diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..28771e1ae591700be3fe27c3acd668ef8cee77ad
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,195 @@
+---
+Language:        Cpp
+# BasedOnStyle:  Google
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: None
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: Left
+AlignOperands:   Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: false
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: true
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     120
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+StatementAttributeLikeMacros:
+  - Q_EMIT
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^<ext/.*\.h>'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IncludeIsMainSourceRegex: ''
+IndentCaseLabels: true
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequires:  false
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Right
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+      - ParseTestProto
+      - ParsePartialTestProto
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+ReflowComments:  false
+SortIncludes:    true
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard:        Auto
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        2
+UseCRLF:         false
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...
+
diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 0000000000000000000000000000000000000000..b41ec6b295a3e650b762617712ebadebe0383cfe
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,31 @@
+Checks: '-*,readability-identifier-naming,readability-function-size,
+         readability-braces-around-statements,readability-magic-numbers,
+         misc-unused-parameters,modernize-use-nullptr,modernize-replace-auto-ptr,
+         modernize-use-noexcept,modernize-use-override,performance-move-const-arg,
+         cppcoreguidelines-pro-type-cstyle-cast,cppcoreguidelines-pro-type-reinterpret-cast,
+         cppcoreguidelines-pro-type-const-cast'
+CheckOptions:
+  - key:             readability-identifier-naming.ClassCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.StructCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.TypedefCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.EnumCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.EnumConstantCase
+    value:           camelBack
+  - key:             readability-identifier-naming.UnionCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.NamespaceCase
+    value:           lower_case
+  - key:             readability-identifier-naming.FunctionCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.VariableCase
+    value:           camelBack
+  - key:             readability-identifier-naming.ConstantCase
+    value:           camelBack
+  - key:             readability-function-size.StatementThreshold
+    value:           50
+  - key:             readability-function-size.ParameterThreshold
+    value:           5
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..dcf0dec08f06bb5391c8935caae1a02ce71b0c3c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,30 @@
+android/*
+third_party/d8*
+third_party/icu*
+third_party/libdex*
+third_party/aosp_10.0.0_r35*
+third_party/aosp_modified*
+third_party/ctorture*
+third_party/llvm_modified*
+third_party/llvm-*
+tools/lib
+tools/bin*
+tools/android*
+tools/aosp*
+tools/clang*
+tools/gcc*
+tools/gn*
+tools/icu*
+tools/libz*
+tools/zlib*
+tools/ninja*
+tools/qemu*
+tools/r8*
+tools/release*
+tools/sysroot-glibc*
+build/logs*
+libjava-core
+output
+compile_commands.json
+testsuite/tools*
+*__pycache__*
diff --git a/.gn b/.gn
new file mode 100644
index 0000000000000000000000000000000000000000..c00e581063d8ce84c72d56d979a105c8d833a701
--- /dev/null
+++ b/.gn
@@ -0,0 +1,15 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+buildconfig = "//build/config/BUILDCONFIG.gn"
diff --git a/BUILD.gn b/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..40e691379fdb548eb9a6292775b15262bfa1c51d
--- /dev/null
+++ b/BUILD.gn
@@ -0,0 +1,68 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+group("maple") {
+  deps = [ "${MAPLEALL_ROOT}:maple" ]
+}
+
+group("irbuild") {
+  deps = [ "${MAPLEALL_ROOT}:irbuild" ]
+}
+
+group("hir2mpl") {
+  deps = [ "${HIR2MPL_ROOT}:hir2mpl" ]
+}
+
+group("hir2mplUT") {
+  deps = [ "${HIR2MPL_ROOT}/test:hir2mplUT" ]
+}
+
+group("maple-rt") {
+  deps = [ "${MAPLE_MRT_ROOT}:maple-rt" ]
+}
+
+group("ast2mpl") {
+  deps = []
+  if (IS_AST2MPL_EXISTS == "1") {
+    deps = [ "${AST2MPL_ROOT}/src:ast2mpl" ]
+  }
+}
+
+group("mapleallUT") {
+  deps = [
+    "${MAPLEALL_ROOT}/test:mapleallUT",
+  ]
+}
+
+group("maplegendef") {
+  exeTool = "-e" + rebase_path("${GN_BINARY_OUTPUT_DIRECTORY}/maplegen", root_build_dir)
+  mdDir = "-m" + rebase_path("${MAPLEALL_ROOT}/maple_be/include/ad/cortex_a55", root_build_dir)
+  outDir = "-o" + rebase_path("${MAPLE_BUILD_OUTPUT}/common/target", root_build_dir)
+  if (ASAN == 1) {
+    exec_script("${MAPLEALL_ROOT}/maple_be/mdgen/gendef.py",
+                [
+                  "-aLD_PRELOAD=${LLVMLIBDIR}/libclang_rt.asan-x86_64.so",
+                  exeTool,
+                  mdDir,
+                  outDir,
+                ])
+ } else {
+   exec_script("${MAPLEALL_ROOT}/maple_be/mdgen/gendef.py",
+               [
+                 exeTool,
+                 mdDir,
+                 outDir
+               ])
+ }
+}
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..f1e5b20f8152395af6c06f294c0275611b1abc89
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,51 @@
+FROM ubuntu:16.04 AS build-env
+MAINTAINER https://www.openarkcompiler.cn
+
+# Setting up the build environment
+RUN sed -i 's/archive.ubuntu.com/mirrors.163.com/g' /etc/apt/sources.list && \
+    dpkg --add-architecture i386 && \
+    apt-get -y update && \
+    apt-get -y dist-upgrade && \
+    apt-get -y install openjdk-8-jdk git-core build-essential zlib1g-dev libc6-dev-i386 g++-multilib gcc-multilib linux-libc-dev:i386 && \
+    apt-get -y install gcc-5-aarch64-linux-gnu g++-5-aarch64-linux-gnu unzip tar curl && \
+    apt-get -y install python3-paramiko python-paramiko python-requests && \
+    mkdir -p /tools/ninja /tools/gn
+
+# 在国内请反注释下行, 因为容器也是个单独的系统，所以别用127.0.0.1
+#ENV http_proxy=http://192.168.3.81:1081 \ 
+#    https_proxy=http://192.168.3.81:1081
+
+RUN cd /tools && \
+    curl -C - -LO http://releases.llvm.org/8.0.0/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz && \
+    curl -LO https://github.com/ninja-build/ninja/releases/download/v1.9.0/ninja-linux.zip && \
+    curl -LO http://tools.harmonyos.com/mirrors/gn/1523/linux/gn.1523.tar && \
+    tar Jvxf /tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz -C /tools/ && \
+    unzip /tools/ninja-linux.zip -d /tools/ninja/ && \
+    tar xvf /tools/gn.1523.tar && \
+    chmod a+x /tools/gn/gn && \
+    rm /tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz /tools/ninja-linux.zip && \
+    rm -rf /var/cache/apt/archives
+
+# copy source
+COPY . /OpenArkCompiler
+WORKDIR /OpenArkCompiler
+
+# create symbolic link
+RUN mkdir -p /OpenArkCompiler/tools /OpenArkCompiler/tools/gn && \
+    ln -s /tools/ninja /OpenArkCompiler/tools/ninja_1.9.0 && \
+    ln -s /tools/gn/gn /OpenArkCompiler/tools/gn/gn && \
+    ln -s /tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04 /OpenArkCompiler/tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04
+
+# compile
+RUN ["/bin/bash", "-c", "source build/envsetup.sh && make && ls -al "]
+
+# build final docker image
+FROM ubuntu:16.04
+RUN sed -i 's/archive.ubuntu.com/mirrors.163.com/g' /etc/apt/sources.list && \
+    apt-get -y update && \
+    apt-get install -y openjdk-8-jdk curl vim && \
+    rm -rf /var/cache/apt/archives
+COPY --from=build-env /OpenArkCompiler/output /OpenArkCompiler
+VOLUME /OpenArkCompiler
+ENV PATH=/OpenArkCompiler/bin:$PATH
+CMD maple -h
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..e3a7e3bc88374fd545074c6ad755af9a98538cf7
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,207 @@
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+# Makefile for OpenArkCompiler
+OPT := O2
+DEBUG := $(MAPLE_DEBUG)
+INSTALL_DIR := $(MAPLE_BUILD_OUTPUT)
+LIB_CORE_PATH := $(MAPLE_BUILD_OUTPUT)/libjava-core/host-x86_64-$(OPT)
+MAPLE_BIN_DIR := $(MAPLE_ROOT)/src/mapleall/bin
+MRT_ROOT := $(MAPLE_ROOT)/src/mrt
+ANDROID_ROOT := $(MAPLE_ROOT)/android
+MAJOR_VERSION := $(MAPLE_MAJOR_VERSION)
+MINOR_VERSION := $(MAPLE_MINOR_VERSION)
+RELEASE_VERSION := $(MAPLE_RELEASE_VERSION)
+BUILD_VERSION := $(MAPLE_BUILD_VERSION)
+GIT_REVISION := $(shell  git log --pretty=format:"%H" -1)
+MAST := 0
+ASAN := 0
+ONLY_C := 0
+COV := 0
+GPROF := 0
+ifeq ($(DEBUG),0)
+  BUILD_TYPE := RELEASE
+else
+  BUILD_TYPE := DEBUG
+endif
+HOST_ARCH := 64
+MIR_JAVA := 1
+GN := $(MAPLE_ROOT)/tools/gn/gn
+NINJA := $(shell ls $(MAPLE_ROOT)/tools/ninja*/ninja | tail -1)
+ifneq ($(findstring GC,$(OPT)),)
+  GCONLY := 1
+else
+  GCONLY := 0
+endif
+
+GN_OPTIONS := \
+  GN_INSTALL_PREFIX="$(MAPLE_ROOT)" \
+  GN_BUILD_TYPE="$(BUILD_TYPE)" \
+  HOST_ARCH=$(HOST_ARCH) \
+  MIR_JAVA=$(MIR_JAVA) \
+  OPT="$(OPT)" \
+  GCONLY=$(GCONLY) \
+  TARGET="$(TARGET_PROCESSOR)" \
+  MAJOR_VERSION="$(MAJOR_VERSION)" \
+  MINOR_VERSION="$(MINOR_VERSION)" \
+  RELEASE_VERSION="$(RELEASE_VERSION)" \
+  BUILD_VERSION="$(BUILD_VERSION)" \
+  GIT_REVISION="$(GIT_REVISION)" \
+  MAST=$(MAST) \
+  ASAN=$(ASAN) \
+  ONLY_C=$(ONLY_C) \
+  COV=$(COV) \
+  GPROF=$(GPROF)
+
+.PHONY: default
+default: install
+
+.PHONY: directory
+directory:
+	$(shell mkdir -p $(INSTALL_DIR)/bin;)
+
+.PHONY: install_patch
+install_patch:
+	@bash build/third_party/patch.sh patch
+
+.PHONY: uninstall_patch
+uninstall_patch:
+	@bash build/third_party/patch.sh unpatch
+
+.PHONY: maplegen
+maplegen:install_patch
+	$(call build_gn, $(GN_OPTIONS), maplegen)
+
+.PHONY: maplegendef
+maplegendef: maplegen
+	$(call build_gn, $(GN_OPTIONS), maplegendef)
+
+.PHONY: maple
+maple: maplegendef
+	$(call build_gn, $(GN_OPTIONS), maple)
+
+.PHONY: irbuild
+irbuild: install_patch
+	$(call build_gn, $(GN_OPTIONS), irbuild)
+
+.PHONY: mpldbg
+mpldbg:
+	$(call build_gn, $(GN_OPTIONS), mpldbg)
+
+.PHONY: ast2mpl
+ast2mpl:
+	$(call build_gn, $(GN_OPTIONS), ast2mpl)
+
+.PHONY: hir2mpl
+hir2mpl: install_patch
+	$(call build_gn, $(GN_OPTIONS), hir2mpl)
+
+.PHONY: clang2mpl
+clang2mpl: maple
+	(cd tools/clang2mpl; make setup; make; make install)
+
+.PHONY: hir2mplUT
+hir2mplUT:
+	$(call build_gn, $(GN_OPTIONS) COV_CHECK=1, hir2mplUT)
+
+.PHONY: libcore
+libcore: maple-rt
+	cd $(LIB_CORE_PATH); \
+	$(MAKE) install OPT=$(OPT) DEBUG=$(DEBUG)
+
+.PHONY: maple-rt
+maple-rt: java-core-def
+	$(call build_gn, $(GN_OPTIONS), maple-rt)
+
+.PHONY: mapleallUT
+mapleallUT: install_patch
+	$(call build_gn, $(GN_OPTIONS), mapleallUT)
+
+.PHONY: java-core-def
+java-core-def: install
+	mkdir -p $(LIB_CORE_PATH); \
+	cp -rp $(MAPLE_ROOT)/libjava-core/* $(LIB_CORE_PATH)/; \
+	cd $(LIB_CORE_PATH); \
+	ln -f -s $(MAPLE_ROOT)/build/core/libcore.mk ./makefile; \
+	$(MAKE) gen-def OPT=$(OPT) DEBUG=$(DEBUG)
+
+.PHONY: install
+install: maple dex2mpl_install irbuild hir2mpl
+	$(shell mkdir -p $(INSTALL_DIR)/ops/linker/; \
+	rsync -a -L $(MRT_ROOT)/maplert/linker/maplelld.so.lds $(INSTALL_DIR)/ops/linker/; \
+	rsync -a -L $(MAPLE_ROOT)/build/java2d8 $(INSTALL_DIR)/bin; \
+	rsync -a -L $(MAPLE_BIN_DIR)/java2jar $(INSTALL_DIR)/bin/; \
+	cp -rf $(MAPLE_ROOT)/tools $(INSTALL_DIR)/../; \
+	rsync -a -L $(MAPLE_ROOT)/src/hir2mpl/ast_input/clang/lib/sys/ $(INSTALL_DIR)/lib/include/;)
+
+.PHONY: all
+all: install libcore
+
+.PHONY: dex2mpl_install
+dex2mpl_install: directory
+	$(shell rsync -a -L $(MAPLE_BIN_DIR)/dex2mpl $(INSTALL_DIR)/bin/;)
+
+.PHONY: setup
+setup:
+	(cd tools; ./setup_tools.sh)
+
+.PHONY: demo
+demo:
+	test/maple_aarch64_with_hir2mpl.sh test/c_demo printHuawei 1 1
+	test/maple_aarch64_with_clang2mpl.sh test/c_demo printHuawei 1 1
+
+.PHONY: ctorture-ci
+ctorture-ci:
+	(cd third_party/ctorture; git checkout .; git pull; ./ci.sh)
+
+.PHONY: ctorture
+ctorture:
+	(cd third_party/ctorture; git checkout .; git pull; ./run.sh work.list)
+
+.PHONY: ctorture2
+ctorture2:
+	(cd third_party/ctorture; git checkout .; git pull; ./run.sh work.list hir2mpl)
+
+THREADS := 50
+ifneq ($(findstring test,$(MAKECMDGOALS)),)
+TESTTARGET := $(MAKECMDGOALS)
+ifdef TARGET
+REALTARGET := $(TARGET)
+else
+REALTARGET := $(TESTTARGET)
+endif
+.PHONY: $(TESTTARGET)
+${TESTTARGET}:
+	@python3 $(MAPLE_ROOT)/testsuite/driver/src/driver.py --target=$(REALTARGET) --run-path=$(MAPLE_ROOT)/output/$(MAPLE_BUILD_TYPE)/testsuite $(if $(MOD), --mod=$(MOD),) --j=$(THREADS)
+endif
+
+.PHONY: cleanrsd
+cleanrsd:uninstall_patch
+	@rm -rf libjava-core/libcore-all.* libjava-core/m* libjava-core/comb.*
+
+.PHONY: clean
+clean: cleanrsd
+	@rm -rf $(MAPLE_BUILD_OUTPUT)/
+	@rm -rf $(MAPLE_ROOT)/report.txt
+
+.PHONY: clobber
+clobber: cleanrsd
+	@rm -rf output
+
+define build_gn
+    mkdir -p $(INSTALL_DIR); \
+    $(GN) gen $(INSTALL_DIR) --args='$(1)' --export-compile-commands; \
+    cd $(INSTALL_DIR); \
+    $(NINJA) -v $(2);
+endef
diff --git a/Readme.md b/Readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..870f27a720326ec28ca5afd48ac9a87b4d16265f
--- /dev/null
+++ b/Readme.md
@@ -0,0 +1,82 @@
+# OpenArkCompiler
+
+## Overview
+-----------------
+> Unified programming platform supporting multiple devices and languages
+
+OpenArkCompiler is Huawei's open source project.
+
+### Four Technical Features of OpenArkCompiler ###
+
+Compiles code of different languages into a set of executable files and efficiently executes the files in the running environment.
+- Supports joint optimization of multiple languages and eliminates cross-language calling overhead.
+- Achieves lightweight language runtime.
+- Collaborates hardware and software to maximize hardware energy efficiency.
+- Supports diversified terminal platforms.
+
+## Open Source Plan
+**Open source compiler framework code**
+- Time: August, 2019
+- Scope: Compiler IR and middle-end language implementation
+- Benefits:
+   - Provides an open source framework for understanding the architecture and framework code of OpenArkCompiler.
+   - Allows developers to build a complete compiler toolchain that supports the compilation of Java samples (non-application).
+
+**Subsequent open source scope**
+Open the front end, back end, and compilation optimization of compilers. Support the full compilation of Java programs and JavaScript applications.
+
+|Open Source Scope|March 2020 |May 2020 |
+| ------------ | -------------------|--------------------- |
+|Front end| Jbc front-end basic framework | Front-end full open source |
+|Middle end |Weekly open source optimization phase |       |
+|Back end |Backend open source (O0) (aarch64)|Weekly open source optimization (O2) (aarch64)|
+|Test framework|Test framework and basic Cases|     |
+
+**Updating...**
+
+## How to use
+- source build/envsetup.sh arm release
+  or
+- source build/envsetup.sh arm debug
+- make setup (In this step, you may need to configure the proxy or VPN to download all dependencies.)
+- make
+- make libcore
+- make testall
+
+C example:
+- make demo
+
+## OpenArkCompiler Incubator
+- FutureWei Mapleall https://gitee.com/openarkcompiler-incubator/mapleall
+- Maple Engine https://gitee.com/openarkcompiler-incubator/maple_engine
+- Maple FrondEnd https://gitee.com/openarkcompiler-incubator/MapleFE
+- Maple clang2mpl https://gitee.com/openarkcompiler-incubator/clang2mpl
+
+## Related Documents
+
+- Architecture Design Principles
+   - [MAPLE IR Design](doc/en/MapleIRDesign.md)
+   - [RC API](doc/en/RcApi.md)
+   - [Naive RC Insertion Principle](doc/en/NaiveRcInsertionDescription.md)
+   - [Virtual Table and Interface Table Design](doc/en/VtableItableDescription.md)
+   - [Phase Design](doc/en/CompilerPhaseDescription.md)
+   - [Application Manual of Maple General Modules](doc/en/DeveloperGuide4Utility.md)
+
+
+- [Environment Configuration](doc/en/DevelopmentPreparation.md)
+
+- [Developer Guide](doc/en/DeveloperGuide.md)
+
+- [Programming Specifications](doc/en/ProgrammingSpecifications.md)
+
+- [Discussion of Pointer in C++ Programming](doc/en/CPPCodingTalkAboutPointer.md)
+
+## License
+- [LICENSE](license/LICENSE)
+
+## Real-time Chat Channel
+- [Discord-OpenArkCompiler](https://discord.gg/CJeJWQXxMP)
+- 9:00 am - 10:30 am everyday, developers can discuss community issues in the voice channel "panel discussion"
+
+- [Discord-MapleFE](https://discord.gg/sBj3cc4GhM)
+- we have weekly meeting about projects related to MapleFE
diff --git a/Readme_zh.md b/Readme_zh.md
new file mode 100644
index 0000000000000000000000000000000000000000..a2aab5783752ad526e2a212a7374fd72ca03abbd
--- /dev/null
+++ b/Readme_zh.md
@@ -0,0 +1,76 @@
+# OpenArkCompiler
+
+## 概述
+-----------------
+> 面向多设备、支持多语言的统一编程平台。
+
+OpenArkCompiler是来自华为方舟编译器的开源项目。
+
+### OpenArkCompiler 四个技术特点 ###
+
+能够将不同语言代码编译成一套可执行文件，在运行环境中高效执行：
+- 支持多语言联合优化、消除跨语言调用开销；
+- 更轻量的语言运行时；
+- 软硬协同充分发挥硬件能效；
+- 支持多样化的终端设备平台
+
+## 开源计划
+**编译器框架代码开源**
+- 时间：2019年8月
+- 开源范围：编译器IR+中端语言实现
+- 开放能力：
+   - 框架开源供参考学习，了解方舟编译器架构及框架代码
+   - 开发者可构建出完整编译器工具链，支持Java Sample程序编译（非应用）
+
+**后续开源范围**
+陆续开源编译器前端、后端、编译优化；完整支持Java程序编译、JavaScript语言应用的编译等。
+
+|开源范围          |2020年3月       |2020年5月             |
+| ------------ | -------------------|--------------------- |
+|编译器前端    |jbc前端基础框架     |前端全量开源          |
+|编译器中端    |独立优化Phase每周持续开源                  ||
+|编译器后端    |后端开源(O0) (aarch64)|独立优化按周开源(O2) (aarch64)|
+|测试框架      |测试框架+基础用例开源| |
+
+**计划持续更新...**
+
+## 如何使用
+- source build/envsetup.sh arm release
+  或
+- source build/envsetup.sh arm debug
+- make setup (这一步可能需要配置代理或者vpn，才能将所有依赖下载下来)
+- make
+- make libcore
+- make testall
+
+## 孵化器项目
+- FutureWei编译器分支 https://gitee.com/openarkcompiler-incubator/mapleall
+- Maple Engine https://gitee.com/openarkcompiler-incubator/maple_engine
+
+## 相关文档
+
+- 架构设计原理
+   - [MAPLE IR Design](doc/en/MapleIRDesign.md)
+   - [RC API](doc/cn/RcApi.md)
+   - [Naive RC操作插入原理](doc/cn/NaiveRcInsertionDescription.md)
+   - [虚函数表和接口函数表设计介绍](doc/cn/VtableItableDescription.md)
+   - [Phase设计介绍](doc/cn/CompilerPhaseDescription.md)
+   - [Maple通用模块应用手册](doc/cn/DeveloperGuide4Utility.md)
+
+- [环境配置](doc/cn/DevelopmentPreparation.md)
+
+- [开发者指南](doc/cn/DeveloperGuide.md)
+
+- [编程规范](doc/cn/ProgrammingSpecifications.md)
+
+- [C++编程探讨之指针](doc/cn/CPPCodingTalkAboutPointer.md)
+
+## 许可证
+- [LICENSE](license/LICENSE)
+
+## 开发者交流频道
+- [Discord-OpenArkCompiler](https://discord.gg/CJeJWQXxMP)
+- 每天上午9:00~10:30不定时在语音频道“panel disscussion”交流社区议题。
+
+## 如何提交代码
+- [wiki](https://gitee.com/openarkcompiler/OpenArkCompiler/wikis/%E4%BB%A3%E7%A0%81%E6%8F%90%E4%BA%A4%E6%B5%81%E7%A8%8B?sort_id=2447213)
diff --git a/Release.md b/Release.md
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/MapleFE/recdetect/build.sh b/build/build.sh
similarity index 36%
rename from src/MapleFE/recdetect/build.sh
rename to build/build.sh
index aa92897ffaa1b044f1d04b1656f09453074e554e..c88052b81a918ee150c5fe13d447f6d9964b1553 100755
--- a/src/MapleFE/recdetect/build.sh
+++ b/build/build.sh
@@ -1,39 +1,30 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
-# 
-# OpenArkFE is licensed under the Mulan PSL v2.
+#!/bin/bash
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
 # You can use this software according to the terms and conditions of the Mulan PSL v2.
 # You may obtain a copy of Mulan PSL v2 at:
-# 
-#  http://license.coscl.org.cn/MulanPSL2
-# 
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
 # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
 # FIT FOR A PARTICULAR PURPOSE.
 # See the Mulan PSL v2 for more details.
-# 
-
-#!/bin/bash
-
-# Usage:
-#  ./build.sh [LANG]
 #
-# eg. ./build.sh java
-
-rm -rf $BUILDDIR/recdetect
-rm -rf $BUILDDIR/recdetect/$1
-
-rm -rf $1
-mkdir -p $1
-
-cp ../$1/include/gen_*.h $1/
-cp ../$1/src/gen_*.cpp $1/
-
-# The four generated files shouldn't be taken in.
-rm -f $1/gen_recursion.h
-rm -f $1/gen_recursion.cpp
-rm -f $1/gen_lookahead.h
-rm -f $1/gen_lookahead.cpp
-
-mkdir -p $BUILDDIR/recdetect
-mkdir -p $BUILDDIR/recdetect/$1
-make LANG=$1
+set -e
+source build/envsetup.sh arm release
+make clean
+option=$@
+model=$1
+if [ -z "$model" ];then
+  model="libcore"
+fi
+logfile_name=$(date +"%Y-%m-%d-%H-%M-%S")
+logfile_path=${MAPLE_ROOT}/build/logs
+date_str=$(date "+%Y-%m-%d %H:%M:%S")
+echo "${date_str} $model INFO special log start" | tee ${logfile_path}/${logfile_name}.log
+make ${option} | tee -a ${logfile_path}/${logfile_name}.log
+date_str=$(date "+%Y-%m-%d %H:%M:%S")
+echo "${date_str} $model INFO special log end" | tee -a ${logfile_path}/${logfile_name}.log
diff --git a/build/config.gni b/build/config.gni
new file mode 100644
index 0000000000000000000000000000000000000000..5db3bf2ce137c9fb04aad98a231669bab0537452
--- /dev/null
+++ b/build/config.gni
@@ -0,0 +1,42 @@
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+# Toolchain setup
+
+CLANG_PATH = "${MAPLE_ROOT}/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04"
+
+LLVMINC = "${CLANG_PATH}/include"
+LLVMLIBDIR = "${CLANG_PATH}/lib"
+CFE_SRC_DIR = "${MAPLE_ROOT}/../third-party/clang-10.0.0.src"
+CFE_SRC_PATH = "${MAPLE_ROOT}/third_party/llvm-12.0.0.src/clang"
+
+# MapleFE path
+MAPLE_PARSER_PATH = ""
+
+GCC_LINARO_PATH = "${MAPLE_ROOT}/tools/gcc-linaro-7.5.0"
+NDK_PATH = "${MAPLE_ROOT}/tools/android-ndk-r21"
+
+GN_C_COMPILER = "${TOOL_BIN_PATH}/clang"
+GN_CXX_COMPILER = "${TOOL_BIN_PATH}/clang++"
+GN_AR_COMPILER = "${TOOL_BIN_PATH}/llvm-ar"
+GN_RANLIB_COMPILER = "${TOOL_BIN_PATH}/llvm-ranlib"
+
+target_toolchain = "//build/toolchain:clang"
+set_default_toolchain(target_toolchain)
+
+# Cross compile
+GN_C_CROSS_COMPILER = "${GCC_LINARO_PATH}/bin/aarch64-linux-gnu-gcc"
+GN_CXX_CROSS_COMPILER = "${GCC_LINARO_PATH}/bin/aarch64-linux-gnu-g++"
+GN_AR_CROSS_COMPILER = "${GCC_LINARO_PATH}/bin/aarch64-linux-gnu-ar"
+GN_RANLIB_CROSS_COMPILER = "${GCC_LINARO_PATH}/bin/aarch64-linux-gnu-ranlib"
diff --git a/build/config/BUILDCONFIG.gn b/build/config/BUILDCONFIG.gn
new file mode 100755
index 0000000000000000000000000000000000000000..675724a3a732318314e6e0bdd3c8b57f62eeee75
--- /dev/null
+++ b/build/config/BUILDCONFIG.gn
@@ -0,0 +1,188 @@
+# This file is the master GN build configuration, all variables
+# declare here will be implicitly global.
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+# List all the input args
+declare_args() {
+  GN_INSTALL_PREFIX = ""
+  GN_BUILD_TYPE = ""
+  HOST_ARCH = 64
+  MIR_JAVA = 1
+  COV_CHECK = 0
+  GCONLY = 0
+  OPT = "O2"
+  TARGET = ""
+  MAJOR_VERSION = ""
+  MINOR_VERSION = ""
+  RELEASE_VERSION = ""
+  BUILD_VERSION = ""
+  GIT_REVISION = ""
+  MAST = 0
+  ASAN = 0
+  ONLY_C = 0
+  COV = 0
+  GPROF = 0
+}
+
+# Define global args
+MAPLE_ROOT = getenv("MAPLE_ROOT")
+ANDROID_ROOT = "${MAPLE_ROOT}/android"
+AOSP_ROOT = "${MAPLE_ROOT}/third_party/aosp_modified"
+MAPLE_BUILD_TYPE = getenv("MAPLE_BUILD_TYPE")
+MAPLE_BUILD_OUTPUT = getenv("MAPLE_BUILD_OUTPUT")
+TOOL_BIN_PATH = getenv("TOOL_BIN_PATH")
+QEMU_PATH = getenv("TOOL_BIN_PATH")
+OLD_OS = getenv("OLD_OS")
+if (OLD_OS == "1") {
+  DESIGNATOR="-Wno-gnu-designator"
+} else {
+  DESIGNATOR="-Wno-c99-designator"
+}
+
+DYNAMICLANG = true
+RC_V2 = true
+TEST_BENCHMARK = false
+MEMORY_LEAK_CHECK = false
+MARK_CYCLE_ROOTS = false
+
+OPENSOURCE_DEPS = "${MAPLE_ROOT}/src/mapleall/deplibs"
+OPENSOURCE_OUTPUT = "${MAPLE_BUILD_OUTPUT}"
+AST2MPL_ROOT = "${MAPLE_ROOT}/src/ast2mpl"
+IS_AST2MPL_EXISTS = getenv("IS_AST2MPL_EXISTS")
+MAPLEALL_ROOT = "${MAPLE_ROOT}/src"
+MAPLEALL_ROOT = "${MAPLE_ROOT}/src/mapleall"
+HIR2MPL_ROOT = "${MAPLE_ROOT}/src/hir2mpl"
+MAPLE_MRT_ROOT = "${MAPLE_ROOT}/src/mrt"
+THIRD_PARTY_ROOT = "${MAPLE_ROOT}/third_party"
+
+# Put all built library files under lib
+GN_ARCHIVE_OUTPUT_DIRECTORY = "${MAPLE_BUILD_OUTPUT}/ar/host-x86_64-${OPT}"
+GN_LIBRARY_OUTPUT_DIRECTORY = "${MAPLE_BUILD_OUTPUT}/lib"
+
+# Put all built binary files under bin
+GN_BINARY_OUTPUT_DIRECTORY = "${MAPLE_BUILD_OUTPUT}/bin"
+
+import("${MAPLE_ROOT}/build/config.gni")
+
+# C/CXX Build flags
+cflags = []
+cflags_cc = []
+cflags_c = []
+if (GN_BUILD_TYPE == "RELEASE") {
+  cflags_cc += [
+    "-O2",
+    "-fno-strict-aliasing",
+    "-fvisibility=hidden",
+    "-D_FORTIFY_SOURCE=2",
+  ]
+  cflags_c += [
+    "-O2",
+    "-fno-strict-aliasing",
+    "-fvisibility=hidden",
+    "-D_FORTIFY_SOURCE=2",
+  ]
+} else if (GN_BUILD_TYPE == "DEBUG") {
+  cflags_cc += [
+    "-O0",
+    "-g3",
+    "-ftrapv",
+    "-fstack-check",
+  ]
+  cflags_c += [
+    "-O0",
+    "-g3",
+    "-ftrapv",
+    "-fstack-check",
+  ]
+  if (target_toolchain == "//build/toolchain:clang") {
+    cflags_c += ["-fno-limit-debug-info"]
+    cflags_cc += ["-fno-limit-debug-info"]
+  }
+} else {
+  cflags_cc += [
+    "-O2",
+    "-fno-strict-aliasing",
+    "-g",
+  ]
+  cflags_c += [
+    "-O2",
+    "-fno-strict-aliasing",
+    "-g",
+  ]
+}
+
+cflags_c += [
+  "-Wall",
+  "-fstack-protector-strong",
+  "-fPIC",
+  "-fPIE",
+  "-pipe",
+  "-Werror",
+  "-Wdate-time",
+  "-Wfloat-equal",
+  "${DESIGNATOR}",
+]
+
+cflags_cc += [
+  "-Wall",
+  "-fstack-protector-strong",
+  "-fPIC",
+  "-fPIE",
+  "-pipe",
+  "-Wno-c99-designator",
+  "-Wno-range-loop-construct",
+  "-Werror",
+  "-Wdate-time",
+  "-Wfloat-equal",
+  "${DESIGNATOR}",
+]
+
+if (HOST_ARCH == 64) {
+  cflags_c += [ "-m64" ]
+  cflags_cc += [ "-m64" ]
+} else {
+  cflags_c += [ "-m32" ]
+  cflags_cc += [ "-m32" ]
+}
+
+if (DYNAMICLANG) {
+  cflags_cc += [ "-DDYNAMICLANG" ]
+}
+
+if (RC_V2) {
+  cflags_cc += [ "-DRC_NO_MMAP" ]
+}
+
+if (TEST_BENCHMARK) {
+  cflags_cc += [ "-DTEST_BENCHMARK" ]
+}
+
+if (MEMORY_LEAK_CHECK) {
+  cflags_cc += [ "-DMEMORY_LEAK_CHECK" ]
+}
+
+if (MARK_CYCLE_ROOTS) {
+  cflags_cc += [ "-DMARK_CYCLE_ROOTS" ]
+}
+
+cflags_cc += [ "-DMIR_FEATURE_FULL=1" ]
+
+if (MIR_JAVA == 1) {
+  cflags_cc += [ "-DMIR_JAVA=1" ]
+} else {
+  TARGET = "vm"
+  cflags_cc += [ "-DMIR_JAVA=0" ]
+}
diff --git a/build/core/extra.mk b/build/core/extra.mk
new file mode 100644
index 0000000000000000000000000000000000000000..2c8551bb9d37ec6804fdd10fc93fe96041a5a890
--- /dev/null
+++ b/build/core/extra.mk
@@ -0,0 +1,24 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+$(INIT_CXX_SRC): $(ADD_OBJS)
+	cp -f $< $@
+
+ifeq ($(DEBUG), 0)
+$(INIT_CXX_O) : $(INIT_CXX_SRC)
+	$(QEMU_CLANG_CPP) -O2 $(QEMU_CLANG_FLAGS) -c $^ -o $@
+else
+$(INIT_CXX_O) : $(INIT_CXX_SRC)
+	$(QEMU_CLANG_CPP) -O0 -g3 $(QEMU_CLANG_FLAGS) -c $^ -o $@
+endif
diff --git a/build/core/genmplt.mk b/build/core/genmplt.mk
new file mode 100644
index 0000000000000000000000000000000000000000..89ffab5337c56eaa0627544a447f829ad793a60a
--- /dev/null
+++ b/build/core/genmplt.mk
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+$(LIB_CORE_MPLT): $(JBC2MPL_BIN) $(LIB_CORE_JAR)
+	$(JBC2MPL_BIN) -injar $(LIB_CORE_JAR) -output $(LIB_CORE_PATH)
diff --git a/build/core/hir2mpl.mk b/build/core/hir2mpl.mk
new file mode 100644
index 0000000000000000000000000000000000000000..e45502f68de5ae349e36d54b7787e27b6bca2506
--- /dev/null
+++ b/build/core/hir2mpl.mk
@@ -0,0 +1,17 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+$(APP_MPL): %.mpl : %.dex $(HIR2MPL_BIN)
+	$(HIR2MPL_BIN) $(HIR2MPL_FLAGS) $<
+
diff --git a/build/core/hir2mpl_test.mk b/build/core/hir2mpl_test.mk
new file mode 100644
index 0000000000000000000000000000000000000000..de06e1b828e6ae748cf2d42be13b2c225249d0ef
--- /dev/null
+++ b/build/core/hir2mpl_test.mk
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+$(APP_MPL): %.mpl : %.dex $(HIR2MPL_BIN)
+	$(HIR2MPL_BIN) $(HIR2MPL_APP_FLAGS) $<
diff --git a/build/core/java2dex.mk b/build/core/java2dex.mk
new file mode 100644
index 0000000000000000000000000000000000000000..20dbe3122425e58a963a168f1e291e4706e23696
--- /dev/null
+++ b/build/core/java2dex.mk
@@ -0,0 +1,2 @@
+$(APP_DEX): %.dex : %.java $(wildcard $(JAR_LIBS_PATH)/*.java)
+	@bash $(JAVA2DEX) -o $(APP_DEX) $(JAVA2DEX_FLAGS) -i $(APP_JAVA):${EXTRA_JAVA_FILE} $<
diff --git a/build/core/libcore.mk b/build/core/libcore.mk
new file mode 100644
index 0000000000000000000000000000000000000000..84354068e26247d7c3f09e1fb1f75bad5313cd29
--- /dev/null
+++ b/build/core/libcore.mk
@@ -0,0 +1,88 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+APP := libcore-all
+include $(MAPLE_BUILD_CORE)/maple_variables.mk
+ifeq ($(DEBUG), 1)
+  MPLCG_FLAGS := $(MPLCG_FLAGS) --add-debug-trace
+endif
+include $(MAPLE_BUILD_CORE)/qemu_ar.mk
+
+ifeq ($(DEBUG), 0)
+  QEMU_CXX_FLAGS := -O2 -s
+else
+  QEMU_CXX_FLAGS := -O0 -g3
+endif
+
+ifeq ($(DISABLE_RC_DUPLICATE), 1)
+  RC_FLAGS = -DDISABLE_RC_DUPLICATE=1
+else
+  RC_FLAGS = -DDISABLE_RC_DUPLICATE=0
+endif
+
+LINKER_QEMU_OPT := -fuse-ld=lld -rdynamic -Wl,-Bsymbolic -lpthread -ldl -L$(MAPLE_OUT)/lib/ -L$(MAPLE_ROOT)/third_party/icu/lib/aarch64-linux-gnu -licuuc
+
+$(APP_O): %.VtableImpl.o : %.VtableImpl.s
+	$(QEMU_CLANG_CPP) $(QEMU_CXX_FLAGS) $(QEMU_CLANG_FLAGS) $(RC_FLAGS) -c -o $@ $<
+
+$(APP_QEMU_SO): %.VtableImpl.qemu.so : %.VtableImpl.o $(INIT_CXX_O) $(qemu)
+	$(QEMU_CLANG_CPP) $(QEMU_CXX_FLAGS) $(QEMU_CLANG_FLAGS) $(RC_FLAGS) -shared -o $@ $(INIT_CXX_O) -Wl,--whole-archive $(qemu) -Wl,--no-whole-archive $(LINKER_QEMU_OPT) $< -Wl,-T $(LDS)
+
+include $(MAPLE_BUILD_CORE)/extra.mk
+include $(MAPLE_BUILD_CORE)/mplcomb_dex.mk
+include $(MAPLE_BUILD_CORE)/hir2mpl.mk
+
+$(APP_DEX): %.dex : $(D8) $(LIB_CORE_JAR)
+	$(D8) --min-api 39 --output . $(LIB_CORE_JAR)
+	mv classes.dex $(APP_DEX)
+
+.PHONY: gen-def
+gen-def: $(APP_DEF)
+$(APP_DEF): $(APP_S)
+	rsync -a -L $(APP_DEF) $(MAPLE_ROOT)/src/mrt/unified.macros.def
+
+.PHONY: install
+install: libcore_so deplibs
+	$(shell mkdir -p $(MAPLE_OUT)/ops/host-x86_64-$(OPT); \
+	mkdir -p $(MAPLE_OUT)/ops/third_party; \
+	rsync -a -L ${MAPLE_ROOT}/src/mrt/codetricks ${MAPLE_ROOT}/output/tools/; \
+	rsync -a -L $(MAPLE_OUT)/lib/$(OPT)/libcore-all.so $(MAPLE_OUT)/ops/host-x86_64-$(OPT); \
+	rsync -a -L $(LIB_CORE_PATH)/mrt_module_init.o $(MAPLE_OUT)/ops/; \
+	rsync -a -L $(LIB_CORE_PATH)/libcore-all.mplt $(MAPLE_OUT)/ops/; \
+	rsync -a -L $(MAPLE_ROOT)/third_party/aosp_10.0.0_r35/libnativehelper $(MAPLE_OUT)/ops/; \
+	rsync -a -L $(MAPLE_ROOT)/android/out/target/common/obj/JAVA_LIBRARIES $(MAPLE_OUT)/ops/third_party; \
+	rsync -a -L $(MAPLE_ROOT)/third_party/libdex/prebuilts/aarch64-linux-gnu/libz.so.1.2.8 $(MAPLE_OUT)/ops/third_party/libz.so.1; \
+	rsync -a -L $(MAPLE_ROOT)/third_party/icu/lib/aarch64-linux-gnu/* $(MAPLE_OUT)/ops/third_party/; \
+	)
+
+.PHONY: deplibs
+deplibs:
+	$(shell	rsync -a -L $(MAPLE_ROOT)/src/mrt/deplibs/*.so $(MAPLE_OUT)/ops/host-x86_64-$(OPT); \
+	rsync -a -L $(MAPLE_ROOT)/src/mrt/bin/mplsh $(MAPLE_OUT)/ops/;)
+
+.PHONY: libcore_so
+libcore_so: $(LIBCORE_SO_QEMU)
+$(LIBCORE_SO_QEMU): $(APP_QEMU_SO)
+	mkdir -p $(MAPLE_OUT)/lib/$(OPT)/
+	rsync -a -L $< $@
+clean:
+	@rm -f libcore-all.*
+	@rm -f *.mpl
+	@rm -f *.mplt
+	@rm -f *.groots.txt
+	@rm -f *.primordials.txt
+	@rm -rf comb.log
+	@rm -rf *.muid
+	@rm -f *.s
+	@rm -rf *.o
diff --git a/build/core/link.mk b/build/core/link.mk
new file mode 100644
index 0000000000000000000000000000000000000000..785af47bc93f0bcfd850de57c2b1bd888ac09b68
--- /dev/null
+++ b/build/core/link.mk
@@ -0,0 +1,2 @@
+${APP_SO}: %.so : %.VtableImpl.s $(CLANG_BIN)
+	${TOOL_BIN_PATH}/clang++ -g3 -O2 -x assembler-with-cpp -march=armv8-a -target aarch64-linux-gnu -c $(APP_S) && ${TOOL_BIN_PATH}/clang++ $(APP_O) -L${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/host-x86_64-O2 -g3 -O2 -march=armv8-a -target aarch64-linux-gnu -fPIC -shared -o $(APP_SO) ${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/mrt_module_init.o -fuse-ld=lld -rdynamic -lcore-all -lcommon-bridge -Wl,-z,notext -Wl,-T${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/linker/maplelld.so.lds
diff --git a/build/core/maple_test.mk b/build/core/maple_test.mk
new file mode 100644
index 0000000000000000000000000000000000000000..0e148680c16512659331a93f30851a6af97405c7
--- /dev/null
+++ b/build/core/maple_test.mk
@@ -0,0 +1,39 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+include $(MAPLE_BUILD_CORE)/maple_variables.mk
+
+test: APP_RUN
+include $(MAPLE_BUILD_CORE)/qemu_run.mk
+include $(MAPLE_BUILD_CORE)/link.mk	
+include $(MAPLE_BUILD_CORE)/mplcomb_dex.mk
+include $(MAPLE_BUILD_CORE)/genmplt.mk
+include $(MAPLE_BUILD_CORE)/hir2mpl_test.mk
+include $(MAPLE_BUILD_CORE)/java2dex.mk
+
+.PHONY: clean
+clean:
+	@rm -rf *.jar
+	@rm -f *.class
+	@rm -f *.mpl
+	@rm -f *.mplt
+	@rm -f *.s
+	@rm -f *.groots.txt
+	@rm -f *.primordials.txt
+	@rm -rf comb.log
+	@rm -rf *.muid
+	@rm -rf *.dex
+	@rm -rf *.def
+	@rm -rf *.so
+	@rm -rf *.o
diff --git a/build/core/maple_variables.mk b/build/core/maple_variables.mk
new file mode 100644
index 0000000000000000000000000000000000000000..87c8372d90c848b67f1bca0dfd5149fa7727aab2
--- /dev/null
+++ b/build/core/maple_variables.mk
@@ -0,0 +1,98 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+OPT := O2
+DEBUG := 0
+LIB_CORE_PATH := $(MAPLE_BUILD_OUTPUT)/libjava-core/host-x86_64-$(OPT)
+LIB_CORE_JAR := $(LIB_CORE_PATH)/java-core.jar
+LIB_CORE_MPLT := $(LIB_CORE_PATH)/java-core.mplt
+
+GCC_LINARO_PATH := $(MAPLE_ROOT)/tools/gcc-linaro-7.5.0
+
+TARGETS := $(APP)
+APP_JAVA := $(foreach APP, $(TARGETS), $(APP).java)
+APP_DEX := $(foreach APP, $(TARGETS), $(APP).dex)
+APP_CLASS := $(foreach APP, $(TARGETS), $(APP).class)
+APP_JAR := $(foreach APP, $(TARGETS), $(APP).jar)
+APP_MPL := $(foreach APP, $(TARGETS), $(APP).mpl)
+APP_MPLT:=$(foreach APP, $(TARGETS), $(APP).mplt)
+APP_S := $(foreach APP, $(TARGETS), $(APP).VtableImpl.s)
+APP_DEF := $(foreach APP, $(TARGETS), $(APP).VtableImpl.macros.def)
+APP_O := $(foreach APP, $(TARGETS), $(APP).VtableImpl.o)
+APP_SO := $(foreach APP, $(TARGETS), $(APP).so)
+APP_QEMU_SO := $(foreach APP, $(TARGETS), $(APP).VtableImpl.qemu.so)
+APP_VTABLEIMPL_MPL := $(foreach APP, $(TARGETS), $(APP).VtableImpl.mpl)
+
+MAPLE_OUT := $(MAPLE_BUILD_OUTPUT)
+JAVA2JAR := $(MAPLE_OUT)/bin/java2jar
+JBC2MPL_BIN := $(MAPLE_OUT)/bin/jbc2mpl
+MAPLE_BIN := $(MAPLE_OUT)/bin/maple
+MPLCG_BIN := $(MAPLE_OUT)/bin/mplcg
+JAVA2D8 := $(MAPLE_OUT)/bin/java2d8
+HIR2MPL_BIN := $(MAPLE_OUT)/bin/hir2mpl
+JAVA2DEX := ${MAPLE_ROOT}/build/java2dex
+
+D8 := $(MAPLE_ROOT)/build/d8
+ADD_OBJS := $(MAPLE_ROOT)/src/mrt/maplert/src/mrt_module_init.c__
+INIT_CXX_SRC := $(LIB_CORE_PATH)/mrt_module_init.cpp
+INIT_CXX_O := $(LIB_CORE_PATH)/mrt_module_init.o
+
+LDS := $(MAPLE_ROOT)/src/mrt/maplert/linker/maplelld.so.lds
+DUPLICATE_DIR := $(MAPLE_ROOT)/src/mrt/codetricks/arch/arm64
+
+QEMU_CLANG_CPP := $(TOOL_BIN_PATH)/clang++
+
+QEMU_CLANG_FLAGS := -Wall -W -Werror -Wno-unused-command-line-argument -Wl,-z,now -fPIC -fstack-protector-strong \
+    -fvisibility=hidden -std=c++14 -march=armv8-a
+
+QEMU_CLANG_FLAGS += -nostdlibinc \
+  --gcc-toolchain=$(GCC_LINARO_PATH) \
+  --sysroot=$(GCC_LINARO_PATH)/aarch64-linux-gnu/libc \
+  -isystem $(GCC_LINARO_PATH)/aarch64-linux-gnu/include/c++/7.5.0 \
+  -isystem $(GCC_LINARO_PATH)/aarch64-linux-gnu/include/c++/7.5.0/aarch64-linux-gnu \
+  -isystem $(GCC_LINARO_PATH)/aarch64-linux-gnu/include/c++/7.5.0/backward \
+  -isystem $(GCC_LINARO_PATH)/lib/gcc/aarch64-linux-gnu/7.5.0/include \
+  -isystem $(GCC_LINARO_PATH)/lib/gcc/aarch64-linux-gnu/7.5.0/include-fixed \
+  -isystem $(GCC_LINARO_PATH)/aarch64-linux-gnu/include \
+  -isystem $(GCC_LINARO_PATH)/aarch64-linux-gnu/libc/usr/include \
+  -target aarch64-linux-gnu
+
+ifeq ($(OPT),O2)
+    HIR2MPL_FLAGS := --rc
+    MPLME_FLAGS := --O2 --quiet
+    MPL2MPL_FLAGS := --O2 --quiet --regnativefunc --no-nativeopt --maplelinker
+    MPLCG_FLAGS := --O2 --quiet --no-pie --verbose-asm --gen-c-macro-def --maplelinker --duplicate_asm_list=$(DUPLICATE_DIR)/duplicateFunc.s
+    MPLCG_SO_FLAGS := --fpic
+else ifeq ($(OPT),O0)
+    HIR2MPL_FLAGS := --rc
+    MPLME_FLAGS := --quiet
+    MPL2MPL_FLAGS := --quiet --regnativefunc --maplelinker
+    MPLCG_FLAGS := --quiet --no-pie --verbose-asm --gen-c-macro-def --maplelinker --duplicate_asm_list=$(DUPLICATE_DIR)/duplicateFunc.s
+    MPLCG_SO_FLAGS := --fpic
+else ifeq ($(OPT),GC_O2)
+    HIR2MPL_FLAGS :=
+    MPLME_FLAGS := --O2 --quiet --gconly
+    MPL2MPL_FLAGS := --O2 --quiet --regnativefunc --no-nativeopt --maplelinker
+    MPLCG_FLAGS := --O2 --quiet --no-pie --verbose-asm --gen-c-macro-def --maplelinker --duplicate_asm_list=$(DUPLICATE_DIR)/duplicateFunc.s --gconly
+    MPLCG_SO_FLAGS := --fpic
+else ifeq ($(OPT),GC_O0)
+    HIR2MPL_FLAGS :=
+    MPLME_FLAGS := --quiet --gconly
+    MPL2MPL_FLAGS := --quiet --regnativefunc --maplelinker
+    MPLCG_FLAGS := --quiet --no-pie --verbose-asm --gen-c-macro-def --maplelinker --duplicate_asm_list=$(DUPLICATE_DIR)/duplicateFunc.s --gconly
+    MPLCG_SO_FLAGS := --fpic
+endif
+HIR2MPL_APP_FLAGS := -mplt=${LIB_CORE_PATH}/libcore-all.mplt
+MPLCOMBO_FLAGS := --run=me:mpl2mpl:mplcg --option="$(MPLME_FLAGS):$(MPL2MPL_FLAGS):$(MPLCG_FLAGS) $(MPLCG_SO_FLAGS)"
+JAVA2DEX_FLAGS := -p ${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/third_party/JAVA_LIBRARIES/core-oj_intermediates/classes.jar:${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/third_party/JAVA_LIBRARIES/core-libart_intermediates/classes.jar
diff --git a/build/core/mplcomb.mk b/build/core/mplcomb.mk
new file mode 100644
index 0000000000000000000000000000000000000000..b0891618fb791f176635ee966b65b1155f5ebab6
--- /dev/null
+++ b/build/core/mplcomb.mk
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+$(APP_S): %.VtableImpl.s : %.jar $(MAPLE_BIN) $(JBC2MPL_BIN) $(LIB_CORE_MPLT)
+	$(MAPLE_BIN) -$(OPT) --mplt $(LIB_CORE_MPLT) $<
diff --git a/build/core/mplcomb_dex.mk b/build/core/mplcomb_dex.mk
new file mode 100644
index 0000000000000000000000000000000000000000..94f477d038f4ca162e059afe5bbea7691989b042
--- /dev/null
+++ b/build/core/mplcomb_dex.mk
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+$(APP_S): %.VtableImpl.s : %.mpl $(MAPLE_BIN) $(DUPLICATE_DIR)/duplicateFunc.s
+	$(MAPLE_BIN) --infile $< $(MPLCOMBO_FLAGS) --save-temps > comb.log 2>&1
diff --git a/build/core/qemu_ar.mk b/build/core/qemu_ar.mk
new file mode 100644
index 0000000000000000000000000000000000000000..323357f226cc43f9229b53205b5a4cfbc583892e
--- /dev/null
+++ b/build/core/qemu_ar.mk
@@ -0,0 +1,29 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+LIB_AR_PATH=$(MAPLE_OUT)/ar/host-x86_64-$(OPT)
+LIB_RUNTIME=$(LIB_AR_PATH)/libmplcompiler-rt.a
+LIB_ZTERP=$(LIB_AR_PATH)/libzterp.a
+LIB_MRT=$(LIB_AR_PATH)/libmaplert.a
+LIB_HUAWEISECUREC=$(LIB_AR_PATH)/libhuawei_secure_c.a
+LIB_CORENATIVE=$(LIB_AR_PATH)/libcore-static-binding-jni.a
+LIBDEXINTERFACE=$(LIB_AR_PATH)/libdexinterface.a
+LIBCORE_SO_QEMU := $(MAPLE_OUT)/lib/$(OPT)/libcore-all.so
+ifneq ($(findstring GC,$(OPT)),)
+  LIB_CORENATIVE_QEMU=$(MAPLE_ROOT)/src/mrt/deplibs/libcore-static-binding-jni-qemu.a
+else
+  LIB_CORENATIVE_QEMU=$(MAPLE_ROOT)/src/mrt/deplibs/gc/libcore-static-binding-jni-qemu.a
+endif
+
+qemu := $(LIB_RUNTIME) $(LIB_MRT) $(LIB_HUAWEISECUREC) $(LIB_CORENATIVE_QEMU) $(LIB_CORENATIVE) $(LIB_ZTERP) $(LIBDEXINTERFACE)
diff --git a/build/core/qemu_run.mk b/build/core/qemu_run.mk
new file mode 100644
index 0000000000000000000000000000000000000000..3572fea91d5ac8eeb3f6f27773b42f2fb49c0271
--- /dev/null
+++ b/build/core/qemu_run.mk
@@ -0,0 +1,2 @@
+APP_RUN: $(APP_SO)
+	${TOOL_BIN_PATH}/qemu-aarch64 -L /usr/aarch64-linux-gnu -E LD_LIBRARY_PATH=${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/third_party:${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/host-x86_64-O2:./ ${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/mplsh -Xbootclasspath:libcore-all.so -cp $(APP_SO) $(APP)
diff --git a/build/d8 b/build/d8
new file mode 100755
index 0000000000000000000000000000000000000000..a3c0c08c419accdd314a53b80d6b59a2d6486fc0
--- /dev/null
+++ b/build/d8
@@ -0,0 +1,24 @@
+#!/bin/bash
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under the Mulan PSL v1.
+# You can use this software according to the terms and conditions of the Mulan PSL v1.
+# You may obtain a copy of Mulan PSL v1 at:
+#
+#     http://license.coscl.org.cn/MulanPSL
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v1 for more details.
+#
+jarfile=d8.jar
+libdir=${MAPLE_ROOT}/third_party/d8/lib
+jarpath="$libdir/$jarfile"
+
+# a max heap size of dx, can be overwrite
+defaultHeapMax="-Xmx1024M"
+javaOpts="${javaOpts} ${defaultHeapMax}"
+
+java $javaOpts -jar "$jarpath" "$@"
diff --git a/build/envsetup.sh b/build/envsetup.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0a363eac85fc4c1c4776cafca438cc11696381f5
--- /dev/null
+++ b/build/envsetup.sh
@@ -0,0 +1,216 @@
+#!/bin/bash
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+function print_usage {
+  echo " "
+  echo "usage: source envsetup.sh arm/ark/engine/riscv/x86_64 release/debug"
+  echo " "
+}
+
+if [ "$#" -lt 2 ]; then
+  print_usage
+# return
+fi
+
+curdir=$(pwd)
+export MAPLE_ROOT=${curdir}
+export SPEC=${MAPLE_ROOT}/testsuite/c_test/spec_test
+export LD_LIBRARY_PATH=${MAPLE_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/lib:${MAPLE_ROOT}/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04/lib:${LD_LIBRARY_PATH}
+export SPECPERLLIB=${SPEC}/bin/lib:${SPEC}/bin:${SPEC}/SPEC500-perlbench_r/data/all/input/lib:${SPEC}/SPEC500-perlbench_r/t/lib
+export CASE_ROOT=${curdir}/testsuite
+export OUT_ROOT=${curdir}/output
+export ANDROID_ROOT=${curdir}/android
+export MAPLE_BUILD_CORE=${MAPLE_ROOT}/build/core
+if [ -d ${MAPLE_ROOT}/src/ast2mpl ]; then
+  export IS_AST2MPL_EXISTS=1
+else
+  export IS_AST2MPL_EXISTS=0
+fi
+export GCOV_PREFIX=${MAPLE_ROOT}/report/gcda
+export GCOV_PREFIX_STRIP=7
+
+# display OS version
+lsb_release -d
+
+export TOOL_BIN_PATH=${MAPLE_ROOT}/tools/bin
+if [ -d ${MAPLE_ROOT}/testsuite/driver/.config ];then
+  rm -rf ${MAPLE_ROOT}/testsuite/driver/config
+  rm -rf ${MAPLE_ROOT}/testsuite/driver/src/api
+  rm -rf ${MAPLE_ROOT}/testsuite/driver/src/mode
+  cd ${MAPLE_ROOT}/testsuite/driver
+  ln -s -f .config config
+  cd ${MAPLE_ROOT}/testsuite/driver/src
+  ln -s -f .api api
+  ln -s -f .mode mode
+fi
+
+cd ${MAPLE_ROOT}
+
+OS_VERSION=`lsb_release -r | sed -e "s/^[^0-9]*//" -e "s/\..*//"`
+if [ "$OS_VERSION" = "16" ] || [ "$OS_VERSION" = "18" ]; then
+  export OLD_OS=1
+else
+  export OLD_OS=0
+fi
+
+# support multiple ARCH and BUILD_TYPE
+
+if [ $1 = "arm" ]; then
+  PLATFORM=aarch64
+  USEOJ=0
+elif [ $1 = "riscv" ]; then
+  PLATFORM=riscv64
+  USEOJ=0
+elif [ $1 = "x86_64" ] ; then
+  PLATFORM=x86_64
+  USEOJ=0
+elif [ $1 = "engine" ]; then
+  PLATFORM=ark
+  USEOJ=1
+elif [ $1 = "ark" ]; then
+  PLATFORM=ark
+  USEOJ=1
+else
+  print_usage
+  return
+fi
+
+if [ "$2" = "release" ]; then
+  TYPE=release
+  DEBUG=0
+elif [ "$2" = "debug" ]; then
+  TYPE=debug
+  DEBUG=1
+else
+  print_usage
+  return
+fi
+
+export MAPLE_DEBUG=${DEBUG}
+export TARGET_PROCESSOR=${PLATFORM}
+export TARGET_SCOPE=${TYPE}
+export USE_OJ_LIBCORE=${USEOJ}
+export TARGET_TOOLCHAIN=clang
+export MAPLE_BUILD_TYPE=${TARGET_PROCESSOR}-${TARGET_TOOLCHAIN}-${TARGET_SCOPE}
+echo "Build:          $MAPLE_BUILD_TYPE"
+export MAPLE_BUILD_OUTPUT=${MAPLE_ROOT}/output/${MAPLE_BUILD_TYPE}
+export MAPLE_EXECUTE_BIN=${MAPLE_ROOT}/output/${MAPLE_BUILD_TYPE}/bin
+export TEST_BIN=${CASE_ROOT}/driver/script
+export PATH=$PATH:${MAPLE_EXECUTE_BIN}:${TEST_BIN}
+
+# Enable Autocompletion for maple driver
+if [ -f $MAPLE_ROOT/tools/maple_autocompletion.sh ]; then
+  source ${MAPLE_ROOT}/tools/maple_autocompletion.sh
+fi
+
+if [ ! -f $MAPLE_ROOT/tools/qemu/usr/bin/qemu-aarch64 ] && [ "$OLD_OS" = "0" ]; then
+  echo " "
+  echo "!!! please run \"make setup\" to get proper qemu-aarch64"
+  echo " "
+fi
+
+function mm
+{
+  THREADS=$(cat /proc/cpuinfo| grep "processor"| wc -l)
+  PWD=$(pwd)
+  num=${#CASE_ROOT}
+  let num++
+  ALL_MODE_LIST=$(cd ${CASE_ROOT}/driver/src/mode; find -name "*.py" | xargs basename -s .py;)
+  TARGET=${PWD:${num}}
+  MODE=
+
+  #mm MODE=O0
+  if [ $# -lt 3 ] && [[ "x${1^^}" =~ ^xMODE=.* ]]; then
+      MODE=${1#*=}
+      MODE=${MODE^^}
+      python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --mode=${MODE} --detail
+  elif [ $# -lt 3 ] && [[ `echo ${ALL_MODE_LIST[@]} | grep -w ${1^^}` ]] ; then
+      MODE=${1^^}
+      python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --mode=${MODE} --detail
+
+  #mm clean
+  elif [ $# -lt 3 ] && [ "x${1}" = "xclean" ]; then
+      python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --clean --detail
+
+  #mm save
+  elif [ $# = 1 ] && [ "x${1}" = "xsave" ]; then
+      python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --save
+
+  #mm testall
+  elif [ $# = 1 ] && [ -f ${CASE_ROOT}/driver/config/${1}.conf ]; then
+      TARGET=${1}
+      python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --run-path=${OUT_ROOT}/host/test --j=${THREADS}
+
+  #mm testall MODE=O0
+  elif [ $# = 2 ] && [ -f ${CASE_ROOT}/driver/config/${1}.conf ]; then
+      if [[ "x${2^^}" =~ ^xMODE=.* ]]; then
+          MODE=${2#*=}
+          MODE=${MODE^^}
+      elif [[ `echo ${ALL_MODE_LIST[@]} | grep -w ${2^^}` ]] ; then
+          MODE=${2^^}
+      fi
+      TARGET=${1}
+      python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --run-path=${OUT_ROOT}/host/test --mode=${MODE} --j=${THREADS}
+
+  #mm app_test
+  elif [ $# = 1 ] && [ -d ${CASE_ROOT}/${1} ]
+  then
+      TARGET=${1}
+      python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --run-path=${OUT_ROOT}/host/test --j=${THREADS}
+
+  #mm app_test MODE=O2
+  elif [ $# = 2 ] && [ -d ${CASE_ROOT}/${1} ]; then
+      if [[ "x${2^^}" =~ ^xMODE=.* ]]; then
+          MODE=${2#*=}
+          MODE=${MODE^^}
+      elif [[ `echo ${ALL_MODE_LIST[@]} | grep -w ${2^^}` ]] ; then
+          MODE=${2^^}
+      fi
+      TARGET=${1}
+      python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --run-path=${OUT_ROOT}/host/test --mode=${MODE} --j=${THREADS}
+
+  elif [ $# = 1 ] && [ "x${1,,}" = "x-h" -o "x${1,,}" = "x--help" ];
+  then
+      cat <<EOF
+---------------------- MAPLE TEST FRAME INSTRUCTION ---------------------------
+[2021/9/17]: capable with uppercase and lowercase for MODE, and "MODE=" is not necessary.
+[*] Run mm [command] under ${MAPLE_ROOT}:
+  - mm testall:               run all test cases for all modes
+
+  - mm testall (MODE=)XX      run all test cases with XX mode. type XX directly if XX in [MODE SUITE]
+                              e.g. mm testall [co0 / CO0 / mode=co0 / MODE=CO0];
+
+  - mm [testsuite]            run [testsuite] with all modes. note [testsuite] should start under $CASE_ROOT.
+                              e.g. mm c_test/ast_test : test all testcases in c_test/ast_test
+                              e.g. mm c_test : test all testcases in c_test
+
+  - mm [testsuite] (MODE=)XX  run [testsuite] with XX mode. note [testsuite] should support XX mode.
+                              e.g. mm c_test/gtorture_test [CO2 / co2 / MODE=CO2 / mode=co2]
+
+[*] Run mm [command] under    single testcase (${MAPLE_ROOT}/testsuite/c_test/ast_test/AST0001-HelloWorld):
+  - mm MODE=XX:               run XX mode for this case
+                              e.g. mm [ASTO0 / asto0 / mode=asto0 / MODE=ASTO0]
+
+  - mm save:                  save temp files for this case
+
+  - mm clean:            clean all temp files for this case
+
+EOF
+  else
+      echo "Input Wrong~! please run: mm -h/--help for more help!"
+  fi
+}
+
diff --git a/build/java2d8 b/build/java2d8
new file mode 100755
index 0000000000000000000000000000000000000000..6f88b4fd084ade8992695696d5c468d9c306b493
--- /dev/null
+++ b/build/java2d8
@@ -0,0 +1,66 @@
+#!/bin/bash
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+#compile a .java to .dex using javac/dx tool chain, it's faster than jack.
+# using: java2dex-fast.sh xxx.java
+# output: xxx.dex
+
+# assumes javac is in the execution path.
+EXECDIR=${MAPLE_ROOT}/build/
+
+DESTDIR=$(pwd)/java2dex
+mkdir -p ${DESTDIR}
+CLASSES_DEX=$DESTDIR/classes.dex
+CLASSES_JAR=$DESTDIR/classes.jar
+
+
+
+INPUT_FILE=$1
+OUTPUT_FILE=${INPUT_FILE/.*/.dex}
+OUTPUT_JAR_FILE=${INPUT_FILE/.*/.jar}
+
+THIRD_PARTY=${MAPLE_ROOT}/android/out/target/common/obj/
+
+#echo "Compiling $INPUT_FILE to $OUTPUT_FILE in temporary directory $DESTDIR"
+echo "Compiling $INPUT_FILE to $OUTPUT_FILE"
+
+javac -g -d $DESTDIR -bootclasspath $THIRD_PARTY/JAVA_LIBRARIES/core-oj_intermediates/classes.jar:$THIRD_PARTY/JAVA_LIBRARIES/core-libart_intermediates/classes.jar:$THIRD_PARTY/JAVA_LIBRARIES/services_intermediates/classes.jar $@
+
+mkdir -p $DESTDIR/classes
+cd $DESTDIR/classes
+find $DESTDIR -name "*.class" | xargs -i cp {} $DESTDIR/classes
+find $DESTDIR -name "*.jar" | xargs -i cp {} $DESTDIR/
+jar -cvf $CLASSES_JAR *.class
+cd -
+cd $DESTDIR
+
+$EXECDIR/d8 --min-api 39 --output $DESTDIR $CLASSES_JAR --classpath $THIRD_PARTY/JAVA_LIBRARIES/core-oj_intermediates/classes.jar --classpath $THIRD_PARTY/JAVA_LIBRARIES/core-libart_intermediates/classes.jar --classpath $THIRD_PARTY/JAVA_LIBRARIES/services_intermediates/classes.jar
+cd -
+
+if [ -f $CLASSES_DEX ]; then
+  mv $CLASSES_DEX $OUTPUT_FILE
+#  echo "Successfully built $OUTPUT_FILE"
+fi
+
+if [ -f $CLASSES_JAR ]; then
+  mv $CLASSES_JAR $OUTPUT_JAR_FILE
+#  echo "Successfully built $OUTPUT_FILE"
+fi
+
+cp $DESTDIR/classes/* .
+#echo "Deleting temporary directory $DESTDIR"
+if [ -d ${DESTDIR} ]; then
+    rm -rf ${DESTDIR}
+fi
diff --git a/build/java2dex b/build/java2dex
new file mode 100755
index 0000000000000000000000000000000000000000..33e4ad61a130015e206599baf8f412c8eed955bb
--- /dev/null
+++ b/build/java2dex
@@ -0,0 +1,92 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+#!/bin/bash
+set -e
+#set -x
+# compile a .java to .dex using javac/dx tool chain.
+# using: java2dex.sh xxx.java
+# output: xxx.dex
+
+while getopts 'i:o:p:s:' args;
+do
+    case ${args} in
+        i)  INPUT_FILE=${OPTARG};;
+        p)  CLASSES_JAR_FILE=${OPTARG};;
+        o)  OUT_FILE=${OPTARG};;
+        s)  USE_SIMPLEJAVA=${OPTARG};;
+        *)  echo "invaild param:"${OPTARG};;
+    esac
+done
+
+CASEDIR=$(pwd)
+DESTDIR=$(pwd)/java2dex
+mkdir -p ${DESTDIR}
+JAVA_FILE=${INPUT_FILE//:/' '}
+CLASS_FILE_ALL=${JAVA_FILE//\.java/\.class}
+CLASS_FILE=*.class
+JAR_FILE=`echo ${OUT_FILE} |awk -F. '{print $1}'`".jar"
+CLASS_PATH='--classpath '${CLASSES_JAR_FILE//:/' --classpath '}
+
+java_file_exist=0
+for i in ${JAVA_FILE}
+do
+    if [ -f $i ];then
+        java_file_exist=1
+        break
+    fi
+done
+
+if [ ${java_file_exist} -eq 1 ];then
+    javac -g -d ${DESTDIR} -bootclasspath ${CLASSES_JAR_FILE} ${JAVA_FILE}
+fi
+
+mkdir -p ${DESTDIR}/classes
+cd ${DESTDIR}/classes
+
+if [ -z ${USE_SIMPLEJAVA} ];then
+    find ${DESTDIR} -name "*.class" | xargs -i cp {} ${DESTDIR}/classes
+else
+    find ${DESTDIR} -name ${CLASS_FILE_ALL} | xargs -i cp {} ${DESTDIR}/classes
+fi
+
+class_file_exist=0
+for i in ${CLASS_FILE_ALL}
+do
+    x=`basename $i`
+    if [ -f ${DESTDIR}/classes/$x ];then
+        class_file_exist=1
+        cp ${DESTDIR}/classes/*.class ${CASEDIR}
+        break
+    fi
+done
+
+if [ ${class_file_exist} -eq 1 ];then
+    jar -cvf $DESTDIR/${JAR_FILE} ${CLASS_FILE}
+fi
+
+if [ -f ${DESTDIR}/${JAR_FILE} ];then
+    java -Xmx1024M -jar ${MAPLE_ROOT}/third_party/d8/lib/d8.jar --min-api 39 --output ${DESTDIR} ${DESTDIR}/${JAR_FILE} ${CLASS_PATH}
+fi
+
+if [ -f ${DESTDIR}/classes.dex ];then
+    cp ${DESTDIR}/classes.dex ${CASEDIR}/${OUT_FILE}
+fi
+
+if [ -f ${DESTDIR}/*.jar ];then
+    cp ${DESTDIR}/*.jar ${CASEDIR}
+fi
+
+rm -rf ${DESTDIR}
+
diff --git a/build/jenkins/main.sh b/build/jenkins/main.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b6b64ba087a9bee577af1eb1c2fc56d6557949cd
--- /dev/null
+++ b/build/jenkins/main.sh
@@ -0,0 +1,85 @@
+#!/bin/bash
+
+set -e
+
+# Note:copy main.sh to the MAPLE_ROOT directory.
+
+sample_list="exceptiontest helloworld iteratorandtemplate polymorphismtest rccycletest threadtest"
+opt=O2
+
+function debug_test {
+  source build/envsetup.sh arm debug
+  make clean
+  make
+  make irbuild
+  make hir2mpl
+  make clang2mpl
+  mkdir -p ${MAPLE_ROOT}/output/script
+  cp ${MAPLE_ROOT}/testsuite/driver/script/check.py ${MAPLE_ROOT}/output/script/
+  cp ${MAPLE_ROOT}/testsuite/driver/script/kernel.py ${MAPLE_ROOT}/output/script/
+  mm irbuild_test
+  mm c_test
+}
+
+function release_test {
+  source build/envsetup.sh arm release
+
+  if [ ! -d $MAPLE_ROOT/third_party/ctorture ]; then
+    cd $TOOLS
+    rm -rf ctorture $MAPLE_ROOT/third_party/ctorture
+    git clone --depth 1 https://gitee.com/hu-_-wen/ctorture.git
+    mv ctorture $MAPLE_ROOT/third_party/
+    echo Downloaded ctorture.
+  fi
+  cd $MAPLE_ROOT/third_party/ctorture
+  git reset --hard
+  git clean -fd
+  git pull
+
+  cd $MAPLE_ROOT
+  make clean
+  make
+  make irbuild
+  make hir2mpl
+  make clang2mpl
+
+  mode_list="O0 O2 GC_O0 GC_O2"
+  for mode in $mode_list
+  do
+    make libcore OPT=${mode}
+    cp -rf $MAPLE_BUILD_OUTPUT/lib/${mode}/libcore-all.so $MAPLE_BUILD_OUTPUT/ops/host-x86_64-${mode}/libcore-all.so
+  done
+
+  mkdir -p ${MAPLE_ROOT}/output/script
+  cp ${MAPLE_ROOT}/testsuite/driver/script/check.py ${MAPLE_ROOT}/output/script/
+  cp ${MAPLE_ROOT}/testsuite/driver/script/kernel.py ${MAPLE_ROOT}/output/script/
+
+  for dir in $sample_list
+  do
+    cd $MAPLE_ROOT/samples/$dir
+    make OPT=O2
+    make clean
+  done
+
+  if [[ $opt != "O2" ]]; then
+    cp $MAPLE_BUILD_OUTPUT/ops/host-x86_64-${opt} $MAPLE_BUILD_OUTPUT/ops/host-x86_64-O2 -rf
+  fi
+
+  cd $MAPLE_ROOT
+  mm testall
+
+  make ctorture-ci
+}
+
+function main {
+  # clean and setup env
+  source build/envsetup.sh arm release
+  make clobber
+  make setup
+
+  debug_test
+
+  release_test
+}
+
+main $@
diff --git a/build/logs/.gitignore b/build/logs/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/build/third_party/aosp_gn/art/libdexfile/BUILD.gn b/build/third_party/aosp_gn/art/libdexfile/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..2c9a3e2a4d93840040ca84f6273f94727c7e8c95
--- /dev/null
+++ b/build/third_party/aosp_gn/art/libdexfile/BUILD.gn
@@ -0,0 +1,45 @@
+include_directories = [
+  "${AOSP_ROOT}/system/core/base/include",
+  "${AOSP_ROOT}/system/core/libziparchive/include",
+  "${AOSP_ROOT}/system/core/liblog/include",
+  "${AOSP_ROOT}/system/core/libutils/include",
+  "${AOSP_ROOT}/art/libartpalette/include",
+  "${AOSP_ROOT}/art/libartbase",
+  "${AOSP_ROOT}/art/libdexfile",
+  "${AOSP_ROOT}/include",
+  "${AOSP_ROOT}/libnativehelper/include_jni",
+]
+
+sources_files = [
+  "dex/art_dex_file_loader.cc",
+  "dex/compact_dex_file.cc",
+  "dex/compact_offset_table.cc",
+  "dex/descriptors_names.cc",
+  "dex/dex_file.cc",
+  "dex/dex_file_exception_helpers.cc",
+  "dex/dex_file_layout.cc",
+  "dex/dex_file_loader.cc",
+  "dex/dex_file_tracking_registrar.cc",
+  "dex/dex_file_verifier.cc",
+  "dex/dex_instruction.cc",
+  "dex/modifiers.cc",
+  "dex/primitive.cc",
+  "dex/signature.cc",
+  "dex/standard_dex_file.cc",
+  "dex/type_lookup_table.cc",
+  "dex/utf.cc",
+]
+
+static_library("libdexfile") {
+  sources = sources_files
+
+  include_dirs = include_directories
+
+  cflags_cc += [
+    "-Wno-defaulted-function-deleted",
+    "-std=gnu++17",
+    "-fPIC",
+  ]
+
+  output_dir = "${root_out_dir}/lib"
+}
diff --git a/build/third_party/aosp_gn/system/core/base/BUILD.gn b/build/third_party/aosp_gn/system/core/base/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..cdc7374fcf2e9172eedb2535aba9a38e3d6dbf4c
--- /dev/null
+++ b/build/third_party/aosp_gn/system/core/base/BUILD.gn
@@ -0,0 +1,32 @@
+include_directories = [
+  "${AOSP_ROOT}/system/core/base/include",
+  "${AOSP_ROOT}/include",
+]
+
+source_files = [
+  "chrono_utils.cpp",
+  "cmsg.cpp",
+  "file.cpp",
+  "logging.cpp",
+  "mapped_file.cpp",
+  "parsenetaddress.cpp",
+  "properties.cpp",
+  "quick_exit.cpp",
+  "stringprintf.cpp",
+  "strings.cpp",
+  "test_utils.cpp",
+  "threads.cpp",
+]
+
+static_library("libbase") {
+  sources = source_files
+
+  include_dirs = include_directories
+
+  cflags_cc += [
+    "-std=gnu++17",
+    "-fPIC",
+  ]
+
+  output_dir = "${root_out_dir}/lib"
+}
diff --git a/build/third_party/aosp_gn/system/core/libziparchive/BUILD.gn b/build/third_party/aosp_gn/system/core/libziparchive/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..442ae3460d8eca3525b574ab52fa7fa402928cf7
--- /dev/null
+++ b/build/third_party/aosp_gn/system/core/libziparchive/BUILD.gn
@@ -0,0 +1,24 @@
+include_directories = [
+  "${AOSP_ROOT}/system/core/include",
+  "${AOSP_ROOT}/system/core/base/include",
+  "${AOSP_ROOT}/system/core/libziparchive/include",
+  "${AOSP_ROOT}/system/core/libziparchive",
+  "${AOSP_ROOT}/system/core/liblog/include",
+  "${AOSP_ROOT}/system/core/libutils/include",
+  "${AOSP_ROOT}/include",
+]
+
+static_library("libziparchive") {
+  sources = [
+    "zip_archive.cc",
+    "zip_archive_stream_entry.cc",
+    "zip_writer.cc",
+  ]
+
+  include_dirs = include_directories
+  cflags_cc += [
+    "-std=gnu++17",
+    "-fPIC",
+  ]
+  output_dir = "${root_out_dir}/lib"
+}
diff --git a/build/third_party/art_001.patch b/build/third_party/art_001.patch
new file mode 100644
index 0000000000000000000000000000000000000000..3b9938f48afbadbf5bb73f243c55febd395f5cde
--- /dev/null
+++ b/build/third_party/art_001.patch
@@ -0,0 +1,703 @@
+diff -ur art_aosp/libartbase/arch/instruction_set.cc art/libartbase/arch/instruction_set.cc
+--- art_aosp/libartbase/arch/instruction_set.cc	2021-01-29 11:00:02.202266487 +0800
++++ art/libartbase/arch/instruction_set.cc	2021-01-29 10:34:50.012986865 +0800
+@@ -19,6 +19,7 @@
+ #include "android-base/logging.h"
+ #include "base/bit_utils.h"
+ #include "base/globals.h"
++#include <string.h>
+ 
+ namespace art {
+ 
+@@ -115,11 +116,23 @@
+ static_assert(IsAligned<kPageSize>(kX86StackOverflowReservedBytes), "X86 gap not page aligned");
+ static_assert(IsAligned<kPageSize>(kX86_64StackOverflowReservedBytes),
+               "X86_64 gap not page aligned");
+-
++/*
++cflags += [
++        "-DART_STACK_OVERFLOW_GAP_arm=8192",
++        "-DART_STACK_OVERFLOW_GAP_arm64=8192",
++        "-DART_STACK_OVERFLOW_GAP_mips=16384",
++        "-DART_STACK_OVERFLOW_GAP_mips64=16384",
++        "-DART_STACK_OVERFLOW_GAP_x86=16384",
++        "-DART_STACK_OVERFLOW_GAP_x86_64=20480",
++        "-DART_FRAME_SIZE_LIMIT=7400",
++    ]
++ */
++/* 
+ #if !defined(ART_FRAME_SIZE_LIMIT)
+ #error "ART frame size limit missing"
+ #endif
+-
++*/
++const uint32_t ART_FRAME_SIZE_LIMIT = 7400;
+ // TODO: Should we require an extra page (RoundUp(SIZE) + kPageSize)?
+ static_assert(ART_FRAME_SIZE_LIMIT < kArmStackOverflowReservedBytes, "Frame size limit too large");
+ static_assert(ART_FRAME_SIZE_LIMIT < kArm64StackOverflowReservedBytes,
+diff -ur art_aosp/libartbase/arch/instruction_set.h art/libartbase/arch/instruction_set.h
+--- art_aosp/libartbase/arch/instruction_set.h	2021-01-29 11:00:02.202266487 +0800
++++ art/libartbase/arch/instruction_set.h	2021-01-29 10:34:50.012986865 +0800
+@@ -227,19 +227,30 @@
+ }
+ 
+ namespace instruction_set_details {
+-
++/*
++cflags += [
++        "-DART_STACK_OVERFLOW_GAP_arm=8192",
++        "-DART_STACK_OVERFLOW_GAP_arm64=8192",
++        "-DART_STACK_OVERFLOW_GAP_mips=16384",
++        "-DART_STACK_OVERFLOW_GAP_mips64=16384",
++        "-DART_STACK_OVERFLOW_GAP_x86=16384",
++        "-DART_STACK_OVERFLOW_GAP_x86_64=20480",
++        "-DART_FRAME_SIZE_LIMIT=7400",
++    ]
++ */
++ /* 
+ #if !defined(ART_STACK_OVERFLOW_GAP_arm) || !defined(ART_STACK_OVERFLOW_GAP_arm64) || \
+     !defined(ART_STACK_OVERFLOW_GAP_mips) || !defined(ART_STACK_OVERFLOW_GAP_mips64) || \
+     !defined(ART_STACK_OVERFLOW_GAP_x86) || !defined(ART_STACK_OVERFLOW_GAP_x86_64)
+ #error "Missing defines for stack overflow gap"
+ #endif
+-
+-static constexpr size_t kArmStackOverflowReservedBytes    = ART_STACK_OVERFLOW_GAP_arm;
+-static constexpr size_t kArm64StackOverflowReservedBytes  = ART_STACK_OVERFLOW_GAP_arm64;
+-static constexpr size_t kMipsStackOverflowReservedBytes   = ART_STACK_OVERFLOW_GAP_mips;
+-static constexpr size_t kMips64StackOverflowReservedBytes = ART_STACK_OVERFLOW_GAP_mips64;
+-static constexpr size_t kX86StackOverflowReservedBytes    = ART_STACK_OVERFLOW_GAP_x86;
+-static constexpr size_t kX86_64StackOverflowReservedBytes = ART_STACK_OVERFLOW_GAP_x86_64;
++*/
++static constexpr size_t kArmStackOverflowReservedBytes    = 8192;
++static constexpr size_t kArm64StackOverflowReservedBytes  = 8192;
++static constexpr size_t kMipsStackOverflowReservedBytes   = 16384;
++static constexpr size_t kMips64StackOverflowReservedBytes = 16384;
++static constexpr size_t kX86StackOverflowReservedBytes    = 16384;
++static constexpr size_t kX86_64StackOverflowReservedBytes = 20480;
+ 
+ NO_RETURN void GetStackOverflowReservedBytesFailure(const char* error_msg);
+ 
+diff -ur art_aosp/libartbase/base/arena_allocator.h art/libartbase/base/arena_allocator.h
+--- art_aosp/libartbase/base/arena_allocator.h	2021-01-29 11:00:02.198266452 +0800
++++ art/libartbase/base/arena_allocator.h	2021-01-29 10:34:50.012986865 +0800
+@@ -25,6 +25,7 @@
+ #include "dchecked_vector.h"
+ #include "macros.h"
+ #include "memory_tool.h"
++#include <string.h>
+ 
+ namespace art {
+ 
+diff -ur art_aosp/libartbase/base/bit_vector.h art/libartbase/base/bit_vector.h
+--- art_aosp/libartbase/base/bit_vector.h	2021-01-29 11:00:02.202266487 +0800
++++ art/libartbase/base/bit_vector.h	2021-01-29 10:34:50.012986865 +0800
+@@ -19,7 +19,7 @@
+ 
+ #include <stdint.h>
+ #include <iterator>
+-
++#include <string.h>
+ #include "bit_utils.h"
+ #include "globals.h"
+ 
+diff -ur art_aosp/libartbase/base/file_magic.cc art/libartbase/base/file_magic.cc
+--- art_aosp/libartbase/base/file_magic.cc	2021-01-29 11:00:02.198266452 +0800
++++ art/libartbase/base/file_magic.cc	2021-01-29 10:34:50.012986865 +0800
+@@ -19,7 +19,7 @@
+ #include <fcntl.h>
+ #include <sys/stat.h>
+ #include <sys/types.h>
+-
++#include <string.h>
+ #include <android-base/logging.h>
+ #include <android-base/stringprintf.h>
+ 
+diff -ur art_aosp/libartbase/base/file_utils.cc art/libartbase/base/file_utils.cc
+--- art_aosp/libartbase/base/file_utils.cc	2021-01-29 11:00:02.198266452 +0800
++++ art/libartbase/base/file_utils.cc	2021-01-29 10:34:50.012986865 +0800
+@@ -40,7 +40,7 @@
+ 
+ 
+ #include <memory>
+-
++#include <string.h>
+ #include "android-base/stringprintf.h"
+ #include "android-base/strings.h"
+ 
+@@ -401,7 +401,7 @@
+                                                &error_msg);
+   return (android_root != nullptr)
+       && (runtime_root != nullptr)
+-      && (std::string_view(android_root) != std::string_view(runtime_root));
++      && (StringView(android_root) != StringView(runtime_root));
+ }
+ 
+ int DupCloexec(int fd) {
+diff -ur art_aosp/libartbase/base/hiddenapi_stubs.h art/libartbase/base/hiddenapi_stubs.h
+--- art_aosp/libartbase/base/hiddenapi_stubs.h	2021-01-29 11:00:02.198266452 +0800
++++ art/libartbase/base/hiddenapi_stubs.h	2021-01-29 10:34:50.012986865 +0800
+@@ -18,11 +18,16 @@
+ #define ART_LIBARTBASE_BASE_HIDDENAPI_STUBS_H_
+ 
+ #include <set>
+-#include <string_view>
++#include "string_view_format.h"
+ 
+ namespace art {
+ namespace hiddenapi {
+ 
++const std::string kPublicApiStr = "public-api";
++const std::string kSystemApiStr = "system-api";
++const std::string kTestApiStr = "test-api";
++const std::string kCorePlatformApiStr = "core-platform-api";
++
+ class ApiStubs {
+  public:
+   enum class Kind {
+@@ -32,7 +37,7 @@
+     kCorePlatformApi,
+   };
+ 
+-  static const std::string_view ToString(Kind api) {
++  static std::string ToString(Kind api) {
+     switch (api) {
+       case Kind::kPublicApi:
+         return kPublicApiStr;
+@@ -45,16 +50,10 @@
+     }
+   }
+ 
+-  static bool IsStubsFlag(const std::string_view& api_flag_name) {
++  static bool IsStubsFlag(const std::string& api_flag_name) {
+     return api_flag_name == kPublicApiStr || api_flag_name == kSystemApiStr ||
+         api_flag_name == kTestApiStr || api_flag_name == kCorePlatformApiStr;
+   }
+-
+- private:
+-  static constexpr std::string_view kPublicApiStr{"public-api"};
+-  static constexpr std::string_view kSystemApiStr{"system-api"};
+-  static constexpr std::string_view kTestApiStr{"test-api"};
+-  static constexpr std::string_view kCorePlatformApiStr{"core-platform-api"};
+ };
+ 
+ }  // namespace hiddenapi
+diff -ur art_aosp/libartbase/base/logging.cc art/libartbase/base/logging.cc
+--- art_aosp/libartbase/base/logging.cc	2021-01-29 11:00:02.202266487 +0800
++++ art/libartbase/base/logging.cc	2021-01-29 10:34:50.012986865 +0800
+@@ -23,6 +23,7 @@
+ #include "aborting.h"
+ #include "os.h"
+ #include "unix_file/fd_file.h"
++#include <string.h>
+ 
+ // Headers for LogMessage::LogLine.
+ #ifdef ART_TARGET_ANDROID
+diff -ur art_aosp/libartbase/base/memfd.cc art/libartbase/base/memfd.cc
+--- art_aosp/libartbase/base/memfd.cc	2021-01-29 11:00:02.198266452 +0800
++++ art/libartbase/base/memfd.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -25,6 +25,7 @@
+ #endif
+ 
+ #include "macros.h"
++#include <string.h>
+ 
+ // When building for linux host, glibc in prebuilts does not include memfd_create system call
+ // number. As a temporary testing measure, we add the definition here.
+diff -ur art_aosp/libartbase/base/os_linux.cc art/libartbase/base/os_linux.cc
+--- art_aosp/libartbase/base/os_linux.cc	2021-01-29 11:00:02.202266487 +0800
++++ art/libartbase/base/os_linux.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -62,8 +62,7 @@
+   CHECK(name != nullptr);
+   bool read_only = ((flags & O_ACCMODE) == O_RDONLY);
+   bool check_usage = !read_only && auto_flush;
+-  std::unique_ptr<File> file(
+-      new File(name, flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH, check_usage));
++  std::unique_ptr<File> file(new File(name, flags, 0666, check_usage));
+   if (!file->IsOpened()) {
+     return nullptr;
+   }
+diff -ur art_aosp/libartbase/base/safe_copy.cc art/libartbase/base/safe_copy.cc
+--- art_aosp/libartbase/base/safe_copy.cc	2021-01-29 11:00:02.202266487 +0800
++++ art/libartbase/base/safe_copy.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -56,10 +56,10 @@
+     }
+ 
+     src_iovs[iovecs_used].iov_base = const_cast<char*>(cur);
+-    if (!IsAlignedParam(cur, PAGE_SIZE)) {
+-      src_iovs[iovecs_used].iov_len = AlignUp(cur, PAGE_SIZE) - cur;
++    if (!IsAlignedParam(cur, sysconf(_SC_PAGE_SIZE))) {
++      src_iovs[iovecs_used].iov_len = AlignUp(cur, sysconf(_SC_PAGE_SIZE)) - cur;
+     } else {
+-      src_iovs[iovecs_used].iov_len = PAGE_SIZE;
++      src_iovs[iovecs_used].iov_len = sysconf(_SC_PAGE_SIZE);
+     }
+ 
+     src_iovs[iovecs_used].iov_len = std::min(src_iovs[iovecs_used].iov_len, len);
+diff -ur art_aosp/libartbase/base/scoped_flock.cc art/libartbase/base/scoped_flock.cc
+--- art_aosp/libartbase/base/scoped_flock.cc	2021-01-29 11:00:02.202266487 +0800
++++ art/libartbase/base/scoped_flock.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -24,6 +24,7 @@
+ 
+ #include "file_utils.h"
+ #include "unix_file/fd_file.h"
++#include <string.h>
+ 
+ namespace art {
+ 
+diff -ur art_aosp/libartbase/base/string_view_cpp20.h art/libartbase/base/string_view_cpp20.h
+--- art_aosp/libartbase/base/string_view_cpp20.h	2021-01-29 11:00:02.198266452 +0800
++++ art/libartbase/base/string_view_cpp20.h	2021-01-29 10:34:50.016986900 +0800
+@@ -17,21 +17,21 @@
+ #ifndef ART_LIBARTBASE_BASE_STRING_VIEW_CPP20_H_
+ #define ART_LIBARTBASE_BASE_STRING_VIEW_CPP20_H_
+ 
+-#include <string_view>
++#include "string_view_format.h"
+ 
+ namespace art {
+ 
+-// Replacement functions for std::string_view::starts_with(), ends_with()
++// Replacement functions for StringView::starts_with(), ends_with()
+ // which shall be available in C++20.
+ #if __cplusplus >= 202000L
+ #error "When upgrading to C++20, remove this error and file a bug to remove this workaround."
+ #endif
+ 
+-inline bool StartsWith(std::string_view sv, std::string_view prefix) {
++inline bool StartsWith(StringView sv, StringView prefix) {
+   return sv.substr(0u, prefix.size()) == prefix;
+ }
+ 
+-inline bool EndsWith(std::string_view sv, std::string_view suffix) {
++inline bool EndsWith(StringView sv, StringView suffix) {
+   return sv.size() >= suffix.size() && sv.substr(sv.size() - suffix.size()) == suffix;
+ }
+ 
+diff -ur art_aosp/libartbase/base/unix_file/fd_file.cc art/libartbase/base/unix_file/fd_file.cc
+--- art_aosp/libartbase/base/unix_file/fd_file.cc	2021-01-29 11:00:02.202266487 +0800
++++ art/libartbase/base/unix_file/fd_file.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -20,6 +20,7 @@
+ #include <sys/stat.h>
+ #include <sys/types.h>
+ #include <unistd.h>
++#include <string.h>
+ 
+ #if defined(__BIONIC__)
+ #include <android/fdsan.h>
+diff -ur art_aosp/libartbase/base/utils.cc art/libartbase/base/utils.cc
+--- art_aosp/libartbase/base/utils.cc	2021-01-29 11:00:02.202266487 +0800
++++ art/libartbase/base/utils.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -29,7 +29,6 @@
+ #include "android-base/stringprintf.h"
+ #include "android-base/strings.h"
+ 
+-#include "bit_utils.h"
+ #include "os.h"
+ 
+ #if defined(__APPLE__)
+@@ -63,98 +62,6 @@
+ using android::base::ReadFileToString;
+ using android::base::StringPrintf;
+ 
+-#if defined(__arm__)
+-
+-namespace {
+-
+-// Bitmap of caches to flush for cacheflush(2). Must be zero for ARM.
+-static constexpr int kCacheFlushFlags = 0x0;
+-
+-// Number of retry attempts when flushing cache ranges.
+-static constexpr size_t kMaxFlushAttempts = 4;
+-
+-int CacheFlush(uintptr_t start, uintptr_t limit) {
+-  // The signature of cacheflush(2) seems to vary by source. On ARM the system call wrapper
+-  //    (bionic/SYSCALLS.TXT) has the form: int cacheflush(long start, long end, long flags);
+-  int r = cacheflush(start, limit, kCacheFlushFlags);
+-  if (r == -1) {
+-    CHECK_NE(errno, EINVAL);
+-  }
+-  return r;
+-}
+-
+-bool TouchAndFlushCacheLinesWithinPage(uintptr_t start, uintptr_t limit, size_t attempts) {
+-  CHECK_LT(start, limit);
+-  CHECK_EQ(RoundDown(start, kPageSize), RoundDown(limit - 1, kPageSize)) << "range spans pages";
+-  // Declare a volatile variable so the compiler does not elide reads from the page being touched.
+-  volatile uint8_t v = 0;
+-  for (size_t i = 0; i < attempts; ++i) {
+-    // Touch page to maximize chance page is resident.
+-    v = *reinterpret_cast<uint8_t*>(start);
+-
+-    if (LIKELY(CacheFlush(start, limit) == 0)) {
+-      return true;
+-    }
+-  }
+-  return false;
+-}
+-
+-}  // namespace
+-
+-bool FlushCpuCaches(void* begin, void* end) {
+-  // This method is specialized for ARM as the generic implementation below uses the
+-  // __builtin___clear_cache() intrinsic which is declared as void. On ARMv7 flushing the CPU
+-  // caches is a privileged operation. The Linux kernel allows these operations to fail when they
+-  // trigger a fault (e.g. page not resident). We use a wrapper for the ARM specific cacheflush()
+-  // system call to detect the failure and potential erroneous state of the data and instruction
+-  // caches.
+-  //
+-  // The Android bug for this is b/132205399 and there's a similar discussion on
+-  // https://reviews.llvm.org/D37788. This is primarily an issue for the dual view JIT where the
+-  // pages where code is executed are only ever RX and never RWX. When attempting to invalidate
+-  // instruction cache lines in the RX mapping after writing fresh code in the RW mapping, the
+-  // page may not be resident (due to memory pressure), and this means that a fault is raised in
+-  // the midst of a cacheflush() call and the instruction cache lines are not invalidated and so
+-  // have stale code.
+-  //
+-  // Other architectures fair better for reasons such as:
+-  //
+-  // (1) stronger coherence between the data and instruction caches.
+-  //
+-  // (2) fault handling that allows flushing/invalidation to continue after
+-  //     a missing page has been faulted in.
+-
+-  // In the common case, this flush of the complete range succeeds.
+-  uintptr_t start = reinterpret_cast<uintptr_t>(begin);
+-  const uintptr_t limit = reinterpret_cast<uintptr_t>(end);
+-  if (LIKELY(CacheFlush(start, limit) == 0)) {
+-    return true;
+-  }
+-
+-  // A rare failure has occurred implying that part of the range (begin, end] has been swapped
+-  // out. Retry flushing but this time grouping cache-line flushes on individual pages and
+-  // touching each page before flushing.
+-  uintptr_t next_page = RoundUp(start + 1, kPageSize);
+-  while (start < limit) {
+-    uintptr_t boundary = std::min(next_page, limit);
+-    if (!TouchAndFlushCacheLinesWithinPage(start, boundary, kMaxFlushAttempts)) {
+-      return false;
+-    }
+-    start = boundary;
+-    next_page += kPageSize;
+-  }
+-  return true;
+-}
+-
+-#else
+-
+-bool FlushCpuCaches(void* begin, void* end) {
+-  __builtin___clear_cache(reinterpret_cast<char*>(begin), reinterpret_cast<char*>(end));
+-  return true;
+-}
+-
+-#endif
+-
+ pid_t GetTid() {
+ #if defined(__APPLE__)
+   uint64_t owner;
+diff -ur art_aosp/libartbase/base/utils.h art/libartbase/base/utils.h
+--- art_aosp/libartbase/base/utils.h	2021-01-29 11:00:02.198266452 +0800
++++ art/libartbase/base/utils.h	2021-01-29 10:34:50.016986900 +0800
+@@ -113,8 +113,15 @@
+ // Sleep forever and never come back.
+ NO_RETURN void SleepForever();
+ 
+-// Flush CPU caches. Returns true on success, false if flush failed.
+-WARN_UNUSED bool FlushCpuCaches(void* begin, void* end);
++inline void FlushDataCache(void* begin, void* end) {
++  __builtin___clear_cache(reinterpret_cast<char*>(begin), reinterpret_cast<char*>(end));
++}
++
++inline void FlushInstructionCache(void* begin, void* end) {
++  // Same as FlushInstructionCache for lack of other builtin. __builtin___clear_cache
++  // flushes both caches.
++  __builtin___clear_cache(reinterpret_cast<char*>(begin), reinterpret_cast<char*>(end));
++}
+ 
+ template <typename T>
+ constexpr PointerSize ConvertToPointerSize(T any) {
+diff -ur art_aosp/libartpalette/system/palette_fake.cc art/libartpalette/system/palette_fake.cc
+--- art_aosp/libartpalette/system/palette_fake.cc	2021-01-29 11:01:59.615297526 +0800
++++ art/libartpalette/system/palette_fake.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -21,7 +21,7 @@
+ 
+ #include <android-base/logging.h>
+ #include <android-base/macros.h>  // For ATTRIBUTE_UNUSED
+-
++#include "string_view_format.h"
+ #include "palette_system.h"
+ 
+ enum PaletteStatus PaletteGetVersion(int32_t* version) {
+@@ -54,7 +54,7 @@
+ }
+ 
+ enum PaletteStatus PaletteWriteCrashThreadStacks(/*in*/ const char* stacks, size_t stacks_len) {
+-  LOG(INFO) << std::string_view(stacks, stacks_len);
++  LOG(INFO) << StringView(stacks, stacks_len);
+   return PaletteStatus::kOkay;
+ }
+ 
+diff -ur art_aosp/libdexfile/dex/compact_dex_file.cc art/libdexfile/dex/compact_dex_file.cc
+--- art_aosp/libdexfile/dex/compact_dex_file.cc	2021-01-29 11:02:31.435577410 +0800
++++ art/libdexfile/dex/compact_dex_file.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -19,6 +19,8 @@
+ #include "base/leb128.h"
+ #include "code_item_accessors-inl.h"
+ #include "dex_file-inl.h"
++#include <string.h>
++#include <algorithm>
+ 
+ namespace art {
+ 
+diff -ur art_aosp/libdexfile/dex/compact_offset_table.h art/libdexfile/dex/compact_offset_table.h
+--- art_aosp/libdexfile/dex/compact_offset_table.h	2021-01-29 11:02:32.119583426 +0800
++++ art/libdexfile/dex/compact_offset_table.h	2021-01-29 10:34:50.016986900 +0800
+@@ -28,7 +28,7 @@
+  public:
+   // This value is coupled with the leb chunk bitmask. That logic must also be adjusted when the
+   // integer is modified.
+-  static constexpr size_t kElementsPerIndex = 16;
++  static constexpr std::size_t kElementsPerIndex = 16;
+ 
+   // Leb block format:
+   // [uint16_t] 16 bit mask for what indexes actually have a non zero offset for the chunk.
+@@ -61,7 +61,7 @@
+                     uint32_t* out_table_offset);
+ 
+   // 32 bit aligned for the offset table.
+-  static constexpr size_t kAlignment = sizeof(uint32_t);
++  static constexpr std::size_t kAlignment = sizeof(uint32_t);
+ };
+ 
+ }  // namespace art
+diff -ur art_aosp/libdexfile/dex/descriptors_names.cc art/libdexfile/dex/descriptors_names.cc
+--- art_aosp/libdexfile/dex/descriptors_names.cc	2021-01-29 11:02:30.463568859 +0800
++++ art/libdexfile/dex/descriptors_names.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -21,6 +21,8 @@
+ 
+ #include "base/macros.h"
+ #include "dex/utf-inl.h"
++#include <string.h>
++#include <algorithm>
+ 
+ namespace art {
+ 
+diff -ur art_aosp/libdexfile/dex/dex_file.cc art/libdexfile/dex/dex_file.cc
+--- art_aosp/libdexfile/dex/dex_file.cc	2021-01-29 11:02:29.831563300 +0800
++++ art/libdexfile/dex/dex_file.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -400,7 +400,7 @@
+ }
+ 
+ // Given a signature place the type ids into the given vector
+-bool DexFile::CreateTypeList(std::string_view signature,
++bool DexFile::CreateTypeList(StringView signature,
+                              dex::TypeIndex* return_type_idx,
+                              std::vector<dex::TypeIndex>* param_type_idxs) const {
+   if (signature[0] != '(') {
+diff -ur art_aosp/libdexfile/dex/dex_file.h art/libdexfile/dex/dex_file.h
+--- art_aosp/libdexfile/dex/dex_file.h	2021-01-29 11:02:29.947564321 +0800
++++ art/libdexfile/dex/dex_file.h	2021-01-29 10:34:50.016986900 +0800
+@@ -19,7 +19,7 @@
+ 
+ #include <memory>
+ #include <string>
+-#include <string_view>
++#include "string_view_format.h"
+ #include <vector>
+ 
+ #include <android-base/logging.h>
+@@ -262,7 +262,7 @@
+   const char* StringDataAndUtf16LengthByIdx(dex::StringIndex idx, uint32_t* utf16_length) const;
+ 
+   const char* StringDataByIdx(dex::StringIndex idx) const;
+-  std::string_view StringViewByIdx(dex::StringIndex idx) const;
++  StringView StringViewByIdx(dex::StringIndex idx) const;
+ 
+   // Looks up a string id for a given modified utf8 string.
+   const dex::StringId* FindStringId(const char* string) const;
+@@ -480,7 +480,7 @@
+   }
+ 
+   // Given a signature place the type ids into the given vector, returns true on success
+-  bool CreateTypeList(std::string_view signature,
++  bool CreateTypeList(StringView signature,
+                       dex::TypeIndex* return_type_idx,
+                       std::vector<dex::TypeIndex>* param_type_idxs) const;
+ 
+diff -ur art_aosp/libdexfile/dex/dex_file-inl.h art/libdexfile/dex/dex_file-inl.h
+--- art_aosp/libdexfile/dex/dex_file-inl.h	2021-01-29 11:02:30.975573364 +0800
++++ art/libdexfile/dex/dex_file-inl.h	2021-01-29 10:34:50.016986900 +0800
+@@ -28,14 +28,15 @@
+ #include "dex_instruction_iterator.h"
+ #include "invoke_type.h"
+ #include "standard_dex_file.h"
++#include "string_view_format.h"
+ 
+ namespace art {
+ 
+-inline std::string_view StringViewFromUtf16Length(const char* utf8_data, size_t utf16_length) {
++inline StringView StringViewFromUtf16Length(const char* utf8_data, size_t utf16_length) {
+   size_t utf8_length = LIKELY(utf8_data[utf16_length] == 0)  // Is ASCII?
+                            ? utf16_length
+                            : utf16_length + strlen(utf8_data + utf16_length);
+-  return std::string_view(utf8_data, utf8_length);
++  return StringView(utf8_data, utf8_length);
+ }
+ 
+ inline int32_t DexFile::GetStringLength(const dex::StringId& string_id) const {
+@@ -71,10 +72,10 @@
+   return StringDataAndUtf16LengthByIdx(idx, &unicode_length);
+ }
+ 
+-inline std::string_view DexFile::StringViewByIdx(dex::StringIndex idx) const {
++inline StringView DexFile::StringViewByIdx(dex::StringIndex idx) const {
+   uint32_t unicode_length;
+   const char* data = StringDataAndUtf16LengthByIdx(idx, &unicode_length);
+-  return data != nullptr ? StringViewFromUtf16Length(data, unicode_length) : std::string_view("");
++  return data != nullptr ? StringViewFromUtf16Length(data, unicode_length) : StringView("");
+ }
+ 
+ inline const char* DexFile::StringByTypeIdx(dex::TypeIndex idx, uint32_t* unicode_length) const {
+diff -ur art_aosp/libdexfile/dex/dex_file_loader.h art/libdexfile/dex/dex_file_loader.h
+--- art_aosp/libdexfile/dex/dex_file_loader.h	2021-01-29 11:02:31.547578394 +0800
++++ art/libdexfile/dex/dex_file_loader.h	2021-01-29 10:34:50.016986900 +0800
+@@ -19,6 +19,7 @@
+ 
+ #include <cstdint>
+ #include <memory>
++#include <string.h>
+ #include <string>
+ #include <vector>
+ 
+diff -ur art_aosp/libdexfile/dex/dex_file_verifier.cc art/libdexfile/dex/dex_file_verifier.cc
+--- art_aosp/libdexfile/dex/dex_file_verifier.cc	2021-01-29 11:02:29.603561296 +0800
++++ art/libdexfile/dex/dex_file_verifier.cc	2021-01-29 10:34:50.016986900 +0800
+@@ -17,7 +17,7 @@
+ #include "dex_file_verifier.h"
+ 
+ #include <inttypes.h>
+-
++#include <algorithm>
+ #include <memory>
+ 
+ #include "android-base/stringprintf.h"
+diff -ur art_aosp/libdexfile/dex/signature.cc art/libdexfile/dex/signature.cc
+--- art_aosp/libdexfile/dex/signature.cc	2021-01-29 11:02:32.579587471 +0800
++++ art/libdexfile/dex/signature.cc	2021-01-29 10:34:50.020986935 +0800
+@@ -57,11 +57,11 @@
+   return strcmp(return_type, "V") == 0;
+ }
+ 
+-bool Signature::operator==(std::string_view rhs) const {
++bool Signature::operator==(StringView rhs) const {
+   if (dex_file_ == nullptr) {
+     return false;
+   }
+-  std::string_view tail(rhs);
++  StringView tail(rhs);
+   if (!StartsWith(tail, "(")) {
+     return false;  // Invalid signature
+   }
+@@ -69,7 +69,7 @@
+   const TypeList* params = dex_file_->GetProtoParameters(*proto_id_);
+   if (params != nullptr) {
+     for (uint32_t i = 0; i < params->Size(); ++i) {
+-      std::string_view param(dex_file_->StringByTypeIdx(params->GetTypeItem(i).type_idx_));
++      StringView param(dex_file_->StringByTypeIdx(params->GetTypeItem(i).type_idx_));
+       if (!StartsWith(tail, param)) {
+         return false;
+       }
+diff -ur art_aosp/libdexfile/dex/signature.h art/libdexfile/dex/signature.h
+--- art_aosp/libdexfile/dex/signature.h	2021-01-29 11:02:30.347567837 +0800
++++ art/libdexfile/dex/signature.h	2021-01-29 10:34:50.020986935 +0800
+@@ -19,7 +19,7 @@
+ 
+ #include <iosfwd>
+ #include <string>
+-#include <string_view>
++#include "string_view_format.h"
+ 
+ #include <android-base/logging.h>
+ 
+@@ -49,7 +49,7 @@
+     return !(*this == rhs);
+   }
+ 
+-  bool operator==(std::string_view rhs) const;
++  bool operator==(StringView rhs) const;
+ 
+  private:
+   Signature(const DexFile* dex, const dex::ProtoId& proto) : dex_file_(dex), proto_id_(&proto) {
+diff -ur art_aosp/libdexfile/dex/signature-inl.h art/libdexfile/dex/signature-inl.h
+--- art_aosp/libdexfile/dex/signature-inl.h	2021-01-29 11:02:32.063582932 +0800
++++ art/libdexfile/dex/signature-inl.h	2021-01-29 10:34:50.020986935 +0800
+@@ -36,13 +36,13 @@
+   uint32_t lhs_shorty_len;  // For a shorty utf16 length == mutf8 length.
+   const char* lhs_shorty_data = dex_file_->StringDataAndUtf16LengthByIdx(proto_id_->shorty_idx_,
+                                                                          &lhs_shorty_len);
+-  std::string_view lhs_shorty(lhs_shorty_data, lhs_shorty_len);
++  StringView lhs_shorty(lhs_shorty_data, lhs_shorty_len);
+   {
+     uint32_t rhs_shorty_len;
+     const char* rhs_shorty_data =
+         rhs.dex_file_->StringDataAndUtf16LengthByIdx(rhs.proto_id_->shorty_idx_,
+                                                      &rhs_shorty_len);
+-    std::string_view rhs_shorty(rhs_shorty_data, rhs_shorty_len);
++    StringView rhs_shorty(rhs_shorty_data, rhs_shorty_len);
+     if (lhs_shorty != rhs_shorty) {
+       return false;  // Shorty mismatch.
+     }
+@@ -56,7 +56,7 @@
+       return false;  // Return type mismatch.
+     }
+   }
+-  if (lhs_shorty.find('L', 1) != std::string_view::npos) {
++  if (lhs_shorty.find('L', 1) != StringView::npos) {
+     const dex::TypeList* params = dex_file_->GetProtoParameters(*proto_id_);
+     const dex::TypeList* rhs_params = rhs.dex_file_->GetProtoParameters(*rhs.proto_id_);
+     // We found a reference parameter in the matching shorty, so both lists must be non-empty.
+diff -ur art_aosp/libdexfile/dex/standard_dex_file.cc art/libdexfile/dex/standard_dex_file.cc
+--- art_aosp/libdexfile/dex/standard_dex_file.cc	2021-01-29 11:02:31.491577900 +0800
++++ art/libdexfile/dex/standard_dex_file.cc	2021-01-29 10:34:50.020986935 +0800
+@@ -20,6 +20,8 @@
+ #include "base/leb128.h"
+ #include "code_item_accessors-inl.h"
+ #include "dex_file-inl.h"
++#include <string.h>
++#include <algorithm>
+ 
+ namespace art {
+ 
+diff -ur art_aosp/libdexfile/external/include/art_api/dex_file_support.h art/libdexfile/external/include/art_api/dex_file_support.h
+--- art_aosp/libdexfile/external/include/art_api/dex_file_support.h	2021-01-29 11:02:33.379594509 +0800
++++ art/libdexfile/external/include/art_api/dex_file_support.h	2021-01-29 10:34:50.020986935 +0800
+@@ -22,7 +22,7 @@
+ #include <cstring>
+ #include <memory>
+ #include <string>
+-#include <string_view>
++#include "string_view_format.h"
+ #include <utility>
+ #include <vector>
+ 
+@@ -46,7 +46,7 @@
+   }
+   explicit DexString(const char* str = "")
+       : ext_string_(MakeExtDexFileString(str, std::strlen(str))) {}
+-  explicit DexString(std::string_view str)
++  explicit DexString(StringView str)
+       : ext_string_(MakeExtDexFileString(str.data(), str.size())) {}
+   ~DexString() { g_ExtDexFileFreeString(ext_string_); }
+ 
+@@ -68,10 +68,10 @@
+   }
+   size_t length() const { return size(); }
+ 
+-  operator std::string_view() const {
++  operator StringView() const {
+     size_t len;
+     const char* chars = g_ExtDexFileGetString(ext_string_, &len);
+-    return std::string_view(chars, len);
++    return StringView(chars, len);
+   }
+ 
+  private:
diff --git a/build/third_party/llvm_001.patch b/build/third_party/llvm_001.patch
new file mode 100644
index 0000000000000000000000000000000000000000..d09e4adbb13564ddd32431836209f7e8241a190c
--- /dev/null
+++ b/build/third_party/llvm_001.patch
@@ -0,0 +1,659 @@
+diff -ur llvm/include/llvm/BinaryFormat/Dwarf.def llvm_mod/include/llvm/BinaryFormat/Dwarf.def
+--- llvm/include/llvm/BinaryFormat/Dwarf.def	2021-08-05 10:44:22.675885701 +0800
++++ llvm_mod/include/llvm/BinaryFormat/Dwarf.def	2021-08-05 10:53:17.888077533 +0800
+@@ -17,7 +17,7 @@
+     defined HANDLE_DW_VIRTUALITY || defined HANDLE_DW_DEFAULTED ||             \
+     defined HANDLE_DW_CC || defined HANDLE_DW_LNS || defined HANDLE_DW_LNE ||  \
+     defined HANDLE_DW_LNCT || defined HANDLE_DW_MACRO ||                       \
+-    defined HANDLE_DW_MACRO_GNU || defined HANDLE_MACRO_FLAG ||                \
++    defined HANDLE_MACRO_FLAG ||                                               \
+     defined HANDLE_DW_RLE || defined HANDLE_DW_LLE ||                          \
+     (defined HANDLE_DW_CFA && defined HANDLE_DW_CFA_PRED) ||                   \
+     defined HANDLE_DW_APPLE_PROPERTY || defined HANDLE_DW_UT ||                \
+@@ -88,10 +88,6 @@
+ #define HANDLE_DW_MACRO(ID, NAME)
+ #endif
+ 
+-#ifndef HANDLE_DW_MACRO_GNU
+-#define HANDLE_DW_MACRO_GNU(ID, NAME)
+-#endif
+-
+ #ifndef HANDLE_MACRO_FLAG
+ #define HANDLE_MACRO_FLAG(ID, NAME)
+ #endif
+@@ -841,18 +837,6 @@
+ HANDLE_DW_MACRO(0x0b, define_strx)
+ HANDLE_DW_MACRO(0x0c, undef_strx)
+ 
+-// GNU .debug_macro extension.
+-HANDLE_DW_MACRO_GNU(0x01, define)
+-HANDLE_DW_MACRO_GNU(0x02, undef)
+-HANDLE_DW_MACRO_GNU(0x03, start_file)
+-HANDLE_DW_MACRO_GNU(0x04, end_file)
+-HANDLE_DW_MACRO_GNU(0x05, define_indirect)
+-HANDLE_DW_MACRO_GNU(0x06, undef_indirect)
+-HANDLE_DW_MACRO_GNU(0x07, transparent_include)
+-HANDLE_DW_MACRO_GNU(0x08, define_indirect_alt)
+-HANDLE_DW_MACRO_GNU(0x09, undef_indirect_alt)
+-HANDLE_DW_MACRO_GNU(0x0a, transparent_include_alt)
+-
+ // DWARF v5 Macro header flags.
+ HANDLE_MACRO_FLAG(0x01, OFFSET_SIZE)
+ HANDLE_MACRO_FLAG(0x02, DEBUG_LINE_OFFSET)
+@@ -909,7 +893,7 @@
+ HANDLE_DW_CFA(0x16, val_expression)
+ // Vendor extensions:
+ HANDLE_DW_CFA_PRED(0x1d, MIPS_advance_loc8, SELECT_MIPS64)
+-HANDLE_DW_CFA_PRED(0x2d, GNU_window_save, SELECT_SPARC)
++//HANDLE_DW_CFA_PRED(0x2d, GNU_window_save, SELECT_SPARC)
+ HANDLE_DW_CFA_PRED(0x2d, AARCH64_negate_ra_state, SELECT_AARCH64)
+ HANDLE_DW_CFA_PRED(0x2e, GNU_args_size, SELECT_X86)
+ 
+@@ -1002,7 +986,6 @@
+ #undef HANDLE_DW_LNE
+ #undef HANDLE_DW_LNCT
+ #undef HANDLE_DW_MACRO
+-#undef HANDLE_DW_MACRO_GNU
+ #undef HANDLE_MACRO_FLAG
+ #undef HANDLE_DW_RLE
+ #undef HANDLE_DW_LLE
+diff -ur llvm/include/llvm/BinaryFormat/Dwarf.h llvm_mod/include/llvm/BinaryFormat/Dwarf.h
+--- llvm/include/llvm/BinaryFormat/Dwarf.h	2021-08-05 10:44:22.675885701 +0800
++++ llvm_mod/include/llvm/BinaryFormat/Dwarf.h	2021-08-05 10:53:21.308129313 +0800
+@@ -1,4 +1,4 @@
+-//===-- llvm/BinaryFormat/Dwarf.h ---Dwarf Constants-------------*- C++ -*-===//
++//===-- Dwarf.h ---Dwarf Constants-------------*- C++ -*-===//
+ //
+ // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ // See https://llvm.org/LICENSE.txt for license information.
+@@ -19,21 +19,6 @@
+ #ifndef LLVM_BINARYFORMAT_DWARF_H
+ #define LLVM_BINARYFORMAT_DWARF_H
+ 
+-#include "llvm/ADT/Optional.h"
+-#include "llvm/Support/Compiler.h"
+-#include "llvm/Support/DataTypes.h"
+-#include "llvm/Support/ErrorHandling.h"
+-#include "llvm/Support/Format.h"
+-#include "llvm/Support/FormatVariadicDetails.h"
+-#include "llvm/ADT/Triple.h"
+-
+-#include <limits>
+-
+-namespace llvm {
+-class StringRef;
+-
+-namespace dwarf {
+-
+ //===----------------------------------------------------------------------===//
+ // DWARF constants as gleaned from the DWARF Debugging Information Format V.5
+ // reference manual http://www.dwarfstd.org/.
+@@ -43,7 +28,7 @@
+ // enumeration base type.
+ 
+ enum LLVMConstants : uint32_t {
+-  // LLVM mock tags (see also llvm/BinaryFormat/Dwarf.def).
++  // LLVM mock tags (see also Dwarf.def).
+   DW_TAG_invalid = ~0U,        // Tag for invalid results.
+   DW_VIRTUALITY_invalid = ~0U, // Virtuality for invalid results.
+   DW_MACINFO_invalid = ~0U,    // Macinfo type for invalid results.
+@@ -84,7 +69,7 @@
+ 
+ enum Tag : uint16_t {
+ #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) DW_TAG_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_TAG_lo_user = 0x4080,
+   DW_TAG_hi_user = 0xffff,
+   DW_TAG_user_base = 0x1000 ///< Recommended base for user tags.
+@@ -97,39 +82,38 @@
+ #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND)                         \
+   case DW_TAG_##NAME:                                                          \
+     return (KIND == DW_KIND_TYPE);
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   }
+ }
+ 
+ /// Attributes.
+ enum Attribute : uint16_t {
+ #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) DW_AT_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_AT_lo_user = 0x2000,
+   DW_AT_hi_user = 0x3fff,
+ };
+ 
+ enum Form : uint16_t {
+ #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) DW_FORM_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_FORM_lo_user = 0x1f00, ///< Not specified by DWARF.
+ };
+ 
+ enum LocationAtom {
+ #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) DW_OP_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_OP_lo_user = 0xe0,
+   DW_OP_hi_user = 0xff,
+-  DW_OP_LLVM_fragment = 0x1000,         ///< Only used in LLVM metadata.
+-  DW_OP_LLVM_convert = 0x1001,          ///< Only used in LLVM metadata.
+-  DW_OP_LLVM_tag_offset = 0x1002,       ///< Only used in LLVM metadata.
+-  DW_OP_LLVM_entry_value = 0x1003,      ///< Only used in LLVM metadata.
+-  DW_OP_LLVM_implicit_pointer = 0x1004, ///< Only used in LLVM metadata.
++  DW_OP_LLVM_fragment = 0x1000,    ///< Only used in LLVM metadata.
++  DW_OP_LLVM_convert = 0x1001,     ///< Only used in LLVM metadata.
++  DW_OP_LLVM_tag_offset = 0x1002,  ///< Only used in LLVM metadata.
++  DW_OP_LLVM_entry_value = 0x1003, ///< Only used in LLVM metadata.
+ };
+ 
+ enum TypeKind : uint8_t {
+ #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) DW_ATE_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_ATE_lo_user = 0x80,
+   DW_ATE_hi_user = 0xff
+ };
+@@ -146,7 +130,7 @@
+ enum EndianityEncoding {
+   // Endianity attribute values
+ #define HANDLE_DW_END(ID, NAME) DW_END_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_END_lo_user = 0x40,
+   DW_END_hi_user = 0xff
+ };
+@@ -167,26 +151,25 @@
+ 
+ enum VirtualityAttribute {
+ #define HANDLE_DW_VIRTUALITY(ID, NAME) DW_VIRTUALITY_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_VIRTUALITY_max = 0x02
+ };
+ 
+ enum DefaultedMemberAttribute {
+ #define HANDLE_DW_DEFAULTED(ID, NAME) DW_DEFAULTED_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_DEFAULTED_max = 0x02
+ };
+ 
+ enum SourceLanguage {
+ #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
+   DW_LANG_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_LANG_lo_user = 0x8000,
+   DW_LANG_hi_user = 0xffff
+ };
+ 
+ inline bool isCPlusPlus(SourceLanguage S) {
+-  bool result = false;
+   // Deliberately enumerate all the language options so we get a warning when
+   // new language options are added (-Wswitch) that'll hopefully help keep this
+   // switch up-to-date when new C++ versions are added.
+@@ -195,8 +178,7 @@
+   case DW_LANG_C_plus_plus_03:
+   case DW_LANG_C_plus_plus_11:
+   case DW_LANG_C_plus_plus_14:
+-    result = true;
+-    break;
++    return true;
+   case DW_LANG_C89:
+   case DW_LANG_C:
+   case DW_LANG_Ada83:
+@@ -235,68 +217,8 @@
+   case DW_LANG_BORLAND_Delphi:
+   case DW_LANG_lo_user:
+   case DW_LANG_hi_user:
+-    result = false;
+-    break;
+-  }
+-
+-  return result;
+-}
+-
+-inline bool isFortran(SourceLanguage S) {
+-  bool result = false;
+-  // Deliberately enumerate all the language options so we get a warning when
+-  // new language options are added (-Wswitch) that'll hopefully help keep this
+-  // switch up-to-date when new Fortran versions are added.
+-  switch (S) {
+-  case DW_LANG_Fortran77:
+-  case DW_LANG_Fortran90:
+-  case DW_LANG_Fortran95:
+-  case DW_LANG_Fortran03:
+-  case DW_LANG_Fortran08:
+-    result = true;
+-    break;
+-  case DW_LANG_C89:
+-  case DW_LANG_C:
+-  case DW_LANG_Ada83:
+-  case DW_LANG_C_plus_plus:
+-  case DW_LANG_Cobol74:
+-  case DW_LANG_Cobol85:
+-  case DW_LANG_Pascal83:
+-  case DW_LANG_Modula2:
+-  case DW_LANG_Java:
+-  case DW_LANG_C99:
+-  case DW_LANG_Ada95:
+-  case DW_LANG_PLI:
+-  case DW_LANG_ObjC:
+-  case DW_LANG_ObjC_plus_plus:
+-  case DW_LANG_UPC:
+-  case DW_LANG_D:
+-  case DW_LANG_Python:
+-  case DW_LANG_OpenCL:
+-  case DW_LANG_Go:
+-  case DW_LANG_Modula3:
+-  case DW_LANG_Haskell:
+-  case DW_LANG_C_plus_plus_03:
+-  case DW_LANG_C_plus_plus_11:
+-  case DW_LANG_OCaml:
+-  case DW_LANG_Rust:
+-  case DW_LANG_C11:
+-  case DW_LANG_Swift:
+-  case DW_LANG_Julia:
+-  case DW_LANG_Dylan:
+-  case DW_LANG_C_plus_plus_14:
+-  case DW_LANG_RenderScript:
+-  case DW_LANG_BLISS:
+-  case DW_LANG_Mips_Assembler:
+-  case DW_LANG_GOOGLE_RenderScript:
+-  case DW_LANG_BORLAND_Delphi:
+-  case DW_LANG_lo_user:
+-  case DW_LANG_hi_user:
+-    result = false;
+-    break;
++    return false;
+   }
+-
+-  return result;
+ }
+ 
+ enum CaseSensitivity {
+@@ -310,7 +232,7 @@
+ enum CallingConvention {
+ // Calling convention codes
+ #define HANDLE_DW_CC(ID, NAME) DW_CC_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_CC_lo_user = 0x40,
+   DW_CC_hi_user = 0xff
+ };
+@@ -338,20 +260,20 @@
+ /// Line Number Standard Opcode Encodings.
+ enum LineNumberOps : uint8_t {
+ #define HANDLE_DW_LNS(ID, NAME) DW_LNS_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+ };
+ 
+ /// Line Number Extended Opcode Encodings.
+ enum LineNumberExtendedOps {
+ #define HANDLE_DW_LNE(ID, NAME) DW_LNE_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_LNE_lo_user = 0x80,
+   DW_LNE_hi_user = 0xff
+ };
+ 
+ enum LineNumberEntryFormat {
+ #define HANDLE_DW_LNCT(ID, NAME) DW_LNCT_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_LNCT_lo_user = 0x2000,
+   DW_LNCT_hi_user = 0x3fff,
+ };
+@@ -368,36 +290,28 @@
+ /// DWARF v5 macro information entry type encodings.
+ enum MacroEntryType {
+ #define HANDLE_DW_MACRO(ID, NAME) DW_MACRO_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_MACRO_lo_user = 0xe0,
+   DW_MACRO_hi_user = 0xff
+ };
+ 
+-/// GNU .debug_macro macro information entry type encodings.
+-enum GnuMacroEntryType {
+-#define HANDLE_DW_MACRO_GNU(ID, NAME) DW_MACRO_GNU_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
+-  DW_MACRO_GNU_lo_user = 0xe0,
+-  DW_MACRO_GNU_hi_user = 0xff
+-};
+-
+ /// DWARF v5 range list entry encoding values.
+ enum RnglistEntries {
+ #define HANDLE_DW_RLE(ID, NAME) DW_RLE_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+ };
+ 
+ /// DWARF v5 loc list entry encoding values.
+ enum LoclistEntries {
+ #define HANDLE_DW_LLE(ID, NAME) DW_LLE_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+ };
+ 
+ /// Call frame instruction encodings.
+ enum CallFrameInfo {
+ #define HANDLE_DW_CFA(ID, NAME) DW_CFA_##NAME = ID,
+ #define HANDLE_DW_CFA_PRED(ID, NAME, ARCH) DW_CFA_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_CFA_extended = 0x00,
+ 
+   DW_CFA_lo_user = 0x1c,
+@@ -433,20 +347,20 @@
+ /// ObjCPropertyAttribute::Kind!
+ enum ApplePropertyAttributes {
+ #define HANDLE_DW_APPLE_PROPERTY(ID, NAME) DW_APPLE_PROPERTY_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+ };
+ 
+ /// Constants for unit types in DWARF v5.
+ enum UnitType : unsigned char {
+ #define HANDLE_DW_UT(ID, NAME) DW_UT_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_UT_lo_user = 0x80,
+   DW_UT_hi_user = 0xff
+ };
+ 
+ enum Index {
+ #define HANDLE_DW_IDX(ID, NAME) DW_IDX_##NAME = ID,
+-#include "llvm/BinaryFormat/Dwarf.def"
++#include "Dwarf.def"
+   DW_IDX_lo_user = 0x2000,
+   DW_IDX_hi_user = 0x3fff
+ };
+@@ -465,7 +379,7 @@
+   }
+ }
+ 
+-inline bool isUnitType(dwarf::Tag T) {
++inline bool isUnitType(Tag T) {
+   switch (T) {
+   case DW_TAG_compile_unit:
+   case DW_TAG_type_unit:
+@@ -502,275 +416,6 @@
+   DW_hash_function_djb = 0u
+ };
+ 
+-// Constants for the GNU pubnames/pubtypes extensions supporting gdb index.
+-enum GDBIndexEntryKind {
+-  GIEK_NONE,
+-  GIEK_TYPE,
+-  GIEK_VARIABLE,
+-  GIEK_FUNCTION,
+-  GIEK_OTHER,
+-  GIEK_UNUSED5,
+-  GIEK_UNUSED6,
+-  GIEK_UNUSED7
+-};
+-
+ enum GDBIndexEntryLinkage { GIEL_EXTERNAL, GIEL_STATIC };
+ 
+-/// \defgroup DwarfConstantsDumping Dwarf constants dumping functions
+-///
+-/// All these functions map their argument's value back to the
+-/// corresponding enumerator name or return an empty StringRef if the value
+-/// isn't known.
+-///
+-/// @{
+-StringRef TagString(unsigned Tag);
+-StringRef ChildrenString(unsigned Children);
+-StringRef AttributeString(unsigned Attribute);
+-StringRef FormEncodingString(unsigned Encoding);
+-StringRef OperationEncodingString(unsigned Encoding);
+-StringRef AttributeEncodingString(unsigned Encoding);
+-StringRef DecimalSignString(unsigned Sign);
+-StringRef EndianityString(unsigned Endian);
+-StringRef AccessibilityString(unsigned Access);
+-StringRef DefaultedMemberString(unsigned DefaultedEncodings);
+-StringRef VisibilityString(unsigned Visibility);
+-StringRef VirtualityString(unsigned Virtuality);
+-StringRef LanguageString(unsigned Language);
+-StringRef CaseString(unsigned Case);
+-StringRef ConventionString(unsigned Convention);
+-StringRef InlineCodeString(unsigned Code);
+-StringRef ArrayOrderString(unsigned Order);
+-StringRef LNStandardString(unsigned Standard);
+-StringRef LNExtendedString(unsigned Encoding);
+-StringRef MacinfoString(unsigned Encoding);
+-StringRef MacroString(unsigned Encoding);
+-StringRef GnuMacroString(unsigned Encoding);
+-StringRef RangeListEncodingString(unsigned Encoding);
+-StringRef LocListEncodingString(unsigned Encoding);
+-StringRef CallFrameString(unsigned Encoding, Triple::ArchType Arch);
+-StringRef ApplePropertyString(unsigned);
+-StringRef UnitTypeString(unsigned);
+-StringRef AtomTypeString(unsigned Atom);
+-StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind);
+-StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage);
+-StringRef IndexString(unsigned Idx);
+-StringRef FormatString(DwarfFormat Format);
+-StringRef FormatString(bool IsDWARF64);
+-StringRef RLEString(unsigned RLE);
+-/// @}
+-
+-/// \defgroup DwarfConstantsParsing Dwarf constants parsing functions
+-///
+-/// These functions map their strings back to the corresponding enumeration
+-/// value or return 0 if there is none, except for these exceptions:
+-///
+-/// \li \a getTag() returns \a DW_TAG_invalid on invalid input.
+-/// \li \a getVirtuality() returns \a DW_VIRTUALITY_invalid on invalid input.
+-/// \li \a getMacinfo() returns \a DW_MACINFO_invalid on invalid input.
+-///
+-/// @{
+-unsigned getTag(StringRef TagString);
+-unsigned getOperationEncoding(StringRef OperationEncodingString);
+-unsigned getVirtuality(StringRef VirtualityString);
+-unsigned getLanguage(StringRef LanguageString);
+-unsigned getCallingConvention(StringRef LanguageString);
+-unsigned getAttributeEncoding(StringRef EncodingString);
+-unsigned getMacinfo(StringRef MacinfoString);
+-unsigned getMacro(StringRef MacroString);
+-/// @}
+-
+-/// \defgroup DwarfConstantsVersioning Dwarf version for constants
+-///
+-/// For constants defined by DWARF, returns the DWARF version when the constant
+-/// was first defined. For vendor extensions, if there is a version-related
+-/// policy for when to emit it, returns a version number for that policy.
+-/// Otherwise returns 0.
+-///
+-/// @{
+-unsigned TagVersion(Tag T);
+-unsigned AttributeVersion(Attribute A);
+-unsigned FormVersion(Form F);
+-unsigned OperationVersion(LocationAtom O);
+-unsigned AttributeEncodingVersion(TypeKind E);
+-unsigned LanguageVersion(SourceLanguage L);
+-/// @}
+-
+-/// \defgroup DwarfConstantsVendor Dwarf "vendor" for constants
+-///
+-/// These functions return an identifier describing "who" defined the constant,
+-/// either the DWARF standard itself or the vendor who defined the extension.
+-///
+-/// @{
+-unsigned TagVendor(Tag T);
+-unsigned AttributeVendor(Attribute A);
+-unsigned FormVendor(Form F);
+-unsigned OperationVendor(LocationAtom O);
+-unsigned AttributeEncodingVendor(TypeKind E);
+-unsigned LanguageVendor(SourceLanguage L);
+-/// @}
+-
+-Optional<unsigned> LanguageLowerBound(SourceLanguage L);
+-
+-/// The size of a reference determined by the DWARF 32/64-bit format.
+-inline uint8_t getDwarfOffsetByteSize(DwarfFormat Format) {
+-  switch (Format) {
+-  case DwarfFormat::DWARF32:
+-    return 4;
+-  case DwarfFormat::DWARF64:
+-    return 8;
+-  }
+-  llvm_unreachable("Invalid Format value");
+-}
+-
+-/// A helper struct providing information about the byte size of DW_FORM
+-/// values that vary in size depending on the DWARF version, address byte
+-/// size, or DWARF32/DWARF64.
+-struct FormParams {
+-  uint16_t Version;
+-  uint8_t AddrSize;
+-  DwarfFormat Format;
+-
+-  /// The definition of the size of form DW_FORM_ref_addr depends on the
+-  /// version. In DWARF v2 it's the size of an address; after that, it's the
+-  /// size of a reference.
+-  uint8_t getRefAddrByteSize() const {
+-    if (Version == 2)
+-      return AddrSize;
+-    return getDwarfOffsetByteSize();
+-  }
+-
+-  /// The size of a reference is determined by the DWARF 32/64-bit format.
+-  uint8_t getDwarfOffsetByteSize() const {
+-    return dwarf::getDwarfOffsetByteSize(Format);
+-  }
+-
+-  explicit operator bool() const { return Version && AddrSize; }
+-};
+-
+-/// Get the byte size of the unit length field depending on the DWARF format.
+-inline uint8_t getUnitLengthFieldByteSize(DwarfFormat Format) {
+-  switch (Format) {
+-  case DwarfFormat::DWARF32:
+-    return 4;
+-  case DwarfFormat::DWARF64:
+-    return 12;
+-  }
+-  llvm_unreachable("Invalid Format value");
+-}
+-
+-/// Get the fixed byte size for a given form.
+-///
+-/// If the form has a fixed byte size, then an Optional with a value will be
+-/// returned. If the form is always encoded using a variable length storage
+-/// format (ULEB or SLEB numbers or blocks) then None will be returned.
+-///
+-/// \param Form DWARF form to get the fixed byte size for.
+-/// \param Params DWARF parameters to help interpret forms.
+-/// \returns Optional<uint8_t> value with the fixed byte size or None if
+-/// \p Form doesn't have a fixed byte size.
+-Optional<uint8_t> getFixedFormByteSize(dwarf::Form Form, FormParams Params);
+-
+-/// Tells whether the specified form is defined in the specified version,
+-/// or is an extension if extensions are allowed.
+-bool isValidFormForVersion(Form F, unsigned Version, bool ExtensionsOk = true);
+-
+-/// Returns the symbolic string representing Val when used as a value
+-/// for attribute Attr.
+-StringRef AttributeValueString(uint16_t Attr, unsigned Val);
+-
+-/// Returns the symbolic string representing Val when used as a value
+-/// for atom Atom.
+-StringRef AtomValueString(uint16_t Atom, unsigned Val);
+-
+-/// Describes an entry of the various gnu_pub* debug sections.
+-///
+-/// The gnu_pub* kind looks like:
+-///
+-/// 0-3  reserved
+-/// 4-6  symbol kind
+-/// 7    0 == global, 1 == static
+-///
+-/// A gdb_index descriptor includes the above kind, shifted 24 bits up with the
+-/// offset of the cu within the debug_info section stored in those 24 bits.
+-struct PubIndexEntryDescriptor {
+-  GDBIndexEntryKind Kind;
+-  GDBIndexEntryLinkage Linkage;
+-  PubIndexEntryDescriptor(GDBIndexEntryKind Kind, GDBIndexEntryLinkage Linkage)
+-      : Kind(Kind), Linkage(Linkage) {}
+-  /* implicit */ PubIndexEntryDescriptor(GDBIndexEntryKind Kind)
+-      : Kind(Kind), Linkage(GIEL_EXTERNAL) {}
+-  explicit PubIndexEntryDescriptor(uint8_t Value)
+-      : Kind(
+-            static_cast<GDBIndexEntryKind>((Value & KIND_MASK) >> KIND_OFFSET)),
+-        Linkage(static_cast<GDBIndexEntryLinkage>((Value & LINKAGE_MASK) >>
+-                                                  LINKAGE_OFFSET)) {}
+-  uint8_t toBits() const {
+-    return Kind << KIND_OFFSET | Linkage << LINKAGE_OFFSET;
+-  }
+-
+-private:
+-  enum {
+-    KIND_OFFSET = 4,
+-    KIND_MASK = 7 << KIND_OFFSET,
+-    LINKAGE_OFFSET = 7,
+-    LINKAGE_MASK = 1 << LINKAGE_OFFSET
+-  };
+-};
+-
+-template <typename Enum> struct EnumTraits : public std::false_type {};
+-
+-template <> struct EnumTraits<Attribute> : public std::true_type {
+-  static constexpr char Type[3] = "AT";
+-  static constexpr StringRef (*StringFn)(unsigned) = &AttributeString;
+-};
+-
+-template <> struct EnumTraits<Form> : public std::true_type {
+-  static constexpr char Type[5] = "FORM";
+-  static constexpr StringRef (*StringFn)(unsigned) = &FormEncodingString;
+-};
+-
+-template <> struct EnumTraits<Index> : public std::true_type {
+-  static constexpr char Type[4] = "IDX";
+-  static constexpr StringRef (*StringFn)(unsigned) = &IndexString;
+-};
+-
+-template <> struct EnumTraits<Tag> : public std::true_type {
+-  static constexpr char Type[4] = "TAG";
+-  static constexpr StringRef (*StringFn)(unsigned) = &TagString;
+-};
+-
+-template <> struct EnumTraits<LineNumberOps> : public std::true_type {
+-  static constexpr char Type[4] = "LNS";
+-  static constexpr StringRef (*StringFn)(unsigned) = &LNStandardString;
+-};
+-
+-template <> struct EnumTraits<LocationAtom> : public std::true_type {
+-  static constexpr char Type[3] = "OP";
+-  static constexpr StringRef (*StringFn)(unsigned) = &OperationEncodingString;
+-};
+-
+-inline uint64_t computeTombstoneAddress(uint8_t AddressByteSize) {
+-  return std::numeric_limits<uint64_t>::max() >> (8 - AddressByteSize) * 8;
+-}
+-
+-} // End of namespace dwarf
+-
+-/// Dwarf constants format_provider
+-///
+-/// Specialization of the format_provider template for dwarf enums. Unlike the
+-/// dumping functions above, these format unknown enumerator values as
+-/// DW_TYPE_unknown_1234 (e.g. DW_TAG_unknown_ffff).
+-template <typename Enum>
+-struct format_provider<Enum, std::enable_if_t<dwarf::EnumTraits<Enum>::value>> {
+-  static void format(const Enum &E, raw_ostream &OS, StringRef Style) {
+-    StringRef Str = dwarf::EnumTraits<Enum>::StringFn(E);
+-    if (Str.empty()) {
+-      OS << "DW_" << dwarf::EnumTraits<Enum>::Type << "_unknown_"
+-         << llvm::format("%x", E);
+-    } else
+-      OS << Str;
+-  }
+-};
+-} // End of namespace llvm
+-
+ #endif
diff --git a/build/third_party/patch.sh b/build/third_party/patch.sh
new file mode 100644
index 0000000000000000000000000000000000000000..647ba0f34807bfaa40c99d440c44170c4f04cb95
--- /dev/null
+++ b/build/third_party/patch.sh
@@ -0,0 +1,71 @@
+#!/bin/bash
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+THIRD_PARTY_PATH=$MAPLE_ROOT/third_party
+TOOLS_PATH=$MAPLE_ROOT/build/third_party
+AOSP_PATH=$THIRD_PARTY_PATH/aosp_10.0.0_r35
+AOSP_GN_PATH=$TOOLS_PATH/aosp_gn
+LLVM_PATH=$THIRD_PARTY_PATH/llvm-12.0.0.src
+MODIFIED_AOSP_PATH=$THIRD_PARTY_PATH/aosp_modified
+MODIFIED_LLVM_PATH=$THIRD_PARTY_PATH/llvm_modified
+
+function install_patch {
+    if [ -d $MODIFIED_AOSP_PATH ];then
+        echo "Already Patched."
+        exit 0
+    fi
+
+    echo "Preparing the build environment..."
+
+    #backup source code
+    cd $THIRD_PARTY_PATH
+    cp -rH $AOSP_PATH $MODIFIED_AOSP_PATH
+    cp -rH $LLVM_PATH $MODIFIED_LLVM_PATH
+
+    #patch
+    cd $MODIFIED_AOSP_PATH
+    patch -p0 < $TOOLS_PATH/system_001.patch
+    patch -p0 < $TOOLS_PATH/art_001.patch
+    mkdir -p include/
+    cp -r ${MAPLE_ROOT}/src/hir2mpl/bytecode_input/dex/include/string_view_format.h include/
+
+    cd $MODIFIED_LLVM_PATH
+    patch -p0 < $TOOLS_PATH/llvm_001.patch
+
+    #add third_party gn
+    cp -f $AOSP_GN_PATH/art/libdexfile/BUILD.gn $MODIFIED_AOSP_PATH/art/libdexfile/
+    cp -f $AOSP_GN_PATH/system/core/libziparchive/BUILD.gn $MODIFIED_AOSP_PATH/system/core/libziparchive/
+    cp -f $AOSP_GN_PATH/system/core/base/BUILD.gn $MODIFIED_AOSP_PATH/system/core/base/
+}
+
+
+function uninstall_patch {
+    rm -rf $MODIFIED_AOSP_PATH $MODIFIED_LLVM_PATH
+}
+
+function main {
+    if [ "x$1" == "xpatch" ]; then
+        install_patch
+    fi
+
+    if [ "x$1" == "xunpatch" ]; then
+        uninstall_patch
+    fi
+    cd $MAPLE_ROOT
+}
+
+
+main $@
diff --git a/build/third_party/system_001.patch b/build/third_party/system_001.patch
new file mode 100644
index 0000000000000000000000000000000000000000..a9c5aa77f2859f45158071c39b3f98980dcaa0ce
--- /dev/null
+++ b/build/third_party/system_001.patch
@@ -0,0 +1,476 @@
+diff -ur system_aosp/core/base/cmsg.cpp system/core/base/cmsg.cpp
+--- system_aosp/core/base/cmsg.cpp	2021-01-29 10:43:34.145594722 +0800
++++ system/core/base/cmsg.cpp	2021-01-29 10:36:40.905961768 +0800
+@@ -21,7 +21,7 @@
+ #include <stdlib.h>
+ #include <sys/socket.h>
+ #include <sys/user.h>
+-
++#include <unistd.h>
+ #include <memory>
+
+ #include <android-base/logging.h>
+@@ -33,7 +33,7 @@
+                                  const std::vector<int>& fds) {
+   size_t cmsg_space = CMSG_SPACE(sizeof(int) * fds.size());
+   size_t cmsg_len = CMSG_LEN(sizeof(int) * fds.size());
+-  if (cmsg_space >= PAGE_SIZE) {
++  if (cmsg_space >= sysconf(_SC_PAGE_SIZE)) {
+     errno = ENOMEM;
+     return -1;
+   }
+@@ -75,7 +75,7 @@
+   fds->clear();
+
+   size_t cmsg_space = CMSG_SPACE(sizeof(int) * max_fds);
+-  if (cmsg_space >= PAGE_SIZE) {
++  if (cmsg_space >= sysconf(_SC_PAGE_SIZE)) {
+     errno = ENOMEM;
+     return -1;
+   }
+diff -ur system_aosp/core/base/include/android-base/logging.h system/core/base/include/android-base/logging.h
+--- system_aosp/core/base/include/android-base/logging.h	2021-01-29 10:43:34.145594722 +0800
++++ system/core/base/include/android-base/logging.h	2021-01-29 10:36:40.905961768 +0800
+@@ -81,7 +81,7 @@
+
+ enum LogSeverity {
+   VERBOSE,
+-  DEBUG,
++  DEBUG_S,
+   INFO,
+   WARNING,
+   ERROR,
+@@ -181,7 +181,7 @@
+ // Note: DO NOT USE DIRECTLY. This is an implementation detail.
+ #define SEVERITY_LAMBDA(severity) ([&]() {    \
+   using ::android::base::VERBOSE;             \
+-  using ::android::base::DEBUG;               \
++  using ::android::base::DEBUG_S;             \
+   using ::android::base::INFO;                \
+   using ::android::base::WARNING;             \
+   using ::android::base::ERROR;               \
+@@ -248,7 +248,7 @@
+ // Logs a message to logcat with the specified log ID on Android otherwise to
+ // stderr. If the severity is FATAL it also causes an abort.
+ // Use an expression here so we can support the << operator following the macro,
+-// like "LOG(DEBUG) << xxx;".
++// like "LOG(DEBUG_S) << xxx;".
+ #define LOG_TO(dest, severity) LOGGING_PREAMBLE(severity) && LOG_STREAM_TO(dest, severity)
+
+ // A variant of LOG that also logs the current errno value. To be used when
+diff -ur system_aosp/core/base/include/android-base/strings.h system/core/base/include/android-base/strings.h
+--- system_aosp/core/base/include/android-base/strings.h	2021-01-29 10:43:34.145594722 +0800
++++ system/core/base/include/android-base/strings.h	2021-01-29 10:36:40.905961768 +0800
+@@ -19,6 +19,7 @@
+ #include <sstream>
+ #include <string>
+ #include <vector>
++#include "string_view_format.h"
+
+ namespace android {
+ namespace base {
+@@ -56,17 +57,17 @@
+ extern template std::string Join(const std::vector<const char*>&, const std::string&);
+
+ // Tests whether 's' starts with 'prefix'.
+-bool StartsWith(std::string_view s, std::string_view prefix);
+-bool StartsWith(std::string_view s, char prefix);
+-bool StartsWithIgnoreCase(std::string_view s, std::string_view prefix);
++bool StartsWith(StringView s, StringView prefix);
++bool StartsWith(StringView s, char prefix);
++bool StartsWithIgnoreCase(StringView s, StringView prefix);
+
+ // Tests whether 's' ends with 'suffix'.
+-bool EndsWith(std::string_view s, std::string_view suffix);
+-bool EndsWith(std::string_view s, char suffix);
+-bool EndsWithIgnoreCase(std::string_view s, std::string_view suffix);
++bool EndsWith(StringView s, StringView suffix);
++bool EndsWith(StringView s, char suffix);
++bool EndsWithIgnoreCase(StringView s, StringView suffix);
+
+ // Tests whether 'lhs' equals 'rhs', ignoring case.
+-bool EqualsIgnoreCase(std::string_view lhs, std::string_view rhs);
++bool EqualsIgnoreCase(StringView lhs, StringView rhs);
+
+ }  // namespace base
+ }  // namespace android
+diff -ur system_aosp/core/base/logging.cpp system/core/base/logging.cpp
+--- system_aosp/core/base/logging.cpp	2021-01-29 10:43:34.145594722 +0800
++++ system/core/base/logging.cpp	2021-01-29 10:36:40.905961768 +0800
+@@ -16,10 +16,11 @@
+
+ #if defined(_WIN32)
+ #include <windows.h>
++#include "android-base/threads.h"
+ #endif
+
+ #include "android-base/logging.h"
+-
++#include <string.h>
+ #include <fcntl.h>
+ #include <inttypes.h>
+ #include <libgen.h>
+@@ -167,7 +168,7 @@
+   static constexpr int kLogSeverityToKernelLogLevel[] = {
+       [android::base::VERBOSE] = 7,              // KERN_DEBUG (there is no verbose kernel log
+                                                  //             level)
+-      [android::base::DEBUG] = 7,                // KERN_DEBUG
++      [android::base::DEBUG_S] = 7,              // KERN_DEBUG_S
+       [android::base::INFO] = 6,                 // KERN_INFO
+       [android::base::WARNING] = 4,              // KERN_WARNING
+       [android::base::ERROR] = 3,                // KERN_ERROR
+@@ -310,7 +311,7 @@
+           gMinimumLogSeverity = VERBOSE;
+           continue;
+         case 'd':
+-          gMinimumLogSeverity = DEBUG;
++          gMinimumLogSeverity = DEBUG_S;
+           continue;
+         case 'i':
+           gMinimumLogSeverity = INFO;
+diff -ur system_aosp/core/base/mapped_file.cpp system/core/base/mapped_file.cpp
+--- system_aosp/core/base/mapped_file.cpp	2021-01-29 10:43:34.145594722 +0800
++++ system/core/base/mapped_file.cpp	2021-01-29 10:36:40.905961768 +0800
+@@ -76,7 +76,7 @@
+   if (base_ != nullptr) UnmapViewOfFile(base_);
+   if (handle_ != nullptr) CloseHandle(handle_);
+ #else
+-  if (base_ != nullptr) munmap(base_, size_ + offset_);
++  if (base_ != nullptr) munmap(base_, size_);
+ #endif
+
+   base_ = nullptr;
+diff -ur system_aosp/core/base/strings.cpp system/core/base/strings.cpp
+--- system_aosp/core/base/strings.cpp	2021-01-29 10:43:34.145594722 +0800
++++ system/core/base/strings.cpp	2021-01-29 10:36:40.905961768 +0800
+@@ -87,32 +87,32 @@
+ template std::string Join(const std::vector<std::string>&, const std::string&);
+ template std::string Join(const std::vector<const char*>&, const std::string&);
+
+-bool StartsWith(std::string_view s, std::string_view prefix) {
++bool StartsWith(StringView s, StringView prefix) {
+   return s.substr(0, prefix.size()) == prefix;
+ }
+
+-bool StartsWith(std::string_view s, char prefix) {
++bool StartsWith(StringView s, char prefix) {
+   return !s.empty() && s.front() == prefix;
+ }
+
+-bool StartsWithIgnoreCase(std::string_view s, std::string_view prefix) {
++bool StartsWithIgnoreCase(StringView s, StringView prefix) {
+   return s.size() >= prefix.size() && strncasecmp(s.data(), prefix.data(), prefix.size()) == 0;
+ }
+
+-bool EndsWith(std::string_view s, std::string_view suffix) {
++bool EndsWith(StringView s, StringView suffix) {
+   return s.size() >= suffix.size() && s.substr(s.size() - suffix.size(), suffix.size()) == suffix;
+ }
+
+-bool EndsWith(std::string_view s, char suffix) {
++bool EndsWith(StringView s, char suffix) {
+   return !s.empty() && s.back() == suffix;
+ }
+
+-bool EndsWithIgnoreCase(std::string_view s, std::string_view suffix) {
++bool EndsWithIgnoreCase(StringView s, StringView suffix) {
+   return s.size() >= suffix.size() &&
+          strncasecmp(s.data() + (s.size() - suffix.size()), suffix.data(), suffix.size()) == 0;
+ }
+
+-bool EqualsIgnoreCase(std::string_view lhs, std::string_view rhs) {
++bool EqualsIgnoreCase(StringView lhs, StringView rhs) {
+   return lhs.size() == rhs.size() && strncasecmp(lhs.data(), rhs.data(), lhs.size()) == 0;
+ }
+
+diff -ur system_aosp/core/include/cutils/android_filesystem_config.h system/core/include/cutils/android_filesystem_config.h
+--- system_aosp/core/include/cutils/android_filesystem_config.h	2021-01-29 10:43:42.185665405 +0800
++++ system/core/include/cutils/android_filesystem_config.h	2021-01-29 10:36:40.909961804 +0800
+@@ -144,6 +144,7 @@
+ /* The range 2900-2999 is reserved for OEM, and must never be
+  * used here */
+ #define AID_OEM_RESERVED_START 2900
++#define AID_HDB           2901  /* access hdbservice */
+ #define AID_OEM_RESERVED_END 2999
+
+ /* The 3000 series are intended for use as supplemental group id's only.
+@@ -161,6 +162,38 @@
+
+ /* The range 5000-5999 is also reserved for OEM, and must never be used here. */
+ #define AID_OEM_RESERVED_2_START 5000
++
++/* Huawei Extend AID */
++/*
++ * 1. ALL huawei extend AID should add VENDOR prefix,e.g. AID_VENDOR_XXXX
++ * 2. If the added AID was used in vendor partition only, Add it to config.fs
++ *    vendor/huawei/chipset_common/config/common/config.fs
++ * 3. Huawei AID range:
++ *    AID used in system partition: 5501-5900
++ *    AID used in vendor partiton only: 5900-5999
++ * 4. wiki: http://3ms.huawei.com/hi/group/2844405/wiki_5160709.html?for_statistic_from=creation_group_wiki
++*/
++
++#define AID_VENDOR_HDB 5501 /* access hdbservice*/
++
++#define AID_VENDOR_DSM 5502 /* dsm access */
++
++#define AID_VENDOR_HWHFD 5503 /* Huawei kernel hot fix daemon */
++
++#define AID_VENDOR_SKYTONE 5504 /* access skytone */
++
++#define AID_VENDOR_ACT_RCS 5505 /* access device actr */
++
++#define AID_VENDOR_ODMF 5506 /* access AI model files */
++
++#define AID_VENDOR_INSTALLER 5507  /* access installer files */
++
++#define AID_VENDOR_HBS    5508 /* access hbs data */
++
++#define AID_DSM 5509 /* dsm access */
++
++#define AID_VENDOR_FACEID 5510 /* acess faceid */
++
+ #define AID_OEM_RESERVED_2_END 5999
+
+ #define AID_EVERYBODY 9997 /* shared between all apps in the same profile */
+diff -ur system_aosp/core/include/cutils/fs.h system/core/include/cutils/fs.h
+--- system_aosp/core/include/cutils/fs.h	2021-01-29 10:43:42.185665405 +0800
++++ system/core/include/cutils/fs.h	2021-01-29 10:36:40.909961804 +0800
+@@ -45,6 +45,14 @@
+  */
+ extern int fs_prepare_dir(const char* path, mode_t mode, uid_t uid, gid_t gid);
+
++/* DTS2016051401335 AR000485VM FixUid l00214442 20160514 begin */
++/*
++ * Ensure that directory exists with given mode and owners.  If it exists
++ * with a different mode or owners, they are fixed to match the given values recursively.
++ */
++extern int fs_prepare_dir_fixup_recursive(const char* path, mode_t mode, uid_t uid, gid_t gid, int allow_fixup);
++/* DTS2016051401335 AR000485VM FixUid l00214442 20160514 end */
++
+ /*
+  * Ensure that directory exists with given mode and owners.  If it exists
+  * with different owners, they are not fixed and -1 is returned.
+diff -ur system_aosp/core/include/cutils/trace.h system/core/include/cutils/trace.h
+--- system_aosp/core/include/cutils/trace.h	2021-01-29 10:43:42.185665405 +0800
++++ system/core/include/cutils/trace.h	2021-01-29 10:36:40.909961804 +0800
+@@ -18,7 +18,6 @@
+ #define _LIBS_CUTILS_TRACE_H
+
+ #include <inttypes.h>
+-#include <stdatomic.h>
+ #include <stdbool.h>
+ #include <stdint.h>
+ #include <stdio.h>
+@@ -88,7 +87,7 @@
+ #elif ATRACE_TAG > ATRACE_TAG_VALID_MASK
+ #error ATRACE_TAG must be defined to be one of the tags defined in cutils/trace.h
+ #endif
+-
++using namespace std;
+ /**
+  * Opens the trace file for writing and reads the property for initial tags.
+  * The atrace.tags.enableflags property sets the tags to trace.
+diff -ur system_aosp/core/include/log/log_id.h system/core/include/log/log_id.h
+--- system_aosp/core/include/log/log_id.h	2021-01-29 10:43:42.185665405 +0800
++++ system/core/include/log/log_id.h	2021-01-29 10:36:40.909961804 +0800
+@@ -58,6 +58,8 @@
+ log_id_t android_name_to_log_id(const char* logName);
+ const char* android_log_id_to_name(log_id_t log_id);
+
++int __hwlog_setparam(int paramid, const char *val);
++
+ #ifdef __cplusplus
+ }
+ #endif
+diff -ur system_aosp/core/include/private/android_filesystem_config.h system/core/include/private/android_filesystem_config.h
+--- system_aosp/core/include/private/android_filesystem_config.h	2021-01-29 10:43:42.185665405 +0800
++++ system/core/include/private/android_filesystem_config.h	2021-01-29 10:36:40.909961804 +0800
+@@ -144,6 +144,7 @@
+ /* The range 2900-2999 is reserved for OEM, and must never be
+  * used here */
+ #define AID_OEM_RESERVED_START 2900
++#define AID_HDB           2901  /* access hdbservice */
+ #define AID_OEM_RESERVED_END 2999
+
+ /* The 3000 series are intended for use as supplemental group id's only.
+@@ -161,6 +162,38 @@
+
+ /* The range 5000-5999 is also reserved for OEM, and must never be used here. */
+ #define AID_OEM_RESERVED_2_START 5000
++
++/* Huawei Extend AID */
++/*
++ * 1. ALL huawei extend AID should add VENDOR prefix,e.g. AID_VENDOR_XXXX
++ * 2. If the added AID was used in vendor partition only, Add it to config.fs
++ *    vendor/huawei/chipset_common/config/common/config.fs
++ * 3. Huawei AID range:
++ *    AID used in system partition: 5501-5900
++ *    AID used in vendor partiton only: 5900-5999
++ * 4. wiki: http://3ms.huawei.com/hi/group/2844405/wiki_5160709.html?for_statistic_from=creation_group_wiki
++*/
++
++#define AID_VENDOR_HDB 5501 /* access hdbservice*/
++
++#define AID_VENDOR_DSM 5502 /* dsm access */
++
++#define AID_VENDOR_HWHFD 5503 /* Huawei kernel hot fix daemon */
++
++#define AID_VENDOR_SKYTONE 5504 /* access skytone */
++
++#define AID_VENDOR_ACT_RCS 5505 /* access device actr */
++
++#define AID_VENDOR_ODMF 5506 /* access AI model files */
++
++#define AID_VENDOR_INSTALLER 5507  /* access installer files */
++
++#define AID_VENDOR_HBS    5508 /* access hbs data */
++
++#define AID_DSM 5509 /* dsm access */
++
++#define AID_VENDOR_FACEID 5510 /* acess faceid */
++
+ #define AID_OEM_RESERVED_2_END 5999
+
+ #define AID_EVERYBODY 9997 /* shared between all apps in the same profile */
+diff -ur system_aosp/core/include/utils/Flattenable.h system/core/include/utils/Flattenable.h
+--- system_aosp/core/include/utils/Flattenable.h	2021-01-29 10:43:42.189665440 +0800
++++ system/core/include/utils/Flattenable.h	2021-01-29 10:36:40.909961804 +0800
+@@ -47,12 +47,7 @@
+
+     template<size_t N>
+     static size_t align(void*& buffer) {
+-        static_assert(!(N & (N - 1)), "Can only align to a power of 2.");
+-        void* b = buffer;
+-        buffer = reinterpret_cast<void*>((uintptr_t(buffer) + (N-1)) & ~(N-1));
+-        size_t delta = size_t(uintptr_t(buffer) - uintptr_t(b));
+-        memset(b, 0, delta);
+-        return delta;
++        return align<N>( const_cast<void const*&>(buffer) );
+     }
+
+     static void advance(void*& buffer, size_t& size, size_t offset) {
+diff -ur system_aosp/core/include/utils/String8.h system/core/include/utils/String8.h
+--- system_aosp/core/include/utils/String8.h	2021-01-29 10:43:42.189665440 +0800
++++ system/core/include/utils/String8.h	2021-01-29 10:36:40.909961804 +0800
+@@ -58,6 +58,9 @@
+     explicit                    String8(const char16_t* o, size_t numChars);
+     explicit                    String8(const char32_t* o);
+     explicit                    String8(const char32_t* o, size_t numChars);
++    //fix bug of sogou input method
++    explicit                    String8(unsigned short const* o);
++    //fix bug of sogou input method
+                                 ~String8();
+
+     static inline const String8 empty();
+diff -ur system_aosp/core/liblog/include/log/log_id.h system/core/liblog/include/log/log_id.h
+--- system_aosp/core/liblog/include/log/log_id.h	2021-01-29 10:43:56.097787709 +0800
++++ system/core/liblog/include/log/log_id.h	2021-01-29 10:36:40.909961804 +0800
+@@ -58,6 +58,8 @@
+ log_id_t android_name_to_log_id(const char* logName);
+ const char* android_log_id_to_name(log_id_t log_id);
+
++int __hwlog_setparam(int paramid, const char *val);
++
+ #ifdef __cplusplus
+ }
+ #endif
+diff -ur system_aosp/core/liblog/include_vndk/log/log_id.h system/core/liblog/include_vndk/log/log_id.h
+--- system_aosp/core/liblog/include_vndk/log/log_id.h	2021-01-29 10:43:56.097787709 +0800
++++ system/core/liblog/include_vndk/log/log_id.h	2021-01-29 10:36:40.909961804 +0800
+@@ -58,6 +58,8 @@
+ log_id_t android_name_to_log_id(const char* logName);
+ const char* android_log_id_to_name(log_id_t log_id);
+
++int __hwlog_setparam(int paramid, const char *val);
++
+ #ifdef __cplusplus
+ }
+ #endif
+diff -ur system_aosp/core/liblog/liblog.map.txt system/core/liblog/liblog.map.txt
+--- system_aosp/core/liblog/liblog.map.txt	2021-01-29 10:43:56.097787709 +0800
++++ system/core/liblog/liblog.map.txt	2021-01-29 10:36:40.909961804 +0800
+@@ -63,6 +63,7 @@
+     __android_log_security; # apex
+     android_log_reset; #vndk
+     android_log_parser_reset; #vndk
++    __hwlog_setparam;
+ };
+
+ LIBLOG_PRIVATE {
+diff -ur system_aosp/core/libutils/include/utils/Flattenable.h system/core/libutils/include/utils/Flattenable.h
+--- system_aosp/core/libutils/include/utils/Flattenable.h	2021-01-29 10:44:02.421843310 +0800
++++ system/core/libutils/include/utils/Flattenable.h	2021-01-29 10:36:40.909961804 +0800
+@@ -47,12 +47,7 @@
+
+     template<size_t N>
+     static size_t align(void*& buffer) {
+-        static_assert(!(N & (N - 1)), "Can only align to a power of 2.");
+-        void* b = buffer;
+-        buffer = reinterpret_cast<void*>((uintptr_t(buffer) + (N-1)) & ~(N-1));
+-        size_t delta = size_t(uintptr_t(buffer) - uintptr_t(b));
+-        memset(b, 0, delta);
+-        return delta;
++        return align<N>( const_cast<void const*&>(buffer) );
+     }
+
+     static void advance(void*& buffer, size_t& size, size_t offset) {
+diff -ur system_aosp/core/libutils/include/utils/String8.h system/core/libutils/include/utils/String8.h
+--- system_aosp/core/libutils/include/utils/String8.h	2021-01-29 10:44:02.421843310 +0800
++++ system/core/libutils/include/utils/String8.h	2021-01-29 10:36:40.909961804 +0800
+@@ -58,6 +58,9 @@
+     explicit                    String8(const char16_t* o, size_t numChars);
+     explicit                    String8(const char32_t* o);
+     explicit                    String8(const char32_t* o, size_t numChars);
++    //fix bug of sogou input method
++    explicit                    String8(unsigned short const* o);
++    //fix bug of sogou input method
+                                 ~String8();
+
+     static inline const String8 empty();
+diff -ur system_aosp/core/libziparchive/zip_archive.cc system/core/libziparchive/zip_archive.cc
+--- system_aosp/core/libziparchive/zip_archive.cc	2021-01-29 10:44:10.001909933 +0800
++++ system/core/libziparchive/zip_archive.cc	2021-01-29 10:36:40.913961839 +0800
+@@ -33,6 +33,7 @@
+
+ #include <memory>
+ #include <vector>
++#include "string_view_format.h"
+
+ #if defined(__APPLE__)
+ #define lseek64 lseek
+@@ -103,8 +104,8 @@
+
+ static uint32_t ComputeHash(const ZipString& name) {
+ #if !defined(_WIN32)
+-  return std::hash<std::string_view>{}(
+-      std::string_view(reinterpret_cast<const char*>(name.name), name.name_length));
++  return std::hash<StringView>{}(
++      StringView(reinterpret_cast<const char*>(name.name), name.name_length));
+ #else
+   // Remove this code path once the windows compiler knows how to compile the above statement.
+   uint32_t hash = 0;
+diff -ur system_aosp/core/libziparchive/zip_archive_private.h system/core/libziparchive/zip_archive_private.h
+--- system_aosp/core/libziparchive/zip_archive_private.h	2021-01-29 10:44:10.001909933 +0800
++++ system/core/libziparchive/zip_archive_private.h	2021-01-29 10:36:40.913961839 +0800
+@@ -138,7 +138,7 @@
+
+ /**
+  * More space efficient string representation of strings in an mmaped zipped file than
+- * std::string_view or ZipString. Using ZipString as an entry in the ZipArchive hashtable wastes
++ * StringView or ZipString. Using ZipString as an entry in the ZipArchive hashtable wastes
+  * space. ZipString stores a pointer to a string (on 64 bit, 8 bytes) and the length to read from
+  * that pointer, 2 bytes. Because of alignment, the structure consumes 16 bytes, wasting 6 bytes.
+  * ZipStringOffset stores a 4 byte offset from a fixed location in the memory mapped file instead
+diff -ur system_aosp/core/libziparchive/zip_writer.cc system/core/libziparchive/zip_writer.cc
+--- system_aosp/core/libziparchive/zip_writer.cc	2021-01-29 10:44:10.001909933 +0800
++++ system/core/libziparchive/zip_writer.cc	2021-01-29 10:36:40.913961839 +0800
+@@ -358,7 +358,7 @@
+   CHECK(z_stream_->avail_out != 0);
+
+   // Prepare the input.
+-  z_stream_->next_in = reinterpret_cast<const uint8_t*>(data);
++  z_stream_->next_in = (unsigned char *)(data);
+   z_stream_->avail_in = len;
+
+   while (z_stream_->avail_in > 0) {
diff --git a/build/toolchain/BUILD.gn b/build/toolchain/BUILD.gn
new file mode 100755
index 0000000000000000000000000000000000000000..d45cde7be74dbf4cc33faff3ebd9af95e833d9f0
--- /dev/null
+++ b/build/toolchain/BUILD.gn
@@ -0,0 +1,205 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+toolchain("clang") {
+  tool("cc") {
+    depfile = "{{output}}.d"
+    command = "${GN_C_COMPILER} {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -MD -MT {{output}} -MF $depfile -o {{output}} -c {{source}}"
+    depsformat = "gcc"
+    description = "Building C object {{output}}"
+    outputs = [
+      "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
+    ]
+  }
+
+  tool("cxx") {
+    depfile = "{{output}}.d"
+    command = "${GN_CXX_COMPILER} {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} -MD -MT {{output}} -MF $depfile -o {{output}} -c {{source}}"
+    depsformat = "gcc"
+    description = "Building CXX object {{output}}"
+    outputs = [
+      "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
+    ]
+  }
+
+  tool("asm") {
+    depfile = "{{output}}.d"
+
+    #command = "${GN_C_COMPILER} -MMD -MF $depfile ${rebuild_string}{{defines}} {{include_dirs}} {{asmflags}}${extra_asmflags} -c {{source}} -o {{output}}"
+    command = "${GN_CXX_COMPILER} {{defines}} {{include_dirs}} {{asmflags}} -MD -MT {{output}} -MF $depfile -c {{source}} -o {{output}}"
+    depsformat = "gcc"
+    description = "ASM {{output}}"
+    outputs = [
+      "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
+    ]
+  }
+
+  tool("alink") {
+    rspfile = "{{output}}.rsp"
+    rspfile_content = "{{inputs}}"
+    command = "rm -f {{output}} && ${GN_AR_COMPILER} qc {{output}} ${rspfile_content} && ${GN_RANLIB_COMPILER} {{output}}"
+    description = "AR {{target_output_name}}{{output_extension}}"
+    outputs = [
+      "{{output_dir}}/{{target_output_name}}{{output_extension}}",
+    ]
+    default_output_extension = ".a"
+    default_output_dir = "${GN_ARCHIVE_OUTPUT_DIRECTORY}"
+  }
+
+  tool("solink") {
+    soname = "{{target_output_name}}{{output_extension}}"
+    sofile = "{{output_dir}}/$soname"
+    rspfile = soname + ".rsp"
+
+    #command = "${GN_CXX_COMPILER} -shared {{ldflags}} -o $soname -Wl,-soname=$soname @$rspfile {{libs}}"
+    rspfile_content = "{{inputs}} {{solibs}} {{libs}}"
+    command = "${GN_CXX_COMPILER} -fuse-ld=lld {{ldflags}} -o $sofile -shared -Wl,-soname=$soname ${rspfile_content}"
+    description = "SOLINK $soname"
+
+    # Use this for {{output_extension}} expansions unless a target manually
+    # overrides it (in which case {{output_extension}} will be what the target
+    # specifies).
+    default_output_extension = ".so"
+    outputs = [
+      sofile,
+    ]
+    link_output = sofile
+    depend_output = sofile
+
+    #output_prefix = ""
+    default_output_dir = "${GN_LIBRARY_OUTPUT_DIRECTORY}/${OPT}"
+    restat = true
+  }
+
+  tool("link") {
+    outfile = "${GN_BINARY_OUTPUT_DIRECTORY}/{{target_output_name}}{{output_extension}}"
+    rspfile = "$outfile.rsp"
+    rspfile_content = "{{inputs}}"
+
+    strip_flag = ""
+    if (GN_BUILD_TYPE == "RELEASE" && GPROF == 0) {
+      strip_flag = "-s"
+    }
+
+    command = "${GN_CXX_COMPILER} ${strip_flag} -fuse-ld=lld {{ldflags}} -o $outfile -Wl,--start-group ${rspfile_content} {{libs}} -Wl,--end-group {{solibs}}"
+
+    description = "LINK $outfile"
+    rspfile_content = "{{inputs}}"
+    outputs = [
+      outfile,
+    ]
+  }
+
+  tool("stamp") {
+    command = "touch {{output}}"
+    description = "STAMP {{output}}"
+  }
+
+  tool("copy") {
+    command = "cp -af {{source}} {{output}}"
+    description = "COPY {{source}} {{output}}"
+  }
+}
+
+toolchain("cross_compile") {
+  tool("cc") {
+    depfile = "{{output}}.d"
+    command = "${GN_C_CROSS_COMPILER} {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -MD -MT {{output}} -MF $depfile -o {{output}} -c {{source}}"
+    depsformat = "gcc"
+    description = "Building C object {{output}}"
+    outputs = [
+      "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
+    ]
+  }
+
+  tool("cxx") {
+    depfile = "{{output}}.d"
+    command = "${GN_CXX_CROSS_COMPILER} {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} -MD -MT {{output}} -MF $depfile -o {{output}} -c {{source}}"
+    depsformat = "gcc"
+    description = "Building CXX object {{output}}"
+    outputs = [
+      "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
+    ]
+  }
+
+  tool("asm") {
+    depfile = "{{output}}.d"
+    command = "${GN_CXX_CROSS_COMPILER} {{defines}} {{include_dirs}} {{asmflags}} -MD -MT {{output}} -MF $depfile -c {{source}} -o {{output}}"
+    depsformat = "gcc"
+    description = "ASM {{output}}"
+    outputs = [
+      "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
+    ]
+  }
+
+  tool("alink") {
+    rspfile = "{{output}}.rsp"
+    rspfile_content = "{{inputs}}"
+    command = "rm -f {{output}} && ${GN_AR_CROSS_COMPILER} qc {{output}} ${rspfile_content} && ${GN_RANLIB_CROSS_COMPILER} {{output}}"
+    description = "AR {{target_output_name}}{{output_extension}}"
+    rspfile_content = "{{inputs}}"
+    outputs = [
+      "{{output_dir}}/{{target_output_name}}{{output_extension}}",
+    ]
+    default_output_extension = ".a"
+    default_output_dir = "${GN_ARCHIVE_OUTPUT_DIRECTORY}"
+  }
+
+  tool("solink") {
+    soname = "{{target_output_name}}{{output_extension}}"
+    sofile = "{{output_dir}}/$soname"
+    rspfile = soname + ".rsp"
+    rspfile_content = "{{inputs}} {{solibs}} {{libs}}"
+    command = "${GN_CXX_CROSS_COMPILER} {{ldflags}} -o $sofile -shared -Wl,-soname=$soname ${rspfile_content}"
+    description = "SOLINK $soname"
+
+    # Use this for {{output_extension}} expansions unless a target manually
+    # overrides it (in which case {{output_extension}} will be what the target
+    # specifies).
+    default_output_extension = ".so"
+    outputs = [
+      sofile,
+    ]
+    link_output = sofile
+    depend_output = sofile
+
+    #output_prefix = ""
+    default_output_dir = "${GN_LIBRARY_OUTPUT_DIRECTORY}/${OPT}"
+    restat = true
+  }
+
+  tool("link") {
+    outfile = "${GN_BINARY_OUTPUT_DIRECTORY}/{{target_output_name}}{{output_extension}}"
+    rspfile = "$outfile.rsp"
+    rspfile_content = "{{inputs}}"
+
+    #command = "${GN_CXX_CROSS_COMPILER} {{ldflags}} -o $outfile @$rspfile {{solibs}} {{libs}}"
+    command = "${GN_CXX_CROSS_COMPILER} {{ldflags}} -o $outfile ${rspfile_content} {{solibs}} {{libs}}"
+    description = "LINK $outfile"
+    rspfile_content = "{{inputs}}"
+    outputs = [
+      outfile,
+    ]
+  }
+
+  tool("stamp") {
+    command = "touch {{output}}"
+    description = "STAMP {{output}}"
+  }
+
+  tool("copy") {
+    command = "cp -af {{source}} {{output}}"
+    description = "COPY {{source}} {{output}}"
+  }
+}
diff --git a/build/tools/common/bis.sh b/build/tools/common/bis.sh
new file mode 100755
index 0000000000000000000000000000000000000000..644ff36e9bda6025369a3547bcf65c7bfbfbf640
--- /dev/null
+++ b/build/tools/common/bis.sh
@@ -0,0 +1,75 @@
+
+good_dir=$1
+bad_dir=$2
+src_list=src_list.log
+pwd=$PWD
+cd $bad_dir
+sed 's/ /\n/g' obj.list > $pwd/$src_list
+cd -
+file_lenth=`sed -n '$=' $src_list`
+
+function get_src_list() {
+  min=$1
+  max=$2
+  line_number=1
+  src=" "
+  cat $src_list | while read line
+  do
+  if [ "${line_number}" -ge "${min}" ]&&[ "${line_number}" -le "${max}" ];
+  then
+    src=${src}${bad_dir}"/"${line}" "
+  else
+    src=${src}${good_dir}"/"${line}" "
+  fi
+  if [ $line_number -eq $file_lenth ];then
+    echo "${src}"
+  fi
+  line_number=`expr $line_number + 1`
+  done
+}
+
+cur_max=`sed -n '$=' $src_list`
+cur_min=1
+last_max=$cur_max
+while true
+do
+cur_src=`echo $(get_src_list $cur_min $cur_max)`
+echo $file_lenth
+bash run.sh $cur_src
+
+if [ $? -eq 0 ];then
+
+if [ $cur_min -eq $cur_max ];then
+cur_min=$last_max
+cur_max=$last_max
+cur_src=`echo $(get_src_list $cur_min $cur_max)`
+break
+fi
+
+cur_min=$cur_max
+cur_max=${last_max}
+
+else
+if [ $cur_min -eq $cur_max ];then
+cur_src=`echo $(get_src_list $cur_min $cur_max)`
+break
+fi
+last_max=$cur_max
+cur_max=$(((${cur_max}+${cur_min})/2))
+fi
+echo "==================================="
+echo "cur_min" $cur_min
+echo "cur_max" $cur_max
+echo "==================================="
+
+done
+
+bash run.sh $cur_src
+if [ $? -eq 0 ];then
+  echo "bad src not found"
+else
+  echo "=================================="
+  echo "bad src found:"
+  head -$cur_min  $src_list | tail -1
+  echo "=================================="
+fi
diff --git a/build/tools/common/bisfunc.sh b/build/tools/common/bisfunc.sh
new file mode 100755
index 0000000000000000000000000000000000000000..8ad515db2dd2e18e671da73c64fca2fbe3cd9258
--- /dev/null
+++ b/build/tools/common/bisfunc.sh
@@ -0,0 +1,132 @@
+#!/bin/bash
+bad_mpl=""
+good_dir=""
+bad_dir=""
+candidate_type="object"
+src_list=src_list.log
+pwd=${PWD}
+twd=${pwd}/temp_dir
+LINARO=${MAPLE_ROOT}/tools/gcc-linaro-7.5.0
+fileName=""
+
+function parse_args() {
+  while [ $# -ne 0 ]; do
+      case "$1" in
+          *.mpl)
+              bad_mpl=$1
+              candidate_type="mpl"
+              fileName=${bad_mpl%\.mpl*}
+              ;;
+          *)
+              if [ -d "$1" ]; then
+                good_dir=$1
+                shift
+                bad_dir=$1
+              else
+                echo "no such directory ""$1"
+                exit 1
+              fi
+              ;;
+      esac
+      shift
+  done
+}
+
+function get_cur_func_list() {
+  echo > ${twd}/temp_func.list
+  min=$1
+  max=$2
+  line_number=1
+  src=" "
+  cat ${twd}/$src_list | while read line
+  do
+  if [ "${line_number}" -ge "${min}" ]&&[ "${line_number}" -le "${max}" ];
+  then
+    echo ${line} >> ${twd}/temp_func.list
+  fi
+  line_number=`expr $line_number + 1`
+  done
+}
+
+function compileMpl() {
+  #echo "cur parto2list:"
+  #cat temp_func.list | lolcat
+  $MAPLE_ROOT/output/aarch64-clang-release/bin/maple --partO2=${twd}/temp_func.list --run=me:mpl2mpl:mplcg --option="--O2 --quiet: --O2 --quiet: --O2 --quiet --no-pie --verbose-asm" ${twd}/$bad_mpl &> comb.log
+  $LINARO/bin/aarch64-linux-gnu-gcc -O2 -std=c99 -o ${twd}/${fileName}.o -c ${twd}/${fileName}.s
+}
+
+function asmMpl() {
+  cat temp_func.list
+  python3 replace_func.py good.s bad.s ${twd}/temp_func.list > ${twd}/newgood.s
+  $LINARO/bin/aarch64-linux-gnu-gcc -O2 -std=c99 -o ${twd}/${fileName}.o -c ${twd}/newgood.s
+}
+
+function main() {
+  rm -rf ${twd}
+  cp -r $good_dir ${twd}
+  cp run.sh ${twd}/
+  #cp replace_func.py ${twd}/
+  #cp good.s ${twd}/
+  #cp bad.s ${twd}/
+  if [ "$candidate_type" == "mpl" ]; then
+    grep -E "func &.*{$" $good_dir/$bad_mpl | awk '{print $2}' | sed 's/&//g' > ${twd}/$src_list
+  else
+    sed 's/ /\n/g' $good_dir/obj.list > $twd/$src_list
+  fi
+
+  obj_list=`sed 's/ /\n/g' $good_dir/obj.list`
+  cd ${twd}
+  file_length=`sed -n '$=' $src_list`
+
+  cur_min=1
+  cur_max=$file_length
+  last_max=$cur_max
+  while true
+  do
+    get_cur_func_list $cur_min $cur_max
+    #echo $file_length
+
+    echo "==================================="
+    echo "cur_min" $cur_min
+    echo "cur_max" $cur_max
+
+    #asmMpl
+    compileMpl
+    bash run.sh $obj_list
+
+    if [ $? -eq 0 ];then
+      echo -e "\033[32mSUCCESS \033[0m"
+      if [ $cur_min -eq $cur_max ];then
+        cur_min=$last_max
+        cur_max=$last_max
+        get_cur_func_list $cur_min $cur_max
+        break
+      fi
+      cur_min=$cur_max
+      cur_max=${last_max}
+    else
+      echo -e "\033[31mFAILED \033[0m"
+      if [ $cur_min -eq $cur_max ];then
+        get_cur_func_list $cur_min $cur_max
+        break
+      fi
+      last_max=$cur_max
+      cur_max=$(((${cur_max}+${cur_min})/2))
+    fi
+    echo "==================================="
+  done
+
+  #asmMpl
+  compileMpl
+  echo "==================================="
+  bash run.sh $obj_list
+  if [ $? -eq 0 ];then
+    echo "bad func not found"
+  else
+    echo "bad func found:"
+    head -$cur_min  $src_list | tail -1
+  fi
+}
+
+parse_args $@
+main
\ No newline at end of file
diff --git a/build/tools/common/maplec b/build/tools/common/maplec
new file mode 100755
index 0000000000000000000000000000000000000000..6d0ff340990039bb46fce6644349ed53a70d9b58
--- /dev/null
+++ b/build/tools/common/maplec
@@ -0,0 +1,260 @@
+#!/bin/bash
+src_file_path=""
+target_name=""
+file_name=""
+option=""
+obj_list=""
+src_list=""
+pre_process=true
+compile=true
+assemble=true
+link=true
+out=""
+std="-std=gnu99"
+list_mode="false"
+
+# config fe compiler
+use_hir2mpl=true
+use_clang2mpl=false
+# config maple optimization level
+use_O2=true
+# config mpl or bpl
+use_bpl=false
+
+if [ "$use_bpl" == "true" ];then
+  WHIRL_OPT=""
+  suffix="bpl"
+else
+  WHIRL_OPT="-a"
+  suffix="mpl"
+fi
+
+# preifx directories
+OPENSOURCE_OUT=$MAPLE_ROOT/output
+MAPLE_BIN=$OPENSOURCE_OUT/aarch64-clang-release/bin
+TOOLS_ROOT=$MAPLE_ROOT/tools
+TOOLS_BIN=$TOOLS_ROOT/bin
+LINARO=$TOOLS_ROOT/gcc-linaro-7.5.0
+GCC=$LINARO/bin/aarch64-linux-gnu-gcc
+
+# compile flags
+ISYSTEM_FLAGS="-isystem $LINARO/aarch64-linux-gnu/libc/usr/include -isystem $LINARO/lib/gcc/aarch64-linux-gnu/7.5.0/include"
+
+# maple options
+O2="--O2 --quiet:--O2 --quiet:--O2 --quiet --verbose-asm --verbose-cg"
+O0="--O0 --quiet --verbose-asm --verbose-cg"
+
+# whole cmd of maplec.sh
+SELF_CMD="${0} ${@}"
+
+while [ $# -ne 0 ]; do
+  case "$1" in
+    -O2)
+        use_O2=true
+        ;;
+    -O0)
+        use_O2=false
+        ;;
+    -hir2mpl)
+        use_hir2mpl=true
+        use_clang2mpl=false
+        ;;
+    -clang2mpl)
+        use_hir2mpl=false
+        use_clang2mpl=true
+        ;;
+    --list)
+        shift
+        list_mode=true
+        src_list="$1"
+        ;;
+    -v)
+        exit 0
+        ;;
+    -b)
+        WHIRL_OPT=""
+        suffix="bpl"
+        ;;
+    -o)
+        shift
+        out="-o $1"
+        ;;
+    -I)
+        shift
+        option=$option"-I $1 "
+        ;;
+    -isystem)
+        shift
+        ISYSTEM_FLAGS="-isystem $1 "$ISYSTEM_FLAGS
+        ;;
+    -c)
+        link=false
+        ;;
+    -S)
+        assemble=false
+        link=false
+        ;;
+    -E)
+        compile=false
+        assemble=false
+        link=false
+        ;;
+    -include)
+        shift
+        option=$option"-include $1 "
+        ;;
+    -gcc)
+        shift
+        GCC=$1
+        ;;
+    -Werror)
+        ;;
+    -fno-pic)
+        O2=$O2" --no-fpic"
+        O0=$O0" --no-fpic"
+        ;;
+    -ffunction-sections)
+        O2=$O2" --function-sections"
+        O0=$O0" --function-sections"
+        ;;
+    -mgeneral-regs-only)
+        O2=$O2" --general-reg-only"
+        O0=$O0" --general-reg-only"
+        ;;
+    -f*)
+        ;;
+    -*)
+        option=$option"$1"" "
+        ;;
+    *.c)
+        src_file_path="$1"
+        ;;
+    *.mpl)
+        src_file_path="$1"
+        pre_process=false
+        ;;
+    *.s)
+        src_file_path="$1"
+        pre_process=false
+        compile=false
+        ;;
+    *.o)
+        obj_list=$obj_list"$1"" "
+        pre_process=false
+        compile=false
+        assemble=false
+        link=true
+        ;;
+  esac
+  shift
+done
+
+# flags for clang
+CLANG_COMMON_FLAGS="-U __SIZEOF_INT128__ $ISYSTEM_FLAGS"
+CLANGFE_FLAGS="-cc1 ${std} -emit-llvm -triple aarch64-linux-gnu -D__clang__ -D__BLOCKS__ $CLANG_COMMON_FLAGS -fgnu89-inline"
+CLANG2MPL_FLAGS="--target=aarch64-linux-elf -Wno-return-type -U__SIZEOF_INT128__"
+CLANG_FLAGS="--target=aarch64 $CLANG_COMMON_FLAGS -emit-ast"
+
+function color_print() {
+  # default -S 1050 -F 0.01
+  echo -e $1 #| lolcat -S 1050 -F 0.01
+}
+
+function excecute() {
+  outputFile=$target_name
+  echo "${@}" && echo ""
+  "${@}" 1>/dev/null 2>$outputFile || {
+    echo "" >> "$outputFile" && cat $outputFile
+    echo -e "FAILED:" "$@" | tee -a $outputFile
+    echo "" | tee -a "$outputFile"
+    echo -e "[whole compile cmd]: "$SELF_CMD >> "$outputFile"
+    echo "" >> "$outputFile" && echo "" >> "$outputFile"
+    exit 1;
+  }
+  echo ""
+}
+
+function hir2mpl() {
+  # generate .ast
+  color_print "Starting ast for $src_file_path:"
+  excecute $TOOLS_BIN/clang $CLANG_FLAGS $option $src_file_path -o $file_name.ast
+  # generate .mpl
+  color_print "Starting hir2mpl for $src_file_path:"
+  excecute $MAPLE_BIN/hir2mpl $file_name.ast --enable-variable-array
+}
+
+function clangfe() {
+  # generate .B
+  color_print "Starting clangfe for $src_file_path:"
+  excecute $OPEN64BIN/clangfe $CLANGFE_FLAGS $option $src_file_path
+  # generate .mpl
+  color_print "Starting whirl2mpl for $src_file_path:"
+  excecute $OPEN64BIN/whirl2mpl $WHIRL_OPT $file_name.B
+}
+
+function clang2mpl() {
+  # generate .mpl
+  color_print "Starting clang2mpl for $src_file_path:"
+  excecute $MAPLE_BIN/clang2mpl --ascii "$src_file_path" -- $CLANG2MPL_FLAGS $option
+}
+
+function c_to_mpl() {
+  [ "$use_clang2mpl" == "true" ] && clang2mpl && return
+  [ "$use_hir2mpl" == "true" ] && hir2mpl && return
+  clangfe
+}
+
+function maple_to_asm() {
+  color_print "Starting maplecomb for $src_file_path:"
+  run_exe=mplcg
+  maple_option=$O0
+  [ "$use_O2" == "true" ] && run_exe="me:mpl2mpl:mplcg" && maple_option=$O2
+  excecute $MAPLE_BIN/maple "--run=$run_exe" "--option=$maple_option" "${file_name}.${suffix}" --save-temps
+}
+
+function asm_to_obj() {
+  color_print "Starting asm for $src_file_path:"
+  excecute $GCC -std=c99 $option -c "${file_name}.s" $out
+  echo ""
+}
+
+function init() {
+  src_file_path=$(realpath $src_file_path)
+  target_name=${src_file_path##*/}".err"
+  file_name=${src_file_path%\.*}
+}
+
+function c_to_asm() {
+  init
+  # generate .mpl
+  c_to_mpl
+  # generate .s
+  maple_to_asm
+  # generate .o
+  asm_to_obj
+}
+
+function link() {
+  target_name=${out##* }".err"
+  echo -e $obj_list > obj.list
+  echo -e $GCC ${std} $option $obj_list $out > link.cmd
+  color_print "Starting Link ${out##* }:"
+  excecute $GCC ${std} $obj_list $option $out
+}
+
+function asm_list() {
+  cat $src_list | grep "\.c" | while read line
+  do
+    src_file_path=`echo ${line} | awk '{print $NF}'`
+    c_to_asm
+  done
+}
+
+init
+[ "$pre_process" == "true" ] && c_to_mpl
+[ "$compile" == "true" ] && maple_to_asm
+[ "$assemble" == "true" ] && asm_to_obj
+[ "$link" == "true" ] && link
+
+rm $target_name
+exit 0
diff --git a/build/tools/common/replace_func.py b/build/tools/common/replace_func.py
new file mode 100755
index 0000000000000000000000000000000000000000..32dd095547c529cbb898068a4649618a5230f379
--- /dev/null
+++ b/build/tools/common/replace_func.py
@@ -0,0 +1,151 @@
+#!/usr/bin/python3
+import sys
+import os
+import re
+
+funclist=[]
+funcMap={}
+buffer=''
+
+class AsmFunc:
+    funcName = ''
+    start = 0
+    end = 0
+    funcId = 0
+    totalLine = 0
+    realLine = 0
+    blankLine = 0
+    varRegLine = 0
+    aliasLine = 0
+    commentLine = 0
+    funcInfo = 7
+    locLine = 0
+    otherLine = 0
+    source = ''
+    locList =[]
+
+    def __str__(self):
+        return '\n'.join(['%s:%s' % item for item in self.__dict__.items()])
+    def calc(self):
+        self.totalLine = self.end - self.start - 1
+        self.realLine = self.totalLine - 1 - self.funcInfo - self.blankLine - self.varRegLine - self.aliasLine - self.locLine - self.commentLine
+
+
+def binarySearch (arr, l, r, x):
+    while l <= r:
+        mid = int(l + (r - l)/2)
+        # 元素整好的中间位置
+        if arr[mid] == x:
+            return mid
+        # 元素小于中间位置的元素，只需要再比较左边的元素
+        elif arr[mid] > x:
+            r = mid-1
+        # 元素大于中间位置的元素，只需要再比较右边的元素
+        else:
+            l = mid+1
+    # 不存在
+    return -1
+
+def readFunclist(file):
+    global funclist
+    with open(file, "r") as f:
+        for func in f:
+            funclist.append(func.strip())
+    funclist.sort()
+
+def isMatch(name):
+    global funclist
+    index = binarySearch(funclist, 0, len(funclist) - 1, name)
+    if index != -1:
+        return True
+    return False
+
+def exportToFile(list, file):
+    f = open(file, "a+")
+    i = 0
+    while i < len(list):
+        f.write(list[i].source)
+        i += 1
+    f.close()
+
+def processAsm(mpl):
+    global funcMap
+    with open(mpl, "r") as f:
+        infunc = False
+        match = False
+        flag = False
+        curfunc = AsmFunc()
+        for ori_line in f:
+            line = ori_line.strip()
+            if not match:
+                if line.endswith("%function"):
+                    funcName = line.split()[1][:-1]
+                    match=isMatch(funcName)
+                    if match:
+                        func = AsmFunc()
+                        func.funcName = funcName
+                        funcMap[funcName] = func
+                        curfunc = func
+                        continue
+            else:
+                if not infunc:
+                    if line == curfunc.funcName + ":":
+                        infunc = True
+                        curfunc.source += ori_line
+                else:
+                    curfunc.source += ori_line
+                    if line.endswith(curfunc.funcName + ", .-" + curfunc.funcName):
+                        infunc = False
+                        match = False
+
+def repaceGood(mpl):
+    global funcMap
+    with open(mpl, "r") as f:
+        infunc = False
+        match = False
+        curfunc = AsmFunc()
+        for ori_line in f:
+            line = ori_line.strip()
+            if not match:
+                print(ori_line, end='')
+                if line.endswith("%function"):
+                    funcName = line.split()[1][:-1]
+                    match=isMatch(funcName)
+                    if match:
+                        func = AsmFunc()
+                        func.funcName = funcName
+                        curfunc = func
+                        continue
+            else:
+                if not infunc:
+                    if line == curfunc.funcName + ":":
+                        print(funcMap[curfunc.funcName].source, end='')
+                        infunc = True
+                    else:
+                        print(ori_line, end='')
+                else:
+                    if line.endswith(curfunc.funcName + ", .-" + curfunc.funcName):
+                        infunc = False
+                        match = False
+
+def main():
+    if len(sys.argv) < 4 :
+        print("args count less than 4")
+        return
+    global file1
+    good = sys.argv[1]
+    bad = sys.argv[2]
+    readFunclist(sys.argv[3])
+    if os.path.isfile(bad):
+        processAsm(bad)
+    else:
+        print("file not found")
+    if os.path.isfile(good):
+        repaceGood(good)
+    else:
+        print("file not found")
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/build/tools/spec/bis.sh b/build/tools/spec/bis.sh
new file mode 120000
index 0000000000000000000000000000000000000000..5eaf823ba64478e16393288c6c6e72c1b9269495
--- /dev/null
+++ b/build/tools/spec/bis.sh
@@ -0,0 +1 @@
+../common/bis.sh
\ No newline at end of file
diff --git a/build/tools/spec/bisfunc.sh b/build/tools/spec/bisfunc.sh
new file mode 120000
index 0000000000000000000000000000000000000000..49fcfec73350cbd8807e54fbcc38dcf05a97e2cd
--- /dev/null
+++ b/build/tools/spec/bisfunc.sh
@@ -0,0 +1 @@
+../common/bisfunc.sh
\ No newline at end of file
diff --git a/build/tools/spec/clang2mpl.cfg b/build/tools/spec/clang2mpl.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..76d8c154208451f5e42ea9817a237ba0f7c12c9d
--- /dev/null
+++ b/build/tools/spec/clang2mpl.cfg
@@ -0,0 +1,687 @@
+#------------------------------------------------------------------------------
+# SPEC CPU2017 config file for: gcc / g++ / gfortran on Linux x86
+#------------------------------------------------------------------------------
+#
+# Usage: (1) Copy this to a new name
+#             cd $SPEC/config
+#             cp Example-x.cfg myname.cfg
+#        (2) Change items that are marked 'EDIT' (search for it)
+#
+# SPEC tested this config file with:
+#    Compiler version(s):    4.4.7, 4.9.2, 5.2.0, 6.3.0, 7.2.1, 8.1.0
+#    Operating system(s):    Oracle Linux Server 6.5 and 7.4 /
+#                            Red Hat Enterprise Linux Server 6.5 and 7.4
+#    Hardware:               Xeon
+#
+# If your system differs, this config file might not work.
+# You might find a better config file at http://www.spec.org/cpu2017/results
+#
+# Known Limitations with GCC 4
+#
+#   (1) Possible problem: compile time messages
+#                             error: unrecognized command line option '...'
+#      Recommendation:    Use a newer version of the compiler.
+#                         If that is not possible, remove the unrecognized
+#                         option from this config file.
+#
+#   (2) Possible problem: run time errors messages
+#           527.cam4_r or 627.cam4_s    *** Miscompare of cam4_validate.txt
+#      Recommendation: Use a newer version of the compiler.
+#                      If that is not possible, try reducing the optimization.
+#
+#
+# Compiler issues: Contact your compiler vendor, not SPEC.
+# For SPEC help:   http://www.spec.org/cpu2017/Docs/techsupport.html
+#------------------------------------------------------------------------------
+
+
+#--------- Label --------------------------------------------------------------
+# Arbitrary string to tag binaries (no spaces allowed)
+#                  Two Suggestions: # (1) EDIT this label as you try new ideas.
+%define label maplec               # (2)      Use a label meaningful to *you*.
+
+
+#--------- Preprocessor -------------------------------------------------------
+%ifndef %{bits}                # EDIT to control 32 or 64 bit compilation.  Or,
+%   define  bits        64     #      you can set it on the command line using:
+%endif                         #      'runcpu --define bits=nn'
+
+%ifndef %{build_ncpus}         # EDIT to adjust number of simultaneous compiles.
+%   define  build_ncpus 8      #      Or, you can set it on the command line:
+%endif                         #      'runcpu --define build_ncpus=nn'
+
+# Don't change this part.
+%define    os           LINUX
+%if %{bits} == 64
+%   define model        -m64
+%elif %{bits} == 32
+%   define model        -m32
+%else
+%   error Please define number of bits - see instructions in config file
+%endif
+%if %{label} =~ m/ /
+%   error Your label "%{label}" contains spaces.  Please try underscores instead.
+%endif
+%if %{label} !~ m/^[a-zA-Z0-9._-]+$/
+%   error Illegal character in label "%{label}".  Please use only alphanumerics, underscore, hyphen, and period.
+%endif
+
+
+
+#--------- Global Settings ----------------------------------------------------
+# For info, see:
+#            https://www.spec.org/cpu2017/Docs/config.html#fieldname
+#   Example: https://www.spec.org/cpu2017/Docs/config.html#tune
+
+command_add_redirect = 1
+flagsurl             = $[top]/config/flags/gcc.xml
+ignore_errors        = 1
+iterations           = 1
+label                = %{label}-m%{bits}
+line_width           = 1020
+log_line_width       = 1020
+makeflags            = --jobs=%{build_ncpus}
+mean_anyway          = 1
+output_format        = txt,html,cfg,pdf,csv
+preenv               = 1
+reportable           = 0
+tune                 = base
+
+
+#--------- How Many CPUs? -----------------------------------------------------
+# Both SPECrate and SPECspeed can test multiple chips / cores / hw threads
+#    - For SPECrate,  you set the number of copies.
+#    - For SPECspeed, you set the number of threads.
+# See: https://www.spec.org/cpu2017/Docs/system-requirements.html#MultipleCPUs
+#
+#    q. How many should I set?
+#    a. Unknown, you will have to try it and see!
+#
+# To get you started, some suggestions:
+#
+#     copies - This config file defaults to testing only 1 copy.   You might
+#              try changing it to match the number of cores on your system,
+#              or perhaps the number of virtual CPUs as reported by:
+#                     grep -c processor /proc/cpuinfo
+#              Be sure you have enough memory.  See:
+#              https://www.spec.org/cpu2017/Docs/system-requirements.html#memory
+#
+#     threads - This config file sets a starting point.  You could try raising
+#               it.  A higher thread count is much more likely to be useful for
+#               fpspeed than for intspeed.
+#
+intrate,fprate:
+   copies           = 1   # EDIT to change number of copies (see above)
+intspeed,fpspeed:
+   threads          = 4   # EDIT to change number of OpenMP threads (see above)
+
+%ifndef %{gcc_dir}
+%   define  gcc_dir        /gcc_dir-is-not-used/tools/gcc-linaro-7.5.0  # EDIT (see above)
+%endif
+
+#------- Compilers ------------------------------------------------------------
+default:
+#  EDIT: The parent directory for your compiler.
+#        Do not include the trailing /bin/
+#        Do not include a trailing slash
+#  Examples:
+#   1  On a Red Hat system, you said
+#      'yum install devtoolset-7'
+#      Use:                 %   define gcc_dir /opt/rh/devtoolset-7/root/usr
+#
+#   2  You built GCC in:                       /disk1/mybuild/gcc-8.1.0/bin/gcc
+#      Use:                 %   define gcc_dir /disk1/mybuild/gcc-8.1.0
+#
+#   3  You want:                               /usr/bin/gcc
+#      Use:                 %   define gcc_dir /usr
+#      WARNING: See section
+#      "Known Limitations with GCC 4"
+#
+   LINARO                  = $MAPLE_ROOT/tools/gcc-linaro-7.5.0
+   CC                      = $(MAPLE_ROOT)/build/tools/spec/maplec -clang2mpl
+   CXX                     = $(LINARO)/bin/aarch64-linux-gnu-g++ -std=c++03
+   FC                      = $(LINARO)/bin/aarch64-linux-gnu-gfortran
+   # How to say "Show me your version, please"
+   CC_VERSION_OPTION       = -v
+   CXX_VERSION_OPTION      = -v
+   FC_VERSION_OPTION       = -v
+
+   QEMU_RUN                = $MAPLE_ROOT/tools/bin/qemu-aarch64 -L $LINARO/aarch64-linux-gnu/libc
+
+default:
+%if %{bits} == 64
+   sw_base_ptrsize = 64-bit
+   sw_peak_ptrsize = 64-bit
+%else
+   sw_base_ptrsize = 32-bit
+   sw_peak_ptrsize = 32-bit
+%endif
+
+
+#--------- Portability --------------------------------------------------------
+default:               # data model applies to all benchmarks
+%if %{bits} == 32
+    # Strongly recommended because at run-time, operations using modern file
+    # systems may fail spectacularly and frequently (or, worse, quietly and
+    # randomly) if a program does not accommodate 64-bit metadata.
+    EXTRA_PORTABILITY = -D_FILE_OFFSET_BITS=64
+%else
+    EXTRA_PORTABILITY = -DSPEC_LP64
+%endif
+
+# Benchmark-specific portability (ordered by last 2 digits of bmark number)
+
+500.perlbench_r,600.perlbench_s:  #lang='C'
+%if %{bits} == 32
+%   define suffix IA32
+%else
+%   define suffix X64
+%endif
+   PORTABILITY    = -DSPEC_%{os}_%{suffix}
+
+502.gcc_r:  #lang='c'
+   CPORTABILITY  = -DHAVE_ALLOCA_H
+
+521.wrf_r,621.wrf_s:  #lang='F,C'
+   CPORTABILITY  = -DSPEC_CASE_FLAG
+   FPORTABILITY  = -fconvert=big-endian
+
+523.xalancbmk_r,623.xalancbmk_s:  #lang='CXX'
+   PORTABILITY   = -DSPEC_%{os}
+
+526.blender_r:  #lang='CXX,C'
+   PORTABILITY   = -funsigned-char -DSPEC_LINUX
+
+527.cam4_r,627.cam4_s:  #lang='F,C'
+   PORTABILITY   = -DSPEC_CASE_FLAG
+
+628.pop2_s:  #lang='F,C'
+   CPORTABILITY    = -DSPEC_CASE_FLAG
+   FPORTABILITY    = -fconvert=big-endian
+
+
+#-------- Tuning Flags common to Base and Peak --------------------------------
+
+#
+# Speed (OpenMP and Autopar allowed)
+#
+%if %{bits} == 32
+   intspeed,fpspeed:
+   #
+   # Many of the speed benchmarks (6nn.benchmark_s) do not fit in 32 bits
+   # If you wish to run SPECint2017_speed or SPECfp2017_speed, please use
+   #
+   #     runcpu --define bits=64
+   #
+   fail_build = 1
+%else
+   intspeed,fpspeed:
+      EXTRA_OPTIMIZE = -fopenmp -lgomp -DSPEC_OPENMP
+   fpspeed:
+      #
+      # 627.cam4 needs a big stack; the preENV will apply it to all
+      # benchmarks in the set, as required by the rules.
+      #
+      preENV_OMP_STACKSIZE = 120M
+%endif
+
+
+#--------  Baseline Tuning Flags ----------------------------------------------
+#
+# EDIT if needed -- Older GCC might not support some of the optimization
+#                   switches here.  See also 'About the -fno switches' below.
+#
+default=base:         # flags for all base
+   OPTIMIZE       = 
+
+intrate,intspeed=base: # flags for integer base
+   EXTRA_COPTIMIZE = 
+# Notes about the above
+#  - 500.perlbench_r/600.perlbench_s needs -fno-strict-aliasing.
+#  - 502.gcc_r/602.gcc_s             needs -fgnu89-inline or -z muldefs
+#  - For 'base', all benchmarks in a set must use the same options.
+#  - Therefore, all base benchmarks get the above.  See:
+#       www.spec.org/cpu2017/Docs/runrules.html#BaseFlags
+#       www.spec.org/cpu2017/Docs/benchmarks/500.perlbench_r.html
+#       www.spec.org/cpu2017/Docs/benchmarks/502.gcc_r.html
+
+
+#--------  Peak Tuning Flags ----------------------------------------------
+default=peak:
+   basepeak = yes  # if you develop some peak tuning, remove this line.
+   #
+   # -----------------------
+   # About the -fno switches
+   # -----------------------
+   #
+   # For 'base', this config file (conservatively) disables some optimizations.
+   # You might want to try turning some of them back on, by creating a 'peak'
+   # section here, with individualized benchmark options:
+   #
+   #        500.perlbench_r=peak:
+   #           OPTIMIZE = this
+   #        502.gcc_r=peak:
+   #           OPTIMIZE = that
+   #        503.bwaves_r=peak:
+   #           OPTIMIZE = other   .....(and so forth)
+   #
+   # If you try it:
+   #   - You must remove the 'basepeak' option, above.
+   #   - You will need time and patience, to diagnose and avoid any errors.
+   #   - perlbench is unlikely to work with strict aliasing
+   #   - Some floating point benchmarks may get wrong answers, depending on:
+   #         the particular chip
+   #         the version of GCC
+   #         other optimizations enabled
+   #         -m32 vs. -m64
+   #   - See: http://www.spec.org/cpu2017/Docs/config.html
+   #   - and: http://www.spec.org/cpu2017/Docs/runrules.html
+
+
+#------------------------------------------------------------------------------
+# Tester and System Descriptions - EDIT all sections below this point
+#------------------------------------------------------------------------------
+#   For info about any field, see
+#             https://www.spec.org/cpu2017/Docs/config.html#fieldname
+#   Example:  https://www.spec.org/cpu2017/Docs/config.html#hw_memory
+#-------------------------------------------------------------------------------
+
+#--------- EDIT to match your version -----------------------------------------
+default:
+   sw_compiler001   = C/C++/Fortran: Version 7.2.1 of GCC, the
+   sw_compiler002   = GNU Compiler Collection
+
+#--------- EDIT info about you ------------------------------------------------
+# To understand the difference between hw_vendor/sponsor/tester, see:
+#     https://www.spec.org/cpu2017/Docs/config.html#test_sponsor
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+   hw_vendor          = My Corporation
+   tester             = My Corporation
+   test_sponsor       = My Corporation
+   license_num        = nnn (Your SPEC license number)
+#  prepared_by        = # Ima Pseudonym                       # Whatever you like: is never output
+
+
+#--------- EDIT system availability dates -------------------------------------
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+                        # Example                             # Brief info about field
+   hw_avail           = # Nov-2099                            # Date of LAST hardware component to ship
+   sw_avail           = # Nov-2099                            # Date of LAST software component to ship
+
+#--------- EDIT system information --------------------------------------------
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+                        # Example                             # Brief info about field
+#  hw_cpu_name        = # Intel Xeon E9-9999 v9               # chip name
+   hw_cpu_nominal_mhz = # 9999                                # Nominal chip frequency, in MHz
+   hw_cpu_max_mhz     = # 9999                                # Max chip frequency, in MHz
+#  hw_disk            = # 9 x 9 TB SATA III 9999 RPM          # Size, type, other perf-relevant info
+   hw_model           = # TurboBlaster 3000                   # system model name
+#  hw_nchips          = # 99                                  # number chips enabled
+   hw_ncores          = # 9999                                # number cores enabled
+   hw_ncpuorder       = # 1-9 chips                           # Ordering options
+   hw_nthreadspercore = # 9                                   # number threads enabled per core
+   hw_other           = # TurboNUMA Router 10 Gb              # Other perf-relevant hw, or "None"
+
+#  hw_memory001       = # 999 GB (99 x 9 GB 2Rx4 PC4-2133P-R, # The 'PCn-etc' is from the JEDEC
+#  hw_memory002       = # running at 1600 MHz)                # label on the DIMM.
+
+   hw_pcache          = # 99 KB I + 99 KB D on chip per core  # Primary cache size, type, location
+   hw_scache          = # 99 KB I+D on chip per 9 cores       # Second cache or "None"
+   hw_tcache          = # 9 MB I+D on chip per chip           # Third  cache or "None"
+   hw_ocache          = # 9 GB I+D off chip per system board  # Other cache or "None"
+
+   fw_bios            = # American Megatrends 39030100 02/29/2016 # Firmware information
+#  sw_file            = # ext99                               # File system
+#  sw_os001           = # Linux Sailboat                      # Operating system
+#  sw_os002           = # Distribution 7.2 SP1                # and version
+   sw_other           = # TurboHeap Library V8.1              # Other perf-relevant sw, or "None"
+#  sw_state           = # Run level 99                        # Software state.
+
+# Note: Some commented-out fields above are automatically set to preliminary
+# values by sysinfo
+#       https://www.spec.org/cpu2017/Docs/config.html#sysinfo
+# Uncomment lines for which you already know a better answer than sysinfo
+
+__HASH__
+500.perlbench_r=base=maple_test-m64:
+# Last updated 2021-05-10 10:36:40
+opthash=1b55f44e78c515229834a282ce9d3013fee214077130f5cc6c8d469cce53274c
+baggage=
+compiler_version=\
+@eNp9VE1v2zAMvftX+NYNteK26ZIigA9Z6hYD0qZI3e0YyBLtqJUlTx+J08N++2Qnjr202MWC+Cjy\
+kXy0P5utfsbL5x+Lx9XiKXHHxHvRTOR+ahk3iAlfl0D0wJst5vN4lqzuZ7MotFqFKRNhTsgRmCeL\
+1a/l9OkpXu4dOEtrh7C6Ga1G14gzYSuUCxuOQ24k2ipclqC8xd3dfDG9XSXT5X2crB6nD/FzJDal\
+qZCQAk7x2/hu+jJPoksvwSoHM/FP43szKTKWWwXU3zKznviDQagVCUlr99HGR6jGUPmWb0BpJkV0\
+9pJaYaw/HnwbXKChbW6Xfy5vBhfXZ61/al0AHmWMwyQMmzr1GisIqSR1tWgcLuPp7UM8+G5z7V6B\
+wCkHxLHILc5BRyTAFAfk/DzIZZAqlgc0yKQyCotApq+k/iAHu7elgoxVTTfb/HWKAr9KhQ60kRR8\
+1/jKXOECaZvVb9C4ZzvEOW0U6ug1NdAeXSbeQKFaBBSxGnDThAoIZeo43QMnaWudEG4pUOQmYqAy\
+XSSzVoCpjkqpWbWPcxLj4Ch4r12plEa7lpSdiXBJMIfIEe/zTLWhpKoQBTeazwDDCoh2oNsOUsiw\
+ddLuPHDKIgHb7nHdGyvYbwvIDQNIXQ5lusE2Zn+AYtnun3xFWXX3ktvcLc/x3mYtGbRE9E4bKNB7\
+10lkGkmfIIcItTbc+CNsjeyshQvKsCLrHsUtKCWPiqlBNLyK2OhmdLS5iovRdXttgrhkrgptomJ4\
+FTgwKKrh1UmiPlUr3CxAuD6QHsks4xLTQyG6t8c9sRBLMaKKuR72xrsG8uZ+PJECDljX/o36PqjW\
+AWvpaH5i32f9gHhJo0G/kBT4xG+U6LlF8g8rtN94/8t/9v+r7/0FuibFEg==
+compile_options=\
+@eNrVU21r2zAQ/u5fIfxdccdGWUJdsB0l8eZEwrIh2xfhOkqqLZaD5IS1v34n56UtDFpGv1RgfLq3\
+R3fP3aLVuKl+y7XaStTuOtVqO/JsZ1TdCbPXK2XEQRq1fgj9T74HogWX0L8aDK+ufc9L6JyNkB/s\
+rQnulA42dY3cwbZbhfVw6MTm+gvCNcLtGWDQIjzmjCTwW4xJXE5BYCTPREJzgnA6gG+lbBekFKR6\
+V+mgUI3EM5VLe9bMinmGWWWsNKCSf7rASBDsTtam0itIOaZlnBHBs4jPCBcOMY2y8OqELqKyoIKX\
+jOWEc0EZWcwZ2EQW5VMiJmlG+OXqboLTMk+I0/VXOplwUog4LXgINSK8QZh+hoIrU9+HuurUAV60\
+1i3ea1utJRi6e+ya0KjHqm8FOto7IyXetu0OH2TdtUY9SnQ6p7dm6aJciqWDOcUcScLVVlVWaYBe\
+b/T+6xArvVVaPotkLujGtntTy1vfS0YoScJXKTs60vgbZUXov+DP94DzhJWTLJpysL3ksrfGZJHM\
+xMXhw5Pre3SEoBPpPP1JoKL3ZLpvGKN5EcVplhY/zh194rxHJ8sij6CJT494fQr61MfAfwIwlxtg\
+vr9lh4/Kd5/x/x3wm/buFySyt85/26DLwlzmFKF+iLPxW6b9g/IL9c2jYga5Yrdp2+ZUMi3d1j5b\
+2b8rRMvz
+exehash=1c69320bf26365e65e5b19b87fd09bbfdf73b3d6257845446d6001048f92fd40
+
+619.lbm_s=base=maplec-m64:
+# Last updated 2021-05-12 16:29:02
+opthash=7affc07e1d7c5ca4633093daa05c20102ce1dec866120559a921160cddd58e76
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNqVUG1rgzAY/J5fEfLd2kEZTGpBY2ZdowlW2csXaV1kbmpE7WD/ftG+Ci1sIZCH3OVyd4GstHLz\
+JbK8EFDWXS6r1gBt1+RplzS76j1vkm/R5NmPie4QUGOrKCaaTh6mMwQAZj43INI/ZCn0dlfp27zS\
+y01diBRqasuj6ERCzVlzgtUROMSOXTVQK3RJ8szCFWWWAy+XlslaVGV9eJUwTgKfD8j+gvL7GYTz\
+Vu6aVCwQwAbE2LzqZA8y+4nxyEQjWwgo+5jHj9Ry1wobWxxQmwR4mZwIY88IMAOSlyi0lMPI8703\
+okhXvQ9ieypnYWTZHvWi1+OfQx4EqBesbvX5p37mcvsp0q5d9JyiPPNPkSEc+qDOrbL+kUjp+Fa0\
+TKhn9+UU5UGaxX3RFy3/AtPTsPg=
+exehash=4796f3d722b9339855ae459928ddcee0650c458340a971fc905fa5338976c68c
+
+505.mcf_r=base=maplec-m64:
+# Last updated 2021-05-12 17:04:02
+opthash=cd00cc44466c7c00fcb0a07a84b8bdec510af969b5da706b722633229c2d2efc
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNqNkF1PgzAYhe/7K5reM2aiJpKxBApuaKENH4leNRt2EQWKFEz89xYEdYsa3zRpk3PanvNEsjaq\
+3bM4FKWAsukKWSsLqK4t8o63ff1QtPxVtMXhzUZnCOij0hYbLRdXywsEAKYhsyAyH2UlTNXX5r6o\
+zWrXlCKHhl5yfnQhoeElzMd6izzfzTYQGoFqRM5flGy7SeVOllKeZIzFfpJwyvwoZPBkJithl+cQ\
+rpTs21ysEcAWxNj+McuHSN0bylIbHQVDQBfALLsmzibR2nHIUXX9CG85nh3/TD1e9e/S2OGMxqnj\
+BiRI7+cfxvQIkCC6/Y3fyazk/knknVoPBMrqi8ZnFQjHnsT7A0LopFtOAncoUlaTn2YDlW9I3gG2\
+95r+
+exehash=806db0e68b5994ed49999cc86262dbea2e13c31853d3ba087eb2f180c940ee06
+
+502.gcc_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=2839b1967320158040c55387a370c4661288143e5e404dc55ea5be68a750538d
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNq1kV9PgzAUxd/5FE3fGdM4E5exBLoOqqxtBhh9ajbWxSrQScHEby/g8M+ivnnTpjc5J7f9nVJd\
+2sXmSe5VLoE+1EqXZmqZulJZLaqm3KlKvMhK7V9deAattjWtxYXj0dV4Ai0LsRWfAug86EI6pimd\
+rSqdYnPIZQbsdulh6EgDexFzjNqDLrCfBsAmo247qszyZif73hxkJp6NruqjXUzG50PrpQkTccr5\
+GsexYBzTFW81QkWAurmhd4sFYnRJAhGC0zoOifjlBQAzo5sqk3NooSlAyP2R4F1k/jXjiQu/4UCr\
+xUY8XUZeELfad7Re9TFFoRgM/8ra34fvkrUnOFsnnk8iktwPz+qRoRURevPbV53UTG8fZVabeRdb\
+XnxG+MEPQB9OtPgjuZWXhCIifoefF0c/S7sov+T4BmRTt5k=
+exehash=0
+
+520.omnetpp_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=be6e4dd67b5187b3cefa0f68d2b9d0de0da20ab650fd3c3ee25c7e2e09cbff32
+baggage=
+compiler_version=\
+*IENYWENfVkVSU0lPTl9PUFRJT046Ci9iaW4vc2g6IENDOiBjb21tYW5kIG5vdCBmb3VuZAo=
+compile_options=\
+@eNq1UNFOgzAUfe9XNH1nzkRNJGMJlLqhHW2gjfjUTOgSFCgBZuLfW3E45rv3pTfnnt57zolN49T7\
+d30oKw1NO5Sm6V3QD12ZD6o7NkXZqQ/dlYdPD10jYNveUjy0XNwvbxEAmO24CxHG0MmhY6YVCwOd\
+MOXEwmEckkBuoBP1ZX2s9oPprlr7FLqdY7avTaEr++E5ElsVExHIiIYkOW1SvhRMpZLzhKSpYpzE\
+Ow7PdWJRfncD4ao3xy7XawSwC3GWeVbh1LPgkXHhoQvBCFgbmMsH6m9SO7sUP04DEuOtmgj/4WY8\
+QzKR+IqzRPhBRCPxMqkZrSFAo/jpJ/E/tTKvbzof+vUcPDuEcAyAhr9Z0JDJ7xxmIXwBBSCXiw==
+exehash=0
+
+523.xalancbmk_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=a5f92e3f29c9a9dc5714dc66815a936b3270df34bf15c51d6007f825c19a3bfd
+baggage=
+compiler_version=\
+*IENYWENfVkVSU0lPTl9PUFRJT046Ci9iaW4vc2g6IENDOiBjb21tYW5kIG5vdCBmb3VuZAo=
+compile_options=\
+@eNrtU9FumzAUfecrLL8TuqmbtKip5ICX0tnYwmaiTxZ1aEVHcIVJ1f59HZhTsk1969ssIZ17z8G6\
+3HPITBfuql/1XdPWwDwOjensMrBD3+hB9ftu2/Tqqe6bu5cV/AQDB62TrODZ4tvZFxgEMaN8CWAc\
+g1CD0PgrFgaEieDYtZMswetiAxxCnKuMKXmVY5QI1ygRQZlKM4qpomKjCEMJzkGYLtzzXPe6tvoN\
+RVuzO62iZvfYzlq2ep5V+6FpI2rviam2bu4o7Wi9M/3LnxLZV53VZtJo0z0dBFVbdTpqOt3ut7Ub\
+lefsWpWUcJSLw4jHRiFT4suJFL4UqDyPZ8VnjxNGPfyJSJogyca33HWqENhvBAuBNtgvZdynQoVk\
+ShSc545VjOOMcnA4v3mSZkV50uBfzwG4sGbvPvkSBvESxGW5cpZ5zNbXjMsVPHEQBs7XmBffCdoI\
+x526ObJrnMVXyl1w1Pw3+GMMHtfNWS7ROiWpvPF+TG6PLC5ljtQ/NS4AMHDKH9OP+nb+isyFuX2o\
+9WAvwVx1zAQAY2RIMqXn/ZlGISsOuZqF6hW+xlPZ
+exehash=0
+
+525.x264_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=17555907b69668487c703e8ad30fdca935346ca79afa0bfdc1ae288920733ee3
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNrtkt9vgjAQx9/5K5q+I+rUbUZMAJmyIW34kcynBrFu3YCagsb990PEDc22V/dA06TX3l179+nX\
+4amchO90zWIK+CZnPM2GUpYLFuVEbNMVE2RHBVt/qLADpcLMihAVtlv37T6U0DEDrLkALAlf6C6M\
+2SrMKel3+0NJMtAcDwFUXnlClWybKkuWKkm4iWkE5GLy05stDuSJh02jWJyJqQdTIFvxikZ8RTIR\
+KSwtoq19d9A7bGumQve5CLP6ScSThKfVfUQLfES8AGPX9DyCsOnM8ZlPX/gmciemq7b3ne5Nrz+4\
+vQOXo0qw8aAHwCjjWxHRMZSMITAM9cf+jk6kPyLsq/CsWSgVUAwcPNja1Ct8542XXt10jBk5BVyR\
+RFmN+ey7GsHI9TXdsi1/cSq6BAIl23KefvvmizHiyzca5dn4ADVOvgF/0QGgRGdP/uA61/wZsS39\
+ACdOqngUHEDXKNfVWREUjSgbUf4bUZZMGkk2kryuJD8BghRXuw==
+exehash=0
+
+531.deepsjeng_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=c9d27d3cf5376f585e57a3f2a29ee65eb5a8ddb7a1042d47749d036bb8f42043
+baggage=
+compiler_version=\
+*IENYWENfVkVSU0lPTl9PUFRJT046Ci9iaW4vc2g6IENDOiBjb21tYW5kIG5vdCBmb3VuZAo=
+compile_options=\
+@eNqNkF9PgzAUxd/7KW76zjKTxUQylkBbJ1poQyFhT41il9Q/1AAz8dvb4ZDNJ+/T7T2nvb/T3LXB\
+++Or2ds3A+5jsK7tQ9QPnW0G3R3aZ9vpT9PZ/VeErzDybe8tEV4ubpYrjBARmQwBEwJBA4Gbnlg4\
+CKiSzI9pTllSbY/nLOZcZywTxe4k67gqhVaVlAVTSgvJ8kzCXCcXl9crgHXvDl1jNhiREEhdR37t\
+1IvkXsgywhcUGHk2IqtbHm+V1y6JRjVhObnTs+GfiONdVpdFrKUoyjhJeVruphUjL0Y8zR9+/uZP\
+rd3Ti2mGfnM+nLEBxlSc/gbkVFTHcGfJvgF3B3iC
+exehash=0
+
+541.leela_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=c715a7e7b712428302fadbd8205a3f5ff13d2a99dbcb03cfef4de14ebb0dbb76
+baggage=
+compiler_version=\
+*IENYWENfVkVSU0lPTl9PUFRJT046Ci9iaW4vc2g6IENDOiBjb21tYW5kIG5vdCBmb3VuZAo=
+compile_options=\
+@eNp9kE9LxDAQxe/5FEPuKSuoYNkutElcq9kktCnUU9CahfqnkbYr+O2NdevuenBOw5uXmd+L9B15\
+e3hx2/bVgX8fW98NMRrGvm1G2++6p7a3H65vt58JPsMotEOwJHgRXS0uMEJUbXQMmFIgDRA/r4g8\
+EFZqHmQmGc+qNZA82ms2rYyyZaV1wcvSKs3lRsOh9i6hL88BloPf9Y1bYURjoHWdhFtzr7JbpU2C\
+T05jFICorq5Fui7D7BRjmmZc0hs7G/7nmh7w2hSp1aowaZaL3NzPeydIjEQu735+4U8t/eOza8Zh\
+dSweWAGmKIL9phJMVd+JjuJ8ASVmcYc=
+exehash=0
+
+548.exchange2_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=7c95017cd71c6e94420e5cb70d3cc0a48a81eb16a8246cb031329e6470ab6a5c
+baggage=
+compiler_version=\
+*IEZDX1ZFUlNJT05fT1BUSU9OOgovYmluL3NoOiBmOTA6IGNvbW1hbmQgbm90IGZvdW5kCg==
+compile_options=\
+@eNq9kEtPhDAUhff8iqZ7yJioCWSYhEcZ0Q5teCS6apQpSX3QhjJG/fUWBhmcuLab3vae2/OdZrK1\
+3x5feCNeOZCqF7LVnqX7TtQ96w7tXnTsnXei+fThBbRMqY3EhyvHXV1By0oo9QDUitdKATsuKIrM\
+lsUorLbTmQVVSVhRUZqjomCEomxHf3qYXl+CtZaHruYbYMu5dhqlxBffO437AS1jEtEqwcG28OGZ\
+zdgNURbdsF+CP31HMbov84BRkpdBmOK0fJhHBhxoRWQ3pGrcFbDrAWr6GEeCmc+oPJBE/qA61iS8\
+JbQ0Ty1H/hsdp9ndhH621vLpmde93iwvT6AAjClwfEqEY1INeRZhvgFuXpvb
+exehash=0
+
+557.xz_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=34d1fd17d5aa193e0a6a2c6e3f3472c24b4e41ed9de1aafdefcd23008f8b6564
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNrtk1tPwyAUx9/7KQjvXTcvUxdr0gtu1a6QXsz0hXQMHVrK0nZG/fSy6Uw7L59AAhz+nMNJzvmF\
+SJWmzJ/4vSg4UKtGqLIeGXVTCdbQal0uREWfeSXuX204gIY+1jrEhv3eWX8IDcPDUzIC0Foqya16\
+XVpzUVoyXxWcAVNPtUvaU8D0E4I8bSIfudn4U1MnSzF1b1OEYx/Fdv9lcHB4dDw8OdUBE+cGUQ9H\
+l8GYTuzB7skUTWmAd2p210mVZITEKEkoJiiaEmAGPb3qFWdUckmF2qhlbh5oy5SUqtSHQsyLN5lb\
++Uq01GZryW/RbMnZU0vXQurKWxcLXjR5J2FLVHn5wJla8Arsj896QjI8AuC8VuuK8QtoeCPgefaP\
+3f5wYvcKk9SGndZDQyPySHYZOuNE+7oYtl4XRd6EdgL+ufBq2xs0S2OHEhynjhuEQXr71aENHmiE\
+QXT92xfYG+dq/shZU190WH+BAmBLMfT/QBz6ONsAbtF9B8AAJ6o=
+exehash=0
+
+999.specrand_ir=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=2b6f45155529ef0ee94c19b9445375b5551207252ee5fb82fdcb9fe4f6f19a4c
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNp9kFFLwzAUhd/zK0Leu04UwbIO2rTOamzC1oI+lS7LMLomJWkF/72xo2KLermQwDm5+c7NtfKa\
++k0c5UlA3XZSKxsA2xnJu8r06iBN9S6MPH6E6AIBd7XOEqLl4mZ5iQDA9JEFEPkvuhG+7ZW/l8pv\
+6vYkOPRc63HoQkMv2bEUuyNP0rjcQC+zreCmVgeP66bRCs7r/KIi7PoKwpXVveFijQAOIMbhr5+e\
+RRrfU1aEaEKAgCPFrLwl0WbntCnNoMZpju+q0TDHGyzpU7GNKka3RRRnJCuex0kDJQIkyx/+Wsis\
+Vnr/Knhn15PI37wQDmFI8k9SktDyK+ePkJ/hnoeM
+exehash=0
+
+519.lbm_r=base=maplec-m64:
+# Last updated 2021-05-12 17:29:14
+opthash=55e637b326098960c2f25abcffd8e22854b4464b6ae2619ebf92ce74d672f662
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNp9kF9PgzAUxd/7KZq+M2aiJpKxBApuaKENlESfmg27WAW68MfEb2/ZcMoyvWnSNufc9nduomur\
+2rzLnSol1PtO6bp1QNs1quhE09cvqhEfslG7TxddIWCOrbG4aD67m98gADCNmQOR/aorabd9bW9V\
+bVebfSkLaJmlvx+daWgFGQux2ZIg9PPVeBdezqnIcsbSMMsEZWESM3heo5ew22sIF63um0IuEcAO\
+xNi9+P1RpP4DZdxFExYEDDNm+T3xVpnRplwH1Q8TvBYTw0XQgzl84qknGE2550ck4s+nloEXARIl\
+j38N6awWevsmi65dDpnL6if/CR7CQzIS/BM79vhakMgf2Mtq9NN8mMOvIXwB6zCRCQ==
+exehash=95e543602be6b0de89f9afd90aacb45d06bb7b32f0f2295d9571e3c9a893f901
+
+511.povray_r=base=maplec-m64:
+# Last updated 2021-05-19 14:10:44
+opthash=6681316d90fcef5a8ec9d57d1ec3590b7d32c00621a8f461b30ed5b709bb4dc3
+baggage=
+compiler_version=\
+@eNq9VUtv2zAMvvtX6NYNqaKmj7QJ4MNgBNuAYCnabOstkGXGViNLmiQ3bg/77ZPtuPaaDANWrJc4\
+FB8f+YmkUHR3F62+zW5uPy++rBbXS/+ZBijaP/tquUxRXHDhMJfIamB2GESL+XwWLVcfoygkmcqB\
+PGY5yakWsFIapFWFYUB6f51SwpKUMSy4pEbhy+HF8ITEXBJKDcvG55WiKHEqC5wOBs8Q8+Vi9f3m\
+w/X17Ob1UMMhETyGElil30cmjalwCm8N1RpMsKQmBTdFe7ZBpOSap4WBBG25y6boqMnPsW2KK8YS\
+K+gDkK0yG6sp22lyugFsQAC1sBoRK6m2mXJ1xsOUu59d1vj0ZDQZjk4Ja6GO0O2n2Xwe1tXE1GYI\
+4woc55qF/wK/qi1JY08SsC7hhvDx1Rhr1hXbwazNW+CkuX4TGN9s1PYlkXgp4ZbGArx9nBfJWlDt\
+D0E2Z051gs1odf2NvyqqEWGiSCDBvmcclK4zleIZxz5aBzl+8uF7YPZe3GMoGWjHlbSdZ5VWIfmP\
+ArCK74H1gvqCNmAaejB/kbqvnZWlrzvrHNhk0hOEYlRA2BDyHLJ1TCAu0p5CybT+acvw7ioNpWpl\
+rUVP4nYntRnlhXC8KXkXcc1LzJTxPGF6cYavzi4ux5M/q8/PzkeTNnw1jSE1+cMVpp2LywzQxIZa\
+WV52xzV05XGoTMdzCB/hBeFc+sbxXON1IVl1IS1ww7W/QqOUe02P7kLY/S3U65PXgvxtEA6sQM8M\
+6/VIBmzjn4BwF7p3oXGVvTO/DQeVaUFTsCE7ZoPB8dpfn6HyuBmaOpnw0DBmyrqDCldv3/AQRdqA\
+75D/SU6wrNsJ5SoBMUV1UwV+S6MHMLZqifq1QO/m9cJG/jFEvaX9HgW/AHQUm+k=
+compile_options=\
+@eNrtlFFPwjAQx9/3KZq+Lt1mRI2EkcA2ER1bw7YEn5pRCkyhxXYY+fZuAxTUxAcToskuWXrJXde7\
+37X/QHC0TJ/YNFswIFZ5JrhqaiqXGc2JXPNJJskLk9l0Y8MzqBWuKlJsaBnXVgNqmhMOcBNAcy6W\
+zNzMl+YyXS0YESvGlVhLyswDNxdiocwZpWiR8VQKdGVcGJY5zriZppLOLxtlYP2KZnyNZroOSkMq\
+n9hU161zgChAYl+lIQByI+w5xRK4XjfpAdSfSsFzxieFO04VKxaj+NSKUfKshMx3W0gniUMSJRgP\
+vSgiIfaCAQYftsvy8WUDgNa2+jbUnCZwRiP7NN3ujwu7dyGObXjUPNQK6g5ObvxOLypixyCqaNcL\
+nFuyT/gVmep/3igedggOh3Gn2/f78cP+2AoT/HoTykYrPvR0g/txfI79bYXb4H9B7feD+5M9uk/W\
+EuNHRnPVPgL+TguACqXvnvKV+G6YlGM7mFktTLUw1cJUC9OfE6Y3nDbadw==
+exehash=0f4659ece5065638b9268e65a56d231636b83a05ae00d17df9bf1a2ae7112f8b
+
+538.imagick_r=base=maplec-m64:
+# Last updated 2021-05-31 19:30:05
+opthash=54a10f343892c95817762d047800af2eccb783c0e3ff864fcef7d0ae46bd6135
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNrtkdFqgzAUhu/zFCH3agdlMKkFja51iyZohO0qtC5lbmqK0cHeftbqtpatDzAWAgk5fw7f/59Y\
+1Ua1eZW7opRQ7dtC1doGum2KvBVNVz8VjXiTTbF7d9AVAv1V9xIHzcyb2RwBgGnEbIisZ1VJS3e1\
+tS1qq9rsS5lDo99qamoqaPgpC3B/xH7gZStohOb4JtyMU5FmjCVBmgrKgjhi8HyNWsKu5xAutOqa\
+XC4RwDbE2PkR4Vik3h1l3EEnPAj03Jhlt8RdpX3tlG2oekGM12ISXIYdPgQPPHEFowl3vZCE/HHq\
+OzAjQML4/rewztZCbV9k3urlwXdZfWXwaQDCwR3xL1iPXL4WJPQO/GU16ml2yOJbEP9D/AND/ABB\
+Sw9g
+exehash=facef3555a82b36cc7e8d92e422f6bffa9ea772e21800b4dd646cd8aa6e6eb36
+
+500.perlbench_r=base=maplec-m64:
+# Last updated 2021-06-02 10:59:30
+opthash=907b382deeffec61ac5b9a27df38c7435aa5d83bcabdd7e546b4199881462251
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNrVUtFqgzAUffcrgu/WDkZhZQ40TatbaoKJ0D0Fa1OWrWpJ7Nj+ftG1doWOPU+U3HvO8YZ77k2b\
+2quKN7lVOwmafaua2kwd02pVtkIf6o3S4l1qtf0M3BvXsaGxksAdj+7GE9dxIFnSKXD9l6aSvjnU\
+/lrVflXsd7IEnn2bU9FRA7wZowjaI52hKF/YgKIMC0gyBLxkZL+NMq2fEBuV+6L2uaqkF6tMmhMS\
+8yX2aKGN1BaSH62vpQ3MXpa6qDe25IzkEUaC4ZDFiInuxiTEwfh4uwhzTgTLKc0QY4JQlC6p5QQO\
+swUS8wQjNqRdJhjJM4g6rE/JfM4QF1HCWTC5BcNzLI+TNF+J1cCcYNoh96Y56FI+uA6cAgiDq7Z9\
+kyR6JJQH7oWHrmO9hjSf43DBLHfpZ89GKIWxGAT/3uC+KUoyHkYJTvjzqeuz0b0CrXgWiqs62kms\
++um3Nf1jhvfN+lWWrXnoBLvqLB7GAkA/Mzz7baB/t2B/X4Y8tlDUzW1XHSuSvNuBHwvwBanrEMs=
+exehash=51357adb393d1e80ce358878f264dc9f58399d0c7c71acd7c4834ae0d4c6d3e4
+
+600.perlbench_s=base=maplec-m64:
+# Last updated 2021-07-08 13:59:25
+opthash=4a435f7f3d851ba39439680b2f6c3962466eabafd26d686251cc537e642df2bf
+baggage=
+compiler_version=\
+@eNo9T0FugzAQvOcVfIC6h6qHSjmAWYIlB1s2VLlZBLaqVcCWoVWfX7ttcljtzOxoZzej1LyC0ky0\
+RsgutpcDeXcLkmuwI5Jl8DMS4XEtwgd1i7czBnL9tPNEdufmjWwexz/bmOWVlkBjayso+1MEEhQ3\
+VCjIcvYQa7LbTpiIaPTDSjq7YN5YhdtNabozz+UQNgxRwu+dBIwgpYRhneLKSvQlB6N5oRvQJiWy\
+gh8f48jwQp3A1IyDvtPEjBa9opC0XyrqWkNnStbp4/PT/92Gs7a/mEsS3lx8efG3iZDQnuXdJ5Pl\
+6/ADa+5hBw==
+compile_options=\
+@eNrVUk2PmzAQvfMrLO6EVKp6iJaVwHGCWxNbYKR0LxYhjkoXMLJJ1f77DqTJ7kp72u1lEYj5eH4z\
+fjM70wdd9ahPTauRGcbG9G7ludE29ajsuT82Vv3Stjn9ifxPvgemAwjYi+Vy6Xse5plYIT/8YTod\
+HuCUDrtqaHXIB93H9hGbbgBqGx7OTXsMR2NaF7pB1xdYjQJ4zbXywqBgXQiC4bdbk6TcgiFIzhTm\
+OUEBXcB3bNwYUg5WPVR9KJtOB2mTa3eNpDJjgais0xZC+vcYWg3GVNVW/REo17xMGFEFi4uUFGqq\
+SGMWLSGlWJxvidpQRoqbO3mq4GWOyRSbXb7ZFESqhMoi+vIZ3Z7LBRSju3Kv9nMmOBlQoxuuOS7I\
+LhPPwWLC3TlztrW+9z28QhhHb1f1wsCTr1zIyH8hse/BvLAoNyzeFpB7KfecTcgOp+oG+BD6z40L\
+nss4oYzK79ebPc3B9/gKkb3MY9Bf0ow+EAC9OpmZ7AJ9lVJMbED87V2b/6aVuTOHn7oe3f2Eabsn\
+ituAEZqnz9bv2p//qia0k8UyhdPJtFFt969DXk7b+Ww1/wKvBF+R
+exehash=d2d00cc9f02ff885cbbaa84d0ca4c454e358751556a1d406920eb0d884eddc13
+
+602.gcc_s=base=maplec-m64:
+# Last updated 2021-07-08 14:13:46
+opthash=2b044efddeb93a2f639d7b416bfe4d7dffc256240a57f0bb58e0d756048efe18
+baggage=
+compiler_version=\
+@eNo1jVEPgiAAhN/9FfwBorXmQ2+GpGwFLMtXlkjLBUKo/f6w8uF2d9t3O4CxrMm5opxJLi7Rdgl6\
+OKtREzqlkb15oxH3us/CEzvrO6MDaqbOtGh0zgxo8Fr9MAVgXgmCo7Gc7K8FgHQ1C3W9MlOrv3nm\
+5WtwYfzjMl1vYqRMFnjelllNJObsQAtZAnh38dz6BeaCsJNY2lGkWwDfyQcMLD2L
+compile_options=\
+@eNqlUdFOgzAUfe9XNH1nTGP2QDYT6BhUgZKNGfWl2VgXcUCxBRP/3gJDt8QHdU2b3vSec2/vOZEo\
+jWJz4Pss51BUdSZKZQFVyyytmWzKXSbZO5fZ/mOGrhDQodIQHY/G4zECANMwtiAyX0TBza1mcbPY\
+VDk3acVLWx6wKCpdWprbJst3Zi1ErkxV8bSHpdDQWwydRwIa81XsYn1Fc9dZe9Ago/aYWZnmzY53\
+cctnb0rI+ghnk/G1DknEPNxyffvBZZhGC+IxH54uYy/0x4pqINLYjcK4y/QPQTy5gXCqRCNTfosA\
+tiDGs/8P2Fegzh2Nkxk6mxYBLR2O14vA9lY6dz55l3XcCPtsAFwsBQLUgu5jsrT14AkJybOry/4o\
+Sde+h8Z0mdgOCUjyNPyykwmBgET3F7n/K2+mYvvK01rdtpi8+MZ/KQlhJ3Mwv8ioP2ijm4V24rOA\
+OK0xeXHsT9etyScOfwKElQZx
+exehash=fbf53d23cd71f67cdb1656653f9f52d792b67aecc01a767deb20944e23e43b6a
+
+625.x264_s=base=maplec-m64:
+# Last updated 2021-07-08 14:14:34
+opthash=d40a7799bcf65d95bfb5aa310bda263a121e6e86a0a7c7cbe07f1d48ebad6dd9
+baggage=
+compiler_version=\
+@eNpNjkkKwjAYhfeeIhcIv0OtIrjoEKSgTahVcBXaNGIwaUJapce3ooKrN/DxeChJ+JkUx4zmnLJy\
+lM0EbtZIqL0SEkzltATqZBv5e2KNU1p6qB9KN9BbqzvonBQfTCCcHhlJRslTEp92CGe6kcI2vPMC\
+VDsC2TAPg3f8syCH3lfdfyOsMbb97vHoVFIeX0pCi5QU2+kwmy+CZbhaI3y14zXjfiRlJD+wX9qz\
+MED4OXkB41NIsA==
+compile_options=\
+@eNrtU9FugjAUfecrmr5j1Tm3EDUBZNoNKFFM5l6IYs2YlJIWF/f3K6ibJnvYZvawhIakl97Te9tz\
+enye6WyxoeskpYDnRcIzaWiyEElcRGKbrRIRvVKRrN/6sAU1FUoFUXGj2WxCTbOJFxgAomfOKFqq\
+XRSxRZ5SRHKamWJjc5ar0gItt0m6QgXnqUQyp/EeFgNdffzYucGBPpwGjq0mf+hYsxHQcbqiMV9F\
+UsQoyRQa79rdTvl7EiK6K8RCnq7EnDGeHepF5iwkkTUPHTIZOpN+c9dqX3Wuuze34HToa66OzfLj\
+LhI4vhdUmf2CG3Q7APQk34qYDqBmG8C2+7+//r4Cse5JEPbhGRdQU8TawezONUdTlTvnpcpajm+P\
+oyPgj4mCGjGA8xhOTEVLiD385KimXxJWHW4PDcgkNC3s4nB+vENFItRc7D9c9HK+pVyPL19oXMhB\
+iUnZJ/6DZwAqEdzhRTL+gBvVzDPDceRiq5QtZYf+ZFY+gRP9a3PV5qrNVZurNldtrv9lrnet0yqr
+exehash=49c2c4c7a717f1d6c11fb7bb9ebeeebca2e5dafe6288d3b0f1112ec42afbf549
+
+605.mcf_s=base=maplec-m64:
+# Last updated 2021-07-08 14:27:49
+opthash=5a9bcfb51f44556d7b0f1d91dc12b533c8271e4d495bdde702718e8c126d2e5c
+baggage=
+compiler_version=\
+@eNo1jdEKwiAYhe/3FL6A/BDRRXfLSQxKZW7dSjNHkqbp6vkz1q4O55wPPkSIutBOtpwpLvoS+wru\
+wRsYk9UG/DU6AzyaZ50eJPhonUkwvq27wRyCy5Cj0QumEcZ64xFupKCkBGvoYTgi3P4Y9cohzf9T\
+1UPPlRyE6KiUxUzZWSA8hSLycYXWeWknsdsi/Km+tk04/Q==
+compile_options=\
+@eNqtUV1vgjAUfe+vuOk74pZlD0RNoDJlQ9oIJNteGsWaMYGyFpfs36+gRE32sGX2pTf3nvtxzolk\
+ZZWrndjmhQBZN7mstIN0o/Ks4WpfbXLFP4XKt19jfIORCbWBmHgwHA4xQoQumAPYfpOlsNemS9jl\
+qi6ETWtRuWpHZFmb0cpe7/NiYzdSFtrWtcgOsAwsK7stwTKB7PcPJFjTmPnEfNHU99IZgBW0TfxD\
+S9Ucq9xNE8rjlLGlH8ecMj9aMDh71laaI8q6x58Qx0TI7u8ARlruVSYmGBEHCBn/l8xhDvUeKUvG\
++IIZRkYswtKH0J3FpnbJsqt6fkTmnPSIX9LGiDrgPydL1ySSYBG8+qb5R/7dlgOU0WXiekEYJC/9\
+MZ0mGIVB9HQFW+E3dozk+l1kjZ60mOLUdJINoNM0nF7Bmz/oZFYu3GTOw8BrrSjK4xU0bX09M/Ub\
+hGoAkA==
+exehash=92eb0a99ad04eb8d3409b9a0638b2e87a9e31d34990aac67a88b4a3bcd2accb3
+
diff --git a/build/tools/spec/cross-gcc.cfg b/build/tools/spec/cross-gcc.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..361d657c6ff5ca93312d99121afd3271bfdd4d67
--- /dev/null
+++ b/build/tools/spec/cross-gcc.cfg
@@ -0,0 +1,496 @@
+#------------------------------------------------------------------------------
+# SPEC CPU2017 config file for: gcc / g++ / gfortran on Linux x86
+#------------------------------------------------------------------------------
+#
+# Usage: (1) Copy this to a new name
+#             cd $SPEC/config
+#             cp Example-x.cfg myname.cfg
+#        (2) Change items that are marked 'EDIT' (search for it)
+#
+# SPEC tested this config file with:
+#    Compiler version(s):    4.4.7, 4.9.2, 5.2.0, 6.3.0, 7.2.1, 8.1.0
+#    Operating system(s):    Oracle Linux Server 6.5 and 7.4 /
+#                            Red Hat Enterprise Linux Server 6.5 and 7.4
+#    Hardware:               Xeon
+#
+# If your system differs, this config file might not work.
+# You might find a better config file at http://www.spec.org/cpu2017/results
+#
+# Known Limitations with GCC 4
+#
+#   (1) Possible problem: compile time messages
+#                             error: unrecognized command line option '...'
+#      Recommendation:    Use a newer version of the compiler.
+#                         If that is not possible, remove the unrecognized
+#                         option from this config file.
+#
+#   (2) Possible problem: run time errors messages
+#           527.cam4_r or 627.cam4_s    *** Miscompare of cam4_validate.txt
+#      Recommendation: Use a newer version of the compiler.
+#                      If that is not possible, try reducing the optimization.
+#
+#
+# Compiler issues: Contact your compiler vendor, not SPEC.
+# For SPEC help:   http://www.spec.org/cpu2017/Docs/techsupport.html
+#------------------------------------------------------------------------------
+
+
+#--------- Label --------------------------------------------------------------
+# Arbitrary string to tag binaries (no spaces allowed)
+#                  Two Suggestions: # (1) EDIT this label as you try new ideas.
+%define label gcc                # (2)      Use a label meaningful to *you*.
+
+
+#--------- Preprocessor -------------------------------------------------------
+%ifndef %{bits}                # EDIT to control 32 or 64 bit compilation.  Or,
+%   define  bits        64     #      you can set it on the command line using:
+%endif                         #      'runcpu --define bits=nn'
+
+%ifndef %{build_ncpus}         # EDIT to adjust number of simultaneous compiles.
+%   define  build_ncpus 8      #      Or, you can set it on the command line:
+%endif                         #      'runcpu --define build_ncpus=nn'
+
+# Don't change this part.
+%define    os           LINUX
+%if %{bits} == 64
+%   define model        -m64
+%elif %{bits} == 32
+%   define model        -m32
+%else
+%   error Please define number of bits - see instructions in config file
+%endif
+%if %{label} =~ m/ /
+%   error Your label "%{label}" contains spaces.  Please try underscores instead.
+%endif
+%if %{label} !~ m/^[a-zA-Z0-9._-]+$/
+%   error Illegal character in label "%{label}".  Please use only alphanumerics, underscore, hyphen, and period.
+%endif
+
+
+
+#--------- Global Settings ----------------------------------------------------
+# For info, see:
+#            https://www.spec.org/cpu2017/Docs/config.html#fieldname
+#   Example: https://www.spec.org/cpu2017/Docs/config.html#tune
+
+command_add_redirect = 1
+flagsurl             = $[top]/config/flags/gcc.xml
+ignore_errors        = 1
+iterations           = 1
+label                = %{label}-m%{bits}
+line_width           = 1020
+log_line_width       = 1020
+makeflags            = --jobs=%{build_ncpus}
+mean_anyway          = 1
+output_format        = txt,html,cfg,pdf,csv
+preenv               = 1
+reportable           = 0
+tune                 = base
+
+
+#--------- How Many CPUs? -----------------------------------------------------
+# Both SPECrate and SPECspeed can test multiple chips / cores / hw threads
+#    - For SPECrate,  you set the number of copies.
+#    - For SPECspeed, you set the number of threads.
+# See: https://www.spec.org/cpu2017/Docs/system-requirements.html#MultipleCPUs
+#
+#    q. How many should I set?
+#    a. Unknown, you will have to try it and see!
+#
+# To get you started, some suggestions:
+#
+#     copies - This config file defaults to testing only 1 copy.   You might
+#              try changing it to match the number of cores on your system,
+#              or perhaps the number of virtual CPUs as reported by:
+#                     grep -c processor /proc/cpuinfo
+#              Be sure you have enough memory.  See:
+#              https://www.spec.org/cpu2017/Docs/system-requirements.html#memory
+#
+#     threads - This config file sets a starting point.  You could try raising
+#               it.  A higher thread count is much more likely to be useful for
+#               fpspeed than for intspeed.
+#
+intrate,fprate:
+   copies           = 1   # EDIT to change number of copies (see above)
+intspeed,fpspeed:
+   threads          = 4   # EDIT to change number of OpenMP threads (see above)
+
+
+#------- Compilers ------------------------------------------------------------
+default:
+#  EDIT: The parent directory for your compiler.
+#        Do not include the trailing /bin/
+#        Do not include a trailing slash
+#  Examples:
+#   1  On a Red Hat system, you said
+#      'yum install devtoolset-7'
+#      Use:                 %   define gcc_dir /opt/rh/devtoolset-7/root/usr
+#
+#   2  You built GCC in:                       /disk1/mybuild/gcc-8.1.0/bin/gcc
+#      Use:                 %   define gcc_dir /disk1/mybuild/gcc-8.1.0
+#
+#   3  You want:                               /usr/bin/gcc
+#      Use:                 %   define gcc_dir /usr
+#      WARNING: See section
+#      "Known Limitations with GCC 4"
+#
+%ifndef %{gcc_dir}
+%   define  gcc_dir        /home/yhm/maple_opensource/opensource/tools/gcc-linaro-7.5.0  # EDIT (see above)
+%endif
+
+# EDIT if needed: the preENV line adds library directories to the runtime
+#      path.  You can adjust it, or add lines for other environment variables.
+#      See: https://www.spec.org/cpu2017/Docs/config.html#preenv
+#      and: https://gcc.gnu.org/onlinedocs/gcc/Environment-Variables.html
+   SPECLANG                = %{gcc_dir}/bin/
+   CC                      = $(SPECLANG)aarch64-linux-gnu-gcc     -std=c99  
+   CXX                     = $(SPECLANG)aarch64-linux-gnu-g++     -std=c++03 
+   FC                      = /usr/bin/aarch64-linux-gnu-gfortran-7
+   # How to say "Show me your version, please"
+   CC_VERSION_OPTION       = -v
+   CXX_VERSION_OPTION      = -v
+   FC_VERSION_OPTION       = -v
+
+default:
+%if %{bits} == 64
+   sw_base_ptrsize = 64-bit
+   sw_peak_ptrsize = 64-bit
+%else
+   sw_base_ptrsize = 32-bit
+   sw_peak_ptrsize = 32-bit
+%endif
+
+
+#--------- Portability --------------------------------------------------------
+default:               # data model applies to all benchmarks
+%if %{bits} == 32
+    # Strongly recommended because at run-time, operations using modern file
+    # systems may fail spectacularly and frequently (or, worse, quietly and
+    # randomly) if a program does not accommodate 64-bit metadata.
+    EXTRA_PORTABILITY = -D_FILE_OFFSET_BITS=64
+%else
+    EXTRA_PORTABILITY = -DSPEC_LP64
+%endif
+
+# Benchmark-specific portability (ordered by last 2 digits of bmark number)
+
+500.perlbench_r,600.perlbench_s:  #lang='C'
+%if %{bits} == 32
+%   define suffix IA32
+%else
+%   define suffix X64
+%endif
+   PORTABILITY    = -DSPEC_%{os}_%{suffix}
+
+521.wrf_r,621.wrf_s:  #lang='F,C'
+   CPORTABILITY  = -DSPEC_CASE_FLAG
+   FPORTABILITY  = -fconvert=big-endian
+
+523.xalancbmk_r,623.xalancbmk_s:  #lang='CXX'
+   PORTABILITY   = -DSPEC_%{os}
+
+526.blender_r:  #lang='CXX,C'
+   PORTABILITY   = -funsigned-char -DSPEC_LINUX
+
+527.cam4_r,627.cam4_s:  #lang='F,C'
+   PORTABILITY   = -DSPEC_CASE_FLAG
+
+628.pop2_s:  #lang='F,C'
+   CPORTABILITY    = -DSPEC_CASE_FLAG
+   FPORTABILITY    = -fconvert=big-endian
+
+
+#-------- Tuning Flags common to Base and Peak --------------------------------
+
+#
+# Speed (OpenMP and Autopar allowed)
+#
+%if %{bits} == 32
+   intspeed,fpspeed:
+   #
+   # Many of the speed benchmarks (6nn.benchmark_s) do not fit in 32 bits
+   # If you wish to run SPECint2017_speed or SPECfp2017_speed, please use
+   #
+   #     runcpu --define bits=64
+   #
+   fail_build = 1
+%else
+   intspeed,fpspeed:
+      EXTRA_OPTIMIZE = -fopenmp -DSPEC_OPENMP
+   fpspeed:
+      #
+      # 627.cam4 needs a big stack; the preENV will apply it to all
+      # benchmarks in the set, as required by the rules.
+      #
+      preENV_OMP_STACKSIZE = 120M
+%endif
+
+
+#--------  Baseline Tuning Flags ----------------------------------------------
+#
+# EDIT if needed -- Older GCC might not support some of the optimization
+#                   switches here.  See also 'About the -fno switches' below.
+#
+default=base:         # flags for all base
+   OPTIMIZE       = -g -O3 -fno-pie -fno-unsafe-math-optimizations  -fno-tree-loop-vectorize
+
+intrate,intspeed=base: # flags for integer base
+   EXTRA_COPTIMIZE = -fno-strict-aliasing -fgnu89-inline
+# Notes about the above
+#  - 500.perlbench_r/600.perlbench_s needs -fno-strict-aliasing.
+#  - 502.gcc_r/602.gcc_s             needs -fgnu89-inline or -z muldefs
+#  - For 'base', all benchmarks in a set must use the same options.
+#  - Therefore, all base benchmarks get the above.  See:
+#       www.spec.org/cpu2017/Docs/runrules.html#BaseFlags
+#       www.spec.org/cpu2017/Docs/benchmarks/500.perlbench_r.html
+#       www.spec.org/cpu2017/Docs/benchmarks/502.gcc_r.html
+
+
+#--------  Peak Tuning Flags ----------------------------------------------
+default=peak:
+   basepeak = yes  # if you develop some peak tuning, remove this line.
+   #
+   # -----------------------
+   # About the -fno switches
+   # -----------------------
+   #
+   # For 'base', this config file (conservatively) disables some optimizations.
+   # You might want to try turning some of them back on, by creating a 'peak'
+   # section here, with individualized benchmark options:
+   #
+   #        500.perlbench_r=peak:
+   #           OPTIMIZE = this
+   #        502.gcc_r=peak:
+   #           OPTIMIZE = that
+   #        503.bwaves_r=peak:
+   #           OPTIMIZE = other   .....(and so forth)
+   #
+   # If you try it:
+   #   - You must remove the 'basepeak' option, above.
+   #   - You will need time and patience, to diagnose and avoid any errors.
+   #   - perlbench is unlikely to work with strict aliasing
+   #   - Some floating point benchmarks may get wrong answers, depending on:
+   #         the particular chip
+   #         the version of GCC
+   #         other optimizations enabled
+   #         -m32 vs. -m64
+   #   - See: http://www.spec.org/cpu2017/Docs/config.html
+   #   - and: http://www.spec.org/cpu2017/Docs/runrules.html
+
+
+#------------------------------------------------------------------------------
+# Tester and System Descriptions - EDIT all sections below this point
+#------------------------------------------------------------------------------
+#   For info about any field, see
+#             https://www.spec.org/cpu2017/Docs/config.html#fieldname
+#   Example:  https://www.spec.org/cpu2017/Docs/config.html#hw_memory
+#-------------------------------------------------------------------------------
+
+#--------- EDIT to match your version -----------------------------------------
+default:
+   sw_compiler001   = C/C++/Fortran: Version 7.2.1 of GCC, the
+   sw_compiler002   = GNU Compiler Collection
+
+#--------- EDIT info about you ------------------------------------------------
+# To understand the difference between hw_vendor/sponsor/tester, see:
+#     https://www.spec.org/cpu2017/Docs/config.html#test_sponsor
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+   hw_vendor          = My Corporation
+   tester             = My Corporation
+   test_sponsor       = My Corporation
+   license_num        = nnn (Your SPEC license number)
+#  prepared_by        = # Ima Pseudonym                       # Whatever you like: is never output
+
+
+#--------- EDIT system availability dates -------------------------------------
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+                        # Example                             # Brief info about field
+   hw_avail           = # Nov-2099                            # Date of LAST hardware component to ship
+   sw_avail           = # Nov-2099                            # Date of LAST software component to ship
+
+#--------- EDIT system information --------------------------------------------
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+                        # Example                             # Brief info about field
+#  hw_cpu_name        = # Intel Xeon E9-9999 v9               # chip name
+   hw_cpu_nominal_mhz = # 9999                                # Nominal chip frequency, in MHz
+   hw_cpu_max_mhz     = # 9999                                # Max chip frequency, in MHz
+#  hw_disk            = # 9 x 9 TB SATA III 9999 RPM          # Size, type, other perf-relevant info
+   hw_model           = # TurboBlaster 3000                   # system model name
+#  hw_nchips          = # 99                                  # number chips enabled
+   hw_ncores          = # 9999                                # number cores enabled
+   hw_ncpuorder       = # 1-9 chips                           # Ordering options
+   hw_nthreadspercore = # 9                                   # number threads enabled per core
+   hw_other           = # TurboNUMA Router 10 Gb              # Other perf-relevant hw, or "None"
+
+#  hw_memory001       = # 999 GB (99 x 9 GB 2Rx4 PC4-2133P-R, # The 'PCn-etc' is from the JEDEC
+#  hw_memory002       = # running at 1600 MHz)                # label on the DIMM.
+
+   hw_pcache          = # 99 KB I + 99 KB D on chip per core  # Primary cache size, type, location
+   hw_scache          = # 99 KB I+D on chip per 9 cores       # Second cache or "None"
+   hw_tcache          = # 9 MB I+D on chip per chip           # Third  cache or "None"
+   hw_ocache          = # 9 GB I+D off chip per system board  # Other cache or "None"
+
+   fw_bios            = # American Megatrends 39030100 02/29/2016 # Firmware information
+#  sw_file            = # ext99                               # File system
+#  sw_os001           = # Linux Sailboat                      # Operating system
+#  sw_os002           = # Distribution 7.2 SP1                # and version
+   sw_other           = # TurboHeap Library V8.1              # Other perf-relevant sw, or "None"
+#  sw_state           = # Run level 99                        # Software state.
+
+# Note: Some commented-out fields above are automatically set to preliminary
+# values by sysinfo
+#       https://www.spec.org/cpu2017/Docs/config.html#sysinfo
+# Uncomment lines for which you already know a better answer than sysinfo
+
+__HASH__
+500.perlbench_r=base=maple_test-m64:
+# Last updated 2021-05-10 10:36:40
+opthash=1b55f44e78c515229834a282ce9d3013fee214077130f5cc6c8d469cce53274c
+baggage=
+compiler_version=\
+@eNp9VE1v2zAMvftX+NYNteK26ZIigA9Z6hYD0qZI3e0YyBLtqJUlTx+J08N++2Qnjr202MWC+Cjy\
+kXy0P5utfsbL5x+Lx9XiKXHHxHvRTOR+ahk3iAlfl0D0wJst5vN4lqzuZ7MotFqFKRNhTsgRmCeL\
+1a/l9OkpXu4dOEtrh7C6Ga1G14gzYSuUCxuOQ24k2ipclqC8xd3dfDG9XSXT5X2crB6nD/FzJDal\
+qZCQAk7x2/hu+jJPoksvwSoHM/FP43szKTKWWwXU3zKznviDQagVCUlr99HGR6jGUPmWb0BpJkV0\
+9pJaYaw/HnwbXKChbW6Xfy5vBhfXZ61/al0AHmWMwyQMmzr1GisIqSR1tWgcLuPp7UM8+G5z7V6B\
+wCkHxLHILc5BRyTAFAfk/DzIZZAqlgc0yKQyCotApq+k/iAHu7elgoxVTTfb/HWKAr9KhQ60kRR8\
+1/jKXOECaZvVb9C4ZzvEOW0U6ug1NdAeXSbeQKFaBBSxGnDThAoIZeo43QMnaWudEG4pUOQmYqAy\
+XSSzVoCpjkqpWbWPcxLj4Ch4r12plEa7lpSdiXBJMIfIEe/zTLWhpKoQBTeazwDDCoh2oNsOUsiw\
+ddLuPHDKIgHb7nHdGyvYbwvIDQNIXQ5lusE2Zn+AYtnun3xFWXX3ktvcLc/x3mYtGbRE9E4bKNB7\
+10lkGkmfIIcItTbc+CNsjeyshQvKsCLrHsUtKCWPiqlBNLyK2OhmdLS5iovRdXttgrhkrgptomJ4\
+FTgwKKrh1UmiPlUr3CxAuD6QHsks4xLTQyG6t8c9sRBLMaKKuR72xrsG8uZ+PJECDljX/o36PqjW\
+AWvpaH5i32f9gHhJo0G/kBT4xG+U6LlF8g8rtN94/8t/9v+r7/0FuibFEg==
+compile_options=\
+@eNrVU21r2zAQ/u5fIfxdccdGWUJdsB0l8eZEwrIh2xfhOkqqLZaD5IS1v34n56UtDFpGv1RgfLq3\
+R3fP3aLVuKl+y7XaStTuOtVqO/JsZ1TdCbPXK2XEQRq1fgj9T74HogWX0L8aDK+ufc9L6JyNkB/s\
+rQnulA42dY3cwbZbhfVw6MTm+gvCNcLtGWDQIjzmjCTwW4xJXE5BYCTPREJzgnA6gG+lbBekFKR6\
+V+mgUI3EM5VLe9bMinmGWWWsNKCSf7rASBDsTtam0itIOaZlnBHBs4jPCBcOMY2y8OqELqKyoIKX\
+jOWEc0EZWcwZ2EQW5VMiJmlG+OXqboLTMk+I0/VXOplwUog4LXgINSK8QZh+hoIrU9+HuurUAV60\
+1i3ea1utJRi6e+ya0KjHqm8FOto7IyXetu0OH2TdtUY9SnQ6p7dm6aJciqWDOcUcScLVVlVWaYBe\
+b/T+6xArvVVaPotkLujGtntTy1vfS0YoScJXKTs60vgbZUXov+DP94DzhJWTLJpysL3ksrfGZJHM\
+xMXhw5Pre3SEoBPpPP1JoKL3ZLpvGKN5EcVplhY/zh194rxHJ8sij6CJT494fQr61MfAfwIwlxtg\
+vr9lh4/Kd5/x/x3wm/buFySyt85/26DLwlzmFKF+iLPxW6b9g/IL9c2jYga5Yrdp2+ZUMi3d1j5b\
+2b8rRMvz
+exehash=1c69320bf26365e65e5b19b87fd09bbfdf73b3d6257845446d6001048f92fd40
+
+500.perlbench_r=base=gcc-m64:
+# Last updated 2021-05-13 10:18:46
+opthash=4a1fc46ed4b7dc5c387a83a4c8727837cdc03d41f8bddf80c915370e9e6911bd
+baggage=
+compiler_version=\
+@eNq9VUtv2zAMvudX6NYNraKmj7QJ4MMQBNuAYAnabDsasszYamRJ06Nxd9hvn2zHtddmGLBuvcSh\
++PjITySFZrP4y/zm9uPyU7xcrcNnOvhsucxQ4rlwmEtkNTA7HMyWi8V8to7fz2YRyVUBxHpJoPCc\
+FFQLiJUGaZU3DEjvr1NKWJIxhgWX1Ch8NbwcnpKES0KpYfn4olL4EmfS42D2iLNYL+OvN+9Wq/nN\
+P8IbDongCZTAKv1zeNKYCqfwzlCtwQzW1GTgpuiZ7WCm5IZn3kCKdtzlU3TUJOnYLsMVd6kV9B7I\
+Tpmt1ZTtNQXdAjYggFqIR8RKqm2uXJ3xMOPuR5c1PjsdTYajM8JaqCN0+2G+WER1NQm1OcK4AseF\
+ZtHfwMe1JWnsSQrWpdwQPr4eY826YjuYjXkNnKzQrwITOo7aviTSIKXc0kRAsE8Kn24E1eEQZHPm\
+VCfYnFbX3/grXw0LEz6FFIeecVC6zlSKRxz7YB0U+HsI3wOzd+IOQ8lAO66k7TyrtLzk3zxgldwB\
+6wUNBW3BNPRg/iT1UDsry1B33jmwyaQnCMWogKgh5DFk65hC4rOeQsms/mnLCO4qi6RqZa1FT+J2\
+L7UZFV443pS8j7jhJWbKBJ4wvTzH1+eXV+PJ79UX5xejSRu+msaImuL+GtPOxeUGaGojrSwvu+Ma\
+uvI4VKbjBUQP8IRwLkPjBK7xxktWXUgL3HAdrtAo5V7So/sQ9vkW6vXJS0H+NAgHVmBghvV6JAe2\
+DY9BtA/du9Ckyt6ZX4aDyszTDGzETtjx8ckmXJ+h8qQZmjqZ6NAw5sq6gwpXb9/oEEXaQOiQ/0nO\
+YF23EypUCmKK6qYahC2N7sHYqiXq1wK9WdQLG4VnEfWW9ls0+Alw/ZnQ
+compile_options=\
+@eNrVVG1r2zAQ/u5fIfxdcca6bAl1wXaUxJsTCb9Ati/CdZREmy0ZyS5df/1kO0lTGAxGKVRgfKd7\
+eaS757SRAlb5L7bnJQOybrgUembpRvGioaoVO67oA1N8/9u1P9iWEbVxce3xaDqe2JYV4DWZAds5\
+yoo5uhUOq1ruVHldMiprJrRsVcGcK7GRstTOoShgyUWuJPw8+jQaO/dcOHmuiuPkpjO0j/AgWmjc\
+QLegbnZuMZ0CWAAozwcdSQDnCUGB+W3myM+WRiAojmiAYwRgODLfjuvGCbGRijoXTsorBlc8Zvq8\
+s0rXESS50kyZLfbYOIoZQdesULnYmZRznPkRoknkJSuU0A4x9CJ3fEKnXpZimmSExChJKCZosybG\
+RiMvXiK6CCOUXNROownO4gB1e72KF4sEpdQP08Sd3JjbHgDEHwHcCwlrzgahFTrfM9Os5gi7+1f8\
+Ke+rAAZ7oxiDpZQ1fGBFIxV/YuC0TseMwk22pdsO4RQz9BnmJc81FwZ1b4r+ZQq5MC1gV5GkC7od\
+OnhnW8EMBIH7Zl0fALH/FZPUtV9QwLYM/QKSLSJvmRjbSzr0Vh9tghW9OLx7ftgWngFTiXAd/kDm\
+Rq9Elr5WBMep54dRmH4/F/OZNj0w2qaxZ+r3jP9vIvWph8C/ApAut4H59pYvyaC95qT975jdyvuf\
+JpG+6/zLClzG9sJyAPoRiOZvOXPvj2WmRGsvXZlcfjfqZXWqGs66Z+PqzfgDFjQx9g==
+exehash=6baceb9eb267d444c46c4c9f978e50063408522981011f9ac78e7db729fc8926
+
+519.lbm_r=base=gcc-m64:
+# Last updated 2021-05-13 10:35:31
+opthash=d0595b41acba249b4b15e2950cf3b949e9504a149adac9800b3de173849eacd9
+baggage=
+compiler_version=\
+@eNq9VUtv2zAMvudX6NYNraKmj7QJ4MMQBNuAYAnabDsasszYamRJ06Nxd9hvn2zHtddmGLBuvcSh\
++PjITySFZrP4y/zm9uPyU7xcrcNnOvhsucxQ4rlwmEtkNTA7HMyWi8V8to7fz2YRyVUBxHpJoPCc\
+FFQLiJUGaZU3DEjvr1NKWJIxhgWX1Ch8NbwcnpKES0KpYfn4olL4EmfS42D2iLNYL+OvN+9Wq/nN\
+P8IbDongCZTAKv1zeNKYCqfwzlCtwQzW1GTgpuiZ7WCm5IZn3kCKdtzlU3TUJOnYLsMVd6kV9B7I\
+Tpmt1ZTtNQXdAjYggFqIR8RKqm2uXJ3xMOPuR5c1PjsdTYajM8JaqCN0+2G+WER1NQm1OcK4AseF\
+ZtHfwMe1JWnsSQrWpdwQPr4eY826YjuYjXkNnKzQrwITOo7aviTSIKXc0kRAsE8Kn24E1eEQZHPm\
+VCfYnFbX3/grXw0LEz6FFIeecVC6zlSKRxz7YB0U+HsI3wOzd+IOQ8lAO66k7TyrtLzk3zxgldwB\
+6wUNBW3BNPRg/iT1UDsry1B33jmwyaQnCMWogKgh5DFk65hC4rOeQsms/mnLCO4qi6RqZa1FT+J2\
+L7UZFV443pS8j7jhJWbKBJ4wvTzH1+eXV+PJ79UX5xejSRu+msaImuL+GtPOxeUGaGojrSwvu+Ma\
+uvI4VKbjBUQP8IRwLkPjBK7xxktWXUgL3HAdrtAo5V7So/sQ9vkW6vXJS0H+NAgHVmBghvV6JAe2\
+DY9BtA/du9Ckyt6ZX4aDyszTDGzETtjx8ckmXJ+h8qQZmjqZ6NAw5sq6gwpXb9/oEEXaQOiQ/0nO\
+YF23EypUCmKK6qYahC2N7sHYqiXq1wK9WdQLG4VnEfWW9ls0+Alw/ZnQ
+compile_options=\
+@eNq9UlFPgzAQfudXNH3vmNFptsgSYKgoo82ARH1pkHVbFVrSglF/vWXM6RIfdffSu97lu7vvvlgK\
+VOUvbMVLBmTdcCn0xNKN4kVDVSuWXNFXpvjq3YEn0DKuNiUOHA7GwxG0LB/PyQRAeyMrZutW2Kxq\
+uV3ldcmorJnQslUFs3+4jZSlttdFgUouciXRxWA0GNpPXNh5rorN+VmXaN/QWrTIlIHOkG6WTjEe\
+A1QAJL8GHUiAZgkJfPPEs8DLrncxdbMU0yQjZBEkCcUkiOfEoKwBwqcArYRENWe90wqdr5ghodmg\
+DrfiH/kWHfT5RjGGSilr9MqKRir+wcCh7XpG5PwMgMt+zSm0/Anwfedo1PQNsXeLSerAA56gZW7k\
+k+wqcq8TkzvkbJv1gti/oQcFv5IILTwBpkM4Dx8DU/lHjG5nCO7ThUsJXqSuF0Zh+rCfpKMWWlEY\
+3x1Ta33055q5lE/P5ldPO/Sy+pbR/l4AbI8ZzY6pnn+6q9lj7qY3NAq9TllltVsNZ51Kf0j0E2qG\
+c4o=
+exehash=b17469e48480b17716b457cef173dcb01bb9f937e33f10bfda3c01e7cce63d3b
+
+538.imagick_r=base=gcc-m64:
+# Last updated 2021-05-13 15:27:38
+opthash=2f48a899d3d456bed03183b03581d9905efa460c559864a9e038739267957e43
+baggage=
+compiler_version=\
+@eNq9VUtv2zAMvudX6NYNraKmj7QJ4MMQBNuAYAnabDsasszYamRJ06Nxd9hvn2zHtddmGLBuvcSh\
++PjITySFZrP4y/zm9uPyU7xcrcNnOvhsucxQ4rlwmEtkNTA7HMyWi8V8to7fz2YRyVUBxHpJoPCc\
+FFQLiJUGaZU3DEjvr1NKWJIxhgWX1Ch8NbwcnpKES0KpYfn4olL4EmfS42D2iLNYL+OvN+9Wq/nN\
+P8IbDongCZTAKv1zeNKYCqfwzlCtwQzW1GTgpuiZ7WCm5IZn3kCKdtzlU3TUJOnYLsMVd6kV9B7I\
+Tpmt1ZTtNQXdAjYggFqIR8RKqm2uXJ3xMOPuR5c1PjsdTYajM8JaqCN0+2G+WER1NQm1OcK4AseF\
+ZtHfwMe1JWnsSQrWpdwQPr4eY826YjuYjXkNnKzQrwITOo7aviTSIKXc0kRAsE8Kn24E1eEQZHPm\
+VCfYnFbX3/grXw0LEz6FFIeecVC6zlSKRxz7YB0U+HsI3wOzd+IOQ8lAO66k7TyrtLzk3zxgldwB\
+6wUNBW3BNPRg/iT1UDsry1B33jmwyaQnCMWogKgh5DFk65hC4rOeQsms/mnLCO4qi6RqZa1FT+J2\
+L7UZFV443pS8j7jhJWbKBJ4wvTzH1+eXV+PJ79UX5xejSRu+msaImuL+GtPOxeUGaGojrSwvu+Ma\
+uvI4VKbjBUQP8IRwLkPjBK7xxktWXUgL3HAdrtAo5V7So/sQ9vkW6vXJS0H+NAgHVmBghvV6JAe2\
+DY9BtA/du9Ckyt6ZX4aDyszTDGzETtjx8ckmXJ+h8qQZmjqZ6NAw5sq6gwpXb9/oEEXaQOiQ/0nO\
+YF23EypUCmKK6qYahC2N7sHYqiXq1wK9WdQLG4VnEfWW9ls0+Alw/ZnQ
+compile_options=\
+@eNrtVE1vozAQvfMrLN8NWTXtKlGpBIS27BJsBZDaXixKncRdsJENVbe/fg0ku81lT2lO8cVjz2g+\
+3jy9RApUF7/YmlcMyKblUui5pVvFy5aqTrxwRd+Y4uvfLvwGLWNqE+LCiT2bTKFlBXhJ5gA6W1kz\
+R3fCYXXHnbpoKkZlw4SWnSqZ88lspay0sylLVHFRKIm+25f2xHnmwikKVW6vpr2je0cb0SETBvqD\
+dPvilrMZQCVAct+oLQFapCQMzJUsQj+/Ayiyd3/UyzNM05yQVZimFJMwWRKTaQMQvgBoLSRqOBuN\
+TuhizQwQ7Rb1uWv+UQwVwOhvFWOokrJBb6xspeIfDByeXc2YXE0BuB5HvYFWMAdB4J4MnrEg9n9g\
+krnwACtomT0FJL+NvbvU+A5xG7x+mAT3dB/wfyChhefAVImW0VNooo+E6tBH+JCtPErwKvP8KI6y\
+x327A7zQiqPk5yk5N76Ozptr+fxqfvVNn72q/1Hp784AGBYaL07JoC/aq5lj6WX3NI78nl1VvRsN\
+5z1TP9H0LClnSTlLyllSjigpfwDZpdRT
+exehash=eee9c4547d70bbcff53dd938e8d24d3492bdaa0d41abdbc0912925aae18bf1d5
+
+507.cactuBSSN_r=base=gcc-m64:
+# Last updated 2021-05-19 10:35:36
+opthash=89a6bfc2a18191e165ebb9999593cbcfd3b1e3234d8c08585230a52bdafd0e27
+baggage=
+compiler_version=\
+@eNrtVltv2zYYffev0Fs6JLTiJnFiA3roPO8CeEuQulvfDIr6LDGmSJaX2NlDf/soSrJUW06LBOuA\
+wS+2SX73yzkOJh8/ThZ/Tu/f/3b7x+L2bu6+xr1g0nH38/7dB015GsSWMoMoD7QEovu9ye1sNp3M\
+F79MJlGYiRzCpywPcywZLIQEroVVBMLWTyME02FKCGKUYyXQdf+qfx7GlIcYK5INL4sHu0Eptyg9\
+Pd26mM1vF3/dv7u7m96/3lW/HzIawwZI8b7vOSxFmRForbCUoHpzrFIw42BPtjcRfElTqyAJ1tRk\
+4+CkjM+QdYqKiiWa4UcI10KttMSkesnxCpACBljDYhBqjqXOhPER91NqPjdRo7fng1F/8DYktauT\
+4P2v09ks8tnEWGcBQoVzlEsSvcT9wkuGpXyYgDYJVSEd3gyRJE2yjZul+h5+0lx+Fzdu2LBun1ji\
+TgnVOGbg5OPcJkuGpbsEXt4Z0Rx0hov2l/rCFitCmE0gQW5mDGxMI8rZ1o9+0gZy9Lcz33KmH9gD\
+gg0BaajgutEswrKcfrKARPwApGXUJbQCVZYH0Z3QXe5ks3F5Z40CGY1aByYIZhCVBdmarBUTiG3a\
+ehA89R91Gk5dpBEX9VlK1jpRXZ3qiHLLDC1Triwu6QYRoVydEL66QDcXV9fD0eHny4vLwag2X2xj\
+hFX+eINwo2IyBTjRkRSabppr77rQ6ErT0ByiJ9gpOOVucFyt0dJyUjSkdlzW2rVQCWFeM6OVCb2P\
+Qq05ea2Try1CBwS6ypDWjGRAVo4Cosp0q6FxEb1RXywH5qnFKeiInJHT07Ola5/C/KxcGh9M1LWM\
+mdCm88F49I26SiQVuAn5N4vTm/txCnKRABsHfqh6DqWDR1C6GAnPFsGbmQfswJFh0ALtH4L/iDwJ\
+OZLnkTyP5HkkzyN5Hsnz/0yeVqtDJFgVD113c2Gh6XrliY4ooXUXnb2UyhxRakUa3gnQ43bNV2mV\
+f3TyIbbc2LAqgC8HurD+cvB5cNM/vzxp9sbZYdGSMhiHoY/eo2eYCE/G6Dq8n7776fdp/0eb6u6R\
+wgn2Y5WKs2Q7Ww4TSfGB3EtrLJyDLa476zl+EApVgSPB2ZOXFanCOdJ2Weig6w5kP4i01R8JNznb\
+XnwTEexilNPbsdHJGCUSvBi8u+DOm05giR08tiRwTCMO6+cJqMUznyxOcmyy7ltXXCldqxpzktmU\
+8uZcRyApdDPkYRQ/RBF1HGtQSqhn0awEpc3NcLGDLx6TOu6fhaRynqoZ3N9pJ1MPRt3y/aWtJL4V\
+fb6+gw6J/gGx5MUB
+compile_options=\
+@eNrNVd1umzAYvecpLG4jh1TLWiUqlfhLx0oABZCy3VjUMYk3sCMD1dqnn4GmC1qjdVLK5hvbfAd9\
+x+cc2T5nsEi/k4zmBPB9RTkr50pZCYorJGq2oQI9EEGzR129UBW5LCVEVyfj2WSqKooVLMM5ULUd\
+L4j2uCu0It3nBPE9YSWvBSba0bLiPC+1LcYwpywVHF6NP44n2j1lWpoKvLucNoX6B9yyGm5HI9AM\
+WFYbHY9Gkw8AYgD5geWYA2hHoWPJybcdM7l93iMjiQMUJWG4cqIIBaHjL0MAXcpwXm+IRFlWYDvt\
+HN8h240M03OQBMcr14r1CwC3AAayXcY43FPSLWpWphmRYlU72FAo6FPaEgFdvRKEwJzzPXwguOKC\
+PhFwGM/EvPByCsB1p8aNqlhzYK3X+jDqHdoF5ucgjHW1J6aqSBetMFl4xm0ka31h26rp+NYn1AO8\
+qvQRWHY74N+uvqoEcyAZukv3qyP/PJMXLS1nHa8MFAar2DBdz42/vJyksUZ9zzRjfOTHbHbuLJ87\
+sX/MraUPIVPXa8jIngrs/xDLuhSndMu4qETK4NXvwfp1kr/jfDIjvSAsmiC8hViHHtDKxStWLv61\
+lZ7r3w32Xnb7s18N1/z+m/xa3vSuihc3AWit9uzBHrZ3srM9RJA0aT2K6k+WW+Ko
+exehash=63bc323d25366ddc5092f5d594b9e1caa8da1a2fac4e5ece4e8311cc4282a03a
+
diff --git a/build/tools/spec/gcc.cfg b/build/tools/spec/gcc.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f264f2b95e3cf4d79cdeafe417ca1637635b522a
--- /dev/null
+++ b/build/tools/spec/gcc.cfg
@@ -0,0 +1,461 @@
+#------------------------------------------------------------------------------
+# SPEC CPU2017 config file for: gcc / g++ / gfortran on Linux x86
+#------------------------------------------------------------------------------
+#
+# Usage: (1) Copy this to a new name
+#             cd $SPEC/config
+#             cp Example-x.cfg myname.cfg
+#        (2) Change items that are marked 'EDIT' (search for it)
+#
+# SPEC tested this config file with:
+#    Compiler version(s):    4.4.7, 4.9.2, 5.2.0, 6.3.0, 7.2.1, 8.1.0
+#    Operating system(s):    Oracle Linux Server 6.5 and 7.4 /
+#                            Red Hat Enterprise Linux Server 6.5 and 7.4
+#    Hardware:               Xeon
+#
+# If your system differs, this config file might not work.
+# You might find a better config file at http://www.spec.org/cpu2017/results
+#
+# Known Limitations with GCC 4
+#
+#   (1) Possible problem: compile time messages
+#                             error: unrecognized command line option '...'
+#      Recommendation:    Use a newer version of the compiler.
+#                         If that is not possible, remove the unrecognized
+#                         option from this config file.
+#
+#   (2) Possible problem: run time errors messages
+#           527.cam4_r or 627.cam4_s    *** Miscompare of cam4_validate.txt
+#      Recommendation: Use a newer version of the compiler.
+#                      If that is not possible, try reducing the optimization.
+#
+#
+# Compiler issues: Contact your compiler vendor, not SPEC.
+# For SPEC help:   http://www.spec.org/cpu2017/Docs/techsupport.html
+#------------------------------------------------------------------------------
+
+
+#--------- Label --------------------------------------------------------------
+# Arbitrary string to tag binaries (no spaces allowed)
+#                  Two Suggestions: # (1) EDIT this label as you try new ideas.
+%define label gcc                # (2)      Use a label meaningful to *you*.
+
+
+#--------- Preprocessor -------------------------------------------------------
+%ifndef %{bits}                # EDIT to control 32 or 64 bit compilation.  Or,
+%   define  bits        64     #      you can set it on the command line using:
+%endif                         #      'runcpu --define bits=nn'
+
+%ifndef %{build_ncpus}         # EDIT to adjust number of simultaneous compiles.
+%   define  build_ncpus 8      #      Or, you can set it on the command line:
+%endif                         #      'runcpu --define build_ncpus=nn'
+
+# Don't change this part.
+%define    os           LINUX
+%if %{bits} == 64
+%   define model        -m64
+%elif %{bits} == 32
+%   define model        -m32
+%else
+%   error Please define number of bits - see instructions in config file
+%endif
+%if %{label} =~ m/ /
+%   error Your label "%{label}" contains spaces.  Please try underscores instead.
+%endif
+%if %{label} !~ m/^[a-zA-Z0-9._-]+$/
+%   error Illegal character in label "%{label}".  Please use only alphanumerics, underscore, hyphen, and period.
+%endif
+
+
+
+#--------- Global Settings ----------------------------------------------------
+# For info, see:
+#            https://www.spec.org/cpu2017/Docs/config.html#fieldname
+#   Example: https://www.spec.org/cpu2017/Docs/config.html#tune
+
+command_add_redirect = 1
+flagsurl             = $[top]/config/flags/gcc.xml
+ignore_errors        = 1
+iterations           = 1
+label                = %{label}-m%{bits}
+line_width           = 1020
+log_line_width       = 1020
+makeflags            = --jobs=%{build_ncpus}
+mean_anyway          = 1
+output_format        = txt,html,cfg,pdf,csv
+preenv               = 1
+reportable           = 0
+tune                 = base
+
+
+#--------- How Many CPUs? -----------------------------------------------------
+# Both SPECrate and SPECspeed can test multiple chips / cores / hw threads
+#    - For SPECrate,  you set the number of copies.
+#    - For SPECspeed, you set the number of threads.
+# See: https://www.spec.org/cpu2017/Docs/system-requirements.html#MultipleCPUs
+#
+#    q. How many should I set?
+#    a. Unknown, you will have to try it and see!
+#
+# To get you started, some suggestions:
+#
+#     copies - This config file defaults to testing only 1 copy.   You might
+#              try changing it to match the number of cores on your system,
+#              or perhaps the number of virtual CPUs as reported by:
+#                     grep -c processor /proc/cpuinfo
+#              Be sure you have enough memory.  See:
+#              https://www.spec.org/cpu2017/Docs/system-requirements.html#memory
+#
+#     threads - This config file sets a starting point.  You could try raising
+#               it.  A higher thread count is much more likely to be useful for
+#               fpspeed than for intspeed.
+#
+intrate,fprate:
+   copies           = 1   # EDIT to change number of copies (see above)
+intspeed,fpspeed:
+   threads          = 4   # EDIT to change number of OpenMP threads (see above)
+
+
+#------- Compilers ------------------------------------------------------------
+default:
+#  EDIT: The parent directory for your compiler.
+#        Do not include the trailing /bin/
+#        Do not include a trailing slash
+#  Examples:
+#   1  On a Red Hat system, you said
+#      'yum install devtoolset-7'
+#      Use:                 %   define gcc_dir /opt/rh/devtoolset-7/root/usr
+#
+#   2  You built GCC in:                       /disk1/mybuild/gcc-8.1.0/bin/gcc
+#      Use:                 %   define gcc_dir /disk1/mybuild/gcc-8.1.0
+#
+#   3  You want:                               /usr/bin/gcc
+#      Use:                 %   define gcc_dir /usr
+#      WARNING: See section
+#      "Known Limitations with GCC 4"
+#
+%ifndef %{gcc_dir}
+%   define  gcc_dir        /home/sun/emui/maple_opensource/opensource/tools/gcc-linaro-7.5.0  # EDIT (see above)
+%endif
+
+# EDIT if needed: the preENV line adds library directories to the runtime
+#      path.  You can adjust it, or add lines for other environment variables.
+#      See: https://www.spec.org/cpu2017/Docs/config.html#preenv
+#      and: https://gcc.gnu.org/onlinedocs/gcc/Environment-Variables.html
+   SPECLANG                = %{gcc_dir}/bin/
+   CC                      = $(SPECLANG)aarch64-linux-gnu-gcc     -std=c99  
+   CXX                     = $(SPECLANG)g++     -std=c++03 %{model}
+   FC                      = $(SPECLANG)gfortran           %{model}
+   # How to say "Show me your version, please"
+   CC_VERSION_OPTION       = -v
+   CXX_VERSION_OPTION      = -v
+   FC_VERSION_OPTION       = -v
+
+default:
+%if %{bits} == 64
+   sw_base_ptrsize = 64-bit
+   sw_peak_ptrsize = 64-bit
+%else
+   sw_base_ptrsize = 32-bit
+   sw_peak_ptrsize = 32-bit
+%endif
+
+
+#--------- Portability --------------------------------------------------------
+default:               # data model applies to all benchmarks
+%if %{bits} == 32
+    # Strongly recommended because at run-time, operations using modern file
+    # systems may fail spectacularly and frequently (or, worse, quietly and
+    # randomly) if a program does not accommodate 64-bit metadata.
+    EXTRA_PORTABILITY = -D_FILE_OFFSET_BITS=64
+%else
+    EXTRA_PORTABILITY = -DSPEC_LP64
+%endif
+
+# Benchmark-specific portability (ordered by last 2 digits of bmark number)
+
+500.perlbench_r,600.perlbench_s:  #lang='C'
+%if %{bits} == 32
+%   define suffix IA32
+%else
+%   define suffix X64
+%endif
+   PORTABILITY    = -DSPEC_%{os}_%{suffix}
+
+521.wrf_r,621.wrf_s:  #lang='F,C'
+   CPORTABILITY  = -DSPEC_CASE_FLAG
+   FPORTABILITY  = -fconvert=big-endian
+
+523.xalancbmk_r,623.xalancbmk_s:  #lang='CXX'
+   PORTABILITY   = -DSPEC_%{os}
+
+526.blender_r:  #lang='CXX,C'
+   PORTABILITY   = -funsigned-char -DSPEC_LINUX
+
+527.cam4_r,627.cam4_s:  #lang='F,C'
+   PORTABILITY   = -DSPEC_CASE_FLAG
+
+628.pop2_s:  #lang='F,C'
+   CPORTABILITY    = -DSPEC_CASE_FLAG
+   FPORTABILITY    = -fconvert=big-endian
+
+
+#-------- Tuning Flags common to Base and Peak --------------------------------
+
+#
+# Speed (OpenMP and Autopar allowed)
+#
+%if %{bits} == 32
+   intspeed,fpspeed:
+   #
+   # Many of the speed benchmarks (6nn.benchmark_s) do not fit in 32 bits
+   # If you wish to run SPECint2017_speed or SPECfp2017_speed, please use
+   #
+   #     runcpu --define bits=64
+   #
+   fail_build = 1
+%else
+   intspeed,fpspeed:
+      EXTRA_OPTIMIZE = -fopenmp -DSPEC_OPENMP
+   fpspeed:
+      #
+      # 627.cam4 needs a big stack; the preENV will apply it to all
+      # benchmarks in the set, as required by the rules.
+      #
+      preENV_OMP_STACKSIZE = 120M
+%endif
+
+
+#--------  Baseline Tuning Flags ----------------------------------------------
+#
+# EDIT if needed -- Older GCC might not support some of the optimization
+#                   switches here.  See also 'About the -fno switches' below.
+#
+default=base:         # flags for all base
+   OPTIMIZE       = -O2 -fno-pie -fno-unsafe-math-optimizations  -fno-tree-loop-vectorize
+
+intrate,intspeed=base: # flags for integer base
+   EXTRA_COPTIMIZE = -fno-strict-aliasing -fgnu89-inline
+# Notes about the above
+#  - 500.perlbench_r/600.perlbench_s needs -fno-strict-aliasing.
+#  - 502.gcc_r/602.gcc_s             needs -fgnu89-inline or -z muldefs
+#  - For 'base', all benchmarks in a set must use the same options.
+#  - Therefore, all base benchmarks get the above.  See:
+#       www.spec.org/cpu2017/Docs/runrules.html#BaseFlags
+#       www.spec.org/cpu2017/Docs/benchmarks/500.perlbench_r.html
+#       www.spec.org/cpu2017/Docs/benchmarks/502.gcc_r.html
+
+
+#--------  Peak Tuning Flags ----------------------------------------------
+default=peak:
+   basepeak = yes  # if you develop some peak tuning, remove this line.
+   #
+   # -----------------------
+   # About the -fno switches
+   # -----------------------
+   #
+   # For 'base', this config file (conservatively) disables some optimizations.
+   # You might want to try turning some of them back on, by creating a 'peak'
+   # section here, with individualized benchmark options:
+   #
+   #        500.perlbench_r=peak:
+   #           OPTIMIZE = this
+   #        502.gcc_r=peak:
+   #           OPTIMIZE = that
+   #        503.bwaves_r=peak:
+   #           OPTIMIZE = other   .....(and so forth)
+   #
+   # If you try it:
+   #   - You must remove the 'basepeak' option, above.
+   #   - You will need time and patience, to diagnose and avoid any errors.
+   #   - perlbench is unlikely to work with strict aliasing
+   #   - Some floating point benchmarks may get wrong answers, depending on:
+   #         the particular chip
+   #         the version of GCC
+   #         other optimizations enabled
+   #         -m32 vs. -m64
+   #   - See: http://www.spec.org/cpu2017/Docs/config.html
+   #   - and: http://www.spec.org/cpu2017/Docs/runrules.html
+
+
+#------------------------------------------------------------------------------
+# Tester and System Descriptions - EDIT all sections below this point
+#------------------------------------------------------------------------------
+#   For info about any field, see
+#             https://www.spec.org/cpu2017/Docs/config.html#fieldname
+#   Example:  https://www.spec.org/cpu2017/Docs/config.html#hw_memory
+#-------------------------------------------------------------------------------
+
+#--------- EDIT to match your version -----------------------------------------
+default:
+   sw_compiler001   = C/C++/Fortran: Version 7.2.1 of GCC, the
+   sw_compiler002   = GNU Compiler Collection
+
+#--------- EDIT info about you ------------------------------------------------
+# To understand the difference between hw_vendor/sponsor/tester, see:
+#     https://www.spec.org/cpu2017/Docs/config.html#test_sponsor
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+   hw_vendor          = My Corporation
+   tester             = My Corporation
+   test_sponsor       = My Corporation
+   license_num        = nnn (Your SPEC license number)
+#  prepared_by        = # Ima Pseudonym                       # Whatever you like: is never output
+
+
+#--------- EDIT system availability dates -------------------------------------
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+                        # Example                             # Brief info about field
+   hw_avail           = # Nov-2099                            # Date of LAST hardware component to ship
+   sw_avail           = # Nov-2099                            # Date of LAST software component to ship
+
+#--------- EDIT system information --------------------------------------------
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+                        # Example                             # Brief info about field
+#  hw_cpu_name        = # Intel Xeon E9-9999 v9               # chip name
+   hw_cpu_nominal_mhz = # 9999                                # Nominal chip frequency, in MHz
+   hw_cpu_max_mhz     = # 9999                                # Max chip frequency, in MHz
+#  hw_disk            = # 9 x 9 TB SATA III 9999 RPM          # Size, type, other perf-relevant info
+   hw_model           = # TurboBlaster 3000                   # system model name
+#  hw_nchips          = # 99                                  # number chips enabled
+   hw_ncores          = # 9999                                # number cores enabled
+   hw_ncpuorder       = # 1-9 chips                           # Ordering options
+   hw_nthreadspercore = # 9                                   # number threads enabled per core
+   hw_other           = # TurboNUMA Router 10 Gb              # Other perf-relevant hw, or "None"
+
+#  hw_memory001       = # 999 GB (99 x 9 GB 2Rx4 PC4-2133P-R, # The 'PCn-etc' is from the JEDEC
+#  hw_memory002       = # running at 1600 MHz)                # label on the DIMM.
+
+   hw_pcache          = # 99 KB I + 99 KB D on chip per core  # Primary cache size, type, location
+   hw_scache          = # 99 KB I+D on chip per 9 cores       # Second cache or "None"
+   hw_tcache          = # 9 MB I+D on chip per chip           # Third  cache or "None"
+   hw_ocache          = # 9 GB I+D off chip per system board  # Other cache or "None"
+
+   fw_bios            = # American Megatrends 39030100 02/29/2016 # Firmware information
+#  sw_file            = # ext99                               # File system
+#  sw_os001           = # Linux Sailboat                      # Operating system
+#  sw_os002           = # Distribution 7.2 SP1                # and version
+   sw_other           = # TurboHeap Library V8.1              # Other perf-relevant sw, or "None"
+#  sw_state           = # Run level 99                        # Software state.
+
+# Note: Some commented-out fields above are automatically set to preliminary
+# values by sysinfo
+#       https://www.spec.org/cpu2017/Docs/config.html#sysinfo
+# Uncomment lines for which you already know a better answer than sysinfo
+
+__HASH__
+500.perlbench_r=base=maple_test-m64:
+# Last updated 2021-05-10 10:36:40
+opthash=1b55f44e78c515229834a282ce9d3013fee214077130f5cc6c8d469cce53274c
+baggage=
+compiler_version=\
+@eNp9VE1v2zAMvftX+NYNteK26ZIigA9Z6hYD0qZI3e0YyBLtqJUlTx+J08N++2Qnjr202MWC+Cjy\
+kXy0P5utfsbL5x+Lx9XiKXHHxHvRTOR+ahk3iAlfl0D0wJst5vN4lqzuZ7MotFqFKRNhTsgRmCeL\
+1a/l9OkpXu4dOEtrh7C6Ga1G14gzYSuUCxuOQ24k2ipclqC8xd3dfDG9XSXT5X2crB6nD/FzJDal\
+qZCQAk7x2/hu+jJPoksvwSoHM/FP43szKTKWWwXU3zKznviDQagVCUlr99HGR6jGUPmWb0BpJkV0\
+9pJaYaw/HnwbXKChbW6Xfy5vBhfXZ61/al0AHmWMwyQMmzr1GisIqSR1tWgcLuPp7UM8+G5z7V6B\
+wCkHxLHILc5BRyTAFAfk/DzIZZAqlgc0yKQyCotApq+k/iAHu7elgoxVTTfb/HWKAr9KhQ60kRR8\
+1/jKXOECaZvVb9C4ZzvEOW0U6ug1NdAeXSbeQKFaBBSxGnDThAoIZeo43QMnaWudEG4pUOQmYqAy\
+XSSzVoCpjkqpWbWPcxLj4Ch4r12plEa7lpSdiXBJMIfIEe/zTLWhpKoQBTeazwDDCoh2oNsOUsiw\
+ddLuPHDKIgHb7nHdGyvYbwvIDQNIXQ5lusE2Zn+AYtnun3xFWXX3ktvcLc/x3mYtGbRE9E4bKNB7\
+10lkGkmfIIcItTbc+CNsjeyshQvKsCLrHsUtKCWPiqlBNLyK2OhmdLS5iovRdXttgrhkrgptomJ4\
+FTgwKKrh1UmiPlUr3CxAuD6QHsks4xLTQyG6t8c9sRBLMaKKuR72xrsG8uZ+PJECDljX/o36PqjW\
+AWvpaH5i32f9gHhJo0G/kBT4xG+U6LlF8g8rtN94/8t/9v+r7/0FuibFEg==
+compile_options=\
+@eNrVU21r2zAQ/u5fIfxdccdGWUJdsB0l8eZEwrIh2xfhOkqqLZaD5IS1v34n56UtDFpGv1RgfLq3\
+R3fP3aLVuKl+y7XaStTuOtVqO/JsZ1TdCbPXK2XEQRq1fgj9T74HogWX0L8aDK+ufc9L6JyNkB/s\
+rQnulA42dY3cwbZbhfVw6MTm+gvCNcLtGWDQIjzmjCTwW4xJXE5BYCTPREJzgnA6gG+lbBekFKR6\
+V+mgUI3EM5VLe9bMinmGWWWsNKCSf7rASBDsTtam0itIOaZlnBHBs4jPCBcOMY2y8OqELqKyoIKX\
+jOWEc0EZWcwZ2EQW5VMiJmlG+OXqboLTMk+I0/VXOplwUog4LXgINSK8QZh+hoIrU9+HuurUAV60\
+1i3ea1utJRi6e+ya0KjHqm8FOto7IyXetu0OH2TdtUY9SnQ6p7dm6aJciqWDOcUcScLVVlVWaYBe\
+b/T+6xArvVVaPotkLujGtntTy1vfS0YoScJXKTs60vgbZUXov+DP94DzhJWTLJpysL3ksrfGZJHM\
+xMXhw5Pre3SEoBPpPP1JoKL3ZLpvGKN5EcVplhY/zh194rxHJ8sij6CJT494fQr61MfAfwIwlxtg\
+vr9lh4/Kd5/x/x3wm/buFySyt85/26DLwlzmFKF+iLPxW6b9g/IL9c2jYga5Yrdp2+ZUMi3d1j5b\
+2b8rRMvz
+exehash=1c69320bf26365e65e5b19b87fd09bbfdf73b3d6257845446d6001048f92fd40
+
+500.perlbench_r=base=gcc-m64:
+# Last updated 2021-05-13 10:18:46
+opthash=4a1fc46ed4b7dc5c387a83a4c8727837cdc03d41f8bddf80c915370e9e6911bd
+baggage=
+compiler_version=\
+@eNq9VUtv2zAMvudX6NYNraKmj7QJ4MMQBNuAYAnabDsasszYamRJ06Nxd9hvn2zHtddmGLBuvcSh\
++PjITySFZrP4y/zm9uPyU7xcrcNnOvhsucxQ4rlwmEtkNTA7HMyWi8V8to7fz2YRyVUBxHpJoPCc\
+FFQLiJUGaZU3DEjvr1NKWJIxhgWX1Ch8NbwcnpKES0KpYfn4olL4EmfS42D2iLNYL+OvN+9Wq/nN\
+P8IbDongCZTAKv1zeNKYCqfwzlCtwQzW1GTgpuiZ7WCm5IZn3kCKdtzlU3TUJOnYLsMVd6kV9B7I\
+Tpmt1ZTtNQXdAjYggFqIR8RKqm2uXJ3xMOPuR5c1PjsdTYajM8JaqCN0+2G+WER1NQm1OcK4AseF\
+ZtHfwMe1JWnsSQrWpdwQPr4eY826YjuYjXkNnKzQrwITOo7aviTSIKXc0kRAsE8Kn24E1eEQZHPm\
+VCfYnFbX3/grXw0LEz6FFIeecVC6zlSKRxz7YB0U+HsI3wOzd+IOQ8lAO66k7TyrtLzk3zxgldwB\
+6wUNBW3BNPRg/iT1UDsry1B33jmwyaQnCMWogKgh5DFk65hC4rOeQsms/mnLCO4qi6RqZa1FT+J2\
+L7UZFV443pS8j7jhJWbKBJ4wvTzH1+eXV+PJ79UX5xejSRu+msaImuL+GtPOxeUGaGojrSwvu+Ma\
+uvI4VKbjBUQP8IRwLkPjBK7xxktWXUgL3HAdrtAo5V7So/sQ9vkW6vXJS0H+NAgHVmBghvV6JAe2\
+DY9BtA/du9Ckyt6ZX4aDyszTDGzETtjx8ckmXJ+h8qQZmjqZ6NAw5sq6gwpXb9/oEEXaQOiQ/0nO\
+YF23EypUCmKK6qYahC2N7sHYqiXq1wK9WdQLG4VnEfWW9ls0+Alw/ZnQ
+compile_options=\
+@eNrVVG1r2zAQ/u5fIfxdcca6bAl1wXaUxJsTCb9Ati/CdZREmy0ZyS5df/1kO0lTGAxGKVRgfKd7\
+eaS757SRAlb5L7bnJQOybrgUembpRvGioaoVO67oA1N8/9u1P9iWEbVxce3xaDqe2JYV4DWZAds5\
+yoo5uhUOq1ruVHldMiprJrRsVcGcK7GRstTOoShgyUWuJPw8+jQaO/dcOHmuiuPkpjO0j/AgWmjc\
+QLegbnZuMZ0CWAAozwcdSQDnCUGB+W3myM+WRiAojmiAYwRgODLfjuvGCbGRijoXTsorBlc8Zvq8\
+s0rXESS50kyZLfbYOIoZQdesULnYmZRznPkRoknkJSuU0A4x9CJ3fEKnXpZimmSExChJKCZosybG\
+RiMvXiK6CCOUXNROownO4gB1e72KF4sEpdQP08Sd3JjbHgDEHwHcCwlrzgahFTrfM9Os5gi7+1f8\
+Ke+rAAZ7oxiDpZQ1fGBFIxV/YuC0TseMwk22pdsO4RQz9BnmJc81FwZ1b4r+ZQq5MC1gV5GkC7od\
+OnhnW8EMBIH7Zl0fALH/FZPUtV9QwLYM/QKSLSJvmRjbSzr0Vh9tghW9OLx7ftgWngFTiXAd/kDm\
+Rq9Elr5WBMep54dRmH4/F/OZNj0w2qaxZ+r3jP9vIvWph8C/ApAut4H59pYvyaC95qT975jdyvuf\
+JpG+6/zLClzG9sJyAPoRiOZvOXPvj2WmRGsvXZlcfjfqZXWqGs66Z+PqzfgDFjQx9g==
+exehash=6baceb9eb267d444c46c4c9f978e50063408522981011f9ac78e7db729fc8926
+
+519.lbm_r=base=gcc-m64:
+# Last updated 2021-05-13 10:35:31
+opthash=d0595b41acba249b4b15e2950cf3b949e9504a149adac9800b3de173849eacd9
+baggage=
+compiler_version=\
+@eNq9VUtv2zAMvudX6NYNraKmj7QJ4MMQBNuAYAnabDsasszYamRJ06Nxd9hvn2zHtddmGLBuvcSh\
++PjITySFZrP4y/zm9uPyU7xcrcNnOvhsucxQ4rlwmEtkNTA7HMyWi8V8to7fz2YRyVUBxHpJoPCc\
+FFQLiJUGaZU3DEjvr1NKWJIxhgWX1Ch8NbwcnpKES0KpYfn4olL4EmfS42D2iLNYL+OvN+9Wq/nN\
+P8IbDongCZTAKv1zeNKYCqfwzlCtwQzW1GTgpuiZ7WCm5IZn3kCKdtzlU3TUJOnYLsMVd6kV9B7I\
+Tpmt1ZTtNQXdAjYggFqIR8RKqm2uXJ3xMOPuR5c1PjsdTYajM8JaqCN0+2G+WER1NQm1OcK4AseF\
+ZtHfwMe1JWnsSQrWpdwQPr4eY826YjuYjXkNnKzQrwITOo7aviTSIKXc0kRAsE8Kn24E1eEQZHPm\
+VCfYnFbX3/grXw0LEz6FFIeecVC6zlSKRxz7YB0U+HsI3wOzd+IOQ8lAO66k7TyrtLzk3zxgldwB\
+6wUNBW3BNPRg/iT1UDsry1B33jmwyaQnCMWogKgh5DFk65hC4rOeQsms/mnLCO4qi6RqZa1FT+J2\
+L7UZFV443pS8j7jhJWbKBJ4wvTzH1+eXV+PJ79UX5xejSRu+msaImuL+GtPOxeUGaGojrSwvu+Ma\
+uvI4VKbjBUQP8IRwLkPjBK7xxktWXUgL3HAdrtAo5V7So/sQ9vkW6vXJS0H+NAgHVmBghvV6JAe2\
+DY9BtA/du9Ckyt6ZX4aDyszTDGzETtjx8ckmXJ+h8qQZmjqZ6NAw5sq6gwpXb9/oEEXaQOiQ/0nO\
+YF23EypUCmKK6qYahC2N7sHYqiXq1wK9WdQLG4VnEfWW9ls0+Alw/ZnQ
+compile_options=\
+@eNq9UlFPgzAQfudXNH3vmNFptsgSYKgoo82ARH1pkHVbFVrSglF/vWXM6RIfdffSu97lu7vvvlgK\
+VOUvbMVLBmTdcCn0xNKN4kVDVSuWXNFXpvjq3YEn0DKuNiUOHA7GwxG0LB/PyQRAeyMrZutW2Kxq\
+uV3ldcmorJnQslUFs3+4jZSlttdFgUouciXRxWA0GNpPXNh5rorN+VmXaN/QWrTIlIHOkG6WTjEe\
+A1QAJL8GHUiAZgkJfPPEs8DLrncxdbMU0yQjZBEkCcUkiOfEoKwBwqcArYRENWe90wqdr5ghodmg\
+DrfiH/kWHfT5RjGGSilr9MqKRir+wcCh7XpG5PwMgMt+zSm0/Anwfedo1PQNsXeLSerAA56gZW7k\
+k+wqcq8TkzvkbJv1gti/oQcFv5IILTwBpkM4Dx8DU/lHjG5nCO7ThUsJXqSuF0Zh+rCfpKMWWlEY\
+3x1Ta33055q5lE/P5ldPO/Sy+pbR/l4AbI8ZzY6pnn+6q9lj7qY3NAq9TllltVsNZ51Kf0j0E2qG\
+c4o=
+exehash=b17469e48480b17716b457cef173dcb01bb9f937e33f10bfda3c01e7cce63d3b
+
+538.imagick_r=base=gcc-m64:
+# Last updated 2021-06-01 19:42:39
+opthash=f82ded290c3df58b7c2eebd89f6f9377bf6eeeea69047f4bcaf68dd02039245c
+baggage=
+compiler_version=\
+@eNq9VUtv2zAMvudX6NYNraKmj7QJ4MMQBNuAYAnabDsasszYamRJ06Nxd9hvn2zHtddmGLBuvcSh\
++PjITySFZrP4y/zm9uPyU7xcrcNnOvhsucxQ4rlwmEtkNTA7HMyWi8V8to7fz2YRyVUBxHpJoPCc\
+FFQLiJUGaZU3DEjvr1NKWJIxhgWX1Ch8NbwcnpKES0KpYfn4olL4EmfS42D2iLNYL+OvN+9Wq/nN\
+P8IbDongCZTAKv1zeNKYCqfwzlCtwQzW1GTgpuiZ7WCm5IZn3kCKdtzlU3TUJOnYLsMVd6kV9B7I\
+Tpmt1ZTtNQXdAjYggFqIR8RKqm2uXJ3xMOPuR5c1PjsdTYajM8JaqCN0+2G+WER1NQm1OcK4AseF\
+ZtHfwMe1JWnsSQrWpdwQPr4eY826YjuYjXkNnKzQrwITOo7aviTSIKXc0kRAsE8Kn24E1eEQZHPm\
+VCfYnFbX3/grXw0LEz6FFIeecVC6zlSKRxz7YB0U+HsI3wOzd+IOQ8lAO66k7TyrtLzk3zxgldwB\
+6wUNBW3BNPRg/iT1UDsry1B33jmwyaQnCMWogKgh5DFk65hC4rOeQsms/mnLCO4qi6RqZa1FT+J2\
+L7UZFV443pS8j7jhJWbKBJ4wvTzH1+eXV+PJ79UX5xejSRu+msaImuL+GtPOxeUGaGojrSwvu+Ma\
+uvI4VKbjBUQP8IRwLkPjBK7xxktWXUgL3HAdrtAo5V7So/sQ9vkW6vXJS0H+NAgHVmBghvV6JAe2\
+DY9BtA/du9Ckyt6ZX4aDyszTDGzETtjx8ckmXJ+h8qQZmjqZ6NAw5sq6gwpXb9/oEEXaQOiQ/0nO\
+YF23EypUCmKK6qYahC2N7sHYqiXq1wK9WdQLG4VnEfWW9ls0+Alw/ZnQ
+compile_options=\
+@eNrtVE1vozAQvfMrLN8N6SrbKlGpBIS27BJsBZC6e7EodRq3YCMbqm5+/RpI2ubSU5tTfPHgGebj\
+zdNLpEB18czWvGJANi2XQs8t3SpetlR14oEr+sIUX/9z4Rm0jKlNiAsn9mwyhZYV4CWZA+hsZM0c\
+3QmH1R136qKpGJUNE1p2qmTOB7OVstLOY1miiotCSXRh/7Qnzj0XTlGocnM+7R3dK3oUHTJhoD9I\
+tw9uOZsBVAIk943aEqBFSsLAXMki9PMbgCJ790a9PMM0zQlZhWlKMQmTJTGZ8A+A1kKihrPR6IQu\
+1syg0G5Qn7jm22JID0Z/qxhDlZQNemFlKxXf7n7kwjTKwOHZFY/J+RSAy3HmK2gFcxAE7tFwGgti\
+/xcmmQsPQIOWWVhA8uvYu0mN7xDAweuHSXBL9wGfIwotPAemSrSM/oYm+qvhHRoK77KVRwleZZ4f\
+xVH2Z9/3gDO04ij5fUwWjl/fx6RLef9kIvRVX6aq38n1tkUAhhXHi2Ny6rs3bQZaetktjSO/J15V\
+72bEeU/iDww+yc5Jdk6yc5KdI8vOf2Dz8Is=
+exehash=5fecfa5494e0b35756916f9e524fafee9ba36469de705f9e33ee6082bdf1d8bc
+
diff --git a/build/tools/spec/maplec b/build/tools/spec/maplec
new file mode 120000
index 0000000000000000000000000000000000000000..0d46bbe86784244a11ac16fcbfe9e9b01a5f94da
--- /dev/null
+++ b/build/tools/spec/maplec
@@ -0,0 +1 @@
+../common/maplec
\ No newline at end of file
diff --git a/build/tools/spec/mplfe.cfg b/build/tools/spec/mplfe.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..523eccea9e626bf2d1bf86c003f9ee2498354621
--- /dev/null
+++ b/build/tools/spec/mplfe.cfg
@@ -0,0 +1,643 @@
+#------------------------------------------------------------------------------
+# SPEC CPU2017 config file for: gcc / g++ / gfortran on Linux x86
+#------------------------------------------------------------------------------
+#
+# Usage: (1) Copy this to a new name
+#             cd $SPEC/config
+#             cp Example-x.cfg myname.cfg
+#        (2) Change items that are marked 'EDIT' (search for it)
+#
+# SPEC tested this config file with:
+#    Compiler version(s):    4.4.7, 4.9.2, 5.2.0, 6.3.0, 7.2.1, 8.1.0
+#    Operating system(s):    Oracle Linux Server 6.5 and 7.4 /
+#                            Red Hat Enterprise Linux Server 6.5 and 7.4
+#    Hardware:               Xeon
+#
+# If your system differs, this config file might not work.
+# You might find a better config file at http://www.spec.org/cpu2017/results
+#
+# Known Limitations with GCC 4
+#
+#   (1) Possible problem: compile time messages
+#                             error: unrecognized command line option '...'
+#      Recommendation:    Use a newer version of the compiler.
+#                         If that is not possible, remove the unrecognized
+#                         option from this config file.
+#
+#   (2) Possible problem: run time errors messages
+#           527.cam4_r or 627.cam4_s    *** Miscompare of cam4_validate.txt
+#      Recommendation: Use a newer version of the compiler.
+#                      If that is not possible, try reducing the optimization.
+#
+#
+# Compiler issues: Contact your compiler vendor, not SPEC.
+# For SPEC help:   http://www.spec.org/cpu2017/Docs/techsupport.html
+#------------------------------------------------------------------------------
+
+
+#--------- Label --------------------------------------------------------------
+# Arbitrary string to tag binaries (no spaces allowed)
+#                  Two Suggestions: # (1) EDIT this label as you try new ideas.
+%define label maplec               # (2)      Use a label meaningful to *you*.
+
+
+#--------- Preprocessor -------------------------------------------------------
+%ifndef %{bits}                # EDIT to control 32 or 64 bit compilation.  Or,
+%   define  bits        64     #      you can set it on the command line using:
+%endif                         #      'runcpu --define bits=nn'
+
+%ifndef %{build_ncpus}         # EDIT to adjust number of simultaneous compiles.
+%   define  build_ncpus 8      #      Or, you can set it on the command line:
+%endif                         #      'runcpu --define build_ncpus=nn'
+
+# Don't change this part.
+%define    os           LINUX
+%if %{bits} == 64
+%   define model        -m64
+%elif %{bits} == 32
+%   define model        -m32
+%else
+%   error Please define number of bits - see instructions in config file
+%endif
+%if %{label} =~ m/ /
+%   error Your label "%{label}" contains spaces.  Please try underscores instead.
+%endif
+%if %{label} !~ m/^[a-zA-Z0-9._-]+$/
+%   error Illegal character in label "%{label}".  Please use only alphanumerics, underscore, hyphen, and period.
+%endif
+
+
+
+#--------- Global Settings ----------------------------------------------------
+# For info, see:
+#            https://www.spec.org/cpu2017/Docs/config.html#fieldname
+#   Example: https://www.spec.org/cpu2017/Docs/config.html#tune
+
+command_add_redirect = 1
+flagsurl             = $[top]/config/flags/gcc.xml
+ignore_errors        = 1
+iterations           = 1
+label                = %{label}-m%{bits}
+line_width           = 1020
+log_line_width       = 1020
+makeflags            = --jobs=%{build_ncpus}
+mean_anyway          = 1
+output_format        = txt,html,cfg,pdf,csv
+preenv               = 1
+reportable           = 0
+tune                 = base
+
+
+#--------- How Many CPUs? -----------------------------------------------------
+# Both SPECrate and SPECspeed can test multiple chips / cores / hw threads
+#    - For SPECrate,  you set the number of copies.
+#    - For SPECspeed, you set the number of threads.
+# See: https://www.spec.org/cpu2017/Docs/system-requirements.html#MultipleCPUs
+#
+#    q. How many should I set?
+#    a. Unknown, you will have to try it and see!
+#
+# To get you started, some suggestions:
+#
+#     copies - This config file defaults to testing only 1 copy.   You might
+#              try changing it to match the number of cores on your system,
+#              or perhaps the number of virtual CPUs as reported by:
+#                     grep -c processor /proc/cpuinfo
+#              Be sure you have enough memory.  See:
+#              https://www.spec.org/cpu2017/Docs/system-requirements.html#memory
+#
+#     threads - This config file sets a starting point.  You could try raising
+#               it.  A higher thread count is much more likely to be useful for
+#               fpspeed than for intspeed.
+#
+intrate,fprate:
+   copies           = 1   # EDIT to change number of copies (see above)
+intspeed,fpspeed:
+   threads          = 4   # EDIT to change number of OpenMP threads (see above)
+
+%ifndef %{gcc_dir}
+%   define  gcc_dir        /gcc_dir-is-not-used/tools/gcc-linaro-7.5.0  # EDIT (see above)
+%endif
+
+#------- Compilers ------------------------------------------------------------
+default:
+#  EDIT: The parent directory for your compiler.
+#        Do not include the trailing /bin/
+#        Do not include a trailing slash
+#  Examples:
+#   1  On a Red Hat system, you said
+#      'yum install devtoolset-7'
+#      Use:                 %   define gcc_dir /opt/rh/devtoolset-7/root/usr
+#
+#   2  You built GCC in:                       /disk1/mybuild/gcc-8.1.0/bin/gcc
+#      Use:                 %   define gcc_dir /disk1/mybuild/gcc-8.1.0
+#
+#   3  You want:                               /usr/bin/gcc
+#      Use:                 %   define gcc_dir /usr
+#      WARNING: See section
+#      "Known Limitations with GCC 4"
+#
+   LINARO                  = $MAPLE_ROOT/tools/gcc-linaro-7.5.0
+   CC                      = $(MAPLE_ROOT)/build/tools/spec/maplec
+   CXX                     = $(LINARO)/bin/aarch64-linux-gnu-g++ -std=c++03
+   FC                      = $(LINARO)/bin/aarch64-linux-gnu-gfortran
+   # How to say "Show me your version, please"
+   CC_VERSION_OPTION       = -v
+   CXX_VERSION_OPTION      = -v
+   FC_VERSION_OPTION       = -v
+
+   QEMU_RUN                = $MAPLE_ROOT/tools/bin/qemu-aarch64 -L $LINARO/aarch64-linux-gnu/libc
+
+default:
+%if %{bits} == 64
+   sw_base_ptrsize = 64-bit
+   sw_peak_ptrsize = 64-bit
+%else
+   sw_base_ptrsize = 32-bit
+   sw_peak_ptrsize = 32-bit
+%endif
+
+
+#--------- Portability --------------------------------------------------------
+default:               # data model applies to all benchmarks
+%if %{bits} == 32
+    # Strongly recommended because at run-time, operations using modern file
+    # systems may fail spectacularly and frequently (or, worse, quietly and
+    # randomly) if a program does not accommodate 64-bit metadata.
+    EXTRA_PORTABILITY = -D_FILE_OFFSET_BITS=64
+%else
+    EXTRA_PORTABILITY = -DSPEC_LP64
+%endif
+
+# Benchmark-specific portability (ordered by last 2 digits of bmark number)
+
+500.perlbench_r,600.perlbench_s:  #lang='C'
+%if %{bits} == 32
+%   define suffix IA32
+%else
+%   define suffix X64
+%endif
+   PORTABILITY    = -DSPEC_%{os}_%{suffix}
+
+502.gcc_r:  #lang='c'
+   CPORTABILITY  = -DHAVE_ALLOCA_H
+
+521.wrf_r,621.wrf_s:  #lang='F,C'
+   CPORTABILITY  = -DSPEC_CASE_FLAG
+   FPORTABILITY  = -fconvert=big-endian
+
+523.xalancbmk_r,623.xalancbmk_s:  #lang='CXX'
+   PORTABILITY   = -DSPEC_%{os}
+
+526.blender_r:  #lang='CXX,C'
+   PORTABILITY   = -funsigned-char -DSPEC_LINUX
+
+527.cam4_r,627.cam4_s:  #lang='F,C'
+   PORTABILITY   = -DSPEC_CASE_FLAG
+
+628.pop2_s:  #lang='F,C'
+   CPORTABILITY    = -DSPEC_CASE_FLAG
+   FPORTABILITY    = -fconvert=big-endian
+
+
+#-------- Tuning Flags common to Base and Peak --------------------------------
+
+#
+# Speed (OpenMP and Autopar allowed)
+#
+%if %{bits} == 32
+   intspeed,fpspeed:
+   #
+   # Many of the speed benchmarks (6nn.benchmark_s) do not fit in 32 bits
+   # If you wish to run SPECint2017_speed or SPECfp2017_speed, please use
+   #
+   #     runcpu --define bits=64
+   #
+   fail_build = 1
+%else
+   intspeed,fpspeed:
+      EXTRA_OPTIMIZE = -fopenmp -lgomp -DSPEC_OPENMP
+   fpspeed:
+      #
+      # 627.cam4 needs a big stack; the preENV will apply it to all
+      # benchmarks in the set, as required by the rules.
+      #
+      preENV_OMP_STACKSIZE = 120M
+%endif
+
+
+#--------  Baseline Tuning Flags ----------------------------------------------
+#
+# EDIT if needed -- Older GCC might not support some of the optimization
+#                   switches here.  See also 'About the -fno switches' below.
+#
+default=base:         # flags for all base
+   OPTIMIZE       = 
+
+intrate,intspeed=base: # flags for integer base
+   EXTRA_COPTIMIZE = 
+# Notes about the above
+#  - 500.perlbench_r/600.perlbench_s needs -fno-strict-aliasing.
+#  - 502.gcc_r/602.gcc_s             needs -fgnu89-inline or -z muldefs
+#  - For 'base', all benchmarks in a set must use the same options.
+#  - Therefore, all base benchmarks get the above.  See:
+#       www.spec.org/cpu2017/Docs/runrules.html#BaseFlags
+#       www.spec.org/cpu2017/Docs/benchmarks/500.perlbench_r.html
+#       www.spec.org/cpu2017/Docs/benchmarks/502.gcc_r.html
+
+
+#--------  Peak Tuning Flags ----------------------------------------------
+default=peak:
+   basepeak = yes  # if you develop some peak tuning, remove this line.
+   #
+   # -----------------------
+   # About the -fno switches
+   # -----------------------
+   #
+   # For 'base', this config file (conservatively) disables some optimizations.
+   # You might want to try turning some of them back on, by creating a 'peak'
+   # section here, with individualized benchmark options:
+   #
+   #        500.perlbench_r=peak:
+   #           OPTIMIZE = this
+   #        502.gcc_r=peak:
+   #           OPTIMIZE = that
+   #        503.bwaves_r=peak:
+   #           OPTIMIZE = other   .....(and so forth)
+   #
+   # If you try it:
+   #   - You must remove the 'basepeak' option, above.
+   #   - You will need time and patience, to diagnose and avoid any errors.
+   #   - perlbench is unlikely to work with strict aliasing
+   #   - Some floating point benchmarks may get wrong answers, depending on:
+   #         the particular chip
+   #         the version of GCC
+   #         other optimizations enabled
+   #         -m32 vs. -m64
+   #   - See: http://www.spec.org/cpu2017/Docs/config.html
+   #   - and: http://www.spec.org/cpu2017/Docs/runrules.html
+
+
+#------------------------------------------------------------------------------
+# Tester and System Descriptions - EDIT all sections below this point
+#------------------------------------------------------------------------------
+#   For info about any field, see
+#             https://www.spec.org/cpu2017/Docs/config.html#fieldname
+#   Example:  https://www.spec.org/cpu2017/Docs/config.html#hw_memory
+#-------------------------------------------------------------------------------
+
+#--------- EDIT to match your version -----------------------------------------
+default:
+   sw_compiler001   = C/C++/Fortran: Version 7.2.1 of GCC, the
+   sw_compiler002   = GNU Compiler Collection
+
+#--------- EDIT info about you ------------------------------------------------
+# To understand the difference between hw_vendor/sponsor/tester, see:
+#     https://www.spec.org/cpu2017/Docs/config.html#test_sponsor
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+   hw_vendor          = My Corporation
+   tester             = My Corporation
+   test_sponsor       = My Corporation
+   license_num        = nnn (Your SPEC license number)
+#  prepared_by        = # Ima Pseudonym                       # Whatever you like: is never output
+
+
+#--------- EDIT system availability dates -------------------------------------
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+                        # Example                             # Brief info about field
+   hw_avail           = # Nov-2099                            # Date of LAST hardware component to ship
+   sw_avail           = # Nov-2099                            # Date of LAST software component to ship
+
+#--------- EDIT system information --------------------------------------------
+intrate,intspeed,fprate,fpspeed: # Important: keep this line
+                        # Example                             # Brief info about field
+#  hw_cpu_name        = # Intel Xeon E9-9999 v9               # chip name
+   hw_cpu_nominal_mhz = # 9999                                # Nominal chip frequency, in MHz
+   hw_cpu_max_mhz     = # 9999                                # Max chip frequency, in MHz
+#  hw_disk            = # 9 x 9 TB SATA III 9999 RPM          # Size, type, other perf-relevant info
+   hw_model           = # TurboBlaster 3000                   # system model name
+#  hw_nchips          = # 99                                  # number chips enabled
+   hw_ncores          = # 9999                                # number cores enabled
+   hw_ncpuorder       = # 1-9 chips                           # Ordering options
+   hw_nthreadspercore = # 9                                   # number threads enabled per core
+   hw_other           = # TurboNUMA Router 10 Gb              # Other perf-relevant hw, or "None"
+
+#  hw_memory001       = # 999 GB (99 x 9 GB 2Rx4 PC4-2133P-R, # The 'PCn-etc' is from the JEDEC
+#  hw_memory002       = # running at 1600 MHz)                # label on the DIMM.
+
+   hw_pcache          = # 99 KB I + 99 KB D on chip per core  # Primary cache size, type, location
+   hw_scache          = # 99 KB I+D on chip per 9 cores       # Second cache or "None"
+   hw_tcache          = # 9 MB I+D on chip per chip           # Third  cache or "None"
+   hw_ocache          = # 9 GB I+D off chip per system board  # Other cache or "None"
+
+   fw_bios            = # American Megatrends 39030100 02/29/2016 # Firmware information
+#  sw_file            = # ext99                               # File system
+#  sw_os001           = # Linux Sailboat                      # Operating system
+#  sw_os002           = # Distribution 7.2 SP1                # and version
+   sw_other           = # TurboHeap Library V8.1              # Other perf-relevant sw, or "None"
+#  sw_state           = # Run level 99                        # Software state.
+
+# Note: Some commented-out fields above are automatically set to preliminary
+# values by sysinfo
+#       https://www.spec.org/cpu2017/Docs/config.html#sysinfo
+# Uncomment lines for which you already know a better answer than sysinfo
+
+__HASH__
+500.perlbench_r=base=maple_test-m64:
+# Last updated 2021-05-10 10:36:40
+opthash=1b55f44e78c515229834a282ce9d3013fee214077130f5cc6c8d469cce53274c
+baggage=
+compiler_version=\
+@eNp9VE1v2zAMvftX+NYNteK26ZIigA9Z6hYD0qZI3e0YyBLtqJUlTx+J08N++2Qnjr202MWC+Cjy\
+kXy0P5utfsbL5x+Lx9XiKXHHxHvRTOR+ahk3iAlfl0D0wJst5vN4lqzuZ7MotFqFKRNhTsgRmCeL\
+1a/l9OkpXu4dOEtrh7C6Ga1G14gzYSuUCxuOQ24k2ipclqC8xd3dfDG9XSXT5X2crB6nD/FzJDal\
+qZCQAk7x2/hu+jJPoksvwSoHM/FP43szKTKWWwXU3zKznviDQagVCUlr99HGR6jGUPmWb0BpJkV0\
+9pJaYaw/HnwbXKChbW6Xfy5vBhfXZ61/al0AHmWMwyQMmzr1GisIqSR1tWgcLuPp7UM8+G5z7V6B\
+wCkHxLHILc5BRyTAFAfk/DzIZZAqlgc0yKQyCotApq+k/iAHu7elgoxVTTfb/HWKAr9KhQ60kRR8\
+1/jKXOECaZvVb9C4ZzvEOW0U6ug1NdAeXSbeQKFaBBSxGnDThAoIZeo43QMnaWudEG4pUOQmYqAy\
+XSSzVoCpjkqpWbWPcxLj4Ch4r12plEa7lpSdiXBJMIfIEe/zTLWhpKoQBTeazwDDCoh2oNsOUsiw\
+ddLuPHDKIgHb7nHdGyvYbwvIDQNIXQ5lusE2Zn+AYtnun3xFWXX3ktvcLc/x3mYtGbRE9E4bKNB7\
+10lkGkmfIIcItTbc+CNsjeyshQvKsCLrHsUtKCWPiqlBNLyK2OhmdLS5iovRdXttgrhkrgptomJ4\
+FTgwKKrh1UmiPlUr3CxAuD6QHsks4xLTQyG6t8c9sRBLMaKKuR72xrsG8uZ+PJECDljX/o36PqjW\
+AWvpaH5i32f9gHhJo0G/kBT4xG+U6LlF8g8rtN94/8t/9v+r7/0FuibFEg==
+compile_options=\
+@eNrVU21r2zAQ/u5fIfxdccdGWUJdsB0l8eZEwrIh2xfhOkqqLZaD5IS1v34n56UtDFpGv1RgfLq3\
+R3fP3aLVuKl+y7XaStTuOtVqO/JsZ1TdCbPXK2XEQRq1fgj9T74HogWX0L8aDK+ufc9L6JyNkB/s\
+rQnulA42dY3cwbZbhfVw6MTm+gvCNcLtGWDQIjzmjCTwW4xJXE5BYCTPREJzgnA6gG+lbBekFKR6\
+V+mgUI3EM5VLe9bMinmGWWWsNKCSf7rASBDsTtam0itIOaZlnBHBs4jPCBcOMY2y8OqELqKyoIKX\
+jOWEc0EZWcwZ2EQW5VMiJmlG+OXqboLTMk+I0/VXOplwUog4LXgINSK8QZh+hoIrU9+HuurUAV60\
+1i3ea1utJRi6e+ya0KjHqm8FOto7IyXetu0OH2TdtUY9SnQ6p7dm6aJciqWDOcUcScLVVlVWaYBe\
+b/T+6xArvVVaPotkLujGtntTy1vfS0YoScJXKTs60vgbZUXov+DP94DzhJWTLJpysL3ksrfGZJHM\
+xMXhw5Pre3SEoBPpPP1JoKL3ZLpvGKN5EcVplhY/zh194rxHJ8sij6CJT494fQr61MfAfwIwlxtg\
+vr9lh4/Kd5/x/x3wm/buFySyt85/26DLwlzmFKF+iLPxW6b9g/IL9c2jYga5Yrdp2+ZUMi3d1j5b\
+2b8rRMvz
+exehash=1c69320bf26365e65e5b19b87fd09bbfdf73b3d6257845446d6001048f92fd40
+
+600.perlbench_s=base=maplec-m64:
+# Last updated 2021-05-12 15:35:30
+opthash=3cf993256ffc5aaeca4f7b92e3300c53cdd5a2bdb530ca54cfd558466978ed44
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNrVUsGOmzAQvfMVlu+EVKpWarSsBMQJbg22sJHSXiyWOKrbgJFNqvbva0iT3ZWyl2ovi0DMzHu8\
+wW+mNH3YNT/VQR8VMMOoTe9WgRutbkdpT/1eW/lLWX34E8MPMPCh85QYLheflncwCDJasBWA0XfT\
+qcid+uhR91HXDEfVgtDf5iK6MCBcc4Yy/yrXKK23PmCoIjKjFQIhXvhnr90YYeqjdmj6SOhOhbmu\
+lLtUclGQkDXWKetL6vcYWeUDN6jWNv3eS65pnRIkOUl4jricOuKExEsPSZJUWyQ3mCB+TadMclpX\
+GZpqc0o3G46ETLHg8d1HcL3OB5AEl/VO7mYkPJhB9d1wwShDZcGek9nEu3fmZFv1AINsBbIsvmnY\
+GaTpZ8pEDF+4BwPvcsbqDUm23GMvnZzRFJVZLq+Ed2Ht/OOMViJJMcHi6+VkTxbDgK4A2okq8dYK\
+XOBvyJNumj6Lnak3Jdmk5oW/vLav/zXoe/P4Q7Wje5g4x+5J4jo7AObBkvVrU39TD3ynIhG5/zqd\
+9uDY/WtO62mnni3UX8u2Jz8=
+exehash=2d8e7986845a1a99ef89f93cd339b6da23b7cfe2fc85ca3e8925db6f58260583
+
+619.lbm_s=base=maplec-m64:
+# Last updated 2021-05-12 16:29:02
+opthash=7affc07e1d7c5ca4633093daa05c20102ce1dec866120559a921160cddd58e76
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNqVUG1rgzAY/J5fEfLd2kEZTGpBY2ZdowlW2csXaV1kbmpE7WD/ftG+Ci1sIZCH3OVyd4GstHLz\
+JbK8EFDWXS6r1gBt1+RplzS76j1vkm/R5NmPie4QUGOrKCaaTh6mMwQAZj43INI/ZCn0dlfp27zS\
+y01diBRqasuj6ERCzVlzgtUROMSOXTVQK3RJ8szCFWWWAy+XlslaVGV9eJUwTgKfD8j+gvL7GYTz\
+Vu6aVCwQwAbE2LzqZA8y+4nxyEQjWwgo+5jHj9Ry1wobWxxQmwR4mZwIY88IMAOSlyi0lMPI8703\
+okhXvQ9ieypnYWTZHvWi1+OfQx4EqBesbvX5p37mcvsp0q5d9JyiPPNPkSEc+qDOrbL+kUjp+Fa0\
+TKhn9+UU5UGaxX3RFy3/AtPTsPg=
+exehash=4796f3d722b9339855ae459928ddcee0650c458340a971fc905fa5338976c68c
+
+605.mcf_s=base=maplec-m64:
+# Last updated 2021-05-12 17:02:05
+opthash=f8c9b30b6e77a4a59a777237ddaf5842ad1c2a8ae410864ef1a31d5c27b9ec03
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNqVUV1rgzAUfc+vCHm3drANJrWgada6qQk1wraX0LqUualxxg7275fa2g9ooQuBhHtObs45N1aV\
+VS6+5CovJFR1m6tKO0C3TZ61ollX73kjfmSTr35ddIOAuWpDcdFw8DC8QwBgGjEHIvtDldLW68pe\
+5pVdLupCZtAyW/VNBwpak4QRbI54Qvx0CqEV6Fpm4lurpt2hwks5FUnK2JwkiaCMxBGDR8taqVpW\
+Zd3zD4xdIWT3txCOtFo3mRwjgB2IsXtW4Rak/hNl3EUnchEwtjBLH0NvmhjsVHqH+iTGM4F7xpVe\
+EKAOJC987pkCD6LgjZjHZ011v2ypjM655wdhwF97MZ1RBMIgfr40AHhNcCO1/JRZq8cbTlEe+Pss\
+IOyCCieXUvyHI9Mn8vhMhIG/Ca0od61pupnAUfx/9bTCPg==
+exehash=c4863fbc60ab23589893d59f3b7f8b19f77ca751d2a775ef1905cd68a80904ea
+
+505.mcf_r=base=maplec-m64:
+# Last updated 2021-05-12 17:04:02
+opthash=cd00cc44466c7c00fcb0a07a84b8bdec510af969b5da706b722633229c2d2efc
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNqNkF1PgzAYhe/7K5reM2aiJpKxBApuaKENH4leNRt2EQWKFEz89xYEdYsa3zRpk3PanvNEsjaq\
+3bM4FKWAsukKWSsLqK4t8o63ff1QtPxVtMXhzUZnCOij0hYbLRdXywsEAKYhsyAyH2UlTNXX5r6o\
+zWrXlCKHhl5yfnQhoeElzMd6izzfzTYQGoFqRM5flGy7SeVOllKeZIzFfpJwyvwoZPBkJithl+cQ\
+rpTs21ysEcAWxNj+McuHSN0bylIbHQVDQBfALLsmzibR2nHIUXX9CG85nh3/TD1e9e/S2OGMxqnj\
+BiRI7+cfxvQIkCC6/Y3fyazk/knknVoPBMrqi8ZnFQjHnsT7A0LopFtOAncoUlaTn2YDlW9I3gG2\
+95r+
+exehash=806db0e68b5994ed49999cc86262dbea2e13c31853d3ba087eb2f180c940ee06
+
+502.gcc_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=2839b1967320158040c55387a370c4661288143e5e404dc55ea5be68a750538d
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNq1kV9PgzAUxd/5FE3fGdM4E5exBLoOqqxtBhh9ajbWxSrQScHEby/g8M+ivnnTpjc5J7f9nVJd\
+2sXmSe5VLoE+1EqXZmqZulJZLaqm3KlKvMhK7V9deAattjWtxYXj0dV4Ai0LsRWfAug86EI6pimd\
+rSqdYnPIZQbsdulh6EgDexFzjNqDLrCfBsAmo247qszyZif73hxkJp6NruqjXUzG50PrpQkTccr5\
+GsexYBzTFW81QkWAurmhd4sFYnRJAhGC0zoOifjlBQAzo5sqk3NooSlAyP2R4F1k/jXjiQu/4UCr\
+xUY8XUZeELfad7Re9TFFoRgM/8ra34fvkrUnOFsnnk8iktwPz+qRoRURevPbV53UTG8fZVabeRdb\
+XnxG+MEPQB9OtPgjuZWXhCIifoefF0c/S7sov+T4BmRTt5k=
+exehash=0
+
+520.omnetpp_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=be6e4dd67b5187b3cefa0f68d2b9d0de0da20ab650fd3c3ee25c7e2e09cbff32
+baggage=
+compiler_version=\
+*IENYWENfVkVSU0lPTl9PUFRJT046Ci9iaW4vc2g6IENDOiBjb21tYW5kIG5vdCBmb3VuZAo=
+compile_options=\
+@eNq1UNFOgzAUfe9XNH1nzkRNJGMJlLqhHW2gjfjUTOgSFCgBZuLfW3E45rv3pTfnnt57zolN49T7\
+d30oKw1NO5Sm6V3QD12ZD6o7NkXZqQ/dlYdPD10jYNveUjy0XNwvbxEAmO24CxHG0MmhY6YVCwOd\
+MOXEwmEckkBuoBP1ZX2s9oPprlr7FLqdY7avTaEr++E5ElsVExHIiIYkOW1SvhRMpZLzhKSpYpzE\
+Ow7PdWJRfncD4ao3xy7XawSwC3GWeVbh1LPgkXHhoQvBCFgbmMsH6m9SO7sUP04DEuOtmgj/4WY8\
+QzKR+IqzRPhBRCPxMqkZrSFAo/jpJ/E/tTKvbzof+vUcPDuEcAyAhr9Z0JDJ7xxmIXwBBSCXiw==
+exehash=0
+
+523.xalancbmk_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=a5f92e3f29c9a9dc5714dc66815a936b3270df34bf15c51d6007f825c19a3bfd
+baggage=
+compiler_version=\
+*IENYWENfVkVSU0lPTl9PUFRJT046Ci9iaW4vc2g6IENDOiBjb21tYW5kIG5vdCBmb3VuZAo=
+compile_options=\
+@eNrtU9FumzAUfecrLL8TuqmbtKip5ICX0tnYwmaiTxZ1aEVHcIVJ1f59HZhTsk1969ssIZ17z8G6\
+3HPITBfuql/1XdPWwDwOjensMrBD3+hB9ftu2/Tqqe6bu5cV/AQDB62TrODZ4tvZFxgEMaN8CWAc\
+g1CD0PgrFgaEieDYtZMswetiAxxCnKuMKXmVY5QI1ygRQZlKM4qpomKjCEMJzkGYLtzzXPe6tvoN\
+RVuzO62iZvfYzlq2ep5V+6FpI2rviam2bu4o7Wi9M/3LnxLZV53VZtJo0z0dBFVbdTpqOt3ut7Ub\
+lefsWpWUcJSLw4jHRiFT4suJFL4UqDyPZ8VnjxNGPfyJSJogyca33HWqENhvBAuBNtgvZdynQoVk\
+ShSc545VjOOMcnA4v3mSZkV50uBfzwG4sGbvPvkSBvESxGW5cpZ5zNbXjMsVPHEQBs7XmBffCdoI\
+x526ObJrnMVXyl1w1Pw3+GMMHtfNWS7ROiWpvPF+TG6PLC5ljtQ/NS4AMHDKH9OP+nb+isyFuX2o\
+9WAvwVx1zAQAY2RIMqXn/ZlGISsOuZqF6hW+xlPZ
+exehash=0
+
+525.x264_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=17555907b69668487c703e8ad30fdca935346ca79afa0bfdc1ae288920733ee3
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNrtkt9vgjAQx9/5K5q+I+rUbUZMAJmyIW34kcynBrFu3YCagsb990PEDc22V/dA06TX3l179+nX\
+4amchO90zWIK+CZnPM2GUpYLFuVEbNMVE2RHBVt/qLADpcLMihAVtlv37T6U0DEDrLkALAlf6C6M\
+2SrMKel3+0NJMtAcDwFUXnlClWybKkuWKkm4iWkE5GLy05stDuSJh02jWJyJqQdTIFvxikZ8RTIR\
+KSwtoq19d9A7bGumQve5CLP6ScSThKfVfUQLfES8AGPX9DyCsOnM8ZlPX/gmciemq7b3ne5Nrz+4\
+vQOXo0qw8aAHwCjjWxHRMZSMITAM9cf+jk6kPyLsq/CsWSgVUAwcPNja1Ct8542XXt10jBk5BVyR\
+RFmN+ey7GsHI9TXdsi1/cSq6BAIl23KefvvmizHiyzca5dn4ADVOvgF/0QGgRGdP/uA61/wZsS39\
+ACdOqngUHEDXKNfVWREUjSgbUf4bUZZMGkk2kryuJD8BghRXuw==
+exehash=0
+
+531.deepsjeng_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=c9d27d3cf5376f585e57a3f2a29ee65eb5a8ddb7a1042d47749d036bb8f42043
+baggage=
+compiler_version=\
+*IENYWENfVkVSU0lPTl9PUFRJT046Ci9iaW4vc2g6IENDOiBjb21tYW5kIG5vdCBmb3VuZAo=
+compile_options=\
+@eNqNkF9PgzAUxd/7KW76zjKTxUQylkBbJ1poQyFhT41il9Q/1AAz8dvb4ZDNJ+/T7T2nvb/T3LXB\
+++Or2ds3A+5jsK7tQ9QPnW0G3R3aZ9vpT9PZ/VeErzDybe8tEV4ubpYrjBARmQwBEwJBA4Gbnlg4\
+CKiSzI9pTllSbY/nLOZcZywTxe4k67gqhVaVlAVTSgvJ8kzCXCcXl9crgHXvDl1jNhiREEhdR37t\
+1IvkXsgywhcUGHk2IqtbHm+V1y6JRjVhObnTs+GfiONdVpdFrKUoyjhJeVruphUjL0Y8zR9+/uZP\
+rd3Ti2mGfnM+nLEBxlSc/gbkVFTHcGfJvgF3B3iC
+exehash=0
+
+541.leela_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=c715a7e7b712428302fadbd8205a3f5ff13d2a99dbcb03cfef4de14ebb0dbb76
+baggage=
+compiler_version=\
+*IENYWENfVkVSU0lPTl9PUFRJT046Ci9iaW4vc2g6IENDOiBjb21tYW5kIG5vdCBmb3VuZAo=
+compile_options=\
+@eNp9kE9LxDAQxe/5FEPuKSuoYNkutElcq9kktCnUU9CahfqnkbYr+O2NdevuenBOw5uXmd+L9B15\
+e3hx2/bVgX8fW98NMRrGvm1G2++6p7a3H65vt58JPsMotEOwJHgRXS0uMEJUbXQMmFIgDRA/r4g8\
+EFZqHmQmGc+qNZA82ms2rYyyZaV1wcvSKs3lRsOh9i6hL88BloPf9Y1bYURjoHWdhFtzr7JbpU2C\
+T05jFICorq5Fui7D7BRjmmZc0hs7G/7nmh7w2hSp1aowaZaL3NzPeydIjEQu735+4U8t/eOza8Zh\
+dSweWAGmKIL9phJMVd+JjuJ8ASVmcYc=
+exehash=0
+
+548.exchange2_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=7c95017cd71c6e94420e5cb70d3cc0a48a81eb16a8246cb031329e6470ab6a5c
+baggage=
+compiler_version=\
+*IEZDX1ZFUlNJT05fT1BUSU9OOgovYmluL3NoOiBmOTA6IGNvbW1hbmQgbm90IGZvdW5kCg==
+compile_options=\
+@eNq9kEtPhDAUhff8iqZ7yJioCWSYhEcZ0Q5teCS6apQpSX3QhjJG/fUWBhmcuLab3vae2/OdZrK1\
+3x5feCNeOZCqF7LVnqX7TtQ96w7tXnTsnXei+fThBbRMqY3EhyvHXV1By0oo9QDUitdKATsuKIrM\
+lsUorLbTmQVVSVhRUZqjomCEomxHf3qYXl+CtZaHruYbYMu5dhqlxBffO437AS1jEtEqwcG28OGZ\
+zdgNURbdsF+CP31HMbov84BRkpdBmOK0fJhHBhxoRWQ3pGrcFbDrAWr6GEeCmc+oPJBE/qA61iS8\
+JbQ0Ty1H/hsdp9ndhH621vLpmde93iwvT6AAjClwfEqEY1INeRZhvgFuXpvb
+exehash=0
+
+557.xz_r=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=34d1fd17d5aa193e0a6a2c6e3f3472c24b4e41ed9de1aafdefcd23008f8b6564
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNrtk1tPwyAUx9/7KQjvXTcvUxdr0gtu1a6QXsz0hXQMHVrK0nZG/fSy6Uw7L59AAhz+nMNJzvmF\
+SJWmzJ/4vSg4UKtGqLIeGXVTCdbQal0uREWfeSXuX204gIY+1jrEhv3eWX8IDcPDUzIC0Foqya16\
+XVpzUVoyXxWcAVNPtUvaU8D0E4I8bSIfudn4U1MnSzF1b1OEYx/Fdv9lcHB4dDw8OdUBE+cGUQ9H\
+l8GYTuzB7skUTWmAd2p210mVZITEKEkoJiiaEmAGPb3qFWdUckmF2qhlbh5oy5SUqtSHQsyLN5lb\
++Uq01GZryW/RbMnZU0vXQurKWxcLXjR5J2FLVHn5wJla8Arsj896QjI8AuC8VuuK8QtoeCPgefaP\
+3f5wYvcKk9SGndZDQyPySHYZOuNE+7oYtl4XRd6EdgL+ufBq2xs0S2OHEhynjhuEQXr71aENHmiE\
+QXT92xfYG+dq/shZU190WH+BAmBLMfT/QBz6ONsAbtF9B8AAJ6o=
+exehash=0
+
+999.specrand_ir=base=maplec-m64:
+# Last updated 2021-05-12 17:24:36
+opthash=2b6f45155529ef0ee94c19b9445375b5551207252ee5fb82fdcb9fe4f6f19a4c
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNp9kFFLwzAUhd/zK0Leu04UwbIO2rTOamzC1oI+lS7LMLomJWkF/72xo2KLermQwDm5+c7NtfKa\
++k0c5UlA3XZSKxsA2xnJu8r06iBN9S6MPH6E6AIBd7XOEqLl4mZ5iQDA9JEFEPkvuhG+7ZW/l8pv\
+6vYkOPRc63HoQkMv2bEUuyNP0rjcQC+zreCmVgeP66bRCs7r/KIi7PoKwpXVveFijQAOIMbhr5+e\
+RRrfU1aEaEKAgCPFrLwl0WbntCnNoMZpju+q0TDHGyzpU7GNKka3RRRnJCuex0kDJQIkyx/+Wsis\
+Vnr/Knhn15PI37wQDmFI8k9SktDyK+ePkJ/hnoeM
+exehash=0
+
+519.lbm_r=base=maplec-m64:
+# Last updated 2021-05-12 17:29:14
+opthash=55e637b326098960c2f25abcffd8e22854b4464b6ae2619ebf92ce74d672f662
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNp9kF9PgzAUxd/7KZq+M2aiJpKxBApuaKENlESfmg27WAW68MfEb2/ZcMoyvWnSNufc9nduomur\
+2rzLnSol1PtO6bp1QNs1quhE09cvqhEfslG7TxddIWCOrbG4aD67m98gADCNmQOR/aorabd9bW9V\
+bVebfSkLaJmlvx+daWgFGQux2ZIg9PPVeBdezqnIcsbSMMsEZWESM3heo5ew22sIF63um0IuEcAO\
+xNi9+P1RpP4DZdxFExYEDDNm+T3xVpnRplwH1Q8TvBYTw0XQgzl84qknGE2550ck4s+nloEXARIl\
+j38N6awWevsmi65dDpnL6if/CR7CQzIS/BM79vhakMgf2Mtq9NN8mMOvIXwB6zCRCQ==
+exehash=95e543602be6b0de89f9afd90aacb45d06bb7b32f0f2295d9571e3c9a893f901
+
+511.povray_r=base=maplec-m64:
+# Last updated 2021-05-19 14:10:44
+opthash=6681316d90fcef5a8ec9d57d1ec3590b7d32c00621a8f461b30ed5b709bb4dc3
+baggage=
+compiler_version=\
+@eNq9VUtv2zAMvvtX6NYNqaKmj7QJ4MNgBNuAYCnabOstkGXGViNLmiQ3bg/77ZPtuPaaDANWrJc4\
+FB8f+YmkUHR3F62+zW5uPy++rBbXS/+ZBijaP/tquUxRXHDhMJfIamB2GESL+XwWLVcfoygkmcqB\
+PGY5yakWsFIapFWFYUB6f51SwpKUMSy4pEbhy+HF8ITEXBJKDcvG55WiKHEqC5wOBs8Q8+Vi9f3m\
+w/X17Ob1UMMhETyGElil30cmjalwCm8N1RpMsKQmBTdFe7ZBpOSap4WBBG25y6boqMnPsW2KK8YS\
+K+gDkK0yG6sp22lyugFsQAC1sBoRK6m2mXJ1xsOUu59d1vj0ZDQZjk4Ja6GO0O2n2Xwe1tXE1GYI\
+4woc55qF/wK/qi1JY08SsC7hhvDx1Rhr1hXbwazNW+CkuX4TGN9s1PYlkXgp4ZbGArx9nBfJWlDt\
+D0E2Z051gs1odf2NvyqqEWGiSCDBvmcclK4zleIZxz5aBzl+8uF7YPZe3GMoGWjHlbSdZ5VWIfmP\
+ArCK74H1gvqCNmAaejB/kbqvnZWlrzvrHNhk0hOEYlRA2BDyHLJ1TCAu0p5CybT+acvw7ioNpWpl\
+rUVP4nYntRnlhXC8KXkXcc1LzJTxPGF6cYavzi4ux5M/q8/PzkeTNnw1jSE1+cMVpp2LywzQxIZa\
+WV52xzV05XGoTMdzCB/hBeFc+sbxXON1IVl1IS1ww7W/QqOUe02P7kLY/S3U65PXgvxtEA6sQM8M\
+6/VIBmzjn4BwF7p3oXGVvTO/DQeVaUFTsCE7ZoPB8dpfn6HyuBmaOpnw0DBmyrqDCldv3/AQRdqA\
+75D/SU6wrNsJ5SoBMUV1UwV+S6MHMLZqifq1QO/m9cJG/jFEvaX9HgW/AHQUm+k=
+compile_options=\
+@eNrtlFFPwjAQx9/3KZq+Lt1mRI2EkcA2ER1bw7YEn5pRCkyhxXYY+fZuAxTUxAcToskuWXrJXde7\
+37X/QHC0TJ/YNFswIFZ5JrhqaiqXGc2JXPNJJskLk9l0Y8MzqBWuKlJsaBnXVgNqmhMOcBNAcy6W\
+zNzMl+YyXS0YESvGlVhLyswDNxdiocwZpWiR8VQKdGVcGJY5zriZppLOLxtlYP2KZnyNZroOSkMq\
+n9hU161zgChAYl+lIQByI+w5xRK4XjfpAdSfSsFzxieFO04VKxaj+NSKUfKshMx3W0gniUMSJRgP\
+vSgiIfaCAQYftsvy8WUDgNa2+jbUnCZwRiP7NN3ujwu7dyGObXjUPNQK6g5ObvxOLypixyCqaNcL\
+nFuyT/gVmep/3igedggOh3Gn2/f78cP+2AoT/HoTykYrPvR0g/txfI79bYXb4H9B7feD+5M9uk/W\
+EuNHRnPVPgL+TguACqXvnvKV+G6YlGM7mFktTLUw1cJUC9OfE6Y3nDbadw==
+exehash=0f4659ece5065638b9268e65a56d231636b83a05ae00d17df9bf1a2ae7112f8b
+
+538.imagick_r=base=maplec-m64:
+# Last updated 2021-05-31 19:30:05
+opthash=54a10f343892c95817762d047800af2eccb783c0e3ff864fcef7d0ae46bd6135
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNrtkdFqgzAUhu/zFCH3agdlMKkFja51iyZohO0qtC5lbmqK0cHeftbqtpatDzAWAgk5fw7f/59Y\
+1Ua1eZW7opRQ7dtC1doGum2KvBVNVz8VjXiTTbF7d9AVAv1V9xIHzcyb2RwBgGnEbIisZ1VJS3e1\
+tS1qq9rsS5lDo99qamoqaPgpC3B/xH7gZStohOb4JtyMU5FmjCVBmgrKgjhi8HyNWsKu5xAutOqa\
+XC4RwDbE2PkR4Vik3h1l3EEnPAj03Jhlt8RdpX3tlG2oekGM12ISXIYdPgQPPHEFowl3vZCE/HHq\
+OzAjQML4/rewztZCbV9k3urlwXdZfWXwaQDCwR3xL1iPXL4WJPQO/GU16ml2yOJbEP9D/AND/ABB\
+Sw9g
+exehash=facef3555a82b36cc7e8d92e422f6bffa9ea772e21800b4dd646cd8aa6e6eb36
+
+500.perlbench_r=base=maplec-m64:
+# Last updated 2021-06-02 10:59:30
+opthash=907b382deeffec61ac5b9a27df38c7435aa5d83bcabdd7e546b4199881462251
+baggage=
+compiler_version=\
+*IENDX1ZFUlNJT05fT1BUSU9OOgo=
+compile_options=\
+@eNrVUtFqgzAUffcrgu/WDkZhZQ40TatbaoKJ0D0Fa1OWrWpJ7Nj+ftG1doWOPU+U3HvO8YZ77k2b\
+2quKN7lVOwmafaua2kwd02pVtkIf6o3S4l1qtf0M3BvXsaGxksAdj+7GE9dxIFnSKXD9l6aSvjnU\
+/lrVflXsd7IEnn2bU9FRA7wZowjaI52hKF/YgKIMC0gyBLxkZL+NMq2fEBuV+6L2uaqkF6tMmhMS\
+8yX2aKGN1BaSH62vpQ3MXpa6qDe25IzkEUaC4ZDFiInuxiTEwfh4uwhzTgTLKc0QY4JQlC6p5QQO\
+swUS8wQjNqRdJhjJM4g6rE/JfM4QF1HCWTC5BcNzLI+TNF+J1cCcYNoh96Y56FI+uA6cAgiDq7Z9\
+kyR6JJQH7oWHrmO9hjSf43DBLHfpZ89GKIWxGAT/3uC+KUoyHkYJTvjzqeuz0b0CrXgWiqs62kms\
++um3Nf1jhvfN+lWWrXnoBLvqLB7GAkA/Mzz7baB/t2B/X4Y8tlDUzW1XHSuSvNuBHwvwBanrEMs=
+exehash=51357adb393d1e80ce358878f264dc9f58399d0c7c71acd7c4834ae0d4c6d3e4
+
diff --git a/build/tools/spec/replace_func.py b/build/tools/spec/replace_func.py
new file mode 120000
index 0000000000000000000000000000000000000000..8da5f589b021dd54b47a6da164e7197c75f79024
--- /dev/null
+++ b/build/tools/spec/replace_func.py
@@ -0,0 +1 @@
+../common/replace_func.py
\ No newline at end of file
diff --git a/doc/cn/CPPCodingTalkAboutPointer.md b/doc/cn/CPPCodingTalkAboutPointer.md
new file mode 100644
index 0000000000000000000000000000000000000000..d8be304b8ec099fbd7f614cb0a300b5028f16dd1
--- /dev/null
+++ b/doc/cn/CPPCodingTalkAboutPointer.md
@@ -0,0 +1,266 @@
+# C++编程探讨之指针
+
+# 背景
+
+`C/C++`中指针的使用具有极大的灵活性，伴随着的是更多的安全风险，同时这也对程序员提出了更高的要求。本文将讨论裸指针在`C/C++`中当如何被使用，乃至最终确立一种编码范式。
+
+# 裸指针vs引用
+
+## 成员访问
+
+当访问对象成员时，裸指针存在为空的场景（指针的有效性由闭合对象或函数从逻辑上自保证），所以必须检查非法指针。而引用必定非空。
+
+## 做容器成员
+
+引用从`C++`语义中，表达的是别名关系，理论上不占内存（实际中规中矩的编译器对于引用的内部实现是指针）。引用本身不是对象，这点与指针不同，指针可以作为各容器成员，而引用不行。
+
+# 裸指针vs智能指针
+
+## 堆对象销毁
+
+```c++
+class Int {
+  ...
+ private:
+  int data;
+}
+
+void test(int* in) {
+  Int* tmp = new Int();
+  ...
+  goto LABEL;
+  ...
+
+  delete tmp;
+LABEL:
+}
+```
+
+对于资源（堆对象、栈对象、文件资源等）的使用，遵循**“谁申请，谁释放”**的原则(RAII)，这样可以最大限度的降低资源泄露的可能。
+
+裸指针的`new`与`delete`之间往往会包含一段处理逻辑以及子函数调用，中间的处理逻辑可能发生异常、跳转等动作（中间的处理逻辑的行为不会由当前对象越权限制，超出`new`行为的管辖范围），而跳过资源的释放，从而造成资源泄露（如示例中`test`函数中`tmp`对象）。
+
+智能指针改造为`auto tmp = std::make_unique<Int>();`，构造对象`tmp`时，即绑定其`delete`行为，退出当前作用域销毁，而避免了资源泄露的可能。
+
+## 管理权vs使用权
+
+```c++
+int* delete(int* in);
+```
+
+管理权：拥有销毁、重建对象的权利
+
+使用权：拥有访问、修改对象的权利
+
+如上示例所示，当使用裸指针传递参数时，由于其隐含了转移所有权的属性（可能转移所有权，亦可能没有），入参`in`以及出参均无法确定行使了**管理权**还是**使用权**。调用此函数将需要额外补充信息：`in`是否会被`delete`函数销毁？返回值是否需要调用者销毁？
+
+```c++
+std::unique_ptr<int> delete(std::unique_ptr<int>& in);
+```
+
+使用智能指针将在接口中明确表达参数的角色，如`std::unique_ptr<int>& in`代表`delete`函数享有其**使用权**，函数返回值代表`delete`函数转移所有权。
+
+# 指针使用范式
+
+## `new`创建的对象，必须立即绑定其销毁方式
+
+错误示例：
+
+```c++
+Object* obj = new Object();
+...
+delete obj;
+```
+
+正确示例：
+
+```c++
+std::unique_ptr<Object> obj = std::make_unique(new Object());
+```
+
+## 申请的资源，必须立即绑定其释放方式
+
+错误示例：
+
+```c++
+FILE* file = open("xxx.txt");
+...
+file->close();
+```
+
+正确示例（本例比较通用，最佳方式应用类封装`open`）：
+
+```c++
+template <typename T, typename Func>
+class ResourceGuard {
+ public:
+  ResourceGuard(T* _obj, Func _func) : obj(_obj), func(_func) {}
+
+  ~ResourceGuard() { obj.func(); }
+ private:
+  T* obj;
+  Func func;
+}
+
+FILE* file = open("xxx.txt");
+auto fileGuard = ResourceGuard<FILE, std::function<void()>>(file, FILE::close);
+...
+```
+
+## 确定不为空的场景，使用引用而非指针
+
+错误示例：
+
+```c++
+void func1(int* in) {
+  if (in == nullptr) return;
+  ...
+}
+
+void func2() {
+  int* p = nullptr;
+  ...
+  if (p != nullptr) {
+    func1(p);
+  }
+}
+```
+
+正确示例：
+
+```c++
+void func1(int& in) {
+  ...
+}
+
+void func2() {
+  int* p = nullptr;
+  ...
+  if (p != nullptr) {
+    func1(*p);
+  }
+}
+```
+
+## 作为容器成员（不具管理权），确定不为空时，使用封装的引用容器，而非指针
+
+错误示例：
+
+```c++
+void func(std::vector<int *>& in) {
+  for (auto *p : in) {
+    if (p == nullptr) {
+      continue;
+    }
+    ...
+  }
+}
+```
+
+正确示例：
+
+```c++
+template <typename T>
+class Ref {
+ public:
+  Ref() = delete;
+  Ref(T& ref) : data(&ref) {}
+
+  ...
+
+  operator T() const noexcept {
+    return *data;
+  }
+
+ private:
+  T* data;
+}
+
+template <typename T>
+using ref_vector = std::vector<Ref<T>>;
+void func(ref_vector<int>& in) {
+  for (auto p : in) {
+    int& data = p;
+    ...
+  }
+}
+```
+
+## 作为容器成员（具备管理权），使用具有管理生命周期的容器，而非指针容器
+
+错误示例：
+
+```c++
+std::vector<int *> data;
+...
+for (auto *p : data) {
+  delete p;
+}
+```
+
+正确示例：
+
+```c++
+template <typename T>
+class ptr_vector {
+ public:
+  ~ptr_vector() {
+    for (auto *p : data) {
+      delete p;
+    }
+  }
+
+ private:
+  std::vector<T *> data;
+}
+
+ptr_vector<int> data;
+...
+```
+
+## 显示转移对象管理权，明确对象使用权
+
+`C++11`新增了`move`语义，并废弃`auto_ptr`而使用需显示转移所有权的`unique_ptr`，使得栈对象和堆对象的生命周期管理方式可以进行统一。
+
+栈对象转移示例：
+
+```c++
+std::vector<int> func() {
+  std::vector<int> data;
+  data.push_back(0);
+  return std::move(data);
+}
+```
+
+模糊的堆对象转移示例：
+
+```c++
+Object* func() {
+  std::unique_ptr<Object> data = std::make_unique(new Object);
+  Object& rData = ToRef(data);
+  rData.push_back(0);
+  return data.release();
+}
+```
+
+明晰的的堆对象转移示例：
+
+```c++
+std::unique_ptr<Object> func() {
+  std::unique_ptr<Object> data = std::make_unique(new Object);
+  Object& rData = ToRef(data);
+  rData.push_back(0);
+  return std::move(data);
+}
+```
+
+## 应当使用指针场景
+
+1. 第三方库函数传入或传出指针，但必须在调用前一刻使用`unique_ptr.get()`或`unique_ptr.release()`构建入参，出参也必须在拿到后立即使用`unique_ptr`接住或判空并转引用。
+2. 作为容器成员（不具管理权），使用场景中有空指针设计，但必须在使用前立即判空并转引用，不支持指针扩散。
+
+# 备注
+
+上述的`Ref`、`ref_vector`已开发完成，`Ref`由于`operator.`无法被重载，所以定义为`SafePtr`。
+
+上述的`ResourceGuard`、`ptr_vector`正在开发中，文中主要为示意。
diff --git a/doc/cn/CompilerPhaseDescription.md b/doc/cn/CompilerPhaseDescription.md
new file mode 100644
index 0000000000000000000000000000000000000000..3bd1244dac0613fb660ec67930f0caa46e0bf328
--- /dev/null
+++ b/doc/cn/CompilerPhaseDescription.md
@@ -0,0 +1,155 @@
+### 方舟编译器phase层次结构
+
+目前phase主要有两类：module phase和function phase。在其他层次的IR上的phase可以通过继承自MaplePhase完成。MaplePhase在特定的IR层次上完成优化或者进行程序分析。
+
+##### MapleModulePhase
+
+如果一个phase继承自MapleModulePhase，说明这个phase需要在整个module上进行转换；module phase也可以调用更低层次的MaplePhase。
+
+##### MapleFunctionPhase
+
+```c++
+ template <class funcT>
+ class MapleFunctionPhase : public MaplePhase
+```
+
+不同于MapleModulePhase，MapleFunctionPhase是一个模板类，主要是因为Maple中有不同层次的函数级IR。中端的优化phase和后端的优化phase都是该类的派生类。
+
+### phase的内存管理
+
+方舟编译器的phasemanager可以对内存进行有效的管理，以便每个phase可以保留可能被其他phase依赖的分析结果；以及丢弃失效的结果。每个phasemanager中提供一个AnalysisDataManager类（多线程时，每个线程对应一个AnalysisDataManager）用来存储分析结果。为了实现这个功能，每个phase需要实现GetAnalysisDependence函数。如下：
+
+```c++
+ void <OPT_PHASENAME>::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<OPT_PHASENAME>();  // 配置当前phase需要依赖的phase。
+  aDep.AddPreserved<OPT_PHASENAME>(); // 配置当前phase执行完成后，需要保留的分析结果。
+  aDep.SetPreservedAll();             // 保留所有的分析结果。
+}
+```
+
+#### 分析phase
+
+分析phase中的GetPhasesMempool函数返回的mempool来自于AnalysisDataManager。分析phase的内存池中分配的对象，只有在被其他phase设置为需要丢弃；或者当前phasemanager结束时，才会被释放。否则会一直存在于当前phasemanager中。如果有些信息仅仅是在分析phase内部局部使用，那么可以将其分配在临时内存池中，通过ApplyTempMemPool函数获取一个临时的内存池。
+
+#### 转化phase
+
+对于转化phase，GetPhasesMempool和ApplyTempMemPool获取的内存池类似，都会在该phase结束后进行释放。**如果一个转化phase不实现GetAnalysisDependence，则意味着phase结束后会把当前phase所在的phasemanager中的所有现存分析phase的结果删掉**。
+
+
+
+**If a transform phase does not implement the GetAnalysisDependence method, it defaults to not having any prerequisite phases, and invalidating all phases information in analysisDataManager.** Transfrom phase default to be assumed to invalid all ananlysis results.
+
+### 快速开始
+
+假设我们要在中端实现一个叫做“MEHello”的`转化`phase。
+
+- 1 新增两个文件
+
+me_hello_opt.h：
+
+```c++
+#ifndef MAPLE_ME_INCLUDE_ME_HELLO_OPT_H
+#define MAPLE_ME_INCLUDE_ME_HELLO_OPT_H
+#include "me_function.h"    // 使用MeFunction
+#include "maple_phase.h"    // 使用MAPLE_FUNC_PHASE_DECLARE宏
+namespace maple {
+
+// 对于转化phase，尽量使用这个宏。
+MAPLE_FUNC_PHASE_DECLARE(MEHello, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_HELLO_OPT_H
+
+```
+
+me_hello_opt.cpp：
+
+```c++
+#include "me_hello_opt.h"
+// 将该phase对应的phasemanager头文件引入进来，可以方便地使用其他phase的分析结果。
+#include "me_phase_manager.h"
+
+namespace maple {
+
+// 您需要清楚地知道，当前的phase依赖什么分析结果，以及会破坏什么分析结果。
+void MEHello::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>(); // phasemanager会保证MEDominace这个phase的分析结果在当前phase中是可用的。
+  aDep.SetPreservedAll();          // 表明了当前phase不会破坏任何分析结果。
+}
+
+// 这个函数的返回值表明了当前phase是否修改了IR，目前该返回值并未使用。
+bool MEHello::PhaseRun(maple::MeFunction &f) {
+  // 您可以通过这个宏来获取想要的分析结果，前提是在GetAnalysisDependence配置过，否则会报错。
+  auto *dom = GET_ANALYSIS(MEDominance);
+  // 使用dom信息，做一些事情。。。
+  LogInfo::MapleLogger() << "hello opt on function: " << f.GetName() << '\n';
+  return false;
+}
+
+}  // namespace maple
+
+```
+
+- 2 告知phasemanager，有新的phase加入了。
+  - 2.1 将新phase的头文件(me_hello_opt.h) 添加至me_phase_manager.h
+  - 2.2 在me_phase_manager.cpp注册新的phase，如下:
+
+```c++
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEHdse, hdse)
+// 后缀CANSKIP的宏表明了这个phase可以跳过。第一个参数是phase的实现类，第二个参数是phase的名字。
+// phase的名字可以用在多个选项中，如skip-phases，dump-phase(s)，skip-after等等；同时配置哪些phase需要运行，也是用这个名字。
++MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEHello, hello)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MELfoIVCanon, ivcanon)
+```
+
+- 3 配置需要运行的phase列表。
+  x修改phase.def文件，如下：
+
+```c++
+...
+ADDMAPLEMEPHASE("dse", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("hello", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("analyzector", JAVALANG)
+...
+```
+
+- 4 把cpp文件加入到对应的build.gn中。
+- 5 编译工具链测试
+  maple --run=me:mpl2mpl:mplcg --option="--O2 :--O2 --quiet:--O2 --quiet" test.mpl
+  可以看到，我们新增的phase在dse之后正确地输出了预期的内容！
+
+```
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Optimizing Function  < VEC_invariant_p_base_space id=5471 >---
+---Preparing Function  < VEC_invariant_p_base_space > [1] ---
+---Run Phase [ mecfgbuild ]---
+---Run Phase [ cfgOpt ]---
+---Run Phase [ loopcanon ]---
+    ++ trigger phase [ dominance ]
+    ++ trigger phase [ identloops ]
+---Run Phase [ splitcriticaledge ]---
+---Run Phase [ ssatab ]---
+---Run Phase [ aliasclass ]---
+---Run Phase [ ssa ]---
+    ++ trigger phase [ dominance ]
+---Run Phase [ dse ]---
+    ++ trigger phase [ fsaa ]
+---Run Phase [ hello ]---
+hello opt on function: VEC_invariant_p_base_space
+---Run Phase [ hprop ]---
+    ++ trigger phase [ irmapbuild ]
+---Run Phase [ valueRangePropagation ]---
+    ++ trigger phase [ identloops ]
+---Run Phase [ hdse ]---
+---Run Phase [ epre ]---
+    ++ trigger phase [ dominance ]
+    ++ trigger phase [ identloops ]
+  == epre invokes [ hdse ] ==
+---Run Phase [ rename2preg ]---
+---Run Phase [ lpre ]---
+---Run Phase [ storepre ]---
+---Run Phase [ copyprop ]---
+---Run Phase [ hdse ]---
+---Run Phase [ pregrename ]---
+---Run Phase [ bblayout ]---
+---Run Phase [ meemit ]---
+
+```
diff --git a/doc/cn/DeveloperGuide.md b/doc/cn/DeveloperGuide.md
new file mode 100644
index 0000000000000000000000000000000000000000..969f52b08816f29a9a796d8852ce78f9b60395ee
--- /dev/null
+++ b/doc/cn/DeveloperGuide.md
@@ -0,0 +1,103 @@
+# 开发者指南
+
+通过参考本文档，您可以下载编译器源码编译出OpenArkCompiler。同时，本文档也为开发者提供了源码静态检查指南。
+
+## 源码下载
+
+下载地址：<https://code.opensource.huaweicloud.com/HarmonyOS/OpenArkCompiler/home>，可以通过`Clone` or `Download`的方式下载openarkcompiler源码。
+
+   > 注：默认源码下载目录为openarkcompiler。
+
+之后请按照《环境配置》文档完成您的开发环境准备。
+
+
+## 源码编译
+
+在openarkcompiler目录下执行以下命令，编译出OpenArkCompiler，默认输出路径 openarkcompiler/output/TYPE/bin, TYPE: aarch64-clang-release。
+
+```
+source build/envsetup.sh arm release
+make setup
+make
+```
+
+命令说明：
+
+- `source build/envsetup.sh arm release` 初始化环境，将OpenArkCompiler工具链路径openarkcompiler/output/TYPE/bin设置到环境变量中；
+- `make` 编译OpenArkCompiler的Release版本；
+- `make BUILD_TYPE=DEBUG` 编译OpenArkCompiler的Debug版本。
+
+在openarkcompiler目录下执行以下命令，编译出OpenArkCompiler及maple runtime部分，默认输出路径 openarkcompiler/output/TYPE, TYPE: aarch64-clang-release。
+
+```
+source build/envsetup.sh arm release
+make setup
+make libcore
+```
+
+命令说明：
+
+- `make libcore` 编译OpenArkCompiler及maple runtime部分的Release版本；
+- `make libcore BUILD_TYPE=DEBUG` 编译OpenArkCompiler及maple runtime部分的Debug版本；
+
+此外，方舟编译器还提供了源码编译脚本，开发者也可以通过在openarkcompiler目录下执行该脚本，默认编译出OpenArkCompiler及maple runtime部分的Release版本。执行命令如下：
+
+```
+source build/build.sh
+```
+
+## Sample示例编译
+
+当前编译方舟编译器Sample应用需要使用到Java基础库，我们以Android系统提供的Java基础库为例，展示Sample样例的编译过程。
+
+**基础库准备**
+
+环境准备阶段已经通过AOSP获取到需要的libcore的jar文件。
+
+**生成libjava-core.mplt文件**
+
+编译前，请先在openarkcompiler目录下创建libjava-core目录，拷贝java-core.jar到此目录下，在openarkcompiler目录执行以下命令：
+
+```
+source build/envsetup.sh arm release
+make
+cd libjava-core
+jbc2mpl -injar java-core.jar -out libjava-core
+```
+
+执行完成后会在此目录下生成libjava-core.mplt文件。
+
+**示例代码快速编译**
+
+示例代码位于openarkcompiler/samples目录。
+
+以samples/helloworld/代码为例，在openarkcompiler/目录下执行以下命令：
+
+```
+source build/envsetup.sh arm release
+make
+cd samples/helloworld/
+make
+```
+
+## 源码静态检查
+
+本部分内容将指导您使用clang-tidy进行源码静态检查。在对源码进行修改之后，对源码进行静态检查，可以检查源码是否符合编程规范，有效的提高代码质量。
+
+静态源码检查之前，需要先编译出OpenArkCompiler。此后，以检查src/maple_driver源码为例，在openarkcompiler目录下执行以下命令：
+
+```
+cp output/TYPE/compile_commands.json ./
+./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/share/clang/run-clang-tidy.py -clang-tidy-binary='./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/bin/clang-tidy' -clang-apply-replacements-binary='./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/bin/clang-apply-replacements' src/maple_driver/
+```
+
+命令说明：
+
+- `cp output/TYPE/compile_commands.json ./` 将output/TYPE目录之下的compile_commands.json复制到当前目录之下，它是clang-tidy运行所需要的编译命令；
+
+- `./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/share/clang/run-clang-tidy.py` 调用clang-tidy进行批量检查的脚本run-clang-tidy.py，其中 `./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/`目录是之前配置的clang编译器的发行包主目录； `-clang-tidy-binary` 是指明clang-tidy的具体位置； `-clang-apply-replacements-binary` 是指明run-clang-tidy.py所依赖的clang-apply-replacements的位置； `src/maple_driver/` 是要进行源码检查的目录。
+
+## 编译器注意事项
+
+- 方舟编译器前端暂时不支持字节码校验，未符合dex、jbc语义的字节码输入可能造成编译器Crash。
+- 方舟编译器中后端暂时不支持IR中间件语法校验，未符合MapleIR语义的中间件输入可能造成编译器Crash。
diff --git a/doc/cn/DeveloperGuide4Utility.md b/doc/cn/DeveloperGuide4Utility.md
new file mode 100644
index 0000000000000000000000000000000000000000..08045fc06352bcdc7acac72aac6e0796a4d9368d
--- /dev/null
+++ b/doc/cn/DeveloperGuide4Utility.md
@@ -0,0 +1,431 @@
+# Maple通用模块应用手册
+
+# Cast
+
+## `instance_of`与`safe_cast`
+
+`maple`对于`C++`的使用，原则上需要禁用`RTTI`，即禁用`dynamic_cast`。而由于编译器系统的复杂性，完全通过类设计来破除父类向子类转换的情况，反而会使得对象关系变得更加复杂，得不偿失。所以`maple`代码实现中便有了众多如下设计：
+
+```c++
+SubClass *sub = nullptr;
+if (base.Type() == SubType) {
+  sub = static_cast<SubClass*>(base);
+}
+```
+
+通过设计某属性字段来实现父类与子类之间的关系绑定，从而达到与`dynamic_cast`相同的效果。
+
+但此种写法仍有一些不足，首先`SubType`与`SubClass`之间隐藏有静态绑定关系，这由设计者决定，却需要调用者将两者关系显化，这会产生强依赖；其次，并不是所有场景都如类型比较这样直观，复杂的场景对于调用者来说更容易出错；最后，散落在各地的转换，将会埋下散弹式修改的问题。所以我们设计出了`safe_cast`，由设计者注册转换关系，调用者只需以`dynamic_cast`的方式调用即可
+
+### 注册方式
+
+通过`REGISTER_SAFE_CAST`宏来达成注册，声明如下：
+
+```c++
+#define REGISTER_SAFE_CAST(type, condition)
+```
+
+其中`type`为子类类型(假设为`B`)，`condition`为匹配到`B`以及其子类所有场景的布尔表达式。示例如下：
+
+```c++
+class A;
+class B : A;
+class C : B;
+REGISTER_SAFE_CAST(B, from.Kind() == B || from.Kind() == C);
+REGISTER_SAFE_CAST(C, from.Kind() == C);
+```
+
+`from`为表达式传入的类型的形参名。
+
+*注意：*
+
+*- 注册同时持了子类向父类转换以及父类向子类转换。*
+
+*- `condition`可以是任意的布尔表达式，但设计者应尽量使其符合继承关系，避免非继承关系的转换。*
+
+*- 对于复杂的`condition`使用`kind ==`表示一棵继承关系树是不明智的，需考虑优化，如：组织`kind`的范围、使用特定位标记等方式来达成快速匹配。*
+
+### 使用场景
+
+1. 针对只做单个类型匹配的场景
+
+```c++
+SubClass *sub = safe_cast<SubClass>(base);
+if (sub == nullptr) {
+  // TODO
+}
+```
+
+2. 针对多个类型匹配的场景
+
+```c++
+if (instanceof<SubClass1>(base)) {
+  auto *sub = static_cast<SubClass1*>(base);
+  // TODO
+} else if (instanceof<SubClass2>(base)) {
+  auto *sub = static_cast<SubClass2*>(base);
+  // TODO
+}
+...
+```
+
+*注意：*
+
+*- 对于`switch case`等已经正确识别类型的场景，使用`static_cast`即可。*
+
+*- `safe_cast`返回值永远是指针，外部识别是否转换成功。*
+
+*- 输入若为指针，`instance_of`与`safe_cast`都会做判空，所以`base`非空时优先传入引用*
+
+# Container
+
+## `Ptr`
+
+`Ptr`模拟了原生指针的行为，但切除了对数组操作的支持。
+
+其通过在构造、赋值的操作中校验数据，使得指针对象仅在构造时需验证满足某特征，而传递和使用时均无需再次验证该特征，降低重复检查的开销。
+
+```c++
+template<typename T>
+using PtrCheckerType = void (*)(const T*);
+
+template<typename T>
+constexpr void CheckNothing(const T*) {}
+
+template<typename T, PtrCheckerType<T> Check = CheckNothing<T>>
+class Ptr;
+```
+
+如上所示，`Ptr`的默认校验行为不做任何检查，通过
+
+```c++
+template < typename T>
+using XXXPtr = utils::Ptr<T, CheckXXX<T>>;
+```
+
+即可定义不同场景下的已经校验过的指针对象，统称安全指针。
+
+*注：其由`safe_ptr`的诉求而扩展而来，但`safe_ptr`相对通用的`Ptr`场景更为复杂，因为其针对的是指针本身的合法性而非指针对象的特征。*
+
+## `safe_ptr`
+
+参见《CPPCodingTalkAboutPointer》中`Ref`的定义。由于`c++`中`operator.`无法进行重载，所以无法构建`Ref`对象，但可以定义与其等效的非空指针对象，即`safe_ptr`。
+
+### 场景：数组、字典等容器成员
+
+示例可见于《CPPCodingTalkAboutPointer》。
+
+为了弥补`operator.`无法重载的问题，后续将扩展`Utility`中`ToRef`小工具的能力，保证指针无开销但安全转换为引用。其可能特化如下：
+
+```c++
+template <typename T>
+constexpr T &ToRef(safe_ptr<T> ptr) {
+  return *ptr;
+}
+```
+
+*注：对于使用频繁的容器，后续将封装`ref_xxx`系列的容器以取代`safe_ptr`这类使用场景。*
+
+### 场景：作为对象成员
+
+此为`safe_ptr`开发出来后意外发掘的场景。
+
+由于存在引用数据成员的类，编译器无法为其生成默认拷贝和转移，但很多场景下需要支持拷贝和转移能力，此时通常的做法是存储为指针成员。但指针成员将带来两个问题：
+
+1. 针对指针成员访问时需要去识别指针的合法性。
+2. 重构和演进都有可能从定义成员的角色方来改变其行为可空，而使用成员的角色方不一定会被告知，这可能会导致进一步的隐藏bug。
+
+而使用`safe_ptr`代替裸指针，`safe_ptr`解引用处都使用`ToRef`来转引用(裸指针的`ToRef`有额外的开销)，将会避免这样的问题。
+
+*注意：`safe_ptr`设计为容器或对象成员，而不应用于函数传参，函数传参应使用`&`。*
+
+## `mpl_iterator`
+
+`mpl_iterator`原名为`iterator`，但由于和容器中`using iterator`重名，所以添加`mpl`前缀。
+
+由于`ref_xxx`容器的设计，以及未来可能扩展small talk系列，重复的迭代器设计是个比较麻烦的问题，所以抽象出持续演进的统一迭代器容器，通过`mpl_iterator_traits`进行少量配置而快速实现新容器的迭代器。
+
+当前基于`ref_vector`的迭代器诉求，设计`mpl_iterator_traits`的成员如下：
+
+```c++
+template <typename Iterator, typename Container>
+struct mpl_iterator_traits {
+  using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
+  using value_type = typename std::iterator_traits<Iterator>::value_type;
+  using difference_type = typename std::iterator_traits<Iterator>::difference_type;
+  using pointer = typename std::iterator_traits<Iterator>::pointer;
+  using reference = typename std::iterator_traits<Iterator>::reference;
+
+  static reference operator_dereference(Iterator iter) {
+    return *iter;
+  };
+
+  static Iterator operator_arrow(Iterator iter) {
+    return iter;
+  }
+
+  static reference operator_bracket(Iterator iter, difference_type n) {
+    return iter[n];
+  }
+};
+
+```
+
+## `ref_vector`
+
+参见《CPPCodingTalkAboutPointer》中`ref_vector`的定义。
+
+使用指针数组：`std::vector<T*>`
+
+```c++
+  int a = 0, b = 1;
+
+  std::vector<int*> data;
+  data.push_back(&a);
+  data.push_back(&b);
+  ASSERT_EQ(*data[0], 0);
+  ASSERT_EQ(*data[1], 1);
+```
+
+重构为引用数组：`utils::ref_vector<T>`
+```c++
+  int a = 0, b = 1;
+
+  ref_vector<int> data;
+  data.push_back(a);
+  data.push_back(b);
+  ASSERT_EQ(data[0], 0);
+  ASSERT_EQ(data[1], 1);
+```
+
+## `Index`
+
+`Index`的设计初衷为满足基础类型的静态安全。
+
+如`GStrIdx`、`UStrIdx`、`U16StrIdx`三者在业务代码中会共同参与计算，包括其提供的接口也有比较高的相似性。它们底层均为`uint32`，若均定义为`uint32`那将是个灾难，调用者不得不得小心翼翼，但也很难避免传错数据。所以使静态类型互斥，由编译器来检查使用的正确性，将大大降低出错的几率。
+
+定义一个静态类型方式非常简单，只要定义不同的Tag即可，如下：
+
+```c++
+class GStrTag;
+using GStrIdx = utils::Index<GStrTag, uint32>;
+
+class UStrTag;
+using UStrIdx = utils::Index<UStrTag, uint32>;
+
+class U16StrTag;
+using U16StrIdx = utils::Index<U16StrTag, uint32>; 
+```
+
+# Generalize Pattern
+
+## `ObjectFactory`
+
+`ObjectFactory`为针对抽象工厂的封装，用于解决以下问题：
+
+1. 消除代码中由`switch ... case`、`if ... else if ...`等构成的具有高圈复杂度的大函数，这类函数难以维护和扩展，且灵活度低。*(注意：应避免机械的性解决问题，需分析语义做好设计，如配合模板模式等，实现设计隔离而非仅仅代码隔离。)*
+
+2. 采用工厂将依赖反转，更容易将调用者和设计者、设计者和设计者之间隔离。
+
+其应用方式如下示例：
+
+```c++
+// 定义Key，用于标记工厂将创建的产品类别
+enum class ObjectType {
+  kPlus,
+  kMinus
+};
+
+// 定义接口，所有产品应实现的接口协议
+class Base {
+ public:
+  virtual ~Base() = default;
+  virtual int32_t DoIt(int32_t lhs, int32_t rhs) const = 0;
+};
+
+// 定义工厂，使用ObjectType作为查找关键字，Base为接口协议，int32_t为所有产品构造函数的参数类型
+using TestObjectFactory = ObjectFactory<ObjectType, Base, int32_t>;
+
+// Key，接口，工厂需要对注册者和调用者均可见，所以可能在.h文件中，可能在.cpp文件汇总
+// 产品只要保证能注册入工厂，可以在不同的.cpp文件中
+// 定义产品
+class ObjectPlus : public Base {
+ public:
+  // 定义工厂时所约定的构造函数
+  explicit ObjectPlus(int32_t base) : base(base) {}
+  virtual ~ObjectPlus() = default;
+
+  // 定义接口时的约定
+  virtual int32_t DoIt(int32_t lhs, int32_t rhs) const override {
+    return base + lhs + rhs;
+  }
+
+ private:
+  int32_t base;
+};
+
+// 定义产品，可能在另外的.cpp文件中
+class ObjectMinus : public Base {
+ public:
+  explicit ObjectMinus(int32_t base) : base(base) {}
+  virtual ~ObjectMinus() = default;
+
+  virtual int32_t DoIt(int32_t lhs, int32_t rhs) const override {
+    return base + lhs - rhs;
+  }
+
+ private:
+  int32_t base;
+};
+
+// 注册产品，注册产品的方式随着Key，接口，工厂，产品之间的分布以及加载可灵活处理，保证注册成功即可
+// 此处利用static变量初始化来确保注册
+bool RegisterObject() {
+  RegisterFactoryObject<TestObjectFactory, ObjectType::kPlus, ObjectPlus>();
+  RegisterFactoryObject<TestObjectFactory, ObjectType::kMinus, ObjectMinus>();
+}
+static auto testObjectFactory = RegisterObject();
+
+TEST(TestFactory, ObjectFactory) {
+  // 获取产品对象，需要判空，本示例略
+  auto obj = CreateProductObject<TestObjectFactory>(ObjectType::kPlus, 10);
+  ASSERT_EQ(obj->DoIt(1, 2), 13);
+  obj = CreateProductObject<TestObjectFactory>(ObjectType::kMinus, 10);
+  ASSERT_EQ(obj->DoIt(1, 2), 9);
+}
+```
+
+## `FunctionFactory`
+
+`FunctionFactory`解决的问题与`ObjectFactory`类似，其主要为了简化抽象工厂的复杂性，对于大多数场景，`FunctionFactory`更容易编写和上手。
+
+其应用方式如下示例：
+
+```c++
+// 定义Key，用于标记工厂将创建的产品类别
+enum class FunctionType {
+  kPlus,
+  kMinus
+};
+
+// 定义接口和工厂，使用FunctionType作为查找关键字，int32_t(int32_t, int32_t)为函数协议
+using TestFunctionFactory = FunctionFactory<FunctionType, int32_t, int32_t, int32_t>;
+
+// 定义产品
+int32_t Plus(int32_t lhs, int32_t rhs) {
+  return lhs + rhs;
+}
+
+// 定义产品，可能在另外的.cpp文件中
+int32_t Minus(int32_t lhs, int32_t rhs) {
+  return lhs - rhs;
+}
+
+// 注册产品，注册产品的方式随着Key，接口，工厂，产品之间的分布以及加载可灵活处理，保证注册成功即可
+// 此处利用单件模式来确保注册
+bool RegisterFunction() {
+  RegisterFactoryFunction<TestFunctionFactory>(FunctionType::kPlus, Plus);
+  RegisterFactoryFunction<TestFunctionFactory>(FunctionType::kMinus, Minus);
+}
+void AutoFunctionLoader() {
+  static auto testObjectFactor = RegisterFunction();
+}
+
+TEST(TestFactory, TestAll) {
+  // 加载产品
+  AutoFunctionLoader();
+
+  // 获取产品对象，需要判空，本示例略
+  auto func = CreateProductFunction<TestFunctionFactory>(FunctionType::kPlus);
+  ASSERT_EQ(func(1, 2), 3);
+  func = CreateProductFunction<TestFunctionFactory>(FunctionType::kMinus);
+  ASSERT_EQ(func(1, 2), -1);
+}
+```
+
+
+# Utility
+
+## `ToRef`
+
+针对方舟新增代码和重构代码中指针传参的场景，期望以引用的方式来替代，即确保所有指针均已经过校验，再以引用的方式传递给被调用的函数，被调用函数多数情况下不应承担函数参数中指针为空的风险以及判断的开销。
+
+通常的写法为(示例中`DoIt`和`Run`可当做第三方接口，无法更改)：
+
+```c++
+A *DoIt(B &b);
+void Run(B *b) {
+  CHECK_NULL_FATAL(b);
+  // ...
+  A *a = DoIt(*b);
+  CHECK_NULL_FATAL(a);
+  a->Do;
+}
+```
+
+期望多数指针获取即引用：
+
+```c++
+A *DoIt(B &b);
+void Run(B *b) {
+  B &bRef = utils::ToRef(b);
+  // ...
+  A &a = utils::ToRef(DoIt(bRef));
+  a.Do;
+}
+```
+
+对于`b`仅单次使用，亦可以调整为：
+
+```c++
+A *DoIt(B &b);
+void Run(B *b) {
+  // ...
+  A &a = utils::ToRef(DoIt(utils::ToRef(b)));
+  a.Do;
+}
+```
+
+## `bit_field_v`&`lbit_field_v`
+
+使用bit位来标记状态开关组合，是一种既节约内存又能高效编码的设计方法。通常，在枚举定义或常量定义时，会有如下写法：
+
+```c++
+enum BBAttr : uint32 {
+  kBBAttrIsEntry = 0x02,
+  kBBAttrIsExit = 0x04,
+  kBBAttrWontExit = 0x08,
+  kBBAttrIsTry = 0x10,
+  kBBAttrIsTryEnd = 0x20,
+  kBBAttrIsJSCatch = 0x40,
+  kBBAttrIsJSFinally = 0x80,
+  kBBAttrIsCatch = 0x0100,
+  kBBAttrIsJavaFinally = 0x0200,
+  kBBAttrArtificial = 0x0400,
+  kBBAttrIsInLoop = 0x0800,
+  kBBAttrIsInLoopForEA = 0x1000
+};
+```
+
+此设计很明显的欲用位来记录某些属性信息，但位信息比较隐晦，难以维护与阅读。
+
+所以需要更加清晰的设计：
+
+```c++
+enum BBAttr : uint32 {
+  kBBAttrIsEntry       = utils::bit_field_v<1>,
+  kBBAttrIsExit        = utils::bit_field_v<2>,
+  kBBAttrWontExit      = utils::bit_field_v<3>,
+  kBBAttrIsTry         = utils::bit_field_v<4>,
+  kBBAttrIsTryEnd      = utils::bit_field_v<5>,
+  kBBAttrIsJSCatch     = utils::bit_field_v<6>,
+  kBBAttrIsJSFinally   = utils::bit_field_v<7>,
+  kBBAttrIsCatch       = utils::bit_field_v<8>,
+  kBBAttrIsJavaFinally = utils::bit_field_v<9>,
+  kBBAttrArtificial    = utils::bit_field_v<10>,
+  kBBAttrIsInLoop      = utils::bit_field_v<11>,
+  kBBAttrIsInLoopForEA = utils::bit_field_v<12>
+};
+```
+
+其中`bit_field_v`:`uint32`，`lbit_field_v`:`uint64`，未来将按需添加`sbit_field_v`:`uint16`以及`bbit_field_v`:`uint8`。
diff --git a/doc/cn/DevelopmentPreparation.md b/doc/cn/DevelopmentPreparation.md
new file mode 100644
index 0000000000000000000000000000000000000000..8420fc48fdb4cef88e31c202e272cfb393c8449a
--- /dev/null
+++ b/doc/cn/DevelopmentPreparation.md
@@ -0,0 +1,171 @@
+# 环境配置
+
+## 硬件推荐配置
+
+- 2 GHz 双核处理器或者更高等级 CPU
+
+- 2 GB 系统内存及以上
+
+- 200GB 可用磁盘空间
+
+## 开发环境推荐
+
+您需要安装一个 64 位版本的 Ubuntu（Ubuntu 16.04，18.04，20.04 皆可）
+
+```
+sudo apt-get -y install clang llvm lld libelf-dev libssl-dev python qemu openjdk-8-jre-headless openjdk-8-jdk-headless cmake
+sudo apt-get -y install git build-essential zlib1g-dev libc6-dev-i386 g++-multilib gcc-multilib linux-libc-dev:i386
+
+Ubuntu 16.04:
+sudo apt-get -y install gcc-5-aarch64-linux-gnu g++-5-aarch64-linux-gnu
+
+Ubuntu 18.04:
+sudo apt-get -y install gcc-7-aarch64-linux-gnu g++-7-aarch64-linux-gnu
+
+Ubuntu 20.04:
+sudo apt-get -y install gcc-9-aarch64-linux-gnu g++-9-aarch64-linux-gnu libncurses5
+```
+
+## 自动安装工具
+
+```
+source build/envsetup.sh arm release
+make setup
+
+以下的步骤只是作为参考，需要的工具都已经在 "make setup" 一步自动安装完成。
+```
+
+## 安装 Clang 编译器并完成配置（用于编译方舟编译器代码，20.04 已改为使用系统安装的 Clang）
+
+下载**clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04** (具体版本请根据系统版本确定)
+
+LLVM 下载地址：http://releases.llvm.org/download.html#10.0.0
+
+解压并放置到`openarkcompiler/tools`目录
+
+- 修改`openarkcompiler/build/envsetup.sh`文件，将`CLANG_PATH`变量配置为 clang 编译器所在路径，例如：
+
+```
+CLANG_PATH = "${MAPLE_ROOT}/tools/clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04/bin"
+```
+
+其中${MAPLE_ROOT}为 openarkcompiler 源码根目录。
+
+## 安装 Ninja、GN 并完成配置
+
+下载**Ninja(v1.10.0)**及**GN(Linux Version)**
+
+Ninja 下载地址：https://github.com/ninja-build/ninja/releases
+
+GN 下载地址：https://gitee.com/xlnb/gn_binary
+
+将 GN 和 Ninja 可执行程序放置到`openarkcompiler/tools`目录，然后修改这两个文件为可执行:
+
+```
+cd openarkcompiler/tools
+chmod 775 gn
+chmod 775 ninja
+```
+
+打开`openarkcompiler/Makefile`文件，将 GN 和 NINJA 两个变量配置为 GN 和 Ninja 可执行程序所在路径。例如：
+
+```
+GN := ${MAPLE_ROOT}/tools/gn/gn
+NINJA := ${MAPLE_ROOT}/tools/ninja/ninja
+```
+
+## 安装 gcc-linaro 并完成配置（用于交叉编译方舟编译器代码）
+
+下载**gcc-linaro-7.5.0-2019.12-i686_aarch64-linux-gnu**
+
+gcc-linaro-7.5.0 下载地址：https://releases.linaro.org/components/toolchain/binaries/latest-7/aarch64-linux-gnu/
+
+解压并放置到`openarkcompiler/tools`目录，并将文件夹更名为`gcc-linaro-7.5.0`。
+
+- 修改`openarkcompiler/build/config.gni`文件，将`GCC_LINARO_PATH`变量配置为 gcc-linaro-7.5.0 所在路径，例如：
+
+```
+GCC_LINARO_PATH = "${MAPLE_ROOT}/tools/gcc-linaro-7.5.0"
+```
+
+- 修改`openarkcompiler/build/core/maple_variables.mk`文件，将`GCC_LINARO_PATH`配置为 gcc-linaro-7.5.0 所在路径，例如：
+
+```
+GCC_LINARO_PATH := ${MAPLE_ROOT}/tools/gcc-linaro-7.5.0
+```
+
+## 安装 android-ndk 并完成配置（用于编译方舟编译器代码）
+
+下载**android-ndk-r21b-linux-x86_64.zip**
+
+android-ndk-r21 下载地址：https://developer.android.google.cn/ndk/downloads/
+
+解压并放置到 openarkcompiler/tools 目录，并将文件夹更名为`android-ndk-r21`。
+
+- 修改`openarkcompiler/build/config.gni`文件，将`NDK_PATH`变量配置为 android-ndk-r21 所在路径，例如：
+
+```
+NDK_PATH = "${MAPLE_ROOT}/tools/android-ndk-r21"
+```
+
+- 修改`openarkcompiler/build/core/maple_variables.mk`文件，将`NDK_PATH`配置为 android-ndk-r21 所在路径，例如：
+
+```
+NDK_PATH := ${MAPLE_ROOT}/tools/android-ndk-r21
+```
+
+## AOSP 运行环境依赖
+
+当前编译方舟编译器 Sample 应用需要使用到 Java 基础库，我们通过 AOSP 来获取，请使用 Android-10.0.0_r35 版本，暂不支持 Android11 版本。
+
+AOSP 下载地址：https://source.android.com/source/downloading/
+
+下载 AOSP 并编译完成。
+
+- 在 openarkcompiler 目录下新建链接`android/`，并链接到 AOSP 的根目录；
+- 将`openarkcompiler/android/out/target/product/generic_arm64/obj/JAVA_LIBRARIES/core-all_intermediates/javalib.jar`拷贝到`openarkcompiler/libjava-core`目录，并命名为`java-core.jar`，同时码云上也提供了编译好的 libcore 的 jar 文件，你可以下载直接使用，下载链接`https://gitee.com/xlnb/aosp_core_bin`；
+- 在 openarkcompiler/tools 下新建链接 gcc，并链接到 AOSP 的`openarkcompiler/android/prebuilts/gcc`;
+- 在 openarkcompiler/tools 下新建链接 clang-r353983c，并链接到 AOSP 的`openarkcompiler/android/prebuilts/clang/host/linux-x86/clang-r353983c`；
+- 修改`openarkcompiler/build/config.gni`和`openarkcompiler/build/core/maple_variables.mk`中`ANDROID_GCC_PATH`和`ANDROID_CLANG_PATH`两个变量，配置为上述 gcc 和 clang-r353982c 的所在路径，例如：
+
+config.gni
+
+```
+ANDROID_GCC_PATH = "${MAPLE_ROOT}/tools/gcc"
+ANDROID_CLANG_PATH = "${MAPLE_ROOT}/tools/clang-r353983c"
+```
+
+maple_variables.mk
+
+```
+ANDROID_GCC_PATH := ${MAPLE_ROOT}/tools/gcc
+ANDROID_GLANG_PATH := ${MAPLE_ROOT}/tools/clang-r353983c
+```
+
+## 构建工具依赖下载
+
+### icu 下载并编译
+
+当前用例编译需要 icu 动态库支持，请使用 icu56.1 版本。
+
+icu 下载地址：http://site.icu-project.org/home
+
+下载 56.1 版本的 icu4c 并编译完成，生成`libicuuc.so`和`libicudata.so`，将两者放置到`openarkcompiler/third_party/icu/lib/aarch64-linux-gnu`路径下，并重命名为`libicuuc.so.56`和`libicudata.so.56`。
+
+### libz 下载并编译
+
+当前用例编译需要 libz.so 支持，请使用 1.2.8 版本。
+
+libz 下载地址：https://zlib.net
+
+下载 1.2.8 版本的 libz.so，将其放置到`openarkcompiler/third_party/libdex/prebuilts/aarch64-linux-gnu/`路径下，并重命名为`libz.so.1.2.8`。
+
+### r8 下载并编译
+
+当前用例编译需要 d8.jar 支持，请使用 d8-1.5.13 版本。
+
+r8 社区地址：https://r8.googlesource.com/r8
+
+已经编译后的二进制：https://gitee.com/xlnb/r8-d81513/tree/master/d8/lib/d8.jar
+
+将 d8.jar 放置到`openarkcompiler/third_party/d8/lib/`目录
diff --git a/doc/cn/MapleDriverOverview.md b/doc/cn/MapleDriverOverview.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca6fbbe172b833f9314178a8d43f6a47421107ac
--- /dev/null
+++ b/doc/cn/MapleDriverOverview.md
@@ -0,0 +1,46 @@
+# maple驱动程序概述
+## 简介
+本文档描述了maple驱动程序的当前状态。这包括设计、使用、目标和内部实施。
+
+## 目标
+maple驱动程序旨在满足优秀编译器（如clang）的要求。换句话说，它应该是：
+-灵活支持新功能
+-高效，开销低
+-易于使用
+
+驱动程序开发的最终目标是完全支持gcc选项，并直接集成到CMake构建系统中。
+
+## 设计和实现
+
+### 设计概述
+
+下图显示了maple驱动程序体系结构的重要组件以及它们之间的关系。红色组件表示基本的驱动程序部分（类、方法），蓝色组件是输出/输入数据结构，绿色组件是重要的帮助器类。
+
+![](media/MapleDriverStructure.png)
+
+### 驱动程序阶段
+
+驱动程序功能可分为五个阶段：
+
+**1.解析选项**
+
+首先检查输入命令行参数字符串的格式正确性，并将其转换为键值对，然后检查键是否在`OptionParser`的`usage`多映射（以前从帮助数据结构创建）中匹配。Option类还包含Descriptor数据结构，用一些附加数据描述选项参数所需的解析细节。然后解析参数。驱动程序希望了解所有可用选项。然后，结果将写入`OptionParser`类的`options`向量中。
+
+
+**2.填充MplOptions**
+
+解析输入后，根据结果填充`MplOptions`：首先确定运行类型为自动或者自定义（取决于`--run`选项），然后初始化输入文件并检查有效性。如果运行类型为自动maple驱动程序还将自行配置代码生成管道（您将接收汇编程序文件作为最终输出），具体取决于第一个输入文件的扩展名。然后处理其他选项，包括`--option`，其值必须包含所有编译阶段的选项，使用解析通用选项时相同方法和数据结构来解析值，结果将存放到`MplOptions`类的`exeOptions`映射中。然后，maple驱动程序尝试打开输入文件，如果成功，将进入下一阶段。
+
+**3.编译器选择**
+
+上一阶段完成后，maple驱动程序触发`CompilerFactory`类构造函数，该构造函数创建受支持编译器的类，并将指向所有编译器的指针保存在`supportedCompilers`数据结构中。
+
+**4.阶段特定选项构建**
+
+`CompilerFactory`调用选定编译器的`Compile`方法，该方法构造默认和自定义的选项并写入字符串中。主要的问题是命令从一种风格转换到另一种风格，一些驱动程序组件需要自己的方法正确运行，如`MplcgCompiler`；而另一些组件只使用几个选项，它们的主要目的是确定要调用的可执行文件的路径和传递它们的输入和输出参数，如`AsCompiler`。
+
+但是，`MaplecombCompiler`和`MplcgCompiler`需要特殊的管道，它们不调用可执行文件给它们传递命令行，而是使用`MIRModule`、`mirParser`和`DriverRunner`类与输入文件交互。`MIRModule`是一种数据结构，其功能类似于`MplOptions`，`MaplecombCompiler`和`MplcgCompiler`会在其中存储关键数据（输入文件的名称、源语言等）；`MIRParser`是为了解析maple IR; `DriverRunner`是一个协调器，它可以与以前的两个数据结构一起工作，同时还存储其负责的阶段的选项和编译中所需的其他数据。
+
+**5.执行**
+
+之后，可执行文件的命令行和完整路径将重定向到`SafeExe`类的`Exe`方法，在那里它通过子进程处理和执行。如果是`MaplecombCompiler`和`MplcgCompiler`，则调用`DriverRunner`的`Run`方法，并将作业发布到阶段管理器。
\ No newline at end of file
diff --git a/doc/cn/NaiveRcInsertionDescription.md b/doc/cn/NaiveRcInsertionDescription.md
new file mode 100644
index 0000000000000000000000000000000000000000..cfd65561644fd7a017b5d22db865e4b8cbf7c80c
--- /dev/null
+++ b/doc/cn/NaiveRcInsertionDescription.md
@@ -0,0 +1,174 @@
+# 朴素版RC操作插入原理
+
+引用计数（Reference Counting, RC）是计算机编程语言中的一种内存管理技术，是指将资源（可以是对象、内存或磁盘空间等等）的被引用次数保存起来，当被引用次数变为零时就将其释放的过程。使用引用计数技术可以实现自动资源管理的目的。同时引用计数还可以指使用引用计数技术回收未使用资源的垃圾回收算法。朴素版RC（Naive RC）是一种简单直接的RC插入操作。
+
+
+Naive RC插入的基本原理
+======================
+
+- 对象的引用计数的来源：
+
+   - 堆内对象（其它对象、本身）的引用   
+
+   - 栈上的引用（包含寄存器）
+
+   - 静态、全局变量
+
+- 引用计数操作的插入规则（编译器和运行时），对应上面的:   
+
+   - Object field的赋值，需要将field指向的新对象+1，原对象计数-1
+
+   - 读取对象到栈上局部变量（含寄存器），需要对读取的对象引用计数+1
+
+   - 局部变量Last Use后引用计数-1
+
+   - 返回对象，引用计数+1，补偿局部变量Last Use后-1
+
+-   简单示例
+
+    - 插入前
+
+     ```cpp
+    class A {
+      static Object static_field;
+      Object instance_field;
+      A() {
+        static_field = new Object();
+      }
+    }
+    Object foo(){
+      A a = new A();
+      bar(a, new Object())
+      return a.instance_field;
+    }
+    void bar(A a, Object o) {
+      a.instance_field = o;
+    }
+    ```	
+   
+    - 插入后
+
+    ```cpp 
+    class A {
+      A() {
+       local_var t = new Object(); // t是赋值给static_field过程中使用的临时变量
+       old = static_field;
+       static_field = t;
+       IncRef(t); DecRef(old);  // 更新堆上RC
+       DecRef(t); // 函数退出释放栈上RC
+      }
+    }
+    Object foo(){
+      A a = new A();
+      bar(a, new Object());
+      locl_var t = a.instance_field;
+      IncRef(t) // 栈上变量引用RC+1
+      IncRef(t) // 函数返回，返回值RC+1
+      DecRef(a) // 函数退出释放栈上RC，释放a
+      DecRef(t) // 函数退出释放栈上RC
+      return t;
+    }
+    void bar(A a, Object o) {
+      old = a.instance_field
+      a.instance_field = o;
+      IncRef(o); DecRef(old);
+    }
+     ```
+
+
+- 引用计数函数MIntrinsicsId:
+
+   - 基础函数
+    使用方法：使用IrMap中的CreateIntrinsicCallMeStmt创建IntrinsiccallMeStmt语句，并插入到RC需要加减之处。
+
+      - INTRN_MCCIncRef
+
+      - INTRN_MCCDecRef
+
+   - Load/Write函数
+    使用方法：Write函数使用IrMap中的CreateIntrinsicCallMeStmt创建IntrinsiccallMeStmt语句替换左值具有static、global、volatile等属性的iassign语句、Load函数使用CreateIntrinsicCallAssignedMeStmt创建IntrinsiccallMeStmt语句，并替换右值具有static、global、volatile等属性的dassign语句，Load/Write函数均具有IncRef操作。
+
+      -   INTRN_MCCLoadRef
+
+      -   INTRN_MCCLoadRefS
+
+      -   INTRN_MCCLoadRefVol
+
+      -   INTRN_MCCLoadRefSVol
+
+      -   INTRN_MCCWrite
+
+      -   INTRN_MCCWriteS
+
+      -   INTRN_MCCWriteVol
+
+      -   INTRN_MCCWriteSVol
+
+RefVar IncRef 处理规则：
+========================
+
+- 赋值语句处理：
+
+   - 按照左值（赋值语句中被赋值的变量）、右值（赋值语句中被引用的值）表达式不同处理
+
+   - 先处理右值：比如选择什么Load接口；不需要+1的右值（New、Call）
+
+      - Global属性选择INTRN_MCCLoadRef
+
+      - Static属性选择INTRN_MCCLoadRefS
+
+      - Volatile属性选择INTRN_MCCLoadRefVol
+
+   - 再处理左值：选择什么Write接口；是否需要保存老值等等
+
+      - Global属性选择INTRN_MCCWriteRef
+
+      - Static属性选择INTRN_MCCWriteRefS
+
+      - Volatile属性选择INTRN_MCCWriteRefVol
+
+-   返回值处理：
+
+    - 返回值+1
+
+- 局部变量处理：
+
+   - 在当前函数退出前（异常、正常退出）引用计数减一
+
+Rclowering处理流程：
+====================
+
+- 设置rclowering处理标志位
+- 标记localrefvar
+
+- rclowering预处理
+
+   - 标记需要RC操作的变量
+
+      - 需要标记DecRef的左值（赋值语句中被赋值的变量）：
+
+         - Ref变量
+
+   - 需要标记IncRef的右值（赋值语句中被引用的值或返回值等）：
+
+      - Return值
+
+      - Ref变量
+
+     - hrow Value的寄存器
+
+   - 清理栈变量
+
+- rclowering处理
+
+   - 处理包含Ref类型变量的赋值语句
+
+      - DecRef原值
+
+      - IncRef新值，参照RefVar IncRef 处理规则
+
+- rclowering后处理
+
+   - 在函数入口对参数做IncRef并标记为LocalRefVar属性
+
+   - 处理函数返回值， 属性为LocalRefVar，则InRef，其他参照RefVar IncRef处理规则右值部分
diff --git a/doc/cn/ProgrammingSpecifications.md b/doc/cn/ProgrammingSpecifications.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e80d28632387a41cc4d317cef5fa39ee27feecc
--- /dev/null
+++ b/doc/cn/ProgrammingSpecifications.md
@@ -0,0 +1,3089 @@
+<!-- <center><br><br><br><br><br><br><br> -->
+<big><big><big><big><big><strong> 方舟编译器C++语言编程规范 </strong><big><big><big><big><big>
+
+<!-- <center><br><br><br><br><br><br><br> -->
+
+
+
+
+
+
+<!-- <br></center> -->
+
+
+| 章节                 | 内容                                       |
+| ------------------ | ---------------------------------------- |
+| [0 前言](#c0)        | [目的](#c0-1) [重点关注](#c0-2) [约定](#c0-3) [例外](#c0-4) |
+| [1 原则](#c1)        | [好代码的原则](#c1-1) [类和函数设计指导原则](#c1-2) [遵循C++ ISO标准](#c1-4) <br>[优先编译时检查错误](#c1-5) [使用命名空间来限定作用域](#c1-6) [优先使用C++特性而不是C特性](#c1-7) |
+| [2 命名](#c2)        | [通用命名](#c2-1) [文件命名](#c2-2) [函数命名](#c2-3) [类型命名](#c2-4) [变量命名](#c2-5) [宏、常量、枚举命名](#c2-6) |
+| [3 格式](#c3) | [行宽](#c3-1) [缩进](#c3-2) [大括号](#c3-3) [函数声明和定义](#c3-4) [函数调用](#c3-5) [if语句](#c3-6) [循环语句](#c3-7) [switch语句](#c3-8) [表达式](#c3-9) [变量赋值](#c3-10) <br>[初始化](#c3-11) [指针和引用](#c3-12) [编译预处理](#c3-13) [空格和空行](#c3-14) [类](#c3-15) |
+| [4 注释](#c4)        | [注释风格](#c4-1) [文件头注释](#c4-2) [函数头注释](#c4-3) [代码注释](#c4-4) |
+| [5 头文件](#c5)       | [头文件职责](#c5-1) [头文件依赖](#c5-2)            |
+| [6 作用域](#c6)       | [命名空间](#c6-1) [全局函数和静态成员函数](#c6-2) [全局变量](#c6-3) [全局常量和静态成员常量](#c6-4) |
+| [7 类](#c7)         | [构造、拷贝构造、赋值和析构函数](#c7-1) [继承](#c7-2) [多重继承](#c7-3) [重载](#c7-4) |
+| [8 函数](#c8)        | [函数设计](#c8-1) [内联函数](#c8-2) [函数参数](#c8-3) |
+| [9 C++其他特性](#c9)   | [常量与初始化](#c9-1) [表达式](#c9-2) [类型转换](#c9-3) [资源分配和释放](#c9-4) [标准库](#c9-5) [const的用法](#c9-6) [模板](#c9-7) [宏](#c9-8) [其他](#c9-9)|
+| [10 现代C++特性](#c10) | [代码简洁性和安全性提升](#c10-1) [智能指针](#c10-2) [Lambda](#c10-3) [接口](#c10-4) |
+| [11 安全编码规范](#c11) | [基本原则](#c11-1) [变量](#c11-2) [断言](#c11-3) [异常机制](#c11-4) [内存](#c11-5) [危险函数](#c11-6) |
+
+# <a name="c0"></a>0 前言
+
+## <a name="c0-1"></a> 目的
+
+规则并不是完美的，通过禁止在特定情况下有用的特性，可能会对代码实现造成影响。但是我们制定规则的目的__“为了大多数程序员可以得到更多的好处”__， 如果在团队运作中认为某个规则无法遵循，希望可以共同改进该规则。
+
+参考该规范之前，希望您具有相应的C++基础能力，而不是通过该文档来学习C++。
+1. 了解C++的ISO标准；
+2. 熟知C++的基本语言特性，包括C++ 03/11/14/17相关特性；
+3. 了解C++的标准库；
+
+
+## <a name="c0-2"></a> 重点关注
+1. 约定C++的编程风格，比如命名，排版等。
+2. C++的模块化设计，如何设计头文件，类，接口和函数。
+3. C++相关特性的优秀实践，比如常量，类型转换，资源管理，模板等。
+4. 现代C++的优秀实践，包括C++11/14/17中可以提高代码可维护性，提高代码可靠性的相关约定。
+
+
+## <a name="c0-3"></a> 约定
+**规则**：编程时必须遵守的约定(must)
+
+**建议**：编程时应该遵守的约定(should)
+
+本规范适用通用C++标准, 如果没有特定的标准版本，适用所有的版本(C++03/11/14/17)。
+
+## <a name="c0-4"></a> 例外
+无论是'规则'还是'建议'，都必须理解该条目这么规定的原因，并努力遵守。
+但是，有些规则和建议可能会有例外。
+
+在不违背总体原则，经过充分考虑，有充足的理由的前提下，可以适当违背规范中约定。
+例外破坏了代码的一致性，请尽量避免。'规则'的例外应该是极少的。
+
+下列情况，应风格一致性原则优先：  
+**修改外部开源代码、第三方代码时，应该遵守开源代码、第三方代码已有规范，保持风格统一。**  
+**某些特定领域，优先参考其行业规范。**
+
+# <a name="c1"></a>1 原则
+
+## <a name="c1-1"></a> 好代码的原则
+我们参考Kent Beck的简单设计四原则来指导我们的如何写出优秀的代码，如何有效地判断我们的代码是优秀的。
+1.    通过所有测试（Passes its tests）
+2.    尽可能消除重复 (Minimizes duplication)
+3.    尽可能清晰表达 (Maximizes clarity)
+4.    更少代码元素 (Has fewer elements)
+5.    以上四个原则的重要程度依次降低。
+    这组定义被称做简单设计原则。
+
+第一条强调的是外部需求，这是代码实现最重要的；第二点就是代码的模块架构设计，保证代码的正交性，保证代码更容易修改；第三点是代码的可阅读性，保证代码是容易阅读的；最后一点才是保证代码是简洁的，在简洁和表达力之间，我们更看重表达力。
+
+## <a name="c1-2"></a> 类和函数设计指导原则
+C++是典型的面向对象编程语言，软件工程界已经有很多OOP原则来指导我们编写大规模的，高可扩展的，可维护性的代码：
+- 高内聚，低耦合的基本原则：使程序模块的可重用性、移植性大大增强
+- SOLID原则：分别是单一原则、开闭原则、里氏替换原则、接口隔离原则、依赖倒置原则，遵循五大原则可以使程序低耦合，更加健壮
+- 迪米特法则：降低类之间的耦合
+- “Tell，Don’t ask”原则：一个对象应该命令其它对象做什么，而不是去查询其它对象的状态来决定做什么
+- 组合/聚合复用原则：尽量使用合成/聚合，不要使用类继承
+
+## <a name="c1-3"></a> 遵循C++ ISO标准
+希望通过使用ISO C++标准的特性来编写C++代码，对于ISO标准中未定义的或者编译器实现的特性要谨慎使用，对于GCC等编译器的提供的扩展特性也需要谨慎使用，这些特性会导致代码的可移植性比较差。
+
+注意：如果模块中需要使用相关的扩展特性来，那么尽可能将这些特性封装成独立的接口，并且可以通过编译选项关闭或者编译这些特性。对于这些扩展特性的使用，请模块制定特性编程指南来指导这些特性的使用。
+
+## <a name="c1-4"></a> 优先编译时检查错误
+通过编译器来优先保证代码健壮性，而不是通过编写错误处理代码来处理编译就可以发现的异常，比如：
+
+- 通过const来保证数据的不变性，防止数据被无意修改。
+- 通过static_assert来进行编译时检查。
+
+## <a name="c1-5"></a> 使用命名空间来限定作用域
+全局变量，全局常量和全局类型定义由于都属于全局作用域，在项目中，使用第三方库中容易出现冲突。
+
+命名空间将作用域细分为独立的，具名的作用域，可有效地防止全局作用域的命名冲突。
+1. class，struct等都具有自己的类作用域。
+2. 具名的namespace可以实现类作用域更上层的作用域。
+3. 匿名namespace和static可以实现文件作用域。
+
+对于没有作用域的宏变量，宏函数强烈建议不使用。
+
+作用域的一些缺点：
+1. 虽然可以通过作用域来区分两个命名相同的类型，但是还是具有迷惑性。
+2. 内联命名空间会让命名空间内部的成员摆脱限制，让人迷惑。
+3. 通过多重嵌套来定义namespace，会让完整的命名空间比较冗长。
+
+所以，我们使用命名空间的建议如下：
+- 对于变量，常量和类型定义尽可能使用namespace，减少全局作用域的冲突
+- 不要在头文件中使用using namespace
+- 不要使用内联命名空间
+- 鼓励在.cpp文件中通过匿名namespace或者static来封装，防止不必要的定义通过API暴露出去。
+
+
+## <a name="c1-6"></a> 优先使用C++特性而不是C特性
+C++比起C语言更加类型安全，更加抽象。我们更推荐使用C++的语言特性来编程，比如使用string而不是`char*`, 使用vector而不是原生数组，使用namespace而不是static。
+
+
+# <a name="c2"></a>2 命名
+## <a name="c2-1"></a>通用命名
+常见命名风格有：
+__驼峰风格(CamelCase)__
+大小写字母混用，单词连在一起，不同单词间通过单词首字母大写来分开。
+按连接后的首字母是否大写，又分: 大驼峰(UpperCamelCase)和小驼峰(lowerCamelCase)
+
+__内核风格(unix_like)__
+单词全小写，用下划线分割。
+如：'test_result'
+
+__匈牙利风格__
+在‘大驼峰’的基础上，加上前缀；前缀用于表达类型或用途。
+如：'uiSavedCount', 'bTested'
+
+### <a name="r2-1-1"></a>规则2.1.1 标识符命名使用驼峰风格
+不考虑匈牙利命名，在内核风格与驼峰风格之间，根据存量代码的情况，我们选择驼峰风格。
+
+| 类型                                                         | 命名风格                                 |
+| ------------------------------------------------------------ | ---------------------------------------- |
+| 类类型，结构体类型，枚举类型，联合体类型等类型定义           | 大驼峰                                   |
+| 函数(包括全局函数，作用域函数，成员函数)                     | 大驼峰（接口部分可加前缀，如XXX_函数名） |
+| 全局变量(包括全局和命名空间域下的变量，类静态变量)，局部变量，函数参数，类、结构体和联合体中的成员变量 | 小驼峰                                   |
+| 常量(const)，枚举值                                          | k+大小写混合                             |
+| 宏                                                           | 大写+下划线                              |
+| 命名空间                                                     | 全小写                                   |
+
+注意：
+上表中__常量__是指全局作用域、namespace域、类的静态成员域下，以 const或constexpr 修饰的基本数据类型、枚举、字符串类型的变量。
+上表中__变量__是指除常量定义以外的其他变量，均使用小驼峰风格。
+
+## <a name="c2-2"></a> 文件命名
+### <a name="a2-2-1"></a>建议2.2.1 C++文件以.cpp结尾，头文件以.h结尾。文件名使用下划线小写风格。
+
+目前业界还有一些其他的后缀的表示方法：
+
+- 头文件：  .hh, .hpp, .hxx
+- cpp文件：.cc, .cxx, .C
+
+对于本文档，我们默认使用.h和.cpp作为后缀。
+
+文件名如下：
+- database_connection.h
+- database_connection.cpp
+
+
+## <a name="c2-3"></a>  函数命名
+函数命名统一使用大驼峰风格，一般采用动词或者动宾结构。接口部分可加前缀，如XXX_函数名。
+```cpp
+class List {
+ public:
+  void AddElement(const Element& element);
+  Element GetElement(const unsigned int index) const;
+  bool IsEmpty() const;
+  bool MCC_GetClass();
+};
+
+namespace utils {
+void DeleteUser();
+}
+```
+
+## <a name="c2-4"></a> 类型命名
+
+类型命名采用大驼峰命名风格。
+所有类型命名——类、结构体、联合体、类型定义（typedef）、枚举——使用相同约定，例如：
+
+```cpp
+// classes, structs and unions
+class UrlTable { ...
+class UrlTableTester { ...
+struct UrlTableProperties { ...
+union Packet { ...
+
+// typedefs
+typedef std::map<std::string, UrlTableProperties*> PropertiesMap;
+
+// enums
+enum UrlTableErrors { ...
+```
+
+对于命名空间的命名，建议全小写：
+```cpp
+// namespace
+namespace osutils {
+  
+namespace fileutils {
+      
+}
+  
+}
+```
+
+
+## <a name="c2-5"></a> 变量命名
+通用变量命名采用小驼峰，包括全局变量，函数形参，局部变量，成员变量。
+```cpp
+std::string tableName;  // Good: 推荐此风格
+std::string tablename;  // Bad: 禁止此风格
+std::string path;       // Good: 只有一个单词时，小驼峰为全小写
+
+class Foo {
+ private:
+  std::string fileName;    // 不添加任何作用域前缀或者后缀
+};
+```
+
+## <a name="c2-6"></a> 宏、常量、枚举命名
+宏采用全大写，下划线连接的格式。常量、枚举值使用k+大小写混合。
+函数局部 const 常量和类的普通const成员变量，使用小驼峰命名风格。
+
+```cpp
+#define MAX(a, b)   (((a) < (b)) ? (b) : (a)) // 仅对宏命名举例，并不推荐用宏实现此类功能
+
+enum TintColor {    // 注意，枚举类型名用大驼峰，其下面的取值是k+大小写混合
+  kRed,
+  kDarkRed,
+  kGreen,
+  kLightGreen
+};
+
+int Func(...) {
+  const unsigned int bufferSize = 100;   // 函数局部常量
+  char *p = new char[bufferSize];
+  ...
+}
+
+namespace utils {
+const unsigned int kFileSize = 200;      // 全局常量
+}
+
+```
+
+# <a name="c3"></a>3 格式
+尽管有些编程的排版风格因人而异，但是我们强烈建议和要求使用统一的编码风格，以便所有人都能够轻松的阅读和理解代码，增强代码的可维护性。
+
+## <a name="c3-1"></a>行宽
+
+### <a name="a3-1-1"></a>建议3.1.1 行宽不超过 120 个字符
+建议每行字符数不要超过 120 个。如果超过120个字符，请选择合理的方式进行换行。
+
+例外:
+- 如果一行注释包含了超过120 个字符的命令或URL，则可以保持一行，以方便复制、粘贴和通过grep查找；
+- 包含长路径的 #include 语句可以超出120 个字符，但是也需要尽量避免；
+- 编译预处理中的error信息可以超出一行。
+预处理的 error 信息在一行便于阅读和理解，即使超过 120 个字符。
+
+```cpp
+#ifndef XXX_YYY_ZZZ
+#error Header aaaa/bbbb/cccc/abc.h must only be included after xxxx/yyyy/zzzz/xyz.h, because xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+#endif
+```
+
+## <a name="c3-2"></a>缩进
+
+### <a name="r3-2-1"></a>规则3.2.1 使用空格进行缩进，每次缩进2个空格
+只允许使用空格(space)进行缩进，每次缩进为 2 个空格。
+
+
+
+
+## <a name="c3-3"></a>大括号
+### <a name="r3-3-1"></a>规则3.3.1 除函数外，使用 K&R 缩进风格
+函数左大括号跟随语句放行末。
+右大括号独占一行，除非后面跟着同一语句的剩余部分，如 do 语句中的 while，或者 if 语句的 else/else if，或者逗号、分号。
+
+如：
+```cpp
+struct MyType {     // 跟随语句放行末，前置1空格
+  ...
+};
+
+int Foo(int a) {                   // 函数左大括号跟随语句放行末
+  if (...) {
+    ...
+  } else {
+    ...
+  }
+}
+```
+推荐这种风格的理由：
+
+- 代码更紧凑；
+- 相比另起一行，放行末使代码阅读节奏感上更连续；
+- 符合后来语言的习惯，符合业界主流习惯；
+- 现代集成开发环境（IDE）都具有代码缩进对齐显示的辅助功能，大括号放在行尾并不会对缩进和范围产生理解上的影响。
+
+
+对于空函数体，可以将大括号放在同一行：
+```cpp
+class MyClass {
+ public:
+  MyClass() : value(0) {}
+    
+ private:
+  int value;
+};
+```
+
+## <a name="c3-4"></a> 函数声明和定义
+
+### <a name="r3-4-1"></a>规则3.4.1 函数声明和定义的返回类型和函数名在同一行；函数参数列表超出行宽时要换行并合理对齐
+在声明和定义函数的时候，函数的返回值类型应该和函数名在同一行；如果行宽度允许，函数参数也应该放在一行；否则，函数参数应该换行，并进行合理对齐。
+参数列表的左圆括号总是和函数名在同一行，不要单独一行；右圆括号总是跟随最后一个参数。
+
+换行举例：
+```cpp
+ReturnType FunctionName(ArgType paramName1, ArgType paramName2) {  // Good：全在同一行
+  ...
+}
+
+ReturnType VeryVeryVeryLongFunctionName(ArgType paramName1,     // 行宽不满足所有参数，进行换行
+                                        ArgType paramName2,     // Good：和上一行参数对齐
+                                        ArgType paramName3) {
+  ...
+}
+
+ReturnType LongFunctionName(ArgType paramName1, ArgType paramName2, // 行宽限制，进行换行
+    ArgType paramName3, ArgType paramName4, ArgType paramName5) {     // Good: 换行后 4 空格缩进
+  ...
+}
+
+ReturnType ReallyReallyReallyReallyLongFunctionName(            // 行宽不满足第1个参数，直接换行
+    ArgType paramName1, ArgType paramName2, ArgType paramName3) { // Good: 换行后 4 空格缩进
+  ...
+}
+```
+
+## <a name="c3-5"></a>函数调用
+### <a name="r3-5-1"></a>规则3.5.1 函数调用入参列表应放在一行，超出行宽换行时，保持参数进行合理对齐
+函数调用时，函数参数列表放在一行。参数列表如果超过行宽，需要换行并进行合理的参数对齐。
+左圆括号总是跟函数名，右圆括号总是跟最后一个参数。
+
+换行举例：
+```cpp
+ReturnType result = FunctionName(paramName1, paramName2);   // Good：函数参数放在一行
+
+ReturnType result = FunctionName(paramName1,
+                                 paramName2,                // Good：保持与上方参数对齐
+                                 paramName3);
+
+ReturnType result = FunctionName(paramName1, paramName2, 
+    paramName3, paramName4, paramName5);                    // Good：参数换行，4 空格缩进
+
+ReturnType result = VeryVeryVeryLongFunctionName(           // 行宽不满足第1个参数，直接换行
+    paramName1, paramName2, paramName3);                    // 换行后，4 空格缩进
+```
+
+如果函数调用的参数存在内在关联性，按照可理解性优先于格式排版要求，对参数进行合理分组换行。
+```cpp
+// Good：每行的参数代表一组相关性较强的数据结构，放在一行便于理解
+int result = DealWithStructureLikeParams(left.x, left.y,     // 表示一组相关参数
+                                         right.x, right.y);  // 表示另外一组相关参数
+```
+
+## <a name="c3-6"></a> if语句
+
+### <a name="r3-6-1"></a>规则3.6.1 if语句必须要使用大括号
+我们要求if语句都需要使用大括号，即便只有一条语句。
+
+理由：
+- 代码逻辑直观，易读；
+- 在已有条件语句代码上增加新代码时不容易出错；
+- 对于在if语句中使用函数式宏时，有大括号保护不易出错（如果宏定义时遗漏了大括号）。
+
+```cpp
+if (objectIsNotExist) {         // Good：单行条件语句也加大括号
+  return CreateNewObject();
+}
+```
+### <a name="r3-6-2"></a>规则3.6.2 禁止 if/else/else if 写在同一行
+条件语句中，若有多个分支，应该写在不同行。
+
+如下是正确的写法：
+
+```cpp
+if (someConditions) { 
+  DoSomething();
+  ...
+} else {  // Good: else 与 if 在不同行
+  ...
+}
+```
+
+下面是不符合规范的案例：
+
+```cpp
+if (someConditions) { ... } else { ... } // Bad: else 与 if 在同一行
+```
+
+## <a name="c3-7"></a> 循环语句
+### <a name="r3-7-1"></a>规则3.7.1 循环语句要求使用大括号
+和if语句类似，我们要求for/while循环语句必须加上的大括号，即使循环体是空的，或者循环语句只有一条。
+
+```cpp
+for (int i = 0; i < someRange; i++) {
+  DoSomething();
+}
+```
+
+如果循环体是空的，应该使用空的大括号，而不是使用单个分号。 单个分号容易被遗漏，也容易被误认为是循环语句中的一部分。
+
+```cpp
+for (int i = 0; i < someRange; i++) { } // Good： for循环体是空，使用大括号，而不是使用分号
+
+while (someCondition) { }  // Good：while循环体是空，使用大括号，而不是使用分号
+
+while (someCondition) {
+  continue;  // Good：continue表示空逻辑，可以使用大括号也可以不使用
+}
+
+```
+
+坏的例子：
+```cpp
+for (int i = 0; i < someRange; i++) ;   // Bad： for循环体是空，也不要只使用分号，要使用大括号
+
+while (someCondition) ; // Bad：使用分号容易让人误解是while语句中的一部分
+```
+
+## <a name="c3-8"></a> switch语句
+### <a name="r3-8-1"></a>规则3.8.1 switch 语句的 case/default 要缩进一层
+switch 语句的缩进风格如下：
+```cpp
+switch (var) {
+  case 0:             // Good: 缩进
+    DoSomething1();   // Good: 缩进
+    break;
+  case 1: {           // Good: 带大括号格式
+    DoSomething2();
+    break;
+  }
+  default:
+    break;
+}
+```
+
+```cpp
+switch (var) {
+case 0:                 // Bad: case 未缩进
+  DoSomething();
+  break;
+default:                // Bad: default 未缩进
+  break;
+}
+```
+
+## <a name="c3-9"></a> 表达式
+
+### <a name="a3-9-1"></a>建议3.9.1 表达式换行要保持换行的一致性
+较长的表达式，不满足行宽要求的时候，需要在适当的地方换行。
+例：
+
+// 假设下面第一行已经不满足行宽要求
+```cpp
+if (currentValue > threshold &&  
+    someConditionsion) {
+  DoSomething();
+  ...
+}
+
+int result = reallyReallyLongVariableName1 +    // Good
+             reallyReallyLongVariableName2;
+```
+表达式换行后，注意保持合理对齐，或者4空格缩进。参考下面例子
+
+```cpp
+int sum = longVaribleName1 + longVaribleName2 + longVaribleName3 +
+    longVaribleName4 + longVaribleName5 + longVaribleName6;         // Good: 4空格缩进
+
+int sum = longVaribleName1 + longVaribleName2 + longVaribleName3 +
+          longVaribleName4 + longVaribleName5 + longVaribleName6;   // Good: 保持对齐
+```
+## <a name="c3-10"></a> 变量赋值
+
+### <a name="r3-10-1"></a>规则3.10.1 多个变量定义和赋值语句不允许写在一行
+每行只有一个变量初始化的语句，更容易阅读和理解。
+
+```cpp
+int maxCount = 10;
+bool isCompleted = false;
+```
+
+下面是不符合规范的示例：
+
+```cpp
+int maxCount = 10; bool isCompleted = false; // Bad：多个变量初始化需要分开放在多行，每行一个变量初始化
+int x, y = 0;  // Bad：多个变量定义需要分行，每行一个
+
+int pointX;
+int pointY;
+...
+pointX = 1; pointY = 2;  // Bad：多个变量赋值语句放同一行
+```
+例外：for 循环头、if 初始化语句（C++17）、结构化绑定语句（C++17）中可以声明和初始化多个变量。这些语句中的多个变量声明有较强关联，如果强行分成多行会带来作用域不一致，声明和初始化割裂等问题。
+
+## <a name="c3-11"></a> 初始化
+初始化包括结构体、联合体、及数组的初始化
+
+### <a name="r3-11-1"></a>规则3.11.1 初始化换行时要有缩进，并进行合理对齐
+结构体或数组初始化时，如果换行应保持4空格缩进。
+从可读性角度出发，选择换行点和对齐位置。
+
+```cpp
+const int rank[] = {
+    16, 16, 16, 16, 32, 32, 32, 32,
+    64, 64, 64, 64, 32, 32, 32, 32
+};
+```
+
+## <a name="c3-12"></a> 指针与引用
+### <a name="a3-12-1"></a>建议3.12.1  指针类型"* "跟随变量名或者类型，不要两边都留有或者都没有空格
+
+指针命名: * 靠左靠右都可以，但是不要两边都有或者都没有空格。
+
+```cpp
+int* p = NULL; // Good
+int *p = NULL; // Good
+int*p = NULL; // Bad
+int * p = NULL; // Bad
+```
+
+例外：当变量被 const 修饰时，"`*`" 无法跟随变量，此时也不要跟随类型。
+```cpp
+char * const VERSION = "V100";
+```
+
+例外：对于如` static_cast<char*>(somePointer)/(char*)/vector<char*> `中的场景，*与类型之间不加空格。
+
+### <a name="a3-12-2"></a>建议3.12.2  引用类型"& "跟随变量名或者类型，不要两边都留有或者都没有空格
+
+引用命名： & 靠左靠右都可以，但是不要两边都有或者都没有空格。
+
+```cpp
+int i = 8;
+int& p = i; // Good
+int &p = i; // Good
+int & p = i; // Bad
+int&p = i; // Bad
+```
+
+
+## <a name="c3-13"></a> 编译预处理
+### <a name="r3-13-1"></a>规则3.13.1 编译预处理的"#"统一放在行首，嵌套编译预处理语句时，"#"不缩进
+编译预处理的"#"统一放在行首，即使编译预处理的代码是嵌入在函数体中的，"#"也应该放在行首。
+
+```cpp
+#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) // Good："#"放在行首
+#define ATOMIC_X86_HAS_CMPXCHG16B 1  // Good："#"放在行首
+#else
+#define ATOMIC_X86_HAS_CMPXCHG16B 0
+#endif 
+
+
+int FunctionName() {
+  if (someThingError) {
+    ...
+#ifdef HAS_SYSLOG        // Good：即便在函数内部，"#"也放在行首
+    WriteToSysLog();
+#else
+    WriteToFileLog();
+#endif
+  }
+}
+```
+内嵌的预处理语句"#"不缩进
+
+```cpp
+#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define ATOMIC_X86_HAS_CMPXCHG16B 1  // Good：区分层次，便于阅读
+#else
+#define ATOMIC_X86_HAS_CMPXCHG16B 0
+#endif
+```
+
+## <a name="c3-14"></a> 空格和空行
+### <a name="r3-14-1"></a>建议3.14.1 水平空格应该突出关键字和重要信息，避免不必要的留白
+水平空格应该突出关键字和重要信息，每行代码尾部不要加空格。总体规则如下：
+
+- if, switch, case, do, while, for等关键字之后加空格；
+- 小括号内部的两侧，不要加空格；
+- 大括号内部两侧有无空格，左右必须保持一致；
+- 一元操作符（& * + ‐ ~ !）之后不要加空格；
+- 二元操作符（= + ‐ < > * / % | & ^ <= >= == != ）左右两侧加空格
+- 三目运算符（? :）符号两侧均需要空格
+- 前置和后置的自增、自减（++ --）和变量之间不加空格
+- 结构体成员操作符（. ->）前后不加空格
+- 逗号(,)前面不加空格，后面增加空格
+- 对于模板和类型转换(<>)和类型之间不要添加空格
+- 域操作符(::)前后不要添加空格
+- 冒号(:)前后根据情况来判断是否要添加空格
+
+常规情况：
+```cpp
+void Foo(int b) {  // Good：大括号前应该留空格
+
+int i = 0;  // Good：变量初始化时，=前后应该有空格，分号前面不要留空格
+
+int buf[kBufSize] = {0};    // Good：大括号内两侧都无空格
+```
+
+函数定义和函数调用：
+```cpp
+int result = Foo(arg1,arg2);
+                    ^    // Bad: 逗号后面需要增加空格
+
+int result = Foo( arg1, arg2 );
+                 ^          ^  // Bad: 函数参数列表的左括号后面不应该有空格，右括号前面不应该有空格
+```
+
+指针和取地址
+```cpp
+x = *p;     // Good：*操作符和指针p之间不加空格
+p = &x;     // Good：&操作符和变量x之间不加空格
+x = r.y;    // Good：通过.访问成员变量时不加空格
+x = r->y;   // Good：通过->访问成员变量时不加空格
+```
+
+操作符：
+```cpp
+x = 0；   // Good：赋值操作的=前后都要加空格
+x = -5；  // Good：负数的符号和数值之前不要加空格
+++x；     // Good：前置和后置的++/--和变量之间不要加空格
+x--；
+
+if (x && !y)  // Good：布尔操作符前后要加上空格，！操作和变量之间不要空格
+v = w * x + y / z;  // Good：二元操作符前后要加空格
+v = w * (x + z);    // Good：括号内的表达式前后不需要加空格
+
+int a = (x < y) ? x : y;  // Good: 三目运算符， ？和：前后需要添加空格
+```
+
+循环和条件语句：
+```cpp
+if (condition) {  // Good：if关键字和括号之间加空格，括号内条件语句前后不加空格
+  ...
+} else {           // Good：else关键字和大括号之间加空格
+  ...
+}
+
+while (condition) {}   // Good：while关键字和括号之间加空格，括号内条件语句前后不加空格
+
+for (int i = 0; i < someRange; ++i) {  // Good：for关键字和括号之间加空格，分号之后加空格
+  ...
+}
+
+switch (condition) {  // Good: switch 关键字后面有1空格
+  case 0:     // Good：case语句条件和冒号之间不加空格
+    ...
+    break;
+    ...
+  default:
+    ...
+    break;
+}
+```
+
+模板和转换
+```cpp
+// 尖括号(< and >) 不与空格紧邻, < 前没有空格, > 和 ( 之间也没有.
+vector<string> x;
+y = static_cast<char*>(x);
+
+// 在类型与指针操作符之间留空格也可以, 但要保持一致.
+vector<char *> x;
+```
+
+域操作符
+```cpp
+std::cout;    // Good: 命名空间访问，不要留空格
+
+int MyClass::GetValue() const {}  // Good: 对于成员函数定义，不要留空格
+```
+
+冒号
+```cpp
+// 添加空格的场景
+
+// Good: 类的派生需要留有空格
+class Sub : public Base {
+    
+};
+
+// 构造函数初始化列表需要留有空格
+MyClass::MyClass(int var) : someVar(var) {
+  DoSomething();
+}
+
+// 位域表示也留有空格
+struct XX {
+  char a : 4;     
+  char b : 5;     
+  char c : 4;
+};
+```
+
+```cpp
+// 不添加空格的场景
+
+// Good: 对于public:, private:这种类访问权限的冒号不用添加空格
+class MyClass {
+ public:
+  MyClass(int var);
+ private:
+  int someVar;
+};
+
+// 对于switch-case的case和default后面的冒号不用添加空格
+switch (value) {
+  case 1:
+    DoSomething();
+    break;
+  default:
+    break;
+}
+```
+
+注意：当前的集成开发环境（IDE）可以设置删除行尾的空格，请正确配置。
+
+### <a name="a3-14-2"></a>建议3.14.2 合理安排空行，保持代码紧凑
+
+减少不必要的空行，可以显示更多的代码，方便代码阅读。下面有一些建议遵守的规则：
+- 根据上下内容的相关程度，合理安排空行；
+- 函数内部、类型定义内部、宏内部、初始化表达式内部，不使用连续空行
+- 不使用连续 **3** 个空行，或更多
+- 大括号内的代码块行首之前和行尾之后不要加空行。
+
+```cpp
+int Foo() {
+  ...
+}
+
+
+// Bad：两个函数定义间超过了一个空行
+int Bar() {
+  ...
+}
+
+
+if (...) {
+        // Bad：大括号内的代码块行首不要加入空行
+  ...
+        // Bad：大括号内的代码块行尾不要加入空行
+}
+
+int Foo(...) {
+        // Bad：函数体内行首不要加空行
+  ...
+}
+```
+
+## <a name="c3-15"></a> 类
+### <a name="r3-15-1"></a>规则3.15.1 类访问控制块的声明依次序是 public:, protected:, private:，每个都缩进 1 个空格
+```cpp
+class MyClass : public BaseClass {
+ public:      // 1空格缩进
+  MyClass();  // 标准的2空格缩进
+  explicit MyClass(int var);
+  ~MyClass() {}
+
+  void SomeFunction();
+  void SomeFunctionThatDoesNothing() {
+  }
+
+  void SetVar(int var) { 
+    someVar = var; 
+  }
+  
+  int GetVar() const { 
+    return someVar; 
+  }
+
+ private:
+  bool SomeInternalFunction();
+
+  int someVar;
+  int someOtherVar;
+};
+```
+
+在各个部分中，建议将类似的声明放在一起, 并且建议以如下的顺序: 类型 (包括 typedef, using 和嵌套的结构体与类), 常量, 工厂函数, 构造函数, 赋值运算符, 析构函数, 其它成员函数, 数据成员。
+
+
+### <a name="r3-15-2"></a>规则3.15.2 构造函数初始化列表放在同一行或按四格缩进并排多行
+```cpp
+// 如果所有变量能放在同一行:
+MyClass::MyClass(int var) : someVar(var) {
+  DoSomething();
+}
+
+// 如果不能放在同一行,
+// 必须置于冒号后, 并缩进4个空格
+MyClass::MyClass(int var)
+    : someVar(var), someOtherVar(var + 1) { // Good: 逗号后面留有空格
+  DoSomething();
+}
+
+// 如果初始化列表需要置于多行, 需要逐行对齐
+MyClass::MyClass(int var)
+    : someVar(var),             // 缩进4个空格
+      someOtherVar(var + 1) {  
+  DoSomething();
+}
+```
+
+# <a name="c4"></a>4 注释
+一般的，尽量通过清晰的架构逻辑，好的符号命名来提高代码可读性；需要的时候，才辅以注释说明。
+注释是为了帮助阅读者快速读懂代码，所以要从读者的角度出发，__按需注释__。
+
+注释内容要简洁、明了、无二义性，信息全面且不冗余。
+
+__注释跟代码一样重要。__
+写注释时要换位思考，用注释去表达此时读者真正需要的信息。在代码的功能、意图层次上进行注释，即注释解释代码难以表达的意图，不要重复代码信息。
+修改代码时，也要保证其相关注释的一致性。只改代码，不改注释是一种不文明行为，破坏了代码与注释的一致性，让阅读者迷惑、费解，甚至误解。
+
+## <a name="c4-1"></a> 注释风格
+在 C++ 代码中，使用` /* */`和` // `都是可以的。
+按注释的目的和位置，注释可分为不同的类型，如文件头注释、函数头注释、代码注释等等；
+同一类型的注释应该保持统一的风格，建议：
+1）文件头注释使用` /* */ `。
+2）同一文件内函数头注释、代码注释要使用相同的注释符，不可混用。
+
+注意：__本文示例代码中，大量使用 '//' 后置注释只是为了更精确的描述问题，并不代表这种注释风格更好。__
+
+## <a name="c4-2"></a>  文件头注释
+### <a name="r4-2-1"></a>规则4.2.1 文件头注释必须包含版权许可
+```cpp
+/*
+ * Copyright (c) [2019] [name of copyright holder]
+ * [Software Name] is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *   http://license.coscl.org.cn/MulanPSL
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+```
+
+
+
+## <a name="c4-3"></a> 函数头注释
+### <a name="r4-3-1"></a>规则4.3.1 禁止空有格式的函数头注释
+并不是所有的函数都需要函数头注释；
+函数签名无法表达的信息，加函数头注释辅助说明;
+
+函数头注释统一放在函数声明或定义上方，使用如下风格之一：
+使用`//`写函数头
+
+```cpp
+// 单行函数头
+int Func1(void);
+
+// 多行函数头
+// 第二行
+int Func2(void);
+```
+
+使用`/*   */`写函数头
+```cpp
+/* 单行函数头 */
+int Func1(void);
+
+/*
+ * 另一种单行函数头
+ */
+int Func2(void);
+
+/*
+ * 多行函数头
+ * 第二行
+ */
+int Func3(void);
+```
+函数尽量通过函数名自注释，按需写函数头注释。
+不要写无用、信息冗余的函数头；不要写空有格式的函数头。
+
+函数头注释内容可选，但不限于：功能说明、返回值，性能约束、用法、内存约定、算法实现、可重入的要求等等。
+模块对外头文件中的函数接口声明，其函数头注释，应当将重要、有用的信息表达清楚。
+
+例：
+
+```cpp
+/*
+ * 返回实际写入的字节数，-1表示写入失败
+ * 注意，内存 buf 由调用者负责释放
+ */
+int WriteString(const char *buf, int len);
+```
+
+坏的例子：
+```cpp
+/*
+ * 函数名：WriteString
+ * 功能：写入字符串
+ * 参数：
+ * 返回值：
+ */
+int WriteString(const char *buf, int len);
+```
+上面例子中的问题：
+
+- 参数、返回值，空有格式没内容
+- 函数名信息冗余
+- 关键的 buf 由谁释放没有说清楚
+
+## <a name="c4-4"></a> 代码注释
+### <a name="r4-4-1"></a>规则4.4.1 代码注释放于对应代码的上方或右边
+### <a name="r4-4-2"></a>规则4.4.2 注释符与注释内容间要有1空格；右置注释与前面代码至少1空格
+代码上方的注释，应该保持对应代码一样的缩进。
+选择并统一使用如下风格之一：
+使用`//`
+```cpp
+
+// 这是单行注释
+DoSomething();
+
+// 这是多行注释
+// 第二行
+DoSomething();
+```
+
+使用`/*' '*/`
+```cpp
+/* 这是单行注释 */
+DoSomething();
+
+/*
+ * 另一种方式的多行注释
+ * 第二行
+ */
+DoSomething();
+```
+代码右边的注释，与代码之间，至少留1空格，建议不超过4空格。
+通常使用扩展后的 TAB 键即可实现 1-4 空格的缩进。
+
+选择并统一使用如下风格之一：
+
+```cpp
+int foo = 100;  // 放右边的注释
+int bar = 200;  /* 放右边的注释 */
+```
+右置格式在适当的时候，上下对齐会更美观。
+对齐后的注释，离左边代码最近的那一行，保证1-4空格的间隔。
+例：
+
+```cpp
+const int kConst = 100;          /* 相关的同类注释，可以考虑上下对齐 */
+const int kAnotherConst = 200;   /* 上下对齐时，与左侧代码保持间隔*/
+```
+当右置的注释超过行宽时，请考虑将注释置于代码上方。
+
+### <a name="r4-4-3"></a>规则4.4.3 不用的代码段直接删除，不要注释掉
+被注释掉的代码，无法被正常维护；当企图恢复使用这段代码时，极有可能引入易被忽略的缺陷。
+正确的做法是，不需要的代码直接删除掉。若再需要时，考虑移植或重写这段代码。
+
+这里说的注释掉代码，包括用 /* */ 和 //，还包括 #if 0， #ifdef NEVER_DEFINED 等等。
+
+### <a name="a4-4-1"></a>建议4.4.1 代码尽量不要包含 TODO/TBD/FIXME 注释
+TODO/TBD 注释一般用来描述已知待改进、待补充的修改点
+FIXME 注释一般用来描述已知缺陷
+它们都应该有统一风格，方便文本搜索统一处理。如：
+
+```cpp
+// TODO(<author-name>): 补充XX处理
+// FIXME: XX缺陷
+```
+
+
+# <a name="c5"></a>5 头文件
+## <a name="c5-1"></a> 头文件职责
+头文件是模块或文件的对外接口，头文件的设计体现了大部分的系统设计。
+头文件中适合放置接口的声明，不适合放置实现（内联函数除外）。对于cpp文件中内部才需要使用的函数、宏、枚举、结构定义等不要放在头文件中。
+头文件应当职责单一。头文件过于复杂，依赖过于复杂还是导致编译时间过长的主要原因。
+
+### <a name="a5-1-1"></a>建议5.1.1 每一个.cpp文件应有一个对应的.h文件，用于声明需要对外公开的类与接口
+通常情况下，每个.cpp文件都有一个相应的.h，用于放置对外提供的函数声明、宏定义、类型定义等。另外，可根据实际情况添加对应的.inline.h文件优化代码。
+如果一个.cpp文件不需要对外公布任何接口，则其就不应当存在。
+例外：__程序的入口（如main函数所在的文件），单元测试代码，动态库代码。__
+
+示例:
+```cpp
+// Foo.h 
+
+#ifndef FOO_H
+#define FOO_H
+
+class Foo {
+ public:
+  Foo();
+  void Fun();
+    
+ private:
+  int value;
+};
+
+#endif
+```
+
+```cpp
+// Foo.cpp
+#include "Foo.h"
+
+namespace { // Good: 对内函数的声明放在.cpp文件的头部，并声明为匿名namespace或者static限制其作用域
+void Bar() {
+}
+}
+
+...
+
+void Foo::Fun() {
+  Bar();
+}
+```
+
+## <a name="c5-2"></a> 头文件依赖
+### <a name="r5-2-1"></a>规则5.2.1 禁止头文件循环依赖
+头文件循环依赖，指 a.h 包含 b.h，b.h 包含 c.h，c.h 包含 a.h， 导致任何一个头文件修改，都导致所有包含了a.h/b.h/c.h的代码全部重新编译一遍。  
+而如果是单向依赖，如a.h包含b.h，b.h包含c.h，而c.h不包含任何头文件，则修改a.h不会导致包含了b.h/c.h的源代码重新编译。
+
+头文件循环依赖直接体现了架构设计上的不合理，可通过优化架构去避免。
+
+### <a name="r5-2-2"></a>规则5.2.2 禁止包含用不到的头文件
+用不到的头文件被包含的同时引入了不必要的依赖，增加了模块或单元之间的耦合度，只要该头文件被修改，代码就要重新编译。
+
+很多系统中头文件包含关系复杂，开发人员为了省事起见，直接包含一切想到的头文件，甚至发布了一个god.h，其中包含了所有头文件，然后发布给各个项目组使用，这种只图一时省事的做法，导致整个系统的编译时间进一步恶化，并对后来人的维护造成了巨大的麻烦。
+
+### <a name="r5-2-3"></a>规则5.2.3 头文件应当自包含
+简单的说，自包含就是任意一个头文件均可独立编译。如果一个文件包含某个头文件，还要包含另外一个头文件才能工作的话，给这个头文件的用户增添不必要的负担。
+
+示例：
+如果a.h不是自包含的，需要包含b.h才能编译，会带来的危害：
+每个使用a.h头文件的.cpp文件，为了让引入的a.h的内容编译通过，都要包含额外的头文件b.h。
+额外的头文件b.h必须在a.h之前进行包含，这在包含顺序上产生了依赖。
+
+
+### <a name="r5-2-4"></a>规则5.2.4 头文件必须编写`#define`保护，防止重复包含
+为防止头文件被重复包含，所有头文件都应当使用 #define 保护；不要使用 #pragma once
+
+定义包含保护符时，应该遵守如下规则：
+1）保护符使用唯一名称；
+2）不要在受保护部分的前后放置代码或者注释，文件头注释除外。
+
+示例：假定VOS工程的timer模块的timer.h，其目录为VOS/include/timer/Timer.h,应按如下方式保护：
+
+```cpp
+#ifndef VOS_INCLUDE_TIMER_TIMER_H
+#define VOS_INCLUDE_TIMER_TIMER_H
+...
+#endif
+```
+
+也可以不用像上面添加路径，但是要保证当前工程内宏是唯一的。
+```cpp
+#ifndef TIMER_H
+#define TIMER_H
+...
+#endif
+```
+
+### <a name="r5-2-1"></a>建议5.2.1 禁止通过声明的方式引用外部函数接口、变量
+只能通过包含头文件的方式使用其他模块或文件提供的接口。
+通过 extern 声明的方式使用外部函数接口、变量，容易在外部接口改变时可能导致声明和定义不一致。
+同时这种隐式依赖，容易导致架构腐化。
+
+不符合规范的案例：
+
+// a.cpp内容
+```cpp
+extern int Fun();   // Bad: 通过extern的方式使用外部函数
+
+void Bar() {
+  int i = Fun();
+  ...
+}
+```
+
+// b.cpp内容
+```cpp
+int Fun() {
+  // Do something
+}
+```
+应该改为：
+
+// a.cpp内容
+```cpp
+#include "b.h"   // Good: 通过包含头文件的方式使用其他.cpp提供的接口
+
+void Bar() {
+  int i = Fun();
+  ...
+}
+```
+
+// b.h内容
+```cpp
+int Fun();
+```
+
+// b.cpp内容
+```cpp
+int Fun() {
+  // Do something
+}
+```
+例外，有些场景需要引用其内部函数，但并不想侵入代码时，可以 extern 声明方式引用。
+如：
+针对某一内部函数进行单元测试时，可以通过 extern 声明来引用被测函数；
+当需要对某一函数进行打桩、打补丁处理时，允许 extern 声明该函数。
+
+### <a name="r5-2-5"></a>规则5.2.5 禁止在extern "C"中包含头文件
+在 extern "C" 中包含头文件，有可能会导致 extern "C" 嵌套，部分编译器对 extern "C" 嵌套层次有限制，嵌套层次太多会编译错误。
+
+在C，C++混合编程的情况下，在extern "C"中包含头文件，可能会导致被包含头文件的原有意图遭到破坏，比如链接规范被不正确地更改。
+
+示例，存在a.h和b.h两个头文件：
+
+// a.h内容
+```cpp
+...
+#ifdef __cplusplus
+void Foo(int);
+#define A(value) Foo(value)
+#else
+void A(int)
+#endif
+```
+// b.h内容
+```cpp
+...
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "a.h"
+void B();
+
+#ifdef __cplusplus
+}
+#endif
+```
+
+使用C++预处理器展开b.h，将会得到
+```cpp
+extern "C" {
+  void Foo(int);
+  void B();
+}
+```
+
+按照 a.h 作者的本意，函数 Foo 是一个 C++ 自由函数，其链接规范为 "C++"。
+但在 b.h 中，由于 `#include "a.h"` 被放到了 `extern "C"` 的内部，函数 Foo 的链接规范被不正确地更改了。
+
+例外：
+如果在 C++ 编译环境中，想引用纯C的头文件，这些C头文件并没有` extern "C"` 修饰。非侵入式的做法是，在 `extern "C"` 中去包含C头文件。
+
+### <a name="a5-2-2"></a>建议5.2.2尽量避免使用前置声明，而是通过`#include`来包含头文件
+前置声明（forward declaration）是类、函数和模板的纯粹声明，没伴随着其定义。
+
+- 优点：
+  1. 前置声明能够节省编译时间，多余的 #include 会迫使编译器展开更多的文件，处理更多的输入。
+  2. 前置声明能够节省不必要的重新编译的时间。 #include 使代码因为头文件中无关的改动而被重新编译多次。
+- 缺点：
+  1. 前置声明隐藏了依赖关系，头文件改动时，用户的代码会跳过必要的重新编译过程。
+  2. 前置声明可能会被库的后续更改所破坏。前置声明函数或模板有时会妨碍头文件开发者变动其 API. 例如扩大形参类型，加个自带默认参数的模板形参等等。
+  3. 前置声明来自命名空间` std::` 的 symbol 时，其行为未定义（在C++11标准规范中明确说明）。
+  4. 前置声明了不少来自头文件的 symbol 时，就会比单单一行的 include 冗长。
+  5. 仅仅为了能前置声明而重构代码（比如用指针成员代替对象成员）会使代码变得更慢更复杂。
+  6. 很难判断什么时候该用前置声明，什么时候该用`#include`，某些场景下面前置声明和`#include`互换以后会导致意想不到的结果。
+
+所以我们尽可能避免使用前置声明，而是使用#include头文件来保证依赖关系。
+
+### <a name="a5-2-3"></a>建议5.2.3 头文件包含顺序：首先是.cpp相应的.h文件，其它头文件按照稳定度排序
+使用标准的头文件包含顺序可增强可读性, 避免隐藏依赖，建议按照稳定度排序：cpp对应的头文件, C/C++标准库, 系统库的.h, 其他库的.h, 本项目内其他的.h。
+
+举例，Foo.cpp中包含头文件的次序如下:
+```cpp
+#include "Foo/Foo.h"
+
+#include <cstdlib>
+#include <string>
+
+#include <linux/list.h>
+#include <linux/time.h>
+
+#include "platform/Base.h"
+#include "platform/Framework.h"
+
+#include "project/public/Log.h"
+```
+将Foo.h放在最前面可以保证当Foo.h遗漏某些必要的库，或者有错误时，Foo.cpp的构建会立刻中止，减少编译时间。 对于头文件中包含顺序也参照此建议。
+
+例外：
+平台特定代码需要条件编译，这些代码可以放到其它 includes 之后。
+```cpp
+#include "foo/public/FooServer.h"
+
+#include "base/Port.h"  // For LANG_CXX11.
+
+#ifdef LANG_CXX11
+#include <initializer_list>
+#endif  // LANG_CXX11
+```
+
+# <a name="c6"></a>6 作用域
+
+## <a name="c6-1"></a> 命名空间
+命名空间里的内容不缩进。
+
+### <a name="a6-1-1"></a>建议6.1.1 对于cpp文件中不需要导出的变量，常量或者函数，请使用匿名namespace封装或者用static修饰
+在C++ 2003标准规范中，使用static修饰文件作用域的变量，函数等被标记为deprecated特性，所以更推荐使用匿名namespace。
+
+主要原因如下：
+1. static在C++中已经赋予了太多的含义，静态函数成员变量，静态成员函数，静态全局变量，静态函数局部变量，每一种都有特殊的处理。
+2. static只能保证变量，常量和函数的文件作用域，但是namespace还可以封装类型等。
+3. 统一namespace来处理C++的作用域，而不需要同时使用static和namespace来管理。
+4. static修饰的函数不能用来实例化模板，而匿名namespace可以。
+
+但是不要在 .h 中使用中使用匿名namespace或者static。
+
+```cpp
+// Foo.cpp
+
+namespace {
+const int kMaxCount = 20;
+void InternalFun(){};
+}
+
+void Foo::Fun() {
+  int i = kMaxCount;
+    
+  InternalFun();
+}
+
+```
+
+### <a name="r6-1-1"></a>规则6.1.1 不要在头文件中或者#include之前使用using导入命名空间
+说明：使用using导入命名空间会影响后续代码，易造成符号冲突，所以不要在头文件以及源文件中的#include之前使用using导入命名空间。
+示例：
+
+```cpp
+// 头文件a.h
+namespace namespacea {
+int Fun(int);
+}
+```
+
+```cpp
+// 头文件b.h
+namespace namespaceb {
+int Fun(int);
+}
+
+using namespace namespaceb;
+
+void G() {
+  Fun(1); 
+}
+```
+
+```cpp
+// 源代码a.cpp
+#include "a.h"
+using namespace namespacea; 
+#include "b.h"
+
+void main() {
+  G(); // using namespace namespacea在#include “b.h”之前，引发歧义：namespacea::Fun，namespaceb::Fun调用不明确
+}
+```
+
+对于在头文件中使用using导入单个符号或定义别名，允许在模块自定义名字空间中使用，但禁止在全局名字空间中使用。
+```cpp
+// foo.h
+
+#include <fancy/string>
+using fancy::string;  // Bad，禁止向全局名字空间导入符号
+
+namespace foo {
+using fancy::string;  // Good，可以在模块自定义名字空间中导入符号
+using MyVector = fancy::vector<int>;  // Good，C++11可在自定义名字空间中定义别名
+}
+```
+
+
+### <a name="r6-1-2"></a>规则6.1.2 禁止using namespace std;
+说明：使用std前缀让代码更清楚，并且可以防止名字冲突。
+
+
+## <a name="c6-2"></a> 全局函数和静态成员函数
+
+### <a name="a6-2-1"></a>建议6.2.1 优先使用命名空间来管理全局函数，如果和某个class有直接关系的，可以使用静态成员函数
+说明：非成员函数放在名字空间内可避免污染全局作用域， 也不要用类+静态成员方法来简单管理全局函数。 如果某个全局函数和某个类有紧密联系， 那么可以作为类的静态成员函数。
+
+如果你需要定义一些全局函数，给某个cpp文件使用，那么请使用匿名namespace来管理。
+```cpp
+namespace mynamespace {
+int Add(int a, int b);
+}
+
+class File {
+ public:
+  static File CreateTempFile(const std::string& fileName);
+};
+```
+
+## <a name="c6-3"></a> 全局常量和静态成员常量
+
+### <a name="a6-3-1"></a>建议6.3.1 优先使用命名空间来管理全局常量，如果和某个class有直接关系的，可以使用静态成员常量
+说明：全局常量放在命名空间内可避免污染全局作用域， 也不要用类+静态成员常量来简单管理全局常量。 如果某个全局常量和某个类有紧密联系， 那么可以作为类的静态成员常量。
+
+如果你需要定义一些全局常量，只给某个cpp文件使用，那么请使用匿名namespace来管理。
+```cpp
+namespace mynamespace {
+const int kMaxSize = 100;
+}
+
+class File {
+ public:
+  static const std::string kName;
+};
+```
+
+## <a name="c6-4"></a> 全局变量
+
+### <a name="a6-4-1"></a>建议6.4.1 尽量避免使用全局变量，考虑使用单例模式
+说明：全局变量是可以修改和读取的，那么这样会导致业务代码和这个全局变量产生数据耦合。
+```cpp
+int counter = 0;
+
+// a.cpp
+counter++;
+
+// b.cpp
+counter++;
+
+// c.cpp
+cout << counter << endl;
+```
+
+使用单实例模式
+```cpp
+class Counter {
+ public:
+  static Counter& GetInstance() {
+    static Counter counter;
+    return counter;
+  }  // 单实例实现简单举例
+    
+  void Increase() {
+    value++;
+  }
+    
+  void Print() const {
+    std::cout << value << std::endl;
+  }
+
+ private:
+  Counter() : value(0) {}
+
+ private:
+  int value;
+};
+
+// a.cpp
+Counter::GetInstance().Increase();
+
+// b.cpp
+Counter::GetInstance().Increase();
+
+// c.cpp
+Counter::GetInstance().Print();
+```
+
+实现单例模式以后，实现了全局唯一一个实例，和全局变量同样的效果，并且单实例提供了更好的封装性。
+
+例外：有的时候全局变量的作用域仅仅是模块内部，这样进程空间里面就会有多个全局变量实例，每个模块持有一份，这种场景下是无法使用单例模式解决的。
+
+# <a name="c7"></a>7 类
+
+如果仅有数据成员，使用结构体，其他使用类
+
+## <a name="c7-1"></a> 构造，拷贝构造，赋值和析构函数
+构造，拷贝，移动和析构函数提供了对象的生命周期管理方法：
+- 构造函数（constructor）： `X()`
+- 拷贝构造函数（copy constructor）：`X(const X&)`
+- 拷贝赋值操作符（copy assignment）：`operator=(const X&)`   
+- 移动构造函数（move constructor）：`X(X&&)`         *C++11以后提供*
+- 移动赋值操作符（move assignment）：`operator=(X&&)`       *C++11以后提供*
+- 析构函数（destructor）：`~X()`
+
+### <a name="r7-1-1"></a>规则7.1.1 类的成员变量必须显式初始化
+说明：如果类有成员变量，没有定义构造函数，又没有定义默认构造函数，编译器将自动生成一个构造函数，但编译器生成的构造函数并不会对成员变量进行初始化，对象状态处于一种不确定性。
+
+例外：
+- 如果类的成员变量具有默认构造函数，那么可以不需要显式初始化。
+
+示例：如下代码没有构造函数，私有数据成员无法初始化：
+```cpp
+class Message {
+ public:
+  void ProcessOutMsg() {
+    //…
+  }
+ private:
+  unsigned int msgID;
+  unsigned int msgLength; 
+  unsigned char* msgBuffer;
+  std::string someIdentifier;
+};
+
+Message message;   // message成员变量没有初始化
+message.ProcessOutMsg();   // 后续使用存在隐患
+
+// 因此，有必要定义默认构造函数，如下：
+class Message {
+ public:
+  Message() : msgID(0), msgLength(0) {
+  }
+    
+  void ProcessOutMsg() {
+    // …
+  }
+    
+ private:
+  unsigned int msgID;
+  unsigned int msgLength; 
+  unsigned char* msgBuffer;
+  std::string someIdentifier; //具有默认构造函数，不需要显式初始化
+};
+```
+
+### <a name="a7-1-1"></a>建议7.1.1 成员变量优先使用声明时初始化（C++11）和构造函数初始化列表初始化
+说明：C++11的声明时初始化可以一目了然的看出成员初始值，应当优先使用。如果成员初始化值和构造函数相关，或者不支持C++11，则应当优先使用构造函数初始化列表来初始化成员。相比起在构造函数体中对成员赋值，初始化列表的代码更简洁，执行性能更好，而且可以对const成员和引用成员初始化。
+
+```cpp
+class Message {
+ public:
+  Message() : msgLength(0) {  // Good，优先使用初始化列表
+    msgBuffer = NULL;     // Bad，不推荐在构造函数中赋值
+  }
+    
+ private:
+  unsigned int msgID{0};  // Good，C++11中使用
+  unsigned int msgLength;
+  unsigned char* msgBuffer;
+};
+```
+
+### <a name="r7-1-2"></a>规则7.1.2 为避免隐式转换，将单参数构造函数声明为explicit
+说明：单参数构造函数如果没有用explicit声明，则会成为隐式转换函数。
+示例：
+
+```cpp
+class Foo {
+ public:
+  explicit Foo(const string& name): name(name) {
+  }
+ private:
+  string name;
+};
+
+
+void ProcessFoo(const Foo& foo){}
+
+int main(void) {
+  std::string test = "test";
+  ProcessFoo(test);  // 编译不通过
+  return 0;
+}
+```
+
+上面的代码编译不通过，因为`ProcessFoo`需要的参数是Foo类型，传入的string类型不匹配。
+
+如果将Foo构造函数的explicit关键字移除，那么调用`ProcessFoo`传入的string就会触发隐式转换，生成一个临时的Foo对象。往往这种隐式转换是让人迷惑的，并且容易隐藏Bug，得到了一个不期望的类型转换。所以对于单参数的构造函数是要求explicit声明。
+
+### <a name="r7-1-3"></a>规则7.1.3 如果不需要拷贝构造函数、赋值操作符 / 移动构造函数、赋值操作符，请明确禁止
+说明：如果用户不定义，编译器默认会生成拷贝构造函数和拷贝赋值操作符， 移动构造和移动赋值操作符（移动语义的函数C++11以后才有）。
+如果我们不要使用拷贝构造函数，或者赋值操作符，请明确拒绝：
+
+1.将拷贝构造函数或者赋值操作符设置为private，并且不实现：
+
+```cpp
+class Foo {
+ private:
+  Foo(const Foo&);
+  Foo& operator=(const Foo&);
+};
+```
+2.使用C++11提供的delete:
+
+```cpp
+// 同时禁止, 使用C++11的delete
+class Foo {
+ public:
+  Foo(Foo&&) = delete;
+  Foo& operator=(Foo&&) = delete;
+};
+```
+3.静态方法类，禁用构造函数，防止创建实例
+
+```cpp
+class Helper {
+ public:
+  static bool DoSomething();
+
+ private:
+  Helper();
+};
+```
+4.单例类，禁用构造函数，拷贝构造函数，防止创建实例
+
+```cpp
+class Foo {
+ private:
+  static Foo *instance;
+  Foo() {}
+  Foo(const Foo &a);
+  Foo& operator=(const Foo &a);
+ public:
+  static Foo &Instance() {
+    if (!instance) {
+      instance = new Foo();
+    }
+    return *instance;
+  }
+};
+```
+
+5.析构函数通过裸指针释放资源的，禁用拷贝构造、拷贝赋值，防止重复释放
+
+```cpp
+class Foo {
+ private:
+  FILE *fp;
+  Foo(const Foo &a);
+  Foo& operator=(const Foo &a);
+ public:
+  Foo() : fp(nullptr) {}
+  ~Foo() {
+    if (fp != nullptr) {
+      fclose(fp);
+      fp = nullptr;
+    }
+  }
+};
+
+Foo* Foo::instance = nullptr;
+```
+
+### <a name="r7-1-4"></a>规则7.1.4 拷贝构造和拷贝赋值操作符应该是成对出现或者禁止
+拷贝构造函数和拷贝赋值操作符都是具有拷贝语义的，应该同时出现或者禁止。
+
+```cpp
+// 同时出现
+class Foo {
+ public:
+  ...
+  Foo(const Foo&);
+  Foo& operator=(const Foo&);
+  ...
+};
+
+// 同时default， C++11支持
+class Foo {
+ public:
+  Foo(const Foo&) = default;
+  Foo& operator=(const Foo&) = default;
+};
+
+// 同时禁止, C++11可以使用delete
+class Foo {
+ private:
+  Foo(const Foo&);
+  Foo& operator=(const Foo&);
+};
+```
+
+### <a name="r7-1-5"></a>规则7.1.5 移动构造和移动赋值操作符应该是成对出现或者禁止
+在C++11中增加了move操作，如果需要某个类支持移动操作，那么需要实现移动构造和移动赋值操作符。
+
+移动构造函数和移动赋值操作符都是具有移动语义的，应该同时出现或者禁止。
+```cpp
+// 同时出现
+class Foo {
+ public:
+  ...
+  Foo(Foo&&);
+  Foo& operator=(Foo&&);
+  ...
+};
+
+// 同时default， C++11支持
+class Foo {
+ public:
+  Foo(Foo&&) = default;
+  Foo& operator=(Foo&&) = default;
+};
+
+// 同时禁止, 使用C++11的delete
+class Foo {
+ public:
+  Foo(Foo&&) = delete;
+  Foo& operator=(Foo&&) = delete;
+};
+```
+
+### <a name="r7-1-6"></a>规则7.1.6 禁止在构造函数和析构函数中调用虚函数
+说明：在构造函数和析构函数中调用当前对象的虚函数，会导致未实现多态的行为。
+在C++中，一个基类一次只构造一个完整的对象。
+
+示例：类Base是基类，Sub是派生类
+```cpp
+class Base {                       
+ public:                
+  Base();
+  virtual void Log() = 0;    // 不同的派生类调用不同的日志文件
+};
+
+Base::Base() {        // 基类构造函数
+  Log();              // 调用虚函数Log
+}                                                  
+
+class Sub : public Base {       
+ public:
+  virtual void Log();          
+};
+```
+
+当执行如下语句：
+`Sub sub;`
+会先执行Sub的构造函数，但首先调用Base的构造函数，由于Base的构造函数调用虚函数Log，此时Log还是基类的版本，只有基类构造完成后，才会完成派生类的构造，从而导致未实现多态的行为。
+同样的道理也适用于析构函数。
+
+### <a name="a7-1-2"></a>建议7.1.2 类定义中的函数不要添加inline关键字
+说明：类定义中的函数默认是inline的。
+
+
+## <a name="c7-2"></a> 继承
+
+### <a name="r7-2-1"></a>规则7.2.1 基类的析构函数应该声明为virtual
+说明：只有基类析构函数是virtual，通过多态调用的时候才能保证派生类的析构函数被调用。
+
+示例：基类的析构函数没有声明为virtual导致了内存泄漏。
+```cpp
+class Base {
+ public:
+  virtual std::string getVersion() = 0;
+    
+  ~Base() {
+    std::cout << "~Base" << std::endl;
+  }
+};
+```
+
+```cpp
+class Sub : public Base {
+ public:
+  Sub() : numbers(nullptr) {  
+  }
+    
+  ~Sub() {
+    delete[] numbers;
+    std::cout << "~Sub" << std::endl;
+  }
+    
+  int Init() {
+    const size_t numberCount = 100;
+    numbers = new (std::nothrow) int[numberCount];
+    if (numbers == nullptr) {
+      return -1;
+    }
+        
+    ...
+  }
+
+  std::string getVersion() { 
+    return std::string("hello!");
+  }
+private:
+  int* numbers;
+};
+```
+
+```cpp
+int main(int argc, char* args[]) {
+  Base* b = new Sub();
+
+  delete b;
+  return 0;
+}
+```
+由于基类Base的析构函数没有声明为virtual，当对象被销毁时，只会调用基类的析构函数，不会调用派生类Sub的析构函数，导致内存泄漏。
+
+
+### <a name="r7-2-2"></a>规则7.2.2 禁止虚函数使用缺省参数值
+说明：在C++中，虚函数是动态绑定的，但函数的缺省参数却是在编译时就静态绑定的。这意味着你最终执行的函数是一个定义在派生类，但使用了基类中的缺省参数值的虚函数。为了避免虚函数重载时，因参数声明不一致给使用者带来的困惑和由此导致的问题，规定所有虚函数均不允许声明缺省参数值。
+示例：虚函数display缺省参数值text是由编译时刻决定的，而非运行时刻，没有达到多态的目的：
+```cpp
+class Base {
+ public:
+  virtual void Display(const std::string& text = "Base!") {
+    std::cout << text << std::endl;
+  }
+    
+  virtual ~Base(){}
+};
+
+class Sub : public Base {
+ public:
+  virtual void Display(const std::string& text  = "Sub!") {
+    std::cout << text << std::endl; 
+  }
+    
+  virtual ~Sub(){}
+};
+
+int main() {
+  Base* base = new Sub();
+  Sub* sub = new Sub();
+   
+  ...
+    
+  base->Display();  // 程序输出结果: Base! 而期望输出：Sub!
+  sub->Display();   // 程序输出结果: Sub!
+    
+  delete base;
+  delete sub;
+  return 0;
+};
+```
+
+### <a name="r7-2-3"></a>规则7.2.3 禁止重新定义继承而来的非虚函数
+说明：因为非虚函数无法实现动态绑定，只有虚函数才能实现动态绑定：只要操作基类的指针，即可获得正确的结果。
+
+示例：
+```cpp
+class Base {
+ public:
+  void Fun();
+};
+
+class Sub : public Base { 
+ public:
+  void Fun();
+};
+
+Sub* sub = new Sub();                     
+Base* base = sub;
+
+sub->Fun();    // 调用子类的Fun                  
+base->Fun();   // 调用父类的Fun
+//...
+
+```
+
+## <a name="c7-3"></a> 多重继承
+在实际开发过程中使用多重继承的场景是比较少的，因为多重继承使用过程中有下面的典型问题：
+1. 菱形继承所带来的数据重复，以及名字二义性。因此，C++引入了virtual继承来解决这类问题;
+2. 即便不是菱形继承，多个父类之间的名字也可能存在冲突，从而导致的二义性;
+3. 如果子类需要扩展或改写多个父类的方法时，造成子类的职责不明，语义混乱;
+4. 相对于委托，继承是一种白盒复用，即子类可以访问父类的protected成员, 这会导致更强的耦合。而多重继承，由于耦合了多个父类，相对于单根继承，这会产生更强的耦合关系。
+
+多重继承具有下面的优点：
+多重继承提供了一种更简单的组合来实现多种接口或者类的组装与复用。
+
+所以，对于多重继承的只有下面几种情况下面才允许使用多重继承。
+
+### <a name="a7-3-1"></a>建议7.3.1 使用多重继承来实现接口分离与多角色组合
+如果某个类需要实现多重接口，可以通过多重继承把多个分离的接口组合起来，类似 scala 语言的 traits 混入。
+
+```cpp
+class Role1 {};
+class Role2 {};
+class Role3 {};
+
+class Object1 : public Role1, public Role2 {
+  // ...
+};
+
+class Object2 : public Role2, public Role3 {
+  // ...
+};
+
+```
+
+在C++标准库中也有类似的实现样例：
+```cpp
+class basic_istream {};
+class basic_ostream {};
+
+class basic_iostream : public basic_istream, public basic_ostream {
+  
+};
+```
+
+## <a name="c7-4"></a> 重载
+
+重载操作符要有充分理由,而且不要改变操作符原有语义，例如不要使用 ‘+’ 操作符来做减运算。
+操作符重载令代码更加直观，但也有一些不足：
+- 混淆直觉，误以为该操作和内建类型一样是高性能的，忽略了性能降低的可能；
+- 问题定位时不够直观，按函数名查找比按操作符显然更方便。
+- 重载操作符如果行为定义不直观(例如将‘+’ 操作符来做减运算)，会让代码产生混淆。
+- 赋值操作符的重载引入的隐式转换会隐藏很深的bug。可以定义类似Equals()、CopyFrom()等函数来替代=,==操作符。
+
+
+
+# <a name="c8"></a> 8 函数
+## <a name="c8-1"></a>函数设计
+### <a name="r8-1-1"></a>建议8.1.1 避免函数过长，函数不超过50行（非空非注释）
+函数应该可以一屏显示完 (50行以内)，只做一件事情，而且把它做好。
+
+过长的函数往往意味着函数功能不单一，过于复杂，或过分呈现细节，未进行进一步抽象。
+
+例外：某些实现算法的函数，由于算法的聚合性与功能的全面性，可能会超过50行。
+
+即使一个长函数现在工作的非常好, 一旦有人对其修改, 有可能出现新的问题, 甚至导致难以发现的bug。
+建议将其拆分为更加简短并易于管理的若干函数，以便于他人阅读和修改代码。
+
+## <a name="c8-2"></a>内联函数
+
+###  <a name="a8-2-1"></a>建议8.2.1 内联函数不超过10行（非空非注释）
+**说明**：内联函数具有一般函数的特性，它与一般函数不同之处只在于函数调用的处理。一般函数进行调用时，要将程序执行权转到被调用函数中，然后再返回到调用它的函数中；而内联函数在调用时，是将调用表达式用内联函数体来替换。
+
+内联函数只适合于只有 1~10 行的小函数。对一个含有许多语句的大函数，函数调用和返回的开销相对来说微不足道，也没有必要用内联函数实现，一般的编译器会放弃内联方式，而采用普通的方式调用函数。
+
+如果内联函数包含复杂的控制结构，如循环、分支(switch)、try-catch 等语句，一般编译器将该函数视同普通函数。
+**虚函数、递归函数不能被用来做内联函数**。
+
+## <a name="c8-3"></a> 函数参数
+
+### <a name="a8-3-1"></a>建议8.3.1 函数参数使用引用取代指针
+
+**说明**：引用比指针更安全，因为它一定非空，且一定不会再指向其他目标；引用不需要检查非法的NULL指针。
+
+选择 const 避免参数被修改，让代码阅读者清晰地知道该参数不被修改，可大大增强代码可读性。
+
+### <a name="a8-3-2"></a>建议8.3.2 使用强类型参数，避免使用void*
+尽管不同的语言对待强类型和弱类型有自己的观点，但是一般认为c/c++是强类型语言，既然我们使用的语言是强类型的，就应该保持这样的风格。
+好处是尽量让编译器在编译阶段就检查出类型不匹配的问题。
+
+使用强类型便于编译器帮我们发现错误，如下代码中注意函数 FooListAddNode 的使用：
+```cpp
+struct FooNode {
+  struct List link;
+  int foo;
+};
+
+struct BarNode {
+  struct List link;
+  int bar;
+}
+
+void FooListAddNode(void *node) { // Bad: 这里用 void * 类型传递参数
+  FooNode *foo = (FooNode *)node;
+  ListAppend(&fooList, &foo->link);
+}
+
+void MakeTheList() {
+  FooNode *foo = nullptr;
+  BarNode *bar = nullptr;
+  ...
+
+  FooListAddNode(bar);        // Wrong: 这里本意是想传递参数 foo，但错传了 bar，却没有报错
+}
+```
+
+1. 可以使用模板函数来实现参数类型的变化。
+2. 可以使用基类指针来实现多态。
+
+### <a name="a8-3-3"></a>建议8.3.3 函数的参数个数不超过5个
+函数的参数过多，会使得该函数易于受外部变化的影响，从而影响维护工作。函数的参数过多同时也会增大测试的工作量。
+
+如果超过可以考虑:
+- 看能否拆分函数
+- 看能否将相关参数合在一起，定义结构体
+
+# <a name="c9"></a> 9 C++其他特性
+
+## <a name="c9-1"></a> 常量与初始化
+
+不变的值更易于理解、跟踪和分析，所以应该尽可能地使用常量代替变量，定义值的时候，应该把const作为默认的选项。
+
+### <a name="r9-1-1"></a>建议9.1.1 不允许使用宏来表示常量
+
+**说明**：宏是简单的文本替换，在预处理阶段时完成，运行报错时直接报相应的值；跟踪调试时也是显示值，而不是宏名；宏没有类型检查，不安全；宏没有作用域。
+
+```cpp
+#define MAX_MSISDN_LEN 20    // 不好
+
+// C++请使用const常量
+const int kMaxMsisdnLen = 20; // 好
+
+// 对于C++11以上版本，可以使用constexpr
+constexpr int kMaxMsisdnLen = 20;
+```
+
+###  <a name="a9-1-2"></a>建议9.1.2 一组相关的整型常量应定义为枚举
+
+**说明**：枚举比`#define`或`const int`更安全。编译器会检查参数值是否位于枚举取值范围内，避免错误发生。
+
+```cpp
+// 好的例子：
+enum Week {
+  kSunday,
+  kMonday,
+  kTuesday,
+  kWednesday,
+  kThursday,
+  kFriday,
+  kSaturday
+};
+
+enum Color {
+  kRed,
+  kBlack,
+  kBlue
+};
+
+void ColorizeCalendar(Week today, Color color);
+
+ColorizeCalendar(kBlue, kSunday); // 编译报错，参数类型错误
+
+// 不好的例子:
+const int kSunday = 0;
+const int kMonday = 1;
+
+const int kRed = 0;
+const int kBlack = 1;
+
+bool ColorizeCalendar(int today, int color);
+ColorizeCalendar(kBlue, kSunday); // 不会报错
+```
+
+当枚举值需要对应到具体数值时，须在声明时显式赋值。否则不需要显式赋值，以避免重复赋值，降低维护(增加、删除成员)工作量。
+
+```cpp
+// 好的例子：S协议里定义的设备ID值，用于标识设备类型
+enum DeviceType {
+  kUnknown = -1,
+  kDsmp = 0,
+  kIsmg = 1,
+  kWapportal = 2
+};
+```
+
+
+
+### <a name="r9-1-3"></a>建议9.1.3 不允许使用魔鬼数字
+所谓魔鬼数字即看不懂、难以理解的数字。
+
+魔鬼数字并非一个非黑即白的概念，看不懂也有程度，需要自行判断。
+例如数字 12，在不同的上下文中情况是不一样的：
+type = 12; 就看不懂，但 `month = year * 12`; 就能看懂。
+数字 0 有时候也是魔鬼数字，比如 `status = 0`; 并不能表达是什么状态。
+
+解决途径：
+对于局部使用的数字，可以增加注释说明
+对于多处使用的数字，必须定义 const 常量，并通过符号命名自注释。
+
+禁止出现下列情况：
+没有通过符号来解释数字含义，如` const int kZero = 0`
+符号命名限制了其取值，如 `const int kXxTimerInterval = 300`，直接使用`kXxTimerInterval `来表示该常量是定时器的时间间隔。
+
+### <a name="r9-1-1"></a>规则9.1.1 常量应该保证单一职责
+
+**说明**：一个常量只用来表示一个特定功能，即一个常量不能有多种用途。
+
+```cpp
+// 好的例子：协议A和协议B，手机号(MSISDN)的长度都是20。
+const unsigned int kAMaxMsisdnLen = 20;
+const unsigned int kBMaxMsisdnLen = 20;
+
+// 或者使用不同的名字空间：
+namespace namespace1 {
+const unsigned int kMaxMsisdnLen = 20;
+}
+
+namespace namespace2 {
+const unsigned int kMaxMsisdnLen = 20;
+}
+```
+
+### <a name="r9-1-4"></a>建议9.1.4 禁止用memcpy_s、memset_s初始化非POD对象
+
+**说明**：`POD`全称是`Plain Old Data`，是C++ 98标准(ISO/IEC 14882, first edition, 1998-09-01)中引入的一个概念，`POD`类型主要包括`int`, `char`, `float`，`double`，`enumeration`，`void`，指针等原始类型以及聚合类型，不能使用封装和面向对象特性（如用户定义的构造/赋值/析构函数、基类、虚函数等）。
+
+由于非POD类型比如非聚合类型的class对象，可能存在虚函数，内存布局不确定，跟编译器有关，滥用内存拷贝可能会导致严重的问题。
+
+即使对聚合类型的class，使用直接的内存拷贝和比较，破坏了信息隐蔽和数据保护的作用，也不提倡`memcpy_s`、`memset_s`操作。
+
+对于POD类型的详细说明请参见附录。
+
+
+## <a name="c9-2"></a> 表达式
+
+### <a name="r9-2-2"></a>规则9.2.1 switch语句要有default分支
+大部分情况下，switch语句中要有default分支，保证在遗漏case标签处理时能够有一个缺省的处理行为。
+
+特例：
+如果switch条件变量是枚举类型，并且 case 分支覆盖了所有取值，则加上default分支处理有些多余。
+现代编译器都具备检查是否在switch语句中遗漏了某些枚举值的case分支的能力，会有相应的warning提示。 
+
+```cpp
+enum Color {
+  kRed = 0,
+  kBlue
+};
+
+// 因为switch条件变量是枚举值，这里可以不用加default处理分支
+switch (color) {
+  case kRed:
+    DoRedThing();
+    break;
+  case kBlue:
+    DoBlueThing();
+    ...
+    break;
+}
+```
+
+### <a name="a9-2-1"></a>建议9.2.1 表达式的比较，应当遵循左侧倾向于变化、右侧倾向于不变的原则
+当变量与常量比较时，如果常量放左边，如 if (MAX == v) 不符合阅读习惯，而 if (MAX > v) 更是难于理解。
+应当按人的正常阅读、表达习惯，将常量放右边。写成如下方式：
+```cpp
+if (value == MAX) {
+  
+}
+
+if (value < MAX) {
+  
+}
+```
+也有特殊情况，如：`if (MIN < value && value < MAX)` 用来描述区间时，前半段是常量在左的。
+
+不用担心将 '==' 误写成 '='，因为` if (value = MAX)` 会有编译告警，其他静态检查工具也会报错。让工具去解决笔误问题，代码要符合可读性第一。
+
+
+## <a name="c9-3"></a> 类型转换
+
+避免使用类型分支来定制行为：类型分支来定制行为容易出错，是企图用C++编写C代码的明显标志。这是一种很不灵活的技术，要添加新类型时，如果忘记修改所有分支，编译器也不会告知。使用模板和虚函数，让类型自己而不是调用它们的代码来决定行为。
+
+建议避免类型转换，我们在代码的类型设计上应该考虑到每种数据的数据类型是什么，而不是应该过度使用类型转换来解决问题。在设计某个基本类型的时候，请考虑：
+- 是无符号还是有符号的
+- 是适合float还是double
+- 是使用int8，int16，int32还是int64，确定整形的长度
+
+但是我们无法禁止使用类型转换，因为C++语言是一门面向机器编程的语言，涉及到指针地址，并且我们会与各种第三方或者底层API交互，他们的类型设计不一定是合理的，在这个适配的过程中很容易出现类型转换。
+
+例外：在调用某个函数的时候，如果我们不想处理函数结果，首先要考虑这个是否是你的最好的选择。如果确实不想处理函数的返回值，那么可以使用(void)转换来解决。
+
+### <a name="r9-3-1"></a>规则9.3.1 如果确定要使用类型转换，请使用有C++提供的类型转换，而不是C风格的类型转换
+
+**说明**：
+
+C++提供的类型转换操作比C风格更有针对性，更易读，也更加安全，C++提供的转换有：
+- 类型转换：
+1. `dynamic_cast`：主要用于继承体系下行转换，`dynamic_cast`具有类型检查的功能，请做好基类和派生类的设计，避免使用dynamic_cast来进行转换。
+2. `static_cast`：和C风格转换相似可做值的强制转换，或上行转换(把派生类的指针或引用转换成基类的指针或引用)。该转换经常用于消除多重继承带来的类型歧义，是相对安全的。如果是纯粹的算数转换，那么请使用后面的大括号转换方式。
+3. `reinterpret_cast`：用于转换不相关的类型。`reinterpret_cast`强制编译器将某个类型对象的内存重新解释成另一种类型，这是一种不安全的转换，建议尽可能少用`reinterpret_cast`。
+4. `const_cast`：用于移除对象的`const`属性，使对象变得可修改，这样会破坏数据的不变性，建议尽可能少用。
+
+- 算数转换： （C++11开始支持）
+  对于那种算数转换，并且类型信息没有丢失的，比如float到double， int32到int64的转换，推荐使用大括号的初始方式。
+```cpp
+  double d{ someFloat };
+  int64_t i{ someInt32 };
+```
+
+### <a name="a9-3-1"></a>建议9.3.1 避免使用`dynamic_cast`
+1. `dynamic_cast`依赖于C++的RTTI， 让程序员在运行时识别C++类对象的类型。
+2. `dynamic_cast`的出现一般说明我们的基类和派生类设计出现了问题，派生类破坏了基类的契约，不得不通过`dynamic_cast`转换到子类进行特殊处理，这个时候更希望来改善类的设计，而不是通过`dynamic_cast`来解决问题。
+
+### <a name="a9-3-2"></a>建议9.3.2 避免使用`reinterpret_cast`
+
+**说明**：`reinterpret_cast`用于转换不相关类型。尝试用`reinterpret_cast`将一种类型强制转换另一种类型，这破坏了类型的安全性与可靠性，是一种不安全的转换。不同类型之间尽量避免转换。
+
+### <a name="a9-3-3"></a>建议9.3.3 避免使用`const_cast`
+
+**说明**：`const_cast`用于移除对象的`const`和`volatile`性质。
+
+使用const_cast转换后的指针或者引用来修改const对象，行为是未定义的。
+
+```cpp
+// 不好的例子
+const int i = 1024; 
+int* p = const_cast<int*>(&i);
+*p = 2048;      // 未定义行为
+```
+
+```cpp
+// 不好的例子
+class Foo {
+ public:
+  Foo() : i(3) {}
+
+  void Fun(int v) {
+    i = v;
+  }
+
+ private:
+  int i;
+};
+
+int main(void) {
+  const Foo f;
+  Foo* p = const_cast<Foo*>(&f);
+  p->Fun(8);  // 未定义行为
+}
+
+```
+
+
+## <a name="c9-4"></a>资源分配和释放
+
+### <a name="r9-4-1"></a>规则9.4.1 单个对象释放使用delete，数组对象释放使用delete []
+说明：单个对象删除使用delete， 数组对象删除使用delete []，原因：
+
+- 调用new所包含的动作：从系统中申请一块内存，并调用此类型的构造函数。
+- 调用new[n]所包含的动作：申请可容纳n个对象的内存，并且对每一个对象调用其构造函数。
+- 调用delete所包含的动作：先调用相应的析构函数，再将内存归还系统。
+- 调用delete[]所包含的动作：对每一个对象调用析构函数，再释放所有内存
+
+如果new和delete的格式不匹配，结果是未知的。对于非class类型， new和delete不会调用构造与析构函数。
+
+错误写法：
+```cpp
+const int KMaxArraySize = 100;
+int* numberArray = new int[KMaxArraySize];
+...
+delete numberArray;
+numberArray = NULL;
+```
+
+正确写法：
+```cpp
+const int KMaxArraySize = 100;
+int* numberArray = new int[KMaxArraySize];
+...
+delete[] numberArray;
+numberArray = NULL;
+```
+
+## <a name="c9-5"></a>标准库
+
+STL标准模板库在不同模块使用程度不同，这里列出一些基本规则和建议。
+
+### <a name="r9-5-1"></a>规则9.5.1 不要保存std::string的c_str()返回的指针
+
+说明：在C++标准中并未规定string::c_str()指针持久有效，因此特定STL实现完全可以在调用string::c_str()时返回一个临时存储区并很快释放。所以为了保证程序的可移植性，不要保存string::c_str()的结果，而是在每次需要时直接调用。
+
+示例：
+
+```cpp
+void Fun1() {
+  std::string name = "demo";
+  const char* text = name.c_str();  // 表达式结束以后，name的生命周期还在，指针有效
+
+  // 如果中间调用了string的非const成员函数，导致string被修改，比如operator[], begin()等
+  // 可能会导致text的内容不可用，或者不是原来的字符串
+  name = "test";
+  name[1] = '2';
+
+  // 后续使用text指针，其字符串内容不再是"demo"
+}
+
+void Fun2() {
+  std::string name = "demo";
+  std::string test = "test";
+  const char* text = (name + test).c_str(); // 表达式结束以后，+号产生的临时对象被销毁，指针无效
+
+    // 后续使用text指针，其已不再指向合法内存空间
+}
+```
+例外：在少数对性能要求非常高的代码中，为了适配已有的只接受const char*类型入参的函数，可以临时保存string::c_str()返回的指针。但是必须严格保证string对象的生命周期长于所保存指针的生命周期，并且保证在所保存指针的生命周期内，string对象不会被修改。
+
+
+### <a name="a9-5-1"></a>建议9.5.1 使用std::string代替char*
+
+说明：使用string代替`char*`有很多优势，比如：
+1. 不用考虑结尾的’\0’；
+2. 可以直接使用+, =, ==等运算符以及其它字符串操作函数；
+3. 不需要考虑内存分配操作，避免了显式的new/delete，以及由此导致的错误；
+
+需要注意的是某些stl实现中string是基于写时复制策略的，这会带来2个问题，一是某些版本的写时复制策略没有实现线程安全，在多线程环境下会引起程序崩溃；二是当与动态链接库相互传递基于写时复制策略的string时，由于引用计数在动态链接库被卸载时无法减少可能导致悬挂指针。因此，慎重选择一个可靠的stl实现对于保证程序稳定是很重要的。
+
+例外：
+当调用系统或者其它第三方库的API时，针对已经定义好的接口，只能使用`char*`。但是在调用接口之前都可以使用string，在调用接口时使用string::c_str()获得字符指针。
+当在栈上分配字符数组当作缓冲区使用时，可以直接定义字符数组，不要使用string，也没有必要使用类似`vector<char>`等容器。
+
+### <a name="r9-5-2"></a>规则9.5.2 禁止使用auto_ptr
+说明：在stl库中的std::auto_ptr具有一个隐式的所有权转移行为，如下代码：
+```cpp
+auto_ptr<T> p1(new T);
+auto_ptr<T> p2 = p1;
+```
+当执行完第2行语句后，p1已经不再指向第1行中分配的对象，而是变为NULL。正因为如此，auto_ptr不能被置于各种标准容器中。
+转移所有权的行为通常不是期望的结果。对于必须转移所有权的场景，也不应该使用隐式转移的方式。这往往需要程序员对使用auto_ptr的代码保持额外的谨慎，否则出现对空指针的访问。
+使用auto_ptr常见的有两种场景，一是作为智能指针传递到产生auto_ptr的函数外部，二是使用auto_ptr作为RAII管理类，在超出auto_ptr的生命周期时自动释放资源。
+对于第1种场景，可以使用std::shared_ptr来代替。
+对于第2种场景，可以使用C++11标准中的std::unique_ptr来代替。其中std::unique_ptr是std::auto_ptr的代替品，支持显式的所有权转移。
+
+例外：
+在C++11标准得到普遍使用之前，在一定需要对所有权进行转移的场景下，可以使用std::auto_ptr，但是建议对std::auto_ptr进行封装，并禁用封装类的拷贝构造函数和赋值运算符，以使该封装类无法用于标准容器。
+
+
+### <a name="a9-5-2"></a>建议9.5.2 使用新的标准头文件
+
+说明：
+使用C++的标准头文件时，请使用`<cstdlib>`这样的，而不是`<stdlib.h>`这种的。
+
+## <a name="c9-6"></a> const的用法
+在声明的变量或参数前加上关键字 const 用于指明变量值不可被篡改 (如 `const int foo` ). 为类中的函数加上 const 限定符表明该函数不会修改类成员变量的状态 (如 `class Foo { int Bar(char c) const; };`)。 const 变量, 数据成员, 函数和参数为编译时类型检测增加了一层保障， 便于尽早发现错误。因此, 我们强烈建议在任何可能的情况下使用 const。
+有时候，使用C++11的constexpr来定义真正的常量可能更好。
+
+### <a name="r9-6-1"></a>规则9.6.1 对于指针和引用类型的形参，如果是不需要修改的，请使用const
+不变的值更易于理解/跟踪和分析，把const作为默认选项，在编译时会对其进行检查，使代码更牢固/更安全。
+```cpp
+class Foo;
+
+void PrintFoo(const Foo& foo);
+```
+
+### <a name="r9-6-2"></a>规则9.6.2 对于不会修改成员变量的成员函数请使用const修饰
+尽可能将成员函数声明为 const。 访问函数应该总是 const。只要不修改数据成员的成员函数，都声明为const。
+
+```cpp
+class Foo {
+ public:
+
+  // ...
+
+  int PrintValue() const { // const修饰成员函数，不会修改成员变量
+    std::cout << value << std::endl;
+  }
+
+  int GetValue() const { // const修饰成员函数，不会修改成员变量
+    return value;
+  }
+
+ private:
+  int value;
+};
+```
+
+### <a name="a9-6-1"></a>建议9.6.1 初始化后不会再修改的成员变量定义为const
+
+```cpp
+class Foo {
+ public:
+  Foo(int length) : dataLength(length) {}
+ private:
+  const int dataLength;  
+};
+```
+
+## <a name="c9-7"></a> 模板
+
+模板能够实现非常灵活简洁的类型安全的接口，实现类型不同但是行为相同的代码复用。
+
+模板编程的缺点：
+
+1. 模板编程所使用的技巧对于使用c++不是很熟练的人是比较晦涩难懂的。在复杂的地方使用模板的代码让人更不容易读懂，并且debug 和维护起来都很麻烦。
+2. 模板编程经常会导致编译出错的信息非常不友好: 在代码出错的时候, 即使这个接口非常的简单, 模板内部复杂的实现细节也会在出错信息显示. 导致这个编译出错信息看起来非常难以理解。
+3. 模板如果使用不当，会导致运行时代码过度膨胀。
+4. 模板代码难以修改和重构。模板的代码会在很多上下文里面扩展开来, 所以很难确认重构对所有的这些展开的代码有用。
+
+所以， 建议__模板编程最好只用在少量的基础组件，基础数据结构上面__。并且使用模板编程的时候尽可能把__复杂度最小化__，尽量__不要让模板对外暴露__。最好只在实现里面使用模板, 然后给用户暴露的接口里面并不使用模板, 这样能提高你的接口的可读性。 并且你应该在这些使用模板的代码上写尽可能详细的注释。
+
+
+## <a name="c9-8"></a> 宏
+在C++语言中，我们强烈建议尽可能少使用复杂的宏
+- 对于常量定义，请按照前面章节所述，使用const或者枚举； 
+- 对于宏函数，尽可能简单，并且遵循下面的原则，并且优先使用内联函数，模板函数等进行替换。
+
+```cpp
+// 不推荐使用宏函数
+#define SQUARE(a, b) ((a) * (b)) 
+
+// 请使用模板函数，内联函数等来替换。
+template<typename T> T Square(T a, T b) { return a * b; }
+```
+
+如果需要使用宏，请参考C语言规范的相关章节。
+**例外**：一些通用且成熟的应用，如：对 new, delete 的封装处理，可以保留对宏的使用。
+
+
+## <a name="c9-9"></a> 其他
+
+### <a name="a9-9-1"></a>建议9.9.1 输出到文件时，尽量使用'\n'代替std::endl;
+说明：std::endl会将缓冲区的内容flush到文件中，可能会影响性能。
+
+# <a name="c10"></a> 10 现代C++特性
+
+随着 ISO 在2011年发布 C++11 语言标准，以及2017年3月发布 C++17 ，现代C++(C++11/14/17等)增加了大量提高编程效率、代码质量的新语言特性和标准库。
+本章节描述了一些可以帮助团队更有效率的使用现代C++，规避语言陷阱的指导意见。
+
+## <a name="c10-1"></a> 代码简洁性和安全性提升
+### <a name="a10-1-1"></a>建议10.1.1 合理使用`auto`
+**理由**
+
+* `auto`可以避免编写冗长、重复的类型名，也可以保证定义变量时初始化。
+* `auto`类型推导规则复杂，需要仔细理解。
+* 如果能够使代码更清晰，继续使用明确的类型，且只在局部变量使用`auto`。
+
+**示例**
+
+```cpp
+// 避免冗长的类型名
+std::map<string, int>::iterator iter = m.find(val);
+auto iter = m.find(val);
+
+// 避免重复类型名
+class Foo {...};
+Foo* p = new Foo;
+auto p = new Foo;
+
+// 保证初始化
+int x;    // 编译正确，没有初始化
+auto x;   // 编译失败，必须初始化
+```
+
+auto 的类型推导可能导致困惑：
+
+```cpp
+auto a = 3;           // int
+const auto ca = a;    // const int
+const auto& ra = a;   // const int&
+auto aa = ca;         // int, 忽略 const 和 reference
+auto ila1 = { 10 };   // std::initializer_list<int>
+auto ila2{ 10 };      // std::initializer_list<int>
+
+auto&& ura1 = x;      // int&
+auto&& ura2 = ca;     // const int&
+auto&& ura3 = 10;     // int&&
+
+const int b[10];
+auto arr1 = b;        // const int*
+auto& arr2 = b;       // const int(&)[10]
+```
+
+如果没有注意 `auto` 类型推导时忽略引用，可能引入难以发现的性能问题:
+
+```cpp
+std::vector<std::string> v;
+auto s1 = v[0];  // auto 推导为 std::string，拷贝 v[0]
+```
+
+如果使用`auto`定义接口，如头文件中的常量，可能因为开发人员修改了值，而导致类型发生变化。
+
+在循环中，考虑使用auto &和auto *去遍历复杂对象，以提升性能。
+
+```cpp
+for (auto &stmt : bb->GetStmtNodes()) {
+...
+}
+```
+
+### <a name="r10-1-1"></a>规则10.1.1 在重写虚函数时请使用`override`关键字
+**理由**
+`override`关键字保证函数是虚函数，且重写了基类的虚函数。如果子类函数与基类函数原型不一致，则产生编译告警。
+
+如果修改了基类虚函数原型，但忘记修改子类重写的虚函数，在编译期就可以发现。也可以避免有多个子类时，重写函数的修改遗漏。
+
+**示例**
+
+```cpp
+class Base {
+ public:
+  virtual void Foo();
+  void Bar();
+};
+
+class Derived : public Base {
+ public:
+  void Foo() const override; // 编译失败: derived::Foo 和 base::Foo 原型不一致，不是重写
+  void Foo() override;       // 正确: derived::Foo 重写 base::Foo
+  void Bar() override;       // 编译失败: base::Bar 不是虚函数
+};
+```
+
+**总结**
+1. 基类首次定义虚函数，使用`virtual`关键字
+2. 子类重写基类虚函数，使用`override`关键字
+3. 非虚函数，`virtual`和`override`都不使用
+
+### <a name="r10-1-2"></a>规则10.1.2 使用`delete`关键字删除函数
+**理由**
+相比于将类成员函数声明为`private`但不实现，`delete`关键字更明确，且适用范围更广。
+
+**示例**
+
+```cpp
+class Foo {
+ private:
+  // 只看头文件不知道拷贝构造是否被删除
+  Foo(const Foo&);
+};
+
+class Foo {
+ public:
+  // 明确删除拷贝赋值函数
+  Foo& operator=(const Foo&) = delete;
+};
+```
+
+`delete`关键字还支持删除非成员函数
+
+```cpp
+template<typename T>
+void Process(T value);
+
+template<>
+void Process<void>(void) = delete;
+```
+
+### <a name="r10-1-3"></a>规则10.1.3 使用`nullptr`，而不是`NULL`或`0`
+**理由**
+长期以来，C++没有一个代表空指针的关键字，这是一件很尴尬的事：
+
+```cpp
+#define NULL ((void *)0)
+
+char* str = NULL;   // 错误: void* 不能自动转换为 char*
+
+void(C::*pmf)() = &C::Func;
+if (pmf == NULL) {} // 错误: void* 不能自动转换为指向成员函数的指针
+```
+
+如果把`NULL`被定义为`0`或`0L`。可以解决上面的问题。
+
+或者在需要空指针的地方直接使用`0`。但这引入另一个问题，代码不清晰，特别是使用`auto`自动推导：
+
+```cpp
+auto result = Find(id);
+if (result == 0) {  // Find() 返回的是 指针 还是 整数?
+  // do something
+}
+```
+
+`0`字面上是`int`类型(`0L`是`long`)，所以`NULL`和`0`都不是指针类型。
+当重载指针和整数类型的函数时，传递`NULL`或`0`都调用到整数类型重载的函数:
+
+```cpp
+void F(int);
+void F(int*);
+
+F(0);      // 调用 F(int)，而非 F(int*)
+F(NULL);   // 调用 F(int)，而非 F(int*)
+```
+
+另外，`sizeof(NULL) == sizeof(void*)`并不一定总是成立的，这也是一个潜在的风险。
+
+总结： 直接使用`0`或`0L`，代码不清晰，且无法做到类型安全；使用`NULL`无法做到类型安全。这些都是潜在的风险。
+
+`nullptr`的优势不仅仅是在字面上代表了空指针，使代码清晰，而且它不再是一个整数类型。
+
+`nullptr`是`std::nullptr_t`类型，而`std::nullptr_t`可以隐式的转换为所有的原始指针类型，这使得`nullptr`可以表现成指向任意类型的空指针。
+
+```cpp
+void F(int);
+void F(int*);
+F(nullptr);   // 调用 F(int*)
+
+auto result = Find(id);
+if (result == nullptr) {  // Find() 返回的是 指针
+  // do something
+}
+```
+
+### <a name="r10-1-2"></a>建议10.1.2 使用`using`而非`typedef`
+在`C++11`之前，可以通过`typedef`定义类型的别名。没人愿意多次重复`std::map<uint32_t, std::vector<int>>`这样的代码。
+
+```cpp
+typedef std::map<uint32_t, std::vector<int>> SomeType;
+```
+
+类型的别名实际是对类型的封装。而通过封装，可以让代码更清晰，同时在很大程度上避免类型变化带来的散弹式修改。
+在`C++11`之后，提供`using`，实现`声明别名(alias declarations)`:
+
+```cpp
+using SomeType = std::map<uint32_t, std::vector<int>>;
+```
+
+对比两者的格式：
+
+```cpp
+typedef Type Alias;   // Type 在前，还是 Alias 在前
+using Alias = Type;   // 符合'赋值'的用法，容易理解，不易出错
+```
+
+如果觉得这点还不足以切换到`using`，我们接着看看`模板别名(alias template)`:
+
+```cpp
+// 定义模板的别名，一行代码
+template<class T>
+using MyAllocatorVector = std::vector<T, MyAllocator<T>>;
+
+MyAllocatorVector<int> data;       // 使用 using 定义的别名
+
+template<class T>
+class MyClass {
+ private:
+  MyAllocatorVector<int> data_;   // 模板类中使用 using 定义的别名
+};
+```
+
+而`typedef`不支持带模板参数的别名，只能"曲线救国":
+
+```cpp
+// 通过模板包装 typedef，需要实现一个模板类
+template<class T>
+struct MyAllocatorVector {
+  typedef std::vector<T, MyAllocator<T>> type;
+};
+
+MyAllocatorVector<int>::type data;  // 使用 typedef 定义的别名，多写 ::type
+
+template<class T>
+class MyClass {
+ private:
+  typename MyAllocatorVector<int>::type data_;  // 模板类中使用，除了 ::type，还需要加上 typename
+};
+```
+
+### <a name="r10-1-4"></a>规则10.1.4 禁止使用std::move操作const对象
+从字面上看，`std::move`的意思是要移动一个对象。而const对象是不允许修改的，自然也无法移动。因此用`std::move`操作const对象会给代码阅读者带来困惑。
+在实际功能上，`std::move`会把对象转换成右值引用类型；对于const对象，会将其转换成const的右值引用。由于极少有类型会定义以const右值引用为参数的移动构造函数和移动赋值操作符，因此代码实际功能往往退化成了对象拷贝而不是对象移动，带来了性能上的损失。
+
+**错误示例：**
+```cpp
+std::string gString;
+std::vector<std::string> gStringList;
+
+void func() {
+  const std::string myString = "String content";
+  gString = std::move(myString); // bad:并没有移动myString，而是进行了复制
+  const std::string anotherString = "Another string content";
+  gStringList.push_back(std::move(anotherString));    // bad:并没有移动anotherString，而是进行了复制
+}
+```
+
+## <a name="c10-2"></a> 智能指针
+### <a name="r10-2-1"></a>建议10.2.1 优先使用智能指针而不是原始指针管理资源
+**理由**
+避免资源泄露。
+
+**示例**
+
+```cpp
+void Use(int i) {
+  auto p = new int {7};               // 不好: 通过 new 初始化局部指针
+  auto q = std::make_unique<int>(9);  // 好: 保证释放内存
+  if (i > 0) {
+    return;                           // 可能 return，导致内存泄露
+  }
+  delete p;                           // 太晚了
+}
+```
+
+**例外**
+在性能敏感、兼容性等场景可以使用原始指针。
+
+### <a name="r10-2-1"></a>规则10.2.1 优先使用`unique_ptr`而不是`shared_ptr`
+**理由**
+1. `shared_ptr`引用计数的原子操作存在可测量的开销，大量使用`shared_ptr`影响性能。
+2. 共享所有权在某些情况（如循环依赖）可能导致对象永远得不到释放。
+3. 相比于谨慎设计所有权，共享所有权是一种诱人的替代方案，但它可能使系统变得混乱。
+
+### <a name="r10-2-2"></a>规则10.2.2 使用`std::make_unique`而不是`new`创建`unique_ptr`
+**理由**
+1. `make_unique`提供了更简洁的创建方式
+2. 保证了复杂表达式的异常安全
+
+**示例**
+
+```cpp
+// 不好：两次出现 MyClass，重复导致不一致风险
+std::unique_ptr<MyClass> ptr(new MyClass(0, 1));
+// 好：只出现一次 MyClass，不存在不一致的可能
+auto ptr = std::make_unique<MyClass>(0, 1);
+```
+
+重复出现类型可能导致非常严重的问题，且很难发现：
+
+```cpp
+// 编译正确，但new和delete不配套
+std::unique_ptr<uint8_t> ptr(new uint8_t[10]);
+std::unique_ptr<uint8_t[]> ptr(new uint8_t);
+// 非异常安全: 编译器可能按如下顺序计算参数:
+// 1. 分配 Foo 的内存,
+// 2. 构造 Foo,
+// 3. 调用 Bar,
+// 4. 构造 unique_ptr<Foo>.
+// 如果 Bar 抛出异常, Foo 不会被销毁，产生内存泄露。
+F(unique_ptr<Foo>(new Foo()), Bar());
+
+// 异常安全: 调用函数不会被打断.
+F(make_unique<Foo>(), Bar());
+```
+
+**例外**
+`std::make_unique`不支持自定义`deleter`。
+在需要自定义`deleter`的场景，建议在自己的命名空间实现定制版本的`make_unique`。
+使用`new`创建自定义`deleter`的`unique_ptr`是最后的选择。
+
+### <a name="r10-2-3"></a>规则10.2.3 使用`std::make_shared`而不是`new`创建`shared_ptr`
+**理由**
+使用`std::make_shared`除了类似`std::make_unique`一致性等原因外，还有性能的因素。
+`std::shared_ptr`管理两个实体：
+* 控制块(存储引用计数，`deleter`等)
+* 管理对象
+
+`std::make_shared`创建`std::shared_ptr`，会一次性在堆上分配足够容纳控制块和管理对象的内存。而使用`std::shared_ptr<MyClass>(new MyClass)`创建`std::shared_ptr`，除了`new MyClass`会触发一次堆分配外，`std::shard_ptr`的构造函数还会触发第二次堆分配，产生额外的开销。
+
+**例外**
+类似`std::make_unique`，`std::make_shared`不支持定制`deleter`
+
+## <a name="c10-3"></a> Lambda
+### <a name="a10-3-1"></a>建议10.3.1 当函数不能工作时选择使用`lambda`(捕获局部变量，或编写局部函数)
+**理由**
+函数无法捕获局部变量或在局部范围内声明；如果需要这些东西，尽可能选择`lambda`，而不是手写的`functor`。
+另一方面，`lambda`和`functor`不会重载；如果需要重载，则使用函数。
+如果`lambda`和函数都可以的场景，则优先使用函数；尽可能使用最简单的工具。
+
+**示例**
+
+```cpp
+// 编写一个只接受 int 或 string 的函数
+// -- 重载是自然的选择
+void F(int);
+void F(const string&);
+
+// 需要捕获局部状态，或出现在语句或表达式范围
+// -- lambda 是自然的选择
+vector<Work> v = LotsOfWork();
+for (int taskNum = 0; taskNum < max; ++taskNum) {
+  pool.Run([=, &v] {...});
+}
+pool.Join();
+```
+
+### <a name="r10-3-2"></a>规则10.3.1 非局部范围使用`lambdas`，避免使用按引用捕获
+**理由**
+非局部范围使用`lambdas`包括返回值，存储在堆上，或者传递给其它线程。局部的指针和引用不应该在它们的范围外存在。`lambdas`按引用捕获就是把局部对象的引用存储起来。如果这会导致超过局部变量生命周期的引用存在，则不应该按引用捕获。
+
+**示例**
+
+```cpp
+// 不好
+void Foo() {
+  int local = 42;
+  // 按引用捕获 local.
+  // 当函数返回后，local 不再存在，
+  // 因此 Process() 的行为未定义!
+  threadPool.QueueWork([&]{ Process(local); });
+}
+
+// 好
+void Foo() {
+  int local = 42;
+  // 按值捕获 local。
+  // 因为拷贝，Process() 调用过程中，local 总是有效的
+  threadPool.QueueWork([=]{ Process(local); });
+}
+```
+
+### <a name="a10-3-2"></a>建议10.3.2 如果捕获`this`，则显式捕获所有变量
+**理由**
+在成员函数中的`[=]`看起来是按值捕获。但因为是隐式的按值获取了`this`指针，并能够操作所有成员变量，数据成员实际是按引用捕获的，一般情况下建议避免。如果的确需要这样做，明确写出对`this`的捕获。
+
+**示例**
+
+```cpp
+class MyClass {
+ public:
+  void Foo() {
+    int i = 0;
+
+    auto Lambda = [=]() { Use(i, data_); };   // 不好: 看起来像是拷贝/按值捕获，成员变量实际上是按引用捕获
+
+    data_ = 42;
+    Lambda(); // 调用 use(42);
+    data_ = 43;
+    Lambda(); // 调用 use(43);
+
+    auto Lambda2 = [i, this]() { Use(i, data_); }; // 好，显式指定按值捕获，最明确，最少的混淆
+  }
+
+ private:
+  int data_ = 0;
+};
+```
+
+### <a name="a10-3-3"></a>建议10.3.3 避免使用默认捕获模式
+**理由**
+lambda表达式提供了两种默认捕获模式：按引用（&）和按值（=）。
+默认按引用捕获会隐式的捕获所有局部变量的引用，容易导致访问悬空引用。相比之下，显式的写出需要捕获的变量可以更容易的检查对象生命周期，减小犯错可能。
+默认按值捕获会隐式的捕获this指针，且难以看出lambda函数所依赖的变量是哪些。如果存在静态变量，还会让阅读者误以为lambda拷贝了一份静态变量。
+因此，通常应当明确写出lambda需要捕获的变量，而不是使用默认捕获模式。
+
+**错误示例**
+```cpp
+auto func() {
+  int addend = 5;
+  static int baseValue = 3;
+
+  return [=]() {    // 实际上只复制了addend
+    ++baseValue;    // 修改会影响静态变量的值
+    return baseValue + addend;
+  };
+}
+```
+
+**正确示例**
+```cpp
+auto func() {
+  int addend = 5;
+  static int baseValue = 3;
+
+  return [addend, baseValue = baseValue]() mutable {  // 使用C++14的捕获初始化拷贝一份变量
+    ++baseValue;    // 修改自己的拷贝，不会影响静态变量的值
+    return baseValue + addend;
+  };
+}
+```
+
+参考：《Effective Modern C++》：Item 31: Avoid default capture modes.
+
+## <a name="c10-4"></a> 接口
+### <a name="a10-4-1"></a>建议10.4.1 不涉及所有权的场景，使用`T*`或`T&`作为参数，而不是智能指针
+**理由**
+1. 只在需要明确所有权机制时，才通过智能指针转移或共享所有权.
+2. 通过智能指针传递，限制了函数调用者必须使用智能指针(如调用者希望传递`this`)。
+3. 传递共享所有权的智能指针存在运行时的开销。
+
+**示例**
+
+```cpp
+// 接受任何 int*
+void F(int*);
+
+// 只能接受希望转移所有权的 int
+void G(unique_ptr<int>);
+
+// 只能接受希望共享所有权的 int
+void G(shared_ptr<int>);
+
+// 不改变所有权，但需要特定所有权的调用者
+void H(const unique_ptr<int>&);
+
+// 接受任何 int
+void H(int&);
+
+// 不好
+void F(shared_ptr<Widget>& w) {
+  // ...
+  Use(*w); // 只使用 w -- 完全不涉及生命周期管理
+  // ...
+};
+```
+
+
+# <a name="c11"></a> 11 安全编码规范
+
+## <a name="c11-1"></a> 基本原则
+
+1. 程序在处理外部数据时必须经过严格的合法性校验。编程人员在处理外部数据过程中必须时刻保持这种思维意
+识，不能做出任何外部数据符合预期的假设，外部数据必须经过严格判断后才能使用。编码人员必须在这种严
+酷的攻击环境下通过遵守这一原则保证程序的执行过程符合预期结果。
+2. 尽量减少代码的攻击面，代码的实现应该尽量简单，避免与外部环境做多余的数据交互，过多的攻击面增加了
+被攻击的概率，尽量避免将程序内部的数据处理过程暴露到外部环境。
+3. 通过防御性的编码策略来弥补潜在的编码人员的疏忽。粗心是人类的天性。由于外部环境的不确定性，以及编
+码人员的经验、习惯的差异，代码的执行过程很难达到完全符合预期设想的情况。因此在编码过程中必须采取
+防御性的策略，尽量缓解由于编码人员疏忽导致的缺陷。这些措施包括：
+
+- 变量声明应该赋予初值
+- 谨慎使用全局变量
+- 避免使用功能复杂、易用错的函数
+- 禁用易用错的编译器/操作系统的机制
+- 小心处理资源访问过程
+- 不要改变操作系统的运行环境（创建临时文件、修改环境变量、创建进程等）
+- 严格的错误处理
+- 合理使用调试断言（ASSERT）
+
+## <a name="c11-2"></a> 变量
+
+### <a name="r11-2-1"></a>规则11.2.1 指针变量、表示资源描述符的变量、BOOL变量声明必须赋予初值
+
+说明：变量声明赋予初值，可以避免由于编程人员的疏忽导致的变量未初始化引用。
+
+正确示例：
+
+```cpp
+SOCKET s = INVALID_SOCKET;
+unsigned char *msg = nullptr;
+int fd = -1;
+```
+
+错误示例：以下代码，由于变量声明未赋予初值，在最后free的时候出错。
+
+```cpp
+char *message; // 错误！必须声明为 char *message = nullptr;
+
+if (condition) {
+  message = (char *)malloc(len);
+}
+
+if (message != nullptr) {
+  free(message); //如果condition未满足，会造成free未初始化的内存。
+}
+```
+
+### <a name="r11-2-2"></a>规则11.2.2 指向资源句柄或描述符的变量，在资源释放后立即赋予新值
+
+说明：资源释放后，对应的变量应该立即赋予新值，防止后续又被重新引用。如果释放语句刚好在变量作用域的最后一句，可以不进行赋值。
+
+正确示例：
+
+```cpp
+SOCKET s = INVALID_SOCKET;
+...
+closesocket(s);
+s = INVALID_SOCKET;
+
+unsigned char *msg = nullptr;
+...
+free(msg);
+msg = nullptr;
+```
+
+### <a name="r11-2-3"></a>规则11.2.3 同一个函数内，局部变量所占用的空间不要过大
+
+程序在运行期间，函数内的局部变量保存在栈中，栈的大小是有限的。如果申请过大的静态数组，可能导致出现运行
+出错。 建议在申请静态数组的时候，大小不超过0x1000。
+
+下面的代码，buff申请过大，导致栈空间不够，程序发生stackoverflow异常。
+
+```c++
+constexpr int MAX_BUF = 0x1000000;
+int Foo() {
+    char buff[MAX_BUFF] = {0}; // Bad
+    ...
+}
+```
+
+## <a name="c11-3"></a> 断言
+
+### 断言使用原则
+
+目前代码中有两种断言：一种是ASSERT，用于在DEBUG模式进行条件判定，条件不满足时程序直接退出；一种是CHECK_FATAL，用于检测运行时异常，条件不满足时程序直接退出。
+
+适用用CHECK_FATAL的情况：主要是输入、资源申请等不受控情况。示例：
+
+```cpp
+CHECK_FATAL(mplName.rfind(kMplSuffix) != std::string::npos, "File name %s does not contain .mpl", mplName.c_str()); // 文件名不符合要求
+
+CHECK_FATAL(intrinCall->GetReturnVec().size() == 1, "INTRN_JAVA_FILL_NEW_ARRAY should have 1 return value"); // 逻辑约束不满足
+
+CHECK_FATAL(func->GetParamSize() <= 0xffff, "Error:the argsize is too large"); // 输入合法性较验
+
+void *MemPool::Malloc(size_t size) {
+  ...
+  CHECK_FATAL(b != nullptr, "ERROR: Malloc error"); // 内存申请失败
+}
+```
+
+适合用ASSERT的情况，用于bug定位，防御性编程。示例：
+
+```cpp
+ASSERT(false, "should not be here");
+
+ASSERT(false, "Unknown opcode for FoldIntConstComparison");
+```
+
+### <a name="a11-3-1"></a>建议11.3.1 上下文安全的指针，不用使用断言较验其是否为nullptr
+
+说明：编译器是离线编译工具，进程崩溃的影响相对在线服务要小很多，可以适当减少防御性编程方式。因此，并不是所有入参都需要较验空指针，而是通过上下文逻辑来判断是否需要较验空指针。逻辑上不可能为nullptr的入参，可以不用较验。确定需要较验的，参考断言使用原则。
+
+### <a name="a11-3-2"></a>建议11.3.2 上下文安全的数组下标，不用使用断言较验数组是否越界
+
+说明：同空指针原则一样，通过逻辑来判断是否需要用断言进行数组越界较验。确定需要添加的，参考断言使用原则。
+
+### <a name="a11-3-3"></a>建议11.3.3 上下文安全的情况，不用使用断言较验整数溢出、截断、回绕
+
+说明：加法或乘法导致的整数溢出，如果逻辑保证的，可以不用较验。整数类型转换也可能导致截断、回绕，如果是逻辑保证的，可以不用较验。确定需要较验的，参考断言使用原则。
+
+如果希望容错，逻辑继续运行的，可以用条件语句进行较验。
+
+### <a name="r11-3-1"></a>规则11.3.1 运行时可能会导致的错误，严禁使用ASSERT断言
+
+错误示例：
+
+```cpp
+FILE *fp = fopen(path, "r");
+ASSERT(fp != nullptr, "nullptr check"); //错误用法：文件有可能打开失败
+
+char *str = (char *)malloc(MAX_LINE);
+ASSERT(str != nullptr, "nullptr check"); //错误用法：内存有可能分配失败
+ReadLine(fp, str);
+```
+
+### <a name="r11-3-2"></a>规则11.3.2 严禁在断言内改变运行环境
+
+说明：在程序正式发布阶段，断言不会被编译进去，为了确保调试版和正式版的功能一致性，严禁在断言中使用任何赋值、
+修改变量、资源操作、内存申请等操作。
+
+例如，以下的断言方式是错误的：
+
+```cpp
+ASSERT(i++ > 1000); // p1被修改
+ASSERT(close(fd) == 0); // fd被关闭
+```
+
+## <a name="c11-4"></a> 异常机制
+
+### <a name="r11-4-1"></a>规则11.4.1 禁用C++异常机制
+
+说明：严禁使用C++的异常机制，所有的错误都应该通过错误值在函数之间传递并做相应的判断, 而不应该通过异常机制进行错误处理。
+
+编码人员必须完全掌控整个编码过程，建立攻击者思维，增强安全编码意识，主动把握有可能出错的环节。而使用C++异常机制进行错误处理，会削弱编码人员的安全意识。
+
+异常机制会打乱程序的正常执行流程，使程序结构更加复杂，原先申请的资源可能会得不到有效清理。
+
+异常机制导致代码的复用性降低，使用了异常机制的代码，不能直接给不使用异常机制的代码复用。
+
+异常机制在实现上依赖于编译器、操作系统、处理器，使用异常机制，导致程序执行性能降低。
+
+在二进制层面，程序被加载后，异常处理函数增加了程序的被攻击面，攻击者可以通过覆盖异常处理函数地址，达到
+攻击的效果。
+
+## <a name="c11-5"></a> 内存
+
+### <a name="r11-5-1"></a>规则11.5.1 内存申请前，必须对申请内存大小进行合法性校验
+
+内存申请的大小可能来自于外部数据，必须检查其合法性，防止过多地、非法地申请内存。不能申请0长度的内存。
+例如：
+```cpp
+int Foo(int size) {
+  if (size <= 0) {
+    //error
+    ...
+  }
+  ...
+  char *msg = (char *)malloc(size);
+  ...
+}
+```
+
+### <a name="r11-5-2"></a>规则11.5.2 内存分配后必须判断是否成功
+
+```cpp
+char *msg = (char *)malloc(size);
+if (msg != nullptr) {
+  ...
+}
+```
+
+## <a name="c11-6"></a> 危险函数
+
+### <a name="r11-6-1"></a>规则11.6.1 禁止使用内存操作类危险函数
+C标准的许多函数，没有将目标缓冲区的大小作为参数，并且未考虑到内存重叠、非法指针的情况，在使用中很容易引入缓冲区溢出等安全漏洞。
+
+基于历史缓冲区溢出漏洞触发的情况统计，有很大一部分是因为调用了这些内存操作类函数但未考虑目标缓冲区大小而导致。
+以下列出了部分内存操作类危险函数：
+
+内存拷贝函数：memcpy(), wmemcpy(), memmove(), wmemmove()
+
+内存初始化函数：memset()
+
+字符串拷贝函数：strcpy(), wcscpy(),strncpy(), wcsncpy()
+
+字符串拼接函数：strcat(), wcscat(),strncat(), wcsncat()
+
+字符串格式化输出函数：sprintf(), swprintf(), vsprintf(), vswprintf(), snprintf(), vsnprintf()
+
+字符串格式化输入函数：scanf(), wscanf(), vscanf(), vwscanf(), fscanf(),fwscanf(),vfscanf(),vfwscanf(),sscanf(), swscanf(), vsscanf(), vswscanf() 
+
+stdin流输入函数：gets() 
+请使用对应的安全函数(详细信息请参考huawei_secure_c)。
+
+例外：在下列情况下，由于未涉及到外部数据处理，不存在被攻击的场景，内存操作完全在本函数内完成，不存在因外部控制而失败的可能性。
+如果使用安全函数反而造成代码的冗余，可以留用危险函数：
+
+（1）对固定长度的数组进行初始化，或对固定长度的结构体进行内存初始化：
+```cpp
+BYTE array[ARRAY_SIZE];
+
+void Foo() {
+  char destBuff[BUFF_SIZE];
+  ...
+  memset(array, c1, sizeof(array)); //对全局固定长度的数据赋值
+  ...
+  memset(destBuff, c2, sizeof(destBuff)); //对局部固定长度的数据赋值
+  ...
+}
+
+typedef struct {
+  int type;
+  int data;
+} Tag;
+
+Tag g_tag = {1, 2};
+
+void Foo() {
+  Tag dest;
+  ...
+  memcpy((void *)&dest, (const void *)&g_tag, sizeof(Tag)); //对固定长度结构体赋值
+  ...
+}
+```
+
+（2）函数参数中有表示内存的参数，对该内存进行初始化：
+```cpp
+void Foo(BYTE *buff1, size_t len1, BYTE *buff2, size_t len2) {
+  ...
+  memset(buff1, 0, len1); //对buff1清0
+  memset(buff2, 0, len2); //对buff2清0
+  ...
+}
+```
+
+（3）从堆中分配内存后，赋予初值：
+```cpp
+size_t len = ...
+char *str = (char *)malloc(len);
+if (str != nullptr) {
+  memset(str, 0, len);
+  ...
+}
+```
+
+（4）根据源内存的大小进行同等大小的内存复制：
+以下代码基于srcSize分配了一块相同大小的内存，并复制过去：
+```cpp
+BYTE *src = ...
+size_t srcSize = ...
+BYTE *destBuff = new BYTE[srcSize];
+memcpy(destBuff, src, srcSize);
+```
+
+以下代码根据源字符串的大小分配一块相同的内存，并复制过去：
+```cpp
+char *src = ...
+size_t len = strlen(src);
+if (len > BUFF_SIZE) {
+  ...
+}
+char *destBuff = new char[len + 1];
+strcpy(destBuff, src);
+```
+
+（5）源内存全部是静态字符串常量（编码时需要检查目标内存是否足够的存储空间）：
+以下代码直接将字符串常量“hello”复制到数组中：
+```cpp
+char destBuff[BUFF_SIZE];
+strcpy(destBuff, "hello");
+```
+以下代码对静态字符串常量进行拼接：
+```cpp
+const char *list[] = {"red","green","blue"};
+char destBuff[BUFF_SIZE];
+sprintf(destBuff, "hello %s", list[i]);
+```
diff --git a/doc/cn/RcApi.md b/doc/cn/RcApi.md
new file mode 100644
index 0000000000000000000000000000000000000000..7a3777a7c277ecef8771dea1b3f9048ee35ea8fa
--- /dev/null
+++ b/doc/cn/RcApi.md
@@ -0,0 +1,524 @@
+RC API
+----
+
+引用计数(Reference Counting, RC)是计算机编程语言中的一种内存管理技术，是指将资源（可以是对象、内存或磁盘空间等等）的被引用次数保存起来，当被引用次数变为零时就将其释放的过程。使用引用计数技术可以实现自动资源管理的目的。同时引用计数还可以指使用引用计数技术回收未使用资源的垃圾回收算法。
+
+由于需要支持RC操作，运行时为方舟编译器提供了如下API，以便其更好的生成相关代码。
+
+## void MCC\_IncRef\_NaiveRCFast(address\_t obj)
+
+**功能说明:**
+
+将对象的RC值原子性的加一。
+
+**入参说明:**
+
+obj, 堆对象指针。
+
+**返回值：**
+
+无
+
+## void MCC\_DecRef\_NaiveRCFast(address\_t obj)
+
+**功能说明：**
+
+将对象的RC值原子性的减一。
+
+**入参说明:**
+
+obj, 堆对象指针。
+
+**返回值：**
+
+无
+
+## void MCC\_ClearLocalStackRef(address\_t \*addr)
+
+**功能说明：**
+
+用来清理线程栈上的局部引用（Local Reference）。当前编译框架下为支持异常和GC，此函数可以将对应栈地址上的局部引用清零，并将其老值的RC原子性的减一。
+
+**入参说明:**
+
+addr, 栈上局部引用的地址。
+
+**返回值：**
+
+无
+
+## void MCC\_IncDecRef\_NaiveRCFast(address\_t incObj, address\_t decObj)
+
+**功能说明：**
+
+用来将incObj指向的对象的RC值原子性的加一和将decObj指向的对象的RC原子性的减一。
+
+**入参说明:**
+
+incObj，需要将RC原子性加一的对象地址。
+
+decObj，需要将RC原子性减一的对象地址。
+
+**返回值：**
+
+无
+
+## void MCC\_IncDecRefReset(address\_t incObj, address\_t \*decAddr)
+
+**功能说明：**
+
+将incObj指向的对象的RC值原子性的加一，并将栈地址指针decAddr存放的局部变量对象的RC原子性的减一，同时将栈地址指针decAddr指向的内存清零。
+
+**入参说明:**
+
+incObj，需要将RC原子性加一的堆对象。
+
+decAddr，栈上局部引用的地址。
+
+**返回值：**
+
+无
+
+## void MCC\_DecRefResetPair(address\_t \*decAddr0, address\_t \*decAddr1)
+
+**功能说明：**
+
+将所有参数指向的栈地址空间清零，并将对应包含的局部变量老值的RC原子性的减一。
+
+**入参说明:**
+
+decAddr0和decAddr1，栈上局部引用的地址。
+
+**返回值：**
+
+无
+
+## void MCC\_SetObjectPermanent(address\_t obj)
+
+**功能说明：**
+
+将堆对象设置成永久存活的对象，调用之后obj对应的对象的RC会变成极大值。
+
+**入参说明:**
+
+obj的堆对象地址。
+
+**返回值：**
+
+无
+
+## address\_t MCC\_LoadVolatileStaticField(address\_t \*fieldAddr)
+
+**功能说明：**
+
+从易失性（Volatile）静态变量中取值，并且将取到的堆对象的RC原子性的加一。
+
+**入参说明:**
+
+fieldAddr，Volatile静态变量的地址。
+
+**返回值：**
+
+返回Volatile静态变量的值。
+
+## address\_t MCC\_LoadRefStatic(address\_t \*fieldAddr)
+
+**功能说明：**
+
+从静态变量中取值，并且将取到的堆对象的RC原子性的加一。
+
+**入参说明:**
+
+fieldAddr，静态变量的地址。
+
+**返回值：**
+
+返回静态变量的值。
+
+## address\_t MCC\_LoadVolatileWeakField(address\_t obj, address\_t \*fieldAddr)
+
+**功能说明：**
+
+从Weak的Volatile字段中取值， 如果取到非空的堆对象，会将该对象的RC原子性的加一。
+
+**入参说明:**
+
+obj，堆对象地址。
+
+fieldAddr，标记为Weak的Volatile字段的地址
+
+**返回值：**
+
+返回标记为Weak的Volatile字段中的值，有可能返回空对象指针。
+
+## address\_t MCC\_LoadWeakField(address\_t obj, address\_t \*field\_addr)
+
+**功能说明：**
+
+从Weak的字段中取值，如果取到非空的堆对象，会将该对象的RC原子性的加一。
+
+**入参说明:**
+
+obj，堆对象地址。
+
+fieldAddr，标记为Weak的字段的地址
+
+**返回值：**
+
+返回标记为Weak的字段中的值，有可能返回空对象指针。
+
+## address\_t MCC\_LoadRefField\_NaiveRCFast(address\_t obj, address\_t \*fieldAddr)
+
+**功能说明：**
+
+从fieldAddr字段取值，并将取到的堆对象的RC原子性的加一。
+
+**入参说明:**
+
+obj，堆对象地址。
+
+fieldAddr，对象对应字段的地址
+
+**返回值：**
+
+返回对象字段中存储的值。
+
+## address\_t MCC\_LoadVolatileField(address\_t obj, address\_t \*fieldAddr)
+
+**功能说明：**
+
+从Volatile字段中取值，并将取到的堆对象的RC原子性的加一。
+
+**入参说明:**
+
+obj，堆对象地址。
+
+fieldAddr，对象对应Volatile字段的地址
+
+**返回值：**
+
+返回对象Volatile字段中存储的值。
+
+## void MCC\_WriteReferent(address\_t obj, address\_t value)
+
+**功能说明：**
+
+写入java.lang.ref.Reference的referent字段，如果取到非空的堆对象，会将该对象的RC原子性的加一。
+
+**入参说明:**
+
+obj，java.lang.ref.Reference对象地址。
+
+value，作为referent的堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteVolatileStaticFieldNoInc(address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向Volatile静态变量中写入堆对象，此调用不改变写入的堆对象的RC，但是会将静态变量存储的老值的RC原子性的减一。
+
+**入参说明:**
+
+fieldAddr，Volatile静态变量的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteVolatileStaticFieldNoDec(address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向Volatile静态变量中写入堆对象，此调用会将新写入的堆对象value的RC原子性的加一，但是不将静态变量的老值减一。
+
+**入参说明:**
+
+fieldAddr，Volatile静态变量的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteVolatileStaticFieldNoRC(address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向Volatile静态变量中写入堆对象，此调用不会改变写入的新值（value）的RC，也不会改变老值（fieldAddr存放的值）的RC。
+
+**入参说明:**
+
+fieldAddr，Volatile静态变量的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteVolatileStaticField(address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向Volatile静态变量中写入堆对象，此调用会将新写入的堆对象value的RC原子性的加一，但是并将静态变量的老值的RC减一。
+
+**入参说明:**
+
+fieldAddr，Volatile静态变量的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteRefFieldStaticNoInc(address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象普通静态变量字段中写入堆对象value，此调用不会将新写入的堆对象value的RC原子性的加一，但是会将其存储的老值的RC减一。
+
+**入参说明:**
+
+fieldAddr，对象静态变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteRefFieldStaticNoDec(address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象普通静态变量字段中写入堆对象value，此调用会将新写入的堆对象value的RC原子性的加一，但是不会将其存储的老值的RC减一。
+
+**入参说明:**
+
+fieldAddr，对象静态变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteRefFieldStaticNoRC(address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象普通静态变量字段中写入堆对象value，此调用不会将新写入的堆对象value的RC原子性的加一，也不会将其存储的老值的RC减一。
+
+**入参说明:**
+
+fieldAddr，对象静态变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteRefFieldStatic(address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象普通静态变量字段中写入堆对象value，此调用会将新写入的堆对象value的RC原子性的加一，同时会将其存储的老值的RC减一。
+
+**入参说明:**
+
+fieldAddr，对象静态变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteVolatileFieldNoInc(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象Volatile变量字段中写入堆对象value，此调用不会将新写入的堆对象value的RC原子性的加一，但是会将其存储的老值的RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象volatile变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteVolatileFieldNoDec(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象Volatile变量字段中写入堆对象value，此调用会将新写入的堆对象value的RC原子性的加一，但是不会并将其存储的老值的RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象volatile变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteVolatileFieldNoRC(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象Volatile变量字段中写入堆对象value，此调用不会将新写入的堆对象value的RC原子性的加一，也不会将其存储的老值的RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象volatile变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteVolatileField(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象Volatile变量字段中写入堆对象value，此调用会将新写入的堆对象value的RC原子性的加一，也会将其存储的老值的RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象volatile变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteRefFieldNoInc(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象普通变量字段中写入堆对象value，此调用不会将新写入的堆对象value的RC原子性的加一，但是会将其存储的老值的RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象普通变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteRefFieldNoDec(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象普通变量字段中写入堆对象value，此调用会将新写入的堆对象value的RC原子性的加一，但是不会将其存储的老值的RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象普通变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteRefFieldNoRC(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象普通变量字段中写入堆对象value，此调用不会将新写入的堆对象value的RC原子性的加一，也不会将其存储的老值的RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象普通变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteRefField(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象普通变量字段中写入堆对象value，此调用会将新写入的堆对象value的RC原子性的加一，也会将其存储的老值的RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象普通变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteVolatileWeakField(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象标记为Weak的volatile变量字段中写入堆对象value，此调用会将新写入的堆对象value的Weak RC原子性的加一，也会将其存储的老值的Weak RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象标记为Weak的volatile变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
+
+## void MCC\_WriteWeakField(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**功能说明：**
+
+向对象标记为Weak的普通变量字段中写入堆对象value，此调用会将新写入的堆对象value的Weak RC原子性的加一，也会将其存储的老值的Weak RC减一。
+
+**入参说明:**
+
+obj，对象的地址
+
+fieldAddr，对象标记为Weak的普通变量字段的地址。
+
+value，待写入堆对象地址
+
+**返回值：**
+
+无。
diff --git a/doc/cn/VtableItableDescription.md b/doc/cn/VtableItableDescription.md
new file mode 100644
index 0000000000000000000000000000000000000000..a7092d0f45a7042919897e16f92af2c3e576e575
--- /dev/null
+++ b/doc/cn/VtableItableDescription.md
@@ -0,0 +1,401 @@
+# 虚函数表和接口函数表设计介绍
+
+## 虚函数表
+
+方舟编译器会为每一个类生成一个虚方法表。在这个表中，会存储父类的虚方法，再加上子类的虚方法以及实现的接口类的Default方法。如果子类重载了父类的实现，那么在虚方法表中同样的位置，则会覆盖掉父类的方法。
+
+下面，展示一个具体 的例子：
+
+```java
+class A {
+  public int first() {
+    return 0;
+  }
+}
+
+class B extends A {
+  public void foo() {
+  }
+  public int first() {
+    return 1;
+  }
+}
+
+class C extends A {
+  public void bar() {
+  }
+  public int first() {
+    return 2;
+  }
+}
+
+public class IsEmpty {
+  public static void main(String [] args) {
+    A x = new B();
+    x.first();
+    A y = new C()
+    y.first();
+  }
+
+  public void add(A x) {
+    x.first();
+  }
+}
+```
+
+
+
+方舟编译器生成的虚函数表的结构如下：
+
+A:
+```
+ _vtb_LA_3B:
+        .quad   Ljava_2Flang_2FObject_3B_7Cclone_7C_28_29Ljava_2Flang_2FObject_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cfinalize_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CgetClass_7C_28_29Ljava_2Flang_2FClass_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7ChashCode_7C_28_29I - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cnotify_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CnotifyAll_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CtoString_7C_28_29Ljava_2Flang_2FString_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28J_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28JI_29V - .
+        .quad   LA_3B_7Cfirst_7C_28_29I - .
+```
+
+B:
+
+```
+ __vtb_LB_3B:
+        .quad   Ljava_2Flang_2FObject_3B_7Cclone_7C_28_29Ljava_2Flang_2FObject_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cfinalize_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CgetClass_7C_28_29Ljava_2Flang_2FClass_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7ChashCode_7C_28_29I - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cnotify_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CnotifyAll_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CtoString_7C_28_29Ljava_2Flang_2FString_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28J_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28JI_29V - .
+        .quad   LB_3B_7Cfirst_7C_28_29I - .
+        .quad   LB_3B_7Cfoo_7C_28_29V - .
+```
+C：
+```
+__vtb_LC_3B:
+前面11个和A和B一样
+       … …
+       .quad   LC_3B_7Cfirst_7C_28_29I - .
+       .quad   LC_3B_7Cbar_7C_28_29V - .
+
+```
+
+对比一下，我们可以发现：
+
+1. 所有的类都是继承自Object类，所以虚函数表的前面11个函数都是继承自Object，且和父类Object布局保持一致。
+2. 对于第12个函数，子类B覆盖了父类A，所以在同样的位置，父类是LA_3B_7Cfirst_7C_28_29I，子类是LB_3B_7Cfirst_7C_28_29I。类C继承至类A并重写了first函数，且实现了接口iD，所以12的位置为 LC_3B_7Cfirst_7C_28_29I，接口函数LiD_3B_7Csecond_7C_28_29I被放在了13的位置。
+
+## 虚函数访问处理(编译时)
+
+因为要保持多态性，所以在编译时，不能确定具体调用是哪个函数。在当前例子里面体现在这个位置：
+
+```java
+public class IsEmpty {
+  public static void main(String [] args) {
+    A x = new B();
+    x.first();
+    A y = new C();
+    y.first();
+  }
+
+  public void add(A x) {
+    x.first();
+  }
+}
+```
+
+
+像这种情况，我们编译时不能知道运行时调用的是B里面的first函数，还是C里面的first函数。
+
+但是，因为first函数在A，B，C中布局一致，而这个例子当中first函数在vtab中的偏移是12，因此我们可以生成这样的访问代码：从相应的对象中拿到vtable指针，然后加上offset12。这样我们就能访问到正确的函数。
+
+## 虚函数调用处理(运行时)
+
+在程序执行过程中，以(图1)为例，当遇到虚拟函数调用的时候，我们执行如下步骤：
+1. 判断对象(this_指针)是哪个类的实例(在图1中，this是类C的实例)；
+2. 使用函数索引在对应类的虚拟函数表中查找；
+3. 返回实际调用的函数指针。
+
+![](media/javavmt.png)
+<center>图1: Java虚拟函数调用的静态化</center>
+
+## 接口函数表
+
+Interface call类似于多重继承，比java单继承要复杂。多继承无法天然地确定唯一一个继承顺序。
+
+在一个封闭的环境下，可以通过拓扑排序的方法确定一个顺序(iA，iB，iC)。好处是可以实现像虚函数表一样的访问方式来处理interface call。但是这样得到的一个类的itable会非常大，而且大部分是空洞。考虑到性能和代码大小，这种方法是不可用的。
+
+![](media/Topology.png)
+
+
+对于开放的环境，编译时刻是无法通过拓扑排序来确定一个顺序的，导致接口函数表里的方法顺序不固定，所以实际实现中没办法像虚函数调用一样实现一个顺序一致的方法表和访问形式为 offset 的访问机制。在编译时刻，可以确定一个类实现的所有接口，以及接口的继承关系。运行时对函数签名进行比较来确定需要调用的函数。因为字符串比较开销比较大，所以方舟编译器会在编译时刻对函数名字和签名进行哈希计算得出哈希值。运行时首先比较哈希值；如果哈希值相同，且不存在哈希冲突，则调用这个函数。如果存在哈希冲突，则进行函数名字和签名的比较，取得函数指针。
+
+同时，考虑到运行时效率和 ROM 空间的原因，我们把 Itable 分成了两级表，第一级表为真正的 hash ，考虑到ROM空间的压力，我们把 hash 值设为23，然后，依据 hash 得到的值把函数地址填到这个值对应的位置上去（0~22）。如果我们一级 hash 表不发生冲突的话，那么在最后一个包含函数地址的位置之后的表项都是空白的，这样后面的表项可以被去掉而不需要占用空间。如果一级 hash 表发生冲突了，则在发生冲突的位置填0，然后在第23个 slot 的位置填上二级表的地址。
+
+一级函数表结构如下：
+
+<table style="width: 600px;">
+  <tr>
+    <th width="50px">表序</th>
+    <th width="150px">接口函数表项</th>
+    <th width="400px">说明</th>
+  </tr>
+  <tr>
+    <td>0</td>
+    <td>&Func 或 0</td>
+    <td rowspan="5">对应Hash值的函数地址，没有则为0; 如果出现冲突，那么冲突的位置也为0，并且在第23个表项填上二级表的地址; 如果没有冲突，那么将最后一个有对应函数的hash值( n )之后的表项删除</td>
+  </tr>
+  <tr>
+    <td>1</td>
+    <td>&Func 或 0</td>
+  </tr>
+  <tr>
+    <td>2</td>
+    <td>&Func 或 0</td>
+  </tr>
+  <tr>
+    <td>...</td>
+    <td>&Func 或 0</td>
+  </tr>
+  <tr>
+    <td>n</td>
+    <td>&Func</td>
+  </tr>
+   <tr>
+    <td>23</td>
+    <td>&itbC</td>
+    <td>二级表的地址。如果一级表没有出现冲突，则该项不存在</td>
+  </tr>
+</table>
+
+
+二级函数表的结构如下：
+
+| 接口函数表项          | 说明                                             |
+|----------------------|--------------------------------------------------|
+| Size                 | 不冲突的接口函数表的大小                         |
+| 1                    | 对齐站位作用，无实际意义                         |
+| Func1_sig            | Func1签名的哈希值                                |
+| &Func1               | Fun1的地址                                       |
+| Func2_sig            | Func2签名的哈希值                                |
+| &Func2               | Func2的地址                                      |
+| ......               |                                                  |
+| Func3_sig和Func4_sig | Func3签名的哈希值和Func4签名的哈希值，两个值相同 |
+| 1                    | 表示冲突，因为func3和func4签名的哈希值一样       |
+| ……                   |                                                  |
+| Func3_sig            | Func3签名                                        |
+| &Func3               | Func3的地址                                      |
+| Func4_sig            | Func4签名                                        |
+| &Func4               | Func4的地址                                      |
+| ……                   |                                                  |
+
+## 接口函数调用：
+
+对于声明为如下形式的接口函数调用的情况，我们的调用过程如图2所示：
+
+```java
+interface B { funcB(); }
+interface C { funcC(); }
+interface D { funcD(); }
+Class A implements B, C, D {}
+```
+
+![](media/interface1.jpg)
+
+<center>图2：Java接口函数调用的静态化</center>
+
+
+如图2所示，在程序执行过程中，我们执行如下步骤：
+
+1. 判断对象(obj)是哪个类的实例，当前为类A的实例；
+2. 根据hash值，在一级表中查找，存在则返回函数指针，如果对应位置为0，则通过二级表查找。在二级表中，使用函数签名的哈希值查找，如果找到就返回函数指针，否则用函数名查找；
+3. 间接调用函数指针，并把相关的参数(args)传给间接调用。
+
+下面，举一个具体的例子：
+
+这个IsEmpty类实现了接口A和B，每个接口中声明有两个方法。
+
+```java
+interface A{
+  public int add();
+  public int minus();
+}
+
+interface B{
+  public int mult();
+  public int div();
+}
+
+public class IsEmpty implements A, B {
+    public static void main(String[]args) {
+    }
+
+    public void test(B x) {
+      x.mult();
+    }
+
+    public int add() {
+      return 6 + 3;
+    }
+
+    public int minus() {
+      return 6 - 3;
+    }
+
+    public int mult() {
+      return 6 * 3;
+    }
+
+    public int div() {
+      return 6 / 3;
+    }
+}
+```
+
+首先，我们来看一下 IsEmpty 的 itable 在 maple 代码里面是怎么样的：
+
+```
+var $__itb_LIsEmpty_3B fstatic <[24] <* void>> = [0, 0, 0, 0, 0, 0, 0, 0, addroffunc ptr &LIsEmpty_3B_7Cdiv_7C_28_29I, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, addroffunc ptr &LIsEmpty_3B_7Cadd_7C_28_29I, 0, 0, addrof ptr $__itabC_LIsEmpty_3B]
+
+var $__itbC_LIsEmpty_3B fstatic <[6] <* void>> = [2, 1, 0xb97, addroffunc ptr &LIsEmpty_3B_7Cmult_7C_28_29I, 0x1f7f, addroffunc ptr &LIsEmpty_3B_7Cminus_7C_28_29I]
+```
+
+对应的汇编结构：
+
+```
+__itb_LIsEmpty_3B:
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   LIsEmpty_3B_7Cdiv_7C_28_29I - .
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   LIsEmpty_3B_7Cadd_7C_28_29I - .
+        .quad   0
+        .quad   0
+        .quad   __itabC_LIsEmpty_3B - .
+```
+```
+__itbC_LIsEmpty_3B:
+        .quad   2
+        .quad   1
+        .quad   2967
+        .quad   LIsEmpty_3B_7Cmult_7C_28_29I - .
+        .quad   8063
+        .quad   LIsEmpty_3B_7Cminus_7C_28_29I - .
+```
+
+其中表项内容如下：
+
+1. 一级表中(__itb_LIsEmpty_3B)，共23项，其中第9项和第20项为函数地址，第23项为二级表地址，由此可见一级表发生了冲突，从而需要二级表来确认具体的函数地址；
+
+2. 二级表中第一项为2，表示有2个不冲突的函数，第二项为1，起到对齐占位的作用，而后面4项分别为函数签名产生的hash值和对应的函数地址。
+
+接下来我们看到这个例子里面，源码中test函数中会产生一个interface-call，对应的maple代码如下：
+
+```
+if (eq u1 u64 (regread u64 %4, constval u64 0)) {
+  callassigned &MCC_getFuncPtrFromItabSecondHash64 (regread ptr %3, constval u64 0xb97, conststr ptr "mult|()I") { regassign u64 %4}
+}
+icallassigned (regread u64 %4, regread ref %2) {}
+```
+
+可以看出调用逻辑是这样的：
+
+首先判断一级itable表当中hash值对应位置表项是否为空，如果不空则直接使用该地址；如果为空，则调用 getFuncPtrFromItabSecondHash64 函数。
+
+getFuncPtrFromItabSecondHash64 函数有三个参数，itable 地址，函数 basename 对应的 hash 值，和函数的签名。完整的调用过程是先通过 classinfo 找到对应的 itable 地址，然后进行 hash 值的比对，如果比对成功且不冲突就能得到正确的地址；如果比对冲突，则直接使用 signature name 进行比对(字符串比对)。
+
+这里所访问的 itable 和上面列出的 IsEmpty 的itable表项形式一致。
+
+##  Interface override
+
+Java 8中引入了 `Default` 函数。父类中的实现会覆盖接口中的Default函数；接口之间的Default函数需要根据接口的继承关系来确定Override。如下所示，类cA继承类cB实现了接口iD，在cB和iD中都有foo的实现。对于cA来说，foo的实现来自父类cB而不是接口iD。
+
+```java
+
+interface iD {
+  public default void foo(){System.out.println("iD foo");}
+}
+
+class cB {
+  public void foo(){System.out.println("cB foo");}
+}
+
+class cA extends cB implements iD {
+}
+
+public class IsEmpty {
+  public static void main(String [] args) {
+    iD obj = new cA();
+    obj.foo();
+  }
+}
+```
+
+
+如下所示，接口Parent和Son都定义了getValue。对于类Sson来说，getValue的实现来自Son，而不是来自Parent。
+
+```java
+interface Parent{
+  default void getValue(){
+    System.out.println("Parent getVatue……");
+  }
+}
+
+interface Son extends Parent{
+  default void getValue(){
+    System.out.println("OfInt getValue……")
+  }
+}
+
+abstract class OfPrimitive implements Parent{
+}
+
+class SSon extends OfPrimitive implements Son{
+}
+
+public class Main {
+  static int get() {
+    return 1;
+  }
+  
+  public static void main(String[] args) {
+    Parent son = (Parent)new SSon();
+    son.getValue();
+
+    SSon son2;
+    if(get()==1) {
+      son2 = new SSon();
+    }
+    else son2 = new SSon();
+    son2.getValue();
+  }
+}
+```
diff --git a/doc/cn/media/MapleDriverStructure.png b/doc/cn/media/MapleDriverStructure.png
new file mode 100644
index 0000000000000000000000000000000000000000..adc5f98ba54d4ffb4430cb3bbff37e8e45d06214
Binary files /dev/null and b/doc/cn/media/MapleDriverStructure.png differ
diff --git a/doc/cn/media/Topology.png b/doc/cn/media/Topology.png
new file mode 100644
index 0000000000000000000000000000000000000000..6967780a1ac7addf7811b4271bbf805c6d659027
Binary files /dev/null and b/doc/cn/media/Topology.png differ
diff --git a/doc/cn/media/addphase.png b/doc/cn/media/addphase.png
new file mode 100644
index 0000000000000000000000000000000000000000..ed9b5fbfccb5a30ba1ac877952c6b5372a43dafa
Binary files /dev/null and b/doc/cn/media/addphase.png differ
diff --git a/doc/cn/media/interface1.jpg b/doc/cn/media/interface1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..7377546fc36b03b282e5d85d0a89fd274288f831
Binary files /dev/null and b/doc/cn/media/interface1.jpg differ
diff --git a/doc/cn/media/javavmt.png b/doc/cn/media/javavmt.png
new file mode 100644
index 0000000000000000000000000000000000000000..ef93f36923559321d0512a862ca9a1ff9d36a6b6
Binary files /dev/null and b/doc/cn/media/javavmt.png differ
diff --git a/doc/en/CPPCodingTalkAboutPointer.md b/doc/en/CPPCodingTalkAboutPointer.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e822efaa531cc7c8b7785c8a9f07748ce6a08d5
--- /dev/null
+++ b/doc/en/CPPCodingTalkAboutPointer.md
@@ -0,0 +1,266 @@
+# Discussion of Pointer in C++ Programming
+
+# Background
+
+The use of pointers in `C/C++` is flexible and accompanied by many security risks, which poses higher requirements on programmers. This document will discuss how to use raw pointers in `C/C++` and ultimately establish a coding paradigm.
+
+# Raw Pointer vs Reference
+
+## Member access.
+
+When an object member is accessed, the raw pointer may be null (the validity of a pointer is logically ensured by a closed object or function). Therefore, invalid pointers must be checked, whereas the reference cannot be null and does not need to be checked.
+
+## Container members.
+
+In the semantics of `C++`, references express alias relationships, which do not occupy memory theoretically. (In practice, references are implemented internally as pointers in a compiler.) A reference is not an object in itself, which is different from a pointer. A pointer can be a container member, but a reference cannot.
+
+# Raw Pointer vs Smart Pointer
+
+## Destroy a heap object.
+
+```c++
+class Int {
+  ...
+private:
+  int data;
+}
+
+void test(int *in) {
+  Int* tmp = new Int();
+  ...
+  goto LABEL;
+  ...
+
+  delete tmp;
+LABEL:
+}
+```
+
+The use of resources (heap objects, stack objects, and file resources) complies with the principle that **"resources that are released in the same scope as they are acquired"** in Resource Acquisition Is Initialization (RAII), which minimizes the possibility of resource leakage.
+
+A segment of processing logic and sub-function calling are usually involved between `new` and `delete` of a raw pointer. The intermediate processing logic may encounter exceptions or jumps. (The current object will not go beyond authority to restrict the behavior of the intermediate processing logic, which exceeds the management scope of `new`.) The resource release is skipped due to exceptions or jumps, causing resource leakage (for example, the `tmp` object in the `test` function in the preceding example).
+
+The smart pointer is reconstructed to `auto tmp = std::make_unique<Int>();`. When the `tmp` object is constructed, the `delete` behavior is bound and the current scope is destroyed, preventing resource leakage.
+
+## Management permission vs use permission.
+
+```c++
+int *delete(int *in);
+```
+
+Management permission: Destroy and rebuild objects.
+
+Use permission: Access and modify objects.
+
+As shown in the preceding example, when a raw pointer is used to transfer parameters, the use of the **management permission** or **use permission** cannot be determined by the input parameter `in` and output parameter because the raw pointer implies an attribute of transferring the ownership (possibly or not). Additional information is required when this function is called: Will the `in` parameter be destroyed by the `delete` function? Does the return value need to be destroyed by the caller?
+
+```c++
+std::unique_ptr<int> delete(std::unique_ptr<int> &in);
+```
+
+A smart pointer is used to specify a role of a parameter in an interface. For example, `std::unique_ptr& in` indicates that the `delete` function has the **use permission**, and the return value indicates that the `delete` function transfers the ownership.
+
+# Pointer Normalization
+
+## A destruction method must be immediately bound to an object created by `new`.
+
+Bad example:
+
+```c++
+Object *obj = new Object();
+...
+delete obj;
+```
+
+Good example:
+
+```c++
+std::unique_ptr<Object> obj = std::make_unique<Object>();
+```
+
+## A release method must be immediately bound to the applied resources.
+
+Bad example:
+
+```c++
+FILE *file = open("xxx.txt");
+...
+file->close();
+```
+
+Good example: (This example is commonly used. The best way is to encapsulate an application class `open`.)
+
+```c++
+template <typename T, typename Func>
+class ResourceGuard {
+ public:
+  ResourceGuard(T *_obj, Func _func) : obj(_obj), func(_func) {}
+
+  ~ResourceGuard() { obj.func(); }
+ private:
+  T *obj;
+  Func func;
+}
+
+FILE* file = open("xxx.txt");
+auto fileGuard = ResourceGuard<FILE, std::function<void()>>(file, FILE::close);
+...
+```
+
+## Use a reference instead of a pointer when the value is not null.
+
+Bad example:
+
+```c++
+void func1(int *in) {
+  if (in == nullptr) return;
+  ...
+}
+
+void func2() {
+  int *p = nullptr;
+  ...
+  if (p != nullptr) {
+    func1(p);
+  }
+}
+```
+
+Good example:
+
+```c++
+void func1(int &in) {
+  ...
+}
+
+void func2() {
+  int *p = nullptr;
+  ...
+  if (p != nullptr) {
+    func1(*p);
+  }
+}
+```
+
+## As a container member (without the management permission), use an encapsulated reference container instead of a pointer when the value is not null.
+
+Bad example:
+
+```c++
+void func(std::vector<int*> &in) {
+  for (auto *p : in) {
+    if (p == nullptr) {
+      continue;
+    }
+    ...
+  }
+}
+```
+
+Good example:
+
+```c++
+template <typename T>
+class Ref {
+ public:
+  Ref() = delete;
+  Ref(T &ref) : data(&ref) {}
+
+  ...
+
+  operator T() const noexcept {
+    return *data;
+  }
+
+ private:
+  T *data;
+}
+
+template <typename T>
+using ref_vector = std::vector<Ref<T>>;
+void func(ref_vector<int> &in) {
+  for (auto p : in) {
+  int &data = p;
+    ...
+  }
+}
+```
+
+## As a container member (with the management permission), use a container that has the lifecycle management permission instead of a pointer container.
+
+Bad example:
+
+```c++
+std::vector<int*> data;
+...
+for (auto *p : data) {
+  delete p;
+}
+```
+
+Good example:
+
+```c++
+template <typename T>
+class ptr_vector {
+public:
+  ~ptr_vector() {
+    for (auto *p : data) {
+      delete p;
+    }
+  }
+    
+private:
+  std::vector<T*> data;
+}
+
+ptr_vector<int> data;
+...
+```
+
+## Explicitly transfer an object management permission and specify an object use permission.
+
+`move` semantics is added to `C++11`, and `auto_ptr` is discarded. `unique_ptr` is used to explicitly transfer the ownership so that the lifecycle management methods of stack objects and heap objects can be unified.
+
+Example of stack object transfer:
+
+```c++
+std::vector<int> func() {
+  std::vector<int> data;
+  data.push_back(0);
+  return std::move(data);
+}
+```
+
+Example of fuzzy heap object transfer:
+
+```c++
+Object *func() {
+  std::unique_ptr<Object> data = std::make_unique<Object>();
+  Object &rData = ToRef(data);
+  rData.push_back(0);
+  return data.release();
+}
+```
+
+Example of clear heap object transfer:
+
+```c++
+std::unique_ptr<Object> func() {
+  std::unique_ptr<Object> data = std::make_unique<Object>();
+  Object &rData = ToRef(data);
+  rData.push_back(0);
+  return std::move(data);
+}
+```
+
+## Scenarios where pointers should be used.
+
+1. When a third-party library function transfers in or out a pointer, `unique_ptr.get()` or `unique_ptr.release()` must be used to construct input parameters before the function is called. After output parameters are obtained, `unique_ptr` must be used to catch or check whether the output parameters are null and convert the output parameters to references.
+2. As a container member (without the management permission), a null pointer is designed in the application scenario. However, the null pointer must be checked and converted to a reference immediately before use. Pointer diffusion is not supported.
+
+# Remarks
+
+`Ref` and `ref_vector` have been developed. `Ref` is defined as `SafePtr` because `operator.` cannot be reloaded.
+
+The `ResourceGuard` and `ptr_vector` are being developed and are mainly used as examples in this document.
diff --git a/doc/en/CompilerPhaseDescription.md b/doc/en/CompilerPhaseDescription.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d9870b21b9e96684973c1d9707298760fe9aae3
--- /dev/null
+++ b/doc/en/CompilerPhaseDescription.md
@@ -0,0 +1,152 @@
+### Hierarchy in maple phase
+At the Current stage, there are two phases classes provided for inheritance.
+Other level IR phase can be designed as a subclass of the MaplePhase class.
+They perform the optimizations or generate analysis results on the specific IR level.
+
+##### The MapleModulePhase class
+
+If a phases is derived from MapleModulePhase, it indicates that this phase does transformation on the module.
+It can run lower level IR phases manager as well.
+
+##### The MapleFunctionPhase class
+
+```c++
+ template <class funcT>
+ class MapleFunctionPhase : public MaplePhase
+```
+
+In constrast to MapleFunctionPhase, it is template class due to different Function level IRs in Maple.
+Both CodeGen Function level IR and MidEnd Function level IR derives this class.
+
+### Memory management for maple phase
+
+Maple phase management is able to manage memory so that each phase can keep the information required by other phases and discard useless information. Each phase manager provides an analysisDataManager (In multithreading, each threads provides an analysisDataMangers) which takes responsibility for storing analysis data. 
+To implement this functionality, the GetAnalysisDependence Method is required to be implemented be each phases.
+```c++
+ void <OPT_PHASENAME>::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<OPT_PHASENAME>();  // If a previous phase is requried to be executed
+  aDep.AddPreserved<OPT_PHASENAME>(); // preserve specific previous phase information
+  aDep.SetPreservedAll();             // preserve all previous phase information in analysisDataManager
+}
+```
+#### Analysis phase
+
+GetPhasesMempool() in Analysis phase provides mempool from analysisDataManager.
+Any data that is put in analysis phase mempool is not deleted until it is declared to be discarded by other phases or the end of phase manager.
+If information generated during analysis phase need to be deleted after this analysis phase, it can be put in Temp mempool in MaplePhase.
+
+#### Transfrom phase
+
+GetPhasesMempool() in Transform phase provides mempool which lives until this transformation finish.
+**If a transform phase does not implement the GetAnalysisDependence method, it defaults to not having any prerequisite phases, and invalidating all phases information in analysisDataManager.** Transfrom phase default to be assumed to invalid all ananlysis results.
+
+
+### Quick Start -- basic code
+
+An example for function level `transform` phase called 'MEHello' in me.
+- 1 add two files: me_hello_opt.h and me_hello_opt.cpp
+
+content in me_hello_opt.h
+```c++
+#ifndef MAPLE_ME_INCLUDE_ME_HELLO_OPT_H
+#define MAPLE_ME_INCLUDE_ME_HELLO_OPT_H
+#include "me_function.h"    // in order to use MeFunction
+#include "maple_phase.h"    // in order to use the macro
+namespace maple {
+
+// always use this macro when you work with a transform phase.
+MAPLE_FUNC_PHASE_DECLARE(MEHello, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_HELLO_OPT_H
+
+```
+content in me_hello_opt.cpp
+```c++
+#include "me_hello_opt.h"
+// include the corresponding phasemanager in order to use information from other phase.
+#include "me_phase_manager.h"
+
+namespace maple {
+
+// you need always keep in mind that which analysis results are needed and which results will be destroyed.
+void MEHello::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>(); // it is guaranteed that MEDominance's result is available in this phase.
+  aDep.SetPreservedAll();          // it means that this phase will not destroy any analysis results.
+}
+
+// the return value of this function indicates that whether this phase
+// has modified the IR of this function, for now we do not use this value.
+bool MEHello::PhaseRun(maple::MeFunction &f) {
+  // you can use this macro to get the result which is configured as Required
+  // in GetAnalysisDependence; or an error will be reported.
+  auto *dom = GET_ANALYSIS(MEDominance);
+  // do something using dom info.
+  LogInfo::MapleLogger() << "hello opt on function: " << f.GetName() << '\n';
+  return false;
+}
+
+}  // namespace maple
+
+```
+- 2 tell the phase manager to welcome a new phase.
+    - 2.1 add the header file(me_hello_opt.h) to me_phase_manager.h
+    - 2.2 register the phase in me_phase_manager.cpp, like this:
+```c++
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEHdse, hdse)
+// the macro suffix CANSKIP indicates that this phase can be skipped.
+// first parameter tells the implement class and the second parameter is
+// the phase name, which could be used in option like: dump-phase(s),
+// skip-phases, skip-after; and it is used to configure the phase list that will run in phasemanager.
++MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEHello, hello)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MELfoIVCanon, ivcanon)
+```
+
+- 3 add the new phase into run list.
+modify the phase.def file, like this:
+```c++
+...
+ADDMAPLEMEPHASE("dse", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("hello", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("analyzector", JAVALANG)
+...
+```
+- 4 add the cpp file into corresponding build.gn file.
+- 5 compile and test new phase.
+maple --run=me:mpl2mpl:mplcg --option="--O2 :--O2 --quiet:--O2 --quiet" test.mpl
+we can see that our new hello phase is performed after dse successfully.
+```
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Optimizing Function  < VEC_invariant_p_base_space id=5471 >---
+---Preparing Function  < VEC_invariant_p_base_space > [1] ---
+---Run Phase [ mecfgbuild ]---
+---Run Phase [ cfgOpt ]---
+---Run Phase [ loopcanon ]---
+    ++ trigger phase [ dominance ]
+    ++ trigger phase [ identloops ]
+---Run Phase [ splitcriticaledge ]---
+---Run Phase [ ssatab ]---
+---Run Phase [ aliasclass ]---
+---Run Phase [ ssa ]---
+    ++ trigger phase [ dominance ]
+---Run Phase [ dse ]---
+    ++ trigger phase [ fsaa ]
+---Run Phase [ hello ]---
+hello opt on function: VEC_invariant_p_base_space
+---Run Phase [ hprop ]---
+    ++ trigger phase [ irmapbuild ]
+---Run Phase [ valueRangePropagation ]---
+    ++ trigger phase [ identloops ]
+---Run Phase [ hdse ]---
+---Run Phase [ epre ]---
+    ++ trigger phase [ dominance ]
+    ++ trigger phase [ identloops ]
+  == epre invokes [ hdse ] ==
+---Run Phase [ rename2preg ]---
+---Run Phase [ lpre ]---
+---Run Phase [ storepre ]---
+---Run Phase [ copyprop ]---
+---Run Phase [ hdse ]---
+---Run Phase [ pregrename ]---
+---Run Phase [ bblayout ]---
+---Run Phase [ meemit ]---
+
+```
\ No newline at end of file
diff --git a/doc/en/DeveloperGuide.md b/doc/en/DeveloperGuide.md
new file mode 100644
index 0000000000000000000000000000000000000000..7b604e2540d76f5c04f236e94ee23ebed3a2717e
--- /dev/null
+++ b/doc/en/DeveloperGuide.md
@@ -0,0 +1,102 @@
+# Developer Guide
+
+By referring to this document, you can download the OpenArkCompiler source code to compile it. At the same time, this document also provide the guide of static code analysis to developers.
+
+## Prerequisites
+
+Prepare development environment by referring to Environment Configuration.
+
+
+## Downloading Source Code
+
+Download address: <https://code.opensource.huaweicloud.com/HarmonyOS/OpenArkCompiler/home> .
+You can download the OpenArkCompiler source code in `Clone` or `Download` mode.
+> Note: The download directory of the source code is openarkcompiler by default.
+
+
+## Compiling Source Code
+
+
+Run the following command in the openarkcompiler directory to compile OpenArkCompiler. The output path is openarkcompiler/output/TYPE/bin, TYPE: aarch64-clang-release by default.
+
+```
+source build/envsetup.sh
+make setup
+make
+```
+Command description:
+
+- `source build/envsetup.sh`: Initialize the environment and add the toolchain path openarkcompiler/output/bin of OpenArkCompiler to environment variables.
+- `make`: Compile the release version of OpenArkCompiler.
+- `make BUILD_TYPE=DEBUG`: Compile the debug version of OpenArkCompiler.
+
+Run the following command in the openarkcompiler directory to compile OpenArkCompiler and maple runtime. The output path is openarkcompiler/output/TYPE, TYPE: aarch64-clang-release by default.
+
+```
+source build/envsetup.sh arm release
+make setup
+make libcore
+```
+
+命令说明：
+
+- `make libcore` Compile the release version of OpenArkCompiler;
+- `make libcore BUILD_TYPE=DEBUG` Compile the debug version of OpenArkCompiler;
+
+In addition, the OpenArkCompiler also provides a shell script which contains the command to compile OpenArkCompiler. The developer can run the script in the openarkcompiler directory to compile OpenArkCompiler. The command to run the script:
+
+```
+source build/build.sh
+```
+
+## Compiling Sample
+
+The Java basic library is required for OpenArkCompiler to compile a sample. The following uses the Java basic library provided by the Android OS to describe the sample compilation process.
+
+**Preparing basic library**
+
+- Download the Android code and compile it locally to obtain the libcore JAR package. The Android 9.0.0_r45 version is recommended.
+
+- Gitee also provides the compiled libcore JAR file. Download address: https://gitee.com/mirrors/java-core/ .
+
+**Generating the libjava-core.mplt file**
+
+Before compilation, create the libjava-core directory in the openarkcompiler directory, copy the java-core.jar file to the libjava-core directory, and run the following commands in the openarkcompiler directory:
+
+```
+source build/envsetup.sh
+make
+cd libjava-core
+jbc2mpl -injar java-core.jar -out libjava-core
+```
+
+After the execution is complete, the libjava-core.mplt file is generated in the directory.
+
+**Compiling sample code**
+
+The sample code is in the openarkcompiler/samples directory.
+
+Take the samples/helloworld/ code as an example. Run the following command in the openarkcompiler/ directory:
+
+```
+source build/envsetup.sh
+make
+cd samples/helloworld/
+make
+```
+
+## Static code analysis
+
+This part will guide you to do the static code analysis by using the clang-tidy. After the code is changed, the static code analysis will check the coding specifications to improve the code quality.
+
+Before the static code analysis, we need compiled the OpenArkCompiler. After that, using the code of src/maple_driver as the tested directory, run the following commands in the openarkcompiler directory:
+
+```
+cp output/compile_commands.json ./
+./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/share/clang/run-clang-tidy.py -clang-tidy-binary='./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/bin/clang-tidy' -clang-apply-replacements-binary='./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/bin/clang-apply-replacements' src/maple_driver/
+```
+Command description:
+
+- `cp output/compile_commands.json ./`: Copy the compile_commands.json in the output directory to the openarkcompiler directory, it is required by the clang-tidy, it contains the compile commands of OpenArkCompiler.
+
+- `./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/share/clang/run-clang-tidy.py`: Call the run-clang-tidy.py which is the parallel clang-tidy runner. The `./tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/` directory is the directory of the release package of clang compiler. The `-clang-tidy-binary` set the path of clang-tidy binary. The `-clang-apply-replacements-binary` set the path of the clang-apply-replacements binary which is requried by the run-clang-tidy.py. The `src/maple_driver/` is the tested code directory.
diff --git a/doc/en/DeveloperGuide4Utility.md b/doc/en/DeveloperGuide4Utility.md
new file mode 100644
index 0000000000000000000000000000000000000000..d1262234c1b994a87719154a4f44881422282683
--- /dev/null
+++ b/doc/en/DeveloperGuide4Utility.md
@@ -0,0 +1,431 @@
+# Application Manual of Maple General Modules
+
+# Cast
+
+## `instance_of` and `safe_cast`.
+
+In principle, `RTTI`, that is, `dynamic_cast`, must be disabled for the use of `C++` in `maple`. The compiler system is complex. It will make the object relationship more complex to cast from a class object to a subclass object by class design. Therefore, the `maple` code implementation introduces the following designs:
+
+```c++
+SubClass *sub = nullptr;
+if (base.Type() == SubType) {
+  sub = static_cast<SubClass*>(base);
+}
+```
+
+A property field is designed to implement the binding between a class and its subclass, achieving the same effect as `dynamic_cast`.
+
+However, this method has some disadvantages. First, whereas the binding relationship between `SubType` and `SubClass` is  static and determined by the designer, the caller needs to make the relationship explicit, resulting in strong dependency. Second, not all scenarios are as intuitive as type comparison. Callers are prone to make mistakes in complex scenarios, causing shotgun surgery in later code rectification. Therefore, the `safe_cast` is designed. The designer registers the casting relationship. A caller only needs to call the `dynamic_cast` method.
+
+### Registration method.
+
+Use the `REGISTER_SAFE_CAST` macro to complete the registration. The declaration is as follows:
+
+```c++
+#define REGISTER_SAFE_CAST(type, condition)
+```
+
+`type` is a subclass type (assumed as `B`), and `condition` is a Boolean expression that matches `B` and all its subclasses. Example:
+
+```c++
+class A;
+class B : A;
+class C : B;
+REGISTER_SAFE_CAST(B, from.Kind() == B || from.Kind() == C);
+REGISTER_SAFE_CAST(C, from.Kind() == C);
+```
+
+`from` is a formal parameter name of a type transferred by an expression.
+
+*Note:*
+
+*- The registration supports the casting from a subclass to a class and from a class to a subclass.*
+
+*- `condition` can be any Boolean expression. However, the designer must ensure that it complies with the inheritance relationship to avoid casting of non-inheritance relationships.*
+
+*- For a complex `condition`, using `kind ==` to indicate an inheritance relationship tree is not recommended. Optimization needs to be considered. For example, the range of `kind` needs to be organized, and a specific bit flag needs to be used to achieve quick matching.*
+
+#### Application scenarios.
+
+1. For scenarios where only one type is matched:
+
+```c++
+SubClass *sub = safe_cast<SubClass>(base);
+if (sub == nullptr) {
+  // TODO
+}
+```
+
+2. For scenarios where multiple types are matched:
+
+```c++
+if (instanceof<SubClass1>(base)) {
+  auto *sub = static_cast<SubClass1*>(base);
+  // TODO
+} else if (instanceof<SubClass2>(base)) {
+  auto *sub = static_cast<SubClass2*>(base);
+  // TODO
+}
+...
+```
+
+*Note:*
+
+*- In scenarios where types have been correctly identified, such as `switch case`, use `static_cast`.*
+
+*- The return value of `safe_cast` is always a pointer, indicating whether the casting is successful.*
+
+*- If the input is a pointer, both `instance_of` and `safe_cast` check whether the input is null. Therefore, if `base` is not null, the reference is preferentially transferred.*
+
+# Container
+
+## `Ptr`
+
+`Ptr` simulates the behavior of a native pointer, but removes support for array operations.
+
+In this method, data is validated in the construction and assignment operations, so that a feature of a pointer object needs to be validated only during construction, and does not need to be validated again during transfer and use, thereby reducing overheads of repeated check.
+
+```c++
+template<typename T>
+using PtrCheckerType = void (*)(const T*);
+
+template<typename T>
+constexpr void CheckNothing(const T*) {}
+
+template<typename T, PtrCheckerType<T> Check = CheckNothing<T>>
+class Ptr;
+```
+
+As shown in the preceding example, the default validation behavior of `Ptr` is not checked.
+
+```c++
+template < typename T>
+using XXXPtr = utils::Ptr<T, CheckXXX<T>>;
+```
+
+In the preceding example, the validated pointer objects in different scenarios can be defined, which are called security pointers.
+
+*Note: The preceding behavior is extended based on the requirements of `safe_ptr`. However, `safe_ptr` is more complex than the common `Ptr` scenario because it is specific to the validity of a pointer rather than features of a pointer object.*
+
+## `safe_ptr`
+
+For details, see the definition of `Ref` in the CPPCodingTalkAboutPointer. The `operator.` in `c++` cannot be overloaded. As a result, the `Ref` object cannot be built. However, the `safe_ptr` object, which is a non-null pointer object equivalent to the `Ref` object, can be defined.
+
+### Scenario: Container members such as arrays and dictionaries.
+
+For details, see the CPPCodingTalkAboutPointer.
+
+To solve the problem that `operator.` cannot be overloaded, the `ToRef` tool capability in `Utility` will be extended, ensuring that the pointer does not have overhead and is securely casted into a reference. It may have the following features:
+
+```c++
+template <typename T>
+constexpr T &ToRef(safe_ptr<T> ptr) {
+  return *ptr;
+}
+```
+
+*Note: For containers that are frequently used, containers of the `ref_xxx` series will be encapsulated to replace the `safe_ptr` application scenarios.*
+
+### Scenario: Object members.
+
+This is an unexpected scenario discovered after `safe_ptr` is developed.
+
+The compiler cannot generate default copies and transfers for classes of reference data members. However, the copy and transfer capabilities are required in many scenarios. In this case, the common method is to store the classes as pointer members. However, pointer members bring the following problems:
+
+1. When a pointer member is accessed, the validity of the pointer needs to be identified.
+2. The behavior can be controllable by defining member roles during refactoring and evolution. However, the role that uses the member may not be notified, which may further cause hidden bugs.
+
+If `safe_ptr` is used to replace a raw pointer and `ToRef` is used to convert the reference at the `safe_ptr` dereference position (`ToRef` of a raw pointer has extra overheads), the preceding problems can be avoided.
+
+*Note: `safe_ptr` is designed as a container or object member. `&` is used for transferring function parameters.*
+
+## `mpl_iterator`
+
+The original name of `mpl_iterator` is `iterator`, but the name is the same as that of `using iterator` in the container. Therefore, the `mpl` prefix is added.
+
+Taking the design of the `ref_xxx` container and possible expansion of the small talk series in the future into consideration, repeated iterator design is troublesome. Therefore, a unified iterator container that continuously evolves is abstracted, which uses `mpl_iterator_traits` to quickly implement the iterator of the new container with a few configurations.
+
+Based on the iterator requirements of `ref_vector`, members of `mpl_iterator_traits` are designed as follows:
+
+```c++
+template <typename Iterator, typename Container>
+struct mpl_iterator_traits {
+  using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
+  using value_type = typename std::iterator_traits<Iterator>::value_type;
+  using difference_type = typename std::iterator_traits<Iterator>::difference_type;
+  using pointer = typename std::iterator_traits<Iterator>::pointer;
+  using reference = typename std::iterator_traits<Iterator>::reference;
+
+  static reference operator_dereference(Iterator iter) {
+    return *iter;
+  };
+
+  static Iterator operator_arrow(Iterator iter) {
+    return iter;
+  }
+
+  static reference operator_bracket(Iterator iter, difference_type n) {
+    return iter[n];
+  }
+};
+
+```
+
+## `ref_vector`
+
+For details, see the definition of `ref_vector` in the CPPCodingTalkAboutPointer.
+
+Use the pointer array: `std::vector<T*>`.
+
+```c++
+  int a = 0, b = 1;
+
+  std::vector<int*> data;
+  data.push_back(&a);
+  data.push_back(&b);
+  ASSERT_EQ(*data[0], 0);
+  ASSERT_EQ(*data[1], 1);
+```
+
+Refactored as a reference array: `utils::ref_vector<T>`.
+```c++
+  int a = 0, b = 1;
+
+  ref_vector<int> data;
+  data.push_back(a);
+  data.push_back(b);
+  ASSERT_EQ(data[0], 0);
+  ASSERT_EQ(data[1], 1);
+```
+
+## `Index`
+
+`Index` is designed to meet the static security requirements of basic types.
+
+For example, `GStrIdx`, `UStrIdx`, and `U16StrIdx` are involved in calculation in service code, and their interfaces are similar. Their bottom layers are `uint32`. If all formal parameters are defined as `uint32`, it will be a disaster. The caller must be careful, but it is difficult to avoid transferring incorrect data. So static type conflict is used and the compiler checks the correctness of the use, which will greatly reduce the errors.
+
+To define a static type, you only need to define different tags, as shown in the following example:
+
+```c++
+class GStrTag;
+using GStrIdx = utils::Index<GStrTag, uint32>;
+
+class UStrTag;
+using UStrIdx = utils::Index<UStrTag, uint32>;
+
+class U16StrTag;
+using U16StrIdx = utils::Index<U16StrTag, uint32>; 
+```
+
+# Generalize Pattern
+
+## `ObjectFactory`
+
+The `ObjectFactory` is an encapsulation for an abstract factory and is used to solve the following problems:
+
+1. Eliminate large functions with high cyclomatic complexity in code, such as `switch... case` and `if... else if...`. These functions are difficult to maintain and extend and have low flexibility.* (Note: Analyze semantics and design well instead of rigidly solving problems, for example, use template mode to implement design isolation instead of code isolation.)*
+
+2. The use of a factory will invert the dependency, making it easier to isolate the caller from the designer and the designer from each other.
+
+Example:
+
+```c++
+// Defines a key to mark the product type to be created by the factory.
+enum class ObjectType {
+  kPlus,
+  kMinus
+};
+
+//Defines interfaces and interface protocols that all products must implement.
+class Base {
+ public:
+  virtual ~Base() = default;
+  virtual int32_t DoIt(int32_t lhs, int32_t rhs) const = 0;
+};
+
+// Defines a factory by using ObjectType as the search keyword. Base indicates the interface protocol, and int32_t indicates the parameter type of all product constructor functions.
+using TestObjectFactory = ObjectFactory<ObjectType, Base, int32_t>;
+
+// Key, interface, and factory must be visible to both the registrant and caller. Therefore, the key may be in the .h file or summarized in the .cpp file.
+// Products can be registered in different .cpp files as long as they can be registered in the factory.
+// Defines a product.
+class ObjectPlus : public Base {
+ public:
+  // Constructor function agreed upon during factory definition.
+  explicit ObjectPlus(int32_t base) : base(base) {}
+  virtual ~ObjectPlus() = default;
+
+  // Conventions for defining interfaces.
+  virtual int32_t DoIt(int32_t lhs, int32_t rhs) const override {
+    return base + lhs + rhs;
+  }
+
+ private:
+  int32_t base;
+};
+
+// Defines the product, which may be in another .cpp file.
+class ObjectMinus : public Base {
+ public:
+  explicit ObjectMinus(int32_t base) : base(base) {}
+  virtual ~ObjectMinus() = default;
+
+  virtual int32_t DoIt(int32_t lhs, int32_t rhs) const override {
+    return base + lhs - rhs;
+  }
+
+ private:
+  int32_t base;
+};
+
+// Registers a product. The product registration mode varies depending on the distribution and loading of keys, interfaces, factories, and products. Ensure that the registration is successful.
+// Initializes the static variable to ensure registration.
+bool RegisterObject() {
+  RegisterFactoryObject<TestObjectFactory, ObjectType::kPlus, ObjectPlus>();
+  RegisterFactoryObject<TestObjectFactory, ObjectType::kMinus, ObjectMinus>();
+}
+static auto testObjectFactory = RegisterObject();
+
+TEST(TestFactory, ObjectFactory) {
+  // Obtains a product object. Check whether the value is null. The example is omitted.
+  auto obj = CreateProductObject<TestObjectFactory>(ObjectType::kPlus, 10);
+  ASSERT_EQ(obj->DoIt(1, 2), 13);
+  obj = CreateProductObject<TestObjectFactory>(ObjectType::kMinus, 10);
+  ASSERT_EQ(obj->DoIt(1, 2), 9);
+}
+```
+
+## `FunctionFactory`
+
+Similar to `ObjectFactory`, `FunctionFactory` is used to simplify the complexity of abstract factories. In most scenarios, `FunctionFactory` is easier to compile and use.
+
+Example:
+
+```c++
+// Defines a key to mark the product type to be created by the factory.
+enum class FunctionType {
+  kPlus,
+  kMinus
+};
+
+// Defines the interface and factory by using the FunctionType as the search keyword and the int32_t(int32_t, int32_t) as the function protocol.
+using TestFunctionFactory = FunctionFactory<FunctionType, int32_t, int32_t, int32_t>;
+
+// Defines a product.
+int32_t Plus(int32_t lhs, int32_t rhs) {
+  return lhs + rhs;
+}
+
+// Defines the product, which may be in another .cpp file.
+int32_t Minus(int32_t lhs, int32_t rhs) {
+  return lhs - rhs;
+}
+
+// Registers a product. The product registration mode varies depending on the distribution and loading of keys, interfaces, factories, and products. Ensure that the registration is successful.
+// Uses the singleton pattern to ensure registration.
+bool RegisterFunction() {
+  RegisterFactoryFunction<TestFunctionFactory>(FunctionType::kPlus, Plus);
+  RegisterFactoryFunction<TestFunctionFactory>(FunctionType::kMinus, Minus);
+}
+void AutoFunctionLoader() {
+  static auto testObjectFactor = RegisterFunction();
+}
+
+TEST(TestFactory, TestAll) {
+  // Loads the product.
+  AutoFunctionLoader();
+
+  // Obtains a product object. Check whether the value is null. The example is omitted.
+  auto func = CreateProductFunction<TestFunctionFactory>(FunctionType::kPlus);
+  ASSERT_EQ(func(1, 2), 3);
+  func = CreateProductFunction<TestFunctionFactory>(FunctionType::kMinus);
+  ASSERT_EQ(func(1, 2), -1);
+}
+```
+
+
+# Utility
+
+## `ToRef`
+
+In the scenario where pointers transfer parameters in the new code and refactored code of Ark Compiler, it is expected that all pointers are validated and then transferred to the called function in reference mode. In most cases, the called function should not bear the risk of null pointers in function parameters and the overhead of judgment.
+
+The common format is as follows (In the example, `DoIt` and `Run` can be used as third-party interfaces and cannot be changed):
+
+```c++
+A *DoIt(B &b);
+void Run(B *b) {
+  CHECK_NULL_FATAL(b);
+  // ...
+  A *a = DoIt(*b);
+  CHECK_NULL_FATAL(a);
+  a->Do;
+}
+```
+
+If most pointers are transferred into a reference type once obtained:
+
+```c++
+A *DoIt(B &b);
+void Run(B *b) {
+  B &bRef = utils::ToRef(b);
+  // ...
+  A &a = utils::ToRef(DoIt(bRef));
+  a.Do;
+}
+```
+
+If `b` is used only once:
+
+```c++
+A *DoIt(B &b);
+void Run(B *b) {
+  // ...
+  A &a = utils::ToRef(DoIt(utils::ToRef(b)));
+  a.Do;
+}
+```
+
+## `bit_field_v`&`lbit_field_v`
+
+Using a bit to mark a state switch combination is a design method that saves memory and can be efficiently encoded. Generally, the enumeration definition or constant definition is written as follows:
+
+```c++
+enum BBAttr : uint32 {
+  kBBAttrIsEntry = 0x02,
+  kBBAttrIsExit = 0x04,
+  kBBAttrWontExit = 0x08,
+  kBBAttrIsTry = 0x10,
+  kBBAttrIsTryEnd = 0x20,
+  kBBAttrIsJSCatch = 0x40,
+  kBBAttrIsJSFinally = 0x80,
+  kBBAttrIsCatch = 0x0100,
+  kBBAttrIsJavaFinally = 0x0200,
+  kBBAttrArtificial = 0x0400,
+  kBBAttrIsInLoop = 0x0800,
+  kBBAttrIsInLoopForEA = 0x1000
+};
+```
+
+This design is obviously intended to use bits to record some attribute information, but the bits are obscure and difficult to maintain and read.
+
+Therefore, a clearer design is required.
+
+```c++
+enum BBAttr : uint32 {
+  kBBAttrIsEntry        = utils::bit_field_v<1>,
+  kBBAttrIsExit         = utils::bit_field_v<2>,
+  kBBAttrWontExit       = utils::bit_field_v<3>,
+  kBBAttrIsTry          = utils::bit_field_v<4>,
+  kBBAttrIsTryEnd       = utils::bit_field_v<5>,
+  kBBAttrIsJSCatch      = utils::bit_field_v<6>,
+  kBBAttrIsJSFinally    = utils::bit_field_v<7>,
+  kBBAttrIsCatch        = utils::bit_field_v<8>,
+  kBBAttrIsJavaFinally  = utils::bit_field_v<9>,
+  kBBAttrArtificial     = utils::bit_field_v<10>,
+  kBBAttrIsInLoop       = utils::bit_field_v<11>,
+  kBBAttrIsInLoopForEA  = utils::bit_field_v<12>
+};
+```
+
+`bit_field_v`:`uint32` and `lbit_field_v`:`uint64` are supported. In the future, `sbit_field_v`:`uint16` and `bbit_field_v`:`uint8` will be added as required.
diff --git a/doc/en/DevelopmentPreparation.md b/doc/en/DevelopmentPreparation.md
new file mode 100644
index 0000000000000000000000000000000000000000..912e9653876f608fe98634ac787ffcdd36dd1aef
--- /dev/null
+++ b/doc/en/DevelopmentPreparation.md
@@ -0,0 +1,72 @@
+## Environment Configuration
+
+## Recommended Hardware:
+
+- 2 GHz dual-core processor or higher
+
+- 2 GB system memory or higher
+
+- 200 GB available disk space
+
+## Recommended Development Environment
+
+Install a 64-bit Ubuntu (Ubuntu 16.04, 18.04 or 20.04 is required).
+
+```
+sudo apt-get -y install clang llvm lld libelf-dev libssl-dev python qemu openjdk-8-jre-headless openjdk-8-jdk-headless cmake
+sudo apt-get -y install git build-essential zlib1g-dev libc6-dev-i386 g++-multilib gcc-multilib linux-libc-dev:i386
+
+Ubuntu 16.04:
+sudo apt-get -y install gcc-5-aarch64-linux-gnu g++-5-aarch64-linux-gnu
+
+Ubuntu 18.04:
+sudo apt-get -y install gcc-7-aarch64-linux-gnu g++-7-aarch64-linux-gnu
+
+Ubuntu 20.04:
+sudo apt-get -y install gcc-9-aarch64-linux-gnu g++-9-aarch64-linux-gnu libncurses5
+```
+
+## Auto Installation of Tools
+
+```
+source build/envsetup.sh arm release
+make setup
+
+Note: the following steps are for reference only. All required tools are installed during above "make setup"
+```
+
+## Installing and Configuring Clang (for Compiling the OpenArkCompiler Code)
+
+Download **clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04**
+LLVM download address: http://releases.llvm.org/download.html#10.0.0
+
+Place the downloaded files in the `openarkcompiler/tools` directory, open the `openarkcompiler/build/config.gni` file, and set the three variables `GN_C_COMPILER`, `GN_CXX_COMPILER`, and `GN_AR_COMPILER` to the path where Clang is located. For example:
+
+```
+GN_C_COMPILER = "${MAPLE_ROOT}/tools/clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/clang"
+GN_CXX_COMPILER = "${MAPLE_ROOT}/tools/clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/clang++"
+GN_AR_COMPILER = "${MAPLE_ROOT}/tools/clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/llvm-ar"
+```
+
+${MAPLE_ROOT} is the root directory of the OpenArkCompiler source code.
+
+## Installing and configuring Ninja and GN
+
+Download **Ninja(v1.10.0)** and **GN(Linux Version)**
+Ninja download address: https://github.com/ninja-build/ninja/releases
+GN download address: https://gitee.com/xlnb/gn_binary
+
+Place the executable programs of GN and Ninja in the openarkcompiler/tools directory, modify these two files to be executable.
+
+```
+cd openarkcompiler/tools
+chmod 775 gn
+chmod 775 ninja
+```
+
+Open the openarkcompiler/Makefile file, and set the two variables GN and NINJA to the path where the executable programs of GN and Ninja are located. For example,
+
+```
+GN := ${MAPLE_ROOT}/tools/gn/gn
+NINJA := ${MAPLE_ROOT}/tools/ninja/ninja
+```
diff --git a/doc/en/MapleDriverOverview.md b/doc/en/MapleDriverOverview.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d29efbd0fdbcded50fc5ba54aec3b378f5bf417
--- /dev/null
+++ b/doc/en/MapleDriverOverview.md
@@ -0,0 +1,48 @@
+# Maple Driver Overview
+## Introduction
+This document describes current state of Maple Driver. This includes design, usage, goals and internal implementation.
+
+##  Goals
+The Maple driver is intended to meet requirements of a good compiler driver such as Clang. In other words it should be:
+- Flexible to support new features
+- Efficient with low overhead
+- Easy to use
+
+The end goal of driver development is full support of gcc options with direct integration into the CMake build system.
+
+## Design and Implementation
+
+### Design overview
+
+The diagram below shows significant components of the Maple Driver architecture as well as their realtions to one another. The red components represent essential driver parts(classes, methods), the blue components are output/input data structures, the green components are important helper classes.
+
+![](media/MapleDriverStructure.png)
+
+### Driver stages
+
+The driver functionality can be divded into five stages:
+
+**1. Parsing options**
+
+The input command-line argument strings are firstly checked for correctness of format and transformed into pairs of key-value, keys are then checked for a match in `usages` multimap (previously created from a helper data structure) of `OptionParser`. The `Option` class also contains `Descriptor` data structure, describing required parsing details for option argument with some additional data. Then the argument is parsed. The driver expects to understand all available options. The result is then written in the `options` vector of the `OptionParser` class.
+
+
+**2. Filling MplOptions**
+
+After parsing input, `MplOptions` is filled depending on the results: firstly the run type is decided to be either automatic or custom (depends on the presence of `--run` option), then input files are initialized and checked for validity. If the run type is automatic Maple Driver will also configure the code generation pipeline by itself(you will recieve assembler file as the final output), depending on the extension of the first input file. Then other options are handled, including `--option`, value of which must contain options for all phases of compilation, the value is parsed using the same methods and data structures that were used in parsing of general options, the results are pushed in map `exeOptions` of the `MplOptions` class. Then the Maple Driver attempts to open input file and in case of success moves on to the next stage.
+
+**3. Compiler Selection**
+
+Upon the completion of the previous stage Maple Driver triggers `CompilerFactory` class constructor, which creates classes of supported compilers and saves pointers to all of them in `supportedCompilers` data structure. 
+
+**4. Phase specific option construction**
+
+`CompilerFactory` calls `Compile` methods of selected Compilers, during which default and user-determined options are constructed and written in a string. The main problem is the translation of commands from one style to another, some driver components, like `MplcgCompiler` require their own methods to work correctly, while others, like `AsCompiler` work with just a handful of options and their main purpose is to determine the path of the executable to call and pass on their input and output arguments.
+
+However, `MaplecombCompiler` and `MplcgCompiler` require special pipeline, they do not call executables and pass on command-line to them, but interact the with input file using `MIRModule`, `MIRParser` and `DriverRunner` classes. `MIRModule` is a data structure, purpose of which is similar to `MplOptions`, two previously mentioned compilers store crucial data in it (name of the input file, source language, etc.); `MIRParser` as the name implies exists to parse Maple IR; `DriverRunner` is an orchestrator that works with two previous data structures and also stores options for phases it is responsible for and other data, required in compilation.
+
+**5. Execute**
+
+After that the command-line and full path to executable is redirected to the `Exe` method of the `SafeExe` class, where it is handled and executed via child process. In case of `MaplecombCompiler` and `MplcgCompiler` the `Run` method of the `DriverRunner` is called and issues job to the Phase Manger.
+
+
diff --git a/doc/en/MapleIRDesign.md b/doc/en/MapleIRDesign.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac0ca70085cb5c81e02c52c78786515f52f150f4
--- /dev/null
+++ b/doc/en/MapleIRDesign.md
@@ -0,0 +1,2616 @@
+```
+#
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# Licensed under the Mulan Permissive Software License v2.
+# You can use this software according to the terms and conditions of the MulanPSL - 2.0. 
+# You may obtain a copy of MulanPSL - 2.0 at:
+#
+#   https://opensource.org/licenses/MulanPSL-2.0
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the MulanPSL - 2.0 for more details.
+#
+```
+
+MAPLE IR Specification
+======================
+
+Contents {#contents .TOC-Heading}
+========
+
+[1 Introduction 7](#introduction)
+
+[2 Program Representation in MAPLE IR 8](#program-representation-in-maple-ir)
+
+[2.1 Symbol Tables 9](#symbol-tables)
+
+[2.2 Primitive Types 9](#primitive-types)
+
+[2.3 Constants 10](#constants)
+
+[2.4 Identifiers (\$ % &) 10](#identifiers)
+
+[2.5 Pseudo-registers (%) 11](#pseudo-registers)
+
+[2.6 Special Registers (%%) 11](#special-registers)
+
+[2.7 Statement Labels (@) 11](#statement-labels)
+
+[2.8 Storage Accesses 11](#storage-accesses)
+
+[2.9 Aggregates 12](#aggregates)
+
+[2.9.1 Arrays 12](#arrays)
+
+[2.9.2 Structures 12](#structures)
+
+[3 Instruction Specification 13](#instruction-specification)
+
+[3.1 Storage Access Instructions 13](#storage-access-instructions)
+
+[3.1.1 dassign 13](#dassign)
+
+[3.1.2 dread 14](#dread)
+
+[3.1.3 iassign 14](#iassign)
+
+[3.1.4 iread 14](#iread)
+
+[3.1.5 iassignoff 14](#iassignoff)
+
+[3.1.6 iassignfpoff 14](#iassignfpoff)
+
+[3.1.7 iassignpcoff 14](#iassignpcoff)
+
+[3.1.8 ireadoff 15](#ireadoff)
+
+[3.1.9 ireadfpoff 15](#ireadfpoff)
+
+[3.1.10 ireadpcoff 15](#ireadpcoff)
+
+[3.1.11 regassign 15](#regassign)
+
+[3.1.12 regread 15](#regread)
+
+[3.2 Leaf Opcodes 15](#leaf-opcodes)
+
+[3.2.1 addrof 15](#addrof)
+
+[3.2.2 addroflabel 16](#addroflabel)
+
+[3.2.3 addroffunc 16](#addroffunc)
+
+[3.2.4 addroffpc 16](#addroffpc)
+
+[3.2.5 conststr 16](#conststr)
+
+[3.2.6 conststr16 16](#conststr16)
+
+[3.2.7 constval 16](#constval)
+
+[3.2.8 sizeoftype 16](#sizeoftype)
+
+[3.3 Unary Expression Opcodes 16](#unary-expression-opcodes)
+
+[3.3.1 abs 16](#abs)
+
+[3.3.2 bnot 17](#bnot)
+
+[3.3.3 extractbits 17](#extractbits)
+
+[3.3.4 iaddrof 17](#iaddrof)
+
+[3.3.5 lnot 17](#lnot)
+
+[3.3.6 neg 17](#neg)
+
+[3.3.7 recip 17](#recip)
+
+[3.3.8 sext 17](#sext)
+
+[3.3.9 sqrt 17](#sqrt)
+
+[3.3.10 zext 17](#zext)
+
+[3.4 Type Conversion Expression Opcodes 18](#type-conversion-expression-opcodes)
+
+[3.4.1 ceil 18](#ceil)
+
+[3.4.2 cvt 18](#cvt)
+
+[3.4.3 floor 18](#floor)
+
+[3.4.4 retype 18](#retype)
+
+[3.4.5 round 18](#round)
+
+[3.4.6 trunc 18](#trunc)
+
+[3.5 Binary Expression Opcodes 19](#binary-expression-opcodes)
+
+[3.5.1 add 19](#add)
+
+[3.5.2 ashr 19](#ashr)
+
+[3.5.3 band 19](#band)
+
+[3.5.4 bior 19](#bior)
+
+[3.5.5 bxor 19](#bxor)
+
+[3.5.6 cand 19](#cand)
+
+[3.5.7 cior 19](#cior)
+
+[3.5.8 cmp 19](#cmp)
+
+[3.5.9 cmpg 19](#cmpg)
+
+[3.5.10 cmpl 20](#cmpl)
+
+[3.5.11 depositbits 20](#depositbits)
+
+[3.5.12 div 20](#div)
+
+[3.5.13 eq 20](#eq)
+
+[3.5.14 ge 20](#ge)
+
+[3.5.15 gt 20](#gt)
+
+[3.5.16 land 20](#land)
+
+[3.5.17 lior 20](#lior)
+
+[3.5.18 le 20](#le)
+
+[3.5.19 lshr 20](#lshr)
+
+[3.5.20 lt 21](#lt)
+
+[3.5.21 max 21](#max)
+
+[3.5.22 min 21](#min)
+
+[3.5.23 mul 21](#mul)
+
+[3.5.24 ne 21](#ne)
+
+[3.5.25 rem 21](#rem)
+
+[3.5.26 shl 21](#shl)
+
+[3.5.27 sub 21](#sub)
+
+[3.6 Ternary Expression Opcodes 21](#ternary-expression-opcodes)
+
+[3.6.1 select 21](#select)
+
+[3.7 N-ary Expression Opcodes 22](#n-ary-expression-opcodes)
+
+[3.7.1 array 22](#array)
+
+[3.7.2 intrinsicop 22](#intrinsicop)
+
+[3.7.3 intrinsicopwithtype 22](#intrinsicopwithtype)
+
+[3.8 Control Flow Statements 22](#control-flow-statements)
+
+[3.8.1 Hierarchical control flow statements 22](#hierarchical-control-flow-statements)
+
+[3.8.1.1 doloop 23](#doloop)
+
+[3.8.1.2 dowhile 23](#dowhile)
+
+[3.8.1.3 foreachelem 23](#foreachelem)
+
+[3.8.1.4 if 23](#if)
+
+[3.8.1.5 while 23](#while)
+
+[3.8.2 Flat control flow statements 24](#flat-control-flow-statements)
+
+[3.8.2.1 brfalse 24](#brfalse)
+
+[3.8.2.2 brtrue 24](#brtrue)
+
+[3.8.2.3 goto 24](#goto)
+
+[3.8.2.4 igoto 24](#igoto)
+
+[3.8.2.5 multiway 24](#multiway)
+
+[3.8.2.6 return 24](#return)
+
+[3.8.2.7 switch 24](#switch)
+
+[3.8.2.8 rangegoto 25](#rangegoto)
+
+[3.8.2.9 indexgoto 25](#indexgoto)
+
+[3.9 Call Statements 25](#call-statements)
+
+[3.9.1 call 25](#call)
+
+[3.9.2 callinstant 26](#callinstant)
+
+[3.9.3 icall 26](#icall)
+
+[3.9.4 intrinsiccall 26](#intrinsiccall)
+
+[3.9.5 intrinsiccallwithtype 26](#intrinsiccallwithtype)
+
+[3.9.6 xintrinsiccall 26](#xintrinsiccall)
+
+[3.10 Java Call Statements 26](#java-call-statements)
+
+[3.10.1 virtualcall 26](#virtualcall)
+
+[3.10.2 superclasscall 26](#superclasscall)
+
+[3.10.3 interfacecall 26](#interfacecall)
+
+[3.11 Calls with Return Values Assigned 27](#calls-with-return-values-assigned)
+
+[3.11.1 callassigned 27](#callassigned)
+
+[3.12 Exceptions Handling 27](#exceptions-handling)
+
+[3.12.1 jstry 28](#jstry)
+
+[3.12.2 javatry 28](#javatry)
+
+[3.12.3 cpptry 29](#cpptry)
+
+[3.12.4 throw 29](#throw)
+
+[3.12.5 jscatch 29](#jscatch)
+
+[3.12.6 javacatch 29](#javacatch)
+
+[3.12.7 cppcatch 29](#cppcatch)
+
+[3.12.8 finally 29](#finally)
+
+[3.12.9 cleanuptry 30](#cleanuptry)
+
+[3.12.10 endtry 30](#endtry)
+
+[3.12.11 gosub 30](#gosub)
+
+[3.12.12 retsub 30](#retsub)
+
+[3.13 Memory Allocation and Deallocation 30](#memory-allocation-and-deallocation)
+
+[3.13.1 alloca 30](#alloca)
+
+[3.13.2 decref 31](#decref)
+
+[3.13.3 decrefreset 31](#decrefreset)
+
+[3.13.4 free 31](#free)
+
+[3.13.5 gcmalloc 31](#gcmalloc)
+
+[3.13.6 gcmallocjarray 31](#gcmallocjarray)
+
+[3.13.7 gcpermalloc 31](#gcpermalloc)
+
+[3.13.8 incref 32](#incref)
+
+[3.13.9 malloc 32](#malloc)
+
+[3.13.10 stackmalloc 32](#stackmalloc)
+
+[3.13.11 stackmallocjarray 32](#stackmallocjarray)
+
+[3.14 Other Statements 32](#other-statements)
+
+[3.14.1 assertge 32](#assertge)
+
+[3.14.2 assertlt 32](#assertlt)
+
+[3.14.3 assertnonnull 32](#assertnonnull)
+
+[3.14.4 eval 33](#eval)
+
+[3.14.5 checkpoint 33](#checkpoint)
+
+[3.14.6 membaracquire 33](#membaracquire)
+
+[3.14.7 membarrelease 33](#membarrelease)
+
+[3.14.8 membarfull 33](#membarfull)
+
+[3.14.9 syncenter 33](#syncenter)
+
+[3.14.10 syncexit 33](#syncexit)
+
+[4 Declaration Specification 34](#declaration-specification)
+
+[4.1 Module Declaration 34](#module-declaration)
+
+[4.1.1 entryfunc 34](#entryfunc)
+
+[4.1.2 flavor 34](#flavor)
+
+[4.1.3 globalmemmap 34](#globalmemmap)
+
+[4.1.4 globalmemsize 34](#globalmemsize)
+
+[4.1.5 globalwordstypetagged 34](#globalwordstypetagged)
+
+[4.1.6 globalwordsrefcounted 35](#globalwordsrefcounted)
+
+[4.1.7 id 35](#id)
+
+[4.1.8 import 35](#import)
+
+[4.1.9 importpath 35](#importpath)
+
+[4.1.10 numfuncs 35](#numfuncs)
+
+[4.1.11 srclang 35](#srclang)
+
+[4.2 Variable Declaration 35](#variable-declaration)
+
+[4.3 Pseudo-register Declarations 36](#pseudo-register-declarations)
+
+[4.4 Type Specification 36](#type-specification)
+
+[4.4.1 Incomplete Type Specification 37](#incomplete-type-specification)
+
+[4.5 Type Declaration 37](#type-declaration)
+
+[4.6 Java Class and Interface Declaration 38](#java-class-and-interface-declaration)
+
+[4.7 Function Declaration 39](#function-declaration)
+
+[4.7.1 funcsize 39](#funcsize)
+
+[4.7.2 framesize 39](#framesize)
+
+[4.7.3 moduleid 39](#moduleid)
+
+[4.7.4 upformalsize 39](#upformalsize)
+
+[4.7.5 formalwordstypetagged 40](#formalwordstypetagged)
+
+[4.7.6 formalwordsrefcounted 40](#formalwordsrefcounted)
+
+[4.7.7 localwordstypetagged 40](#localwordstypetagged)
+
+[4.7.8 localwordsrefcounted 40](#localwordsrefcounted)
+
+[4.8 Initializations 40](#initializations)
+
+[4.9 Type Parameters 41](#type-parameters)
+
+Introduction
+============
+
+MAPLE IR is an internal program representation to support program
+compilation, analysis, optimization and execution. The name MAPLE comes
+from the acronym "Multiple Architecture and Programming Language
+Environment". Because information in the source program may be useful
+for program analysis and optimization, MAPLE IR aims to provide
+information about the source program that is as complete as possible.
+
+Program information is represented in two parts: the declaration part
+for defining the program constructs and the execution part specifying
+the program code. The former is often collectively referred to as the
+symbol table, though there can be different types of tables.
+
+MAPLE IR is target-independent. It is not pre-disposed towards any
+specific target processor or processor characteristic.
+
+MAPLE IR can be regarded as the ISA of a virtual machine (VM). The MAPLE
+VM can be regarded as a general purpose processor that takes MAPLE IR as
+input and directly executes the program portion of the MAPLE IR.
+
+MAPLE IR is the common representation for programs compiled from
+different programming languages, which include general purpose languages
+like C, C++, Java and Javascript. MAPLE IR is extensible. As additional
+languages, including domain-specific languages, are compiled into MAPLE
+IR, more constructs will be added to represent constructs unique to each
+language.
+
+The compilation process can be viewed as a gradual lowering of the
+program representation from high level human perceivable form to low
+level machine executable form. MAPLE IR is capable of supporting all
+known program analyses and optimizations, owing to its flexibility of
+being able to represent program code at multiple semantic levels. At the
+highest level, MAPLE IR exhibits more variety of program constructs,
+corresponding to abstract language operations or constructs unique to
+the language it is translated from. As a result, the code sequences at
+the higher levels are shorter. Language or domain specific optimizations
+are best performed at the higher levels. At the higher levels, there are
+also constructs that are hierarchical in nature, like nested blocks and
+expression trees. Nearly all program information is retained at the
+highest level.
+
+As compilation proceeds, MAPLE IR is gradually lowered so that the
+granularity of its operations corresponds more closely to the
+instructions of a general purpose processor. The code sequences become
+longer as many high-level constructs are disallowed. At the same time,
+the program constructs become less hierarchical. It is at the lower
+levels where general purpose optimizations are performed. In particular,
+at the lowest level, MAPLE IR instructions map nearly one-to-one to the
+machine instructions of the mainstream processor ISAs. This is where the
+effects of optimizations at the IR level are maximized, as each
+eliminated operation will have the corresponding effect on the target
+machine. At the lowest level, all operations, including type conversion
+operations, are explicitly expressed at the IR level so that they can be
+optimized by the compiler. The lowest level of MAPLE IR is also its
+executable form, where the program structure is flat to allow the
+sequential form of program execution. Expression trees are laid out in
+prefix form and they are evaluated by the execution engine using the
+stack machine model.
+
+Program Representation in MAPLE IR
+==================================
+
+The internal representation of MAPLE IR consists of tables for the
+declaration part and tree nodes for the execution part. In the execution
+part, each tree node represents one MAPLE IR instruction, and is just
+large enough to store the instruction's contents. Externally, MAPLE IR
+can exist in either binary or ASCII formats. The binary format is a
+straightforward dump of the byte contents of the internal program data
+structures. The ASCII form is editable, which implies that it is
+possible to program in MAPLE IR directly. The ASCII form of MAPLE IR has
+a layout similar to the C language. Declarations are followed by
+executable code. Expressions are displayed in in-fix notation, using
+parentheses to explicitly indicate the nesting relationships.
+
+The language front-end compiles a source file into a MAPLE IR file.
+Thus, each MAPLE IR file corresponds to a compilation unit, referred to
+as a *module*. A module is made up of declarations at the global scope.
+Among the declarations are functions. Inside each function are
+declarations at the local scope followed by the executable code of the
+function.
+
+There are three kinds of executable nodes in MAPLE IR:
+
+1.  Leaf nodes - Also called terminal nodes, these nodes denote a value
+    at execution time, which may be a constant or the value of a storage
+    unit.
+
+2.  Expression nodes - An expression node performs an operation on its
+    operands to compute a result. Its result is a function of the values
+    of its operands and nothing else. Each operand can be either a leaf
+    node or another expression node. Expression nodes are the internal
+    nodes of expression trees.
+
+3.  Statement nodes - These represent the flow of control. Execution
+    starts at the entry of the function and continues sequentially
+    statement by statement until a control flow statement is executed.
+    Apart from modifying control flow, statements can also modify data
+    storage in the program. A statement node has operands that can be
+    leaf, expression or statement nodes.
+
+In all the executable nodes, the opcode field specifies the operation of
+the node, followed by additional field specification relevant to the
+opcode. The operands for the node are specified inside parentheses
+separated by commas. The general form is:
+
+```
+        opcode fields (opnd0, opnd1, opnd2)
+```
+
+For example, the C statement \"a = b\" is translated to the **dassign**
+node that assigns the right hand side operand b to a .
+
+```
+        dassign $a (dread i32 $b)
+```
+
+In the declaration part, each declaration is a statement. Each
+declaration or execution statement must start a new line, and each line
+cannot contain more than one statement node. A statement node can occupy
+more than one line. The character \'\#\' can appear anywhere to indicate
+that the contents from the \'\#\' to the end of the line are comments.
+
+Symbol Tables
+-------------
+
+Program information that is of declarative nature is stored in the
+symbol table portion of the IR. Having the executable instructions refer
+to the symbol tables reduces the amount of information that needs to be
+stored in the executable instructions. For each declaration scope, there
+is a main table called the Symbol Table that manages all the
+user-defined names in that scope. This implies one global Symbol Table
+and a local Symbol Table for each function declared in the file. The
+various types of symbol entries correspond to the kinds of constructs
+that can be assigned names, including:
+
+1.  Types
+
+2.  Variables
+
+3.  Functions (either prototypes or with function bodies)
+
+In the ASCII format, the IR instructions refer to the various symbols by
+their names. In the binary representation, the symbols are referred to
+via their table indices..
+
+Primitive Types
+---------------
+
+Primitive types can be regarded as pre-defined types supported by the
+execution engine such that they can be directly operated on. They also
+play a part in conveying the semantics of operations, as addresses are
+distinct from unsigned integers. The number in the primitive type name
+indicates the storage size in bits.
+
+The primitive types are:
+
+```
+      no type - void
+      signed integers - i8, i16, i32, i64
+      unsigned integers - u8, u16, u32, u64
+      booleans- u1
+      addresses - ptr, ref, a32, a64
+      floating point numbers - f32, f64
+      complex numbers - c64, c128
+      aggregates - agg
+      javascript types:
+        dynany
+        dynu32
+        dyni32
+        dynundef
+        dynnull
+        dynhole
+        dynbool
+        dynptr
+        dynf64
+        dynf32
+        dynstr
+        dynob
+      SIMD types -- v2i64, v4i32, v8i16, v16i8, v2f64, v4f32
+      unknown
+```
+
+An instruction that produces or operates on values must specify the
+primitive type in the instruction, as the type is not necessarily
+implied by the opcode. There is the distinction between result type and
+operand type. Result type can be regarded as the type of the value as it
+resides in a machine register, because arithmetic operations in the
+mainstream processor architectures are mostly register-based. When an
+instruction only specifies a single primitive type, the type specified
+applies to both the operands and the result. In the case of instructions
+where the operand and result types may differ, the primitive type
+specified is the result type, and a second field is added to specify the
+operand type.
+
+Some opcodes are applicable to non-primitive (or derived) types, as in
+an aggregate assignment. When the type is derived, agg can be used. In
+such cases, the data size can be found by looking up the type of the
+symbol .
+
+The primitive types *ptr* and *ref* are the target-independent types for
+addresses. *ref* conveys the additional semantics that the address is a
+reference to a run-time managed block of memory or object in the heap.
+Uses of ptr or ref instead of a32 or a64 allow the IR to be independent
+of the target machine by not manifesting the size of addresses until the
+later target-dependent compilation phases.
+
+The primitive type unknown is used by the language front-end when the
+type of a field in an object has not been fully resolved because the
+full definition resides in a different compilation unit.
+
+Constants
+---------
+
+Constants in MAPLE IR are always of one of the primitive types.
+
+Integer and address (pointer) types can be specified in decimal or in
+hexadecimal using the 0x prefix.
+
+Floating point types can be specified in hexadecimal or as floating
+point literal as in standard C.
+
+Single characters enclosed in single quotes can be used for i8 and u8
+constants.
+
+String literals are enclosed in double quotes.
+
+For the complex and SIMD types, the group of values are enclosed in
+square brackets separated by commas.
+
+Identifiers (\$ % &)
+--------------------
+
+In ASCII MAPLE IR, standalone identifier names are regarded as keywords
+of the MAPLE IR language. To refer to entries in the symbol tables,
+identifier names must be prefixed.
+
+**\$** - Identifiers prefixed with \'\$\' are global variables and will
+be looked up in the global Symbol Table.
+
+**%** - Identifiers prefixed with \'%\' are local variables and will be
+looked up in the local Symbol Table.
+
+**&** - Identifiers prefixed with \'&\' are function or method names and
+will be looked up in the Functions Table. The major purpose of these
+prefixes is to avoid name clash with the keywords (opcode names, etc.)
+in the IR.
+
+Pseudo-registers (%)
+--------------------
+
+Pseudo-registers can be regarded as local variables of a primitive type
+whose addresses are never taken. They can be declared implicitly by
+their appearances. The primitive type associated with a pseudo-register
+is sticky.
+
+Because pseudo-registers can only be created to store primitive types,
+the use of field IDs does not apply to them. Pseudo-registers are
+referred to by the \'%\' prefix followed by a number. This distinguishes
+them from other local variables that are not pseudo-registers, as their
+names cannot start with a number.
+
+The compiler will promote variables to pseudo-registers. To avoid the
+loss of high level type information when a variable is promoted to
+pseudo-registers, reg declarations are used to provide the type
+information associated with the pseudo-registers.
+
+Special Registers (%%)
+----------------------
+
+Special registers are registers with special meaning. They are all
+specified using %% as prefix. **%%SP** is the stack pointer and **%%FP**
+the frame pointer in referencing the stack frame of the current
+function. **%%GP** is the global pointer used for addressing global
+variables. **%%PC** is the program counter. **%%thrownval** stores the
+thrown value after throwing an exception.
+
+Special registers **%%retval0**, **%%retval1**, **%%retval2**, etc. are
+used for fetching the multiple values returned by a call. They are
+overwritten by each call, and should only be read at most once after
+each call. They can assume whatever is the type of the return value.
+
+Statement Labels (@)
+--------------------
+
+Label names are prefixed with \'@\' which serves to identify them. Any
+statement beginning with a label name defines that label as referring to
+that text position. Labels are only referred to locally by goto and
+branch statements.
+
+Storage Accesses
+----------------
+
+Since MAPLE IR is target-independent, it does not exhibit any
+pre-disposition as to how storage are allocated for the program
+variables. It only applies rules defined by the language regarding
+storage.
+
+In general, there are two distinct kinds of storage accesses: direct and
+indirect. Direct accesses do not require any run-time computation to
+determine the exact address location. Indirect accesses require address
+arithmetic before the location can be determined. Indirect accesses are
+associated with pointer dereferences and arrays. Direct accesses are
+associated with scalar variables and fixed fields inside structures.
+
+Direct accesses can be mapped to pseudo-register if the variable or
+field has no alias. Indirect accesses cannot be mapped to
+pseudo-registers unless the computed address does not change.
+
+In MAPLE IR, **dassign** and **dread** are the opcodes for direct
+assignments and direct references; **iassign** and **iread** are the
+opcodes for indirect assignments and indirect references.
+
+Aggregates
+----------
+
+Aggregates (or composites) are either structures or arrays. They both
+designate a grouping of storage elements. In structures, the storage
+elements are designated by field names and can be of different types and
+sizes. Classes and objects are special kinds of structures in
+object-oriented programming languages. In arrays, the same storage
+element is repeated a number of times and the elements are accessed via
+index (or subscript).
+
+### Arrays
+
+Array subscripting designates address computation. Since making the
+subscripts stand out facilitate data dependency analysis and other loop
+oriented optimizations, MAPLE IR represents array subscripting using the
+special **array** opcode, which returns the address resulting from the
+subscripting operation. For example, \"a\[i\] = i\" is:
+```
+    # <* [10] i32> is pointer to array of 10 ints
+    iassign <* i32> (
+      array a32 <* [10] i32> (addrof a32 $a, dread i32 $i),
+      dread i32 \$i)
+```
+
+and \"x = a\[i,j\]\" is:
+
+
+```
+    # <* [10] [10] i32 indicates pointer to a 10x10 matrix of ints
+    dassign $x (
+      iread i32 <* i32> (
+      array a32 <* [10] [10] i32> (addrof a32 $a, dread i32 $i, dread i32 $j)))
+```
+
+### Structures
+
+Fields in a structure can be accessed directly, but use of **dassign**
+or **dread** on a structure would refer to the entire structure as an
+aggregate. Thus, we extend **dassign**, **dread**, **iassign** and
+**iread** to take an additional parameter called field-ID.
+
+In general, for a top level structure, unique field-IDs can be assigned
+to all the fields contained inside the structure. Field-ID 0 is assigned
+to the top level structure (the entire structure). Field-ID is also 0 if
+it is not a structure. As each field is visited, the field-ID is
+incremented by 1. If a field is a structure, that structure is assigned
+a unique field-ID, and then field-ID assignments continue with the
+fields inside the nested structure. If a field is an array, the array is
+assigned only one field-ID.
+
+Note that if a structure exists both standalone and nested inside
+another structure, the same field inside the structure will be assigned
+different field-IDs because field-ID assignment always starts from the
+top level structure.
+
+Three kinds of structures are supported: **struct**, **class** and
+**interface**.
+
+A **struct** corresponds to the struct type in C, and is specified by
+the **struct** keyword followed by a list of field declarations enclosed
+by braces, as in:
+```
+    struct {
+      @f1 i32,
+      @f2 <$structz> } # $structz is the type name of another struct
+```
+A **class** corresponds to the class type in Java, to provide single
+inheritances. The syntax is the same as struct except for an additional
+type name specified after the class keyword that specifies the class it
+inherits from. Fields in the parent class are also referred to via
+field-IDs, as if the first field of the derived class is the parent
+class. In other words, the parent class is treated like a sub-structure.
+```
+    class <$classz> { # $classz is the parent of this class being defined
+      @f1 i32,
+      @f2 f32 }
+```
+Unrelated to storage, structures can contain member function prototypes.
+The list of member function prototypes must appear after all the fields
+have been specified. Each member function name starts with &, which
+indicates that it is a function prototype. The prototype specification
+follows the same syntax as ordinary function prototypes.
+
+An **interface** corresponds to the interface type in Java, and has the
+same form as class, except that it cannot be instantiated via a var
+declaration, and fields declared inside it are always statically
+allocated. More details are provided later in this document.
+
+Instruction Specification
+=========================
+
+In MAPLE IR expression trees, we use parentheses or braces to
+distinguish operands from the other fields of an instruction, to
+facilitate visualization of the nested structure of MAPLE IR. The
+expression operands of each instruction are always enclosed by
+parentheses, using commas to separate the operands. Statement operands
+are indicated via braces.
+
+Storage Access Instructions
+---------------------------
+
+A memory access instruction either loads a memory location to a register
+for further processing, or store a value from register to memory. For
+load instructions, the result type given in the instruction is the type
+of the loaded value residing in register. If the memory location is of
+size smaller than the register size, the value being loaded must be of
+integer type, and there will be implicit zero- or sign-extension
+depending on the signedness of the result type.
+
+### dassign
+
+syntax: dassign \<var-name\> \<field-id\> (\<rhs-expr\>)
+
+\<rhs-expr\> is computed to return a value, which is then assigned to
+variable \<var-name\>. If \<field-id\> is not 0, then the variable must
+be a structure, and the assignment only applies to the specified field.
+If \<rhs-expr\> is of type agg, then the size of the structure must
+match. If \<rhs-expr\> is a primitive integer type, the assigned
+variable may be smaller, resulting in a truncation. If\<field-id\> is
+not specified, it is assumed to be 0.
+
+### dread
+
+syntax: dread \<prim-type\> \<var-name\> \<field-id\>
+
+Variable \<var-name\> is read from its storage location. If the variable
+is a structure, then \<prim-type\> should specify agg. If \<field-id\>
+is not 0, then the variable must be a structure, and instead of reading
+the entire variable, only the specified field is read. If the field
+itself is also a structure, then \<prim-type\> should also specify agg.
+If \<field-id\> is not specified, it is assumed to be 0.
+
+### iassign
+
+syntax: iassign \<type\> \<field-id\> (\<addr-expr\>, \<rhs-expr\>)
+
+\<addr-expr\> is computed to return an address. \<type\> gives the high
+level type of \<addr-expr\> and must be a pointer type. \<rhs-expr\> is
+computed to return a value, which is then assigned to the location
+specified by \<addr-expr\>. If \<field-id\> is not 0, then the computed
+address must correspond to a structure, and the assignment only applies
+to the specified field. If \<rhs-expr\> is of type agg, then the size of
+the structure must match. The size of the location affected by the
+assignment is determined by what \<type\> points to. If \<rhs-expr\> is
+a primitive integer type, the assigned location (according to what
+\<type\> points to) may be smaller, resulting in a truncation. If
+\<field-id\> is not specified, it is assumed to be 0.
+
+### iread
+
+syntax: iread \<prim-type\> \<type\> \<field-id\> (\<addr-expr\>)
+
+The content of the location specified by the address computed from the
+address expression \<addr-expr\> is read (dereferenced) as the given
+primitive type. \<type\> gives the high level type of \<addr-expr\> and
+must be a pointer type. If the content dereferenced is a structure (as
+given by what \<type\> points to), then \<prim-type\> should specify
+agg. If \<field-id\> is not 0, then \<type\> must specify pointer to a
+structure, and instead of reading the entire structure, only the
+specified field is read. If the field itself is also a structure, then
+\<prim-type\> should also specify agg. If \<field-id\> is not specified,
+it is assumed to be 0.
+
+### iassignoff
+
+syntax: iassignoff \<prim-type\> \<offset\> (\<addr-expr\>,
+\<rhs-expr\>)
+
+\<rhs-expr\> is computed to return a scalar value, which is then
+assigned to the memory location formed by the addition of \<offset\> in
+bytes to \<addr-expr\>. \<prim-type\> gives the type of the stored-to
+location, which also specifies the size of the affected memory location.
+
+### iassignfpoff
+
+syntax: iassignfpoff \<prim-type\> \<offset\> (\<rhs-expr\>)
+
+\<rhs-expr\> is computed to return a scalar value, which is then
+assigned to the memory location formed by the addition of \<offset\> in
+bytes to %%FP. \<prim-type\> gives the type of the stored-to location,
+which also specifies the size of the affected memory location. This is
+the same as iassignoff where its \<addr-expr\> is %%FP.
+
+### iassignpcoff
+
+syntax: iassignpcoff \<prim-type\> \<offset\> (\<rhs-expr\>)
+
+\<rhs-expr\> is computed to return a scalar value, which is then
+assigned to the memory location formed by the addition of \<offset\> in
+bytes to %%PC.  \<prim-type\> gives the type of the stored-to location,
+which also specifies the size of the affected memory location
+
+### ireadoff
+
+syntax: ireadoff \<prim-type\> \<offset\> (\<addr-expr\>)
+
+\<prim-type\> must be of scalar type. \<offset\> in bytes is added to
+\<addr-expr\> to form the address of the memory location to be read as
+the specified scalar type.
+
+### ireadfpoff
+
+syntax: ireadfpoff \<prim-type\> \<offset\>
+
+\<prim-type\> must be of scalar type. \<offset\> in bytes is added to
+%%FP to form the address of the memory location to be read as the
+specified scalar type. This is the same as ireadoff where its
+\<addr-expr\> is %%FP.
+
+### ireadpcoff
+
+syntax: ireadpcoff \<prim-type\> \<offset\>
+
+\<prim-type\> must be of scalar type.  \<offset\> in bytes is added to
+%%PC to form the address location to be read as the specified scalar
+type.
+
+### regassign
+
+syntax: regassign \<prim-type\> \<register\> (\<rhs-expr\>)
+
+\<rhs-expr\> is computed to return a scalar value, which is then
+assigned to the pseudo or special register given by \<register\>.
+\<prim-type\> gives the type of the register, which also specifies the
+size of the value being assigned.
+
+### regread
+
+syntax: regread \<prim-type\> \<register\>
+
+The given pseudo or special register is read in the scalar type
+specified by \<prim-type\>.
+
+Leaf Opcodes
+------------
+
+dread and regread are leaf opcodes for reading the contents of
+variables. The following are additional leaf opcodes:
+
+### addrof
+
+syntax: addrof \<prim-type\> \<var-name\> \<field-id\>
+
+The address of the variable \<var-name\> is returned. \<prim-type\> must
+be either ptr, a32 or a64. If \<field-id\> is not 0, then the variable
+must be a structure, and the address of the specified field is returned
+instead.
+
+### addroflabel
+
+syntax: addroflabel \<prim-type\> \<label\>
+
+The text address of the label is returned. \<prim-type\> must be either
+a32 or a64.
+
+### addroffunc
+
+syntax: addroffunc \<prim-type\> \<function-name\>
+
+The text address of the function is returned. \<prim-type\> must be
+either a32 or a64.
+
+### addroffpc
+
+syntax: addroffpc \<prim-type\> \<offset\>
+
+\<prim-type\> must be either a32 or a64.  \<offset\> in bytes is added
+to %%PC to form the address value being returned.
+
+### conststr
+
+syntax: conststr \<prim-type\> \<string literal\>
+
+The address of the string literal is returned. \<prim-type\> must be
+either ptr, a32 or a64. The string must be stored in read-only memory.
+
+### conststr16
+
+syntax: conststr16 \<prim-type\> \<string literal\>
+
+The address of the string literal composed of 16-bit wide characters is
+returned. \<prim-type\> must be either ptr, a32 or a64. The string must
+be stored in read-only memory.
+
+### constval
+
+syntax: constval \<prim-type\> \<const-value\>
+
+The specified constant value of the given primitive type is returned.
+Since floating point values cannot be represented in ASCII without loss
+of accuracy, they can be specified in hexadecimal form, in which case
+\<prim-type\> indicates the floating point type.
+
+### sizeoftype
+
+syntax: sizeoftype \<int-prim-type\> \<type\>
+
+The size in bytes of \<type\> is returned as an integer constant value.
+Since type size is in general target-dependent, use of this opcode
+preserves the target independence of the program code.
+
+Unary Expression Opcodes
+------------------------
+
+These are opcodes with a single operand.
+
+### abs
+
+syntax: abs \<prim-type\> (\<opnd0\>)
+
+The absolute value of the operand is returned.
+
+### bnot
+
+syntax: bnot \<prim-type\> (\<opnd0)
+
+Each bit in the operand is reversed and the resulting value is returned.
+
+### extractbits
+
+syntax: extractbits \<int-type\> \<boffset\> \<bsize\> (\<opnd0\>)
+
+The bitfield starting at bit position \<boffset\> with \<bsize\> number
+of bits is extracted and then sign- or zero- extended to form the
+primitive integer given by \<int-type\>. The operand must be of integer
+type and must be large enough to contain the specified bitfield.
+
+###  iaddrof
+
+syntax: iaddrof \<prim-type\> \<type\> \<field-id\>(\<addr-expr\>)
+
+\<type\> gives the high level type of \<addr-expr\> and must be a
+pointer type. The address of the pointed-to item is returned.
+\<prim-type\> must be either ptr, a32 or a64. If \<field-id\> is not 0,
+then \<type\> must specify a pointer to a structure, and the address of
+the specified field in the structure is returned instead. This operation
+is of no utility if \<fielid\_id\> is 0, as it will just return the
+value of \<addr-expr\>.
+
+### lnot
+
+syntax: lnot \<prim-type\> (\<opnd0\>)
+
+If the operand is not 0, 0 is returned. If the operand is 0, 1 is
+returned.
+
+### neg
+
+syntax: neg \<prim-type\> (\<opnd0\>)
+
+The operand value is negated and returned.
+
+### recip
+
+syntax: recip \<prim-type\> (\<opnd0\>)
+
+The reciprocal of the operand is returned. \<prim-type\> must be a
+floating-point type.
+
+### sext
+
+syntax: sext \<signed-int-type\> \<bsize\> (\<opnd0\>)
+
+Sign-extend the integer by treating the integer size as being \<bsize\>
+bits. This can be regarded as a special case of extractbits where the
+bitfield is in the lowest bits. The primitive type \<signed-int-type\>
+stays the same.
+
+### sqrt
+
+syntax: sqrt \<prim-type\> (\<opnd0\>)
+
+The square root of the operand is returned. \<prim-type\> must be a
+floating-point type.
+
+### zext
+
+syntax: zext \<unsigned-int-type\> \<bsize\> (\<opnd0\>)
+
+Zero-extend the integer by treating the integer size as being \<bsize\>
+bits. This can be regarded as a special case of extractbits where the
+bitfield is in the lowest bits. The primitive type \<unsigned-int-type\>
+stays the same.
+
+Type Conversion Expression Opcodes
+----------------------------------
+
+Type conversion opcodes are unary in nature. With the exception of
+retype, they all require specifying both the from and to types in the
+instruction. Conversions between integer types of different sizes
+require the cvt opcode.
+
+Conversion between signed and unsigned integers of the same size does
+not require any operation, not even retype.
+
+### ceil
+
+syntax: ceil \<prim-type\> \<float-type\> (\<opnd0\>)
+
+The floating point value is rounded towards positive infinity.
+
+### cvt
+
+syntax: cvt \<to-type\> \<from-type\> (\<opnd0\>)
+
+Convert the operand\'s value from \<from-type\> to \<to-type\>. This
+instruction must not be used If the sizes of the two types are the same
+and the conversion does not result in altering the bit contents.
+
+### floor
+
+syntax: floor \<prim-type\> \<float-type\> (\<opnd0\>)
+
+The floating point value is rounded towards negative infinity.
+
+### Retype
+
+syntax: retype \<prim-type\> \<type\> (\<opnd0\>)
+
+\<opnd0\> is converted to \<prim-type\> which has derived type \<type\>
+without changing any bits. The size of \<opnd0\> and \<prim-type\> must
+be the same. \<opnd0\> may be of aggregate type.
+
+### round
+
+syntax: round \<prim-type\> \<float-type\> (\<opnd0\>)
+
+The floating point value is rounded to the nearest integer.
+
+### trunc
+
+syntax: trunc \<prim-type\> \<float-type\> (\<opnd0\>)
+
+The floating point value is rounded towards zero.
+
+Binary Expression Opcodes
+-------------------------
+
+These are opcodes with two operands.
+
+### add
+
+syntax: add \<prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform the addition of the two operands.
+
+### ashr
+
+syntax: ashr \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Return \<opnd0\> with its bits shifted to the right by \<opnd1\> bits.
+The high order bits shifted in are set according to the original sign
+bit.
+
+### band
+
+syntax: band \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform the bitwise AND of the two operands.
+
+### bior
+
+syntax: bior \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform the bitwise inclusive OR of the two operands.
+
+### bxor
+
+syntax: bxor \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform the bitwise exclusive OR of the two operands.
+
+### cand
+
+syntax: cand \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform the logical AND of the two operands via short-circuiting. If
+\<opnd0\> yields 0, \<opnd1\> is not to be evaluated. The result is
+either 0 or 1.
+
+### cior
+
+syntax: cior \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform the logical inclusive OR of the two operands via
+short-circuiting. If \<opnd0\> yields 1, \<opnd1\> is not to be
+evaluated. The result is either 0 or 1.
+
+### cmp
+
+syntax: cmp \<int-type\> \<opnd-prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Performs a comparison between \<opnd0\> and \<opnd1\>. If the two
+operands are equal, return 0. If \<opnd0\> is less than \<opnd1\>,
+return -1. Otherwise, return +1.
+
+### cmpg
+
+syntax: cmpg \<int-type\> \<opnd-prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Same as cmp, except 1 is returned if any operand is NaN.
+
+### cmpl
+
+syntax: cmpl \<int-type\> \<opnd-prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Same as cmp, except -1 is returned if any operand is NaN.
+
+### depositbits
+
+syntax: depositbits \<int-type\> \<boffset\> \<bsize\> (\<opnd0\>,
+\<opnd1\>)
+
+Creates a new integer value by depositing the value of \<opnd1\> into
+the range of bits in \<opnd0\> that starts at bit position \<boffset\>
+and runs for \<bsize\> bits. \<opnd0\> must be large enough to contain
+the specified bitfield.
+
+Depending on the size of \<opnd1\> relative to the bitfield, there may
+be truncation. The rest of the bits in \<opnd0\> remains unchanged.
+
+### div
+
+syntax: div \<prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform \<opnd0\> divided by \<opnd1\> and return the result.
+
+### eq
+
+syntax: eq \<int-type\> \<opnd-prim-type\> (\<opnd0\>, \<opnd1\>)
+
+If the two operands are equal, return 1. Otherwise, return 0.
+
+### ge
+
+syntax: ge \<int-type\> \<opnd-prim-type\> (\<opnd0\>, \<opnd1\>)
+
+If \<opnd0\> is greater than or equal to \<opnd1\>, return 1. Otherwise,
+return 0.
+
+### gt
+
+syntax: ge \<int-type\> \<opnd-prim-type\> (\<opnd0\>, \<opnd1\>)
+
+If \<opnd0\> is greater than \<opnd1\>, return 1. Otherwise, return 0.
+
+### land
+
+syntax: land \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform the logical AND of the two operands. The result is either 0 or
+1.
+
+### lior
+
+syntax: lior \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform the logical inclusive OR of the two operands. The result is
+either 0 or 1.
+
+### le
+
+syntax: le \<int-type\> \<opnd-prim-type\> (\<opnd0\>, \<opnd1\>)
+
+If \<opnd0\> is less than or equal to \<opnd1\>, return 1. Otherwise,
+return 0.
+
+### lshr
+
+syntax: lshr \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Return \<opnd0\> with its bits shifted to the right by \<opnd1\> bits.
+The high order bits shifted in are set to 0.
+
+### lt
+
+syntax: lt \<int-type\> \<opnd-prim-type\> (\<opnd0\>, \<opnd1\>)
+
+If \<opnd0\> is less than \<opnd1\>, return 1. Otherwise, return 0.
+
+### max
+
+syntax: max \<prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Return the maximum of \<opnd0\> and \<opnd1\>.
+
+### min
+
+syntax: min \<prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Return the minimum of \<opnd0\> and \<opnd1\>.
+
+### mul
+
+syntax: mul \<prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Perform the multiplication of the two operands.
+
+### ne
+
+syntax: ne \<int-type\> \<opnd-prim-type\> (\<opnd0\>, \<opnd1\>)
+
+If the two operands are not equal, return 1. Otherwise, return 0.
+
+### rem
+
+syntax: rem \<prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Return the remainder when \<opnd0\> is divided by \<opnd1\>.
+
+### shl
+
+syntax: shl \<int-type\> (\<opnd0\>, \<opnd1\>)
+
+Return \<opnd0\> with its bits shifted to the left by \<opnd1\> bits.
+The low order bits shifted in are set to 0.
+
+### sub
+
+syntax: sub \<prim-type\> (\<opnd0\>, \<opnd1\>)
+
+Subtract \<opnd1\> from \<opnd0\> and return the result.
+
+Ternary Expression Opcodes
+--------------------------
+
+These are opcodes with three operands.
+
+### select
+
+syntax: select \<prim-type\> (\<opnd0\>, \<opnd1\>, \<opnd2\>)
+
+\<opnd0\> must be of integer type. \<opnd1\> and \<opnd2\> must be of
+the type given by \<prim-type\>. If \<opnd0\> is not 0, return
+\<opnd1\>. Otherwise, return \<opnd2\>.
+
+N-ary Expression Opcodes
+------------------------
+
+These are opcodes that can have any number of operands.
+
+### array
+
+syntax: array \<check-flag\> \<addr-type\> \<array-type\> (\<opnd0\>,
+\<opnd1\>, . . . , \<opndn\>)
+
+\<opnd0\> is the base address of an array in memory. \<check-flag\> is
+either 0 or 1, indicating bounds-checking needs not be performed or
+needs to be performed respectively. \<array-type\> gives the high-level
+type of a pointer to the array. Return the address resulting from
+row-major order multi-dimentional indexing operation, with the indices
+represented by \<opnd1\> onwards. Since arrays must have at least one
+dimension, this opcode must have at least two operands.
+
+### intrinsicop
+
+syntax: intrinsicop \<prim-type\> \<intrinsic\> (\<opnd0\>, \...,
+\<opndn\>)
+
+\<intrinsic\> indicates an intrinsic function that has no side effect
+whose return value depends only on the arguments (a pure function), and
+thus can be represented as an expression opcode.
+
+### intrinsicopwithtype
+
+syntax: intrinsicopwithtype \<prim-type\> \<type\> \<intrinsic\>
+(\<opnd0\>, \..., \<opndn\>)
+
+This is the same as intrinsicop except that it takes on an additional
+high level type argument specified by \<type\>.
+
+Control Flow Statements
+-----------------------
+
+Program control flows can be represented by either hierarchical
+statement structures or a flat list of statements. Hierarchical
+statement structures are mostly derived from constructs in the source
+language. Flat control flow statements correspond more closely to
+processor instructions. Thus, hierarchical statements exist only in high
+level MAPLE IR. They are lowered to the flat control flow statements in
+the course of compilation.
+
+A statement block is indicated by multiple statements enclosed inside
+the braces \'{\' and \'}\'. Such statement blocks can appear any where
+that a statement is allowed. In hierarchical statements, nested
+statements are specified by such statement blocks. Statement blocks
+should only associated with hierarchical control flow statements.
+
+In MAPLE IR, each statement must start on a new line. The use of
+semicolon is not needed, or even allowed, to indicate the end of
+statements.
+
+### Hierarchical control flow statements
+
+#### doloop
+
+syntax:
+```
+    doloop <do-var> (<start-expr>, <cont-expr>, <incr-amt>) {
+      <body-stmts> }
+```
+
+\<do-var\> specifies a local integer scalar variable with no alias.
+\<incr-amt\> must be an integer expression. \<do-var\> is initialized
+with \<start-expr\>. \<cont-expr\> must be a single comparison operation
+representing the termination test. The loop body is represented by
+\<body-stmts\>, which specifies the list of statements to be executed as
+long as \<cont-expr\> evaluates to true. After each execution of the
+loop body, \<do-var\> is incremented by \<incr-amt\> and the loop is
+tested again for termination.
+
+#### dowhile
+
+syntax:
+```
+    dowhile {
+      <body-stmts>
+    } (<cond-expr>)
+```
+Execute the loop body represented by \<body-stmts\>, and while
+\<cond-expr\> evaluates to non-zero, continue to execute \<body-stmts\>.
+Since \<cond-expr\> is tested at the end of the loop body, the loop body
+is executed at least once.
+
+#### foreachelem
+
+syntax:
+```
+    foreach <elem-var> <collection-var> {
+      <body-stmts> }
+```
+
+This is an abstract loop form where \<collection-var\> is an array-like
+variable representing a collection of uniform elements, and \<elem-var\>
+specifies a variable whose type is the element type of
+\<collection-var\>. The loop body is represented by \<body-stmts\>,
+which specifies the list of statements to be repeated for each element
+of \<collection-var\> expressed via \<elem-var\>. This statement will be
+lowered to a more concrete loop form based on the type of
+\<collection-var\>.
+
+#### if
+
+syntax:
+```
+    if (<cond-expr>) {
+      <then-part> }
+    else {
+      <else-part> }
+```
+If \<cond-expr\> evaluates to non-zero, control flow passes to the
+\<then-part\> statements. Otherwise, control flow passes to the
+\<else-part\> statements. If there is no else part, \"else {
+\<else-part\> }\" can be omitted.
+
+#### while
+
+syntax:
+```
+    while (<cond-expr>) {
+      <body-stmts> }
+```
+This implements the while loop. While \<cond-expr\> evaluates to
+non-zero, the list of statements represented by \<body-stmts\> are
+repeatedly executed. Since \<cond-expr\> is tested before the first
+execution, the loop body may execute zero times.
+
+### Flat control flow statements
+
+#### brfalse
+
+syntax: brfalse \<label\> (\<opnd0\>)
+
+If \<opnd0\> evaluates to 0, branch to \<label\>. Otherwise, fall
+through.
+
+#### brtrue
+
+syntax: brtrue \<label\> (\<opnd0\>)
+
+If \<opnd0\> evaluates to non-0, branch to \<label\>. Otherwise, fall
+through.
+
+#### goto
+
+syntax: goto \<label\>
+
+Transfer control unconditionally to \<label\>.
+
+#### igoto
+
+syntax: igoto (\<opnd0\>)
+
+\<opnd0\> must evaluate to the address of a label.  Transfer control unconditionally to the evaluated label address.
+
+#### multiway
+
+syntax:
+```
+    multiway (<opnd0>) <default-label> {
+      (<expr0>): goto <label0>
+      (<expr1>): goto <label1>
+      ...
+      (<exprn>): goto <labeln> }
+```
+
+\<opnd0\> must be of type convertible to an integer or a string.
+Following \<default-label\> is a table of pairs of expression tags and
+labels. When executed, it evaluates \<opnd0\> and then searches the
+table for a match of the evaluated value of \<opnd0\> with the evaluated
+value of each expression tag \<expri\> in the listed order. On a match,
+control is transferred to the corresponding label. If no match is found,
+control is transferred to \<default- label\>. The evaluation of the
+expression tags must not incur side effect. Depending on the resolved
+type of \<opnd0\>, this statement will be lowered to either the switch
+statement or a cascade of if statements.
+
+#### return
+
+syntax: return (\<opnd0\>, . . ., \<opndn\>)
+
+Return from the current PU with the multiple return values given by the
+operands. The list of operands can be empty, which corresponds to no
+return value. The types of \<opndi\> must be compatible with the list of
+return types according to the declaration or prototype of the PU.
+
+#### switch
+
+syntax:
+```
+    switch (<opnd0>) <default-label> {
+      <intconst0>: goto <label0>
+      <intconst1>: goto <label1>
+      ...
+      <intconstn>: goto <labeln> }
+```
+
+\<opnd0\> must be of integer type. After \<default-label\>, it specifies
+a table of pairs of constant integer values (tags) and labels. When
+executed, it searches the table for a match with the evaluated value of
+\<opnd0\> and transfers control to the corresponding label. If no match
+is found, control is transferred to \<default-label\>. There must not be
+duplicate entries for the constant integer values. It is up to the
+compiler backend to decide how to actually generate code for this
+statement after analyzing the tag distribution in the table.
+
+#### rangegoto
+
+syntax:
+```
+    rangegoto (<opnd0> <tag-offset> {
+      <intconst0>: goto <label0>
+      <intconst1>: goto <label1>
+      ...
+      <intconstn>: goto <labeln> }
+```
+
+This is the lowered form of switch that explicitly designates its
+execution to be handled by the jump table mechanism. \<opnd0\> must be
+of integer type. After \<tag-offset\> follows a table of pairs of
+constant integer values and labels. In searching the table for a match
+during execution, the evaluated value of \<opnd0\> minus \<tag-offset\>
+is used during execution so as to cause transfer of control to the
+corresponding label. There must be no gap in the constant integer values
+specified, and a match is guaranteed within the range of specified
+constant integer values, which means the code generator can omit
+generation of out-of-range checks. There must be no duplicated entries
+for the constant integer values.
+
+#### indexgoto
+
+syntax: indexgoto (\<opnd0\> \<var-name\>
+
+This is only generated by the compiler as a result of lowering the
+switch statement. \<var-name\> is the name of a compiler-generated
+symbol designating a static array, or jump table, which is statically
+initialized to store labels.
+
+Each stored label marks the code corresponding to a switch case.
+Execution of this instruction uses the evaluated value of \<opnd0\> to
+index into this array and then transfers control to the label stored at
+that array element. If the evaluated value of \<opnd0\> is less than 0
+or exceeds the number of entries in the jump table, the behavior is
+undefined.
+
+Call Statements
+---------------
+
+There are various flavors of procedure invocation. Intrinsics are
+library functions known to the compiler.
+
+### call
+
+syntax: call \<func-name\> (\<opnd0\>, \..., \<opndn\>)
+
+Invoke the function while passing the parameters given by the operands.
+
+### callinstant
+
+syntax: callinstant \<generic-func-name\> \<instant-vector\> (\<opnd0\>,
+\..., \<opndn\>)
+
+Instantiate the given generic function according to instantiation vector
+\<instant-vector\> and then invoke the function while passing the
+parameters given by the operands.
+
+### icall
+
+syntax: icall (\<func-ptr\>, \<opnd0\>, \..., \<opndn\>)
+
+Invoke the function specified indirectly by \<func-ptr\>, passing the
+parameters given by \<opnd0\> onwards.
+
+### intrinsiccall
+
+syntax: intrinsiccall \<intrinsic\> (\<opnd0\>, \..., \<opndn\>)
+
+Invoke the specified intrinsic defined by the compiler while passing the
+parameters given by the operands.
+
+### intrinsiccallwithtype
+
+syntax: intrinsiccallwithtype \<type\> \<intrinsic\> (\<opnd0\>, \...,
+\<opndn\>)
+
+This is the same as intrinsiccall except that it takes on an additional
+high level type argument specified by \<type\>.
+
+### xintrinsiccall
+
+syntax: xintrinsiccall \<user-intrinsic-index\> (\<opnd0\>, \...,
+\<opndn\>)
+
+Invoke the intrinsic specified as an index into a user-defined intrinsic
+table while passing the parameters given by the operands.
+
+Java Call Statements
+--------------------
+
+The following statements are used to represent Java member function
+calls that are not yet resolved.
+
+### virtualcall
+
+syntax: virtualcall \<method-name\> (\<object-ptr\>, \<opnd0\>, \...,
+\<opndn\>)
+
+\<object-ptr\> is a pointer to an instance of a class. The class
+hierarchy is searched using the specified \<method-name\> to find the
+appropriate virtual method to invoke. The invocation will pass the
+remaining operands as parameters.
+
+### superclasscall
+
+syntax: superclasscall \<method-name\> (\<object-ptr\>, \<opnd0\>, \...,
+\<opndn\>)
+
+This is the same as virtualcall except it will not use the class\'s own
+virtual method, but the one in its closest superclass that defines the
+virtual method.
+
+### interfacecall
+
+syntax: interfacecall \<method-name\> (\<object-ptr\>, \<opnd0\>, \...,
+\<opndn\>)
+
+\<method-name\> is a method defined in an interface. \<object-ptr\> is a
+pointer to an instance of a class the implements the interface. The
+class is searched using the \<method-name\> to find the corresponding
+method to invoke. The invocation will pass the remaining operands as
+parameters.
+
+There are also virtualcallinstant, superclasscallinstant and
+interfacecallinstant for calling generic versions of the methods after
+instantiating with the specified instantiation vector. The instantiation
+vector is specified after \<method-name\>, as in the callinstant
+instruction.
+
+Calls with Return Values Assigned
+---------------------------------
+
+MAPLE IR supports calls with any number of return values. All the
+various call operations have a corresponding higher-level abstracted
+variant such that a single call operation also specify how the multiple
+function return values are assigned, without relying on separate
+statements to read the %%retval registers. Only assignments to local
+scalar variables, fields in local aggregates or pseudo-registers are
+allowed. These operations have the same names with the suffix
+\"assigned\" added. They are callassigned, callinstantassigned,
+icallassigned, intrinsiccallassigned, intrinsiccallwithtypeassigned,
+xintrinsiccallassigned, virtualcallassigned, virtualcallinstantassigned,
+superclasscallassigned, superclasscallinstantassigned,
+interfacecallassigned and interfacecallinstantassigned. Only
+callassigned is defined here. The same extension applies to the
+definitions of the rest of these call operations.
+
+### callassigned
+
+syntax:
+```
+    callassigned <func-name> (<opnd0>, ..., <opndn>) {
+      dassign <var-name0> <field-id0>
+      dassign <var-name1> <field-id1>
+      ...
+      dassign <var-namen> <field-idn> }
+```
+
+Invoke the function passing the parameters given by the operands. After
+returning from the call, the multiple return values are assigned to the
+scalar variables listed in order. If a specified field-id is not 0, then
+the corresponding variable must be an aggregate, and the assignment is
+to the field corresponding to the field-id. If a field-id is absent, 0
+is implied. If \<var-name\> is absent, it means the corresponding return
+value is ignored by the caller. If a call has no return value, no
+dassign should be listed.
+
+In the course of compilation, these call instructions may be lowered to
+use the special registers %%retval0, retval1, %%retval2, etc. to
+indicate how their return values are fetched and used. These special
+registers are overwritten by each call. The same special register can
+assume whatever is the type of the return value. Each special register
+can be read only once after each call.
+
+Exceptions Handling
+-------------------
+
+Described in this section are the various exception handling constructs
+and operations. The try statement marks the entrance to a try block. The
+catch statement marks the entrance to a catch block. The finally
+statement marks the entrance to a finally block. The endtry statement
+marks the end of the composite exception handling constructs that began
+with the try. In addition, there are two special types of labels.
+Handler labels are placed before catch statements, and finally labels
+are placed before finally statements. Handler labels are distinguished
+from ordinary labels via the prefix \"\@h@\", while finally labels use
+the prefix \"\@f@\". These special labels explicitly shows the
+correspondence of try, catch and finally to each other in each
+try-catch-finally composite, without relying on block nesting. The
+special register %%thrownval contains the value being thrown, which is
+the operand of the throw operation that raised the current exception.
+
+Since different languages have exhibit different semantics or behavior
+related to the exception handling constructs, the try and catch opcodes
+have different variants distinguished by their language prefices.
+
+### jstry
+
+syntax: jstry \<handler-label\> \<finally-label\>
+
+Executing this statement indicates entry into a Javascript try block.
+\<handler-label\> is 0 when there is no catch block associated with the
+try. \<finally-label\> is 0 when there is no finally block associated
+with the try. Any exception thrown inside this try block will transfer
+control to these labels, unless another nested try block is entered. A
+finally block if present must be executed to conclude the execution of
+the try composite constructs regardless of whether exception is thrown
+or not.
+
+There are three possible scenarios based on the way the
+jstry-jscatch-finally composite is written:
+
+1.  jstry-jscatch
+
+2.  jstry-finally
+
+3.  jstry-jscatch-finally
+
+For case 1, if an exception is thrown inside the try block, control is
+transferred to the handler label that marks the catch statement and the
+exception is regarded as having been handled. Program flow eventually
+exits the try block with a goto statement to the label that marks the
+endtry statement. If no exception is thrown, the try block is eventually
+exited via a goto statement to the label that marks the endtry
+statement.
+
+For case 2, if an exception is thrown inside the try block, control is
+transferred to the finally label that marks the finally statement. But
+the exception is regarded as not having been handled yet, and the search
+for the throw\'s upper level handler starts. If no exception is thrown
+in try block, program flow eventually exits the try block with a gosub
+statement to the finally block. Execution in the finally block ends with
+a retsub, which returns to the try block and the try block is then
+exited via a goto statement to the label that marks the endtry
+statement.
+
+For case 3, if an exception is thrown inside the try block, control is
+transferred to the handler label that marks the catch statement as in
+case 1. Execution in the catch block ends with a gosub statement to the
+finally block. Execution in the finally block ends with a retsub, which
+returns to the catch block and the catch block is then exited via a goto
+statement to the label that marks the endtry statement. If no exception
+is thrown in the try block, program flow eventually exits the try block
+with a gosub statement to the finally block, and execution will continue
+in the finally block until it executes a retsub, at which time it
+returns to the try block and the try block is then exited via a goto
+statement to the label that marks the endtry statement.
+
+### javatry
+
+syntax: javatry {\<handler-label1\> \<handler-label2\> . . .
+\<handler-labeln\>}
+
+This is the Java flavor of try, which can have more than one catch block
+but no finally block. The entry labels for the catch blocks are listed
+in order and enclosed in braces.
+
+### cpptry
+
+syntax: cpptry {\<handler-label1\> \<handler-label2\> . . .
+\<handler-labeln\>}
+
+This is the C++ flavor of try, which can have more than one catch block
+but no finally block. The entry labels for the catch blocks are listed
+in order and enclosed in braces.
+
+### throw
+
+syntax: throw (\<opnd0\>)
+
+Raise a user-defined exception with the given exception value. If this
+statement is nested within a try block, control is then transferred to
+the label associated with the try, which is either a catch statement or
+a finally statement. If this throw statement is nested within a catch
+block, control is first transferred to the finally associated with the
+catch if any, in which case the finally block will be executed. After it
+finishes executing the finally block, the search for the throw\'s upper
+level handler starts. If this throw statement is nested within a finally
+block, the search for the throw\'s upper level handler starts right
+away. If the throw is not nested inside any try block within a function,
+the system will look for the first enclosing try block by unwinding the
+call stack. If no try block is found, the program will terminate. Inside
+the catch block, the thrown exception value can be accessed using the
+special register %%thrownval.
+
+### jscatch
+
+syntax: \<handler-label\> jscatch
+
+This marks the start of the catch block associated with a try in
+Javascript. The try block associated with this catch block is regarded
+to have been exited and the exception is regarded as being handled. If
+no exception is thrown inside the catch block, exit from the catch block
+is effected by either a gosub statement to a finally label, if there is
+a finally block, or a goto statement to endtry.
+
+### javacatch
+
+syntax: \<handler-label\> javacatch {\<type1\> \<type2\> \... \<typen\>}
+
+This marks the start of a catch block in Java. The possible types of
+thrown value that match this catch block are listed. If none of the
+specified types corresponds to the type of the thrown value, control
+will pass to the next javacatch.
+
+### cppcatch
+
+syntax: \<handler-label\> cppcatch \<type1\>
+
+This marks the start of a catch block in C++, in which each catch block
+can only be matched by one type of thrown value. If specified type does
+not correspond to the type of the thrown value, control will pass to the
+next cppcatch.
+
+### finally
+
+syntax: \<finally-label\> finally
+
+This marks the start of the finally block in Javascript. The finally
+block can be entered either via the execution of a gosub statement, or a
+throw statement the finally\'s corresponding try block that has no catch
+block, or a throw statement in the finally\'s corresponding catch block.
+The exit from the finally block can be effected by the execution of
+either a retsub or a throw statement in the finally block. If the exit
+is via a retsub and if there is outstanding throw yet to be handled, the
+search for the throw\'s upper level handler continues.
+
+### cleanuptry
+
+syntax: cleanuptry
+
+This statement is generated in situations where the control is going to
+leave the try-catch-finally composite prematurely via jumps unrelated to
+exception handling. This statement effects the cleanup work related to
+exception handling for the current try-catch-finally composite in
+Javascript.
+
+### endtry
+
+syntax: \<label\> endtry
+
+This marks either the end of each try-catch-finally composite or the end
+of each javatry block.
+
+### gosub
+
+syntax: gosub \<finally-label\>
+
+Transfer control to the finally block marked by \<finally-label\>. This
+also has the effect of exiting the try block or catch block which this
+statement belongs. It is like a goto, except that the next instruction
+is saved. Execution will transfer back to the next instruction when a
+retsub statement is executed. This can also be thought of as a call,
+except it uses label name instead of function name, and no passing of
+parameter or return value is implied. This opcode is only generated from
+Javascript.
+
+### retsub
+
+syntax: retsub
+
+This must only occur as the last instruction inside a finally block. If
+there is no outstanding throw, control is transferred back to the
+instruction following the last gosub executed. Otherwise the search for
+the upper level exception handler continues. This opcode is only
+generated from Javascript.
+
+Memory Allocation and Deallocation
+----------------------------------
+
+The following instructions are related to the allocation and
+de-allocation of dynamic memory during program execution. The
+instructions with \"gc\" as prefix are associated with languages with
+managed runtime environments.
+
+### alloca
+
+syntax: alloca \<prim-type\> (\<opnd0\>)
+
+This returns a pointer to the block of uninitialized memory allocated by
+adjusting the function stack pointer %%SP, with size in bytes given by
+\<opnd0\>. This instruction must only appear as the right hand side of
+an assignment operation.
+
+### decref
+
+syntax: decref (\<opnd0\>)
+
+\<opnd0\> must be a dread or iread of a pointer that refers to an object
+allocated in the run-time-managed part of the heap. It decrements the
+reference count of the pointed-to object by 1. \<opnd0\> must be of
+primitive type ref.
+
+### decrefreset
+
+syntax: decrefreset(\<opnd0\>)
+
+\<opnd0\> must be the address of a pointer that refers to an object
+allocated in the run-time-managed part of the heap. It decrements the
+reference count of the pointed-to object by 1, and then reset the value
+of the pointer to null by zeroing its memory location.
+
+### free
+
+syntax: free (\<opnd0\>)
+
+The block of memory pointed to by \<opnd0\> is released so it can be
+re-allocated by the system for other uses.
+
+### gcmalloc
+
+syntax: gcmalloc \<pointer prim-type\> \<type\>
+
+This requests the memory manager to allocate an object of type \<type\>
+with associated meta-data according to the requirements of the managed
+runtime. The size of the object must be fixed at compilation time. As
+this returns the pointer to the allocated block, this instruction must
+only appear as the right hand side of an assignment operation.
+
+The managed runtime is responsible for its eventual deallocation.
+
+### gcmallocjarray
+
+syntax: gcmallocjarray \<pointer prim-type\> \<java-array-type\>
+(\<opnd0\>)
+
+This requests the memory manager to allocate a java array object as
+given by \<java-array-type\>. The allocated storage must be large enough
+to store the number of array elements as given by \<opnd0\>. As this
+returns the pointer to the allocated block, this instruction must only
+appear as the right hand side of an assignment operation.
+
+The managed runtime is responsible for its eventual deallocation, and
+the block size must remain fixed during its life time.
+
+### gcpermalloc
+
+syntax: gcpermalloc \<pointer prim-type\> \<type\>
+
+This requests the memory manager to allocate an object of type \<type\>
+in the permanent area of the heap which is not subject to deallocation.
+The size of the object must be fixed at compilation time. As this
+returns the pointer to the allocated block, this instruction must only
+appear as the right hand side of an assignment operation
+
+### incref
+
+syntax: incref (\<opnd0\>)
+
+\<opnd0\> must be a dread or iread of a pointer that refers to an object
+allocated in the run-time managed part of the heap. It increments the
+reference count of the pointed-to object\'s by 1. \<opnd0\> must be of
+primitive type ref.
+
+### malloc
+
+syntax: malloc \<pointer prim-type\> (\<opnd0\>)
+
+This requests the system to allocate a block of uninitialized memory
+with size in bytes given by \<opnd0\>. As this returns the pointer to
+the allocated block, this instruction must only appear as the right hand
+side of an assignment operation. The block of memory remains unavailable
+for re-use until it is explicitly freed via the free instruction.
+
+### stackmalloc
+
+syntax: stackmalloc \<pointer prim-type\> \<type\>
+
+This allocates an object of type \<type\> on the function stack frame by
+decrementing %%SP. The size of the object must be fixed at compilation
+time. As this returns the pointer to the allocated block, this
+instruction must only appear as the right hand side of an assignment
+operation.
+
+### stackmallocjarray
+
+syntax: stackmallocjarray \<pointer prim-type\> \<java-array-type\>
+(\<opnd0\>)
+
+This allocates a java array object as given by \<java-array-type\> on
+the function stack frame by decrementing %%SP. The allocated storage
+must be large enough to store the number of array elements as given by
+\<opnd0\>. As this returns the pointer to the allocated block, this
+instruction must only appear as the right hand side of an assignment
+operation.
+
+Other Statements
+----------------
+
+### assertge
+
+syntax: assertge (\<opnd0\>, \<opnd1\>)
+
+Raise an exception if \<opnd0\> is not greater than or equal to
+\<opnd1\>. This is used for checking if an array index is within range
+during execution. \<opnd0\> and \<opnd1\> must be of the same type.
+
+### assertlt
+
+syntax: assertlt (\<opnd0\>, \<opnd1\>)
+
+Raise an exception if \<opnd0\> is not less than \<opnd1\>. This is used
+for checking if an array index is within range during execution.
+\<opnd0\> and \<opnd1\> must be of the same type.
+
+### assertnonnull
+
+syntax: assertnonnull (\<opnd0\>)
+
+Raise an exception if \<opnd0\> is a null pointer, corresponding to the
+value 0.
+
+### eval
+
+syntax: eval (\<opnd0\>)
+
+\<opnd0\> is evaluated but the result is thrown away. If \<opnd0\>
+contains volatile references, this statement cannot be optimized away.
+
+### checkpoint
+
+syntax: checkpoint \<action\>
+
+This instruction serves as a check point, such that when execution
+reaches this instruction, it will trigger the indicated action.
+
+### membaracquire
+
+syntax: membaracquire
+
+This instruction acts as both a Load-to-Load barrier and a Load-to-Store
+barrier: the order between any load instruction before it and any load
+instruction after it must be strictly followed, and the order between
+any load instruction before it and any store instruction after it must
+be strictly followed.
+
+### membarrelease
+
+syntax: membarrelease
+
+This instruction acts as both a Load-to-Store barrier and a
+Store-to-Store barrier: the order between any load instruction before it
+and any store instruction after it must be strictly followed, and the
+order between any store instruction before it and any store instruction
+after it must be strictly followed.
+
+### membarfull
+
+syntax: membarfull
+
+This instruction acts as a barrier to any load or store instruction
+before it and any load or store instruction after it.
+
+### syncenter
+
+syntax: syncenter (\<opnd0\>)
+
+This instruction indicates entry to a region where the object pointed to
+by the pointer \<opnd0\> needs to be synchronized for Java
+multi-threading. This means at any time, there cannot be more than one
+thread executing in a synchronized region of the same object. Any other
+thread attempting to enter a synchronized region of the same object will
+be blocked. For the compiler, it implies a barrier to the backward
+movement (against the flow of control) of any operation that accesses
+the object.
+
+### syncexit
+
+syntax: syncexit (\<opnd0\>)
+
+This instruction indicates exit from a region where the object pointed
+to by the pointer \<opnd0\> needs to be synchronized for Java
+multi-threading. For the compiler, it implies a barrier to the forward
+movement (along the flow of control) of any operation that accesses the
+object.
+
+Declaration Specification
+=========================
+
+In this section, we describes the various kinds of statements in the
+declaration part of Maple IR. Internally, they are represented by data
+structures organized into different kinds of tables.
+
+Type declarations can be huge and they are often shared by different
+modules, MAPLE IR provides the *import* facility to avoid duplicating
+type declarations in each MAPLE IR file. MAPLE IR files that store only
+type information have .mplt as file suffix. They can then be imported
+into each MAPLE IR files that need them via the **import** statement.
+
+Module Declaration
+------------------
+
+Each Maple IR file represents a program module, also called compilation
+unit, that consists of various declarations at the global scope. The
+following directives appear at the start of the Maple IR file and
+provide information about the module:
+
+### entryfunc
+
+syntax: entryfunc \<func-name\>
+
+This gives the name of the function defined in the module that will
+serve as the single entry point for the module.
+
+### flavor
+
+syntax: flavor \<IR-flavor\>
+
+The IR flavor gives information as to how the IR was produced, which in
+turn indicates the state of the compilation process.
+
+### globalmemmap
+
+syntax: globalmemmap = \[ \<initialization-values\> \]
+
+This specifies the static initialization values of the global memory
+block as a list of space-separated 32-bit integer constants. The amount
+of initializations should correspond to the memory size given by
+globalmemsize.
+
+### globalmemsize
+
+syntax: globalmemsize \<size-in-bytes\>
+
+This gives the size of the global memory block for storing all global
+static variables.
+
+### globalwordstypetagged
+
+syntax: globalwordstypetagged = \[ \<word-values\> \]
+
+This specifies a bitvector initialized to the value specified by the
+list of space-separated 32-bit integer constants. The Nth bit in this
+bitvector is set to 1 if the Nth word in globalmemmap has a type tag, in
+which case the type tag is at the (N+1)th word.
+
+### globalwordsrefcounted
+
+syntax: globalwordsrefcounted = \[ \<word-values\> \]
+
+This specifies a bitvector initialized to the value specified by the
+list of space-separated 32-bit integer constants. The Nth bit in this
+bitvector is set to 1 if the Nth word in globalmemmap is a pointer to a
+reference-counted dynamically allocated memory block.
+
+### id
+
+syntax: id \<id-number\>
+
+This gives the unique module id assigned to the module. This id enables
+the Maple virtual machine to handle the execution of program code
+originating from multiple Maple IR modules.
+
+### import
+
+syntax: import \"\<filename\>\"
+
+\<filename\> is the path name for a MAPLE IR file with suffix .mplt that
+only stores type declarations. The contents of this file are imported.
+This allows the same type declarations to be shared across multiple
+files, and large volumes of type declarations to be organized by files.
+Only one level of import is allowed, as .mplt files are not allowed to
+have import statements.
+
+### importpath
+
+syntax: importpath \"\<path-name\>\"
+
+This specifies a directory path for the compiler to look for the
+imported MAPLE IR files required to complete the compilation. This is
+used only in the early compilation phases, before all types and symbol
+names have been fully resolved. Each appearance only specifies one
+specific path.
+
+### numfuncs
+
+syntax: numfuncs \<integer\>
+
+This gives the number of function definitions in the module, excluding
+function prototypes.
+
+### srclang
+
+syntax: srclang \<language\>
+
+This gives the source language that produces the Maple IR module.
+
+Variable Declaration
+--------------------
+
+syntax: var \<id-name\> \<storage-class\> \<type\> \<type-attributes\>
+
+The keyword \'var\' designates a declaration statement for a variable.
+\<id-name\> specifies its name, prefixed by \'\$\' or \'%\' based on
+whether its scope is global or local respectively. \<storage-class\> is
+optional and can be extern, fstatic or pstatic. \<type\> is the type
+specification. \<type-attributes\> is optional and specifies additional
+attributes like volatile, const, alignment, etc. Examples:
+
+var \$x extern f32 volatile static
+
+syntax: tempvar \<id-name\> \<storage-class\> \<type\>
+\<type-attributes\>
+
+This is the same as **var** except that it conveys the additional
+information that it is a compiler-generated temporary.
+
+Pseudo-register Declarations
+----------------------------
+
+syntax: reg \<preg-name\> \<type\>
+
+The keyword \'reg\' designates a declaration statement for a
+pseudo-register. \<preg-name\> specifies the pseudo-register prefixed by
+\'%\'. \<type\> is the high level type information. If a pseudo-register
+is only of primitive type, its declaration is optional. This statement
+is only allowed inside functions as pseudo-registers are of local scope.
+
+Type Specification
+------------------
+
+Types are either primitive or derived. Derived types are specified using
+C-like tokens, except that the specification is always
+right-associative, following a strictly left to right order. Derived
+types are distinguished from primitive types by being enclosed in
+angular brackets. Derived types can also be thought of as high-level
+types. Examples:
+```
+    var %p <* i32>      # pointer to a 32-bit integer
+
+    var %a <[10] i32>   # an array of 10 32-bit integers
+```
+var %foo \<func(i32) i32\> \# a pointer to a function that takes one i32
+parameter and returns an i32 value (func is a keyword)
+
+Additional nested angular brackets are not required, as there is no
+ambiguity due to the right-associative rule. But the nested angular
+brackets can be optionally inserted to aid readability. Thus, the
+following two examples are equivalent:
+```
+    var %q <* <[10] i32>> # pointer to an array of 10 32-bit integers
+
+    var %q <* [10] i32>   # pointer to an array of 10 32-bit integers
+```
+Inside a struct declaration, field names are prefixed by @. Though label
+names also use @ as prefix, there is no ambiguity due to the usage
+context between struct field declaration and label usage being distinct.
+Example:
+```
+    var %s <struct{@f1 i32,
+                   @f2 f64,
+                   @f3:3 i32}> # a bitfield of 3 bits
+```
+A union declaration has the same syntax as struct. In a union, all the
+fields overlap with each other.
+
+The last field of a struct can be a flexible array member along the line
+of the C99 standard, which is an array with variable number of elements.
+It is specified with empty square brackets, as in:
+```
+    var %p <* struct{@f1 i32,
+                     @f2 <[] u16>}> # a flexible array member with unsigned 16-bit integers as elements
+```
+Structs with flexible array member as its last field can only be
+dynamically allocated. Its actual size is fixed only at its allocation
+during execution time, and cannot change during its life time. A struct
+with flexible array member cannot be nested inside another aggregate.
+During compilation, the flexible array member is regarded as having size
+zero.
+
+Because its use is usually associated with managed runtime, a language
+processor may introduce additional meta-data associated with the array.
+In particular, there must be some language-dependent scheme to keep
+track of the size of the array during execution time.
+
+When a type needs to be qualified by additional attributes for const,
+volatile, restrict and various alignments, they follow the type that
+they qualify. These attributes are not regarded as part of the type. If
+these attributes are applied to a derived type, they must follow outside
+the type angular brackets. Examples:
+```
+    var %x f64 volatile align(16) # %s is a f64 value that is volatile and
+                                  # aligned on 16 byte boundary
+    var %p <* f32> const volatile # %p is a pointer to a f32 value, and
+                                  # %p itself is const and volatile
+```
+Alignments are specified in units of bytes and must be power of 2.
+Alignment attributes must only be used to increase the natural
+alignments of the types, to make the alignments more stringent. For
+decreasing alignments, the generator of MAPLE IR must use smaller types
+to achieve the effect of packing instead of relying on the align
+attribute.
+
+### Incomplete Type Specification
+
+Languages like Java allow contents of any object to be referenced
+without full definition of the object being available. Their full
+contents are to be resolved from additional input files in later
+compilation phases. MAPLE IR allows structs, classes and interfaces to
+be declared incompletely so their specific contents can be referenced.
+Instead of the struct, class and interface keywords, structincomplete,
+classincomplete and interfaceincomplete should be used instead.
+
+Type Declaration
+----------------
+
+The purpose of type declaration is to associate type names with types so
+they can be referred to via their names, thus avoiding repeated
+specification of the details of the types.
+
+syntax: type \<id-name\> \<derived-type\>
+
+Type names are also prefixed with either \'\$\' or \'%\' based on
+whether the scope is global or local. Example:
+```
+    type $i32ptr <* i32>        # the type $i32ptr is a pointer to i32
+```
+Primitive types are not allowed to be given a different type name.
+
+Attributes are not allowed in type declaration.
+
+Once a type name is defined, specifying the type name is equivalent to
+specifying the derived type that it stands for. Thus, the use of a type
+name should always be enclosed in angular brackets.
+
+Java Class and Interface Declaration
+------------------------------------
+
+A Java class designates more than a type, because the class name also
+carries the attributes declared for the class. Thus, we support
+declaration of Java classes via:
+
+syntax: javaclass \<id-name\> \<class-type\> \<attributes\>
+
+\<id-name\> must have \'\$\' as prefix as class names always have global
+scope. For example:
+```
+    # a java class named "Puppy" with a single field "color" and attributes public and final
+    javaclass $Puppy <class {@color i32}> public final
+```
+A **javaclass** name should not be regarded as a type name as it
+contains additional attribute information. It cannot be enclosed in
+angular brackets as it cannot be referred to as a type.
+
+A java interface has the same form as the class type, being able to
+extend another interface, but unlike class, an interface can extend
+multiple interfaces. Another difference from class is that an interface
+cannot be instantiated. Without instantiation, the data fields in
+interfaces are always allocated statically. For example,
+```
+    interface <$interfaceA> { # this interface extends interfaceA
+        @s1 int32,            # data fields inside interfaces always statically allocated
+        &method1(int32) f32 } # a method declaration
+```
+MAPLE IR handles an interface declaration as a type declaration. Thus,
+the above can be specified after the type keyword to be associated with
+a type name. Separately, the **javainterface** keyword declares the
+symbol associated with the interface:
+
+syntax: javainterface \<id-name\> \<interface-type\> \<attributes\>
+
+\<id-name\> must have \'\$\' as prefix as interface names always have
+global scope. For example:
+```
+    # $IFA is an interface with a single method &amethod
+    javainterface $IFA <interface {&amethod(void) int32}> public static
+```
+Again, a **javainterface** name should not be regarded as a type name,
+as it is a symbol name. When a class implements an interface, it
+specifies the **javainterface** name as part of its comma-separated
+contents, as in:
+```
+    class <$PP> { &amethod(void) int32, # this class extends the $PP class, and
+                                # &amethod is a member function of this class
+                  $IFA }        # this class implements the $IFA interface
+```
+Function Declaration
+--------------------
+
+syntax:
+```
+    func <func-name> <attributes> (
+      var <parm0> <type>,
+      ...
+      var <parmn> <type>) <ret-type0>, . . . <ret_typen> {
+      <stmt0>
+      ...
+      <stmtn> }
+
+```
+\<attributes\> provides various attributes about the function, like
+static, extern, etc. The opening parentheses starts the parameter
+declarations, which can be empty. Each \<parm~i~\> is of the form of a
+**var** or **reg** declaration declaring each incoming parameter. If the
+last parameter is specified as \"\...\", it indicates the start of the
+variable part of the arguments as in C. Following the parameter
+declarations is a list of the multiple return types separated by commas.
+If there is no return value, \<ret-type0\> should specify void. Each
+\<ret-type~i~\> can be either primitive or derived. If no statement
+follows the parentheses, then it is just a prototype declaration.
+
+### funcsize
+
+syntax: funcsize \<size-in-bytes\>
+
+This directive appears inside the function block to give the Maple IR
+code size of the function.
+
+### framesize
+
+syntax: framesize \<size-in-bytes\>
+
+This directive appears inside the function block to give the stack frame
+size of the function.
+
+### moduleid
+
+syntax: moduleid \<id\>
+
+This directive appears inside the function to give the unique id of the
+module which the function belongs to.
+
+### upformalsize
+
+syntax: upformalsize \<size-in-bytes\>
+
+This directive appears inside the function block to give the size of
+upformal segment that stores the formal parameters being passed above
+the frame pointer %%FP.
+
+### formalwordstypetagged
+
+syntax: formalwordstypetagged = \[ \<word-values\> \]
+
+This specifies a bitvector initialized to the value specified by the
+list of space-separated 32-bit integer constants. The Nth bit in this
+bitvector is set to 1 if the Nth word in the upformal segment has a type
+tag, in which case the type tag is at the (N+1)th word.
+
+### formalwordsrefcounted
+
+syntax: formalwordsrefcounted = \[ \<word-values\> \]
+
+This specifies a bitvector initialized to the value specified by the
+list of space-separated 32-bit integer constants. The Nth bit in this
+bitvector is set to 1 if the Nth word in the upformal segment is a
+pointer to a reference-counted dynamically allocated memory block.
+
+### localwordstypetagged
+
+syntax: localwordstypetagged = \[ \<word-values\> \]
+
+This specifies a bitvector initialized to the value specified by the
+list of space-separated 32-bit integer constants. The Nth bit in this
+bitvector is set to 1 if the -Nth word in the local stack frame has a
+type tag, in which case the type tag is at the (-N+1)th word.
+
+### localwordsrefcounted
+
+syntax: localwordsrefcounted = \[ \<word-values\> \]
+
+This specifies a bitvector initialized to the value specified by the
+list of space-separated 32-bit integer constants. The Nth bit in this
+bitvector is set to 1 if the -Nth word in the local stack frame is a
+pointer to a reference-counted dynamically allocated memory block.
+
+Initializations
+---------------
+
+When there are initializations associated with a **var** declaration,
+there is \'=\' after the **var** declaration, followed by the
+initialization value. For aggregates, the list of initialization values
+are enclosed by brackets \'\[\' and \'\]\', with the values separated by
+commas. In arrays, the initialization values for the array elements are
+listed one by one, and nested brackets must be used to correspond to
+elements in each lower-order dimension.
+
+In specifying the initializations for a struct, inside the brackets,
+field number followed by \'=\' must be used to specify the value for each
+field explicitly. The fields\' initialization values can be listed in
+arbitrary order. For nested structs, nested brackets must be used according
+to the nesting relationship. Because a bracket is used for each sub-struct in
+the nesting, the field number usage is relative to the sub-struct, and starts
+at 1 for the first field of the sub-struct.  Example:
+```
+    type %SS <struct { @g1 f64, @g2 f64 }>
+    var %s struct{@f1 i32,
+                  @f2 <%SS>,
+                  @f3:4 i32} = [
+        1 = 99,        # field f1 is initialized to 99
+        2 = [1= 10.0f, 2=22.2f],
+                       # fields f2.g1 and f2.g2 initialized to
+                       # 10.0f and 22.2f respectively
+        3 = 15 ]       # field f3 (4 bits in size) has field number 3 in
+                       # struct %s and is initialized to 15
+```
+ Type Parameters
+---------------
+
+Also called generics or templates, type parameters allow derived types
+and functions to be written without specifying the exact types in parts
+of their contents. The type parameters can be instantiated to different
+specific types later, thus enabling the code to be more widely
+applicable, promoting software re-use.
+
+Type parameters and their instantiation can be handled completely by the
+language front-ends. MAPLE IR provides representation for generic types
+and generic functions and their instantiation so as to reduce the amount
+of work in the language front-ends. A MAPLE IR file with type parameters
+requires a front-end lowering phase to de-genericize the IR before the
+rest of the MAPLE IR components can process the code.
+
+Type parameters are symbol names prefixed with \"!\", and can appear
+anywhere that a type can appear. Each type or function definition can
+have multiple type parameters, and each type parameter can appear more
+than one time. Since type parameters are also types, they can only
+appear inside the angular brackets \"\<\" and \"\>\", e.g. \<!T\>. When
+the definition of a derived type contains any type parameter, the type
+becomes a generic type. When the definition of a function contains any
+type parameter, the function becomes a generic function. A function
+prototype cannot contain generic type.
+
+A generic type or generic function is marked with the generic attribute
+to make them easier to be identified. A generic type or function is
+instantiated by assigning specific non-generic types to each of its type
+parameters. The instantiation is specified by a list of such assignments
+separated by commas. We refer to this as an instantiation vector, which
+is specified inside braces \"{\" and \"}\". In the case of the
+instantiation of a generic type, the type parameter is immediately
+followed by the instantiation vector. Example:
+```
+    type $apair <struct {@f1 <!T>, @f2 <!T>}> # $apair is a generic type
+
+    var $x <$apair{!T=f32}>     # the type of $x is $apair instantiated with
+                                # f32 being assigned to the type parameter !T
+```
+A generic function is instantiated by invoking it with an instantiation
+vector. The instantiation vector immediately follows the name of the
+generic function. Since the instantiation vector is regarded as type
+information, it is further enclosed inside the angular brackets \"\<\"
+and \"\>\". Invocation of generic functions must be via the opcodes
+callinstant and callinstantassigned, which correspond to call and
+callassigned respectively. Example:
+```
+    # &swap is a generic function to swap two parameters
+    func &swap (var %x \<!UU\>, var %y \<!UU\>) void {
+      var %z \<!UU\>
+      dassign %z (dread agg %x)
+      dassiign %x (dread agg %y)
+      dassign %y (dread agg %z)
+      return
+    }
+
+    ...
+
+      # &swap is instantiated with type argument <$apair{!T=i32}>,
+      # itself an instantiated type
+      callinstant &swap<{!UU=<$apair{!T=i32}>}> (
+      dread agg %a,
+      dread agg %b)
+```
diff --git a/doc/en/NaiveRcInsertionDescription.md b/doc/en/NaiveRcInsertionDescription.md
new file mode 100644
index 0000000000000000000000000000000000000000..f3d19b343de320220a26244510027991f6ee377e
--- /dev/null
+++ b/doc/en/NaiveRcInsertionDescription.md
@@ -0,0 +1,175 @@
+# Naive RC Insertion Principle
+
+Reference Counting (RC) is a programming technique of storing the number of references to a resource, such as an object, a block of memory, disk space, and others, and releasing the resource when the number of references becomes 0. RC is used to achieve automatic resource management. RC also refers to a garbage collection algorithm that deallocates objects which are no longer referenced. Naive RC is a simplified RC.
+
+
+Principle
+======================
+
+- RC sources:
+
+   - Heap reference (other objects or itself)   
+
+   - Stack-based reference (including registers)
+
+   - Static variable and global variable
+
+- RC Insertion rules (compiler and runtime):   
+
+   - If a value is assigned to a field, RC for the new object to which the field points is incremented and RC for the original object is decremented.
+
+   - To read a local variable (including registers) on the stack, RC for the object to be read is incremented.
+
+   - After last use, RC for the local variable is decremented.
+
+   - If an object is returned, RC is incremented. After last use, RC for the compensated local variable is decremented.
+
+- Example
+
+    - Before insertion
+
+     ```cpp
+    class A {
+      static Object static_field;
+      Object instance_field;
+      A() {
+        static_field = new Object();
+      }
+    }
+    Object foo(){
+      A a = new A();
+      bar(a, new Object())
+      return a.instance_field;
+    }
+    void bar(A a, Object o) {
+      a.instance_field = o;
+    }
+    ```	
+   
+    - After insertion
+
+    ```cpp 
+    class A {
+      A() {
+       local_var t = new Object(); // t is a temporary variable assigned to the static_field process.
+       old = static_field;
+       static_field = t;
+       IncRef(t); DecRef(old); // RC is updated on the heap.
+       The DecRef(t); // The function exits and RC on the stack is released.
+      }
+    }
+    Object foo(){
+      A a = new A();
+      bar(a, new Object());
+      locl_var t = a.instance_field;
+      IncRef(t) // RC for the variable on the stack is incremented.
+      The IncRef(t) // The function returns and RC for the returned value is incremented.
+      The DecRef(a) // The function exits and RC on the stack is released.
+      The DecRef(t) // The function exits and RC on the stack is released. 
+      return t;
+    }
+    void bar(A a, Object o) {
+      old = a.instance_field
+      a.instance_field = o;
+      IncRef(o); DecRef(old);
+    }
+     ```
+
+
+- RC intrinsics:
+
+   - Basic function
+    Method: The basic function uses CreateIntrinsicCallMeStmt in IrMap to create the IntrinsiccallMeStmt statement and insert it to the position where RC needs increment or decrement.
+
+      - INTRN_MCCIncRef
+
+      - INTRN_MCCDecRef
+
+   - Load/Write function
+    Method: The Write function uses CreateIntrinsicCallMeStmt in IrMap to create the IntrinsiccallMeStmt statement and replace the iassign statement whose lvalue is static, global, or volatile. The Load function uses CreateIntrinsicCallAssignedMeStmt to create the IntrinsiccallMeStmt statement and replace the dassign statement whose rvalue is static, global, or volatile. The Load/Write function supports the IncRef operation.
+
+      -   INTRN_MCCLoadRef
+
+      -   INTRN_MCCLoadRefS
+
+      -   INTRN_MCCLoadRefVol
+
+      -   INTRN_MCCLoadRefSVol
+
+      -   INTRN_MCCWrite
+
+      -   INTRN_MCCWriteS
+
+      -   INTRN_MCCWriteVol
+
+      -   INTRN_MCCWriteSVol
+
+RefVar IncRef Processing Rules:
+========================
+
+-  Assignment statement processing:
+
+   - Process the statement based on the lvalue (variable value in the assignment statement) and rvalue (referenced value in the assignment statement) expressions.
+
+   - First, process the rvalue. For example, select a load interface, or the rvalue (New, Call) that does not need RC increment.
+
+      - Set Global to INTRN_MCCLoadRef.
+
+      - Set Static to INTRN_MCCLoadRefS.
+
+      - Set Volatile to INTRN_MCCLoadRefVol.
+
+   - Then process the lvalue. For example, select a write interface, or save the old value or not.
+
+      - Set Global to INTRN_MCCWriteRef.
+
+      - Set Static to INTRN_MCCWriteRefS.
+
+      - Set Volatile to INTRN_MCCWriteRefVol.
+
+- Return value processing:
+
+    - Increment RC for the return value.
+
+- Local variable processing:
+
+   - Decrement RC before the current function exits (normal or abnormal) 
+
+Rclowering Processing Procedure:
+====================
+
+- Set the rclowering processing flag.
+- Mark localrefvar.
+
+-  Rclowering pre-processing
+
+   - Mark variables that need RC.
+
+      - Mark the lvalue as DecRef, that is, variable value in the assignment statement.
+
+         - Ref variable
+
+   - Mark the rvalue as IncRef, that is, referenced or return value in the assignment statement.
+
+      - Return value
+
+      - Ref variable
+
+     - hrow Value register
+
+   - Clear stack variables.
+
+- Rclowering processing
+
+   - Process the assignment statement that contains the Ref variable.
+
+      - DecRef original value
+
+      - IncRef new value. For details, see RefVar IncRef processing rules.
+
+- Rclowering post-processing
+
+   - Perform the IncRef operation on the parameter at the function entry and mark the parameter as LocalRefVar.
+
+   - Process the return value of the function. If the attribute is LocalRefVar, then the InRef operation is performed. If not, see RefVar IncRef processing rules.
+
diff --git a/doc/en/ProgrammingSpecifications.md b/doc/en/ProgrammingSpecifications.md
new file mode 100644
index 0000000000000000000000000000000000000000..be602470dc602a958c8fab045b8d849be108e80e
--- /dev/null
+++ b/doc/en/ProgrammingSpecifications.md
@@ -0,0 +1,3077 @@
+<!-- <center><br><br><br><br><br><br><br> -->
+<big><big><big><big><big><strong> Ark Compiler C++ Coding Style Guide </strong><big><big><big><big><big>
+
+<!-- <center><br><br><br><br><br><br><br> -->
+
+
+
+
+
+
+<!-- <br></center> -->
+
+
+| Chapter                 | Content                                       |
+| ------------------ | ---------------------------------------- |
+| <u>[0 About This Document](#c0)</u>        | <u>[Purpose](#c0-1)</u> <u>[Key Points](#c0-2)</u> <u>[Conventions](#c0-3)</u> <u>[Exceptions](#c0-4)</u> |
+| <u>[1 Principles](#c1)</u>        | <u>[Principles of Good Code](#c1-1)</u> <u>[Class and Function Design Guidelines](#c1-2)</u> <u>[Follow C++ ISO Standards](#c1-4)</u> <br><u>[Check Errors During Compilation](#c1-5)</u> <u>[Use Namespaces for Scoping](#c1-6)</u> <u>[Use C++ Features over C Features](#c1-7)</u> |
+| <u>[2 Naming](#c2)</u>        | <u>[General Naming Rules](#c2-1)</u> <u>[File Names](#c2-2)</u> <u>[Function Names](#c2-3)</u> <u>[Type Names](#c2-4)</u> <u>[Variable Names](#c2-5)</u> <u>[Macro, Constant, and Enumeration Names](#c2-6)</u> |
+| <u>[3 Formatting](#c3)</u> | <u>[Line Length](#c3-1)</u> <u>[Indentation](#c3-2)</u> <u>[Braces](#c3-3)</u> <u>[Function Declarations and Definitions](#c3-4)</u> <u>[Function Calls](#c3-5)</u> <u>[if Statements](#c3-6)</u> <u>[Loop Statements](#c3-7)</u> <u>[Switch Statements](#c3-8)</u> <u>[Expressions](#c3-9)</u> <u>[Variable Assignment](#c3-10)</u> <br><u>[Initialization](#c3-11)</u> <u>[Pointers and References](#c3-12)</u> <u>[Preprocessor Directives](#c3-13)</u> <u>[Whitespace](#c3-14)</u> <u>[Classes](#c3-15)</u> |
+| <u>[4 Comments](#c4)</u>        | <u>[Comment Style](#c4-1)</u> <u>[File Header Comments](#c4-2)</u> <u>[Function Header Comments](#c4-3)</u> <u>[Code Comments](#c4-4)</u> |
+| <u>[5 Header Files](#c5)</u>       | <u>[Header File Responsibility](#c5-1)</u> <u>[Header File Dependency](#c5-2)</u>            |
+| <u>[6 Scopes](#c6)</u>       | <u>[Namespaces](#c6-1)</u> <u>[Global Functions and Static Member Functions](#c6-2)</u> <u>[Global Variables](#c6-3)</u> <u>[Global Constants and Static Member Constants](#c6-4)</u> |
+| <u>[7 Classes](#c7)</u>         | <u>[Constructors, Copy/Move Constructors, Copy/Move Assignment Operators, and Destructors](#c7-1)</u> <u>[Inheritance](#c7-2)</u> <u>[Multiple Inheritance](#c7-3)</u> <u>[Overloading](#c7-4)</u> |
+| <u>[8 Functions](#c8)</u>        | <u>[Function Design](#c8-1)</u> <u>[Inline Functions](#c8-2)</u> <u>[Function Parameters](#c8-3)</u> |
+| <u>[9 Other C++ Features](#c9)</u>   | <u>[Constants and Initialization](#c9-1)</u> <u>[Expressions](#c9-2)</u> <u>[Type Casting](#c9-3)</u> <u>[Resource Allocation and Release](#c9-4)</u> <u>[Standard Template Library](#c9-5)</u> <u>[Usage of const](#c9-6)</u> <u>[Templates](#c9-7)</u> <u>[Macros](#c9-8)</u> <u>[Others](#c9-9)</u>|
+| <u>[10 Modern C++ Features](#c10)</u> | <u>[Code Simplicity and Security Improvement](#c10-1)</u> <u>[Smart Pointers](#c10-2)</u> <u>[Lambda](#c10-3)</u> <u>[Interfaces](#c10-4)</u> |
+| <u>[11 Security Coding Specifications](#c11)</u> | <u>[Basic Principles](#c11-1)</u> <u>[Variables](#c11-2)</u> <u>[Assertions](#c11-3)</u> <u>[Exception Mechanisms](#c11-4)</u> <u>[Memory](#c11-5)</u> <u>[Dangerous Functions](#c11-6)</u> |
+
+# <a name="c0"></a>0 About This Document
+
+## <a name="c0-1"></a>Purpose
+
+Rules are not perfect. Disabling useful features in specific situations may affect implementation. However, the rules are formulated "to benefit most programmers". If a rule is found unhelpful or difficult to follow during team coding, please send feedback so we can improve it accordingly.
+
+Before referring to this guide, you are expected to have the following basic capabilities for C++. It is not for a beginner that wants to learn about C++.
+1. Have a general knowledge of ISO standards for C++.
+2. Be familiar with the basic features of C++, including those of C++ 03/11/14/17.
+3. Have a general knowledge of the C++ Standard Library.
+
+
+## <a name="c0-2"></a>Key Points
+1. C++ programming style, such as naming and typesetting.
+2. C++ modular design, including how to design header files, classes, interfaces, and functions.
+3. Best practices of C++ features, including constants, type casting, resource management, and templates.
+4. Best practices of modern C++, including conventions that can improve code maintainability and reliability in C++ 11/14/17.
+
+
+## <a name="c0-3"></a>Conventions
+**Rule**: a regulating principle that must be followed during programming.
+
+**Recommendation**: a guideline that must be considered during programming.
+
+This document is applicable to standard C++ versions (03/11/14/17) unless otherwise specified in the rule.
+
+## <a name="c0-4"></a>Exceptions
+It is necessary to understand the reason for each 'rule' or 'recommendation' and to try and comply with them.
+However, some rules and recommendations have exceptions.
+
+The only acceptable exceptions are those that do not violate the general principles and provide appropriate reasons for the exception.
+Try to avoid exceptions because they affect the code consistency. Exceptions to 'Rules' should be very rare.
+
+The style consistency principle is preferred in the following cases:  
+**When you modify external open source or third-party code, the existing code specifications prevail.**  
+**For specific domains, the domain specifications prevail.**
+
+# <a name="c1"></a>1 Principles
+
+## <a name="c1-1"></a>Principles of Good Code
+We refer to Kent Beck's four rules of simple design to guide our coding and to identify good code.
+1. Passes its tests
+2. Minimizes duplication
+3. Maximizes clarity
+4. Has fewer elements
+5. The importance of the preceding four rules decreases in sequence.
+    They are referred to as rules of simple design.
+
+The first point is the most important as it stresses external requirements. The second point refers to the modular design of code to ensure orthogonality and maintainability. The third point refers to code readability. The fourth point is code simplicity. Of course, we still emphasize expressiveness over simplicity.
+
+## <a name="c1-2"></a>Class and Function Design Guidelines
+C++ is a typical object-oriented programming (OOP) language. The software engineering industry has developed many OOP principles to guide programmers in compiling large-scale, highly scalable, and maintainable code:
+- Basic rule of high cohesion and low coupling: improves the reuse and portability of program modules.
+- SOLID principles: consists of single responsibility, open–closed, Liskov substitution, interface segregation, and dependency inversion. The SOLID principles can make the program less coupled and more robust.
+- Law of Demeter: reduces coupling between classes.
+- "Tell, Don't ask": suggests that it is better to issue an object a command to perform some operation or logic, rather than to query its state and then take some action as a result.
+- Composition/Aggregation Principle (CARP): favors composition/aggregation over class inheritance.
+
+## <a name="c1-3"></a>Follow C++ ISO Standards
+It is hoped that C++ code is written using features compliant with ISO standards. Features that are not defined by ISO or those used in compilers must be used with caution. Extended features provided by compilers such as GCC must be used with caution too, because these features lead to poor portability.
+
+Note: If extended features are required by the product, encapsulate these features into independent interfaces and enable or disable these features through options on the interface. Develop programming manuals to instruct programmers on the use of these extended features.
+
+## <a name="c1-4"></a>Check Errors During Compilation
+Use compilers to ensure code robustness instead of compiling error processing codes to handle exceptions.
+
+- Use const to ensure data consistency and prevent data from being modified unexpectedly.
+- Run the static_assert command to check errors at compilation time.
+
+## <a name="c1-5"></a>Use Namespaces for Scoping
+Global variables, global constants, and global type definitions belong to the global scope. Conflicts may occur when a third-party library is used in a project.
+
+Namespaces divide a scope into independent, name-specified scopes that can effectively prevent name conflicts within the global scope.
+1. Classes and structs have their own scopes.
+2. A named namespace can implement an upper-level scope, higher than a class scope.
+3. Unnamed namespaces and the static keyword can be used to implement a file scope.
+
+We strongly recommend programmers not use global macro variables and functions, and instead place them inside a more restrictive scope.
+
+Scopes have the following disadvantages:
+1. Although two types of the same name can be distinguished in different scopes, they are still confusing to readers.
+2. An inline namespace allows its members to be treated as if they are members of the enclosing namespace, which is also confusing to readers.
+3. A nested namespace definition can make names lengthy when the namespace needs to be referenced.
+
+Therefore, we recommended:
+- For variables, constants, and type definitions, use namespaces as much as possible to reduce conflicts within the global scope.
+- Do not use "using namespace" in header files.
+- Do not use inline namespaces.
+- Encapsulate definitions using unnamed namespaces or the static keyword in .cpp files to prevent leaking through APIs.
+
+
+## <a name="c1-6"></a>Use C++ Features over C Features
+C++ is more type safe and more abstract than C. It is recommended that you use C++ features for programming. For example, use strings instead of `char*`, use vectors instead of native arrays, and use namespaces instead of statically defined members.
+
+
+# <a name="c2"></a>2 Naming
+## <a name="c2-1"></a>General Naming Rules
+General naming styles include the following:
+__CamelCase__
+CamelCase is the practice of writing compound words or phrases so that each word or abbreviation in the phrase begins with a capital letter, with no intervening spaces or punctuation.
+There are two conventions: UpperCamelCase and lowerCamelCase.
+
+__Kernel Style (Unix-like)__
+Words are in lowercase and are separated with underscores (_).
+'test_result'
+
+__Hungarian Style__
+Add a prefix to UpperCamelCase. The prefix indicates the type or usage.
+'uiSavedCount ', or ' bTested'
+
+### <a name="r2-1-1"></a>Rule 2.1.1 Use the CamelCase style for identifier names.
+The Hungarian style is not considered for identifier names, and we choose the CamelCase style over the Kernel style.
+
+| Type                                                         | Naming Style                                 |
+| ------------------------------------------------------------ | ---------------------------------------- |
+| Class Type, Struct Type, Enumeration Type, and Union Type Definitions           | UpperCamelCase                                   |
+| Functions (Including Global Functions, Scope Functions, and Member Functions)                     | UpperCamelCase (You can add a prefix to an interface. XXX_FunctionName) |
+| Global Variables (Including Variables of the Global and Namespace Scopes, Namespace Variables, and Class Static Variables), Local Variables, Function Parameters, and Class, Struct, and Union Member Variables | lowerCamelCase                                   |
+| Constant, Enumerated Value                                          | k+CamelCase                             |
+| Macro                                                           | All caps, separated with underscores (_)                              |
+| Namespace                                                     | All in lowercase                                   |
+
+Note:
+__Constant__ indicates the variables of the basic, enumeration, or character string type modified by const or constexpr in the global scope, the namespace scope, and the scope of a static member of a class.
+__Variable__ indicates the variables excluding those defined in Constant. These variables use the lowerCamelCase style.
+
+## <a name="c2-2"></a>File Names
+### <a name="a2-2-1"></a>Recommendation 2.2.1 Use .cpp as the C++ file name extension and .h as the header file name extension. Use Kernel style for file names.
+
+At present, there are some other file name extensions used by programmers:
+
+- Header files:  .hh, .hpp, .hxx
+- Implementation files: .cc, .cxx, .C
+
+This document uses .h and .cpp extensions.
+
+File names are as follows:
+- database_connection.h
+- database_connection.cpp
+
+
+## <a name="c2-3"></a>Function Names
+Functions are named in UpperCamelCase. Generally, the verb or verb-object structure is used. You can add a prefix to an interface. XXX_FunctionName
+```cpp
+class List {
+ public:
+  void AddElement(const Element& element);
+  Element GetElement(const unsigned int index) const;
+  bool IsEmpty() const;
+  bool MCC_GetClass();
+};
+
+namespace utils {
+void DeleteUser();
+}
+```
+
+## <a name="c2-4"></a>Type Names
+
+Types are named in the UpperCamelCase style.
+All types, such as classes, structs, unions, typedefs, and enumerations, use the same conventions.
+
+```cpp
+// classes, structs and unions
+class UrlTable { ...
+class UrlTableTester { ...
+struct UrlTableProperties { ...
+union Packet { ...
+
+// typedefs
+typedef std::map<std::string, UrlTableProperties*> PropertiesMap;
+
+// enums
+enum UrlTableErrors { ...
+```
+
+For namespace naming, UpperCamelCase is recommended.
+```cpp
+// namespace
+namespace osutils {
+  
+namespace fileutils {
+      
+}
+  
+}
+```
+
+
+## <a name="c2-5"></a>Variable Names
+General variables are named in lowerCamelCase, including global variables, function parameters, local variables, and member variables.
+```cpp
+std::string tableName;  // Good: Recommended style.
+std::string tablename;  // Bad: Forbidden style.
+std::string path;       // Good: When there is only one word, lowerCamelCase (all lowercase) is used.
+
+class Foo {
+ private:
+  std::string fileName;    // Do not add a prefix or suffix that identifies the scope.
+};
+```
+
+## <a name="c2-6"></a>Macro, Constant, and Enumeration Names
+For macros, use all caps separated with underscores (_). For constants and enumerated values, use k+CamelCase.
+Local constants and ordinary const member variables use the lowerCamelCase naming style.
+
+```cpp
+#define MAX(a, b)   (((a) < (b)) ? (b) : (a)) // Example of naming a macro only.
+
+enum TintColor {    // Note: Enumerated types are named in the UpperCamelCase style, while their values are in k+CamelCase style.
+  kRed,
+  kDarkRed,
+  kGreen,
+  kLightGreen
+};
+
+int Func(...) {
+  const unsigned int bufferSize = 100;   // Local variable
+  char *p = new char[bufferSize];
+  ...
+}
+
+namespace utils {
+const unsigned int kFileSize = 200;      // Global variable
+}
+
+```
+
+# <a name="c3"></a>3 Formatting
+While programming styles coexist to meet different requirements, we strongly recommend that you use a standardized coding style in the same project so that everyone can easily read and understand the code and the code can be easily maintained.
+
+## <a name="c3-1"></a>Line Length
+
+### <a name="a3-1-1"></a>Recommendation 3.1.1 Each line of code should contain a maximum of 120 characters.
+It is recommended that the number of characters in each line not exceed 120. If the line of code exceeds the permitted length, wrap the line appropriately.
+
+Exception:
+- If a one-line comment contains a command or URL of more than 120 characters, you can keep the line for ease in using copy, paste, and search using the grep command.
+- The length of an #include statement can contain a long path exceeding 120 characters, but this should be avoided if possible.
+- The error information in preprocessor directives can exceed the permitted length.
+Put the error information of preprocessor directives in one line to facilitate reading and understanding even if the line contains more than 120 characters.
+
+```cpp
+#ifndef XXX_YYY_ZZZ
+#error Header aaaa/bbbb/cccc/abc.h must only be included after xxxx/yyyy/zzzz/xyz.h, because xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+#endif
+```
+
+## <a name="c3-2"></a>Indentation
+
+### <a name="r3-2-1"></a>Rule 3.2.1 Use spaces to indent and indent two spaces at a time.
+Only spaces can be used for indentation. Two spaces are indented each time.
+
+
+
+
+## <a name="c3-3"></a>Braces
+### <a name="r3-3-1"></a>Rule 3.3.1 Use the K&R indentation writing style except for functions.
+The left brace of the function is placed at the end of the statement.
+The right brace starts a new line and nothing else is placed on the line, unless it is followed by the remaining part of the same statement, for example, "while" in the do statement, "else" or "else if" in the if statement, a comma, and a semicolon.
+
+ 
+```cpp
+struct MyType {     // Follow the statement to the end, and indent one space.
+  ...
+};
+
+int Foo(int a) {                   // The left brace of the function is placed at the end of the statement.
+  if (...) {
+    ...
+  } else {
+    ...
+  }
+}
+```
+ 
+
+- Code is more compact.
+- Placing the brace at the end of the statement makes the code more continuous in reading rhythm than starting a new line.
+- This style complies with mainstream norms and habits of programming languages.
+- Most modern IDEs have an automatic code indentation, alignment and display. Placing the brace at the end of a line does not impact understanding.
+
+
+If no function body is inside the braces, the braces can be put on the same line.
+```cpp
+class MyClass {
+ public:
+  MyClass() : value(0) {}
+    
+ private:
+  int value;
+};
+```
+
+## <a name="c3-4"></a>Function Declarations and Definitions
+
+### <a name="r3-4-1"></a>Rule 3.4.1 The return type and the function name of a function declaration or definition must be on the same line. When the length of the function parameter list exceeds the permitted length, a line break is required and parameters must be aligned appropriately.
+When a function is declared or defined, the return value type of the function should be on the same line as the function name. If the line length permits, the function parameters should be placed on the same line. Otherwise, the function parameters should be wrapped and properly aligned.
+The left parenthesis of a parameter list should always be on the same line as the function name. The right parenthesis always follows the last parameter.
+
+The following is an example of line breaks:
+```cpp
+ReturnType FunctionName(ArgType paramName1, ArgType paramName2) {  // Good: All are on the same line.
+  ...
+}
+
+ReturnType VeryVeryVeryLongFunctionName(ArgType paramName1,     // Each added parameter starts on a new line because the line length limit is exceeded.
+                                        ArgType paramName2,     // Good: Aligned with the previous parameter
+                                        ArgType paramName3) {
+  ...
+}
+
+ReturnType LongFunctionName(ArgType paramName1, ArgType paramName2, // The parameters are wrapped because the line length limit is exceeded.
+    ArgType paramName3, ArgType paramName4, ArgType paramName5) {     // Good: After the line break, 4 spaces are used for indentation.
+  ...
+}
+
+ReturnType ReallyReallyReallyReallyLongFunctionName(            // The line length cannot accommodate even the first parameter, and a line break is required.
+    ArgType paramName1, ArgType paramName2, ArgType paramName3) { // Good: After the line break, 4 spaces are used for indentation.
+  ...
+}
+```
+
+## <a name="c3-5"></a>Function Calls
+### <a name="r3-5-1"></a>Rule 3.5.1 A function call parameter list should be placed on one line. When the parameter list exceeds the line length and requires a line break, the parameters should be properly aligned.
+The left parenthesis always follows the function name, and the right parenthesis always follows the last parameter.
+
+
+The following is an example of line breaks:
+```cpp
+ReturnType result = FunctionName(paramName1, paramName2);   // Good: All function parameters are on one line.
+
+ReturnType result = FunctionName(paramName1,
+                                 paramName2,                // Good: Aligned with the previous parameter.
+                                 paramName3);
+
+ReturnType result = FunctionName(paramName1, paramName2, 
+    paramName3, paramName4, paramName5);                    // Good: Parameters are wrapped. After the line break, 4 spaces are used for indentation.
+
+ReturnType result = VeryVeryVeryLongFunctionName(           // The line length cannot accommodate even the first parameter, and a line break is required.
+    paramName1, paramName2, paramName3); // After the line break, 4 spaces are used for indentation.
+```
+
+If some of the parameters called by a function are associated with each other, you can group them for better understanding.
+```cpp
+// Good: The parameters in each line represent a group of data structures with a strong correlation. They are placed on one line for ease of understanding.
+int result = DealWithStructureLikeParams(left.x, left.y,     // A group of related parameters.
+                                         right.x, right.y);  // Another group of related parameters.
+```
+
+## <a name="c3-6"></a>if Statements
+
+### <a name="r3-6-1"></a>Rule 3.6.1 Use braces to include an if statement.
+We require that all if statements use braces, even if there is only one statement.
+
+ 
+- The logic is intuitive and easy to read.
+- It is less prone to mistakes when new code is added to the existing if statement.
+- If function-like macros are used in a conditional statement, it is less prone to mistakes (in case the braces are missing when macros are defined).
+
+```cpp
+if (objectIsNotExist) {         // Good: Braces are added to a single-line conditional statement.
+  return CreateNewObject();
+}
+```
+### <a name="r3-6-2"></a>Rule 3.6.2 Place if, else, and else if keywords on separate lines.
+If there are multiple branches in a conditional statement, they should be placed on separate lines.
+
+Good example:
+
+```cpp
+if (someConditions) { 
+  DoSomething();
+  ...
+} else {  // Good: Put the if and else keywords on separate lines.
+  ...
+}
+```
+
+Bad example:
+
+```cpp
+if (someConditions) { ... } else { ... } // Bad: The if and else keywords are put on the same line.
+```
+
+## <a name="c3-7"></a>Loop Statements
+### <a name="r3-7-1"></a>Rule 3.7.1 Use braces after loop statements.
+Similar to if statements, we require that the for and while loop statements contain braces, even if the loop body is empty or there is only one loop statement.
+
+```cpp
+for (int i = 0; i < someRange; i++) {
+  DoSomething();
+}
+```
+
+If the loop body is empty, use empty braces instead of a single semicolon. A single semicolon is easy to miss or incorrectly regarded as a part of the loop statement.
+
+```cpp
+for (int i = 0; i < someRange; i++) { } // Good: The for loop body is empty. Braces should be used, instead of semicolons (;).
+
+while (someCondition) { }  // Good: The while loop body is empty. Braces should be used, instead of semicolons (;).
+
+while (someCondition) {
+  continue;  // Good: The continue keyword highlights the end of the empty loop. Braces are optional in this case.
+}
+
+```
+
+Bad example:
+```cpp
+for (int i = 0; i < someRange; i++) ;   // Bad: The for loop body is empty. Braces are mandatory.
+
+while (someCondition) ; // Bad: Using a semicolon here will make people misunderstand that it is a part of the while statement and not the end to it.
+```
+
+## <a name="c3-8"></a>Switch Statements
+### <a name="r3-8-1"></a>Rule 3.8.1 Indent case and default in a switch statement with four spaces.
+This rule includes the requirement to further indent all content encased by a case or the default case.
+```cpp
+switch (var) {
+  case 0:             // Good: Indented
+    DoSomething1();   // Good: Indented
+    break;
+  case 1: {           // Good: Braces are added.
+    DoSomething2();
+    break;
+  }
+  default:
+    break;
+}
+```
+
+```cpp
+switch (var) {
+case 0:                 // Bad: case is not indented.
+  DoSomething();
+  break;
+default:                // Bad: default is not indented.
+  break;
+}
+```
+
+## <a name="c3-9"></a>Expressions
+
+### <a name="a3-9-1"></a>Recommendation 3.9.1 Keep a consistent line break style for expressions.
+A long expression that does not meet the line length requirement must be wrapped appropriately.
+ 
+
+// Assume that the first line exceeds the length limit.
+```cpp
+if (currentValue > threshold &&  
+  someConditionsion) {
+  DoSomething();
+  ...
+}
+
+int result = reallyReallyLongVariableName1 +    // Good
+             reallyReallyLongVariableName2;
+```
+After an expression is wrapped, ensure that the lines are aligned appropriately or indented with 4 spaces. See the following example.
+
+```cpp
+int sum = longVaribleName1 + longVaribleName2 + longVaribleName3 +
+    longVaribleName4 + longVaribleName5 + longVaribleName6;         // Good: Indented with 4 spaces.
+
+int sum = longVaribleName1 + longVaribleName2 + longVaribleName3 +
+          longVaribleName4 + longVaribleName5 + longVaribleName6;   // Good: The lines are aligned.
+```
+## <a name="c3-10"></a>Variable Assignment
+
+### <a name="r3-10-1"></a>Rule 3.10.1 Multiple variable definitions and assignment statements cannot be written on one line.
+Each line should have only one variable initialization statement. It is easier to read and understand.
+
+```cpp
+int maxCount = 10;
+bool isCompleted = false;
+```
+
+Bad example:
+
+```cpp
+int maxCount = 10; bool isCompleted = false; // Bad: Multiple variable initialization statements must be separated on different lines. Each variable initialization statement occupies one line.
+int x, y = 0;  // Bad: Multiple variable definitions must be separated on different lines. Each definition occupies one line.
+
+int pointX;
+int pointY;
+...
+pointX = 1; pointY = 2;  // Bad: Multiple variable assignment statements must be separated on different lines.
+```
+Exception: Multiple variables can be declared and initialized in the for loop header, if initialization statement (C++17), and structured binding statement (C++17). Multiple variable declarations in these statements have strong associations. Forcible division into multiple lines may cause problems such as scope inconsistency and separation of declaration from initialization.
+
+## <a name="c3-11"></a>Initialization
+Initialization is applicable to structs, unions, and arrays.
+
+### <a name="r3-11-1"></a>Rule 3.11.1 When an initialization list is wrapped, ensure that the line after the break is indented and aligned properly.
+If a structure or array initialization list is wrapped, the line after the break is indented with four spaces.
+Choose the wrap location and alignment style for best comprehension.
+
+```cpp
+const int rank[] = {
+    16, 16, 16, 16, 32, 32, 32, 32,
+    64, 64, 64, 64, 32, 32, 32, 32
+};
+```
+
+## <a name="c3-12"></a>Pointers and References
+### <a name="a3-12-1"></a>Recommendation 3.12.1 The pointer type "`*`" follows a variable name. There is one space between variable name and type.
+
+```cpp
+int *p = nullptr;  // Good
+```
+
+Exception: When a variable is modified by const or restrict, "`*`" cannot follow the variable or type.
+```cpp
+char * const VERSION = "V100";
+```
+
+### <a name="a3-12-2"></a>Recommendation 3.12.2 The reference type "`&`" follows a variable name. There is one space between variable name and type.
+```cpp
+int i = 8;
+
+int &p = i;     // Good
+```
+
+## <a name="c3-13"></a>Preprocessor Directives
+### <a name="r3-13-1"></a>Rule 3.13.1 The number sign "#" that starts a preprocessor directive must be at the beginning of the line and is not indented in nested preprocessor directives.
+The number sign "#" that starts a preprocessor directive must be at the beginning of the line even through the preprocessor directive is inside a function.
+
+```cpp
+#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) // Good: "#" is at the beginning of the line.
+#define ATOMIC_X86_HAS_CMPXCHG16B 1  // Good: "#" is at the beginning of the line.
+#else
+#define ATOMIC_X86_HAS_CMPXCHG16B 0
+#endif 
+
+
+int FunctionName() {
+  if (someThingError) {
+    ...
+#ifdef HAS_SYSLOG        // Good: Even in the function body, "#" is at the beginning of the line.
+    WriteToSysLog();
+#else
+    WriteToFileLog();
+#endif
+  }
+}
+```
+The nested preprocessor directives starting with "#" is not indented.
+
+```cpp
+#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define ATOMIC_X86_HAS_CMPXCHG16B 1  // Good: Wrapped for easier comprehension.
+#else
+#define ATOMIC_X86_HAS_CMPXCHG16B 0
+#endif
+```
+
+## <a name="c3-14"></a>Whitespace
+### <a name="r3-14-1"></a>Rule 3.14.1 Ensure that horizontal spaces are used to highlight keywords and important information, and avoid unnecessary whitespace.
+Horizontal spaces are used to highlight keywords and important information. Spaces are not allowed at the end of each code line. The general rules are as follows:
+
+- Add spaces after keywords such as if, switch, case, do, while, and for.
+- Do not add spaces after the left parenthesis or before the right parenthesis.
+- For expressions enclosed by braces, either add a space on either side or avoid a space on either side.
+- Do not add spaces after unary operators (& * + - ~ !).
+- Add a space to the left and right sides of each binary operator (= + - < > * / % | & ^ <= >= == !=).
+- Add spaces to the left and right sides of a ternary operator (? :).
+- Do not add spaces between a prefix or suffix increment (++) or decrement (--) operator and a variable.
+- Do not add spaces before or after a struct member operator (. ->).
+- Do not add spaces before commas. Add spaces after commas.
+- Do not add spaces between a template or type conversion operator (<>) and a type.
+- Do not add spaces before or after a domain operator (::).
+- Determine whether to add spaces before and after a colon (:) based on the situation.
+
+In normal cases:
+```cpp
+void Foo(int b) {  // Good: A space is before the left brace.
+
+int i = 0;  // Good: During variable initialization, there should be spaces before and after =. Do not leave a space before the semicolon.
+
+int buf[kBufSize] = {0};    // Good: Spaces are not allowed in braces.
+```
+
+Function definition and call:
+```cpp
+int result = Foo(arg1,arg2);
+                    ^    // Bad: Function arguments must be separated by spaces for explicit display.
+
+int result = Foo( arg1, arg2 );
+                 ^          ^  // Bad: There cannot be spaces after the left parenthesis or before the right parenthesis.
+```
+
+Pointer and Address Operator
+```cpp
+x = *p;     // Good: There is no space between the operator * and the pointer p.
+p = &x;     // Good: There is no space between the operator & and the variable x.
+x = r.y;    // Good: When a member variable is accessed through the operator (.), no space is added.
+x = r->y;   // Good: When a member variable is accessed through the operator (->), no space is added.
+```
+
+Other Operators:
+```cpp
+x = 0;   // Good: There is a space before and after the assignment operator (=).
+x = -5;  // Good: There is no space between the minus sign (–) and the number.
+++x;     // Good: Do not add spaces between a prefix or suffix increment (++) or decrement (--) operator and a variable.
+x--;
+
+if (x && !y)  // Good: There is a space before and after the Boolean operator. There is no space between the ! operator and the variable.
+v = w * x + y / z;  // Good: There is a space before and after the binary operator.
+v = w * (x + z);    // Good: There is no space before or after the expression in the parentheses.
+
+int a = (x < y) ? x : y;  // Good: Ternary operator. There is a space before and after ? and :
+```
+
+Loops and Conditional Statements:
+```cpp
+if (condition) {  // Good: There is a space between the if keyword and the left parenthesis, and no space before or after the conditional statement in the parentheses.
+  ...
+} else {           // Good: There is a space between the else keyword and the left brace.
+  ...
+}
+
+while (condition) {}   // Good: There is a space between the while keyword and the left parenthesis. There is no space before or after the conditional statement in the parentheses.
+
+for (int i = 0; i < someRange; ++i) {  // Good: There is a space between the for keyword and the left parenthesis, and after the semicolons.
+  ...
+}
+
+switch (condition) {  // Good: There is a space after the switch keyword.
+  case 0:     // Good: There is no space between the case condition and the colon.
+    ...
+    break;
+    ...
+  default:
+    ...
+    break;
+}
+```
+
+Templates and Conversions
+```cpp
+// Angle brackets (< and >) are not adjacent to space. There is no space before < or between > and (.
+vector<string> x;
+y = static_cast<char*>(x);
+
+// There can be a space between the type and the pointer operator. Keep the spacing style consistent.
+vector<char *> x;
+```
+
+Scope Operators
+```cpp
+std::cout;    // Good: Namespace access. Do not leave spaces.
+
+int MyClass::GetValue() const {}  // Good: Do not leave spaces in the definition of member functions.
+```
+
+Colons
+```cpp
+// Scenarios when space is required.
+
+// Good: Add a space before or after the colon in a derived class definition.
+class Sub : public Base {
+    
+};
+
+// Add a space before and after the colon for the initialization list of a constructor function.
+MyClass::MyClass(int var) : someVar(var) {
+  DoSomething();
+}
+
+// Add a space before and after the colon in a bit-field.
+struct XX {
+  char a : 4;     
+  char b : 5;     
+  char c : 4;
+};
+```
+
+```cpp
+// Scenarios when space is not required.
+
+// Good: // No space is added before or after the colon next to a class access permission (public or private).
+class MyClass {
+ public:
+  MyClass(int var);
+ private:
+  int someVar;
+};
+
+// No space is added before or after the colon in a switch statement.
+switch (value) {
+  case 1:
+    DoSomething();
+    break;
+  default:
+    break;
+}
+```
+
+Note: Currently, all IDEs support automatic deletion of spaces at the end of a line. Please configure your IDE correctly.
+
+### <a name="a3-14-2"></a>Recommendation 3.14.2 Use blank lines only when necessary to keep code compact.
+
+There must be as few blank lines as possible so that more code can be displayed for easy reading. Recommendations:
+- Add blank lines according to the correlation between lines.
+- Consecutive blank lines are not allowed inside functions, type definitions, macros, and initialization expressions.
+- A maximum of **two** consecutive blank lines can be used.
+-.Do not add blank lines on the first and last lines of a code block.
+
+```cpp
+int Foo() {
+  ...
+}
+
+
+// Bad: More than one blank lines are used between two function definitions.
+int Bar() {
+  ...
+}
+
+
+if (...) {
+        // Bad: Do not add blank lines on the first and last lines of a code block.
+  ...
+        // Bad: Do not add blank lines on the first and last lines of a code block.
+}
+
+int Foo(...) {
+        // Bad: Do not add blank lines before the first statement in a function body.
+  ...
+}
+```
+
+## <a name="c3-15"></a>Classes
+### <a name="r3-15-1"></a>Rule 3.15.1 Class access specifier declarations are in the sequence: public, protected, private. Indent each specifier with one space.
+```cpp
+class MyClass : public BaseClass {
+ public:      // Indented with 1 space.
+  MyClass();  // Indented with 2 spaces.
+  explicit MyClass(int var);
+  ~MyClass() {}
+
+  void SomeFunction();
+  void SomeFunctionThatDoesNothing() {
+  }
+
+  void SetVar(int var) { 
+    someVar = var; 
+  }
+  
+  int GetVar() const { 
+    return someVar; 
+  }
+
+ private:
+  bool SomeInternalFunction();
+
+  int someVar;
+  int someOtherVar;
+};
+```
+
+In each part, it is recommended that similar statements be put together in the following order: Type (including typedef, using, nested structs and classes), Constant, Factory Function, Constructor, Assignment Operator, Destructor, Other Member Function, and Data Member.
+
+
+### <a name="r3-15-2"></a>Rule 3.15.2 The constructor initialization list must be on the same line or wrapped and aligned with four spaces of indentation.
+```cpp
+// If all variables can be placed on the same line:
+MyClass::MyClass(int var) : someVar(var) {
+  DoSomething();
+}
+
+// If the variables cannot be placed on the same line:
+// Wrapped at the colon and indented with four spaces.
+MyClass::MyClass(int var)
+    : someVar(var), someOtherVar(var + 1) { // Good: Add a space after the comma.
+  DoSomething();
+}
+
+// If an initialization list needs to be placed in multiple lines, put each member on a separate line and align between lines.
+MyClass::MyClass(int var)
+    : someVar(var),             // Indented with 4 spaces.
+      someOtherVar(var + 1) {  
+  DoSomething();
+}
+```
+
+# <a name="c4"></a>4 Comments
+Generally, clear architecture and good naming are recommended to improve code readability, and comments are provided only when necessary.
+Comments are used to help readers quickly understand code. Therefore, comments should be provided __for the sake of readers__.
+
+Comments must be concise, clear, and unambiguous, ensuring that information is complete and not redundant.
+
+__Comments are as important as code.__
+When writing a comment, you need to step into the reader's shoes and use comments to express what the reader really needs. Comments are used to express the function and intention of code, rather than repeating the code.
+When modifying the code, ensure that the comments are consistent with the modified code. It is not polite to modify only code and keep the old comments, which will undermine the consistency between code and comments, and may confuse or even mislead readers.
+
+## <a name="c4-1"></a>Comment Style
+In C++ code, both ` /* */` and ` // ` can be used for commenting.
+Comments can be classified into different types, such as file header comments, function header comments, and code comments. This is based on their purposes and positions.
+Comments of the same type must keep a consistent style.
+(1) Use ` /* */ ` for file header comments.
+(2) The style of function header comments and code comments in the same file must be consistent.
+
+Note: __Example code in this document uses comments in the '//' format only to better describe the rules and recommendations. This does not mean this comment format is better.__
+
+## <a name="c4-2"></a>File Header Comments
+### <a name="r4-2-1"></a>Rule 4.2.1 File header comments must contain the copyright notice.
+```cpp
+/*
+ * Copyright (c) [2019] [name of copyright holder]
+ * [Software Name] is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *   http://license.coscl.org.cn/MulanPSL
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+```
+
+
+
+## <a name="c4-3"></a>Function Header Comments
+### <a name="r4-3-1"></a>Rule 4.3.1 Function header comments with no content are forbidden.
+Not all functions need function header comments.
+For information that cannot be described by function signatures, add function header comments.
+
+Function header comments are placed above the function declaration or definition. Use one of the following styles:
+Use `//` to start the function header.
+
+```cpp
+// Single-line function header
+int Func1(void);
+
+// Multi-line function header
+// Second line
+int Func2(void);
+```
+
+Use `/*   */` to start the function header.
+```cpp
+/* single-line function header */
+int Func1(void);
+
+/*
+ * Another single-line function header
+ */
+int Func2(void);
+
+/*
+ * Multi-line function header
+ * Second line
+ */
+int Func3(void);
+```
+Use function names to describe functions, and add function header comments if necessary.
+Do not write useless or redundant function headers. Do not write empty function headers with no content.
+
+The function header comment content will depend on the function and includes but is not limited to: a function description, return value, performance constraints, usage comments, memory conventions, algorithm implementation, reentering requirements.
+In the function interface declaration in the external header file, the function header comment should clearly describe important and useful information.
+
+Good example:
+
+```cpp
+/*
+ * The number of written bytes is returned. If -1 is returned, the write operation failed.
+ * Note that, the memory buffer should be released by the caller.
+ */
+int WriteString(const char *buf, int len);
+```
+
+Bad example:
+```cpp
+/*
+ * Function name: WriteString
+ * Function: Write a character string.
+ * Parameters:
+ * Return value:
+ */
+int WriteString(const char *buf, int len);
+```
+Problems:
+
+- The 'Parameters' and 'Return value' have no content.
+- The function name comment is redundant.
+- The most important thing, that is, who needs to release the buffer, is not clearly stated.
+
+## <a name="c4-4"></a>Code Comments
+### <a name="r4-4-1"></a>Rule 4.4.1 Code comments are placed above or to the right of the corresponding code.
+### <a name="r4-4-2"></a>Rule 4.4.2 There must be a space between the comment character and the comment content. At least one space is required between the comment and code if the comment is placed to the right of code.
+Comments placed above the code should be indented the same as that of the code.
+Use one of the following styles:
+Use `//`.
+```cpp
+
+// Single-line comment
+DoSomething();
+
+// Multi-line comment
+// Second line
+DoSomething();
+```
+
+Use `/*' '*/`.
+```cpp
+/* Single-line comment */
+DoSomething();
+
+/*
+ * Multi-line comment in another mode
+ * Second line
+ */
+DoSomething();
+```
+Leave at least one space between the code and the comment on the right. It is recommended that no more than four spaces be left.
+You can use the Tab key to indent 1–4 spaces, set this in your IDE or editor.
+
+Use one of the following styles:
+
+```cpp
+int foo = 100;  // Comment on the right
+int bar = 200;  /* Comment on the right */
+```
+It is more appealing sometimes when the comment is placed on the right of code and the comments are aligned vertically.
+After the alignment, ensure that the comment is still 1–4 spaces away from the widest line of code.
+Example:
+
+```cpp
+const int kConst = 100;          /* Related comments of the same type can be aligned vertically. */
+const int kAnotherConst = 200;   /* Leave spaces after code to align comments vertically.*/
+```
+When the comment on the right exceeds the line width, consider placing the comment above the code.
+
+### <a name="r4-4-3"></a>Rule 4.4.3 Delete unused code segments. Do not comment them out.
+Code that is commented out cannot be maintained normally. When you attempt to restore the code, it is very likely to introduce easy to overlook defects.
+The correct method is to delete unnecessary code directly. If necessary, consider porting or rewriting the code.
+
+Here, commenting out the removal of code from compilation without actually deleting it. This is done using /* */, //, #if 0, #ifdef NEVER_DEFINED, and so on.
+
+### <a name="a4-4-1"></a>Recommendation 4.4.1 Try not to contain a TODO/TBD/FIXME comment in code.
+TODO/TBD comments are used to describe required improvements and supplements.
+FIXME comments are used to describe defects that need fixing.
+They should have a standardized style, which facilitates text search. 
+
+```cpp
+// TODO(<author-name>): XX
+// FIXME: XX
+```
+
+
+# <a name="c5"></a>5 Header Files
+## <a name="c5-1"></a>Header File Responsibility
+A header file is an external interface of a module or file. The design of a header file shows most of the system design.
+The interface declaration for most functions is more suitable placed in the header file, but implementation (except inline functions) cannot be placed in the header file. Functions, macros, enumerations, and structure definitions that need to be used in .cpp files cannot be placed in the header file.
+The header responsibility should be simple. A too complex header file will make dependencies complex and cause a long compilation time.
+
+### <a name="a5-1-1"></a>Recommendation 5.1.1 Each .cpp file should have a .h file with the same name. The file is used to declare the classes and interfaces that need to be exposed externally.
+Generally, each .cpp file has a corresponding .h file. This .cpp file is used to store the function declarations, macro definitions, and class definitions that are to be disclosed externally. In addition, corresponding .inline.h files can be added based on sit requirements to optimize code.
+If a .cpp file does not need to open any interface externally, it should not exist.
+Exception: __An entry point (for example, the file where the main function is located), unit tests, and dynamic library code.__
+
+Example:
+```cpp
+// Foo.h 
+
+#ifndef FOO_H
+#define FOO_H
+
+class Foo {
+ public:
+  Foo();
+  void Fun();
+    
+ private:
+  int value;
+};
+
+#endif
+```
+
+```cpp
+// Foo.cpp
+#include "Foo.h"
+
+namespace { // Good: The declaration of the internal function is placed in the header of the .cpp file, and has been limited to the unnamed namespace or static scope.
+void Bar() {
+}
+}
+
+...
+
+void Foo::Fun() {
+  Bar();
+}
+```
+
+## <a name="c5-2"></a>Header File Dependency
+### <a name="r5-2-1"></a>Rule 5.2.1 Header file cyclic dependency is forbidden.
+Cyclic dependency of header files means that a.h contains b.h, b.h contains c.h, and c.h contains a.h. If any header file is modified, all code containing a.h, b.h, and c.h needs to be recompiled.  
+For a unidirectional dependency, for example, a.h contains b.h, b.h contains c.h, and c.h does not contain any header file, modifying a.h does not mean that we need to recompile the source code for b.h or c.h.
+
+The cyclic dependency of header files directly reflects the unreasonable architecture design, which can be avoided by optimizing the architecture.
+
+### <a name="r5-2-2"></a>Rule 5.2.2 Do not include unnecessary header files.
+The inclusion of header files that are not used will cause unnecessary dependency, which increases the coupling between modules or units. As long as a header file is modified, the code needs to be recompiled.
+
+In many systems, the inclusion relationships of header files are complex. To save time, developers may directly include all header files in their files, or even release a god.h file that contains all header files to project teams. This will cause a great time in compilation and great trouble in maintenance.
+
+### <a name="r5-2-3"></a>Rule 5.2.3 Header files should be self-contained.
+Simply, self-containing means that any header file can be compiled independently. For a file containing a header file, unnecessary burdens are added to users if the file cannot work unless the header file contains another header file.
+
+For example, if the a.h header file is not self-contained, but must contain b.h, it will cause:
+
+Each .cpp file that uses the a.h header file must include the additional b.h header file to ensure that the a.h content can be compiled.
+The additional b.h header file must be included before a.h, which has a dependency in the inclusion order.
+
+
+### <a name="r5-2-4"></a>Rule 5.2.4 Header files must have `#define` guards to prevent multiple inclusion.
+To prevent header files from being included multiple times, all header files should be protected by #define. Do not use #pragma once.
+
+When defining a protection character, comply with the following rules:
+(1) The protection character uses a unique name.
+(2) Do not place code or comments (except for file header comments) before or after the protected part.
+
+Example: Assume that the timer.h file of the timer module of the VOS project is in the VOS/include/timer/Timer.h directory. Perform the following operations to protect the timer.h file:
+
+```cpp
+#ifndef VOS_INCLUDE_TIMER_TIMER_H
+#define VOS_INCLUDE_TIMER_TIMER_H
+...
+#endif
+```
+
+You do not need to add a path as shown in the preceding example, but you need to ensure that the macro in the current project is unique.
+```cpp
+#ifndef TIMER_H
+#define TIMER_H
+...
+#endif
+```
+
+### <a name="r5-2-1"></a>Recommendation 5.2.1 It is prohibited to reference external function interfaces and variables in declaration mode.
+Interfaces provided by other modules or files can be used only by including header files.
+Using external function interfaces and variables in extern declaration mode may cause inconsistency between declarations and definitions when external interfaces are changed.
+In addition, this implicit dependency may cause architecture corruption.
+
+Cases that do not comply with specifications:
+
+// a.cpp content
+```cpp
+extern int Fun();   // Bad: Use external functions in extern mode.
+
+void Bar() {
+  int i = Fun();
+  ...
+}
+```
+
+// b.cpp content
+```cpp
+int Fun() {
+  // Do something
+}
+```
+It should be changed to:
+
+// a.cpp content
+```cpp
+#include "b.h"   // Good: Use the interface provided by other .cpp by including its corresponding header file.
+
+void Bar() {
+  int i = Fun();
+  ...
+}
+```
+
+// b.h content
+```cpp
+int Fun();
+```
+
+// b.cpp content
+```cpp
+int Fun() {
+  // Do something
+}
+```
+In some scenarios, if the internal functions need to be referenced with no intrusion to the code, the extern declaration mode can be used.
+For example:
+When performing unit testing on an internal function, you can use the extern declaration to reference the function to be tested.
+When a function needs to be stubbed or patched, the function can be declared using extern.
+
+### <a name="r5-2-5"></a>Rule 5.2.5 Do not include header files in extern "C".
+If a header file is included in extern "C", extern "C" may be nested. Some compilers restrict the nesting level of extern "C". If there are too many nested layers, compilation errors may occur.
+
+When C and C++ programmings are used together and if extern "C" includes a header file, the original intent behind the header file may be hindered. For example, when the link specifications are modified incorrectly.
+
+Example: Assume that there are two header files, a.h and b.h.
+
+// a.h content
+```cpp
+...
+#ifdef __cplusplus
+void Foo(int);
+#define A(value) Foo(value)
+#else
+void A(int)
+#endif
+```
+// b.h content
+```cpp
+...
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "a.h"
+void B();
+
+#ifdef __cplusplus
+}
+#endif
+```
+
+Use the C++ preprocessor to expand b.h. The following information is displayed:
+```cpp
+extern "C" {
+  void Foo(int);
+  void B();
+}
+```
+
+According to the author of a.h, the function Foo is a C++ free function following the "C++" link specification.
+However, because `#include "a.h"` is placed inside `extern "C"` in b.h, the link specification of function Foo is changed incorrectly.
+
+Exception:
+In the C++ compilation environment, if you want to reference the header file of pure C, the C header files must not include `extern "C"`. The non-intrusive approach is to include the C header file in `extern "C"`.
+
+### <a name="a5-2-2"></a>Recommendation 5.2.2 Use `#include` instead of a forward declaration to include header files.
+A forward declaration is for the declaration of classes, functions, and templates and is not meant for its definition.
+
+- Pros:
+  1. Forward declarations can save compilation time. Unnecessary #includes force the compiler to open more files and process more input.
+  2. Forward declarations can save unnecessary recompilation time. The use of #include will force your code to be recompiled for multiple times due to unrelated changes in header files.
+- Cons:
+  1. Forward declarations hide dependency relationship. When a header file is modified, user code will skip the necessary recompilation process.
+  2. A forward declaration may be broken by subsequent changes to the library. Forward declarations of functions and templates sometimes prevent header file developers from changing APIs. For example, widening a formal parameter type, adding a formal template parameter with a default value, and so on.
+  3. Forward declaration of symbols from the namespace `std::` is seen as undefined behavior (as specified in the C++ 11 standard specification).
+  4. Forward declaration of multiple symbols from a header file can be more verbose than simply including (#include) the header.
+  5. Structuring code only for forward declaration (for example, using pointer members instead of object members) can make the code more complex and slower.
+  6. It is difficult to determine whether a forward declaration or `#include` is needed. In some scenarios, replacing `#include` with a forward declaration may cause unexpected results.
+
+Therefore, we should avoid using forward declarations as much as possible. Instead, we use the #include statement to include a header file and ensure dependency.
+
+### <a name="a5-2-3"></a>Recommendation 5.2.3 Include headers in the following sequence: .h file corresponding to the .cpp file > other header files according to their stability.
+Using standard header file inclusion sequence can enhance readability and avoid hidden dependencies. The recommended header file inclusion priority is: the header file corresponding to the .cpp file > C/C++ standard libraries > .h files from used system libraries > .h files from other libraries > other .h files in the project.
+
+For example, the sequence of the header files in Foo.cpp is as follows:
+```cpp
+#include "Foo/Foo.h"
+
+#include <cstdlib>
+#include <string>
+
+#include <linux/list.h>
+#include <linux/time.h>
+
+#include "platform/Base.h"
+#include "platform/Framework.h"
+
+#include "project/public/Log.h"
+```
+Placing the Foo.h file at the top ensures that when the Foo.h file misses some necessary libraries or an error occurs, the Foo.cpp build is terminated immediately, reducing the compilation time. For the sequence of header files, refer to this suggestion.
+
+Exception:
+Platform-specific code requires conditional compilation. The code can be placed after other "includes".
+```cpp
+#include "foo/public/FooServer.h"
+
+#include "base/Port.h"  // For LANG_CXX11.
+
+#ifdef LANG_CXX11
+#include <initializer_list>
+#endif  // LANG_CXX11
+```
+
+# <a name="c6"></a>6 Scopes
+
+## <a name="c6-1"></a>Namespaces
+The content of a namespace is not indented.
+
+### <a name="a6-1-1"></a>Recommendation 6.1.1 Use an unnamed namespace to encapsulate or use static to modify variables, constants, or functions that do not need to be exported from the .cpp file.
+In the C++ 2003 standard, using static to modify the external availability of functions and variables was marked as deprecated. Therefore, unnamed namespaces are the recommended method.
+
+The main reasons are as follows:
+1. There are too many meanings for static in C++: static function member variable, static member function, static global variable, and static function local variable. Each of them has special processing.
+2. Static can only be used to define variables, constants, and functions that are not referenced outside the current .cpp file, while namespaces can also be used to encapsulate types.
+3. Use a namespace to process the scope of C++ instead of using both static and namespaces.
+4. Unnamed namespaces rather than functions modified by static can be used to instantiate templates.
+
+Do not use unnamed namespaces or static in header files.
+
+```cpp
+// Foo.cpp
+
+namespace {
+const int kMaxCount = 20;
+void InternalFun(){};
+}
+
+void Foo::Fun() {
+  int i = kMaxCount;
+    
+  InternalFun();
+}
+
+```
+
+### <a name="r6-1-1"></a>Rule 6.1.1 Do not use "using" to import a namespace in header files or before #include statements.
+Note: Using "using" to import a namespace will affect subsequent code and may cause symbol conflicts. Therefore, do not use "using" to import a namespace in a header file or before #include in a source file.
+Example:
+
+```cpp
+// Header file a.h
+namespace namespacea {
+int Fun(int);
+}
+```
+
+```cpp
+// Header file b.h
+namespace namespaceb {
+int Fun(int);
+}
+
+using namespace namespaceb;
+
+void G() {
+  Fun(1); 
+}
+```
+
+```cpp
+// Source code a.cpp
+#include "a.h"
+using namespace namespacea; 
+#include "b.h"
+
+void main() {
+  G(); // using namespace namespacea is before #include "b.h", which will cause the following issues: The calling of namespacea::Fun and namespaceb::Fun is not clear.
+}
+```
+
+Using "using" to import a symbol or define an alias in a header file is allowed in customized namespaces of modules, but is prohibited in the global namespace.
+```cpp
+// foo.h
+
+#include <fancy/string>
+using fancy::string;  // Bad: It is prohibited to import symbols to global namespaces.
+
+namespace foo {
+using fancy::string;  // Good: Symbols can be imported in customized namespaces of modules.
+using MyVector = fancy::vector<int>;  // Good: In C++11, aliases can be defined in customized namespaces.
+}
+```
+
+
+### <a name="r6-1-2"></a>Rule 6.1.2 Do not use "using namespace std".
+Note: The std:: prefix can make code clear and avoid naming conflicts.
+
+
+## <a name="c6-2"></a>Global Functions and Static Member Functions
+
+### <a name="a6-2-1"></a>Recommendation 6.2.1 Preferentially use namespaces to manage global functions. If global functions are closely related to a class, you can use static member functions.
+Note: Placing non-member functions in a namespace avoids polluting the global scope. Do not use "class + static member function" to simply manage global functions. If a global function is closely tied to a class, it can be used as a static member function of the class.
+
+If you need to define some global functions for a .cpp file, use unnamed namespaces for management.
+```cpp
+namespace mynamespace {
+int Add(int a, int b);
+}
+
+class File {
+ public:
+  static File CreateTempFile(const std::string& fileName);
+};
+```
+
+## <a name="c6-3"></a>Global Constants and Static Member Constants
+
+### <a name="a6-3-1"></a>Recommendation 6.3.1 Preferentially use namespaces to manage global constants. If global constants are closely related to a class, you can use static member constants.
+Note: Placing global constants in a namespace avoids polluting the global scope. Do not use "class + static member constant" to simply manage global constants. If a global constant is closely tied to a class, it can be used as a static member constant of the class.
+
+If you need to define some global constants only for a .cpp file, use unnamed namespaces for management.
+```cpp
+namespace mynamespace {
+const int kMaxSize = 100;
+}
+
+class File {
+ public:
+  static const std::string kName;
+};
+```
+
+## <a name="c6-4"></a>Global Variables
+
+### <a name="a6-4-1"></a>Recommendation 6.4.1 Do not use global variables. Use the singleton pattern instead.
+Note: Global variables can be modified and read, which causes data coupling between the business code and the global variable.
+```cpp
+int counter = 0;
+
+// a.cpp
+counter++;
+
+// b.cpp
+counter++;
+
+// c.cpp
+cout << counter << endl;
+```
+
+Singleton
+```cpp
+class Counter {
+ public:
+  static Counter& GetInstance() {
+    static Counter counter;
+    return counter;
+  }  // Simple example of a singleton implementation
+    
+  void Increase() {
+    value++;
+  }
+    
+  void Print() const {
+    std::cout << value << std::endl;
+  }
+
+ private:
+  Counter() : value(0) {}
+
+ private:
+  int value;
+};
+
+// a.cpp
+Counter::GetInstance().Increase();
+
+// b.cpp
+Counter::GetInstance().Increase();
+
+// c.cpp
+Counter::GetInstance().Print();
+```
+
+After the singleton is implemented, there is a unique global instance, which can functions as a global variable. In addition, singleton provides better encapsulation.
+
+Exception: In some cases, the scope of a global variable is only inside a module. Multiple instances of the same global variable may exist in the process space, and each module holds one copy. In this case, a singleton cannot be used as it is limited to one instance.
+
+# <a name="c7"></a>7 Classes
+
+Use a struct only for passive objects that carry data; everything else is a class.
+
+## <a name="c7-1"></a>Constructors, Copy/Move Constructors, Copy/Move Assignment Operators, and Destructors
+Constructors, copy/move constructors, copy/move assignment operators, and destructors provide lifetime management methods for objects.
+- Constructor: `X()`
+- Copy constructor: `X(const X&)`
+- Copy assignment operator: `operator=(const X&)`   
+- Move constructor: `X (X&&)`         *Provided in versions later than C++ 11*.
+- Move assignment operator: `operator=(X&&)`       *Provided in versions later than C++ 11*.
+- Destructor: `~X()`
+
+### <a name="r7-1-1"></a>Rule 7.1.1 The member variables of a class must be initialized explicitly.
+Note: If a class has member variables but no constructors and default constructors are defined, the compiler will automatically generate a constructor, which will not initialize member variables. The object status is uncertain.
+
+Exception:
+- If the member variables of a class have a default constructor, explicit initialization is not required.
+
+Example: The following code has no constructor, and private data members cannot be initialized:
+```cpp
+class Message {
+ public:
+  void ProcessOutMsg() {
+    //…
+  }
+ private:
+  unsigned int msgID;
+  unsigned int msgLength; 
+  unsigned char* msgBuffer;
+  std::string someIdentifier;
+};
+
+Message message;   // The message member variable is not initialized.
+message.ProcessOutMsg();   // Potential risks exist in subsequent use.
+
+// Therefore, it is necessary to define the default constructor as follows:
+class Message {
+ public:
+  Message() : msgID(0), msgLength(0) {
+  }
+    
+  void ProcessOutMsg() {
+    // …
+  }
+    
+ private:
+  unsigned int msgID;
+  unsigned int msgLength; 
+  unsigned char* msgBuffer;
+  std::string someIdentifier; // The member variable has a default constructor. Therefore, explicit initialization is not required.
+};
+```
+
+### <a name="a7-1-1"></a>Recommendation 7.1.1 Initialization during declaration (C++ 11) and initialization using the constructor initialization list are preferred for member variables.
+Note: Initialization during declaration (C++11) is preferred because initialized values of member variables can be easily understood. If initialized values of certain member variables are relevant to constructors, or C++ 11 is not supported, the constructor initialization list should be used preferentially to initialize these member variables. Compared with the assignment statements in constructors, code of the constructor initialization list is simpler and has higher performance, and can be used to initialize constant and reference members.
+
+```cpp
+class Message {
+ public:
+  Message() : msgLength(0) {  // Good: The constructor initialization list is preferred.
+    msgBuffer = NULL;     // Bad: Values cannot be assigned in constructors.
+  }
+    
+ private:
+  unsigned int msgID{0};  // Good: used in C++11.
+  unsigned int msgLength;
+  unsigned char* msgBuffer;
+};
+```
+
+### <a name="r7-1-2"></a>Rule 7.1.2 Declare single-parameter constructors as explicit to prevent implicit conversion.
+Note: If a single-parameter constructor is not declared as explicit, it will become an implicit conversion function.
+Example:
+
+```cpp
+class Foo {
+ public:
+  explicit Foo(const string& name): name(name) {
+  }
+ private:
+  string name;
+};
+
+
+void ProcessFoo(const Foo& foo){}
+
+int main(void) {
+  std::string test = "test";
+  ProcessFoo(test);  // Compiling failed.
+  return 0;
+}
+```
+
+The preceding code fails to be compiled because the parameter required by `ProcessFoo` is of the Foo type, which mismatch with the input string type.
+
+If the explicit keyword of the Foo constructor is removed, implicit conversion is triggered and a temporary Foo object is generated when `ProcessFoo` is called with the string parameter. Usually, this implicit conversion is confusing and bugs are apt to be hidden, due to unexpected type conversion. Therefore, single-parameter constructors require explicit declaration.
+
+### <a name="r7-1-3"></a>Rule 7.1.3 If copy/move constructors and copy/move assignment operators are not needed, clearly prohibit them.
+Note: If users do not define it, the compiler will generate copy/move constructors and copy/move assignment operators (move semantic functions will be available in versions later than C++ 11).
+If we do not use copy constructors or copy assignment operators, explicitly delete them.
+
+1. Set copy constructors or copy assignment operators to private and do not implement them.
+
+```cpp
+class Foo {
+ private:
+  Foo(const Foo&);
+  Foo& operator=(const Foo&);
+};
+```
+2. Use delete provided by C++ 11.
+
+```cpp
+// Copy constructors and copy assignment operators are forbidden together. Use delete provided by C++ 11.
+class Foo {
+ public:
+  Foo(Foo&&) = delete;
+  Foo& operator=(Foo&&) = delete;
+};
+```
+3. For static method class, disable constructors to prevent instances from being created.
+
+```cpp
+class Helper {
+ public:
+  static bool DoSomething();
+
+ private:
+  Helper();
+};
+```
+4. For singleton class, disable constructors and copy constructors to prevent instances from being created.
+
+```cpp
+class Foo {
+ private:
+  static Foo *instance;
+  Foo() {}
+  Foo(const Foo &a);
+  Foo& operator=(const Foo &a);
+ public:
+  static Foo &Instance() {
+    if (!instance) {
+      instance = new Foo();
+    }
+    return *instance;
+  }
+};
+```
+
+5. For destructors that release resources by raw pointers, disable copy constructions and copy assignment operators to prevent repeated release.
+
+```cpp
+class Foo {
+ private:
+  FILE *fp;
+  Foo(const Foo &a);
+  Foo& operator=(const Foo &a);
+ public:
+  Foo() : fp(nullptr) {}
+  ~Foo() {
+    if (fp != nullptr) {
+      fclose(fp);
+      fp = nullptr;
+    }
+  }
+};
+
+Foo* Foo::instance = nullptr;
+```
+
+### <a name="r7-1-4"></a>Rule 7.1.4 Copy constructors and copy assignment operators should be implemented or forbidden together.
+Both copy constructors and copy assignment operators provide copy semantics. They should be implemented or forbidden together.
+
+```cpp
+// Copy constructors and copy assignment operators are implemented together.
+class Foo {
+ public:
+  ...
+  Foo(const Foo&);
+  Foo& operator=(const Foo&);
+  ...
+};
+
+// Copy constructors and copy assignment operators are both set to default, as supported by C++ 11.
+class Foo {
+ public:
+  Foo(const Foo&) = default;
+  Foo& operator=(const Foo&) = default;
+};
+
+// Copy constructors and copy assignment operators are forbidden together. You can use delete provided by C++ 11.
+class Foo {
+ private:
+  Foo(const Foo&);
+  Foo& operator=(const Foo&);
+};
+```
+
+### <a name="r7-1-5"></a>Rule 7.1.5 Move constructors and move assignment operators should be implemented or forbidden together.
+The move operation is added in C++ 11. If a class is required to support the move operation, move constructors and move assignment operators need to be implemented.
+
+Both move constructors and move assignment operators provide move semantics. They should be implemented or forbidden together.
+```cpp
+// Move constructors and move assignment operators are implemented together.
+class Foo {
+ public:
+  ...
+  Foo(Foo&&);
+  Foo& operator=(Foo&&);
+  ...
+};
+
+// Move constructors and move assignment operators are both set to default, as supported by C++ 11.
+class Foo {
+ public:
+  Foo(Foo&&) = default;
+  Foo& operator=(Foo&&) = default;
+};
+
+// Move constructors and move assignment operators are forbidden together. Use delete provided by C++ 11.
+class Foo {
+ public:
+  Foo(Foo&&) = delete;
+  Foo& operator=(Foo&&) = delete;
+};
+```
+
+### <a name="r7-1-6"></a>Rule 7.1.6 It is prohibited to call virtual functions in constructors and destructors.
+Note: Calling a virtual function of the current object in a constructor or destructor will cause behavior of non-polymorphism.
+In C++, a base class constructs only one complete object at a time.
+
+Example: Base indicates the base class, and Sub indicates the derived class.
+```cpp
+class Base {                       
+ public:                
+  Base();
+  virtual void Log() = 0;    // Different derived classes call different log files.
+};
+
+Base::Base() {        // Base class constructor
+  Log();              // Call the virtual function log.
+}                                                  
+
+class Sub : public Base {       
+ public:
+  virtual void Log();          
+};
+```
+
+When running the following statement:
+`Sub sub;`
+The constructor of the derived class is executed first. However, the constructor of the base class is called first. Because the constructor of the base class calls the virtual function log, the log is in the base class version. The derived class is constructed only after the base class is constructed. As a result, behavior of non-polymorphism are caused.
+This also applies to destructors.
+
+### <a name="a7-1-2"></a>Recommendation 7.1.2 Do not add the inline keyword to functions in the class definition.
+Note: By default, functions in the class definition are inline.
+
+
+## <a name="c7-2"></a>Inheritance
+
+### <a name="r7-2-1"></a>Rule 7.2.1 Destructors of the base class should be declared as virtual.
+Note: Destructors of the derived class can be called during polymorphism invocation only when destructors of the base class are virtual.
+
+Example: There will be memory leak if destructors of the base class are not declared as virtual.
+```cpp
+class Base {
+ public:
+  virtual std::string getVersion() = 0;
+    
+  ~Base() {
+    std::cout << "~Base" << std::endl;
+  }
+};
+```
+
+```cpp
+class Sub : public Base {
+ public:
+  Sub() : numbers(nullptr) {  
+  }
+    
+  ~Sub() {
+    delete[] numbers;
+    std::cout << "~Sub" << std::endl;
+  }
+    
+  int Init() {
+    const size_t numberCount = 100;
+    numbers = new (std::nothrow) int[numberCount];
+    if (numbers == nullptr) {
+      return -1;
+    }
+        
+    ...
+  }
+
+  std::string getVersion() { 
+    return std::string("hello!");
+  }
+private:
+  int* numbers;
+};
+```
+
+```cpp
+int main(int argc, char* args[]) {
+  Base* b = new Sub();
+
+  delete b;
+  return 0;
+}
+```
+Because destructors of the base class are not declared as virtual, only destructors of the base class are called when an object is destroyed. Destructors of the derived class Sub are not called. As a result, a memory leak occurs.
+
+
+### <a name="r7-2-2"></a>Rule 7.2.2 Do not use default parameter values for virtual functions.
+Note: In C++, virtual functions are dynamically bound, but the default parameters of functions are statically bound during compilation. This means that the function you finally execute is a virtual function that is defined in the derived class but uses the default parameter value in the base class. To avoid confusion and other problems caused by inconsistent default parameter declarations during overriding of virtual functions, it is prohibited to declare default parameter values for all virtual functions.
+Example: The default value of parameter "text" of the virtual function "Display" is determined at compilation time instead of runtime, which does not fit with polymorphism.
+```cpp
+class Base {
+ public:
+  virtual void Display(const std::string& text = "Base!") {
+    std::cout << text << std::endl;
+  }
+    
+  virtual ~Base(){}
+};
+
+class Sub : public Base {
+ public:
+  virtual void Display(const std::string& text  = "Sub!") {
+    std::cout << text << std::endl; 
+  }
+    
+  virtual ~Sub(){}
+};
+
+int main() {
+  Base* base = new Sub();
+  Sub* sub = new Sub();
+   
+  ...
+    
+  base->Display();  // The program output is as follows: Base! The expected output is as follows: Sub!
+  sub->Display();   // The program output is as follows: Sub!
+    
+  delete base;
+  delete sub;
+  return 0;
+};
+```
+
+### <a name="r7-2-3"></a>Rule 7.2.3 Do not redefine inherited non-virtual functions.
+Note: Non-virtual functions cannot be dynamically bound (only virtual functions can be dynamically bound). You can obtain the correct result by operating the pointer of the base class.
+
+Example:
+```cpp
+class Base {
+ public:
+  void Fun();
+};
+
+class Sub : public Base { 
+ public:
+  void Fun();
+};
+
+Sub* sub = new Sub();                     
+Base* base = sub;
+
+sub->Fun();    // Call Fun of the derived class.                  
+base->Fun();   // Call Fun of the base class.
+//...
+
+```
+
+## <a name="c7-3"></a>Multiple Inheritance
+In the actual development process, multiple inheritance scenarios are seldom used because the following typical problems may occur:
+1. Data duplication and name ambiguity caused by "diamond" inheritance. Therefore, C++ introduces virtual inheritance to solve these problems.
+2. In addition to "diamond" inheritance, names of multiple base classes may also conflict with each other, resulting in name ambiguity.
+3. If a derived class needs to be extended or needs to override methods of multiple base classes, the responsibilities of the derived classes are unclear and semantics are muddled.
+4. Compared with delegation, inheritance is seen as white box reuse, that is, a derived class can access the protected members of the base class, which leads to more coupling. Multiple inheritance, due to the coupling of multiple base classes, leads to even more coupling.
+
+Multiple inheritance has the following advantages:
+Multiple inheritance provides a simpler method for assembling and reusing multiple interfaces or classes.
+
+Therefore, multiple inheritance can be used only in the following cases:
+
+### <a name="a7-3-1"></a>Recommendation 7.3.1 Use multiple inheritance to implement interface separation and multi-role combination.
+If a class requires multiple interfaces, combine multiple separated interfaces by using multiple inheritance. This is similar to the Traits mixin of the Scala language.
+
+```cpp
+class Role1 {};
+class Role2 {};
+class Role3 {};
+
+class Object1 : public Role1, public Role2 {
+  // ...
+};
+
+class Object2 : public Role2, public Role3 {
+  // ...
+};
+
+```
+
+The C++ standard library has a similar implementation example:
+```cpp
+class basic_istream {};
+class basic_ostream {};
+
+class basic_iostream : public basic_istream, public basic_ostream {
+  
+};
+```
+
+## <a name="c7-4"></a>Overloading
+
+Overload operators should be used when there are sufficient reasons, and they do not change the original perception of the operators. For example, do not use the plus sign (+) to perform subtraction.
+Operator overloading can make code more intuitive but has some disadvantages:
+- It is often mistaken that the operation is as fast as a built-in operator, which has no performance degradation.
+- There is no naming to aid debugging. It is more convenient to search by function name than by operator.
+- Overloading operators can cause confusion if behavior definitions are not intuitive (for example, if the "+" operator is used for subtraction).
+- The implicit conversion caused by the overloading of assignment operators may lead to entrenched bugs. Functions such as Equals () and CopyFrom () can be defined to replace the = and == operators.
+
+
+
+# <a name="c8"></a> 8 Functions
+## <a name="c8-1"></a>Function Design
+### <a name="r8-1-1"></a>Recommendation 8.1.1 Avoid long functions and ensure that each function contains no more than 50 lines (non-null and non-comment).
+A function should be displayed on one screen (no longer than 50 lines). It should do only one thing, and do it well.
+
+Long functions often mean that the functions are too complex to implement more than one function, or overly detailed but not further abstracted.
+
+Exception: Some implementation algorithm functions may be longer than 50 lines due to algorithm convergence and functional comprehensiveness.
+
+Even if a long function works very well now, once someone modifies it, new problems may occur, even causing bugs that are difficult to discover.
+It is recommended that you split a long function into several functions that are simpler and easier to manage, facilitating code comprehension and modification.
+
+## <a name="c8-2"></a>Inline Functions
+
+###  <a name="a8-2-1"></a>Recommendation 8.2.1 An inline function cannot exceed 10 lines.
+**Note**: An inline function has the same characteristics of a normal function. The difference between an inline function and a normal function lies in the processing of function calls. When a general function is called, the program execution right is transferred to the called function, and then returned to the function that calls it. When an inline function is called, the invocation expression is replaced with an inline function body.
+
+Inline functions are only suitable for small functions with only 1-10 lines. For a large function that contains many statements, the function call and return overheads are relatively trivial and do not need to be implemented by an inline function. Most compilers may abandon the inline mode and use the common method to call the function.
+
+If an inline function contains complex control structures, such as loop, branch (switch), and try-catch statements, the compiler may regard the function as a common function.
+**Virtual functions and recursive functions cannot be used as inline functions**.
+
+## <a name="c8-3"></a>Function Parameters
+
+### <a name="a8-3-1"></a>Recommendation 8.3.1 Use a reference instead of a pointer for function parameters.
+
+**Note**: A reference is more secure than a pointer because it is not empty and does not point to other targets. Using a reference stops the need to check for illegal null pointers.
+
+Use const to avoid parameter modification, so that readers can clearly know that a parameter is not going to be modified. This greatly enhances code readability.
+
+### <a name="a8-3-2"></a>Recommendation 8.3.2 Use strongly typed parameters. Do not use void*.
+While different languages have their own views on strong typing and weak typing, it is generally believed that C/C++ is a strongly typed language. Since we use such a strongly typed language, we should keep this style.
+An advantage of this is the compiler can find type mismatch problems at the compilation stage.
+
+Using strong typing helps the compiler find more errors for us. Pay attention to the usage of the FooListAddNode function in the following code:
+```cpp
+struct FooNode {
+  struct List link;
+  int foo;
+};
+
+struct BarNode {
+  struct List link;
+  int bar;
+}
+
+void FooListAddNode(void *node) { // Bad: Here, the void * type is used to transfer parameters.
+  FooNode *foo = (FooNode *)node;
+  ListAppend(&fooList, &foo->link);
+}
+
+void MakeTheList() {
+  FooNode *foo = nullptr;
+  BarNode *bar = nullptr;
+  ...
+
+  FooListAddNode(bar);        // Wrong: In this example, the foo parameter was supposed to be transferred, but the bar parameter is accidentally transferred instead. However, no error is reported.
+}
+```
+
+1. You can use the template function to change the parameter type.
+2. A base class pointer can be used to implement polymorphism.
+
+### <a name="a8-3-3"></a>Recommendation 8.3.3 A function can have a maximum of five parameters.
+If a function has too many parameters, it is apt to be affected by external changes, and therefore maintenance is affected. Too many parameters will also increase the testing workload.
+
+If a function has more than five parameters, you can:
+- Split the function.
+- Combine related parameters into a struct.
+
+# <a name="c9"></a> 9 Other C++ Features
+
+## <a name="c9-1"></a>Constants and Initialization
+
+Unchanged values are easier to understand, trace, and analyze. Therefore, use constants instead of variables as much as possible. When defining values, use const as a default.
+
+### <a name="r9-1-1"></a>Recommendation 9.1.1 Do not use macros to replace constants.
+
+**Note**: Macros are a simple text replacement that is completed in the preprocessing phase. When an error is reported, the corresponding value is reported. During tracing and debugging, the value is also displayed instead of the macro name. A macro does not support type checking and is insecure. A macro has no scope.
+
+```cpp
+#define MAX_MSISDN_LEN 20    // Bad
+
+// Use the const constant in C++.
+const int kMaxMsisdnLen = 20; // Good
+
+// In versions later than C++ 11, constexpr can be used.
+constexpr int kMaxMsisdnLen = 20;
+```
+
+###  <a name="a9-1-2"></a>Recommendation 9.1.2 A group of related integer constants must be defined as an enumeration.
+
+**Note**: Enumerations are more secure than `#define` or `const int`. The compiler checks whether a parameter value is within the enumerated value range to avoid errors.
+
+```cpp
+// Good example:
+enum Week {
+  kSunday,
+  kMonday,
+  kTuesday,
+  kWednesday,
+  kThursday,
+  kFriday,
+  kSaturday
+};
+
+enum Color {
+  kRed,
+  kBlack,
+  kBlue
+};
+
+void ColorizeCalendar(Week today, Color color);
+
+ColorizeCalendar(kBlue, kSunday); // Compilation error. The parameter type is incorrect.
+
+// Bad example:
+const int kSunday = 0;
+const int kMonday = 1;
+
+const int kRed = 0;
+const int kBlack = 1;
+
+bool ColorizeCalendar(int today, int color);
+ColorizeCalendar(kBlue, kSunday); // No error is reported.
+```
+
+When an enumeration value needs to correspond to a specific value, explicit value assignment is required during declaration. Otherwise, do not assign explicit values. This will prevent repeated assignment and reduce the maintenance workload (when adding and deleting members).
+
+```cpp
+// Good example: Device ID defined in the S protocol. It is used to identify a device type.
+enum DeviceType {
+  kUnknown = -1,
+  kDsmp = 0,
+  kIsmg = 1,
+  kWapportal = 2
+};
+```
+
+
+
+### <a name="r9-1-3"></a>Recommendation 9.1.3 Magic numbers cannot be used.
+So-called magic numbers are the numbers that are unintelligible and difficult to understand.
+
+Some numbers can be understood based on context.
+For example, you may understand the number 12 in certain contexts.
+type = 12; is not intelligible (and a magic number), but `month = year * 12`; can be understood, so we wouldn't really class this as a magic number.
+The number 0 is often seen as a magic number. For example, `status = 0`; cannot truly express any status information.
+
+Solution:
+Comments can be added for numbers that are used locally.
+For the numbers that are used multiple times, you must define them as constants and give them descriptive names.
+
+The following cases are forbidden:
+No symbol is used to explain the meaning of a number, for example, `const int kZero = 0`.
+The symbol name limits the value. For example, in`const int kXxTimerInterval = 300`, Use `kXxTimerInterval` instead.
+
+### <a name="r9-1-1"></a>Rule 9.1.1 Ensure that a constant has only one responsibility.
+
+**Note**: A constant is used for only a specific function, that is, a constant cannot be used for multiple purposes.
+
+```cpp
+// Good example: For protocol A and protocol B, the length of the MSISDN is 20.
+const unsigned int kAMaxMsisdnLen = 20;
+const unsigned int kBMaxMsisdnLen = 20;
+
+// Or use different namespaces:
+namespace namespace1 {
+const unsigned int kMaxMsisdnLen = 20;
+}
+
+namespace namespace2 {
+const unsigned int kMaxMsisdnLen = 20;
+}
+```
+
+### <a name="r9-1-4"></a>Recommendation 9.1.4 Do not use memcpy_s or memset_s to initialize non-POD objects.
+
+**Note**: `POD` is short for `Plain Old Data`, which is a concept introduced in the C++ 98 standard (ISO/IEC 14882, first edition, 1998-09-01). The `POD` types include the original types and aggregate types such as `int`, `char`, `float`, `double`, `enumeration`, `void`, and pointer. Encapsulation and object-oriented features cannot be used (for example, user-defined constructors, assignment operators, destructors, base classes, and virtual functions).
+
+For non-POD classes, such as class objects of non-aggregate types, virtual functions may exist. Memory layout is uncertain, and is related to the compiler. Misuse of memory copies may cause serious problems.
+
+Even if a class of the aggregate type is directly copied and compared, and any functions hiding information or protecting data are destroyed, the `memcpy_s` and `memset_s` operations are not recommended.
+
+For details about the POD type, see the appendix.
+
+
+## <a name="c9-2"></a>Expressions
+
+### <a name="r9-2-2"></a>Rule 9.2.1 A switch statement must have a default branch.
+In most cases, a switch statement requires a default branch to ensure that there is a default action when the case tag is missing.
+
+Exception:
+If the switch condition variables are enumerated and the case branch covers all values, the default branch is redundant.
+Modern compilers can check which case branches are missing in the switch statement and provide an advanced warning. 
+
+```cpp
+enum Color {
+  kRed = 0,
+  kBlue
+};
+
+// The switch condition variables are enumerated. Therefore, you do not need to add a default branch.
+switch (color) {
+  case kRed:
+    DoRedThing();
+    break;
+  case kBlue:
+    DoBlueThing();
+    ...
+    break;
+}
+```
+
+### <a name="a9-2-1"></a>Recommendation 9.2.1 When comparing expressions, follow the principle that the left side tends to change and the right side tends to remain unchanged.
+When a variable is compared with a constant, placing the constant on the left, for example, if (MAX == v), does not comply with reading habits and if (MAX > v) is more difficult to understand.
+The constant should be placed on the right according to common reading and expression conventions. The expression is written as follows:
+```cpp
+if (value == MAX) {
+  
+}
+
+if (value < MAX) {
+  
+}
+```
+There are special cases: for example, if the expression `if (MIN < value && value < MAX)` is used to describe a range, the first half, as a constant, should be placed on the left.
+
+You do not need to worry about writing '==' as '=' because a compilation alarm will be generated for `if (value = MAX)` and an error will be reported by other static check tools. Use the tool to solve such writing errors and ensure that the code must be readable.
+
+
+## <a name="c9-3"></a>Type Casting
+
+Do not use type branches to customize behavior. Type branch customization behavior is prone to errors and is an obvious sign of attempting to compile C code using C++. This is very inflexible technology. If you forget to modify all branches when adding a new type to a compiler, you will not be notified. Use templates and virtual functions to let the type define itself rather than letting the calling side determine behavior.
+
+It is recommended that type casting be avoided. We should consider the data type of each type of data in the code design instead of overusing type casting to solve type conflicts. When designing a basic type, consider the following:
+- Whether it is unsigned or signed?
+- Is it suitable for float or double?
+- Should you use int8, int16, int32, or int64 bit lengths?
+
+However, we cannot prohibit the use of type casting because the C++ language is a machine-oriented programming language, involving pointer addresses, and we interact with various third-party or underlying APIs. Their type design may not be reasonable and type casting tends to occur in the adaptation process.
+
+Exception: When calling a function, if we do not want to process the result of the function, first consider whether this is your best choice. If you do not want to process the return value of the function, cast it to void.
+
+### <a name="r9-3-1"></a>Rule 9.3.1 If type casting is required, use the type casting provided by the C++ instead of the C style.
+
+**Note**:
+
+The type casting provided by C++ is more targeted, easy to read, and more secure than the C style. C++ provides the following types of casting:
+- Type casting:
+1. `dynamic_cast`: It is used to inherit the downstream transformation of the system. `dynamic_cast` has the type check function. Design the base class and derived class to avoid using dynamic_cast for casting.
+2. `static_cast`: It is similar to the C style casting, which can be used to convert a value, or to convert the pointer or reference of a derived class into a base class pointer or reference. This casting is often used to eliminate type ambiguity brought on by multiple inheritance, which is relatively safe. If it is a pure arithmetic conversion, use the braces as stated in the following text.
+3. `reinterpret_cast`: It is used to convert irrelevant types. `reinterpret_cast` forces the compiler to reinterpret the memory of a certain type of objects into another type, which is an unsafe conversion. It is recommended that `reinterpret_cast` be used as little as possible.
+4. `const_cast`: It is used to remove the `const` attribute of an object so that the object can be modified. It is recommended that `const_cast` be used as little as possible.
+
+- Arithmetic conversion: (Supported by C++ 11 and later versions)
+  If the type information is not lost, for example, the casting from float to double, or from int32 to int64, the initial mode of braces is recommended.
+```cpp
+  double d{ someFloat };
+  int64_t i{ someInt32 };
+```
+
+### <a name="a9-3-1"></a>Recommendation 9.3.1 Avoid using `dynamic_cast`.
+1. `dynamic_cast` depends on the RTTI of C++ so that the programmer can identify the type of the object in C++ at run time.
+2. `dynamic_cast` indicates that a problem occurs in the design of the base class and derived class. The derived class destroys the contract of the base class and it is necessary to use `dynamic_cast` to convert the class to a subclass for special processing. In this case, it is more desirable to improve the design of the class, instead of using `dynamic_cast` to solve the problem.
+
+### <a name="a9-3-2"></a>Recommendation 9.3.2 Avoid using `reinterpret_cast`.
+
+**Note**: `reinterpret_cast` is used to convert irrelevant types. Trying to use `reinterpret_cast` to force a type to another type destroys the security and reliability of the type and is an insecure casting method. Avoid casting between different types.
+
+### <a name="a9-3-3"></a>Recommendation 9.3.3 Avoid using `const_cast`.
+
+**Note**: The `const_cast` command is used to remove the `const` and `volatile` properties of an object.
+
+The action of using a pointer or reference after the const_cast conversion to modify the const property of an object is undefined.
+
+```cpp
+// Bad example:
+const int i = 1024; 
+int* p = const_cast<int*>(&i);
+*p = 2048;      // The action is undefined.
+```
+
+```cpp
+// Bad example:
+class Foo {
+ public:
+  Foo() : i(3) {}
+
+  void Fun(int v) {
+    i = v;
+  }
+
+ private:
+  int i;
+};
+
+int main(void) {
+  const Foo f;
+  Foo* p = const_cast<Foo*>(&f);
+  p->Fun(8);  // The action is undefined.
+}
+
+```
+
+
+## <a name="c9-4"></a>Resource Allocation and Release
+
+### <a name="r9-4-1"></a>Rule 9.4.1 When a single object is released, delete is used. When an array object is released, delete [] is used.
+Note: Delete is used to delete a single object, and delete [] is used to delete an array object. Reason:
+
+- new: Apply for memory from the system and call the corresponding constructor to initialize an object.
+- new[n]: Apply for memory for n objects and call the constructor n times for each object to initialize them.
+- delete: Call the corresponding destructor first and release the memory of an object.
+- delete[]: Call the corresponding destructor for each object and release their memory.
+
+If the usage of new and delete does not match this format, the results are unknown. For a non-class type, new and delete will not call the constructor or destructor.
+
+The incorrect format is as follows:
+```cpp
+const int KMaxArraySize = 100;
+int* numberArray = new int[KMaxArraySize];
+...
+delete numberArray;
+numberArray = NULL;
+```
+
+The correct format is as follows:
+```cpp
+const int KMaxArraySize = 100;
+int* numberArray = new int[KMaxArraySize];
+...
+delete[] numberArray;
+numberArray = NULL;
+```
+
+## <a name="c9-5"></a>Standard Template Library
+
+The standard template library (STL) varies between modules. The following table lists some basic rules and suggestions.
+
+### <a name="r9-5-1"></a>Rule 9.5.1 Do not save the pointer returned by c_str () of std::string.
+
+Note: The C++ standard does not specify that the string::c_str () pointer is permanently valid. Therefore, the STL implementation used can return a temporary storage area and release it quickly when calling string::c_str (). Therefore, to ensure the portability of the program, do not save the result of string::c_str (). Instead, call it directly.
+
+Example:
+
+```cpp
+void Fun1() {
+  std::string name = "demo";
+  const char* text = name.c_str(); // After the expression ends, the life cycle of name is still in use and the pointer is valid.
+
+  // If a non-const member function (such as operator[] and begin()) of the string type is invoked and the string is therefore modified,
+  // the text content may become unavailable or may not be the original character string.
+  name = "test";
+  name[1] = '2';
+
+  // When the text pointer is used next time, the string is no longer "demo".
+}
+
+void Fun2() {
+  std::string name = "demo";
+  std::string test = "test";
+  const char* text = (name + test).c_str(); // After the expression ends, the temporary object generated by the + operator may be destroyed, and the pointer may be invalid.
+
+    // When the text pointer is used next time, it no longer points to the valid memory space.
+}
+```
+Exception: In rare cases where high performance coding is required , you can temporarily save the pointer returned by string::c_str() to match the existing functions which support only the input parameters of the const char* type. However, you should ensure that the life cycle of the string object is longer than that of the saved pointer, and that the string object is not modified within the life cycle of the saved pointer.
+
+
+### <a name="a9-5-1"></a>Recommendation 9.5.1 Use std::string instead of char*.
+
+Note: Using string instead of `char*` has the following advantages:
+1. There is no need to consider the null character '\0' at the end.
+2. You can directly use operators such as +, =, and ==, and other character string operation functions.
+3. No need to consider memory allocation operations. This helps avoid explicit usage of new and delete and the resulting errors.
+
+Note that in some STL implementations, string is based on the copy-on-write policy, which causes two problems. One is that the copy-on-write policy of some versions does not implement thread security, and the program breaks down in multi-threaded environments. Second, dangling pointers may be caused when a dynamic link library transfers the string based on the copy-on-write policy, due to the fact that reference count cannot be reduced when the library is unloaded. Therefore, it is important to select a reliable STL implementation to ensure the stability of the program.
+
+Exceptions:
+When an API of a system or other third-party libraries is called, only `char*` can be used for defined interfaces. However, before calling the interfaces, you can use string. When calling the interfaces, you can use string::c_str () to obtain the character pointer.
+When a character array is allocated as a buffer on the stack, you can directly define the character array without using string or containers such as `vector<char>`.
+
+### <a name="r9-5-2"></a>Rule 9.5.2 Do not use auto_ptr.
+Note: The std::auto_ptr in the STL library has an implicit ownership transfer behavior. The code is as follows:
+```cpp
+auto_ptr<T> p1(new T);
+auto_ptr<T> p2 = p1;
+```
+After the second line of statements is executed, p1 does not point to the object allocated in line 1 and becomes NULL. Therefore, auto_ptr cannot be placed in any standard containers.
+This ownership transfer behavior is not expected. In scenarios where ownership must be transferred, implicit transfer should not be used. This often requires the programmer to keep extra attention on code that uses auto_ptr , otherwise access to a null pointer will occur.
+There are two common scenarios for using auto_ptr . One is to transfer it as a smart pointer to outside of the function that generates the auto_ptr , and the other is to use auto_ptr as the RAII management class. Resources are automatically released when the lifecycle of auto_ptr expires.
+In the first scenario, you can use std::shared_ptr instead.
+In the second scenario, you can use std::unique_ptr in the C++ 11 standard. std::unique_ptr is a substitute for std::auto_ptr and supports explicit ownership transfer.
+
+Exceptions:
+Before the C++ 11 standard is widely used, std::auto_ptr can be used in scenarios where ownership needs to be transferred. However, it is recommended that std::auto_ptr be encapsulated. The copy constructor and assignment operator of the encapsulation class should not be used, so that the encapsulation class cannot be used in a standard container.
+
+
+### <a name="a9-5-2"></a>Recommendation 9.5.2 Use the new standard header files.
+
+Note:
+When using the standard header file of C++, use `<cstdlib>` instead of `<stdlib.h>`.
+
+## <a name="c9-6"></a>Usage of const
+Add the keyword const before the declared variable or parameter (example: `const int foo`) to prevent the variable from being tampered with. Add the const qualifier to the function in the class (example: `class Foo {int Bar (char c) const;} ;`) to make sure the function does not modify the status of the class member variable. const variables, data members, functions, and parameters ensure that the type detection during compilation is accurate and errors are found as soon as possible. Therefore, we strongly recommend that const be used in any possible case.
+Sometimes it is better to use constexpr of C++ 11 to define real constants.
+
+### <a name="r9-6-1"></a>Rule 9.6.1 For formal parameters of pointer and reference types, if the parameters do not need to be modified, use const.
+Unchanged values are easier to understand, trace, and analyze. const is used as the default option and is checked during compilation to make the code more secure and reliable.
+```cpp
+class Foo;
+
+void PrintFoo(const Foo& foo);
+```
+
+### <a name="r9-6-2"></a>Rule 9.6.2 For member functions that do not modify member variables, use const.
+Declare the member function as const whenever possible. The access function should always be const. So long as the function of a member is not modified, the function is declared with const.
+
+```cpp
+class Foo {
+ public:
+
+  // ...
+
+  int PrintValue() const // const’s usage here modifies member functions and does not modify member variables.
+    std::cout << value << std::endl;
+  }
+
+  int GetValue() const // and again here.
+    return value;
+  }
+
+ private:
+  int value;
+};
+```
+
+### <a name="a9-6-1"></a>Recommendation 9.6.1 Member variables that will not be modified after initialization should be defined as constants.
+
+```cpp
+class Foo {
+ public:
+  Foo(int length) : dataLength(length) {}
+ private:
+  const int dataLength;  
+};
+```
+
+## <a name="c9-7"></a>Templates
+
+Template programming allows for extremely flexible interfaces that are type safe and high performance, enabling reuse of code of different types but with the same behavior.
+
+The disadvantages of template programming are as follows:
+
+1. The techniques used in template programming are often obscure to anyone but language experts. Code that uses templates in complicated ways is often unreadable, and is hard to debug or maintain.
+2. Template programming often leads to extremely poor compiler time error messages: even if an interface is simple, complicated implementation details become visible when the user does something wrong.
+3. If the template is not properly used, the code will be over expanded during runtime.
+4. It is difficult to modify or refactor the template code. The template code is expanded in multiple contexts, and it is hard to verify that the transformation makes sense in all of them.
+
+Therefore, it is recommended that __template programming be used only in a small number of basic components and basic data structure__. When using the template programming, minimize the __complexity as much as possible__, and __avoid exposing the template__. It is better to hide programming as an implementation detail whenever possible, so that user-facing headers are readable. And you should write sufficiently detailed comments for code that uses templates.
+
+
+## <a name="c9-8"></a>Macros
+In the C++ language, it is strongly recommended that complex macros be used as little as possible.
+- For constant definitions, use `const` or `enum` as stated in the preceding sections. 
+- For macro functions, try to be as simple as possible, comply with the following principles, and use inline functions and template functions for replacement.
+
+```cpp
+// The macro function is not recommended.
+#define SQUARE(a, b) ((a) * (b)) 
+
+// Use the template function and inline function as a replacement.
+template<typename T> T Square(T a, T b) { return a * b; }
+```
+
+For details about how to use macros, see the related chapters about the C language specifications.
+**Exception**: For some common and mature applications, for example, encapsulation for new and delete, the use of macros can be retained.
+
+
+## <a name="c9-9"></a>Others
+
+### <a name="a9-9-1"></a>Recommendation 9.9.1 Use '\n' instead of std::endl when exporting objects to a file.
+Note: std::endl flushes content in the buffer to a file, which may affect the performance.
+
+# <a name="c10"></a>10 Modern C++ Features
+
+As the ISO released the C++ 11 language standard in 2011 and released the C++ 17 in March 2017, the modern C++ (C++ 11/14/17) adds a large number of new language features and standard libraries that improve programming efficiency and code quality.
+This chapter describes some guidelines for modern C++ use, to avoid language pitfalls.
+
+## <a name="c10-1"></a>Code Simplicity and Security Improvement
+### <a name="a10-1-1"></a>Recommendation 10.1.1 Use `auto` properly.
+
+
+* `auto` can help you avoid writing verbose, repeated type names, and can also ensure initialization when variables are defined.
+* The `auto` type deduction rules are complex and need to be read carefully.
+* If using `auto` makes the code clearer, use a specific type of it and use it only for local variables.
+
+**Example**
+
+```cpp
+// Avoid verbose type names.
+std::map<string, int>::iterator iter = m.find(val);
+auto iter = m.find(val);
+
+// Avoid duplicate type names.
+class Foo {...};
+Foo* p = new Foo;
+auto p = new Foo;
+
+// Ensure that the initialization is successful.
+int x;    // The compilation is correct but the variable is not initialized.
+auto x;   // The compilation failed. Initialization is needed.
+```
+
+`auto` type deduction may cause the following problems:
+
+```cpp
+auto a = 3;           // int
+const auto ca = a;    // const int
+const auto& ra = a;   // const int&
+auto aa = ca;         // int, const and reference are neglected.
+auto ila1 = { 10 };   // std::initializer_list<int>
+auto ila2{ 10 };      // std::initializer_list<int>
+
+auto&& ura1 = x;      // int&
+auto&& ura2 = ca;     // const int&
+auto&& ura3 = 10;     // int&&
+
+const int b[10];
+auto arr1 = b;        // const int*
+auto& arr2 = b;       // const int(&)[10]
+```
+
+If you do not pay attention to `auto` type deduction and ignore the reference, hard-to-find performance problems may be created.
+
+```cpp
+std::vector<std::string> v;
+auto s1 = v[0]; // auto deduction changes s1 to std::string in order to copy v[0].
+```
+
+If the `auto` is used to define an interface, such as a constant in the header file, it may be possible that the type has changed because the developer has modified the value.
+
+In a loop, consider using auto & and auto * to traverse complex objects to improve performance.
+
+```cpp
+for (auto &stmt : bb->GetStmtNodes()) {
+...
+}
+```
+
+### <a name="r10-1-1"></a>Rule 10.1.1 Use the keyword `override` when rewriting virtual functions.
+
+The keyword `override` ensures that the function is a virtual function and an overridden virtual function of the base class. If the subclass function is different from the base class function prototype, a compilation alarm is generated.
+
+If you modify the prototype of a base class virtual function but forget to modify the virtual function overridden by the subclass, you can find inconsistency during compilation. You can also avoid forgetting to modify the overridden function when there are multiple subclasses.
+
+**Example**
+
+```cpp
+class Base {
+ public:
+  virtual void Foo();
+  void Bar();
+};
+
+class Derived : public Base {
+ public:
+  void Foo() const override; // Compilation failed: derived::Foo is different from that of the prototype of base::Foo and is not overridden.
+  void Foo() override;       // Compilation successful: derived::Foo overrode base::Foo.
+  void Bar() override;       // Compilation failed: base::Bar is not a virtual function.
+};
+```
+
+**Summary**
+1. When defining the virtual function for the first time based on the base class, use the keyword `virtual`.
+2. When the subclass overrides the base class’ virtual function, use the keyword `virtual`.
+3. For the non-virtual function, do not use `virtual` or `override`.
+
+### <a name="r10-1-2"></a>Rule: 10.1.2 Use the keyword delete to `delete` functions.
+
+The `delete` keyword is clearer and the application scope is wider than a class member function that is declared as private and not implemented.
+
+**Example**
+
+```cpp
+class Foo {
+ private:
+  // Whether the copy structure is deleted or not is unknown because usually only the header file is checked.
+  Foo(const Foo&);
+};
+
+class Foo {
+ public:
+  // Explicitly delete the copy assignment operator.
+  Foo& operator=(const Foo&) = delete;
+};
+```
+
+The `delete` keyword can also be used to delete non-member functions.
+
+```cpp
+template<typename T>
+void Process(T value);
+
+template<>
+void Process<void>(void) = delete;
+```
+
+### <a name="r10-1-3"></a>Rule 10.1.3 Use `nullptr` instead of `NULL` or `0`.
+
+For a long time, C++ has not had a keyword that represents a null pointer, which is embarrassing:
+
+```cpp
+#define NULL ((void *)0)
+
+char* str = NULL;   // Error: void* cannot be automatically converted to char*.
+
+void(C::*pmf)() = &C::Func;
+if (pmf == NULL) {} // Error: void* cannot be automatically converted to the pointer that points to the member function.
+```
+
+If `NULL` is defined as `0` or `0L`, the above problems can be solved.
+
+Alternatively, use `0` directly in places where null pointers are required. However, another problem occurs. The code is not clear, especially when the `auto` is used for automatic deduction.
+
+```cpp
+auto result = Find(id);
+if (result == 0) {  // Does Find() return a pointer or an integer?
+  // do something
+}
+```
+
+Literally `0` is of the `int` type (`0L` is the `long` type). Therefore, neither `NULL` nor `0` is a pointer type.
+When a function of the pointer or integer type is overloaded, `NULL` or `0` calls only the overloaded pointer function.
+
+```cpp
+void F(int);
+void F(int*);
+
+F(0);      // Call F(int) instead of F(int*).
+F(NULL);   // Call F(int) instead of F(int*).
+```
+
+In addition, `sizeof(NULL) == sizeof(void*)` does not always make sense, which is a potential risk.
+
+Summary: If `0` or `0L` is directly used, the code is not clear and type security cannot be ensured. If `NULL` is used, the type security cannot be ensured. These are all potential risks.
+
+`nullptr` has many advantages. It literally represents the null pointer and makes the code clearer. More to the point, it is no longer an integer type.
+
+`nullptr` is of the `std::nullptr_t` type. `std::nullptr_t` can be implicitly converted into all original pointer types, so that `nullptr` can represent a null pointer that points to any type.
+
+```cpp
+void F(int);
+void F(int*);
+F(nullptr);   // Call F(int*).
+
+auto result = Find(id);
+if (result == nullptr) {  // Find() returns a pointer.
+  // do something
+}
+```
+
+### <a name="r10-1-2"></a>Recommendation 10.1.2 Use `using` instead of `typedef`.
+For versions earlier than `C++11`, you can define the alias of the type by using `typedef`. No one wants to repeat code like `std::map<uint32_t, std::vector<int>>`.
+
+```cpp
+typedef std::map<uint32_t, std::vector<int>> SomeType;
+```
+
+Using alias for the type is actually encapsulating the type. This encapsulation makes the code clearer, and to a large extent avoids the bulk modification caused by the type change.
+For versions later than `C++ 11`, `using` is provided to implement `alias declarations`:
+
+```cpp
+using SomeType = std::map<uint32_t, std::vector<int>>;
+```
+
+Compare the two formats:
+
+```cpp
+typedef Type Alias;   // It cannot be told whether Type or Alias is at the front.
+using Alias = Type;   // The format confirms to the assignment rule. It is easy to understand and helps reduce errors.
+```
+
+If this is not enough to prove the advantages of `using`, the alias template may be a better example:
+
+```cpp
+//: Only one line of code is need to define an alias for a template.
+template<class T>
+using MyAllocatorVector = std::vector<T, MyAllocator<T>>;
+
+MyAllocatorVector<int> data;       // An alias for a template defined with "using".
+
+template<class T>
+class MyClass {
+ private:
+  MyAllocatorVector<int> data_;   // Another.
+};
+```
+
+`typedef` does not support alias templates and they have to be hacked in.
+
+```cpp
+// A template is used for packaging typedef. Therefore, a template class is needed.
+template<class T>
+struct MyAllocatorVector {
+  typedef std::vector<T, MyAllocator<T>> type;
+};
+
+MyAllocatorVector<int>::type data;  // ::type needs to be added when using typedef to define an alias.
+
+template<class T>
+class MyClass {
+ private:
+  typename MyAllocatorVector<int>::type data_;  // For a template class, typename is also needed in addition to ::type.
+};
+```
+
+### <a name="r10-1-4"></a>Rule 10.1.4 Do not use std::move to operate the const object.
+Literally, `std::move` means moving an object. The const object cannot be modified and cannot be moved. Therefore, using `std::move` to operate the const object may confuse code readers.
+Regarding actual functions, `std::move` converts an object to the rvalue reference type. It can convert the const object to the rvalue reference of const. Because few types define the move constructor and the move assignment operator that use the const rvalue reference as the parameter, the actual function of code is often degraded to object copy instead of object movement, which brings performance loss.
+
+**Bad example:**
+```cpp
+std::string gString;
+std::vector<std::string> gStringList;
+
+void func() {
+  const std::string myString = "String content";
+  gString = std::move(myString); // Bad: myString is not moved. Instead, it is copied.
+  const std::string anotherString = "Another string content";
+  gStringList.push_back(std::move(anotherString));    // Bad: anotherString is not moved. Instead, it is copied.
+}
+```
+
+## <a name="c10-2"></a>Smart Pointers
+### <a name="r10-2-1"></a>Recommendation 10.2.1 Preferentially use the smart pointer instead of the raw pointer to manage resources.
+
+Avoid resource leakage.
+
+**Example**:
+
+```cpp
+void Use(int i) {
+  auto p = new int {7};               // Bad: Initializing local pointers with new.
+  auto q = std::make_unique<int>(9);  // Good: Guarantee that memory is released.
+  if (i > 0) {
+    return;                           // Return and possible leak.
+  }
+  delete p;                           // Too late to salvage.
+}
+```
+
+**Exception:**
+Raw pointers can be used in scenarios such as performance sensitivity and compatibility.
+
+### <a name="r10-2-1"></a>Rule 10.2.1 Use `unique_ptr` instead of `shared_ptr`.
+
+1. Using `shared_ptr` a lot has an overhead (atomic operations on the `shared_ptr`s reference count have a measurable cost).
+2. Shared ownership in some cases (such as circular dependency) may create objects that can never be released.
+3. Shared ownership can be an attractive alternative to careful ownership design but it may obfuscate the design of a system.
+
+### <a name="r10-2-2"></a>Rule 10.2.2 Use `std::make_unique` instead of `new` to create `unique_ptr`.
+
+1. `make_uniqe` provides a simpler creation method.
+2. `make_uniqe` ensures the exception safety of complex expressions.
+
+**Example**
+
+```cpp
+// Bad: MyClass appears twice, which carries a risk of inconsistency.
+std::unique_ptr<MyClass> ptr(new MyClass(0, 1));
+// Good: MyClass appears once and there is no possibility of inconsistency.
+auto ptr = std::make_unique<MyClass>(0, 1);
+```
+
+Recurrence of types may cause serious problems, and it is difficult to find them:
+
+```cpp
+// The code compiles fine, but new and delete usage does not match.
+std::unique_ptr<uint8_t> ptr(new uint8_t[10]);
+std::unique_ptr<uint8_t[]> ptr(new uint8_t);
+// No exception safety: The compiler may calculate parameters in the following order:
+// 1. Allocate the memory of Foo.
+// 2. Construct Foo.
+// 3. Call Bar.
+// 4. Construct unique_ptr<Foo>.
+// If Bar throws an exception, Foo is not destroyed and a memory leak occurs.
+F(unique_ptr<Foo>(new Foo()), Bar());
+
+// Exception safety: Calling of function is not interrupted.
+F(make_unique<Foo>(), Bar());
+```
+
+**Exception:**
+`std::make_unique` does not support user-defined `deleter`.
+In the scenario where the `deleter` needs to be customized, it is recommended that `make_unique` of the customized version be implemented in its own namespace.
+`Using `new` to create `unique_ptr` with the user-defined `deleter` is the last choice.
+
+### <a name="r10-2-3"></a>Rule 10.2.3 Create `shared_ptr` by using `std::make_shared` instead of `new`.
+
+In addition to the consistency factor similar to that in `std::make_unique` when using `std::make_shared`, performance is also a factor to consider.
+`std::shared_ptr` manages two entities:
+* Control block (storing reference count, `deleter`, etc.)
+Managed objects
+
+When `std::make_shared` creates `std::shared_ptr`, it allocates sufficient memory for storing control blocks and managed objects on the heap at a time. When `std::shared_ptr<MyClass>(new MyClass)`is used to create `std::shared_ptr`, except that `new MyClass` triggers a heap allocation, the constructor function of `std::shard_ptr` triggers the second heap allocation, resulting in extra overhead.
+
+**Exception:**
+Similar to `std::make_unique`, `std::make_shared` does not support `deleter` customization.
+
+## <a name="c10-3"></a>Lambda
+### <a name="a10-3-1"></a>Recommendation 10.3.1 Use `lambda` to capture local variables or write local functions when normal functions do not work.
+
+Functions cannot capture local variables or be declared at local scope. If you need those things, choose `lambda` instead of handwritten `functor`.
+On the other hand, `lambda` and `functor` objects do not overload. If overload is required, use a function.
+If both `lambda` and functions work, a function is preferred. Use the simplest tool.
+
+**Example**
+
+```cpp
+// Write a function that accepts only an int or string.
+// -- Overloading is natural.
+void F(int);
+void F(const string&);
+
+// The local state needs to be captured or appear in the statement or expression range.
+// -- A lambda is natural.
+vector<Work> v = LotsOfWork();
+for (int taskNum = 0; taskNum < max; ++taskNum) {
+  pool.Run([=, &v] {...});
+}
+pool.Join();
+```
+
+### <a name="r10-3-2"></a>Rule 10.3.1 Avoid capturing by reference in lambdas that will be used nonlocally.
+
+When used in non-local scope, `lambdas` includes returned values which are stored on the heap, or passed to other threads. Local pointers and references should not outlive their scope. Capturing by reference in `lambdas` indicates storing a reference to a local object. If this leads to a reference that exceeds the local variable lifecycle, capturing by reference should not be used.
+
+**Example**
+
+```cpp
+// Bad
+void Foo() {
+  int local = 42;
+  // Capture a reference to a local variable.
+  // After the function returns results, local no longer exists,
+  // Process() call will have undefined behavior.
+  threadPool.QueueWork([&]{ Process(local); });
+}
+
+Good
+void Foo() {
+  int local = 42;
+  // Capture a copy of local.
+  // Since a copy of local is made, it will be always available for the call.
+  threadPool.QueueWork([=]{ Process(local); });
+}
+```
+
+### <a name="a10-3-2"></a>Recommendation 10.3.2 All variables are explicitly captured if `this` is captured.
+
+The `[=]` in the member function seems to indicate capturing by value but actually it is capturing data members by reference because it captures the invisible `this` pointer by value. Generally, it is recommended that capturing by reference be avoided. If it is necessary to do so, write `this` explicitly.
+
+**Example**
+
+```cpp
+class MyClass {
+ public:
+  void Foo() {
+    int i = 0;
+
+    auto Lambda = [=]() { Use(i, data_); };   // Bad: It looks like coping or capturing by value but member variables are actually captured by reference.
+
+    data_ = 42;
+    Lambda(); // Call use(42);
+    data_ = 43;
+    Lambda(); // Call use(43);
+
+    auto Lambda2 = [i, this]() { Use(i, data_); }; // Good: the most explicit and least confusing method.
+  }
+
+ private:
+  int data_ = 0;
+};
+```
+
+### <a name="a10-3-3"></a>Recommendation 10.3.3 Avoid default capture modes.
+
+The lambda expression provides two default capture modes: by-reference (&) and by-value (=).
+By default, the "by-reference" capture mode will implicitly capture the reference of all local variables, which will easily lead to dangling references. By contrast, explicitly writing variables that need to be captured can make it easier to check the life cycle of an object and reduce the possibility of making a mistake
+By default, the "by-value” capture mode will implicitly capture this pointer, and it is difficult to find out which variables the lambda function depends on. If a static variable exists, the reader mistakenly considers that the lambda has copied a static variable.
+Therefore, it is required to clearly state the variables that lambda needs to capture, instead of using the default capture mode.
+
+**Bad example:**
+```cpp
+auto func() {
+  int addend = 5;
+  static int baseValue = 3;
+
+  return [=]() {    // Only addend is actually copied.
+    ++baseValue;    // The modification will affect the value of the static variable.
+    return baseValue + addend;
+  };
+}
+```
+
+**Good example:**
+```cpp
+auto func() {
+  int addend = 5;
+  static int baseValue = 3;
+
+  return [addend, baseValue = baseValue]() mutable {  // Uses the C++14 capture initialization to copy a variable.
+    ++baseValue;    // Modifying the copy of a static variable does not affect the value of the static variable.
+    return baseValue + addend;
+  };
+}
+```
+
+Reference: Effective Modern C++: Item 31: Avoid default capture modes.
+
+## <a name="c10-4"></a>Interfaces
+### <a name="a10-4-1"></a>Recommendation 10.4.1 Use `T*` or `T&` arguments instead of a smart pointer in scenarios where ownership is not involved.
+
+1. Passing a smart pointer to transfer or share ownership should only be used when the ownership mechanism is explicitly required.
+2. Passing a smart pointer (for example, passing the `this` smart pointer) restricts the use of a function to callers using smart pointers.
+3. Passing a shared smart pointer adds a runtime performance cost.
+
+**Example**:
+
+```cpp
+// Accept any int*.
+void F(int*);
+
+// Accept only integers for which you want to transfer ownership.
+void G(unique_ptr<int>);
+
+// Accept only integers for which you want to share ownership.
+void G(shared_ptr<int>);
+
+// Does not need to change the ownership but requires ownership of the caller.
+void H(const unique_ptr<int>&);
+
+// Accept any int.
+void H(int&);
+
+//Bad example
+void F(shared_ptr<Widget>& w) {
+  // ...
+  Use(*w); // When only w is used, lifecycle management is not required.
+  // ...
+};
+```
+
+
+# <a name="c11"></a> 11 Secure Coding Standard
+
+## <a name="c11-1"></a>Basic Principles
+
+1. Programs must strictly verify external data. During external data processing, programmers must keep this in mind and not make any assumption that external data meets expectations. External data must be strictly checked before being used.
+ Programmers must abide by this principle in the complex attack environment to ensure that the program execution process is in line with expected results.
+
+2. The attack surface of code must be minimized. The code implementation should be as simple as possible to avoid unnecessary data exchange with external environments. Excess attack surfaces will increase the attack probability. Therefore, avoid exposing internal data processing of programs to external environments.
+
+3. Defensive coding strategies must be used to compensate for potential negligence of programmers. Every man is liable to error. Due to uncertainties of external environments and the differences in the experience and habits of programmers, it is hard for the code execution process to fully meet expectations.
+ Therefore, defensive strategies must be adopted in the coding process to minimize the defects caused by the negligence of programmers.
+ The measures include:
+
+- Defining an initial value for the declaration of variables.
+- Exercise caution in using global variables.
+- Avoid using complex and error-prone functions.
+- Do not use error-prone mechanisms of compilers/operating systems.
+- Deal with the resource access process carefully.
+- Do not change the runtime environment of the operating system. For example, do not create temporary files, modify environment variables, or create processes.
+- Rectify errors strictly.
+- Use the debugging assertion (ASSERT) properly.
+
+## <a name="c11-2"></a>Variables
+
+### <a name="r11-2-1"></a>Rule 11.2.1: Define an initial value for the declaration of pointer variables, variables indicating resource descriptors, or BOOL variables.
+
+Note: Defining an initial value for the declaration of variables can prevent programmers from referencing uninitialized variables.
+
+Good example:
+
+```cpp
+SOCKET s = INVALID_SOCKET;
+unsigned char *msg = nullptr;
+int fd = -1;
+```
+
+Bad example: In the following code, no initial value is defined for the declaration of variables. As a result, an error occurs in the free step.
+
+```cpp
+char *message; // Error! char *message = nullptr; is required.
+
+if (condition) {
+  message = (char *)malloc(len);
+}
+
+if (message != nullptr) {
+  free(message); //If the condition is not met, the uninitialized memory will be freed.
+}
+```
+
+### <a name="r11-2-2"></a>Rule 11.2.2: Assign a new value to the variable pointing to a resource handle or descriptor immediately after the resource is freed.
+
+Note: After a resource is freed, a new value must be immediately assigned to the corresponding variable to prevent the re-reference of the variable. If the release statement is in the last line of the scope, you do not need to assign a new value.
+
+Good example:
+
+```cpp
+SOCKET s = INVALID_SOCKET;
+...
+closesocket(s);
+s = INVALID_SOCKET;
+
+unsigned char *msg = nullptr;
+...
+free(msg);
+msg = nullptr;
+```
+
+### <a name="r11-2-3"></a>Rule 11.2.3: Ensure that local variables in a function do not take up too much space.
+
+When a program is running, the local variables in the function are stored in the stack, and the stack size is limited. If a large static array is requested, an error may occur.
+ It is recommended that the size of the static array not exceed 0x1000.
+
+In the following code, buff requests a large stack but the stack space is insufficient. As a result, stack overflow occurs in the program.
+
+```c++
+constexpr int MAX_BUF = 0x1000000;
+int Foo() {
+    char buff[MAX_BUFF] = {0}; // Bad
+    ...
+}
+```
+
+## <a name="c11-3"></a>Assertions
+
+### Principles
+
+Assertions in code consist of ASSERT and CHECK_FATAL. ASSERT is used to determine conditions in DEBUG mode. If conditions are not met, the program exits directly. CHECK_FATAL is used to detect exceptions during program running. If the conditions are not met, the program exits.
+
+CHECK_FATAL is applicable to scenarios where the input and resource application are not under control. Example:
+
+```cpp
+CHECK_FATAL(mplName.rfind(kMplSuffix) != std::string::npos, "File name %s does not contain .mpl", mplName.c_str()); // The file name does not meet the requirements.
+
+CHECK_FATAL(intrinCall->GetReturnVec().size() == 1, "INTRN_JAVA_FILL_NEW_ARRAY should have 1 return value"); // The logic restriction is not met.
+
+CHECK_FATAL(func->GetParamSize() <= 0xffff, "Error:the argsize is too large"); // The validity is verified.
+
+void *MemPool::Malloc(size_t size) {
+  ...
+  CHECK_FATAL(b != nullptr, "ERROR: Malloc error"); // Failed to apply for memory.
+}
+```
+
+ASSERT is applicable to scenarios where you want to locate bugs in the defensive programming mode. Example:
+
+```cpp
+ASSERT(false, "should not be here");
+
+ASSERT(false, "Unknown opcode for FoldIntConstComparison");
+```
+
+### <a name="a11-3-1"></a>Recommendation 11.3.1 Do not use ASSERT to verify whether a pointer with security context is nullptr.
+
+Note: The compiler is an offline compilation tool. The impact of process breakdown is much less than that of online services. Therefore, the defensive programming mode should be reduced. Not all input parameters require null pointer verification. Instead, the context logic is used to determine whether null pointer verification is required. An input parameter without the nullptr logic does not need to be verified. For details, see the assertion usage principles.
+
+### <a name="a11-3-2"></a>Recommendation 11.3.2 Do not use ASSERT to verify whether a data array with security context exceeds the threshold.
+
+Note: Similar to the null pointer rule, the context logic is used to determine whether to use assertions for out-of-threshold array verification. For details, see the assertion usage principles.
+
+### <a name="a11-3-3"></a>Recommendation 11.3.3 Do not use ASSERT to verify integer overflow, truncation, or wraparound in the case of context security.
+
+Note: In terms of integer overflow caused by addition or multiplication, verification is not required with the context logic guaranteed. In terms of integer truncation and wraparound caused by type conversion, verification is not required with the context logic guaranteed. For details, see the assertion usage principles.
+
+To ensure that fault tolerance and logic continue to run, you can use conditional statements for verification.
+
+### <a name="r11-3-1"></a>Rule 11.3.1 Do not use ASSERT to verify errors that may occur during program runtime.
+
+Bad example:
+
+```cpp
+FILE *fp = fopen(path, "r");
+ASSERT(fp != nullptr, "nullptr check"); //Incorrect code: Opening the file may fail.
+
+char *str = (char *)malloc(MAX_LINE);
+ASSERT(str != nullptr, "nullptr check"); //Incorrect code: Memory allocation may fail.
+ReadLine(fp, str);
+```
+
+### <a name="r11-3-2"></a>Rule 11.3.2 Do not modify the runtime environment in ASSERT.
+
+Note: In the formal release stage of a program, ASSERT is not compiled. To ensure the function consistency between the debugging version and formal version, do not perform any operation, such as value assignment, variable modification, resource operation, or memory application, in ASSERT.
+
+
+In the following code, ASSERT configuration is incorrect.
+
+```cpp
+ASSERT(i++ > 1000); // p1 is modified.
+ASSERT(close(fd) == 0); // fd is closed.
+```
+
+## <a name="c11-4"></a>Exception Mechanisms
+
+### <a name="r11-4-1"></a>Rule 11.4.1 Do not use the C++ exception mechanism.
+
+Note: Do not use the exception mechanism of C++. All errors must be transferred between functions and judged using error values, but not be handled using the exception mechanism.
+
+Programmers must fully control the entire coding process, build the attacker mindset, enhance secure coding awareness, and attach importance to procedures with potential errors. Using the C++ exception mechanism to handle errors, however, will weaken the security awareness of programmers because it will:
+
+Disrupt program execution, making the program structure more complex and used resources not cleared.
+
+Reduce the reusability of code. The code that uses the exception mechanism cannot be reused by the code that does not use the exception mechanism.
+
+Depend on the compiler, operating system, and processor. The execution performance of the program will deteriorate if the exception mechanism is used.
+
+Increase the attack surface of a program in the binary layer after the program is loaded. The attacker can overwrite the abnormal processing function address to launch an attack.
+
+
+## <a name="c11-5"></a>Memory
+
+### <a name="r11-5-1"></a>Rule 11.5.1: Verify the requested memory size before requesting memory.
+
+The requested memory size may come from external data and must be verified to prevent memory abuse. The requested memory size must not be 0.
+Example:
+```cpp
+int Foo(int size) {
+  if (size <= 0) {
+    //error
+    ...
+  }
+  ...
+  char *msg = (char *)malloc(size);
+  ...
+}
+```
+
+### <a name="r11-5-2"></a>Rule 11.5.2: Check whether memory allocation is successful.
+
+```cpp
+char *msg = (char *)malloc(size);
+if (msg != nullptr) {
+  ...
+}
+```
+
+## <a name="c11-6"></a>Dangerous Functions
+
+### <a name="r11-6-1"></a>Rule 11.6.1: Do not use dangerous functions related to memory operations.
+Many C functions do not use the destination buffer size as a parameter or consider memory overlapping and invalid pointers. As a result, security vulnerabilities such as buffer overflow may be caused.
+
+The historical statistics about buffer overflow vulnerabilities show that a majority of the vulnerabilities are caused by memory operation functions that do not consider the destination buffer size.
+The following lists the dangerous functions related to memory operations:
+
+Memory copy functions: memcpy(), wmemcpy(), memmove(), wmemmove()
+
+Memory initialization function: memset()
+
+String copy functions: strcpy(), wcscpy(),strncpy(), wcsncpy()
+
+String concatenation functions: strcat(), wcscat(),strncat(), wcsncat()
+
+Formatted string output functions: sprintf(), swprintf(), vsprintf(), vswprintf(), snprintf(), vsnprintf()
+
+Formatted string input functions: scanf(), wscanf(), vscanf(), vwscanf(), fscanf(),fwscanf(),vfscanf(),vfwscanf(),sscanf(), swscanf(), vsscanf(), vswscanf() 
+
+stdin stream-input function: gets() 
+Use safe functions. For details, see huawei_secure_c.
+
+Exceptions: In the following cases, external data processing is not involved, and no attack risks exist. Memory operations are complete in this function, and there is no possibility of failure.
+Using safe functions causes redundant code, and therefore dangerous functions can be used in these cases.
+
+(1) Initialize a fixed-length array, or initialize the memory of the structure with a fixed length:
+```cpp
+BYTE array[ARRAY_SIZE];
+
+void Foo() {
+  char destBuff[BUFF_SIZE];
+  ...
+  memset(array, c1, sizeof(array)); //Assign values to global fixed-length data.
+  ...
+  memset(destBuff, c2, sizeof(destBuff)); //Assign values to partial fixed-length data.
+  ...
+}
+
+typedef struct {
+  int type;
+  int data;
+} Tag;
+
+Tag g_tag = {1, 2};
+
+void Foo() {
+  Tag dest;
+  ...
+  memcpy((void *)&dest, (const void *)&g_tag, sizeof(Tag)); //Assign values to fixed-length structure.
+  ...
+}
+```
+
+(2) Initialize memory if function parameters include memory parameters.
+```cpp
+void Foo(BYTE *buff1, size_t len1, BYTE *buff2, size_t len2) {
+  ...
+  memset(buff1, 0, len1); //Clear buff1.
+  memset(buff2, 0, len2); //Clear buff2.
+  ...
+}
+```
+
+(3) Assign an initial value after allocating memory from the heap.
+```cpp
+size_t len = ...
+char *str = (char *)malloc(len);
+if (str != nullptr) {
+  memset(str, 0, len);
+  ...
+}
+```
+
+(4) Copy memory with the same size as the source memory size.
+The following code copies a memory block with the same size as srcSize:
+```cpp
+BYTE *src = ...
+size_t srcSize = ...
+BYTE *destBuff = new BYTE[srcSize];
+memcpy(destBuff, src, srcSize);
+```
+
+The following code copies a memory block with the same size as the source character string:
+```cpp
+char *src = ...
+size_t len = strlen(src);
+if (len > BUFF_SIZE) {
+  ...
+}
+char *destBuff = new char[len + 1];
+strcpy(destBuff, src);
+```
+
+(5) The source memory stores static character string constants only. (Check whether the destination memory is sufficient during encoding.)
+The following code directly copies the string constant "hello" to the array:
+```cpp
+char destBuff[BUFF_SIZE];
+strcpy(destBuff, "hello");
+```
+The following code concatenates static character string constants:
+```cpp
+const char *list[] = {"red","green","blue"};
+char destBuff[BUFF_SIZE];
+sprintf(destBuff, "hello %s", list[i]);
+```
+
diff --git a/doc/en/RcApi.md b/doc/en/RcApi.md
new file mode 100644
index 0000000000000000000000000000000000000000..c3568ac28b1e4ab326e3d2b1d00b43507968f8bb
--- /dev/null
+++ b/doc/en/RcApi.md
@@ -0,0 +1,525 @@
+RC API
+----
+
+Reference counting (RC) is a programming technique of storing the number of references to a resource, such as an object, a block of memory, disk space, and others, and releasing the resource when the number of references becomes 0. RC is used to achieve automatic resource management. RC also refers to a garbage collection algorithm that deallocates objects which are no longer referenced.
+
+To support RC, OpenArkCompiler provides the following APIs for better code generation.
+
+## void MCC\_IncRef\_NaiveRCFast(address\_t obj)
+
+**Function:**
+
+Increments RC of the object.
+
+**Input parameter:**
+
+obj: pointer of the heap object
+
+**Return value:**
+
+None
+
+## void MCC\_DecRef\_NaiveRCFast(address\_t obj)
+
+**Function:**
+
+Decrements RC of the object.
+
+**Input parameter:**
+
+obj: pointer of the heap object
+
+**Return value:**
+
+None
+
+## void MCC\_ClearLocalStackRef(address\_t \*addr)
+
+**Function:**
+
+Clears local reference on the thread stack and decrements RC for the stored reference.
+
+**Input parameter:**
+
+addr: address of the local reference on the thread stack
+
+**Return value:**
+
+None
+
+## void MCC\_IncDecRef\_NaiveRCFast(address\_t incObj, address\_t decObj)
+
+**Function:**
+
+Increments RC for the object to which incObj points and decrements RC for the object to which decObj points.
+
+**Input parameter:**
+
+incObj: address of the object whose RC needs increment
+
+incObj: address of the object whose RC needs decrement
+
+**Return value:**
+
+None
+
+## void MCC\_IncDecRefReset(address\_t incObj, address\_t \*decAddr)
+
+**Function:**
+
+Increments RC for the object to which incObj points, decrements RC for the local variable object stored on the stack address pointer decAddr, and clears the memory to which the stack address pointer decAddr points.
+
+**Input parameter:**
+
+incObj: heap object whose RC needs increment
+
+decAddr: address of the local reference on the stack
+
+**Return value:**
+
+None
+
+## void MCC\_DecRefResetPair(address\_t \*decAddr0, address\_t \*decAddr1)
+
+**Function:**
+
+Clears the stack address space to which all parameters point, and decrements RC for the old value of the local variable.
+
+**Input parameter:**
+
+decAddr0 and decAddr1: addresses of the local reference on the stack
+
+**Return value:**
+
+None
+
+## void MCC\_SetObjectPermanent(address\_t obj)
+
+**Function:**
+
+Sets a heap object to be permanently valid. After being invoked, RC for the object reaches the maximum value.
+
+**Input parameter:**
+
+obj: address of the heap object
+
+**Return value:**
+
+None
+
+## address\_t MCC\_LoadVolatileStaticField(address\_t \*fieldAddr)
+
+**Function:**
+
+Obtains the value of the volatile static variable and increments RC for the fetched heap object.
+
+**Input parameter:**
+
+fieldAddr: address of the volatile static variable
+
+**Return value:**
+
+Returns the value of the volatile static variable.
+
+## address\_t MCC\_LoadRefStatic(address\_t \*fieldAddr)
+
+**Function:**
+
+Obtains the value of the static variable and increments RC for the fetched heap object.
+
+**Input parameter:**
+
+fieldAddr: address of the static variable
+
+**Return value**
+
+Returns the value of the static variable.
+
+## address\_t MCC\_LoadVolatileWeakField(address\_t obj, address\_t \*fieldAddr)
+
+**Function:**
+
+Obtains the value of the volatile variable marked by the weak annotation. If a non-null heap object is obtained, RC for the object will be incremented.
+
+**Input parameter:**
+
+obj: address of the heap object
+
+fieldAddr: address of the volatile variable marked as weak
+
+**Return value:**
+
+Returns the value of the volatile variable marked as weak. A null object pointer may be returned.
+
+## address\_t MCC\_LoadWeakField(address\_t obj, address\_t \*field\_addr)
+
+**Function:**
+
+Obtains the value of the variable marked by the weak annotation. If a non-null heap object is obtained, RC for the object will be incremented.
+
+**Input parameter:**
+
+obj: address of the heap object
+
+fieldAddr: address of the variable marked as weak
+
+**Return value:**
+
+Returns the value of the variable marked as weak. A null object pointer may be returned.
+
+## address\_t MCC\_LoadRefField\_NaiveRCFast(address\_t obj, address\_t \*fieldAddr)
+
+**Function:**
+
+Obtains the value of the fieldAddr variable, and increments RC for the obtained heap object.
+
+**Input parameter:**
+
+obj: address of the heap object
+
+fieldAddr: address of the variable
+
+**Return value:**
+
+Returns the value of the variable.
+
+## address\_t MCC\_LoadVolatileField(address\_t obj, address\_t \*fieldAddr)
+
+**Function:**
+
+Obtains the value of the volatile variable, and increments RC for the fetched heap object.
+
+**Input parameter:**
+
+obj: address of the heap object
+
+fieldAddr: address of the volatile variable
+
+**Return value:**
+
+Returns the value of the volatile variable.
+
+## void MCC\_WriteReferent(address\_t obj, address\_t value)
+
+**Function:**
+
+Store an object to the referent field of a java.lang.ref.Reference object. If a non-null heap object is obtained, RC for the object is incremented.
+
+**Input parameter:**
+
+obj: address of java.lang.ref.Reference
+
+value: address of the heap object
+
+**Return value:**
+
+None
+
+## void MCC\_WriteVolatileStaticFieldNoInc(address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the volatile static variable. This does not change RC for the heap object, but decrements RC for the old value of the static variable.
+
+**Input parameter:**
+
+fieldAddr: address of the volatile static variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteVolatileStaticFieldNoDec(address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the volatile static variable. This increments RC for the heap object, but does not decrement RC for the old value of the static variable.
+
+**Input parameter:**
+
+fieldAddr: address of the volatile static variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteVolatileStaticFieldNoRC(address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the volatile static variable. This does not change RC for the new value (value) or the old value (value of fieldAddr).
+
+**Input parameter:**
+
+fieldAddr: address of the volatile static variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteVolatileStaticField(address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the volatile static variable. This increments RC for the heap object, and decrements RC for the old value of the static variable.
+
+**Input parameter:**
+
+fieldAddr: address of the volatile static variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteRefFieldStaticNoInc(address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the static variable. This does not increment RC for the heap object, but decrements RC for the old value of the static variable.
+
+**Input parameter:**
+
+fieldAddr: address of the static variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteRefFieldStaticNoDec(address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the static variable. This increments RC for the heap object, but does not decrement RC for the old value of the static variable.
+
+**Input parameter:**
+
+fieldAddr: address of the static variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteRefFieldStaticNoRC(address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the static variable. This does not increment RC for the heap object or decrement RC for the old value of the static variable.
+
+**Input parameter:**
+
+fieldAddr: address of the static variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteRefFieldStatic(address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the static variable. This increments RC for the heap object, and decrements RC for the old value of the static variable.
+
+**Input parameter:**
+
+fieldAddr: address of the static variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteVolatileFieldNoInc(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the volatile variable. This does not increment RC for the heap object, but decrements RC for the old value of the volatile variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: address of the volatile variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteVolatileFieldNoDec(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the volatile variable. This increments RC for the heap object, but does not decrement RC for the old value of the volatile variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: address of the volatile variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteVolatileFieldNoRC(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the volatile variable. This does not increment RC for the heap object or decrement RC for the old value of the volatile variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: address of the volatile variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteVolatileField(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the volatile variable. This increments RC for the heap object, and decrements RC for the old value of the volatile variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: address of the volatile variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteRefFieldNoInc(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the variable. This does not increment RC for the heap object, but decrements RC for the old value of the variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: address of the variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteRefFieldNoDec(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the variable. This increments RC for the heap object, but does not decrement RC for the old value of the variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: address of the variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteRefFieldNoRC(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the variable. This does not increment RC for the heap object or decrement RC for the old value of the variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: address of the variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteRefField(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the variable. This increments RC for the heap object, and decrements RC for the old value of the variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: address of the variable
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteVolatileWeakField(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the volatile variable marked by Weak annotation. This increments RC for the heap object, and decrements RC for the old value of the volatile variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: field of the volatile variable marked by the weak annotation
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
+## void MCC\_WriteWeakField(address\_t obj, address\_t \*fieldAddr, address\_t value)
+
+**Function:**
+
+Writes a heap object to the variable marked by the weak annotation. This increments RC for the heap object, and decrements RC for the old value of the variable.
+
+**Input parameter:**
+
+obj: address of the object
+
+fieldAddr: field of the variable which marked by weak annotation
+
+value: address of the heap object to be written
+
+**Return value:**
+
+None
+
diff --git a/doc/en/TargetConstants.md b/doc/en/TargetConstants.md
new file mode 100644
index 0000000000000000000000000000000000000000..4be1770113c4d96ab7d45d7cfd760b8b9abe2c07
--- /dev/null
+++ b/doc/en/TargetConstants.md
@@ -0,0 +1,136 @@
+### Introduction
+This document describes the way to work with target constants in maple IR.
+It's very important to distinguish `host` constants from the `target` ones.
+`Host` constants represent values on the machine where the compiler runs.
+`Target` constants represent values that will be present in the target code generated by the compiler.
+So, in the common case there is no one-to-one mapping between `host` constants and `target` ones.
+For example, a host machine has `one's complement` representation for integers, but the `target` machine
+has `two's complement` integers representation. Or more realistic case when the target machine supports `int128_t` and can
+hold 128-bit constants directly, but the `host` machine does not.
+So, we need to find a safe and convenient way how to represent and operate on the `target` constants in maple IR
+while compiling a user program.
+
+### Working with constants in maple IR
+Let's show how to work with constants on `Constant Folding` optimization as an example.
+Consider the following Maple IR:
+```
+func &foo static used () i8 {
+  return (add i8 (constval i8 1, constval i8 2))
+}
+```
+we want to fold this `add` to perform calculation at compile time.
+We could do something like this:
+```c++
+MIRConst *ConstantFold::FoldIntConstBinaryMIRConst(Opcode opcode, PrimType resultType,
+                                                   const MIRIntConst *intConst0,
+                                                   const MIRIntConst *intConst1) const {
+  int64 intValueOfConst0 = intConst0->GetValue();
+  int64 intValueOfConst1 = intConst1->GetValue();
+
+  uint64 result64 = 0;
+  uint32 result32 = 0;
+  uint16 result16 = 0;
+  uint8 result8 = 0;
+
+  bool useResult64 = (GetPrimTypeSize(resultType) == 8);
+  bool useResult32 = (GetPrimTypeSize(resultType) == 4);
+  bool useResult16 = (GetPrimTypeSize(resultType) == 2);
+  bool useResult8 = (GetPrimTypeSize(resultType) == 1);
+
+  switch (opcode) {
+    case OP_add: {
+      if (useResult64) {
+        result64 = static_cast<uint64>(intValueOfConst0) + static_cast<uint64>(intValueOfConst1);
+      } else if (useResult32) {
+        result32 = static_cast<uint32>(intValueOfConst0) + static_cast<uint32>(intValueOfConst1);
+      } else if (useResult16) {
+        result16 = static_cast<uint16>(intValueOfConst0) + static_cast<uint16>(intValueOfConst1);
+      } else if (useResult8) {
+        result8 = static_cast<uint8>(intValueOfConst0) + static_cast<uint8>(intValueOfConst1);
+      }
+      break;
+    }
+    ...
+```
+As can be seen, there is a lot of boilerplate code depending on the type size of the result of operation.
+In a more general case, the sign of the result type is also has to be taken into account, doubling the code size (e.g. div)
+Also, if we manipulate with 128-bit types it's possible that there is no `int128_t` type on the host machine and in this
+case we need to perform such calculation manually. For example, we need to hold the value in two `int64_t` variables.
+So, we need to be able to work with target constants in a safe and convenient way. To achieve this goal we can use
+a special class that's called `IntVal`. It provides a convenient interface for manipulation with target constants.
+For example, the above case can be managed as follows:
+```c++
+MIRConst *ConstantFold::FoldIntConstBinaryMIRConst(Opcode opcode, PrimType resultType,
+                                                   const MIRIntConst *intConst0,
+                                                   const MIRIntConst *intConst1) const {
+  IntVal intVal0 = intConst0->GetValue();
+  IntVal intVal1 = intConst1->GetValue();
+
+  IntVal result(0, resultType);
+
+  switch (opcode) {
+    case OP_add: {
+      result = intVal0.Add(intVal1, resultType);
+      // or
+      // result = intVal0 + intVal1;
+      // if resultType is equal to type of operands
+      break;
+    }
+    ...
+```
+Let's take a look at `IntVal` class in more detail.
+
+##### The IntVal class
+This class represents a target integer constant in `two's complement` representation.
+It's able to hold signed and unsigned integers with arbitrary bit-width (currently, no more than 64 bits. 128-bit support is in progress)
+that can be created using the following constructors:
+```c++
+/// Creates IntVal object from uint64 value with bit-width defined by bitWidth parameter
+/// and interpreted as signed value if isSigned parameter is true
+IntVal(uint64 val, uint8 bitWidth, bool isSigned);
+
+/// The same as above, but bit-width and signedness are obtained from the given PrimType
+IntVal(uint64 val, PrimType type);
+```
+Also, this class provides an interface to perform arithmetic, bitwise, comparison and other operations on the target constants.
+For example:
+```c++
+/// perform an addition: *this + val. Bit-width and signedness of values must be the same
+IntVal operator+(const IntVal &val) const;
+
+/// the same as above, but performs '+' in terms of the given integer PrimType
+IntVal Add(const IntVal &val, PrimType pType) const;
+
+/// perform a binary 'and': *this & val. Bit-width and signedness of values must be the same
+IntVal operator&(const IntVal &val) const;
+
+/// the same as above, but performs '&' in terms of the given integer PrimType
+IntVal And(const IntVal &val, PrimType pType) const;
+
+/// perform a comparison: *this < val. Bit-width and signedness of values must be the same
+bool operator<(const IntVal &rhs) const;
+
+/// the same as above, but performs '<' in terms of the given integer PrimType
+bool Less(const IntVal &rhs, PrimType pType) const;
+```
+
+There are `Extend`, `Trunc` and `TruncOrExtend` functions that allow truncating or extending (zero or sign extension)
+depending on the given integer PrimType. These functions return new `IntVal` object that has bit-width and sign obtained
+from the given PrimType and has a value obtained from the original value by truncation or extension (zero of sign).
+```c++
+IntVal TruncOrExtend(PrimType newType) cosnt;
+IntVal Extend(PrimType newType) cosnt;
+IntVal Trunc(PrimType newType) cosnt;
+```
+It's possible to get a host constant from the target one (in case the value can fit into the host constant) using the following
+interfaces:
+```c++
+/// perform zero extension of the value
+uint64 GetZXTValue(uint8 size = 0) const;
+
+/// perform sign extension of the value
+int64 GetSXTValue(uint8 size = 0) const;
+
+/// perform sign or zero extension of the value depending on its sign
+int64 GetExtValue(uint8 size = 0) const;
+```
diff --git a/doc/en/VtableItableDescription.md b/doc/en/VtableItableDescription.md
new file mode 100644
index 0000000000000000000000000000000000000000..aa01bca9736393114700781a35bb5150b9009ebe
--- /dev/null
+++ b/doc/en/VtableItableDescription.md
@@ -0,0 +1,376 @@
+# Virtual Table and Interface Table Design
+
+## Virtual Table
+
+OpenArkCompiler generates a virtual table for each class. A virtual table of one class consists of virtual functions of its super classs, virtual functions of the current class, and default functions of the interfaces which the current class implements. If function of the current class override function of its superclass, the function of its superclass will be replaced by the function of the current class in the virtual table of the current class.
+
+The following is a specific example:
+
+```java
+class A {
+  public int first() {
+    return 0;
+  }
+}
+
+class B extends A {
+  public void foo() {
+  }
+  public int first() {
+    return 1;
+  }
+}
+
+class C extends A {
+  public void bar() {
+  }
+  public int first() {
+    return 2;
+  }
+}
+
+public class IsEmpty {
+  public static void main(String [] args) {
+    A x = new B();
+    x.first();
+    A y = new C()
+    y.first();
+  }
+
+  public void add(A x) {
+    x.first();
+  }
+}
+```
+
+
+
+The structure of the virtual table generated by OpenArkCompiler is as follows:
+
+A:
+```
+ _vtb_LA_3B:
+        .quad   Ljava_2Flang_2FObject_3B_7Cclone_7C_28_29Ljava_2Flang_2FObject_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cfinalize_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CgetClass_7C_28_29Ljava_2Flang_2FClass_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7ChashCode_7C_28_29I - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cnotify_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CnotifyAll_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CtoString_7C_28_29Ljava_2Flang_2FString_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28J_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28JI_29V - .
+        .quad   LA_3B_7Cfirst_7C_28_29I - .
+```
+
+B:
+
+```
+ __vtb_LB_3B:
+        .quad   Ljava_2Flang_2FObject_3B_7Cclone_7C_28_29Ljava_2Flang_2FObject_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cfinalize_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CgetClass_7C_28_29Ljava_2Flang_2FClass_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7ChashCode_7C_28_29I - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cnotify_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CnotifyAll_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7CtoString_7C_28_29Ljava_2Flang_2FString_3B - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28J_29V - .
+        .quad   Ljava_2Flang_2FObject_3B_7Cwait_7C_28JI_29V - .
+        .quad   LB_3B_7Cfirst_7C_28_29I - .
+        .quad   LB_3B_7Cfoo_7C_28_29V - .
+```
+C:
+```
+__vtb_LC_3B:
+The first 11 functions are the same as those of A and B.
+       … …
+       .quad   LC_3B_7Cfirst_7C_28_29I - .
+       .quad   LC_3B_7Cbar_7C_28_29V - .
+
+```
+
+Comparison shows that:
+
+1. All classes inherit from the object class. Therefore, the first 11 functions in the virtual table are inherited from the object class, and the layout is the same as that of the object class.
+2. For function 12, function 12 of the subclass B overrides function 12 of the superclass A. Therefore, in the same position, the virtual table of class A is LA_3B_7Cfirst_7C_28_29I and the virtual table of class B is LB_3B_7Cfirst_7C_28_29I. Class C inherits from Class A and overrides the first function. In addition, the iD interface is implemented. Therefore, LC_3B_7Cfirst_7C_28_29I lies on position 12, and LiD_3B_7Csecond_7C_28_29I lies on position 13.
+
+## Virtual Function Invocation (During Compilation)
+
+For virtual call, we cannot determine which function is called during compilation. The following is an example:
+
+```java
+public class IsEmpty {
+  public static void main(String [] args) {
+    A x = new B();
+    x.first();
+    A y = new C();
+    y.first();
+  }
+
+  public void add(A x) {
+    x.first();
+  }
+}
+```
+
+
+In this case, we are not sure whether the first function in B or C is called during compilation.
+
+However, the layout of the first function in A, B, and C is the same. In this example, the offset of the first function in the virtual table is 12. Therefore, we can access the function by obtaining the virtual table pointer from the corresponding object and add offset 12 to the pointer.
+## Virtual Function Invocation (Running)
+
+In a program execution process, as shown in Figure 1, if a virtual function is called, we perform the following steps:
+1. Determine the instance class of the object (this_ pointer). In Figure 1, this is the instance of class C.
+2. Search the virtual table of the corresponding class using the function index.
+3. Return the function pointer that is actually called.
+
+![](media/javavmt.png)
+<center>Figure 1: Static calling of Java virtual function</center>
+
+## Interface Table
+
+Interface call is similar as multiple inheritance and is more complex than Java single inheritance. For multiple inheritance, a unique inheritance order cannot be determined naturally.
+
+In a closed environment, a sequence (iA, iB, iC) can be determined through topology sorting. The advantage is that interface call can be processed in a way similar as that of a virtual table. However, the interface table of a class obtained in this way will be very large with few data. This approach is not available considering performance and code size.
+
+![](media/Topology.png)
+
+
+In an open environment, a sequence cannot be determined through topology sorting during compilation. As a result, the sequence of functions in the interface table is not fixed. Therefore, in actual implementation, it is unlikely to achieve a function table with a consistent sequence and an access mechanism by offset. During compilation, we can determine all interfaces implemented by a class and the inheritance relationship of the interfaces. During running, the function signatures can be compared to determine which function needs to be called. As string comparison causes overhead, OpenArkCompiler calculates the hash value of the function name and signature during compilation. First, compare the hash values. If they are the same, and no hash conflict exists, the function is called. If a hash conflict occurs, OpenArkCompiler compares the function name with signature and obtain the function pointer.
+
+In addition, considering running efficiency and ROM size, we divide the interface table into two levels of tables. Level 1 is the real hash table. We set the hash value to 23, and enter the function address in the position corresponding to the hash value (0-C22). If no conflict occurs in the level 1 hash table, the entries following the last position that contains the function address are blank. In this way, the subsequent entries can be deleted without occupying space. If a conflict occurs in the level-2 hash table, enter 0 in the position where the conflict occurs, and then enter the address of the level-2 hash table in entry 23.
+
+The structure of the level-1 table is as follows:
+
+| Sequence | Interface Table Entry | Description
+|----|------------|---------------------------------------------|
+| 0 | &Func or 0 | Function address corresponding to the hash value. If no function address exists, the value is 0. If a conflict occurs, the conflict position is also 0, and the level-2 table address is entered in entry 23. If no conflict occurs, the entries after the last value (n) with a corresponding function are deleted.|
+| 1 | &Func or 0 |
+| 2 | &Func or 0 | 
+| ... | &Func or 0 |
+|n   | &Func      |
+| 23 | &itbC | Address of the level-2 table If no conflict occurs in the level-1 table, this entry does not exist. |
+
+
+The structure of the level-2 function table is as follows:
+
+| Interface Table Entry | Description |
+|----------------------|--------------------------------------------------|
+| Size | Size of the interface table that does not conflict |
+| 1 | Align the site position. Meaningless |
+| Func1_sig | Func1 signature hash value |
+| &Func1 | Fun1 address |
+| Func2_sig | Func2 signature hash value|
+| &Func2 | Func2 address |
+| ......               |                                                  |
+| Func3_sig and Func4_sig | Func3 signature and Func4 signature hash values. The two values are the same. |
+| 1 | Indicates a conflict as Func3 and Func4 signature harsh values are the same. |
+| ......                  |                                                  |
+| Func3_sig | Func3 signature |
+| &Func3 | Func3 address |
+| Func4_sig | Func4 signature |
+| &Func4 | Func4 address |
+| ......                  |                                                  |
+
+## Interface Function Calling:
+
+Figure 2 shows the process of calling an interface function that is declared as follows:
+
+```java
+interface B { funcB(); }
+interface C { funcC(); }
+interface D { funcD(); }
+Class A implements B, C, D {}
+```
+
+![](media/interface1.jpg)
+
+<center>Figure 2: Static calling of Java interface function</center> 
+
+
+As shown in Figure 2, in a program execution process, we perform the following steps:
+
+1. Determine the class instance of the object. Here, the object is the instance of class A.
+2. In the level-1 table, search for the address based on the harsh value. If the address exists, the function pointer is returned. If the value is 0, search the level-2 table. In the level-2 table, search for the address using the signature hash value. If the address is found, the function pointer is returned. Otherwise, use the function name to search the table.
+3. Indirectly invoke the function pointer and transfer related parameter (args) to the indirect invocation.
+
+The following is a specific example:
+
+The IsEmpty class implements interfaces A and B. Each interface declares two functions.
+
+```java
+interface A{
+  public int add();
+  public int minus();
+}
+
+interface B{
+  public int mult();
+  public int div();
+}
+
+public class IsEmpty implements A, B {
+    public static void main(String[]args) {
+    }
+
+    public void test(B x) {
+      x.mult();
+    }
+
+    public int add() {
+      return 6 + 3;
+    }
+
+    public int minus() {
+      return 6 - 3;
+    }
+
+    public int mult() {
+      return 6 * 3;
+    }
+
+    public int div() {
+      return 6 / 3;
+    }
+}
+```
+
+The interface table of IsEmpty is in the maple code is as follows:
+
+```
+var $__itb_LIsEmpty_3B fstatic <[24] <* void>> = [0, 0, 0, 0, 0, 0, 0, 0, addroffunc ptr &LIsEmpty_3B_7Cdiv_7C_28_29I, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, addroffunc ptr &LIsEmpty_3B_7Cadd_7C_28_29I, 0, 0, addrof ptr $__itabC_LIsEmpty_3B]
+
+var $__itbC_LIsEmpty_3B fstatic <[6] <* void>> = [2, 1, 0xb97, addroffunc ptr &LIsEmpty_3B_7Cmult_7C_28_29I, 0x1f7f, addroffunc ptr &LIsEmpty_3B_7Cminus_7C_28_29I]
+```
+
+Corresponding assembly structure:
+
+```
+__itb_LIsEmpty_3B:
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   LIsEmpty_3B_7Cdiv_7C_28_29I - .
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   0
+        .quad   LIsEmpty_3B_7Cadd_7C_28_29I - .
+        .quad   0
+        .quad   0
+        .quad   __itabC_LIsEmpty_3B - .
+```
+```
+__itbC_LIsEmpty_3B:
+        .quad   2
+        .quad   1
+        .quad   2967
+        .quad   LIsEmpty_3B_7Cmult_7C_28_29I - .
+        .quad   8063
+        .quad   LIsEmpty_3B_7Cminus_7C_28_29I - .
+```
+
+The entry content is as follows:
+
+1. In the level-1 table (__itb_LIsEmpty_3B), there are 23 entries in total, where entry 9 and entry 12 are function addresses, and entry 23 is the level-2 table address. Therefore, a conflict occurs in the level-1 table, and a specific function address needs to be confirmed in the level-2 table.
+
+2. In the level-2 table, the first entry is 2, indicating that there are two functions that do not conflict with each other. The second entry is 1, which is used for alignment and placeholder. The last four entries are the hash values generated by the function signature and the corresponding function addresses.
+
+In the following example, the test function in the source code generates interface-call. The corresponding maple code is as follows:
+
+```
+if (eq u1 u64 (regread u64 %4, constval u64 0)) {
+  callassigned &MCC_getFuncPtrFromItabSecondHash64 (regread ptr %3, constval u64 0xb97, conststr ptr "mult|()I") { regassign u64 %4}
+}
+icallassigned (regread u64 %4, regread ref %2) {}
+```
+
+The calling logic is as follows:
+
+Check whether the entry corresponding to the hash value in the level-1 interface table is null. If not, use the address. If yes, call the getFuncPtrFromItabSecondHash64 function.
+
+The getFuncPtrFromItabSecondHash64 function has three parameters: interface table address, hash value of the basename function, and the function signature. The complete calling process is as follows: Find the corresponding interface table address based on classinfo and compare the hash values. If the comparison is successful, and no conflict occurs, the correct address can be obtained. If a conflict occurs, compare the signature names (character string comparison).
+
+The format of the accessed interface table is the same as that of IsEmpty.
+
+##  Interface override
+
+The `Default` function is introduced in Java 8. The implementation in the superclass overrides the default function of the interface. Override depends on the inheritance relationship between interfaces. As shown in the following figure, the cA class inherits the cB class to implement the iD interface. The foo function is implemented in both the cB class and iD interface. For the cA class, the implementation of the foo function depends on the superclass cB rather than the iD interface.
+
+```java
+
+interface iD {
+  public default void foo(){System.out.println("iD foo");}
+}
+
+class cB {
+  public void foo(){System.out.println("cB foo");}
+}
+
+class cA extends cB implements iD {
+}
+
+public class IsEmpty {
+  public static void main(String [] args) {
+    iD obj = new cA();
+    obj.foo();
+  }
+}
+```
+
+
+As shown in the following figure, the getValue function is defined in both parent and son interfaces. For the Sson calss, the implementation of the getValue function depends on the son interface rather than the parent interface.
+
+```java
+interface Parent{
+  default void getValue(){
+    System.out.println("Parent getVatue......");
+  }
+}
+
+interface Son extends Parent{
+  default void getValue(){
+    System.out.println("OfInt getValue......")
+  }
+}
+
+abstract class OfPrimitive implements Parent{
+}
+
+class SSon extends OfPrimitive implements Son{
+}
+
+public class Main {
+  static int get() {
+    return 1;
+  }
+  
+  public static void main(String[] args) {
+    Parent son = (Parent)new SSon();
+    son.getValue();
+
+    SSon son2;
+    if(get()==1) {
+      son2 = new SSon();
+    }
+    else son2 = new SSon();
+    son2.getValue();
+  }
+}
+```
+
diff --git a/doc/en/media/MapleDriverStructure.png b/doc/en/media/MapleDriverStructure.png
new file mode 100644
index 0000000000000000000000000000000000000000..adc5f98ba54d4ffb4430cb3bbff37e8e45d06214
Binary files /dev/null and b/doc/en/media/MapleDriverStructure.png differ
diff --git a/doc/en/media/Topology.png b/doc/en/media/Topology.png
new file mode 100644
index 0000000000000000000000000000000000000000..6967780a1ac7addf7811b4271bbf805c6d659027
Binary files /dev/null and b/doc/en/media/Topology.png differ
diff --git a/doc/en/media/addphase.png b/doc/en/media/addphase.png
new file mode 100644
index 0000000000000000000000000000000000000000..049560035bd8b661454107d4be2498f3bc9d06b9
Binary files /dev/null and b/doc/en/media/addphase.png differ
diff --git a/doc/en/media/interface1.jpg b/doc/en/media/interface1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..7377546fc36b03b282e5d85d0a89fd274288f831
Binary files /dev/null and b/doc/en/media/interface1.jpg differ
diff --git a/doc/en/media/javavmt.png b/doc/en/media/javavmt.png
new file mode 100644
index 0000000000000000000000000000000000000000..ef93f36923559321d0512a862ca9a1ff9d36a6b6
Binary files /dev/null and b/doc/en/media/javavmt.png differ
diff --git a/format.sh b/format.sh
new file mode 100755
index 0000000000000000000000000000000000000000..1189a7868479d16a67d2db24b67a054fca1fdaba
--- /dev/null
+++ b/format.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+# usage: in OpenArkCompiler dir, ./format.sh xxx.cpp
+CLANG_FORMAT=$MAPLE_ROOT/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/clang-format
+
+$CLANG_FORMAT -style=file -i $1
+sed -i -e 's/ \*,/\*,/g' -e 's/ \*>/\*>/g' -e 's/ \*)/\*)/g'  -e 's/ \&,/\&,/g' -e 's/ \&>/\&>/g' -e 's/ \&)/\&)/g' $1
+sed -i ":a;$!N;s/enum\(.*\)\n{/enum\1 {/g;ba" $1
diff --git a/license/LICENSE b/license/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..9e32cdef1625daed25cf365c865f01050877cff3
--- /dev/null
+++ b/license/LICENSE
@@ -0,0 +1,127 @@
+                     木兰宽松许可证, 第2版
+
+   木兰宽松许可证， 第2版 
+   2020年1月 http://license.coscl.org.cn/MulanPSL2
+
+
+   您对“软件”的复制、使用、修改及分发受木兰宽松许可证，第2版（“本许可证”）的如下条款的约束：
+
+   0. 定义
+
+      “软件”是指由“贡献”构成的许可在“本许可证”下的程序和相关文档的集合。
+
+      “贡献”是指由任一“贡献者”许可在“本许可证”下的受版权法保护的作品。
+
+      “贡献者”是指将受版权法保护的作品许可在“本许可证”下的自然人或“法人实体”。
+
+      “法人实体”是指提交贡献的机构及其“关联实体”。
+
+      “关联实体”是指，对“本许可证”下的行为方而言，控制、受控制或与其共同受控制的机构，此处的控制是指有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。
+
+   1. 授予版权许可
+
+      每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、分发其“贡献”，不论修改与否。
+
+   2. 授予专利许可
+
+      每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销除外）专利许可，供您制造、委托制造、使用、许诺销售、销售、进口其“贡献”或以其他方式转移其“贡献”。前述专利许可仅限于“贡献者”现在或将来拥有或控制的其“贡献”本身或其“贡献”与许可“贡献”时的“软件”结合而将必然会侵犯的专利权利要求，不包括对“贡献”的修改或包含“贡献”的其他结合。如果您或您的“关联实体”直接或间接地，就“软件”或其中的“贡献”对任何人发起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，指控其侵犯专利权，则“本许可证”授予您对“软件”的专利许可自您提起诉讼或发起维权行动之日终止。
+
+   3. 无商标许可
+
+      “本许可证”不提供对“贡献者”的商品名称、商标、服务标志或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用除外。
+
+   4. 分发限制
+
+      您可以在任何媒介中将“软件”以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供“本许可证”的副本，并保留“软件”中的版权、商标、专利及免责声明。
+
+   5. 免责声明与责任限制
+
+      “软件”及其中的“贡献”在提供时不带任何明示或默示的担保。在任何情况下，“贡献者”或版权所有者不对任何人因使用“软件”或其中的“贡献”而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论，即使其曾被建议有此种损失的可能性。 
+
+   6. 语言
+      “本许可证”以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何冲突不一致，以中文版为准。
+
+   条款结束 
+
+   如何将木兰宽松许可证，第2版，应用到您的软件
+   
+   如果您希望将木兰宽松许可证，第2版，应用到您的新软件，为了方便接收者查阅，建议您完成如下三步：
+
+      1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；
+
+      2， 请您在软件包的一级目录下创建以“LICENSE”为名的文件，将整个许可证文本放入该文件中；
+
+      3， 请将如下声明文本放入每个源文件的头部注释中。
+
+   Copyright (c) [Year] [name of copyright holder]
+   [Software Name] is licensed under Mulan PSL v2.
+   You can use this software according to the terms and conditions of the Mulan PSL v2. 
+   You may obtain a copy of Mulan PSL v2 at:
+            http://license.coscl.org.cn/MulanPSL2 
+   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.  
+   See the Mulan PSL v2 for more details.  
+
+
+                     Mulan Permissive Software License，Version 2
+
+   Mulan Permissive Software License，Version 2 (Mulan PSL v2)
+   January 2020 http://license.coscl.org.cn/MulanPSL2
+
+   Your reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v2 (this License) with the following terms and conditions: 
+   
+   0. Definition
+   
+      Software means the program and related documents which are licensed under this License and comprise all Contribution(s). 
+   
+      Contribution means the copyrightable work licensed by a particular Contributor under this License.
+   
+      Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.
+   
+      Legal Entity means the entity making a Contribution and all its Affiliates.
+   
+      Affiliates means entities that control, are controlled by, or are under common control with the acting entity under this License, ‘control’ means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.
+
+   1. Grant of Copyright License
+
+      Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.
+
+   2. Grant of Patent License 
+
+      Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to make, have made, use, offer for sale, sell, import or otherwise transfer its Contribution, where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, or by combination of the Contribution with the Software to which the Contribution was contributed. The patent license shall not apply to any modification of the Contribution, and any other combination which includes the Contribution. If you or your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to you under this License for the Software shall terminate as of the date such litigation or activity is filed or taken.
+
+   3. No Trademark License
+
+      No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in Section 4.
+
+   4. Distribution Restriction
+
+      You may distribute the Software in any medium with or without modification, whether in source or executable forms, provided that you provide recipients with a copy of this License and retain copyright, patent, trademark and disclaimer statements in the Software.
+
+   5. Disclaimer of Warranty and Limitation of Liability
+
+      THE SOFTWARE AND CONTRIBUTION IN IT ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE SOFTWARE OR THE CONTRIBUTION IN IT, NO MATTER HOW IT’S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+   6. Language
+
+      THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.
+
+   END OF THE TERMS AND CONDITIONS
+
+   How to Apply the Mulan Permissive Software License，Version 2 (Mulan PSL v2) to Your Software
+
+      To apply the Mulan PSL v2 to your work, for easy identification by recipients, you are suggested to complete following three steps:
+
+      i Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner; 
+
+      ii Create a file named “LICENSE” which contains the whole context of this License in the first directory of your software package;
+
+      iii Attach the statement to the appropriate annotated syntax at the beginning of each source file.
+
+
+   Copyright (c) [Year] [name of copyright holder]
+   [Software Name] is licensed under Mulan PSL v2.
+   You can use this software according to the terms and conditions of the Mulan PSL v2. 
+   You may obtain a copy of Mulan PSL v2 at:
+               http://license.coscl.org.cn/MulanPSL2 
+   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.  
+   See the Mulan PSL v2 for more details.  
diff --git a/license/ThirdPartyOpenSourceSoftwareNotice b/license/ThirdPartyOpenSourceSoftwareNotice
new file mode 100644
index 0000000000000000000000000000000000000000..ab3019730241e2616919a552300ecb8205d64aba
--- /dev/null
+++ b/license/ThirdPartyOpenSourceSoftwareNotice
@@ -0,0 +1,483 @@
+OPEN SOURCE SOFTWARE NOTICE
+
+Please note we provide an open source software notice along with this product and/or this product firmware (in the following just “this product”). The open source software licenses are granted by the respective right holders. And the open source licenses prevail all other license information with regard to the respective open source software contained in the product, including but not limited to End User Software Licensing Agreement. This notice is provided on behalf of Huawei Technologies Co. Ltd. and any of its local subsidiaries which may have provided this product to you in your local country.
+
+Warranty Disclaimer
+
+THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+
+Copyright Notice and License Texts
+
+Software: LLVM 10.0.0
+
+Copyright notice:
+Copyright 2015 Google Inc. All rights reserved.
+Copyright 2018 Google Inc. All rights reserved.
+Copyright 2016 Ismael Jimenez Martinez. All rights reserved.
+Copyright 2017 Roman Lebedev. All rights reserved.
+Copyright 2011 The Go Authors. All rights reserved.
+Copyright (c) 2012  Alexandre K. I. de Mendonca <alexandre.keunecke@gmail.com>,Paulo Pizarro <paulo.pizarro@gmail.com>
+Copyright (c) 2012  Alexandre K. I. de Mendonca <alexandre.keunecke@gmail.com>
+Copyright (c) 2013 Imagination Technologies
+Copyright (c) 2013 Imagination Technologies Ltd.
+Copyright (c) 2014,2015 Advanced Micro Devices, Inc.
+Copyright (c) 1998 Cygnus Solutions
+Copyright (c) 2004 Simon Posnjak
+Copyright (c) 2005 Axis Communications AB
+Copyright (C) 2007 Free Software Foundation, Inc.
+Copyright (c) 2012  Anthony Green
+Copyright (c) 1996-2003  Red Hat, Inc.
+Copyright (c) 2011-2019 by the contributors listed in CREDITS.TXT
+Copyright 2008, Google Inc.
+Copyright 2005, Google Inc.
+Copyright 2007, Google Inc.
+Copyright 2008 Google Inc.
+Copyright (c) 2000, 2007 Software AG
+Copyright (c) 2008 Red Hat, Inc
+Copyright (c) 2015 Advanced Micro Devices, Inc.
+Copyright (c) 2009-2019 by the contributors listed in CREDITS.TXT
+Copyright (c) 2009-2015 by the contributors listed in CREDITS.TXT
+Copyright (c) 2019 The LLVM Developers
+Copyright 2008-2010 Apple, Inc. Permission is hereby granted, free of charge,to any person obtaining a copy of this software and associated documentation
+Copyright (c) 2014 Advanced Micro Devices, Inc.
+Copyright (c) 2014, 2015 Advanced Micro Devices, Inc.
+Copyright (c) 2013 Victor Oliveira <victormatheus@gmail.com>
+Copyright (c) 2013 Jesse Towner <jessetowner@lavabit.com>
+Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+Copyright (c) 2016 Aaron Watry
+Copyright (c) 2016 Aaron Watry <awatry@gmail.com>
+Copyright (c) 2011-2014 by the contributors listed in CREDITS.TXT
+Copyright © 2012 Peter Harris
+Copyright (c) 2007, 2009, 2010  Red Hat, Inc.
+Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc
+Copyright (c) 2011 Plausible Labs Cooperative, Inc.
+Copyright (c) 1996 Red Hat, Inc.
+Copyright (c) 1999, 2007, 2008  Red Hat, Inc.
+Copyright (c) 2011, 2012  Anthony Green
+Copyright (c) 1996, 1998, 2007  Red Hat, Inc.
+Copyright (c) 1999, 2008  Red Hat, Inc.
+Copyright (c) 1996, 1998  Red Hat, Inc.
+Copyright (c) 2012  Anthony Green
+Copyright (c) 1998, 2001, 2007, 2008  Red Hat, Inc.
+Copyright (C) 2012-2015 Free Software Foundation, Inc.
+Copyright (C) 2013-2015 Free Software Foundation, Inc.
+Copyright (c) 2009-2019 Polly Team
+Copyright (c) 1996-2014  Anthony Green, Red Hat, Inc and others.
+Copyright (c) 2013 Mentor Graphics.
+Copyright (c) 2007-2019 University of Illinois at Urbana-Champaign.
+Copyright (c) 2014  Red Hat, Inc.
+Copyright (C) 2011, 2012, 2013  Anthony Green
+Copyright (C) 2007  Free Software Foundation, Inc
+Copyright (c) 1996  Red Hat, Inc.
+Copyright (c) 2009, 2010, 2011, 2012 ARM Ltd.
+Copyright (c) 2013  Synopsys, Inc. (www.synopsys.com)
+Copyright (c) 2013  Synopsys, Inc. (www.synopsys.com)
+Copyright (c) 2011 Timothy Wall
+Copyright (c) 2011 Anthony Green
+Copyright (c) 2011 Free Software Foundation
+Copyright (c) 1998, 2008, 2011  Red Hat, Inc.
+Copyright (c) 2010  CodeSourcery
+Copyright (c) 2011  Anthony Green
+Copyright (c) 2009  Bradley Smith <brad@brad-smith.co.uk>
+Copyright (C) 2004  Anthony Green
+Copyright (C) 2007  Free Software Foundation, Inc.
+Copyright (C) 2008  Red Hat, Inc.
+Copyright (c) 1996-2004  Red Hat, Inc.
+Copyright (c) 1998, 2007, 2008, 2012 Red Hat, Inc.
+Copyright (c) 2000 Hewlett Packard Company
+Copyright (c) 2000 Hewlett Packard Company
+Copyright (c) 2004  Renesas Technology
+Copyright (c) 2008  Red Hat, Inc.
+Copyright (c) 2004  Renesas Technology.
+Copyright (c) 2013 Miodrag Vallat.  <miod@openbsd.org>
+Copyright (c) 2012, 2013 Xilinx, Inc
+Copyright (c) 2012, 2013 Xilinx, Inc
+Copyright (c) 2008  David Daney
+Copyright (c) 1996, 2007, 2008, 2011  Red Hat, Inc.
+Copyright (C) 2012, 2013  Anthony Green
+Copyright (c) 2012, 2013  Anthony Green
+Copyright (c) 2014 Sebastian Macke <sebastian@macke.de>
+Copyright (c) 2014 Sebastian Macke <sebastian@macke.de>
+(c) 2011 Anthony Green
+(c) 2008 Red Hat, Inc.
+(c) 2006 Free Software Foundation, Inc.
+(c) 2003-2004 Randolph Chung <tausq@debian.org>
+Copyright (c) 1998 Geoffrey Keating
+Copyright (C) 2013 IBM
+Copyright (C) 2011 Anthony Green
+Copyright (C) 2011 Kyle Moffett
+Copyright (C) 2008 Red Hat, Inc
+Copyright (C) 2007, 2008 Free Software Foundation, Inc
+Copyright (c) 1998 Geoffrey Keating
+Copyright (C) 2007, 2008, 2010 Free Software Foundation, Inc
+Copyright (C) 1998 Geoffrey Keating
+Copyright (C) 2001 John Hornkvist
+Copyright (C) 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 2013 IBM
+Copyright (c) 2002-2008, 2012 Kaz Kojima
+Copyright (c) 2008 Red Hat, Inc.
+Copyright (c) 2012 Anthony Green
+Copyright (c) 2003, 2004, 2006, 2007, 2012 Kaz Kojima
+Copyright (c) 2008 Anthony Green
+Copyright (c) 2011, 2013 Anthony Green
+Copyright (c) 1996, 2003-2004, 2007-2008 Red Hat, Inc.
+Copyright (c) 2012 Tilera Corp.
+Copyright (c) 2012 Tilera Corp.
+Copyright (c) 20011  Anthony Green
+Copyright (c) 2008, 2010  Red Hat, Inc.
+Copyright (c) 2002, 2007  Bo Thorsen <bo@suse.de>
+Copyright (c) 1996, 1998, 1999, 2001, 2007, 2008  Red Hat, Inc.
+Copyright (c) 2002  Ranjit Mathew
+Copyright (c) 2002  Bo Thorsen
+Copyright (c) 2002  Roger Sayle
+Copyright (C) 2008, 2010  Free Software Foundation, Inc.
+Copyright (c) 2013  The Written Word, Inc.
+Copyright (c) 2011  Anthony Green
+Copyright (c) 2012, 2014  Anthony Green
+Copyright (c) 1996-2003, 2010  Red Hat, Inc.
+Copyright (C) 2008  Free Software Foundation, Inc.
+Copyright (c) 2014 Red Hat, Inc.
+Copyright (c) 2013 Tensilica, Inc.
+Copyright (c) 2013 Tensilica, Inc.
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,2007, 2008, 2009 Free Software Foundation, Inc.
+Copyright 2009 The Go Authors. All rights reserved.
+Copyright 2012 The Go Authors.  All rights reserved.
+Copyright 2009 The Go Authors.  All rights reserved.
+Copyright 2014 The Go Authors.  All rights reserved.
+Copyright 2013 The Go Authors. All rights reserved.
+Copyright 2010 The Go Authors. All rights reserved.
+Copyright 2012 The Go Authors. All rights reserved.
+Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2014 The Go Authors. All rights reserved.
+Copyright 2015 The Go Authors. All rights reserved.
+Copyright 2009, 2010 The Go Authors. All rights reserved.
+Copyright 2013 The Go Authors.  All rights reserved.
+Copyright 2001-2004 Unicode, Inc.
+Copyright (C) 2004 eXtensible Systems, Inc.
+Copyright (c) 2001 Alexander Peslyak and it is hereby released to the general public under the following terms:
+Copyright (C) 2012-2016, Yann Collet.
+Copyright (c) 2003-2019 University of Illinois at Urbana-Champaign.
+Copyright (c) 2013-2014, Pexpect development team
+Copyright (c) 2012, Noah Spurrier <noah@noah.org>
+Copyright (c) 2009-2016 by the contributors listed in CREDITS.TXT
+Copyright 2015, Google Inc.
+Copyright (c) 1999-2003 Steve Purcell
+Copyright (c) 2003-2010 Python Software Foundation
+Copyright (c) 1999-2007 Apple Inc. All rights reserved.
+Copyright (c) 2017-2019 by the contributors listed in CREDITS.TXT
+Copyright (c) 2010 Apple Inc.
+Copyright (c) 2013-2016, Pexpect development team
+Copyright (c) 2010-2015 Benjamin Peterson
+Copyright 2004 Free Software Foundation, Inc.
+Copyright 2006, Google Inc.
+Copyright (c) 2007-2018 University of Illinois at Urbana-Champaign.
+Copyright 2013, Google Inc.
+Copyright (c) 2009 Google Inc. All rights reserved.
+Copyright (c) 2006 Kirill Simonov
+Copyright © 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.
+Copyright 2008-2009 Katholieke Universiteit Leuven
+Copyright 2006-2007 Universiteit Leiden
+Copyright 2012,2014 Ecole Normale Superieure
+Copyright 2013      Ecole Normale Superieure
+Copyright 2017      Sven Verdoolaege
+Copyright 2011      INRIA Saclay
+Copyright 2011      Sven Verdoolaege
+Copyright 2012-2014 Ecole Normale Superieure
+Copyright 2014      INRIA Rocquencourt
+Copyright 2010      INRIA Saclay
+Copyright 2012      Ecole Normale Superieure
+Copyright 2012-2013 Ecole Normale Superieure
+Copyright 2016      Sven Verdoolaege
+Copyright 2010-2011 INRIA Saclay
+Copyright 2016      INRIA Paris
+Copyright 2005-2007 Universiteit Leiden
+Copyright 2012      Universiteit Leiden
+Copyright 2014      Ecole Normale Superieure
+Copyright 2015 INRIA Paris-Rocquencourt
+Copyright 2014-2015 INRIA Rocquencourt
+Copyright 2015-2016 Sven Verdoolaege
+Copyright 2013-2014 Ecole Normale Superieure
+Copyright 2016-2017 Sven Verdoolaege
+Copyright 2018      Sven Verdoolaege
+Copyright 2016-2017 Tobias Grosser
+Copyright 2015      INRIA Paris-Rocquencourt
+Copyright (C) 1996-2015 Free Software Foundation, Inc.
+Copyright (c) 2012 Qualcomm Innovation Center, Inc. All rights reserved.
+Copyright (C) 2002-2007 Michael J. Fromberger, All Rights Reserved.
+Copyright (c) 1992, 1993 UNIX International, Inc.
+Copyright 1992, 1993, 1994 Henry Spencer.  All rights reserved.
+Copyright (c) 1994
+Copyright (c) 1992, 1993, 1994 Henry Spencer.
+Copyright (c) 1992, 1993, 1994
+Copyright (c) 1992 Henry Spencer.
+Copyright (c) 1992, 1993
+Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+Copyright (C) 2012-2016, Yann Collet
+Copyright (c) 1997-2019 Intel Corporation
+Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT
+Copyright 2012 INRIA Paris-Rocquencourt
+Copyright 2012 Ecole Normale Superieure
+Copyright 2015      Sven Verdoolaege
+Copyright (C) Microsoft Corporation. All rights reserved.
+Copyright 2003 Google Inc.
+Copyright 2009 Google Inc.
+Copyright 2016, 2017 Tobias Grosser. All rights reserved.
+Copyright 2011 Sven Verdoolaege. All rights reserved.
+Copyright 2011,2015 Sven Verdoolaege. All rights reserved.
+
+License: Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+1. Definitions.
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+You must give any other recipients of the Work or Derivative Works a copy of this License; and
+You must cause any modified files to carry prominent notices stating that You changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+END OF TERMS AND CONDITIONS
+
+License:University of Illinois/NCSA Open Source License
+Copyright (c) <Year> <Owner Organization Name> All rights reserved.
+Developed by:
+ <Name of Development Group> <Name of Institution> <URL for Development Group/Institution>
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal with the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+•	Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers.
+•	Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution.
+•	Neither the names of <Name of Development Group, Name of Institution>, nor the names of its contributors may be used to endorse or promote products derived from this Software without specific prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE.
+
+License:The MIT License
+Copyright (c) <year> <copyright holders>
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+
+Software: Android 10.0.0_r2
+
+Copyright notice:
+Copyright (c) 2005-2020, The Android Open Source Project
+
+License: Apache License V2.0
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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.
+
+THIS OFFER IS VALID FOR THREE YEARS FROM THE MOMENT WE DISTRIBUTED THE PRODUCT OR FIRMWARE.
diff --git a/samples/exceptiontest/Arith.java b/samples/exceptiontest/Arith.java
new file mode 100644
index 0000000000000000000000000000000000000000..893f452074a96f9251f8ab6b01bcd83050f361ce
--- /dev/null
+++ b/samples/exceptiontest/Arith.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+public class Arith {
+    private static native void raise_sigfpe();
+
+    public static int TestMain( int c ) {
+        int r = 0;
+        try {
+            r += 1;
+            if( c > 0 )
+                raise_sigfpe();
+            else if ( c == 0 ) {
+                r += 103;
+                throw new ArithmeticException();
+            }
+            r += 3;
+        } catch( ArithmeticException e ) {
+            r += 100;
+        }
+        return r;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(TestMain(-5));
+        System.out.println(TestMain(0));
+    }
+}
diff --git a/samples/exceptiontest/Makefile b/samples/exceptiontest/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..061f116d0a5cfb94e95955f707fea94fe505daf0
--- /dev/null
+++ b/samples/exceptiontest/Makefile
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+APP = Arith
+include $(MAPLE_BUILD_CORE)/maple_test.mk
diff --git a/samples/helloworld/HelloWorld.java b/samples/helloworld/HelloWorld.java
new file mode 100644
index 0000000000000000000000000000000000000000..a002960377e6d7728decb9f111625bc301e864e4
--- /dev/null
+++ b/samples/helloworld/HelloWorld.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+public class HelloWorld {
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+    }
+}
+
diff --git a/samples/helloworld/Makefile b/samples/helloworld/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..77580165d82941ec9b348ed15fed0ce311721b58
--- /dev/null
+++ b/samples/helloworld/Makefile
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+APP = HelloWorld
+include $(MAPLE_BUILD_CORE)/maple_test.mk
diff --git a/samples/iteratorandtemplate/IteratorAndTemplateTest.java b/samples/iteratorandtemplate/IteratorAndTemplateTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb0cd3f3b6186b0414e4585cbbb91c568dacc0fb
--- /dev/null
+++ b/samples/iteratorandtemplate/IteratorAndTemplateTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.util.*;
+public class IteratorAndTemplateTest {
+    public static void main(String args[]) {
+        testIterator();
+        testTemplate();
+    }
+
+    public static void testIterator(){
+        AbstractCollection<String> l = new ArrayList<String>();
+        l.add(new String("Hello"));
+        l.add(new String(" World"));
+        System.out.println(l.size());
+        System.out.println(l.toString());
+    }
+
+    public static void testTemplate(){
+        List<Integer> wholeChain = new ArrayList<Integer>();
+        wholeChain.add(1);
+        wholeChain.add(2);
+        for (Integer i : wholeChain) {
+            System.out.println(i);
+        }
+    }
+}
+
diff --git a/samples/iteratorandtemplate/Makefile b/samples/iteratorandtemplate/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..93802205e8ac460bb8d55d927d681b8e8620b023
--- /dev/null
+++ b/samples/iteratorandtemplate/Makefile
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+APP = IteratorAndTemplateTest
+include $(MAPLE_BUILD_CORE)/maple_test.mk
diff --git a/samples/polymorphismtest/InterfaceTest.java b/samples/polymorphismtest/InterfaceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2df75fe2d722d335775ac194bff17f836b138e7b
--- /dev/null
+++ b/samples/polymorphismtest/InterfaceTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+interface Inter {
+    public default void foo() {
+        System.out.println("Inter.foo()");
+    }
+}
+
+class Base implements Inter {
+    public void foo() {
+        System.out.println("Base.foo()");
+    }
+}
+
+class Derived extends Base {
+    public void foo() {
+        System.out.println("Derived.foo()");
+    }
+}
+
+public class InterfaceTest {
+    public static void main(String[] args) {
+        Derived o1 = new Derived();
+        o1.foo();
+        Base o2 = new Derived();
+        o2.foo();
+        Inter o3 = new Derived();
+        o3.foo();
+    }
+}
diff --git a/samples/polymorphismtest/Makefile b/samples/polymorphismtest/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..aa9a53434063a40b1f813d3b244521f25c6afbbe
--- /dev/null
+++ b/samples/polymorphismtest/Makefile
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+APP = InterfaceTest
+include $(MAPLE_BUILD_CORE)/maple_test.mk
diff --git a/samples/rccycletest/Makefile b/samples/rccycletest/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..c93d70d8f68ec451b48f8eb0e5c6355106cefe81
--- /dev/null
+++ b/samples/rccycletest/Makefile
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+APP = RCCycleTest
+include $(MAPLE_BUILD_CORE)/maple_test.mk
diff --git a/samples/rccycletest/RCCycleTest.java b/samples/rccycletest/RCCycleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8794429e207e58c5ac14247c567492414da7a16
--- /dev/null
+++ b/samples/rccycletest/RCCycleTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+class Test_A {
+    Test_B bb;
+    void genCycle() {
+        Test_B b = new Test_B();
+        bb = b;
+        b.aa = this;
+    }
+}
+
+class Test_B {
+    Test_A aa;
+}
+
+public class RCCycleTest {
+    public static void main (String []args) {
+        Test_A a = new Test_A();
+        a.genCycle();
+        if (a.bb == null) {
+	        System.out.println("class B is collected");
+        } else {
+	        System.out.println("class B is not collected");
+        }
+    }
+}
diff --git a/samples/threadtest/Makefile b/samples/threadtest/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..7b98e1ec3fd25777e2a39abdb6aced671a2e6688
--- /dev/null
+++ b/samples/threadtest/Makefile
@@ -0,0 +1,16 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+APP = ThreadTest
+include $(MAPLE_BUILD_CORE)/maple_test.mk
diff --git a/samples/threadtest/ThreadTest.java b/samples/threadtest/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..522947b67468088295faba0c455f1e284d05fd02
--- /dev/null
+++ b/samples/threadtest/ThreadTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+public class ThreadTest {
+    static volatile long flag = 0L;
+    static int number = 0;
+    static class FirstThread extends Thread {
+        public void run() {
+            while(flag != Long.MAX_VALUE) {
+            }
+            System.out.println(number);
+        }
+    }
+    static class SecondThread extends Thread {
+        public void run() {
+            number = 42;
+            flag = Long.MAX_VALUE;
+        }
+    }
+
+    public static void main(String args[]) {
+        FirstThread t1 = new FirstThread();
+        SecondThread t2 = new SecondThread();
+        t1.start();
+        t2.start();
+        try {
+            t1.join();
+            t2.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE");
+        }
+        System.out.println("OK");
+    }
+}
diff --git a/src/MapleFE/.gitignore b/src/MapleFE/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..533695ff01a419af9567d36b8d2cf41970296906
--- /dev/null
+++ b/src/MapleFE/.gitignore
@@ -0,0 +1,25 @@
+output/
+*.output
+*.out
+*.bak
+*.swo
+*.swp
+*.mpl
+*.js
+*.dot
+*.png
+*.out.ts
+*.ts.ast
+*.java.ast
+gdbfile
+test/typescript/**/*.cpp
+test/typescript/**/*.h
+test/typescript/**/*.log
+test/TypeScript/
+test/msts_failed.txt
+test/msts_passed.txt
+test/typescript/ms_tests/*.ts
+test/typescript/ms_tests/LICENSE.txt
+test/typescript/unit_tests/temp.ts
+test/typescript/unit_tests/perf.data
+test/typescript/unit_tests/perf.data.old
diff --git a/src/MapleFE/Makefile b/src/MapleFE/Makefile
index c3c89b4319bc3779fa06f6319ae45d34f165095a..f1dbcac61dd5bed54e947fda4a6c6be58a2144c1 100644
--- a/src/MapleFE/Makefile
+++ b/src/MapleFE/Makefile
@@ -1,4 +1,4 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
 #
 # OpenArkFE is licensed under the Mulan PSL v2.
 # You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -14,37 +14,64 @@
 
 include Makefile.in
 
-TARGS = autogen shared recdetect ladetect java2mpl
+TARGS = autogen shared recdetect ladetect astopt java2mpl ast2mpl ts2ast ast2cpp c2ast obfuscate
 
 # create BUILDDIR first
 $(shell $(MKDIR_P) $(BUILDDIR))
 
-java2mpl: autogen recdetect ladetect shared
-	$(MAKE) LANG=java -C java
+ifeq ($(SRCLANG),java)
+  TARGET := java2ast ast2mpl
+else ifeq ($(SRCLANG),typescript)
+  TARGET := ts2ast ast2cpp obfuscate
+else ifeq ($(SRCLANG),c)
+  TARGET := c2ast
+endif
 
-recdetect: autogen shared
-	(cd recdetect; ./build.sh java)
-	(cd $(BUILDDIR)/recdetect; ./recdetect)
+all: $(TARGET)
+
+java2ast: autogen recdetect ladetect shared
+	$(MAKE) LANG=$(SRCLANG) -C $(SRCLANG)
+
+ts2ast: autogen recdetect ladetect shared
+	$(MAKE) LANG=$(SRCLANG) -C $(SRCLANG)
+
+c2ast: autogen recdetect ladetect shared astopt
+	$(MAKE) LANG=$(SRCLANG) -C $(SRCLANG)
+
+recdetect: autogen shared ladetect
+	$(MAKE) LANG=$(SRCLANG) -C recdetect
 
 ladetect: autogen shared
-	(cd ladetect; ./build.sh java)
-	(cd $(BUILDDIR)/ladetect; ./ladetect)
+	$(MAKE) LANG=$(SRCLANG) -C ladetect
+
+ast2mpl: astopt java2ast
+	$(MAKE) -C ast2mpl
+
+astopt: shared recdetect ladetect
+	$(MAKE) -C astopt
+
+ast2cpp: astopt ts2ast
+	$(MAKE) -C ast2cpp
+
+obfuscate: astopt ts2ast ast2cpp
+	$(MAKE) -C tools/obfuscate
 
 shared: autogen
-	$(MAKE) LANG=java -C shared
+	$(MAKE) -C shared
 
 autogen:
-	$(MAKE) LANG=java -C autogen
-	(cd $(BUILDDIR)/autogen; ./autogen)
+	$(MAKE) -C autogen
 
 mapleall:
 	./scripts/build_mapleall.sh
 
-test: autogen
-	$(MAKE) LANG=java -C test
+test:
+	$(MAKE) LANG=$(SRCLANG) -C test
 
-testall:
-	(cd test; ./runtests.pl all)
+testms:
+	$(MAKE) LANG=$(SRCLANG) -C test testms
+
+testall: test
 
 test1:
 	@cp test/java2mpl/t1.java .
@@ -55,12 +82,14 @@ test1:
 clean:
 	rm -rf $(BUILDDIR)
 
-clobber: clean
-	rm -rf java/include/gen_*.h java/src/gen_*.cpp ladetect/java recdetect/java
+clobber:
+	rm -rf output
+
+r: rebuild
 
 rebuild:
 	make clobber
-	make -j8
+	make -j
 
-.PHONY: $(TARGS)
+.PHONY: $(TARGS) test
 
diff --git a/src/MapleFE/Makefile.in b/src/MapleFE/Makefile.in
index 0902fbd1540ecc1bbcf4887df41e44c3f94f50d2..9ec2c1ca5240a2d01be9d271ec8a04b1c6abbcb3 100644
--- a/src/MapleFE/Makefile.in
+++ b/src/MapleFE/Makefile.in
@@ -1,17 +1,17 @@
 CXX = clang++
-CC = gcc
+CC = clang
 AR = ar rcs
 FLAVOR = gnu
 LD = clang++
 
-CXXFLAGS = -O0 -g3 -Wall -std=c++17 -DDEBUG
+CXXFLAGS = -O0 -g3 -Wall -std=c++17 -DDEBUG -fPIC
 LFLAGS=-std=c++17
+LANG=java
 
 MKDIR_P = mkdir -p
 
 MAPLELIBPATH:=$(MAPLE_ROOT)/OpenArkCompiler/output/aarch64-clang-debug/lib/64
-MAPLELIBPATH1:=$(MAPLE_ROOT)/OpenArkCompiler/output/aarch64-clang-debug/ar
-MAPLELIBS := -L $(MAPLELIBPATH) -L $(MAPLELIBPATH1) -lmplir -loption_parser -lmpl2mpl -lmplutil -lmempool -lHWSecureC -ldriver_option
+MAPLELIBS := -L $(MAPLELIBPATH) -lmplir -loption_parser -lmplphase -lmplutil -lmempool -lmpl2mpl -lHWSecureC -ldriver_option -lmplir -loption_parser -ldriver_option
 
 MAPLEALL_INC = -I $(MAPLEALL_SRC)/maple_ir/include \
 							 -I $(MAPLEALL_SRC)/mempool/include \
diff --git a/src/MapleFE/README b/src/MapleFE/README
index 5a495962a12a54b48f9929ffbba1e88b224f33e3..9446b57ff2979767e8ab7b069dae94f732af269f 100644
--- a/src/MapleFE/README
+++ b/src/MapleFE/README
@@ -28,32 +28,35 @@ have our own frontend, which could be easier to handle new languages.
 
 [Preparation]
 
-Before start building MapleFE, please download mapleall from the open ark compiler incubator,
-https://gitee.com/openarkcompiler-incubator/mapleall
-Follow the instruction of mapleall and build the necessary libraries.
-Once you are done, please update the lib and include paths in MapleFE/shared/src/Makefile accordingly.
+https://gitee.com/openarkcompiler/OpenArkCompiler/blob/master/doc/en/DevelopmentPreparation.md
+Follow the instruction in "Recommended Development Environment" section to get tools installed
+
+The following packages also need to be installed:
+```bash
+sudo apt install -y clang-tools-10 clang-format-10 python3 python3-pip libyaml-cpp-dev nodejs npm
+pip3 install pyyaml
+sudo npm install -g typescript@latest
+```
 
 [How to build]
 
-1. source envsetup.sh
-2. make mapleall.
+1. source envsetup.sh [java|typescript]
+2. make mapleall
    This step is to build mapleall (Maple IR related libraries). If you have done it once,
    you dont need do it again unless you changed the code in mapleall.
 3. make
-4. If you are working at Java frontend, you will see output/java/java2mpl. This is the executable
+4. If you are working at Java frontend, you will see output/java/java/java2mpl. This is the executable
    frontend.
+4. If you are working at Typescript frontend, you will see output/typescript/bin/ts2ast. This is the executable
+   frontend. You can also see output/typescript/bin/ast2cpp, which translate AST to cpp source code.
 
 [How to test]
 
-1. cd test
-2. ./runtests.pl all
-
-or
-1. make testall
+1. make test
 
 run a single test, say t1.java:
 1. cd test
 2. make t1
 
-You can find all Java test cases in test/java2mpl. Right now only java test cases
-are used.
+You can find all Java test cases in test/java.
+You can find all Typescript test cases in test/typescript.
diff --git a/src/MapleFE/TODO b/src/MapleFE/TODO
new file mode 100644
index 0000000000000000000000000000000000000000..a24e602d81cb144fd26df0dec6da3ddad3914cc7
--- /dev/null
+++ b/src/MapleFE/TODO
@@ -0,0 +1,4 @@
+1. Implement language specific lexer through overriding. Right now some functions are in shared lexer
+   template literal related code
+2. Implement language specific through overriding. Right now semi-coloning skipping is in shared parser.
+   See code in Parser::TraverseToken()
diff --git a/src/MapleFE/ast2cpp/Makefile b/src/MapleFE/ast2cpp/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..34428253a1698e6d7154d16969f3816729268ebf
--- /dev/null
+++ b/src/MapleFE/ast2cpp/Makefile
@@ -0,0 +1,27 @@
+# Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
+include ../Makefile.in
+
+all:
+	$(MAKE) -C src
+
+clean:
+	rm -rf $(BUILDDIR)/ast2cpp
+
+test:
+	$(MAKE) -C ../test p
+
+.PHONY: $(TARGS)
+
diff --git a/src/MapleFE/ast2cpp/README.md b/src/MapleFE/ast2cpp/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/MapleFE/ast2cpp/include/a2c_util.h b/src/MapleFE/ast2cpp/include/a2c_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ec86c37a25dcc7ed52239d67e1fea36dad3227f
--- /dev/null
+++ b/src/MapleFE/ast2cpp/include/a2c_util.h
@@ -0,0 +1,45 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+//                This is the interface to translate AST to C++
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __A2C_UTIL_HEADER__
+#define __A2C_UTIL_HEADER__
+
+#include <vector>
+#include <string>
+#include "gen_astvisitor.h"
+
+namespace maplefe {
+
+//  To collect all filenames for imported modules
+class ImportedFiles : public AstVisitor {
+  public:
+    ModuleNode              *mModule;
+    std::vector<std::string> mFilenames;
+  public:
+    ImportedFiles(ModuleNode *m) : mModule(m) {}
+
+    // A helper function to get the target filename of an ImportNode
+    std::string GetTargetFilename(TreeNode *node);
+
+    ImportNode *VisitImportNode(ImportNode *node);
+    ExportNode *VisitExportNode(ExportNode *node);
+};
+
+}
+#endif
diff --git a/src/MapleFE/ast2cpp/include/ast2cpp.h b/src/MapleFE/ast2cpp/include/ast2cpp.h
new file mode 100644
index 0000000000000000000000000000000000000000..9687592f296f1a5c117f3dab2a54a4164bff7b09
--- /dev/null
+++ b/src/MapleFE/ast2cpp/include/ast2cpp.h
@@ -0,0 +1,62 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+//                This is the interface to translate AST to C++
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __AST2CPP_HEADER__
+#define __AST2CPP_HEADER__
+
+#include "astopt.h"
+#include "ast_handler.h"
+#include "ast_module.h"
+
+namespace maplefe {
+
+class A2C : public AstOpt {
+private:
+  AST_Handler *mASTHandler;
+  unsigned     mFlags;
+  unsigned     mIndexImported;
+
+public:
+  explicit A2C(AST_Handler *h, unsigned flags) :
+    AstOpt(h, flags),
+    mASTHandler(h),
+    mFlags(flags),
+    mIndexImported(0) {}
+  ~A2C() = default;
+
+  void EmitTS();
+  bool LoadImportedModules();
+
+  // return 0 if successful
+  // return non-zero if failed
+  int ProcessAST();
+};
+
+class CppHandler {
+private:
+  AST_Handler *mASTHandler;
+  unsigned     mFlags;
+
+public:
+  CppHandler(AST_Handler *h, unsigned f) : mASTHandler(h), mFlags(f) {}
+  bool EmitCxxFiles();
+};
+
+}
+#endif
diff --git a/src/MapleFE/ast2cpp/include/cpp_declaration.h b/src/MapleFE/ast2cpp/include/cpp_declaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..352a0006bc51c858d06c97b5bd1a24562cb4e327
--- /dev/null
+++ b/src/MapleFE/ast2cpp/include/cpp_declaration.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __CPPDECL_HEADER__
+#define __CPPDECL_HEADER__
+
+#include <set>
+#include "ast_handler.h"
+#include "cpp_emitter.h"
+
+namespace maplefe {
+
+class CppDecl : public CppEmitter {
+private:
+  std::set<std::string> mImportedModules;
+  std::string           mDefinitions;
+  std::string           mInits;
+
+public:
+  CppDecl(Module_Handler *h) : CppEmitter(h) {}
+  CppDecl() : CppDecl(nullptr) {}
+
+  std::string Emit() {
+    return EmitTreeNode(GetASTModule());
+  }
+
+  void AddImportedModule(const std::string& module);
+  bool IsImportedModule(const std::string& module);
+
+  void AddDefinition(const std::string& def) { mDefinitions += def; }
+  std::string GetDefinitions() { return mDefinitions; }
+  void AddInit(const std::string& init) { mInits += init; }
+  std::string GetInits() { return mInits; }
+
+  std::string EmitUserTypeNode(UserTypeNode *node) override;
+  std::string EmitBinOperatorNode(BinOperatorNode *node) override;
+  std::string EmitIdentifierNode(IdentifierNode *node) override;
+  std::string EmitDeclNode(DeclNode *node) override;
+  std::string EmitFieldNode(FieldNode *node) override;
+  std::string EmitArrayLiteralNode(ArrayLiteralNode *node) override;
+  std::string EmitCondBranchNode(CondBranchNode *node) override;
+  std::string EmitForLoopNode(ForLoopNode *node) override;
+  std::string EmitWhileLoopNode(WhileLoopNode *node) override;
+  std::string EmitDoLoopNode(DoLoopNode *node) override;
+  std::string EmitAssertNode(AssertNode *node) override;
+  std::string EmitCallNode(CallNode *node) override;
+  std::string EmitFunctionNode(FunctionNode *node) override;
+  std::string EmitPrimTypeNode(PrimTypeNode *node) override;
+  std::string EmitModuleNode(ModuleNode *node) override;
+  std::string EmitClassNode(ClassNode *node) override;
+
+  std::string EmitNumIndexSigNode(NumIndexSigNode *node) override;
+  std::string EmitStrIndexSigNode(StrIndexSigNode *node) override;
+
+  std::string EmitNewNode(NewNode *node) override;
+  std::string EmitStructNode(StructNode *node) override;
+  std::string EmitTypeAliasNode(TypeAliasNode* node) override;
+  std::string EmitLiteralNode(LiteralNode* node) override;
+  std::string EmitArrayTypeNode(ArrayTypeNode *node) override;
+
+  std::string GetTypeString(TreeNode *node, TreeNode *child = nullptr);
+  std::string EmitTSEnum(StructNode *node);
+  std::string EmitInterface(StructNode *node);
+
+  void CollectFuncArgInfo(TreeNode* node);
+  std::string ConstructArray(ArrayLiteralNode* node, int dim, std::string type);
+  std::string ConstructArrayAny(ArrayLiteralNode* node);
+};
+
+inline bool IsVarInitStructLiteral(DeclNode* node) {
+  return node->GetInit() &&
+         node->GetInit()->IsTypeIdClass() &&
+         node->GetInit()->IsStructLiteral();
+}
+
+inline bool IsVarInitClass(DeclNode* node) {
+  return node->GetInit() &&
+         node->GetInit()->IsTypeIdClass() &&
+         node->GetInit()->IsIdentifier();
+}
+
+template <class T>
+bool HasAttrStatic(T* node) {
+  for (unsigned i = 0; i < node->GetAttrsNum(); ++i) {
+    std::string s = Emitter::GetEnumAttrId(node->GetAttrAtIndex(i));
+    if (s.compare("static ") == 0)
+      return true;
+  }
+  return false;
+}
+
+} // namespace maplefe
+#endif
diff --git a/src/MapleFE/ast2cpp/include/cpp_definition.h b/src/MapleFE/ast2cpp/include/cpp_definition.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab4c1b077356d1a8b6d1ac7f80797a6e58a25583
--- /dev/null
+++ b/src/MapleFE/ast2cpp/include/cpp_definition.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __CPPDEFINITIONEMITTER_HEADER__
+#define __CPPDEFINITIONEMITTER_HEADER__
+
+#include "ast_handler.h"
+#include "cpp_emitter.h"
+#include "cpp_declaration.h"
+
+namespace maplefe {
+
+class CppDef : public CppEmitter {
+public:
+  CppDecl        &mCppDecl;
+  bool            mIsInit;
+  bool            mIsGenerator;
+
+  CppDef(Module_Handler *h, CppDecl &d) : CppEmitter(h), mCppDecl(d), mIsInit(false), mIsGenerator(false) {}
+
+  std::string Emit() {
+    return EmitTreeNode(GetASTModule());
+  }
+
+  std::string EmitIdentifierNode(IdentifierNode *node) override;
+  std::string EmitImportNode(ImportNode *node) override;
+  std::string EmitXXportAsPairNode(XXportAsPairNode *node) override;
+  std::string EmitExportNode(ExportNode *node) override;
+  std::string EmitUnaOperatorNode(UnaOperatorNode *node) override;
+  std::string EmitBinOperatorNode(BinOperatorNode *node) override;
+  std::string EmitBlockNode(BlockNode *node) override;
+  std::string EmitDeclNode(DeclNode *node) override;
+  std::string EmitFieldNode(FieldNode *node) override;
+  std::string EmitArrayLiteralNode(ArrayLiteralNode *node) override;
+  std::string EmitTemplateLiteralNode(TemplateLiteralNode *node) override;
+  std::string EmitLiteralNode(LiteralNode *node) override;
+  std::string EmitCondBranchNode(CondBranchNode *node) override;
+  std::string EmitBreakNode(BreakNode *node) override;
+  std::string EmitContinueNode(ContinueNode *node) override;
+  std::string EmitForLoopNode(ForLoopNode *node) override;
+  std::string EmitSwitchNode(SwitchNode *node) override;
+  std::string EmitCallNode(CallNode *node) override;
+  std::string EmitFunctionNode(FunctionNode *node) override;
+  std::string EmitTypeOfNode(TypeOfNode *node) override;
+  std::string EmitModuleNode(ModuleNode *node) override;
+  std::string EmitPrimTypeNode(PrimTypeNode *node) override;
+  std::string EmitPrimArrayTypeNode(PrimArrayTypeNode *node) override;
+  std::string EmitNewNode(NewNode *node) override;
+  std::string EmitArrayElementNode(ArrayElementNode *node) override;
+  std::string EmitTypeAliasNode(TypeAliasNode* node) override;
+  std::string EmitInstanceOfNode(InstanceOfNode *node) override;
+  std::string EmitDeclareNode(DeclareNode *node) override;
+  std::string EmitAsTypeNode(AsTypeNode *node) override;
+  std::string EmitNamespaceNode(NamespaceNode *node) override;
+  std::string EmitRegExprNode(RegExprNode *node);
+  std::string EmitStructNode(StructNode *node) override;
+  std::string EmitStructLiteralNode(StructLiteralNode* node) override;
+  std::string EmitWhileLoopNode(WhileLoopNode *node) override;
+  std::string EmitYieldNode(YieldNode *node) override;
+  std::string& HandleTreeNode(std::string &str, TreeNode *node) override;
+
+  std::string EmitClassProps(TreeNode *node);
+  std::string EmitFuncScopeVarDecls(FunctionNode *node);
+  std::string EmitCppCtor(ClassNode* node);
+  std::string EmitCtorInstance(ClassNode *c);
+  std::string EmitDefaultCtor(ClassNode *c);
+  std::string EmitBracketNotationProp(ArrayElementNode* ae, OprId binOpId, bool isLhs, bool& isDynProp);
+  TypeId GetTypeIdFromDecl(TreeNode* id);
+  bool   IsClassField(ArrayElementNode* node, std::string propKey);
+  std::string GetTypeForTemplateArg(TreeNode* node);
+  TreeNode*   FindDeclType(TreeNode* node);
+  std::string GetThisParamObjType(TreeNode *node);
+
+  std::string ConstructArray(ArrayLiteralNode* node, int dim, std::string type);
+  std::string ConstructArrayAny(ArrayLiteralNode* node);
+  std::string GenObjectLiteral(TreeNode* var, std::string varName, TreeNode* idType, StructLiteralNode* n);
+  std::string GenDirectFieldInit(std::string varName, StructLiteralNode* node);
+};
+
+} // namespace maplefe
+#endif
diff --git a/src/MapleFE/ast2cpp/include/cpp_emitter.h b/src/MapleFE/ast2cpp/include/cpp_emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec2f269dba259ae718c2db3d18ca98b74b05c500
--- /dev/null
+++ b/src/MapleFE/ast2cpp/include/cpp_emitter.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __CPPEMITTER_HEADER__
+#define __CPPEMITTER_HEADER__
+
+#include "ast_module.h"
+#include "emitter.h"
+
+namespace maplefe {
+
+// Class CppEmitter includes all functionalities which are common for Cpp definition and declaration
+class CppEmitter : public Emitter {
+
+public:
+  CppEmitter(Module_Handler *h) : Emitter(h) {}
+
+  std::string GetIdentifierName(TreeNode *node);
+  bool IsInNamespace(TreeNode *node);
+  std::string GetNamespace(TreeNode *node);
+  std::string GetQualifiedName(IdentifierNode *node);
+  bool IsClassId(TreeNode *node);
+  bool IsVarTypeClass(TreeNode* var);
+  void InsertEscapes(std::string& str);
+  bool IsGenerator(TreeNode *node);
+  FunctionNode* GetGeneratorFunc(TreeNode *node);
+  void GetArrayTypeInfo(ArrayLiteralNode* node, int& numDim, std::string& type);
+  std::string FunctionHeader(FunctionNode* node, std::string retType);
+  std::string GetClassName(TreeNode* node);
+};
+
+} // namespace maplefe
+#endif
diff --git a/src/MapleFE/ast2cpp/include/emitter.h b/src/MapleFE/ast2cpp/include/emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8447db75616fe3886cdee9d83e863082a074955
--- /dev/null
+++ b/src/MapleFE/ast2cpp/include/emitter.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __EMITTER_HEADER__
+#define __EMITTER_HEADER__
+
+#include "ast.h"
+#include "ast_attr.h"
+#include "ast_module.h"
+#include "ast_type.h"
+
+#include "ast_handler.h"
+#include "gen_astdump.h"
+using namespace std::string_literals;
+
+namespace maplefe {
+
+class Emitter {
+
+protected:
+  using Precedence = unsigned char;
+  Precedence mPrecedence;
+
+  Module_Handler *mHandler;
+
+public:
+  Emitter(Module_Handler *h) : mHandler(h) {}
+
+  std::string Emit(const char *title);
+  std::string GetEnding(TreeNode *n);
+  std::string Clean(std::string &s);
+  std::string GetBaseFilename();
+  std::string GetModuleName(const char *p = nullptr);
+  std::string GetModuleName(TreeNode *node);
+
+  Module_Handler *GetModuleHandler() { return mHandler; }
+  ModuleNode *GetASTModule() { return mHandler->GetASTModule(); }
+
+  virtual std::string EmitAnnotationNode(AnnotationNode *node);
+  virtual std::string EmitAsTypeNode(AsTypeNode *node);
+  virtual std::string EmitIdentifierNode(IdentifierNode *node);
+  virtual std::string EmitFunctionNode(FunctionNode *node);
+  virtual std::string EmitUserTypeNode(UserTypeNode *node);
+  virtual std::string EmitComputedNameNode(ComputedNameNode *node);
+  virtual std::string EmitPackageNode(PackageNode *node);
+  virtual std::string EmitXXportAsPairNode(XXportAsPairNode *node);
+  virtual std::string EmitDeclareNode(DeclareNode *node);
+  virtual std::string EmitExportNode(ExportNode *node);
+  virtual std::string EmitImportNode(ImportNode *node);
+  virtual std::string EmitUnaOperatorNode(UnaOperatorNode *node);
+  virtual std::string EmitBinOperatorNode(BinOperatorNode *node);
+  virtual std::string EmitTerOperatorNode(TerOperatorNode *node);
+  virtual std::string EmitTypeAliasNode(TypeAliasNode *node);
+  virtual std::string EmitConditionalTypeNode(ConditionalTypeNode *node);
+  virtual std::string EmitTypeParameterNode(TypeParameterNode *node);
+  virtual std::string EmitBlockNode(BlockNode *node);
+  virtual std::string EmitNewNode(NewNode *node);
+  virtual std::string EmitDeleteNode(DeleteNode *node);
+  virtual std::string EmitAnnotationTypeNode(AnnotationTypeNode *node);
+  virtual std::string EmitDimensionNode(DimensionNode *node);
+  virtual std::string EmitDeclNode(DeclNode *node);
+  virtual std::string EmitCastNode(CastNode *node);
+  virtual std::string EmitParenthesisNode(ParenthesisNode *node);
+  virtual std::string EmitFieldNode(FieldNode *node);
+  virtual std::string EmitArrayElementNode(ArrayElementNode *node);
+  virtual std::string EmitArrayLiteralNode(ArrayLiteralNode *node);
+  virtual std::string EmitBindingElementNode(BindingElementNode *node);
+  virtual std::string EmitBindingPatternNode(BindingPatternNode *node);
+  virtual std::string EmitNumIndexSigNode(NumIndexSigNode *node);
+  virtual std::string EmitStrIndexSigNode(StrIndexSigNode *node);
+  virtual std::string EmitStructNode(StructNode *node);
+  virtual std::string EmitFieldLiteralNode(FieldLiteralNode *node);
+  virtual std::string EmitStructLiteralNode(StructLiteralNode *node);
+  virtual std::string EmitNamespaceNode(NamespaceNode *node);
+  virtual std::string EmitVarListNode(VarListNode *node);
+  virtual std::string EmitExprListNode(ExprListNode *node);
+  virtual std::string EmitTemplateLiteralNode(TemplateLiteralNode *node);
+  virtual std::string EmitLiteralNode(LiteralNode *node);
+  virtual std::string EmitRegExprNode(RegExprNode *node);
+  virtual std::string EmitThrowNode(ThrowNode *node);
+  virtual std::string EmitCatchNode(CatchNode *node);
+  virtual std::string EmitFinallyNode(FinallyNode *node);
+  virtual std::string EmitTryNode(TryNode *node);
+  virtual std::string EmitExceptionNode(ExceptionNode *node);
+  virtual std::string EmitReturnNode(ReturnNode *node);
+  virtual std::string EmitYieldNode(YieldNode *node);
+  virtual std::string EmitCondBranchNode(CondBranchNode *node);
+  virtual std::string EmitBreakNode(BreakNode *node);
+  virtual std::string EmitContinueNode(ContinueNode *node);
+  virtual std::string EmitForLoopNode(ForLoopNode *node);
+  virtual std::string EmitWhileLoopNode(WhileLoopNode *node);
+  virtual std::string EmitDoLoopNode(DoLoopNode *node);
+  virtual std::string EmitSwitchLabelNode(SwitchLabelNode *node);
+  virtual std::string EmitSwitchCaseNode(SwitchCaseNode *node);
+  virtual std::string EmitSwitchNode(SwitchNode *node);
+  virtual std::string EmitAssertNode(AssertNode *node);
+  virtual std::string EmitCallNode(CallNode *node);
+  virtual std::string EmitInterfaceNode(InterfaceNode *node);
+  virtual std::string EmitClassNode(ClassNode *node);
+  virtual std::string EmitPassNode(PassNode *node);
+  virtual std::string EmitLambdaNode(LambdaNode *node);
+  virtual std::string EmitInstanceOfNode(InstanceOfNode *node);
+  virtual std::string EmitTypeOfNode(TypeOfNode *node);
+  virtual std::string EmitKeyOfNode(KeyOfNode *node);
+  virtual std::string EmitInferNode(InferNode *node);
+  virtual std::string EmitInNode(InNode *node);
+  virtual std::string EmitIsNode(IsNode *node);
+  virtual std::string EmitAwaitNode(AwaitNode *node);
+  virtual std::string EmitNameTypePairNode(NameTypePairNode *node);
+  virtual std::string EmitTupleTypeNode(TupleTypeNode *node);
+  virtual std::string EmitTripleSlashNode(TripleSlashNode *node);
+  virtual std::string EmitModuleNode(ModuleNode *node);
+  virtual std::string EmitAttrNode(AttrNode *node);
+  virtual std::string EmitArrayTypeNode(ArrayTypeNode *node);
+  virtual std::string EmitFunctionTypeNode(FunctionTypeNode *node);
+  virtual std::string EmitPrimTypeNode(PrimTypeNode *node);
+  virtual std::string EmitPrimArrayTypeNode(PrimArrayTypeNode *node);
+
+  virtual std::string EmitTreeNode(TreeNode *node);
+  virtual std::string& HandleTreeNode(std::string &str, TreeNode *node);
+
+  static void Replace(std::string &str, const char *o, const char *n, int cnt = 0);
+  static std::string GetEnumTypeId(TypeId k);
+  //static const char *GetEnumSepId(SepId k);
+  static const char *GetEnumOprId(OprId k);
+  //static const char *GetEnumLitId(LitId k);
+  static std::string GetEnumAttrId(AttrId k);
+  //static const char *GetEnumImportProperty(ImportProperty k);
+  //static const char *GetEnumOperatorProperty(OperatorProperty k);
+  static std::string GetEnumDeclProp(DeclProp k);
+  //static const char *GetEnumStructProp(StructProp k);
+  //static const char *GetEnumForLoopProp(ForLoopProp k);
+  //static const char *GetEnumLambdaProperty(LambdaProperty k);
+  const char *GetEnumTripleSlashProp(TripleSlashProp k);
+  std::string &AddParentheses(std::string &str, TreeNode *node);
+
+};
+
+} // namespace maplefe
+#endif
diff --git a/src/MapleFE/ast2cpp/include/helper.h b/src/MapleFE/ast2cpp/include/helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..0eb8e89843ecb23e65507e68955a116bbc319deb
--- /dev/null
+++ b/src/MapleFE/ast2cpp/include/helper.h
@@ -0,0 +1,143 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __HELPER_H__
+#define __HELPER_H__
+
+#include <unordered_map>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <set>
+#include "massert.h"
+#include "ast.h"
+#include "typetable.h"
+#include "emitter.h"
+
+using namespace std::string_literals;
+
+namespace maplefe {
+extern std::string GeneratorFn_start;
+extern std::string GeneratorFn_return;
+
+extern std::unordered_map<TypeId, std::string>TypeIdToJSType;
+extern std::unordered_map<TypeId, std::string>TypeIdToJSTypeCXX;
+extern TypeId hlpGetTypeId(TreeNode* node);
+extern std::string GenClassFldAddProp(std::string, std::string, std::string, std::string, std::string);
+extern std::string FunctionClassDecl(std::string retType, std::string funcName, unsigned nodeId);
+extern std::string GeneratorClassDecl(std::string funcName, unsigned nodeId);
+extern std::string GeneratorClassDef(std::string ns, std::string funcName, unsigned nodeId);
+extern std::string tab(int n);
+extern bool IsClassMethod(TreeNode* node);
+extern std::string GetClassOfAssignedFunc(TreeNode* node);
+extern std::string GenAnonFuncName(TreeNode* node);
+inline std::string ClsName(std::string func) { return "Cls_"s + func; }
+inline std::string GeneratorName(std::string func) { return "Generator_"s + func; }
+inline std::string GeneratorFuncName(std::string func) { return "GeneratorFunc_"s + func; }
+extern std::string hlpGetJSValTypeStr(TypeId typeId);
+extern std::string ArrayCtorName(int dim, std::string type);
+extern bool IsBuiltinObj(std::string name);
+extern std::string ObjectTypeStr(std::string name);
+extern std::string GeneratorFuncHeader(std::string cls, unsigned nodeId);
+extern std::string FunctionParams(unsigned nodeId, bool handleThis, bool argsOnly = false, bool byRef = false, bool fdInit = false, bool capture = false);
+
+class GeneratorLabels {
+private:
+  unsigned GenLoopId = 0;
+  unsigned GenYieldId= 0;
+public:
+  std::string NextLoopLabel(void) {
+    std::string label = "_loop_" + std::to_string(++GenLoopId);
+    return label;
+  }
+  std::string NextYieldLabel(void) {
+    std::string label = "_yield_" + std::to_string(++GenYieldId);
+    return label;
+  }
+  void ResetLabels(void) {
+    GenLoopId  = 0;
+    GenYieldId = 0;
+  }
+};
+
+class FuncTable {
+private:
+  std::unordered_map<unsigned, TreeNode*> TopLevelFunc; // map nodeId to TreeNode*
+  std::set<std::string> TopLevelFuncNm;   // name of top level func or name of var assigned top level func
+  std::set<std::string> ImportedFields;
+  std::set<std::string> StaticMembers;
+
+  // map of FunctionNode node id to vector of function arg info (pair of arg type and name)
+  std::unordered_map<unsigned, std::vector<std::pair<std::string, std::string>>> args;
+
+public:
+  FuncTable() {}
+  ~FuncTable() {}
+
+  // Check if node is top level function
+  void AddTopLevelFunc(TreeNode* node) {
+    assert(node->IsFunction());
+    if (!static_cast<FunctionNode*>(node)->IsConstructor())
+      TopLevelFunc[node->GetNodeId()] = node;
+  }
+  bool IsTopLevelFunc(TreeNode* node) {
+    assert(node->IsFunction());
+    std::unordered_map<unsigned, TreeNode*>::iterator it;
+    it = TopLevelFunc.find(node->GetNodeId());
+    return(it != TopLevelFunc.end());
+  }
+
+  // Check if name is top level func
+  void AddNameIsTopLevelFunc(std::string name) {
+    TopLevelFuncNm.insert(name); // name can be 1st level func, or func typed var
+  }
+  bool IsTopLevelFuncName(std::string& name) {
+    return(TopLevelFuncNm.find(name) != TopLevelFuncNm.end());
+  }
+
+  // Check if string (xxx::yyy) is an Imported field
+  std::string& AddFieldIsImported(std::string field) {
+    ImportedFields.insert(field);
+    return(field);
+  }
+  bool IsImportedField(std::string& field) {
+    return(ImportedFields.find(field) != ImportedFields.end());
+  }
+
+  // Check if a class member (field or method) is static
+  std::string& AddMemberIsStatic(std::string field) {
+    StaticMembers.insert(field);
+    return(field);
+  }
+  bool IsStaticMember(std::string& field) {
+    return(StaticMembers.find(field) != StaticMembers.end());
+  }
+
+  // Function arg info
+  void AddArgInfo(unsigned nodeId, std::string type, std::string name) {
+    args[nodeId].push_back(std::pair(type, name));
+  }
+  std::vector<std::pair<std::string, std::string>> GetArgInfo(unsigned nodeId) {
+    return args[nodeId];
+  }
+
+};
+
+extern FuncTable hFuncTable;
+extern GeneratorLabels GenFnLabels;
+
+}
+#endif  // __HELPER_H__
+
diff --git a/src/MapleFE/ast2cpp/runtime/include/builtins.h b/src/MapleFE/ast2cpp/runtime/include/builtins.h
new file mode 100644
index 0000000000000000000000000000000000000000..af0fe8f50dd34f39cf5912d7ed54593be4ce5748
--- /dev/null
+++ b/src/MapleFE/ast2cpp/runtime/include/builtins.h
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __BUILTINS_H__
+#define __BUILTINS_H__
+
+#include <sstream>
+
+namespace t2crt {
+
+template <typename T1, typename T2>
+class Record : public Object {
+  public:
+    std::unordered_map<T1, T2> records;
+    Record() {}
+    ~Record() {}
+    Record(Function* ctor, Object* proto) : Object(ctor, proto) {}
+    Record(Function* ctor, Object* proto, std::vector<ObjectProp> props) : Object(ctor, proto, props) {}
+};
+
+template <typename T>
+class Array : public Object {
+  public:
+    std::vector<T> elements;
+    Array(Function* ctor, Object* proto): Object(ctor, proto) {}
+    Array(Function* ctor, Object* proto, std::initializer_list<T> l): Object(ctor, proto), elements(l) {}
+
+    T& operator[](int i) {return elements[i];}
+    void operator = (const std::vector<T> &v) { elements = v; }
+    long size() { return elements.size(); }
+
+    // Output array to string (recurses if multi-dim array via ostream output operator overload in t2cpp.cpp)
+    std::string Dump (void) override {
+      std::stringstream ss;
+      std::streambuf* old = std::cout.rdbuf(ss.rdbuf());
+      if (elements.empty())
+        std::cout << "[]";
+      else {
+        std::cout << "[ ";
+        auto i = elements.begin(), e = elements.end();
+        std::cout << *i++;
+        for (; i != e; ++i)
+          std::cout << ", " << *i;
+        std::cout << " ]";
+      }
+      std::cout.rdbuf(old);
+      return ss.str();
+    }
+
+    // Put JS Array.prototype props as static fields and methods in this class
+    // and add to proplist of Array_ctor.prototype object on system init.
+
+    class Ctor: public Function {
+    public:
+      Ctor(Function* ctor, Object* proto, Object* prototype_proto) : Function(ctor, proto, prototype_proto) {}
+      Array<T>* _new() {
+        return new Array<T>(this, this->prototype);
+      }
+      Array<T>* _new(std::initializer_list<T>l) {
+        return new Array<T>(this, this->prototype, l);
+      }
+    };
+    static Ctor ctor;
+};
+
+// Create ctor func for 1,2,3 dimension array of given type
+// note: must be in sync with format generated by ArrayCtorName in helper.h
+#define ARR_CTOR_DEF(type) \
+  template <> \
+  Array<type>::Ctor                 Array<type>::ctor = Array<type>::Ctor(&Function::ctor, Function::ctor.prototype, Object::ctor.prototype); \
+  template <> \
+  Array<Array<type>*>::Ctor         Array<Array<type>*>::ctor = Array<Array<type>*>::Ctor(&Function::ctor, Function::ctor.prototype, Object::ctor.prototype); \
+  template <> \
+  Array<Array<Array<type>*>*>::Ctor Array<Array<Array<type>*>*>::ctor = Array<Array<Array<type>*>*>::Ctor(&Function::ctor, Function::ctor.prototype, Object::ctor.prototype);
+
+class JSON : public Object {
+  // TODO
+};
+
+class RegExp : public Object {
+  // TODO
+public:
+  RegExp(Function* ctor, Object* proto): Object(ctor, proto) { }
+  RegExp(Function* ctor, Object* proto, std::string src): Object(ctor, proto) {  source = src; }
+  ~RegExp(){}
+  std::string source;               // text of the pattern
+  std::string Dump(void) override { return source; }
+
+  class Ctor : public Function {
+  public:
+    Ctor(Function* ctor, Object* proto, Object* prototype_proto) : Function(ctor, proto, prototype_proto) { }
+    RegExp* _new(std::string src) {return new RegExp(this, this->prototype, src);}
+    virtual const char* __GetClassName() const {return "RegExp ";}
+  };
+  static Ctor ctor;
+};
+
+class Number : public Object {
+public:
+  // TODO
+  class Ctor : public Function {
+  public:
+    Ctor(Function* ctor, Object* proto, Object* prototype_proto) : Function(ctor, proto, prototype_proto) { }
+    virtual const char* __GetClassName() const {return "Number ";}
+  };
+  static Ctor ctor;
+};
+
+
+// 20.5 Error objects for execptions
+class Error : public Object {
+  // TODO
+};
+
+// JavaScript generators and generator functions
+// - The builtin GeneratorFunction is the constructor for all generator functions.
+// - Generator functions are called directly to return generators (with closure).
+// - Generators are iterators that calls corresponding generator function with
+//   data captured in closure to iterate for results.
+
+// ecma-262 section references are based on ecma-262 edition 12.0
+
+// ecma262 27.1.1.5 IteratorResult interface:
+struct IteratorResult : public Object {
+  bool   done;  // status of iterator next() call
+  JS_Val value; // done=false: current iteration element value
+                // done=true:  return value of the iterator, undefined if none returned
+  IteratorResult() : done(true), value(undefined) {
+    this->AddProp("done",  t2crt::ClassFld<bool   IteratorResult::*>(&IteratorResult::done).NewProp(this, t2crt::TY_CXX_Bool));
+    this->AddProp("value", t2crt::ClassFld<JS_Val IteratorResult::*>(&IteratorResult::value).NewProp(this, t2crt::TY_CXX_Any));
+  }
+  IteratorResult(bool done, JS_Val val) : done(done), value(val) { }
+  ~IteratorResult() { }
+};
+
+// ecma262 27.1.1.1 Iterable interface:
+// To be iterable, an object or one of the objects up its prototype chain must
+// have a property with a @@iterator key (<obj>[Symbol.iterator], the value of
+// which is a function that returns iterators (i.e objects with Iterator interace
+// methods next/return/throw).
+//
+// Note: For iterable objects such as arrays and strings, <obj>[Symbol.iterator]()
+// returns a new iteraor object. But for the intrinsic object %IteratorPrototype%
+// (27.1.2.1) it returns the current iterator instance, which
+// means for all iterators, <obj>[Sumbol.iterator]() returns itself.
+
+// ecma262 27.1.2.1 %IteratorPrototype%:
+// 1) All objects that implement iterator interface also inherit from %IteratorPrototype%
+// 2) %IteratorPrototype% provides shared props for all iterator objects
+// 3) %IteratorPrototype%[Symbol.iterator]() = this (current iterator instance) - used in for loops
+class IteratorProto : public Object {
+public:
+  IteratorResult _res;
+  IteratorProto(Function* ctor, Object* proto) : Object(ctor, proto) { }
+  ~IteratorProto() { }
+  // note: the arg on an iterator's 1st next() call is ignored per spec 27.5.1.2
+  virtual IteratorResult* next  (JS_Val* arg = nullptr) { return &_res; }
+  virtual IteratorResult* _return(JS_Val* val = nullptr) { return &_res; }
+  virtual IteratorResult* _throw(Error exception)  { return &_res; }
+
+  // TODO: %IteratorPrototype%[Symbol.iterator]() = this (current iterator instance)
+};
+
+// 27.5.1 Generator Prototype Object
+// - in ecma edition 11: named %GeneratorPrototype% (25.4.1)
+// - in ecma edition 12: named %GeneratorFunction.prototype.prototype% (27.5.1) but
+//                       labelled as %GeneratoPrototype% in 27.3 Figure 5.
+//                       Label corrected in version at tc39.
+class GeneratorProto : public IteratorProto {
+public:
+  GeneratorProto(Function* ctor, Object* proto) : IteratorProto(ctor, proto) { }
+  ~GeneratorProto() { }
+  void*  _yield     = nullptr; // pointer to yield label to resume execution
+  bool   _finished  = false;   // flag if generator is in finished state
+  bool   _firstNext = true;    // flag if first next has been called on iterator (27.5.1.2)
+  
+  IteratorResult* _return(JS_Val* arg = nullptr) override {
+    _finished = true;
+    if (arg != nullptr) {
+      _res.value = *arg;
+    }
+    return &_res;
+  }
+};
+
+// 27.3.1 GeneratorFunction Constructor
+class GeneratorFunc : public Function::Ctor {
+public:
+  GeneratorFunc(Function* ctor, Object* proto, Object* prototype_proto, Function* prototype_obj) : Function::Ctor(ctor, proto, prototype_proto, prototype_obj) { }
+  ~GeneratorFunc() {}
+};
+
+// 27.3.3 GeneratorFunction Prototype Obejct
+// - in ecma edition 11: named %Generator% (25.2.3)
+// - in ecma edition 12: named %GeneratorFunction.prorotype% (27.3.3) but
+//                       labelled as %Generator% in 27.3 Figure 5.
+//                       Label corrected in tc39 version.
+class GeneratorFuncPrototype : public Function {
+public:
+  GeneratorFuncPrototype(Function* ctor, Object* proto, Object* prototype_proto) : Function(ctor, proto, prototype_proto) { }
+};
+
+// Generator related intrinsic objects. (ecma 27.3)
+// IteratorPrototype: It is not a prototype object of any constructor func, but holds shared properties for iterators
+// GeneratorFunction: A builtin function used as the constructor for generator functions.
+// Generator:         (GeneratorFuncion.prototype in edition 12.0) is the prototype object of GeneratorFunction,
+//                    It is a special object used as both prototype object and constructor - as prototype for sharing
+//                    properties between generator functions, and as constructor whose prototype object (GeneratorPrototype
+//                    in edition 11) holds shared properties for generators (i.e. instances returned by generator functions.
+extern IteratorProto              IteratorPrototype;
+extern GeneratorFunc              GeneratorFunction;
+extern GeneratorFuncPrototype     Generator;
+extern Object*                    GeneratorPrototype;
+
+} // namespace t2crt
+
+
+using t2crt::Record;
+using t2crt::JSON;
+using t2crt::RegExp;
+#endif // __BUILTINS_H__
diff --git a/src/MapleFE/ast2cpp/runtime/include/ts2cpp.h b/src/MapleFE/ast2cpp/runtime/include/ts2cpp.h
new file mode 100644
index 0000000000000000000000000000000000000000..cdf48d2d55cc3ac65f17f6585192b2efbcd8fb25
--- /dev/null
+++ b/src/MapleFE/ast2cpp/runtime/include/ts2cpp.h
@@ -0,0 +1,510 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __TS2CPP_RT_HEADER__
+#define __TS2CPP_RT_HEADER__
+
+#include <iostream>
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <cmath>
+#include <cstdarg>
+#include <cctype>
+
+using namespace std::string_literals;
+
+namespace t2crt {
+
+using std::to_string;
+
+inline std::string to_string(std::string t) {return t;}
+
+class Object;
+class Function;
+template <typename T>
+class Array;
+
+// JS types for props
+#define TY_CXX 0x20
+typedef enum JS_Type : uint8_t {
+  TY_None = 0,  // Placeholder for non-existing property
+  TY_Undef,     // "undefined"
+  TY_Null,      // "object"
+  TY_Bool,      // "boolean"
+  TY_Long,      // "number"
+  TY_Double,    // "number"
+  TY_BigInt,    // "bigint"
+  TY_String,    // "string"
+  TY_Symbol,    // "symbol"
+  TY_Function,  // "function"
+  TY_Object,    // "object"
+  TY_Array,
+  TY_Any,       // JS_Val::x.field points to a JS_Val
+  TY_LAST,
+  TY_CXX_Undef = TY_Undef | TY_CXX,
+  TY_CXX_Null,
+  TY_CXX_Bool,
+  TY_CXX_Long,
+  TY_CXX_Double,
+  TY_CXX_BigInt,
+  TY_CXX_String,
+  TY_CXX_Symbol,
+  TY_CXX_Function,
+  TY_CXX_Object,
+  TY_CXX_Array,
+  TY_CXX_Any,   // JS_Val::x.field points to a JS_Val
+  TY_CXX_LAST,
+} JS_Type;
+
+struct JS_Val {
+  union {
+    void*        field;      // used by compiler genereted fields only
+    bool         val_bool;
+    int64_t      val_long;
+    double       val_double;
+    void*        val_bigint;
+    std::string* val_string; // JS string primitive (not JS String object)
+    Object*      val_obj;    // for function, object (incl. String objects)
+    Function*    val_func;   // for function
+  } x;
+  JS_Type type;
+
+  bool IsCxxProp() { return type & TY_CXX; } // true if a cxx field
+  bool IsNone()  { return type == TY_None; }
+  bool IsNull()  { return type & TY_Null;  }
+  bool IsUndef() { return type & TY_Undef; }
+
+  JS_Val() { x.val_long = 0l; type = TY_Undef; }
+  JS_Val(int64_t l, JS_Type t, bool c) { x.val_long = l; type = t; }
+  JS_Val(bool b)    { x.val_bool = b; type = TY_Bool; }
+  JS_Val(int64_t l) { x.val_long = l; type = TY_Long; }
+  JS_Val(double d)  { x.val_double = d; type = TY_Double; }
+  JS_Val(Object* o) { x.val_obj = o; type = TY_Object; }
+  JS_Val(Object* o, JS_Type t) { x.val_obj = o; type = t; }
+  JS_Val(Function* o){ x.val_func = o; type = TY_Function; }
+  JS_Val(std::string* s) { x.val_string = s; type = TY_String; }
+  JS_Val(std::string s) { x.val_string = new std::string(s); type = TY_String; }
+  JS_Val(const char* s) { x.val_string = new std::string(s); type = TY_String; }
+  JS_Val(int i) { x.val_long = i; type = TY_Long; }
+  JS_Val(JS_Type jstype, bool v) { x.val_long = (int64_t)v; type = jstype; }
+  // Prop directly generated as class fields when TS is compiled into CPP
+  JS_Val(JS_Type jstype, void* field) { x.field = field; type = static_cast<JS_Type>(jstype|TY_CXX); }
+
+#define OPERATORS(op) \
+  JS_Val operator op(const JS_Val &v) { \
+    JS_Val res; \
+    if(type == v.type) \
+      switch(type) { \
+        case TY_Long:   return { x.val_long op v.x.val_long }; \
+        case TY_Double: return { x.val_double op v.x.val_double }; \
+      } \
+    else { \
+      if(type == TY_Long && v.type == TY_Double) \
+        return { (double)x.val_long op v.x.val_double }; \
+      if(type == TY_Double && v.type == TY_Long) \
+        return { x.val_double op (double)v.x.val_long }; \
+    } \
+    return res; \
+  }
+
+  OPERATORS(+)
+  OPERATORS(-)
+  OPERATORS(*)
+
+  // Handle assigning value to a JS_Val obj
+#define ASSIGN_OPR(ctype, jstype, jscxxtype) \
+    JS_Val& operator=(ctype val)  { \
+      if (IsCxxProp()) {            \
+        type = jscxxtype;           \
+        *(ctype *)x.field = val;    \
+      } else {                      \
+        type = jstype;              \
+        x.val_##ctype = val;        \
+      }                             \
+      return *this;                 \
+    }
+
+  ASSIGN_OPR(double, TY_Double, TY_CXX_Double)
+  ASSIGN_OPR(long, TY_Long, TY_CXX_Long)
+  ASSIGN_OPR(bool, TY_Bool, TY_CXX_Bool)
+
+  // assign Object ptr to JS_Val
+  JS_Val& operator=(Object* val)  {
+    if (IsCxxProp()) {
+      type = TY_CXX_Object;
+      *(Object **)x.field = val;
+    } else {
+      type = TY_Object;
+      x.val_obj = val;
+    }
+    return *this;
+  }
+
+  // convert int to numeric type in target JS_Val
+  JS_Val& operator=(int val)  {
+    if (IsCxxProp()) {
+      if (type == TY_CXX_Long)
+        *(long*)x.field = (long)val;
+      else if (type == TY_CXX_Double)
+        *(double *)x.field = (double)val;
+    } else {
+      if (type == TY_Long)
+        x.val_long = (long)val;
+      else if (type == TY_Double)
+        x.val_double = (double)val;
+      else if (type == TY_Undef) {
+        // if target JS_Val is undef, convert to long
+        type = TY_Long;
+        x.val_long = (long)val;
+      }
+    }
+    return *this;
+  }
+
+  JS_Val& operator=(std::string &val)  {
+    if (IsCxxProp()) {
+      type = TY_CXX_String;
+      // x.field already pt to a str fd in a c++ obj
+      *(std::string *)x.field = val;
+    } else {
+      type = TY_String;
+      x.val_string = new std::string(val);
+    }
+    return *this;
+  }
+
+  JS_Val& operator=(char* val)  {
+    if (IsCxxProp()) {
+      type = TY_CXX_String;
+      *(std::string *)x.field = std::string(val);
+    } else {
+      type = TY_String;
+      x.val_string = new std::string(val);
+    }
+    return *this;
+  }
+
+
+};
+
+typedef std::unordered_map<std::string, JS_Val> JS_PropList;
+typedef std::pair<std::string, JS_Val> ObjectProp;
+
+class Object {
+  public:
+    JS_PropList propList;
+    Object*   __proto__;       // prototype chain
+    Function* constructor;     // constructor of object
+
+  public:
+    Object(): __proto__(nullptr) {}
+    Object(Function* ctor, Object* proto): constructor(ctor), __proto__(proto) {}
+    Object(Function* ctor, Object* proto, std::vector<ObjectProp> props): constructor(ctor), __proto__(proto)
+    {
+      for (int i=0; i<props.size(); ++i)
+        this->AddProp(props[i].first, props[i].second);
+    }
+    virtual ~Object() {}
+    class Ctor;
+    static Ctor ctor;
+    virtual std::string Dump(void);
+
+    JS_Val& operator[] (std::string key)
+    {
+      if (!HasOwnProp(key)) AddProp(key, JS_Val());
+      return GetPropVal(key);
+    }
+
+
+    bool HasOwnProp(std::string key) {
+      JS_PropList::iterator it;
+      it = propList.find(key);
+      return (it != propList.end());
+    }
+
+    void AddProp(std::string key, JS_Val val) {
+      propList[key] = val;
+    }
+
+    JS_Val GetProp(std::string key) {
+      return propList[key];
+    }
+
+    JS_Val& GetPropVal(std::string key) {
+      return propList[key];
+    }
+
+    void* GetPropField(std::string key) {
+      return propList[key].x.field;
+    }
+
+    bool GetPropBool(std::string key) {
+      if (propList[key].IsCxxProp())
+        return *(bool*)GetPropField(key);
+      return propList[key].x.val_bool;
+    }
+    long GetPropLong(std::string key) {
+      if (propList[key].IsCxxProp())
+        return *(long*)GetPropField(key);
+      return propList[key].x.val_long;
+    }
+    double GetPropDouble(std::string key) {
+      if (propList[key].IsCxxProp())
+        return *(double*)GetPropField(key);
+      return propList[key].x.val_double;
+    }
+    void* GetPropBigInt(std::string key) {
+      if (propList[key].IsCxxProp())
+        return *(void**)GetPropField(key);
+      return propList[key].x.val_bigint;
+    }
+    std::string GetPropStr(std::string key) {
+      if (propList[key].IsCxxProp())
+        return *(*(std::string**)GetPropField(key));
+      return *propList[key].x.val_string;
+    }
+    Object* GetPropObj(std::string key) {
+      if (propList[key].IsCxxProp())
+        return *(Object**)GetPropField(key);
+      return propList[key].x.val_obj;
+    }
+    Function* GetPropFunc(std::string key) {
+      if (propList[key].IsCxxProp())
+        return *(Function**)GetPropField(key);
+      return propList[key].x.val_func;
+    }
+
+    virtual bool IsFuncObj() {
+      return false;
+    }
+
+    bool IsEmpty() const {
+      return propList.empty();
+    }
+
+    virtual const char* __GetClassName() const {
+      return "";
+    }
+
+    // Put code for JS Object.prototype props as static fields and methods in this class
+    // and add to propList of Object_ctor.prototype object on system init.
+
+    virtual std::string TypeId() {
+      return "object"s;
+    }
+};
+
+
+using ArgsT = Array<JS_Val>;
+
+class Function : public Object {
+  public:
+    Object* prototype;    // prototype property
+    Object* _thisArg;     // from bind()
+    ArgsT*  _args;        // from bind()
+
+    Function(Function* ctor, Object* proto, Object* prototype_proto) : Object(ctor, proto) {
+      JS_Val val(this);
+      prototype = new Object(this, prototype_proto);
+      prototype->AddProp("constructor", val);
+    }
+    // Special constructor for creating builtin constructor function "GeneratorFunction" see builtins.h
+    Function(Function* ctor, Object* proto, Object* prototype_proto, Object* prototype_obj) : Object(ctor, proto) {
+      JS_Val val(this);
+      prototype =  prototype_obj;
+      prototype->AddProp("constructor", val);
+    }
+
+    class Ctor;
+    static Ctor ctor;
+
+    bool IsFuncObj() {
+      return true;
+    }
+
+    // Put code for JS Function.prototype props as static fields and methods in this class
+    // and add to propList of Function_ctor.prototype object on system init.
+    virtual Object* bind (Object* obj, ArgsT* argv) { return nullptr; }
+    virtual JS_Val  call (Object* obj, ArgsT* argv) { JS_Val res; return res; }
+    virtual JS_Val  apply(Object* obj, ArgsT* argv) { JS_Val res; return res; }
+
+    std::string TypeId() override {
+      return "function"s;
+    }
+};
+
+
+
+class Object::Ctor : public Function {
+  public:
+    Ctor(Function* ctor, Object* proto) : Function(ctor, proto, nullptr) {}
+
+    Object* operator()(Object* obj) {
+      return(obj);
+    }
+    Object* _new() {
+      return new Object(this, this->prototype);
+    }
+    Object* _new(std::vector<ObjectProp> props) {
+      return new Object(this, this->prototype, props);
+    }
+};
+
+class Function::Ctor : public Function {
+  public:
+    Ctor(Function* ctor, Object* proto, Object* prototype_proto) : Function(ctor, proto, prototype_proto) {}
+    Ctor(Function* ctor, Object* proto, Object* prototype_proto, Object* prototype_obj) : Function(ctor, proto, prototype_proto, prototype_obj) {}
+};
+
+template <class T>
+class ClassFld {
+  // Helper class for converting between class field offset, void ptr and integer val
+  // NewProp() creates a JS_Val of type TY_CXX_<xxx> with pointer to objet member field.
+  typedef union {
+//  void* addr;
+    T     offset;
+    int   fld_offset;
+  } FldAddr;
+
+  public:
+    FldAddr field;
+  public:
+//  JS_Val NewProp(JS_Type type) {return JS_Val(type, field.addr);}
+    ClassFld(T offset)   {field.offset = offset;}
+    T     Offset()       {return field.offset;}
+    JS_Val NewProp(void* obj, JS_Type type) {return JS_Val(type, (void*)((char*)obj+field.fld_offset));}
+};
+
+template <typename T> std::string __js_typeof(T* v) {
+  return v->TypeId();
+}
+
+template <typename T> std::string __js_typeof(T v) {
+  if (std::is_signed<T>::value)
+    return "number"s;
+  if (std::is_integral<T>::value)
+    return "boolean"s;
+  return "unknown"s;
+}
+
+template <> inline std::string __js_typeof<std::string>(std::string v) {
+  return "string"s;
+}
+
+template <> inline std::string __js_typeof<t2crt::JS_Val>(t2crt::JS_Val v) {
+  static std::string names[t2crt::TY_LAST] = {
+    [t2crt::TY_None]     =  "none"s,
+    [t2crt::TY_Undef]    = "undefined"s,
+    [t2crt::TY_Null]     = "object"s,
+    [t2crt::TY_Bool]     = "boolean"s,
+    [t2crt::TY_Long]     = "number"s,
+    [t2crt::TY_Double]   = "number"s,
+    [t2crt::TY_BigInt]   = "bigint"s,
+    [t2crt::TY_String]   = "string"s,
+    [t2crt::TY_Symbol]   = "symbol"s,
+    [t2crt::TY_Function] = "function"s,
+    [t2crt::TY_Object]   = "object"s,
+  };
+  return names[v.type];
+}
+
+// TSC restricts Lhs of instanceof operator to either type any or an object type.
+bool InstanceOf(JS_Val val, Function* ctor);
+
+// Our implementation returns true if the prototype property of the func/class
+// constructor appers in the proto chain of the object.
+template <class T>
+bool InstanceOf(T* val, Function* ctor) {
+  if (ctor == nullptr)
+    return false;
+
+  Object* p = val->__proto__;
+  while (p) {
+    if (p == ctor->prototype)
+      return true;
+    else
+      p = p->__proto__;
+  }
+  return false;
+}
+
+// TODO: To be implemented
+inline bool StrictEqu(JS_Val lhs, JS_Val rhs) { return false; }
+inline bool StrictNotEqu(JS_Val lhs, JS_Val rhs) { return true; }
+
+void GenerateDOTGraph( std::vector<Object *>&obj, std::vector<std::string>&name);
+
+} // namespace t2crt
+
+extern std::ostream& operator<< (std::ostream& out, const t2crt::JS_Val& v);
+extern std::ostream& operator<< (std::ostream& out, t2crt::Object* obj);
+extern const t2crt::JS_Val undefined;
+extern const t2crt::JS_Val null;
+
+#include "builtins.h"
+
+template <typename T>
+std::ostream& operator<< (std::ostream& out, const std::vector<T>& v) {
+  if(v.empty())
+    out << "[]";
+  else {
+    out << "[ ";
+    auto i = v.begin(), e = v.end();
+    out << *i++;
+    for (; i != e; ++i)
+        std::cout << ", " << *i;
+    out << " ]";
+  }
+  return out;
+}
+
+template <typename T>
+std::ostream& operator<< (std::ostream& out, const t2crt::Array<T>* v) {
+  if(v->elements.empty())
+    out << "[]";
+  else {
+    out << "[ ";
+    auto i = v->elements.begin(), e = v->elements.end();
+    out << *i++;
+    for (; i != e; ++i)
+        std::cout << ", " << *i;
+    out << " ]";
+  }
+  return out;
+}
+
+template <typename T>
+std::ostream& operator<< (std::ostream& out, const t2crt::Array<T>& v) {
+  if(v.elements.empty())
+    out << "[]";
+  else {
+    out << "[ ";
+    auto i = v.elements.begin(), e = v.elements.end();
+    out << *i++;
+    for (; i != e; ++i)
+        std::cout << ", " << *i;
+    out << " ]";
+  }
+  return out;
+}
+
+#define debugger (0)
+
+using t2crt::Object;
+using t2crt::Function;
+using t2crt::Array;
+
+#endif
diff --git a/src/MapleFE/ast2cpp/runtime/src/builtins.cpp b/src/MapleFE/ast2cpp/runtime/src/builtins.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..43f6dd65fbd1bf433a3576824b3745121c340ef2
--- /dev/null
+++ b/src/MapleFE/ast2cpp/runtime/src/builtins.cpp
@@ -0,0 +1,23 @@
+#include "../include/ts2cpp.h"
+
+namespace t2crt {
+
+Object::Ctor   Object::ctor  (&Function::ctor, Function::ctor.prototype);
+Function::Ctor Function::ctor(&Function::ctor, Function::ctor.prototype, Object::ctor.prototype);
+Number::Ctor   Number::ctor  (&Function::ctor, Function::ctor.prototype, Object::ctor.prototype);
+RegExp::Ctor   RegExp::ctor  (&Function::ctor, Function::ctor.prototype, Object::ctor.prototype);
+
+IteratorProto                IteratorPrototype(&Object::ctor, Object::ctor.prototype);
+GeneratorFuncPrototype       Generator(&GeneratorFunction, Function::ctor.prototype, &IteratorPrototype);
+GeneratorFunc                GeneratorFunction(&Function::ctor, &Function::ctor, Function::ctor.prototype, &Generator);
+Object* GeneratorPrototype = Generator.prototype;
+
+ARR_CTOR_DEF(int)
+ARR_CTOR_DEF(long)
+ARR_CTOR_DEF(double)
+ARR_CTOR_DEF(JS_Val)
+ARR_CTOR_DEF(Object)
+ARR_CTOR_DEF(Object*)
+
+} // namepsace t2crt
+
diff --git a/src/MapleFE/ast2cpp/runtime/src/ts2cpp.cpp b/src/MapleFE/ast2cpp/runtime/src/ts2cpp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..50fecb38bc70c6b4c71e517d5bf98f7392e4178e
--- /dev/null
+++ b/src/MapleFE/ast2cpp/runtime/src/ts2cpp.cpp
@@ -0,0 +1,151 @@
+#include <algorithm>
+#include <sstream>
+#include "../include/ts2cpp.h"
+#include "ast_common.h"
+
+std::ostream& operator<< (std::ostream& out, const t2crt::JS_Val& v) {
+  switch(v.type) {
+    case t2crt::TY_None: out << "None"; break;
+    case t2crt::TY_Undef: out << "undefined"; break;
+    case t2crt::TY_Null: out << "null"; break;
+    case t2crt::TY_Bool: out << v.x.val_bool; break;
+    case t2crt::TY_Long: out << v.x.val_long; break;
+    case t2crt::TY_Double: out << v.x.val_double; break;
+    case t2crt::TY_BigInt: out << "bigint"; break;
+    case t2crt::TY_String: out << *v.x.val_string; break;
+    case t2crt::TY_Symbol: out << "symbol"; break;
+    case t2crt::TY_Function: out << "function"; break;
+    case t2crt::TY_Object: out << v.x.val_obj; break;
+    case t2crt::TY_Any: out << *(t2crt::JS_Val*)v.x.field; break;
+
+    case t2crt::TY_CXX_Undef: out  << "undefined"; break;
+    case t2crt::TY_CXX_Null: out   << "null"; break;
+    case t2crt::TY_CXX_Bool: out   << *(bool*)v.x.field; break;
+    case t2crt::TY_CXX_Long: out   << *(int64_t*)v.x.field; break;
+    case t2crt::TY_CXX_Double: out << *(double *)v.x.field; break;
+    case t2crt::TY_CXX_BigInt: out << "bigint"; break;
+    case t2crt::TY_CXX_String: out << *(std::string*)v.x.field; break;
+    case t2crt::TY_CXX_Symbol: out << "symbol"; break;
+    case t2crt::TY_CXX_Function: out << "function"; break;
+    case t2crt::TY_CXX_Object: out << *(Object**)v.x.field; break;
+    case t2crt::TY_CXX_Any: out << *(t2crt::JS_Val*)v.x.field; break;
+  }
+  return out;
+}
+
+std::ostream& operator<< (std::ostream& out, t2crt::Object *obj) {
+  if (obj == nullptr)
+    return out;
+  out << obj->Dump();
+  return out;
+}
+
+const t2crt::JS_Val undefined = { 0, t2crt::TY_Undef, false };
+const t2crt::JS_Val null = { 0, t2crt::TY_Null, false };
+
+namespace t2crt {
+
+std::string Object::Dump(void) {
+  std::string str;
+  str += this->constructor->__GetClassName();
+  if (this->IsEmpty())
+    str += "{}";
+  else {
+    std::vector<std::string> vec;
+    unsigned cnt = 0;
+    std::stringstream buf;
+    buf << std::boolalpha;
+    // non-object fields go first
+    for (bool flag: { false, true }) {
+      for (auto it = this->propList.begin(); it != this->propList.end(); it++) {
+        auto k = it->second.type;
+        auto b = k == t2crt::TY_Object || k == t2crt::TY_CXX_Object;
+        if (b == flag) {
+          buf.str(std::string());
+          const std::string &prop = it->first;
+          if (isdigit(prop.front()))
+            buf << '\'' << prop << "': ";
+          else {
+            auto len = prop.length();
+            constexpr auto suffixlen = sizeof(RENAMINGSUFFIX) - 1;
+            if (len > suffixlen && prop.substr(len - suffixlen) == RENAMINGSUFFIX)
+              buf << prop.substr(0, len - suffixlen) << ": ";
+            else
+              buf << prop << ": ";
+          }
+          if (k == t2crt::TY_String || k == t2crt::TY_CXX_String)
+            buf << '\'' << it->second << '\'';
+          else
+            buf << it->second;
+          vec.push_back(buf.str());
+        }
+      }
+      std::sort(vec.begin() + cnt, vec.end());
+      cnt = vec.size();
+    }
+    const char *p = "{ ";
+    for (auto prop: vec) {
+      str += p + prop;
+      p = ", ";
+    }
+    str += " }";
+  }
+  return str;
+}
+
+bool InstanceOf(JS_Val val, Function* ctor) {
+  if (val.type != TY_Object || val.x.val_obj == nullptr || ctor == nullptr)
+    return false;
+
+  Object* p = val.x.val_obj->__proto__;
+  while (p) {
+    if (p == ctor->prototype)
+      return true;
+    else
+      p = p->__proto__;
+  }
+  return false;
+}
+
+// Generate DOT graph output to show object inheritance with
+// constructor, prototype chain and prototype property linkages
+void GenerateDOTGraph( std::vector<Object *>&obj, std::vector<std::string>&name) {
+  for(int g = 0; g < 2; ++g) {
+    std::vector<Object*> objs = obj;
+    std::vector<std::string> names = name;
+    std::cout << "digraph JS" << g << " {\nranksep=0.6;\nnodesep=0.6;\n" << (g == 0 ? "newrank=true;\n" : "") << std::endl;
+    int num = objs.size();
+    int k = num;
+
+    for (int i=0; i<num; ++i) {
+      bool isFuncObj = objs[i]->IsFuncObj();
+      if (isFuncObj) {
+        // only function objects have prototype prop
+        objs.push_back(((Function *)objs[i])->prototype);
+        names.push_back(names[i] + "_prototype");
+        if (g == 0) {
+          std::cout << "subgraph cluster_" << names[i] << " {\nrank=same;\ncolor=white;\n"
+          << names[i] << ";\n" << names[k] << "[label=\"" << names[i] << ".prototype\", shape=box];\n }" << std::endl;
+        }
+        else {
+          std::cout <<  names[k] << "[label=\"" << names[i] << ".prototype\", shape=box];" << std::endl;
+        }
+        std::cout << names[i] << " -> " << names[k] << " [label=\"prototype\", color=blue, fontcolor=blue];" << std::endl;
+        k++;
+      }
+    }
+    num = objs.size();
+    for (int i=0; i<num; ++i) {
+      for (int j=0; j<num; ++j) {
+        if(g > 0 && objs[i]->constructor == objs[j])
+          std::cout << names[i] << " -> " << names[j] << " [label=\"ctor\", color=darkgreen, fontcolor=darkgreen];" << std::endl;
+
+        if(objs[i]->__proto__ == objs[j])
+          std::cout << names[i] << " -> " << names[j] << " [label=\"__proto__\", color=red, fontcolor=red];" << std::endl;
+      }
+    }
+    std::cout << "} // digraph JS" << g << std::endl;
+  }
+}
+
+} // namespace t2crt
diff --git a/src/MapleFE/ast2cpp/src/Makefile b/src/MapleFE/ast2cpp/src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..084bcad114a3f5728966433d2aaf28c3569731ba
--- /dev/null
+++ b/src/MapleFE/ast2cpp/src/Makefile
@@ -0,0 +1,93 @@
+# Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
+include ../../Makefile.in
+BUILDBIN=$(BUILDDIR)/bin
+BUILD=$(BUILDDIR)/ast2cpp
+BUILDGEN=$(BUILDDIR)/gen
+BUILDASTGEN=$(BUILDDIR)/ast_gen/shared
+$(shell $(MKDIR_P) $(BUILD))
+
+SRC=$(wildcard *.cpp)
+OBJ :=$(patsubst %.cpp,%.o,$(SRC))
+DEP :=$(patsubst %.cpp,%.d,$(SRC))
+
+SRCG := $(wildcard $(BUILDGEN)/gen*.cpp)
+OBJG := $(patsubst %.cpp, %.o, $(SRCG))
+DEPG := $(patsubst %.cpp, %.d, $(SRCG))
+
+LOCALOBJS :=$(foreach obj,$(OBJ), $(BUILD)/$(obj))
+LOCALDEPS :=$(foreach dep,$(DEP), $(BUILD)/$(dep))
+OBJS :=$(LOCALOBJS) $(OBJG)
+DEPS :=$(LOCALDEPS) $(DEPG)
+
+LIBOBJS :=$(patsubst $(BUILD)/main.o,,$(LOCALOBJS))
+
+GENDIR:=${BUILDDIR}/ast_gen/shared
+
+INCLUDES := -I $(MAPLEFE_ROOT)/shared/include \
+            -I $(MAPLEFE_ROOT)/astopt/include \
+            -I $(MAPLEFE_ROOT)/ast2cpp/include \
+            -I $(MAPLEFE_ROOT)/autogen/include \
+            -I $(MAPLEFE_ROOT)/shared/include \
+            -I $(MAPLEFE_ROOT)/typescript/include \
+            $(MAPLEALL_INC) -I ${GENDIR}
+
+INCLUDEGEN := -I $(MAPLEFE_ROOT)/shared/include -I $(BUILDDIR)/gen -I $(BUILDASTGEN)
+
+TARGET=ast2cpp
+TARGET_A=ast2cpp.a
+
+SHAREDLIB = $(BUILDDIR)/astopt/astopt.a $(BUILDDIR)/shared/shared.a $(BUILDASTGEN)/genast.a
+LANGSPEC=$(BUILDDIR)/typescript/lang_spec.o
+
+.PHONY: all
+all: $(BUILDBIN)/$(TARGET)
+
+-include $(DEPS)
+.PHONY: clean
+
+vpath %.o $(BUILD)
+vpath %.d $(BUILD)
+
+#Pattern Rules
+$(BUILD)/%.o : %.cpp
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
+
+$(BUILD)/%.d : %.cpp
+	@$(CXX) $(CXXFLAGS) -MM $(INCLUDES) $< > $@
+	@mv -f $(BUILD)/$*.d $(BUILD)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
+	@rm -f $(BUILD)/$*.d.tmp
+
+$(BUILDGEN)/%.o : $(BUILDGEN)/%.cpp $(BUILDGEN)/%.d
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDEGEN) -w -c $< -o $@
+
+$(BUILDGEN)/%.d : $(BUILDGEN)/%.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDEGEN) $< > $@
+	@mv -f $(BUILDGEN)/$*.d $(BUILDGEN)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILDGEN)/$*.o:|' < $(BUILDGEN)/$*.d.tmp > $(BUILDGEN)/$*.d
+	@rm -f $(BUILDGEN)/$*.d.tmp
+
+# TARGET depends on OBJS and shared OBJS from shared directory
+# as well as mapleall libraries
+$(BUILD)/$(TARGET_A): $(LIBOBJS)
+	/usr/bin/ar rcs $(BUILD)/$(TARGET_A) $(LIBOBJS)
+
+$(BUILDBIN)/$(TARGET): $(BUILD)/$(TARGET_A) $(OBJS) $(SHAREDLIB)
+	@mkdir -p $(BUILDBIN)
+	$(LD) -o $(BUILDBIN)/$(TARGET) $(BUILD)/main.o $(BUILD)/$(TARGET_A) $(OBJG) $(LANGSPEC) $(SHAREDLIB)
+
+clean:
+	rm -rf $(BUILD)
diff --git a/src/MapleFE/ast2cpp/src/a2c_util.cpp b/src/MapleFE/ast2cpp/src/a2c_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f9bb62cadc557da43df4949d5b5d2e3702303830
--- /dev/null
+++ b/src/MapleFE/ast2cpp/src/a2c_util.cpp
@@ -0,0 +1,73 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <filesystem>
+#include "a2c_util.h"
+#include "gen_astdump.h"
+
+namespace maplefe {
+
+std::string ImportedFiles::GetTargetFilename(TreeNode *node) {
+  std::string filename;
+  if (node && node->IsLiteral()) {
+    LiteralNode *lit = static_cast<LiteralNode *>(node);
+    LitData data = lit->GetData();
+    filename = AstDump::GetEnumLitData(data);
+    filename += ".ts.ast"s;
+    if(filename.front() != '/') {
+      std::filesystem::path p = mModule->GetFilename();
+      try {
+        p = std::filesystem::canonical(p.parent_path() / filename);
+        filename = p.string();
+      }
+      catch(std::filesystem::filesystem_error const& ex) {
+        // Ignore std::filesystem::filesystem_error exception
+        // keep filename without converting it to a cannonical path
+      }
+    }
+  }
+  return filename;
+}
+
+ImportNode *ImportedFiles::VisitImportNode(ImportNode *node) {
+  std::string name = GetTargetFilename(node->GetTarget());
+  if (!name.empty()) {
+    mFilenames.push_back(name);
+  }
+  for (unsigned i = 0; i < node->GetPairsNum(); ++i) {
+    if (auto x = node->GetPair(i); x->IsSingle()) {
+      std::string s = GetTargetFilename(x->GetBefore());
+      if (!s.empty())
+        mFilenames.push_back(s);
+    }
+  }
+  for (unsigned i = 0; i < node->GetPairsNum(); i++) {
+    XXportAsPairNode *pair = node->GetPair(i);
+    (void) AstVisitor::VisitTreeNode(pair);
+  }
+  return node;
+}
+
+ExportNode *ImportedFiles::VisitExportNode(ExportNode *node) {
+  std::string name = GetTargetFilename(node->GetTarget());
+  if (!name.empty())
+    mFilenames.push_back(name);
+  for (unsigned i = 0; i < node->GetPairsNum(); i++) {
+    XXportAsPairNode *pair = node->GetPair(i);
+    (void) AstVisitor::VisitTreeNode(pair);
+  }
+  return node;
+}
+}
diff --git a/src/MapleFE/ast2cpp/src/ast2cpp.cpp b/src/MapleFE/ast2cpp/src/ast2cpp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..449e4b9c17caeb49da0feb1e037cf51a99b2ade2
--- /dev/null
+++ b/src/MapleFE/ast2cpp/src/ast2cpp.cpp
@@ -0,0 +1,243 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <queue>
+#include <sstream>
+#include <fstream>
+#include <iterator>
+#include <cstdlib>
+
+#include "ast2cpp.h"
+#include "ast_handler.h"
+#include "gen_astdump.h"
+#include "gen_astgraph.h"
+#include "gen_aststore.h"
+#include "gen_astload.h"
+#include "cpp_definition.h"
+#include "cpp_declaration.h"
+#include "a2c_util.h"
+
+namespace maplefe {
+
+void A2C::EmitTS() {
+  for (HandlerIndex i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+
+    // build CFG
+    handler->BuildCFG();
+
+    ModuleNode *module = handler->GetASTModule();
+    std::cout << "============= AstDump ===========" << std::endl;
+    AstDump astdump(module);
+    astdump.Dump("After BuildCFG()", &std::cout);
+    std::cout << "============= AstGraph ===========" << std::endl;
+    AstGraph graph(module);
+    graph.DumpGraph("After BuildCFG()", &std::cout);
+    std::cout << "============= Emitter ===========" << std::endl;
+    maplefe::Emitter emitter(handler);
+    std::string code = emitter.Emit("Convert AST to TypeScript code");
+    std::cout << code;
+  }
+}
+
+bool A2C::LoadImportedModules() {
+  std::queue<std::string> queue;
+  for (HandlerIndex i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+    ImportedFiles imported(module);
+    imported.VisitTreeNode(module);
+    for(const auto &e: imported.mFilenames)
+      queue.push(e);
+  }
+
+  bool err = false;
+  while(!queue.empty()) {
+    std::string filename = queue.front();
+    queue.pop();
+    if(mASTHandler->GetHandlerIndex(filename.c_str()) == HandlerNotFound) {
+      std::ifstream input(filename, std::ifstream::binary);
+      if(input.fail()) {
+        std::cerr << "Error: File " << filename << " not found for imported module" << std::endl;
+        err = true;
+        continue;
+      }
+      input >> std::noskipws;
+      std::istream_iterator<uint8_t> s(input), e;
+      maplefe::AstBuffer vec(s, e);
+      maplefe::AstLoad loadAst;
+      maplefe::ModuleNode *mod = loadAst.LoadFromAstBuf(vec);
+      // add mod to the vector
+      while(mod) {
+        mASTHandler->AddModule(mod);
+        ImportedFiles imported(mod);
+        imported.VisitTreeNode(mod);
+        for(const auto &e: imported.mFilenames)
+          queue.push(e);
+        mod = loadAst.Next();
+      }
+    }
+  }
+  return err;
+}
+
+// starting point of AST
+int A2C::ProcessAST() {
+  mIndexImported = GetModuleNum();
+
+  // used for FE verification
+  if (mFlags & FLG_emit_ts_only) {
+    EmitTS();
+    return 0;
+  }
+
+  // load all imported modules
+  if (!(mFlags & FLG_no_imported))
+    if (LoadImportedModules())
+      return 1;
+
+  // loop through module handlers
+  for (HandlerIndex i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+
+    if (mFlags & FLG_trace_1) {
+      std::cout << "============= in ProcessAST ===========" << std::endl;
+      std::cout << "srcLang : " << module->GetSrcLangString() << std::endl;
+
+      for(unsigned k = 0; k < module->GetTreesNum(); k++) {
+        TreeNode *tnode = module->GetTree(k);
+        if (mFlags & FLG_trace_1) {
+          tnode->Dump(0);
+          std::cout << std::endl;
+        }
+      }
+    }
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= AstGraph ===========" << std::endl;
+      AstGraph graph(module);
+      graph.DumpGraph("After LoadFromAstBuf()", &std::cout);
+    }
+  }
+
+  // build dependency of modules
+  PreprocessModules();
+
+  // loop through module handlers in import/export dependency order
+  for (auto handler: mHandlersInOrder) {
+    ModuleNode *module = handler->GetASTModule();
+
+    // basic analysis
+    handler->BasicAnalysis();
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= After AdjustAST ===========" << std::endl;
+      for(unsigned k = 0; k < module->GetTreesNum(); k++) {
+        TreeNode *tnode = module->GetTree(k);
+        if (mFlags & FLG_trace_1) {
+          tnode->Dump(0);
+          std::cout << std::endl;
+        }
+      }
+      AstGraph graph(module);
+      graph.DumpGraph("After AdjustAST()", &std::cout);
+    }
+
+    // build CFG
+    handler->BuildCFG();
+
+    if (mFlags & FLG_trace_2) {
+      handler->Dump("After BuildCFG()");
+    }
+
+    // control flow analysis
+    handler->ControlFlowAnalysis();
+
+    // type inference
+    handler->TypeInference();
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= AstGraph ===========" << std::endl;
+      AstGraph graph(module);
+      graph.DumpGraph("After TypeInference()", &std::cout);
+    }
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= AstDump ===========" << std::endl;
+      AstDump astdump(module);
+      astdump.Dump("After TypeInference()", &std::cout);
+    }
+
+    // data flow analysis
+    handler->DataFlowAnalysis();
+
+    if (mFlags & FLG_trace_2) {
+      handler->Dump("After DataFlowAnalysis()");
+    }
+  }
+
+  for (auto handler: mHandlersInOrder) {
+    ModuleNode *module = handler->GetASTModule();
+
+    if (mFlags & FLG_emit_ts) {
+      std::cout << "============= Emitter ===========" << std::endl;
+      maplefe::Emitter emitter(handler);
+      std::string code = emitter.Emit("Convert AST to TypeScript code");
+      std::cout << code;
+    }
+  }
+
+  if (mFlags & FLG_trace_2) {
+    std::cout << "============= CppHandler ===========" << std::endl;
+  }
+  maplefe::CppHandler cppHandler(mASTHandler, mFlags);
+  cppHandler.EmitCxxFiles();
+  return 0;
+}
+
+bool CppHandler::EmitCxxFiles() {
+  unsigned size = mASTHandler->GetSize();
+  for (int i = 0; i < size; i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    CppDecl decl(handler);
+    { // Emit C++ header file
+      std::string decl_code = decl.Emit();
+      std::string fn = decl.GetBaseFilename() + ".h"s;
+      std::ofstream out(fn.c_str(), std::ofstream::out);
+      out << decl_code;
+      out.close();
+      if (mFlags & FLG_format_cpp) {
+        std::string cmd = "clang-format-10 -i --sort-includes=0 "s + fn;
+        std::system(cmd.c_str());
+      }
+    }
+    { // Emit C++ implementation file
+      CppDef def(handler, decl);
+      std::string def_code = def.Emit();
+      std::string fn = def.GetBaseFilename() + ".cpp"s;
+      std::ofstream out(fn.c_str(), std::ofstream::out);
+      out << def_code;
+      out.close();
+      if (mFlags & FLG_format_cpp) {
+        std::string cmd = "clang-format-10 -i --sort-includes=0 "s + fn;
+        std::system(cmd.c_str());
+      }
+    }
+  }
+  return true;
+}
+
+} // namespace maplefe
diff --git a/src/MapleFE/ast2cpp/src/cpp_declaration.cpp b/src/MapleFE/ast2cpp/src/cpp_declaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..315c8624b6a528f0959b5770b4a3d2642a03470b
--- /dev/null
+++ b/src/MapleFE/ast2cpp/src/cpp_declaration.cpp
@@ -0,0 +1,1128 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "cpp_declaration.h"
+#include "gen_astvisitor.h"
+#include <algorithm>
+#include <cstring>
+#include "helper.h"
+#include "ast_common.h"
+
+namespace maplefe {
+
+class ImportExportModules : public AstVisitor {
+  private:
+    CppDecl     *mCppDecl;
+    Emitter     *mEmitter;
+    std::string  mIncludes;
+    std::string  mImports;
+    std::string  mExports;
+    bool         mExFlag;
+
+  public:
+    ImportExportModules(CppDecl *c) : mCppDecl(c),
+      mIncludes("// include directives\n"),
+      mImports("// imports\n"),
+      mExports("// exports\n"),
+      mExFlag(false) {
+      mEmitter = new Emitter(c->GetModuleHandler());
+    }
+    ~ImportExportModules() { delete mEmitter; }
+
+    std::string GetIncludes() { return mIncludes; }
+    std::string GetImports() { return mImports; }
+    std::string GetExports() { return mExports; }
+
+    std::string AddIncludes(TreeNode *node) {
+      std::string filename;
+      if (node) {
+        filename = mEmitter->EmitTreeNode(node);
+        auto len = filename.size();
+        filename = len >= 2 && filename.back() == '"' ? filename.substr(1, len - 2) : std::string();
+        // may have some duplicated include directives which do not hurt
+        if (!filename.empty()) {
+          std::string incl = "#include \""s + filename + ".h\"\n"s;
+          std::size_t found = mIncludes.find(incl);
+          if (found == std::string::npos) {
+            mIncludes += "#include \""s + filename + ".h\"\n"s;
+            mCppDecl->AddInit(tab(1) + mCppDecl->GetModuleName(filename.c_str()) + "::__init_func__();\n"s);
+          }
+        }
+      }
+      return filename;
+    }
+
+    std::string Comment(TreeNode *node) {
+      std::string s = mEmitter->EmitTreeNode(node);
+      return s.empty() ? s : "//--- "s + s.substr(0, s.find('\n')) + '\n';
+    }
+
+    ImportNode *VisitImportNode(ImportNode *node) {
+      std::string filename = AddIncludes(node->GetTarget());
+      std::string module = mCppDecl->GetModuleName(filename.c_str());
+      for (unsigned i = 0; i < node->GetPairsNum(); ++i) {
+        if (auto x = node->GetPair(i)) {
+          mImports += Comment(node);
+          std::string str;
+          if (x->IsDefault()) {
+            if (auto b = x->GetBefore()) {
+              std::string v = module + "::__export::__default"s;
+              std::string s = mEmitter->EmitTreeNode(b);
+              if (b->GetTypeId() == TY_Class)
+                mImports += "using "s + s + " = "s + v + ";\n"s;
+              else
+                mImports += "inline const decltype("s + v + ") &"s + s + " = "s + v + ";\n"s;
+            }
+          } else if (x->IsSingle()) {
+            if (auto b = x->GetBefore(); b->IsLiteral()) {
+                if (auto a = x->GetAfter()) {
+                  // import X = require("./module");
+                  std::string after = mEmitter->EmitTreeNode(a);
+                  filename = AddIncludes(b);
+                  module = mCppDecl->GetModuleName(filename.c_str());
+                  std::string v = module + "::__export::__default"s;
+                  if(a->GetTypeId() == TY_Module || a->GetTypeId() == TY_Namespace)
+                    mImports += "namespace "s + after + " = "s + module + v + ";\n"s;
+                  else if (a->GetTypeId() == TY_Class)
+                    mImports += "using "s + after + " = "s + v + ";\n"s;
+                  else
+                    mImports += "inline const decltype("s + v + ") &"s + after + " = "s + v + ";\n"s;
+                }
+            }
+          } else if (x->IsEverything()) {
+            if (auto n = x->GetBefore()) {
+              std::string s = mEmitter->EmitTreeNode(n);
+              mImports += "namespace "s + s + " = " + module + "::__export;\n"s;
+              mCppDecl->AddImportedModule(s);
+            }
+          } else {
+            if (auto n = x->GetBefore()) {
+              std::string v = mEmitter->EmitTreeNode(n);
+              if (auto a = x->GetAfter()) {
+                std::string after = mEmitter->EmitTreeNode(a);
+                if (node->GetTarget()) {
+                  v = "::__export::"s + (v == "default" ? "__"s + v : v);
+                  if (node->IsImportType())
+                    mImports += "using "s + after + " = "s + module + v + ";\n"s;
+                  else if (a->GetTypeId() == TY_Module || a->GetTypeId() == TY_Namespace)
+                    mImports += "namespace "s + after + " = "s + module + v + ";\n"s;
+                  else
+                    mImports += "inline const decltype("s + module + v + ") &"s + after
+                      + " = "s + module + v + ";\n"s;
+                } else {
+                  mEmitter->Replace(v, ".", "::");
+                  mImports += "inline const decltype("s + v + ") &"s + after + " = "s + v + ";\n"s;
+                }
+                if (mExFlag)
+                  mExports += "namespace __export { using "s + mCppDecl->GetModuleName() + "::"s + after + "; }\n"s;
+              } else {
+                auto u = module + "::__export::"s + v;
+                if (node->IsImportType())
+                  mImports += "using "s + v + " = "s + u + ";\n"s;
+                else
+                  mImports += "inline const decltype("s + u + ") &"s + v + " = "s + u + ";\n"s;
+              }
+            }
+          }
+        }
+      }
+      return node;
+    }
+
+    ExportNode *VisitExportNode(ExportNode *node) {
+      if (mCppDecl->IsInNamespace(node))
+        return node;
+      // 'export *' does not re-export a default, it re-exports only named exports
+      // Multiple 'export *'s fails with tsc if they export multiple exports with same name
+      std::string filename = AddIncludes(node->GetTarget());
+      std::string module = mCppDecl->GetModuleName(filename.c_str());
+      for (unsigned i = 0; i < node->GetPairsNum(); ++i) {
+        if (auto x = node->GetPair(i)) {
+          mExports += Comment(node);
+          if (x->IsDefault()) {
+            if (x->IsRef()) {
+              auto b = x->GetBefore();
+              std::string target = mCppDecl->GetIdentifierName(b);
+              bool emit = true;
+              if (target == "default" RENAMINGSUFFIX) {
+                target = module + "::__export::__default";
+                mExports += "namespace __export { inline const decltype("s + target + ") &"s
+                  + "__"s + "default" + " = "s + target + "; }\n"s;
+                emit = false;
+              }
+              if (emit) {
+                mExports += "namespace __export { inline const decltype("s + target + ") &__default = "s + target + "; }\n"s;
+                emit = false;
+              }
+              if (emit)
+                mExports += "namespace __export { using "s + module + "::"s + "default" RENAMINGSUFFIX "; }\n"s;
+            } else {
+              if (auto n = x->GetBefore()) {
+                std::string v = mEmitter->EmitTreeNode(n);
+                mExports += "namespace __export { inline decltype("s + v + ") __default; }\n"s;
+              }
+            }
+          } else if (x->IsSingle()) {
+            std::string str;
+            if (auto a = x->GetAfter())
+              mExports += "TODO: " + mEmitter->EmitTreeNode(a) + '\n';
+            else if (auto b = x->GetBefore()) {
+              std::string s = mEmitter->EmitTreeNode(b);
+              if (b->GetTypeId() == TY_Class)
+                mExports += "namespace __export { using __default = "s + module + "::"s + s + "; }\n"s;
+              else if (b->GetTypeId() == TY_Namespace)
+                mExports += "namespace __export { namespace __default = "s + module + "::"s + s + "; }\n"s;
+              else
+                mExports += "namespace __export { inline const decltype("s + module + "::"s + s + ") &__default = "s
+                  + module + "::"s + s + "; }\n"s;
+            }
+          } else if (x->IsEverything()) {
+            if (auto b = x->GetBefore())
+              mExports += "namespace __export { namespace "s + mCppDecl->GetIdentifierName(b)
+                + " = " + module + "::__export; }\n"s;
+            else
+              mExports += "namespace __export { using namespace "s + module + "::__export; }\n"s;
+          } else if (x->GetAsNamespace()) {
+            if (auto b = x->GetBefore())
+              mExports += "namespace __export { namespace "s + mCppDecl->GetIdentifierName(b)
+                + " = " + module + "; }\n"s;
+          } else {
+            if (auto b = x->GetBefore()) {
+              if (b->IsDeclare()) {
+                DeclareNode *decl = static_cast<DeclareNode *>(b);
+                if (decl->GetDeclsNum() == 1)
+                  b = decl->GetDeclAtIndex(0);
+              }
+              if (b->IsImport()) {
+                mExFlag = true;
+                VisitImportNode(static_cast<ImportNode *>(b));
+                mExFlag = false;
+                continue;
+              }
+              std::string target = mCppDecl->GetIdentifierName(b);
+              bool emit = true;
+              if (auto a = x->GetAfter()) {
+                std::string after = mCppDecl->GetIdentifierName(a);
+                if (target == "default" RENAMINGSUFFIX) {
+                  target = module + "::__export::__default";
+                  mExports += "namespace __export { inline const decltype("s + target + ") &"s
+                    + (after == "default" RENAMINGSUFFIX ? "__"s + after : after) + " = "s + target + "; }\n"s;
+                  emit = false;
+                }
+                else if (target != after) {
+                  auto t = a->GetTypeId();
+                  if (t == TY_Namespace)
+                    mExports += "namespace __export { namespace "s + after + " = "s + module + "::"s + target + "; }\n"s;
+                  else if (t == TY_Function)
+                    mExports += "namespace __export { inline const decltype("s + target + ") &"s + after + " = "s
+                                + module + "::"s + target + "; }\n"s;
+                  else
+                    mExports += "namespace __export { using "s + after + " = "s + module + "::"s + target + "; }\n"s;
+                  emit = false;
+                }
+              }
+              if (emit)
+                if (b->IsNamespace())
+                  mExports += "namespace __export { namespace "s + target + " = "s + module + "::"s + target + "; }\n"s;
+                else
+                  mExports += "namespace __export { using "s + module + "::"s + target + "; }\n"s;
+            }
+          }
+        }
+      }
+      return node;
+    }
+};
+
+class ClassDecls : public AstVisitor {
+  private:
+    CppDecl     *mCppDecl;
+    std::string  mDecls;
+
+  public:
+    ClassDecls(CppDecl *c) : mCppDecl(c), mDecls("// class decls\n") {}
+
+    ClassNode *VisitClassNode(ClassNode *node) {
+      std::string ns = mCppDecl->GetNamespace(node);
+      if (ns.empty())
+        mDecls += mCppDecl->EmitTreeNode(node) + ";\n"s;
+      else
+        mDecls += "namespace "s + ns + " {\n"s + mCppDecl->EmitTreeNode(node) + ";\n}\n"s;
+      return node;
+    }
+
+    StructNode *VisitStructNode(StructNode *node) {
+      std::string ns = mCppDecl->GetNamespace(node);
+      if (ns.empty())
+        mDecls += mCppDecl->EmitStructNode(node);
+      else
+        mDecls += "namespace "s + ns + " {\n"s + mCppDecl->EmitTreeNode(node) + "}\n"s;
+      return node;
+    }
+
+    TypeAliasNode *VisitTypeAliasNode(TypeAliasNode* node) {
+      std::string ns = mCppDecl->GetNamespace(node);
+      if (ns.empty())
+        mDecls += mCppDecl->EmitTypeAliasNode(node);
+      else
+        mDecls += "namespace "s + ns + " {\n"s + mCppDecl->EmitTypeAliasNode(node) + "}\n"s;
+      return node;
+    }
+
+    std::string GetDecls() { return mDecls; }
+};
+
+class CollectDecls : public AstVisitor {
+  private:
+    CppDecl     *mCppDecl;
+    std::string  mDecls;
+
+  public:
+    CollectDecls(CppDecl *c) : mCppDecl(c), mDecls("// var decls\n") {}
+
+    FunctionNode *VisitFunctionNode(FunctionNode *node) {
+      return node;
+    }
+
+    LambdaNode *VisitLambdaNode(LambdaNode *node) {
+      return node;
+    }
+
+    DeclNode *VisitDeclNode(DeclNode *node) {
+      std::string def = mCppDecl->EmitTreeNode(node);
+      std::string var = mCppDecl->EmitTreeNode(node->GetVar());
+      std::string ns = mCppDecl->GetNamespace(node);
+      std::string ext = "extern "s + def.substr(0, def.find('=')) + ";\n"s;
+      if (ns.empty())
+        mDecls += ext;
+      else {
+        mDecls += "namespace "s + ns + " {\n"s + ext + "}\n"s;
+        def = "namespace "s + ns + " {\n"s + def + ";\n}\n"s;
+      }
+      mCppDecl->AddDefinition(def + ";\n"s);
+      return node;
+    }
+
+    std::string GetDecls() { return mDecls; }
+};
+
+void CppDecl::AddImportedModule(const std::string& module) {
+  mImportedModules.insert(module);
+}
+
+bool CppDecl::IsImportedModule(const std::string& module) {
+  auto res = mImportedModules.find(module);
+  return res != mImportedModules.end();
+}
+
+void CppDecl::CollectFuncArgInfo(TreeNode* node) {
+  if (!node->IsFunction())
+    return;
+
+  FunctionNode* func = static_cast<FunctionNode*>(node);
+  for (unsigned i = 0; i < func->GetParamsNum(); ++i) {
+    if (auto n = func->GetParam(i)) {
+      // build vector of string pairs of argument types and names
+      std::string name = GetIdentifierName(n);
+      std::string type = GetTypeString(n, n->IsIdentifier()? static_cast<IdentifierNode*>(n)->GetType(): nullptr);
+      type.erase(type.find_last_not_of(' ')+1);  // strip trailing spaces
+      hFuncTable.AddArgInfo(func->GetNodeId(), type, name);
+    }
+  }
+}
+
+std::string CppDecl::EmitModuleNode(ModuleNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string module = GetModuleName();
+  std::string header("__");
+  for(auto &c : module)
+    header += std::toupper(c);
+  header += "__HEADER__\n";
+  std::string str("// TypeScript filename: "s + node->GetFilename() + "\n"s);
+  str += "#ifndef "s + header + "#define "s + header;
+  str += R"""(
+#include "ts2cpp.h"
+)""";
+
+  ImportExportModules xxportModules(this);
+  xxportModules.Visit(node);
+  // All include directived from import/export statements
+  str += xxportModules.GetIncludes();
+
+  // Generate the namespace of current module
+  str += R"""(
+namespace )""" + module + R"""( {
+)""";
+
+  // Generate code for all imports
+  str += xxportModules.GetImports();
+
+  ClassDecls clsDecls(this);
+  clsDecls.VisitTreeNode(node);
+  // declarations of user defined classes
+  str += clsDecls.GetDecls();
+
+  // declarations of all top level functions
+  CfgFunc *mod = mHandler->GetCfgFunc();
+  auto num = mod->GetNestedFuncsNum();
+  for(unsigned i = 0; i < num; ++i) {
+    CfgFunc *func = mod->GetNestedFuncAtIndex(i);
+    TreeNode *node = func->GetFuncNode();
+    std::string funcName = GetIdentifierName(node);
+
+    CollectFuncArgInfo(node);
+    if (!IsClassMethod(node)) {
+      std::string ns = GetNamespace(node);
+      if (!ns.empty())
+        str += "namespace "s + ns + " {\n"s;
+      bool isGenerator = static_cast<FunctionNode*>(node)->IsGenerator();
+      std::string generatorClassDef;
+      if (isGenerator) {
+        str += GeneratorClassDecl(funcName, node->GetNodeId());
+        generatorClassDef = GeneratorClassDef(ns, funcName, node->GetNodeId());
+        AddDefinition(generatorClassDef);
+      }
+      else {
+        // gen function class for each top level function
+        str += FunctionClassDecl(GetTypeString(static_cast<FunctionNode*>(node)->GetRetType(), nullptr), GetIdentifierName(node), node->GetNodeId());
+      }
+      if (!mHandler->IsFromLambda(node)) {
+        // top level funcs instantiated here as function objects from their func class
+        // top level lamda funcs instantiated later in assignment stmts
+        std::string typeName = isGenerator? GeneratorFuncName(funcName): ClsName(funcName);
+        std::string funcinit = typeName + "* "s + funcName + " = new "s + typeName + "();\n"s;
+        if (ns.empty())
+          AddDefinition(funcinit);
+        else
+          AddDefinition("namespace "s + ns + " {\n"s + funcinit + "\n}\n"s);
+        str += "extern "s + typeName + "* "s + funcName + ";\n"s;
+      }
+      if (!ns.empty())
+        str += "\n} // namespace " + ns + '\n';
+    }
+  }
+
+  CollectDecls decls(this);
+  decls.VisitTreeNode(node);
+  // declarations of all variables
+  str += decls.GetDecls();
+
+  // Generate code for all exports
+  str += xxportModules.GetExports() + "\nnamespace __export {}\n"s;
+
+  // init function and an object for dynamic properties
+  str += R"""(
+  // init function for current module
+  void __init_func__();
+
+  // all dynamic properties of current module
+  extern t2crt::Object __module;
+
+} // namespace of current module
+
+#endif
+)""";
+  return str;
+}
+
+std::string CppDecl::EmitFunctionNode(FunctionNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str(GetTypeString(node->GetRetType(), node->GetRetType()));
+  if(node->GetStrIdx())
+    str += " "s + node->GetName();
+  str += "("s;
+  for (unsigned i = 0; i < node->GetParamsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetParam(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  str += ");\n"s;
+
+  if (HasAttrStatic<FunctionNode>(node))
+    str = "static "s + str;
+  return str;
+}
+
+std::string CppDecl::EmitBinOperatorNode(BinOperatorNode *node) {
+  const char *op = Emitter::GetEnumOprId(node->GetOprId());
+  const Precedence precd = *op & 0x3f;
+  const bool rl_assoc = *op >> 6; // false: left-to-right, true: right-to-left
+  std::string lhs, rhs;
+  if (auto n = node->GetOpndA()) {
+    lhs = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && rl_assoc))
+      lhs = "("s + lhs + ")"s;
+  }
+  else
+    lhs = "(NIL) "s;
+  if (auto n = node->GetOpndB()) {
+    rhs = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && !rl_assoc))
+      rhs = "("s + rhs + ")"s;
+  }
+  else
+    rhs = " (NIL)"s;
+  OprId k = node->GetOprId();
+  std::string str;
+  if(k == OPR_Exp) {
+    str = "std::pow("s + lhs + ", "s + rhs + ")";
+  } else {
+    switch(k) {
+      case OPR_Band:
+      case OPR_Bor:
+      case OPR_Bxor:
+      case OPR_Shl:
+      case OPR_Shr:
+        lhs = "static_cast<int32_t>("s + lhs + ")"s;
+        break;
+      case OPR_Zext:
+        lhs = "static_cast<uint32_t>("s + lhs + ")"s;
+        op = "\015>>";
+        break;
+    }
+    str = lhs + " "s + std::string(op + 1) + " "s + rhs;
+  }
+  mPrecedence = precd;
+  if (node->IsStmt())
+    str += ";\n"s;
+  return str;
+
+}
+
+std::string CppDecl::EmitIdentifierNode(IdentifierNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str(GetTypeString(node, node->GetType()));
+  str += " "s + node->GetName();
+
+  if (HasAttrStatic<IdentifierNode>(node))
+    str = "static "s + str;
+  else if (auto n = node->GetInit()) {
+    // emit init for non static class field
+    if (node->GetParent() && node->GetParent()->IsClass())
+      str += " = "s + EmitTreeNode(n);
+  }
+  return str;
+}
+
+std::string CppDecl::EmitPrimTypeNode(PrimTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  return GetTypeString(node);
+}
+
+std::string CppDecl::EmitDeclNode(DeclNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetVar()) {
+    str += "  "s + EmitTreeNode(n);
+  }
+  return str;
+}
+
+std::string CppDecl::EmitCallNode(CallNode *node) {
+  return std::string();
+}
+
+std::string CppDecl::EmitCondBranchNode(CondBranchNode *node) {
+  return std::string();
+}
+
+std::string CppDecl::EmitForLoopNode(ForLoopNode *node) {
+
+  return std::string();
+}
+
+std::string CppDecl::EmitWhileLoopNode(WhileLoopNode *node) {
+  return std::string();
+}
+
+std::string CppDecl::EmitDoLoopNode(DoLoopNode *node) {
+  return std::string();
+}
+
+std::string CppDecl::EmitAssertNode(AssertNode *node) {
+  return std::string();
+}
+
+// Generate code to construct an array of type any from an ArrayLiteral. TODO: merge with similar in cppdef
+std::string CppDecl::ConstructArrayAny(ArrayLiteralNode *node) {
+  if (node == nullptr || !node->IsArrayLiteral())
+    return std::string();
+
+  // Generate array ctor call to instantiate array
+  std::string literals;
+  for (unsigned i = 0; i < node->GetLiteralsNum(); ++i) {
+    if (i)
+      literals += ", "s;
+    if (auto n = node->GetLiteral(i)) {
+      if (n->IsArrayLiteral())
+        // Recurse to handle array elements that are arrays
+        literals += ConstructArrayAny(static_cast<ArrayLiteralNode*>(n));
+      else {
+        // Wrap element in JS_Val. C++ class constructor of JS_Val
+        // will set tupe tag in JS_Val according to element type.
+        literals += "t2crt::JS_Val("s + EmitTreeNode(n) + ")"s;
+      }
+    }
+  }
+  std::string str = ArrayCtorName(1, "t2crt::JS_Val") + "._new({"s + literals + "})"s;
+  return str;
+}
+
+// Generate code to construct an array object with brace-enclosed initializer list TODO: merge with similar in cppdef
+std::string CppDecl::ConstructArray(ArrayLiteralNode *node, int dim, std::string type) {
+  if (type.empty()) {
+    return ConstructArrayAny(node); // proceed as array of type any if no type info
+  }
+  // Generate array ctor call to instantiate array
+  std::string str = ArrayCtorName(dim, type) + "._new({"s;
+  for (unsigned i = 0; i < node->GetLiteralsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetLiteral(i)) {
+      if (n->IsArrayLiteral())
+        str += ConstructArray(static_cast<ArrayLiteralNode*>(n), dim-1, type);
+      else
+        str += EmitTreeNode(n);
+    }
+  }
+  str += "})"s;
+  return str;
+}
+
+std::string CppDecl::EmitArrayLiteralNode(ArrayLiteralNode *node) { // TODO: merge with similar in cppdef
+  if (node == nullptr)
+    return std::string();
+  if (node->GetParent() &&
+      node->GetParent()->IsDecl() ||          // for var decl init
+      node->GetParent()->IsIdentifier() ||    // for default val init in class field decl
+      node->GetParent()->IsFieldLiteral()) {  // for obj decl with struct literal init
+    // emit code to construct array object with brace-enclosed initializer list
+    int dim;
+    std::string str, type;
+    GetArrayTypeInfo(node, dim, type);
+    str = ConstructArray(node, dim, type);
+    return str;
+  }
+
+  // emit code to build a brace-enclosed intializer list (for rhs of array var assignment op)
+  std::string str("{"s);
+  for (unsigned i = 0; i < node->GetLiteralsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetLiteral(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  str += "}"s;
+  return str;
+}
+
+std::string BuildArrayType(int dim, std::string typeStr) {
+  std::string str;
+  str = "t2crt::Array<"s + typeStr + ">*"s;;
+  for (unsigned i = 1; i < dim; ++i) {
+    str = "t2crt::Array<"s + str + ">*"s;;
+  }
+  return str;
+}
+
+std::string CppDecl::EmitArrayTypeNode(ArrayTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+
+  if (node->GetElemType() && node->GetDims()) {
+    str = BuildArrayType(
+      node->GetDims()->GetDimensionsNum(),
+      EmitTreeNode(node->GetElemType()));
+  }
+  return str;
+}
+
+std::string CppDecl::EmitFieldNode(FieldNode *node) {
+  return std::string();
+}
+
+std::string CppDecl::GetTypeString(TreeNode *node, TreeNode *child) {
+  std::string str;
+  if (node) {
+    if (IsGenerator(node)) {  // check generator type
+      if (auto func = GetGeneratorFunc(node))
+        return GeneratorName(GetIdentifierName(func)) + "*"s;
+    }
+    TypeId k = node->GetTypeId();
+    if (k == TY_None || k == TY_Class) {
+      switch(node->GetKind()) {
+        case NK_PrimType:
+          k = static_cast<PrimTypeNode*>(node)->GetPrimType();
+          break;
+        case NK_Identifier:
+        case NK_Function:
+          if (child && child->IsUserType())
+            return EmitTreeNode(child);
+          break;
+        case NK_UserType:
+          return EmitTreeNode(node);
+      }
+    }
+    switch(k) {
+      case TY_Object:
+        return "t2crt::Object* "s;
+      case TY_Function: // Need to handle class constructor type: Ctor_<class>*
+      {
+        std::string funcName = GetClassOfAssignedFunc(node);
+        if (!funcName.empty())
+          return funcName + "* ";
+        else
+          return "t2crt::Function* "s;
+      }
+      case TY_Boolean:
+        return "bool "s;
+      case TY_Int:
+        return "long "s;
+      case TY_String:
+        return "std::string "s;
+      case TY_Number:
+      case TY_Double:
+        return "double "s;
+      case TY_Class:
+        return "t2crt::Object* "s;
+      case TY_Any:
+        return "t2crt::JS_Val "s;
+    }
+    {
+      if (child && child->IsStruct() && static_cast<StructNode*>(child)->GetProp() == SProp_NA) {
+        // This will change pending solution for issue #69.
+        return "t2crt::Object * "s; // object literal type - dynamic-import.ts
+      }
+      str = child ? EmitTreeNode(child) : (k == TY_Array ? "t2crt::Array<t2crt::JS_Val>* "s : Emitter::GetEnumTypeId(k));
+      if (str != "none"s)
+        return str + " "s;
+    }
+  }
+  return "t2crt::JS_Val "s;
+}
+
+std::string CppDecl::EmitUserTypeNode(UserTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  {
+    auto k = node->GetType();
+    if(k == UT_Union || k == UT_Inter)
+      // Generate both vars and arrays of union/intersect type as t2crt::JS_Val of type TY_Object.
+      return "t2crt::JS_Val"s;
+  }
+  std::string str, usrType;
+
+  if (auto n = node->GetId()) {
+    if (n->IsTypeIdClass()) {
+      if (mHandler->IsGeneratorUsed(n->GetNodeId())) {
+        // Check if a generator type : TODO: this needs TI
+        auto func = mHandler->GetGeneratorUsed(n->GetNodeId());
+        usrType = GetIdentifierName(func) + "*"s;
+      } else
+        usrType = n->GetName() + "*"s;
+    }
+    else if (IsBuiltinObj(n->GetName()))
+      usrType = "t2crt::"s + n->GetName() + "*"s;
+    else // TypeAlias Id gets returned here
+      usrType = n->GetName();
+
+    str = usrType; // note: array dimension now come from ArrayTypeNode
+    auto num = node->GetTypeGenericsNum();
+    if(num) {
+      std::string lastChar = "";
+      if (str.back() == '*') {
+        str.pop_back();
+        lastChar = "*";
+      }
+      str += "<"s;
+      for (unsigned i = 0; i < num; ++i) {
+        if (i)
+          str += ", "s;
+        if (auto n = node->GetTypeGeneric(i)) {
+          str += EmitTreeNode(n);
+        }
+      }
+      str += ">"s;
+      str += lastChar;
+    }
+  }
+#if 0
+  auto k = node->GetType();
+  if(k != UT_Regular) {
+    if(!str.empty())
+      str = "using "s + str + " = "s;
+    std::string op = k == UT_Union ? " | "s : " & "s;
+    for (unsigned i = 0; i < node->GetUnionInterTypesNum(); ++i) {
+      if(i)
+        str += op;
+      str += EmitTreeNode(node->GetUnionInterType(i));
+    }
+  }
+#endif
+  return str;
+}
+
+std::string CppDecl::EmitClassNode(ClassNode *node) {
+  std::string str;
+  std::string base;
+  std::string staticProps;
+
+  if (node == nullptr)
+    return std::string();
+
+  std::string clsName = node->GetName();
+  // 1. c++ class for JS object
+  base = (node->GetSuperClassesNum() != 0)? node->GetSuperClass(0)->GetName() : "t2crt::Object";
+  str += "class "s + clsName + " : public "s + base + " {\n"s;
+
+  str += "public:\n";
+
+  // constructor decl
+  str += "  "s + clsName + "(t2crt::Function* ctor, t2crt::Object* proto);\n"s;
+  str += "  ~"s + clsName + "(){}\n";
+
+  // class field decl and init. TODO: handle private, protected attrs.
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    auto n = node->GetField(i);
+    str += "  "s + EmitTreeNode(n);
+
+    if (n->IsIdentifier()) {
+      if (HasAttrStatic<IdentifierNode>(static_cast<IdentifierNode*>(n))) {
+        // static field - add field to ctor prop and init later at field def in cpp
+        staticProps += tab(3) + "this->AddProp(\""s + clsName + "\", t2crt::JS_Val("s +
+          TypeIdToJSTypeCXX[n->GetTypeId()] + ", &"s + clsName + "::"s + GetIdentifierName(n) + "));\n"s;
+      }
+    }
+    str += ";\n";
+  }
+  for (unsigned i = 0; i < node->GetMethodsNum(); ++i) {
+    str += tab(1) + EmitFunctionNode(node->GetMethod(i));
+  }
+
+  // 2. c++ class for the JS object's JS constructor
+  std::string indent = tab(1);
+  if (!staticProps.empty()) staticProps = "\n"s + staticProps;
+  base = (node->GetSuperClassesNum() != 0)? (node->GetSuperClass(0)->GetName()+"::Ctor"s) : "t2crt::Function";
+  str += indent + "class Ctor : public "s + base + " {\n"s;
+  str += indent + "public:\n";
+  str += indent + "  Ctor(t2crt::Function* ctor, t2crt::Object* proto, t2crt::Object* prototype_proto) : "s +
+    base + "(ctor, proto, prototype_proto) {"s + staticProps + tab(2) + "}\n"s;
+
+  // constructor function
+  for (unsigned i = 0; i < node->GetConstructorsNum(); ++i) {
+    std::string ctor;
+    if (auto c = node->GetConstructor(i)) {
+      ctor = indent + "  "s + clsName + "* operator()("s + clsName + "* obj"s;
+      for (unsigned k = 0; k < c->GetParamsNum(); ++k) {
+        ctor += ", "s;
+        if (auto n = c->GetParam(k)) {
+          ctor += EmitTreeNode(n);
+        }
+      }
+      ctor += ");\n";
+      str += ctor;
+    }
+  }
+
+  // Generate decl for default constructor function if none declared for class
+  if (node->GetConstructorsNum() == 0)
+    str += indent + "  "s + clsName + "* operator()("s + clsName + "* obj);\n"s;
+
+  // Generate new() function
+  str += indent + "  "s+clsName+"* _new() {return new "s+clsName+"(this, this->prototype);}\n"s;
+  str += indent + "  virtual const char* __GetClassName() const {return \""s + clsName + " \";}\n"s;
+  str += indent + "};\n";
+  str += indent + "static Ctor ctor;\n"s;
+  str += "};\n";
+  return str;
+}
+
+std::string CppDecl::EmitNewNode(NewNode *node) {
+  if (node == nullptr || node->GetAttrsNum() > 0)
+    return std::string();
+
+  std::string str;
+  MASSERT(node->GetId() && "No mId on NewNode");
+  if (node->GetId() && node->GetId()->IsTypeIdClass()) {
+    // Generate code to create new obj and call constructor
+    str = node->GetId()->GetName() + "::ctor("s + node->GetId()->GetName() + "::ctor._new("s;
+  } else if (IsBuiltinObj(node->GetId()->GetName())) {
+    // Check for builtin obejcts: t2crt::Object, t2crt::Function, etc.
+    str = node->GetId()->GetName() + "::ctor._new("s;
+  } else  {
+    str = "new "s + EmitTreeNode(node->GetId());
+    str += "("s;
+  }
+
+  auto num = node->GetArgsNum();
+  for (unsigned i = 0; i < num; ++i) {
+    if (i || node->GetId()->IsTypeIdClass())
+      str += ", "s;
+    if (auto n = node->GetArg(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  str += ")"s;
+  mPrecedence = '\024';
+  return str;
+}
+
+std::string CppDecl::EmitInterface(StructNode *node) {
+  std::string str, ifName;
+  std::string def;
+
+  if (node == nullptr)
+    return std::string();
+
+  std::string superClass = "t2crt::Object";
+  if (node->GetSupersNum() > 0) {
+    auto n = node->GetSuper(0);
+    superClass = EmitTreeNode(n);
+    if (superClass.back() == '*')
+      superClass.pop_back();
+  }
+  ifName = GetIdentifierName(node);
+  str = "class "s + ifName + " : public "s + superClass + " {\n"s;
+  str += "  public:\n"s;
+
+  // Generate code to add prop in class constructor
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (auto n = node->GetField(i)) {
+      str += "    "s + EmitTreeNode(n) + ";\n"s;
+      if (n->IsIdentifier()) {
+        def += tab(1) + GenClassFldAddProp("this", ifName, n->GetName(),
+          GetTypeString(n, static_cast<IdentifierNode*>(n)->GetType()),
+          TypeIdToJSTypeCXX[hlpGetTypeId(n)]) + ";\n"s;
+      }
+    }
+  }
+  if (!def.empty())
+    def = "\n"+def;
+
+  str += "    "s  + ifName + "() {};\n"s;
+  str += "    ~"s + ifName + "() {};\n"s;
+  str += "    "s + ifName + "(t2crt::Function* ctor, t2crt::Object* proto);\n"s;
+  str += "    "s + ifName + "(t2crt::Function* ctor, t2crt::Object* proto, std::vector<t2crt::ObjectProp> props): "s + superClass + "(ctor, proto, props) {}\n"s;
+  str += "};\n"s;
+
+  def = ifName + "::"s + ifName + "(t2crt::Function* ctor, t2crt::Object* proto): "s + superClass + "(ctor, proto) {" + def + "}\n";
+  AddDefinition(def);
+  return str;
+}
+
+// Generate C++ class def for the TS num type here and instance in CppDef EmitStructNode.
+// TS enum member field can be either Identifier or Literal string (of any character).
+// TS enum member value can be either long, double, or string.
+// Numeric enum member with no assigned value default to val of preceding member plus 1.
+std::string CppDecl::EmitTSEnum(StructNode *node) {
+  std::string str, init;
+  TypeId memberValType = TY_None;
+
+  if (node == nullptr)
+    return std::string();
+
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    // Enum member field default to TY_Int if not specified - should this be set by FE?
+    if (node->GetField(i)->IsTypeIdNone())
+      node->GetField(i)->SetTypeId(TY_Int);
+  }
+
+  if (node->GetFieldsNum() > 0) {
+    memberValType = node->GetField(0)->GetTypeId();
+    MASSERT(memberValType == TY_String ||
+            memberValType == TY_Double ||
+            memberValType == TY_Int && "Unsupported Enum type");
+  }
+
+  str = "class "s;
+  std::string enumClsName, enumName;
+  if (auto n = node->GetStructId()) {
+    enumName = GetIdentifierName(n);
+    enumClsName = "Enum_"s + enumName;
+    str += enumClsName + " : public t2crt::Object {\n"s;
+  }
+  str += "  public:\n"s;
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (auto n = node->GetField(i)) {
+      if (n->IsLiteral()) {
+        MWARNING("Literal enum field not supported yet");
+        continue;
+      }
+      IdentifierNode* id = static_cast<IdentifierNode*>(n);
+      if (id->GetInit()) {
+        init = EmitTreeNode(id->GetInit());
+      } else {
+        if (memberValType == TY_Int || memberValType == TY_Double) {
+           // if numeric member and no initialzer, set to 0 or last field + 1
+          if (i == 0)
+            init = "0";
+          else
+            init = GetIdentifierName(node->GetField(i-1)) + "+1"s;
+        }
+      }
+      str += "    const "s + EmitTreeNode(n) + " = "s + init + ";\n"s;
+    }
+  }
+  str += "    "s  + enumClsName + "() {};\n"s;
+  str += "    ~"s + enumClsName + "() {};\n"s;
+
+  std::string def = enumClsName + "* "s + enumName + ";\n"s;
+  AddDefinition(def);
+  str += "};\nextern "s + def;
+  return str;
+}
+
+std::string CppDecl::EmitStructNode(StructNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  const char *suffix = ";\n";
+  switch(node->GetProp()) {
+#if 0
+    case SProp_CStruct:
+      str = "struct "s;
+      break;
+    case SProp_NA:
+      str = ""s;
+      break;
+#endif
+    case SProp_TSEnum:
+      str = EmitTSEnum(node);
+      return str;
+    case SProp_TSInterface:
+    case SProp_NA: // for classes generated by TI
+      str = EmitInterface(node);
+      return str;
+    default:
+      return std::string();
+      MASSERT(0 && "Unexpected enumerator");
+  }
+#if 0
+  if (auto n = node->GetStructId()) {
+    str += EmitIdentifierNode(n);
+  }
+
+  auto num = node->GetTypeParamsNum();
+  if(num) {
+    str += "<"s;
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetTypeParamAtIndex(i))
+        str += EmitTreeNode(n);
+    }
+    str += ">"s;
+  }
+
+  for (unsigned i = 0; i < node->GetSupersNum(); ++i) {
+    str += i ? ", "s : " extends "s;
+    if (auto n = node->GetSuper(i))
+      str += EmitTreeNode(n);
+  }
+  str += " {\n"s;
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (auto n = node->GetField(i)) {
+      str += EmitTreeNode(n) + suffix;
+    }
+  }
+
+  if (auto n = node->GetNumIndexSig())
+    str += EmitNumIndexSigNode(n) + "\n"s;;
+  }
+  if (auto n = node->GetStrIndexSig()) {
+    str += EmitStrIndexSigNode(n) + "\n";
+  }
+
+  for (unsigned i = 0; i < node->GetMethodsNum(); ++i) {
+    if (auto n = node->GetMethod(i)) {
+      std::string func = EmitFunctionNode(n);
+      if (func.substr(0, 9) == "function ")
+        func = func.substr(9);
+      size_t index = func.rfind(')');
+      if (index != std::string::npos) {
+        std::string t = func.substr(index);
+        Replace(t, "=>", ":");
+        func = func.substr(0, index) + t;
+      }
+      str += func.length() > 2 && func.substr(func.length() - 2) == ";\n" ? func : func + ";\n"s;
+    }
+  }
+  str += "}\n"s;
+#endif
+  return HandleTreeNode(str, node);
+}
+
+std::string CppDecl::EmitNumIndexSigNode(NumIndexSigNode *node) {
+  return std::string();
+}
+
+std::string CppDecl::EmitStrIndexSigNode(StrIndexSigNode *node) {
+  return std::string();
+}
+
+std::string CppDecl::EmitTypeAliasNode(TypeAliasNode* node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str, alias;
+
+  if (auto n = node->GetId()) {
+    if (n->IsUserType()) {
+      str = EmitTreeNode(n);
+      if (str.back() == '*')
+        str.pop_back();
+    }
+  }
+  if (auto m = node->GetAlias()) {
+    if (m->IsUserType()) {
+      alias = EmitTreeNode(m);
+      if (alias.back() == '*')
+        alias.pop_back();
+      str = "using "s + str + " = "s + alias + ";\n";
+    } else { // if (m->IsStruct()) {
+      // todo
+      str = "// type alias for "s + str + '\n';;
+    }
+  }
+  return str;
+}
+
+std::string CppDecl::EmitLiteralNode(LiteralNode *node) {
+  if (node == nullptr)
+    return std::string();
+  LitData lit = node->GetData();
+  std::string str(AstDump::GetEnumLitData(lit));
+  if(lit.mType == LT_StringLiteral || lit.mType == LT_CharacterLiteral)
+    str = '"' + str + '"';
+  mPrecedence = '\030';
+  str = HandleTreeNode(str, node);
+  if (auto n = node->GetType()) {
+    str += ": "s + EmitTreeNode(n);
+  }
+  if (auto n = node->GetInit()) {
+    str += " = "s + EmitTreeNode(n);
+  }
+  return str;
+}
+
+} // namespace maplefe
diff --git a/src/MapleFE/ast2cpp/src/cpp_definition.cpp b/src/MapleFE/ast2cpp/src/cpp_definition.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d6b1935446c577ae09fecea01366394615c1d2df
--- /dev/null
+++ b/src/MapleFE/ast2cpp/src/cpp_definition.cpp
@@ -0,0 +1,1584 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "cpp_definition.h"
+#include "helper.h"
+
+namespace maplefe {
+
+std::string CppDef::EmitCtorInstance(ClassNode *c) {
+  std::string str, thisClass, ctor, proto, prototypeProto;
+  ctor = "&t2crt::Function::ctor";
+  thisClass = c->GetName();
+  if (c->GetSuperClassesNum() == 0) {
+    proto = "t2crt::Function::ctor.prototype";
+    prototypeProto = "t2crt::Object::ctor.prototype";
+  } else {
+    proto = c->GetSuperClass(0)->GetName() + "::ctor"s;
+    prototypeProto = proto + ".prototype"s;
+    proto.insert(0, "&"s, 0, std::string::npos);
+  }
+  str = "\n// Init class ctor as a static class field for "+ thisClass+ "\n"s;
+  str += thisClass + "::Ctor "s + thisClass+"::ctor("s +ctor+","s+proto+","+prototypeProto+");\n\n"s;
+
+  // piggy back generation of static field definition
+  for (unsigned i = 0; i < c->GetFieldsNum(); ++i) {
+    auto n = c->GetField(i);
+    if (n->IsIdentifier() &&
+        HasAttrStatic<IdentifierNode>(static_cast<IdentifierNode*>(n))) {
+      str += mCppDecl.GetTypeString(n, n) + " "s + thisClass + "::"s + EmitTreeNode(n);
+      str += ";\n";
+    }
+  }
+
+  return str;
+}
+
+// Emit default constructor func def and instance
+std::string CppDef::EmitDefaultCtor(ClassNode *c) {
+  if (c == nullptr)
+    return std::string();
+
+  std::string str, className;
+  className = c->GetName();
+  str = "\n"s;
+  str += className + "* "s + className + "::Ctor::operator()("s + className + "* obj)"s;
+  str += "{ return obj; }\n"s;
+  str += EmitCtorInstance(c);
+
+  return str;
+}
+
+std::string CppDef::EmitCppCtor(ClassNode* node) {
+  std::string str, base, props;
+  props = EmitClassProps(node);
+  if (!props.empty())
+    props = "\n"s + props;
+  base = (node->GetSuperClassesNum() != 0)? node->GetSuperClass(0)->GetName() : "t2crt::Object";
+  str += node->GetName() + "::"s + node->GetName() + "(t2crt::Function* ctor, t2crt::Object* proto): "s
+    + base + "(ctor, proto)"  + " {"s + props +"}\n"s;
+  return str;
+}
+
+std::string CppDef::EmitModuleNode(ModuleNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string module = GetModuleName();
+
+  // include directives
+  std::string str("// TypeScript filename: "s + node->GetFilename() + "\n"s);
+  str += "#include <iostream>\n#include \""s + GetBaseFilename() + ".h\"\n\n"s;
+
+  // start a namespace for this module
+  str += "namespace "s + module + " {\n"s;
+
+  // definitions of default class constructors
+  for (unsigned i = 0; i < node->GetTreesNum(); ++i) {
+    if (auto n = node->GetTree(i))
+      if (n->IsClass()) {
+        str += EmitCppCtor(static_cast<ClassNode*>(n));
+        if (static_cast<ClassNode*>(n)->GetConstructorsNum() == 0)
+          str += EmitDefaultCtor(static_cast<ClassNode*>(n));
+      }
+  }
+
+  // definitions
+  str += mCppDecl.GetDefinitions();
+
+  // definitions of all top level functions in current module
+  CfgFunc *mod = mHandler->GetCfgFunc();
+  auto num = mod->GetNestedFuncsNum();
+  for(unsigned i = 0; i < num; ++i) {
+    CfgFunc *func = mod->GetNestedFuncAtIndex(i);
+    TreeNode *node = func->GetFuncNode();
+    if (!IsClassMethod(node)) {
+      hFuncTable.AddTopLevelFunc(node);
+      hFuncTable.AddNameIsTopLevelFunc(GetIdentifierName(node));
+    }
+    std::string s = EmitTreeNode(node) + GetEnding(node);
+    str += s;
+  }
+
+  // definition of init function of current module
+  str += R"""(void __init_func__() {
+  // bind "this" to current module
+  static bool __init_once = false;
+  if (__init_once) return;
+  __init_once = true;
+)""" + mCppDecl.GetInits();
+  mIsInit = true;
+  for (unsigned i = 0; i < node->GetTreesNum(); ++i) {
+    if (auto n = node->GetTree(i)) {
+      if (!n->IsClass()) {
+        std::string s = EmitTreeNode(n);
+        if (!s.empty())
+          str += tab(1) + s + (s.back()=='\n'? "": ";\n");
+      }
+    }
+  }
+  str += R"""(}
+
+  t2crt::Object __module;
+} // namespace of current module
+)""";
+
+  AST_Handler *handler = mHandler->GetASTHandler();
+  HandlerIndex idx = handler->GetHandlerIndex(node->GetFilename());
+  // If the program starts from this module, generate the main function
+  if (idx == 0) {
+    str += R"""(
+int main(int argc, char **argv) {
+  std::cout << std::boolalpha;
+)""" + "  "s + module + R"""(::__init_func__(); // call its __init_func__()
+  return 0;
+}
+)""";
+  }
+  return str;
+}
+
+std::string CppDef::EmitExportNode(ExportNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  auto num = node->GetPairsNum();
+  for (unsigned i = 0; i < node->GetPairsNum(); ++i) {
+    if (auto x = node->GetPair(i)) {
+      if (x->IsDefault() && !x->IsRef()) {
+        if (auto n = x->GetBefore()) {
+          std::string v = EmitTreeNode(n);
+          str += "__export::__default = "s + v + ";\n"s;
+        }
+      }
+      if(node->GetTarget() == nullptr &&
+          !x->IsDefault() &&
+          !x->IsEverything() &&
+          !x->GetAsNamespace() &&
+          !x->IsSingle()) {
+        //str += EmitXXportAsPairNode(x);
+        if (auto n = x->GetBefore())
+          if ((!n->IsIdentifier() || static_cast<IdentifierNode *>(n)->GetInit() != nullptr) &&
+              !n->IsStruct() &&
+              !n->IsClass() &&
+              !n->IsUserType())
+            str += EmitTreeNode(n);
+      }
+    }
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string CppDef::EmitImportNode(ImportNode *node) {
+  return std::string();
+}
+
+std::string CppDef::EmitXXportAsPairNode(XXportAsPairNode *node) {
+  return std::string();
+}
+
+inline bool IsClassMethod(FunctionNode* f) {
+  return (f && f->GetParent() && f->GetParent()->IsClass());
+}
+
+std::string CppDef::EmitClassProps(TreeNode* node) {
+  std::string clsFd, addProp;
+  MASSERT(node->IsClass() && "Not NK_Class node");
+  ClassNode* c = static_cast<ClassNode*>(node);
+  for (unsigned i = 0; i < c->GetFieldsNum(); ++i) {
+    auto node = c->GetField(i);
+    if (!node->IsIdentifier())
+      // StrIndexSig, NumIndexSig, ComputedName have to be handled at run time
+      continue;
+    IdentifierNode* id = static_cast<IdentifierNode*>(node);
+    if (HasAttrStatic<IdentifierNode>(id)) // static props are added to class ctor
+      continue;
+    std::string fdName = node->GetName();
+    std::string fdType = mCppDecl.GetTypeString(node, id->GetType());
+    TypeId typeId = node->GetTypeId();
+    if (typeId == TY_None) {
+      if (auto n = id->GetType()) {
+        if (n->IsPrimType())
+          typeId = static_cast<PrimTypeNode*>(n)->GetPrimType();
+        else if (n->IsUserType())
+          typeId = static_cast<UserTypeNode*>(n)->GetTypeId();
+      }
+    }
+    addProp += "  "s + GenClassFldAddProp("this", c->GetName(), fdName, fdType, TypeIdToJSTypeCXX[typeId]) + ";\n"s;
+  }
+  return "  // Add class fields to obj prop list\n"s + clsFd + addProp;
+}
+
+// "var" declarations in TS/JS functions are function scope.
+// Duplicate decls may appear in different blocks within
+// function but should all refer to the same function scope var.
+//
+// So we scan for JS_Var decls with dup names in a function and emit
+// a decl list with unique names for insert into function definition.
+//
+// The var may be initialized to different values in different
+// blocks which will be done in the individual DeclNodes (re: var-dup.ts)
+std::string CppDef::EmitFuncScopeVarDecls(FunctionNode *node) {
+  std::unordered_map<std::string, DeclNode*>varDeclsInScope;
+  ASTScope* s = node->GetScope();
+  for (int i = 0; i < s->GetDeclNum(); i++) {
+    // build list of var decls (no dups) in function scope
+    TreeNode* n = s->GetDecl(i);
+    if (!n->IsDecl())
+      continue;
+    DeclNode* d = static_cast<DeclNode*>(n);
+    if (d->GetProp() == JS_Var) {
+      // skip var decl name duplicates - same name but diff
+      // type is illegal in typescript so not checked here
+      std::unordered_map<std::string, DeclNode*>::iterator it;
+      it = varDeclsInScope.find(d->GetVar()->GetName());
+      if (it == varDeclsInScope.end()) {
+        varDeclsInScope[d->GetVar()->GetName()] = d;
+      }
+    }
+  }
+  std::string str;
+  for (auto const&[key, val] : varDeclsInScope) {
+    // Emit decl for the var (just type and name). The init part
+    // to be emitted when corresponding DeclNode is processed
+    str += tab(1) + mCppDecl.EmitTreeNode(val->GetVar()) + ";\n"s;
+  }
+  return str;
+}
+
+std::string CppDef::EmitYieldNode(YieldNode *node) {
+  if (node == nullptr)
+    return std::string();
+  //std::string str(node->IsTransfer() ? "yield* " : "yield ");
+  std::string str, res;
+  if (auto n = node->GetResult())
+    res = EmitTreeNode(n);
+  else
+    res = "undefined";
+
+  std::string yieldLabel = GenFnLabels.NextYieldLabel();
+  str += "  yield = &&" + yieldLabel + ";\n";           // save yp
+  str += "  res.value = t2crt::JS_Val(" +res+ ");\n";  // init value and return
+  str += "  res.done  = false;\n";
+  str += "  return;\n";
+  str += yieldLabel + ":\n";                            // label for this yp
+
+  mPrecedence = '\024';
+  return str;
+}
+
+std::string CppDef::EmitWhileLoopNode(WhileLoopNode *node) {
+//  return(Emitter::EmitWhileLoopNode(node));
+
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  std::string loopLabel;
+
+  if(auto n = node->GetLabel()) {
+    str = EmitTreeNode(n) + ":\n"s;
+  }
+
+  if (mIsGenerator) { // insert label and loop cond check
+    loopLabel = GenFnLabels.NextLoopLabel();
+    str += loopLabel + ":\n";
+    if (auto n = node->GetCond()) {
+      std::string cond = EmitTreeNode(n);
+      str += "  if (!(" +cond+ "))\n";
+      str += "    goto " +loopLabel+ "_exit;\n";
+    }
+  } else {            // normal while loop
+    str += "while("s;
+    if (auto n = node->GetCond()) {
+      str += EmitTreeNode(n);
+    }
+    str += ')';
+  }
+
+  if (auto n = node->GetBody()) {
+    str += EmitTreeNode(n) + GetEnding(n);
+    if (mIsGenerator) {
+      str.insert(str.find_first_of("{"), "  ");
+      str.insert(str.find_last_of("}"), "  ");
+    }
+  }
+
+  if (mIsGenerator) { // insert loop back and label at loop exit
+    str += "  goto " +loopLabel+ ";\n";
+    str += loopLabel + "_exit:";
+  }
+
+  return HandleTreeNode(str, node);
+}
+
+
+std::string CppDef::EmitFunctionNode(FunctionNode *node) {
+  if (mIsInit || node == nullptr)
+    return std::string();
+
+  bool isTopLevel = hFuncTable.IsTopLevelFunc(node);
+  std::string str;
+  str += "\n";
+  str += FunctionHeader(node, mCppDecl.GetTypeString(node->GetRetType(), node->GetRetType()));
+  mIsGenerator = node->IsGenerator();
+
+  int bodyPos = str.size();
+  if (auto n = node->GetBody()) {
+    auto varDecls = EmitFuncScopeVarDecls(node);
+    auto s = EmitBlockNode(n);
+    if (isTopLevel)
+      Emitter::Replace(s, "this", "_this");
+    if(s.empty() || s.front() != '{')
+      str += "{\n"s + s + "}\n"s;
+    else
+      str += s;
+    str.insert(bodyPos+2, varDecls);  // skip over leading "{\n" of generated block
+  } else
+    str += "{}\n"s;
+
+  if (mIsGenerator) {
+    str.insert(str.find_first_of("{")+1, GeneratorFn_start);
+    str.insert(str.find_last_of("}"), GeneratorFn_return);
+  }
+
+  if (node->IsConstructor()) {
+    Emitter::Replace(str, "this->", "obj->", 0);
+    std::string ctorBody;
+    ctorBody += "  return obj;\n"s;
+    str.insert(str.size()-2, ctorBody, 0, std::string::npos);
+    str += EmitCtorInstance(static_cast<ClassNode*>(node->GetParent()));
+  }
+
+  if (mIsGenerator) {
+    mIsGenerator = false;
+    GenFnLabels.ResetLabels();
+  }
+  return str;
+}
+
+std::string CppDef::EmitIdentifierNode(IdentifierNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str = GetQualifiedName(node);
+  if (auto n = node->GetInit()) {
+    str += " = "s + EmitTreeNode(n);
+  }
+  mPrecedence = '\030';
+  return str;
+}
+
+// Generate code to create object instance that was declared using
+// an object literal. First process the object literals in the
+// StructLiteralNode argument to build the proplist list (vector of
+// type ObjectProp) to be used as initializer, then generate call to
+// the  builtin Object constructor with initializer as parameter.
+std::string CppDef::EmitStructLiteralNode(StructLiteralNode* node) {
+  std::string str;
+  int stops = 2;
+  // Build proplist to be used as initializer
+  str += "\n"s + tab(stops) + "std::vector<t2crt::ObjectProp>({\n"s;
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (i)
+      str += ",\n"s;
+    if (auto field = node->GetField(i)) {
+      auto lit = field->GetLiteral();
+      std::string fieldName = EmitTreeNode(field->GetFieldName());
+      TypeId typId = lit->GetTypeId();
+      std::string fieldVal = EmitTreeNode(lit);
+      str += tab(stops+1);
+      switch(typId) {
+        case TY_Object:
+          break;
+        case TY_Function:
+          break;
+        case TY_Array:
+          fieldVal = EmitTreeNode(lit); // ArrayLiteralNode
+          str += "std::make_pair(\""s + fieldName + "\", t2crt::JS_Val("s + fieldVal + "))"s;
+          break;
+        case TY_Boolean:
+          str += "std::make_pair(\""s + fieldName + "\", t2crt::JS_Val(bool("s + fieldVal + ")))"s;
+          break;
+        case TY_None:
+          if (fieldVal.compare("true") == 0 || fieldVal.compare("false") == 0)
+            str += "std::make_pair(\""s + fieldName + "\", t2crt::JS_Val(bool("s + fieldVal + ")))"s;
+          else
+            // if no type info, use type any (JS_Val)
+            str += "std::make_pair(\""s + fieldName + "\", t2crt::JS_Val("s + fieldVal + "))"s;
+          break;
+        case TY_Int:
+          str += "std::make_pair(\""s + fieldName + "\", t2crt::JS_Val(int64_t("s + fieldVal + ")))"s;
+          break;
+        case TY_String:
+          str += "std::make_pair(\""s + fieldName + "\", t2crt::JS_Val("s + fieldVal + "))"s;
+          break;
+        case TY_Number:
+        case TY_Double:
+          str += "std::make_pair(\""s + fieldName + "\", t2crt::JS_Val(double("s + fieldVal + ")))"s;
+          break;
+        case TY_Class:
+          // Handle embedded t2crt::ObjectLiterals recursively
+          if (lit->IsStructLiteral()) {
+            std::string props = EmitStructLiteralNode(static_cast<StructLiteralNode*>(lit));
+            str += "std::make_pair(\""s + fieldName + "\", t2crt::JS_Val("s + props + "))"s;
+          }
+          break;
+      }
+    }
+  }
+  str += " })"s;
+  // Generate code to call builtin Object constructor with the initializer proplist.
+  str = "t2crt::Object::ctor._new("s + str + ")"s;
+  return str;
+}
+
+std::string CppDef::GenDirectFieldInit(std::string varName, StructLiteralNode* node) {
+  std::string str;
+  //str += ";\n"s;
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (auto field = node->GetField(i)) {
+      auto lit = field->GetLiteral();
+      std::string fieldName = EmitTreeNode(field->GetFieldName());
+      std::string fieldVal = EmitTreeNode(lit);
+      if (mHandler->IsCppField(field)) // Check if it accesses a Cxx class field
+        str += tab(1) + varName + "->"s + fieldName + " = "s + fieldVal + ";\n"s;
+      else
+        str += tab(1) + "(*"s + varName + ")[\""s + fieldName + "\"] = "s + fieldVal + ";\n"s;
+    }
+  }
+  return str;
+}
+
+std::string CppDef::GenObjectLiteral(TreeNode* var, std::string varName, TreeNode* varIdType, StructLiteralNode* node) {
+  if (varName.empty())
+    return std::string();
+
+  std::string str;
+  // UserType can be TS interface, class, type alias, builtin (t2crt::Object, t2crt::Record..)
+  UserTypeNode* userType = (varIdType && varIdType->IsUserType())? (UserTypeNode*)varIdType: nullptr;
+
+  if (userType == nullptr) {
+    // no type info - create instance of builtin t2crt::Object with proplist
+    str = varName+ " = "s + EmitTreeNode(node);
+  } else if (IsVarTypeClass(var)) {
+    // init var of type TS class
+    // - create obj instance of user defined class and do direct field access init
+    // - todo: handle class with generics
+    str = varName+ " = "s +userType->GetId()->GetName()+ "::ctor._new();\n"s;
+    str += GenDirectFieldInit(varName, node);
+  } else {
+    // type is builtin (e.g. t2crt::Record) and StructNode types (e.g. TSInterface)
+    // create instance of type but set constructor to the builtin t2crt::Object.
+    str = varName+ " = new "s +EmitUserTypeNode(userType)+ "(&t2crt::Object::ctor, t2crt::Object::ctor.prototype);\n"s;
+    auto n = mHandler->FindDecl(static_cast<IdentifierNode*>(userType->GetId()));
+    if (n && n->IsStruct() && static_cast<StructNode*>(n)->GetProp() == SProp_TSInterface) {
+      str += GenDirectFieldInit(varName, node); // do direct field init
+    }
+  }
+  return str;
+}
+
+// Generate code to construct an array of type any from an ArrayLiteral.
+std::string CppDef::ConstructArrayAny(ArrayLiteralNode *node) {
+  if (node == nullptr || !node->IsArrayLiteral())
+    return std::string();
+
+  // Generate array ctor call to instantiate array
+  std::string literals;
+  for (unsigned i = 0; i < node->GetLiteralsNum(); ++i) {
+    if (i)
+      literals += ", "s;
+    if (auto n = node->GetLiteral(i)) {
+      if (n->IsArrayLiteral())
+        // Recurse to handle array elements that are arrays
+        literals += ConstructArrayAny(static_cast<ArrayLiteralNode*>(n));
+      else {
+        // Wrap element in JS_Val. C++ class constructor of JS_Val 
+        // will set tupe tag in JS_Val according to element type. 
+        literals += "t2crt::JS_Val("s + EmitTreeNode(n) + ")"s;
+      }
+    }
+  }
+  std::string str = ArrayCtorName(1, "t2crt::JS_Val") + "._new({"s + literals + "})"s;
+  return str;
+}
+
+// Generate code to construct an array object with brace-enclosed initializer list
+std::string CppDef::ConstructArray(ArrayLiteralNode *node, int dim, std::string type) {
+  if (type.empty()) {
+    return ConstructArrayAny(node); // proceed as array of type any if no type info
+  } 
+  // Generate array ctor call to instantiate array
+  std::string str = ArrayCtorName(dim, type) + "._new({"s;
+  for (unsigned i = 0; i < node->GetLiteralsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetLiteral(i)) {
+      if (n->IsArrayLiteral())
+        str += ConstructArray(static_cast<ArrayLiteralNode*>(n), dim-1, type);
+      else
+        str += EmitTreeNode(n);
+    }
+  }
+  str += "})"s;
+  return str;
+}
+
+// decl of global var is handled by EmitDeclNode in cpp_declaration
+// decl of function vars of type JS_Var is handled in EmitFuncSCopeVarDecls
+// This function handles init of global/func var, and decl/init of func let/const.
+//
+// Declaration of Javascript "var", "let" an "const" variables:
+// - "var" decls are function/global scoped
+// - "let" and "const" are block scoped
+// TS/JS allows duplicate "var" declarations in global scope as well as
+// function scope. Duplicate global scope var decls are resolved
+// by the front end which make only 1 decl for the dup and changes any inits
+// in the dup decls to assigments. Duplicate function scope var decls are
+// handled in CppDef::EmitFuncScopeVarDecls.
+//
+std::string CppDef::EmitDeclNode(DeclNode *node) {
+  if (node == nullptr)
+    return std::string();
+
+  std::string str, varStr;
+  TreeNode* idType = nullptr;
+  TypeId varType = TY_None;
+
+  //std::string str(Emitter::GetEnumDeclProp(node->GetProp()));
+
+  // For func var of JS_Var and global vars, emit var name
+  // For func var of JS_Let/JS_Const, emit both var type & name
+  if (auto n = node->GetVar()) {
+    varType = n->GetTypeId();
+    if (mIsInit || node->GetProp() == JS_Var) {
+      // handle declnode inside for-of/for-in (uses GetSet() and has null GetInit())
+      if (!node->GetInit() && node->GetParent() && !node->GetParent()->IsForLoop())
+        return std::string();
+      varStr = EmitTreeNode(n);            // emit var name only
+    } else {
+      varStr = mCppDecl.EmitTreeNode(n);   // emit both var type and name
+    }
+    if (n->IsIdentifier()) {
+      idType = static_cast<IdentifierNode*>(n)->GetType();
+    }
+  }
+  if (auto n = node->GetInit()) {
+    if (n->IsStructLiteral())
+      str += GenObjectLiteral(node->GetVar(), varStr, idType, static_cast<StructLiteralNode*>(n));
+    else if (node->GetVar()->IsIdentifier() && n->IsIdentifier() && n->IsTypeIdClass())
+      str += varStr + "= &"s + n->GetName() + "::ctor"s;           // init with ctor address
+    else if (n->IsFunction()) {
+      if (hFuncTable.IsTopLevelFunc(n)) {
+        str += varStr + " = new "s + "Cls_" + n->GetName() + "()"s;
+        hFuncTable.AddNameIsTopLevelFunc(varStr);
+      }
+    } else {
+      str += varStr + " = ";
+      if (varType == TY_None)  // no type info. assume TY_Any and wrap val in JS_Val
+        str += "t2crt::JS_Val("s + EmitTreeNode(n) + ")"s;
+      else
+        str += EmitTreeNode(n);
+    }
+  } else {
+    str = varStr;
+  }
+  return str;
+}
+
+static bool QuoteStringLiteral(std::string &s) {
+  if(s.front() != '"' || s.back() != '"')
+    return false;
+  s = s.substr(1, s.length() - 2);
+  Emitter::Replace(s, "\"", "\\\"", 0);
+  s = "\"" + s + "\"";
+  return true;
+}
+
+std::string EmitSuperCtorCall(TreeNode* node) {
+  while (node->GetKind() && !node->IsClass())
+    node = node->GetParent();
+  if (node && node->IsClass()) {
+    std::string base, str;
+    base = (static_cast<ClassNode*>(node)->GetSuperClassesNum() != 0)? static_cast<ClassNode*>(node)->GetSuperClass(0)->GetName() : "t2crt::Object";
+    str = "  "s + base + "::ctor"s;
+    return str;
+  }
+  return ""s;
+}
+
+std::string CppDef::EmitCallNode(CallNode *node) {
+  if (node == nullptr)
+    return std::string();
+  bool log = false;
+  bool isSuper = false;
+  std::string str;
+  if (auto n = node->GetMethod()) {
+    if(n->IsFunction()) {
+      str += static_cast<FunctionNode *>(n)->GetName();
+    } else {
+      auto s = EmitTreeNode(n);
+      if(s.compare(0, 12, "console->log") == 0) {
+        str += "std::cout"s;
+        log = true;
+      } else if (s.compare("super") == 0) {
+        isSuper = true;
+        str += EmitSuperCtorCall(node);
+      } else if (hFuncTable.IsTopLevelFuncName(s)) {
+        // s can be either ts function or ts var of function type
+        str += "(*"s + s + ")"s;
+      } else if (hFuncTable.IsImportedField(s)) {
+        str += "(*"s + s + ")"s;
+      } else if (hFuncTable.IsStaticMember(s)) {
+        str += "("s + s +")"s;
+      } else if (s.find("->") != std::string::npos)
+        str += s;
+      else
+        str += "(*("s + s + "))"s;
+    }
+  }
+  if(!log)
+    str += isSuper? "(obj"s : "("s;
+  unsigned num = node->GetArgsNum();
+  for (unsigned i = 0; i < num; ++i) {
+    if(log) {
+      std::string s = EmitTreeNode(node->GetArg(i));
+      if(QuoteStringLiteral(s)) {
+        //if(num > 1)
+        //  s = "\"'\""s + s + "\"'\""s;
+      } else if(mPrecedence <= 13) // '\015'
+        s = "("s + s + ")"s;
+      if (i)
+        str += " << ' ' "s;
+      str += " << "s + s;
+    } else {
+      if (i || isSuper)
+        str += ", "s;
+      if (auto n = node->GetArg(i))
+        str += EmitTreeNode(n);
+    }
+  }
+  if(!log)
+    str += ")"s;
+  else
+    str += " << std::endl;";
+  mPrecedence = '\024';
+  return str;
+}
+
+std::string CppDef::EmitPrimTypeNode(PrimTypeNode *node) {
+  return mCppDecl.EmitPrimTypeNode(node);
+}
+
+std::string CppDef::EmitPrimArrayTypeNode(PrimArrayTypeNode *node) {
+  return std::string();
+}
+
+inline bool IsBracketNotationProp(TreeNode *node) {
+  return node->IsArrayElement() &&
+         static_cast<ArrayElementNode*>(node)->GetArray()->IsTypeIdClass();
+}
+
+std::string CppDef::EmitArrayElementNode(ArrayElementNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (IsBracketNotationProp(node)) {
+    bool unused;
+    str = EmitBracketNotationProp(node, OPR_Arrow, false, unused);
+    return str;
+  }
+  if (auto n = node->GetArray()) {
+    std::string s = EmitTreeNode(n);
+    if (mIsInit && s == "this")
+      str = "__module"s;
+    else
+      str = "(*"s + s + ")"s;
+    if(mPrecedence < '\024')
+      str = "("s + str + ")"s;
+  }
+
+
+  for (unsigned i = 0; i < node->GetExprsNum(); ++i) {
+    if (auto n = node->GetExprAtIndex(i)) {
+      std::string expr;
+      expr = "["s + EmitTreeNode(n) + "]"s;
+      if (i < node->GetExprsNum()-1)
+        str  = "(*"s + str + expr  + ")"s;
+      else
+        str += expr;
+    }
+  }
+
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+
+std::string CppDef::EmitArrayLiteralNode(ArrayLiteralNode *node) {
+  if (node == nullptr)
+    return std::string();
+  if (node->GetParent() &&
+      node->GetParent()->IsDecl() ||          // for var decl init
+      node->GetParent()->IsIdentifier() ||    // for default val init in class field decl
+      node->GetParent()->IsFieldLiteral()) {  // for obj decl with struct literal init
+    // emit code to construct array object with brace-enclosed initializer list
+    int dim;
+    std::string str, type;
+    GetArrayTypeInfo(node, dim, type);
+    str = ConstructArray(node, dim, type);
+    return str;
+  }
+
+  // emit code to build a brace-enclosed intializer list (for rhs of array var assignment op)
+  std::string str("{"s);
+  for (unsigned i = 0; i < node->GetLiteralsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetLiteral(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  str += "}"s;
+  return str;
+}
+
+std::string CppDef::EmitFieldNode(FieldNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string upper, field, propType;
+  bool isRhs = false;   // indicate if field is rhs (val) or lhs (ref)
+  auto upnode = node->GetUpper();
+  bool upperIsGenerator = false;
+  if (upnode) {
+    upper = EmitTreeNode(upnode);
+    isRhs = !mHandler->IsDef(upnode);
+    upperIsGenerator = IsGenerator(upnode); // TODO: await TI fix for generator3.ts
+  }
+  if (auto n = node->GetField()) {
+    if (isRhs) {
+      propType = hlpGetJSValTypeStr(hlpGetTypeId(n));
+    }
+    field = EmitTreeNode(n);
+    if (n->IsIdentifier()) {  // check for static class field or method
+      if (auto decl = mHandler->FindDecl(static_cast<IdentifierNode*>(n))) {
+        if ((decl->IsFunction()   && HasAttrStatic<FunctionNode>(static_cast<FunctionNode*>(decl))) ||
+            (decl->IsIdentifier() && HasAttrStatic<IdentifierNode>(static_cast<IdentifierNode*>(decl)))) {
+          std::string fdStr = GetClassName(decl) + "::"s + field;
+          hFuncTable.AddMemberIsStatic(fdStr);
+          return fdStr;
+        }
+      }
+    }
+  }
+  if (upper.empty() || field.empty()) // Error if either is empty
+    return "%%%Empty%%%";
+  if (field == "length") // for length property
+    return upper + "->size()"s;
+  if (mCppDecl.IsImportedModule(upper) || upnode->GetTypeId() == TY_Module || upnode->GetTypeId() == TY_Namespace) // for imported module
+    return hFuncTable.AddFieldIsImported(upper + "::"s + field);
+  if (mHandler->IsCppField(node->GetField()) || // check if it accesses a Cxx class field
+      node->IsTypeIdFunction())
+    return upper + "->"s + field;
+  if (isRhs)
+    return "(*"s + upper + ").GetProp"s + propType + "(\""s + field + "\")"s;
+  return "(*"s + upper + ")[\""s + field + "\"]"s;
+}
+
+std::string CppDef::EmitCondBranchNode(CondBranchNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("if("s);
+  if (auto n = node->GetCond()) {
+    auto cond = EmitTreeNode(n);
+    str += Clean(cond);
+  }
+  str += ")"s;
+  if (auto n = node->GetTrueBranch()) {
+    str += EmitTreeNode(n) + GetEnding(n);
+  }
+  if (auto n = node->GetFalseBranch()) {
+    str += "else"s + EmitTreeNode(n) + GetEnding(n);
+  }
+  if(auto n = node->GetLabel()) {
+    str += "__label_break_"s + EmitTreeNode(n) + ":;\n"s;
+  }
+  return str;
+}
+
+std::string CppDef::EmitBlockNode(BlockNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("{\n");
+  for (unsigned i = 0; i < node->GetChildrenNum(); ++i) {
+    if (auto n = node->GetChildAtIndex(i)) {
+      std::string s = EmitTreeNode(n);
+      if (n->IsYield()) {
+        str += s;
+        continue;
+      }
+      if (!s.empty())
+        str += "  "s + s + GetEnding(n);
+    }
+  }
+  str += "}\n"s;
+  if(auto n = node->GetLabel()) {
+    str += "__label_break_"s + EmitTreeNode(n) + ":;\n"s;
+  }
+  mPrecedence = '\030';
+  return str;
+}
+
+std::string CppDef::EmitForLoopNode(ForLoopNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  str += "for("s;
+  switch(node->GetProp()) {
+    case FLP_Regular:
+      {
+        for (unsigned i = 0; i < node->GetInitsNum(); ++i)
+          if (auto n = node->GetInitAtIndex(i)) {
+            if (i)
+              str += ", "s;
+            str += EmitTreeNode(n);
+          }
+        str += "; "s;
+        if (auto n = node->GetCond()) {
+          str += EmitTreeNode(n);
+        }
+        str += "; "s;
+        for (unsigned i = 0; i < node->GetUpdatesNum(); ++i)
+          if (auto n = node->GetUpdateAtIndex(i)) {
+            if (i)
+              str += ", "s;
+            str += EmitTreeNode(n);
+          }
+        break;
+      }
+    case FLP_JSIn:
+      {
+        if (auto n = node->GetVariable()) {
+          str += EmitTreeNode(n);
+        }
+        str += " in "s;
+        if (auto n = node->GetSet()) {
+          str += EmitTreeNode(n);
+        }
+        break;
+      }
+    case FLP_JSOf:
+      {
+        if (auto n = node->GetVariable()) {
+          std::string s = EmitTreeNode(n);
+          str += "auto "s + Clean(s);
+        }
+        str += " : "s;
+        if (auto n = node->GetSet()) {
+          str += EmitTreeNode(n);
+          if (n->IsIdentifier() && static_cast<IdentifierNode*>(n)->IsTypeIdArray()) {
+            str += "->elements"s;
+          }
+        }
+        break;
+      }
+    case FLP_NA:
+      return "FLP_NA"s;
+    default:
+      MASSERT(0 && "Unexpected enumerator");
+  }
+  str += ")"s;
+
+  auto label = node->GetLabel();
+  std::string lstr;
+  if(label) {
+    lstr = EmitTreeNode(label);
+    str += "{\n"s;
+  }
+  if (auto n = node->GetBody()) {
+    str += EmitTreeNode(n) + GetEnding(n);
+  }
+  if(label)
+    str += "__label_cont_"s + lstr + ":;\n}\n"s + "__label_break_"s + lstr + ":;\n"s;
+  return str;
+}
+
+std::string CppDef::EmitBreakNode(BreakNode *node) {
+  if (node == nullptr)
+    return std::string();
+  auto target = node->GetTarget();
+  std::string str = target ? "goto __label_break_"s + EmitTreeNode(target) : "break"s;
+  return str;
+}
+
+std::string CppDef::EmitContinueNode(ContinueNode *node) {
+  if (node == nullptr)
+    return std::string();
+  auto target = node->GetTarget();
+  std::string str = target ? "goto __label_cont_"s + EmitTreeNode(target) : "continue"s;
+  return str;
+}
+
+TypeId CppDef::GetTypeIdFromDecl(TreeNode* node) {
+  TypeId typeId = TY_None;
+
+  if (auto typ = FindDeclType(node)) {
+    if (typ->IsPrimType())
+      typeId = static_cast<PrimTypeNode*>(typ)->GetPrimType();
+  }
+  return typeId;
+}
+
+// Check if a bracket notation property is a class member field
+bool CppDef::IsClassField(ArrayElementNode* node, std::string propKey) {
+  if (!node->GetArray()->IsIdentifier()) {
+    return false;
+  }
+  // find declared type of bracket notation obj; if class type
+  // if class type, lookup class decl and check if prop is a class member fd
+  if (auto typ = FindDeclType(node->GetArray()))
+    if (typ->IsUserType() && static_cast<UserTypeNode*>(typ)->IsTypeIdClass())
+      if (auto classId = static_cast<UserTypeNode*>(typ)->GetId())
+        if (auto n = mHandler->FindDecl(static_cast<IdentifierNode*>(classId)))
+          if (n->IsClass())
+            for (unsigned i = 0; i < static_cast<ClassNode*>(n)->GetFieldsNum(); ++i) {
+              auto fd = static_cast<ClassNode*>(n)->GetField(i);
+              if (fd->IsIdentifier())
+                // skip leading and trailing quote in propKey when comparing
+                if (propKey.compare(1, propKey.length()-2, static_cast<IdentifierNode*>(fd)->GetName()) == 0)
+                  return true;
+            }
+  return false;
+}
+
+//
+// For property access using bracket notation (e.g. bar["prop"]):
+//   1) If the property is a member field in the object's class, emit: bar->prop
+//   2) Otherwise it is a property created dynamically at runtime:
+//      - If it is a lvalue, emit: (*bar)["prop"] - [] operator overloaded in ts2cpp.h
+//      - If it is a rvalue, emit: bar->GetPropXX("prop") - XX is one of union types in t2crt::JS_Val
+//   3) For OP_Assign, if lvalue on lhs is dynamic prop, wrap rhs with t2crt::JS_Val() macro.
+//      e.g.   (*bar)["p1"] = t2crt::JS_Val(0xa);
+//             (*bar)["p2"] = t2crt::JS_Val(bar->f2);
+//             (*bar)["p2"] = t2crt::JS_Val(bar->GetPropLong("p1"));
+//             (*bar)["p2"] = t2crt::JS_Val((uint32_t)(bar->GetPropLong("p2") >> bar->GetPropLong("p1")));
+//
+// *note: to do 1), the property key must be a string literal. if the property key
+//        is an identfier, then we have to do 2) because the identfier can be
+//        a var or a TS symobol resolvable only at runtime.
+//        Also, the object may be an expression, in which case, it can only be evaluated at runtime
+//
+std::string CppDef::EmitBracketNotationProp(ArrayElementNode* ae, OprId binOpId, bool isLhs, bool& isDynProp) {
+  if (ae == nullptr)
+    return std::string();
+
+  isDynProp = true;
+  std::string str, propKey;
+  std::string objName;
+
+  if (ae->GetArray()->IsIdentifier()) {
+    objName = ae->GetArray()->GetName();
+  } else {
+    // case where the object is an expression - re: call-func.ts
+    objName = EmitTreeNode(ae->GetArray());
+  }
+
+  TypeId propKeyType  = ae->GetExprAtIndex(0)->GetTypeId();
+  if (propKeyType == TY_String && ae->GetExprAtIndex(0)->IsLiteral()) {
+    propKey = EmitTreeNode(ae->GetExprAtIndex(0));
+    if (IsClassField(ae, propKey)) {
+      // property is class member field
+      str = objName + "->"s + propKey.substr(1, propKey.length()-2);
+      isDynProp = false;
+      return str;
+    }
+  }
+  if (propKeyType == TY_None) {
+    propKeyType = GetTypeIdFromDecl(ae->GetExprAtIndex(0));
+  }
+  // resolve propKey at runtime
+  switch (propKeyType) {
+    case TY_Int:
+      propKey = "t2crt::to_string("s + EmitTreeNode(ae->GetExprAtIndex(0)) + ")"s;
+      break;
+    case TY_String:
+      propKey = EmitTreeNode(ae->GetExprAtIndex(0));
+      break;
+    case TY_Symbol:
+      propKey = "t2crt::to_string("s + EmitTreeNode(ae->GetExprAtIndex(0)) + ")"s;
+      break;
+    default:
+      MASSERT(0 && "Encounter unsupported prop key type in bracket notation");
+      break;
+  }
+
+  if (binOpId == OPR_Assign && isLhs) {
+    // prop is lvalue
+    str = "(*"s + objName + ")["s + propKey + "]"s;
+  } else {
+    switch(ae->GetTypeId()) {
+      case TY_Long:
+      case TY_Int:
+        str = objName + "->GetPropLong("s + propKey + ")"s;
+        break;
+      case TY_Double:
+        str = objName + "->GetPropDouble("s + propKey + ")"s;
+        break;
+      case TY_String:
+        str = objName + "->GetPropString("s + propKey + ")"s;
+        break;
+      case TY_Boolean:
+        str = objName + "->GetPropBool("s + propKey + ")"s;
+        break;
+      case TY_Function:
+      case TY_Object:
+        str = objName + "->GetPropObj("s + propKey + ")"s;
+        break;
+      case TY_Any:
+        str = objName + "->GetProp("s + propKey + ")"s;
+        break;
+      default:
+        str = "(*"s + objName + ")["s + propKey + ']';
+    }
+
+    // prop is rvalue
+    // emit: bar->GetPropXX("prop")
+    // Need type info for each property
+  }
+  return str;
+}
+
+std::string CppDef::EmitBinOperatorNode(BinOperatorNode *node) {
+  if (node == nullptr)
+    return std::string();
+  const char *op = Emitter::GetEnumOprId(node->GetOprId());
+  const Precedence precd = *op & 0x3f;
+  const bool rl_assoc = *op >> 6; // false: left-to-right, true: right-to-left
+  std::string lhs, rhs;
+  bool lhsIsDynProp = false;
+  bool rhsIsDynProp = false;
+
+  if (auto n = node->GetOpndA()) {
+    if (IsBracketNotationProp(n)) {
+      lhs = EmitBracketNotationProp(static_cast<ArrayElementNode*>(n), node->GetOprId(), true, lhsIsDynProp);
+    } else {
+      lhs = EmitTreeNode(n);
+      if (n->IsIdentifier() && n->IsTypeIdArray())
+        lhs = "*"s + lhs;
+    }
+    if(precd > mPrecedence || (precd == mPrecedence && rl_assoc))
+      lhs = "("s + lhs + ")"s;
+  }
+  else
+    lhs = "(NIL) "s;
+
+  if (auto n = node->GetOpndB()) {
+    if (IsBracketNotationProp(n)) {
+      rhs = EmitBracketNotationProp(static_cast<ArrayElementNode*>(n), node->GetOprId(), false, rhsIsDynProp);
+    } else if (IsClassId(n)) {
+      rhs = "&"s + n->GetName() + "::ctor"s;
+    } else
+      rhs = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && !rl_assoc))
+      rhs = "("s + rhs + ")"s;
+  }
+  else
+    rhs = " (NIL)"s;
+
+  OprId k = node->GetOprId();
+  std::string str;
+  switch(k) {
+    case OPR_Exp:
+      str = "std::pow("s + lhs + ", "s + rhs + ")";
+      break;
+    case OPR_StEq:
+      str = "t2crt::StrictEqu("s + lhs + ',' + rhs + ')';
+      break;
+    case OPR_StNe:
+      str = "t2crt::StrictNotEqu("s + lhs + ',' + rhs + ')';
+      break;
+    default:
+      switch(k) {
+        case OPR_Band:
+        case OPR_Bor:
+        case OPR_Bxor:
+        case OPR_Shl:
+        case OPR_Shr:
+          lhs = "static_cast<int64_t>(static_cast<int32_t>("s + lhs + "))"s;
+          break;
+        case OPR_Zext:
+          lhs = "static_cast<int64_t>(static_cast<uint32_t>("s + lhs + "))"s;
+          op = "\015>>";
+          break;
+      }
+      if (k == OPR_Assign && lhsIsDynProp)
+        rhs = "t2crt::JS_Val("s + rhs + ")"s;
+      str = lhs + " "s + std::string(op + 1) + " "s + rhs;
+  }
+  mPrecedence = precd;
+  return str;
+}
+
+std::string CppDef::EmitUnaOperatorNode(UnaOperatorNode *node) {
+  if (node == nullptr)
+    return std::string();
+  bool isPost = node->IsPost();
+  const char *op = Emitter::GetEnumOprId(node->GetOprId());
+  const Precedence precd = *op & 0x3f;
+  const bool rl_assoc = *op >> 6; // false: left-to-right, true: right-to-left
+  std::string opr;
+  if (auto n = node->GetOpnd()) {
+    opr = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && (rl_assoc && isPost || !rl_assoc && !isPost)))
+      opr = "("s + opr + ")"s;
+  }
+  else
+      opr = "(NIL)"s;
+  if(node->GetOprId() == OPR_Bcomp)
+    opr = "static_cast<int32_t>("s + opr + ")"s;
+  std::string str;
+  if(node->IsPost())
+    str = opr + std::string(op + 1) + " "s;
+  else
+    str = " "s + std::string(op + 1) + opr;
+  mPrecedence = precd;
+  return str;
+}
+
+std::string CppDef::EmitTemplateLiteralNode(TemplateLiteralNode *node) {
+  if (node == nullptr)
+    return std::string();
+  auto num = node->GetTreesNum();
+  std::string str;
+  for (unsigned i = 0; i < num; ++i) {
+    if (auto n = node->GetTreeAtIndex(i)) {
+      if (!std::empty(str))
+        str += " + "s;
+      std::string s(EmitTreeNode(n));
+      if(i & 0x1)
+        str += "t2crt::to_string("s + s+ ")"s;
+      else {
+        QuoteStringLiteral(s);
+        str += s;
+      }
+    }
+  }
+  mPrecedence = '\016';
+  return str;
+}
+
+std::string CppDef::EmitLiteralNode(LiteralNode *node) {
+  if (node == nullptr)
+    return std::string();
+  LitData lit = node->GetData();
+  if(lit.mType == LT_VoidLiteral)
+    return "undefined";
+  std::string str = Emitter::EmitLiteralNode(node);
+  return str;
+}
+
+std::string CppDef::EmitSwitchNode(SwitchNode *node) {
+  if (node == nullptr)
+    return std::string();
+  bool doable = true;
+  for (unsigned i = 0; i < node->GetCasesNum(); ++i)
+    if (SwitchCaseNode* c = node->GetCaseAtIndex(i))
+      for (unsigned j = 0; j < c->GetLabelsNum(); ++j) {
+        auto l = c->GetLabelAtIndex(j);
+        if (l && l->IsSwitchLabel()) {
+          auto ln = static_cast<SwitchLabelNode*>(l);
+          if (auto v = ln->GetValue())
+            if(!v->IsLiteral() || !v->IsTypeIdInt()) {
+              doable = false;
+              goto out_of_loops;
+            }
+        }
+      }
+out_of_loops:
+  std::string label;
+  TreeNode* lab = node->GetLabel();
+  if(lab)
+    label = "__label_break_"s + EmitTreeNode(lab);
+  else
+    label = "__label_switch_" + std::to_string(node->GetNodeId());
+  std::string str;
+  if(doable) {
+    str = "switch("s;
+    if (TreeNode* n = node->GetExpr()) {
+      std::string expr = EmitTreeNode(n);
+      str += Clean(expr);
+    }
+    str += "){\n"s;
+    for (unsigned i = 0; i < node->GetCasesNum(); ++i) {
+      if(SwitchCaseNode* n = node->GetCaseAtIndex(i))
+        str += EmitTreeNode(n);
+    }
+    str += "}\n"s;
+  } else {
+    std::string tmp = "__tmp_"s + std::to_string(node->GetNodeId());
+    str = "do { // switch\nauto "s + tmp + " = "s;
+    if (TreeNode* n = node->GetExpr()) {
+      std::string expr = EmitTreeNode(n);
+      str += Clean(expr);
+    }
+    str += ";\n"s;
+    std::string body;
+    std::string other = "goto "s + label + ";\n"s;;
+    for (unsigned i = 0; i < node->GetCasesNum(); ++i)
+      if (SwitchCaseNode* cn = node->GetCaseAtIndex(i)) {
+        for (unsigned j = 0; j < cn->GetLabelsNum(); ++j)
+          if (SwitchLabelNode* ln = cn->GetLabelAtIndex(j)) {
+            if(ln->IsDefault())
+              other = "goto __case_"s + std::to_string(cn->GetNodeId()) + ";\n"s;
+            else {
+              std::string le = EmitTreeNode(ln->GetValue());
+              str += "if("s + tmp + " == ("s + Clean(le)
+                + "))\ngoto __case_"s + std::to_string(cn->GetNodeId()) + ";\n"s;
+            }
+          }
+        body += "__case_"s + std::to_string(cn->GetNodeId()) + ":\n"s;
+        for (unsigned s = 0; s < cn->GetStmtsNum(); ++s)
+          if (TreeNode* t = cn->GetStmtAtIndex(s))
+            body += EmitTreeNode(t) + ";\n"s;
+      }
+    str += other + body;
+    str += "} while(0);\n"s;
+  }
+  if(!doable || lab)
+    str += label + ":;\n"s;
+  return str;
+}
+
+std::string CppDef::EmitTypeOfNode(TypeOfNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("t2crt::__js_typeof("s), rhs;
+  if (auto n = node->GetExpr())
+    rhs = EmitTreeNode(n);
+  str += rhs + ")"s;
+  return HandleTreeNode(str, node);
+}
+
+// Return C++ object type of "this" parameter in function param declaration
+std::string CppDef::GetThisParamObjType(TreeNode *node) {
+  if (node && !node->IsFunction())
+    return std::string();
+
+  std::string str = "t2crt::Object";
+  if (static_cast<FunctionNode*>(node)->GetParamsNum()) {
+    auto n = static_cast<FunctionNode*>(node)->GetParam(0);
+    if (n->IsThis()) {
+      TreeNode* tn = static_cast<IdentifierNode*>(n)->GetType();
+      str = mCppDecl.GetTypeString(tn, nullptr);
+      if (str.back() == '*')
+        str.pop_back();
+      if (!str.compare("t2crt::JS_Val ") || !str.compare("t2crt::JS_Val")) {
+        str = "t2crt::Object";
+      }
+    }
+  }
+  return str;
+}
+
+std::string CppDef::EmitNewNode(NewNode *node) {
+  if (node == nullptr)
+    return std::string();
+
+  std::string str;
+  MASSERT(node->GetId() && "No mId on NewNode");
+
+  if (auto id = node->GetId()) {
+    if (id->IsTypeIdClass()) {
+      // Generate code to create new class obj and call class constructor
+      std::string clsName = EmitTreeNode(node->GetId());
+      if (IsBuiltinObj(clsName))
+        clsName = "t2crt::"s + clsName;
+      str = clsName + "::ctor("s + clsName + "::ctor._new()"s;
+
+    } else if (id->IsTypeIdFunction()) {  // TS: new <func> (<args..>)
+      // When calling TS new() on constructor function:
+      // A new object is created and bound to "this" of ctor func which is then invoked.
+      // The object's proto chain is linked to ctor func prototype, and constructor set
+      // to the consturctor object. The object is then returned.
+      // note: When calling new() on functions, TSC only allows void functions that
+      //       reference 'this' or non void function that do not reference 'this'.
+      //       TSC strict mode requires all funcs that refs "this" to declare it as 1st parm.
+      if (auto decl = mHandler->FindDecl(static_cast<IdentifierNode*>(id))) {
+        std::string objClass = GetThisParamObjType(decl); // "t2crt::Object" , "Foo" etc
+        std::string fnName = GetIdentifierName(id);
+        // create new obj with proto chain and ctor init'd : new <obj>(<ctor>, <ctor>->prototype)
+        std::string newObj = "new "s + objClass + "("s + fnName + ", "s + fnName + "->prototype)"s;
+        str = fnName + "->ctor("s + newObj + ", "s;  // call ctor function with new obj as this arg
+      }
+    } else {
+      // for builtins
+      str = "new "s + EmitTreeNode(node->GetId());
+      str += "("s;
+    }
+  }
+
+  auto num = node->GetArgsNum();
+  for (unsigned i = 0; i < num; ++i) {
+    if (i || node->GetId()->IsTypeIdClass())
+      str += ", "s;
+    if (auto n = node->GetArg(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  str += ")"s;
+  if (auto n = node->GetBody()) {
+    str += " "s + EmitBlockNode(n);
+  }
+  mPrecedence = '\024';
+  return HandleTreeNode(str, node);
+}
+
+static std::string MethodString(std::string &func) {
+  size_t s = func.substr(0, 9) == "function " ? 9 : 0;
+  return func.back() == '}' ? func.substr(s) + "\n"s : func.substr(s) + ";\n"s;
+}
+
+std::string CppDef::EmitStructNode(StructNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  const char *suffix = ";\n";
+  switch(node->GetProp()) {
+    case SProp_CStruct:
+      str = "struct "s;
+      break;
+    case SProp_TSInterface:
+      return std::string(); // decl already generation by CppDecl
+    case SProp_TSEnum: {
+      // Create the enum type object
+      std::string enumClsName;
+      if (auto n = node->GetStructId()) {
+        enumClsName = "Enum_"s + n->GetName();
+        str += n->GetName() + " = new "s + enumClsName + "();\n"s;
+        return str;
+      }
+      break;
+    }
+    case SProp_NA:
+      str = ""s;
+      return str; // todo: handle anonymous struct created for untyped object literals.
+      break;
+    default:
+      MASSERT(0 && "Unexpected enumerator");
+  }
+
+  if (auto n = node->GetStructId()) {
+    str += EmitIdentifierNode(n);
+  }
+
+  auto num = node->GetTypeParamsNum();
+  if(num) {
+    str += "<"s;
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetTypeParamAtIndex(i))
+        str += EmitTreeNode(n);
+    }
+    str += ">"s;
+  }
+
+  for (unsigned i = 0; i < node->GetSupersNum(); ++i) {
+    str += i ? ", "s : " extends "s;
+    if (auto n = node->GetSuper(i))
+      str += EmitTreeNode(n);
+  }
+  str += " {\n"s;
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (auto n = node->GetField(i)) {
+      str += EmitTreeNode(n) + suffix;
+    }
+  }
+
+  if (auto n = node->GetNumIndexSig()) {
+    str += EmitNumIndexSigNode(n) + "\n"s;;
+  }
+  if (auto n = node->GetStrIndexSig()) {
+    str += EmitStrIndexSigNode(n) + "\n";
+  }
+
+  for (unsigned i = 0; i < node->GetMethodsNum(); ++i) {
+    if (auto n = node->GetMethod(i)) {
+      std::string func = EmitFunctionNode(n);
+      func = Clean(func);
+      str += MethodString(func);
+    }
+  }
+
+  str += "}\n"s;
+  return HandleTreeNode(str, node);
+}
+
+std::string CppDef::EmitTypeAliasNode(TypeAliasNode *node) {
+  return std::string();
+}
+
+// Return the declared type for an identifier
+TreeNode* CppDef::FindDeclType(TreeNode* node) {
+  if (node == nullptr || !node->IsIdentifier())
+    return nullptr;
+
+  if (auto n = mHandler->FindDecl(static_cast<IdentifierNode*>(node)))
+    if (n->IsDecl())
+      if (auto var = static_cast<DeclNode*>(n)->GetVar())
+        if (var->IsIdentifier())
+          if (auto type = static_cast<IdentifierNode*>(var)->GetType())
+            return type;
+
+  return nullptr;
+}
+
+// Get template argument for calling InstanceOf template func.
+std::string CppDef::GetTypeForTemplateArg(TreeNode* node) {
+  if (node == nullptr)
+    return std::string();
+
+  std::string str;
+  if (auto n = FindDeclType(node)) {
+    // lhs type of instanceof operator is either object or ANY
+    switch(n->GetKind()) {
+      case NK_UserType:
+        str = EmitTreeNode(n);
+        break;
+      case NK_PrimType:
+        str = EmitTreeNode(n);
+        if (str.find("t2crt::JS_Val") != std::string::npos)
+          str = "t2crt::JS_Val";
+        break;
+      default:
+        MASSERT(0 && "Unexpected node type");
+    }
+  } else if (node->IsField()) {
+    // Lookup declared type of the obj in mUpper, then find
+    // mField from the obj field list to get the field type.
+    //
+    // The result is used as template argument for the InstanceOf
+    // template func. However, without this information
+    // the compiler does template argument deduction
+    // to call the template func, and has work ok for testcases.
+    // So implementation of this part is deferred until needed.
+  } else {
+    // No info - return ANY for now...
+    str = "t2crt::JS_Val"s;
+    //MASSERT(0 && "Unexpected node type");
+  }
+  return str;
+}
+
+std::string CppDef::EmitInstanceOfNode(InstanceOfNode *node) {
+  if (node == nullptr)
+    return std::string();
+  const Precedence precd = '\014';
+  const bool rl_assoc = false;         // false: left-to-right
+  std::string lhs, rhs, typ;
+  if (auto n = node->GetLeft()) {
+    lhs = EmitTreeNode(n);
+    typ = GetTypeForTemplateArg(n);
+    if (typ.compare("t2crt::JS_Val") == 0) {
+      lhs = "t2crt::JS_Val("s + lhs + ")"s;
+      typ = "";
+    }
+    else if (!typ.empty())
+      typ = "<"s + typ + ">"s;        // InstanceOf<typ>
+
+    if(precd > mPrecedence)
+      lhs = '(' + lhs + ')';
+  }
+  else
+    lhs = "(NIL) "s;
+
+  if (auto n = node->GetRight()) {
+    if (IsClassId(n) || IsBuiltinObj(n->GetName()))
+      rhs = "&t2crt::"s + n->GetName() + "::ctor"s;
+    else
+      rhs = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && !rl_assoc))
+      rhs = '(' + rhs + ')';
+  }
+  else
+    rhs = " (NIL)"s;
+
+  std::string str("t2crt::InstanceOf"s + typ + "("s + lhs + ", "s + rhs + ")"s);
+  mPrecedence = precd;
+  return HandleTreeNode(str, node);
+}
+
+std::string CppDef::EmitDeclareNode(DeclareNode *node) {
+  return std::string();
+}
+
+std::string CppDef::EmitAsTypeNode(AsTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetType())
+    str = EmitTreeNode(n);
+  if (!str.empty())
+    str = '(' + str + ')';
+  return str;
+}
+
+std::string CppDef::EmitNamespaceNode(NamespaceNode *node) {
+  if (node == nullptr)
+    return std::string();
+  // emit namespace in each statement inside of current namespace
+  std::string str;
+  for (unsigned i = 0; i < node->GetElementsNum(); ++i) {
+    if (auto n = node->GetElementAtIndex(i)) {
+      str += EmitTreeNode(n) + GetEnding(n);
+    }
+  }
+  return str;
+}
+
+std::string &CppDef::HandleTreeNode(std::string &str, TreeNode *node) {
+  auto num = node->GetAsTypesNum();
+  if(num > 0) {
+    std::string as;
+    for (unsigned i = 0; i < num; ++i)
+      if (auto t = node->GetAsTypeAtIndex(i))
+        as = EmitAsTypeNode(t) + as;
+    str = as + '(' + str + ')';
+  }
+  /*
+  if(node->IsOptional())
+    str = AddParentheses(str, node) + '?';
+  if(node->IsNonNull())
+    str = AddParentheses(str, node) + '!';
+  */
+  if(node->IsRest())
+    str = "..."s; // + AddParentheses(str, node);
+  /*
+  if(node->IsConst())
+    if(node->IsField())
+      str += " as const"s;
+    else
+      str = AddParentheses(str, node) + " as const"s;
+  */
+  return str;
+}
+
+std::string CppDef::EmitRegExprNode(RegExprNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string source = Emitter::EmitRegExprNode(node);
+  InsertEscapes(source);
+  return "RegExp::ctor._new(\""s + source + "\")"s;
+}
+
+} // namespace maplefe
diff --git a/src/MapleFE/ast2cpp/src/cpp_emitter.cpp b/src/MapleFE/ast2cpp/src/cpp_emitter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c5c92c0b0409646a598f2cc081f2b3d50197f638
--- /dev/null
+++ b/src/MapleFE/ast2cpp/src/cpp_emitter.cpp
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cpp_emitter.h"
+#include "helper.h"
+
+namespace maplefe {
+
+std::string CppEmitter::GetIdentifierName(TreeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  switch (node->GetKind()) {
+    case NK_Identifier:
+        return std::string(static_cast<IdentifierNode *>(node)->GetName());
+    case NK_Decl:
+        return GetIdentifierName(static_cast<DeclNode *>(node)->GetVar());
+    case NK_Struct:
+        // Named StructNode has name in StructId. Unamed StructNode is assigned
+        // anonymous name by frontend and can be accessed using node mStrIdx
+        // through node GetName() interface.
+        if (auto n = static_cast<StructNode *>(node)->GetStructId())
+          return GetIdentifierName(n);
+        else
+          return node->GetName(); // for anonomyous name
+    case NK_Function:
+        if (static_cast<FunctionNode *>(node)->GetFuncName())
+          return GetIdentifierName(static_cast<FunctionNode *>(node)->GetFuncName());
+        else
+          return GenAnonFuncName(node);
+    case NK_Class:
+        return std::string(static_cast<ClassNode *>(node)->GetName());
+    case NK_Interface:
+        return std::string(static_cast<InterfaceNode *>(node)->GetName());
+    case NK_UserType:
+        return GetIdentifierName(static_cast<UserTypeNode *>(node)->GetId());
+    case NK_TypeAlias:
+        return GetIdentifierName(static_cast<TypeAliasNode *>(node)->GetId());
+    case NK_Namespace:
+        return GetIdentifierName(static_cast<NamespaceNode *>(node)->GetId());
+    case NK_Module:
+        return GetModuleName(static_cast<ModuleNode *>(node)->GetFilename());
+    case NK_Literal:
+        return AstDump::GetEnumLitData(static_cast<LiteralNode *>(node)->GetData());
+    case NK_Declare:
+        { auto n = static_cast<DeclareNode *>(node);
+          auto num = n->GetDeclsNum();
+          if (num == 1)
+            return GetIdentifierName(n->GetDeclAtIndex(0));
+          return "Failed: one decl is expected"s;
+        }
+    default:
+        return "Failed to get the name of "s + AstDump::GetEnumNodeKind(node->GetKind());
+  }
+}
+
+bool CppEmitter::IsInNamespace(TreeNode *node) {
+  while (node) {
+    if (node->IsNamespace())
+      return true;
+    node = node->GetParent();
+  }
+  return false;
+}
+
+std::string CppEmitter::GetNamespace(TreeNode *node) {
+  std::string ns;
+  while (node) {
+    if (node->IsNamespace()) {
+      TreeNode *id = static_cast<NamespaceNode *>(node)->GetId();
+      if (id->IsIdentifier()) {
+        std::string s = Emitter::EmitIdentifierNode(static_cast<IdentifierNode *>(id));
+        ns = ns.empty() ? s : s + "::"s + ns;
+      }
+    }
+    node = node->GetParent();
+  }
+  return ns;
+}
+
+std::string CppEmitter::GetQualifiedName(IdentifierNode *node) {
+  std::string name;
+  if (node == nullptr)
+    return name;
+  name = node->GetName();
+  TreeNode *parent = node->GetParent();
+  if (parent->IsField())
+    return name;
+  Module_Handler *handler = GetModuleHandler();
+  TreeNode *decl = handler->FindDecl(node);
+  if (decl == nullptr)
+    return name;
+  std::string ns = GetNamespace(decl);
+  return ns.empty() ? name : ns + "::"s + name;
+}
+
+// Returns true if identifier is a class
+bool CppEmitter::IsClassId(TreeNode* node) {
+  if (node == nullptr || !node->IsIdentifier())
+    return false;
+  if (auto decl = mHandler->FindDecl(static_cast<IdentifierNode*>(node), true)) { // deep, cross module lookup
+    if (decl->IsClass())
+      return true;
+    // TODO: handle type alias
+  }
+  return false;
+}
+
+// Returns true if the declared type of a var is a TS class
+bool CppEmitter::IsVarTypeClass(TreeNode* var) {
+  if (var == nullptr)
+    return false;
+  if (auto n = gTypeTable.GetTypeFromTypeIdx(var->GetTypeIdx())) {
+    if (n->IsClass())
+      return true;
+  }
+  return false;
+}
+
+void CppEmitter::InsertEscapes(std::string& str) {
+  Emitter::Replace(str, "\\", "\\\\", 0);
+  Emitter::Replace(str, "\"", "\\\"", 0);
+}
+
+bool CppEmitter::IsGenerator(TreeNode* node) {
+  return mHandler->IsGeneratorUsed(node->GetNodeId());
+}
+
+FunctionNode* CppEmitter::GetGeneratorFunc(TreeNode* node) {
+  return mHandler->GetGeneratorUsed(node->GetNodeId());
+}
+
+//
+// Interface to get array type and dimension interface for an ArrayLiteral
+// (should be just a wrapper to call TI interfaces GetArrayElemTypeId()
+// and GetArrayDim(), but until the usage of those 2 interface can cover all
+// use caes, this interface encaps any additional work to get array type info.
+//
+void CppEmitter::GetArrayTypeInfo(ArrayLiteralNode* node, int& numDim, std::string& type) {
+  TypeId typeId = mHandler->GetArrayElemTypeId(node->GetNodeId());
+  DimensionNode* dim  = mHandler->GetArrayDim(node->GetNodeId());
+  if (dim)
+    numDim = dim->GetDimensionsNum();
+  switch(typeId) {
+    case TY_Class: {
+      unsigned tIdx = mHandler->GetArrayElemTypeIdx(node->GetNodeId());
+      TreeNode* tp  = gTypeTable.GetTypeFromTypeIdx(tIdx);
+      type = ObjectTypeStr(tp->GetName());
+      break;
+    }
+    case TY_Int:
+      type = "long";
+      break;
+    case TY_String:
+      type = "std::string";
+      break;
+    case TY_Double:
+      type = "double";
+      break;
+    case TY_None:
+      type = "t2crt::JS_Val";
+      break;
+#if 0
+    case TY_Array:
+      type = "t2crt::Array<t2crt::JS_Val>*";
+      break;
+#endif
+    case TY_Function:
+    default:
+      // TODO
+      dim = 0;
+      type = "TBD";
+      break;
+  }
+  return;
+
+#if 0
+  if (!node->GetParent())
+    return;
+
+  switch(node->GetParent()->GetKind()) {
+  case NK_Decl:
+    // e.g. var arr: number[]=[1,2,3];
+    //GetArrInfoByVarId(node, dim, type);
+    break;
+  case NK_Identifier:
+    // e.g. class Foo { arr: number[]=[1,2,3]; }
+    //GetArrInfoByClassFieldId(node, dim, type);
+    break;
+  case NK_FieldLiteral:
+    // e.g. var: {arr:number[]} = { n:[1,2,3] };
+    //GetArrInfoByObjLiteralClassField(node, dim, type);
+    break;
+  }
+#endif
+}
+
+// C++ function header for different TS function types:
+//   Generator:    t2crt::IteratorResult [<ns>::]GeneratorFunc_<function>::_body(t2crt::Object* _this, void*& yield[, &<params>]...)
+//   Class ctor:   [<ns>::]<class>* <class>::Ctor::operator()(<class>* obj[, <params>]...)
+//   Class method: <retType> [<ns>::]<class>::<function>([params]...)
+//   Function:     <retType> [<ns>::]Cls_<function>::_body(t2crt::Object|<object>* _this[, params]...)
+std::string CppEmitter::FunctionHeader(FunctionNode* node, std::string retType) {
+  std::string str;
+  std::string ns = GetNamespace(node).empty() ? ""s : GetNamespace(node)+"::";
+  std::string funcName = GetIdentifierName(node);
+  std::string className= ns + GetClassName(node);
+  bool isTopLevel = hFuncTable.IsTopLevelFunc(node);
+  retType = retType + " "s + ns;
+
+  if (node->IsGenerator())                     // generator
+    str += GeneratorFuncHeader(ns+GeneratorFuncName(funcName)+"::", node->GetNodeId());
+  else if (node->IsConstructor()) {            // class constructor
+    std::string param = FunctionParams(node->GetNodeId(), false);
+    param = param.empty() ? ""s : (", "s+param);
+    str += className + "* "s + className + "::Ctor::operator()" + "(" +className+ "* obj" +param+ ") ";
+  }
+  else if (IsClassMethod(node))                // class method
+    str += retType + GetClassName(node) + "::" + funcName + "(" + FunctionParams(node->GetNodeId(), false) + ") ";
+  else if (isTopLevel)                         // top level function
+    str += retType + "Cls_" + funcName + "::_body" + "(" + FunctionParams(node->GetNodeId(), true) + ") ";
+  else
+    str += retType + funcName + "(" + FunctionParams(node->GetNodeId(), false) + ") ";
+  return str;
+}
+
+// Return class name from class method or class field
+std::string CppEmitter::GetClassName(TreeNode* node) {
+  TreeNode* n = node->GetParent();
+  if (n && n->IsClass())
+    return n->GetName();
+  return ""s;
+}
+
+} // namespace maplefe
diff --git a/src/MapleFE/ast2cpp/src/emitter.cpp b/src/MapleFE/ast2cpp/src/emitter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fbf695857eaf577226ec8854914a7f84f48dba2c
--- /dev/null
+++ b/src/MapleFE/ast2cpp/src/emitter.cpp
@@ -0,0 +1,2453 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkFE is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *  http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "emitter.h"
+#include <cstring>
+#include <limits>
+#include <cctype>
+
+namespace maplefe {
+
+std::string Emitter::Emit(const char *title) {
+  std::string code;
+  code = "// [Beginning of Emitter: "s + title + "\n"s;
+  code += EmitTreeNode(GetASTModule());
+  code += "// End of Emitter]\n"s;
+  return code;
+}
+
+std::string Emitter::GetEnding(TreeNode *n) {
+  if (n->IsExport()) {
+    ExportNode *ex = static_cast<ExportNode *>(n);
+    if (ex->GetPairsNum() == 1) {
+      if (auto p = ex->GetPair(0)->GetBefore())
+        n = p;
+    }
+  }
+  if (n->IsDeclare()) {
+    DeclareNode *d = static_cast<DeclareNode *>(n);
+    if (d->GetDeclsNum() == 1 && !d->IsGlobal())
+      if (auto p = d->GetDeclAtIndex(0))
+        n = p;
+  }
+  std::string str;
+  switch(n->GetKind()) {
+    case NK_Function:
+    case NK_TripleSlash:
+      str += '\n';
+      break;
+    default:
+      str += ';';
+    case NK_Block:
+    case NK_Switch:
+    case NK_ForLoop:
+    case NK_WhileLoop:
+    case NK_DoLoop:
+    case NK_CondBranch:
+    case NK_Class:
+    case NK_Struct:
+    case NK_Namespace:
+    case NK_Declare:
+    case NK_Module:
+      str += '\n';
+  }
+  return str;
+}
+
+std::string Emitter::Clean(std::string &s) {
+  auto len = s.length();
+  if(len >= 1 && s.back() == '\n')
+    s = s.erase(len - 1);
+  if(len >= 2 && s.back() == ';')
+    return s.erase(len - 2);
+  return s;
+}
+
+std::string Emitter::GetBaseFilename() {
+  std::string str(GetASTModule()->GetFilename());
+  auto len = str.length();
+  if(len >= 3 && str.substr(len - 3) == ".ts")
+    return str.erase(len - 3);
+  return str;
+}
+
+std::string Emitter::GetModuleName(const char *p) {
+  std::string str = p && *p ? p : GetBaseFilename();
+  size_t pos = str.rfind("/", std::string::npos);
+  str = pos == std::string::npos ? str : str.substr(pos);
+  for (auto &c : str)
+    if(std::ispunct(c))
+        c = '_';
+  return "M_"s + str;
+}
+
+std::string Emitter::GetModuleName(TreeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str = EmitTreeNode(node);
+  auto len = str.length();
+  if (len <= 2 || str.back() != '"' || str.front() != '"')
+    return std::string();
+  str = str.substr(1, len - 2);
+  return GetModuleName(str.c_str());
+}
+
+std::string Emitter::GetEnumAttrId(AttrId k) {
+  std::string str(AstDump::GetEnumAttrId(k) + 5);
+  Emitter::Replace(str, "etter", "et");
+  str += ' ';
+  return str;
+}
+
+void Emitter::Replace(std::string &str, const char *o, const char *n, int cnt) {
+  size_t len = std::strlen(o);
+  size_t nlen = std::strlen(n);
+  if(cnt > 0) {
+    size_t index = 0;
+    int num = cnt;
+    do {
+      index = str.find(o, index);
+      if (index == std::string::npos) break;
+      str.replace(index, len, n);
+      index += nlen;
+    } while(--num && index < str.size());
+  } else {
+    size_t index = std::string::npos;
+    int num = cnt ? -cnt : std::numeric_limits<int>::max();
+    do {
+      index = str.rfind(o, index);
+      if (index == std::string::npos) break;
+      str.replace(index, len, n);
+      index -= len;
+    } while(--num);
+  }
+}
+
+std::string Emitter::EmitAnnotationNode(AnnotationNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetId()) {
+    str += EmitTreeNode(n);
+  }
+  if (auto num = node->GetArgsNum()) {
+    str += '(';
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetArgAtIndex(i))
+        str += EmitTreeNode(n);
+    }
+    str += ')';
+  }
+  if (auto n = node->GetType()) {
+    str += ": "s + EmitAnnotationTypeNode(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitAsTypeNode(AsTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetType()) {
+    str += " as "s + EmitTreeNode(n);
+  }
+  mPrecedence = '\023';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitIdentifierNode(IdentifierNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+
+  for (unsigned i = 0; i < node->GetAnnotationsNum(); ++i)
+    if (auto n = node->GetAnnotationAtIndex(i))
+      str += '@' + EmitTreeNode(n) + "\n"s;
+
+  std::string accessor1, accessor2;
+  for (unsigned i = 0; i < node->GetAttrsNum(); ++i) {
+    std::string s = GetEnumAttrId(node->GetAttrAtIndex(i));
+    if (s == "get "s || s == "set "s)
+      accessor2 += s;
+    else
+      accessor1 += s;
+  }
+  std::string name(node->GetName());
+  if (accessor1 == "private "s && name == "private"s)
+    str += "#private"s;
+  else
+    str += accessor1 + accessor2 + name;
+  mPrecedence = '\030';
+  str = HandleTreeNode(str, node);
+  //if (auto n = node->GetDims()) {
+  //  str += ' ' + EmitDimensionNode(n);
+  //}
+
+  if (auto n = node->GetType()) {
+    std::string s = EmitTreeNode(n);
+    if(s.length() > 9 && s.substr(0, 9) == "function ") {
+      std::size_t loc = s.find("(");
+      if(loc != std::string::npos)
+        s = s.substr(loc);
+    }
+    str += ": "s + s;
+  }
+  if (auto n = node->GetInit()) {
+    str += " = "s + EmitTreeNode(n);
+  }
+  return str;
+}
+
+std::string Emitter::EmitFunctionNode(FunctionNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string pre;
+  for (unsigned i = 0; i < node->GetAnnotationsNum(); ++i)
+    if (auto n = node->GetAnnotationAtIndex(i))
+      pre += '@' + EmitTreeNode(n) + "\n"s;
+
+  auto p = node->GetParent();
+  NodeKind k = p ? p->GetKind() : NK_Null;
+  bool inside = k == NK_Class || k == NK_Struct || k == NK_Interface;
+  bool func = !inside;
+  std::string accessor;
+  for (unsigned i = 0; i < node->GetAttrsNum(); ++i) {
+    std::string s = GetEnumAttrId(node->GetAttrAtIndex(i));
+    if (s == "get "s || s == "set "s) {
+      func = false;
+      accessor += s;
+    } else
+      pre += s;
+  }
+  pre += accessor;
+
+  std::string str;
+  if (node->IsConstructor())
+    str = "constructor "s;
+  bool has_name;
+  if(TreeNode* name = node->GetFuncName()) {
+    std::string s = EmitTreeNode(name);
+    has_name = s.substr(0, 9) != "__lambda_";
+    if (has_name)
+      str += node->IsIterator() ? "* ["s + s + ']' : s;
+  } else
+    has_name = k == NK_XXportAsPair;
+
+  if (node->IsConstructSignature())
+    str += "new"s;
+
+  auto num = node->GetTypeParamsNum();
+  if(num) {
+    str += '<';
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetTypeParamAtIndex(i)) {
+        str += EmitTreeNode(n);
+      }
+    }
+    str += '>';
+  }
+
+  /*
+  for (unsigned i = 0; i < node->GetThrowsNum(); ++i) {
+    if (auto n = node->GetThrowAtIndex(i)) {
+      str += ' ' + EmitExceptionNode(n);
+    }
+  }
+  */
+
+  str += '(';
+  for (unsigned i = 0; i < node->GetParamsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetParam(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  str += ')';
+
+  if (auto n = node->GetAssert())
+    str += " : asserts "s + EmitTreeNode(n);
+
+  auto body = node->GetBody();
+  if (auto n = node->GetRetType()) {
+    std::string s = EmitTreeNode(n);
+    if(!s.empty()) {
+      str += (body || has_name || inside ? " : "s : " => "s) + s;
+      if (!body && !has_name)
+        func = false;
+    }
+  }
+
+  str = pre + (func && !node->IsIterator() ? (node->IsGenerator() ? "function* "s : "function "s) : ""s) + str;
+
+  if (body) {
+    auto s = EmitBlockNode(body);
+    if(s.empty() || s.front() != '{')
+      str += '{' + s + "}\n"s;
+    else
+      str += s;
+  }
+  else
+    if (k == NK_Block || k == NK_Struct || k == NK_Class)
+      str += ";\n"s;
+  /*
+  if (auto n = node->GetDims()) {
+    str += ' ' + EmitDimensionNode(n);
+  }
+  str += ' ' + std::to_string(node->IsConstructor());
+  */
+  mPrecedence = '\004';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitUserTypeNode(UserTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  auto k = node->GetType();
+  Precedence precd;
+  switch (k) {
+    case UT_Union:
+      precd = '\010';
+      break;
+    case UT_Inter:
+      precd = '\012';
+      break;
+    default:
+      precd = '\030';
+  }
+  std::string attrs, accessor, str;
+  for (unsigned i = 0; i < node->GetAttrsNum(); ++i) {
+    std::string s = GetEnumAttrId(node->GetAttrAtIndex(i));
+    if (s == "get "s || s == "set "s)
+      accessor += s;
+    else
+      attrs += s;
+  }
+  attrs += accessor;
+  if (auto n = node->GetId()) {
+    str += EmitTreeNode(n);
+    auto num = node->GetTypeGenericsNum();
+    if(num) {
+      str += '<';
+      for (unsigned i = 0; i < num; ++i) {
+        if (i)
+          str += ", "s;
+        if (auto n = node->GetTypeGeneric(i)) {
+          str += EmitTreeNode(n);
+        }
+      }
+      str += '>';
+    }
+    precd = mPrecedence;
+  }
+
+  if(k != UT_Regular) {
+    if(!str.empty())
+      str = "type "s + str + " = "s;
+    std::string op = k == UT_Union ? " | "s : " & "s;
+    for (unsigned i = 0; i < node->GetUnionInterTypesNum(); ++i) {
+      if(i)
+        str += op;
+      std::string s = EmitTreeNode(node->GetUnionInterType(i));
+      if (precd >= mPrecedence)
+        s = '(' + s + ')';
+      str += s;
+    }
+    mPrecedence = precd;
+  }
+
+  if (auto n = node->GetDims()) {
+    std::string s = EmitDimensionNode(n);
+    if (precd <= mPrecedence)
+      str = '(' + str + ')';
+     str += s;
+  }
+  str = attrs + str;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitComputedNameNode(ComputedNameNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  for (unsigned i = 0; i < node->GetAttrsNum(); ++i) {
+    std::string s = GetEnumAttrId(node->GetAttrAtIndex(i));
+    str += s;
+  }
+  str += " ["s;
+  if (auto n = node->GetExpr()) {
+    str += EmitTreeNode(n);
+  }
+  str += "] "s;
+
+  if (auto prop = node->GetProp()) {
+    if (prop & CNP_Rem_ReadOnly)
+      str = "-readonly "s + str;
+    if (prop & CNP_Add_ReadOnly)
+      str = "readonly "s + str;
+    if (prop & CNP_Rem_Optional)
+      str += "-?"s;
+    if (prop & CNP_Add_Optional)
+      str += '?';
+  }
+
+  str = HandleTreeNode(str, node);
+  if (auto n = node->GetExtendType()) {
+    str += ": "s + EmitTreeNode(n);
+  }
+  if (auto n = node->GetInit()) {
+    str += " = "s + EmitTreeNode(n);
+  }
+  return str;
+}
+
+std::string Emitter::EmitPackageNode(PackageNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str = "package";
+  if (auto n = node->GetPackage()) {
+    str += ' ' + EmitTreeNode(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitXXportAsPairNode(XXportAsPairNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (node->IsDefault()) {
+    if (auto n = node->GetBefore())
+      str += "default "s + EmitTreeNode(n);
+  } else if (node->IsEverything()) {
+    str += " * "s;
+    if (auto n = node->GetBefore())
+      str += "as "s + EmitTreeNode(n);
+  } else if (node->IsSingle()) {
+    if (auto a = node->GetAfter())
+      str += EmitTreeNode(a);
+    if (auto n = node->GetBefore()) {
+      str += " = "s;
+      std::string s = EmitTreeNode(n);
+      str += n->IsLiteral() ? "require("s + s + ')' : s;
+    }
+  } else if (node->GetAsNamespace()) {
+    if (auto n = node->GetBefore())
+      str += " as namespace "s + EmitTreeNode(n);
+  } else {
+    if (auto n = node->GetBefore()) {
+      std::string s = EmitTreeNode(n);
+      if (auto a = node->GetAfter())
+        s += " as "s + EmitTreeNode(a);
+      if (n->IsIdentifier())
+        s = "{ "s + s + " }"s;
+      str += s;
+    }
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitDeclareNode(DeclareNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str, accessor;
+  for (unsigned i = 0; i < node->GetAttrsNum(); ++i) {
+    std::string s = GetEnumAttrId(node->GetAttrAtIndex(i));
+    if (s == "get "s || s == "set "s)
+      accessor += s;
+    else
+      str += s;
+  }
+  str += accessor;
+
+  unsigned num = node->GetDeclsNum();
+  if (node->IsGlobal() || num != 1) {
+    str += "declare "s;
+    if (node->IsGlobal()) {
+      TreeNode *n = node;
+      while(n = n->GetParent())
+        if (n->IsDeclare()) {
+          str = std::string();
+          break;
+        }
+      str += "global "s;
+    }
+    str += "{\n"s;
+    for (unsigned i = 0; i < num; ++i) {
+      if (auto n = node->GetDeclAtIndex(i))
+        str += EmitTreeNode(n) + GetEnding(n);
+    }
+    str += "}\n"s;
+  } else {
+    if (auto n = node->GetDeclAtIndex(0)) {
+      std::string s = EmitTreeNode(n);
+      str += "declare "s + s;
+    }
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitExportNode(ExportNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string deco;
+  for (unsigned i = 0; i < node->GetAnnotationsNum(); ++i)
+    if (auto n = node->GetAnnotationAtIndex(i))
+      deco += '@' + EmitTreeNode(n) + "\n"s;
+
+  std::string str;
+  auto num = node->GetPairsNum();
+  if (num == 1 && node->GetTarget() == nullptr)
+    if (XXportAsPairNode *pair = node->GetPair(0))
+      if (auto b = pair->GetBefore())
+        if (b->IsModule() && pair->GetAfter() == nullptr)
+          return "export "s + EmitTreeNode(b);
+  for (unsigned i = 0; i < num; ++i) {
+    if (auto n = node->GetPair(i)) {
+      std::string s = EmitXXportAsPairNode(n);
+      if (!s.empty() && s.front() == '{' && !str.empty() && str.back() == '}') {
+        str.pop_back();
+        s.erase(0, 1);
+      }
+      str += i ? ", "s + s : s;
+    }
+  }
+  if (auto n = node->GetTarget()) {
+    str += " from "s + EmitTreeNode(n);
+  }
+  str = Clean(str);
+  if (str.empty())
+    str = "{}"s;
+  str = deco + (node->IsExportType() ? "export type "s : "export "s) + str;
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitImportNode(ImportNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("import ");
+  if (node->IsImportType())
+    str += "type "s;
+  /*
+  switch (node->GetProperty()) {
+    case ImpNone:
+      break;
+    case ImpType:
+      break;
+    case ImpStatic:
+      break;
+    case ImpSingle:
+      break;
+    case ImpAll:
+      break;
+    case ImpLocal:
+      break;
+    case ImpSystem:
+      break;
+    default:
+      MASSERT(0 && "Unexpected enumerator");
+  }
+  */
+  auto num = node->GetPairsNum();
+  if (num == 1 && node->GetTarget() == nullptr)
+    if (XXportAsPairNode *pair = node->GetPair(0))
+      if (auto a = pair->GetAfter())
+        if (auto b = pair->GetBefore())
+          if (a->IsIdentifier() && !b->IsLiteral()) {
+            str += EmitTreeNode(a) + " = "s + EmitTreeNode(b);
+            return HandleTreeNode(str, node);
+          }
+
+  for (unsigned i = 0; i < node->GetPairsNum(); ++i) {
+    if (auto n = node->GetPair(i)) {
+      std::string s = EmitXXportAsPairNode(n);
+      auto len = s.length();
+      if(len > 13 && s.substr(len - 13) == " as default }"s)
+        s = s.substr(1, len - 13); // default export from a module
+      if(len > 8 && s.substr(0, 8) == "default "s)
+        s = s.substr(8, len - 1);
+      if (!s.empty() && s.front() == '{' && !str.empty() && str.back() == '}') {
+        str.pop_back();
+        s.erase(0, 1);
+      }
+      str += i ? ", "s + s : s;
+    }
+  }
+  if (auto n = node->GetTarget()) {
+    std::string s = EmitTreeNode(n);
+    if (num)
+      str += " from "s + s;
+    else {
+      auto p = node->GetParent();
+      if (p && (p->IsField() || p->IsTypeOf() || p->IsAwait()))
+        str += '(' + s + ')';
+      else
+        str += s;
+    }
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitUnaOperatorNode(UnaOperatorNode *node) {
+  if (node == nullptr)
+    return std::string();
+  bool isPost = node->IsPost();
+  const char *op = Emitter::GetEnumOprId(node->GetOprId());
+  const Precedence precd = *op & 0x3f;
+  const bool rl_assoc = *op >> 6; // false: left-to-right, true: right-to-left
+  std::string opr;
+  if (auto n = node->GetOpnd()) {
+    opr = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && (rl_assoc && isPost || !rl_assoc && !isPost)))
+      opr = '(' + opr + ')';
+  }
+  else
+      opr = "(NIL)"s;
+  std::string str;
+  if(node->IsPost())
+    str = opr + std::string(op + 1) + ' ';
+  else
+    str = ' ' + std::string(op + 1) + opr;
+  mPrecedence = precd;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitBinOperatorNode(BinOperatorNode *node) {
+  if (node == nullptr)
+    return std::string();
+  const char *op = Emitter::GetEnumOprId(node->GetOprId());
+  const Precedence precd = *op & 0x3f;
+  const bool rl_assoc = *op >> 6; // false: left-to-right, true: right-to-left
+  std::string lhs, rhs;
+  if (auto n = node->GetOpndA()) {
+    lhs = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && rl_assoc))
+      lhs = '(' + lhs + ')';
+  }
+  else
+    lhs = "(NIL) "s;
+  if (auto n = node->GetOpndB()) {
+    rhs = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && !rl_assoc))
+      rhs = '(' + rhs + ')';
+  }
+  else
+    rhs = " (NIL)"s;
+  std::string str(lhs + ' ' + std::string(op + 1) + ' ' + rhs);
+  mPrecedence = precd;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitTerOperatorNode(TerOperatorNode *node) {
+  if (node == nullptr)
+    return std::string();
+  const Precedence precd = '\004';
+  const bool rl_assoc = true; // true: right-to-left
+  std::string str;
+  if (auto n = node->GetOpndA()) {
+    str = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && rl_assoc))
+      str = '(' + str + ')';
+  }
+  str += " ? "s;
+  if (auto n = node->GetOpndB()) {
+    str += EmitTreeNode(n);
+  }
+  str += " : "s;
+  if (auto n = node->GetOpndC()) {
+    auto s = EmitTreeNode(n);
+    if(precd > mPrecedence)
+      s = '(' + s + ')';
+    str += s;
+  }
+  mPrecedence = '\004';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitTypeAliasNode(TypeAliasNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("type ");
+  if (auto n = node->GetId()) {
+    str += EmitUserTypeNode(n);
+  }
+  if (auto n = node->GetAlias()) {
+    str += " = "s + EmitTreeNode(n);
+  }
+  mPrecedence = '\030';
+  return str;
+}
+
+std::string Emitter::EmitConditionalTypeNode(ConditionalTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  Precedence precd = '\030';
+  if (auto n = node->GetTypeA()) {
+    str = EmitTreeNode(n);
+    precd = mPrecedence;
+  }
+  if (auto n = node->GetTypeB()) {
+    str = Clean(str);
+    if (precd < '\024')
+      str = '(' + str + ')';
+    str += " extends "s + EmitTreeNode(n);
+  }
+  if (auto n = node->GetTypeC()) {
+    str += " ? "s + EmitTreeNode(n);
+  }
+  if (auto n = node->GetTypeD()) {
+    str += " : "s + EmitTreeNode(n);
+  }
+  mPrecedence = '\004';
+  return str;
+}
+
+std::string Emitter::EmitTypeParameterNode(TypeParameterNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetId()) {
+    str = EmitTreeNode(n);
+  }
+  if (auto n = node->GetExtends()) {
+    str += " extends "s + EmitTreeNode(n);
+  }
+  if (auto n = node->GetDefault()) {
+    str += " = "s + EmitTreeNode(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitBlockNode(BlockNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if(auto n = node->GetLabel()) {
+    str = EmitTreeNode(n) + ":\n"s;
+  }
+  str += "{\n"s;
+  for (unsigned i = 0; i < node->GetChildrenNum(); ++i) {
+    if (auto n = node->GetChildAtIndex(i)) {
+      str += EmitTreeNode(n) + GetEnding(n);
+    }
+  }
+  str += "}\n"s;
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitNewNode(NewNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  for (unsigned i = 0; i < node->GetAttrsNum(); ++i)
+    str += GetEnumAttrId(node->GetAttrAtIndex(i));
+  str += "new"s;
+  if (auto id = node->GetId()) {
+    std::string idstr = EmitTreeNode(id);
+    if (mPrecedence <= '\024'
+        && !id->IsUserType()
+        && !id->IsLambda()
+        && !id->IsFunction())
+      idstr = '(' + idstr + ')';
+    str += ' ' + idstr;
+    if(!id->IsFunction() && !id->IsLambda() && !id->IsClass()) {
+      auto num = node->GetArgsNum();
+      str += '(';
+      for (unsigned i = 0; i < num; ++i) {
+        if (i)
+          str += ", "s;
+        if (auto n = node->GetArg(i)) {
+          str += EmitTreeNode(n);
+        }
+      }
+      str += ')';
+    }
+  }
+  if (auto n = node->GetBody()) {
+    str += ' ' + EmitBlockNode(n);
+  }
+  // Set mPrecedence, e.g. type AType = (new () => Error)|Error;
+  mPrecedence = '\004';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitDeleteNode(DeleteNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("delete "s);
+  if (auto n = node->GetExpr()) {
+    str += EmitTreeNode(n);
+  }
+  mPrecedence = '\021';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitAnnotationTypeNode(AnnotationTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetId()) {
+    str += ' ' + EmitIdentifierNode(n);
+  }
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitDimensionNode(DimensionNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  for (unsigned i = 0; i < node->GetDimensionsNum(); ++i) {
+    auto n = node->GetDimension(i);
+    std::string d(n ? std::to_string(n) : ""s);
+    str += '[' + d + ']';
+  }
+  mPrecedence = '\024';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitDeclNode(DeclNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str(Emitter::GetEnumDeclProp(node->GetProp()));
+  if (auto n = node->GetVar()) {
+    str += ' ' + EmitTreeNode(n);
+  }
+  if (auto n = node->GetInit()) {
+    str += " = "s + EmitTreeNode(n);
+  }
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitCastNode(CastNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetDestType()) {
+    str += '<' + EmitTreeNode(n) + ">";
+  }
+  if (auto n = node->GetExpr()) {
+    str += EmitTreeNode(n);
+  }
+  mPrecedence = '\021';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitParenthesisNode(ParenthesisNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetExpr()) {
+    str += '(' + EmitTreeNode(n) + ')';
+  }
+  mPrecedence = '\025';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitFieldNode(FieldNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  const Precedence precd = '\024';
+  if (auto n = node->GetUpper()) {
+    str = EmitTreeNode(n);
+    if (precd > mPrecedence)
+      str = '(' + str + ')';
+  }
+  if (auto n = node->GetField()) {
+    str += '.' + EmitTreeNode(n);
+  }
+  mPrecedence = precd;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitArrayElementNode(ArrayElementNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetArray()) {
+    str = EmitTreeNode(n);
+    if(mPrecedence < '\024')
+      str = '(' + str + ')';
+  }
+  str = Clean(str);
+  for (unsigned i = 0; i < node->GetExprsNum(); ++i) {
+    if (auto n = node->GetExprAtIndex(i)) {
+      if (str.back() == '?')
+        str += '.';
+      str += '[' + EmitTreeNode(n) + ']';
+    }
+  }
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitArrayLiteralNode(ArrayLiteralNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("[");
+  for (unsigned i = 0; i < node->GetLiteralsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetLiteral(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  str += ']';
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitBindingElementNode(BindingElementNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetVariable()) {
+    str += EmitTreeNode(n);
+  }
+  if (auto n = node->GetElement()) {
+    if (!str.empty())
+      str += ": "s;
+    str += EmitTreeNode(n);
+  }
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitBindingPatternNode(BindingPatternNode *node) {
+  if (node == nullptr)
+    return std::string();
+  // Needs a flag to distinguish between array destructuring and object destructuring
+  // Object destructuring: optional-prop.ts
+  // Array destructuring:  trailing-commas.ts
+  std::string str;
+
+  for (unsigned i = 0; i < node->GetElementsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetElement(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+
+  if (node->GetProp() == BPP_ArrayBinding)
+    str = '[' + str + ']';
+  else
+    str = '{' + str + '}';
+  str = HandleTreeNode(str, node);
+
+  if (auto n = node->GetType()) {
+    str += ": "s + EmitTreeNode(n);
+  }
+  if (auto n = node->GetInit()) {
+    str += " = "s + EmitTreeNode(n);
+  }
+  mPrecedence = '\030';
+  return str;
+}
+
+std::string Emitter::EmitNumIndexSigNode(NumIndexSigNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetKey())
+    str += "[ "s + EmitTreeNode(n) + " : number ]";
+  if (auto n = node->GetDataType()) {
+    str += " : "s + EmitTreeNode(n);
+  }
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitStrIndexSigNode(StrIndexSigNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetKey())
+    str += "[ "s + EmitTreeNode(n) + " : string ]";
+  if (auto n = node->GetDataType()) {
+    str += " : "s + EmitTreeNode(n);
+  }
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+static std::string MethodString(std::string &func) {
+  size_t s = func.substr(0, 9) == "function " ? 9 : 0;
+  return func.back() == '}' ? func.substr(s) + "\n"s : func.substr(s) + ";\n"s;
+}
+
+std::string Emitter::EmitStructNode(StructNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  const char *suffix = ";\n";
+  switch(node->GetProp()) {
+    case SProp_CStruct:
+      str = "struct "s;
+      break;
+    case SProp_TSInterface:
+      str = "interface "s;
+      break;
+    case SProp_TSEnum:
+      str = "enum "s;
+      suffix = ",\n";
+      break;
+    case SProp_NA:
+      str = ""s;
+      break;
+    default:
+      MASSERT(0 && "Unexpected enumerator");
+  }
+
+  if (auto n = node->GetStructId()) {
+    str += EmitIdentifierNode(n);
+    if (str.substr(0,16) == "AnonymousStruct_")
+      str = "class "s + str;
+  }
+
+  auto num = node->GetTypeParamsNum();
+  if(num) {
+    str += '<';
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetTypeParamAtIndex(i))
+        str += EmitTreeNode(n);
+    }
+    str += '>';
+  }
+
+  for (unsigned i = 0; i < node->GetSupersNum(); ++i) {
+    str += i ? ", "s : " extends "s;
+    if (auto n = node->GetSuper(i))
+      str += EmitTreeNode(n);
+  }
+  str += " {\n"s;
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (auto n = node->GetField(i)) {
+      str += EmitTreeNode(n) + suffix;
+    }
+  }
+
+  if (auto n = node->GetNumIndexSig()) {
+    str += EmitNumIndexSigNode(n) + "\n"s;;
+  }
+  if (auto n = node->GetStrIndexSig()) {
+    str += EmitStrIndexSigNode(n) + "\n";
+  }
+
+  for (unsigned i = 0; i < node->GetMethodsNum(); ++i) {
+    if (auto n = node->GetMethod(i)) {
+      std::string func = EmitFunctionNode(n);
+      func = Clean(func);
+      str += MethodString(func);
+    }
+  }
+
+  str += "}\n"s;
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitFieldLiteralNode(FieldLiteralNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  auto lit = node->GetLiteral();
+  if (auto n = node->GetFieldName()) {
+    if(lit && lit->IsFunction() &&
+        static_cast<FunctionNode *>(lit)->GetFuncName() == n) {
+      str = EmitTreeNode(lit);
+      if (str.substr(0, 9) == "function ")
+        str = str.substr(9);
+      lit = nullptr;
+    } else {
+      str = EmitTreeNode(n);
+      if(lit)
+        str += ": "s;
+    }
+  }
+  if(lit) {
+    auto s = EmitTreeNode(lit);
+    if(s.size() > 4 && (s[0] == 's' || s[0] == 'g') && !s.compare(1, 3, "et "))
+      str = s;
+    else
+      str += s;
+  }
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitStructLiteralNode(StructLiteralNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("{");
+  auto num = node->GetFieldsNum();
+  for (unsigned i = 0; i < num; ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetField(i)) {
+      str += EmitFieldLiteralNode(n);
+    }
+  }
+
+  // Workaround for an identifier issue
+  if (num > 1 && str.length() > 6 &&
+      (str.substr(str.length() - 6) == ": true" ||
+       str.substr(str.length() - 7) == ": false"))
+    str += ',';
+
+  str += '}';
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitNamespaceNode(NamespaceNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("namespace ");
+  if (auto n = node->GetId()) {
+    std::string s = EmitTreeNode(n);
+    str += Clean(s);
+  }
+  str += " {\n"s;
+  for (unsigned i = 0; i < node->GetElementsNum(); ++i) {
+    if (auto n = node->GetElementAtIndex(i)) {
+      str += EmitTreeNode(n) + GetEnding(n);
+    }
+  }
+  str += "}\n"s;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitVarListNode(VarListNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+
+  for (unsigned i = 0; i < node->GetVarsNum(); ++i) {
+    if (auto n = node->GetVarAtIndex(i)) {
+      str += ' ' + EmitIdentifierNode(n);
+    }
+  }
+
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitExprListNode(ExprListNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+
+  for (unsigned i = 0; i < node->GetExprsNum(); ++i) {
+    if (auto n = node->GetExprAtIndex(i)) {
+      str += ' ' + EmitTreeNode(n);
+    }
+  }
+
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitTemplateLiteralNode(TemplateLiteralNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("`");
+  auto num = node->GetTreesNum();
+  for (unsigned i = 0; i < num; ++i) {
+    if (auto n = node->GetTreeAtIndex(i)) {
+      std::string s(EmitTreeNode(n));
+      if (i & 0x1)
+        str += "${"s + s+ '}';
+      else
+        str += s.front() == '"' && s.back() == '"' && s.size() >= 2 ? s.substr(1, s.size() - 2) : s;
+    }
+  }
+  str += '`';
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitLiteralNode(LiteralNode *node) {
+  if (node == nullptr)
+    return std::string();
+  LitData lit = node->GetData();
+  std::string str(AstDump::GetEnumLitData(lit));
+  if(lit.mType == LT_StringLiteral || lit.mType == LT_CharacterLiteral)
+    str = '"' + str + '"';
+  mPrecedence = '\030';
+  str = HandleTreeNode(str, node);
+  if (auto n = node->GetType()) {
+    str += ": "s + EmitTreeNode(n);
+  }
+  if (auto n = node->GetInit()) {
+    str += " = "s + EmitTreeNode(n);
+  }
+  return str;
+}
+
+std::string Emitter::EmitRegExprNode(RegExprNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (const char* e = node->GetData().mExpr)
+    str = "/"s + e + '/';
+  if (const char* f = node->GetData().mFlags)
+    str += f;
+  return str;
+}
+
+std::string Emitter::EmitThrowNode(ThrowNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("throw ");
+  for (unsigned i = 0; i < node->GetExceptionsNum(); ++i) {
+    if (auto n = node->GetExceptionAtIndex(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitCatchNode(CatchNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("catch");
+  unsigned num = node->GetParamsNum();
+  if (num > 0) {
+    str += '(';
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetParamAtIndex(i)) {
+        str += EmitTreeNode(n);
+      }
+    }
+    str += ')';
+  }
+  if (auto n = node->GetBlock()) {
+    str += EmitBlockNode(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitFinallyNode(FinallyNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("finally ");
+  if (auto n = node->GetBlock()) {
+    str += EmitBlockNode(n);
+  }
+  else
+    str += "{}\n"s;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitTryNode(TryNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("try ");
+  if (auto n = node->GetBlock()) {
+    str += EmitBlockNode(n);
+  }
+  for (unsigned i = 0; i < node->GetCatchesNum(); ++i) {
+    if (auto n = node->GetCatchAtIndex(i)) {
+      str += EmitCatchNode(n);
+    }
+  }
+  if (auto n = node->GetFinally()) {
+    str += EmitFinallyNode(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitExceptionNode(ExceptionNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetException()) {
+    str += ' ' + EmitIdentifierNode(n);
+  }
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitReturnNode(ReturnNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("return");
+  if (auto n = node->GetResult()) {
+    str += ' ' + EmitTreeNode(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitYieldNode(YieldNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str(node->IsTransfer() ? "yield* " : "yield ");
+  if (auto n = node->GetResult()) {
+    str += EmitTreeNode(n);
+  }
+  mPrecedence = '\024';
+  return str;
+}
+
+std::string Emitter::EmitCondBranchNode(CondBranchNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if(auto n = node->GetLabel()) {
+    str = EmitTreeNode(n) + ":\n"s;
+  }
+  str += "if("s;
+  if (auto n = node->GetCond()) {
+    auto cond = EmitTreeNode(n);
+    str += Clean(cond);
+  }
+  str += ")\n"s;
+  if (auto n = node->GetTrueBranch()) {
+    str += EmitTreeNode(n) + GetEnding(n);
+  }
+  if (auto n = node->GetFalseBranch()) {
+    str += "else\n"s + EmitTreeNode(n) + GetEnding(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitBreakNode(BreakNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("break");
+  if (auto n = node->GetTarget()) {
+    str += ' ' + EmitTreeNode(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitContinueNode(ContinueNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("continue");
+  if (auto n = node->GetTarget()) {
+    str += ' ' + EmitTreeNode(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitForLoopNode(ForLoopNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if(auto n = node->GetLabel()) {
+    str = EmitTreeNode(n) + ":\n"s;
+  }
+  str += "for("s;
+  switch(node->GetProp()) {
+    case FLP_Regular:
+      {
+        for (unsigned i = 0; i < node->GetInitsNum(); ++i)
+          if (auto n = node->GetInitAtIndex(i)) {
+            std::string init = EmitTreeNode(n);
+            if (i) {
+              str += ", "s;
+              if(init.substr(0, 4) == "let " || init.substr(0, 4) == "var ")
+                init = init.substr(4);
+              else if(init.substr(0, 6) == "const ")
+                init = init.substr(6);
+            }
+            str += init;
+          }
+        str += "; "s;
+        if (auto n = node->GetCond()) {
+          str += EmitTreeNode(n);
+        }
+        str += "; "s;
+        for (unsigned i = 0; i < node->GetUpdatesNum(); ++i)
+          if (auto n = node->GetUpdateAtIndex(i)) {
+            if (i)
+              str += ", "s;
+            str += EmitTreeNode(n);
+          }
+        break;
+      }
+    case FLP_JSIn:
+      {
+        if (auto n = node->GetVariable()) {
+          str += EmitTreeNode(n);
+        }
+        str += " in "s;
+        if (auto n = node->GetSet()) {
+          str += EmitTreeNode(n);
+        }
+        break;
+      }
+    case FLP_JSOf:
+      {
+        if (auto n = node->GetVariable()) {
+          str += EmitTreeNode(n);
+        }
+        str += " of "s;
+        if (auto n = node->GetSet()) {
+          str += EmitTreeNode(n);
+        }
+        break;
+      }
+    case FLP_NA:
+      return "FLP_NA"s;
+    default:
+      MASSERT(0 && "Unexpected enumerator");
+  }
+  str += ')';
+
+  if (auto n = node->GetBody()) {
+    str += EmitTreeNode(n) + GetEnding(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitWhileLoopNode(WhileLoopNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if(auto n = node->GetLabel()) {
+    str = EmitTreeNode(n) + ":\n"s;
+  }
+  str += "while("s;
+  if (auto n = node->GetCond()) {
+    str += EmitTreeNode(n);
+  }
+  str += ')';
+  if (auto n = node->GetBody()) {
+    str += EmitTreeNode(n) + GetEnding(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitDoLoopNode(DoLoopNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if(auto n = node->GetLabel()) {
+    str = EmitTreeNode(n) + ":\n"s;
+  }
+  str += "do "s;
+  if (auto n = node->GetBody()) {
+    str += EmitTreeNode(n);
+  }
+  str += "while("s;
+  if (auto n = node->GetCond()) {
+    str += EmitTreeNode(n);
+  }
+  str += ");\n"s;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitSwitchLabelNode(SwitchLabelNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if(node->IsDefault())
+    str += "default:\n"s;
+  if(auto n = node->GetValue()) {
+    auto ce = EmitTreeNode(n);
+    str += "case "s + Clean(ce) + ":\n"s;
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitSwitchCaseNode(SwitchCaseNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  for (unsigned i = 0; i < node->GetLabelsNum(); ++i) {
+    if (auto n = node->GetLabelAtIndex(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  for (unsigned i = 0; i < node->GetStmtsNum(); ++i) {
+    if (auto n = node->GetStmtAtIndex(i))
+      str += EmitTreeNode(n) + GetEnding(n);
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitSwitchNode(SwitchNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if(auto n = node->GetLabel()) {
+    str = EmitTreeNode(n) + ":\n"s;
+  }
+  str += "switch("s;
+  if (auto n = node->GetExpr()) {
+    auto expr = EmitTreeNode(n);
+    str += Clean(expr);
+  }
+  str += "){\n"s;
+  for (unsigned i = 0; i < node->GetCasesNum(); ++i) {
+    if(auto n = node->GetCaseAtIndex(i))
+      str += EmitTreeNode(n);
+  }
+  str += "}\n"s;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitAssertNode(AssertNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetExpr()) {
+    str += ' ' + EmitTreeNode(n);
+  }
+  if (auto n = node->GetMsg()) {
+    str += ' ' + EmitTreeNode(n);
+  }
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitCallNode(CallNode *node) {
+  if (node == nullptr)
+    return std::string();
+  // Function call: left-to-right, precedence = 20
+  std::string str;
+  if (auto n = node->GetMethod()) {
+    std::string s = EmitTreeNode(n);
+    bool optional = n->IsOptional();
+    if (optional && !s.empty() && s.back() == '?')
+      s.pop_back();
+    if(n->IsFunction() || n->IsLambda() || n->IsTerOperator())
+      str += '(' + s + ')';
+    else
+      str += s;
+    if (optional)
+      str += "?."s; // for optional chaining
+  }
+  if(auto num = node->GetTypeArgumentsNum()) {
+    str += '<';
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetTypeArgumentAtIndex(i)) {
+        str += EmitTreeNode(n);
+      }
+    }
+    str += '>';
+  }
+  if (auto tagged = node->GetTaggedTemplate()) {
+    str += EmitTreeNode(tagged);
+  } else {
+    str += '(';
+    for (unsigned i = 0; i < node->GetArgsNum(); ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetArg(i))
+        str += EmitTreeNode(n);
+    }
+    str += ')';
+  }
+  mPrecedence = '\024';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitInterfaceNode(InterfaceNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str = "interface "s + node->GetName();
+
+  /*
+  auto num = node->GetTypeParamsNum();
+  if(num) {
+    str += '<';
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetTypeParamAtIndex(i))
+        str += EmitTreeNode(n);
+    }
+    str += '>';
+  }
+  */
+
+  for (unsigned i = 0; i < node->GetSuperInterfacesNum(); ++i) {
+    str += i ? ", "s : " implements "s;
+    if (auto n = node->GetSuperInterfaceAtIndex(i))
+      str += EmitTreeNode(n);
+  }
+  str += " {\n"s;
+
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (auto n = node->GetField(i)) {
+      str += EmitIdentifierNode(n) + ";\n"s;
+    }
+  }
+
+  for (unsigned i = 0; i < node->GetMethodsNum(); ++i) {
+    if (auto n = node->GetMethod(i)) {
+      std::string func = EmitFunctionNode(n);
+      func = Clean(func);
+      str += MethodString(func);
+    }
+  }
+
+  str += "}\n"s;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitClassNode(ClassNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  for (unsigned i = 0; i < node->GetAnnotationsNum(); ++i)
+    if (auto n = node->GetAnnotationAtIndex(i))
+      str += '@' + EmitTreeNode(n) + "\n"s;
+
+  for (unsigned i = 0; i < node->GetAttributesNum(); ++i)
+    str += GetEnumAttrId(node->GetAttribute(i));
+
+  str += "class "s + node->GetName();
+
+  auto num = node->GetTypeParamsNum();
+  if(num) {
+    str += '<';
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetTypeParamAtIndex(i))
+        str += EmitTreeNode(n);
+    }
+    str += '>';
+  }
+
+  auto classNum = node->GetSuperClassesNum();
+  for (unsigned i = 0; i < classNum; ++i) {
+    str += i ? ", "s : " extends "s;
+    if (auto n = node->GetSuperClass(i)) {
+      std::string s = EmitTreeNode(n);
+      str += mPrecedence > '\023' ? s : '(' + s + ')';
+    }
+  }
+  for (unsigned i = 0; i < node->GetSuperInterfacesNum(); ++i) {
+    str += i ? ", "s : " implements "s;
+    if (auto n = node->GetSuperInterface(i))
+      str += EmitTreeNode(n);
+  }
+  str += " {\n"s;
+
+  for (unsigned i = 0; i < node->GetDeclaresNum(); ++i) {
+    if (auto n = node->GetDeclare(i)) {
+      std::string s = EmitTreeNode(n);
+      Replace(s, " var ", " "); // TODO: JS_Var for field
+      str += s + ";\n"s;
+    }
+  }
+
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (auto n = node->GetField(i)) {
+      str += EmitTreeNode(n) + ";\n"s;
+    }
+  }
+
+  for (unsigned i = 0; i < node->GetConstructorsNum(); ++i) {
+    if (auto n = node->GetConstructor(i)) {
+      std::string func = EmitFunctionNode(n);
+      if (func.substr(0, 9) == "function ")
+        func = func.substr(9);
+      func = Clean(func);
+      str += func.back() == '}' ? func + "\n"s : func + ";\n"s;
+    }
+  }
+
+  for (unsigned i = 0; i < node->GetMethodsNum(); ++i) {
+    if (FunctionNode *n = node->GetMethod(i)) {
+      std::string func = EmitFunctionNode(n);
+      func = Clean(func);
+      str += MethodString(func);
+    }
+  }
+
+  for (unsigned i = 0; i < node->GetInstInitsNum(); ++i) {
+    if (auto n = node->GetInstInit(i)) {
+      str += EmitBlockNode(n) + "\n"s;
+    }
+  }
+
+  for (unsigned i = 0; i < node->GetLocalClassesNum(); ++i) {
+    if (auto n = node->GetLocalClass(i)) {
+      str += EmitClassNode(n) + "\n"s;
+    }
+  }
+
+  for (unsigned i = 0; i < node->GetLocalInterfacesNum(); ++i) {
+    if (auto n = node->GetLocalInterface(i)) {
+      str += EmitInterfaceNode(n) + "\n"s;
+    }
+  }
+
+  str += "}\n";
+  mPrecedence = '\020';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitPassNode(PassNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("PassNode {");
+
+  for (unsigned i = 0; i < node->GetChildrenNum(); ++i) {
+    if (auto n = node->GetChild(i)) {
+      str += ' ' + EmitTreeNode(n);
+    }
+  }
+
+  str += '}';
+  mPrecedence = '\030';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitLambdaNode(LambdaNode *node) {
+  if (node == nullptr)
+    return std::string();
+  switch (node->GetProperty()) {
+    case LP_JSArrowFunction:
+      break;
+    case LP_JavaLambda:
+    case LP_NA:
+    default:
+      MASSERT(0 && "Unexpected enumerator");
+  }
+
+  std::string str;
+  for (unsigned i = 0; i < node->GetAttrsNum(); ++i)
+    str += GetEnumAttrId(node->GetAttrAtIndex(i));
+  auto num = node->GetTypeParamsNum();
+  if(num) {
+    str += '<';
+    for (unsigned i = 0; i < num; ++i) {
+      if (i)
+        str += ", "s;
+      if (auto n = node->GetTypeParamAtIndex(i)) {
+        str += EmitTreeNode(n);
+      }
+    }
+    str += '>';
+  }
+
+  str += '(';
+  for (unsigned i = 0; i < node->GetParamsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetParam(i)) {
+      str += EmitTreeNode(n);
+    }
+  }
+  str += ')';
+
+  if (auto n = node->GetBody()) {
+    if (auto t = node->GetRetType()) {
+      str += ": "s + EmitTreeNode(t);
+    }
+    std::string s = EmitTreeNode(n);
+    s = Clean(s);
+    if (n->IsStructLiteral())
+      s = '(' + s + ')';
+    str += " => "s + s;
+  }
+  else {
+    if (auto t = node->GetRetType()) {
+      str += " => "s + EmitTreeNode(t);
+    }
+  }
+
+  mPrecedence = '\004';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitInstanceOfNode(InstanceOfNode *node) {
+  if (node == nullptr)
+    return std::string();
+  const Precedence precd = '\014';
+  const bool rl_assoc = false;         // false: left-to-right
+  std::string lhs, rhs;
+  if (auto n = node->GetLeft()) {
+    lhs = EmitTreeNode(n);
+    if(precd > mPrecedence)
+      lhs = '(' + lhs + ')';
+  }
+  else
+    lhs = "(NIL) "s;
+  if (auto n = node->GetRight()) {
+    rhs = EmitTreeNode(n);
+    if(precd > mPrecedence || (precd == mPrecedence && !rl_assoc))
+      rhs = '(' + rhs + ')';
+  }
+  else
+    rhs = " (NIL)"s;
+  std::string str(lhs + " instanceof "s + rhs);
+  mPrecedence = precd;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitTypeOfNode(TypeOfNode *node) {
+  if (node == nullptr)
+    return std::string();
+  const Precedence precd = '\121' & 0x3f;
+  std::string str("typeof "s), rhs;
+  if (auto n = node->GetExpr()) {
+    rhs = EmitTreeNode(n);
+    if(precd > mPrecedence && !n->IsConditionalType()) // right-to-left
+      rhs = '(' + rhs + ')';
+  }
+  else
+    rhs = " (NIL)"s;
+  str += rhs;
+  mPrecedence = precd;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitKeyOfNode(KeyOfNode *node) {
+  if (node == nullptr)
+    return std::string();
+  const Precedence precd = '\121' & 0x3f;
+  std::string str("keyof "s), rhs;
+  if (auto n = node->GetExpr()) {
+    rhs = EmitTreeNode(n);
+    if(precd > mPrecedence)
+      rhs = '(' + rhs + ')';
+  }
+  else
+    rhs = " (NIL)"s;
+  str += rhs;
+  mPrecedence = precd;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitInferNode(InferNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("infer ");
+  if (auto n = node->GetExpr()) {
+    str += EmitTreeNode(n);
+  }
+  mPrecedence = '\024';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitInNode(InNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetLeft()) {
+    str += EmitTreeNode(n);
+  }
+  str += " in "s;
+  if (auto n = node->GetRight()) {
+    str += EmitTreeNode(n);
+  }
+  mPrecedence = '\014';
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitIsNode(IsNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetLeft()) {
+    str = EmitTreeNode(n);
+  }
+  str += " is "s;
+  if (auto n = node->GetRight()) {
+    str += EmitTreeNode(n);
+  }
+  return str;
+}
+
+std::string Emitter::EmitAwaitNode(AwaitNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("await "s);
+  if (auto n = node->GetExpr()) {
+    str += EmitTreeNode(n);
+  }
+  mPrecedence = '\023';
+  if (node->IsStmt())
+    str += ";\n"s;
+  return str;
+}
+
+std::string Emitter::EmitNameTypePairNode(NameTypePairNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  if (auto n = node->GetVar()) {
+    str += EmitTreeNode(n) + ": "s;
+  }
+  if (auto n = node->GetType()) {
+    str += EmitTreeNode(n);
+  }
+  return str;
+}
+
+std::string Emitter::EmitTupleTypeNode(TupleTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str("[ ");
+
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    if (i)
+      str += ", "s;
+    if (auto n = node->GetField(i)) {
+      str += EmitNameTypePairNode(n);
+    }
+  }
+  str += " ]"s;
+
+  mPrecedence = '\030';
+  return str;
+}
+
+std::string Emitter::EmitTripleSlashNode(TripleSlashNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str;
+  str += "/// <reference "s + GetEnumTripleSlashProp(node->GetProp());
+  if (auto n = node->GetValue()) {
+    str += '=' + EmitTreeNode(n);
+  }
+  str += " />"s;
+  return str;
+}
+
+std::string Emitter::EmitModuleNode(ModuleNode *node) {
+  if (node == nullptr)
+    return std::string();
+
+  std::string str;
+  for (unsigned i = 0; i < node->GetTreesNum(); ++i) {
+    if (auto n = node->GetTree(i)) {
+      str += EmitTreeNode(n) + GetEnding(n);
+    }
+  }
+
+  std::string name = node->GetFilename();
+  if (auto p = node->GetParent()) {
+    if (node->IsAmbient())
+      name = '"' + name + '"';
+    str = "module "s + name + " {\n"s + str + "}\n"s;
+  } else
+    str = "// Filename: "s + name + "\n"s + str;
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitAttrNode(AttrNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str(GetEnumAttrId(node->GetId()));
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitArrayTypeNode(ArrayTypeNode *node) {
+  // TODO
+  std::string str = "";
+  return str;
+}
+
+std::string Emitter::EmitFunctionTypeNode(FunctionTypeNode *node) {
+  // TODO
+  std::string str = "";
+  return str;
+}
+
+std::string Emitter::EmitPrimTypeNode(PrimTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  auto k = node->GetPrimType();
+  std::string str = k == TY_None ? std::string() : Emitter::GetEnumTypeId(k);
+  if (node->IsUnique())
+    str = "unique "s + str;
+  mPrecedence = '\030';
+  return str;
+}
+
+std::string Emitter::EmitPrimArrayTypeNode(PrimArrayTypeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  std::string str, accessor;
+  for (unsigned i = 0; i < node->GetAttrsNum(); ++i) {
+    std::string s = GetEnumAttrId(node->GetAttrAtIndex(i));
+    if (s == "get "s || s == "set "s)
+      accessor += s;
+    else
+      str += s;
+  }
+  str += accessor;
+  if (auto n = node->GetPrim()) {
+    str += EmitPrimTypeNode(n);
+  }
+  if (auto n = node->GetDims()) {
+    str += EmitDimensionNode(n);
+    Replace(str, "never[", "[");
+  }
+  return HandleTreeNode(str, node);
+}
+
+std::string Emitter::EmitTreeNode(TreeNode *node) {
+  if (node == nullptr)
+    return std::string();
+  switch (node->GetKind()) {
+  case NK_Module:
+    return EmitModuleNode(static_cast<ModuleNode *>(node));
+    break;
+  case NK_Package:
+    return EmitPackageNode(static_cast<PackageNode *>(node));
+    break;
+  case NK_XXportAsPair:
+    return EmitXXportAsPairNode(static_cast<XXportAsPairNode *>(node));
+    break;
+  case NK_Import:
+    return EmitImportNode(static_cast<ImportNode *>(node));
+    break;
+  case NK_Export:
+    return EmitExportNode(static_cast<ExportNode *>(node));
+    break;
+  case NK_Declare:
+    return EmitDeclareNode(static_cast<DeclareNode *>(node));
+    break;
+  case NK_Decl:
+    return EmitDeclNode(static_cast<DeclNode *>(node));
+    break;
+  case NK_Identifier:
+    return EmitIdentifierNode(static_cast<IdentifierNode *>(node));
+    break;
+  case NK_Field:
+    return EmitFieldNode(static_cast<FieldNode *>(node));
+    break;
+  case NK_Dimension:
+    return EmitDimensionNode(static_cast<DimensionNode *>(node));
+    break;
+  case NK_Attr:
+    return EmitAttrNode(static_cast<AttrNode *>(node));
+    break;
+  case NK_NameTypePair:
+    return EmitNameTypePairNode(static_cast<NameTypePairNode *>(node));
+    break;
+  case NK_PrimType:
+    return EmitPrimTypeNode(static_cast<PrimTypeNode *>(node));
+    break;
+  case NK_PrimArrayType:
+    return EmitPrimArrayTypeNode(static_cast<PrimArrayTypeNode *>(node));
+    break;
+  case NK_ArrayType:
+    return EmitArrayTypeNode(static_cast<ArrayTypeNode *>(node));
+    break;
+  case NK_FunctionType:
+    return EmitFunctionTypeNode(static_cast<FunctionTypeNode *>(node));
+    break;
+  case NK_UserType:
+    return EmitUserTypeNode(static_cast<UserTypeNode *>(node));
+    break;
+  case NK_TypeParameter:
+    return EmitTypeParameterNode(static_cast<TypeParameterNode *>(node));
+    break;
+  case NK_AsType:
+    return EmitAsTypeNode(static_cast<AsTypeNode *>(node));
+    break;
+  case NK_TypeAlias:
+    return EmitTypeAliasNode(static_cast<TypeAliasNode *>(node));
+    break;
+  case NK_ConditionalType:
+    return EmitConditionalTypeNode(static_cast<ConditionalTypeNode *>(node));
+    break;
+  case NK_TupleType:
+    return EmitTupleTypeNode(static_cast<TupleTypeNode *>(node));
+    break;
+  case NK_Cast:
+    return EmitCastNode(static_cast<CastNode *>(node));
+    break;
+  case NK_Parenthesis:
+    return EmitParenthesisNode(static_cast<ParenthesisNode *>(node));
+    break;
+  case NK_BindingElement:
+    return EmitBindingElementNode(static_cast<BindingElementNode *>(node));
+    break;
+  case NK_BindingPattern:
+    return EmitBindingPatternNode(static_cast<BindingPatternNode *>(node));
+    break;
+  case NK_Struct:
+    return EmitStructNode(static_cast<StructNode *>(node));
+    break;
+  case NK_StructLiteral:
+    return EmitStructLiteralNode(static_cast<StructLiteralNode *>(node));
+    break;
+  case NK_FieldLiteral:
+    return EmitFieldLiteralNode(static_cast<FieldLiteralNode *>(node));
+    break;
+  case NK_NumIndexSig:
+    return EmitNumIndexSigNode(static_cast<NumIndexSigNode *>(node));
+    break;
+  case NK_StrIndexSig:
+    return EmitStrIndexSigNode(static_cast<StrIndexSigNode *>(node));
+    break;
+  case NK_ComputedName:
+    return EmitComputedNameNode(static_cast<ComputedNameNode *>(node));
+    break;
+  case NK_ArrayElement:
+    return EmitArrayElementNode(static_cast<ArrayElementNode *>(node));
+    break;
+  case NK_ArrayLiteral:
+    return EmitArrayLiteralNode(static_cast<ArrayLiteralNode *>(node));
+    break;
+  case NK_VarList:
+    return EmitVarListNode(static_cast<VarListNode *>(node));
+    break;
+  case NK_ExprList:
+    return EmitExprListNode(static_cast<ExprListNode *>(node));
+    break;
+  case NK_TemplateLiteral:
+    return EmitTemplateLiteralNode(static_cast<TemplateLiteralNode *>(node));
+    break;
+  case NK_RegExpr:
+    return EmitRegExprNode(static_cast<RegExprNode *>(node));
+    break;
+  case NK_Literal:
+    return EmitLiteralNode(static_cast<LiteralNode *>(node));
+    break;
+  case NK_UnaOperator:
+    return EmitUnaOperatorNode(static_cast<UnaOperatorNode *>(node));
+    break;
+  case NK_BinOperator:
+    return EmitBinOperatorNode(static_cast<BinOperatorNode *>(node));
+    break;
+  case NK_TerOperator:
+    return EmitTerOperatorNode(static_cast<TerOperatorNode *>(node));
+    break;
+  case NK_Lambda:
+    return EmitLambdaNode(static_cast<LambdaNode *>(node));
+    break;
+  case NK_InstanceOf:
+    return EmitInstanceOfNode(static_cast<InstanceOfNode *>(node));
+    break;
+  case NK_TypeOf:
+    return EmitTypeOfNode(static_cast<TypeOfNode *>(node));
+    break;
+  case NK_KeyOf:
+    return EmitKeyOfNode(static_cast<KeyOfNode *>(node));
+    break;
+  case NK_In:
+    return EmitInNode(static_cast<InNode *>(node));
+    break;
+  case NK_Is:
+    return EmitIsNode(static_cast<IsNode *>(node));
+    break;
+  case NK_Infer:
+    return EmitInferNode(static_cast<InferNode *>(node));
+    break;
+  case NK_TripleSlash:
+    return EmitTripleSlashNode(static_cast<TripleSlashNode *>(node));
+    break;
+  case NK_Block:
+    return EmitBlockNode(static_cast<BlockNode *>(node));
+    break;
+  case NK_Function:
+    return EmitFunctionNode(static_cast<FunctionNode *>(node));
+    break;
+  case NK_Class:
+    return EmitClassNode(static_cast<ClassNode *>(node));
+    break;
+  case NK_Interface:
+    return EmitInterfaceNode(static_cast<InterfaceNode *>(node));
+    break;
+  case NK_Namespace:
+    return EmitNamespaceNode(static_cast<NamespaceNode *>(node));
+    break;
+  case NK_AnnotationType:
+    return EmitAnnotationTypeNode(static_cast<AnnotationTypeNode *>(node));
+    break;
+  case NK_Annotation:
+    return EmitAnnotationNode(static_cast<AnnotationNode *>(node));
+    break;
+  case NK_Try:
+    return EmitTryNode(static_cast<TryNode *>(node));
+    break;
+  case NK_Catch:
+    return EmitCatchNode(static_cast<CatchNode *>(node));
+    break;
+  case NK_Finally:
+    return EmitFinallyNode(static_cast<FinallyNode *>(node));
+    break;
+  case NK_Exception:
+    return EmitExceptionNode(static_cast<ExceptionNode *>(node));
+    break;
+  case NK_Throw:
+    return EmitThrowNode(static_cast<ThrowNode *>(node));
+    break;
+  case NK_Await:
+    return EmitAwaitNode(static_cast<AwaitNode *>(node));
+    break;
+  case NK_Return:
+    return EmitReturnNode(static_cast<ReturnNode *>(node));
+    break;
+  case NK_Yield:
+    return EmitYieldNode(static_cast<YieldNode *>(node));
+    break;
+  case NK_CondBranch:
+    return EmitCondBranchNode(static_cast<CondBranchNode *>(node));
+    break;
+  case NK_Break:
+    return EmitBreakNode(static_cast<BreakNode *>(node));
+    break;
+  case NK_Continue:
+    return EmitContinueNode(static_cast<ContinueNode *>(node));
+    break;
+  case NK_ForLoop:
+    return EmitForLoopNode(static_cast<ForLoopNode *>(node));
+    break;
+  case NK_WhileLoop:
+    return EmitWhileLoopNode(static_cast<WhileLoopNode *>(node));
+    break;
+  case NK_DoLoop:
+    return EmitDoLoopNode(static_cast<DoLoopNode *>(node));
+    break;
+  case NK_New:
+    return EmitNewNode(static_cast<NewNode *>(node));
+    break;
+  case NK_Delete:
+    return EmitDeleteNode(static_cast<DeleteNode *>(node));
+    break;
+  case NK_Call:
+    return EmitCallNode(static_cast<CallNode *>(node));
+    break;
+  case NK_Assert:
+    return EmitAssertNode(static_cast<AssertNode *>(node));
+    break;
+  case NK_SwitchLabel:
+    return EmitSwitchLabelNode(static_cast<SwitchLabelNode *>(node));
+    break;
+  case NK_SwitchCase:
+    return EmitSwitchCaseNode(static_cast<SwitchCaseNode *>(node));
+    break;
+  case NK_Switch:
+    return EmitSwitchNode(static_cast<SwitchNode *>(node));
+    break;
+  case NK_Pass:
+    return EmitPassNode(static_cast<PassNode *>(node));
+    break;
+  case NK_Null:
+    // Ignore NullNode
+    break;
+  default:
+    MASSERT(0 && "Unexpected node kind");
+  }
+  return std::string();
+}
+
+std::string &Emitter::AddParentheses(std::string &str, TreeNode *node) {
+  if (mPrecedence < '\024' ||
+      (!node->IsIdentifier() &&
+       !node->IsField() &&
+       !node->IsInfer() &&
+       !node->IsLiteral() &&
+       !node->IsArrayLiteral() &&
+       !node->IsBindingPattern())) {
+    str = '(' + str + ')';
+    mPrecedence = '\030';
+  }
+  return str;
+}
+
+std::string &Emitter::HandleTreeNode(std::string &str, TreeNode *node) {
+  auto num = node->GetAsTypesNum();
+  if(num > 0) {
+    if (node->IsBinOperator() ||
+        node->IsUnaOperator() ||
+        node->IsTerOperator() ||
+        node->IsNew()) {
+      str = '(' + str + ')';
+      mPrecedence = '\030';
+    }
+    for (unsigned i = 0; i < num; ++i)
+      if (auto t = node->GetAsTypeAtIndex(i)) {
+        str += EmitAsTypeNode(t);
+        mPrecedence = '\003';
+      }
+  }
+  if(node->IsOptional())
+    str = AddParentheses(str, node) + '?';
+  if(node->IsNonNull())
+    str = AddParentheses(str, node) + '!';
+  if(node->IsRest())
+    str = "..."s + AddParentheses(str, node);
+  if(node->IsConst()) {
+    str = AddParentheses(str, node) + " as const"s;
+    mPrecedence = '\003';
+  }
+  return str;
+}
+
+std::string Emitter::GetEnumTypeId(TypeId k) {
+  std::string str(AstDump::GetEnumTypeId(k) + 3);
+  if (k != TY_Function && k != TY_Object)
+    str[0] = std::tolower(str[0]);
+  return str;
+}
+
+std::string Emitter::GetEnumDeclProp(DeclProp k) {
+  std::string str(AstDump::GetEnumDeclProp(k) + 3);
+  if(str != "NA")
+    str[0] = std::tolower(str[0]);
+  return str;
+}
+
+const char *Emitter::GetEnumOprId(OprId k) {
+  // The first char in the returned string includes operator precedence and associativity info
+  //
+  // bits   7   6   5   4   3   2   1   0
+  //        0   ^   ^---^---^-+-^---^---^
+  //            |             |__ operator precedence
+  //            |
+  //            |__ associativity, 0: left-to-right, 1: right-to-left
+  //
+  switch (k) {
+  case OPR_Plus:
+    return          "\121+";
+  case OPR_Add:
+    return          "\016+";
+  case OPR_Minus:
+    return          "\121-";
+  case OPR_Sub:
+    return          "\016-";
+  case OPR_Mul:
+    return          "\017*";
+  case OPR_Div:
+    return          "\017/";
+  case OPR_Mod:
+    return          "\017%";
+  case OPR_PreInc:
+    return          "\121++";
+  case OPR_Inc:
+    return          "\022++";
+  case OPR_PreDec:
+    return          "\121--";
+  case OPR_Dec:
+    return          "\022--";
+  case OPR_Exp:
+    return          "\120**";
+  case OPR_EQ:
+    return          "\013==";
+  case OPR_NE:
+    return          "\013!=";
+  case OPR_GT:
+    return          "\014>";
+  case OPR_LT:
+    return          "\014<";
+  case OPR_GE:
+    return          "\014>=";
+  case OPR_LE:
+    return          "\014<=";
+  case OPR_Band:
+    return          "\012&";
+  case OPR_Bor:
+    return          "\010|";
+  case OPR_Bxor:
+    return          "\011^";
+  case OPR_Bcomp:
+    return          "\121~";
+  case OPR_Shl:
+    return          "\015<<";
+  case OPR_Shr:
+    return          "\015>>";
+  case OPR_Zext:
+    return          "\015>>>";
+  case OPR_Land:
+    return          "\007&&";
+  case OPR_Lor:
+    return          "\006||";
+  case OPR_Not:
+    return          "\121!";
+  case OPR_Assign:
+    return          "\103=";
+  case OPR_AddAssign:
+    return          "\103+=";
+  case OPR_SubAssign:
+    return          "\103-=";
+  case OPR_MulAssign:
+    return          "\103*=";
+  case OPR_DivAssign:
+    return          "\103/=";
+  case OPR_ModAssign:
+    return          "\103%=";
+  case OPR_ShlAssign:
+    return          "\103<<=";
+  case OPR_ShrAssign:
+    return          "\103>>=";
+  case OPR_BandAssign:
+    return          "\103&=";
+  case OPR_BorAssign:
+    return          "\103|=";
+  case OPR_BxorAssign:
+    return          "\103^=";
+  case OPR_ZextAssign:
+    return          "\103>>>=";
+  case OPR_NullAssign:
+    return          "\103??=";
+  case OPR_Arrow:
+    return          "\030 OPR_Arrow";
+  case OPR_Diamond:
+    return          "\030 OPR_Diamond";
+  case OPR_StEq:
+    return          "\013===";
+  case OPR_StNe:
+    return          "\013!==";
+  case OPR_ArrowFunction:
+    return          "\030 OPR_ArrowFunction";
+  case OPR_NullCoalesce:
+    return          "\005??";
+  case OPR_NA:
+    return          "\030 OPR_NA";
+  default:
+    MASSERT(0 && "Unexpected enumerator");
+  }
+  return "UNEXPECTED OprId";
+}
+
+const char *Emitter::GetEnumTripleSlashProp(TripleSlashProp k) {
+  switch (k) {
+  case TSP_Path:
+    return "path";
+  case TSP_Types:
+    return "types";
+  case TSP_Lib:
+    return "lib";
+  case TSP_NoDefaultLib:
+    return "no-default-lib";
+  case TSP_NA:
+    return "TSP_NA";
+  default:
+    MASSERT(0 && "Unexpected enumerator");
+  }
+  return "UNEXPECTED TripleSlashProp";
+}
+
+} // namespace maplefe
diff --git a/src/MapleFE/ast2cpp/src/helper.cpp b/src/MapleFE/ast2cpp/src/helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1222f2341802e47bf06284101f033cd65dd21376
--- /dev/null
+++ b/src/MapleFE/ast2cpp/src/helper.cpp
@@ -0,0 +1,355 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+#include "helper.h"
+
+namespace maplefe {
+
+FuncTable hFuncTable;
+GeneratorLabels GenFnLabels;
+
+std::unordered_map<TypeId, std::string>TypeIdToJSTypeCXX = {
+  // AST TypeId to t2crt JS_Type mapping for JS_Val type of obj props that pts to CXX class fields 
+  {TY_Object,  "t2crt::TY_CXX_Object"},
+  {TY_Function,"t2crt::TY_CXX_Function"},
+  {TY_Boolean, "t2crt::TY_CXX_Bool"},
+  {TY_Int,     "t2crt::TY_CXX_Long"},
+  {TY_String,  "t2crt::TY_CXX_String"},
+  {TY_Number,  "t2crt::TY_CXX_Double"},
+  {TY_Double,  "t2crt::TY_CXX_Double"},
+  {TY_Array,   "t2crt::TY_CXX_Object"},
+  {TY_Class,   "t2crt::TY_CXX_Object"},
+  {TY_Any,     "t2crt::TY_CXX_Any"},
+};
+
+std::string GeneratorFn_start = R"""(
+  if (yield != nullptr)
+    goto *yield;
+)""";
+
+std::string GeneratorFn_return = R"""(
+  res.value = undefined;
+  res.done  = true;
+  return;
+)""";
+
+// Used to build GetProp<xxx> for calls to get Object (class Object in ts2cpp.h) property
+std::string hlpGetJSValTypeStr(TypeId typeId) {
+  switch(typeId) {
+    case TY_Object:
+    case TY_Class:
+      return "Obj";
+    case TY_Any:
+      return "";
+    case TY_Function:
+      return "Func";
+    case TY_Boolean:
+      return "bool";
+    case TY_Number:
+      return "Double";
+    case TY_String:
+      return "Str";
+  }
+  return std::string();
+}
+
+// Get TypeId info for a treenode.
+TypeId hlpGetTypeId(TreeNode* node) {
+  // lookup typetable
+  if (node->GetTypeIdx()) {
+    TypeEntry* te = gTypeTable.GetTypeEntryFromTypeIdx(node->GetTypeIdx());
+    if (te) 
+      return te->GetTypeId();
+  }
+
+  // lookup ast node mTypeId (will be deprecated)
+  if (node->GetTypeId() != TY_None) {
+    return node->GetTypeId();
+  }
+  return TY_Any;
+}
+
+// Temp. workaround to get func info for var of type function. TODO: replace with TI API when avail.
+std::string GetClassOfAssignedFunc(TreeNode* node) {
+  if (node->IsIdentifier() &&
+      node->GetParent() &&
+      node->GetParent()->IsDecl() &&
+      static_cast<DeclNode*>(node->GetParent())->GetInit() &&
+      static_cast<DeclNode*>(node->GetParent())->GetInit()->IsFunction()) {
+    auto n = static_cast<DeclNode*>(node->GetParent())->GetInit();
+    return("Cls_"s + static_cast<FunctionNode*>(n)->GetName());
+  }
+  return std::string();
+}
+
+// Generate call to create obj prop with ptr to c++ class fld member
+// e.g. obj->AddProp("fdLong", t2crt::ClassFld<long   Foo::*>(&Foo::fdLong).NewProp(this, t2crt::TY_CXX_Long))
+//      obj->AddProp("fdAny",  t2crt::ClassFld<JS_Val Foo::*>(&Foo::fdAny).NewProp(this,  t2crt::TY_CXX_Any))
+std::string GenClassFldAddProp(std::string objName,
+                               std::string clsName,
+                               std::string fldName,
+                               std::string fldCType,
+                               std::string fldJSType) {
+  std::string str;
+  str = objName + "->AddProp(\"" + fldName + "\", t2crt::ClassFld<" + 
+    fldCType + " " + clsName + "::*>(&" +
+    clsName + "::" + fldName + ").NewProp(this, " + fldJSType + "))";
+  return str;
+}
+
+// From TS func param info, generate param and arg list for corresponding mapped C++ func.
+//
+// Different formats of arg list as needed by C++ mapping of function/class/generators
+// <type>    <argName>   - args for function class functor and generation class constructor
+// <argName> (<ArgName>) - generator class constructor field init list
+// <type>&   <argName>   - args passed by reference to generation function _body method
+// <type>    <argName>;  - generator class fields for capturing closure
+//
+std::string FunctionParams(unsigned nodeId, bool handleThis, bool argsOnly, bool byRef, bool fdInit, bool capture) {
+  std::vector<std::pair<std::string, std::string>> funcParams = hFuncTable.GetArgInfo(nodeId);
+  std::string ObjT = "t2crt::Object*";
+  std::string str;
+
+  // "this" in TS function paramter mapping to C++:
+  //
+  // TS2cpp's C++ mapping for TS func has a "this" obj in the c++ func param list
+  // which will be generated from AST if "this" is declared as a TS func parameter
+  // as required by TS strict mode. However TS funcs that do not reference 'this'
+  // are not required to declare it, in which case emitter has to insert one.
+  //
+  // Cases:
+  // if TS func has no param
+  //   - insert param "ts2crt::Object* _this"
+  // if 1st TS func param is not "this"
+  //   - insert param "ts2crt::Object* _this"
+  // if 1st TS func param is "this"
+  //   - rename to "_this"
+  //   - if type is Any (JS_Val), change to "ts2crt::Object*"
+  //
+  if (handleThis) {
+    if (funcParams.size() == 0)          // func has no param
+      return argsOnly ? "_this"s : (ObjT + " _this");
+  }
+
+  for (bool first=true; auto elem : funcParams) {
+    std::string type = elem.first, name = elem.second;
+    if (!first)
+      str += ", "s;
+    else {                              // 1st param of TS func
+      if (handleThis) {
+        if (name.compare("this") != 0)  // if not "this", insert _this
+          str += argsOnly? ("_this, "s): (ObjT + " _this, "s);
+        else {                          // if "this"
+          name = "_this";               // rename to "_this"
+          if (type.compare("t2crt::JS_Val") == 0)
+            type = ObjT;                // change type Any to Object*
+        }
+      }
+      first = false;
+    }
+    if (fdInit)
+      str += name + "(" + name + ")";
+    else if (capture)
+      str += type + " " + name + ";\n";
+    else
+      str += argsOnly? name: (type + (byRef?"\&":"") +  " "s + name);
+  }
+  return str;
+}
+
+// Each first level function is instantiated from a corresponding class generated with interfaces below:
+//   Body  - user defined function code
+//   ()    - functor for OrdinaryCallEvaluteBody [9.2.1.3]
+//   Ctor  - Call user defined code as constructor (with object from new() op)
+//   Call  - Call user defined code with designated 'this'
+//   Apply - Call user defined code with designated 'this' and array of argument
+//   Bind  - Create and return function object binded to designated this and optional args
+// note: the parameter args is expected to be a string that start with "_this"
+//       TODO: apply and bind may be moved to ts2cpp.h Fuction class as virtual
+// note: TSC prohibits calling non-void constructor func with new(), so in the code generated below
+//       for ctor(), it calls _body() but ignores return val from _body(), and instead returns _this
+//       per TS/JS spec.
+
+std::string FunctionClassDecl(std::string retType, std::string funcName, unsigned nodeId) {
+  std::string str, args, params, thisType;
+
+  std::string clsName = ClsName(funcName);
+  params = FunctionParams(nodeId, true, false);
+  args   = FunctionParams(nodeId, true, true);
+  thisType = params.substr(0, params.find(" "));  // extract return type of "this" parameter
+
+  std::string functorParams = params;
+  std::string functorArgs   = args;
+  functorArgs.replace(0, 5, "_thisArg"); // replace _this with _thisArg
+  size_t pos;
+  if ((pos = functorParams.find("_this, ")) != std::string::npos)
+    functorParams.erase(0, pos+7);
+  else if ((pos = functorParams.find("_this")) != std::string::npos)
+    functorParams.erase(0, pos+5);
+
+  str = R"""(
+class )""" + clsName + R"""( : public t2crt::Function {
+  public:
+    )""" + clsName + R"""(() : t2crt::Function(&t2crt::Function::ctor,t2crt::Function::ctor.prototype,t2crt::Object::ctor.prototype) {}
+    ~)""" + clsName + R"""(() {}
+
+    )""" + retType + R"""(  _body()""" + params + R"""();
+    )""" + retType + R"""(  operator()()""" + functorParams + R"""() { return _body(()""" + thisType + R"""())""" + functorArgs + R"""(); }
+    t2crt::Object*  ctor ()""" + params + R"""() { _body()""" + args + R"""(); return(_this); }
+    )""" + retType + R"""(  call ()""" + params + R"""() { return _body()""" + args + R"""( ); }
+    )""" + retType + R"""(  apply(t2crt::Object* _this, t2crt::ArgsT& args) { /* TODO: call _body wtih flatten args  */ }
+    )""" + clsName + R"""(* bind (t2crt::Object* _this, t2crt::ArgsT* args) {
+      )""" + clsName + R"""(* func = new )""" + clsName + R"""(();
+      func->_thisArg = _this;
+      func->_args = args;
+      return(func);
+    }
+    virtual const char* __GetClassName() const {return ")""" + funcName + R"""( ";}
+};
+
+)""";
+  return str;
+}
+
+// build generator function header for _body
+std::string GeneratorFuncHeader(std::string cls, unsigned nodeId) {
+  std::string params = FunctionParams(nodeId, false, false, true); // pass params by ref into _body()
+  if (!params.empty())
+    params = ", " + params;
+  return "void " + cls + "_body(t2crt::Object* _this, void*& yield, t2crt::IteratorResult& res" + params + ")";
+}
+
+// Generating Generators and Generator Functions:
+// For each TS generator function, 2 C++ classes: generator and generator function are emitted.
+// The generator function has only a single instance. It is called to create generator instances.
+std::string GeneratorClassDecl(std::string funcName, unsigned nodeId) {
+  std::string str;
+  std::string generatorName = GeneratorName(funcName);
+  std::string generatorFuncName = GeneratorFuncName(funcName);
+
+  std::string functorArgs  = FunctionParams(nodeId, false, false);
+  std::string initList     = FunctionParams(nodeId, false, false, false, true) ;
+  std::string captureFields = FunctionParams(nodeId, false, false, false, false, true);
+  std::string ctorArgs = functorArgs.empty()? std::string(): (", "s + functorArgs);
+  initList = initList.empty()? "": (", "s + initList);
+
+  std::string genClsDecl[] = {
+"// " +funcName+ " generators",
+"class " +generatorName+ " : public t2crt::GeneratorProto {",
+"public:",
+"  " +generatorName+ "(t2crt::Function* ctor, t2crt::Object* proto" +ctorArgs+ ") : t2crt::GeneratorProto(ctor, proto)" +initList+ " {}",
+"  ~" +generatorName+ "() {}",
+"  // closure capture fields",
+"  " +captureFields,
+"  // iterator interface (override _return and _throw when needed)",
+"  t2crt::IteratorResult* next(t2crt::JS_Val* arg = nullptr) override;",
+"};",
+"// " +funcName+ " generator function",
+"class " +generatorFuncName+ " : public t2crt::GeneratorFuncPrototype {",
+"public:",
+"  " +generatorFuncName+ "() : t2crt::GeneratorFuncPrototype(&t2crt::GeneratorFunction, &t2crt::Generator, t2crt::GeneratorPrototype) {}",
+"  ~" +generatorFuncName+ "() {}",
+"  // call operator returns generator instances",
+"  " +generatorName+ "* operator()(" +functorArgs+ ");",
+"  // generator function body",
+"  " +GeneratorFuncHeader("", nodeId)+ ";",
+"};",
+""
+  };
+
+  str += "\n";
+  for (auto elem : genClsDecl)
+    str += elem + "\n";
+  return str;
+}
+
+std::string GeneratorClassDef(std::string ns, std::string funcName, unsigned nodeId) {
+  std::string str;
+  std::string generatorName = ns + GeneratorName(funcName);
+  std::string generatorFuncName = ns + GeneratorFuncName(funcName);
+
+  if (!ns.empty())
+    funcName = ns + "::" + funcName;
+
+  std::string params = FunctionParams(nodeId, false, false);
+  std::string args   = FunctionParams(nodeId, false, true);
+  if (!args.empty())
+    args = ", " + args;
+
+  str = R"""(
+t2crt::IteratorResult* )""" + generatorName + R"""(::next(t2crt::JS_Val* arg) {
+  if (_finished) {
+    _res.done = true;
+    return &_res;
+  }
+  // iterate by calling generation function with captures in generator
+  )""" + funcName + R"""(->_body(this, _yield, _res)""" + args + R"""();
+  if (_res.done == true)
+    _finished = true;
+  return &_res;
+}
+
+)""" + generatorName + "* "s + generatorFuncName + R"""(::operator()()""" + params + R"""() {
+  return new )""" + generatorName + R"""((&t2crt::Generator, foo->prototype)""" + args + R"""();
+}
+
+)""";
+  return str;
+}
+
+bool IsClassMethod(TreeNode* node) {
+  return(node->IsFunction() && node->GetParent() && node->GetParent()->IsClass());
+}
+
+std::string tab(int n) {
+  return std::string(n*2,' ');
+}
+
+std::string GenAnonFuncName(TreeNode* node) {
+  return "_anon_func_"s + std::to_string(node->GetNodeId());
+}
+
+// return array constructor name of given type
+// format:
+//  1D array: t2crt::Array<type>::ctor
+//  2D array: t2crt::Array<t2crt::Array<type>*>::ctor
+//  3D array: t2crt::Array<t2crt::Array<t2crt::Array<type>*>*>::ctor
+//  ...
+//  note: must be in sycn with format generated by ARR_CTOR_DEF in builtins.h
+std::string ArrayCtorName(int dim, std::string type) {
+  if (!dim)
+    return std::string();
+  std::string str = "t2crt::Array<"s + type + ">"s;
+  for (int i=1; i<dim; ++i) {
+    str = "t2crt::Array<"s + str + "*>"s;
+  }
+  str = str + "::ctor"s;
+  return str;
+}
+
+// note: entries below are to match values from ast nodes. Do not prepend with "t2crt::"
+std::vector<std::string>builtins = {"Object", "Function", "Number", "Array", "Record"};
+
+bool IsBuiltinObj(std::string name) {
+  return std::find(builtins.begin(), builtins.end(), name) != builtins.end();
+}
+
+std::string ObjectTypeStr(std::string name) {
+  if (IsBuiltinObj(name))
+    return "t2crt::" + name + "*";
+  else
+    return name + "*";
+}
+
+} // namespace maplefe
diff --git a/src/MapleFE/ast2cpp/src/main.cpp b/src/MapleFE/ast2cpp/src/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6062f4228f538d04148f62a5fa909b7bacb08819
--- /dev/null
+++ b/src/MapleFE/ast2cpp/src/main.cpp
@@ -0,0 +1,108 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <sstream>
+#include <fstream>
+#include <iterator>
+#include "gen_astload.h"
+#include "ast_handler.h"
+#include "ast2cpp.h"
+
+static void help() {
+  std::cout << "ast2cpp a.ast[,b.ast] [options]:" << std::endl;
+  std::cout << "   --out=x.cpp      : cpp output file" << std::endl;
+  std::cout << "   --help           : print this help" << std::endl;
+  std::cout << "   --trace=n        : Emit trace with 4-bit combo levels 1...15" << std::endl;
+  std::cout << "           1        : Emit ast tree visits" << std::endl;
+  std::cout << "           2        : Emit graph" << std::endl;
+  std::cout << "   --emit-ts-only   : Emit ts code only" << std::endl;
+  std::cout << "   --emit-ts        : Emit ts code" << std::endl;
+  std::cout << "   --format-cpp     : Format cpp" << std::endl;
+  std::cout << "   --no-imported    : Do not process the imported modules" << std::endl;
+  std::cout << "default out name uses the first input name: a.cpp" << std::endl;
+}
+
+int main (int argc, char *argv[]) {
+  if (argc == 1 || (!strncmp(argv[1], "--help", 6) && (strlen(argv[1]) == 6))) {
+    help();
+    exit(-1);
+  }
+
+  unsigned flags;
+  // one or more input .ast files separated by ','
+  const char *inputname = argv[1];
+  // output .cpp file
+  const char *outputname = nullptr;
+
+  // Parse the argument
+  for (unsigned i = 2; i < argc; i++) {
+    if (!strncmp(argv[i], "--trace=", 8)) {
+      int val = atoi(argv[i] + 8);
+      if (val < 1 || val > 15) {
+        help();
+        exit(-1);
+      }
+      flags |= val;
+    } else if (!strncmp(argv[i], "--emit-ts-only", 14)) {
+      flags |= maplefe::FLG_emit_ts_only;
+    } else if (!strncmp(argv[i], "--emit-ts", 9)) {
+      flags |= maplefe::FLG_emit_ts;
+    } else if (!strncmp(argv[i], "--format-cpp", 12)) {
+      flags |= maplefe::FLG_format_cpp;
+    } else if (!strncmp(argv[i], "--no-imported", 13)) {
+      flags |= maplefe::FLG_no_imported;
+    } else if (!strncmp(argv[i], "--in=", 5)) {
+      inputname = argv[i]+5;
+    } else if (!strncmp(argv[i], "--out=", 6)) {
+      outputname = argv[i]+6;
+    } else {
+      std::cerr << "unknown option " << argv[i] << std::endl;
+      exit(-1);
+    }
+  }
+
+  // input ast files
+  std::vector<std::string> inputfiles;
+  if (inputname) {
+    std::stringstream ss;
+    ss.str(inputname);
+    std::string item;
+    while (std::getline(ss, item, ',')) {
+      // std::cout << "item " << item << " xxx"<< std::endl;
+      inputfiles.push_back(item);
+    }
+  }
+
+  unsigned trace = (flags & maplefe::FLG_trace);
+  maplefe::AST_Handler handler(trace);
+  for (auto astfile: inputfiles) {
+    std::ifstream input(astfile, std::ifstream::binary);
+    input >> std::noskipws;
+    std::istream_iterator<uint8_t> s(input), e;
+    maplefe::AstBuffer vec(s, e);
+    maplefe::AstLoad loadAst;
+    maplefe::ModuleNode *mod = loadAst.LoadFromAstBuf(vec);
+    // add mod to the vector
+    while(mod) {
+      handler.AddModule(mod);
+      mod = loadAst.Next();
+    }
+  }
+
+  maplefe::A2C *a2c = new maplefe::A2C(&handler, flags);
+  int res = a2c->ProcessAST();
+
+  return res;
+}
diff --git a/src/MapleFE/test/testall b/src/MapleFE/ast2mpl/Makefile
old mode 100755
new mode 100644
similarity index 71%
rename from src/MapleFE/test/testall
rename to src/MapleFE/ast2mpl/Makefile
index 5de40cd76a41b0fbc4a25cd8d8a55707cfeecb14..da0321c1b14cbbfc75d469ee5abcdb42e6d29b15
--- a/src/MapleFE/test/testall
+++ b/src/MapleFE/ast2mpl/Makefile
@@ -1,4 +1,4 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+# Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
 # 
 # OpenArkFE is licensed under the Mulan PSL v2.
 # You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -12,5 +12,16 @@
 # See the Mulan PSL v2 for more details.
 # 
 
-./java2mpl_runtests.pl java2mpl
-./sharedfe_runtests.pl sharedfe
+include ../Makefile.in
+
+all:
+	$(MAKE) -C src
+
+clean:
+	rm -rf $(BUILDDIR)/shared
+
+test:
+	$(MAKE) -C ../test p
+
+.PHONY: $(TARGS)
+
diff --git a/src/MapleFE/java/include/ast2mpl_java.h b/src/MapleFE/ast2mpl/include/ast2mpl.h
similarity index 53%
rename from src/MapleFE/java/include/ast2mpl_java.h
rename to src/MapleFE/ast2mpl/include/ast2mpl.h
index cec63ef9035608a2e8ab8eddf821b02b6d0fc2ae..a9283482498005a40f1666a3bbaace49a85e4557 100644
--- a/src/MapleFE/java/include/ast2mpl_java.h
+++ b/src/MapleFE/ast2mpl/include/ast2mpl.h
@@ -13,25 +13,38 @@
 * See the Mulan PSL v2 for more details.
 */
 
-/////////////////////////////////////////////////////////////////////////////////
-//                   Java Specific AST2MPL                                     //
-/////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////
+//                This is the interface to translate AST to MapleIR.
+//////////////////////////////////////////////////////////////////////////////////////////////
 
-#ifndef __AST2MPL_JAVA_H__
-#define __AST2MPL_JAVA_H__
+#ifndef __AST2MPL_HEADER__
+#define __AST2MPL_HEADER__
 
-#include "ast2mpl.h"
+#include "astopt.h"
+#include "ast_handler.h"
+
+#include "mir_module.h"
+#include "maplefe_mir_builder.h"
 
 namespace maplefe {
 
-class A2MJava : public A2M {
+class A2M : public AstOpt {
 private:
-public:
-  A2MJava(const char *filename) : A2M(filename) { }
+  AST_Handler *mASTHandler;
+  unsigned     mFlags;
+  unsigned     mIndexImported;
 
-  const char *Type2Label(const maple::MIRType *type);
-
-  maple::MIRType *MapPrimType(PrimTypeNode *ptnode);
+public:
+  explicit A2M(AST_Handler *h, unsigned flags) :
+    AstOpt(h, flags),
+    mASTHandler(h),
+    mFlags(flags),
+    mIndexImported(0) {}
+  ~A2M() = default;
+
+  // return 0 if successful
+  // return non-zero if failed
+  int ProcessAST();
 };
 
 }
diff --git a/src/MapleFE/shared/include/ast2mpl.h b/src/MapleFE/ast2mpl/include/ast2mpl_builder.h
similarity index 75%
rename from src/MapleFE/shared/include/ast2mpl.h
rename to src/MapleFE/ast2mpl/include/ast2mpl_builder.h
index 837c7ee30229625f1a58893e3f424b26a858f48a..1270063fde7b185f7c04293502898921f6174215 100644
--- a/src/MapleFE/shared/include/ast2mpl.h
+++ b/src/MapleFE/ast2mpl/include/ast2mpl_builder.h
@@ -17,14 +17,14 @@
 //                This is the interface to translate AST to MapleIR.
 //////////////////////////////////////////////////////////////////////////////////////////////
 
-#ifndef __AST2MPL_HEADER__
-#define __AST2MPL_HEADER__
+#ifndef __AST2MPL_BUILDER_HEADER__
+#define __AST2MPL_BUILDER_HEADER__
 
-#include "ast_module.h"
 #include "ast.h"
-#include "ast_type.h"
+#include "ast_handler.h"
 
 #include "mir_module.h"
+#include "generic_attrs.h"
 #include "maplefe_mir_builder.h"
 
 namespace maplefe {
@@ -40,54 +40,72 @@ enum StmtExprKind {
   SK_Expr
 };
 
-class A2M {
+enum bool3 {
+  false3,
+  true3,
+  maybe3
+};
+
+class Ast2MplBuilder {
 private:
-  const char *mFileName;
-  bool mTraceA2m;
-  FEMIRBuilder *mMirBuilder;
+  AST_Handler    *mASTHandler;
+  const char     *mFilename;
+  bool            mTraceA2m;
+  FEMIRBuilder    *mMirBuilder;
   maple::MIRType *mDefaultType;
-  FieldData *mFieldData;
+  FieldData       *mFieldData;
+  unsigned        mUniqNum;
+  unsigned        mFlags;
+
 public:
   maple::MIRModule *mMirModule;
   // use type's uniq name as key
-  std::map<const char *, maple::MIRType*> mNodeTypeMap;
-  std::map<const char *, std::vector<maple::MIRFunction*>> mNameFuncMap;
+  std::map<unsigned, maple::MIRType*> mNodeTypeMap;
+  std::map<unsigned, std::vector<maple::MIRFunction*>> mNameFuncMap;
   std::map<BlockNode*, maple::BlockNode*> mBlockNodeMap;
   std::map<BlockNode*, maple::MIRFunction*> mBlockFuncMap;
   std::map<TreeNode*, maple::MIRFunction*> mFuncMap;
-  std::map<std::pair<const char *, BlockNode*>, maple::MIRSymbol*> mNameBlockVarMap;
+  std::map<std::pair<unsigned, BlockNode*>, maple::MIRSymbol*> mNameBlockVarMap;
+
+  Ast2MplBuilder(AST_Handler *h, unsigned f);
+  ~Ast2MplBuilder();
 
-  A2M(const char *filename);
-  ~A2M();
+  void Build();
 
   void Init();
   bool IsStmt(TreeNode *tnode);
+  bool3 IsCompatibleTo(maple::PrimType expected, maple::PrimType prim);
 
   void UpdateFuncName(maple::MIRFunction *func);
 
   virtual const char *Type2Label(const maple::MIRType *type);
   void Type2Name(std::string &str, const maple::MIRType *type);
 
+  ClassNode *GetSuperClass(ClassNode *klass);
   BlockNode *GetSuperBlock(BlockNode *block);
   maple::MIRSymbol *GetSymbol(TreeNode *tnode, BlockNode *block);
   maple::MIRSymbol *CreateSymbol(TreeNode *tnode, BlockNode *block);
   maple::MIRSymbol *CreateTempVar(const char *prefix, maple::MIRType *type);
-  maple::MIRFunction *GetFunc(BlockNode *block);
-  maple::MIRFunction *SearchFunc(const char *name, const maple::MapleVector<maple::BaseNode *> &args);
+  maple::MIRFunction *GetCurrFunc(BlockNode *block);
+  maple::MIRFunction *SearchFunc(unsigned idx, maple::MapleVector<maple::BaseNode *> &args);
+  maple::MIRFunction *SearchFunc(TreeNode *method, maple::MapleVector<maple::BaseNode *> &args, BlockNode *block);
   maple::MIRClassType *GetClass(BlockNode *block);
   void UpdateUniqName(std::string &str);
 
-  virtual maple::MIRType *MapPrimType(PrimTypeNode *tnode)=0;
+  maple::PrimType MapPrim(TypeId id);
+  maple::MIRType *MapPrimType(TypeId id);
+  maple::MIRType *MapPrimType(PrimTypeNode *tnode);
 
   maple::MIRType *MapType(TreeNode *tnode);
-  void MapAttr(maple::GenericAttrs &attr, const IdentifierNode *inode);
+  void MapAttr(maple::GenericAttrs &attr, AttrId id);
+  void MapAttr(maple::GenericAttrs &attr, IdentifierNode *inode);
+  void MapAttr(maple::GenericAttrs &attr, FunctionNode *fnode);
 
   maple::Opcode MapUnaOpcode(OprId);
   maple::Opcode MapBinOpcode(OprId);
   maple::Opcode MapBinCmpOpcode(OprId);
   maple::Opcode MapBinComboOpcode(OprId);
 
-  void ProcessAST(bool trace_a2m);
   maple::BaseNode *ProcessNodeDecl(StmtExprKind, TreeNode *tnode, BlockNode *);
   maple::BaseNode *ProcessNode(StmtExprKind, TreeNode *tnode, BlockNode *);
 
@@ -123,6 +141,7 @@ public:
                                               BlockNode *block);
 
   maple::BaseNode *ProcessLoopCondBody(StmtExprKind skind, TreeNode *cond, TreeNode *body, BlockNode *block);
+  maple::BaseNode *GetNewNodeLhs(NewNode *node, BlockNode *block);
 };
 
 }
diff --git a/src/MapleFE/autogen/src/expr_gen.cpp b/src/MapleFE/ast2mpl/include/cvt_block.h
similarity index 39%
rename from src/MapleFE/autogen/src/expr_gen.cpp
rename to src/MapleFE/ast2mpl/include/cvt_block.h
index 1a5af43a85bb0328fc87483e9a1d188989ac93c4..99ac1da878fed8b78a11a0465c6d7aec4a56bd33 100644
--- a/src/MapleFE/autogen/src/expr_gen.cpp
+++ b/src/MapleFE/ast2mpl/include/cvt_block.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -12,36 +12,30 @@
 * FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PSL v2 for more details.
 */
-#include "expr_gen.h"
 
-namespace maplefe {
-
-void ExprGen::Generate() {
-  GenRuleTables();
-  GenHeaderFile();
-  GenCppFile();
-}
+#ifndef __AST_CVT_BLOCK_H__
+#define __AST_CVT_BLOCK_H__
 
-void ExprGen::GenHeaderFile() {
-  mHeaderFile.WriteOneLine("#ifndef __EXPR_GEN_H__", 22);
-  mHeaderFile.WriteOneLine("#define __EXPR_GEN_H__", 22);
-  mHeaderFile.WriteOneLine("namespace maplefe {", 19);
+#include "ast_module.h"
+#include "ast.h"
+#include "gen_astvisitor.h"
 
-  // generate the rule tables
-  mHeaderFile.WriteFormattedBuffer(&mRuleTableHeader);
+namespace maplefe {
 
-  mHeaderFile.WriteOneLine("}", 1);
-  mHeaderFile.WriteOneLine("#endif", 6);
-}
+// CvtBlockVisitor is to fix up some tree nodes after the AST is created
+class CvtToBlockVisitor : public AstVisitor {
+  private:
+    ModuleNode *mASTModule;
+    bool       mUpdated;
 
-void ExprGen::GenCppFile() {
-  mCppFile.WriteOneLine("#include \"common_header_autogen.h\"", 34);
-  mCppFile.WriteOneLine("namespace maplefe {", 19);
+  public:
+    CvtToBlockVisitor(ModuleNode *m) : mASTModule(m), mUpdated(false) {}
 
-  // generate the rule tables
-  mCppFile.WriteFormattedBuffer(&mRuleTableCpp);
-  mCppFile.WriteOneLine("}", 1);
-}
-}
+    bool CvtToBlock();
 
+    CondBranchNode *VisitCondBranchNode(CondBranchNode *node);
+    ForLoopNode *VisitForLoopNode(ForLoopNode *node);
+};
 
+}
+#endif
diff --git a/src/MapleFE/ast2mpl/include/generic_attrs.h b/src/MapleFE/ast2mpl/include/generic_attrs.h
new file mode 100644
index 0000000000000000000000000000000000000000..ecab7c62d180bec7218941b55af3167d9d8eefcf
--- /dev/null
+++ b/src/MapleFE/ast2mpl/include/generic_attrs.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef GENERIC_ATTRS_H
+#define GENERIC_ATTRS_H
+#include <bitset>
+#include "mir_type.h"
+
+namespace maple {
+// only for internal use, not emitted
+enum GenericAttrKind {
+#define FUNC_ATTR
+#define TYPE_ATTR
+#define FIELD_ATTR
+#define ATTR(STR) GENATTR_##STR,
+#include "all_attributes.def"
+#undef ATTR
+#undef FUNC_ATTR
+#undef TYPE_ATTR
+#undef FIELD_ATTR
+};
+
+class GenericAttrs {
+ public:
+  GenericAttrs() = default;
+  GenericAttrs(const GenericAttrs &ta) = default;
+  GenericAttrs &operator=(const GenericAttrs &p) = default;
+  ~GenericAttrs() = default;
+
+  void SetAttr(GenericAttrKind x) {
+    attrFlag.set(x);
+  }
+
+  bool GetAttr(GenericAttrKind x) const {
+    return attrFlag[x];
+  }
+
+  bool operator==(const GenericAttrs &tA) const {
+    return attrFlag == tA.attrFlag;
+  }
+
+  bool operator!=(const GenericAttrs &tA) const {
+    return !(*this == tA);
+  }
+
+  FieldAttrs ConvertToFieldAttrs();
+  TypeAttrs ConvertToTypeAttrs();
+  FuncAttrs ConvertToFuncAttrs();
+
+ private:
+  std::bitset<128> attrFlag = 0;
+};
+}
+#endif // GENERIC_ATTRS_H
\ No newline at end of file
diff --git a/src/MapleFE/shared/include/maplefe_mir_builder.h b/src/MapleFE/ast2mpl/include/maplefe_mir_builder.h
similarity index 89%
rename from src/MapleFE/shared/include/maplefe_mir_builder.h
rename to src/MapleFE/ast2mpl/include/maplefe_mir_builder.h
index d4fa730156948804ba3add28fa1162b3ec61b3cf..52261130d603806cea5c925440facd161cf15718 100644
--- a/src/MapleFE/shared/include/maplefe_mir_builder.h
+++ b/src/MapleFE/ast2mpl/include/maplefe_mir_builder.h
@@ -77,6 +77,11 @@ class FEMIRBuilder : public maple::MIRBuilder {
 
   bool TraverseToNamedField(maple::MIRStructType *structType, unsigned &fieldID, FieldData *fieldData);
   maple::BaseNode *CreateExprDread(const maple::MIRSymbol *symbol, maple::FieldID fieldID = maple::FieldID(0));
+
+  // use maple::PTY_ref for pointer types
+  maple::MIRType *GetOrCreatePointerType(const maple::MIRType *pointTo) {
+    return maple::GlobalTables::GetTypeTable().GetOrCreatePointerType(*pointTo, maple::PTY_ref);
+  }
 };
 
 }
diff --git a/src/MapleFE/ast2mpl/src/Makefile b/src/MapleFE/ast2mpl/src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..51ab1dcd3e1b7c95dcda06ba6a8a02e8df10d433
--- /dev/null
+++ b/src/MapleFE/ast2mpl/src/Makefile
@@ -0,0 +1,88 @@
+# Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
+include ../../Makefile.in
+BUILDBIN=$(BUILDDIR)/bin
+BUILD=$(BUILDDIR)/ast2mpl
+BUILDGEN=$(BUILDDIR)/gen
+BUILDASTGEN=$(BUILDDIR)/ast_gen/shared
+$(shell $(MKDIR_P) $(BUILD))
+
+SRC=$(wildcard *.cpp)
+OBJ :=$(patsubst %.cpp,%.o,$(SRC))
+DEP :=$(patsubst %.cpp,%.d,$(SRC))
+
+SRCG := $(wildcard $(BUILDGEN)/gen*.cpp)
+OBJG := $(patsubst %.cpp, %.o, $(SRCG))
+DEPG := $(patsubst %.cpp, %.d, $(SRCG))
+
+OBJS :=$(foreach obj,$(OBJ), $(BUILD)/$(obj)) $(OBJG)
+DEPS :=$(foreach dep,$(DEP), $(BUILD)/$(dep)) $(DEPG)
+
+LIBOBJS :=$(patsubst $(BUILD)/main.o,,$(OBJS))
+
+GENDIR:=${BUILDDIR}/ast_gen/shared
+
+INCLUDES := -I $(MAPLEFE_ROOT)/shared/include \
+            -I $(MAPLEFE_ROOT)/astopt/include \
+            -I $(MAPLEFE_ROOT)/ast2mpl/include \
+            -I $(MAPLEFE_ROOT)/autogen/include \
+            -I $(MAPLEFE_ROOT)/shared/include \
+            -I $(MAPLEFE_ROOT)/java/include \
+            $(MAPLEALL_INC) -I ${GENDIR}
+
+AST2MPLLIB = ast2mpl.a
+
+INCLUDEGEN := -I $(MAPLEFE_ROOT)/shared/include -I $(BUILDDIR)/gen -I $(BUILDASTGEN)
+
+TARGET=ast2mpl
+SHAREDLIB = $(BUILDDIR)/astopt/astopt.a $(BUILDDIR)/shared/shared.a $(BUILDASTGEN)/genast.a
+LANGSPEC=$(BUILDDIR)/java/lang_spec.o
+
+.PHONY: all
+all: $(BUILDBIN)/$(TARGET)
+
+-include $(DEPS)
+.PHONY: clean
+
+vpath %.o $(BUILD)
+vpath %.d $(BUILD)
+
+#Pattern Rules
+$(BUILD)/%.o : %.cpp
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
+
+$(BUILD)/%.d : %.cpp
+	@$(CXX) $(CXXFLAGS) -MM $(INCLUDES) $< > $@
+	@mv -f $(BUILD)/$*.d $(BUILD)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
+	@rm -f $(BUILD)/$*.d.tmp
+
+$(BUILDGEN)/%.o : $(BUILDGEN)/%.cpp $(BUILDGEN)/%.d
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDEGEN) -w -c $< -o $@
+
+$(BUILDGEN)/%.d : $(BUILDGEN)/%.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDEGEN) $< > $@
+	@mv -f $(BUILDGEN)/$*.d $(BUILDGEN)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILDGEN)/$*.o:|' < $(BUILDGEN)/$*.d.tmp > $(BUILDGEN)/$*.d
+	@rm -f $(BUILDGEN)/$*.d.tmp
+
+# TARGET depends on OBJS and shared OBJS from shared directory
+# as well as mapleall libraries
+$(BUILDBIN)/$(TARGET): $(OBJS) $(SHAREDLIB)
+	@mkdir -p $(BUILDBIN)
+	$(LD) -o $(BUILDBIN)/$(TARGET) $(OBJS) $(LANGSPEC) $(SHAREDLIB) $(MAPLELIBS)
+
+clean:
+	rm -rf $(BUILD)
diff --git a/src/MapleFE/ast2mpl/src/ast2mpl.cpp b/src/MapleFE/ast2mpl/src/ast2mpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e6ac6c2b44641dfdd3b96313037b5dadfe55ecbb
--- /dev/null
+++ b/src/MapleFE/ast2mpl/src/ast2mpl.cpp
@@ -0,0 +1,129 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <queue>
+#include <sstream>
+#include <fstream>
+#include <iterator>
+
+#include "ast2mpl.h"
+#include "ast_handler.h"
+#include "gen_astdump.h"
+#include "gen_astgraph.h"
+#include "gen_aststore.h"
+#include "gen_astload.h"
+
+#include "mir_function.h"
+#include "ast2mpl_builder.h"
+
+namespace maplefe {
+
+// starting point of AST
+int A2M::ProcessAST() {
+  mIndexImported = GetModuleNum();
+
+  // loop through module handlers
+  for (HandlerIndex i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+
+    if (mFlags & FLG_trace_1) {
+      std::cout << "============= in ProcessAST ===========" << std::endl;
+      std::cout << "srcLang : " << module->GetSrcLangString() << std::endl;
+
+      for(unsigned k = 0; k < module->GetTreesNum(); k++) {
+        TreeNode *tnode = module->GetTree(k);
+        if (mFlags & FLG_trace_1) {
+          tnode->Dump(0);
+          std::cout << std::endl;
+        }
+      }
+    }
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= AstGraph ===========" << std::endl;
+      AstGraph graph(module);
+      graph.DumpGraph("After LoadFromAstBuf()", &std::cout);
+    }
+  }
+
+  // build dependency of modules
+  PreprocessModules();
+
+  // loop through module handlers in import/export dependency order
+  for (auto handler: mHandlersInOrder) {
+    ModuleNode *module = handler->GetASTModule();
+
+    // basic analysis
+    handler->BasicAnalysis();
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= After AdjustAST ===========" << std::endl;
+      for(unsigned k = 0; k < module->GetTreesNum(); k++) {
+        TreeNode *tnode = module->GetTree(k);
+        if (mFlags & FLG_trace_1) {
+          tnode->Dump(0);
+          std::cout << std::endl;
+        }
+      }
+      AstGraph graph(module);
+      graph.DumpGraph("After AdjustAST()", &std::cout);
+    }
+
+    // build CFG
+    handler->BuildCFG();
+
+    if (mFlags & FLG_trace_2) {
+      handler->Dump("After BuildCFG()");
+    }
+
+    // control flow analysis
+    handler->ControlFlowAnalysis();
+
+    // type inference
+    handler->TypeInference();
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= AstGraph ===========" << std::endl;
+      AstGraph graph(module);
+      graph.DumpGraph("After BuildCFG()", &std::cout);
+    }
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= AstDump ===========" << std::endl;
+      AstDump astdump(module);
+      astdump.Dump("After BuildCFG()", &std::cout);
+    }
+
+    // data flow analysis
+    handler->DataFlowAnalysis();
+
+    if (mFlags & FLG_trace_2) {
+      handler->Dump("After DataFlowAnalysis()");
+    }
+  }
+
+  // build mpl
+  if (mFlags & FLG_trace_2) {
+    std::cout << "============= Ast2Mpl Build ===========" << std::endl;
+  }
+  maplefe::Ast2MplBuilder ast2mpl_builder(mASTHandler, mFlags);
+  ast2mpl_builder.Build();
+
+  ast2mpl_builder.mMirModule->OutputAsciiMpl("", ".mpl");
+  return 0;
+}
+
+}
diff --git a/src/MapleFE/shared/src/ast2mpl.cpp b/src/MapleFE/ast2mpl/src/ast2mpl_builder.cpp
similarity index 50%
rename from src/MapleFE/shared/src/ast2mpl.cpp
rename to src/MapleFE/ast2mpl/src/ast2mpl_builder.cpp
index f980347848ae9f737588bf3a6dc768ea8ca57a01..2c8c3546f32498b5d14b0b4639585a97e747164d 100644
--- a/src/MapleFE/shared/src/ast2mpl.cpp
+++ b/src/MapleFE/ast2mpl/src/ast2mpl_builder.cpp
@@ -13,80 +13,127 @@
 * See the Mulan PSL v2 for more details.
 */
 
-#include "ast2mpl.h"
+#include "ast2mpl_builder.h"
+#include "gen_astdump.h"
+#include "mir_module.h"
 #include "mir_function.h"
 #include "maplefe_mir_builder.h"
+#include "cvt_block.h"
 
 namespace maplefe {
 
-static unsigned mVarUniqNum;
-
-A2M::A2M(const char *filename) : mFileName(filename) {
-  mMirModule = new maple::MIRModule(mFileName);
+Ast2MplBuilder::Ast2MplBuilder(AST_Handler *h, unsigned f) : mASTHandler(h), mFlags(f) {
+  mFilename = h->GetModuleHandler((unsigned)0)->GetASTModule()->GetFilename();
+  mMirModule = new maple::MIRModule(mFilename);
   maple::theMIRModule = mMirModule;
   mMirBuilder = new FEMIRBuilder(mMirModule);
   mFieldData = new FieldData();
-  mVarUniqNum = 1;
   Init();
 }
 
-A2M::~A2M() {
+Ast2MplBuilder::~Ast2MplBuilder() {
   delete mMirModule;
   delete mMirBuilder;
   delete mFieldData;
   mNodeTypeMap.clear();
 }
 
-void A2M::Init() {
+void Ast2MplBuilder::Init() {
   // create mDefaultType
   maple::MIRType *type = maple::GlobalTables::GetTypeTable().GetOrCreateClassType("DEFAULT_TYPE", *mMirModule);
   type->SetMIRTypeKind(maple::kTypeClass);
-  mDefaultType = maple::GlobalTables::GetTypeTable().GetOrCreatePointerType(*type);
+  mDefaultType = mMirBuilder->GetOrCreatePointerType(type);
 
   // setup flavor and srclang
   mMirModule->SetFlavor(maple::kFeProduced);
   mMirModule->SetSrcLang(maple::kSrcLangJava);
 
   // setup INFO_filename
-  maple::GStrIdx idx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(mFileName);
+  maple::GStrIdx idx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(mFilename);
   SET_INFO_PAIR(mMirModule, "INFO_filename", idx.GetIdx(), true);
 
-  // add to java src file list
-  std::string str(mFileName);
+  // add to src file list
+  std::string str(mFilename);
   size_t pos = str.rfind('/');
   if (pos != std::string::npos) {
     idx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str.substr(pos+1));
   }
   mMirModule->PushbackFileInfo(maple::MIRInfoPair(idx, 2));
+
+  // initialize unique serial number for temporary variables and inner classes
+  mUniqNum = 1;
 }
 
 // starting point of AST to MPL process
-void A2M::ProcessAST(bool trace_a2m) {
-  mTraceA2m = trace_a2m;
-  if (mTraceA2m) std::cout << "============= in ProcessAST ===========" << std::endl;
-  // pass 1: collect class/interface/function decl
-  for(auto it: gModule.mTrees) {
-    TreeNode *tnode = it->mRootNode;
-    ProcessNodeDecl(SK_Stmt, tnode, nullptr);
+void Ast2MplBuilder::Build() {
+  mTraceA2m = mFlags & FLG_trace_2;
+  for (HandlerIndex i = 0; i < mASTHandler->GetSize(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+
+    AstDump astdump(module);
+
+    if (mTraceA2m) {
+      std::cout << "============= in ProcessAST ===========" << std::endl;
+      std::cout << "srcLang : " << module->GetSrcLangString() << std::endl;
+    }
+    // pass 0: convert to use BlockNode for if-then-else and loop bodies
+    CvtToBlockVisitor visitor(module);
+    visitor.CvtToBlock();
+
+    // pass 1: collect class/interface/function decl
+    for (unsigned i = 0; i < module->GetTreesNum(); i++) {
+      TreeNode *tnode = module->GetTree(i);
+      ProcessNodeDecl(SK_Stmt, tnode, nullptr);
+    }
+
+    // pass 2: handle function def
+    for (unsigned i = 0; i < module->GetTreesNum(); i++) {
+      TreeNode *tnode = module->GetTree(i);
+      ProcessNode(SK_Stmt, tnode, nullptr);
+    }
+    if (mTraceA2m) { astdump.Dump("Build", &std::cout); }
   }
-  // pass 2: handle function def
-  for(auto it: gModule.mTrees) {
-    TreeNode *tnode = it->mRootNode;
-    if (mTraceA2m) { tnode->Dump(0); fflush(0); }
-    ProcessNode(SK_Stmt, tnode, nullptr);
+}
+
+maple::PrimType Ast2MplBuilder::MapPrim(TypeId id) {
+  maple::PrimType prim;
+  switch (id) {
+    case TY_Boolean: prim = maple::PTY_u1; break;
+    case TY_Byte:    prim = maple::PTY_u8; break;
+    case TY_Short:   prim = maple::PTY_i16; break;
+    case TY_Int:     prim = maple::PTY_i32; break;
+    case TY_Long:    prim = maple::PTY_i64; break;
+    case TY_Char:    prim = maple::PTY_u16; break;
+    case TY_Float:   prim = maple::PTY_f32; break;
+    case TY_Double:  prim = maple::PTY_f64; break;
+    case TY_Void:    prim = maple::PTY_void; break;
+    case TY_Null:    prim = maple::PTY_void; break;
+    default: MASSERT("Unsupported PrimType"); break;
   }
+  return prim;
+}
+
+maple::MIRType *Ast2MplBuilder::MapPrimType(TypeId id) {
+  maple::PrimType prim = MapPrim(id);
+  maple::TyIdx tid(prim);
+  return maple::GlobalTables::GetTypeTable().GetTypeFromTyIdx(tid);
+}
+
+maple::MIRType *Ast2MplBuilder::MapPrimType(PrimTypeNode *ptnode) {
+  return MapPrimType(ptnode->GetPrimType());
 }
 
-maple::MIRType *A2M::MapType(TreeNode *type) {
+maple::MIRType *Ast2MplBuilder::MapType(TreeNode *type) {
   if (!type) {
     return maple::GlobalTables::GetTypeTable().GetVoid();
   }
 
   maple::MIRType *mir_type = mDefaultType;
 
-  const char *name = type->GetName();
-  if (mNodeTypeMap.find(name) != mNodeTypeMap.end()) {
-    return mNodeTypeMap[name];
+  unsigned idx = type->GetStrIdx();
+  if (mNodeTypeMap.find(idx) != mNodeTypeMap.end()) {
+    return mNodeTypeMap[idx];
   }
 
   if (type->IsPrimType()) {
@@ -94,7 +141,7 @@ maple::MIRType *A2M::MapType(TreeNode *type) {
     mir_type = MapPrimType(ptnode);
 
     // update mNodeTypeMap
-    mNodeTypeMap[name] = mir_type;
+    mNodeTypeMap[idx] = mir_type;
   } else  if (type->IsUserType()) {
     if (type->IsIdentifier()) {
       IdentifierNode *inode = static_cast<IdentifierNode *>(type);
@@ -106,14 +153,20 @@ maple::MIRType *A2M::MapType(TreeNode *type) {
     }
     // DimensionNode *mDims
     // unsigned dnum = inode->GetDimsNum();
-    mNodeTypeMap[name] = mir_type;
+    mNodeTypeMap[idx] = mir_type;
+  } else if (idx) {
+    AST2MPLMSG("MapType add a class type by idx", idx);
+    mir_type = maple::GlobalTables::GetTypeTable().GetOrCreateClassType(type->GetName(), *mMirModule);
+    mir_type->SetMIRTypeKind(maple::kTypeClass);
+    mir_type = mMirBuilder->GetOrCreatePointerType(mir_type);
+    mNodeTypeMap[idx] = mir_type;
   } else {
-    NOTYETIMPL("MapType Unknown");
+    NOTYETIMPL("MapType unknown type");
   }
   return mir_type;
 }
 
-maple::Opcode A2M::MapUnaOpcode(OprId ast_op) {
+maple::Opcode Ast2MplBuilder::MapUnaOpcode(OprId ast_op) {
   maple::Opcode op = maple::OP_undef;
   switch (ast_op) {
     case OPR_Add: op = maple::OP_add; break;
@@ -127,7 +180,7 @@ maple::Opcode A2M::MapUnaOpcode(OprId ast_op) {
   return op;
 }
 
-maple::Opcode A2M::MapBinOpcode(OprId ast_op) {
+maple::Opcode Ast2MplBuilder::MapBinOpcode(OprId ast_op) {
   maple::Opcode op = maple::OP_undef;
   switch (ast_op) {
     case OPR_Add: op = maple::OP_add; break;
@@ -148,7 +201,7 @@ maple::Opcode A2M::MapBinOpcode(OprId ast_op) {
   return op;
 }
 
-maple::Opcode A2M::MapBinCmpOpcode(OprId ast_op) {
+maple::Opcode Ast2MplBuilder::MapBinCmpOpcode(OprId ast_op) {
   maple::Opcode op = maple::OP_undef;
   switch (ast_op) {
     case OPR_EQ: op = maple::OP_eq; break;
@@ -162,7 +215,7 @@ maple::Opcode A2M::MapBinCmpOpcode(OprId ast_op) {
   return op;
 }
 
-maple::Opcode A2M::MapBinComboOpcode(OprId ast_op) {
+maple::Opcode Ast2MplBuilder::MapBinComboOpcode(OprId ast_op) {
   maple::Opcode op = maple::OP_undef;
   switch (ast_op) {
     case OPR_AddAssign: op = maple::OP_add; break;
@@ -182,7 +235,25 @@ maple::Opcode A2M::MapBinComboOpcode(OprId ast_op) {
   return op;
 }
 
-const char *A2M::Type2Label(const maple::MIRType *type) {
+#if 1
+const char *Ast2MplBuilder::Type2Label(const maple::MIRType *type) {
+  maple::PrimType pty = type->GetPrimType();
+  switch (pty) {
+    case maple::PTY_u1:   return "Z";
+    case maple::PTY_u8:   return "B";
+    case maple::PTY_i16:  return "S";
+    case maple::PTY_u16:  return "C";
+    case maple::PTY_i32:  return "I";
+    case maple::PTY_i64:  return "J";
+    case maple::PTY_f32:  return "F";
+    case maple::PTY_f64:  return "D";
+    case maple::PTY_void: return "V";
+    default:       return "L";
+  }
+}
+#else
+
+const char *Ast2MplBuilder::Type2Label(const maple::MIRType *type) {
   maple::PrimType pty = type->GetPrimType();
   switch (pty) {
     case maple::PTY_u1:   return "Z";
@@ -200,16 +271,13 @@ const char *A2M::Type2Label(const maple::MIRType *type) {
     default:       return "L";
   }
 }
+#endif
 
-bool A2M::IsStmt(TreeNode *tnode) {
+bool Ast2MplBuilder::IsStmt(TreeNode *tnode) {
   bool status = true;
   if (!tnode) return false;
 
   switch (tnode->GetKind()) {
-    case NK_Literal:
-    case NK_Identifier:
-      status = false;
-      break;
     case NK_Parenthesis: {
       ParenthesisNode *node = static_cast<ParenthesisNode *>(tnode);
       status = IsStmt(node->GetExpr());
@@ -221,16 +289,57 @@ bool A2M::IsStmt(TreeNode *tnode) {
       if (ast_op != OPR_Inc && ast_op != OPR_Dec) {
         status = false;
       }
+      break;
     }
     case NK_BinOperator: {
       BinOperatorNode *bon = static_cast<BinOperatorNode *>(tnode);
-      maple::Opcode op = MapBinComboOpcode(bon->mOprId);
-      if (bon->mOprId != OPR_Assign && op == maple::OP_undef) {
+      maple::Opcode op = MapBinComboOpcode(bon->GetOprId());
+      if (bon->GetOprId() != OPR_Assign && op == maple::OP_undef) {
         status = false;
       }
       break;
     }
+    case NK_Block:
+    case NK_Break:
+    case NK_Call:
+    case NK_CondBranch:
+    case NK_Delete:
+    case NK_DoLoop:
+    case NK_ExprList:
+    case NK_ForLoop:
+    case NK_Function:
+    case NK_Interface:
+    case NK_Lambda:
+    case NK_New:
+    case NK_Return:
+    case NK_Switch:
+    case NK_SwitchCase:
+    case NK_VarList:
+    case NK_WhileLoop:
+      status = true;
+      break;
+    case NK_Annotation:
+    case NK_AnnotationType:
+    case NK_Assert:
+    case NK_Attr:
+    case NK_Cast:
+    case NK_Class:
+    case NK_Dimension:
+    case NK_Exception:
+    case NK_Field:
+    case NK_Identifier:
+    case NK_Import:
+    case NK_InstanceOf:
+    case NK_Literal:
+    case NK_Package:
+    case NK_Pass:
+    case NK_PrimArrayType:
+    case NK_PrimType:
+    case NK_SwitchLabel:
+    case NK_TerOperator:
+    case NK_UserType:
     default:
+      status = false;
       break;
   }
   return status;
@@ -251,7 +360,7 @@ bool A2M::IsStmt(TreeNode *tnode) {
 #define RARG     "_29" // ")"
 #endif
 
-void A2M::Type2Name(std::string &str, const maple::MIRType *type) {
+void Ast2MplBuilder::Type2Name(std::string &str, const maple::MIRType *type) {
   maple::PrimType pty = type->GetPrimType();
   const char *n = Type2Label(type);
   str.append(n);
@@ -265,16 +374,15 @@ void A2M::Type2Name(std::string &str, const maple::MIRType *type) {
   }
 }
 
-// update to use uniq name: str --> str|mVarUniqNum
-void A2M::UpdateUniqName(std::string &str) {
+// update to use uniq name: str --> str|mUniqNum
+void Ast2MplBuilder::UpdateUniqName(std::string &str) {
   str.append(SEP);
-  str.append(std::to_string(mVarUniqNum));
-  mVarUniqNum++;
+  str.append(std::to_string(mUniqNum++));
   return;
 }
 
 // update to use mangled name: className|funcName|(argTypes)retType
-void A2M::UpdateFuncName(maple::MIRFunction *func) {
+void Ast2MplBuilder::UpdateFuncName(maple::MIRFunction *func) {
   std::string str;
   maple::TyIdx tyIdx = func->GetClassTyIdx();
   maple::MIRType *type;
@@ -308,21 +416,29 @@ void A2M::UpdateFuncName(maple::MIRFunction *func) {
   maple::GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcst);
 }
 
-BlockNode *A2M::GetSuperBlock(BlockNode *block) {
-  TreeNode *blk = block->GetParent();
-  while (blk && !blk->IsBlock()) {
-    blk = blk->GetParent();
+ClassNode *Ast2MplBuilder::GetSuperClass(ClassNode *klass) {
+  TreeNode *tnode = klass->GetParent();
+  while (tnode && !tnode->IsClass()) {
+    tnode = tnode->GetParent();
   }
-  return (BlockNode*)blk;
+  return static_cast<ClassNode *>(tnode);
 }
 
-maple::MIRSymbol *A2M::GetSymbol(TreeNode *tnode, BlockNode *block) {
-  const char *name = tnode->GetName();
+BlockNode *Ast2MplBuilder::GetSuperBlock(BlockNode *block) {
+  TreeNode *tnode = block->GetParent();
+  while (tnode && !tnode->IsBlock()) {
+    tnode = tnode->GetParent();
+  }
+  return static_cast<BlockNode *>(tnode);
+}
+
+maple::MIRSymbol *Ast2MplBuilder::GetSymbol(TreeNode *tnode, BlockNode *block) {
+  unsigned idx = tnode->GetStrIdx();
   maple::MIRSymbol *symbol = nullptr;
 
   // global symbol
   if (!block) {
-    std::pair<const char *, BlockNode*> P(tnode->GetName(), block);
+    std::pair<unsigned, BlockNode*> P(idx, block);
     symbol = mNameBlockVarMap[P];
     return symbol;
   }
@@ -330,7 +446,7 @@ maple::MIRSymbol *A2M::GetSymbol(TreeNode *tnode, BlockNode *block) {
   // trace block hirachy for defined symbol
   BlockNode *blk = block;
   do {
-    std::pair<const char *, BlockNode*> P(tnode->GetName(), blk);
+    std::pair<unsigned, BlockNode*> P(idx, blk);
     symbol = mNameBlockVarMap[P];
     if (symbol) {
       return symbol;
@@ -339,12 +455,12 @@ maple::MIRSymbol *A2M::GetSymbol(TreeNode *tnode, BlockNode *block) {
   } while (blk);
 
   // check parameters
-  maple::MIRFunction *func = GetFunc(blk);
+  maple::MIRFunction *func = GetCurrFunc(blk);
   if (!func) {
     NOTYETIMPL("Block parent hirachy");
     return symbol;
   }
-  maple::GStrIdx stridx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  maple::GStrIdx stridx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(tnode->GetName());
   if (func->IsAFormalName(stridx)) {
     maple::FormalDef def = func->GetFormalFromName(stridx);
     return def.formalSym;
@@ -352,21 +468,20 @@ maple::MIRSymbol *A2M::GetSymbol(TreeNode *tnode, BlockNode *block) {
   return symbol;
 }
 
-maple::MIRSymbol *A2M::CreateTempVar(const char *prefix, maple::MIRType *type) {
+maple::MIRSymbol *Ast2MplBuilder::CreateTempVar(const char *prefix, maple::MIRType *type) {
   if (!type) {
     return nullptr;
   }
   std::string str(prefix);
   str.append(SEP);
-  str.append(std::to_string(mVarUniqNum));
-  mVarUniqNum++;
+  str.append(std::to_string(mUniqNum++));
   maple::MIRFunction *func = mMirModule->CurFunction();
   maple::MIRSymbol *var = mMirBuilder->CreateLocalDecl(str, *type);
   return var;
 }
 
-maple::MIRSymbol *A2M::CreateSymbol(TreeNode *tnode, BlockNode *block) {
-  const char *name = tnode->GetName();
+maple::MIRSymbol *Ast2MplBuilder::CreateSymbol(TreeNode *tnode, BlockNode *block) {
+  std::string name = tnode->GetName();
   maple::MIRType *mir_type;
 
   if (tnode->IsIdentifier()) {
@@ -381,12 +496,12 @@ maple::MIRSymbol *A2M::CreateSymbol(TreeNode *tnode, BlockNode *block) {
   maple::MIRTypeKind kind = mir_type->GetKind();
   if (kind == maple::kTypeClass || kind == maple::kTypeClassIncomplete ||
       kind == maple::kTypeInterface || kind == maple::kTypeInterfaceIncomplete) {
-    mir_type = maple::GlobalTables::GetTypeTable().GetOrCreatePointerType(*mir_type, maple::PTY_ref);
+    mir_type = mMirBuilder->GetOrCreatePointerType(mir_type);
   }
 
   maple::MIRSymbol *symbol = nullptr;
   if (block) {
-    maple::MIRFunction *func = GetFunc(block);
+    maple::MIRFunction *func = GetCurrFunc(block);
     symbol = mMirBuilder->GetLocalDecl(name);
     std::string str(name);
     // symbol with same name already exist, use a uniq new name
@@ -404,54 +519,197 @@ maple::MIRSymbol *A2M::CreateSymbol(TreeNode *tnode, BlockNode *block) {
     symbol = mMirBuilder->CreateGlobalDecl(str, *mir_type, maple::kScGlobal);
   }
 
-  std::pair<const char *, BlockNode*> P(name, block);
+  std::pair<unsigned, BlockNode*> P(tnode->GetStrIdx(), block);
   mNameBlockVarMap[P] = symbol;
 
   return symbol;
 }
 
-maple::MIRFunction *A2M::GetFunc(BlockNode *block) {
+maple::MIRFunction *Ast2MplBuilder::GetCurrFunc(BlockNode *block) {
   maple::MIRFunction *func = nullptr;
   // func = mBlockFuncMap[block];
   func = mMirModule->CurFunction();
   return func;
 }
 
-maple::MIRClassType *A2M::GetClass(BlockNode *block) {
-  maple::TyIdx tyidx = GetFunc(block)->GetClassTyIdx();
+maple::MIRClassType *Ast2MplBuilder::GetClass(BlockNode *block) {
+  maple::TyIdx tyidx = GetCurrFunc(block)->GetClassTyIdx();
   return (maple::MIRClassType*)maple::GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx);
 }
 
-maple::MIRFunction *A2M::SearchFunc(const char *name, const maple::MapleVector<maple::BaseNode *> &args) {
-  if (mNameFuncMap.find(name) == mNameFuncMap.end()) {
+bool3 Ast2MplBuilder::IsCompatibleTo(maple::PrimType expected, maple::PrimType prim) {
+  if (expected == prim)
+    return true3;
+
+  maple::PrimitiveType type(prim);
+  bool3 comp = false3;
+  switch (expected) {
+    case maple::PTY_i8:
+    case maple::PTY_i16:
+    case maple::PTY_i32:
+    case maple::PTY_i64:
+    case maple::PTY_u8:
+    case maple::PTY_u16:
+    case maple::PTY_u32:
+    case maple::PTY_u64:
+    case maple::PTY_u1:
+      if (type.IsInteger()) {
+        comp = true3;
+      }
+      break;
+    case maple::PTY_ptr:
+    case maple::PTY_ref:
+      if (type.IsPointer()) {
+        comp = true3;
+      }
+      if (type.IsInteger()) {
+        comp = maybe3;
+      }
+      break;
+    case maple::PTY_a32:
+    case maple::PTY_a64:
+      if (type.IsAddress()) {
+        comp = true3;
+      }
+      break;
+    case maple::PTY_f32:
+    case maple::PTY_f64:
+    case maple::PTY_f128:
+      if (type.IsFloat()) {
+        comp = true3;
+      }
+      break;
+    case maple::PTY_c64:
+    case maple::PTY_c128:
+      if (type.IsInteger()) {
+        comp = true3;
+      }
+      break;
+    case maple::PTY_constStr:
+    case maple::PTY_gen:
+    case maple::PTY_agg:
+    case maple::PTY_unknown:
+    case maple::PTY_v2i64:
+    case maple::PTY_v4i32:
+    case maple::PTY_v8i16:
+    case maple::PTY_v16i8:
+    case maple::PTY_v2f64:
+    case maple::PTY_v4f32:
+    case maple::PTY_void:
+    default:
+      break;
+  }
+  return comp;
+}
+
+maple::MIRFunction *Ast2MplBuilder::SearchFunc(unsigned idx, maple::MapleVector<maple::BaseNode *> &args) {
+  if (mNameFuncMap.find(idx) == mNameFuncMap.end()) {
     return nullptr;
   }
-  for (auto it: mNameFuncMap[name]) {
+  std::vector<maple::MIRFunction *> candidates;
+  for (auto it: mNameFuncMap[idx]) {
     if (it->GetFormalCount() != args.size()) {
       continue;
     }
     bool matched = true;
+    bool3 mightmatched = true3;
     for (int i = 0; i < it->GetFormalCount(); i++) {
-      // TODO: allow compatible types
       maple::MIRType *type = maple::GlobalTables::GetTypeTable().GetTypeFromTyIdx(it->GetFormalDefAt(i).formalTyIdx);
-      if (type->GetPrimType() != args[i]->GetPrimType()) {
+      bool3 comp = IsCompatibleTo(type->GetPrimType(), args[i]->GetPrimType());
+      if (comp == false3) {
         matched = false;
+        mightmatched = false3;
         break;
+      } else if (comp == maybe3) {
+        matched = false;
       }
     }
-    if (!matched) {
-      continue;
+    if (matched) {
+      return it;
     }
-    return it;
+    if (mightmatched != false3) {
+      candidates.push_back(it);
+    }
+  }
+  if (candidates.size()) {
+    return candidates[0];
   }
   return nullptr;
 }
 
-void A2M::MapAttr(maple::GenericAttrs &attr, const IdentifierNode *inode) {
+maple::MIRFunction *Ast2MplBuilder::SearchFunc(TreeNode *method, maple::MapleVector<maple::BaseNode *> &args, BlockNode *block) {
+  maple::MIRFunction *func = nullptr;
+  switch (method->GetKind()) {
+    case NK_Function: {
+      func = SearchFunc(method->GetStrIdx(), args);
+      break;
+    }
+    case NK_Identifier: {
+      IdentifierNode *imethod = static_cast<IdentifierNode *>(method);
+      func = SearchFunc(imethod->GetStrIdx(), args);
+      break;
+    }
+    case NK_Field: {
+      FieldNode *node = static_cast<FieldNode *>(method);
+      TreeNode *upper = node->GetUpper();
+      TreeNode *field = node->GetField();
+      if (field->IsIdentifier()) {
+        // pass upper as this
+        maple::BaseNode *bn = ProcessNode(SK_Expr, upper, block);
+        if (bn) {
+          args[0] = bn;
+        }
+      }
+      func = SearchFunc(field, args, block);
+      break;
+    }
+    default:
+      NOTYETIMPL("GetFuncName() method to be handled");
+  }
+
+  return func;
+}
+
+void Ast2MplBuilder::MapAttr(maple::GenericAttrs &attr, AttrId id) {
+  switch (id) {
+#undef ATTRIBUTE
+#define ATTRIBUTE(X) case ATTR_##X: attr.SetAttr(maple::GENATTR_##X); break;
+// #include "supported_attributes.def"
+ATTRIBUTE(abstract)
+ATTRIBUTE(const)
+ATTRIBUTE(volatile)
+ATTRIBUTE(final)
+ATTRIBUTE(native)
+ATTRIBUTE(private)
+ATTRIBUTE(protected)
+ATTRIBUTE(public)
+ATTRIBUTE(static)
+ATTRIBUTE(default)
+ATTRIBUTE(synchronized)
+
+// ATTRIBUTE(strictfp)
+    case ATTR_strictfp: attr.SetAttr(maple::GENATTR_strict); break;
+
+    default:
+      break;
+  }
+}
+
+void Ast2MplBuilder::MapAttr(maple::GenericAttrs &attr, IdentifierNode *inode) {
   // SmallVector<AttrId> mAttrs
   unsigned anum = inode->GetAttrsNum();
   for (int i = 0; i < anum; i++) {
+    const AttrId ast_attr = inode->GetAttrAtIndex(i);
+    MapAttr(attr, ast_attr);
   }
 }
+
+void Ast2MplBuilder::MapAttr(maple::GenericAttrs &attr, FunctionNode *fnode) {
+  unsigned anum = fnode->GetAttrsNum();
+  for (int i = 0; i < anum; i++) {
+    const AttrId ast_attr = fnode->GetAttrAtIndex(i);
+    MapAttr(attr, ast_attr);
+  }
 }
 
+}
diff --git a/src/MapleFE/ast2mpl/src/cvt_block.cpp b/src/MapleFE/ast2mpl/src/cvt_block.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..419d1c54bd72c4aa5d0db2ac80bb82b0b40f713a
--- /dev/null
+++ b/src/MapleFE/ast2mpl/src/cvt_block.cpp
@@ -0,0 +1,62 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include "cvt_block.h"
+
+namespace maplefe {
+
+bool CvtToBlockVisitor::CvtToBlock() {
+  for (unsigned i = 0; i < mASTModule->GetTreesNum(); i++ ) {
+    TreeNode *it = mASTModule->GetTree(i);
+    Visit(it);
+  }
+  return mUpdated;
+}
+
+// if-then-else
+CondBranchNode *CvtToBlockVisitor::VisitCondBranchNode(CondBranchNode *node) {
+  TreeNode *tn = VisitTreeNode(node->GetTrueBranch());
+  if (tn && !tn->IsBlock()) {
+    BlockNode *blk = (BlockNode*)gTreePool.NewTreeNode(sizeof(BlockNode));
+    new (blk) BlockNode();
+    blk->AddChild(tn);
+    node->SetTrueBranch(blk);
+    mUpdated = true;
+  }
+  tn = VisitTreeNode(node->GetFalseBranch());
+  if (tn && !tn->IsBlock()) {
+    BlockNode *blk = (BlockNode*)gTreePool.NewTreeNode(sizeof(BlockNode));
+    new (blk) BlockNode();
+    blk->AddChild(tn);
+    node->SetFalseBranch(blk);
+    mUpdated = true;
+  }
+  return node;
+}
+
+// for
+ForLoopNode *CvtToBlockVisitor::VisitForLoopNode(ForLoopNode *node) {
+  TreeNode *tn = VisitTreeNode(node->GetBody());
+  if (tn && !tn->IsBlock()) {
+    BlockNode *blk = (BlockNode*)gTreePool.NewTreeNode(sizeof(BlockNode));
+    new (blk) BlockNode();
+    blk->AddChild(tn);
+    node->SetBody(blk);
+    mUpdated = true;
+  }
+  return node;
+}
+
+}
diff --git a/src/MapleFE/ast2mpl/src/generic_attrs.cpp b/src/MapleFE/ast2mpl/src/generic_attrs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..185d327387249f9ceea60c5fd288970ac463c739
--- /dev/null
+++ b/src/MapleFE/ast2mpl/src/generic_attrs.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "generic_attrs.h"
+
+namespace maple {
+TypeAttrs GenericAttrs::ConvertToTypeAttrs() {
+  TypeAttrs attr;
+  constexpr uint32 maxAttrNum = 128;
+  for (uint32 i = 0; i < maxAttrNum; ++i) {
+    if (attrFlag[i] == 0) {
+      continue;
+    }
+    auto tA = static_cast<GenericAttrKind>(i);
+    switch (tA) {
+#define TYPE_ATTR
+#define ATTR(STR)               \
+    case GENATTR_##STR:         \
+      attr.SetAttr(ATTR_##STR); \
+      break;
+#include "all_attributes.def"
+#undef ATTR
+#undef TYPE_ATTR
+      default:
+        ASSERT(false, "unknown TypeAttrs");
+        break;
+    }
+  }
+  return attr;
+}
+
+FuncAttrs GenericAttrs::ConvertToFuncAttrs() {
+  FuncAttrs attr;
+  constexpr uint32 maxAttrNum = 128;
+  for (uint32 i = 0; i < maxAttrNum; ++i) {
+    if (attrFlag[i] == 0) {
+      continue;
+    }
+    auto tA = static_cast<GenericAttrKind>(i);
+    switch (tA) {
+#define FUNC_ATTR
+#define ATTR(STR)                   \
+    case GENATTR_##STR:             \
+      attr.SetAttr(FUNCATTR_##STR); \
+      break;
+#include "all_attributes.def"
+#undef ATTR
+#undef FUNC_ATTR
+      default:
+        ASSERT(false, "unknown FuncAttrs");
+        break;
+    }
+  }
+  return attr;
+}
+
+FieldAttrs GenericAttrs::ConvertToFieldAttrs() {
+  FieldAttrs attr;
+  constexpr uint32 maxAttrNum = 128;
+  for (uint32 i = 0; i < maxAttrNum; ++i) {
+    if (attrFlag[i] == 0) {
+      continue;
+    }
+    auto tA = static_cast<GenericAttrKind>(i);
+    switch (tA) {
+#define FIELD_ATTR
+#define ATTR(STR)                  \
+    case GENATTR_##STR:            \
+      attr.SetAttr(FLDATTR_##STR); \
+      break;
+#include "all_attributes.def"
+#undef ATTR
+#undef FIELD_ATTR
+      default:
+        ASSERT(false, "unknown FieldAttrs");
+        break;
+    }
+  }
+  return attr;
+}
+}
\ No newline at end of file
diff --git a/src/MapleFE/ast2mpl/src/main.cpp b/src/MapleFE/ast2mpl/src/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0f89a9114ac926688e5a8b2f6e0d4ff6c9176d8
--- /dev/null
+++ b/src/MapleFE/ast2mpl/src/main.cpp
@@ -0,0 +1,96 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <sstream>
+#include <fstream>
+#include <iterator>
+#include "gen_astload.h"
+#include "ast_handler.h"
+#include "ast2mpl.h"
+
+static void help() {
+  std::cout << "ast2cpp a.ast[,b.ast] [options]:" << std::endl;
+  std::cout << "   --out=x.cpp      : cpp output file" << std::endl;
+  std::cout << "   --help           : print this help" << std::endl;
+  std::cout << "   --trace=n        : Emit trace with 4-bit combo levels 1...15" << std::endl;
+  std::cout << "           1        : Emit ast tree visits" << std::endl;
+  std::cout << "           2        : Emit graph" << std::endl;
+  std::cout << "   --emit-ts-only   : Emit ts code only" << std::endl;
+  std::cout << "   --emit-ts        : Emit ts code" << std::endl;
+  std::cout << "   --format-cpp     : Format cpp" << std::endl;
+  std::cout << "   --no-imported    : Do not process the imported modules" << std::endl;
+  std::cout << "default out name uses the first input name: a.cpp" << std::endl;
+}
+
+int main (int argc, char *argv[]) {
+  if (argc == 1 || (!strncmp(argv[1], "--help", 6) && (strlen(argv[1]) == 6))) {
+    help();
+    exit(-1);
+  }
+
+  unsigned flags;
+  // one or more input .ast files separated by ','
+  const char *inputname = argv[1];
+
+  // Parse the argument
+  for (unsigned i = 2; i < argc; i++) {
+    if (!strncmp(argv[i], "--trace=", 8)) {
+      int val = atoi(argv[i] + 8);
+      if (val < 1 || val > 15) {
+        help();
+        exit(-1);
+      }
+      flags |= val;
+    } else {
+      std::cerr << "unknown option " << argv[i] << std::endl;
+      exit(-1);
+    }
+  }
+
+  // input ast files
+  std::vector<std::string> inputfiles;
+  if (inputname) {
+    std::stringstream ss;
+    ss.str(inputname);
+    std::string item;
+    while (std::getline(ss, item, ',')) {
+      // std::cout << "item " << item << " xxx"<< std::endl;
+      inputfiles.push_back(item);
+    }
+  }
+
+  unsigned trace = (flags & maplefe::FLG_trace);
+  maplefe::AST_Handler handler(trace);
+  for (auto astfile: inputfiles) {
+    std::ifstream input(astfile, std::ifstream::binary);
+    input >> std::noskipws;
+    std::istream_iterator<uint8_t> s(input), e;
+    maplefe::AstBuffer vec(s, e);
+    maplefe::AstLoad loadAst;
+    maplefe::ModuleNode *mod = loadAst.LoadFromAstBuf(vec);
+    // add mod to the vector
+    while(mod) {
+      handler.AddModule(mod);
+      mod = loadAst.Next();
+    }
+  }
+
+  maplefe::A2M *a2m = new maplefe::A2M(&handler, flags);
+  int res = a2m->ProcessAST();
+
+  delete a2m;
+
+  return 0;
+}
diff --git a/src/MapleFE/shared/src/maplefe_mir_builder.cpp b/src/MapleFE/ast2mpl/src/maplefe_mir_builder.cpp
similarity index 94%
rename from src/MapleFE/shared/src/maplefe_mir_builder.cpp
rename to src/MapleFE/ast2mpl/src/maplefe_mir_builder.cpp
index adae368a639ea461a274e7ba7d5df2e55b5fcbc3..680635f744443258f5713f5ebaab85fe54fc1278 100644
--- a/src/MapleFE/shared/src/maplefe_mir_builder.cpp
+++ b/src/MapleFE/ast2mpl/src/maplefe_mir_builder.cpp
@@ -59,7 +59,8 @@ bool FEMIRBuilder::TraverseToNamedField(maple::MIRStructType *structType, unsign
 }
 
 maple::BaseNode *FEMIRBuilder::CreateExprDread(const maple::MIRSymbol *symbol, maple::FieldID fieldID) {
-  maple::BaseNode *nd = new maple::AddrofNode(maple::OP_dread, maple::kPtyInvalid, symbol->GetStIdx(), fieldID);
+  maple::PrimType prim = symbol->GetType()->GetPrimType();
+  maple::BaseNode *nd = new maple::AddrofNode(maple::OP_dread, prim, symbol->GetStIdx(), fieldID);
   return nd;
 }
 
diff --git a/src/MapleFE/shared/src/mpl_processor.cpp b/src/MapleFE/ast2mpl/src/mpl_processor.cpp
similarity index 50%
rename from src/MapleFE/shared/src/mpl_processor.cpp
rename to src/MapleFE/ast2mpl/src/mpl_processor.cpp
index 62e2e29d0f242febba626ffefd240c4fceb98544..378c18860ff09647cbe0d32e5dd21e526a94b0f3 100644
--- a/src/MapleFE/shared/src/mpl_processor.cpp
+++ b/src/MapleFE/ast2mpl/src/mpl_processor.cpp
@@ -13,11 +13,12 @@
 * See the Mulan PSL v2 for more details.
 */
 
-#include "ast2mpl.h"
+#include "ast2mpl_builder.h"
+#include "stringpool.h"
 
 namespace maplefe {
 
-maple::BaseNode *A2M::ProcessNodeDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessNodeDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   if (!tnode) {
     return nullptr;
   }
@@ -25,19 +26,19 @@ maple::BaseNode *A2M::ProcessNodeDecl(StmtExprKind skind, TreeNode *tnode, Block
   maple::BaseNode *mpl_node = nullptr;
   switch (tnode->GetKind()) {
     case NK_Class: {
-      mpl_node =ProcessClassDecl(SK_Stmt, tnode, nullptr);
+      mpl_node =ProcessClassDecl(SK_Stmt, tnode, block);
       break;
     }
     case NK_Interface: {
-      mpl_node = ProcessInterfaceDecl(SK_Stmt, tnode, nullptr);
+      mpl_node = ProcessInterfaceDecl(SK_Stmt, tnode, block);
       break;
     }
     case NK_Function: {
-      mpl_node = ProcessFuncDecl(SK_Stmt, tnode, nullptr);
+      mpl_node = ProcessFuncDecl(SK_Stmt, tnode, block);
       break;
     }
     case NK_Block: {
-      mpl_node = ProcessBlockDecl(SK_Stmt, tnode, nullptr);
+      mpl_node = ProcessBlockDecl(SK_Stmt, tnode, block);
       break;
     }
     default: {
@@ -47,7 +48,7 @@ maple::BaseNode *A2M::ProcessNodeDecl(StmtExprKind skind, TreeNode *tnode, Block
   return mpl_node;
 }
 
-maple::BaseNode *A2M::ProcessNode(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessNode(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   if (!tnode) {
     return nullptr;
   }
@@ -64,21 +65,43 @@ maple::BaseNode *A2M::ProcessNode(StmtExprKind skind, TreeNode *tnode, BlockNode
   return mpl_node;
 }
 
-maple::BaseNode *A2M::ProcessPackage(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessModule(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessModule()");
+  ModuleNode *node = static_cast<ModuleNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessPackage(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessPackage()");
   PackageNode *node = static_cast<PackageNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessImport(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessDeclare(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessImport(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessImport()");
   ImportNode *node = static_cast<ImportNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessIdentifier(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessExport(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessExport()");
+  ExportNode *node = static_cast<ExportNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessXXportAsPair(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessXXportAsPair()");
+  XXportAsPairNode *node = static_cast<XXportAsPairNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessIdentifier(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   IdentifierNode *node = static_cast<IdentifierNode *>(tnode);
-  const char *name = node->GetName();
+  std::string name = node->GetName();
 
   if (skind == SK_Stmt) {
     AST2MPLMSG("ProcessIdentifier() is a decl", name);
@@ -94,7 +117,7 @@ maple::BaseNode *A2M::ProcessIdentifier(StmtExprKind skind, TreeNode *tnode, Blo
   }
 
   maple::GStrIdx stridx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
-  maple::MIRFunction *func = GetFunc(block);
+  maple::MIRFunction *func = GetCurrFunc(block);
 
   // check parameters
   if (func->IsAFormalName(stridx)) {
@@ -118,7 +141,7 @@ maple::BaseNode *A2M::ProcessIdentifier(StmtExprKind skind, TreeNode *tnode, Blo
     maple::BaseNode *bn = mMirBuilder->CreateExprDread(sym);
     maple::MIRType *ftype = maple::GlobalTables::GetTypeTable().GetTypeFromTyIdx(mFieldData->GetTyIdx());
     AST2MPLMSG("ProcessIdentifier() found match field", name);
-    return new maple::IreadNode(maple::OP_iread, ftype->GetPrimType(), mFieldData->GetTyIdx(), maple::FieldID(fid), bn);
+    return new maple::IreadNode(maple::OP_iread, ftype->GetPrimType(), sym->GetTyIdx(), maple::FieldID(fid), bn);
   }
 
   // check global var
@@ -129,11 +152,12 @@ maple::BaseNode *A2M::ProcessIdentifier(StmtExprKind skind, TreeNode *tnode, Blo
   }
 
   AST2MPLMSG("ProcessIdentifier() unknown identifier", name);
+  // create a dummy var with name and mDefaultType
   symbol = mMirBuilder->GetOrCreateLocalDecl(name, *mDefaultType);
   return mMirBuilder->CreateExprDread(symbol);
 }
 
-maple::BaseNode *A2M::ProcessField(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessField(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   FieldNode *node = static_cast<FieldNode *>(tnode);
   maple::BaseNode *bn = nullptr;
 
@@ -148,40 +172,81 @@ maple::BaseNode *A2M::ProcessField(StmtExprKind skind, TreeNode *tnode, BlockNod
 
   maple::MIRType *ctype = nullptr;
   maple::TyIdx cptyidx(0);
-  maple::BaseNode *dr = nullptr;
+  maple::BaseNode *nd = nullptr;
+  nd = ProcessNode(SK_Expr, upper, block);
   if (upper->IsLiteral()) {
     LiteralNode *lt = static_cast<LiteralNode *>(upper);
     if (lt->GetData().mType == LT_ThisLiteral) {
-      maple::MIRFunction *func = GetFunc(block);
+      maple::MIRFunction *func = GetCurrFunc(block);
       maple::MIRSymbol *sym = func->GetFormal(0); // this
       cptyidx = sym->GetTyIdx();
       ctype = GetClass(block);
-      dr = new maple::DreadNode(maple::OP_dread, maple::PTY_ptr, sym->GetStIdx(), 0);
+      nd = new maple::DreadNode(maple::OP_dread, maple::PTY_ptr, sym->GetStIdx(), 0);
     } else {
       NOTYETIMPL("ProcessField() not this literal");
     }
+  } else if (nd) {
+    maple::TyIdx tyidx(0);
+    switch (nd->GetOpCode()) {
+      case maple::OP_dread: {
+        maple::AddrofNode *dr = static_cast<maple::AddrofNode *>(nd);
+        maple::StIdx stidx = dr->GetStIdx();
+        maple::MIRSymbol *sym = nullptr;
+        if (stidx.Islocal()) {
+          sym = mMirModule->CurFunction()->GetSymTab()->GetSymbolFromStIdx(stidx.Idx());
+        } else {
+          sym = maple::GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx());
+        }
+        tyidx = sym->GetTyIdx();
+        break;
+      }
+      case maple::OP_iread: {
+        maple::IreadNode *ir = static_cast<maple::IreadNode *>(nd);
+        tyidx = ir->GetTyIdx();
+        break;
+      }
+      default:
+        NOTYETIMPL("ProcessField() supper");
+        break;
+    }
+    maple::MIRType *type = maple::GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx);
+    cptyidx = type->GetTypeIndex();
+    while (type->GetKind() == maple::kTypePointer) {
+      maple::MIRPtrType *ptype = static_cast<maple::MIRPtrType *>(type);
+      type = ptype->GetPointedType();
+    }
+    ctype = type;
   } else {
-    NOTYETIMPL("ProcessField() upper not literal");
+    NOTYETIMPL("ProcessField() nullptr nd");
   }
 
-  if (!ctype) {
-    NOTYETIMPL("ProcessField() null class type");
+  if (!(ctype && ctype->IsInstanceOfMIRStructType())) {
+    NOTYETIMPL("ProcessField() null or non structure/class/interface type");
     return bn;
   }
 
-  const char *fname = field->GetName();
+  std::string fname = field->GetName();
   maple::GStrIdx stridx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fname);
   mFieldData->ResetStrIdx(stridx);
   maple::uint32 fid = 0;
   bool status = mMirBuilder->TraverseToNamedField((maple::MIRStructType*)ctype, fid, mFieldData);
+  maple::MIRType *ftype = maple::GlobalTables::GetTypeTable().GetTypeFromTyIdx(mFieldData->GetTyIdx());
   if (status) {
-    maple::MIRType *ftype = maple::GlobalTables::GetTypeTable().GetTypeFromTyIdx(mFieldData->GetTyIdx());
-    bn = new maple::IreadNode(maple::OP_iread, ftype->GetPrimType(), cptyidx, fid, dr);
+    bn = new maple::IreadNode(maple::OP_iread, ftype->GetPrimType(), cptyidx, fid, nd);
+  } else {
+    NOTYETIMPL("ProcessField() can not find field");
+    // insert a dummy field with fname and mDefaultType
+    const maple::FieldAttrs attr;
+    maple::TyIdxFieldAttrPair P0(mDefaultType->GetTypeIndex(), attr);
+    maple::FieldPair P1(stridx, P0);
+    maple::MIRStructType *stype = static_cast<maple::MIRStructType *>(ctype);
+    stype->GetFields().push_back(P1);
+    bn = new maple::IreadNode(maple::OP_iread, maple::PTY_begin, cptyidx, fid+1, nd);
   }
   return bn;
 }
 
-maple::BaseNode *A2M::ProcessFieldDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessFieldDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   FieldNode *node = static_cast<FieldNode *>(tnode);
   maple::BaseNode *bn = nullptr;
 
@@ -192,88 +257,133 @@ maple::BaseNode *A2M::ProcessFieldDecl(StmtExprKind skind, TreeNode *tnode, Bloc
 
   TreeNode *parent = tnode->GetParent();
   MASSERT((parent->IsClass() || parent->IsInterface()) && "Not class or interface");
-  maple::MIRType *ptype = mNodeTypeMap[parent->GetName()];
+  maple::MIRType *ptype = mNodeTypeMap[parent->GetStrIdx()];
+  if (ptype->IsMIRPtrType()) {
+    maple::MIRPtrType * ptrtype = static_cast<maple::MIRPtrType *>(ptype);
+    ptype = ptrtype->GetPointedType();
+  }
   maple::MIRStructType *stype = static_cast<maple::MIRStructType *>(ptype);
   MASSERT(stype && "struct type not valid");
 
   IdentifierNode *inode = static_cast<IdentifierNode *>(tnode);
-  const char    *name = inode->GetName();
+  std::string    name = inode->GetName();
   TreeNode      *type = inode->GetType(); // PrimTypeNode or UserTypeNode
   TreeNode      *init = inode->GetInit(); // Init value
 
   maple::GenericAttrs genAttrs;
   MapAttr(genAttrs, inode);
+  maple::FieldAttrs fAttrs = genAttrs.ConvertToFieldAttrs();
+  bool isStatic = fAttrs.GetAttr(maple::FLDATTR_static);
 
-  maple::GStrIdx stridx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
   maple::MIRType *mir_type = MapType(type);
-  // always use pointer type for classes, with PTY_ref
-  if (mir_type->GetKind() == maple::kTypeClass || mir_type->GetKind() == maple::kTypeClassIncomplete ||
-      mir_type->GetKind() == maple::kTypeInterface || mir_type->GetKind() == maple::kTypeInterfaceIncomplete) {
-    mir_type = maple::GlobalTables::GetTypeTable().GetOrCreatePointerType(*mir_type, maple::PTY_ref);
+  if (!mir_type) {
+    NOTYETIMPL("ProcessFieldSetup() unknown field type");
   }
-  if (mir_type) {
-    maple::TyIdxFieldAttrPair P0(mir_type->GetTypeIndex(), genAttrs.ConvertToFieldAttrs());
-    maple::FieldPair P1(stridx, P0);
+
+  // use mangled name for static fields as they will be global
+  std::string str(name);
+  if (isStatic) {
+    str.insert(0, "|");
+    str.insert(0, parent->GetName());
+  }
+
+  maple::GStrIdx stridx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
+  maple::TyIdxFieldAttrPair P0(mir_type->GetTypeIndex(), fAttrs);
+  maple::FieldPair P1(stridx, P0);
+  maple::MIRSymbol *symbol = nullptr;
+  if (isStatic) {
+    stype->GetStaticFields().push_back(P1);
+    symbol = mMirBuilder->CreateGlobalDecl(str, *mir_type, maple::kScGlobal);
+    symbol->SetAttrs(genAttrs.ConvertToTypeAttrs());
+  } else {
     stype->GetFields().push_back(P1);
   }
 
+  if (init) {
+    if (isStatic) {
+      if (init->IsLiteral()) {
+        maple::BaseNode *val = ProcessLiteral(SK_Expr, init, nullptr);
+        if (val->op == maple::OP_constval) {
+          maple::ConstvalNode *cval = static_cast<maple::ConstvalNode *>(val);
+          symbol->SetKonst(cval->GetConstVal());
+        } else {
+          NOTYETIMPL("ProcessFieldSetup() not constval Init");
+        }
+      }
+    } else {
+      NOTYETIMPL("ProcessFieldSetup() non-static Init");
+    }
+  }
+
   return bn;
 }
 
-maple::BaseNode *A2M::ProcessAssert(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  DeclNode *node = static_cast<DeclNode *>(tnode);
+  TreeNode *vars = node->GetVar();
+  return ProcessNode(skind, vars, block);
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessAssert(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessAssert()");
   AssertNode *node = static_cast<AssertNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessDimension(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessDimension(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessDimension()");
   DimensionNode *node = static_cast<DimensionNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessAttr(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessAttr(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessAttr()");
   // AttrNode *node = static_cast<AttrNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessPrimType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessPrimType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessPrimType()");
   PrimTypeNode *node = static_cast<PrimTypeNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessPrimArrayType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessPrimArrayType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessPrimArrayType()");
   PrimArrayTypeNode *node = static_cast<PrimArrayTypeNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessUserType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessUserType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessUserType()");
   UserTypeNode *node = static_cast<UserTypeNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessCast(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessCast(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessCast()");
   CastNode *node = static_cast<CastNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessParenthesis(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessParenthesis(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   ParenthesisNode *node = static_cast<ParenthesisNode *>(tnode);
   return ProcessNode(skind, node->GetExpr(), block);
 }
 
-maple::BaseNode *A2M::ProcessVarList(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessVarList(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   VarListNode *node = static_cast<VarListNode *>(tnode);
-  for (int i = 0; i < node->GetNum(); i++) {
-    TreeNode *n = node->VarAtIndex(i);
+  for (int i = 0; i < node->GetVarsNum(); i++) {
+    TreeNode *n = node->GetVarAtIndex(i);
     IdentifierNode *inode = static_cast<IdentifierNode *>(n);
     AST2MPLMSG("ProcessVarList() decl", inode->GetName());
     maple::MIRSymbol *symbol = CreateSymbol(inode, block);
+
+    maple::GenericAttrs genAttrs;
+    MapAttr(genAttrs, inode);
+    maple::TypeAttrs tAttrs = genAttrs.ConvertToTypeAttrs();
+    symbol->SetAttrs(tAttrs);
+
     TreeNode *init = inode->GetInit(); // Init value
     if (init) {
       maple::BaseNode *bn = ProcessNode(SK_Expr, init, block);
@@ -288,35 +398,78 @@ maple::BaseNode *A2M::ProcessVarList(StmtExprKind skind, TreeNode *tnode, BlockN
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessExprList(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessExprList(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessExprList()");
   ExprListNode *node = static_cast<ExprListNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessLiteral(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessNamespace(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessLiteral(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   LiteralNode *node = static_cast<LiteralNode *>(tnode);
   LitData data = node->GetData();
+  maple::MIRType *type = nullptr;
+  maple::PrimType prim = maple::PTY_unknown;
   maple::BaseNode *bn = nullptr;
   switch (data.mType) {
     case LT_IntegerLiteral: {
-      maple::MIRType *typeI32 = maple::GlobalTables::GetTypeTable().GetInt32();
-      maple::MIRIntConst *cst = new maple::MIRIntConst(data.mData.mInt, *typeI32);
-      bn =  new maple::ConstvalNode(maple::PTY_i32, cst);
+      type = MapPrimType(TY_Int);
+      prim = MapPrim(TY_Int);
+      maple::MIRIntConst *cst = new maple::MIRIntConst(data.mData.mInt, *type);
+      bn = new maple::ConstvalNode(prim, cst);
       break;
     }
     case LT_BooleanLiteral: {
-      int val = (data.mData.mBool == true) ? 1 : 0;
-      maple::MIRType *typeU1 = maple::GlobalTables::GetTypeTable().GetUInt1();
-      bn = new maple::ConstvalNode(maple::PTY_u1, new maple::MIRIntConst(val, *typeU1));
+      type = MapPrimType(TY_Boolean);
+      prim = MapPrim(TY_Boolean);
+      maple::MIRIntConst *cst = new maple::MIRIntConst((data.mData.mBool == true) ? 1 : 0, *type);
+      bn = new maple::ConstvalNode(prim, cst);
+      break;
+    }
+    case LT_CharacterLiteral: {
+      type = MapPrimType(TY_Char);
+      prim = MapPrim(TY_Char);
+      maple::MIRIntConst *cst = new maple::MIRIntConst((int)data.mData.mChar.mData.mChar, *type);
+      bn = new maple::ConstvalNode(prim, cst);
+      break;
+    }
+    case LT_FPLiteral: {
+      type = MapPrimType(TY_Float);
+      prim = MapPrim(TY_Float);
+      maple::MIRFloatConst *cst = new maple::MIRFloatConst(data.mData.mFloat, *type);
+      bn = new maple::ConstvalNode(prim, cst);
+      break;
+    }
+    case LT_DoubleLiteral: {
+      type = MapPrimType(TY_Double);
+      prim = MapPrim(TY_Double);
+      maple::MIRDoubleConst *cst = new maple::MIRDoubleConst(data.mData.mDouble, *type);
+      bn = new maple::ConstvalNode(prim, cst);
+      break;
+    }
+    case LT_StringLiteral: {
+      const std::string str(gStringPool.GetStringFromStrIdx(data.mData.mStrIdx));
+      maple::UStrIdx strIdx = maple::GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str);
+      bn = new maple::ConststrNode(strIdx);
+      bn->SetPrimType(maple::PTY_ptr);
+      break;
+    }
+    case LT_NullLiteral: {
+      type = MapPrimType(TY_Null);
+      prim = MapPrim(TY_Null);
+      maple::MIRIntConst *cst = new maple::MIRIntConst(0, *type);
+      bn = new maple::ConstvalNode(prim, cst);
+      break;
+    }
+    case LT_ThisLiteral: {
+      maple::MIRFunction *func = GetCurrFunc(block);
+      maple::MIRSymbol *sym = func->GetFormal(0);
+      bn = mMirBuilder->CreateExprDread(sym);
       break;
     }
-    case LT_FPLiteral:
-    case LT_DoubleLiteral:
-    case LT_CharacterLiteral:
-    case LT_StringLiteral:
-    case LT_NullLiteral:
-    case LT_ThisLiteral:
     default: {
       NOTYETIMPL("ProcessLiteral() need support");
       break;
@@ -325,7 +478,7 @@ maple::BaseNode *A2M::ProcessLiteral(StmtExprKind skind, TreeNode *tnode, BlockN
   return bn;
 }
 
-maple::BaseNode *A2M::ProcessUnaOperator(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessUnaOperator(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   UnaOperatorNode *node = static_cast<UnaOperatorNode *>(tnode);
   OprId ast_op = node->GetOprId();
   TreeNode *ast_rhs = node->GetOpnd();
@@ -347,11 +500,11 @@ maple::BaseNode *A2M::ProcessUnaOperator(StmtExprKind skind, TreeNode *tnode, Bl
   return mpl_node;
 }
 
-maple::BaseNode *A2M::ProcessBinOperator(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessBinOperator(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   BinOperatorNode *bon = static_cast<BinOperatorNode *>(tnode);
-  OprId ast_op = bon->mOprId;
-  TreeNode *ast_lhs = bon->mOpndA;
-  TreeNode *ast_rhs = bon->mOpndB;
+  OprId ast_op = bon->GetOprId();
+  TreeNode *ast_lhs = bon->GetOpndA();
+  TreeNode *ast_rhs = bon->GetOpndB();
   maple::BaseNode *lhs = ProcessNode(SK_Expr, ast_lhs, block);
   maple::BaseNode *rhs = ProcessNode(SK_Expr, ast_rhs, block);
   maple::BaseNode *mpl_node = nullptr;
@@ -394,35 +547,98 @@ maple::BaseNode *A2M::ProcessBinOperator(StmtExprKind skind, TreeNode *tnode, Bl
   return mpl_node;
 }
 
-maple::BaseNode *A2M::ProcessTerOperator(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessTerOperator(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessTerOperator()");
   TerOperatorNode *node = static_cast<TerOperatorNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessLambda(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessLambda(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessLambda()");
   LambdaNode *node = static_cast<LambdaNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessBlockDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessInstanceOf(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessInstanceOf()");
+  InstanceOfNode *node = static_cast<InstanceOfNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessTemplateLiteral(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessTemplateLiteral()");
+  TemplateLiteralNode *node = static_cast<TemplateLiteralNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessRegExpr(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessIn(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessIn()");
+  InNode *node = static_cast<InNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessComputedName(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessIs(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessIs()");
+  IsNode *node = static_cast<IsNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessTypeOf(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessTypeOf()");
+  TypeOfNode *node = static_cast<TypeOfNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessAwait(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessKeyOf(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessInfer(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessTripleSlash(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessFunctionType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessBlockDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   BlockNode *ast_block = static_cast<BlockNode *>(tnode);
-  maple::BlockNode *blk = mBlockNodeMap[block];
   for (int i = 0; i < ast_block->GetChildrenNum(); i++) {
     TreeNode *child = ast_block->GetChildAtIndex(i);
-    maple::BaseNode *stmt = ProcessNodeDecl(skind, child, block);
+    maple::BaseNode *stmt = ProcessNodeDecl(skind, child, ast_block);
   }
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessBlock(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessBlock(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   BlockNode *ast_block = static_cast<BlockNode *>(tnode);
-  maple::BlockNode *blk = mBlockNodeMap[block];
+  if (block) {
+    // promote statements to parent
+    mBlockNodeMap[ast_block] = mBlockNodeMap[block];
+  } else {
+    mBlockNodeMap[ast_block] = new maple::BlockNode();
+  }
+  maple::BlockNode *blk = mBlockNodeMap[ast_block];
   for (int i = 0; i < ast_block->GetChildrenNum(); i++) {
     TreeNode *child = ast_block->GetChildAtIndex(i);
-    maple::BaseNode *stmt = ProcessNode(skind, child, block);
-    if (stmt) {
+    maple::BaseNode *stmt = ProcessNode(skind, child, ast_block);
+    if (stmt && IsStmt(child)) {
       blk->AddStatement((maple::StmtNode*)stmt);
       if (mTraceA2m) stmt->Dump(0);
     }
@@ -430,19 +646,19 @@ maple::BaseNode *A2M::ProcessBlock(StmtExprKind skind, TreeNode *tnode, BlockNod
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessFunction(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessFunction(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   MASSERT(tnode->IsFunction() && "it is not an FunctionNode");
   NOTYETIMPL("ProcessFunction()");
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessFuncDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessFuncDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   FunctionNode *ast_func = static_cast<FunctionNode *>(tnode);
-  const char                     *name = ast_func->GetName();
+  std::string                     name = ast_func->GetName();
   // SmallVector<AttrId>          mAttrs;
   // SmallVector<AnnotationNode*> mAnnotations; //annotation or pragma
   // SmallVector<ExceptionNode*>  mThrows;      // exceptions it can throw
-  TreeNode                    *ast_rettype = ast_func->GetType();        // return type
+  TreeNode                    *ast_rettype = ast_func->GetRetType();        // return type
   // SmallVector<TreeNode*>       mParams;      //
   BlockNode                   *ast_body = ast_func->GetBody();
   // DimensionNode               *mDims;
@@ -452,7 +668,11 @@ maple::BaseNode *A2M::ProcessFuncDecl(StmtExprKind skind, TreeNode *tnode, Block
   TreeNode *parent = tnode->GetParent();
   maple::MIRStructType *stype = nullptr;
   if (parent->IsClass() || parent->IsInterface()) {
-    maple::MIRType *ptype = mNodeTypeMap[parent->GetName()];
+    maple::MIRType *ptype = mNodeTypeMap[parent->GetStrIdx()];
+    if (ptype->IsMIRPtrType()) {
+      maple::MIRPtrType * ptrtype = static_cast<maple::MIRPtrType *>(ptype);
+      ptype = ptrtype->GetPointedType();
+    }
     stype = static_cast<maple::MIRStructType *>(ptype);
     MASSERT(stype && "struct type not valid");
   }
@@ -461,8 +681,12 @@ maple::BaseNode *A2M::ProcessFuncDecl(StmtExprKind skind, TreeNode *tnode, Block
   maple::MIRFunction *func = mMirBuilder->GetOrCreateFunction(name, rettype->GetTypeIndex());
 
   // init function fields
-  func->SetBody(func->GetCodeMemPool()->New<maple::BlockNode>());
+  maple::BlockNode *funcbody = func->GetCodeMemPool()->New<maple::BlockNode>();
+  func->SetBody(funcbody);
   func->AllocSymTab();
+  if (ast_func->IsConstructor()) {
+    func->SetAttr(maple::FUNCATTR_constructor);
+  }
 
   mMirModule->AddFunction(func);
   mMirModule->SetCurFunction(func);
@@ -480,7 +704,7 @@ maple::BaseNode *A2M::ProcessFuncDecl(StmtExprKind skind, TreeNode *tnode, Block
   if (stype) {
     maple::GStrIdx stridx = maple::GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("this");
     maple::TypeAttrs attr = maple::TypeAttrs();
-    maple::MIRType *sptype = maple::GlobalTables::GetTypeTable().GetOrCreatePointerType(*stype, maple::PTY_ref);
+    maple::MIRType *sptype = mMirBuilder->GetOrCreatePointerType(stype);
     maple::MIRSymbol *sym = mMirBuilder->GetOrCreateLocalDecl("this", *sptype);
     sym->SetStorageClass(maple::kScFormal);
     func->AddArgument(sym);
@@ -512,10 +736,11 @@ maple::BaseNode *A2M::ProcessFuncDecl(StmtExprKind skind, TreeNode *tnode, Block
   // use className|funcName|_argTypes_retType as function name
   UpdateFuncName(func);
   mFuncMap[ast_func] = func;
-  mNameFuncMap[name].push_back(func);
+  mNameFuncMap[ast_func->GetStrIdx()].push_back(func);
 
   // create function type
-  maple::MIRFuncType *functype = (maple::MIRFuncType*)maple::GlobalTables::GetTypeTable().GetOrCreateFunctionType(*mMirModule, rettype->GetTypeIndex(), funcvectype, funcvecattr, /*isvarg*/ false, false);
+  maple::MIRFuncType *functype = (maple::MIRFuncType*)maple::GlobalTables::GetTypeTable().GetOrCreateFunctionType(
+      rettype->GetTypeIndex(), funcvectype, funcvecattr, /*isvarg*/ false);
   func->SetMIRFuncType(functype);
 
   // update function symbol's type
@@ -531,11 +756,10 @@ maple::BaseNode *A2M::ProcessFuncDecl(StmtExprKind skind, TreeNode *tnode, Block
     stype->GetMethods().push_back(P1);
   }
 
-  if (ast_func->GetBody()) {
-    BlockNode *ast_block = static_cast<BlockNode *>(ast_func->GetBody());
-    for (int i = 0; i < ast_block->GetChildrenNum(); i++) {
-      TreeNode *child = ast_block->GetChildAtIndex(i);
-      maple::BaseNode *stmt = ProcessNodeDecl(skind, child, block);
+  if (ast_body) {
+    for (int i = 0; i < ast_body->GetChildrenNum(); i++) {
+      TreeNode *child = ast_body->GetChildAtIndex(i);
+      maple::BaseNode *stmt = ProcessNodeDecl(skind, child, ast_body);
     }
   }
 
@@ -543,7 +767,7 @@ maple::BaseNode *A2M::ProcessFuncDecl(StmtExprKind skind, TreeNode *tnode, Block
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessFuncSetup(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessFuncSetup(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   FunctionNode *ast_func = static_cast<FunctionNode *>(tnode);
 
   maple::MIRFunction *func = mFuncMap[ast_func];
@@ -572,11 +796,27 @@ maple::BaseNode *A2M::ProcessFuncSetup(StmtExprKind skind, TreeNode *tnode, Bloc
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessClassDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessClassDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   ClassNode *classnode = static_cast<ClassNode *>(tnode);
-  const char *name = classnode->GetName();
+  std::string name = classnode->GetName();
+  TreeNode *parent = GetSuperClass(classnode);
+  // mangle the name for inner classes
+  if (parent) {
+    if (parent->IsClass()) {
+      std::string str = parent->GetName();
+      str.append("$");   // indicate inner class name
+      str.append(std::to_string(mUniqNum++));
+      str.append(name);
+      name = strdup(str.c_str());
+      classnode->SetStrIdx(name);
+    }
+  }
   maple::MIRType *type = maple::GlobalTables::GetTypeTable().GetOrCreateClassType(name, *mMirModule);
-  mNodeTypeMap[name] = type;
+  type->SetMIRTypeKind(maple::kTypeClass);
+  // always use pointer type for classes, with PTY_ref
+  type = mMirBuilder->GetOrCreatePointerType(type);
+  unsigned idx = gStringPool.GetStrIdx(name);
+  mNodeTypeMap[idx] = type;
   AST2MPLMSG("\n================== class =====================", name);
 
   for (int i=0; i < classnode->GetLocalClassesNum(); i++) {
@@ -591,7 +831,7 @@ maple::BaseNode *A2M::ProcessClassDecl(StmtExprKind skind, TreeNode *tnode, Bloc
     ProcessFieldDecl(skind, classnode->GetField(i), block);
   }
 
-  for (int i=0; i < classnode->GetConstructorNum(); i++) {
+  for (int i=0; i < classnode->GetConstructorsNum(); i++) {
     ProcessFuncDecl(skind, classnode->GetConstructor(i), block);
   }
 
@@ -599,16 +839,13 @@ maple::BaseNode *A2M::ProcessClassDecl(StmtExprKind skind, TreeNode *tnode, Bloc
     ProcessFuncDecl(skind, classnode->GetMethod(i), block);
   }
 
-  // set kind to kTypeClass from kTypeClassIncomplete
-  type->SetMIRTypeKind(maple::kTypeClass);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessClass(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessClass(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   ClassNode *classnode = static_cast<ClassNode *>(tnode);
-  const char *name = classnode->GetName();
-  maple::MIRType *type = maple::GlobalTables::GetTypeTable().GetOrCreateClassType(name, *mMirModule);
-  mNodeTypeMap[name] = type;
+  std::string name = classnode->GetName();
+  maple::MIRType *type = mNodeTypeMap[classnode->GetStrIdx()];
   AST2MPLMSG("\n================== class =====================", name);
 
   for (int i=0; i < classnode->GetLocalClassesNum(); i++) {
@@ -619,7 +856,7 @@ maple::BaseNode *A2M::ProcessClass(StmtExprKind skind, TreeNode *tnode, BlockNod
     ProcessInterface(skind, classnode->GetLocalInterface(i), block);
   }
 
-  for (int i=0; i < classnode->GetConstructorNum(); i++) {
+  for (int i=0; i < classnode->GetConstructorsNum(); i++) {
     ProcessFuncSetup(skind, classnode->GetConstructor(i), block);
   }
 
@@ -627,49 +864,149 @@ maple::BaseNode *A2M::ProcessClass(StmtExprKind skind, TreeNode *tnode, BlockNod
     ProcessFuncSetup(skind, classnode->GetMethod(i), block);
   }
 
-  // set kind to kTypeClass from kTypeClassIncomplete
-  type->SetMIRTypeKind(maple::kTypeClass);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessInterfaceDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessInterfaceDecl(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessInterfaceDecl()");
   InterfaceNode *node = static_cast<InterfaceNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessInterface(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessInterface(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessInterface()");
   InterfaceNode *node = static_cast<InterfaceNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessAnnotationType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessArrayElement(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessArrayElement()");
+  ArrayElementNode *node = static_cast<ArrayElementNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessArrayLiteral(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessArrayLiteral()");
+  ArrayLiteralNode *node = static_cast<ArrayLiteralNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessNumIndexSig(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessStrIndexSig(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessBindingElement(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessBindingPattern(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessTypeAlias(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessAsType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessConditionalType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessTypeParameter(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessNameTypePair(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessTupleType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessStruct(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessStruct()");
+  StructNode *node = static_cast<StructNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessStructLiteral(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessStructLiteral()");
+  StructLiteralNode *node = static_cast<StructLiteralNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessFieldLiteral(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessFieldLiteral()");
+  FieldLiteralNode *node = static_cast<FieldLiteralNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessAnnotationType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessAnnotationType()");
   AnnotationTypeNode *node = static_cast<AnnotationTypeNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessAnnotation(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessAnnotation(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessAnnotation()");
   AnnotationNode *node = static_cast<AnnotationNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessException(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessTry(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessTry()");
+  TryNode *node = static_cast<TryNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessCatch(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessCatch()");
+  CatchNode *node = static_cast<CatchNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessFinally(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessFinally()");
+  FinallyNode *node = static_cast<FinallyNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessThrow(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessThrow()");
+  ThrowNode *node = static_cast<ThrowNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessException(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessException()");
   ExceptionNode *node = static_cast<ExceptionNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessReturn(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessReturn(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   ReturnNode *node = static_cast<ReturnNode *>(tnode);
   maple::BaseNode *val = ProcessNode(SK_Expr, node->GetResult(), block);
   maple::NaryStmtNode *stmt = mMirBuilder->CreateStmtReturn(val);
   return stmt;
 }
 
-maple::BaseNode *A2M::ProcessCondBranch(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessYield(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessArrayType(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessCondBranch(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   CondBranchNode *node = static_cast<CondBranchNode *>(tnode);
   maple::BaseNode *cond = ProcessNode(SK_Expr, node->GetCond(), block);
   if (!cond) {
@@ -700,13 +1037,19 @@ maple::BaseNode *A2M::ProcessCondBranch(StmtExprKind skind, TreeNode *tnode, Blo
   return ifnode;
 }
 
-maple::BaseNode *A2M::ProcessBreak(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessBreak(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessBreak()");
   BreakNode *node = static_cast<BreakNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessLoopCondBody(StmtExprKind skind, TreeNode *cond, TreeNode *body, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessContinue(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+  NOTYETIMPL("ProcessContinue()");
+  ContinueNode *node = static_cast<ContinueNode *>(tnode);
+  return nullptr;
+}
+
+maple::BaseNode *Ast2MplBuilder::ProcessLoopCondBody(StmtExprKind skind, TreeNode *cond, TreeNode *body, BlockNode *block) {
   maple::BaseNode *mircond = ProcessNode(SK_Expr, cond, block);
   if (!mircond) {
     NOTYETIMPL("ProcessLoopCondBody() condition");
@@ -727,14 +1070,14 @@ maple::BaseNode *A2M::ProcessLoopCondBody(StmtExprKind skind, TreeNode *cond, Tr
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessForLoop(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessForLoop(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   ForLoopNode *node = static_cast<ForLoopNode *>(tnode);
   maple::BlockNode *mblock = mBlockNodeMap[block];
   maple::BaseNode *bn = nullptr;
 
   // init
-  for (int i = 0; i < node->GetInitNum(); i++) {
-    bn = ProcessNode(SK_Stmt, node->InitAtIndex(i), block);
+  for (int i = 0; i < node->GetInitsNum(); i++) {
+    bn = ProcessNode(SK_Stmt, node->GetInitAtIndex(i), block);
     if (bn) {
       mblock->AddStatement((maple::StmtNode*)bn);
       if (mTraceA2m) bn->Dump(0);
@@ -748,8 +1091,8 @@ maple::BaseNode *A2M::ProcessForLoop(StmtExprKind skind, TreeNode *tnode, BlockN
   maple::BlockNode *mbody = mBlockNodeMap[static_cast<BlockNode*>(astbody)];
 
   // update stmts are added into loop mbody
-  for (int i = 0; i < node->GetUpdateNum(); i++) {
-    bn = ProcessNode(SK_Stmt, node->UpdateAtIndex(i), (maplefe::BlockNode*)astbody);
+  for (int i = 0; i < node->GetUpdatesNum(); i++) {
+    bn = ProcessNode(SK_Stmt, node->GetUpdateAtIndex(i), (maplefe::BlockNode*)astbody);
     if (bn) {
       mbody->AddStatement((maple::StmtNode*)bn);
       if (mTraceA2m) bn->Dump(0);
@@ -759,33 +1102,81 @@ maple::BaseNode *A2M::ProcessForLoop(StmtExprKind skind, TreeNode *tnode, BlockN
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessWhileLoop(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessWhileLoop(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   WhileLoopNode *node = static_cast<WhileLoopNode *>(tnode);
   return ProcessLoopCondBody(skind, node->GetCond(), node->GetBody(), block);
 }
 
-maple::BaseNode *A2M::ProcessDoLoop(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessDoLoop(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   DoLoopNode *node = static_cast<DoLoopNode *>(tnode);
   return ProcessLoopCondBody(skind, node->GetCond(), node->GetBody(), block);
 }
 
-maple::BaseNode *A2M::ProcessNew(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
-  NOTYETIMPL("ProcessNew()");
+maple::BaseNode *Ast2MplBuilder::ProcessNew(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NewNode *node = static_cast<NewNode *>(tnode);
-  return nullptr;
+  maple::BaseNode *bn = nullptr;
+
+  // search for constructor to call
+  TreeNode *id = node->GetId();
+  if (!id->IsClass()) {
+    NOTYETIMPL("ProcessNew() mId not class");
+    return bn;
+  }
+  ClassNode *classnode = static_cast<ClassNode *>(id);
+
+  FunctionNode *func = nullptr;
+  for (int i=0; i < classnode->GetConstructorsNum(); i++) {
+    func = classnode->GetConstructor(i);
+    if (func->GetParamsNum() == node->GetArgsNum()) {
+      break;
+    }
+  }
+  if (!func) {
+    NOTYETIMPL("ProcessNew() null ast constructor");
+    return bn;
+  }
+
+  maple::BaseNode *obj = GetNewNodeLhs(node, block);
+  if (!obj) {
+    NOTYETIMPL("ProcessNew() null lhs");
+    return bn;
+  }
+
+  maple::MapleVector<maple::BaseNode *> args(mMirModule->CurFuncCodeMemPoolAllocator()->Adapter());
+  args.push_back(obj);
+  // pass arg
+  for (int i = 0; i < node->GetArgsNum(); i++) {
+    maple::BaseNode *arg = ProcessNode(SK_Expr, node->GetArg(i), block);
+    if (arg) {
+      args.push_back(arg);
+    } else {
+      NOTYETIMPL("ProcessCall() null arg");
+    }
+  }
+
+  maple::MIRFunction *callfunc = SearchFunc(func, args, block);
+  if (!callfunc) {
+    NOTYETIMPL("ProcessNew() null maple constructor");
+    return bn;
+  }
+  maple::PUIdx puIdx = callfunc->GetPuidx();
+  maple::Opcode callop = maple::OP_virtualcall;
+  maple::StmtNode *stmt = mMirBuilder->CreateStmtCallAssigned(puIdx, args, nullptr, callop);
+  maple::BlockNode *blk = mBlockNodeMap[block];
+  blk->AddStatement(stmt);
+  return bn;
 }
 
-maple::BaseNode *A2M::ProcessDelete(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessDelete(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessDelete()");
   DeleteNode *node = static_cast<DeleteNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessCall(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
-  NOTYETIMPL("ProcessCall()");
+maple::BaseNode *Ast2MplBuilder::ProcessCall(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   CallNode *node = static_cast<CallNode *>(tnode);
   maple::MapleVector<maple::BaseNode *> args(mMirModule->CurFuncCodeMemPoolAllocator()->Adapter());
-  maple::MIRFunction *func = GetFunc(block);
+  maple::MIRFunction *func = GetCurrFunc(block);
 
   // pass this
   maple::MIRSymbol *sym = func->GetFormal(0);
@@ -801,24 +1192,20 @@ maple::BaseNode *A2M::ProcessCall(StmtExprKind skind, TreeNode *tnode, BlockNode
   }
 
   TreeNode *method = node->GetMethod();
-  if (!method->IsIdentifier()) {
-    NOTYETIMPL("ProcessCall() method not an identifier");
-  }
-  IdentifierNode *imethod = static_cast<IdentifierNode *>(method);
-  func = SearchFunc(imethod->GetName(), args);
-  if (!func) {
+  maple::MIRFunction *callfunc = SearchFunc(method, args, block);
+  if (!callfunc) {
     NOTYETIMPL("ProcessCall() method not found");
     return nullptr;
   }
-  maple::PUIdx puIdx = func->GetPuidx();
+  maple::PUIdx puIdx = callfunc->GetPuidx();
 
-  maple::MIRType *returnType = func->GetReturnType();
+  maple::MIRType *returnType = callfunc->GetReturnType();
   maple::MIRSymbol *rv = nullptr;
-  maple::Opcode callop = maple::OP_call;
+  maple::Opcode callop = func->IsJava() ? maple::OP_virtualcall : maple::OP_call;
   if (returnType->GetPrimType() != maple::PTY_void) {
-    NOTYETIMPL("ProcessCall() OP_callassigned");
-    // rv = CreateTempVar("retvar", returnType);
-    // callop = maple::OP_callassigned;
+    AST2MPLMSG0("ProcessCall() OP_[virtual]callassigned");
+    rv = CreateTempVar("retvar", returnType);
+    callop = func->IsJava() ? maple::OP_virtualcallassigned : maple::OP_callassigned;
   }
 
   maple::StmtNode *stmt = mMirBuilder->CreateStmtCallAssigned(puIdx, args, rv, callop);
@@ -832,25 +1219,25 @@ maple::BaseNode *A2M::ProcessCall(StmtExprKind skind, TreeNode *tnode, BlockNode
   }
 }
 
-maple::BaseNode *A2M::ProcessSwitchLabel(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessSwitchLabel(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessSwitchLabel()");
   SwitchLabelNode *node = static_cast<SwitchLabelNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessSwitchCase(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessSwitchCase(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessSwitchCase()");
   SwitchCaseNode *node = static_cast<SwitchCaseNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessSwitch(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessSwitch(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   NOTYETIMPL("ProcessSwitch()");
   SwitchNode *node = static_cast<SwitchNode *>(tnode);
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessPass(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
+maple::BaseNode *Ast2MplBuilder::ProcessPass(StmtExprKind skind, TreeNode *tnode, BlockNode *block) {
   PassNode *node = static_cast<PassNode *>(tnode);
   maple::BlockNode *blk = mBlockNodeMap[block];
   maple::BaseNode *stmt = nullptr;
@@ -860,12 +1247,15 @@ maple::BaseNode *A2M::ProcessPass(StmtExprKind skind, TreeNode *tnode, BlockNode
     if (stmt && IsStmt(child)) {
       blk->AddStatement((maple::StmtNode*)stmt);
       if (mTraceA2m) stmt->Dump(0);
+    } else {
+      NOTYETIMPL("ProcessPass() having unhandled stmt");
+      break;
     }
   }
   return nullptr;
 }
 
-maple::BaseNode *A2M::ProcessUnaOperatorMpl(StmtExprKind skind,
+maple::BaseNode *Ast2MplBuilder::ProcessUnaOperatorMpl(StmtExprKind skind,
                                        maple::Opcode op,
                                        maple::BaseNode *bn,
                                        BlockNode *block) {
@@ -910,7 +1300,7 @@ maple::BaseNode *A2M::ProcessUnaOperatorMpl(StmtExprKind skind,
   return node;
 }
 
-maple::BaseNode *A2M::ProcessBinOperatorMplAssign(StmtExprKind skind,
+maple::BaseNode *Ast2MplBuilder::ProcessBinOperatorMplAssign(StmtExprKind skind,
                                              maple::BaseNode *lhs,
                                              maple::BaseNode *rhs,
                                              BlockNode *block) {
@@ -939,7 +1329,7 @@ maple::BaseNode *A2M::ProcessBinOperatorMplAssign(StmtExprKind skind,
   return node;
 }
 
-maple::BaseNode *A2M::ProcessBinOperatorMplComboAssign(StmtExprKind skind,
+maple::BaseNode *Ast2MplBuilder::ProcessBinOperatorMplComboAssign(StmtExprKind skind,
                                                   maple::Opcode op,
                                                   maple::BaseNode *lhs,
                                                   maple::BaseNode *rhs,
@@ -949,7 +1339,7 @@ maple::BaseNode *A2M::ProcessBinOperatorMplComboAssign(StmtExprKind skind,
   return assign;
 }
 
-maple::BaseNode *A2M::ProcessBinOperatorMplArror(StmtExprKind skind,
+maple::BaseNode *Ast2MplBuilder::ProcessBinOperatorMplArror(StmtExprKind skind,
                                             maple::BaseNode *lhs,
                                             maple::BaseNode *rhs,
                                             BlockNode *block) {
@@ -957,5 +1347,51 @@ maple::BaseNode *A2M::ProcessBinOperatorMplArror(StmtExprKind skind,
   return nullptr;
 }
 
+// Lhs = new ...
+maple::BaseNode *Ast2MplBuilder::GetNewNodeLhs(NewNode *node, BlockNode *block) {
+  maple::BaseNode *obj = nullptr;
+  TreeNode *id = node->GetId();
+
+  TreeNode *parent = node->GetParent();
+  if (!parent) {
+    NOTYETIMPL("GetNewNodeLhs() null parent");
+    return obj;
+  }
+  maple::BaseNode *bn = nullptr;
+  switch (parent->GetKind()) {
+    // Lhs = new ...
+    case NK_BinOperator: {
+      BinOperatorNode *biop = static_cast<BinOperatorNode *>(parent);
+      switch (biop->GetOprId()) {
+        case OPR_Assign: {
+          obj = ProcessNode(SK_Expr, biop->GetOpndA(), block);
+          break;
+        }
+        default: {
+          NOTYETIMPL("GetNewNodeLhs() not BinOperator");
+          break;
+        }
+      }
+      break;
+    }
+    // decl init: Type Lhs = new ...
+    case NK_Identifier: {
+      obj = ProcessNode(SK_Expr, parent, block);
+      break;
+    }
+    default:
+      NOTYETIMPL("GetNewNodeLhs() other kind");
+      break;
+  }
+
+  if (!obj) {
+    AST2MPLMSG0("ProcessNew() null lhs");
+    maple::MIRType *type = MapType(id);
+    maple::MIRSymbol *var = CreateTempVar("dummy_new", type);
+    obj = mMirBuilder->CreateExprDread(var);
+  }
+  return obj;
+}
+
 }
 
diff --git a/src/MapleFE/astopt/Makefile b/src/MapleFE/astopt/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..0a16203b38c8275b85df68e1d5e3fb7ad56fac63
--- /dev/null
+++ b/src/MapleFE/astopt/Makefile
@@ -0,0 +1,27 @@
+# Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
+include ../Makefile.in
+
+all:
+	$(MAKE) -C src
+
+clean:
+	rm -rf $(BUILDDIR)/astopt
+
+test:
+	$(MAKE) -C ../test p
+
+.PHONY: $(TARGS)
+
diff --git a/src/MapleFE/astopt/include/ast_adj.h b/src/MapleFE/astopt/include/ast_adj.h
new file mode 100644
index 0000000000000000000000000000000000000000..36675d91eb0d6004051f5d04c2518db280fe7337
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_adj.h
@@ -0,0 +1,85 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_ADJ_HEADER__
+#define __AST_ADJ_HEADER__
+
+#include <stack>
+#include <utility>
+#include <unordered_map>
+#include <unordered_set>
+#include "ast_module.h"
+#include "ast.h"
+#include "ast_type.h"
+#include "gen_astvisitor.h"
+#include "ast_info.h"
+
+namespace maplefe {
+
+class AST_ADJ {
+ private:
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+
+ public:
+  explicit AST_ADJ(Module_Handler *h, unsigned f) : mHandler(h), mFlags(f) {}
+  ~AST_ADJ() {}
+
+  void AdjustAST();
+};
+
+class AdjustASTVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+  AST_INFO       *mInfo;
+  AST_Util       *mUtil;
+  unsigned       mFlags;
+  bool           mUpdated;
+
+ public:
+  explicit AdjustASTVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h), mFlags(f), mUpdated(false) {
+      mInfo = h->GetINFO();
+      mInfo->SetNameAnonyStruct(true);
+      mUtil = h->GetUtil();
+    }
+  ~AdjustASTVisitor() = default;
+
+  std::unordered_map<unsigned, unsigned> mRenameMap;
+  void CheckAndRenameCppKeywords(TreeNode *node);
+  void AssignPseudoName(TreeNode *node);
+
+  DeclNode *VisitDeclNode(DeclNode *node);
+  ImportNode *VisitImportNode(ImportNode *node);
+  ExportNode *VisitExportNode(ExportNode *node);
+  CondBranchNode *VisitCondBranchNode(CondBranchNode *node);
+  ForLoopNode *VisitForLoopNode(ForLoopNode *node);
+  LambdaNode *VisitLambdaNode(LambdaNode *node);
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+  NamespaceNode *VisitNamespaceNode(NamespaceNode *node);
+  StructNode *VisitStructNode(StructNode *node);
+  StructLiteralNode *VisitStructLiteralNode(StructLiteralNode *node);
+  ClassNode *VisitClassNode(ClassNode *node);
+  InterfaceNode *VisitInterfaceNode(InterfaceNode *node);
+  FunctionNode *VisitFunctionNode(FunctionNode *node);
+  UserTypeNode *VisitUserTypeNode(UserTypeNode *node);
+  TypeAliasNode *VisitTypeAliasNode(TypeAliasNode *node);
+  LiteralNode *VisitLiteralNode(LiteralNode *node);
+  UnaOperatorNode *VisitUnaOperatorNode(UnaOperatorNode *node);
+  PrimArrayTypeNode *VisitPrimArrayTypeNode(PrimArrayTypeNode *node);
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_cfa.h b/src/MapleFE/astopt/include/ast_cfa.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4b65773184350b795ac3f891a43421fa315f854
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_cfa.h
@@ -0,0 +1,45 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_CFA_HEADER__
+#define __AST_CFA_HEADER__
+
+#include <stack>
+#include <utility>
+#include "ast_module.h"
+#include "ast.h"
+#include "ast_type.h"
+#include "gen_astvisitor.h"
+
+namespace maplefe {
+
+class AST_CFA {
+ private:
+  Module_Handler  *mHandler;
+  unsigned         mFlags;
+  std::unordered_set<unsigned> mReachableBbIdx;;
+
+ public:
+  explicit AST_CFA(Module_Handler *h, unsigned f) : mHandler(h), mFlags(f) {}
+  ~AST_CFA() {}
+
+  void ControlFlowAnalysis();
+  void CollectReachableBB();
+  void RemoveUnreachableBB();
+  void Dump();
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_cfg.h b/src/MapleFE/astopt/include/ast_cfg.h
new file mode 100644
index 0000000000000000000000000000000000000000..40fd2e9c4af8fafe3e10683b1d725625aff95cc4
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_cfg.h
@@ -0,0 +1,272 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_CFG_HEADER__
+#define __AST_CFG_HEADER__
+
+#include <utility>
+#include "ast_module.h"
+#include "ast.h"
+#include "ast_type.h"
+#include "gen_astvisitor.h"
+
+namespace maplefe {
+
+enum BBKind {
+  BK_Unknown,     // Uninitialized
+  BK_Uncond,      // BB for unconditional branch
+  BK_Block,       // BB for a block/compound statement
+  BK_Branch,      // BB ends up with a predicate for true/false branches
+  BK_LoopHeader,  // BB for a loop header of a for, for/in, for/of, while, or do/while statement
+  BK_Switch,      // BB for a switch statement
+  BK_Case,        // BB for a case in switch statement
+  BK_Try,         // BB for a try block
+  BK_Catch,       // BB for a catch block
+  BK_Finally,     // BB for a finally block
+  BK_Yield,       // Yield BB eneded with a yield statement
+  BK_Terminated,  // Return BB endded with a return/break/continue statement
+  BK_Join,        // BB at join point for loops and switch
+  BK_Join2,       // BB at join point for if-stmt and block
+};
+
+enum BBAttribute : unsigned {
+  AK_None     = 0,
+  AK_Entry    = 1 << 0,
+  AK_Exit     = 1 << 1,
+  AK_Break    = 1 << 2,
+  AK_Return   = 1 << 3,
+  AK_Throw    = 1 << 4,
+  AK_Cont     = 1 << 5,
+  AK_InLoop   = 1 << 6,
+  AK_HasCall  = 1 << 7,
+  AK_ALL      = 0xffffffff
+};
+
+inline BBAttribute operator|(BBAttribute x, BBAttribute y) {
+  return static_cast<BBAttribute>(static_cast<unsigned>(x) | static_cast<unsigned>(y));
+}
+inline BBAttribute operator&(BBAttribute x, BBAttribute y) {
+  return static_cast<BBAttribute>(static_cast<unsigned>(x) & static_cast<unsigned>(y));
+}
+
+using BBIndex = unsigned;
+class Module_Handler;
+class AST_AST;
+
+class CfgBB {
+ private:
+  BBKind                 mKind;
+  BBAttribute            mAttr;
+  BBIndex                mId;             // unique BB id
+  TreeNode              *mPredicate;      // a predicate for true/false branches
+  TreeNode              *mAuxNode;        // the auxiliary node of current BB
+  SmallList<TreeNode *>  mStatements;     // all statement nodes
+  SmallList<CfgBB *>     mSuccessors;     // for BK_Branch: [0] true branch, [1] false branch
+  SmallList<CfgBB *>     mPredecessors;
+
+  friend class AST_AST;
+  friend class AST_CFA;
+
+ public:
+  explicit CfgBB(BBKind k)
+    : mKind(k), mAttr(AK_None), mId(GetNextId()), mPredicate(nullptr), mAuxNode(nullptr) {}
+  ~CfgBB() {mStatements.Release(); mSuccessors.Release(); mPredecessors.Release();}
+
+  void   SetKind(BBKind k) {mKind = k;}
+  BBKind GetKind()         {return mKind;}
+
+  void    SetAttr(BBAttribute a)  {mAttr = mAttr | a;}
+  BBIndex GetAttr()               {return mAttr;}
+  bool    TestAttr(BBAttribute a) {return mAttr & a;}
+
+  void    SetId(BBIndex id) {mId = id;}
+  BBIndex GetId()           {return mId;}
+
+  void      SetPredicate(TreeNode *node) {mPredicate = node;}
+  TreeNode *GetPredicate()               {return mPredicate;}
+
+  void      SetAuxNode(TreeNode *node)  {mAuxNode = node;}
+  TreeNode *GetAuxNode()                {return mAuxNode;}
+
+  unsigned  GetStatementsNum()              {return mStatements.GetNum();}
+  TreeNode* GetStatementAtIndex(unsigned i) {return mStatements.ValueAtIndex(i);}
+
+  void AddStatement(TreeNode *stmt) {
+    if(mKind != BK_Terminated) {
+      mStatements.PushBack(stmt);
+      stmt->SetIsStmt();
+    }
+  }
+
+  void InsertStmtAfter(TreeNode *new_stmt, TreeNode *exist_stmt) {
+    mStatements.LocateValue(exist_stmt);
+    mStatements.InsertAfter(new_stmt);
+  }
+
+  void InsertStmtBefore(TreeNode *new_stmt, TreeNode *exist_stmt) {
+    mStatements.LocateValue(exist_stmt);
+    mStatements.InsertBefore(new_stmt);
+  }
+
+  void AddSuccessor(CfgBB *succ) {
+    if(mKind == BK_Terminated) {
+      return;
+    }
+    mSuccessors.PushBack(succ);
+    succ->mPredecessors.PushBack(this);
+  }
+  unsigned  GetSuccessorsNum()                     {return mSuccessors.GetNum();}
+  CfgBB *GetSuccessorAtIndex(unsigned i)   {return mSuccessors.ValueAtIndex(i);}
+  unsigned  GetPredecessorsNum()                   {return mPredecessors.GetNum();}
+  CfgBB *GetPredecessorAtIndex(unsigned i) {return mPredecessors.ValueAtIndex(i);}
+
+  static BBIndex GetLastId() {return GetNextId(false);}
+
+  void Dump();
+
+ private:
+  static BBIndex GetNextId(bool inc = true) {static BBIndex id = 0; return inc ? ++id : id; }
+};
+
+class CfgFunc {
+ private:
+  TreeNode             *mFuncNode;    // ModuleNode, FunctionNode or LambdaNode
+  SmallList<CfgFunc *>  mNestedFuncs; // nested functions
+  CfgFunc              *mParent;
+  CfgBB                *mEntryBB;
+  CfgBB                *mExitBB;
+  BBIndex               mLastBBId;
+
+ public:
+  explicit CfgFunc() : mFuncNode(nullptr), mParent(nullptr), mEntryBB(nullptr), mExitBB(nullptr) {}
+  ~CfgFunc() {mNestedFuncs.Release();}
+
+  void      SetFuncNode(TreeNode *func) {mFuncNode = func;}
+  TreeNode *GetFuncNode()               {return mFuncNode;}
+
+  const char *GetName() {
+    return mFuncNode->IsModule() ? "_init_" :
+      (mFuncNode->GetStrIdx() ? mFuncNode->GetName() : "_anonymous_");
+  }
+
+  void     AddNestedFunc(CfgFunc *func)     {mNestedFuncs.PushBack(func); func->SetParent(this);}
+  unsigned GetNestedFuncsNum()              {return mNestedFuncs.GetNum();}
+  CfgFunc *GetNestedFuncAtIndex(unsigned i) {return mNestedFuncs.ValueAtIndex(i);}
+
+  void     SetParent(CfgFunc *func) {mParent = func;}
+  CfgFunc *GetParent()              {return mParent;}
+
+  void   SetEntryBB(CfgBB *bb) {mEntryBB = bb; bb->SetAttr(AK_Entry);}
+  CfgBB *GetEntryBB()          {return mEntryBB;}
+
+  void   SetExitBB(CfgBB *bb)  {mExitBB = bb; bb->SetAttr(AK_Exit);}
+  CfgBB *GetExitBB()           {return mExitBB;}
+
+  void    SetLastBBId(BBIndex id) {mLastBBId = id;}
+  BBIndex GetLastBBId()           {return mLastBBId;}
+
+  void Dump();
+};
+
+class CfgBuilder : public AstVisitor {
+
+  using TargetLabel = unsigned;
+  using TargetBB = std::pair<CfgBB*, unsigned>;
+  using TargetBBStack = std::vector<TargetBB>;
+
+ private:
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+
+  CfgFunc   *mCurrentFunction;
+  CfgBB *mCurrentBB;
+
+  TargetBBStack  mBreakBBs;
+  TargetBBStack  mContinueBBs;
+  TargetBBStack  mThrowBBs;
+
+ public:
+  explicit CfgBuilder(Module_Handler *h, unsigned f)
+    : AstVisitor(false), mHandler(h), mFlags(f) {}
+  ~CfgBuilder() = default;
+
+  void Build();
+
+  // Create CfgFunc nodes for a module
+  CfgFunc *InitCfgFunc(ModuleNode *module);
+
+  CfgFunc *NewFunction(TreeNode *);
+  CfgBB   *NewBB(BBKind k);
+
+  static void Push(TargetBBStack &stack, CfgBB* bb, TreeNode *label);
+  static CfgBB *LookUp(TargetBBStack &stack, TreeNode *label);
+  static void Pop(TargetBBStack &stack);
+
+  void InitializeFunction(CfgFunc *func);
+  void FinalizeFunction();
+
+  // For function and lambda
+  FunctionNode *VisitFunctionNode(FunctionNode *node);
+  LambdaNode *VisitLambdaNode(LambdaNode *node);
+
+  // For class and interface
+  ClassNode *VisitClassNode(ClassNode *node);
+  InterfaceNode *VisitInterfaceNode(InterfaceNode *node);
+  StructNode *VisitStructNode(StructNode *node);
+
+  // For statements of control flow
+  ReturnNode *VisitReturnNode(ReturnNode *node);
+  CondBranchNode *VisitCondBranchNode(CondBranchNode *node);
+  ForLoopNode *VisitForLoopNode(ForLoopNode *node);
+  WhileLoopNode *VisitWhileLoopNode(WhileLoopNode *node);
+  DoLoopNode *VisitDoLoopNode(DoLoopNode *node);
+  ContinueNode *VisitContinueNode(ContinueNode *node);
+  BreakNode *VisitBreakNode(BreakNode *node);
+  SwitchNode *VisitSwitchNode(SwitchNode *node);
+  TryNode *VisitTryNode(TryNode *node);
+  ThrowNode *VisitThrowNode(ThrowNode *node);
+  BlockNode *VisitBlockNode(BlockNode *node);
+  NamespaceNode *VisitNamespaceNode(NamespaceNode *node);
+
+  // For statements of a BB
+  PassNode *VisitPassNode(PassNode *node);
+  TemplateLiteralNode *VisitTemplateLiteralNode(TemplateLiteralNode *node);
+  ImportNode *VisitImportNode(ImportNode *node);
+  ExportNode *VisitExportNode(ExportNode *node);
+  DeclNode *VisitDeclNode(DeclNode *node);
+  ParenthesisNode *VisitParenthesisNode(ParenthesisNode *node);
+  CastNode *VisitCastNode(CastNode *node);
+  ArrayElementNode *VisitArrayElementNode(ArrayElementNode *node);
+  VarListNode *VisitVarListNode(VarListNode *node);
+  ExprListNode *VisitExprListNode(ExprListNode *node);
+  UnaOperatorNode *VisitUnaOperatorNode(UnaOperatorNode *node);
+  BinOperatorNode *VisitBinOperatorNode(BinOperatorNode *node);
+  TerOperatorNode *VisitTerOperatorNode(TerOperatorNode *node);
+  InstanceOfNode *VisitInstanceOfNode(InstanceOfNode *node);
+  TypeOfNode *VisitTypeOfNode(TypeOfNode *node);
+  NewNode *VisitNewNode(NewNode *node);
+  DeleteNode *VisitDeleteNode(DeleteNode *node);
+  CallNode *VisitCallNode(CallNode *node);
+  AssertNode *VisitAssertNode(AssertNode *node);
+  UserTypeNode *VisitUserTypeNode(UserTypeNode *node);
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+  LiteralNode *VisitLiteralNode(LiteralNode *node);
+  TypeAliasNode *VisitTypeAliasNode(TypeAliasNode *node);
+  FieldNode *VisitFieldNode(FieldNode *node);
+
+  TreeNode *BaseTreeNode(TreeNode *node);
+};
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_common.h b/src/MapleFE/astopt/include/ast_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c25f1ca9f1e7553c799aefcba22a8f93d64c638
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_common.h
@@ -0,0 +1,42 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_COMMON_HEADER__
+#define __AST_COMMON_HEADER__
+
+namespace maplefe {
+
+#define DEFAULTVALUE 0xdeadbeef
+#define RENAMINGSUFFIX "__RENAMED"
+
+#define NOTYETIMPL(M) { if (mFlags & FLG_trace) { MNYI(M);        }}
+#define MSGNOLOC0(M)  { if (mFlags & FLG_trace_3) { MMSGNOLOC0(M);  }}
+#define MSGNOLOC(M,v) { if (mFlags & FLG_trace_3) { MMSGNOLOC(M,v); }}
+
+enum AST_Flags {
+  FLG_trace_1      = 0x00000001,
+  FLG_trace_2      = 0x00000002,
+  FLG_trace_3      = 0x00000004,
+  FLG_trace_4      = 0x00000008,
+  FLG_trace        = 0x0000000f,
+
+  FLG_emit_ts      = 0x00000010,
+  FLG_emit_ts_only = 0x00000020,
+  FLG_format_cpp   = 0x00000040,
+  FLG_no_imported  = 0x00000080,
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_dfa.h b/src/MapleFE/astopt/include/ast_dfa.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e232449f729595439d87b1c02c3d65e96cece52
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_dfa.h
@@ -0,0 +1,155 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_DFA_HEADER__
+#define __AST_DFA_HEADER__
+
+#include <stack>
+#include <utility>
+
+#include "stringpool.h"
+#include "ast_module.h"
+#include "ast.h"
+#include "ast_type.h"
+#include "ast_handler.h"
+#include "gen_astvisitor.h"
+
+namespace maplefe {
+
+// def positions: <stridx, nodeid>
+typedef std::pair<unsigned, unsigned> DefPosition;
+// map <bbid, BitVector>
+typedef std::unordered_map<unsigned, BitVector*> BVMap;
+
+class AST_DFA {
+ private:
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+  std::unordered_map<unsigned, unsigned> mVar2DeclMap; // var to decl, both NodeId
+
+  // stmt id
+  SmallVector<unsigned> mStmtIdVec;
+  std::unordered_map<unsigned, TreeNode*> mStmtId2StmtMap;
+  std::unordered_map<unsigned, CfgFunc*> mEntryBbId2FuncMap;
+
+  // def node id set
+  std::unordered_set<unsigned> mDefNodeIdSet;
+  // def and use id set: i in i++; i+=j;
+  std::unordered_set<unsigned> mDefUseNodeIdSet;
+  // def positions, def index
+  SmallVector<DefPosition> mDefPositionVec;
+  // use stridx to set of node id
+  std::unordered_map<unsigned, std::set<unsigned>> mUsePositionMap;
+
+  // followint maps with key BB id
+  BVMap mPrsvMap;
+  BVMap mGenMap;
+  BVMap mRchInMap; // reaching definition bit vector entering bb
+  BVMap mRchOutMap;
+
+  // def/use nid --> stmtid
+  std::unordered_map<unsigned, unsigned> mNodeId2StmtIdMap;
+  // stmtid --> bbid
+  std::unordered_map<unsigned, unsigned> mStmtId2BbIdMap;
+
+  // def stridx set
+  std::unordered_set<unsigned> mDefStrIdxSet;
+  // def-use : key is def node id to a set of use node id
+  std::unordered_map<unsigned, std::set<unsigned>> mDefUseMap;
+
+  friend class DefUseChainVisitor;
+
+ public:
+  explicit AST_DFA(Module_Handler *h, unsigned f) : mHandler(h), mFlags(f) {}
+  ~AST_DFA();
+
+  void DataFlowAnalysis();
+
+  void CollectInfo();
+  void CollectDefNodes();
+  void BuildBitVectors();
+  void BuildDefUseChain();
+
+  bool IsDef(unsigned nid) { return mDefNodeIdSet.find(nid) != mDefNodeIdSet.end();}
+  bool IsDefUse(unsigned nid) { return mDefUseNodeIdSet.find(nid) != mDefUseNodeIdSet.end();}
+  // return def stridx, return 0 if no def
+  unsigned GetDefStrIdx(TreeNode *node);
+  // return def nodeId, return 0 if no def
+  unsigned AddDef(TreeNode *node, unsigned &bitnum, unsigned bbid);
+
+  void SetNodeId2StmtId(unsigned nid, unsigned sid) { mNodeId2StmtIdMap[nid] = sid; }
+  unsigned GetStmtIdFromNodeId(unsigned id) { return mNodeId2StmtIdMap[id]; }
+  unsigned GetBbIdFromStmtId(unsigned id) { return mStmtId2BbIdMap[id]; }
+  TreeNode *GetStmtFromStmtId(unsigned id) { return mStmtId2StmtMap[id]; }
+  CfgBB *GetBbFromBbId(unsigned id) { return mHandler->GetBbFromBbId(id); }
+
+  void DumpDefPosition(unsigned idx, DefPosition pos);
+  void DumpDefPositionVec();
+  void DumpReachDefIn();
+
+  void DumpBV(BitVector *bv);
+  void DumpBVMap(BVMap &bvmap);
+  void DumpAllBVMaps();
+  void DumpDefUse();
+  void TestBV();
+  void Clear();
+};
+
+class CollectInfoVisitor : public AstVisitor {
+ private:
+  AST_DFA        *mDFA;
+  unsigned        mStmtIdx;
+  unsigned        mBbId;
+
+ public:
+  explicit CollectInfoVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mDFA(h->GetDFA()) {}
+  ~CollectInfoVisitor() = default;
+
+  void SetStmtIdx(unsigned id) { mStmtIdx = id; }
+  void SetBbId(unsigned id)    { mBbId    = id; }
+
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+};
+
+class DefUseChainVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+  AST_DFA        *mDFA;
+  unsigned        mFlags;
+  unsigned        mStmtIdx;
+  unsigned        mBbId;
+
+ public:
+  unsigned      mDefNodeId;
+  unsigned      mDefStrIdx;
+  unsigned      mReachDef;
+  unsigned      mReachNewDef;
+
+ public:
+  explicit DefUseChainVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h), mDFA(h->GetDFA()), mFlags(f) {}
+  ~DefUseChainVisitor() = default;
+
+  void SetStmtIdx(unsigned id) { mStmtIdx = id; }
+  void SetBbId(unsigned id)    { mBbId    = id; }
+  void VisitBB(unsigned bbid);
+
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+  BinOperatorNode *VisitBinOperatorNode(BinOperatorNode *node);
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_handler.h b/src/MapleFE/astopt/include/ast_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..42153f013fb46b771480e7cba2c63a86480d7f76
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_handler.h
@@ -0,0 +1,267 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_HANDLER_HEADER__
+#define __AST_HANDLER_HEADER__
+
+#include <stack>
+#include <utility>
+#include <unordered_map>
+#include <unordered_set>
+#include <cstring>
+#include <map>
+#include <climits>
+#include "ast_module.h"
+#include "ast.h"
+#include "astopt.h"
+#include "ast_cfg.h"
+#include "ast_type.h"
+#include "ast_common.h"
+#include "gen_astvisitor.h"
+
+namespace maplefe {
+
+class CfgBB;
+class CfgFunc;
+class AST_INFO;
+class AST_ADJ;
+class AST_CFA;
+class AST_DFA;
+class AST_SCP;
+class AST_Util;
+class AST_XXport;;
+class Module_Handler;
+class TypeInfer;
+class TypeTable;
+class AstOpt;
+
+using HandlerIndex = unsigned;
+const HandlerIndex HandlerNotFound = UINT_MAX;
+
+struct StrLess {
+  bool operator()(const char *p, const char *q) const {
+    return std::strcmp(p, q) < 0;
+  }
+};
+
+class AST_Handler {
+ private:
+  MemPool  mMemPool;    // Memory pool for all CfgFunc, CfgBB, etc.
+  AstOpt  *mAstOpt;
+  unsigned mSize;
+  unsigned mFlags;
+
+  // vector of all AST modules
+  SmallVector<Module_Handler *> mModuleHandlers;
+  Module_Handler *GetModuleHandler(ModuleNode *module);
+
+ public:
+  // mapping of mModuleHandlers index with its corresponding filename as its key
+  std::map<const char*, HandlerIndex, StrLess> mModuleHandlerMap;
+
+  explicit AST_Handler(unsigned f) : mSize(0), mFlags(f) {}
+  ~AST_Handler() {mMemPool.Release();}
+
+  MemPool *GetMemPool() {return &mMemPool;}
+
+  AstOpt *GetAstOpt() {return mAstOpt;}
+  void SetAstOpt(AstOpt *opt) {mAstOpt = opt;}
+
+  Module_Handler *GetModuleHandler(unsigned i) {return mModuleHandlers.ValueAtIndex(i);}
+  Module_Handler *GetModuleHandler(TreeNode *node);
+
+  unsigned GetSize() {return mSize;}
+
+  // If m does not exist in mModuleHandlerMap,
+  //    create an object of Module_Handler for module m
+  //    add this object to mModuleHandlers
+  //    map its corresponding filename and the index of this object in mModuleHandlers in mModuleHandlerMap
+  //    return true
+  // Otherwise,
+  //    return false
+  bool AddModule(ModuleNode *m);
+
+  // Return an index of mModuleHandlers if filename exists in mModuleHandlerMap, otherwise return HandlerNotFound
+  HandlerIndex GetHandlerIndex(const char *filename);
+};
+
+// Each source file is a module
+class Module_Handler {
+ private:
+  AST_Handler  *mASTHandler;
+  ModuleNode   *mASTModule;  // for an AST module
+  CfgFunc      *mCfgFunc;    // initial CfgFunc in module scope
+  AST_INFO     *mINFO;
+  AST_ADJ      *mADJ;
+  AST_SCP      *mSCP;
+  TypeInfer    *mTI;
+  AST_CFA      *mCFA;
+  AST_DFA      *mDFA;
+  AST_Util     *mUtil;
+  const char   *mOutputFilename;
+  unsigned      mHidx;       // handler index in AST_Handler
+
+  unsigned      mFlags;
+  bool            mIsTS;
+
+  std::unordered_map<unsigned, CfgBB *> mNodeId2BbMap;
+
+ public:
+  // module's ast function vector
+  std::vector<CfgFunc *> mModuleFuncs;
+  // all BBs
+  std::unordered_map<unsigned, CfgBB *> mBbId2BbMap;
+  // bbid vec - only reachable BBs
+  std::vector<unsigned> mBbIdVec;
+  // identifier node id to decl
+  std::unordered_map<unsigned, TreeNode *> mNodeId2Decl;
+  // array's element type: decl node id to typeid
+  std::unordered_map<unsigned, TypeId> mArrayDeclId2EleTypeIdMap;
+  // array's element typeidx: decl node id to typeidx
+  std::unordered_map<unsigned, unsigned> mArrayDeclId2EleTypeIdxMap;
+  // array literal's dim: decl node id to dim
+  std::unordered_map<unsigned, DimensionNode *> mArrayDeclId2DimMap;
+  // nodeid to used generator
+  std::unordered_map<unsigned, FunctionNode *> mGeneratorUsedMap;
+  // fields' nodeid set
+  std::unordered_set<unsigned> mDirectFieldSet;
+  // alias type, identifier node id
+  std::unordered_set<unsigned> mAliasTypeSet;
+
+ public:
+  explicit Module_Handler(unsigned f) :
+    mCfgFunc(nullptr),
+    mINFO(nullptr),
+    mADJ(nullptr),
+    mSCP(nullptr),
+    mTI(nullptr),
+    mCFA(nullptr),
+    mDFA(nullptr),
+    mUtil(nullptr),
+    mFlags(f) {}
+  ~Module_Handler();
+
+  void BasicAnalysis();
+  void CollectInfo();
+  void AdjustAST();
+  void ScopeAnalysis();
+  void TypeInference();
+  void BuildCFG();
+  void ControlFlowAnalysis();
+  void DataFlowAnalysis();
+
+  const char *GetOutputFilename()          {return mOutputFilename;}
+  void SetOutputFilename(const char *name) {mOutputFilename = name;}
+
+  void SetASTHandler(AST_Handler *h) {mASTHandler = h;}
+  AST_Handler *GetASTHandler()       {return mASTHandler;}
+
+  void SetASTModule(ModuleNode *mod) {mASTModule = mod;}
+  ModuleNode *GetASTModule()         {return mASTModule;}
+
+  MemPool *GetMemPool();
+
+  void     SetCfgFunc(CfgFunc *func)  {mCfgFunc = func;}
+  CfgFunc *GetCfgFunc()               {return mCfgFunc;}
+
+  void SetBbFromNodeId(unsigned id, CfgBB *bb) { mNodeId2BbMap[id] = bb; }
+  CfgBB *GetBbFromNodeId(unsigned id)          { return mNodeId2BbMap[id]; }
+
+  void SetBbFromBbId(unsigned id, CfgBB *bb) { mBbId2BbMap[id] = bb; }
+  CfgBB *GetBbFromBbId(unsigned id)          { return mBbId2BbMap[id]; }
+
+  unsigned GetFlags() {return mFlags;}
+  unsigned GetHidx() {return mHidx;}
+  AST_INFO *GetINFO() {return mINFO;}
+  AST_ADJ *GetADJ() {return mADJ;}
+  AST_CFA *GetCFA() {return mCFA;}
+  AST_DFA *GetDFA() {return mDFA;}
+  AST_SCP *GetSCP() {return mSCP;}
+  TypeInfer *GetTI() {return mTI;}
+  AST_Util *GetUtil() {return mUtil;}
+  AstOpt *GetAstOpt();
+  AST_XXport *GetASTXXport();
+
+  void SetHidx(unsigned idx) {mHidx = idx;}
+  void SetINFO(AST_INFO *p) {mINFO = p;}
+  void SetADJ(AST_ADJ *p) {mADJ = p;}
+  void SetCFA(AST_CFA *p) {mCFA = p;}
+  void SetDFA(AST_DFA *p) {mDFA = p;}
+  void SetSCP(AST_SCP *p) {mSCP = p;}
+  void SetTI(TypeInfer *p) {mTI = p;}
+  void SetUtil(AST_Util *p) {mUtil = p;}
+  void SetIsTS(bool b) {mIsTS = b;}
+
+  // deep true  : find Decl in imported module as well
+  //      false : find Decl in current module only
+  TreeNode *FindDecl(IdentifierNode *node, bool deep = false);
+
+  TreeNode *FindType(IdentifierNode *node);
+  TreeNode *FindFunc(TreeNode *node);
+
+  void AddDirectField(TreeNode *node);
+  bool IsDirectField(TreeNode *node);
+
+  bool IsFromLambda(TreeNode *node);
+  bool IsDef(TreeNode *node);
+  bool IsTS() {return mIsTS;}
+
+  void AddNodeId2DeclMap(unsigned nid, TreeNode *node) {
+    mNodeId2Decl[nid] = node;
+  }
+
+  void AddAliasType(unsigned nid) { mAliasTypeSet.insert(nid); }
+  bool isAliasType(unsigned nid) {
+    return mAliasTypeSet.find(nid) != mAliasTypeSet.end();
+  }
+  bool isAliasType(TreeNode *node) { return isAliasType(node->GetNodeId()); }
+
+  template <typename T>
+  T *NewTreeNode() {
+    T *node = (T*)gTreePool.NewTreeNode(sizeof(T));
+    new (node) T();
+    AstOpt *opt = mASTHandler->GetAstOpt();
+    opt->AddNodeId2NodeMap(node);
+    return node;
+  }
+
+  Module_Handler *GetModuleHandler(unsigned i) {return mASTHandler->GetModuleHandler(i);}
+  Module_Handler *GetModuleHandler(TreeNode *node) {return mASTHandler->GetModuleHandler(node);}
+
+  // array's element typeid
+  TypeId GetArrayElemTypeId(unsigned nid);
+  void SetArrayElemTypeId(unsigned nid, TypeId tid);
+  unsigned GetArrayElemTypeIdx(unsigned nid);
+  void SetArrayElemTypeIdx(unsigned nid, unsigned tidx);
+  DimensionNode *GetArrayDim(unsigned nid);
+  void SetArrayDim(unsigned nid, DimensionNode *dim);
+
+  // used generator
+  void AddGeneratorUsed(unsigned nid, FunctionNode *func);
+  bool IsGeneratorUsed(unsigned nid);
+  FunctionNode *GetGeneratorUsed(unsigned nid);
+  bool UpdateGeneratorUsed(unsigned target, unsigned src);
+
+  // API to check a node is c++ field which satisfy both:
+  // 1. direct field
+  // 2. its name is valid in c++
+  bool IsCppField(TreeNode *node);
+
+  void Dump(char *msg);
+  void DumpArrayElemTypeIdMap();
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_info.h b/src/MapleFE/astopt/include/ast_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..83a0fc37122e10231fdde2f6d7050bd0eaf908ff
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_info.h
@@ -0,0 +1,197 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_INFO_HEADER__
+#define __AST_INFO_HEADER__
+
+#include <stack>
+#include <utility>
+#include <unordered_map>
+#include <unordered_set>
+#include "ast_module.h"
+#include "ast.h"
+#include "ast_type.h"
+#include "gen_astvisitor.h"
+
+namespace maplefe {
+
+class FindStrIdxVisitor;
+
+class AST_INFO {
+ private:
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+  unsigned        mNum;
+  bool            mNameAnonyStruct;
+  unsigned        mPass;
+  FindStrIdxVisitor *mStrIdxVisitor;
+
+  std::unordered_set<unsigned> mReachableBbIdx;;
+  std::unordered_map<unsigned, std::unordered_set<TreeNode *>> mFieldNum2StructNodeMap;
+  std::unordered_map<unsigned, SmallVector<TreeNode*>> mStructId2FieldsMap;
+  std::unordered_map<unsigned, TreeNode *> mStrIdx2StructMap;
+  std::unordered_set<unsigned> mTypeParamStrIdxSet;
+  std::unordered_set<unsigned> mWithTypeParamNodeSet;
+  std::unordered_set<unsigned> mWithThisFuncSet;;
+  std::unordered_set<unsigned> mFromLambda;
+  std::unordered_map<unsigned, unsigned> mStrIdx2TypeIdxMap;
+
+  void AddField(unsigned nid, TreeNode *node);
+
+ public:
+  explicit AST_INFO(Module_Handler *h, unsigned f) : mHandler(h), mFlags(f), mNum(1),
+           mNameAnonyStruct(false) {}
+  ~AST_INFO() {}
+
+  void CollectInfo();
+
+  unsigned GetPass() { return mPass; }
+  TypeId GetTypeId(TreeNode *node);
+  unsigned GetFieldsSize(TreeNode *node, bool native = false);
+  TreeNode *GetField(TreeNode *node, unsigned i, bool native = false);
+  void AddField(TreeNode *container, TreeNode *node);
+  TreeNode *GetField(unsigned nid, unsigned stridx);
+  unsigned GetSuperSize(TreeNode *node, unsigned idx);
+  TreeNode *GetSuper(TreeNode *node, unsigned i, unsigned idx);
+
+  void SetStrIdx2Struct(unsigned stridx, TreeNode *node) { mStrIdx2StructMap[stridx] = node; }
+  TreeNode *GetStructFromStrIdx(unsigned stridx) { return mStrIdx2StructMap[stridx]; }
+
+  TreeNode *GetCanonicStructNode(TreeNode *node);
+
+  IdentifierNode *CreateIdentifierNode(unsigned stridx);
+  UserTypeNode *CreateUserTypeNode(unsigned stridx, ASTScope *scope = NULL);
+  UserTypeNode *CreateUserTypeNode(IdentifierNode *node);
+  TypeAliasNode *CreateTypeAliasNode(TreeNode *to, TreeNode *from);
+  StructNode *CreateStructFromStructLiteral(StructLiteralNode *node);
+
+  unsigned GetAnonymousName();
+  TreeNode *GetAnonymousStruct(TreeNode *node);
+
+  bool IsInterface(TreeNode *node);
+  bool IsTypeIdCompatibleTo(TypeId field, TypeId target);
+  bool IsTypeCompatible(TreeNode *node1, TreeNode *node2);
+  bool IsFieldCompatibleTo(TreeNode *from, TreeNode *to);
+
+  void SetNameAnonyStruct(bool b) { mNameAnonyStruct = b; }
+  bool GetNameAnonyStruct() { return mNameAnonyStruct; }
+
+  template <typename T1, typename T2> void SortFields(T1 *node);
+  template <typename T1> void ExtendFields(T1 *node, TreeNode *sup);
+
+  bool WithStrIdx(TreeNode *node, unsigned stridx);
+  bool WithTypeParam(TreeNode *node);
+  bool WithTypeParamFast(TreeNode *node);
+  void InsertTypeParamStrIdx(unsigned stridx) { mTypeParamStrIdxSet.insert(stridx); }
+  void InsertWithTypeParamNode(TreeNode *node) { mWithTypeParamNodeSet.insert(node->GetNodeId()); }
+
+  bool WithThis(TreeNode *node);
+  void InsertWithThisFunc(TreeNode *node) { mWithThisFuncSet.insert(node->GetNodeId()); }
+  bool IsFuncBodyUseThis(TreeNode *node) { return mWithThisFuncSet.find(node->GetNodeId())!= mWithThisFuncSet.end(); }
+
+  bool WithSuper(TreeNode *node);
+
+  void SetTypeId(TreeNode *node, TypeId tid);
+  void SetTypeIdx(TreeNode *node, unsigned tidx);
+
+  void AddFromLambda(unsigned nid) { mFromLambda.insert(nid); }
+  bool IsFromLambda(unsigned nid) { return mFromLambda.find(nid) != mFromLambda.end(); }
+
+  void AddBuiltInTypes();
+  bool IsBuiltInType(TreeNode *node);
+  unsigned GetBuiltInTypeIdx(unsigned stridx);
+  unsigned GetBuiltInTypeIdx(TreeNode *node);
+};
+
+class FillNodeInfoVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+  AST_INFO       *mInfo;
+
+ public:
+  explicit FillNodeInfoVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h) {
+      mInfo= mHandler->GetINFO();
+    }
+  ~FillNodeInfoVisitor() = default;
+
+  LiteralNode *VisitLiteralNode(LiteralNode *node);
+  PrimTypeNode *VisitPrimTypeNode(PrimTypeNode *node);
+  UserTypeNode *VisitUserTypeNode(UserTypeNode *node);
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+  FunctionNode *VisitFunctionNode(FunctionNode *node);
+};
+
+class ClassStructVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+  AST_INFO       *mInfo;
+
+ public:
+  explicit ClassStructVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h) {
+      mInfo= mHandler->GetINFO();
+    }
+  ~ClassStructVisitor() = default;
+
+  StructLiteralNode *VisitStructLiteralNode(StructLiteralNode *node);
+  StructNode *VisitStructNode(StructNode *node);
+  ClassNode *VisitClassNode(ClassNode *node);
+  InterfaceNode *VisitInterfaceNode(InterfaceNode *node);
+  TypeParameterNode *VisitTypeParameterNode(TypeParameterNode *node);
+  FunctionNode *VisitFunctionNode(FunctionNode *node);
+};
+
+class FunctionVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+  AST_INFO       *mInfo;
+
+ public:
+  explicit FunctionVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h) {
+      mInfo= mHandler->GetINFO();
+    }
+  ~FunctionVisitor() = default;
+
+  FunctionNode *VisitFunctionNode(FunctionNode *node);
+};
+
+class FindStrIdxVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+  AST_INFO       *mInfo;
+  unsigned       mStrIdx;
+  bool           mCheckThis;
+  bool           mFound;
+
+ public:
+  explicit FindStrIdxVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h), mStrIdx(0),
+      mCheckThis(false), mFound(false) {
+      mInfo = mHandler->GetINFO();
+    }
+  ~FindStrIdxVisitor() = default;
+
+  void ResetFound() { mFound = false; }
+  void SetStrIdx(unsigned stridx) { mStrIdx = stridx; }
+  void SetCheckThis(bool b = true) { mCheckThis = b; }
+  bool GetFound() { return mFound; }
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+  LiteralNode *VisitLiteralNode(LiteralNode *node);
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_scp.h b/src/MapleFE/astopt/include/ast_scp.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a9a7124a2adbd4d89b4da617fa21fbb57763f6a
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_scp.h
@@ -0,0 +1,173 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_SCP_HEADER__
+#define __AST_SCP_HEADER__
+
+#include <stack>
+#include <deque>
+#include <utility>
+
+#include "stringpool.h"
+#include "ast_module.h"
+#include "ast.h"
+#include "ast_type.h"
+#include "ast_handler.h"
+#include "gen_astvisitor.h"
+
+namespace maplefe {
+
+class AST_SCP {
+ private:
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+
+ public:
+  explicit AST_SCP(Module_Handler *h, unsigned f) : mHandler(h), mFlags(f) {}
+  ~AST_SCP() {};
+
+  void ScopeAnalysis();
+
+  void BuildScope();
+  void RenameVar();
+  void AdjustASTWithScope();
+};
+
+class BuildScopeBaseVisitor : public AstVisitor {
+ public:
+  std::stack<ASTScope *> mScopeStack;
+  std::stack<ASTScope *> mUserScopeStack;
+
+ public:
+  explicit BuildScopeBaseVisitor(unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base) {}
+  ~BuildScopeBaseVisitor() = default;
+
+#undef  NODEKIND
+#define NODEKIND(K) virtual K##Node *Visit##K##Node(K##Node *node) {\
+  ASTScope *scope = mScopeStack.top(); \
+  node->SetScope(scope); \
+  (void) AstVisitor::Visit##K##Node(node); \
+  return node; \
+}
+#include "ast_nk.def"
+};
+
+class BuildScopeVisitor : public BuildScopeBaseVisitor {
+ private:
+  Module_Handler *mHandler;
+  ModuleNode     *mASTModule;
+  unsigned        mFlags;
+  bool            mRunIt;
+  AST_XXport     *mXXport;
+
+  // stridx to scope map for struct/class
+  std::unordered_map<unsigned, ASTScope *> mStrIdx2ScopeMap;;
+
+  std::unordered_map<unsigned, std::unordered_set<unsigned>> mScope2DeclsMap;
+  std::unordered_map<unsigned, std::unordered_set<unsigned>> mScope2ImportedDeclsMap;
+  std::unordered_map<unsigned, std::unordered_set<unsigned>> mScope2ExportedDeclsMap;
+  std::unordered_map<unsigned, std::unordered_set<unsigned>> mScope2TypesMap;
+
+ public:
+  explicit BuildScopeVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : BuildScopeBaseVisitor(f, base), mHandler(h), mFlags(f) {
+      mASTModule = mHandler->GetASTModule();
+      mXXport = h->GetASTXXport();
+    }
+  ~BuildScopeVisitor() = default;
+
+  bool GetRunIt() { return mRunIt; }
+  void SetRunIt(bool b) { mRunIt = b; }
+
+  void InitInternalTypes();
+  ClassNode *AddClass(unsigned stridx, unsigned tyidx = 0);
+  FunctionNode *AddFunction(std::string name);
+
+  void AddType(ASTScope *scope, TreeNode *node);
+  void AddImportedDecl(ASTScope *scope, TreeNode *node);
+  void AddExportedDecl(ASTScope *scope, TreeNode *node);
+  void AddDecl(ASTScope *scope, TreeNode *node);
+  void AddTypeAndDecl(ASTScope *scope, TreeNode *node);
+  ASTScope *NewScope(ASTScope *parent, TreeNode *node);
+
+  void AddScopeMap(unsigned stridx, ASTScope *scope) { mStrIdx2ScopeMap[stridx] = scope; }
+
+  // scope nodes
+  BlockNode *VisitBlockNode(BlockNode *node);
+  FunctionNode *VisitFunctionNode(FunctionNode *node);
+  LambdaNode *VisitLambdaNode(LambdaNode *node);
+  ClassNode *VisitClassNode(ClassNode *node);
+  StructNode *VisitStructNode(StructNode *node);
+  StructLiteralNode *VisitStructLiteralNode(StructLiteralNode *node);
+  InterfaceNode *VisitInterfaceNode(InterfaceNode *node);
+  NamespaceNode *VisitNamespaceNode(NamespaceNode *node);
+  ForLoopNode *VisitForLoopNode(ForLoopNode *node);
+  TryNode *VisitTryNode(TryNode *node);
+  CatchNode *VisitCatchNode(CatchNode *node);
+  FinallyNode *VisitFinallyNode(FinallyNode *node);
+
+  FieldNode *VisitFieldNode(FieldNode *node);
+  TypeParameterNode *VisitTypeParameterNode(TypeParameterNode *node);
+
+  // related node with scope : decl, type
+  DeclNode *VisitDeclNode(DeclNode *node);
+  UserTypeNode *VisitUserTypeNode(UserTypeNode *node);
+  TypeAliasNode *VisitTypeAliasNode(TypeAliasNode *node);
+  ImportNode *VisitImportNode(ImportNode *node);
+  ExportNode *VisitExportNode(ExportNode *node);
+};
+
+class RenameVarVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+  ModuleNode     *mASTModule;
+  AstOpt         *mAstOpt;
+  unsigned        mFlags;
+
+ public:
+  unsigned        mPass;
+  unsigned        mOldStrIdx;
+  unsigned        mNewStrIdx;
+  std::unordered_map<unsigned, std::deque<unsigned>> mStridx2DeclIdMap;
+
+ public:
+  explicit RenameVarVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h), mFlags(f) {
+      mASTModule = mHandler->GetASTModule();
+      mAstOpt = mHandler->GetASTHandler()->GetAstOpt();
+    }
+  ~RenameVarVisitor() = default;
+
+  bool SkipRename(IdentifierNode *node);
+  bool IsFuncArg(FunctionNode *func, IdentifierNode *node);
+  void InsertToStridx2DeclIdMap(unsigned stridx, IdentifierNode *node);
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+};
+
+class AdjustASTWithScopeVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+
+ public:
+  explicit AdjustASTWithScopeVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h) {}
+  ~AdjustASTWithScopeVisitor() = default;
+
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_ti.h b/src/MapleFE/astopt/include/ast_ti.h
new file mode 100644
index 0000000000000000000000000000000000000000..ece38d68dcbe7e6257562c68bfc23f37383b231b
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_ti.h
@@ -0,0 +1,232 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_TYPE_INFERENCE_HEADER__
+#define __AST_TYPE_INFERENCE_HEADER__
+
+#include <stack>
+#include <utility>
+#include "ast_module.h"
+#include "ast.h"
+#include "ast_type.h"
+#include "gen_astvisitor.h"
+#include "ast_common.h"
+
+namespace maplefe {
+
+class Module_Handler;
+
+class TypeInfer {
+ private:
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+
+ public:
+  explicit TypeInfer(Module_Handler *h, unsigned f) : mHandler(h), mFlags(f) {}
+  ~TypeInfer() {}
+
+  void TypeInference();
+  void CheckType();
+};
+
+class BuildIdNodeToDeclVisitor : public AstVisitor {
+  Module_Handler *mHandler;
+
+  public:
+  explicit BuildIdNodeToDeclVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h) {}
+  ~BuildIdNodeToDeclVisitor() = default;
+
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+};
+
+class BuildIdDirectFieldVisitor : public AstVisitor {
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+
+  public:
+  explicit BuildIdDirectFieldVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h), mFlags(f) {}
+  ~BuildIdDirectFieldVisitor() = default;
+
+  TreeNode *GetParentVarClass(TreeNode *node);
+  Module_Handler *GetHandler(TreeNode *node);
+
+  FieldNode *VisitFieldNode(FieldNode *node);
+  FieldLiteralNode *VisitFieldLiteralNode(FieldLiteralNode *node);
+  ArrayElementNode *VisitArrayElementNode(ArrayElementNode *node);
+  void Dump();
+};
+
+class TypeInferBaseVisitor : public AstVisitor {
+ public:
+  explicit TypeInferBaseVisitor(unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base) {}
+  ~TypeInferBaseVisitor() = default;
+
+#undef  NODEKIND
+#define NODEKIND(K) virtual K##Node *Visit##K##Node(K##Node *node) { \
+  (void) AstVisitor::Visit##K##Node(node); \
+  return node; \
+}
+#include "ast_nk.def"
+};
+
+class ChangeTypeIdxVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+  unsigned        mStrIdx;
+  unsigned        mTypeIdx;
+
+ public:
+  explicit ChangeTypeIdxVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h) {}
+  ~ChangeTypeIdxVisitor() = default;
+
+  void Setup(unsigned stridx, unsigned tidx) { mStrIdx = stridx; mTypeIdx = tidx;}
+
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+};
+
+class TypeInferVisitor : public TypeInferBaseVisitor {
+ private:
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+  bool            mUpdated;
+  AST_INFO       *mInfo;
+  AST_XXport     *mXXport;
+  AstOpt         *mAstOpt;
+
+  ChangeTypeIdxVisitor *mChangeTypeIdxVisitor;
+
+  std::unordered_map<unsigned, std::unordered_set<TreeNode *>> mParam2ArgArrayDeclMap;;
+
+  // func nodeid to typeidx
+  std::unordered_map<unsigned, unsigned> mFuncIsNodeMap;;
+  std::unordered_map<unsigned, std::unordered_set<unsigned>> mCbFuncIsDone;
+
+ public:
+  explicit TypeInferVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : TypeInferBaseVisitor(f, base), mHandler(h), mFlags(f) {
+      mChangeTypeIdxVisitor = new ChangeTypeIdxVisitor(h, f, true);
+      mInfo = h->GetINFO();
+      mXXport = h->GetASTXXport();
+      mAstOpt = h->GetAstOpt();
+    }
+
+  ~TypeInferVisitor() = default;
+
+  bool IsPrimTypeId(TypeId tid);
+
+  bool GetUpdated() {return mUpdated;}
+  void SetUpdated(bool b = true) {mUpdated = b;}
+
+  void SetTypeId(TreeNode *node, TypeId tid);
+  void SetTypeId(TreeNode *node1, TreeNode *node2);
+  void UpdateTypeId(TreeNode *node, TypeId tid);
+  void UpdateTypeId(TreeNode *node1, TreeNode *node2);
+
+  void SetTypeIdx(TreeNode *node, unsigned tidx);
+  void SetTypeIdx(TreeNode *node1, TreeNode *node2);
+  void UpdateTypeIdx(TreeNode *node, unsigned tidx);
+  void UpdateTypeIdx(TreeNode *node1, TreeNode *node2);
+
+  void UpdateFuncRetTypeId(FunctionNode *node, TypeId tid, unsigned tidx);
+  void UpdateTypeUseNode(TreeNode *target, TreeNode *input);
+  void UpdateArgArrayDecls(unsigned nid, TypeId tid);
+  void UpdateArrayElemTypeMap(TreeNode *node, TypeId tid, unsigned tidx);
+  void UpdateArrayDimMap(TreeNode *node, DimensionNode *dim);
+  bool UpdateVarTypeWithInit(TreeNode *var, TreeNode *init);
+  TypeId GetArrayElemTypeId(TreeNode *node);
+  unsigned GetArrayElemTypeIdx(TreeNode *node);
+
+  TypeId MergeTypeId(TypeId tia, TypeId tib);
+  unsigned MergeTypeIdx(unsigned tia, unsigned tib);
+
+  bool IsArray(TreeNode *node);
+  // refer to shared/include/supported_types.def
+  bool IsPrimTypeIdx(unsigned tidx) { return tidx > 0 && tidx < TY_Void; }
+
+  PrimTypeNode *GetOrClonePrimTypeNode(PrimTypeNode *node, TypeId tid);
+
+  TreeNode *VisitClassField(TreeNode *node);
+
+  ArrayElementNode *VisitArrayElementNode(ArrayElementNode *node);
+  ArrayLiteralNode *VisitArrayLiteralNode(ArrayLiteralNode *node);
+  AsTypeNode *VisitAsTypeNode(AsTypeNode *node);
+  BinOperatorNode *VisitBinOperatorNode(BinOperatorNode *node);
+  CallNode *VisitCallNode(CallNode *node);
+  CastNode *VisitCastNode(CastNode *node);
+  ClassNode *VisitClassNode(ClassNode *node);
+  CondBranchNode *VisitCondBranchNode(CondBranchNode *node);
+  DeclNode *VisitDeclNode(DeclNode *node);
+  ExportNode *VisitExportNode(ExportNode *node);
+  FieldLiteralNode *VisitFieldLiteralNode(FieldLiteralNode *node);
+  FieldNode *VisitFieldNode(FieldNode *node);
+  ForLoopNode *VisitForLoopNode(ForLoopNode *node);
+  FunctionNode *VisitFunctionNode(FunctionNode *node);
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+  ImportNode *VisitImportNode(ImportNode *node);
+  InterfaceNode *VisitInterfaceNode(InterfaceNode *node);
+  IsNode *VisitIsNode(IsNode *node);
+  LambdaNode *VisitLambdaNode(LambdaNode *node);
+  LiteralNode *VisitLiteralNode(LiteralNode *node);
+  NewNode *VisitNewNode(NewNode *node);
+  ReturnNode *VisitReturnNode(ReturnNode *node);
+  StructLiteralNode *VisitStructLiteralNode(StructLiteralNode *node);
+  StructNode *VisitStructNode(StructNode *node);
+  TemplateLiteralNode *VisitTemplateLiteralNode(TemplateLiteralNode *node);
+  TerOperatorNode *VisitTerOperatorNode(TerOperatorNode *node);
+  TypeAliasNode *VisitTypeAliasNode(TypeAliasNode *node);
+  TypeOfNode *VisitTypeOfNode(TypeOfNode *node);
+  UnaOperatorNode *VisitUnaOperatorNode(UnaOperatorNode *node);
+  UserTypeNode *VisitUserTypeNode(UserTypeNode *node);
+};
+
+class ShareUTVisitor : public AstVisitor {
+ private:
+  std::stack<ASTScope *> mScopeStack;
+
+ public:
+  explicit ShareUTVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base) {}
+  ~ShareUTVisitor() = default;
+
+  void Push(ASTScope *scope) { mScopeStack.push(scope); }
+  void Pop() { mScopeStack.pop(); }
+
+  UserTypeNode *VisitUserTypeNode(UserTypeNode *node);
+};
+
+class CheckTypeVisitor : public AstVisitor {
+ private:
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+
+  std::stack<ASTScope *> mScopeStack;
+
+ public:
+  explicit CheckTypeVisitor(Module_Handler *h, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mHandler(h), mFlags(f) {}
+  ~CheckTypeVisitor() = default;
+
+  // check if typeid "tid" is compatible with "target"
+  bool IsCompatible(TypeId tid, TypeId target);
+
+  IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_util.h b/src/MapleFE/astopt/include/ast_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2a39d40d31ce275deb9bcf829424acbaca230bd
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_util.h
@@ -0,0 +1,55 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+//                This is the interface to translate AST to C++
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __AST_UTIL_HEADER__
+#define __AST_UTIL_HEADER__
+
+#include <unordered_set>
+
+namespace maplefe {
+
+class Module_Handler;
+
+class AST_Util {
+ private:
+  Module_Handler *mHandler;
+  unsigned        mFlags;
+
+  std::unordered_set<unsigned> mCppKeywords;
+
+  void BuildCppKeyWordSet();
+
+ public:
+  explicit AST_Util(Module_Handler *h, unsigned f) : mHandler(h), mFlags(f) {
+    BuildCppKeyWordSet();
+  }
+  ~AST_Util() {}
+
+  bool IsDirectField(TreeNode *node);
+  bool IsCppKeyWord(unsigned stridx);
+  bool IsCppKeyWord(std::string name);
+  bool IsCppName(std::string name);
+  bool IsCppField(TreeNode *node);
+
+  void SetTypeId(TreeNode *node, TypeId tid);
+  void SetTypeIdx(TreeNode *node, unsigned tidx);
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/ast_xxport.h b/src/MapleFE/astopt/include/ast_xxport.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5f99e7352f721b88d1f4db931fd762acdd18be5
--- /dev/null
+++ b/src/MapleFE/astopt/include/ast_xxport.h
@@ -0,0 +1,166 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_XXPORT_HEADER__
+#define __AST_XXPORT_HEADER__
+
+#include <list>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <set>
+#include <algorithm>
+#include "ast_module.h"
+#include "ast.h"
+#include "gen_astvisitor.h"
+
+namespace maplefe {
+
+class AstOpt;
+class AST_Handler;
+class Module_Handler;
+
+class XXportInfo {
+ public:
+  unsigned mModuleStrIdx;
+  unsigned mXXportNodeId;
+  unsigned mDefaultNodeId;
+  bool     mEverything;
+  std::set<std::pair<unsigned, unsigned>> mNodeIdPairs;
+
+ public:
+  explicit XXportInfo(unsigned stridx, unsigned nid) :
+    mModuleStrIdx(stridx), mXXportNodeId(nid), mDefaultNodeId(0), mEverything(false) {}
+  ~XXportInfo() = default;
+
+  void SetEverything() {mEverything = true;}
+  void Dump();
+};
+
+class AST_XXport {
+ private:
+  AstOpt      *mAstOpt;
+  AST_Handler *mASTHandler;
+  unsigned     mFlags;
+
+  std::list<unsigned> mHandlersIdxInOrder;
+  std::unordered_map<unsigned, std::unordered_set<unsigned>> mHandlerIdx2DependentHandlerIdxMap;
+  std::unordered_map<unsigned, unsigned> mStrIdx2HandlerIdxMap;
+
+  std::unordered_map<unsigned, unsigned> mIdStrIdx2ModuleStrIdxMap;
+
+ public:
+  // module handler idx to set of XXportInfo
+  std::unordered_map<unsigned, std::unordered_set<XXportInfo *>> mImports;
+  std::unordered_map<unsigned, std::unordered_set<XXportInfo *>> mExports;
+
+  // module handler idx to import/export nodes in the module
+  std::unordered_map<unsigned, std::vector<ImportNode *>> mImportNodeSets;
+  std::unordered_map<unsigned, std::vector<ExportNode *>> mExportNodeSets;
+
+  std::unordered_map<unsigned, std::vector<unsigned>> mImportedDeclIds;
+  std::unordered_map<unsigned, std::vector<unsigned>> mExportedDeclIds;
+
+ public:
+  explicit AST_XXport(AstOpt *o, unsigned f);
+  ~AST_XXport() {}
+
+  unsigned GetModuleNum();
+
+  void BuildModuleOrder();
+
+  void SetModuleStrIdx();
+  void CollectXXportNodes();
+
+  TreeNode *GetTarget(TreeNode *node);
+  std::string GetTargetFilename(unsigned hidx, TreeNode *node);
+  void UpdateDependency(unsigned hidx, TreeNode *node);
+  void AddHandler();
+
+  void SortHandler();
+
+  void CollectXXportInfo(unsigned hidx);
+  void CollectImportInfo(unsigned hidx);
+  void CollectExportInfo(unsigned hidx);
+
+  void AddHandlerIdx2DependentHandlerIdxMap(unsigned hdlIdx, unsigned depHdlIdx) {
+    mHandlerIdx2DependentHandlerIdxMap[hdlIdx].insert(depHdlIdx);
+  }
+
+  unsigned GetHandleIdxFromStrIdx(unsigned stridx);
+
+  // check if node with id is imported decl
+  bool IsImportedDeclId(unsigned hidx, unsigned id) {
+    return (std::find(mImportedDeclIds[hidx].begin(),
+                     mImportedDeclIds[hidx].end(), id) != mImportedDeclIds[hidx].end());
+  }
+
+  // check if node with id is exported decl
+  bool IsExportedDeclId(unsigned hidx, unsigned id) {
+    return (std::find(mExportedDeclIds[hidx].begin(),
+                     mExportedDeclIds[hidx].end(), id) != mExportedDeclIds[hidx].end());
+  }
+
+  bool IsImportedExportedDeclId(unsigned hidx, unsigned id) {
+    return IsImportedDeclId(hidx, id) || IsExportedDeclId(hidx, id);
+  }
+
+  void AddImportedDeclIds(unsigned hidx, unsigned nid) {mImportedDeclIds[hidx].push_back(nid);}
+  void AddExportedDeclIds(unsigned hidx, unsigned nid) {mExportedDeclIds[hidx].push_back(nid);}
+
+  TreeNode *FindExportedDecl(unsigned hidx, unsigned stridx);
+
+  // get stridx of M from M.get()
+  unsigned ExtractTargetStrIdx(TreeNode *node);
+
+  // get/set full module file name stridx of M.ts from an identifier of that module M
+  unsigned GetModuleStrIdxFromIdStrIdx(unsigned stridx) {return mIdStrIdx2ModuleStrIdxMap[stridx];}
+  void SetIdStrIdx2ModuleStrIdx(unsigned id, unsigned mod) {mIdStrIdx2ModuleStrIdxMap[id] = mod;}
+
+  // find default exported node in handler
+  TreeNode *GetExportedDefault(unsigned hstridx);
+
+  // find exported node of given name in handler hidx
+  TreeNode *GetExportedNamedNode(unsigned hidx, unsigned stridx);
+
+  // find the exported node in exporting module given imported node
+  // hidx is the handler index of node with index nid
+  TreeNode *GetExportedNodeFromImportedNode(unsigned hidx, unsigned nid);
+
+  // get identifier from node
+  TreeNode *GetIdentifier(TreeNode *node);
+
+  void Dump();
+};
+
+class XXportBasicVisitor : public AstVisitor {
+ private:
+  AST_XXport     *mASTXXport;
+  unsigned       mHandlerIdx;
+
+ public:
+  std::unordered_set<ModuleNode *> mImported;
+
+ public:
+  explicit XXportBasicVisitor(AST_XXport *xx, Module_Handler *h, unsigned i, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mASTXXport(xx), mHandlerIdx(i) {}
+  ~XXportBasicVisitor() = default;
+
+  ImportNode *VisitImportNode(ImportNode *node);
+  ExportNode *VisitExportNode(ExportNode *node);
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/astopt.h b/src/MapleFE/astopt/include/astopt.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a5fd6e144fbc8c99b0547c7910bfb0b6e87698b
--- /dev/null
+++ b/src/MapleFE/astopt/include/astopt.h
@@ -0,0 +1,110 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+//                This is the interface to translate AST to C++
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __ASTOPT_HEADER__
+#define __ASTOPT_HEADER__
+
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+#include "ast_module.h"
+#include "ast.h"
+#include "gen_astvisitor.h"
+#include "ast_common.h"
+
+namespace maplefe {
+
+class AST_Handler;
+class Module_Handler;
+class AST_XXport;
+
+class AstOpt {
+private:
+  AST_Handler *mASTHandler;
+  AST_XXport  *mASTXXport;
+  unsigned     mFlags;
+
+  // nodeid to node map for all nodes in all modules
+  std::unordered_map<unsigned, TreeNode*> mNodeId2NodeMap;
+
+  // language keywords
+  std::unordered_set<unsigned> mLangKeywords;
+
+  // nodeid to handler map for all nodes in all modules
+  std::unordered_map<unsigned, Module_Handler*> mNodeId2HandlerMap;
+
+public:
+  // module handlers in mASTHandler sorted by import/export dependency
+  std::vector<Module_Handler *> mHandlersInOrder;
+
+public:
+  explicit AstOpt(AST_Handler *h, unsigned f);
+  ~AstOpt() {}
+
+  AST_Handler *GetASTHandler() {return mASTHandler;}
+  AST_XXport *GetASTXXport() {return mASTXXport;}
+  unsigned GetModuleNum();
+  Module_Handler *GetModuleHandler(unsigned i) { return mHandlersInOrder[i]; }
+  void AddModuleHandler(Module_Handler *h) { mHandlersInOrder.push_back(h); }
+
+  void PreprocessModules();
+  virtual void ProcessAST(unsigned trace);
+
+  TreeNode *GetNodeFromNodeId(unsigned nid) { return mNodeId2NodeMap[nid]; }
+  void AddNodeId2NodeMap(TreeNode *node) { mNodeId2NodeMap[node->GetNodeId()] = node; }
+
+  Module_Handler *GetHandlerFromNodeId(unsigned nid) { return mNodeId2HandlerMap[nid]; }
+  void AddNodeId2HandlerMap(unsigned nid, Module_Handler *h) { mNodeId2HandlerMap[nid] = h; }
+
+  bool IsLangKeyword(TreeNode *node) {
+    return mLangKeywords.find(node->GetStrIdx()) != mLangKeywords.end();
+  }
+};
+
+class BuildNodeIdToNodeVisitor : public AstVisitor {
+  AstOpt         *mAstOpt;
+  unsigned        mFlags;
+  Module_Handler *mHandler;
+
+  public:
+  explicit BuildNodeIdToNodeVisitor(AstOpt *opt, unsigned f, bool base = false)
+    : AstVisitor((f & FLG_trace_1) && base), mAstOpt(opt), mFlags(f) {}
+  ~BuildNodeIdToNodeVisitor() = default;
+
+  void SetHandler(Module_Handler *handler) { mHandler = handler; }
+
+  TreeNode *VisitTreeNode(TreeNode *node) {
+    if (mFlags & FLG_trace_3) std::cout << "nodeid2node:   " << node->GetNodeId() << std::endl;
+    (void) AstVisitor::VisitTreeNode(node);
+    mAstOpt->AddNodeId2NodeMap(node);
+    mAstOpt->AddNodeId2HandlerMap(node->GetNodeId(), mHandler);
+    return node;
+  }
+
+  TreeNode *BaseTreeNode(TreeNode *node) {
+    if (mFlags & FLG_trace_3) std::cout << "nodeid2node: b " << node->GetNodeId() << std::endl;
+    (void) AstVisitor::BaseTreeNode(node);
+    mAstOpt->AddNodeId2NodeMap(node);
+    mAstOpt->AddNodeId2HandlerMap(node->GetNodeId(), mHandler);
+    return node;
+  }
+};
+
+}
+#endif
diff --git a/src/MapleFE/astopt/include/cpp_keywords.def b/src/MapleFE/astopt/include/cpp_keywords.def
new file mode 100644
index 0000000000000000000000000000000000000000..f2fc30566654fbdca92a9621b6324dd4b46be091
--- /dev/null
+++ b/src/MapleFE/astopt/include/cpp_keywords.def
@@ -0,0 +1,112 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+CPPKEYWORD(alignas)
+CPPKEYWORD(alignof)
+CPPKEYWORD(and)
+CPPKEYWORD(and_eq)
+CPPKEYWORD(asm)
+CPPKEYWORD(atomic_cancel)
+CPPKEYWORD(atomic_commit)
+CPPKEYWORD(atomic_noexcept)
+CPPKEYWORD(auto)
+CPPKEYWORD(bitand)
+CPPKEYWORD(bitor)
+CPPKEYWORD(bool)
+CPPKEYWORD(break)
+CPPKEYWORD(case)
+CPPKEYWORD(catch)
+CPPKEYWORD(char)
+CPPKEYWORD(char8_t)
+CPPKEYWORD(char16_t)
+CPPKEYWORD(char32_t)
+CPPKEYWORD(class)
+CPPKEYWORD(compl)
+CPPKEYWORD(concept)
+CPPKEYWORD(const)
+CPPKEYWORD(consteval)
+CPPKEYWORD(constexpr)
+CPPKEYWORD(constinit)
+CPPKEYWORD(const_cast)
+CPPKEYWORD(continue)
+CPPKEYWORD(co_await)
+CPPKEYWORD(co_return)
+CPPKEYWORD(co_yield)
+CPPKEYWORD(decltype)
+CPPKEYWORD(default)
+CPPKEYWORD(delete)
+CPPKEYWORD(do)
+CPPKEYWORD(double)
+CPPKEYWORD(dynamic_cast)
+CPPKEYWORD(else)
+CPPKEYWORD(enum)
+CPPKEYWORD(explicit)
+CPPKEYWORD(export)
+CPPKEYWORD(extern)
+CPPKEYWORD(false)
+CPPKEYWORD(float)
+CPPKEYWORD(for)
+CPPKEYWORD(friend)
+CPPKEYWORD(goto)
+CPPKEYWORD(if)
+CPPKEYWORD(inline)
+CPPKEYWORD(int)
+CPPKEYWORD(long)
+CPPKEYWORD(mutable)
+CPPKEYWORD(namespace)
+CPPKEYWORD(new)
+CPPKEYWORD(noexcept)
+CPPKEYWORD(not)
+CPPKEYWORD(not_eq)
+CPPKEYWORD(nullptr)
+CPPKEYWORD(operator)
+CPPKEYWORD(or)
+CPPKEYWORD(or_eq)
+CPPKEYWORD(private)
+CPPKEYWORD(protected)
+CPPKEYWORD(public)
+CPPKEYWORD(reflexpr)
+CPPKEYWORD(register)
+CPPKEYWORD(reinterpret_cast)
+CPPKEYWORD(requires)
+CPPKEYWORD(return)
+CPPKEYWORD(short)
+CPPKEYWORD(signed)
+CPPKEYWORD(sizeof)
+CPPKEYWORD(static)
+CPPKEYWORD(static_assert)
+CPPKEYWORD(static_cast)
+CPPKEYWORD(struct)
+CPPKEYWORD(switch)
+CPPKEYWORD(synchronized)
+CPPKEYWORD(template)
+CPPKEYWORD(this)
+CPPKEYWORD(thread_local)
+CPPKEYWORD(throw)
+CPPKEYWORD(true)
+CPPKEYWORD(try)
+CPPKEYWORD(typedef)
+CPPKEYWORD(typeid)
+CPPKEYWORD(typename)
+CPPKEYWORD(union)
+CPPKEYWORD(unsigned)
+CPPKEYWORD(using)
+CPPKEYWORD(virtual)
+CPPKEYWORD(void)
+CPPKEYWORD(volatile)
+CPPKEYWORD(wchar_t)
+CPPKEYWORD(while)
+CPPKEYWORD(xor)
+CPPKEYWORD(xor_eq)
diff --git a/src/MapleFE/astopt/src/Makefile b/src/MapleFE/astopt/src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..3d61edb58810ed11d2f63a25a32eba9c5b225f77
--- /dev/null
+++ b/src/MapleFE/astopt/src/Makefile
@@ -0,0 +1,61 @@
+# Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
+include ../../Makefile.in
+BUILD=$(BUILDDIR)/astopt
+$(shell $(MKDIR_P) $(BUILD))
+
+SRC=$(wildcard *.cpp)
+OBJ :=$(patsubst %.cpp,%.o,$(SRC))
+DEP :=$(patsubst %.cpp,%.d,$(SRC))
+
+OBJS :=$(foreach obj,$(OBJ), $(BUILD)/$(obj))
+DEPS :=$(foreach dep,$(DEP), $(BUILD)/$(dep))
+
+LIBOBJS :=$(patsubst $(BUILD)/main.o,,$(OBJS))
+
+
+INCLUDES := -I $(MAPLEFE_ROOT)/shared/include \
+            -I $(MAPLEFE_ROOT)/astopt/include \
+            -I $(MAPLEFE_ROOT)/$(SRCLANG)/include \
+            -I ${BUILDDIR}/ast_gen/shared
+
+TARGET=astopt.a
+
+.PHONY: all
+all: $(BUILD)/$(TARGET)
+
+-include $(DEPS)
+.PHONY: clean
+
+vpath %.o $(BUILD)
+vpath %.d $(BUILD)
+
+#Pattern Rules
+$(BUILD)/%.o : %.cpp
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
+
+$(BUILD)/%.d : %.cpp
+	@$(CXX) $(CXXFLAGS) -MM $(INCLUDES) $< > $@
+	@mv -f $(BUILD)/$*.d $(BUILD)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
+	@rm -f $(BUILD)/$*.d.tmp
+
+# TARGET depends on OBJS and shared OBJS from shared directory
+# as well as mapleall libraries
+$(BUILD)/$(TARGET): $(OBJS)
+	/usr/bin/ar rcs $(BUILD)/$(TARGET) $(OBJS)
+
+clean:
+	rm -rf $(BUILD)
diff --git a/src/MapleFE/astopt/src/ast_adj.cpp b/src/MapleFE/astopt/src/ast_adj.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..64b8e82bf1f0de9ea9ecc9c1e7f3ef79609bd954
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_adj.cpp
@@ -0,0 +1,607 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <stack>
+#include <set>
+#include <algorithm>
+#include "ast_handler.h"
+#include "typetable.h"
+#include "ast_info.h"
+#include "ast_adj.h"
+#include "ast_util.h"
+
+namespace maplefe {
+
+void AST_ADJ::AdjustAST() {
+  MSGNOLOC0("============== AdjustAST ==============");
+  ModuleNode *module = mHandler->GetASTModule();
+  for(unsigned i = 0; i < module->GetTreesNum(); i++) {
+    TreeNode *it = module->GetTree(i);
+    it->SetParent(module);
+  }
+
+  // adjust ast
+  AdjustASTVisitor adjust_visitor(mHandler, mFlags, true);
+  adjust_visitor.Visit(module);
+}
+
+// set parent for some identifier's type
+IdentifierNode *AdjustASTVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  (void) AstVisitor::VisitIdentifierNode(node);
+  CheckAndRenameCppKeywords(node);
+
+  TreeNode *type = node->GetType();
+  if (type && type->IsUserType()) {
+    type->SetParent(node);
+  }
+  return node;
+}
+
+ClassNode *AdjustASTVisitor::VisitClassNode(ClassNode *node) {
+  (void) AstVisitor::VisitClassNode(node);
+  CheckAndRenameCppKeywords(node);
+  AssignPseudoName(node);
+
+  // record names
+  gStringPool.AddAltStrIdx(node->GetStrIdx());
+  for (unsigned i = 0; i < node->GetFieldsNum(); i++) {
+    TreeNode *n = node->GetField(i);
+    gStringPool.AddAltStrIdx(n->GetStrIdx());
+  }
+  for (unsigned i = 0; i < node->GetMethodsNum(); i++) {
+    TreeNode *n = node->GetMethod(i);
+    gStringPool.AddAltStrIdx(n->GetStrIdx());
+  }
+
+  // skip getting canonical type if not only fields
+  if (node->GetMethodsNum() || node->GetSuperClassesNum() || node->GetSuperInterfacesNum() ||
+      node->GetSuperClassesNum() || node->GetTypeParamsNum()) {
+    return node;
+  }
+
+  TreeNode *parent = node->GetParent();
+  TreeNode *newnode = mInfo->GetCanonicStructNode(node);
+  if (newnode == node) {
+    return node;
+  }
+
+  // create a TypeAlias for duplicated type if top level
+  if (parent && parent->IsModule()) {
+    newnode = (ClassNode*)(mInfo->CreateTypeAliasNode(newnode, node));
+  }
+
+  return (ClassNode*)newnode;
+}
+
+InterfaceNode *AdjustASTVisitor::VisitInterfaceNode(InterfaceNode *node) {
+  (void) AstVisitor::VisitInterfaceNode(node);
+  CheckAndRenameCppKeywords(node);
+
+  // record names
+  gStringPool.AddAltStrIdx(node->GetStrIdx());
+  for (unsigned i = 0; i < node->GetFieldsNum(); i++) {
+    TreeNode *n = node->GetField(i);
+    gStringPool.AddAltStrIdx(n->GetStrIdx());
+  }
+  for (unsigned i = 0; i < node->GetMethodsNum(); i++) {
+    TreeNode *n = node->GetMethod(i);
+    gStringPool.AddAltStrIdx(n->GetStrIdx());
+  }
+
+  // skip getting canonical type if not only fields
+  if (node->GetMethodsNum() || node->GetSuperInterfacesNum()) {
+    return node;
+  }
+
+  TreeNode *parent = node->GetParent();
+  TreeNode *newnode = mInfo->GetCanonicStructNode(node);
+  if (newnode == node) {
+    return node;
+  }
+
+  // create a TypeAlias for duplicated type if top level
+  if (parent && parent->IsModule()) {
+    newnode = (InterfaceNode*)(mInfo->CreateTypeAliasNode(newnode, node));
+  }
+  return (InterfaceNode*)newnode;
+}
+
+StructLiteralNode *AdjustASTVisitor::VisitStructLiteralNode(StructLiteralNode *node) {
+  (void) AstVisitor::VisitStructLiteralNode(node);
+
+  unsigned size = node->GetFieldsNum();
+  for (unsigned fid = 0; fid < size; fid++) {
+    FieldLiteralNode *field = node->GetField(fid);
+    TreeNode *name = field->GetFieldName();
+    TreeNode *lit = field->GetLiteral();
+    if (!name || !lit || !lit->IsLiteral()) {
+      return node;
+    }
+  }
+
+  TreeNode *newnode = mInfo->GetCanonicStructNode(node);
+  gStringPool.AddAltStrIdx(newnode->GetStrIdx());
+  if (newnode != node) {
+    node->SetTypeIdx(newnode->GetTypeIdx());
+  }
+
+  return node;
+}
+
+StructNode *AdjustASTVisitor::VisitStructNode(StructNode *node) {
+  (void) AstVisitor::VisitStructNode(node);
+  CheckAndRenameCppKeywords(node);
+
+  // record names
+  gStringPool.AddAltStrIdx(node->GetStrIdx());
+  for (unsigned i = 0; i < node->GetFieldsNum(); i++) {
+    TreeNode *n = node->GetField(i);
+    gStringPool.AddAltStrIdx(n->GetStrIdx());
+  }
+  for (unsigned i = 0; i < node->GetMethodsNum(); i++) {
+    TreeNode *n = node->GetMethod(i);
+    gStringPool.AddAltStrIdx(n->GetStrIdx());
+  }
+
+  // skip getting canonical type for TypeAlias
+  TreeNode *parent_orig = node->GetParent();
+  TreeNode *p = parent_orig;
+  while (p) {
+    if (p->IsTypeAlias()) {
+      return node;
+    }
+    p = p->GetParent();
+  }
+
+  // skip getting canonical type if not only fields
+  if (node->GetMethodsNum() || node->GetSupersNum() || node->GetTypeParamsNum()) {
+    return node;
+  }
+
+  TreeNode *newnode = mInfo->GetCanonicStructNode(node);
+
+  // if returned itself that means it should be added to the moudule if not yet
+  if (newnode == node) {
+    ModuleNode *module = mHandler->GetASTModule();
+    bool found = false;
+    for (unsigned i = 0; i < module->GetTreesNum(); ++i) {
+      if (newnode == module->GetTree(i)) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      module->AddTreeFront(newnode);
+    }
+  }
+
+  // create a TypeAlias for duplicated type if top level
+  // except newly added anonymous type which has updated parent
+  TreeNode *parent = node->GetParent();
+  if (newnode != node && parent_orig && parent && parent == parent_orig && parent->IsModule()) {
+    newnode = mInfo->CreateTypeAliasNode(newnode, node);
+  }
+
+  // for non top level tree node, replace it with a UserType node
+  if (!parent_orig || !parent_orig->IsModule()) {
+    if (newnode->GetStrIdx()) {
+      // for anonymous class, check it is given a name
+      // not skipped due to type parameters
+      newnode = mInfo->CreateUserTypeNode(newnode->GetStrIdx());
+    }
+  }
+
+  return (StructNode*)newnode;
+}
+
+// convert prim array node to array type node
+PrimArrayTypeNode *AdjustASTVisitor::VisitPrimArrayTypeNode(PrimArrayTypeNode *node) {
+  (void) AstVisitor::VisitPrimArrayTypeNode(node);
+  ArrayTypeNode *arr = mHandler->NewTreeNode<ArrayTypeNode>();
+  DimensionNode *dim = node->GetDims();
+  arr->SetDims(dim);
+  arr->SetElemType(node->GetPrim());
+
+  return (PrimArrayTypeNode *)arr;
+}
+
+// set UserTypeNode's mStrIdx to be its mId's
+UserTypeNode *AdjustASTVisitor::VisitUserTypeNode(UserTypeNode *node) {
+  (void) AstVisitor::VisitUserTypeNode(node);
+  TreeNode *id = node->GetId();
+  if (id) {
+    node->SetStrIdx(id->GetStrIdx());
+  }
+
+  // use array type node
+  DimensionNode *dim = node->GetDims();
+  bool isarr = (dim != NULL);
+  // element type
+  TreeNode *etype = NULL;
+
+  if (isarr) {
+    etype = node;
+  } else if (id && id->IsIdentifier()) {
+    IdentifierNode *idnode = static_cast<IdentifierNode *>(id);
+    isarr = (idnode->GetStrIdx() == gStringPool.GetStrIdx("Array"));
+    if (isarr) {
+      if (unsigned s = node->GetTypeGenericsNum()) {
+        if (s == 1) {
+          etype = node->GetTypeGeneric(0);
+        } else {
+          NOTYETIMPL("array usertype with multiple generic type");
+        }
+      }
+    }
+  }
+
+  if (isarr) {
+    ArrayTypeNode *arr = mHandler->NewTreeNode<ArrayTypeNode>();
+    arr->SetDims(dim);
+    arr->SetElemType(etype);
+    node->SetDims(NULL);
+    node = (UserTypeNode *)arr;
+  }
+
+  return node;
+}
+
+// set TypeAliasNode's mStrIdx to be its mId's
+TypeAliasNode *AdjustASTVisitor::VisitTypeAliasNode(TypeAliasNode *node) {
+  (void) AstVisitor::VisitTypeAliasNode(node);
+  UserTypeNode *id = node->GetId();
+  if (id && id->GetId()) {
+    node->SetStrIdx(id->GetId()->GetStrIdx());
+  }
+  return node;
+}
+
+LiteralNode *AdjustASTVisitor::VisitLiteralNode(LiteralNode *node) {
+  (void) AstVisitor::VisitLiteralNode(node);
+  if (node->IsThis()) {
+    unsigned stridx = gStringPool.GetStrIdx("this");
+    IdentifierNode *id = mInfo->CreateIdentifierNode(stridx);
+    TreeNode *type = node->GetType();
+    if (type) {
+      id->SetType(type);
+      id->SetTypeId(type->GetTypeId());
+      id->SetTypeIdx(type->GetTypeIdx());
+    }
+    node = (LiteralNode *)id;
+  }
+  return node;
+}
+
+UnaOperatorNode *AdjustASTVisitor::VisitUnaOperatorNode(UnaOperatorNode *node) {
+  (void) AstVisitor::VisitUnaOperatorNode(node);
+  TreeNode *opnd = node->GetOpnd();
+  OprId op = node->GetOprId();
+  if (op == OPR_Plus || op == OPR_Minus) {
+    if (opnd->IsLiteral()) {
+      LiteralNode *lit = static_cast<LiteralNode *>(opnd);
+      if (lit->GetData().mType == LT_StringLiteral) {
+        unsigned stridx = lit->GetData().mData.mStrIdx;
+        std::string str = gStringPool.GetStringFromStrIdx(stridx);
+        double d = std::stod(str);
+        if (op == OPR_Minus) {
+          d = -d;
+        }
+        long l = (long)d;
+        LitData data;
+        if (d == l) {
+          data.mType = LT_IntegerLiteral;
+          data.mData.mInt = l;
+        } else {
+          data.mType = LT_DoubleLiteral;
+          data.mData.mDouble = d;
+        }
+        LiteralNode *n = mHandler->NewTreeNode<LiteralNode>();
+        n->SetData(data);
+        n->SetParent(node->GetParent());
+        return (UnaOperatorNode*)n;
+      }
+    }
+  }
+  return node;
+}
+
+FunctionNode *AdjustASTVisitor::VisitFunctionNode(FunctionNode *node) {
+  (void) AstVisitor::VisitFunctionNode(node);
+  CheckAndRenameCppKeywords(node);
+
+  gStringPool.AddAltStrIdx(node->GetStrIdx());
+
+  for(unsigned i = 0; i < node->GetParamsNum(); i++) {
+    TreeNode *it = node->GetParam(i);
+    gStringPool.AddAltStrIdx(it->GetStrIdx());
+  }
+
+  TreeNode *type = node->GetRetType();
+  if (type && type->IsUserType()) {
+    type->SetParent(node);
+  }
+
+  // Refine function TypeParames
+  for(unsigned i = 0; i < node->GetTypeParamsNum(); i++) {
+    type = node->GetTypeParamAtIndex(i);
+    if (type->IsIdentifier()) {
+      IdentifierNode *inode = static_cast<IdentifierNode *>(type);
+      TreeNode *newtype = mInfo->CreateUserTypeNode(inode);
+      node->SetTypeParamAtIndex(i, newtype);
+      newtype->SetParent(node);
+    }
+  }
+  return node;
+}
+
+// move init from identifier to decl
+// copy stridx to decl
+DeclNode *AdjustASTVisitor::VisitDeclNode(DeclNode *node) {
+  TreeNode *var = node->GetVar();
+  if (var->IsIdentifier()) {
+    IdentifierNode *inode = static_cast<IdentifierNode *>(var);
+    (void) AstVisitor::VisitIdentifierNode(inode);
+
+    // copy stridx from Identifier to Decl
+    unsigned stridx = inode->GetStrIdx();
+    if (stridx) {
+      node->SetStrIdx(stridx);
+      gStringPool.AddAltStrIdx(stridx);
+      mUpdated = true;
+    }
+
+    // move init from Identifier to Decl
+    TreeNode *init = inode->GetInit();
+    if (init) {
+      node->SetInit(init);
+      inode->ClearInit();
+      mUpdated = true;
+    }
+  } else if (var->IsBindingPattern()) {
+    BindingPatternNode *bind = static_cast<BindingPatternNode *>(var);
+    VisitBindingPatternNode(bind);
+  } else {
+    NOTYETIMPL("decl not idenfier or bind pattern");
+  }
+
+  // reorg before processing init
+  (void) AstVisitor::VisitDeclNode(node);
+  return node;
+}
+
+ImportNode *AdjustASTVisitor::VisitImportNode(ImportNode *node) {
+  (void) AstVisitor::VisitImportNode(node);
+
+  return node;
+}
+
+// if-then-else : use BlockNode for then and else bodies
+// split export decl and body
+// export {func add(y)}  ==> export {add}; func add(y)
+ExportNode *AdjustASTVisitor::VisitExportNode(ExportNode *node) {
+  (void) AstVisitor::VisitExportNode(node);
+  TreeNode *parent = node->GetParent();
+  if (!parent || parent->IsNamespace()) {
+    // Export declarations are not permitted in a namespace
+    return node;
+  }
+  if (node->GetPairsNum() == 1) {
+    XXportAsPairNode *p = node->GetPair(0);
+    TreeNode *bfnode = p->GetBefore();
+    if (bfnode) {
+      if (!bfnode->IsIdentifier()) {
+        switch (bfnode->GetKind()) {
+          case NK_Function: {
+            FunctionNode *func = static_cast<FunctionNode *>(bfnode);
+            IdentifierNode *n = mInfo->CreateIdentifierNode(func->GetStrIdx());
+            // update p
+            p->SetBefore(n);
+            n->SetParent(p);
+            mUpdated = true;
+            // insert func into AST after node
+            if (parent->IsBlock()) {
+              static_cast<BlockNode *>(parent)->InsertStmtAfter(func, node);
+            } else if (parent->IsModule()) {
+              static_cast<ModuleNode *>(parent)->InsertAfter(func, node);
+            }
+            // cp annotation from node to func
+            for (unsigned i = 0; i < node->GetAnnotationsNum(); i++) {
+              func->AddAnnotation(node->GetAnnotationAtIndex(i));
+            }
+            node->ClearAnnotation();
+            break;
+          }
+          case NK_Class: {
+            ClassNode *classnode = static_cast<ClassNode *>(bfnode);
+            IdentifierNode *n = mInfo->CreateIdentifierNode(classnode->GetStrIdx());
+            // update p
+            p->SetBefore(n);
+            n->SetParent(p);
+            mUpdated = true;
+            // insert classnode into AST after node
+            if (parent->IsBlock()) {
+              static_cast<BlockNode *>(parent)->InsertStmtAfter(classnode, node);
+            } else if (parent->IsModule()) {
+              static_cast<ModuleNode *>(parent)->InsertAfter(classnode, node);
+            }
+            // cp annotation from node to classnode
+            for (unsigned i = 0; i < node->GetAnnotationsNum(); i++) {
+              classnode->AddAnnotation(node->GetAnnotationAtIndex(i));
+            }
+            node->ClearAnnotation();
+            break;
+          }
+          default:
+            NOTYETIMPL("VisitExportNode neither function nor class");
+            break;
+        }
+      }
+    }
+  }
+  return node;
+}
+
+NamespaceNode *AdjustASTVisitor::VisitNamespaceNode(NamespaceNode *node) {
+  (void) AstVisitor::VisitNamespaceNode(node);
+  TreeNode *id = node->GetId();
+  if (id) {
+    // for namespace with nested id, split into namespaces
+    if (id->IsField()) {
+      FieldNode *fld = static_cast<FieldNode *>(id);
+      TreeNode *upper = fld->GetUpper();
+      TreeNode *field = fld->GetField();
+      // rename node with upper
+      node->SetId(upper);
+
+      NamespaceNode *ns = mHandler->NewTreeNode<NamespaceNode>();
+      // name ns with field
+      ns->SetId(field);
+      // move elements of node to ns
+      for (unsigned i = 0; i < node->GetElementsNum(); i++) {
+        ns->AddElement(node->GetElementAtIndex(i));
+      }
+      node->Release();
+      // add ns as element of node
+      node->AddElement(ns);
+
+      // recursive if needed
+      if (!upper->IsIdentifier()) {
+        node = VisitNamespaceNode(static_cast<NamespaceNode *>(node));
+      }
+    }
+  }
+  return node;
+}
+
+CondBranchNode *AdjustASTVisitor::VisitCondBranchNode(CondBranchNode *node) {
+  TreeNode *tn = VisitTreeNode(node->GetCond());
+  tn = VisitTreeNode(node->GetTrueBranch());
+  if (tn && !tn->IsBlock()) {
+    BlockNode *blk = mHandler->NewTreeNode<BlockNode>();
+    blk->AddChild(tn);
+    node->SetTrueBranch(blk);
+    mUpdated = true;
+  }
+  tn = VisitTreeNode(node->GetFalseBranch());
+  if (tn && !tn->IsBlock()) {
+    BlockNode *blk = mHandler->NewTreeNode<BlockNode>();
+    blk->AddChild(tn);
+    node->SetFalseBranch(blk);
+    mUpdated = true;
+  }
+  return node;
+}
+
+// for : use BlockNode for body
+ForLoopNode *AdjustASTVisitor::VisitForLoopNode(ForLoopNode *node) {
+  (void) AstVisitor::VisitForLoopNode(node);
+  TreeNode *tn = node->GetBody();
+  if (tn && !tn->IsBlock()) {
+    BlockNode *blk = mHandler->NewTreeNode<BlockNode>();
+    blk->AddChild(tn);
+    node->SetBody(blk);
+    mUpdated = true;
+  }
+  return node;
+}
+
+static unsigned uniq_number = 1;
+
+// lamda : create a FunctionNode for it
+//         use BlockNode for body, add a ReturnNode
+LambdaNode *AdjustASTVisitor::VisitLambdaNode(LambdaNode *node) {
+  FunctionNode *func = mHandler->NewTreeNode<FunctionNode>();
+
+  // func name
+  std::string str("__lambda_");
+  str += std::to_string(uniq_number++);
+  str += "__";
+  unsigned stridx = gStringPool.GetStrIdx(str);
+  IdentifierNode *name = mInfo->CreateIdentifierNode(stridx);
+  func->SetStrIdx(stridx);
+  func->SetFuncName(name);
+  mInfo->AddFromLambda(func->GetNodeId());
+
+  // func parameters
+  for (int i = 0; i < node->GetParamsNum(); i++) {
+    func->AddParam(node->GetParam(i));
+  }
+
+  // func Attributes
+  for (int i = 0; i < node->GetAttrsNum(); i++) {
+    func->AddAttr(node->GetAttrAtIndex(i));
+  }
+
+  // func type parameters
+  for (int i = 0; i < node->GetTypeParamsNum(); i++) {
+    func->AddTypeParam(node->GetTypeParamAtIndex(i));
+  }
+
+  // func body
+  TreeNode *tn = VisitTreeNode(node->GetBody());
+  if (tn) {
+    if (tn->IsBlock()) {
+      func->SetBody(static_cast<BlockNode*>(tn));
+      func->SetRetType(node->GetRetType());
+    } else {
+      BlockNode *blk = mHandler->NewTreeNode<BlockNode>();
+      ReturnNode *ret = mHandler->NewTreeNode<ReturnNode>();
+      ret->SetResult(tn);
+      blk->AddChild(ret);
+
+      func->SetBody(blk);
+    }
+  }
+
+  // func return type
+  if (node->GetRetType()) {
+    func->SetRetType(node->GetRetType());
+  }
+
+  mUpdated = true;
+  // note: the following conversion is only for the visitor to notice the node is updated
+  return (LambdaNode*)func;
+}
+
+void AdjustASTVisitor::CheckAndRenameCppKeywords(TreeNode *node) {
+  if (!mHandler->IsTS() || node->GetStrIdx() == 0) {
+    return;
+  }
+
+  unsigned stridx = node->GetStrIdx();
+  if (mRenameMap.find(stridx) != mRenameMap.end()) {
+    node->SetStrIdx(mRenameMap[stridx]);
+    return;
+  }
+
+  if (mUtil->IsCppKeyWord(stridx)) {
+    std::string name = gStringPool.GetStringFromStrIdx(stridx);
+    unsigned newidx = gStringPool.GetStrIdx(name + RENAMINGSUFFIX);
+    node->SetStrIdx(newidx);
+    mRenameMap[stridx] = newidx;
+  }
+}
+
+void AdjustASTVisitor::AssignPseudoName(TreeNode *node) {
+  if (!mHandler->IsTS() || node->GetStrIdx() != 0) {
+    return;
+  }
+  static int pseudo = 0;
+  // Set a pseudo name
+  unsigned newidx = gStringPool.GetStrIdx("__Pseudo_" + std::to_string(++pseudo));
+  node->SetStrIdx(newidx);
+}
+
+}
diff --git a/src/MapleFE/astopt/src/ast_cfa.cpp b/src/MapleFE/astopt/src/ast_cfa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..57dda93f78017323662bb905e3dbf68c1410094d
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_cfa.cpp
@@ -0,0 +1,107 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <stack>
+#include <set>
+#include "ast_handler.h"
+#include "ast_cfa.h"
+
+namespace maplefe {
+
+void AST_CFA::ControlFlowAnalysis() {
+  MSGNOLOC0("============== ControlFlowAnalysis ==============");
+  CollectReachableBB();
+  RemoveUnreachableBB();
+
+  if (mFlags & FLG_trace_3) {
+    Dump();
+  }
+}
+
+void AST_CFA::Dump() {
+  ModuleNode *module = mHandler->GetASTModule();
+  for(unsigned i = 0; i < module->GetTreesNum(); i++) {
+    TreeNode *it = module->GetTree(i);
+    it->Dump(0);
+    std::cout << std::endl;
+  }
+}
+
+// this calcuates mNodeId2BbMap
+void AST_CFA::CollectReachableBB() {
+  MSGNOLOC0("============== CollectReachableBB ==============");
+  mReachableBbIdx.clear();
+  std::deque<CfgBB *> working_list;
+
+  // process each functions
+  for (auto func: mHandler->mModuleFuncs) {
+    // initialisze work list with all entry BB
+    working_list.push_back(func->GetEntryBB());
+
+    while(working_list.size()) {
+      CfgBB *bb = working_list.front();
+      MASSERT(bb && "null BB");
+      unsigned bbid = bb->GetId();
+
+      // skip bb already visited
+      if (mReachableBbIdx.find(bbid) != mReachableBbIdx.end()) {
+        working_list.pop_front();
+        continue;
+      }
+
+      for (int i = 0; i < bb->GetSuccessorsNum(); i++) {
+        working_list.push_back(bb->GetSuccessorAtIndex(i));
+      }
+
+      for (int i = 0; i < bb->GetStatementsNum(); i++) {
+        TreeNode *node = bb->GetStatementAtIndex(i);
+        mHandler->SetBbFromNodeId(node->GetNodeId(), bb);
+      }
+
+      mHandler->SetBbFromBbId(bbid, bb);
+      mHandler->mBbIdVec.push_back(bbid);
+
+      mReachableBbIdx.insert(bbid);
+      working_list.pop_front();
+    }
+  }
+}
+
+void AST_CFA::RemoveUnreachableBB() {
+  std::set<CfgBB *> deadBb;
+  CfgBB *bb = nullptr;
+  for (auto id: mReachableBbIdx) {
+    bb = mHandler->mBbId2BbMap[id];
+    for (int i = 0; i < bb->GetPredecessorsNum(); i++) {
+      CfgBB *pred = bb->GetPredecessorAtIndex(i);
+      unsigned pid = pred->GetId();
+      if (mHandler->mBbId2BbMap.find(pid) == mHandler->mBbId2BbMap.end()) {
+        deadBb.insert(pred);
+      }
+    }
+  }
+  for (auto it: deadBb) {
+    if (mFlags & FLG_trace_3) std::cout << "deleted BB :";
+    for (int i = 0; i < it->GetSuccessorsNum(); i++) {
+      bb = it->GetSuccessorAtIndex(i);
+      bb->mPredecessors.Remove(it);
+    }
+    if (mFlags & FLG_trace_3) std::cout << " BB" << it->GetId();
+    it->~CfgBB();
+  }
+  if (mFlags & FLG_trace_3) std::cout << std::endl;
+}
+
+}
diff --git a/src/MapleFE/astopt/src/ast_cfg.cpp b/src/MapleFE/astopt/src/ast_cfg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..63bda48be94433bf8c45d6ca52e3f6235734da2f
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_cfg.cpp
@@ -0,0 +1,882 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <stack>
+#include <set>
+#include <queue>
+#include <cstring>
+#include "ast_cfg.h"
+#include "ast_dfa.h"
+#include "ast_handler.h"
+#include "gen_astdump.h"
+
+namespace maplefe {
+
+class CollectNestedFuncs : public AstVisitor {
+  private:
+    CfgBuilder   *mBuilder;
+    CfgFunc *mFunc;
+
+  public:
+    CollectNestedFuncs(CfgBuilder *b, CfgFunc *f) : mBuilder(b), mFunc(f) {}
+
+    FunctionNode *VisitFunctionNode(FunctionNode *node) {
+      if(TreeNode *body = node->GetBody())
+        HandleNestedFunc(node, body);
+      return node;
+    }
+
+    LambdaNode *VisitLambdaNode(LambdaNode *node) {
+      if(TreeNode *body = node->GetBody())
+        HandleNestedFunc(node, body);
+      return node;
+    }
+
+    void HandleNestedFunc(TreeNode *func, TreeNode *body) {
+        CfgFunc *current = mFunc;
+        mFunc = mBuilder->NewFunction(func);
+        current->AddNestedFunc(mFunc);
+        AstVisitor::VisitTreeNode(body);
+        mFunc = current;
+    }
+};
+
+// Create CfgFunc nodes for a module
+CfgFunc *CfgBuilder::InitCfgFunc(ModuleNode *module) {
+  CfgFunc *module_func = NewFunction(module);
+  CollectNestedFuncs collector(this, module_func);
+  collector.Visit(module);
+  return module_func;
+}
+
+// Initialize a CfgFunc node
+void CfgBuilder::InitializeFunction(CfgFunc *func) {
+  // Create the entry BB and exit BB of current function
+  CfgBB *entry = NewBB(BK_Uncond);
+  func->SetEntryBB(entry);
+  CfgBB *exit = NewBB(BK_Join);
+  func->SetExitBB(exit);
+  CfgBuilder::Push(mThrowBBs, exit, nullptr);
+  // Initialize the working function and BB
+  mCurrentFunction = func;
+  mCurrentBB = NewBB(BK_Uncond);
+  entry->AddSuccessor(mCurrentBB);
+}
+
+// Finalize a CfgFunc node
+void CfgBuilder::FinalizeFunction() {
+  CfgBuilder::Pop(mThrowBBs);
+  CfgBB *exit = mCurrentFunction->GetExitBB();
+  mCurrentBB->AddSuccessor(exit);
+  mCurrentFunction->SetLastBBId(CfgBB::GetLastId());
+  mCurrentFunction = nullptr;
+  mCurrentBB = nullptr;
+}
+
+// Push a BB to target BB stack
+void CfgBuilder::Push(TargetBBStack &stack, CfgBB* bb, TreeNode *label) {
+  unsigned idx = 0;
+  if(label && label->IsIdentifier())
+    idx = static_cast<IdentifierNode *>(label)->GetStrIdx();
+  stack.push_back(TargetBB{bb, idx});
+}
+
+// Look up a target BB
+CfgBB *CfgBuilder::LookUp(TargetBBStack &stack, TreeNode *label) {
+  unsigned idx = 0;
+  if(label && label->IsIdentifier())
+    idx = static_cast<IdentifierNode *>(label)->GetStrIdx();
+  if(idx == 0) {
+    for(auto it = stack.rbegin(); it != stack.rend(); ++it)
+      if(it->first->GetKind() != BK_Join2)
+        return it->first;
+  } else {
+    for(auto it = stack.rbegin(); it != stack.rend(); ++it)
+      if(it->second == idx)
+        return it->first;
+  }
+  MASSERT(0 && "Unexpected: Target not found.");
+  return nullptr;
+}
+
+// Pop from a target BB stack
+void CfgBuilder::Pop(TargetBBStack &stack) {
+  stack.pop_back();
+}
+
+// Handle a function
+FunctionNode *CfgBuilder::VisitFunctionNode(FunctionNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// Handle a lambda
+LambdaNode *CfgBuilder::VisitLambdaNode(LambdaNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+ClassNode *CfgBuilder::VisitClassNode(ClassNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+InterfaceNode *CfgBuilder::VisitInterfaceNode(InterfaceNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+StructNode *CfgBuilder::VisitStructNode(StructNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For control flow
+ReturnNode *CfgBuilder::VisitReturnNode(ReturnNode *node) {
+  mCurrentBB->AddStatement(node);
+  CfgBB *exit = mCurrentFunction->GetExitBB();
+  mCurrentBB->AddSuccessor(exit);
+  mCurrentBB->SetKind(BK_Terminated);
+  mCurrentBB->SetAttr(AK_Return);
+  return node;
+}
+
+// For control flow
+CondBranchNode *CfgBuilder::VisitCondBranchNode(CondBranchNode *node) {
+  mCurrentBB->SetKind(BK_Branch);
+  //mCurrentBB->AddStatement(node);
+  mCurrentBB->SetAuxNode(node);
+
+  if(TreeNode *cond = node->GetCond()) {
+    // Set predicate of current BB
+    mCurrentBB->SetPredicate(cond);
+    mCurrentBB->AddStatement(cond);
+  }
+
+  // Save current BB
+  CfgBB *current_bb = mCurrentBB;
+
+  // Create a new BB for true branch
+  mCurrentBB = NewBB(BK_Uncond);
+  current_bb->AddSuccessor(mCurrentBB);
+
+  // Create a BB for the join point
+  CfgBB *join = NewBB(BK_Join2);
+
+  // Handle the label of current if-statement
+  TreeNode *label = node->GetLabel();
+  if(label)
+    CfgBuilder::Push(mBreakBBs, join, label);
+
+  // Visit true branch first
+  VisitTreeNode(node->GetTrueBranch());
+  mCurrentBB->AddSuccessor(join);
+
+  TreeNode *false_branch = node->GetFalseBranch();
+  if(false_branch == nullptr) {
+    current_bb->AddSuccessor(join);
+  } else {
+    mCurrentBB = NewBB(BK_Uncond);
+    current_bb->AddSuccessor(mCurrentBB);
+    // Visit false branch if it exists
+    VisitTreeNode(false_branch);
+    mCurrentBB->AddSuccessor(join);
+  }
+
+  if(label)
+    CfgBuilder::Pop(mBreakBBs);
+
+  // Keep going with the BB at the join point
+  mCurrentBB = join;
+  return node;
+}
+
+// For control flow
+// ForLoopProp: FLP_Regular, FLP_JSIn, FLP_JSOf
+ForLoopNode *CfgBuilder::VisitForLoopNode(ForLoopNode *node) {
+  // Visit all inits
+  for (unsigned i = 0; i < node->GetInitsNum(); ++i) {
+    VisitTreeNode(node->GetInitAtIndex(i));
+  }
+
+  CfgBB *current_bb = mCurrentBB;
+  // Create a new BB for loop header
+  mCurrentBB = NewBB(BK_LoopHeader);
+
+  // Add current node to the loop header BB
+  //mCurrentBB->AddStatement(node);
+  mCurrentBB->SetAuxNode(node);
+  current_bb->AddSuccessor(mCurrentBB);
+  // Set current_bb to be loop header
+  current_bb = mCurrentBB;
+
+  if(node->GetProp() == FLP_Regular) {
+    if(TreeNode *cond = node->GetCond()) {
+      // Set predicate of current BB
+      mCurrentBB->SetPredicate(cond);
+      mCurrentBB->AddStatement(cond);
+    }
+  } else
+    // Set predicate to be current ForLoopNode when it is FLP_JSIn or FLP_JSOf
+    mCurrentBB->SetPredicate(node);
+
+  // Create a BB for loop body
+  mCurrentBB = NewBB(BK_Uncond);
+  current_bb->AddSuccessor(mCurrentBB);
+  // Create a new BB for getting out of the loop
+  CfgBB *loop_exit = NewBB(BK_Join);
+
+  // Push loop_exit and current_bb to stacks for 'break' and 'continue'
+  CfgBuilder::Push(mBreakBBs, loop_exit, node->GetLabel());
+  CfgBuilder::Push(mContinueBBs, current_bb, node->GetLabel());
+  // Visit loop body
+  VisitTreeNode(node->GetBody());
+  CfgBuilder::Pop(mContinueBBs);
+  CfgBuilder::Pop(mBreakBBs);
+
+  // Visit all updates
+  for (unsigned i = 0; i < node->GetUpdatesNum(); ++i) {
+    VisitTreeNode(node->GetUpdateAtIndex(i));
+  }
+  // Add a back edge to loop header
+  mCurrentBB->AddSuccessor(current_bb);
+  current_bb->AddSuccessor(loop_exit);
+  mCurrentBB = loop_exit;
+  return node;
+}
+
+// For control flow
+WhileLoopNode *CfgBuilder::VisitWhileLoopNode(WhileLoopNode *node) {
+  CfgBB *current_bb = mCurrentBB;
+  // Create a new BB for loop header
+  mCurrentBB = NewBB(BK_LoopHeader);
+  // Add current node to the loop header BB
+  //mCurrentBB->AddStatement(node);
+  mCurrentBB->SetAuxNode(node);
+  current_bb->AddSuccessor(mCurrentBB);
+  // Set current_bb to be loop header
+  current_bb = mCurrentBB;
+
+  if(TreeNode *cond = node->GetCond()) {
+    // Set predicate of current BB
+    mCurrentBB->SetPredicate(cond);
+    mCurrentBB->AddStatement(cond);
+  }
+
+  // Create a BB for loop body
+  mCurrentBB = NewBB(BK_Uncond);
+  current_bb->AddSuccessor(mCurrentBB);
+  // Create a new BB for getting out of the loop
+  CfgBB *loop_exit = NewBB(BK_Join);
+
+  // Push loop_exit and current_bb to stacks for 'break' and 'continue'
+  CfgBuilder::Push(mBreakBBs, loop_exit, node->GetLabel());
+  CfgBuilder::Push(mContinueBBs, current_bb, node->GetLabel());
+  // Visit loop body
+  VisitTreeNode(node->GetBody());
+  CfgBuilder::Pop(mContinueBBs);
+  CfgBuilder::Pop(mBreakBBs);
+
+  // Add a back edge to loop header
+  mCurrentBB->AddSuccessor(current_bb);
+  current_bb->AddSuccessor(loop_exit);
+  mCurrentBB = loop_exit;
+  return node;
+}
+
+// For control flow
+DoLoopNode *CfgBuilder::VisitDoLoopNode(DoLoopNode *node) {
+  CfgBB *current_bb = mCurrentBB;
+  // Create a new BB for loop header
+  mCurrentBB = NewBB(BK_LoopHeader);
+  // Add current node to the loop header BB
+  //mCurrentBB->AddStatement(node);
+  mCurrentBB->SetAuxNode(node);
+  current_bb->AddSuccessor(mCurrentBB);
+  // Set current_bb to be loop header
+  current_bb = mCurrentBB;
+
+  // Create a BB for loop body
+  mCurrentBB = NewBB(BK_Uncond);
+  current_bb->AddSuccessor(mCurrentBB);
+  // Create a new BB for getting out of the loop
+  CfgBB *loop_exit = NewBB(BK_Join);
+
+  // Push loop_exit and current_bb to stacks for 'break' and 'continue'
+  CfgBuilder::Push(mBreakBBs, loop_exit, node->GetLabel());
+  CfgBuilder::Push(mContinueBBs, current_bb, node->GetLabel());
+  // Visit loop body
+  VisitTreeNode(node->GetBody());
+  CfgBuilder::Pop(mContinueBBs);
+  CfgBuilder::Pop(mBreakBBs);
+
+  if(TreeNode *cond = node->GetCond()) {
+    // Set predicate of current BB
+    mCurrentBB->SetPredicate(cond);
+    mCurrentBB->AddStatement(cond);
+  }
+
+  // Add a back edge to loop header
+  mCurrentBB->AddSuccessor(current_bb);
+  mCurrentBB->AddSuccessor(loop_exit);
+  mCurrentBB = loop_exit;
+  return node;
+}
+
+// For control flow
+ContinueNode *CfgBuilder::VisitContinueNode(ContinueNode *node) {
+  mCurrentBB->AddStatement(node);
+  // Get the loop header
+  CfgBB *loop_header = CfgBuilder::LookUp(mContinueBBs, node->GetTarget());
+  // Add the loop header as a successor of current BB
+  mCurrentBB->AddSuccessor(loop_header);
+  mCurrentBB->SetKind(BK_Terminated);
+  mCurrentBB->SetAttr(AK_Cont);
+  return node;
+}
+
+// For control flow
+BreakNode *CfgBuilder::VisitBreakNode(BreakNode *node) {
+  mCurrentBB->AddStatement(node);
+  // Get the target BB for a loop or switch statement
+  CfgBB *exit = CfgBuilder::LookUp(mBreakBBs, node->GetTarget());
+  // Add the target as a successor of current BB
+  mCurrentBB->AddSuccessor(exit);
+  mCurrentBB->SetKind(BK_Terminated);
+  mCurrentBB->SetAttr(AK_Break);
+  return node;
+}
+
+// For control flow
+SwitchNode *CfgBuilder::VisitSwitchNode(SwitchNode *node) {
+  mCurrentBB->SetKind(BK_Switch);
+  mCurrentBB->AddStatement(node);
+  // Set the root node of current BB
+  mCurrentBB->SetAuxNode(node);
+
+  // Save current BB
+  CfgBB *current_bb = mCurrentBB;
+
+  // Create a new BB for getting out of the switch block
+  CfgBB *exit = NewBB(BK_Join);
+  CfgBuilder::Push(mBreakBBs, exit, node->GetLabel());
+  CfgBB *prev_block = nullptr;
+  TreeNode *switch_expr = node->GetExpr();
+  for (unsigned i = 0; i < node->GetCasesNum(); ++i) {
+    CfgBB *case_bb = NewBB(BK_Case);
+    current_bb->AddSuccessor(case_bb);
+
+    TreeNode *case_node = node->GetCaseAtIndex(i);
+    // Set the auxiliary node and predicate for current case BB
+    case_bb->SetAuxNode(case_node);
+    case_bb->SetPredicate(switch_expr);
+    case_bb->AddStatement(switch_expr);
+
+    bool is_default = false;
+    TreeNode *case_expr = nullptr;
+    if(case_node->IsSwitchCase()) {
+      // Use the first label node of current SwitchCaseNode
+      TreeNode *label_node = static_cast<SwitchCaseNode *>(case_node)->GetLabelAtIndex(0);
+      if(label_node->IsSwitchLabel()) {
+        is_default = static_cast<SwitchLabelNode *>(label_node)->IsDefault();
+        case_expr = static_cast<SwitchLabelNode *>(label_node)->GetValue();
+      }
+    }
+
+    // Optimize for default case
+    if(is_default) {
+      mCurrentBB = case_bb;
+      case_bb->SetKind(BK_Uncond);
+    } else {
+      mCurrentBB = NewBB(BK_Uncond);
+      case_bb->AddSuccessor(mCurrentBB);
+    }
+
+    // Add a fall-through edge if needed
+    if(prev_block) {
+      prev_block->AddSuccessor(mCurrentBB);
+    }
+
+    // Visit all statements of current case
+    if(case_node->IsSwitchCase()) {
+      SwitchCaseNode *cnode = static_cast<SwitchCaseNode *>(case_node);
+      for (unsigned i = 0; i < cnode->GetStmtsNum(); ++i) {
+        if (auto t = cnode->GetStmtAtIndex(i))
+          VisitTreeNode(t);
+      }
+    }
+
+    // Prepare for next case
+    prev_block = mCurrentBB;
+    current_bb = case_bb;
+  }
+  CfgBuilder::Pop(mBreakBBs);
+
+  // Connect to the exit BB of this switch statement
+  prev_block->AddSuccessor(exit);
+  if(prev_block != current_bb) {
+    current_bb->AddSuccessor(exit);
+  }
+  mCurrentBB = exit;
+  return node;
+}
+
+// For control flow
+TryNode *CfgBuilder::VisitTryNode(TryNode *node) {
+  mCurrentBB->SetKind(BK_Try);
+  //mCurrentBB->AddStatement(node);
+  mCurrentBB->SetAuxNode(node);
+
+  auto try_block_node = node->GetBlock();
+  //mCurrentBB->AddStatement(try_block_node);
+
+  unsigned num = node->GetCatchesNum();
+  CfgBB *catch_bb = num ? NewBB(BK_Catch) : nullptr;
+
+  auto finally_node = node->GetFinally();
+  // Create a BB for the join point
+  CfgBB *join = finally_node ? NewBB(BK_Finally) : NewBB(BK_Join);
+
+  // Save current BB
+  CfgBB *current_bb = mCurrentBB;
+  // Create a new BB for current block node
+  mCurrentBB = NewBB(BK_Uncond);
+  current_bb->AddSuccessor(mCurrentBB);
+
+  // Add an edge for exception
+  current_bb->AddSuccessor(num ? catch_bb : join);
+
+  // Visit try block
+  if(num) {
+    CfgBuilder::Push(mThrowBBs, catch_bb, nullptr);
+    AstVisitor::VisitBlockNode(try_block_node);
+    CfgBuilder::Pop(mThrowBBs);
+  } else
+    AstVisitor::VisitBlockNode(try_block_node);
+
+  // Add an edge to join point
+  mCurrentBB->AddSuccessor(join);
+
+  // JavaScript can have one catch block, or one finally block without catch block
+  // Other languages, such as C++ and Java, may have multiple catch blocks
+  CfgBB *curr_bb = mCurrentBB;
+  for (unsigned i = 0; i < num; ++i) {
+    if(i > 0)
+      catch_bb = NewBB(BK_Catch);
+    // Add an edge to catch bb
+    curr_bb->AddSuccessor(catch_bb);
+    mCurrentBB = catch_bb;
+    auto catch_node = node->GetCatchAtIndex(i);
+    catch_bb->AddStatement(catch_node);
+
+    auto catch_block = catch_node->GetBlock();
+    catch_bb->AddStatement(catch_block);
+    AstVisitor::VisitBlockNode(catch_block);
+
+    mCurrentBB->AddSuccessor(join);
+    curr_bb = catch_bb;
+  }
+
+  mCurrentBB = join;
+  if(finally_node) {
+    // For finally block
+    //mCurrentBB->AddStatement(finally_node);
+    mCurrentBB->SetAuxNode(finally_node);
+    AstVisitor::VisitTreeNode(finally_node);
+    curr_bb = NewBB(BK_Join);
+    mCurrentBB->AddSuccessor(curr_bb);
+    // Add an edge to recent catch BB or exit BB
+    mCurrentBB->AddSuccessor(CfgBuilder::LookUp(mThrowBBs, nullptr));
+    mCurrentBB = curr_bb;
+  }
+  return node;
+}
+
+// For control flow
+ThrowNode *CfgBuilder::VisitThrowNode(ThrowNode *node) {
+  mCurrentBB->AddStatement(node);
+  // Get the catch/exit bb for this throw statement
+  CfgBB *catch_bb = CfgBuilder::LookUp(mThrowBBs, nullptr);
+  // Add the loop header as a successor of current BB
+  mCurrentBB->AddSuccessor(catch_bb);
+  mCurrentBB->SetKind(BK_Terminated);
+  mCurrentBB->SetAttr(AK_Throw);
+  return node;
+}
+
+// For control flow
+BlockNode *CfgBuilder::VisitBlockNode(BlockNode *node) {
+  //mCurrentBB->AddStatement(node);
+  mCurrentBB->SetAuxNode(node);
+  // Check if current block constains any JS_Let or JS_Const DeclNode
+  unsigned i, num = node->GetChildrenNum();
+  for (i = 0; i < num; ++i) {
+    TreeNode *child = node->GetChildAtIndex(i);
+    if(child == nullptr || !child->IsDecl()) {
+      continue;
+    }
+    DeclNode *decl = static_cast<DeclNode *>(child);
+    if(decl->GetProp() == JS_Let || decl->GetProp() == JS_Const) {
+      break;
+    }
+  }
+
+  // Handle the label of current block statement
+  TreeNode *label = node->GetLabel();
+
+  if(i >= num && label == nullptr) {
+    // Do not create BB for current block when no JS_Let or JS_Const DeclNode inside
+    // Visit all child nodes
+    AstVisitor::VisitBlockNode(node);
+  } else {
+    mCurrentBB->SetKind(BK_Block);
+    // Set the auxiliary node of this BB
+    mCurrentBB->SetAuxNode(node);
+
+    // Create a BB for the join point
+    CfgBB *join = NewBB(BK_Join2);
+
+    if(label)
+      CfgBuilder::Push(mBreakBBs, join, label);
+
+    // Needs BBs for current block
+    // Save current BB
+    CfgBB *current_bb = mCurrentBB;
+    // Create a new BB for current block node
+    mCurrentBB = NewBB(BK_Uncond);
+    current_bb->AddSuccessor(mCurrentBB);
+
+    // Visit all child nodes
+    AstVisitor::VisitBlockNode(node);
+
+    mCurrentBB->AddSuccessor(join);
+    // This edge is to determine the block range for JS_Let or JS_Const DeclNode
+    //current_bb->AddSuccessor(join);
+
+    if(label)
+      CfgBuilder::Pop(mBreakBBs);
+
+    mCurrentBB = join;
+  }
+  return node;
+}
+
+// For control flow
+NamespaceNode *CfgBuilder::VisitNamespaceNode(NamespaceNode *node) {
+  //mCurrentBB->AddStatement(node);
+  mCurrentBB->SetKind(BK_Block);
+  // Set the auxiliary node of this BB
+  mCurrentBB->SetAuxNode(node);
+
+  // Create a BB for the join point
+  CfgBB *join = NewBB(BK_Join2);
+
+  // Save current BB
+  CfgBB *current_bb = mCurrentBB;
+  // Create a new BB for current block node
+  mCurrentBB = NewBB(BK_Uncond);
+  current_bb->AddSuccessor(mCurrentBB);
+
+  // Visit all child nodes
+  AstVisitor::VisitNamespaceNode(node);
+
+  mCurrentBB->AddSuccessor(join);
+  // This edge is to determine the namespace range
+  //current_bb->AddSuccessor(join);
+
+  mCurrentBB = join;
+  return node;
+}
+
+// For PassNode
+PassNode *CfgBuilder::VisitPassNode(PassNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+TemplateLiteralNode *CfgBuilder::VisitTemplateLiteralNode(TemplateLiteralNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+ImportNode *CfgBuilder::VisitImportNode(ImportNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+ExportNode *CfgBuilder::VisitExportNode(ExportNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+DeclNode *CfgBuilder::VisitDeclNode(DeclNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+ParenthesisNode *CfgBuilder::VisitParenthesisNode(ParenthesisNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+CastNode *CfgBuilder::VisitCastNode(CastNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+ArrayElementNode *CfgBuilder::VisitArrayElementNode(ArrayElementNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+VarListNode *CfgBuilder::VisitVarListNode(VarListNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+ExprListNode *CfgBuilder::VisitExprListNode(ExprListNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+UnaOperatorNode *CfgBuilder::VisitUnaOperatorNode(UnaOperatorNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+BinOperatorNode *CfgBuilder::VisitBinOperatorNode(BinOperatorNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+TerOperatorNode *CfgBuilder::VisitTerOperatorNode(TerOperatorNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+InstanceOfNode *CfgBuilder::VisitInstanceOfNode(InstanceOfNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+TypeOfNode *CfgBuilder::VisitTypeOfNode(TypeOfNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+NewNode *CfgBuilder::VisitNewNode(NewNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+DeleteNode *CfgBuilder::VisitDeleteNode(DeleteNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+CallNode *CfgBuilder::VisitCallNode(CallNode *node) {
+  mCurrentBB->AddStatement(node);
+  mCurrentBB->SetAttr(AK_HasCall);
+  return node;
+}
+
+// For statement of current BB
+AssertNode *CfgBuilder::VisitAssertNode(AssertNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+UserTypeNode *CfgBuilder::VisitUserTypeNode(UserTypeNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+IdentifierNode *CfgBuilder::VisitIdentifierNode(IdentifierNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+LiteralNode *CfgBuilder::VisitLiteralNode(LiteralNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+TypeAliasNode *CfgBuilder::VisitTypeAliasNode(TypeAliasNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+// For statement of current BB
+FieldNode *CfgBuilder::VisitFieldNode(FieldNode *node) {
+  mCurrentBB->AddStatement(node);
+  return node;
+}
+
+TreeNode *CfgBuilder::BaseTreeNode(TreeNode *node) {
+  return node;
+}
+
+// Allocate a new CfgFunc node
+CfgFunc *CfgBuilder::NewFunction(TreeNode *node)   {
+  CfgFunc *func = new(mHandler->GetMemPool()->Alloc(sizeof(CfgFunc))) CfgFunc;
+  func->SetFuncNode(node);
+  return func;
+}
+
+// Allocate a new CfgBB node
+CfgBB *CfgBuilder::NewBB(BBKind k) {
+  return new(mHandler->GetMemPool()->Alloc(sizeof(CfgBB))) CfgBB(k);
+}
+
+// Helper for a node in dot graph
+static std::string BBLabelStr(CfgBB *bb, const char *shape = nullptr, const char *fn = nullptr) {
+  static const char* const kBBNames[] =
+  { "unknown", "uncond", "block", "branch", "loop", "switch", "case", "try", "catch", "finally",
+    "yield", "term", "join", "join2" };
+  if(shape == nullptr)
+    return kBBNames[bb->GetKind()];
+  std::string str("BB" + std::to_string(bb->GetId()));
+  str += " [label=\"" + str + (shape[0] == 'e' ? std::string("\\n") + kBBNames[bb->GetKind()] : "")
+    + (fn ? std::string("\\n\\\"") + fn + "\\\"" : "") + "\", shape=" + shape + "];\n";
+  return str;
+}
+
+// Dump current CfgFunc node
+void CfgFunc::Dump() {
+  const char *func_name = GetName();
+  std::cout << "Function " << func_name  << " {" << std::endl;
+  unsigned num = GetNestedFuncsNum();
+  if(num > 0) {
+    std::cout << "Nested Functions: " << num << " [" << std::endl;
+    for(unsigned i = 0; i < num; ++i) {
+      CfgFunc *afunc = GetNestedFuncAtIndex(i);
+      const char *fname = afunc->GetName();
+      std::cout << "Function: " << i + 1 << " " << fname << std::endl;
+      afunc->Dump();
+    }
+    std::cout << "] // Nested Functions" << std::endl;
+  }
+  std::cout << "BBs: [" << std::endl;
+
+  std::stack<CfgBB*> bb_stack;
+  CfgBB *entry = GetEntryBB(), *exit = GetExitBB();
+  bb_stack.push(exit);
+  bb_stack.push(entry);
+  std::set<CfgBB*> visited;
+  visited.insert(exit);
+  visited.insert(entry);
+  // Dump CFG in dot format
+  std::string dot("---\ndigraph CFG_");
+  dot = dot + func_name + " {\n" + BBLabelStr(entry, "box", func_name) + BBLabelStr(exit, "doubleoctagon");
+  const char* scoped = " [style=dashed color=grey];";
+  while(!bb_stack.empty()) {
+    CfgBB *bb = bb_stack.top();
+    bb_stack.pop();
+    unsigned succ_num = bb->GetSuccessorsNum();
+    std::cout << "BB" << bb->GetId() << ", " << BBLabelStr(bb) << (succ_num ? " ( succ: " : " ( Exit ");
+    for(unsigned i = 0; i < succ_num; ++i) {
+      CfgBB *curr = bb->GetSuccessorAtIndex(i);
+      std::cout << "BB" << curr->GetId() << " ";
+      dot += "BB" + std::to_string(bb->GetId()) + " -> BB" + std::to_string(curr->GetId())
+        + (bb == entry ? (curr == exit ? scoped : ";") :
+            succ_num == 1 ? ";" : i ? bb->GetKind() == BK_Block ? scoped :
+            " [color=darkred];" : " [color=darkgreen];") + "\n";
+      if(visited.find(curr) == visited.end()) {
+        bb_stack.push(curr);
+        visited.insert(curr);
+        dot += BBLabelStr(curr, "ellipse");
+      }
+    }
+    std::cout << ")" << std::endl;
+    unsigned stmt_num = bb->GetStatementsNum();
+    if(stmt_num) {
+      for(unsigned i = 0; i < stmt_num; ++i) {
+        TreeNode *stmt = bb->GetStatementAtIndex(i);
+        std::cout << "  " << i + 1 << ". NodeId: " << stmt->GetNodeId() << ", "
+          << AstDump::GetEnumNodeKind(stmt->GetKind()) << " : ";
+        stmt->Dump(0);
+        std::cout  << std::endl;
+      }
+    }
+  }
+  std::cout << dot << "} // CFG in dot format" << std::endl;
+  std::cout << "] // BBs\nLastBBId" << (num ? " (Including nested functions)" : "") << ": "
+    << GetLastBBId() << "\n} // Function" << std::endl;
+}
+
+void CfgBuilder::Build() {
+  MSGNOLOC0("============== BuildCFG ==============");
+
+  ModuleNode *module = mHandler->GetASTModule();
+
+  // Set the init function for current module
+  CfgFunc *func = InitCfgFunc(module);
+  mHandler->mModuleFuncs.push_back(func);
+
+  mHandler->SetCfgFunc(func);
+
+  std::queue<CfgFunc*> funcQueue;
+  funcQueue.push(func);
+  while(!funcQueue.empty()) {
+    func = funcQueue.front();
+    funcQueue.pop();
+    // Start to build CFG for current function
+    InitializeFunction(func);
+    TreeNode *node = func->GetFuncNode();
+    switch(node->GetKind()) {
+      case NK_Function:
+        Visit(static_cast<FunctionNode*>(node)->GetBody());;
+        break;
+      case NK_Lambda:
+        {
+          auto n = static_cast<LambdaNode*>(node)->GetBody();
+          if(n->IsBlock())
+            Visit(n);
+        }
+        break;
+      default:
+        Visit(node);
+    }
+    FinalizeFunction();
+    for(unsigned i = 0; i < func->GetNestedFuncsNum(); ++i) {
+      CfgFunc *f = func->GetNestedFuncAtIndex(i);
+      funcQueue.push(f);
+      mHandler->mModuleFuncs.push_back(f);
+    }
+  }
+}
+
+}
diff --git a/src/MapleFE/astopt/src/ast_dfa.cpp b/src/MapleFE/astopt/src/ast_dfa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3e6918b17001c4d523858a3a637f438307762009
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_dfa.cpp
@@ -0,0 +1,711 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <stack>
+#include <set>
+#include <tuple>
+#include "stringpool.h"
+#include "ast_cfg.h"
+#include "ast_dfa.h"
+
+namespace maplefe {
+
+AST_DFA::~AST_DFA() {
+  mVar2DeclMap.clear();
+  for (auto it: mStmtId2StmtMap) {
+    delete it.second;
+  }
+  mStmtId2StmtMap.clear();
+  for (auto it: mPrsvMap) {
+    delete it.second;
+  }
+  mPrsvMap.clear();
+  for (auto it: mGenMap) {
+    delete it.second;
+  }
+  mGenMap.clear();
+  for (auto it: mRchInMap) {
+    delete it.second;
+  }
+  mRchInMap.clear();
+  for (auto it: mRchOutMap) {
+    delete it.second;
+  }
+}
+
+void AST_DFA::TestBV() {
+  unsigned size = 300;
+  BitVector *bv1 = new BitVector(size);
+  bv1->WipeOff(0xab);
+
+  BitVector *bv2 = new BitVector(size);
+  bv2->WipeOff(0x12);
+
+  DumpBV(bv1);
+  DumpBV(bv2);
+
+  bv1->Or(bv2);
+  DumpBV(bv1);
+
+  bv1->And(bv2);
+  DumpBV(bv1);
+
+  free(bv1);
+  free(bv2);
+}
+
+void AST_DFA::DataFlowAnalysis() {
+  Clear();
+  // TestBV();
+  CollectInfo();
+  CollectDefNodes();
+  BuildBitVectors();
+  BuildDefUseChain();
+  if (mFlags & FLG_trace_3) DumpDefUse();
+}
+
+void AST_DFA::Clear() {
+  mVar2DeclMap.clear();
+  mStmtIdVec.Clear();
+  mStmtId2StmtMap.clear();
+  mDefNodeIdSet.clear();
+  mDefPositionVec.Clear();
+  mUsePositionMap.clear();
+  for (auto it: mStmtId2StmtMap) {
+    delete it.second;
+  }
+  mStmtId2StmtMap.clear();
+  for (auto it: mPrsvMap) {
+    delete it.second;
+  }
+  mPrsvMap.clear();
+  for (auto it: mGenMap) {
+    delete it.second;
+  }
+  mGenMap.clear();
+  for (auto it: mRchInMap) {
+    delete it.second;
+  }
+  mRchInMap.clear();
+  for (auto it: mRchOutMap) {
+    delete it.second;
+  }
+  for (auto it: mPrsvMap) {
+    delete it.second;
+  }
+  mNodeId2StmtIdMap.clear();
+  mStmtId2BbIdMap.clear();
+  mDefStrIdxSet.clear();
+  mDefUseMap.clear();
+}
+
+void AST_DFA::DumpDefPosition(unsigned idx, DefPosition pos) {
+  std::cout << "  DefPos: " << idx;
+  unsigned stridx = pos.first;
+  std::cout << " stridx: " << stridx << " " << gStringPool.GetStringFromStrIdx(stridx) << "\t";
+  unsigned nid = pos.second;
+  std::cout << "nodeid: " << nid << "\t";
+  unsigned sid = GetStmtIdFromNodeId(nid);
+  std::cout << "stmtid: " << sid << "\t";
+  unsigned bbid = GetBbIdFromStmtId(sid);
+  std::cout << "  bbid: " << bbid << "\t";
+  std::cout << std::endl;
+}
+
+void AST_DFA::DumpDefPositionVec() {
+  MSGNOLOC0("============== DefPositionVec ==============");
+  for (unsigned i = 0; i < mDefPositionVec.GetNum(); i++) {
+    DefPosition pos = mDefPositionVec.ValueAtIndex(i);
+    DumpDefPosition(i, pos);
+  }
+}
+
+#define DUMMY_BBID 0xffffffff
+
+unsigned AST_DFA::GetDefStrIdx(TreeNode *node) {
+  unsigned stridx = 0;
+  // pass DUMMY_BBID to indicate to get stridx only
+  AddDef(node, stridx, DUMMY_BBID);
+  return stridx;
+}
+
+// return def-node id defined in node
+// return 0 if node has no def
+unsigned AST_DFA::AddDef(TreeNode *node, unsigned &bitnum, unsigned bbid) {
+  unsigned stridx = 0;
+  unsigned nodeid = 0;
+  bool isDefUse = false;
+  switch (node->GetKind()) {
+    case NK_Decl: {
+      DeclNode *decl = static_cast<DeclNode *>(node);
+      if (decl->GetInit()) {
+        stridx = decl->GetStrIdx();
+        nodeid = decl->GetVar()->GetNodeId();
+      }
+      break;
+    }
+    case NK_BinOperator: {
+      BinOperatorNode *bon = static_cast<BinOperatorNode *>(node);
+      OprId op = bon->GetOprId();
+      switch (op) {
+        case OPR_Assign: {
+          TreeNode *lhs = bon->GetOpndA();
+          if (lhs->IsField()) {
+            lhs = static_cast<FieldNode *>(lhs)->GetUpper();
+          }
+          stridx = lhs->GetStrIdx();
+          nodeid = lhs->GetNodeId();
+          break;
+        }
+        case OPR_AddAssign:
+        case OPR_SubAssign:
+        case OPR_MulAssign:
+        case OPR_DivAssign:
+        case OPR_ModAssign:
+        case OPR_ShlAssign:
+        case OPR_ShrAssign:
+        case OPR_BandAssign:
+        case OPR_BorAssign:
+        case OPR_BxorAssign:
+        case OPR_ZextAssign: {
+          TreeNode *lhs = bon->GetOpndA();
+          if (lhs->IsField()) {
+            lhs = static_cast<FieldNode *>(lhs)->GetUpper();
+          }
+          stridx = lhs->GetStrIdx();
+          nodeid = lhs->GetNodeId();
+          isDefUse = true;
+          break;
+        }
+        default:
+          break;
+      }
+      break;
+    }
+    case NK_UnaOperator: {
+      UnaOperatorNode *uon = static_cast<UnaOperatorNode *>(node);
+      OprId op = uon->GetOprId();
+      if (op == OPR_Inc || op == OPR_Dec || op == OPR_PreInc || op == OPR_PreDec) {
+        TreeNode *lhs = uon->GetOpnd();
+        stridx = lhs->GetStrIdx();
+        nodeid = lhs->GetNodeId();
+        isDefUse = true;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+  // update mDefPositionVec
+  if (stridx) {
+    if (bbid == DUMMY_BBID) {
+      // special usage for GetDefStrIdx(): use bitnum to return stridx
+      bitnum = stridx;
+    } else {
+      DefPosition pos(stridx, nodeid);
+      bitnum++;
+      mDefStrIdxSet.insert(stridx);
+      mDefNodeIdSet.insert(nodeid);
+      if (isDefUse) {
+        mDefUseNodeIdSet.insert(nodeid);
+      }
+      mDefPositionVec.PushBack(pos);
+      return nodeid;
+    }
+  }
+
+  return nodeid;
+}
+
+// this calcuates mDefPositionVec
+void AST_DFA::CollectDefNodes() {
+  MSGNOLOC0("============== CollectDefNodes ==============");
+  std::unordered_set<unsigned> done_list;
+  std::deque<CfgBB *> working_list;
+
+  unsigned bitnum = 0;
+
+  // process each functions
+  for (auto func: mHandler->mModuleFuncs) {
+    // add arguments as def
+    TreeNode *f = static_cast<CfgFunc *>(func)->GetFuncNode();
+    if (f->IsFunction()) {
+      FunctionNode *fn = static_cast<FunctionNode *>(f);
+      for (unsigned i = 0; i < fn->GetParamsNum(); i++) {
+        TreeNode *arg = fn->GetParam(i);
+        if (arg->IsIdentifier()) {
+          unsigned stridx = arg->GetStrIdx();
+          unsigned nodeid = arg->GetNodeId();
+          DefPosition pos(stridx, nodeid);
+          bitnum++;
+          mDefStrIdxSet.insert(stridx);
+          mDefNodeIdSet.insert(nodeid);
+          mDefPositionVec.PushBack(pos);
+          SetNodeId2StmtId(nodeid, fn->GetNodeId());
+        }
+      }
+    }
+
+    CfgBB *bb = func->GetEntryBB();
+    MASSERT(bb && "null BB");
+    unsigned bbid = bb->GetId();
+
+    working_list.push_back(bb);
+
+    while(working_list.size()) {
+      bb = working_list.front();
+      MASSERT(bb && "null BB");
+      bbid = bb->GetId();
+
+      // process bb not visited
+      if (done_list.find(bbid) == done_list.end()) {
+        if (mFlags & FLG_trace_3) std::cout << "working_list work " << bbid << std::endl;
+        for (int i = 0; i < bb->GetStatementsNum(); i++) {
+          TreeNode *stmt = bb->GetStatementAtIndex(i);
+          (void) AddDef(stmt, bitnum, bbid);
+        }
+
+        for (int i = 0; i < bb->GetSuccessorsNum(); i++) {
+          working_list.push_back(bb->GetSuccessorAtIndex(i));
+        }
+
+        done_list.insert(bbid);
+      }
+
+      working_list.pop_front();
+    }
+  }
+
+  if (mFlags & FLG_trace_3) DumpDefPositionVec();
+}
+
+void AST_DFA::BuildBitVectors() {
+  MSGNOLOC0("============== BuildBitVectors ==============");
+  std::unordered_set<unsigned> done_list;
+  std::deque<CfgBB *> working_list;
+
+  // init bit vectors
+  unsigned bvsize = mDefPositionVec.GetNum();
+  for (auto bbid: mHandler->mBbIdVec) {
+    BitVector *bv1 = new BitVector(bvsize);
+    bv1->WipeOff(0xff);                // init with all 1
+    mPrsvMap[bbid] = bv1;
+
+    BitVector *bv2 = new BitVector(bvsize);
+    bv2->WipeOff(0);
+    mGenMap[bbid] = bv2;
+
+    working_list.push_back(mHandler->mBbId2BbMap[bbid]);
+  }
+
+  while(working_list.size()) {
+    CfgBB *bb = working_list.front();
+    MASSERT(bb && "null BB");
+    unsigned bbid = bb->GetId();
+
+    // skip bb already visited
+    if (done_list.find(bbid) != done_list.end()) {
+      working_list.pop_front();
+      continue;
+    }
+
+    for (int it = 0; it < bb->GetSuccessorsNum(); it++) {
+      working_list.push_back(bb->GetSuccessorAtIndex(it));
+    }
+
+    // function parameters are considered defined at function entry bb
+    if (bb->GetAttr() == AK_Entry) {
+      CfgFunc *func = mEntryBbId2FuncMap[bbid];
+      if(func) {
+        FunctionNode *fn = static_cast<FunctionNode *>(func->GetFuncNode());
+        for (unsigned i = 0; i < fn->GetParamsNum(); i++) {
+          TreeNode *arg = fn->GetParam(i);
+          if (arg->IsIdentifier()) {
+            for (int i = 0; i < mDefPositionVec.GetNum(); i++) {
+              // set bits for matching bbid
+              unsigned nid = mDefPositionVec.ValueAtIndex(i).second;
+              unsigned sid = GetStmtIdFromNodeId(nid);
+              unsigned bid = GetBbIdFromStmtId(sid);
+              if (bid == bbid) {
+                mGenMap[bbid]->SetBit(i);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    for (int it = 0; it < bb->GetStatementsNum(); it++) {
+      TreeNode *node = bb->GetStatementAtIndex(it);
+      unsigned stridx = GetDefStrIdx(node);
+      if (stridx != 0) {
+        // now loop through all the definition positions
+        // mPrsvMap
+        for (int i = 0; i < mDefPositionVec.GetNum(); i++) {
+          // clear bits for matching stridx
+          if (mDefPositionVec.ValueAtIndex(i).first == stridx) {
+            mPrsvMap[bbid]->ClearBit(i);
+          }
+        }
+
+        // mGenMap
+        for (int i = 0; i < mDefPositionVec.GetNum(); i++) {
+          // set bits for matching bbid
+          unsigned nid = mDefPositionVec.ValueAtIndex(i).second;
+          unsigned sid = GetStmtIdFromNodeId(nid);
+          unsigned bid = GetBbIdFromStmtId(sid);
+          if (bid == bbid) {
+            mGenMap[bbid]->SetBit(i);
+          }
+        }
+      }
+    }
+
+    done_list.insert(bbid);
+    working_list.pop_front();
+  }
+
+  // mRchInMap
+  for (auto bbid: mHandler->mBbIdVec) {
+    BitVector *bv = new BitVector(bvsize);
+    bv->Alloc(bvsize);
+    bv->WipeOff(0);
+    mRchInMap[bbid] = bv;
+  }
+
+  working_list.clear();
+  // initialize work list with all reachable BB
+  for (auto it: done_list) {
+    CfgBB *bb = mHandler->mBbId2BbMap[it];
+    working_list.push_back(bb);
+  }
+
+  BitVector *old_bv = new BitVector(bvsize);
+  BitVector *tmp_bv = new BitVector(bvsize);
+  while (working_list.size()) {
+    CfgBB *bb = working_list.front();
+    unsigned bbid = bb->GetId();
+
+    tmp_bv->WipeOff(0);
+    old_bv->WipeOff(0);
+    old_bv->Or(mRchInMap[bbid]);
+    mRchInMap[bbid]->WipeOff(0);
+    for (int i = 0; i < bb->GetPredecessorsNum(); i++){
+      CfgBB *pred = bb->GetPredecessorAtIndex(i);
+      unsigned pid = pred->GetId();
+      tmp_bv->WipeOff(0);
+      tmp_bv->Or(mRchInMap[pid]);
+      tmp_bv->And(mPrsvMap[pid]);
+      tmp_bv->Or(mGenMap[pid]);
+      mRchInMap[bbid]->Or(tmp_bv);
+    }
+
+    working_list.pop_front();
+    if (!mRchInMap[bbid]->Equal(old_bv)) {
+      for (int i = 0; i < bb->GetSuccessorsNum(); i++) {
+        working_list.push_back(bb->GetSuccessorAtIndex(i));
+      }
+    }
+  }
+
+  bool buildOutMap = false;
+  if (buildOutMap) {
+    for (auto bbid: mHandler->mBbIdVec) {
+      BitVector *bv = new BitVector(bvsize);
+      bv->Alloc(bvsize);
+      bv->WipeOff(0);
+      mRchOutMap[bbid] = bv;
+    }
+  }
+
+  delete old_bv;
+  delete tmp_bv;
+  if (mFlags & FLG_trace_3) DumpAllBVMaps();
+}
+
+void AST_DFA::DumpAllBVMaps() {
+  MSGNOLOC0("=== mPrsvMap ===");
+  DumpBVMap(mPrsvMap);
+  MSGNOLOC0("=== mGenMap ===");
+  DumpBVMap(mGenMap);
+  MSGNOLOC0("=== mRchInMap ===");
+  DumpBVMap(mRchInMap);
+}
+
+void AST_DFA::DumpBVMap(BVMap &map) {
+  if (!map.size()) { return; }
+  std::set<unsigned> ordered(mHandler->mBbIdVec.begin(), mHandler->mBbIdVec.end());
+  for (auto bbid: ordered) {
+    std::cout << "BB" << bbid << " : ";
+    DumpBV(map[bbid]);
+  }
+  std::cout << std::endl;
+}
+
+void AST_DFA::DumpBV(BitVector *bv) {
+  std::cout << "BitVector: ";
+  for (int i = 0; i < mDefPositionVec.GetNum(); i++) {
+    std::cout << bv->GetBit(i);
+    if (i%8 == 7) std::cout << " ";
+    if (i%64 == 63) {
+      std::cout << std::endl;
+      std::cout << "           ";
+    }
+  }
+  std::cout << std::endl;
+}
+
+void AST_DFA::DumpDefUse() {
+  MSGNOLOC0("============== Dump DefUse ==============");
+  for (unsigned i = 0; i < mDefPositionVec.GetNum(); i++) {
+    DefPosition pos = mDefPositionVec.ValueAtIndex(i);
+    DumpDefPosition(i, pos);
+
+    std::cout << "Use: ";
+    for (auto nid: mDefUseMap[pos.second]) {
+      std::cout << nid << " ";
+    }
+    std::cout << std::endl;
+  }
+}
+
+void AST_DFA::CollectInfo() {
+  MSGNOLOC0("============== CollectInfo ==============");
+  // process each functions for arguments
+  for (auto func: mHandler->mModuleFuncs) {
+    // add arguments as def
+    TreeNode *f = static_cast<CfgFunc *>(func)->GetFuncNode();
+    if (f && f->IsFunction()) {
+      unsigned sid = f->GetNodeId();
+      mStmtIdVec.PushBack(sid);
+
+      // use entry bbid for function and its arguments
+      unsigned bbid = func->GetEntryBB()->GetId();
+      mStmtId2BbIdMap[sid] = bbid;
+      mEntryBbId2FuncMap[bbid] = func;
+
+      FunctionNode *fn = static_cast<FunctionNode *>(f);
+      for (unsigned i = 0; i < fn->GetParamsNum(); i++) {
+        TreeNode *arg = fn->GetParam(i);
+        if (arg->IsIdentifier()) {
+          SetNodeId2StmtId(arg->GetNodeId(), sid);
+        }
+      }
+    }
+  }
+
+  // loop through each BB and each statement
+  CollectInfoVisitor visitor(mHandler, mFlags, true);
+  for (auto bbid: mHandler->mBbIdVec) {
+    visitor.SetBbId(bbid);
+    if (mFlags & FLG_trace_3) std::cout << " == bbid " << bbid << std::endl;
+    CfgBB *bb = mHandler->mBbId2BbMap[bbid];
+    for (int i = 0; i < bb->GetStatementsNum(); i++) {
+      TreeNode *stmt = bb->GetStatementAtIndex(i);
+      // function nodes are handled above
+      // so do not override with real bbid
+      if (stmt->IsFunction()) {
+        continue;
+      }
+      unsigned sid = stmt->GetNodeId();
+      mStmtIdVec.PushBack(sid);
+      mStmtId2StmtMap[sid] = stmt;
+      mStmtId2BbIdMap[sid] = bbid;
+      visitor.SetStmtIdx(stmt->GetNodeId());
+      visitor.SetBbId(bbid);
+      visitor.Visit(stmt);
+    }
+  }
+}
+
+IdentifierNode *CollectInfoVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  AstVisitor::VisitIdentifierNode(node);
+  mDFA->SetNodeId2StmtId(node->GetNodeId(), mStmtIdx);
+  return node;
+}
+
+void AST_DFA::BuildDefUseChain() {
+  MSGNOLOC0("============== BuildDefUseChain ==============");
+  DefUseChainVisitor visitor(mHandler, mFlags, true);
+  std::unordered_set<unsigned> defStrIdxs;
+  std::unordered_set<unsigned> done_list;
+  CfgBB *bb;
+
+  // loop through each variable def
+  for (int i = 0; i < mDefPositionVec.GetNum(); i++) {
+    DefPosition pos = mDefPositionVec.ValueAtIndex(i);
+    if (mFlags & FLG_trace_3) DumpDefPosition(i, pos);
+    std::deque<CfgBB *> working_list;
+
+    // def stridx
+    visitor.mDefStrIdx = pos.first;
+    // def nodeid
+    visitor.mDefNodeId = pos.second;
+    visitor.mReachNewDef = false;
+    unsigned sid = GetStmtIdFromNodeId(visitor.mDefNodeId);
+    unsigned bid = GetBbIdFromStmtId(sid);
+    // check if func entry bb
+    if (mEntryBbId2FuncMap.find(bid) != mEntryBbId2FuncMap.end()) {
+      // func arguments are defined in entry bb, mark defined
+      visitor.mReachDef = true;
+    } else {
+      visitor.mReachDef = false;
+    }
+
+    bb = mHandler->mBbId2BbMap[bid];
+
+    // loop through each BB and each statement
+    working_list.push_back(bb);
+    done_list.clear();
+
+    while(working_list.size()) {
+      bb = working_list.front();
+      MASSERT(bb && "null BB");
+      unsigned bbid = bb->GetId();
+      MSGNOLOC("BB", bbid);
+
+      // check if def is either alive at bb entry or created in bb
+      bool alive = mRchInMap[bbid]->GetBit(i);
+      bool gen = mGenMap[bbid]->GetBit(i);
+      if (!(alive || gen)) {
+        done_list.insert(bbid);
+        working_list.pop_front();
+        continue;
+      }
+
+      // process bb
+      visitor.VisitBB(bbid);
+
+      // add successors to working_list if not in done_list
+      if (done_list.find(bbid) == done_list.end()) {
+        // if new def in bb, then no need to visit successors for the current def
+        if (!visitor.mReachNewDef) {
+          for (int i = 0; i < bb->GetSuccessorsNum(); i++) {
+            working_list.push_back(bb->GetSuccessorAtIndex(i));
+          }
+        }
+      }
+
+      done_list.insert(bbid);
+      working_list.pop_front();
+    }
+  }
+}
+
+void DefUseChainVisitor::VisitBB(unsigned bbid) {
+  SetBbId(bbid);
+  CfgBB *bb = mHandler->mBbId2BbMap[bbid];
+  for (int i = 0; i < bb->GetStatementsNum(); i++) {
+    TreeNode *node = bb->GetStatementAtIndex(i);
+    SetStmtIdx(node->GetNodeId());
+    if (node->IsFunction()) {
+      FunctionNode *func = static_cast<FunctionNode *>(node);
+      for (unsigned i = 0; i < func->GetParamsNum(); i++) {
+        TreeNode *arg = func->GetParam(i);
+        Visit(arg);
+      }
+    } else {
+      Visit(node);
+    }
+    if (mReachNewDef) {
+      return;
+    }
+  }
+  return;
+}
+
+IdentifierNode *DefUseChainVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting IdentifierNode, id=" << node->GetNodeId() << "..." << std::endl;
+
+  // only deal with use with same stridx of current def
+  unsigned stridx = node->GetStrIdx();
+  if (stridx != mDefStrIdx) {
+    return node;
+  }
+
+  // new def, quit
+  unsigned nid = node->GetNodeId();
+  bool isDef = mHandler->GetDFA()->IsDef(nid);
+  bool isUse = mHandler->GetDFA()->IsDefUse(nid);
+  if (isDef) {
+    if (mReachDef) {
+      mReachNewDef = true;
+      if (!isUse) {
+        return node;
+      }
+    } else {
+      mReachDef = true;
+      isUse = false;
+    }
+  } else if (mReachDef) {
+    isUse = true;
+  }
+
+  // exclude its own decl
+  TreeNode *p = node->GetParent();
+  if (p && p->IsDecl()) {
+    DeclNode *dn = static_cast<DeclNode *>(p);
+    if (dn->GetVar() == node) {
+      return node;
+    }
+  }
+
+  // add to mDefUseMap
+  if (isUse) {
+    mDFA->mDefUseMap[mDefNodeId].insert(nid);
+  }
+  return node;
+}
+
+BinOperatorNode *DefUseChainVisitor::VisitBinOperatorNode(BinOperatorNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting BinOperatorNode, id=" << node->GetNodeId() << "..." << std::endl;
+
+  BinOperatorNode *bon = static_cast<BinOperatorNode *>(node);
+  OprId op = bon->GetOprId();
+  switch (op) {
+    case OPR_Assign:
+    case OPR_AddAssign:
+    case OPR_SubAssign:
+    case OPR_MulAssign:
+    case OPR_DivAssign:
+    case OPR_ModAssign:
+    case OPR_ShlAssign:
+    case OPR_ShrAssign:
+    case OPR_BandAssign:
+    case OPR_BorAssign:
+    case OPR_BxorAssign:
+    case OPR_ZextAssign: {
+      // visit rhs first due to computation use/def order
+      TreeNode *rhs = bon->GetOpndB();
+      (void) AstVisitor::VisitTreeNode(rhs);
+
+      TreeNode *lhs = bon->GetOpndA();
+      (void) AstVisitor::VisitTreeNode(lhs);
+      break;
+    }
+    default:
+      TreeNode *lhs = bon->GetOpndA();
+      (void) AstVisitor::VisitTreeNode(lhs);
+
+      TreeNode *rhs = bon->GetOpndB();
+      (void) AstVisitor::VisitTreeNode(rhs);
+      break;
+  }
+  return node;
+}
+
+
+}
diff --git a/src/MapleFE/astopt/src/ast_handler.cpp b/src/MapleFE/astopt/src/ast_handler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d08f7415070c5c5908d0d876d002fec026d97733
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_handler.cpp
@@ -0,0 +1,343 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <stack>
+#include <set>
+#include "ast_handler.h"
+#include "ast_cfg.h"
+#include "ast_info.h"
+#include "ast_adj.h"
+#include "ast_scp.h"
+#include "ast_ti.h"
+#include "ast_cfa.h"
+#include "ast_dfa.h"
+#include "ast_util.h"
+#include "ast_xxport.h"
+#include "astopt.h"
+#include "typetable.h"
+#include "gen_astdump.h"
+
+namespace maplefe {
+
+Module_Handler::~Module_Handler() {
+  mNodeId2BbMap.clear();
+  mModuleFuncs.clear();
+  mBbId2BbMap.clear();
+  mBbIdVec.clear();
+  mNodeId2Decl.clear();
+  mArrayDeclId2EleTypeIdMap.clear();
+  delete mCfgFunc;
+  delete mINFO;
+  delete mADJ;
+  delete mSCP;
+  delete mTI;
+  delete mCFA;
+  delete mDFA;
+  delete mUtil;
+}
+
+MemPool *Module_Handler::GetMemPool() {
+  return mASTHandler->GetMemPool();
+}
+
+Module_Handler *AST_Handler::GetModuleHandler(ModuleNode *module) {
+  for (unsigned i = 0; i < mModuleHandlers.GetNum(); i++) {
+    Module_Handler *h = mModuleHandlers.ValueAtIndex(i);
+    if (h->GetASTModule() == module) {
+      return h;
+    }
+  }
+  return NULL;
+}
+
+Module_Handler *AST_Handler::GetModuleHandler(TreeNode *node) {
+  ASTScope *scp = node->GetScope();
+  while (!scp->GetTree()->IsModule()) {
+    scp = scp->GetParent();
+  }
+  TreeNode *mod = scp->GetTree();
+  Module_Handler *h = NULL;
+  if (mod && mod->IsModule()) {
+    h = GetModuleHandler(static_cast<ModuleNode *>(mod));
+  }
+
+  return h;
+}
+
+HandlerIndex AST_Handler::GetHandlerIndex(const char *filename) {
+  if (mModuleHandlerMap.find(filename) == mModuleHandlerMap.end())
+   return HandlerNotFound;
+  return mModuleHandlerMap.at(filename);
+}
+
+bool AST_Handler::AddModule(ModuleNode *m) {
+  const char *filename = m->GetFilename();
+  if (mModuleHandlerMap.find(filename) != mModuleHandlerMap.end())
+    return false;
+  mModuleHandlerMap[filename] = mSize;
+
+  Module_Handler *handler = new(mMemPool.Alloc(sizeof(Module_Handler))) Module_Handler(mFlags);
+  handler->SetASTModule(m);
+  handler->SetIsTS(m->GetSrcLang() == SrcLangTypeScript);
+  handler->SetASTHandler(this);
+  mModuleHandlers.PushBack(handler);
+  mSize++;
+  return true;
+}
+
+void Module_Handler::BasicAnalysis() {
+  // collect AST info
+  CollectInfo();
+
+  // rewirte some AST nodes
+  AdjustAST();
+
+  // scope analysis
+  ScopeAnalysis();
+}
+
+void Module_Handler::CollectInfo() {
+  if (!mUtil) {
+    mUtil = new(GetMemPool()->Alloc(sizeof(AST_Util))) AST_Util(this, mFlags);
+  }
+  if (!mINFO) {
+    mINFO = new(GetMemPool()->Alloc(sizeof(AST_INFO))) AST_INFO(this, mFlags);
+  }
+  mINFO->CollectInfo();
+}
+
+void Module_Handler::AdjustAST() {
+  if (!mADJ) {
+    mADJ = new(GetMemPool()->Alloc(sizeof(AST_ADJ))) AST_ADJ(this, mFlags);
+  }
+  mADJ->AdjustAST();
+}
+
+void Module_Handler::ScopeAnalysis() {
+  if (!mSCP) {
+    mSCP = new(GetMemPool()->Alloc(sizeof(AST_SCP))) AST_SCP(this, mFlags);
+  }
+  mSCP->ScopeAnalysis();
+
+  if (mFlags & FLG_trace_2) {
+    std::cout << "============== Dump Scope ==============" << std::endl;
+    mASTModule->GetRootScope()->Dump(0);
+  }
+}
+
+void Module_Handler::TypeInference() {
+  if (!mTI) {
+    mTI = new(GetMemPool()->Alloc(sizeof(TypeInfer))) TypeInfer(this, mFlags);
+  }
+  mTI->TypeInference();
+}
+
+void Module_Handler::BuildCFG() {
+  CfgBuilder builder(this, mFlags);
+  builder.Build();
+}
+
+void Module_Handler::ControlFlowAnalysis() {
+  if (!mCFA) {
+    mCFA = new(GetMemPool()->Alloc(sizeof(AST_CFA))) AST_CFA(this, mFlags);
+  }
+  mCFA->ControlFlowAnalysis();
+}
+
+void Module_Handler::DataFlowAnalysis() {
+  if (!mDFA) {
+    mDFA = new(GetMemPool()->Alloc(sizeof(AST_DFA))) AST_DFA(this, mFlags);
+  }
+  mDFA->DataFlowAnalysis();
+}
+
+AstOpt *Module_Handler::GetAstOpt() {
+  return mASTHandler->GetAstOpt();
+}
+
+AST_XXport *Module_Handler::GetASTXXport() {
+  return mASTHandler->GetAstOpt()->GetASTXXport();
+}
+
+// input an identifire ===> returen the decl node with same name
+TreeNode *Module_Handler::FindDecl(IdentifierNode *node, bool deep) {
+  TreeNode *decl = NULL;
+  if (!node) {
+    return decl;
+  }
+  unsigned nid = node->GetNodeId();
+
+  // search the existing map mNodeId2Decl first
+  if (mNodeId2Decl.find(nid) != mNodeId2Decl.end()) {
+    decl = mNodeId2Decl[nid];
+    // deep search for imported decl, chase down
+    if (deep && decl && GetASTXXport()->IsImportedDeclId(mHidx, decl->GetNodeId())) {
+      decl = GetASTXXport()->GetExportedNodeFromImportedNode(mHidx, decl->GetNodeId());
+    }
+    return decl;
+  }
+
+  ASTScope *scope = node->GetScope();
+  MASSERT(scope && "null scope");
+
+  TreeNode *tree = scope->GetTree();
+  unsigned stridx = node->GetStrIdx();
+
+  decl = mINFO->GetField(tree->GetNodeId(), stridx);
+
+  if (!decl) {
+    decl = scope->FindDeclOf(stridx);
+  }
+
+  if (!decl && deep) {
+    decl = scope->FindExportedDeclOf(stridx);
+  }
+
+  if (decl) {
+    AddNodeId2DeclMap(node->GetNodeId(), decl);
+  }
+
+  if (deep && decl && GetASTXXport()->IsImportedDeclId(mHidx, decl->GetNodeId())) {
+    decl = GetASTXXport()->GetExportedNodeFromImportedNode(mHidx, decl->GetNodeId());
+  }
+
+  return decl;
+}
+
+TreeNode *Module_Handler::FindType(IdentifierNode *node) {
+  if (!node) {
+    return NULL;
+  }
+  ASTScope *scope = node->GetScope();
+  MASSERT(scope && "null scope");
+  TreeNode *type = scope->FindTypeOf(node->GetStrIdx());
+
+  return type;
+}
+
+// input a node ==> return the function node contains it
+TreeNode *Module_Handler::FindFunc(TreeNode *node) {
+  ASTScope *scope = node->GetScope();
+  MASSERT(scope && "null scope");
+  while (scope) {
+    TreeNode *sn = scope->GetTree();
+    if (sn->IsFunction()) {
+      return sn;
+    }
+    scope = scope->GetParent();
+  }
+  return NULL;
+}
+
+void Module_Handler::AddDirectField(TreeNode *node) {
+  mDirectFieldSet.insert(node->GetNodeId());
+}
+
+bool Module_Handler::IsDirectField(TreeNode *node) {
+  return mDirectFieldSet.find(node->GetNodeId()) != mDirectFieldSet.end();
+}
+
+// array's element typeid
+TypeId Module_Handler::GetArrayElemTypeId(unsigned nid) {
+  TypeId tid = TY_None;
+  if (mArrayDeclId2EleTypeIdMap.find(nid) != mArrayDeclId2EleTypeIdMap.end()) {
+    tid = mArrayDeclId2EleTypeIdMap[nid];
+  }
+  return tid;
+}
+
+void Module_Handler::SetArrayElemTypeId(unsigned nid, TypeId tid) {
+  mArrayDeclId2EleTypeIdMap[nid] = tid;
+}
+
+// array's element typeidx
+unsigned Module_Handler::GetArrayElemTypeIdx(unsigned nid) {
+  unsigned tidx = 0;
+  if (mArrayDeclId2EleTypeIdxMap.find(nid) != mArrayDeclId2EleTypeIdxMap.end()) {
+    tidx = mArrayDeclId2EleTypeIdxMap[nid];
+  }
+  return tidx;
+}
+
+void Module_Handler::SetArrayElemTypeIdx(unsigned nid, unsigned tidx) {
+  mArrayDeclId2EleTypeIdxMap[nid] = tidx;
+}
+
+DimensionNode *Module_Handler::GetArrayDim(unsigned nid) {
+  DimensionNode *dim = NULL;
+  if (mArrayDeclId2DimMap.find(nid) != mArrayDeclId2DimMap.end()) {
+    dim = mArrayDeclId2DimMap[nid];
+  }
+  return dim;
+}
+
+void Module_Handler::SetArrayDim(unsigned nid, DimensionNode *dim) {
+  mArrayDeclId2DimMap[nid] = dim;
+}
+
+void Module_Handler::AddGeneratorUsed(unsigned nid, FunctionNode *func) {
+  mGeneratorUsedMap[nid] = func;
+}
+
+bool Module_Handler::IsGeneratorUsed(unsigned nid) {
+  return (mGeneratorUsedMap.find(nid) != mGeneratorUsedMap.end());
+}
+
+FunctionNode *Module_Handler::GetGeneratorUsed(unsigned nid) {
+  if (mGeneratorUsedMap.find(nid) != mGeneratorUsedMap.end()) {
+    return mGeneratorUsedMap[nid];
+  }
+  return NULL;
+}
+
+bool Module_Handler::UpdateGeneratorUsed(unsigned target, unsigned src) {
+  if (mGeneratorUsedMap.find(src) != mGeneratorUsedMap.end()) {
+    mGeneratorUsedMap[target] = mGeneratorUsedMap[src];
+    return true;
+  }
+  return false;
+}
+
+bool Module_Handler::IsFromLambda(TreeNode *node) {
+  if (!node) {
+    return false;
+  }
+  unsigned nid = node->GetNodeId();
+  return mINFO->IsFromLambda(nid);
+}
+
+bool Module_Handler::IsDef(TreeNode *node) {
+  return mDFA->IsDef(node->GetNodeId());
+}
+
+bool Module_Handler::IsCppField(TreeNode *node) {
+  return mUtil->IsCppField(node);
+}
+
+void Module_Handler::Dump(char *msg) {
+  std::cout << msg << " : " << std::endl;
+  CfgFunc *func = GetCfgFunc();
+  func->Dump();
+}
+
+void Module_Handler::DumpArrayElemTypeIdMap() {
+  std::cout << "================= ArrayDeclId2EleTypeIdMap ==========" << std::endl;
+  for (auto it : mArrayDeclId2EleTypeIdMap) {
+    std::cout << "nodeid : " << it.first  << " "
+              << AstDump::GetEnumTypeId(it.second) << std::endl;
+  }
+}
+
+}
diff --git a/src/MapleFE/astopt/src/ast_info.cpp b/src/MapleFE/astopt/src/ast_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5c8ef881ec5d39d5ac2f54f6a6cae737fbb8cb82
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_info.cpp
@@ -0,0 +1,977 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <stack>
+#include <set>
+#include <algorithm>
+#include "ast_handler.h"
+#include "typetable.h"
+#include "ast_util.h"
+#include "ast_info.h"
+#include "ast_xxport.h"
+
+namespace maplefe {
+
+void AST_INFO::CollectInfo() {
+  MSGNOLOC0("============== ASTInfo ==============");
+  ModuleNode *module = mHandler->GetASTModule();
+  for(unsigned i = 0; i < module->GetTreesNum(); i++) {
+    TreeNode *it = module->GetTree(i);
+    it->SetParent(module);
+  }
+
+  AddBuiltInTypes();
+
+  // collect import/export info
+  MSGNOLOC0("============== XXport info ==============");
+  mHandler->GetASTXXport()->CollectXXportInfo(mHandler->GetHidx());
+
+  MSGNOLOC0("============== Fill node info ==============");
+  FillNodeInfoVisitor visitor_node(mHandler, mFlags, true);
+  visitor_node.Visit(module);
+
+  mStrIdxVisitor = new FindStrIdxVisitor(mHandler, mFlags, true);
+
+  // collect class/interface/struct decl
+  mPass = 0;
+  MSGNOLOC0("============== Collect class/interface/struct ==============");
+  ClassStructVisitor visitor(mHandler, mFlags, true);
+  visitor.Visit(module);
+
+  if (module->GetSrcLang() != SrcLangTypeScript) {
+    return;
+  }
+
+  // collect type parameters
+  // sort fields according to the field name stridx
+  // it also include first visit to named types to reduce
+  // creation of unnecessary anonymous struct
+  mPass = 1;
+  MSGNOLOC0("============== type parameter, super fields and Sort fields ==============");
+  visitor.Visit(module);
+
+  // merge class/interface/struct decl first to reduce
+  // introducing of unnecessary anonymous structs
+  mPass = 2;
+  MSGNOLOC0("============== merge class/interface/struct ==============");
+  visitor.Visit(module);
+
+  // collect function types
+  FunctionVisitor func_visitor(mHandler, mFlags, true);
+  func_visitor.Visit(module);
+}
+
+void AST_INFO::AddBuiltInTypes() {
+  unsigned size = gTypeTable.size();
+  for (unsigned idx = 1; idx < size; idx++) {
+    TreeNode *node = gTypeTable.GetTypeFromTypeIdx(idx);
+    if (node->IsUserType()) {
+      mStrIdx2TypeIdxMap[node->GetStrIdx()] = node->GetTypeIdx();
+    }
+  }
+
+  // add language builtin types
+  TreeNode *node = NULL;
+  unsigned stridx = 0;
+#define BUILTIN(T) \
+  stridx = gStringPool.GetStrIdx(#T);\
+  if (mStrIdx2TypeIdxMap.find(stridx) == mStrIdx2TypeIdxMap.end()) {\
+    node = gTypeTable.CreateBuiltinType(#T, TY_Class);\
+    gTypeTable.AddType(node);\
+    mStrIdx2TypeIdxMap[stridx] = node->GetTypeIdx();\
+  }
+#include "lang_builtin.def"
+}
+
+bool AST_INFO::IsBuiltInType(TreeNode *node) {
+  return mStrIdx2TypeIdxMap.find(node->GetStrIdx()) != mStrIdx2TypeIdxMap.end();
+}
+
+unsigned AST_INFO::GetBuiltInTypeIdx(unsigned stridx) {
+  if (mStrIdx2TypeIdxMap.find(stridx) != mStrIdx2TypeIdxMap.end()) {
+    return mStrIdx2TypeIdxMap[stridx];
+  }
+  return 0;
+}
+
+unsigned AST_INFO::GetBuiltInTypeIdx(TreeNode *node) {
+  unsigned stridx = node->GetStrIdx();
+  return GetBuiltInTypeIdx(stridx);
+}
+
+TypeId AST_INFO::GetTypeId(TreeNode *node) {
+  return node->GetTypeId();
+}
+
+unsigned AST_INFO::GetFieldsSize(TreeNode *node, bool native) {
+  unsigned size = 0;
+  unsigned nid = node->GetNodeId();
+  if (!native && mStructId2FieldsMap.find(nid) != mStructId2FieldsMap.end()) {
+    size = mStructId2FieldsMap[nid].GetNum();
+    return size;
+  }
+  switch (node->GetKind()) {
+    case NK_StructLiteral:
+      size = static_cast<StructLiteralNode *>(node)->GetFieldsNum();
+      break;
+    case NK_Struct:
+      size = static_cast<StructNode *>(node)->GetFieldsNum();
+      break;
+    case NK_Class:
+      size = static_cast<ClassNode *>(node)->GetFieldsNum();
+      break;
+    case NK_Interface:
+      size = static_cast<InterfaceNode *>(node)->GetFieldsNum();
+      break;
+    default:
+      break;
+  }
+  return size;
+}
+
+TreeNode *AST_INFO::GetField(TreeNode *node, unsigned i, bool native) {
+  TreeNode *fld = NULL;
+  unsigned nid = node->GetNodeId();
+  if (!native && mStructId2FieldsMap.find(nid) != mStructId2FieldsMap.end()) {
+    fld = mStructId2FieldsMap[nid].ValueAtIndex(i);
+    return fld;
+  }
+  switch (node->GetKind()) {
+    case NK_StructLiteral:
+      fld = static_cast<StructLiteralNode *>(node)->GetField(i);
+      break;
+    case NK_Struct:
+      fld = static_cast<StructNode *>(node)->GetField(i);
+      break;
+    case NK_Class:
+      fld = static_cast<ClassNode *>(node)->GetField(i);
+      break;
+    case NK_Interface:
+      fld = static_cast<InterfaceNode *>(node)->GetField(i);
+      break;
+    default:
+      break;
+  }
+  return fld;
+}
+
+void AST_INFO::AddField(TreeNode *container, TreeNode *node) {
+  unsigned nid = container->GetNodeId();
+  if (mStructId2FieldsMap.find(nid) == mStructId2FieldsMap.end()) {
+    for (unsigned i = 0; i < GetFieldsSize(container, true); i++) {
+      TreeNode *fld = GetField(container, i, true);
+      mStructId2FieldsMap[nid].PushBack(fld);
+    }
+  }
+  AddField(nid, node);
+}
+
+void AST_INFO::AddField(unsigned nid, TreeNode *node) {
+  mStructId2FieldsMap[nid].PushBack(node);
+}
+
+// get the filed in nid, including its super, with name stridx
+// return NULL if not found
+TreeNode *AST_INFO::GetField(unsigned nid, unsigned stridx) {
+  if (mStructId2FieldsMap.find(nid) != mStructId2FieldsMap.end()) {
+    unsigned size = mStructId2FieldsMap[nid].GetNum();
+    for (unsigned i = 0; i < size; i++) {
+      TreeNode *fld = mStructId2FieldsMap[nid].ValueAtIndex(i);
+      if (fld->GetStrIdx() == stridx) {
+        return fld;
+      }
+    }
+  }
+  return NULL;
+}
+
+unsigned AST_INFO::GetSuperSize(TreeNode *node, unsigned idx) {
+  unsigned size1 = 0;
+  unsigned size2 = 0;
+  switch (node->GetKind()) {
+    case NK_Struct: {
+      size1 = static_cast<StructNode *>(node)->GetSupersNum();
+      size2 = 0;
+      break;
+    }
+    case NK_Class: {
+      size1 = static_cast<ClassNode *>(node)->GetSuperClassesNum();
+      size2 = static_cast<ClassNode *>(node)->GetSuperInterfacesNum();
+      break;
+    }
+    case NK_Interface: {
+      size1 = static_cast<InterfaceNode *>(node)->GetSuperInterfacesNum();
+      size2 = 0;
+      break;
+    }
+    default:
+      break;
+  }
+  return (idx == 1) ? size1 : size2;
+}
+
+TreeNode *AST_INFO::GetSuper(TreeNode *node, unsigned i, unsigned idx) {
+  TreeNode *fld1 = NULL;
+  TreeNode *fld2 = NULL;
+  switch (node->GetKind()) {
+    case NK_Struct:
+      fld1 = static_cast<StructNode *>(node)->GetSuper(i);
+      fld2 = NULL;
+      break;
+    case NK_Class: {
+      fld1 = (idx == 1) ? static_cast<ClassNode *>(node)->GetSuperClass(i) : NULL;
+      fld2 = (idx == 2) ? static_cast<ClassNode *>(node)->GetSuperInterface(i) : NULL;
+      break;
+    }
+    case NK_Interface:
+      fld1 = static_cast<InterfaceNode *>(node)->GetSuperInterfaceAtIndex(i);
+      fld2 = NULL;
+      break;
+    default:
+      break;
+  }
+  return (idx == 1) ? fld1 : fld2;
+}
+
+bool AST_INFO::IsInterface(TreeNode *node) {
+  bool isI = node->IsInterface();
+  if (node->IsStruct()) {
+    isI = isI || (static_cast<StructNode *>(node)->GetProp() == SProp_TSInterface);
+  }
+  return isI;
+}
+
+bool AST_INFO::IsTypeCompatible(TreeNode *node1, TreeNode *node2) {
+  if (node1 == node2) {
+    return true;
+  }
+  // only one is NULL
+  if ((!node1 && node2) || (node1 && !node2)) {
+    return false;
+  }
+  // not same kind
+  if (node1->GetKind() != node2->GetKind()) {
+    return false;
+  }
+  // at least one is prim
+  if (node1->IsPrimType() || node2->IsPrimType()) {
+    TypeId tid_field = GetTypeId(node2);
+    TypeId tid_target = GetTypeId(node1);
+    return (tid_field == tid_target);
+  }
+  bool result = false;
+  // same kind
+  NodeKind nk = node1->GetKind();
+  switch (nk) {
+    case NK_UserType: {
+      UserTypeNode *ut1 = static_cast<UserTypeNode *>(node1);
+      UserTypeNode *ut2 = static_cast<UserTypeNode *>(node2);
+      result = IsTypeCompatible(ut1->GetId(), ut2->GetId());
+    }
+    case NK_PrimType: {
+      PrimTypeNode *pt1 = static_cast<PrimTypeNode *>(node1);
+      PrimTypeNode *pt2 = static_cast<PrimTypeNode *>(node2);
+      result = (pt1->GetPrimType() == pt2->GetPrimType());
+    }
+    case NK_PrimArrayType: {
+      PrimArrayTypeNode *pat1 = static_cast<PrimArrayTypeNode *>(node1);
+      PrimArrayTypeNode *pat2 = static_cast<PrimArrayTypeNode *>(node2);
+      result = IsTypeCompatible(pat1->GetPrim(), pat2->GetPrim());
+      if (!result) {
+        break;
+      }
+      result = IsTypeCompatible(pat1->GetDims(), pat2->GetDims());
+    }
+    case NK_Dimension: {
+      DimensionNode *dim1 = static_cast<DimensionNode *>(node1);
+      DimensionNode *dim2 = static_cast<DimensionNode *>(node2);
+      result = (dim1->GetDimensionsNum() == dim2->GetDimensionsNum());
+      if (!result) {
+        break;
+      }
+      for (unsigned i = 0; i < dim1->GetDimensionsNum(); i++) {
+        result = result && (dim1->GetDimension(i) == dim2->GetDimension(i));
+      }
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  return result;
+}
+
+bool AST_INFO::IsTypeIdCompatibleTo(TypeId field, TypeId target) {
+  if (target == TY_None) {
+    return true;
+  }  else if (target == TY_Number) {
+    return field == TY_Int || field == TY_Long || field == TY_Float || field == TY_Double;
+  } else {
+    return field == target;
+  }
+  return false;
+}
+
+// check if "field" is compatible to "target"
+bool AST_INFO::IsFieldCompatibleTo(TreeNode *field, TreeNode *target) {
+  if (!target->IsIdentifier()) {
+    return false;
+  }
+  unsigned stridx_target = target->GetStrIdx();
+  IdentifierNode *id_target = static_cast<IdentifierNode *>(target);
+
+  unsigned stridx_field = 0;
+  bool result = false;
+
+  // is identifier
+  if (field->IsIdentifier()) {
+    stridx_field = field->GetStrIdx();
+    if (stridx_field != stridx_target) {
+      return false;
+    }
+    IdentifierNode *id_field = static_cast<IdentifierNode *>(field);
+    TreeNode *type_target = id_target->GetType();
+    TreeNode *type_field = id_field->GetType();
+    result = IsTypeCompatible(type_field, type_target);
+  }
+  // field literal
+  else if (field->IsFieldLiteral()) {
+    FieldLiteralNode *fln = static_cast<FieldLiteralNode *>(field);
+    TreeNode *name = fln->GetFieldName();
+    if (name && name->IsIdentifier()) {
+      stridx_field = name->GetStrIdx();
+    }
+    if (stridx_field != stridx_target) {
+      return false;
+    }
+    TreeNode *lit = fln->GetLiteral();
+    if (!lit->IsLiteral()) {
+      return false;
+    }
+    LiteralNode *ln = static_cast<LiteralNode *>(lit);
+    TypeId tid_field = GetTypeId(ln);
+    TypeId tid_target = GetTypeId(id_target->GetType());
+    result = IsTypeIdCompatibleTo(tid_field, tid_target);
+  }
+
+  return result;
+}
+
+TreeNode *AST_INFO::GetCanonicStructNode(TreeNode *node) {
+  // node with super does not map to others
+  if (WithSuper(node)) {
+    return node;
+  }
+
+  unsigned size = GetFieldsSize(node);
+  bool isI0 = IsInterface(node);
+
+  for (auto s: mFieldNum2StructNodeMap[size]) {
+    // found itself
+    if (node == s) {
+      return s;
+    }
+
+    bool isI = IsInterface(s);
+    if (!node->IsStructLiteral()) {
+      // skip if one is interface but other is not
+      if ((isI0 && !isI) || (!isI0 && isI)) {
+        continue;
+      }
+    }
+    bool match = true;;
+    // check fields
+    for (unsigned fid = 0; fid < size; fid++) {
+      TreeNode *f0 = GetField(node, fid);
+      TreeNode *f1 = GetField(s, fid);
+      if (!IsFieldCompatibleTo(f0, f1)) {
+        match = false;
+        break;
+      }
+    }
+
+    if (match) {
+      node->SetTypeIdx(s->GetTypeIdx());
+      return s;
+    }
+  }
+
+  // do not proceed if node contains type parameter
+  if (WithTypeParamFast(node)) {
+    return node;
+  }
+
+  // not match
+  unsigned stridx = node->GetStrIdx();
+
+  // node as anonymous struct will be added to module scope
+  if (GetNameAnonyStruct() && stridx == 0) {
+    TreeNode *anony = GetAnonymousStruct(node);
+    if (!anony) {
+      return node;
+    } else {
+      node->SetTypeIdx(anony->GetTypeIdx());
+      node = anony;
+    }
+  }
+  mFieldNum2StructNodeMap[size].insert(node);
+
+  return node;
+}
+
+IdentifierNode *AST_INFO::CreateIdentifierNode(unsigned stridx) {
+  IdentifierNode *node = mHandler->NewTreeNode<IdentifierNode>();
+  node->SetStrIdx(stridx);
+  return node;
+}
+
+UserTypeNode *AST_INFO::CreateUserTypeNode(unsigned stridx, ASTScope *scope) {
+  unsigned tidx = GetBuiltInTypeIdx(stridx);
+  IdentifierNode *node = CreateIdentifierNode(stridx);
+  SetTypeId(node, TY_Class);
+  SetTypeIdx(node, tidx);
+  if (scope) {
+    node->SetScope(scope);
+  }
+
+  UserTypeNode *utype = mHandler->NewTreeNode<UserTypeNode>();
+  utype->SetId(node);
+  utype->SetStrIdx(stridx);
+  SetTypeId(utype, TY_Class);
+  SetTypeIdx(utype, tidx);
+  node->SetParent(utype);
+  return utype;
+}
+
+UserTypeNode *AST_INFO::CreateUserTypeNode(IdentifierNode *node) {
+  SetTypeId(node, TY_Class);
+  UserTypeNode *utype = mHandler->NewTreeNode<UserTypeNode>();
+  utype->SetId(node);
+  utype->SetStrIdx(node->GetStrIdx());
+  SetTypeId(utype, TY_Class);
+  node->SetParent(utype);
+  return utype;
+}
+
+TypeAliasNode *AST_INFO::CreateTypeAliasNode(TreeNode *to, TreeNode *from) {
+  UserTypeNode *utype1 = CreateUserTypeNode(from->GetStrIdx());
+  UserTypeNode *utype2 = CreateUserTypeNode(to->GetStrIdx());
+
+  TypeAliasNode *alias = mHandler->NewTreeNode<TypeAliasNode>();
+  alias->SetId(utype1);
+  alias->SetStrIdx(from->GetStrIdx());
+  alias->SetAlias(utype2);
+
+  return alias;
+}
+
+StructNode *AST_INFO::CreateStructFromStructLiteral(StructLiteralNode *node) {
+  StructNode *newnode = mHandler->NewTreeNode<StructNode>();
+  SetTypeId(newnode, TY_Class);
+
+  for (unsigned i = 0; i < node->GetFieldsNum(); i++) {
+    FieldLiteralNode *fl = node->GetField(i);
+    TreeNode *name = fl->GetFieldName();
+    if (!name || !name->IsIdentifier()) {
+      newnode->Release();
+      return NULL;
+    }
+
+    IdentifierNode *fid = CreateIdentifierNode(name->GetStrIdx());
+    newnode->AddField(fid);
+    mHandler->AddDirectField(fid);
+
+    TreeNode *lit = fl->GetLiteral();
+    if (lit && lit->IsLiteral()) {
+      TypeId tid = GetTypeId(lit);
+      PrimTypeNode *type = mHandler->NewTreeNode<PrimTypeNode>();
+      type->SetPrimType(tid);
+      fid->SetType(type);
+    } else {
+      NOTYETIMPL("StructLiteralNode literal field kind");
+    }
+  }
+  return newnode;
+}
+
+unsigned AST_INFO::GetAnonymousName() {
+  std::string str("AnonymousStruct__");
+  str += std::to_string(mNum++);
+  unsigned stridx = gStringPool.GetStrIdx(str);
+  return stridx;
+}
+
+TreeNode *AST_INFO::GetAnonymousStruct(TreeNode *node) {
+  unsigned stridx = GetAnonymousName();
+  TreeNode *newnode = node;
+  if (newnode->IsStructLiteral()) {
+    StructLiteralNode *sl = static_cast<StructLiteralNode*>(node);
+    newnode = CreateStructFromStructLiteral(sl);
+    if (!newnode) {
+      return NULL;
+    }
+  }
+  newnode->SetStrIdx(stridx);
+
+  // for struct node, set structid
+  if (newnode->IsStruct()) {
+    StructNode *snode = static_cast<StructNode *>(newnode);
+    IdentifierNode *id = snode->GetStructId();
+    if (!id) {
+      id = CreateIdentifierNode(0);
+      id->SetScope(snode->GetScope());
+      snode->SetStructId(id);
+    }
+
+    // set stridx for structid
+    id->SetStrIdx(stridx);
+  }
+
+  ModuleNode *module = mHandler->GetASTModule();
+  gTypeTable.AddType(newnode);
+  module->GetScope()->AddType(newnode);
+  module->AddTreeFront(newnode);
+  return newnode;
+}
+
+bool AST_INFO::WithStrIdx(TreeNode *node, unsigned stridx) {
+  mStrIdxVisitor->ResetFound();
+  mStrIdxVisitor->SetStrIdx(stridx);
+  mStrIdxVisitor->Visit(node);
+  return mStrIdxVisitor->GetFound();
+}
+
+bool AST_INFO::WithTypeParam(TreeNode *node) {
+  for (auto idx: mTypeParamStrIdxSet) {
+    if (WithStrIdx(node, idx)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AST_INFO::WithThis(TreeNode *node) {
+  unsigned idx = gStringPool.GetStrIdx("this");
+  mStrIdxVisitor->SetCheckThis(true);
+  if (WithStrIdx(node, idx)) {
+    return true;
+  }
+  return false;
+}
+
+bool AST_INFO::WithTypeParamFast(TreeNode *node) {
+  return (mWithTypeParamNodeSet.find(node->GetNodeId()) != mWithTypeParamNodeSet.end());
+}
+
+bool AST_INFO::WithSuper(TreeNode *node) {
+  unsigned supernum = 0;
+  switch (node->GetKind()) {
+    case NK_Class:
+      supernum = static_cast<ClassNode *>(node)->GetSuperClassesNum();
+      break;
+    case NK_Interface:
+      supernum = static_cast<InterfaceNode *>(node)->GetSuperInterfacesNum();
+      break;
+    default:
+      break;
+  }
+  return (supernum != 0);
+}
+
+template <typename T1>
+void AST_INFO::ExtendFields(T1 *node, TreeNode *sup) {
+  if (sup == NULL) {
+    // let sup be node itself
+    sup = node;
+  }
+  unsigned nid = node->GetNodeId();
+  if (sup && sup->IsUserType()) {
+    sup = static_cast<UserTypeNode *>(sup)->GetId();
+  }
+  if (sup && sup->IsIdentifier()) {
+    sup = GetStructFromStrIdx(sup->GetStrIdx());
+  }
+  if (!sup) {
+    return;
+  }
+  for (unsigned i = 0; i < GetFieldsSize(sup, true); i++) {
+    TreeNode *fld = GetField(sup, i, true);
+    AddField(nid, fld);
+  }
+  for (unsigned i = 0; i < GetSuperSize(sup, 1); i++) {
+    TreeNode *s = GetSuper(sup, i, 1);
+    ExtendFields<T1>(node, s);
+  }
+  for (unsigned i = 0; i < GetSuperSize(sup, 2); i++) {
+    TreeNode *s = GetSuper(sup, i, 2);
+    ExtendFields<T1>(node, s);
+  }
+}
+
+template <typename T1>
+static void DumpVec(std::vector<std::pair<unsigned, T1 *>> vec) {
+  unsigned size = vec.size();
+  std::cout << "================ Dump Vec ================" << std::endl;
+  for (unsigned i = 0; i < size; i++) {
+    std::cout << "item #" << i
+              << " nodeid " << vec[i].second->GetNodeId()
+              << " stridx " << vec[i].second->GetStrIdx()
+              << std::endl;
+  }
+}
+
+template <typename T1, typename T2>
+void AST_INFO::SortFields(T1 *node) {
+  std::vector<std::pair<unsigned, T2 *>> vec;
+  unsigned size = GetFieldsSize(node, true);
+  if (size) {
+    for (unsigned i = 0; i < size; i++) {
+      T2 *fld = node->GetField(i);
+      unsigned stridx = fld->GetStrIdx();
+      std::pair<unsigned, T2*> p(stridx, fld);
+      vec.push_back(p);
+    }
+    std::sort(vec.begin(), vec.end());
+    for (unsigned i = 0; i < size; i++) {
+      node->SetField(i, vec[i].second);
+    }
+  }
+
+  unsigned nid = node->GetNodeId();
+  if (mStructId2FieldsMap.find(nid) != mStructId2FieldsMap.end()) {
+    std::vector<std::pair<unsigned, TreeNode *>> vec;
+    unsigned size = mStructId2FieldsMap[nid].GetNum();
+    for (unsigned i = 0; i < size; i++) {
+      TreeNode *fld = mStructId2FieldsMap[nid].ValueAtIndex(i);
+      unsigned stridx = fld->GetStrIdx();
+      std::pair<unsigned, TreeNode*> p(stridx, fld);
+      vec.push_back(p);
+    }
+    std::sort(vec.begin(), vec.end());
+    for (unsigned i = 0; i < size; i++) {
+      *(mStructId2FieldsMap[nid].RefAtIndex(i)) = vec[i].second;
+    }
+  }
+}
+
+void AST_INFO::SetTypeId(TreeNode *node, TypeId tid) {
+  mHandler->GetUtil()->SetTypeId(node, tid);
+}
+
+void AST_INFO::SetTypeIdx(TreeNode *node, unsigned tidx) {
+  mHandler->GetUtil()->SetTypeIdx(node, tidx);
+}
+
+IdentifierNode *FillNodeInfoVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  (void) AstVisitor::VisitIdentifierNode(node);
+  TreeNode *type = node->GetType();
+  if (type) {
+    mInfo->SetTypeId(node, type->GetTypeId());
+    mInfo->SetTypeIdx(node, type->GetTypeIdx());
+  }
+  return node;
+}
+
+FunctionNode *FillNodeInfoVisitor::VisitFunctionNode(FunctionNode *node) {
+  (void) AstVisitor::VisitFunctionNode(node);
+  TreeNode *type = node->GetRetType();
+  if (type) {
+    mInfo->SetTypeId(node, type->GetTypeId());
+    mInfo->SetTypeIdx(node, type->GetTypeIdx());
+  } else if (node->IsGenerator()) {
+    unsigned stridx = gStringPool.GetStrIdx("Generator");
+    unsigned tidx = mInfo->GetBuiltInTypeIdx(stridx);
+    UserTypeNode *ut = mInfo->CreateUserTypeNode(stridx);
+    node->SetRetType(ut);
+  }
+  return node;
+}
+
+LiteralNode *FillNodeInfoVisitor::VisitLiteralNode(LiteralNode *node) {
+  (void) AstVisitor::VisitLiteralNode(node);
+  LitData data = node->GetData();
+  LitId id = data.mType;
+  switch (id) {
+    case LT_IntegerLiteral:
+      mInfo->SetTypeId(node, TY_Int);
+      mInfo->SetTypeIdx(node, TY_Int);
+      break;
+    case LT_FPLiteral:
+      mInfo->SetTypeId(node, TY_Float);
+      mInfo->SetTypeIdx(node, TY_Float);
+      break;
+    case LT_DoubleLiteral:
+      mInfo->SetTypeId(node, TY_Double);
+      mInfo->SetTypeIdx(node, TY_Double);
+      break;
+    case LT_BooleanLiteral:
+      mInfo->SetTypeId(node, TY_Boolean);
+      mInfo->SetTypeIdx(node, TY_Boolean);
+      break;
+    case LT_CharacterLiteral:
+      mInfo->SetTypeId(node, TY_Char);
+      mInfo->SetTypeIdx(node, TY_Char);
+      break;
+    case LT_StringLiteral:
+      mInfo->SetTypeId(node, TY_String);
+      mInfo->SetTypeIdx(node, TY_String);
+      if (node->GetStrIdx() == 0) {
+        node->SetStrIdx(data.mData.mStrIdx);
+      }
+      break;
+    case LT_NullLiteral:
+      mInfo->SetTypeId(node, TY_Null);
+      break;
+    case LT_SuperLiteral:
+      mInfo->SetTypeId(node, TY_Object);
+      break;
+    case LT_VoidLiteral:
+      mInfo->SetTypeId(node, TY_Void);
+      break;
+    case LT_ThisLiteral:
+      break;
+    default:
+      break;
+  }
+  return node;
+}
+
+PrimTypeNode *FillNodeInfoVisitor::VisitPrimTypeNode(PrimTypeNode *node) {
+  (void) AstVisitor::VisitPrimTypeNode(node);
+  TypeId prim = node->GetPrimType();
+  bool isprim = gTypeTable.IsPrimTypeId(prim);
+
+  if (isprim) {
+    mInfo->SetTypeIdx(node, prim);
+  } else {
+    TreeNode *type = gTypeTable.GetTypeFromTypeId(prim);
+    mInfo->SetTypeIdx(node, type->GetTypeIdx());
+  }
+  return node;
+}
+
+UserTypeNode *FillNodeInfoVisitor::VisitUserTypeNode(UserTypeNode *node) {
+  (void) AstVisitor::VisitUserTypeNode(node);
+  TreeNode *id = node->GetId();
+  if (id) {
+    unsigned tidx = mInfo->GetBuiltInTypeIdx(id);
+    if (tidx) {
+      mInfo->SetTypeIdx(id, tidx);
+    }
+    if (!id->IsTypeIdNone()) {
+      mInfo->SetTypeId(node, id->GetTypeId());
+      mInfo->SetTypeIdx(node, id->GetTypeIdx());
+    }
+  }
+  return node;
+}
+
+StructLiteralNode *ClassStructVisitor::VisitStructLiteralNode(StructLiteralNode *node) {
+  mInfo->SetTypeId(node, TY_Class);
+  (void) AstVisitor::VisitStructLiteralNode(node);
+  if (mInfo->GetPass() == 0) {
+    // field literal stridx to its ids'
+    for (unsigned i = 0; i < node->GetFieldsNum(); i++) {
+      FieldLiteralNode *fln = node->GetField(i);
+      TreeNode *name = fln->GetFieldName();
+      if (name) {
+        fln->SetStrIdx(name->GetStrIdx());
+      }
+    }
+  } else if (mInfo->GetPass() == 1) {
+    if (mInfo->WithTypeParam(node)) {
+      mInfo->InsertWithTypeParamNode(node);
+    }
+    // sort fields
+    mInfo->SortFields<StructLiteralNode, FieldLiteralNode>(node);
+  } else if (mInfo->GetPass() == 2) {
+    // create a anonymous struct for it
+    mInfo->SetNameAnonyStruct(true);
+    TreeNode *csn = mInfo->GetCanonicStructNode(node);
+    if (csn && csn != node) {
+      VisitTreeNode(csn);
+    }
+  }
+  return node;
+}
+
+StructNode *ClassStructVisitor::VisitStructNode(StructNode *node) {
+  if (node->GetProp() != SProp_TSEnum) {
+    mInfo->SetTypeId(node, TY_Class);
+    if (node->GetStructId()) {
+      mInfo->SetTypeId(node->GetStructId(), TY_Class);
+    }
+  }
+  (void) AstVisitor::VisitStructNode(node);
+  if (mInfo->GetPass() == 0) {
+    gTypeTable.AddType(node);
+    IdentifierNode *id = node->GetStructId();
+    if (id && node->GetStrIdx() == 0) {
+      node->SetStrIdx(id->GetStrIdx());
+    }
+    if (node->GetStrIdx() == 0) {
+      node->SetStrIdx(mInfo->GetAnonymousName());
+    }
+    mInfo->SetStrIdx2Struct(node->GetStrIdx(), node);
+    for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+      if (TreeNode *t = node->GetField(i)) {
+        if (!t->IsStrIndexSig()) {
+          mHandler->AddDirectField(t);
+        }
+      }
+    }
+  } else if (mInfo->GetPass() == 1) {
+    if (mInfo->WithTypeParam(node)) {
+      mInfo->InsertWithTypeParamNode(node);
+    }
+    // extends
+    mInfo->ExtendFields<StructNode>(node, NULL);
+    // sort fields
+    mInfo->SortFields<StructNode, TreeNode>(node);
+  } else if (mInfo->GetPass() == 2) {
+    // skip getting canonical type if not only fields
+    if (node->GetMethodsNum() || node->GetStrIdx() == 0) {
+      return node;
+    }
+    mInfo->GetCanonicStructNode(node);
+  }
+  return node;
+}
+
+ClassNode *ClassStructVisitor::VisitClassNode(ClassNode *node) {
+  mInfo->SetTypeId(node, TY_Class);
+  (void) AstVisitor::VisitClassNode(node);
+  if (mInfo->GetPass() == 0) {
+    if (node->GetStrIdx() == 0) {
+      node->SetStrIdx(mInfo->GetAnonymousName());
+    }
+    gTypeTable.AddType(node);
+    mInfo->SetStrIdx2Struct(node->GetStrIdx(), node);
+    for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+      if (TreeNode *t = node->GetField(i)) {
+        if (!t->IsStrIndexSig()) {
+          mHandler->AddDirectField(t);
+        }
+      }
+    }
+  } else if (mInfo->GetPass() == 1) {
+    if (mInfo->WithTypeParam(node)) {
+      mInfo->InsertWithTypeParamNode(node);
+    }
+    // include super class fields
+    mInfo->ExtendFields<ClassNode>(node, NULL);
+    // sort fields
+    mInfo->SortFields<ClassNode, TreeNode>(node);
+  } else if (mInfo->GetPass() == 2) {
+    // skip getting canonical type if not only fields
+    if (node->GetMethodsNum() || node->GetTypeParamsNum()) {
+      return node;
+    }
+    mInfo->GetCanonicStructNode(node);
+  }
+  return node;
+}
+
+InterfaceNode *ClassStructVisitor::VisitInterfaceNode(InterfaceNode *node) {
+  mInfo->SetTypeId(node, TY_Class);
+  (void) AstVisitor::VisitInterfaceNode(node);
+  if (mInfo->GetPass() == 0) {
+    if (node->GetStrIdx() == 0) {
+      node->SetStrIdx(mInfo->GetAnonymousName());
+    }
+    gTypeTable.AddType(node);
+    mInfo->SetStrIdx2Struct(node->GetStrIdx(), node);
+    for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+      if (TreeNode *t = node->GetField(i)) {
+        if (!t->IsStrIndexSig()) {
+          mHandler->AddDirectField(t);
+        }
+      }
+    }
+  } else if (mInfo->GetPass() == 1) {
+    if (mInfo->WithTypeParam(node)) {
+      mInfo->InsertWithTypeParamNode(node);
+    }
+    // sort fields
+    mInfo->SortFields<InterfaceNode, IdentifierNode>(node);
+  } else if (mInfo->GetPass() == 2) {
+    // skip getting canonical type if not only fields
+    if (node->GetMethodsNum() || node->GetSuperInterfacesNum()) {
+      return node;
+    }
+    mInfo->GetCanonicStructNode(node);
+  }
+  return node;
+}
+
+TypeParameterNode *ClassStructVisitor::VisitTypeParameterNode(TypeParameterNode *node) {
+  (void) AstVisitor::VisitTypeParameterNode(node);
+  if (mInfo->GetPass() == 0) {
+    TreeNode *id = node->GetId();
+    if (id) {
+      unsigned stridx = id->GetStrIdx();
+      mInfo->InsertTypeParamStrIdx(stridx);
+      node->SetStrIdx(stridx);
+    }
+  }
+  return node;
+}
+
+FunctionNode *ClassStructVisitor::VisitFunctionNode(FunctionNode *node) {
+  (void) AstVisitor::VisitFunctionNode(node);
+  if (mInfo->GetPass() == 1) {
+    TreeNode *body = node->GetBody();
+    if (body && mInfo->WithThis(body)) {
+      mInfo->InsertWithThisFunc(node);
+    }
+  }
+  return node;
+}
+
+FunctionNode *FunctionVisitor::VisitFunctionNode(FunctionNode *node) {
+  FunctionTypeNode *functype = mHandler->NewTreeNode<FunctionTypeNode>();
+  TreeNode *n = NULL;
+  for (unsigned i = 0; i < node->GetParamsNum(); i++) {
+    n = node->GetParam(i);
+    functype->AddParam(n ? n->GetTypeIdx() : 0);
+  }
+
+  // add return
+  n = node->GetRetType();
+  functype->AddParam(n ? n->GetTypeIdx() : 0);
+
+  unsigned tidx = gTypeTable.GetOrCreateFunctionTypeIdx(functype);
+  node->SetTypeIdx(tidx);
+
+  return node;
+}
+
+IdentifierNode *FindStrIdxVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  (void) AstVisitor::VisitIdentifierNode(node);
+  if (node->GetStrIdx() == mStrIdx) {
+    mFound = true;
+  }
+  return node;
+}
+
+LiteralNode *FindStrIdxVisitor::VisitLiteralNode(LiteralNode *node) {
+  (void) AstVisitor::VisitLiteralNode(node);
+  if (mCheckThis && node->IsThis()) {
+    mFound = true;
+  }
+  return node;
+}
+
+}
diff --git a/src/MapleFE/astopt/src/ast_scp.cpp b/src/MapleFE/astopt/src/ast_scp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe472ccd5efd3289ee290da38b51789e456a4f01
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_scp.cpp
@@ -0,0 +1,911 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <stack>
+#include <set>
+#include <tuple>
+#include "stringpool.h"
+#include "astopt.h"
+#include "ast_cfg.h"
+#include "ast_scp.h"
+#include "ast_xxport.h"
+#include "typetable.h"
+
+namespace maplefe {
+
+void AST_SCP::ScopeAnalysis() {
+  MSGNOLOC0("============== ScopeAnalysis ==============");
+  BuildScope();
+  RenameVar();
+  AdjustASTWithScope();
+}
+
+void AST_SCP::BuildScope() {
+  MSGNOLOC0("============== BuildScope ==============");
+  BuildScopeVisitor visitor(mHandler, mFlags, true);
+
+  // add all module themselves to the stridx to scope map
+  AST_Handler *asthandler = mHandler->GetASTHandler();
+  for (int i = 0; i < asthandler->GetSize(); i++) {
+    Module_Handler *handler = asthandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+    ASTScope *scope = module->GetRootScope();
+    module->SetScope(scope);
+    visitor.AddScopeMap(module->GetStrIdx(), scope);
+  }
+
+  ModuleNode *module = mHandler->GetASTModule();
+  ASTScope *scope = module->GetRootScope();
+
+  visitor.InitInternalTypes();
+
+  visitor.SetRunIt(true);
+  unsigned count = 0;
+  // run twice if necessary in case struct's scope is used before set
+  while (visitor.GetRunIt() && count  < 2) {
+    visitor.SetRunIt(false);
+    while(!visitor.mScopeStack.empty()) {
+      visitor.mScopeStack.pop();
+    }
+    visitor.mScopeStack.push(scope);
+
+    while(!visitor.mUserScopeStack.empty()) {
+      visitor.mUserScopeStack.pop();
+    }
+    visitor.mUserScopeStack.push(scope);
+
+    visitor.Visit(module);
+    count++;
+  }
+
+  if (mFlags & FLG_trace_3) {
+    gTypeTable.Dump();
+  }
+}
+
+void BuildScopeVisitor::AddDecl(ASTScope *scope, TreeNode *node) {
+  unsigned sid = scope->GetTree()->GetNodeId();
+  if (mScope2DeclsMap[sid].find(node->GetNodeId()) ==
+      mScope2DeclsMap[sid].end()) {
+    scope->AddDecl(node);
+    mScope2DeclsMap[sid].insert(node->GetNodeId());
+  }
+}
+
+void BuildScopeVisitor::AddImportedDecl(ASTScope *scope, TreeNode *node) {
+  unsigned sid = scope->GetTree()->GetNodeId();
+  unsigned nid = node->GetNodeId();
+  if (mScope2ImportedDeclsMap[sid].find(nid) ==
+      mScope2ImportedDeclsMap[sid].end()) {
+    scope->AddImportDecl(node);
+    mScope2ImportedDeclsMap[sid].insert(nid);
+    mHandler->AddNodeId2DeclMap(nid, node);
+  }
+}
+
+void BuildScopeVisitor::AddExportedDecl(ASTScope *scope, TreeNode *node) {
+  unsigned sid = scope->GetTree()->GetNodeId();
+  unsigned nid = node->GetNodeId();
+  if (mScope2ExportedDeclsMap[sid].find(nid) ==
+      mScope2ExportedDeclsMap[sid].end()) {
+    scope->AddExportDecl(node);
+    mScope2ExportedDeclsMap[sid].insert(nid);
+  }
+}
+
+void BuildScopeVisitor::AddType(ASTScope *scope, TreeNode *node) {
+  unsigned sid = scope->GetTree()->GetNodeId();
+  if (mScope2TypesMap[sid].find(node->GetNodeId()) ==
+      mScope2TypesMap[sid].end()) {
+    scope->AddType(node);
+    gTypeTable.AddType(node);
+    mScope2TypesMap[sid].insert(node->GetNodeId());
+  }
+}
+
+void BuildScopeVisitor::AddTypeAndDecl(ASTScope *scope, TreeNode *node) {
+  AddType(scope, node);
+  AddDecl(scope, node);
+}
+
+void BuildScopeVisitor::InitInternalTypes() {
+  // add primitive and builtin types to root scope
+  ModuleNode *module = mHandler->GetASTModule();
+  ASTScope *scope = module->GetRootScope();
+  for (unsigned i = 1; i < gTypeTable.GetPreBuildSize(); i++) {
+    TreeNode *node = gTypeTable.GetTypeFromTypeIdx(i);
+    node->SetScope(scope);
+    if (node->IsUserType()) {
+      UserTypeNode *ut = static_cast<UserTypeNode *>(node);
+      TreeNode *id = ut->GetId();
+      id->SetScope(scope);
+      AddType(scope, ut);
+      // id as a decl
+      AddDecl(scope, id);
+    } else {
+      AddType(scope, node);
+    }
+  }
+
+  // add dummpy console.log()
+  unsigned size = gStringPool.GetSize();
+  unsigned stridx = gStringPool.GetStrIdx("console");
+  TreeNode *type = gTypeTable.GetTypeFromStrIdx(stridx);
+  if (!type) {
+    ClassNode *console = AddClass(stridx);
+    ASTScope *scp = NewScope(scope, console);
+    mStrIdx2ScopeMap[console->GetStrIdx()] = scp;
+    FunctionNode *log = AddFunction("log");
+    log->SetTypeIdx(TY_Void);
+    console->AddMethod(log);
+    log->SetScope(scp);
+    AddDecl(scp, log);
+  }
+}
+
+ClassNode *BuildScopeVisitor::AddClass(unsigned stridx, unsigned tyidx) {
+  ClassNode *node = mHandler->NewTreeNode<ClassNode>();
+  node->SetStrIdx(stridx);
+  node->SetTypeIdx(tyidx);
+
+  ModuleNode *module = mHandler->GetASTModule();
+  ASTScope *scope = module->GetRootScope();
+  AddTypeAndDecl(scope, node);
+  return node;
+}
+
+FunctionNode *BuildScopeVisitor::AddFunction(std::string name) {
+  FunctionNode *func = mHandler->NewTreeNode<FunctionNode>();
+  unsigned idx = gStringPool.GetStrIdx(name);
+  func->SetStrIdx(idx);
+
+  IdentifierNode *id = mHandler->NewTreeNode<IdentifierNode>();
+  id->SetStrIdx(idx);
+  func->SetFuncName(id);
+
+  // add func to module scope
+  ModuleNode *module = mHandler->GetASTModule();
+  ASTScope *scope = module->GetRootScope();
+  AddDecl(scope, func);
+  id->SetScope(scope);
+  return func;
+}
+
+ASTScope *BuildScopeVisitor::NewScope(ASTScope *parent, TreeNode *node) {
+  MASSERT(parent && "parent scope NULL");
+  ASTScope *scope = node->GetScope();
+  if (!scope || (scope && scope->GetTree() != node)) {
+    scope = mASTModule->NewScope(parent, node);
+  }
+  return scope;
+}
+
+BlockNode *BuildScopeVisitor::VisitBlockNode(BlockNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  ASTScope *scope = NewScope(parent, node);
+  mScopeStack.push(scope);
+  BuildScopeBaseVisitor::VisitBlockNode(node);
+  mScopeStack.pop();
+  return node;
+}
+
+FunctionNode *BuildScopeVisitor::VisitFunctionNode(FunctionNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  // function is a decl
+  AddDecl(parent, node);
+  ASTScope *scope = NewScope(parent, node);
+  mScopeStack.push(scope);
+  mUserScopeStack.push(scope);
+
+  // add parameters as decl
+  for(unsigned i = 0; i < node->GetParamsNum(); i++) {
+    TreeNode *it = node->GetParam(i);
+    AddDecl(scope, it);
+
+    // added extra this is the parent with typeid TY_Class
+    if (it->GetStrIdx() == gStringPool.GetStrIdx("this") && it->GetTypeIdx() == 0) {
+      ASTScope *scp = scope;
+      while (scp && scp->GetTree()->GetTypeId() != TY_Class) {
+        scp = scp->GetParent();
+      }
+      if (scp) {
+        it->SetTypeId(TY_Object);
+        it->SetTypeIdx(scp->GetTree()->GetTypeIdx());
+      }
+    }
+  }
+
+  for(unsigned i = 0; i < node->GetTypeParamsNum(); i++) {
+    TreeNode *it = node->GetTypeParamAtIndex(i);
+
+    // add type parameter as decl
+    if (it->IsTypeParameter()) {
+      VisitTreeNode(it);
+      continue;
+    }
+
+    // add it to scope's mTypes only if it is a new type
+    TreeNode *tn = it;
+    if (it->IsUserType()) {
+      UserTypeNode *ut = static_cast<UserTypeNode *>(it);
+      tn = ut->GetId();
+    }
+    TreeNode *decl = NULL;
+    if (tn->IsIdentifier()) {
+      IdentifierNode *id = static_cast<IdentifierNode *>(tn);
+      // check if it is a known type
+      decl = scope->FindTypeOf(id->GetStrIdx());
+    }
+    // add it if not found
+    if (!decl) {
+      AddType(scope, it);
+    }
+  }
+  BuildScopeBaseVisitor::VisitFunctionNode(node);
+  mUserScopeStack.pop();
+  mScopeStack.pop();
+  return node;
+}
+
+LambdaNode *BuildScopeVisitor::VisitLambdaNode(LambdaNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  ASTScope *scope = NewScope(parent, node);
+
+  // add parameters as decl
+  for(unsigned i = 0; i < node->GetParamsNum(); i++) {
+    TreeNode *it = node->GetParam(i);
+    AddDecl(scope, it);
+  }
+  mScopeStack.push(scope);
+  mUserScopeStack.push(scope);
+  BuildScopeBaseVisitor::VisitLambdaNode(node);
+  mUserScopeStack.pop();
+  mScopeStack.pop();
+  return node;
+}
+
+ClassNode *BuildScopeVisitor::VisitClassNode(ClassNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  // inner class is a decl
+  if (parent) {
+    AddDecl(parent, node);
+    AddType(parent, node);
+  }
+
+  ASTScope *scope = NewScope(parent, node);
+  if (node->GetStrIdx()) {
+    mStrIdx2ScopeMap[node->GetStrIdx()] = scope;
+  }
+
+  // add fields as decl
+  for(unsigned i = 0; i < node->GetFieldsNum(); i++) {
+    TreeNode *fld = node->GetField(i);
+    if (fld->IsStrIndexSig()) {
+      StrIndexSigNode *sis = static_cast<StrIndexSigNode *>(fld);
+      TreeNode *key = sis->GetKey();
+      if (key) {
+        AddDecl(scope, key);
+      }
+    } else if (fld->IsIdentifier()) {
+      AddDecl(scope, fld);
+    } else {
+      NOTYETIMPL("new type of class field");
+    }
+  }
+  mScopeStack.push(scope);
+  BuildScopeBaseVisitor::VisitClassNode(node);
+  mScopeStack.pop();
+  return node;
+}
+
+InterfaceNode *BuildScopeVisitor::VisitInterfaceNode(InterfaceNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  // inner interface is a decl
+  if (parent) {
+    AddDecl(parent, node);
+    AddType(parent, node);
+  }
+
+  ASTScope *scope = NewScope(parent, node);
+  if (node->GetStrIdx()) {
+    mStrIdx2ScopeMap[node->GetStrIdx()] = scope;
+  }
+
+  // add fields as decl
+  for(unsigned i = 0; i < node->GetFieldsNum(); i++) {
+    TreeNode *fld = node->GetField(i);
+    if (fld->IsStrIndexSig()) {
+      continue;
+    }
+    if (fld->IsIdentifier()) {
+      AddDecl(scope, fld);
+    }
+  }
+  mScopeStack.push(scope);
+  BuildScopeBaseVisitor::VisitInterfaceNode(node);
+  mScopeStack.pop();
+  return node;
+}
+
+StructNode *BuildScopeVisitor::VisitStructNode(StructNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  // struct is a decl
+  if (parent) {
+    AddDecl(parent, node);
+    AddType(parent, node);
+  }
+
+  ASTScope *scope = NewScope(parent, node);
+  mScopeStack.push(scope);
+  if (node->GetStructId() && node->GetStructId()->GetStrIdx()) {
+    mStrIdx2ScopeMap[node->GetStructId()->GetStrIdx()] = scope;
+  }
+
+  // add fields as decl
+  for(unsigned i = 0; i < node->GetFieldsNum(); i++) {
+    TreeNode *fld = node->GetField(i);
+    if (fld->IsStrIndexSig()) {
+      continue;
+    }
+    if (fld && fld->IsIdentifier()) {
+      AddDecl(scope, fld);
+    }
+  }
+
+  // add type parameter as decl
+  for(unsigned i = 0; i < node->GetTypeParamsNum(); i++) {
+    VisitTreeNode(node->GetTypeParamAtIndex(i));
+    continue;
+  }
+
+  // add string indexed field as decl
+  StrIndexSigNode *sig = node->GetStrIndexSig();
+  if (sig) {
+    TreeNode *fld = sig->GetKey();
+    sig->SetStrIdx(fld->GetStrIdx());
+    if (fld && fld->IsIdentifier()) {
+      AddDecl(scope, fld);
+    }
+  }
+
+  BuildScopeBaseVisitor::VisitStructNode(node);
+  mScopeStack.pop();
+  return node;
+}
+
+StructLiteralNode *BuildScopeVisitor::VisitStructLiteralNode(StructLiteralNode *node) {
+  ASTScope *parent = mScopeStack.top();
+
+  ASTScope *scope = NewScope(parent, node);
+
+  // add fields as decl
+  for(unsigned i = 0; i < node->GetFieldsNum(); i++) {
+    FieldLiteralNode *fld = node->GetField(i);
+    TreeNode *name = fld->GetFieldName();
+    if (name && name->IsIdentifier()) {
+      AddDecl(scope, name);
+    }
+  }
+  mScopeStack.push(scope);
+  BuildScopeBaseVisitor::VisitStructLiteralNode(node);
+  mScopeStack.pop();
+  return node;
+}
+
+NamespaceNode *BuildScopeVisitor::VisitNamespaceNode(NamespaceNode *node) {
+  node->SetTypeId(TY_Namespace);
+  TreeNode *id = node->GetId();
+  unsigned stridx = 0;
+  if (id && id->GetStrIdx()) {
+    stridx = id->GetStrIdx();
+    node->SetStrIdx(stridx);
+  }
+
+  ASTScope *parent = mScopeStack.top();
+  // inner namespace is a decl
+  if (parent) {
+    AddTypeAndDecl(parent, node);
+  }
+
+  ASTScope *scope = NewScope(parent, node);
+  if (stridx != 0) {
+    mStrIdx2ScopeMap[stridx] = scope;
+  }
+
+  mScopeStack.push(scope);
+  mUserScopeStack.push(scope);
+  BuildScopeBaseVisitor::VisitNamespaceNode(node);
+  mUserScopeStack.pop();
+  mScopeStack.pop();
+  return node;
+}
+
+DeclNode *BuildScopeVisitor::VisitDeclNode(DeclNode *node) {
+  BuildScopeBaseVisitor::VisitDeclNode(node);
+  ASTScope *scope = NULL;
+  bool deep = true;
+  if (node->GetProp() == JS_Var) {
+    // promote to use function or module scope
+    scope = mUserScopeStack.top();
+
+    // update scope
+    node->SetScope(scope);
+    if (node->GetVar()) {
+      node->GetVar()->SetScope(scope);
+    }
+  } else {
+    scope = mScopeStack.top();
+    // for body of function use function scope instead of body scope
+    TreeNode *b = node->GetParent();
+    if (b && b->IsBlock()) {
+      TreeNode *f = b->GetParent();
+      if (f && f->IsFunction()) {
+        scope = mUserScopeStack.top();
+      }
+    }
+    // restrict to current scope
+    deep = false;
+  }
+  // check if it is already a decl in the scope
+  unsigned stridx = node->GetStrIdx();
+  TreeNode *decl = scope->FindDeclOf(stridx, deep);
+  if (decl) {
+    if (decl != node) {
+      // replace with an assignment if apply
+      if (node->GetInit()) {
+        BinOperatorNode *bop = mHandler->NewTreeNode<BinOperatorNode>();
+        bop->SetOprId(OPR_Assign);
+        IdentifierNode *id = mHandler->NewTreeNode<IdentifierNode>();
+        id->SetStrIdx(stridx);
+        id->SetScope(scope);
+
+        bop->SetOpndA(id);
+        bop->SetOpndB(node->GetInit());
+        node = (DeclNode *)bop;
+      } else {
+        node = NULL;
+      }
+    }
+  } else {
+    AddDecl(scope, node);
+  }
+  return node;
+}
+
+UserTypeNode *BuildScopeVisitor::VisitUserTypeNode(UserTypeNode *node) {
+  BuildScopeBaseVisitor::VisitUserTypeNode(node);
+  ASTScope *scope = mScopeStack.top();
+  TreeNode *p = node->GetParent();
+  if (p) {
+    if (p->IsFunction()) {
+      // exclude function return type
+      FunctionNode *f = static_cast<FunctionNode *>(p);
+      if (f->GetRetType() == node) {
+        return node;
+      }
+    } else if (p->IsTypeAlias()) {
+      // handled by typealias node
+      return node;
+    }
+
+    if (p->IsScope()) {
+      // normal type decl
+      // check if it is already in typetable
+      TreeNode *id = node->GetId();
+      if (id) {
+        TreeNode *decl = scope->FindTypeOf(id->GetStrIdx());
+        if (!decl) {
+          AddType(scope, node);
+        }
+      }
+    }
+  }
+  return node;
+}
+
+TypeAliasNode *BuildScopeVisitor::VisitTypeAliasNode(TypeAliasNode *node) {
+  ASTScope *scope = mScopeStack.top();
+  BuildScopeBaseVisitor::VisitTypeAliasNode(node);
+  TreeNode *ut = node->GetId();
+  if (ut->IsUserType()) {
+    TreeNode *id = static_cast<UserTypeNode *>(ut)->GetId();
+    AddDecl(scope, id);
+
+    // add to Alias type
+    mHandler->AddAliasType(id->GetNodeId());
+  }
+  return node;
+}
+
+ForLoopNode *BuildScopeVisitor::VisitForLoopNode(ForLoopNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  ASTScope *scope = parent;
+  if (node->GetProp() == FLP_JSIn) {
+    scope = NewScope(parent, node);
+    TreeNode *var = node->GetVariable();
+    if (var) {
+      if (var->IsDecl()) {
+        AddDecl(scope, var);
+      } else {
+        NOTYETIMPL("VisitForLoopNode() FLP_JSIn var not decl");
+      }
+    }
+    mScopeStack.push(scope);
+  }
+
+  BuildScopeBaseVisitor::VisitForLoopNode(node);
+
+  if (scope != parent) {
+    mScopeStack.pop();
+  }
+  return node;
+}
+
+FieldNode *BuildScopeVisitor::VisitFieldNode(FieldNode *node) {
+  BuildScopeBaseVisitor::VisitFieldNode(node);
+
+  TreeNode *upper = node->GetUpper();
+  TreeNode *field = node->GetField();
+
+  if (upper && upper->GetStrIdx()) {
+    ASTScope *scope = mStrIdx2ScopeMap[upper->GetStrIdx()];
+    if (!scope && upper->IsIdentifier()) {
+      TreeNode *decl = mHandler->FindDecl(static_cast<IdentifierNode *>(upper));
+      if (decl && decl->IsDecl()) {
+        decl = static_cast<DeclNode *>(decl)->GetVar();
+      }
+      if (decl && decl->IsIdentifier()) {
+        IdentifierNode *id = static_cast<IdentifierNode *>(decl);
+        TreeNode *type = id->GetType();
+        if (type && type->IsUserType()) {
+          TreeNode *id = static_cast<UserTypeNode *>(type)->GetId();
+          if (id) {
+            scope = mStrIdx2ScopeMap[id->GetStrIdx()];
+          }
+        } else if (id->GetParent() && id->GetParent()->IsXXportAsPair()) {
+          scope = id->GetScope();
+        }
+      }
+    }
+    if (scope) {
+      mScopeStack.push(scope);
+      BuildScopeBaseVisitor::Visit(field);
+      mScopeStack.pop();
+    } else {
+      mRunIt = true;
+    }
+  }
+
+  return node;
+}
+
+TypeParameterNode *BuildScopeVisitor::VisitTypeParameterNode(TypeParameterNode *node) {
+  BuildScopeBaseVisitor::VisitTypeParameterNode(node);
+  TreeNode *id = node->GetId();
+  if (id && id->IsIdentifier()) {
+    ASTScope *scope = mScopeStack.top();
+    id->SetScope(scope);
+    AddDecl(scope, id);
+  }
+  return node;
+}
+
+ImportNode *BuildScopeVisitor::VisitImportNode(ImportNode *node) {
+  (void) AstVisitor::VisitImportNode(node);
+  ASTScope *scope = mScopeStack.top();
+
+  Module_Handler *targetHandler = NULL;
+  TreeNode *target = node->GetTarget();
+  if (target) {
+    unsigned hstridx = target->GetStrIdx();
+    unsigned hidx = mXXport->GetHandleIdxFromStrIdx(hstridx);
+    targetHandler = mHandler->GetASTHandler()->GetModuleHandler(hidx);
+  }
+
+  for (unsigned i = 0; i < node->GetPairsNum(); i++) {
+    XXportAsPairNode *p = node->GetPair(i);
+    TreeNode *bfnode = p->GetBefore();
+    TreeNode *afnode = p->GetAfter();
+    if (p->IsDefault()) {
+      if (bfnode) {
+        bfnode->SetScope(scope);
+        AddImportedDecl(scope, bfnode);
+      }
+    } else if (p->IsEverything()) {
+      if (bfnode) {
+        AddImportedDecl(scope, bfnode);
+        // imported scope
+        scope = targetHandler->GetASTModule()->GetScope();
+        bfnode->SetScope(scope);
+      }
+    } else if (afnode) {
+      afnode->SetScope(scope);
+      AddImportedDecl(scope, afnode);
+
+      if (bfnode && targetHandler) {
+        ModuleNode *mod = targetHandler->GetASTModule();
+        ASTScope *modscp = mod->GetScope();
+        bfnode->SetScope(modscp);
+      }
+    } else if (bfnode) {
+      bfnode->SetScope(scope);
+      AddImportedDecl(scope, bfnode);
+    }
+  }
+
+  return node;
+}
+
+ExportNode *BuildScopeVisitor::VisitExportNode(ExportNode *node) {
+  (void) AstVisitor::VisitExportNode(node);
+  ASTScope *scope = mScopeStack.top();
+
+  Module_Handler *targetHandler = NULL;
+  TreeNode *target = node->GetTarget();
+  // re-export
+  if (target) {
+    unsigned hstridx = target->GetStrIdx();
+    unsigned hidx = mXXport->GetHandleIdxFromStrIdx(hstridx);
+    targetHandler = mHandler->GetASTHandler()->GetModuleHandler(hidx);
+  }
+
+  for (unsigned i = 0; i < node->GetPairsNum(); i++) {
+    XXportAsPairNode *p = node->GetPair(i);
+    TreeNode *bfnode = p->GetBefore();
+    TreeNode *afnode = p->GetAfter();
+    if (targetHandler) {
+      ModuleNode *mod = targetHandler->GetASTModule();
+      ASTScope *modscp = mod->GetScope();
+
+      if (bfnode) {
+        bfnode->SetScope(modscp);
+        // reexported bfnode is treated as a decl, add directly into map
+        if (bfnode->IsIdentifier()) {
+          mHandler->AddNodeId2DeclMap(bfnode->GetNodeId(), bfnode);
+        }
+      } else if (!afnode) {
+        // reexport everything
+        for (unsigned j = 0; j < modscp->GetExportedDeclNum(); j++) {
+          AddExportedDecl(scope, modscp->GetExportedDecl(j));
+        }
+      }
+    } else {
+      if (!p->IsDefault() && bfnode && !afnode) {
+        AddExportedDecl(scope, bfnode);
+      }
+    }
+
+    if (afnode && afnode->IsIdentifier()) {
+      // exported afnode is treated as a decl, add directly into map
+      mHandler->AddNodeId2DeclMap(afnode->GetNodeId(), afnode);
+      AddExportedDecl(scope, afnode);
+    }
+  }
+
+  return node;
+}
+
+TryNode *BuildScopeVisitor::VisitTryNode(TryNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  ASTScope *scope = NewScope(parent, node);
+  mScopeStack.push(scope);
+  BuildScopeBaseVisitor::VisitTryNode(node);
+  mScopeStack.pop();
+  return node;
+}
+
+CatchNode *BuildScopeVisitor::VisitCatchNode(CatchNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  ASTScope *scope = NewScope(parent, node);
+
+  // add params as decl
+  for (unsigned i = 0; i < node->GetParamsNum(); i++) {
+    TreeNode *n = node->GetParamAtIndex(i);
+    AddDecl(scope, n);
+  }
+
+  mScopeStack.push(scope);
+  BuildScopeBaseVisitor::VisitCatchNode(node);
+  mScopeStack.pop();
+  return node;
+}
+
+FinallyNode *BuildScopeVisitor::VisitFinallyNode(FinallyNode *node) {
+  ASTScope *parent = mScopeStack.top();
+  ASTScope *scope = NewScope(parent, node);
+  mScopeStack.push(scope);
+  BuildScopeBaseVisitor::VisitFinallyNode(node);
+  mScopeStack.pop();
+  return node;
+}
+
+// rename var with same name, i --> i__vN where N is 1, 2, 3 ...
+void AST_SCP::RenameVar() {
+  MSGNOLOC0("============== RenameVar ==============");
+  RenameVarVisitor visitor(mHandler, mFlags, true);
+  ModuleNode *module = mHandler->GetASTModule();
+  visitor.mPass = 0;
+  visitor.Visit(module);
+
+  visitor.mPass = 1;
+  for (auto it: visitor.mStridx2DeclIdMap) {
+    unsigned stridx = it.first;
+    unsigned size = it.second.size();
+    if (size > 1) {
+      const char *name = gStringPool.GetStringFromStrIdx(stridx);
+
+      if (mFlags & FLG_trace_3) {
+        std::cout << "\nstridx: " << stridx << " " << name << std::endl;
+        std::cout << "decl nid : ";
+        for (auto i : visitor.mStridx2DeclIdMap[stridx]) {
+          std::cout << " " << i;
+        }
+        std::cout << std::endl;
+      }
+
+      // variable renaming is in reverse order starting from smaller scope variables
+      std::deque<unsigned>::reverse_iterator rit = visitor.mStridx2DeclIdMap[stridx].rbegin();
+      size--;
+      for (; size && rit!= visitor.mStridx2DeclIdMap[stridx].rend(); --size, ++rit) {
+        unsigned nid = *rit;
+        std::string str(name);
+        str += "__v";
+        str += std::to_string(size);
+        visitor.mOldStrIdx = stridx;
+        visitor.mNewStrIdx = gStringPool.GetStrIdx(str);
+        gStringPool.AddAltStrIdx(visitor.mNewStrIdx);
+        TreeNode *tn = mHandler->GetAstOpt()->GetNodeFromNodeId(nid);
+        ASTScope *scope = tn->GetScope();
+        tn = scope->GetTree();
+        if (mFlags & FLG_trace_3) {
+          std::cout << "\nupdate name : "
+                    << gStringPool.GetStringFromStrIdx(visitor.mOldStrIdx)
+                    << " --> "
+                    << gStringPool.GetStringFromStrIdx(visitor.mNewStrIdx)
+                    << std::endl;
+        }
+        visitor.Visit(tn);
+      }
+    }
+  }
+}
+
+// fields are not renamed
+bool RenameVarVisitor::SkipRename(IdentifierNode *node) {
+  TreeNode *parent = node->GetParent();
+  if (parent) {
+    switch (parent->GetKind()) {
+      case NK_Struct:
+      case NK_Class:
+      case NK_Interface:
+        return true;
+      case NK_Field: {
+        FieldNode *f = static_cast<FieldNode *>(parent);
+        // skip for mField
+        return node == f->GetField();;
+      }
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+
+// check if node is of same name as a parameter of func
+bool RenameVarVisitor::IsFuncArg(FunctionNode *func, IdentifierNode *node) {
+  for (unsigned i = 0; i < func->GetParamsNum(); i++) {
+    if (func->GetParam(i)->GetStrIdx() == node->GetStrIdx()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// insert decl in lattice order of scopes hierachy to ensure proper name versions.
+//
+// the entries of node id in mStridx2DeclIdMap are inserted to a list from larger scopes to smaller scopes
+// later variable renaming is performed in reverse from bottom up of AST within the scope of the variable
+//
+void RenameVarVisitor::InsertToStridx2DeclIdMap(unsigned stridx, IdentifierNode *node) {
+  ASTScope *s0 = node->GetScope();
+  std::deque<unsigned>::iterator it;
+  unsigned i = 0;
+  for (it = mStridx2DeclIdMap[stridx].begin(); it != mStridx2DeclIdMap[stridx].end(); ++it) {
+    i = *it;
+    TreeNode *node1 = mHandler->GetAstOpt()->GetNodeFromNodeId(i);
+    ASTScope *s1 = node1->GetScope();
+    // decl at same scope already exist
+    if (s1 == s0) {
+      return;
+    }
+    // do not insert node after node1 if node's scope s0 is an ancestor of node1's scope s1
+    if (s1->IsAncestor(s0)) {
+      mStridx2DeclIdMap[stridx].insert(it, node->GetNodeId());
+      return;
+    }
+  }
+  mStridx2DeclIdMap[stridx].push_back(node->GetNodeId());
+}
+
+IdentifierNode *RenameVarVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  AstVisitor::VisitIdentifierNode(node);
+  // fields are not renamed
+  if (SkipRename(node)) {
+    return node;
+  }
+  if (mPass == 0) {
+    unsigned stridx = node->GetStrIdx();
+    if (stridx) {
+      TreeNode *parent = node->GetParent();
+      if (parent) {
+        // insert in order according to scopes hierachy to ensure proper name version
+        if ((parent->IsDecl() && parent->GetStrIdx() == stridx)) {
+          // decl
+          InsertToStridx2DeclIdMap(stridx, node);
+        } else if (parent->IsFunction() && IsFuncArg(static_cast<FunctionNode *>(parent), node)) {
+          // func parameters
+          InsertToStridx2DeclIdMap(stridx, node);
+        }
+      }
+    } else {
+      NOTYETIMPL("Unexpected - decl without name stridx");
+    }
+  } else if (mPass == 1) {
+    if (node->GetStrIdx() == mOldStrIdx) {
+      node->SetStrIdx(mNewStrIdx);
+      MSGNOLOC0("   name updated");
+      TreeNode *parent = node->GetParent();
+      if (parent && parent->IsDecl()) {
+        parent->SetStrIdx(mNewStrIdx);
+      }
+    }
+  }
+  return node;
+}
+
+void AST_SCP::AdjustASTWithScope() {
+  MSGNOLOC0("============== AdjustASTWithScope ==============");
+  AdjustASTWithScopeVisitor visitor(mHandler, mFlags, true);
+  ModuleNode *module = mHandler->GetASTModule();
+  visitor.Visit(module);
+}
+
+IdentifierNode *AdjustASTWithScopeVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  TreeNode *decl = mHandler->FindDecl(node);
+  if (!decl) {
+    LitData data;
+    bool change = false;
+    // handle literals true false
+    unsigned stridx = node->GetStrIdx();
+    if (stridx == gStringPool.GetStrIdx("true")) {
+      data.mType = LT_BooleanLiteral;
+      data.mData.mBool = true;
+      change = true;
+    } else if (stridx == gStringPool.GetStrIdx("false")) {
+      data.mType = LT_BooleanLiteral;
+      data.mData.mBool = false;
+      change = true;
+    }
+
+    if (change) {
+      LiteralNode *lit = mHandler->NewTreeNode<LiteralNode>();
+      lit->SetData(data);
+      return (IdentifierNode*)(lit);
+    }
+  }
+  return node;
+}
+
+}
diff --git a/src/MapleFE/astopt/src/ast_ti.cpp b/src/MapleFE/astopt/src/ast_ti.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..99439b59de694b757e30393cd8db4d3a3456d115
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_ti.cpp
@@ -0,0 +1,2042 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <stack>
+#include <set>
+#include "ast_handler.h"
+#include "ast_info.h"
+#include "ast_util.h"
+#include "ast_xxport.h"
+#include "ast_ti.h"
+#include "typetable.h"
+#include "gen_astdump.h"
+
+#define ITERATEMAX 10
+
+namespace maplefe {
+
+void TypeInfer::TypeInference() {
+  ModuleNode *module = mHandler->GetASTModule();
+
+  if (mFlags & FLG_trace_3) {
+    gStringPool.Dump();
+    gTypeTable.Dump();
+  }
+
+  // build mNodeId2Decl
+  MSGNOLOC0("============== Build NodeId2Decl ==============");
+  BuildIdNodeToDeclVisitor visitor_build(mHandler, mFlags, true);
+  visitor_build.Visit(module);
+
+  // type inference
+  MSGNOLOC0("============== TypeInfer ==============");
+  TypeInferVisitor visitor_ti(mHandler, mFlags, true);
+  visitor_ti.SetUpdated(true);
+  int count = 0;
+  while (visitor_ti.GetUpdated() && count++ <= ITERATEMAX) {
+    MSGNOLOC("\n TypeInference iterate ", count);
+    visitor_ti.SetUpdated(false);
+    visitor_ti.Visit(module);
+  }
+
+  // build mDirectFieldSet
+  MSGNOLOC0("============== Build DirectFieldSet ==============");
+  BuildIdDirectFieldVisitor visitor_field(mHandler, mFlags, true);
+  visitor_field.Visit(module);
+  if (mFlags & FLG_trace_3) {
+    visitor_field.Dump();
+  }
+
+  if (mFlags & FLG_trace_3) std::cout << "\n>>>>>> TypeInference() iterated " << count << " times\n" << std::endl;
+
+  // share UserType
+  MSGNOLOC0("============== Share UserType ==============");
+  ShareUTVisitor visitor_ut(mHandler, mFlags, true);
+  visitor_ut.Push(module->GetRootScope());
+  visitor_ut.Visit(module);
+
+  // Check Type
+  MSGNOLOC0("============== Check Type ==============");
+  CheckTypeVisitor visitor_check(mHandler, mFlags, true);
+  visitor_check.Visit(module);
+
+  if (mFlags & FLG_trace_3) {
+    mHandler->DumpArrayElemTypeIdMap();
+  }
+}
+
+// build up mNodeId2Decl by visiting each Identifier
+IdentifierNode *BuildIdNodeToDeclVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  if (mHandler->GetAstOpt()->IsLangKeyword(node)) {
+    return node;
+  }
+  (void) AstVisitor::VisitIdentifierNode(node);
+  // mHandler->FindDecl() will use/add entries to mNodeId2Decl
+  TreeNode *decl = mHandler->FindDecl(node);
+  if (decl && decl != node) {
+    mHandler->GetUtil()->SetTypeId(node, decl->GetTypeId());
+    mHandler->GetUtil()->SetTypeIdx(node, decl->GetTypeIdx());
+  }
+  TreeNode *type = node->GetType();
+  if (type && type->IsPrimType()) {
+    PrimTypeNode *ptn = static_cast<PrimTypeNode *>(type);
+    TypeId tid = ptn->GetPrimType();
+    if (gTypeTable.IsPrimTypeId(tid)) {
+      // mHandler->GetUtil()->SetTypeId(node, tid);
+      mHandler->GetUtil()->SetTypeIdx(node, tid);
+    }
+  }
+  return node;
+}
+
+FieldNode *BuildIdDirectFieldVisitor::VisitFieldNode(FieldNode *node) {
+  (void) AstVisitor::VisitFieldNode(node);
+  IdentifierNode *field = static_cast<IdentifierNode *>(node->GetField());
+  TreeNode *decl = NULL;
+  decl = mHandler->FindDecl(field);
+  if (decl) {
+    mHandler->AddDirectField(field);
+    mHandler->AddDirectField(node);
+  }
+  return node;
+}
+
+TreeNode *BuildIdDirectFieldVisitor::GetParentVarClass(TreeNode *node) {
+  TreeNode *n = node;
+  while (n && !n->IsModule()) {
+    unsigned tyidx = 0;
+    if (n->IsDecl()) {
+      tyidx = n->GetTypeIdx();
+    } else if (n->IsBinOperator()) {
+      tyidx = n->GetTypeIdx();
+    }
+    if (tyidx) {
+      return gTypeTable.GetTypeFromTypeIdx(tyidx);
+    }
+    n = n->GetParent();
+  }
+  return NULL;
+}
+
+FieldLiteralNode *BuildIdDirectFieldVisitor::VisitFieldLiteralNode(FieldLiteralNode *node) {
+  (void) AstVisitor::VisitFieldLiteralNode(node);
+  TreeNode *name = node->GetFieldName();
+  IdentifierNode *field = static_cast<IdentifierNode *>(name);
+  TreeNode *decl = mHandler->FindDecl(field);
+  TreeNode *vtype = GetParentVarClass(decl);
+  if (vtype && !mHandler->GetINFO()->IsBuiltInType(vtype)) {
+    // check if decl is a field of vtype
+    // note: vtype could be in different module
+    Module_Handler *h = mHandler->GetModuleHandler(vtype);
+    TreeNode *fld = h->GetINFO()->GetField(vtype->GetNodeId(), decl->GetStrIdx());
+    if (fld) {
+      mHandler->AddDirectField(field);
+      mHandler->AddDirectField(node);
+    }
+  }
+  return node;
+}
+
+ArrayElementNode *BuildIdDirectFieldVisitor::VisitArrayElementNode(ArrayElementNode *node) {
+  (void) AstVisitor::VisitArrayElementNode(node);
+  TreeNode *array = node->GetArray();
+  if (!array || !array->IsIdentifier()) {
+    return node;
+  }
+
+  TreeNode *decl = mHandler->FindDecl(static_cast<IdentifierNode *>(array));
+  if (decl && decl->IsTypeIdClass()) {
+    // indexed access of types
+    TreeNode *exp = node->GetExprAtIndex(0);
+    unsigned stridx = exp->GetStrIdx();
+    if (exp->IsLiteral() && exp->IsTypeIdString()) {
+      stridx = (static_cast<LiteralNode *>(exp))->GetData().mData.mStrIdx;
+    }
+    if (decl->IsDecl()) {
+      TreeNode *var = static_cast<DeclNode *>(decl)->GetVar();
+      TreeNode * type = static_cast<IdentifierNode *>(var)->GetType();
+      if (type && type->IsUserType()) {
+        UserTypeNode *ut = static_cast<UserTypeNode *>(type);
+        decl = mHandler->FindDecl(static_cast<IdentifierNode *>(ut->GetId()));
+      }
+    }
+    if (decl->IsStruct() || decl->IsClass()) {
+      for (int i = 0; i < mHandler->GetINFO()->GetFieldsSize(decl); i++) {
+        TreeNode *f = mHandler->GetINFO()->GetField(decl, i);
+        if (f->GetStrIdx() == stridx) {
+          mHandler->AddDirectField(exp);
+          mHandler->AddDirectField(node);
+          return node;
+        }
+      }
+    }
+  }
+  return node;
+}
+
+void BuildIdDirectFieldVisitor::Dump() {
+  MSGNOLOC0("============== Direct Field NodeIds ==============");
+  for (auto i: mHandler->mDirectFieldSet) {
+    std::cout << " " << i;
+  }
+  std::cout << std::endl;
+}
+
+#undef  TYPE
+#undef  PRIMTYPE
+#define TYPE(T)
+#define PRIMTYPE(T) case TY_##T:
+bool TypeInferVisitor::IsPrimTypeId(TypeId tid) {
+  bool result = false;
+  switch (tid) {
+#include "supported_types.def"
+      result = true;
+      break;
+    default:
+      break;
+  }
+  return result;
+}
+
+TypeId TypeInferVisitor::MergeTypeId(TypeId tia, TypeId tib) {
+  if (tia == tib || tib == TY_None) {
+    return tia;
+  }
+
+  if (tib == TY_Object || tib == TY_User) {
+    return tib;
+  }
+
+  if ((tia == TY_Function && tib == TY_Class) || (tib == TY_Function && tia == TY_Class)) {
+    return TY_None;
+  }
+
+  // tia != tib && tib != TY_None
+  TypeId result = TY_None;
+  switch (tia) {
+    case TY_None:        result = tib;       break;
+
+    case TY_Class:
+    case TY_Object:
+    case TY_User:        result = tia;       break;
+
+    case TY_Merge:
+    case TY_Undefined:
+    case TY_String:
+    case TY_Function:
+    case TY_Array:       result = TY_Merge;  break;
+
+    case TY_Number: {
+      switch (tib) {
+        case TY_Int:
+        case TY_Long:
+        case TY_Float:
+        case TY_Double:  result = tib;       break;
+        default:         result = TY_Merge;  break;
+      }
+      break;
+    }
+
+    case TY_Boolean: {
+      switch (tib) {
+        case TY_Int:
+        case TY_Long:
+        case TY_Float:
+        case TY_Double:  result = tib;       break;
+        case TY_Number:  result = tia;       break;
+        default:         result = TY_Merge;  break;
+      }
+      break;
+    }
+    case TY_Int: {
+      switch (tib) {
+        case TY_Number:
+        case TY_Boolean: result = tia;       break;
+        case TY_Long:
+        case TY_Float:
+        case TY_Double:  result = tib;       break;
+        default:         result = TY_Merge;  break;
+      }
+      break;
+    }
+    case TY_Long: {
+      switch (tib) {
+        case TY_Number:
+        case TY_Boolean:
+        case TY_Int:     result = tia;       break;
+        case TY_Float:
+        case TY_Double:  result = TY_Double; break;
+        default:         result = TY_Merge;  break;
+      }
+      break;
+    }
+    case TY_Float: {
+      switch (tib) {
+        case TY_Number:
+        case TY_Boolean:
+        case TY_Int:     result = tia;       break;
+        case TY_Long:
+        case TY_Double:  result = TY_Double; break;
+        default:         result = TY_Merge;  break;
+      }
+      break;
+    }
+    case TY_Double: {
+      switch (tib) {
+        case TY_Number:
+        case TY_Boolean:
+        case TY_Int:
+        case TY_Long:
+        case TY_Double:  result = tia;       break;
+        default:         result = TY_Merge;  break;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  if (result == TY_None) {
+    NOTYETIMPL("MergeTypeId()");
+  }
+  if (mFlags & FLG_trace_3) {
+    std::cout << " Type Merge: "
+              << AstDump::GetEnumTypeId(tia) << " "
+              << AstDump::GetEnumTypeId(tib) << " --> "
+              << AstDump::GetEnumTypeId(result) << std::endl;
+  }
+  return result;
+}
+
+unsigned TypeInferVisitor::MergeTypeIdx(unsigned tia, unsigned tib) {
+  if (tia == tib || tib <= 1) {
+    return tia;
+  }
+
+  if (tia <= 1) {
+    return tib;
+  }
+
+  unsigned result = 0;
+
+  TreeNode *ta = gTypeTable.GetTypeFromTypeIdx(tia);
+  TreeNode *tb = gTypeTable.GetTypeFromTypeIdx(tib);
+  if (ta->IsPrimType() && tb->IsPrimType()) {
+    TypeId tid = MergeTypeId(ta->GetTypeId(), tb->GetTypeId());
+    result = (unsigned)tid;
+  } else {
+    TreeNode *type = gTypeTable.GetTypeFromTypeId(TY_Merge);
+    result = type->GetTypeIdx();
+  }
+
+  if (mFlags & FLG_trace_3) {
+    std::cout << " Type idx Merge: "
+              << tia << " "
+              << tib << " --> "
+              << result << std::endl;
+  }
+  return result;
+}
+
+void TypeInferVisitor::SetTypeId(TreeNode *node, TypeId tid) {
+  TypeId id = node->GetTypeId();
+  mHandler->GetUtil()->SetTypeId(node, tid);
+  if (tid != id) {
+    id = node->GetTypeId();
+    if (IsPrimTypeIdx(id) && node->GetTypeIdx() == 0) {
+      SetTypeIdx(node, id);
+    }
+    SetUpdated();
+  }
+}
+
+void TypeInferVisitor::SetTypeIdx(TreeNode *node, unsigned tidx) {
+  mHandler->GetUtil()->SetTypeIdx(node, tidx);
+  if (node && node->GetTypeIdx() != tidx) {
+    SetUpdated();
+  }
+}
+
+void TypeInferVisitor::SetTypeId(TreeNode *node1, TreeNode *node2) {
+  SetTypeId(node1, node2->GetTypeId());
+  SetTypeIdx(node1, node2->GetTypeIdx());
+}
+
+void TypeInferVisitor::SetTypeIdx(TreeNode *node1, TreeNode *node2) {
+  SetTypeIdx(node1, node2->GetTypeIdx());
+}
+
+void TypeInferVisitor::UpdateTypeId(TreeNode *node, TypeId tid) {
+  if (tid == TY_None || !node || node->IsLiteral()) {
+    return;
+  }
+  tid = MergeTypeId(node->GetTypeId(), tid);
+  SetTypeId(node, tid);
+}
+
+void TypeInferVisitor::UpdateTypeId(TreeNode *node1, TreeNode *node2) {
+  if (!node1 || !node2 || node1 == node2) {
+    return;
+  }
+  TypeId tid = MergeTypeId(node1->GetTypeId(), node2->GetTypeId());
+  if (!node1->IsLiteral()) {
+    SetTypeId(node1, tid);
+  }
+  if (!node2->IsLiteral()) {
+    SetTypeId(node2, tid);
+  }
+
+  // update type idx as well
+  UpdateTypeIdx(node1, node2);
+}
+
+void TypeInferVisitor::UpdateTypeIdx(TreeNode *node, unsigned tidx) {
+  if (tidx == 0 || !node || node->IsLiteral()) {
+    return;
+  }
+  tidx = MergeTypeIdx(node->GetTypeIdx(), tidx);
+  SetTypeIdx(node, tidx);
+}
+
+void TypeInferVisitor::UpdateTypeIdx(TreeNode *node1, TreeNode *node2) {
+  if (!node1 || !node2 || node1 == node2) {
+    return;
+  }
+  unsigned tidx = MergeTypeIdx(node1->GetTypeIdx(), node2->GetTypeIdx());
+  if (tidx != 0) {
+    SetTypeIdx(node1, tidx);
+    SetTypeIdx(node2, tidx);
+  }
+}
+
+PrimTypeNode *TypeInferVisitor::GetOrClonePrimTypeNode(PrimTypeNode *pt, TypeId tid) {
+  PrimTypeNode *new_pt = pt;
+  TypeId oldtid = pt->GetTypeId();
+  // merge tids
+  tid = MergeTypeId(oldtid, tid);
+  // check if we need update
+  if (tid != oldtid) {
+    // check if we need clone PrimTypeNode to avoid using the shared one
+    if (oldtid == TY_None) {
+      new_pt = mHandler->NewTreeNode<PrimTypeNode>();
+      new_pt->SetPrimType(pt->GetPrimType());
+    }
+    SetTypeId(new_pt, tid);
+    if (IsPrimTypeId(tid)) {
+      SetTypeIdx(new_pt, tid);
+    } else {
+      SetTypeIdx(new_pt, gTypeTable.GetTypeFromTypeId(tid)->GetTypeIdx());
+    }
+    SetUpdated();
+  }
+  return new_pt;
+}
+
+bool static IsScalar(TypeId tid) {
+  switch (tid) {
+    case TY_None:
+    case TY_Int:
+    case TY_Long:
+    case TY_Float:
+    case TY_Double:
+      return true;
+    default:
+      return false;
+  }
+  return false;
+}
+
+// when function arry type parameter is updated, need update all
+// caller arguments to be consistent with the array type parameter
+void TypeInferVisitor::UpdateArgArrayDecls(unsigned nid, TypeId tid) {
+  for (auto id: mParam2ArgArrayDeclMap[nid]) {
+    mHandler->SetArrayElemTypeId(nid, tid);
+    if (id && id->IsDecl()) {
+      id = static_cast<DeclNode *>(id)->GetVar();
+    }
+    if (id && id->IsIdentifier()) {
+      IdentifierNode *inode = static_cast<IdentifierNode *>(id);
+      TreeNode *type = inode->GetType();
+      if (type && type->IsPrimArrayType()) {
+        PrimArrayTypeNode *pat = static_cast<PrimArrayTypeNode *>(type);
+        SetTypeId(pat->GetPrim(), tid);
+        SetUpdated();
+      }
+    }
+  }
+}
+
+// use input node's type info to update target node's type info
+void TypeInferVisitor::UpdateTypeUseNode(TreeNode *target, TreeNode *input) {
+  // this functionality is reserved for typescript
+  if (!mHandler->IsTS()) {
+    return;
+  }
+  TypeId tid = target->GetTypeId();
+  TypeId iid = input->GetTypeId();
+  if ((tid == iid && IsScalar(tid)) || (iid == TY_Array && tid != iid)) {
+    return;
+  }
+  switch (iid) {
+    case TY_None:
+      break;
+    case TY_Array: {
+      // function's formals with corresponding calls' parameters passed in
+      if (input->IsIdentifier()) {
+        TreeNode *decl = mHandler->FindDecl(static_cast<IdentifierNode *>(input));
+        TypeId old_elemTypeId = GetArrayElemTypeId(target);
+        unsigned old_elemTypeIdx = GetArrayElemTypeIdx(target);
+        TypeId inid = GetArrayElemTypeId(decl);
+        unsigned inidx = GetArrayElemTypeIdx(decl);
+        if (old_elemTypeId != inid || old_elemTypeIdx != inidx) {
+          UpdateArrayElemTypeMap(target, inid, inidx);
+        }
+        TypeId new_elemTypeId = GetArrayElemTypeId(target);
+        TreeNode *type = static_cast<IdentifierNode *>(target)->GetType();
+        MASSERT(target->IsIdentifier() && "target node not identifier");
+        if (type && type->IsPrimArrayType()) {
+          unsigned nid = target->GetNodeId();
+          mParam2ArgArrayDeclMap[nid].insert(decl);
+          if (old_elemTypeId != new_elemTypeId) {
+            PrimArrayTypeNode *pat = static_cast<PrimArrayTypeNode *>(type);
+            PrimTypeNode *pt = pat->GetPrim();
+            PrimTypeNode *new_pt = GetOrClonePrimTypeNode(pt, new_elemTypeId);
+            pat->SetPrim(new_pt);
+            SetUpdated();
+
+            UpdateArgArrayDecls(nid, new_elemTypeId);
+          }
+        }
+      }
+      // function's return type with return statement
+      else if (input->IsArrayLiteral()) {
+        TypeId old_elemTypeId = GetArrayElemTypeId(target);
+        unsigned old_elemTypeIdx = GetArrayElemTypeIdx(target);
+        TypeId inid = GetArrayElemTypeId(input);
+        unsigned inidx = GetArrayElemTypeIdx(input);
+        if (old_elemTypeId != inid || old_elemTypeIdx != inidx) {
+          UpdateArrayElemTypeMap(target, inid, inidx);
+        }
+        TypeId new_elemTypeId = GetArrayElemTypeId(target);
+        if (target->IsPrimArrayType()) {
+          unsigned nid = target->GetNodeId();
+          if (old_elemTypeId != new_elemTypeId) {
+            PrimArrayTypeNode *pat = static_cast<PrimArrayTypeNode *>(target);
+            PrimTypeNode *pt = pat->GetPrim();
+            PrimTypeNode *new_pt = GetOrClonePrimTypeNode(pt, new_elemTypeId);
+            pat->SetPrim(new_pt);
+            SetUpdated();
+
+            UpdateArgArrayDecls(nid, new_elemTypeId);
+          }
+        }
+      } else {
+        NOTYETIMPL("parameter not identifier");
+      }
+      break;
+    }
+    case TY_Int:
+    case TY_Long:
+    case TY_Float:
+    case TY_Double:
+    case TY_String:
+    case TY_Class:
+    case TY_Object:
+    case TY_Function: {
+      TypeId merged = MergeTypeId(tid, iid);
+      if (merged != tid && merged != TY_None) {
+        SetTypeId(target, merged);
+        SetUpdated();
+      }
+      break;
+    }
+    case TY_User:
+      break;
+    default:
+      NOTYETIMPL("TypeId not handled");
+      break;
+  }
+  return;
+}
+
+void TypeInferVisitor::UpdateFuncRetTypeId(FunctionNode *node, TypeId tid, unsigned tidx) {
+  if (!node || (node->GetTypeId() == tid && node->GetTypeIdx() == tidx)) {
+    return;
+  }
+  TreeNode *type = node->GetRetType();
+  // create new return type node if it was shared
+
+  if (type) {
+    if (type->IsPrimType() && type->IsTypeIdNone()) {
+      type = GetOrClonePrimTypeNode((PrimTypeNode *)type, tid);
+      node->SetRetType(type);
+    }
+    tid = MergeTypeId(type->GetTypeId(), tid);
+    SetTypeId(type, tid);
+    tidx = MergeTypeIdx(type->GetTypeIdx(), tidx);
+    SetTypeIdx(type, tidx);
+  }
+}
+
+TypeId TypeInferVisitor::GetArrayElemTypeId(TreeNode *node) {
+  unsigned nid = node->GetNodeId();
+  return mHandler->GetArrayElemTypeId(nid);
+}
+
+unsigned TypeInferVisitor::GetArrayElemTypeIdx(TreeNode *node) {
+  unsigned nid = node->GetNodeId();
+  return mHandler->GetArrayElemTypeIdx(nid);
+}
+
+void TypeInferVisitor::UpdateArrayElemTypeMap(TreeNode *node, TypeId tid, unsigned tidx) {
+  if (!node || tid == TY_None || !IsArray(node)) {
+    return;
+  }
+  unsigned nodeid = node->GetNodeId();
+  TypeId currtid = mHandler->GetArrayElemTypeId(nodeid);
+  tid = MergeTypeId(tid, currtid);
+
+  unsigned currtidx = mHandler->GetArrayElemTypeIdx(nodeid);
+  tidx = MergeTypeIdx(tidx, currtidx);
+
+  if (currtid != tid || currtidx != tidx) {
+    mHandler->SetArrayElemTypeId(node->GetNodeId(), tid);
+    mHandler->SetArrayElemTypeIdx(node->GetNodeId(), tidx);
+    SetUpdated();
+
+    // update array's PrimType node with a new node
+    if (node->IsDecl()) {
+      DeclNode *decl = static_cast<DeclNode *>(node);
+      node = decl->GetVar();
+    }
+    if (node->IsIdentifier()) {
+      IdentifierNode *in = static_cast<IdentifierNode *>(node);
+      node = in->GetType();
+    }
+
+    if (node->IsPrimArrayType()) {
+      PrimArrayTypeNode *pat = static_cast<PrimArrayTypeNode *>(node);
+      PrimTypeNode *pt = pat->GetPrim();
+      PrimTypeNode *new_pt = GetOrClonePrimTypeNode(pt, tid);
+      pat->SetPrim(new_pt);
+    }
+  }
+}
+
+void TypeInferVisitor::UpdateArrayDimMap(TreeNode *node, DimensionNode *dim) {
+  mHandler->SetArrayDim(node->GetNodeId(), dim);
+}
+
+// return true if identifier is constructor
+bool TypeInferVisitor::UpdateVarTypeWithInit(TreeNode *var, TreeNode *init) {
+  bool result = var->IsFunction();
+  if (!var->IsIdentifier()) {
+    return result;
+  }
+  IdentifierNode *idnode = static_cast<IdentifierNode *>(var);
+  TreeNode *type = idnode->GetType();
+  // use init NewNode to set decl type
+  if (init) {
+    if (init->IsNew()) {
+      NewNode *n = static_cast<NewNode *>(init);
+      if (n->GetId()) {
+        TreeNode *id = n->GetId();
+        if (id->IsIdentifier() && id->IsTypeIdClass()) {
+          UserTypeNode *utype = mInfo->CreateUserTypeNode(id->GetStrIdx(), var->GetScope());
+          utype->SetParent(idnode);
+          idnode->SetType(utype);
+          SetUpdated();
+        }
+      }
+    } else if (init->IsIdentifier()) {
+      TreeNode *decl = mHandler->FindDecl(static_cast<IdentifierNode *>(init));
+      if (decl) {
+        unsigned tidx = decl->GetTypeIdx();
+        if ((decl->IsClass() || (0 < tidx && tidx < (unsigned)TY_Max))) {
+          SetTypeId(idnode, TY_Function);
+          SetUpdated();
+          result = true;
+        }
+      }
+    } else if (init->IsStructLiteral()) {
+      if (!type && init->GetTypeIdx() != 0) {
+        type = gTypeTable.GetTypeFromTypeIdx(init->GetTypeIdx());
+        UserTypeNode *utype = mInfo->CreateUserTypeNode(type->GetStrIdx(), var->GetScope());
+        utype->SetParent(idnode);
+        idnode->SetType(utype);
+        SetUpdated();
+      }
+    } else if (init->IsArrayLiteral()) {
+      TypeId tid = GetArrayElemTypeId(init);
+      unsigned tidx = GetArrayElemTypeIdx(init);
+      if (type) {
+        if (type->IsArrayType()) {
+          ArrayTypeNode *pat = static_cast<ArrayTypeNode *>(type);
+          // update array element type
+          SetTypeId(pat->GetElemType(), tid);
+          SetTypeIdx(pat->GetElemType(), tidx);
+          SetUpdated();
+        } else {
+          NOTYETIMPL("array type not ArrayTypeNode");
+        }
+        return result;
+      }
+
+      TreeNode *elemtype = NULL;
+      if (IsPrimTypeId(tid)) {
+        elemtype = gTypeTable.GetTypeFromTypeId(tid);
+      } else if (tidx != 0) {
+        elemtype = gTypeTable.GetTypeFromTypeIdx(tidx);
+      }
+      if (elemtype) {
+        ArrayTypeNode *pat = mHandler->NewTreeNode<ArrayTypeNode>();
+        pat->SetElemType(elemtype);
+
+        DimensionNode *dims = mHandler->GetArrayDim(init->GetNodeId());
+        pat->SetDims(dims);
+
+        pat->SetParent(idnode);
+        idnode->SetType(pat);
+        SetUpdated();
+      }
+    }
+  }
+  return result;
+}
+
+bool TypeInferVisitor::IsArray(TreeNode *node) {
+  if (!node) {
+    return false;
+  }
+  if (node->IsArrayLiteral() || node->IsPrimArrayType()) {
+    return true;
+  }
+  TreeNode *tn = node;
+  if (node->IsDecl()) {
+    DeclNode *decl = static_cast<DeclNode *>(node);
+    tn = decl->GetVar();
+  }
+  if (tn->IsIdentifier()) {
+    IdentifierNode *idnode = static_cast<IdentifierNode *>(tn);
+    if (idnode && idnode->GetType() && idnode->GetType()->IsPrimArrayType()) {
+      return true;
+    }
+  } else if (tn->IsBindingPattern()) {
+    // could be either object or array destructuring
+    return false;
+  } else {
+    NOTYETIMPL("array not identifier or bind pattern");
+  }
+  return false;
+}
+
+TreeNode *TypeInferVisitor::VisitClassField(TreeNode *node) {
+  (void) AstVisitor::VisitTreeNode(node);
+  if (node->IsIdentifier()) {
+    IdentifierNode *idnode = static_cast<IdentifierNode *>(node);
+    TreeNode *type = idnode->GetType();
+    if (type) {
+      TypeId tid = type->GetTypeId();
+      if (type->IsPrimType()) {
+        PrimTypeNode *ptn = static_cast<PrimTypeNode *>(type);
+        tid = ptn->GetPrimType();
+      }
+      // use non TY_Number
+      if (tid != TY_Number) {
+        SetTypeId(node, tid);
+      }
+    }
+    TreeNode *init = idnode->GetInit();
+    if (init) {
+      VisitTreeNode(init);
+      UpdateTypeId(node, init->GetTypeId());
+    }
+  } else if (node->IsLiteral()) {
+    MSGNOLOC0("field is Literal");
+  } else if (node->IsComputedName()) {
+    MSGNOLOC0("field is ComputedName");
+  } else if (node->IsStrIndexSig()) {
+    MSGNOLOC0("field is StrIndexSig");
+  } else {
+    NOTYETIMPL("field new kind");
+  }
+  return node;
+}
+
+// ArrayElementNode are for
+// 1. array access
+// 2. indexed access of class/structure for fields, field types
+ArrayElementNode *TypeInferVisitor::VisitArrayElementNode(ArrayElementNode *node) {
+  (void) AstVisitor::VisitArrayElementNode(node);
+  TreeNode *array = node->GetArray();
+  if (array) {
+    if (array->IsIdentifier()) {
+      TreeNode *decl = mHandler->FindDecl(static_cast<IdentifierNode *>(array));
+      if (decl) {
+        // indexed access of class fields or types
+        if (decl->IsTypeIdClass()) {
+          SetTypeId(array, TY_Class);
+          TreeNode *exp = node->GetExprAtIndex(0);
+          if (exp->IsLiteral()) {
+            if (exp->IsTypeIdString()) {
+              // indexed access of types
+              unsigned stridx = (static_cast<LiteralNode *>(exp))->GetData().mData.mStrIdx;
+              if (decl->IsDecl()) {
+                TreeNode *var = static_cast<DeclNode *>(decl)->GetVar();
+                TreeNode * type = static_cast<IdentifierNode *>(var)->GetType();
+                if (type && type->IsUserType()) {
+                  UserTypeNode *ut = static_cast<UserTypeNode *>(type);
+                  decl = mHandler->FindDecl(static_cast<IdentifierNode *>(ut->GetId()));
+                }
+              }
+              if (decl->IsStruct() || decl->IsClass()) {
+                bool found = false;
+                for (int i = 0; i < mInfo->GetFieldsSize(decl); i++) {
+                  TreeNode *f = mInfo->GetField(decl, i);
+                  if (f->GetStrIdx() == stridx) {
+                    UpdateTypeId(node, f);
+                    found = true;
+                    break;
+                  }
+                }
+                // new field
+                if (!found) {
+                  IdentifierNode *id = mInfo->CreateIdentifierNode(stridx);
+                  mInfo->AddField(decl, id);
+                }
+              }
+            } else if (exp->IsTypeIdInt()) {
+              // indexed access of fields
+              // unsigned i = (static_cast<LiteralNode *>(exp))->GetData().mData.mInt64;
+              NOTYETIMPL("indexed access with literal field id");
+            } else {
+              AstVisitor::VisitTreeNode(exp);
+              NOTYETIMPL("indexed access not literal");
+            }
+          } else {
+            AstVisitor::VisitTreeNode(exp);
+          }
+        } else {
+          // default
+          UpdateTypeId(array, TY_Array);
+          UpdateTypeId(decl, array);
+          UpdateArrayElemTypeMap(decl, node->GetTypeId(), node->GetTypeIdx());
+          UpdateTypeId(node, mHandler->GetArrayElemTypeId(decl->GetNodeId()));
+        }
+      } else {
+        NOTYETIMPL("array not declared");
+      }
+    } else if (array->IsArrayElement()) {
+      NOTYETIMPL("array in ArrayElementNode IsArrayElement");
+    } else if (array->IsField()) {
+      NOTYETIMPL("array in ArrayElementNode IsField");
+    } else if (array->IsUserType()) {
+      NOTYETIMPL("array in ArrayElementNode IsUserType");
+    } else if (array->IsBinOperator()) {
+      NOTYETIMPL("array in ArrayElementNode IsBinOperator");
+    } else if (array->IsLiteral() && ((LiteralNode*)array)->IsThis()) {
+      NOTYETIMPL("array in ArrayElementNode IsLiteral");
+    } else if (array->IsPrimType()) {
+      NOTYETIMPL("array in ArrayElementNode IsPrimType");
+    } else {
+      NOTYETIMPL("array in ArrayElementNode unknown");
+    }
+  }
+  return node;
+}
+
+FieldLiteralNode *TypeInferVisitor::VisitFieldLiteralNode(FieldLiteralNode *node) {
+  (void) AstVisitor::VisitFieldLiteralNode(node);
+  TreeNode *name = node->GetFieldName();
+  TreeNode *lit = node->GetLiteral();
+  UpdateTypeId(name, lit->GetTypeId());
+  UpdateTypeId(node, name);
+  return node;
+}
+
+ArrayLiteralNode *TypeInferVisitor::VisitArrayLiteralNode(ArrayLiteralNode *node) {
+  UpdateTypeId(node, TY_Array);
+  (void) AstVisitor::VisitArrayLiteralNode(node);
+  if (node->IsArrayLiteral()) {
+    unsigned size = node->GetLiteralsNum();
+    TypeId tid = TY_None;
+    unsigned tidx = 0;
+    bool allElemArray = true;
+    for (unsigned i = 0; i < size; i++) {
+      TreeNode *n = node->GetLiteral(i);
+      TypeId id = n->GetTypeId();
+      unsigned idx = n->GetTypeIdx();
+      tid = MergeTypeId(tid, id);
+      tidx = MergeTypeIdx(tidx, idx);
+      if (tid != TY_Array) {
+        allElemArray = false;
+      }
+    }
+
+    DimensionNode *dim = mHandler->NewTreeNode<DimensionNode>();
+    dim->AddDimension(size);
+
+    // n-D array: elements are all arrays
+    if (allElemArray) {
+      unsigned elemdim = DEFAULTVALUE;
+      // recalculate element typeid
+      tid = TY_None;
+      tidx = 0;
+      for (unsigned i = 0; i < size; i++) {
+        TreeNode *n = node->GetLiteral(i);
+        if (n->IsArrayLiteral()) {
+          DimensionNode * dn = mHandler->GetArrayDim(n->GetNodeId());
+          unsigned currdim = dn ? dn->GetDimensionsNum() : 0;
+          // find min dim of all elements
+          if (elemdim == DEFAULTVALUE) {
+            elemdim = currdim;
+            tid = mHandler->GetArrayElemTypeId(n->GetNodeId());
+            tidx = mHandler->GetArrayElemTypeIdx(n->GetNodeId());
+          } else if (currdim < elemdim) {
+            elemdim = currdim;
+            tid = TY_Merge;
+            tidx = 0;
+          } else if (currdim > elemdim) {
+            tid = TY_Merge;
+            tidx = 0;
+          } else {
+            tid = MergeTypeId(tid, mHandler->GetArrayElemTypeId(n->GetNodeId()));
+            tidx = MergeTypeIdx(tidx, mHandler->GetArrayElemTypeIdx(n->GetNodeId()));
+          }
+        }
+      }
+      if (elemdim != DEFAULTVALUE) {
+        for (unsigned i = 0; i < elemdim; i++) {
+          // with unspecified length, can add details later
+          dim->AddDimension(0);
+        }
+      }
+    }
+
+    UpdateArrayElemTypeMap(node, tid, tidx);
+    UpdateArrayDimMap(node, dim);
+  }
+
+  return node;
+}
+
+BinOperatorNode *TypeInferVisitor::VisitBinOperatorNode(BinOperatorNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting BinOperatorNode, id=" << node->GetNodeId() << "..." << std::endl;
+  // (void) AstVisitor::VisitBinOperatorNode(node);
+  OprId op = node->GetOprId();
+  TreeNode *ta = node->GetOpndA();
+  TreeNode *tb = node->GetOpndB();
+  (void) VisitTreeNode(tb);
+  (void) VisitTreeNode(ta);
+  // modified operand
+  TreeNode *mod = NULL;
+  TypeId tia = ta->GetTypeId();
+  TypeId tib = tb->GetTypeId();
+  switch (op) {
+    case OPR_StEq:
+    case OPR_EQ:
+    case OPR_NE:
+    case OPR_GT:
+    case OPR_LT:
+    case OPR_GE:
+    case OPR_LE: {
+      if (tia != TY_None && tib == TY_None) {
+        UpdateTypeId(tb, tia);
+        mod = tb;
+      } else if (tia == TY_None && tib != TY_None) {
+        UpdateTypeId(ta, tib);
+        mod = ta;
+      }
+      SetTypeId(node, TY_Boolean);
+      SetTypeIdx(node, TY_Boolean);
+      break;
+    }
+    case OPR_Assign:
+    case OPR_AddAssign:
+    case OPR_SubAssign:
+    case OPR_MulAssign:
+    case OPR_DivAssign:
+    case OPR_ModAssign:
+    case OPR_ShlAssign:
+    case OPR_ShrAssign:
+    case OPR_BandAssign:
+    case OPR_BorAssign:
+    case OPR_BxorAssign:
+    case OPR_ZextAssign: {
+      TypeId ti = MergeTypeId(tia, tib);
+      if (tia == TY_None || (ta->IsIdentifier() && tia != ti)) {
+        UpdateTypeId(ta, ti);
+        mod = ta;
+      } else if (tib == TY_None) {
+        UpdateTypeId(tb, ti);
+        mod = tb;
+      }
+      UpdateTypeId(node, ti);
+      unsigned tix = MergeTypeIdx(ta->GetTypeIdx(), tb->GetTypeIdx());
+      UpdateTypeIdx(ta, tix);
+      UpdateTypeIdx(tb, tix);
+      UpdateTypeIdx(node, tix);
+      break;
+    }
+    case OPR_Add:
+    case OPR_Sub:
+    case OPR_Mul:
+    case OPR_Div: {
+      if (tia != TY_None && tib == TY_None) {
+        UpdateTypeId(tb, tia);
+        mod = tb;
+      } else if (tia == TY_None && tib != TY_None) {
+        UpdateTypeId(ta, tib);
+        mod = ta;
+      }
+      TypeId ti = MergeTypeId(tia, tib);
+      UpdateTypeId(node, ti);
+      unsigned tix = MergeTypeIdx(ta->GetTypeIdx(), tb->GetTypeIdx());
+      UpdateTypeIdx(ta, tix);
+      UpdateTypeIdx(tb, tix);
+      UpdateTypeIdx(node, tix);
+      break;
+    }
+    case OPR_Mod:
+    case OPR_Band:
+    case OPR_Bor:
+    case OPR_Bxor:
+    case OPR_Shl:
+    case OPR_Shr:
+    case OPR_Zext: {
+      SetTypeId(ta, TY_Int);
+      SetTypeId(tb, TY_Int);
+      SetTypeId(node, TY_Int);
+      SetTypeIdx(ta, TY_Int);
+      SetTypeIdx(tb, TY_Int);
+      SetTypeIdx(node, TY_Int);
+      break;
+    }
+    case OPR_Land:
+    case OPR_Lor: {
+      SetTypeId(ta, TY_Boolean);
+      SetTypeId(tb, TY_Boolean);
+      SetTypeId(node, TY_Boolean);
+      SetTypeIdx(ta, TY_Boolean);
+      SetTypeIdx(tb, TY_Boolean);
+      SetTypeIdx(node, TY_Boolean);
+      break;
+    }
+    case OPR_Exp: {
+      if (tia == TY_Int && tib == TY_Int) {
+        SetTypeId(node, TY_Int);
+        SetTypeIdx(node, TY_Int);
+      }
+      break;
+    }
+    case OPR_NullCoalesce:
+      break;
+    default: {
+      NOTYETIMPL("VisitBinOperatorNode()");
+      break;
+    }
+  }
+  // visit mod to update its content
+  (void) VisitTreeNode(mod);
+  return node;
+}
+
+CallNode *TypeInferVisitor::VisitCallNode(CallNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting CallNode, id=" << node->GetNodeId() << "..." << std::endl;
+  TreeNode *method = node->GetMethod();
+  Module_Handler *handler = mHandler;
+  UpdateTypeId(method, TY_Function);
+  if (method) {
+    if (method->IsField()) {
+      FieldNode *field = static_cast<FieldNode *>(method);
+      method = field->GetField();
+      TreeNode *upper = field->GetUpper();
+      handler = mAstOpt->GetHandlerFromNodeId(upper->GetNodeId());
+    }
+    if (method->IsIdentifier()) {
+      IdentifierNode *mid = static_cast<IdentifierNode *>(method);
+      TreeNode *decl = mHandler->FindDecl(mid);
+      if (decl) {
+        SetTypeIdx(node, decl->GetTypeIdx());
+        SetTypeIdx(mid, decl->GetTypeIdx());
+
+        if (decl->IsDecl()) {
+          DeclNode *d = static_cast<DeclNode *>(decl);
+          if (d->GetInit()) {
+            decl = d->GetInit();
+          }
+        }
+        if (decl && decl->IsIdentifier()) {
+          IdentifierNode *id = static_cast<IdentifierNode *>(decl);
+          if (id->GetType()) {
+            decl = id->GetType();
+          } else if (id->IsTypeIdFunction()) {
+            NOTYETIMPL("VisitCallNode TY_Function");
+          }
+        }
+        if (decl) {
+          if (decl->IsFunction()) {
+            FunctionNode *func = static_cast<FunctionNode *>(decl);
+            // check if called a generator
+            if (func->IsGenerator()) {
+              mHandler->AddGeneratorUsed(node->GetNodeId(), func);
+            }
+            // update call's return type
+            if (func->GetRetType()) {
+              UpdateTypeId(node, func->GetRetType()->GetTypeId());
+            }
+            // skip imported and exported functions as they are generic
+            // so should not restrict their types
+            if (!mXXport->IsImportedExportedDeclId(mHandler->GetHidx(), decl->GetNodeId())) {
+              unsigned min = func->GetParamsNum();
+              if (func->GetParamsNum() != node->GetArgsNum()) {
+                // count minimun number of args need to be passed
+                min = 0;
+                // check arg about whether it is optional or has default value
+                for (unsigned i = 0; i < func->GetParamsNum(); i++) {
+                  TreeNode *arg = func->GetParam(i);
+                  if (arg->IsOptional()) {
+                    continue;
+                  } else if(arg->IsIdentifier()) {
+                    IdentifierNode *id = static_cast<IdentifierNode *>(arg);
+                    TreeNode *d = mHandler->FindDecl(id);
+                    if (d) {
+                      SetTypeId(id, d->GetTypeId());
+                      SetTypeIdx(id, d->GetTypeIdx());
+                    }
+                    if (!id->GetInit()) {
+                      min++;
+                    }
+                  } else {
+                    min++;
+                  }
+                }
+                if (min > node->GetArgsNum()) {
+                  NOTYETIMPL("call and func number of arguments not compatible");
+                  return node;
+                }
+              }
+              // update function's argument types
+              for (unsigned i = 0; i < min; i++) {
+                UpdateTypeUseNode(func->GetParam(i), node->GetArg(i));
+              }
+
+              // dummy functions like console.log
+              if (func->IsTypeIdNone()) {
+                for (unsigned i = 0; i < node->GetArgsNum(); i++) {
+                  TreeNode *arg = node->GetArg(i);
+                  if(arg->IsIdentifier()) {
+                    IdentifierNode *id = static_cast<IdentifierNode *>(arg);
+                    TreeNode *d = mHandler->FindDecl(id);
+                    if (d) {
+                      SetTypeId(id, d->GetTypeId());
+                      SetTypeIdx(id, d->GetTypeIdx());
+                    }
+                  }
+                }
+              }
+            }
+          } else if (decl->IsCall()) {
+            (void) VisitCallNode(static_cast<CallNode *>(decl));
+          } else if (decl->IsDecl()) {
+            DeclNode *d = static_cast<DeclNode *>(decl);
+            if (d->GetInit()) {
+              NOTYETIMPL("VisitCallNode decl init");
+            }
+          } else if (decl->IsLiteral()) {
+            NOTYETIMPL("VisitCallNode literal node");
+          } else if (decl->IsTypeIdClass()) {
+            // object
+            if (node->GetArgsNum()) {
+              TreeNode *arg = node->GetArg(0);
+              SetTypeId(arg, TY_Object);
+              SetTypeIdx(arg, decl->GetTypeIdx());
+            }
+          } else {
+            NOTYETIMPL("VisitCallNode not function node");
+          }
+        } else {
+          NOTYETIMPL("VisitCallNode null decl");
+        }
+      } else if (mAstOpt->IsLangKeyword(mid)) {
+        // known calls
+      } else {
+        // calling constructor like Array(...) could also end up here
+        TreeNode *type = mHandler->FindType(mid);
+        if (type) {
+          NOTYETIMPL("VisitCallNode type");
+        } else {
+          NOTYETIMPL("VisitCallNode null decl and null type");
+        }
+      }
+    }
+  }
+  (void) AstVisitor::VisitCallNode(node);
+  return node;
+}
+
+CastNode *TypeInferVisitor::VisitCastNode(CastNode *node) {
+  (void) AstVisitor::VisitCastNode(node);
+  TreeNode *dest = node->GetDestType();
+  SetTypeId(node, dest);
+  return node;
+}
+
+AsTypeNode *TypeInferVisitor::VisitAsTypeNode(AsTypeNode *node) {
+  (void) AstVisitor::VisitAsTypeNode(node);
+  TreeNode *dest = node->GetType();
+  if (node->GetTypeIdx() == 0) {
+    SetTypeId(node, dest);
+  }
+
+  TreeNode *parent = node->GetParent();
+  if (parent) {
+    // pass to parent, need refine if multiple AsTypeNode
+    if (parent->GetAsTypesNum() == 1 && parent->GetAsTypeAtIndex(0) == node) {
+      if (parent->GetTypeIdx() == 0) {
+        SetTypeId(parent, dest);
+      }
+    }
+  }
+  return node;
+}
+
+ClassNode *TypeInferVisitor::VisitClassNode(ClassNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting ClassNode, id=" << node->GetNodeId() << "..." << std::endl;
+  UpdateTypeId(node, TY_Class);
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    TreeNode *t = node->GetField(i);
+    (void) VisitClassField(t);
+  }
+  (void) AstVisitor::VisitClassNode(node);
+  return node;
+}
+
+CondBranchNode *TypeInferVisitor::VisitCondBranchNode(CondBranchNode *node) {
+  (void) AstVisitor::VisitCondBranchNode(node);
+  TreeNode *cond = node->GetCond();
+  TreeNode *blockT = NULL;
+  TreeNode *blockF = NULL;
+  if (cond->IsUnaOperator()) {
+    cond = static_cast<UnaOperatorNode *>(cond)->GetOpnd();
+    blockT = node->GetFalseBranch();
+    blockF = node->GetTrueBranch();
+  } else {
+    blockT = node->GetTrueBranch();
+    blockF = node->GetFalseBranch();
+  }
+
+  if (cond->IsCall()) {
+    CallNode *call = static_cast<CallNode *>(cond);
+    TreeNode *method = call->GetMethod();
+    if (method && method->IsIdentifier()) {
+      IdentifierNode *id = static_cast<IdentifierNode *>(method);
+      unsigned mid = id->GetStrIdx();
+      unsigned nid = node->GetNodeId();
+      // check if already visited for mid and nodeid
+      if (mCbFuncIsDone.find(mid) != mCbFuncIsDone.end() &&
+          mCbFuncIsDone[mid].find(nid) != mCbFuncIsDone[mid].end()) {
+        return node;
+      }
+      TreeNode *decl = mHandler->FindDecl(id);
+      if (decl && decl->IsFunction()) {
+        unsigned fid = decl->GetNodeId();
+        if (mFuncIsNodeMap.find(fid) != mFuncIsNodeMap.end()) {
+          unsigned tidx = mFuncIsNodeMap[fid];
+          TreeNode *arg = call->GetArg(0);
+          if (arg->IsIdentifier()) {
+            unsigned stridx = arg->GetStrIdx();
+            mChangeTypeIdxVisitor->Setup(stridx, tidx);
+            mChangeTypeIdxVisitor->Visit(blockT);
+            mCbFuncIsDone[mid].insert(nid);
+            SetUpdated();
+
+            // if union of 2 types, update other branch with other type
+            TreeNode *argdecl = mHandler->FindDecl(static_cast<IdentifierNode *>(arg));
+            if (argdecl && argdecl->IsIdentifier()) {
+              TreeNode *type = static_cast<IdentifierNode *>(argdecl)->GetType();
+              if (type->IsUserType()) {
+                UserTypeNode *ut = static_cast<UserTypeNode *>(type);
+                if (ut->GetType() == UT_Union && ut->GetUnionInterTypesNum() == 2) {
+                  TreeNode *u0 = ut->GetUnionInterType(0);
+                  TreeNode *u1 = ut->GetUnionInterType(1);
+                  tidx = (u0->GetTypeIdx() == tidx) ? u1->GetTypeIdx() : u0->GetTypeIdx();
+                  mChangeTypeIdxVisitor->Setup(stridx, tidx);
+                  mChangeTypeIdxVisitor->Visit(blockF);
+                }
+              }
+            }
+          }
+        }
+      }
+
+    } else {
+      NOTYETIMPL("mentod null or not identifier");
+    }
+  }
+
+  return node;
+}
+
+DeclNode *TypeInferVisitor::VisitDeclNode(DeclNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting DeclNode, id=" << node->GetNodeId() << "..." << std::endl;
+  (void) AstVisitor::VisitDeclNode(node);
+  TreeNode *init = node->GetInit();
+  TreeNode *var = node->GetVar();
+  TypeId merged = node->GetTypeId();
+  unsigned mergedtidx = node->GetTypeIdx();
+  TypeId elemTypeId = TY_None;
+  unsigned elemTypeIdx = 0;
+  bool isArray = false;
+  bool isFromGenerator = false;
+  if (init) {
+    merged = MergeTypeId(merged, init->GetTypeId());
+    mergedtidx = MergeTypeIdx(mergedtidx, init->GetTypeIdx());
+    // collect array element typeid if any
+    elemTypeId = GetArrayElemTypeId(init);
+    elemTypeIdx = GetArrayElemTypeIdx(init);
+    isArray = (elemTypeId != TY_None);
+    // pass IsGeneratorUsed
+    isFromGenerator = mHandler->UpdateGeneratorUsed(node->GetNodeId(), init->GetNodeId());
+    if (var && isFromGenerator) {
+      mHandler->UpdateGeneratorUsed(var->GetNodeId(), init->GetNodeId());
+    }
+  }
+  if (var) {
+    // normal cases
+    if(var->IsIdentifier()) {
+      IdentifierNode *idvar = static_cast<IdentifierNode *>(var);
+      if (isFromGenerator && !idvar->GetType()) {
+        unsigned stridx = gStringPool.GetStrIdx("Generator");
+        UserTypeNode *ut = mInfo->CreateUserTypeNode(stridx, var->GetScope());
+        idvar->SetType(ut);
+      }
+      merged = MergeTypeId(merged, var->GetTypeId());
+      mergedtidx = MergeTypeIdx(mergedtidx, var->GetTypeIdx());
+      bool isFunc = UpdateVarTypeWithInit(var, init);
+      if (isFunc) {
+        UpdateTypeId(node, var->GetTypeId());
+        UpdateTypeIdx(node, mergedtidx);
+        UpdateTypeIdx(var, mergedtidx);
+        return node;
+      }
+    } else {
+      // BindingPatternNode
+    }
+  } else {
+    MASSERT("var null");
+  }
+  // override TypeId for array
+  if (isArray) {
+    merged = TY_Array;
+    SetTypeId(node, merged);
+    SetTypeId(init, merged);
+    SetTypeId(var, merged);
+  } else {
+    UpdateTypeId(node, merged);
+    UpdateTypeId(init, merged);
+    UpdateTypeId(var, merged);
+    if (mergedtidx > 0) {
+      UpdateTypeIdx(node, mergedtidx);
+      UpdateTypeIdx(init, mergedtidx);
+      UpdateTypeIdx(var, mergedtidx);
+    }
+  }
+  SetTypeIdx(node, var->GetTypeIdx());
+  if (isArray || IsArray(node)) {
+    UpdateArrayElemTypeMap(node, elemTypeId, elemTypeIdx);
+  }
+  return node;
+}
+
+ImportNode *TypeInferVisitor::VisitImportNode(ImportNode *node) {
+  //(void) AstVisitor::VisitImportNode(node);
+  TreeNode *target = node->GetTarget();
+  unsigned hidx = DEFAULTVALUE;
+  unsigned hstridx = 0;
+  if (target) {
+    std::string name = mXXport->GetTargetFilename(mHandler->GetHidx(), target);
+    // store name's string index in node
+    hstridx = gStringPool.GetStrIdx(name);
+    hidx = mXXport->GetHandleIdxFromStrIdx(hstridx);
+  }
+  for (unsigned i = 0; i < node->GetPairsNum(); i++) {
+    XXportAsPairNode *p = node->GetPair(i);
+    TreeNode *bfnode = p->GetBefore();
+    TreeNode *afnode = p->GetAfter();
+    if (bfnode) {
+      if (hidx == DEFAULTVALUE) {
+        hstridx = mXXport->ExtractTargetStrIdx(bfnode);
+        if (hstridx) {
+          hidx = mXXport->GetHandleIdxFromStrIdx(hstridx);
+        } else {
+          NOTYETIMPL("can not find import target");
+          return node;
+        }
+      }
+      if (p->IsDefault()) {
+        TreeNode *dflt = mXXport->GetExportedDefault(hstridx);
+        if (dflt) {
+          UpdateTypeId(bfnode, dflt->GetTypeId());
+          UpdateTypeIdx(bfnode, dflt->GetTypeIdx());
+        } else {
+          NOTYETIMPL("can not find exported default");
+        }
+      } else if (!bfnode->IsTypeIdModule()) {
+        TreeNode *exported = NULL;
+        if (bfnode->IsField()) {
+          FieldNode *field = static_cast<FieldNode *>(bfnode);
+          TreeNode *upper = field->GetUpper();
+          TreeNode *fld = field->GetField();
+          if (upper->IsTypeIdModule()) {
+            TreeNode *type = gTypeTable.GetTypeFromTypeIdx(upper->GetTypeIdx());
+            Module_Handler *h = mHandler->GetModuleHandler(type);
+            exported = mXXport->GetExportedNamedNode(h->GetHidx(), fld->GetStrIdx());
+            if (exported) {
+              UpdateTypeId(bfnode, exported->GetTypeId());
+              UpdateTypeIdx(bfnode, exported->GetTypeIdx());
+            }
+          }
+        } else {
+          exported = mXXport->GetExportedNamedNode(hidx, bfnode->GetStrIdx());
+          if (exported) {
+            SetTypeId(bfnode, exported);
+          }
+        }
+        if (!exported) {
+          NOTYETIMPL("can not find exported node");
+        }
+      }
+
+      SetTypeId(p, bfnode);
+      if (afnode) {
+        SetTypeId(afnode, bfnode);
+      }
+    }
+  }
+  return node;
+}
+
+// check if node is identifier with name "default"+RENAMINGSUFFIX
+static bool IsDefault(TreeNode *node) {
+  return node->GetStrIdx() == gStringPool.GetStrIdx(std::string("default") + RENAMINGSUFFIX);
+}
+
+ExportNode *TypeInferVisitor::VisitExportNode(ExportNode *node) {
+  (void) AstVisitor::VisitExportNode(node);
+  unsigned hidx = mHandler->GetHidx();
+  for (unsigned i = 0; i < node->GetPairsNum(); i++) {
+    XXportAsPairNode *p = node->GetPair(i);
+    TreeNode *bfnode = p->GetBefore();
+    TreeNode *afnode = p->GetAfter();
+    if (bfnode) {
+      switch (bfnode->GetKind()) {
+        case NK_Struct:
+        case NK_Function:
+        case NK_Decl: {
+          mXXport->AddExportedDeclIds(hidx, bfnode->GetNodeId());
+          break;
+        }
+        case NK_Declare: {
+          DeclareNode *declare = static_cast<DeclareNode *>(bfnode);
+          for (unsigned i = 0; i < declare-> GetDeclsNum(); i++) {
+            TreeNode *decl = declare->GetDeclAtIndex(i);
+            if (decl) {
+              mXXport->AddExportedDeclIds(hidx, decl->GetNodeId());
+            }
+          }
+          break;
+        }
+        case NK_Identifier: {
+          IdentifierNode *idnode = static_cast<IdentifierNode *>(bfnode);
+          TreeNode *decl = mHandler->FindDecl(idnode);
+          if (decl) {
+            mXXport->AddExportedDeclIds(hidx, decl->GetNodeId());
+          }
+          if (IsDefault(bfnode)) {
+            unsigned stridx = node->GetStrIdx();
+            TreeNode *dflt = mXXport->GetExportedDefault(stridx);
+            if (dflt) {
+              UpdateTypeId(bfnode, dflt->GetTypeId());
+              UpdateTypeIdx(bfnode, dflt->GetTypeIdx());
+            } else {
+              NOTYETIMPL("can not find exported default");
+            }
+          }
+          break;
+        }
+        case NK_TypeAlias:
+        case NK_UserType:
+        case NK_Import:
+          break;
+        default: {
+          NOTYETIMPL("new export node kind");
+          break;
+        }
+      }
+
+      UpdateTypeId(p, bfnode->GetTypeId());
+      UpdateTypeIdx(p, bfnode->GetTypeIdx());
+      if (afnode) {
+        UpdateTypeId(afnode, bfnode->GetTypeId());
+        UpdateTypeIdx(afnode, bfnode->GetTypeIdx());
+      }
+    }
+  }
+  return node;
+}
+
+FieldNode *TypeInferVisitor::VisitFieldNode(FieldNode *node) {
+  (void) AstVisitor::VisitFieldNode(node);
+  TreeNode *upper = node->GetUpper();
+  IdentifierNode *field = static_cast<IdentifierNode *>(node->GetField());
+  TreeNode *decl = NULL;
+  if (!upper) {
+    decl = mHandler->FindDecl(field);
+  } else {
+    if (upper->IsLiteral()) {
+      LiteralNode *ln = static_cast<LiteralNode *>(upper);
+      // this.f
+      if (ln->GetData().mType == LT_ThisLiteral) {
+        decl = mHandler->FindDecl(field);
+      }
+    }
+    if (!decl) {
+      unsigned tidx = upper->GetTypeIdx();
+      if (tidx) {
+        TreeNode *n = gTypeTable.GetTypeFromTypeIdx(tidx);
+        ASTScope *scope = n->GetScope();
+        decl = scope->FindDeclOf(field->GetStrIdx());
+      }
+    }
+  }
+  if (decl) {
+    UpdateTypeId(node, decl);
+  }
+  UpdateTypeId(field, node);
+  return node;
+}
+
+ForLoopNode *TypeInferVisitor::VisitForLoopNode(ForLoopNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting ForLoopNode, id=" << node->GetNodeId() << "..." << std::endl;
+  if (node->GetProp() == FLP_JSIn) {
+    TreeNode *var = node->GetVariable();
+    if (var) {
+      SetTypeId(var, TY_Int);
+    }
+  }
+  (void) AstVisitor::VisitForLoopNode(node);
+  return node;
+}
+
+FunctionNode *TypeInferVisitor::VisitFunctionNode(FunctionNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting FunctionNode, id=" << node->GetNodeId() << "..." << std::endl;
+  UpdateTypeId(node, node->IsArray() ? TY_Object : TY_Function);
+  (void) AstVisitor::VisitFunctionNode(node);
+  if (node->GetFuncName()) {
+    SetTypeId(node->GetFuncName(), node->GetTypeId());
+  }
+  return node;
+}
+
+IdentifierNode *TypeInferVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting IdentifierNode, id=" << node->GetNodeId() << "..." << std::endl;
+  if (mAstOpt->IsLangKeyword(node)) {
+    return node;
+  }
+  TreeNode *type = node->GetType();
+  if (type) {
+    if (type->IsPrimArrayType()) {
+      SetTypeId(node, TY_Array);
+      SetUpdated();
+    }
+  }
+  (void) AstVisitor::VisitIdentifierNode(node);
+  if (type) {
+    unsigned tidx = type->GetTypeIdx();
+    if (tidx && node->GetTypeIdx() != tidx) {
+      UpdateTypeId(node, type->GetTypeId());
+      UpdateTypeIdx(node, tidx);
+      SetUpdated();
+    }
+  }
+  TreeNode *init = node->GetInit();
+  if (init) {
+    if (node->GetTypeId() == TY_None) {
+      SetTypeId(node, init->GetTypeId());
+    }
+    if (node->GetTypeIdx() == 0) {
+      SetTypeIdx(node, init->GetTypeIdx());
+    }
+    SetUpdated();
+    if (init->IsArrayLiteral()) {
+      // pass array element info
+      TypeId tid = mHandler->GetArrayElemTypeId(init->GetNodeId());
+      unsigned tidx = mHandler->GetArrayElemTypeIdx(init->GetNodeId());
+      UpdateArrayElemTypeMap(node, tid, tidx);
+      if (type && type->IsArrayType()) {
+        TreeNode *et = static_cast<ArrayTypeNode *>(type)->GetElemType();
+        et->SetTypeId(tid);
+        et->SetTypeIdx(tidx);
+      }
+    }
+    return node;
+  }
+  TreeNode *parent = node->GetParent();
+  TreeNode *decl = NULL;
+  if (parent && parent->IsField()) {
+    FieldNode *field = static_cast<FieldNode *>(parent);
+    TreeNode *upper = field->GetUpper();
+    TreeNode *fld = field->GetField();
+    ASTScope *scope = NULL;
+    if (node == upper) {
+      if (upper->IsThis()) {
+        // this.f
+        scope = upper->GetScope();
+        // this is the parent with typeid TY_Class
+        while (scope && scope->GetTree()->GetTypeId() != TY_Class) {
+          scope = scope->GetParent();
+        }
+        if (scope) {
+          upper->SetTypeId(scope->GetTree()->GetTypeId());
+          upper->SetTypeIdx(scope->GetTree()->GetTypeIdx());
+        }
+        decl = upper;
+      } else {
+        decl = mHandler->FindDecl(node, true);
+      }
+    } else if (node == fld) {
+      TreeNode *uptype = gTypeTable.GetTypeFromTypeIdx(upper->GetTypeIdx());
+      if (uptype) {
+        scope = uptype->GetScope();
+        if (scope) {
+          node->SetScope(scope);
+          decl = mHandler->FindDecl(node, true);
+        }
+      }
+    } else {
+      NOTYETIMPL("node not in field");
+    }
+  } else {
+    decl = mHandler->FindDecl(node);
+  }
+
+  if (decl) {
+    // check node itself is part of decl
+    if (decl != parent) {
+      UpdateTypeId(node, decl);
+      UpdateTypeIdx(node, decl);
+    }
+    // pass IsGeneratorUsed
+    mHandler->UpdateGeneratorUsed(node->GetNodeId(), decl->GetNodeId());
+  } else {
+    NOTYETIMPL("node not declared");
+    MSGNOLOC0(node->GetName());
+  }
+
+  return node;
+}
+
+InterfaceNode *TypeInferVisitor::VisitInterfaceNode(InterfaceNode *node) {
+  UpdateTypeId(node, TY_Class);
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    TreeNode *t = node->GetField(i);
+    (void) VisitClassField(t);
+  }
+  (void) AstVisitor::VisitInterfaceNode(node);
+  return node;
+}
+
+IsNode *TypeInferVisitor::VisitIsNode(IsNode *node) {
+  (void) AstVisitor::VisitIsNode(node);
+  SetTypeIdx(node, TY_Boolean);
+  TreeNode *parent = node->GetParent();
+  if (parent->IsFunction()) {
+    FunctionNode *func = static_cast<FunctionNode *>(parent);
+    if (func->GetRetType() == node) {
+      TreeNode *right = node->GetRight();
+      if (right->IsUserType()) {
+        TreeNode *id = static_cast<UserTypeNode *>(right)->GetId();
+        SetTypeIdx(right, id->GetTypeIdx());
+        mFuncIsNodeMap[func->GetNodeId()] = id->GetTypeIdx();
+      } else {
+        NOTYETIMPL("isnode right not user type");
+      }
+    }
+  }
+
+  return node;
+}
+
+NewNode *TypeInferVisitor::VisitNewNode(NewNode *node) {
+  (void) AstVisitor::VisitNewNode(node);
+  TreeNode *id = node->GetId();
+  if (id) {
+    UpdateTypeId(node, TY_Class);
+    if (id->GetTypeIdx() == 0) {
+      if (id->IsIdentifier()) {
+        IdentifierNode *idn = static_cast<IdentifierNode *>(id);
+        TreeNode *decl = mHandler->FindDecl(idn);
+        if (decl && decl->GetTypeIdx() != 0) {
+          SetTypeIdx(node, decl->GetTypeIdx());
+        }
+      }
+    } else {
+      SetTypeIdx(node, id->GetTypeIdx());
+    }
+  }
+  return node;
+}
+
+StructNode *TypeInferVisitor::VisitStructNode(StructNode *node) {
+  if (node->GetProp() != SProp_TSEnum) {
+    SetTypeId(node, TY_Class);
+  }
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    TreeNode *t = node->GetField(i);
+    (void) VisitClassField(t);
+  }
+  if (node->GetProp() == SProp_TSEnum) {
+    TypeId tid = TY_None;
+    unsigned tidx = 0;
+    for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+      TreeNode *t = node->GetField(i);
+      tid = MergeTypeId(tid, t->GetTypeId());
+      tidx = MergeTypeIdx(tidx, t->GetTypeIdx());
+    }
+    if (tid == TY_None) {
+      tid = TY_Int;
+      tidx = (unsigned)TY_Int;
+    }
+    for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+      TreeNode *t = node->GetField(i);
+      SetTypeId(t, tid);
+      SetTypeIdx(t, tidx);
+    }
+    TreeNode *id = node->GetStructId();
+    if (id) {
+      SetTypeId(id, node->GetTypeId());
+      SetTypeIdx(id, node->GetTypeIdx());
+    }
+  }
+  (void) AstVisitor::VisitStructNode(node);
+  return node;
+}
+
+LambdaNode *TypeInferVisitor::VisitLambdaNode(LambdaNode *node) {
+  if (mFlags & FLG_trace_1) std::cout << "Visiting LambdaNode, id=" << node->GetNodeId() << "..." << std::endl;
+  UpdateTypeId(node, TY_Function);
+  (void) AstVisitor::VisitLambdaNode(node);
+  return node;
+}
+
+LiteralNode *TypeInferVisitor::VisitLiteralNode(LiteralNode *node) {
+  (void) AstVisitor::VisitLiteralNode(node);
+  LitId id = node->GetData().mType;
+  switch (id) {
+    case LT_IntegerLiteral:
+      SetTypeId(node, TY_Int);
+      SetTypeIdx(node, TY_Int);
+      break;
+    case LT_FPLiteral:
+      SetTypeId(node, TY_Float);
+      SetTypeIdx(node, TY_Float);
+      break;
+    case LT_DoubleLiteral:
+      SetTypeId(node, TY_Double);
+      SetTypeIdx(node, TY_Double);
+      break;
+    case LT_StringLiteral:
+      SetTypeId(node, TY_String);
+      SetTypeIdx(node, TY_String);
+      break;
+    case LT_VoidLiteral:
+      SetTypeId(node, TY_Undefined);
+      break;
+    default:
+      break;
+  }
+  return node;
+}
+
+ReturnNode *TypeInferVisitor::VisitReturnNode(ReturnNode *node) {
+  (void) AstVisitor::VisitReturnNode(node);
+  TreeNode *res = node->GetResult();
+  if (res) {
+    UpdateTypeId(node, res->GetTypeId());
+    UpdateTypeIdx(node, res->GetTypeIdx());
+  }
+  TreeNode *tn = mHandler->FindFunc(node);
+  if (tn) {
+    FunctionNode *func = static_cast<FunctionNode *>(tn);
+    // use dummy PrimTypeNode as return type of function if not set to carry return TypeId
+    if (!func->GetRetType()) {
+      PrimTypeNode *type = mHandler->NewTreeNode<PrimTypeNode>();
+      type->SetPrimType(TY_None);
+      func->SetRetType(type);
+    }
+    if (!func->IsGenerator() && !func->IsIterator()) {
+      UpdateFuncRetTypeId(func, node->GetTypeId(), node->GetTypeIdx());
+      if (res) {
+        // use res to update function's return type
+        UpdateTypeUseNode(func->GetRetType(), res);
+      }
+    }
+  }
+  return node;
+}
+
+StructLiteralNode *TypeInferVisitor::VisitStructLiteralNode(StructLiteralNode *node) {
+  SetTypeId(node, TY_Class);
+  for (unsigned i = 0; i < node->GetFieldsNum(); ++i) {
+    FieldLiteralNode *t = node->GetField(i);
+    (void) VisitFieldLiteralNode(t);
+  }
+  (void) AstVisitor::VisitStructLiteralNode(node);
+  return node;
+}
+
+TemplateLiteralNode *TypeInferVisitor::VisitTemplateLiteralNode(TemplateLiteralNode *node) {
+  UpdateTypeId(node, TY_String);
+  (void) AstVisitor::VisitTemplateLiteralNode(node);
+  return node;
+}
+
+TerOperatorNode *TypeInferVisitor::VisitTerOperatorNode(TerOperatorNode *node) {
+  TreeNode *ta = node->GetOpndA();
+  TreeNode *tb = node->GetOpndB();
+  TreeNode *tc = node->GetOpndC();
+  (void) VisitTreeNode(ta);
+  (void) VisitTreeNode(tb);
+  (void) VisitTreeNode(tc);
+  UpdateTypeId(node, tb);
+  return node;
+}
+
+TypeOfNode *TypeInferVisitor::VisitTypeOfNode(TypeOfNode *node) {
+  UpdateTypeId(node, TY_String);
+  (void) AstVisitor::VisitTypeOfNode(node);
+  return node;
+}
+
+TypeAliasNode *TypeInferVisitor::VisitTypeAliasNode(TypeAliasNode *node) {
+  (void) AstVisitor::VisitTypeAliasNode(node);
+  UserTypeNode *id = node->GetId();
+  TreeNode *alias = node->GetAlias();
+  UpdateTypeId(id, alias);
+  return node;
+}
+
+UnaOperatorNode *TypeInferVisitor::VisitUnaOperatorNode(UnaOperatorNode *node) {
+  (void) AstVisitor::VisitUnaOperatorNode(node);
+  OprId op = node->GetOprId();
+  TreeNode *ta = node->GetOpnd();
+  switch (op) {
+    case OPR_Plus:
+    case OPR_Minus:
+      UpdateTypeId(node, ta->GetTypeId());
+      break;
+    case OPR_PreInc:
+    case OPR_Inc:
+    case OPR_PreDec:
+    case OPR_Dec:
+      UpdateTypeId(ta, TY_Int);
+      UpdateTypeId(node, TY_Int);
+      break;
+    case OPR_Bcomp:
+      UpdateTypeId(ta, TY_Int);
+      UpdateTypeId(node, TY_Int);
+      break;
+    case OPR_Not:
+      UpdateTypeId(ta, TY_Boolean);
+      UpdateTypeId(node, TY_Boolean);
+      break;
+    default: {
+      NOTYETIMPL("VisitUnaOperatorNode()");
+      break;
+    }
+  }
+  return node;
+}
+
+UserTypeNode *TypeInferVisitor::VisitUserTypeNode(UserTypeNode *node) {
+  (void) AstVisitor::VisitUserTypeNode(node);
+  if (node->GetDims()) {
+    SetTypeId(node, TY_Array);
+    SetTypeIdx(node, TY_Array);
+  } else if (node->GetId()) {
+    // non-enum user type which keep TY_None
+    if (node->GetId()->GetTypeId() != TY_None) {
+      SetTypeId(node, TY_Class);
+    }
+    UpdateTypeIdx(node, node->GetId());
+  }
+  TreeNode *parent = node->GetParent();
+  if (parent && parent->IsIdentifier()) {
+    // typeid: merge -> user
+    if (parent->IsTypeIdMerge()) {
+      SetTypeId(parent, TY_User);
+      SetUpdated();
+    } else if (parent->IsTypeIdArray()) {
+      TreeNode *idnode = node->GetId();
+      if (idnode && idnode->IsIdentifier()) {
+        // number, string could have been used
+        // as usertype identifier instand of primtype by parser
+        IdentifierNode *id = static_cast<IdentifierNode *>(idnode);
+        TypeId tid = TY_None;
+        unsigned stridx = id->GetStrIdx();
+        if (stridx == gStringPool.GetStrIdx("number")) {
+          tid = TY_Number;
+        } else if (stridx == gStringPool.GetStrIdx("string")) {
+          tid = TY_String;
+        }
+        if (tid != TY_None) {
+          PrimArrayTypeNode *type = mHandler->NewTreeNode<PrimArrayTypeNode>();
+          PrimTypeNode *pt = mHandler->NewTreeNode<PrimTypeNode>();
+          pt->SetPrimType(tid);
+          type->SetPrim(pt);
+          type->SetDims(node->GetDims());
+          IdentifierNode *parentid = static_cast<IdentifierNode *>(parent);
+          parentid->SetType(type);
+
+          // clean up parent info
+          id->SetParent(NULL);
+          node->SetParent(NULL);
+
+          // set updated
+          SetUpdated();
+        }
+      }
+    }
+  }
+  return node;
+}
+
+UserTypeNode *ShareUTVisitor::VisitUserTypeNode(UserTypeNode *node) {
+  // skip it
+  return node;
+
+  (void) AstVisitor::VisitUserTypeNode(node);
+
+  // skip for array
+  if (node->GetDims()) {
+    return node;
+  }
+
+  TreeNode *idnode = node->GetId();
+  if (idnode && idnode->IsIdentifier()) {
+    IdentifierNode *id = static_cast<IdentifierNode *>(idnode);
+    ASTScope *scope = id->GetScope();
+    TreeNode *type = scope->FindTypeOf(id->GetStrIdx());
+    if (type && type != node && type->IsUserType()) {
+      UserTypeNode *ut = static_cast<UserTypeNode *>(type);
+      if (node->GetType() == ut->GetType()) {
+        // do not share if there are generics
+        if (ut->GetTypeGenericsNum() == 0) {
+          return ut;
+        }
+      }
+    }
+  }
+  return node;
+}
+
+bool CheckTypeVisitor::IsCompatible(TypeId tid, TypeId target) {
+  if (tid == target) {
+    return true;
+  }
+
+  bool result = false;
+  switch (target) {
+    case TY_Number: {
+      switch (tid) {
+        case TY_None:
+        case TY_Int:
+        case TY_Long:
+        case TY_Float:
+        case TY_Double:
+          result = true;
+          break;
+        default:
+          result = false;
+          break;
+      }
+      break;
+    }
+    case TY_Any:
+      // TY_Any or unspecified matches everything
+      result = true;
+      break;
+    default:
+      // ok if same typeid
+      result = (target == tid);
+      break;
+  }
+
+  // tid being TY_None means untouched
+  result = result || (tid == TY_None);
+
+  return result;
+}
+
+IdentifierNode *CheckTypeVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  (void) AstVisitor::VisitIdentifierNode(node);
+
+  TreeNode *d = mHandler->FindDecl(node);
+  if (d && d->IsDecl()) {
+    DeclNode *decl = static_cast<DeclNode *>(d);
+    TreeNode *var = decl->GetVar();
+    if (var && var != node && var->IsIdentifier()) {
+      IdentifierNode *id = static_cast<IdentifierNode *>(var);
+      bool result = false;
+      TreeNode *type = id->GetType();
+      if (type) {
+        TypeId id = node->GetTypeId();
+        TypeId target = TY_None;
+        switch (type->GetKind()) {
+          case NK_PrimType: {
+            PrimTypeNode *ptn = static_cast<PrimTypeNode *>(type);
+            target = ptn->GetPrimType();
+            break;
+          }
+          case NK_UserType: {
+            target = var->GetTypeId();
+            break;
+          }
+          default: {
+            target = var->GetTypeId();
+            break;
+          }
+        }
+        result = IsCompatible(id, target);
+        if (!result || (mFlags & FLG_trace_3)) {
+          std::cout << " Type Compatiblity : " << result << " : "
+                    << AstDump::GetEnumTypeId(target) << " "
+                    << AstDump::GetEnumTypeId(id) << std::endl;
+        }
+      }
+    }
+  }
+  return node;
+}
+
+IdentifierNode *ChangeTypeIdxVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  (void) AstVisitor::VisitIdentifierNode(node);
+  if (node->GetStrIdx() == mStrIdx) {
+    mHandler->GetUtil()->SetTypeIdx(node, mTypeIdx);
+  }
+  return node;
+}
+
+}
diff --git a/src/MapleFE/astopt/src/ast_util.cpp b/src/MapleFE/astopt/src/ast_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..84faa11a789b3d1396105073d4d9c3d55b59e194
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_util.cpp
@@ -0,0 +1,102 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include "ast.h"
+#include "ast_util.h"
+#include "ast_handler.h"
+#include "gen_astdump.h"
+
+namespace maplefe {
+
+#define CPPKEYWORD(K) stridx = gStringPool.GetStrIdx(#K); mCppKeywords.insert(stridx);
+void AST_Util::BuildCppKeyWordSet() {
+  unsigned stridx;
+#include "cpp_keywords.def"
+}
+
+bool AST_Util::IsDirectField(TreeNode *node) {
+  return mHandler->IsDirectField(node);
+}
+
+bool AST_Util::IsCppKeyWord(unsigned stridx) {
+  return mCppKeywords.find(stridx) != mCppKeywords.end();
+}
+
+bool AST_Util::IsCppKeyWord(std::string name) {
+  unsigned stridx = gStringPool.GetStrIdx(name);
+  return mCppKeywords.find(stridx) != mCppKeywords.end();
+}
+
+// 
+bool AST_Util::IsCppName(std::string name) {
+  // check first char [a-z][A-Z]_
+  char c = name[0];
+  if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')) {
+    return false;
+  }
+
+  // check char [a-z][A-Z][0-9]_
+  for (int i = 1; i < name.length(); i++) {
+    char c = name[i];
+    if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_')) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool AST_Util::IsCppField(TreeNode *node) {
+  // check if it is a direct field
+  if (!IsDirectField(node)) {
+    return false;
+  }
+
+  // check if it's name is a C++ keyworld
+  unsigned stridx = node->GetStrIdx();
+  if (IsCppKeyWord(stridx)) {
+    return false;
+  }
+
+  // check if it's name is a valid C++ name
+  std::string name = gStringPool.GetStringFromStrIdx(stridx);
+  if (!IsCppName(name)) {
+    return false;
+  }
+  return true;
+}
+
+void AST_Util::SetTypeId(TreeNode *node, TypeId tid) {
+  if (tid != TY_None && node && node->GetTypeId() != tid) {
+    if (mFlags & FLG_trace_3) {
+      std::cout << " NodeId : " << node->GetNodeId() << " Set TypeId : "
+                << AstDump::GetEnumTypeId(node->GetTypeId()) << " --> "
+                << AstDump::GetEnumTypeId(tid) << std::endl;
+    }
+    node->SetTypeId(tid);
+  }
+}
+
+void AST_Util::SetTypeIdx(TreeNode *node, unsigned tidx) {
+  if (node && node->GetTypeIdx() != tidx) {
+    if (mFlags & FLG_trace_3) {
+      std::cout << " NodeId : " << node->GetNodeId() << " Set TypeIdx : "
+                << node->GetTypeIdx() << " --> " << tidx << std::endl;
+    }
+    node->SetTypeIdx(tidx);
+  }
+}
+
+}
diff --git a/src/MapleFE/astopt/src/ast_xxport.cpp b/src/MapleFE/astopt/src/ast_xxport.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3b828851ba70dbec2137c069b8d0b647e1f34ca0
--- /dev/null
+++ b/src/MapleFE/astopt/src/ast_xxport.cpp
@@ -0,0 +1,546 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <stack>
+#include <set>
+#include <algorithm>
+#include <filesystem>
+#include "ast_handler.h"
+#include "ast_util.h"
+#include "astopt.h"
+#include "ast_xxport.h"
+#include "gen_astdump.h"
+
+namespace maplefe {
+
+AST_XXport::AST_XXport(AstOpt *o, unsigned f) {
+  mAstOpt = o;
+  mASTHandler = o->GetASTHandler();
+  mFlags = f;
+}
+
+unsigned AST_XXport::GetModuleNum() {
+  return mASTHandler->GetSize();
+}
+
+void AST_XXport::BuildModuleOrder() {
+  // setup module stridx
+  SetModuleStrIdx();
+
+  // collect dependent info
+  CollectXXportNodes();
+
+  // collect dependent info
+  AddHandler();
+
+  // sort handlers with dependency
+  SortHandler();
+}
+
+void AST_XXport::SetModuleStrIdx() {
+  for (int i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+
+    // setup module node stridx with module file name
+    unsigned stridx = gStringPool.GetStrIdx(module->GetFilename());
+    module->SetStrIdx(stridx);
+    mStrIdx2HandlerIdxMap[stridx] = i;
+  }
+}
+
+TreeNode *AST_XXport::FindExportedDecl(unsigned hidx, unsigned stridx) {
+  for (auto nid : mExportedDeclIds[hidx]) {
+    TreeNode *node = mAstOpt->GetNodeFromNodeId(nid);
+    if (node->GetStrIdx() == stridx) {
+      return node;
+    }
+  }
+  return NULL;
+}
+
+void AST_XXport::CollectXXportNodes() {
+  for (int i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+
+    XXportBasicVisitor visitor(this, handler, i, mFlags);
+    visitor.Visit(module);
+  }
+}
+
+void AST_XXport::AddHandler() {
+  for (unsigned hidx = 0; hidx < GetModuleNum(); hidx++) {
+    for (auto it : mImportNodeSets[hidx]) {
+      ImportNode *node = it;
+      UpdateDependency(hidx, node);
+    }
+    for (auto it : mExportNodeSets[hidx]) {
+      ExportNode *node = it;
+      UpdateDependency(hidx, node);
+    }
+  }
+}
+
+void AST_XXport::SortHandler() {
+  for (int i = 0; i < GetModuleNum(); i++) {
+    if (mHandlersIdxInOrder.size() == 0) {
+      mHandlersIdxInOrder.push_back(i);
+      continue;
+    }
+
+    bool added = false;
+    std::list<unsigned>::iterator it = mHandlersIdxInOrder.begin();
+    for (; it != mHandlersIdxInOrder.end(); it++) {
+      unsigned idx = *it;
+      // check if handler idx has dependency on i
+      if (mHandlerIdx2DependentHandlerIdxMap[idx].find(i) != mHandlerIdx2DependentHandlerIdxMap[i].end()) {
+        mHandlersIdxInOrder.insert(it, i);
+        added = true;
+        break;
+      }
+    }
+
+    if (!added) {
+      mHandlersIdxInOrder.push_back(i);
+    }
+  }
+
+  // copy result to AstOpt
+  std::list<unsigned>::iterator it = mHandlersIdxInOrder.begin();
+  for (; it != mHandlersIdxInOrder.end(); it++) {
+    unsigned idx = *it;
+    Module_Handler *h = mASTHandler->GetModuleHandler(idx);
+    mAstOpt->AddModuleHandler(h);
+  }
+
+  if (mFlags & FLG_trace_2) {
+    std::cout << "============== Module Order ==============" << std::endl;
+    for (auto hidx: mHandlersIdxInOrder) {
+      Module_Handler *handler = mASTHandler->GetModuleHandler(hidx);
+      ModuleNode *module = handler->GetASTModule();
+      std::cout << "module : " << gStringPool.GetStringFromStrIdx(module->GetStrIdx()) << std::endl;
+      for (auto nid: mExportedDeclIds[hidx]) {
+        TreeNode * node = mAstOpt->GetNodeFromNodeId(nid);
+        std::cout << " export : " << gStringPool.GetStringFromStrIdx(node->GetStrIdx()) << " " << nid << std::endl;
+      }
+    }
+  }
+}
+
+unsigned AST_XXport::GetHandleIdxFromStrIdx(unsigned stridx) {
+  if (mStrIdx2HandlerIdxMap.find(stridx) != mStrIdx2HandlerIdxMap.end()) {
+    return mStrIdx2HandlerIdxMap[stridx];
+  }
+  return FLG_no_imported ? 0 : DEFAULTVALUE;
+}
+
+void AST_XXport::CollectXXportInfo(unsigned hidx) {
+  CollectImportInfo(hidx);
+  CollectExportInfo(hidx);
+}
+
+// check if node is identifier with name "default"
+static bool IsDefault(TreeNode *node) {
+  return node->GetStrIdx() == gStringPool.GetStrIdx("default");
+}
+
+void AST_XXport::CollectImportInfo(unsigned hidx) {
+  Module_Handler *handler = mASTHandler->GetModuleHandler(hidx);
+  ModuleNode *module = handler->GetASTModule();
+
+  for (auto it : mImportNodeSets[hidx]) {
+    ImportNode *node = it;
+    TreeNode *target = GetTarget(node);
+    unsigned stridx = (target && target->GetStrIdx()) ? target->GetStrIdx() : module->GetStrIdx();
+    XXportInfo *info = new XXportInfo(stridx, node->GetNodeId());;
+
+    unsigned targethidx = DEFAULTVALUE;;
+    Module_Handler *targethandler = NULL;
+    ModuleNode *targetmodule = NULL;
+
+    if (target) {
+      targethidx = GetHandleIdxFromStrIdx(target->GetStrIdx());
+      targethandler = mASTHandler->GetModuleHandler(targethidx);
+      targetmodule = targethandler->GetASTModule();
+    }
+
+    for (unsigned i = 0; i < node->GetPairsNum(); i++) {
+      XXportAsPairNode *p = node->GetPair(i);
+      TreeNode *bfnode = p->GetBefore();
+      TreeNode *afnode = p->GetAfter();
+      MASSERT(bfnode && "before node NULL for default");
+
+      // import * as MM from "./M";
+      // bfnode represents a module
+      if (p->IsEverything()) {
+        info->SetEverything();
+
+        MASSERT(target && "everything export no target");
+        SetIdStrIdx2ModuleStrIdx(bfnode->GetStrIdx(), target->GetStrIdx());
+
+        bfnode->SetTypeId(TY_Module);
+        bfnode->SetTypeIdx(targetmodule->GetTypeIdx());
+
+        std::pair<unsigned, unsigned> pnid(bfnode->GetNodeId(), 0);
+        info->mNodeIdPairs.insert(pnid);
+      } else {
+        // reformat default import
+        if (!p->IsDefault()) {
+          if (IsDefault(bfnode) ) {
+            p->SetIsDefault(true);
+            p->SetBefore(afnode);
+            p->SetAfter(NULL);
+          }
+        }
+
+        bfnode = p->GetBefore();
+        afnode = p->GetAfter();
+        if (p->IsDefault()) {
+          TreeNode *exported = GetExportedDefault(targetmodule->GetStrIdx());
+          if (exported) {
+            std::pair<unsigned, unsigned> pnid(exported->GetNodeId(), bfnode->GetNodeId());
+            info->mNodeIdPairs.insert(pnid);
+            TypeId tid = exported->GetTypeId();
+            bfnode->SetTypeId(tid);
+            unsigned tidx = exported->GetTypeIdx();
+            bfnode->SetTypeIdx(tidx);
+          } else {
+            NOTYETIMPL("failed to find the exported - default");
+          }
+        } else if (afnode) {
+          // import bfnode as afnode
+          TreeNode *exported = FindExportedDecl(targethidx, bfnode->GetStrIdx());
+          if (!exported) {
+            NOTYETIMPL("need to extract exported - bfnode M.x");
+            exported = bfnode;
+          }
+          std::pair<unsigned, unsigned> pnid(exported->GetNodeId(), afnode->GetNodeId());
+          info->mNodeIdPairs.insert(pnid);
+          TypeId tid = exported->GetTypeId();
+          unsigned tidx = exported->GetTypeIdx();
+          bfnode->SetTypeId(tid);
+          bfnode->SetTypeIdx(tidx);
+          afnode->SetTypeId(tid);
+          afnode->SetTypeIdx(tidx);
+        } else if (bfnode) {
+          // import bfnode
+          TreeNode *exported = FindExportedDecl(targethidx, bfnode->GetStrIdx());
+          if (!exported) {
+            NOTYETIMPL("need to extract exported - bfnode M.x");
+            exported = bfnode;
+          }
+          std::pair<unsigned, unsigned> pnid(exported->GetNodeId(), bfnode->GetNodeId());
+          info->mNodeIdPairs.insert(pnid);
+          TypeId tid = exported->GetTypeId();
+          unsigned tidx = exported->GetTypeIdx();
+          bfnode->SetTypeId(tid);
+          bfnode->SetTypeIdx(tidx);
+        } else {
+          NOTYETIMPL("failed to find the exported");
+        }
+      }
+      // add afnode, bfnode as a decl
+      if (afnode) {
+        AddImportedDeclIds(handler->GetHidx(), afnode->GetNodeId());
+        handler->AddNodeId2DeclMap(afnode->GetNodeId(), afnode);
+      }
+      AddImportedDeclIds(handler->GetHidx(), bfnode->GetNodeId());
+      handler->AddNodeId2DeclMap(bfnode->GetNodeId(), bfnode);
+    }
+
+    mImports[hidx].insert(info);
+  }
+}
+
+TreeNode *AST_XXport::GetIdentifier(TreeNode *node) {
+  switch (node->GetKind()) {
+    case NK_Decl: {
+      DeclNode *decl = static_cast<DeclNode *>(node);
+      node = GetIdentifier(decl->GetVar());
+      break;
+    }
+    case NK_Identifier:
+      break;
+    case NK_TypeAlias: {
+      TypeAliasNode *ta = static_cast<TypeAliasNode *>(node);
+      node = GetIdentifier(ta->GetId());
+      break;
+    }
+    case NK_UserType: {
+      UserTypeNode *ut = static_cast<UserTypeNode *>(node);
+      node = GetIdentifier(ut->GetId());
+      break;
+    }
+    default:
+      NOTYETIMPL("need to extract identifier");
+      break;
+  }
+  return node;
+}
+
+void AST_XXport::CollectExportInfo(unsigned hidx) {
+  Module_Handler *handler = mASTHandler->GetModuleHandler(hidx);
+  ModuleNode *module = handler->GetASTModule();
+
+  for (auto it : mExportNodeSets[hidx]) {
+    ExportNode *node = it;
+    TreeNode *target = GetTarget(node);
+    unsigned stridx = (target && target->GetStrIdx()) ? target->GetStrIdx() : module->GetStrIdx();
+    XXportInfo *info = new XXportInfo(stridx, node->GetNodeId());;
+
+    unsigned targethidx = DEFAULTVALUE;
+    Module_Handler *targethandler = NULL;
+    ModuleNode *targetmodule = NULL;
+
+    if (target) {
+      targethidx = GetHandleIdxFromStrIdx(target->GetStrIdx());
+      targethandler = mASTHandler->GetModuleHandler(targethidx);
+      targetmodule = targethandler->GetASTModule();
+    }
+
+    for (unsigned i = 0; i < node->GetPairsNum(); i++) {
+      XXportAsPairNode *p = node->GetPair(i);
+      TreeNode *bfnode = p->GetBefore();
+      TreeNode *afnode = p->GetAfter();
+
+      // export import a = M.a
+      if (bfnode && bfnode->IsImport()) {
+        ImportNode *imp = static_cast<ImportNode *>(bfnode);
+        for (unsigned j = 0; j < imp->GetPairsNum(); j++) {
+          XXportAsPairNode *q = imp->GetPair(i);
+          TreeNode *bf = q->GetBefore();
+          TreeNode *af = q->GetAfter();
+          std::pair<unsigned, unsigned> pnid(af->GetNodeId(), bf->GetNodeId());
+          info->mNodeIdPairs.insert(pnid);
+        }
+        continue;
+      }
+
+      if (p->IsEverything()) {
+        info->SetEverything();
+        if (bfnode) {
+          // export * as MM from "./M";
+          // bfnode represents a module
+          MASSERT(target && "everything export no target");
+          SetIdStrIdx2ModuleStrIdx(bfnode->GetStrIdx(), target->GetStrIdx());
+
+          bfnode->SetTypeId(TY_Module);
+          bfnode->SetTypeIdx(targetmodule->GetTypeIdx());
+          AddExportedDeclIds(hidx, bfnode->GetNodeId());
+        } else {
+          // export * from "./M"
+          for (auto k : mExportedDeclIds[targethidx]) {
+            AddExportedDeclIds(hidx, k);
+          }
+          continue;
+        }
+      }
+
+      // reformat default export
+      if (p->IsDefault()) {
+        p->SetIsRef(false);
+      } else if (afnode && IsDefault(afnode)) {
+        p->SetIsDefault(true);
+        p->SetBefore(bfnode);
+        p->SetAfter(NULL);
+      }
+
+      afnode = p->GetAfter();
+      bfnode = p->GetBefore();
+      if (!bfnode->IsIdentifier()) {
+        bfnode = GetIdentifier(bfnode);
+      }
+
+      unsigned exportednid = (afnode ? afnode->GetNodeId(): bfnode->GetNodeId());
+      if (p->IsDefault()) {
+        info->mDefaultNodeId = exportednid;
+      } else if (mExportNodeSets[hidx].size() == 1 && node->GetPairsNum() == 1) {
+        info->mDefaultNodeId = bfnode->GetNodeId();
+        std::pair<unsigned, unsigned> pnid(bfnode->GetNodeId(), exportednid);
+        info->mNodeIdPairs.insert(pnid);
+      } else {
+        std::pair<unsigned, unsigned> pnid(bfnode->GetNodeId(), exportednid);
+        info->mNodeIdPairs.insert(pnid);
+      }
+      AddExportedDeclIds(hidx, exportednid);
+    }
+
+    if (info->mDefaultNodeId || info->mNodeIdPairs.size()) {
+      mExports[hidx].insert(info);
+    } else {
+      delete info;
+    }
+  }
+}
+
+TreeNode *AST_XXport::GetTarget(TreeNode *node) {
+  TreeNode *tree = NULL;
+  if (node->IsImport()) {
+    tree = static_cast<ImportNode *>(node)->GetTarget();
+  } else if (node->IsExport()) {
+    tree = static_cast<ExportNode *>(node)->GetTarget();
+  }
+  return tree;
+}
+
+// borrowed from ast2cpp
+std::string AST_XXport::GetTargetFilename(unsigned hidx, TreeNode *node) {
+  std::string filename;
+  if (node && node->IsLiteral()) {
+    LiteralNode *lit = static_cast<LiteralNode *>(node);
+    LitData data = lit->GetData();
+    filename = AstDump::GetEnumLitData(data);
+    filename += ".ts"s;
+    if(filename.front() != '/') {
+      Module_Handler *handler = mASTHandler->GetModuleHandler(hidx);
+      ModuleNode *module = handler->GetASTModule();
+      std::filesystem::path p = module->GetFilename();
+      try {
+        p = std::filesystem::canonical(p.parent_path() / filename);
+        filename = p.string();
+      }
+      catch(std::filesystem::filesystem_error const& ex) {
+        // Ignore std::filesystem::filesystem_error exception
+        // keep filename without converting it to a cannonical path
+      }
+    }
+  }
+  return filename;
+}
+
+// set up import/export node stridx with target module file name stridx
+void AST_XXport::UpdateDependency(unsigned hidx, TreeNode *node) {
+  TreeNode *target = GetTarget(node);
+  if (target) {
+    std::string name = GetTargetFilename(hidx, target);
+
+    // store name's string index in node
+    unsigned stridx = gStringPool.GetStrIdx(name);
+    node->SetStrIdx(stridx);
+    target->SetStrIdx(stridx);
+
+    // update handler dependency map
+    unsigned dep = GetHandleIdxFromStrIdx(stridx);
+    mHandlerIdx2DependentHandlerIdxMap[hidx].insert(dep);
+
+    if (node->IsImport()) {
+      Module_Handler *handler = mASTHandler->GetModuleHandler(dep);
+      ModuleNode *module = handler->GetASTModule();
+
+      node->SetTypeId(module->GetTypeId());
+      node->SetTypeIdx(module->GetTypeIdx());
+    }
+  }
+}
+
+unsigned AST_XXport::ExtractTargetStrIdx(TreeNode *node) {
+  unsigned stridx = 0;
+  if (node->IsField()) {
+    FieldNode *fld = static_cast<FieldNode *>(node);
+    TreeNode *upper = fld->GetUpper();
+    stridx = GetModuleStrIdxFromIdStrIdx(upper->GetStrIdx());
+    if (stridx) {
+      unsigned hidx = GetHandleIdxFromStrIdx(stridx);
+      Module_Handler *handler = mASTHandler->GetModuleHandler(hidx);
+      ModuleNode *module = handler->GetASTModule();
+      upper->SetTypeId(TY_Module);
+      upper->SetTypeIdx(module->GetTypeIdx());
+    }
+  }
+  return stridx;
+}
+
+// hstridx is the string index of handler/module name with full path
+TreeNode *AST_XXport::GetExportedDefault(unsigned hstridx) {
+  if (mStrIdx2HandlerIdxMap.find(hstridx) != mStrIdx2HandlerIdxMap.end()) {
+    unsigned hidx = GetHandleIdxFromStrIdx(hstridx);
+    for (auto it : mExports[hidx]) {
+      if (it->mDefaultNodeId) {
+        return mAstOpt->GetNodeFromNodeId(it->mDefaultNodeId);
+      }
+    }
+  }
+  return NULL;
+}
+
+// hidx is the index of handler, string is the string index of identifier
+TreeNode *AST_XXport::GetExportedNamedNode(unsigned hidx, unsigned stridx) {
+  for (auto it : mExports[hidx]) {
+    for (auto it1 : it->mNodeIdPairs) {
+      unsigned nid = it1.first;
+      TreeNode *node = mAstOpt->GetNodeFromNodeId(nid);
+      if (node->GetStrIdx() == stridx ) {
+        return node;
+      }
+    }
+  }
+  return NULL;
+}
+
+// hidx is the index of handler, string is the string index of identifier
+TreeNode *AST_XXport::GetExportedNodeFromImportedNode(unsigned hidx, unsigned nid) {
+  TreeNode *node = mAstOpt->GetNodeFromNodeId(nid);
+
+  for (auto it : mImports[hidx]) {
+    if (it->mDefaultNodeId == nid) {
+      node = GetExportedDefault(it->mModuleStrIdx);
+      return node;
+    }
+    for (auto it1 : it->mNodeIdPairs) {
+      unsigned nid2 = it1.second;
+      if (nid2 == nid) {
+        unsigned nid1 = it1.first;
+        node = mAstOpt->GetNodeFromNodeId(nid1);
+        return node;
+      }
+    }
+  }
+  return node;
+}
+
+ImportNode *XXportBasicVisitor::VisitImportNode(ImportNode *node) {
+  (void) AstVisitor::VisitImportNode(node);
+  mASTXXport->mImportNodeSets[mHandlerIdx].push_back(node);
+
+  TreeNode *target = mASTXXport->GetTarget(node);
+  if (!target) {
+    // extract target info for
+    // import Bar = require("./Foo");
+    for (unsigned i = 0; i < node->GetPairsNum(); i++) {
+      XXportAsPairNode *p = node->GetPair(i);
+      TreeNode *bfnode = p->GetBefore();
+      if (bfnode && bfnode->IsLiteral()) {
+        LiteralNode *lit = static_cast<LiteralNode *>(bfnode);
+        LitId id = lit->GetData().mType;
+        if (id == LT_StringLiteral) {
+          node->SetTarget(bfnode);
+          p->SetBefore(p->GetAfter());
+          p->SetAfter(NULL);
+          p->SetIsDefault(true);
+        }
+      }
+    }
+  }
+  return node;
+}
+
+ExportNode *XXportBasicVisitor::VisitExportNode(ExportNode *node) {
+  (void) AstVisitor::VisitExportNode(node);
+  mASTXXport->mExportNodeSets[mHandlerIdx].push_back(node);
+  return node;
+}
+
+}
diff --git a/src/MapleFE/astopt/src/astopt.cpp b/src/MapleFE/astopt/src/astopt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bd2ab47d290cfe4fc2577c821046c192246c9ba6
--- /dev/null
+++ b/src/MapleFE/astopt/src/astopt.cpp
@@ -0,0 +1,119 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include "astopt.h"
+#include "typetable.h"
+#include "ast_handler.h"
+#include "ast_xxport.h"
+#include "gen_astgraph.h"
+#include "gen_aststore.h"
+#include "gen_astload.h"
+
+namespace maplefe {
+
+class ImportedFiles;
+
+AstOpt::AstOpt(AST_Handler *h, unsigned f) {
+  mASTHandler = h;
+  h->SetAstOpt(this);
+  mASTXXport = new AST_XXport(this, f);
+  mFlags = f;
+}
+
+unsigned AstOpt::GetModuleNum() {
+  return mASTHandler->GetSize();
+}
+
+// starting point of AST
+void AstOpt::ProcessAST(unsigned flags) {
+  // loop through module handlers
+  for (int i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+
+    mFlags = flags;
+    if (mFlags & FLG_trace_3) {
+      std::cout << "============= in ProcessAST ===========" << std::endl;
+      std::cout << "srcLang : " << module->GetSrcLangString() << std::endl;
+
+      for(unsigned i = 0; i < module->GetTreesNum(); i++) {
+        TreeNode *tnode = module->GetTree(i);
+        tnode->Dump(0);
+        std::cout << std::endl;
+      }
+    }
+  }
+
+  // build dependency of modules
+  PreprocessModules();
+
+  for (auto handler: mHandlersInOrder) {
+    // basic analysis
+    handler->BasicAnalysis();
+
+    // build CFG
+    handler->BuildCFG();
+
+    // control flow analysis
+    handler->ControlFlowAnalysis();
+
+    // type inference
+    handler->TypeInference();
+
+    // data flow analysis
+    handler->DataFlowAnalysis();
+  }
+
+  for (auto handler: mHandlersInOrder) {
+    ModuleNode *module = handler->GetASTModule();
+
+    AstStore saveAst(module);
+    saveAst.StoreInAstBuf();
+  }
+
+  return;
+}
+
+void AstOpt::PreprocessModules() {
+  // initialize gTypeTable with builtin types
+  gTypeTable.AddPrimAndBuiltinTypes();
+
+  // collect language keywords
+#undef LANGKEYWORD
+#define LANGKEYWORD(K) mLangKeywords.insert(gStringPool.GetStrIdx(#K));
+#include "lang_keywords.def"
+
+  // scan through modules to setup mNodeId2NodeMap
+  BuildNodeIdToNodeVisitor visitor(this, mFlags);
+
+  for (int i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    // fill handler index
+    handler->SetHidx(i);
+
+    ModuleNode *module = handler->GetASTModule();
+    // add module as type for import/export purpose
+    module->SetTypeId(TY_Module);
+    gTypeTable.AddType(module);
+
+    visitor.SetHandler(handler);
+    visitor.Visit(module);
+  }
+
+  // list modules according to dependency
+  mASTXXport->BuildModuleOrder();
+}
+
+}
diff --git a/src/MapleFE/java/alt_tokens.spec b/src/MapleFE/autogen/alt_tokens.spec
similarity index 95%
rename from src/MapleFE/java/alt_tokens.spec
rename to src/MapleFE/autogen/alt_tokens.spec
index 831eb7a829637f416ba53a862d6cf60a54dd5bc9..26dc069662815249b01beb67ee04558a1d88bc48 100644
--- a/src/MapleFE/java/alt_tokens.spec
+++ b/src/MapleFE/autogen/alt_tokens.spec
@@ -17,6 +17,8 @@
 // This file will be included in token_gen.cpp.
 // This file defines the alternative tokens of some special tokens. Please refer
 // shared/include/token.h for the definition of alternative tokens.
+//
+// Right now this is language independent
 
   {">>", 2, ">"},
   {">>>", 3, ">"}
diff --git a/src/MapleFE/autogen/include/auto_gen.h b/src/MapleFE/autogen/include/auto_gen.h
index fc5269ec5ad24f74ddb66f6fcfb1db24ea02dd50..40da81fb2e91567b32fc3cf14c1aa1015eec459c 100644
--- a/src/MapleFE/autogen/include/auto_gen.h
+++ b/src/MapleFE/autogen/include/auto_gen.h
@@ -25,10 +25,8 @@
 #include "iden_gen.h"
 #include "literal_gen.h"
 #include "type_gen.h"
-#include "block_gen.h"
 #include "separator_gen.h"
 #include "operator_gen.h"
-#include "expr_gen.h"
 #include "stmt_gen.h"
 #include "keyword_gen.h"
 #include "attr_gen.h"
@@ -43,21 +41,23 @@ private:
   LiteralGen   *mLitGen;
   TypeGen      *mTypeGen;
   AttrGen      *mAttrGen;
-  BlockGen     *mBlockGen;
   SeparatorGen *mSeparatorGen;
   OperatorGen  *mOperatorGen;
   KeywordGen   *mKeywordGen;
-  ExprGen      *mExprGen;
   StmtGen      *mStmtGen;
   TokenGen     *mTokenGen;
 
   std::vector<BaseGen*> mGenArray;
   SPECParser   *mParser;
 
+  std::string   mLang;   // the language(i.e. directory)
+
 public:
   AutoGen(SPECParser *p) : mParser(p) {}
   ~AutoGen();
 
+  void SetLang(std::string s) {mLang = s;}
+
   void Init();
   void Run();
   void BackPatch();
diff --git a/src/MapleFE/autogen/include/base_gen.h b/src/MapleFE/autogen/include/base_gen.h
index 07c08121cf0da65352cb3aa6dac3d1a659c1e37f..fa8a76229fb18f00d118a955cc1836c72a657ad4 100644
--- a/src/MapleFE/autogen/include/base_gen.h
+++ b/src/MapleFE/autogen/include/base_gen.h
@@ -50,7 +50,7 @@ class SPECParser;;
 // the current type of element being read. This helps to read ')' and '+'.
 //
 // Possibly new syntax in the future also need this help.
-typedef enum {
+typedef enum ST_status {
   ST_Set,         // in ( , , )
   ST_Concatenate, // in E + E + E
   ST_Null
@@ -67,7 +67,7 @@ public:
   FormattedBuffer mRuleTableCpp;
   FormattedBuffer mRuleTableHeader;
 
-  std::string mSpecFile;
+  std::string   mSpecFile;
   FileWriter    mHeaderFile;
   FileWriter    mCppFile;
   StringPool   *mStringPool;
diff --git a/src/MapleFE/autogen/include/base_struct.h b/src/MapleFE/autogen/include/base_struct.h
index 957810021afa54fdd7b561281947651e4cb38644..63e49b4444d3247ce8bcc7087a63338aae98ed74 100644
--- a/src/MapleFE/autogen/include/base_struct.h
+++ b/src/MapleFE/autogen/include/base_struct.h
@@ -37,7 +37,7 @@ class StringPool;
 // 2-tuple or 3 tuple. The data in each StructElem could be number, string,
 // string literal (those quoted with ").
 //
-// Each type of .spec has its own definition of STRUCT and so its data in 
+// Each type of .spec has its own definition of STRUCT and so its data in
 // StructElem. So the parsing of a StructElem is left to each .spec parser.
 // But we do provide some common functions of parsing certain StructElem.
 //
@@ -114,7 +114,7 @@ public:
   void SetName(const char *s) { mName = s; }
   bool Empty() {return mStructElems.size() == 0;}
   void Dump();
-  void Sort(unsigned i);  // sort by the length of i-th element which is astring 
+  void Sort(unsigned i);  // sort by the length of i-th element which is astring
 };
 
 }
diff --git a/src/MapleFE/autogen/include/buffer2write.h b/src/MapleFE/autogen/include/buffer2write.h
index c954eda99ae061ed0b48b555877845cf42d23ff2..dcf0cf2b16686159477cabc6b9abbffb2484c32f 100644
--- a/src/MapleFE/autogen/include/buffer2write.h
+++ b/src/MapleFE/autogen/include/buffer2write.h
@@ -53,12 +53,12 @@ class BaseGen;
 // default construction of buffers.                                     //
 //////////////////////////////////////////////////////////////////////////
 
-typedef enum {
+typedef enum WriteStatus {
   WR_GOOD,
   WR_OVERSIZE
 }WriteStatus;
 
-typedef enum {
+typedef enum SimpleBufferType {
   SB_Line,
   SB_Rect
 }SimpleBufferType;
@@ -75,7 +75,7 @@ public:
 
 public:
   SimpleBuffer(unsigned ind) : mIndentation(ind) {}
-  ~SimpleBuffer() {}
+  virtual ~SimpleBuffer() = default;
 
   virtual WriteStatus AddChar(const char) = 0;
   virtual WriteStatus AddString(const char*) = 0;
@@ -86,7 +86,7 @@ public:
 
   virtual bool CurrentLineEmpty() = 0;
 };
- 
+
 // A single line buffer, over MAX_LINE_LIMIT. Theoritically the LineBuffer
 // can extend to unlimited length.
 class LineBuffer : public SimpleBuffer {
@@ -127,7 +127,7 @@ class RectBuffer : public SimpleBuffer {
 public:
   unsigned mUsed;  // a LINES_PER_BLOCK bitmap telling which lines are used.
   char     mData[MAX_LINE_LIMIT * LINES_PER_BLOCK];
-  char    *mCurrLine; 
+  char    *mCurrLine;
   unsigned mCurrLineSize;  // how many char-s in the line
 
 public:
@@ -161,7 +161,7 @@ public:
   union {
     SimpleBuffer    *mSimple;
     FormattedBuffer *mFormatted;
-  }mData; 
+  }mData;
   bool               mIsSimple;
 
 public:
@@ -194,10 +194,10 @@ public:
 /////////////////////////////////////////////////////////////////////////////
 // [FormattedBuffer]
 //
-// A formatted buffer is composed of a set of SimpleBuffer or nested 
+// A formatted buffer is composed of a set of SimpleBuffer or nested
 // formatted buffer. Its goal is to provide interface for buffer users.
 // The inside details of the OneBuffer is protected.
-// 
+//
 // The nested FormattedBuffer is never modified by the parent FormattedBuffer.
 // So the children should be fixed before added into the parent.
 
@@ -216,7 +216,7 @@ public:
   FormattedBuffer(unsigned ind = 0, bool iscomment = false);
   ~FormattedBuffer();
 
-public: 
+public:
   void  AddNestedBuffer(FormattedBuffer *);
 
   char* NewLine();
@@ -312,7 +312,7 @@ public:
 //                         FunctionBuffer                               //
 // A function has three buffers.                                        //
 //   1) Declaration in .h file                                          //
-//   2) Header in .cpp file                                             // 
+//   2) Header in .cpp file                                             //
 //   3) Body in .cpp file                                               //
 // Here is an example:                                                  //
 //     void foo (int a)             <-- Header                          //
@@ -332,7 +332,7 @@ public:
 
   void AddReturnType(const char*);
   void AddFunctionName(const char*);
-  void AddParameter(const char* type, const char *name, bool end = false); 
+  void AddParameter(const char* type, const char *name, bool end = false);
   ScopedBuffer* GetBody() { return &mBody; }
 };
 
diff --git a/src/MapleFE/autogen/include/exprbuffer.h b/src/MapleFE/autogen/include/exprbuffer.h
index 6fd37327fac5701ac0c9efe4869d7e84a983b036..da0b7133769f3e62486563c43c6bb10a0a612f32 100644
--- a/src/MapleFE/autogen/include/exprbuffer.h
+++ b/src/MapleFE/autogen/include/exprbuffer.h
@@ -99,8 +99,8 @@ public:
   // the following functions are used for un-determined number of children.
   void AllocChildren(unsigned i, ExprBuffer *buf);
   ExprNode* GetChild(unsigned index);
-}; 
-  
+};
+
 class ExprBuffer {
 private:
   char     *mData;
@@ -126,7 +126,7 @@ public:
 
 public:
   ExprBuffer();
-  ~ExprBuffer(); 
+  ~ExprBuffer();
 
   // write the expr to the buffer, mData, in text format
   void Write2Buffer();
diff --git a/src/MapleFE/autogen/include/operator_gen.h b/src/MapleFE/autogen/include/operator_gen.h
index 3d3e902359db79540ad00c1c62e172812deb3811..943106cfa475ab754641a0bb972aea16611fa0ec 100644
--- a/src/MapleFE/autogen/include/operator_gen.h
+++ b/src/MapleFE/autogen/include/operator_gen.h
@@ -14,7 +14,7 @@
 */
 ////////////////////////////////////////////////////////////////////////
 //                      Operator Generation
-// The output of this Operator Generation is a table in gen_operator.cpp 
+// The output of this Operator Generation is a table in gen_operator.cpp
 //
 //   OprTableEntry OprTable[OPR_Null] = {
 //     {"xxx", OPR_Xxx},
@@ -37,7 +37,7 @@ namespace maplefe {
 // For each operator, it has three parts involved in the generation.
 //   1. OprId: Used inside autogen, connection between LANGUAGE and
 //             shared/supported.h files
-//   2. Name:  Name of OPR ID, to be generated in gen_operator.cpp 
+//   2. Name:  Name of OPR ID, to be generated in gen_operator.cpp
 //   4. Text:  LANGUAGE syntax text, to be in gen_operator.cpp
 
 // The SUPPORTED operator and their name.
diff --git a/src/MapleFE/autogen/include/rule.h b/src/MapleFE/autogen/include/rule.h
index 607d8c9369aa116bbc5ec45d62cb08b72962ea73..5c23c5ee007c4da4f34ee3fee521d30941e9ecf7 100644
--- a/src/MapleFE/autogen/include/rule.h
+++ b/src/MapleFE/autogen/include/rule.h
@@ -30,15 +30,16 @@ namespace maplefe {
 class Rule;
 class StructData;
 
-typedef enum {
+typedef enum RuleOp {
   RO_Oneof,      // one of (...)
   RO_Zeroormore, // zero or more of (...)
   RO_Zeroorone,  // zero or one ( ... )
   RO_Concatenate,// Elem + Elem + Elem
+  RO_ASI,        // Typescript/Javascript semicolon checking
   RO_Null
 } RuleOp;
 
-typedef enum {
+typedef enum ElemType {
   ET_Char,       // It's a literal elements, char, 'c'.
   ET_String,     // It's a literal elements, string "abc".
   ET_Rule,       // It's rule
diff --git a/src/MapleFE/autogen/include/rule_gen.h b/src/MapleFE/autogen/include/rule_gen.h
index da0cd43cdb485f470b88582dce370eaa3609709b..c68109a69bfcc881aee807046389d0a426b5310c 100644
--- a/src/MapleFE/autogen/include/rule_gen.h
+++ b/src/MapleFE/autogen/include/rule_gen.h
@@ -66,7 +66,7 @@ public:
 
   void PatchTokenOnElem(RuleElem*);
   void PatchToken();
-  void Generate(); 
+  void Generate();
 };
 
 }
diff --git a/src/MapleFE/autogen/include/separator_gen.h b/src/MapleFE/autogen/include/separator_gen.h
index 31597f55668e43e87462935c64fd624223dde7bc..e5b4e3b77a525fe97550e3ce02cafbbf3e3907d3 100644
--- a/src/MapleFE/autogen/include/separator_gen.h
+++ b/src/MapleFE/autogen/include/separator_gen.h
@@ -14,7 +14,7 @@
 */
 ////////////////////////////////////////////////////////////////////////
 //                      Separator Generation
-// The output of this Separator Generation is a table in gen_separator.cpp 
+// The output of this Separator Generation is a table in gen_separator.cpp
 //
 //   SepTableEntry SepTable[SEP_Null] = {
 //     {"xxx", SEP_Xxx},
@@ -45,7 +45,7 @@ namespace maplefe {
 // For each separator, it has three parts involved in the generation.
 //   1. SepId:   Used inside autogen, connection between LANGUAGE and SUPPORTED
 //               .spec files
-//   2. Name:    Name of SEP_ID, to be generated in gen_separator.cpp 
+//   2. Name:    Name of SEP_ID, to be generated in gen_separator.cpp
 //   4. Keyword: LANGUAGE syntax text, to be in gen_separator.cpp
 
 // The SUPPORTED separator and their name.
diff --git a/src/MapleFE/autogen/include/spec_keywords.h b/src/MapleFE/autogen/include/spec_keywords.h
index 9ede40d1238ab3899900a16802a5a9fa522a5d27..8d944cf257d7e764a79f19eb0b6d0fec9d9dc634 100644
--- a/src/MapleFE/autogen/include/spec_keywords.h
+++ b/src/MapleFE/autogen/include/spec_keywords.h
@@ -16,6 +16,7 @@ KEYWORD(rule, Rule)
 KEYWORD(ONEOF, Oneof)
 KEYWORD(ZEROORONE, Zeroorone)
 KEYWORD(ZEROORMORE, Zeroormore)
+KEYWORD(ASI, ASI)
 KEYWORD(STRUCT, Struct)
 KEYWORD(func, Func)
 KEYWORD(attr, Attr)
diff --git a/src/MapleFE/autogen/include/spec_lexer.h b/src/MapleFE/autogen/include/spec_lexer.h
index cd5d2fbdefedb9f6e5df976546704304c47ffa67..db32e526eb897155b06cb3d7c317a39612aa5daf 100644
--- a/src/MapleFE/autogen/include/spec_lexer.h
+++ b/src/MapleFE/autogen/include/spec_lexer.h
@@ -107,7 +107,7 @@ class SPECLexer {
     return _thekind;
   }
 
-  char *GetLine() const { return line; } 
+  char *GetLine() const { return line; }
   int GetLineNum() const { return _linenum; }
   int GetCuridx() const { return curidx; }
   const std::string &GetTheName() const { return thename; }
diff --git a/src/MapleFE/autogen/include/spec_parser.h b/src/MapleFE/autogen/include/spec_parser.h
index cc2ac3ebc668874d1205f9f135f5bee4aacb6ad7..af1754b1311d87c0dea4b954adb8f1d094b9b1dc 100644
--- a/src/MapleFE/autogen/include/spec_parser.h
+++ b/src/MapleFE/autogen/include/spec_parser.h
@@ -69,7 +69,7 @@ public:
   bool ParseStruct();
   bool ParseStructElements();
   bool ParseElemData(StructElem *elem);
-  
+
   bool ParseType();
 
   bool ParseAttr();
diff --git a/src/MapleFE/autogen/include/spec_tokens.h b/src/MapleFE/autogen/include/spec_tokens.h
index 666e52677eca583ecd50132776a6bfbe24893f23..8d8cb19cfbf3ceab0653be4a6de226e2bcf47e6d 100644
--- a/src/MapleFE/autogen/include/spec_tokens.h
+++ b/src/MapleFE/autogen/include/spec_tokens.h
@@ -14,7 +14,7 @@
 */
 #ifndef SPERC_TOKENS_H
 #define SPERC_TOKENS_H
-typedef enum {
+typedef enum SPECTokenKind {
   SPECTK_Invalid,
   // keywords
   #define KEYWORD(S,T) SPECTK_##T,
diff --git a/src/MapleFE/autogen/reserved.spec b/src/MapleFE/autogen/reserved.spec
index b3bb95f7aaa8715527a8f3e76c4d3b8141018e5d..cd258684dc2ad9b79fe06683a1d021930fe3fa98 100644
--- a/src/MapleFE/autogen/reserved.spec
+++ b/src/MapleFE/autogen/reserved.spec
@@ -22,19 +22,21 @@ rule CHAR  : ONEOF('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','
 # DIGIT refers to the 10 digits
 rule DIGIT : ONEOF('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')
 
-# The ASCII character exclude ", ', and \
-#
-# [NOTE] Becareful of ' over here. It's duplicated in ESCAPE as '\' + '''. There is a reason.
-#        When the lexer read a string "doesn't", which is wrong since Java request ' be escaped but
-#        many code does NOT escape, the string in memory is "doesn't" too. The system Reading function
-#        which is in C doesn't escape '. So I duplicate here to catch this case.
-#
-#        Please see test case java2mpl/literal-string-2.java for example.
-#
-rule ASCII : ONEOF(' ', '!', '#', '$', '%', ''', '&', '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', CHAR, DIGIT)
+# The ASCII character exclude ", ', \, and \n
+rule ASCII : ONEOF(' ', '!', '#', '$', '%', '&', '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', CHAR, DIGIT)
 
 # About the handling of escape character in autogen, xx_gen.cpp/h, and stringutil.cpp
 # please refer to the comments in StringToValue::StringToString() in stringutil.cpp
 rule ESCAPE : ONEOF('\' + 'b', '\' + 't', '\' + 'n', '\' + 'f', '\' + 'r', '\' + '"', '\' + ''', '\' + '\')
 
 rule HEXDIGIT : ONEOF(DIGIT, 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F')
+
+# irregular char like  \n,  \, DEL, etc. will be handled in lexer.cpp if some language allows them in string literal.
+rule IRREGULAR_CHAR : "this_is_for_fake_rule"
+
+# Below are special rules handled in lexer.cpp. Since it'll be in lexer code, it means
+# it's a shared rule of all languages. It has to be in reserved.spec.
+rule UTF8 : "this_is_for_fake_rule"
+rule TemplateLiteral : "this_is_for_fake_rule"
+rule RegularExpression : "this_is_for_fake_rule"
+rule NoLineTerminator : "this_is_for_fake_rule"
diff --git a/src/MapleFE/autogen/src/Makefile b/src/MapleFE/autogen/src/Makefile
index 86927f0b36c18b1eb363aeebd544dea2587d4499..7297ffdb8d3decb0a97a0bb9d936a02390535a3d 100644
--- a/src/MapleFE/autogen/src/Makefile
+++ b/src/MapleFE/autogen/src/Makefile
@@ -1,8 +1,22 @@
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
 include ../../Makefile.in
 
 # create build first
 BUILD=$(BUILDDIR)/autogen
-$(shell $(MKDIR_P) $(BUILD))
+$(shell $(MKDIR_P) $(BUILD) $(BUILDDIR)/$(SRCLANG) $(BUILDDIR)/gen)
 
 SHAREDSRC := token.cpp mempool.cpp stringmap.cpp stringpool.cpp write2file.cpp
 SRC := $(wildcard *.cpp) $(SHAREDSRC)
@@ -14,33 +28,24 @@ LIBOBJS :=$(patsubst $(BUILD)/main.o,,$(OBJS))
 DEPS := $(foreach dep, $(DEP), $(BUILD)/$(dep))
 
 INCLUDES := -I $(MAPLEFE_ROOT)/autogen/include \
-            -I $(MAPLEFE_ROOT)/shared/include \
-            -I $(MAPLEFE_ROOT)/java/include \
-            -I $(MAPLEFE_ROOT)/java
+            -I $(MAPLEFE_ROOT)/autogen \
+            -I $(MAPLEFE_ROOT)/shared/include
+
+SPECS := $(wildcard $(MAPLEFE_ROOT)/$(SRCLANG)/*.spec)
 
 TARGET = autogen
 
 AUTOGENLIB = autogen.a
 
 .PHONY: all
+all: $(BUILD)/$(TARGET)
 
-all: $(TARGET)
-
-$(TARGET) : $(AUTOGENLIB)
+$(BUILD)/$(TARGET) : $(BUILD)/$(AUTOGENLIB)
 	$(LD) -o $(BUILD)/$(TARGET) $(BUILD)/main.o $(BUILD)/$(AUTOGENLIB)
-	@ln -sf $(MAPLEFE_ROOT)/java/identifier.spec $(BUILD)/identifier.spec
-	@ln -sf $(MAPLEFE_ROOT)/java/literal.spec $(BUILD)/literal.spec
-	@ln -sf $(MAPLEFE_ROOT)/java/operator.spec $(BUILD)/operator.spec
-	@ln -sf $(MAPLEFE_ROOT)/java/separator.spec $(BUILD)/separator.spec
-	@ln -sf $(MAPLEFE_ROOT)/java/keyword.spec $(BUILD)/keyword.spec
-	@ln -sf $(MAPLEFE_ROOT)/java/type.spec $(BUILD)/type.spec
-	@ln -sf $(MAPLEFE_ROOT)/java/attr.spec $(BUILD)/attr.spec
-	@ln -sf $(MAPLEFE_ROOT)/java/block.spec $(BUILD)/block.spec
-	@ln -sf $(MAPLEFE_ROOT)/java/expr.spec $(BUILD)/expr.spec
-	@ln -sf $(MAPLEFE_ROOT)/java/stmt.spec $(BUILD)/stmt.spec
-	@ln -sf $(MAPLEFE_ROOT)/autogen/reserved.spec $(BUILD)/reserved.spec
-
-$(AUTOGENLIB) : $(OBJS)
+	(cd $(BUILD); ./$(TARGET) $(SRCLANG))
+	(cd $(MAPLEFE_ROOT); ./scripts/maplefe-autogen.py)
+
+$(BUILD)/$(AUTOGENLIB) : $(OBJS)
 	/usr/bin/ar rcs $(BUILD)/$(AUTOGENLIB) $(LIBOBJS)
 
 -include $(DEPS)
@@ -50,24 +55,15 @@ vpath %.cpp $(MAPLEFE_ROOT)/shared/src
 vpath %.o $(BUILD)
 vpath %.d $(BUILD)
 
-ifeq ($(LANG), java)
-CXXFLAGS := $(CXXFLAGS) -I ../java/
-endif
-
 #Pattern Rules
 $(BUILD)/%.o : %.cpp $(BUILD)/%.d
 	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
 
-$(BUILD)/%.d : %.cpp
+$(BUILD)/%.d : %.cpp $(SPECS)
 	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $< > $@
 	@mv -f $(BUILD)/$*.d $(BUILD)/$*.d.tmp
 	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
 	@rm -f $(BUILD)/$*.d.tmp
 
-
-#.cpp.o:
-#	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $*.cpp -o $(BUILD)/$*.o
-#	$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $*.cpp > $(BUILD)/$*.d
-
 clean:
 	rm -rf $(BUILD)
diff --git a/src/MapleFE/autogen/src/all_supported.cpp b/src/MapleFE/autogen/src/all_supported.cpp
index 66ebbdbf2f11dd1d7544189c7a7143964eb40cb1..5ef17f9564e15a043cb16ddd60c1b3567d6cfcf3 100644
--- a/src/MapleFE/autogen/src/all_supported.cpp
+++ b/src/MapleFE/autogen/src/all_supported.cpp
@@ -22,7 +22,9 @@ namespace maplefe {
 //////////////////////////////////////////////////////////////////////
 
 #undef  TYPE
+#undef  PRIMTYPE
 #define TYPE(T) {#T, TY_##T},
+#define PRIMTYPE(T) {#T, TY_##T},
 TypeMapping TypesSupported[TY_NA] = {
 #include "supported_types.def"
 };
@@ -36,7 +38,9 @@ TypeId FindTypeIdLangIndep(const std::string &s) {
 }
 
 #undef  TYPE
+#undef  PRIMTYPE
 #define TYPE(T) case TY_##T: return #T;
+#define PRIMTYPE(T) case TY_##T: return #T;
 char *GetTypeString(TypeId tid) {
   switch (tid) {
 #include "supported_types.def"
@@ -83,7 +87,7 @@ LiteralSuppStruct LiteralsSupported[LT_NA] = {
 #include "supported_literals.def"
 };
 
-// s : the name 
+// s : the name
 // return the LitId
 LitId FindLiteralId(const std::string &s) {
   for (unsigned u = 0; u < LT_NA; u++) {
diff --git a/src/MapleFE/autogen/src/attr_gen.cpp b/src/MapleFE/autogen/src/attr_gen.cpp
index a2c2cc963f35afa55e0aecac3f5d0c013710fdef..a311fddab876c1337d348ad42880acdfcb2b9b1e 100644
--- a/src/MapleFE/autogen/src/attr_gen.cpp
+++ b/src/MapleFE/autogen/src/attr_gen.cpp
@@ -66,29 +66,28 @@ const std::string AttrGen::EnumNextElem(){
 /////////////////////////////////////////////////////////////////////
 
 void AttrGen::Generate() {
-  GenHeaderFile();
   GenCppFile();
 }
 
-void AttrGen::GenHeaderFile() {
-  mHeaderFile.WriteOneLine("#ifndef __ATTR_GEN_H__", 22);
-  mHeaderFile.WriteOneLine("#define __ATTR_GEN_H__", 22);
-  mHeaderFile.WriteOneLine("namespace maplefe {", 19);
-  mHeaderFile.WriteOneLine("extern AttrKeyword AttrKeywordTable[ATTR_NA];", 45);
-  mHeaderFile.WriteOneLine("}", 1);
-  mHeaderFile.WriteOneLine("#endif", 6);
-}
-
 void AttrGen::GenCppFile() {
   mCppFile.WriteOneLine("#include \"common_header_autogen.h\"", 34);
   mCppFile.WriteOneLine("namespace maplefe {", 19);
 
   TableBuffer tb;
-  tb.Generate(this, "AttrKeyword AttrKeywordTable[ATTR_NA] = {");
+  std::string s = "AttrKeyword AttrKeywordTable[";
+  std::string num = std::to_string(mAttrs.size());
+  s += num;
+  s += "] = {";
+  tb.Generate(this, s);
   mCppFile.WriteFormattedBuffer(&tb);
   mCppFile.WriteOneLine("};", 2);
+
+  // generate the table size
+  s = "unsigned AttrKeywordTableSize = ";
+  s += num;
+  s += ";";
+  mCppFile.WriteOneLine(s.c_str(), s.size());
+
   mCppFile.WriteOneLine("}", 1);
 }
 }
-
-
diff --git a/src/MapleFE/autogen/src/auto_gen.cpp b/src/MapleFE/autogen/src/auto_gen.cpp
index e53abeb62264e6f43588277634b417167e3b8661..d2baba06127bf93fbbfc9cd9d1a60b500a4a6542 100644
--- a/src/MapleFE/autogen/src/auto_gen.cpp
+++ b/src/MapleFE/autogen/src/auto_gen.cpp
@@ -62,52 +62,9 @@ FileWriter *gSummaryCppFile;
 unsigned    gRuleTableNum;
 std::vector<std::string> gTopRules;
 
-static void WriteSummaryHFile() {
-  gSummaryHFile->WriteOneLine("#ifndef __DEBUG_GEN_H__", 23);
-  gSummaryHFile->WriteOneLine("#define __DEBUG_GEN_H__", 23);
-  gSummaryHFile->WriteOneLine("#include \"ruletable.h\"", 22);
-  gSummaryHFile->WriteOneLine("#include \"succ_match.h\"", 23);
-  gSummaryHFile->WriteOneLine("#include <vector>", 17);
-  gSummaryHFile->WriteOneLine("namespace maplefe {", 19);
-  gSummaryHFile->WriteOneLine("typedef struct {", 16);
-  gSummaryHFile->WriteOneLine("  const RuleTable *mAddr;", 25);
-  gSummaryHFile->WriteOneLine("  const char      *mName;", 25);
-  gSummaryHFile->WriteOneLine("  unsigned         mIndex;", 26);
-  gSummaryHFile->WriteOneLine("}RuleTableSummary;", 18);
-  gSummaryHFile->WriteOneLine("extern RuleTableSummary gRuleTableSummarys[];", 45);
-  gSummaryHFile->WriteOneLine("extern unsigned RuleTableNum;", 29);
-  gSummaryHFile->WriteOneLine("extern const char* GetRuleTableName(const RuleTable*);", 54);
-
-  std::string s = "extern std::vector<unsigned> gFailed[";
-  s += std::to_string(gRuleTableNum);
-  s += "];";
-  gSummaryHFile->WriteOneLine(s.c_str(), s.size());
-
-  // Write SuccMatch array
-  s = "class SuccMatch;";
-  gSummaryHFile->WriteOneLine(s.c_str(), s.size());
-
-  s = "extern SuccMatch gSucc[";
-  s += std::to_string(gRuleTableNum);
-  s += "];";
-  gSummaryHFile->WriteOneLine(s.c_str(), s.size());
-
-  // Write Top rules
-  s = "extern unsigned gTopRulesNum;";
-  gSummaryHFile->WriteOneLine(s.c_str(), s.size());
-
-  s = "extern RuleTable* gTopRules[";
-  s += std::to_string(gTopRules.size());
-  s += "];";
-  gSummaryHFile->WriteOneLine(s.c_str(), s.size());
-
-  gSummaryHFile->WriteOneLine("}", 1);
-  gSummaryHFile->WriteOneLine("#endif", 6);
-}
-
 // write the beginning part of summary file
 static void PrepareSummaryCppFile() {
-  gSummaryCppFile->WriteOneLine("#include \"gen_summary.h\"", 24);
+  gSummaryCppFile->WriteOneLine("#include \"rule_summary.h\"", 25);
   gSummaryCppFile->WriteOneLine("#include \"common_header_autogen.h\"", 34);
   gSummaryCppFile->WriteOneLine("namespace maplefe {", 19);
   gSummaryCppFile->WriteOneLine("RuleTableSummary gRuleTableSummarys[] = {", 41);
@@ -130,7 +87,7 @@ static void FinishSummaryCppFile() {
   gSummaryCppFile->WriteOneLine("  return NULL;", 14);
   gSummaryCppFile->WriteOneLine("}", 1);
 
-  std::string s = "std::vector<unsigned> gFailed[";
+  std::string s = "BitVector gFailed[";
   s += std::to_string(gRuleTableNum);
   s += "];";
   gSummaryCppFile->WriteOneLine(s.c_str(), s.size());
@@ -167,85 +124,96 @@ static void FinishSummaryCppFile() {
 ///////////////////////////////////////////////////////////////////////////////////////
 
 void AutoGen::Init() {
-  std::string lang_path_header("../../java/include/");
-  std::string lang_path_cpp("../../java/src/");
+  std::string lang_path("../gen/");
 
-  std::string summary_file_name = lang_path_cpp + "gen_summary.cpp";
+  std::string summary_file_name = lang_path + "gen_summary.cpp";
   gSummaryCppFile = new FileWriter(summary_file_name);
-  summary_file_name = lang_path_header + "gen_summary.h";
+  summary_file_name = lang_path + "gen_summary.h";
   gSummaryHFile = new FileWriter(summary_file_name);
   gRuleTableNum = 0;
 
   PrepareSummaryCppFile();
 
-  std::string hFile = lang_path_header + "gen_reserved.h";
-  std::string cppFile = lang_path_cpp + "gen_reserved.cpp";
-  mReservedGen = new ReservedGen("reserved.spec", hFile.c_str(), cppFile.c_str());
+  std::string hFile = lang_path + "gen_reserved.h";
+  std::string cppFile = lang_path + "gen_reserved.cpp";
+  mReservedGen = new ReservedGen("../../../autogen/reserved.spec", hFile.c_str(), cppFile.c_str());
   mReservedGen->SetReserved(mReservedGen);
   mGenArray.push_back(mReservedGen);
 
-  hFile = lang_path_header + "gen_iden.h";
-  cppFile = lang_path_cpp + "gen_iden.cpp";
-  mIdenGen  = new IdenGen("identifier.spec", hFile.c_str(), cppFile.c_str());
+  hFile = lang_path + "gen_iden.h";
+  cppFile = lang_path + "gen_iden.cpp";
+  std::string specFile = "../../../";
+  specFile += mLang;
+  specFile += "/identifier.spec";
+  mIdenGen  = new IdenGen(specFile.c_str(), hFile.c_str(), cppFile.c_str());
   mIdenGen->SetReserved(mReservedGen);
   mGenArray.push_back(mIdenGen);
 
-  hFile = lang_path_header + "gen_literal.h";
-  cppFile = lang_path_cpp + "gen_literal.cpp";
-  mLitGen  = new LiteralGen("literal.spec", hFile.c_str(), cppFile.c_str());
+  hFile = lang_path + "gen_literal.h";
+  cppFile = lang_path + "gen_literal.cpp";
+  specFile = "../../../";
+  specFile += mLang;
+  specFile += "/literal.spec";
+  mLitGen  = new LiteralGen(specFile.c_str(), hFile.c_str(), cppFile.c_str());
   mLitGen->SetReserved(mReservedGen);
   mGenArray.push_back(mLitGen);
 
-  hFile = lang_path_header + "gen_type.h";
-  cppFile = lang_path_cpp + "gen_type.cpp";
-  mTypeGen  = new TypeGen("type.spec", hFile.c_str(), cppFile.c_str());
+  hFile = lang_path + "gen_type.h";
+  cppFile = lang_path + "gen_type.cpp";
+  specFile = "../../../";
+  specFile += mLang;
+  specFile += "/type.spec";
+  mTypeGen  = new TypeGen(specFile.c_str(), hFile.c_str(), cppFile.c_str());
   mTypeGen->SetReserved(mReservedGen);
   mGenArray.push_back(mTypeGen);
 
-  hFile = lang_path_header + "gen_attr.h";
-  cppFile = lang_path_cpp + "gen_attr.cpp";
-  mAttrGen  = new AttrGen("attr.spec", hFile.c_str(), cppFile.c_str());
+  hFile = lang_path + "gen_attr.h";
+  cppFile = lang_path + "gen_attr.cpp";
+  specFile = "../../../";
+  specFile += mLang;
+  specFile += "/attr.spec";
+  mAttrGen  = new AttrGen(specFile.c_str(), hFile.c_str(), cppFile.c_str());
   mAttrGen->SetReserved(mReservedGen);
   mGenArray.push_back(mAttrGen);
 
-  hFile = lang_path_header + "gen_block.h";
-  cppFile = lang_path_cpp + "gen_block.cpp";
-  mBlockGen  = new BlockGen("block.spec", hFile.c_str(), cppFile.c_str());
-  mBlockGen->SetReserved(mReservedGen);
-  mGenArray.push_back(mBlockGen);
-
-  hFile = lang_path_header + "gen_separator.h";
-  cppFile = lang_path_cpp + "gen_separator.cpp";
-  mSeparatorGen  = new SeparatorGen("separator.spec", hFile.c_str(), cppFile.c_str());
+  hFile = lang_path + "gen_separator.h";
+  cppFile = lang_path + "gen_separator.cpp";
+  specFile = "../../../";
+  specFile += mLang;
+  specFile += "/separator.spec";
+  mSeparatorGen  = new SeparatorGen(specFile.c_str(), hFile.c_str(), cppFile.c_str());
   mSeparatorGen->SetReserved(mReservedGen);
   mGenArray.push_back(mSeparatorGen);
 
-  hFile = lang_path_header + "gen_operator.h";
-  cppFile = lang_path_cpp + "gen_operator.cpp";
-  mOperatorGen  = new OperatorGen("operator.spec", hFile.c_str(), cppFile.c_str());
+  hFile = lang_path + "gen_operator.h";
+  cppFile = lang_path + "gen_operator.cpp";
+  specFile = "../../../";
+  specFile += mLang;
+  specFile += "/operator.spec";
+  mOperatorGen  = new OperatorGen(specFile.c_str(), hFile.c_str(), cppFile.c_str());
   mOperatorGen->SetReserved(mReservedGen);
   mGenArray.push_back(mOperatorGen);
 
-  hFile = lang_path_header + "gen_keyword.h";
-  cppFile = lang_path_cpp + "gen_keyword.cpp";
-  mKeywordGen  = new KeywordGen("keyword.spec", hFile.c_str(), cppFile.c_str());
+  hFile = lang_path + "gen_keyword.h";
+  cppFile = lang_path + "gen_keyword.cpp";
+  specFile = "../../../";
+  specFile += mLang;
+  specFile += "/keyword.spec";
+  mKeywordGen  = new KeywordGen(specFile.c_str(), hFile.c_str(), cppFile.c_str());
   mKeywordGen->SetReserved(mReservedGen);
   mGenArray.push_back(mKeywordGen);
 
-  hFile = lang_path_header + "gen_expr.h";
-  cppFile = lang_path_cpp + "gen_expr.cpp";
-  mExprGen  = new ExprGen("expr.spec", hFile.c_str(), cppFile.c_str());
-  mExprGen->SetReserved(mReservedGen);
-  mGenArray.push_back(mExprGen);
-
-  hFile = lang_path_header + "gen_stmt.h";
-  cppFile = lang_path_cpp + "gen_stmt.cpp";
-  mStmtGen  = new StmtGen("stmt.spec", hFile.c_str(), cppFile.c_str());
+  hFile = lang_path + "gen_stmt.h";
+  cppFile = lang_path + "gen_stmt.cpp";
+  specFile = "../../../";
+  specFile += mLang;
+  specFile += "/stmt.spec";
+  mStmtGen  = new StmtGen(specFile.c_str(), hFile.c_str(), cppFile.c_str());
   mStmtGen->SetReserved(mReservedGen);
   mGenArray.push_back(mStmtGen);
 
-  hFile = lang_path_header + "gen_token.h";
-  cppFile = lang_path_cpp + "gen_token.cpp";
+  hFile = lang_path + "gen_token.h";
+  cppFile = lang_path + "gen_token.cpp";
   mTokenGen  = new TokenGen(hFile.c_str(), cppFile.c_str());
   mTokenGen->SetReserved(mReservedGen);
   mGenArray.push_back(mTokenGen);
@@ -304,7 +272,6 @@ void AutoGen::Gen() {
     gen->Generate();
   }
 
-  WriteSummaryHFile();
   FinishSummaryCppFile();
 }
 
diff --git a/src/MapleFE/autogen/src/base_gen.cpp b/src/MapleFE/autogen/src/base_gen.cpp
index 2bad09f17e5d1bc9b9b94e847464b308fd6bcf2a..23f00799aaf9469b78a149295a79ae3073a116a3 100644
--- a/src/MapleFE/autogen/src/base_gen.cpp
+++ b/src/MapleFE/autogen/src/base_gen.cpp
@@ -81,8 +81,8 @@ BaseGen::~BaseGen() {
 }
 
 Rule *BaseGen::AddLiteralRule(std::string rulename) {
-  Rule *rule = NULL;
-  if (rule = FindRule(rulename)) {
+  Rule *rule = FindRule(rulename);
+  if (rule) {
     return rule;
   }
 
diff --git a/src/MapleFE/autogen/src/block_gen.cpp b/src/MapleFE/autogen/src/block_gen.cpp
deleted file mode 100644
index 365f093ad106fb1db90569ae08993eb7be8508bd..0000000000000000000000000000000000000000
--- a/src/MapleFE/autogen/src/block_gen.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
-*
-* OpenArkFE is licensed under the Mulan PSL v2.
-* You can use this software according to the terms and conditions of the Mulan PSL v2.
-* You may obtain a copy of Mulan PSL v2 at:
-*
-*  http://license.coscl.org.cn/MulanPSL2
-*
-* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
-* FIT FOR A PARTICULAR PURPOSE.
-* See the Mulan PSL v2 for more details.
-*/
-#include "block_gen.h"
-
-namespace maplefe {
-
-void BlockGen::Generate() {
-  GenRuleTables();
-  GenHeaderFile();
-  GenCppFile();
-}
-
-void BlockGen::GenHeaderFile() {
-  mHeaderFile.WriteOneLine("#ifndef __BLOCK_GEN_H__", 23);
-  mHeaderFile.WriteOneLine("#define __BLOCK_GEN_H__", 23);
-  mHeaderFile.WriteOneLine("namespace maplefe {", 19);
-
-  // generate the rule tables
-  mHeaderFile.WriteFormattedBuffer(&mRuleTableHeader);
-
-  mHeaderFile.WriteOneLine("}", 1);
-  mHeaderFile.WriteOneLine("#endif", 6);
-}
-
-void BlockGen::GenCppFile() {
-  mCppFile.WriteOneLine("#include \"common_header_autogen.h\"", 34);
-  mCppFile.WriteOneLine("namespace maplefe {", 19);
-  // generate the rule tables
-  mCppFile.WriteFormattedBuffer(&mRuleTableCpp);
-  mCppFile.WriteOneLine("}", 1);
-}
-}
-
-
diff --git a/src/MapleFE/autogen/src/buffer2write.cpp b/src/MapleFE/autogen/src/buffer2write.cpp
index 7381a69168343728306b0d16597effe67009cfa3..17d7bb7be28966ac0755a67eda9f9b526b4335e1 100644
--- a/src/MapleFE/autogen/src/buffer2write.cpp
+++ b/src/MapleFE/autogen/src/buffer2write.cpp
@@ -102,7 +102,7 @@ WriteStatus LineBuffer::AddInteger(int i) {
   unsigned digits = 0;
   if (i < 0) {
     digits = 1;
-  } 
+  }
 
   digits += NumDigits(i);
 
@@ -166,12 +166,12 @@ char* RectBuffer::GetNextAvailLine() {
 
   if (CurrentLineEmpty())
     return mCurrLine;
-  
+
   unsigned mask = (1 << LINES_PER_BLOCK) - 1;
   unsigned line = (mUsed & mask) + 1;
   unsigned log2line = (unsigned)log2(line);
   char *addr = mData + MAX_LINE_LIMIT * log2line;
-  mUsed = mUsed | line; 
+  mUsed = mUsed | line;
 
   mCurrLine = addr;
   mCurrLineSize = 0;
@@ -212,7 +212,7 @@ WriteStatus RectBuffer::AddInteger(int i) {
   // take '-' into account.
   if (i < 0) {
     digits = 1;
-  } 
+  }
 
   digits += NumDigits(i);
   left -= digits;
@@ -238,7 +238,7 @@ WriteStatus RectBuffer::AddString(const char *str){
   // std::string data(indentation);
   // data = data + str;
   // str = data.c_str();
-  
+
   char *pos = mCurrLine + mCurrLineSize;
   unsigned left = MAX_LINE_LIMIT - mCurrLineSize;
   unsigned len = strlen(str);
@@ -404,7 +404,7 @@ char* FormattedBuffer::NewLine() {
     // default constructor of OneBuffer will allocate a new RectBuffer
     ob = NewOneBuffer();
   }
-  return ob->GetNextAvailLine(); 
+  return ob->GetNextAvailLine();
 }
 
 // Open a new line for comment, return the addr of the line.
@@ -473,7 +473,7 @@ void FormattedBuffer::AddStringWholeLine(const char *str){
 void FormattedBuffer::AddNestedBuffer(FormattedBuffer *nested) {
   OneBuffer *ob = new OneBuffer(nested);
   mBuffers.push_back(ob);
-  return; 
+  return;
 }
 
 // wipe existing data, fill with whitespace.
@@ -490,7 +490,7 @@ void FormattedBuffer::ClearLine(char *line) {
 
 // the enum structure will have the following pattern. The following is
 // for Separator.
-//      typedef enum {
+//      typedef enum SepId {
 //        SEP_Xxx,
 //        ...
 //        SEP_Null
@@ -508,21 +508,23 @@ void EnumBuffer::Generate(BaseGen *bg, const char *last_item){
   while(!bg->EnumEnd()) {
     NewLine();
     std::string elem = bg->EnumNextElem();
-    if (!bg->EnumEnd() || last_item)
-      if (!elem.size())
+    if (!bg->EnumEnd() || last_item) {
+      if (!elem.size()) {
         elem = ",";
-      else
+      } else {
         elem = elem + ",";
+      }
+    }
     AddString(elem);
-  } 
+  }
   NewLine();
   AddString(last_item);
- 
+
   DecIndent();
   const std::string name = bg->EnumName();
   std::string s = "}" + name + ";";
   NewOneBuffer(s.size(), true);  // a separate LineBuffer
-  AddString(s); 
+  AddString(s);
 
   return;
 }
@@ -596,13 +598,15 @@ void TableBuffer::Generate(BaseGen *bg, const std::string decl){
   while(!bg->EnumEnd()) {
     NewLine();
     std::string elem = bg->EnumNextElem();
-    if (!bg->EnumEnd())
-      if (!elem.size())
+    if (!bg->EnumEnd()) {
+      if (!elem.size()) {
         elem = ",";
-      else
+      } else {
         elem = elem + ",";
+      }
+    }
     AddString(elem);
-  } 
+  }
 
   DecIndent();
   return;
diff --git a/src/MapleFE/autogen/src/exprbuffer.cpp b/src/MapleFE/autogen/src/exprbuffer.cpp
index 4425cc7d0a178b4193ec69b8f44a97060bc9ff49..507ad149840db83a11387fb5c97d6ff5682384e3 100644
--- a/src/MapleFE/autogen/src/exprbuffer.cpp
+++ b/src/MapleFE/autogen/src/exprbuffer.cpp
@@ -21,7 +21,7 @@ namespace maplefe {
 
 // Note: This must be in the order as in 'enum OprCode', and this is the
 //       reason I duplicate OprCode here in order to make the code easy
-//       to maintain. 
+//       to maintain.
 OprInfo gOprInfo[OPC_Null] = {
   {OPC_Add, OPT_Bin, "+"},
   {OPC_Sub, OPT_Bin, "-"},
@@ -71,21 +71,21 @@ void ExprNode::SetCall(const char *s) {
   unsigned len = strlen(s);
   MASSERT(len < NAME_SIZE);
   strncpy(mName, s, len);
-  mOpc = OPC_Call; 
+  mOpc = OPC_Call;
 }
 
 void ExprNode::SetString(const char *s) {
   unsigned len = strlen(s);
   MASSERT(len < NAME_SIZE);
   strncpy(mName, s, len);
-  mOpc = OPC_Str; 
+  mOpc = OPC_Str;
 }
 
 void ExprNode::SetLiteral(const char *s) {
   unsigned len = strlen(s);
   MASSERT(len < NAME_SIZE);
   strncpy(mName, s, len);
-  mOpc = OPC_Lit; 
+  mOpc = OPC_Lit;
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -94,7 +94,7 @@ void ExprNode::SetLiteral(const char *s) {
 
 ExprBuffer::ExprBuffer() {
   mSize = EXPR_SIZE;
-  mData = (char*)malloc(mSize); 
+  mData = (char*)malloc(mSize);
   MASSERT(mData && "Cannot malloc buffer for ExprBuffer");
   mPos = 0;
   mRoot = (ExprNode*)mMemPool.Alloc(sizeof(ExprNode));
@@ -104,8 +104,8 @@ ExprBuffer::ExprBuffer() {
 // Depth-first search to free string memory which is allocated by
 // the caller of ExprBuffer.
 ExprBuffer::~ExprBuffer() {
-  if (mData);
-    free(mData); 
+  if (mData)
+    free(mData);
 }
 
 // Extend the size of mData
@@ -134,7 +134,7 @@ ExprNode* ExprBuffer::NewExprNodes(unsigned num) {
 // In-Order
 void ExprBuffer::Write2Buffer(){
   MASSERT(mRoot && "Root of expression is NULL!");
-  W2BRecursive(mRoot); 
+  W2BRecursive(mRoot);
 }
 
 void ExprBuffer::WriteStringNode(const ExprNode *n){
@@ -143,7 +143,7 @@ void ExprBuffer::WriteStringNode(const ExprNode *n){
     Extend(mPos + len);
 
   strncpy(mData+mPos, n->mName, len);
-  mPos += len; 
+  mPos += len;
 }
 
 void ExprBuffer::WriteLiteralNode(const ExprNode *n){
@@ -153,7 +153,7 @@ void ExprBuffer::WriteLiteralNode(const ExprNode *n){
 
   WriteChar('\"');
   strncpy(mData+mPos, n->mName, len);
-  mPos += len; 
+  mPos += len;
   WriteChar('\"');
 }
 
@@ -170,7 +170,7 @@ void ExprBuffer::WriteOperatorNode(const ExprNode *n){
   if (mPos + len > mSize)
     Extend(mPos + len);
   strncpy(mData + mPos, text, len);
-  mPos += len; 
+  mPos += len;
 }
 
 void ExprBuffer::WriteChar(const char c){
diff --git a/src/MapleFE/autogen/src/file_write.cpp b/src/MapleFE/autogen/src/file_write.cpp
index 752ffcf699dcf793435793d3d13ae8cd1604f9eb..ed301faaa6ad1d1344580131c198b512b4bd1eee 100644
--- a/src/MapleFE/autogen/src/file_write.cpp
+++ b/src/MapleFE/autogen/src/file_write.cpp
@@ -47,7 +47,7 @@ void FileWriter::WriteSimpleBuffers(const FormattedBuffer *fb) {
   std::vector<OneBuffer*>::const_iterator it = fb->mBuffers.begin();
   for (; it != fb->mBuffers.end(); it++) {
     OneBuffer *one = *it;
-    if (one->mIsSimple) { 
+    if (one->mIsSimple) {
       RectBuffer *rect = one->GetRectBuffer();
       if (rect) {
         mIndentation = rect->mIndentation;
diff --git a/src/MapleFE/autogen/src/keyword_gen.cpp b/src/MapleFE/autogen/src/keyword_gen.cpp
index 36d4afd4b96e715b1b2d84db823bba59ef7f6d90..74bb18dee8aa70f76811f9220c9e6d7337475bc9 100644
--- a/src/MapleFE/autogen/src/keyword_gen.cpp
+++ b/src/MapleFE/autogen/src/keyword_gen.cpp
@@ -36,7 +36,7 @@ const bool KeywordGen::EnumEnd(){
 const std::string KeywordGen::EnumNextElem(){
   std::string keyword = "\"" + *mEnumIter + "\"";
   mEnumIter++;
-  return keyword; 
+  return keyword;
 }
 
 /////////////////////////////////////////////////////////////////////
diff --git a/src/MapleFE/autogen/src/main.cpp b/src/MapleFE/autogen/src/main.cpp
index c8d04677a3682776771ff2bb23ae76f4f00ecbda..02343c71a819dc50bcf12400399643a468330701 100644
--- a/src/MapleFE/autogen/src/main.cpp
+++ b/src/MapleFE/autogen/src/main.cpp
@@ -31,11 +31,19 @@ int main(int argc, char *argv[]) {
   int verbose = 0;
   int fileIndex = 2;
 
+  std::string lang;
+
   if (argc >=2) {
     for (int i = 1; i < argc; i++) {
       int len = strlen(argv[i]);
       if (!strncmp(argv[i], "-verbose=", 9)) {
         verbose = atoi(argv[i]+9);
+      } else if (!strncmp(argv[i], "java", 4)) {
+        lang = "java";
+      } else if (!strncmp(argv[i], "typescript", 10)) {
+        lang = "typescript";
+      } else if (!strncmp(argv[i], "c", 1)) {
+        lang = "c";
       } else if (strcmp(argv[i], "-p") == 0) {
         checkParserOnly = true;
       } else {
@@ -57,6 +65,7 @@ int main(int argc, char *argv[]) {
   }
 
   maplefe::AutoGen ag(parser);
+  ag.SetLang(lang);
   ag.Gen();
 
   return 0;
diff --git a/src/MapleFE/autogen/src/operator_gen.cpp b/src/MapleFE/autogen/src/operator_gen.cpp
index eb9ea3f20c87cd9f71f520ff7a564c6166ab06a0..5113524011919ca0954b09f5c02709465130122a 100644
--- a/src/MapleFE/autogen/src/operator_gen.cpp
+++ b/src/MapleFE/autogen/src/operator_gen.cpp
@@ -27,11 +27,12 @@ OperatorId OprsSupported[OPR_NA] = {
 #include "supported_operators.def"
 };
 
-// s : the literal name 
+// s : the literal name
 // return the OprId
 OprId FindOperatorId(const std::string &s) {
   for (unsigned u = 0; u < OPR_NA; u++) {
-    if (!OprsSupported[u].mName.compare(0, s.length(), s))
+    if (!OprsSupported[u].mName.compare(0, s.length(), s) &&
+        s.length() == OprsSupported[u].mName.size())
       return OprsSupported[u].mOprId;
   }
   return OPR_NA;
@@ -74,7 +75,7 @@ const std::string OperatorGen::EnumNextElem(){
   enum_item = enum_item + "\"" + opr.mText + "\", OPR_" + FindOperatorName(opr.mID);
   enum_item = enum_item + "}";
   mEnumIter++;
-  return enum_item; 
+  return enum_item;
 }
 
 /////////////////////////////////////////////////////////////////////
@@ -111,7 +112,7 @@ void OperatorGen::GenHeaderFile() {
   mHeaderFile.WriteOneLine("#ifndef __OPERATOR_GEN_H__", 26);
   mHeaderFile.WriteOneLine("#define __OPERATOR_GEN_H__", 26);
   mHeaderFile.WriteOneLine("namespace maplefe {", 19);
-  mHeaderFile.WriteOneLine("extern OprTableEntry OprTable[OPR_NA];", 38);
+  mHeaderFile.WriteOneLine("extern OprTableEntry OprTable[];", 32);
   mHeaderFile.WriteOneLine("}", 1);
   mHeaderFile.WriteOneLine("#endif", 6);
 }
@@ -120,9 +121,20 @@ void OperatorGen::GenCppFile() {
   mCppFile.WriteOneLine("#include \"ruletable.h\"", 22);
   mCppFile.WriteOneLine("namespace maplefe {", 19);
   TableBuffer tb;
-  tb.Generate(this, "OprTableEntry OprTable[] = {");
+  std::string s = "OprTableEntry OprTable[";
+  std::string num = std::to_string(mOperators.size());
+  s += num;
+  s += "] = {";
+  tb.Generate(this, s);
   mCppFile.WriteFormattedBuffer(&tb);
   mCppFile.WriteOneLine("};", 2);
+
+  // generate the table size
+  s = "unsigned OprTableSize = ";
+  s += num;
+  s += ";";
+  mCppFile.WriteOneLine(s.c_str(), s.size());
+
   mCppFile.WriteOneLine("}", 1);
 }
 }
diff --git a/src/MapleFE/autogen/src/reserved_gen.cpp b/src/MapleFE/autogen/src/reserved_gen.cpp
index 06a60db950802d6cb4f75da7071989436100eff4..5920a7094ee5cb5f15bde22caceb56f8f292f7c7 100644
--- a/src/MapleFE/autogen/src/reserved_gen.cpp
+++ b/src/MapleFE/autogen/src/reserved_gen.cpp
@@ -25,10 +25,12 @@ ReservedGen::ReservedGen(const char *dfile, const char *hf, const char *cppf)
   ReservedOp oneof = {"ONEOF", RO_Oneof};
   ReservedOp zeroplus = {"ZEROORMORE", RO_Zeroormore};
   ReservedOp zeroorone = {"ZEROORONE", RO_Zeroorone};
+  ReservedOp asi = {"ASI", RO_ASI};
 
   mOps.push_back(oneof);
   mOps.push_back(zeroplus);
   mOps.push_back(zeroorone);
+  mOps.push_back(asi);
 }
 
 // Needs to override BaseGen::Run, since we dont need process
diff --git a/src/MapleFE/autogen/src/rule.cpp b/src/MapleFE/autogen/src/rule.cpp
index 259485306ffa7c12c2ce1dee180ddcdf763e254f..bde0e42ca0d00c440410947c983f3220653ce479 100644
--- a/src/MapleFE/autogen/src/rule.cpp
+++ b/src/MapleFE/autogen/src/rule.cpp
@@ -132,6 +132,7 @@ const char *RuleElem::GetRuleOpName() {
     case RO_Oneof:       return "ONEOF";
     case RO_Zeroormore:  return "ZEROORMORE";
     case RO_Zeroorone:   return "ZEROORONE";
+    case RO_ASI:         return "ASI";
     case RO_Concatenate:
     case RO_Null:
     default:             return "";
@@ -170,7 +171,10 @@ void RuleElem::Dump(bool newline) {
     case ET_Op:
     {
       std::cout << GetRuleOpName();
-      if (mData.mOp == RO_Oneof || mData.mOp == RO_Zeroormore || mData.mOp == RO_Zeroorone)
+      if (mData.mOp == RO_Oneof
+          || mData.mOp == RO_Zeroormore
+          || mData.mOp == RO_Zeroorone
+          || mData.mOp == RO_ASI )
         std::cout << "(";
 
       std::vector<RuleElem *>::iterator it = mSubElems.begin();
@@ -197,6 +201,7 @@ void RuleElem::Dump(bool newline) {
         }
         case RO_Zeroormore:
         case RO_Zeroorone:
+        case RO_ASI:
         {
           (*it)->Dump();
           break;
@@ -205,7 +210,10 @@ void RuleElem::Dump(bool newline) {
           break;
       }
 
-      if (mData.mOp == RO_Oneof || mData.mOp == RO_Zeroormore || mData.mOp == RO_Zeroorone)
+      if (mData.mOp == RO_Oneof
+          || mData.mOp == RO_Zeroormore
+          || mData.mOp == RO_Zeroorone
+          || mData.mOp == RO_ASI)
         std::cout << ")";
       break;
     }
diff --git a/src/MapleFE/autogen/src/rule_gen.cpp b/src/MapleFE/autogen/src/rule_gen.cpp
index fdf811afd28ff6f9531cd4116ded4b930425b982..33269487078102ae13291a040dde0def0ca12a0d 100644
--- a/src/MapleFE/autogen/src/rule_gen.cpp
+++ b/src/MapleFE/autogen/src/rule_gen.cpp
@@ -77,14 +77,14 @@ namespace maplefe {
 // Generate the table name for mRule
 std::string RuleGen::GetTblName(const Rule *rule) {
   std::string tn = "Tbl" + rule->mName;
-  return tn; 
+  return tn;
 }
 
 // Generate the table name for sub rules in mRule
 // The table id will be introduced here
 std::string RuleGen::GetSubTblName() {
   std::string tn = "Tbl" + mRule->mName + "_sub" + std::to_string(mSubTblNum);
-  return tn; 
+  return tn;
 }
 
 std::string RuleGen::GetPropertyName(const RuleAttr *attr) {
@@ -122,7 +122,7 @@ std::string RuleGen::GetEntryTypeName(ElemType type, RuleOp op) {
     name = "ET_Data";
     break;
   case ET_Op: {
-    switch(op) { 
+    switch(op) {
     case RO_Oneof:
       name = "ET_Oneof";
       break;
@@ -135,6 +135,9 @@ std::string RuleGen::GetEntryTypeName(ElemType type, RuleOp op) {
     case RO_Concatenate:
       name = "ET_Concatenate";
       break;
+    case RO_ASI:
+      name = "ET_ASI";
+      break;
     default:
       MERROR("unknown RuleOp");
       break;
@@ -190,7 +193,7 @@ std::string RuleGen::Gen4RuleElem(const RuleElem *elem) {
     // Note: The table could be defined in other files. Need include them.
     data += "DT_Subtable, &";
     data += GetTblName(elem->mData.mRule);
-    break; 
+    break;
   case ET_Op: {
     // Each Op will be generated as a new sub table
     mSubTblNum++;
@@ -248,7 +251,7 @@ void RuleGen::GenDebug(const std::string &rule_table_name) {
   addr_name_mapping += rule_table_name;
   addr_name_mapping += "\", ";
   addr_name_mapping += std::to_string(gRuleTableNum);
-  addr_name_mapping += "}\,";
+  addr_name_mapping += "},";
   gSummaryCppFile->WriteOneLine(addr_name_mapping.c_str(), addr_name_mapping.size());
   gRuleTableNum++;
 }
@@ -336,7 +339,7 @@ void RuleGen::Gen4Table(const Rule *rule, const RuleElem *elem){
       }
     }
   }
-  
+
   Gen4RuleAttr(rule_table_name, attr);
   Gen4TableHeader(rule_table_name);
   unsigned index = gRuleTableNum;
@@ -347,7 +350,7 @@ void RuleGen::Gen4Table(const Rule *rule, const RuleElem *elem){
   std::string rule_table;
 
   // 1. Add the LHS of table decl
-  rule_table = "RuleTable " + rule_table_name + " =";    
+  rule_table = "RuleTable " + rule_table_name + " =";
   rule_table_data = "TableData " + rule_table_data_name + "[";
   std::string elemnum = std::to_string(elem->mSubElems.size());
 
@@ -358,7 +361,7 @@ void RuleGen::Gen4Table(const Rule *rule, const RuleElem *elem){
   if (elem && (elem->mSubElems.size() == 0))
     elemnum = "1";
 
-  rule_table_data += elemnum + "] =";    
+  rule_table_data += elemnum + "] =";
 
   // 2. Add the beginning '{'
   rule_table += '{';
@@ -389,7 +392,7 @@ void RuleGen::Gen4Table(const Rule *rule, const RuleElem *elem){
 
   rule_table += "};";
 
- 
+
   // 4. go through the rule elements, generate rule table data
   std::string data = Gen4TableData(elem);
   rule_table_data += '{';
@@ -405,7 +408,7 @@ void RuleGen::Gen4Table(const Rule *rule, const RuleElem *elem){
 
 // The structure of rule and its sub-rule can be viewed as a tree.
 // We generate tables for rule and its sub-rules in depth first order.
-// 
+//
 void RuleGen::Generate() {
   bool need_patch = true;
   if ((mRule->mName.compare("CHAR") == 0) ||
diff --git a/src/MapleFE/autogen/src/separator_gen.cpp b/src/MapleFE/autogen/src/separator_gen.cpp
index 0afaa8ed75662b63cd5aebcc4b716faddd090141..39cb2318d175e1e5bd151c022fb84d97b0476227 100644
--- a/src/MapleFE/autogen/src/separator_gen.cpp
+++ b/src/MapleFE/autogen/src/separator_gen.cpp
@@ -28,7 +28,7 @@ SuppSepId SepsSupported[SEP_NA] = {
 #include "supported_separators.def"
 };
 
-// s : the literal name 
+// s : the literal name
 // return the SepId
 SepId FindSeparatorId(const std::string &s) {
   for (unsigned u = 0; u < SEP_NA; u++) {
@@ -75,7 +75,7 @@ const std::string SeparatorGen::EnumNextElem(){
   enum_item = enum_item + "\"" + sep.mKeyword + "\", SEP_" + FindSeparatorName(sep.mID);
   enum_item = enum_item + "}";
   mEnumIter++;
-  return enum_item; 
+  return enum_item;
 }
 
 /////////////////////////////////////////////////////////////////////
@@ -112,7 +112,7 @@ void SeparatorGen::GenHeaderFile() {
   mHeaderFile.WriteOneLine("#ifndef __SEPARATOR_GEN_H__", 27);
   mHeaderFile.WriteOneLine("#define __SEPARATOR_GEN_H__", 27);
   mHeaderFile.WriteOneLine("namespace maplefe {", 19);
-  mHeaderFile.WriteOneLine("extern SepTableEntry SepTable[SEP_NA];", 38);
+  mHeaderFile.WriteOneLine("extern SepTableEntry SepTable[];", 32);
   mHeaderFile.WriteOneLine("}", 1);
   mHeaderFile.WriteOneLine("#endif", 6);
 }
@@ -121,9 +121,20 @@ void SeparatorGen::GenCppFile() {
   mCppFile.WriteOneLine("#include \"ruletable.h\"", 22);
   mCppFile.WriteOneLine("namespace maplefe {", 19);
   TableBuffer tb;
-  tb.Generate(this, "SepTableEntry SepTable[SEP_NA] = {");
+  std::string s = "SepTableEntry SepTable[";
+  std::string num = std::to_string(mSeparators.size());
+  s += num;
+  s += "] = {";
+  tb.Generate(this, s);
   mCppFile.WriteFormattedBuffer(&tb);
   mCppFile.WriteOneLine("};", 2);
+
+  // generate the table size
+  s = "unsigned SepTableSize = ";
+  s += num;
+  s += ";";
+  mCppFile.WriteOneLine(s.c_str(), s.size());
+
   mCppFile.WriteOneLine("}", 1);
 }
 }
diff --git a/src/MapleFE/autogen/src/spec_lexer.cpp b/src/MapleFE/autogen/src/spec_lexer.cpp
index 8aea7c1db0900a123d1cda9f9f38ea4516bc287a..bb581c3469e7d71ed6283c55152f073a3e21ce9b 100644
--- a/src/MapleFE/autogen/src/spec_lexer.cpp
+++ b/src/MapleFE/autogen/src/spec_lexer.cpp
@@ -600,6 +600,10 @@ std::string SPECLexer::GetTokenString(SPECTokenKind thekind) {
       temp = "ZEROORMORE";
       break;
     }
+    case SPECTK_ASI: {
+      temp = "ASI";
+      break;
+    }
     case SPECTK_Concat: {
       temp = "+";
       break;
diff --git a/src/MapleFE/autogen/src/spec_parser.cpp b/src/MapleFE/autogen/src/spec_parser.cpp
index f8af4546aac1688a239c475278118eda729593d3..aa0108fad0b41435fc4835ebeb17010aaeb9e647 100644
--- a/src/MapleFE/autogen/src/spec_parser.cpp
+++ b/src/MapleFE/autogen/src/spec_parser.cpp
@@ -31,7 +31,7 @@ namespace maplefe {
 
 //////////////////////////////////////////////////////////////////////////////
 
-void SPECParser::ParserError(std::string msg, std::string str) { 
+void SPECParser::ParserError(std::string msg, std::string str) {
   std::cout << "\n================================= spec file syntax error ============================" << std::endl;
   std::cout << "file " << mFilename << std::endl;
   std::cout << "line " << mLexer->GetLineNum() << std::endl;
@@ -194,6 +194,10 @@ bool SPECParser::ParseElement(RuleElem *&elem, bool allowConcat) {
       elem = mBaseGen->NewRuleElem(RO_Zeroormore);
       status = ParseElementSet(elem);
       break;
+    case SPECTK_ASI:
+      elem = mBaseGen->NewRuleElem(RO_ASI);
+      status = ParseElementSet(elem);
+      break;
     case SPECTK_Char:
     {
       elem = mBaseGen->GetOrCreateRuleElemFromChar(mLexer->thechar);
@@ -299,8 +303,11 @@ RuleAction *SPECParser::GetAction() {
 
 bool SPECParser::ParseElementSet(RuleElem *elem) {
   SPECTokenKind optk = mLexer->GetToken();
-  if (!(optk == SPECTK_Oneof || optk == SPECTK_Zeroorone || optk == SPECTK_Zeroormore))
-    ParserError("expect ONEOF/ZEROORONE/ZEROORMORE but get ", mLexer->GetTokenString());
+  if (!(optk == SPECTK_Oneof
+        || optk == SPECTK_Zeroorone
+        || optk == SPECTK_Zeroormore
+        || optk == SPECTK_ASI))
+    ParserError("expect ONEOF/ZEROORONE/ZEROORMORE/ASI but get ", mLexer->GetTokenString());
 
   SPECTokenKind tk = mLexer->NextToken();
   if (tk != SPECTK_Lparen)
@@ -318,8 +325,8 @@ bool SPECParser::ParseElementSet(RuleElem *elem) {
     tk = mLexer->GetToken();
     if (optk == SPECTK_Oneof && tk == SPECTK_Coma)
       tk = mLexer->NextToken();
-    else if (optk == SPECTK_Zeroorone || optk == SPECTK_Zeroormore)
-      // SPECTK_Zeroorone and SPECTK_Zeroormore only allow one element
+    else if (optk == SPECTK_Zeroorone || optk == SPECTK_Zeroormore || optk == SPECTK_ASI)
+      // SPECTK_Zeroorone, SPECTK_Zeroormore and ASI only allow one element
       break;
   }
 
diff --git a/src/MapleFE/autogen/src/token_gen.cpp b/src/MapleFE/autogen/src/token_gen.cpp
index 725192414d5cbdd64d937aa63a9a9cfb504affbc..45840e7e312e0b3052e20d8e0d3feb49136effe0 100644
--- a/src/MapleFE/autogen/src/token_gen.cpp
+++ b/src/MapleFE/autogen/src/token_gen.cpp
@@ -65,11 +65,12 @@ void TokenGen::ProcessAltTokens() {
   for (unsigned i = 0; i < mAltTokensNum; i++) {
     AlternativeToken at = alt_tokens[i];
     unsigned orig_id;
-    bool found = gTokenTable.FindStringTokenId(at.mName, orig_id);
-    MASSERT(found);
+    bool orig_found = gTokenTable.FindStringTokenId(at.mName, orig_id);
     unsigned alt_id;
-    found = gTokenTable.FindStringTokenId(at.mAltName, alt_id);
-    MASSERT(found);
+    bool alt_found = gTokenTable.FindStringTokenId(at.mAltName, alt_id);
+    if (!orig_found || !alt_found) {
+      continue;
+    }
 
     ProcessedAltToken pat;
     pat.mId = orig_id;
@@ -155,7 +156,7 @@ void TokenGen::GenCppFile() {
 
   std::list<Operator>::iterator oit = gTokenTable.mOperators->begin();
   for (; oit != gTokenTable.mOperators->end(); oit++, overall_index++) {
-    std::string output = "  {.mTkType = TT_OP, {.mOprId = ";
+    std::string output = "  {.mTkType = TT_OP, .mLineNum = 0, .mColNum = 0, .mLineBegin = false, .mLineEnd = false, {.mOprId = ";
     Operator opr = *oit;
     std::string opr_name = "OPR_";
     opr_name += FindOperatorName(opr.mID);
@@ -186,7 +187,7 @@ void TokenGen::GenCppFile() {
 
   std::list<Separator>::iterator sit = gTokenTable.mSeparators->begin();
   for (; sit != gTokenTable.mSeparators->end(); sit++, overall_index++) {
-    std::string output = "  {.mTkType = TT_SP, {.mSepId = ";
+    std::string output = "  {.mTkType = TT_SP, .mLineNum = 0, .mColNum = 0, .mLineBegin = false, .mLineEnd = false, {.mSepId = ";
     Separator sep = *sit;
     std::string sep_name = "SEP_";
     sep_name += FindSeparatorName(sep.mID);
@@ -217,7 +218,7 @@ void TokenGen::GenCppFile() {
 
   unsigned kw_size = gTokenTable.mKeywords.size();
   for (unsigned index = 0; index < kw_size; index++, overall_index++) {
-    std::string output = "  {.mTkType = TT_KW, {.mName = ";
+    std::string output = "  {.mTkType = TT_KW, .mLineNum = 0, .mColNum = 0, .mLineBegin = false, .mLineEnd = false, {.mName = ";
     std::string keyword = gTokenTable.mKeywords[index];
     output += "\"";
     output += keyword;
@@ -247,7 +248,7 @@ void TokenGen::GenCppFile() {
   }
 
   // Write the comment token
-  std::string output = "  {.mTkType = TT_CM, {.mName = NULL}, .mAltTokens = NULL}";
+  std::string output = "  {.mTkType = TT_CM, .mLineNum = 0, .mColNum = 0, .mLineBegin = false, .mLineEnd = false, {.mName = NULL}, .mAltTokens = NULL}";
   mCppFile.WriteOneLine(output.c_str(), output.size());
   mCppFile.WriteOneLine("};", 2);
   mCppFile.WriteOneLine("}", 1);
diff --git a/src/MapleFE/autogen/src/type_gen.cpp b/src/MapleFE/autogen/src/type_gen.cpp
index 786a3d57618abcf6b2bebdbc53a65632572b422e..57214ec7fd0f9f5a32c12df874e048e5b06b24d6 100644
--- a/src/MapleFE/autogen/src/type_gen.cpp
+++ b/src/MapleFE/autogen/src/type_gen.cpp
@@ -76,7 +76,7 @@ void TypeGen::GenHeaderFile() {
   mHeaderFile.WriteOneLine("namespace maplefe {", 19);
 
   // generate the keyword table
-  mHeaderFile.WriteOneLine("extern TypeKeyword TypeKeywordTable[TY_NA];", 43);
+  mHeaderFile.WriteOneLine("extern TypeKeyword TypeKeywordTable[];", 38);
 
   // generate the rule tables
   mHeaderFile.WriteFormattedBuffer(&mRuleTableHeader);
@@ -90,12 +90,23 @@ void TypeGen::GenCppFile() {
 
   // generate the keyword table
   TableBuffer tb;
-  tb.Generate(this, "TypeKeyword TypeKeywordTable[TY_NA] = {");
+  std::string s = "TypeKeyword TypeKeywordTable[";
+  std::string num = std::to_string(mTypes.size());
+  s += num;
+  s += "] = {";
+  tb.Generate(this, s);
   mCppFile.WriteFormattedBuffer(&tb);
   mCppFile.WriteOneLine("};", 2);
 
+  // generate the table size
+  s = "unsigned TypeKeywordTableSize = ";
+  s += num;
+  s += ";";
+  mCppFile.WriteOneLine(s.c_str(), s.size());
+
   // generate the rule tables
   mCppFile.WriteFormattedBuffer(&mRuleTableCpp);
+
   mCppFile.WriteOneLine("}", 1);
 }
 
diff --git a/src/MapleFE/c/Makefile b/src/MapleFE/c/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..6ff0312533c771b903d1686b33384d7da06eff4b
--- /dev/null
+++ b/src/MapleFE/c/Makefile
@@ -0,0 +1,24 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+include ../Makefile.in
+
+TARGS = c2ast
+
+$(TARGS):
+	$(MAKE) -C src
+
+clean:
+	rm -rf $(BUILDDIR)/c
+
+.PHONY: $(TARGS)
diff --git a/src/MapleFE/c/attr.spec b/src/MapleFE/c/attr.spec
new file mode 100644
index 0000000000000000000000000000000000000000..7211303cd96c3d2ceb5755398e12958832394a0a
--- /dev/null
+++ b/src/MapleFE/c/attr.spec
@@ -0,0 +1,18 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+STRUCT Attribute : (("const", const),
+                    ("static", static),
+                    ("volatile", volatile),
+                    ("restrict", restrict))
\ No newline at end of file
diff --git a/src/MapleFE/c/identifier.spec b/src/MapleFE/c/identifier.spec
new file mode 100644
index 0000000000000000000000000000000000000000..ff6f96fdb1c0fa797e70f876d0d2f53f41342f8c
--- /dev/null
+++ b/src/MapleFE/c/identifier.spec
@@ -0,0 +1,17 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+rule CChar : ONEOF(CHAR, '_')
+rule CharOrDigit : ONEOF(CChar, DIGIT)
+rule Identifier : CChar + ZEROORMORE(CharOrDigit)
\ No newline at end of file
diff --git a/src/MapleFE/c/include/lang_builtin.def b/src/MapleFE/c/include/lang_builtin.def
new file mode 100644
index 0000000000000000000000000000000000000000..8c127c72a426bb6113253cdf59a103a11785e8fb
--- /dev/null
+++ b/src/MapleFE/c/include/lang_builtin.def
@@ -0,0 +1,14 @@
+// Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved.
+//
+// OpenArkFE is licensed under the Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+//
+//  http://license.coscl.org.cn/MulanPSL2
+//
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+// FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+//
+
diff --git a/src/MapleFE/c/include/lang_keywords.def b/src/MapleFE/c/include/lang_keywords.def
new file mode 100644
index 0000000000000000000000000000000000000000..fc60a43491ab2c16f99198453f2543f60947aad0
--- /dev/null
+++ b/src/MapleFE/c/include/lang_keywords.def
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+LANGKEYWORD(auto)
+LANGKEYWORD(break)
+LANGKEYWORD(case)
+LANGKEYWORD(char)
+LANGKEYWORD(const)
+LANGKEYWORD(continue)
+LANGKEYWORD(default)
+LANGKEYWORD(do)
+LANGKEYWORD(double)
+LANGKEYWORD(else)
+LANGKEYWORD(enum)
+LANGKEYWORD(extern)
+LANGKEYWORD(float)
+LANGKEYWORD(for)
+LANGKEYWORD(goto)
+LANGKEYWORD(if)
+LANGKEYWORD(inline)
+LANGKEYWORD(int)
+LANGKEYWORD(long)
+LANGKEYWORD(register)
+LANGKEYWORD(restrict)
+LANGKEYWORD(return)
+LANGKEYWORD(short)
+LANGKEYWORD(signed)
+LANGKEYWORD(sizeof)
+LANGKEYWORD(static)
+LANGKEYWORD(struct)
+LANGKEYWORD(switch)
+LANGKEYWORD(typedef)
+LANGKEYWORD(union)
+LANGKEYWORD(unsigned)
+LANGKEYWORD(void)
+LANGKEYWORD(volatile)
+LANGKEYWORD(while)
+LANGKEYWORD(_Bool)
+LANGKEYWORD(_Complex)
+LANGKEYWORD(_Imaginary)
\ No newline at end of file
diff --git a/src/MapleFE/c/include/lang_spec.h b/src/MapleFE/c/include/lang_spec.h
new file mode 100644
index 0000000000000000000000000000000000000000..bae3daba4ee9dc8df6b59334d68e9df4b9f84798
--- /dev/null
+++ b/src/MapleFE/c/include/lang_spec.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEFE_LANG_SPEC_H
+#define MAPLEFE_LANG_SPEC_H
+#include "stringutil.h"
+#include "token.h"
+#include "lexer.h"
+
+namespace maplefe {
+
+class StringToValueImpl : public StringToValue {
+public:
+  float  StringToFloat(std::string &s);
+  double StringToDouble(std::string &s);
+  bool   StringToBool(std::string &s);
+  Char   StringToChar(std::string &s);
+  bool   StringIsNull(std::string &s);
+};
+
+extern LitData ProcessLiteral(LitId type, const char *str);
+
+class CLexer : public Lexer {
+};
+
+}
+#endif //MAPLEFE_LANG_SPEC_H
diff --git a/src/MapleFE/c/keyword.spec b/src/MapleFE/c/keyword.spec
new file mode 100644
index 0000000000000000000000000000000000000000..2e62b807aaaf736015788008e0c36e2b1843bc51
--- /dev/null
+++ b/src/MapleFE/c/keyword.spec
@@ -0,0 +1,51 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+STRUCT KeyWord : ((auto),
+                  (break),
+                  (case),
+                  (char),
+                  (const),
+                  (continue),
+                  (default),
+                  (do),
+                  (double),
+                  (else),
+                  (enum),
+                  (extern),
+                  (float),
+                  (for),
+                  (goto),
+                  (if),
+                  (inline),
+                  (int),
+                  (long),
+                  (register),
+                  (restrict),
+                  (return),
+                  (short),
+                  (signed),
+                  (sizeof),
+                  (static),
+                  (struct),
+                  (switch),
+                  (typedef),
+                  (union),
+                  (unsigned),
+                  (void),
+                  (volatile),
+                  (while),
+                  (_Bool),
+                  (_Complex),
+                  (_Imaginary))
diff --git a/src/MapleFE/c/literal.spec b/src/MapleFE/c/literal.spec
new file mode 100644
index 0000000000000000000000000000000000000000..013f438418239a299bcd63ca4285bc00efd532c6
--- /dev/null
+++ b/src/MapleFE/c/literal.spec
@@ -0,0 +1,118 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+#########################################################################
+##                          Integer                                    ##
+#########################################################################
+
+### Decimal rules
+
+rule NonZeroDigit   : ONEOF('1', '2', '3', '4', '5', '6', '7', '8', '9')
+rule Digit          : ONEOF('0', NonZeroDigit)
+rule DecimalNumeral : ONEOF('0', NonZeroDigit + ZEROORONE(Digit))
+
+### Hexadecimal rules
+
+rule HexDigit   : ONEOF('0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        'a', 'b', 'c', 'd', 'e', 'f',
+                        'A', 'B', 'C', 'D', 'E', 'F')
+rule HexNumeral : ONEOF("0x" + HexDigit, "0X" + HexDigit)
+
+### Octal rules
+
+rule OctalDigit   : ONEOF('0', '1', '2', '3', '4', '5', '6', '7')
+rule OctalNumeral : ONEOF('0' + OctalDigit)
+
+rule IntegerTypeSuffix : ONEOF('L', 'l')
+rule DecimalIntegerLiteral: DecimalNumeral + ZEROORONE(IntegerTypeSuffix)
+rule HexIntegerLiteral    : HexNumeral + ZEROORONE(IntegerTypeSuffix)
+rule OctalIntegerLiteral  : OctalNumeral + ZEROORONE(IntegerTypeSuffix)
+
+rule IntegerLiteral: ONEOF(DecimalIntegerLiteral,
+                           HexIntegerLiteral,
+                           OctalIntegerLiteral)
+
+#########################################################################
+##                       Floating Point                                ##
+#########################################################################
+
+##### Decimal floating point literal
+
+rule Sign : ONEOF('+', '-')
+rule FloatTypeSuffix : ONEOF('f', 'F')
+rule ExponentIndicator : ONEOF('e', 'E')
+rule SignedInteger : ZEROORONE(Sign) + Digit
+rule ExponentPart : ExponentIndicator + SignedInteger
+
+rule DecFPLiteral : ONEOF(Digit + '.' + ZEROORONE(Digit) + ZEROORONE(ExponentPart) + ZEROORONE(FloatTypeSuffix),
+                    '.'+Digit + ZEROORONE(ExponentPart) + ZEROORONE(FloatTypeSuffix),
+                    Digit + ExponentPart + ZEROORONE(FloatTypeSuffix),
+                    Digit + ZEROORONE(ExponentPart))
+
+####### Hex floating point literal
+
+rule BinaryExponentIndicator : ONEOF('p', 'P')
+rule BinaryExponent : BinaryExponentIndicator + SignedInteger
+rule HexSignificand : ONEOF(HexNumeral + ZEROORONE('.'),
+                            "0x" + ZEROORONE(HexDigit) + '.' + HexDigit,
+                            "0X" + ZEROORONE(HexDigit) + '.' + HexDigit)
+rule HexFPLiteral: HexSignificand + BinaryExponent + ZEROORONE(FloatTypeSuffix)
+
+######  Floating Point Literal
+
+rule FPLiteral : ONEOF(DecFPLiteral, HexFPLiteral)
+
+#########################################################################
+##                           Boolean                                   ##
+#########################################################################
+
+rule BooleanLiteral : ONEOF ("true", "false")
+
+#########################################################################
+##                           Character                                 ##
+## ESCAPE is a reserved rule in reserved.spec.                         ##
+#########################################################################
+
+rule UnicodeEscape: '\' + 'u' + HEXDIGIT + HEXDIGIT + HEXDIGIT + HEXDIGIT
+rule RawInputCharacter : ONEOF(ASCII, ''', ESCAPE)
+rule SingleCharacter: ONEOF(UnicodeEscape, RawInputCharacter)
+
+rule OctalEscape : ONEOF('\' + '0', '\' + '1')
+rule EscapeSequence : ONEOF(ESCAPE, OctalEscape)
+rule CharacterLiteral : ''' + ONEOF(SingleCharacter, EscapeSequence) + '''
+
+#########################################################################
+##                           String                                    ##
+#########################################################################
+# The UnicodeEscape is limited from \u0000 to \u00ff.
+rule StringUnicodeEscape: '\' + 'u' + '0' + '0' + HEXDIGIT + HEXDIGIT
+rule StringCharater: ONEOF(StringUnicodeEscape, RawInputCharacter)
+rule StringLiteral : '"' + ZEROORMORE(StringCharater) + '"'
+
+#########################################################################
+##                           Null                                      ##
+#########################################################################
+
+rule NullLiteral : "NULL"
+
+#########################################################################
+##                           Literal                                   ##
+#########################################################################
+
+rule Literal : ONEOF(IntegerLiteral,
+                     FPLiteral,
+                     BooleanLiteral,
+                     CharacterLiteral,
+                     StringLiteral,
+                     NullLiteral)
\ No newline at end of file
diff --git a/src/MapleFE/c/operator.spec b/src/MapleFE/c/operator.spec
new file mode 100644
index 0000000000000000000000000000000000000000..eac023f63e58c861984945d34559c511e2c45daf
--- /dev/null
+++ b/src/MapleFE/c/operator.spec
@@ -0,0 +1,54 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+STRUCT Operator : ONEOF(
+                    # Arithmetic
+                    ("+",    Add),
+                    ("-",    Sub),
+                    ("*",    Mul),
+                    ("/",    Div),
+                    ("%",    Mod),
+                    ("++",   Inc),
+                    ("--",   Dec),
+                    # Relation
+                    ("==",   EQ),
+                    ("!=",   NE),
+                    (">",    GT),
+                    ("<",    LT),
+                    (">=",   GE),
+                    ("<=",   LE),
+                    # Bitwise
+                    ("&",    Band),
+                    ("|",    Bor),
+                    ("^",    Bxor),
+                    ("~",    Bcomp),
+                    # Shift
+                    ("<<",   Shl),
+                    (">>",   Shr),
+                    # Logical
+                    ("&&",   Land),
+                    ("||",   Lor),
+                    ("!",    Not),
+                    # Assign
+                    ("=",    Assign),
+                    ("+=",   AddAssign),
+                    ("-=",   SubAssign),
+                    ("*=",   MulAssign),
+                    ("/=",   DivAssign),
+                    ("%=",   ModAssign),
+                    ("<<=",  ShlAssign),
+                    (">>=",  ShrAssign),
+                    ("&=",   BandAssign),
+                    ("|=",   BorAssign),
+                    ("^=",   BxorAssign))
\ No newline at end of file
diff --git a/src/MapleFE/c/separator.spec b/src/MapleFE/c/separator.spec
new file mode 100644
index 0000000000000000000000000000000000000000..dd37454e81425f720a84c45ab4e96d2a0f4f311f
--- /dev/null
+++ b/src/MapleFE/c/separator.spec
@@ -0,0 +1,29 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+STRUCT Separator : ((" ", Whitespace),
+                    ("(", Lparen),
+                    (")", Rparen),
+                    ("{", Lbrace),
+                    ("}", Rbrace),
+                    ("[", Lbrack),
+                    ("]", Rbrack),
+                    (";", Semicolon),
+                    (",", Comma),
+                    (".", Dot),
+                    ("...", Dotdotdot),
+                    (":", Colon),
+                    ("?", Select),
+                    ("::", Of),
+                    ("#", Pound))
\ No newline at end of file
diff --git a/src/MapleFE/c/src/Makefile b/src/MapleFE/c/src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..c6cb1db128a3572f42d7043f1a9bf8d4fdf58bfc
--- /dev/null
+++ b/src/MapleFE/c/src/Makefile
@@ -0,0 +1,80 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+include ../../Makefile.in
+BUILDBIN=$(BUILDDIR)/bin
+BUILD=$(BUILDDIR)/c
+BUILDGEN=$(BUILDDIR)/gen
+BUILDASTGEN=$(BUILDDIR)/ast_gen/shared
+$(shell $(MKDIR_P) $(BUILD) $(BUILDGEN))
+
+SRC=$(wildcard *.cpp)
+OBJ :=$(patsubst %.cpp,%.o,$(SRC))
+DEP :=$(patsubst %.cpp,%.d,$(SRC))
+
+SRCG := $(wildcard $(BUILDGEN)/gen*.cpp)
+OBJG := $(patsubst %.cpp, %.o, $(SRCG))
+DEPG := $(patsubst %.cpp, %.d, $(SRCG))
+
+OBJS :=$(foreach obj,$(OBJ), $(BUILD)/$(obj)) $(OBJG)
+DEPS :=$(foreach dep,$(DEP), $(BUILD)/$(dep)) $(DEPG)
+
+INCLUDES := -I $(MAPLEFE_ROOT)/shared/include \
+            -I $(MAPLEFE_ROOT)/c/include \
+            -I $(MAPLEFE_ROOT)/autogen/include \
+            -I ${BUILDDIR}/ast_gen/shared \
+            -I $(BUILDGEN)
+
+INCLUDEGEN := -I $(BUILDGEN) -I $(MAPLEFE_ROOT)/shared/include
+
+TARGET=c2ast
+
+SHAREDLIB = $(BUILDDIR)/shared/shared.a $(BUILDASTGEN)/genast.a
+
+.PHONY: all
+all: $(BUILDBIN)/$(TARGET)
+
+-include $(DEPS)
+.PHONY: clean
+
+vpath %.o $(BUILD)
+vpath %.d $(BUILD)
+
+# Pattern Rules
+$(BUILD)/%.o : %.cpp
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
+
+$(BUILD)/%.d : %.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $< > $@
+	@mv -f $(BUILD)/$*.d $(BUILD)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
+	@rm -f $(BUILD)/$*.d.tmp
+
+$(BUILDGEN)/%.o : $(BUILDGEN)/%.cpp $(BUILDGEN)/%.d
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDEGEN) -w -c $< -o $@
+
+$(BUILDGEN)/%.d : $(BUILDGEN)/%.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDEGEN) $< > $@
+	@mv -f $(BUILDGEN)/$*.d $(BUILDGEN)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILDGEN)/$*.o:|' < $(BUILDGEN)/$*.d.tmp > $(BUILDGEN)/$*.d
+	@rm -f $(BUILDGEN)/$*.d.tmp
+
+# TARGET depends on OBJS and shared OBJS from shared directory
+# as well as mapleall libraries
+$(BUILDBIN)/$(TARGET): $(OBJS) $(SHAREDLIB)
+	@mkdir -p $(BUILDBIN)
+	$(LD) -o $(BUILDBIN)/$(TARGET) $(OBJS) $(SHAREDLIB) -lstdc++fs
+
+clean:
+	rm -rf $(BUILD)
diff --git a/src/MapleFE/c/src/lang_spec.cpp b/src/MapleFE/c/src/lang_spec.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d3fd8113c8b85c1770822f1b9b324b860407c410
--- /dev/null
+++ b/src/MapleFE/c/src/lang_spec.cpp
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "lang_spec.h"
+#include "stringpool.h"
+
+namespace maplefe {
+float  StringToValueImpl::StringToFloat(std::string &s) {
+  return stof(s);
+}
+
+double StringToValueImpl::StringToDouble(std::string &s) {
+  std::string str = s;
+  char suffix = str[str.length() - 1];
+  if (suffix == 'l' || suffix == 'L')
+    str[str.length() - 1] = 'L';
+  return stod(str);
+}
+
+bool StringToValueImpl::StringToBool(std::string &s) {
+  if ((s.size() == 4) && (s.compare("true") == 0))
+    return true;
+  else if ((s.size() == 5) && (s.compare("false") == 0))
+    return false;
+  else
+    MERROR("unknown bool literal");
+}
+
+bool StringToValueImpl::StringIsNull(std::string &s) {return false;}
+
+static char DeEscape(char c) {
+  switch(c) {
+    case 'b':
+      return '\b';
+    case 't':
+      return '\t';
+    case 'n':
+      return '\n';
+    case 'f':
+      return '\f';
+    case 'r':
+      return '\r';
+    case '"':
+      return '\"';
+    case '\'':
+      return '\'';
+    case '\\':
+      return '\\';
+    case '0':
+      return '\0';
+    default:
+      MERROR("Unsupported in DeEscape().");
+  }
+}
+
+static int char2int(char c) {
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  else if (c >= 'a' && c <= 'f')
+    return c - 'a' + 10;
+  else if (c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+  else
+    MERROR("Unsupported char in char2int().");
+}
+
+Char StringToValueImpl::StringToChar(std::string &s) {
+  Char ret_char;
+  ret_char.mIsUnicode = false;
+  MASSERT (s[0] == '\'');
+  if (s[1] == '\\') {
+    if (s[2] == 'u') {
+      ret_char.mIsUnicode = true;
+      int first = char2int(s[3]);
+      int second = char2int(s[4]);
+      int third = char2int(s[5]);
+      int forth = char2int(s[6]);
+      MASSERT(s[7] == '\'');
+      ret_char.mData.mUniValue = (first << 12) + (second << 8)
+                                 + (third << 4) + forth;
+    } else {
+      ret_char.mData.mChar = DeEscape(s[2]);
+    }
+  } else {
+    MASSERT(s[2] == '\'');
+    ret_char.mData.mChar = s[1];
+  }
+  return ret_char;
+}
+
+LitData ProcessLiteral(LitId id, const char *str) {
+  LitData data;
+  std::string value_text(str);
+  StringToValueImpl s2v;
+
+  switch (id) {
+    case LT_IntegerLiteral: {
+      int i = s2v.StringToInt(value_text);
+      data.mType = LT_IntegerLiteral;
+      data.mData.mInt = i;
+      break;
+    }
+    case LT_FPLiteral: {
+      char suffix = value_text[value_text.length() - 1];
+      if (suffix == 'f' || suffix == 'F') {
+        float f = s2v.StringToFloat(value_text);
+        data.mType = LT_FPLiteral;
+        data.mData.mFloat = f;
+      } else {
+        double d = s2v.StringToDouble(value_text);
+        data.mType = LT_DoubleLiteral;
+        data.mData.mDouble = d;
+      }
+      break;
+    }
+    case LT_BooleanLiteral: {
+      bool b = s2v.StringToBool(value_text);
+      data.mType = LT_BooleanLiteral;
+      data.mData.mBool = b;
+      break; }
+    case LT_CharacterLiteral: {
+      Char c = s2v.StringToChar(value_text);
+      data.mType = LT_CharacterLiteral;
+      data.mData.mChar = c;
+      break; }
+    case LT_StringLiteral: {
+      const char *s = s2v.StringToString(value_text);
+      data.mType = LT_StringLiteral;
+      data.mData.mStrIdx = gStringPool.GetStrIdx(s);
+      break; }
+    case LT_NullLiteral: {
+      // Just need set the id
+      data.mType = LT_NullLiteral;
+      break; }
+    case LT_NA:    // N/A,
+    default:
+      data.mType = LT_NA;
+      break;
+  }
+
+  return data;
+}
+
+Lexer* CreateLexer() {
+  Lexer *lexer = new CLexer();
+  return lexer;
+}
+
+}
diff --git a/src/MapleFE/c/src/main.cpp b/src/MapleFE/c/src/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b055675ccd5e23deec5d5292167d7cea2d3a57a6
--- /dev/null
+++ b/src/MapleFE/c/src/main.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <fstream>
+#include "parser.h"
+#include "token.h"
+#include "common_header_autogen.h"
+#include "ruletable_util.h"
+#include "gen_summary.h"
+#include "gen_aststore.h"
+#include "gen_astdump.h"
+#include "gen_astgraph.h"
+
+static void help() {
+  std::cout << "c sourcefile [options]:\n" << std::endl;
+  std::cout << "   --help            : print this help" << std::endl;
+  std::cout << "   --trace-lexer     : Trace lexing" << std::endl;
+  std::cout << "   --trace-table     : Trace rule table when entering and exiting" << std::endl;
+  std::cout << "   --trace-left-rec  : Trace left recursion parsing" << std::endl;
+  std::cout << "   --trace-appeal    : Trace appeal process" << std::endl;
+  std::cout << "   --trace-failed    : Trace failed tokens of table" << std::endl;
+  std::cout << "   --trace-timing    : Trace parsing time" << std::endl;
+  std::cout << "   --trace-stack     : Trace visited-token stack of table" << std::endl;
+  std::cout << "   --trace-sortout   : Trace SortOut" << std::endl;
+  std::cout << "   --trace-ast-build : Trace AST Builder" << std::endl;
+  std::cout << "   --trace-patch-was-succ : Trace Patching of WasSucc nodes" << std::endl;
+  std::cout << "   --trace-warning   : Print Warning" << std::endl;
+  std::cout << "   --dump-ast        : Dump AST in text format" << std::endl;
+  std::cout << "   --dump-dot        : Dump AST in dot format" << std::endl;
+}
+
+int main (int argc, char *argv[]) {
+  if (argc == 1 || (!strncmp(argv[1], "--help", 6) && (strlen(argv[1]) == 6))) {
+    help();
+    exit(-1);
+  }
+
+  maplefe::Parser *parser = new maplefe::Parser(argv[1]);
+
+  bool dump_ast = false;
+  bool dump_dot = false;
+  bool succ;
+
+  // Parse the argument
+  for (unsigned i = 2; i < argc; i++) {
+    if (!strncmp(argv[i], "--trace-lexer", 13) && (strlen(argv[i]) == 13)) {
+      parser->SetLexerTrace();
+    } else if (!strncmp(argv[i], "--trace-table", 13) && (strlen(argv[i]) == 13)) {
+      parser->mTraceTable = true;
+    } else if (!strncmp(argv[i], "--trace-left-rec", 16) && (strlen(argv[i]) == 16)) {
+      parser->mTraceLeftRec = true;
+    } else if (!strncmp(argv[i], "--trace-appeal", 14) && (strlen(argv[i]) == 14)) {
+      parser->mTraceAppeal = true;
+    } else if (!strncmp(argv[i], "--trace-stack", 13) && (strlen(argv[i]) == 13)) {
+      parser->mTraceVisited = true;
+    } else if (!strncmp(argv[i], "--trace-failed", 14) && (strlen(argv[i]) == 14)) {
+      parser->mTraceFailed = true;
+    } else if (!strncmp(argv[i], "--trace-timing", 14) && (strlen(argv[i]) == 14)) {
+      parser->mTraceTiming = true;
+    } else if (!strncmp(argv[i], "--trace-sortout", 15) && (strlen(argv[i]) == 15)) {
+      parser->mTraceSortOut = true;
+    } else if (!strncmp(argv[i], "--trace-ast-build", 17) && (strlen(argv[i]) == 17)) {
+      parser->mTraceAstBuild = true;
+    } else if (!strncmp(argv[i], "--trace-patch-was-succ", 22) && (strlen(argv[i]) == 22)) {
+      parser->mTracePatchWasSucc = true;
+    } else if (!strncmp(argv[i], "--trace-warning", 15) && (strlen(argv[i]) == 15)) {
+      parser->mTraceWarning = true;
+    } else if (!strncmp(argv[i], "--dump-ast", 10) && (strlen(argv[i]) == 10)) {
+      dump_ast = true;
+    } else if (!strncmp(argv[i], "--dump-dot", 10) && (strlen(argv[i]) == 10)) {
+      dump_dot = true;
+    } else {
+      std::cerr << "unknown option " << argv[i] << std::endl;
+      exit(-1);
+    }
+  }
+
+  parser->InitRecursion();
+  succ = parser->Parse();
+  if (!succ) {
+    delete parser;
+    return 1;
+  }
+
+  // the module from parser
+  maplefe::ModuleNode *module = parser->GetModule();
+
+  if(dump_ast) {
+    maplefe::AstDump astdump(module);
+    astdump.Dump("c2ast: Initial AST", &std::cout);
+  }
+
+  if(dump_dot) {
+    maplefe::AstGraph graph(module);
+    graph.DumpGraph("c2ast: Initial AST", &std::cout);
+  }
+
+  maplefe::AstStore saveAst(module);
+  saveAst.StoreInAstBuf();
+  maplefe::AstBuffer &ast_buf = saveAst.GetAstBuf();
+
+  std::ofstream ofs;
+  std::string fname(module->GetFilename());
+  fname = fname.replace(fname.find(".c"), 2, ".mast");
+  ofs.open(fname, std::ofstream::out);
+  const char *addr = (const char *)(&(ast_buf[0]));
+  ofs.write(addr, ast_buf.size());
+  ofs.close();
+
+  delete parser;
+  return 0;
+}
diff --git a/src/MapleFE/c/stmt.spec b/src/MapleFE/c/stmt.spec
new file mode 100644
index 0000000000000000000000000000000000000000..f71d36b960266b2d4a5e42e799f73bf60a0223ff
--- /dev/null
+++ b/src/MapleFE/c/stmt.spec
@@ -0,0 +1,163 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+######################################################################
+#                        Expression                                  #
+######################################################################
+
+rule PrimaryExpression : ONEOF(
+  Literal,
+  Identifier
+)
+
+rule DimExprs : DimExpr + ZEROORMORE(DimExpr)
+
+rule DimExpr :  '[' + Expression + ']'
+
+rule Expression : ONEOF(
+  PrimaryExpression,
+  UnaryExpression)
+
+rule UnaryExpression : ONEOF(
+  PreIncrementExpression,
+  PreDecrementExpression,
+  PostIncrementExpression,
+  PostDecrementExpression)
+
+rule PreIncrementExpression : "++" + PrimaryExpression
+  attr.action : BuildUnaryOperation(%1, %2)
+
+rule PreDecrementExpression : "--" + PrimaryExpression
+  attr.action : BuildUnaryOperation(%1, %2)
+
+rule PostIncrementExpression : PrimaryExpression + "++"
+  attr.action : BuildPostfixOperation(%2, %1)
+
+rule PostDecrementExpression : PrimaryExpression + "--"
+  attr.action : BuildPostfixOperation(%2, %1)
+
+######################################################################
+#                         Variable                                   #
+######################################################################
+
+rule GlobalVariableDeclarationStatement : VariableDeclaration + ';'
+  attr.property : Top
+
+rule LocalVariableDeclarationStatement : VariableDeclaration + ';'
+
+rule VariableDeclaration : ZEROORMORE(VariableModifier) + Type + VariableDeclaratorList
+  attr.action: BuildDecl(%2, %3)
+  attr.action: AddModifier(%1)
+
+rule VariableModifier : ONEOF(
+  "static",
+  "const",
+  "volatile",
+  "restrict")
+
+rule VariableDeclaratorList : VariableDeclarator + ZEROORMORE(',' + VariableDeclarator)
+  attr.action: BuildVarList(%1, %2)
+
+rule VariableDeclarator : VariableDeclaratorId + ZEROORONE('=' + VariableInitializer)
+  attr.action: AddInitTo(%1, %2)
+
+rule VariableDeclaratorId : Identifier + ZEROORONE(Dims)
+  attr.action: AddDimsTo(%1, %2)
+
+rule VariableInitializer : ONEOF(
+  Expression,
+  ArrayInitializer)
+
+rule ArrayInitializer : '{' + ZEROORONE(VariableInitializerList) + ZEROORONE(',') + '}'
+
+rule VariableInitializerList: VariableInitializer + ZEROORMORE(',' + VariableInitializer)
+
+rule Dims : Dim + ZEROORMORE(Dim)
+ attr.action: BuildDims(%1, %2)
+
+rule Dim  :  '[' + ']'
+ attr.action: BuildDim(%1)
+
+######################################################################
+#                         statement                                  #
+######################################################################
+
+rule Statement : ONEOF(LocalVariableDeclarationStatement,
+                       ExpressionStatement,
+                       ReturnStatement)
+  attr.property: Single
+
+rule ExpressionStatement : StatementExpression + ';'
+
+rule StatementExpression : ONEOF(
+  PreIncrementExpression,
+  PreDecrementExpression,
+  PostIncrementExpression,
+  PostDecrementExpression,
+  )
+  attr.property: Single
+
+rule ReturnStatement : "return" + ZEROORONE(Expression) + ';'
+  attr.action : BuildReturn(%2)
+
+
+######################################################################
+#                         Function                                   #
+######################################################################
+
+rule GlobalFuncDeclaration : FuncDeclaration
+  attr.property : Top
+
+rule FuncDeclaration : ZEROORMORE(FuncModifier) + FuncHeader + FuncBody
+  attr.action: AddModifierTo(%2, %1)
+  attr.action: AddFunctionBodyTo(%2, %3)
+
+rule FuncBody        : ONEOF(Block, ';')
+  attr.property : Single
+
+rule FuncHeader      : ONEOF(Result + FuncDeclarator)
+  attr.action.%1: AddType(%2, %1)
+  attr.property : Single
+
+rule Result            : ONEOF(Type, "void")
+  attr.property : Single
+
+rule FuncDeclarator  : Identifier + '(' + ZEROORONE(FormalParameters) + ')'
+  attr.action: BuildFunction(%1)
+  attr.action: AddParams(%3)
+
+rule FuncAttr : ONEOF("const", "static")
+  attr.property : Single
+
+rule FuncModifier : ONEOF(FuncAttr)
+  attr.property : Single
+
+rule FormalParameters  : ONEOF(FormalParameter + ZEROORMORE(',' + FormalParameter))
+  attr.property : Single
+
+rule FormalParameter   : ZEROORMORE(VariableModifier) + Type + VariableDeclaratorId
+  attr.action: BuildDecl(%2, %3)
+  attr.action: AddModifier(%1)
+
+######################################################################
+#                        Block                                       #
+######################################################################
+
+rule BlockStatement  : ONEOF(LocalVariableDeclarationStatement, Statement)
+  attr.property : Single
+
+rule BlockStatements : BlockStatement + ZEROORMORE(BlockStatement)
+
+rule Block           : '{' + ZEROORONE(BlockStatements) + '}'
+  attr.action: BuildBlock(%2)
diff --git a/src/MapleFE/c/type.spec b/src/MapleFE/c/type.spec
new file mode 100644
index 0000000000000000000000000000000000000000..af2d02bbb43ecb326acb4a3722ef4c981d76285a
--- /dev/null
+++ b/src/MapleFE/c/type.spec
@@ -0,0 +1,37 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+STRUCT Keyword : (("char", Char),
+                  ("short", Short),
+                  ("int", Int),
+                  ("long", Long),
+                  ("float", Float),
+                  ("double", Double),
+                  ("void", Void),
+                  ("_Bool", Boolean))
+
+rule BooleanType : "_Bool"
+rule IntType : ONEOF("char", "unsigned" + "char", "signed" + "char",
+                     "short", "unsigned" + "short", "signed" + "short",
+                     "int", "unsigned" + "int", "signed" + "int", "unsigned", "signed",
+                     "long", "unsigned" + "long", "signed" + "long")
+rule FPType  : ONEOF("float", "double")
+rule NumericType : ONEOF(IntType, FPType)
+
+rule PrimitiveType : ONEOF(NumericType, BooleanType)
+rule TypeVariable  : Identifier
+
+rule NonePointerType : ONEOF(PrimitiveType, TypeVariable)
+rule PointerType : NonePointerType + '*' + ZEROORMORE('*')
+rule Type : ONEOF(NonePointerType, PointerType)
\ No newline at end of file
diff --git a/src/MapleFE/docs/astdump.md b/src/MapleFE/docs/astdump.md
new file mode 100644
index 0000000000000000000000000000000000000000..7f68eeff72608372e0ba4d81e8a7296497013c37
--- /dev/null
+++ b/src/MapleFE/docs/astdump.md
@@ -0,0 +1,45 @@
+## Overview
+
+The `astdump.sh` tool is a bash script which executes the `ts2cpp` binary executable with option
+`--trace-a2c` to dump the AST and CFG graphs of a TypeScript program.
+
+It also dump the TypeScript code converted from the corresponding AST with AST emitter. 
+
+## Usage to astdump.sh
+
+```bash
+Usage: astdump.sh [-dot] [-f|--fullscreen] [-p <PREFIX>|--pre <PREFIX>] [-a|--ast] [-c|--cfg] [-A|--all] [-C|--clean] <file1> [<file2> ...]
+
+  -d | --dot             Use Graphviz dot to generate the graph and view it with viewnior
+  -f | --fullscreen      View the generated graph in fullscreen mode. It implies option -dot
+  -p | --pre <PREFIX>    Filter graphs with the specified <PREFIX>, e.g. -p "CFG_<function-name>"
+  -a | --ast             Show AST graph. It is equivalent to options "-dot -p AST"
+  -c | --cfg             Show CFG graph. It is equivalent to options "-dot -p CFG"
+  -s | --syntax          Syntax highlighting the generated TypeScript code
+  -A | --all             Process all .ts files in current directory excluding *.ts-[0-9]*.out.ts
+  -C | --clean           Clean up generated files (*.ts-[0-9]*.out.ts)
+  <file1> [<file2> ...]  Specify one or more TypeScript files to be processed
+```
+## Example with binary-search.ts
+
+You can execute the following commands to get the CFG graph of the test case `binary-search.ts`, and the
+TypeScript code converted from the corresponding AST.
+
+### 1. Command lines
+```bash
+cd MapleFE/test/typescript/unit_tests
+../../astdump.sh --cfg --syntax binary-search.ts
+```
+
+### 2. CFG graph of function "binarySearch"
+
+This is the CFG graph of function `binarySearch`.
+
+<img src="https://images.gitee.com/uploads/images/2021/0514/151722_a7245ff7_5583371.png" height="480">
+
+### 3. TypeScript code converted from the corresponding AST
+
+This is the TypeScript code generated from AST.
+
+<img src="https://images.gitee.com/uploads/images/2021/0514/152039_16636b7d_5583371.png" height="360">
+
diff --git a/src/MapleFE/docs/astvisitor.md b/src/MapleFE/docs/astvisitor.md
new file mode 100644
index 0000000000000000000000000000000000000000..6a579350701c0463ca903e31834acd571ad792f6
--- /dev/null
+++ b/src/MapleFE/docs/astvisitor.md
@@ -0,0 +1,86 @@
+## Overview of AstVisitor
+
+The `AstVisitor` class is to let you be able to traverse an AST in a depth-first manner and call a visitor
+function for each node in the AST. Each visitor function for a tree node  can be overridden by a customized
+visitor in a derived class of `AstVisitor`. 
+
+A customized visitor enable you to gather any interesting information of a tree node and replace this tree
+node with another which the customized visitor returns.
+
+## Creat your own visitors in a derived class of AstVisitor
+
+First of all, you need to derive a class from `AstVisitor` and implement your own visitors for any nodes to
+be processed. 
+
+Here is an example. The class `MyVisitor` is derived from `AstVisitor` and has two customized visitors
+implemented for `CondBranchNode`. 
+ 
+
+```c
+class MyVisitor : public AstVisitor {
+  ... ...
+  CondBranchNode *VisitCondBranchNode(CondBranchNode *node);
+}
+```
+
+```c
+CondBranchNode *MyVisitor::VisitCondBranchNode(CondBranchNode *node) {
+  // Do something as needed
+  ...
+  // Call AstVisitor::VisitCondBranchNode to traverse subtrees of this node if needed
+  AstVisitor::VisitCondBranchNode(node);
+  return node;
+}
+```
+
+## Replace a tree node with another one
+
+You may replace a tree node with another one with your customized visitor. 
+
+```c
+CondBranchNode *MyVisitor::VisitCondBranchNode(CondBranchNode *node) {
+  // Do something as needed
+  ...
+  // Create a new CondBranchNode node to replace the current one
+  CondBranchNode *new_node = ...;
+  return new_node;
+}
+```
+
+The customized visitor `MyVisitor::VisitCondBranchNode()` visits a node which is the root of a subtree, 
+and replace this node with `new_node` which is the root of another subtree. This provides a way to
+transform a subtree into a new subtree when needed.
+
+## How does the replacement work?
+
+The `AstVisitor` class is declared and defined in `MapleFE/output/typescript/ast_gen/shared/gen_astvisitor.{h,cpp}`.
+
+```c
+BlockNode *AstVisitor::VisitBlockNode(BlockNode *node) {
+  if (node != nullptr) {
+    if (mTrace) {
+      std::cout << "Visiting BlockNode, id=" << node->GetNodeId() << "..." << std::endl;
+    }
+
+    for (unsigned i = 0; i < node->GetChildrenNum(); ++i) {
+      if (auto t = node->GetChildAtIndex(i)) {
+        auto n = VisitTreeNode(t);
+        if (n != t) {                     // If the returned node 'n' is not the same as 't'
+          node->SetChildAtIndex(i, n);    // the current child node `t` of BlockNode is replaced with 'n'
+        }
+      }
+    }
+
+    if (auto t = node->GetSync()) {
+      auto n = VisitTreeNode(t);
+      if (n != t) {                       // Similar as mentioned above
+        node->SetSync(n);
+      }
+    }
+  }
+  return node;
+}
+```
+
+if a `CondBranchNode` node is a child of a `BlockNode` node, and `MyVisitor::VisitCondBranchNode()` returns
+a new node, this child node of the `BlockNode` node will be replaced with the one returned.
diff --git a/src/MapleFE/docs/builtin-constructors.md b/src/MapleFE/docs/builtin-constructors.md
new file mode 100644
index 0000000000000000000000000000000000000000..aa844737710707a03f7a67d1b7751fb919b9b24c
--- /dev/null
+++ b/src/MapleFE/docs/builtin-constructors.md
@@ -0,0 +1,123 @@
+
+## JavaScript built-in objects
+
+JavaScript built-in object info is available at:
+
+### 1. ECMA-262 standard
+https://262.ecma-international.org/12.0/#sec-ecmascript-standard-built-in-objects
+```
+Under sections:
+  19 The Global Object
+  20 Fundamental Objects
+  21 Numbers and Dates
+  22 Text Processing
+  23 Indexed Collections
+  24 Keyed Collections
+  25 Structured Data
+```
+
+### 2. Mozilla Developer docs
+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference under Built-in objects
+
+## JavaScript built-in object constructors
+
+Not all built-in objects work as object constructors. The following is a list of 
+JavaScript built-in objects that works as object constructors to create objects
+of corresponding built-in type:
+
+### 1. List of JavaScript built-in object constructors
+```
+  1 AggregateError
+  2 Array
+  3 ArrayBuffer
+  4 AsyncFunction
+  5 BigInt64Array
+  6 BigUint64Array
+  7 Boolean
+  8 DataView
+  9 Date
+ 10 Error
+ 11 EvalError
+ 12 FinalizationRegistry
+ 13 Float32Array
+ 14 Float64Array
+ 15 Function
+ 16 Generator
+ 17 GeneratorFunction
+ 18 Int16Array
+ 19 Int32Array
+ 20 Int8Array
+ 21 InternalError (Mozilla only)
+ 22 Map
+ 23 Number
+ 24 Object
+ 25 Promise
+ 26 Proxy
+ 27 RangeError
+ 28 ReferenceError
+ 29 RegExp
+ 30 Set
+ 31 SharedArrayBuffer
+ 32 String
+ 33 Symbol
+ 34 SyntaxError
+ 35 TypeError
+ 36 Uint16Array
+ 37 Uint32Array
+ 38 Uint8Array
+ 39 Uint8ClampedArray
+ 40 URIError
+ 41 WeakMap
+ 42 WeakRef
+ 43 WeakSet
+```
+
+### 2. JavaScript builtin String/Number/Boolean object constructor and string/number/boolean primitive
+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#string_primitives_and_string_objects
+
+"Note that JavaScript distinguishes between String objects and primitive string values. (The same is true of Boolean and Numbers.)
+
+String literals (denoted by double or single quotes) and strings returned from String calls in a non-constructor context (that is, called without using the new keyword) are primitive strings. JavaScript automatically converts primitives to String objects, so that it's possible to use String object methods for primitive strings. In contexts where a method is to be invoked on a primitive string or a property lookup occurs, JavaScript will automatically wrap the string primitive and call the method or perform the property lookup."
+```
+  1 var s1 : string = "test";             // string literal
+  2 var s2 : String = "test";             // string literal
+  3 var s3 : string = String("test");     // string literal
+  4 var s4 : String = String("test");     // string literal
+  5 var s5 : String = new String("test"); // String object
+  6 console.log(typeof(s1));     // string
+  7 console.log(s1.slice(1,2));  // string literal s1 wrapped/converted to String object for call
+  8 console.log(typeof(s2));     // string
+  9 console.log(typeof(s3));     // string
+ 10 console.log(typeof(s4));     // string
+ 11 console.log(typeof(s5));     // object
+```
+
+For TypeScript to C++ mapping, string primitive maps to std::string, and String objects maples to builtin String object t2crt::String (same for Booelan and Numbers).
+
+The type returned by JavaScript/TypeScript String/Number/Boolean builtin/constructor function depends on the usage:
+- when used as a function, it is a type converter (convert between literal typeis), returns primitve/literal type string/number/boolean
+- when used with new op(), it is a constructor and returns an object
+- A variable declared as primitve type string/number/boolean will be wrapped/converted to a String/Number/Boolean object if any object property/method is referenced
+  For TypeScript to C++, this conversion can be done by the runtime, but there is opportunity for optimization if it can be determined at compile time whether a primitive will be used as an object, in which case the primitve literal can be generated as object intead.
+
+
+## TypeScript types
+
+Additionally these TypeScript types will be treated as built-in object types too:
+- Record
+- Tuple
+- Iterable
+- Iterator 
+
+### 1. Record and Tuple types
+Record and Tuple currently are TypeScript only types. They are
+not ECMA-262 standard yet, but has been proposed and undergoing standardization.
+
+- https://tc39.es/proposal-record-tuple
+- https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types
+- https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type
+
+### 2. Iterable and Iterator types
+These are TypeScript types
+- https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-6.html#stricter-generators
+- https://www.typescriptlang.org/docs/handbook/iterators-and-generators.html#iterable-interface
diff --git a/src/MapleFE/docs/maplefe-autogen.md b/src/MapleFE/docs/maplefe-autogen.md
new file mode 100644
index 0000000000000000000000000000000000000000..843f2b6a7a7f2f506037b0e0624821a8a97568d7
--- /dev/null
+++ b/src/MapleFE/docs/maplefe-autogen.md
@@ -0,0 +1,138 @@
+## Overview
+The Python script `maplefe-autogen.py` is a tool to generate the code for class `AstVisitor`, `AstDump`, `AstGraph`,
+etc. for AST tree.
+
+Whenever a new kind of AST tree node is introduced for a new language feature in the future, or any changes are made
+to the existing AST tree node, these classes will be updated automatically. It reduces the maintenance effort and
+ensures the consistency and completeness of these classes.
+
+## How does it work?
+
+It makes use of `clang-doc-10` to parse source file `ast_builder.cpp` and get its documentation files in YAML format.
+These YAML files are fed into `maplefe-autogen.py` to generate C++ header and source files as described below.
+
+## What should I do to generate a new C++ class?
+
+Let's use `AstVisitor` as an example to explain it.
+
+### 1. Set filename, class name, prefix of function name and extra include directives
+
+```python
+gen_args = [
+        "gen_astvisitor", # Filename
+        "AstVisitor",     # Class name
+        "Visit",          # Prefix of function name
+        "",               # Extra include directives
+        ]
+```
+The list `gen_args` contains the filename, class name, prefix of function name and extra include directives for
+generating C++ header and source files. You have to use the list name `gen_args` for them.
+
+### 2. Define the specific content in header file
+
+```python
+astvisitor_init = [
+"""
+private:
+bool mTrace;
+
+public:
+{gen_args1}(bool t = false) : mTrace(t) {{}}
+
+TreeNode* {gen_args2}(TreeNode* node) {{
+  return {gen_args2}TreeNode(node);
+}}
+""".format(gen_args1=gen_args[1], gen_args2=gen_args[2])
+] # astvisitor_init
+```
+The list `astvisitor_init` contains the specific content in C++ header file. The list name can be customized.
+
+### 3. Set callback functions for each part of a C++ function for a AST node
+
+The following callback functions are defined for generating the code for `AstVisitor`.
+
+```python
+gen_call_handle_values = lambda: False
+```
+This function returns true or false.
+There are two kinds of fields in an AST node. One is a pointer to another AST node, and another is 
+a value with a non-AST-node type, such as enum, int, etc.
+If this function returns false, all non-AST-node values will be ignored.
+
+
+```python
+gen_func_declaration = lambda dictionary, node_name: ...
+```
+Function `gen_func_declaration` returns a string for the declaration of a function for an AST node `node_name`. The result will be in
+the C++ header file.
+
+
+```python
+gen_func_definition = lambda dictionary, node_name: ...
+```
+Function `gen_func_definition` returns a string for the definition of a function for an AST node `node_name`. The result will be in
+the C++ source file. Any code which occurs at the beginning of its function body can be placed here.
+
+
+```python
+gen_call_child_node = lambda dictionary, node_name, field_name, node_type, accessor: ...
+```
+Function `gen_call_child_node` returns a string with the statements to handle a child AST node `field_name`. The child node has
+`node_type` and you can use `accessor` to get its pointer value. 
+
+
+```python
+gen_call_children_node = lambda dictionary, node_name, field_name, node_type, accessor: ''
+```
+Function `gen_call_children_node` returns a string with the statements to handle a SmallVector or SmallList node `field_name` with
+`node_type`. The `accessor` can be used to get its pointer value. It returns an empty string for `AstVisitor`.
+
+
+```python
+gen_call_children_node_end = lambda dictionary, node_name, field_name, node_type, accessor: ''
+```
+Function `gen_call_children_node_end` returns a string with the statements following the for-loop for each value stored in the
+SmallVector or SmallList node `field_name`. It returns an empty string for `AstVisitor`. 
+
+
+```python
+gen_func_definition_end = lambda dictionary, node_name: '}\nreturn node;\n}'
+```
+Function `gen_func_definition_end` returns a string with the statements at the end of the function body.
+
+Since it does not need to handle any non-AST-node values, therefore some functions for values are missing for `AstVisitor`.
+
+### 4. Generate the code in C++ header and source files 
+
+Here is the code block for generating the C++ code.
+```python
+handle_src_include_files(Initialization)
+append(include_file, astvisitor_init)
+handle_yaml(initial_yaml, gen_handler)
+handle_src_include_files(Finalization)
+```
+
+It has to call `handle_src_include_files(Initialization)` and `handle_src_include_files(Finalization)` at the beginning and end of the block as shown above.
+
+```python
+append(include_file, astvisitor_init)
+```
+This is to append the code in list `astvisitor_init` to the C++ header file. 
+
+```python
+handle_yaml(initial_yaml, gen_handler)
+```
+This function call `handle_yaml(initial_yaml, gen_handler)` is to handle all related YAML file, call the `gen_func_*` and `gen_call_*` callback functions defined at step 3, and generate the code in C++ header and source files with them.
+
+## Where are the generated files located?
+
+They can be found under directory `MapleFE/output/typescript/ast_gen/shared/`.
+```bash
+MapleFE/output/typescript/ast_gen/shared/gen_astvisitor.h
+MapleFE/output/typescript/ast_gen/shared/gen_astvisitor.cpp
+```
+
+## Format of the generated C++ header and source files
+
+The generated C++ header and source files will be formatted with clang-format-10. You do not
+have to format the generated code manually.
diff --git a/src/MapleFE/docs/readme b/src/MapleFE/docs/readme
new file mode 100644
index 0000000000000000000000000000000000000000..9ff4bbefc70014338c1bd442785b82389db6b262
--- /dev/null
+++ b/src/MapleFE/docs/readme
@@ -0,0 +1,192 @@
+1. SOURCE CODE
+==============
+
+git clone https://gitee.com/openarkcompiler/OpenArkCompiler -b dev_MapleFE
+
+2. ENVIRONMENT
+==============
+System software versions used:
+  Ubuntu: 20.04
+  Typescript: 4.5.5
+  Nodejs: 14.7.0
+
+export MFE=~/OpenArkCompiler/src/MapleFE
+export tsbin=$MFE/output/typescript/bin
+export rtsrc=$MFE/ast2cpp/runtime/src
+export unit=$MFE/test/typescript/unit_tests
+export rtsrc=$MFE/ast2cpp/runtime/src
+alias runbld='cd $MFE;source envsetup.sh typescript;make -j16;cd -'
+alias runtest='rm cxx.log; ../ts2cxx-test.sh
+alias goutil='cd $MFE/test/typescript/utils'
+alias gofe='cd $MFE'
+alias gocpp='cd $MFE/ast2cpp/src'
+alias gort='cd $MFE/ast2cpp/runtime/include'
+alias gounit='cd $unit'
+
+- To build everything: runbld
+- To run unit tests:   cd $unit; runtest
+- To run single test:  cd $unit; ../ts2cxx-test.sh <xxx.ts>
+- To run TSC compile and nodejs execute of JS only for specific testcase:  cd $unit; ../tsc.sh <xxx.ts>
+- CPP emitter source code: $MFE/ast2cpp/src
+- MapleFe compiler toolsfor TSC:
+  o  xxx.ts -> [ast2cpp] -> xxx.ts.ast -> [ast2cpp] -> xxx.h xxx.cpp
+  o $tsbin/ts2ast        - Compile .ts into .ts.ast
+  o $tsbin/ast2cpp       - Compiles .ts.ast into .cpp or back into .ts (for verification)
+  o $MFE/test/astdump.sh - Dump AST tree from .ts.ast. Output can be text or graph.
+  o run each of above cmds to see parameters and options, e.g. $tsbin/ast2cpp will display:
+     ast2cpp a.ast[,b.ast] [options]:
+     --out=x.cpp      : cpp output file
+     --help           : print this help
+     --trace=n        : Emit trace with 4-bit combo levels 1...15
+                      1 : Emit ast tree visits
+                      2 : Emit graph
+     --emit-ts-only   : Emit ts code only
+     --emit-ts        : Emit ts code
+     --format-cpp     : Format cpp
+     ...
+- For graphic view of JavaScript object inheritance relations:
+  o cd $MFE/docs/util; node proto.js | ./viewdot.sh
+
+3. Run a single case from .ts
+  1) ~/OpenArkCompiler/src/MapleFE/output/typescript/bin/ts2ast while-stmt.ts
+     This creates while-stmt.ts.ast at the same directory
+  2) ~/OpenArkCompiler/src/MapleFE/output/typescript/bin/ast2cpp while-stmt.ts.ast
+     This generates the while-stmt.cpp
+  3) g++ -g -o run -I/home/ubuntu/OpenArkCompiler/src/MapleFE/ast2cpp/runtime/include -I/home/ubuntu/OpenArkCompiler/src/MapleFE/astopt/include -std=c++17 while-stmt.cpp /home/ubuntu/OpenArkCompiler/src/MapleFE/ast2cpp/runtime/src/*.cpp
+     This generates the executable run.
+  4) ./run to test the result.
+
+4. TypeScript/JavaScript inheritance modeling in C++
+====================================================
+
+4.1 JavaScript Object Properties
+
+JavaScript objects have both instance properties and inherited
+properties. Instance properties are held in the object's own property
+list. Inherited properties are held in an object pointed to by the
+instance property __proto__.
+
+The chain of __proto__ between objects forms a hierarchical prototype
+chain used in the lookup for an object's inherited properties. Inherited
+properites have only a single copy and is shared by all objects that
+inherits the property.
+
+In Javascript, object property lookup order is:
+- first lookup instance property (from property list of current object)
+- then lookup inherited property (from property list of object pointed to
+  by chain of __proto__ starting from __proto__ of current object
+
+4.2 TypeScript/JavaScript inheritance modeling in C++
+
+The inheritance relationship of TS/JS objects is mapped to C++ as
+classes derived hierarchically along the __proto__ chain. This allows
+accessing inherited properties directly as C++ fields and methods of
+parent classess, instead of having to traverse the __proto__ chain.
+
+To maintain continued support of property lookup by __proto__ chain
+traversal, each object has a proplist which is a C++ map of the object's
+property name and value pairs.
+
+Proplist entries for runtime created instance properties holds the
+actual property value. Proplist entries for properties generated as
+C++ class fields and methods at compile time holds pointers to class
+fields and methods.
+
+This guarantees continued functioning of run time property lookup
+using prop list and __proto__ chain traversal. This is necessary not
+only because of compatibility but also because TS objects can have
+instance properties created at runtime which can only be accessed
+through prop list because they cannot be generated as C++ class fields
+at compile time.
+
+To ensure inherited properties have only a single copy, all properties
+in prototype objects are generated at compile time as C++ static class
+fields and methods and accessed either via direct C++ object field
+reference, or via pointers from the prototype object's proplist.
+
+Note that where __proto__ points to a JavaScript function constructor
+instead of a prototype object, there is still only a single copy of
+inheited properties, because in JavaScript, there is only 1 single
+instance of each function constructor.
+ 
+4.3 Property inheritance with __proto__ chain
+
+See environment section in readme for instruction to view graphic
+display of JavaScript object inheritance relationship. The following
+graphs will be displayed:
+
+ Graph Id.   Graph Name
+   1. Class Graph with Constructor Edges
+   2. Generator Graph with Constructor Edges
+   3. Builtin Graph with Constructor Edges
+   4. Closure Graph with Constructor Edges
+   5. Iterator Graph with Constructor Edges
+   6. Async Graph with Constructor Edges
+   7. Class Graph
+   8. Generator Graph
+   9. Builtin Graph
+  10. Closure Graph
+  11. Iterator Graph
+  12. Async Graph
+
+The CPP emitter optimises property access with static compilation by:
+- Generate C++ class fields and methods for JS properties of an object and
+- Generate code to access JS properties directly as C++ object fields/method
+- Disallow runtime modification of __proto__ property.
+- Disallow runtime modification of inheritable properties in prototype objects.
+
+All JavaScript objects have a __proto__ property. Depending on what the
+kind of JS object, its __proto__ may point to different kinds of JS objects:
+note: (graph x: node x) cross refs example objects by id of graph above and node within graph.
+
+JS object                                        What the object's __proto__ is set to
+=========                                        =====================================
+1) Object instances                              (What <obj>.__proto__ is set to)
+   a) Created by user defined or
+      builtin JS ctor functions,                 Prototype of the object's ctor function
+      e.g. myCar, car (graph 1: node 7, 14)      (graph 1: node 8, 9)
+      including builtin objects:
+      - JSON (graph 3: node 7)                   (graph 3: node 1)
+      - Math (graph 3: node 6)
+   b) Special object instances:
+      - user defined generators                  The builtin "Generator" (renamed GeneratorFunction.prototype in 2022 spec)
+        (graph 2: node 4)                        (graph 2: node 8)
+      - generator instances returned by          Prototype of user defined generator that returned the instance
+        user defined generators                  (graph 2: node 5)
+        (graph 2: node 10)
+   
+2) Prototype object of ctor function which is:  (What <ctor>.prototype.__proto__ is set to)
+   a) ctor of a JS class                         Prototype of ctor of class it extends
+      (graph 1: node 8)                          (graph 1: node 9)
+   b) ctor of top level func or class            Prototype of the builtin "Object" (Object.prototype)
+      (graph 1: node 10)                         (graph 1: node 1)
+      includes builtin functions
+      - Symbol (graph 3: node 5)                 (graph 3: node 1)
+      - Promise (graph 3: node 9)                (graph 3: node 1)
+      
+3) Special Prototype objects
+   a) prototype of user defined generators       The builtin "GeneratorPrototype"
+      (graph 2: node 5)                          (graph 2: node 6)
+   b) the builtin "Generator"                    Prototype of the builtin "Function" (Function.prototype)
+      (graph 2: node 8)                          (graph 2: node 2)
+      (GeneratorFunction.prototype in 2022 spec)                                         
+   c) the builtin "GeneratorPrototype"           The builtin "IteratorPrototype"
+      (graph 2: node 6)                          (graph 2: node 7)
+      (renamed GeneratorFunction.prototype.prototype in 2022 spec)
+   d) the builtin "IteratorPrototype"            Prototype of the builtin "Object" (Object.prototype)
+      (graph 2: node 7)                          (graph 2: node 1)
+      note: A prototype object is usaually the prototype object of its constructor
+            but IteraorPrototype is an exception. Its constructor is "Object" but
+            it is not the prototype object of "Object", or any other ctor function.
+            It's an independent prototype object that does not belong to any constructor
+            
+4) Ctor function                                 (What <ctor>.__proto__ is set to)
+   a) ctor for a JS class                        Ctor of class it extends (i.e parent class)
+      (graph 1: node 13)                         (graph 1: node 12)
+   b) top level func or class                    Prototype of the builtin "Function" (Function.prototype)
+      (graph 1: node 11)                         (graph 1: node 2)
+      includes builtin functions
+      - Symbol (graph 3: node 4)                 (graph 3: node 2)
+      - Promise (graph 3: node 8)
+   c) the builtin "GeneratorFunction"            Ctor of "Function" ("GeneratorFunction extends Function" - so use rule a)
+      (graph 2: node 9)                          (graph 2: node 3)
diff --git a/src/MapleFE/docs/utils/README b/src/MapleFE/docs/utils/README
new file mode 100644
index 0000000000000000000000000000000000000000..1364eab75456cecfec2e7c9c6fa34a87720e5a50
--- /dev/null
+++ b/src/MapleFE/docs/utils/README
@@ -0,0 +1,13 @@
+Contents in this directory:
+
+o  proto.js 
+  - Sample Javascript program to demonstrate object inheritance with constructors, prototype chain and prototype properties.
+  - Run with following commands:
+      node proto.js | ./viewdot.sh
+o  proto.cpp
+  - Sample C++ program based on proto.js to demonstrate how JavaSCript object inheritance can be modeled in C++.
+  - Run with following commands: 
+      g++ ../../ast2cpp/runtime/src/builtins.cpp ../../ast2cpp/runtime/src/ts2cpp.cpp proto.cpp;
+      ./a.out | ./viewdot.sh
+
+note: requires dot and viewnior for graph generation and display.
diff --git a/src/MapleFE/docs/utils/proto-ctor.png b/src/MapleFE/docs/utils/proto-ctor.png
new file mode 100644
index 0000000000000000000000000000000000000000..d6fa7cff21607b69e556bb167f278d20c3d31c9b
Binary files /dev/null and b/src/MapleFE/docs/utils/proto-ctor.png differ
diff --git a/src/MapleFE/docs/utils/proto.cpp b/src/MapleFE/docs/utils/proto.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e57e11232bc7eae40cc3b99903edfd781acbde1b
--- /dev/null
+++ b/src/MapleFE/docs/utils/proto.cpp
@@ -0,0 +1,112 @@
+#include "../../ast2cpp/runtime/include/ts2cpp.h"
+
+using namespace t2crt;
+
+class Ctor_Vehicle;
+class Ctor_Car;
+class Ctor_MyCar;
+
+class Vehicle;
+class Car;
+class MyCar;
+
+extern Ctor_Vehicle  Vehicle_ctor;
+extern Ctor_Car      Car_ctor;
+extern Ctor_MyCar    MyCar_ctor;
+
+class Vehicle : public Object {
+  public:
+    Vehicle(Function* ctor, Object* proto): Object(ctor, proto) {}
+    // Vehicle.prototype props (use static)
+
+  public:
+    // Vehicle instance props
+    std::string name;
+};
+
+class Car : public Vehicle {
+  public:
+    Car(Function* ctor, Object* proto): Vehicle(ctor, proto) {}
+    // Car.prototype props (use static)
+
+  public:
+    // Car instance props
+};
+
+// C++ Class def for instance props and prototype props
+class MyCar : public Car {
+  public:
+    MyCar(Function* ctor, Object* proto): Car(ctor, proto) {}
+    // MyCar.prototype props (use static)
+
+  public:
+    // MyCar instance props
+};
+
+// Class def for function constructors
+
+class Ctor_Vehicle : public Function {
+  public:
+    Ctor_Vehicle(Function* ctor, Object* proto, Object* prototype) : Function(ctor, proto, prototype) {}
+
+    Vehicle* _new() {
+      return  new Vehicle(this, this->prototype);
+    }
+
+    void operator()(Vehicle* obj , std::string name) {
+      // add instance props to instance prop list
+      ClassFld<std::string Vehicle::*> field(&Vehicle::name);
+      obj->AddProp("name", field.NewProp(TY_String));
+      // init instance props
+      obj->name = name;
+    }
+};
+
+class Ctor_Car : public Ctor_Vehicle {
+  public:
+    Ctor_Car(Function* ctor, Object* proto, Object* prototype) : Ctor_Vehicle(ctor, proto, prototype) {}
+
+    Car* _new() {
+      return new Car(this, this->prototype);
+    }
+
+    void operator()(Car* obj , std::string name) {
+      Vehicle_ctor(obj, name);
+    }
+};
+
+class Ctor_MyCar : public Ctor_Car {
+  public:
+    Ctor_MyCar(Function* ctor, Object* proto, Object* prototype) : Ctor_Car(ctor, proto, prototype) {}
+
+    MyCar* _new() {
+      return new MyCar(this, this->prototype);
+    }
+
+    void operator()(MyCar* obj , std::string name) {
+      Car_ctor(obj, name);
+    }
+};
+
+// Function constructors
+Ctor_MyCar    MyCar_ctor   (&Function_ctor, &Car_ctor,               Car_ctor.prototype);
+Ctor_Car      Car_ctor     (&Function_ctor, &Vehicle_ctor,           Vehicle_ctor.prototype);
+Ctor_Vehicle  Vehicle_ctor (&Function_ctor, Function_ctor.prototype, Object_ctor.prototype);
+
+// Object instances
+Car* car    = Car_ctor._new();
+MyCar* mycar= MyCar_ctor._new();
+Array* arr  = Array_ctor._new();
+Object* obj = Object_ctor._new();
+
+int main(int argc, char* argv[]) {
+  // InitAllProtoTypeProps();
+
+  Car_ctor(car, "Tesla");
+  MyCar_ctor(mycar, "Tesla Model X");
+  std::vector<Object*> objs = {obj, arr, &Array_ctor, &Vehicle_ctor, &Car_ctor, &MyCar_ctor, car, mycar, &Function_ctor, &Object_ctor};
+  std::vector<std::string> names = {"obj", "arr", "Array", "Vehicle", "Car", "MyCar", "car", "mycar", "Function", "Object"};
+  GenerateDOTGraph(objs, names);
+  return 0;
+}
+
diff --git a/src/MapleFE/docs/utils/proto.js b/src/MapleFE/docs/utils/proto.js
new file mode 100644
index 0000000000000000000000000000000000000000..6115e6d550e9b98a8657ae0ac7a7482e2d9ebcec
--- /dev/null
+++ b/src/MapleFE/docs/utils/proto.js
@@ -0,0 +1,98 @@
+// Command line to get graphs: nodejs proto.js | ./viewdot.sh
+class Vehicle {
+  constructor (name) { this.name = name; }
+}
+class Car extends Vehicle {
+  constructor (name) { super(name); }
+}
+class MyCar extends Car {
+  constructor (name) { super(name); }
+}
+
+let car = new Car("A car");
+let myCar = new MyCar("My car");
+let arr = [1, 2, 3]
+let regexpr = /ab+c/i
+
+function* generator() { yield 1; }
+const gpt = generator.prototype.__proto__;
+
+function makeClosure(a) {
+  return function (b) {
+    return a + b;
+  }
+}
+const closure = makeClosure(1);
+
+let myMap = new Map();
+let myMapIterator = myMap[Symbol.iterator]();
+let MapIteratorPrototype = Object.getPrototypeOf(new Map()[Symbol.iterator]());
+
+async function asyncFunction() {}
+async function* asyncGenerator() {}
+const agpt = asyncGenerator.prototype.__proto__;
+
+// All data for generating graphs
+let graphData = {
+  Class    : ["Array", "arr", "myCar", "car"],
+  Generator: ["generator", [generator(), "generator_instance"], [gpt, "GeneratorPrototype"],
+              [gpt.__proto__, "IteratorPrototype"], [generator.__proto__, "Generator"]],
+  Builtin  : ["Symbol", "Math", "JSON", "Promise", "RegExp", "regexpr"],
+  Closure  : ["makeClosure", "closure"],
+  Iterator : ["myMap", "myMapIterator", "MapIteratorPrototype", [gpt.__proto__, "IteratorPrototype"]],
+  Async    : ["asyncFunction", "asyncGenerator", [asyncGenerator(), "asyncGenerator_instance"], [agpt, "AsyncGeneratorPrototype"],
+              [agpt.__proto__, "AsyncIteratorPrototype"], [asyncGenerator.__proto__, "AsyncGenerator"]],
+};
+
+generateGraph(graphData);
+
+function generateGraph(data) {
+  // Gather all reachable objects from their prototype, __proto__ and constructor properties
+  function insert(g, depth, ...args) {
+    for (let arg of args) {
+      let [o, name] = typeof arg === "string" ? [eval(arg), arg] : arg;
+      if (typeof o !== "undefined" && o !== null)
+        if (!g.has(o)) {
+          g.set(o, name !== null || typeof o !== "function" ? name : o.toString().split(" ")[1].replace(/[^a-zA-Z0-9+]/g, ""));
+          insert(g, depth + 1, [o.prototype, g.get(o) === null ? null : g.get(o) + "Prototype"], [o.__proto__, null], [o.constructor, null]);
+        } else if (name !== null)
+        g.set(o, name);
+    }
+    if (depth === 0) {
+      let visited = new Set();
+      for (let [index, [key, val]] of Array.from(g).entries()) {
+        val = val === null || val === "" ? "Object_" + index : val.replace(/[^A-Za-z0-9]+/g, "_");
+        if (visited.has(val)) val += "__" + index;
+        visited.add(val);
+        g.set(key, val);
+      }
+    }
+  }
+
+  // Dump graphs with edges for prototype, __proto__ and constructor properties of each object
+  let nodejs = (typeof process !== 'undefined') && (process.release.name === 'node')
+  for (let prop in data) {
+    let graph = new Map();
+    insert(graph, 0, "Function", "Object", ...data[prop]);
+    for (let ctor of ["", "_with_Constructor_Edges"]) {
+      console.log("digraph JS_" + prop + ctor + " {\nlabel=\"\\n" + prop + " Graph" + ctor.replace(/_/g, " ") + "\\n(Node in gray: function)"
+        + "\";\nrankdir = TB;\nranksep=0.6;\nnodesep=0.6;\n" + (ctor != "" ? "" : "newrank=true;"));
+      for (let [index, [key, val]] of Array.from(graph).entries()) {
+        let func = typeof key === "function";
+        // Add comments with detailed information of keys
+        if (nodejs)
+          console.log("\n/* key =", key, "\nObject.getOwnPropertyNames(" + val + "):\n", Object.getOwnPropertyNames(key),
+            "\n" + val + ".toString(): " + (func ? key.toString().replace(/\s+/g, " ") : "-") + "\n*/");
+        console.log(val + " [label=\"" + val + " " + (index < 4 ? 3 - index : index) + "\", shape="
+          + (val.includes("Prototype") ? "box" : "oval") + (func ? ", style=filled" : "") + "];");
+        // Add edges for prototype, constructor and __proto__ properties of objects
+        for (let [f, c] of [["prototype", "blue"], ["constructor", "darkgreen"], ["__proto__", "red"]])
+          if (typeof key[f] !== "undefined" && key[f] !== null && graph.has(key[f]) && (ctor != "" || f !== "constructor"))
+            console.log((ctor != "" || f !== "prototype" ? "" : "subgraph cluster_" + val + " {\nlabel=\"\";rank=same;color=white;\n"
+              + val + ";\n" + graph.get(key.prototype) + " [shape=box];\n}\n") + val + " -> " + graph.get(key[f])
+              + " [label=\"" + (f === "constructor" ? "ctor" : f) + "\", color=" + c + ", fontcolor=" + c + "];");
+      }
+      console.log("} // digraph JS_" + prop + ctor);
+    }
+  }
+} // generateGraph 
diff --git a/src/MapleFE/docs/utils/proto.png b/src/MapleFE/docs/utils/proto.png
new file mode 100644
index 0000000000000000000000000000000000000000..b938c09f413a08ffcc3f90c994bf171a8320244b
Binary files /dev/null and b/src/MapleFE/docs/utils/proto.png differ
diff --git a/src/MapleFE/docs/utils/proto2.ts b/src/MapleFE/docs/utils/proto2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d7d0c406520b346a16a93236e401f4debff57ace
--- /dev/null
+++ b/src/MapleFE/docs/utils/proto2.ts
@@ -0,0 +1,54 @@
+interface IPrototype { prototype: any; }
+type TPrototype = IPrototype & Function;
+interface IProto { __proto__: any; }
+type TProto = IProto & Object;
+
+// Command line to get graphs: tsc -t es6 proto2.ts; nodejs proto2.js | ./viewdot.sh
+class Vehicle {
+}
+class Car implements Vehicle {
+  name: string;
+  constructor (name) { this.name = name; }
+}
+class MyCar extends Car {
+  constructor (name) { super(name); }
+}
+
+let car = new Car("A car");
+let mycar = new MyCar("My car");
+let arr = []
+
+// Dump graphs with edges for prototype, __proto__ and constructor properties of each objects
+for(let g = 0; g < 2; ++g) {
+  let objs =  [  arr,   Array,   Vehicle,   Car,   MyCar,   car,   mycar,   Function,   Object,  ];
+  let names = [ "arr", "Array", "Vehicle", "Car", "MyCar", "car", "mycar", "Function", "Object", ];
+  console.log("digraph JS" + g + " {\nranksep=0.6;\nnodesep=0.6;\n" + (g == 0 ? "newrank=true;\n" : ""));
+  let num = objs.length;
+  let k = num;
+  // Add prototype objects and edges for them
+  for(let i = 0; i < num; ++i) {
+    let x = typeof (objs[i] as unknown as TPrototype).prototype;
+    if(x === "function" || x === "object") {
+      objs[k] = (objs[i] as unknown as TPrototype).prototype;
+      names[k] = names[i] + "_prototype";
+      console.log(g == 0 ? "subgraph cluster_" + names[i] + " {\nrank=same;\ncolor=white;\n"
+        + names[i] + ";\n" + names[k] + "[label=\"" + names[i] + ".prototype\", shape=box];\n }"
+        : names[k] + "[label=\"" + names[i] + ".prototype\", shape=box];");
+      console.log(names[i] + " -> " + names[k] + " [label=\"prototype\", color=blue, fontcolor=blue];");
+      k++;
+    }
+  }
+  // Add edges for __proto__ and constructor properties of each objects
+  num = objs.length;
+  for(let i = 0; i < num; ++i) {
+    for(let j = 0; j < num; ++j) {
+      // Edges for constructor properties in the second graph only
+      if(g > 0 && objs[i].constructor === objs[j])
+        console.log(names[i] + " -> " + names[j] + " [label=\"ctor\", color=darkgreen, fontcolor=darkgreen];");
+      // Edges for __proto__ properties
+      if((objs[i] as unknown as TProto).__proto__ === objs[j])
+        console.log(names[i] + " -> " + names[j] + " [label=\"__proto__\", color=red, fontcolor=red];");
+    }
+  }
+  console.log("}");
+}
diff --git a/src/MapleFE/docs/utils/viewdot.sh b/src/MapleFE/docs/utils/viewdot.sh
new file mode 100755
index 0000000000000000000000000000000000000000..f9252d7c0ae07e7fb98cfdfa058bcfa6bcd6a583
--- /dev/null
+++ b/src/MapleFE/docs/utils/viewdot.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+if [ $# -lt 1 ]; then
+  out=$(cat)
+  tmpdir=$(mktemp -dt viewdot-XXXXXX)
+  trap "rm -rf $tmpdir" SIGINT SIGQUIT SIGKILL
+  grep -n -e "digraph [^{]* {" -e "^} // digraph JS" <<< "$out" | grep -A1 "digraph [^{]* {" |
+    grep -v ^-- | sed 'N;s/\n/ /' | sed -e 's/:.*digraph [^{]* { */,/' -e 's/:.*/p/g' |
+      { while read cmd; do
+        name=$(sed -n $cmd <<< "$out" | head -1 | sed 's/.*digraph \([^{]*\) {.*/\1/')
+        echo $$-$name
+        sed -n $cmd <<< "$out" > "$tmpdir"/$$-$name.dot
+        dot -Tpng -o "$tmpdir"/$$-$name.png "$tmpdir"/$$-$name.dot
+        env LC_ALL=C viewnior "$tmpdir"/$$-$name.png &
+      done
+      wait
+      rm -rf "$tmpdir"; }
+  exit
+fi
+for f; do
+  dot -Tpng -o $f.png $f
+  viewnior $f.png
+  rm -f $f.png
+done
diff --git a/src/MapleFE/envsetup.sh b/src/MapleFE/envsetup.sh
index 1895cbccb164fd281ea3a071a2fc425bec9b3281..bc75a54707313c7edd50cad8b64557d54b67b914 100755
--- a/src/MapleFE/envsetup.sh
+++ b/src/MapleFE/envsetup.sh
@@ -12,26 +12,35 @@
 # FIT FOR A PARTICULAR PURPOSE.
 # See the Mulan PSL v2 for more details.
 #
+if [ "${BASH_SOURCE[0]}" -ef "$0" ]; then
+    echo "This script should be sourced in a bash shell, not executed directly"
+    exit 1
+fi
 
 function print_usage {
   echo " "
-  echo "usage: source envsetup.sh"
+  echo "usage: source envsetup.sh java/typescript/c"
   echo " "
 }
 
-if [ "$#" -ne 0 ]; then
+if [ "$#" -gt 1 ]; then
   echo $#
   print_usage
   return
 fi
 
-pdir=$(cd ..; pwd)
-unset MAPLE_ROOT
-export MAPLE_ROOT=${pdir}
+LANGSRC=java
+if [ "$#" -eq 1 ]; then
+  if [ $1 = "typescript" ]; then
+    LANGSRC=typescript
+  elif [ $1 = "c" ]; then
+    LANGSRC=c
+  fi
+fi
+export SRCLANG=$LANGSRC
 
-curdir=$(pwd)
-unset MAPLEFE_ROOT
-export MAPLEFE_ROOT=${curdir}
+export MAPLEFE_ROOT=$(cd $(dirname ${BASH_SOURCE[0]}); pwd)
+export MAPLE_ROOT=$(cd ${MAPLEFE_ROOT}/../../..; pwd)
 
 unset MAPLEALL_ROOT
 export MAPLEALL_ROOT=${MAPLE_ROOT}/OpenArkCompiler
@@ -40,4 +49,4 @@ unset MAPLEALL_SRC
 export MAPLEALL_SRC=${MAPLEALL_ROOT}/src/mapleall
 
 unset BUILDDIR
-export BUILDDIR=${MAPLEFE_ROOT}/output
+export BUILDDIR=${MAPLEFE_ROOT}/output/${SRCLANG}
diff --git a/src/MapleFE/java/attr.spec b/src/MapleFE/java/attr.spec
index daa682e84c9fcd5953172872560e37cdf0922498..3f098f9c9ab505abc952ee48b66ba263220b9529 100644
--- a/src/MapleFE/java/attr.spec
+++ b/src/MapleFE/java/attr.spec
@@ -31,5 +31,6 @@ STRUCT Attribute : (("abstract", abstract),
                     ("public", public),
                     ("static", static),
                     ("strictfp", strictfp),
-                    ("default", default))
+                    ("default", default),
+                    ("synchronized", synchronized))
 
diff --git a/src/MapleFE/java/block.spec b/src/MapleFE/java/block.spec
deleted file mode 100644
index 905f252c80befab9080c03548ad4c8b87453940e..0000000000000000000000000000000000000000
--- a/src/MapleFE/java/block.spec
+++ /dev/null
@@ -1,346 +0,0 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
-#
-# OpenArkFE is licensed under the Mulan PSL v2.
-# You can use this software according to the terms and conditions of the Mulan PSL v2.
-# You may obtain a copy of Mulan PSL v2 at:
-#
-#  http://license.coscl.org.cn/MulanPSL2
-#
-# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
-# FIT FOR A PARTICULAR PURPOSE.
-# See the Mulan PSL v2 for more details.
-#
-###################################################################################
-# This file defines the Java Block/Class/Interface statement.
-###################################################################################
-
-rule ClassDeclaration : ONEOF(NormalClassDeclaration, EnumDeclaration)
-  attr.property : Single, Top
-rule NormalClassDeclaration : ZEROORMORE(ClassModifier) + "class" + Identifier +
-                              ZEROORONE(TypeParameters) + ZEROORONE(Superclass) +
-                              ZEROORONE(Superinterfaces) + ClassBody
-  attr.action : BuildClass(%3)
-  attr.action : AddModifier(%1)
-  attr.action : AddClassBody(%7)
-  attr.action : AddSuperClass(%5)
-  attr.action : AddSuperInterface(%6)
-  attr.property.%1,%4,%5,%6 : ZomFast
-
-rule ClassAttr : ONEOF("public", "protected", "private", "abstract", "static", "final", "strictfp")
-  attr.property : Single
-rule ClassModifier : ONEOF(Annotation, ClassAttr)
-  attr.property : Single
-
-# 1. Generic class
-# 2. TypeParameter will be defined in type.spec
-rule TypeParameters    : '<' + TypeParameterList + '>'
-rule TypeParameterList : TypeParameter + ZEROORMORE(',' + TypeParameter)
-rule TypeParameter     : ZEROORMORE(TypeParameterModifier) + Identifier + ZEROORONE(TypeBound)
-rule TypeParameterModifier : Annotation
-rule TypeBound : ONEOF("extends" + TypeVariable,
-                       "extends" + ClassOrInterfaceType + ZEROORMORE(AdditionalBound))
-rule AdditionalBound : '&' + InterfaceType
-
-# ClassType and InterfaceType are defined in type.spec
-rule Superclass        : "extends" + ClassType
-rule Superinterfaces   : "implements" + InterfaceTypeList
-rule InterfaceTypeList : InterfaceType + ZEROORMORE(',' + InterfaceType)
-
-# class body
-rule ClassBody              : "{" + ZEROORMORE(ClassBodyDeclaration) + "}"
-  attr.action:       BuildBlock(%2)
-  attr.property.%2 : ZomFast
-
-rule ClassBodyDeclaration   : ONEOF(ClassMemberDeclaration,
-                                    InstanceInitializer,
-                                    StaticInitializer,
-                                    ConstructorDeclaration)
-  attr.property : Single
-
-rule InstanceInitializer    : Block
-  attr.action: BuildInstInit(%1)
-rule StaticInitializer      : "static" + Block
-  attr.action: BuildInstInit(%2)
-  attr.action: AddModifierTo(%2, %1)
-
-rule ClassMemberDeclaration : ONEOF(FieldDeclaration,
-                                    MethodDeclaration,
-                                    ClassDeclaration,
-                                    InterfaceDeclaration,
-                                    ';')
-  attr.property : Single
-
-rule FieldDeclaration  : ZEROORMORE(FieldModifier) + UnannType + VariableDeclaratorList + ';'
-  attr.action: BuildDecl(%2, %3)
-  attr.action: AddModifier(%1)
-
-rule MethodDeclaration : ZEROORMORE(MethodModifier) + MethodHeader + MethodBody
-  attr.action: AddModifierTo(%2, %1)
-  attr.action: AddFunctionBodyTo(%2, %3)
-
-rule MethodBody        : ONEOF(Block, ';')
-  attr.property : Single
-rule MethodHeader      : ONEOF(Result + MethodDeclarator + ZEROORONE(Throws),
-                               TypeParameters + ZEROORMORE(Annotation) + Result + MethodDeclarator +
-                               ZEROORONE(Throws))
-  attr.action.%1: AddTypeTo(%2, %1)
-  attr.action.%1: AddThrowsTo(%2, %3)
-  attr.action.%2: AddTypeTo(%4, %3)
-  attr.action.%2: AddThrowsTo(%4, %5)
-  attr.property : Single
-
-rule Result            : ONEOF(UnannType, "void")
-  attr.property : Single
-rule MethodDeclarator  : Identifier + '(' + ZEROORONE(FormalParameterList) + ')' + ZEROORONE(Dims)
-  attr.action: BuildFunction(%1)
-  attr.action: AddParams(%3)
-  attr.action: AddDims(%5)
-
-rule Throws            : "throws" + ExceptionTypeList
-  attr.action: BuildThrows(%2)
-
-rule ExceptionTypeList : ExceptionType + ZEROORMORE(',' + ExceptionType)
-rule ExceptionType     : ONEOF(ClassType, TypeVariable)
-
-rule MethodAttr : ONEOF("public", "protected", "private", "abstract", "static",
-                        "final", "synchronized", "native", "strictfp")
-  attr.property : Single
-
-rule MethodModifier    : ONEOF(Annotation, MethodAttr)
-  attr.property : Single
-
-rule FormalParameterListNoReceiver : ONEOF(FormalParameters + ',' + LastFormalParameter,
-                                           LastFormalParameter)
-  attr.action.%1: BuildVarList(%1, %3)
-
-# ReceiverParameter and FormalParameterListNoReceiver could match at the same
-# but with different num of tokens. Here is an example
-#   foo(T T.this)
-# The NoReceiver could match "T T", while Receiver match "T T.this".
-# Although later it figures out NoReceiver is wrong, but at this rule, both rule work.
-# If we put NoReceiver as the 1st child and set property 'Single',  we will miss
-# Receiver which is the correct one.
-#
-# So I move Receiver to be the 1st child, since NoReceiver is not correct matching
-# if Receiver works.
-rule FormalParameterList : ONEOF(ReceiverParameter, FormalParameterListNoReceiver)
-  attr.property : Single
-
-rule FormalParameters  : ONEOF(FormalParameter + ZEROORMORE(',' + FormalParameter),
-                               ReceiverParameter + ZEROORMORE(',' + FormalParameter))
-  attr.action.%1: BuildVarList(%1, %2)
-  attr.property : Single
-
-rule FormalParameter   : ZEROORMORE(VariableModifier) + UnannType + VariableDeclaratorId
-  attr.action: BuildDecl(%2, %3)
-  attr.action: AddModifier(%1)
-rule ReceiverParameter : ZEROORMORE(Annotation) + UnannType + ZEROORONE(Identifier + '.') + "this"
-
-rule LastFormalParameter : ONEOF(ZEROORMORE(VariableModifier) + UnannType + ZEROORMORE(Annotation) +
-                                   "..." + VariableDeclaratorId,
-                                 FormalParameter)
-  attr.property : Single
-
-
-rule FieldAttr : ONEOF("public", "protected", "private", "static", "final", "transient", "volatile")
-  attr.property : Single
-rule FieldModifier : ONEOF(Annotation, FieldAttr)
-  attr.property : Single
-
-################################################################
-#                        Constructor                           #
-################################################################
-rule ConstructorDeclaration : ZEROORMORE(ConstructorModifier) + ConstructorDeclarator +
-                              ZEROORONE(Throws) + ConstructorBody
-  attr.action : AddFunctionBodyTo(%2, %4)
-
-rule ConstructorAttr : ONEOF("public", "protected", "private")
-  attr.property : Single
-rule ConstructorModifier    : ONEOF(Annotation, ConstructorAttr)
-  attr.property : Single
-rule ConstructorDeclarator  : ZEROORONE(TypeParameters) + SimpleTypeName + '(' +
-                              ZEROORONE(FormalParameterList) + ')'
-  attr.action : BuildConstructor(%2)
-rule SimpleTypeName         : Identifier
-rule ConstructorBody        : '{' + ZEROORONE(ExplicitConstructorInvocation) +
-                              ZEROORONE(BlockStatements) + '}'
-  attr.action : BuildBlock(%3)
-
-# Although ExpressionName and Primary are not excluding each other, given the rest
-# of the concatenate elements this is a 'Single' rule.
-rule ExplicitConstructorInvocation : ONEOF(
-         ZEROORONE(TypeArguments) + "this" + '(' + ZEROORONE(ArgumentList) + ')' +  ';',
-         ZEROORONE(TypeArguments) + "super" + '(' + ZEROORONE(ArgumentList) + ')' +  ';',
-         ExpressionName + '.' + ZEROORONE(TypeArguments) + "super" + '(' + ZEROORONE(ArgumentList) + ')' +  ';',
-         Primary + '.' + ZEROORONE(TypeArguments) + "super" + '(' + ZEROORONE(ArgumentList) + ')' +  ';')
-  attr.property : Single
-
-######################################################################
-#                           Enum                                     #
-######################################################################
-rule EnumDeclaration: ZEROORMORE(ClassModifier) + "enum" + Identifier +
-                      ZEROORONE(Superinterfaces) + EnumBody
-  attr.action : BuildClass(%3)
-  attr.action : SetClassIsJavaEnum()
-  attr.action : AddModifier(%1)
-  attr.action : AddSuperInterface(%4)
-  attr.action : AddClassBody(%5)
-
-# This returns a PassNode with some ConstantNode and BlockNode. The
-# different between ConstantNode and LiteralNode can be found in their definition.
-rule EnumBody: '{' + ZEROORONE(EnumConstantList) + ZEROORONE(',') +
-               ZEROORONE(EnumBodyDeclarations) + '}'
-  attr.action: BuildBlock(%2)
-  attr.action: AddToBlock(%4)
-
-# This returns a PassNode
-rule EnumConstantList: EnumConstant + ZEROORMORE(',' + EnumConstant)
-
-# AddInitTo() will handle this complicated JavaEnum style initial value of identifier
-rule EnumConstant: ZEROORMORE(EnumConstantModifier) + Identifier +
-                   ZEROORONE('(' + ZEROORONE(ArgumentList) + ')') + ZEROORONE(ClassBody)
-  attr.action : AddInitTo(%2, %3)
-  attr.action : AddInitTo(%2, %4)
-
-rule EnumConstantModifier: Annotation
-
-# This returns a PassNode with a set of BlockNode
-rule EnumBodyDeclarations: ';' + ZEROORMORE(ClassBodyDeclaration)
-
-######################################################################
-#                        Block                                       #
-######################################################################
-
-# 1st and 3rd children don't exclude each other. However, if both of them
-# match, they will match the same sequence of tokens, being a
-# LocalVariableDeclarationStatement. So don't need traverse 3rd any more.
-rule BlockStatement  : ONEOF(LocalVariableDeclarationStatement,
-                             ClassDeclaration,
-                             Statement)
-  attr.property : Single
-
-rule BlockStatements : BlockStatement + ZEROORMORE(BlockStatement)
-  attr.property.%2 : ZomFast
-rule Block           : '{' + ZEROORONE(BlockStatements) + '}'
-  attr.action: BuildBlock(%2)
-
-
-######################################################################
-#                        Interface                                   #
-######################################################################
-rule InterfaceDeclaration : ONEOF(NormalInterfaceDeclaration, AnnotationTypeDeclaration)
-  attr.property : Single, Top
-
-rule NormalInterfaceDeclaration : ZEROORMORE(InterfaceModifier) + "interface" + Identifier +
-                                  ZEROORONE(TypeParameters) + ZEROORONE(ExtendsInterfaces) + InterfaceBody
-  attr.action : BuildInterface(%3)
-  attr.action : AddInterfaceBody(%6)
-
-rule InterfaceAttr : ONEOF("public", "protected", "private", "abstract", "static", "strictfp")
-  attr.property : Single
-rule InterfaceModifier : ONEOF(Annotation, InterfaceAttr)
-  attr.property : Single
-rule ExtendsInterfaces : "extends" + InterfaceTypeList
-rule InterfaceBody     : '{' + ZEROORMORE(InterfaceMemberDeclaration) + '}'
-  attr.action : BuildBlock(%2)
-  attr.property.%2 : ZomFast
-
-rule InterfaceMemberDeclaration : ONEOF(ConstantDeclaration,
-                                        InterfaceMethodDeclaration,
-                                        ClassDeclaration,
-                                        InterfaceDeclaration,
-                                        ';')
-  attr.property : Single
-
-# constant decl is also called field decl. In interface, field must have a variable initializer
-# However, the rules below don't tell this limitation.
-rule ConstantDeclaration : ZEROORMORE(ConstantModifier) + UnannType + VariableDeclaratorList + ';'
-rule ConstantAttr : ONEOF("public", "static", "final")
-  attr.property : Single
-rule ConstantModifier : ONEOF(Annotation, ConstantAttr)
-  attr.property : Single
-
-rule InterfaceMethodDeclaration : ZEROORMORE(InterfaceMethodModifier) + MethodHeader + MethodBody
-  attr.action: AddModifierTo(%2, %1)
-  attr.action: AddFunctionBodyTo(%2, %3)
-rule InterfaceMethodAttr : ONEOF("public", "abstract", "default", "static", "strictfp")
-  attr.property : Single
-rule InterfaceMethodModifier : ONEOF(Annotation, InterfaceMethodAttr)
-  attr.property : Single
-
-######################################################################
-#                        Annotation Type                             #
-######################################################################
-rule AnnotationTypeDeclaration : ZEROORMORE(InterfaceModifier) + '@' + "interface" +
-                                 Identifier + AnnotationTypeBody
-  attr.action : BuildAnnotationType(%4)
-  attr.action : AddModifier(%1)
-  attr.action : AddAnnotationTypeBody(%5)
-
-rule AnnotationTypeBody : '{' + ZEROORMORE(AnnotationTypeMemberDeclaration) + '}'
-  attr.action : BuildBlock(%2)
-rule AnnotationTypeMemberDeclaration : ONEOF(AnnotationTypeElementDeclaration,
-                                             ConstantDeclaration,
-                                             ClassDeclaration,
-                                             InterfaceDeclaration,
-                                             ';')
-  attr.property : Single
-rule AnnotationTypeElementDeclaration : ZEROORMORE(AnnotationTypeElementModifier) + UnannType +
-                                          Identifier + '(' +  ')' + ZEROORONE(Dims) +
-                                          ZEROORONE(DefaultValue) + ';'
-rule AnnotationTypeElementAttr : ONEOF("public", "abstract")
-  attr.property : Single
-rule AnnotationTypeElementModifier : ONEOF(Annotation, AnnotationTypeElementAttr)
-  attr.property : Single
-rule DefaultValue : "default" + ElementValue
-
-######################################################################
-#                        Annotation                                  #
-######################################################################
-rule Annotation : ONEOF(NormalAnnotation,
-                        MarkerAnnotation,
-                        SingleElementAnnotation)
-
-rule NormalAnnotation : '@' + TypeName + '(' + ZEROORONE(ElementValuePairList) + ')'
-  attr.action : BuildAnnotation(%2)
-
-rule MarkerAnnotation : '@' + TypeName
-  attr.action : BuildAnnotation(%2)
-
-rule SingleElementAnnotation : '@' + TypeName + '(' + ElementValue + ')'
-  attr.action : BuildAnnotation(%2)
-
-rule ElementValuePairList : ElementValuePair + ZEROORMORE(',' + ElementValuePair)
-rule ElementValuePair : Identifier + '=' + ElementValue
-rule ElementValue : ONEOF(ConditionalExpression,
-                          ElementValueArrayInitializer,
-                          Annotation)
-rule ElementValueArrayInitializer : '{' + ZEROORONE(ElementValueList) + ZEROORONE(',') + '}'
-rule ElementValueList : ElementValue + ZEROORMORE(',' + ElementValue)
-
-######################################################################
-#                        Package                                     #
-######################################################################
-rule PackageModifier: Annotation
-rule PackageDeclaration: ZEROORMORE(PackageModifier) + "package" + Identifier + ZEROORMORE('.' + Identifier) + ';'
-  attr.action : BuildField(%3, %4)
-  attr.action : BuildPackageName()
-  attr.property : Top
-  attr.property.%1,%4 : ZomFast
-
-rule ImportDeclaration: ONEOF(SingleTypeImportDeclaration,
-                              TypeImportOnDemandDeclaration,
-                              SingleStaticImportDeclaration,
-                              StaticImportOnDemandDeclaration)
-  attr.property : Top
-
-rule SingleTypeImportDeclaration: "import" + TypeName + ';'
-  attr.action : BuildSingleTypeImport(%2)
-rule TypeImportOnDemandDeclaration: "import" + PackageOrTypeName + '.' + '*' + ';'
-  attr.action : BuildAllTypeImport(%2)
-rule SingleStaticImportDeclaration: "import" + "static" + TypeName + '.' + Identifier + ';'
-  attr.action : BuildField(%3, %4)
-  attr.action : BuildSingleStaticImport()
-rule StaticImportOnDemandDeclaration: "import" + "static" + TypeName + '.' + '*' + ';'
-  attr.action : BuildAllStaticImport(%3)
diff --git a/src/MapleFE/java/expr.spec b/src/MapleFE/java/expr.spec
deleted file mode 100644
index 6ac6ad72eb76dcb9f28715a0ff5125c6ab09b6a2..0000000000000000000000000000000000000000
--- a/src/MapleFE/java/expr.spec
+++ /dev/null
@@ -1,293 +0,0 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
-#
-# OpenArkFE is licensed under the Mulan PSL v2.
-# You can use this software according to the terms and conditions of the Mulan PSL v2.
-# You may obtain a copy of Mulan PSL v2 at:
-#
-#  http://license.coscl.org.cn/MulanPSL2
-#
-# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
-# FIT FOR A PARTICULAR PURPOSE.
-# See the Mulan PSL v2 for more details.
-#
-
-
-rule PackageName : ONEOF(Identifier, PackageName + '.' + Identifier)
-  attr.action.%2 : BuildField(%1, %3)
-
-rule TypeName    : ONEOF(Identifier, PackageOrTypeName + '.' + Identifier)
-  attr.action.%2 : BuildField(%1, %3)
-
-rule PackageOrTypeName : ONEOF(Identifier, PackageOrTypeName + '.' + Identifier)
-  attr.action.%2 : BuildField(%1, %3)
-
-rule ExpressionName : ONEOF(Identifier, AmbiguousName + '.' + Identifier)
-  attr.action.%2 : BuildField(%1, %3)
-
-rule MethodName     : Identifier
-
-rule AmbiguousName  : ONEOF(Identifier, AmbiguousName + '.' + Identifier)
-  attr.action.%2 : BuildField(%1, %3)
-
-rule Class : "class"
-rule ClassLiteral : ONEOF(TypeName + ZEROORMORE('[' + ']') + '.' + Class,
-                          NumericType + ZEROORMORE('[' + ']') + '.' + Class,
-                          "boolean" + ZEROORMORE('[' + ']') + '.' + Class,
-                          "void" + '.' + Class)
-  attr.property : Single
-
-rule PrimaryNoNewArray_single : ONEOF(
-  Literal,
-  ClassLiteral,
-  "this",
-  TypeName + '.' + "this",
-  '(' + Expression + ')',
-  ClassInstanceCreationExpression)
-  attr.action.%4 : BuildField(%1, %3)
-  attr.action.%5 : BuildParenthesis(%2)
-  attr.property : Single
-
-rule PrimaryNoNewArray : ONEOF(
-  PrimaryNoNewArray_single,
-  FieldAccess,
-  ArrayAccess,
-  MethodInvocation,
-  MethodReference)
-
-# There was a child rule.
-#  ExpressionName + '.' + UnqualifiedClassInstanceCreationExpression,
-# But Primary contains ExpressionName. It's a duplication, so I removed it.
-rule ClassInstanceCreationExpression : ONEOF(
-  UnqualifiedClassInstanceCreationExpression,
-  Primary + '.' + UnqualifiedClassInstanceCreationExpression)
-
-rule UnqualifiedClassInstanceCreationExpression :
-  "new" + ZEROORONE(TypeArguments) + ClassOrInterfaceTypeToInstantiate +
-  '(' + ZEROORONE(ArgumentList) + ')' + ZEROORONE(ClassBody)
-  attr.action : BuildNewOperation(%3, %5, %7)
-
-rule ClassOrInterfaceTypeToInstantiate :
-  ZEROORMORE(Annotation) + Identifier + ZEROORMORE('.' + ZEROORMORE(Annotation) + Identifier) +
-  ZEROORONE(TypeArgumentsOrDiamond)
-  attr.action : BuildUserType(%2)
-  attr.action : AddTypeArgument(%4)
-
-rule TypeArgumentsOrDiamond : ONEOF(
-  TypeArguments,
-  "<>")
-
-rule ArgumentList : Expression + ZEROORMORE(',' + Expression)
-
-rule ArrayInitializer : '{' + ZEROORONE(VariableInitializerList) + ZEROORONE(',') + '}'
-rule ArrayCreationExpression : ONEOF(
-  "new" + PrimitiveType + DimExprs + ZEROORONE(Dims),
-  "new" + ClassOrInterfaceType + DimExprs + ZEROORONE(Dims),
-  "new" + PrimitiveType + Dims + ArrayInitializer,
-  "new" + ClassOrInterfaceType + Dims + ArrayInitializer)
-
-rule DimExprs : DimExpr + ZEROORMORE(DimExpr)
-
-rule DimExpr : ZEROORMORE(Annotation) + '[' + Expression + ']'
-
-rule ArrayAccess : ONEOF(
-  ExpressionName + '[' + Expression + ']',
-  PrimaryNoNewArray + '[' + Expression + ']')
-
-rule FieldAccess : ONEOF(
-  Primary + '.' + Identifier,
-  "super" + '.' + Identifier,
-  TypeName + '.' + "super" + '.' + Identifier)
-  attr.action.%1 : BuildField(%1, %3)
-
-# It's possible MethodInvocation includes a MethodReference, like
-#  A::B(a,b)
-rule MethodInvocation : ONEOF(
-  MethodName + '(' + ZEROORONE(ArgumentList) + ')',
-  TypeName + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')',
-  ExpressionName + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')',
-  Primary + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')',
-  "super" + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')',
-  TypeName + '.' + "super" + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')')
-  attr.action.%1 : BuildCall(%1)
-  attr.action.%1 : AddArguments(%3)
-  attr.action.%2 : BuildField(%1, %4)
-  attr.action.%2 : BuildCall()
-  attr.action.%2 : AddArguments(%6)
-
-rule ArgumentList : Expression + ZEROORMORE(',' + Expression)
-  attr.action.%1: BuildExprList(%1, %2)
-
-rule MethodReference : ONEOF(
-  ExpressionName + "::" + ZEROORONE(TypeArguments) + Identifier,
-  Primary + "::" + ZEROORONE(TypeArguments) + Identifier,
-  ReferenceType + "::" + ZEROORONE(TypeArguments) + Identifier,
-  "super" + "::" + ZEROORONE(TypeArguments) + Identifier,
-  TypeName + '.' + "super" + "::" + ZEROORONE(TypeArguments) + Identifier,
-  ClassType + "::" + ZEROORONE(TypeArguments) "new",
-  ArrayType + "::" + "new")
-
-rule PostfixExpression : ONEOF(
-  Primary,
-  ExpressionName,
-  PostIncrementExpression,
-  PostDecrementExpression)
-
-rule PostIncrementExpression : PostfixExpression + "++"
-  attr.action : BuildPostfixOperation(%2, %1)
-rule PostDecrementExpression : PostfixExpression + "--"
-  attr.action : BuildPostfixOperation(%2, %1)
-
-rule UnaryExpression : ONEOF(
-  PreIncrementExpression,
-  PreDecrementExpression,
-  '+' + UnaryExpression,
-  '-' + UnaryExpression,
-  UnaryExpressionNotPlusMinus)
-  attr.action.%3,%4 : BuildUnaryOperation(%1, %2)
-
-rule PreIncrementExpression : "++" + UnaryExpression
-  attr.action : BuildUnaryOperation(%1, %2)
-
-rule PreDecrementExpression : "--" + UnaryExpression
-  attr.action : BuildUnaryOperation(%1, %2)
-
-rule UnaryExpressionNotPlusMinus : ONEOF(
-  PostfixExpression,
-  '~' + UnaryExpression,
-  '!' + UnaryExpression,
-  CastExpression)
-
-rule CastExpression : ONEOF(
-  '(' + PrimitiveType + ')' + UnaryExpression,
-  '(' + ReferenceType + ZEROORMORE(AdditionalBound) + ')' + UnaryExpressionNotPlusMinus,
-  '(' + ReferenceType + ZEROORMORE(AdditionalBound) + ')' + LambdaExpression)
-  attr.action.%1 : BuildCast(%2, %4)
-  attr.action.%2,%3 : BuildCast(%2, %5)
-
-rule MultiplicativeExpression : ONEOF(
-  UnaryExpression,
-  MultiplicativeExpression + '*' + UnaryExpression,
-  MultiplicativeExpression + '/' + UnaryExpression,
-  MultiplicativeExpression + '%' + UnaryExpression)
-
-rule AdditiveExpression : ONEOF(
-  MultiplicativeExpression,
-  AdditiveExpression + '+' + MultiplicativeExpression,
-  AdditiveExpression + '-' + MultiplicativeExpression)
-  attr.action.%2,%3 : BuildBinaryOperation(%1, %2, %3)
-
-rule ShiftExpression : ONEOF(
-  AdditiveExpression,
-  ShiftExpression + "<<" + AdditiveExpression,
-  ShiftExpression + ">>" + AdditiveExpression,
-  ShiftExpression + ">>>" + AdditiveExpression)
-  attr.action.%2,%3,%4 : BuildBinaryOperation(%1, %2, %3)
-
-rule RelationalExpression : ONEOF(
-  ShiftExpression,
-  RelationalExpression + '<' + ShiftExpression,
-  RelationalExpression + '>' + ShiftExpression,
-  RelationalExpression + "<=" + ShiftExpression,
-  RelationalExpression + ">=" + ShiftExpression,
-  RelationalExpression + "instanceof" + ReferenceType)
-  attr.action.%2,%3,%4,%5 : BuildBinaryOperation(%1, %2, %3)
-
-rule EqualityExpression : ONEOF(
-  RelationalExpression,
-  EqualityExpression + "==" + RelationalExpression,
-  EqualityExpression + "!=" + RelationalExpression)
-  attr.action.%2,%3 : BuildBinaryOperation(%1, %2, %3)
-
-rule AndExpression : ONEOF(
-  EqualityExpression,
-  AndExpression + '&' + EqualityExpression)
-  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
-
-rule ExclusiveOrExpression : ONEOF(
-  AndExpression,
-  ExclusiveOrExpression + '^' + AndExpression)
-  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
-
-rule InclusiveOrExpression : ONEOF(
-  ExclusiveOrExpression,
-  InclusiveOrExpression + '|' + ExclusiveOrExpression)
-  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
-
-rule ConditionalAndExpression : ONEOF(
-  InclusiveOrExpression,
-  ConditionalAndExpression + "&&" + InclusiveOrExpression)
-  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
-
-rule ConditionalOrExpression : ONEOF(
-  ConditionalAndExpression,
-  ConditionalOrExpression + "||" + ConditionalAndExpression)
-  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
-
-rule ConditionalExpression : ONEOF(
-  ConditionalOrExpression,
-  ConditionalOrExpression + '?' + Expression + ':' + ConditionalExpression,
-  ConditionalOrExpression + '?' + Expression + ':' + LambdaExpression)
-
-rule AssignmentExpression : ONEOF(
-  ConditionalExpression,
-  Assignment)
-
-rule Assignment : LeftHandSide + AssignmentOperator + Expression
-  attr.action : BuildAssignment(%1, %2, %3)
-
-rule LeftHandSide : ONEOF(
-  ExpressionName,
-  FieldAccess,
-  ArrayAccess)
-
-rule AssignmentOperator : ONEOF('=', "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", ">>>=", "&=", "^=", "|=")
-
-rule LambdaExpression : LambdaParameters + "->" + LambdaBody
-  attr.action : BuildLambda(%1, %3)
-
-rule LambdaParameters : ONEOF(
-  '(' + ZEROORONE(LambdaParameterList) + ')',
-  Identifier)
-
-rule LambdaParameterList : ONEOF(
-  LambdaParameter + ZEROORMORE(',' + LambdaParameter),
-  Identifier + ZEROORMORE(',' + Identifier))
-
-rule LambdaParameter : ONEOF(
-  ZEROORMORE(VariableModifier) + LambdaParameterType + VariableDeclaratorId,
-  VariableArityParameter)
-
-rule LambdaParameterType : ONEOF(UnannType, "var")
-
-rule VariableArityParameter : ZEROORMORE(VariableModifier) + UnannType + ZEROORMORE(Annotation) + "..." + Identifier
-
-rule LambdaBody : ONEOF(Expression, Block)
-
-rule ConstantExpression : Expression
-
-rule Primary : ONEOF(
-  PrimaryNoNewArray,
-  ArrayCreationExpression)
-
-rule Expression : ONEOF(
-  ExpressionName,
-  Primary,
-  UnaryExpression,
-  BinaryExpression,
-  ConditionalExpression,
-  LambdaExpression,
-  AssignmentExpression)
-
-rule BinaryExpression : ONEOF (
-  MultiplicativeExpression,
-  AdditiveExpression,
-  ShiftExpression,
-  RelationalExpression,
-  EqualityExpression,
-  AndExpression,
-  ExclusiveOrExpression,
-  InclusiveOrExpression,
-  ConditionalAndExpression,
-  ConditionalOrExpression)
-
diff --git a/src/MapleFE/java/identifier.spec b/src/MapleFE/java/identifier.spec
index a482d95b78ac4e237121b90f6677d208c2333b5c..6cfe3baf6e1b7b01004cdd387139257599dd0990 100644
--- a/src/MapleFE/java/identifier.spec
+++ b/src/MapleFE/java/identifier.spec
@@ -14,8 +14,6 @@
 # An identifier is an unlimited-length sequence of Java letters and Java digits, the
 # first of which must be a Java letter
 #
-# TODO: So far we dont support unicode which are not major goal right now.
-
 rule JavaChar : ONEOF(CHAR, '_' , '$')
 rule CharOrDigit : ONEOF(JavaChar, DIGIT)
 rule Identifier : JavaChar + ZEROORMORE(CharOrDigit)
diff --git a/src/MapleFE/java/include/lang_builtin.def b/src/MapleFE/java/include/lang_builtin.def
new file mode 100644
index 0000000000000000000000000000000000000000..8c127c72a426bb6113253cdf59a103a11785e8fb
--- /dev/null
+++ b/src/MapleFE/java/include/lang_builtin.def
@@ -0,0 +1,14 @@
+// Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved.
+//
+// OpenArkFE is licensed under the Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+//
+//  http://license.coscl.org.cn/MulanPSL2
+//
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+// FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+//
+
diff --git a/src/MapleFE/java/include/lang_keywords.def b/src/MapleFE/java/include/lang_keywords.def
new file mode 100644
index 0000000000000000000000000000000000000000..cc571c8c9d42f70245f634ca76206bf0196ab253
--- /dev/null
+++ b/src/MapleFE/java/include/lang_keywords.def
@@ -0,0 +1,71 @@
+// Copyright (C) [2021] Futurewei Technologies Inc. All rights reverved.
+//
+// OpenArkFE is licensed under the Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+//
+//  http://license.coscl.org.cn/MulanPSL2
+//
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS WITHOUT WARRANTIES OF ANY KIND, EITHER
+// EXPRESS OR IMPLIED INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+// FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+//
+
+LANGKEYWORD(boolean)
+LANGKEYWORD(byte)
+LANGKEYWORD(char)
+LANGKEYWORD(class)
+LANGKEYWORD(double)
+LANGKEYWORD(enum)
+LANGKEYWORD(float)
+LANGKEYWORD(int)
+LANGKEYWORD(interface)
+LANGKEYWORD(long)
+LANGKEYWORD(package)
+LANGKEYWORD(short)
+LANGKEYWORD(void)
+
+LANGKEYWORD(var)
+
+LANGKEYWORD(break)
+LANGKEYWORD(case)
+LANGKEYWORD(catch)
+LANGKEYWORD(continue)
+LANGKEYWORD(default)
+LANGKEYWORD(do)
+LANGKEYWORD(else)
+LANGKEYWORD(finally)
+LANGKEYWORD(for)
+LANGKEYWORD(goto)
+LANGKEYWORD(if)
+LANGKEYWORD(return)
+LANGKEYWORD(switch)
+LANGKEYWORD(try)
+LANGKEYWORD(while)
+
+LANGKEYWORD(abstract)
+LANGKEYWORD(const)
+LANGKEYWORD(volatile)
+
+LANGKEYWORD(assert)
+LANGKEYWORD(new)
+
+LANGKEYWORD(instanceof)
+LANGKEYWORD(extends)
+LANGKEYWORD(implements)
+LANGKEYWORD(import)
+LANGKEYWORD(super)
+LANGKEYWORD(synchronized)
+// LANGKEYWORD(this)
+LANGKEYWORD(throw)
+LANGKEYWORD(throws)
+LANGKEYWORD(transient)
+
+LANGKEYWORD(final)
+LANGKEYWORD(native)
+LANGKEYWORD(private)
+LANGKEYWORD(protected)
+LANGKEYWORD(public)
+LANGKEYWORD(static)
+LANGKEYWORD(strictfp)
diff --git a/src/MapleFE/java/include/lang_spec.h b/src/MapleFE/java/include/lang_spec.h
index b461f71a033dd0257f66e5f00f5f6b73a52bda48..8f02be06ff2494d211b5641e9846c506592c6185 100644
--- a/src/MapleFE/java/include/lang_spec.h
+++ b/src/MapleFE/java/include/lang_spec.h
@@ -21,6 +21,7 @@
 
 #include "stringutil.h"
 #include "token.h"
+#include "lexer.h"
 
 namespace maplefe {
 
@@ -34,5 +35,11 @@ public:
 };
 
 extern LitData ProcessLiteral(LitId type, const char *str);
+
+//
+class JavaLexer : public Lexer {
+};
+
 }
+
 #endif
diff --git a/src/MapleFE/java/include/vfy_java.h b/src/MapleFE/java/include/vfy_java.h
index ba1fbaeb9e0a4101d442a184fcca674f91a444ff..89ab484fe50ea29420ba4fd72a3f00513f7fc057 100644
--- a/src/MapleFE/java/include/vfy_java.h
+++ b/src/MapleFE/java/include/vfy_java.h
@@ -26,7 +26,7 @@ namespace maplefe {
 class VerifierJava : public Verifier {
 private:
 public:
-  VerifierJava(){}
+  VerifierJava(ModuleNode *m) : Verifier(m) {}
   ~VerifierJava(){}
 
   void VerifyGlobalScope();
diff --git a/src/MapleFE/java/literal.spec b/src/MapleFE/java/literal.spec
index 87f8a49652cbc3bea76b89b52b505c008f6e0981..68eae0bdf7f3a0718916e1d537c690b58d569fc9 100644
--- a/src/MapleFE/java/literal.spec
+++ b/src/MapleFE/java/literal.spec
@@ -124,7 +124,15 @@ rule BooleanLiteral : ONEOF ("true", "false")
 # I decided to simplify the unicode escape a little bit. I don't want to
 # handle all odd cases.
 rule UnicodeEscape: '\' + 'u' + HEXDIGIT + HEXDIGIT + HEXDIGIT + HEXDIGIT
-rule RawInputCharacter : ONEOF(ASCII, ESCAPE)
+
+# [NOTE] Becareful of ' over here. It's duplicated in ESCAPE as '\' + '''. There is a reason.
+#        When the lexer read a string "doesn't", which is wrong since Java request ' be escaped but
+#        many code does NOT escape, the string in memory is "doesn't" too. The system Reading function
+#        which is in C doesn't escape '. So I duplicate here to catch this case.
+#
+#        Please see test case java2mpl/literal-string-2.java for example.
+#
+rule RawInputCharacter : ONEOF(ASCII, ''', ESCAPE)
 rule SingleCharacter: ONEOF(UnicodeEscape, RawInputCharacter)
 
 rule OctalEscape : ONEOF('\' + '0', '\' + '1')
@@ -135,7 +143,10 @@ rule CharacterLiteral : ''' + ONEOF(SingleCharacter, EscapeSequence) + '''
 #########################################################################
 ##                           String                                    ##
 #########################################################################
-rule StringLiteral : '"' + ZEROORMORE(RawInputCharacter) + '"'
+# The UnicodeEscape is limited from \u0000 to \u00ff.
+rule StringUnicodeEscape: '\' + 'u' + '0' + '0' + HEXDIGIT + HEXDIGIT
+rule StringCharater: ONEOF(StringUnicodeEscape, RawInputCharacter)
+rule StringLiteral : '"' + ZEROORMORE(StringCharater) + '"'
 
 #########################################################################
 ##                           Null                                      ##
diff --git a/src/MapleFE/java/operator.spec b/src/MapleFE/java/operator.spec
index b5c472571074f25f96b1b5203fde4dc7c842734f..5f561f909f2bb78e7ce8a15fd7178bfb7c845c47 100644
--- a/src/MapleFE/java/operator.spec
+++ b/src/MapleFE/java/operator.spec
@@ -20,6 +20,11 @@
 #  2. The rule part, defining the language restrictions of each operator.
 ##########################################################################
 
+# NOTE
+# Some languages could have one synatx belonging to both separator and operators.
+# eg., ':' in Java 8, it's both a separator colon and operator select.
+# We need avoid such duplication in .spec files.
+
 STRUCT Operator : ONEOF(
                     # Arithmetic
                     ("+",    Add),
@@ -64,6 +69,4 @@ STRUCT Operator : ONEOF(
                     (">>>=", ZextAssign),
                     #
                     ("->",   Arrow),
-                    (":",    Select),
-                    ("?",    Cond),
                     ("<>",   Diamond))
diff --git a/src/MapleFE/java/separator.spec b/src/MapleFE/java/separator.spec
index 1363b2d7b0e21c862e3384129d652f50b5c48b7d..db9df6f5cad9161df16d0ad6ecbff01866f9dc9d 100644
--- a/src/MapleFE/java/separator.spec
+++ b/src/MapleFE/java/separator.spec
@@ -31,6 +31,7 @@ STRUCT Separator : ((" ", Whitespace),
                     (".", Dot),
                     ("...", Dotdotdot),
                     (":", Colon),
+                    ("?", Select),
                     ("::", Of),
                     ("@", At),
                     ("#", Pound))
diff --git a/src/MapleFE/java/src/Makefile b/src/MapleFE/java/src/Makefile
index 5c8aae7fcff64d30beae6ba5ead94393877700e2..7715078eb86192d2422d3f29aec0b0c0a0a5c5aa 100644
--- a/src/MapleFE/java/src/Makefile
+++ b/src/MapleFE/java/src/Makefile
@@ -1,4 +1,4 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
 #
 # OpenArkFE is licensed under the Mulan PSL v2.
 # You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -13,27 +13,37 @@
 #
 
 include ../../Makefile.in
+BUILDBIN=$(BUILDDIR)/bin
 BUILD=$(BUILDDIR)/java
-$(shell $(MKDIR_P) $(BUILD))
+BUILDGEN=$(BUILDDIR)/gen
+BUILDASTGEN=$(BUILDDIR)/ast_gen/shared
+$(shell $(MKDIR_P) $(BUILD) $(BUILDGEN))
 
 SRC=$(wildcard *.cpp)
 OBJ :=$(patsubst %.cpp,%.o,$(SRC))
 DEP :=$(patsubst %.cpp,%.d,$(SRC))
 
-OBJS :=$(foreach obj,$(OBJ), $(BUILD)/$(obj))
-DEPS :=$(foreach dep,$(DEP), $(BUILD)/$(dep))
+SRCG := $(wildcard $(BUILDGEN)/gen*.cpp)
+OBJG := $(patsubst %.cpp, %.o, $(SRCG))
+DEPG := $(patsubst %.cpp, %.d, $(SRCG))
+
+OBJS :=$(foreach obj,$(OBJ), $(BUILD)/$(obj)) $(OBJG)
+DEPS :=$(foreach dep,$(DEP), $(BUILD)/$(dep)) $(DEPG)
 
 INCLUDES := -I $(MAPLEFE_ROOT)/shared/include \
             -I $(MAPLEFE_ROOT)/java/include \
             -I $(MAPLEFE_ROOT)/autogen/include \
-            -I . $(MAPLEALL_INC)
+						-I ${BUILDDIR}/ast_gen/shared \
+            -I $(BUILDGEN) $(MAPLEALL_INC)
+
+INCLUDEGEN := -I $(BUILDGEN) -I $(MAPLEFE_ROOT)/shared/include
 
-TARGET=java2mpl
+TARGET=java2ast
 
-SHAREDLIB = $(BUILDDIR)/shared/shared.a
+SHAREDLIB = $(BUILDDIR)/shared/shared.a $(BUILDASTGEN)/genast.a
 
-.PHONY: all $(TARGET)
-all: $(TARGET)
+.PHONY: all
+all: $(BUILD)/$(TARGET)
 
 -include $(DEPS)
 .PHONY: clean
@@ -43,7 +53,7 @@ vpath %.d $(BUILD)
 
 # Pattern Rules
 $(BUILD)/%.o : %.cpp
-	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@ 
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
 
 $(BUILD)/%.d : %.cpp
 	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $< > $@
@@ -51,14 +61,20 @@ $(BUILD)/%.d : %.cpp
 	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
 	@rm -f $(BUILD)/$*.d.tmp
 
+$(BUILDGEN)/%.o : $(BUILDGEN)/%.cpp $(BUILDGEN)/%.d
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDEGEN) -w -c $< -o $@
+
+$(BUILDGEN)/%.d : $(BUILDGEN)/%.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDEGEN) $< > $@
+	@mv -f $(BUILDGEN)/$*.d $(BUILDGEN)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILDGEN)/$*.o:|' < $(BUILDGEN)/$*.d.tmp > $(BUILDGEN)/$*.d
+	@rm -f $(BUILDGEN)/$*.d.tmp
+
 # TARGET depends on OBJS and shared OBJS from shared directory
 # as well as mapleall libraries
-$(TARGET): $(OBJS) $(SHAREDLIB)
-	$(LD) -o $(BUILD)/$(TARGET) $(OBJS) $(SHAREDLIB) $(MAPLELIBS)
-
-#.cpp.o:
-#	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $*.cpp -o $(BUILD)/$*.o
-#	$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $*.cpp > $(BUILD)/$*.d
+$(BUILD)/$(TARGET): $(OBJS) $(SHAREDLIB)
+	@mkdir -p $(BUILDBIN)
+	$(LD) -o $(BUILDBIN)/$(TARGET) $(OBJS) $(SHAREDLIB) $(MAPLELIBS)
 
 clean:
 	rm -rf $(BUILD)
diff --git a/src/MapleFE/java/src/ast2mpl_java.cpp b/src/MapleFE/java/src/ast2mpl_java.cpp
deleted file mode 100644
index ca77eaaa32c95629b3a6b89eb088e175ee9c78f3..0000000000000000000000000000000000000000
--- a/src/MapleFE/java/src/ast2mpl_java.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
-*
-* OpenArkFE is licensed under the Mulan PSL v2.
-* You can use this software according to the terms and conditions of the Mulan PSL v2.
-* You may obtain a copy of Mulan PSL v2 at:
-*
-*  http://license.coscl.org.cn/MulanPSL2
-*
-* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
-* FIT FOR A PARTICULAR PURPOSE.
-* See the Mulan PSL v2 for more details.
-*/
-
-#include "ast2mpl_java.h"
-
-namespace maplefe {
-
-maple::MIRType *A2MJava::MapPrimType(PrimTypeNode *ptnode) {
-  maple::PrimType prim;
-  switch (ptnode->GetPrimType()) {
-    case TY_Boolean: prim = maple::PTY_u1; break;
-    case TY_Byte:    prim = maple::PTY_u8; break;
-    case TY_Short:   prim = maple::PTY_i16; break;
-    case TY_Int:     prim = maple::PTY_i32; break;
-    case TY_Long:    prim = maple::PTY_i64; break;
-    case TY_Char:    prim = maple::PTY_u16; break;
-    case TY_Float:   prim = maple::PTY_f32; break;
-    case TY_Double:  prim = maple::PTY_f64; break;
-    case TY_Void:    prim = maple::PTY_void; break;
-    case TY_Null:    prim = maple::PTY_void; break;
-    default: MASSERT("Unsupported PrimType"); break;
-  }
-
-  maple::TyIdx tid(prim);
-  return maple::GlobalTables::GetTypeTable().GetTypeFromTyIdx(tid);
-}
-
-const char *A2MJava::Type2Label(const maple::MIRType *type) {
-  maple::PrimType pty = type->GetPrimType();
-  switch (pty) {
-    case maple::PTY_u1:   return "Z";
-    case maple::PTY_u8:   return "B";
-    case maple::PTY_i16:  return "S";
-    case maple::PTY_u16:  return "C";
-    case maple::PTY_i32:  return "I";
-    case maple::PTY_i64:  return "J";
-    case maple::PTY_f32:  return "F";
-    case maple::PTY_f64:  return "D";
-    case maple::PTY_void: return "V";
-    default:       return "L";
-  }
-}
-
-}
diff --git a/src/MapleFE/java/src/lang_spec.cpp b/src/MapleFE/java/src/lang_spec.cpp
index 522e67ad1630e3b14304cf89b34d97ac49bd3e77..7585961fd230765c5e5504e0f9598465fbd7ee2c 100644
--- a/src/MapleFE/java/src/lang_spec.cpp
+++ b/src/MapleFE/java/src/lang_spec.cpp
@@ -13,6 +13,7 @@
 * See the Mulan PSL v2 for more details.
 */
 #include "lang_spec.h"
+#include "stringpool.h"
 
 namespace maplefe {
 
@@ -149,7 +150,7 @@ LitData ProcessLiteral(LitId id, const char *str) {
   case LT_StringLiteral: {
     const char *s = s2v.StringToString(value_text);
     data.mType = LT_StringLiteral;
-    data.mData.mStr = s;
+    data.mData.mStrIdx = gStringPool.GetStrIdx(s);
     break; }
   case LT_NullLiteral: {
     // Just need set the id
@@ -164,4 +165,14 @@ LitData ProcessLiteral(LitId id, const char *str) {
   return data;
 }
 
+/////////////////////////////////////////////////////////////////////////////////////
+//          Implementation of Java Lexer
+/////////////////////////////////////////////////////////////////////////////////////
+
+Lexer* CreateLexer() {
+  Lexer *lexer = new JavaLexer();
+  return lexer;
+}
+
+
 }
diff --git a/src/MapleFE/java/src/main.cpp b/src/MapleFE/java/src/main.cpp
index e5a0e5092add3d5b21454be0f8674d9b6b22637d..e90b50d01f5137deaea432f63fb09184bf69b3b2 100644
--- a/src/MapleFE/java/src/main.cpp
+++ b/src/MapleFE/java/src/main.cpp
@@ -17,8 +17,10 @@
 #include "common_header_autogen.h"
 #include "ruletable_util.h"
 #include "gen_summary.h"
+#include "gen_aststore.h"
+#include "gen_astdump.h"
+#include "gen_astgraph.h"
 #include "vfy_java.h"
-#include "ast2mpl_java.h"
 
 static void help() {
   std::cout << "java2mpl sourcefile [options]:\n" << std::endl;
@@ -35,6 +37,8 @@ static void help() {
   std::cout << "   --trace-patch-was-succ : Trace Patching of WasSucc nodes" << std::endl;
   std::cout << "   --trace-warning   : Print Warning" << std::endl;
   std::cout << "   --trace-a2m       : Trace MPL Builder" << std::endl;
+  std::cout << "   --dump-ast        : Dump AST in text format" << std::endl;
+  std::cout << "   --dump-dot        : Dump AST in dot format" << std::endl;
 }
 
 int main (int argc, char *argv[]) {
@@ -45,7 +49,9 @@ int main (int argc, char *argv[]) {
 
   maplefe::Parser *parser = new maplefe::Parser(argv[1]);
 
-  bool trace_a2m = false;
+  bool dump_ast = false;
+  bool dump_dot = false;
+  bool succ;
 
   // Parse the argument
   for (unsigned i = 2; i < argc; i++) {
@@ -71,8 +77,10 @@ int main (int argc, char *argv[]) {
       parser->mTracePatchWasSucc = true;
     } else if (!strncmp(argv[i], "--trace-warning", 15) && (strlen(argv[i]) == 15)) {
       parser->mTraceWarning = true;
-    } else if (!strncmp(argv[i], "--trace-a2m", 11) && (strlen(argv[i]) == 11)) {
-      trace_a2m = true;
+    } else if (!strncmp(argv[i], "--dump-ast", 10) && (strlen(argv[i]) == 10)) {
+      dump_ast = true;
+    } else if (!strncmp(argv[i], "--dump-dot", 10) && (strlen(argv[i]) == 10)) {
+      dump_dot = true;
     } else {
       std::cerr << "unknown option " << argv[i] << std::endl;
       exit(-1);
@@ -80,18 +88,40 @@ int main (int argc, char *argv[]) {
   }
 
   parser->InitRecursion();
-  parser->Parse();
+  succ = parser->Parse();
+  if (!succ) {
+    delete parser;
+    return 1;
+  }
+
+  // the module from parser
+  maplefe::ModuleNode *module = parser->GetModule();
 
-  maplefe::VerifierJava vfy_java;
+  maplefe::VerifierJava vfy_java(module);
   vfy_java.Do();
 
-  maplefe::A2MJava *a2m = new maplefe::A2MJava(maplefe::gModule.mFileName);
-  a2m->ProcessAST(trace_a2m);
+  if(dump_ast) {
+    maplefe::AstDump astdump(module);
+    astdump.Dump("ts2ast: Initial AST", &std::cout);
+  }
 
-  a2m->mMirModule->OutputAsciiMpl("", ".mpl");
+  if(dump_dot) {
+    maplefe::AstGraph graph(module);
+    graph.DumpGraph("ts2ast: Initial AST", &std::cout);
+  }
 
-  delete parser;
-  delete a2m;
+  maplefe::AstStore saveAst(module);
+  saveAst.StoreInAstBuf();
+  maplefe::AstBuffer &ast_buf = saveAst.GetAstBuf();
+
+  std::ofstream ofs;
+  std::string fname(module->GetFilename());
+  fname += ".ast";
+  ofs.open(fname, std::ofstream::out);
+  const char *addr = (const char *)(&(ast_buf[0]));
+  ofs.write(addr, ast_buf.size());
+  ofs.close();
 
+  delete parser;
   return 0;
 }
diff --git a/src/MapleFE/java/src/vfy_java.cpp b/src/MapleFE/java/src/vfy_java.cpp
index e77e3b6bff5177a52f307303d3f540fe21fb8b19..53efd9c35ca3c4fc47ac81a45d759d7b0ade4587 100644
--- a/src/MapleFE/java/src/vfy_java.cpp
+++ b/src/MapleFE/java/src/vfy_java.cpp
@@ -24,19 +24,15 @@ namespace maplefe {
 
 // Collect all types, decls of global scope all at once.
 void VerifierJava::VerifyGlobalScope() {
-  mCurrScope = gModule.mRootScope;
-  std::vector<ASTTree*>::iterator tree_it = gModule.mTrees.begin();
-  for (; tree_it != gModule.mTrees.end(); tree_it++) {
-    ASTTree *asttree = *tree_it;
-    TreeNode *tree = asttree->mRootNode;
+  mCurrScope = mASTModule->mRootScope;
+  for (unsigned i = 0; i < mASTModule->GetTreesNum(); i++) {
+    TreeNode *tree = mASTModule->GetTree(i);
     mCurrScope->TryAddDecl(tree);
     mCurrScope->TryAddType(tree);
-  } 
+  }
 
-  tree_it = gModule.mTrees.begin();
-  for (; tree_it != gModule.mTrees.end(); tree_it++) {
-    ASTTree *asttree = *tree_it;
-    TreeNode *tree = asttree->mRootNode;
+  for (unsigned i = 0; i < mASTModule->GetTreesNum(); i++) {
+    TreeNode *tree = mASTModule->GetTree(i);
     VerifyTree(tree);
   }
 }
diff --git a/src/MapleFE/java/stmt.spec b/src/MapleFE/java/stmt.spec
index 4e4922f23196015f1a6aa75527cbdd8e44dc19fc..ea54785ffea55213637b31e913ea1544959965c9 100644
--- a/src/MapleFE/java/stmt.spec
+++ b/src/MapleFE/java/stmt.spec
@@ -12,6 +12,289 @@
 # See the Mulan PSL v2 for more details.
 #
 
+rule PackageName : ONEOF(Identifier, PackageName + '.' + Identifier)
+  attr.action.%2 : BuildField(%1, %3)
+
+rule TypeName    : ONEOF(Identifier, PackageOrTypeName + '.' + Identifier)
+  attr.action.%2 : BuildField(%1, %3)
+
+rule PackageOrTypeName : ONEOF(Identifier, PackageOrTypeName + '.' + Identifier)
+  attr.action.%2 : BuildField(%1, %3)
+
+rule ExpressionName : ONEOF(Identifier, AmbiguousName + '.' + Identifier)
+  attr.action.%2 : BuildField(%1, %3)
+
+rule MethodName     : Identifier
+
+rule AmbiguousName  : ONEOF(Identifier, AmbiguousName + '.' + Identifier)
+  attr.action.%2 : BuildField(%1, %3)
+
+rule Class : "class"
+rule ClassLiteral : ONEOF(TypeName + ZEROORMORE('[' + ']') + '.' + Class,
+                          NumericType + ZEROORMORE('[' + ']') + '.' + Class,
+                          "boolean" + ZEROORMORE('[' + ']') + '.' + Class,
+                          "void" + '.' + Class)
+  attr.property : Single
+
+rule PrimaryNoNewArray_single : ONEOF(
+  Literal,
+  ClassLiteral,
+  "this",
+  TypeName + '.' + "this",
+  '(' + Expression + ')',
+  ClassInstanceCreationExpression)
+  attr.action.%4 : BuildField(%1, %3)
+  attr.action.%5 : BuildParenthesis(%2)
+  attr.property : Single
+
+rule PrimaryNoNewArray : ONEOF(
+  PrimaryNoNewArray_single,
+  FieldAccess,
+  ArrayAccess,
+  MethodInvocation,
+  MethodReference)
+
+# There was a child rule.
+#  ExpressionName + '.' + UnqualifiedClassInstanceCreationExpression,
+# But Primary contains ExpressionName. It's a duplication, so I removed it.
+rule ClassInstanceCreationExpression : ONEOF(
+  UnqualifiedClassInstanceCreationExpression,
+  Primary + '.' + UnqualifiedClassInstanceCreationExpression)
+
+rule UnqualifiedClassInstanceCreationExpression :
+  "new" + ZEROORONE(TypeArguments) + ClassOrInterfaceTypeToInstantiate +
+  '(' + ZEROORONE(ArgumentList) + ')' + ZEROORONE(ClassBody)
+  attr.action : BuildNewOperation(%3, %5, %7)
+
+rule ClassOrInterfaceTypeToInstantiate :
+  ZEROORMORE(Annotation) + Identifier + ZEROORMORE('.' + ZEROORMORE(Annotation) + Identifier) +
+  ZEROORONE(TypeArgumentsOrDiamond)
+  attr.action : BuildUserType(%2)
+  attr.action : AddTypeGenerics(%4)
+
+rule TypeArgumentsOrDiamond : ONEOF(
+  TypeArguments,
+  "<>")
+
+rule ArrayInitializer : '{' + ZEROORONE(VariableInitializerList) + ZEROORONE(',') + '}'
+rule ArrayCreationExpression : ONEOF(
+  "new" + PrimitiveType + DimExprs + ZEROORONE(Dims),
+  "new" + ClassOrInterfaceType + DimExprs + ZEROORONE(Dims),
+  "new" + PrimitiveType + Dims + ArrayInitializer,
+  "new" + ClassOrInterfaceType + Dims + ArrayInitializer)
+
+rule DimExprs : DimExpr + ZEROORMORE(DimExpr)
+
+rule DimExpr : ZEROORMORE(Annotation) + '[' + Expression + ']'
+
+rule ArrayAccess : ONEOF(
+  ExpressionName + '[' + Expression + ']',
+  PrimaryNoNewArray + '[' + Expression + ']')
+
+rule FieldAccess : ONEOF(
+  Primary + '.' + Identifier,
+  "super" + '.' + Identifier,
+  TypeName + '.' + "super" + '.' + Identifier)
+  attr.action.%1 : BuildField(%1, %3)
+
+# It's possible MethodInvocation includes a MethodReference, like
+#  A::B(a,b)
+rule MethodInvocation : ONEOF(
+  MethodName + '(' + ZEROORONE(ArgumentList) + ')',
+  TypeName + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')',
+  ExpressionName + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')',
+  Primary + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')',
+  "super" + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')',
+  TypeName + '.' + "super" + '.' + ZEROORONE(TypeArguments) + Identifier + '(' + ZEROORONE(ArgumentList) + ')')
+  attr.action.%1 : BuildCall(%1)
+  attr.action.%1 : AddArguments(%3)
+  attr.action.%2 : BuildField(%1, %4)
+  attr.action.%2 : BuildCall()
+  attr.action.%2 : AddArguments(%6)
+  attr.action.%3,%4,%5 : BuildField(%1, %4)
+  attr.action.%3,%4,%5 : BuildCall()
+  attr.action.%3,%4,%5 : AddArguments(%6)
+
+rule ArgumentList : Expression + ZEROORMORE(',' + Expression)
+  attr.action.%1: BuildExprList(%1, %2)
+
+rule MethodReference : ONEOF(
+  ExpressionName + "::" + ZEROORONE(TypeArguments) + Identifier,
+  Primary + "::" + ZEROORONE(TypeArguments) + Identifier,
+  ReferenceType + "::" + ZEROORONE(TypeArguments) + Identifier,
+  "super" + "::" + ZEROORONE(TypeArguments) + Identifier,
+  TypeName + '.' + "super" + "::" + ZEROORONE(TypeArguments) + Identifier,
+  ClassType + "::" + ZEROORONE(TypeArguments) "new",
+  ArrayType + "::" + "new")
+
+rule PostfixExpression : ONEOF(
+  Primary,
+  ExpressionName,
+  PostIncrementExpression,
+  PostDecrementExpression)
+
+rule PostIncrementExpression : PostfixExpression + "++"
+  attr.action : BuildPostfixOperation(%2, %1)
+rule PostDecrementExpression : PostfixExpression + "--"
+  attr.action : BuildPostfixOperation(%2, %1)
+
+rule UnaryExpression : ONEOF(
+  PreIncrementExpression,
+  PreDecrementExpression,
+  '+' + UnaryExpression,
+  '-' + UnaryExpression,
+  UnaryExpressionNotPlusMinus)
+  attr.action.%3,%4 : BuildUnaryOperation(%1, %2)
+
+rule PreIncrementExpression : "++" + UnaryExpression
+  attr.action : BuildUnaryOperation(%1, %2)
+
+rule PreDecrementExpression : "--" + UnaryExpression
+  attr.action : BuildUnaryOperation(%1, %2)
+
+rule UnaryExpressionNotPlusMinus : ONEOF(
+  PostfixExpression,
+  '~' + UnaryExpression,
+  '!' + UnaryExpression,
+  CastExpression)
+
+rule CastExpression : ONEOF(
+  '(' + PrimitiveType + ')' + UnaryExpression,
+  '(' + ReferenceType + ZEROORMORE(AdditionalBound) + ')' + UnaryExpressionNotPlusMinus,
+  '(' + ReferenceType + ZEROORMORE(AdditionalBound) + ')' + LambdaExpression)
+  attr.action.%1 : BuildCast(%2, %4)
+  attr.action.%2,%3 : BuildCast(%2, %5)
+
+rule MultiplicativeExpression : ONEOF(
+  UnaryExpression,
+  MultiplicativeExpression + '*' + UnaryExpression,
+  MultiplicativeExpression + '/' + UnaryExpression,
+  MultiplicativeExpression + '%' + UnaryExpression)
+  attr.action.%2,%3,%4 : BuildBinaryOperation(%1, %2, %3)
+
+rule AdditiveExpression : ONEOF(
+  MultiplicativeExpression,
+  AdditiveExpression + '+' + MultiplicativeExpression,
+  AdditiveExpression + '-' + MultiplicativeExpression)
+  attr.action.%2,%3 : BuildBinaryOperation(%1, %2, %3)
+
+rule ShiftExpression : ONEOF(
+  AdditiveExpression,
+  ShiftExpression + "<<" + AdditiveExpression,
+  ShiftExpression + ">>" + AdditiveExpression,
+  ShiftExpression + ">>>" + AdditiveExpression)
+  attr.action.%2,%3,%4 : BuildBinaryOperation(%1, %2, %3)
+
+rule RelationalExpression : ONEOF(
+  ShiftExpression,
+  RelationalExpression + '<' + ShiftExpression,
+  RelationalExpression + '>' + ShiftExpression,
+  RelationalExpression + "<=" + ShiftExpression,
+  RelationalExpression + ">=" + ShiftExpression,
+  RelationalExpression + "instanceof" + ReferenceType)
+  attr.action.%2,%3,%4,%5 : BuildBinaryOperation(%1, %2, %3)
+  attr.action.%6 : BuildInstanceOf(%1, %3)
+
+rule EqualityExpression : ONEOF(
+  RelationalExpression,
+  EqualityExpression + "==" + RelationalExpression,
+  EqualityExpression + "!=" + RelationalExpression)
+  attr.action.%2,%3 : BuildBinaryOperation(%1, %2, %3)
+
+rule AndExpression : ONEOF(
+  EqualityExpression,
+  AndExpression + '&' + EqualityExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+rule ExclusiveOrExpression : ONEOF(
+  AndExpression,
+  ExclusiveOrExpression + '^' + AndExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+rule InclusiveOrExpression : ONEOF(
+  ExclusiveOrExpression,
+  InclusiveOrExpression + '|' + ExclusiveOrExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+rule ConditionalAndExpression : ONEOF(
+  InclusiveOrExpression,
+  ConditionalAndExpression + "&&" + InclusiveOrExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+rule ConditionalOrExpression : ONEOF(
+  ConditionalAndExpression,
+  ConditionalOrExpression + "||" + ConditionalAndExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+rule ConditionalExpression : ONEOF(
+  ConditionalOrExpression,
+  ConditionalOrExpression + '?' + Expression + ':' + ConditionalExpression,
+  ConditionalOrExpression + '?' + Expression + ':' + LambdaExpression)
+
+rule AssignmentExpression : ONEOF(
+  ConditionalExpression,
+  Assignment)
+
+rule Assignment : LeftHandSide + AssignmentOperator + Expression
+  attr.action : BuildAssignment(%1, %2, %3)
+
+rule LeftHandSide : ONEOF(
+  ExpressionName,
+  FieldAccess,
+  ArrayAccess)
+
+rule AssignmentOperator : ONEOF('=', "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", ">>>=", "&=", "^=", "|=")
+
+rule LambdaExpression : LambdaParameters + "->" + LambdaBody
+  attr.action : BuildLambda(%1, %3)
+
+rule LambdaParameters : ONEOF(
+  '(' + ZEROORONE(LambdaParameterList) + ')',
+  Identifier)
+
+rule LambdaParameterList : ONEOF(
+  LambdaParameter + ZEROORMORE(',' + LambdaParameter),
+  Identifier + ZEROORMORE(',' + Identifier))
+
+rule LambdaParameter : ONEOF(
+  ZEROORMORE(VariableModifier) + LambdaParameterType + VariableDeclaratorId,
+  VariableArityParameter)
+  attr.action.%1: BuildDecl(%2, %3)
+
+rule LambdaParameterType : ONEOF(UnannType, "var")
+
+rule VariableArityParameter : ZEROORMORE(VariableModifier) + UnannType + ZEROORMORE(Annotation) + "..." + Identifier
+
+rule LambdaBody : ONEOF(Expression, Block)
+
+rule ConstantExpression : Expression
+
+rule Primary : ONEOF(
+  PrimaryNoNewArray,
+  ArrayCreationExpression)
+
+rule Expression : ONEOF(
+  ExpressionName,
+  Primary,
+  UnaryExpression,
+  BinaryExpression,
+  ConditionalExpression,
+  LambdaExpression,
+  AssignmentExpression)
+
+rule BinaryExpression : ONEOF (
+  MultiplicativeExpression,
+  AdditiveExpression,
+  ShiftExpression,
+  RelationalExpression,
+  EqualityExpression,
+  AndExpression,
+  ExclusiveOrExpression,
+  InclusiveOrExpression,
+  ConditionalAndExpression,
+  ConditionalOrExpression)
+
+
 rule LocalVariableDeclarationStatement : LocalVariableDeclaration + ';'
 
 rule LocalVariableDeclaration : ZEROORMORE(VariableModifier) + UnannType + VariableDeclaratorList
@@ -86,6 +369,8 @@ rule IfThenStatement : "if" + '(' + Expression + ')' + Statement
   attr.action: BuildCondBranch(%3)
   attr.action: AddCondBranchTrueStatement(%5)
 
+## " This line is to make my vim show right color for the below contents.
+
 rule IfThenElseStatement : "if" + '(' + Expression + ')' + StatementNoShortIf + "else" + Statement
   attr.action: BuildCondBranch(%3)
   attr.action: AddCondBranchTrueStatement(%5)
@@ -125,7 +410,6 @@ rule SwitchStatement : "switch" + '(' + Expression + ')' + SwitchBlock
   attr.action : BuildSwitch(%3, %5)
 
 rule SwitchBlock : '{' + ZEROORMORE(ZEROORMORE(SwitchBlockStatementGroup) + ZEROORMORE(SwitchLabel)) + '}'
-  attr.action : BuildAllCases(%2)
 
 rule SwitchBlockStatementGroup : SwitchLabels + BlockStatements
   attr.action : BuildOneCase(%1, %2)
@@ -187,6 +471,7 @@ rule ReturnStatement : "return" + ZEROORONE(Expression) + ';'
 rule ThrowStatement : "throw" + Expression + ';'
 
 rule SynchronizedStatement : "synchronized" + '(' + Expression + ')' + Block
+  attr.action : AddSyncToBlock(%3, %5)
 
 rule TryStatement : ONEOF(
   "try" + Block + Catches,
@@ -217,3 +502,339 @@ rule VariableAccess : ONEOF(
   ExpressionName,
   FieldAccess)
 
+###################################################################################
+# This file defines the Java Block/Class/Interface statement.
+###################################################################################
+
+rule ClassDeclaration : ONEOF(NormalClassDeclaration, EnumDeclaration)
+  attr.property : Single, Top
+rule NormalClassDeclaration : ZEROORMORE(ClassModifier) + "class" + Identifier +
+                              ZEROORONE(TypeParameters) + ZEROORONE(Superclass) +
+                              ZEROORONE(Superinterfaces) + ClassBody
+  attr.action : BuildClass(%3)
+  attr.action : AddModifier(%1)
+  attr.action : AddClassBody(%7)
+  attr.action : AddSuperClass(%5)
+  attr.action : AddSuperInterface(%6)
+  attr.property.%1,%4,%5,%6 : ZomFast
+
+rule ClassAttr : ONEOF("public", "protected", "private", "abstract", "static", "final", "strictfp")
+  attr.property : Single
+rule ClassModifier : ONEOF(Annotation, ClassAttr)
+  attr.property : Single
+
+# 1. Generic class
+# 2. TypeParameter will be defined in type.spec
+rule TypeParameters    : '<' + TypeParameterList + '>'
+rule TypeParameterList : TypeParameter + ZEROORMORE(',' + TypeParameter)
+rule TypeParameter     : ZEROORMORE(TypeParameterModifier) + Identifier + ZEROORONE(TypeBound)
+rule TypeParameterModifier : Annotation
+rule TypeBound : ONEOF("extends" + TypeVariable,
+                       "extends" + ClassOrInterfaceType + ZEROORMORE(AdditionalBound))
+rule AdditionalBound : '&' + InterfaceType
+
+# ClassType and InterfaceType are defined in type.spec
+rule Superclass        : "extends" + ClassType
+rule Superinterfaces   : "implements" + InterfaceTypeList
+rule InterfaceTypeList : InterfaceType + ZEROORMORE(',' + InterfaceType)
+
+# class body
+rule ClassBody              : "{" + ZEROORMORE(ClassBodyDeclaration) + "}"
+  attr.action:       BuildBlock(%2)
+  attr.property.%2 : ZomFast
+
+rule ClassBodyDeclaration   : ONEOF(ClassMemberDeclaration,
+                                    InstanceInitializer,
+                                    StaticInitializer,
+                                    ConstructorDeclaration)
+  attr.property : Single
+
+rule InstanceInitializer    : Block
+  attr.action: BuildInstInit(%1)
+rule StaticInitializer      : "static" + Block
+  attr.action: BuildInstInit(%2)
+  attr.action: AddModifierTo(%2, %1)
+
+rule ClassMemberDeclaration : ONEOF(FieldDeclaration,
+                                    MethodDeclaration,
+                                    ClassDeclaration,
+                                    InterfaceDeclaration,
+                                    ';')
+  attr.property : Single
+
+rule FieldDeclaration  : ZEROORMORE(FieldModifier) + UnannType + VariableDeclaratorList + ';'
+  attr.action: BuildDecl(%2, %3)
+  attr.action: AddModifier(%1)
+
+rule MethodDeclaration : ZEROORMORE(MethodModifier) + MethodHeader + MethodBody
+  attr.action: AddModifierTo(%2, %1)
+  attr.action: AddFunctionBodyTo(%2, %3)
+
+rule MethodBody        : ONEOF(Block, ';')
+  attr.property : Single
+rule MethodHeader      : ONEOF(Result + MethodDeclarator + ZEROORONE(Throws),
+                               TypeParameters + ZEROORMORE(Annotation) + Result + MethodDeclarator +
+                               ZEROORONE(Throws))
+  attr.action.%1: AddType(%2, %1)
+  attr.action.%1: AddThrowsTo(%2, %3)
+  attr.action.%2: AddType(%4, %3)
+  attr.action.%2: AddThrowsTo(%4, %5)
+  attr.property : Single
+
+rule Result            : ONEOF(UnannType, "void")
+  attr.property : Single
+rule MethodDeclarator  : Identifier + '(' + ZEROORONE(FormalParameterList) + ')' + ZEROORONE(Dims)
+  attr.action: BuildFunction(%1)
+  attr.action: AddParams(%3)
+  attr.action: AddDims(%5)
+
+rule Throws            : "throws" + ExceptionTypeList
+  attr.action: PassChild(%2)
+
+rule ExceptionTypeList : ExceptionType + ZEROORMORE(',' + ExceptionType)
+rule ExceptionType     : ONEOF(ClassType, TypeVariable)
+
+rule MethodAttr : ONEOF("public", "protected", "private", "abstract", "static",
+                        "final", "synchronized", "native", "strictfp")
+  attr.property : Single
+
+rule MethodModifier    : ONEOF(Annotation, MethodAttr)
+  attr.property : Single
+
+rule FormalParameterListNoReceiver : ONEOF(FormalParameters + ',' + LastFormalParameter,
+                                           LastFormalParameter)
+
+# ReceiverParameter and FormalParameterListNoReceiver could match at the same
+# but with different num of tokens. Here is an example
+#   foo(T T.this)
+# The NoReceiver could match "T T", while Receiver match "T T.this".
+# Although later it figures out NoReceiver is wrong, but at this rule, both rule work.
+# If we put NoReceiver as the 1st child and set property 'Single',  we will miss
+# Receiver which is the correct one.
+#
+# So I move Receiver to be the 1st child, since NoReceiver is not correct matching
+# if Receiver works.
+rule FormalParameterList : ONEOF(ReceiverParameter, FormalParameterListNoReceiver)
+  attr.property : Single
+
+# We don't do any action. Just let it pass a PassNode
+rule FormalParameters  : ONEOF(FormalParameter + ZEROORMORE(',' + FormalParameter),
+                               ReceiverParameter + ZEROORMORE(',' + FormalParameter))
+  attr.property : Single
+
+rule FormalParameter   : ZEROORMORE(VariableModifier) + UnannType + VariableDeclaratorId
+  attr.action: BuildDecl(%2, %3)
+  attr.action: AddModifier(%1)
+rule ReceiverParameter : ZEROORMORE(Annotation) + UnannType + ZEROORONE(Identifier + '.') + "this"
+  attr.action: BuildDecl(%2, %3)
+
+rule LastFormalParameter : ONEOF(ZEROORMORE(VariableModifier) + UnannType + ZEROORMORE(Annotation) +
+                                   "..." + VariableDeclaratorId,
+                                 FormalParameter)
+  attr.action.%1: BuildDecl(%2, %5)
+  attr.action.%1: AddModifier(%1)
+  attr.property : Single
+
+
+rule FieldAttr : ONEOF("public", "protected", "private", "static", "final", "transient", "volatile")
+  attr.property : Single
+rule FieldModifier : ONEOF(Annotation, FieldAttr)
+  attr.property : Single
+
+################################################################
+#                        Constructor                           #
+################################################################
+rule ConstructorDeclaration : ZEROORMORE(ConstructorModifier) + ConstructorDeclarator +
+                              ZEROORONE(Throws) + ConstructorBody
+  attr.action : AddFunctionBodyTo(%2, %4)
+
+rule ConstructorAttr : ONEOF("public", "protected", "private")
+  attr.property : Single
+rule ConstructorModifier    : ONEOF(Annotation, ConstructorAttr)
+  attr.property : Single
+rule ConstructorDeclarator  : ZEROORONE(TypeParameters) + SimpleTypeName + '(' +
+                              ZEROORONE(FormalParameterList) + ')'
+  attr.action : BuildConstructor(%2)
+  attr.action: AddParams(%4)
+rule SimpleTypeName         : Identifier
+rule ConstructorBody        : '{' + ZEROORONE(ExplicitConstructorInvocation) +
+                              ZEROORONE(BlockStatements) + '}'
+  attr.action : BuildBlock(%3)
+
+# Although ExpressionName and Primary are not excluding each other, given the rest
+# of the concatenate elements this is a 'Single' rule.
+rule ExplicitConstructorInvocation : ONEOF(
+         ZEROORONE(TypeArguments) + "this" + '(' + ZEROORONE(ArgumentList) + ')' +  ';',
+         ZEROORONE(TypeArguments) + "super" + '(' + ZEROORONE(ArgumentList) + ')' +  ';',
+         ExpressionName + '.' + ZEROORONE(TypeArguments) + "super" + '(' + ZEROORONE(ArgumentList) + ')' +  ';',
+         Primary + '.' + ZEROORONE(TypeArguments) + "super" + '(' + ZEROORONE(ArgumentList) + ')' +  ';')
+  attr.property : Single
+
+######################################################################
+#                           Enum                                     #
+######################################################################
+rule EnumDeclaration: ZEROORMORE(ClassModifier) + "enum" + Identifier +
+                      ZEROORONE(Superinterfaces) + EnumBody
+  attr.action : BuildClass(%3)
+  attr.action : SetClassIsJavaEnum()
+  attr.action : AddModifier(%1)
+  attr.action : AddSuperInterface(%4)
+  attr.action : AddClassBody(%5)
+
+# This returns a PassNode with some ConstantNode and BlockNode. The
+# different between ConstantNode and LiteralNode can be found in their definition.
+rule EnumBody: '{' + ZEROORONE(EnumConstantList) + ZEROORONE(',') +
+               ZEROORONE(EnumBodyDeclarations) + '}'
+  attr.action: BuildBlock(%2)
+  attr.action: AddToBlock(%4)
+
+# This returns a PassNode
+rule EnumConstantList: EnumConstant + ZEROORMORE(',' + EnumConstant)
+
+# AddInitTo() will handle this complicated JavaEnum style initial value of identifier
+rule EnumConstant: ZEROORMORE(EnumConstantModifier) + Identifier +
+                   ZEROORONE('(' + ZEROORONE(ArgumentList) + ')') + ZEROORONE(ClassBody)
+  attr.action : AddInitTo(%2, %3)
+  attr.action : AddInitTo(%2, %4)
+
+rule EnumConstantModifier: Annotation
+
+# This returns a PassNode with a set of BlockNode
+rule EnumBodyDeclarations: ';' + ZEROORMORE(ClassBodyDeclaration)
+
+######################################################################
+#                        Block                                       #
+######################################################################
+
+# 1st and 3rd children don't exclude each other. However, if both of them
+# match, they will match the same sequence of tokens, being a
+# LocalVariableDeclarationStatement. So don't need traverse 3rd any more.
+rule BlockStatement  : ONEOF(LocalVariableDeclarationStatement,
+                             ClassDeclaration,
+                             Statement)
+  attr.property : Single
+
+rule BlockStatements : BlockStatement + ZEROORMORE(BlockStatement)
+  attr.property.%2 : ZomFast
+rule Block           : '{' + ZEROORONE(BlockStatements) + '}'
+  attr.action: BuildBlock(%2)
+
+
+######################################################################
+#                        Interface                                   #
+######################################################################
+rule InterfaceDeclaration : ONEOF(NormalInterfaceDeclaration, AnnotationTypeDeclaration)
+  attr.property : Single, Top
+
+rule NormalInterfaceDeclaration : ZEROORMORE(InterfaceModifier) + "interface" + Identifier +
+                                  ZEROORONE(TypeParameters) + ZEROORONE(ExtendsInterfaces) + InterfaceBody
+  attr.action : BuildInterface(%3)
+  attr.action : AddInterfaceBody(%6)
+
+rule InterfaceAttr : ONEOF("public", "protected", "private", "abstract", "static", "strictfp")
+  attr.property : Single
+rule InterfaceModifier : ONEOF(Annotation, InterfaceAttr)
+  attr.property : Single
+rule ExtendsInterfaces : "extends" + InterfaceTypeList
+rule InterfaceBody     : '{' + ZEROORMORE(InterfaceMemberDeclaration) + '}'
+  attr.action : BuildBlock(%2)
+  attr.property.%2 : ZomFast
+
+rule InterfaceMemberDeclaration : ONEOF(ConstantDeclaration,
+                                        InterfaceMethodDeclaration,
+                                        ClassDeclaration,
+                                        InterfaceDeclaration,
+                                        ';')
+  attr.property : Single
+
+# constant decl is also called field decl. In interface, field must have a variable initializer
+# However, the rules below don't tell this limitation.
+rule ConstantDeclaration : ZEROORMORE(ConstantModifier) + UnannType + VariableDeclaratorList + ';'
+rule ConstantAttr : ONEOF("public", "static", "final")
+  attr.property : Single
+rule ConstantModifier : ONEOF(Annotation, ConstantAttr)
+  attr.property : Single
+
+rule InterfaceMethodDeclaration : ZEROORMORE(InterfaceMethodModifier) + MethodHeader + MethodBody
+  attr.action: AddModifierTo(%2, %1)
+  attr.action: AddFunctionBodyTo(%2, %3)
+rule InterfaceMethodAttr : ONEOF("public", "abstract", "default", "static", "strictfp")
+  attr.property : Single
+rule InterfaceMethodModifier : ONEOF(Annotation, InterfaceMethodAttr)
+  attr.property : Single
+
+######################################################################
+#                        Annotation Type                             #
+######################################################################
+rule AnnotationTypeDeclaration : ZEROORMORE(InterfaceModifier) + '@' + "interface" +
+                                 Identifier + AnnotationTypeBody
+  attr.action : BuildAnnotationType(%4)
+  attr.action : AddModifier(%1)
+  attr.action : AddAnnotationTypeBody(%5)
+
+rule AnnotationTypeBody : '{' + ZEROORMORE(AnnotationTypeMemberDeclaration) + '}'
+  attr.action : BuildBlock(%2)
+rule AnnotationTypeMemberDeclaration : ONEOF(AnnotationTypeElementDeclaration,
+                                             ConstantDeclaration,
+                                             ClassDeclaration,
+                                             InterfaceDeclaration,
+                                             ';')
+  attr.property : Single
+rule AnnotationTypeElementDeclaration : ZEROORMORE(AnnotationTypeElementModifier) + UnannType +
+                                          Identifier + '(' +  ')' + ZEROORONE(Dims) +
+                                          ZEROORONE(DefaultValue) + ';'
+rule AnnotationTypeElementAttr : ONEOF("public", "abstract")
+  attr.property : Single
+rule AnnotationTypeElementModifier : ONEOF(Annotation, AnnotationTypeElementAttr)
+  attr.property : Single
+rule DefaultValue : "default" + ElementValue
+
+######################################################################
+#                        Annotation                                  #
+######################################################################
+rule Annotation : ONEOF(NormalAnnotation,
+                        MarkerAnnotation,
+                        SingleElementAnnotation)
+
+rule NormalAnnotation : '@' + TypeName + '(' + ZEROORONE(ElementValuePairList) + ')'
+  attr.action : BuildAnnotation(%2)
+
+rule MarkerAnnotation : '@' + TypeName
+  attr.action : BuildAnnotation(%2)
+
+rule SingleElementAnnotation : '@' + TypeName + '(' + ElementValue + ')'
+  attr.action : BuildAnnotation(%2)
+
+rule ElementValuePairList : ElementValuePair + ZEROORMORE(',' + ElementValuePair)
+rule ElementValuePair : Identifier + '=' + ElementValue
+rule ElementValue : ONEOF(ConditionalExpression,
+                          ElementValueArrayInitializer,
+                          Annotation)
+rule ElementValueArrayInitializer : '{' + ZEROORONE(ElementValueList) + ZEROORONE(',') + '}'
+rule ElementValueList : ElementValue + ZEROORMORE(',' + ElementValue)
+
+######################################################################
+#                        Package                                     #
+######################################################################
+rule PackageModifier: Annotation
+rule PackageDeclaration: ZEROORMORE(PackageModifier) + "package" + Identifier + ZEROORMORE('.' + Identifier) + ';'
+  attr.action : BuildField(%3, %4)
+  attr.action : BuildPackageName()
+  attr.property : Top
+  attr.property.%1,%4 : ZomFast
+
+rule ImportDeclaration: ONEOF(SingleTypeImportDeclaration,
+                              TypeImportOnDemandDeclaration,
+                              SingleStaticImportDeclaration,
+                              StaticImportOnDemandDeclaration)
+  attr.property : Top
+
+rule SingleTypeImportDeclaration: "import" + TypeName + ';'
+  attr.action : BuildSingleTypeImport(%2)
+rule TypeImportOnDemandDeclaration: "import" + PackageOrTypeName + '.' + '*' + ';'
+  attr.action : BuildAllTypeImport(%2)
+rule SingleStaticImportDeclaration: "import" + "static" + TypeName + '.' + Identifier + ';'
+  attr.action : BuildField(%3, %5)
+  attr.action : BuildSingleStaticImport()
+rule StaticImportOnDemandDeclaration: "import" + "static" + TypeName + '.' + '*' + ';'
+  attr.action : BuildAllStaticImport(%3)
diff --git a/src/MapleFE/java/type.spec b/src/MapleFE/java/type.spec
index 6a8990b563038b3e2f1256dd137ed226386f8351..d0339d802c7f076b7b25e5b1861000747331ef07 100644
--- a/src/MapleFE/java/type.spec
+++ b/src/MapleFE/java/type.spec
@@ -118,6 +118,7 @@ rule ReferenceType        : ONEOF(ClassOrInterfaceType, TypeVariable, ArrayType)
 #  Final one
 ###########################
 rule TYPE: ONEOF(PrimitiveType, ReferenceType, NullType)
+rule Type : TYPE
 
 #####################################################################################
 #                       Abnormal types                                              #
diff --git a/src/MapleFE/java/type_conv.spec b/src/MapleFE/java/type_conv.spec
deleted file mode 100644
index aa140d750f2be14c30d1a82688fceb9cf866dc44..0000000000000000000000000000000000000000
--- a/src/MapleFE/java/type_conv.spec
+++ /dev/null
@@ -1,121 +0,0 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
-#
-# OpenArkFE is licensed under the Mulan PSL v2.
-# You can use this software according to the terms and conditions of the Mulan PSL v2.
-# You may obtain a copy of Mulan PSL v2 at:
-#
-#  http://license.coscl.org.cn/MulanPSL2
-#
-# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
-# FIT FOR A PARTICULAR PURPOSE.
-# See the Mulan PSL v2 for more details.
-#
-#######################################################################
-# There are over 10 kinds of type conversion in Java. This file       #
-# defines the rules of type conversion in different categories.       #
-#                                                                     #
-# There are many details putting many flavors in the semantics.       #
-# They can be implemented in java/src/*.cpp. Such as when convert     #
-# 'float' to 'Float', it diverges when the value is 'NaN'.            #
-# Situations like this will be handled in specified functions.        #
-#######################################################################
-
-
-#######################################################################
-#            Identity Conversion                                      #
-#######################################################################
-
-
-#######################################################################
-#            Widening Primitive Conversion                            #
-#######################################################################
-
-
-#######################################################################
-#            Narrowing Primitive Conversion                           #
-#######################################################################
-
-
-#######################################################################
-#            Widening Reference Conversion                            #
-#######################################################################
-
-
-#######################################################################
-#            Narrowing Reference Conversion                           #
-#######################################################################
-
-
-#######################################################################
-#            Boxing Conversion                                        #
-#######################################################################
-
-
-#######################################################################
-#            Unboxing Conversion                                      #
-#######################################################################
-
-
-#######################################################################
-#            Unchecked Conversion                                     #
-#######################################################################
-
-
-#######################################################################
-#            Capture Conversion                                       #
-#######################################################################
-
-
-#######################################################################
-#            String Conversion                                        #
-#######################################################################
-
-
-#######################################################################
-#            Forbidden Conversion                                     #
-#######################################################################
-
-
-#######################################################################
-#            Value Set Conversion                                     #
-#######################################################################
-
-
-#######################################################################
-#  Boxing/Unboxing conversion is conversion between primitive types   #
-#  and their corresponding Java reference types.                      #
-#  This could also happen in other similar lanaguages.                #
-#                                                                     #
-#  1. Since reference types are not part of Autogen, they are not     #
-#     handled in the supported_types.spec.                            #
-#  2. Reference types here will be only recognized through keyword,   #
-#     The generated files will handle the conversion.                 #
-#                                                                     #
-# TODO: There is one thing I will figure out later, i.e., see if we   #
-#       need generate the 'new' operation in the Maple IR             #
-#######################################################################
-
-# The syntax of Boxing is a duplex <PrimType, "RefType">
-#   PrimType: Use the types supported in autogen/supported_types.spec
-#   RefType: Use the keyword of reference types
-#
-
-STRUCT Boxing : ONEOF((Boolean, "Boolean"),
-                      (Byte, "Byte"),
-                      (Short, "Short"),
-                      (Char, "Character"),
-                      (Int, "Integer"),
-                      (Long, "Long"),
-                      (Float, "Float"),
-                      (Double, "Double"))
-
-STRUCT UnBoxing : ONEOF(("Boolean", Boolean),
-                        ("Byte", Byte),
-                        ("Short", Short),
-                        ("Char", Char),
-                        ("Int", Int),
-                        ("Long", Long),
-                        ("Float", Float),
-                        ("Double", Double))
-
diff --git a/src/MapleFE/ladetect/Makefile b/src/MapleFE/ladetect/Makefile
index ac28904e9a9334189058b9c9d33c477270ca9fc1..3badd03259474113eedfb80b0f9aed5609b63823 100644
--- a/src/MapleFE/ladetect/Makefile
+++ b/src/MapleFE/ladetect/Makefile
@@ -1,46 +1,70 @@
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
 include ../Makefile.in
 
 # create build first
 BUILD=$(BUILDDIR)/ladetect
-$(shell $(MKDIR_P) $(BUILD))
+BUILDGEN=$(BUILDDIR)/gen
+$(shell $(MKDIR_P) $(BUILD) $(BUILDGEN)) 
 
-# TEMPVAR=$(shell rm -rf $(LANG))
-# TEMPVAR=$(shell mkdir -p $(LANG))
-# TEMPVAR=$(shell cp ../$(LANG)/include/gen_*.h $(LANG)/)
-# TEMPVAR=$(shell cp ../$(LANG)/src/gen_*.cpp $(LANG)/)
-# TEMPVAR=$(shell mkdir -p $(BUILD))
-# TEMPVAR=$(shell mkdir -p $(BUILD)/$(LANG))
+SRCG := $(wildcard $(BUILDGEN)/gen_*.cpp)
+OBJG := $(patsubst %.cpp, %.o, $(SRCG))
+DEPG := $(patsubst %.cpp, %.d, $(SRCG))
 
-LANGSRC=$(shell ls $(LANG)/*.cpp)
-SRC := $(LANGSRC) $(wildcard *.cpp)
+SRC := $(wildcard *.cpp)
 OBJ := $(patsubst %.cpp, %.o, $(SRC))
+OBJL := $(foreach obj, $(OBJ), $(BUILD)/$(obj))
 DEP := $(patsubst %.cpp, %.d, $(SRC))
+DEPL := $(foreach dep, $(DEP), $(BUILD)/$(dep))
 
-OBJS := $(foreach obj, $(OBJ), $(BUILD)/$(obj))
-DEPS := $(foreach dep, $(DEP), $(BUILD)/$(dep))
+OBJS := $(OBJG) $(OBJL)
+DEPS := $(DEPG) $(DEPL)
 
 INCLUDES := -I $(MAPLEFE_ROOT)/ladetect \
-            -I $(MAPLEFE_ROOT)/ladetect/$(LANG) \
-            -I $(MAPLEFE_ROOT)/shared/include
+            -I $(MAPLEFE_ROOT)/shared/include \
+            -I $(MAPLEFE_ROOT)/$(SRCLANG)/include \
+            -I $(BUILDGEN)
+
+INCLUDEGEN := -I $(BUILDGEN) -I $(MAPLEFE_ROOT)/shared/include
+
 SHAREDLIB = $(BUILDDIR)/shared/shared.a
 
 TARGET = ladetect
 
 .PHONY: all
 
-all: $(TARGET)
+all: $(BUILD)/$(TARGET)
 
-$(TARGET) : $(OBJS) $(SHAREDLIB)
+$(BUILD)/$(TARGET) : $(OBJS) $(SHAREDLIB)
 	$(LD) -o $(BUILD)/$(TARGET) $(OBJS) $(SHAREDLIB)
+	(cd $(BUILD); ./$(TARGET))
 
 -include $(DEPS)
 .PHONY: clean
 
-vpath %.cpp $(MAPLEFE_ROOT)/shared/src
 vpath %.o $(BUILD)
 vpath %.d $(BUILD)
 
-CXXFLAGS := $(CXXFLAGS) -I ../$(LANG)/
+$(BUILDGEN)/%.o : $(BUILDGEN)/%.cpp $(BUILDGEN)/%.d
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDEGEN) -w -c $< -o $@
+
+$(BUILDGEN)/%.d : $(BUILDGEN)/%.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDEGEN) $< > $@
+	@mv -f $(BUILDGEN)/$*.d $(BUILDGEN)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILDGEN)/$*.o:|' < $(BUILDGEN)/$*.d.tmp > $(BUILDGEN)/$*.d
+	@rm -f $(BUILDGEN)/$*.d.tmp
 
 #Pattern Rules
 $(BUILD)/%.o : %.cpp $(BUILD)/%.d
@@ -52,10 +76,5 @@ $(BUILD)/%.d : %.cpp
 	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
 	@rm -f $(BUILD)/$*.d.tmp
 
-
-#.cpp.o:
-#	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $*.cpp -o $(BUILD)/$*.o
-#	$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $*.cpp > $(BUILD)/$*.d
-
 clean:
-	rm -rf $(BUILD)
+	rm -rf $(BUILD) $(OBJG) $(DEPG)
diff --git a/src/MapleFE/ladetect/la_detect.cpp b/src/MapleFE/ladetect/la_detect.cpp
index c1eba89defe7c1517e0548ebf3f891381a92bf1c..49757bab478a9dc1923ba914f572f824646fe25b 100644
--- a/src/MapleFE/ladetect/la_detect.cpp
+++ b/src/MapleFE/ladetect/la_detect.cpp
@@ -15,7 +15,7 @@
 
 #include "common_header_autogen.h"
 #include "ruletable_util.h"
-#include "gen_summary.h"
+#include "rule_summary.h"
 #include "la_detect.h"
 #include "container.h"
 
@@ -266,6 +266,7 @@ TResult LADetector::DetectRuleTable(RuleTable *rt, ContTreeNode<RuleTable*> *p)
       break;
     case ET_Zeroorone:
     case ET_Zeroormore:
+    case ET_ASI:
       res = DetectZeroorXXX(rt, node);
       break;
     case ET_Concatenate:
@@ -351,7 +352,7 @@ TResult LADetector::DetectOneof(RuleTable *rule_table, ContTreeNode<RuleTable*>
   return result;
 }
 
-// Zeroormore and Zeroorone has the same way to handle.
+// Zeroormore and Zeroorone and ASI has the same way to handle.
 TResult LADetector::DetectZeroorXXX(RuleTable *rule_table, ContTreeNode<RuleTable*> *tree_node) {
   TResult result = TRS_NA;
   MASSERT((rule_table->mNum == 1) && "zeroormore node has more than one elements?");
@@ -488,7 +489,7 @@ void LADetector::Release() {
 }
 
 // To write the external decl of all LookAheadTable of each rule.
-//   
+//
 //   extern LookAheadTable TblStatementLookAheadTable;
 //   extern LookAhead     *TblStatementLookAhead;
 //   ...
@@ -597,14 +598,13 @@ void LADetector::WriteCppFile() {
   mCppFile->WriteOneLine("}", 1);
 }
 
-// Write the recursion to java/gen_recursion.h and java/gen_recursion.cpp
+// Write the recursion to gen/genmore_lookahead.h and gen/genmore_lookahead.cpp
 void LADetector::Write() {
-  std::string lang_path_header("../../java/include/");
-  std::string lang_path_cpp("../../java/src/");
+  std::string lang_path("../gen/");
 
-  std::string file_name = lang_path_cpp + "gen_lookahead.cpp";
+  std::string file_name = lang_path + "genmore_lookahead.cpp";
   mCppFile = new Write2File(file_name);
-  file_name = lang_path_header + "gen_lookahead.h";
+  file_name = lang_path + "gen_lookahead.h";
   mHeaderFile = new Write2File(file_name);
 
   WriteHeaderFile();
diff --git a/src/MapleFE/ladetect/la_detect.h b/src/MapleFE/ladetect/la_detect.h
index 18a1bcbd8a8fd2e4f4cfad834fed7a53fdf4f76e..46fe89d1a9677b41d3b3c5df319fd28946d7a4c5 100644
--- a/src/MapleFE/ladetect/la_detect.h
+++ b/src/MapleFE/ladetect/la_detect.h
@@ -62,7 +62,7 @@ public:
   void AddDependent(RuleTable *rt) {mDependents.PushBack(rt);}
 
   void Release() {mDependents.Release();}
-}; 
+};
 
 // Return result of most detect functions.
 enum TResult {
diff --git a/src/MapleFE/recdetect/Makefile b/src/MapleFE/recdetect/Makefile
index 6d436ee84cde07134c4d5222729a46aaa40b283e..025b900d399d63e2cab3d3bb9e35a7a9eedb3ca9 100644
--- a/src/MapleFE/recdetect/Makefile
+++ b/src/MapleFE/recdetect/Makefile
@@ -1,46 +1,67 @@
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
 include ../Makefile.in
 
 # create build first
 BUILD=$(BUILDDIR)/recdetect
-$(shell $(MKDIR_P) $(BUILD))
+BUILDGEN=$(BUILDDIR)/gen
+$(shell $(MKDIR_P) $(BUILD) $(BUILDGEN)) 
 
-# TEMPVAR=$(shell rm -rf $(LANG))
-# TEMPVAR=$(shell mkdir -p $(LANG))
-# TEMPVAR=$(shell cp ../$(LANG)/include/gen_*.h $(LANG)/)
-# TEMPVAR=$(shell cp ../$(LANG)/src/gen_*.cpp $(LANG)/)
-# TEMPVAR=$(shell mkdir -p $(BUILD))
-# TEMPVAR=$(shell mkdir -p $(BUILD)/$(LANG))
+SRCG := $(wildcard $(BUILDGEN)/gen_*.cpp)
+OBJG := $(patsubst %.cpp, %.o, $(SRCG))
+DEPG := $(patsubst %.cpp, %.d, $(SRCG))
 
-LANGSRC=$(shell ls $(LANG)/*.cpp)
-SRC := $(LANGSRC) $(wildcard *.cpp)
+SRC := $(wildcard *.cpp)
 OBJ := $(patsubst %.cpp, %.o, $(SRC))
+OBJL := $(foreach obj, $(OBJ), $(BUILD)/$(obj))
 DEP := $(patsubst %.cpp, %.d, $(SRC))
+DEPL := $(foreach dep, $(DEP), $(BUILD)/$(dep))
+
+OBJS := $(OBJG) $(OBJL)
+DEPS := $(DEPG) $(DEPL)
 
-OBJS := $(foreach obj, $(OBJ), $(BUILD)/$(obj))
-DEPS := $(foreach dep, $(DEP), $(BUILD)/$(dep))
+INCLUDES := -I $(MAPLEFE_ROOT)/recdetect \
+            -I $(MAPLEFE_ROOT)/shared/include \
+            -I $(BUILDGEN)
 
-INCLUDES := -I $(MAPLEFE_ROOT)/recdetect/include \
-            -I $(MAPLEFE_ROOT)/recdetect/$(LANG) \
-            -I $(MAPLEFE_ROOT)/shared/include
 SHAREDLIB = $(BUILDDIR)/shared/shared.a
 
 TARGET = recdetect
 
 .PHONY: all
 
-all: $(TARGET)
+all: $(BUILD)/$(TARGET)
 
-$(TARGET) : $(OBJS) $(SHAREDLIB)
+$(BUILD)/$(TARGET) : $(OBJS) $(SHAREDLIB)
 	$(LD) -o $(BUILD)/$(TARGET) $(OBJS) $(SHAREDLIB)
+	(cd $(BUILD); ./$(TARGET))
 
 -include $(DEPS)
 .PHONY: clean
 
-vpath %.cpp $(MAPLEFE_ROOT)/shared/src
 vpath %.o $(BUILD)
 vpath %.d $(BUILD)
 
-CXXFLAGS := $(CXXFLAGS) -I ../$(LANG)/
+$(BUILDGEN)/%.o : $(BUILDGEN)/%.cpp $(BUILDGEN)/%.d
+	$(CXX) $(CXXFLAGS) -fpermissive -I $(BUILDGEN) -w -c $< -o $@
+
+$(BUILDGEN)/%.d : $(BUILDGEN)/%.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $< > $@
+	@mv -f $(BUILDGEN)/$*.d $(BUILDGEN)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILDGEN)/$*.o:|' < $(BUILDGEN)/$*.d.tmp > $(BUILDGEN)/$*.d
+	@rm -f $(BUILDGEN)/$*.d.tmp
 
 #Pattern Rules
 $(BUILD)/%.o : %.cpp $(BUILD)/%.d
@@ -52,10 +73,5 @@ $(BUILD)/%.d : %.cpp
 	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
 	@rm -f $(BUILD)/$*.d.tmp
 
-
-#.cpp.o:
-#	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $*.cpp -o $(BUILD)/$*.o
-#	$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $*.cpp > $(BUILD)/$*.d
-
 clean:
-	rm -rf $(BUILD)
+	rm -rf $(BUILD) $(OBJG) $(DEPG)
diff --git a/src/MapleFE/recdetect/rec_detect.cpp b/src/MapleFE/recdetect/rec_detect.cpp
index 8de48d23fff2b8abc31c11d9ef14c6b4df1dc342..8193ebd46c6978641d2dcd2c91896cdb838f4f33 100644
--- a/src/MapleFE/recdetect/rec_detect.cpp
+++ b/src/MapleFE/recdetect/rec_detect.cpp
@@ -16,7 +16,7 @@
 #include "common_header_autogen.h"
 #include "ruletable_util.h"
 #include "rec_detect.h"
-#include "gen_summary.h"
+#include "rule_summary.h"
 
 namespace maplefe {
 
@@ -27,7 +27,7 @@ namespace maplefe {
 //     the recursions. We differentiate a recursion using the first node, ie, the topmost
 //     node in the tree in this recursion.
 //  2) Each node (ie rule table) could have multiple recursions.
-//  3) Recursions could include children recursions inside. 
+//  3) Recursions could include children recursions inside.
 //
 // [NOTE] The key point in recursion detector is to make sure for each loop, there
 //        should be one and only one recursion counted, even if there are multiple
@@ -346,6 +346,7 @@ TResult RecDetector::DetectRuleTable(RuleTable *rt, ContTreeNode<RuleTable*> *p)
     break;
   case ET_Zeroorone:
   case ET_Zeroormore:
+  case ET_ASI:
     res = DetectZeroorXXX(rt, node);
     break;
   case ET_Concatenate:
@@ -422,7 +423,7 @@ TResult RecDetector::DetectOneof(RuleTable *rule_table, ContTreeNode<RuleTable*>
   return result;
 }
 
-// Zeroormore and Zeroorone has the same way to handle.
+// Zeroormore and Zeroorone and ASI has the same way to handle.
 TResult RecDetector::DetectZeroorXXX(RuleTable *rule_table, ContTreeNode<RuleTable*> *p) {
   TResult result = TRS_NA;
   MASSERT((rule_table->mNum == 1) && "zeroormore node has more than one elements?");
@@ -548,7 +549,7 @@ TResult RecDetector::DetectData(RuleTable *rule_table, ContTreeNode<RuleTable*>
 
 // At any point when we want to return, we need take the remaining elements
 // to ToDo list, if they are not in any of InProcess, Done and ToDo.
- 
+
 TResult RecDetector::DetectConcatenate(RuleTable *rule_table, ContTreeNode<RuleTable*> *p) {
   // We use 'res' to record the status of the leading children. TRS_MaybeZero is good
   // for the beginning as it means it's empty right now.
@@ -571,7 +572,7 @@ TResult RecDetector::DetectConcatenate(RuleTable *rule_table, ContTreeNode<RuleT
       // won't be counted, and we return TRS_Fail at the end.
       temp_res = TRS_Fail;
     }
-  
+
     MASSERT((res == TRS_MaybeZero));
 
     if (temp_res == TRS_Fail) {
@@ -756,6 +757,7 @@ bool RecDetector::LRReachable(RuleTable *from, RuleTable *to) {
     }
     case ET_Zeroorone:
     case ET_Zeroormore:
+    case ET_ASI:
     case ET_Data: {
       MASSERT(rt->mNum == 1);
       TableData *data = rt->mData;
@@ -1123,7 +1125,7 @@ void RecDetector::WriteRecursionGroups() {
     }
     group += "};";
     mCppFile->WriteOneLine(group.c_str(), group.size());
-  } 
+  }
 
   // LeftRecursion **recursion_groups[N] = {RecursionGroup_1, RecursionGroup_2...};
   // LeftRecursion ***gRecursionGroups = recursion_groups;
@@ -1146,7 +1148,7 @@ void RecDetector::WriteRecursionGroups() {
 
 // We want to dump like below.
 //   unsigned gRule2GroupNum = X;
-//   
+//
 
 void RecDetector::WriteRule2Group() {
   std::string comment = "// Rule2Group mapping";
@@ -1357,12 +1359,11 @@ void RecDetector::WriteRule2Recursion() {
 
 // Write the recursion to java/gen_recursion.h and java/gen_recursion.cpp
 void RecDetector::Write() {
-  std::string lang_path_header("../../java/include/");
-  std::string lang_path_cpp("../../java/src/");
+  std::string lang_path("../gen/");
 
-  std::string file_name = lang_path_cpp + "gen_recursion.cpp";
+  std::string file_name = lang_path + "genmore_recursion.cpp";
   mCppFile = new Write2File(file_name);
-  file_name = lang_path_header + "gen_recursion.h";
+  file_name = lang_path + "gen_recursion.h";
   mHeaderFile = new Write2File(file_name);
 
   WriteHeaderFile();
diff --git a/src/MapleFE/scripts/build_mapleall.sh b/src/MapleFE/scripts/build_mapleall.sh
index a37d1634def7e2988d4bc89a29ee234cfb97e03e..c1c5d7375cdb59f496a9c361166f40eab0b2a456 100755
--- a/src/MapleFE/scripts/build_mapleall.sh
+++ b/src/MapleFE/scripts/build_mapleall.sh
@@ -13,13 +13,18 @@
 # See the Mulan PSL v2 for more details.
 #
 
+set -e
+
 if [ ! -d $MAPLEALL_ROOT ]; then
   cd $MAPLE_ROOT
-  git clone https://gitee.com/openarkcompiler/OpenArkCompiler.git
+  git clone https://gitee.com/openarkcompiler/OpenArkCompiler.git -b dev_MapleFE
 fi
 
 cd $MAPLEALL_ROOT
+git checkout dev_MapleFE
 git pull
 source build/envsetup.sh arm debug
 make setup
-make
+make clobber
+make maple
+make irbuild
diff --git a/src/MapleFE/scripts/maplefe-autogen.py b/src/MapleFE/scripts/maplefe-autogen.py
new file mode 100755
index 0000000000000000000000000000000000000000..f0ffce0cf1f8723de889853653e340c32e058df9
--- /dev/null
+++ b/src/MapleFE/scripts/maplefe-autogen.py
@@ -0,0 +1,1375 @@
+#!/usr/bin/env python3
+from os import path, environ
+import subprocess
+import hashlib
+import yaml
+
+#
+# Needs to install the following packages on Ubuntu 18.04 or 20.04
+#   sudo apt install -y clang-tools-10 clang-format-10 libyaml-cpp-dev
+#
+
+root_dir = path.dirname(path.dirname(path.realpath(__file__))) + '/'
+builddir = environ.get('BUILDDIR')
+output_dir = builddir + '/ast_gen/' if builddir != None else root_dir + "output/typescript/ast_gen/"
+maplefe_dir = root_dir + 'shared/'
+# initial_yaml = output_dir + 'maplefe/index.yaml' # For higher version of clang-doc
+initial_yaml = output_dir + 'maplefe.yaml'         # For version 10
+treenode_yaml = output_dir + 'maplefe/TreeNode.yaml'
+
+if not hasattr(yaml, "cyaml"):
+    print("Note: You may install package 'libyaml-cpp-dev' to speed up YAML parsing.")
+
+license_notice = [
+"""/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+// Generated by maplefe-autogen.py
+"""
+] # license_notice
+
+compile_commands = [
+f"""
+[
+  {{ "directory": "{maplefe_dir}src"
+    "command":   "clang++ -std=c++17 -DDEBUG -fpermissive -I {maplefe_dir}include -w -c ast_builder.cpp",
+    "file":      "ast_builder.cpp",
+    "output":    "{output_dir}"
+  }}
+]
+"""
+] # compile_commands
+
+bash_commands = [
+f"""
+cd {maplefe_dir}src || exit 1
+rm -f {output_dir}yaml.log
+clang-doc-10 ast_builder.cpp -p {output_dir} --format=yaml -output={output_dir}
+"""
+] # bash_commands
+
+def exec_command(cmd):
+    subprocess.call(cmd, shell=True)
+
+def create(filename, lines):
+    with open(filename, "w") as f:
+        for line in lines:
+            f.write(line + "\n")
+
+def append(filename, lines):
+    with open(filename, "a") as f:
+        for line in lines:
+            f.write(line + "\n")
+
+def finalize(filename, lines):
+    append(filename, lines)
+    exec_command('clang-format-10 -i --style="{ColumnLimit: 120}" ' + filename)
+    print("Generated " + filename)
+
+exec_command('bash -c "mkdir -p ' + output_dir + 'shared"')
+create(output_dir + 'compile_commands.json', compile_commands)
+create(output_dir + 'ast.sh', bash_commands)
+exec_command('bash ' + output_dir + 'ast.sh')
+
+################################################################################
+#                                                                              #
+#                   Common code to handle YAML files                           #
+#                                                                              #
+################################################################################
+
+# Dump all content in a dictionary to ast_gen/yaml.log
+def log(dictionary, indent, msg = ""):
+    global log_buf
+    if indent == 0: log_buf = [msg]
+    indstr = " .  " * indent
+    for key, value in dictionary.items():
+        if key == "USR": continue
+        prefix = indstr + key + ' : '
+        if isinstance(value, dict):
+            log_buf.append(prefix + "{")
+            log(value, indent + 1)
+            log_buf.append(indstr+ " }")
+        elif isinstance(value, list):
+            log_buf.append(prefix + "[")
+            for elem in value:
+                if isinstance(elem, dict):
+                    log(elem, indent + 1)
+                else:
+                    log_buf.append(indstr + "   " + str(elem))
+            log_buf.append(indstr+ " ]")
+        else:
+            log_buf.append(prefix + str(value))
+    log_buf.append(indstr + "---")
+    if indent == 0:
+        append(output_dir + 'yaml.log', log_buf)
+
+# Handle a YAML file with a callback
+def handle_yaml(filename, callback, saved_yaml = {}):
+    if filename not in saved_yaml:
+        print(str(len(saved_yaml) + 1) + ": Processing " + filename + " ...")
+        with open(filename) as stream:
+            loader = yaml.cyaml.CLoader if hasattr(yaml, "cyaml") else yaml.Loader
+            yaml_data = yaml.load(stream, Loader=loader)
+        saved_yaml[filename] = yaml_data
+        log(yaml_data, 0, "YAML file: " + filename)
+    else:
+        yaml_data = saved_yaml[filename]
+    callback(yaml_data)
+
+# Get the pointed-to type, e.g. FunctionNode of "class maplefe::FunctionNode *"
+def get_pointed(mtype):
+    loc = mtype.find("class maplefe::")
+    return mtype[loc + 15:-2] if loc >= 0 and mtype[-6:] == "Node *" else None
+
+# Get enum type, e.g. ImportProperty of "enum maplefe::ImportProperty"
+def get_enum_type(mtype):
+    loc = mtype.find("maplefe::")
+    return mtype[loc + 9:] if loc >= 0 else None
+
+# Get the enum list for given enum name
+def get_enum_list(dictionary, enum_name):
+    assert dictionary != None
+    enums = dictionary["ChildEnums"]
+    for e in enums:
+        for key, value in e.items():
+            if key == "Name" and value == enum_name:
+                return e["Members"]
+    return []
+
+# Generate functions for enum types, e.g. "const char *GetEnumOprId(OprId k);" for enum OprId
+def gen_enum_func(dictionary):
+    global include_file, src_file, gen_args
+    hcode = ['']
+    xcode = ['']
+    for each in dictionary["ChildEnums"]:
+        name = each["Name"]
+        hcode.append("static const char* GetEnum" + name + "(" + name + " k);")
+        xcode.extend(["const char* " + gen_args[1] + "::GetEnum" + name + "(" + name + " k) {",
+                      "switch(k) {"])
+        for e in get_enum_list(dictionary, name):
+            xcode.append('case ' + e + ': return "' + e + '";')
+        xcode.extend(['default: MASSERT(0 && "Unexpected enumerator");',
+                      '}',
+                      'return "UNEXPECTED ' + name + '";',
+                      '}\n'])
+    append(src_file, xcode)
+    append(include_file, hcode)
+
+# Generate code for class node which is derived from TreeNode
+def gen_handler_ast_node(dictionary):
+    global include_file, src_file, gen_args
+    code = ['']
+    node_name = dictionary["Name"];
+    assert dictionary["TagType"] == "Class"
+
+    member_functions = {}
+    child_functions = dictionary.get("ChildFunctions")
+    if child_functions != None:
+        for c in child_functions:
+            name = c.get("Name")
+            member_functions[name] = "R-" + str(c.get("ReturnType").get("Type").get("Name"))
+
+    # gen_func_definition() for the code at the beginning of current function body
+    code.append(gen_func_definition(dictionary, node_name))
+    members = dictionary.get("Members")
+    if members != None:
+        declloc = dictionary.get("DefLocation")
+        if gen_func_decl_location() and declloc != None and isinstance(declloc, dict):
+            fname = declloc.get("Filename")
+            floc = fname.find("shared/")
+            code.append("// Declared at " + fname[floc:] + ":" + str(declloc.get("LineNumber")))
+
+        for m in members:
+            name = m.get("Name")
+            assert name[0:1] == "m"
+            otype = m.get("Type").get("Name")
+            if otype == "_Bool": otype = "bool"
+
+            plural = "Get" + name[1:]
+
+            # m*Children to GetChild*()
+            if name[-8:] == "Children":
+                singular = "Get" + name[1:-3]
+
+            # m*Catches to GetCatch*(), m*Classes to GetClass*()
+            elif name[-4:] == "ches" or name[-4:] == "shes" or name[-4:] == "sses" or name[-4:] == "xes" :
+                singular = "Get" + name[1:-2]
+
+            # mIs* to Is*() for boolean type
+            elif name[:3] == "mIs" and otype == "bool":
+                plural = name[1:]
+                singular = name[1:]
+
+            # Default singular without the endding 's'
+            else:
+                singular = "Get" + name[1:-1]
+
+            ntype = get_pointed(otype)
+            access = m.get("Access")
+            accessstr = access if access != None else ""
+            if ntype != None:
+                if member_functions.get(plural) != None:
+                    # gen_call_child_node() for child node in current function body
+                    code.append(gen_call_child_node(dictionary, node_name, name, ntype, "node->" + plural + "()"))
+                else:
+                    # It is an ERROR if no member function for the child node
+                    code.append("Error!; // " + gen_call_child_node(dictionary, node_name, name, ntype, "node->" + plural + "()"))
+            elif ((otype == "SmallVector" or otype == "SmallList" or otype == "ExprListNode")
+                    and member_functions.get(plural + "Num") != None
+                    and (member_functions.get(singular) != None or member_functions.get(singular + "AtIndex") != None)):
+                func_name = singular if member_functions.get(singular) != None else singular + "AtIndex"
+                rtype = member_functions[func_name][2:]
+                if rtype == "_Bool": rtype = "bool"
+                ntype = get_pointed(rtype)
+                if (ntype != None or gen_call_handle_values()) and gen_children_num(plural) != None:
+                    # gen_call_children_node() for list or vector of nodes before entering the loop
+                    code.append(gen_call_children_node(dictionary, node_name, name, otype + "<" + rtype + ">", "node->" + plural + "Num()"))
+                    code.append("for(unsigned i = 0; i < " + gen_children_num(plural) + "; ++i) {")
+                    if ntype != None:
+                        # gen_call_nth_child_node() for the nth child node in the loop for the list or vector
+                        code.append(gen_call_nth_child_node(dictionary, node_name, name, ntype, "node->" + func_name + "(i)"))
+                    else:
+                        # gen_call_nth_child_value() for the nth child value in the loop for the list or vector
+                        code.append(gen_call_nth_child_value(dictionary, node_name, name, rtype, "node->" + func_name + "(i)"))
+                    code.append("}")
+                code.append(gen_call_children_node_end(dictionary, node_name, name, otype + "<" + rtype + ">", "node->" + plural + "Num()"))
+            elif gen_call_handle_values():
+                if member_functions.get(plural) != None:
+                    # gen_call_child_value() for child value in current function body
+                    code.append(gen_call_child_value(dictionary, node_name, name, otype, "node->" + plural + "()"))
+                else:
+                    # It is an ERROR if no member function for the child value
+                    code.append("Error!; // " + gen_call_child_value(dictionary, node_name, name, otype, "node->" + plural + "()"))
+
+    # gen_func_definition_end() for the code at the end of current function body
+    code.append(gen_func_definition_end(dictionary, node_name))
+    append(src_file, code)
+
+    code = []
+    code.append(gen_func_declaration(dictionary, node_name))
+    append(include_file, code)
+
+# Generate handler for TreeNode
+def gen_handler_ast_TreeNode(dictionary):
+    global include_file, src_file, gen_args
+    code = ['']
+    code.append(gen_func_declaration(dictionary, "TreeNode"))
+    append(include_file, code)
+
+    code = ['']
+    code.append(gen_func_definition(dictionary, "TreeNode"))
+
+    code.append("switch(" + gen_switch_expr() + ") {")
+    for flag in get_enum_list(dictionary, "NodeKind"):
+        code.append("case " + flag + ":");
+        node_name = flag[3:] + "Node"
+        filename = output_dir + 'maplefe/' + node_name + '.yaml'
+        if path.exists(filename):
+            # gen_call_child_node() for visiting child node
+            code.append(gen_call_child_node(dictionary, node_name, "", node_name, "static_cast<" + node_name + "*>(node)"))
+        elif node_name == "NullNode":
+            code.append("// Ignore NullNode")
+        else:
+            # it is an ERROR if the node kind is out of range
+            code.append("Error!!! // " + gen_call_child_node(dictionary, node_name, "", node_name, "static_cast<" + node_name + "*>(node)"))
+        code.append("break;");
+    code.append('default: MASSERT(0 && "Unexpected node kind");')
+    code.append("}")
+    code.append(gen_func_definition_end(dictionary, "TreeNode"))
+    append(src_file, code)
+
+# Handle each node which has TreeNode as its base
+def gen_handler_ast_node_file(dictionary):
+    base = dictionary.get("Bases")
+    if base != None:
+        basename = base[0].get("Name")
+        if basename == "TreeNode":
+            gen_handler_ast_node(dictionary)
+
+# Check each child records
+def gen_handler(dictionary):
+    child_records = dictionary["ChildRecords"]
+    for child in child_records:
+        value = child["Name"]
+        filename = output_dir + 'maplefe/' + value + '.yaml'
+        if path.exists(filename):
+            handle_yaml(filename, gen_handler_ast_node_file)
+    # Generate handler for TreeNode
+    gen_handler_ast_TreeNode(dictionary)
+
+################################################################################
+#                                                                              #
+#                           Signature of TreeNodes                             #
+#                                                                              #
+################################################################################
+
+def gen_signature_of_ast_node(dictionary):
+    global tn_signature
+    tn_signature += '\n^' + dictionary["Name"];
+    members = dictionary.get("Members")
+    if members != None:
+        for m in members:
+            tn_signature += '\n' + m.get("Name") + ':' + m.get("Type").get("Name")
+
+def gen_signature_of_ast_nodes(dictionary):
+    base = dictionary.get("Bases")
+    basename = base[0].get("Name") if base != None else ''
+    if basename == "TreeNode":
+        gen_signature_of_ast_node(dictionary)
+
+def gen_signature(dictionary):
+    for child in dictionary["ChildRecords"]:
+        filename = output_dir + 'maplefe/' + child["Name"] + '.yaml'
+        if path.exists(filename):
+            handle_yaml(filename, gen_signature_of_ast_nodes)
+
+tn_signature = 'Signature:'
+handle_yaml(initial_yaml, gen_signature)
+handle_yaml(treenode_yaml, gen_signature_of_ast_node)
+signature = int(hashlib.sha256(tn_signature.encode('utf-8')).hexdigest()[-15:], 16)
+append(output_dir + 'yaml.log', [tn_signature, str(signature)])
+
+################################################################################
+#                                                                              #
+#           Initialize/finalize include_file and src_file with gen_args        #
+#                                                                              #
+################################################################################
+
+Initialization = 1
+Finalization = 2
+def handle_src_include_files(phase):
+    global include_file, src_file, gen_args
+    include_file = output_dir + "shared/" + gen_args[0] + ".h"
+    src_file = output_dir + "shared/" + gen_args[0] + ".cpp"
+
+    include_start = [
+"""
+#ifndef __{gen_args1upper}_HEADER__
+#define __{gen_args1upper}_HEADER__
+
+#include "ast_module.h"
+#include "ast.h"
+#include "ast_type.h"
+#include "ast_attr.h"
+{gen_args3}
+
+namespace maplefe {{
+
+class {gen_args1} {gen_args4} {{
+""".format(gen_args1upper=gen_args[1].upper(), gen_args1=gen_args[1], gen_args3=gen_args[3], gen_args4=gen_args[4])
+] # include_start
+
+    include_end = [
+"""
+}};
+
+}}
+#endif
+""".format() # Use format() to match each pair of "{{" and "}}"
+] # include_end
+
+    src_start = [
+"""
+#include "{gen_args0}.h"
+
+namespace maplefe {{
+""".format(gen_args0=gen_args[0])
+] # src_start
+
+    src_end = [
+"""
+}}
+""".format() # Use format() to match each pair of "{{" and "}}"
+]
+    if phase == Initialization:
+        create(include_file, license_notice + include_start)
+        create(src_file, license_notice + src_start)
+    elif phase == Finalization:
+        finalize(include_file, include_end)
+        finalize(src_file, src_end)
+
+################################################################################
+#                                                                              #
+#                                AstDump                                       #
+#                                                                              #
+################################################################################
+
+def get_data_based_on_type(val_type, accessor):
+    if val_type[-10:] == "ASTScope *" or val_type[-12:] == "ASTScopePool":
+        return val_type + ': skipped"'
+    e = get_enum_type(val_type)
+    if e != None:
+        return e + ': " + GetEnum' + e + '(' + accessor + ')'
+    elif val_type == "LitData":
+        return 'LitData: LitId, " + GetEnumLitId(' + accessor + '.mType) + ", " + GetEnumLitData(' + accessor + ')'
+    elif val_type == "bool":
+        return val_type + ', ", ' + accessor
+    elif val_type == 'unsigned int' or val_type == 'uint32_t' or val_type == 'uint64_t' \
+            or val_type == 'unsigned' or val_type == 'int' or val_type == 'int32_t' or val_type == 'int64_t' :
+        if accessor.find("GetStrIdx()") >= 0:
+            return val_type + ', " + std::to_string(' + accessor + ') + " => " + (' + accessor \
+                    + '? "\\""s + gStringPool.GetStringFromStrIdx(' + accessor + ') + "\\""s : "null"s)'
+        return val_type + ', " + std::to_string(' + accessor + ')'
+    elif val_type == 'const char *':
+        return 'const char*, " + (' + accessor + ' ? "\\""s + EncodeLiteral(' + accessor + ') + "\\""s : "null"s)'
+    elif val_type == 'RegExprData':
+        return 'RegExprData, Expr: " + "\\""s + ' + accessor + '.mExpr + "\\", Flags: \\""s + (' \
+                + accessor + '.mFlags ? ' + accessor + '.mFlags : ""s) + "\\""s'
+    return val_type + ', " + "value" /* Warning: failed to get value */'
+
+def short_name(node_type):
+    return node_type.replace('class ', '').replace('maplefe::', '').replace(' *', '*')
+
+gen_padding = ''
+def padding_name(name):
+    return gen_padding + name.ljust(7)
+
+# The follwoing gen_func_* and gen_call* functions are for AstDump
+gen_children_num = lambda pl: 'node->' + pl + 'Num()'
+gen_switch_expr = lambda: 'node->GetKind()'
+gen_func_decl_location = lambda: True
+gen_call_handle_values = lambda: True
+gen_func_declaration = lambda dictionary, node_name: \
+        "void " + gen_args[2] + node_name + "(" + node_name + "* node);"
+gen_func_definition = lambda dictionary, node_name: \
+        "void " + gen_args[1] + "::" + gen_args[2] + node_name + "(" + node_name + "* node) {" \
+        + ('if (node == nullptr){return;}' if node_name == "TreeNode" else '\nif(DumpFB("' + node_name \
+        + '", node)) { MASSERT(node->Is' + node_name.replace('Node', '()') + ');')
+gen_call_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        ('Dump("' + padding_name(field_name) + ': ' + short_name(node_type) + '*", ' + accessor  + ');\n' \
+        if field_name != '' else '') + gen_args[2] + short_name(node_type) + '(' + accessor + ');'
+gen_call_child_value = lambda dictionary, node_name, field_name, val_type, accessor: \
+        'Dump("' + padding_name(field_name) + ': "s + "' + get_data_based_on_type(val_type, accessor) + ');'
+gen_call_children_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'DumpLB("' + padding_name(field_name) + ': ' + short_name(node_type) + ', size=", ' + accessor+ ');'
+gen_call_children_node_end = lambda dictionary, node_name, field_name, node_type, accessor: 'DumpLE(' + accessor + ');'
+gen_call_nth_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'Dump(std::to_string(i + 1) + ": ' + short_name(node_type) + '*", ' + accessor + ');\n' \
+        + gen_args[2] + short_name(node_type) + '(' + accessor + ');'
+gen_call_nth_child_value = lambda dictionary, node_name, field_name, val_type, accessor: \
+        'Dump(std::to_string(i) + ". ' + get_data_based_on_type(val_type, accessor) + ');'
+gen_func_definition_end = lambda dictionary, node_name: \
+        'return;\n}' if node_name == "TreeNode" else 'DumpFE();\n}\nreturn;\n}'
+
+#
+# Generate source files for dumping AST
+#
+gen_args = [
+        "gen_astdump", # Filename
+        "AstDump",     # Class name
+        "AstDump",     # Prefix of function name
+        """
+#include <sstream>
+using namespace std::string_literals;
+""",                   # Extra include directives
+        "",            # Base class
+        ]
+astdump = gen_args[0]
+astdumpclass = gen_args[1]
+prefixfuncname = gen_args[2]
+
+astdump_init = [
+"""
+private:
+ModuleNode    *mASTModule;
+std::ostream *mOs;
+int           indent;
+std::string   indstr;
+
+public:
+{gen_args1}(ModuleNode *m) : mASTModule(m), mOs(nullptr), indent(0) {{
+indstr = std::string(256, \' \');
+for(int i = 2; i < 256; i += 4)
+indstr.at(i) = \'.\';
+}}
+
+void Dump(const char *title, std::ostream *os) {{
+  mOs = os;
+  *mOs << "{gen_args1}: " << title << " {{\\n";
+  {gen_args2}TreeNode(mASTModule);
+  *mOs << "}}\\n";
+}}
+
+static std::string EncodeLiteral(std::string str) {{
+  std::string enc;
+  bool esc = false;
+  for (auto&c : str) {{
+    if(esc) {{
+      switch(c) {{
+        //case 'a': c = '\\a'; break; '\a' is 'a' in Javascript
+        case 'b': c = '\\b'; break;
+        case 'f': c = '\\f'; break;
+        case 'n': c = '\\n'; break;
+        case 'r': c = '\\r'; break;
+        case 't': c = '\\t'; break;
+        case 'v': c = '\\v'; break;
+        case '\\'': c = '\\''; break;
+        case '\\"': c = '"'; break;
+        default: enc += '\\\\';
+      }}
+      esc = false;
+    }} else if(c == '\\\\') {{
+      esc = true;
+      continue;
+    }}
+    switch(c) {{
+      case '"': enc += "\\\\\\""; break;
+      case '\\b': enc += "\\\\b"; break;
+      case '\\f': enc += "\\\\f"; break;
+      case '\\n': enc += "\\\\n"; break;
+      case '\\r': enc += "\\\\r"; break;
+      case '\\t': enc += "\\\\t"; break;
+      case '\\v': enc += "\\\\v"; break;
+      default: enc += c; // TODO: Unicode support
+    }}
+  }}
+  return enc;
+}}
+
+static std::string GetEnumLitData(LitData lit) {{
+  switch (lit.mType) {{
+    case LT_IntegerLiteral:
+      {{ std::stringstream s;
+         s << lit.mData.mInt;
+         return s.str();
+      }}
+    case LT_FPLiteral:
+      return std::to_string(lit.mData.mFloat);
+    case LT_DoubleLiteral:
+      return std::to_string(lit.mData.mDouble);
+    case LT_BooleanLiteral:
+      return lit.mData.mBool ? "true" : "false";
+    case LT_CharacterLiteral:
+      {{ std::string s = std::string(1, lit.mData.mChar.mData.mChar);
+         return EncodeLiteral(s);
+      }}
+    case LT_StringLiteral:
+      {{ std::string s = std::string(gStringPool.GetStringFromStrIdx(lit.mData.mStrIdx));
+         return EncodeLiteral(s);
+      }}
+    case LT_NullLiteral:
+      return "null";
+    case LT_ThisLiteral:
+      return "this";
+    case LT_SuperLiteral:
+      return "super";
+    case LT_VoidLiteral:
+      return "void 0";
+    case LT_NA:
+      return "NA";
+    default:
+      MASSERT(0 && "Unexpected LitData");
+  }}
+  return "Unexpected";
+}}
+
+private:
+void Dump(const std::string& msg) {{
+  *mOs << indstr.substr(0, indent) << msg << std::endl;
+}}
+
+void Dump(const std::string& msg, TreeNode *node) {{
+  *mOs << indstr.substr(0, indent) << msg << (node ? "" : ", null") << std::endl;
+}}
+
+void Dump(const std::string& msg, bool val) {{
+  *mOs << indstr.substr(0, indent) << msg << (val ? "true" : "false") << std::endl;
+}}
+
+TreeNode* DumpFB(const std::string& msg, TreeNode* node) {{
+  if (node != nullptr) {{
+    *mOs << indstr.substr(0, indent + 2) << msg;
+    indent += 4;
+    *mOs << " {{" << std::endl;
+    DumpTreeNode(node);
+  }}
+  return node;
+}}
+
+void DumpFE() {{
+  indent -= 4;
+  *mOs << indstr.substr(0, indent + 2) << "}}" << std::endl;
+}}
+
+void DumpLB(const std::string& msg, unsigned size) {{
+  *mOs << indstr.substr(0, indent) << msg << size << (size ? " [" : "") << std::endl;
+  indent += 4;
+}}
+
+void DumpLE(unsigned size) {{
+  indent -= 4;
+  if(size)
+    *mOs << indstr.substr(0, indent + 2) << "]" << std::endl;
+}}
+""".format(gen_args1=gen_args[1], gen_args2=gen_args[2])
+] # astdump_init
+
+handle_src_include_files(Initialization)
+append(include_file, astdump_init)
+handle_yaml(initial_yaml, gen_handler)
+append(include_file, ['','public:'])
+handle_yaml(initial_yaml, gen_enum_func)
+gen_args[2] = "Dump"
+gen_padding = "^ "
+gen_call_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+    ('Dump("' + padding_name(field_name) + ': ' + short_name(node_type) \
+    + '*, " + (' + accessor + ' ? "NodeId=" + std::to_string(' + accessor \
+    + '->GetNodeId()) : "null"s));\n' if field_name == "mParent" else \
+    'Dump("' + padding_name(field_name) + ': ' + short_name(node_type) + '*", ' + accessor + ');\n' \
+    + prefixfuncname + short_name(node_type) + '(' + accessor + ');') if field_name != '' else ''
+gen_call_nth_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+    'Dump(std::to_string(i + 1) + ": ' + short_name(node_type) + '*", ' + accessor + ');\n' \
+    + "Ast" + gen_args[2] + short_name(node_type) + '(' + accessor + ');'
+handle_yaml(treenode_yaml, gen_handler_ast_node)
+handle_src_include_files(Finalization)
+
+################################################################################
+#                                                                              #
+#                                AstVisitor                                    #
+#                                                                              #
+################################################################################
+
+def gen_setter(accessor):
+    return accessor.replace("Get", "Set").replace("()", "(n)").replace("(i)", "(i,n)")
+
+# The follwoing gen_func_* and gen_call* functions are for AstVisitor
+gen_call_handle_values = lambda: False
+gen_func_declaration = lambda dictionary, node_name: \
+        'virtual ' + node_name + '* ' + gen_args[2] + node_name + '(' + node_name + '* node);'
+gen_func_definition = lambda dictionary, node_name: \
+        node_name + '* ' + gen_args[1] + '::' + gen_args[2] + node_name + '(' + node_name \
+        + '* node) {\nif(node != nullptr' + (' && !IsVisited(node)) {' \
+        + '\nif(mTrace){std::cout << "Visiting ' + node_name + ', id=" << node->GetNodeId() << "..." << std::endl;}' \
+        + '\nBaseTreeNode(node);' if node_name != 'TreeNode' else ') {')
+gen_call_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        ('if(auto t = ' + accessor + ') {' + 'auto n = ' + gen_args[5] + node_type + '(t);' \
+        + 'if(n != t){' + gen_setter(accessor) + ';}}' if field_name != "mParent" else '') \
+        if field_name != '' else 'return ' + gen_args[5] + node_type + '(' + accessor + ');\n'
+gen_call_children_node = lambda dictionary, node_name, field_name, node_type, accessor: ''
+gen_call_children_node_end = lambda dictionary, node_name, field_name, node_type, accessor: ''
+gen_call_nth_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'if(auto t = ' + accessor + ') { auto n = ' + gen_args[5] + node_type + '(t);' \
+        + 'if(n != t) {' + gen_setter(accessor) + ';}}'
+gen_func_definition_end = lambda dictionary, node_name: '}\nreturn node;\n}'
+
+# -------------------------------------------------------
+gen_args = [
+        "gen_astvisitor", # Filename
+        "AstVisitor",     # Class name
+        "Visit",          # Prefix of function name
+        "",               # Extra include directives
+        "",               # Base class
+        "Visit",          # In body
+        ]
+astvisitor = gen_args[0]
+astvisitorclass = gen_args[1]
+
+astvisitor_init = [
+"""
+private:
+bool mTrace;
+BitVector mVisited;
+
+public:
+{gen_args1}(bool t = false) : mTrace(t) {{}}
+
+TreeNode* {gen_args2}(TreeNode* node) {{
+  mVisited.ClearAll();
+  return {gen_args2}TreeNode(node);
+}}
+
+virtual bool IsVisited(TreeNode* node) {{
+  if(mVisited.GetBit(node->GetNodeId()))
+    return true;
+  mVisited.SetBit(node->GetNodeId());
+  return false;
+}}
+""".format(gen_args1=gen_args[1], gen_args2=gen_args[2])
+] # astvisitor_init
+
+# Example to extract code pieces starting from initial_yaml
+handle_src_include_files(Initialization)
+append(include_file, astvisitor_init)
+handle_yaml(initial_yaml, gen_handler)
+gen_args[2] = "Base"
+handle_yaml(treenode_yaml, gen_handler_ast_node)
+handle_src_include_files(Finalization)
+
+################################################################################
+#                                                                              #
+#                                AstGraph                                      #
+#                                                                              #
+################################################################################
+
+# The follwoing gen_func_* and gen_call* functions are for AstGraph
+gen_func_declaration = lambda dictionary, node_name: \
+        'void ' + gen_args[2] + node_name + '(' + node_name + '* node);'
+gen_func_definition = lambda dictionary, node_name: \
+        'void ' + gen_args[1] + '::' + gen_args[2] + node_name + '(' + node_name + '* node) {' \
+        + '\nif(node != nullptr' + (' && PutNode(node)) {\nHandleTreeNode(node);' \
+        if node_name != "TreeNode" else ') {')
+gen_call_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'if(auto t = ' + accessor + ') {' + ('PutEdge(node, t, "' + field_name[1:] + \
+        '", NK_' + node_type.replace('Node', '').replace('Tree', 'Null') + ');' \
+        if field_name != '' else '') + gen_args[2] + node_type + '(t);}'
+gen_call_nth_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'if(auto t = ' + accessor + ') { PutChildEdge(node, t, "' + field_name[1:] \
+        + '", i, NK_' + node_type.replace('Node', '').replace('Tree', 'Null') \
+        + '); ' + gen_args[2] + node_type + '(t);}'
+gen_func_definition_end = lambda dictionary, node_name: '}\n}'
+
+# -------------------------------------------------------
+gen_args = [
+        "gen_astgraph", # Filename
+        "AstGraph",     # Class name
+        "DumpGraph",    # Prefix of function name
+        """
+#include "stringpool.h"
+#include "{astdump}.h"
+#include <algorithm>
+#include <set>
+#include <cctype>
+#include <cstring>""".format(astdump = astdump),  # Extra include directives
+        "",            # Base class
+        ]
+
+astgraph_init = [
+"""
+public:
+{gen_args1}(TreeNode *m) : mRoot(m), mOs(nullptr) {{}}
+
+#define NodeName(n,s)  ({astdumpclass}::GetEnumNodeKind((n)->GetKind()) + 3) << s << n->GetNodeId()
+#define EnumVal(t,e,m) {astdumpclass}::GetEnum##e((static_cast<t *>(n))->Get##m())
+#define NodeColor(c)   "\\",style=filled,color=white,fillcolor=\\""#c
+
+void {gen_args2}(const char *title, std::ostream *os) {{
+  mNodes.clear();
+  mOs = os;
+  mTitle = title;
+  *mOs << "digraph AST_Module {{\\nrankdir=LR;\\n";
+  {gen_args2}TreeNode(mRoot);
+  *mOs << "}}\\n";
+}}
+
+bool PutNode(TreeNode *n) {{
+  if(n && mNodes.find(n) == mNodes.end()) {{
+    mNodes.insert(n);
+    *mOs << NodeName(n,\'_\') << " [label=\\"" << NodeName(n,',') << "\\\\n";
+    std::string tid(EnumVal(TreeNode, TypeId, TypeId));
+    if(tid != "TY_None" || n->GetTypeIdx() != 0) *mOs << "<" << tid << " " << n->GetTypeIdx() << ">\\\\n";
+
+    switch(n->GetKind()) {{
+      case NK_Module:    {{
+                           auto fn = static_cast<ModuleNode *>(n)->GetFilename();
+                           if(auto p = std::strrchr(fn, '/'))
+                             fn = p + 1;
+                           *mOs << fn << "\\\\n" << mTitle << "\\",shape=\\"box"; break;
+                         }}
+      case NK_Function:    *mOs << (n->GetStrIdx() ? n->GetName() : "_anonymous_") << NodeColor(lightcoral); break;
+      case NK_Lambda:      *mOs << NodeColor(pink); break;
+      case NK_Call:        *mOs << NodeColor(burlywood); break;
+      case NK_Class:       *mOs << (n->GetStrIdx() ? n->GetName() : ""); break;
+      case NK_Block:       *mOs << NodeColor(lightcyan); break;
+      case NK_CondBranch:  *mOs << NodeColor(lightblue); break;
+      case NK_Return:      *mOs << NodeColor(tan); break;
+      case NK_Break:       *mOs << NodeColor(peachpuff); break;
+      case NK_Continue:    *mOs << NodeColor(paleturquoise); break;
+      case NK_SwitchCase:
+      case NK_SwitchLabel:
+      case NK_Switch:      *mOs << NodeColor(powderblue); break;
+      case NK_ForLoop:     *mOs << EnumVal(ForLoopNode, ForLoopProp, Prop);
+      case NK_WhileLoop:
+      case NK_DoLoop:      *mOs << NodeColor(lightskyblue); break;
+      case NK_Identifier:  *mOs << "\\\\\\"" << n->GetName() << "\\\\\\"" << NodeColor(wheat); break;
+      case NK_Decl:        *mOs << EnumVal(DeclNode, DeclProp, Prop) << NodeColor(palegoldenrod); break;
+      case NK_PrimType:    *mOs << EnumVal(PrimTypeNode, TypeId, PrimType) << NodeColor(lemonchiffon); break;
+      case NK_BinOperator: *mOs << EnumVal(BinOperatorNode, OprId, OprId);
+      case NK_TerOperator:
+                           *mOs << NodeColor(palegreen); break;
+      case NK_UnaOperator: *mOs << EnumVal(UnaOperatorNode, OprId, OprId);
+      case NK_InstanceOf:
+      case NK_TypeOf:      *mOs << NodeColor(lightgreen); break;
+      case NK_Literal:     {{
+                             std::string s({astdumpclass}::GetEnumLitData(static_cast<LiteralNode *>(n)->GetData()));
+                             std::replace(s.begin(), s.end(), '"', ':');
+                             *mOs << s;
+                             break;
+                           }}
+      case NK_Pass:        *mOs << NodeColor(darkgrey); break;
+      case NK_AsType:      *mOs << NodeColor(bisque); break;
+      case NK_New:         *mOs << NodeColor(khaki); break;
+      case NK_Try:         *mOs << NodeColor(plum); break;
+      case NK_Catch:       *mOs << NodeColor(thistle); break;
+      case NK_Finally:     *mOs << NodeColor(thistle); break;
+      case NK_Throw:       *mOs << NodeColor(plum); break;
+      case NK_Dimension:   *mOs << static_cast<DimensionNode *>(n)->GetDimensionsNum() << " dim(s)"; break;
+      case NK_UserType:    *mOs << EnumVal(UserTypeNode, UT_Type, Type); break;
+      case NK_XXportAsPair: *mOs << (static_cast<XXportAsPairNode*>(n)->IsDefault() ? "default" : "");
+                            *mOs << (static_cast<XXportAsPairNode*>(n)->IsRef() ? " ref" : " copy"); break;
+      case NK_Struct:      *mOs << EnumVal(StructNode, StructProp, Prop); *mOs << "\\\\n" << n->GetName(); break;
+    }}
+    if(n->IsStmt())
+       *mOs << "\\",penwidth=2,color=\\"tomato";
+    *mOs << "\\"];\\n";
+    return true;
+  }}
+  return false;
+}}
+
+void PutEdge(TreeNode *from, TreeNode *to, const char *field, NodeKind k) {{
+  if(to)
+    *mOs << NodeName(from,\'_\') << " -> " << NodeName(to,\'_\') << "[label=" << field
+      << (to->GetParent() == from ? ",arrowhead=diamond" : "") << "];\\n";
+}}
+
+void PutChildEdge(TreeNode *from, TreeNode *to, const char *field, unsigned idx, NodeKind k) {{
+  if(to)
+    *mOs << NodeName(from,\'_\') << " -> " << NodeName(to,\'_\') << "[label=\\"" << field
+      << "[" << idx << "]\\"" << (to->GetParent() == from ? ",arrowhead=diamond" : "") << "];\\n";
+}}
+
+void HandleTreeNode(TreeNode *node) {{
+  if (auto t = node->GetLabel()) {{
+    PutEdge(node, t, "Label", NK_Null);
+    DumpGraphTreeNode(t);
+  }}
+  for (unsigned i = 0; i < node->GetAsTypesNum(); ++i)
+    if (auto t = node->GetAsTypeAtIndex(i)) {{
+      PutChildEdge(node, t, "AsTypes", i, NK_AsType);
+      DumpGraphAsTypeNode(t);
+    }}
+}}
+
+private:
+TreeNode             *mRoot;
+std::ostream         *mOs;
+std::set<TreeNode *>  mNodes;
+const char           *mTitle;
+""".format(gen_args1=gen_args[1], gen_args2=gen_args[2], astdumpclass=astdumpclass)
+] # astgraph_init
+
+handle_src_include_files(Initialization)
+append(include_file, astgraph_init)
+handle_yaml(initial_yaml, gen_handler)
+handle_src_include_files(Finalization)
+
+################################################################################
+#                                                                              #
+#                                  Emitter                                     #
+#                                                                              #
+################################################################################
+
+def get_data_based_on_type(val_type, accessor):
+    e = get_enum_type(val_type)
+    if e == "ASTScope *":
+        return e + ': " + "' + accessor + '");'
+    elif e != None:
+        return astdumpclass + '::GetEnum' + e + '(' + accessor + ')'
+    elif val_type == "LitData":
+        return astdumpclass + '::GetEnumLitData(' + accessor + ')'
+    elif val_type == "bool":
+        return 'std::to_string(' + accessor + ')'
+    elif val_type == 'unsigned int' or val_type == 'uint32_t' or val_type == 'uint64_t' \
+            or val_type == 'unsigned' or val_type == 'int' or val_type == 'int32_t' or val_type == 'int64_t' :
+        return 'std::to_string(' + accessor + ')'
+    elif val_type == 'const char *':
+        return 'std::to_string(' + accessor + ' ? std::string("\\"") + ' + accessor + ' + "\\"" : "null")'
+    return 'Warning: failed to get value with ' + val_type + ", " + accessor
+
+def short_name(node_type):
+    return node_type.replace('class ', '').replace('maplefe::', '').replace(' *', '*')
+
+# The follwoing gen_func_* and gen_call* functions are for Emitter
+gen_func_decl_location = lambda: False
+gen_call_handle_values = lambda: True
+gen_func_declaration = lambda dictionary, node_name: \
+        "virtual std::string " + gen_args[2] + node_name + "(" + node_name + "* node);"
+gen_func_definition = lambda dictionary, node_name: \
+        "std::string " + gen_args[1] + "::" + gen_args[2] + node_name + "(" + node_name + "* node) {" \
+        + 'if (node == nullptr) \nreturn std::string();' \
+        + ('' if node_name == "TreeNode" else \
+        'std::string str;')
+gen_call_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'if(auto n = ' + accessor + ') {str += " "s + ' + gen_args[2] + short_name(node_type) + '(n);}' \
+        if field_name != '' else \
+        'return ' + gen_args[2] + short_name(node_type) + '(' + accessor + ');'
+gen_call_child_value = lambda dictionary, node_name, field_name, val_type, accessor: \
+        'str += " "s + ' + get_data_based_on_type(val_type, accessor) + ';'
+gen_call_nth_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'if(i)str+= ", "s; if(auto n = ' + accessor + ') {str += " "s + ' + gen_args[2] + short_name(node_type) + '(n);}'
+gen_call_nth_child_value = lambda dictionary, node_name, field_name, val_type, accessor: \
+        'str += " "s + ' + get_data_based_on_type(val_type, accessor) + ';'
+gen_func_definition_end = lambda dictionary, node_name: \
+        'mPrecedence = \'\\030\'; if(node->IsStmt()) str += ";\\n"s;' \
+        + 'return str;}' if node_name != "TreeNode" else 'return std::string();}'
+
+#
+gen_args = [
+        "gen_emitter",   # Filename
+        "Emitter",       # Class name
+        "Emit",          # Prefix of function name
+        """
+#include "ast_handler.h"
+#include "{astdump}.h"
+using namespace std::string_literals;
+""".format(astdump = astdump),  # Extra include directives
+        ""
+        "",             # Base class
+        ]
+
+astemit_init = [
+"""
+protected:
+using Precedence = unsigned char;
+Precedence    mPrecedence;
+
+Module_Handler *mHandler;
+
+public:
+{gen_args1}(Module_Handler *h) : mHandler(h) {{}}
+
+std::string {gen_args2}(const char *title);
+std::string GetEnding(TreeNode *n);
+std::string Clean(std::string &s);
+std::string GetBaseFilename();
+std::string GetModuleName(const char *p = nullptr);
+
+ModuleNode *GetASTModule() {{ return mHandler->GetASTModule(); }}
+
+""".format(gen_args1=gen_args[1], gen_args2=gen_args[2])
+] # astemit_init
+
+if False:
+    handle_src_include_files(Initialization)
+    append(src_file, ['using namespace std::string_literals;'])
+    append(include_file, astemit_init)
+    handle_yaml(initial_yaml, gen_handler)
+    handle_src_include_files(Finalization)
+
+################################################################################
+#                                                                              #
+#                                AstStore                                      #
+#                                                                              #
+################################################################################
+
+def get_data_based_on_type(val_type, accessor):
+    if val_type[-10:] == "ASTScope *" or val_type[-12:] == "ASTScopePool":
+        return '; // Skip ' + val_type
+    e = get_enum_type(val_type)
+    if e != None:
+        return 'WriteValue(static_cast<int64_t>(' + accessor + '));'
+    elif val_type == "bool":
+        return 'WriteValue(static_cast<int64_t>(' + accessor + '));'
+    elif val_type == 'unsigned int' or val_type == 'uint32_t' or val_type == 'uint64_t' \
+            or val_type == 'unsigned' or val_type == 'int' or val_type == 'int32_t' or val_type == 'int64_t' :
+        return ('AddStrIdx(' + accessor + ');' if accessor.find("GetStrIdx()") >= 0 else '') \
+                + 'WriteValue(static_cast<int64_t>(' + accessor + '));'
+    elif val_type == "LitData":
+        return 'if(' + accessor + '.mType == LT_StringLiteral) AddStrIdx(' + accessor + '.mData.mStrIdx);' \
+                + 'WriteValue(static_cast<int64_t>(' + accessor + '.mType));' \
+                + 'WriteValue(' + accessor + '.mData.mInt64);'
+    elif val_type == 'const char *':
+        return 'WriteString(' + accessor + ');'
+    elif val_type == 'RegExprData':
+        return 'WriteString(' + accessor + '.mExpr);\nWriteString(' + accessor + '.mFlags);'
+    return 'Failed to get value with ' + val_type + ", " + accessor + ';'
+
+def short_name(node_type):
+    return node_type.replace('class ', '').replace('maplefe::', '').replace(' *', '*')
+
+# The follwoing gen_func_* and gen_call* functions are for AstStore
+#
+gen_func_decl_location = lambda: False
+gen_call_handle_values = lambda: True
+gen_func_declaration = lambda dictionary, node_name: \
+        "void " + gen_args[2] + node_name + "(" + node_name + "* node);"
+gen_func_definition = lambda dictionary, node_name: \
+        "void " + gen_args[1] + "::" + gen_args[2] + node_name + "(" + node_name + "* node) {" \
+        + ('' if node_name == "TreeNode" else 'WriteNode(node);')
+gen_call_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'WriteAddress(' + accessor + '); // ' + field_name + ': ' + node_type if field_name != '' else \
+        gen_args[2] + short_name(node_type) + '(' + accessor + ');'
+gen_call_child_value = lambda dictionary, node_name, field_name, val_type, accessor: \
+        get_data_based_on_type(val_type, accessor) + ' // ' + field_name + ': ' + val_type
+gen_call_children_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'WriteLength(' + accessor + '); // ' + field_name + ': ' + node_type
+gen_call_nth_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        'WriteAddress(' + accessor + '); // '  + field_name + ': ' + node_type
+gen_call_nth_child_value = lambda dictionary, node_name, field_name, val_type, accessor: \
+        get_data_based_on_type(val_type, accessor) + ' // ' + field_name + ': ' + val_type
+gen_func_definition_end = lambda dictionary, node_name: '}'
+#
+gen_args = [
+        "gen_aststore", # Filename
+        "AstStore",     # Class name
+        "Store",        # Prefix of function name
+        """
+#include "stringpool.h"
+#include "{astvisitor}.h"
+#include <cstring>
+#include <cstdint>
+#include <set>
+namespace maplefe {{
+using AstBuffer  = std::vector<uint8_t>;
+using AstNodeVec = std::vector<TreeNode*>;
+}}
+""".format(astvisitor=astvisitor),
+        ": public " + astvisitorclass, # Base class
+        ]
+
+#tag_control = 'true'
+tag_control = "tag != 'A' && tag != 'V'"
+
+aststore_init = [
+"""
+private:
+ModuleNode         *mASTModule;
+AstBuffer           mAstBuf {{'M', 'P'}};
+AstBuffer          *mBufPtr;
+std::set<unsigned>  mStrIdxSet;
+
+public:
+{gen_args1}(ModuleNode *m) : mASTModule(m) {{}}
+
+AstBuffer& GetAstBuf() {{return mAstBuf;}}
+
+bool {gen_args2}InAstBuf() {{
+  AstBuffer node_buf;
+  mAstBuf.erase(mAstBuf.begin() + 2, mAstBuf.end());
+  mBufPtr = &mAstBuf;
+  WriteNum('L', {signature}LL);
+  mAstBuf.reserve(32768); // For performance
+  node_buf.reserve(32768);
+  mBufPtr = &node_buf;
+  VisitTreeNode(mASTModule);
+  mBufPtr = &mAstBuf;
+  WriteStrIdxTable();
+  mAstBuf.insert(mAstBuf.end(), node_buf.begin(), node_buf.end());
+  mStrIdxSet.clear();
+  return true;
+}}
+
+bool IsVisited(TreeNode* node) {{
+  if({astvisitorclass}::IsVisited(node))
+    return true;
+  {gen_args2}TreeNode(node);
+  return false;
+}}
+
+// Tags:
+//   'N': Beginning of a tree node
+//   'A': address of a child tree node
+//   'V': value of a field in a tree node
+//   'L': list/vector of chrildren in a tree node
+//   'S': char string of a field in a tree node
+//   'T': StrIdx Table
+// The initial version will keep all tags, and some of them can be optimized out
+
+// LEB128, same as for MapleIR
+void WriteNum(uint8_t tag, int64_t x) {{
+  if({tag_control})
+    mBufPtr->push_back(tag);
+  while (x < -0x40 || x >= 0x40) {{
+    mBufPtr->push_back(static_cast<uint8_t>((static_cast<uint64_t>(x) & 0x7F) + 0x80));
+    x = x >> 7;
+  }}
+  mBufPtr->push_back(static_cast<uint8_t>(static_cast<uint64_t>(x) & 0x7F));
+}}
+
+void WriteNode(TreeNode *node) {{
+  AstBuffer *tmp = mBufPtr;
+  mBufPtr = &mAstBuf;
+  WriteNum('N', static_cast<int64_t>(node->GetKind()));
+  WriteNum('V', static_cast<int64_t>(node->GetNodeId()));
+  mBufPtr = tmp;
+  //WriteNum('N', static_cast<int64_t>(node->GetKind()));
+  WriteTreeNode(node); // Base TreeNode
+}}
+
+void WriteAddress(TreeNode *node) {{
+  if(node)
+    WriteNum('A', static_cast<int64_t>(node->GetNodeId()));
+  else
+    WriteNum('A', -1);
+}}
+
+void WriteValue(int64_t val) {{
+  WriteNum('V', val);
+}}
+
+void WriteLength(unsigned len) {{
+  WriteNum('L', static_cast<int64_t>(len));
+}}
+
+void WriteString(const char *str) {{
+  if(const char *p = str) {{
+    WriteNum('S', static_cast<int64_t>(std::strlen(p) + 1));
+    do {{
+      mBufPtr->push_back(static_cast<uint8_t>(*p));
+    }} while(*p++);
+  }} else
+    WriteNum('S', 0);
+}}
+
+void WriteStrIdxTable() {{
+  WriteNum('T', static_cast<int64_t>(mStrIdxSet.size()));
+  for(auto s: mStrIdxSet) {{
+    WriteValue(s);
+    WriteString(gStringPool.GetStringFromStrIdx(s));
+  }}
+}}
+
+void AddStrIdx(unsigned idx) {{
+  if(idx)
+    mStrIdxSet.insert(idx);
+}}
+
+""".format(signature=signature, gen_args1=gen_args[1], gen_args2=gen_args[2], \
+        astvisitorclass=astvisitorclass, tag_control=tag_control)
+] # aststore_init
+
+handle_src_include_files(Initialization)
+append(src_file, ['using namespace std::string_literals;'])
+append(include_file, aststore_init)
+handle_yaml(initial_yaml, gen_handler)
+gen_args[2] = "Write"
+handle_yaml(treenode_yaml, gen_handler_ast_node)
+handle_src_include_files(Finalization)
+
+################################################################################
+#                                                                              #
+#                                AstLoad                                       #
+#                                                                              #
+################################################################################
+
+def gen_setter(accessor):
+    return accessor.replace("Get", "Set").replace("()", "(n)").replace("(i)", "(i,n)").replace("Is", "SetIs")
+
+def gen_add_setter(accessor):
+    return accessor.replace("Get", "Add").replace("AtIndex", "").replace("(i)", "(n)")
+
+def short_name(node_type):
+    return node_type.replace('class ', '').replace('maplefe::', '').replace(' *', '*')
+
+def set_data_based_on_type(val_type, accessor, setter):
+    if val_type[-10:] == "ASTScope *" or val_type[-12:] == "ASTScopePool":
+        return '; /* Skip ' + val_type + ' */'
+    e = get_enum_type(val_type)
+    if e != None:
+        return e + ' n = static_cast<' + e + '>(ReadValue());' + setter(accessor) + ';'
+    elif val_type == "bool":
+        return val_type + ' n = static_cast<' + val_type + '>(ReadValue());' + setter(accessor) + ';'
+    elif val_type == 'unsigned int' or val_type == 'uint32_t' or val_type == 'uint64_t' \
+            or val_type == 'unsigned' or val_type == 'int' or val_type == 'int32_t' or val_type == 'int64_t' :
+        return (val_type + ' n = static_cast<' + val_type + '>(ReadValue());' if accessor.find("GetStrIdx()") < 0 \
+           else val_type + ' n = static_cast<' + val_type + '>(mStrMap[ReadValue()]);') \
+           + (setter(accessor) + ';' if accessor.find("GetNodeId()") < 0 else '/* ' + setter(accessor) + '; */')
+    elif val_type == "LitData":
+        return val_type + ' n; n.mType = static_cast<LitId>(ReadValue());if(n.mType == LT_StringLiteral)' \
+           + 'n.mData.mInt64 = mStrMap[ReadValue()]; else n.mData.mInt64 = ReadValue();' + setter(accessor) + ';'
+    elif val_type == 'const char *':
+        return val_type + ' n = ReadString();' + setter(accessor) + ';'
+    elif val_type == 'RegExprData':
+        return val_type + ' n; n.mExpr = ReadString(); n.mFlags = ReadString();' + setter(accessor) + ';'
+    return 'Failed to get value with ' + val_type + ", " + accessor + ';'
+
+# The follwoing gen_func_* and gen_call* functions are for AstLoad
+#
+gen_children_num = lambda pl: 'num'
+gen_func_decl_location = lambda: False
+gen_call_handle_values = lambda: True
+gen_func_declaration = lambda dictionary, node_name: \
+        "void " + gen_args[2] + node_name + '(' + node_name + ' *node);'
+gen_func_definition = lambda dictionary, node_name: \
+        "void " + gen_args[1] + "::" + gen_args[2] + node_name + '(' + node_name + ' *node) {\n' \
+        + ('' if node_name == "TreeNode" else 'InitTreeNode(node);')
+gen_call_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        '{' + node_type + '* n = static_cast<' + node_type + '*>(ReadAddress()); ' + gen_setter(accessor) \
+        + '; } // ' + field_name + ': ' + node_type \
+        if field_name != '' else gen_args[2] + short_name(node_type) + '(static_cast<' + short_name(node_name) + '*>(node));'
+gen_call_child_value = lambda dictionary, node_name, field_name, val_type, accessor: \
+        '{' + set_data_based_on_type(val_type, accessor, gen_setter) + '} // ' + field_name + ': ' + val_type
+gen_call_children_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        '{unsigned num = ReadLength(); // ' + field_name + ': ' + node_type
+gen_call_nth_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        node_type + '* n = static_cast<' + node_type + '*>(ReadAddress()); ' + gen_add_setter(accessor) \
+        + '; // ' + field_name + ': ' + node_type
+gen_call_nth_child_value = lambda dictionary, node_name, field_name, val_type, accessor: \
+        '{' + set_data_based_on_type(val_type, accessor, gen_add_setter) + '} // ' + field_name + ': ' + val_type
+gen_call_children_node_end = lambda dictionary, node_name, field_name, node_type, accessor: '}'
+gen_func_definition_end = lambda dictionary, node_name: 'return;}'
+#
+gen_args = [
+        "gen_astload", # Filename
+        "AstLoad",     # Class name
+        "Load",        # Prefix of function name
+        """
+#include "stringpool.h"
+#include "ast_mempool.h"
+#include "{astvisitor}.h"
+#include <cstring>
+#include <cstdint>
+#include <set>
+#include <unordered_map>
+namespace maplefe {{
+using AstBuffer  = std::vector<uint8_t>;
+using AstBufIter = std::vector<uint8_t>::iterator;
+using AstNodeVec = std::vector<TreeNode*>;
+using AstNodeMap = std::unordered_map<unsigned, TreeNode*>;
+using AstStrMap  = std::unordered_map<unsigned, unsigned>;
+}}
+""".format(astvisitor=astvisitor),
+        ""             # Base class
+        ]
+
+astload_init = [
+"""
+private:
+AstBufIter  it;
+AstBufIter  end;
+AstStrMap   mStrMap;  // key: previous str id,  val: new str id
+AstNodeMap  mNodeMap; // key: previous node id, val: TreeNode*
+
+public:
+ModuleNode *{gen_args2}FromAstBuf(AstBuffer &buf) {{
+  it = buf.begin();
+  end = buf.end();
+  return Next();
+}}
+
+ModuleNode *Next() {{
+  if(it == end)
+    return nullptr;
+  bool check = *it++ == 'M';
+  check &= *it++ == 'P';
+  if(!check) {{
+    std::cerr << "Error: Unknown file type." << std::endl;
+    return nullptr;
+  }}
+  int64_t sig = ReadNum('L');
+  if(sig != {signature}LL) {{
+    std::cerr << "Error: Unknown signature " << sig << ". Expected {signature}." << std::endl;
+    return nullptr;
+  }}
+  AstNodeVec node_vec;
+  while(*it != 'T')
+    node_vec.push_back(CreateNode());
+  ModuleNode *module = static_cast<ModuleNode *>(node_vec.front());
+  ReadStrIdxTable();
+  for(auto iter = node_vec.begin(); iter != node_vec.end(); ++iter)
+    ReadNode(*iter);
+  mStrMap.clear();
+  mNodeMap.clear();
+  return module;
+}}
+
+TreeNode *CreateNode() {{
+  NodeKind k = static_cast<NodeKind>(ReadNum('N'));
+  unsigned id = static_cast<unsigned>(ReadNum('V'));
+  TreeNode *node = CreateTreeNode(k);
+  mNodeMap[id] = node;
+  return node;
+}}
+
+// LEB128, same as for MapleIR
+int64_t ReadNum(uint8_t tag) {{
+  if({tag_control}) {{
+    bool check = tag == *it++;
+    MASSERT(check);
+  }}
+  uint64_t n = 0;
+  int64_t y = 0;
+  uint64_t b = static_cast<uint64_t>(*it++);
+  while (b >= 0x80) {{
+    y += ((b - 0x80) << n);
+    n += 7;
+    b = static_cast<uint64_t>(*it++);
+  }}
+  b = (b & 0x3F) - (b & 0x40);
+  return y + (b << n);
+}}
+
+void ReadNode(TreeNode *node) {{
+  //NodeKind k = static_cast<NodeKind>(ReadNum('N'));
+  //MASSERT(k == node->GetKind());
+  LoadTreeNode(node);
+}}
+
+TreeNode *ReadAddress() {{
+  int64_t n = ReadNum('A');
+  return n != -1 ? mNodeMap[static_cast<unsigned>(n)] : nullptr;
+}}
+
+int64_t ReadValue() {{
+  return ReadNum('V');
+}}
+
+int64_t ReadLength() {{
+  return ReadNum('L');
+}}
+
+const char *ReadString() {{
+  int64_t len = ReadNum('S');
+  if(len) {{
+    const char *res = gStringPool.FindString(reinterpret_cast<const char *>(&(*it)));
+    it += len;
+    return res;
+  }} else
+    return nullptr;
+}}
+
+void ReadStrIdxTable() {{
+  int64_t num = ReadNum('T');
+  for(int64_t i = 0; i < num; ++i) {{
+    unsigned id = static_cast<unsigned>(ReadValue());
+    const char *s = ReadString();
+    unsigned nid = gStringPool.GetStrIdx(s);
+    mStrMap[id] = nid;
+  }}
+}}
+
+""".format(signature=signature, gen_args1=gen_args[1], gen_args2=gen_args[2], \
+        astvisitorclass=astvisitorclass, tag_control=tag_control)
+] # astload_init
+
+handle_src_include_files(Initialization)
+append(src_file, ['using namespace std::string_literals;'])
+append(include_file, astload_init)
+handle_yaml(initial_yaml, gen_handler)
+gen_args[2] = "Init"
+gen_func_declaration = lambda dictionary, node_name: \
+        'void ' + gen_args[2] + node_name + '(TreeNode *node);'
+gen_func_definition = lambda dictionary, node_name: \
+        'void ' + gen_args[1] + "::" + gen_args[2] + node_name + '(TreeNode *node) {'
+gen_func_definition_end = lambda dictionary, node_name: '}'
+handle_yaml(treenode_yaml, gen_handler_ast_node)
+gen_args[2] = "Create"
+gen_switch_expr = lambda: 'k'
+gen_children_num = lambda pl: None
+gen_call_handle_values = lambda: False
+gen_func_declaration = lambda dictionary, node_name: \
+        node_name + "* " + gen_args[2] + node_name + "(NodeKind k);"
+gen_func_definition = lambda dictionary, node_name: \
+        node_name + "* " + gen_args[1] + "::" + gen_args[2] + node_name + "(NodeKind k) {\n" \
+        + (node_name + ' *node;' if node_name == "TreeNode" else \
+        node_name + ' *node = new (gTreePool.NewTreeNode(sizeof(' + node_name + '))) ' + node_name + '();')
+gen_call_child_node = lambda dictionary, node_name, field_name, node_type, accessor: \
+        '' if field_name != '' else 'node = ' + gen_args[2] + short_name(node_type) + '(k);'
+gen_call_children_node = lambda dictionary, node_name, field_name, node_type, accessor: ''
+gen_call_nth_child_node = lambda dictionary, node_name, field_name, node_type, accessor: ''
+gen_call_children_node_end = lambda dictionary, node_name, field_name, node_type, accessor: ''
+gen_func_definition_end = lambda dictionary, node_name: 'return node;}'
+handle_yaml(initial_yaml, gen_handler)
+handle_src_include_files(Finalization)
diff --git a/src/MapleFE/scripts/perf-java.sh b/src/MapleFE/scripts/perf-java.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b838fd3675cf0b76f7ba0a6bc9aee3d477e59d70
--- /dev/null
+++ b/src/MapleFE/scripts/perf-java.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+# This script is to measure the runtime performance of java2ast and other executables
+# If perf is not installed yet, please install the package linux-tools-common with all dependencies
+TS2AST=$(dirname $0)/../output/java/bin/java2ast
+CMD="sudo perf record -e cpu-cycles,cache-misses --call-graph fp -F 10000 -o perf.data"
+if [ $# -eq 0 ]; then
+  echo "Usage: $0 <TypeScript-filename.ts>"
+  echo "       $0 <command-with-arguments>"
+  exit 1
+elif [ $# -eq 1 -a "$(basename $1)" != "$(basename $1 .ts)" ]; then
+  echo $CMD $TS2AST "$@"
+  $CMD $TS2AST "$@"
+else
+  echo $CMD "$@"
+  $CMD "$@"
+fi
+echo sudo perf report
+sudo perf report
diff --git a/src/MapleFE/scripts/perf.sh b/src/MapleFE/scripts/perf.sh
new file mode 100755
index 0000000000000000000000000000000000000000..7d3c9bbbd695f5b0d3896bd344bc96d72839da3b
--- /dev/null
+++ b/src/MapleFE/scripts/perf.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+# This script is to measure the runtime performance of ts2ast and other executables
+# If perf is not installed yet, please install the package linux-tools-common with all dependencies
+TS2AST=$(dirname $0)/../output/typescript/bin/ts2ast
+CMD="sudo perf record -e cpu-cycles,cache-misses --call-graph fp -F 10000 -o perf.data"
+if [ $# -eq 0 ]; then
+  echo "Usage: $0 <TypeScript-filename.ts>"
+  echo "       $0 <command-with-arguments>"
+  exit 1
+elif [ $# -eq 1 -a "$(basename $1)" != "$(basename $1 .ts)" ]; then
+  echo $CMD $TS2AST "$@"
+  $CMD $TS2AST "$@"
+else
+  echo $CMD "$@"
+  $CMD "$@"
+fi
+echo sudo perf report
+sudo perf report
diff --git a/src/MapleFE/shared/Makefile b/src/MapleFE/shared/Makefile
index 23e7e196bb2a0b8fc522c57cf1eff8239f2bbef3..a36bf4408e58eba9d2274287221a13d0f1b632a0 100644
--- a/src/MapleFE/shared/Makefile
+++ b/src/MapleFE/shared/Makefile
@@ -1,10 +1,24 @@
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
 include ../Makefile.in
 
 all:
 	$(MAKE) -C src
 
 clean:
-	rm -rf $(MAPLEFE_ROOT)/$(BUILDDIR)/shared
+	rm -rf $(BUILDDIR)/shared
 
 test:
 	$(MAKE) -C ../test p
diff --git a/src/MapleFE/shared/include/appnode_pool.h b/src/MapleFE/shared/include/appnode_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..70ed2959f21e195c79841fe5e62039dd866d3ad9
--- /dev/null
+++ b/src/MapleFE/shared/include/appnode_pool.h
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+//////////////////////////////////////////////////////////////////////////////
+// This file contains the Memory Pool for AppealNode which are dynamically    //
+// allocated.                                                               //
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __APPNODE_POOL_H__
+#define __APPNODE_POOL_H__
+
+#include "mempool.h"
+
+namespace maplefe {
+
+class AppealNode;
+
+// this Pool contains two types of dynamic memory.
+// (1) Those managed by mMP. This is where all the AppealNode come from.
+// (2) Those managed by some containers in some AppealNode. For example, the
+//     SmallVector of children nodes. These are maintained by containers.
+//
+class AppealNodePool {
+private:
+  MemPool mMP;
+public:
+  AppealNodePool(){}
+  ~AppealNodePool() {mMP.Release();}
+
+  void  SetBlockSize(unsigned s) {mMP.SetBlockSize(s);}
+  AppealNode* NewAppealNode();
+
+  // Clear all data, keep the memory
+  void  Clear() {mMP.Clear();}
+};
+
+}
+#endif
diff --git a/src/MapleFE/shared/include/ast.h b/src/MapleFE/shared/include/ast.h
index 43c2c003e0633608e04028c107833e4a391f670d..347f8d443493ec5bb3bf048c33a8f7d29e0328a6 100644
--- a/src/MapleFE/shared/include/ast.h
+++ b/src/MapleFE/shared/include/ast.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -46,6 +46,7 @@
 //    A Function node have its arguments as children node. The return value is not counted.
 //
 
+#include "stringpool.h"
 #include "ast_mempool.h"
 #include "container.h"
 
@@ -54,6 +55,8 @@
 
 namespace maplefe {
 
+#define SETPARENT(n) if(n && !n->IsPrimType()) n->SetParent(this)
+
 enum NodeKind {
 #undef  NODEKIND
 #define NODEKIND(K) NK_##K,
@@ -69,36 +72,102 @@ enum NodeKind {
 // if needed in order to invoke the derived class destructor.
 
 class AnnotationNode;
+class AsTypeNode;
+class IdentifierNode;
+class FunctionNode;
+class UserTypeNode;
+class ComputedNameNode;
+class ASTScope;
+
 class TreeNode {
 protected:
   NodeKind  mKind;
+  unsigned  mNodeId;
   TreeNode *mParent;
   TreeNode *mLabel;   // label of a statement, or expression.
-  const char *mName;
+  unsigned  mStrIdx;
+  unsigned  mTypeIdx;     // typetable index
+  TypeId    mTypeId;      // typeId of the node
+  ASTScope *mScope;
+
+  bool      mIsStmt;      // if a node is a statement
+  bool      mIsOptional;  // if a node is optionally existing during runtime.
+                          // This design is first coming from Javascript.
+  bool      mIsNonNull;   // if a node is asserted to be non-null.
+                          // This design is first coming from Typescript.
+  bool      mIsRest;      // A spread or rest syntax in Javascript.
+  bool      mIsConst;     // A constant node. Readonly.
+
+  // This is a feature coming from TypeScript. Almost every expression in Typescript has
+  // this information. So it's here.
+  SmallVector<AsTypeNode*> mAsTypes;
+
 public:
-  TreeNode() {mKind = NK_Null; mLabel = NULL; mParent = NULL; mName = NULL;}
+  TreeNode(NodeKind k, unsigned i)
+    : mKind(k), mLabel(nullptr), mParent(nullptr), mStrIdx(i), mIsStmt(false), mTypeId(TY_None), mTypeIdx(0),
+      mScope(nullptr), mIsOptional(false), mIsNonNull(false), mIsRest(false), mIsConst(false) {}
+  TreeNode(NodeKind k) : TreeNode(k, 0) {}
+  //TreeNode() : TreeNode(NK_Null, 0) {}
   virtual ~TreeNode() {}
 
 #undef  NODEKIND
 #define NODEKIND(K) bool Is##K() const {return mKind == NK_##K;}
 #include "ast_nk.def"
 
-  bool IsScope() {return IsBlock() || IsClass() || IsFunction() || IsInterface();}
+#undef  TYPE
+#undef  PRIMTYPE
+#define TYPE(K) bool IsTypeId##K() const {return mTypeId == TY_##K;}
+#define PRIMTYPE(K) bool IsTypeId##K() const {return mTypeId == TY_##K;}
+#include "supported_types.def"
+
+  bool IsScope() {return IsBlock() || IsClass() || IsFunction() || IsInterface() || IsModule();}
   bool TypeEquivalent(TreeNode*);
 
-  NodeKind GetKind() {return mKind;}
+  void SetKind(NodeKind k) {} // Not allowed to change its kind
+  void SetNodeId(unsigned id) {mNodeId = id;}
   void SetParent(TreeNode *p) {mParent = p;}
-  void SetLabel (TreeNode *p) {mLabel = p;}
+  void SetLabel (TreeNode *p) {mLabel = p; SETPARENT(p);}
+  void SetTypeId(TypeId id)   {mTypeId = id;}
+  void SetTypeIdx(unsigned id) {mTypeIdx = id;}
+  void SetScope(ASTScope *s)   {mScope = s;}
+
+  NodeKind GetKind()    {return mKind;}
+  unsigned GetNodeId()  {return mNodeId;}
   TreeNode* GetParent() {return mParent;}
   TreeNode* GetLabel()  {return mLabel;}
-
-  virtual const char* GetName() {return mName;}
-  virtual void SetName(const char *s) {mName = s;}
+  TypeId GetTypeId()    {return mTypeId;}
+  unsigned GetTypeIdx() {return mTypeIdx;}
+  ASTScope *GetScope()   {return mScope;}
+
+  bool IsStmt()                    {return mIsStmt;}
+  void SetIsStmt(bool b = true)    {mIsStmt = b;}
+  bool IsOptional()                {return mIsOptional;}
+  void SetIsOptional(bool b = true){mIsOptional = b;}
+  bool IsNonNull()                 {return mIsNonNull;}
+  void SetIsNonNull(bool b = true) {mIsNonNull = b;}
+  bool IsRest()                    {return mIsRest;}
+  void SetIsRest(bool b = true)    {mIsRest = b;}
+  bool IsConst()                   {return mIsConst;}
+  void SetIsConst(bool b = true)   {mIsConst = b;}
+  bool IsThis()                    {return mStrIdx == gStringPool.GetStrIdx("this");}
+
+  virtual unsigned GetStrIdx() {return mStrIdx;}
+  virtual void SetStrIdx(unsigned id) {mStrIdx = id;}
+  virtual const char *GetName() {return gStringPool.GetStringFromStrIdx(mStrIdx);}
+  virtual void SetStrIdx(std::string str) {mStrIdx = gStringPool.GetStrIdx(str);}
   virtual void ReplaceChild(TreeNode *oldchild, TreeNode *newchild){}
   virtual void AddAttr(AttrId) {}
   virtual void AddAnnotation(AnnotationNode *n){}
-  virtual void Dump(unsigned){}
 
+  // AsType related
+  unsigned GetAsTypesNum()           {return mAsTypes.GetNum();}
+  void     AddAsType(AsTypeNode *n)  {mAsTypes.PushBack(n);}
+  void     AddAsTypes(TreeNode *n);
+  AsTypeNode* GetAsTypeAtIndex(unsigned i) {return mAsTypes.ValueAtIndex(i);}
+  void        SetAsTypeAtIndex(unsigned i, AsTypeNode* n) {*(mAsTypes.RefAtIndex(i)) = n;}
+
+  virtual void Dump(unsigned){}
+  virtual void D(){Dump(0); std::cout << std::endl;}
   void DumpIndentation(unsigned);
   void DumpLabel(unsigned);
 
@@ -112,15 +181,171 @@ public:
 
 class PackageNode : public TreeNode {
 private:
+  TreeNode *mPackage;
 public:
-  PackageNode(){mKind = NK_Package;}
-  PackageNode(const char *s) {mKind = NK_Package; mName = s;}
+  PackageNode() : TreeNode(NK_Package) {}
+  PackageNode(unsigned id) : TreeNode(NK_Package, id) {}
   ~PackageNode() {}
 
-  void SetName(const char *s) {mName = s;}
+  TreeNode* GetPackage() {return mPackage;}
+  void SetPackage(TreeNode *t) {mPackage = t;}
+
+  void SetName(unsigned id) {mStrIdx = id;}
+  void Dump(unsigned indent);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                     XXportAsPair Node
+// In JS, the import or export support: xxport {x as y}
+// Its kind of like a mapping of internal name to extern name.
+//
+// Regarding 'default' and 'everything' (*), there are some rules of saving
+// in the XXportAsPairNode. First, let's look at the variaties of combinations
+// of default and *.
+//
+//   1) import * as x
+//        mIsEverything = true
+//        mAfter = x
+//   2) import default as x
+//   3) export x as default
+//   4) export *
+//        mIsEverything = true
+//        mAfter = nullptr, mBefore = nullptr
+//   5) export default declaration
+//   6) export = x                 // This exports a single object.
+//        mIsSingle = true
+//        mBefore = x
+//   7) import x = require("y")   // The counterpart of export = xxx
+//        mIsSingle = true;
+//        mBefore = y
+//        mAfter = x
+// For all these cases, we set mIsDefault or mIsEverything, and save the
+// possible 'x' to mBefore.
+//////////////////////////////////////////////////////////////////////////
+
+class XXportAsPairNode : public TreeNode {
+private:
+  bool      mIsDefault;     // import or export 'default'
+  bool      mIsEverything;  // import or export '*', which is everything
+  bool      mIsSingle;      // export = xxx
+  bool      mIsRef;         // export is reference, otherwise is copy
+  bool      mAsNamespace;   // export as namespace xxx;
+  TreeNode *mBefore;        // In usual cases, name before 'as'
+  TreeNode *mAfter;         // In usual cases, name after 'as'
+
+public:
+  XXportAsPairNode() : TreeNode(NK_XXportAsPair),
+    mIsDefault(false), mIsEverything(false), mIsSingle(false), mIsRef(true), mAsNamespace(false),
+    mBefore(nullptr), mAfter(nullptr) {}
+  ~XXportAsPairNode() {}
+
+  bool IsDefault()    {return mIsDefault;}
+  void SetIsDefault(bool b = true) {mIsDefault = b;}
+
+  bool IsEverything()    {return mIsEverything;}
+  void SetIsEverything(bool b = true) {mIsEverything = b;}
+
+  bool IsSingle()    {return mIsSingle;}
+  void SetIsSingle(bool b = true) {mIsSingle = b;}
+
+  bool IsRef() {return mIsRef;}
+  void SetIsRef(bool b = true) {mIsRef = b;}
+
+  bool GetAsNamespace()    {return mAsNamespace;}
+  void SetAsNamespace(bool b = true) {mAsNamespace = b;}
+
+  TreeNode* GetBefore() {return mBefore;}
+  void SetBefore(TreeNode *t) {mBefore = t; SETPARENT(t);}
+
+  TreeNode* GetAfter() {return mAfter;}
+  void SetAfter(TreeNode *t) {mAfter = t; SETPARENT(t);}
+
+  void Dump(unsigned indent);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                         Declare Nodes
+// C/C++ extern decl,
+// Typescript declare.
+//
+// A declare node could declare more than one declarations, like
+//   declare global {
+//      interface a {}
+//      var b;
+//      ..
+//   }
+//////////////////////////////////////////////////////////////////////////
+
+class DeclareNode : public TreeNode {
+private:
+  SmallVector<TreeNode*> mDecls;
+  SmallVector<AttrId>    mAttrs;
+  bool                   mIsGlobal;//
+public:
+  DeclareNode() : TreeNode(NK_Declare), mIsGlobal(false) {}
+  ~DeclareNode(){mAttrs.Release(); mDecls.Release();}
+
+  bool IsGlobal()                 {return mIsGlobal;}
+  void SetIsGlobal(bool b = true) {mIsGlobal = b;}
+
+  // Attributes related
+  unsigned GetAttrsNum() const        {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
+
+  // Declares
+  unsigned GetDeclsNum() const        {return mDecls.GetNum();}
+  void     AddDecl(TreeNode*);
+  TreeNode* GetDeclAtIndex(unsigned i)              {return mDecls.ValueAtIndex(i);}
+  void      SetDeclAtIndex(unsigned i, TreeNode *n) {*(mDecls.RefAtIndex(i)) = n;}
+
+  void Dump(unsigned indent);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                         Export Nodes
+// export first comes from Javascript.
+//
+// If Export only exports a decl or a statement, it will be saved in
+// mPairs as the only pair. This is the same in ImportNode.
+//////////////////////////////////////////////////////////////////////////
+
+class ExportNode : public TreeNode {
+private:
+  TreeNode       *mTarget;    // the exported package in Java or module in JS
+  SmallVector<XXportAsPairNode*> mPairs;
+  SmallVector<AnnotationNode*> mAnnotations; //annotation or pragma
+  bool            mIsExportType;
+
+public:
+  ExportNode() : TreeNode(NK_Export), mTarget(nullptr), mIsExportType(false) {}
+  ~ExportNode(){}
+
+  void SetTarget(TreeNode *t) {mTarget = t; SETPARENT(t);}
+  TreeNode* GetTarget() {return mTarget;}
+
+  bool IsExportType()                 {return mIsExportType;}
+  void SetIsExportType(bool b = true) {mIsExportType = b;}
+
+  unsigned GetPairsNum() {return mPairs.GetNum();}
+  XXportAsPairNode* GetPair(unsigned i) {return mPairs.ValueAtIndex(i);}
+  void SetPair(unsigned i, XXportAsPairNode* n) {*(mPairs.RefAtIndex(i)) = n; SETPARENT(n);}
+  void AddPair(TreeNode *p);
+  void AddDefaultPair(TreeNode *p);
+  void AddSinglePair(TreeNode *before, TreeNode *after);
+
+  // Annotation/Pragma related
+  unsigned GetAnnotationsNum()           {return mAnnotations.GetNum();}
+  void     AddAnnotation(AnnotationNode *n) {mAnnotations.PushBack(n);}
+  AnnotationNode* GetAnnotationAtIndex(unsigned i) {return mAnnotations.ValueAtIndex(i);}
+  void            SetAnnotationAtIndex(unsigned i, AnnotationNode* n) {*(mAnnotations.RefAtIndex(i)) = n;}
+  void ClearAnnotation() {mAnnotations.Clear();}
+
   void Dump(unsigned indent);
 };
 
+
 //////////////////////////////////////////////////////////////////////////
 //                     Import Node
 // Java import, c/c++ include, are the same scenarios. We just save the
@@ -129,7 +354,9 @@ public:
 // We also borrow the idea of system directory vs. local directory from c/c++.
 //////////////////////////////////////////////////////////////////////////
 
+// The property is useful in Java right now. Javascript use the XXportAsPair.
 enum ImportProperty {
+  ImpNone = 0,
   ImpType = 1,        // Java like, import type
   ImpStatic = 1 << 1, // Java like, import static field.
                       // If we don't specify the data type of imported, it's
@@ -141,15 +368,33 @@ enum ImportProperty {
   ImpSystem = 1 << 5
 };
 
+inline ImportProperty& operator|=(ImportProperty& t, ImportProperty p) {
+    return t = static_cast<ImportProperty>(static_cast<unsigned>(t) | static_cast<unsigned>(p));
+}
+
+inline ImportProperty operator&(ImportProperty p, ImportProperty q) {
+    return static_cast<ImportProperty>(static_cast<unsigned>(p) & static_cast<unsigned>(q));
+}
+
 class ImportNode : public TreeNode {
 private:
-  unsigned    mProperty;
+  ImportProperty  mProperty;
+
+  // Solely for javascript right now.
+  // In many languages, mPairs could be empty. In such case it import the whole module.
+  SmallVector<XXportAsPairNode*> mPairs;
+
+  // the imported target, a package in Java, or a module in JS
+  TreeNode       *mTarget;
+
 public:
-  ImportNode() {mName = NULL; mProperty = 0; mKind = NK_Import;}
-  ~ImportNode(){}
+  ImportNode() : TreeNode(NK_Import), mProperty(ImpNone), mTarget(nullptr) {}
+  ~ImportNode(){mPairs.Release();}
 
-  void SetName(const char *s) {mName = s;}
-  const char* GetName() {return mName;}
+  void SetProperty(ImportProperty p) {mProperty = p;}
+  ImportProperty GetProperty() {return mProperty;}
+  void SetTarget(TreeNode *n) {mTarget = n; SETPARENT(n);}
+  TreeNode* GetTarget() {return mTarget;}
 
   void SetImportType()   {mProperty |= ImpType;}
   void SetImportStatic() {mProperty |= ImpStatic;}
@@ -164,6 +409,13 @@ public:
   bool IsImportLocal()  {return mProperty & ImpLocal;}
   bool IsImportSystem() {return mProperty & ImpSystem;}
 
+  unsigned GetPairsNum() {return mPairs.GetNum();}
+  XXportAsPairNode* GetPair(unsigned i) {return mPairs.ValueAtIndex(i);}
+  void SetPair(unsigned i, XXportAsPairNode* n) {*(mPairs.RefAtIndex(i)) = n;}
+  void AddPair(TreeNode *p);
+  void AddDefaultPair(TreeNode *p);
+  void AddSinglePair(TreeNode *before, TreeNode *after);
+
   void Dump(unsigned indent);
 };
 
@@ -195,13 +447,13 @@ private:
   OprId     mOprId;
   TreeNode *mOpnd;
 public:
-  UnaOperatorNode(OprId id) : mOprId(id), mOpnd(NULL), mIsPost(false)
-    {mKind = NK_UnaOperator;}
-  UnaOperatorNode() : mOpnd(NULL), mIsPost(false) {mKind = NK_UnaOperator;}
+  UnaOperatorNode(OprId id) : TreeNode(NK_UnaOperator),
+    mOprId(id), mOpnd(nullptr), mIsPost(false) {}
+  UnaOperatorNode() : UnaOperatorNode(OPR_NA) {}
   ~UnaOperatorNode() {}
 
   void SetIsPost(bool b)    {mIsPost = b;}
-  void SetOpnd(TreeNode* t) {mOpnd = t; t->SetParent(this);}
+  void SetOpnd(TreeNode* t) {mOpnd = t; SETPARENT(t);}
   void SetOprId(OprId o)    {mOprId = o;}
 
   bool      IsPost()  {return mIsPost;}
@@ -214,30 +466,143 @@ public:
 };
 
 class BinOperatorNode : public TreeNode {
-public:
+private:
   OprId     mOprId;
   TreeNode *mOpndA;
   TreeNode *mOpndB;
 public:
-  BinOperatorNode(OprId id) : mOprId(id) {mKind = NK_BinOperator;}
-  BinOperatorNode() {mKind = NK_BinOperator;}
+  BinOperatorNode(OprId id) : TreeNode(NK_BinOperator), mOprId(id) {}
+  BinOperatorNode() : BinOperatorNode(OPR_NA) {}
   ~BinOperatorNode() {}
 
+  OprId     GetOprId() {return mOprId;}
+  TreeNode* GetOpndA() {return mOpndA;}
+  TreeNode* GetOpndB() {return mOpndB;}
+  void SetOprId(OprId o)     {mOprId = o;}
+  void SetOpndA(TreeNode* t) {mOpndA = t; SETPARENT(t);}
+  void SetOpndB(TreeNode* t) {mOpndB = t; SETPARENT(t);}
+
   void ReplaceChild(TreeNode*, TreeNode*);
   void Dump(unsigned);
 };
 
+// TerOperatorNode is for an expression like
+//   a > b ? c : d
 class TerOperatorNode : public TreeNode {
-public:
-  OprId     mOprId;
+private:
   TreeNode *mOpndA;
   TreeNode *mOpndB;
   TreeNode *mOpndC;
 public:
-  TerOperatorNode(OprId id) : mOprId(id) {mKind = NK_TerOperator;}
-  TerOperatorNode() {mKind = NK_TerOperator;}
+  TerOperatorNode() : TreeNode(NK_TerOperator) {}
   ~TerOperatorNode() {}
 
+  TreeNode* GetOpndA() {return mOpndA;}
+  TreeNode* GetOpndB() {return mOpndB;}
+  TreeNode* GetOpndC() {return mOpndC;}
+  void SetOpndA(TreeNode* t) {mOpndA = t; SETPARENT(t);}
+  void SetOpndB(TreeNode* t) {mOpndB = t; SETPARENT(t);}
+  void SetOpndC(TreeNode* t) {mOpndC = t; SETPARENT(t);}
+
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                      TypeAliasNode
+// The syntax is type alias in Typescript, typedef in c/c++
+//////////////////////////////////////////////////////////////////////////
+
+class TypeAliasNode : public TreeNode {
+private:
+  UserTypeNode *mId;
+  TreeNode     *mAlias;
+public:
+  TypeAliasNode() : TreeNode(NK_TypeAlias), mId(nullptr), mAlias(nullptr){}
+  ~TypeAliasNode() {}
+
+  UserTypeNode* GetId() {return mId;}
+  void SetId(UserTypeNode *id);
+
+  TreeNode* GetAlias() {return mAlias;}
+  void SetAlias(TreeNode *n);
+
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                      ConditionalType
+// The syntax is n Typescript,
+//   type-a extends type-b ? type-c : type-d
+//////////////////////////////////////////////////////////////////////////
+
+class ConditionalTypeNode : public TreeNode {
+private:
+  TreeNode *mTypeA;
+  TreeNode *mTypeB;
+  TreeNode *mTypeC;
+  TreeNode *mTypeD;
+public:
+  ConditionalTypeNode() : TreeNode(NK_ConditionalType),
+                          mTypeA(nullptr), mTypeB(nullptr), mTypeC(nullptr), mTypeD(nullptr){}
+  ~ConditionalTypeNode() {}
+
+  TreeNode* GetTypeA() {return mTypeA;}
+  TreeNode* GetTypeB() {return mTypeB;}
+  TreeNode* GetTypeC() {return mTypeC;}
+  TreeNode* GetTypeD() {return mTypeD;}
+  void SetTypeA(TreeNode *n) {mTypeA = n; SETPARENT(n);}
+  void SetTypeB(TreeNode *n) {mTypeB = n; SETPARENT(n);}
+  void SetTypeC(TreeNode *n) {mTypeC = n; SETPARENT(n);}
+  void SetTypeD(TreeNode *n) {mTypeD = n; SETPARENT(n);}
+
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                      AstType
+// The syntax is like: variable as type-a as type-b ...
+// It tells what type is the 'variable'
+//////////////////////////////////////////////////////////////////////////
+
+class AsTypeNode : public TreeNode {
+private:
+  TreeNode *mType;
+public:
+  AsTypeNode() : TreeNode(NK_AsType), mType(nullptr) {}
+  ~AsTypeNode() {}
+
+  TreeNode* GetType() {return mType;}
+  void SetType(TreeNode *t) {mType = t; SETPARENT(t);}
+
+  void Dump(unsigned indent);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                      TypeParameter
+//////////////////////////////////////////////////////////////////////////
+
+class TypeParameterNode : public TreeNode {
+private:
+  TreeNode *mId;      // The name of the type parameter
+  TreeNode *mDefault; // The default value of this type parameter.
+                      // some languages support default value.
+  TreeNode *mExtends; // The constraint of this type parameter.
+                         // In Typescript, the syntax is like: T<X extends Y>
+
+public:
+  TypeParameterNode() : TreeNode(NK_TypeParameter), mId(nullptr), mDefault(nullptr),
+                        mExtends(nullptr) {}
+  ~TypeParameterNode() {}
+
+  TreeNode* GetId()            {return mId;}
+  void      SetId(TreeNode* t) {mId = t; SETPARENT(t);}
+
+  TreeNode* GetDefault()            {return mDefault;}
+  void      SetDefault(TreeNode* t) {mDefault = t; SETPARENT(t);}
+
+  TreeNode* GetExtends()            {return mExtends;}
+  void      SetExtends(TreeNode* t) {mExtends = t; SETPARENT(t);}
+
   void Dump(unsigned);
 };
 
@@ -255,27 +620,100 @@ private:
   TreeNode  *mId;                  // A name could be like Outer.Inner
                                    // Hard to give a const char* as name.
                                    // So give it an id.
-  SmallVector<TreeNode*> mParams;  //
+                                   // In Typescript, it could be a lambda:
+                                   //   new (...) => Type
+                                   // in which mArgs and mBody are not used.
+  SmallVector<TreeNode*> mArgs;    //
   BlockNode *mBody;                // When body is not empty, it's an
                                    // anonymous class.
+  SmallVector<AttrId>          mAttrs;
 public:
-  NewNode() : mId(NULL), mBody(NULL) {mKind = NK_New;}
-  ~NewNode() {mParams.Release();}
+  NewNode() : TreeNode(NK_New), mId(nullptr), mBody(nullptr) {}
+  ~NewNode() {mArgs.Release();}
 
   TreeNode* GetId()          {return mId;}
-  void SetId(TreeNode *n)    {mId = n;}
+  void SetId(TreeNode *n)    {mId = n; SETPARENT(n);}
   BlockNode* GetBody()       {return mBody;}
   void SetBody(BlockNode *n) {mBody = n;}
 
-  unsigned  GetParamsNum()        {return mParams.GetNum();}
-  TreeNode* GetParam(unsigned i)  {return mParams.ValueAtIndex(i);}
-  void      AddParam(TreeNode *t) {mParams.PushBack(t);}
+  unsigned  GetArgsNum()        {return mArgs.GetNum();}
+  TreeNode* GetArg(unsigned i)  {return mArgs.ValueAtIndex(i);}
+  void      SetArg(unsigned i, TreeNode* n) {*(mArgs.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddArg(TreeNode *t) {mArgs.PushBack(t); SETPARENT(t);}
+
+  // Attributes related
+  unsigned GetAttrsNum()              {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
 
   void ReplaceChild(TreeNode *oldone, TreeNode *newone);
   void Dump(unsigned);
 };
 
 class DeleteNode : public TreeNode {
+private:
+  TreeNode *mExpr;
+public:
+  DeleteNode() : TreeNode(NK_Delete), mExpr(nullptr) {}
+  ~DeleteNode(){}
+
+  TreeNode* GetExpr()            {return mExpr;}
+  void      SetExpr(TreeNode *t) {mExpr = t; SETPARENT(t);}
+
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                         AnnotationNode
+//
+// Pragma or Annotation are language constructs to help (1) compiler
+// (2) runtime (3) other tools, to better analyze or execute the program.
+// It doesn't change the program behaviour, but may be improve static
+// and/or dynamic analysis and/or performance.
+//
+// We have a dedicated AnnotationNode here. The program/annotation syntax
+// could be complicated, eg. c99 introduce function call like pragma.
+//
+// The difference between Java annotation and C/c++ pragma is annotation
+// is user defined and pragma is compiler/system defined. In another word
+// Java annoation has unlimited number while pragmas are limited.
+//////////////////////////////////////////////////////////////////////////
+
+// AnnotationTypeNode defines a new Annotation
+class AnnotationTypeNode : public TreeNode {
+private:
+  IdentifierNode *mId;
+public:
+  AnnotationTypeNode() : TreeNode(NK_AnnotationType) {}
+  ~AnnotationTypeNode() {}
+  IdentifierNode* GetId() {return mId;}
+  void SetId(IdentifierNode *n) {mId = n;}
+  void Dump(unsigned);
+};
+
+// Annotation/Pragma is complicated, but everything starts from the
+// name. So at construction, we will take in the name at first.
+// Later we will initialize mType, mExpr based on the 'name' and other
+// expression.
+class AnnotationNode : public TreeNode {
+private:
+  TreeNode           *mId;
+  AnnotationTypeNode *mType;
+  SmallVector<TreeNode*> mArgs;
+public:
+  AnnotationNode() : TreeNode(NK_Annotation), mId(nullptr), mType(nullptr) {}
+  ~AnnotationNode(){mArgs.Release();}
+
+  TreeNode* GetId()       {return mId;}
+  void SetId(TreeNode *n) {mId = n; SETPARENT(n);}
+  AnnotationTypeNode* GetType() {return mType;}
+  void SetType(AnnotationTypeNode *n) {mType = n; SETPARENT(n);}
+
+  unsigned  GetArgsNum()       {return mArgs.GetNum();}
+  TreeNode* GetArgAtIndex(unsigned i) {return mArgs.ValueAtIndex(i);}
+  void      SetArgAtIndex(unsigned i, TreeNode* n) {*(mArgs.RefAtIndex(i)) = n;}
+  void      AddArg(TreeNode *n){mArgs.PushBack(n); SETPARENT(n);}
 };
 
 //////////////////////////////////////////////////////////////////////////
@@ -307,16 +745,13 @@ class DimensionNode : public TreeNode {
 private:
   SmallVector<unsigned> mDimensions;
 public:
-  DimensionNode() {mKind = NK_Dimension;}
+  DimensionNode() : TreeNode(NK_Dimension) {}
   ~DimensionNode(){Release();}
 
-  unsigned GetDimsNum() {return mDimensions.GetNum();}
-  unsigned GetNthDim(unsigned n) {return mDimensions.ValueAtIndex(n);} // 0 means unspecified.
-  void     SetNthDim(unsigned n, unsigned i) {
-    unsigned *addr = mDimensions.RefAtIndex(n);
-    *addr = i;
-  }
-  void AddDim(unsigned i = 0) {mDimensions.PushBack(i);}
+  unsigned GetDimensionsNum() {return mDimensions.GetNum();}
+  unsigned GetDimension(unsigned i) {return mDimensions.ValueAtIndex(i);} // 0 means unspecified.
+  void     SetDimension(unsigned i, unsigned n) {*(mDimensions.RefAtIndex(i)) = n;}
+  void AddDimension(unsigned i = 0) {mDimensions.PushBack(i);}
   void Merge(const TreeNode*);
 
   void Release() {mDimensions.Release();}
@@ -331,77 +766,84 @@ private:
   TreeNode      *mType; // PrimTypeNode or UserTypeNode
   TreeNode      *mInit; // Init value
   DimensionNode *mDims;
+
+  SmallVector<AnnotationNode*> mAnnotations; //annotation or pragma
+
 public:
-  IdentifierNode(const char *s) : mType(NULL), mInit(NULL), mDims(NULL){
-    mKind = NK_Identifier;
-    SetName(s); }
-  IdentifierNode(const char *s, TreeNode *t) : mType(t), mInit(NULL), mDims(NULL) {
-    mKind = NK_Identifier;
-    SetName(s);}
-  ~IdentifierNode(){}
+  IdentifierNode(unsigned id, TreeNode *t) : TreeNode(NK_Identifier, id),
+    mType(t), mInit(nullptr), mDims(nullptr) {}
+  IdentifierNode(unsigned id) : IdentifierNode(id, nullptr) {}
+  IdentifierNode() : IdentifierNode(0, nullptr) {}
+  ~IdentifierNode(){Release();}
 
   TreeNode*   GetType() {return mType;}
   TreeNode*   GetInit() {return mInit;}
+  DimensionNode* GetDims() {return mDims;}
 
-  void SetType(TreeNode *t)      {mType = t;}
-  void SetInit(TreeNode *t)      {mInit = t;}
-  void SetDims(DimensionNode *t) {mDims = t;}
+  void SetType(TreeNode *t)      {mType = t; SETPARENT(t);}
+  void SetInit(TreeNode *t)      {mInit = t; SETPARENT(t);}
+  void ClearInit()               {mInit = nullptr;}
+  void SetDims(DimensionNode *t) {mDims = t; SETPARENT(t);}
 
-  unsigned GetDimsNum()          {return mDims->GetDimsNum();}
+  unsigned GetDimsNum()          {return mDims->GetDimensionsNum();}
+  unsigned GetDim(unsigned n)    {return mDims->GetDimension(n);} // 0 means unspecified.
   bool     IsArray()             {return mDims && GetDimsNum() > 0;}
-  unsigned AddDim(unsigned i = 0){mDims->AddDim(i);}           // 0 means unspecified
-  unsigned GetNthNum(unsigned n) {return mDims->GetNthDim(n);} // 0 means unspecified.
-  void     SetNthNum(unsigned n, unsigned i) {mDims->SetNthDim(n, i);}
+  void     AddDim(unsigned i = 0){mDims->AddDimension(i);}        // 0 means unspecified
+  unsigned GetNthNum(unsigned n) {return mDims->GetDimension(n);} // 0 means unspecified.
+  void     SetNthNum(unsigned n, unsigned i) {mDims->SetDimension(n, i);}
 
   // Attributes related
-  unsigned GetAttrsNum() const     {return mAttrs.GetNum();}
-  void     AddAttr(AttrId a)       {mAttrs.PushBack(a);}
-  AttrId   AttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  unsigned GetAttrsNum() const        {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
+
+  // Annotation/Pragma related
+  unsigned GetAnnotationsNum()           {return mAnnotations.GetNum();}
+  void     AddAnnotation(AnnotationNode *n) {mAnnotations.PushBack(n); SETPARENT(n);}
+  AnnotationNode* GetAnnotationAtIndex(unsigned i) {return mAnnotations.ValueAtIndex(i);}
+  void            SetAnnotationAtIndex(unsigned i, AnnotationNode* n) {*(mAnnotations.RefAtIndex(i)) = n;}
 
-  void Release() { if (mDims) mDims->Release();}
+  void Release();
   void Dump(unsigned);
 };
 
 //////////////////////////////////////////////////////////////////////////
-//                         AnnotationNode
-//
-// Pragma or Annotation are language constructs to help (1) compiler
-// (2) runtime (3) other tools, to better analyze or execute the program.
-// It doesn't change the program behaviour, but may be improve static
-// and/or dynamic analysis and/or performance.
-//
-// We have a dedicated AnnotationNode here. The program/annotation syntax
-// could be complicated, eg. c99 introduce function call like pragma.
-//
-// The difference between Java annotation and C/c++ pragma is annotation
-// is user defined and pragma is compiler/system defined. In another word
-// Java annoation has unlimited number while pragmas are limited.
+//                       DeclNode
+// A DeclNode defines one single variable or a VarList.
+// The type info and init expr are both inside the IdentifierNode.
+// DeclNode only tells this is a declaration.
 //////////////////////////////////////////////////////////////////////////
 
-// AnnotationTypeNode defines a new Annotation
-class AnnotationTypeNode : public TreeNode {
-private:
-  IdentifierNode *mId;
-public:
-  void SetId(IdentifierNode *n) {mId = n;}
-  void Dump(unsigned);
+// special property of Javascript
+enum DeclProp {
+  JS_Var,
+  JS_Let,
+  JS_Const,
+  DP_NA
 };
 
-// Annotation/Pragma is complicated, but everything starts from the
-// name. So at construction, we will take in the name at first.
-// Later we will initialize mType, mExpr based on the 'name' and other
-// expression.
-class AnnotationNode : public TreeNode {
+class DeclNode : public TreeNode {
 private:
-  IdentifierNode     *mId;
-  AnnotationTypeNode *mType;
-  TreeNode           *mExpr;
+  TreeNode *mVar;
+  TreeNode *mInit; // Init value
+  DeclProp  mProp;
 public:
-  AnnotationNode() : mId(NULL), mType(NULL), mExpr(NULL) {
-    mKind = NK_Annotation;}
-  ~AnnotationNode(){}
+  DeclNode(TreeNode *t) : TreeNode(NK_Decl),
+    mVar(t), mInit(nullptr), mProp(DP_NA) {SETPARENT(t);}
+  DeclNode() : DeclNode(nullptr) {}
+  ~DeclNode(){}
 
-  void SetId(IdentifierNode *n) {mId = n;}
+  TreeNode* GetVar() {return mVar;}
+  TreeNode* GetInit() {return mInit;}
+
+  void SetVar(TreeNode *t) {mVar = t; SETPARENT(t);}
+  void SetInit(TreeNode *t) {mInit = t; SETPARENT(t);}
+
+  DeclProp GetProp() {return mProp;}
+  void SetProp(DeclProp p) {mProp = p;}
+
+  void Dump(unsigned);
 };
 
 //////////////////////////////////////////////////////////////////////////
@@ -414,16 +856,16 @@ private:
   TreeNode *mDestType;
   TreeNode *mExpr;
 public:
-  CastNode() : mDestType(NULL), mExpr(NULL) {mKind = NK_Cast;}
+  CastNode() : TreeNode(NK_Cast), mDestType(nullptr), mExpr(nullptr) {}
   ~CastNode(){}
 
   TreeNode* GetDestType() {return mDestType;}
   void SetDestType(TreeNode *t) {mDestType = t;}
 
   TreeNode* GetExpr() {return mExpr;}
-  void SetExpr(TreeNode *t) {mExpr = t;}
+  void SetExpr(TreeNode *t) {mExpr = t; SETPARENT(t);}
 
-  const char* GetName();
+  const char* GetDumpName();
   void Dump(unsigned);
 };
 
@@ -443,44 +885,328 @@ class ParenthesisNode : public TreeNode {
 private:
   TreeNode *mExpr;
 public:
-  ParenthesisNode() : mExpr(NULL) {mKind = NK_Parenthesis;}
+  ParenthesisNode() : TreeNode(NK_Parenthesis), mExpr(nullptr) {}
   ~ParenthesisNode(){}
 
-  TreeNode* GetExpr() {return mExpr;}
-  void SetExpr(TreeNode *t) {mExpr = t; t->SetParent(this);}
+  TreeNode* GetExpr() {return mExpr;}
+  void SetExpr(TreeNode *t) {mExpr = t; SETPARENT(t);}
+
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                           FieldNode
+// This is used for field reference. The field could be a member field or
+// a member function.
+//////////////////////////////////////////////////////////////////////////
+
+class FieldNode : public TreeNode {
+private:
+  TreeNode *mUpper; // The upper enclosing structure
+  TreeNode *mField;
+public:
+  FieldNode() : TreeNode(NK_Field), mField(nullptr), mUpper(nullptr) {}
+  ~FieldNode(){}
+
+  TreeNode* GetField() {return mField;}
+  void SetField(TreeNode *f) {mField = f; SETPARENT(f);}
+
+  TreeNode *GetUpper()       {return mUpper;}
+  void SetUpper(TreeNode *n) {
+    TreeNode *up = n;
+    while (up->IsParenthesis()) {
+      ParenthesisNode *pn = (ParenthesisNode*)up;
+      up = pn->GetExpr();
+    }
+    mUpper = up;
+    SETPARENT(up);
+  }
+
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                           Array Related Nodes
+// ArrayElementNode, ArrayLiteralNode.
+//////////////////////////////////////////////////////////////////////////
+
+// Array element is a[b][c].
+class ArrayElementNode : public TreeNode {
+private:
+  TreeNode              *mArray;
+  SmallVector<TreeNode*> mExprs;  // index expressions.
+public:
+  ArrayElementNode() : TreeNode(NK_ArrayElement), mArray(nullptr) {}
+  ~ArrayElementNode() {Release();}
+
+  TreeNode* GetArray()            {return mArray;}
+  void      SetArray(TreeNode *n) {mArray = n; SETPARENT(n);}
+
+  unsigned  GetExprsNum()       {return mExprs.GetNum();}
+  TreeNode* GetExprAtIndex(unsigned i) {return mExprs.ValueAtIndex(i);}
+  void      SetExprAtIndex(unsigned i, TreeNode* n) {*(mExprs.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddExpr(TreeNode *n){mExprs.PushBack(n); SETPARENT(n);}
+
+  void Release() {mExprs.Release();}
+  void Dump(unsigned);
+};
+
+
+// Array literal is [1, 2 , 0, -4]. It's an arrya of literals.
+// It could also be multi-dim array literal like [[1,2],[2,3]]
+class ArrayLiteralNode : public TreeNode {
+private:
+  SmallVector<TreeNode*> mLiterals;
+public:
+  ArrayLiteralNode() : TreeNode(NK_ArrayLiteral) {}
+  ~ArrayLiteralNode() {Release();}
+
+  unsigned  GetLiteralsNum()       {return mLiterals.GetNum();}
+  TreeNode* GetLiteral(unsigned i) {return mLiterals.ValueAtIndex(i);}
+  void      SetLiteral(unsigned i, TreeNode* n) {*(mLiterals.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddLiteral(TreeNode *n){mLiterals.PushBack(n); SETPARENT(n);}
+
+  void Release() {mLiterals.Release();}
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                           BindingPattern
+// It's used in Destructuring scenarios. It comes from Javascript.
+// It takes out elements from structs or arrays and form a new one.
+// It may bind elements to some new variables. I believe this is the reason
+// it's called BindingXXX
+//////////////////////////////////////////////////////////////////////////
+
+class BindingElementNode : public TreeNode {
+private:
+  TreeNode *mVariable;  // The new variable to bind element to
+  TreeNode *mElement;   // the elements in the source struct or array
+public:
+  BindingElementNode() : TreeNode(NK_BindingElement),
+                         mVariable(nullptr), mElement(nullptr) {}
+  ~BindingElementNode() {}
+
+  TreeNode* GetVariable()            {return mVariable;}
+  void      SetVariable(TreeNode* n) {mVariable = n; SETPARENT(n);}
+  TreeNode* GetElement()             {return mElement;}
+  void      SetElement(TreeNode* n)  {mElement = n; SETPARENT(n);}
+
+  void Dump(unsigned);
+};
+
+enum BindPattProp {
+  BPP_ArrayBinding,
+  BPP_ObjectBinding,
+  BPP_NA
+};
+
+class BindingPatternNode : public TreeNode {
+private:
+  BindPattProp           mProp;
+  SmallVector<TreeNode*> mElements;    // mostly BindingElementNode, also could be
+                                       // a nested BindingPatternNode.
+  TreeNode              *mType;        // The type
+  TreeNode              *mInit;        // An initializer
+public:
+  BindingPatternNode() :
+      TreeNode(NK_BindingPattern), mInit(nullptr), mType(nullptr), mProp(BPP_NA) {}
+  ~BindingPatternNode() {Release();}
+
+  BindPattProp GetProp()                {return mProp;}
+  void         SetProp(BindPattProp n)  {mProp = n;}
+
+  unsigned  GetElementsNum()       {return mElements.GetNum();}
+  TreeNode* GetElement(unsigned i) {return mElements.ValueAtIndex(i);}
+  void      SetElement(unsigned i, TreeNode* n) {*(mElements.RefAtIndex(i)) = n;}
+  void      AddElement(TreeNode *n);
+
+  TreeNode* GetType()             {return mType;}
+  void      SetType(TreeNode* n)  {mType = n; SETPARENT(n);}
+  TreeNode* GetInit()             {return mInit;}
+  void      SetInit(TreeNode* n)  {mInit = n; SETPARENT(n);}
+
+  void Release() {mElements.Release();}
+  void Dump(unsigned);
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+//                           Struct Node
+// This is first coming from C struct. Typescript 'interface' has the
+// similar structure.
+//
+// Index signature of Typescript make it complicated. Here is an example.
+//  interface Foo{
+//    [key: string]: number;
+//  }
+//
+//  let bar: Foo = {};
+//  bar['key1'] = 1;
+//
+//////////////////////////////////////////////////////////////////////////
+
+enum StructProp {
+  SProp_CStruct,
+  SProp_TSInterface,
+  SProp_TSEnum,
+  SProp_NA
+};
+
+class NumIndexSigNode : public TreeNode{
+public:
+  TreeNode *mKey;
+  TreeNode *mDataType;
+
+  void      SetKey(TreeNode *t) {mKey = t;}
+  TreeNode* GetKey()            {return mKey;}
+  void      SetDataType(TreeNode *t) {mDataType = t;}
+  TreeNode* GetDataType()            {return mDataType;}
+
+  NumIndexSigNode() : TreeNode(NK_NumIndexSig), mDataType(nullptr), mKey(nullptr) {}
+  ~NumIndexSigNode(){}
+  void Dump(unsigned);
+};
+
+class StrIndexSigNode : public TreeNode{
+public:
+  TreeNode *mKey;
+  TreeNode *mDataType;
+
+  void      SetKey(TreeNode *t) {mKey = t; SETPARENT(t);}
+  TreeNode* GetKey()            {return mKey;}
+  void      SetDataType(TreeNode *t) {mDataType = t; SETPARENT(t);}
+  TreeNode* GetDataType()            {return mDataType;}
+
+  StrIndexSigNode() : TreeNode(NK_StrIndexSig), mDataType(nullptr), mKey(nullptr) {}
+  ~StrIndexSigNode(){}
+  void Dump(unsigned);
+};
+
+// C++ struct or Typescript interface.
+// The methods in Typescript interface has no function body.
+class StructNode : public TreeNode {
+private:
+  StructProp      mProp;
+  IdentifierNode *mStructId;
+  SmallVector<TypeParameterNode*> mTypeParams;
+  SmallVector<TreeNode*>       mFields;
+  SmallVector<FunctionNode*>   mMethods;
+  SmallVector<TreeNode*>       mSupers;
+
+  // These are for 'number' or 'string' index data type
+  NumIndexSigNode *mNumIndexSig;
+  StrIndexSigNode *mStrIndexSig;
+
+public:
+  StructNode(IdentifierNode *n) : TreeNode(NK_Struct), mStructId(n), mProp(SProp_NA),
+                                  mNumIndexSig(nullptr), mStrIndexSig(nullptr) {SETPARENT(n);}
+  StructNode() : StructNode(nullptr) {}
+  ~StructNode() {Release();}
+
+  StructProp GetProp() {return mProp;}
+  IdentifierNode* GetStructId() {return mStructId;}
+  void SetProp(StructProp p) {mProp = p;}
+  void SetStructId(IdentifierNode *n) {mStructId = n; SETPARENT(n);}
+
+  NumIndexSigNode* GetNumIndexSig() {return mNumIndexSig;}
+  StrIndexSigNode* GetStrIndexSig() {return mStrIndexSig;}
+  void SetNumIndexSig(NumIndexSigNode *t) {mNumIndexSig = t;}
+  void SetStrIndexSig(StrIndexSigNode *t) {mStrIndexSig = t;}
+
+  // TypeParameter
+  unsigned GetTypeParamsNum()           {return mTypeParams.GetNum();}
+  void     AddTypeParam(TreeNode *n);
+  TypeParameterNode* GetTypeParamAtIndex(unsigned i) {return mTypeParams.ValueAtIndex(i);}
+  void               SetTypeParamAtIndex(unsigned i, TypeParameterNode* n) {*(mTypeParams.RefAtIndex(i)) = n;}
+
+  unsigned  GetFieldsNum() {return mFields.GetNum();}
+  TreeNode* GetField(unsigned i) {return mFields.ValueAtIndex(i);}
+  void      SetField(unsigned i, TreeNode* n) {*(mFields.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddField(TreeNode *n) {mFields.PushBack(n); SETPARENT(n);}
+
+  unsigned  GetSupersNum() {return mSupers.GetNum();}
+  TreeNode* GetSuper(unsigned i) {return mSupers.ValueAtIndex(i);}
+  void      SetSuper(unsigned i, TreeNode* n) {*(mSupers.RefAtIndex(i)) = n;}
+  void      AddSuper(TreeNode *n);
+
+  unsigned      GetMethodsNum() {return mMethods.GetNum();}
+  FunctionNode* GetMethod(unsigned i) {return mMethods.ValueAtIndex(i);}
+  void          SetMethod(unsigned i, FunctionNode* n) {*(mMethods.RefAtIndex(i)) = n;}
+  void          AddMethod(FunctionNode *n) {mMethods.PushBack(n);}
+
+  void AddChild(TreeNode *);
+
+  void Release() {mFields.Release(); mMethods.Release(); mSupers.Release(); mTypeParams.Release();}
+  void Dump(unsigned);
+};
+
+// We define StructLiteral for C/C++ struct literal, TS/JS object literal.
+// It contains a list of duple <fieldname, value>
+//
+// In Javascript, the GetAccessor/SetAccessor makes it complicated.
+// We save the XetAccessor as a field literal with fieldname being func
+// name and literal being function node itself.
+
+// mFieldName could be nullptr, like {3, 4} or {a, b}, 3, 4, a and b are literals without
+// a name. but mLiteral may not be nullptr.
+class FieldLiteralNode : public TreeNode{
+public:
+  TreeNode *mFieldName;  // Generally a field is an identifier. However, in JS/TS
+                         // it could be a literal string or numeric.
+  TreeNode *mLiteral;
+
+  void SetFieldName(TreeNode *id) {mFieldName = id; SETPARENT(id);}
+  void SetLiteral(TreeNode *id) {mLiteral = id; SETPARENT(id);}
+
+  TreeNode* GetFieldName() {return mFieldName;}
+  TreeNode* GetLiteral() {return mLiteral;}
+
+  FieldLiteralNode() : mFieldName(nullptr), TreeNode(NK_FieldLiteral) {}
+  ~FieldLiteralNode(){}
+};
+
+class StructLiteralNode : public TreeNode {
+private:
+  SmallVector<FieldLiteralNode*> mFields;
+public:
+  StructLiteralNode() : TreeNode(NK_StructLiteral) {}
+  ~StructLiteralNode(){Release();}
+
+  unsigned          GetFieldsNum() {return mFields.GetNum();}
+  FieldLiteralNode* GetField(unsigned i) {return mFields.ValueAtIndex(i);}
+  void              SetField(unsigned i, FieldLiteralNode* n) {*(mFields.RefAtIndex(i)) = n; SETPARENT(n);}
+  void              AddField(TreeNode *n);
 
   void Dump(unsigned);
 };
 
 //////////////////////////////////////////////////////////////////////////
-//                           FieldNode
-// This is used for field reference. It includes both member field and
-// member function.
+//                           Namespace Node
+// Typescript namespace has only a list of children which could be any
+// kind of declaration or statement. So I simply keep their original
+// nodes.
 //////////////////////////////////////////////////////////////////////////
 
-class FieldNode : public TreeNode {
+class NamespaceNode : public TreeNode {
 private:
-  TreeNode       *mUpper; // The upper enclosing structure
-  IdentifierNode *mField;
+  SmallVector<TreeNode*> mElements;
+  TreeNode *mId;   // the name of namespace
 public:
-  FieldNode() : TreeNode(), mField(NULL), mUpper(NULL) {mKind = NK_Field;}
-  ~FieldNode(){}
+  NamespaceNode() : TreeNode(NK_Namespace), mId(nullptr) {}
+  ~NamespaceNode() {Release();}
 
-  void Init();
+  void SetId(TreeNode *id) {mId = id; SETPARENT(id);}
+  TreeNode* GetId() {return mId;}
 
-  IdentifierNode* GetField() {return mField;}
-  void SetField(IdentifierNode *f) {mField = f;}
+  unsigned  GetElementsNum()              {return mElements.GetNum();}
+  TreeNode* GetElementAtIndex(unsigned i) {return mElements.ValueAtIndex(i);}
+  void      SetElementAtIndex(unsigned i, TreeNode* n) {*(mElements.RefAtIndex(i)) = n;}
+  void      AddElement(TreeNode* n) {mElements.PushBack(n); SETPARENT(n);}
 
-  TreeNode *GetUpper()       {return mUpper;}
-  void SetUpper(TreeNode *n) {
-    TreeNode *up = n;
-    while (up->IsParenthesis()) {
-      ParenthesisNode *pn = (ParenthesisNode*)up;
-      up = pn->GetExpr();
-    }
-    mUpper = up;
-  }
+  void AddBody(TreeNode *);
 
+  void Release() {mElements.Release();}
   void Dump(unsigned);
 };
 
@@ -494,11 +1220,12 @@ class VarListNode : public TreeNode {
 private:
   SmallVector<IdentifierNode*> mVars;
 public:
-  VarListNode() {mKind = NK_VarList;}
-  ~VarListNode() {}
+  VarListNode() : TreeNode(NK_VarList) {}
+  ~VarListNode() {Release();}
 
-  unsigned GetNum() {return mVars.GetNum();}
-  IdentifierNode* VarAtIndex(unsigned i) {return mVars.ValueAtIndex(i);}
+  unsigned GetVarsNum() {return mVars.GetNum();}
+  IdentifierNode* GetVarAtIndex(unsigned i) {return mVars.ValueAtIndex(i);}
+  void            SetVarAtIndex(unsigned i, IdentifierNode* n) {*(mVars.RefAtIndex(i)) = n;}
 
   void AddVar(IdentifierNode *n);
   void Merge(TreeNode*);
@@ -516,11 +1243,12 @@ class ExprListNode : public TreeNode {
 private:
   SmallVector<TreeNode*> mExprs;
 public:
-  ExprListNode() {mKind = NK_ExprList;}
+  ExprListNode() : TreeNode(NK_ExprList) {}
   ~ExprListNode() {}
 
-  unsigned GetNum() {return mExprs.GetNum();}
-  TreeNode* ExprAtIndex(unsigned i) {return mExprs.ValueAtIndex(i);}
+  unsigned GetExprsNum() {return mExprs.GetNum();}
+  TreeNode* GetExprAtIndex(unsigned i) {return mExprs.ValueAtIndex(i);}
+  void      SetExprAtIndex(unsigned i, TreeNode* n) {*(mExprs.RefAtIndex(i)) = n;}
 
   void AddExpr(TreeNode *n) {mExprs.PushBack(n);}
   void Merge(TreeNode*);
@@ -528,23 +1256,182 @@ public:
   void Dump(unsigned);
 };
 
+//////////////////////////////////////////////////////////////////////////
+//                         TemplateLiteral Nodes
+// TemplateLiteral node is created from the corresponding TempLit Token,
+// copying the raw mStrings from token.
+// Later on, call parser special API to create AST nodes for the patterns.
+// After that, only mStrings and mTrees are used.
+//////////////////////////////////////////////////////////////////////////
+
+class TemplateLiteralNode : public TreeNode {
+private:
+  // mStrings save <format, placeholder> pairs.
+  SmallVector<const char*> mStrings;
+
+  // It's tree nodes of pairs of <format, placeholder>. So it would be pairs
+  // of <TreeNode*, TreeNode*>, For any missing element, a nullptr is saved
+  // in its position.
+  // Even index elements are for formats, Odd index elements are for placeholder.
+  SmallVector<TreeNode*> mTrees;
+
+public:
+  TemplateLiteralNode() : TreeNode(NK_TemplateLiteral) {}
+  ~TemplateLiteralNode(){mStrings.Release(); mTrees.Release();}
+
+  unsigned    GetStringsNum() {return mStrings.GetNum();}
+  const char* GetStringAtIndex(unsigned i) {return mStrings.ValueAtIndex(i);}
+  void        SetStringAtIndex(unsigned i, const char* n) {*(mStrings.RefAtIndex(i)) = n;}
+  void        AddString(const char *n) {mStrings.PushBack(n);}
+
+  unsigned    GetTreesNum() {return mTrees.GetNum();}
+  TreeNode*   GetTreeAtIndex(unsigned i) {return mTrees.ValueAtIndex(i);}
+  void        SetTreeAtIndex(unsigned i, TreeNode *n) {*(mTrees.RefAtIndex(i)) = n; SETPARENT(n);}
+  void        AddTree(TreeNode *n) {mTrees.PushBack(n); SETPARENT(n);}
+
+  void Dump(unsigned);
+};
+
+// We define a global vector for TemplateLiteralNode created after all parsing.
+extern SmallVector<TemplateLiteralNode*> gTemplateLiteralNodes;
+
 //////////////////////////////////////////////////////////////////////////
 //                         Literal Nodes
 //////////////////////////////////////////////////////////////////////////
 
 class LiteralNode : public TreeNode {
 private:
-  LitData mData;
+  LitData   mData;
+
+  // The regular type information is stored in LitData which is common practice.
+  // However, in languages like Typescript, it does allow special literals like 'this'
+  // to have a dedicated type. So here comes 'mType'.
+  TreeNode *mType;
+
+  // Typescript allows a string literal to be used as an Identifier, so it allows
+  // an init value.
+  TreeNode *mInit;
+
 private:
   void InitName();
 
 public:
-  LiteralNode(LitData d) : mData(d) {
-    mKind = NK_Literal; InitName();
-  }
+  LiteralNode(LitData d) : TreeNode(NK_Literal), mData(d), mType(nullptr), mInit(nullptr) {}
+  LiteralNode() : LiteralNode({.mType = LT_NA, .mData.mInt = 0}) {}
   ~LiteralNode(){}
 
   LitData GetData() {return mData;}
+  void SetData(LitData d) {mData = d;}
+
+  TreeNode* GetType()            {return mType;}
+  void      SetType(TreeNode *t) {mType = t; SETPARENT(t);}
+  TreeNode*   GetInit()                 {return mInit;}
+  void        SetInit(TreeNode *t)      {mInit = t; SETPARENT(t);}
+
+  bool IsThis() {return mData.mType == LT_ThisLiteral;}
+
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                         RegExpr Nodes
+//////////////////////////////////////////////////////////////////////////
+
+class RegExprNode : public TreeNode {
+private:
+  RegExprData mData;
+public:
+  RegExprNode() : TreeNode(NK_RegExpr) {mData.mExpr = nullptr; mData.mFlags = nullptr;}
+  ~RegExprNode(){}
+
+  RegExprData GetData() {return mData;}
+  void SetData(RegExprData d) {mData = d;}
+
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                         ThrowNode
+// This is the throw statement.
+// In Java some functions throw exception in declaration, and they are
+// saved in FunctionNode::mThrows.
+//////////////////////////////////////////////////////////////////////////
+
+class ThrowNode : public TreeNode {
+private:
+  SmallVector<TreeNode *> mExceptions;
+public:
+  ThrowNode() : TreeNode(NK_Throw) {}
+  ~ThrowNode(){}
+
+  unsigned  GetExceptionsNum() {return mExceptions.GetNum();}
+  TreeNode* GetExceptionAtIndex(unsigned i) {return mExceptions.ValueAtIndex(i);}
+  void      SetExceptionAtIndex(unsigned i, TreeNode* n) {*(mExceptions.RefAtIndex(i)) = n;}
+  void      AddException(TreeNode *n);
+
+  void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////////////////////////
+//                         Try, Catch, Finally
+// I can build one single TryNode to contain all the information. However,
+// I built all three types of nodes, since some language could have complex
+// syntax of catch or finally.
+//////////////////////////////////////////////////////////////////////////
+
+class CatchNode : public TreeNode {
+private:
+  SmallVector<TreeNode *> mParams;  // In Java, this sould be exception node.
+  BlockNode              *mBlock;
+public:
+  CatchNode() : TreeNode(NK_Catch), mBlock(nullptr) {}
+  ~CatchNode(){}
+
+  BlockNode* GetBlock()       {return mBlock;}
+  void SetBlock(BlockNode *n) {mBlock = n;}
+
+  unsigned  GetParamsNum() {return mParams.GetNum();}
+  TreeNode* GetParamAtIndex(unsigned i) {return mParams.ValueAtIndex(i);}
+  void      SetParamAtIndex(unsigned i, TreeNode* n) {*(mParams.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddParam(TreeNode *n);
+
+  void Dump(unsigned);
+};
+
+class FinallyNode : public TreeNode {
+private:
+  BlockNode              *mBlock;
+public:
+  FinallyNode() : TreeNode(NK_Finally), mBlock(nullptr) {}
+  ~FinallyNode(){}
+
+  BlockNode* GetBlock()       {return mBlock;}
+  void SetBlock(BlockNode *n) {mBlock = n;}
+
+  void Dump(unsigned);
+};
+
+class TryNode : public TreeNode {
+private:
+  BlockNode   *mBlock;
+  FinallyNode *mFinally;
+  SmallVector<CatchNode*> mCatches; // There could be >1 catches.
+
+public:
+  TryNode() : TreeNode(NK_Try), mBlock(nullptr), mFinally(nullptr) {}
+  ~TryNode(){}
+
+  BlockNode* GetBlock()       {return mBlock;}
+  void SetBlock(BlockNode *n) {mBlock = n;}
+
+  FinallyNode* GetFinally()       {return mFinally;}
+  void SetFinally(FinallyNode *n) {mFinally = n;}
+
+  unsigned   GetCatchesNum() {return mCatches.GetNum();}
+  CatchNode* GetCatchAtIndex(unsigned i) {return mCatches.ValueAtIndex(i);}
+  void       SetCatchAtIndex(unsigned i, CatchNode* n) {*(mCatches.RefAtIndex(i)) = n;}
+  void       AddCatch(TreeNode *n);
+
   void Dump(unsigned);
 };
 
@@ -557,8 +1444,8 @@ private:
   // right now I only put a name for it. It could have more properties.
   IdentifierNode *mException;
 public:
-  ExceptionNode() : mException(NULL) {mKind = NK_Exception;}
-  ExceptionNode(IdentifierNode *inode) : mException(inode) {mKind = NK_Exception;}
+  ExceptionNode(IdentifierNode *inode) : TreeNode(NK_Exception), mException(inode) {}
+  ExceptionNode() : ExceptionNode(nullptr) {}
   ~ExceptionNode(){}
 
   IdentifierNode* GetException()       {return mException;}
@@ -575,10 +1462,26 @@ class ReturnNode : public TreeNode {
 private:
   TreeNode *mResult;
 public:
-  ReturnNode() : mResult(NULL) {mKind = NK_Return;}
+  ReturnNode() : TreeNode(NK_Return), mResult(nullptr) {}
   ~ReturnNode(){}
 
-  void SetResult(TreeNode *t) {mResult = t;}
+  void SetResult(TreeNode *t) {mResult = t; SETPARENT(t);}
+  TreeNode* GetResult() { return mResult; }
+  void Dump(unsigned);
+};
+
+class YieldNode : public TreeNode {
+private:
+  TreeNode *mResult;
+  bool      mIsTransfer;  // In TS, yeild* tranfers to another generator
+public:
+  YieldNode() : TreeNode(NK_Yield), mResult(nullptr), mIsTransfer(false) {}
+  ~YieldNode(){}
+
+  void SetIsTransfer(bool b = true) {mIsTransfer = b;}
+  bool IsTransfer()          {return mIsTransfer;}
+
+  void SetResult(TreeNode *t) {mResult = t; SETPARENT(t);}
   TreeNode* GetResult() { return mResult; }
   void Dump(unsigned);
 };
@@ -592,9 +1495,9 @@ public:
   CondBranchNode();
   ~CondBranchNode(){}
 
-  void SetCond(TreeNode *t)       {mCond = t; t->SetParent(this);}
-  void SetTrueBranch(TreeNode *t) {mTrueBranch = t; t->SetParent(this);}
-  void SetFalseBranch(TreeNode *t){mFalseBranch = t; t->SetParent(this);}
+  void SetCond(TreeNode *t)       {mCond = t; SETPARENT(t);}
+  void SetTrueBranch(TreeNode *t) {mTrueBranch = t; SETPARENT(t);}
+  void SetFalseBranch(TreeNode *t){mFalseBranch = t; SETPARENT(t);}
 
   TreeNode* GetCond()        {return mCond;}
   TreeNode* GetTrueBranch()  {return mTrueBranch;}
@@ -608,50 +1511,97 @@ class BreakNode : public TreeNode {
 private:
   TreeNode* mTarget;
 public:
-  BreakNode() {mKind = NK_Break; mTarget = NULL;}
+  BreakNode() : TreeNode(NK_Break), mTarget(nullptr) {}
   ~BreakNode(){}
 
   TreeNode* GetTarget()           {return mTarget;}
-  void      SetTarget(TreeNode* t){mTarget = t;}
+  void      SetTarget(TreeNode* t){mTarget = t; SETPARENT(t);}
+  void      Dump(unsigned);
+};
+
+
+// Continue statement. Continue targets could be one identifier or empty.
+class ContinueNode : public TreeNode {
+private:
+  TreeNode* mTarget;
+public:
+  ContinueNode() : TreeNode(NK_Continue), mTarget(nullptr) {}
+  ~ContinueNode(){}
+
+  TreeNode* GetTarget()           {return mTarget;}
+  void      SetTarget(TreeNode* t){mTarget = t; SETPARENT(t);}
   void      Dump(unsigned);
 };
 
+// Javascript makes for loop complicated. It creates two special syntax as below
+//   for (var in set) {...}
+//   for (var of set) {...}
+// We use  FL_Prop to differentiate them with regular for loop.
+enum ForLoopProp {
+  FLP_Regular,  // this is the default property
+  FLP_JSIn,
+  FLP_JSOf,
+  FLP_NA
+};
+
 class ForLoopNode : public TreeNode {
 private:
-  SmallVector<TreeNode *> mInit;
+  ForLoopProp mProp;
+
+  // Regular for loop
+  SmallVector<TreeNode *> mInits;
   TreeNode               *mCond;
-  SmallVector<TreeNode *> mUpdate;
-  TreeNode               *mBody;   // This is a block node
+  SmallVector<TreeNode *> mUpdates;
+
+  // JS In or JS Of
+  TreeNode *mVariable;
+  TreeNode *mSet;
+
+  // shared by all kinds
+  TreeNode *mBody;   // This could be a single statement, or a block node
+
 public:
-  ForLoopNode() {mCond = NULL; mBody = NULL; mKind = NK_ForLoop;}
+  ForLoopNode() : TreeNode(NK_ForLoop),
+    mCond(nullptr), mBody(nullptr), mVariable(nullptr), mSet(nullptr), mProp(FLP_Regular) {}
   ~ForLoopNode() {Release();}
 
-  void AddInit(TreeNode *t)   {mInit.PushBack(t);}
-  void AddUpdate(TreeNode *t) {mUpdate.PushBack(t);}
-  void SetCond(TreeNode *t)   {mCond = t;}
-  void SetBody(TreeNode *t)   {mBody = t;}
-
-  unsigned GetInitNum()       {return mInit.GetNum();}
-  unsigned GetUpdateNum()     {return mUpdate.GetNum();}
-  TreeNode* InitAtIndex(unsigned i)   {return mInit.ValueAtIndex(i);}
-  TreeNode* UpdateAtIndex(unsigned i) {return mUpdate.ValueAtIndex(i);}
+  void AddInit(TreeNode *t);
+  void AddUpdate(TreeNode *t);
+  void SetCond(TreeNode *t)   {mCond = t; SETPARENT(t);}
+  void SetBody(TreeNode *t)   {mBody = t; SETPARENT(t);}
+
+  unsigned GetInitsNum()     {return mInits.GetNum();}
+  unsigned GetUpdatesNum()   {return mUpdates.GetNum();}
+  TreeNode* GetInitAtIndex(unsigned i)   {return mInits.ValueAtIndex(i);}
+  void      SetInitAtIndex(unsigned i, TreeNode* n) {*(mInits.RefAtIndex(i)) = n;}
+  TreeNode* GetUpdateAtIndex(unsigned i) {return mUpdates.ValueAtIndex(i);}
+  void      SetUpdateAtIndex(unsigned i, TreeNode* n) {*(mUpdates.RefAtIndex(i)) = n;}
   TreeNode* GetCond() {return mCond;}
   TreeNode* GetBody() {return mBody;}
 
-  void Release() {mInit.Release(); mUpdate.Release();}
+  ForLoopProp GetProp() {return mProp;}
+  void SetProp(ForLoopProp p) {mProp = p;}
+
+  TreeNode* GetVariable() {return mVariable;}
+  void SetVariable(TreeNode *t) {mVariable = t; SETPARENT(t);}
+
+  TreeNode* GetSet() {return mSet;}
+  void SetSet(TreeNode *t) {mSet = t; SETPARENT(t);}
+
+  void Release() {mInits.Release(); mUpdates.Release();}
   void Dump(unsigned);
 };
 
 class WhileLoopNode : public TreeNode {
 private:
   TreeNode *mCond;
-  TreeNode *mBody; // This is a block node
+  TreeNode *mBody; // This could be a single statement, or a block node
 public:
-  WhileLoopNode() {mCond = NULL; mBody = NULL; mKind = NK_WhileLoop;}
+  WhileLoopNode() : TreeNode(NK_WhileLoop), mCond(nullptr), mBody(nullptr) {}
   ~WhileLoopNode() {Release();}
 
-  void SetCond(TreeNode *t) {mCond = t;}
-  void SetBody(TreeNode *t) {mBody = t;}
+  void SetCond(TreeNode *t) {mCond = t; SETPARENT(t);}
+  void SetBody(TreeNode *t) {mBody = t; SETPARENT(t);}
   TreeNode* GetCond()       {return mCond;}
   TreeNode* GetBody()       {return mBody;}
 
@@ -662,13 +1612,13 @@ public:
 class DoLoopNode : public TreeNode {
 private:
   TreeNode *mCond;
-  TreeNode *mBody; // This is a block node
+  TreeNode *mBody; // This could be a single statement, or a block node
 public:
-  DoLoopNode() {mCond = NULL; mBody = NULL; mKind = NK_DoLoop;}
+  DoLoopNode() : TreeNode(NK_DoLoop), mCond(nullptr), mBody(nullptr) {}
   ~DoLoopNode(){Release();}
 
-  void SetCond(TreeNode *t) {mCond = t;}
-  void SetBody(TreeNode *t) {mBody = t;}
+  void SetCond(TreeNode *t) {mCond = t; SETPARENT(t);}
+  void SetBody(TreeNode *t) {mBody = t; SETPARENT(t);}
   TreeNode* GetCond()       {return mCond;}
   TreeNode* GetBody()       {return mBody;}
 
@@ -689,11 +1639,11 @@ private:
   bool      mIsDefault; // default lable
   TreeNode *mValue;     // the constant expression
 public:
-  SwitchLabelNode() : mIsDefault(false), mValue(NULL) {mKind = NK_SwitchLabel;}
+  SwitchLabelNode() : TreeNode(NK_SwitchLabel), mIsDefault(false), mValue(nullptr) {}
   ~SwitchLabelNode(){}
 
   void SetIsDefault(bool b) {mIsDefault = b;}
-  void SetValue(TreeNode *t){mValue = t;}
+  void SetValue(TreeNode *t){mValue = t; SETPARENT(t);}
   bool IsDefault()     {return mIsDefault;}
   TreeNode* GetValue() {return mValue;}
 
@@ -709,16 +1659,19 @@ private:
   SmallVector<TreeNode*>    mStmts;
 
 public:
-  SwitchCaseNode() {mKind = NK_SwitchCase;}
+  SwitchCaseNode() :TreeNode(NK_SwitchCase) {}
   ~SwitchCaseNode() {Release();}
 
   unsigned  GetLabelsNum()            {return mLabels.GetNum();}
-  TreeNode* GetLabelAtIndex(unsigned i) {return mLabels.ValueAtIndex(i);}
   void      AddLabel(TreeNode*);
+  SwitchLabelNode* GetLabelAtIndex(unsigned i) {return mLabels.ValueAtIndex(i);}
+  void             SetLabelAtIndex(unsigned i, SwitchLabelNode* n) {*(mLabels.RefAtIndex(i)) = n;}
 
   unsigned  GetStmtsNum()            {return mStmts.GetNum();}
   TreeNode* GetStmtAtIndex(unsigned i) {return mStmts.ValueAtIndex(i);}
+  void      SetStmtAtIndex(unsigned i, TreeNode* n) {*(mStmts.RefAtIndex(i)) = n; SETPARENT(n);}
   void      AddStmt(TreeNode*);
+  void      PopStmt() {mStmts.PopBack();}
 
   void Release() {mStmts.Release(); mLabels.Release();}
   void Dump(unsigned);
@@ -726,18 +1679,22 @@ public:
 
 class SwitchNode : public TreeNode {
 private:
-  TreeNode *mCond;
+  TreeNode *mExpr;
   SmallVector<SwitchCaseNode*> mCases;
 public:
-  SwitchNode() : mCond(NULL) {mKind = NK_Switch;}
+  SwitchNode() : TreeNode(NK_Switch), mExpr(nullptr) {}
   ~SwitchNode() {Release();}
 
-  TreeNode* GetCond() {return mCond;}
-  void SetCond(TreeNode *c) {mCond = c;}
+  TreeNode* GetExpr() {return mExpr;}
+  void SetExpr(TreeNode *c) {mExpr = c; SETPARENT(c);}
 
   unsigned  GetCasesNum() {return mCases.GetNum();}
-  TreeNode* GetCaseAtIndex(unsigned i) {return mCases.ValueAtIndex(i);}
-  void      AddCase(TreeNode *c);
+  SwitchCaseNode* GetCaseAtIndex(unsigned i) {return mCases.ValueAtIndex(i);}
+  void            SetCaseAtIndex(unsigned i, SwitchCaseNode* n) {*(mCases.RefAtIndex(i)) = n;}
+  void AddCase(SwitchCaseNode* n) {mCases.PushBack(n); SETPARENT(n);}
+
+  void            AddSwitchCase(TreeNode *t);
+  SwitchCaseNode* SwitchLabelToCase(SwitchLabelNode*);
 
   void Release() {mCases.Release();}
   void Dump(unsigned);
@@ -754,13 +1711,13 @@ private:
   TreeNode  *mExpr;
   TreeNode  *mMsg;
 public:
-  AssertNode() : mExpr(NULL), mMsg(NULL) {mKind = NK_Assert;}
+  AssertNode() : TreeNode(NK_Assert), mExpr(nullptr), mMsg(nullptr) {}
   ~AssertNode(){}
 
   TreeNode* GetExpr() {return mExpr;}
   TreeNode* GetMsg() {return mMsg;}
-  void SetExpr(TreeNode *t) {mExpr = t;}
-  void SetMsg(TreeNode *t)  {mMsg = t;}
+  void SetExpr(TreeNode *t) {mExpr = t; SETPARENT(t);}
+  void SetMsg(TreeNode *t)  {mMsg = t; SETPARENT(t);}
 
   void Dump(unsigned);
 };
@@ -773,20 +1730,31 @@ class CallNode : public TreeNode {
 private:
   TreeNode    *mMethod;
   ExprListNode mArgs;
+  SmallVector<TreeNode*> mTypeArguments;
+  TemplateLiteralNode *mTaggedTemplate;
 public:
-  CallNode() : mMethod(NULL){mKind = NK_Call;}
-  ~CallNode(){}
+  CallNode() : TreeNode(NK_Call), mMethod(nullptr), mTaggedTemplate(nullptr) {}
+  ~CallNode(){Release();}
 
   void Init();
 
   TreeNode* GetMethod() {return mMethod;}
-  void SetMethod(TreeNode *t) {mMethod = t;}
+  void SetMethod(TreeNode *t) {mMethod = t; SETPARENT(t);}
 
-  void AddArg(TreeNode *t);
-  unsigned GetArgsNum() {return mArgs.GetNum();}
-  TreeNode* GetArg(unsigned index) {return mArgs.ExprAtIndex(index);}
+  TemplateLiteralNode* GetTaggedTemplate() {return mTaggedTemplate;}
+  void SetTaggedTemplate(TemplateLiteralNode *t) {mTaggedTemplate = t; SETPARENT(t);}
 
-  void Release() {mArgs.Release();}
+  void AddArg(TreeNode *t) {mArgs.Merge(t); SETPARENT(t);}
+  unsigned GetArgsNum() {return mArgs.GetExprsNum();}
+  TreeNode* GetArg(unsigned index) {return mArgs.GetExprAtIndex(index);}
+  void      SetArg(unsigned i, TreeNode* n) {mArgs.SetExprAtIndex(i, n); SETPARENT(n);}
+
+  unsigned  GetTypeArgumentsNum()            {return mTypeArguments.GetNum();}
+  TreeNode* GetTypeArgumentAtIndex(unsigned i) {return mTypeArguments.ValueAtIndex(i);}
+  void      SetTypeArgumentAtIndex(unsigned i, TreeNode* n) {*(mTypeArguments.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddTypeArgument(TreeNode *);
+
+  void Release() {mArgs.Release(); mTypeArguments.Release();}
   void Dump(unsigned);
 };
 
@@ -817,22 +1785,32 @@ public:
   bool                mIsInstInit; // Instance Initializer
   SmallVector<AttrId> mAttrs;
 
+  TreeNode           *mSync;       // Java allows a sync object on a Block.
+
 public:
-  BlockNode(){mKind = NK_Block; mIsInstInit = false;}
+  BlockNode() : TreeNode(NK_Block), mIsInstInit(false), mSync(nullptr) {}
   ~BlockNode() {Release();}
 
   // Instance Initializer and Attributes related
   bool IsInstInit()    {return mIsInstInit;}
-  void SetIsInstInit() {mIsInstInit = true;}
-  unsigned GetAttrsNum()           {return mAttrs.GetNum();}
-  void     AddAttr(AttrId a)       {mAttrs.PushBack(a);}
-  AttrId   AttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void SetIsInstInit(bool b = true) {mIsInstInit = b;}
+  unsigned GetAttrsNum()              {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
+
+  void  SetSync(TreeNode *n) {mSync = n;}
+  TreeNode* GetSync() {return mSync;}
 
   unsigned  GetChildrenNum()            {return mChildren.GetNum();}
   TreeNode* GetChildAtIndex(unsigned i) {return mChildren.ValueAtIndex(i);}
-  void      AddChild(TreeNode *c)       {mChildren.PushBack(c); c->SetParent(this);}
+  void      SetChildAtIndex(unsigned i, TreeNode* n) {*(mChildren.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddChild(TreeNode *c);
   void      ClearChildren()             {mChildren.Clear();}
 
+  void InsertStmtAfter(TreeNode *new_stmt, TreeNode *exist_stmt);
+  void InsertStmtBefore(TreeNode *new_stmt, TreeNode *exist_stmt);
+
   void Release() {mChildren.Release();}
   void Dump(unsigned);
 };
@@ -850,11 +1828,25 @@ private:
   SmallVector<AttrId>          mAttrs;
   SmallVector<AnnotationNode*> mAnnotations; //annotation or pragma
   SmallVector<ExceptionNode*>  mThrows;      // exceptions it can throw
-  TreeNode                    *mType;        // return type
+  SmallVector<TreeNode*>       mTypeParams;
+  TreeNode                    *mFuncName;    // function name, usually an identifier
+  TreeNode                    *mRetType;     // return type
   SmallVector<TreeNode*>       mParams;      //
   BlockNode                   *mBody;
   DimensionNode               *mDims;
-  bool                         mIsConstructor;
+  TreeNode                    *mAssert;      // In typescript, a function could have asserts
+                                             // like: func () : asserts v is string
+                                             // or a type predicate signature, like
+                                             //    func() : v is string
+                                             // So mAssert could be either an AssertNode or
+                                             // an IsNode.
+  bool mIsConstructor;
+  bool mIsGetAccessor;
+  bool mIsSetAccessor;
+  bool mIsGenerator;          // JS/TS generator
+  bool mIsIterator;           // JS/TS iterator
+  bool mIsCallSignature;      // no func name, no func body
+  bool mIsConstructSignature; // no func name, no func body, and is a construct sig in TS
 
 public:
   FunctionNode();
@@ -864,40 +1856,69 @@ public:
   // the PassNode in the tree.
   void CleanUp();
 
-  BlockNode* GetBody() {return mBody;}
-  void AddBody(BlockNode *b) {mBody = b; b->SetParent(this); CleanUp();}
+  TreeNode* GetFuncName() {return mFuncName;}
+  void SetFuncName(TreeNode *n) {mFuncName = n; SETPARENT(n);}
 
-  bool IsConstructor()    {return mIsConstructor;}
-  void SetIsConstructor() {mIsConstructor = true;}
+  BlockNode* GetBody() {return mBody;}
+  void SetBody(BlockNode *b) {mBody = b; SETPARENT(b); if(b) CleanUp();}
+
+  TreeNode* GetAssert() {return mAssert;}
+  void SetAssert(TreeNode *b) {mAssert = b; SETPARENT(b);}
+
+  bool IsConstructor()                 {return mIsConstructor;}
+  void SetIsConstructor(bool b = true) {mIsConstructor = b;}
+  bool IsGenerator()                 {return mIsGenerator;}
+  void SetIsGenerator(bool b = true) {mIsGenerator = b;}
+  bool IsIterator()                 {return mIsIterator;}
+  void SetIsIterator(bool b = true) {mIsIterator = b;}
+  bool IsGetAccessor()               {return mIsGetAccessor;}
+  void SetIsGetAccessor(bool b = true) {mIsGetAccessor = b;}
+  bool IsSetAccessor()                 {return mIsSetAccessor;}
+  void SetIsSetAccessor(bool b = true) {mIsSetAccessor = b;}
+  bool IsCallSignature()                 {return mIsCallSignature;}
+  void SetIsCallSignature(bool b = true) {mIsCallSignature = b;}
+  bool IsConstructSignature()                 {return mIsConstructSignature;}
+  void SetIsConstructSignature(bool b = true) {mIsConstructSignature = b;}
 
   unsigned  GetParamsNum()        {return mParams.GetNum();}
   TreeNode* GetParam(unsigned i)  {return mParams.ValueAtIndex(i);}
-  void      AddParam(TreeNode *t) {mParams.PushBack(t); t->SetParent(this);}
-  
+  void      SetParam(unsigned i, TreeNode* n) {*(mParams.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddParam(TreeNode *t) {mParams.PushBack(t); SETPARENT(t);}
+  void      ClearParam()          {mParams.Clear();}
+
   // Attributes related
-  unsigned GetAttrsNum()           {return mAttrs.GetNum();}
-  void     AddAttr(AttrId a)       {mAttrs.PushBack(a);}
-  AttrId   AttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  unsigned GetAttrsNum()              {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
 
   // Annotation/Pragma related
   unsigned GetAnnotationsNum()           {return mAnnotations.GetNum();}
   void     AddAnnotation(AnnotationNode *n) {mAnnotations.PushBack(n);}
-  AnnotationNode* AnnotationAtIndex(unsigned i) {return mAnnotations.ValueAtIndex(i);}
+  AnnotationNode* GetAnnotationAtIndex(unsigned i) {return mAnnotations.ValueAtIndex(i);}
+  void            SetAnnotationAtIndex(unsigned i, AnnotationNode* n) {*(mAnnotations.RefAtIndex(i)) = n;}
 
   // Exception/throw related
-  unsigned       GetThrowNum()             {return mThrows.GetNum();}
-  void           AddThrow(ExceptionNode *n){mThrows.PushBack(n);}
-  ExceptionNode* ThrowAtIndex(unsigned i)  {return mThrows.ValueAtIndex(i);}
+  unsigned       GetThrowsNum()               {return mThrows.GetNum();}
+  void           AddThrow(ExceptionNode *n)   {mThrows.PushBack(n);}
+  ExceptionNode* GetThrowAtIndex(unsigned i)  {return mThrows.ValueAtIndex(i);}
+  void           SetThrowAtIndex(unsigned i, ExceptionNode* n) {*(mThrows.RefAtIndex(i)) = n;}
 
-  void SetType(TreeNode *t) {mType = t;}
-  TreeNode* GetType(){return mType;}
+  unsigned  GetTypeParamsNum()            {return mTypeParams.GetNum();}
+  TreeNode* GetTypeParamAtIndex(unsigned i) {return mTypeParams.ValueAtIndex(i);}
+  void      SetTypeParamAtIndex(unsigned i, TreeNode* n) {*(mTypeParams.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddTypeParam(TreeNode *);
 
+  void SetRetType(TreeNode *t) {mRetType = t; SETPARENT(t);}
+  TreeNode* GetRetType(){return mRetType;}
+
+  DimensionNode* GetDims()       {return mDims;}
   void SetDims(DimensionNode *t) {mDims = t;}
-  unsigned GetDimsNum()          {return mDims->GetDimsNum();}
-  bool     IsArray()             {return mDims && GetDimsNum() > 0;}
-  unsigned AddDim(unsigned i = 0){mDims->AddDim(i);}           // 0 means unspecified
-  unsigned GetNthNum(unsigned n) {return mDims->GetNthDim(n);} // 0 means unspecified.
-  void     SetNthNum(unsigned n, unsigned i) {mDims->SetNthDim(n, i);}
+  unsigned GetDimsNum()          {return mDims->GetDimensionsNum();}
+  bool     IsArray()             {return mDims && mDims->GetDimensionsNum() > 0;}
+  void     AddDim(unsigned i = 0){mDims->AddDimension(i);}        // 0 means unspecified
+  unsigned GetNthDim(unsigned n) {return mDims->GetDimension(n);} // 0 means unspecified.
+  void     SetNthDim(unsigned n, unsigned i) {mDims->SetDimension(n, i);}
 
   // Override equivalent.
   bool OverrideEquivalent(FunctionNode*);
@@ -922,10 +1943,26 @@ private:
   SmallVector<IdentifierNode*> mFields;
   SmallVector<FunctionNode*>   mMethods;
 public:
-  InterfaceNode() : mIsAnnotation(false) {mKind = NK_Interface;}
+  InterfaceNode() : TreeNode(NK_Interface), mIsAnnotation(false) {}
   ~InterfaceNode() {}
 
+  unsigned       GetSuperInterfacesNum()              {return mSuperInterfaces.GetNum();}
+  void           AddSuperInterface(InterfaceNode* a)  {mSuperInterfaces.PushBack(a);}
+  InterfaceNode* GetSuperInterfaceAtIndex(unsigned i) {return mSuperInterfaces.ValueAtIndex(i);}
+  void           SetSuperInterfaceAtIndex(unsigned i, InterfaceNode* n) {*(mSuperInterfaces.RefAtIndex(i)) = n;}
+
+  unsigned        GetFieldsNum()              {return mFields.GetNum();}
+  void            AddField(IdentifierNode* n) {mFields.PushBack(n); SETPARENT(n);}
+  IdentifierNode* GetField(unsigned i) {return mFields.ValueAtIndex(i);}
+  void            SetField(unsigned i, IdentifierNode* n) {*(mFields.RefAtIndex(i)) = n; SETPARENT(n);}
+
+  unsigned      GetMethodsNum()              {return mMethods.GetNum();}
+  void          AddMethod(FunctionNode* a)   {mMethods.PushBack(a);}
+  FunctionNode* GetMethod(unsigned i) {return mMethods.ValueAtIndex(i);}
+  void          SetMethod(unsigned i, FunctionNode* n) {*(mMethods.RefAtIndex(i)) = n;}
+
   void SetIsAnnotation(bool b) {mIsAnnotation = b;}
+  bool IsAnnotation()          {return mIsAnnotation;}
 
   void Construct(BlockNode *);
   void Dump(unsigned);
@@ -933,25 +1970,6 @@ public:
 
 //////////////////////////////////////////////////////////////////////////
 //                         Class Nodes
-//                             &
-//                         ClassBody -->BlockNode
-// In reality there is no such thing as ClassBody, since this 'body' will
-// eventually become fields and methods of a class. However, during parsing
-// the children are processed before parents, which means we need to have
-// all fields and members ready before the class. So we come up with
-// this ClassBody to temporarily hold these subtrees, and let the class
-// to interpret it in the future. Once the class is done, this ClassBody
-// is useless. In the real implementation, ClassBody is actually a BlockNode.
-//
-// NOTE. There is one important thing to know is This design is following
-//       the common rules of Java/C++, where a declaration of field or
-//       method has the scope of the whole class. This means it can be
-//       used before the declaratioin. There is no order of first decl then
-//       use. So we can do a Construct() which collect all Fields & Methods.
-//
-//       However, we still keep mBody, which actually tells the order of
-//       the original program. Any language requiring order could use mBody
-//       to implement.
 //////////////////////////////////////////////////////////////////////////
 
 class ClassNode : public TreeNode {
@@ -960,46 +1978,101 @@ private:
   // and special semantic rules. We define JavaEnum here too. For other
   // languages like C/C++ which have very simply Enum, we will have a
   // dedicated EnumNode for them.
-  bool                         mJavaEnum;
+  bool                         mIsJavaEnum;
 
-  SmallVector<ClassNode*>      mSuperClasses;
-  SmallVector<InterfaceNode*>  mSuperInterfaces;
-  SmallVector<AttrId>          mAttributes;
-  BlockNode                   *mBody;
+  SmallVector<TreeNode*>          mSuperClasses;
+  SmallVector<TreeNode*>          mSuperInterfaces;
+  SmallVector<AttrId>             mAttributes;
+  SmallVector<AnnotationNode*>    mAnnotations; //annotation or pragma
+  SmallVector<TypeParameterNode*> mTypeParams;
 
-  SmallVector<IdentifierNode*> mFields;       // aka Field
+  SmallVector<TreeNode*>       mFields;  // a Field could be identifier or computed name
   SmallVector<FunctionNode*>   mMethods;
   SmallVector<FunctionNode*>   mConstructors;
   SmallVector<BlockNode*>      mInstInits;     // instance initializer
   SmallVector<ClassNode*>      mLocalClasses;
   SmallVector<InterfaceNode*>  mLocalInterfaces;
+  SmallVector<ImportNode*>     mImports;
+  SmallVector<ExportNode*>     mExports;
+
+  SmallVector<DeclareNode*>    mDeclares; // First coming from TS.
 
 public:
-  ClassNode(){mKind = NK_Class; mJavaEnum = false; mBody = NULL;}
+  ClassNode() : TreeNode(NK_Class), mIsJavaEnum(false) {}
   ~ClassNode() {Release();}
 
-  bool IsJavaEnum() {return mJavaEnum;}
-  void SetJavaEnum(){mJavaEnum = true;}
-
-  void AddSuperClass(ClassNode *n)         {mSuperClasses.PushBack(n);}
-  void AddSuperInterface(InterfaceNode *n) {mSuperInterfaces.PushBack(n);}
-  void AddAttr(AttrId a) {mAttributes.PushBack(a);}
-  void AddBody(BlockNode *b) {mBody = b; b->SetParent(this);}
-
-  unsigned GetFieldsNum()      {return mFields.GetNum();}
-  unsigned GetMethodsNum()     {return mMethods.GetNum();}
-  unsigned GetConstructorNum() {return mConstructors.GetNum();}
-  unsigned GetInstInitsNum()   {return mInstInits.GetNum();}
-  unsigned GetLocalClassesNum()   {return mLocalClasses.GetNum();}
-  unsigned GetLocalInterfacesNum(){return mLocalInterfaces.GetNum();}
-  IdentifierNode* GetField(unsigned i)     {return mFields.ValueAtIndex(i);}
-  FunctionNode* GetMethod(unsigned i)      {return mMethods.ValueAtIndex(i);}
-  FunctionNode* GetConstructor(unsigned i) {return mConstructors.ValueAtIndex(i);}
+  bool IsJavaEnum()                {return mIsJavaEnum;}
+  void SetIsJavaEnum(bool b = true){mIsJavaEnum = b;}
+
+  // Annotation/Pragma related
+  unsigned GetAnnotationsNum()           {return mAnnotations.GetNum();}
+  void     AddAnnotation(AnnotationNode *n) {mAnnotations.PushBack(n);}
+  AnnotationNode* GetAnnotationAtIndex(unsigned i) {return mAnnotations.ValueAtIndex(i);}
+  void            SetAnnotationAtIndex(unsigned i, AnnotationNode* n) {*(mAnnotations.RefAtIndex(i)) = n;}
+
+  // TypeParameter
+  unsigned GetTypeParamsNum()           {return mTypeParams.GetNum();}
+  void     AddTypeParam(TreeNode *n);
+  TypeParameterNode* GetTypeParamAtIndex(unsigned i) {return mTypeParams.ValueAtIndex(i);}
+  void               SetTypeParamAtIndex(unsigned i, TypeParameterNode* n) {*(mTypeParams.RefAtIndex(i)) = n;}
+
+  void      AddSuperClass(TreeNode *n);
+  unsigned  GetSuperClassesNum()        {return mSuperClasses.GetNum();}
+  TreeNode* GetSuperClass(unsigned i)   {return mSuperClasses.ValueAtIndex(i);}
+  void      SetSuperClass(unsigned i, TreeNode* n) {*(mSuperClasses.RefAtIndex(i)) = n;}
+
+  void      AddSuperInterface(TreeNode *n);
+  unsigned  GetSuperInterfacesNum()        {return mSuperInterfaces.GetNum();}
+  TreeNode* GetSuperInterface(unsigned i)  {return mSuperInterfaces.ValueAtIndex(i);}
+  void      SetSuperInterface(unsigned i, TreeNode* n) {*(mSuperInterfaces.RefAtIndex(i)) = n;}
+
+  void AddAttr(AttrId a)      {mAttributes.PushBack(a);}
+  void AddAttribute(AttrId a) {mAttributes.PushBack(a);}
+
+  void AddField(TreeNode *n) {mFields.PushBack(n); SETPARENT(n);}
+  void AddMethod(FunctionNode *n) {mMethods.PushBack(n);}
+  void AddConstructor(FunctionNode *n) {mConstructors.PushBack(n);}
+  void AddInstInit(BlockNode *n) {mInstInits.PushBack(n);}
+  void AddLocalClass(ClassNode *n) {mLocalClasses.PushBack(n);}
+  void AddLocalInterface(InterfaceNode *n) {mLocalInterfaces.PushBack(n);}
+  void AddImport(ImportNode *n) {mImports.PushBack(n);}
+  void AddExport(ExportNode *n) {mExports.PushBack(n);}
+  void AddDeclare(DeclareNode *n) {mDeclares.PushBack(n);}
+
+
+  unsigned GetAttributesNum()      {return mAttributes.GetNum();}
+  unsigned GetFieldsNum()          {return mFields.GetNum();}
+  unsigned GetMethodsNum()         {return mMethods.GetNum();}
+  unsigned GetConstructorsNum()    {return mConstructors.GetNum();}
+  unsigned GetInstInitsNum()       {return mInstInits.GetNum();}
+  unsigned GetLocalClassesNum()    {return mLocalClasses.GetNum();}
+  unsigned GetLocalInterfacesNum() {return mLocalInterfaces.GetNum();}
+  unsigned GetImportsNum()         {return mImports.GetNum();}
+  unsigned GetExportsNum()         {return mExports.GetNum();}
+  unsigned GetDeclaresNum()        {return mDeclares.GetNum();}
+
+  AttrId GetAttribute(unsigned i)              {return mAttributes.ValueAtIndex(i);}
+  void   SetAttribute(unsigned i, AttrId n) {*(mAttributes.RefAtIndex(i)) = n;}
+  TreeNode* GetField(unsigned i)         {return mFields.ValueAtIndex(i);}
+  void      SetField(unsigned i, TreeNode* n) {*(mFields.RefAtIndex(i)) = n; SETPARENT(n);}
+  FunctionNode* GetMethod(unsigned i)          {return mMethods.ValueAtIndex(i);}
+  void          SetMethod(unsigned i, FunctionNode* n) {*(mMethods.RefAtIndex(i)) = n;}
+  FunctionNode* GetConstructor(unsigned i)     {return mConstructors.ValueAtIndex(i);}
+  void          SetConstructor(unsigned i, FunctionNode* n) {*(mConstructors.RefAtIndex(i)) = n;}
   BlockNode* GetInstInit(unsigned i)       {return mInstInits.ValueAtIndex(i);}
+  void       SetInstInit(unsigned i, BlockNode* n) {*(mInstInits.RefAtIndex(i)) = n;}
   ClassNode* GetLocalClass(unsigned i)     {return mLocalClasses.ValueAtIndex(i);}
-  InterfaceNode* GetLocalInterface(unsigned i)  {return mLocalInterfaces.ValueAtIndex(i);}
-
-  void Construct();
+  void       SetLocalClass(unsigned i, ClassNode* n) {*(mLocalClasses.RefAtIndex(i)) = n;}
+  InterfaceNode* GetLocalInterface(unsigned i)                   {return mLocalInterfaces.ValueAtIndex(i);}
+  void           SetLocalInterface(unsigned i, InterfaceNode* n) {*(mLocalInterfaces.RefAtIndex(i)) = n;}
+  ImportNode* GetImport(unsigned i)                {return mImports.ValueAtIndex(i);}
+  void        SetImport(unsigned i, ImportNode* n) {*(mImports.RefAtIndex(i)) = n;}
+  ExportNode* GetExport(unsigned i)                {return mExports.ValueAtIndex(i);}
+  void        SetExport(unsigned i, ExportNode* n) {*(mExports.RefAtIndex(i)) = n;}
+  DeclareNode* GetDeclare(unsigned i)                 {return mDeclares.ValueAtIndex(i);}
+  void         SetDeclare(unsigned i, DeclareNode* n) {*(mDeclares.RefAtIndex(i)) = n;}
+
+  void Construct(BlockNode*);
   void Release();
   void Dump(unsigned);
 };
@@ -1018,69 +2091,332 @@ class PassNode : public TreeNode {
 private:
   SmallVector<TreeNode*> mChildren;
 public:
-  PassNode() {mKind = NK_Pass;}
+  PassNode() : TreeNode(NK_Pass) {}
   ~PassNode() {Release();}
 
   unsigned  GetChildrenNum() {return mChildren.GetNum();}
-  TreeNode* GetChild(unsigned idx) {return mChildren.ValueAtIndex(idx);}
-  void SetChild(unsigned idx, TreeNode *t) {*(mChildren.RefAtIndex(idx)) = t;}
+  TreeNode* GetChild(unsigned i) {return mChildren.ValueAtIndex(i);}
+  void      SetChild(unsigned i, TreeNode* n) {*(mChildren.RefAtIndex(i)) = n;}
 
-  void AddChild(TreeNode *c) {mChildren.PushBack(c); c->SetParent(this);}
+  void AddChild(TreeNode *c) {mChildren.PushBack(c); SETPARENT(c);}
   void Dump(unsigned);
   void Release() {mChildren.Release();}
 };
 
 ////////////////////////////////////////////////////////////////////////////
 //                  Lambda Expression
+// Java Lambda expression and JS arrow function have similar syntax.
+// Also in Typescript, FunctionType and Constructor Type have the similar syntax.
+// We put them in the same node.
 ////////////////////////////////////////////////////////////////////////////
 
+// This property tells categories of LambdaNode
+enum LambdaProperty {
+  LP_JavaLambda,
+  LP_JSArrowFunction,
+  LP_NA
+};
+
 class LambdaNode : public TreeNode {
 private:
-  SmallVector<IdentifierNode*> mParams;
-  TreeNode *mBody;  // the body is block.
+  LambdaProperty         mProperty;
+  TreeNode              *mRetType;      // The return type. nullptr as Java Lambda.
+  SmallVector<TreeNode*> mParams;       // A param could be an IdentifierNode or DeclNode.
+  TreeNode              *mBody;         // the body could be an expression, or block.
+                                        // nullptr as TS FunctionType and ConstructorType
+  SmallVector<TypeParameterNode*> mTypeParams;
+  SmallVector<AttrId>    mAttrs;
 public:
-  LambdaNode() {mBody = NULL; mKind = NK_Lambda;}
+  LambdaNode() : TreeNode(NK_Lambda),
+    mBody(nullptr), mProperty(LP_JSArrowFunction), mRetType(nullptr) {}
   ~LambdaNode(){Release();}
 
-  void AddParam(IdentifierNode *n) {mParams.PushBack(n); n->SetParent(this);}
-  void SetBody(TreeNode *n) {mBody = n; n->SetParent(this);}
+
+  TreeNode* GetBody()            {return mBody;}
+  void      SetBody(TreeNode *n) {mBody = n; SETPARENT(n);}
+
+  LambdaProperty  GetProperty()                 {return mProperty;}
+  void            SetProperty(LambdaProperty p) {mProperty = p;}
+
+  TreeNode* GetRetType()            {return mRetType;}
+  void      SetRetType(TreeNode* t) {mRetType = t; SETPARENT(t);}
+
+  unsigned  GetParamsNum()        {return mParams.GetNum();}
+  TreeNode* GetParam(unsigned i)  {return mParams.ValueAtIndex(i);}
+  void      SetParam(unsigned i, TreeNode* n) {*(mParams.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddParam(TreeNode *n) {mParams.PushBack(n); SETPARENT(n);}
+
+  // TypeParameter
+  unsigned GetTypeParamsNum()           {return mTypeParams.GetNum();}
+  void     AddTypeParam(TreeNode *n);
+  TypeParameterNode* GetTypeParamAtIndex(unsigned i) {return mTypeParams.ValueAtIndex(i);}
+  void               SetTypeParamAtIndex(unsigned i, TypeParameterNode* n) {*(mTypeParams.RefAtIndex(i)) = n;}
+
+  // Attributes related
+  unsigned GetAttrsNum() const        {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
 
   void Release() {mParams.Release();}
   void Dump(unsigned);
 };
 
 ////////////////////////////////////////////////////////////////////////////
-//                  The AST Tree
+//                  InstanceOf Expression
+// This is first created for Java's instanceof operation. It has the form of
+// left instanceof right.
+////////////////////////////////////////////////////////////////////////////
+
+class InstanceOfNode : public TreeNode {
+private:
+  TreeNode *mLeft;
+  TreeNode *mRight;
+public:
+  InstanceOfNode() : TreeNode(NK_InstanceOf), mLeft(nullptr), mRight(nullptr) {}
+  ~InstanceOfNode(){Release();}
+
+  TreeNode* GetLeft() {return mLeft;}
+  void SetLeft(TreeNode *n) {mLeft = n; SETPARENT(n);}
+  TreeNode* GetRight() {return mRight;}
+  void SetRight(TreeNode *n){mRight = n; SETPARENT(n);}
+
+  void Dump(unsigned);
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                  TypeOf Expression
+// First coming from typescript.
+////////////////////////////////////////////////////////////////////////////
+
+class TypeOfNode : public TreeNode {
+private:
+  TreeNode *mExpr;
+public:
+  TypeOfNode() : TreeNode(NK_TypeOf), mExpr(nullptr) {}
+  ~TypeOfNode(){Release();}
+
+  TreeNode* GetExpr()            {return mExpr;}
+  void      SetExpr(TreeNode *n) {mExpr = n; SETPARENT(n);}
+
+  void Dump(unsigned);
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                  KeyOf Expression
+// First coming from typescript.
+////////////////////////////////////////////////////////////////////////////
+
+class KeyOfNode : public TreeNode {
+private:
+  TreeNode *mExpr;
+public:
+  KeyOfNode() : TreeNode(NK_KeyOf), mExpr(nullptr) {}
+  ~KeyOfNode(){Release();}
+
+  TreeNode* GetExpr()            {return mExpr;}
+  void      SetExpr(TreeNode *n) {mExpr = n; SETPARENT(n);}
+
+  void Dump(unsigned);
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                  Infer Expression
+// First coming from typescript.
+////////////////////////////////////////////////////////////////////////////
+
+class InferNode : public TreeNode {
+private:
+  TreeNode *mExpr;
+public:
+  InferNode() : TreeNode(NK_Infer), mExpr(nullptr) {}
+  ~InferNode(){Release();}
+
+  TreeNode* GetExpr()            {return mExpr;}
+  void      SetExpr(TreeNode *n) {mExpr = n; SETPARENT(n);}
+
+  void Dump(unsigned);
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                  In Expression
+// First coming from Javascript. It's like
+// A is IN B.
+// B is a set of properties. A is one of the properties.
+////////////////////////////////////////////////////////////////////////////
+
+class InNode : public TreeNode {
+private:
+  TreeNode *mLeft;
+  TreeNode *mRight;
+public:
+  InNode() : TreeNode(NK_In), mLeft(nullptr), mRight(nullptr) {}
+  ~InNode(){Release();}
+
+  TreeNode* GetLeft() {return mLeft;}
+  void SetLeft(TreeNode *n) {mLeft = n; SETPARENT(n);}
+  TreeNode* GetRight() {return mRight;}
+  void SetRight(TreeNode *n){mRight = n; SETPARENT(n);}
+
+  void Dump(unsigned);
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                  ComputedName Expression
+// First coming from Javascript. It's like
+// [ xxx ]
 ////////////////////////////////////////////////////////////////////////////
 
-class AppealNode;
-class ASTBuilder;
+enum CompNameProp {
+  CNP_NA = 0,
+  CNP_Rem_ReadOnly = 1,
+  CNP_Add_ReadOnly = 1 << 1,
+  CNP_Rem_Optional = 1 << 2,
+  CNP_Add_Optional = 1 << 3,
+};
+
+class ComputedNameNode : public TreeNode {
+private:
+  unsigned  mProp;
+  TreeNode *mExpr;
+  TreeNode *mInit;
+  TreeNode *mExtendType;  // This is the type extending expression
+                          // of the mapped property
+  SmallVector<AttrId>    mAttrs;
+public:
+  ComputedNameNode() : TreeNode(NK_ComputedName),
+    mProp(CNP_NA), mExpr(nullptr), mExtendType(nullptr), mInit(nullptr) {}
+  ~ComputedNameNode(){Release();}
+
+  void Release() {mAttrs.Release();}
+
+  unsigned GetProp()           {return mProp;}
+  void     SetProp(unsigned p) {mProp = mProp | p;}
+
+  TreeNode* GetExpr()            {return mExpr;}
+  void      SetExpr(TreeNode *n) {mExpr = n; SETPARENT(n);}
+  TreeNode* GetInit()            {return mInit;}
+  void      SetInit(TreeNode *n) {mInit = n; SETPARENT(n);}
+  TreeNode* GetExtendType()            {return mExtendType;}
+  void      SetExtendType(TreeNode *n) {mExtendType = n; SETPARENT(n);}
+
+  // Attributes related
+  unsigned GetAttrsNum() const        {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
+
+  void Dump(unsigned);
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                  Is Expression
+// First coming from Typescript. It's like
+// A is B.
+// B is usually a type.
+////////////////////////////////////////////////////////////////////////////
 
-class ASTTree {
+class IsNode : public TreeNode {
+private:
+  TreeNode *mLeft;
+  TreeNode *mRight;
 public:
-  TreePool    mTreePool;
-  TreeNode   *mRootNode;
+  IsNode() : TreeNode(NK_Is), mLeft(nullptr), mRight(nullptr) {}
+  ~IsNode(){Release();}
+
+  TreeNode* GetLeft() {return mLeft;}
+  void SetLeft(TreeNode *n) {mLeft = n; SETPARENT(n);}
+  TreeNode* GetRight() {return mRight;}
+  void SetRight(TreeNode *n){mRight = n; SETPARENT(n);}
+
+  void Dump(unsigned);
+};
 
+////////////////////////////////////////////////////////////////////////////
+//                  Await node
+// 'await' is waiting on some expression to finish.
+////////////////////////////////////////////////////////////////////////////
+
+class AwaitNode : public TreeNode {
 private:
-  // We need a set of functions to deal with some common manipulations of
-  // most languages during AST Building. You can disable it if some functions
-  // are not what you want.
-  TreeNode* Manipulate(AppealNode*);
-  TreeNode* Manipulate2Binary(TreeNode*, TreeNode*);
-  TreeNode* Manipulate2Cast(TreeNode*, TreeNode*);
+  TreeNode *mExpr;
+public:
+  AwaitNode() : TreeNode(NK_Await), mExpr(nullptr) {}
+  ~AwaitNode() {}
+
+  TreeNode* GetExpr() {return mExpr;}
+  void SetExpr(TreeNode *n) {mExpr = n; SETPARENT(n);}
+
+  void Dump(unsigned);
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                  Tuple Type
+// [label : type, label : type, ...]
+////////////////////////////////////////////////////////////////////////////
 
+class NameTypePairNode : public TreeNode {
+private:
+  TreeNode *mVar;
+  TreeNode *mType;
 public:
-  ASTTree();
-  ~ASTTree();
+  NameTypePairNode() : TreeNode(NK_NameTypePair), mVar(nullptr), mType(nullptr) {}
+  ~NameTypePairNode() {}
+
+  TreeNode* GetVar()  {return mVar;}
+  TreeNode* GetType() {return mType;}
+  void SetVar(TreeNode* t)  {mVar = t; SETPARENT(t);}
+  void SetType(TreeNode* t) {mType = t; SETPARENT(t);}
+
+  void Dump(unsigned);
+};
 
-  TreeNode* NewTreeNode(AppealNode*);
+class TupleTypeNode : public TreeNode {
+private:
+  SmallVector<NameTypePairNode*>       mFields;
+public:
+  TupleTypeNode() : TreeNode(NK_TupleType) {}
+  ~TupleTypeNode() {Release();}
 
-  TreeNode* BuildBinaryOperation(TreeNode *, TreeNode *, OprId);
-  TreeNode* BuildPassNode();
+  unsigned  GetFieldsNum() {return mFields.GetNum();}
+  NameTypePairNode* GetField(unsigned i) {return mFields.ValueAtIndex(i);}
+  void      SetField(unsigned i, NameTypePairNode* n) {*(mFields.RefAtIndex(i)) = n; SETPARENT(n);}
+  void      AddField(NameTypePairNode *n) {mFields.PushBack(n); SETPARENT(n);}
+  void      AddChild(TreeNode *n);
 
+  void Release() {mFields.Release();}
   void Dump(unsigned);
+};
+
+//////////////////////////////////////////////////////
+//           Triple Slash Directive
+//////////////////////////////////////////////////////
+
+enum TripleSlashProp {
+  TSP_Path,
+  TSP_Types,
+  TSP_Lib,
+  TSP_NoDefaultLib,
+  TSP_NA
+};
 
+class TripleSlashNode : public TreeNode {
+private:
+  TripleSlashProp  mProp;
+  TreeNode *mValue;
+public:
+  TripleSlashNode() : TreeNode(NK_TripleSlash) {mValue = NULL; mProp = TSP_NA;}
+  ~TripleSlashNode() {}
+
+  TreeNode* GetValue() {return mValue;}
+  void SetValue(TreeNode *n) {mValue = n; SETPARENT(n);}
+
+  TripleSlashProp GetProp() {return mProp;}
+  void SetProp(TripleSlashProp p) {mProp = p;}
+
+  void Dump(unsigned);
 };
 
+
 }
 #endif
diff --git a/src/MapleFE/shared/include/ast_attr.h b/src/MapleFE/shared/include/ast_attr.h
index 0678308c2835bc11074831bed84f2d47ac2a8624..326a9444cc24a4896c2dc072172b953776bb96aa 100644
--- a/src/MapleFE/shared/include/ast_attr.h
+++ b/src/MapleFE/shared/include/ast_attr.h
@@ -40,13 +40,16 @@ class AttrNode : public TreeNode {
 private:
   AttrId mId;
 public:
-  AttrNode() {mKind = NK_Attr; mId = ATTR_NA;}
+  AttrNode() : TreeNode(NK_Attr), mId(ATTR_NA) {}
   ~AttrNode(){}
 
   AttrId GetId()          {return mId;}
   void   SetId(AttrId id) {mId = id;}
 };
 
+extern const char* FindAttrKeyword(AttrId id);
+extern AttrId FindAttrId(const char *keyword);
+
 ///////////////////////////////////////////////////////////////////////////////
 //                      AttrPool
 // The size of AttrNode is fixed, so it's good to use MemPool for the storage.
diff --git a/src/MapleFE/shared/include/ast_builder.h b/src/MapleFE/shared/include/ast_builder.h
index 7890fd3c700bb4b29ac8ed8234aef5aeaa0ca56c..74ab70396f1a38e847fe91b4cacc9c21d4dec524 100644
--- a/src/MapleFE/shared/include/ast_builder.h
+++ b/src/MapleFE/shared/include/ast_builder.h
@@ -17,6 +17,7 @@
 #define __AST_BUILDER_HEADER__
 
 #include "ast.h"
+#include "ast_module.h"
 #include "ast_mempool.h"
 
 namespace maplefe {
@@ -49,24 +50,29 @@ class ASTScope;
 
 class ASTBuilder {
 private:
-  bool mTrace;
+  bool        mTrace;
+  ModuleNode *mASTModule;
 
   // The last created node. It will be referenced by the
   // following AddModifier() or other functions.
-  TreeNode               *mLastTreeNode;
+  TreeNode   *mLastTreeNode;
+
+  // Sometimes we call BuildIdentifier() to build an identifier node
+  // from keywords or any reserved words. This is allowed in Typescript.
+  // We save the Name of the keyword for BuildIdentifier().
+  const char *mNameForBuildIdentifier;
 
 public:
   // information for a single action
   unsigned                mActionId;
   std::vector<Param>      mParams;
-  TreePool               *mTreePool;
 
 public:
-  ASTBuilder() : mTreePool(NULL), mTrace(false) {}
+  ASTBuilder(ModuleNode *m) : mASTModule(m), mTrace(false), mLastTreeNode(NULL), mNameForBuildIdentifier(NULL) {}
   ~ASTBuilder() {}
 
   void SetTrace(bool b) {mTrace = b;}
-  void SetTreePool(TreePool *p) {mTreePool = p;}
+  void SetModule(ModuleNode *m) {mASTModule = m;}
 
   void AddParam(Param p) {mParams.push_back(p);}
   void ClearParams() {mParams.clear();}
@@ -74,104 +80,18 @@ public:
 
   // Create Functions for Token
   TreeNode* CreateTokenTreeNode(const Token*);
+  TreeNode* BuildIdentifier(const Token*);
+  TreeNode* BuildIdentifier(const TreeNode*);
 
   TreeNode* Build();
 
-  TreeNode* BuildPackageName();
-
-  TreeNode* BuildSingleTypeImport();
-  TreeNode* BuildAllTypeImport();
-  TreeNode* BuildSingleStaticImport();
-  TreeNode* BuildAllStaticImport();
-  TreeNode* BuildAllImport();
-
-  TreeNode* BuildBlock();
-  TreeNode* AddToBlock();
-  TreeNode* CvtToBlock(TreeNode *tnode);
-
-  TreeNode* BuildUnaryOperation();
-  TreeNode* BuildPostfixOperation();
-  TreeNode* BuildBinaryOperation();
-  TreeNode* BuildCast();
-  TreeNode* BuildParenthesis();
-  TreeNode* BuildLambda();
-
-  TreeNode* BuildDecl();
-  TreeNode* BuildField();
-  TreeNode* BuildVarList();
-
-  TreeNode* AddInitTo();
-  TreeNode* AddTypeTo();
-  TreeNode* AddModifier();
-  TreeNode* AddModifierTo();
-
-  // Callsite
-  TreeNode* AddArguments();
-  TreeNode* BuildCall();
-  TreeNode* BuildExprList();
+#undef  ACTION
+#define ACTION(K) TreeNode* K();
+#include "supported_actions.def"
 
-  // Function related
+  void AddArguments(TreeNode *call, TreeNode *args);
   void AddParams(TreeNode *func, TreeNode *params);
-  TreeNode* AddParams();
-  TreeNode* BuildFunction();
-  TreeNode* BuildConstructor();
-  TreeNode* AddFunctionBody();
-  TreeNode* AddFunctionBodyTo();
-
-  TreeNode* BuildClass();
-  TreeNode* SetClassIsJavaEnum();
-  TreeNode* AddClassBody();
-  TreeNode* AddSuperClass();
-  TreeNode* AddSuperInterface();
-  TreeNode* BuildInstInit();
-
-  // Annotation related
-  TreeNode* BuildAnnotationType();
-  TreeNode* BuildAnnotation();
-  TreeNode* AddAnnotationTypeBody();
-
-  // Interface related
-  TreeNode* BuildInterface();
-  TreeNode* AddInterfaceBody();
-
-  // Dimension Related
-  TreeNode* BuildDim();
-  TreeNode* BuildDims();
-  TreeNode* AddDims();
-  TreeNode* AddDimsTo();
-
-  // Statements, Control Flow
-  TreeNode* BuildAssignment();
-  TreeNode* BuildReturn();
-  TreeNode* BuildCondBranch();
-  TreeNode* AddCondBranchTrueStatement();
-  TreeNode* AddCondBranchFalseStatement();
-  TreeNode* AddLabel();
-  TreeNode* BuildBreak();
-  TreeNode* BuildForLoop();
-  TreeNode* BuildWhileLoop();
-  TreeNode* BuildDoLoop();
-  TreeNode* BuildNewOperation();
-  TreeNode* BuildDeleteOperation();
-  TreeNode* BuildAssert();
-
-  SwitchCaseNode* SwitchLabelToCase(SwitchLabelNode*);
-  TreeNode* BuildSwitchLabel();
-  TreeNode* BuildDefaultSwitchLabel();
-  TreeNode* BuildOneCase();
-  TreeNode* BuildAllCases();
-  TreeNode* BuildSwitch();
-
-  // Exception, throw
-  TreeNode* BuildThrows();
-  TreeNode* AddThrowsTo();
-
-  // User Type related
-  TreeNode* BuildUserType();
-  TreeNode* AddTypeArgument();
 };
 
-// A global builder is good enough.
-extern ASTBuilder gASTBuilder;
 }
 #endif
diff --git a/src/MapleFE/shared/include/ast_fixup.h b/src/MapleFE/shared/include/ast_fixup.h
new file mode 100644
index 0000000000000000000000000000000000000000..af36113470ee6ddd9d5ab4115d554b5a2a1eaeea
--- /dev/null
+++ b/src/MapleFE/shared/include/ast_fixup.h
@@ -0,0 +1,59 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __AST_FIXUP_H__
+#define __AST_FIXUP_H__
+
+#include "ast_module.h"
+#include "ast.h"
+#include "gen_astvisitor.h"
+
+namespace maplefe {
+
+// FixUpVisitor is to fix up some tree nodes after the AST is created
+class FixUpVisitor : public AstVisitor {
+  private:
+    ModuleNode *mASTModule;
+    bool       mUpdated;
+
+  public:
+    FixUpVisitor(ModuleNode *m) : mASTModule(m), mUpdated(false) {}
+
+    bool FixUp();
+
+    // Fix up OprId of a UnaOperatorNode
+    //   OPR_Add              --> OPR_Plus
+    //   OPR_Sub              --> OPR_Minus
+    //   OPR_Inc && !IsPost() --> OPR_PreInc
+    //   OPR_Dec && !IsPost() --> OPR_DecInc
+    //
+    UnaOperatorNode *VisitUnaOperatorNode(UnaOperatorNode *node);
+
+    // Fix up literal boolean 'true' or 'false' as a type
+    UserTypeNode *VisitUserTypeNode(UserTypeNode *node);
+
+    // Fix up the name string of a UserTypeNode
+    // Fix up literal boolean 'true' or 'false'
+    IdentifierNode *VisitIdentifierNode(IdentifierNode *node);
+
+    // Update mFilename of a ModuleNode with a connonical absolute path
+    ModuleNode *VisitModuleNode(ModuleNode *node);
+
+    // Replace a PassNode with a CallNode for tagged template literal
+    PassNode *VisitPassNode(PassNode *node);
+};
+
+}
+#endif
diff --git a/src/MapleFE/shared/include/ast_mempool.h b/src/MapleFE/shared/include/ast_mempool.h
index f9a5c32e4958b1067ffc5b8628a9069cfcff22ef..62db391d1624da5da6d9f04376d5b78268756b54 100644
--- a/src/MapleFE/shared/include/ast_mempool.h
+++ b/src/MapleFE/shared/include/ast_mempool.h
@@ -54,5 +54,6 @@ public:
                     //     is out of the control of mMP.
 };
 
+extern TreePool gTreePool;
 }
 #endif
diff --git a/src/MapleFE/shared/include/ast_module.h b/src/MapleFE/shared/include/ast_module.h
index bc4de35a93412d29ab3afe0697899e677052f15a..58e6b19e1a0289949de47e4911f4ccc071203648 100644
--- a/src/MapleFE/shared/include/ast_module.h
+++ b/src/MapleFE/shared/include/ast_module.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -23,42 +23,74 @@
 
 namespace maplefe {
 
-class ASTTree;
-class ASTScope;
+enum SrcLang {
+  SrcLangUnknown,
+  SrcLangJava,
+  SrcLangJavaScript,
+  SrcLangTypeScript,
+  SrcLangC,
+};
 
 // The module is a member of class Parser.
-class ASTModule {
+class ModuleNode : public TreeNode {
 public:
-  const char              *mFileName;
+  const char              *mFilename;
   PackageNode             *mPackage;
-  SmallVector<ImportNode*> mImports;
 public:
-  std::vector<ASTTree*>  mTrees;  // All trees in the module. There is no root tree
-                                  // which covers all the others.
-                                  // Everything else will be treated as a TreeNode, not a tree,
-                                  // even if it's a local class.
-                                  // Memory is released in ~ASTModule();
+  SmallList<TreeNode*>   mTrees;     // All trees in the module.
   ASTScope              *mRootScope; // the scope corresponding to a module. All other scopes
                                      // are children of mRootScope.
   ASTScopePool           mScopePool; // All the scopes are store in this pool. It also contains
-                                     // a vector of ASTScope pointer for traversal. 
+                                     // a vector of ASTScope pointer for traversal.
+  SrcLang                mSrcLang;
+
+  bool                   mIsAmbient;   // In Typescript there is an ambient module containing
+                                     // only declarations.
 public:
-  ASTModule();
-  ~ASTModule();
+  ModuleNode();
+  ~ModuleNode();
+
+  bool IsAmbient()                 {return mIsAmbient;}
+  void SetIsAmbient(bool b = true) {mIsAmbient = b;}
+
+  void        SetFilename(const char *f) {mFilename = f;}
+  const char *GetFilename() {return mFilename;}
+
+  void         SetPackage(PackageNode *p);
+  PackageNode *GetPackage() {return mPackage;};
 
-  void SetFileName(const char *f) {mFileName = f;}
-  void SetPackage(PackageNode *p);
-  void AddImport(ImportNode *imp) {mImports.PushBack(imp);}
+  void    SetSrcLang(SrcLang l);
+  SrcLang GetSrcLang();
+  std::string GetSrcLangString();
 
-  void AddTree(ASTTree* t) { mTrees.push_back(t); }
+  unsigned  GetTreesNum()       {return mTrees.GetNum();}
+  TreeNode* GetTree(unsigned i) {return mTrees.ValueAtIndex(i);}
+  void SetTree(unsigned i, TreeNode* t)  {*(mTrees.RefAtIndex(i)) = t;}
+  void AddTree(TreeNode* t);
+  void AddTreeFront(TreeNode* t);
+
+  void InsertAfter(TreeNode *new_stmt, TreeNode *exist_stmt) {
+    mTrees.LocateValue(exist_stmt);
+    mTrees.InsertAfter(new_stmt);
+    if(new_stmt) new_stmt->SetParent(this);
+  }
+  void InsertBefore(TreeNode *new_stmt, TreeNode *exist_stmt) {
+    mTrees.LocateValue(exist_stmt);
+    mTrees.InsertBefore(new_stmt);
+    if(new_stmt) new_stmt->SetParent(this);
+  }
+
+  ASTScope* GetRootScope()            {return mRootScope;}
+  void      SetRootScope(ASTScope *s) {mRootScope = s;}
+
+  ASTScopePool& GetScopePool()        {return mScopePool;}
+  void          SetScopePool(ASTScopePool &s) {mScopePool = s;}
 
   ASTScope* NewScope(ASTScope *p);
+  ASTScope* NewScope(ASTScope *p, TreeNode *t);
 
-  void Dump();
+  void Dump(unsigned);
 };
 
-// Assume currently only one global module is being processed.
-extern ASTModule gModule;
-
 }
 #endif
diff --git a/src/MapleFE/shared/include/ast_nk.def b/src/MapleFE/shared/include/ast_nk.def
index 7ce9f893576a8bf8ce4965f593ab37b38c6d246c..091b6931090a7a6a88b7c0b802624032fbf30ddc 100644
--- a/src/MapleFE/shared/include/ast_nk.def
+++ b/src/MapleFE/shared/include/ast_nk.def
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -16,35 +16,86 @@
 // This file defines the AST Node Kind list. It is shared nodes among different languages.
 // Each language can have its own unique set of noke kind list, and be included too.
 
+NODEKIND(Module)
 NODEKIND(Package)
+
+NODEKIND(XXportAsPair)   // JS has: import {x as y}, and export {x as y}
 NODEKIND(Import)
+NODEKIND(Export)
+NODEKIND(Declare)        // c/c++ extern decl, or typescript 'declare'
 
+NODEKIND(Decl)
 NODEKIND(Identifier)
 NODEKIND(Field)
 NODEKIND(Dimension)
 NODEKIND(Attr)
+
+// A pair of <name, type>
+NODEKIND(NameTypePair)
+
+// Type related
 NODEKIND(PrimType)
 NODEKIND(PrimArrayType)
+NODEKIND(ArrayType)
 NODEKIND(UserType)
+NODEKIND(TypeParameter)
+NODEKIND(AsType)
+NODEKIND(TypeAlias)
+NODEKIND(ConditionalType)  // Conditional types in Typescript
+NODEKIND(TupleType)        // tuple types in Typescript
+NODEKIND(FunctionType)
 
+//
 NODEKIND(Cast)
 NODEKIND(Parenthesis)
 
+// For de-structuring syntax, first in JS
+NODEKIND(BindingElement)
+NODEKIND(BindingPattern)
+
+// Struct
+NODEKIND(Struct)
+NODEKIND(StructLiteral)
+NODEKIND(FieldLiteral)
+
+// define two spcial nodes for typescript index signature
+NODEKIND(NumIndexSig)
+NODEKIND(StrIndexSig)
+
+// Typescript, computed name
+NODEKIND(ComputedName)
+
+// Array related
+NODEKIND(ArrayElement)
+NODEKIND(ArrayLiteral)
+
 // VarList is for identifier list only.
 // ExprList is for all kinds of node.
 NODEKIND(VarList)
 NODEKIND(ExprList)
 
+NODEKIND(TemplateLiteral)
+NODEKIND(RegExpr)
+
 NODEKIND(Literal)
 NODEKIND(UnaOperator)
 NODEKIND(BinOperator)
 NODEKIND(TerOperator)
 NODEKIND(Lambda)
+NODEKIND(InstanceOf)
+NODEKIND(TypeOf)
+NODEKIND(KeyOf)
+NODEKIND(In)
+NODEKIND(Is)
+NODEKIND(Infer)
+
+NODEKIND(TripleSlash)  // TS triple-slash directive
 
 NODEKIND(Block)
 NODEKIND(Function)
 NODEKIND(Class)
 NODEKIND(Interface)
+NODEKIND(Namespace)  // First come from Typescript namespace.
 
 // Annotation, Pragma in c/c++, has no effects for execution, but has meanings
 // for compiler or runtime.
@@ -55,13 +106,23 @@ NODEKIND(Interface)
 NODEKIND(AnnotationType)
 NODEKIND(Annotation)
 
+NODEKIND(Try)
+NODEKIND(Catch)
+NODEKIND(Finally)
 NODEKIND(Exception)
 
+// This is for the throw statement. Not the "exceptions thrown by functions".
+NODEKIND(Throw)
+
+NODEKIND(Await)
+
 // These are statement nodes, or control flow related nodes. They are
 // common in most languages.
 NODEKIND(Return)
+NODEKIND(Yield)
 NODEKIND(CondBranch)
 NODEKIND(Break)
+NODEKIND(Continue)
 NODEKIND(ForLoop)
 NODEKIND(WhileLoop)
 NODEKIND(DoLoop)
diff --git a/src/MapleFE/shared/include/ast_scope.h b/src/MapleFE/shared/include/ast_scope.h
index c74c2f2c52ac9a34e6a86602b6c8506411724dd1..088072c362f6c492203110f4d0689223a2281428 100644
--- a/src/MapleFE/shared/include/ast_scope.h
+++ b/src/MapleFE/shared/include/ast_scope.h
@@ -40,7 +40,7 @@ private:
   // tree with it. It actually related to the module. Local scope always
   // has a local TreeNode with it.
   TreeNode *mTree;
- 
+
   SmallVector<ASTScope*> mChildren;
 
   // Local User types like local class,etc.
@@ -51,33 +51,53 @@ private:
   // So TreeNode is the only choice for it.
   SmallVector<TreeNode*> mDecls;
 
+  // Imported Decles
+  SmallVector<TreeNode*> mImportedDecls;
+
+  // Exported Decles
+  SmallVector<TreeNode*> mExportedDecls;
+
 public:
   ASTScope() : mParent(NULL), mTree(NULL) {}
-  ASTScope(ASTScope *p);
+  ASTScope(ASTScope *p) : mTree(NULL) { SetParent(p); }
+  ASTScope(ASTScope *p, TreeNode *t)  { SetParent(p); SetTree(t); }
   ~ASTScope() {Release();}
 
   // It's the caller's duty to make sure p is not NULL
-  void SetParent(ASTScope *p) {mParent = p; p->AddChild(this);}
+  void SetParent(ASTScope *p) {mParent = p; if(p) p->AddChild(this);}
   ASTScope* GetParent() {return mParent;}
 
   TreeNode* GetTree() {return mTree;}
-  void SetTree(TreeNode* t) {mTree = t;}
+  void SetTree(TreeNode* t) {mTree = t; if(t) t->SetScope(this);}
 
   void AddChild(ASTScope*);
 
+  unsigned GetChildrenNum() {return mChildren.GetNum();}
   unsigned GetDeclNum() {return mDecls.GetNum();}
+  unsigned GetImportedDeclNum() {return mImportedDecls.GetNum();}
+  unsigned GetExportedDeclNum() {return mExportedDecls.GetNum();}
   unsigned GetTypeNum() {return mTypes.GetNum();}
+  ASTScope* GetChild(unsigned i) {return mChildren.ValueAtIndex(i);}
   TreeNode* GetDecl(unsigned i) {return mDecls.ValueAtIndex(i);}
+  TreeNode* GetImportedDecl(unsigned i) {return mImportedDecls.ValueAtIndex(i);}
+  TreeNode* GetExportedDecl(unsigned i) {return mExportedDecls.ValueAtIndex(i);}
   TreeNode* GetType(unsigned i) {return mTypes.ValueAtIndex(i);}
 
-  TreeNode* FindDeclOf(IdentifierNode*);
-  TreeNode* FindTypeOf(IdentifierNode*);
+  TreeNode* FindDeclOf(unsigned stridx, bool deep = true);
+  TreeNode* FindExportedDeclOf(unsigned stridx);
+  TreeNode* FindTypeOf(unsigned stridx);
 
   void AddDecl(TreeNode *n) {mDecls.PushBack(n);}
+  void AddImportDecl(TreeNode *n) {mImportedDecls.PushBack(n);}
+  void AddExportDecl(TreeNode *n) {mExportedDecls.PushBack(n);}
   void AddType(TreeNode *n) {mTypes.PushBack(n);}
   void TryAddDecl(TreeNode *n);
   void TryAddType(TreeNode *n);
 
+  bool IsAncestor(ASTScope *ancestor);
+
+  void Dump(unsigned indent = 0);
+
   virtual void Release();
 };
 
@@ -94,7 +114,7 @@ private:
 public:
   ASTScopePool() {}
   ~ASTScopePool();
-  
+
   ASTScope* NewScope(ASTScope *parent);
 };
 
diff --git a/src/MapleFE/shared/include/ast_type.h b/src/MapleFE/shared/include/ast_type.h
index 66c0b296680a5e7ee38ac468a7684b630aa0c3b8..0f4afe5ee73d61dff5d91d629ab2d40b51d7d471 100644
--- a/src/MapleFE/shared/include/ast_type.h
+++ b/src/MapleFE/shared/include/ast_type.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -36,21 +36,20 @@
 // Right now, I just let each instance represent a separate type, and will
 // come back to this.
 //
-// So we a TreeNode of the type identifier can be a type, and we don't have
-// to give any special data struct for it. A user type is created as a treenode
-// (IdentifierNode) at the beginning, but later we will do consolidation,
-// and it may be turned into a function, struct, etc. So a TreeNode is good here.
-//
-//
 // We define 3 different types.
 // 1. UserType
 //    It's an identifier which defines a class, interface, struct, etc.
+//    It also includes DimensionNode to tell if it's array.
 // 2. PrimType
 //    This is coming from language's type keyword which are primitive types.
 //    PrimType-s have limited number, and we pre-created AST nodes for them.
 //    All same prim type nodes are pointing to the same one.
 // 3. PrimArrayType
 //    This is a special case. e.g. int[]
+//
+// The reason we split primary types into PrimType and PrimArrayType is to
+// share the same PrimType since they can be predefined in the Prim Pool.
+//
 //////////////////////////////////////////////////////////////////////////
 
 #ifndef __AST_TYPE_H__
@@ -65,32 +64,130 @@ namespace maplefe {
 
 ///////////////////////////////////////////////////////////////////////////////
 //                          UserTypeNode
+// User type is complicated in Typescript. It could a union or intersection
+// of other types.
 ///////////////////////////////////////////////////////////////////////////////
 
+enum UT_Type {
+  UT_Regular, // the normal user type, it could be just a name.
+  UT_Union,   // Union of two other types.
+  UT_Inter,   // Intersection of other types.
+};
+
 class UserTypeNode : public TreeNode {
 private:
-  IdentifierNode *mId;
-  SmallVector<IdentifierNode*> mTypeArguments;
+  // A regular UT always has an Id (or name), or lambda, etc.
+  // A union or intersection UT may or may not have an ID.
+  TreeNode *mId;
+
+  UT_Type   mType;
+  DimensionNode *mDims;
+
+  // the set of types in union or intersection.
+  SmallVector<TreeNode*> mUnionInterTypes;
+
+  // There are two scenarios type generic info are used.
+  // 1. It's a type argument
+  // 2. It's a type parameter. Type parameter may have default value.
+  SmallVector<TreeNode*> mTypeGenerics;
+
+  SmallVector<AttrId> mAttrs;
+
 public:
-  UserTypeNode() : mId(NULL) {mKind = NK_UserType;}
-  UserTypeNode(IdentifierNode *n) : mId(n) {mKind = NK_UserType;}
+  UserTypeNode(TreeNode *n) : TreeNode(NK_UserType),
+    mId(n), mType(UT_Regular), mDims(NULL) { SETPARENT(n); }
+  UserTypeNode() : UserTypeNode(NULL) {}
   ~UserTypeNode(){Release();}
 
-  IdentifierNode* GetId() {return mId;}
-  void SetId(IdentifierNode *n) {mId = n;}
+  TreeNode* GetId() {return mId;}
+  void SetId(TreeNode *n) {mId = n; SETPARENT(n);}
 
-  const char* GetName() {return mId->GetName();}
+  unsigned  GetUnionInterTypesNum()                    {return mUnionInterTypes.GetNum();}
+  void      AddUnionInterType(TreeNode *n, bool front = false);
+  TreeNode* GetUnionInterType(unsigned i)              {return mUnionInterTypes.ValueAtIndex(i);}
+  void      SetUnionInterType(unsigned i, TreeNode* n) {*(mUnionInterTypes.RefAtIndex(i)) = n; SETPARENT(n);}
 
-  unsigned TypeArgsNum() {return mTypeArguments.GetNum();}
-  void     AddTypeArg(IdentifierNode *n) {mTypeArguments.PushBack(n);}
-  void     AddTypeArgs(TreeNode *n);
+  unsigned  GetTypeGenericsNum()                    {return mTypeGenerics.GetNum();}
+  void      AddTypeGeneric(TreeNode *n);
+  TreeNode* GetTypeGeneric(unsigned i)              {return mTypeGenerics.ValueAtIndex(i);}
+  void      SetTypeGeneric(unsigned i, TreeNode* n) {*(mTypeGenerics.RefAtIndex(i)) = n; SETPARENT(n);}
+
+  UT_Type GetType() {return mType;}
+  void SetType(UT_Type t) {mType = t;}
+
+  DimensionNode* GetDims()       {return mDims;}
+  void SetDims(DimensionNode *d) {mDims = d;}
+
+  unsigned GetDimsNum()          {return mDims->GetDimensionsNum();}
+  bool     IsArray()             {return mDims && GetDimsNum() > 0;}
+  void     AddDim(unsigned i = 0){mDims->AddDimension(i);}        // 0 means unspecified
+  unsigned GetNthNum(unsigned n) {return mDims->GetDimension(n);} // 0 means unspecified.
+  void     SetNthNum(unsigned n, unsigned i) {mDims->SetDimension(n, i);}
+
+  // Attributes related
+  unsigned GetAttrsNum() const        {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
 
   bool TypeEquivalent(UserTypeNode *);
 
-  void Release() {mTypeArguments.Release();}
+  void Release() {mTypeGenerics.Release(); mUnionInterTypes.Release();}
   void Dump(unsigned);
 };
 
+///////////////////////////////////////////////////////////////////////////////
+//                          ArrayTypeNode
+// It is used to specify Array types, including element type and dimensions
+///////////////////////////////////////////////////////////////////////////////
+
+class ArrayTypeNode : public TreeNode {
+private:
+  TreeNode      *mElemType;
+  DimensionNode *mDims;
+  SmallVector<AttrId> mAttrs;
+
+public:
+  ArrayTypeNode() : TreeNode(NK_ArrayType), mElemType(NULL), mDims(NULL) {}
+  ~ArrayTypeNode(){}
+
+  void SetElemType(TreeNode *n)  {mElemType = n; SETPARENT(n);}
+  void SetDims(DimensionNode *d) {mDims = d; SETPARENT(d);}
+  TreeNode*  GetElemType()       {return mElemType;}
+  DimensionNode* GetDims()       {return mDims;}
+
+  // Attributes related
+  unsigned GetAttrsNum() const        {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
+
+  void Dump(unsigned);
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//                          FunctionTypeNode
+// It is used to specify function types with its parameters and return type
+///////////////////////////////////////////////////////////////////////////////
+class FunctionTypeNode : public TreeNode {
+private:
+  SmallVector<unsigned>        mParams;     // type index of formal parameters
+                                            // and return which is the last one
+
+public:
+  FunctionTypeNode() : TreeNode(NK_FunctionType) {}
+  ~FunctionTypeNode(){}
+
+  unsigned GetParamsNum()         {return mParams.GetNum();}
+  unsigned GetParam(unsigned i)   {return mParams.ValueAtIndex(i);}
+  void     SetParam(unsigned i, unsigned n) {*(mParams.RefAtIndex(i)) = n;}
+  void     AddParam(unsigned i)   {mParams.PushBack(i);}
+  void     ClearParam()           {mParams.Clear();}
+
+  bool     IsEqual(FunctionTypeNode *f);
+  void     Dump(unsigned);
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 //                          PrimTypeNode & PrimTypePool
 // The size of PrimTypeNode is fixed, so it's good to use container for the storage.
@@ -100,13 +197,18 @@ public:
 class PrimTypeNode : public TreeNode {
 private:
   TypeId    mPrimType; // primitive type
+  bool      mIsUnique; // This is specifically for TS "unique symbol". TS creates many
+                       // opaque syntax.
 public:
-  PrimTypeNode() {mKind = NK_PrimType;}
+  PrimTypeNode() : TreeNode(NK_PrimType), mIsUnique(false) {}
   ~PrimTypeNode(){}
 
+  bool IsUnique()                 {return mIsUnique;}
+  void SetIsUnique(bool b = true) {mIsUnique = b;}
+
   TypeId    GetPrimType()     {return mPrimType;}
   void SetPrimType(TypeId id) {mPrimType = id; }
-  const char* GetName();  // type name
+  const char* GetTypeName();  // type name
 
   void Dump(unsigned);
 };
@@ -115,29 +217,34 @@ class PrimArrayTypeNode : public TreeNode {
 private:
   PrimTypeNode  *mPrim;
   DimensionNode *mDims;
+  SmallVector<AttrId> mAttrs;
+
 public:
-  PrimArrayTypeNode() : mPrim(NULL), mDims(NULL) {mKind = NK_PrimArrayType;}
+  PrimArrayTypeNode() : TreeNode(NK_PrimArrayType), mPrim(NULL), mDims(NULL) {}
   ~PrimArrayTypeNode(){}
 
-  void SetPrim(PrimTypeNode *p) {mPrim = p;}
-  void SetDims(DimensionNode *d) {mDims = d;}
+  void SetPrim(PrimTypeNode *p) {mPrim = p; SETPARENT(p);}
+  void SetDims(DimensionNode *d) {mDims = d; SETPARENT(d);}
   PrimTypeNode*  GetPrim() {return mPrim;}
   DimensionNode* GetDims(){return mDims;}
 
+  // Attributes related
+  unsigned GetAttrsNum() const        {return mAttrs.GetNum();}
+  void     AddAttr(AttrId a)          {mAttrs.PushBack(a);}
+  AttrId   GetAttrAtIndex(unsigned i) {return mAttrs.ValueAtIndex(i);}
+  void     SetAttrAtIndex(unsigned i, AttrId n) {*(mAttrs.RefAtIndex(i)) = n;}
+
   void Dump(unsigned);
 };
 
 class PrimTypePool {
 private:
-  TreePool                   mTreePool;
   SmallVector<PrimTypeNode*> mTypes;
-
-  void Init();
-
 public:
   PrimTypePool();
   ~PrimTypePool();
 
+  void Init();
   PrimTypeNode* FindType(const char *keyword);
   PrimTypeNode* FindType(TypeId id);
 };
diff --git a/src/MapleFE/shared/include/comment.h b/src/MapleFE/shared/include/comment.h
index a468e1050557464db7c7f6ff1b223ec4c363daf2..d0ee240ad04a1104eb8a441438c1cefe1f28fc29 100644
--- a/src/MapleFE/shared/include/comment.h
+++ b/src/MapleFE/shared/include/comment.h
@@ -21,7 +21,7 @@
 //                        |-->literals
 //                        |-->separators
 //                        |-->operators
-// 
+//
 // This categorization is shared among all languages. [NOTE] If anything
 // in a new language is exceptional, please add to this.
 //
@@ -36,7 +36,7 @@
 
 namespace maplefe {
 
-typedef enum {
+typedef enum COMM_Type {
   COMM_EOL,   //End of Line, //
   COMM_TRA    //Traditional, /* ... */
 }COMM_Type;
@@ -46,7 +46,7 @@ private:
   COMM_Type CommType;
 public:
   Comment(COMM_Type ct) : CommType(ct) {EType = ET_CM;}
-  
+
   bool IsEndOfLine()   {return CommType == COMM_EOL;}
   bool IsTraditional() {return CommType == COMM_TRA;}
 };
diff --git a/src/MapleFE/shared/include/common_header_autogen.h b/src/MapleFE/shared/include/common_header_autogen.h
index febf115539c59beeaf07f53a8b18f414cf3e1a5e..221b853d73d383f0147b0ce9c8a90358a84e1f8f 100644
--- a/src/MapleFE/shared/include/common_header_autogen.h
+++ b/src/MapleFE/shared/include/common_header_autogen.h
@@ -27,12 +27,9 @@
 #include "gen_literal.h"
 #include "gen_iden.h"
 #include "gen_type.h"
-#include "gen_expr.h"
 #include "gen_stmt.h"
-#include "gen_block.h"
 #include "gen_separator.h"
 #include "gen_operator.h"
 #include "gen_keyword.h"
-#include "gen_summary.h"
 
 #endif
diff --git a/src/MapleFE/shared/include/container.h b/src/MapleFE/shared/include/container.h
index 4859a7af047fd098ba2fcae063dde1fc64e1e159..828a8379e00034339b1eeca24fbc55045b9a79f9 100644
--- a/src/MapleFE/shared/include/container.h
+++ b/src/MapleFE/shared/include/container.h
@@ -1,5 +1,6 @@
 /*
 * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) 2022 Tencent. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -32,8 +33,11 @@
 #ifndef __CONTAINER_H__
 #define __CONTAINER_H__
 
+#include <type_traits>
+#include <unordered_map>
 #include "mempool.h"
 #include "massert.h"
+#include "macros.h"
 
 namespace maplefe {
 
@@ -45,9 +49,13 @@ namespace maplefe {
 class ContainerMemPool : public MemPool {
 public:
   unsigned mElemSize;
+  unsigned mElemNumPerBlock;
 public:
+  ContainerMemPool() : mElemSize(1) {}
+
+  void  SetBlockSize(unsigned i) {mBlockSize = i; mElemNumPerBlock = mBlockSize / mElemSize;}
   char* AddrOfIndex(unsigned index);
-  void  SetElemSize(unsigned i) {mElemSize = i;}
+  void  SetElemSize(unsigned i) {mElemSize = i; mElemNumPerBlock = mBlockSize/mElemSize;}
   char* AllocElem() {return Alloc(mElemSize);}
 };
 
@@ -77,7 +85,10 @@ public:
 
   void PushBack(T t) {
     char *addr = mMemPool.AllocElem();
-    *(T*)addr = t;
+    if(std::is_class<T>::value)
+      new (addr) T(t);
+    else
+      *(T*)addr = t;
     mNum++;
   }
 
@@ -107,7 +118,10 @@ public:
   // It's the caller's duty to make sure ith element is valid.
   void SetElem(unsigned i, T t) {
     char *addr = mMemPool.AddrOfIndex(i);
-    *(T*)addr = t;
+    if(std::is_class<T>::value)
+      new (addr) T(t);
+    else
+      *(T*)addr = t;
   }
 
   bool Find(T t) {
@@ -472,7 +486,7 @@ private:
   //   Add more elements, on the knob.
   // This is common scenario. To implement, it requires a temporary
   // pointer to the located knob. This temp knob is used ONLY when
-  // paired operations, PairedFindOrCreateKnob() and PairedAddElem() 
+  // paired operations, PairedFindOrCreateKnob() and PairedAddElem()
   Knob *mTempKnob;
 
 private:
@@ -765,6 +779,338 @@ public:
   }
 };
 
+////////////////////////////////////////////////////////////////////////
+// GuamianFast uses unordered map to store the Knob-s in order to
+// speed up the searching with big number of data.
+////////////////////////////////////////////////////////////////////////
+
+template <class K = unsigned, class D = unsigned, class E = unsigned> class GuamianFast {
+private:
+  struct Elem{
+    E     mData;
+    Elem *mNext;
+  };
+
+  // Sometimes people need save certain additional information to
+  // each knob. So we define mData.
+  struct Knob{
+    D        mData;
+    Elem    *mChildren; // pointing to the first child
+  };
+
+  MemPool mMemPool;
+  std::unordered_map<K, Knob*> mKnobs;
+
+  // allocate a new knob
+  Knob* NewKnob() {
+    Knob *knob = (Knob*)mMemPool.Alloc(sizeof(Knob));
+    knob->mData = 0;
+    knob->mChildren = NULL;
+    return knob;
+  }
+
+  // allocate a new element
+  Elem* NewElem() {
+    Elem *elem = (Elem*)mMemPool.Alloc(sizeof(Elem));
+    elem->mNext = NULL;
+    elem->mData = 0;
+    return elem;
+  }
+
+  // Sometimes people want to have a sequence of operations like,
+  //   Get the knob,
+  //   Add one element, on the knob
+  //   Add more elements, on the knob.
+  // This is common scenario. To implement, it requires a temporary
+  // pointer to the located knob. This temp knob is used ONLY when
+  // paired operations, PairedFindOrCreateKnob() and PairedAddElem()
+  struct {
+    Knob *mKnob;
+    K     mKey;
+  }mTempKnob;
+
+private:
+  // Just try to find the Knob.
+  // return NULL if fails.
+  Knob* FindKnob(K key) {
+    Knob *result = NULL;
+    auto search = mKnobs.find(key);
+    if (search != mKnobs.end())
+      result = search->second;
+    return result;
+  }
+
+  // Try to find the Knob. Create one if failed.
+  Knob* FindOrCreateKnob(K key) {
+    Knob *knob = FindKnob(key);
+    if (!knob) {
+      knob = NewKnob();
+      mKnobs.insert(std::make_pair(key, knob));
+    }
+    return knob;
+  }
+
+  // Add an element to knob. It's the caller's duty to assure
+  // knob is not NULL.
+  void AddElem(Knob *knob, E data) {
+    Elem *elem = knob->mChildren;
+    Elem *found = NULL;
+    while (elem) {
+      if (elem->mData == data) {
+        found = elem;
+        break;
+      }
+      elem = elem->mNext;
+    }
+
+    if (!found) {
+      Elem *e = NewElem();
+      e->mData = data;
+      e->mNext = knob->mChildren;
+      knob->mChildren = e;
+    }
+  }
+
+  // return true : if find the element
+  //       false : if fail
+  bool FindElem(Knob *knob, E data) {
+    Elem *elem = knob->mChildren;
+    while (elem) {
+      if (elem->mData == data)
+        return true;
+      elem = elem->mNext;
+    }
+    return false;
+  }
+
+  // Remove elem from the list. If elem doesn't exist, exit quietly.
+  // It's caller's duty to assure elem exists.
+  void RemoveElem(Knob *knob, E data) {
+    Elem *elem = knob->mChildren;
+    Elem *elem_prev = NULL;
+    Elem *target = NULL;
+    while (elem) {
+      if (elem->mData == data) {
+        target = elem;
+        break;
+      }
+      elem_prev = elem;
+      elem = elem->mNext;
+    }
+
+    if (target) {
+      if (target == knob->mChildren)
+        knob->mChildren = target->mNext;
+      else
+        elem_prev->mNext = target->mNext;
+    }
+  }
+
+  // Move the element to be the first child  of knob.
+  // It's the caller's duty to make sure 'data' does exist
+  // in knob's children.
+  void MoveElemToHead(Knob *knob, E data) {
+    Elem *target_elem = NULL;
+    Elem *elem = knob->mChildren;
+    Elem *elem_prev = NULL;
+    while (elem) {
+      if (elem->mData == data) {
+        target_elem = elem;
+        break;
+      }
+      elem_prev = elem;
+      elem = elem->mNext;
+    }
+
+    if (target_elem && (target_elem != knob->mChildren)) {
+      elem_prev->mNext = target_elem->mNext;
+      target_elem->mNext = knob->mChildren;
+      knob->mChildren = target_elem;
+    }
+  }
+
+  // Try to find the first child of Knob k. Return the data.
+  // found is set to false if fails, or true.
+  // [NOTE] It's the user's responsibilty to make sure the Knob
+  //        of 'key' exists.
+  E FindFirstElem(Knob *knob, bool &found) {
+    Elem *e = knob->mChildren;
+    if (!e) {
+      found = false;
+      return 0;
+    }
+    found = true;
+    return e->mData;
+  }
+
+  // return num of elements in knob.
+  // It's caller's duty to assure knob is not NULL.
+  unsigned NumOfElem(Knob *knob) {
+    Elem *e = knob->mChildren;
+    unsigned c = 0;
+    while(e) {
+      c++;
+      e = e->mNext;
+    }
+    return c;
+  }
+
+  // Return the idx-th element in knob.
+  // It's caller's duty to assure the validity of return value.
+  // It doesn't check validity here.
+  // Index starts from 0.
+  E GetElemAtIndex(Knob *knob, unsigned idx) {
+    Elem *e = knob->mChildren;
+    unsigned c = 0;
+    E data;
+    while(e) {
+      if (c == idx) {
+        data = e->mData;
+        break;
+      }
+      c++;
+      e = e->mNext;
+    }
+    return data;
+  }
+
+public:
+  GuamianFast() {mTempKnob.mKnob = NULL;}
+  ~GuamianFast(){Release();}
+
+  void AddElem(K key, E data) {
+    Knob *knob = FindOrCreateKnob(key);
+    AddElem(knob, data);
+  }
+
+  // If 'data' doesn't exist, it ends quietly
+  void RemoveElem(K key, E data) {
+    Knob *knob = FindOrCreateKnob(key);
+    RemoveElem(knob, data);
+  }
+
+  // Try to find the first child of Knob k. Return the data.
+  // found is set to false if fails, or true.
+  // [NOTE] It's the user's responsibilty to make sure the Knob
+  //        of 'key' exists.
+  E FindFirstElem(K key, bool &found) {
+    Knob *knob = FindKnob(key);
+    if (!knob) {
+      found = false;
+      return 0;   // return value doesn't matter when fails.
+    }
+    E data = FindFirstElem(knob, found);
+    return data;
+  }
+
+  // return true : if find the element
+  //       false : if fail
+  bool FindElem(K key, E data) {
+    Knob *knob = FindKnob(key);
+    if (!knob)
+      return false;
+    return FindElem(knob, data);
+  }
+
+  // Move element to be the header
+  // If 'data' doesn't exist, it ends quietly.
+  void MoveElemToHead(K key, E data) {
+    Knob *knob = FindKnob(key);
+    if (!knob)
+      return;
+    MoveElemToHead(knob, data);
+  }
+
+  /////////////////////////////////////////////////////////
+  // Paired operations start with finding a knob. It can
+  // be either PairedFindKnob() or PairedFindOrCreateKnob()
+  // Following that, there could be any number of operations
+  // like searching, adding, moving an element.
+  /////////////////////////////////////////////////////////
+
+  void PairedFindOrCreateKnob(K key) {
+    mTempKnob.mKnob = FindOrCreateKnob(key);
+    mTempKnob.mKey = key;
+  }
+
+  bool PairedFindKnob(K key) {
+    mTempKnob.mKnob = FindKnob(key);
+    mTempKnob.mKey = key;
+    if (mTempKnob.mKnob)
+      return true;
+    else
+      return false;
+  }
+
+  void PairedAddElem(E data) {
+    AddElem(mTempKnob.mKnob, data);
+  }
+
+  // If 'data' doesn't exist, it ends quietly
+  void PairedRemoveElem(E data) {
+    RemoveElem(mTempKnob.mKnob, data);
+  }
+
+  bool PairedFindElem(E data) {
+    return FindElem(mTempKnob.mKnob, data);
+  }
+
+  // If 'data' doesn't exist, it ends quietly.
+  void PairedMoveElemToHead(E data) {
+    MoveElemToHead(mTempKnob.mKnob, data);
+  }
+
+  E PairedFindFirstElem(bool &found) {
+    return FindFirstElem(mTempKnob.mKnob, found);
+  }
+
+  // return num of elements in current temp knob.
+  // It's caller's duty to assure knob is not NULL.
+  unsigned PairedNumOfElem() {
+    return NumOfElem(mTempKnob.mKnob);
+  }
+
+  // Return the idx-th element in knob.
+  // It's caller's duty to assure the validity of return value.
+  // It doesn't check validity here.
+  // Index starts from 0.
+  E PairedGetElemAtIndex(unsigned idx) {
+    return GetElemAtIndex(mTempKnob.mKnob, idx);
+  }
+
+  // Reduce the element at index exc_idx.
+  // It's caller's duty to assure the element exists.
+  void PairedReduceElems(unsigned exc_idx) {
+    ReduceElems(mTempKnob.mKnob, exc_idx);
+  }
+
+  void PairedSetKnobData(D d) {
+    mTempKnob.mKnob->mData = d;
+  }
+
+  D PairedGetKnobData() {
+    return mTempKnob.mKnob->mData;
+  }
+
+  K PairedGetKnobKey() {
+    return mTempKnob.mKey;
+  }
+
+  /////////////////////////////////////////////////////////
+  //                 Other functions
+  /////////////////////////////////////////////////////////
+
+  void Clear(){
+    mTempKnob.mKnob = NULL;
+    mKnobs.clear();
+    mMemPool.Clear();
+  }
+
+  void Release(){
+    mMemPool.Release();
+  }
+};
+
 //////////////////////////////////////////////////////////////////////////////////////
 //                                 Tree
 // This is a regular tree. It simply maintains the basic operations of a tree, like
@@ -779,7 +1125,7 @@ public:
 
 // We first give each node certain children. If it needs more, an allocation from
 // memory pool is needed.
-#define TREE_MAX_CHILDREN_NUM 12
+#define TREE_MAX_CHILDREN_NUM 20
 #define TREE_CHILDREN_NUM     4
 
 template<class T> class ContTreeNode {
@@ -916,5 +1262,29 @@ public:
   }
 };
 
+/////////////////////////////////////////////////////////////////////////////
+//                         Bit Vector
+/////////////////////////////////////////////////////////////////////////////
+
+class BitVector : public MemPool {
+private:
+  unsigned mBVSize;         // number of bits
+  char* GetAddr(unsigned);  // return the address of bit
+public:
+  BitVector();
+  BitVector(unsigned);
+  ~BitVector(){}
+
+  void ClearAll() {WipeOff();}
+  void ClearBit(unsigned);
+  void SetBit(unsigned);
+  bool GetBit(unsigned);
+  void SetBVSize(unsigned i) {mBVSize = i;}
+  unsigned GetBVSize() {return mBVSize;}
+  bool Equal(BitVector *bv);
+  void And(BitVector *bv);
+  void Or(BitVector *bv);
+};
+
 }
 #endif
diff --git a/src/MapleFE/shared/include/diagnose.h b/src/MapleFE/shared/include/diagnose.h
index a554325c11e705e317739040ebb29f84c6b4318b..5f769bc9621a18e37320e1e49cb27b8d0831d635 100644
--- a/src/MapleFE/shared/include/diagnose.h
+++ b/src/MapleFE/shared/include/diagnose.h
@@ -31,7 +31,7 @@ public:
   unsigned Col;
   char     Msg[256];
 public:
-  DiagMessage(const char*, unsigned, unsigned, const char*); 
+  DiagMessage(const char*, unsigned, unsigned, const char*);
 }
 
 // We save OBJECT not POINTER of DiagMessage in Diagnose.
diff --git a/src/MapleFE/shared/include/element.h b/src/MapleFE/shared/include/element.h
index be10ef628f11f42fa58b495c8891261e60ca1cde..27b68a46e0c4cb3da2cc168de1c33498bdad356f 100644
--- a/src/MapleFE/shared/include/element.h
+++ b/src/MapleFE/shared/include/element.h
@@ -33,7 +33,7 @@
 
 namespace maplefe {
 
-typedef enum {
+typedef enum ELMT_Type {
   ET_WS,    // White Space
   ET_CM,    // Comment
   ET_TK,    // Token
diff --git a/src/MapleFE/shared/include/fileread.h b/src/MapleFE/shared/include/fileread.h
index dd106348fd3d9e18a5952bdb41f04dd87c449694..e71d2ba6cadf296303e9c9d1b0098be096f77c42 100644
--- a/src/MapleFE/shared/include/fileread.h
+++ b/src/MapleFE/shared/include/fileread.h
@@ -49,7 +49,7 @@ public:
 
   void   MoveCursor(int i) {mCurChar += i; mPos += i;} // i can be <0.
   void   MoveToEndOfLine() {mPos = mCurLine.size();}
-  bool   MoveUntil(const char*);   
+  bool   MoveUntil(const char*);
 
   bool   Good() { return mDefFile.good(); }
   bool   EndOfLine() {return mPos == mCurLine.size();}
diff --git a/src/MapleFE/shared/include/lexer.h b/src/MapleFE/shared/include/lexer.h
index 4dfd0e1abc052b006f5856f9ad3e247c8614812d..00a3f708629d9e8e8d347b56e6e942b241c768fb 100644
--- a/src/MapleFE/shared/include/lexer.h
+++ b/src/MapleFE/shared/include/lexer.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -46,6 +46,7 @@ public:
   TokenPool  mTokenPool;
   unsigned   mPredefinedTokenNum;   // number of predefined tokens.
   bool       mTrace;
+  bool       mLineMode;             // Lex just one line
 
 public:
   FILE *srcfile;
@@ -54,6 +55,7 @@ public:
   ssize_t current_line_size;
   uint32_t curidx;
   uint32_t _linenum;
+  uint32_t _total_linenum;  // total line number of the file
   bool endoffile;
   int ReadALine();  // read a line from def file.
 
@@ -73,7 +75,11 @@ public:
     }
   }
 
-  void SetTrace() {mTrace = true;}
+  void SetTrace()     {mTrace = true;}
+  bool GetTrace()     {return mTrace;}
+
+  void SetLineMode()  {mLineMode = true;}
+  void ResetLineMode(){mLineMode = false;}
 
   bool EndOfLine() { return curidx == current_line_size; }
   bool EndOfFile() { return endoffile; }
@@ -81,7 +87,7 @@ public:
   void ResetPos();
 
   void PrepareForFile(const std::string filename);
-  void PrepareForString(const std::string &src);
+  void PrepareForString(const char *);
 
   int GetCuridx() const { return curidx; }
   void SetCuridx(int i) { curidx = i; }
@@ -98,6 +104,11 @@ public:
 
   friend class Parser;
 
+  // These two functions are both due to weird literal or template literal
+  // in script language which allows \n directly in their literals.
+  void ClearLeadingNewLine(); // clear the leading \n in line.
+  void AddEndingNewLine();    // add the ending \n in a line.
+
   // These are for autogen table testing
   Token* LexToken();  // always return token until end of file.
   Token* LexTokenNoNewLine(); // try to get token untile end of line.
@@ -108,24 +119,29 @@ public:
   //           They won't move 'curidx' if target is not hit.
   ///////////////////////////////////////////////////////////////////////////////////
 
-  SepId       GetSeparator();
-  OprId       GetOperator();
-  LitData     GetLiteral();
-  const char* GetKeyword();
-  const char* GetIdentifier();
-  bool        GetComment();
+  SepId        GetSeparator();
+  OprId        GetOperator();
+  LitData      GetLiteral();
+  const char*  GetKeyword();
+  const char*  GetIdentifier();
+  bool         GetComment();
+
+  Token* FindRegExprToken();
+
+  // For most languages, this does nothing. TS/JS are doing something.
+  virtual bool CharIsSeparator(const char c) {return false;}
+
+  virtual TempLitData* GetTempLit() {return NULL;}
+  virtual bool FindNextTLFormat(unsigned start, std::string& s, unsigned& end) {return false;}
+  virtual bool FindNextTLPlaceHolder(unsigned start, std::string& s, unsigned& end) {return false;}
+
+  virtual bool FindTripleSlash() {return false;}
 
   // replace keyword/opr/sep... with tokens
   //void PlantTokens();
   //void PlantTraverseRuleTable(RuleTable*);
   //void PlantTraverseTableData(TableData*);
 
-  //
-  Token* FindSeparatorToken(SepId id);
-  Token* FindOperatorToken(OprId id);
-  Token* FindKeywordToken(const char *key);
-  Token* FindCommentToken();
-
   // When we start walk a rule table to find a token, do we need check if
   // the following data is a separator?
   bool mCheckSeparator;
diff --git a/src/MapleFE/shared/include/log.h b/src/MapleFE/shared/include/log.h
index 9e5cb2f8aab714adfd4c7a53f94111f2950a55b3..1130cfc96091d4d06010da5dbb6f10fcf70ba8a7 100644
--- a/src/MapleFE/shared/include/log.h
+++ b/src/MapleFE/shared/include/log.h
@@ -13,7 +13,7 @@
 * See the Mulan PSL v2 for more details.
 */
 /////////////////////////////////////////////////////////////////////
-// Log file 
+// Log file
 //
 /////////////////////////////////////////////////////////////////////
 
@@ -34,7 +34,7 @@ private:
   std::ofstream mFile;
 
 public:
-  typedef enum {
+  typedef enum Level {
     LOG_NONE,
     LOG_DEBUG,
     LOG_INFO,
@@ -42,10 +42,10 @@ public:
     LOG_ERROR,
     LOG_FATAL
   }Level;
-  
+
   Log() {mFile.open("log");}
   ~Log(){mFile.close();}
-  
+
 
   Log& operator<<(float f);
   Log& operator<<(int i);
diff --git a/src/MapleFE/shared/include/mempool.h b/src/MapleFE/shared/include/mempool.h
index c7a85ff0de8f4988468fb3645053cb7eb6119680..3112dafdc3b22f7882cee0daa02d74ca10f25cff 100644
--- a/src/MapleFE/shared/include/mempool.h
+++ b/src/MapleFE/shared/include/mempool.h
@@ -50,9 +50,6 @@ struct Block {
   Block *prev;       // prev block
 };
 
-// So far there is nothing like free list. Everything will be released when
-// StaticMemPool is destructed.
-//
 class MemPool{
 protected:
   Block    *mCurrBlock; // Currently available block
@@ -67,7 +64,8 @@ public:
   char* Alloc(unsigned);
   void  Release(unsigned i);  // release the last occupied i bytes.
 
-  void  Clear();   // remove all data, but keep memory.
+  void  WipeOff(int c = 0);   // wipe off all data with c
+  void  Clear();   // free up all block, dont wipe data, Keep memory.
   void  Release(); // Allow users to free memory explicitly.
 };
 
diff --git a/src/MapleFE/shared/include/parser.h b/src/MapleFE/shared/include/parser.h
index da040f8e7478857dc490779cc8051c133af7f8f2..5b4a1072bc48fd4bce6da0d79d0ffe37756fbfdb 100644
--- a/src/MapleFE/shared/include/parser.h
+++ b/src/MapleFE/shared/include/parser.h
@@ -1,7 +1,8 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
+* Copyright 2022 Tencent. All rights reverved.
 *
-* OpenArkFE is licensed under the Mulan PSL v2.
+* MapleFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
 * You may obtain a copy of Mulan PSL v2 at:
 *
@@ -23,10 +24,12 @@
 
 #include "lexer.h"
 #include "ast_module.h"
+#include "ast_builder.h"
 #include "container.h"
 #include "recursion.h"
 #include "succ_match.h"
-#include "gen_summary.h"
+#include "rule_summary.h"
+#include "appnode_pool.h"
 
 namespace maplefe {
 
@@ -38,14 +41,17 @@ class TableData;
 class ASTTree;
 class TreeNode;
 
-typedef enum {
+typedef enum AppealStatus {
   FailWasFailed,
   FailNotRightToken,
+  FailNotRightString,
   FailNotIdentifier,
   FailNotLiteral,
+  FailNotRegExpr,
   FailChildrenFailed,
   Fail2ndOf1st,
   FailLookAhead,
+  FailASI,
 
   // Succ :             Really does the matching, will be saved in SuccMatch
   // SuccWasSucc :      Was matched, not tried traversal for a second timewill,
@@ -54,13 +60,21 @@ typedef enum {
   //                    in RecurionNodes where it does multiple instances of
   //                    traversal. But it doesn't make any change compared
   //                    to the last real Succ. It will NOT be saved in SuccMatch
+  // SuccASI:           TS/JS auto-semicolon-insert
   Succ,
   SuccWasSucc,
   SuccStillWasSucc,
+  SuccASI,
 
   AppealStatus_NA
 }AppealStatus;
 
+typedef enum {
+  ParseSucc,
+  ParseFail,
+  ParseEOF
+} ParseStatus;
+
 // As in Left Recursion scenario, a rule can have multiple matches on a start token.
 // Each AppealNode represents an instance in the recursion, and it matches different
 // number of tokens. However, truth is the parent nodes matches more than children
@@ -68,14 +82,21 @@ typedef enum {
 
 class AppealNode{
 private:
-  // In theory a tree shouldn't merge. But we do allow merge in the recursion
-  // parsing. mParent is the first level parent. mSecondParents are second level, and
-  // they are used during manipulation at certain phases like connecting instances
-  // of recursion. However, after SortOut, only mParent is valid.
   AppealNode  *mParent;
-  SmallVector<AppealNode*> mSecondParents;
+
+  // We do allow the tree to merge in the recursion parsing.
+  // they are used during manipulation at certain phases like connecting instances
+  // of recursion, if a recursion have multiple cycles with one same leading node.
+  // The leading node will be connected multiple times. See ConnectPrevious().
+  //
+  // However, in sort out, we traverse from parent to child, and these 'secondary'
+  // parents are never used. So, I decided not to have dedicated data structure to
+  // record these 'second' parents.
+  //
+  // SmallVector<AppealNode*> mSecondParents;
 
   unsigned     mStartIndex;       // index of start matching token
+  unsigned     mChildIndex;       // index as a child in the parent rule table.
   bool         mSorted;           // already sorted out?
   bool         mIsPseudo;         // A pseudo node, mainly used for sub trees connection
                                   // It has no real program meaning, but can be used
@@ -92,15 +113,14 @@ private:
   TreeNode    *mAstTreeNode;      // The AST tree node of this AppealNode.
 
 public:
-  unsigned GetSecondParentsNum() {return mSecondParents.GetNum();}
-  AppealNode* GetSecondParent(unsigned i) {return mSecondParents.ValueAtIndex(i);}
-  void        ClearSecondParents() {mSecondParents.Clear();}
   AppealNode* GetParent()       {return mParent;}
   void        SetParent(AppealNode *n) {mParent = n;}
   void        AddParent(AppealNode *n);
 
-  unsigned GetStartIndex()      {return mStartIndex;}
-  void SetStartIndex(unsigned i){mStartIndex = i;}
+  unsigned GetStartIndex()          {return mStartIndex;}
+  void     SetStartIndex(unsigned i){mStartIndex = i;}
+  unsigned GetChildIndex()          {return mChildIndex;}
+  void     SetChildIndex(unsigned i){mChildIndex = i;}
 
   bool IsPseudo()   {return mIsPseudo;}
   void SetIsPseudo(){mIsPseudo = true;}
@@ -117,6 +137,7 @@ public:
 
   unsigned GetMatchNum()        {return mMatches.GetNum();}
   unsigned GetMatch(unsigned i) {return mMatches.ValueAtIndex(i);}
+  void     ClearMatch()         {mMatches.Clear();}
   void     AddMatch(unsigned i);
   unsigned LongestMatch();        // find the longest match.
   bool     FindMatch(unsigned m); // if 'm' exists?
@@ -125,12 +146,6 @@ public:
 
 public:
   bool mIsTable;     // A AppealNode could relate to either rule table or token.
-  unsigned int mSimplifiedIndex;  // After SimplifyShrinkEdges, a node could be moved to
-                                  // connect to a new 'parent' node, replacing its ancestor.
-                                  // To make AST building work, it needs to inherit ancestor's
-                                  // index in the rule table.
-
-public:
   union {
     RuleTable *mTable;
     Token     *mToken;
@@ -143,7 +158,7 @@ public:
 
   Token       *mAltToken;         // The alt token it matches.
 
-  std::vector<AppealNode*> mChildren;
+  SmallVector<AppealNode*> mChildren;
 
   // I use an additional vector for the sorted out children. Why do we have two duplicated
   // children vectors? The reason is coming from sortout. After SortOut we need remove some
@@ -154,28 +169,30 @@ public:
   // During AST tree generation, for the SuccWasSucc child we need find the original matching
   // tree. That means the original mChildren vector needs to be traversed to locate that tree.
   // So we keep mChildren untouched and define a second vector for the SortOut-ed children.
-  std::vector<AppealNode*> mSortedChildren;
+  SmallVector<AppealNode*> mSortedChildren;
 
   // A Succ mResult doesn't mean 'really' matching tokens. e.g. Zeroorxxx rules could
   // match nothing, but it is succ.
   AppealStatus mResult;
 
   AppealNode() {mData.mTable=NULL; mParent = NULL;
-                mResult = AppealStatus_NA; mSimplifiedIndex = 0; mIsTable = true;
+                mResult = AppealStatus_NA; mIsTable = true;
                 mStartIndex = 0; mSorted = false; mFinalMatch = 0;
                 m1stAltTokenMatched = false; mAltToken = NULL;
-                mIsPseudo = false; mAstTreeNode = NULL; mAstCreated = false;}
-  ~AppealNode(){mMatches.Release();}
+                mIsPseudo = false; mAstTreeNode = NULL; mAstCreated = false;
+                mChildIndex = 0;
+                // These two don't need big memory. So set block size to 128.
+                mChildren.SetBlockSize(128); mSortedChildren.SetBlockSize(128); }
+  ~AppealNode() {Release();}
+  void Release(){mMatches.Release(); mChildren.Release(); mSortedChildren.Release();}
 
-  void AddChild(AppealNode *n) { mChildren.push_back(n); }
-  void RemoveChild(AppealNode *n);
-  void ClearChildren() { mChildren.clear(); }
+  void AddChild(AppealNode *n) { mChildren.PushBack(n); }
+  void ClearChildren() { mChildren.Clear(); }
 
   void ReplaceSortedChild(AppealNode *existing, AppealNode *replacement);
-  void AddSortedChild(AppealNode *n) { mSortedChildren.push_back(n); }
-  bool GetSortedChildIndex(AppealNode*, unsigned &);
-  AppealNode* GetSortedChildByIndex(unsigned idx);
-  AppealNode* FindSpecChild(TableData *tdata, unsigned match);
+  void AddSortedChild(AppealNode *n) { mSortedChildren.PushBack(n); }
+  AppealNode* GetSortedChild(unsigned idx);
+  AppealNode* FindIndexedChild(unsigned match, unsigned index);
 
   bool IsSucc() { return (mResult == Succ) ||
                          (mResult == SuccWasSucc) ||
@@ -195,11 +212,6 @@ public:
   void SetToken(Token *t)     { mIsTable = false; mData.mToken = t; }
   RuleTable* GetTable() { return mData.mTable; }
   Token*     GetToken() { return mData.mToken; }
-
-  bool SuccEqualTo(AppealNode*);
-
-  // If 'this' is a descendant of 'p'.
-  bool DescendantOf(AppealNode *p);
 };
 
 class RecursionTraversal;
@@ -215,14 +227,22 @@ struct RecStackEntry {
   }
 };
 
+////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////
+
 class Parser {
-private:
+protected:
   friend class RecursionTraversal;
 
   // Matching on alternative tokens needs a state machine.
-  bool     mInAltTokensMatching;  // once it's true, mCurToken is frozen.
-  unsigned mNextAltTokenIndex;    // index of next alt token to be matched.
-  unsigned mATMToken;             // the current input token being processed.
+  bool        mInAltTokensMatching;  // once it's true, mCurToken is frozen.
+  unsigned    mNextAltTokenIndex;    // index of next alt token to be matched.
+  unsigned    mATMToken;             // the current input token being processed.
+  ModuleNode *mASTModule;            // the AST Module
+  ASTBuilder *mASTBuilder;           // the AST Builder
+
+  AppealNodePool mAppealNodePool;
 
 public:
   Lexer *mLexer;
@@ -242,16 +262,24 @@ public:
   bool mTracePatchWasSucc;  // trace patching was succ node.
   bool mTraceWarning;       // print the warning.
 
+  TreeNode *mNormalModeRoot;// For NormalMode, the root node after BuildAST.
+
+  TreeNode *mLineModeRoot;  // For LineMode, the root node after BuildAST.
+  bool mLineMode;           // LineMode is for parsing a single line of source code.
+                            // It could be from a string in memory, or read from URL.
+                            // It's common in dynamic loading of code in web application.
+
   void SetLexerTrace() {mLexer->SetTrace();}
   void DumpIndentation();
   void DumpEnterTable(const char *tablename, unsigned indent);
   void DumpExitTable(const char *tablename, unsigned indent, AppealNode*);
+  void DumpExitTable(const char *tablename, unsigned indent, AppealStatus, AppealNode *n = NULL);
   void DumpAppeal(RuleTable *table, unsigned token);
   void DumpSuccTokens(AppealNode*);
   void DumpSortOut(AppealNode *root, const char * /*hint*/);
   void DumpSortOutNode(AppealNode*);
 
-private:
+public:
   SmallVector<Token*>   mActiveTokens;   // vector for tokens during matching.
   unsigned              mCurToken;       // index in mActiveTokens, the next token to be matched.
   unsigned              mPending;        // index in mActiveTokens, the first pending token.
@@ -262,22 +290,26 @@ private:
   void UpdateSuccInfo(unsigned, AppealNode*);
 
   bool TraverseStmt();
+  bool TraverseTempLiteral();
   bool TraverseRuleTable(RuleTable*, AppealNode*, AppealNode *&);
   bool TraverseRuleTableRegular(RuleTable*, AppealNode*);
-  bool TraverseRuleTablePre(AppealNode*);
   bool TraverseTableData(TableData*, AppealNode*, AppealNode *&);
   bool TraverseConcatenate(RuleTable*, AppealNode*);
   bool TraverseOneof(RuleTable*, AppealNode*);
   bool TraverseZeroormore(RuleTable*, AppealNode*);
   bool TraverseZeroorone(RuleTable*, AppealNode*);
+  virtual bool TraverseASI(RuleTable*, AppealNode*, AppealNode *&) {return false;}
 
   // There are some special cases we can speed up the traversal.
   // 1. If the target is a token, we just need compare mCurToken with it.
   // 2. If the target is a special rule table, like literal, identifier, we just
   //    need check the type of mCurToken.
+  bool TraverseStringSucc(Token*, AppealNode*, AppealNode *&);
   bool TraverseToken(Token*, AppealNode*, AppealNode *&);
   bool TraverseLiteral(RuleTable*, AppealNode*);
   bool TraverseIdentifier(RuleTable*, AppealNode*);
+  bool TraverseTemplateLiteral(RuleTable*, AppealNode*);
+  bool TraverseRegularExpression(RuleTable*, AppealNode*);
   void TraverseSpecialTableSucc(RuleTable*, AppealNode*);
 
   bool IsVisited(RuleTable*);
@@ -295,6 +327,7 @@ private:
 
   bool MoveCurToken();             // move mCurToken one step.
   Token* GetActiveToken(unsigned); // Get an active token.
+  void InsertToken(unsigned, Token*);  //
 
   // Appealing System
   std::vector<AppealNode*> mAppealNodes;
@@ -324,8 +357,19 @@ private:
   void SupplementalSortOut(AppealNode *root, AppealNode *target);
 
   // Build AST, for each top level construct.
-  ASTTree*  BuildAST();
-
+  TreeNode* BuildAST();
+  // We need a set of functions to deal with some common manipulations of
+  // most languages during AST Building. You can disable it if some functions
+  // are not what you want.
+  TreeNode* NewTreeNode(AppealNode*);
+  TreeNode* Manipulate(AppealNode*);
+  TreeNode* Manipulate2Binary(TreeNode*, TreeNode*);
+  TreeNode* Manipulate2Cast(TreeNode*, TreeNode*);
+  TreeNode* BuildBinaryOperation(TreeNode *, TreeNode *, OprId);
+  TreeNode* BuildPassNode();
+
+  // Handle TemplateLiteralNodes
+  void ParseTemplateLiterals();
 
 //////////////////////////////////////////////////////////////
 // The following section is all about left recursion parsing
@@ -348,15 +392,30 @@ public:
   ~Parser();
 
   void SetVerbose(int i) { mLexer->SetVerbose(i); }
-  int  GetVerbose() { mLexer->GetVerbose(); }
+  int  GetVerbose() { return mLexer->GetVerbose(); }
+
+  ModuleNode* GetModule() {return mASTModule;}
 
   void Dump();
 
   bool Parse();
-  bool ParseStmt();
+  ParseStatus  ParseStmt();
+
   void InitRecursion();
   unsigned LexOneLine();
+
+  bool   TokenMerge(Token *);
+
+  // These are language specific.
+  virtual bool   TokenSplit(Token *)  {return false;}
+  virtual Token* GetRegExpr(Token *t) {return t;}
 };
 
+// Each language will have its own implementation of lexer. Most of lexer
+// are shared with some special functions being language specific.
+//
+// The implementation of this function is in lang/src/lang_spec.cpp.
+extern Lexer* CreateLexer();
+
 }
 #endif
diff --git a/src/MapleFE/shared/include/parser_rec.h b/src/MapleFE/shared/include/parser_rec.h
index bc64dfb455cbb1ebc16ce066ce49bc3750488883..bd79654e3d31e1ad1d2f15b31613052c9df37b69 100644
--- a/src/MapleFE/shared/include/parser_rec.h
+++ b/src/MapleFE/shared/include/parser_rec.h
@@ -42,7 +42,7 @@ public:
 public:
   RecPath(){};
   ~RecPath() {mPath.Release();}
-  
+
 };
 
 enum RecTraInstance {
@@ -82,7 +82,7 @@ private:
   //
   // In each iteration, the first time a LeadNode is visited, it will be saved
   // in this vector. The second time it's visited, it should go to connect
-  // with the node in the previous instance.
+  // with the node in the previous instance or set as Failed2ndOf1st.
   SmallVector<RuleTable*> mVisitedLeadNodes;
 
   // Visited Recursion Node. This is a per-iteration data too.
diff --git a/src/MapleFE/shared/include/recursion.h b/src/MapleFE/shared/include/recursion.h
index c60575600ddfe6ebc0ec4d2d112e7ece575edf91..20e19e421fae6838f12601b36da880ab50c9e039 100644
--- a/src/MapleFE/shared/include/recursion.h
+++ b/src/MapleFE/shared/include/recursion.h
@@ -32,7 +32,7 @@ namespace maplefe {
 struct LeftRecursion {
   RuleTable *mRuleTable;
   unsigned   mNum;  // How many recursions
-  unsigned **mCircles; // 
+  unsigned **mCircles; //
 };
 
 extern LeftRecursion **gLeftRecursions; //
diff --git a/src/MapleFE/shared/include/rule_summary.h b/src/MapleFE/shared/include/rule_summary.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6803bcd73b5f35eb5b870cb2e33d32d6c272942
--- /dev/null
+++ b/src/MapleFE/shared/include/rule_summary.h
@@ -0,0 +1,73 @@
+/*
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
+* Copyright 2022 Tencent. All rights reverved.
+*
+* MapleFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __RULE_SUMMARY_H__
+#define __RULE_SUMMARY_H__
+#include "ruletable.h"
+#include "succ_match.h"
+#include "token.h"
+namespace maplefe {
+typedef struct {
+  const RuleTable *mAddr;
+  const char      *mName;
+  unsigned         mIndex;
+}RuleTableSummary;
+extern RuleTableSummary gRuleTableSummarys[];
+extern unsigned RuleTableNum;
+extern const char* GetRuleTableName(const RuleTable*);
+class BitVector;
+extern BitVector gFailed[];
+class SuccMatch;
+extern SuccMatch gSucc[];
+extern unsigned gTopRulesNum;
+extern RuleTable* gTopRules[];
+
+// The rule tables of autogen reserved rules.
+extern RuleTable TblCHAR;
+extern RuleTable TblDIGIT;
+extern RuleTable TblASCII;
+extern RuleTable TblESCAPE;
+extern RuleTable TblHEXDIGIT;
+extern RuleTable TblUTF8;
+extern RuleTable TblIRREGULAR_CHAR;
+
+extern RuleTable TblNoLineTerminator;
+extern RuleTable TblTemplateLiteral;
+extern RuleTable TblRegularExpression;
+extern RuleTable TblExpression;
+extern RuleTable TblType;
+
+//
+extern RuleTable TblIdentifier;
+extern RuleTable TblLiteral;
+extern RuleTable TblIntegerLiteral;
+extern RuleTable TblFPLiteral;
+extern RuleTable TblBooleanLiteral;
+extern RuleTable TblCharacterLiteral;
+extern RuleTable TblStringLiteral;
+extern RuleTable TblNullLiteral;
+
+// The tokens defined by system
+extern unsigned gSystemTokensNum;
+extern unsigned gOperatorTokensNum;
+extern unsigned gSeparatorTokensNum;
+extern unsigned gKeywordTokensNum;
+extern Token gSystemTokens[];
+extern unsigned gAltTokensNum;
+extern AltToken gAltTokens[];
+
+}
+#endif
diff --git a/src/MapleFE/shared/include/ruletable.h b/src/MapleFE/shared/include/ruletable.h
index b671bc95f73671792d056b72931f931250b234e9..2464e7c6eaaafaf414c2420b5780d9f3a72e63e7 100644
--- a/src/MapleFE/shared/include/ruletable.h
+++ b/src/MapleFE/shared/include/ruletable.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -14,7 +14,7 @@
 */
 //////////////////////////////////////////////////////////////////////////
 // This file contains all the information to describe the tables that
-// autogen creates. 
+// autogen creates.
 //////////////////////////////////////////////////////////////////////////
 
 #ifndef __RULE_TABLE_H__
@@ -36,21 +36,23 @@ namespace maplefe {
 //       keyword, separator, operator with tokens. This happens in memory.
 // The reason we need token is to save the time of matching a rule. Lexer
 // returns a set of tokens, so it's faster if parts of a rule are tokens
-// to compare. 
+// to compare.
 ///////////////////////////////////////////////////////////////////////////
 
 // The list of RuleTable Entry types
-typedef enum {
+typedef enum EntryType {
   ET_Oneof,      // one of (...)
   ET_Zeroormore, // zero or more of (...)
   ET_Zeroorone,  // zero or one ( ... )
   ET_Concatenate,// Elem + Elem + Elem
+  ET_ASI,        // Typescript Auto-Semicolon-Insertion. This is to
+                 // parse the missing simicolon of TS/JS
   ET_Data,       // data, further categorized into DT_Char, DT_String, ...
   ET_Null
 }EntryType;
 
 // List of data types
-typedef enum {
+typedef enum DataType {
   DT_Char,       // It's a literal elements, char, 'c'.
   DT_String,     // It's a literal elements, string "abc".
   DT_Type,       // It's a type id
@@ -97,6 +99,8 @@ enum RuleProp {
                     // match, and it's ok. However, some concatenate rules do require
                     // certain sub-rules NOT to match the longest so that the later
                     // sub-rules can match, and so the whole rule.
+  RP_NoAltToken = 16, // don't do alternative token matching for some special tokens
+                      // inside the current rule.
 };
 
 // A rule has a limited set of beginning tokens. These are called LookAhead.
@@ -117,7 +121,7 @@ enum LAType {
 struct LookAhead {
   LAType mType;   // the type of look ahead
   union{
-    char        mChar;
+    unsigned char  mChar;
     const char *mString;
     unsigned    mTokenId;
   }mData;
@@ -153,6 +157,8 @@ struct TypeKeyword {
   const char *mText;
   TypeId      mId;
 };
+extern TypeKeyword TypeKeywordTable[];
+extern unsigned TypeKeywordTableSize;
 
 //////////////////////////////////////////////////////////////////////
 //                     Attribute  Table                             //
@@ -163,6 +169,8 @@ struct AttrKeyword {
   const char *mText;
   AttrId      mId;
 };
+extern AttrKeyword AttrKeywordTable[];
+extern unsigned AttrKeywordTableSize;
 
 //////////////////////////////////////////////////////////////////////
 //                    Separator Table                               //
@@ -174,6 +182,8 @@ struct SepTableEntry {
   const char *mText;
   SepId       mId;
 };
+extern SepTableEntry SepTable[];
+extern unsigned SepTableSize;
 
 //////////////////////////////////////////////////////////////////////
 //                    Operator  Table                               //
@@ -185,6 +195,8 @@ struct OprTableEntry {
   const char *mText;
   OprId       mId;
 };
+extern OprTableEntry OprTable[];
+extern unsigned OprTableSize;
 
 //////////////////////////////////////////////////////////////////////
 //                    Keyword   Table                               //
@@ -195,6 +207,8 @@ struct OprTableEntry {
 struct KeywordTableEntry {
   const char *mText;
 };
+extern KeywordTableEntry KeywordTable[];
+extern unsigned KeywordTableSize;
 
 }
 #endif
diff --git a/src/MapleFE/shared/include/ruletable_util.h b/src/MapleFE/shared/include/ruletable_util.h
index 618b9ea6f53f8e982bef2058265978fca359e8bd..851feb3ea37a4e98ab90486910d5a96b2c8cc6ee 100644
--- a/src/MapleFE/shared/include/ruletable_util.h
+++ b/src/MapleFE/shared/include/ruletable_util.h
@@ -46,7 +46,7 @@ namespace maplefe {
 //      The most straightforward idea is to put the function pointers in the rule table
 //      with additional information. However, the signatures of a function makes the idea
 //      complicated.
-//      
+//
 //      So I finally decided to have an Id for each check function, and Id is written into
 //      the rule tables by Autogen.
 
diff --git a/src/MapleFE/shared/include/stringmap.h b/src/MapleFE/shared/include/stringmap.h
index cbfc6ca0f3264346552073612246bd06090fefa2..66fe263e81b040fe88d8663bc47dd3937044b7ac 100644
--- a/src/MapleFE/shared/include/stringmap.h
+++ b/src/MapleFE/shared/include/stringmap.h
@@ -16,7 +16,7 @@
 //
 // StringMap is heavily used in the StringPool. It's used to locate the address
 // of string in the StringPool. Here is how it works:
-//   (1) std::string ---> Hash value, --> Locate the Bucket in StringMap 
+//   (1) std::string ---> Hash value, --> Locate the Bucket in StringMap
 //       --> get the addr from StringMapEntry
 //   (2) If conflicted in the Bucket, iterate to find the right StringMapEntry
 //   (3) If not found, a) Add std::string to the StringPool
@@ -38,13 +38,17 @@ class StringPool;
 class StringMapEntry {
 public:
   char           *Addr;   // Addr in the string pool
-  StringMapEntry *Next; 
+  unsigned        StrIdx; // String index
+  StringMapEntry *Next;
 public:
-  StringMapEntry() { Addr = NULL; Next = NULL; }
-  StringMapEntry(char *A) { Addr = A; Next = NULL; }
-  StringMapEntry(char *A, StringMapEntry *E) { Addr = A; Next = E; }
+  StringMapEntry() { Addr = NULL; StrIdx = 0; Next = NULL; }
+  StringMapEntry(char *A, unsigned idx) { Addr = A; StrIdx = idx; Next = NULL; }
+  StringMapEntry(char *A, unsigned idx, StringMapEntry *E) { Addr = A; StrIdx = idx; Next = E; }
 
   ~StringMapEntry() {}
+
+  char *GetAddr() { return Addr; }
+  unsigned GetStrIdx() { return StrIdx; }
 };
 
 class StringMap {
@@ -62,8 +66,8 @@ public:
   void     SetPool(StringPool *p) {mPool = p;}
 
   unsigned BucketNoFor(const std::string &s);
-  char*    LookupAddrFor(const std::string &s);
-  void     InsertEntry(char *, unsigned);
+  StringMapEntry *LookupEntryFor(const std::string &s);
+  StringMapEntry *InsertEntry(char *, unsigned, unsigned);
 };
 
 }
diff --git a/src/MapleFE/shared/include/stringpool.h b/src/MapleFE/shared/include/stringpool.h
index da076c9df949007d46dc8bd6427d3591fd9ae007..fd8dfee8ab8012e29a2bf5586db57f588e7d1721 100644
--- a/src/MapleFE/shared/include/stringpool.h
+++ b/src/MapleFE/shared/include/stringpool.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -23,7 +23,10 @@
 
 #include <map>
 #include <vector>
+#include <unordered_map>
+#include <unordered_set>
 #include <string>
+#include "massert.h"
 
 namespace maplefe {
 
@@ -44,21 +47,52 @@ private:
   StringMap            *mMap;
   std::vector<SPBlock>  mBlocks;
   int                   mFirstAvail; // -1 means no available.
+  bool                  mUseAltStr;  // use alter string
+
+  std::vector<char*> mLongStrings; // for strings longer than block size,
+                                   // we allocate them by malloc.
+
+  std::vector<const char*> mStringTable;
+
+  // alternate string which can be used for obfuscation
+  std::unordered_set<unsigned> mAltStrIdxSet;
+  std::unordered_map<unsigned, unsigned> mAltStrIdxMap;
+
+  friend class StringMap;
 
 public:
+  StringPool();
+  ~StringPool();
+
+  void SetUseAltStr(bool b) { mUseAltStr = b; }
+  void AddAltStrIdx(unsigned idx) { mAltStrIdxSet.insert(idx); }
+  unsigned GetAltStrSize() { return mAltStrIdxSet.size(); }
+  bool IsAltStrIdx(unsigned idx) {
+    return mAltStrIdxSet.find(idx) != mAltStrIdxSet.end();
+  }
+  void AddAltStrIdxMap(unsigned orig, unsigned alt) { mAltStrIdxMap[orig] = alt; }
+  void SetAltStrIdxMap();
+
   char* AllocBlock();
   char* Alloc(const size_t);
   char* Alloc(const std::string&);
   char* Alloc(const char*);
 
-public:
-  StringPool();
-  ~StringPool();
-
   // If not found, add into StringPool
   const char* FindString(const std::string&);
   const char* FindString(const char*);
   const char* FindString(const char*, size_t);
+
+  unsigned GetStrIdx(const std::string&);
+  unsigned GetStrIdx(const char*);
+  unsigned GetStrIdx(const char*, size_t);
+
+  unsigned GetSize() {return mStringTable.size();}
+
+  const char *GetStringFromStrIdx(unsigned idx);
+
+  void Dump();
+  void DumpAlt();
 };
 
 // Lexing, Parsing, AST Building and IR Building all share one global
diff --git a/src/MapleFE/shared/include/stringutil.h b/src/MapleFE/shared/include/stringutil.h
index b0b66a32775d6401c8986e2e9be95c4533ea1880..83b5000f7ab44e2a760291119308688d2b950485 100644
--- a/src/MapleFE/shared/include/stringutil.h
+++ b/src/MapleFE/shared/include/stringutil.h
@@ -31,7 +31,7 @@ namespace maplefe {
 // http://license.coscl.org.cn/MulanPSL2
 static inline unsigned HashString(const std::string &s) {
   unsigned Result = 0;
-  for (size_t i = 0; i < s.size(); i++) 
+  for (size_t i = 0; i < s.size(); i++)
     Result = Result * 33 + (unsigned char)s[i];
   return Result;
 }
diff --git a/src/MapleFE/shared/include/succ_match.h b/src/MapleFE/shared/include/succ_match.h
index bfe143e66d32dd57ffed591c059e0b9b6eb7879d..648dc0be294fdb3a04afba79679b5ecb3596c819 100644
--- a/src/MapleFE/shared/include/succ_match.h
+++ b/src/MapleFE/shared/include/succ_match.h
@@ -1,7 +1,8 @@
 /*
 * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright 2022 Tencent. All rights reverved.
 *
-* OpenArkFE is licensed under the Mulan PSL v2.
+* MapleFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
 * You may obtain a copy of Mulan PSL v2 at:
 *
@@ -37,7 +38,7 @@ namespace maplefe {
 //    on every recursion group in a wavefront manner. Although after each iteration of
 //    the wavefront we got succ/fail info, but it's not complete yet. This field tells
 //    if we have reached the fixed point or not.
-//    
+//
 //    The second 'unsigned' in mMatches is not used, since putting IsDone in mNodes
 //    is enough.
 //
@@ -47,8 +48,8 @@ namespace maplefe {
 class AppealNode;
 class SuccMatch {
 private:
-  Guamian<unsigned, unsigned, AppealNode*> mNodes;
-  Guamian<unsigned, unsigned, unsigned> mMatches;
+  GuamianFast<unsigned, unsigned, AppealNode*> mNodes;
+  GuamianFast<unsigned, unsigned, unsigned> mMatches;
 
 public:
   SuccMatch(){}
diff --git a/src/MapleFE/shared/include/supported.h b/src/MapleFE/shared/include/supported.h
index 9ed0f51d2601ccfb2dac1a7a58bf83367c737218..2b1e6ad41d92056dc07bdb83cfd66f1e5428be2c 100644
--- a/src/MapleFE/shared/include/supported.h
+++ b/src/MapleFE/shared/include/supported.h
@@ -24,8 +24,10 @@ namespace maplefe {
 // The list of all supported types. This covers all the languages.
 // NOTE: autogen also relies on this set of supported separators
 #undef  TYPE
+#undef  PRIMTYPE
 #define TYPE(T) TY_##T,
-typedef enum {
+#define PRIMTYPE(T) TY_##T,
+typedef enum TypeId {
 #include "supported_types.def"
 TY_NA
 }TypeId;
@@ -34,7 +36,7 @@ TY_NA
 // NOTE: autogen also relies on this set of supported separators
 #undef  SEPARATOR
 #define SEPARATOR(T) SEP_##T,
-typedef enum {
+typedef enum SepId {
 #include "supported_separators.def"
 SEP_NA
 }SepId;
@@ -43,16 +45,16 @@ SEP_NA
 // NOTE: autogen also relies on this set of supported operators.
 #undef  OPERATOR
 #define OPERATOR(T, D) OPR_##T,
-typedef enum {
+typedef enum OprId {
 #include "supported_operators.def"
 OPR_NA
 }OprId;
 
 #define LITERAL(T) LT_##T,
-typedef enum {
+typedef enum LitId {
 #include "supported_literals.def"
   LT_NA     // N/A, in java, Null is legal type with only one value 'null'
-            // reference, a literal. So LT_Null is actually legal. 
+            // reference, a literal. So LT_Null is actually legal.
             // So I put LT_NA for the illegal literal
 }LitId;
 
@@ -64,7 +66,6 @@ enum AttrId {
 ATTR_NA
 };
 
-
 // TODO: The action id will come from both the shared part and language specific part.
 //       Some language may have its own special action to build AST.
 //       For now I just put everything together in order to expediate the overall
diff --git a/src/MapleFE/shared/include/supported_actions.def b/src/MapleFE/shared/include/supported_actions.def
index 30ca48756cfeb342538e299d4c8b04bbccc4537b..ef4710d3862514ff281d00f5f277cbf93d708a66 100644
--- a/src/MapleFE/shared/include/supported_actions.def
+++ b/src/MapleFE/shared/include/supported_actions.def
@@ -28,29 +28,96 @@
 //          It also shows the internal parameters when parser creates the AST tree node.
 //          Please refer autogen/README.ACTIONS for details.
 
+ACTION(BuildModule)
+ACTION(AddModuleBody)
+ACTION(SetIsAmbient)
+
 ACTION(BuildPackageName)
 
 // These are about import/include
 ACTION(BuildSingleTypeImport)      // style like java single type import
 ACTION(BuildAllTypeImport)         // style like java ondemand type import
 ACTION(BuildSingleStaticImport)    // style like java single static import
-ACTION(BuildAllStaticImport)       // style like java ondemand static import
+ACTION(BuildAllStaticImport)       // style like java on-demand static import
 ACTION(BuildAllImport)             // style like c/c++ include all in .h file
 
+ACTION(BuildExternalDeclaration)           // c/c++ external decl, typescript declare.
+ACTION(BuildGlobalExternalDeclaration)     // typescript global declare.
+
+// Special actions for JS import/export
+ACTION(BuildImport)
+ACTION(BuildExport)
+ACTION(SetIsXXportType)
+ACTION(SetPairs)
+ACTION(SetDefaultPairs)
+ACTION(SetSinglePairs)
+ACTION(SetFromModule)
+ACTION(SetIsEverything)   // Apply to all pairs in import/export
+ACTION(SetAsNamespace)    // Apply to all pairs in import/export
+
+ACTION(BuildXXportAsPair)             // normal pair
+ACTION(BuildXXportAsPairEverything)   // '*'
+ACTION(BuildXXportAsPairDefault)      // 'default'
+
+
 ACTION(BuildBlock)
 ACTION(AddToBlock)
+ACTION(AddSyncToBlock)             // Java allows a sync obj to block
+
+ACTION(BuildAwait)
 
 ACTION(BuildCast)
 ACTION(BuildParenthesis)
 ACTION(BuildBinaryOperation)
 ACTION(BuildUnaryOperation)
+ACTION(BuildTernaryOperation)
 ACTION(BuildPostfixOperation)
+ACTION(BuildInstanceOf)
+ACTION(BuildIn)
+ACTION(BuildIs)
+ACTION(BuildTypeOf)
+ACTION(BuildKeyOf)
+ACTION(BuildInfer)
+
 ACTION(BuildLambda)
+ACTION(SetJavaLambda)       // java lambda
+ACTION(SetArrowFunction)    // JS arrow function
+
+// This is very special function, it changes other
+// keyword, attr node or anything into a new identifier node
+ACTION(BuildIdentifier)
+
+ACTION(BuildLiteral)
 
 // For variable declaration, expression
 ACTION(BuildDecl)
+ACTION(SetJSVar)
+ACTION(SetJSLet)
+ACTION(SetJSConst)
+
 ACTION(BuildField)
 ACTION(BuildVarList)
+ACTION(BuildComputedName)
+
+ACTION(BuildBindingElement)
+ACTION(BuildBindingPattern)
+ACTION(SetObjectBinding)
+ACTION(SetArrayBinding)
+
+// For struct
+ACTION(BuildStruct)
+ACTION(SetTSInterface)
+ACTION(SetTSEnum)
+ACTION(AddStructField)
+ACTION(BuildFieldLiteral)
+ACTION(BuildStructLiteral)
+
+ACTION(BuildStrIndexSig)
+ACTION(BuildNumIndexSig)
+
+// For Array
+ACTION(BuildArrayElement)
+ACTION(BuildArrayLiteral)
 
 // For function
 ACTION(AddParams)
@@ -58,6 +125,13 @@ ACTION(BuildFunction)
 ACTION(BuildConstructor)
 ACTION(AddFunctionBody)
 ACTION(AddFunctionBodyTo)
+ACTION(SetGetAccessor)   // TS 'get' accessor
+ACTION(SetSetAccessor)   // TS 'set' accessor
+ACTION(SetCallSignature) // TS call signature
+ACTION(SetConstructSignature) // TS construct signature
+ACTION(SetIsGenerator)   // JS generator
+ACTION(SetIsIterator)    // JS iterator
+ACTION(AddAssert)
 
 // For callsite
 ACTION(BuildCall)
@@ -72,10 +146,15 @@ ACTION(AddSuperInterface)
 ACTION(AddClassBody)
 ACTION(BuildInstInit)
 
+ACTION(BuildNamespace)
+ACTION(AddNamespaceBody)
+
 ACTION(AddModifier)
 ACTION(AddModifierTo)
+ACTION(AddInit)
 ACTION(AddInitTo)
-ACTION(AddTypeTo)
+ACTION(AddType)
+ACTION(AddAsType)
 
 // Annotation.
 ACTION(BuildAnnotationType)
@@ -92,6 +171,17 @@ ACTION(BuildDims)
 ACTION(AddDims)
 ACTION(AddDimsTo)
 
+// Set a tree node as ... properties
+ACTION(SetIsStmt)
+ACTION(SetIsOptional)
+ACTION(SetIsNonNull)
+ACTION(SetIsRest)
+ACTION(SetIsConst)
+ACTION(SetIsUnique)
+
+ACTION(BuildYield)
+ACTION(SetIsTransfer)
+
 // statment, control flow
 ACTION(BuildAssignment)
 ACTION(BuildAssert)
@@ -101,7 +191,10 @@ ACTION(AddCondBranchTrueStatement)
 ACTION(AddCondBranchFalseStatement)
 ACTION(AddLabel)
 ACTION(BuildBreak)
+ACTION(BuildContinue)
 ACTION(BuildForLoop)
+ACTION(BuildForLoop_In)     //This is Javascript, for (.. in ..){}
+ACTION(BuildForLoop_Of)     //This is Javascript, for (.. of ..){}
 ACTION(BuildWhileLoop)
 ACTION(BuildDoLoop)
 ACTION(BuildNewOperation)
@@ -110,13 +203,41 @@ ACTION(BuildDeleteOperation)
 ACTION(BuildSwitchLabel)
 ACTION(BuildDefaultSwitchLabel)
 ACTION(BuildOneCase)
-ACTION(BuildAllCases)
 ACTION(BuildSwitch)
 
 // Exceptions, Throws
 ACTION(BuildThrows)
 ACTION(AddThrowsTo)
 
+// Try, Catch, Finally
+ACTION(BuildTry)
+ACTION(BuildCatch)
+ACTION(BuildFinally)
+ACTION(AddCatch)
+ACTION(AddFinally)
+
 // User Types
 ACTION(BuildUserType)
-ACTION(AddTypeArgument)
+ACTION(BuildTupleType)      // Comes from Typescript.
+ACTION(AddTypeGenerics)     // add type arguments or type parameters or type generics
+ACTION(BuildUnionUserType)  // build union type
+ACTION(BuildInterUserType)  // build intersect type
+ACTION(BuildArrayType)      // From Spec point of view,
+                            // In languages like TS, dimension info is attached to type.
+                            // In C/C++, dimension info is attached to identifier.
+                            // However, the AST design is up to each implementation.
+ACTION(BuildNeverArrayType) // Special 'never' array type.
+
+ACTION(BuildTypeAlias)
+ACTION(BuildAsType)
+ACTION(BuildConditionalType)
+
+ACTION(BuildTypeParameter)
+ACTION(AddTypeParameterExtends)
+
+ACTION(BuildNameTypePair)
+
+ACTION(BuildTripleSlash)    // TS triple-slash directive.
+
+// This is a special action to pass a child to parent
+ACTION(PassChild)
diff --git a/src/MapleFE/shared/include/supported_attributes.def b/src/MapleFE/shared/include/supported_attributes.def
index 789de310f700b762f4ad4767e933e4a266aefe1b..86cc52600ea92b50476cd939557b8f7b454150ac 100644
--- a/src/MapleFE/shared/include/supported_attributes.def
+++ b/src/MapleFE/shared/include/supported_attributes.def
@@ -27,3 +27,8 @@ ATTRIBUTE(public)
 ATTRIBUTE(static)
 ATTRIBUTE(strictfp)
 ATTRIBUTE(default)
+ATTRIBUTE(synchronized)
+ATTRIBUTE(async)
+ATTRIBUTE(readonly)           // Typescript
+ATTRIBUTE(getter)             // Javascript getter function
+ATTRIBUTE(setter)             // Javascript setter function
diff --git a/src/MapleFE/shared/include/supported_literals.def b/src/MapleFE/shared/include/supported_literals.def
index 5bcf1a4f1353113fa837622cd83be46873a8554c..7ad1d28105b9ce2485cb6a90e5850ea2554fa430 100644
--- a/src/MapleFE/shared/include/supported_literals.def
+++ b/src/MapleFE/shared/include/supported_literals.def
@@ -26,4 +26,5 @@ LITERAL(CharacterLiteral)
 LITERAL(StringLiteral)
 LITERAL(NullLiteral)
 LITERAL(ThisLiteral)
-
+LITERAL(SuperLiteral)
+LITERAL(VoidLiteral)
diff --git a/src/MapleFE/shared/include/supported_operators.def b/src/MapleFE/shared/include/supported_operators.def
index 7b96ce06c84e8e4bb3075af322ac198f9214569f..2ffa34dd44fa1f53b361757b863c4d9ae861e8b4 100644
--- a/src/MapleFE/shared/include/supported_operators.def
+++ b/src/MapleFE/shared/include/supported_operators.def
@@ -15,6 +15,12 @@
 
 // This file defines the operators supported by AutoGen and MapleFE
 
+// NOTE
+// 1. Add/Sub will be used as binary only after AST building.
+//    Plus/Minus will be the unary
+// 2. Inc/Dec will be used as post after AST building.
+//    PreInc/PreDec will be pre operators.
+
 OPERATOR(Add, Binary|Unary)
 OPERATOR(Sub, Binary|Unary)
 OPERATOR(Mul, Binary)
@@ -23,6 +29,13 @@ OPERATOR(Mod, Binary)
 OPERATOR(Inc, Pre|Post)
 OPERATOR(Dec, Pre|Post)
 
+OPERATOR(Exp, Binary)
+
+OPERATOR(Plus,   Unary)
+OPERATOR(Minus,  Unary)
+OPERATOR(PreInc, Pre)
+OPERATOR(PreDec, Pre)
+
 OPERATOR(EQ, Binary)
 OPERATOR(NE, Binary)
 OPERATOR(GT, Binary)
@@ -57,10 +70,16 @@ OPERATOR(BxorAssign, Binary)
 OPERATOR(ZextAssign, Binary)
 
 OPERATOR(Arrow, Binary)
-OPERATOR(Select, Ternary)
-OPERATOR(Cond, Ternary)
-
 
 // In Java, there is a special type argument, <>, meaning no arguments.
 // It could appear in other languages. So I define Diamond.
 OPERATOR(Diamond, Unary)
+
+// This part comes from JS/TS
+OPERATOR(StEq, Binary)
+OPERATOR(StNe, Binary)
+OPERATOR(ArrowFunction, Binary)
+OPERATOR(NullCoalesce, Binary)
+OPERATOR(NullAssign, Binary)
+OPERATOR(TripleSlash, Binary)            // triple slash directive
+
diff --git a/src/MapleFE/shared/include/supported_separators.def b/src/MapleFE/shared/include/supported_separators.def
index a179c40679834dda7a12331f1e6fc44c0829b9d2..40298b4bb0afe66cac276efaf21fae8da10eff0d 100644
--- a/src/MapleFE/shared/include/supported_separators.def
+++ b/src/MapleFE/shared/include/supported_separators.def
@@ -25,8 +25,12 @@ SEPARATOR(Semicolon)
 SEPARATOR(Comma)
 SEPARATOR(Dot)
 SEPARATOR(Dotdotdot)
-SEPARATOR(Colon)
+SEPARATOR(Select)         // ?
+SEPARATOR(Colon)          // :
 SEPARATOR(Of)
 SEPARATOR(At)
 SEPARATOR(Pound)
 SEPARATOR(Whitespace)
+SEPARATOR(Tab)            // Horizontal Tab, 0x09
+SEPARATOR(ArrowFunction)  // first coming from JS, =>
+SEPARATOR(Optional)       // first coming from JS, ?.
diff --git a/src/MapleFE/shared/include/supported_types.def b/src/MapleFE/shared/include/supported_types.def
index df5a396d5641b0055c2cf84ca54f63d8276310fd..c16bd4a934d49783017babb74231ece08d02a74d 100644
--- a/src/MapleFE/shared/include/supported_types.def
+++ b/src/MapleFE/shared/include/supported_types.def
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -16,14 +16,40 @@
 // This file defines the complete set of primitive types supported in Autogen
 // and the parser.
 
-TYPE(Boolean)
-TYPE(Byte)
-TYPE(Short)
-TYPE(Int)
-TYPE(Long)
-TYPE(Char)
-TYPE(Float)
-TYPE(Double)
+TYPE(None)
+
+PRIMTYPE(Boolean)
+PRIMTYPE(Byte)
+PRIMTYPE(Short)
+PRIMTYPE(Int)
+PRIMTYPE(Long)
+PRIMTYPE(Char)
+PRIMTYPE(Float)
+PRIMTYPE(Double)
+
+// keep these two after primitive types as we are going to create
+// primitive types for them as well
+TYPE(Number)    // First come from JS
+TYPE(String)    // First come from JS
+
 TYPE(Void)      // Although this is not a type, it does categorize the types.
 TYPE(Null)      // The Null type. It is a type.
+TYPE(Unknown)   // First come from TS 3.0
+TYPE(Never)     // First come from TS
+TYPE(Undefined) // First come from JS
+TYPE(Symbol)    // First come from JS
+TYPE(Any)       // First come from JS
+TYPE(Date)
+
+TYPE(Array)
+TYPE(Object)
+TYPE(Function)  // function/lambda decl
+TYPE(Class)     // class/interface decl
+TYPE(Module)    // import/export module
+TYPE(Namespace) // namespace
+TYPE(User)      // user types
+TYPE(Merge)     // merge of two types, unexpected
+
+// last entry
+TYPE(Max)
 
diff --git a/src/MapleFE/shared/include/token.h b/src/MapleFE/shared/include/token.h
index 71e9119486fbdf2448ff1f218ed36b3c04984ec9..f2406ee14ead46ea4581bf5a584ed6531026a84a 100644
--- a/src/MapleFE/shared/include/token.h
+++ b/src/MapleFE/shared/include/token.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -30,20 +30,24 @@
 #ifndef __Token_H__
 #define __Token_H__
 
+#include <cstdint>
 #include <vector>
 #include "char.h"
 #include "stringutil.h"
 #include "supported.h"
+#include "container.h"
 
 namespace maplefe {
 
-typedef enum {
+typedef enum TK_Type {
   TT_ID,    // Identifier
   TT_KW,    // Keyword
   TT_LT,    // Literal
   TT_SP,    // separator
   TT_OP,    // operator
   TT_CM,    // comment
+  TT_TL,    // template literal. coming from Javascript first.
+  TT_RE,    // regular expression, coming from most script languages.
   TT_NA     // N.A.
 }TK_Type;
 
@@ -59,12 +63,13 @@ typedef enum {
 struct LitData {
   LitId mType;
   union {
-    int    mInt;
+    long   mInt;
     float  mFloat;
     double mDouble;
     bool   mBool;
     Char   mChar;
-    const char  *mStr;     // the string is allocated in gStringPool
+    unsigned mStrIdx;     // the string is allocated in gStringPool
+    int64_t  mInt64;      // for serialization
   }mData;
 };
 
@@ -90,13 +95,36 @@ struct AltToken {
   unsigned mAltTokenId;
 };
 
+// We define the data of template literal token.
+// TemplateLiteral data contains: formate and placeholder.
+// They are saved as pair <format, placeholder>. If either is missing, NULL
+// is saved in its position.
+struct TempLitData {
+  SmallVector<const char*> mStrings;
+};
+
+// Regular expressions have two data. One is the expression,
+// the other is the flags. Both are saved as strings.
+struct RegExprData {
+  const char *mExpr;
+  const char *mFlags;
+};
+
 struct Token {
   TK_Type mTkType;
+
+  unsigned mLineNum;    // line num
+  unsigned mColNum;     // column num
+  bool     mLineBegin;  // first token of line?
+  bool     mLineEnd;    // last token of line?
+
   union {
     const char *mName; // Identifier, Keyword. In the gStringPool
     LitData     mLitData;
     SepId       mSepId;
     OprId       mOprId;
+    TempLitData *mTempLitData;
+    RegExprData  mRegExprData;
   }mData;
 
   AltToken     *mAltTokens;
@@ -107,17 +135,34 @@ struct Token {
   bool IsLiteral()    const { return mTkType == TT_LT; }
   bool IsKeyword()    const { return mTkType == TT_KW; }
   bool IsComment()    const { return mTkType == TT_CM; }
+  bool IsTempLit()    const { return mTkType == TT_TL; }
+  bool IsRegExpr()    const { return mTkType == TT_RE; }
 
   void SetIdentifier(const char *name) {mTkType = TT_ID; mData.mName = name;}
   void SetLiteral(LitData data)        {mTkType = TT_LT; mData.mLitData = data;}
+  void SetTempLit(TempLitData *data)   {mTkType = TT_TL; mData.mTempLitData = data;}
+  void SetRegExpr(RegExprData data)    {mTkType = TT_RE; mData.mRegExprData = data;}
+
+  const char*  GetName() const;
+  LitData      GetLitData()   const {return mData.mLitData;}
+  OprId        GetOprId()     const {return mData.mOprId;}
+  SepId        GetSepId()     const {return mData.mSepId;}
+  bool         IsWhiteSpace() const {return mData.mSepId == SEP_Whitespace;}
+  bool         IsTab()        const {return mData.mSepId == SEP_Tab;}
+  TempLitData* GetTempLitData()   const {return mData.mTempLitData;}
+  RegExprData  GetRegExpr()   const {return mData.mRegExprData;}
+
+  // This is handle only Operator, Separator, and Keyword. All others return false.
+  bool Equal(Token *);
 
-  const char* GetName() const;
-  LitData     GetLitData()   const {return mData.mLitData;}
-  OprId       GetOprId()     const {return mData.mOprId;}
-  SepId       GetSepId()     const {return mData.mSepId;}
-  bool        IsWhiteSpace() const {return mData.mSepId == SEP_Whitespace;}
   void Dump();
 };
 
+  //
+  Token* FindSeparatorToken(SepId id);
+  Token* FindOperatorToken(OprId id);
+  Token* FindKeywordToken(const char *key);
+  Token* FindCommentToken();
+
 }
 #endif
diff --git a/src/MapleFE/shared/include/typetable.h b/src/MapleFE/shared/include/typetable.h
new file mode 100644
index 0000000000000000000000000000000000000000..d53b17719156f086fefca6fbc7d2f9ec02844e92
--- /dev/null
+++ b/src/MapleFE/shared/include/typetable.h
@@ -0,0 +1,91 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+//////////////////////////////////////////////////////////////////////////////
+// This file contains the Memory Pool for String pool.                      //
+//                                                                          //
+// A String is stored in the pool with an ending '\0'.                      //
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __TYPETABLE_H__
+#define __TYPETABLE_H__
+
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <string>
+#include "massert.h"
+#include "ast.h"
+#include "ast_type.h"
+
+namespace maplefe {
+
+class TypeEntry {
+ private:
+  TreeNode *mType;
+  TypeId    mTypeId;
+
+ public:
+  TypeEntry() : mType(NULL), mTypeId(TY_None) {}
+  TypeEntry(TreeNode *node);
+  ~TypeEntry(){};
+
+  TypeId    GetTypeId()   { return mTypeId; }
+  TreeNode *GetType()     { return mType; }
+
+  void SetTypeId(TypeId i)     { mTypeId = i; }
+  void SetType(TreeNode *n)    { mType = n; }
+};
+
+class TypeTable {
+private:
+  std::vector<TypeEntry *> mTypeTable;
+  std::unordered_map<unsigned, unsigned> mNodeId2TypeIdxMap;
+  std::unordered_map<TypeId, TreeNode*> mTypeId2TypeMap;
+  std::unordered_set<TypeId> mPrimTypeId;
+  std::unordered_set<unsigned> mFuncTypeIdx;
+  unsigned mPrimSize;
+  unsigned mPreBuildSize;
+
+public:
+  TypeTable() {};
+  ~TypeTable() { mTypeTable.clear(); };
+
+  unsigned size() { return mTypeTable.size(); }
+  unsigned GetPreBuildSize() { return mPreBuildSize; }
+
+  bool IsPrimTypeId(TypeId tid) { return mPrimTypeId.find(tid) != mPrimTypeId.end(); }
+  unsigned GetPrimSize() { return mPrimSize; }
+  TreeNode *CreatePrimType(std::string name, TypeId tid);
+  TreeNode *CreateBuiltinType(std::string name, TypeId tid);
+
+  void AddPrimTypeId(TypeId tid);
+  void AddPrimAndBuiltinTypes();
+  bool AddType(TreeNode *node);
+
+  TypeEntry *GetTypeEntryFromTypeIdx(unsigned tidx);
+  TreeNode  *GetTypeFromTypeIdx(unsigned tidx);
+  TreeNode  *GetTypeFromTypeId(TypeId tid) { return mTypeId2TypeMap[tid]; }
+  TreeNode  *GetTypeFromStrIdx(unsigned strid);
+
+  unsigned GetOrCreateFunctionTypeIdx(FunctionTypeNode *type);
+
+  void Dump();
+};
+
+extern TypeTable gTypeTable;
+
+
+}
+#endif  // __TYPETABLE_H__
diff --git a/src/MapleFE/shared/include/vfy.h b/src/MapleFE/shared/include/vfy.h
index 208fbac48e56d9d79723eab468e09b3ab29761b9..279052d38eae4bf06f6a70f8b8bf7a5f37921741 100644
--- a/src/MapleFE/shared/include/vfy.h
+++ b/src/MapleFE/shared/include/vfy.h
@@ -18,7 +18,7 @@
 // which takes an ASTModule recently generated. At this point we have a complete
 // module with AST trees created by ASTBuilder.
 //
-// The verification is a top-down traversal on the AST trees. 
+// The verification is a top-down traversal on the AST trees.
 //
 // It carries on more than one jobs.
 // Verification : Checks the validity of semanteme
@@ -41,6 +41,7 @@
 #include "ast.h"
 #include "ast_attr.h"
 #include "ast_type.h"
+#include "ast_module.h"
 #include "container.h"
 #include "vfy_log.h"
 
@@ -51,7 +52,8 @@ class TreeNode;
 
 class Verifier {
 protected:
-  VfyLog    mLog;
+  VfyLog      mLog;
+  ModuleNode *mASTModule;
 
   ASTScope *mCurrScope;
 
@@ -72,7 +74,7 @@ protected:
 
   virtual void VerifyType(IdentifierNode*);
 public:
-  Verifier();
+  Verifier(ModuleNode *m);
   ~Verifier();
 
   void Do();
diff --git a/src/MapleFE/shared/src/Makefile b/src/MapleFE/shared/src/Makefile
index 0ee1fc974c86b0f241dedbf40cd28ac587716001..e09a8359da282bcbcfa5eb587cfb226eff3a9939 100644
--- a/src/MapleFE/shared/src/Makefile
+++ b/src/MapleFE/shared/src/Makefile
@@ -1,4 +1,4 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
 # 
 # OpenArkFE is licensed under the Mulan PSL v2.
 # You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -24,24 +24,36 @@ OBJS :=$(foreach obj,$(OBJ), $(BUILD)/$(obj))
 LIBOBJS :=$(patsubst $(BUILD)/main.o,,$(OBJS))
 DEPS :=$(foreach dep,$(DEP), $(BUILD)/$(dep))
 
-INCLUDES := -I $(MAPLEFE_ROOT)/shared/include \
-            -I $(MAPLEFE_ROOT)/$(LANG)/include \
-            -I . $(MAPLEALL_INC)
+GENDIR:=${BUILDDIR}/gen
 
-SHAREDLIB = shared.a
+SRCG:=$(wildcard ${GENDIR}/gen_*.cpp)
+OBJG:=$(patsubst %.cpp,%.o,$(SRCG))
+DEPG:=$(patsubst %.cpp,%.d,$(SRCG))
 
-.PHONY: all
-all: $(SHAREDLIB)
+GENASTDIR:=${BUILDDIR}/ast_gen/shared
+
+ASTSRCG:=$(wildcard ${GENASTDIR}/*.cpp)
+ASTOBJG:=$(patsubst %.cpp,%.o,$(ASTSRCG))
+ASTDEPG:=$(patsubst %.cpp,%.d,$(ASTSRCG))
+
+INCLUDES := -I $(MAPLEFE_ROOT)/shared/include -I ${GENASTDIR} -I ${GENDIR}
+
+SHAREDLIB := shared.a
+GENASTLIB := genast.a
+GENLIB    := gen.a
+
+.PHONY: all gen_doc clean
+
+all: $(BUILD)/$(SHAREDLIB) $(GENASTDIR)/$(GENASTLIB) $(GENDIR)/$(GENLIB)
 
 -include $(DEPS)
-.PHONY: clean
 
 vpath %.o $(BUILD)
 vpath %.d $(BUILD)
 
 #Pattern Rules
 $(BUILD)/%.o : %.cpp
-	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@ 
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
 
 $(BUILD)/%.d : %.cpp
 	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $< > $@
@@ -49,8 +61,31 @@ $(BUILD)/%.d : %.cpp
 	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
 	@rm -f $(BUILD)/$*.d.tmp
 
-$(SHAREDLIB) : $(OBJS)
+$(GENASTDIR)/%.cpp : gendoc
+
+gen_doc:
+	(cd $(MAPLEFE_ROOT); ./scripts/maplefe-autogen.py)
+
+$(GENASTDIR)/%.o : $(GENASTDIR)/%.cpp
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
+
+$(GENASTDIR)/%.d : $(GENASTDIR)/%.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $< > $@
+
+$(GENDIR)/%.o : $(GENDIR)/%.cpp
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
+
+$(GENDIR)/%.d : $(GENDIR)/%.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $< > $@
+
+$(BUILD)/$(SHAREDLIB) : $(LIBOBJS)
 	/usr/bin/ar rcs $(BUILD)/$(SHAREDLIB) $(LIBOBJS)
 
+$(GENASTDIR)/$(GENASTLIB) : $(ASTOBJG)
+	/usr/bin/ar rcs $(GENASTDIR)/$(GENASTLIB) $(ASTOBJG)
+
+$(GENDIR)/$(GENLIB) : $(OBJG)
+	/usr/bin/ar rcs $(GENDIR)/$(GENLIB) $(OBJG)
+
 clean:
 	rm -rf $(BUILD)
diff --git a/src/MapleFE/autogen/include/block_gen.h b/src/MapleFE/shared/src/appnode_pool.cpp
similarity index 54%
rename from src/MapleFE/autogen/include/block_gen.h
rename to src/MapleFE/shared/src/appnode_pool.cpp
index d2fbf1a80990fba82bf22399f9032a21c2bd280a..a2014c6148fb925f6a2f33eafa9efd9213d4af04 100644
--- a/src/MapleFE/autogen/include/block_gen.h
+++ b/src/MapleFE/shared/src/appnode_pool.cpp
@@ -12,28 +12,15 @@
 * FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PSL v2 for more details.
 */
-////////////////////////////////////////////////////////////////
-//                  Block Generation
-////////////////////////////////////////////////////////////////
-
-#ifndef __BLOCK_GEN_H__
-#define __BLOCK_GEN_H__
-
-#include "base_gen.h"
+#include "appnode_pool.h"
+#include "parser.h"
 
 namespace maplefe {
 
-class BlockGen : public BaseGen {
-public:
-  BlockGen(const char *dfile, const char *hfile, const char *cfile) :
-    BaseGen(dfile, hfile, cfile) {}
-  ~BlockGen(){}
-
-  void Generate();
-  void GenCppFile();
-  void GenHeaderFile();
-};
-
+AppealNode* AppealNodePool::NewAppealNode() {
+  AppealNode *node = (AppealNode*)mMP.Alloc(sizeof(AppealNode));
+  new (node) AppealNode();
+  return node;
 }
 
-#endif
+}
diff --git a/src/MapleFE/shared/src/ast.cpp b/src/MapleFE/shared/src/ast.cpp
index d33f7a7669a0975e4bef3bf5acb229b8672c1140..f42e21d7ff0442a6825f5ca3dcb6e92968630f91 100644
--- a/src/MapleFE/shared/src/ast.cpp
+++ b/src/MapleFE/shared/src/ast.cpp
@@ -54,228 +54,26 @@ static const char* GetOperatorName(OprId opr) {
 };
 
 //////////////////////////////////////////////////////////////////////////////////////
-//                             ASTTree
-//////////////////////////////////////////////////////////////////////////////////////
-
-ASTTree::ASTTree() {
-  mRootNode = NULL;
-  gASTBuilder.SetTreePool(&mTreePool);
-}
-
-ASTTree::~ASTTree() {
-}
-
-// Create tree node. Its children have been created tree nodes.
-// There are couple issueshere.
-//
-// 1. An sorted AppealNode could have NO tree node, because it may have NO RuleAction to
-//    create the sub tree. This happens if the RuleTable is just a temporary intermediate
-//    table created by Autogen, or its rule is just ONEOF without real syntax. Here
-//    is an example.
-//
-//       The AST after BuildAST() for a simple statment: c=a+b;
-//
-//       ======= Simplify Trees Dump SortOut =======
-//       [1] Table TblExpressionStatement@0: 2,3,
-//       [2:1] Table TblAssignment@0: 4,5,6,
-//       [3] Token
-//       [4:1] Token
-//       [5:2] Token
-//       [6:3] Table TblArrayAccess_sub1@2: 7,8,  <-- supposed to get a binary expression
-//       [7:1] Token                              <-- a
-//       [8:2] Table TblUnaryExpression_sub1@3: 9,10, <-- +b
-//       [9] Token
-//       [10:2] Token
-//
-//    Node [1] won't have a tree node at all since it has no Rule Action attached.
-//    Node [6] won't have a tree node either.
-//
-// 2. A binary operation like a+b could be parsed as (1) expression: a, and (2) a
-//    unary operation: +b. This is because we parse them in favor to ArrayAccess before
-//    Binary Operation. Usually to handle this issue, in some system like ANTLR,
-//    they require you to list the priority, by writing rules from higher priority to
-//    lower priority.
-//
-//    We are going to do a consolidation of the sub-trees, by converting smaller trees
-//    to a more compact bigger trees. However, to do this we want to set some rules.
-//    *) The parent AppealNode of these sub-trees has no tree node. So the conversion
-//       helps make the tree complete.
-
-TreeNode* ASTTree::NewTreeNode(AppealNode *appeal_node) {
-  TreeNode *sub_tree = NULL;
-
-  if (appeal_node->IsToken()) {
-    sub_tree = gASTBuilder.CreateTokenTreeNode(appeal_node->GetToken());
-    return sub_tree;
-  }
-
-  RuleTable *rule_table = appeal_node->GetTable();
-
-  for (unsigned i = 0; i < rule_table->mNumAction; i++) {
-    Action *action = rule_table->mActions + i;
-    gASTBuilder.mActionId = action->mId;
-    gASTBuilder.ClearParams();
-
-    for (unsigned j = 0; j < action->mNumElem; j++) {
-      // find the appeal node child
-      unsigned elem_idx = action->mElems[j];
-      AppealNode *child = appeal_node->GetSortedChildByIndex(elem_idx);
-      Param p;
-      p.mIsEmpty = true;
-      // There are 3 cases to handle.
-      // 1. child is token, we pass the token to param.
-      // 2. child is a sub appeal tree, but has no legal AST tree. For example,
-      //    a parameter list: '(' + param-lists + ')'.
-      //    if param-list is empty, it has no AST tree.
-      //    In this case, we sset mIsEmpty to true.
-      // 3. chidl is a sub appeal tree, and has a AST tree too.
-      if (child) {
-        TreeNode *tree_node = child->GetAstTreeNode();
-        if (!tree_node) {
-          if (child->IsToken()) {
-            p.mIsEmpty = false;
-            p.mIsTreeNode = false;
-            p.mData.mToken = child->GetToken();
-          }
-        } else {
-          p.mIsEmpty = false;
-          p.mIsTreeNode = true;
-          p.mData.mTreeNode = tree_node;
-        }
-      }
-      gASTBuilder.AddParam(p);
-    }
-
-    // For multiple actions of a rule, there should be only action which create tree.
-    // The others are just for adding attribute or else, and return the same tree
-    // with additional attributes.
-    sub_tree = gASTBuilder.Build();
-  }
-
-  if (sub_tree)
-    return sub_tree;
-
-  // It's possible that the Rule has no action, meaning it cannot create tree node.
-  // Now we have to do some manipulation. Please check if you need all of them.
-  sub_tree = Manipulate(appeal_node);
-
-  // It's possible that the sub tree is actually empty. For example, in a Parameter list
-  // ( params ). If 'params' is empty, it returns NULL.
-
-  return sub_tree;
-}
-
-// It's possible that we get NULL tree.
-TreeNode* ASTTree::Manipulate(AppealNode *appeal_node) {
-  TreeNode *sub_tree = NULL;
+//                               TreeNode
+//////////////////////////////////////////////////////////////////////////////////////
 
-  std::vector<TreeNode*> child_trees;
-  std::vector<AppealNode*>::iterator cit = appeal_node->mSortedChildren.begin();
-  for (; cit != appeal_node->mSortedChildren.end(); cit++) {
-    AppealNode *a_node = *cit;
-    TreeNode *t_node = a_node->GetAstTreeNode();
-    if (t_node)
-      child_trees.push_back(t_node);
-  }
+void TreeNode::AddAsTypes(TreeNode *type) {
+  if (!type)
+    return;
 
-  // If we have one and only one child's tree node, we take it.
-  if (child_trees.size() == 1) {
-    sub_tree = child_trees[0];
-    if (sub_tree)
-      return sub_tree;
-    else
-      MERROR("We got a broken AST tree, not connected sub tree.");
-  }
-
-  // For the tree having two children, there are a few approaches to further
-  // manipulate them in order to obtain better AST.
-  //
-  // 1. There are cases like (type)value, but they are not recoganized as cast.
-  //    Insteand they are seperated into two nodes, one is (type), the other value.
-  //    So we define ParenthesisNode for (type), and build a CastNode over here.
-  //
-  // 2. There are cases like a+b could be parsed as "a" and "+b", a symbol and a
-  //    unary operation. However, we do prefer binary operation than unary. So a
-  //    combination is needed here, especially when the parent node is NULL.
-  if (child_trees.size() == 2) {
-    TreeNode *child_a = child_trees[0];
-    TreeNode *child_b = child_trees[1];
-
-    sub_tree = Manipulate2Cast(child_a, child_b);
-    if (sub_tree)
-      return sub_tree;
-
-    sub_tree = Manipulate2Binary(child_a, child_b);
-    if (sub_tree)
-      return sub_tree;
-  }
-
-  // In the end, if we still have no suitable solution to create the tree,
-  //  we will put subtrees into a PassNode to pass to parent.
-  if (child_trees.size() > 0) {
-    PassNode *pass = (PassNode*)BuildPassNode();
-    std::vector<TreeNode*>::iterator child_it = child_trees.begin();
-    for (; child_it != child_trees.end(); child_it++)
-      pass->AddChild(*child_it);
-    return pass;
-  }
-
-  // It's possible that we get a Null tree.
-  return sub_tree;
-}
-
-TreeNode* ASTTree::Manipulate2Cast(TreeNode *child_a, TreeNode *child_b) {
-  if (child_a->IsParenthesis()) {
-    ParenthesisNode *type = (ParenthesisNode*)child_a;
-    CastNode *n = (CastNode*)mTreePool.NewTreeNode(sizeof(CastNode));
-    new (n) CastNode();
-    n->SetDestType(type->GetExpr());
-    n->SetExpr(child_b);
-    return n;
-  }
-  return NULL;
-}
-
-TreeNode* ASTTree::Manipulate2Binary(TreeNode *child_a, TreeNode *child_b) {
-  if (child_b->IsUnaOperator()) {
-    UnaOperatorNode *unary = (UnaOperatorNode*)child_b;
-    unsigned property = GetOperatorProperty(unary->GetOprId());
-    if ((property & Binary) && (property & Unary)) {
-      std::cout << "Convert unary --> binary" << std::endl;
-      TreeNode *unary_sub = unary->GetOpnd();
-      TreeNode *binary = BuildBinaryOperation(child_a, unary_sub, unary->GetOprId());
-      return binary;
-    }
+  if (type->IsPass()) {
+    PassNode *pass_node = (PassNode*)type;
+    for (unsigned i = 0; i < pass_node->GetChildrenNum(); i++)
+      AddAsTypes(pass_node->GetChild(i));
+  } else if (type->IsAsType()) {
+    AsTypeNode *asn = (AsTypeNode*)type;
+    AddAsType(asn);
+    SETPARENT(asn);
+  } else {
+    MERROR("unsupported as-type in AddAsType.");
   }
-  return NULL;
-}
-
-void ASTTree::Dump(unsigned indent) {
-  DUMP0("== Sub Tree ==");
-  mRootNode->Dump(indent);
-  std::cout << std::endl;
-}
-
-TreeNode* ASTTree::BuildBinaryOperation(TreeNode *childA, TreeNode *childB, OprId id) {
-  BinOperatorNode *n = (BinOperatorNode*)mTreePool.NewTreeNode(sizeof(BinOperatorNode));
-  new (n) BinOperatorNode(id);
-  n->mOpndA = childA;
-  n->mOpndB = childB;
-  childA->SetParent(n);
-  childB->SetParent(n);
-  return n;
 }
 
-TreeNode* ASTTree::BuildPassNode() {
-  PassNode *n = (PassNode*)mTreePool.NewTreeNode(sizeof(PassNode));
-  new (n) PassNode();
-  return n;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////
-//                               TreeNode
-//////////////////////////////////////////////////////////////////////////////////////
-
 // return true iff:
 //   both are type nodes, either UserTypeNode or PrimTypeNode, and
 //   they are type equal.
@@ -318,19 +116,231 @@ void TreeNode::DumpIndentation(unsigned ind) {
 void PackageNode::Dump(unsigned indent) {
   DumpIndentation(indent);
   DUMP0_NORETURN("package ");
-  DUMP0_NORETURN(mName);
+  mPackage->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          DeclareNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void DeclareNode::AddDecl(TreeNode *t) {
+  if (!t)
+    return;
+
+  if (t->IsPass()) {
+    PassNode *n = (PassNode*)t;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddDecl(child);
+    }
+  } else {
+    mDecls.PushBack(t);
+    SETPARENT(t);
+  }
+}
+
+void DeclareNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("declare ");
+
+  for (unsigned i = 0; i < mDecls.GetNum(); i++) {
+    TreeNode *tree = mDecls.ValueAtIndex(i);
+    tree->Dump(0);
+  }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 //                          ImportNode
 //////////////////////////////////////////////////////////////////////////////////////
 
+void ImportNode::AddPair(TreeNode *t) {
+  if (t->IsPass()) {
+    PassNode *n = (PassNode*)t;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddPair(child);
+    }
+  } else if (t->IsXXportAsPair()) {
+    mPairs.PushBack((XXportAsPairNode*)t);
+    SETPARENT(t);
+  } else {
+    // We create a new pair to save 't'.
+    XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+    new (n) XXportAsPairNode();
+    n->SetBefore(t);
+    mPairs.PushBack(n);
+    SETPARENT(n);
+  }
+}
+
+void ImportNode::AddDefaultPair(TreeNode *t) {
+  if (t->IsPass()) {
+    PassNode *n = (PassNode*)t;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddDefaultPair(child);
+    }
+  } else if (t->IsXXportAsPair()) {
+    XXportAsPairNode *p = (XXportAsPairNode*)t;
+    p->SetIsDefault();
+    mPairs.PushBack((XXportAsPairNode*)p);
+    SETPARENT(p);
+  } else {
+    // We create a new pair to save 't'.
+    XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+    new (n) XXportAsPairNode();
+    n->SetBefore(t);
+    n->SetIsDefault();
+    mPairs.PushBack(n);
+    SETPARENT(n);
+  }
+}
+
+void ImportNode::AddSinglePair(TreeNode *before, TreeNode *after) {
+  // We create a new pair
+  XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+  new (n) XXportAsPairNode();
+  n->SetBefore(before);
+  n->SetAfter(after);
+  n->SetIsSingle();
+  mPairs.PushBack(n);
+  SETPARENT(n);
+}
+
 void ImportNode::Dump(unsigned indent) {
   DumpIndentation(indent);
   DUMP0_NORETURN("import ");
   if (IsImportStatic())
     DUMP0_NORETURN("static ");
-  DUMP0_NORETURN(mName);
+
+  if (mPairs.GetNum() > 0) {
+    DUMP0_NORETURN('{');
+    for (unsigned i = 0; i < mPairs.GetNum(); i++) {
+      XXportAsPairNode *p = GetPair(i);
+      p->Dump(0);
+      if (i < mPairs.GetNum() - 1)
+        DUMP0_NORETURN(',');
+    }
+    DUMP0_NORETURN("} ");
+  }
+
+  if (mTarget)
+    mTarget->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          ExportNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void ExportNode::AddPair(TreeNode *t) {
+  if (t->IsPass()) {
+    PassNode *n = (PassNode*)t;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddPair(child);
+    }
+  } else if (t->IsXXportAsPair()) {
+    mPairs.PushBack((XXportAsPairNode*)t);
+    SETPARENT(t);
+  } else {
+    // We create a new pair to save 't'.
+    XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+    new (n) XXportAsPairNode();
+    n->SetBefore(t);
+    mPairs.PushBack(n);
+    SETPARENT(n);
+  }
+}
+
+void ExportNode::AddDefaultPair(TreeNode *t) {
+  if (t->IsPass()) {
+    PassNode *n = (PassNode*)t;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddPair(child);
+    }
+  } else if (t->IsXXportAsPair()) {
+    XXportAsPairNode *p = (XXportAsPairNode*)t;
+    p->SetIsDefault();
+    mPairs.PushBack(p);
+    SETPARENT(t);
+  } else {
+    // We create a new pair to save 't'.
+    XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+    new (n) XXportAsPairNode();
+    n->SetBefore(t);
+    n->SetIsDefault();
+    mPairs.PushBack(n);
+    SETPARENT(n);
+  }
+}
+
+void ExportNode::AddSinglePair(TreeNode *before, TreeNode *after) {
+  // We create a new pair
+  XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+  new (n) XXportAsPairNode();
+  n->SetBefore(before);
+  n->SetAfter(after);
+  n->SetIsSingle();
+  mPairs.PushBack(n);
+  SETPARENT(n);
+}
+
+void ExportNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("export ");
+  if (mIsExportType)
+    DUMP0_NORETURN("type ");
+
+  if (mPairs.GetNum() > 0) {
+    DUMP0_NORETURN('{');
+    for (unsigned i = 0; i < mPairs.GetNum(); i++) {
+      XXportAsPairNode *p = GetPair(i);
+      p->Dump(0);
+      if (i < mPairs.GetNum() - 1)
+        DUMP0_NORETURN(',');
+    }
+    DUMP0_NORETURN("} ");
+  }
+
+  if (mTarget)
+    mTarget->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          XXportAsPair
+//////////////////////////////////////////////////////////////////////////////////////
+
+void XXportAsPairNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  if (IsEverything()) {
+    DUMP0_NORETURN(" *");
+    if (mBefore) {
+      DUMP0_NORETURN(" as ");
+      mBefore->Dump(0);
+    }
+  } else if (IsDefault()) {
+    DUMP0_NORETURN(" default");
+    if (mBefore) {
+      DUMP0_NORETURN(" as ");
+      mBefore->Dump(0);
+    }
+  } else if (IsSingle()) {
+    DUMP0_NORETURN(" SINGLE ");
+    if (mBefore)
+      mBefore->Dump(0);
+    if (mAfter) {
+      DUMP0_NORETURN(" as ");
+      mAfter->Dump(0);
+    }
+  } else {
+    MASSERT(mBefore);
+    mBefore->Dump(0);
+    if (mAfter) {
+      DUMP0_NORETURN(" as ");
+      mAfter->Dump(0);
+    }
+  }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
@@ -358,15 +368,12 @@ void AnnotationTypeNode::Dump(unsigned indent) {
 //                          CastNode
 //////////////////////////////////////////////////////////////////////////////////////
 
-const char* CastNode::GetName() {
-  if (mName)
-    return mName;
+const char* CastNode::GetDumpName() {
   std::string name = "(";
   name += mDestType->GetName();
   name += ")";
   name += mExpr->GetName();
-  mName = gStringPool.FindString(name);
-  return mName;
+  return gStringPool.FindString(name);
 }
 
 void CastNode::Dump(unsigned indent) {
@@ -390,6 +397,19 @@ void AssertNode::Dump(unsigned indent) {
     mMsg->Dump(0);
 }
 
+//////////////////////////////////////////////////////////////////////////////////////
+//                          TerOpeartorNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void TerOperatorNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  mOpndA->Dump(0);
+  DUMP0_NORETURN(" ? ");
+  mOpndB->Dump(0);
+  DUMP0_NORETURN(" : ");
+  mOpndC->Dump(0);
+}
+
 //////////////////////////////////////////////////////////////////////////////////////
 //                          BinOperatorNode
 //////////////////////////////////////////////////////////////////////////////////////
@@ -429,11 +449,13 @@ void UnaOperatorNode::Dump(unsigned indent) {
   const char *name = GetOperatorName(mOprId);
   DumpIndentation(indent);
   if (IsPost()) {
-    mOpnd->Dump(indent + 2);
+    mOpnd->Dump(0);
+    DUMP0_NORETURN(' ');
     DUMP0(name);
   } else {
-    DUMP0(name);
-    mOpnd->Dump(indent + 2);
+    DUMP0_NORETURN(name);
+    DUMP0_NORETURN(' ');
+    mOpnd->Dump(0);
   }
 }
 
@@ -441,17 +463,73 @@ void UnaOperatorNode::Dump(unsigned indent) {
 //                           FieldNode
 //////////////////////////////////////////////////////////////////////////////////////
 
-// Right now it's major work is to init the name
-void FieldNode::Init() {
-  std::string name = mUpper->GetName();
-  name += '.';
-  name += mField->GetName();
-  mName = gStringPool.FindString(name);
+void FieldNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  mUpper->Dump(0);
+  DUMP0_NORETURN('.');
+  mField->Dump(0);
 }
 
-void FieldNode::Dump(unsigned indent) {
+//////////////////////////////////////////////////////////////////////////////////////
+//                           TypeAlias Node
+//////////////////////////////////////////////////////////////////////////////////////
+
+void TypeAliasNode::SetId(UserTypeNode *id) {
+  mId = id;
+  SETPARENT(mId);
+}
+
+void TypeAliasNode::SetAlias(TreeNode *n) {
+  mAlias = n;
+  SETPARENT(mAlias);
+}
+
+void TypeAliasNode::Dump(unsigned indent) {
   DumpIndentation(indent);
-  DUMP0_NORETURN(mName);
+  DUMP0_NORETURN(" type ");
+  mId->Dump(0);
+  DUMP0_NORETURN(" = ");
+  mAlias->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                           ConditionalType Node
+//////////////////////////////////////////////////////////////////////////////////////
+
+void ConditionalTypeNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  mTypeA->Dump(0);
+  DUMP0_NORETURN(" extends ");
+  mTypeB->Dump(0);
+  DUMP0_NORETURN(" ? ");
+  mTypeC->Dump(0);
+  DUMP0_NORETURN(" : ");
+  mTypeD->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                           AsType Node
+//////////////////////////////////////////////////////////////////////////////////////
+
+void AsTypeNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN(" as ");
+  TreeNode *type = GetType();
+  type->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                           type parameter & type argument
+//////////////////////////////////////////////////////////////////////////////////////
+
+void TypeParameterNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  TreeNode *id = GetId();
+  DUMP0_NORETURN(id->GetName());
+  if (mDefault) {
+    DUMP0_NORETURN("=");
+    DUMP0_NORETURN(mDefault->GetName());
+  }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
@@ -464,9 +542,9 @@ void NewNode::ReplaceChild(TreeNode *old_child, TreeNode *new_child) {
     SetId(new_child);
     return;
   } else {
-    for (unsigned i = 0; i < GetParamsNum(); i++) {
-      if (GetParam(i) == old_child)
-        mParams.SetElem(i, new_child);
+    for (unsigned i = 0; i < GetArgsNum(); i++) {
+      if (GetArg(i) == old_child)
+        mArgs.SetElem(i, new_child);
     }
   }
 }
@@ -475,30 +553,64 @@ void NewNode::Dump(unsigned indent) {
   DumpIndentation(indent);
   DUMP0_NORETURN("new ");
   TreeNode *id = GetId();
-  id->Dump(0);
-  //DUMP0_NORETURN(id->GetName());
+  if (id->IsLambda()) {
+    LambdaNode *lmd = (LambdaNode*)id;
+    lmd->Dump(0);
+  } else {
+    DUMP0_NORETURN(id->GetName());
+    DUMP0_NORETURN("(");
+    for (unsigned i = 0; i < GetArgsNum(); i++) {
+      TreeNode *arg = GetArg(i);
+      arg->Dump(0);
+      if (i < GetArgsNum() - 1)
+        DUMP0_NORETURN(",");
+    }
+    DUMP0_NORETURN(")");
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          DeleteNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void DeleteNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN(" delete ");
+  if (mExpr)
+    mExpr->Dump(0);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 //                          CallNode
 //////////////////////////////////////////////////////////////////////////////////////
 
-void CallNode::Init() {
-  // Init the mName;
-  if (mMethod->IsIdentifier() || mMethod->IsField()) {
-    mName = mMethod->GetName();
+void CallNode::AddTypeArgument(TreeNode *arg) {
+  if (arg->IsPass()) {
+    PassNode *n = (PassNode*)arg;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddTypeArgument(child);
+    }
   } else {
-    MASSERT(0 && "Unsupported method type in CallNode");
+    mTypeArguments.PushBack(arg);
+    SETPARENT(arg);
   }
 }
 
-void CallNode::AddArg(TreeNode *arg) {
-  mArgs.Merge(arg);
-}
-
 void CallNode::Dump(unsigned indent) {
   DumpIndentation(indent);
-  DUMP0_NORETURN(mName);
+  mMethod->Dump(0);
+  if (GetTypeArgumentsNum() > 0) {
+    DUMP0_NORETURN("<");
+    for (unsigned i = 0; i < GetTypeArgumentsNum(); i++) {
+      TreeNode *arg = GetTypeArgumentAtIndex(i);
+      arg->Dump(0);
+      if (i < GetTypeArgumentsNum() - 1)
+        DUMP0_NORETURN(",");
+    }
+    DUMP0_NORETURN(">");
+  }
+
   DUMP0_NORETURN("(");
   mArgs.Dump(0);
   DUMP0_NORETURN(")");
@@ -515,8 +627,8 @@ void DimensionNode::Merge(const TreeNode *node) {
 
   if (node->IsDimension()) {
     DimensionNode *n = (DimensionNode *)node;
-    for (unsigned i = 0; i < n->GetDimsNum(); i++)
-      AddDim(n->GetNthDim(i));
+    for (unsigned i = 0; i < n->GetDimensionsNum(); i++)
+      AddDimension(n->GetDimension(i));
   } else if (node->IsPass()) {
     PassNode *n = (PassNode*)node;
     for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
@@ -532,9 +644,22 @@ void DimensionNode::Merge(const TreeNode *node) {
 //                          IdentifierNode
 //////////////////////////////////////////////////////////////////////////////////////
 
+void IdentifierNode::Release() {
+  if (mDims)
+     mDims->Release();
+  mAttrs.Release();
+  mAnnotations.Release();
+}
+
 void IdentifierNode::Dump(unsigned indent) {
   DumpIndentation(indent);
-  DUMP0_NORETURN(mName);
+  if (mIsRest)
+    DUMP0_NORETURN("...");
+  DUMP0_NORETURN(GetName());
+  if (mIsOptional)
+    DUMP0_NORETURN('?');
+  if (IsNonNull())
+    DUMP0_NORETURN('!');
   if (mInit) {
     DUMP0_NORETURN('=');
     mInit->Dump(0);
@@ -546,12 +671,283 @@ void IdentifierNode::Dump(unsigned indent) {
   }
 }
 
+//////////////////////////////////////////////////////////////////////////////////////
+//                          DeclNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void DeclNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  switch (mProp) {
+  case JS_Var:
+    DUMP0_NORETURN("js_var ");
+    break;
+  case JS_Let:
+    DUMP0_NORETURN("js_let ");
+    break;
+  case JS_Const:
+    DUMP0_NORETURN("js_const ");
+    break;
+  default:
+    break;
+  }
+  DUMP0_NORETURN("Decl: ");
+  mVar->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          ArrayElement and ArrayLiteral
+//////////////////////////////////////////////////////////////////////////////////////
+
+void ArrayElementNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  mArray->Dump(0);
+  for (unsigned i = 0; i < mExprs.GetNum(); i++) {
+    DUMP0_NORETURN("[");
+    mExprs.ValueAtIndex(i)->Dump(0);
+    DUMP0_NORETURN("]");
+  }
+}
+
+void ArrayLiteralNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("[");
+  for (unsigned i = 0; i < GetLiteralsNum(); i++) {
+    GetLiteral(i)->Dump(0);
+    if (i < GetLiteralsNum() - 1)
+      DUMP0_NORETURN(",");
+  }
+  DUMP0_NORETURN("]");
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          BindingElement and BindingPattern
+//////////////////////////////////////////////////////////////////////////////////////
+
+void BindingElementNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  if (mVariable)
+    mVariable->Dump(0);
+  DUMP0_NORETURN(":");
+  if (mElement)
+    mElement->Dump(0);
+}
+
+void BindingPatternNode::AddElement(TreeNode *tree) {
+  if (tree->IsBindingElement() || tree->IsBindingPattern()) {
+    mElements.PushBack(tree);
+    SETPARENT(tree);
+  } else if (tree->IsPass()) {
+    PassNode *pass = (PassNode*)tree;
+    for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
+      TreeNode *child = pass->GetChild(i);
+      AddElement(child);
+    }
+  } else {
+    MERROR("Unsupported element of binding pattern.");
+  }
+}
+
+void BindingPatternNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("{");
+  for (unsigned i = 0; i < mElements.GetNum(); i++) {
+    TreeNode *elem = GetElement(i);
+    elem->Dump(0);
+    if (i != mElements.GetNum()-1)
+      DUMP0_NORETURN(", ");
+  }
+  DUMP0_NORETURN("}");
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          StructNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void StructNode::AddTypeParam(TreeNode *param) {
+  if (param->IsPass()) {
+    PassNode *n = (PassNode*)param;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddTypeParam(child);
+    }
+  } else {
+    MASSERT(param->IsTypeParameter());
+    mTypeParams.PushBack((TypeParameterNode*)param);
+    SETPARENT(param);
+  }
+}
+
+void StructNode::AddSuper(TreeNode *the_super) {
+  if (!the_super)
+    return;
+
+  if (the_super->IsPass()) {
+    PassNode *pass_node = (PassNode*)the_super;
+    for (unsigned i = 0; i < pass_node->GetChildrenNum(); i++)
+      AddSuper(pass_node->GetChild(i));
+  } else {
+    mSupers.PushBack(the_super);
+  }
+}
+
+// Child could be a field or index signature.
+void StructNode::AddChild(TreeNode *field) {
+  if (field->IsPass()) {
+    PassNode *pass = (PassNode*)field;
+    for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
+      TreeNode *child = pass->GetChild(i);
+      AddChild(child);
+    }
+  } else if (field->IsIdentifier() ||
+             field->IsComputedName() ||
+             field->IsLiteral()) {
+    AddField(field);
+    SETPARENT(field);
+  } else if (field->IsFunction()) {
+    AddMethod((FunctionNode*)field);
+    SETPARENT(field);
+  } else if (field->IsNumIndexSig()) {
+    SetNumIndexSig((NumIndexSigNode*)field);
+    SETPARENT(field);
+  } else if (field->IsStrIndexSig()) {
+    SetStrIndexSig((StrIndexSigNode*)field);
+    SETPARENT(field);
+  } else
+    MERROR("Unsupported struct field type.");
+}
+
+void NumIndexSigNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  if (mDataType)
+    mDataType->Dump(0);
+}
+
+void StrIndexSigNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  if (mDataType)
+    mDataType->Dump(0);
+}
+
+void StructNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  switch (mProp) {
+  case SProp_CStruct:
+    DUMP0_NORETURN("struct: ");
+    break;
+  case SProp_TSInterface:
+    DUMP0_NORETURN("ts_interface: ");
+    break;
+  case SProp_TSEnum:
+    DUMP0_NORETURN("ts_enum: ");
+    break;
+  default:
+    break;
+  }
+
+  if (mStructId)
+    mStructId->Dump(0);
+
+  if (mTypeParams.GetNum() > 0) {
+    DUMP0_NORETURN("<");
+    for (unsigned i = 0; i < mTypeParams.GetNum(); i++) {
+      TypeParameterNode *node = mTypeParams.ValueAtIndex(i);
+      node->Dump(0);
+      DUMP0_NORETURN(",");
+    }
+    DUMP0_NORETURN(">");
+  }
+
+  DUMP0_NORETURN(" {");
+
+  if (mNumIndexSig) {
+    DUMP0_NORETURN("numeric index type: ");
+    mNumIndexSig->Dump(0);
+  }
+
+  if (mStrIndexSig) {
+    DUMP0_NORETURN("string index type: ");
+    mStrIndexSig->Dump(0);
+  }
+
+  for (unsigned i = 0; i < mFields.GetNum(); i++) {
+    mFields.ValueAtIndex(i)->Dump(0);
+    if (i != mFields.GetNum()-1)
+      DUMP0_NORETURN(";");
+  }
+
+  for (unsigned i = 0; i < mMethods.GetNum(); i++) {
+    mMethods.ValueAtIndex(i)->Dump(0);
+    if (i != mMethods.GetNum()-1)
+      DUMP0_NORETURN(";");
+  }
+
+  DUMP0_NORETURN(" }");
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          StructLiteralNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void StructLiteralNode::AddField(TreeNode *tree) {
+  if (tree->IsFieldLiteral()) {
+    FieldLiteralNode *fl = (FieldLiteralNode*)tree;
+    mFields.PushBack(fl);
+    SETPARENT(fl);
+  } else if (tree->IsFunction()) {
+    FunctionNode *node = (FunctionNode*)tree;
+    FieldLiteralNode *func_lit = (FieldLiteralNode*)gTreePool.NewTreeNode(sizeof(FieldLiteralNode));
+    new (func_lit) FieldLiteralNode();
+    TreeNode *func_name = node->GetFuncName();
+    if (func_name) {
+      MASSERT(func_name->IsIdentifier() || func_name->IsComputedName());
+      func_lit->SetFieldName(func_name);
+    }
+    func_lit->SetLiteral(node);
+    mFields.PushBack(func_lit);
+    SETPARENT(func_lit);
+  } else if (tree->IsLiteral() ||
+             tree->IsIdentifier() ||
+             tree->IsField() ||
+             tree->IsCall() ||
+             tree->IsArrayElement()) {
+    FieldLiteralNode *fln = (FieldLiteralNode*)gTreePool.NewTreeNode(sizeof(FieldLiteralNode));
+    new (fln) FieldLiteralNode();
+    fln->SetLiteral(tree);
+    mFields.PushBack(fln);
+    SETPARENT(fln);
+  } else if (tree->IsPass()) {
+    PassNode *pass = (PassNode*)tree;
+    for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
+      TreeNode *child = pass->GetChild(i);
+      AddField(child);
+    }
+  } else {
+    MASSERT(0 && "unsupported.");
+  }
+}
+
+void StructLiteralNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN(" {");
+  for (unsigned i = 0; i < mFields.GetNum(); i++) {
+    FieldLiteralNode *fl = GetField(i);
+    if (fl->mFieldName)
+      fl->mFieldName->Dump(0);
+    DUMP0_NORETURN(":");
+    fl->mLiteral->Dump(0);
+    if (i != mFields.GetNum()-1)
+      DUMP0_NORETURN(", ");
+  }
+  DUMP0_NORETURN("}");
+}
+
 //////////////////////////////////////////////////////////////////////////////////////
 //                          VarListNode
 //////////////////////////////////////////////////////////////////////////////////////
 
 void VarListNode::AddVar(IdentifierNode *n) {
   mVars.PushBack(n);
+  SETPARENT(n);
 }
 
 // Merge a node.
@@ -576,7 +972,6 @@ void VarListNode::Merge(TreeNode *n) {
 
 void VarListNode::Dump(unsigned indent) {
   DumpIndentation(indent);
-  DUMP0_NORETURN("var:");
   for (unsigned i = 0; i < mVars.GetNum(); i++) {
     //DUMP0_NORETURN(mVars.ValueAtIndex(i)->GetName());
     mVars.ValueAtIndex(i)->Dump(0);
@@ -585,6 +980,36 @@ void VarListNode::Dump(unsigned indent) {
   }
 }
 
+//////////////////////////////////////////////////////////////////////////////////////
+//                          NamespaceNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void NamespaceNode::AddBody(TreeNode *tree) {
+  if (tree->IsPass()) {
+    PassNode *p = (PassNode*)tree;
+    for (unsigned i = 0; i < p->GetChildrenNum(); i++) {
+      TreeNode *child = p->GetChild(i);
+      AddBody(child);
+    }
+  } else {
+    AddElement(tree);
+    SETPARENT(tree);
+  }
+}
+
+void NamespaceNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("namespace  ");
+  if (mId)
+    mId->Dump(0);
+  DUMP_RETURN();
+  for (unsigned i = 0; i < mElements.GetNum(); i++) {
+    DumpIndentation(indent + 2);
+    mElements.ValueAtIndex(i)->Dump(0);
+    DUMP_RETURN();
+  }
+}
+
 //////////////////////////////////////////////////////////////////////////////////////
 //                          ExprListNode
 //////////////////////////////////////////////////////////////////////////////////////
@@ -594,8 +1019,8 @@ void VarListNode::Dump(unsigned indent) {
 void ExprListNode::Merge(TreeNode *n) {
   if (n->IsExprList()) {
     ExprListNode *expr_list = (ExprListNode*)n;
-    for (unsigned i = 0; i < expr_list->GetNum(); i++)
-      AddExpr(expr_list->ExprAtIndex(i));
+    for (unsigned i = 0; i < expr_list->GetExprsNum(); i++)
+      AddExpr(expr_list->GetExprAtIndex(i));
   } else if (n->IsPass()) {
     PassNode *p = (PassNode*)n;
     for (unsigned i = 0; i < p->GetChildrenNum(); i++) {
@@ -606,11 +1031,29 @@ void ExprListNode::Merge(TreeNode *n) {
     AddExpr(n);
 }
 
-void ExprListNode::Dump(unsigned indent) {
+void ExprListNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  for (unsigned i = 0; i < mExprs.GetNum(); i++) {
+    mExprs.ValueAtIndex(i)->Dump(0);
+    if (i != mExprs.GetNum()-1)
+      DUMP0_NORETURN(",");
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          TemplateLiteralNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void TemplateLiteralNode::Dump(unsigned indent) {
   DumpIndentation(indent);
-  for (unsigned i = 0; i < mExprs.GetNum(); i++) {
-    mExprs.ValueAtIndex(i)->Dump(0);
-    if (i != mExprs.GetNum()-1)
+  DUMP0_NORETURN(" template-literal: ");
+  for (unsigned i = 0; i < mTrees.GetNum(); i++) {
+    TreeNode *n = mTrees.ValueAtIndex(i);
+    if (n)
+      n->Dump(0);
+    else
+      DUMP0_NORETURN("NULL");
+    if (i < mStrings.GetNum() - 1)
       DUMP0_NORETURN(",");
   }
 }
@@ -624,11 +1067,11 @@ void LiteralNode::InitName() {
   switch (mData.mType) {
   case LT_NullLiteral:
     s = "null";
-    mName = gStringPool.FindString(s);
+    mStrIdx = gStringPool.GetStrIdx(s);
     break;
   case LT_ThisLiteral:
     s = "this";
-    mName = gStringPool.FindString(s);
+    mStrIdx = gStringPool.GetStrIdx(s);
     break;
   case LT_IntegerLiteral:
   case LT_DoubleLiteral:
@@ -639,7 +1082,7 @@ void LiteralNode::InitName() {
   case LT_NA:
   default:
     s = "<NA>";
-    mName = gStringPool.FindString(s);
+    mStrIdx = gStringPool.GetStrIdx(s);
     break;
   }
 }
@@ -657,7 +1100,9 @@ void LiteralNode::Dump(unsigned indent) {
     DUMP0_NORETURN(mData.mData.mFloat);
     break;
   case LT_StringLiteral:
-    DUMP0_NORETURN(mData.mData.mStr);
+    DUMP0_NORETURN("\"");
+    DUMP0_NORETURN(gStringPool.GetStringFromStrIdx(mData.mData.mStrIdx));
+    DUMP0_NORETURN("\"");
     break;
   case LT_BooleanLiteral:
     if(mData.mData.mBool == true)
@@ -679,11 +1124,115 @@ void LiteralNode::Dump(unsigned indent) {
   case LT_ThisLiteral:
     DUMP0_NORETURN("this");
     break;
+  case LT_SuperLiteral:
+    DUMP0_NORETURN("super");
+    break;
+  case LT_VoidLiteral:
+    DUMP0_NORETURN("void");
+    break;
   case LT_NA:
   default:
     DUMP0_NORETURN("NA Token:");
     break;
   }
+
+  if (mInit) {
+    DUMP0_NORETURN(" = ");
+    mInit->Dump(0);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          RegExprNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void RegExprNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP1_NORETURN("reg expr : ", mData.mExpr);
+  if (mData.mFlags)
+    DUMP1_NORETURN(" ", mData.mFlags);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          ThrowNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void ThrowNode::AddException(TreeNode *t) {
+  if (t->IsPass()) {
+    PassNode *pass_node = (PassNode*)t;
+    for (unsigned i = 0; i < pass_node->GetChildrenNum(); i++)
+      AddException(pass_node->GetChild(i));
+  } else {
+    mExceptions.PushBack(t);
+    SETPARENT(t);
+  }
+}
+
+void ThrowNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("throw ");
+  for (unsigned i = 0; i < GetExceptionsNum(); i++) {
+    TreeNode *t = GetExceptionAtIndex(i);
+    t->Dump(0);
+    if (i < GetExceptionsNum() - 1)
+      DUMP0_NORETURN(", ");
+  }
+  DUMP_RETURN();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                          Try, Catch, Finally nodes
+//////////////////////////////////////////////////////////////////////////////////////
+
+void TryNode::AddCatch(TreeNode *t) {
+  if (t->IsPass()) {
+    PassNode *pass_node = (PassNode*)t;
+    for (unsigned i = 0; i < pass_node->GetChildrenNum(); i++)
+      AddCatch(pass_node->GetChild(i));
+  } else {
+    MASSERT(t->IsCatch());
+    mCatches.PushBack((CatchNode*)t);
+    SETPARENT(t);
+  }
+}
+
+void TryNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("try ");
+  if (mBlock)
+    mBlock->Dump(indent + 2);
+  for (unsigned i = 0; i < GetCatchesNum(); i++) {
+    CatchNode *c = GetCatchAtIndex(i);
+    c->Dump(indent);
+  }
+  if (mFinally)
+    mFinally->Dump(indent);
+}
+
+void CatchNode::AddParam(TreeNode *t) {
+  if (t->IsPass()) {
+    PassNode *pass_node = (PassNode*)t;
+    for (unsigned i = 0; i < pass_node->GetChildrenNum(); i++)
+      AddParam(pass_node->GetChild(i));
+  } else {
+    mParams.PushBack(t);
+    SETPARENT(t);
+  }
+}
+
+void CatchNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("catch(");
+  DUMP0_NORETURN(")");
+  if (mBlock)
+    mBlock->Dump(indent + 2);
+}
+
+void FinallyNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("finally ");
+  if (mBlock)
+    mBlock->Dump(indent + 2);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
@@ -706,13 +1255,20 @@ void ReturnNode::Dump(unsigned ind) {
     GetResult()->Dump(0);
 }
 
-CondBranchNode::CondBranchNode() {
-  mKind = NK_CondBranch;
-  mCond = NULL;
-  mTrueBranch = NULL;
-  mFalseBranch = NULL;
+void YieldNode::Dump(unsigned ind) {
+  DumpLabel(ind);
+  DumpIndentation(ind);
+  if (mIsTransfer)
+    DUMP0_NORETURN("yield* ");
+  else
+    DUMP0_NORETURN("yield ");
+  if (GetResult())
+    GetResult()->Dump(0);
 }
 
+CondBranchNode::CondBranchNode() : TreeNode(NK_CondBranch),
+  mCond(NULL), mTrueBranch(NULL), mFalseBranch(NULL) {}
+
 void CondBranchNode::Dump(unsigned ind) {
   DumpLabel(ind);
   DumpIndentation(ind);
@@ -732,11 +1288,61 @@ void CondBranchNode::Dump(unsigned ind) {
 void BreakNode::Dump(unsigned ind) {
   DumpLabel(ind);
   DumpIndentation(ind);
-  DUMP0_NORETURN("break ");
-  GetTarget()->Dump(0);
+  DUMP0_NORETURN("break:");
+  if (GetTarget())
+    GetTarget()->Dump(0);
+  DUMP_RETURN();
+}
+
+void ContinueNode::Dump(unsigned ind) {
+  DumpLabel(ind);
+  DumpIndentation(ind);
+  DUMP0_NORETURN("continue:");
+  if (GetTarget())
+    GetTarget()->Dump(0);
   DUMP_RETURN();
 }
 
+// 't' could be a decl with multiple var which are contained in
+// a pass node.
+void ForLoopNode::AddInit(TreeNode *t) {
+  if (t->IsDecl()) {
+    DeclNode *decl = (DeclNode*)t;
+    TreeNode *var = decl->GetVar();
+    if (var && var->IsPass()) {
+      PassNode *pass = (PassNode*)var;
+      for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
+        DeclNode *n = (DeclNode*)gTreePool.NewTreeNode(sizeof(DeclNode));
+        new (n) DeclNode();
+        n->SetVar(pass->GetChild(i));
+        n->SetProp(decl->GetProp());
+        AddInit(n);
+      }
+    } else {
+      mInits.PushBack(t);
+      SETPARENT(t);
+    }
+  } else if (t->IsPass()) {
+    PassNode *pass = (PassNode*)t;
+    for (unsigned i = 0; i < pass->GetChildrenNum(); i++)
+      AddInit(pass->GetChild(i));
+  } else {
+    mInits.PushBack(t);
+    SETPARENT(t);
+  }
+}
+
+void ForLoopNode::AddUpdate(TreeNode *t) {
+  if (t->IsPass()) {
+    PassNode *pass = (PassNode*)t;
+    for (unsigned i = 0; i < pass->GetChildrenNum(); i++)
+      AddUpdate(pass->GetChild(i));
+  } else {
+    mUpdates.PushBack(t);
+    SETPARENT(t);
+  }
+}
+
 void ForLoopNode::Dump(unsigned ind) {
   DumpLabel(ind);
   DumpIndentation(ind);
@@ -771,55 +1377,100 @@ void SwitchLabelNode::Dump(unsigned ind) {
 }
 
 void SwitchCaseNode::AddLabel(TreeNode *t) {
-  std::list<TreeNode*> working_list;
-  working_list.push_back(t);
-  while (!working_list.empty()) {
-    TreeNode *t = working_list.front();
-    working_list.pop_front();
-    if (t->IsPass()) {
-      PassNode *labels = (PassNode*)t;
-      for (unsigned i = 0; i < labels->GetChildrenNum(); i++)
-        working_list.push_back(labels->GetChild(i));
-    } else {
-      MASSERT(t->IsSwitchLabel());
-      mLabels.PushBack((SwitchLabelNode*)t);
-    }
+  if (t->IsPass()) {
+    PassNode *pass = (PassNode*)t;
+    for (unsigned i = 0; i < pass->GetChildrenNum(); i++)
+      AddLabel(pass->GetChild(i));
+  } else {
+    MASSERT(t->IsSwitchLabel());
+    mLabels.PushBack((SwitchLabelNode*)t);
+    SETPARENT(t);
   }
 }
 
 void SwitchCaseNode::AddStmt(TreeNode *t) {
-  std::list<TreeNode*> working_list;
-  working_list.push_back(t);
-  while (!working_list.empty()) {
-    TreeNode *t = working_list.front();
-    working_list.pop_front();
-    if (t->IsPass()) {
-      PassNode *stmts = (PassNode*)t;
-      for (unsigned i = 0; i < stmts->GetChildrenNum(); i++)
-        working_list.push_back(stmts->GetChild(i));
-    } else {
-      mStmts.PushBack(t);
-    }
+  if (t->IsPass()) {
+    PassNode *pass = (PassNode*)t;
+    for (unsigned i = 0; i < pass->GetChildrenNum(); i++)
+      AddStmt(pass->GetChild(i));
+  } else {
+    mStmts.PushBack(t);
+    SETPARENT(t);
   }
 }
 
 void SwitchCaseNode::Dump(unsigned ind) {
 }
 
-void SwitchNode::AddCase(TreeNode *tree) {
-  std::list<TreeNode*> working_list;
-  working_list.push_back(tree);
-  while (!working_list.empty()) {
-    TreeNode *t = working_list.front();
-    working_list.pop_front();
-    if (t->IsPass()) {
-      PassNode *cases = (PassNode*)t;
-      for (unsigned i = 0; i < cases->GetChildrenNum(); i++)
-        working_list.push_back(cases->GetChild(i));
-    } else {
-      MASSERT(t->IsSwitchCase());
-      mCases.PushBack((SwitchCaseNode*)t);
+SwitchCaseNode* SwitchNode::SwitchLabelToCase(SwitchLabelNode *label) {
+  SwitchCaseNode *case_node =
+    (SwitchCaseNode*)gTreePool.NewTreeNode(sizeof(SwitchCaseNode));
+  new (case_node) SwitchCaseNode();
+  case_node->AddLabel(label);
+  return case_node;
+}
+
+void SwitchNode::AddSwitchCase(TreeNode *t) {
+  if (t->IsPass()) {
+    PassNode *cases = (PassNode*)t;
+    for (unsigned i = 0; i < cases->GetChildrenNum(); i++)
+      AddSwitchCase(cases->GetChild(i));
+  } else if (t->IsSwitchCase()) {
+    // Need go through the statements in this case. Some stmt like
+    // default : xxx
+    // are parsed as a labeled stmt inside this case, which they
+    // are actually a case of switch.
+    SwitchCaseNode *the_case = (SwitchCaseNode*)t;
+    SwitchCaseNode *new_case = NULL;
+    unsigned stmt_num = the_case->GetStmtsNum();
+    for (unsigned i = 0; i < stmt_num; i++) {
+      TreeNode *stmt = the_case->GetStmtAtIndex(i);
+      TreeNode *label = stmt->GetLabel();
+      if (label) {
+        MASSERT(label->IsIdentifier());
+        IdentifierNode *id = (IdentifierNode*)label;
+        const char *name = id->GetName();
+
+        // If it's a default case, all remaining statements belong
+        // to this default case.
+        if (!strncmp(name, "default", 7) && (strlen(name) == 7)) {
+          // 1. clear the label of stmt.
+          stmt->SetLabel(NULL);
+          // 2. build switch label
+          SwitchLabelNode *default_label =
+            (SwitchLabelNode*)gTreePool.NewTreeNode(sizeof(SwitchLabelNode));
+          new (default_label) SwitchLabelNode();
+          default_label->SetIsDefault(true);
+          // 3. build the switch case
+          new_case = (SwitchCaseNode*)gTreePool.NewTreeNode(sizeof(SwitchCaseNode));
+          new (new_case) SwitchCaseNode();
+          // 4. set the label and stmt for this case.
+          new_case->AddLabel(default_label);
+          new_case->AddStmt(stmt);
+          // 5. add all remaining stmts to new_case
+          for (unsigned j = i+1; j < stmt_num; j++) {
+            TreeNode *rem_stmt = the_case->GetStmtAtIndex(j);
+            new_case->AddStmt(rem_stmt);
+          }
+          // 6. remove the stmts added to new_case from the_case
+          for (unsigned j = i; j < stmt_num; j++)
+            the_case->PopStmt();
+          break;
+        }
+      }
+    }
+
+    AddCase(the_case);
+    SETPARENT(the_case);
+    if (new_case) {
+      AddCase(new_case);
+      SETPARENT(new_case);
     }
+
+  } else if (t->IsSwitchLabel()) {
+    SwitchCaseNode *casenode = SwitchLabelToCase((SwitchLabelNode*)t);
+    AddCase(casenode);
+    SETPARENT(casenode);
   }
 }
 
@@ -832,6 +1483,47 @@ void SwitchNode::Dump(unsigned ind) {
 //                          BlockNode
 //////////////////////////////////////////////////////////////////////////////////////
 
+void BlockNode::AddChild(TreeNode *tree) {
+  if (tree->IsDecl()) {
+    DeclNode *decl = (DeclNode*)tree;
+    TreeNode *var = decl->GetVar();
+    if (var && var->IsPass()) {
+      PassNode *pass = (PassNode*)var;
+      for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
+        DeclNode *n = (DeclNode*)gTreePool.NewTreeNode(sizeof(DeclNode));
+        new (n) DeclNode();
+        n->SetVar(pass->GetChild(i));
+        n->SetProp(decl->GetProp());
+        AddChild(n);
+      }
+    } else {
+      mChildren.PushBack(tree);
+      SETPARENT(tree);
+    }
+  } else if (tree->IsPass()) {
+    PassNode *passnode = (PassNode*)tree;
+    for (unsigned j = 0; j < passnode->GetChildrenNum(); j++) {
+      TreeNode *child = passnode->GetChild(j);
+      AddChild(child);
+    }
+  } else {
+    mChildren.PushBack(tree);
+    SETPARENT(tree);
+  }
+}
+
+void BlockNode::InsertStmtAfter(TreeNode *new_stmt, TreeNode *exist_stmt) {
+  mChildren.LocateValue(exist_stmt);
+  mChildren.InsertAfter(new_stmt);
+  SETPARENT(new_stmt);
+}
+
+void BlockNode::InsertStmtBefore(TreeNode *new_stmt, TreeNode *exist_stmt) {
+  mChildren.LocateValue(exist_stmt);
+  mChildren.InsertBefore(new_stmt);
+  SETPARENT(new_stmt);
+}
+
 void BlockNode::Dump(unsigned ind) {
   DumpLabel(ind);
   for (unsigned i = 0; i < GetChildrenNum(); i++) {
@@ -859,35 +1551,113 @@ void PassNode::Dump(unsigned ind) {
 //                          ClassNode
 //////////////////////////////////////////////////////////////////////////////////////
 
+void ClassNode::AddTypeParam(TreeNode *param) {
+  if (param->IsPass()) {
+    PassNode *n = (PassNode*)param;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddTypeParam(child);
+    }
+  } else {
+    MASSERT(param->IsTypeParameter());
+    mTypeParams.PushBack((TypeParameterNode*)param);
+    SETPARENT(param);
+  }
+}
+
+void ClassNode::AddSuperClass(TreeNode *the_super) {
+  if (!the_super)
+    return;
+
+  if (the_super->IsPass()) {
+    PassNode *pass_node = (PassNode*)the_super;
+    for (unsigned i = 0; i < pass_node->GetChildrenNum(); i++)
+      AddSuperClass(pass_node->GetChild(i));
+  } else {
+    mSuperClasses.PushBack(the_super);
+    SETPARENT(the_super);
+  }
+}
+
+void ClassNode::AddSuperInterface(TreeNode *the_super) {
+  if (!the_super)
+    return;
+
+  if (the_super->IsPass()) {
+    PassNode *pass_node = (PassNode*)the_super;
+    for (unsigned i = 0; i < pass_node->GetChildrenNum(); i++)
+      AddSuperInterface(pass_node->GetChild(i));
+  } else {
+    mSuperInterfaces.PushBack(the_super);
+    SETPARENT(the_super);
+  }
+}
+
 // When the class body, a BlockNode, is added to the ClassNode, we need further
 // categorize the subtrees into members, methods, local classes, interfaces, etc.
-void ClassNode::Construct() {
-  for (unsigned i = 0; i < mBody->GetChildrenNum(); i++) {
-    TreeNode *tree_node = mBody->GetChildAtIndex(i);
-    tree_node->SetParent(this);
-    if (tree_node->IsVarList()) {
-      VarListNode *vlnode = (VarListNode*)tree_node;
-      for (unsigned i = 0; i < vlnode->GetNum(); i++) {
-        IdentifierNode *inode = vlnode->VarAtIndex(i);
-        inode->SetParent(this);
-        mFields.PushBack(inode);
-      }
-    } else if (tree_node->IsIdentifier())
-      mFields.PushBack((IdentifierNode*)tree_node);
-    else if (tree_node->IsFunction()) {
+void ClassNode::Construct(BlockNode *block) {
+  for (unsigned i = 0; i < block->GetChildrenNum(); i++) {
+    TreeNode *tree_node = block->GetChildAtIndex(i);
+    SETPARENT(tree_node);
+    if (tree_node->IsDecl()) {
+      DeclNode *decl = (DeclNode*)tree_node;
+      TreeNode *var = decl->GetVar();
+      if (var->IsVarList()) {
+        VarListNode *vlnode = (VarListNode*)var;
+        for (unsigned i = 0; i < vlnode->GetVarsNum(); i++) {
+          IdentifierNode *inode = vlnode->GetVarAtIndex(i);
+          SETPARENT(inode);
+          mFields.PushBack(inode);
+        }
+      } else if (var->IsIdentifier() || var->IsComputedName() || var->IsLiteral()) {
+        // string literal is allowed to be a field.
+        mFields.PushBack(var);
+        SETPARENT(var);
+      } else
+        MERROR("Unsupported class field.");
+    } else if (tree_node->IsNumIndexSig() || tree_node->IsStrIndexSig()) {
+      mFields.PushBack(tree_node);
+      SETPARENT(tree_node);
+    } else if (tree_node->IsFunction()) {
       FunctionNode *f = (FunctionNode*)tree_node;
+      // There is an ugly case from Typescript, which use keyword 'constructor'
+      // as an identifier. This causes a constructor to be recoganized as normal function.
+      // We do adjustment here.
+      TreeNode *name = f->GetFuncName();
+      if (name && name->IsIdentifier()) {
+        IdentifierNode *id = (IdentifierNode*)name;
+        const char *name_str = id->GetName();
+        if (!strncmp(name_str, "constructor", 11) && (strlen(name_str) == 11)) {
+          f->SetFuncName(NULL);
+          f->SetStrIdx(0);
+          f->SetIsConstructor();
+        }
+      }
       if (f->IsConstructor())
         mConstructors.PushBack(f);
       else
         mMethods.PushBack(f);
-    } else if (tree_node->IsClass())
+      SETPARENT(f);
+    } else if (tree_node->IsClass()) {
       mLocalClasses.PushBack((ClassNode*)tree_node);
-    else if (tree_node->IsInterface())
+      SETPARENT(tree_node);
+    } else if (tree_node->IsInterface()) {
       mLocalInterfaces.PushBack((InterfaceNode*)tree_node);
-    else if (tree_node->IsBlock()) {
+      SETPARENT(tree_node);
+    } else if (tree_node->IsBlock()) {
       BlockNode *block = (BlockNode*)tree_node;
       MASSERT(block->IsInstInit() && "unnamed block in class is not inst init?");
       mInstInits.PushBack(block);
+      SETPARENT(tree_node);
+    } else if (tree_node->IsImport()) {
+      mImports.PushBack((ImportNode*)tree_node);
+      SETPARENT(tree_node);
+    } else if (tree_node->IsExport()) {
+      mExports.PushBack((ExportNode*)tree_node);
+      SETPARENT(tree_node);
+    } else if (tree_node->IsDeclare()) {
+      mDeclares.PushBack((DeclareNode*)tree_node);
+      SETPARENT(tree_node);
     } else
       MASSERT("Unsupported tree node in class body.");
   }
@@ -899,20 +1669,35 @@ void ClassNode::Release() {
   mSuperClasses.Release();
   mSuperInterfaces.Release();
   mAttributes.Release();
+  mAnnotations.Release();
+  mTypeParams.Release();
   mFields.Release();
   mMethods.Release();
   mLocalClasses.Release();
   mLocalInterfaces.Release();
+  mImports.Release();
+  mExports.Release();
+  mDeclares.Release();
 }
 
 void ClassNode::Dump(unsigned indent) {
   DumpIndentation(indent);
   if (IsJavaEnum())
-    DUMP1_NORETURN("class[JavaEnum] ", mName);
+    DUMP1_NORETURN("class[JavaEnum] ", GetName());
   else
-    DUMP1_NORETURN("class ", mName);
+    DUMP1_NORETURN("class ", GetName());
   DUMP_RETURN();
 
+  if (mTypeParams.GetNum() > 0) {
+    DUMP0_NORETURN("<");
+    for (unsigned i = 0; i < mTypeParams.GetNum(); i++) {
+      TypeParameterNode *node = mTypeParams.ValueAtIndex(i);
+      node->Dump(0);
+      DUMP0_NORETURN(",");
+    }
+    DUMP0_NORETURN(">");
+  }
+
   DumpIndentation(indent + 2);
   DUMP0("Fields: ");
   for (unsigned i = 0; i < mFields.GetNum(); i++) {
@@ -956,28 +1741,65 @@ void ClassNode::Dump(unsigned indent) {
     TreeNode *node = mLocalInterfaces.ValueAtIndex(i);
     node->Dump(indent + 4);
   }
+
+  if (mImports.GetNum() > 0) {
+    DumpIndentation(indent + 2);
+    DUMP0("Imports: ");
+  }
+  for (unsigned i = 0; i < mImports.GetNum(); i++) {
+    TreeNode *node = mImports.ValueAtIndex(i);
+    node->Dump(indent + 4);
+  }
+
+  if (mExports.GetNum() > 0) {
+    DumpIndentation(indent + 2);
+    DUMP0("Exports: ");
+  }
+  for (unsigned i = 0; i < mExports.GetNum(); i++) {
+    TreeNode *node = mExports.ValueAtIndex(i);
+    node->Dump(indent + 4);
+  }
+
+  if (mDeclares.GetNum() > 0) {
+    DumpIndentation(indent + 2);
+    DUMP0("Declares: ");
+  }
+  for (unsigned i = 0; i < mDeclares.GetNum(); i++) {
+    TreeNode *node = mDeclares.ValueAtIndex(i);
+    node->Dump(indent + 4);
+  }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 //                          FunctionNode
 //////////////////////////////////////////////////////////////////////////////////////
 
-FunctionNode::FunctionNode() {
-  mKind = NK_Function;
-  mName = NULL;
-  mType = NULL;
-  mBody = NULL;
-  mDims = NULL;
-  mIsConstructor = false;
+FunctionNode::FunctionNode() : TreeNode(NK_Function),
+  mFuncName(NULL), mRetType(NULL), mBody(NULL), mDims(NULL),
+  mIsConstructor(false), mIsGenerator(false), mIsIterator(false), mIsGetAccessor(false),
+  mIsSetAccessor(false), mIsCallSignature(false), mIsConstructSignature(false),
+  mAssert(NULL) {}
+
+void FunctionNode::AddTypeParam(TreeNode *param) {
+  if (param->IsPass()) {
+    PassNode *n = (PassNode*)param;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddTypeParam(child);
+    }
+  } else {
+    mTypeParams.PushBack(param);
+    SETPARENT(param);
+  }
 }
 
 // This is to tell if both FunctionNodes have same return type
 // and parameter types. So languages require Type Erasure at first, like Java.
 // Type erasure should be done earlier in language specific process.
 bool FunctionNode::OverrideEquivalent(FunctionNode *fun) {
-  if (!mType->TypeEquivalent(fun->GetType()))
+  if (!mRetType->TypeEquivalent(fun->GetRetType()))
     return false;
-  if (GetName() != fun->GetName())
+  if (GetStrIdx() != fun->GetStrIdx())
     return false;
   if (GetParamsNum() != fun->GetParamsNum())
     return false;
@@ -1021,6 +1843,8 @@ void FunctionNode::CleanUp() {
         } else {
           // If pass node is the header, insert before next.
           // If pass node is the last or any one else, insert after prev.
+          next = NULL;
+          prev = NULL;
           if (i == 0) {
             next = mBody->GetChildAtIndex(1);
           } else {
@@ -1061,12 +1885,46 @@ void FunctionNode::CleanUp() {
 void FunctionNode::Dump(unsigned indent) {
   DumpIndentation(indent);
   if (mIsConstructor)
-    DUMP1_NORETURN("constructor ", mName);
-  else 
-    DUMP1_NORETURN("func ", mName);
+    DUMP0_NORETURN("constructor  ");
+  else if (mIsGetAccessor)
+    DUMP0_NORETURN("get ");
+  else if (mIsSetAccessor)
+    DUMP0_NORETURN("set ");
+  else if (mIsGenerator)
+    DUMP0_NORETURN("generator ");
+  else
+    DUMP0_NORETURN("func  ");
+
+  if (mStrIdx)
+    DUMP0_NORETURN(GetName());
+  if (mFuncName && mFuncName->IsOptional())
+    DUMP0_NORETURN("?");
+
+  if (GetTypeParamsNum() > 0) {
+    DUMP0_NORETURN("<");
+    for (unsigned i = 0; i < GetTypeParamsNum(); i++) {
+      TreeNode *arg = GetTypeParamAtIndex(i);
+      arg->Dump(0);
+      if (i < GetTypeParamsNum() - 1)
+        DUMP0_NORETURN(",");
+    }
+    DUMP0_NORETURN(">");
+  }
 
   // dump parameters
-  DUMP0_NORETURN("()");
+  DUMP0_NORETURN("(");
+  for (unsigned i = 0; i < GetParamsNum(); i++) {
+    TreeNode *param = GetParam(i);
+    param->Dump(0);
+    if (i < GetParamsNum() - 1)
+      DUMP0_NORETURN(",");
+  }
+  DUMP0_NORETURN(")");
+
+  if (mAssert) {
+    DUMP0_NORETURN(" : ");
+    mAssert->Dump(0);
+  }
 
   // dump throws
   DUMP0_NORETURN("  throws: ");
@@ -1085,13 +1943,30 @@ void FunctionNode::Dump(unsigned indent) {
 //                              LambdaNode
 //////////////////////////////////////////////////////////////////////////////////////
 
+void LambdaNode::AddTypeParam(TreeNode *param) {
+  if (param->IsPass()) {
+    PassNode *n = (PassNode*)param;
+    for (unsigned i = 0; i < n->GetChildrenNum(); i++) {
+      TreeNode *child = n->GetChild(i);
+      AddTypeParam(child);
+    }
+  } else {
+    MASSERT(param->IsTypeParameter());
+    mTypeParams.PushBack((TypeParameterNode*)param);
+    SETPARENT(param);
+  }
+}
+
 void LambdaNode::Dump(unsigned indent) {
   DumpIndentation(indent);
   std::string dump;
   dump += "(";
   for (unsigned i = 0; i < mParams.GetNum(); i++) {
-    IdentifierNode *in = mParams.ValueAtIndex(i);
-    dump += in->GetName();
+    TreeNode *in = mParams.ValueAtIndex(i);
+    if(in->IsDecl())
+      dump += static_cast<DeclNode*>(in)->GetVar()->GetName();
+    else
+      dump += in->GetName();
     if (i < mParams.GetNum() - 1)
       dump += ",";
   }
@@ -1101,6 +1976,137 @@ void LambdaNode::Dump(unsigned indent) {
     mBody->Dump(0);
 }
 
+//////////////////////////////////////////////////////////////////////////////////////
+//                              InstanceOfNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void InstanceOfNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  mLeft->Dump(0);
+  DUMP0_NORETURN(" instanceof ");
+  mRight->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                              InNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void InNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  mLeft->Dump(0);
+  DUMP0_NORETURN(" in ");
+  mRight->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                              MappedPropertyNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void ComputedNameNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("[");
+  mExpr->Dump(0);
+  DUMP0_NORETURN("] : ");
+  if (mExtendType)
+    mExtendType->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                              IsNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void IsNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  mLeft->Dump(0);
+  DUMP0_NORETURN(" is ");
+  mRight->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                              AwaitNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void AwaitNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN(" await ");
+  if (mExpr)
+    mExpr->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                              TypeOfNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void TypeOfNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN(" typeof ");
+  mExpr->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                              KeyOfNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void KeyOfNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN(" keyof ");
+  mExpr->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                              InferNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void InferNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN(" infer ");
+  mExpr->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                              NameTypePairNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+void NameTypePairNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  if (mVar)
+    mVar->Dump(0);
+  DUMP0_NORETURN(" : ");
+  if (mType)
+    mType->Dump(0);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+//                              TupleTypeNode
+//////////////////////////////////////////////////////////////////////////////////////
+
+// Child should be NameTypePairNode
+void TupleTypeNode::AddChild(TreeNode *field) {
+  if (field->IsPass()) {
+    PassNode *pass = (PassNode*)field;
+    for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
+      TreeNode *child = pass->GetChild(i);
+      AddChild(child);
+    }
+  } else {
+    MASSERT(field->IsNameTypePair());
+    NameTypePairNode *node = (NameTypePairNode*)field;
+    AddField(node);
+    SETPARENT(node);
+  }
+}
+
+void TupleTypeNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN(" [ ");
+  for (unsigned i = 0; i < mFields.GetNum(); i++) {
+    NameTypePairNode *node = mFields.ValueAtIndex(i);
+    node->Dump(0);
+    DUMP0_NORETURN(" , ");
+  }
+  DUMP0_NORETURN(" ] ");
+}
+
 //////////////////////////////////////////////////////////////////////////////////////
 //                             InterfaceNode
 //////////////////////////////////////////////////////////////////////////////////////
@@ -1108,12 +2114,12 @@ void LambdaNode::Dump(unsigned indent) {
 void InterfaceNode::Construct(BlockNode *block) {
   for (unsigned i = 0; i < block->GetChildrenNum(); i++) {
     TreeNode *tree_node = block->GetChildAtIndex(i);
-    tree_node->SetParent(this);
+    SETPARENT(tree_node);
     if (tree_node->IsVarList()) {
       VarListNode *vlnode = (VarListNode*)tree_node;
-      for (unsigned i = 0; i < vlnode->GetNum(); i++) {
-        IdentifierNode *inode = vlnode->VarAtIndex(i);
-        inode->SetParent(this);
+      for (unsigned i = 0; i < vlnode->GetVarsNum(); i++) {
+        IdentifierNode *inode = vlnode->GetVarAtIndex(i);
+        SETPARENT(inode);
         mFields.PushBack(inode);
       }
     } else if (tree_node->IsIdentifier())
@@ -1128,7 +2134,7 @@ void InterfaceNode::Construct(BlockNode *block) {
 
 void InterfaceNode::Dump(unsigned indent) {
   DumpIndentation(indent);
-  DUMP1_NORETURN("interface ", mName);
+  DUMP1_NORETURN("interface ", GetName());
   DUMP_RETURN();
   DumpIndentation(indent + 2);
 
@@ -1146,4 +2152,31 @@ void InterfaceNode::Dump(unsigned indent) {
     node->Dump(indent + 4);
   }
 }
+
+void TripleSlashNode::Dump(unsigned indent) {
+  DumpIndentation(indent);
+  DUMP0_NORETURN("trip-slash reference ");
+
+  switch(mProp) {
+  case TSP_Path:
+    DUMP0_NORETURN("path = ");
+    break;
+  case TSP_Types:
+    DUMP0_NORETURN("types = ");
+    break;
+  case TSP_NoDefaultLib:
+    DUMP0_NORETURN("no-default-lib = ");
+    break;
+  case TSP_Lib:
+    DUMP0_NORETURN("lib = ");
+    break;
+  case TSP_NA:
+  default:
+    DUMP0_NORETURN("NA =  ");
+    break;
+  }
+
+  mValue->Dump(0);
+}
+
 }
diff --git a/src/MapleFE/shared/src/ast_attr.cpp b/src/MapleFE/shared/src/ast_attr.cpp
index 7b4279eb920d603bfa0809ff3bf6c904f6f7b1cc..19b2124b717efe6c259591dec60a9dd85fec112c 100644
--- a/src/MapleFE/shared/src/ast_attr.cpp
+++ b/src/MapleFE/shared/src/ast_attr.cpp
@@ -18,14 +18,13 @@
 #include "ast.h"
 #include "ruletable.h"
 #include "ast_attr.h"
-#include "gen_attr.h"   // for language specific attr keyword
 #include "massert.h"
 
 namespace maplefe {
 
 // Inquiry function for language specific attr keyword
-static const char* FindAttrKeyword(AttrId id) {
-  for (unsigned i = 0; i < ATTR_NA; i++) {
+const char* FindAttrKeyword(AttrId id) {
+  for (unsigned i = 0; i < AttrKeywordTableSize; i++) {
     if (AttrKeywordTable[i].mId == id)
       return AttrKeywordTable[i].mText;
   }
@@ -33,8 +32,8 @@ static const char* FindAttrKeyword(AttrId id) {
 }
 
 // Inquiry function for language specific attr keyword
-static AttrId FindAttrId(const char *keyword) {
-  for (unsigned i = 0; i < ATTR_NA; i++) {
+AttrId FindAttrId(const char *keyword) {
+  for (unsigned i = 0; i < AttrKeywordTableSize; i++) {
     if (strncmp(AttrKeywordTable[i].mText, keyword, strlen(keyword)) == 0
         && strlen(keyword) == strlen(AttrKeywordTable[i].mText))
       return AttrKeywordTable[i].mId;
diff --git a/src/MapleFE/shared/src/ast_builder.cpp b/src/MapleFE/shared/src/ast_builder.cpp
index 011cafb03f24d84d32a0967d9a5faddc0ad0bc02..8f345d1fff75a00261b6690b48ebe80000387b89 100644
--- a/src/MapleFE/shared/src/ast_builder.cpp
+++ b/src/MapleFE/shared/src/ast_builder.cpp
@@ -17,6 +17,7 @@
 
 #include "token.h"
 #include "ruletable.h"
+#include "stringpool.h"
 #include "ast_builder.h"
 #include "ast_scope.h"
 #include "ast_attr.h"
@@ -26,8 +27,6 @@
 
 namespace maplefe {
 
-ASTBuilder gASTBuilder;
-
 ////////////////////////////////////////////////////////////////////////////////////////
 // For the time being, we simply use a big switch-case. Later on we could use a more
 // flexible solution.
@@ -51,17 +50,48 @@ TreeNode* ASTBuilder::Build() {
 TreeNode* ASTBuilder::CreateTokenTreeNode(const Token *token) {
   unsigned size = 0;
   if (token->IsIdentifier()) {
-    IdentifierNode *n = (IdentifierNode*)mTreePool->NewTreeNode(sizeof(IdentifierNode));
-    new (n) IdentifierNode(token->GetName());
+    IdentifierNode *n = (IdentifierNode*)gTreePool.NewTreeNode(sizeof(IdentifierNode));
+    unsigned idx = gStringPool.GetStrIdx(token->GetName());
+    new (n) IdentifierNode(idx);
     mLastTreeNode = n;
     return n;
   } else if (token->IsLiteral()) {
     LitData data = token->GetLitData();
-    LiteralNode *n = (LiteralNode*)mTreePool->NewTreeNode(sizeof(LiteralNode));
+    LiteralNode *n = (LiteralNode*)gTreePool.NewTreeNode(sizeof(LiteralNode));
     new (n) LiteralNode(data);
     mLastTreeNode = n;
     return n;
+  } else if (token->IsTempLit()) {
+    TemplateLiteralNode *n = (TemplateLiteralNode*)gTreePool.NewTreeNode(sizeof(TemplateLiteralNode));
+    new (n) TemplateLiteralNode();
+
+    // copy mStrings&mPlaceHolders to n
+    TempLitData *tld = token->GetTempLitData();
+    for (unsigned i = 0; i < tld->mStrings.GetNum(); i++) {
+      const char *s = tld->mStrings.ValueAtIndex(i);
+      n->AddString(s);
+    }
+
+    // release memeory of SmallVector of mStrings.
+    tld->mStrings.Release();
+    delete tld;
+
+    gTemplateLiteralNodes.PushBack(n);
+    mLastTreeNode = n;
+    return n;
+
+  } else if (token->IsRegExpr()) {
+    RegExprNode *n = (RegExprNode*)gTreePool.NewTreeNode(sizeof(RegExprNode));
+    new (n) RegExprNode();
+
+    RegExprData d = token->GetRegExpr();
+    n->SetData(d);
+
+    mLastTreeNode = n;
+    return n;
+
   } else if (token->IsKeyword()) {
+    mNameForBuildIdentifier = NULL;
     const char *keyword = token->GetName();
     // If it's an attribute
     AttrNode *n = gAttrPool.GetAttrNode(keyword);
@@ -73,18 +103,29 @@ TreeNode* ASTBuilder::CreateTokenTreeNode(const Token *token) {
     PrimTypeNode *type = gPrimTypePool.FindType(keyword);
     if (type) {
       mLastTreeNode = type;
+      mNameForBuildIdentifier = keyword;
       return type;
     }
-    // We define special literal tree node for 'this'.
+    // We define special literal tree node for 'this', 'super'.
     if ((strlen(token->GetName()) == 4) && !strncmp(token->GetName(), "this", 4)) {
       LitData data;
       data.mType = LT_ThisLiteral;
-      LiteralNode *n = (LiteralNode*)mTreePool->NewTreeNode(sizeof(LiteralNode));
+      LiteralNode *n = (LiteralNode*)gTreePool.NewTreeNode(sizeof(LiteralNode));
+      new (n) LiteralNode(data);
+      mLastTreeNode = n;
+      return n;
+    } else if ((strlen(token->GetName()) == 5) && !strncmp(token->GetName(), "super", 5)) {
+      LitData data;
+      data.mType = LT_SuperLiteral;
+      LiteralNode *n = (LiteralNode*)gTreePool.NewTreeNode(sizeof(LiteralNode));
       new (n) LiteralNode(data);
       mLastTreeNode = n;
       return n;
     }
+
     // Otherwise, it doesn't create any tree node.
+    // But we pass the keyword name to future possible BuildIdentifier.
+    mNameForBuildIdentifier = keyword;
   }
 
   // Other tokens shouldn't be involved in the tree creation.
@@ -99,24 +140,30 @@ static void add_attribute_to(TreeNode *tree, TreeNode *attr) {
   MASSERT(attr->IsAttr());
   AttrNode *attr_node = (AttrNode*)attr;
   AttrId aid = attr_node->GetId();
-  if (tree->IsVarList()) {
+
+  if (tree->IsPass()) {
+    PassNode *pass_node = (PassNode*)tree;
+    for (unsigned i = 0; i < pass_node->GetChildrenNum(); i++) {
+      TreeNode *child = pass_node->GetChild(i);
+      add_attribute_to(child, attr);
+    }
+  } else if (tree->IsVarList()) {
     VarListNode *vl = (VarListNode*)tree;
-    for (unsigned i = 0; i < vl->GetNum(); i++) {
-      IdentifierNode *inode = vl->VarAtIndex(i);
+    for (unsigned i = 0; i < vl->GetVarsNum(); i++) {
+      IdentifierNode *inode = vl->GetVarAtIndex(i);
       inode->AddAttr(aid);
     }
-    return;
-  } else if (tree->IsBlock()){
-    BlockNode *b = (BlockNode*)tree;
-    if (b->IsInstInit()) {
-      b->AddAttr(aid);
-      return;
+  } else if (tree->IsExprList()) {
+    ExprListNode *vl = (ExprListNode*)tree;
+    for (unsigned i = 0; i < vl->GetExprsNum(); i++) {
+      TreeNode *child = vl->GetExprAtIndex(i);
+      add_attribute_to(child, attr);
     }
   } else {
-    ClassNode *klass = (ClassNode*)tree;
-    klass->AddAttr(aid);
-    return;
+    // The basse TreeNode has a virtual AddAttr().
+    tree->AddAttr(aid);
   }
+  return;
 }
 
 // It's the caller to assure tree is valid, meaning something could carry type.
@@ -124,39 +171,243 @@ static void add_type_to(TreeNode *tree, TreeNode *type) {
   if (tree->IsIdentifier()) {
     IdentifierNode *in = (IdentifierNode*)tree;
     in->SetType(type);
+  } else if (tree->IsLiteral()) {
+    LiteralNode *lit = (LiteralNode*)tree;
+    lit->SetType(type);
+  } else if (tree->IsLambda()) {
+    LambdaNode *lam = (LambdaNode*)tree;
+    lam->SetRetType(type);
   } else if (tree->IsVarList()) {
     VarListNode *vl = (VarListNode*)tree;
-    for (unsigned i = 0; i < vl->GetNum(); i++)
-      vl->VarAtIndex(i)->SetType(type);
+    for (unsigned i = 0; i < vl->GetVarsNum(); i++)
+      vl->GetVarAtIndex(i)->SetType(type);
   } else if (tree->IsFunction()) {
     FunctionNode *func = (FunctionNode*)tree;
-    func->SetType(type);
+    func->SetRetType(type);
+  } else if (tree->IsBindingPattern()) {
+    BindingPatternNode *bp = (BindingPatternNode*)tree;
+    bp->SetType(type);
+  } else if (tree->IsComputedName()) {
+    ComputedNameNode *mp = (ComputedNameNode*)tree;
+    mp->SetExtendType(type);
   } else {
     MERROR("Unsupported tree node in add_type_to()");
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
-//                      Major Functions to build the tree
+//                          BuildModule
+////////////////////////////////////////////////////////////////////////////////////////
+
+// Take one argument, the module name
+TreeNode* ASTBuilder::BuildModule() {
+  ModuleNode *n = (ModuleNode*)gTreePool.NewTreeNode(sizeof(ModuleNode));
+  new (n) ModuleNode();
+
+  MASSERT(mParams.size() == 1);
+  Param p_a = mParams[0];
+  if (!p_a.mIsEmpty && p_a.mIsTreeNode) {
+    TreeNode *tree = p_a.mData.mTreeNode;
+    if (tree->IsIdentifier()) {
+      const char *name = tree->GetName();
+      n->SetFilename(name);
+    } else if (tree->IsLiteral()) {
+      LiteralNode *lit = (LiteralNode*)tree;
+      LitData data = lit->GetData();
+      MASSERT(data.mType == LT_StringLiteral);
+      const char *name = gStringPool.GetStringFromStrIdx(data.mData.mStrIdx);
+      n->SetFilename(name);
+    } else {
+      MERROR("Unsupported module name.");
+    }
+  }
+
+  mLastTreeNode = n;
+  return mLastTreeNode;
+}
+
+// It takes no argument.
+TreeNode* ASTBuilder::SetIsAmbient() {
+  MASSERT(mLastTreeNode->IsModule());
+  ModuleNode *mod = (ModuleNode*)mLastTreeNode;
+  mod->SetIsAmbient();
+  return mLastTreeNode;
+}
+
+// Takes one parameter which is the tree of module body.
+TreeNode* ASTBuilder::AddModuleBody() {
+  if (mTrace)
+    std::cout << "In AddModuleBody" << std::endl;
+
+  Param p_body = mParams[0];
+  if (!p_body.mIsEmpty) {
+    if (!p_body.mIsTreeNode)
+      MERROR("The module body is not a tree node.");
+    TreeNode *tn = p_body.mData.mTreeNode;
+
+    MASSERT(mLastTreeNode->IsModule());
+    ModuleNode *mod = (ModuleNode*)mLastTreeNode;
+    mod->AddTree(tn);
+  }
+
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//                          BuildIdentifier
+////////////////////////////////////////////////////////////////////////////////////////
+
+// 1. It takes one argument, the target to build into identifier.
+// 2. It takes no argument, then mLastTreeNode is the target.
+// It could be a token or tree.
+TreeNode* ASTBuilder::BuildIdentifier() {
+  if (mParams.size() == 1) {
+    Param target = mParams[0];
+    if (!target.mIsEmpty) {
+      if (target.mIsTreeNode) {
+        TreeNode *tn = target.mData.mTreeNode;
+        return BuildIdentifier(tn);
+      } else {
+        Token *tn = target.mData.mToken;
+        return BuildIdentifier(tn);
+      }
+    }
+    return NULL;
+  }
+
+  if (mNameForBuildIdentifier) {
+    IdentifierNode *n = (IdentifierNode*)gTreePool.NewTreeNode(sizeof(IdentifierNode));
+    unsigned idx = gStringPool.GetStrIdx(mNameForBuildIdentifier);
+    new (n) IdentifierNode(idx);
+    mLastTreeNode = n;
+    mNameForBuildIdentifier = NULL;
+    return n;
+  } else if (mLastTreeNode->IsIdentifier()) {
+    return mLastTreeNode;
+  } else if (mLastTreeNode->IsAttr()) {
+    AttrNode *an = (AttrNode*)mLastTreeNode;
+    AttrId aid = an->GetId();
+
+    IdentifierNode *n = (IdentifierNode*)gTreePool.NewTreeNode(sizeof(IdentifierNode));
+    unsigned idx = gStringPool.GetStrIdx(FindAttrKeyword(aid));
+    new (n) IdentifierNode(idx);
+    mLastTreeNode = n;
+    return n;
+  } else if (mLastTreeNode->IsPrimType()) {
+    PrimTypeNode *prim_type = (PrimTypeNode*)mLastTreeNode;
+    IdentifierNode *n = (IdentifierNode*)gTreePool.NewTreeNode(sizeof(IdentifierNode));
+    unsigned idx = gStringPool.GetStrIdx(prim_type->GetTypeName());
+    new (n) IdentifierNode(idx);
+    mLastTreeNode = n;
+    return n;
+  } else if (mLastTreeNode->IsLiteral()) {
+    LiteralNode *lit = (LiteralNode*)mLastTreeNode;
+    LitData data = lit->GetData();
+    if (data.mType == LT_ThisLiteral) {
+      IdentifierNode *n = (IdentifierNode*)gTreePool.NewTreeNode(sizeof(IdentifierNode));
+      unsigned idx = gStringPool.GetStrIdx("this");
+      new (n) IdentifierNode(idx);
+      mLastTreeNode = n;
+      return n;
+    } else {
+      MERROR("Unsupported node type in BuildIdentifier()");
+    }
+  } else {
+    MERROR("Unsupported node type in BuildIdentifier()");
+  }
+}
+
+// Build IdentifierNode from a token.
+TreeNode* ASTBuilder::BuildIdentifier(const Token *token) {
+  const char *name = token->GetName();
+  MASSERT(name);
+  IdentifierNode *n = (IdentifierNode*)gTreePool.NewTreeNode(sizeof(IdentifierNode));
+  unsigned idx = gStringPool.GetStrIdx(name);
+  new (n) IdentifierNode(idx);
+  mLastTreeNode = n;
+  return n;
+}
+
+// Build IdentifierNode from a TreeNode.
+TreeNode* ASTBuilder::BuildIdentifier(const TreeNode *tree) {
+  if (!tree)
+    return NULL;
+
+  if (tree->IsAttr()) {
+    AttrNode *an = (AttrNode*)tree;
+    AttrId aid = an->GetId();
+    IdentifierNode *n = (IdentifierNode*)gTreePool.NewTreeNode(sizeof(IdentifierNode));
+    unsigned idx = gStringPool.GetStrIdx(FindAttrKeyword(aid));
+    new (n) IdentifierNode(idx);
+    mLastTreeNode = n;
+    return n;
+  } else if (tree->IsLiteral()) {
+    LiteralNode *lit = (LiteralNode*)tree;
+    LitData data = lit->GetData();
+    if (data.mType == LT_ThisLiteral) {
+      IdentifierNode *n = (IdentifierNode*)gTreePool.NewTreeNode(sizeof(IdentifierNode));
+      unsigned idx = gStringPool.GetStrIdx("this");
+      new (n) IdentifierNode(idx);
+      mLastTreeNode = n;
+      return n;
+    }
+  }
+
+  return NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//                      NameTypePair
+////////////////////////////////////////////////////////////////////////////////////////
+
+// It could takes (1) two arguments, name and type
+//                (2) one argument, the name
+TreeNode* ASTBuilder::BuildNameTypePair() {
+  if (mTrace)
+    std::cout << "In BuildNameTypePair" << std::endl;
+
+  NameTypePairNode *n = (NameTypePairNode*)gTreePool.NewTreeNode(sizeof(NameTypePairNode));
+  new (n) NameTypePairNode();
+  mLastTreeNode = n;
+
+  if (mParams.size() == 2) {
+    Param p_a = mParams[0];
+    Param p_b = mParams[1];
+
+    if (!p_a.mIsEmpty && p_a.mIsTreeNode)
+      n->SetVar(p_a.mData.mTreeNode);
+
+    if (!p_b.mIsEmpty && p_b.mIsTreeNode)
+      n->SetType(p_b.mData.mTreeNode);
+  } else {
+    Param p_b = mParams[0];
+    if (!p_b.mIsEmpty && p_b.mIsTreeNode)
+      n->SetType(p_b.mData.mTreeNode);
+  }
+
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//                      Interfaces for Java style package  and import
 ////////////////////////////////////////////////////////////////////////////////////////
 
 TreeNode* ASTBuilder::BuildPackageName() {
-  MASSERT(!gModule.mPackage);
+  MASSERT(!mASTModule->mPackage);
   MASSERT(mLastTreeNode->IsField() || mLastTreeNode->IsIdentifier());
 
-  PackageNode *n = (PackageNode*)mTreePool->NewTreeNode(sizeof(PackageNode));
+  PackageNode *n = (PackageNode*)gTreePool.NewTreeNode(sizeof(PackageNode));
   new (n) PackageNode();
-  const char *name = mLastTreeNode->GetName();
-  n->SetName(name);
+  n->SetPackage(mLastTreeNode);
 
-  gModule.SetPackage(n);
+  mASTModule->SetPackage(n);
 
   mLastTreeNode = n;
   return mLastTreeNode;
 }
 
 TreeNode* ASTBuilder::BuildSingleTypeImport() {
-  ImportNode *n = (ImportNode*)mTreePool->NewTreeNode(sizeof(ImportNode));
+  ImportNode *n = (ImportNode*)gTreePool.NewTreeNode(sizeof(ImportNode));
   new (n) ImportNode();
   n->SetImportSingle();
   n->SetImportType();
@@ -167,13 +418,13 @@ TreeNode* ASTBuilder::BuildSingleTypeImport() {
   TreeNode *tree = p.mData.mTreeNode;
   MASSERT(tree->IsIdentifier() || tree->IsField());
 
-  n->SetName(tree->GetName());
+  n->SetTarget(tree);
   mLastTreeNode = n;
   return mLastTreeNode;
 }
 
 TreeNode* ASTBuilder::BuildAllTypeImport() {
-  ImportNode *n = (ImportNode*)mTreePool->NewTreeNode(sizeof(ImportNode));
+  ImportNode *n = (ImportNode*)gTreePool.NewTreeNode(sizeof(ImportNode));
   new (n) ImportNode();
   n->SetImportAll();
   n->SetImportType();
@@ -184,20 +435,20 @@ TreeNode* ASTBuilder::BuildAllTypeImport() {
   TreeNode *tree = p.mData.mTreeNode;
   MASSERT(tree->IsIdentifier() || tree->IsField());
 
-  n->SetName(tree->GetName());
+  n->SetTarget(tree);
   mLastTreeNode = n;
   return mLastTreeNode;
 }
 
 // It takes the mLastTreeNode as parameter
 TreeNode* ASTBuilder::BuildSingleStaticImport() {
-  ImportNode *n = (ImportNode*)mTreePool->NewTreeNode(sizeof(ImportNode));
+  ImportNode *n = (ImportNode*)gTreePool.NewTreeNode(sizeof(ImportNode));
   new (n) ImportNode();
   n->SetImportSingle();
   n->SetImportType();
 
   MASSERT(mLastTreeNode->IsIdentifier() || mLastTreeNode->IsField());
-  n->SetName(mLastTreeNode->GetName());
+  n->SetTarget(mLastTreeNode);
   n->SetImportStatic();
   mLastTreeNode = n;
   return mLastTreeNode;
@@ -211,8 +462,307 @@ TreeNode* ASTBuilder::BuildAllStaticImport() {
 }
 
 TreeNode* ASTBuilder::BuildAllImport() {
+  ImportNode *n = (ImportNode*)gTreePool.NewTreeNode(sizeof(ImportNode));
+  new (n) ImportNode();
+  n->SetImportAll();
+  mLastTreeNode = n;
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//                      Interfaces for Javascript style export and import
+////////////////////////////////////////////////////////////////////////////////////////
+
+// Takes no argument.
+TreeNode* ASTBuilder::BuildImport() {
+  ImportNode *n = (ImportNode*)gTreePool.NewTreeNode(sizeof(ImportNode));
+  new (n) ImportNode();
+
+  mLastTreeNode = n;
+  return mLastTreeNode;
+}
+
+// Takes no argument.
+TreeNode* ASTBuilder::BuildExport() {
+  ExportNode *n = (ExportNode*)gTreePool.NewTreeNode(sizeof(ExportNode));
+  new (n) ExportNode();
+
+  mLastTreeNode = n;
+  return mLastTreeNode;
+}
+
+// It set mLastTreeNode to a type import/export.
+TreeNode* ASTBuilder::SetIsXXportType() {
+  if (mLastTreeNode->IsImport()) {
+    ImportNode *inode = (ImportNode*)mLastTreeNode;
+    inode->SetImportType();
+  } else if (mLastTreeNode->IsExport()) {
+    ExportNode *enode = (ExportNode*)mLastTreeNode;
+    enode->SetIsExportType();
+  } else {
+    MERROR("Unsupported action.");
+  }
+
+  return mLastTreeNode;
+}
+
+// It takes one argument, the pairs.
+// The pairs could be complicated in Javascript. We will let ImportNode or
+// ExportNode to handle by themselves.
+TreeNode* ASTBuilder::SetPairs() {
+  TreeNode *pairs = NULL;
+  Param p = mParams[0];
+  if (!p.mIsEmpty && p.mIsTreeNode) {
+    pairs = p.mData.mTreeNode;
+    if (mLastTreeNode->IsImport()) {
+      ImportNode *inode = (ImportNode*)mLastTreeNode;
+      inode->AddPair(pairs);
+    } else if (mLastTreeNode->IsExport()) {
+      ExportNode *enode = (ExportNode*)mLastTreeNode;
+      enode->AddPair(pairs);
+    }
+  }
+
+  return mLastTreeNode;
+}
+
+TreeNode* ASTBuilder::SetDefaultPairs() {
+  TreeNode *pairs = NULL;
+  Param p = mParams[0];
+  if (!p.mIsEmpty && p.mIsTreeNode) {
+    pairs = p.mData.mTreeNode;
+    if (mLastTreeNode->IsImport()) {
+      ImportNode *inode = (ImportNode*)mLastTreeNode;
+      inode->AddDefaultPair(pairs);
+    } else if (mLastTreeNode->IsExport()) {
+      ExportNode *enode = (ExportNode*)mLastTreeNode;
+      enode->AddDefaultPair(pairs);
+    }
+  }
+
+  return mLastTreeNode;
+}
+
+// It takes
+//   1. One argument:  the mBefore object. Usually happens in
+//                       export = x
+//   2. Two arguments: the mBefore and mAfter. In TS, it has
+//                       import x = require(y)
+//                     [NOTE] In .spec file, put the arguments in order of
+//                            SetSinglePairs(before, after)
+
+TreeNode* ASTBuilder::SetSinglePairs() {
+  TreeNode *before = NULL;
+  TreeNode *after = NULL;
+
+  if (mParams.size() == 2) {
+    Param p = mParams[0];
+    if (!p.mIsEmpty && p.mIsTreeNode)
+      before = p.mData.mTreeNode;
+    p = mParams[1];
+    if (!p.mIsEmpty && p.mIsTreeNode)
+      after = p.mData.mTreeNode;
+  } else {
+    MASSERT(mParams.size() == 1);
+    Param p = mParams[0];
+    if (!p.mIsEmpty && p.mIsTreeNode)
+      before = p.mData.mTreeNode;
+  }
+
+  if (mLastTreeNode->IsImport()) {
+    ImportNode *inode = (ImportNode*)mLastTreeNode;
+    inode->AddSinglePair(before, after);
+  } else if (mLastTreeNode->IsExport()) {
+    ExportNode *enode = (ExportNode*)mLastTreeNode;
+    enode->AddSinglePair(before, after);
+  }
+
+  return mLastTreeNode;
+}
+
+// Takes one argument, the 'from' module
+TreeNode* ASTBuilder::SetFromModule() {
+  Param p = mParams[0];
+  if (!p.mIsEmpty && p.mIsTreeNode) {
+    TreeNode *t = p.mData.mTreeNode;
+    if (mLastTreeNode->IsImport()) {
+      ImportNode *inode = (ImportNode*)mLastTreeNode;
+      inode->SetTarget(t);
+    } else if (mLastTreeNode->IsExport()) {
+      ExportNode *enode = (ExportNode*)mLastTreeNode;
+      enode->SetTarget(t);
+    }
+  }
+  return mLastTreeNode;
+}
+
+// Take no argument, or one argument.
+// (1) If no argument, it applies to all pairs of import/export.
+//     This happens right after BuildImport or BuildExport, and there is no existing
+//     pairs. In this case, we create a new pair and sets it to *.
+// (2) If one argument, it's the new name of '*' (aka the Everything),
+//     and is saved in mAfter of the pair.
+//
+// In either case, we need create a new and the only pair for XXport node.
+TreeNode* ASTBuilder::SetIsEverything() {
+  XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+  new (n) XXportAsPairNode();
+  n->SetIsEverything();
+
+  if (mParams.size() == 1) {
+    Param p = mParams[0];
+    if (!p.mIsEmpty && p.mIsTreeNode) {
+      TreeNode *expr = p.mData.mTreeNode;
+      n->SetBefore(expr);
+    }
+  }
+
+  if (mLastTreeNode->IsImport()) {
+    ImportNode *inode = (ImportNode*)mLastTreeNode;
+    MASSERT(!inode->GetPairsNum());
+    inode->AddPair(n);
+  } else if (mLastTreeNode->IsExport()) {
+    ExportNode *enode = (ExportNode*)mLastTreeNode;
+    MASSERT(!enode->GetPairsNum());
+    enode->AddPair(n);
+  }
+
+  return mLastTreeNode;
+}
+
+// Right now it takes no argument. mLastTreeNode is the implicit argument
+TreeNode* ASTBuilder::SetAsNamespace() {
+  MASSERT(mLastTreeNode->IsXXportAsPair());
+  XXportAsPairNode *pair = (XXportAsPairNode*)mLastTreeNode;
+  pair->SetAsNamespace();
+  return mLastTreeNode;
+}
+
+// 1. It takes two arguments, before and after.
+// 2. It takes one argument, before.
+TreeNode* ASTBuilder::BuildXXportAsPair() {
+
+  TreeNode *before = NULL;
+  TreeNode *after = NULL;
+
+  Param p = mParams[0];
+  if (!p.mIsEmpty && p.mIsTreeNode) {
+    before = p.mData.mTreeNode;
+  }
+
+  if (mParams.size() == 2) {
+    p = mParams[1];
+    if (!p.mIsEmpty) {
+      if (p.mIsTreeNode) {
+        after = p.mData.mTreeNode;
+      } else {
+        after = BuildIdentifier(p.mData.mToken);
+      }
+    }
+  }
+
+  XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+  new (n) XXportAsPairNode();
+
+  if (before)
+    n->SetBefore(before);
+  if (after)
+    n->SetAfter(after);
+
+  mLastTreeNode = n;
+  return mLastTreeNode;
+}
+
+// It takes one arguments, the 'x' in the '* as x'.
+TreeNode* ASTBuilder::BuildXXportAsPairEverything() {
+  MASSERT(mParams.size() == 1);
+
+  TreeNode *tree = NULL;
+
+  Param p = mParams[0];
+  if (!p.mIsEmpty && p.mIsTreeNode) {
+    tree = p.mData.mTreeNode;
+  }
+
+  XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+  new (n) XXportAsPairNode();
+  n->SetIsEverything();
+
+  if (tree)
+    n->SetBefore(tree);
+
+  mLastTreeNode = n;
+  return mLastTreeNode;
+}
+
+// It takes one arguments, the name after 'as'.
+TreeNode* ASTBuilder::BuildXXportAsPairDefault() {
+  MASSERT(mParams.size() == 1);
+
+  TreeNode *tree = NULL;
+
+  Param p = mParams[0];
+  if (!p.mIsEmpty && p.mIsTreeNode) {
+    tree = p.mData.mTreeNode;
+  }
+
+  XXportAsPairNode *n = (XXportAsPairNode*)gTreePool.NewTreeNode(sizeof(XXportAsPairNode));
+  new (n) XXportAsPairNode();
+  n->SetIsDefault();
+
+  if (tree)
+    n->SetBefore(tree);
+
+  mLastTreeNode = n;
+  return mLastTreeNode;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//          BuildExternalDeclaration and BuildGlobalExternalDeclaration
+/////////////////////////////////////////////////////////////////////////////////////////
+
+// It takes one arguments
+TreeNode* ASTBuilder::BuildExternalDeclaration() {
+  MASSERT(mParams.size() == 1);
+
+  TreeNode *tree = NULL;
+
+  Param p = mParams[0];
+  if (!p.mIsEmpty && p.mIsTreeNode) {
+    tree = p.mData.mTreeNode;
+  }
+
+  DeclareNode *n = (DeclareNode*)gTreePool.NewTreeNode(sizeof(DeclareNode));
+  new (n) DeclareNode();
+  n->AddDecl(tree);
+
+  mLastTreeNode = n;
+  return mLastTreeNode;
+}
+
+// It takes one arguments
+TreeNode* ASTBuilder::BuildGlobalExternalDeclaration() {
+  MASSERT(mParams.size() == 1);
+
+  TreeNode *tree = NULL;
+
+  Param p = mParams[0];
+  if (!p.mIsEmpty && p.mIsTreeNode) {
+    tree = p.mData.mTreeNode;
+  }
+
+  DeclareNode *n = (DeclareNode*)gTreePool.NewTreeNode(sizeof(DeclareNode));
+  new (n) DeclareNode();
+  n->AddDecl(tree);
+  n->SetIsGlobal();
+
+  mLastTreeNode = n;
+  return mLastTreeNode;
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////
+
 // Takes one argument, the expression of the parenthesis
 TreeNode* ASTBuilder::BuildParenthesis() {
   if (mTrace)
@@ -225,7 +775,7 @@ TreeNode* ASTBuilder::BuildParenthesis() {
   MASSERT(!p.mIsEmpty && p.mIsTreeNode);
   expr = p.mData.mTreeNode;
 
-  ParenthesisNode *n = (ParenthesisNode*)mTreePool->NewTreeNode(sizeof(ParenthesisNode));
+  ParenthesisNode *n = (ParenthesisNode*)gTreePool.NewTreeNode(sizeof(ParenthesisNode));
   new (n) ParenthesisNode();
   n->SetExpr(expr);
 
@@ -247,7 +797,7 @@ TreeNode* ASTBuilder::BuildCast() {
   TreeNode *desttype = p_a.mData.mTreeNode;
   TreeNode *expr = p_b.mData.mTreeNode;
 
-  CastNode *n = (CastNode*)mTreePool->NewTreeNode(sizeof(CastNode));
+  CastNode *n = (CastNode*)gTreePool.NewTreeNode(sizeof(CastNode));
   new (n) CastNode();
 
   n->SetDestType(desttype);
@@ -257,6 +807,35 @@ TreeNode* ASTBuilder::BuildCast() {
   return n;
 }
 
+// It takes one parameter, the word tells what literal it is.
+TreeNode* ASTBuilder::BuildLiteral() {
+  if (mTrace)
+    std::cout << "In BuildLiteral" << std::endl;
+
+  MASSERT(mParams.size() == 1);
+  Param p_a = mParams[0];
+  MASSERT(p_a.mIsTreeNode);
+
+  TreeNode *tree = p_a.mData.mTreeNode;
+  bool is_void = false;
+  if (tree->IsPrimType()) {
+    PrimTypeNode *prim = (PrimTypeNode*)tree;
+    if (prim->GetPrimType() == TY_Void)
+      is_void = true;
+  }
+
+  if (is_void) {
+    LitData data;
+    data.mType = LT_VoidLiteral;
+    LiteralNode *n = (LiteralNode*)gTreePool.NewTreeNode(sizeof(LiteralNode));
+    new (n) LiteralNode(data);
+    mLastTreeNode = n;
+    return n;
+  } else {
+    MERROR("Unspported in BuildLiteral().");
+  }
+}
+
 
 // For first parameter has to be an operator.
 TreeNode* ASTBuilder::BuildUnaryOperation() {
@@ -272,7 +851,7 @@ TreeNode* ASTBuilder::BuildUnaryOperation() {
   MASSERT(token->IsOperator() && "First param of Unary Operator is not an operator token?");
 
   // create the sub tree
-  UnaOperatorNode *n = (UnaOperatorNode*)mTreePool->NewTreeNode(sizeof(UnaOperatorNode));
+  UnaOperatorNode *n = (UnaOperatorNode*)gTreePool.NewTreeNode(sizeof(UnaOperatorNode));
   new (n) UnaOperatorNode(token->GetOprId());
 
   // set 1st param
@@ -282,7 +861,6 @@ TreeNode* ASTBuilder::BuildUnaryOperation() {
     TreeNode *tn = CreateTokenTreeNode(p_b.mData.mToken);
     n->SetOpnd(tn);
   }
-  n->GetOpnd()->SetParent(n);
 
   mLastTreeNode = n;
   return n;
@@ -313,52 +891,234 @@ TreeNode* ASTBuilder::BuildBinaryOperation() {
   MASSERT(token->IsOperator() && "Second param of Binary Operator is not an operator token?");
 
   // create the sub tree
-  BinOperatorNode *n = (BinOperatorNode*)mTreePool->NewTreeNode(sizeof(BinOperatorNode));
+  BinOperatorNode *n = (BinOperatorNode*)gTreePool.NewTreeNode(sizeof(BinOperatorNode));
   new (n) BinOperatorNode(token->GetOprId());
   mLastTreeNode = n;
 
   // set 1st param
   if (p_a.mIsTreeNode)
-    n->mOpndA = p_a.mData.mTreeNode;
+    n->SetOpndA(p_a.mData.mTreeNode);
   else {
     TreeNode *tn = CreateTokenTreeNode(p_a.mData.mToken);
-    n->mOpndA = tn;
+    n->SetOpndA(tn);
   }
-  n->mOpndA->SetParent(n);
 
   // set 2nd param
   if (p_c.mIsTreeNode)
-    n->mOpndB = p_c.mData.mTreeNode;
+    n->SetOpndB(p_c.mData.mTreeNode);
   else {
     TreeNode *tn = CreateTokenTreeNode(p_c.mData.mToken);
-    n->mOpndB = tn;
+    n->SetOpndB(tn);
   }
-  n->mOpndB->SetParent(n);
 
   return n;
 }
 
-// Assignment is actually a binary operator.
-TreeNode* ASTBuilder::BuildAssignment() {
+// For second parameter has to be an operator.
+TreeNode* ASTBuilder::BuildTernaryOperation() {
   if (mTrace)
-    std::cout << "In assignment --> BuildBinary" << std::endl;
-  return BuildBinaryOperation();
-}
+    std::cout << "In BuildTernaryOperation" << std::endl;
+
+  MASSERT(mParams.size() == 3 && "Ternary Operator has NO 3 params?");
+  Param p_a = mParams[0];
+  Param p_b = mParams[1];
+  Param p_c = mParams[2];
+
+  // create the sub tree
+  TerOperatorNode *n = (TerOperatorNode*)gTreePool.NewTreeNode(sizeof(TerOperatorNode));
+  new (n) TerOperatorNode();
+  mLastTreeNode = n;
+
+  MASSERT(p_a.mIsTreeNode);
+  n->SetOpndA(p_a.mData.mTreeNode);
+
+  MASSERT(p_b.mIsTreeNode);
+  n->SetOpndB(p_b.mData.mTreeNode);
+
+  MASSERT(p_c.mIsTreeNode);
+  n->SetOpndC(p_c.mData.mTreeNode);
+
+  return n;
+}
+
+// Takes one argument. Set the tree as a statement.
+// We still return the previous mLastTreeNode.
+TreeNode* ASTBuilder::SetIsStmt() {
+  if (mTrace)
+    std::cout << "In SetIsStmt" << std::endl;
+
+  Param p_tree = mParams[0];
+  if (!p_tree.mIsEmpty) {
+    MASSERT(p_tree.mIsTreeNode);
+    TreeNode *treenode = p_tree.mData.mTreeNode;
+    treenode->SetIsStmt();
+  }
+
+  return mLastTreeNode;
+}
+
+// 1. Takes one argument. Set the tree as an optional node.
+// 2. Takes no argument. Set mLastTreeNode as optional.
+// We still return the previous mLastTreeNode.
+TreeNode* ASTBuilder::SetIsOptional() {
+  if (mTrace)
+    std::cout << "In SetIsOptional" << std::endl;
+
+  TreeNode *treenode = NULL;
+  if (mParams.size() > 0) {
+    Param p_tree = mParams[0];
+    if (!p_tree.mIsEmpty) {
+      if (p_tree.mIsTreeNode)
+        treenode = p_tree.mData.mTreeNode;
+      else
+        treenode = BuildIdentifier(p_tree.mData.mToken);
+    }
+  } else {
+    treenode = mLastTreeNode;
+  }
+
+  MASSERT(treenode);
+  if (treenode->IsFunction()) {
+    FunctionNode *f = (FunctionNode*)mLastTreeNode;
+    f->GetFuncName()->SetIsOptional();
+  } else {
+    treenode->SetIsOptional();
+  }
+
+  return mLastTreeNode;
+}
+
+// Takes one argument. Set the tree as a non null node.
+// We still return the previous mLastTreeNode.
+TreeNode* ASTBuilder::SetIsNonNull() {
+  if (mTrace)
+    std::cout << "In SetIsNonNull" << std::endl;
+
+  Param p_tree = mParams[0];
+  if (!p_tree.mIsEmpty) {
+    MASSERT(p_tree.mIsTreeNode);
+    TreeNode *treenode = p_tree.mData.mTreeNode;
+    treenode->SetIsNonNull();
+  }
+
+  return mLastTreeNode;
+}
+
+// Takes one argument. Set the tree as a rest or spread node.
+// We still return the previous mLastTreeNode.
+TreeNode* ASTBuilder::SetIsRest() {
+  if (mTrace)
+    std::cout << "In SetIsRest" << std::endl;
+
+  Param p_tree = mParams[0];
+  if (!p_tree.mIsEmpty) {
+    MASSERT(p_tree.mIsTreeNode);
+    TreeNode *treenode = p_tree.mData.mTreeNode;
+    treenode->SetIsRest();
+  }
+
+  return mLastTreeNode;
+}
+
+// Takes one argument. Set the tree as a constant node.
+// Or takes no argument. Set mLastTreeNode as constant.
+// We still return the previous mLastTreeNode.
+TreeNode* ASTBuilder::SetIsConst() {
+  if (mTrace)
+    std::cout << "In SetIsConst" << std::endl;
+
+  TreeNode *treenode = NULL;
+
+  if (mParams.size() == 1) {
+    Param p_tree = mParams[0];
+    if (!p_tree.mIsEmpty) {
+      MASSERT(p_tree.mIsTreeNode);
+      treenode = p_tree.mData.mTreeNode;
+    }
+  } else {
+    treenode = mLastTreeNode;
+  }
+
+  treenode->SetIsConst();
+
+  mLastTreeNode = treenode;
+  return mLastTreeNode;
+}
+
+// Takes one argument, which is a primary type node. Set the type as unique.
+// Or takes no argument. Use mLastTreeNode as the argument.
+TreeNode* ASTBuilder::SetIsUnique() {
+  if (mTrace)
+    std::cout << "In SetIsUnique" << std::endl;
+
+  TreeNode *treenode = NULL;
+
+  if (mParams.size() == 1) {
+    Param p_tree = mParams[0];
+    if (!p_tree.mIsEmpty) {
+      MASSERT(p_tree.mIsTreeNode);
+      treenode = p_tree.mData.mTreeNode;
+    }
+  } else {
+    treenode = mLastTreeNode;
+  }
+
+  MASSERT(treenode);
+  MASSERT(treenode->IsPrimType());
+  PrimTypeNode *p = (PrimTypeNode*)treenode;
+  p->SetIsUnique();
+
+  return treenode;
+}
+
+
+// Assignment is actually a binary operator.
+TreeNode* ASTBuilder::BuildAssignment() {
+  if (mTrace)
+    std::cout << "In assignment --> BuildBinary" << std::endl;
+  return BuildBinaryOperation();
+}
 
 // Takes one argument, the result expression
+// Or takes 0 argument, and it's a simple return stmt.
 TreeNode* ASTBuilder::BuildReturn() {
   if (mTrace)
     std::cout << "In BuildReturn" << std::endl;
 
-  ReturnNode *result = (ReturnNode*)mTreePool->NewTreeNode(sizeof(ReturnNode));
+  ReturnNode *result = (ReturnNode*)gTreePool.NewTreeNode(sizeof(ReturnNode));
   new (result) ReturnNode();
 
-  Param p_result = mParams[0];
-  if (!p_result.mIsEmpty) {
-    if (!p_result.mIsTreeNode)
-      MERROR("The return value is not a tree node.");
-    TreeNode *result_value = p_result.mData.mTreeNode;
-    result->SetResult(result_value);
+  if (mParams.size() == 1) {
+    Param p_result = mParams[0];
+    if (!p_result.mIsEmpty) {
+      if (!p_result.mIsTreeNode)
+        MERROR("The return value is not a tree node.");
+      TreeNode *result_value = p_result.mData.mTreeNode;
+      result->SetResult(result_value);
+    }
+  }
+
+  mLastTreeNode = result;
+  return mLastTreeNode;
+}
+
+// Takes one argument, the result expression
+// Or takes 0 argument, and it's a simple return stmt.
+TreeNode* ASTBuilder::BuildYield() {
+  if (mTrace)
+    std::cout << "In BuildYield" << std::endl;
+
+  YieldNode *result = (YieldNode*)gTreePool.NewTreeNode(sizeof(YieldNode));
+  new (result) YieldNode();
+
+  if (mParams.size() == 1) {
+    Param p_result = mParams[0];
+    if (!p_result.mIsEmpty) {
+      if (!p_result.mIsTreeNode)
+        MERROR("The return value is not a tree node.");
+      TreeNode *result_value = p_result.mData.mTreeNode;
+      result->SetResult(result_value);
+    }
   }
 
   mLastTreeNode = result;
@@ -370,7 +1130,7 @@ TreeNode* ASTBuilder::BuildCondBranch() {
   if (mTrace)
     std::cout << "In BuildCondBranch" << std::endl;
 
-  CondBranchNode *cond_branch = (CondBranchNode*)mTreePool->NewTreeNode(sizeof(CondBranchNode));
+  CondBranchNode *cond_branch = (CondBranchNode*)gTreePool.NewTreeNode(sizeof(CondBranchNode));
   new (cond_branch) CondBranchNode();
 
   Param p_cond = mParams[0];
@@ -397,7 +1157,7 @@ TreeNode* ASTBuilder::AddCondBranchTrueStatement() {
   if (!p_true.mIsEmpty) {
     if (!p_true.mIsTreeNode)
       MERROR("The condition expr is not a tree node.");
-    TreeNode *true_expr = CvtToBlock(p_true.mData.mTreeNode);
+    TreeNode *true_expr = p_true.mData.mTreeNode;
     cond_branch->SetTrueBranch(true_expr);
   }
 
@@ -414,7 +1174,7 @@ TreeNode* ASTBuilder::AddCondBranchFalseStatement() {
   if (!p_false.mIsEmpty) {
     if (!p_false.mIsTreeNode)
       MERROR("The condition expr is not a tree node.");
-    TreeNode *false_expr = CvtToBlock(p_false.mData.mTreeNode);
+    TreeNode *false_expr = p_false.mData.mTreeNode;
     cond_branch->SetFalseBranch(false_expr);
   }
 
@@ -447,27 +1207,56 @@ TreeNode* ASTBuilder::AddLabel() {
   return tree;
 }
 
-// BuildBreak takes one argument, an identifer node of empty.
+// BuildBreak takes 1) one argument, an identifer node
+//                  2) empty
 TreeNode* ASTBuilder::BuildBreak() {
   if (mTrace)
     std::cout << "In BuildBreak " << std::endl;
 
-  BreakNode *break_node = (BreakNode*)mTreePool->NewTreeNode(sizeof(BreakNode));
+  BreakNode *break_node = (BreakNode*)gTreePool.NewTreeNode(sizeof(BreakNode));
   new (break_node) BreakNode();
 
-  MASSERT(mParams.size() == 1 && "BuildBreak has NO 1 params?");
-  Param p_target = mParams[0];
-  if (!p_target.mIsEmpty) {
-    MASSERT(p_target.mIsTreeNode && "Target in BuildBreak is not a tree.");
-    TreeNode *target = p_target.mData.mTreeNode;
-    MASSERT(target->IsIdentifier() && "Target in BuildBreak is not an identifier.");
-    break_node->SetTarget(target);
+  TreeNode *target = NULL;
+
+  if (mParams.size() == 1) {
+    Param p_target = mParams[0];
+    if (!p_target.mIsEmpty) {
+      MASSERT(p_target.mIsTreeNode && "Target in BuildBreak is not a tree.");
+      target = p_target.mData.mTreeNode;
+      MASSERT(target->IsIdentifier() && "Target in BuildBreak is not an identifier.");
+      break_node->SetTarget(target);
+    }
   }
 
   mLastTreeNode = break_node;
   return break_node;
 }
 
+// BuildContinue takes 1) one argument, an identifer node
+//                  2) empty
+TreeNode* ASTBuilder::BuildContinue() {
+  if (mTrace)
+    std::cout << "In BuildContinue " << std::endl;
+
+  ContinueNode *continue_node = (ContinueNode*)gTreePool.NewTreeNode(sizeof(ContinueNode));
+  new (continue_node) ContinueNode();
+
+  TreeNode *target = NULL;
+
+  if (mParams.size() == 1) {
+    Param p_target = mParams[0];
+    if (!p_target.mIsEmpty) {
+      MASSERT(p_target.mIsTreeNode && "Target in BuildContinue is not a tree.");
+      target = p_target.mData.mTreeNode;
+      MASSERT(target->IsIdentifier() && "Target in BuildContinue is not an identifier.");
+      continue_node->SetTarget(target);
+    }
+  }
+
+  mLastTreeNode = continue_node;
+  return continue_node;
+}
+
 // BuildForLoop takes four arguments.
 //  1. init statement, could be a list
 //  2. cond expression, should be a boolean expresion.
@@ -477,7 +1266,7 @@ TreeNode* ASTBuilder::BuildForLoop() {
   if (mTrace)
     std::cout << "In BuildForLoop " << std::endl;
 
-  ForLoopNode *for_loop = (ForLoopNode*)mTreePool->NewTreeNode(sizeof(ForLoopNode));
+  ForLoopNode *for_loop = (ForLoopNode*)gTreePool.NewTreeNode(sizeof(ForLoopNode));
   new (for_loop) ForLoopNode();
 
   MASSERT(mParams.size() == 4 && "BuildForLoop has NO 4 params?");
@@ -518,7 +1307,7 @@ TreeNode* ASTBuilder::BuildForLoop() {
   Param p_body = mParams[3];
   if (!p_body.mIsEmpty) {
     MASSERT(p_body.mIsTreeNode && "ForLoop body is not a treenode.");
-    TreeNode *body = CvtToBlock(p_body.mData.mTreeNode);
+    TreeNode *body = p_body.mData.mTreeNode;
     for_loop->SetBody(body);
   }
 
@@ -526,11 +1315,142 @@ TreeNode* ASTBuilder::BuildForLoop() {
   return mLastTreeNode;
 }
 
+// BuildForLoop_In takes 3 or 2 arguments.
+// If 3 arguments
+//  1. The decl of variable.
+//  2. The first explicit arg. This is the set of data
+//  3. The body.
+// If 2 arguments
+//  1. The implicit arg, mLastTreeNode. This is a decl of variable.
+//  2. The first explicit arg. This is the set of data
+//  3. The body.
+TreeNode* ASTBuilder::BuildForLoop_In() {
+  if (mTrace)
+    std::cout << "In BuildForLoop_In " << std::endl;
+
+  ForLoopNode *for_loop = (ForLoopNode*)gTreePool.NewTreeNode(sizeof(ForLoopNode));
+  new (for_loop) ForLoopNode();
+  for_loop->SetProp(FLP_JSIn);
+
+  TreeNode *the_var = NULL;
+  TreeNode *the_set = NULL;
+  TreeNode *the_body = NULL;
+
+  if (mParams.size() == 3) {
+    Param p_var = mParams[0];
+    if (!p_var.mIsEmpty) {
+      MASSERT(p_var.mIsTreeNode);
+      the_var = p_var.mData.mTreeNode;
+    }
+
+    Param p_set = mParams[1];
+    if (!p_set.mIsEmpty) {
+      MASSERT(p_set.mIsTreeNode);
+      the_set = p_set.mData.mTreeNode;
+    }
+
+    Param p_body = mParams[2];
+    if (!p_body.mIsEmpty) {
+      MASSERT(p_body.mIsTreeNode);
+      the_body = p_body.mData.mTreeNode;
+    }
+  } else {
+    MASSERT(mParams.size() == 2);
+
+    the_var = mLastTreeNode;
+
+    Param p_set = mParams[0];
+    if (!p_set.mIsEmpty) {
+      MASSERT(p_set.mIsTreeNode);
+      the_set = p_set.mData.mTreeNode;
+    }
+
+    Param p_body = mParams[1];
+    if (!p_body.mIsEmpty) {
+      MASSERT(p_body.mIsTreeNode);
+      the_body = p_body.mData.mTreeNode;
+    }
+  }
+
+  for_loop->SetVariable(the_var);
+  for_loop->SetSet(the_set);
+  for_loop->SetBody(the_body);
+
+  mLastTreeNode = for_loop;
+  return mLastTreeNode;
+}
+
+// BuildForLoop_Of takes 3 or 2 arguments.
+// If 3 arguments
+//  1. The decl of variable.
+//  2. The first explicit arg. This is the set of data
+//  3. The body.
+// If 2 arguments
+//  1. The implicit arg, mLastTreeNode. This is a decl of variable.
+//  2. The first explicit arg. This is the set of data
+//  3. The body.
+TreeNode* ASTBuilder::BuildForLoop_Of() {
+  if (mTrace)
+    std::cout << "In BuildForLoop_Of " << std::endl;
+
+  ForLoopNode *for_loop = (ForLoopNode*)gTreePool.NewTreeNode(sizeof(ForLoopNode));
+  new (for_loop) ForLoopNode();
+  for_loop->SetProp(FLP_JSOf);
+
+  TreeNode *the_var = NULL;
+  TreeNode *the_set = NULL;
+  TreeNode *the_body = NULL;
+
+  if (mParams.size() == 3) {
+    Param p_var = mParams[0];
+    if (!p_var.mIsEmpty) {
+      MASSERT(p_var.mIsTreeNode);
+      the_var = p_var.mData.mTreeNode;
+    }
+
+    Param p_set = mParams[1];
+    if (!p_set.mIsEmpty) {
+      MASSERT(p_set.mIsTreeNode);
+      the_set = p_set.mData.mTreeNode;
+    }
+
+    Param p_body = mParams[2];
+    if (!p_body.mIsEmpty) {
+      MASSERT(p_body.mIsTreeNode);
+      the_body = p_body.mData.mTreeNode;
+    }
+  } else {
+    MASSERT(mParams.size() == 2);
+
+    the_var = mLastTreeNode;
+
+    Param p_set = mParams[0];
+    if (!p_set.mIsEmpty) {
+      MASSERT(p_set.mIsTreeNode);
+      the_set = p_set.mData.mTreeNode;
+    }
+
+    Param p_body = mParams[1];
+    if (!p_body.mIsEmpty) {
+      MASSERT(p_body.mIsTreeNode);
+      the_body = p_body.mData.mTreeNode;
+    }
+  }
+
+  for_loop->SetVariable(the_var);
+  for_loop->SetSet(the_set);
+  for_loop->SetBody(the_body);
+
+  mLastTreeNode = for_loop;
+  return mLastTreeNode;
+}
+
+
 TreeNode* ASTBuilder::BuildWhileLoop() {
   if (mTrace)
     std::cout << "In BuildWhileLoop " << std::endl;
 
-  WhileLoopNode *while_loop = (WhileLoopNode*)mTreePool->NewTreeNode(sizeof(WhileLoopNode));
+  WhileLoopNode *while_loop = (WhileLoopNode*)gTreePool.NewTreeNode(sizeof(WhileLoopNode));
   new (while_loop) WhileLoopNode();
 
   MASSERT(mParams.size() == 2 && "BuildWhileLoop has NO 2 params?");
@@ -545,7 +1465,7 @@ TreeNode* ASTBuilder::BuildWhileLoop() {
   Param p_body = mParams[1];
   if (!p_body.mIsEmpty) {
     MASSERT(p_body.mIsTreeNode && "WhileLoop body is not a treenode.");
-    TreeNode *body = CvtToBlock(p_body.mData.mTreeNode);
+    TreeNode *body = p_body.mData.mTreeNode;
     while_loop->SetBody(body);
   }
 
@@ -557,7 +1477,7 @@ TreeNode* ASTBuilder::BuildDoLoop() {
   if (mTrace)
     std::cout << "In BuildDoLoop " << std::endl;
 
-  DoLoopNode *do_loop = (DoLoopNode*)mTreePool->NewTreeNode(sizeof(DoLoopNode));
+  DoLoopNode *do_loop = (DoLoopNode*)gTreePool.NewTreeNode(sizeof(DoLoopNode));
   new (do_loop) DoLoopNode();
 
   MASSERT(mParams.size() == 2 && "BuildDoLoop has NO 2 params?");
@@ -572,7 +1492,7 @@ TreeNode* ASTBuilder::BuildDoLoop() {
   Param p_body = mParams[1];
   if (!p_body.mIsEmpty) {
     MASSERT(p_body.mIsTreeNode && "DoLoop body is not a treenode.");
-    TreeNode *body = CvtToBlock(p_body.mData.mTreeNode);
+    TreeNode *body = p_body.mData.mTreeNode;
     do_loop->SetBody(body);
   }
 
@@ -586,7 +1506,7 @@ TreeNode* ASTBuilder::BuildSwitchLabel() {
     std::cout << "In BuildSwitchLabel " << std::endl;
 
   SwitchLabelNode *label =
-    (SwitchLabelNode*)mTreePool->NewTreeNode(sizeof(SwitchLabelNode));
+    (SwitchLabelNode*)gTreePool.NewTreeNode(sizeof(SwitchLabelNode));
   new (label) SwitchLabelNode();
 
   MASSERT(mParams.size() == 1 && "BuildSwitchLabel has NO 1 params?");
@@ -606,110 +1526,79 @@ TreeNode* ASTBuilder::BuildDefaultSwitchLabel() {
   if (mTrace)
     std::cout << "In BuildDefaultSwitchLabel " << std::endl;
   SwitchLabelNode *label =
-    (SwitchLabelNode*)mTreePool->NewTreeNode(sizeof(SwitchLabelNode));
+    (SwitchLabelNode*)gTreePool.NewTreeNode(sizeof(SwitchLabelNode));
   new (label) SwitchLabelNode();
   label->SetIsDefault(true);
   mLastTreeNode = label;
   return label;
 }
 
-// BuildOneCase takes two arguments, the expression of a label and a
-// and the statements under the label. Both the label and the statements
-// could be a PassNode, and I need look into it. We don't want to carry
-// PassNode into the SwitchCaseNode.
+// BuildOneCase takes
+// 1. two arguments, the expression of a label and the statements under the label.
+// 2. One arguemnt, which is the statements. The label is mLastTreeNode.
 
 TreeNode* ASTBuilder::BuildOneCase() {
   if (mTrace)
     std::cout << "In BuildOneCase " << std::endl;
 
   SwitchCaseNode *case_node =
-    (SwitchCaseNode*)mTreePool->NewTreeNode(sizeof(SwitchCaseNode));
+    (SwitchCaseNode*)gTreePool.NewTreeNode(sizeof(SwitchCaseNode));
   new (case_node) SwitchCaseNode();
 
-  MASSERT(mParams.size() == 2 && "BuildOneCase has NO 1 params?");
+  TreeNode *label = NULL;
+  TreeNode *stmt = NULL;
 
-  Param p_label = mParams[0];
-  MASSERT(!p_label.mIsEmpty);
-  MASSERT(p_label.mIsTreeNode && "Labels in BuildOneCase is not a tree.");
-  TreeNode *label = p_label.mData.mTreeNode;
-  case_node->AddLabel(label);
+  if (mParams.size() == 2) {
+    Param p_label = mParams[0];
+    if (!p_label.mIsEmpty) {
+      MASSERT(p_label.mIsTreeNode && "Labels in BuildOneCase is not a tree.");
+      label = p_label.mData.mTreeNode;
+    }
+    Param p_stmt = mParams[1];
+    if (!p_stmt.mIsEmpty) {
+      MASSERT(p_stmt.mIsTreeNode && "Stmts in BuildOneCase is not a tree.");
+      stmt = p_stmt.mData.mTreeNode;
+    }
+  } else {
+    label = mLastTreeNode;
+    Param p_stmt = mParams[0];
+    if (!p_stmt.mIsEmpty) {
+      MASSERT(p_stmt.mIsTreeNode && "Stmts in BuildOneCase is not a tree.");
+      stmt = p_stmt.mData.mTreeNode;
+    }
+  }
 
-  Param p_stmt = mParams[1];
-  MASSERT(!p_stmt.mIsEmpty);
-  MASSERT(p_stmt.mIsTreeNode && "Stmts in BuildOneCase is not a tree.");
-  TreeNode *stmt = p_stmt.mData.mTreeNode;
-  case_node->AddStmt(stmt);
+  if (label)
+    case_node->AddLabel(label);
+  if (stmt)
+    case_node->AddStmt(stmt);
 
   mLastTreeNode = case_node;
   return case_node;
 }
 
-SwitchCaseNode* ASTBuilder::SwitchLabelToCase(SwitchLabelNode *label) {
-  SwitchCaseNode *case_node =
-    (SwitchCaseNode*)mTreePool->NewTreeNode(sizeof(SwitchCaseNode));
-  new (case_node) SwitchCaseNode();
-  case_node->AddLabel(label);
-  return case_node;
-}
-
-// This takes one argument, which is all SwitchCaseNode-s. It could be
-// a PassNode. We don't handle it at all. We simply forward this tree node
-// up to the parent, which should be final Switch Node.
-TreeNode* ASTBuilder::BuildAllCases() {
-  if (mTrace)
-    std::cout << "In BuildAllCases " << std::endl;
-
-  MASSERT(mParams.size() == 1 && "BuildAllCases has NO 1 params?");
-  Param p_cases = mParams[0];
-  MASSERT(!p_cases.mIsEmpty);
-  MASSERT(p_cases.mIsTreeNode && "Cases in BuildAllCases is not a tree.");
-  TreeNode *cases = p_cases.mData.mTreeNode;
-
-  // We want to make sure every tree node after BuildAllCases() is
-  // a SwitchCaseNode. This will ease the handling in future AST process.
-  // So for those SwitchLabelNode which only have no statement, will be
-  // converted to a SwitchCaseNode.
-
-  if (cases->IsPass()) {
-    PassNode *pass = (PassNode*)cases;
-    for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
-      TreeNode *child = pass->GetChild(i);
-      if (child->IsSwitchLabel()) {
-        SwitchCaseNode *newcase = SwitchLabelToCase((SwitchLabelNode*)child);
-        pass->SetChild(i, newcase);
-      }
-    }
-  } else if (cases->IsSwitchLabel()) {
-    SwitchLabelNode *label = (SwitchLabelNode*)cases;
-    SwitchCaseNode *newcase = SwitchLabelToCase(label);
-    cases = newcase;
-  }
-
-  mLastTreeNode = cases;
-  return cases;
-}
-
 TreeNode* ASTBuilder::BuildSwitch() {
   if (mTrace)
     std::cout << "In BuildSwitch " << std::endl;
 
   SwitchNode *switch_node =
-    (SwitchNode*)mTreePool->NewTreeNode(sizeof(SwitchNode));
+    (SwitchNode*)gTreePool.NewTreeNode(sizeof(SwitchNode));
   new (switch_node) SwitchNode();
 
   MASSERT(mParams.size() == 2 && "BuildSwitch has NO 1 params?");
 
-  Param p_cond = mParams[0];
-  MASSERT(!p_cond.mIsEmpty);
-  MASSERT(p_cond.mIsTreeNode && "Condition in BuildSwitch is not a tree.");
-  TreeNode *cond = p_cond.mData.mTreeNode;
-  switch_node->SetCond(cond);
+  Param p_expr = mParams[0];
+  MASSERT(!p_expr.mIsEmpty);
+  MASSERT(p_expr.mIsTreeNode && "Expression in BuildSwitch is not a tree.");
+  TreeNode *expr = p_expr.mData.mTreeNode;
+  switch_node->SetExpr(expr);
 
   Param p_cases = mParams[1];
   MASSERT(!p_cases.mIsEmpty);
   MASSERT(p_cases.mIsTreeNode && "Cases in BuildSwitch is not a tree.");
   TreeNode *cases = p_cases.mData.mTreeNode;
-  switch_node->AddCase(cases);
+
+  switch_node->AddSwitchCase(cases);
 
   mLastTreeNode = switch_node;
   return switch_node;
@@ -723,118 +1612,610 @@ TreeNode* ASTBuilder::BuildSwitch() {
 //    We need have a list of pending declarations until the scope is created.
 ////////////////////////////////////////////////////////////////////////////////
 
-// AddTypeTo takes two parameters, 1) tree; 2) type
-TreeNode* ASTBuilder::AddTypeTo() {
+// AddType takes two parameters, 1) tree; 2) type
+// or takes one parameter, type, and apply it to mLastTreeNode
+TreeNode* ASTBuilder::AddType() {
   if (mTrace)
-    std::cout << "In AddTypeTo " << std::endl;
+    std::cout << "In AddType " << std::endl;
 
-  MASSERT(mParams.size() == 2 && "BinaryDecl has NO 2 params?");
-  Param p_type = mParams[1];
-  Param p_name = mParams[0];
+  TreeNode *node = NULL;
+  TreeNode *tree_type = NULL;
+
+  if (mParams.size() == 2) {
+    Param p_type = mParams[1];
+    Param p_name = mParams[0];
 
-  MASSERT(!p_type.mIsEmpty && p_type.mIsTreeNode
-          && "Not appropriate type node in AddTypeTo()");
-  TreeNode *tree_type = p_type.mData.mTreeNode;
+    if(!p_type.mIsEmpty && p_type.mIsTreeNode)
+      tree_type = p_type.mData.mTreeNode;
 
-  if (!p_name.mIsTreeNode)
-    MERROR("The variable name should be a IdentifierNode already, but actually NOT?");
-  TreeNode *node = p_name.mData.mTreeNode;
+    if (!p_name.mIsTreeNode)
+      MERROR("The variable name should be a IdentifierNode already, but actually NOT?");
+    node = p_name.mData.mTreeNode;
+
+  } else {
+    Param p_type = mParams[0];
+    if(!p_type.mIsEmpty && p_type.mIsTreeNode)
+      tree_type = p_type.mData.mTreeNode;
+    node = mLastTreeNode;
+  }
 
-  add_type_to(node, tree_type);
+  if (tree_type)
+    add_type_to(node, tree_type);
 
-  return node;
+  mLastTreeNode = node;
+  return mLastTreeNode;
 }
 
-// BuildDecl takes two parameters, 1) type; 2) name
-TreeNode* ASTBuilder::BuildDecl() {
+// AddType takes two parameters, 1) tree; 2) type
+// or takes one parameter, type, and apply it to mLastTreeNode
+TreeNode* ASTBuilder::AddAsType() {
   if (mTrace)
-    std::cout << "In BuildDecl" << std::endl;
-
-  MASSERT(mParams.size() == 2 && "BinaryDecl has NO 2 params?");
-  Param p_type = mParams[0];
-  Param p_name = mParams[1];
+    std::cout << "In AddAsType " << std::endl;
 
-  MASSERT(!p_type.mIsEmpty && p_type.mIsTreeNode
-          && "Not appropriate type node in BuildDecl()");
-  TreeNode *tree_type = p_type.mData.mTreeNode;
+  TreeNode *node = NULL;
+  TreeNode *tree_type = NULL;
 
-  if (!p_name.mIsTreeNode)
-    MERROR("The variable name should be a IdentifierNode already, but actually NOT?");
-  TreeNode *node = p_name.mData.mTreeNode;
+  if (mParams.size() == 2) {
+    Param p_type = mParams[1];
+    Param p_name = mParams[0];
+    if(!p_type.mIsEmpty) {
+      if(p_type.mIsTreeNode)
+        tree_type = p_type.mData.mTreeNode;
+      else
+        MERROR("The variable name should be a IdentifierNode already, but actually NOT?");
+    }
+    node = p_name.mData.mTreeNode;
+  } else {
+    Param p_type = mParams[0];
+    if(!p_type.mIsEmpty && p_type.mIsTreeNode)
+      tree_type = p_type.mData.mTreeNode;
+    node = mLastTreeNode;
+  }
 
-  add_type_to(node, tree_type);
+  if (tree_type) {
+    node->AddAsTypes(tree_type);
+  }
 
   mLastTreeNode = node;
-  return node;
+  return mLastTreeNode;
 }
 
-// BuildField takes two parameters,
-// 1) upper enclosing node, could be another field.
-// 2) name of this field.
-TreeNode* ASTBuilder::BuildField() {
+// BuildDecl usually takes two parameters, 1) type; 2) name
+// It can also take only one parameter: name.
+// It can also take zero parameter, it's mLastTreeNode handled.
+TreeNode* ASTBuilder::BuildDecl() {
   if (mTrace)
-    std::cout << "In BuildField" << std::endl;
+    std::cout << "In BuildDecl" << std::endl;
 
-  MASSERT(mParams.size() == 2 && "BuildField has NO 2 params?");
-  Param p_var_a = mParams[0];
-  Param p_var_b = mParams[1];
+  TreeNode *tree_type = NULL;
+  TreeNode *var = NULL;
 
-  // Both variable should have been created as tree node.
-  if (!p_var_a.mIsTreeNode || !p_var_b.mIsTreeNode) {
-    MERROR("The param in BuildField is not a treenode");
+  if (mParams.size() == 2) {
+    Param p_type = mParams[0];
+    Param p_name = mParams[1];
+    if(!p_type.mIsEmpty && p_type.mIsTreeNode)
+      tree_type = p_type.mData.mTreeNode;
+
+    if (!p_name.mIsTreeNode)
+      MERROR("The variable name should be a IdentifierNode already, but actually NOT?");
+    var = p_name.mData.mTreeNode;
+
+    if (tree_type)
+      add_type_to(var, tree_type);
+
+  } else if (mParams.size() == 1) {
+    Param p_name = mParams[0];
+    if (!p_name.mIsTreeNode)
+      MERROR("The variable name should be a IdentifierNode already, but actually NOT?");
+    var = p_name.mData.mTreeNode;
+  } else {
+    var = mLastTreeNode;
   }
 
-  // The second param should be an IdentifierNode
-  TreeNode *node_a = p_var_a.mIsEmpty ? NULL : p_var_a.mData.mTreeNode;
-  TreeNode *node_b = p_var_b.mIsEmpty ? NULL : p_var_b.mData.mTreeNode;
+  DeclNode *decl = decl = (DeclNode*)gTreePool.NewTreeNode(sizeof(DeclNode));
+  new (decl) DeclNode(var);
 
-  FieldNode *field = NULL;
+  mLastTreeNode = decl;
+  return decl;
+}
 
-  if (node_b->IsPass()) {
-    TreeNode *upper = node_a;
-    PassNode *pass = (PassNode*)node_b;
-    for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
-      TreeNode *child = pass->GetChild(i);
-      MASSERT(child->IsIdentifier());
+TreeNode* ASTBuilder::SetJSVar() {
+  MASSERT(mLastTreeNode->IsDecl());
+  DeclNode *decl = (DeclNode*)mLastTreeNode;
+  decl->SetProp(JS_Var);
+  return mLastTreeNode;
+}
 
-      field = (FieldNode*)mTreePool->NewTreeNode(sizeof(FieldNode));
-      new (field) FieldNode();
-      field->SetUpper(upper);
-      field->SetField((IdentifierNode*)child);
-      field->Init();
+TreeNode* ASTBuilder::SetJSLet() {
+  MASSERT(mLastTreeNode->IsDecl());
+  DeclNode *decl = (DeclNode*)mLastTreeNode;
+  decl->SetProp(JS_Let);
+  return mLastTreeNode;
+}
 
-      upper = field;
-    }
+TreeNode* ASTBuilder::SetJSConst() {
+  MASSERT(mLastTreeNode->IsDecl());
+  DeclNode *decl = (DeclNode*)mLastTreeNode;
+  decl->SetProp(JS_Const);
+  return mLastTreeNode;
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+//                         ArrayElement, ArrayLiteral
+//////////////////////////////////////////////////////////////////////////////////
+
+// It takes two or more than two params.
+// The first is the array.
+// The second is the first dimension expression
+// So on so forth.
+
+TreeNode* ASTBuilder::BuildArrayElement() {
+  if (mTrace)
+    std::cout << "In BuildArrayElement" << std::endl;
+
+  MASSERT(mParams.size() >= 2);
+
+  Param p_array = mParams[0];
+  MASSERT(p_array.mIsTreeNode);
+  TreeNode *array = p_array.mData.mTreeNode;
+  MASSERT(array->IsIdentifier() ||
+          array->IsArrayElement() ||
+          array->IsField() ||
+          array->IsUserType() ||
+          array->IsBinOperator() ||
+          array->IsCall() ||
+          (array->IsLiteral() && ((LiteralNode*)array)->IsThis()) ||
+          array->IsTupleType() ||
+          array->IsStruct() ||
+          array->IsNew() ||
+          array->IsTypeOf() ||
+          array->IsCast() ||
+          array->IsPrimType());
+
+  ArrayElementNode *array_element = NULL;
+  if (array->IsIdentifier() ||
+      array->IsField() ||
+      array->IsUserType() ||
+      array->IsBinOperator() ||
+      array->IsCall() ||
+      array->IsTupleType() ||
+      (array->IsLiteral() && ((LiteralNode*)array)->IsThis()) ||
+      array->IsStruct() ||
+      array->IsNew() ||
+      array->IsTypeOf() ||
+      array->IsCast() ||
+      array->IsPrimType()) {
+    array_element = (ArrayElementNode*)gTreePool.NewTreeNode(sizeof(ArrayElementNode));
+    new (array_element) ArrayElementNode();
+    array_element->SetArray(array);
   } else {
-    MASSERT(node_b->IsIdentifier());
-    field = (FieldNode*)mTreePool->NewTreeNode(sizeof(FieldNode));
-    new (field) FieldNode();
-    field->SetUpper(node_a);
-    field->SetField((IdentifierNode*)node_b);
-    field->Init();
+    array_element = (ArrayElementNode*)array;
   }
 
-  mLastTreeNode = field;
+  unsigned num = mParams.size() - 1;
+  for (unsigned i = 0; i < num; i++) {
+    Param p_index = mParams[i+1];
+    MASSERT(p_index.mIsTreeNode);
+    TreeNode *index = p_index.mData.mTreeNode;
+    array_element->AddExpr(index);
+  }
+
+  mLastTreeNode = array_element;
   return mLastTreeNode;
 }
 
-// BuildVariableList takes two parameters, var 1 and var 2
-TreeNode* ASTBuilder::BuildVarList() {
+// It takes only one parameter, the literals.
+TreeNode* ASTBuilder::BuildArrayLiteral() {
   if (mTrace)
-    std::cout << "In build Variable List" << std::endl;
+    std::cout << "In BuildArrayLiteral" << std::endl;
 
-  MASSERT(mParams.size() == 2 && "BuildVarList has NO 2 params?");
-  Param p_var_a = mParams[0];
-  Param p_var_b = mParams[1];
+  MASSERT(mParams.size() == 1);
 
-  // Both variable should have been created as tree node.
-  if (!p_var_a.mIsTreeNode || !p_var_b.mIsTreeNode) {
-    MERROR("The var in BuildVarList is not a treenode");
+  // The parameter could be empty, meaning the literal is like: [].
+  // But it still is a array literal, and we create one for it with 0 expressions.
+  ArrayLiteralNode *array_literal = (ArrayLiteralNode*)gTreePool.NewTreeNode(sizeof(ArrayLiteralNode));
+  new (array_literal) ArrayLiteralNode();
+
+  Param p_literals = mParams[0];
+  if (!p_literals.mIsEmpty) {
+    MASSERT(p_literals.mIsTreeNode);
+    TreeNode *literals = p_literals.mData.mTreeNode;
+    MASSERT(literals->IsLiteral() ||
+            literals->IsIdentifier() ||
+            literals->IsNew() ||
+            literals->IsExprList() ||
+            literals->IsArrayLiteral() ||
+            literals->IsStructLiteral() ||
+            literals->IsFieldLiteral() ||
+            literals->IsCall() ||
+            literals->IsArrayElement() ||
+            literals->IsField() ||
+            literals->IsBinOperator() ||
+            literals->IsUnaOperator() ||
+            literals->IsTerOperator() ||
+            literals->IsRegExpr() ||
+            literals->IsFunction() ||
+            literals->IsTemplateLiteral() ||
+            literals->IsLambda());
+    if (literals->IsExprList()) {
+      ExprListNode *el = (ExprListNode*)literals;
+      for (unsigned i = 0; i < el->GetExprsNum(); i++) {
+        TreeNode *expr = el->GetExprAtIndex(i);
+        MASSERT(expr->IsLiteral() ||
+                expr->IsNew() ||
+                expr->IsArrayLiteral() ||
+                expr->IsFieldLiteral() ||
+                expr->IsStructLiteral() ||
+                expr->IsIdentifier() ||
+                expr->IsCall() ||
+                expr->IsArrayElement() ||
+                expr->IsField() ||
+                expr->IsBinOperator() ||
+                expr->IsUnaOperator() ||
+                expr->IsTerOperator() ||
+                expr->IsRegExpr() ||
+                expr->IsFunction() ||
+                expr->IsTemplateLiteral() ||
+                expr->IsLambda());
+        array_literal->AddLiteral(expr);
+      }
+    } else {
+      array_literal->AddLiteral(literals);
+    }
   }
 
-  TreeNode *node_a = p_var_a.mIsEmpty ? NULL : p_var_a.mData.mTreeNode;
-  TreeNode *node_b = p_var_b.mIsEmpty ? NULL : p_var_b.mData.mTreeNode;
-
+  mLastTreeNode = array_literal;
+  return mLastTreeNode;
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+//                         BindingElement and BindingPattern
+//////////////////////////////////////////////////////////////////////////////////
+
+// It could take:
+// 1) Two arguments, 'variable' name and 'element' to bind
+// 2) one argument,  the 'element'
+TreeNode* ASTBuilder::BuildBindingElement() {
+  if (mTrace)
+    std::cout << "In BuildBindingElement" << std::endl;
+
+  BindingElementNode *be_node = NULL;
+
+  if (mParams.size() == 2) {
+    Param p_variable = mParams[0];
+    MASSERT(p_variable.mIsTreeNode);
+    TreeNode *variable = p_variable.mData.mTreeNode;
+
+    Param p_element = mParams[1];
+    MASSERT(p_element.mIsTreeNode);
+    TreeNode *element = p_element.mData.mTreeNode;
+
+    // There are a few cases.
+    // 1. If element is an existing binding element, we just add the 'variable'.
+    // 2. If element is a binding pattern, we need create new binding element.
+    // 3. If element is anything else, we need create new binding element.
+    if (element->IsBindingElement()) {
+      be_node = (BindingElementNode*)element;
+      be_node->SetVariable(variable);
+    } else {
+      be_node = (BindingElementNode*)gTreePool.NewTreeNode(sizeof(BindingElementNode));
+      new (be_node) BindingElementNode();
+      be_node->SetVariable(variable);
+      be_node->SetElement(element);
+    }
+  } else if (mParams.size() == 1) {
+    Param p_element = mParams[0];
+    MASSERT(p_element.mIsTreeNode);
+    TreeNode *element = p_element.mData.mTreeNode;
+
+    be_node = (BindingElementNode*)gTreePool.NewTreeNode(sizeof(BindingElementNode));
+    new (be_node) BindingElementNode();
+    be_node->SetElement(element);
+  } else {
+    MASSERT(0 && "unsupported number of arguments in BuildBindingElemnt.");
+  }
+
+  mLastTreeNode = be_node;
+  return mLastTreeNode;
+}
+
+// It could take:
+// 1) zero arguments. it is an empty binding pattern.
+// 2) one argument, the 'element' or passnode containing list of elements.
+TreeNode* ASTBuilder::BuildBindingPattern() {
+  if (mTrace)
+    std::cout << "In BuildBindingPattern" << std::endl;
+
+  BindingPatternNode *bp = NULL;
+
+  if (mParams.size() == 1) {
+    Param p_element = mParams[0];
+    MASSERT(p_element.mIsTreeNode);
+    TreeNode *element = p_element.mData.mTreeNode;
+
+    bp = (BindingPatternNode*)gTreePool.NewTreeNode(sizeof(BindingPatternNode));
+    new (bp) BindingPatternNode();
+    bp->AddElement(element);
+  } else if (mParams.size() == 0) {
+    // an empty binding pattern
+    bp = (BindingPatternNode*)gTreePool.NewTreeNode(sizeof(BindingPatternNode));
+    new (bp) BindingPatternNode();
+  } else {
+    MASSERT(0 && "unsupported number of arguments in BuildBindingElemnt.");
+  }
+
+  mLastTreeNode = bp;
+  return mLastTreeNode;
+}
+
+TreeNode* ASTBuilder::SetArrayBinding() {
+  MASSERT(mLastTreeNode->IsBindingPattern());
+  BindingPatternNode *b = (BindingPatternNode*)mLastTreeNode;
+  b->SetProp(BPP_ArrayBinding);
+  return mLastTreeNode;
+}
+
+TreeNode* ASTBuilder::SetObjectBinding() {
+  MASSERT(mLastTreeNode->IsBindingPattern());
+  BindingPatternNode *b = (BindingPatternNode*)mLastTreeNode;
+  b->SetProp(BPP_ObjectBinding);
+  return mLastTreeNode;
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+//                         StructNode, StructLiteralNode, FieldLiteralNode
+//////////////////////////////////////////////////////////////////////////////////
+
+// It takes two parameters: name of key, the data type.
+TreeNode* ASTBuilder::BuildNumIndexSig() {
+  if (mTrace)
+    std::cout << "In BuildNumIndexSig" << std::endl;
+
+  Param p_key = mParams[0];
+  MASSERT(p_key.mIsTreeNode);
+  TreeNode *key = p_key.mData.mTreeNode;
+
+  Param p_data = mParams[1];
+  MASSERT(p_data.mIsTreeNode);
+  TreeNode *data = p_data.mData.mTreeNode;
+
+  NumIndexSigNode *sig = (NumIndexSigNode*)gTreePool.NewTreeNode(sizeof(NumIndexSigNode));
+  new (sig) NumIndexSigNode();
+  sig->SetKey(key);
+  sig->SetDataType(data);
+
+  mLastTreeNode = sig;
+  return mLastTreeNode;
+}
+
+// It takes two parameters: name of key, the data type.
+TreeNode* ASTBuilder::BuildStrIndexSig() {
+  if (mTrace)
+    std::cout << "In BuildStrIndexSig" << std::endl;
+
+  Param p_key = mParams[0];
+  MASSERT(p_key.mIsTreeNode);
+  TreeNode *key = p_key.mData.mTreeNode;
+
+  Param p_data = mParams[1];
+  MASSERT(p_data.mIsTreeNode);
+  TreeNode *data = p_data.mData.mTreeNode;
+
+  StrIndexSigNode *sig = (StrIndexSigNode*)gTreePool.NewTreeNode(sizeof(StrIndexSigNode));
+  new (sig) StrIndexSigNode();
+  sig->SetKey(key);
+  sig->SetDataType(data);
+
+  mLastTreeNode = sig;
+  return mLastTreeNode;
+}
+
+// It takes only one parameter: name.
+// Or it take no param, meaning the name is empty.
+TreeNode* ASTBuilder::BuildStruct() {
+  if (mTrace)
+    std::cout << "In BuildStruct" << std::endl;
+
+  TreeNode *name = NULL;
+
+  if (mParams.size() == 1) {
+    Param p_name = mParams[0];
+    MASSERT(p_name.mIsTreeNode);
+    name = p_name.mData.mTreeNode;
+    MASSERT(name->IsIdentifier());
+  }
+
+  StructNode *struct_node = (StructNode*)gTreePool.NewTreeNode(sizeof(StructNode));
+  new (struct_node) StructNode((IdentifierNode*)name);
+
+  mLastTreeNode = struct_node;
+  return mLastTreeNode;
+}
+
+// It take no param.
+TreeNode* ASTBuilder::BuildTupleType() {
+  if (mTrace)
+    std::cout << "In BuildTupleType" << std::endl;
+
+  TupleTypeNode *tuple_type = (TupleTypeNode*)gTreePool.NewTreeNode(sizeof(TupleTypeNode));
+  new (tuple_type) TupleTypeNode();
+
+  mLastTreeNode = tuple_type;
+  return mLastTreeNode;
+}
+
+// It takes only one parameter: Field.
+TreeNode* ASTBuilder::AddStructField() {
+  if (mTrace)
+    std::cout << "In AddStructField" << std::endl;
+  Param p_field = mParams[0];
+  if (!p_field.mIsEmpty) {
+    MASSERT(p_field.mIsTreeNode);
+    TreeNode *field = p_field.mData.mTreeNode;
+
+    if (mLastTreeNode->IsStruct()) {
+      StructNode *struct_node = (StructNode*)mLastTreeNode;
+      struct_node->AddChild(field);
+    } else if (mLastTreeNode->IsTupleType()) {
+      TupleTypeNode *tt = (TupleTypeNode*)mLastTreeNode;
+      tt->AddChild(field);
+    } else {
+      MERROR("Unsupported in AddStructField()");
+    }
+  }
+  return mLastTreeNode;
+}
+
+TreeNode* ASTBuilder::SetTSInterface() {
+  MASSERT(mLastTreeNode->IsStruct());
+  StructNode *s = (StructNode*)mLastTreeNode;
+  s->SetProp(SProp_TSInterface);
+  return mLastTreeNode;
+}
+
+TreeNode* ASTBuilder::SetTSEnum() {
+  MASSERT(mLastTreeNode->IsStruct());
+  StructNode *s = (StructNode*)mLastTreeNode;
+  s->SetProp(SProp_TSEnum);
+  return mLastTreeNode;
+}
+
+// Build FieldLiteral
+// It takes two param, field name and field value (a literal).
+TreeNode* ASTBuilder::BuildFieldLiteral() {
+  if (mTrace)
+    std::cout << "In BuildFieldLiteral" << std::endl;
+
+  TreeNode *field = NULL;
+  Param p_field = mParams[0];
+  if (p_field.mIsTreeNode) {
+    field = p_field.mData.mTreeNode;
+  } else {
+    field = BuildIdentifier(p_field.mData.mToken);
+  }
+
+  Param p_value = mParams[1];
+  MASSERT(p_value.mIsTreeNode);
+  TreeNode *value = p_value.mData.mTreeNode;
+
+  FieldLiteralNode *field_literal = (FieldLiteralNode*)gTreePool.NewTreeNode(sizeof(FieldLiteralNode));
+  new (field_literal) FieldLiteralNode();
+  field_literal->SetFieldName(field);
+  field_literal->SetLiteral(value);
+
+  mLastTreeNode = field_literal;
+  return mLastTreeNode;
+}
+
+// 1) It takes no param. We create an empty struct litreal.
+// 2) It takes one param. The param could a FieldLiteralNode or
+//    a PassNode containing multiple FieldLiteralNode.
+//
+// The param could also be a GetAccessor/SetAccessor in Javascript,
+// which is a function node. We take the name of function as field name,
+// the FunctionNode as the value.
+TreeNode* ASTBuilder::BuildStructLiteral() {
+  if (mTrace)
+    std::cout << "In BuildStructLiteral" << std::endl;
+
+  TreeNode *literal = NULL;
+
+  if (mParams.size() == 1) {
+    Param p_literal = mParams[0];
+    MASSERT(p_literal.mIsTreeNode);
+    literal = p_literal.mData.mTreeNode;
+  }
+
+  StructLiteralNode *struct_literal = (StructLiteralNode*)gTreePool.NewTreeNode(sizeof(StructLiteralNode));
+  new (struct_literal) StructLiteralNode();
+
+  if (literal)
+    struct_literal->AddField(literal);
+
+  mLastTreeNode = struct_literal;
+  return mLastTreeNode;
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////
+
+// BuildField takes two parameters,
+// 1) upper enclosing node, could be another field.
+// 2) name of this field.
+TreeNode* ASTBuilder::BuildField() {
+  if (mTrace)
+    std::cout << "In BuildField" << std::endl;
+
+  MASSERT(mParams.size() == 2 && "BuildField has NO 2 params?");
+  Param p_var_a = mParams[0];
+  Param p_var_b = mParams[1];
+
+  // Both variable should have been created as tree node.
+  MASSERT(p_var_a.mIsTreeNode);
+
+  // The second param should be an IdentifierNode
+  TreeNode *node_a = p_var_a.mIsEmpty ? NULL : p_var_a.mData.mTreeNode;
+  TreeNode *node_b = NULL;
+  if (!p_var_b.mIsEmpty) {
+    if (p_var_b.mIsTreeNode) {
+      node_b = p_var_b.mData.mTreeNode;
+      if (!node_b->IsIdentifier() && !node_b->IsComputedName()) {
+        TreeNode *id = BuildIdentifier(node_b);
+        if (id)
+          node_b = id;
+      }
+    } else {
+      node_b = BuildIdentifier(p_var_b.mData.mToken);
+    }
+  }
+
+  FieldNode *field = NULL;
+
+  if (node_b->IsPass()) {
+    TreeNode *upper = node_a;
+    PassNode *pass = (PassNode*)node_b;
+    for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
+      TreeNode *child = pass->GetChild(i);
+      MASSERT(child->IsIdentifier());
+
+      field = (FieldNode*)gTreePool.NewTreeNode(sizeof(FieldNode));
+      new (field) FieldNode();
+      field->SetUpper(upper);
+      field->SetField((IdentifierNode*)child);
+
+      upper = field;
+    }
+  } else {
+    MASSERT(node_b->IsIdentifier() ||
+            node_b->IsCall() ||
+            node_b->IsUserType());
+    field = (FieldNode*)gTreePool.NewTreeNode(sizeof(FieldNode));
+    new (field) FieldNode();
+    field->SetUpper(node_a);
+    field->SetField(node_b);
+  }
+
+  mLastTreeNode = field;
+  return mLastTreeNode;
+}
+
+// BuildVariableList takes two parameters, var 1 and var 2
+TreeNode* ASTBuilder::BuildVarList() {
+  if (mTrace)
+    std::cout << "In build Variable List" << std::endl;
+
+  MASSERT(mParams.size() == 2 && "BuildVarList has NO 2 params?");
+  Param p_var_a = mParams[0];
+  Param p_var_b = mParams[1];
+
+  // Both variable should have been created as tree node.
+  if (!p_var_a.mIsTreeNode || !p_var_b.mIsTreeNode) {
+    MERROR("The var in BuildVarList is not a treenode");
+  }
+
+  TreeNode *node_a = p_var_a.mIsEmpty ? NULL : p_var_a.mData.mTreeNode;
+  TreeNode *node_b = p_var_b.mIsEmpty ? NULL : p_var_b.mData.mTreeNode;
+
   // There are a few different scenarios.
   // (1) node_a is a VarListNode, and we dont care about node_b
   // (2) node_a is an IdentifierNode, node_b is a VarListNode
@@ -851,7 +2232,7 @@ TreeNode* ASTBuilder::BuildVarList() {
     node_ret->Merge(node_a);
   } else {
     // both nodes are not VarListNode
-    node_ret = (VarListNode*)mTreePool->NewTreeNode(sizeof(VarListNode));
+    node_ret = (VarListNode*)gTreePool.NewTreeNode(sizeof(VarListNode));
     new (node_ret) VarListNode();
     if (node_a)
       node_ret->Merge(node_a);
@@ -866,37 +2247,110 @@ TreeNode* ASTBuilder::BuildVarList() {
 }
 
 // Attach the modifier(s) to mLastTreeNode.
+// It takes:
+//   1. One argument, which is the solo modifier.
+//   2. Two arguments, which happens mostly in Typescript, like
+//        + readonly
+//        - readonly
+//        + ?
+//        - ?
 TreeNode* ASTBuilder::AddModifier() {
   if (mTrace)
     std::cout << "In AddModifier" << std::endl;
 
-  Param p_mod = mParams[0];
-  if (p_mod.mIsEmpty) {
-    if (mTrace)
-      std::cout << " do nothing." << std::endl;
-    return mLastTreeNode;
-  }
+  if (mParams.size() == 1) {
+    Param p_mod = mParams[0];
+    if (p_mod.mIsEmpty) {
+      if (mTrace)
+        std::cout << " do nothing." << std::endl;
+      return mLastTreeNode;
+    }
 
-  if (!p_mod.mIsTreeNode)
-    MERROR("The modifier is not a treenode");
-  TreeNode *mod= p_mod.mData.mTreeNode;
+    TreeNode *mod = NULL;
+    if (!p_mod.mIsTreeNode) {
+      Token *token = p_mod.mData.mToken;
+      if (token->IsSeparator() && token->GetSepId()==SEP_Pound) {
+        // This is a '#' in front of class member in Javascript.
+        // This is a 'private' modifier.
+        AttrNode *an = gAttrPool.GetAttrNode(ATTR_private);
+        MASSERT(an);
+        mod = an;
+      } else {
+        MERROR("The modifier is not a treenode");
+      }
+    } else {
+      mod= p_mod.mData.mTreeNode;
+    }
 
-  if (mod->IsPass()) {
-    PassNode *pass = (PassNode*)mod;
-    for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
-      TreeNode *child = pass->GetChild(i);
-      if (child->IsAnnotation()) {
-        AnnotationNode *a = (AnnotationNode*)child;
-        mLastTreeNode->AddAnnotation(a);
+    if (mod->IsPass()) {
+      PassNode *pass = (PassNode*)mod;
+      for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
+        TreeNode *child = pass->GetChild(i);
+        if (child->IsAnnotation()) {
+          AnnotationNode *a = (AnnotationNode*)child;
+          mLastTreeNode->AddAnnotation(a);
+        } else {
+          add_attribute_to(mLastTreeNode, child);
+        }
+      }
+    } else if (mod->IsAnnotation()) {
+      AnnotationNode *a = (AnnotationNode*)mod;
+      mLastTreeNode->AddAnnotation(a);
+    } else {
+      add_attribute_to(mLastTreeNode, mod);
+    }
+  } else if (mParams.size() == 2) {
+    // the two modifiers are in fixed order, with +/- at first
+    // readonly/? the second.
+    bool add = false;   // add opr if true, rem if false
+    bool readonly = false;
+    bool optional = false;
+    Param p_opr = mParams[0];
+    if (p_opr.mIsEmpty) {
+      add = true;
+    } else {
+      MASSERT(!p_opr.mIsTreeNode);
+      Token *token= p_opr.mData.mToken;
+      if (token->GetOprId() == OPR_Add)
+        add = true;
+      else if (token->GetOprId() == OPR_Sub)
+        add = false;
+      else
+        MERROR("unsupported opr id.");
+    }
+
+    Param p_prop = mParams[1];
+    if (!p_prop.mIsEmpty) {
+      if (!p_prop.mIsTreeNode) {
+        Token *token= p_prop.mData.mToken;
+        MASSERT(token->IsSeparator() && (token->GetSepId() == SEP_Select));
+        optional = true;
+      } else {
+        TreeNode *tree = p_prop.mData.mTreeNode;
+        MASSERT(tree->IsAttr());
+        AttrNode *attr = (AttrNode*)tree;
+        MASSERT(attr->GetId() == ATTR_readonly);
+        readonly = true;
+      }
+
+      MASSERT(mLastTreeNode->IsComputedName());
+      ComputedNameNode *cnn = (ComputedNameNode*)mLastTreeNode;
+      if (add) {
+        if (readonly)
+          cnn->SetProp((unsigned)CNP_Add_ReadOnly);
+        else if (optional)
+          cnn->SetProp((unsigned)CNP_Add_Optional);
+        else
+          MERROR("unsupported property.");
       } else {
-        add_attribute_to(mLastTreeNode, child);
+        if (readonly)
+          cnn->SetProp((unsigned)CNP_Rem_ReadOnly);
+        else if (optional)
+          cnn->SetProp((unsigned)CNP_Rem_Optional);
+        else
+          MERROR("unsupported property.");
       }
     }
-  } else if (mod->IsAnnotation()) {
-    AnnotationNode *a = (AnnotationNode*)mod;
-    mLastTreeNode->AddAnnotation(a);
-  } else {
-    add_attribute_to(mLastTreeNode, mod);
   }
 
   return mLastTreeNode;
@@ -943,55 +2397,151 @@ TreeNode* ASTBuilder::AddModifierTo() {
   return tree;
 }
 
-TreeNode* ASTBuilder::AddInitTo() {
+// It takes one argument, the init.
+// Apply init to mLastTreeNode
+TreeNode* ASTBuilder::AddInit() {
   if (mTrace)
-    std::cout << "In AddInitTo" << std::endl;
-  Param p_decl = mParams[0];
-  Param p_init;
+    std::cout << "In AddInit" << std::endl;
 
-  // If there is no init value, return NULL.
-  if (mParams.size() == 1)
-    return NULL;
+  MASSERT(mParams.size() == 1);
 
-  p_init = mParams[1];
+  Param p_init = mParams[0];
   if (p_init.mIsEmpty)
     return NULL;
 
-  // Both variable should have been created as tree node.
-  if (!p_decl.mIsTreeNode || !p_init.mIsTreeNode)
-    MERROR("The decl or init is not a treenode in AddInitTo()");
+  if (!p_init.mIsTreeNode)
+    MERROR("The init is not a treenode in AddInit()");
 
-  TreeNode *node_decl = p_decl.mData.mTreeNode;
   TreeNode *node_init = p_init.mData.mTreeNode;
 
-  if (!node_decl->IsIdentifier())
-    MERROR("The target of AddInitTo should be an indentifier node. Not?");
+  if (mLastTreeNode->IsIdentifier()) {
+    IdentifierNode *in = (IdentifierNode*)mLastTreeNode;
+    in->SetInit(node_init);
+    return in;
+  } else if (mLastTreeNode->IsBindingPattern()) {
+    BindingPatternNode *in = (BindingPatternNode*)mLastTreeNode;
+    in->SetInit(node_init);
+    return in;
+  } else if (mLastTreeNode->IsTypeParameter()) {
+    TypeParameterNode *in = (TypeParameterNode*)mLastTreeNode;
+    in->SetDefault(node_init);
+    return in;
+  } else {
+    MERROR("The target of AddInit is unsupported.");
+  }
+}
+
+// It takes (1) two arguments or (2) one argument
+TreeNode* ASTBuilder::AddInitTo() {
+  if (mTrace)
+    std::cout << "In AddInitTo" << std::endl;
+
+  TreeNode *node_decl = NULL;
+  TreeNode *node_init = NULL;
+
+  // If there is no init value, return NULL.
+  if (mParams.size() == 1) {
+    Param p_init = mParams[0];
+    if (p_init.mIsEmpty)
+      return NULL;
+    node_init = p_init.mData.mTreeNode;
+    node_decl = mLastTreeNode;
+  } else {
+    Param p_decl = mParams[0];
+    Param p_init;
+    p_init = mParams[1];
+    if (p_init.mIsEmpty)
+      return NULL;
+
+    // Both variable should have been created as tree node.
+    if (!p_decl.mIsTreeNode || !p_init.mIsTreeNode)
+      MERROR("The decl or init is not a treenode in AddInitTo()");
+
+    node_decl = p_decl.mData.mTreeNode;
+    node_init = p_init.mData.mTreeNode;
+  }
+
+  if (node_decl->IsIdentifier()) {
+    IdentifierNode *in = (IdentifierNode*)node_decl;
+    in->SetInit(node_init);
+    return in;
+  } else if (node_decl->IsBindingPattern()) {
+    BindingPatternNode *in = (BindingPatternNode*)node_decl;
+    in->SetInit(node_init);
+    return in;
+  } else if (node_decl->IsComputedName()) {
+    ComputedNameNode *in = (ComputedNameNode*)node_decl;
+    in->SetInit(node_init);
+    return in;
+  } else if (node_decl->IsLiteral()) {
+    LiteralNode *in = (LiteralNode*)node_decl;
+    in->SetInit(node_init);
+    return in;
+  } else {
+    MERROR("The target of AddInitTo is unsupported.");
+  }
+}
+
+// This takes just one argument which is the namespace name.
+TreeNode* ASTBuilder::BuildNamespace() {
+  if (mTrace)
+    std::cout << "In BuildNamespace" << std::endl;
+
+  Param p_name = mParams[0];
+  MASSERT(p_name.mIsTreeNode);
+  TreeNode *node_name = p_name.mData.mTreeNode;
+
+  MASSERT(node_name->IsIdentifier() || node_name->IsField());
 
-  IdentifierNode *in = (IdentifierNode*)node_decl;
-  in->SetInit(node_init);
+  NamespaceNode *ns = (NamespaceNode*)gTreePool.NewTreeNode(sizeof(NamespaceNode));
+  new (ns) NamespaceNode();
+  ns->SetId(node_name);
 
-  return in;
+  mLastTreeNode = ns;
+  return mLastTreeNode;
 }
 
+// Takes one parameter which is the tree of namespace body.
+TreeNode* ASTBuilder::AddNamespaceBody() {
+  if (mTrace)
+    std::cout << "In AddNamespaceBody" << std::endl;
+
+  Param p_body = mParams[0];
+  if (!p_body.mIsEmpty) {
+    if(!p_body.mIsTreeNode)
+      MERROR("The namespace body is not a tree node.");
+    TreeNode *tree = p_body.mData.mTreeNode;
+
+    MASSERT(mLastTreeNode->IsNamespace());
+    NamespaceNode *ns = (NamespaceNode*)mLastTreeNode;
+    ns->AddBody(tree);
+  }
+
+  return mLastTreeNode;
+}
 
 // This takes just one argument which is the class name.
 TreeNode* ASTBuilder::BuildClass() {
   if (mTrace)
     std::cout << "In BuildClass" << std::endl;
 
-  Param p_name = mParams[0];
-
-  if (!p_name.mIsTreeNode)
-    MERROR("The class name is not a treenode in BuildClass()");
-  TreeNode *node_name = p_name.mData.mTreeNode;
+  IdentifierNode *in = NULL;
 
-  if (!node_name->IsIdentifier())
-    MERROR("The class name should be an indentifier node. Not?");
-  IdentifierNode *in = (IdentifierNode*)node_name;
+  Param p_name = mParams[0];
+  if (!p_name.mIsEmpty) {
+    if (!p_name.mIsTreeNode)
+      MERROR("The class name is not a treenode in BuildClass()");
+    TreeNode *node_name = p_name.mData.mTreeNode;
+
+    if (!node_name->IsIdentifier())
+      MERROR("The class name should be an identifier node. Not?");
+    in = (IdentifierNode*)node_name;
+  }
 
-  ClassNode *node_class = (ClassNode*)mTreePool->NewTreeNode(sizeof(ClassNode));
+  ClassNode *node_class = (ClassNode*)gTreePool.NewTreeNode(sizeof(ClassNode));
   new (node_class) ClassNode();
-  node_class->SetName(in->GetName());
+  if (in)
+    node_class->SetStrIdx(in->GetStrIdx());
 
   mLastTreeNode = node_class;
   return mLastTreeNode;
@@ -999,7 +2549,7 @@ TreeNode* ASTBuilder::BuildClass() {
 
 TreeNode* ASTBuilder::SetClassIsJavaEnum() {
   ClassNode *klass = (ClassNode*)mLastTreeNode;
-  klass->SetJavaEnum();
+  klass->SetIsJavaEnum();
   return mLastTreeNode;
 }
 
@@ -1008,7 +2558,7 @@ TreeNode* ASTBuilder::BuildBlock() {
   if (mTrace)
     std::cout << "In BuildBlock" << std::endl;
 
-  BlockNode *block = (BlockNode*)mTreePool->NewTreeNode(sizeof(BlockNode));
+  BlockNode *block = (BlockNode*)gTreePool.NewTreeNode(sizeof(BlockNode));
   new (block) BlockNode();
 
   Param p_subtree = mParams[0];
@@ -1062,19 +2612,27 @@ TreeNode* ASTBuilder::AddToBlock() {
   return mLastTreeNode;
 }
 
-// if tnode is not a BlockNode, wrap it into a BlockNode
-TreeNode* ASTBuilder::CvtToBlock(TreeNode *tnode) {
+// This takes just two arguments. First is the sync object, second the block
+// It returns the block with sync added.
+TreeNode* ASTBuilder::AddSyncToBlock() {
   if (mTrace)
-    std::cout << "In CvtToBlock" << std::endl;
+    std::cout << "In AddSyncToBlock" << std::endl;
 
-  if (tnode->IsBlock()) {
-    return tnode;
-  }
+  Param p_sync = mParams[0];
+  MASSERT(!p_sync.mIsEmpty && p_sync.mIsTreeNode);
+  TreeNode *sync_tree = p_sync.mData.mTreeNode;
 
-  BlockNode *block = (BlockNode*)mTreePool->NewTreeNode(sizeof(BlockNode));
-  new (block) BlockNode();
-  block->AddChild(tnode);
-  return block;
+  Param p_block = mParams[1];
+  MASSERT(!p_block.mIsEmpty && p_block.mIsTreeNode);
+  TreeNode *b = p_block.mData.mTreeNode;
+  MASSERT(b->IsBlock());
+  BlockNode *block = (BlockNode*)b;
+
+  block->SetSync(sync_tree);
+
+  // set last tree node
+  mLastTreeNode = block;
+  return mLastTreeNode;
 }
 
 // This takes just one argument which either a block node, or the root of sub tree
@@ -1109,14 +2667,41 @@ TreeNode* ASTBuilder::BuildInstInit() {
 TreeNode* ASTBuilder::AddSuperClass() {
   if (mTrace)
     std::cout << "In AddSuperClass" << std::endl;
-  Param p_attr = mParams[0];
+  Param p_super = mParams[0];
+  if (p_super.mIsEmpty)
+    return mLastTreeNode;
+
+  MASSERT(p_super.mIsTreeNode);
+  TreeNode *t_super = p_super.mData.mTreeNode;
+
+  if (mLastTreeNode->IsClass()) {
+    ClassNode *sn = (ClassNode*)mLastTreeNode;
+    sn->AddSuperClass(t_super);
+  }
+
   return mLastTreeNode;
 }
 
+// It takes one argument, the super interface.
+// Add it to the mLastTreeNode.
 TreeNode* ASTBuilder::AddSuperInterface() {
   if (mTrace)
     std::cout << "In AddSuperInterface" << std::endl;
-  Param p_attr = mParams[0];
+  Param p_super = mParams[0];
+  if (p_super.mIsEmpty)
+    return mLastTreeNode;
+
+  MASSERT(p_super.mIsTreeNode);
+  TreeNode *t_super = p_super.mData.mTreeNode;
+
+  if (mLastTreeNode->IsStruct()) {
+    StructNode *sn = (StructNode*)mLastTreeNode;
+    sn->AddSuper(t_super);
+  } else if (mLastTreeNode->IsClass()) {
+    ClassNode *sn = (ClassNode*)mLastTreeNode;
+    sn->AddSuperInterface(t_super);
+  }
+
   return mLastTreeNode;
 }
 
@@ -1126,16 +2711,24 @@ TreeNode* ASTBuilder::AddClassBody() {
     std::cout << "In AddClassBody" << std::endl;
 
   Param p_body = mParams[0];
-  if (!p_body.mIsTreeNode)
+  if (p_body.mIsEmpty)
+    return mLastTreeNode;
+
+  if (!p_body.mIsTreeNode)
     MERROR("The class body is not a tree node.");
-  TreeNode *tree_node = p_body.mData.mTreeNode;
-  MASSERT(tree_node->IsBlock() && "Class body is not a BlockNode?");
-  BlockNode *block = (BlockNode*)tree_node;
+
+  TreeNode *tn = p_body.mData.mTreeNode;
+  if (!tn->IsBlock()) {
+    BlockNode *block = (BlockNode*)gTreePool.NewTreeNode(sizeof(BlockNode));
+    new (block) BlockNode();
+    block->AddChild(tn);
+    tn = block;
+  }
+  BlockNode *block = (BlockNode*)(tn);
 
   MASSERT(mLastTreeNode->IsClass() && "Class is not a ClassNode?");
   ClassNode *klass = (ClassNode*)mLastTreeNode;
-  klass->AddBody(block);
-  klass->Construct();
+  klass->Construct(block);
 
   return mLastTreeNode;
 }
@@ -1152,10 +2745,10 @@ TreeNode* ASTBuilder::BuildAnnotationType() {
   TreeNode *node_name = p_name.mData.mTreeNode;
 
   if (!node_name->IsIdentifier())
-    MERROR("The annotation type name should be an indentifier node. Not?");
+    MERROR("The annotation type name should be an identifier node. Not?");
   IdentifierNode *in = (IdentifierNode*)node_name;
 
-  AnnotationTypeNode *annon_type = (AnnotationTypeNode*)mTreePool->NewTreeNode(sizeof(AnnotationTypeNode));
+  AnnotationTypeNode *annon_type = (AnnotationTypeNode*)gTreePool.NewTreeNode(sizeof(AnnotationTypeNode));
   new (annon_type) AnnotationTypeNode();
   annon_type->SetId(in);
 
@@ -1180,12 +2773,9 @@ TreeNode* ASTBuilder::BuildAnnotation() {
     MERROR("The annotationtype name is not a treenode in BuildAnnotation()");
   TreeNode *iden = p_name.mData.mTreeNode;
 
-  if (!iden->IsIdentifier())
-    MERROR("The annotation name is NOT an indentifier node.");
-
-  AnnotationNode *annot = (AnnotationNode*)mTreePool->NewTreeNode(sizeof(AnnotationNode));
+  AnnotationNode *annot = (AnnotationNode*)gTreePool.NewTreeNode(sizeof(AnnotationNode));
   new (annot) AnnotationNode();
-  annot->SetId((IdentifierNode*)iden);
+  annot->SetId(iden);
 
   // set last tree node and return it.
   mLastTreeNode = annot;
@@ -1202,12 +2792,12 @@ TreeNode* ASTBuilder::BuildInterface() {
   TreeNode *node_name = p_name.mData.mTreeNode;
 
   if (!node_name->IsIdentifier())
-    MERROR("The name is NOT an indentifier node.");
+    MERROR("The name is NOT an identifier node.");
   IdentifierNode *in = (IdentifierNode*)node_name;
 
-  InterfaceNode *interf = (InterfaceNode*)mTreePool->NewTreeNode(sizeof(InterfaceNode));
+  InterfaceNode *interf = (InterfaceNode*)gTreePool.NewTreeNode(sizeof(InterfaceNode));
   new (interf) InterfaceNode();
-  interf->SetName(in->GetName());
+  interf->SetStrIdx(in->GetStrIdx());
 
   // set last tree node and return it.
   mLastTreeNode = interf;
@@ -1238,9 +2828,9 @@ TreeNode* ASTBuilder::BuildDim() {
   if (mTrace)
     std::cout << "In BuildDim" << std::endl;
 
-  DimensionNode *dim = (DimensionNode*)mTreePool->NewTreeNode(sizeof(DimensionNode));
+  DimensionNode *dim = (DimensionNode*)gTreePool.NewTreeNode(sizeof(DimensionNode));
   new (dim) DimensionNode();
-  dim->AddDim();
+  dim->AddDimension();
 
   // set last tree node and return it.
   mLastTreeNode = dim;
@@ -1309,7 +2899,7 @@ TreeNode* ASTBuilder::AddDimsTo() {
       mLastTreeNode = node_a;
     } else if (node_a->IsPrimType()) {
       PrimTypeNode *pt = (PrimTypeNode*)node_a;
-      PrimArrayTypeNode *pat = (PrimArrayTypeNode*)mTreePool->NewTreeNode(sizeof(PrimArrayTypeNode));
+      PrimArrayTypeNode *pat = (PrimArrayTypeNode*)gTreePool.NewTreeNode(sizeof(PrimArrayTypeNode));
       new (pat) PrimArrayTypeNode();
       pat->SetPrim(pt);
       pat->SetDims(dim);
@@ -1349,77 +2939,121 @@ TreeNode* ASTBuilder::AddDims() {
   return mLastTreeNode;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-//                    New & Delete operation related
-////////////////////////////////////////////////////////////////////////////////
-
 // This is a help function which adds parameters to a function decl.
 // It's the caller's duty to assure 'func' and 'params' are non null.
-void ASTBuilder::AddParams(TreeNode *func, TreeNode *params) {
-  if (params->IsIdentifier()) {
-    // one single parameter at call site
-    IdentifierNode *inode = (IdentifierNode*)params;
-    if (func->IsFunction())
-      ((FunctionNode*)func)->AddParam(inode);
-    else if (func->IsNew())
-      ((NewNode*)func)->AddParam(inode);
-    else
-      MERROR("Unsupported yet.");
-  } else if (params->IsVarList()) {
-    // a list of decls at function declaration
-    VarListNode *vl = (VarListNode*)params;
-    for (unsigned i = 0; i < vl->GetNum(); i++) {
-      IdentifierNode *inode = vl->VarAtIndex(i);
+void ASTBuilder::AddParams(TreeNode *func, TreeNode *decl_params) {
+  if (decl_params->IsDecl()) {
+    DeclNode *decl = (DeclNode*)decl_params;
+    TreeNode *params = decl->GetVar();
+    // a param could be a 'this' literal, binding pattern, etc
+    if (params->IsIdentifier() || params->IsLiteral() || params->IsBindingPattern()) {
+      // one single parameter at call site
       if (func->IsFunction())
-        ((FunctionNode*)func)->AddParam(inode);
-      else if (func->IsNew())
-        ((NewNode*)func)->AddParam(inode);
+        ((FunctionNode*)func)->AddParam(params);
+      else if (func->IsLambda())
+        ((LambdaNode*)func)->AddParam(params);
       else
         MERROR("Unsupported yet.");
+    } else if (params->IsVarList()) {
+      // a list of decls at function declaration
+      VarListNode *vl = (VarListNode*)params;
+      for (unsigned i = 0; i < vl->GetVarsNum(); i++) {
+        IdentifierNode *inode = vl->GetVarAtIndex(i);
+        if (func->IsFunction())
+          ((FunctionNode*)func)->AddParam(inode);
+        else if (func->IsLambda())
+          ((LambdaNode*)func)->AddParam(inode);
+        else
+          MERROR("Unsupported yet.");
+      }
+    } else {
+      MERROR("Unsupported yet.");
     }
-  } else if (params->IsPass()) {
-    // a list of identifiers at call site.
-    PassNode *pass = (PassNode*)params;
+  } else if (decl_params->IsPass()) {
+    PassNode *pass = (PassNode*)decl_params;
     for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
       TreeNode *child = pass->GetChild(i);
-      if (func->IsFunction())
-        ((FunctionNode*)func)->AddParam(child);
-      else if (func->IsNew())
-        ((NewNode*)func)->AddParam(child);
-      else
-        MERROR("Unsupported yet.");
+      AddParams(func, child);
     }
+  } else if (decl_params->IsIdentifier()) {
+    // sometimes, the parameter is just an identifier in Javascript.
+    // Like the SetAccessor
+    if (func->IsFunction())
+      ((FunctionNode*)func)->AddParam(decl_params);
+    else if (func->IsLambda())
+      ((LambdaNode*)func)->AddParam(decl_params);
+    else
+      MERROR("Unsupported yet.");
+  } else if (decl_params->IsStruct()) {
+    if (func->IsFunction())
+      ((FunctionNode*)func)->AddParam(decl_params);
+    else if (func->IsLambda())
+      ((LambdaNode*)func)->AddParam(decl_params);
+    else
+      MERROR("Unsupported yet.");
+  } else {
+    MERROR("Unsupported yet.");
   }
 }
 
+// AddAssert takes one parameter, the asserts expression, and apply it to mLastTreeNode
+TreeNode* ASTBuilder::AddAssert() {
+  if (mTrace)
+    std::cout << "In AddAssert " << std::endl;
+
+  FunctionNode *f = NULL;
+  TreeNode *a = NULL;
+
+  Param p_type = mParams[0];
+  if(!p_type.mIsEmpty && p_type.mIsTreeNode) {
+    a = p_type.mData.mTreeNode;
+    MASSERT(mLastTreeNode->IsFunction());
+    f = (FunctionNode*)mLastTreeNode;
+  }
+
+  if (f && a)
+    f->SetAssert(a);
+
+  return mLastTreeNode;
+}
+////////////////////////////////////////////////////////////////////////////////
+//                    New & Delete operation related
+////////////////////////////////////////////////////////////////////////////////
+
+// This function takes one, two or three arguments.
+// 1. The id of the class/interface/function/..., or a lambda
+// 2. The arguments, could be empty
+// 3. In some cases there is a third argument, for function body.
 TreeNode* ASTBuilder::BuildNewOperation() {
   if (mTrace)
     std::cout << "In BuildNewOperation " << std::endl;
 
-  NewNode *new_node = (NewNode*)mTreePool->NewTreeNode(sizeof(NewNode));
+  NewNode *new_node = (NewNode*)gTreePool.NewTreeNode(sizeof(NewNode));
   new (new_node) NewNode();
 
-  MASSERT(mParams.size() == 3 && "BuildNewOperation has NO 3 params?");
-  Param p_a = mParams[0];
-  Param p_b = mParams[1];
-  Param p_c = mParams[2];
-
   // Name could not be empty
+  Param p_a = mParams[0];
   if (p_a.mIsEmpty)
     MERROR("The name in BuildNewOperation() is empty?");
   MASSERT(p_a.mIsTreeNode && "Name of new expression is not a tree?");
   TreeNode *name = p_a.mData.mTreeNode;
   new_node->SetId(name);
-  
-  TreeNode *node_b = p_b.mIsEmpty ? NULL : p_b.mData.mTreeNode;
-  if (node_b)
-    AddParams(new_node, node_b);
 
-  TreeNode *node_c = p_c.mIsEmpty ? NULL : p_c.mData.mTreeNode;
-  if (node_c) {
-    MASSERT(node_c->IsBlock() && "ClassBody is not a block?");
-    BlockNode *b = (BlockNode*)node_c;
-    new_node->SetBody(b);
+  if (mParams.size() > 1) {
+    Param p_b = mParams[1];
+    TreeNode *node_b = p_b.mIsEmpty ? NULL : p_b.mData.mTreeNode;
+    if (node_b)
+      AddArguments(new_node, node_b);
+  }
+
+  if (mParams.size() > 2) {
+    Param p_c = mParams[2];
+    TreeNode *node_c = p_c.mIsEmpty ? NULL : p_c.mData.mTreeNode;
+    if (node_c) {
+      MASSERT(node_c->IsBlock() && "ClassBody is not a block?");
+      BlockNode *b = (BlockNode*)node_c;
+      new_node->SetBody(b);
+    }
   }
 
   mLastTreeNode = new_node;
@@ -1427,6 +3061,20 @@ TreeNode* ASTBuilder::BuildNewOperation() {
 }
 
 TreeNode* ASTBuilder::BuildDeleteOperation() {
+  if (mTrace)
+    std::cout << "In BuildDelete" << std::endl;
+
+  Param l_param = mParams[0];
+  MASSERT(!l_param.mIsEmpty);
+  MASSERT(l_param.mIsTreeNode);
+  TreeNode *expr = l_param.mData.mTreeNode;
+
+  DeleteNode *d_node = (DeleteNode*)gTreePool.NewTreeNode(sizeof(DeleteNode));
+  new (d_node) DeleteNode();
+  d_node->SetExpr(expr);
+
+  mLastTreeNode = d_node;
+  return mLastTreeNode;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1439,7 +3087,7 @@ TreeNode* ASTBuilder::BuildAssert() {
   if (mTrace)
     std::cout << "In BuildAssert " << std::endl;
 
-  AssertNode *assert_node = (AssertNode*)mTreePool->NewTreeNode(sizeof(AssertNode));
+  AssertNode *assert_node = (AssertNode*)gTreePool.NewTreeNode(sizeof(AssertNode));
   new (assert_node) AssertNode();
 
   MASSERT(mParams.size() >= 1 && "BuildAssert has NO expression?");
@@ -1475,7 +3123,7 @@ TreeNode* ASTBuilder::BuildCall() {
   if (mTrace)
     std::cout << "In BuildCall" << std::endl;
 
-  CallNode *call = (CallNode*)mTreePool->NewTreeNode(sizeof(CallNode));
+  CallNode *call = (CallNode*)gTreePool.NewTreeNode(sizeof(CallNode));
   new (call) CallNode();
 
   // The default is having no param.
@@ -1484,12 +3132,16 @@ TreeNode* ASTBuilder::BuildCall() {
   if (!ParamsEmpty()) {
     Param p_method = mParams[0];
     if (!p_method.mIsTreeNode)
-      MERROR("The function name is not a treenode in BuildFunction()");
+      MERROR("The function name is not a treenode in BuildCall()");
     method = p_method.mData.mTreeNode;
   }
 
+  // In Typescript, get/set are keywords of attributes. But it also allowed to be
+  // function name. So we need transfer this AttrNode to IdentifierNode.
+  if (method && method->IsAttr())
+    method = BuildIdentifier(method);
+
   call->SetMethod(method);
-  call->Init();
 
   mLastTreeNode = call;
   return mLastTreeNode;
@@ -1499,43 +3151,67 @@ TreeNode* ASTBuilder::BuildCall() {
 // identifier, call, or any valid expression.
 //
 // This AddArguments can be used for CallNode, NewNode, etc.
-// Right now I just support CallNode. NewNode will be moved from AddParams()
-// to here.
 
 TreeNode* ASTBuilder::AddArguments() {
   if (mTrace)
     std::cout << "In AddArguments" << std::endl;
 
   Param p_params = mParams[0];
-  TreeNode *params = NULL;
+  TreeNode *args = NULL;
   if (!p_params.mIsEmpty) {
     if (!p_params.mIsTreeNode)
       MERROR("The parameters is not a treenode in AddArguments()");
-    params = p_params.mData.mTreeNode;
+    args = p_params.mData.mTreeNode;
   }
 
-  if (!params)
+  if (!args)
     return mLastTreeNode;
 
-  CallNode *call = (CallNode*)mLastTreeNode;
+  AddArguments(mLastTreeNode, args);
 
-  if (params->IsVarList()) {
-    VarListNode *vl = (VarListNode*)params;
-    for (unsigned i = 0; i < vl->GetNum(); i++) {
-      IdentifierNode *inode = vl->VarAtIndex(i);
-      call->AddArg(inode);
+  return mLastTreeNode;
+}
+
+// 'call' could be a CallNode or NewNode.
+// 'args' could be identifier, literal, expr, etc.
+void ASTBuilder::AddArguments(TreeNode *call, TreeNode *args) {
+  CallNode *callnode = NULL;
+  NewNode *newnode = NULL;
+  AnnotationNode *annotation = NULL;
+  if (call->IsCall())
+    callnode = (CallNode*)call;
+  else if (call->IsNew())
+    newnode = (NewNode*)call;
+  else if (call->IsAnnotation())
+    annotation = (AnnotationNode*)call;
+  else
+    MERROR("Unsupported call node.");
+
+  if (args->IsVarList()) {
+    VarListNode *vl = (VarListNode*)args;
+    for (unsigned i = 0; i < vl->GetVarsNum(); i++) {
+      IdentifierNode *inode = vl->GetVarAtIndex(i);
+      if (callnode)
+        callnode->AddArg(inode);
+      else if (newnode)
+        newnode->AddArg(inode);
+      else if (annotation)
+        annotation->AddArg(inode);
     }
-  } else if (params->IsPass()) {
-    PassNode *pass = (PassNode*)params;
+  } else if (args->IsPass()) {
+    PassNode *pass = (PassNode*)args;
     for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
       TreeNode *child = pass->GetChild(i);
-      call->AddArg(child);
+      AddArguments(call, child);
     }
   } else {
-    call->AddArg(params);
+    if (callnode)
+      callnode->AddArg(args);
+    else if (newnode)
+      newnode->AddArg(args);
+    else if (annotation)
+      annotation->AddArg(args);
   }
-
-  return mLastTreeNode;
 }
 
 // BuildVariableList takes two parameters, var 1 and var 2
@@ -1564,7 +3240,7 @@ TreeNode* ASTBuilder::BuildExprList() {
     node_ret->Merge(node_a);
   } else {
     // both nodes are not ExprListNode
-    node_ret = (ExprListNode*)mTreePool->NewTreeNode(sizeof(ExprListNode));
+    node_ret = (ExprListNode*)gTreePool.NewTreeNode(sizeof(ExprListNode));
     new (node_ret) ExprListNode();
     if (node_a)
       node_ret->Merge(node_a);
@@ -1582,6 +3258,7 @@ TreeNode* ASTBuilder::BuildExprList() {
 //                    FunctionNode related
 ////////////////////////////////////////////////////////////////////////////////
 
+// Takes only one argument, the params, and add it to mLastTreeNode
 TreeNode* ASTBuilder::AddParams() {
   if (mTrace)
     std::cout << "In AddParams" << std::endl;
@@ -1598,25 +3275,41 @@ TreeNode* ASTBuilder::AddParams() {
 }
 
 // This takes just one argument which is the function name.
+// The name could empty which is allowed in languages like JS.
 TreeNode* ASTBuilder::BuildFunction() {
   if (mTrace)
     std::cout << "In BuildFunction" << std::endl;
 
-  Param p_name = mParams[0];
-
-  if (!p_name.mIsTreeNode)
-    MERROR("The function name is not a treenode in BuildFunction()");
-  TreeNode *node_name = p_name.mData.mTreeNode;
+  TreeNode *node_name = NULL;
+
+  if (mParams.size() > 0) {
+    Param p_name = mParams[0];
+    // In JS/TS the name could be empty.
+    if (!p_name.mIsEmpty) {
+      if (p_name.mIsTreeNode) {
+        node_name = p_name.mData.mTreeNode;
+        if (node_name->IsAttr()) {
+          node_name = BuildIdentifier(node_name);
+        } else if (!node_name->IsIdentifier() &&
+                   !node_name->IsComputedName() &&
+                   !node_name->IsLiteral() &&
+                   !node_name->IsField())
+          MERROR("The function name should be an identifier node. Not?");
+      } else {
+        node_name = BuildIdentifier(p_name.mData.mToken);
+      }
+    }
+  }
 
-  if (!node_name->IsIdentifier())
-    MERROR("The function name should be an indentifier node. Not?");
-  IdentifierNode *in = (IdentifierNode*)node_name;
+  FunctionNode *f = (FunctionNode*)gTreePool.NewTreeNode(sizeof(FunctionNode));
+  new (f) FunctionNode();
 
-  FunctionNode *function = (FunctionNode*)mTreePool->NewTreeNode(sizeof(FunctionNode));
-  new (function) FunctionNode();
-  function->SetName(node_name->GetName());
+  if (node_name) {
+    f->SetFuncName(node_name);
+    f->SetStrIdx(node_name->GetStrIdx());
+  }
 
-  mLastTreeNode = function;
+  mLastTreeNode = f;
   return mLastTreeNode;
 }
 
@@ -1640,11 +3333,17 @@ TreeNode* ASTBuilder::AddFunctionBody() {
   // It's possible that the func body is empty, such as in the
   // function header declaration. Usually it's just a token ';'.
   Param p_body = mParams[0];
-  if (p_body.mIsTreeNode) {
+  if (!p_body.mIsEmpty) {
+    MASSERT(p_body.mIsTreeNode);
     TreeNode *tree_node = p_body.mData.mTreeNode;
     MASSERT(tree_node->IsBlock() && "Class body is not a BlockNode?");
     BlockNode *block = (BlockNode*)tree_node;
-    func->AddBody(block);
+    func->SetBody(block);
+  } else {
+    // It is an 'empty' function body. Not a NULL pointer of function body.
+    BlockNode *block = (BlockNode*)gTreePool.NewTreeNode(sizeof(BlockNode));
+    new (block) BlockNode();
+    func->SetBody(block);
   }
 
   mLastTreeNode = func;
@@ -1668,24 +3367,194 @@ TreeNode* ASTBuilder::AddFunctionBodyTo() {
   // It's possible that the func body is empty, such as in the
   // function header declaration. Usually it's just a token ';'.
   Param p_body = mParams[1];
-  if (p_body.mIsTreeNode) {
+  if (!p_body.mIsEmpty && p_body.mIsTreeNode) {
     TreeNode *tree_node = p_body.mData.mTreeNode;
     MASSERT(tree_node->IsBlock() && "Class body is not a BlockNode?");
     BlockNode *block = (BlockNode*)tree_node;
-    func->AddBody(block);
+    func->SetBody(block);
   }
 
   mLastTreeNode = func;
   return mLastTreeNode;
 }
 
+// It take no arugment. It uses mLastTreeNode which is
+// a function node.
+TreeNode* ASTBuilder::SetIsGenerator() {
+  MASSERT(mLastTreeNode->IsFunction());
+  FunctionNode *node = (FunctionNode*)mLastTreeNode;
+  node->SetIsGenerator();
+  return mLastTreeNode;
+}
+
+// It take no arugment. It uses mLastTreeNode which is
+// a function node.
+TreeNode* ASTBuilder::SetIsIterator() {
+  MASSERT(mLastTreeNode->IsFunction());
+  FunctionNode *node = (FunctionNode*)mLastTreeNode;
+  node->SetIsIterator();
+  return mLastTreeNode;
+}
+
+// It take no arugment. It uses mLastTreeNode which is
+// a yield node.
+TreeNode* ASTBuilder::SetIsTransfer() {
+  MASSERT(mLastTreeNode->IsYield());
+  YieldNode *node = (YieldNode*)mLastTreeNode;
+  node->SetIsTransfer();
+  return mLastTreeNode;
+}
+
+// It take no arugment. It uses mLastTreeNode which is
+// a function node.
+TreeNode* ASTBuilder::SetGetAccessor() {
+  MASSERT(mLastTreeNode->IsFunction());
+  FunctionNode *node = (FunctionNode*)mLastTreeNode;
+  node->SetIsGetAccessor();
+  return mLastTreeNode;
+}
+
+// It take no arugment. It uses mLastTreeNode which is
+// a function node.
+TreeNode* ASTBuilder::SetSetAccessor() {
+  MASSERT(mLastTreeNode->IsFunction());
+  FunctionNode *node = (FunctionNode*)mLastTreeNode;
+  node->SetIsSetAccessor();
+  return mLastTreeNode;
+}
+
+// It take no arugment. It uses mLastTreeNode which is
+// a function node.
+TreeNode* ASTBuilder::SetCallSignature() {
+  MASSERT(mLastTreeNode->IsFunction());
+  FunctionNode *node = (FunctionNode*)mLastTreeNode;
+  node->SetIsCallSignature();
+  return mLastTreeNode;
+}
+
+// It take no arugment. It uses mLastTreeNode which is
+// a function node.
+TreeNode* ASTBuilder::SetConstructSignature() {
+  MASSERT(mLastTreeNode->IsFunction());
+  FunctionNode *node = (FunctionNode*)mLastTreeNode;
+  node->SetIsConstructSignature();
+  return mLastTreeNode;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
-//                   Other Functions
+//                   Try, Catch, Throw
 ////////////////////////////////////////////////////////////////////////////////
 
-// This takes just one argument which is the tree passed from the
-// children. It could be single IdentifierNode, or a PassNode with
-// more than one tree nodes.
+// Takes one argument which is the block.
+TreeNode* ASTBuilder::BuildTry() {
+  if (mTrace)
+    std::cout << "In BuildTry" << std::endl;
+
+  Param p_block = mParams[0];
+
+  MASSERT(p_block.mIsTreeNode);
+  TreeNode *block = p_block.mData.mTreeNode;
+
+  TryNode *try_node = (TryNode*)gTreePool.NewTreeNode(sizeof(TryNode));
+  new (try_node) TryNode();
+  try_node->SetBlock((BlockNode*)block);
+
+  mLastTreeNode = try_node;
+  return mLastTreeNode;
+}
+
+// Takes one arguments, the catch clause
+// Add to mLastTreeNode which is a TryNode.
+TreeNode* ASTBuilder::AddCatch() {
+  if (mTrace)
+    std::cout << "In AddCatch " << std::endl;
+
+  Param p_catch = mParams[0];
+  MASSERT(p_catch.mIsTreeNode);
+  TreeNode *catch_node = p_catch.mData.mTreeNode;
+
+  TryNode *try_node = (TryNode*)mLastTreeNode;
+  try_node->AddCatch(catch_node);
+
+  return mLastTreeNode;
+}
+
+// Takes one arguments, the finally clause
+// Add to mLastTreeNode which is a TryNode.
+TreeNode* ASTBuilder::AddFinally() {
+  if (mTrace)
+    std::cout << "In AddFinally " << std::endl;
+
+  Param p_finally = mParams[0];
+  MASSERT(p_finally.mIsTreeNode);
+  TreeNode *finally_node = p_finally.mData.mTreeNode;
+  MASSERT(finally_node->IsFinally());
+
+  TryNode *try_node = (TryNode*)mLastTreeNode;
+  try_node->SetFinally((FinallyNode*)finally_node);
+
+  return mLastTreeNode;
+}
+
+// Takes one argument which is the block.
+TreeNode* ASTBuilder::BuildFinally() {
+  if (mTrace)
+    std::cout << "In BuildFinally" << std::endl;
+
+  Param p_block = mParams[0];
+
+  MASSERT(p_block.mIsTreeNode);
+  TreeNode *block = p_block.mData.mTreeNode;
+
+  FinallyNode *finally_node = (FinallyNode*)gTreePool.NewTreeNode(sizeof(FinallyNode));
+  new (finally_node) FinallyNode();
+  finally_node->SetBlock((BlockNode*)block);
+
+  mLastTreeNode = finally_node;
+  return mLastTreeNode;
+}
+
+// 1. Takes two arguments, the parameters and the block
+// 2. Takes one argument, the block
+TreeNode* ASTBuilder::BuildCatch() {
+  if (mTrace)
+    std::cout << "In BuildCatch" << std::endl;
+
+  TreeNode *params = NULL;
+  TreeNode *block = NULL;
+
+  if (mParams.size() == 2) {
+    Param p_params = mParams[0];
+    Param p_block = mParams[1];
+
+    MASSERT(p_params.mIsTreeNode);
+    params = p_params.mData.mTreeNode;
+
+    MASSERT(p_block.mIsTreeNode);
+    block = p_block.mData.mTreeNode;
+  } else {
+    Param p_block = mParams[0];
+    MASSERT(p_block.mIsTreeNode);
+    block = p_block.mData.mTreeNode;
+  }
+
+  CatchNode *catch_node = (CatchNode*)gTreePool.NewTreeNode(sizeof(CatchNode));
+  new (catch_node) CatchNode();
+
+  if (params)
+    catch_node->AddParam(params);
+  catch_node->SetBlock((BlockNode*)block);
+
+  mLastTreeNode = catch_node;
+  return mLastTreeNode;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+//                   Throw Functions
+////////////////////////////////////////////////////////////////////////////////
+
+// This takes just one argument which is the exception(s) thrown.
 TreeNode* ASTBuilder::BuildThrows() {
   if (mTrace)
     std::cout << "In BuildThrows" << std::endl;
@@ -1694,12 +3563,14 @@ TreeNode* ASTBuilder::BuildThrows() {
 
   if (!p_throws.mIsTreeNode)
     MERROR("The exceptions is not a treenode in BuildThrows()");
-  TreeNode *node_throws = p_throws.mData.mTreeNode;
+  TreeNode *exceptions = p_throws.mData.mTreeNode;
+
+  ThrowNode *throw_node = (ThrowNode*)gTreePool.NewTreeNode(sizeof(ThrowNode));
+  new (throw_node) ThrowNode();
 
-  if (!node_throws->IsIdentifier() && !node_throws->IsPass())
-    MERROR("The throws should be an indentifier node or pass node. Not?");
+  throw_node->AddException(exceptions);
 
-  mLastTreeNode = node_throws;
+  mLastTreeNode = throw_node;
   return mLastTreeNode;
 }
 
@@ -1724,7 +3595,7 @@ TreeNode* ASTBuilder::AddThrowsTo() {
     TreeNode *tree_node = p_body.mData.mTreeNode;
     if (tree_node->IsIdentifier()) {
       IdentifierNode *id = (IdentifierNode*)tree_node;
-      ExceptionNode *exception = (ExceptionNode*)mTreePool->NewTreeNode(sizeof(ExceptionNode));
+      ExceptionNode *exception = (ExceptionNode*)gTreePool.NewTreeNode(sizeof(ExceptionNode));
       new (exception) ExceptionNode(id);
       func->AddThrow(exception);
     } else if (tree_node->IsPass()) {
@@ -1733,7 +3604,7 @@ TreeNode* ASTBuilder::AddThrowsTo() {
         TreeNode *child = pass->GetChild(i);
         if (child->IsIdentifier()) {
           IdentifierNode *id = (IdentifierNode*)child;
-          ExceptionNode *exception = (ExceptionNode*)mTreePool->NewTreeNode(sizeof(ExceptionNode));
+          ExceptionNode *exception = (ExceptionNode*)gTreePool.NewTreeNode(sizeof(ExceptionNode));
           new (exception) ExceptionNode(id);
           func->AddThrow(exception);
         } else {
@@ -1747,6 +3618,27 @@ TreeNode* ASTBuilder::AddThrowsTo() {
   return mLastTreeNode;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+//                   Pass a Child
+// We only pass tree node. It should not be a token.
+////////////////////////////////////////////////////////////////////////////////
+
+TreeNode* ASTBuilder::PassChild() {
+  if (mTrace)
+    std::cout << "In PassChild" << std::endl;
+
+  TreeNode *node = NULL;
+  Param p = mParams[0];
+  if (!p.mIsEmpty) {
+    if (!p.mIsTreeNode)
+      MERROR("The child is not a treenode.");
+    node = p.mData.mTreeNode;
+  }
+
+  mLastTreeNode = node;
+  return mLastTreeNode;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 //                   User Type Functions
 ////////////////////////////////////////////////////////////////////////////////
@@ -1758,26 +3650,107 @@ TreeNode* ASTBuilder::BuildUserType() {
   Param p_id = mParams[0];
   if (!p_id.mIsTreeNode)
     MERROR("The Identifier of user type is not a treenode.");
+  TreeNode *id = p_id.mData.mTreeNode;
 
-  TreeNode *node = p_id.mData.mTreeNode;
-  if (!node->IsIdentifier())
-    MERROR("The Identifier of user type is not an identifier.");
-  IdentifierNode *id = (IdentifierNode*)node;
-
-  UserTypeNode *user_type = (UserTypeNode*)mTreePool->NewTreeNode(sizeof(UserTypeNode));
+  UserTypeNode *user_type = (UserTypeNode*)gTreePool.NewTreeNode(sizeof(UserTypeNode));
   new (user_type) UserTypeNode(id);
   mLastTreeNode = user_type;
   return mLastTreeNode;
 }
 
-TreeNode* ASTBuilder::AddTypeArgument() {
+TreeNode* ASTBuilder::BuildTypeParameter() {
+  if (mTrace)
+    std::cout << "In BuildTypeParameter" << std::endl;
+
+  Param p_id = mParams[0];
+  if (!p_id.mIsTreeNode)
+    MERROR("The Identifier of type parameter is not a treenode.");
+  TreeNode *id = p_id.mData.mTreeNode;
+
+  TypeParameterNode *tp = (TypeParameterNode*)gTreePool.NewTreeNode(sizeof(TypeParameterNode));
+  new (tp) TypeParameterNode();
+  tp->SetId(id);
+
+  mLastTreeNode = tp;
+  return mLastTreeNode;
+}
+
+// It takes one argument, the constraint which could be empty.
+TreeNode* ASTBuilder::AddTypeParameterExtends() {
   if (mTrace)
-    std::cout << "In AddTypeArgument" << std::endl;
+    std::cout << "In AddTypeParameterExtends" << std::endl;
+
+  Param p_id = mParams[0];
+  if (p_id.mIsEmpty)
+    return mLastTreeNode;
+
+  MASSERT(p_id.mIsTreeNode);
+  TreeNode *id = p_id.mData.mTreeNode;
+
+  MASSERT(mLastTreeNode->IsTypeParameter());
+  TypeParameterNode *tp = (TypeParameterNode*)mLastTreeNode;
+  tp->SetExtends(id);
+
+  mLastTreeNode = tp;
+  return mLastTreeNode;
+}
+
+
+// Takes one argument, the as 'type'.
+TreeNode* ASTBuilder::BuildAsType() {
+  if (mTrace)
+    std::cout << "In BuildAsType" << std::endl;
+
+  Param p_id = mParams[0];
+  if (!p_id.mIsTreeNode)
+    MERROR("The Identifier of type parameter is not a treenode.");
+  TreeNode *id = p_id.mData.mTreeNode;
+
+  AsTypeNode *tp = (AsTypeNode*)gTreePool.NewTreeNode(sizeof(AsTypeNode));
+  new (tp) AsTypeNode();
+  tp->SetType(id);
+
+  mLastTreeNode = tp;
+  return mLastTreeNode;
+}
+
+// Takes four argument, type a, type b, type c , type d.
+TreeNode* ASTBuilder::BuildConditionalType() {
+  if (mTrace)
+    std::cout << "In BuildConditionalType" << std::endl;
+
+  Param p_a = mParams[0];
+  TreeNode *type_a = p_a.mData.mTreeNode;
+  Param p_b = mParams[1];
+  TreeNode *type_b = p_b.mData.mTreeNode;
+  Param p_c = mParams[2];
+  TreeNode *type_c = p_c.mData.mTreeNode;
+  Param p_d = mParams[3];
+  TreeNode *type_d = p_d.mData.mTreeNode;
+
+  ConditionalTypeNode *tp = (ConditionalTypeNode*)gTreePool.NewTreeNode(sizeof(ConditionalTypeNode));
+  new (tp) ConditionalTypeNode();
+  tp->SetTypeA(type_a);
+  tp->SetTypeB(type_b);
+  tp->SetTypeC(type_c);
+  tp->SetTypeD(type_d);
+
+  mLastTreeNode = tp;
+  return mLastTreeNode;
+}
+
+
+// It takes one argument, the type param or type arg
+TreeNode* ASTBuilder::AddTypeGenerics() {
+  if (mTrace)
+    std::cout << "In AddTypeGenerics" << std::endl;
 
   if (mParams.size() == 0)
     return mLastTreeNode;
 
   Param p_args = mParams[0];
+  if (p_args.mIsEmpty)
+    return mLastTreeNode;
 
   // Some language allows special syntax as type arguments, like <> in Java.
   // It's just a token.
@@ -1787,22 +3760,273 @@ TreeNode* ASTBuilder::AddTypeArgument() {
   TreeNode *args = p_args.mData.mTreeNode;
   MASSERT(args);
 
-  UserTypeNode *type_node = (UserTypeNode*)mLastTreeNode;
-  type_node->AddTypeArgs(args);
+  if (mLastTreeNode->IsTypeAlias()) {
+    TypeAliasNode *type_alias = (TypeAliasNode*)mLastTreeNode;
+    UserTypeNode *n = type_alias->GetId();
+    n->AddTypeGeneric(args);
+  } else if (mLastTreeNode->IsUserType()) {
+    UserTypeNode *type_node = (UserTypeNode*)mLastTreeNode;
+    type_node->AddTypeGeneric(args);
+  } else if (mLastTreeNode->IsCall()) {
+    CallNode *call = (CallNode*)mLastTreeNode;
+    call->AddTypeArgument(args);
+  } else if (mLastTreeNode->IsFunction()) {
+    FunctionNode *func = (FunctionNode*)mLastTreeNode;
+    func->AddTypeParam(args);
+  } else if (mLastTreeNode->IsClass()) {
+    ClassNode *c = (ClassNode*)mLastTreeNode;
+    c->AddTypeParam(args);
+  } else if (mLastTreeNode->IsStruct()) {
+    StructNode *c = (StructNode*)mLastTreeNode;
+    c->AddTypeParam(args);
+  } else if (mLastTreeNode->IsLambda()) {
+    LambdaNode *c = (LambdaNode*)mLastTreeNode;
+    c->AddTypeParam(args);
+  } else {
+    MERROR("Unsupported node in AddTypeGenerics()");
+  }
+
+  return mLastTreeNode;
+}
+
+// It takes two arguments to build a union type, child-a and child-b
+// A child could be a prim type or user type, or even a union user type.
+TreeNode* ASTBuilder::BuildUnionUserType() {
+  if (mTrace)
+    std::cout << "In BuildUnionUserType" << std::endl;
+
+  UserTypeNode *user_type = NULL;
+
+  Param p_a = mParams[0];
+  MASSERT (p_a.mIsTreeNode);
+  TreeNode *child_a = p_a.mData.mTreeNode;
+
+  Param p_b = mParams[1];
+  MASSERT (p_b.mIsTreeNode);
+  TreeNode *child_b = p_b.mData.mTreeNode;
+
+  if (child_a->IsUserType()) {
+    UserTypeNode *ut = (UserTypeNode*)child_a;
+    // for case like : (a | b)[] | c
+    // We won't merge c into the array type.
+    if (ut->GetType() == UT_Union && !ut->GetDims()) {
+      user_type = ut;
+      user_type->AddUnionInterType(child_b);
+    }
+  }
+
+  if (child_b->IsUserType()) {
+    UserTypeNode *ut = (UserTypeNode*)child_b;
+    if (ut->GetType() == UT_Union && !ut->GetDims()) {
+      // assert, both children cannot be UnionUserType at the same time.
+      MASSERT(!user_type);
+      user_type = ut;
+      user_type->AddUnionInterType(child_a, true);
+    }
+  }
+
+  if (!user_type) {
+    user_type = (UserTypeNode*)gTreePool.NewTreeNode(sizeof(UserTypeNode));
+    new (user_type) UserTypeNode();
+    user_type->SetType(UT_Union);
+    user_type->AddUnionInterType(child_a);
+    user_type->AddUnionInterType(child_b);
+  }
+
+  mLastTreeNode = user_type;
+  return mLastTreeNode;
+}
+
+// It takes two arguments to build a intersection type, child-a and child-b
+// A child could be a prim type or user type.
+TreeNode* ASTBuilder::BuildInterUserType() {
+  if (mTrace)
+    std::cout << "In BuildInterUserType" << std::endl;
+
+  UserTypeNode *user_type = NULL;
+
+  Param p_a = mParams[0];
+  MASSERT (p_a.mIsTreeNode);
+  TreeNode *child_a = p_a.mData.mTreeNode;
+
+  Param p_b = mParams[1];
+  MASSERT (p_b.mIsTreeNode);
+  TreeNode *child_b = p_b.mData.mTreeNode;
+
+  if (child_a->IsUserType()) {
+    UserTypeNode *ut = (UserTypeNode*)child_a;
+    if (ut->GetType() == UT_Inter) {
+      user_type = ut;
+      user_type->AddUnionInterType(child_b);
+    }
+  }
+
+  if (child_b->IsUserType()) {
+    UserTypeNode *ut = (UserTypeNode*)child_b;
+    if (ut->GetType() == UT_Inter) {
+      // assert, both children cannot be UnionUserType at the same time.
+      MASSERT(!user_type);
+      user_type = ut;
+      user_type->AddUnionInterType(child_a, true);
+    }
+  }
+
+  if (!user_type) {
+    user_type = (UserTypeNode*)gTreePool.NewTreeNode(sizeof(UserTypeNode));
+    new (user_type) UserTypeNode();
+    user_type->SetType(UT_Inter);
+    user_type->AddUnionInterType(child_a);
+    user_type->AddUnionInterType(child_b);
+  }
+
+  mLastTreeNode = user_type;
+  return mLastTreeNode;
+}
+
+// It takes two arguments. The alias name, and they orig type.
+TreeNode* ASTBuilder::BuildTypeAlias() {
+  if (mTrace)
+    std::cout << "In BuildTypeAlias" << std::endl;
+
+  Param p_name = mParams[0];
+  MASSERT (p_name.mIsTreeNode);
+  TreeNode *name = p_name.mData.mTreeNode;
+  MASSERT(name->IsIdentifier());
+  IdentifierNode *id = (IdentifierNode*)name;
+
+  UserTypeNode *user_type = (UserTypeNode*)gTreePool.NewTreeNode(sizeof(UserTypeNode));
+  new (user_type) UserTypeNode();
+  user_type->SetId(id);
+
+  Param p_orig = mParams[1];
+  MASSERT (p_orig.mIsTreeNode);
+  TreeNode *orig = p_orig.mData.mTreeNode;
+
+  TypeAliasNode *type_alias = (TypeAliasNode*)gTreePool.NewTreeNode(sizeof(TypeAliasNode));
+  new (type_alias) TypeAliasNode();
+  type_alias->SetId(user_type);
+  type_alias->SetAlias(orig);
+
+  mLastTreeNode = type_alias;
+  return mLastTreeNode;
+}
+
+// It takes at least one argument, the basic type.
+TreeNode* ASTBuilder::BuildNeverArrayType() {
+  if (mTrace)
+    std::cout << "In BuildNeverArrayType" << std::endl;
+
+  PrimTypeNode *prim_type = gPrimTypePool.FindType(TY_Never);
+  PrimArrayTypeNode *prim_array_type = (PrimArrayTypeNode*)gTreePool.NewTreeNode(sizeof(PrimArrayTypeNode));
+  new (prim_array_type) PrimArrayTypeNode();
+  prim_array_type->SetPrim(prim_type);
+
+  DimensionNode *dims = (DimensionNode*)gTreePool.NewTreeNode(sizeof(DimensionNode));
+  new (dims) DimensionNode();
+  dims->AddDimension(0);
+
+  prim_array_type->SetDims(dims);
+  mLastTreeNode = prim_array_type;
+
+  return mLastTreeNode;
+}
+
+// It takes at least one argument, the basic type.
+// The rest argument represent the dimensions.
+//
+// [NOTE] For each dimension, we are using a trick. If the size of a dimension is unknown,
+//        we use the same tree node of 'basic type'.
+
+TreeNode* ASTBuilder::BuildArrayType() {
+  if (mTrace)
+    std::cout << "In BuildArrayType" << std::endl;
+
+  Param p_basic = mParams[0];
+  MASSERT (p_basic.mIsTreeNode);
+  TreeNode *basic = p_basic.mData.mTreeNode;
+
+  UserTypeNode *user_type = NULL;       // we return either user_type
+  PrimTypeNode *prim_type = NULL;       //
+  PrimArrayTypeNode *prim_array_type = NULL; // or prim_array_type
+
+  DimensionNode *dims = NULL;
+
+  // This is a weird behavior in Typescript. A type key word can be identifier also.
+  // I need check here.
+  if (basic->IsIdentifier()) {
+    IdentifierNode *id = (IdentifierNode*)basic;
+    const char *id_name = id->GetName();
+    if (id_name) {
+      PrimTypeNode *pt = gPrimTypePool.FindType(id_name);
+      if (pt)
+        basic = pt;
+    }
+  }
+
+  if (basic->IsPrimArrayType()) {
+    prim_array_type = (PrimArrayTypeNode*)basic;
+    dims = prim_array_type->GetDims();
+  } else if (basic->IsUserType()) {
+    user_type = (UserTypeNode*)basic;
+    dims = user_type->GetDims();
+  } else if (basic->IsPrimType()) {
+    prim_type = (PrimTypeNode*)basic;
+    prim_array_type = (PrimArrayTypeNode*)gTreePool.NewTreeNode(sizeof(PrimArrayTypeNode));
+    new (prim_array_type) PrimArrayTypeNode();
+    prim_array_type->SetPrim(prim_type);
+  } else {
+    user_type = (UserTypeNode*)gTreePool.NewTreeNode(sizeof(UserTypeNode));
+    new (user_type) UserTypeNode();
+    user_type->SetId(basic);
+  }
+
+  if (!dims) {
+    dims = (DimensionNode*)gTreePool.NewTreeNode(sizeof(DimensionNode));
+    new (dims) DimensionNode();
+  }
+
+  for (unsigned i = 1; i < mParams.size(); i++) {
+    Param p_dim = mParams[i];
+    MASSERT (p_dim.mIsTreeNode);
+    TreeNode *dim = p_dim.mData.mTreeNode;
+    // Right now we just add all 0 to dim.
+    if (dim == basic)
+      dims->AddDimension(0);
+    else
+      dims->AddDimension(0);
+  }
+
+  if (user_type) {
+    if (!user_type->GetDims())
+      user_type->SetDims(dims);
+    mLastTreeNode = user_type;
+  } else {
+    MASSERT(prim_array_type);
+    if (!prim_array_type->GetDims())
+      prim_array_type->SetDims(dims);
+    mLastTreeNode = prim_array_type;
+  }
 
   return mLastTreeNode;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-//                       Lambda Expression
+//                       LambdaNode
+// As stated in the ast.h, LambdaNode could be different syntax construct in
+// different languages.
 ////////////////////////////////////////////////////////////////////////////////
 
+// It could take
+//   1) One parameter, which is the parameter list.
+//   2) two parameters, the parameter list and the body
 TreeNode* ASTBuilder::BuildLambda() {
   if (mTrace)
     std::cout << "In BuildLambda" << std::endl;
 
-  Param p_params = mParams[0];
   TreeNode *params_node = NULL;
+  TreeNode *body_node = NULL;
+
+  Param p_params = mParams[0];
   if (!p_params.mIsEmpty) {
     if (!p_params.mIsTreeNode)
       MERROR("Lambda params is not a tree node.");
@@ -1810,26 +4034,294 @@ TreeNode* ASTBuilder::BuildLambda() {
       params_node = p_params.mData.mTreeNode;
   }
 
-  Param p_body = mParams[1];
-  TreeNode *body_node = NULL;
-  if (!p_body.mIsEmpty) {
-    if (!p_body.mIsTreeNode)
-      MERROR("Lambda Body is not a tree node.");
-    else
-      body_node = CvtToBlock(p_body.mData.mTreeNode);
+  if (mParams.size() == 2) {
+    Param p_body = mParams[1];
+    if (!p_body.mIsEmpty) {
+      if (!p_body.mIsTreeNode)
+        MERROR("Lambda Body is not a tree node.");
+      else
+        body_node = p_body.mData.mTreeNode;
+    }
   }
 
-  LambdaNode *lambda = (LambdaNode*)mTreePool->NewTreeNode(sizeof(LambdaNode));
+  LambdaNode *lambda = (LambdaNode*)gTreePool.NewTreeNode(sizeof(LambdaNode));
   new (lambda) LambdaNode();
 
   if (params_node) {
-    if (params_node->IsIdentifier())
+    if (params_node->IsIdentifier()) {
       lambda->AddParam((IdentifierNode*)params_node);
+    } else {
+      AddParams(lambda, params_node);
+    }
   }
 
-  lambda->SetBody(body_node);
+  if (body_node)
+    lambda->SetBody(body_node);
 
   mLastTreeNode = lambda;
   return mLastTreeNode;
 }
+
+// It take no arugment. It uses mLastTreeNode which is
+// a lambda node.
+TreeNode* ASTBuilder::SetJavaLambda() {
+  MASSERT(mLastTreeNode->IsLambda());
+  LambdaNode *node = (LambdaNode*)mLastTreeNode;
+  node->SetProperty(LP_JavaLambda);
+  return mLastTreeNode;
+}
+
+// It take no arugment. It uses mLastTreeNode which is
+// a lambda node.
+TreeNode* ASTBuilder::SetArrowFunction() {
+  MASSERT(mLastTreeNode->IsLambda());
+  LambdaNode *node = (LambdaNode*)mLastTreeNode;
+  node->SetProperty(LP_JSArrowFunction);
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//                       InstanceOf Expression
+////////////////////////////////////////////////////////////////////////////////
+
+TreeNode* ASTBuilder::BuildInstanceOf() {
+  if (mTrace)
+    std::cout << "In BuildInstanceOf" << std::endl;
+
+  Param l_param = mParams[0];
+  MASSERT(!l_param.mIsEmpty);
+  MASSERT(l_param.mIsTreeNode);
+  TreeNode *left = l_param.mData.mTreeNode;
+
+  Param r_param = mParams[1];
+  MASSERT(!r_param.mIsEmpty);
+  MASSERT(r_param.mIsTreeNode);
+  TreeNode *right = r_param.mData.mTreeNode;
+
+  InstanceOfNode *instanceof = (InstanceOfNode*)gTreePool.NewTreeNode(sizeof(InstanceOfNode));
+  new (instanceof) InstanceOfNode();
+
+  instanceof->SetLeft(left);
+  instanceof->SetRight(right);
+
+  mLastTreeNode = instanceof;
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//                       In Expression
+////////////////////////////////////////////////////////////////////////////////
+
+TreeNode* ASTBuilder::BuildIn() {
+  if (mTrace)
+    std::cout << "In BuildIn" << std::endl;
+
+  Param l_param = mParams[0];
+  MASSERT(!l_param.mIsEmpty);
+  MASSERT(l_param.mIsTreeNode);
+  TreeNode *left = l_param.mData.mTreeNode;
+
+  Param r_param = mParams[1];
+  MASSERT(!r_param.mIsEmpty);
+  MASSERT(r_param.mIsTreeNode);
+  TreeNode *right = r_param.mData.mTreeNode;
+
+  InNode *innode = (InNode*)gTreePool.NewTreeNode(sizeof(InNode));
+  new (innode) InNode();
+
+  innode->SetLeft(left);
+  innode->SetRight(right);
+
+  mLastTreeNode = innode;
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//                       ComputedNameNode Expression
+////////////////////////////////////////////////////////////////////////////////
+
+TreeNode* ASTBuilder::BuildComputedName() {
+  if (mTrace)
+    std::cout << "In BuildComputedName" << std::endl;
+
+  Param l_param = mParams[0];
+  MASSERT(!l_param.mIsEmpty);
+  MASSERT(l_param.mIsTreeNode);
+  TreeNode *in = l_param.mData.mTreeNode;
+
+  ComputedNameNode *innode = (ComputedNameNode*)gTreePool.NewTreeNode(sizeof(ComputedNameNode));
+  new (innode) ComputedNameNode();
+  innode->SetExpr(in);
+
+  mLastTreeNode = innode;
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//                       Is Expression
+////////////////////////////////////////////////////////////////////////////////
+
+TreeNode* ASTBuilder::BuildIs() {
+  if (mTrace)
+    std::cout << "In BuildIs" << std::endl;
+
+  Param l_param = mParams[0];
+  MASSERT(!l_param.mIsEmpty);
+  MASSERT(l_param.mIsTreeNode);
+  TreeNode *left = l_param.mData.mTreeNode;
+
+  Param r_param = mParams[1];
+  MASSERT(!r_param.mIsEmpty);
+  MASSERT(r_param.mIsTreeNode);
+  TreeNode *right = r_param.mData.mTreeNode;
+
+  IsNode *isnode = (IsNode*)gTreePool.NewTreeNode(sizeof(IsNode));
+  new (isnode) IsNode();
+
+  isnode->SetLeft(left);
+  isnode->SetRight(right);
+
+  mLastTreeNode = isnode;
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//                       TypeOf Expression
+////////////////////////////////////////////////////////////////////////////////
+
+// It takes (1) one argument
+//          (2) zero argument. Use mLastTreeNode as the argument.
+TreeNode* ASTBuilder::BuildTypeOf() {
+  if (mTrace)
+    std::cout << "In BuildTypeOf" << std::endl;
+
+  TreeNode *expr = NULL;
+
+  if (mParams.size() == 0) {
+    expr = mLastTreeNode;
+  } else {
+    Param l_param = mParams[0];
+    MASSERT(l_param.mIsTreeNode);
+    expr = l_param.mData.mTreeNode;
+  }
+
+  TypeOfNode *typeof = (TypeOfNode*)gTreePool.NewTreeNode(sizeof(TypeOfNode));
+  new (typeof) TypeOfNode();
+
+  typeof->SetExpr(expr);
+
+  mLastTreeNode = typeof;
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//                       KeyOf Expression
+////////////////////////////////////////////////////////////////////////////////
+
+TreeNode* ASTBuilder::BuildKeyOf() {
+  if (mTrace)
+    std::cout << "In BuildKeyOf" << std::endl;
+
+  Param l_param = mParams[0];
+  MASSERT(!l_param.mIsEmpty);
+  MASSERT(l_param.mIsTreeNode);
+  TreeNode *expr = l_param.mData.mTreeNode;
+
+  KeyOfNode *keyof = (KeyOfNode*)gTreePool.NewTreeNode(sizeof(KeyOfNode));
+  new (keyof) KeyOfNode();
+
+  keyof->SetExpr(expr);
+
+  mLastTreeNode = keyof;
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//                       Infer Expression
+////////////////////////////////////////////////////////////////////////////////
+
+TreeNode* ASTBuilder::BuildInfer() {
+  if (mTrace)
+    std::cout << "In BuildInfer" << std::endl;
+
+  Param l_param = mParams[0];
+  MASSERT(!l_param.mIsEmpty);
+  MASSERT(l_param.mIsTreeNode);
+  TreeNode *expr = l_param.mData.mTreeNode;
+
+  InferNode *infer = (InferNode*)gTreePool.NewTreeNode(sizeof(InferNode));
+  new (infer) InferNode();
+
+  infer->SetExpr(expr);
+
+  mLastTreeNode = infer;
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//                       Triple Slash Directive of TypeScript
+////////////////////////////////////////////////////////////////////////////////
+
+TreeNode* ASTBuilder::BuildTripleSlash() {
+  if (mTrace)
+    std::cout << "In BuildTripleSlash" << std::endl;
+
+  Param l_param = mParams[0];
+  MASSERT(!l_param.mIsEmpty);
+  MASSERT(l_param.mIsTreeNode);
+  TreeNode *left = l_param.mData.mTreeNode;
+
+  Param r_param = mParams[1];
+  MASSERT(!r_param.mIsEmpty);
+  MASSERT(r_param.mIsTreeNode);
+  TreeNode *right = r_param.mData.mTreeNode;
+
+  TripleSlashNode *tsnode = (TripleSlashNode*)gTreePool.NewTreeNode(sizeof(TripleSlashNode));
+  new (tsnode) TripleSlashNode();
+
+  TripleSlashProp prop = TSP_NA;
+  if (left->IsIdentifier()) {
+    // no-default-lib
+    if ((strlen(left->GetName()) == 14) && !strncmp(left->GetName(), "no-default-lib", 14))
+      prop = TSP_NoDefaultLib;
+    // lib
+    if ((strlen(left->GetName()) == 3) && !strncmp(left->GetName(), "lib", 3))
+      prop = TSP_Lib;
+    // types
+    if ((strlen(left->GetName()) == 5) && !strncmp(left->GetName(), "types", 5))
+      prop = TSP_Types;
+    // path
+    if ((strlen(left->GetName()) == 4) && !strncmp(left->GetName(), "path", 4))
+      prop = TSP_Path;
+  }
+  tsnode->SetProp(prop);
+
+  tsnode->SetValue(right);
+
+  mLastTreeNode = tsnode;
+  return mLastTreeNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//                       Await
+////////////////////////////////////////////////////////////////////////////////
+
+// For first parameter has to be an operator.
+TreeNode* ASTBuilder::BuildAwait() {
+  if (mTrace)
+    std::cout << "In BuildAwait" << std::endl;
+
+  MASSERT(mParams.size() == 1);
+  Param p_a = mParams[0];
+  MASSERT(!p_a.mIsEmpty && p_a.mIsTreeNode);
+  TreeNode *expr = p_a.mData.mTreeNode;
+
+  AwaitNode *n = (AwaitNode*)gTreePool.NewTreeNode(sizeof(AwaitNode));
+  new (n) AwaitNode();
+  n->SetExpr(expr);
+
+  mLastTreeNode = n;
+  return n;
+}
+
 }
diff --git a/src/MapleFE/shared/src/ast_fixup.cpp b/src/MapleFE/shared/src/ast_fixup.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..30e8a26cc7475faacf088f8897946ef85b0e4c1f
--- /dev/null
+++ b/src/MapleFE/shared/src/ast_fixup.cpp
@@ -0,0 +1,169 @@
+/*
+* Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <filesystem>
+#include "ast_fixup.h"
+#include "stringpool.h"
+
+namespace maplefe {
+
+bool FixUpVisitor::FixUp() {
+  Visit(mASTModule);
+  return mUpdated;
+}
+
+// Fix up mOprId of a UnaOperatorNode
+UnaOperatorNode *FixUpVisitor::VisitUnaOperatorNode(UnaOperatorNode *node) {
+  switch(node->GetOprId()) {
+    case OPR_Add:
+      node->SetOprId(OPR_Plus);
+      mUpdated = true;
+      break;
+    case OPR_Sub:
+      node->SetOprId(OPR_Minus);
+      mUpdated = true;
+    case OPR_Minus:
+      if (TreeNode *n = node->GetOpnd(); n && n->IsLiteral()) {
+        LiteralNode *lit = static_cast<LiteralNode *>(n);
+        LitData data = lit->GetData();
+        switch(data.mType) {
+          case LT_IntegerLiteral:
+            data.mData.mInt = -data.mData.mInt;
+            break;
+          case LT_FPLiteral:
+            data.mData.mFloat = -data.mData.mFloat;
+            break;
+          case LT_DoubleLiteral:
+            data.mData.mDouble = -data.mData.mDouble;
+            break;
+          default:
+            goto skip;
+        }
+        lit->SetData(data);
+        lit->SetParent(node->GetParent());
+        mUpdated = true;
+        return (UnaOperatorNode *)lit;
+      }
+    skip:
+      break;
+    case OPR_Inc:
+      if(!node->IsPost()) {
+        node->SetOprId(OPR_PreInc);
+        mUpdated = true;
+      }
+      break;
+    case OPR_Dec:
+      if(!node->IsPost()) {
+        node->SetOprId(OPR_PreDec);
+        mUpdated = true;
+      }
+  }
+  return AstVisitor::VisitUnaOperatorNode(node);
+}
+
+// Fix up the name string of a UserTypeNode
+// Fix up literal boolean 'true' or 'false' as a type
+UserTypeNode *FixUpVisitor::VisitUserTypeNode(UserTypeNode *node) {
+  auto id = node->GetId();
+
+  // Java FE 'java2mpl' needs this
+  if(id)
+    if(auto n = id->GetStrIdx())
+      if(node->GetStrIdx() != n) {
+        node->SetStrIdx(n);
+        mUpdated = true;
+      }
+
+  if(id && id->IsIdentifier()) {
+    auto n = id->GetStrIdx();
+    auto true_id = gStringPool.GetStrIdx("true");
+    if(n == true_id || n == gStringPool.GetStrIdx("false")) {
+      if(node->GetType() == UT_Regular
+          && node->GetDims() == nullptr
+          && node->GetUnionInterTypesNum() == 0
+          && node->GetTypeGenericsNum() == 0
+          && node->GetAttrsNum() == 0
+          && node->GetAsTypesNum() == 0) {
+        mUpdated = true;
+        LitData data;
+        data.mType = LT_BooleanLiteral;
+        data.mData.mBool = n == true_id;
+        LiteralNode *lit = new (gTreePool.NewTreeNode(sizeof(LiteralNode))) LiteralNode(data);
+        return (UserTypeNode*)lit;
+      }
+    }
+  }
+  return AstVisitor::VisitUserTypeNode(node);
+}
+
+// Fix up literal 'true' or 'false'
+IdentifierNode *FixUpVisitor::VisitIdentifierNode(IdentifierNode *node) {
+  auto p = node->GetParent();
+  if(p && node->GetInit() == nullptr &&
+      (p->IsFieldLiteral() || p->IsTerOperator() || p->IsIdentifier() || p->IsBinOperator())) {
+    if(auto n = node->GetStrIdx()) {
+      auto true_id = gStringPool.GetStrIdx("true");
+      if(n == true_id || n == gStringPool.GetStrIdx("false")) {
+        mUpdated = true;
+        LitData data;
+        data.mType = LT_BooleanLiteral;
+        data.mData.mBool = n == true_id;
+        LiteralNode *lit = new (gTreePool.NewTreeNode(sizeof(LiteralNode))) LiteralNode(data);
+        return (IdentifierNode*)lit;
+      }
+    }
+  }
+  return AstVisitor::VisitIdentifierNode(node);
+}
+
+// Fix up the filename of a ModuleNode
+ModuleNode *FixUpVisitor::VisitModuleNode(ModuleNode *node) {
+  const char* filename = node->GetFilename();
+  std::filesystem::path orig = filename;
+  std::filesystem::path uniq;
+  try {
+    uniq = std::filesystem::canonical(orig);
+  }
+  catch(std::filesystem::filesystem_error const& ex) {
+    // Use orig if std::filesystem::filesystem_error is thrown
+    uniq = orig;
+  }
+  std::string p = uniq.string();
+  if(p != filename) {
+    const char *res = gStringPool.FindString(p.c_str());
+    node->SetFilename(res);
+    mUpdated = true;
+  }
+  return AstVisitor::VisitModuleNode(node);;
+}
+
+// Fux up a PassNode for tagged template literal
+PassNode *FixUpVisitor::VisitPassNode(PassNode *node) {
+  AstVisitor::VisitPassNode(node);
+  unsigned num = node->GetChildrenNum();
+  if (num == 2) {
+    TreeNode *child0 = node->GetChild(0);
+    TreeNode *child1 = node->GetChild(1);
+    if (child0 && child1 && child1->IsTemplateLiteral()) {
+      CallNode *call = new (gTreePool.NewTreeNode(sizeof(CallNode))) CallNode();
+      call->SetMethod(child0);
+      call->SetTaggedTemplate(static_cast<TemplateLiteralNode *>(child1));
+      return (PassNode*)call;
+    }
+  }
+  return node;
+}
+
+}
diff --git a/src/MapleFE/shared/src/ast_mempool.cpp b/src/MapleFE/shared/src/ast_mempool.cpp
index 1c9cf527a47f364bdc67cbb5abc5e0ff9ea02c05..6c52307703272dd690bcb109e88c9d62843fea55 100644
--- a/src/MapleFE/shared/src/ast_mempool.cpp
+++ b/src/MapleFE/shared/src/ast_mempool.cpp
@@ -17,16 +17,21 @@
 
 namespace maplefe {
 
+TreePool gTreePool;
+
 TreePool::~TreePool() {
   Release();
 }
 
 char* TreePool::NewTreeNode(unsigned size) {
   char *addr = mMP.Alloc(size);
-  mTreeNodes.push_back((TreeNode*)addr);
+  TreeNode *tree = (TreeNode*)addr;
+  mTreeNodes.push_back(tree);
+  unsigned id = mTreeNodes.size();
+  tree->SetNodeId(id);
   return addr;
 }
-  
+
 void TreePool::Release() {
   // step 1. Release the containers in each tree node.
   std::vector<TreeNode*>::iterator it = mTreeNodes.begin();
diff --git a/src/MapleFE/shared/src/ast_module.cpp b/src/MapleFE/shared/src/ast_module.cpp
index 02e80f41f33b89072c5b716b6007f194af1da0a9..9cab6e95aaf3856b52ef1283fdef66b794d7a798 100644
--- a/src/MapleFE/shared/src/ast_module.cpp
+++ b/src/MapleFE/shared/src/ast_module.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -18,45 +18,98 @@
 
 namespace maplefe {
 
-ASTModule gModule;
-
-ASTModule::ASTModule() {
+ModuleNode::ModuleNode() : TreeNode(NK_Module), mPackage(NULL), mSrcLang(SrcLangUnknown),
+                           mIsAmbient(false) {
   mRootScope = mScopePool.NewScope(NULL);
-  mPackage = NULL;
+  mRootScope->SetTree(this);
+  this->SetScope(mRootScope);
 }
 
-ASTModule::~ASTModule() {
-  // free trees
-  std::vector<ASTTree*>::iterator it = mTrees.begin();
-  for (; it != mTrees.end(); it++) {
-    ASTTree *tree = *it;
-    if (tree)
-      delete tree;
-  }
-  mTrees.clear();
-
-  mImports.Release();
+ModuleNode::~ModuleNode() {
+  mTrees.Release();
 }
 
 // AFAIK, all languages allow only one package name if it allows.
-void ASTModule::SetPackage(PackageNode *p) {
+void ModuleNode::SetPackage(PackageNode *p) {
   MASSERT(!mPackage);
   mPackage = p;
 }
 
+void ModuleNode::SetSrcLang(SrcLang l) {
+  mSrcLang = l;
+}
+
+SrcLang ModuleNode::GetSrcLang() {
+  return mSrcLang;
+}
+
+std::string ModuleNode::GetSrcLangString() {
+  switch (mSrcLang) {
+    case SrcLangJava: return "Java";
+    case SrcLangTypeScript: return "TypeScript";
+    case SrcLangJavaScript: return "JavaScript";
+    case SrcLangC: return "C";
+    default: break;
+  }
+  return "Unknown";
+}
+
+void ModuleNode::AddTreeFront(TreeNode *tree) {
+  mTrees.PushFront(tree);
+  tree->SetParent(this);
+}
+
+// The tree could be PassNode
+void ModuleNode::AddTree(TreeNode *tree) {
+  if (tree->IsDecl()) {
+    DeclNode *decl = (DeclNode*)tree;
+    TreeNode *var = decl->GetVar();
+    if (var && var->IsPass()) {
+      PassNode *pass = (PassNode*)var;
+      for (unsigned i = 0; i < pass->GetChildrenNum(); i++) {
+        DeclNode *n = (DeclNode*)gTreePool.NewTreeNode(sizeof(DeclNode));
+        new (n) DeclNode();
+        n->SetVar(pass->GetChild(i));
+        n->SetProp(decl->GetProp());
+        AddTree(n);
+      }
+    } else {
+      mTrees.PushBack(tree);
+      tree->SetParent(this);
+    }
+  } else if (tree->IsPass()) {
+    PassNode *pass_node = (PassNode*)tree;
+    for (unsigned i = 0; i < pass_node->GetChildrenNum(); i++) {
+      TreeNode *child = pass_node->GetChild(i);
+      AddTree(child);
+    }
+  } else {
+    mTrees.PushBack(tree);
+    tree->SetParent(this);
+  }
+}
+
 // Return a new scope newly created.
 // Set the parent<->child relation between it and p.
-ASTScope* ASTModule::NewScope(ASTScope *p) {
+ASTScope* ModuleNode::NewScope(ASTScope *p) {
+  ASTScope *newscope = mScopePool.NewScope(p);
+  return newscope;
+}
+
+ASTScope* ModuleNode::NewScope(ASTScope *p, TreeNode *t) {
   ASTScope *newscope = mScopePool.NewScope(p);
+  newscope->SetTree(t);
+  t->SetScope(newscope);
   return newscope;
 }
 
-void ASTModule::Dump() {
+void ModuleNode::Dump(unsigned indent) {
   std::cout << "============= Module ===========" << std::endl;
-  std::vector<ASTTree*>::iterator tree_it = mTrees.begin();
-  for (; tree_it != mTrees.end(); tree_it++) {
-    ASTTree *tree = *tree_it;
+  for (unsigned i = 0; i < mTrees.GetNum(); i++) {
+    TreeNode *tree = GetTree(i);
+    DUMP0("== Sub Tree ==");
     tree->Dump(0);
+    DUMP_RETURN();
   }
 }
 }
diff --git a/src/MapleFE/shared/src/ast_scope.cpp b/src/MapleFE/shared/src/ast_scope.cpp
index 8f416244c0097928eb237ee76796721ccfe288fd..f1e5505be67a6b5e36140edc8200f9c4c4f62fd3 100644
--- a/src/MapleFE/shared/src/ast_scope.cpp
+++ b/src/MapleFE/shared/src/ast_scope.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -14,51 +14,69 @@
 */
 
 #include "ast_scope.h"
+#include "gen_astdump.h"
 
 namespace maplefe {
 
-ASTScope::ASTScope(ASTScope *parent) {
-  mParent = NULL;
-  mTree = NULL;
-  if (parent)
-    SetParent(parent);
-}
-
 void ASTScope::AddChild(ASTScope *s) {
   for (unsigned i = 0; i < mChildren.GetNum(); i++) {
-    ASTScope *scope = mChildren.ValueAtIndex(i);
-    if (s == scope)
+    if (s == GetChild(i)) {
       return;
+    }
   }
 
   mChildren.PushBack(s);
   s->SetParent(this);
 }
 
-// We are using name address to decide if two names are equal, since we have a
-// string pool with any two equal strings will be at the same address.
-TreeNode* ASTScope::FindDeclOf(IdentifierNode *inode) {
-  for (unsigned i = 0; i < GetDeclNum(); i++) {
-    TreeNode *tree = GetDecl(i);
-    if (tree->IsIdentifier()) {
-      IdentifierNode *id = (IdentifierNode*)tree;
-      MASSERT(id->GetType() && "Identifier has no type?");
+// This is to find the decl having the name as stridx
+// starting from local scope
+TreeNode* ASTScope::FindDeclOf(unsigned stridx, bool deep) {
+  ASTScope *scope = this;
+  while (scope) {
+    for (unsigned i = 0; i < scope->GetDeclNum(); i++) {
+      TreeNode *tree = scope->GetDecl(i);
+      if (tree->GetStrIdx() == stridx) {
+        return tree;
+      }
     }
-    if (tree->GetName() == inode->GetName())
+    for (unsigned i = 0; i < scope->GetImportedDeclNum(); i++) {
+      TreeNode *tree = scope->GetImportedDecl(i);
+      if (tree->GetStrIdx() == stridx) {
+        return tree;
+      }
+    }
+    // search parent scope if deep is set
+    scope = deep ? scope->mParent : NULL;
+  }
+  return NULL;
+}
+
+// This is to find the exported decl having the name as stridx
+TreeNode* ASTScope::FindExportedDeclOf(unsigned stridx) {
+  for (unsigned i = 0; i < GetExportedDeclNum(); i++) {
+    TreeNode *tree = GetExportedDecl(i);
+    if (tree->GetStrIdx() == stridx) {
       return tree;
+    }
   }
   return NULL;
 }
 
-// This is to find the type having the same name as 'inode'.
+// This is to find the type having the name as stridx.
 //
-// We are using name address to decide if two names are equal, since we have a
-// string pool with any two equal strings will be at the same address.
-TreeNode* ASTScope::FindTypeOf(IdentifierNode *inode) {
-  for (unsigned i = 0; i < GetTypeNum(); i++) {
-    TreeNode *tree = GetType(i);
-    if (tree->GetName() == inode->GetName())
-      return tree;
+// starting from local scope
+TreeNode* ASTScope::FindTypeOf(unsigned stridx) {
+  ASTScope *scope = this;
+  while (scope) {
+    for (unsigned i = 0; i < scope->GetTypeNum(); i++) {
+      TreeNode *tree = scope->GetType(i);
+      if (tree->GetStrIdx() == stridx) {
+        return tree;
+      }
+    }
+    // search parent scope
+    scope = scope->mParent;
   }
   return NULL;
 }
@@ -78,8 +96,8 @@ void ASTScope::TryAddDecl(TreeNode *tree) {
       mDecls.PushBack(inode);
   } else if (tree->IsVarList()) {
     VarListNode *vl = (VarListNode*)tree;
-    for (unsigned i = 0; i < vl->GetNum(); i++) {
-      IdentifierNode *inode = vl->VarAtIndex(i);
+    for (unsigned i = 0; i < vl->GetVarsNum(); i++) {
+      IdentifierNode *inode = vl->GetVarAtIndex(i);
       if (inode->GetType())
         mDecls.PushBack(inode);
     }
@@ -117,4 +135,86 @@ ASTScope* ASTScopePool::NewScope(ASTScope *parent) {
   mScopes.push_back(s);
   return s;
 }
+
+bool ASTScope::IsAncestor(ASTScope *ancestor) {
+  ASTScope *p = this;
+  while (p) {
+    if (p == ancestor) {
+      return true;
+    }
+    p = p->GetParent();
+  }
+  return false;
+}
+
+void ASTScope::Dump(unsigned indent) {
+  mTree->DumpIndentation(indent);
+  std::cout << "scope: " << AstDump::GetEnumNodeKind(mTree->GetKind()) << " " << mTree->GetName() << " " << mTree->GetNodeId() << std::endl;
+  for (unsigned i = 0; i < GetDeclNum(); i++) {
+    TreeNode *node = GetDecl(i);
+    std::string str = "";
+    switch (node->GetKind()) {
+      case NK_Identifier: str = "       var: "; break;
+      case NK_Decl:       str = "      decl: "; break;
+      case NK_Function:   str = "      func: "; break;
+      case NK_Struct:     str = "    struct: "; break;
+      case NK_Class:      str = "     class: "; break;
+      case NK_Namespace:  str = " namespace: "; break;
+    }
+    if (str.length()) {
+      node->DumpIndentation(indent);
+      std::string name = node->GetStrIdx() ? node->GetName() : "-";
+      std::cout << str << name << " " << node->GetNodeId() << std::endl;
+    }
+  }
+
+  for (unsigned i = 0; i < GetImportedDeclNum(); i++) {
+    TreeNode *node = GetImportedDecl(i);
+    std::string str = "";
+    switch (node->GetKind()) {
+      case NK_Identifier: str = "       var: - Imported "; break;
+      case NK_Decl:       str = "      decl: - Imported "; break;
+      case NK_Function:   str = "      func: - Imported "; break;
+      case NK_Struct:     str = "    struct: - Imported "; break;
+      case NK_Class:      str = "     class: - Imported "; break;
+      case NK_Namespace:  str = " namespace: - Imported "; break;
+    }
+    if (str.length()) {
+      node->DumpIndentation(indent);
+      std::string name = node->GetStrIdx() ? node->GetName() : "-";
+      std::cout << str << name << " " << node->GetNodeId() << std::endl;
+    }
+  }
+
+  for (unsigned i = 0; i < GetExportedDeclNum(); i++) {
+    TreeNode *node = GetExportedDecl(i);
+    std::string str = "";
+    switch (node->GetKind()) {
+      case NK_Identifier: str = "       var: - Exported "; break;
+      case NK_Decl:       str = "      decl: - Exported "; break;
+      case NK_Function:   str = "      func: - Exported "; break;
+      case NK_Struct:     str = "    struct: - Exported "; break;
+      case NK_Class:      str = "     class: - Exported "; break;
+      case NK_Namespace:  str = " namespace: - Exported "; break;
+    }
+    if (str.length()) {
+      node->DumpIndentation(indent);
+      std::string name = node->GetStrIdx() ? node->GetName() : "-";
+      std::cout << str << name << " " << node->GetNodeId() << std::endl;
+    }
+  }
+
+  for (unsigned i = 0; i < GetTypeNum(); i++) {
+    TreeNode *node = GetType(i);
+    node->DumpIndentation(indent);
+    std::string name = node->GetStrIdx() ? node->GetName() : "-";
+    std::cout << "      type: " << name << " " << node->GetTypeIdx() << std::endl;
+  }
+
+  for (unsigned i = 0; i < GetChildrenNum(); i++) {
+    ASTScope *scope = GetChild(i);
+    scope->Dump(indent + 2);
+  }
+}
+
 }
diff --git a/src/MapleFE/shared/src/ast_type.cpp b/src/MapleFE/shared/src/ast_type.cpp
index ac170c9028beaef569783c841bc1a9201326eb05..74ab86984068083463faea968862b181c685d6b0 100644
--- a/src/MapleFE/shared/src/ast_type.cpp
+++ b/src/MapleFE/shared/src/ast_type.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -16,8 +16,8 @@
 #include <cstring>
 
 #include "ast_type.h"
-#include "gen_type.h"   // for language specific type keyword
 #include "ruletable.h"
+#include "rule_summary.h"
 #include "ast.h"
 #include "massert.h"
 
@@ -27,15 +27,65 @@ namespace maplefe {
 //                           UserTypeNode                               //
 //////////////////////////////////////////////////////////////////////////
 
-void UserTypeNode::AddTypeArgs(TreeNode *args) {
-  if (args->IsIdentifier()) {
-    IdentifierNode *inode = (IdentifierNode*)args;
-    AddTypeArg(inode);
+void UserTypeNode::AddUnionInterType(TreeNode *args, bool front) {
+  if (args->IsIdentifier() ||
+      args->IsPrimType() ||
+      args->IsPrimArrayType() ||
+      args->IsUserType() ||
+      args->IsLiteral() ||
+      args->IsLambda() ||
+      args->IsTypeOf() ||
+      args->IsTupleType() ||
+      args->IsArrayElement() ||
+      args->IsConditionalType() ||
+      args->IsNew() ||
+      args->IsKeyOf() ||
+      args->IsImport() ||
+      args->IsField() ||
+      args->IsTemplateLiteral() ||
+      args->IsStruct()) {
+    mUnionInterTypes.PushBack(args);
+    if (front) {
+      for(unsigned i = mUnionInterTypes.GetNum() - 1; i > 0; --i)
+        mUnionInterTypes.SetElem(i, mUnionInterTypes.ValueAtIndex(i-1));
+      mUnionInterTypes.SetElem(0, args);
+    }
+    SETPARENT(args);
+  } else if (args->IsPass()) {
+    PassNode *p = (PassNode*)args;
+    for (unsigned i = 0; i < p->GetChildrenNum(); i++) {
+      TreeNode *a = p->GetChild(i);
+      AddTypeGeneric(a);
+    }
+  } else {
+    MASSERT(0 && "Unsupported tree node in UserTypeNode::AddUnionInterType()");
+  }
+}
+
+void UserTypeNode::AddTypeGeneric(TreeNode *args) {
+  if (args->IsIdentifier() ||
+      args->IsPrimType() ||
+      args->IsPrimArrayType() ||
+      args->IsUserType() ||
+      args->IsTypeParameter() ||
+      args->IsLiteral() ||
+      args->IsTypeOf() ||
+      args->IsArrayElement() ||
+      args->IsStruct() ||
+      args->IsTupleType() ||
+      args->IsLambda() ||
+      args->IsKeyOf() ||
+      args->IsField() ||
+      args->IsConditionalType() ||
+      args->IsTemplateLiteral() ||
+      args->IsInfer()) {
+    mTypeGenerics.PushBack(args);
+    SETPARENT(args);
   } else if (args->IsPass()) {
     PassNode *p = (PassNode*)args;
     for (unsigned i = 0; i < p->GetChildrenNum(); i++) {
       TreeNode *a = p->GetChild(i);
-      AddTypeArgs(a);
+      AddTypeGeneric(a);
     }
   } else {
     MASSERT(0 && "Unsupported tree node in UserTypeNode::AddTypeArgs()");
@@ -46,25 +96,60 @@ void UserTypeNode::AddTypeArgs(TreeNode *args) {
 bool UserTypeNode::TypeEquivalent(UserTypeNode *type) {
   // For now, I just check the name. The name is in the global string pool,
   // so two same names should be in the same address.
-  if (GetName() == type->GetName())
+  if (GetStrIdx() == type->GetStrIdx())
     return true;
   else
     return false;
 }
 
 void UserTypeNode::Dump(unsigned ind) {
-  mId->Dump(0);
-  unsigned size = mTypeArguments.GetNum();
+  if (mType == UT_Union)
+    DUMP0_NORETURN("union ");
+  else if (mType == UT_Inter)
+    DUMP0_NORETURN("intersect ");
+
+  if (mId)
+    mId->Dump(0);
+
+  unsigned size = mTypeGenerics.GetNum();
   if (size > 0) {
     DUMP0_NORETURN('<');
     for (unsigned i = 0; i < size; i++) {
-      IdentifierNode *inode = mTypeArguments.ValueAtIndex(i);
+      TreeNode *inode = mTypeGenerics.ValueAtIndex(i);
       inode->Dump(0);
       if (i < size - 1)
         DUMP0_NORETURN(',');
     }
     DUMP0_NORETURN('>');
   }
+
+  size = mUnionInterTypes.GetNum();
+  if (size > 0) {
+    DUMP0_NORETURN(" = ");
+    for (unsigned i = 0; i < size; i++) {
+      TreeNode *inode = mUnionInterTypes.ValueAtIndex(i);
+      inode->Dump(0);
+      if (i < size - 1) {
+        if (mType == UT_Union)
+          DUMP0_NORETURN(" | ");
+        else if (mType == UT_Inter)
+          DUMP0_NORETURN(" & ");
+      }
+    }
+  }
+
+  if (mDims) {
+    for (unsigned i = 0; i < GetDimsNum(); i++)
+      DUMP0_NORETURN("[]");
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////
+//                              ArrayTypeNode                           //
+//////////////////////////////////////////////////////////////////////////
+
+void ArrayTypeNode::Dump(unsigned ind) {
+  DUMP0_NORETURN("array-TBD");
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -80,7 +165,7 @@ void PrimArrayTypeNode::Dump(unsigned ind) {
 //////////////////////////////////////////////////////////////////////////
 
 static const char* FindPrimTypeName(TypeId id) {
-  for (unsigned i = 0; i < TY_NA; i++) {
+  for (unsigned i = 0; i < TypeKeywordTableSize; i++) {
     if (TypeKeywordTable[i].mId == id)
       return TypeKeywordTable[i].mText;
   }
@@ -88,7 +173,7 @@ static const char* FindPrimTypeName(TypeId id) {
 }
 
 static TypeId FindPrimTypeId(const char *keyword) {
-  for (unsigned i = 0; i < TY_NA; i++) {
+  for (unsigned i = 0; i < TypeKeywordTableSize; i++) {
     if (strncmp(TypeKeywordTable[i].mText, keyword, strlen(keyword)) == 0
         && strlen(keyword) == strlen(TypeKeywordTable[i].mText))
       return TypeKeywordTable[i].mId;
@@ -96,42 +181,64 @@ static TypeId FindPrimTypeId(const char *keyword) {
   return TY_NA;
 }
 
+//////////////////////////////////////////////////////////////////////////
+//                           FunctionTypeNode                           //
+//////////////////////////////////////////////////////////////////////////
+
+bool FunctionTypeNode::IsEqual(FunctionTypeNode *node) {
+  bool result = true;
+  if (node->GetParamsNum() != GetParamsNum()) {
+    result = false;
+  } else {
+    for (unsigned i = 0; i < GetParamsNum(); i++) {
+      if (node->GetParam(i) != GetParam(i)) {
+        result = false;
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+void FunctionTypeNode::Dump(unsigned ind) {
+  DUMP0_NORETURN("functiontype-TBD");
+}
+
 //////////////////////////////////////////////////////////////////////////
 //                             PrimTypeNode                             //
 //////////////////////////////////////////////////////////////////////////
 
-const char* PrimTypeNode::GetName() {
+const char* PrimTypeNode::GetTypeName() {
   const char *name = FindPrimTypeName(GetPrimType());
   return name;
 }
 
 void PrimTypeNode::Dump(unsigned indent) {
+  if (mIsUnique)
+    DUMP0_NORETURN("unique ");
+
   DumpIndentation(indent);
-  DUMP0_NORETURN(GetName());
+  DUMP0_NORETURN(GetTypeName());
 }
 
 //////////////////////////////////////////////////////////////////////////
 //                           PrimTypePool                               //
 //////////////////////////////////////////////////////////////////////////
 
-// The global Pool for 
+// The global Pool for
 PrimTypePool gPrimTypePool;
 
-PrimTypePool::PrimTypePool() {
-  // 1024 per block could be better.
-  mTreePool.SetBlockSize(1024);
-  Init();
-}
+PrimTypePool::PrimTypePool() {}
 
 PrimTypePool::~PrimTypePool() {
   mTypes.Release();
 }
 
 void PrimTypePool::Init() {
-  for (unsigned i = 0; i < TY_NA; i++) {
-    PrimTypeNode *n = (PrimTypeNode*)mTreePool.NewTreeNode(sizeof(PrimTypeNode));
+  for (unsigned i = 0; i < TypeKeywordTableSize; i++) {
+    PrimTypeNode *n = (PrimTypeNode*)gTreePool.NewTreeNode(sizeof(PrimTypeNode));
     new (n) PrimTypeNode();
-    n->SetPrimType((TypeId)i);
+    n->SetPrimType((TypeId)TypeKeywordTable[i].mId);
     mTypes.PushBack(n);
   }
 }
@@ -145,7 +252,7 @@ PrimTypeNode* PrimTypePool::FindType(const char *keyword) {
 }
 
 PrimTypeNode* PrimTypePool::FindType(TypeId id) {
-  for (unsigned i = 0; i < TY_NA; i++) {
+  for (unsigned i = 0; i < TypeKeywordTableSize; i++) {
     PrimTypeNode *type_float = mTypes.ValueAtIndex(6);
     PrimTypeNode *type = mTypes.ValueAtIndex(i);
     if (type->GetPrimType() == id)
diff --git a/src/MapleFE/shared/src/container.cpp b/src/MapleFE/shared/src/container.cpp
index ac5de846898990cc2d4ba5e58dc6485ef9a7e757..923c67715a734ca319d914a062f616c8abffbea2 100644
--- a/src/MapleFE/shared/src/container.cpp
+++ b/src/MapleFE/shared/src/container.cpp
@@ -18,6 +18,7 @@
 //////////////////////////////////////////////////////////////////////////////
 
 #include <cstdlib>
+#include <cstring>
 
 #include "container.h"
 #include "massert.h"
@@ -25,9 +26,8 @@
 namespace maplefe {
 
 char* ContainerMemPool::AddrOfIndex(unsigned index) {
-  unsigned num_in_blk = mBlockSize / mElemSize;
-  unsigned blk = index / num_in_blk;
-  unsigned index_in_blk = index % num_in_blk;
+  unsigned blk = index / mElemNumPerBlock;
+  unsigned index_in_blk = index % mElemNumPerBlock;
 
   Block *block = mBlocks;
   for (unsigned i = 0; i < blk; i++) {
@@ -37,4 +37,140 @@ char* ContainerMemPool::AddrOfIndex(unsigned index) {
   char *addr = block->addr + index_in_blk * mElemSize;
   return addr;
 }
+
+////////////////////////////////////////////////////////////////////////////////
+//                               Bit Vector
+////////////////////////////////////////////////////////////////////////////////
+
+BitVector::BitVector() : mBVSize(0) {
+  SetBlockSize(1024);
+}
+
+BitVector::BitVector(unsigned n) : mBVSize(n) {
+  SetBlockSize(1024);
+  Alloc(n);
+}
+
+void BitVector::ClearBit(unsigned idx) {
+  unsigned byte_idx = idx / 8;
+  unsigned blk_idx = byte_idx / mBlockSize;
+  Block *block = mBlocks;
+  for (unsigned i = 0; i < blk_idx; i++) {
+    block = block->next;
+    if (!block)
+      MERROR("ClearBit at unknown location.");
+  }
+
+  unsigned bit_idx = idx % 8;
+  char mask = ~(1 << bit_idx);
+
+  char *addr = block->addr + byte_idx % mBlockSize;
+  *addr = (*addr) & mask;
+}
+
+void BitVector::SetBit(unsigned idx) {
+  unsigned byte_idx = idx / 8;
+  unsigned blk_idx = byte_idx / mBlockSize;
+  Block *block = mBlocks;
+  unsigned block_num = 0;
+  for (; block && (block_num < blk_idx); block_num++) {
+    block = block->next;
+  }
+
+  // Out of memory. Need to allocate.
+  // For each block allocated, the random data need be wiped off.
+  if (!block) {
+    unsigned blocks_to_alloc = blk_idx + 1 - block_num;
+    for (unsigned i = 0; i < blocks_to_alloc; i++) {
+      char *addr = AllocBlock();
+      memset((void*)addr, 0, mBlockSize);
+    }
+
+    // get the block again
+    block = mBlocks;
+    for (unsigned i = 0; i < blk_idx; i++)
+      block = block->next;
+  }
+
+  unsigned bit_idx = idx % 8;
+  char *addr = block->addr + byte_idx % mBlockSize;
+  *addr = (*addr) | (1 << bit_idx);
+}
+
+// return true if the bit is set, or else false.
+bool BitVector::GetBit(unsigned idx) {
+  unsigned byte_idx = idx / 8;
+  unsigned blk_idx = byte_idx / mBlockSize;
+  Block *block = mBlocks;
+  unsigned block_num = 0;
+  for (; block && (block_num < blk_idx); block_num++) {
+    block = block->next;
+  }
+
+  // Out of memory. Need to allocate.
+  // For each block allocated, the random data need be wiped off.
+  if (!block) {
+    unsigned blocks_to_alloc = blk_idx + 1 - block_num;
+    for (unsigned i = 0; i < blocks_to_alloc; i++) {
+      char *addr = AllocBlock();
+      memset((void*)addr, 0, mBlockSize);
+    }
+
+    // get the block again
+    block = mBlocks;
+    for (unsigned i = 0; i < blk_idx; i++)
+      block = block->next;
+  }
+
+  unsigned bit_idx = idx % 8;
+  char *addr = block->addr + byte_idx % mBlockSize;
+  unsigned data = (*addr) & (1 << bit_idx);
+  if (data != 0)
+    return true;
+  else
+    return false;
+}
+
+// bit wise EQUAL
+bool BitVector::Equal(BitVector *bv) {
+  char *addr = mBlocks->addr;
+  char *bvaddr = bv->mBlocks->addr;
+  if (mBVSize != bv->mBVSize) {
+    return false;
+  }
+
+  MASSERT(mBVSize < 1024 && "NYI: BitVector length > 1024");
+
+  for (int i = 0; i < (mBVSize + 3)/4; i++) {
+    if (*(unsigned *)(addr + i*4) != *(unsigned*)(bvaddr + i*4)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// bit wise AND
+void BitVector::And(BitVector *bv) {
+  char *addr = mBlocks->addr;
+  char *bvaddr = bv->mBlocks->addr;
+  MASSERT(mBVSize == bv->mBVSize && "BitVector length not equal");
+  MASSERT(mBVSize < 1024 && "NYI: BitVector length > 1024");
+
+  for (int i = 0; i < (mBVSize + 3)/4; i++) {
+    *(unsigned *)(addr + i*4) &= *(unsigned*)(bvaddr + i*4);
+  }
+}
+
+// bit wise OR
+void BitVector::Or(BitVector *bv) {
+  char *addr = mBlocks->addr;
+  char *bvaddr = bv->mBlocks->addr;
+  MASSERT(mBVSize == bv->mBVSize && "BitVector length not equal");
+  MASSERT(mBVSize < 1024 && "NYI: BitVector length > 1024");
+
+  for (int i = 0; i < (mBVSize + 3)/4; i++) {
+    *(unsigned *)(addr + i*4) |= *(unsigned*)(bvaddr + i*4);
+  }
+}
 }
diff --git a/src/MapleFE/shared/src/fileread.cpp b/src/MapleFE/shared/src/fileread.cpp
index bb038660434317ec91a529b66ed83924dccf15ea..491d6684b7df5a80b029332bf9af64d595659e9b 100644
--- a/src/MapleFE/shared/src/fileread.cpp
+++ b/src/MapleFE/shared/src/fileread.cpp
@@ -131,7 +131,7 @@ bool FileReader::SkipTRAComment(){
       Assert(0, "No ending */ of traditional comment)");
     }
   }
-  return false; 
+  return false;
 }
 
 // Skip the next separator designated by 'c'.
@@ -173,7 +173,7 @@ bool FileReader::ReadLineNonEmpty(){
     if (mCurLine.size() > 0)
       return true;
   }
-  return false; 
+  return false;
 }
 
 // Read line from the file, and return the number of read chars.
diff --git a/src/MapleFE/shared/src/lexer.cpp b/src/MapleFE/shared/src/lexer.cpp
index 87f83e3689d3e39c78954aef24ade144ddad2437..694f86a8edafedea9ff0584a140a9b0e25777951 100644
--- a/src/MapleFE/shared/src/lexer.cpp
+++ b/src/MapleFE/shared/src/lexer.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -17,16 +17,12 @@
 #include "massert.h"
 #include "lexer.h"
 #include "token.h"
-#include "common_header_autogen.h"
 #include "ruletable_util.h"
-#include "gen_summary.h"
-#include "gen_token.h"
+#include "rule_summary.h"
 #include "massert.h"
 #include <climits>
 #include <cstdlib>
 
-#include "ruletable_util.h"
-
 namespace maplefe {
 
 #define MAX_LINE_SIZE 4096
@@ -44,18 +40,38 @@ int Lexer::ReadALine() {
   }
 
   current_line_size = getline(&line, &linebuf_size, srcfile);
+  _linenum++;
+
   if (current_line_size <= 0) {  // EOF
     fclose(srcfile);
     line[0] = '\0';
     endoffile = true;
   } else {
-    if (line[current_line_size - 1] == '\n') {
+    // There could be \n\r or \r\n
+    // Handle the last escape
+    if ((line[current_line_size - 1] == '\n') ||
+        (line[current_line_size - 1] == '\r')) {
+      line[current_line_size - 1] = '\0';
+      current_line_size--;
+    }
+    // Handle the second last escape
+    if ((line[current_line_size - 1] == '\n') ||
+        (line[current_line_size - 1] == '\r')) {
       line[current_line_size - 1] = '\0';
       current_line_size--;
     }
   }
 
   curidx = 0;
+
+  // There are some special UTF-8 encoding in the beginning of some file format, like BOM
+  // with \357\273\277. We skip this mark.
+  if ( *(line+curidx) == -17 &&
+       *(line+curidx+1) == -69 &&
+       *(line+curidx+2) == -65) {
+    curidx += 3;
+  }
+
   return current_line_size;
 }
 
@@ -73,6 +89,8 @@ Lexer::Lexer()
     endoffile(false),
     mPredefinedTokenNum(0),
     mTrace(false),
+    mLineMode(false),
+    _total_linenum(0),
     _linenum(0) {
       seencomments.clear();
       mCheckSeparator = true;
@@ -81,12 +99,21 @@ Lexer::Lexer()
 }
 
 void Lexer::PrepareForFile(const std::string filename) {
-  // open file
+  // Find the total line number in the file
   srcfile = fopen(filename.c_str(), "r");
   if (!srcfile) {
     std::cerr << "cannot open file " << filename << std::endl;
     exit(1);
   }
+  while (getline(&line, &linebuf_size, srcfile) > 0) {
+    _total_linenum++;
+  }
+
+  fclose(srcfile);
+  line[0] = '\0';
+
+  // open file
+  srcfile = fopen(filename.c_str(), "r");
 
   // allocate line buffer.
   linebuf_size = (size_t)MAX_LINE_SIZE;
@@ -96,114 +123,202 @@ void Lexer::PrepareForFile(const std::string filename) {
   }
 
   // try to read the first line
-  if (ReadALine() < 0) {
-    _linenum = 0;
-  } else {
-    _linenum = 1;
-  }
+  ReadALine();
 }
 
-///////////////////////////////////////////////////////////////////////////
-//                Utilities for finding system tokens
-// Remember the order of tokens are operators, separators, and keywords.
-///////////////////////////////////////////////////////////////////////////
+void Lexer::PrepareForString(const char *str) {
+  current_line_size = strlen(str);
+  strncpy(line, str, current_line_size);
+  line[current_line_size] = '\0';
+  curidx = 0;
+  _linenum = 1;
+  endoffile = false;
+}
 
-Token* Lexer::FindOperatorToken(OprId id) {
-  Token *token = NULL;
-  bool found = false;
-  for (unsigned i = 0; i < gOperatorTokensNum; i++) {
-    token = &gSystemTokens[i];
-    MASSERT(token->mTkType == TT_OP);
-    if (token->GetOprId() == id) {
-      found = true;
-      break;
+/////////////////////////////////////////////////////////////////////////////
+// Both ClearLeadingNewLine() and AddEndingNewLine() will later be implemented
+// as language specific, and they will be overriding functions.
+/////////////////////////////////////////////////////////////////////////////
+
+//1. mLexer could cross the line if it's a template literal in Javascript.
+//2. During some language lexing, like Typescript template literal, we
+//   may add \n in a place holder (the line to be lexed). This \n should
+//   be removed when lexing the expressions in place holder.
+void Lexer::ClearLeadingNewLine() {
+  while (line[curidx] == '\n') {
+    curidx ++;
+    if (curidx == current_line_size) {
+      ReadALine();
+      if (EndOfFile())
+        return;
     }
   }
-  MASSERT(found && token);
-  return token;
 }
 
-Token* Lexer::FindSeparatorToken(SepId id) {
-  Token *token = NULL;
-  bool found = false;
-  for (unsigned i = gOperatorTokensNum; i < gOperatorTokensNum + gSeparatorTokensNum; i++) {
-    token = &gSystemTokens[i];
-    MASSERT(token->mTkType == TT_SP);
-    if (token->GetSepId() == id) {
-      found = true;
-      break;
+// We are starting a new token, if current char is ' or ",
+// it's the beginning of a string literal. We traverse until the end of the
+// current line, if there is no ending ' or ", it means the string goes to next
+// line and we add an ending \n, and concatenate the next line.
+void Lexer::AddEndingNewLine() {
+  bool single_quote = false;
+  bool double_quote = false;
+
+  if (line[curidx] == '\'')
+    single_quote = true;
+  if (line[curidx] == '\"')
+    double_quote = true;
+
+  if (!single_quote && !double_quote)
+    return;
+
+  unsigned working_idx = curidx + 1;
+
+  // If we are in escape
+  bool in_escape = false;
+
+  // Reading a raw data, meaning we get the data through getline() directly.
+  // If we do ReadALine(), it's not a raw data because the ending \n or \r are removed.
+  bool raw_data = false;
+
+  while(1) {
+
+    // We reach the end of the line, and not done yet.
+    // So read in a new line and add \n to the end if it's Not raw data.
+    if (working_idx == current_line_size) {
+      // Add ending NewLine
+      if (!raw_data) {
+        line[working_idx] = '\n';
+        current_line_size++;
+        working_idx++;
+      }
+
+      // Read new line.
+      char *new_buf = NULL;
+      size_t new_buf_size = 0;
+      ssize_t new_line_size = getline(&new_buf, &new_buf_size, srcfile);
+      if (new_line_size <= 0) {  // EOF
+        fclose(srcfile);
+        MERROR("EOF Error reading multi-line string literal.");
+      } else {
+        // add new_buf to line
+        strncpy(line + working_idx, new_buf, new_line_size);
+        current_line_size += new_line_size;
+      }
+
+      free(new_buf);
+
+      in_escape = false;
+      raw_data = true;
     }
-  }
-  MASSERT(found && token);
-  return token;
-}
 
-// The caller of this function makes sure 'key' is already in the
-// string pool of Lexer.
-Token* Lexer::FindKeywordToken(const char *key) {
-  Token *token = NULL;
-  bool found = false;
-  for (unsigned i = gOperatorTokensNum + gSeparatorTokensNum;
-       i < gOperatorTokensNum + gSeparatorTokensNum + gKeywordTokensNum;
-       i++) {
-    token = &gSystemTokens[i];
-    MASSERT(token->mTkType == TT_KW);
-    if (strlen(key) == strlen(token->GetName()) &&
-        !strncmp(key, token->GetName(), strlen(key))) {
-      found = true;
-      break;
+    // Handle escape
+    if (line[working_idx] == '\\') {
+      if (!in_escape) {
+        in_escape = true;
+        working_idx++;
+        continue;
+      }
     }
-  }
-  MASSERT(found && token);
-  return token;
-}
 
-// CommentToken is the last predefined token
-Token* Lexer::FindCommentToken() {
-  Token *token = &gSystemTokens[gSystemTokensNum - 1];
-  MASSERT((token->mTkType == TT_CM) && "Last system token is not a comment token.");
-  return token;
+    // return if string literal end.
+    if (!in_escape &&
+        ( (line[working_idx] == '\'' && single_quote) ||
+          (line[working_idx] == '\"' && double_quote))) {
+      if (raw_data) {
+        // Need remove the ending \n or \r for the regular token reading.
+        if ((line[current_line_size - 1] == '\n') ||
+            (line[current_line_size - 1] == '\r')) {
+          line[current_line_size - 1] = '\0';
+          current_line_size--;
+        }
+        // Handle the second last escape
+        if ((line[current_line_size - 1] == '\n') ||
+            (line[current_line_size - 1] == '\r')) {
+          line[current_line_size - 1] = '\0';
+          current_line_size--;
+        }
+      }
+
+      // Finally We are done!
+      return;
+    }
+
+    in_escape = false;
+    working_idx++;
+  }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 //
 /////////////////////////////////////////////////////////////////////////////
 
-// Read a token until end of file.
-// If no remaining tokens in current line, we move to the next line.
 Token* Lexer::LexToken(void) {
+  ClearLeadingNewLine();
+  AddEndingNewLine();
+  if (EndOfFile())
+    return NULL;
+
   return LexTokenNoNewLine();
 }
 
 // Read a token until end of line.
 // Return NULL if no token read.
 Token* Lexer::LexTokenNoNewLine(void) {
+  unsigned old_curidx = curidx;
   bool is_comment = GetComment();
   if (is_comment) {
-    Token *t = FindCommentToken();
+    Token *sys_t = FindCommentToken();
+    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token));
+    *t = *sys_t;
+    t->mLineNum = _linenum;
+    t->mColNum = old_curidx;
     if (mTrace)
       t->Dump();
     return t;
   }
 
-  // We try to get system tokens in the order of operator, separtor, and keyword
-  // This is the same as token_gen.cpp in autogen. There is a reason behind this.
-  // Some languages could have one synatx belonging to both separator and operators.
-  // eg., ':' in Java 8, it's both a separator colon and operator select.
-  // So the order here must be consistent with autogen where it decides ':' a colon or
-  // select in a rule.
-
   OprId opr = GetOperator();
   if (opr != OPR_NA) {
-    Token *t = FindOperatorToken(opr);
+    Token *sys_t = FindOperatorToken(opr);
+    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token));
+    *t = *sys_t;
+    t->mLineNum = _linenum;
+    t->mColNum = old_curidx;
     if (mTrace)
       t->Dump();
     return t;
   }
 
+  // There is a corner case: .2
+  // The dot is lexed as separator, and 2 is an integer. But actually it's a decimal.
   SepId sep = GetSeparator();
+  unsigned new_curidx = curidx;
+
   if (sep != SEP_NA) {
-    Token *t = FindSeparatorToken(sep);
+    if (sep == SEP_Dot) {
+      // restore curidx
+      curidx = old_curidx;
+      // try decimal literal
+      LitData ld = GetLiteral();
+      if (ld.mType != LT_NA) {
+        MASSERT(ld.mType == LT_FPLiteral || ld.mType == LT_DoubleLiteral);
+        Token *t = (Token*)mTokenPool.NewToken(sizeof(Token));
+        t->mLineNum = _linenum;
+        t->mColNum = old_curidx;
+        t->SetLiteral(ld);
+        if (mTrace)
+          t->Dump();
+        return t;
+      } else {
+        curidx = new_curidx;
+      }
+    }
+
+    Token *sys_t = FindSeparatorToken(sep);
+    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token));
+    *t = *sys_t;
+    t->mLineNum = _linenum;
+    t->mColNum = old_curidx;
     if (mTrace)
       t->Dump();
     return t;
@@ -211,7 +326,11 @@ Token* Lexer::LexTokenNoNewLine(void) {
 
   const char *keyword = GetKeyword();
   if (keyword != NULL) {
-    Token *t = FindKeywordToken(keyword);
+    Token *sys_t = FindKeywordToken(keyword);
+    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token));
+    *t = *sys_t;
+    t->mLineNum = _linenum;
+    t->mColNum = old_curidx;
     if (mTrace)
       t->Dump();
     return t;
@@ -219,7 +338,9 @@ Token* Lexer::LexTokenNoNewLine(void) {
 
   LitData ld = GetLiteral();
   if (ld.mType != LT_NA) {
-    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token)); 
+    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token));
+    t->mLineNum = _linenum;
+    t->mColNum = old_curidx;
     t->SetLiteral(ld);
     if (mTrace)
       t->Dump();
@@ -228,8 +349,21 @@ Token* Lexer::LexTokenNoNewLine(void) {
 
   const char *identifier = GetIdentifier();
   if (identifier != NULL) {
-    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token)); 
+    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token));
     t->SetIdentifier(identifier);
+    t->mLineNum = _linenum;
+    t->mColNum = old_curidx;
+    if (mTrace)
+      t->Dump();
+    return t;
+  }
+
+  TempLitData* tldata = GetTempLit();
+  if (tldata != NULL) {
+    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token));
+    t->mLineNum = _linenum;
+    t->mColNum = old_curidx;
+    t->SetTempLit(tldata);
     if (mTrace)
       t->Dump();
     return t;
@@ -238,6 +372,98 @@ Token* Lexer::LexTokenNoNewLine(void) {
   return NULL;
 }
 
+// We only look for the reg expr ending with / and a few flags like 'g'.
+// Flags include: d, g, i, m, s, u, y.
+// Anything else finishes the flag.
+//
+// The content in the reg expr could be any character, we just allow
+// all char excluding /.
+//
+// [NOTE] This function will later be implemented as an overriden function
+//        of a child class of Lexer. Each lang will have its own
+//        implementation of this function.
+Token* Lexer::FindRegExprToken() {
+
+  // for a regular expr, /a\b/g
+  // curidx is pointing to 'a' right now.
+  unsigned old_cur_idx = curidx;
+  unsigned work_idx = curidx;
+  unsigned expr_beg_idx = curidx; // the first char of reg expr.
+  unsigned expr_length = 0;
+  unsigned flag_beg_idx = 0; // the first char of flags.
+  unsigned flag_length = 0;  // the number of char of flags.
+
+  bool on_flags = false;
+
+  // In Typescript, [ ] includes characters and the escape inside
+  // is defferent than outside. / is considered non-escape.
+  bool on_bracket = false;   //
+
+  while (work_idx < current_line_size) {
+    if (line[work_idx] == '[') {
+      on_bracket = true;
+      expr_length++;
+    } else if (on_bracket && line[work_idx] == ']') {
+      on_bracket = false;
+      expr_length++;
+    } else if (line[work_idx] == '/') {
+      if (on_bracket) {
+        expr_length++;
+      } else {
+        flag_beg_idx = work_idx + 1;
+        on_flags = true;
+      }
+    } else if (line[work_idx] == '\\') {
+      // An escape.
+      expr_length += 2;
+      work_idx += 2;
+      continue;
+    } else if (on_flags) {
+      if (line[work_idx] == 'd' ||
+          line[work_idx] == 'g' ||
+          line[work_idx] == 'i' ||
+          line[work_idx] == 'm' ||
+          line[work_idx] == 's' ||
+          line[work_idx] == 'u' ||
+          line[work_idx] == 'y')
+        flag_length++;
+      else
+        break;
+    } else {
+      expr_length++;
+    }
+    work_idx++;
+  }
+
+  if (expr_length > 0) {
+    // set curidx
+    curidx = work_idx;
+
+    const char *addr_expr = NULL;
+    std::string s(line + expr_beg_idx, expr_length);
+    addr_expr = gStringPool.FindString(s);
+
+    const char *addr_flag = NULL;
+    if (flag_length > 0) {
+      std::string sf(line + flag_beg_idx, flag_length);
+      addr_flag = gStringPool.FindString(sf);
+    }
+
+    RegExprData reg = {addr_expr, addr_flag};
+
+    Token *t = (Token*)mTokenPool.NewToken(sizeof(Token));
+    t->SetRegExpr(reg);
+    if (mTrace) {
+      std::cout << "Find a reg expr: ";
+      t->Dump();
+    }
+    return t;
+
+  } else {
+    return NULL;
+  }
+}
+
 // Returen the separator ID, if it's. Or SEP_NA.
 SepId Lexer::GetSeparator() {
   return TraverseSepTable();
@@ -310,14 +536,24 @@ LitData Lexer::GetLiteral() {
 //      This is the end of line
 //  (2) /* .. */
 //      This is the traditional comments
+//  (3) #!
+//      This is the common Shebang. We takes it as a comment.
 //
 // Return true if a comment is read. The contents are ignore.
 bool Lexer::GetComment() {
+  if (FindTripleSlash())
+    return false;
+
   if (line[curidx] == '/' && line[curidx+1] == '/') {
     curidx = current_line_size;
     return true;
   }
 
+  if (line[curidx] == '#' && line[curidx+1] == '!') {
+    curidx = current_line_size;
+    return true;
+  }
+
   // Handle comments in /* */
   // If there is a /* without ending */, the rest of code until the end of the current
   // source file will be treated as comment.
@@ -333,7 +569,6 @@ bool Lexer::GetComment() {
           len = ReadALine();
         if (len < 0)
           return true;
-        _linenum++;  // a new line read.
       }
       if ((line[curidx] == '*' && line[curidx+1] == '/')) {
         get_ending = true;
@@ -414,14 +649,23 @@ bool Lexer::TraverseTableData(TableData *data) {
 
   case DT_String: {
     if( !strncmp(line + curidx, data->mData.mString, strlen(data->mData.mString))) {
+      bool special_need_check = false;
+      if (!strncmp(data->mData.mString, "false", 5) && (strlen(data->mData.mString) == 5))
+        special_need_check = true;
+      if (!strncmp(data->mData.mString, "true", 4) && (strlen(data->mData.mString) == 4))
+        special_need_check = true;
       // Need to make sure the following text is a separator
       curidx += strlen(data->mData.mString);
-      if (mCheckSeparator && (TraverseSepTable() != SEP_NA) && (TraverseOprTable() != OPR_NA)) {
-        // TraverseSepTable() moves 'curidx', need restore it
-        curidx = old_pos + strlen(data->mData.mString);
-        // Put into gStringPool
-        gStringPool.FindString(data->mData.mString);
-        found = true;
+      if (mCheckSeparator || special_need_check) {
+        if ((TraverseSepTable() != SEP_NA) ||
+           (TraverseOprTable() != OPR_NA) ||
+           EndOfLine()) {
+          // TraverseSepTable() moves 'curidx', need restore it
+          curidx = old_pos + strlen(data->mData.mString);
+          // Put into gStringPool
+          gStringPool.FindString(data->mData.mString);
+          found = true;
+        }
       } else {
         found = true;
       }
@@ -472,7 +716,7 @@ bool Lexer::MatchToken(Token *token) {
   case TT_OP: {
     // Pick the longest matching operator.
     unsigned longest = 0;
-    for (unsigned i = 0; i < OPR_NA; i++) {
+    for (unsigned i = 0; i < OprTableSize; i++) {
       OprTableEntry e = OprTable[i];
       if ((e.mId == token->GetOprId()) &&
           !strncmp(line + curidx, e.mText, strlen(e.mText))) {
@@ -490,7 +734,7 @@ bool Lexer::MatchToken(Token *token) {
   case TT_SP: {
     // Pick the longest matching separator.
     unsigned longest = 0;
-    for (unsigned i = 0; i < SEP_NA; i++) {
+    for (unsigned i = 0; i < SepTableSize; i++) {
       SepTableEntry e = SepTable[i];
       if ((e.mId == token->GetSepId()) &&
           !strncmp(line + curidx, e.mText, strlen(e.mText))) {
@@ -656,11 +900,35 @@ bool Lexer::TraverseSecondTry(const RuleTable *rule_table) {
 
 bool Lexer::Traverse(const RuleTable *rule_table) {
 
+  if (rule_table == &TblUTF8) {
+    char c = *(line + curidx);
+    unsigned i = (unsigned)c;
+    if(i >= 0x80) {
+      curidx += 1;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
   // CHAR, DIGIT are reserved rules. It should NOT be changed. We can
   // expediate the lexing.
   if (rule_table == &TblCHAR) {
     char c = *(line + curidx);
-    if( (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
+    if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
+      curidx += 1;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  //
+  // [NOTE] Since there is no way to describe special char in .spec files, we decided
+  //        to handle here.
+  if (rule_table == &TblIRREGULAR_CHAR) {
+    char c = *(line + curidx);
+    if(c == '\n' || c == '\\' || (unsigned)c == 127) {
       curidx += 1;
       return true;
     } else {
@@ -721,7 +989,7 @@ bool Lexer::Traverse(const RuleTable *rule_table) {
     }
 
     curidx = new_pos;
-    matched = found; 
+    matched = found;
     break;
   }
 
@@ -822,7 +1090,7 @@ const char* Lexer::TraverseKeywordTable() {
   if (addr) {
     unsigned saved_curidx = curidx;
 
-    // It's a keyword only if the following is a separator
+    // It's a keyword if the following is a separator
     // End of current line is a separator too.
     curidx += len;
     if ((current_line_size == curidx) || (TraverseSepTable() != SEP_NA)) {
@@ -830,10 +1098,24 @@ const char* Lexer::TraverseKeywordTable() {
       curidx = saved_curidx + len;
       addr = gStringPool.FindString(addr);
       return addr;
-    } else {
-      // failed, restore curidx
-      curidx = saved_curidx;
     }
+
+    // It's a keyword if the following is a operator
+    curidx = saved_curidx + len;
+    if ((TraverseOprTable() != OPR_NA)) {
+      curidx = saved_curidx + len;
+      addr = gStringPool.FindString(addr);
+      return addr;
+    }
+
+    curidx = saved_curidx + len;
+    if (CharIsSeparator(line[curidx])) {
+      addr = gStringPool.FindString(addr);
+      return addr;
+    }
+
+    // failed, restore curidx
+    curidx = saved_curidx;
   }
   return NULL;
 }
diff --git a/src/MapleFE/shared/src/mempool.cpp b/src/MapleFE/shared/src/mempool.cpp
index 7636364d10a9216ca7c0fe93c821b89fda42b8c7..9de4915a7dbefd2de3ac881863ffec0461021b2d 100644
--- a/src/MapleFE/shared/src/mempool.cpp
+++ b/src/MapleFE/shared/src/mempool.cpp
@@ -23,7 +23,7 @@
 //////////////////////////////////////////////////////////////////////////////
 
 #include <cstdlib>
-
+#include <cstring>
 
 #include "mempool.h"
 #include "massert.h"
@@ -129,8 +129,7 @@ void MemPool::Release(unsigned num) {
     MERROR("Release of num bytes failed.");
 }
 
-// Removes all data in the memory pool. Reset everything to the beginning
-// of the pool. But we keep the memory.
+// free all blocks in the memory pool. But we keep the memory.
 void MemPool::Clear() {
   mCurrBlock = mBlocks;
   Block *temp_block = mCurrBlock;
@@ -139,5 +138,15 @@ void MemPool::Clear() {
     temp_block = temp_block->next;
   }
 }
+
+// Wipe off all data. Keep the blocks.
+void MemPool::WipeOff(int c) {
+  Block *temp_block = mBlocks;
+  while(temp_block) {
+    memset((void*)temp_block->addr, c, mBlockSize);
+    temp_block = temp_block->next;
+  }
+}
+
 }
 
diff --git a/src/MapleFE/shared/src/parser.cpp b/src/MapleFE/shared/src/parser.cpp
index 6914855dca076c9bb02dc1c48fffcc9021405fef..a3f8139a95310f5d692004b8e687b0ca5c6bbca6 100644
--- a/src/MapleFE/shared/src/parser.cpp
+++ b/src/MapleFE/shared/src/parser.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -21,16 +21,19 @@
 #include "parser.h"
 #include "massert.h"
 #include "token.h"
-#include "common_header_autogen.h"
 #include "ruletable_util.h"
-#include "gen_summary.h"
-#include "gen_token.h"
+#include "rule_summary.h"
 #include "ast.h"
 #include "ast_builder.h"
+#include "ast_mempool.h"
+#include "ast_type.h"
 #include "parser_rec.h"
+#include "ast_fixup.h"
 
 namespace maplefe {
 
+SmallVector<TemplateLiteralNode*> gTemplateLiteralNodes;
+
 //////////////////////////////////////////////////////////////////////////////////
 //                   Top Issues in Parsing System
 //
@@ -182,15 +185,44 @@ namespace maplefe {
 //////////////////////////////////////////////////////////////////////////////////
 
 Parser::Parser(const char *name) : filename(name) {
-  mLexer = new Lexer();
+  mLexer = CreateLexer();
   const std::string file(name);
 
-  gModule.SetFileName(name);
+  mASTModule = new (gTreePool.NewTreeNode(sizeof(ModuleNode))) ModuleNode();
+  mASTModule->SetFilename(name);
+  mASTBuilder = new ASTBuilder(mASTModule);
+  gPrimTypePool.Init();
+
+  mAppealNodePool.SetBlockSize(16*4096);
+
+  // get source language type
+  std::string::size_type lastDot = file.find_last_of('.');
+  if (lastDot == std::string::npos) {
+    std::cout << "used improper source file" << std::endl;
+    return;
+  }
+  std::string fileExt = file.substr(lastDot);
+  if (fileExt.compare(".java") == 0) {
+    mASTModule->mSrcLang = SrcLangJava;
+  } else if (fileExt.compare(".js") == 0) {
+    mASTModule->mSrcLang = SrcLangJavaScript;
+  } else if (fileExt.compare(".ts") == 0) {
+    mASTModule->mSrcLang = SrcLangTypeScript;
+  } else if (fileExt.compare(".c") == 0) {
+    mASTModule->mSrcLang = SrcLangC;
+  } else {
+    mASTModule->mSrcLang = SrcLangUnknown;
+  }
+
   mLexer->PrepareForFile(file);
   mCurToken = 0;
   mPending = 0;
   mEndOfFile = false;
 
+  mNormalModeRoot = NULL;
+  mLineModeRoot = NULL;
+  mLineMode = false;
+
   mTraceTable = false;
   mTraceLeftRec = false;
   mTraceAppeal = false;
@@ -220,33 +252,97 @@ void Parser::Dump() {
 
 void Parser::ClearFailed() {
   for (unsigned i = 0; i < RuleTableNum; i++)
-     gFailed[i].clear();
+     gFailed[i].ClearAll();
 }
 
 // Add one fail case for the table
 void Parser::AddFailed(RuleTable *table, unsigned token) {
-  //std::cout << " push " << mCurToken << " from " << table;
-  gFailed[table->mIndex].push_back(token);
+  gFailed[table->mIndex].SetBit(token);
 }
 
 // Remove one fail case for the table
 void Parser::ResetFailed(RuleTable *table, unsigned token) {
-  std::vector<unsigned>::iterator it = gFailed[table->mIndex].begin();;
-  for (; it != gFailed[table->mIndex].end(); it++) {
-    if (*it == token)
-      break;
-  }
-
-  if (it != gFailed[table->mIndex].end())
-    gFailed[table->mIndex].erase(it);
+  gFailed[table->mIndex].ClearBit(token);
 }
 
 bool Parser::WasFailed(RuleTable *table, unsigned token) {
-  std::vector<unsigned>::iterator it = gFailed[table->mIndex].begin();
-  for (; it != gFailed[table->mIndex].end(); it++) {
-    if (*it == token)
-      return true;
+  return gFailed[table->mIndex].GetBit(token);
+}
+
+// return true if t can be merged with previous tokens.
+// This happens when "-3" is lexed as operator Sub and literal 3.
+// For Lexer' stance, this is the right thing to do. However, we do
+// need literal -3.
+bool Parser::TokenMerge(Token *t) {
+  if (!t->IsLiteral())
+    return false;
+  unsigned size = mActiveTokens.GetNum();
+  if (size < 2)
+    return false;
+
+  // We take care of a few scenarios.
+  //   = -1   <-- sep is an assignment operator
+  //   [-1    <-- sep is a separtor
+  //
+  // Here is also another ugly case in Typescript.
+  //  keyword -1
+  // such as: x extends -1
+  // In normal sense, if it's a keyword we can merge tokens.
+  // However, in TS keyword can also be an identifier which means
+  // keyword - 1 could be an expression.
+  // In this case, we further look at one more token ahead, so if it's
+  //   identifier keyword -1
+  // then we know keyword is not used an identifier and we can merge tokens.
+
+  Token *sep = mActiveTokens.ValueAtIndex(size - 2);
+  bool is_sep = false;
+  if (sep->IsSeparator() &&
+     (sep->GetSepId() != SEP_Rparen) &&
+     (sep->GetSepId() != SEP_Rbrack))
+    is_sep = true;
+  if (sep->IsOperator() &&
+        (sep->GetOprId() == OPR_Assign ||
+         sep->GetOprId() == OPR_Bor))
+    is_sep = true;
+
+  if (sep->IsKeyword() && mActiveTokens.GetNum() >= 3) {
+    Token *idn = mActiveTokens.ValueAtIndex(size - 3);
+    if (idn->IsIdentifier())
+      is_sep = true;
+  }
+
+  if (!is_sep)
+    return false;
+
+  Token *opr = mActiveTokens.ValueAtIndex(size - 1);
+  if (!opr->IsOperator())
+    return false;
+
+  if ((opr->GetOprId() != OPR_Sub) && (opr->GetOprId() != OPR_Add))
+    return false;
+
+  LitData data = t->GetLitData();
+  if ((data.mType != LT_IntegerLiteral) &&
+      (data.mType != LT_FPLiteral) &&
+      (data.mType != LT_DoubleLiteral))
+    return false;
+
+  if (opr->GetOprId() == OPR_Sub) {
+    if ((data.mType == LT_IntegerLiteral)) {
+      data.mData.mInt = (-1) * data.mData.mInt;
+    } else if (data.mType == LT_FPLiteral) {
+      data.mData.mFloat = (-1) * data.mData.mFloat;
+    } else if (data.mType == LT_DoubleLiteral) {
+      data.mData.mDouble = (-1) * data.mData.mDouble;
+    }
+    t->SetLiteral(data);
+    mActiveTokens.SetElem(size - 1, t);
+    return true;
+  } else if (opr->GetOprId() == OPR_Add) {
+    mActiveTokens.SetElem(size - 1, t);
+    return true;
   }
+
   return false;
 }
 
@@ -257,12 +353,15 @@ unsigned Parser::LexOneLine() {
   unsigned token_num = 0;
   Token *t = NULL;
 
+  Token *last_token = NULL;
+  bool line_begin = true;
+
   // Check if there are already pending tokens.
   if (mCurToken < mActiveTokens.GetNum())
     return mActiveTokens.GetNum() - mCurToken;
 
   while (!token_num) {
-    // read untile end of line
+    // read until end of line
     while (!mLexer->EndOfLine() && !mLexer->EndOfFile()) {
       t = mLexer->LexToken();
       if (t) {
@@ -271,9 +370,33 @@ unsigned Parser::LexOneLine() {
           if (t->IsWhiteSpace())
             is_whitespace = true;
         }
-        // Put into the token storage, as Pending tokens.
-        if (!is_whitespace && !t->IsComment()) {
+        bool is_tab = false;
+        if (t->IsSeparator()) {
+          if (t->IsTab())
+            is_tab = true;
+        }
+        // Put into the token storage
+        if (!is_whitespace && !is_tab && !t->IsComment()) {
+          // 1. if need to merge
+          if (TokenMerge(t))
+            continue;
+
+          // 2. if need split tokens
+          if (TokenSplit(t))
+            continue;
+
+          // 3. handle regular expression
+          t = GetRegExpr(t);
+
+          if (line_begin) {
+            t->mLineBegin = true;
+            line_begin = false;
+            if (mLexer->GetTrace())
+              DUMP0("Set as Line First.");
+          }
+
           mActiveTokens.PushBack(t);
+          last_token = t;
           token_num++;
         }
       } else {
@@ -282,7 +405,7 @@ unsigned Parser::LexOneLine() {
       }
     }
     // Read in the next line.
-    if (!token_num) {
+    if (!token_num && !mLineMode) {
       if(!mLexer->EndOfFile())
         mLexer->ReadALine();
       else
@@ -290,6 +413,13 @@ unsigned Parser::LexOneLine() {
     }
   }
 
+  // We are done with a meaningful line
+  if (token_num) {
+    last_token->mLineEnd = true;
+    if (mLexer->GetTrace())
+      DUMP0("Set as Line End.");
+  }
+
   return token_num;
 }
 
@@ -299,6 +429,11 @@ unsigned Parser::LexOneLine() {
 bool Parser::MoveCurToken() {
   mCurToken++;
   if (mCurToken == mActiveTokens.GetNum()) {
+    // In line mode, we won't read new line any more.
+    if (mLineMode) {
+      mEndOfFile = true;
+      return true;
+    }
     unsigned num = LexOneLine();
     if (!num) {
       mEndOfFile = true;
@@ -314,29 +449,87 @@ Token* Parser::GetActiveToken(unsigned i) {
   return mActiveTokens.ValueAtIndex(i);
 }
 
+// insert token at position idx.
+void Parser::InsertToken(unsigned idx, Token *token) {
+  if (idx >= mActiveTokens.GetNum())
+    MASSERT(0 && "mActiveTokens OutOfBound");
+  // enlarge the size by 1.
+  mActiveTokens.PushBack(NULL);
+  // Copy each of them forwards.
+  unsigned i = mActiveTokens.GetNum() - 2;
+  for (; i >= idx; i--) {
+    Token *move_t = mActiveTokens.ValueAtIndex(i);
+    mActiveTokens.SetElem(i + 1, move_t);
+  }
+  mActiveTokens.SetElem(idx, token);
+}
+
 bool Parser::Parse() {
-  gASTBuilder.SetTrace(mTraceAstBuild);
-  bool succ = false;
+  gTemplateLiteralNodes.Clear();
+  mASTBuilder->SetTrace(mTraceAstBuild);
+  ParseStatus res;
   while (1) {
-    succ = ParseStmt();
-    if (!succ)
+    res = ParseStmt();
+    if (res == ParseFail || res == ParseEOF)
       break;
   }
 
-  gModule.Dump();
+  if (gTemplateLiteralNodes.GetNum() > 0)
+    ParseTemplateLiterals();
 
-  return succ;
+  FixUpVisitor worker(mASTModule);
+  worker.FixUp();
+
+  mASTModule->Dump(0);
+  return (res==ParseFail)? false: true;
+}
+
+void Parser::ParseTemplateLiterals() {
+
+  mLineMode = true;
+  mLexer->SetLineMode();
+  for (unsigned i = 0; i < gTemplateLiteralNodes.GetNum(); i++) {
+    TemplateLiteralNode *tl = gTemplateLiteralNodes.ValueAtIndex(i);
+    for (unsigned j = 1; j < tl->GetStringsNum(); j += 2) {
+      // Create tree node for format
+      const char *fmt_str = tl->GetStringAtIndex(j-1);
+      if (fmt_str) {
+        //Create a string literal node
+        LitData litdata;
+        litdata.mType = LT_StringLiteral;
+        litdata.mData.mStrIdx = gStringPool.GetStrIdx(fmt_str);
+        LiteralNode *n = (LiteralNode*)gTreePool.NewTreeNode(sizeof(LiteralNode));
+        new (n) LiteralNode(litdata);
+        tl->AddTree(n);
+      } else {
+        tl->AddTree(NULL);
+      }
+
+      const char *ph_str = tl->GetStringAtIndex(j);
+      if (ph_str) {
+        mLexer->PrepareForString(ph_str);
+        // Clear some status
+        ParseStatus result = ParseStmt();
+        MASSERT(result == ParseSucc);
+        MASSERT(mLineModeRoot);
+        tl->AddTree(mLineModeRoot);
+      } else {
+        tl->AddTree(NULL);
+      }
+    }
+  }
+  mLineMode = false;
+  mLexer->ResetLineMode();
 }
 
-// Right now I didn't use mempool yet, will come back.
-// [TODO] Using mempool.
 void Parser::ClearAppealNodes() {
   for (unsigned i = 0; i < mAppealNodes.size(); i++) {
     AppealNode *node = mAppealNodes[i];
     if (node)
-      delete node;
+      node->Release();
   }
   mAppealNodes.clear();
+  mAppealNodePool.Clear();
 }
 
 // This is for the appealing of mistaken Fail cases created during the first instance
@@ -349,10 +542,7 @@ void Parser::ClearAppealNodes() {
 void Parser::Appeal(AppealNode *start, AppealNode *root) {
   MASSERT((root->IsSucc()) && "root->mResult is not Succ.");
 
-  // A recursion group could have >1 lead node. 'start' could be a different leadnode
-  // than 'root'.
-
-  AppealNode *node = start->GetParent();
+  AppealNode *node = start;
 
   // It's possible that this sub-tree could be separated. For example, the last
   // instance of RecursionTraversal, which is a Fake Succ, and is separated
@@ -375,7 +565,7 @@ void Parser::Appeal(AppealNode *start, AppealNode *root) {
 // This is the parsing for highest level language constructs. It could be class
 // in Java/c++, or a function/statement in c/c++. In another word, it's the top
 // level constructs in a compilation unit (aka Module).
-bool Parser::ParseStmt() {
+ParseStatus Parser::ParseStmt() {
   // clear status
   ClearFailed();
   ClearSucc();
@@ -383,21 +573,13 @@ bool Parser::ParseStmt() {
   mPending = 0;
 
   // set the root appealing node
-  mRootNode = new AppealNode();
+  mRootNode = mAppealNodePool.NewAppealNode();
   mAppealNodes.push_back(mRootNode);
 
-  // mActiveTokens contain some un-matched tokens from last time of TraverseStmt(),
-  // because at the end of every TraverseStmt() when it finishes its matching it always
-  // MoveCurToken() which in turn calls LexOneLine() to read new tokens of a new line.
-  //
-  // This means in LexOneLine() we also need check if there are already tokens pending.
-  //
-  // [TODO] Later on, we will move thoes pending tokens to a separate data structure.
-
   unsigned token_num = LexOneLine();
   // No more token, end of file
   if (!token_num)
-    return false;
+    return ParseEOF;
 
   // Match the tokens against the rule tables.
   // In a rule table there are : (1) separtaor, operator, keyword, are already in token
@@ -409,7 +591,12 @@ bool Parser::ParseStmt() {
   if (mTraceTiming)
     gettimeofday(&start, NULL);
 
-  bool succ = TraverseStmt();
+  bool succ = false;
+  if (mLineMode)
+    succ = TraverseTempLiteral();
+  else
+    succ = TraverseStmt();
+
   if (mTraceTiming) {
     gettimeofday(&stop, NULL);
     std::cout << "Parse Time: " << (stop.tv_sec - start.tv_sec) * 1000000 + stop.tv_usec - start.tv_usec;
@@ -421,7 +608,7 @@ bool Parser::ParseStmt() {
     if (mTraceTiming)
       gettimeofday(&start, NULL);
 
-    PatchWasSucc(mRootNode->mSortedChildren[0]);
+    PatchWasSucc(mRootNode->mSortedChildren.ValueAtIndex(0));
     if (mTraceTiming) {
       gettimeofday(&stop, NULL);
       std::cout << "PatchWasSucc Time: " << (stop.tv_sec - start.tv_sec) * 1000000 + stop.tv_usec - start.tv_usec;
@@ -439,9 +626,11 @@ bool Parser::ParseStmt() {
 
     if (mTraceTiming)
       gettimeofday(&start, NULL);
-    ASTTree *tree = BuildAST();
+    TreeNode *tree = BuildAST();
     if (tree) {
-      gModule.AddTree(tree);
+      if (!mLineMode) {
+        mASTModule->AddTree(tree);
+      }
     }
 
     if (mTraceTiming) {
@@ -450,6 +639,71 @@ bool Parser::ParseStmt() {
       std::cout << " us" << std::endl;
     }
   }
+  return succ? ParseSucc: ParseFail;
+}
+
+// return true : if all tokens in mActiveTokens are matched.
+//       false : if faled.
+// For the place holders in Typescript Template Literal, there are usually two
+// syntax, expression and type.
+
+bool Parser::TraverseTempLiteral() {
+  bool succ_expr = false;
+  bool succ_type = false;
+  unsigned saved_mCurToken = mCurToken;
+  unsigned new_mCurToken_expr = 0;
+  unsigned new_mCurToken_type = 0;
+
+  mRootNode->ClearChildren();
+
+  RuleTable *t = &TblExpression;
+  AppealNode *child = NULL;
+  succ_expr = TraverseRuleTable(t, mRootNode, child);
+  if (succ_expr) {
+    MASSERT(child || t->mType == ET_ASI);
+    if (child)
+      mRootNode->CopyMatch(child);
+    // Need adjust the mCurToken. A rule could try multiple possible
+    // children rules, although there is one and only one valid child
+    // for a Top table. However, the mCurToken could deviate from
+    // the valid children and reflect the invalid children.
+    //MASSERT(mRootNode->mChildren.GetNum() == 1);
+    //AppealNode *topnode = mRootNode->mChildren.ValueAtIndex(0);
+    //MASSERT(topnode->IsSucc());
+    new_mCurToken_expr = mCurToken;
+  }
+
+  // Type TblType
+  mCurToken = saved_mCurToken;
+  t = &TblType;
+  child = NULL;
+  succ_type = TraverseRuleTable(t, mRootNode, child);
+  if (succ_type) {
+    MASSERT(child || t->mType == ET_ASI);
+    if (child)
+      mRootNode->CopyMatch(child);
+    // Need adjust the mCurToken. A rule could try multiple possible
+    // children rules, although there is one and only one valid child
+    // for a Top table. However, the mCurToken could deviate from
+    // the valid children and reflect the invalid children.
+    //MASSERT(mRootNode->mChildren.GetNum() == 1);
+    //AppealNode *topnode = mRootNode->mChildren.ValueAtIndex(0);
+    //MASSERT(topnode->IsSucc());
+    new_mCurToken_type = mCurToken;
+  }
+
+  mCurToken = new_mCurToken_expr > new_mCurToken_type ? new_mCurToken_expr : new_mCurToken_type;
+
+  bool succ = succ_expr | succ_type;
+  if (succ) {
+    mRootNode->mResult = Succ;
+    SortOut();
+  }
+
+  if (!succ)
+    std::cout << "Illegal syntax detected!" << std::endl;
+  else
+    std::cout << "Matched " << mCurToken << " tokens." << std::endl;
 
   return succ;
 }
@@ -467,14 +721,16 @@ bool Parser::TraverseStmt() {
     mRootNode->ClearChildren();
     AppealNode *child = NULL;
     succ = TraverseRuleTable(t, mRootNode, child);
-    mRootNode->CopyMatch(child);
     if (succ) {
+      MASSERT(child || t->mType == ET_ASI);
+      if (child)
+        mRootNode->CopyMatch(child);
       // Need adjust the mCurToken. A rule could try multiple possible
-      // children rules, although there is one any only one valid child
+      // children rules, although there is one and only one valid child
       // for a Top table. However, the mCurToken could deviate from
       // the valid children and reflect the invalid children.
-      MASSERT(mRootNode->mChildren.size() == 1);
-      AppealNode *topnode = mRootNode->mChildren[0];
+      MASSERT(mRootNode->mChildren.GetNum() == 1);
+      AppealNode *topnode = mRootNode->mChildren.ValueAtIndex(0);
       MASSERT(topnode->IsSucc());
 
       // Top level table should have only one valid matching. Otherwise,
@@ -515,39 +771,51 @@ void Parser::DumpEnterTable(const char *table_name, unsigned indent) {
 }
 
 void Parser::DumpExitTable(const char *table_name, unsigned indent, AppealNode *appeal) {
+  DumpExitTable(table_name, indent, appeal->mResult, appeal);
+}
+
+void Parser::DumpExitTable(const char *table_name, unsigned indent,
+                           AppealStatus reason, AppealNode *appeal) {
   for (unsigned i = 0; i < indent; i++)
     std::cout << " ";
   std::cout << "Exit  " << table_name << "@" << mCurToken;
-  bool succ = appeal->IsSucc();
-  AppealStatus reason = appeal->mResult;
-  if (succ) {
-    if (reason == SuccWasSucc)
-      std::cout << " succ@WasSucc" << "}";
-    else if (reason == SuccStillWasSucc)
-      std::cout << " succ@StillWasSucc" << "}";
-    else if (reason == Succ)
-      std::cout << " succ" << "}";
-
+  if (reason == SuccWasSucc) {
+    std::cout << " succ@WasSucc" << "}";
     DumpSuccTokens(appeal);
     std::cout << std::endl;
-  } else {
-    if (reason == FailWasFailed)
-      std::cout << " fail@WasFailed" << "}" << std::endl;
-    else if (reason == FailNotRightToken)
-      std::cout << " fail@NotRightToken" << "}" << std::endl;
-    else if (reason == FailNotIdentifier)
-      std::cout << " fail@NotIdentifer" << "}" << std::endl;
-    else if (reason == FailNotLiteral)
-      std::cout << " fail@NotLiteral" << "}" << std::endl;
-    else if (reason == FailChildrenFailed)
-      std::cout << " fail@ChildrenFailed" << "}" << std::endl;
-    else if (reason == Fail2ndOf1st)
-      std::cout << " fail@2ndOf1st" << "}" << std::endl;
-    else if (reason == FailLookAhead)
-      std::cout << " fail@LookAhead" << "}" << std::endl;
-    else if (reason == AppealStatus_NA)
-      std::cout << " fail@NA" << "}" << std::endl;
-  }
+  } else if (reason == SuccStillWasSucc) {
+    std::cout << " succ@StillWasSucc" << "}";
+    DumpSuccTokens(appeal);
+    std::cout << std::endl;
+  } else if (reason == Succ) {
+    std::cout << " succ" << "}";
+    DumpSuccTokens(appeal);
+    std::cout << std::endl;
+  } else if (reason == SuccASI) {
+    std::cout << " succASI" << "}";
+    std::cout << std::endl;
+  } else if (reason == FailWasFailed)
+    std::cout << " fail@WasFailed" << "}" << std::endl;
+  else if (reason == FailNotRightToken)
+    std::cout << " fail@NotRightToken" << "}" << std::endl;
+  else if (reason == FailNotRightString)
+    std::cout << " fail@NotRightString" << "}" << std::endl;
+  else if (reason == FailNotIdentifier)
+    std::cout << " fail@NotIdentifer" << "}" << std::endl;
+  else if (reason == FailNotLiteral)
+    std::cout << " fail@NotLiteral" << "}" << std::endl;
+  else if (reason == FailNotRegExpr)
+    std::cout << " fail@NotRegExpr" << "}" << std::endl;
+  else if (reason == FailChildrenFailed)
+    std::cout << " fail@ChildrenFailed" << "}" << std::endl;
+  else if (reason == Fail2ndOf1st)
+    std::cout << " fail@2ndOf1st" << "}" << std::endl;
+  else if (reason == FailLookAhead)
+    std::cout << " fail@LookAhead" << "}" << std::endl;
+  else if (reason == FailASI)
+    std::cout << " fail@ASI" << "}" << std::endl;
+  else if (reason == AppealStatus_NA)
+    std::cout << " fail@NA" << "}" << std::endl;
 }
 
 void Parser::DumpSuccTokens(AppealNode *appeal) {
@@ -577,67 +845,9 @@ void Parser::RemoveSuccNode(unsigned curr_token, AppealNode *node) {
   succ_match->RemoveNode(node);
 }
 
-// The PreProcessing of TraverseRuleTable().
-// Under the Wavefront algorithm of recursion group traversal, things are
-// are a little complicated.
-// 1. If a rule is failed at some token, it could be succ later. For example,
-//    the 2nd hit in 1st iteration of a recursion node, is failed@2ndof1st,
-//    but the rule could be succ match later.
-// 2. If a rule is succ at some token, it doesn't mean it's finished, and
-//    there could be more matchings.
-//
-// Returns true : if SuccMatch is done.
-
-bool Parser::TraverseRuleTablePre(AppealNode *appeal) {
-  unsigned saved_mCurToken = mCurToken;
-  bool is_done = false;
-  RuleTable *rule_table = appeal->GetTable();
-  const char *name = NULL;
-  if (mTraceTable)
-    name = GetRuleTableName(rule_table);
-
-  // Check if it was succ. The longest matching is chosen for the next rule table to match.
-  SuccMatch *succ = &gSucc[rule_table->mIndex];
-  if (succ) {
-    bool was_succ = succ->GetStartToken(mCurToken);
-    if (was_succ) {
-      // Those affected by the 1st appearance of 1st instance which returns false.
-      // 1stOf1st is not add to WasFail, but those affected will be added to WasFail.
-      // The affected can be succ later. So there is possibility both succ and fail
-      // exist at the same time.
-      //
-      // I still keep this assertion. We will see. Maybe we'll remove it.
-      MASSERT(!WasFailed(rule_table, mCurToken));
-
-      is_done = succ->IsDone();
-
-      unsigned num = succ->GetMatchNum();
-      for (unsigned i = 0; i < num; i++) {
-        unsigned match = succ->GetOneMatch(i);
-        // WasSucc nodes need Match info, which will be used later
-        // in the sort out.
-        appeal->AddMatch(match);
-        if (match > mCurToken)
-          mCurToken = match;
-      }
-      appeal->mResult = SuccWasSucc;
-
-      // In ZeroorXXX cases, it was successful and has SuccMatch. However,
-      // it could be a failure. In this case, we shouldn't move mCurToken.
-      if (num > 0)
-        MoveCurToken();
-    }
-  }
-
-  if (WasFailed(rule_table, saved_mCurToken)) {
-    appeal->mResult = FailWasFailed;
-  }
-
-  return is_done;
-}
-
 bool Parser::LookAheadFail(RuleTable *rule_table, unsigned token) {
   Token *curr_token = GetActiveToken(token);
+
   LookAheadTable latable = gLookAheadTable[rule_table->mIndex];
 
   bool found = false;
@@ -651,8 +861,20 @@ bool Parser::LookAheadFail(RuleTable *rule_table, unsigned token) {
       // which are not recoganized by lexer.
       break;
     case LA_Token:
-      if (curr_token == &gSystemTokens[la.mData.mTokenId])
+      if (curr_token->Equal(&gSystemTokens[la.mData.mTokenId]))
         found = true;
+      // TemplateLiteral, Regular Expression is treated as a special keyword.
+      {
+        Token *t = &gSystemTokens[la.mData.mTokenId];
+        if (t->IsKeyword() && !strncmp(t->GetName(), "this_is_for_fake_rule", 21)) {
+          if (curr_token->IsTempLit() || curr_token->IsRegExpr())
+            found = true;
+        }
+        if (rule_table == &TblNoLineTerminator) {
+          if (!curr_token->mLineBegin)
+            found = true;
+        }
+      }
       break;
     case LA_Identifier:
       if (curr_token->IsIdentifier())
@@ -686,16 +908,13 @@ bool Parser::LookAheadFail(RuleTable *rule_table, unsigned token) {
 //        2. TraverseRuleTable will let the children's traverse to move mCurToken
 //           if they succeeded.
 //        3. TraverseOneof, TraverseZeroxxxx, TraverseConcatenate follow rule 1&2.
-//        4. TraverseRuleTablePre and TraverseLeadNode both exit early, so they
-//           need follow the rule 1&2.
-//        3. TraverseRuleTablePre move mCurToken is succ, and actually it doesn't
-//           touch mCurToken when fail.
+//        3. TraverseLeadNode exit early, so need follow the rule 1&2.
 //        4. TraverseLeadNode() also follows the rule 1&2. It moves mCurToken
 //           when succ and restore it when fail.
 //
 // 'child' is the AppealNode of 'rule_table'.
 bool Parser::TraverseRuleTable(RuleTable *rule_table, AppealNode *parent, AppealNode *&child) {
-  if (mEndOfFile)
+  if (mEndOfFile && mCurToken >= mActiveTokens.GetNum())
     return false;
 
   mIndentation += 2;
@@ -705,45 +924,104 @@ bool Parser::TraverseRuleTable(RuleTable *rule_table, AppealNode *parent, Appeal
     DumpEnterTable(name, mIndentation);
   }
 
-  // set the apppeal node
-  AppealNode *appeal = new AppealNode();
-  mAppealNodes.push_back(appeal);
-  appeal->SetTable(rule_table);
-  appeal->SetStartIndex(mCurToken);
-  appeal->SetParent(parent);
-  parent->AddChild(appeal);
-  child = appeal;
+  if (rule_table->mType == ET_ASI) {
+    bool found = TraverseASI(rule_table, parent, child);
+    if (mTraceTable) {
+      if (found)
+        DumpExitTable(name, mIndentation, SuccASI);
+      else
+        DumpExitTable(name, mIndentation, FailASI);
+    }
+    mIndentation -= 2;
+    return found;
+  }
 
+  // Lookahead fail is fast to check, even faster than check WasFailed.
+  if (LookAheadFail(rule_table, mCurToken) &&
+      (rule_table->mType != ET_Zeroormore) &&
+      (rule_table->mType != ET_Zeroorone)) {
+    if (mTraceTable)
+      DumpExitTable(name, mIndentation, FailLookAhead);
+    mIndentation -= 2;
+    return false;
+  }
+
+  AppealNode *appeal = NULL;
   unsigned saved_mCurToken = mCurToken;
-  bool is_done = TraverseRuleTablePre(appeal);
+  bool is_done = false;
+
+  // Check if it was succ. The longest matching is chosen for the next rule table to match.
+  SuccMatch *succ = &gSucc[rule_table->mIndex];
+  if (succ) {
+    bool was_succ = succ->GetStartToken(mCurToken);
+    if (was_succ) {
+      // Those affected by the 1st appearance of 1st instance which returns false.
+      // 1stOf1st is not add to WasFail, but those affected will be added to WasFail.
+      // The affected can be succ later. So there is possibility both succ and fail
+      // exist at the same time.
+      //
+      // I still keep this assertion. We will see. Maybe we'll remove it.
+      MASSERT(!WasFailed(rule_table, mCurToken));
+
+      // set the apppeal node
+      appeal = mAppealNodePool.NewAppealNode();
+      mAppealNodes.push_back(appeal);
+      appeal->SetTable(rule_table);
+      appeal->SetStartIndex(mCurToken);
+      appeal->SetParent(parent);
+      parent->AddChild(appeal);
+      child = appeal;
+
+      is_done = succ->IsDone();
+
+      unsigned num = succ->GetMatchNum();
+      for (unsigned i = 0; i < num; i++) {
+        unsigned match = succ->GetOneMatch(i);
+        // WasSucc nodes need Match info, which will be used later
+        // in the sort out.
+        appeal->AddMatch(match);
+        if (match > mCurToken)
+          mCurToken = match;
+      }
+      appeal->mResult = SuccWasSucc;
+
+      // In ZeroorXXX cases, it was successful and has SuccMatch. However,
+      // it could be a failure. In this case, we shouldn't move mCurToken.
+      if (num > 0)
+        MoveCurToken();
+    }
+  }
 
   unsigned group_id;
   bool in_group = FindRecursionGroup(rule_table, group_id);
 
   // 1. In a recursion, a rule could fail in the first a few instances,
   //    but could match in a later instance. So I need check is_done.
+  //    Here is an example. Node A is one of the circle node.
+  //    (a) In the first recursion instance, A is failed, but luckly it
+  //        gets appealed due to lead node is 2ndOf1st.
+  //    (b) In the second instance, it still fail because its children
+  //        failed. But the whole recursion actually matches tokens, and
+  //        those matching rule tables are not related to A.
+  //    (c) Finally, A matches because leading node goes forward and gives
+  //        A new opportunity.
   // 2. For A not-in-group rule, a WasFailed is a real fail.
-  if (appeal->IsFail() && (!in_group || is_done)) {
-    if (mTraceTable)
-      DumpExitTable(name, mIndentation, appeal);
-    mIndentation -= 2;
-    return false;
-  }
 
-  if (LookAheadFail(rule_table, saved_mCurToken) &&
-      (rule_table->mType != ET_Zeroormore) &&
-      (rule_table->mType != ET_Zeroorone)) {
-    appeal->mResult = FailLookAhead;
-    AddFailed(rule_table, saved_mCurToken);
+  bool was_failed = WasFailed(rule_table, saved_mCurToken);
+  if (was_failed && (!in_group || is_done)) {
     if (mTraceTable)
-      DumpExitTable(name, mIndentation, appeal);
+      DumpExitTable(name, mIndentation, FailWasFailed);
     mIndentation -= 2;
     return false;
   }
 
   // If the rule is NOT in any recursion group, we simply return the result.
   // If the rule is done, we also simply return the result.
-  if (appeal->IsSucc()) {
+
+  // If a rule is succ at some token, it doesn't mean it's finished, and
+  // there could be more matchings.
+
+  if (appeal && appeal->IsSucc()) {
     if (!in_group || is_done) {
       if (mTraceTable)
         DumpExitTable(name, mIndentation, appeal);
@@ -752,19 +1030,47 @@ bool Parser::TraverseRuleTable(RuleTable *rule_table, AppealNode *parent, Appeal
     } else {
       if (mTraceTable) {
         DumpIndentation();
-        std::cout << "Traverse-Pre WasSucc, mCurToken:" << mCurToken;
+        std::cout << "Traverse-Pre WasSucc, mCurToken:" << saved_mCurToken;
         std::cout << std::endl;
       }
     }
   }
 
-  RecursionTraversal *rec_tra = FindRecStack(group_id, appeal->GetStartIndex());
+  RecursionTraversal *rec_tra = FindRecStack(group_id, saved_mCurToken);
 
   // group_id is 0 which is the default value if rule_table is not in a group
   // Need to reset rec_tra;
   if (!in_group)
     rec_tra = NULL;
 
+  // This part is to handle a special case: The second appearance in the first instance
+  // (wave) in the Wavefront algorithm. At this moment, the first appearance in this
+  // instance hasn't finished its traversal, so there is no previous succ or fail case.
+  //
+  // We need to simply return false, but we cannot add them to the Fail mapping.
+  // A rule is AddFailed() in TraverseRuleTableRegular() which is in the end of this function.
+
+  if (rec_tra &&
+      rec_tra->GetInstance() == InstanceFirst &&
+      rec_tra->LeadNodeVisited(rule_table)) {
+    rec_tra->AddAppealPoint(parent);
+    if (mTraceTable)
+      DumpExitTable(name, mIndentation, Fail2ndOf1st);
+    mIndentation -= 2;
+    return false;
+  }
+
+  // We delay creation of AppealNode as much as possible.
+  if (!appeal) {
+    appeal = mAppealNodePool.NewAppealNode();
+    mAppealNodes.push_back(appeal);
+    appeal->SetTable(rule_table);
+    appeal->SetStartIndex(saved_mCurToken);
+    appeal->SetParent(parent);
+    parent->AddChild(appeal);
+    child = appeal;
+  }
+
   // If the rule is already traversed in this iteration(instance), we return the result.
   if (rec_tra && rec_tra->RecursionNodeVisited(rule_table)) {
     if (mTraceTable)
@@ -788,7 +1094,7 @@ bool Parser::TraverseRuleTable(RuleTable *rule_table, AppealNode *parent, Appeal
     // wave (instance) of the Wavefront traversal, the 1st is not visited, the
     // 2nd is visited.
 
-    if (rec_tra->LeadNodeVisited(rule_table)) {  
+    if (rec_tra->LeadNodeVisited(rule_table)) {
       if (mTraceLeftRec) {
         DumpIndentation();
         std::cout << "<LR>: ConnectPrevious " << GetRuleTableName(rule_table)
@@ -807,22 +1113,6 @@ bool Parser::TraverseRuleTable(RuleTable *rule_table, AppealNode *parent, Appeal
     }
   }
 
-  // This part is to handle a special case: The second appearance in the first instance
-  // (wave) in the Wavefront algorithm. At this moment, the first appearance in this
-  // instance hasn't finished its traversal, so there is no previous succ or fail case.
-  //
-  // We need to simply return false, but we cannot add them to the Fail mapping.
-  if (rec_tra &&
-      rec_tra->GetInstance() == InstanceFirst &&
-      rec_tra->LeadNodeVisited(rule_table)) {
-    rec_tra->AddAppealPoint(appeal);
-    appeal->mResult = Fail2ndOf1st;
-    if (mTraceTable)
-      DumpExitTable(name, mIndentation, appeal);
-    mIndentation -= 2;
-    return false;
-  }
-
   // Restore the mCurToken since TraverseRuleTablePre() update the mCurToken
   // if succ. And we need use the old mCurToken.
   mCurToken = saved_mCurToken;
@@ -874,12 +1164,24 @@ bool Parser::TraverseRuleTable(RuleTable *rule_table, AppealNode *parent, Appeal
 //   1. TraverseIdentifier, TraverseLiteral, TraverseOneof, TraverseZeroorXXx, etc
 //      since we konw the relation between parent and children
 //   2. Or TraverseTableData in this function, because we know the relation.
-//   3. Or when TraverseRuleTablePre is succ, also because we know the relation. We
-//      do it inside TraverseRuleTablePre.
+//   3. When TraverseRuleTable pre-check was succ. Because we know the relation.
 // These are the only places of colleting succ match for a parent node.
 //
 
 bool Parser::TraverseRuleTableRegular(RuleTable *rule_table, AppealNode *appeal) {
+  // In TraverseToken(), alt tokens are traversed. The intermediate status of matching
+  // are needed. However, if a matching failed in the middle of alt token serial, the
+  // status is not cleared in TraverseToken(). It's hard to clear in TraverseToken()
+  // as it doesn't know the context of traversal.
+  //
+  // A better solution is to clear each time entering a top rule table.
+  if (rule_table->mProperties & RP_Top) {
+    mInAltTokensMatching = false;
+    mNextAltTokenIndex = 0;
+    if (mTraceTable)
+      std::cout << "Clear alt token status." << std::endl;
+  }
+
   bool matched = false;
   unsigned saved_mCurToken = mCurToken;
 
@@ -900,6 +1202,20 @@ bool Parser::TraverseRuleTableRegular(RuleTable *rule_table, AppealNode *appeal)
   if ((rule_table == &TblLiteral))
     return TraverseLiteral(rule_table, appeal);
 
+  if ((rule_table == &TblTemplateLiteral))
+    return TraverseTemplateLiteral(rule_table, appeal);
+
+  if ((rule_table == &TblRegularExpression))
+    return TraverseRegularExpression(rule_table, appeal);
+
+  if (rule_table == &TblNoLineTerminator) {
+    Token *token = mActiveTokens.ValueAtIndex(mCurToken);
+    if (token->mLineBegin)
+      return false;
+    else
+      return true;
+  }
+
   EntryType type = rule_table->mType;
   switch(type) {
   case ET_Oneof:
@@ -914,14 +1230,22 @@ bool Parser::TraverseRuleTableRegular(RuleTable *rule_table, AppealNode *appeal)
   case ET_Concatenate:
     matched = TraverseConcatenate(rule_table, appeal);
     break;
+  case ET_ASI: {
+    AppealNode *child = NULL;
+    matched = TraverseASI(rule_table, appeal, child);
+    break;
+  }
   case ET_Data: {
     // This is a rare case where a rule table contains only table, either a token
     // or a single child rule. In this case, we need merge the child's match into
     // parent. However, we cannot do the merge in TraverseTableData() since this
     // function will be used in multiple places where we cannot merge.
-    AppealNode *child;
+    AppealNode *child = NULL;
     matched = TraverseTableData(rule_table->mData, appeal, child);
-    appeal->CopyMatch(child);
+    if (child) {
+      child->SetChildIndex(0);
+      appeal->CopyMatch(child);
+    }
     break;
   }
   case ET_Null:
@@ -944,30 +1268,102 @@ bool Parser::TraverseRuleTableRegular(RuleTable *rule_table, AppealNode *appeal)
 
 // Returns 1. true if succ.
 //         2. child_node which represents 'token'.
-bool Parser::TraverseToken(Token *token, AppealNode *parent, AppealNode *&child_node) {
-  Token *curr_token = GetActiveToken(mCurToken);
-  bool found = false;
+bool Parser::TraverseStringSucc(Token *token, AppealNode *parent, AppealNode *&child_node) {
+  AppealNode *appeal = NULL;
   mIndentation += 2;
 
   if (mTraceTable) {
-    std::string name = "token:";
+    std::string name = "string:";
     name += token->GetName();
-    name += " curr_token:";
-    name += curr_token->GetName();
+    name += " curr_token matches";
     DumpEnterTable(name.c_str(), mIndentation);
   }
 
-  AppealNode *appeal = new AppealNode();
+  appeal = mAppealNodePool.NewAppealNode();
   child_node = appeal;
   mAppealNodes.push_back(appeal);
-  appeal->mResult = FailNotRightToken;
-  appeal->SetToken(curr_token);
+  appeal->SetToken(token);
   appeal->SetStartIndex(mCurToken);
   appeal->SetParent(parent);
   parent->AddChild(appeal);
+  appeal->mResult = Succ;
+  appeal->AddMatch(mCurToken);
+  MoveCurToken();
+
+  if (mTraceTable) {
+    std::string name;
+    name = "string:";
+    name += token->GetName();
+    DumpExitTable(name.c_str(), mIndentation, appeal);
+  }
+
+  mIndentation -= 2;
+  return true;
+}
+
+// Returns 1. true if succ.
+//         2. child_node which represents 'token'.
+bool Parser::TraverseToken(Token *token, AppealNode *parent, AppealNode *&child_node) {
+  Token *curr_token = GetActiveToken(mCurToken);
+  bool found = false;
+  mIndentation += 2;
+
+  if (mTraceTable) {
+    std::string name = "token:";
+    name += token->GetName();
+    name += " curr_token:";
+    name += curr_token->GetName();
+    DumpEnterTable(name.c_str(), mIndentation);
+  }
 
   bool use_alt_token = false;
-  if (token == curr_token) {
+  AppealNode *appeal = NULL;
+
+  // [TODO]
+  // We enable skipping semi-colon. Later we will implement TS specific version of parser
+  // which overried TraverseToken().
+  // We handle one case in the following:
+  //   The rule expects:
+  //       { statement ;}
+  //   But we see :
+  //       { statement }  // No ';'
+  // In this case we can skip the checking of ';' since '}' actually closes everything.
+  // There are many other cases. Will handle later.
+  if (token->IsSeparator() && token->GetSepId() == SEP_Semicolon) {
+    if (curr_token->IsSeparator() && curr_token->GetSepId() == SEP_Rbrace) {
+      // 1. There are rule like ZEROORMORE(';'). In this case, we don't insert
+      RuleTable *parent_rt = parent->GetTable();
+      bool need_insert = true;
+      if (parent_rt->mType == ET_Zeroormore || parent_rt->mType == ET_Zeroorone)
+        need_insert = false;
+
+      // We also require that '}' is the last token, at least the last in this line
+      // if not the end of file.
+      if (mActiveTokens.GetNum() > mCurToken + 1)
+        need_insert = false;
+
+      // 2. we need check cases where we already have one previous ';'.
+      Token *prev = mActiveTokens.ValueAtIndex(mCurToken - 1);
+      if (prev != token && need_insert) {
+        // The simpliest way is to insert a semicolon token in mActiveTokens.
+        // Just pretend we lex a semicolon.
+        InsertToken(mCurToken, token);
+        curr_token = token;
+        if (mTraceTable) {
+          std::cout << "Auto-insert one semicolon." << std::endl;
+        }
+      }
+    }
+  }
+
+  if (token->Equal(curr_token)) {
+    appeal = mAppealNodePool.NewAppealNode();
+    child_node = appeal;
+    mAppealNodes.push_back(appeal);
+    appeal->SetToken(curr_token);
+    appeal->SetStartIndex(mCurToken);
+    appeal->SetParent(parent);
+    parent->AddChild(appeal);
     appeal->mResult = Succ;
     appeal->AddMatch(mCurToken);
     found = true;
@@ -977,13 +1373,39 @@ bool Parser::TraverseToken(Token *token, AppealNode *parent, AppealNode *&child_
     if (curr_token->mAltTokens) {
       bool alt_found = false;
       AltToken *pat = curr_token->mAltTokens;
-      if (token == &gSystemTokens[pat->mAltTokenId]) {
+
+      // Sometimes a rule which has literally good alt tokens doesn't want to be
+      // considered as alt token matching, eg.
+      //  RelationalExpression :   expr + '>' + expr
+      // This '>' won't be suitable for alt tokens of >> or >>>, because so far
+      // there is no expr ending with '>'.
+      bool parent_ok = true;
+      if (parent->GetTable()->mProperties & RP_NoAltToken)
+        parent_ok = false;
+
+      if (parent_ok && (token->Equal(&gSystemTokens[pat->mAltTokenId]))) {
+        appeal = mAppealNodePool.NewAppealNode();
+        child_node = appeal;
+        mAppealNodes.push_back(appeal);
+        appeal->SetToken(curr_token);
+        appeal->SetStartIndex(mCurToken);
+        appeal->SetParent(parent);
+        parent->AddChild(appeal);
+
         found = true;
         alt_found = true;
         mATMToken = mCurToken;
+
+        if (mTraceTable) {
+          std::cout << "Work on alt token, index : " << mNextAltTokenIndex << std::endl;
+        }
+
         if (!mInAltTokensMatching) {
           mInAltTokensMatching = true;
           appeal->m1stAltTokenMatched = true;
+          if (mTraceTable) {
+            std::cout << "Turn On mInAltTokensMatching " << std::endl;
+          }
         }
         mNextAltTokenIndex++;
 
@@ -998,6 +1420,10 @@ bool Parser::TraverseToken(Token *token, AppealNode *parent, AppealNode *&child_
           MoveCurToken();
           mInAltTokensMatching = false;
           mNextAltTokenIndex = 0;
+          if (mTraceTable) {
+            std::cout << "Work on alt token is successfully finised. Set mNextAltTokenIndex to : " << mNextAltTokenIndex << std::endl;
+            std::cout << "Turn Off mInAltTokensMatching " << std::endl;
+          }
         }
       }
     }
@@ -1010,7 +1436,10 @@ bool Parser::TraverseToken(Token *token, AppealNode *parent, AppealNode *&child_
     else
       name = "token:";
     name += token->GetName();
-    DumpExitTable(name.c_str(), mIndentation, appeal);
+    if (appeal)
+      DumpExitTable(name.c_str(), mIndentation, appeal);
+    else
+      DumpExitTable(name.c_str(), mIndentation, FailNotRightToken);
   }
 
   mIndentation -= 2;
@@ -1048,6 +1477,44 @@ bool Parser::TraverseLiteral(RuleTable *rule_table, AppealNode *appeal) {
   return found;
 }
 
+// We don't go into TemplateLiteral table.
+// 'appeal' is the node for this rule table. This is different than TraverseOneof
+// or the others where 'appeal' is actually a parent node.
+bool Parser::TraverseTemplateLiteral(RuleTable *rule_table, AppealNode *appeal) {
+  Token *curr_token = GetActiveToken(mCurToken);
+  const char *name = GetRuleTableName(rule_table);
+  bool found = false;
+
+  if (curr_token->IsTempLit()) {
+    found = true;
+    TraverseSpecialTableSucc(rule_table, appeal);
+  } else {
+    appeal->mResult = FailNotLiteral;
+    AddFailed(rule_table, mCurToken);
+  }
+
+  return found;
+}
+
+// We don't go into RegularExpressionLiteral table.
+// 'appeal' is the node for this rule table. This is different than TraverseOneof
+// or the others where 'appeal' is actually a parent node.
+bool Parser::TraverseRegularExpression(RuleTable *rule_table, AppealNode *appeal) {
+  Token *curr_token = GetActiveToken(mCurToken);
+  const char *name = GetRuleTableName(rule_table);
+  bool found = false;
+
+  if (curr_token->IsRegExpr()) {
+    found = true;
+    TraverseSpecialTableSucc(rule_table, appeal);
+  } else {
+    appeal->mResult = FailNotRegExpr;
+    AddFailed(rule_table, mCurToken);
+  }
+
+  return found;
+}
+
 // We don't go into Identifier table.
 // 'appeal' is the node for this rule table.
 bool Parser::TraverseIdentifier(RuleTable *rule_table, AppealNode *appeal) {
@@ -1110,7 +1577,7 @@ bool Parser::TraverseZeroormore(RuleTable *rule_table, AppealNode *appeal) {
       bool temp_found = TraverseTableData(data, appeal, child);
       found_subtable |= temp_found;
 
-      if (temp_found) {
+      if (temp_found && child) {
         unsigned match_num = child->GetMatchNum();
         for (unsigned id = 0; id < match_num; id++) {
           unsigned match = child->GetMatch(id);
@@ -1150,13 +1617,16 @@ bool Parser::TraverseZeroormore(RuleTable *rule_table, AppealNode *appeal) {
 bool Parser::TraverseZeroorone(RuleTable *rule_table, AppealNode *appeal) {
   MASSERT((rule_table->mNum == 1) && "zeroorone node has more than one elements?");
   TableData *data = rule_table->mData;
-  AppealNode *child;
+  AppealNode *child = NULL;
   bool found = TraverseTableData(data, appeal, child);
-  appeal->CopyMatch(child);
+  if (child)
+    appeal->CopyMatch(child);
   return true;
 }
 
 // 1. Save all the possible matchings from children.
+//    There is one exception. If the rule-table is a top rule it should
+//    get the longest match.
 // 2. As return value we choose the longest matching.
 //
 // 'appeal' is the node of 'rule_table'.
@@ -1171,8 +1641,8 @@ bool Parser::TraverseOneof(RuleTable *rule_table, AppealNode *appeal) {
     bool temp_found = TraverseTableData(data, appeal, child);
     found = found | temp_found;
     if (temp_found) {
-      MASSERT(child);
-      appeal->CopyMatch(child);
+      if (child)
+        appeal->CopyMatch(child);
       if (mCurToken > new_mCurToken)
         new_mCurToken = mCurToken;
 
@@ -1180,12 +1650,19 @@ bool Parser::TraverseOneof(RuleTable *rule_table, AppealNode *appeal) {
       mCurToken = old_mCurToken;
 
       // Some ONEOF rules can have only children matching current token seq.
+      // Or the language desiner just want to match the first children rule.
       if (rule_table->mProperties & RP_Single) {
         break;
       }
     }
   }
 
+  if (found && (rule_table->mProperties & RP_Top)) {
+    unsigned longest = appeal->LongestMatch();
+    appeal->ClearMatch();
+    appeal->AddMatch(longest);
+  }
+
   // move position according to the longest matching
   mCurToken = new_mCurToken;
   return found;
@@ -1202,7 +1679,7 @@ bool Parser::TraverseOneof(RuleTable *rule_table, AppealNode *appeal) {
 //           e.g. in a rule like below
 //              rule AA : BB + CC + ZEROORONE(xxx)
 //           If ZEROORONE(xxx) doesn't match anything, it sets subtable_succ_tokens to 0. However
-//           rule AA matches multiple tokens. So final_succ_tokens needs to be calculated carefully.
+//           rule AA matches 'BB + CC'. So final_succ_tokens needs to be calculated carefully.
 //        4. We are going to take succ match info from SuccMatch, not from a specific
 //           AppealNode. SuccMatch has the complete info.
 //
@@ -1215,22 +1692,41 @@ bool Parser::TraverseConcatenate(RuleTable *rule_table, AppealNode *appeal) {
 
   SmallVector<unsigned> prev_succ_tokens;
   SmallVector<unsigned> subtable_succ_tokens;
-  SmallVector<unsigned> final_succ_tokens;
 
   unsigned saved_mCurToken = mCurToken;
 
+  // prepare the prev_succ_tokens[_num] for the 1st iteration.
   int last_matched = mCurToken - 1;
+  prev_succ_tokens.PushBack(last_matched);
 
-  // prepare the prev_succ_tokens[_num] for the 1st iteration.
-  prev_succ_tokens.PushBack(mCurToken - 1);
+  // This is regarding the matching of Alternative Tokens. For example,
+  //    a<b<c>>
+  // >> needs to be matched as two '>'.
+  // mInAltTokensMatching is used to control if we are in the middle of matching such tokens.
+  // However, there is a complicated case, that is  "c>", which could be matched as part
+  // RelationshipExpression, and it turned on mInAltTokensMatching. But it actually fails
+  // to be a RelationshipExpression and mInAltTokensMatching should be turned off.
+  bool turned_on_AltToken = false;
 
   for (unsigned i = 0; i < rule_table->mNum; i++) {
-    bool is_zeroxxx = false;
+    bool is_zeroxxx = false;  // If the table is Zeroorxxx(), or NoLineTerminator.
+    bool no_line_term = false;  // If the table is NoLineTerminator
+    bool no_line_term_met = false;  // If the table is NoLineTerminator and token is no line term.
+    bool is_asi = false;
+    bool is_token = false;
+    bool old_mInAltTokensMatching = mInAltTokensMatching;
+
     TableData *data = rule_table->mData + i;
     if (data->mType == DT_Subtable) {
-      RuleTable *zero_rt = data->mData.mEntry;
-      if (zero_rt->mType == ET_Zeroormore || zero_rt->mType == ET_Zeroorone)
+      RuleTable *curr_rt = data->mData.mEntry;
+      if (curr_rt == &TblNoLineTerminator) 
+        no_line_term = true;
+      if (curr_rt->mType == ET_Zeroormore || curr_rt->mType == ET_Zeroorone)
         is_zeroxxx = true;
+      if (curr_rt->mType == ET_ASI)
+        is_asi = true;
+    } else if (data->mType == DT_Token) {
+      is_token = true;
     }
 
     SmallVector<unsigned> carry_on_prev;
@@ -1250,49 +1746,56 @@ bool Parser::TraverseConcatenate(RuleTable *rule_table, AppealNode *appeal) {
 
       AppealNode *child = NULL;
       bool temp_found = TraverseTableData(data, appeal, child);
+      if (child)
+        child->SetChildIndex(i);
       found_subtable |= temp_found;
 
-      if (temp_found) {
-        bool duplicated_with_prev = false;
-        for (unsigned id = 0; id < child->GetMatchNum(); id++) {
-          unsigned match = child->GetMatch(id);
-          if (!subtable_succ_tokens.Find(match))
-            subtable_succ_tokens.PushBack(match);
-          if (match == prev)
-            duplicated_with_prev = true;
+      if (temp_found ) {
+        if (child) {
+          for (unsigned id = 0; id < child->GetMatchNum(); id++) {
+            unsigned match = child->GetMatch(id);
+            if (!subtable_succ_tokens.Find(match))
+              subtable_succ_tokens.PushBack(match);
+          }
+        } else if (is_asi) {
+          // ASI succeeded, without child. It means semicolon is skipped.
+          // Keep prev. NO moving mCurToken.
+          subtable_succ_tokens.PushBack(prev);
         }
-
-        // for Zeroorone/Zeroormore node it always returns true. NO matter how
-        // many tokens it really matches, 'zero' is also a correct match. we
-        // need take it into account so that the next rule table can try
-        // on it. [Except it's a duplication]
-        if (is_zeroxxx && !duplicated_with_prev)
-          carry_on_prev.PushBack(prev);
       }
     }
 
-    // Update the final_succ_tokens
-    // Please read comment 3 before this function.
-    if (!is_zeroxxx)
-      final_succ_tokens.Clear();
-
-    prev_succ_tokens.Clear();
+    if ((prev_succ_tokens.GetNum() == 1) && no_line_term) {
+      unsigned prev = prev_succ_tokens.ValueAtIndex(0);
+      Token *t = GetActiveToken(prev + 1);
+      if (!t->mLineBegin)
+        no_line_term_met = true;
+    }
 
-    if (found_subtable) {
+    // for Zeroorone/Zeroormore node it always returns true. NO matter how
+    // many tokens it really matches, 'zero' is also a correct match. we
+    // need take it into account so that the next rule table can try
+    // on it.
+    if (!is_zeroxxx && !no_line_term_met)
+      prev_succ_tokens.Clear();
+
+    // is_zeroxxx seems redundant because the traversal should always be true.
+    // However, it's not true. In mLineMode, mEndOfFile could be set before
+    // traversing this ZEROORXXX table. It will return false.
+    // Since we do treat this case as success, so is_zeroxxx is included in this
+    // condition expression.
+    if (found_subtable || is_zeroxxx) {
       for (unsigned id = 0; id < subtable_succ_tokens.GetNum(); id++) {
         unsigned token = subtable_succ_tokens.ValueAtIndex(id);
         if (!prev_succ_tokens.Find(token))
           prev_succ_tokens.PushBack(token);
-        if (!final_succ_tokens.Find(token))
-          final_succ_tokens.PushBack(token);
       }
-      for (unsigned id = 0; id < carry_on_prev.GetNum(); id++) {
-        unsigned token = carry_on_prev.ValueAtIndex(id);
-        if (!prev_succ_tokens.Find(token))
-          prev_succ_tokens.PushBack(token);
+      // alert mInAltTokensMatching is turned on
+      if (is_token && mInAltTokensMatching && !old_mInAltTokensMatching) {
+        turned_on_AltToken = true;
       }
     } else {
-      // Once a single child rule fails, the 'appeal' fails.
+      // Once a child rule fails, the 'appeal' fails.
       found = false;
       break;
     }
@@ -1301,9 +1804,10 @@ bool Parser::TraverseConcatenate(RuleTable *rule_table, AppealNode *appeal) {
   mCurToken = saved_mCurToken;
 
   if (found) {
-    for (unsigned id = 0; id < final_succ_tokens.GetNum(); id++) {
-      unsigned token = final_succ_tokens.ValueAtIndex(id);
-      appeal->AddMatch(token);
+    for (unsigned id = 0; id < prev_succ_tokens.GetNum(); id++) {
+      unsigned token = prev_succ_tokens.ValueAtIndex(id);
+      if (token != last_matched)
+        appeal->AddMatch(token);
     }
     // mCurToken doesn't have much meaning in current algorithm when
     // transfer to the next rule table, because the next rule will take
@@ -1314,6 +1818,10 @@ bool Parser::TraverseConcatenate(RuleTable *rule_table, AppealNode *appeal) {
     appeal->mResult = Succ;
     if (appeal->GetMatchNum() > 0)
       mCurToken = appeal->LongestMatch() + 1;
+  } else if (turned_on_AltToken) {
+    mInAltTokensMatching = false;
+    if (mTraceTable)
+      std::cout << "Turned Off mInAltTokensMatching." << std::endl;
   }
 
   return found;
@@ -1325,8 +1833,24 @@ bool Parser::TraverseConcatenate(RuleTable *rule_table, AppealNode *appeal) {
 //    Oneof and Zeroormore should be handled differently.
 // 3. The mCurToken moves if found target, or restore the original location.
 bool Parser::TraverseTableData(TableData *data, AppealNode *appeal, AppealNode *&child_node) {
-  if (mEndOfFile)
-    return false;
+  // Usually mCurToken is a new token to be matched. So if it's end of file, we simply return false.
+  // However, (1) if mCurToken is actually an ATMToken, which means it needs to be matched
+  //              multiple times, we are NOT at the end yet.
+  //          (2) If we are traverse a Concatenate rule, and the previous sub-rule has multiple matches,
+  //              and we are trying the current sub-rule, ie. 'data', using one of the matches.
+  //              The lexer actually reaches the EndOfFile in previous matchings, but the mCurToken
+  //              we are working on right now is not the last token. It's one of the previous matches.
+  // So we need check if we are matching the last token.
+  if (mEndOfFile && mCurToken >= mActiveTokens.GetNum()) {
+    if (!(mInAltTokensMatching && (mCurToken == mATMToken))) {
+      if (data->mType == DT_Subtable) {
+        RuleTable *t = data->mData.mEntry;
+        if (t->mType == ET_ASI)
+          return TraverseASI(t, appeal, child_node);
+      }
+      return false;
+    }
+  }
 
   unsigned old_pos = mCurToken;
   bool     found = false;
@@ -1334,10 +1858,14 @@ bool Parser::TraverseTableData(TableData *data, AppealNode *appeal, AppealNode *
 
   switch (data->mType) {
   case DT_Char:
+    MASSERT(0 && "Hit Char in TableData during matching!");
+    break;
   case DT_String:
-    //MASSERT(0 && "Hit Char/String in TableData during matching!");
-    //TODO: Need compare literal. But so far looks like it's impossible to
-    //      have a literal token able to match a string/char in rules.
+    if (curr_token->IsIdentifier() &&
+        !strncmp(curr_token->GetName(), data->mData.mString, strlen(data->mData.mString)) &&
+        strlen(curr_token->GetName()) == strlen(data->mData.mString) ){
+      found = TraverseStringSucc(curr_token, appeal, child_node);
+    }
     break;
   // separator, operator, keywords are generated as DT_Token.
   // just need check the pointer of token
@@ -1369,18 +1897,23 @@ void Parser::SetIsDone(unsigned group_id, unsigned start_token) {
     bool found = succ->GetStartToken(start_token);
     if(found)
       succ->SetIsDone();
-  } 
+  }
 }
 
 void Parser::SetIsDone(RuleTable *rt, unsigned start_token) {
   // We don't save SuccMatch for TblLiteral and TblIdentifier
-  if((rt == &TblLiteral) || (rt == &TblIdentifier))
+  if((rt == &TblLiteral) ||
+     (rt == &TblIdentifier) ||
+     (rt == &TblRegularExpression) ||
+     (rt == &TblTemplateLiteral))
     return;
 
   SuccMatch *succ = &gSucc[rt->mIndex];
   bool found = succ->GetStartToken(start_token);
-  MASSERT(found);
-  succ->SetIsDone();
+  if (rt != &TblNoLineTerminator) {
+    MASSERT(found);
+    succ->SetIsDone();
+  }
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -1411,19 +1944,33 @@ void Parser::SetIsDone(RuleTable *rt, unsigned start_token) {
 //           get a single tree.
 /////////////////////////////////////////////////////////////////////////////
 
-// We don't want to use recursive. So a deque is used here.
+// We don't want to use recursion. So a deque is used here.
 static std::deque<AppealNode*> to_be_sorted;
 
 void Parser::SortOut() {
   // we remove all failed children, leaving only succ child
-  std::vector<AppealNode*>::iterator it = mRootNode->mChildren.begin();
-  for (; it != mRootNode->mChildren.end(); it++) {
-    AppealNode *n = *it;
-    if (!n->IsFail() && !n->IsNA())
-      mRootNode->mSortedChildren.push_back(n);
+  AppealNode *root = NULL;
+  if (!mLineMode) {
+    for (unsigned i = 0; i < mRootNode->mChildren.GetNum(); i++) {
+      AppealNode *n = mRootNode->mChildren.ValueAtIndex(i);
+      if (!n->IsFail() && !n->IsNA())
+        mRootNode->mSortedChildren.PushBack(n);
+    }
+    MASSERT(mRootNode->mSortedChildren.GetNum()==1);
+    root = mRootNode->mSortedChildren.ValueAtIndex(0);
+  } else {
+    // LineMode could have >1 matching children
+    // Find the longest match
+    unsigned longest = mRootNode->LongestMatch();
+    for (unsigned i = 0; i < mRootNode->mChildren.GetNum(); i++) {
+      AppealNode *n = mRootNode->mChildren.ValueAtIndex(i);
+      if (n->LongestMatch() == longest) {
+        root = n;
+        mRootNode->mSortedChildren.PushBack(n);
+        break;
+      }
+    }
   }
-  MASSERT(mRootNode->mSortedChildren.size()==1);
-  AppealNode *root = mRootNode->mSortedChildren.front();
 
   // First sort the root.
   RuleTable *table = root->GetTable();
@@ -1432,12 +1979,22 @@ void Parser::SortOut() {
   MASSERT(succ && "root has no SuccMatch?");
   bool found = succ->GetStartToken(root->GetStartIndex());
 
-  // Top level tree can have only one match, otherwise, the language
+  // In regular parsing, Top level tree can have only one match, otherwise, the language
   // is ambiguous.
+  // In LineMode parsing, we are parsing an expression, and it could be multiple matching
+  // with some partial matchings. We pick the longest matching and it should be the same
+  // as mActiveTokens.GetNum() meaning it matches all token so far.
   unsigned match_num = succ->GetMatchNum();
-  MASSERT(match_num == 1 && "Top level tree has >1 matches?");
-  unsigned match = succ->GetOneMatch(0);
+  unsigned match = 0;
+  if (mLineMode) {
+    match = root->LongestMatch();
+    MASSERT(match + 1 == mActiveTokens.GetNum());
+  } else {
+    MASSERT(match_num == 1 && "Top level tree has >1 matches?");
+    match = succ->GetOneMatch(0);
+  }
   root->SetFinalMatch(match);
+
   root->SetSorted();
 
   to_be_sorted.clear();
@@ -1468,7 +2025,7 @@ void Parser::SortOutNode(AppealNode *node) {
   // during matching. In SortOut, we simple return. However, when generating IR,
   // the children have to be created.
   if (node->mResult == SuccWasSucc) {
-    MASSERT(node->mChildren.size() == 0);
+    MASSERT(node->mChildren.GetNum() == 0);
     return;
   }
 
@@ -1479,16 +2036,15 @@ void Parser::SortOutNode(AppealNode *node) {
   RuleTable *rule_table = node->GetTable();
 
   // Table Identifier and Literal don't need sort.
-  if (rule_table == &TblIdentifier || rule_table == &TblLiteral)
+  if (rule_table == &TblIdentifier || rule_table == &TblLiteral || rule_table == &TblTemplateLiteral)
     return;
 
   // The lead node of a traversal group need special solution, if they are
   // simply connect to previous instance(s).
   if (mRecursionAll.IsLeadNode(rule_table)) {
     bool connect_only = true;
-    std::vector<AppealNode*>::iterator it = node->mChildren.begin();
-    for (; it != node->mChildren.end(); it++) {
-      AppealNode *child = *it;
+    for (unsigned i = 0; i < node->mChildren.GetNum(); i++) {
+      AppealNode *child = node->mChildren.ValueAtIndex(i);
       if (!child->IsTable() || child->GetTable() != rule_table) {
         connect_only = false;
         break;
@@ -1537,15 +2093,14 @@ void Parser::SortOutRecursionHead(AppealNode *parent) {
   unsigned parent_match = parent->GetFinalMatch();
 
   //Find the first child having the same match as parent.
-  std::vector<AppealNode*>::iterator it = parent->mChildren.begin();
-  for (; it != parent->mChildren.end(); it++) {
-    AppealNode *child = *it;
+  for (unsigned i = 0; i < parent->mChildren.GetNum(); i++) {
+    AppealNode *child = parent->mChildren.ValueAtIndex(i);
     if (child->IsFail() || child->IsNA())
       continue;
     bool found = child->FindMatch(parent_match);
     if (found) {
       to_be_sorted.push_back(child);
-      parent->mSortedChildren.push_back(child);
+      parent->mSortedChildren.PushBack(child);
       child->SetFinalMatch(parent_match);
       child->SetSorted();
       child->SetParent(parent);
@@ -1566,9 +2121,8 @@ void Parser::SortOutOneof(AppealNode *parent) {
 
   unsigned parent_match = parent->GetFinalMatch();
   unsigned good_children = 0;
-  std::vector<AppealNode*>::iterator it = parent->mChildren.begin();
-  for (; it != parent->mChildren.end(); it++) {
-    AppealNode *child = *it;
+  for (unsigned i = 0; i < parent->mChildren.GetNum(); i++) {
+    AppealNode *child = parent->mChildren.ValueAtIndex(i);
     if (child->IsFail() || child->IsNA())
       continue;
 
@@ -1583,14 +2137,14 @@ void Parser::SortOutOneof(AppealNode *parent) {
         child->SetFinalMatch(parent_match);
         child->SetParent(parent);
         good_children++;
-        parent->mSortedChildren.push_back(child);
+        parent->mSortedChildren.PushBack(child);
       }
     } else {
       bool found = child->FindMatch(parent_match);
       if (found) {
         good_children++;
         to_be_sorted.push_back(child);
-        parent->mSortedChildren.push_back(child);
+        parent->mSortedChildren.PushBack(child);
         child->SetFinalMatch(parent_match);
         child->SetSorted();
         child->SetParent(parent);
@@ -1630,9 +2184,8 @@ void Parser::SortOutZeroormore(AppealNode *parent) {
   SmallVector<AppealNode*> sorted_children;
   while(1) {
     AppealNode *good_child = NULL;
-    std::vector<AppealNode*>::iterator it = parent->mChildren.begin();
-    for (; it != parent->mChildren.end(); it++) {
-      AppealNode *child = *it;
+    for (unsigned i = 0; i < parent->mChildren.GetNum(); i++) {
+      AppealNode *child = parent->mChildren.ValueAtIndex(i);
       if (sorted_children.Find(child))
         continue;
       if (child->IsSucc() && child->FindMatch(last_match)) {
@@ -1657,7 +2210,7 @@ void Parser::SortOutZeroormore(AppealNode *parent) {
 
   for (int i = sorted_children.GetNum() - 1; i >= 0; i--) {
     AppealNode *child = sorted_children.ValueAtIndex(i);
-    parent->mSortedChildren.push_back(child);
+    parent->mSortedChildren.PushBack(child);
     if (child->IsTable())
       to_be_sorted.push_back(child);
   }
@@ -1682,8 +2235,8 @@ void Parser::SortOutZeroorone(AppealNode *parent) {
   // 2. If the child is succ, the major work of this loop is to verify the child's SuccMatch is
   //    consistent with parent's.
 
-  MASSERT((parent->mChildren.size() == 1) && "Zeroorone has >1 valid children?");
-  AppealNode *child = parent->mChildren.front();
+  MASSERT((parent->mChildren.GetNum() == 1) && "Zeroorone has >1 valid children?");
+  AppealNode *child = parent->mChildren.ValueAtIndex(0);
 
   if (child->IsFail() || child->IsNA())
     return;
@@ -1710,7 +2263,7 @@ void Parser::SortOutZeroorone(AppealNode *parent) {
   }
 
   // Finally add the only successful child to mSortedChildren
-  parent->mSortedChildren.push_back(child);
+  parent->mSortedChildren.PushBack(child);
   child->SetParent(parent);
 }
 
@@ -1742,13 +2295,15 @@ void Parser::SortOutConcatenate(AppealNode *parent) {
   SmallVector<AppealNode*> sorted_children;
   for (int i = rule_table->mNum - 1; i >= 0; i--) {
     TableData *data = rule_table->mData + i;
-    AppealNode *child = parent->FindSpecChild(data, last_match);
-    // It's possible that we find NO child if 'data' is a ZEROORxxx table
+    AppealNode *child = parent->FindIndexedChild(last_match, i);
+    // It's possible that we find NO child if 'data' is a ZEROORxxx table or ASI.
     bool good_child = false;
     if (!child) {
       if (data->mType == DT_Subtable) {
         RuleTable *table = data->mData.mEntry;
-        if (table->mType == ET_Zeroorone || table->mType == ET_Zeroormore)
+        if (table->mType == ET_Zeroorone || table->mType == ET_Zeroormore || table == &TblNoLineTerminator)
+          good_child = true;
+        if (table->mType == ET_ASI)
           good_child = true;
       }
       MASSERT(good_child);
@@ -1769,7 +2324,7 @@ void Parser::SortOutConcatenate(AppealNode *parent) {
 
   for (int i = sorted_children.GetNum() - 1; i >= 0; i--) {
     AppealNode *child = sorted_children.ValueAtIndex(i);
-    parent->mSortedChildren.push_back(child);
+    parent->mSortedChildren.PushBack(child);
     if (child->IsTable())
       to_be_sorted.push_back(child);
   }
@@ -1787,21 +2342,21 @@ void Parser::SortOutData(AppealNode *parent) {
   case DT_Subtable: {
     // There should be one child node, which represents the subtable.
     // we just need to add the child node to working list.
-    MASSERT((parent->mChildren.size() == 1) && "Should have only one child?");
-    AppealNode *child = parent->mChildren.front();
+    MASSERT((parent->mChildren.GetNum() == 1) && "Should have only one child?");
+    AppealNode *child = parent->mChildren.ValueAtIndex(0);
     child->SetFinalMatch(parent->GetFinalMatch());
     child->SetSorted();
     to_be_sorted.push_back(child);
-    parent->mSortedChildren.push_back(child);
+    parent->mSortedChildren.PushBack(child);
     child->SetParent(parent);
     break;
   }
   case DT_Token: {
     // token in table-data created a Child AppealNode
     // Just keep the child node. Don't need do anything.
-    AppealNode *child = parent->mChildren.front();
+    AppealNode *child = parent->mChildren.ValueAtIndex(0);
     child->SetFinalMatch(child->GetStartIndex());
-    parent->mSortedChildren.push_back(child);
+    parent->mSortedChildren.PushBack(child);
     child->SetParent(parent);
     break;
   }
@@ -1843,12 +2398,9 @@ void Parser::DumpSortOutNode(AppealNode *n) {
   unsigned dump_id = to_be_dumped_id.front();
   to_be_dumped_id.pop_front();
 
-  if (n->mSimplifiedIndex > 0)
-    std::cout << "[" << dump_id << ":" << n->mSimplifiedIndex<< "] ";
-  else
-    std::cout << "[" << dump_id << "] ";
+  std::cout << "[" << dump_id << ":" << n->GetChildIndex() << "] ";
   if (n->IsToken()) {
-    std::cout << "Token" << std::endl;
+    n->mData.mToken->Dump();
   } else {
     RuleTable *t = n->GetTable();
     std::cout << "Table " << GetRuleTableName(t) << "@" << n->GetStartIndex() << ": ";
@@ -1856,10 +2408,9 @@ void Parser::DumpSortOutNode(AppealNode *n) {
     if (n->mResult == SuccWasSucc)
       std::cout << "WasSucc";
 
-    std::vector<AppealNode*>::iterator it = n->mSortedChildren.begin();
-    for (; it != n->mSortedChildren.end(); it++) {
+    for (unsigned i = 0; i < n->mSortedChildren.GetNum(); i++) {
       std::cout << seq_num << ",";
-      to_be_dumped.push_back(*it);
+      to_be_dumped.push_back(n->mSortedChildren.ValueAtIndex(i));
       to_be_dumped_id.push_back(seq_num++);
     }
     std::cout << std::endl;
@@ -1905,9 +2456,8 @@ void Parser::FindWasSucc(AppealNode *root) {
           std::cout << "a token?" << std::endl;
       }
     } else {
-      std::vector<AppealNode*>::iterator it = node->mSortedChildren.begin();
-      for (; it != node->mSortedChildren.end(); it++)
-        working_list.push_back(*it);
+      for (unsigned i = 0; i < node->mSortedChildren.GetNum(); i++)
+        working_list.push_back(node->mSortedChildren.ValueAtIndex(i));
     }
   }
   return;
@@ -1950,7 +2500,7 @@ void Parser::FindPatchingNodes() {
 // This is another entry point of sort, similar as SortOut().
 // The only difference is we use 'reference' as the refrence of final match.
 void Parser::SupplementalSortOut(AppealNode *root, AppealNode *reference) {
-  MASSERT(root->mSortedChildren.size()==0 && "root should be un-sorted.");
+  MASSERT(root->mSortedChildren.GetNum()==0 && "root should be un-sorted.");
   MASSERT(root->IsTable() && "root should be a table node.");
 
   // step 1. Find the last matching token index we want.
@@ -2010,8 +2560,8 @@ void Parser::PatchWasSucc(AppealNode *root) {
       // it's the original tree. We don't want to mess it up. Think about it, if you
       // copy the mChildren to was_succ, there are duplicated tree nodes. This violates
       // the definition of the original tree.
-      for (unsigned j = 0; j < patch->mSortedChildren.size(); j++)
-        was_succ->AddSortedChild(patch->mSortedChildren[j]);
+      for (unsigned j = 0; j < patch->mSortedChildren.GetNum(); j++)
+        was_succ->AddSortedChild(patch->mSortedChildren.ValueAtIndex(j));
     }
   }
 
@@ -2031,7 +2581,7 @@ void Parser::PatchWasSucc(AppealNode *root) {
 void Parser::SimplifySortedTree() {
   // start with the only child of mRootNode.
   std::deque<AppealNode*> working_list;
-  working_list.push_back(mRootNode->mSortedChildren[0]);
+  working_list.push_back(mRootNode->mSortedChildren.ValueAtIndex(0));
 
   while(!working_list.empty()) {
     AppealNode *node = working_list.front();
@@ -2043,14 +2593,13 @@ void Parser::SimplifySortedTree() {
       continue;
     node = SimplifyShrinkEdges(node);
 
-    std::vector<AppealNode*>::iterator it = node->mSortedChildren.begin();
-    for (; it != node->mSortedChildren.end(); it++) {
-      working_list.push_back(*it);
+    for (unsigned i = 0; i < node->mSortedChildren.GetNum(); i++) {
+      working_list.push_back(node->mSortedChildren.ValueAtIndex(i));
     }
   }
 
   if (mTraceSortOut)
-    DumpSortOut(mRootNode->mSortedChildren[0], "Simplify AppealNode Trees");
+    DumpSortOut(mRootNode->mSortedChildren.ValueAtIndex(0), "Simplify AppealNode Trees");
 }
 
 // Reduce an edge is (1) Pred has only one succ
@@ -2069,31 +2618,31 @@ AppealNode* Parser::SimplifyShrinkEdges(AppealNode *node) {
 
   while(1) {
     // step 1. Check condition (1) (2)
-    if (node->mSortedChildren.size() != 1)
+    if (node->mSortedChildren.GetNum() != 1)
       break;
-    AppealNode *child = node->mSortedChildren[0];
+    AppealNode *child = node->mSortedChildren.ValueAtIndex(0);
 
     // step 2. Find out the index of child, through looking into sub-ruletable or token.
-    //         At this point, there is only one sorted child.
-    unsigned child_index;
-    bool found = node->GetSortedChildIndex(child, child_index);
-    if (!found) {
-      // There is one case where it cannot find child_index. In the left recursion
-      // parsing, each instance is connected to its previous one through the lead node.
-      // The connected two nodes are both lead rule table. We need remove one of them.
-      //
-      // In this case we don't worry about action since one of them is kept and the
-      // actions are kept actually.
 
-      RuleTable *rt_p = node->GetTable();
-      RuleTable *rt_c = child->GetTable();
-      MASSERT((rt_p == rt_c));
-      MASSERT(mRecursionAll.IsLeadNode(rt_p));
-    } else {
+    // There is one case where it cannot find child_index. In the left recursion
+    // parsing, each instance is connected to its previous one through the lead node.
+    // The connected two nodes are both lead rule table. We need remove one of them.
+    //
+    // In this case we don't worry about action since one of them is kept and the
+    // actions are kept actually.
+
+    bool skip = false;
+    RuleTable *rt_p = node->GetTable();
+    RuleTable *rt_c = child->GetTable();
+    if (rt_p == rt_c && mRecursionAll.IsLeadNode(rt_p))
+      skip = true;
+
+    unsigned child_index = child->GetChildIndex();
+    if (!skip) {
       // step 3. check condition (3)
       //         [NOTE] in RuleAction, element index starts from 1.
       RuleTable *rt = node->GetTable();
-      bool has_action = RuleActionHasElem(rt, child_index);
+      bool has_action = RuleActionHasElem(rt, child_index + 1);
       if (has_action)
         break;
     }
@@ -2103,14 +2652,8 @@ AppealNode* Parser::SimplifyShrinkEdges(AppealNode *node) {
     AppealNode *parent = node->GetParent();
     parent->ReplaceSortedChild(node, child);
 
-    // 1. mRootNode won't have RuleAction, so the index is never used.
-    // 2. 'index' just need be calculated once, at the first ancestor which is 'node'
-    //    transferred into this function.
-    if (parent != mRootNode && index == 0) {
-      found = parent->GetSortedChildIndex(node, index);
-      MASSERT(found && "Could not find child index?");
-    }
-    child->mSimplifiedIndex = index;
+    index = node->GetChildIndex();
+    child->SetChildIndex(index);
 
     // step 5. keep going
     node = child;
@@ -2123,20 +2666,20 @@ AppealNode* Parser::SimplifyShrinkEdges(AppealNode *node) {
 //                             Build the AST
 ////////////////////////////////////////////////////////////////////////////////////
 
-ASTTree* Parser::BuildAST() {
-  ASTTree *tree = new ASTTree();
+TreeNode* Parser::BuildAST() {
+  mLineModeRoot = NULL;
+  mNormalModeRoot = NULL;
 
   std::stack<AppealNode*> appeal_stack;
-  appeal_stack.push(mRootNode->mSortedChildren[0]);
+  appeal_stack.push(mRootNode->mSortedChildren.ValueAtIndex(0));
 
   // 1) If all children done. Time to create tree node for 'appeal_node'
   // 2) If some are done, some not. Add the first not-done child to stack
   while(!appeal_stack.empty()) {
     AppealNode *appeal_node = appeal_stack.top();
     bool children_done = true;
-    std::vector<AppealNode*>::iterator it = appeal_node->mSortedChildren.begin();
-    for (; it != appeal_node->mSortedChildren.end(); it++) {
-      AppealNode *child = *it;
+    for (unsigned i = 0; i < appeal_node->mSortedChildren.GetNum(); i++) {
+      AppealNode *child = appeal_node->mSortedChildren.ValueAtIndex(i);
       if (!child->AstCreated()) {
         appeal_stack.push(child);
         children_done = false;
@@ -2147,24 +2690,219 @@ ASTTree* Parser::BuildAST() {
     if (children_done) {
       // Create tree node when there is a rule table, or meanful tokens.
       MASSERT(!appeal_node->GetAstTreeNode());
-      TreeNode *sub_tree = tree->NewTreeNode(appeal_node);
+      TreeNode *sub_tree = NewTreeNode(appeal_node);
       if (sub_tree) {
         appeal_node->SetAstTreeNode(sub_tree);
-        // mRootNode is overwritten each time until the last one which is
+        // mNormalModeRoot is overwritten each time until the last one which is
         // the real root node.
-        tree->mRootNode = sub_tree;
+        mNormalModeRoot = sub_tree;
       }
-
       // pop out the 'appeal_node'
       appeal_node->SetAstCreated();
       appeal_stack.pop();
     }
   }
 
-  if (!tree->mRootNode)
-    MERROR("We got a statement failed to create AST!");
+  // The tree could be an empty statement like: ;
+
+  if (mLineMode)
+    mLineModeRoot = mNormalModeRoot;
+
+  return mNormalModeRoot;
+}
+
+// Create tree node. Its children have been created tree nodes.
+// There are couple issueshere.
+//
+// 1. An sorted AppealNode could have NO tree node, because it may have NO RuleAction to
+//    create the sub tree. This happens if the RuleTable is just a temporary intermediate
+//    table created by Autogen, or its rule is just ONEOF without real syntax. Here
+//    is an example.
+//
+//       The AST after BuildAST() for a simple statment: c=a+b;
+//
+//       ======= Simplify Trees Dump SortOut =======
+//       [1] Table TblExpressionStatement@0: 2,3,
+//       [2:1] Table TblAssignment@0: 4,5,6,
+//       [3] Token
+//       [4:1] Token
+//       [5:2] Token
+//       [6:3] Table TblArrayAccess_sub1@2: 7,8,  <-- supposed to get a binary expression
+//       [7:1] Token                              <-- a
+//       [8:2] Table TblUnaryExpression_sub1@3: 9,10, <-- +b
+//       [9] Token
+//       [10:2] Token
+//
+//    Node [1] won't have a tree node at all since it has no Rule Action attached.
+//    Node [6] won't have a tree node either.
+//
+// 2. A binary operation like a+b could be parsed as (1) expression: a, and (2) a
+//    unary operation: +b. This is because we parse them in favor to ArrayAccess before
+//    Binary Operation. Usually to handle this issue, in some system like ANTLR,
+//    they require you to list the priority, by writing rules from higher priority to
+//    lower priority.
+//
+//    We are going to do a consolidation of the sub-trees, by converting smaller trees
+//    to a more compact bigger trees. However, to do this we want to set some rules.
+//    *) The parent AppealNode of these sub-trees has no tree node. So the conversion
+//       helps make the tree complete.
+
+TreeNode* Parser::NewTreeNode(AppealNode *appeal_node) {
+  TreeNode *sub_tree = NULL;
+
+  if (appeal_node->IsToken()) {
+    sub_tree = mASTBuilder->CreateTokenTreeNode(appeal_node->GetToken());
+    return sub_tree;
+  }
+
+  RuleTable *rule_table = appeal_node->GetTable();
+
+  for (unsigned i = 0; i < rule_table->mNumAction; i++) {
+    Action *action = rule_table->mActions + i;
+    mASTBuilder->mActionId = action->mId;
+    mASTBuilder->ClearParams();
+
+    for (unsigned j = 0; j < action->mNumElem; j++) {
+      // find the appeal node child
+      unsigned elem_idx = action->mElems[j];
+      AppealNode *child = appeal_node->GetSortedChild(elem_idx - 1);
+      Param p;
+      p.mIsEmpty = true;
+      // There are 3 cases to handle.
+      // 1. child is token, we pass the token to param.
+      // 2. child is a sub appeal tree, but has no legal AST tree. For example,
+      //    a parameter list: '(' + param-lists + ')'.
+      //    if param-list is empty, it has no AST tree.
+      //    In this case, we sset mIsEmpty to true.
+      // 3. chidl is a sub appeal tree, and has a AST tree too.
+      if (child) {
+        TreeNode *tree_node = child->GetAstTreeNode();
+        if (!tree_node) {
+          if (child->IsToken()) {
+            p.mIsEmpty = false;
+            p.mIsTreeNode = false;
+            p.mData.mToken = child->GetToken();
+          }
+        } else {
+          p.mIsEmpty = false;
+          p.mIsTreeNode = true;
+          p.mData.mTreeNode = tree_node;
+        }
+      }
+      mASTBuilder->AddParam(p);
+    }
+
+    // For multiple actions of a rule, there should be only action which create tree.
+    // The others are just for adding attribute or else, and return the same tree
+    // with additional attributes.
+    sub_tree = mASTBuilder->Build();
+  }
+
+  if (sub_tree)
+    return sub_tree;
+
+  // It's possible that the Rule has no action, meaning it cannot create tree node.
+  // Now we have to do some manipulation. Please check if you need all of them.
+  sub_tree = Manipulate(appeal_node);
+
+  // It's possible that the sub tree is actually empty. For example, in a Parameter list
+  // ( params ). If 'params' is empty, it returns NULL.
+
+  return sub_tree;
+}
+
+// It's possible that we get NULL tree.
+TreeNode* Parser::Manipulate(AppealNode *appeal_node) {
+  TreeNode *sub_tree = NULL;
+
+  std::vector<TreeNode*> child_trees;
+  for (unsigned i = 0; i < appeal_node->mSortedChildren.GetNum(); i++) {
+    AppealNode *a_node = appeal_node->mSortedChildren.ValueAtIndex(i);
+    TreeNode *t_node = a_node->GetAstTreeNode();
+    if (t_node)
+      child_trees.push_back(t_node);
+  }
+
+  // If we have one and only one child's tree node, we take it.
+  if (child_trees.size() == 1) {
+    sub_tree = child_trees[0];
+    if (sub_tree)
+      return sub_tree;
+    else
+      MERROR("We got a broken AST tree, not connected sub tree.");
+  }
+
+  // For the tree having two children, there are a few approaches to further
+  // manipulate them in order to obtain better AST.
+  //
+  // 1. There are cases like (type)value, but they are not recoganized as cast.
+  //    Insteand they are seperated into two nodes, one is (type), the other value.
+  //    So we define ParenthesisNode for (type), and build a CastNode over here.
+  //
+  // 2. There are cases like a+b could be parsed as "a" and "+b", a symbol and a
+  //    unary operation. However, we do prefer binary operation than unary. So a
+  //    combination is needed here, especially when the parent node is NULL.
+  if (child_trees.size() == 2) {
+    TreeNode *child_a = child_trees[0];
+    TreeNode *child_b = child_trees[1];
+
+    sub_tree = Manipulate2Cast(child_a, child_b);
+    if (sub_tree)
+      return sub_tree;
+  }
+
+  // In the end, if we still have no suitable solution to create the tree,
+  //  we will put subtrees into a PassNode to pass to parent.
+  if (child_trees.size() > 0) {
+    PassNode *pass = (PassNode*)BuildPassNode();
+    std::vector<TreeNode*>::iterator child_it = child_trees.begin();
+    for (; child_it != child_trees.end(); child_it++)
+      pass->AddChild(*child_it);
+    return pass;
+  }
+
+  // It's possible that we get a Null tree.
+  return sub_tree;
+}
 
-  return tree;
+TreeNode* Parser::Manipulate2Cast(TreeNode *child_a, TreeNode *child_b) {
+  if (child_a->IsParenthesis()) {
+    ParenthesisNode *type = (ParenthesisNode*)child_a;
+    CastNode *n = (CastNode*)gTreePool.NewTreeNode(sizeof(CastNode));
+    new (n) CastNode();
+    n->SetDestType(type->GetExpr());
+    n->SetExpr(child_b);
+    return n;
+  }
+  return NULL;
+}
+
+TreeNode* Parser::Manipulate2Binary(TreeNode *child_a, TreeNode *child_b) {
+  if (child_b->IsUnaOperator()) {
+    UnaOperatorNode *unary = (UnaOperatorNode*)child_b;
+    unsigned property = GetOperatorProperty(unary->GetOprId());
+    if ((property & Binary) && (property & Unary)) {
+      std::cout << "Convert unary --> binary" << std::endl;
+      TreeNode *unary_sub = unary->GetOpnd();
+      TreeNode *binary = BuildBinaryOperation(child_a, unary_sub, unary->GetOprId());
+      return binary;
+    }
+  }
+  return NULL;
+}
+
+TreeNode* Parser::BuildBinaryOperation(TreeNode *childA, TreeNode *childB, OprId id) {
+  BinOperatorNode *n = (BinOperatorNode*)gTreePool.NewTreeNode(sizeof(BinOperatorNode));
+  new (n) BinOperatorNode(id);
+  n->SetOpndA(childA);
+  n->SetOpndB(childB);
+  return n;
+}
+
+TreeNode* Parser::BuildPassNode() {
+  PassNode *n = (PassNode*)gTreePool.NewTreeNode(sizeof(PassNode));
+  new (n) PassNode();
+  return n;
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ -2280,8 +3018,8 @@ bool SuccMatch::IsDone() {
 void AppealNode::AddParent(AppealNode *p) {
   if (!mParent || mParent->IsPseudo())
     mParent = p;
-  else
-    mSecondParents.PushBack(p);
+  //else
+  //  mSecondParents.PushBack(p);
   return;
 }
 
@@ -2324,47 +3062,11 @@ void AppealNode::CopyMatch(AppealNode *another) {
     mResult = another->mResult;
 }
 
-// return true if 'parent' is a parent of this.
-bool AppealNode::DescendantOf(AppealNode *parent) {
-  AppealNode *node = mParent;
-  while (node) {
-    if (node == parent)
-      return true;
-    node = node->mParent;
-  }
-  return false;
-}
-
-// Returns true, if both nodes are successful and match the same tokens
-// with the same rule table
-bool AppealNode::SuccEqualTo(AppealNode *other) {
-  if (IsSucc() && other->IsSucc() && mStartIndex == other->GetStartIndex()) {
-    if (IsToken() && other->IsToken()) {
-      return GetToken() == other->GetToken();
-    } else if (IsTable() && other->IsTable()) {
-      return GetTable() == other->GetTable();
-    }
-  }
-  return false;
-}
-
-void AppealNode::RemoveChild(AppealNode *child) {
-  std::vector<AppealNode*> temp_vector;
-  std::vector<AppealNode*>::iterator it = mChildren.begin();
-  for (; it != mChildren.end(); it++) {
-    if (*it != child)
-      temp_vector.push_back(*it);
-  }
-
-  mChildren.clear();
-  mChildren.assign(temp_vector.begin(), temp_vector.end());
-}
-
 void AppealNode::ReplaceSortedChild(AppealNode *existing, AppealNode *replacement) {
   unsigned index;
   bool found = false;
-  for (unsigned i = 0; i < mSortedChildren.size(); i++) {
-    if (mSortedChildren[i] == existing) {
+  for (unsigned i = 0; i < mSortedChildren.GetNum(); i++) {
+    if (mSortedChildren.ValueAtIndex(i) == existing) {
       index = i;
       found = true;
       break;
@@ -2372,126 +3074,32 @@ void AppealNode::ReplaceSortedChild(AppealNode *existing, AppealNode *replacemen
   }
   MASSERT(found && "ReplaceSortedChild could not find existing node?");
 
-  mSortedChildren[index] = replacement;
+  *(mSortedChildren.RefAtIndex(index)) = replacement;
   replacement->SetParent(this);
 }
 
-// Returns true : if successfully found the index.
-// [NOTE] This is the index in the Rule Spec description, which are used in the
-//        building of AST. So remember it starts from 1.
-//
-// The AppealNode tree has many messy nodes generated during second try, or others.
-// It's not a good idea to find the index through the tree. The final real solution
-// is to go through the RuleTable and locate the child's index.
-bool AppealNode::GetSortedChildIndex(AppealNode *child, unsigned &index) {
-  bool found = false;
-  MASSERT(IsTable() && "Parent node is not a RuleTable");
-  RuleTable *rule_table = GetTable();
-
-  // In SimplifyShrinkEdge, the tree could be simplified and a node could be given an index
-  // to his ancestor.
-  if (child->mSimplifiedIndex != 0) {
-    index = child->mSimplifiedIndex;
-    return true;
-  }
-
-  // If the edge is not shrinked, we just look into the rule tabls or tokens.
-  for (unsigned i = 0; i < rule_table->mNum; i++) {
-    TableData *data = rule_table->mData + i;
-    switch (data->mType) {
-    case DT_Token: {
-      Token *t = &gSystemTokens[data->mData.mTokenId];
-      if (child->IsToken() && child->GetToken() == t) {
-        found = true;
-        index = i+1;
-      }
-      break;
-    }
-    case DT_Subtable: {
-      RuleTable *t = data->mData.mEntry;
-      if (t == &TblIdentifier) {
-        if (child->IsToken()) {
-          Token *token = child->GetToken();
-          if (token->IsIdentifier()) {
-            found = true;
-            index = i+1;
-          }
-        }
-      } else if (t == &TblLiteral) {
-        if (child->IsToken()) {
-          Token *token = child->GetToken();
-          if (token->IsLiteral()) {
-            found = true;
-            index = i+1;
-          }
-        }
-      } else if (child->IsTable() && child->GetTable() == t) {
-        found = true;
-        index = i+1;
-      }
-      break;
-    }
-    case DT_String:
-    case DT_Char:
-      break;
-    default:
-      MASSERT(0 && "Unknown entry in TableData");
-      break;
-    }
-  }
-
-  return found;
-}
-
-AppealNode* AppealNode::GetSortedChildByIndex(unsigned index) {
-  std::vector<AppealNode*>::iterator it = mSortedChildren.begin();
-  for (; it != mSortedChildren.end(); it++) {
-    AppealNode *child = *it;
-    unsigned id = 0;
-    bool found = GetSortedChildIndex(child, id);
-    MASSERT(found && "sorted child has no index..");
+AppealNode* AppealNode::GetSortedChild(unsigned index) {
+  for (unsigned i = 0; i < mSortedChildren.GetNum(); i++) {
+    AppealNode *child = mSortedChildren.ValueAtIndex(i);
+    unsigned id = child->GetChildIndex();
     if (id == index)
       return child;
   }
   return NULL;
 }
 
-// Look for a specific un-sorted child having the ruletable/token and match.
-// There could be multiple, but we return the first good one.
-AppealNode* AppealNode::FindSpecChild(TableData *tdata, unsigned match) {
+// Look for a specific un-sorted child having the child index and match.
+AppealNode* AppealNode::FindIndexedChild(unsigned match, unsigned index) {
   AppealNode *ret_child = NULL;
-
-  std::vector<AppealNode*>::iterator it = mChildren.begin();
-  for (; it != mChildren.end(); it++) {
-    AppealNode *child = *it;
-    if (child->IsSucc() && child->FindMatch(match)) {
-      switch (tdata->mType) {
-      case DT_Subtable: {
-        RuleTable *child_rule = tdata->mData.mEntry;
-        if (child->IsTable() && child->GetTable() == child_rule)
-          ret_child = child;
-        // Literal and Identifier are treated as token.
-        if (child->IsToken() && (child_rule == &TblLiteral || child_rule == &TblIdentifier))
-          ret_child = child;
-        break;
-      }
-      case DT_Token: {
-        Token *token = &gSystemTokens[tdata->mData.mTokenId];
-        if ( child->IsToken() &&
-             ((child->GetToken() == token) || (child->mAltToken == token)))
-          ret_child = child;
-        break;
-      }
-      case DT_Char:
-      case DT_String:
-      case DT_Type:
-      case DT_Null:
-      default:
-        break;
-      }
+  for (unsigned i = 0; i < mChildren.GetNum(); i++) {
+    AppealNode *child = mChildren.ValueAtIndex(i);
+    if (child->IsSucc() &&
+        child->FindMatch(match) &&
+        (index == child->GetChildIndex())) {
+      ret_child = child;
+      break;
     }
   }
-
   return ret_child;
 }
 
diff --git a/src/MapleFE/shared/src/parser_rec.cpp b/src/MapleFE/shared/src/parser_rec.cpp
index d5fe65357bf228b316554bd64741c7c55d291d99..615b78d63a065ed6bb1798dcee738794a1654ae6 100644
--- a/src/MapleFE/shared/src/parser_rec.cpp
+++ b/src/MapleFE/shared/src/parser_rec.cpp
@@ -21,7 +21,7 @@
 #include "parser.h"
 #include "parser_rec.h"
 #include "ruletable_util.h"
-#include "gen_summary.h"
+#include "rule_summary.h"
 
 namespace maplefe {
 
@@ -182,7 +182,7 @@ bool RecursionTraversal::ConnectPrevious(AppealNode *curr_node) {
       // will handle the multiple parents issue.
       curr_node->AddChild(prev_lead);
       prev_lead->AddParent(curr_node);
-      
+
       // there should be only one match.
       MASSERT(!found);
       found = true;
@@ -217,8 +217,12 @@ bool RecursionTraversal::FindInstances() {
     mVisitedRecursionNodes.Clear();
     mLeadNodes.Clear();
 
-    // Find the instance
+    // Find the instance.
+    // Remember to reset mEndOfFile since the prev instance could reach the end of file
+    // We need start from the beginning.
     mParser->mCurToken = saved_mCurToken;
+    if (mParser->mEndOfFile)
+      mParser->mEndOfFile = false;
     temp_found = FindRestInstance();
   }
 
@@ -251,9 +255,9 @@ bool RecursionTraversal::FindFirstInstance() {
 
   // Appealing of the mistaken Fail nodes.
   //
-  // This is for appealing those affected by the 1st appearance
-  // of 1st instance which returns false. 1stOf1st is not add to WasFail, but
-  // those affected will be added to WasFail.
+  // This is for appealing those affected by the 2nd appearance
+  // of 2nd instance which returns false. 2ndOf1st is not add to WasFail, but
+  // those affected will be AddFailed().
   //
   // I still keep an assertion in TraverseRuleTablePre() when it has SuccMatch,
   // asserting !WasFail. But I believe there are still WasFail at the same time.
@@ -281,7 +285,6 @@ bool RecursionTraversal::FindRestInstance() {
   AppealNode *lead = new AppealNode();
   lead->SetStartIndex(mStartToken);
   lead->SetTable(mRuleTable);
-  mParser->mAppealNodes.push_back(lead);
 
   AddLeadNode(lead);
   AddVisitedLeadNode(mRuleTable);
diff --git a/src/MapleFE/shared/src/recursion.cpp b/src/MapleFE/shared/src/recursion.cpp
index dc08a2d1a283582ea43824d381d14ee87ed4b7dd..c67f4e88ccd95427ea286ce43368c5c4d38e1652 100644
--- a/src/MapleFE/shared/src/recursion.cpp
+++ b/src/MapleFE/shared/src/recursion.cpp
@@ -20,8 +20,7 @@
 /////////////////////////////////////////////////////////////////////////////////////
 
 #include "recursion.h"
-#include "gen_summary.h"
-#include "gen_token.h"
+#include "rule_summary.h"
 #include "token.h"
 
 namespace maplefe {
@@ -275,7 +274,7 @@ void Recursion::FindFronNodes(unsigned circle_index) {
     case ET_Oneof: {
       // Look into every childof 'prev'. If it's not 'next' and
       // not in 'mRecursionNodes', it's a FronNode.
-      // 
+      //
       // [NOTE] This is a per circle algorithm. So a FronNode found here could
       //        be a recursion node in another circle.
       // Actually if it's Recursion node, we can still include it as FronNode,
@@ -290,7 +289,7 @@ void Recursion::FindFronNodes(unsigned circle_index) {
           fnode.mData.mToken = &gSystemTokens[data->mData.mTokenId];
           fron_nodes->PushBack(fnode);
           //std::cout << "  Token " << data->mData.mToken->GetName() << std::endl;
-        } else if (data->mType = DT_Subtable) {
+        } else if (data->mType == DT_Subtable) {
           RuleTable *ruletable = data->mData.mEntry;
           bool found = IsRecursionNode(ruletable);
           if (!found && (ruletable != next)) {
diff --git a/src/MapleFE/shared/src/ruletable_util.cpp b/src/MapleFE/shared/src/ruletable_util.cpp
index 3b6049e2430cfbd3e7cd29d0065d2c57c224a0f5..65dc85557fe634d3dece1f2f5ae82b1f5d576f18 100644
--- a/src/MapleFE/shared/src/ruletable_util.cpp
+++ b/src/MapleFE/shared/src/ruletable_util.cpp
@@ -16,9 +16,8 @@
 
 #include "ruletable_util.h"
 #include "lexer.h"
-#include "lang_spec.h"
 #include "massert.h"
-#include "common_header_autogen.h"
+#include "rule_summary.h"
 #include "container.h"
 
 namespace maplefe {
@@ -40,7 +39,7 @@ SepId FindSeparator(const char *str, const char c, unsigned &len) {
     text = c;
 
   unsigned i = 0;
-  for (; i < SEP_NA; i++) {
+  for (; i < SepTableSize; i++) {
     SepTableEntry e = SepTable[i];
     if (!strncmp(text.c_str(), e.mText, strlen(e.mText))) {
       len = strlen(e.mText);
@@ -63,7 +62,7 @@ OprId FindOperator(const char *str, const char c, unsigned &len) {
     text = c;
 
   unsigned i = 0;
-  for (; i < OPR_NA; i++) {
+  for (; i < OprTableSize; i++) {
     OprTableEntry e = OprTable[i];
     if (!strncmp(text.c_str(), e.mText, strlen(e.mText))) {
       len = strlen(e.mText);
@@ -100,12 +99,20 @@ const char* FindKeyword(const char *str, const char c, unsigned &len) {
 
 // Returns true : The rule actions in 'table' involves i-th element
 // [NOTE] i starts from 1.
+//
+// If there is an action which has no elem as its argument. It could
+// take all element, or any number of element. In this case, we think
+// it HasElem.  Please look at typescript's stmt.spec.
+//   rule JSIdentifier: is a good example.
+//
 bool RuleActionHasElem(RuleTable *table, unsigned target_idx) {
   for (unsigned i = 0; i < table->mNumAction; i++) {
     Action *act = table->mActions + i;
+    if (act->mNumElem == 0)
+      return true;
     for (unsigned j = 0; j < act->mNumElem; j++) {
       unsigned index = act->mElems[j];
-      if (index = target_idx)
+      if (index == target_idx)
         return true;
     }
   }
diff --git a/src/MapleFE/shared/src/stringmap.cpp b/src/MapleFE/shared/src/stringmap.cpp
index 00103b1d35155b00cd0021371cf6b1b935d18b0d..4327e40f7d99d464907d6c7d18599e14d7cca561 100644
--- a/src/MapleFE/shared/src/stringmap.cpp
+++ b/src/MapleFE/shared/src/stringmap.cpp
@@ -40,17 +40,17 @@ StringMap::~StringMap() {
       temp = entry->Next;
       delete entry;
       entry = temp;
-    } 
+    }
   }
 
   delete [] mBuckets;
 }
 
 void StringMap::Init(unsigned Num) {
-  MASSERT((Num & (Num-1)) == 0 && 
-        "Init Size must be a power of 2 or zero!"); 
-  mNumBuckets = Num ? Num : DEFAULT_BUCKETS_NUM; 
-   
+  MASSERT((Num & (Num-1)) == 0 &&
+        "Init Size must be a power of 2 or zero!");
+  mNumBuckets = Num ? Num : DEFAULT_BUCKETS_NUM;
+
   mBuckets = new StringMapEntry[mNumBuckets];
   StringMapEntry *E = mBuckets;
   for (unsigned i = 0; i < mNumBuckets; i++, E++) {
@@ -60,20 +60,20 @@ void StringMap::Init(unsigned Num) {
 }
 
 // Get the bucket no for 'S'.
-unsigned StringMap::BucketNoFor(const std::string &S) { 
-  unsigned HTSize = mNumBuckets; 
-  if (HTSize == 0) {  // Hash table unallocated so far? 
-    Init(DEFAULT_BUCKETS_NUM); 
-    HTSize = mNumBuckets; 
-  } 
-  unsigned FullHashValue = HashString(S); 
-  unsigned BucketNo = FullHashValue & (HTSize-1); 
-  return BucketNo;  
-} 
+unsigned StringMap::BucketNoFor(const std::string &S) {
+  unsigned HTSize = mNumBuckets;
+  if (HTSize == 0) {  // Hash table unallocated so far?
+    Init(DEFAULT_BUCKETS_NUM);
+    HTSize = mNumBuckets;
+  }
+  unsigned FullHashValue = HashString(S);
+  unsigned BucketNo = FullHashValue & (HTSize-1);
+  return BucketNo;
+}
 
 // Look up to find the address in the string pool of 'S'.
 // If 'S' is not in the string pool, insert it.
-char* StringMap::LookupAddrFor(const std::string &S) { 
+StringMapEntry *StringMap::LookupEntryFor(const std::string &S) {
   unsigned BucketNo = BucketNoFor(S);
   StringMapEntry *E = &mBuckets[BucketNo];
 
@@ -82,32 +82,37 @@ char* StringMap::LookupAddrFor(const std::string &S) {
   if (E && !E->Addr && !E->Next) {
     char *addr = mPool->Alloc(S);
     E->Addr = addr;
-    return addr;
+    E->StrIdx = mPool->mStringTable.size();
+    mPool->mStringTable.push_back(addr);
+    return E;
   }
-  
+
   while (E && E->Addr) {
-    if (S.compare(E->Addr) == 0)
-      return E->Addr;
+    if (S.compare(E->Addr) == 0) {
+      return E;
+    }
     E = E->Next;
   }
-   
-  // We cannot find an existing string for 'S'. Need to allocate
-  char *Addr = mPool->Alloc(S);
-  InsertEntry(Addr, BucketNo);
 
-  return Addr;
-} 
+  // We cannot find an existing string for 'S'. Need to allocate
+  char *addr = mPool->Alloc(S);
+  unsigned idx = mPool->mStringTable.size();
+  mPool->mStringTable.push_back(addr);
+  E = InsertEntry(addr, idx, BucketNo);
+  return E;
+}
 
 // Add a new entry in 'bucket'.
 // 'addr' is the address in the string pool
-void StringMap::InsertEntry(char *addr, unsigned bucket) {
+StringMapEntry *StringMap::InsertEntry(char *addr, unsigned idx, unsigned bucket) {
   StringMapEntry *E = &mBuckets[bucket];
   while (E->Next) {
     E = E->Next;
   }
 
-  StringMapEntry *NewEnt = new StringMapEntry(addr);
+  StringMapEntry *NewEnt = new StringMapEntry(addr, idx);
   E->Next = NewEnt;
+  return NewEnt;
 }
 }
 
diff --git a/src/MapleFE/shared/src/stringpool.cpp b/src/MapleFE/shared/src/stringpool.cpp
index eb5d6b6861ee0531272edd233e1e58c55078ab9b..3b6e292486e4199e33c3347bc6bc941298d08b41 100644
--- a/src/MapleFE/shared/src/stringpool.cpp
+++ b/src/MapleFE/shared/src/stringpool.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -20,10 +20,10 @@
 
 #include <cstdlib>
 #include <cstring>
+#include <stdlib.h>
 
 #include "stringpool.h"
 #include "stringmap.h"
-#include "massert.h"
 
 namespace maplefe {
 
@@ -32,9 +32,14 @@ namespace maplefe {
 StringPool gStringPool;
 
 StringPool::StringPool() {
+  mUseAltStr = false;
   mMap = new StringMap();
   mMap->SetPool(this);
   mFirstAvail = -1;
+  // make string idx starting from 1
+  mStringTable.push_back("");
+  // empty string idx is 1
+  mStringTable.push_back("");
 }
 
 StringPool::~StringPool() {
@@ -45,7 +50,16 @@ StringPool::~StringPool() {
     char *addr = block.Addr;
     free(addr);
   }
-  
+  mStringTable.clear();
+
+  // Release the long strings
+  std::vector<char*>::iterator long_it;
+  for (long_it = mLongStrings.begin(); long_it != mLongStrings.end(); long_it++) {
+    char *addr = *long_it;
+    free(addr);
+  }
+  mLongStrings.clear();
+
   // Release the StringMap
   delete mMap;
 }
@@ -57,11 +71,14 @@ char* StringPool::Alloc(const std::string &s) {
 // 's' must guarantee to end with NULL
 char* StringPool::Alloc(const char *s) {
   size_t size = strlen(s) + 1;
+  char *addr = NULL;
   if (size > BLOCK_SIZE) {
-    MERROR ("Requsted size is bigger than block size");
+    addr = (char*)malloc(size);
+    mLongStrings.push_back(addr);
+  } else {
+    addr = Alloc(size);
   }
 
-  char *addr = Alloc(size);
   MASSERT (addr && "StringPool failed to alloc for string");
 
   strncpy(addr, s, size - 1);
@@ -114,24 +131,151 @@ char* StringPool::AllocBlock() {
 }
 
 // This is the public interface to find a string in the pool.
-// If not found, add it.
+// If not found, allocate in the pool and save in the map.
 const char* StringPool::FindString(const std::string &s) {
-  return mMap->LookupAddrFor(s);
+  return mMap->LookupEntryFor(s)->GetAddr();
 }
 
 // This is the public interface to find a string in the pool.
-// If not found, add it.
+// If not found, allocate in the pool and save in the map.
 const char* StringPool::FindString(const char *str) {
   std::string s(str);
-  return mMap->LookupAddrFor(s);
+  return mMap->LookupEntryFor(s)->GetAddr();
 }
 
 // This is the public interface to find a string in the pool.
-// If not found, add it.
+// If not found, allocate in the pool and save in the map.
 const char* StringPool::FindString(const char *str, size_t len) {
   std::string s;
   s.assign(str, len);
-  return mMap->LookupAddrFor(s);
+  return mMap->LookupEntryFor(s)->GetAddr();
+}
+
+// This is the public interface to find a string in the pool.
+// If not found, allocate in the pool and save in the map.
+unsigned StringPool::GetStrIdx(const std::string &s) {
+  if (s.empty()) return 1;
+  return mMap->LookupEntryFor(s)->GetStrIdx();
+}
+
+// This is the public interface to find a string in the pool.
+// If not found, allocate in the pool and save in the map.
+unsigned StringPool::GetStrIdx(const char *str) {
+  if (strlen(str) == 0) return 1;
+  std::string s(str);
+  return mMap->LookupEntryFor(s)->GetStrIdx();
+}
+
+// This is the public interface to find a string in the pool.
+// If not found, allocate in the pool and save in the map.
+unsigned StringPool::GetStrIdx(const char *str, size_t len) {
+  if (len == 0) return 1;
+  std::string s;
+  s.assign(str, len);
+  return mMap->LookupEntryFor(s)->GetStrIdx();
+}
+
+const char *StringPool::GetStringFromStrIdx(unsigned idx) {
+  MASSERT(idx < mStringTable.size() && "string index out of range");
+  if (mUseAltStr) {
+    if (mAltStrIdxMap.find(idx) != mAltStrIdxMap.end()) {
+      idx = mAltStrIdxMap[idx];
+    }
+  }
+  return mStringTable[idx];
+}
+
+// This is the public interface to setup AltStrIdxMap used for obfuscation
+// a name is mapped to a fixed length random unused name.
+// starting from 2-letter names, [a-zA-Z] [a-zA-Z], which will cover over 2K names
+// AA Aa AB Ab, ...., zz
+// if not enough will extend to use 3-letter or 4-letter for over 7 million names
+void StringPool::SetAltStrIdxMap() {
+  // starting from 2-letter names
+  unsigned len = 2;
+  bool done = false;
+
+  // names use [A-Z] and [a-z] total 52 letters
+  int k = 52;
+
+  // total number of names can be handled for len = 4, 3, 2, 1 respectively
+  int Size[4] = {k*k*k*k, k*k*k, k*k, k};
+
+  // names, trailing '\0'
+  char A[5] = {0, 0, 0, 0, 0};
+
+  // names already encounted, either existing name or new names
+  std::unordered_set<unsigned> used;
+
+  for (auto stridx : mAltStrIdxSet) {
+    done = false;
+    while (!done) {
+      unsigned offset = 4 - len;
+      int mod = Size[offset];
+
+      int n = rand();
+      int r = n % mod;
+
+      // check if already encounted
+      if (used.find(r) != used.end()) {
+        // expand to use one more leter if close to limit
+        if (used.size() > mod - Size[offset + 1]) {
+          len++;
+          MASSERT(len < 5 && "Need more names");
+        }
+        continue;
+      }
+
+      // have un-encounted name
+      used.insert(r);
+
+      int q;
+      bool odd;
+      int i = 0;
+      while (i < len - 1) {
+        mod = Size[offset + 1 + i];
+        q = r / mod;
+        r = r % mod;
+
+        // char, use upper case for odd number
+        odd = q%2;
+        A[i++] = (odd ? 'A' : 'a') + q/2;
+      }
+
+      // last char, use upper case for odd number
+      odd = r%2;
+      A[i] = (odd ? 'A' : 'a') + r/2;
+
+      unsigned size = GetSize();
+      unsigned alt = GetStrIdx(A);
+      // make sure alt is a new string
+      if (alt == size) {
+        mAltStrIdxMap[stridx] = alt;
+        done = true;
+      }
+    }
+  }
 }
+
+void StringPool::Dump() {
+  std::cout << "===================== StringTable =====================" << std::endl;
+  for (unsigned idx = 1; idx < mStringTable.size(); idx++) {
+    std::cout << "  " << idx << " : " << mStringTable[idx] << std::endl;
+  }
+}
+
+void StringPool::DumpAlt() {
+  std::cout << "================= Alt String Map ======================" << std::endl;
+  unsigned count = 0;
+  for (auto stridx : mAltStrIdxSet) {
+    unsigned alt = mAltStrIdxMap[stridx];
+    std::cout << "count #" << stridx
+              << " str " << GetStringFromStrIdx(stridx)
+              << " --> "
+              << " alt " << GetStringFromStrIdx(alt)
+              << std::endl;
+  }
+}
+
 }
 
diff --git a/src/MapleFE/shared/src/stringutil.cpp b/src/MapleFE/shared/src/stringutil.cpp
index a3d8a5163c4c2831d9cedcd050eab46ff44c4e5f..f524c99a65609df284a42e5d08f4485a56ea8297 100644
--- a/src/MapleFE/shared/src/stringutil.cpp
+++ b/src/MapleFE/shared/src/stringutil.cpp
@@ -175,42 +175,24 @@ Char StringToValue::StringToChar(std::string &str) {
 //    When parser read it, it's just a plain text file. So it will see 6 characters actually.
 //    The backslash is itself a character.
 //    After parser read this string into buffer, you can see it in gdb is "test\\n".
-//
-// 4. StringToValue need convert the two characters into an escape character.
-//    This is what we are doing here.
+//    Lexer and Parser will keep what they saw.
 
-const char* StringToValue::StringToString(std::string &str) {
+const char* StringToValue::StringToString(std::string &in_str) {
   std::string target;
-  for (unsigned i = 0; i < str.size(); i++) {
-    char c = str[i];
-    if ((c == '\\') && (i < str.size() - 1)) {
-      char c_next = str[i+1];
-      char c_target = 0;
-      if (c_next == 'n')
-        c_target = '\n';
-      else if (c_next == '\\')
-        c_target = '\\';
-      else if (c_next == '\'')
-        c_target = '\'';
-      else if (c_next == '\"')
-        c_target = '\"';
-      else if (c_next == 'b')
-        c_target = '\b';
-      else if (c_next == 'f')
-        c_target = '\f';
-      else if (c_next == 'r')
-        c_target = '\r';
-
-      if (c_target) {
-        target += c_target;
-        i++;
-      }
-    } else {
-      target += c;
-    }
+
+  // For most languages, the input 'in_str' still contains the leading " or ' and the
+  // ending " or '. They need to be removed.
+  std::string str;
+
+  // If empty string literal, return the empty 'target'.
+  if (in_str.size() == 2) {
+    const char *s = gStringPool.FindString(target);
+    return s;
+  } else {
+    str.assign(in_str, 1, in_str.size() - 2);
   }
 
-  const char *s = gStringPool.FindString(target);
+  const char *s = gStringPool.FindString(str);
   return s;
 }
 
diff --git a/src/MapleFE/shared/src/token.cpp b/src/MapleFE/shared/src/token.cpp
index 38141cea10e3ae09302063c6687fa4ff97b742d3..39b20a15fe084e9007cf60667d4b3233f7e86ce6 100644
--- a/src/MapleFE/shared/src/token.cpp
+++ b/src/MapleFE/shared/src/token.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -13,8 +13,13 @@
 * See the Mulan PSL v2 for more details.
 */
 #include "token.h"
+#include "stringpool.h"
+#include "rule_summary.h"
 #include "massert.h"
 
+#include <string.h>
+#include <string>
+
 namespace maplefe {
 
 #undef  SEPARATOR
@@ -29,7 +34,7 @@ const char* SeparatorTokenGetName(SepId id) {
 
 void SeparatorTokenDump(SepId id) {
   const char *name = SeparatorTokenGetName(id);
-  DUMP1("Separator  Token: ", name);
+  DUMP1_NORETURN("Separator  Token: ", name);
   return;
 }
 
@@ -45,34 +50,34 @@ const char* OperatorTokenGetName(OprId id) {
 
 void OperatorTokenDump(OprId id) {
   const char *name = OperatorTokenGetName(id);
-  DUMP1("Operator   Token: ", name);
+  DUMP1_NORETURN("Operator   Token: ", name);
   return;
 }
 
 void LiteralTokenDump(LitData data) {
   switch (data.mType) {
   case LT_IntegerLiteral:
-    DUMP1("Integer Literal Token:", data.mData.mInt);
+    DUMP1_NORETURN("Integer Literal Token:", data.mData.mInt);
     break;
   case LT_FPLiteral:
-    DUMP1("Floating Literal Token:", data.mData.mFloat);
+    DUMP1_NORETURN("Floating Literal Token:", data.mData.mFloat);
     break;
   case LT_DoubleLiteral:
-    DUMP1("Double Literal Token:", data.mData.mDouble);
+    DUMP1_NORETURN("Double Literal Token:", data.mData.mDouble);
     break;
   case LT_BooleanLiteral:
-    DUMP1("Boolean Literal Token:", data.mData.mBool);
+    DUMP1_NORETURN("Boolean Literal Token:", data.mData.mBool);
     break;
   case LT_CharacterLiteral: {
     Char the_char = data.mData.mChar;
     if (the_char.mIsUnicode)
-      DUMP1("Char Literal Token(Unicode):", the_char.mData.mUniValue);
+      DUMP1_NORETURN("Char Literal Token(Unicode):", the_char.mData.mUniValue);
     else
-      DUMP1("Char Literal Token:", the_char.mData.mChar);
+      DUMP1_NORETURN("Char Literal Token:", the_char.mData.mChar);
     break;
   }
   case LT_StringLiteral:
-    DUMP1("String Literal Token:", data.mData.mStr);
+    DUMP1_NORETURN("String Literal Token:", gStringPool.GetStringFromStrIdx(data.mData.mStrIdx));
     break;
   case LT_NullLiteral:
     DUMP0("Null Literal Token:");
@@ -104,19 +109,128 @@ void Token::Dump() {
     OperatorTokenDump(mData.mOprId);
     break;
   case TT_ID:
-    DUMP1("Identifier Token: ", mData.mName);
+    DUMP1_NORETURN("Identifier Token: ", mData.mName);
     break;
   case TT_KW:
-    DUMP1("Keyword    Token: ", mData.mName);
+    DUMP1_NORETURN("Keyword    Token: ", mData.mName);
     break;
   case TT_CM:
     DUMP0("Comment Token: ");
     break;
+  case TT_TL:
+    DUMP0("TemplateLiteral Token: ");
+    break;
+  case TT_RE:
+    DUMP1_NORETURN("RegExpr Token: ", mData.mRegExprData.mExpr);
+    if (mData.mRegExprData.mFlags)
+      DUMP1_NORETURN(" : ", mData.mRegExprData.mFlags);
+    break;
   case TT_LT:
     LiteralTokenDump(mData.mLitData);
     break;
   default:
     break;
   }
+
+  DUMP1_NORETURN(" line: ", mLineNum);
+  DUMP1_NORETURN(" col: ", mColNum);
+  if (mLineBegin)
+    DUMP0_NORETURN(" line-first ");
+  if (mLineEnd)
+    DUMP0_NORETURN(" line-last ");
+  DUMP_RETURN();
 }
+
+bool Token::Equal(Token *t) {
+  bool equal = false;
+  switch (mTkType) {
+  case TT_SP:
+    if (t->mTkType == TT_SP &&
+        GetSepId() == t->GetSepId())
+      equal = true;
+    break;
+  case TT_OP:
+    if (t->mTkType == TT_OP &&
+        GetOprId() == t->GetOprId())
+      equal = true;
+    break;
+  case TT_KW:
+    if (t->mTkType == TT_KW &&
+        GetName() == t->GetName())
+      equal = true;
+    break;
+  case TT_ID:
+  case TT_CM:
+  case TT_TL:
+  case TT_RE:
+  case TT_LT:
+  default:
+    break;
+  }
+
+  return equal;
+}
+
+///////////////////////////////////////////////////////////////////////////
+//                Utilities for finding system tokens
+// Remember the order of tokens are operators, separators, and keywords.
+///////////////////////////////////////////////////////////////////////////
+
+Token* FindOperatorToken(OprId id) {
+  Token *token = NULL;
+  bool found = false;
+  for (unsigned i = 0; i < gOperatorTokensNum; i++) {
+    token = &gSystemTokens[i];
+    MASSERT(token->mTkType == TT_OP);
+    if (token->GetOprId() == id) {
+      found = true;
+      break;
+    }
+  }
+  MASSERT(found && token);
+  return token;
+}
+
+Token* FindSeparatorToken(SepId id) {
+  Token *token = NULL;
+  bool found = false;
+  for (unsigned i = gOperatorTokensNum; i < gOperatorTokensNum + gSeparatorTokensNum; i++) {
+    token = &gSystemTokens[i];
+    MASSERT(token->mTkType == TT_SP);
+    if (token->GetSepId() == id) {
+      found = true;
+      break;
+    }
+  }
+  MASSERT(found && token);
+  return token;
+}
+
+// The caller of this function makes sure 'key' is already in the
+// string pool of Lexer.
+Token* FindKeywordToken(const char *key) {
+  Token *token = NULL;
+  bool found = false;
+  for (unsigned i = gOperatorTokensNum + gSeparatorTokensNum;
+       i < gOperatorTokensNum + gSeparatorTokensNum + gKeywordTokensNum;
+       i++) {
+    token = &gSystemTokens[i];
+    MASSERT(token->mTkType == TT_KW);
+    if (strlen(key) == strlen(token->GetName()) &&
+        !strncmp(key, token->GetName(), strlen(key))) {
+      found = true;
+      break;
+    }
+  }
+  MASSERT(found && token);
+  return token;
+}
+
+// CommentToken is the last predefined token
+Token* FindCommentToken() {
+  Token *token = &gSystemTokens[gSystemTokensNum - 1];
+  MASSERT((token->mTkType == TT_CM) && "Last system token is not a comment token.");
+  return token;
+}
+
 }
diff --git a/src/MapleFE/shared/src/tokenpool.cpp b/src/MapleFE/shared/src/tokenpool.cpp
index 263e76a03ccf5e313500e6e5c9ca953c041fc817..89dfde73e94772499496049360b155e912cb9b3a 100644
--- a/src/MapleFE/shared/src/tokenpool.cpp
+++ b/src/MapleFE/shared/src/tokenpool.cpp
@@ -23,8 +23,15 @@ char* TokenPool::NewToken(unsigned size) {
   char *addr = mMemPool.Alloc(size);
   MASSERT(addr && "MemPool failed to alloc a token.");
   Token *token = (Token*)addr;
+
   token->mAltTokens = NULL;
+  token->mLineNum = 0;
+  token->mColNum = 0;
+  token->mLineBegin = false;
+  token->mLineEnd = false;
+
   mTokens.PushBack((Token*)addr);
   return addr;
 }
+
 }
diff --git a/src/MapleFE/shared/src/typetable.cpp b/src/MapleFE/shared/src/typetable.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8a1d8a93e96c53f2c8636eafbdebf5d22e352a57
--- /dev/null
+++ b/src/MapleFE/shared/src/typetable.cpp
@@ -0,0 +1,204 @@
+/*
+* Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+//////////////////////////////////////////////////////////////////////////////
+//                                                                          //
+// This file contains the implementation of string pool.                    //
+//                                                                          //
+//////////////////////////////////////////////////////////////////////////////
+
+#include <cstdlib>
+#include <cstring>
+
+#include "typetable.h"
+#include "gen_astdump.h"
+
+namespace maplefe {
+
+TypeTable gTypeTable;
+
+TypeEntry::TypeEntry(TreeNode *node) {
+  mType = node;
+  if (!node->IsTypeIdNone()) {
+    mTypeId = node->GetTypeId();
+  } else {
+    switch (node->GetKind()) {
+      case NK_Struct:
+      case NK_StructLiteral:
+      case NK_Class:
+      case NK_Interface:
+        mTypeId = TY_Class;
+        break;
+      case NK_ArrayLiteral:
+        mTypeId = TY_Array;
+        break;
+      case NK_UserType:
+        mTypeId = TY_User;
+        break;
+      default:
+        mTypeId = TY_None;
+        break;
+    }
+  }
+}
+
+TreeNode *TypeTable::CreatePrimType(std::string name, TypeId tid) {
+  unsigned stridx = gStringPool.GetStrIdx(name);
+  PrimTypeNode *ptype = (PrimTypeNode*)gTreePool.NewTreeNode(sizeof(PrimTypeNode));
+  new (ptype) PrimTypeNode();
+  ptype->SetStrIdx(stridx);
+  ptype->SetPrimType(tid);
+  ptype->SetTypeId(tid);
+
+  mTypeId2TypeMap[tid] = ptype;
+  return ptype;
+}
+
+TreeNode *TypeTable::CreateBuiltinType(std::string name, TypeId tid) {
+  unsigned stridx = gStringPool.GetStrIdx(name);
+  IdentifierNode *id = (IdentifierNode*)gTreePool.NewTreeNode(sizeof(IdentifierNode));
+  new (id) IdentifierNode(stridx);
+  // use TY_Class for Object type
+  (tid == TY_Object) ? id->SetTypeId(TY_Class) : id->SetTypeId(tid);
+
+  UserTypeNode *utype = (UserTypeNode*)gTreePool.NewTreeNode(sizeof(UserTypeNode));
+  new (utype) UserTypeNode(id);
+  utype->SetStrIdx(stridx);
+  utype->SetTypeId(TY_Class);
+  id->SetParent(utype);
+
+  mTypeId2TypeMap[tid] = utype;
+  return utype;
+}
+
+bool TypeTable::AddType(TreeNode *node) {
+  unsigned nid = node->GetNodeId();
+  if (mNodeId2TypeIdxMap.find(nid) != mNodeId2TypeIdxMap.end()) {
+    return false;
+  }
+  unsigned tidx = mTypeTable.size();
+  mNodeId2TypeIdxMap[nid] = tidx;
+  node->SetTypeIdx(tidx);
+  if (node->IsUserType()) {
+    static_cast<UserTypeNode*>(node)->GetId()->SetTypeIdx(tidx);
+  }
+  TypeEntry *entry = new TypeEntry(node);
+  mTypeTable.push_back(entry);
+  return true;
+}
+
+void TypeTable::AddPrimTypeId(TypeId tid) {
+  mPrimTypeId.insert(tid);
+}
+
+#undef  TYPE
+#undef  PRIMTYPE
+void TypeTable::AddPrimAndBuiltinTypes() {
+  // only initialize once
+  if (mTypeTable.size() != 0) {
+    return;
+  }
+
+  TreeNode *node;
+  // add a NULL entry so real typeidx starting from 1
+  TypeEntry *entry = new TypeEntry();
+  mTypeTable.push_back(entry);
+
+  // first are primitive types, and their typeid TY_Xyz is their typeidx as well
+#define TYPE(T)
+#define PRIMTYPE(T) node = CreatePrimType(#T, TY_##T); AddType(node); AddPrimTypeId(TY_##T);
+#include "supported_types.def"
+  // add additional primitive types for number and string
+  PRIMTYPE(Number);
+  PRIMTYPE(String);
+
+  mPrimSize = size();
+
+#define TYPE(T) node = CreateBuiltinType(#T, TY_##T); AddType(node);
+#define PRIMTYPE(T)
+  // additional usertype Boolean
+  TYPE(Boolean);
+#include "supported_types.def"
+
+  mPreBuildSize = size();
+  return;
+}
+
+TypeEntry *TypeTable::GetTypeEntryFromTypeIdx(unsigned tidx) {
+  MASSERT(tidx < mTypeTable.size() && "type index out of range");
+  return mTypeTable[tidx];
+}
+
+TreeNode *TypeTable::GetTypeFromTypeIdx(unsigned tidx) {
+  MASSERT(tidx < mTypeTable.size() && "type index out of range");
+  return mTypeTable[tidx]->GetType();
+}
+
+TreeNode *TypeTable::GetTypeFromStrIdx(unsigned stridx) {
+  for (auto entry : mTypeTable) {
+    TreeNode *node = entry->GetType();
+    if (node && node->GetStrIdx() == stridx) {
+      return node;
+    }
+  }
+  return NULL;
+}
+
+unsigned TypeTable::GetOrCreateFunctionTypeIdx(FunctionTypeNode *node) {
+  for (auto tidx: mFuncTypeIdx) {
+    TreeNode *type = GetTypeFromTypeIdx(tidx);
+    FunctionTypeNode *functype = static_cast<FunctionTypeNode *>(type);
+    bool found = functype->IsEqual(node);
+    if (found) {
+      return tidx;
+    }
+  }
+  bool status = AddType(node);
+  MASSERT(status && "failed to add a functiontype");
+  unsigned tidx = node->GetTypeIdx();
+  mFuncTypeIdx.insert(tidx);
+
+  std::string str("FuncType__");
+  str += std::to_string(tidx);
+  unsigned stridx = gStringPool.GetStrIdx(str);
+  node->SetStrIdx(stridx);
+
+  return tidx;
+}
+
+void TypeTable::Dump() {
+  std::cout << "===================== TypeTable =====================" << std::endl;
+  std::cout << " tid:type-name: node-kind  node-id" << std::endl;
+  std::cout << "--------------------------------" << std::endl;
+  unsigned idx = 1;
+  for (unsigned idx = 1; idx < mTypeTable.size(); idx++) {
+    TypeEntry *entry = mTypeTable[idx];
+    TreeNode *node = entry->GetType();
+    TypeId tid = node->GetTypeId();
+    if (node->IsUserType()) {
+      tid = static_cast<UserTypeNode*>(node)->GetId()->GetTypeId();
+    }
+    std::cout << "  " << idx << " : " << node->GetName() << " : " <<
+              AstDump::GetEnumNodeKind(node->GetKind()) << " " <<
+              AstDump::GetEnumTypeId(tid) << " " <<
+              "(typeid " << tid << ") " <<
+              "(typeidx " << node->GetTypeIdx() << ") " <<
+              "(stridx " << node->GetStrIdx() << ") " <<
+              "(nodeid " << node->GetNodeId() << ")" << std::endl;
+  }
+  std::cout << "===================== End TypeTable =====================" << std::endl;
+}
+
+}
+
diff --git a/src/MapleFE/shared/src/vfy.cpp b/src/MapleFE/shared/src/vfy.cpp
index 7ed154992ed6d9486fc6c2539eae18270ac22165..07809d0f89ed58d2191117ee254c9fe0ca949449 100644
--- a/src/MapleFE/shared/src/vfy.cpp
+++ b/src/MapleFE/shared/src/vfy.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -31,7 +31,7 @@ namespace maplefe {
 //    resursive process.
 ///////////////////////////////////////////////////////////////////////////////
 
-Verifier::Verifier() {
+Verifier::Verifier(ModuleNode *m) : mASTModule(m) {
   mCurrScope = NULL;
   mTempParent = NULL;
 }
@@ -52,11 +52,9 @@ void Verifier::Do() {
 // see java/vfy_java.cpp.
 
 void Verifier::VerifyGlobalScope() {
-  mCurrScope = gModule.mRootScope;
-  std::vector<ASTTree*>::iterator tree_it = gModule.mTrees.begin();
-  for (; tree_it != gModule.mTrees.end(); tree_it++) {
-    ASTTree *asttree = *tree_it;
-    TreeNode *tree = asttree->mRootNode;
+  mCurrScope = mASTModule->mRootScope;
+  for (unsigned i = 0; i < mASTModule->GetTreesNum(); i++) {
+    TreeNode *tree = mASTModule->GetTree(i);
     // Step 1. Try to add decl.
     mCurrScope->TryAddDecl(tree);
     // Step 2. Try to add type.
@@ -87,7 +85,7 @@ void Verifier::CollectAllDeclsTypes(ASTScope *scope) {
   // All fields, methods, local classes, local interfaces are decls.
   // All local classes/interfaces are types.
   for (unsigned i = 0; i < klass->GetFieldsNum(); i++) {
-    IdentifierNode *in = klass->GetField(i);
+    TreeNode *in = klass->GetField(i);
     scope->AddDecl(in);
   }
   for (unsigned i = 0; i < klass->GetMethodsNum(); i++) {
@@ -119,7 +117,7 @@ void Verifier::VerifyIdentifier(IdentifierNode *inode) {
   ASTScope *scope = mCurrScope;
   IdentifierNode *decl = NULL;
   while (scope) {
-    if (decl = (IdentifierNode*) scope->FindDeclOf(inode))
+    if ((decl = (IdentifierNode*) scope->FindDeclOf(inode->GetStrIdx())))
       break;
     scope = scope->GetParent();
   }
@@ -127,18 +125,24 @@ void Verifier::VerifyIdentifier(IdentifierNode *inode) {
   if (!decl) {
     mLog.MissDecl(inode);
   } else {
-    // Replace the temp IdentifierNode with the found Decl.
-    // Sometimes inode and decl are the same, which happens for the declaration statement.
-    // We will verify decl statement as the others, so its inode is the same as decl.
-    if (inode != decl) {
-      // TODO : There are many complicated cases which we will handle in the furture.
-      //        Right now I just put a simple check of mTempParent.
-      if (mTempParent)
-        mTempParent->ReplaceChild(inode, decl);
-    }
+    // We disabled this part to keep the integerity of TREE. We don't want
+    // a graph.
+    //
+    // // Replace the temp IdentifierNode with the found Decl.
+    // // Sometimes inode and decl are the same, which happens for the declaration statement.
+    // // We will verify decl statement as the others, so its inode is the same as decl.
+    // if (inode != decl) {
+    //   // TODO : There are many complicated cases which we will handle in the furture.
+    //   //        Right now I just put a simple check of mTempParent.
+    //   if (mTempParent)
+    //     mTempParent->ReplaceChild(inode, decl);
+    // }
   }
 }
 
+void Verifier::VerifyDecl(DeclNode *tree){
+}
+
 void Verifier::VerifyDimension(DimensionNode *tree){
 }
 
@@ -160,8 +164,8 @@ void Verifier::VerifyPrimArrayType(PrimArrayTypeNode *tree){
 void Verifier::VerifyVarList(VarListNode *vlnode){
   TreeNode *old_temp_parent = mTempParent;
   mTempParent = vlnode;
-  for (unsigned i = 0; i < vlnode->GetNum(); i++) {
-    IdentifierNode *n = vlnode->VarAtIndex(i);
+  for (unsigned i = 0; i < vlnode->GetVarsNum(); i++) {
+    IdentifierNode *n = vlnode->GetVarAtIndex(i);
     VerifyIdentifier(n);
   }
   mTempParent = old_temp_parent;
@@ -172,14 +176,22 @@ void Verifier::VerifyLiteral(LiteralNode *tree){
   return;
 }
 
+void Verifier::VerifyTemplateLiteral(TemplateLiteralNode *tree){
+  return;
+}
+
+void Verifier::VerifyRegExpr(RegExprNode *tree){
+  return;
+}
+
 void Verifier::VerifyUnaOperator(UnaOperatorNode *tree){
 }
 
 void Verifier::VerifyBinOperator(BinOperatorNode *binop){
   TreeNode *old_temp_parent = mTempParent;
   mTempParent = binop;
-  VerifyTree(binop->mOpndA);
-  VerifyTree(binop->mOpndB);
+  VerifyTree(binop->GetOpndA());
+  VerifyTree(binop->GetOpndB());
   mTempParent = old_temp_parent;
 }
 
@@ -187,7 +199,7 @@ void Verifier::VerifyTerOperator(TerOperatorNode *tree){
 }
 
 void Verifier::VerifyBlock(BlockNode *block){
-  mCurrScope = gModule.NewScope(mCurrScope);
+  mCurrScope = mASTModule->NewScope(mCurrScope);
   mCurrScope->SetTree(block);
 
   for (unsigned i = 0; i < block->GetChildrenNum(); i++) {
@@ -204,7 +216,7 @@ void Verifier::VerifyBlock(BlockNode *block){
 // Function body's block is different than a pure BlockNode.
 void Verifier::VerifyFunction(FunctionNode *func){
   ASTScope *old_scope = mCurrScope;
-  mCurrScope = gModule.NewScope(mCurrScope);
+  mCurrScope = mASTModule->NewScope(mCurrScope);
   mCurrScope->SetTree(func);
 
   // Add the parameters to the decl. Since we search for the decl of a var from
@@ -241,11 +253,11 @@ void Verifier::VerifyFunction(FunctionNode *func){
 void Verifier::VerifyClassFields(ClassNode *klass) {
   // rule 1. No duplicated fields name with another decls.
   for (unsigned i = 0; i < klass->GetFieldsNum(); i++) {
-    IdentifierNode *na = klass->GetField(i);
+    TreeNode *na = klass->GetField(i);
     bool hit_self = false;
     for (unsigned j = 0; j < mCurrScope->GetDeclNum(); j++) {
       TreeNode *nb = mCurrScope->GetDecl(j);
-      if (na->GetName() == nb->GetName()) {
+      if (na->GetStrIdx() == nb->GetStrIdx()) {
         if (nb->IsIdentifier()) {
           if (!hit_self)
             hit_self = true;
@@ -265,7 +277,7 @@ void Verifier::VerifyClassSuperInterfaces(ClassNode *klass) {}
 
 void Verifier::VerifyClass(ClassNode *klass){
   // Step 1. Create a new scope
-  ASTScope *scope = gModule.NewScope(mCurrScope);
+  ASTScope *scope = mASTModule->NewScope(mCurrScope);
   mCurrScope = scope;
   scope->SetTree(klass);
 
@@ -293,18 +305,36 @@ void Verifier::VerifyAnnotationType(AnnotationTypeNode *tree){
 void Verifier::VerifyAnnotation(AnnotationNode *tree){
 }
 
+void Verifier::VerifyThrow(ThrowNode *tree){
+}
+
+void Verifier::VerifyTry(TryNode *tree){
+}
+
+void Verifier::VerifyCatch(CatchNode *tree){
+}
+
+void Verifier::VerifyFinally(FinallyNode *tree){
+}
+
 void Verifier::VerifyException(ExceptionNode *tree){
 }
 
 void Verifier::VerifyReturn(ReturnNode *tree){
 }
 
+void Verifier::VerifyYield(YieldNode *tree){
+}
+
 void Verifier::VerifyCondBranch(CondBranchNode *tree){
 }
 
 void Verifier::VerifyBreak(BreakNode *tree){
 }
 
+void Verifier::VerifyContinue(ContinueNode *tree){
+}
+
 void Verifier::VerifyForLoop(ForLoopNode *tree){
 }
 
@@ -320,7 +350,7 @@ void Verifier::VerifyType(IdentifierNode *inode) {
   ASTScope *scope = mCurrScope;
   TreeNode *type = NULL;
   while (scope) {
-    if (type = scope->FindTypeOf(inode))
+    if ((type = scope->FindTypeOf(inode->GetStrIdx())))
       break;
     scope = scope->GetParent();
   }
@@ -356,8 +386,8 @@ void Verifier::VerifyNew(NewNode *new_node){
   VerifyType(inode);
   // verify parameters.
   // A parameter could be any type. We have to verify type by type.
-  for (unsigned i = 0; i < new_node->GetParamsNum(); i++) {
-    TreeNode *p = new_node->GetParam(i);
+  for (unsigned i = 0; i < new_node->GetArgsNum(); i++) {
+    TreeNode *p = new_node->GetArg(i);
     if(p->IsIdentifier()) {
       IdentifierNode *inode = (IdentifierNode*)p;
       VerifyIdentifier(inode);
@@ -386,6 +416,10 @@ void Verifier::VerifyExprList(ExprListNode *tree){
   return;
 }
 
+void Verifier::VerifyNamespace(NamespaceNode *tree){
+  return;
+}
+
 void Verifier::VerifyCall(CallNode *tree){
   return;
 }
@@ -406,14 +440,30 @@ void Verifier::VerifyParenthesis(ParenthesisNode *tree){
   return;
 }
 
+void Verifier::VerifyModule(ModuleNode *tree){
+  return;
+}
+
 void Verifier::VerifyPackage(PackageNode *tree){
   return;
 }
 
+void Verifier::VerifyDeclare(DeclareNode *tree){
+  return;
+}
+
 void Verifier::VerifyImport(ImportNode *tree){
   return;
 }
 
+void Verifier::VerifyExport(ExportNode *tree){
+  return;
+}
+
+void Verifier::VerifyXXportAsPair(XXportAsPairNode *tree){
+  return;
+}
+
 void Verifier::VerifyUserType(UserTypeNode *tree){
   return;
 }
@@ -421,4 +471,109 @@ void Verifier::VerifyUserType(UserTypeNode *tree){
 void Verifier::VerifyLambda(LambdaNode *tree){
   return;
 }
+
+void Verifier::VerifyInstanceOf(InstanceOfNode *tree){
+  return;
+}
+
+void Verifier::VerifyIn(InNode *tree){
+  return;
+}
+
+void Verifier::VerifyComputedName(ComputedNameNode *tree){
+  return;
+}
+
+void Verifier::VerifyIs(IsNode *tree){
+  return;
+}
+
+void Verifier::VerifyAwait(AwaitNode *tree){
+  return;
+}
+
+void Verifier::VerifyTypeOf(TypeOfNode *tree){
+  return;
+}
+
+void Verifier::VerifyTypeAlias(TypeAliasNode *tree){
+  return;
+}
+
+void Verifier::VerifyAsType(AsTypeNode *tree){
+  return;
+}
+
+void Verifier::VerifyConditionalType(ConditionalTypeNode *tree){
+  return;
+}
+
+void Verifier::VerifyTypeParameter(TypeParameterNode *tree){
+  return;
+}
+
+void Verifier::VerifyKeyOf(KeyOfNode *tree){
+  return;
+}
+
+void Verifier::VerifyInfer(InferNode *tree){
+  return;
+}
+
+void Verifier::VerifyArrayElement(ArrayElementNode *tree){
+  return;
+}
+
+void Verifier::VerifyArrayLiteral(ArrayLiteralNode *tree){
+  return;
+}
+
+void Verifier::VerifyNumIndexSig(NumIndexSigNode *tree){
+  return;
+}
+
+void Verifier::VerifyStrIndexSig(StrIndexSigNode *tree){
+  return;
+}
+
+void Verifier::VerifyStruct(StructNode *tree){
+  return;
+}
+
+void Verifier::VerifyNameTypePair(NameTypePairNode *tree){
+  return;
+}
+
+void Verifier::VerifyTupleType(TupleTypeNode *tree){
+  return;
+}
+
+void Verifier::VerifyBindingElement(BindingElementNode *tree){
+  return;
+}
+
+void Verifier::VerifyBindingPattern(BindingPatternNode *tree){
+  return;
+}
+
+void Verifier::VerifyStructLiteral(StructLiteralNode *tree){
+  return;
+}
+
+void Verifier::VerifyFieldLiteral(FieldLiteralNode *tree){
+  return;
+}
+
+void Verifier::VerifyArrayType(ArrayTypeNode *tree){
+  return;
+}
+
+void Verifier::VerifyTripleSlash(TripleSlashNode *tree){
+  return;
+}
+
+void Verifier::VerifyFunctionType(FunctionTypeNode *tree){
+  return;
+}
+
 }
diff --git a/src/MapleFE/test/Makefile b/src/MapleFE/test/Makefile
index 09a42a4e3387428f41744a5e252a469072150699..aed83f9c0ad98a99312e7e2785030cbc13cd311a 100644
--- a/src/MapleFE/test/Makefile
+++ b/src/MapleFE/test/Makefile
@@ -1,4 +1,4 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
 # 
 # OpenArkFE is licensed under the Mulan PSL v2.
 # You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -15,74 +15,104 @@
 # for testing batch1/Arithmetic/Add.java:
 # make Add
 
-build = ../output/test
+build = ../output/$(SRCLANG)/test
 $(shell mkdir -p $(build))
 
-DIR = . $(wildcard * */* */*/*)
+ifeq ($(SRCLANG),java)
+  FLAGS := --trace-a2m
+else ifeq ($(SRCLANG),typescript)
+  FLAGS1 := --trace-lexer
+  FLAGS2 := --trace=3 --format-cpp
+endif
 
-vpath %.java $(DIR)
-vpath %.mpl $(DIR)
-vpath %.c $(DIR)
-vpath %.cpp $(DIR)
+DIRS := . $(shell find $(SRCLANG) -type d)
 
-all: test
+vpath %.java $(DIRS)
+vpath %.ts $(DIRS)
+vpath %.mpl $(DIRS)
+vpath %.c $(DIRS)
+vpath %.cpp $(DIRS)
 
-autogen:
-	make -C ../autogen
+.PHONY: $(SRCLANG)
+.PHONY: mssetup
 
-shared: autogen test
-	make -C ../shared
+$(SRCLANG):
+	env LANG=en_US.UTF-8 ./new_runtests.pl $(SRCLANG)
 
 full:
-	make -C ..
-
-clean:
-	make -C .. clean
-
-clobber:
-	make -C .. clobber
+	make -C .. -j8
 
 rebuild:
-	make -C .. rebuild
+	make -C .. rebuild -j8
 
-tt:
-	../output/java/java2mpl tt.java --trace-a2m
-	@echo "\n======================== tt.mpl ========================"
-	@cat tt.mpl
-	@echo "========================================================\n"
-	../../mapleall/bin/aarch64-clang-debug/irbuild tt.mpl
-	../../mapleall/bin/aarch64-clang-debug/irbuild tt.irb.mpl
-	diff -uwb tt.irb.mpl tt.irb.irb.mpl
+clean:
+	rm -rf $(build)
+
+clobber: clean
 
 dbg:
-	gdb --args ../output/java/java2mpl tt.java --trace-a2m
+	gdb --args ../output/java/java/java2mpl test.java $(FLAGS)
+
+ifeq ($(SRCLANG),java)
 
-# only run autogen for now
-test:
-	./runtests.pl all
+mssetup:
 
 % : %.java
 	@cp $< $(build)
-	@echo gdb --args ../output/java/java2mpl $(build)/$@.java --trace-a2m
-	../output/java/java2mpl $(build)/$@.java --trace-a2m
+	@echo gdb --args ../output/java/bin/java2ast $(build)/$@.java $(FLAGS1)
+	@echo gdb --args ../output/java/bin/ast2mpl $(build)/$@.java.ast $(FLAGS2)
+	../output/java/bin/java2ast $(build)/$@.java $(FLAGS1)
+	../output/java/bin/ast2mpl $(build)/$@.java.ast $(FLAGS2)
+	@echo "\n======================= $@.java ========================="
+	@cat -n $(build)/$@.java
+	@echo "========================================================\n"
+	@echo gdb --args ../output/java/bin/java2ast $(build)/$@.java $(FLAGS1)
+	@echo gdb --args ../output/java/bin/ast2mpl $(build)/$@.java.ast $(FLAGS2)
 	@echo "\n======================= $@.mpl ========================="
-	@cat $(build)/$@.mpl
+	@cat -n $(build)/$@.mpl
 	@echo "========================================================\n"
-	../../mapleall/bin/aarch64-clang-debug/irbuild $(build)/$@.mpl
-	../../mapleall/bin/aarch64-clang-debug/irbuild $(build)/$@.irb.mpl
+	@echo gdb --args ../output/java/bin/java2ast $(build)/$@.java $(FLAGS1)
+	@echo gdb --args ../output/java/bin/ast2mpl $(build)/$@.java.ast $(FLAGS2)
+	@cat -n $(build)/$@.mpl
+	@echo "========================================================\n"
+	@echo gdb --args ../output/java/java/java2mpl $(build)/$@.java $(FLAGS)
+	$(MAPLEALL_ROOT)/output/aarch64-clang-debug/bin/irbuild $(build)/$@.mpl
+	$(MAPLEALL_ROOT)/output/aarch64-clang-debug/bin/irbuild $(build)/$@.irb.mpl
 	diff -uwb $(build)/$@.irb.mpl $(build)/$@.irb.irb.mpl
-	@echo gdb --args ../output/java/java2mpl $(build)/$@.java --trace-a2m
-
-% : %.c
-	cp $< $(build)
-	@echo "\ngdb command:\n(cd $(BUILDDIR)/autogen/; gdb -args ./sharedfe -verbose=3 ../../test/$(build)/$<)"
-	(cd $(BUILDDIR)/autogen; ./sharedfe -verbose=3 ../../test/$(build)/$<)
-	@echo "\ncommand:\n(cd $(BUILDDIR)/autogen/; ./sharedfe ../../test/$(build)/$<)"
-	@echo "\ngdb command:\n(cd $(BUILDDIR)/autogen/; gdb -args ./sharedfe -verbose=3 ../../test/$(build)/$<)"
-
-% : %.cpp
-	cp $< $(build)
-	@echo "\ngdb command:\n(cd $(BUILDDIR)/autogen/; gdb -args ./sharedfe -verbose=3 ../../test/$(build)/$<)"
-	(cd $(BUILDDIR)/autogen; ./sharedfe -verbose=3 ../../test/$(build)/$<)
-	@echo "\ncommand:\n(cd $(BUILDDIR)/autogen/; ./sharedfe ../../test/$(build)/$<)"
-	@echo "\ngdb command:\n(cd $(BUILDDIR)/autogen/; gdb -args ./sharedfe -verbose=3 ../../test/$(build)/$<)"
+
+else ifeq ($(SRCLANG),typescript)
+
+mssetup:
+	./msts_test.sh setup
+
+testms:
+	./msts_test.sh
+
+testmslocal: mssetup
+	env LANG=en_US.UTF-8 ./new_runtests.pl typescript TypeScript/tests/cases/compiler
+
+unit:
+	env LANG=en_US.UTF-8 ./new_runtests.pl typescript typescript/unit_tests
+
+ms: mssetup
+	env LANG=en_US.UTF-8 ./new_runtests.pl typescript typescript/ms_tests
+
+% : %.ts
+	@cp $< $(build)
+	@echo gdb --args ../output/typescript/bin/ts2ast $(build)/$@.ts $(FLAGS1)
+	@echo gdb --args ../output/typescript/bin/ast2cpp $(build)/$@.ts.ast $(FLAGS2)
+	../output/typescript/bin/ts2ast $(build)/$@.ts $(FLAGS1)
+	../output/typescript/bin/ast2cpp $(build)/$@.ts.ast $(FLAGS2)
+	@echo "\n======================= $@.ts ========================="
+	@cat -n $(build)/$@.ts
+	@echo "========================================================\n"
+	@echo gdb --args ../output/typescript/bin/ts2ast $(build)/$@.ts $(FLAGS1)
+	@echo gdb --args ../output/typescript/bin/ast2cpp $(build)/$@.ts.ast $(FLAGS2)
+	@echo "\n======================= $@.h ========================="
+	@cat -n $(build)/$@.h
+	@echo "\n======================= $@.cpp ========================="
+	@cat -n $(build)/$@.cpp
+	@echo "========================================================\n"
+	@echo gdb --args ../output/typescript/bin/ts2ast $(build)/$@.ts $(FLAGS1)
+	@echo gdb --args ../output/typescript/bin/ast2cpp $(build)/$@.ts.ast $(FLAGS2)
+endif
diff --git a/src/MapleFE/test/README b/src/MapleFE/test/README
index a46d226caf1805245765cf35d1efdf3efde933be..cdbdaa9af05a75e1b81b517a346e09daf8ea2618 100644
--- a/src/MapleFE/test/README
+++ b/src/MapleFE/test/README
@@ -1,10 +1,43 @@
 This directory contains the test framework and test cases.
-The test cases are in 3 directories.
-1. java2mpl
-   This is for the Java test cases. They are correct code.
-2. errtest
-   This is for the Java test cases. They are incorrect code.
-3. others
-   This is for the Java test cases. They are taken from 3rd party open source projects,
-   in order to have a complete coverage of the testing. If you want to reuse the code
-   please read the LICENSE carefully.
+
+Directories:
+./java
+./java/syntaxonly        Test cases for syntax check
+./java/others            Other Java test cases from third-party open source projects. Included the LICENSE for them.
+./java/java2mpl          Java test cases for java2mpl
+./java/openjdk           Java test cases
+./java/errtest           Negative test cases
+
+./typescript
+./typescript/ms_tests    TypeScript official test cases. Included the LICENSE for them.
+./typescript/unit_tests  Unit test cases
+
+To run TypeScript tests:
+  1. source envsetup typescript; cd $MAPLEFE_ROOT/test
+  2. Run both unit_tests and ms_tests:
+       make
+     Run just unit_tests
+       make unit
+     Run just ms_tests
+       make ms
+     Run specific typescript test
+       make <testcase name>
+     * Tests should be run using make instead of using the .pl scripts directly.
+
+Tool to dump AST and CFG of a TypeScript test case:
+
+ Usage: astdump.sh [-dot] [-f|--fullscreen] [-p <PREFIX>|--pre <PREFIX>] [-a|--ast] [-c|--cfg] <file1> [<file2> ...]
+
+  -d | --dot             Use Graphviz dot to generate the graph and view it with viewnior
+  -f | --fullscreen      View the generated graph in fullscreen mode. It implies option -dot
+  -p | --pre <PREFIX>    Filter graphs with the specified <PREFIX>, e.g. -p "CFG_<function-name>"
+  -a | --ast             Show AST graph. It is equivalent to options "-dot -p AST"
+  -c | --cfg             Show CFG graph. It is equivalent to options "-dot -p CFG"
+  -h | --help            Display usage information
+  -s | --syntax          Syntax highlighting the generated TypeScript code
+  <file1> [<file2> ...]  Specify one or more TypeScript files to be processed
+
+Examples:
+  cd MapleFE/test/typescript/unit_tests
+  ../../astdump.sh -a binary-search.ts   # Show AST graph
+  ../../astdump.sh binary-search.ts -c   # Show CFG graph
diff --git a/src/MapleFE/test/astdump.sh b/src/MapleFE/test/astdump.sh
new file mode 100755
index 0000000000000000000000000000000000000000..2260c58f95c703efdf91b6bb871d883f67219a3f
--- /dev/null
+++ b/src/MapleFE/test/astdump.sh
@@ -0,0 +1,209 @@
+#!/bin/bash
+function usage {
+cat << EOF
+
+Usage: astdump.sh [-d] [-f] [-p <PREFIX>] [-a] [-c] [-k] [-A] [-C] [-n] [-t|-T] <file1> [<file2> ...]
+
+Short/long options:
+  -d | --dot             Use Graphviz dot to generate the graph and view it with viewnior
+  -f | --fullscreen      View the generated graph in fullscreen mode. It implies option -dot
+  -p | --pre <PREFIX>    Filter graphs with the specified <PREFIX>, e.g. -p "CFG_<function-name>"
+  -a | --ast             Show AST graph. It is equivalent to options "-d -p AST"
+  -c | --cfg             Show CFG graph. It is equivalent to options "-d -p CFG"
+  -s | --syntax          Syntax highlighting the generated TypeScript code
+  -k | --keep            Keep generated files *.ts-[0-9]*.out.ts which fail to compile with tsc
+  -A | --all             Process all .ts files in current directory excluding *.ts-[0-9]*.out.ts
+  -C | --clean           Clean up generated files (*.ts-[0-9]*.out.ts)
+  -n | --name            Keep original names by removing "__v[0-9]*" from generated code
+  -t | --treediff        Compare the AST of generated TS code with the one of original TS code
+  -T | --Treediff        Same as -t/--treediff except that it disables tsc for generated TS code
+  -i | --ignore-imported Ignore all imported modules
+  <file1> [<file2> ...]  Specify one or more TypeScript files to be processed
+EOF
+exit 1
+}
+CMDLINE="$0 $*"
+GITTS=$(git ls-files "*.ts")
+DOT= PRE= LIST= VIEWOP= HIGHLIGHT="cat" TSCERR= KEEP= CLEAN= NAME= TREEDIFF= TSC=yes NOIMPORTED=
+while [ $# -gt 0 ]; do
+    case $1 in
+        -d|--dot)        DOT=dot;;
+        -f|--fullscreen) VIEWOP="--fullscreen"; DOT=fullscreen;;
+        -p|--pre)        [ $# -ge 2 ] && { PRE="$2"; shift; } || { echo "$1 needs an argument"; exit 1; } ;;
+        -a|--ast)        PRE="AST" ; DOT=ast ; TSCERR=">& /dev/null" ;;
+        -c|--cfg)        PRE="CFG" ; DOT=cfg ; TSCERR=">& /dev/null" ;;
+        -s|--syntax)     HIGHLIGHT="highlight -O xterm256 --syntax ts" ;;
+        -e|--tscerror)   TSCERR= ;;
+        -k|--keep)       KEEP=keep ;;
+        -C|--clean)      CLEAN=clean ;;
+        -A|--all)        LIST="$LIST $(echo $GITTS | xargs grep -l '^ *export ') "
+                         LIST="$LIST $(echo $GITTS | xargs grep -L '^ *export ') " ;;
+        -n|--name)       NAME="original" ;;
+        -t|--treediff)   TREEDIFF="--emit-ts-only"; NAME="original"; TSC=yes ;;
+        -T|--Treediff)   TREEDIFF="--emit-ts-only"; NAME="original"; TSC= ;;
+        -i|--ignore-imported) NOIMPORTED="--no-imported" ;;
+        -*)              echo "Unknown option $1"; usage;;
+        *)               LIST="$LIST $1"
+    esac
+    shift
+done
+LIST=$(echo $LIST | xargs -n1 | grep -v '\.ts-[0-9][0-9]*\.out\.[d.]*ts' | grep -vF .ts.tmp.ts)
+if [ -n "$CLEAN" ]; then
+  echo Cleaning up generated files...
+  find -maxdepth 1 -regex '.*\.ts-[0-9]+\.out.[ctj][ps]p*\|.*\.ts-[0-9]+\.[pd][no][gt]\|.*\.ts.[ca][ps][pt]' -exec rm '{}' \;
+  rm -rf *.ts.orig *.ts.gen *.ts.tmp.ts *[0-9]-dump.out ts2cxx-lock-*
+  for ts in $LIST $GITTS; do
+    rm -rf $ts.orig $ts.gen $ts.tmp.ts $ts.*[0-9]-dump.out $ts-*[0-9].out.ts $ts-*[0-9].out.d.ts
+  done
+  echo Done.
+fi
+[ -n "$LIST" ] || { echo Please specify one or more TypeScript files.; usage; }
+[ -z "$DOT" ] || [ -x /usr/bin/dot -a -x /usr/bin/viewnior -a -x /usr/bin/highlight ] || sudo apt install graphviz viewnior highlight
+TSOUT=$(cd $(dirname $(realpath $0))/../; pwd)/output/typescript
+TS2AST=$TSOUT/bin/ts2ast
+AST2CPP=$TSOUT/bin/ast2cpp
+[ -x "$TS2AST" ] || { echo Cannot execute $TS2AST; exit 1; }
+[ -x "$AST2CPP" ] || { echo Cannot execute $AST2CPP; exit 1; }
+
+# Acquire/release a lock
+typeset -i LockVar
+LockVar=1
+function AcquireLock {
+    while [[ $LockVar -ne 0 ]] || sleep 0.3; do
+        ln -s Lock_$2 $1-lock-$((LockVar=(LockVar+1)%$3)) > /dev/null 2>&1 && break
+    done
+}
+function ReleaseLock {
+    rm -f $1-lock-$LockVar
+}
+trap "{ pstree -p $$ | tr ')' '\n' | sed 's/.*(//' | xargs kill -9 2> /dev/null; rm -f ts2cxx-lock-*; }" SIGINT SIGQUIT SIGKILL SIGTERM
+
+PROCID=$$
+rm -rf *$PROCID-dump.out $PROCID-summary.out *$PROCID.out.ts ts2cxx-lock-*
+OPT="--target es6 \
+     --lib es2015,es2017,dom \
+     --module commonjs \
+     --downlevelIteration \
+     --esModuleInterop \
+     --experimentalDecorators"
+cnt=0
+for ts in $LIST; do
+  ts=$(sed 's|^\./||' <<< "$ts")
+  echo $((++cnt)): $ts
+  AcquireLock ts2cxx for_$(basename $ts) $(nproc)
+  (if true; then
+  set -x
+  echo ---------
+  echo "$TS2AST" "$ts"
+  out=$("$TS2AST" "$ts")
+  if [ $? -ne 0 ]; then
+    echo "MSG: Failed, test case (ts2ast)$ts"
+  else
+    echo "$AST2CPP" "$ts".ast --trace=2 --emit-ts $TREEDIFF $NOIMPORTED
+    out=$("$AST2CPP" "$ts".ast --trace=2 --emit-ts $TREEDIFF $NOIMPORTED 2>&1)
+    [ $? -eq 0 ] || echo "MSG: Failed, test case (ast2cpp)$ts"
+  fi
+  echo "$out"
+  cmd=$(grep -n -e "^// .Beginning of Emitter:" -e "// End of Emitter.$" <<< "$out" |
+    tail -2 | sed 's/:.*//' | xargs | sed 's/\([^ ]*\) \(.*\)/sed -n \1,$((\2))p/')
+  if [ "x${cmd:0:4}" = "xsed " ]; then
+    T=$(sed -e "s/\(.*\)\(\.d\)\(\.ts-$PROCID.out\)/\1\2\3\2/" <<< "$ts-$PROCID.out.ts")
+    eval $cmd <<< "$out" > "$T"
+    [ -z "$NAME" ] || sed -i 's/__v[0-9][0-9]*//g' "$T"
+    echo -e "\n====== TS Reformatted ======\n"
+    $HIGHLIGHT "$T"
+    echo TREEDIFF=$TREEDIFF
+    E=
+    grep -qm1 "PassNode *{" <<< "$out" && E=",PassNode"
+    if [ -z "$TREEDIFF" -o -n "$TSC" ]; then
+      eval tsc $OPT "$T" $TSCERR
+    else
+      echo Skipping tsc for tree diff
+    fi
+    # --strict  --downlevelIteration --esModuleInterop --noImplicitAny --isolatedModules "$T" $TSCERR
+    if [ $? -ne 0 ]; then
+      echo "MSG: Failed, test case (tsc-failed$E)$ts"
+      [ -n "$KEEP" ] || rm -f "$T"
+    elif [ -z $TREEDIFF ]; then
+      echo "MSG: Passed, test case $ts"
+      Passed="$Passed $ts"
+      [ -n "$KEEP" ] || rm -f "$T"
+    else
+      cp $ts $ts.tmp.ts
+      $TS2AST $ts.tmp.ts
+      if [ $? -eq 0 ]; then
+        $AST2CPP $ts.tmp.ts.ast $TREEDIFF | sed -n '/^AstDump:/,/^}/p' | sed 's/\(mStrIdx: unsigned int, \)[0-9]* =>/\1=>/'
+      fi > $ts.orig
+      $TS2AST $T
+      if [ $? -eq 0 ]; then
+        $AST2CPP $T.ast $TREEDIFF | sed -n '/^AstDump:/,/^}/p' | sed -e "s|/$T|/$ts.tmp.ts|" \
+          -e 's/\(mStrIdx: unsigned int, \)[0-9]* =>/\1=>/'
+      else
+        E="$E,ts2ast"
+      fi > $ts.gen
+      diff $ts.orig $ts.gen
+      if [ $? -eq 0 -a -s $ts.orig -a -s $ts.gen ]; then
+        Passed="$Passed $ts"
+        echo "MSG: Passed, test case $ts"
+      else
+        diff -I '[0-9]\. const char\*, "' $ts.orig $ts.gen
+        if [ $? -eq 0 -a -s $ts.orig -a -s $ts.gen ]; then
+          Passed="$Passed $ts"
+          echo "MSG: Passed, test case (const-char*)$ts"
+        else
+          echo "MSG: Failed, test case (diff-ast$E)$ts"
+        fi
+      fi
+      echo === "$T"; cat "$T"
+      echo --- "$ts"; cat "$ts"
+      echo ===
+      if [ -n "$DOT" ]; then
+        for tf in $ts.tmp.ts $T; do
+          echo "=== $tf"
+          cat $tf
+          out="$out"$'\n'"$($TS2AST $tf --dump-dot)"
+        done
+      fi
+      [ -n "$KEEP" ] || rm -f "$T" $ts.orig $ts.gen $ts.tmp.ts
+    fi
+  fi
+  if [ -n "$DOT" ]; then
+    echo --- "$ts"; cat "$ts"
+    idx=0
+    grep -n -e "^digraph $PRE[^{]* {" -e "^}" <<< "$out" | grep -A1 "digraph [^{]* {" |
+      grep -v ^-- | sed 'N;s/\n/ /' | sed -e 's/:digraph [^{]* { */,/' -e 's/:.*/p/g' |
+      { while read cmd; do
+        idx=$((idx+1))
+        sed -n $cmd <<< "$out" > "$ts"-$idx.dot
+        dot -Tpng -o "$ts"-$idx.png "$ts"-$idx.dot
+        env LC_ALL=C viewnior $VIEWOP "$ts"-$idx.png &
+      done
+      wait
+      rm -f "$ts"-[0-9]*.png "$ts"-[0-9]*.dot; }
+  fi
+  ReleaseLock ts2cxx
+  set +x
+  fi >& $ts.$PROCID-dump.out
+  grep -a "^MSG: [PF]a[si][sl]ed," $ts.$PROCID-dump.out >> $PROCID-summary.out
+  ) &
+done
+wait
+echo Done.
+if [ -s $PROCID-summary.out ]; then
+  msg=$(grep -a "^MSG: [PF]a[si][sl]ed," $PROCID-summary.out)
+  echo "$CMDLINE" >> $PROCID-summary.out
+  if true; then
+    echo
+    echo "Test case(s) passed:"
+    grep -a "^MSG: Passed, test case " <<< "$msg" | sed 's/MSG: Passed, test case //' | env LC_ALL=C sort -r | nl
+    grep -aq -m1 "^MSG: Failed, test case " <<< "$msg"
+    if [ $? -eq 0 ]; then
+      echo
+      echo "Test case(s) failed:"
+      grep -a "^MSG: Failed," <<< "$msg" | sed 's/MSG: Failed, test case //' | env LC_ALL=C sort | nl
+    fi
+    echo
+    echo Total: $(wc -l <<< "$msg"), Passed: $(grep -ac "^MSG: Passed," <<< "$msg"), Failed: $(grep -ac "^MSG: Failed," <<< "$msg")
+    grep -a "^MSG: Failed," <<< "$msg" | sed 's/MSG: Failed, test case (\([^)]*\).*/due to \1/' | sort | uniq -c
+  fi | tee -a $PROCID-summary.out
+fi
diff --git a/src/MapleFE/test/astdumpjava.sh b/src/MapleFE/test/astdumpjava.sh
new file mode 100755
index 0000000000000000000000000000000000000000..a60c18ab412cbd7f81066032884f0c34efec56f3
--- /dev/null
+++ b/src/MapleFE/test/astdumpjava.sh
@@ -0,0 +1,164 @@
+#!/bin/bash
+function usage {
+cat << EOF
+
+Usage: astdump.sh [-d] [-f] [-p <PREFIX>] [-a] [-c] [-k] [-A] [-C] [-n] [-t|-T] <file1> [<file2> ...]
+
+Short/long options:
+  -d | --dot             Use Graphviz dot to generate the graph and view it with viewnior
+  -f | --fullscreen      View the generated graph in fullscreen mode. It implies option -dot
+  -p | --pre <PREFIX>    Filter graphs with the specified <PREFIX>, e.g. -p "CFG_<function-name>"
+  -a | --ast             Show AST graph. It is equivalent to options "-d -p AST"
+  -c | --cfg             Show CFG graph. It is equivalent to options "-d -p CFG"
+  -s | --syntax          Syntax highlighting the generated TypeScript code
+  -k | --keep            Keep generated files *.java-[0-9]*.out.java which fail to compile with tsc
+  -A | --all             Process all .java files in current directory excluding *.java-[0-9]*.out.java
+  -C | --clean           Clean up generated files (*.java-[0-9]*.out.java)
+  -n | --name            Keep original names by removing "__v[0-9]*" from generated code
+  -t | --treediff        Compare the AST of generated TS code with the one of original TS code
+  -T | --Treediff        Same as -t/--treediff except that it disables tsc for generated TS code
+  <file1> [<file2> ...]  Specify one or more TypeScript files to be processed
+EOF
+exit 1
+}
+CMDLINE="$0 $*"
+DOT= PRE= LIST= VIEWOP= HIGHLIGHT="cat" TSCERR= KEEP= CLEAN= NAME= TREEDIFF= TSC=yes
+while [ $# -gt 0 ]; do
+    case $1 in
+        -d|--dot)        DOT=dot;;
+        -f|--fullscreen) VIEWOP="--fullscreen"; DOT=fullscreen;;
+        -p|--pre)        [ $# -ge 2 ] && { PRE="$2"; shift; } || { echo "$1 needs an argument"; exit 1; } ;;
+        -a|--ast)        PRE="AST" ; DOT=ast ; TSCERR=">& /dev/null" ;;
+        -c|--cfg)        PRE="CFG" ; DOT=cfg ; TSCERR=">& /dev/null" ;;
+        -s|--syntax)     HIGHLIGHT="highlight -O xterm256 --syntax ts" ;;
+        -e|--tscerror)   TSCERR= ;;
+        -k|--keep)       KEEP=keep ;;
+        -C|--clean)      CLEAN=clean ;;
+        -A|--all)        LIST="$LIST $(find -maxdepth 1 -name '*.java')" ;;
+        -n|--name)       NAME="original" ;;
+        -t|--treediff)   TREEDIFF="--emit-ts-only"; NAME="original"; TSC=yes ;;
+        -T|--Treediff)   TREEDIFF="--emit-ts-only"; NAME="original"; TSC= ;;
+        -*)              echo "Unknown option $1"; usage;;
+        *)               LIST="$LIST $1"
+    esac
+    shift
+done
+LIST=$(echo $LIST | xargs -n1 | grep -v '\.java-[0-9][0-9]*\.out.java' | grep -vF .java.tmp.java)
+if [ -n "$CLEAN" ]; then
+  echo Cleaning up generated files...
+  find -maxdepth 1 -regex '.*\.java-[0-9]+\.out.[ctj][ps]p*\|.*\.java-[0-9]+\.[pd][no][gt]\|.*\.java.[ca][ps][pt]' -exec rm '{}' \;
+  rm -rf *.java.orig *.java.gen *.java.tmp.java *[0-9]-dump.out ts2cxx-lock-*
+  for xx in $LIST; do
+    rm -rf $xx.orig $xx.gen $xx.tmp.java $xx.*[0-9]-dump.out $xx-*[0-9].out.java
+  done
+  echo Done.
+fi
+[ -n "$LIST" ] || { echo Please specify one or more TypeScript files.; usage; }
+[ -z "$DOT" ] || [ -x /usr/bin/dot -a -x /usr/bin/viewnior -a -x /usr/bin/highlight ] || sudo apt install graphviz viewnior highlight
+JAVAOUT=$(cd $(dirname $(realpath $0))/../; pwd)/output/java
+JAVA2AST=$JAVAOUT/bin/java2ast
+AST2MPL=$JAVAOUT/bin/ast2mpl
+[ -x "$JAVA2AST" ] || { echo Cannot execute $JAVA2AST; exit 1; }
+[ -x "$AST2MPL" ] || { echo Cannot execute $AST2MPL; exit 1; }
+
+# Acquire/release a lock
+typeset -i LockVar
+LockVar=1
+function AcquireLock {
+    while [[ $LockVar -ne 0 ]] || sleep 0.3; do
+        ln -s Lock_$2 $1-lock-$((LockVar=(LockVar+1)%$3)) > /dev/null 2>&1 && break
+    done
+}
+function ReleaseLock {
+    rm -f $1-lock-$LockVar
+}
+
+PROCID=$$
+#rm -rf *$PROCID-dump.out $PROCID-summary.out *$PROCID.out.java ts2cxx-lock-*
+echo PROCID-dump.out=$PROCID-dump.out $PROCID-summary.out *$PROCID.out.java ts2cxx-lock-*
+rm -f ~/tmp/*
+cnt=0
+for tt in $LIST; do
+  echo $((++cnt)): $tt
+  set -x
+  echo ---------
+  echo "$JAVA2AST" "$tt"
+  out=$("$JAVA2AST" "$tt")
+  if [ $? -ne 0 ]; then
+    echo "MSG: Failed, test case (java2ast)$tt"
+  else
+    echo "$AST2MPL" "$tt".ast --trace=2  $TREEDIFF
+    out=$("$AST2MPL" "$tt".ast --trace=2  $TREEDIFF 2>&1)
+    [ $? -eq 0 ] || echo "MSG: Failed, test case (ast2mpl)$tt"
+  fi
+  echo "$out"
+  $JAVA2AST $tt.java
+  if [ $? -eq 0 ]; then
+    $AST2MPL $tt.java.ast $TREEDIFF | sed -n '/^AstDump:/,/^}/p' | sed 's/\(mStrIdx: unsigned int, \)[0-9]* =>/\1=>/'
+  fi > $tt.orig
+  $JAVA2AST $T
+  if [ $? -eq 0 ]; then
+    $AST2MPL $T.ast $TREEDIFF | sed -n '/^AstDump:/,/^}/p' | sed -e "s|$T|$tt.java|" \
+      -e 's/\(mStrIdx: unsigned int, \)[0-9]* =>/\1=>/'
+  else
+    E="$E,java2ast"
+  fi > $tt.gen
+  diff $tt.orig $tt.gen
+  if [ $? -eq 0 -a -s $tt.orig -a -s $tt.gen ]; then
+    Passed="$Passed $tt"
+    echo "MSG: Passed, test case $tt"
+  else
+    diff -I '[0-9]\. const char\*, "' $tt.orig $tt.gen
+    if [ $? -eq 0 -a -s $tt.orig -a -s $tt.gen ]; then
+      Passed="$Passed $tt"
+      echo "MSG: Passed, test case (const-char*)$tt"
+    else
+      echo "MSG: Failed, test case (diff-ast$E)$tt"
+    fi
+  fi
+  echo === "$T"; cat "$T"
+  echo --- "$tt"; cat "$tt"
+  echo ===
+  if [ -n "$DOT" ]; then
+    for tf in $tt.java $T; do
+      echo "=== $tf"
+      cat $tf
+      out="$out"$'\n'"$($JAVA2AST $tf --dump-dot)"
+    done
+  fi
+  [ -n "$KEEP" ] || rm -f "$T" $tt.orig $tt.gen $tt.java
+  if [ -n "$DOT" ]; then
+    echo --- "$tt"; cat "$tt"
+    idx=0
+    grep -n -e "^digraph $PRE[^{]* {" -e "^}" <<< "$out" | grep -A1 "digraph [^{]* {" |
+      grep -v ^-- | sed 'N;s/\n/ /' | sed -e 's/:digraph [^{]* { */,/' -e 's/:.*/p/g' |
+      { while read cmd; do
+        idx=$((idx+1))
+        sed -n $cmd <<< "$out" > "$tt"-$idx.dot
+        dot -Tpng -o "$tt"-$idx.png "$tt"-$idx.dot
+        # env LC_ALL=C viewnior $VIEWOP "$tt"-$idx.png &
+      done
+      wait
+      rm -f "$tt"-[0-9]*.png "$tt"-[0-9]*.dot; }
+  fi
+done
+wait
+echo Done.
+if [ -s $PROCID-summary.out ]; then
+  msg=$(grep -a "^MSG: [PF]a[si][sl]ed," $PROCID-summary.out)
+  echo "$CMDLINE" >> $PROCID-summary.out
+  if true; then
+    echo
+    echo "Test case(s) passed:"
+    grep -a "^MSG: Passed, test case " <<< "$msg" | sed 's/MSG: Passed, test case //' | env LC_ALL=C sort -r | nl
+    grep -aq -m1 "^MSG: Failed, test case " <<< "$msg"
+    if [ $? -eq 0 ]; then
+      echo
+      echo "Test case(s) failed:"
+      grep -a "^MSG: Failed," <<< "$msg" | sed 's/MSG: Failed, test case //' | env LC_ALL=C sort | nl
+    fi
+    echo
+    echo Total: $(wc -l <<< "$msg"), Passed: $(grep -ac "^MSG: Passed," <<< "$msg"), Failed: $(grep -ac "^MSG: Failed," <<< "$msg")
+    grep -a "^MSG: Failed," <<< "$msg" | sed 's/MSG: Failed, test case (\([^)]*\).*/due to \1/' | sort | uniq -c
+  fi | tee -a $PROCID-summary.out
+fi
diff --git a/src/MapleFE/test/gdbfile b/src/MapleFE/test/gdbfile
deleted file mode 100644
index 31f4b07b22e30fb1524e1f07cb6c3286ba82c803..0000000000000000000000000000000000000000
--- a/src/MapleFE/test/gdbfile
+++ /dev/null
@@ -1,4 +0,0 @@
-file $BUILDDIR/java/java2mpl
-set args t1.java
-b main
-r
diff --git a/src/MapleFE/test/errtest/Point.class b/src/MapleFE/test/java/errtest/Point.class
similarity index 100%
rename from src/MapleFE/test/errtest/Point.class
rename to src/MapleFE/test/java/errtest/Point.class
diff --git a/src/MapleFE/test/errtest/class-field-dup-1.java b/src/MapleFE/test/java/errtest/class-field-dup-1.java
similarity index 100%
rename from src/MapleFE/test/errtest/class-field-dup-1.java
rename to src/MapleFE/test/java/errtest/class-field-dup-1.java
diff --git a/src/MapleFE/test/errtest/class-field-dup-1.java.result b/src/MapleFE/test/java/errtest/class-field-dup-1.java.result
similarity index 100%
rename from src/MapleFE/test/errtest/class-field-dup-1.java.result
rename to src/MapleFE/test/java/errtest/class-field-dup-1.java.result
diff --git a/src/MapleFE/test/errtest/class-field-dup-2.java b/src/MapleFE/test/java/errtest/class-field-dup-2.java
similarity index 100%
rename from src/MapleFE/test/errtest/class-field-dup-2.java
rename to src/MapleFE/test/java/errtest/class-field-dup-2.java
diff --git a/src/MapleFE/test/errtest/class-field-dup-2.java.result b/src/MapleFE/test/java/errtest/class-field-dup-2.java.result
similarity index 100%
rename from src/MapleFE/test/errtest/class-field-dup-2.java.result
rename to src/MapleFE/test/java/errtest/class-field-dup-2.java.result
diff --git a/src/MapleFE/test/errtest/definite-assignment-1.java b/src/MapleFE/test/java/errtest/definite-assignment-1.java
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-1.java
rename to src/MapleFE/test/java/errtest/definite-assignment-1.java
diff --git a/src/MapleFE/test/errtest/definite-assignment-1.java.result b/src/MapleFE/test/java/errtest/definite-assignment-1.java.result
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-1.java.result
rename to src/MapleFE/test/java/errtest/definite-assignment-1.java.result
diff --git a/src/MapleFE/test/errtest/definite-assignment-2.java b/src/MapleFE/test/java/errtest/definite-assignment-2.java
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-2.java
rename to src/MapleFE/test/java/errtest/definite-assignment-2.java
diff --git a/src/MapleFE/test/errtest/definite-assignment-2.java.result b/src/MapleFE/test/java/errtest/definite-assignment-2.java.result
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-2.java.result
rename to src/MapleFE/test/java/errtest/definite-assignment-2.java.result
diff --git a/src/MapleFE/test/errtest/definite-assignment-3.java b/src/MapleFE/test/java/errtest/definite-assignment-3.java
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-3.java
rename to src/MapleFE/test/java/errtest/definite-assignment-3.java
diff --git a/src/MapleFE/test/errtest/definite-assignment-3.java.result b/src/MapleFE/test/java/errtest/definite-assignment-3.java.result
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-3.java.result
rename to src/MapleFE/test/java/errtest/definite-assignment-3.java.result
diff --git a/src/MapleFE/test/errtest/definite-assignment-4.java b/src/MapleFE/test/java/errtest/definite-assignment-4.java
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-4.java
rename to src/MapleFE/test/java/errtest/definite-assignment-4.java
diff --git a/src/MapleFE/test/errtest/definite-assignment-4.java.result b/src/MapleFE/test/java/errtest/definite-assignment-4.java.result
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-4.java.result
rename to src/MapleFE/test/java/errtest/definite-assignment-4.java.result
diff --git a/src/MapleFE/test/errtest/definite-assignment-5.java b/src/MapleFE/test/java/errtest/definite-assignment-5.java
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-5.java
rename to src/MapleFE/test/java/errtest/definite-assignment-5.java
diff --git a/src/MapleFE/test/errtest/definite-assignment-5.java.result b/src/MapleFE/test/java/errtest/definite-assignment-5.java.result
similarity index 96%
rename from src/MapleFE/test/errtest/definite-assignment-5.java.result
rename to src/MapleFE/test/java/errtest/definite-assignment-5.java.result
index 46be40791da6d84464d090e3e90b9dbd84981392..122d471355a0aca9f620ab28c98ea3b1411821ac 100644
--- a/src/MapleFE/test/errtest/definite-assignment-5.java.result
+++ b/src/MapleFE/test/java/errtest/definite-assignment-5.java.result
@@ -9,7 +9,7 @@ class  Point
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:pl
+      Decl: pl
       pl.z Assign 1
       return pl.z
   LocalClasses: 
diff --git a/src/MapleFE/test/errtest/definite-assignment-6.java b/src/MapleFE/test/java/errtest/definite-assignment-6.java
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-6.java
rename to src/MapleFE/test/java/errtest/definite-assignment-6.java
diff --git a/src/MapleFE/test/errtest/definite-assignment-6.java.result b/src/MapleFE/test/java/errtest/definite-assignment-6.java.result
similarity index 68%
rename from src/MapleFE/test/errtest/definite-assignment-6.java.result
rename to src/MapleFE/test/java/errtest/definite-assignment-6.java.result
index dbd6f354215e3278573491d27b4da271d2dc8e5d..2e0cfcd43ee209ad7e789d05352ea6955746fc54 100644
--- a/src/MapleFE/test/errtest/definite-assignment-6.java.result
+++ b/src/MapleFE/test/java/errtest/definite-assignment-6.java.result
@@ -8,9 +8,14 @@ class  Point
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:k
+      Decl: k
       while n LT 4        k Assign n
+        cond-branch cond:k GE 5
+        true branch :
+          break:
+        false branch :
 
+        n Assign 6
 
       System.out.println(k)
   LocalClasses: 
diff --git a/src/MapleFE/test/errtest/definite-assignment-7.java b/src/MapleFE/test/java/errtest/definite-assignment-7.java
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-7.java
rename to src/MapleFE/test/java/errtest/definite-assignment-7.java
diff --git a/src/MapleFE/test/errtest/definite-assignment-7.java.result b/src/MapleFE/test/java/errtest/definite-assignment-7.java.result
similarity index 91%
rename from src/MapleFE/test/errtest/definite-assignment-7.java.result
rename to src/MapleFE/test/java/errtest/definite-assignment-7.java.result
index c468a381e0c98c132717d67ad6926eb48685beed..7a0a5b310e26ed6cbc2981c2272d18fd696f3271 100644
--- a/src/MapleFE/test/errtest/definite-assignment-7.java.result
+++ b/src/MapleFE/test/java/errtest/definite-assignment-7.java.result
@@ -8,8 +8,8 @@ class  Point
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:k
-      var:n=5
+      Decl: k
+      Decl: n=5
       cond-branch cond:n GT 2
       true branch :
         k Assign 3      false branch :
diff --git a/src/MapleFE/test/errtest/definite-assignment-8.java b/src/MapleFE/test/java/errtest/definite-assignment-8.java
similarity index 100%
rename from src/MapleFE/test/errtest/definite-assignment-8.java
rename to src/MapleFE/test/java/errtest/definite-assignment-8.java
diff --git a/src/MapleFE/test/errtest/definite-assignment-8.java.result b/src/MapleFE/test/java/errtest/definite-assignment-8.java.result
similarity index 89%
rename from src/MapleFE/test/errtest/definite-assignment-8.java.result
rename to src/MapleFE/test/java/errtest/definite-assignment-8.java.result
index 54716ecde467bb990ae0a8b0aa9483885785a734..e3f0e3c4409d900d538423bb4f9a6814e2fbc441 100644
--- a/src/MapleFE/test/errtest/definite-assignment-8.java.result
+++ b/src/MapleFE/test/java/errtest/definite-assignment-8.java.result
@@ -7,8 +7,8 @@ class  Point
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  flow()  throws: 
-      var:k
+    func  flow(flag)  throws: 
+      Decl: k
       cond-branch cond:flag
       true branch :
         k Assign 3      false branch :
diff --git a/src/MapleFE/test/errtest/fun-param-1.java b/src/MapleFE/test/java/errtest/fun-param-1.java
similarity index 100%
rename from src/MapleFE/test/errtest/fun-param-1.java
rename to src/MapleFE/test/java/errtest/fun-param-1.java
diff --git a/src/MapleFE/test/errtest/fun-param-1.java.result b/src/MapleFE/test/java/errtest/fun-param-1.java.result
similarity index 100%
rename from src/MapleFE/test/errtest/fun-param-1.java.result
rename to src/MapleFE/test/java/errtest/fun-param-1.java.result
diff --git a/src/MapleFE/test/errtest/func-dup-1.java b/src/MapleFE/test/java/errtest/func-dup-1.java
similarity index 100%
rename from src/MapleFE/test/errtest/func-dup-1.java
rename to src/MapleFE/test/java/errtest/func-dup-1.java
diff --git a/src/MapleFE/test/errtest/func-dup-1.java.result b/src/MapleFE/test/java/errtest/func-dup-1.java.result
similarity index 75%
rename from src/MapleFE/test/errtest/func-dup-1.java.result
rename to src/MapleFE/test/java/errtest/func-dup-1.java.result
index 1a3b6b7077899782927dcb665f8ebf820640da8a..e15de87904fd0abaa09181c30a775871270733fd 100644
--- a/src/MapleFE/test/errtest/func-dup-1.java.result
+++ b/src/MapleFE/test/java/errtest/func-dup-1.java.result
@@ -7,8 +7,8 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
-    func  foo()  throws: 
+    func  foo(c,b)  throws: 
+    func  foo(i,b,c)  throws: 
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/errtest/generate-result.sh b/src/MapleFE/test/java/errtest/generate-result.sh
similarity index 92%
rename from src/MapleFE/test/errtest/generate-result.sh
rename to src/MapleFE/test/java/errtest/generate-result.sh
index 9e1585b384c4e043acf8f6551a256a2ee41f7f20..08b3acc3b58dc1585fb15888064b004629e72007 100755
--- a/src/MapleFE/test/errtest/generate-result.sh
+++ b/src/MapleFE/test/java/errtest/generate-result.sh
@@ -17,5 +17,5 @@ FILES=$(pwd)/*.java
 for f in $FILES
 do
   echo "Generating result for $f ..."
-  $BUILDDIR/java/java2mpl $f > $f.result
+  ../../../output/java/java/java2mpl $f > $f.result
 done
diff --git a/src/MapleFE/test/errtest/new-class-nodecl.java b/src/MapleFE/test/java/errtest/new-class-nodecl.java
similarity index 100%
rename from src/MapleFE/test/errtest/new-class-nodecl.java
rename to src/MapleFE/test/java/errtest/new-class-nodecl.java
diff --git a/src/MapleFE/test/errtest/new-class-nodecl.java.result b/src/MapleFE/test/java/errtest/new-class-nodecl.java.result
similarity index 90%
rename from src/MapleFE/test/errtest/new-class-nodecl.java.result
rename to src/MapleFE/test/java/errtest/new-class-nodecl.java.result
index dae33b0a3fddbf6052438231ef602b7c352b1e43..b54ce6497757b1fe6579b5dd024179151531b77d 100644
--- a/src/MapleFE/test/errtest/new-class-nodecl.java.result
+++ b/src/MapleFE/test/java/errtest/new-class-nodecl.java.result
@@ -8,7 +8,7 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      new Cyclic<Cyclic>
+      new Cyclic()
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/errtest/new-param-nodecl.java b/src/MapleFE/test/java/errtest/new-param-nodecl.java
similarity index 100%
rename from src/MapleFE/test/errtest/new-param-nodecl.java
rename to src/MapleFE/test/java/errtest/new-param-nodecl.java
diff --git a/src/MapleFE/test/errtest/new-param-nodecl.java.result b/src/MapleFE/test/java/errtest/new-param-nodecl.java.result
similarity index 94%
rename from src/MapleFE/test/errtest/new-param-nodecl.java.result
rename to src/MapleFE/test/java/errtest/new-param-nodecl.java.result
index 4e496b1c10557801f985647afcedf740d99497f5..452a50a7237d54b7b5146f5c8240fa0f3850a030 100644
--- a/src/MapleFE/test/errtest/new-param-nodecl.java.result
+++ b/src/MapleFE/test/java/errtest/new-param-nodecl.java.result
@@ -9,7 +9,7 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      new Cyclic<Cyclic>
+      new Cyclic(a,b)
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/errtest/var-no-decl-1.java b/src/MapleFE/test/java/errtest/var-no-decl-1.java
similarity index 100%
rename from src/MapleFE/test/errtest/var-no-decl-1.java
rename to src/MapleFE/test/java/errtest/var-no-decl-1.java
diff --git a/src/MapleFE/test/errtest/var-no-decl-1.java.result b/src/MapleFE/test/java/errtest/var-no-decl-1.java.result
similarity index 86%
rename from src/MapleFE/test/errtest/var-no-decl-1.java.result
rename to src/MapleFE/test/java/errtest/var-no-decl-1.java.result
index 5b6375ed5b910025aa1b7ff760e9d76a3620dfb4..8e3b5b1a9dfa0a0239a58c4669943b189ff3a5fa 100644
--- a/src/MapleFE/test/errtest/var-no-decl-1.java.result
+++ b/src/MapleFE/test/java/errtest/var-no-decl-1.java.result
@@ -8,9 +8,10 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:a
+      Decl: a
       a Assign b
   LocalClasses: 
   LocalInterfaces: 
 
+Identifier:a has no decl.
 Identifier:b has no decl.
diff --git a/src/MapleFE/test/errtest/var-no-decl-2.java b/src/MapleFE/test/java/errtest/var-no-decl-2.java
similarity index 100%
rename from src/MapleFE/test/errtest/var-no-decl-2.java
rename to src/MapleFE/test/java/errtest/var-no-decl-2.java
diff --git a/src/MapleFE/test/errtest/var-no-decl-2.java.result b/src/MapleFE/test/java/errtest/var-no-decl-2.java.result
similarity index 100%
rename from src/MapleFE/test/errtest/var-no-decl-2.java.result
rename to src/MapleFE/test/java/errtest/var-no-decl-2.java.result
diff --git a/src/MapleFE/test/errtest/var-no-decl-3.java b/src/MapleFE/test/java/errtest/var-no-decl-3.java
similarity index 100%
rename from src/MapleFE/test/errtest/var-no-decl-3.java
rename to src/MapleFE/test/java/errtest/var-no-decl-3.java
diff --git a/src/MapleFE/test/errtest/var-no-decl-3.java.result b/src/MapleFE/test/java/errtest/var-no-decl-3.java.result
similarity index 100%
rename from src/MapleFE/test/errtest/var-no-decl-3.java.result
rename to src/MapleFE/test/java/errtest/var-no-decl-3.java.result
diff --git a/src/MapleFE/test/java2mpl/annotation-marker.java b/src/MapleFE/test/java/java2mpl/annotation-marker.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/annotation-marker.java
rename to src/MapleFE/test/java/java2mpl/annotation-marker.java
diff --git a/src/MapleFE/test/java2mpl/annotation-marker.java.result b/src/MapleFE/test/java/java2mpl/annotation-marker.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/annotation-marker.java.result
rename to src/MapleFE/test/java/java2mpl/annotation-marker.java.result
diff --git a/src/MapleFE/test/java2mpl/annotation-single-elem.java b/src/MapleFE/test/java/java2mpl/annotation-single-elem.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/annotation-single-elem.java
rename to src/MapleFE/test/java/java2mpl/annotation-single-elem.java
diff --git a/src/MapleFE/test/java2mpl/annotation-single-elem.java.result b/src/MapleFE/test/java/java2mpl/annotation-single-elem.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/annotation-single-elem.java.result
rename to src/MapleFE/test/java/java2mpl/annotation-single-elem.java.result
diff --git a/src/MapleFE/test/java2mpl/annotation-type-decl.java b/src/MapleFE/test/java/java2mpl/annotation-type-decl.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/annotation-type-decl.java
rename to src/MapleFE/test/java/java2mpl/annotation-type-decl.java
diff --git a/src/MapleFE/test/java2mpl/annotation-type-decl.java.result b/src/MapleFE/test/java/java2mpl/annotation-type-decl.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/annotation-type-decl.java.result
rename to src/MapleFE/test/java/java2mpl/annotation-type-decl.java.result
diff --git a/src/MapleFE/test/java2mpl/annotation-useage.java b/src/MapleFE/test/java/java2mpl/annotation-useage.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/annotation-useage.java
rename to src/MapleFE/test/java/java2mpl/annotation-useage.java
diff --git a/src/MapleFE/test/java2mpl/annotation-useage.java.result b/src/MapleFE/test/java/java2mpl/annotation-useage.java.result
similarity index 77%
rename from src/MapleFE/test/java2mpl/annotation-useage.java.result
rename to src/MapleFE/test/java/java2mpl/annotation-useage.java.result
index a3e660fd181da2ad43978b1fbd62843a66e4cdff..1f64c090b4f1460068047d9e116dc344b9478ca8 100644
--- a/src/MapleFE/test/java2mpl/annotation-useage.java.result
+++ b/src/MapleFE/test/java/java2mpl/annotation-useage.java.result
@@ -7,7 +7,7 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  travelThroughTime()  throws: 
+    func  travelThroughTime(destination)  throws: 
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/array-2d.java b/src/MapleFE/test/java/java2mpl/array-2d.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/array-2d.java
rename to src/MapleFE/test/java/java2mpl/array-2d.java
diff --git a/src/MapleFE/test/java2mpl/array-2d.java.result b/src/MapleFE/test/java/java2mpl/array-2d.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/array-2d.java.result
rename to src/MapleFE/test/java/java2mpl/array-2d.java.result
diff --git a/src/MapleFE/test/java2mpl/array-access.java b/src/MapleFE/test/java/java2mpl/array-access.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/array-access.java
rename to src/MapleFE/test/java/java2mpl/array-access.java
diff --git a/src/MapleFE/test/java2mpl/array-access.java.result b/src/MapleFE/test/java/java2mpl/array-access.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/array-access.java.result
rename to src/MapleFE/test/java/java2mpl/array-access.java.result
diff --git a/src/MapleFE/test/java2mpl/array-init.java b/src/MapleFE/test/java/java2mpl/array-init.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/array-init.java
rename to src/MapleFE/test/java/java2mpl/array-init.java
diff --git a/src/MapleFE/test/java2mpl/array-init.java.result b/src/MapleFE/test/java/java2mpl/array-init.java.result
similarity index 78%
rename from src/MapleFE/test/java2mpl/array-init.java.result
rename to src/MapleFE/test/java/java2mpl/array-init.java.result
index 66f4a67617a83bcb17b0c27bcf586a77ed2f6a51..3ef43504c621e734813d2c79a03ab7040f8ac918 100644
--- a/src/MapleFE/test/java2mpl/array-init.java.result
+++ b/src/MapleFE/test/java/java2mpl/array-init.java.result
@@ -8,9 +8,9 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:ba=
-      var:array=[]
-      var:array=[]
+      Decl: ba=
+      Decl: array=[]
+      Decl: array=[]
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/array.java b/src/MapleFE/test/java/java2mpl/array.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/array.java
rename to src/MapleFE/test/java/java2mpl/array.java
diff --git a/src/MapleFE/test/java2mpl/array.java.result b/src/MapleFE/test/java/java2mpl/array.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/array.java.result
rename to src/MapleFE/test/java/java2mpl/array.java.result
diff --git a/src/MapleFE/test/java2mpl/assert.java b/src/MapleFE/test/java/java2mpl/assert.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/assert.java
rename to src/MapleFE/test/java/java2mpl/assert.java
diff --git a/src/MapleFE/test/java2mpl/assert.java.result b/src/MapleFE/test/java/java2mpl/assert.java.result
similarity index 87%
rename from src/MapleFE/test/java2mpl/assert.java.result
rename to src/MapleFE/test/java/java2mpl/assert.java.result
index 5e8b03621585d4050be1e101251f7004ddc0ffa9..16a94b50a7df4c987ace27e3a7c273f576c42806 100644
--- a/src/MapleFE/test/java2mpl/assert.java.result
+++ b/src/MapleFE/test/java/java2mpl/assert.java.result
@@ -7,7 +7,7 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
+    func  foo(a,b)  throws: 
       assert a LT b : 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/assignment.java b/src/MapleFE/test/java/java2mpl/assignment.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/assignment.java
rename to src/MapleFE/test/java/java2mpl/assignment.java
diff --git a/src/MapleFE/test/java2mpl/assignment.java.result b/src/MapleFE/test/java/java2mpl/assignment.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/assignment.java.result
rename to src/MapleFE/test/java/java2mpl/assignment.java.result
diff --git a/src/MapleFE/test/java2mpl/binary-expr-1.java b/src/MapleFE/test/java/java2mpl/binary-expr-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/binary-expr-1.java
rename to src/MapleFE/test/java/java2mpl/binary-expr-1.java
diff --git a/src/MapleFE/test/java2mpl/binary-expr-1.java.result b/src/MapleFE/test/java/java2mpl/binary-expr-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/binary-expr-1.java.result
rename to src/MapleFE/test/java/java2mpl/binary-expr-1.java.result
diff --git a/src/MapleFE/test/java2mpl/binary-expr-2.java b/src/MapleFE/test/java/java2mpl/binary-expr-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/binary-expr-2.java
rename to src/MapleFE/test/java/java2mpl/binary-expr-2.java
diff --git a/src/MapleFE/test/java2mpl/binary-expr-2.java.result b/src/MapleFE/test/java/java2mpl/binary-expr-2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/binary-expr-2.java.result
rename to src/MapleFE/test/java/java2mpl/binary-expr-2.java.result
diff --git a/src/MapleFE/test/java2mpl/binary-expr-3.java b/src/MapleFE/test/java/java2mpl/binary-expr-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/binary-expr-3.java
rename to src/MapleFE/test/java/java2mpl/binary-expr-3.java
diff --git a/src/MapleFE/test/java2mpl/binary-expr-3.java.result b/src/MapleFE/test/java/java2mpl/binary-expr-3.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/binary-expr-3.java.result
rename to src/MapleFE/test/java/java2mpl/binary-expr-3.java.result
diff --git a/src/MapleFE/test/java2mpl/binary-expr-4.java b/src/MapleFE/test/java/java2mpl/binary-expr-4.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/binary-expr-4.java
rename to src/MapleFE/test/java/java2mpl/binary-expr-4.java
diff --git a/src/MapleFE/test/java2mpl/binary-expr-4.java.result b/src/MapleFE/test/java/java2mpl/binary-expr-4.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/binary-expr-4.java.result
rename to src/MapleFE/test/java/java2mpl/binary-expr-4.java.result
diff --git a/src/MapleFE/test/java2mpl/binary-expr.java b/src/MapleFE/test/java/java2mpl/binary-expr.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/binary-expr.java
rename to src/MapleFE/test/java/java2mpl/binary-expr.java
diff --git a/src/MapleFE/test/java2mpl/binary-expr.java.result b/src/MapleFE/test/java/java2mpl/binary-expr.java.result
similarity index 36%
rename from src/MapleFE/test/java2mpl/binary-expr.java.result
rename to src/MapleFE/test/java/java2mpl/binary-expr.java.result
index cdbfae457762078f979563e89710058d7f0507e8..c17eb9683da4b55f6b21b2ae0a5abc3504be38d1 100644
--- a/src/MapleFE/test/java2mpl/binary-expr.java.result
+++ b/src/MapleFE/test/java/java2mpl/binary-expr.java.result
@@ -8,7 +8,7 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:a,b,c
+      Decl: a,b,c
       a Assign b Add c
       a Assign b Sub c
       a Assign b GT c
@@ -21,3 +21,30 @@ class  A
   LocalClasses: 
   LocalInterfaces: 
 
+Identifier:a has no decl.
+Identifier:b has no decl.
+Identifier:c has no decl.
+Identifier:a has no decl.
+Identifier:b has no decl.
+Identifier:c has no decl.
+Identifier:a has no decl.
+Identifier:b has no decl.
+Identifier:c has no decl.
+Identifier:a has no decl.
+Identifier:b has no decl.
+Identifier:c has no decl.
+Identifier:a has no decl.
+Identifier:b has no decl.
+Identifier:c has no decl.
+Identifier:a has no decl.
+Identifier:b has no decl.
+Identifier:c has no decl.
+Identifier:a has no decl.
+Identifier:b has no decl.
+Identifier:c has no decl.
+Identifier:a has no decl.
+Identifier:b has no decl.
+Identifier:c has no decl.
+Identifier:a has no decl.
+Identifier:b has no decl.
+Identifier:c has no decl.
diff --git a/src/MapleFE/test/java2mpl/call-1.java b/src/MapleFE/test/java/java2mpl/call-1.java
similarity index 94%
rename from src/MapleFE/test/java2mpl/call-1.java
rename to src/MapleFE/test/java/java2mpl/call-1.java
index 1dab53c13ee39d0137e35fd78c56173feec84567..749296a93c6f1640b14620019a658782effd873e 100644
--- a/src/MapleFE/test/java2mpl/call-1.java
+++ b/src/MapleFE/test/java/java2mpl/call-1.java
@@ -13,7 +13,8 @@
 //See the Mulan PSL v2 for more details.
 //
 class A {
+  void println() {}
   void foo() {
-    println(c);
+    println();
   }
 }
diff --git a/src/MapleFE/test/java2mpl/call-1.java.result b/src/MapleFE/test/java/java2mpl/call-1.java.result
similarity index 74%
rename from src/MapleFE/test/java2mpl/call-1.java.result
rename to src/MapleFE/test/java/java2mpl/call-1.java.result
index 7b1a54d690a1ddeda74cdc8d8a7ab52f58e98271..00599325f8be757af7b1762ef0a594cd1fa25d5f 100644
--- a/src/MapleFE/test/java2mpl/call-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/call-1.java.result
@@ -1,4 +1,4 @@
-Matched 15 tokens.
+Matched 20 tokens.
 ============= Module ===========
 == Sub Tree ==
 class  A
@@ -7,8 +7,9 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
+    func  println()  throws: 
     func  foo()  throws: 
-      println(c)
+      println()
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/call-2.java b/src/MapleFE/test/java/java2mpl/call-2.java
similarity index 91%
rename from src/MapleFE/test/java2mpl/call-2.java
rename to src/MapleFE/test/java/java2mpl/call-2.java
index 5ad3b36674bf4ff32ace41498c6cde0aae1c7567..315d053548472c2681db79f45d32fb7321c9022b 100644
--- a/src/MapleFE/test/java2mpl/call-2.java
+++ b/src/MapleFE/test/java/java2mpl/call-2.java
@@ -13,7 +13,8 @@
 //See the Mulan PSL v2 for more details.
 //
 class A {
+  void println(char c, int a) {}
   void foo() {
-    println(c, a);
+    println('a', 1);
   }
 }
diff --git a/src/MapleFE/test/java2mpl/call-2.java.result b/src/MapleFE/test/java/java2mpl/call-2.java.result
similarity index 72%
rename from src/MapleFE/test/java2mpl/call-2.java.result
rename to src/MapleFE/test/java/java2mpl/call-2.java.result
index 0f2a36102d38c5a7bff60fce9016ee322e6cfae1..d93d7abeeac17023bbe34f76127160e2ddd62abc 100644
--- a/src/MapleFE/test/java2mpl/call-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/call-2.java.result
@@ -1,4 +1,4 @@
-Matched 17 tokens.
+Matched 28 tokens.
 ============= Module ===========
 == Sub Tree ==
 class  A
@@ -7,8 +7,9 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
+    func  println(c,a)  throws: 
     func  foo()  throws: 
-      println(c,a)
+      println(a,1)
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/call-3.java b/src/MapleFE/test/java/java2mpl/call-3.java
similarity index 87%
rename from src/MapleFE/test/java2mpl/call-3.java
rename to src/MapleFE/test/java/java2mpl/call-3.java
index f6578decf51503b17ff5d3ed4f414a0c113aeafc..2cbca58e90b3cb31eff2b3397e5868deaf32921d 100644
--- a/src/MapleFE/test/java2mpl/call-3.java
+++ b/src/MapleFE/test/java/java2mpl/call-3.java
@@ -13,7 +13,8 @@
 //See the Mulan PSL v2 for more details.
 //
 class A {
-  void foo() {
-    println(c+1, a);
+  void println(char c, int a) {}
+  void foo(char c, int a) {
+    println(c, a);
   }
 }
diff --git a/src/MapleFE/test/java/java2mpl/call-3.java.result b/src/MapleFE/test/java/java2mpl/call-3.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..e4cd31cb30e39ada338cb254b10c91ed6d41f425
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/call-3.java.result
@@ -0,0 +1,15 @@
+Matched 33 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  println(c,a)  throws: 
+    func  foo(c,a)  throws: 
+      println(c,a)
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java2mpl/call-4.java b/src/MapleFE/test/java/java2mpl/call-4.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/call-4.java
rename to src/MapleFE/test/java/java2mpl/call-4.java
diff --git a/src/MapleFE/test/java2mpl/call-4.java.result b/src/MapleFE/test/java/java2mpl/call-4.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/call-4.java.result
rename to src/MapleFE/test/java/java2mpl/call-4.java.result
diff --git a/src/MapleFE/test/java2mpl/call-5.java b/src/MapleFE/test/java/java2mpl/call-5.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/call-5.java
rename to src/MapleFE/test/java/java2mpl/call-5.java
diff --git a/src/MapleFE/test/java2mpl/call-5.java.result b/src/MapleFE/test/java/java2mpl/call-5.java.result
similarity index 78%
rename from src/MapleFE/test/java2mpl/call-5.java.result
rename to src/MapleFE/test/java/java2mpl/call-5.java.result
index 0addd443fa0633d217a13a0b62e5ed719636db3b..6f0495e478e15adaefe9afb3c1084606b10a5401 100644
--- a/src/MapleFE/test/java2mpl/call-5.java.result
+++ b/src/MapleFE/test/java/java2mpl/call-5.java.result
@@ -8,7 +8,7 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:socket=new Socket<Socket>
+      Decl: socket=new Socket("localhost",listeningPort)
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java/java2mpl/call-6.java b/src/MapleFE/test/java/java2mpl/call-6.java
new file mode 100644
index 0000000000000000000000000000000000000000..c50c134fc5ed1a9d614a85c117819ba0008a6904
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/call-6.java
@@ -0,0 +1,21 @@
+//
+//Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+//
+//OpenArkFE is licensed under the Mulan PSL v2.
+//You can use this software according to the terms and conditions of the Mulan PSL v2.
+//You may obtain a copy of Mulan PSL v2 at:
+//
+// http://license.coscl.org.cn/MulanPSL2
+//
+//THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+//EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+//FIT FOR A PARTICULAR PURPOSE.
+//See the Mulan PSL v2 for more details.
+//
+class A {
+  int bar(char c) { return 1; }
+  void foo(char c) {
+    int i;
+    i = bar(c);
+  }
+}
diff --git a/src/MapleFE/test/java/java2mpl/call-6.java.result b/src/MapleFE/test/java/java2mpl/call-6.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..9e07cabbf805525a53b101f2ff8cc6a850e31ee0
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/call-6.java.result
@@ -0,0 +1,18 @@
+Matched 33 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  bar(c)  throws: 
+      return 1
+    func  foo(c)  throws: 
+      Decl: i
+      i Assign bar(c)
+  LocalClasses: 
+  LocalInterfaces: 
+
+Identifier:i has no decl.
diff --git a/src/MapleFE/test/java/java2mpl/call-7.java b/src/MapleFE/test/java/java2mpl/call-7.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d89cb0d8c5bc486c4624e11b74fec8b0e69988d
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/call-7.java
@@ -0,0 +1,26 @@
+//
+//Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+//
+//OpenArkFE is licensed under the Mulan PSL v2.
+//You can use this software according to the terms and conditions of the Mulan PSL v2.
+//You may obtain a copy of Mulan PSL v2 at:
+//
+// http://license.coscl.org.cn/MulanPSL2
+//
+//THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+//EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+//FIT FOR A PARTICULAR PURPOSE.
+//See the Mulan PSL v2 for more details.
+//
+class B {
+  int bar(int c, int a) {
+    c += a;
+    return c;
+  }
+}
+
+class A {
+  int foo(B b) {
+    return b.bar(3, 4);
+  }
+}
diff --git a/src/MapleFE/test/java/java2mpl/call-7.java.result b/src/MapleFE/test/java/java2mpl/call-7.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..be32c9b7d483f8f204644fcd59cfd1ee6d2ed795
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/call-7.java.result
@@ -0,0 +1,28 @@
+Matched 22 tokens.
+Matched 44 tokens.
+============= Module ===========
+== Sub Tree ==
+class  B
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  bar(c,a)  throws: 
+      c AddAssign a
+      return c
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  A
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  foo(b)  throws: 
+      return b.bar(3,4)
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/java2mpl/call-8.java b/src/MapleFE/test/java/java2mpl/call-8.java
new file mode 100644
index 0000000000000000000000000000000000000000..68ca75463eab2d199bf7282930132016ee626871
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/call-8.java
@@ -0,0 +1,29 @@
+//
+//Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+//
+//OpenArkFE is licensed under the Mulan PSL v2.
+//You can use this software according to the terms and conditions of the Mulan PSL v2.
+//You may obtain a copy of Mulan PSL v2 at:
+//
+// http://license.coscl.org.cn/MulanPSL2
+//
+//THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+//EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+//FIT FOR A PARTICULAR PURPOSE.
+//See the Mulan PSL v2 for more details.
+//
+class A {
+  int f;
+  int bar(int c, A a) { return c; }
+  int bar(int c, int a) { return a; }
+  int bar(A a) { return f; }
+  int foo(A b) {
+    int i = 0;
+    int j = 3;
+    int k = 4;
+    i = bar(i);
+    j = bar(j, k);
+    k = bar(j, this);
+    return i + j + k;
+  }
+}
diff --git a/src/MapleFE/test/java/java2mpl/call-8.java.result b/src/MapleFE/test/java/java2mpl/call-8.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..1ac416e49e35d2d8b79698376c5eab2d3977cbff
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/call-8.java.result
@@ -0,0 +1,29 @@
+Matched 101 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+    f
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  bar(c,a)  throws: 
+      return c
+    func  bar(c,a)  throws: 
+      return a
+    func  bar(a)  throws: 
+      return f
+    func  foo(b)  throws: 
+      Decl: i=0
+      Decl: j=3
+      Decl: k=4
+      i Assign bar(i)
+      j Assign bar(j,k)
+      k Assign bar(j,this)
+      return i Add j Add k
+  LocalClasses: 
+  LocalInterfaces: 
+
+Identifier:i has no decl.
+Identifier:j has no decl.
+Identifier:k has no decl.
diff --git a/src/MapleFE/test/sharedfe/add2.java b/src/MapleFE/test/java/java2mpl/call-param.java
similarity index 90%
rename from src/MapleFE/test/sharedfe/add2.java
rename to src/MapleFE/test/java/java2mpl/call-param.java
index 7f9c2a8f24dd8d66c4358eeab2251c8de35d71d1..eaed074e0fe533038ec2d7318ff163ed64e6b9b9 100644
--- a/src/MapleFE/test/sharedfe/add2.java
+++ b/src/MapleFE/test/java/java2mpl/call-param.java
@@ -12,10 +12,8 @@
 //FIT FOR A PARTICULAR PURPOSE.
 //See the Mulan PSL v2 for more details.
 //
-
-int foo(int a, int b) {
-  int c;
-
-  c = a + b;
-  return c;
+class A {
+  void foo(int c) {
+    println(c);
+  }
 }
diff --git a/src/MapleFE/test/java2mpl/call-3.java.result b/src/MapleFE/test/java/java2mpl/call-param.java.result
similarity index 69%
rename from src/MapleFE/test/java2mpl/call-3.java.result
rename to src/MapleFE/test/java/java2mpl/call-param.java.result
index 75eeeb5eba57813fd5c125aeb80afebf21dd84b5..058a3d0a1a765659f3b305ea8e88a7c2b4dd60b4 100644
--- a/src/MapleFE/test/java2mpl/call-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/call-param.java.result
@@ -1,4 +1,4 @@
-Matched 19 tokens.
+Matched 17 tokens.
 ============= Module ===========
 == Sub Tree ==
 class  A
@@ -7,8 +7,8 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
-      println(c Add 1,a)
+    func  foo(c)  throws: 
+      println(c)
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/cast-1.java b/src/MapleFE/test/java/java2mpl/cast-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/cast-1.java
rename to src/MapleFE/test/java/java2mpl/cast-1.java
diff --git a/src/MapleFE/test/java2mpl/cast-1.java.result b/src/MapleFE/test/java/java2mpl/cast-1.java.result
similarity index 73%
rename from src/MapleFE/test/java2mpl/cast-1.java.result
rename to src/MapleFE/test/java/java2mpl/cast-1.java.result
index 05d4989550b031a22b210e597570d9ba52e4368d..50dd6170c0555c65ec5dcda78983a90d7cc38fb4 100644
--- a/src/MapleFE/test/java2mpl/cast-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/cast-1.java.result
@@ -19,7 +19,7 @@ interface  Colorable
   Fields: 
 
   Methods: 
-    func  setColor()  throws: 
+    func  setColor(color)  throws: 
 
 == Sub Tree ==
 class  ColoredPoint
@@ -28,7 +28,7 @@ class  ColoredPoint
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  setColor()  throws: 
+    func  setColor(color)  throws: 
       this.color Assign color
   LocalClasses: 
   LocalInterfaces: 
@@ -50,15 +50,18 @@ class  Test
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  main()  throws: 
-      var:p=new Point<Point>
-      var:cp=new ColoredPoint<ColoredPoint>
-      var:c
+    func  main(args)  throws: 
+      Decl: p=new Point()
+      Decl: cp=new ColoredPoint()
+      Decl: c
       cp Assign (ColoredPoint)p
       c Assign (Colorable)p
-      var:l=(Long)p
-      var:e=new EndPoint<EndPoint>
+      Decl: l=(Long)p
+      Decl: e=new EndPoint()
       c Assign (Colorable)e
   LocalClasses: 
   LocalInterfaces: 
 
+Identifier:cp has no decl.
+Identifier:c has no decl.
+Identifier:c has no decl.
diff --git a/src/MapleFE/test/java2mpl/cast-2.java b/src/MapleFE/test/java/java2mpl/cast-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/cast-2.java
rename to src/MapleFE/test/java/java2mpl/cast-2.java
diff --git a/src/MapleFE/test/java2mpl/cast-2.java.result b/src/MapleFE/test/java/java2mpl/cast-2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/cast-2.java.result
rename to src/MapleFE/test/java/java2mpl/cast-2.java.result
diff --git a/src/MapleFE/test/java2mpl/class-anonymous.java b/src/MapleFE/test/java/java2mpl/class-anonymous.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-anonymous.java
rename to src/MapleFE/test/java/java2mpl/class-anonymous.java
diff --git a/src/MapleFE/test/java2mpl/class-anonymous.java.result b/src/MapleFE/test/java/java2mpl/class-anonymous.java.result
similarity index 83%
rename from src/MapleFE/test/java2mpl/class-anonymous.java.result
rename to src/MapleFE/test/java/java2mpl/class-anonymous.java.result
index 5dd2661dbf5ef9a1262d47cf44c7b3dfc8675c40..69dec033ca83d6d62bb51a8bf318dbe45cab967b 100644
--- a/src/MapleFE/test/java2mpl/class-anonymous.java.result
+++ b/src/MapleFE/test/java/java2mpl/class-anonymous.java.result
@@ -8,7 +8,7 @@ class  ChatTest
   Constructors: 
   Methods: 
     func  performDontReceiveMessageInNameState()  throws:     Exception
-      var:client2=new Thread<Thread>
+      Decl: client2=new Thread(new ChatConnection())
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/class-constructor-explicit-2.java b/src/MapleFE/test/java/java2mpl/class-constructor-explicit-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-constructor-explicit-2.java
rename to src/MapleFE/test/java/java2mpl/class-constructor-explicit-2.java
diff --git a/src/MapleFE/test/java2mpl/class-constructor-explicit-2.java.result b/src/MapleFE/test/java/java2mpl/class-constructor-explicit-2.java.result
similarity index 76%
rename from src/MapleFE/test/java2mpl/class-constructor-explicit-2.java.result
rename to src/MapleFE/test/java/java2mpl/class-constructor-explicit-2.java.result
index a2e56860a7eb31a9e86e27dd1b9929d646eb9bc8..3130fa4e825f9fa930afb2a9b417b7288aa59d8d 100644
--- a/src/MapleFE/test/java2mpl/class-constructor-explicit-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/class-constructor-explicit-2.java.result
@@ -7,7 +7,7 @@ class  Point
     x    y
   Instance Initializer: 
   Constructors: 
-    constructor  Point()  throws: 
+    constructor  Point(x,y)  throws: 
       this.x Assign x
       this.y Assign y
   Methods: 
@@ -20,8 +20,8 @@ class  ColoredPoint
     WHITE=0    color
   Instance Initializer: 
   Constructors: 
-    constructor  ColoredPoint()  throws: 
-    constructor  ColoredPoint()  throws: 
+    constructor  ColoredPoint(x,y)  throws: 
+    constructor  ColoredPoint(x,y,color)  throws: 
       this.color Assign color
   Methods: 
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/class-constructor-explicit.java b/src/MapleFE/test/java/java2mpl/class-constructor-explicit.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-constructor-explicit.java
rename to src/MapleFE/test/java/java2mpl/class-constructor-explicit.java
diff --git a/src/MapleFE/test/java2mpl/class-constructor-explicit.java.result b/src/MapleFE/test/java/java2mpl/class-constructor-explicit.java.result
similarity index 85%
rename from src/MapleFE/test/java2mpl/class-constructor-explicit.java.result
rename to src/MapleFE/test/java/java2mpl/class-constructor-explicit.java.result
index 5194e250689f7824d8775eef28dcc95aea99c5dd..51e2d3636b85711fb1df3909b16776e020e146f6 100644
--- a/src/MapleFE/test/java2mpl/class-constructor-explicit.java.result
+++ b/src/MapleFE/test/java/java2mpl/class-constructor-explicit.java.result
@@ -6,7 +6,7 @@ class  Point
     x    y
   Instance Initializer: 
   Constructors: 
-    constructor  Point()  throws: 
+    constructor  Point(y)  throws: 
       this.y Assign y
   Methods: 
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/class-constructor.java b/src/MapleFE/test/java/java2mpl/class-constructor.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-constructor.java
rename to src/MapleFE/test/java/java2mpl/class-constructor.java
diff --git a/src/MapleFE/test/java2mpl/class-constructor.java.result b/src/MapleFE/test/java/java2mpl/class-constructor.java.result
similarity index 86%
rename from src/MapleFE/test/java2mpl/class-constructor.java.result
rename to src/MapleFE/test/java/java2mpl/class-constructor.java.result
index d9c4a0af8eb133761c6002521e117587358765bf..ef94fd9d7618926f879363fb37540882c065f77a 100644
--- a/src/MapleFE/test/java2mpl/class-constructor.java.result
+++ b/src/MapleFE/test/java/java2mpl/class-constructor.java.result
@@ -6,7 +6,7 @@ class  Point
     x    y
   Instance Initializer: 
   Constructors: 
-    constructor  Point()  throws: 
+    constructor  Point(x,y)  throws: 
       this.x Assign x
       this.y Assign y
   Methods: 
diff --git a/src/MapleFE/test/java2mpl/class-instance-initializer.java b/src/MapleFE/test/java/java2mpl/class-instance-initializer.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-instance-initializer.java
rename to src/MapleFE/test/java/java2mpl/class-instance-initializer.java
diff --git a/src/MapleFE/test/java2mpl/class-instance-initializer.java.result b/src/MapleFE/test/java/java2mpl/class-instance-initializer.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-instance-initializer.java.result
rename to src/MapleFE/test/java/java2mpl/class-instance-initializer.java.result
diff --git a/src/MapleFE/test/java2mpl/class-method-1.java b/src/MapleFE/test/java/java2mpl/class-method-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-method-1.java
rename to src/MapleFE/test/java/java2mpl/class-method-1.java
diff --git a/src/MapleFE/test/java2mpl/class-method-1.java.result b/src/MapleFE/test/java/java2mpl/class-method-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-method-1.java.result
rename to src/MapleFE/test/java/java2mpl/class-method-1.java.result
diff --git a/src/MapleFE/test/java2mpl/class-method-2.java b/src/MapleFE/test/java/java2mpl/class-method-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-method-2.java
rename to src/MapleFE/test/java/java2mpl/class-method-2.java
diff --git a/src/MapleFE/test/java2mpl/class-method-2.java.result b/src/MapleFE/test/java/java2mpl/class-method-2.java.result
similarity index 87%
rename from src/MapleFE/test/java2mpl/class-method-2.java.result
rename to src/MapleFE/test/java/java2mpl/class-method-2.java.result
index 3a49cec4d0c63bb39c2f62116642b5004d2651a6..63a9e974acf1a29c1e8253c016c96d886cfef76b 100644
--- a/src/MapleFE/test/java2mpl/class-method-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/class-method-2.java.result
@@ -7,7 +7,7 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
+    func  foo(c)  throws: 
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/class-multi-decl.java b/src/MapleFE/test/java/java2mpl/class-multi-decl.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-multi-decl.java
rename to src/MapleFE/test/java/java2mpl/class-multi-decl.java
diff --git a/src/MapleFE/test/java2mpl/class-multi-decl.java.result b/src/MapleFE/test/java/java2mpl/class-multi-decl.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-multi-decl.java.result
rename to src/MapleFE/test/java/java2mpl/class-multi-decl.java.result
diff --git a/src/MapleFE/test/java2mpl/class-multi-line.java b/src/MapleFE/test/java/java2mpl/class-multi-line.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-multi-line.java
rename to src/MapleFE/test/java/java2mpl/class-multi-line.java
diff --git a/src/MapleFE/test/java2mpl/class-multi-line.java.result b/src/MapleFE/test/java/java2mpl/class-multi-line.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-multi-line.java.result
rename to src/MapleFE/test/java/java2mpl/class-multi-line.java.result
diff --git a/src/MapleFE/test/java2mpl/class-nested.java b/src/MapleFE/test/java/java2mpl/class-nested.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-nested.java
rename to src/MapleFE/test/java/java2mpl/class-nested.java
diff --git a/src/MapleFE/test/java2mpl/class-nested.java.result b/src/MapleFE/test/java/java2mpl/class-nested.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-nested.java.result
rename to src/MapleFE/test/java/java2mpl/class-nested.java.result
diff --git a/src/MapleFE/test/java2mpl/class-static-initializer.java b/src/MapleFE/test/java/java2mpl/class-static-initializer.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-static-initializer.java
rename to src/MapleFE/test/java/java2mpl/class-static-initializer.java
diff --git a/src/MapleFE/test/java2mpl/class-static-initializer.java.result b/src/MapleFE/test/java/java2mpl/class-static-initializer.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/class-static-initializer.java.result
rename to src/MapleFE/test/java/java2mpl/class-static-initializer.java.result
diff --git a/src/MapleFE/test/java2mpl/class.java b/src/MapleFE/test/java/java2mpl/class.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/class.java
rename to src/MapleFE/test/java/java2mpl/class.java
diff --git a/src/MapleFE/test/java2mpl/class.java.result b/src/MapleFE/test/java/java2mpl/class.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/class.java.result
rename to src/MapleFE/test/java/java2mpl/class.java.result
diff --git a/src/MapleFE/test/java2mpl/comment-1.java b/src/MapleFE/test/java/java2mpl/comment-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/comment-1.java
rename to src/MapleFE/test/java/java2mpl/comment-1.java
diff --git a/src/MapleFE/test/java2mpl/comment-1.java.result b/src/MapleFE/test/java/java2mpl/comment-1.java.result
similarity index 85%
rename from src/MapleFE/test/java2mpl/comment-1.java.result
rename to src/MapleFE/test/java/java2mpl/comment-1.java.result
index 80a92a3a9b58bfc354c4a28fd18fe06c52931e64..d45e86e510ff9949e14b2fcf8a7510269aad3893 100644
--- a/src/MapleFE/test/java2mpl/comment-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/comment-1.java.result
@@ -6,7 +6,7 @@ class  Point
 
   Instance Initializer: 
   Constructors: 
-    constructor  Point()  throws: 
+    constructor  Point(x)  throws: 
       this.x Assign x
   Methods: 
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/comment-2.java b/src/MapleFE/test/java/java2mpl/comment-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/comment-2.java
rename to src/MapleFE/test/java/java2mpl/comment-2.java
diff --git a/src/MapleFE/test/java2mpl/comment-2.java.result b/src/MapleFE/test/java/java2mpl/comment-2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/comment-2.java.result
rename to src/MapleFE/test/java/java2mpl/comment-2.java.result
diff --git a/src/MapleFE/test/java2mpl/comment-3.java b/src/MapleFE/test/java/java2mpl/comment-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/comment-3.java
rename to src/MapleFE/test/java/java2mpl/comment-3.java
diff --git a/src/MapleFE/test/java2mpl/comment-3.java.result b/src/MapleFE/test/java/java2mpl/comment-3.java.result
similarity index 85%
rename from src/MapleFE/test/java2mpl/comment-3.java.result
rename to src/MapleFE/test/java/java2mpl/comment-3.java.result
index 80a92a3a9b58bfc354c4a28fd18fe06c52931e64..d45e86e510ff9949e14b2fcf8a7510269aad3893 100644
--- a/src/MapleFE/test/java2mpl/comment-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/comment-3.java.result
@@ -6,7 +6,7 @@ class  Point
 
   Instance Initializer: 
   Constructors: 
-    constructor  Point()  throws: 
+    constructor  Point(x)  throws: 
       this.x Assign x
   Methods: 
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/comment-4.java b/src/MapleFE/test/java/java2mpl/comment-4.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/comment-4.java
rename to src/MapleFE/test/java/java2mpl/comment-4.java
diff --git a/src/MapleFE/test/java2mpl/comment-4.java.result b/src/MapleFE/test/java/java2mpl/comment-4.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/comment-4.java.result
rename to src/MapleFE/test/java/java2mpl/comment-4.java.result
diff --git a/src/MapleFE/test/java2mpl/conversion-1.java b/src/MapleFE/test/java/java2mpl/conversion-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/conversion-1.java
rename to src/MapleFE/test/java/java2mpl/conversion-1.java
diff --git a/src/MapleFE/test/java2mpl/conversion-1.java.result b/src/MapleFE/test/java/java2mpl/conversion-1.java.result
similarity index 56%
rename from src/MapleFE/test/java2mpl/conversion-1.java.result
rename to src/MapleFE/test/java/java2mpl/conversion-1.java.result
index 823c0b8ee4045035c60b7ad6696c76c986ddf44b..486eae7281893a5a605b3b0647b4e11745186e3b 100644
--- a/src/MapleFE/test/java2mpl/conversion-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/conversion-1.java.result
@@ -7,13 +7,16 @@ class  Test
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  main()  throws: 
-      var:i=(int)12.5
+    func  main(args)  throws: 
+      Decl: i=(int)12.5
       System.out.println("(int)12.5f==" Add i)
-      var:f=i
+      Decl: f=i
       System.out.print(f)
-      f Assign 
-      var:d=Math.sin(f)
+      f Assign f Mul i
+      Decl: d=Math.sin(f)
   LocalClasses: 
   LocalInterfaces: 
 
+Identifier:f has no decl.
+Identifier:f has no decl.
+Identifier:i has no decl.
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-1.java b/src/MapleFE/test/java/java2mpl/definite-assignment-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/definite-assignment-1.java
rename to src/MapleFE/test/java/java2mpl/definite-assignment-1.java
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-1.java.result b/src/MapleFE/test/java/java2mpl/definite-assignment-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/definite-assignment-1.java.result
rename to src/MapleFE/test/java/java2mpl/definite-assignment-1.java.result
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-2.java b/src/MapleFE/test/java/java2mpl/definite-assignment-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/definite-assignment-2.java
rename to src/MapleFE/test/java/java2mpl/definite-assignment-2.java
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-2.java.result b/src/MapleFE/test/java/java2mpl/definite-assignment-2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/definite-assignment-2.java.result
rename to src/MapleFE/test/java/java2mpl/definite-assignment-2.java.result
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-3.java b/src/MapleFE/test/java/java2mpl/definite-assignment-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/definite-assignment-3.java
rename to src/MapleFE/test/java/java2mpl/definite-assignment-3.java
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-3.java.result b/src/MapleFE/test/java/java2mpl/definite-assignment-3.java.result
similarity index 82%
rename from src/MapleFE/test/java2mpl/definite-assignment-3.java.result
rename to src/MapleFE/test/java/java2mpl/definite-assignment-3.java.result
index 5066bbbf6afc1dbe2efdd8ab7cc4436d3066f89f..dacb216c91756bdea4d421503c0e1427f6afa5b1 100644
--- a/src/MapleFE/test/java2mpl/definite-assignment-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/definite-assignment-3.java.result
@@ -8,11 +8,10 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:k
+      Decl: k
       cond-branch cond:v GT 0 Land (k Assign System.in.read()) GE 0
       true branch :
-        System.out.println(k)
-      false branch :
+        System.out.println(k)      false branch :
 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-4.java b/src/MapleFE/test/java/java2mpl/definite-assignment-4.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/definite-assignment-4.java
rename to src/MapleFE/test/java/java2mpl/definite-assignment-4.java
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-4.java.result b/src/MapleFE/test/java/java2mpl/definite-assignment-4.java.result
similarity index 68%
rename from src/MapleFE/test/java2mpl/definite-assignment-4.java.result
rename to src/MapleFE/test/java/java2mpl/definite-assignment-4.java.result
index c9954779e6e336d17c4ab81a1fb7c283799057ac..b682ea540fff5f1c93296b7d850111b67ac0d24b 100644
--- a/src/MapleFE/test/java2mpl/definite-assignment-4.java.result
+++ b/src/MapleFE/test/java/java2mpl/definite-assignment-4.java.result
@@ -8,9 +8,14 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:k
+      Decl: k
       while true        k Assign n
+        cond-branch cond:k GE 5
+        true branch :
+          break:
+        false branch :
 
+        n Assign 6
 
       System.out.println(k)
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-5.java b/src/MapleFE/test/java/java2mpl/definite-assignment-5.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/definite-assignment-5.java
rename to src/MapleFE/test/java/java2mpl/definite-assignment-5.java
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-5.java.result b/src/MapleFE/test/java/java2mpl/definite-assignment-5.java.result
similarity index 76%
rename from src/MapleFE/test/java2mpl/definite-assignment-5.java.result
rename to src/MapleFE/test/java/java2mpl/definite-assignment-5.java.result
index 96fed950ed666c113bb89f747d84303bcbb74ed3..ab7ce94f419de62fe6d9ec11a847a51f6b682b47 100644
--- a/src/MapleFE/test/java2mpl/definite-assignment-5.java.result
+++ b/src/MapleFE/test/java/java2mpl/definite-assignment-5.java.result
@@ -7,14 +7,12 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  flow()  throws: 
-      var:k
+    func  flow(flag)  throws: 
+      Decl: k
       cond-branch cond:flag
       true branch :
-        k Assign 3
-      false branch :
+        k Assign 3      false branch :
         k Assign 4
-
       System.out.println(k)
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-6.java b/src/MapleFE/test/java/java2mpl/definite-assignment-6.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/definite-assignment-6.java
rename to src/MapleFE/test/java/java2mpl/definite-assignment-6.java
diff --git a/src/MapleFE/test/java2mpl/definite-assignment-6.java.result b/src/MapleFE/test/java/java2mpl/definite-assignment-6.java.result
similarity index 82%
rename from src/MapleFE/test/java2mpl/definite-assignment-6.java.result
rename to src/MapleFE/test/java/java2mpl/definite-assignment-6.java.result
index de1ccd48d8c787674c090b95980c5f7666f87e5d..72b74d484c82e50dc48ef519aa881d158f966453 100644
--- a/src/MapleFE/test/java2mpl/definite-assignment-6.java.result
+++ b/src/MapleFE/test/java/java2mpl/definite-assignment-6.java.result
@@ -8,11 +8,10 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:k
+      Decl: k
       cond-branch cond:v GT 0 Land (k Assign System.read()) GE 0
       true branch :
-        System.println(k)
-      false branch :
+        System.println(k)      false branch :
 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/doloop-1.java b/src/MapleFE/test/java/java2mpl/doloop-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/doloop-1.java
rename to src/MapleFE/test/java/java2mpl/doloop-1.java
diff --git a/src/MapleFE/test/java2mpl/doloop-1.java.result b/src/MapleFE/test/java/java2mpl/doloop-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/doloop-1.java.result
rename to src/MapleFE/test/java/java2mpl/doloop-1.java.result
diff --git a/src/MapleFE/test/java2mpl/enum-1.java b/src/MapleFE/test/java/java2mpl/enum-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/enum-1.java
rename to src/MapleFE/test/java/java2mpl/enum-1.java
diff --git a/src/MapleFE/test/java2mpl/enum-1.java.result b/src/MapleFE/test/java/java2mpl/enum-1.java.result
similarity index 90%
rename from src/MapleFE/test/java2mpl/enum-1.java.result
rename to src/MapleFE/test/java/java2mpl/enum-1.java.result
index 29ffe431e3bbc4d109adc343ba3963faf902856b..b1a3b3dc78218547f76750421ccb9dcc06c2931f 100644
--- a/src/MapleFE/test/java2mpl/enum-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/enum-1.java.result
@@ -6,7 +6,7 @@ class[JavaEnum]  Coin
     value
   Instance Initializer: 
   Constructors: 
-    constructor  Coin()  throws: 
+    constructor  Coin(value)  throws: 
       this.value Assign value
   Methods: 
     func  value()  throws: 
diff --git a/src/MapleFE/test/java2mpl/escape-seq.java b/src/MapleFE/test/java/java2mpl/escape-seq.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/escape-seq.java
rename to src/MapleFE/test/java/java2mpl/escape-seq.java
diff --git a/src/MapleFE/test/java2mpl/escape-seq.java.result b/src/MapleFE/test/java/java2mpl/escape-seq.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/escape-seq.java.result
rename to src/MapleFE/test/java/java2mpl/escape-seq.java.result
diff --git a/src/MapleFE/test/java/java2mpl/field-1.java b/src/MapleFE/test/java/java2mpl/field-1.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fa020083f8c42382ac826d28be6e066aa8d148e
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/field-1.java
@@ -0,0 +1,5 @@
+class A {
+    public byte B() {
+      c = e.getValue().getBytes().length;
+    }
+}
diff --git a/src/MapleFE/test/java/java2mpl/field-1.java.result b/src/MapleFE/test/java/java2mpl/field-1.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..08b23df1739f889476828801001425adb619fe28
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/field-1.java.result
@@ -0,0 +1,15 @@
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  B()  throws: 
+      c Assign e.getValue().getBytes().length
+  LocalClasses: 
+  LocalInterfaces: 
+
+Identifier:c has no decl.
diff --git a/src/MapleFE/test/java/java2mpl/field-2.java b/src/MapleFE/test/java/java2mpl/field-2.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f53850954577c44e65e20053be6878b3ff37f1d
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/field-2.java
@@ -0,0 +1,5 @@
+public class Sizing {
+    void main() {
+        println(parseInstance(bitSet).toPrintable());
+    }
+}
diff --git a/src/MapleFE/test/java/java2mpl/field-2.java.result b/src/MapleFE/test/java/java2mpl/field-2.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..ad276786674345046f80573238f0691223717a24
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/field-2.java.result
@@ -0,0 +1,14 @@
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Sizing
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  main()  throws: 
+      println(parseInstance(bitSet).toPrintable())
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/java2mpl/field-3.java b/src/MapleFE/test/java/java2mpl/field-3.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a2f73bd35a290803827ebbf1da9db79af766f1d
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/field-3.java
@@ -0,0 +1,25 @@
+//
+//Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+//
+//OpenArkFE is licensed under the Mulan PSL v2.
+//You can use this software according to the terms and conditions of the Mulan PSL v2.
+//You may obtain a copy of Mulan PSL v2 at:
+//
+// http://license.coscl.org.cn/MulanPSL2
+//
+//THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+//EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+//FIT FOR A PARTICULAR PURPOSE.
+//See the Mulan PSL v2 for more details.
+//
+
+class B {
+  Point p;
+}
+
+class Point {
+  int x;
+  void foo(B q) {
+    q.p.x = 1;
+  }
+}
diff --git a/src/MapleFE/test/java/java2mpl/field-3.java.result b/src/MapleFE/test/java/java2mpl/field-3.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..5511e77c8fa6d76ebeefd6e1a0e499654fa25606
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/field-3.java.result
@@ -0,0 +1,25 @@
+Matched 7 tokens.
+Matched 30 tokens.
+============= Module ===========
+== Sub Tree ==
+class  B
+  Fields: 
+    p
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Point
+  Fields: 
+    x
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  foo(q)  throws: 
+      q.p.x Assign 1
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java2mpl/forloop-1.java b/src/MapleFE/test/java/java2mpl/forloop-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/forloop-1.java
rename to src/MapleFE/test/java/java2mpl/forloop-1.java
diff --git a/src/MapleFE/test/java2mpl/forloop-1.java.result b/src/MapleFE/test/java/java2mpl/forloop-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/forloop-1.java.result
rename to src/MapleFE/test/java/java2mpl/forloop-1.java.result
diff --git a/src/MapleFE/test/java2mpl/forloop-2.java b/src/MapleFE/test/java/java2mpl/forloop-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/forloop-2.java
rename to src/MapleFE/test/java/java2mpl/forloop-2.java
diff --git a/src/MapleFE/test/java2mpl/forloop-2.java.result b/src/MapleFE/test/java/java2mpl/forloop-2.java.result
similarity index 82%
rename from src/MapleFE/test/java2mpl/forloop-2.java.result
rename to src/MapleFE/test/java/java2mpl/forloop-2.java.result
index 3fd419113288e4558e75e69c0adbe2bc6ae823c6..de6b83a2cec7e703feccd478dde30b3a0949d36d 100644
--- a/src/MapleFE/test/java2mpl/forloop-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/forloop-2.java.result
@@ -9,9 +9,8 @@ class  A
   Methods: 
     func  foo()  throws: 
       for ( )
-        Inc
-          k
-                  iInc
+        PreInc k
+        i Inc
 
 
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/forloop-3.java b/src/MapleFE/test/java/java2mpl/forloop-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/forloop-3.java
rename to src/MapleFE/test/java/java2mpl/forloop-3.java
diff --git a/src/MapleFE/test/java2mpl/forloop-3.java.result b/src/MapleFE/test/java/java2mpl/forloop-3.java.result
similarity index 82%
rename from src/MapleFE/test/java2mpl/forloop-3.java.result
rename to src/MapleFE/test/java/java2mpl/forloop-3.java.result
index db96d08b6c2d35814e60db931f53007844d0077f..77669d056798d30837c930e2a698e66707ea8457 100644
--- a/src/MapleFE/test/java2mpl/forloop-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/forloop-3.java.result
@@ -9,9 +9,8 @@ class  A
   Methods: 
     func  foo()  throws: 
       for ( )
-        Inc
-          k
-                  iInc
+        PreInc k
+        i Inc
 
 
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/forloop-4.java b/src/MapleFE/test/java/java2mpl/forloop-4.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/forloop-4.java
rename to src/MapleFE/test/java/java2mpl/forloop-4.java
diff --git a/src/MapleFE/test/java2mpl/forloop-4.java.result b/src/MapleFE/test/java/java2mpl/forloop-4.java.result
similarity index 82%
rename from src/MapleFE/test/java2mpl/forloop-4.java.result
rename to src/MapleFE/test/java/java2mpl/forloop-4.java.result
index 08c5830eb8cd2bec5ae7d1a3ac64acf5608c0ad1..54c4d8cd6fa532770b043c1bf7cc15562422a5b7 100644
--- a/src/MapleFE/test/java2mpl/forloop-4.java.result
+++ b/src/MapleFE/test/java/java2mpl/forloop-4.java.result
@@ -9,9 +9,9 @@ class  A
   Methods: 
     func  foo()  throws: 
       for ( )
-                  kInc
+        k Inc
 
-                  iInc
+        i Inc
 
 
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/func-body-2.java b/src/MapleFE/test/java/java2mpl/func-body-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/func-body-2.java
rename to src/MapleFE/test/java/java2mpl/func-body-2.java
diff --git a/src/MapleFE/test/java2mpl/func-body-2.java.result b/src/MapleFE/test/java/java2mpl/func-body-2.java.result
similarity index 88%
rename from src/MapleFE/test/java2mpl/func-body-2.java.result
rename to src/MapleFE/test/java/java2mpl/func-body-2.java.result
index b95b2f11e5ce3466ae72bc353880bfe79a634f18..95a46f76b202a9ae5af20a270bedc5bfff676897 100644
--- a/src/MapleFE/test/java2mpl/func-body-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/func-body-2.java.result
@@ -7,7 +7,7 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
+    func  foo(c,b)  throws: 
       c Assign 3
       return c Add b
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/func-body-3.java b/src/MapleFE/test/java/java2mpl/func-body-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/func-body-3.java
rename to src/MapleFE/test/java/java2mpl/func-body-3.java
diff --git a/src/MapleFE/test/java2mpl/func-body-3.java.result b/src/MapleFE/test/java/java2mpl/func-body-3.java.result
similarity index 77%
rename from src/MapleFE/test/java2mpl/func-body-3.java.result
rename to src/MapleFE/test/java/java2mpl/func-body-3.java.result
index 71fa07343af0c07a17c35b1fb4250d979231c687..27174deac163f7d3d7c34f0df14ac9959b7847cd 100644
--- a/src/MapleFE/test/java2mpl/func-body-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/func-body-3.java.result
@@ -8,9 +8,11 @@ class  Test
   Constructors: 
   Methods: 
     func  main()  throws: 
-      var:i=12
+      Decl: i=12
       i Assign 2
       i Assign 1
   LocalClasses: 
   LocalInterfaces: 
 
+Identifier:i has no decl.
+Identifier:i has no decl.
diff --git a/src/MapleFE/test/java2mpl/func-body-4.java b/src/MapleFE/test/java/java2mpl/func-body-4.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/func-body-4.java
rename to src/MapleFE/test/java/java2mpl/func-body-4.java
diff --git a/src/MapleFE/test/java2mpl/func-body-4.java.result b/src/MapleFE/test/java/java2mpl/func-body-4.java.result
similarity index 79%
rename from src/MapleFE/test/java2mpl/func-body-4.java.result
rename to src/MapleFE/test/java/java2mpl/func-body-4.java.result
index dbb7ad1bb598bc5fe78c85446c5d7691f7a1ce07..def16e9fea4c4af5b4a744e39884f78b2589f3ce 100644
--- a/src/MapleFE/test/java2mpl/func-body-4.java.result
+++ b/src/MapleFE/test/java/java2mpl/func-body-4.java.result
@@ -7,9 +7,9 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
+    func  foo(c,b)  throws: 
       return c Add b
-    func  foo()  throws: 
+    func  foo(c)  throws: 
       return c
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/func-body.java b/src/MapleFE/test/java/java2mpl/func-body.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/func-body.java
rename to src/MapleFE/test/java/java2mpl/func-body.java
diff --git a/src/MapleFE/test/java2mpl/func-body.java.result b/src/MapleFE/test/java/java2mpl/func-body.java.result
similarity index 87%
rename from src/MapleFE/test/java2mpl/func-body.java.result
rename to src/MapleFE/test/java/java2mpl/func-body.java.result
index 94281ad6d4d6e363fef569580b34a2c2308e1709..8b87a7f5f3bf5d6f487c466bbf24c40afbe73e6a 100644
--- a/src/MapleFE/test/java2mpl/func-body.java.result
+++ b/src/MapleFE/test/java/java2mpl/func-body.java.result
@@ -7,7 +7,7 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
+    func  foo(c,b)  throws: 
       return c Add b
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/func-multi-param.java b/src/MapleFE/test/java/java2mpl/func-multi-param.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/func-multi-param.java
rename to src/MapleFE/test/java/java2mpl/func-multi-param.java
diff --git a/src/MapleFE/test/java2mpl/func-multi-param.java.result b/src/MapleFE/test/java/java2mpl/func-multi-param.java.result
similarity index 75%
rename from src/MapleFE/test/java2mpl/func-multi-param.java.result
rename to src/MapleFE/test/java/java2mpl/func-multi-param.java.result
index 9a8abb5a85217e09b46adae374347eb7faf7a5e5..adc37165f90e4d0093bae09fcd9350c922e5c3bb 100644
--- a/src/MapleFE/test/java2mpl/func-multi-param.java.result
+++ b/src/MapleFE/test/java/java2mpl/func-multi-param.java.result
@@ -7,8 +7,8 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
-    func  bar()  throws: 
+    func  foo(c,b)  throws: 
+    func  bar(i,b,c)  throws: 
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/others/generate-result.sh b/src/MapleFE/test/java/java2mpl/generate-result.sh
similarity index 92%
rename from src/MapleFE/test/others/generate-result.sh
rename to src/MapleFE/test/java/java2mpl/generate-result.sh
index bbd3acd878bd41d3a31fc5123972e954d7c9fcd0..08b3acc3b58dc1585fb15888064b004629e72007 100755
--- a/src/MapleFE/test/others/generate-result.sh
+++ b/src/MapleFE/test/java/java2mpl/generate-result.sh
@@ -17,5 +17,5 @@ FILES=$(pwd)/*.java
 for f in $FILES
 do
   echo "Generating result for $f ..."
-  ../../output/java/java2mpl $f > $f.result
+  ../../../output/java/java/java2mpl $f > $f.result
 done
diff --git a/src/MapleFE/test/java2mpl/if-else-1.java b/src/MapleFE/test/java/java2mpl/if-else-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/if-else-1.java
rename to src/MapleFE/test/java/java2mpl/if-else-1.java
diff --git a/src/MapleFE/test/java2mpl/if-else-1.java.result b/src/MapleFE/test/java/java2mpl/if-else-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/if-else-1.java.result
rename to src/MapleFE/test/java/java2mpl/if-else-1.java.result
diff --git a/src/MapleFE/test/java2mpl/if-else-2.java b/src/MapleFE/test/java/java2mpl/if-else-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/if-else-2.java
rename to src/MapleFE/test/java/java2mpl/if-else-2.java
diff --git a/src/MapleFE/test/java2mpl/if-else-2.java.result b/src/MapleFE/test/java/java2mpl/if-else-2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/if-else-2.java.result
rename to src/MapleFE/test/java/java2mpl/if-else-2.java.result
diff --git a/src/MapleFE/test/java2mpl/if-else-3.java b/src/MapleFE/test/java/java2mpl/if-else-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/if-else-3.java
rename to src/MapleFE/test/java/java2mpl/if-else-3.java
diff --git a/src/MapleFE/test/java2mpl/if-else-3.java.result b/src/MapleFE/test/java/java2mpl/if-else-3.java.result
similarity index 89%
rename from src/MapleFE/test/java2mpl/if-else-3.java.result
rename to src/MapleFE/test/java/java2mpl/if-else-3.java.result
index e8f85eb80675776505131652c9c166686f5a35c7..02239e703020f1071f35269c604fef2fe80369af 100644
--- a/src/MapleFE/test/java2mpl/if-else-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/if-else-3.java.result
@@ -14,8 +14,7 @@ class  A
       false branch :
         cond-branch cond:b
         true branch :
-          return 3
-        false branch :
+          return 3        false branch :
 
         return 1
 
diff --git a/src/MapleFE/test/java2mpl/illegal-expr-2.java b/src/MapleFE/test/java/java2mpl/illegal-expr-2.java.disabled
similarity index 100%
rename from src/MapleFE/test/java2mpl/illegal-expr-2.java
rename to src/MapleFE/test/java/java2mpl/illegal-expr-2.java.disabled
diff --git a/src/MapleFE/test/java2mpl/illegal-expr-2.java.result b/src/MapleFE/test/java/java2mpl/illegal-expr-2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/illegal-expr-2.java.result
rename to src/MapleFE/test/java/java2mpl/illegal-expr-2.java.result
diff --git a/src/MapleFE/test/java2mpl/illegal-expr.java b/src/MapleFE/test/java/java2mpl/illegal-expr.java.disabled
similarity index 100%
rename from src/MapleFE/test/java2mpl/illegal-expr.java
rename to src/MapleFE/test/java/java2mpl/illegal-expr.java.disabled
diff --git a/src/MapleFE/test/java2mpl/illegal-expr.java.result b/src/MapleFE/test/java/java2mpl/illegal-expr.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/illegal-expr.java.result
rename to src/MapleFE/test/java/java2mpl/illegal-expr.java.result
diff --git a/src/MapleFE/test/java2mpl/interface-field.java b/src/MapleFE/test/java/java2mpl/interface-field.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/interface-field.java
rename to src/MapleFE/test/java/java2mpl/interface-field.java
diff --git a/src/MapleFE/test/java2mpl/interface-field.java.result b/src/MapleFE/test/java/java2mpl/interface-field.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/interface-field.java.result
rename to src/MapleFE/test/java/java2mpl/interface-field.java.result
diff --git a/src/MapleFE/test/java2mpl/label-stmt.java b/src/MapleFE/test/java/java2mpl/label-stmt.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/label-stmt.java
rename to src/MapleFE/test/java/java2mpl/label-stmt.java
diff --git a/src/MapleFE/test/java2mpl/label-stmt.java.result b/src/MapleFE/test/java/java2mpl/label-stmt.java.result
similarity index 92%
rename from src/MapleFE/test/java2mpl/label-stmt.java.result
rename to src/MapleFE/test/java/java2mpl/label-stmt.java.result
index bc0929a2817f385360eed4bc847c985e6f193ac3..524f7cd81391e216eaba2a56c6b8ecf37d8f14dd 100644
--- a/src/MapleFE/test/java2mpl/label-stmt.java.result
+++ b/src/MapleFE/test/java/java2mpl/label-stmt.java.result
@@ -9,7 +9,7 @@ class  A
   Methods: 
     func  loseEdges()  throws: 
       search:
-      break search
+      break:search
 
 
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/lambda-1.java b/src/MapleFE/test/java/java2mpl/lambda-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/lambda-1.java
rename to src/MapleFE/test/java/java2mpl/lambda-1.java
diff --git a/src/MapleFE/test/java2mpl/lambda-1.java.result b/src/MapleFE/test/java/java2mpl/lambda-1.java.result
similarity index 90%
rename from src/MapleFE/test/java2mpl/lambda-1.java.result
rename to src/MapleFE/test/java/java2mpl/lambda-1.java.result
index 44e7e9238f5c5d76810ebb0837ccc2e4e20ac85d..16ea64b335bac5e1dfc3b385d142bd4aaf2d39ed 100644
--- a/src/MapleFE/test/java2mpl/lambda-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/lambda-1.java.result
@@ -8,8 +8,7 @@ class  Point
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      bar(() -> 42
-)
+      bar(() -> 42)
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/lambda-2.java b/src/MapleFE/test/java/java2mpl/lambda-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/lambda-2.java
rename to src/MapleFE/test/java/java2mpl/lambda-2.java
diff --git a/src/MapleFE/test/java2mpl/lambda-2.java.result b/src/MapleFE/test/java/java2mpl/lambda-2.java.result
similarity index 78%
rename from src/MapleFE/test/java2mpl/lambda-2.java.result
rename to src/MapleFE/test/java/java2mpl/lambda-2.java.result
index b122cfbdb909338b687e18e76255885d36037005..5cc1b420788f5c4f7f1bc668b4227a7c2d25e22a 100644
--- a/src/MapleFE/test/java2mpl/lambda-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/lambda-2.java.result
@@ -13,13 +13,13 @@ class  Main
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  main()  throws: 
-      var:numbers=new ArrayList<Integer>
+    func  main(args)  throws: 
+      Decl: numbers=new ArrayList()
       numbers.add(5)
       numbers.add(9)
       numbers.add(8)
       numbers.add(1)
-      var:method=(n) -> System.out.println(n)
+      Decl: method=(n) -> System.out.println(n)
 
       numbers.forEach(method)
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/lambda-3.java b/src/MapleFE/test/java/java2mpl/lambda-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/lambda-3.java
rename to src/MapleFE/test/java/java2mpl/lambda-3.java
diff --git a/src/MapleFE/test/java2mpl/lambda-3.java.result b/src/MapleFE/test/java/java2mpl/lambda-3.java.result
similarity index 84%
rename from src/MapleFE/test/java2mpl/lambda-3.java.result
rename to src/MapleFE/test/java/java2mpl/lambda-3.java.result
index 114e7b196e8479492d4f475732ea58d7509a1d47..0fb5dcb10fd362b5e55248f08f92321b6c1913f7 100644
--- a/src/MapleFE/test/java2mpl/lambda-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/lambda-3.java.result
@@ -10,8 +10,8 @@ class  Main
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  main()  throws: 
-      var:numbers=new ArrayList<Integer>
+    func  main(args)  throws: 
+      Decl: numbers=new ArrayList()
       numbers.add(5)
       numbers.add(9)
       numbers.add(8)
diff --git a/src/MapleFE/test/java2mpl/lambda-4.java b/src/MapleFE/test/java/java2mpl/lambda-4.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/lambda-4.java
rename to src/MapleFE/test/java/java2mpl/lambda-4.java
diff --git a/src/MapleFE/test/java2mpl/lambda-4.java.result b/src/MapleFE/test/java/java2mpl/lambda-4.java.result
similarity index 63%
rename from src/MapleFE/test/java2mpl/lambda-4.java.result
rename to src/MapleFE/test/java/java2mpl/lambda-4.java.result
index 7adeb147e3af0a80394bba7f21c7f4d21c7ad890..f7c61355a8bd9c2ce61c1027292f29e0a192e3b5 100644
--- a/src/MapleFE/test/java2mpl/lambda-4.java.result
+++ b/src/MapleFE/test/java/java2mpl/lambda-4.java.result
@@ -6,7 +6,7 @@ interface  StringFunction
   Fields: 
 
   Methods: 
-    func  run()  throws: 
+    func  run(str)  throws: 
 
 == Sub Tree ==
 class  Main
@@ -15,15 +15,13 @@ class  Main
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  main()  throws: 
-      var:exclaim=(s) -> s Add "!"
-
-      var:ask=(s) -> s Add "?"
-
+    func  main(args)  throws: 
+      Decl: exclaim=(s) -> s Add "!"
+      Decl: ask=(s) -> s Add "?"
       printFormatted("Hello",exclaim)
       printFormatted("Hello",ask)
-    func  printFormatted()  throws: 
-      var:result=format.run(str)
+    func  printFormatted(str,format)  throws: 
+      Decl: result=format.run(str)
       System.out.println(result)
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/lambda-5.java b/src/MapleFE/test/java/java2mpl/lambda-5.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/lambda-5.java
rename to src/MapleFE/test/java/java2mpl/lambda-5.java
diff --git a/src/MapleFE/test/java2mpl/lambda-5.java.result b/src/MapleFE/test/java/java2mpl/lambda-5.java.result
similarity index 70%
rename from src/MapleFE/test/java2mpl/lambda-5.java.result
rename to src/MapleFE/test/java/java2mpl/lambda-5.java.result
index 9f9aa2932015d632f7a10b0c950fe64332b145c6..e4892c90d2521fa5e2b1cc01315ec9fa5003e030 100644
--- a/src/MapleFE/test/java2mpl/lambda-5.java.result
+++ b/src/MapleFE/test/java/java2mpl/lambda-5.java.result
@@ -14,18 +14,21 @@ class  Point
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:m
+      Decl: m
       m Assign () -> 
       m Assign () -> 42
-
       m Assign () -> null
-
       m Assign () -> return 42
 
       m Assign () -> system.gc()
 
-      m Assign () -> x Add y
-
+      m Assign (x,y) -> x Add y
   LocalClasses: 
   LocalInterfaces: 
 
+Identifier:m has no decl.
+Identifier:m has no decl.
+Identifier:m has no decl.
+Identifier:m has no decl.
+Identifier:m has no decl.
+Identifier:m has no decl.
diff --git a/src/MapleFE/test/java2mpl/left-rec-1.java b/src/MapleFE/test/java/java2mpl/left-rec-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/left-rec-1.java
rename to src/MapleFE/test/java/java2mpl/left-rec-1.java
diff --git a/src/MapleFE/test/java2mpl/left-rec-1.java.result b/src/MapleFE/test/java/java2mpl/left-rec-1.java.result
similarity index 84%
rename from src/MapleFE/test/java2mpl/left-rec-1.java.result
rename to src/MapleFE/test/java/java2mpl/left-rec-1.java.result
index 6e55437b2ccd830ae8aba352a63855e46b0b326a..bc2788a9097ee1e454a8b4b79a6d1cbad7d168da 100644
--- a/src/MapleFE/test/java2mpl/left-rec-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/left-rec-1.java.result
@@ -10,8 +10,7 @@ class  A
     func  foo()  throws: 
       cond-branch cond:(k Assign System.in.read()) GE 0
       true branch :
-        System.out.println(k)
-      false branch :
+        System.out.println(k)      false branch :
 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/literal-float-double.java b/src/MapleFE/test/java/java2mpl/literal-float-double.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-float-double.java
rename to src/MapleFE/test/java/java2mpl/literal-float-double.java
diff --git a/src/MapleFE/test/java2mpl/literal-float-double.java.result b/src/MapleFE/test/java/java2mpl/literal-float-double.java.result
similarity index 84%
rename from src/MapleFE/test/java2mpl/literal-float-double.java.result
rename to src/MapleFE/test/java/java2mpl/literal-float-double.java.result
index 5f1bf6992b63ece0ed6f720b0efd526749804fe0..9d218a0b075eecae25ce5dc6e1f3d275ab359a2a 100644
--- a/src/MapleFE/test/java2mpl/literal-float-double.java.result
+++ b/src/MapleFE/test/java/java2mpl/literal-float-double.java.result
@@ -8,8 +8,8 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:a=11.1
-      var:a=22.2
+      Decl: a=11.1
+      Decl: a=22.2
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/literal-integer-2.java b/src/MapleFE/test/java/java2mpl/literal-integer-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-integer-2.java
rename to src/MapleFE/test/java/java2mpl/literal-integer-2.java
diff --git a/src/MapleFE/test/java2mpl/literal-integer-2.java.result b/src/MapleFE/test/java/java2mpl/literal-integer-2.java.result
similarity index 91%
rename from src/MapleFE/test/java2mpl/literal-integer-2.java.result
rename to src/MapleFE/test/java/java2mpl/literal-integer-2.java.result
index abf79b059c13b8041cc6b659bf3ee076356d444e..1a5bb2d45d38ce0132e33e4eaabe9a42b0782b65 100644
--- a/src/MapleFE/test/java2mpl/literal-integer-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/literal-integer-2.java.result
@@ -8,7 +8,7 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:a=273
+      Decl: a=273
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/literal-integer-3.java b/src/MapleFE/test/java/java2mpl/literal-integer-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-integer-3.java
rename to src/MapleFE/test/java/java2mpl/literal-integer-3.java
diff --git a/src/MapleFE/test/java2mpl/literal-integer-3.java.result b/src/MapleFE/test/java/java2mpl/literal-integer-3.java.result
similarity index 78%
rename from src/MapleFE/test/java2mpl/literal-integer-3.java.result
rename to src/MapleFE/test/java/java2mpl/literal-integer-3.java.result
index 27e73a24f4e60eceba4e6b702479ef334cc5aacc..82c1284467f4d864f07fde4f01a0cd96e4f8db3f 100644
--- a/src/MapleFE/test/java2mpl/literal-integer-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/literal-integer-3.java.result
@@ -8,9 +8,11 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:a=273
+      Decl: a=273
       a Assign 268435455
       a Assign -1
   LocalClasses: 
   LocalInterfaces: 
 
+Identifier:a has no decl.
+Identifier:a has no decl.
diff --git a/src/MapleFE/test/java2mpl/literal-integer.java b/src/MapleFE/test/java/java2mpl/literal-integer.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-integer.java
rename to src/MapleFE/test/java/java2mpl/literal-integer.java
diff --git a/src/MapleFE/test/java2mpl/literal-integer.java.result b/src/MapleFE/test/java/java2mpl/literal-integer.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-integer.java.result
rename to src/MapleFE/test/java/java2mpl/literal-integer.java.result
diff --git a/src/MapleFE/test/java2mpl/literal-string-2.java b/src/MapleFE/test/java/java2mpl/literal-string-2.java
similarity index 96%
rename from src/MapleFE/test/java2mpl/literal-string-2.java
rename to src/MapleFE/test/java/java2mpl/literal-string-2.java
index ca47e9ef5dc4e5e1ede1446154728b82ef09bbc1..c0dfe8fc3d012602cfa29afc5d3926fa0eaa7557 100644
--- a/src/MapleFE/test/java2mpl/literal-string-2.java
+++ b/src/MapleFE/test/java/java2mpl/literal-string-2.java
@@ -13,6 +13,7 @@
 //See the Mulan PSL v2 for more details.
 //
 class A {
+  void write(String s);
   void foo() {
     write("doesn't");
     write("doesn\'t");
diff --git a/src/MapleFE/test/java2mpl/literal-string-2.java.result b/src/MapleFE/test/java/java2mpl/literal-string-2.java.result
similarity index 74%
rename from src/MapleFE/test/java2mpl/literal-string-2.java.result
rename to src/MapleFE/test/java/java2mpl/literal-string-2.java.result
index e08faab0e035bc782e0a08d15c571bf1ef0dc80e..7699fb51c96a52def125d2b29ff9cae1b195d9af 100644
--- a/src/MapleFE/test/java2mpl/literal-string-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/literal-string-2.java.result
@@ -1,4 +1,4 @@
-Matched 20 tokens.
+Matched 27 tokens.
 ============= Module ===========
 == Sub Tree ==
 class  A
@@ -7,9 +7,10 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
+    func  write(s)  throws: 
     func  foo()  throws: 
       write("doesn't")
-      write("doesn't")
+      write("doesn\'t")
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/literal-string.java b/src/MapleFE/test/java/java2mpl/literal-string.java
similarity index 96%
rename from src/MapleFE/test/java2mpl/literal-string.java
rename to src/MapleFE/test/java/java2mpl/literal-string.java
index c3aaa6176a67e590e888242ffc60c43d86afdebb..7eb79933aa51f92fd62c9d55f5b598b2d4fded85 100644
--- a/src/MapleFE/test/java2mpl/literal-string.java
+++ b/src/MapleFE/test/java/java2mpl/literal-string.java
@@ -13,6 +13,7 @@
 //See the Mulan PSL v2 for more details.
 //
 class A {
+  void write(String s);
   void foo() {
     write("test\n");
   }
diff --git a/src/MapleFE/test/java2mpl/literal-string.java.result b/src/MapleFE/test/java/java2mpl/literal-string.java.result
similarity index 72%
rename from src/MapleFE/test/java2mpl/literal-string.java.result
rename to src/MapleFE/test/java/java2mpl/literal-string.java.result
index 1f3dd1f0ba06163f48ca36de7a2e7c4d0e50c67d..145e330401b210f7edb9cff65e3353f4a1d87a93 100644
--- a/src/MapleFE/test/java2mpl/literal-string.java.result
+++ b/src/MapleFE/test/java/java2mpl/literal-string.java.result
@@ -1,4 +1,4 @@
-Matched 15 tokens.
+Matched 22 tokens.
 ============= Module ===========
 == Sub Tree ==
 class  A
@@ -7,9 +7,9 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
+    func  write(s)  throws: 
     func  foo()  throws: 
-      write("test
-")
+      write("test\n")
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java2mpl/literal-this-1.java b/src/MapleFE/test/java/java2mpl/literal-this-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-this-1.java
rename to src/MapleFE/test/java/java2mpl/literal-this-1.java
diff --git a/src/MapleFE/test/java2mpl/literal-this-1.java.result b/src/MapleFE/test/java/java2mpl/literal-this-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-this-1.java.result
rename to src/MapleFE/test/java/java2mpl/literal-this-1.java.result
diff --git a/src/MapleFE/test/java2mpl/literal-this-2.java b/src/MapleFE/test/java/java2mpl/literal-this-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-this-2.java
rename to src/MapleFE/test/java/java2mpl/literal-this-2.java
diff --git a/src/MapleFE/test/java2mpl/literal-this-2.java.result b/src/MapleFE/test/java/java2mpl/literal-this-2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-this-2.java.result
rename to src/MapleFE/test/java/java2mpl/literal-this-2.java.result
diff --git a/src/MapleFE/test/java2mpl/literal-unicode.java b/src/MapleFE/test/java/java2mpl/literal-unicode.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-unicode.java
rename to src/MapleFE/test/java/java2mpl/literal-unicode.java
diff --git a/src/MapleFE/test/java2mpl/literal-unicode.java.result b/src/MapleFE/test/java/java2mpl/literal-unicode.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/literal-unicode.java.result
rename to src/MapleFE/test/java/java2mpl/literal-unicode.java.result
diff --git a/src/MapleFE/test/java2mpl/local-class.java b/src/MapleFE/test/java/java2mpl/local-class.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/local-class.java
rename to src/MapleFE/test/java/java2mpl/local-class.java
diff --git a/src/MapleFE/test/java2mpl/local-class.java.result b/src/MapleFE/test/java/java2mpl/local-class.java.result
similarity index 98%
rename from src/MapleFE/test/java2mpl/local-class.java.result
rename to src/MapleFE/test/java/java2mpl/local-class.java.result
index 663f73158c2a3f2a351f96443fa90985342fc1ac..94a8dc2d57c2e3f92d87ded085b7bb6f95b9374e 100644
--- a/src/MapleFE/test/java2mpl/local-class.java.result
+++ b/src/MapleFE/test/java/java2mpl/local-class.java.result
@@ -8,7 +8,7 @@ class  Global
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      new Cyclic<Cyclic>
+      new Cyclic()
       class  Cyclic
         Fields: 
 
diff --git a/src/MapleFE/test/java2mpl/new-stmt-1.java b/src/MapleFE/test/java/java2mpl/new-stmt-1.java
similarity index 97%
rename from src/MapleFE/test/java2mpl/new-stmt-1.java
rename to src/MapleFE/test/java/java2mpl/new-stmt-1.java
index 989e7968879e403c0c1d1f52b49232d501a3f61c..bdd4b5513fcf65d3fda6a20e7f27185f551cc19e 100644
--- a/src/MapleFE/test/java2mpl/new-stmt-1.java
+++ b/src/MapleFE/test/java/java2mpl/new-stmt-1.java
@@ -19,4 +19,5 @@ class A {
 }
 
 class Cyclic {
+  Cyclic() {}
 }
diff --git a/src/MapleFE/test/java2mpl/new-stmt-1.java.result b/src/MapleFE/test/java/java2mpl/new-stmt-1.java.result
similarity index 82%
rename from src/MapleFE/test/java2mpl/new-stmt-1.java.result
rename to src/MapleFE/test/java/java2mpl/new-stmt-1.java.result
index 4785ac1f04b0f462d9cb8377472b482aceb337f8..38cc51684021ccf647c1be343aeff4babdfd0138 100644
--- a/src/MapleFE/test/java2mpl/new-stmt-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/new-stmt-1.java.result
@@ -1,5 +1,5 @@
 Matched 15 tokens.
-Matched 19 tokens.
+Matched 24 tokens.
 ============= Module ===========
 == Sub Tree ==
 class  A
@@ -9,7 +9,7 @@ class  A
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      new Cyclic<Cyclic>
+      new Cyclic()
   LocalClasses: 
   LocalInterfaces: 
 
@@ -19,6 +19,7 @@ class  Cyclic
 
   Instance Initializer: 
   Constructors: 
+    constructor  Cyclic()  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/new-stmt-2.java b/src/MapleFE/test/java/java2mpl/new-stmt-2.java
similarity index 97%
rename from src/MapleFE/test/java2mpl/new-stmt-2.java
rename to src/MapleFE/test/java/java2mpl/new-stmt-2.java
index a0156ccc386cc5be0dcdbe870ff686c82f05bda3..6ee5b41ae2c94a87fb25b4fddd9f7419c12e3e3d 100644
--- a/src/MapleFE/test/java2mpl/new-stmt-2.java
+++ b/src/MapleFE/test/java/java2mpl/new-stmt-2.java
@@ -19,4 +19,5 @@ class A {
 }
 
 class Cyclic {
+  Cyclic(int i) {}
 }
diff --git a/src/MapleFE/test/java2mpl/new-stmt-2.java.result b/src/MapleFE/test/java/java2mpl/new-stmt-2.java.result
similarity index 75%
rename from src/MapleFE/test/java2mpl/new-stmt-2.java.result
rename to src/MapleFE/test/java/java2mpl/new-stmt-2.java.result
index 8706e6ffe58523083074c28d47d300efdfa1890d..7a792a923733e75bd9219d1c6c587ca8a68e919b 100644
--- a/src/MapleFE/test/java2mpl/new-stmt-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/new-stmt-2.java.result
@@ -1,5 +1,5 @@
 Matched 18 tokens.
-Matched 22 tokens.
+Matched 29 tokens.
 ============= Module ===========
 == Sub Tree ==
 class  A
@@ -8,8 +8,8 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
-      new Cyclic<Cyclic>
+    func  foo(a)  throws: 
+      new Cyclic(a)
   LocalClasses: 
   LocalInterfaces: 
 
@@ -19,6 +19,7 @@ class  Cyclic
 
   Instance Initializer: 
   Constructors: 
+    constructor  Cyclic(i)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/new-stmt-3.java b/src/MapleFE/test/java/java2mpl/new-stmt-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/new-stmt-3.java
rename to src/MapleFE/test/java/java2mpl/new-stmt-3.java
diff --git a/src/MapleFE/test/java2mpl/new-stmt-3.java.result b/src/MapleFE/test/java/java2mpl/new-stmt-3.java.result
similarity index 90%
rename from src/MapleFE/test/java2mpl/new-stmt-3.java.result
rename to src/MapleFE/test/java/java2mpl/new-stmt-3.java.result
index 195cc40edeb05f2eb020078f2093a3811bb36fa0..54d6721ee9ed140d8614f17dfc776f155ceaabf8 100644
--- a/src/MapleFE/test/java2mpl/new-stmt-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/new-stmt-3.java.result
@@ -7,7 +7,7 @@ class  Outer
   Instance Initializer: 
   Constructors: 
     constructor  Outer()  throws: 
-      var:i=new Inner<Inner>
+      Decl: i=new Inner()
   Methods: 
   LocalClasses: 
     class  Inner
@@ -17,7 +17,7 @@ class  Outer
       Constructors: 
       Methods: 
         func  foo()  throws: 
-          var:i=
+          Decl: i=
       LocalClasses: 
         class  Inner2
           Fields: 
@@ -32,7 +32,7 @@ class  Outer
               Instance Initializer: 
               Constructors: 
                 constructor  Inner3()  throws: 
-                  var:i2=new Inner2<Inner2>
+                  Decl: i2=new Inner2()
               Methods: 
               LocalClasses: 
               LocalInterfaces: 
diff --git a/src/MapleFE/test/sharedfe/add3.java b/src/MapleFE/test/java/java2mpl/new-stmt-4.java
similarity index 88%
rename from src/MapleFE/test/sharedfe/add3.java
rename to src/MapleFE/test/java/java2mpl/new-stmt-4.java
index 1c9b539ae78938be3d630dcaeb6e3924679dbac0..fe5428e599323109a4837de0c21d38894030b52c 100644
--- a/src/MapleFE/test/sharedfe/add3.java
+++ b/src/MapleFE/test/java/java2mpl/new-stmt-4.java
@@ -13,9 +13,10 @@
 //See the Mulan PSL v2 for more details.
 //
 
-int foo(int a, int b) {
-  int c;
-
-  c = a + b + c;
-  return c;
+class A {
+  A(int x) {}
+  void foo() {
+    A a;
+    a = new A(3);
+  }
 }
diff --git a/src/MapleFE/test/java/java2mpl/new-stmt-4.java.result b/src/MapleFE/test/java/java2mpl/new-stmt-4.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..4836a70c96e244e9044b81e52801a680f1b3c411
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/new-stmt-4.java.result
@@ -0,0 +1,17 @@
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+    constructor  A(x)  throws: 
+  Methods: 
+    func  foo()  throws: 
+      Decl: a
+      a Assign new A(3)
+  LocalClasses: 
+  LocalInterfaces: 
+
+Identifier:a has no decl.
diff --git a/src/MapleFE/test/java2mpl/point-list.java b/src/MapleFE/test/java/java2mpl/point-list.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/point-list.java
rename to src/MapleFE/test/java/java2mpl/point-list.java
diff --git a/src/MapleFE/test/java2mpl/point-list.java.result b/src/MapleFE/test/java/java2mpl/point-list.java.result
similarity index 92%
rename from src/MapleFE/test/java2mpl/point-list.java.result
rename to src/MapleFE/test/java/java2mpl/point-list.java.result
index 7c9b31ffc1da5e7657ea28ff533f0b0dc5013672..b9155b43b38ab2271706493070e60f786a181a2d 100644
--- a/src/MapleFE/test/java2mpl/point-list.java.result
+++ b/src/MapleFE/test/java/java2mpl/point-list.java.result
@@ -9,7 +9,7 @@ class  Point
   Constructors: 
   Methods: 
     func  foo()  throws: 
-      var:pl=new PointList<PointList>
+      Decl: pl=new PointList()
       pl.z Assign 1
       return pl.z
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/switch-1.java b/src/MapleFE/test/java/java2mpl/switch-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/switch-1.java
rename to src/MapleFE/test/java/java2mpl/switch-1.java
diff --git a/src/MapleFE/test/java2mpl/switch-1.java.result b/src/MapleFE/test/java/java2mpl/switch-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/switch-1.java.result
rename to src/MapleFE/test/java/java2mpl/switch-1.java.result
diff --git a/src/MapleFE/test/java2mpl/switch-2.java b/src/MapleFE/test/java/java2mpl/switch-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/switch-2.java
rename to src/MapleFE/test/java/java2mpl/switch-2.java
diff --git a/src/MapleFE/test/java2mpl/switch-2.java.result b/src/MapleFE/test/java/java2mpl/switch-2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/switch-2.java.result
rename to src/MapleFE/test/java/java2mpl/switch-2.java.result
diff --git a/src/MapleFE/test/java2mpl/t.java b/src/MapleFE/test/java/java2mpl/t.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/t.java
rename to src/MapleFE/test/java/java2mpl/t.java
diff --git a/src/MapleFE/test/java2mpl/t.java.result b/src/MapleFE/test/java/java2mpl/t.java.result
similarity index 85%
rename from src/MapleFE/test/java2mpl/t.java.result
rename to src/MapleFE/test/java/java2mpl/t.java.result
index 80a92a3a9b58bfc354c4a28fd18fe06c52931e64..d45e86e510ff9949e14b2fcf8a7510269aad3893 100644
--- a/src/MapleFE/test/java2mpl/t.java.result
+++ b/src/MapleFE/test/java/java2mpl/t.java.result
@@ -6,7 +6,7 @@ class  Point
 
   Instance Initializer: 
   Constructors: 
-    constructor  Point()  throws: 
+    constructor  Point(x)  throws: 
       this.x Assign x
   Methods: 
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/t1.java b/src/MapleFE/test/java/java2mpl/t1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/t1.java
rename to src/MapleFE/test/java/java2mpl/t1.java
diff --git a/src/MapleFE/test/java2mpl/t1.java.result b/src/MapleFE/test/java/java2mpl/t1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/t1.java.result
rename to src/MapleFE/test/java/java2mpl/t1.java.result
diff --git a/src/MapleFE/test/java2mpl/t2.java b/src/MapleFE/test/java/java2mpl/t2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/t2.java
rename to src/MapleFE/test/java/java2mpl/t2.java
diff --git a/src/MapleFE/test/java2mpl/t2.java.result b/src/MapleFE/test/java/java2mpl/t2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/t2.java.result
rename to src/MapleFE/test/java/java2mpl/t2.java.result
diff --git a/src/MapleFE/test/java2mpl/t3.java b/src/MapleFE/test/java/java2mpl/t3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/t3.java
rename to src/MapleFE/test/java/java2mpl/t3.java
diff --git a/src/MapleFE/test/java2mpl/t3.java.result b/src/MapleFE/test/java/java2mpl/t3.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/t3.java.result
rename to src/MapleFE/test/java/java2mpl/t3.java.result
diff --git a/src/MapleFE/test/java2mpl/t4.java b/src/MapleFE/test/java/java2mpl/t4.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/t4.java
rename to src/MapleFE/test/java/java2mpl/t4.java
diff --git a/src/MapleFE/test/java2mpl/t4.java.result b/src/MapleFE/test/java/java2mpl/t4.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/t4.java.result
rename to src/MapleFE/test/java/java2mpl/t4.java.result
diff --git a/src/MapleFE/test/java2mpl/t5.java b/src/MapleFE/test/java/java2mpl/t5.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/t5.java
rename to src/MapleFE/test/java/java2mpl/t5.java
diff --git a/src/MapleFE/test/java2mpl/t5.java.result b/src/MapleFE/test/java/java2mpl/t5.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/t5.java.result
rename to src/MapleFE/test/java/java2mpl/t5.java.result
diff --git a/src/MapleFE/test/java/java2mpl/ternary-operator.java b/src/MapleFE/test/java/java2mpl/ternary-operator.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c4abf67536d37c48435740c1f62a56ccc72fa93
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/ternary-operator.java
@@ -0,0 +1,23 @@
+//
+//Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+//
+//OpenArkFE is licensed under the Mulan PSL v2.
+//You can use this software according to the terms and conditions of the Mulan PSL v2.
+//You may obtain a copy of Mulan PSL v2 at:
+//
+// http://license.coscl.org.cn/MulanPSL2
+//
+//THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+//EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+//FIT FOR A PARTICULAR PURPOSE.
+//See the Mulan PSL v2 for more details.
+//
+
+class A {
+  public static Boolean Is3(int s) {
+    Boolean b;
+    b = (s == 3 ? true : false);
+    return b;
+  }
+
+}
diff --git a/src/MapleFE/test/java/java2mpl/ternary-operator.java.result b/src/MapleFE/test/java/java2mpl/ternary-operator.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..c1cc983aa0ee0b76fa407770126d462e8a11c470
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/ternary-operator.java.result
@@ -0,0 +1,17 @@
+Matched 32 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  Is3(s)  throws: 
+      Decl: b
+      b Assign ()
+      return b
+  LocalClasses: 
+  LocalInterfaces: 
+
+Identifier:b has no decl.
diff --git a/src/MapleFE/test/java2mpl/throw-1.java b/src/MapleFE/test/java/java2mpl/throw-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/throw-1.java
rename to src/MapleFE/test/java/java2mpl/throw-1.java
diff --git a/src/MapleFE/test/java2mpl/throw-1.java.result b/src/MapleFE/test/java/java2mpl/throw-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/throw-1.java.result
rename to src/MapleFE/test/java/java2mpl/throw-1.java.result
diff --git a/src/MapleFE/test/java2mpl/throw-2.java b/src/MapleFE/test/java/java2mpl/throw-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/throw-2.java
rename to src/MapleFE/test/java/java2mpl/throw-2.java
diff --git a/src/MapleFE/test/java2mpl/throw-2.java.result b/src/MapleFE/test/java/java2mpl/throw-2.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/throw-2.java.result
rename to src/MapleFE/test/java/java2mpl/throw-2.java.result
diff --git a/src/MapleFE/test/java2mpl/type-argument-1.java b/src/MapleFE/test/java/java2mpl/type-argument-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/type-argument-1.java
rename to src/MapleFE/test/java/java2mpl/type-argument-1.java
diff --git a/src/MapleFE/test/java2mpl/type-argument-1.java.result b/src/MapleFE/test/java/java2mpl/type-argument-1.java.result
similarity index 90%
rename from src/MapleFE/test/java2mpl/type-argument-1.java.result
rename to src/MapleFE/test/java/java2mpl/type-argument-1.java.result
index 26072486913e9134b0cf558311ceb80140ee77b6..5031a406178674ab0966917f2af76f62ca7c61ea 100644
--- a/src/MapleFE/test/java2mpl/type-argument-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/type-argument-1.java.result
@@ -3,7 +3,7 @@ Matched 14 tokens.
 == Sub Tree ==
 class  A
   Fields: 
-    m=new HM
+    m=new HM(256)
   Instance Initializer: 
   Constructors: 
   Methods: 
diff --git a/src/MapleFE/test/java2mpl/type-argument-2.java b/src/MapleFE/test/java/java2mpl/type-argument-2.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/type-argument-2.java
rename to src/MapleFE/test/java/java2mpl/type-argument-2.java
diff --git a/src/MapleFE/test/java2mpl/type-argument-2.java.result b/src/MapleFE/test/java/java2mpl/type-argument-2.java.result
similarity index 91%
rename from src/MapleFE/test/java2mpl/type-argument-2.java.result
rename to src/MapleFE/test/java/java2mpl/type-argument-2.java.result
index bfaa72f4a5a6423dd755381ddb9ef0ec2af9866d..3898da8e42cd8039913a076660fd43c24e5df300 100644
--- a/src/MapleFE/test/java2mpl/type-argument-2.java.result
+++ b/src/MapleFE/test/java/java2mpl/type-argument-2.java.result
@@ -3,7 +3,7 @@ Matched 23 tokens.
 == Sub Tree ==
 class  A
   Fields: 
-    b=new B<T[]>
+    b=new B(8)
   Instance Initializer: 
   Constructors: 
   Methods: 
diff --git a/src/MapleFE/test/java2mpl/type-argument-3.java b/src/MapleFE/test/java/java2mpl/type-argument-3.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/type-argument-3.java
rename to src/MapleFE/test/java/java2mpl/type-argument-3.java
diff --git a/src/MapleFE/test/java2mpl/type-argument-3.java.result b/src/MapleFE/test/java/java2mpl/type-argument-3.java.result
similarity index 78%
rename from src/MapleFE/test/java2mpl/type-argument-3.java.result
rename to src/MapleFE/test/java/java2mpl/type-argument-3.java.result
index 05fbf45200db860a4b16d79f4922a52b86cd5c81..9bf1a3effa320225106fe83923691696a2c0ea7a 100644
--- a/src/MapleFE/test/java2mpl/type-argument-3.java.result
+++ b/src/MapleFE/test/java/java2mpl/type-argument-3.java.result
@@ -7,8 +7,8 @@ class  C
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  getClasses()  throws: 
-      var:result=a
+    func  getClasses(a)  throws: 
+      Decl: result=a
       return result
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/unary-operator-1.java b/src/MapleFE/test/java/java2mpl/unary-operator-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/unary-operator-1.java
rename to src/MapleFE/test/java/java2mpl/unary-operator-1.java
diff --git a/src/MapleFE/test/java2mpl/unary-operator-1.java.result b/src/MapleFE/test/java/java2mpl/unary-operator-1.java.result
similarity index 78%
rename from src/MapleFE/test/java2mpl/unary-operator-1.java.result
rename to src/MapleFE/test/java/java2mpl/unary-operator-1.java.result
index e493b2c3387e31f42111d2dfc125f8918c20f80f..931f5e09901bbc714327fc6fc656b6b01a04ba88 100644
--- a/src/MapleFE/test/java2mpl/unary-operator-1.java.result
+++ b/src/MapleFE/test/java/java2mpl/unary-operator-1.java.result
@@ -7,11 +7,10 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
+    func  foo(x)  throws: 
       cond-branch cond:x NE 0
       true branch :
-        return 0
-      false branch :
+        return 0      false branch :
 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/java2mpl/unary-operator.java b/src/MapleFE/test/java/java2mpl/unary-operator.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/unary-operator.java
rename to src/MapleFE/test/java/java2mpl/unary-operator.java
diff --git a/src/MapleFE/test/java2mpl/unary-operator.java.result b/src/MapleFE/test/java/java2mpl/unary-operator.java.result
similarity index 66%
rename from src/MapleFE/test/java2mpl/unary-operator.java.result
rename to src/MapleFE/test/java/java2mpl/unary-operator.java.result
index fde76bdbe978473e1d5d2a435729d9ab8a2f68ac..2ed0a9a8e3cf5158bc710cd9148bcdaac9b5877b 100644
--- a/src/MapleFE/test/java2mpl/unary-operator.java.result
+++ b/src/MapleFE/test/java/java2mpl/unary-operator.java.result
@@ -7,12 +7,12 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
-      var:y,z
-              xInc
+    func  foo(x)  throws: 
+      Decl: y,z
+      x Inc
 
       y AddAssign (x Add a Add b)
-              aDec
+      a Dec
 
       b BxorAssign a
       z MulAssign y Add 4
@@ -20,3 +20,6 @@ class  A
   LocalClasses: 
   LocalInterfaces: 
 
+Identifier:y has no decl.
+Identifier:z has no decl.
+Identifier:y has no decl.
diff --git a/src/MapleFE/test/java/java2mpl/var-scope-2.java b/src/MapleFE/test/java/java2mpl/var-scope-2.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5391c4be2185cfb52d8e8a25311711a1e3faf36
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/var-scope-2.java
@@ -0,0 +1,36 @@
+//
+//Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+//
+//OpenArkFE is licensed under the Mulan PSL v2.
+//You can use this software according to the terms and conditions of the Mulan PSL v2.
+//You may obtain a copy of Mulan PSL v2 at:
+//
+// http://license.coscl.org.cn/MulanPSL2
+//
+//THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+//EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+//FIT FOR A PARTICULAR PURPOSE.
+//See the Mulan PSL v2 for more details.
+//
+
+class A {
+  int a;
+  
+  int foo(int x) {
+    a = x;            // field a
+    if (a == 1) {
+      int a = 2;      // local variable a
+      a = x + this.a;
+      return a + 2;
+    }
+
+    int a = 4;        // local variable a|1
+    a = x + this.a;
+    {
+      int a = 6;      // local variable a|2
+      x = a;
+    }
+    a += x;           // local variable a|1
+    return a + 4;
+  }
+}
diff --git a/src/MapleFE/test/java/java2mpl/var-scope-2.java.result b/src/MapleFE/test/java/java2mpl/var-scope-2.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..5a56845acdad661704058e92c9e99b6f4cdfb461
--- /dev/null
+++ b/src/MapleFE/test/java/java2mpl/var-scope-2.java.result
@@ -0,0 +1,28 @@
+Matched 78 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+    a
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  foo(x)  throws: 
+      a Assign x
+      cond-branch cond:a EQ 1
+      true branch :
+        Decl: a=2
+        a Assign x Add this.a
+        return a Add 2
+      false branch :
+
+      Decl: a=4
+      a Assign x Add this.a
+      Decl: a=6
+      x Assign a
+
+      a AddAssign x
+      return a Add 4
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java2mpl/var-scope.java b/src/MapleFE/test/java/java2mpl/var-scope.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/var-scope.java
rename to src/MapleFE/test/java/java2mpl/var-scope.java
diff --git a/src/MapleFE/test/java2mpl/var-scope.java.result b/src/MapleFE/test/java/java2mpl/var-scope.java.result
similarity index 73%
rename from src/MapleFE/test/java2mpl/var-scope.java.result
rename to src/MapleFE/test/java/java2mpl/var-scope.java.result
index 253ac3d55f5aa2c5fd80c158f084987ebcf9bdb3..85df7146e43c6edfedc9749e43b16cd3901a7e5d 100644
--- a/src/MapleFE/test/java2mpl/var-scope.java.result
+++ b/src/MapleFE/test/java/java2mpl/var-scope.java.result
@@ -7,15 +7,16 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
+    func  foo(x)  throws: 
       a Assign x
       cond-branch cond:a EQ 1
       true branch :
-        var:a=2
-
+        Decl: a=2
+        a Assign x Add this.a
+        return a Add 2
       false branch :
 
-      var:a=4
+      Decl: a=4
       a Assign x Add this.a
       return a Add 4
   LocalClasses: 
diff --git a/src/MapleFE/test/java2mpl/whileloop-1.java b/src/MapleFE/test/java/java2mpl/whileloop-1.java
similarity index 100%
rename from src/MapleFE/test/java2mpl/whileloop-1.java
rename to src/MapleFE/test/java/java2mpl/whileloop-1.java
diff --git a/src/MapleFE/test/java2mpl/whileloop-1.java.result b/src/MapleFE/test/java/java2mpl/whileloop-1.java.result
similarity index 100%
rename from src/MapleFE/test/java2mpl/whileloop-1.java.result
rename to src/MapleFE/test/java/java2mpl/whileloop-1.java.result
diff --git a/src/MapleFE/test/openjdk/AbstractMethodError.java b/src/MapleFE/test/java/openjdk/AbstractMethodError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/AbstractMethodError.java
rename to src/MapleFE/test/java/openjdk/AbstractMethodError.java
diff --git a/src/MapleFE/test/openjdk/AbstractMethodError.java.result b/src/MapleFE/test/java/openjdk/AbstractMethodError.java.result
similarity index 72%
rename from src/MapleFE/test/openjdk/AbstractMethodError.java.result
rename to src/MapleFE/test/java/openjdk/AbstractMethodError.java.result
index b316609ddc8ca5d33c2ebbdf41903a71a4cf14ed..ba598d38f2e8ca72c4baf23edd11262f99d7e37d 100644
--- a/src/MapleFE/test/openjdk/AbstractMethodError.java.result
+++ b/src/MapleFE/test/java/openjdk/AbstractMethodError.java.result
@@ -1,17 +1,16 @@
 Matched 5 tokens.
-Matched 44 tokens.
+Matched 43 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  AbstractMethodError
   Fields: 
-    serialVersionUID=Sub
-  -1256039074
+    serialVersionUID=1256039074
   Instance Initializer: 
   Constructors: 
     constructor  AbstractMethodError()  throws: 
-    constructor  AbstractMethodError()  throws: 
+    constructor  AbstractMethodError(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/AbstractStringBuilder-simplified.java b/src/MapleFE/test/java/openjdk/AbstractStringBuilder-simplified.java
similarity index 100%
rename from src/MapleFE/test/openjdk/AbstractStringBuilder-simplified.java
rename to src/MapleFE/test/java/openjdk/AbstractStringBuilder-simplified.java
diff --git a/src/MapleFE/test/java/openjdk/AbstractStringBuilder-simplified.java.result b/src/MapleFE/test/java/openjdk/AbstractStringBuilder-simplified.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..4ca8eed4878e7a6857f1d703c8b24ab46b62a1de
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/AbstractStringBuilder-simplified.java.result
@@ -0,0 +1,43 @@
+Matched 329 tokens.
+============= Module ===========
+== Sub Tree ==
+class  AbstractStringBuilder
+  Fields: 
+    value    count    MAX_ARRAY_SIZE=Integer.MAX_VALUE Sub 8
+  Instance Initializer: 
+  Constructors: 
+    constructor  AbstractStringBuilder()  throws: 
+    constructor  AbstractStringBuilder(capacity)  throws: 
+  Methods: 
+    func  length()  throws: 
+    func  capacity()  throws: 
+    func  ensureCapacity(minimumCapacity)  throws: 
+    func  ensureCapacityInternal(minimumCapacity)  throws: 
+    func  newCapacity(minCapacity)  throws: 
+    func  hugeCapacity(minCapacity)  throws: 
+    func  trimToSize()  throws: 
+    func  setLength(newLength)  throws: 
+    func  charAt(index)  throws: 
+    func  codePointAt(index)  throws: 
+    func  codePointBefore(index)  throws: 
+    func  codePointCount(beginIndex,endIndex)  throws: 
+    func  offsetByCodePoints(index,codePointOffset)  throws: 
+    func  getChars(srcBegin,srcEnd,dst,dstBegin)  throws: 
+    func  setCharAt(index,ch)  throws: 
+    func  append(obj)  throws: 
+    func  append(str)  throws: 
+    func  append(sb)  throws: 
+    func  append(asb)  throws: 
+    func  append(s)  throws: 
+    func  appendNull()  throws: 
+    func  append(s,start,end)  throws: 
+    func  append(str)  throws: 
+    func  append(str[],offset,len)  throws: 
+    func  append(b)  throws: 
+    func  append(c)  throws: 
+    func  append(i)  throws: 
+    func  append(l)  throws: 
+    func  append(f)  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/openjdk/AbstractStringBuilder.java b/src/MapleFE/test/java/openjdk/AbstractStringBuilder.java
similarity index 100%
rename from src/MapleFE/test/openjdk/AbstractStringBuilder.java
rename to src/MapleFE/test/java/openjdk/AbstractStringBuilder.java
diff --git a/src/MapleFE/test/openjdk/AbstractStringBuilder.java.result b/src/MapleFE/test/java/openjdk/AbstractStringBuilder.java.result
similarity index 57%
rename from src/MapleFE/test/openjdk/AbstractStringBuilder.java.result
rename to src/MapleFE/test/java/openjdk/AbstractStringBuilder.java.result
index e2266a7cc41e75fd420a0e6afe758f2f10896cd7..9e9e2349c4b2ed8229f362673a4d7110a10e62ee 100644
Binary files a/src/MapleFE/test/openjdk/AbstractStringBuilder.java.result and b/src/MapleFE/test/java/openjdk/AbstractStringBuilder.java.result differ
diff --git a/src/MapleFE/test/openjdk/Appendable.java b/src/MapleFE/test/java/openjdk/Appendable.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Appendable.java
rename to src/MapleFE/test/java/openjdk/Appendable.java
diff --git a/src/MapleFE/test/openjdk/Appendable.java.result b/src/MapleFE/test/java/openjdk/Appendable.java.result
similarity index 60%
rename from src/MapleFE/test/openjdk/Appendable.java.result
rename to src/MapleFE/test/java/openjdk/Appendable.java.result
index 93789bd41e00d444dbea1751d57c1b97382d94ab..ee3a5ce7fa79c2591be93f9ab36dd50cc0a4ff15 100644
--- a/src/MapleFE/test/openjdk/Appendable.java.result
+++ b/src/MapleFE/test/java/openjdk/Appendable.java.result
@@ -11,7 +11,7 @@ interface  Appendable
   Fields: 
 
   Methods: 
-    func  append()  throws:     IOException
-    func  append()  throws:     IOException
-    func  append()  throws:     IOException
+    func  append(csq)  throws:     IOException
+    func  append(csq,start,end)  throws:     IOException
+    func  append(c)  throws:     IOException
 
diff --git a/src/MapleFE/test/openjdk/ArithmeticException.java b/src/MapleFE/test/java/openjdk/ArithmeticException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/ArithmeticException.java
rename to src/MapleFE/test/java/openjdk/ArithmeticException.java
diff --git a/src/MapleFE/test/openjdk/ArithmeticException.java.result b/src/MapleFE/test/java/openjdk/ArithmeticException.java.result
similarity index 86%
rename from src/MapleFE/test/openjdk/ArithmeticException.java.result
rename to src/MapleFE/test/java/openjdk/ArithmeticException.java.result
index 9b4a3b76ead1bd4ae2341109ff7b11a765835a95..b858b7e57a8387ece48fb83667e0434f45e1f613 100644
--- a/src/MapleFE/test/openjdk/ArithmeticException.java.result
+++ b/src/MapleFE/test/java/openjdk/ArithmeticException.java.result
@@ -10,7 +10,7 @@ class  ArithmeticException
   Instance Initializer: 
   Constructors: 
     constructor  ArithmeticException()  throws: 
-    constructor  ArithmeticException()  throws: 
+    constructor  ArithmeticException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/ArrayIndexOutOfBoundsException.java b/src/MapleFE/test/java/openjdk/ArrayIndexOutOfBoundsException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/ArrayIndexOutOfBoundsException.java
rename to src/MapleFE/test/java/openjdk/ArrayIndexOutOfBoundsException.java
diff --git a/src/MapleFE/test/openjdk/ArrayIndexOutOfBoundsException.java.result b/src/MapleFE/test/java/openjdk/ArrayIndexOutOfBoundsException.java.result
similarity index 46%
rename from src/MapleFE/test/openjdk/ArrayIndexOutOfBoundsException.java.result
rename to src/MapleFE/test/java/openjdk/ArrayIndexOutOfBoundsException.java.result
index ddd36a4f3ca1e7977ba9191c26babd5f435be1a6..b80ef27091987537772f2e3601c2f636cabf1e82 100644
--- a/src/MapleFE/test/openjdk/ArrayIndexOutOfBoundsException.java.result
+++ b/src/MapleFE/test/java/openjdk/ArrayIndexOutOfBoundsException.java.result
@@ -1,20 +1,19 @@
 Matched 5 tokens.
-Matched 110 tokens.
+Matched 109 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  ArrayIndexOutOfBoundsException
   Fields: 
-    serialVersionUID=Sub
-  -1467917380
+    serialVersionUID=1467917380
   Instance Initializer: 
   Constructors: 
     constructor  ArrayIndexOutOfBoundsException()  throws: 
-    constructor  ArrayIndexOutOfBoundsException()  throws: 
-    constructor  ArrayIndexOutOfBoundsException()  throws: 
-    constructor  ArrayIndexOutOfBoundsException()  throws: 
-    constructor  ArrayIndexOutOfBoundsException()  throws: 
+    constructor  ArrayIndexOutOfBoundsException(index)  throws: 
+    constructor  ArrayIndexOutOfBoundsException(s)  throws: 
+    constructor  ArrayIndexOutOfBoundsException(sourceLength,index)  throws: 
+    constructor  ArrayIndexOutOfBoundsException(sourceLength,offset,count)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/ArrayStoreException.java b/src/MapleFE/test/java/openjdk/ArrayStoreException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/ArrayStoreException.java
rename to src/MapleFE/test/java/openjdk/ArrayStoreException.java
diff --git a/src/MapleFE/test/openjdk/ArrayStoreException.java.result b/src/MapleFE/test/java/openjdk/ArrayStoreException.java.result
similarity index 72%
rename from src/MapleFE/test/openjdk/ArrayStoreException.java.result
rename to src/MapleFE/test/java/openjdk/ArrayStoreException.java.result
index eedee8eec59aa257701e5ca55d339cda3c8e64e9..9ce786e95f8d5b34264ed8cba49b6b6710357764 100644
--- a/src/MapleFE/test/openjdk/ArrayStoreException.java.result
+++ b/src/MapleFE/test/java/openjdk/ArrayStoreException.java.result
@@ -1,17 +1,16 @@
 Matched 5 tokens.
-Matched 44 tokens.
+Matched 43 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  ArrayStoreException
   Fields: 
-    serialVersionUID=Sub
-  1085227297
+    serialVersionUID=-1085227297
   Instance Initializer: 
   Constructors: 
     constructor  ArrayStoreException()  throws: 
-    constructor  ArrayStoreException()  throws: 
+    constructor  ArrayStoreException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/AutoCloseable.java b/src/MapleFE/test/java/openjdk/AutoCloseable.java
similarity index 100%
rename from src/MapleFE/test/openjdk/AutoCloseable.java
rename to src/MapleFE/test/java/openjdk/AutoCloseable.java
diff --git a/src/MapleFE/test/openjdk/AutoCloseable.java.result b/src/MapleFE/test/java/openjdk/AutoCloseable.java.result
similarity index 100%
rename from src/MapleFE/test/openjdk/AutoCloseable.java.result
rename to src/MapleFE/test/java/openjdk/AutoCloseable.java.result
diff --git a/src/MapleFE/test/openjdk/Boolean.java b/src/MapleFE/test/java/openjdk/Boolean.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Boolean.java
rename to src/MapleFE/test/java/openjdk/Boolean.java
diff --git a/src/MapleFE/test/openjdk/Boolean.java.result b/src/MapleFE/test/java/openjdk/Boolean.java.result
similarity index 44%
rename from src/MapleFE/test/openjdk/Boolean.java.result
rename to src/MapleFE/test/java/openjdk/Boolean.java.result
index 8e54b2f8c83bb7e8394d669aed217fc728fdaed5..a780b2d8ad1a8801a0ff204e8763f0546d141c0b 100644
--- a/src/MapleFE/test/openjdk/Boolean.java.result
+++ b/src/MapleFE/test/java/openjdk/Boolean.java.result
@@ -1,58 +1,64 @@
 Matched 5 tokens.
-Matched 442 tokens.
+Matched 440 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  Boolean
   Fields: 
-    TRUE=new Boolean<Boolean>    FALSE=new Boolean<Boolean>    TYPE=()    value    serialVersionUID=Sub
-  711132434
+    TRUE=new Boolean(true)    FALSE=new Boolean(false)    TYPE=()boolean.getComponentType()    value    serialVersionUID=-711132434
   Instance Initializer: 
   Constructors: 
-    constructor  Boolean()  throws: 
+    constructor  Boolean(value)  throws: 
       this.value Assign value
-    constructor  Boolean()  throws: 
+    constructor  Boolean(s)  throws: 
   Methods: 
-    func  parseBoolean()  throws: 
+    func  parseBoolean(s)  throws: 
       return ((s NE null) Land s.equalsIgnoreCase("true"))
     func  booleanValue()  throws: 
       return value
-    func  valueOf()  throws: 
+    func  valueOf(b)  throws: 
       return ()
-    func  valueOf()  throws: 
+    func  valueOf(s)  throws: 
       return 
-    func  toString()  throws: 
+    func  toString(b)  throws: 
       return 
     func  toString()  throws: 
       return 
     func  hashCode()  throws: 
       return Boolean.hashCode(value)
-    func  hashCode()  throws: 
+    func  hashCode(value)  throws: 
       return 
-    func  equals()  throws: 
-      cond-branch cond:
+    func  equals(obj)  throws: 
+      cond-branch cond:obj instanceof Boolean
       true branch :
-        return value EQ ((Boolean)obj)booleanValue
+        return value EQ (Boolean)obj.booleanValue()
       false branch :
 
       return false
-    func  getBoolean()  throws: 
-      var:result=false
+    func  getBoolean(name)  throws: 
+      Decl: result=false
       result Assign parseBoolean(System.getProperty(name))
 
+      IllegalArgumentException
+      NullPointerException
+      e
 
       return result
-    func  compareTo()  throws: 
+    func  compareTo(b)  throws: 
       return compare(this.value,b.value)
-    func  compare()  throws: 
+    func  compare(x,y)  throws: 
       return 
-    func  logicalAnd()  throws: 
+    func  logicalAnd(a,b)  throws: 
       return a Land b
-    func  logicalOr()  throws: 
+    func  logicalOr(a,b)  throws: 
       return a Lor b
-    func  logicalXor()  throws: 
+    func  logicalXor(a,b)  throws: 
       return a Bxor b
   LocalClasses: 
   LocalInterfaces: 
 
+Identifier:result has no decl.
+Identifier:IllegalArgumentException has no decl.
+Identifier:NullPointerException has no decl.
+Identifier:e has no decl.
diff --git a/src/MapleFE/test/openjdk/BootstrapMethodError.java b/src/MapleFE/test/java/openjdk/BootstrapMethodError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/BootstrapMethodError.java
rename to src/MapleFE/test/java/openjdk/BootstrapMethodError.java
diff --git a/src/MapleFE/test/openjdk/BootstrapMethodError.java.result b/src/MapleFE/test/java/openjdk/BootstrapMethodError.java.result
similarity index 68%
rename from src/MapleFE/test/openjdk/BootstrapMethodError.java.result
rename to src/MapleFE/test/java/openjdk/BootstrapMethodError.java.result
index 144c70e68044fbb458be1deb47ae88174ad43e1a..d4d4b74a471b0aaaae526add731d196d79c6dfcd 100644
--- a/src/MapleFE/test/openjdk/BootstrapMethodError.java.result
+++ b/src/MapleFE/test/java/openjdk/BootstrapMethodError.java.result
@@ -10,9 +10,9 @@ class  BootstrapMethodError
   Instance Initializer: 
   Constructors: 
     constructor  BootstrapMethodError()  throws: 
-    constructor  BootstrapMethodError()  throws: 
-    constructor  BootstrapMethodError()  throws: 
-    constructor  BootstrapMethodError()  throws: 
+    constructor  BootstrapMethodError(s)  throws: 
+    constructor  BootstrapMethodError(s,cause)  throws: 
+    constructor  BootstrapMethodError(cause)  throws: 
       initCause(cause)
   Methods: 
   LocalClasses: 
diff --git a/src/MapleFE/test/openjdk/Byte.java b/src/MapleFE/test/java/openjdk/Byte.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Byte.java
rename to src/MapleFE/test/java/openjdk/Byte.java
diff --git a/src/MapleFE/test/openjdk/Byte.java.result b/src/MapleFE/test/java/openjdk/Byte.java.result
similarity index 53%
rename from src/MapleFE/test/openjdk/Byte.java.result
rename to src/MapleFE/test/java/openjdk/Byte.java.result
index 2c9e8a581342384a63e3bd9d4b345eaea6a1c9ed..37e80e137922edf8e27e5f557862acf629f2eb8d 100644
--- a/src/MapleFE/test/openjdk/Byte.java.result
+++ b/src/MapleFE/test/java/openjdk/Byte.java.result
@@ -1,46 +1,42 @@
 Matched 5 tokens.
-Matched 909 tokens.
+Matched 906 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  Byte
   Fields: 
-    MIN_VALUE=Sub
-  128    MAX_VALUE=127    TYPE=()    value    SIZE=8    BYTES=    serialVersionUID=Sub
-  296684260    DIGITS=    UPPER_CASE_DIGITS=
+    MIN_VALUE=-128    MAX_VALUE=127    TYPE=()byte.getComponentType()    value    SIZE=8    BYTES=SIZE Div Byte.SIZE    serialVersionUID=-296684260    DIGITS=    UPPER_CASE_DIGITS=
   Instance Initializer: 
   Constructors: 
-    constructor  Byte()  throws: 
+    constructor  Byte(value)  throws: 
       this.value Assign value
-    constructor  Byte()  throws: 
+    constructor  Byte(s)  throws: 
       this.value Assign parseByte(s,10)
   Methods: 
-    func  toString()  throws: 
+    func  toString(b)  throws: 
       return Integer.toString((int)b,10)
-    func  valueOf()  throws: 
-      var:offset=128
+    func  valueOf(b)  throws: 
+      Decl: offset=128
       return 
-    func  parseByte()  throws:     NumberFormatException
-      var:i=Integer.parseInt(s,radix)
+    func  parseByte(s,radix)  throws:     NumberFormatException
+      Decl: i=Integer.parseInt(s,radix)
       cond-branch cond:i LT MIN_VALUE Lor i GT MAX_VALUE
       true branch :
-        new NumberFormatException<NumberFormatException>
-      false branch :
+        new NumberFormatException("Value out of range. Value:\"" Add s Add "\" Radix:" Add radix)      false branch :
 
       return (byte)i
-    func  parseByte()  throws:     NumberFormatException
+    func  parseByte(s)  throws:     NumberFormatException
       return parseByte(s,10)
-    func  valueOf()  throws:     NumberFormatException
+    func  valueOf(s,radix)  throws:     NumberFormatException
       return valueOf(parseByte(s,radix))
-    func  valueOf()  throws:     NumberFormatException
+    func  valueOf(s)  throws:     NumberFormatException
       return valueOf(s,10)
-    func  decode()  throws:     NumberFormatException
-      var:i=Integer.decode(nm)
+    func  decode(nm)  throws:     NumberFormatException
+      Decl: i=Integer.decode(nm)
       cond-branch cond:i LT MIN_VALUE Lor i GT MAX_VALUE
       true branch :
-        new NumberFormatException<NumberFormatException>
-      false branch :
+        new NumberFormatException("Value " Add i Add " out of range from input " Add nm)      false branch :
 
       return valueOf((byte)i)
     func  byteValue()  throws: 
@@ -59,29 +55,29 @@ class  Byte
       return Integer.toString((int)value)
     func  hashCode()  throws: 
       return Byte.hashCode(value)
-    func  hashCode()  throws: 
+    func  hashCode(value)  throws: 
       return (int)value
-    func  equals()  throws: 
-      cond-branch cond:
+    func  equals(obj)  throws: 
+      cond-branch cond:obj instanceof Byte
       true branch :
-        return value EQ ((Byte)obj)byteValue
+        return value EQ (Byte)obj.byteValue()
       false branch :
 
       return false
-    func  compareTo()  throws: 
+    func  compareTo(anotherByte)  throws: 
       return compare(this.value,anotherByte.value)
-    func  compare()  throws: 
+    func  compare(x,y)  throws: 
       return x Sub y
-    func  toUnsignedInt()  throws: 
+    func  toUnsignedInt(x)  throws: 
       return ((int)x) Band 255
-    func  toUnsignedLong()  throws: 
+    func  toUnsignedLong(x)  throws: 
       return ((long)x) Band 4095
-    func  toHexString()  throws: 
-      var:digits=
-      var:buf=
+    func  toHexString(b,upperCase)  throws: 
+      Decl: digits=
+      Decl: buf=
        Assign 
        Assign 
-      return new String<String>
+      return new String(0,2,buf)
   LocalClasses: 
     class  ByteCache
       Fields: 
diff --git a/src/MapleFE/test/openjdk/CharSequence.java b/src/MapleFE/test/java/openjdk/CharSequence.java
similarity index 100%
rename from src/MapleFE/test/openjdk/CharSequence.java
rename to src/MapleFE/test/java/openjdk/CharSequence.java
diff --git a/src/MapleFE/test/openjdk/CharSequence.java.result b/src/MapleFE/test/java/openjdk/CharSequence.java.result
similarity index 62%
rename from src/MapleFE/test/openjdk/CharSequence.java.result
rename to src/MapleFE/test/java/openjdk/CharSequence.java.result
index 30f6b8b351ecccc27fe23d6dd4d5a06a1bba1703..be0ea994337d1959b2b85cf4253f0ef8d0608588 100644
--- a/src/MapleFE/test/openjdk/CharSequence.java.result
+++ b/src/MapleFE/test/java/openjdk/CharSequence.java.result
@@ -30,8 +30,8 @@ interface  CharSequence
 
   Methods: 
     func  length()  throws: 
-    func  charAt()  throws: 
-    func  subSequence()  throws: 
+    func  charAt(index)  throws: 
+    func  subSequence(start,end)  throws: 
     func  toString()  throws: 
     func  chars()  throws: 
       class  CharIterator
@@ -45,20 +45,19 @@ interface  CharSequence
           func  nextInt()  throws: 
             cond-branch cond:hasNext()
             true branch :
-              return charAt(  curInc
+              return charAt(cur Inc
 )
             false branch :
-              new NoSuchElementException<NoSuchElementException>
+              new NoSuchElementException()
 
-          func  forEachRemaining()  throws: 
+          func  forEachRemaining(block)  throws: 
             for ( )
               block.accept(charAt(cur))
 
         LocalClasses: 
         LocalInterfaces: 
 
-      return StreamSupport.intStream(() -> Spliterators.spliterator(new CharIterator<CharIterator>,length(),Spliterator.ORDERED)
-,Spliterator.SUBSIZED Bor Spliterator.SIZED Bor Spliterator.ORDERED,false)
+      return StreamSupport.intStream(() -> Spliterators.spliterator(new CharIterator(),length(),Spliterator.ORDERED),Spliterator.SUBSIZED Bor Spliterator.SIZED Bor Spliterator.ORDERED,false)
     func  codePoints()  throws: 
       class  CodePointIterator
         Fields: 
@@ -66,27 +65,46 @@ interface  CharSequence
         Instance Initializer: 
         Constructors: 
         Methods: 
-          func  forEachRemaining()  throws: 
-            var:length=length()
-            var:i=cur
+          func  forEachRemaining(block)  throws: 
+            Decl: length=length()
+            Decl: i=cur
+            while i LT length              Decl: c1=charAt(i Inc
+)
+              cond-branch cond:Character.isHighSurrogate(c1) Lor i GE length
+              true branch :
+                block.accept(c1)
+              false branch :
+                Decl: c2=charAt(i)
+                cond-branch cond:Character.isLowSurrogate(c2)
+                true branch :
+                  i Inc
+
+                  block.accept(Character.toCodePoint(c1,c2))
+                false branch :
+                  block.accept(c1)
+
+
+
+
+            cur Assign i
 
           func  hasNext()  throws: 
             return cur LT length()
           func  nextInt()  throws: 
-            var:length=length()
+            Decl: length=length()
             cond-branch cond:cur GE length
             true branch :
-              new NoSuchElementException<NoSuchElementException>
+              new NoSuchElementException()
             false branch :
 
-            var:c1=charAt(  curInc
+            Decl: c1=charAt(cur Inc
 )
             cond-branch cond:Character.isHighSurrogate(c1) Land cur LT length
             true branch :
-              var:c2=charAt(cur)
+              Decl: c2=charAt(cur)
               cond-branch cond:Character.isLowSurrogate(c2)
               true branch :
-                                  curInc
+                cur Inc
 
                 return Character.toCodePoint(c1,c2)
               false branch :
@@ -97,6 +115,5 @@ interface  CharSequence
         LocalClasses: 
         LocalInterfaces: 
 
-      return StreamSupport.intStream(() -> Spliterators.spliteratorUnknownSize(new CodePointIterator<CodePointIterator>,Spliterator.ORDERED)
-,Spliterator.ORDERED,false)
+      return StreamSupport.intStream(() -> Spliterators.spliteratorUnknownSize(new CodePointIterator(),Spliterator.ORDERED),Spliterator.ORDERED,false)
 
diff --git a/src/MapleFE/test/openjdk/Character-1.java b/src/MapleFE/test/java/openjdk/Character-1.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Character-1.java
rename to src/MapleFE/test/java/openjdk/Character-1.java
diff --git a/src/MapleFE/test/java/openjdk/Character-1.java.result b/src/MapleFE/test/java/openjdk/Character-1.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..b145edf69e466f864e9534a862fa50f3b9feecd1
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Character-1.java.result
@@ -0,0 +1,94 @@
+Matched 5 tokens.
+Matched 14 tokens.
+Matched 21 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+Matched 42 tokens.
+Matched 5258 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import dalvik.annotation.optimization.FastNative
+== Sub Tree ==
+import java.util.Arrays
+== Sub Tree ==
+import java.util.HashMap
+== Sub Tree ==
+import java.util.Locale
+== Sub Tree ==
+import java.util.Map
+== Sub Tree ==
+class  Character
+  Fields: 
+    MIN_RADIX=2    MAX_RADIX=36    MIN_VALUE=0    MAX_VALUE=65535    TYPE=()char.getComponentType()    UNASSIGNED=0    UPPERCASE_LETTER=1    LOWERCASE_LETTER=2    TITLECASE_LETTER=3    MODIFIER_LETTER=4    OTHER_LETTER=5    NON_SPACING_MARK=6    ENCLOSING_MARK=7    COMBINING_SPACING_MARK=8    DECIMAL_DIGIT_NUMBER=9    LETTER_NUMBER=10    OTHER_NUMBER=11    SPACE_SEPARATOR=12    LINE_SEPARATOR=13    PARAGRAPH_SEPARATOR=14    CONTROL=15    FORMAT=16    PRIVATE_USE=18    SURROGATE=19    DASH_PUNCTUATION=20    START_PUNCTUATION=21    END_PUNCTUATION=22    CONNECTOR_PUNCTUATION=23    OTHER_PUNCTUATION=24    MATH_SYMBOL=25    CURRENCY_SYMBOL=26    MODIFIER_SYMBOL=27    OTHER_SYMBOL=28    INITIAL_QUOTE_PUNCTUATION=29    FINAL_QUOTE_PUNCTUATION=30    ERROR=-1    DIRECTIONALITY_UNDEFINED=-1    DIRECTIONALITY_LEFT_TO_RIGHT=0    DIRECTIONALITY_RIGHT_TO_LEFT=1    DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC=2    DIRECTIONALITY_EUROPEAN_NUMBER=3    DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR=4    DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR=5    DIRECTIONALITY_ARABIC_NUMBER=6    DIRECTIONALITY_COMMON_NUMBER_SEPARATOR=7    DIRECTIONALITY_NONSPACING_MARK=8    DIRECTIONALITY_BOUNDARY_NEUTRAL=9    DIRECTIONALITY_PARAGRAPH_SEPARATOR=10    DIRECTIONALITY_SEGMENT_SEPARATOR=11    DIRECTIONALITY_WHITESPACE=12    DIRECTIONALITY_OTHER_NEUTRALS=13    DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING=14    DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE=15    DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING=16    DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE=17    DIRECTIONALITY_POP_DIRECTIONAL_FORMAT=18    MIN_HIGH_SURROGATE=55296    MAX_HIGH_SURROGATE=56319    MIN_LOW_SURROGATE=56320    MAX_LOW_SURROGATE=57343    MIN_SURROGATE=MIN_HIGH_SURROGATE    MAX_SURROGATE=MAX_LOW_SURROGATE    MIN_SUPPLEMENTARY_CODE_POINT=65536    MIN_CODE_POINT=0    MAX_CODE_POINT=1114111    DIRECTIONALITY=
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+    class  Subset
+      Fields: 
+        name
+      Instance Initializer: 
+      Constructors: 
+        constructor  Subset(name)  throws: 
+          cond-branch cond:name EQ null
+          true branch :
+            new NullPointerException("name")
+          false branch :
+
+          this.name Assign name
+      Methods: 
+        func  equals(obj)  throws: 
+          return (this EQ obj)
+        func  hashCode()  throws: 
+          return super.hashCode()
+        func  toString()  throws: 
+          return name
+      LocalClasses: 
+      LocalInterfaces: 
+    class  UnicodeBlock
+      Fields: 
+        map=new HashMap(256)        BASIC_LATIN=new UnicodeBlock("BASIC_LATIN","BASIC LATIN","BASICLATIN")        LATIN_1_SUPPLEMENT=new UnicodeBlock("LATIN_1_SUPPLEMENT","LATIN-1 SUPPLEMENT","LATIN-1SUPPLEMENT")        LATIN_EXTENDED_A=new UnicodeBlock("LATIN_EXTENDED_A","LATIN EXTENDED-A","LATINEXTENDED-A")        LATIN_EXTENDED_B=new UnicodeBlock("LATIN_EXTENDED_B","LATIN EXTENDED-B","LATINEXTENDED-B")        IPA_EXTENSIONS=new UnicodeBlock("IPA_EXTENSIONS","IPA EXTENSIONS","IPAEXTENSIONS")        SPACING_MODIFIER_LETTERS=new UnicodeBlock("SPACING_MODIFIER_LETTERS","SPACING MODIFIER LETTERS","SPACINGMODIFIERLETTERS")        COMBINING_DIACRITICAL_MARKS=new UnicodeBlock("COMBINING_DIACRITICAL_MARKS","COMBINING DIACRITICAL MARKS","COMBININGDIACRITICALMARKS")        GREEK=new UnicodeBlock("GREEK","GREEK AND COPTIC","GREEKANDCOPTIC")        CYRILLIC=new UnicodeBlock("CYRILLIC")        ARMENIAN=new UnicodeBlock("ARMENIAN")        HEBREW=new UnicodeBlock("HEBREW")        ARABIC=new UnicodeBlock("ARABIC")        DEVANAGARI=new UnicodeBlock("DEVANAGARI")        BENGALI=new UnicodeBlock("BENGALI")        GURMUKHI=new UnicodeBlock("GURMUKHI")        GUJARATI=new UnicodeBlock("GUJARATI")        ORIYA=new UnicodeBlock("ORIYA")        TAMIL=new UnicodeBlock("TAMIL")        TELUGU=new UnicodeBlock("TELUGU")        KANNADA=new UnicodeBlock("KANNADA")        MALAYALAM=new UnicodeBlock("MALAYALAM")        THAI=new UnicodeBlock("THAI")        LAO=new UnicodeBlock("LAO")        TIBETAN=new UnicodeBlock("TIBETAN")        GEORGIAN=new UnicodeBlock("GEORGIAN")        HANGUL_JAMO=new UnicodeBlock("HANGUL_JAMO","HANGUL JAMO","HANGULJAMO")        LATIN_EXTENDED_ADDITIONAL=new UnicodeBlock("LATIN_EXTENDED_ADDITIONAL","LATIN EXTENDED ADDITIONAL","LATINEXTENDEDADDITIONAL")        GREEK_EXTENDED=new UnicodeBlock("GREEK_EXTENDED","GREEK EXTENDED","GREEKEXTENDED")        GENERAL_PUNCTUATION=new UnicodeBlock("GENERAL_PUNCTUATION","GENERAL PUNCTUATION","GENERALPUNCTUATION")        SUPERSCRIPTS_AND_SUBSCRIPTS=new UnicodeBlock("SUPERSCRIPTS_AND_SUBSCRIPTS","SUPERSCRIPTS AND SUBSCRIPTS","SUPERSCRIPTSANDSUBSCRIPTS")        CURRENCY_SYMBOLS=new UnicodeBlock("CURRENCY_SYMBOLS","CURRENCY SYMBOLS","CURRENCYSYMBOLS")        COMBINING_MARKS_FOR_SYMBOLS=new UnicodeBlock("COMBINING_MARKS_FOR_SYMBOLS","COMBINING DIACRITICAL MARKS FOR SYMBOLS","COMBININGDIACRITICALMARKSFORSYMBOLS","COMBINING MARKS FOR SYMBOLS","COMBININGMARKSFORSYMBOLS")        LETTERLIKE_SYMBOLS=new UnicodeBlock("LETTERLIKE_SYMBOLS","LETTERLIKE SYMBOLS","LETTERLIKESYMBOLS")        NUMBER_FORMS=new UnicodeBlock("NUMBER_FORMS","NUMBER FORMS","NUMBERFORMS")        ARROWS=new UnicodeBlock("ARROWS")        MATHEMATICAL_OPERATORS=new UnicodeBlock("MATHEMATICAL_OPERATORS","MATHEMATICAL OPERATORS","MATHEMATICALOPERATORS")        MISCELLANEOUS_TECHNICAL=new UnicodeBlock("MISCELLANEOUS_TECHNICAL","MISCELLANEOUS TECHNICAL","MISCELLANEOUSTECHNICAL")        CONTROL_PICTURES=new UnicodeBlock("CONTROL_PICTURES","CONTROL PICTURES","CONTROLPICTURES")        OPTICAL_CHARACTER_RECOGNITION=new UnicodeBlock("OPTICAL_CHARACTER_RECOGNITION","OPTICAL CHARACTER RECOGNITION","OPTICALCHARACTERRECOGNITION")        ENCLOSED_ALPHANUMERICS=new UnicodeBlock("ENCLOSED_ALPHANUMERICS","ENCLOSED ALPHANUMERICS","ENCLOSEDALPHANUMERICS")        BOX_DRAWING=new UnicodeBlock("BOX_DRAWING","BOX DRAWING","BOXDRAWING")        BLOCK_ELEMENTS=new UnicodeBlock("BLOCK_ELEMENTS","BLOCK ELEMENTS","BLOCKELEMENTS")        GEOMETRIC_SHAPES=new UnicodeBlock("GEOMETRIC_SHAPES","GEOMETRIC SHAPES","GEOMETRICSHAPES")        MISCELLANEOUS_SYMBOLS=new UnicodeBlock("MISCELLANEOUS_SYMBOLS","MISCELLANEOUS SYMBOLS","MISCELLANEOUSSYMBOLS")        DINGBATS=new UnicodeBlock("DINGBATS")        CJK_SYMBOLS_AND_PUNCTUATION=new UnicodeBlock("CJK_SYMBOLS_AND_PUNCTUATION","CJK SYMBOLS AND PUNCTUATION","CJKSYMBOLSANDPUNCTUATION")        HIRAGANA=new UnicodeBlock("HIRAGANA")        KATAKANA=new UnicodeBlock("KATAKANA")        BOPOMOFO=new UnicodeBlock("BOPOMOFO")        HANGUL_COMPATIBILITY_JAMO=new UnicodeBlock("HANGUL_COMPATIBILITY_JAMO","HANGUL COMPATIBILITY JAMO","HANGULCOMPATIBILITYJAMO")        KANBUN=new UnicodeBlock("KANBUN")        ENCLOSED_CJK_LETTERS_AND_MONTHS=new UnicodeBlock("ENCLOSED_CJK_LETTERS_AND_MONTHS","ENCLOSED CJK LETTERS AND MONTHS","ENCLOSEDCJKLETTERSANDMONTHS")        CJK_COMPATIBILITY=new UnicodeBlock("CJK_COMPATIBILITY","CJK COMPATIBILITY","CJKCOMPATIBILITY")        CJK_UNIFIED_IDEOGRAPHS=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS","CJK UNIFIED IDEOGRAPHS","CJKUNIFIEDIDEOGRAPHS")        HANGUL_SYLLABLES=new UnicodeBlock("HANGUL_SYLLABLES","HANGUL SYLLABLES","HANGULSYLLABLES")        PRIVATE_USE_AREA=new UnicodeBlock("PRIVATE_USE_AREA","PRIVATE USE AREA","PRIVATEUSEAREA")        CJK_COMPATIBILITY_IDEOGRAPHS=new UnicodeBlock("CJK_COMPATIBILITY_IDEOGRAPHS","CJK COMPATIBILITY IDEOGRAPHS","CJKCOMPATIBILITYIDEOGRAPHS")        ALPHABETIC_PRESENTATION_FORMS=new UnicodeBlock("ALPHABETIC_PRESENTATION_FORMS","ALPHABETIC PRESENTATION FORMS","ALPHABETICPRESENTATIONFORMS")        ARABIC_PRESENTATION_FORMS_A=new UnicodeBlock("ARABIC_PRESENTATION_FORMS_A","ARABIC PRESENTATION FORMS-A","ARABICPRESENTATIONFORMS-A")        COMBINING_HALF_MARKS=new UnicodeBlock("COMBINING_HALF_MARKS","COMBINING HALF MARKS","COMBININGHALFMARKS")        CJK_COMPATIBILITY_FORMS=new UnicodeBlock("CJK_COMPATIBILITY_FORMS","CJK COMPATIBILITY FORMS","CJKCOMPATIBILITYFORMS")        SMALL_FORM_VARIANTS=new UnicodeBlock("SMALL_FORM_VARIANTS","SMALL FORM VARIANTS","SMALLFORMVARIANTS")        ARABIC_PRESENTATION_FORMS_B=new UnicodeBlock("ARABIC_PRESENTATION_FORMS_B","ARABIC PRESENTATION FORMS-B","ARABICPRESENTATIONFORMS-B")        HALFWIDTH_AND_FULLWIDTH_FORMS=new UnicodeBlock("HALFWIDTH_AND_FULLWIDTH_FORMS","HALFWIDTH AND FULLWIDTH FORMS","HALFWIDTHANDFULLWIDTHFORMS")        SPECIALS=new UnicodeBlock("SPECIALS")        SURROGATES_AREA=new UnicodeBlock("SURROGATES_AREA",false)        SYRIAC=new UnicodeBlock("SYRIAC")        THAANA=new UnicodeBlock("THAANA")        SINHALA=new UnicodeBlock("SINHALA")        MYANMAR=new UnicodeBlock("MYANMAR")        ETHIOPIC=new UnicodeBlock("ETHIOPIC")        CHEROKEE=new UnicodeBlock("CHEROKEE")        UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS=new UnicodeBlock("UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS","UNIFIED CANADIAN ABORIGINAL SYLLABICS","UNIFIEDCANADIANABORIGINALSYLLABICS")        OGHAM=new UnicodeBlock("OGHAM")        RUNIC=new UnicodeBlock("RUNIC")        KHMER=new UnicodeBlock("KHMER")        MONGOLIAN=new UnicodeBlock("MONGOLIAN")        BRAILLE_PATTERNS=new UnicodeBlock("BRAILLE_PATTERNS","BRAILLE PATTERNS","BRAILLEPATTERNS")        CJK_RADICALS_SUPPLEMENT=new UnicodeBlock("CJK_RADICALS_SUPPLEMENT","CJK RADICALS SUPPLEMENT","CJKRADICALSSUPPLEMENT")        KANGXI_RADICALS=new UnicodeBlock("KANGXI_RADICALS","KANGXI RADICALS","KANGXIRADICALS")        IDEOGRAPHIC_DESCRIPTION_CHARACTERS=new UnicodeBlock("IDEOGRAPHIC_DESCRIPTION_CHARACTERS","IDEOGRAPHIC DESCRIPTION CHARACTERS","IDEOGRAPHICDESCRIPTIONCHARACTERS")        BOPOMOFO_EXTENDED=new UnicodeBlock("BOPOMOFO_EXTENDED","BOPOMOFO EXTENDED","BOPOMOFOEXTENDED")        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A","CJK UNIFIED IDEOGRAPHS EXTENSION A","CJKUNIFIEDIDEOGRAPHSEXTENSIONA")        YI_SYLLABLES=new UnicodeBlock("YI_SYLLABLES","YI SYLLABLES","YISYLLABLES")        YI_RADICALS=new UnicodeBlock("YI_RADICALS","YI RADICALS","YIRADICALS")        CYRILLIC_SUPPLEMENTARY=new UnicodeBlock("CYRILLIC_SUPPLEMENTARY","CYRILLIC SUPPLEMENTARY","CYRILLICSUPPLEMENTARY","CYRILLIC SUPPLEMENT","CYRILLICSUPPLEMENT")        TAGALOG=new UnicodeBlock("TAGALOG")        HANUNOO=new UnicodeBlock("HANUNOO")        BUHID=new UnicodeBlock("BUHID")        TAGBANWA=new UnicodeBlock("TAGBANWA")        LIMBU=new UnicodeBlock("LIMBU")        TAI_LE=new UnicodeBlock("TAI_LE","TAI LE","TAILE")        KHMER_SYMBOLS=new UnicodeBlock("KHMER_SYMBOLS","KHMER SYMBOLS","KHMERSYMBOLS")        PHONETIC_EXTENSIONS=new UnicodeBlock("PHONETIC_EXTENSIONS","PHONETIC EXTENSIONS","PHONETICEXTENSIONS")        MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A=new UnicodeBlock("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A","MISCELLANEOUS MATHEMATICAL SYMBOLS-A","MISCELLANEOUSMATHEMATICALSYMBOLS-A")        SUPPLEMENTAL_ARROWS_A=new UnicodeBlock("SUPPLEMENTAL_ARROWS_A","SUPPLEMENTAL ARROWS-A","SUPPLEMENTALARROWS-A")        SUPPLEMENTAL_ARROWS_B=new UnicodeBlock("SUPPLEMENTAL_ARROWS_B","SUPPLEMENTAL ARROWS-B","SUPPLEMENTALARROWS-B")        MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B=new UnicodeBlock("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B","MISCELLANEOUS MATHEMATICAL SYMBOLS-B","MISCELLANEOUSMATHEMATICALSYMBOLS-B")        SUPPLEMENTAL_MATHEMATICAL_OPERATORS=new UnicodeBlock("SUPPLEMENTAL_MATHEMATICAL_OPERATORS","SUPPLEMENTAL MATHEMATICAL OPERATORS","SUPPLEMENTALMATHEMATICALOPERATORS")        MISCELLANEOUS_SYMBOLS_AND_ARROWS=new UnicodeBlock("MISCELLANEOUS_SYMBOLS_AND_ARROWS","MISCELLANEOUS SYMBOLS AND ARROWS","MISCELLANEOUSSYMBOLSANDARROWS")        KATAKANA_PHONETIC_EXTENSIONS=new UnicodeBlock("KATAKANA_PHONETIC_EXTENSIONS","KATAKANA PHONETIC EXTENSIONS","KATAKANAPHONETICEXTENSIONS")        YIJING_HEXAGRAM_SYMBOLS=new UnicodeBlock("YIJING_HEXAGRAM_SYMBOLS","YIJING HEXAGRAM SYMBOLS","YIJINGHEXAGRAMSYMBOLS")        VARIATION_SELECTORS=new UnicodeBlock("VARIATION_SELECTORS","VARIATION SELECTORS","VARIATIONSELECTORS")        LINEAR_B_SYLLABARY=new UnicodeBlock("LINEAR_B_SYLLABARY","LINEAR B SYLLABARY","LINEARBSYLLABARY")        LINEAR_B_IDEOGRAMS=new UnicodeBlock("LINEAR_B_IDEOGRAMS","LINEAR B IDEOGRAMS","LINEARBIDEOGRAMS")        AEGEAN_NUMBERS=new UnicodeBlock("AEGEAN_NUMBERS","AEGEAN NUMBERS","AEGEANNUMBERS")        OLD_ITALIC=new UnicodeBlock("OLD_ITALIC","OLD ITALIC","OLDITALIC")        GOTHIC=new UnicodeBlock("GOTHIC")        UGARITIC=new UnicodeBlock("UGARITIC")        DESERET=new UnicodeBlock("DESERET")        SHAVIAN=new UnicodeBlock("SHAVIAN")        OSMANYA=new UnicodeBlock("OSMANYA")        CYPRIOT_SYLLABARY=new UnicodeBlock("CYPRIOT_SYLLABARY","CYPRIOT SYLLABARY","CYPRIOTSYLLABARY")        BYZANTINE_MUSICAL_SYMBOLS=new UnicodeBlock("BYZANTINE_MUSICAL_SYMBOLS","BYZANTINE MUSICAL SYMBOLS","BYZANTINEMUSICALSYMBOLS")        MUSICAL_SYMBOLS=new UnicodeBlock("MUSICAL_SYMBOLS","MUSICAL SYMBOLS","MUSICALSYMBOLS")        TAI_XUAN_JING_SYMBOLS=new UnicodeBlock("TAI_XUAN_JING_SYMBOLS","TAI XUAN JING SYMBOLS","TAIXUANJINGSYMBOLS")        MATHEMATICAL_ALPHANUMERIC_SYMBOLS=new UnicodeBlock("MATHEMATICAL_ALPHANUMERIC_SYMBOLS","MATHEMATICAL ALPHANUMERIC SYMBOLS","MATHEMATICALALPHANUMERICSYMBOLS")        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B","CJK UNIFIED IDEOGRAPHS EXTENSION B","CJKUNIFIEDIDEOGRAPHSEXTENSIONB")        CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT=new UnicodeBlock("CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT","CJK COMPATIBILITY IDEOGRAPHS SUPPLEMENT","CJKCOMPATIBILITYIDEOGRAPHSSUPPLEMENT")        TAGS=new UnicodeBlock("TAGS")        VARIATION_SELECTORS_SUPPLEMENT=new UnicodeBlock("VARIATION_SELECTORS_SUPPLEMENT","VARIATION SELECTORS SUPPLEMENT","VARIATIONSELECTORSSUPPLEMENT")        SUPPLEMENTARY_PRIVATE_USE_AREA_A=new UnicodeBlock("SUPPLEMENTARY_PRIVATE_USE_AREA_A","SUPPLEMENTARY PRIVATE USE AREA-A","SUPPLEMENTARYPRIVATEUSEAREA-A")        SUPPLEMENTARY_PRIVATE_USE_AREA_B=new UnicodeBlock("SUPPLEMENTARY_PRIVATE_USE_AREA_B","SUPPLEMENTARY PRIVATE USE AREA-B","SUPPLEMENTARYPRIVATEUSEAREA-B")        HIGH_SURROGATES=new UnicodeBlock("HIGH_SURROGATES","HIGH SURROGATES","HIGHSURROGATES")        HIGH_PRIVATE_USE_SURROGATES=new UnicodeBlock("HIGH_PRIVATE_USE_SURROGATES","HIGH PRIVATE USE SURROGATES","HIGHPRIVATEUSESURROGATES")        LOW_SURROGATES=new UnicodeBlock("LOW_SURROGATES","LOW SURROGATES","LOWSURROGATES")        ARABIC_SUPPLEMENT=new UnicodeBlock("ARABIC_SUPPLEMENT","ARABIC SUPPLEMENT","ARABICSUPPLEMENT")        NKO=new UnicodeBlock("NKO")        SAMARITAN=new UnicodeBlock("SAMARITAN")        MANDAIC=new UnicodeBlock("MANDAIC")        ETHIOPIC_SUPPLEMENT=new UnicodeBlock("ETHIOPIC_SUPPLEMENT","ETHIOPIC SUPPLEMENT","ETHIOPICSUPPLEMENT")        UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED=new UnicodeBlock("UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED","UNIFIED CANADIAN ABORIGINAL SYLLABICS EXTENDED","UNIFIEDCANADIANABORIGINALSYLLABICSEXTENDED")        NEW_TAI_LUE=new UnicodeBlock("NEW_TAI_LUE","NEW TAI LUE","NEWTAILUE")        BUGINESE=new UnicodeBlock("BUGINESE")        TAI_THAM=new UnicodeBlock("TAI_THAM","TAI THAM","TAITHAM")        BALINESE=new UnicodeBlock("BALINESE")        SUNDANESE=new UnicodeBlock("SUNDANESE")        BATAK=new UnicodeBlock("BATAK")        LEPCHA=new UnicodeBlock("LEPCHA")        OL_CHIKI=new UnicodeBlock("OL_CHIKI","OL CHIKI","OLCHIKI")        VEDIC_EXTENSIONS=new UnicodeBlock("VEDIC_EXTENSIONS","VEDIC EXTENSIONS","VEDICEXTENSIONS")        PHONETIC_EXTENSIONS_SUPPLEMENT=new UnicodeBlock("PHONETIC_EXTENSIONS_SUPPLEMENT","PHONETIC EXTENSIONS SUPPLEMENT","PHONETICEXTENSIONSSUPPLEMENT")        COMBINING_DIACRITICAL_MARKS_SUPPLEMENT=new UnicodeBlock("COMBINING_DIACRITICAL_MARKS_SUPPLEMENT","COMBINING DIACRITICAL MARKS SUPPLEMENT","COMBININGDIACRITICALMARKSSUPPLEMENT")        GLAGOLITIC=new UnicodeBlock("GLAGOLITIC")        LATIN_EXTENDED_C=new UnicodeBlock("LATIN_EXTENDED_C","LATIN EXTENDED-C","LATINEXTENDED-C")        COPTIC=new UnicodeBlock("COPTIC")        GEORGIAN_SUPPLEMENT=new UnicodeBlock("GEORGIAN_SUPPLEMENT","GEORGIAN SUPPLEMENT","GEORGIANSUPPLEMENT")        TIFINAGH=new UnicodeBlock("TIFINAGH")        ETHIOPIC_EXTENDED=new UnicodeBlock("ETHIOPIC_EXTENDED","ETHIOPIC EXTENDED","ETHIOPICEXTENDED")        CYRILLIC_EXTENDED_A=new UnicodeBlock("CYRILLIC_EXTENDED_A","CYRILLIC EXTENDED-A","CYRILLICEXTENDED-A")        SUPPLEMENTAL_PUNCTUATION=new UnicodeBlock("SUPPLEMENTAL_PUNCTUATION","SUPPLEMENTAL PUNCTUATION","SUPPLEMENTALPUNCTUATION")        CJK_STROKES=new UnicodeBlock("CJK_STROKES","CJK STROKES","CJKSTROKES")        LISU=new UnicodeBlock("LISU")        VAI=new UnicodeBlock("VAI")        CYRILLIC_EXTENDED_B=new UnicodeBlock("CYRILLIC_EXTENDED_B","CYRILLIC EXTENDED-B","CYRILLICEXTENDED-B")        BAMUM=new UnicodeBlock("BAMUM")        MODIFIER_TONE_LETTERS=new UnicodeBlock("MODIFIER_TONE_LETTERS","MODIFIER TONE LETTERS","MODIFIERTONELETTERS")        LATIN_EXTENDED_D=new UnicodeBlock("LATIN_EXTENDED_D","LATIN EXTENDED-D","LATINEXTENDED-D")        SYLOTI_NAGRI=new UnicodeBlock("SYLOTI_NAGRI","SYLOTI NAGRI","SYLOTINAGRI")        COMMON_INDIC_NUMBER_FORMS=new UnicodeBlock("COMMON_INDIC_NUMBER_FORMS","COMMON INDIC NUMBER FORMS","COMMONINDICNUMBERFORMS")        PHAGS_PA=new UnicodeBlock("PHAGS_PA","PHAGS-PA")        SAURASHTRA=new UnicodeBlock("SAURASHTRA")        DEVANAGARI_EXTENDED=new UnicodeBlock("DEVANAGARI_EXTENDED","DEVANAGARI EXTENDED","DEVANAGARIEXTENDED")        KAYAH_LI=new UnicodeBlock("KAYAH_LI","KAYAH LI","KAYAHLI")        REJANG=new UnicodeBlock("REJANG")        HANGUL_JAMO_EXTENDED_A=new UnicodeBlock("HANGUL_JAMO_EXTENDED_A","HANGUL JAMO EXTENDED-A","HANGULJAMOEXTENDED-A")        JAVANESE=new UnicodeBlock("JAVANESE")        CHAM=new UnicodeBlock("CHAM")        MYANMAR_EXTENDED_A=new UnicodeBlock("MYANMAR_EXTENDED_A","MYANMAR EXTENDED-A","MYANMAREXTENDED-A")        TAI_VIET=new UnicodeBlock("TAI_VIET","TAI VIET","TAIVIET")        ETHIOPIC_EXTENDED_A=new UnicodeBlock("ETHIOPIC_EXTENDED_A","ETHIOPIC EXTENDED-A","ETHIOPICEXTENDED-A")        MEETEI_MAYEK=new UnicodeBlock("MEETEI_MAYEK","MEETEI MAYEK","MEETEIMAYEK")        HANGUL_JAMO_EXTENDED_B=new UnicodeBlock("HANGUL_JAMO_EXTENDED_B","HANGUL JAMO EXTENDED-B","HANGULJAMOEXTENDED-B")        VERTICAL_FORMS=new UnicodeBlock("VERTICAL_FORMS","VERTICAL FORMS","VERTICALFORMS")        ANCIENT_GREEK_NUMBERS=new UnicodeBlock("ANCIENT_GREEK_NUMBERS","ANCIENT GREEK NUMBERS","ANCIENTGREEKNUMBERS")        ANCIENT_SYMBOLS=new UnicodeBlock("ANCIENT_SYMBOLS","ANCIENT SYMBOLS","ANCIENTSYMBOLS")        PHAISTOS_DISC=new UnicodeBlock("PHAISTOS_DISC","PHAISTOS DISC","PHAISTOSDISC")        LYCIAN=new UnicodeBlock("LYCIAN")        CARIAN=new UnicodeBlock("CARIAN")        OLD_PERSIAN=new UnicodeBlock("OLD_PERSIAN","OLD PERSIAN","OLDPERSIAN")        IMPERIAL_ARAMAIC=new UnicodeBlock("IMPERIAL_ARAMAIC","IMPERIAL ARAMAIC","IMPERIALARAMAIC")        PHOENICIAN=new UnicodeBlock("PHOENICIAN")        LYDIAN=new UnicodeBlock("LYDIAN")        KHAROSHTHI=new UnicodeBlock("KHAROSHTHI")        OLD_SOUTH_ARABIAN=new UnicodeBlock("OLD_SOUTH_ARABIAN","OLD SOUTH ARABIAN","OLDSOUTHARABIAN")        AVESTAN=new UnicodeBlock("AVESTAN")        INSCRIPTIONAL_PARTHIAN=new UnicodeBlock("INSCRIPTIONAL_PARTHIAN","INSCRIPTIONAL PARTHIAN","INSCRIPTIONALPARTHIAN")        INSCRIPTIONAL_PAHLAVI=new UnicodeBlock("INSCRIPTIONAL_PAHLAVI","INSCRIPTIONAL PAHLAVI","INSCRIPTIONALPAHLAVI")        OLD_TURKIC=new UnicodeBlock("OLD_TURKIC","OLD TURKIC","OLDTURKIC")        RUMI_NUMERAL_SYMBOLS=new UnicodeBlock("RUMI_NUMERAL_SYMBOLS","RUMI NUMERAL SYMBOLS","RUMINUMERALSYMBOLS")        BRAHMI=new UnicodeBlock("BRAHMI")        KAITHI=new UnicodeBlock("KAITHI")        CUNEIFORM=new UnicodeBlock("CUNEIFORM")        CUNEIFORM_NUMBERS_AND_PUNCTUATION=new UnicodeBlock("CUNEIFORM_NUMBERS_AND_PUNCTUATION","CUNEIFORM NUMBERS AND PUNCTUATION","CUNEIFORMNUMBERSANDPUNCTUATION")        EGYPTIAN_HIEROGLYPHS=new UnicodeBlock("EGYPTIAN_HIEROGLYPHS","EGYPTIAN HIEROGLYPHS","EGYPTIANHIEROGLYPHS")        BAMUM_SUPPLEMENT=new UnicodeBlock("BAMUM_SUPPLEMENT","BAMUM SUPPLEMENT","BAMUMSUPPLEMENT")        KANA_SUPPLEMENT=new UnicodeBlock("KANA_SUPPLEMENT","KANA SUPPLEMENT","KANASUPPLEMENT")        ANCIENT_GREEK_MUSICAL_NOTATION=new UnicodeBlock("ANCIENT_GREEK_MUSICAL_NOTATION","ANCIENT GREEK MUSICAL NOTATION","ANCIENTGREEKMUSICALNOTATION")        COUNTING_ROD_NUMERALS=new UnicodeBlock("COUNTING_ROD_NUMERALS","COUNTING ROD NUMERALS","COUNTINGRODNUMERALS")        MAHJONG_TILES=new UnicodeBlock("MAHJONG_TILES","MAHJONG TILES","MAHJONGTILES")        DOMINO_TILES=new UnicodeBlock("DOMINO_TILES","DOMINO TILES","DOMINOTILES")        PLAYING_CARDS=new UnicodeBlock("PLAYING_CARDS","PLAYING CARDS","PLAYINGCARDS")        ENCLOSED_ALPHANUMERIC_SUPPLEMENT=new UnicodeBlock("ENCLOSED_ALPHANUMERIC_SUPPLEMENT","ENCLOSED ALPHANUMERIC SUPPLEMENT","ENCLOSEDALPHANUMERICSUPPLEMENT")        ENCLOSED_IDEOGRAPHIC_SUPPLEMENT=new UnicodeBlock("ENCLOSED_IDEOGRAPHIC_SUPPLEMENT","ENCLOSED IDEOGRAPHIC SUPPLEMENT","ENCLOSEDIDEOGRAPHICSUPPLEMENT")        MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS=new UnicodeBlock("MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS","MISCELLANEOUS SYMBOLS AND PICTOGRAPHS","MISCELLANEOUSSYMBOLSANDPICTOGRAPHS")        EMOTICONS=new UnicodeBlock("EMOTICONS")        TRANSPORT_AND_MAP_SYMBOLS=new UnicodeBlock("TRANSPORT_AND_MAP_SYMBOLS","TRANSPORT AND MAP SYMBOLS","TRANSPORTANDMAPSYMBOLS")        ALCHEMICAL_SYMBOLS=new UnicodeBlock("ALCHEMICAL_SYMBOLS","ALCHEMICAL SYMBOLS","ALCHEMICALSYMBOLS")        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C","CJK UNIFIED IDEOGRAPHS EXTENSION C","CJKUNIFIEDIDEOGRAPHSEXTENSIONC")        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D","CJK UNIFIED IDEOGRAPHS EXTENSION D","CJKUNIFIEDIDEOGRAPHSEXTENSIOND")        ARABIC_EXTENDED_A=new UnicodeBlock("ARABIC_EXTENDED_A","ARABIC EXTENDED-A","ARABICEXTENDED-A")        SUNDANESE_SUPPLEMENT=new UnicodeBlock("SUNDANESE_SUPPLEMENT","SUNDANESE SUPPLEMENT","SUNDANESESUPPLEMENT")        MEETEI_MAYEK_EXTENSIONS=new UnicodeBlock("MEETEI_MAYEK_EXTENSIONS","MEETEI MAYEK EXTENSIONS","MEETEIMAYEKEXTENSIONS")        MEROITIC_HIEROGLYPHS=new UnicodeBlock("MEROITIC_HIEROGLYPHS","MEROITIC HIEROGLYPHS","MEROITICHIEROGLYPHS")        MEROITIC_CURSIVE=new UnicodeBlock("MEROITIC_CURSIVE","MEROITIC CURSIVE","MEROITICCURSIVE")        SORA_SOMPENG=new UnicodeBlock("SORA_SOMPENG","SORA SOMPENG","SORASOMPENG")        CHAKMA=new UnicodeBlock("CHAKMA")        SHARADA=new UnicodeBlock("SHARADA")        TAKRI=new UnicodeBlock("TAKRI")        MIAO=new UnicodeBlock("MIAO")        ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS=new UnicodeBlock("ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS","ARABIC MATHEMATICAL ALPHABETIC SYMBOLS","ARABICMATHEMATICALALPHABETICSYMBOLS")        blockStarts=[]        blocks=
+      Instance Initializer: 
+      Constructors: 
+        constructor  UnicodeBlock(idName)  throws: 
+        constructor  UnicodeBlock(idName,isMap)  throws: 
+          cond-branch cond:isMap
+          true branch :
+            map.put(idName,this)
+          false branch :
+
+        constructor  UnicodeBlock(idName,alias)  throws: 
+          map.put(alias,this)
+        constructor  UnicodeBlock(idName,aliases)  throws: 
+          String
+          alias
+          aliases
+          map.put(alias,this)
+      Methods: 
+        func  of(c)  throws: 
+          return of((int)c)
+        func  of(codePoint)  throws: 
+          cond-branch cond:isValidCodePoint(codePoint)
+          true branch :
+            new IllegalArgumentException()
+          false branch :
+
+          Decl: top,bottom,current
+          bottom Assign 0
+          top Assign blockStarts.length
+          current Assign top Div 2
+          while top Sub bottom GT 1            cond-branch cond:codePoint GE 
+            true branch :
+              bottom Assign current
+            false branch :
+              top Assign current
+
+            current Assign (top Add bottom) Div 2
+
+          return 
+      LocalClasses: 
+      LocalInterfaces: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/openjdk/Character-2.java b/src/MapleFE/test/java/openjdk/Character-2.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Character-2.java
rename to src/MapleFE/test/java/openjdk/Character-2.java
diff --git a/src/MapleFE/test/openjdk/Character-2.java.result b/src/MapleFE/test/java/openjdk/Character-2.java.result
similarity index 77%
rename from src/MapleFE/test/openjdk/Character-2.java.result
rename to src/MapleFE/test/java/openjdk/Character-2.java.result
index 3dba7f116e0ccd4f8eac2e8ff074b1fc0010531c..57633d3b59ff2a36d79c9557e9d32cf09d0b6aff 100644
Binary files a/src/MapleFE/test/openjdk/Character-2.java.result and b/src/MapleFE/test/java/openjdk/Character-2.java.result differ
diff --git a/src/MapleFE/test/openjdk/Character-3.java b/src/MapleFE/test/java/openjdk/Character-3.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Character-3.java
rename to src/MapleFE/test/java/openjdk/Character-3.java
diff --git a/src/MapleFE/test/openjdk/Character-3.java.result b/src/MapleFE/test/java/openjdk/Character-3.java.result
similarity index 96%
rename from src/MapleFE/test/openjdk/Character-3.java.result
rename to src/MapleFE/test/java/openjdk/Character-3.java.result
index 5e7b55c8cfbffe30ecb9973faf6c0c2d1ff48e86..96e1415cc94ad9c912b3a7ff8d4185b15f7e08d1 100644
--- a/src/MapleFE/test/openjdk/Character-3.java.result
+++ b/src/MapleFE/test/java/openjdk/Character-3.java.result
@@ -7,7 +7,7 @@ class  Character
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  isWhitespace()  throws: 
+    func  isWhitespace(codePoint)  throws: 
       cond-branch cond:(codePoint GE 28 Land codePoint LE 32) Lor (codePoint GE 9 Land codePoint LE 13)
       true branch :
         return true
diff --git a/src/MapleFE/test/openjdk/Character.java b/src/MapleFE/test/java/openjdk/Character.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Character.java
rename to src/MapleFE/test/java/openjdk/Character.java
diff --git a/src/MapleFE/test/openjdk/Character.java.result b/src/MapleFE/test/java/openjdk/Character.java.result
similarity index 30%
rename from src/MapleFE/test/openjdk/Character.java.result
rename to src/MapleFE/test/java/openjdk/Character.java.result
index f074c02b6c61834e1a3f55ab5542329269e33d9a..3ab414e2dfa0b84f28a4e026a1d301519307fc0f 100644
--- a/src/MapleFE/test/openjdk/Character.java.result
+++ b/src/MapleFE/test/java/openjdk/Character.java.result
@@ -4,7 +4,7 @@ Matched 21 tokens.
 Matched 28 tokens.
 Matched 35 tokens.
 Matched 42 tokens.
-Matched 11999 tokens.
+Matched 11996 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
@@ -21,63 +21,61 @@ import java.util.Map
 == Sub Tree ==
 class  Character
   Fields: 
-    MIN_RADIX=2    MAX_RADIX=36    MIN_VALUE=0    MAX_VALUE=65535    TYPE=()    UNASSIGNED=0    UPPERCASE_LETTER=1    LOWERCASE_LETTER=2    TITLECASE_LETTER=3    MODIFIER_LETTER=4    OTHER_LETTER=5    NON_SPACING_MARK=6    ENCLOSING_MARK=7    COMBINING_SPACING_MARK=8    DECIMAL_DIGIT_NUMBER=9    LETTER_NUMBER=10    OTHER_NUMBER=11    SPACE_SEPARATOR=12    LINE_SEPARATOR=13    PARAGRAPH_SEPARATOR=14    CONTROL=15    FORMAT=16    PRIVATE_USE=18    SURROGATE=19    DASH_PUNCTUATION=20    START_PUNCTUATION=21    END_PUNCTUATION=22    CONNECTOR_PUNCTUATION=23    OTHER_PUNCTUATION=24    MATH_SYMBOL=25    CURRENCY_SYMBOL=26    MODIFIER_SYMBOL=27    OTHER_SYMBOL=28    INITIAL_QUOTE_PUNCTUATION=29    FINAL_QUOTE_PUNCTUATION=30    ERROR=-1    DIRECTIONALITY_UNDEFINED=Sub
-  1    DIRECTIONALITY_LEFT_TO_RIGHT=0    DIRECTIONALITY_RIGHT_TO_LEFT=1    DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC=2    DIRECTIONALITY_EUROPEAN_NUMBER=3    DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR=4    DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR=5    DIRECTIONALITY_ARABIC_NUMBER=6    DIRECTIONALITY_COMMON_NUMBER_SEPARATOR=7    DIRECTIONALITY_NONSPACING_MARK=8    DIRECTIONALITY_BOUNDARY_NEUTRAL=9    DIRECTIONALITY_PARAGRAPH_SEPARATOR=10    DIRECTIONALITY_SEGMENT_SEPARATOR=11    DIRECTIONALITY_WHITESPACE=12    DIRECTIONALITY_OTHER_NEUTRALS=13    DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING=14    DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE=15    DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING=16    DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE=17    DIRECTIONALITY_POP_DIRECTIONAL_FORMAT=18    MIN_HIGH_SURROGATE=55296    MAX_HIGH_SURROGATE=56319    MIN_LOW_SURROGATE=56320    MAX_LOW_SURROGATE=57343    MIN_SURROGATE=MIN_HIGH_SURROGATE    MAX_SURROGATE=MAX_LOW_SURROGATE    MIN_SUPPLEMENTARY_CODE_POINT=65536    MIN_CODE_POINT=0    MAX_CODE_POINT=1114111    DIRECTIONALITY=    value    serialVersionUID=1796875896    SIZE=16    BYTES=
+    MIN_RADIX=2    MAX_RADIX=36    MIN_VALUE=0    MAX_VALUE=65535    TYPE=()char.getComponentType()    UNASSIGNED=0    UPPERCASE_LETTER=1    LOWERCASE_LETTER=2    TITLECASE_LETTER=3    MODIFIER_LETTER=4    OTHER_LETTER=5    NON_SPACING_MARK=6    ENCLOSING_MARK=7    COMBINING_SPACING_MARK=8    DECIMAL_DIGIT_NUMBER=9    LETTER_NUMBER=10    OTHER_NUMBER=11    SPACE_SEPARATOR=12    LINE_SEPARATOR=13    PARAGRAPH_SEPARATOR=14    CONTROL=15    FORMAT=16    PRIVATE_USE=18    SURROGATE=19    DASH_PUNCTUATION=20    START_PUNCTUATION=21    END_PUNCTUATION=22    CONNECTOR_PUNCTUATION=23    OTHER_PUNCTUATION=24    MATH_SYMBOL=25    CURRENCY_SYMBOL=26    MODIFIER_SYMBOL=27    OTHER_SYMBOL=28    INITIAL_QUOTE_PUNCTUATION=29    FINAL_QUOTE_PUNCTUATION=30    ERROR=-1    DIRECTIONALITY_UNDEFINED=-1    DIRECTIONALITY_LEFT_TO_RIGHT=0    DIRECTIONALITY_RIGHT_TO_LEFT=1    DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC=2    DIRECTIONALITY_EUROPEAN_NUMBER=3    DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR=4    DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR=5    DIRECTIONALITY_ARABIC_NUMBER=6    DIRECTIONALITY_COMMON_NUMBER_SEPARATOR=7    DIRECTIONALITY_NONSPACING_MARK=8    DIRECTIONALITY_BOUNDARY_NEUTRAL=9    DIRECTIONALITY_PARAGRAPH_SEPARATOR=10    DIRECTIONALITY_SEGMENT_SEPARATOR=11    DIRECTIONALITY_WHITESPACE=12    DIRECTIONALITY_OTHER_NEUTRALS=13    DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING=14    DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE=15    DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING=16    DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE=17    DIRECTIONALITY_POP_DIRECTIONAL_FORMAT=18    MIN_HIGH_SURROGATE=55296    MAX_HIGH_SURROGATE=56319    MIN_LOW_SURROGATE=56320    MAX_LOW_SURROGATE=57343    MIN_SURROGATE=MIN_HIGH_SURROGATE    MAX_SURROGATE=MAX_LOW_SURROGATE    MIN_SUPPLEMENTARY_CODE_POINT=65536    MIN_CODE_POINT=0    MAX_CODE_POINT=1114111    DIRECTIONALITY=    value    serialVersionUID=1796875896    SIZE=16    BYTES=SIZE Div Byte.SIZE
   Instance Initializer: 
   Constructors: 
-    constructor  Character()  throws: 
+    constructor  Character(value)  throws: 
       this.value Assign value
   Methods: 
-    func  valueOf()  throws: 
+    func  valueOf(c)  throws: 
       cond-branch cond:c LE 127
       true branch :
         return 
       false branch :
 
-      return new Character<Character>
+      return new Character(c)
     func  charValue()  throws: 
       return value
     func  hashCode()  throws: 
       return Character.hashCode(value)
-    func  hashCode()  throws: 
+    func  hashCode(value)  throws: 
       return (int)value
-    func  equals()  throws: 
-      cond-branch cond:
+    func  equals(obj)  throws: 
+      cond-branch cond:obj instanceof Character
       true branch :
-        return value EQ ((Character)obj)charValue
+        return value EQ (Character)obj.charValue()
       false branch :
 
       return false
     func  toString()  throws: 
-      var:buf=value[]
+      Decl: buf=value[]
       return String.valueOf(buf)
-    func  toString()  throws: 
+    func  toString(c)  throws: 
       return String.valueOf(c)
-    func  isValidCodePoint()  throws: 
-      var:plane=codePoint Zext 16
+    func  isValidCodePoint(codePoint)  throws: 
+      Decl: plane=codePoint Zext 16
       return plane LT ((MAX_CODE_POINT Add 1) Zext 16)
-    func  isBmpCodePoint()  throws: 
+    func  isBmpCodePoint(codePoint)  throws: 
       return codePoint Zext 16 EQ 0
-    func  isSupplementaryCodePoint()  throws: 
+    func  isSupplementaryCodePoint(codePoint)  throws: 
       return codePoint GE MIN_SUPPLEMENTARY_CODE_POINT Land codePoint LT MAX_CODE_POINT Add 1
-    func  isHighSurrogate()  throws: 
+    func  isHighSurrogate(ch)  throws: 
       return ch GE MIN_HIGH_SURROGATE Land ch LT (MAX_HIGH_SURROGATE Add 1)
-    func  isLowSurrogate()  throws: 
+    func  isLowSurrogate(ch)  throws: 
       return ch GE MIN_LOW_SURROGATE Land ch LT (MAX_LOW_SURROGATE Add 1)
-    func  isSurrogate()  throws: 
+    func  isSurrogate(ch)  throws: 
       return ch GE MIN_SURROGATE Land ch LT (MAX_SURROGATE Add 1)
-    func  isSurrogatePair()  throws: 
+    func  isSurrogatePair(high,low)  throws: 
       return isHighSurrogate(high) Land isLowSurrogate(low)
-    func  charCount()  throws: 
+    func  charCount(codePoint)  throws: 
       return 
-    func  toCodePoint()  throws: 
+    func  toCodePoint(high,low)  throws: 
       return ((high Shl 10) Add low) Add (MIN_SUPPLEMENTARY_CODE_POINT Sub (MIN_HIGH_SURROGATE Shl 10) Sub MIN_LOW_SURROGATE)
-    func  codePointAt()  throws: 
-      var:c1=seq.charAt(index)
-      cond-branch cond:isHighSurrogate(c1) Land Inc
-  index LT seq.length()
+    func  codePointAt(seq,index)  throws: 
+      Decl: c1=seq.charAt(index)
+      cond-branch cond:isHighSurrogate(c1) Land PreInc index LT seq.length()
       true branch :
-        var:c2=seq.charAt(index)
+        Decl: c2=seq.charAt(index)
         cond-branch cond:isLowSurrogate(c2)
         true branch :
           return toCodePoint(c1,c2)
@@ -86,21 +84,20 @@ class  Character
       false branch :
 
       return c1
-    func  codePointAt()  throws: 
+    func  codePointAt(a,index)  throws: 
       return codePointAtImpl(a,index,a.length)
-    func  codePointAt()  throws: 
+    func  codePointAt(a,index,limit)  throws: 
       cond-branch cond:index GE limit Lor limit LT 0 Lor limit GT a.length
       true branch :
-        new IndexOutOfBoundsException<IndexOutOfBoundsException>
+        new IndexOutOfBoundsException()
       false branch :
 
       return codePointAtImpl(a,index,limit)
-    func  codePointAtImpl()  throws: 
-      var:c1=
-      cond-branch cond:isHighSurrogate(c1) Land Inc
-  index LT limit
+    func  codePointAtImpl(a,index,limit)  throws: 
+      Decl: c1=
+      cond-branch cond:isHighSurrogate(c1) Land PreInc index LT limit
       true branch :
-        var:c2=
+        Decl: c2=
         cond-branch cond:isLowSurrogate(c2)
         true branch :
           return toCodePoint(c1,c2)
@@ -109,13 +106,11 @@ class  Character
       false branch :
 
       return c1
-    func  codePointBefore()  throws: 
-      var:c2=seq.charAt(Dec
-  index)
+    func  codePointBefore(seq,index)  throws: 
+      Decl: c2=seq.charAt(PreDec index)
       cond-branch cond:isLowSurrogate(c2) Land index GT 0
       true branch :
-        var:c1=seq.charAt(Dec
-  index)
+        Decl: c1=seq.charAt(PreDec index)
         cond-branch cond:isHighSurrogate(c1)
         true branch :
           return toCodePoint(c1,c2)
@@ -124,20 +119,20 @@ class  Character
       false branch :
 
       return c2
-    func  codePointBefore()  throws: 
+    func  codePointBefore(a,index)  throws: 
       return codePointBeforeImpl(a,index,0)
-    func  codePointBefore()  throws: 
+    func  codePointBefore(a,index,start)  throws: 
       cond-branch cond:index LE start Lor start LT 0 Lor start GE a.length
       true branch :
-        new IndexOutOfBoundsException<IndexOutOfBoundsException>
+        new IndexOutOfBoundsException()
       false branch :
 
       return codePointBeforeImpl(a,index,start)
-    func  codePointBeforeImpl()  throws: 
-      var:c2=
+    func  codePointBeforeImpl(a,index,start)  throws: 
+      Decl: c2=
       cond-branch cond:isLowSurrogate(c2) Land index GT start
       true branch :
-        var:c1=
+        Decl: c1=
         cond-branch cond:isHighSurrogate(c1)
         true branch :
           return toCodePoint(c1,c2)
@@ -146,11 +141,11 @@ class  Character
       false branch :
 
       return c2
-    func  highSurrogate()  throws: 
+    func  highSurrogate(codePoint)  throws: 
       return (char)((codePoint Zext 10) Add (MIN_HIGH_SURROGATE Sub (MIN_SUPPLEMENTARY_CODE_POINT Zext 10)))
-    func  lowSurrogate()  throws: 
+    func  lowSurrogate(codePoint)  throws: 
       return (char)((codePoint Band 1023) Add MIN_LOW_SURROGATE)
-    func  toChars()  throws: 
+    func  toChars(codePoint,dst,dstIndex)  throws: 
       cond-branch cond:isBmpCodePoint(codePoint)
       true branch :
          Assign (char)codePoint
@@ -161,150 +156,200 @@ class  Character
           toSurrogates(codePoint,dst,dstIndex)
           return 2
         false branch :
-          new IllegalArgumentException<IllegalArgumentException>
+          new IllegalArgumentException()
 
-
-    func  toChars()  throws: 
+    func  toChars(codePoint)  throws: 
       cond-branch cond:isBmpCodePoint(codePoint)
       true branch :
         return 
       false branch :
         cond-branch cond:isValidCodePoint(codePoint)
         true branch :
-          var:result=
-
+          Decl: result=
+          toSurrogates(codePoint,result,0)
+          return result
         false branch :
-          new IllegalArgumentException<IllegalArgumentException>
+          new IllegalArgumentException()
 
-
-    func  toSurrogates()  throws: 
+    func  toSurrogates(codePoint,dst,index)  throws: 
        Assign lowSurrogate(codePoint)
        Assign highSurrogate(codePoint)
-    func  codePointCount()  throws: 
-      var:length=seq.length()
+    func  codePointCount(seq,beginIndex,endIndex)  throws: 
+      Decl: length=seq.length()
       cond-branch cond:beginIndex LT 0 Lor endIndex GT length Lor beginIndex GT endIndex
       true branch :
-        new IndexOutOfBoundsException<IndexOutOfBoundsException>
+        new IndexOutOfBoundsException()
       false branch :
 
-      var:n=endIndex Sub beginIndex
+      Decl: n=endIndex Sub beginIndex
       for ( )
-        cond-branch cond:isHighSurrogate(seq.charAt(  iInc
+        cond-branch cond:isHighSurrogate(seq.charAt(i Inc
 )) Land i LT endIndex Land isLowSurrogate(seq.charAt(i))
         true branch :
-                      nDec
+          n Dec
 
-                      iInc
+          i Inc
 
         false branch :
 
 
       return n
-    func  codePointCount()  throws: 
+    func  codePointCount(a,offset,count)  throws: 
       cond-branch cond:count GT a.length Sub offset Lor offset LT 0 Lor count LT 0
       true branch :
-        new IndexOutOfBoundsException<IndexOutOfBoundsException>
+        new IndexOutOfBoundsException()
       false branch :
 
       return codePointCountImpl(a,offset,count)
-    func  codePointCountImpl()  throws: 
-      var:endIndex=offset Add count
-      var:n=count
+    func  codePointCountImpl(a,offset,count)  throws: 
+      Decl: endIndex=offset Add count
+      Decl: n=count
       for ( )
-        cond-branch cond:isHighSurrogate(a,  iInc
+        cond-branch cond:isHighSurrogate(a,i Inc
 ) Land i LT endIndex Land isLowSurrogate(a,i)
         true branch :
-                      nDec
+          n Dec
 
-                      iInc
+          i Inc
 
         false branch :
 
 
       return n
-    func  offsetByCodePoints()  throws: 
-      var:length=seq.length()
+    func  offsetByCodePoints(seq,index,codePointOffset)  throws: 
+      Decl: length=seq.length()
       cond-branch cond:index LT 0 Lor index GT length
       true branch :
-        new IndexOutOfBoundsException<IndexOutOfBoundsException>
+        new IndexOutOfBoundsException()
       false branch :
 
-      var:x=index
+      Decl: x=index
       cond-branch cond:codePointOffset GE 0
       true branch :
-        var:i
+        Decl: i
+        for ( )
+          cond-branch cond:isHighSurrogate(seq.charAt(x Inc
+)) Land x LT length Land isLowSurrogate(seq.charAt(x))
+          true branch :
+            x Inc
+
+          false branch :
+
+
+        cond-branch cond:i LT codePointOffset
+        true branch :
+          new IndexOutOfBoundsException()
+        false branch :
 
       false branch :
-        var:i
+        Decl: i
+        for ( )
+          cond-branch cond:isLowSurrogate(seq.charAt(PreDec x)) Land x GT 0 Land isHighSurrogate(seq.charAt(x Sub 1))
+          true branch :
+            x Dec
+
+          false branch :
+
+
+        cond-branch cond:i LT 0
+        true branch :
+          new IndexOutOfBoundsException()
+        false branch :
 
 
       return x
-    func  offsetByCodePoints()  throws: 
+    func  offsetByCodePoints(a,start,count,index,codePointOffset)  throws: 
       cond-branch cond:count GT a.length Sub start Lor start LT 0 Lor count LT 0 Lor index LT start Lor index GT start Add count
       true branch :
-        new IndexOutOfBoundsException<IndexOutOfBoundsException>
+        new IndexOutOfBoundsException()
       false branch :
 
       return offsetByCodePointsImpl(a,start,count,index,codePointOffset)
-    func  offsetByCodePointsImpl()  throws: 
-      var:x=index
+    func  offsetByCodePointsImpl(a,start,count,index,codePointOffset)  throws: 
+      Decl: x=index
       cond-branch cond:codePointOffset GE 0
       true branch :
-        var:limit=start Add count
+        Decl: limit=start Add count
+        Decl: i
+        for ( )
+          cond-branch cond:isHighSurrogate(a,x Inc
+) Land x LT limit Land isLowSurrogate(a,x)
+          true branch :
+            x Inc
+
+          false branch :
+
+
+        cond-branch cond:i LT codePointOffset
+        true branch :
+          new IndexOutOfBoundsException()
+        false branch :
 
       false branch :
-        var:i
+        Decl: i
+        for ( )
+          cond-branch cond:isLowSurrogate(a,PreDec x) Land x GT start Land isHighSurrogate(a,x Sub 1)
+          true branch :
+            x Dec
+
+          false branch :
+
+
+        cond-branch cond:i LT 0
+        true branch :
+          new IndexOutOfBoundsException()
+        false branch :
 
 
       return x
-    func  isLowerCase()  throws: 
+    func  isLowerCase(ch)  throws: 
       return isLowerCase((int)ch)
-    func  isLowerCase()  throws: 
+    func  isLowerCase(codePoint)  throws: 
       return isLowerCaseImpl(codePoint)
-    func  isLowerCaseImpl()  throws: 
-    func  isUpperCase()  throws: 
+    func  isLowerCaseImpl(codePoint)  throws: 
+    func  isUpperCase(ch)  throws: 
       return isUpperCase((int)ch)
-    func  isUpperCase()  throws: 
+    func  isUpperCase(codePoint)  throws: 
       return isUpperCaseImpl(codePoint)
-    func  isUpperCaseImpl()  throws: 
-    func  isTitleCase()  throws: 
+    func  isUpperCaseImpl(codePoint)  throws: 
+    func  isTitleCase(ch)  throws: 
       return isTitleCase((int)ch)
-    func  isTitleCase()  throws: 
+    func  isTitleCase(codePoint)  throws: 
       return isTitleCaseImpl(codePoint)
-    func  isTitleCaseImpl()  throws: 
-    func  isDigit()  throws: 
+    func  isTitleCaseImpl(codePoint)  throws: 
+    func  isDigit(ch)  throws: 
       return isDigit((int)ch)
-    func  isDigit()  throws: 
+    func  isDigit(codePoint)  throws: 
       return isDigitImpl(codePoint)
-    func  isDigitImpl()  throws: 
-    func  isDefined()  throws: 
+    func  isDigitImpl(codePoint)  throws: 
+    func  isDefined(ch)  throws: 
       return isDefined((int)ch)
-    func  isDefined()  throws: 
+    func  isDefined(codePoint)  throws: 
       return isDefinedImpl(codePoint)
-    func  isDefinedImpl()  throws: 
-    func  isLetter()  throws: 
+    func  isDefinedImpl(codePoint)  throws: 
+    func  isLetter(ch)  throws: 
       return isLetter((int)ch)
-    func  isLetter()  throws: 
+    func  isLetter(codePoint)  throws: 
       return isLetterImpl(codePoint)
-    func  isLetterImpl()  throws: 
-    func  isLetterOrDigit()  throws: 
+    func  isLetterImpl(codePoint)  throws: 
+    func  isLetterOrDigit(ch)  throws: 
       return isLetterOrDigit((int)ch)
-    func  isLetterOrDigit()  throws: 
+    func  isLetterOrDigit(codePoint)  throws: 
       return isLetterOrDigitImpl(codePoint)
-    func  isLetterOrDigitImpl()  throws: 
-    func  isJavaLetter()  throws: 
+    func  isLetterOrDigitImpl(codePoint)  throws: 
+    func  isJavaLetter(ch)  throws: 
       return isJavaIdentifierStart(ch)
-    func  isJavaLetterOrDigit()  throws: 
+    func  isJavaLetterOrDigit(ch)  throws: 
       return isJavaIdentifierPart(ch)
-    func  isAlphabetic()  throws: 
+    func  isAlphabetic(codePoint)  throws: 
       return isAlphabeticImpl(codePoint)
-    func  isAlphabeticImpl()  throws: 
-    func  isIdeographic()  throws: 
+    func  isAlphabeticImpl(codePoint)  throws: 
+    func  isIdeographic(codePoint)  throws: 
       return isIdeographicImpl(codePoint)
-    func  isIdeographicImpl()  throws: 
-    func  isJavaIdentifierStart()  throws: 
+    func  isIdeographicImpl(codePoint)  throws: 
+    func  isJavaIdentifierStart(ch)  throws: 
       return isJavaIdentifierStart((int)ch)
-    func  isJavaIdentifierStart()  throws: 
+    func  isJavaIdentifierStart(codePoint)  throws: 
       cond-branch cond:codePoint LT 64
       true branch :
         return (codePoint EQ $)
@@ -314,11 +359,10 @@ class  Character
           return (2147483630 Band (1 Shl (codePoint Sub 64))) NE 0
         false branch :
 
-
       return ((1 Shl getType(codePoint)) Band ((1 Shl UPPERCASE_LETTER) Bor (1 Shl LOWERCASE_LETTER) Bor (1 Shl TITLECASE_LETTER) Bor (1 Shl MODIFIER_LETTER) Bor (1 Shl OTHER_LETTER) Bor (1 Shl CURRENCY_SYMBOL) Bor (1 Shl CONNECTOR_PUNCTUATION) Bor (1 Shl LETTER_NUMBER))) NE 0
-    func  isJavaIdentifierPart()  throws: 
+    func  isJavaIdentifierPart(ch)  throws: 
       return isJavaIdentifierPart((int)ch)
-    func  isJavaIdentifierPart()  throws: 
+    func  isJavaIdentifierPart(codePoint)  throws: 
       cond-branch cond:codePoint LT 64
       true branch :
         return (-253953 Band (1 Shl codePoint)) NE 0
@@ -328,26 +372,25 @@ class  Character
           return (2147483630 Band (1 Shl (codePoint Sub 64))) NE 0
         false branch :
 
-
       return ((1 Shl getType(codePoint)) Band ((1 Shl UPPERCASE_LETTER) Bor (1 Shl LOWERCASE_LETTER) Bor (1 Shl TITLECASE_LETTER) Bor (1 Shl MODIFIER_LETTER) Bor (1 Shl OTHER_LETTER) Bor (1 Shl CURRENCY_SYMBOL) Bor (1 Shl CONNECTOR_PUNCTUATION) Bor (1 Shl DECIMAL_DIGIT_NUMBER) Bor (1 Shl LETTER_NUMBER) Bor (1 Shl FORMAT) Bor (1 Shl COMBINING_SPACING_MARK) Bor (1 Shl NON_SPACING_MARK))) NE 0 Lor (codePoint GE 0 Land codePoint LE 8) Lor (codePoint GE 14 Land codePoint LE 27) Lor (codePoint GE 127 Land codePoint LE 159)
-    func  isUnicodeIdentifierStart()  throws: 
+    func  isUnicodeIdentifierStart(ch)  throws: 
       return isUnicodeIdentifierStart((int)ch)
-    func  isUnicodeIdentifierStart()  throws: 
+    func  isUnicodeIdentifierStart(codePoint)  throws: 
       return isUnicodeIdentifierStartImpl(codePoint)
-    func  isUnicodeIdentifierStartImpl()  throws: 
-    func  isUnicodeIdentifierPart()  throws: 
+    func  isUnicodeIdentifierStartImpl(codePoint)  throws: 
+    func  isUnicodeIdentifierPart(ch)  throws: 
       return isUnicodeIdentifierPart((int)ch)
-    func  isUnicodeIdentifierPart()  throws: 
+    func  isUnicodeIdentifierPart(codePoint)  throws: 
       return isUnicodeIdentifierPartImpl(codePoint)
-    func  isUnicodeIdentifierPartImpl()  throws: 
-    func  isIdentifierIgnorable()  throws: 
+    func  isUnicodeIdentifierPartImpl(codePoint)  throws: 
+    func  isIdentifierIgnorable(ch)  throws: 
       return isIdentifierIgnorable((int)ch)
-    func  isIdentifierIgnorable()  throws: 
+    func  isIdentifierIgnorable(codePoint)  throws: 
       return isIdentifierIgnorableImpl(codePoint)
-    func  isIdentifierIgnorableImpl()  throws: 
-    func  toLowerCase()  throws: 
+    func  isIdentifierIgnorableImpl(codePoint)  throws: 
+    func  toLowerCase(ch)  throws: 
       return (char)toLowerCase((int)ch)
-    func  toLowerCase()  throws: 
+    func  toLowerCase(codePoint)  throws: 
       cond-branch cond:codePoint GE A Land codePoint LE Z
       true branch :
         return codePoint Add (a Sub A)
@@ -359,10 +402,10 @@ class  Character
       false branch :
 
       return toLowerCaseImpl(codePoint)
-    func  toLowerCaseImpl()  throws: 
-    func  toUpperCase()  throws: 
+    func  toLowerCaseImpl(codePoint)  throws: 
+    func  toUpperCase(ch)  throws: 
       return (char)toUpperCase((int)ch)
-    func  toUpperCase()  throws: 
+    func  toUpperCase(codePoint)  throws: 
       cond-branch cond:codePoint GE a Land codePoint LE z
       true branch :
         return codePoint Sub (a Sub A)
@@ -374,33 +417,44 @@ class  Character
       false branch :
 
       return toUpperCaseImpl(codePoint)
-    func  toUpperCaseImpl()  throws: 
-    func  toTitleCase()  throws: 
+    func  toUpperCaseImpl(codePoint)  throws: 
+    func  toTitleCase(ch)  throws: 
       return (char)toTitleCase((int)ch)
-    func  toTitleCase()  throws: 
+    func  toTitleCase(codePoint)  throws: 
       return toTitleCaseImpl(codePoint)
-    func  toTitleCaseImpl()  throws: 
-    func  digit()  throws: 
+    func  toTitleCaseImpl(codePoint)  throws: 
+    func  digit(ch,radix)  throws: 
       return digit((int)ch,radix)
-    func  digit()  throws: 
+    func  digit(codePoint,radix)  throws: 
       cond-branch cond:radix LT MIN_RADIX Lor radix GT MAX_RADIX
       true branch :
-        return Sub
-  1
+        return -1
       false branch :
 
       cond-branch cond:codePoint LT 128
       true branch :
-        var:result=Sub
-  1
+        Decl: result=-1
+        cond-branch cond:0 LE codePoint Land codePoint LE 9
+        true branch :
+          result Assign codePoint Sub 0
+        false branch :
+          cond-branch cond:a LE codePoint Land codePoint LE z
+          true branch :
+            result Assign 10 Add (codePoint Sub a)
+          false branch :
+            cond-branch cond:A LE codePoint Land codePoint LE Z
+            true branch :
+              result Assign 10 Add (codePoint Sub A)
+            false branch :
 
+        return 
       false branch :
 
       return digitImpl(codePoint,radix)
-    func  digitImpl()  throws: 
-    func  getNumericValue()  throws: 
+    func  digitImpl(codePoint,radix)  throws: 
+    func  getNumericValue(ch)  throws: 
       return getNumericValue((int)ch)
-    func  getNumericValue()  throws: 
+    func  getNumericValue(codePoint)  throws: 
       cond-branch cond:codePoint LT 128
       true branch :
         cond-branch cond:codePoint GE 0 Land codePoint LE 9
@@ -408,7 +462,17 @@ class  Character
           return codePoint Sub 0
         false branch :
 
+        cond-branch cond:codePoint GE a Land codePoint LE z
+        true branch :
+          return codePoint Sub (a Sub 10)
+        false branch :
 
+        cond-branch cond:codePoint GE A Land codePoint LE Z
+        true branch :
+          return codePoint Sub (A Sub 10)
+        false branch :
+
+        return -1
       false branch :
 
       cond-branch cond:codePoint GE 65313 Land codePoint LE 65338
@@ -422,12 +486,12 @@ class  Character
       false branch :
 
       return getNumericValueImpl(codePoint)
-    func  getNumericValueImpl()  throws: 
-    func  isSpace()  throws: 
+    func  getNumericValueImpl(codePoint)  throws: 
+    func  isSpace(ch)  throws: 
       return (ch LE 32) Land (((((1 Shl 9) Bor (1 Shl 10) Bor (1 Shl 12) Bor (1 Shl 13) Bor (1 Shl 32)) Shr ch) Band 1) NE 0)
-    func  isSpaceChar()  throws: 
+    func  isSpaceChar(ch)  throws: 
       return isSpaceChar((int)ch)
-    func  isSpaceChar()  throws: 
+    func  isSpaceChar(codePoint)  throws: 
       cond-branch cond:codePoint EQ 32 Lor codePoint EQ 160
       true branch :
         return true
@@ -454,10 +518,10 @@ class  Character
       false branch :
 
       return isSpaceCharImpl(codePoint)
-    func  isSpaceCharImpl()  throws: 
-    func  isWhitespace()  throws: 
+    func  isSpaceCharImpl(codePoint)  throws: 
+    func  isWhitespace(ch)  throws: 
       return isWhitespace((int)ch)
-    func  isWhitespace()  throws: 
+    func  isWhitespace(codePoint)  throws: 
       cond-branch cond:(codePoint GE 28 Land codePoint LE 32) Lor (codePoint GE 9 Land codePoint LE 13)
       true branch :
         return true
@@ -489,23 +553,23 @@ class  Character
       false branch :
 
       return isWhitespaceImpl(codePoint)
-    func  isWhitespaceImpl()  throws: 
-    func  isISOControl()  throws: 
+    func  isWhitespaceImpl(codePoint)  throws: 
+    func  isISOControl(ch)  throws: 
       return isISOControl((int)ch)
-    func  isISOControl()  throws: 
+    func  isISOControl(codePoint)  throws: 
       return codePoint LE 159 Land (codePoint GE 127 Lor (codePoint Zext 5 EQ 0))
-    func  getType()  throws: 
+    func  getType(ch)  throws: 
       return getType((int)ch)
-    func  getType()  throws: 
-      var:type=getTypeImpl(codePoint)
+    func  getType(codePoint)  throws: 
+      Decl: type=getTypeImpl(codePoint)
       cond-branch cond:type LE Character.FORMAT
       true branch :
         return type
       false branch :
 
       return (type Add 1)
-    func  getTypeImpl()  throws: 
-    func  forDigit()  throws: 
+    func  getTypeImpl(codePoint)  throws: 
+    func  forDigit(digit,radix)  throws: 
       cond-branch cond:(digit GE radix) Lor (digit LT 0)
       true branch :
         return 
@@ -522,126 +586,123 @@ class  Character
       false branch :
 
       return (char)(a Sub 10 Add digit)
-    func  getDirectionality()  throws: 
+    func  getDirectionality(ch)  throws: 
       return getDirectionality((int)ch)
-    func  getDirectionality()  throws: 
+    func  getDirectionality(codePoint)  throws: 
       cond-branch cond:getType(codePoint) EQ Character.UNASSIGNED
       true branch :
         return Character.DIRECTIONALITY_UNDEFINED
       false branch :
 
-      var:directionality=getDirectionalityImpl(codePoint)
+      Decl: directionality=getDirectionalityImpl(codePoint)
       cond-branch cond:directionality GE 0 Land directionality LT DIRECTIONALITY.length
       true branch :
         return 
       false branch :
 
       return Character.DIRECTIONALITY_UNDEFINED
-    func  getDirectionalityImpl()  throws: 
-    func  isMirrored()  throws: 
+    func  getDirectionalityImpl(codePoint)  throws: 
+    func  isMirrored(ch)  throws: 
       return isMirrored((int)ch)
-    func  isMirrored()  throws: 
+    func  isMirrored(codePoint)  throws: 
       return isMirroredImpl(codePoint)
-    func  isMirroredImpl()  throws: 
-    func  compareTo()  throws: 
+    func  isMirroredImpl(codePoint)  throws: 
+    func  compareTo(anotherCharacter)  throws: 
       return compare(this.value,anotherCharacter.value)
-    func  compare()  throws: 
+    func  compare(x,y)  throws: 
       return x Sub y
-    func  reverseBytes()  throws: 
+    func  reverseBytes(ch)  throws: 
       return (char)(((ch Band 65280) Shr 8) Bor (ch Shl 8))
-    func  getName()  throws: 
+    func  getName(codePoint)  throws: 
       cond-branch cond:isValidCodePoint(codePoint)
       true branch :
-        new IllegalArgumentException<IllegalArgumentException>
+        new IllegalArgumentException()
       false branch :
 
-      var:name=getNameImpl(codePoint)
+      Decl: name=getNameImpl(codePoint)
       cond-branch cond:name NE null
       true branch :
-        return name
-      false branch :
+        return name      false branch :
 
       cond-branch cond:getType(codePoint) EQ UNASSIGNED
       true branch :
-        return null
-      false branch :
+        return null      false branch :
 
-      var:block=UnicodeBlock.of(codePoint)
+      Decl: block=UnicodeBlock.of(codePoint)
       cond-branch cond:block NE null
       true branch :
-        return  Add " " Add 
-      false branch :
+        return block.toString().replace(_, ) Add " " Add Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH)      false branch :
 
-      return 
-    func  getNameImpl()  throws: 
+      return Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH)
+    func  getNameImpl(codePoint)  throws: 
   LocalClasses: 
     class  Subset
       Fields: 
         name
       Instance Initializer: 
       Constructors: 
-        constructor  Subset()  throws: 
+        constructor  Subset(name)  throws: 
           cond-branch cond:name EQ null
           true branch :
-            new NullPointerException<NullPointerException>
+            new NullPointerException("name")
           false branch :
 
           this.name Assign name
       Methods: 
-        func  equals()  throws: 
+        func  equals(obj)  throws: 
           return (this EQ obj)
         func  hashCode()  throws: 
-          return hashCode
+          return super.hashCode()
         func  toString()  throws: 
           return name
       LocalClasses: 
       LocalInterfaces: 
     class  UnicodeBlock
       Fields: 
-        map=new HashMap        BASIC_LATIN=new UnicodeBlock<UnicodeBlock>        LATIN_1_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_B=new UnicodeBlock<UnicodeBlock>        IPA_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        SPACING_MODIFIER_LETTERS=new UnicodeBlock<UnicodeBlock>        COMBINING_DIACRITICAL_MARKS=new UnicodeBlock<UnicodeBlock>        GREEK=new UnicodeBlock<UnicodeBlock>        CYRILLIC=new UnicodeBlock<UnicodeBlock>        ARMENIAN=new UnicodeBlock<UnicodeBlock>        HEBREW=new UnicodeBlock<UnicodeBlock>        ARABIC=new UnicodeBlock<UnicodeBlock>        DEVANAGARI=new UnicodeBlock<UnicodeBlock>        BENGALI=new UnicodeBlock<UnicodeBlock>        GURMUKHI=new UnicodeBlock<UnicodeBlock>        GUJARATI=new UnicodeBlock<UnicodeBlock>        ORIYA=new UnicodeBlock<UnicodeBlock>        TAMIL=new UnicodeBlock<UnicodeBlock>        TELUGU=new UnicodeBlock<UnicodeBlock>        KANNADA=new UnicodeBlock<UnicodeBlock>        MALAYALAM=new UnicodeBlock<UnicodeBlock>        THAI=new UnicodeBlock<UnicodeBlock>        LAO=new UnicodeBlock<UnicodeBlock>        TIBETAN=new UnicodeBlock<UnicodeBlock>        GEORGIAN=new UnicodeBlock<UnicodeBlock>        HANGUL_JAMO=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_ADDITIONAL=new UnicodeBlock<UnicodeBlock>        GREEK_EXTENDED=new UnicodeBlock<UnicodeBlock>        GENERAL_PUNCTUATION=new UnicodeBlock<UnicodeBlock>        SUPERSCRIPTS_AND_SUBSCRIPTS=new UnicodeBlock<UnicodeBlock>        CURRENCY_SYMBOLS=new UnicodeBlock<UnicodeBlock>        COMBINING_MARKS_FOR_SYMBOLS=new UnicodeBlock<UnicodeBlock>        LETTERLIKE_SYMBOLS=new UnicodeBlock<UnicodeBlock>        NUMBER_FORMS=new UnicodeBlock<UnicodeBlock>        ARROWS=new UnicodeBlock<UnicodeBlock>        MATHEMATICAL_OPERATORS=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_TECHNICAL=new UnicodeBlock<UnicodeBlock>        CONTROL_PICTURES=new UnicodeBlock<UnicodeBlock>        OPTICAL_CHARACTER_RECOGNITION=new UnicodeBlock<UnicodeBlock>        ENCLOSED_ALPHANUMERICS=new UnicodeBlock<UnicodeBlock>        BOX_DRAWING=new UnicodeBlock<UnicodeBlock>        BLOCK_ELEMENTS=new UnicodeBlock<UnicodeBlock>        GEOMETRIC_SHAPES=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_SYMBOLS=new UnicodeBlock<UnicodeBlock>        DINGBATS=new UnicodeBlock<UnicodeBlock>        CJK_SYMBOLS_AND_PUNCTUATION=new UnicodeBlock<UnicodeBlock>        HIRAGANA=new UnicodeBlock<UnicodeBlock>        KATAKANA=new UnicodeBlock<UnicodeBlock>        BOPOMOFO=new UnicodeBlock<UnicodeBlock>        HANGUL_COMPATIBILITY_JAMO=new UnicodeBlock<UnicodeBlock>        KANBUN=new UnicodeBlock<UnicodeBlock>        ENCLOSED_CJK_LETTERS_AND_MONTHS=new UnicodeBlock<UnicodeBlock>        CJK_COMPATIBILITY=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS=new UnicodeBlock<UnicodeBlock>        HANGUL_SYLLABLES=new UnicodeBlock<UnicodeBlock>        PRIVATE_USE_AREA=new UnicodeBlock<UnicodeBlock>        CJK_COMPATIBILITY_IDEOGRAPHS=new UnicodeBlock<UnicodeBlock>        ALPHABETIC_PRESENTATION_FORMS=new UnicodeBlock<UnicodeBlock>        ARABIC_PRESENTATION_FORMS_A=new UnicodeBlock<UnicodeBlock>        COMBINING_HALF_MARKS=new UnicodeBlock<UnicodeBlock>        CJK_COMPATIBILITY_FORMS=new UnicodeBlock<UnicodeBlock>        SMALL_FORM_VARIANTS=new UnicodeBlock<UnicodeBlock>        ARABIC_PRESENTATION_FORMS_B=new UnicodeBlock<UnicodeBlock>        HALFWIDTH_AND_FULLWIDTH_FORMS=new UnicodeBlock<UnicodeBlock>        SPECIALS=new UnicodeBlock<UnicodeBlock>        SURROGATES_AREA=new UnicodeBlock<UnicodeBlock>        SYRIAC=new UnicodeBlock<UnicodeBlock>        THAANA=new UnicodeBlock<UnicodeBlock>        SINHALA=new UnicodeBlock<UnicodeBlock>        MYANMAR=new UnicodeBlock<UnicodeBlock>        ETHIOPIC=new UnicodeBlock<UnicodeBlock>        CHEROKEE=new UnicodeBlock<UnicodeBlock>        UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS=new UnicodeBlock<UnicodeBlock>        OGHAM=new UnicodeBlock<UnicodeBlock>        RUNIC=new UnicodeBlock<UnicodeBlock>        KHMER=new UnicodeBlock<UnicodeBlock>        MONGOLIAN=new UnicodeBlock<UnicodeBlock>        BRAILLE_PATTERNS=new UnicodeBlock<UnicodeBlock>        CJK_RADICALS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        KANGXI_RADICALS=new UnicodeBlock<UnicodeBlock>        IDEOGRAPHIC_DESCRIPTION_CHARACTERS=new UnicodeBlock<UnicodeBlock>        BOPOMOFO_EXTENDED=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A=new UnicodeBlock<UnicodeBlock>        YI_SYLLABLES=new UnicodeBlock<UnicodeBlock>        YI_RADICALS=new UnicodeBlock<UnicodeBlock>        CYRILLIC_SUPPLEMENTARY=new UnicodeBlock<UnicodeBlock>        TAGALOG=new UnicodeBlock<UnicodeBlock>        HANUNOO=new UnicodeBlock<UnicodeBlock>        BUHID=new UnicodeBlock<UnicodeBlock>        TAGBANWA=new UnicodeBlock<UnicodeBlock>        LIMBU=new UnicodeBlock<UnicodeBlock>        TAI_LE=new UnicodeBlock<UnicodeBlock>        KHMER_SYMBOLS=new UnicodeBlock<UnicodeBlock>        PHONETIC_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTAL_ARROWS_A=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTAL_ARROWS_B=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTAL_MATHEMATICAL_OPERATORS=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_SYMBOLS_AND_ARROWS=new UnicodeBlock<UnicodeBlock>        KATAKANA_PHONETIC_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        YIJING_HEXAGRAM_SYMBOLS=new UnicodeBlock<UnicodeBlock>        VARIATION_SELECTORS=new UnicodeBlock<UnicodeBlock>        LINEAR_B_SYLLABARY=new UnicodeBlock<UnicodeBlock>        LINEAR_B_IDEOGRAMS=new UnicodeBlock<UnicodeBlock>        AEGEAN_NUMBERS=new UnicodeBlock<UnicodeBlock>        OLD_ITALIC=new UnicodeBlock<UnicodeBlock>        GOTHIC=new UnicodeBlock<UnicodeBlock>        UGARITIC=new UnicodeBlock<UnicodeBlock>        DESERET=new UnicodeBlock<UnicodeBlock>        SHAVIAN=new UnicodeBlock<UnicodeBlock>        OSMANYA=new UnicodeBlock<UnicodeBlock>        CYPRIOT_SYLLABARY=new UnicodeBlock<UnicodeBlock>        BYZANTINE_MUSICAL_SYMBOLS=new UnicodeBlock<UnicodeBlock>        MUSICAL_SYMBOLS=new UnicodeBlock<UnicodeBlock>        TAI_XUAN_JING_SYMBOLS=new UnicodeBlock<UnicodeBlock>        MATHEMATICAL_ALPHANUMERIC_SYMBOLS=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B=new UnicodeBlock<UnicodeBlock>        CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        TAGS=new UnicodeBlock<UnicodeBlock>        VARIATION_SELECTORS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTARY_PRIVATE_USE_AREA_A=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTARY_PRIVATE_USE_AREA_B=new UnicodeBlock<UnicodeBlock>        HIGH_SURROGATES=new UnicodeBlock<UnicodeBlock>        HIGH_PRIVATE_USE_SURROGATES=new UnicodeBlock<UnicodeBlock>        LOW_SURROGATES=new UnicodeBlock<UnicodeBlock>        ARABIC_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        NKO=new UnicodeBlock<UnicodeBlock>        SAMARITAN=new UnicodeBlock<UnicodeBlock>        MANDAIC=new UnicodeBlock<UnicodeBlock>        ETHIOPIC_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED=new UnicodeBlock<UnicodeBlock>        NEW_TAI_LUE=new UnicodeBlock<UnicodeBlock>        BUGINESE=new UnicodeBlock<UnicodeBlock>        TAI_THAM=new UnicodeBlock<UnicodeBlock>        BALINESE=new UnicodeBlock<UnicodeBlock>        SUNDANESE=new UnicodeBlock<UnicodeBlock>        BATAK=new UnicodeBlock<UnicodeBlock>        LEPCHA=new UnicodeBlock<UnicodeBlock>        OL_CHIKI=new UnicodeBlock<UnicodeBlock>        VEDIC_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        PHONETIC_EXTENSIONS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        COMBINING_DIACRITICAL_MARKS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        GLAGOLITIC=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_C=new UnicodeBlock<UnicodeBlock>        COPTIC=new UnicodeBlock<UnicodeBlock>        GEORGIAN_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        TIFINAGH=new UnicodeBlock<UnicodeBlock>        ETHIOPIC_EXTENDED=new UnicodeBlock<UnicodeBlock>        CYRILLIC_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTAL_PUNCTUATION=new UnicodeBlock<UnicodeBlock>        CJK_STROKES=new UnicodeBlock<UnicodeBlock>        LISU=new UnicodeBlock<UnicodeBlock>        VAI=new UnicodeBlock<UnicodeBlock>        CYRILLIC_EXTENDED_B=new UnicodeBlock<UnicodeBlock>        BAMUM=new UnicodeBlock<UnicodeBlock>        MODIFIER_TONE_LETTERS=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_D=new UnicodeBlock<UnicodeBlock>        SYLOTI_NAGRI=new UnicodeBlock<UnicodeBlock>        COMMON_INDIC_NUMBER_FORMS=new UnicodeBlock<UnicodeBlock>        PHAGS_PA=new UnicodeBlock<UnicodeBlock>        SAURASHTRA=new UnicodeBlock<UnicodeBlock>        DEVANAGARI_EXTENDED=new UnicodeBlock<UnicodeBlock>        KAYAH_LI=new UnicodeBlock<UnicodeBlock>        REJANG=new UnicodeBlock<UnicodeBlock>        HANGUL_JAMO_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        JAVANESE=new UnicodeBlock<UnicodeBlock>        CHAM=new UnicodeBlock<UnicodeBlock>        MYANMAR_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        TAI_VIET=new UnicodeBlock<UnicodeBlock>        ETHIOPIC_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        MEETEI_MAYEK=new UnicodeBlock<UnicodeBlock>        HANGUL_JAMO_EXTENDED_B=new UnicodeBlock<UnicodeBlock>        VERTICAL_FORMS=new UnicodeBlock<UnicodeBlock>        ANCIENT_GREEK_NUMBERS=new UnicodeBlock<UnicodeBlock>        ANCIENT_SYMBOLS=new UnicodeBlock<UnicodeBlock>        PHAISTOS_DISC=new UnicodeBlock<UnicodeBlock>        LYCIAN=new UnicodeBlock<UnicodeBlock>        CARIAN=new UnicodeBlock<UnicodeBlock>        OLD_PERSIAN=new UnicodeBlock<UnicodeBlock>        IMPERIAL_ARAMAIC=new UnicodeBlock<UnicodeBlock>        PHOENICIAN=new UnicodeBlock<UnicodeBlock>        LYDIAN=new UnicodeBlock<UnicodeBlock>        KHAROSHTHI=new UnicodeBlock<UnicodeBlock>        OLD_SOUTH_ARABIAN=new UnicodeBlock<UnicodeBlock>        AVESTAN=new UnicodeBlock<UnicodeBlock>        INSCRIPTIONAL_PARTHIAN=new UnicodeBlock<UnicodeBlock>        INSCRIPTIONAL_PAHLAVI=new UnicodeBlock<UnicodeBlock>        OLD_TURKIC=new UnicodeBlock<UnicodeBlock>        RUMI_NUMERAL_SYMBOLS=new UnicodeBlock<UnicodeBlock>        BRAHMI=new UnicodeBlock<UnicodeBlock>        KAITHI=new UnicodeBlock<UnicodeBlock>        CUNEIFORM=new UnicodeBlock<UnicodeBlock>        CUNEIFORM_NUMBERS_AND_PUNCTUATION=new UnicodeBlock<UnicodeBlock>        EGYPTIAN_HIEROGLYPHS=new UnicodeBlock<UnicodeBlock>        BAMUM_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        KANA_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        ANCIENT_GREEK_MUSICAL_NOTATION=new UnicodeBlock<UnicodeBlock>        COUNTING_ROD_NUMERALS=new UnicodeBlock<UnicodeBlock>        MAHJONG_TILES=new UnicodeBlock<UnicodeBlock>        DOMINO_TILES=new UnicodeBlock<UnicodeBlock>        PLAYING_CARDS=new UnicodeBlock<UnicodeBlock>        ENCLOSED_ALPHANUMERIC_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        ENCLOSED_IDEOGRAPHIC_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS=new UnicodeBlock<UnicodeBlock>        EMOTICONS=new UnicodeBlock<UnicodeBlock>        TRANSPORT_AND_MAP_SYMBOLS=new UnicodeBlock<UnicodeBlock>        ALCHEMICAL_SYMBOLS=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D=new UnicodeBlock<UnicodeBlock>        ARABIC_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        SUNDANESE_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        MEETEI_MAYEK_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        MEROITIC_HIEROGLYPHS=new UnicodeBlock<UnicodeBlock>        MEROITIC_CURSIVE=new UnicodeBlock<UnicodeBlock>        SORA_SOMPENG=new UnicodeBlock<UnicodeBlock>        CHAKMA=new UnicodeBlock<UnicodeBlock>        SHARADA=new UnicodeBlock<UnicodeBlock>        TAKRI=new UnicodeBlock<UnicodeBlock>        MIAO=new UnicodeBlock<UnicodeBlock>        ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS=new UnicodeBlock<UnicodeBlock>        blockStarts=[]        blocks=
+        map=new HashMap(256)        BASIC_LATIN=new UnicodeBlock("BASIC_LATIN","BASIC LATIN","BASICLATIN")        LATIN_1_SUPPLEMENT=new UnicodeBlock("LATIN_1_SUPPLEMENT","LATIN-1 SUPPLEMENT","LATIN-1SUPPLEMENT")        LATIN_EXTENDED_A=new UnicodeBlock("LATIN_EXTENDED_A","LATIN EXTENDED-A","LATINEXTENDED-A")        LATIN_EXTENDED_B=new UnicodeBlock("LATIN_EXTENDED_B","LATIN EXTENDED-B","LATINEXTENDED-B")        IPA_EXTENSIONS=new UnicodeBlock("IPA_EXTENSIONS","IPA EXTENSIONS","IPAEXTENSIONS")        SPACING_MODIFIER_LETTERS=new UnicodeBlock("SPACING_MODIFIER_LETTERS","SPACING MODIFIER LETTERS","SPACINGMODIFIERLETTERS")        COMBINING_DIACRITICAL_MARKS=new UnicodeBlock("COMBINING_DIACRITICAL_MARKS","COMBINING DIACRITICAL MARKS","COMBININGDIACRITICALMARKS")        GREEK=new UnicodeBlock("GREEK","GREEK AND COPTIC","GREEKANDCOPTIC")        CYRILLIC=new UnicodeBlock("CYRILLIC")        ARMENIAN=new UnicodeBlock("ARMENIAN")        HEBREW=new UnicodeBlock("HEBREW")        ARABIC=new UnicodeBlock("ARABIC")        DEVANAGARI=new UnicodeBlock("DEVANAGARI")        BENGALI=new UnicodeBlock("BENGALI")        GURMUKHI=new UnicodeBlock("GURMUKHI")        GUJARATI=new UnicodeBlock("GUJARATI")        ORIYA=new UnicodeBlock("ORIYA")        TAMIL=new UnicodeBlock("TAMIL")        TELUGU=new UnicodeBlock("TELUGU")        KANNADA=new UnicodeBlock("KANNADA")        MALAYALAM=new UnicodeBlock("MALAYALAM")        THAI=new UnicodeBlock("THAI")        LAO=new UnicodeBlock("LAO")        TIBETAN=new UnicodeBlock("TIBETAN")        GEORGIAN=new UnicodeBlock("GEORGIAN")        HANGUL_JAMO=new UnicodeBlock("HANGUL_JAMO","HANGUL JAMO","HANGULJAMO")        LATIN_EXTENDED_ADDITIONAL=new UnicodeBlock("LATIN_EXTENDED_ADDITIONAL","LATIN EXTENDED ADDITIONAL","LATINEXTENDEDADDITIONAL")        GREEK_EXTENDED=new UnicodeBlock("GREEK_EXTENDED","GREEK EXTENDED","GREEKEXTENDED")        GENERAL_PUNCTUATION=new UnicodeBlock("GENERAL_PUNCTUATION","GENERAL PUNCTUATION","GENERALPUNCTUATION")        SUPERSCRIPTS_AND_SUBSCRIPTS=new UnicodeBlock("SUPERSCRIPTS_AND_SUBSCRIPTS","SUPERSCRIPTS AND SUBSCRIPTS","SUPERSCRIPTSANDSUBSCRIPTS")        CURRENCY_SYMBOLS=new UnicodeBlock("CURRENCY_SYMBOLS","CURRENCY SYMBOLS","CURRENCYSYMBOLS")        COMBINING_MARKS_FOR_SYMBOLS=new UnicodeBlock("COMBINING_MARKS_FOR_SYMBOLS","COMBINING DIACRITICAL MARKS FOR SYMBOLS","COMBININGDIACRITICALMARKSFORSYMBOLS","COMBINING MARKS FOR SYMBOLS","COMBININGMARKSFORSYMBOLS")        LETTERLIKE_SYMBOLS=new UnicodeBlock("LETTERLIKE_SYMBOLS","LETTERLIKE SYMBOLS","LETTERLIKESYMBOLS")        NUMBER_FORMS=new UnicodeBlock("NUMBER_FORMS","NUMBER FORMS","NUMBERFORMS")        ARROWS=new UnicodeBlock("ARROWS")        MATHEMATICAL_OPERATORS=new UnicodeBlock("MATHEMATICAL_OPERATORS","MATHEMATICAL OPERATORS","MATHEMATICALOPERATORS")        MISCELLANEOUS_TECHNICAL=new UnicodeBlock("MISCELLANEOUS_TECHNICAL","MISCELLANEOUS TECHNICAL","MISCELLANEOUSTECHNICAL")        CONTROL_PICTURES=new UnicodeBlock("CONTROL_PICTURES","CONTROL PICTURES","CONTROLPICTURES")        OPTICAL_CHARACTER_RECOGNITION=new UnicodeBlock("OPTICAL_CHARACTER_RECOGNITION","OPTICAL CHARACTER RECOGNITION","OPTICALCHARACTERRECOGNITION")        ENCLOSED_ALPHANUMERICS=new UnicodeBlock("ENCLOSED_ALPHANUMERICS","ENCLOSED ALPHANUMERICS","ENCLOSEDALPHANUMERICS")        BOX_DRAWING=new UnicodeBlock("BOX_DRAWING","BOX DRAWING","BOXDRAWING")        BLOCK_ELEMENTS=new UnicodeBlock("BLOCK_ELEMENTS","BLOCK ELEMENTS","BLOCKELEMENTS")        GEOMETRIC_SHAPES=new UnicodeBlock("GEOMETRIC_SHAPES","GEOMETRIC SHAPES","GEOMETRICSHAPES")        MISCELLANEOUS_SYMBOLS=new UnicodeBlock("MISCELLANEOUS_SYMBOLS","MISCELLANEOUS SYMBOLS","MISCELLANEOUSSYMBOLS")        DINGBATS=new UnicodeBlock("DINGBATS")        CJK_SYMBOLS_AND_PUNCTUATION=new UnicodeBlock("CJK_SYMBOLS_AND_PUNCTUATION","CJK SYMBOLS AND PUNCTUATION","CJKSYMBOLSANDPUNCTUATION")        HIRAGANA=new UnicodeBlock("HIRAGANA")        KATAKANA=new UnicodeBlock("KATAKANA")        BOPOMOFO=new UnicodeBlock("BOPOMOFO")        HANGUL_COMPATIBILITY_JAMO=new UnicodeBlock("HANGUL_COMPATIBILITY_JAMO","HANGUL COMPATIBILITY JAMO","HANGULCOMPATIBILITYJAMO")        KANBUN=new UnicodeBlock("KANBUN")        ENCLOSED_CJK_LETTERS_AND_MONTHS=new UnicodeBlock("ENCLOSED_CJK_LETTERS_AND_MONTHS","ENCLOSED CJK LETTERS AND MONTHS","ENCLOSEDCJKLETTERSANDMONTHS")        CJK_COMPATIBILITY=new UnicodeBlock("CJK_COMPATIBILITY","CJK COMPATIBILITY","CJKCOMPATIBILITY")        CJK_UNIFIED_IDEOGRAPHS=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS","CJK UNIFIED IDEOGRAPHS","CJKUNIFIEDIDEOGRAPHS")        HANGUL_SYLLABLES=new UnicodeBlock("HANGUL_SYLLABLES","HANGUL SYLLABLES","HANGULSYLLABLES")        PRIVATE_USE_AREA=new UnicodeBlock("PRIVATE_USE_AREA","PRIVATE USE AREA","PRIVATEUSEAREA")        CJK_COMPATIBILITY_IDEOGRAPHS=new UnicodeBlock("CJK_COMPATIBILITY_IDEOGRAPHS","CJK COMPATIBILITY IDEOGRAPHS","CJKCOMPATIBILITYIDEOGRAPHS")        ALPHABETIC_PRESENTATION_FORMS=new UnicodeBlock("ALPHABETIC_PRESENTATION_FORMS","ALPHABETIC PRESENTATION FORMS","ALPHABETICPRESENTATIONFORMS")        ARABIC_PRESENTATION_FORMS_A=new UnicodeBlock("ARABIC_PRESENTATION_FORMS_A","ARABIC PRESENTATION FORMS-A","ARABICPRESENTATIONFORMS-A")        COMBINING_HALF_MARKS=new UnicodeBlock("COMBINING_HALF_MARKS","COMBINING HALF MARKS","COMBININGHALFMARKS")        CJK_COMPATIBILITY_FORMS=new UnicodeBlock("CJK_COMPATIBILITY_FORMS","CJK COMPATIBILITY FORMS","CJKCOMPATIBILITYFORMS")        SMALL_FORM_VARIANTS=new UnicodeBlock("SMALL_FORM_VARIANTS","SMALL FORM VARIANTS","SMALLFORMVARIANTS")        ARABIC_PRESENTATION_FORMS_B=new UnicodeBlock("ARABIC_PRESENTATION_FORMS_B","ARABIC PRESENTATION FORMS-B","ARABICPRESENTATIONFORMS-B")        HALFWIDTH_AND_FULLWIDTH_FORMS=new UnicodeBlock("HALFWIDTH_AND_FULLWIDTH_FORMS","HALFWIDTH AND FULLWIDTH FORMS","HALFWIDTHANDFULLWIDTHFORMS")        SPECIALS=new UnicodeBlock("SPECIALS")        SURROGATES_AREA=new UnicodeBlock("SURROGATES_AREA",false)        SYRIAC=new UnicodeBlock("SYRIAC")        THAANA=new UnicodeBlock("THAANA")        SINHALA=new UnicodeBlock("SINHALA")        MYANMAR=new UnicodeBlock("MYANMAR")        ETHIOPIC=new UnicodeBlock("ETHIOPIC")        CHEROKEE=new UnicodeBlock("CHEROKEE")        UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS=new UnicodeBlock("UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS","UNIFIED CANADIAN ABORIGINAL SYLLABICS","UNIFIEDCANADIANABORIGINALSYLLABICS")        OGHAM=new UnicodeBlock("OGHAM")        RUNIC=new UnicodeBlock("RUNIC")        KHMER=new UnicodeBlock("KHMER")        MONGOLIAN=new UnicodeBlock("MONGOLIAN")        BRAILLE_PATTERNS=new UnicodeBlock("BRAILLE_PATTERNS","BRAILLE PATTERNS","BRAILLEPATTERNS")        CJK_RADICALS_SUPPLEMENT=new UnicodeBlock("CJK_RADICALS_SUPPLEMENT","CJK RADICALS SUPPLEMENT","CJKRADICALSSUPPLEMENT")        KANGXI_RADICALS=new UnicodeBlock("KANGXI_RADICALS","KANGXI RADICALS","KANGXIRADICALS")        IDEOGRAPHIC_DESCRIPTION_CHARACTERS=new UnicodeBlock("IDEOGRAPHIC_DESCRIPTION_CHARACTERS","IDEOGRAPHIC DESCRIPTION CHARACTERS","IDEOGRAPHICDESCRIPTIONCHARACTERS")        BOPOMOFO_EXTENDED=new UnicodeBlock("BOPOMOFO_EXTENDED","BOPOMOFO EXTENDED","BOPOMOFOEXTENDED")        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A","CJK UNIFIED IDEOGRAPHS EXTENSION A","CJKUNIFIEDIDEOGRAPHSEXTENSIONA")        YI_SYLLABLES=new UnicodeBlock("YI_SYLLABLES","YI SYLLABLES","YISYLLABLES")        YI_RADICALS=new UnicodeBlock("YI_RADICALS","YI RADICALS","YIRADICALS")        CYRILLIC_SUPPLEMENTARY=new UnicodeBlock("CYRILLIC_SUPPLEMENTARY","CYRILLIC SUPPLEMENTARY","CYRILLICSUPPLEMENTARY","CYRILLIC SUPPLEMENT","CYRILLICSUPPLEMENT")        TAGALOG=new UnicodeBlock("TAGALOG")        HANUNOO=new UnicodeBlock("HANUNOO")        BUHID=new UnicodeBlock("BUHID")        TAGBANWA=new UnicodeBlock("TAGBANWA")        LIMBU=new UnicodeBlock("LIMBU")        TAI_LE=new UnicodeBlock("TAI_LE","TAI LE","TAILE")        KHMER_SYMBOLS=new UnicodeBlock("KHMER_SYMBOLS","KHMER SYMBOLS","KHMERSYMBOLS")        PHONETIC_EXTENSIONS=new UnicodeBlock("PHONETIC_EXTENSIONS","PHONETIC EXTENSIONS","PHONETICEXTENSIONS")        MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A=new UnicodeBlock("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A","MISCELLANEOUS MATHEMATICAL SYMBOLS-A","MISCELLANEOUSMATHEMATICALSYMBOLS-A")        SUPPLEMENTAL_ARROWS_A=new UnicodeBlock("SUPPLEMENTAL_ARROWS_A","SUPPLEMENTAL ARROWS-A","SUPPLEMENTALARROWS-A")        SUPPLEMENTAL_ARROWS_B=new UnicodeBlock("SUPPLEMENTAL_ARROWS_B","SUPPLEMENTAL ARROWS-B","SUPPLEMENTALARROWS-B")        MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B=new UnicodeBlock("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B","MISCELLANEOUS MATHEMATICAL SYMBOLS-B","MISCELLANEOUSMATHEMATICALSYMBOLS-B")        SUPPLEMENTAL_MATHEMATICAL_OPERATORS=new UnicodeBlock("SUPPLEMENTAL_MATHEMATICAL_OPERATORS","SUPPLEMENTAL MATHEMATICAL OPERATORS","SUPPLEMENTALMATHEMATICALOPERATORS")        MISCELLANEOUS_SYMBOLS_AND_ARROWS=new UnicodeBlock("MISCELLANEOUS_SYMBOLS_AND_ARROWS","MISCELLANEOUS SYMBOLS AND ARROWS","MISCELLANEOUSSYMBOLSANDARROWS")        KATAKANA_PHONETIC_EXTENSIONS=new UnicodeBlock("KATAKANA_PHONETIC_EXTENSIONS","KATAKANA PHONETIC EXTENSIONS","KATAKANAPHONETICEXTENSIONS")        YIJING_HEXAGRAM_SYMBOLS=new UnicodeBlock("YIJING_HEXAGRAM_SYMBOLS","YIJING HEXAGRAM SYMBOLS","YIJINGHEXAGRAMSYMBOLS")        VARIATION_SELECTORS=new UnicodeBlock("VARIATION_SELECTORS","VARIATION SELECTORS","VARIATIONSELECTORS")        LINEAR_B_SYLLABARY=new UnicodeBlock("LINEAR_B_SYLLABARY","LINEAR B SYLLABARY","LINEARBSYLLABARY")        LINEAR_B_IDEOGRAMS=new UnicodeBlock("LINEAR_B_IDEOGRAMS","LINEAR B IDEOGRAMS","LINEARBIDEOGRAMS")        AEGEAN_NUMBERS=new UnicodeBlock("AEGEAN_NUMBERS","AEGEAN NUMBERS","AEGEANNUMBERS")        OLD_ITALIC=new UnicodeBlock("OLD_ITALIC","OLD ITALIC","OLDITALIC")        GOTHIC=new UnicodeBlock("GOTHIC")        UGARITIC=new UnicodeBlock("UGARITIC")        DESERET=new UnicodeBlock("DESERET")        SHAVIAN=new UnicodeBlock("SHAVIAN")        OSMANYA=new UnicodeBlock("OSMANYA")        CYPRIOT_SYLLABARY=new UnicodeBlock("CYPRIOT_SYLLABARY","CYPRIOT SYLLABARY","CYPRIOTSYLLABARY")        BYZANTINE_MUSICAL_SYMBOLS=new UnicodeBlock("BYZANTINE_MUSICAL_SYMBOLS","BYZANTINE MUSICAL SYMBOLS","BYZANTINEMUSICALSYMBOLS")        MUSICAL_SYMBOLS=new UnicodeBlock("MUSICAL_SYMBOLS","MUSICAL SYMBOLS","MUSICALSYMBOLS")        TAI_XUAN_JING_SYMBOLS=new UnicodeBlock("TAI_XUAN_JING_SYMBOLS","TAI XUAN JING SYMBOLS","TAIXUANJINGSYMBOLS")        MATHEMATICAL_ALPHANUMERIC_SYMBOLS=new UnicodeBlock("MATHEMATICAL_ALPHANUMERIC_SYMBOLS","MATHEMATICAL ALPHANUMERIC SYMBOLS","MATHEMATICALALPHANUMERICSYMBOLS")        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B","CJK UNIFIED IDEOGRAPHS EXTENSION B","CJKUNIFIEDIDEOGRAPHSEXTENSIONB")        CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT=new UnicodeBlock("CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT","CJK COMPATIBILITY IDEOGRAPHS SUPPLEMENT","CJKCOMPATIBILITYIDEOGRAPHSSUPPLEMENT")        TAGS=new UnicodeBlock("TAGS")        VARIATION_SELECTORS_SUPPLEMENT=new UnicodeBlock("VARIATION_SELECTORS_SUPPLEMENT","VARIATION SELECTORS SUPPLEMENT","VARIATIONSELECTORSSUPPLEMENT")        SUPPLEMENTARY_PRIVATE_USE_AREA_A=new UnicodeBlock("SUPPLEMENTARY_PRIVATE_USE_AREA_A","SUPPLEMENTARY PRIVATE USE AREA-A","SUPPLEMENTARYPRIVATEUSEAREA-A")        SUPPLEMENTARY_PRIVATE_USE_AREA_B=new UnicodeBlock("SUPPLEMENTARY_PRIVATE_USE_AREA_B","SUPPLEMENTARY PRIVATE USE AREA-B","SUPPLEMENTARYPRIVATEUSEAREA-B")        HIGH_SURROGATES=new UnicodeBlock("HIGH_SURROGATES","HIGH SURROGATES","HIGHSURROGATES")        HIGH_PRIVATE_USE_SURROGATES=new UnicodeBlock("HIGH_PRIVATE_USE_SURROGATES","HIGH PRIVATE USE SURROGATES","HIGHPRIVATEUSESURROGATES")        LOW_SURROGATES=new UnicodeBlock("LOW_SURROGATES","LOW SURROGATES","LOWSURROGATES")        ARABIC_SUPPLEMENT=new UnicodeBlock("ARABIC_SUPPLEMENT","ARABIC SUPPLEMENT","ARABICSUPPLEMENT")        NKO=new UnicodeBlock("NKO")        SAMARITAN=new UnicodeBlock("SAMARITAN")        MANDAIC=new UnicodeBlock("MANDAIC")        ETHIOPIC_SUPPLEMENT=new UnicodeBlock("ETHIOPIC_SUPPLEMENT","ETHIOPIC SUPPLEMENT","ETHIOPICSUPPLEMENT")        UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED=new UnicodeBlock("UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED","UNIFIED CANADIAN ABORIGINAL SYLLABICS EXTENDED","UNIFIEDCANADIANABORIGINALSYLLABICSEXTENDED")        NEW_TAI_LUE=new UnicodeBlock("NEW_TAI_LUE","NEW TAI LUE","NEWTAILUE")        BUGINESE=new UnicodeBlock("BUGINESE")        TAI_THAM=new UnicodeBlock("TAI_THAM","TAI THAM","TAITHAM")        BALINESE=new UnicodeBlock("BALINESE")        SUNDANESE=new UnicodeBlock("SUNDANESE")        BATAK=new UnicodeBlock("BATAK")        LEPCHA=new UnicodeBlock("LEPCHA")        OL_CHIKI=new UnicodeBlock("OL_CHIKI","OL CHIKI","OLCHIKI")        VEDIC_EXTENSIONS=new UnicodeBlock("VEDIC_EXTENSIONS","VEDIC EXTENSIONS","VEDICEXTENSIONS")        PHONETIC_EXTENSIONS_SUPPLEMENT=new UnicodeBlock("PHONETIC_EXTENSIONS_SUPPLEMENT","PHONETIC EXTENSIONS SUPPLEMENT","PHONETICEXTENSIONSSUPPLEMENT")        COMBINING_DIACRITICAL_MARKS_SUPPLEMENT=new UnicodeBlock("COMBINING_DIACRITICAL_MARKS_SUPPLEMENT","COMBINING DIACRITICAL MARKS SUPPLEMENT","COMBININGDIACRITICALMARKSSUPPLEMENT")        GLAGOLITIC=new UnicodeBlock("GLAGOLITIC")        LATIN_EXTENDED_C=new UnicodeBlock("LATIN_EXTENDED_C","LATIN EXTENDED-C","LATINEXTENDED-C")        COPTIC=new UnicodeBlock("COPTIC")        GEORGIAN_SUPPLEMENT=new UnicodeBlock("GEORGIAN_SUPPLEMENT","GEORGIAN SUPPLEMENT","GEORGIANSUPPLEMENT")        TIFINAGH=new UnicodeBlock("TIFINAGH")        ETHIOPIC_EXTENDED=new UnicodeBlock("ETHIOPIC_EXTENDED","ETHIOPIC EXTENDED","ETHIOPICEXTENDED")        CYRILLIC_EXTENDED_A=new UnicodeBlock("CYRILLIC_EXTENDED_A","CYRILLIC EXTENDED-A","CYRILLICEXTENDED-A")        SUPPLEMENTAL_PUNCTUATION=new UnicodeBlock("SUPPLEMENTAL_PUNCTUATION","SUPPLEMENTAL PUNCTUATION","SUPPLEMENTALPUNCTUATION")        CJK_STROKES=new UnicodeBlock("CJK_STROKES","CJK STROKES","CJKSTROKES")        LISU=new UnicodeBlock("LISU")        VAI=new UnicodeBlock("VAI")        CYRILLIC_EXTENDED_B=new UnicodeBlock("CYRILLIC_EXTENDED_B","CYRILLIC EXTENDED-B","CYRILLICEXTENDED-B")        BAMUM=new UnicodeBlock("BAMUM")        MODIFIER_TONE_LETTERS=new UnicodeBlock("MODIFIER_TONE_LETTERS","MODIFIER TONE LETTERS","MODIFIERTONELETTERS")        LATIN_EXTENDED_D=new UnicodeBlock("LATIN_EXTENDED_D","LATIN EXTENDED-D","LATINEXTENDED-D")        SYLOTI_NAGRI=new UnicodeBlock("SYLOTI_NAGRI","SYLOTI NAGRI","SYLOTINAGRI")        COMMON_INDIC_NUMBER_FORMS=new UnicodeBlock("COMMON_INDIC_NUMBER_FORMS","COMMON INDIC NUMBER FORMS","COMMONINDICNUMBERFORMS")        PHAGS_PA=new UnicodeBlock("PHAGS_PA","PHAGS-PA")        SAURASHTRA=new UnicodeBlock("SAURASHTRA")        DEVANAGARI_EXTENDED=new UnicodeBlock("DEVANAGARI_EXTENDED","DEVANAGARI EXTENDED","DEVANAGARIEXTENDED")        KAYAH_LI=new UnicodeBlock("KAYAH_LI","KAYAH LI","KAYAHLI")        REJANG=new UnicodeBlock("REJANG")        HANGUL_JAMO_EXTENDED_A=new UnicodeBlock("HANGUL_JAMO_EXTENDED_A","HANGUL JAMO EXTENDED-A","HANGULJAMOEXTENDED-A")        JAVANESE=new UnicodeBlock("JAVANESE")        CHAM=new UnicodeBlock("CHAM")        MYANMAR_EXTENDED_A=new UnicodeBlock("MYANMAR_EXTENDED_A","MYANMAR EXTENDED-A","MYANMAREXTENDED-A")        TAI_VIET=new UnicodeBlock("TAI_VIET","TAI VIET","TAIVIET")        ETHIOPIC_EXTENDED_A=new UnicodeBlock("ETHIOPIC_EXTENDED_A","ETHIOPIC EXTENDED-A","ETHIOPICEXTENDED-A")        MEETEI_MAYEK=new UnicodeBlock("MEETEI_MAYEK","MEETEI MAYEK","MEETEIMAYEK")        HANGUL_JAMO_EXTENDED_B=new UnicodeBlock("HANGUL_JAMO_EXTENDED_B","HANGUL JAMO EXTENDED-B","HANGULJAMOEXTENDED-B")        VERTICAL_FORMS=new UnicodeBlock("VERTICAL_FORMS","VERTICAL FORMS","VERTICALFORMS")        ANCIENT_GREEK_NUMBERS=new UnicodeBlock("ANCIENT_GREEK_NUMBERS","ANCIENT GREEK NUMBERS","ANCIENTGREEKNUMBERS")        ANCIENT_SYMBOLS=new UnicodeBlock("ANCIENT_SYMBOLS","ANCIENT SYMBOLS","ANCIENTSYMBOLS")        PHAISTOS_DISC=new UnicodeBlock("PHAISTOS_DISC","PHAISTOS DISC","PHAISTOSDISC")        LYCIAN=new UnicodeBlock("LYCIAN")        CARIAN=new UnicodeBlock("CARIAN")        OLD_PERSIAN=new UnicodeBlock("OLD_PERSIAN","OLD PERSIAN","OLDPERSIAN")        IMPERIAL_ARAMAIC=new UnicodeBlock("IMPERIAL_ARAMAIC","IMPERIAL ARAMAIC","IMPERIALARAMAIC")        PHOENICIAN=new UnicodeBlock("PHOENICIAN")        LYDIAN=new UnicodeBlock("LYDIAN")        KHAROSHTHI=new UnicodeBlock("KHAROSHTHI")        OLD_SOUTH_ARABIAN=new UnicodeBlock("OLD_SOUTH_ARABIAN","OLD SOUTH ARABIAN","OLDSOUTHARABIAN")        AVESTAN=new UnicodeBlock("AVESTAN")        INSCRIPTIONAL_PARTHIAN=new UnicodeBlock("INSCRIPTIONAL_PARTHIAN","INSCRIPTIONAL PARTHIAN","INSCRIPTIONALPARTHIAN")        INSCRIPTIONAL_PAHLAVI=new UnicodeBlock("INSCRIPTIONAL_PAHLAVI","INSCRIPTIONAL PAHLAVI","INSCRIPTIONALPAHLAVI")        OLD_TURKIC=new UnicodeBlock("OLD_TURKIC","OLD TURKIC","OLDTURKIC")        RUMI_NUMERAL_SYMBOLS=new UnicodeBlock("RUMI_NUMERAL_SYMBOLS","RUMI NUMERAL SYMBOLS","RUMINUMERALSYMBOLS")        BRAHMI=new UnicodeBlock("BRAHMI")        KAITHI=new UnicodeBlock("KAITHI")        CUNEIFORM=new UnicodeBlock("CUNEIFORM")        CUNEIFORM_NUMBERS_AND_PUNCTUATION=new UnicodeBlock("CUNEIFORM_NUMBERS_AND_PUNCTUATION","CUNEIFORM NUMBERS AND PUNCTUATION","CUNEIFORMNUMBERSANDPUNCTUATION")        EGYPTIAN_HIEROGLYPHS=new UnicodeBlock("EGYPTIAN_HIEROGLYPHS","EGYPTIAN HIEROGLYPHS","EGYPTIANHIEROGLYPHS")        BAMUM_SUPPLEMENT=new UnicodeBlock("BAMUM_SUPPLEMENT","BAMUM SUPPLEMENT","BAMUMSUPPLEMENT")        KANA_SUPPLEMENT=new UnicodeBlock("KANA_SUPPLEMENT","KANA SUPPLEMENT","KANASUPPLEMENT")        ANCIENT_GREEK_MUSICAL_NOTATION=new UnicodeBlock("ANCIENT_GREEK_MUSICAL_NOTATION","ANCIENT GREEK MUSICAL NOTATION","ANCIENTGREEKMUSICALNOTATION")        COUNTING_ROD_NUMERALS=new UnicodeBlock("COUNTING_ROD_NUMERALS","COUNTING ROD NUMERALS","COUNTINGRODNUMERALS")        MAHJONG_TILES=new UnicodeBlock("MAHJONG_TILES","MAHJONG TILES","MAHJONGTILES")        DOMINO_TILES=new UnicodeBlock("DOMINO_TILES","DOMINO TILES","DOMINOTILES")        PLAYING_CARDS=new UnicodeBlock("PLAYING_CARDS","PLAYING CARDS","PLAYINGCARDS")        ENCLOSED_ALPHANUMERIC_SUPPLEMENT=new UnicodeBlock("ENCLOSED_ALPHANUMERIC_SUPPLEMENT","ENCLOSED ALPHANUMERIC SUPPLEMENT","ENCLOSEDALPHANUMERICSUPPLEMENT")        ENCLOSED_IDEOGRAPHIC_SUPPLEMENT=new UnicodeBlock("ENCLOSED_IDEOGRAPHIC_SUPPLEMENT","ENCLOSED IDEOGRAPHIC SUPPLEMENT","ENCLOSEDIDEOGRAPHICSUPPLEMENT")        MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS=new UnicodeBlock("MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS","MISCELLANEOUS SYMBOLS AND PICTOGRAPHS","MISCELLANEOUSSYMBOLSANDPICTOGRAPHS")        EMOTICONS=new UnicodeBlock("EMOTICONS")        TRANSPORT_AND_MAP_SYMBOLS=new UnicodeBlock("TRANSPORT_AND_MAP_SYMBOLS","TRANSPORT AND MAP SYMBOLS","TRANSPORTANDMAPSYMBOLS")        ALCHEMICAL_SYMBOLS=new UnicodeBlock("ALCHEMICAL_SYMBOLS","ALCHEMICAL SYMBOLS","ALCHEMICALSYMBOLS")        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C","CJK UNIFIED IDEOGRAPHS EXTENSION C","CJKUNIFIEDIDEOGRAPHSEXTENSIONC")        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D=new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D","CJK UNIFIED IDEOGRAPHS EXTENSION D","CJKUNIFIEDIDEOGRAPHSEXTENSIOND")        ARABIC_EXTENDED_A=new UnicodeBlock("ARABIC_EXTENDED_A","ARABIC EXTENDED-A","ARABICEXTENDED-A")        SUNDANESE_SUPPLEMENT=new UnicodeBlock("SUNDANESE_SUPPLEMENT","SUNDANESE SUPPLEMENT","SUNDANESESUPPLEMENT")        MEETEI_MAYEK_EXTENSIONS=new UnicodeBlock("MEETEI_MAYEK_EXTENSIONS","MEETEI MAYEK EXTENSIONS","MEETEIMAYEKEXTENSIONS")        MEROITIC_HIEROGLYPHS=new UnicodeBlock("MEROITIC_HIEROGLYPHS","MEROITIC HIEROGLYPHS","MEROITICHIEROGLYPHS")        MEROITIC_CURSIVE=new UnicodeBlock("MEROITIC_CURSIVE","MEROITIC CURSIVE","MEROITICCURSIVE")        SORA_SOMPENG=new UnicodeBlock("SORA_SOMPENG","SORA SOMPENG","SORASOMPENG")        CHAKMA=new UnicodeBlock("CHAKMA")        SHARADA=new UnicodeBlock("SHARADA")        TAKRI=new UnicodeBlock("TAKRI")        MIAO=new UnicodeBlock("MIAO")        ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS=new UnicodeBlock("ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS","ARABIC MATHEMATICAL ALPHABETIC SYMBOLS","ARABICMATHEMATICALALPHABETICSYMBOLS")        blockStarts=[]        blocks=
       Instance Initializer: 
       Constructors: 
-        constructor  UnicodeBlock()  throws: 
-        constructor  UnicodeBlock()  throws: 
+        constructor  UnicodeBlock(idName)  throws: 
+        constructor  UnicodeBlock(idName,isMap)  throws: 
           cond-branch cond:isMap
           true branch :
             map.put(idName,this)
           false branch :
 
-        constructor  UnicodeBlock()  throws: 
+        constructor  UnicodeBlock(idName,alias)  throws: 
           map.put(alias,this)
-        constructor  UnicodeBlock()  throws: 
+        constructor  UnicodeBlock(idName,aliases)  throws: 
           String
           alias
           aliases
           map.put(alias,this)
       Methods: 
-        func  of()  throws: 
+        func  of(c)  throws: 
           return of((int)c)
-        func  of()  throws: 
+        func  of(codePoint)  throws: 
           cond-branch cond:isValidCodePoint(codePoint)
           true branch :
-            new IllegalArgumentException<IllegalArgumentException>
+            new IllegalArgumentException()
           false branch :
 
-          var:top,bottom,current
+          Decl: top,bottom,current
           bottom Assign 0
           top Assign blockStarts.length
-          current Assign 
+          current Assign top Div 2
           while top Sub bottom GT 1            cond-branch cond:codePoint GE 
             true branch :
               bottom Assign current
             false branch :
               top Assign current
 
-            current Assign (top Add bottom)2
+            current Assign (top Add bottom) Div 2
 
           return 
-        func  forName()  throws: 
-          var:block=map.get(blockName.toUpperCase(Locale.US))
+        func  forName(blockName)  throws: 
+          Decl: block=map.get(blockName.toUpperCase(Locale.US))
           cond-branch cond:block EQ null
           true branch :
-            new IllegalArgumentException<IllegalArgumentException>
+            new IllegalArgumentException()
           false branch :
 
           return block
@@ -649,38 +710,33 @@ class  Character
       LocalInterfaces: 
     class[JavaEnum]  UnicodeScript
       Fields: 
-        COMMON        scriptStarts=        scripts=        aliases
+        scriptStarts=        scripts=        aliases
       Instance Initializer: 
         InstInit- 0
       Constructors: 
       Methods: 
-        func  of()  throws: 
+        func  of(codePoint)  throws: 
           cond-branch cond:isValidCodePoint(codePoint)
           true branch :
-            new IllegalArgumentException<IllegalArgumentException>
-          false branch :
+            new IllegalArgumentException()          false branch :
 
-          var:type=getType(codePoint)
+          Decl: type=getType(codePoint)
           cond-branch cond:type EQ UNASSIGNED
           true branch :
-            return UNKNOWN
-          false branch :
+            return UNKNOWN          false branch :
 
-          var:index=Arrays.binarySearch(scriptStarts,codePoint)
+          Decl: index=Arrays.binarySearch(scriptStarts,codePoint)
           cond-branch cond:index LT 0
           true branch :
-            index Assign Sub
-  index Sub 2
-          false branch :
+            index Assign Minus index Sub 2          false branch :
 
           return 
-        func  forName()  throws: 
+        func  forName(scriptName)  throws: 
           scriptName Assign scriptName.toUpperCase(Locale.ENGLISH)
-          var:sc=aliases.get(scriptName)
+          Decl: sc=aliases.get(scriptName)
           cond-branch cond:sc NE null
           true branch :
-            return sc
-          false branch :
+            return sc          false branch :
 
           return valueOf(scriptName)
       LocalClasses: 
diff --git a/src/MapleFE/test/openjdk/Class-2.java b/src/MapleFE/test/java/openjdk/Class-2.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Class-2.java
rename to src/MapleFE/test/java/openjdk/Class-2.java
diff --git a/src/MapleFE/test/openjdk/Class-2.java.result b/src/MapleFE/test/java/openjdk/Class-2.java.result
similarity index 62%
rename from src/MapleFE/test/openjdk/Class-2.java.result
rename to src/MapleFE/test/java/openjdk/Class-2.java.result
index a18295d54303b1ee1f0f4b9fb0638dcc2b954404..bbe92670f84638da3f5c4970793b40eb95f8b2ea 100644
--- a/src/MapleFE/test/openjdk/Class-2.java.result
+++ b/src/MapleFE/test/java/openjdk/Class-2.java.result
@@ -16,14 +16,13 @@ class  Class
       return getEnclosingConstructorNative()
     func  getEnclosingConstructorNative()  throws: 
     func  classNameImpliesTopLevel()  throws: 
-      return 
+      return getName().contains("$")
     func  getDeclaringClass()  throws: 
     func  getEnclosingClass()  throws: 
     func  getSimpleName()  throws: 
       cond-branch cond:isArray()
       true branch :
-        return  Add "[]"
-      false branch :
+        return getComponentType().getSimpleName() Add "[]"      false branch :
 
       cond-branch cond:isAnonymousClass()
       true branch :
@@ -35,8 +34,8 @@ class  Class
         return getInnerClassName()
       false branch :
 
-      var:simpleName=getName()
-      var:dot=simpleName.lastIndexOf(".")
+      Decl: simpleName=getName()
+      Decl: dot=simpleName.lastIndexOf(".")
       cond-branch cond:dot GT 0
       true branch :
         return simpleName.substring(simpleName.lastIndexOf(".") Add 1)
@@ -46,9 +45,21 @@ class  Class
     func  getTypeName()  throws: 
       cond-branch cond:isArray()
       true branch :
-        var:cl=this
+        Decl: cl=this
+        Decl: dimensions=0
+        while cl.isArray()          dimensions Inc
+
+          cl Assign cl.getComponentType()
+
+        Decl: sb=new StringBuilder()
+        sb.append(cl.getName())
+        for ( )
+          sb.append("[]")
 
+        return sb.toString()
 
+        Throwable
+        e
 
       false branch :
 
@@ -56,27 +67,28 @@ class  Class
     func  getCanonicalName()  throws: 
       cond-branch cond:isArray()
       true branch :
-        var:canonicalName=
+        Decl: canonicalName=getComponentType().getCanonicalName()
         cond-branch cond:canonicalName NE null
         true branch :
-          return canonicalName Add "[]"
-        false branch :
+          return canonicalName Add "[]"        false branch :
           return null
-
       false branch :
 
       cond-branch cond:isLocalOrAnonymousClass()
       true branch :
-        return null
-      false branch :
+        return null      false branch :
 
-      var:enclosingClass=getEnclosingClass()
+      Decl: enclosingClass=getEnclosingClass()
       cond-branch cond:enclosingClass EQ null
       true branch :
         return getName()
       false branch :
-        var:enclosingName=enclosingClass.getCanonicalName()
+        Decl: enclosingName=enclosingClass.getCanonicalName()
+        cond-branch cond:enclosingName EQ null
+        true branch :
+          return null        false branch :
 
+        return enclosingName Add "." Add getSimpleName()
 
     func  isAnonymousClass()  throws: 
     func  isLocalClass()  throws: 
@@ -86,7 +98,7 @@ class  Class
     func  isLocalOrAnonymousClass()  throws: 
       return isLocalClass() Lor isAnonymousClass()
     func  getClasses()  throws: 
-      var:result=new ArrayList<Class>
+      Decl: result=new ArrayList()
       for ( )
         Class
         member
@@ -100,27 +112,27 @@ class  Class
 
       return result.toArray(Class,result.size())
     func  getFields()  throws:     SecurityException
-      var:fields=new ArrayList<Field>
+      Decl: fields=new ArrayList()
       getPublicFieldsRecursive(fields)
       return fields.toArray(Field,fields.size())
-    func  getPublicFieldsRecursive()  throws: 
+    func  getPublicFieldsRecursive(result)  throws: 
       for ( )
         Collections.addAll(result,c.getPublicDeclaredFields())
 
-      var:iftable=ifTable
+      Decl: iftable=ifTable
       cond-branch cond:iftable NE null
       true branch :
         for ( )
-          Collections.addAll(result,((Class))getPublicDeclaredFields)
+          Collections.addAll(result,(Class).getPublicDeclaredFields())
 
       false branch :
 
     func  getMethods()  throws:     SecurityException
-      var:methods=new ArrayList<Method>
+      Decl: methods=new ArrayList()
       getPublicMethodsInternal(methods)
       CollectionUtils.removeDuplicates(methods,Method.ORDER_BY_SIGNATURE)
       return methods.toArray(Method,methods.size())
-    func  getPublicMethodsInternal()  throws: 
+    func  getPublicMethodsInternal(result)  throws: 
       Collections.addAll(result,getDeclaredMethodsUnchecked(true))
       cond-branch cond:isInterface()
       true branch :
@@ -129,40 +141,40 @@ class  Class
 
       false branch :
 
-      var:iftable=ifTable
+      Decl: iftable=ifTable
       cond-branch cond:iftable NE null
       true branch :
         for ( )
-          var:ifc=(Class)
+          Decl: ifc=(Class)
           Collections.addAll(result,ifc.getDeclaredMethodsUnchecked(true))
 
       false branch :
 
     func  getConstructors()  throws:     SecurityException
       return getDeclaredConstructorsInternal(true)
-    func  getField()  throws:     NoSuchFieldException
+    func  getField(name)  throws:     NoSuchFieldException
       cond-branch cond:name EQ null
       true branch :
-        new NullPointerException<NullPointerException>
+        new NullPointerException("name == null")
       false branch :
 
-      var:result=getPublicFieldRecursive(name)
+      Decl: result=getPublicFieldRecursive(name)
       cond-branch cond:result EQ null
       true branch :
-        new NoSuchFieldException<NoSuchFieldException>
+        new NoSuchFieldException(name)
       false branch :
 
       return result
-    func  getPublicFieldRecursive()  throws: 
-    func  getMethod()  throws:     NoSuchMethodException    SecurityException
+    func  getPublicFieldRecursive(name)  throws: 
+    func  getMethod(name,parameterTypes)  throws:     NoSuchMethodException    SecurityException
       return getMethod(name,parameterTypes,true)
-    func  getConstructor()  throws:     NoSuchMethodException    SecurityException
+    func  getConstructor(parameterTypes)  throws:     NoSuchMethodException    SecurityException
       return getConstructor0(parameterTypes,Member.PUBLIC)
     func  getDeclaredClasses()  throws: 
     func  getDeclaredFields()  throws: 
-    func  getDeclaredFieldsUnchecked()  throws: 
+    func  getDeclaredFieldsUnchecked(publicOnly)  throws: 
     func  getDeclaredMethods()  throws:     SecurityException
-      var:result=getDeclaredMethodsUnchecked(false)
+      Decl: result=getDeclaredMethodsUnchecked(false)
       Method
       m
       result
@@ -170,18 +182,18 @@ class  Class
       m.getParameterTypes()
 
       return result
-    func  getDeclaredMethodsUnchecked()  throws: 
+    func  getDeclaredMethodsUnchecked(publicOnly)  throws: 
     func  getDeclaredConstructors()  throws:     SecurityException
       return getDeclaredConstructorsInternal(false)
-    func  getDeclaredConstructorsInternal()  throws: 
-    func  getDeclaredField()  throws:     NoSuchFieldException
+    func  getDeclaredConstructorsInternal(publicOnly)  throws: 
+    func  getDeclaredField(name)  throws:     NoSuchFieldException
     func  getPublicDeclaredFields()  throws: 
-    func  getDeclaredMethod()  throws:     NoSuchMethodException    SecurityException
+    func  getDeclaredMethod(name,parameterTypes)  throws:     NoSuchMethodException    SecurityException
       return getMethod(name,parameterTypes,false)
-    func  getMethod()  throws:     NoSuchMethodException
+    func  getMethod(name,parameterTypes,recursivePublicMethods)  throws:     NoSuchMethodException
       cond-branch cond:name EQ null
       true branch :
-        new NullPointerException<NullPointerException>
+        new NullPointerException("name == null")
       false branch :
 
       cond-branch cond:parameterTypes EQ null
@@ -189,17 +201,25 @@ class  Class
         parameterTypes Assign EmptyArray.CLASS
       false branch :
 
+      Class
+      c
+      parameterTypes
+      cond-branch cond:c EQ null
+      true branch :
+        new NoSuchMethodException("parameter type is null")
+      false branch :
+
 
-      var:result=
+      Decl: result=
       cond-branch cond:result EQ null Lor (recursivePublicMethods Land Modifier.isPublic(result.getAccessFlags()))
       true branch :
-        new NoSuchMethodException<NoSuchMethodException>
+        new NoSuchMethodException(name Add " " Add Arrays.toString(parameterTypes))
       false branch :
 
       return result
-    func  getPublicMethodRecursive()  throws: 
+    func  getPublicMethodRecursive(name,parameterTypes)  throws: 
       for ( )
-        var:result=c.getDeclaredMethodInternal(name,parameterTypes)
+        Decl: result=c.getDeclaredMethodInternal(name,parameterTypes)
         cond-branch cond:result NE null Land Modifier.isPublic(result.getAccessFlags())
         true branch :
           return result
@@ -207,9 +227,9 @@ class  Class
 
 
       return findInterfaceMethod(name,parameterTypes)
-    func  getInstanceMethod()  throws:     NoSuchMethodException    IllegalAccessException
+    func  getInstanceMethod(name,parameterTypes)  throws:     NoSuchMethodException    IllegalAccessException
       for ( )
-        var:result=c.getDeclaredMethodInternal(name,parameterTypes)
+        Decl: result=c.getDeclaredMethodInternal(name,parameterTypes)
         cond-branch cond:result NE null Land Modifier.isStatic(result.getModifiers())
         true branch :
           return result
@@ -217,31 +237,36 @@ class  Class
 
 
       return findInterfaceMethod(name,parameterTypes)
-    func  findInterfaceMethod()  throws: 
-      var:iftable=ifTable
+    func  findInterfaceMethod(name,parameterTypes)  throws: 
+      Decl: iftable=ifTable
       cond-branch cond:iftable NE null
       true branch :
         for ( )
-          var:ifc=(Class)
+          Decl: ifc=(Class)
+          Decl: result=ifc.getPublicMethodRecursive(name,parameterTypes)
+          cond-branch cond:result NE null Land Modifier.isPublic(result.getAccessFlags())
+          true branch :
+            return result
+          false branch :
 
 
       false branch :
 
       return null
-    func  getDeclaredConstructor()  throws:     NoSuchMethodException    SecurityException
+    func  getDeclaredConstructor(parameterTypes)  throws:     NoSuchMethodException    SecurityException
       return getConstructor0(parameterTypes,Member.DECLARED)
-    func  getResourceAsStream()  throws: 
+    func  getResourceAsStream(name)  throws: 
       name Assign resolveName(name)
-      var:cl=getClassLoader()
+      Decl: cl=getClassLoader()
       cond-branch cond:cl EQ null
       true branch :
         return ClassLoader.getSystemResourceAsStream(name)
       false branch :
 
       return cl.getResourceAsStream(name)
-    func  getResource()  throws: 
+    func  getResource(name)  throws: 
       name Assign resolveName(name)
-      var:cl=getClassLoader()
+      Decl: cl=getClassLoader()
       cond-branch cond:cl EQ null
       true branch :
         return ClassLoader.getSystemResource(name)
@@ -250,7 +275,7 @@ class  Class
       return cl.getResource(name)
     func  getProtectionDomain()  throws: 
       return null
-    func  resolveName()  throws: 
+    func  resolveName(name)  throws: 
       cond-branch cond:name EQ null
       true branch :
         return name
@@ -258,13 +283,21 @@ class  Class
 
       cond-branch cond:name.startsWith("/")
       true branch :
-        var:c=this
+        Decl: c=this
+        while c.isArray()          c Assign c.getComponentType()
+
+        Decl: baseName=c.getName()
+        Decl: index=baseName.lastIndexOf(.)
+        cond-branch cond:index NE -1
+        true branch :
+          name Assign baseName.substring(0,index).replace(.,/) Add "/" Add name
+        false branch :
 
       false branch :
         name Assign name.substring(1)
 
       return name
-    func  getConstructor0()  throws:     NoSuchMethodException
+    func  getConstructor0(parameterTypes,which)  throws:     NoSuchMethodException
       cond-branch cond:parameterTypes EQ null
       true branch :
         parameterTypes Assign EmptyArray.CLASS
@@ -275,53 +308,49 @@ class  Class
       parameterTypes
       cond-branch cond:c EQ null
       true branch :
-        new NoSuchMethodException<NoSuchMethodException>
+        new NoSuchMethodException("parameter type is null")
       false branch :
 
 
-      var:result=getDeclaredConstructorInternal(parameterTypes)
+      Decl: result=getDeclaredConstructorInternal(parameterTypes)
       cond-branch cond:result EQ null Lor which EQ Member.PUBLIC Land Modifier.isPublic(result.getAccessFlags())
       true branch :
-        new NoSuchMethodException<NoSuchMethodException>
+        new NoSuchMethodException("<init> " Add Arrays.toString(parameterTypes))
       false branch :
 
       return result
-    func  getDeclaredConstructorInternal()  throws: 
+    func  getDeclaredConstructorInternal(args)  throws: 
     func  desiredAssertionStatus()  throws: 
       return false
     func  getInnerClassName()  throws: 
-    func  getInnerClassFlags()  throws: 
+    func  getInnerClassFlags(defaultValue)  throws: 
     func  isEnum()  throws: 
-      return ( Band ENUM) NE 0 Land  EQ java.lang.Enum
+      return (this.getModifiers() Band ENUM) NE 0 Land this.getSuperclass() EQ java.lang.Enum
     func  getEnumConstants()  throws: 
-      var:values=getEnumConstantsShared()
+      Decl: values=getEnumConstantsShared()
       return 
     func  getEnumConstantsShared()  throws: 
       cond-branch cond:isEnum()
       true branch :
-        return null
-      false branch :
+        return null      false branch :
 
       return (T[])Enum.getSharedConstants((Class)this)
-    func  cast()  throws: 
+    func  cast(obj)  throws: 
       cond-branch cond:obj NE null Land isInstance(obj)
       true branch :
-        new ClassCastException<ClassCastException>
-      false branch :
+        new ClassCastException(cannotCastMsg(obj))      false branch :
 
       return (T)obj
-    func  cannotCastMsg()  throws: 
-      return "Cannot cast " Add  Add " to " Add getName()
-    func  asSubclass()  throws: 
+    func  cannotCastMsg(obj)  throws: 
+      return "Cannot cast " Add obj.getClass().getName() Add " to " Add getName()
+    func  asSubclass(clazz)  throws: 
       cond-branch cond:clazz.isAssignableFrom(this)
       true branch :
-        return ()this
-      false branch :
-        new ClassCastException<ClassCastException>
-
-    func  getAnnotation()  throws: 
+        return ()this      false branch :
+        new ClassCastException(this.toString() Add " cannot be cast to " Add clazz.getName())
+    func  getAnnotation(annotationClass)  throws: 
       Objects.requireNonNull(annotationClass)
-      var:annotation=getDeclaredAnnotation(annotationClass)
+      Decl: annotation=getDeclaredAnnotation(annotationClass)
       cond-branch cond:annotation NE null
       true branch :
         return annotation
@@ -340,10 +369,10 @@ class  Class
       false branch :
 
       return null
-    func  isAnnotationPresent()  throws: 
+    func  isAnnotationPresent(annotationClass)  throws: 
       cond-branch cond:annotationClass EQ null
       true branch :
-        new NullPointerException<NullPointerException>
+        new NullPointerException("annotationClass == null")
       false branch :
 
       cond-branch cond:isDeclaredAnnotationPresent(annotationClass)
@@ -363,8 +392,8 @@ class  Class
       false branch :
 
       return false
-    func  getAnnotationsByType()  throws: 
-      var:annotations=
+    func  getAnnotationsByType(annotationClass)  throws: 
+      Decl: annotations=
       cond-branch cond:annotations.length NE 0
       true branch :
         return annotations
@@ -372,7 +401,7 @@ class  Class
 
       cond-branch cond:annotationClass.isDeclaredAnnotationPresent(Inherited)
       true branch :
-        var:superClass=getSuperclass()
+        Decl: superClass=getSuperclass()
         cond-branch cond:superClass NE null
         true branch :
           return superClass.getAnnotationsByType(annotationClass)
@@ -382,7 +411,7 @@ class  Class
 
       return (A[])Array.newInstance(annotationClass,0)
     func  getAnnotations()  throws: 
-      var:map=new HashMap<Class,Annotation>
+      Decl: map=new HashMap()
       Annotation
       declaredAnnotation
       getDeclaredAnnotations()
@@ -392,7 +421,7 @@ class  Class
         Annotation
         declaredAnnotation
         sup.getDeclaredAnnotations()
-        var:clazz=declaredAnnotation.annotationType()
+        Decl: clazz=declaredAnnotation.annotationType()
         cond-branch cond:map.containsKey(clazz) Land clazz.isDeclaredAnnotationPresent(Inherited)
         true branch :
           map.put(clazz,declaredAnnotation)
@@ -400,19 +429,23 @@ class  Class
 
 
 
-      var:coll=map.values()
+      Decl: coll=map.values()
       return coll.toArray(Annotation,coll.size())
-    func  getDeclaredAnnotation()  throws: 
+    func  getDeclaredAnnotation(annotationClass)  throws: 
     func  getDeclaredAnnotations()  throws: 
-    func  isDeclaredAnnotationPresent()  throws: 
+    func  isDeclaredAnnotationPresent(annotationClass)  throws: 
     func  getSignatureAttribute()  throws: 
-      var:annotation=getSignatureAnnotation()
+      Decl: annotation=getSignatureAnnotation()
       cond-branch cond:annotation EQ null
       true branch :
         return null
       false branch :
 
-      var:result=new StringBuilder<StringBuilder>
+      Decl: result=new StringBuilder()
+      String
+      s
+      annotation
+      result.append(s)
 
       return result.toString()
     func  getSignatureAnnotation()  throws: 
@@ -420,11 +453,11 @@ class  Class
       return (accessFlags Band 262144) NE 0
     func  getAccessFlags()  throws: 
       return accessFlags
-    func  getDeclaredMethodInternal()  throws: 
+    func  getDeclaredMethodInternal(name,args)  throws: 
   LocalClasses: 
     class  Caches
       Fields: 
-        genericInterfaces=new BasicLruCache<Class,Type[]>
+        genericInterfaces=new BasicLruCache(8)
       Instance Initializer: 
       Constructors: 
       Methods: 
@@ -434,7 +467,13 @@ class  Class
 
 Identifier:Method has no decl.
 Identifier:m has no decl.
+Identifier:result has no decl.
+Identifier:Class has no decl.
+Identifier:c has no decl.
 Identifier:Class has no decl.
 Identifier:c has no decl.
 Identifier:Annotation has no decl.
 Identifier:declaredAnnotation has no decl.
+Identifier:String has no decl.
+Identifier:s has no decl.
+Identifier:annotation has no decl.
diff --git a/src/MapleFE/test/openjdk/Class-3.java b/src/MapleFE/test/java/openjdk/Class-3.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Class-3.java
rename to src/MapleFE/test/java/openjdk/Class-3.java
diff --git a/src/MapleFE/test/openjdk/Class-3.java.result b/src/MapleFE/test/java/openjdk/Class-3.java.result
similarity index 81%
rename from src/MapleFE/test/openjdk/Class-3.java.result
rename to src/MapleFE/test/java/openjdk/Class-3.java.result
index f9098f16aa989f15fb7789e7587fb0d2d603431b..2d303b495bbeb5dff8564b3783c1e40a45e94e90 100644
--- a/src/MapleFE/test/openjdk/Class-3.java.result
+++ b/src/MapleFE/test/java/openjdk/Class-3.java.result
@@ -8,7 +8,7 @@ class  Class
   Constructors: 
   Methods: 
     func  getDeclaredMethods()  throws: 
-      var:result=getDeclaredMethodsUnchecked(false)
+      Decl: result=getDeclaredMethodsUnchecked(false)
       Method
       m
       result
@@ -20,3 +20,4 @@ class  Class
 
 Identifier:Method has no decl.
 Identifier:m has no decl.
+Identifier:result has no decl.
diff --git a/src/MapleFE/test/openjdk/Class.java b/src/MapleFE/test/java/openjdk/Class.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Class.java
rename to src/MapleFE/test/java/openjdk/Class.java
diff --git a/src/MapleFE/test/openjdk/Class.java.result b/src/MapleFE/test/java/openjdk/Class.java.result
similarity index 62%
rename from src/MapleFE/test/openjdk/Class.java.result
rename to src/MapleFE/test/java/openjdk/Class.java.result
index d955278969e86f51936a20429807dc3ecf5a320d..15d929fa9918f9b0f835856e0fdb4ab78a8040f6 100644
--- a/src/MapleFE/test/openjdk/Class.java.result
+++ b/src/MapleFE/test/java/openjdk/Class.java.result
@@ -111,30 +111,82 @@ class  Class
       true branch :
         return toString()
       false branch :
-        var:sb=new StringBuilder<StringBuilder>
+        Decl: sb=new StringBuilder()
+        Decl: modifiers=getModifiers() Band Modifier.classModifiers()
+        cond-branch cond:modifiers NE 0
+        true branch :
+          sb.append(Modifier.toString(modifiers))
+          sb.append( )
+        false branch :
 
+        cond-branch cond:isAnnotation()
+        true branch :
+          sb.append(@)
+        false branch :
 
-    func  forName()  throws:     ClassNotFoundException
+        cond-branch cond:isInterface()
+        true branch :
+          sb.append("interface")
+        false branch :
+          cond-branch cond:isEnum()
+          true branch :
+            sb.append("enum")          false branch :
+            sb.append("class")
+
+        sb.append( )
+        sb.append(getName())
+        Decl: typeparms=getTypeParameters()
+        cond-branch cond:typeparms.length GT 0
+        true branch :
+          Decl: first=true
+          sb.append(<)
+          TypeVariable
+          typeparm
+          typeparms
+          cond-branch cond:first
+          true branch :
+            sb.append(,)          false branch :
+
+          sb.append(typeparm.getTypeName())
+          first Assign false
+
+          sb.append(>)
+        false branch :
+
+        return sb.toString()
+
+    func  forName(className)  throws:     ClassNotFoundException
       return forName(className,true,VMStack.getCallingClassLoader())
-    func  forName()  throws:     ClassNotFoundException
+    func  forName(name,initialize,loader)  throws:     ClassNotFoundException
       cond-branch cond:loader EQ null
       true branch :
         loader Assign BootClassLoader.getInstance()
       false branch :
 
-      var:result
+      Decl: result
+      result Assign classForName(name,initialize,loader)
+
+      ClassNotFoundException
+      e
+      Decl: cause=e.getCause()
+      cond-branch cond:cause instanceof LinkageError
+      true branch :
+        (LinkageError)cause
+      false branch :
+
+      e
 
       return result
-    func  classForName()  throws:     ClassNotFoundException
+    func  classForName(className,shouldInitialize,classLoader)  throws:     ClassNotFoundException
     func  newInstance()  throws:     InstantiationException    IllegalAccessException
-    func  isInstance()  throws: 
+    func  isInstance(obj)  throws: 
       cond-branch cond:obj EQ null
       true branch :
         return false
       false branch :
 
       return isAssignableFrom(obj.getClass())
-    func  isAssignableFrom()  throws: 
+    func  isAssignableFrom(cls)  throws: 
       cond-branch cond:this EQ cls
       true branch :
         return true
@@ -149,8 +201,19 @@ class  Class
           false branch :
             cond-branch cond:isInterface()
             true branch :
-              var:iftable=cls.ifTable
+              Decl: iftable=cls.ifTable
+              cond-branch cond:iftable NE null
+              true branch :
+                for ( )
+                  cond-branch cond: EQ this
+                  true branch :
+                    return true
+                  false branch :
+
 
+              false branch :
+
+              return false
             false branch :
               cond-branch cond:cls.isInterface()
               true branch :
@@ -165,9 +228,6 @@ class  Class
 
               return false
 
-
-
-
     func  isInterface()  throws: 
       return (accessFlags Band Modifier.INTERFACE) NE 0
     func  isArray()  throws: 
@@ -181,11 +241,10 @@ class  Class
     func  isSynthetic()  throws: 
       return (getModifiers() Band SYNTHETIC) NE 0
     func  getName()  throws: 
-      var:name=this.name
+      Decl: name=this.name
       cond-branch cond:name EQ null
       true branch :
-        this.name Assign name Assign getNameNative()
-      false branch :
+        this.name Assign name Assign getNameNative()      false branch :
 
       return name
     func  getNameNative()  throws: 
@@ -197,13 +256,13 @@ class  Class
 
       return 
     func  getTypeParameters()  throws: 
-      var:annotationSignature=getSignatureAttribute()
+      Decl: annotationSignature=getSignatureAttribute()
       cond-branch cond:annotationSignature EQ null
       true branch :
         return EmptyArray.TYPE_VARIABLE
       false branch :
 
-      var:parser=new GenericSignatureParser<GenericSignatureParser>
+      Decl: parser=new GenericSignatureParser(getClassLoader())
       parser.parseForClass(this,annotationSignature)
       return parser.formalTypeParameters
     func  getSuperclass()  throws: 
@@ -214,32 +273,33 @@ class  Class
         return superClass
 
     func  getGenericSuperclass()  throws: 
-      var:genericSuperclass=getSuperclass()
+      Decl: genericSuperclass=getSuperclass()
       cond-branch cond:genericSuperclass EQ null
       true branch :
         return null
       false branch :
 
-      var:annotationSignature=getSignatureAttribute()
+      Decl: annotationSignature=getSignatureAttribute()
       cond-branch cond:annotationSignature NE null
       true branch :
-        var:parser=new GenericSignatureParser<GenericSignatureParser>
-
+        Decl: parser=new GenericSignatureParser(getClassLoader())
+        parser.parseForClass(this,annotationSignature)
+        genericSuperclass Assign parser.superclassType
       false branch :
 
       return Types.getType(genericSuperclass)
     func  getPackage()  throws: 
-      var:loader=getClassLoader()
+      Decl: loader=getClassLoader()
       cond-branch cond:loader NE null
       true branch :
-        var:packageName=getPackageName$()
+        Decl: packageName=getPackageName$()
         return 
       false branch :
 
       return null
     func  getPackageName$()  throws: 
-      var:name=getName()
-      var:last=name.lastIndexOf(.)
+      Decl: name=getName()
+      Decl: last=name.lastIndexOf(.)
       return 
     func  getInterfaces()  throws: 
       cond-branch cond:isArray()
@@ -247,7 +307,7 @@ class  Class
         return 
       false branch :
 
-      var:ifaces=getInterfacesInternal()
+      Decl: ifaces=getInterfacesInternal()
       cond-branch cond:ifaces EQ null
       true branch :
         return EmptyArray.CLASS
@@ -256,13 +316,20 @@ class  Class
       return ifaces
     func  getInterfacesInternal()  throws: 
     func  getGenericInterfaces()  throws: 
-      var:result
-      Caches.genericInterfaces
+      Decl: result
       result Assign Caches.genericInterfaces.get(this)
       cond-branch cond:result EQ null
       true branch :
-        var:annotationSignature=getSignatureAttribute()
+        Decl: annotationSignature=getSignatureAttribute()
+        cond-branch cond:annotationSignature EQ null
+        true branch :
+          result Assign getInterfaces()
+        false branch :
+          Decl: parser=new GenericSignatureParser(getClassLoader())
+          parser.parseForClass(this,annotationSignature)
+          result Assign Types.getTypeArray(parser.interfaceTypes,false)
 
+        Caches.genericInterfaces.put(this,result)
       false branch :
 
 
@@ -272,12 +339,17 @@ class  Class
     func  getModifiers()  throws: 
       cond-branch cond:isArray()
       true branch :
-        var:componentModifiers=
+        Decl: componentModifiers=getComponentType().getModifiers()
+        cond-branch cond:(componentModifiers Band Modifier.INTERFACE) NE 0
+        true branch :
+          componentModifiers BandAssign (Modifier.INTERFACE Bor Modifier.STATIC)
+        false branch :
 
+        return Modifier.ABSTRACT Bor Modifier.FINAL Bor componentModifiers
       false branch :
 
-      var:JAVA_FLAGS_MASK=65535
-      var:modifiers=
+      Decl: JAVA_FLAGS_MASK=65535
+      Decl: modifiers=this.getInnerClassFlags(accessFlags Band JAVA_FLAGS_MASK)
       return modifiers Band JAVA_FLAGS_MASK
     func  getSigners()  throws: 
       return null
@@ -298,14 +370,13 @@ class  Class
       return getEnclosingConstructorNative()
     func  getEnclosingConstructorNative()  throws: 
     func  classNameImpliesTopLevel()  throws: 
-      return 
+      return getName().contains("$")
     func  getDeclaringClass()  throws: 
     func  getEnclosingClass()  throws: 
     func  getSimpleName()  throws: 
       cond-branch cond:isArray()
       true branch :
-        return  Add "[]"
-      false branch :
+        return getComponentType().getSimpleName() Add "[]"      false branch :
 
       cond-branch cond:isAnonymousClass()
       true branch :
@@ -317,8 +388,8 @@ class  Class
         return getInnerClassName()
       false branch :
 
-      var:simpleName=getName()
-      var:dot=simpleName.lastIndexOf(".")
+      Decl: simpleName=getName()
+      Decl: dot=simpleName.lastIndexOf(".")
       cond-branch cond:dot GT 0
       true branch :
         return simpleName.substring(simpleName.lastIndexOf(".") Add 1)
@@ -328,9 +399,21 @@ class  Class
     func  getTypeName()  throws: 
       cond-branch cond:isArray()
       true branch :
-        var:cl=this
+        Decl: cl=this
+        Decl: dimensions=0
+        while cl.isArray()          dimensions Inc
+
+          cl Assign cl.getComponentType()
+
+        Decl: sb=new StringBuilder()
+        sb.append(cl.getName())
+        for ( )
+          sb.append("[]")
 
+        return sb.toString()
 
+        Throwable
+        e
 
       false branch :
 
@@ -338,27 +421,28 @@ class  Class
     func  getCanonicalName()  throws: 
       cond-branch cond:isArray()
       true branch :
-        var:canonicalName=
+        Decl: canonicalName=getComponentType().getCanonicalName()
         cond-branch cond:canonicalName NE null
         true branch :
-          return canonicalName Add "[]"
-        false branch :
+          return canonicalName Add "[]"        false branch :
           return null
-
       false branch :
 
       cond-branch cond:isLocalOrAnonymousClass()
       true branch :
-        return null
-      false branch :
+        return null      false branch :
 
-      var:enclosingClass=getEnclosingClass()
+      Decl: enclosingClass=getEnclosingClass()
       cond-branch cond:enclosingClass EQ null
       true branch :
         return getName()
       false branch :
-        var:enclosingName=enclosingClass.getCanonicalName()
+        Decl: enclosingName=enclosingClass.getCanonicalName()
+        cond-branch cond:enclosingName EQ null
+        true branch :
+          return null        false branch :
 
+        return enclosingName Add "." Add getSimpleName()
 
     func  isAnonymousClass()  throws: 
     func  isLocalClass()  throws: 
@@ -368,7 +452,7 @@ class  Class
     func  isLocalOrAnonymousClass()  throws: 
       return isLocalClass() Lor isAnonymousClass()
     func  getClasses()  throws: 
-      var:result=new ArrayList<Class>
+      Decl: result=new ArrayList()
       for ( )
         Class
         member
@@ -382,27 +466,27 @@ class  Class
 
       return result.toArray(Class,result.size())
     func  getFields()  throws:     SecurityException
-      var:fields=new ArrayList<Field>
+      Decl: fields=new ArrayList()
       getPublicFieldsRecursive(fields)
       return fields.toArray(Field,fields.size())
-    func  getPublicFieldsRecursive()  throws: 
+    func  getPublicFieldsRecursive(result)  throws: 
       for ( )
         Collections.addAll(result,c.getPublicDeclaredFields())
 
-      var:iftable=ifTable
+      Decl: iftable=ifTable
       cond-branch cond:iftable NE null
       true branch :
         for ( )
-          Collections.addAll(result,((Class))getPublicDeclaredFields)
+          Collections.addAll(result,(Class).getPublicDeclaredFields())
 
       false branch :
 
     func  getMethods()  throws:     SecurityException
-      var:methods=new ArrayList<Method>
+      Decl: methods=new ArrayList()
       getPublicMethodsInternal(methods)
       CollectionUtils.removeDuplicates(methods,Method.ORDER_BY_SIGNATURE)
       return methods.toArray(Method,methods.size())
-    func  getPublicMethodsInternal()  throws: 
+    func  getPublicMethodsInternal(result)  throws: 
       Collections.addAll(result,getDeclaredMethodsUnchecked(true))
       cond-branch cond:isInterface()
       true branch :
@@ -411,40 +495,40 @@ class  Class
 
       false branch :
 
-      var:iftable=ifTable
+      Decl: iftable=ifTable
       cond-branch cond:iftable NE null
       true branch :
         for ( )
-          var:ifc=(Class)
+          Decl: ifc=(Class)
           Collections.addAll(result,ifc.getDeclaredMethodsUnchecked(true))
 
       false branch :
 
     func  getConstructors()  throws:     SecurityException
       return getDeclaredConstructorsInternal(true)
-    func  getField()  throws:     NoSuchFieldException
+    func  getField(name)  throws:     NoSuchFieldException
       cond-branch cond:name EQ null
       true branch :
-        new NullPointerException<NullPointerException>
+        new NullPointerException("name == null")
       false branch :
 
-      var:result=getPublicFieldRecursive(name)
+      Decl: result=getPublicFieldRecursive(name)
       cond-branch cond:result EQ null
       true branch :
-        new NoSuchFieldException<NoSuchFieldException>
+        new NoSuchFieldException(name)
       false branch :
 
       return result
-    func  getPublicFieldRecursive()  throws: 
-    func  getMethod()  throws:     NoSuchMethodException    SecurityException
+    func  getPublicFieldRecursive(name)  throws: 
+    func  getMethod(name,parameterTypes)  throws:     NoSuchMethodException    SecurityException
       return getMethod(name,parameterTypes,true)
-    func  getConstructor()  throws:     NoSuchMethodException    SecurityException
+    func  getConstructor(parameterTypes)  throws:     NoSuchMethodException    SecurityException
       return getConstructor0(parameterTypes,Member.PUBLIC)
     func  getDeclaredClasses()  throws: 
     func  getDeclaredFields()  throws: 
-    func  getDeclaredFieldsUnchecked()  throws: 
+    func  getDeclaredFieldsUnchecked(publicOnly)  throws: 
     func  getDeclaredMethods()  throws:     SecurityException
-      var:result=getDeclaredMethodsUnchecked(false)
+      Decl: result=getDeclaredMethodsUnchecked(false)
       Method
       m
       result
@@ -452,18 +536,18 @@ class  Class
       m.getParameterTypes()
 
       return result
-    func  getDeclaredMethodsUnchecked()  throws: 
+    func  getDeclaredMethodsUnchecked(publicOnly)  throws: 
     func  getDeclaredConstructors()  throws:     SecurityException
       return getDeclaredConstructorsInternal(false)
-    func  getDeclaredConstructorsInternal()  throws: 
-    func  getDeclaredField()  throws:     NoSuchFieldException
+    func  getDeclaredConstructorsInternal(publicOnly)  throws: 
+    func  getDeclaredField(name)  throws:     NoSuchFieldException
     func  getPublicDeclaredFields()  throws: 
-    func  getDeclaredMethod()  throws:     NoSuchMethodException    SecurityException
+    func  getDeclaredMethod(name,parameterTypes)  throws:     NoSuchMethodException    SecurityException
       return getMethod(name,parameterTypes,false)
-    func  getMethod()  throws:     NoSuchMethodException
+    func  getMethod(name,parameterTypes,recursivePublicMethods)  throws:     NoSuchMethodException
       cond-branch cond:name EQ null
       true branch :
-        new NullPointerException<NullPointerException>
+        new NullPointerException("name == null")
       false branch :
 
       cond-branch cond:parameterTypes EQ null
@@ -471,17 +555,25 @@ class  Class
         parameterTypes Assign EmptyArray.CLASS
       false branch :
 
+      Class
+      c
+      parameterTypes
+      cond-branch cond:c EQ null
+      true branch :
+        new NoSuchMethodException("parameter type is null")
+      false branch :
+
 
-      var:result=
+      Decl: result=
       cond-branch cond:result EQ null Lor (recursivePublicMethods Land Modifier.isPublic(result.getAccessFlags()))
       true branch :
-        new NoSuchMethodException<NoSuchMethodException>
+        new NoSuchMethodException(name Add " " Add Arrays.toString(parameterTypes))
       false branch :
 
       return result
-    func  getPublicMethodRecursive()  throws: 
+    func  getPublicMethodRecursive(name,parameterTypes)  throws: 
       for ( )
-        var:result=c.getDeclaredMethodInternal(name,parameterTypes)
+        Decl: result=c.getDeclaredMethodInternal(name,parameterTypes)
         cond-branch cond:result NE null Land Modifier.isPublic(result.getAccessFlags())
         true branch :
           return result
@@ -489,9 +581,9 @@ class  Class
 
 
       return findInterfaceMethod(name,parameterTypes)
-    func  getInstanceMethod()  throws:     NoSuchMethodException    IllegalAccessException
+    func  getInstanceMethod(name,parameterTypes)  throws:     NoSuchMethodException    IllegalAccessException
       for ( )
-        var:result=c.getDeclaredMethodInternal(name,parameterTypes)
+        Decl: result=c.getDeclaredMethodInternal(name,parameterTypes)
         cond-branch cond:result NE null Land Modifier.isStatic(result.getModifiers())
         true branch :
           return result
@@ -499,31 +591,36 @@ class  Class
 
 
       return findInterfaceMethod(name,parameterTypes)
-    func  findInterfaceMethod()  throws: 
-      var:iftable=ifTable
+    func  findInterfaceMethod(name,parameterTypes)  throws: 
+      Decl: iftable=ifTable
       cond-branch cond:iftable NE null
       true branch :
         for ( )
-          var:ifc=(Class)
+          Decl: ifc=(Class)
+          Decl: result=ifc.getPublicMethodRecursive(name,parameterTypes)
+          cond-branch cond:result NE null Land Modifier.isPublic(result.getAccessFlags())
+          true branch :
+            return result
+          false branch :
 
 
       false branch :
 
       return null
-    func  getDeclaredConstructor()  throws:     NoSuchMethodException    SecurityException
+    func  getDeclaredConstructor(parameterTypes)  throws:     NoSuchMethodException    SecurityException
       return getConstructor0(parameterTypes,Member.DECLARED)
-    func  getResourceAsStream()  throws: 
+    func  getResourceAsStream(name)  throws: 
       name Assign resolveName(name)
-      var:cl=getClassLoader()
+      Decl: cl=getClassLoader()
       cond-branch cond:cl EQ null
       true branch :
         return ClassLoader.getSystemResourceAsStream(name)
       false branch :
 
       return cl.getResourceAsStream(name)
-    func  getResource()  throws: 
+    func  getResource(name)  throws: 
       name Assign resolveName(name)
-      var:cl=getClassLoader()
+      Decl: cl=getClassLoader()
       cond-branch cond:cl EQ null
       true branch :
         return ClassLoader.getSystemResource(name)
@@ -532,7 +629,7 @@ class  Class
       return cl.getResource(name)
     func  getProtectionDomain()  throws: 
       return null
-    func  resolveName()  throws: 
+    func  resolveName(name)  throws: 
       cond-branch cond:name EQ null
       true branch :
         return name
@@ -540,13 +637,21 @@ class  Class
 
       cond-branch cond:name.startsWith("/")
       true branch :
-        var:c=this
+        Decl: c=this
+        while c.isArray()          c Assign c.getComponentType()
+
+        Decl: baseName=c.getName()
+        Decl: index=baseName.lastIndexOf(.)
+        cond-branch cond:index NE -1
+        true branch :
+          name Assign baseName.substring(0,index).replace(.,/) Add "/" Add name
+        false branch :
 
       false branch :
         name Assign name.substring(1)
 
       return name
-    func  getConstructor0()  throws:     NoSuchMethodException
+    func  getConstructor0(parameterTypes,which)  throws:     NoSuchMethodException
       cond-branch cond:parameterTypes EQ null
       true branch :
         parameterTypes Assign EmptyArray.CLASS
@@ -557,53 +662,49 @@ class  Class
       parameterTypes
       cond-branch cond:c EQ null
       true branch :
-        new NoSuchMethodException<NoSuchMethodException>
+        new NoSuchMethodException("parameter type is null")
       false branch :
 
 
-      var:result=getDeclaredConstructorInternal(parameterTypes)
+      Decl: result=getDeclaredConstructorInternal(parameterTypes)
       cond-branch cond:result EQ null Lor which EQ Member.PUBLIC Land Modifier.isPublic(result.getAccessFlags())
       true branch :
-        new NoSuchMethodException<NoSuchMethodException>
+        new NoSuchMethodException("<init> " Add Arrays.toString(parameterTypes))
       false branch :
 
       return result
-    func  getDeclaredConstructorInternal()  throws: 
+    func  getDeclaredConstructorInternal(args)  throws: 
     func  desiredAssertionStatus()  throws: 
       return false
     func  getInnerClassName()  throws: 
-    func  getInnerClassFlags()  throws: 
+    func  getInnerClassFlags(defaultValue)  throws: 
     func  isEnum()  throws: 
-      return ( Band ENUM) NE 0 Land  EQ java.lang.Enum
+      return (this.getModifiers() Band ENUM) NE 0 Land this.getSuperclass() EQ java.lang.Enum
     func  getEnumConstants()  throws: 
-      var:values=getEnumConstantsShared()
+      Decl: values=getEnumConstantsShared()
       return 
     func  getEnumConstantsShared()  throws: 
       cond-branch cond:isEnum()
       true branch :
-        return null
-      false branch :
+        return null      false branch :
 
       return (T[])Enum.getSharedConstants((Class)this)
-    func  cast()  throws: 
+    func  cast(obj)  throws: 
       cond-branch cond:obj NE null Land isInstance(obj)
       true branch :
-        new ClassCastException<ClassCastException>
-      false branch :
+        new ClassCastException(cannotCastMsg(obj))      false branch :
 
       return (T)obj
-    func  cannotCastMsg()  throws: 
-      return "Cannot cast " Add  Add " to " Add getName()
-    func  asSubclass()  throws: 
+    func  cannotCastMsg(obj)  throws: 
+      return "Cannot cast " Add obj.getClass().getName() Add " to " Add getName()
+    func  asSubclass(clazz)  throws: 
       cond-branch cond:clazz.isAssignableFrom(this)
       true branch :
-        return ()this
-      false branch :
-        new ClassCastException<ClassCastException>
-
-    func  getAnnotation()  throws: 
+        return ()this      false branch :
+        new ClassCastException(this.toString() Add " cannot be cast to " Add clazz.getName())
+    func  getAnnotation(annotationClass)  throws: 
       Objects.requireNonNull(annotationClass)
-      var:annotation=getDeclaredAnnotation(annotationClass)
+      Decl: annotation=getDeclaredAnnotation(annotationClass)
       cond-branch cond:annotation NE null
       true branch :
         return annotation
@@ -622,10 +723,10 @@ class  Class
       false branch :
 
       return null
-    func  isAnnotationPresent()  throws: 
+    func  isAnnotationPresent(annotationClass)  throws: 
       cond-branch cond:annotationClass EQ null
       true branch :
-        new NullPointerException<NullPointerException>
+        new NullPointerException("annotationClass == null")
       false branch :
 
       cond-branch cond:isDeclaredAnnotationPresent(annotationClass)
@@ -645,8 +746,8 @@ class  Class
       false branch :
 
       return false
-    func  getAnnotationsByType()  throws: 
-      var:annotations=
+    func  getAnnotationsByType(annotationClass)  throws: 
+      Decl: annotations=
       cond-branch cond:annotations.length NE 0
       true branch :
         return annotations
@@ -654,7 +755,7 @@ class  Class
 
       cond-branch cond:annotationClass.isDeclaredAnnotationPresent(Inherited)
       true branch :
-        var:superClass=getSuperclass()
+        Decl: superClass=getSuperclass()
         cond-branch cond:superClass NE null
         true branch :
           return superClass.getAnnotationsByType(annotationClass)
@@ -664,7 +765,7 @@ class  Class
 
       return (A[])Array.newInstance(annotationClass,0)
     func  getAnnotations()  throws: 
-      var:map=new HashMap<Class,Annotation>
+      Decl: map=new HashMap()
       Annotation
       declaredAnnotation
       getDeclaredAnnotations()
@@ -674,7 +775,7 @@ class  Class
         Annotation
         declaredAnnotation
         sup.getDeclaredAnnotations()
-        var:clazz=declaredAnnotation.annotationType()
+        Decl: clazz=declaredAnnotation.annotationType()
         cond-branch cond:map.containsKey(clazz) Land clazz.isDeclaredAnnotationPresent(Inherited)
         true branch :
           map.put(clazz,declaredAnnotation)
@@ -682,19 +783,23 @@ class  Class
 
 
 
-      var:coll=map.values()
+      Decl: coll=map.values()
       return coll.toArray(Annotation,coll.size())
-    func  getDeclaredAnnotation()  throws: 
+    func  getDeclaredAnnotation(annotationClass)  throws: 
     func  getDeclaredAnnotations()  throws: 
-    func  isDeclaredAnnotationPresent()  throws: 
+    func  isDeclaredAnnotationPresent(annotationClass)  throws: 
     func  getSignatureAttribute()  throws: 
-      var:annotation=getSignatureAnnotation()
+      Decl: annotation=getSignatureAnnotation()
       cond-branch cond:annotation EQ null
       true branch :
         return null
       false branch :
 
-      var:result=new StringBuilder<StringBuilder>
+      Decl: result=new StringBuilder()
+      String
+      s
+      annotation
+      result.append(s)
 
       return result.toString()
     func  getSignatureAnnotation()  throws: 
@@ -702,11 +807,11 @@ class  Class
       return (accessFlags Band 262144) NE 0
     func  getAccessFlags()  throws: 
       return accessFlags
-    func  getDeclaredMethodInternal()  throws: 
+    func  getDeclaredMethodInternal(name,args)  throws: 
   LocalClasses: 
     class  Caches
       Fields: 
-        genericInterfaces=new BasicLruCache<Class,Type[]>
+        genericInterfaces=new BasicLruCache(8)
       Instance Initializer: 
       Constructors: 
       Methods: 
@@ -714,9 +819,20 @@ class  Class
       LocalInterfaces: 
   LocalInterfaces: 
 
+Identifier:result has no decl.
+Identifier:ClassNotFoundException has no decl.
+Identifier:e has no decl.
+Identifier:e has no decl.
+Identifier:result has no decl.
 Identifier:Method has no decl.
 Identifier:m has no decl.
+Identifier:result has no decl.
+Identifier:Class has no decl.
+Identifier:c has no decl.
 Identifier:Class has no decl.
 Identifier:c has no decl.
 Identifier:Annotation has no decl.
 Identifier:declaredAnnotation has no decl.
+Identifier:String has no decl.
+Identifier:s has no decl.
+Identifier:annotation has no decl.
diff --git a/src/MapleFE/test/openjdk/ClassCastException.java b/src/MapleFE/test/java/openjdk/ClassCastException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/ClassCastException.java
rename to src/MapleFE/test/java/openjdk/ClassCastException.java
diff --git a/src/MapleFE/test/openjdk/ClassCastException.java.result b/src/MapleFE/test/java/openjdk/ClassCastException.java.result
similarity index 72%
rename from src/MapleFE/test/openjdk/ClassCastException.java.result
rename to src/MapleFE/test/java/openjdk/ClassCastException.java.result
index f6924ba6c8d0a3f64851ac35dda1cc1f8f7b0b45..51ba376909b673710ac93cfe8dd5b9797f8df885 100644
--- a/src/MapleFE/test/openjdk/ClassCastException.java.result
+++ b/src/MapleFE/test/java/openjdk/ClassCastException.java.result
@@ -1,17 +1,16 @@
 Matched 5 tokens.
-Matched 44 tokens.
+Matched 43 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  ClassCastException
   Fields: 
-    serialVersionUID=Sub
-  832051876
+    serialVersionUID=-832051876
   Instance Initializer: 
   Constructors: 
     constructor  ClassCastException()  throws: 
-    constructor  ClassCastException()  throws: 
+    constructor  ClassCastException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/ClassCircularityError.java b/src/MapleFE/test/java/openjdk/ClassCircularityError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/ClassCircularityError.java
rename to src/MapleFE/test/java/openjdk/ClassCircularityError.java
diff --git a/src/MapleFE/test/openjdk/ClassCircularityError.java.result b/src/MapleFE/test/java/openjdk/ClassCircularityError.java.result
similarity index 86%
rename from src/MapleFE/test/openjdk/ClassCircularityError.java.result
rename to src/MapleFE/test/java/openjdk/ClassCircularityError.java.result
index 83db87477c031158210b810f224ec4191755f058..7982bbd80765a5f334f08732eab60e5f54215fcf 100644
--- a/src/MapleFE/test/openjdk/ClassCircularityError.java.result
+++ b/src/MapleFE/test/java/openjdk/ClassCircularityError.java.result
@@ -10,7 +10,7 @@ class  ClassCircularityError
   Instance Initializer: 
   Constructors: 
     constructor  ClassCircularityError()  throws: 
-    constructor  ClassCircularityError()  throws: 
+    constructor  ClassCircularityError(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/ClassFormatError.java b/src/MapleFE/test/java/openjdk/ClassFormatError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/ClassFormatError.java
rename to src/MapleFE/test/java/openjdk/ClassFormatError.java
diff --git a/src/MapleFE/test/openjdk/ClassFormatError.java.result b/src/MapleFE/test/java/openjdk/ClassFormatError.java.result
similarity index 72%
rename from src/MapleFE/test/openjdk/ClassFormatError.java.result
rename to src/MapleFE/test/java/openjdk/ClassFormatError.java.result
index 865999f63df951b27a8c2a422eb5b3a14179ec5a..2a347889ce0f2ca65e193a48128bcfd04f82f4fe 100644
--- a/src/MapleFE/test/openjdk/ClassFormatError.java.result
+++ b/src/MapleFE/test/java/openjdk/ClassFormatError.java.result
@@ -1,17 +1,16 @@
 Matched 5 tokens.
-Matched 44 tokens.
+Matched 43 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  ClassFormatError
   Fields: 
-    serialVersionUID=Sub
-  -344126837
+    serialVersionUID=344126837
   Instance Initializer: 
   Constructors: 
     constructor  ClassFormatError()  throws: 
-    constructor  ClassFormatError()  throws: 
+    constructor  ClassFormatError(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/ClassLoader.java b/src/MapleFE/test/java/openjdk/ClassLoader.java
similarity index 100%
rename from src/MapleFE/test/openjdk/ClassLoader.java
rename to src/MapleFE/test/java/openjdk/ClassLoader.java
diff --git a/src/MapleFE/test/openjdk/ClassLoader.java.result b/src/MapleFE/test/java/openjdk/ClassLoader.java.result
similarity index 57%
rename from src/MapleFE/test/openjdk/ClassLoader.java.result
rename to src/MapleFE/test/java/openjdk/ClassLoader.java.result
index 70912ebe161e0b4b5972a9499fa7f9766efb01fe..185be8e8e980c216e0e7c7636d510e71897251bf 100644
--- a/src/MapleFE/test/openjdk/ClassLoader.java.result
+++ b/src/MapleFE/test/java/openjdk/ClassLoader.java.result
@@ -115,26 +115,35 @@ import sun.security.util.SecurityConstants
 == Sub Tree ==
 class  ClassLoader
   Fields: 
-    proxyCache=new HashMap<List,Class,Class>    parent    packages=new HashMap    allocator    classTable
+    proxyCache=new HashMap()    parent    packages=new HashMap()    allocator    classTable
   Instance Initializer: 
   Constructors: 
-    constructor  ClassLoader()  throws: 
+    constructor  ClassLoader(unused,parent)  throws: 
       this.parent Assign parent
-    constructor  ClassLoader()  throws: 
+    constructor  ClassLoader(parent)  throws: 
     constructor  ClassLoader()  throws: 
   Methods: 
     func  createSystemClassLoader()  throws: 
-      var:classPath=System.getProperty("java.class.path",".")
-      var:librarySearchPath=System.getProperty("java.library.path","")
-      return new PathClassLoader<PathClassLoader>
+      Decl: classPath=System.getProperty("java.class.path",".")
+      Decl: librarySearchPath=System.getProperty("java.library.path","")
+      return new PathClassLoader(classPath,librarySearchPath,BootClassLoader.getInstance())
     func  checkCreateClassLoader()  throws: 
       return null
-    func  loadClass()  throws:     ClassNotFoundException
+    func  loadClass(name)  throws:     ClassNotFoundException
       return loadClass(name,false)
-    func  loadClass()  throws:     ClassNotFoundException
-      var:c=findLoadedClass(name)
+    func  loadClass(name,resolve)  throws:     ClassNotFoundException
+      Decl: c=findLoadedClass(name)
       cond-branch cond:c EQ null
       true branch :
+        cond-branch cond:parent NE null
+        true branch :
+          c Assign parent.loadClass(name,false)
+        false branch :
+          c Assign findBootstrapClassOrNull(name)
+
+
+        ClassNotFoundException
+        e
 
         cond-branch cond:c EQ null
         true branch :
@@ -144,33 +153,31 @@ class  ClassLoader
       false branch :
 
       return c
-    func  findClass()  throws:     ClassNotFoundException
-      new ClassNotFoundException<ClassNotFoundException>
-    func  defineClass()  throws:     ClassFormatError
-      new UnsupportedOperationException<UnsupportedOperationException>
-    func  defineClass()  throws:     ClassFormatError
-      new UnsupportedOperationException<UnsupportedOperationException>
-    func  defineClass()  throws:     ClassFormatError
-      new UnsupportedOperationException<UnsupportedOperationException>
-    func  defineClass()  throws:     ClassFormatError
-      new UnsupportedOperationException<UnsupportedOperationException>
-    func  resolveClass()  throws: 
-    func  findSystemClass()  throws:     ClassNotFoundException
+    func  findClass(name)  throws:     ClassNotFoundException
+      new ClassNotFoundException(name)
+    func  defineClass(b,off,len)  throws:     ClassFormatError
+      new UnsupportedOperationException("can't load this type of class file")
+    func  defineClass(name,b,off,len)  throws:     ClassFormatError
+      new UnsupportedOperationException("can't load this type of class file")
+    func  defineClass(name,b,off,len,protectionDomain)  throws:     ClassFormatError
+      new UnsupportedOperationException("can't load this type of class file")
+    func  defineClass(name,b,protectionDomain)  throws:     ClassFormatError
+      new UnsupportedOperationException("can't load this type of class file")
+    func  resolveClass(c)  throws: 
+    func  findSystemClass(name)  throws:     ClassNotFoundException
       return Class.forName(name,false,getSystemClassLoader())
-    func  findBootstrapClassOrNull()  throws: 
+    func  findBootstrapClassOrNull(name)  throws: 
       return null
-    func  findLoadedClass()  throws: 
-      var:loader
+    func  findLoadedClass(name)  throws: 
+      Decl: loader
       cond-branch cond:this EQ BootClassLoader.getInstance()
       true branch :
-        loader Assign null
-      false branch :
+        loader Assign null      false branch :
         loader Assign this
-
       return VMClassLoader.findLoadedClass(loader,name)
-    func  setSigners()  throws: 
-    func  getResource()  throws: 
-      var:url
+    func  setSigners(c,signers)  throws: 
+    func  getResource(name)  throws: 
+      Decl: url
       cond-branch cond:parent NE null
       true branch :
         url Assign parent.getResource(name)
@@ -183,8 +190,8 @@ class  ClassLoader
       false branch :
 
       return url
-    func  getResources()  throws:     IOException
-      var:tmp=()
+    func  getResources(name)  throws:     IOException
+      Decl: tmp=()
       cond-branch cond:parent NE null
       true branch :
          Assign parent.getResources(name)
@@ -192,70 +199,80 @@ class  ClassLoader
          Assign getBootstrapResources(name)
 
        Assign findResources(name)
-      return new CompoundEnumeration
-    func  findResource()  throws: 
+      return new CompoundEnumeration(tmp)
+    func  findResource(name)  throws: 
       return null
-    func  findResources()  throws:     IOException
+    func  findResources(name)  throws:     IOException
       return java.util.Collections.emptyEnumeration()
     func  registerAsParallelCapable()  throws: 
       return true
-    func  getSystemResource()  throws: 
-      var:system=getSystemClassLoader()
+    func  getSystemResource(name)  throws: 
+      Decl: system=getSystemClassLoader()
       cond-branch cond:system EQ null
       true branch :
         return getBootstrapResource(name)
       false branch :
 
       return system.getResource(name)
-    func  getSystemResources()  throws:     IOException
-      var:system=getSystemClassLoader()
+    func  getSystemResources(name)  throws:     IOException
+      Decl: system=getSystemClassLoader()
       cond-branch cond:system EQ null
       true branch :
         return getBootstrapResources(name)
       false branch :
 
       return system.getResources(name)
-    func  getBootstrapResource()  throws: 
+    func  getBootstrapResource(name)  throws: 
       return null
-    func  getBootstrapResources()  throws:     IOException
+    func  getBootstrapResources(name)  throws:     IOException
       return null
-    func  getResourceAsStream()  throws: 
-      var:url=getResource(name)
+    func  getResourceAsStream(name)  throws: 
+      Decl: url=getResource(name)
       return 
 
+      IOException
+      e
+      return null
 
-    func  getSystemResourceAsStream()  throws: 
-      var:url=getSystemResource(name)
+    func  getSystemResourceAsStream(name)  throws: 
+      Decl: url=getSystemResource(name)
       return 
 
+      IOException
+      e
+      return null
 
     func  getParent()  throws: 
       return parent
     func  getSystemClassLoader()  throws: 
       return SystemClassLoader.loader
-    func  definePackage()  throws:     IllegalArgumentException
-      packages
-      var:pkg=packages.get(name)
+    func  definePackage(name,specTitle,specVersion,specVendor,implTitle,implVersion,implVendor,sealBase)  throws:     IllegalArgumentException
+      Decl: pkg=packages.get(name)
+      cond-branch cond:pkg NE null
+      true branch :
+        new IllegalArgumentException(name)
+      false branch :
 
+      pkg Assign new Package(name,specTitle,specVersion,specVendor,implTitle,implVersion,implVendor,sealBase,this)
+      packages.put(name,pkg)
+      return pkg
 
-    func  getPackage()  throws: 
-      var:pkg
-      packages
+    func  getPackage(name)  throws: 
+      Decl: pkg
       pkg Assign packages.get(name)
 
       return pkg
     func  getPackages()  throws: 
-      var:map
-      packages
-      map Assign new HashMap
+      Decl: map
+      map Assign new HashMap(packages)
 
-      var:pkgs
-      return 
-    func  findLibrary()  throws: 
+      Decl: pkgs
+      return map.values().toArray(Package,map.size())
+    func  findLibrary(libname)  throws: 
       return null
-    func  setDefaultAssertionStatus()  throws: 
-    func  setPackageAssertionStatus()  throws: 
-    func  setClassAssertionStatus()  throws: 
+    func  setDefaultAssertionStatus(enabled)  throws: 
+    func  setPackageAssertionStatus(packageName,enabled)  throws: 
+    func  setClassAssertionStatus(className,enabled)  throws: 
     func  clearAssertionStatus()  throws: 
   LocalClasses: 
     class  SystemClassLoader
@@ -279,37 +296,41 @@ class  BootClassLoader
     func  getInstance()  throws: 
       cond-branch cond:instance EQ null
       true branch :
-        instance Assign new BootClassLoader<BootClassLoader>
+        instance Assign new BootClassLoader()
       false branch :
 
       return instance
-    func  findClass()  throws:     ClassNotFoundException
+    func  findClass(name)  throws:     ClassNotFoundException
       return Class.classForName(name,false,null)
-    func  findResource()  throws: 
+    func  findResource(name)  throws: 
       return VMClassLoader.getResource(name)
-    func  findResources()  throws:     IOException
+    func  findResources(resName)  throws:     IOException
       return Collections.enumeration(VMClassLoader.getResources(resName))
-    func  getPackage()  throws: 
+    func  getPackage(name)  throws: 
       cond-branch cond:name NE null Land name.isEmpty()
       true branch :
-        this
-        var:pack=
+        Decl: pack=super.getPackage(name)
+        cond-branch cond:pack EQ null
+        true branch :
+          pack Assign definePackage(name,"Unknown","0.0","Unknown","Unknown","0.0","Unknown",null)
+        false branch :
 
+        return pack
 
       false branch :
 
       return null
-    func  getResource()  throws: 
+    func  getResource(resName)  throws: 
       return findResource(resName)
-    func  loadClass()  throws:     ClassNotFoundException
-      var:clazz=findLoadedClass(className)
+    func  loadClass(className,resolve)  throws:     ClassNotFoundException
+      Decl: clazz=findLoadedClass(className)
       cond-branch cond:clazz EQ null
       true branch :
         clazz Assign findClass(className)
       false branch :
 
       return clazz
-    func  getResources()  throws:     IOException
+    func  getResources(resName)  throws:     IOException
       return findResources(resName)
   LocalClasses: 
   LocalInterfaces: 
@@ -319,4 +340,12 @@ UserType:UnsupportedOperationException has no decl.
 UserType:UnsupportedOperationException has no decl.
 UserType:UnsupportedOperationException has no decl.
 UserType:UnsupportedOperationException has no decl.
+Identifier:IOException has no decl.
+Identifier:e has no decl.
+Identifier:IOException has no decl.
+Identifier:e has no decl.
+Identifier:pkg has no decl.
+UserType:Package has no decl.
+Identifier:pkg has no decl.
+Identifier:map has no decl.
 UserType:HashMap has no decl.
diff --git a/src/MapleFE/test/openjdk/ClassNotFoundException.java b/src/MapleFE/test/java/openjdk/ClassNotFoundException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/ClassNotFoundException.java
rename to src/MapleFE/test/java/openjdk/ClassNotFoundException.java
diff --git a/src/MapleFE/test/openjdk/ClassNotFoundException.java.result b/src/MapleFE/test/java/openjdk/ClassNotFoundException.java.result
similarity index 80%
rename from src/MapleFE/test/openjdk/ClassNotFoundException.java.result
rename to src/MapleFE/test/java/openjdk/ClassNotFoundException.java.result
index 3fa59df1521e1bc42fd7830f9cb1fa2f40e2aad3..2fb746eda8dc24d8092ee275bdddd7d7cb8a4176 100644
--- a/src/MapleFE/test/openjdk/ClassNotFoundException.java.result
+++ b/src/MapleFE/test/java/openjdk/ClassNotFoundException.java.result
@@ -10,8 +10,8 @@ class  ClassNotFoundException
   Instance Initializer: 
   Constructors: 
     constructor  ClassNotFoundException()  throws: 
-    constructor  ClassNotFoundException()  throws: 
-    constructor  ClassNotFoundException()  throws: 
+    constructor  ClassNotFoundException(s)  throws: 
+    constructor  ClassNotFoundException(s,ex)  throws: 
       this.ex Assign ex
   Methods: 
     func  getException()  throws: 
diff --git a/src/MapleFE/test/openjdk/CloneNotSupportedException.java b/src/MapleFE/test/java/openjdk/CloneNotSupportedException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/CloneNotSupportedException.java
rename to src/MapleFE/test/java/openjdk/CloneNotSupportedException.java
diff --git a/src/MapleFE/test/openjdk/CloneNotSupportedException.java.result b/src/MapleFE/test/java/openjdk/CloneNotSupportedException.java.result
similarity index 85%
rename from src/MapleFE/test/openjdk/CloneNotSupportedException.java.result
rename to src/MapleFE/test/java/openjdk/CloneNotSupportedException.java.result
index e9dbfc2a87bc8c3893fa28cea8dd811e372d51c4..b63bfc1f9a54290068194a116ccfe561190c4612 100644
--- a/src/MapleFE/test/openjdk/CloneNotSupportedException.java.result
+++ b/src/MapleFE/test/java/openjdk/CloneNotSupportedException.java.result
@@ -10,7 +10,7 @@ class  CloneNotSupportedException
   Instance Initializer: 
   Constructors: 
     constructor  CloneNotSupportedException()  throws: 
-    constructor  CloneNotSupportedException()  throws: 
+    constructor  CloneNotSupportedException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/Cloneable.java b/src/MapleFE/test/java/openjdk/Cloneable.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Cloneable.java
rename to src/MapleFE/test/java/openjdk/Cloneable.java
diff --git a/src/MapleFE/test/openjdk/Cloneable.java.result b/src/MapleFE/test/java/openjdk/Cloneable.java.result
similarity index 100%
rename from src/MapleFE/test/openjdk/Cloneable.java.result
rename to src/MapleFE/test/java/openjdk/Cloneable.java.result
diff --git a/src/MapleFE/test/openjdk/Comparable.java b/src/MapleFE/test/java/openjdk/Comparable.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Comparable.java
rename to src/MapleFE/test/java/openjdk/Comparable.java
diff --git a/src/MapleFE/test/openjdk/Comparable.java.result b/src/MapleFE/test/java/openjdk/Comparable.java.result
similarity index 86%
rename from src/MapleFE/test/openjdk/Comparable.java.result
rename to src/MapleFE/test/java/openjdk/Comparable.java.result
index 2d737cec543cbff17120c020edeaa87d83f005ef..1a4f72012690673b17f68a7e024fb72ffe4548e0 100644
--- a/src/MapleFE/test/openjdk/Comparable.java.result
+++ b/src/MapleFE/test/java/openjdk/Comparable.java.result
@@ -11,5 +11,5 @@ interface  Comparable
   Fields: 
 
   Methods: 
-    func  compareTo()  throws: 
+    func  compareTo(o)  throws: 
 
diff --git a/src/MapleFE/test/openjdk/Compiler.java b/src/MapleFE/test/java/openjdk/Compiler.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Compiler.java
rename to src/MapleFE/test/java/openjdk/Compiler.java
diff --git a/src/MapleFE/test/openjdk/Compiler.java.result b/src/MapleFE/test/java/openjdk/Compiler.java.result
similarity index 75%
rename from src/MapleFE/test/openjdk/Compiler.java.result
rename to src/MapleFE/test/java/openjdk/Compiler.java.result
index d8c352271fda6a7d2612ae65351aaa16fe264269..a6b3bc5da59adcff29ccbede3941e1593d56b599 100644
--- a/src/MapleFE/test/openjdk/Compiler.java.result
+++ b/src/MapleFE/test/java/openjdk/Compiler.java.result
@@ -11,11 +11,11 @@ class  Compiler
   Constructors: 
     constructor  Compiler()  throws: 
   Methods: 
-    func  compileClass()  throws: 
+    func  compileClass(classToCompile)  throws: 
       return false
-    func  compileClasses()  throws: 
+    func  compileClasses(nameRoot)  throws: 
       return false
-    func  command()  throws: 
+    func  command(cmd)  throws: 
       return null
     func  enable()  throws: 
     func  disable()  throws: 
diff --git a/src/MapleFE/test/openjdk/Deprecated.java b/src/MapleFE/test/java/openjdk/Deprecated.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Deprecated.java
rename to src/MapleFE/test/java/openjdk/Deprecated.java
diff --git a/src/MapleFE/test/openjdk/Deprecated.java.result b/src/MapleFE/test/java/openjdk/Deprecated.java.result
similarity index 100%
rename from src/MapleFE/test/openjdk/Deprecated.java.result
rename to src/MapleFE/test/java/openjdk/Deprecated.java.result
diff --git a/src/MapleFE/test/openjdk/Double-2.java b/src/MapleFE/test/java/openjdk/Double-2.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Double-2.java
rename to src/MapleFE/test/java/openjdk/Double-2.java
diff --git a/src/MapleFE/test/openjdk/Double-2.java.result b/src/MapleFE/test/java/openjdk/Double-2.java.result
similarity index 89%
rename from src/MapleFE/test/openjdk/Double-2.java.result
rename to src/MapleFE/test/java/openjdk/Double-2.java.result
index 8d239862b275dd1b9801953098cfd98e7a63dc9a..65efd20c0deac2928bdfa238f6a21a7b51b3f2f9 100644
--- a/src/MapleFE/test/openjdk/Double-2.java.result
+++ b/src/MapleFE/test/java/openjdk/Double-2.java.result
@@ -7,7 +7,7 @@ class  Double
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  equals()  throws: 
+    func  equals(obj)  throws: 
       return doubleToLongBits((Double)obj.value) EQ doubleToLongBits(value)
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/Double.java b/src/MapleFE/test/java/openjdk/Double.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Double.java
rename to src/MapleFE/test/java/openjdk/Double.java
diff --git a/src/MapleFE/test/openjdk/Double.java.result b/src/MapleFE/test/java/openjdk/Double.java.result
similarity index 42%
rename from src/MapleFE/test/openjdk/Double.java.result
rename to src/MapleFE/test/java/openjdk/Double.java.result
index fecc8cc42968c1c08b816502b7b3c098d5fc2fe9..7092f2aa51d3f61a8f59e3870d43aa2cdd0cc09c 100644
--- a/src/MapleFE/test/openjdk/Double.java.result
+++ b/src/MapleFE/test/java/openjdk/Double.java.result
@@ -2,7 +2,7 @@ Matched 5 tokens.
 Matched 12 tokens.
 Matched 19 tokens.
 Matched 26 tokens.
-Matched 976 tokens.
+Matched 972 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
@@ -15,37 +15,52 @@ import sun.misc.DoubleConsts
 == Sub Tree ==
 class  Double
   Fields: 
-    POSITIVE_INFINITY=    NEGATIVE_INFINITY=    NaN=    MAX_VALUE=1.79769e+308    MIN_NORMAL=2.22507e-308    MIN_VALUE=4.94066e-324    MAX_EXPONENT=1023    MIN_EXPONENT=Sub
-  1022    SIZE=64    BYTES=    TYPE=()    value    serialVersionUID=Sub
-  -694942468
+    POSITIVE_INFINITY=1 Div 0    NEGATIVE_INFINITY=-1 Div 0    NaN=0 Div 0    MAX_VALUE=1.79769e+308    MIN_NORMAL=2.22507e-308    MIN_VALUE=4.94066e-324    MAX_EXPONENT=1023    MIN_EXPONENT=-1022    SIZE=64    BYTES=SIZE Div Byte.SIZE    TYPE=()double.getComponentType()    value    serialVersionUID=694942468
   Instance Initializer: 
   Constructors: 
-    constructor  Double()  throws: 
+    constructor  Double(value)  throws: 
       this.value Assign value
-    constructor  Double()  throws: 
+    constructor  Double(s)  throws: 
       value Assign parseDouble(s)
   Methods: 
-    func  toString()  throws: 
+    func  toString(d)  throws: 
       return FloatingDecimal.toJavaFormatString(d)
-    func  toHexString()  throws: 
+    func  toHexString(d)  throws: 
       cond-branch cond:isFinite(d)
       true branch :
-        return Double.toString(d)
-      false branch :
-        var:answer=new StringBuilder<StringBuilder>
+        return Double.toString(d)      false branch :
+        Decl: answer=new StringBuilder(24)
+        cond-branch cond:Math.copySign(1,d) EQ -1
+        true branch :
+          answer.append("-")        false branch :
+
+        answer.append("0x")
+        d Assign Math.abs(d)
+        cond-branch cond:d EQ 0
+        true branch :
+          answer.append("0.0p0")
+        false branch :
+          Decl: subnormal=(d LT DoubleConsts.MIN_NORMAL)
+          Decl: signifBits=(Double.doubleToLongBits(d) Band DoubleConsts.SIGNIF_BIT_MASK) Bor 0
+          answer.append(subnormal,"0.","1.")
+          Decl: signif=Long.toHexString(signifBits).substring(3,16)
+          answer.append(signif.equals("0000000000000"),"0",signif.replaceFirst("0{1,12}$",""))
+          answer.append(p)
+          answer.append(subnormal,DoubleConsts.MIN_EXPONENT,Math.getExponent(d))
 
+        return answer.toString()
 
-    func  valueOf()  throws:     NumberFormatException
-      return new Double<Double>
-    func  valueOf()  throws: 
-      return new Double<Double>
-    func  parseDouble()  throws:     NumberFormatException
+    func  valueOf(s)  throws:     NumberFormatException
+      return new Double(parseDouble(s))
+    func  valueOf(d)  throws: 
+      return new Double(d)
+    func  parseDouble(s)  throws:     NumberFormatException
       return FloatingDecimal.parseDouble(s)
-    func  isNaN()  throws: 
+    func  isNaN(v)  throws: 
       return (v NE v)
-    func  isInfinite()  throws: 
+    func  isInfinite(v)  throws: 
       return (v EQ POSITIVE_INFINITY) Lor (v EQ NEGATIVE_INFINITY)
-    func  isFinite()  throws: 
+    func  isFinite(d)  throws: 
       return Math.abs(d) LE DoubleConsts.MAX_VALUE
     func  isNaN()  throws: 
       return isNaN(value)
@@ -67,43 +82,39 @@ class  Double
       return value
     func  hashCode()  throws: 
       return Double.hashCode(value)
-    func  hashCode()  throws: 
-      var:bits=doubleToLongBits(value)
+    func  hashCode(value)  throws: 
+      Decl: bits=doubleToLongBits(value)
       return (int)(bits Bxor (bits Zext 32))
-    func  equals()  throws: 
-      return () Land (doubleToLongBits((Double)obj.value) EQ doubleToLongBits(value))
-    func  doubleToLongBits()  throws: 
-      var:result=doubleToRawLongBits(value)
+    func  equals(obj)  throws: 
+      return (obj instanceof Double) Land (doubleToLongBits((Double)obj.value) EQ doubleToLongBits(value))
+    func  doubleToLongBits(value)  throws: 
+      Decl: result=doubleToRawLongBits(value)
       cond-branch cond:((result Band DoubleConsts.EXP_BIT_MASK) EQ DoubleConsts.EXP_BIT_MASK) Land (result Band DoubleConsts.SIGNIF_BIT_MASK) NE 0
       true branch :
-        result Assign 0
-      false branch :
+        result Assign 0      false branch :
 
       return result
-    func  doubleToRawLongBits()  throws: 
-    func  longBitsToDouble()  throws: 
-    func  compareTo()  throws: 
+    func  doubleToRawLongBits(value)  throws: 
+    func  longBitsToDouble(bits)  throws: 
+    func  compareTo(anotherDouble)  throws: 
       return Double.compare(value,anotherDouble.value)
-    func  compare()  throws: 
+    func  compare(d1,d2)  throws: 
       cond-branch cond:d1 LT d2
       true branch :
-        return Sub
-  1
-      false branch :
+        return -1      false branch :
 
       cond-branch cond:d1 GT d2
       true branch :
-        return 1
-      false branch :
+        return 1      false branch :
 
-      var:thisBits=Double.doubleToLongBits(d1)
-      var:anotherBits=Double.doubleToLongBits(d2)
+      Decl: thisBits=Double.doubleToLongBits(d1)
+      Decl: anotherBits=Double.doubleToLongBits(d2)
       return ()
-    func  sum()  throws: 
+    func  sum(a,b)  throws: 
       return a Add b
-    func  max()  throws: 
+    func  max(a,b)  throws: 
       return Math.max(a,b)
-    func  min()  throws: 
+    func  min(a,b)  throws: 
       return Math.min(a,b)
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/Enum.java b/src/MapleFE/test/java/openjdk/Enum.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Enum.java
rename to src/MapleFE/test/java/openjdk/Enum.java
diff --git a/src/MapleFE/test/openjdk/Enum.java.result b/src/MapleFE/test/java/openjdk/Enum.java.result
similarity index 68%
rename from src/MapleFE/test/openjdk/Enum.java.result
rename to src/MapleFE/test/java/openjdk/Enum.java.result
index c3a82a8bdf1800105532533ff0d0fb9bd97fdf10..fa6cb1d2de4c2b14419e990aa4cafbcc07f16cf7 100644
--- a/src/MapleFE/test/openjdk/Enum.java.result
+++ b/src/MapleFE/test/java/openjdk/Enum.java.result
@@ -33,10 +33,10 @@ import libcore.util.EmptyArray
 == Sub Tree ==
 class  Enum
   Fields: 
-    name    ordinal    sharedConstantsCache=new BasicLruCache<Class,Enum,Object[]>
+    name    ordinal    sharedConstantsCache=new BasicLruCache(64)
   Instance Initializer: 
   Constructors: 
-    constructor  Enum()  throws: 
+    constructor  Enum(name,ordinal)  throws: 
       this.name Assign name
       this.ordinal Assign ordinal
   Methods: 
@@ -46,58 +46,57 @@ class  Enum
       return ordinal
     func  toString()  throws: 
       return name
-    func  equals()  throws: 
+    func  equals(other)  throws: 
       return this EQ other
     func  hashCode()  throws: 
-      return hashCode
+      return super.hashCode()
     func  clone()  throws:     CloneNotSupportedException
-      new CloneNotSupportedException<CloneNotSupportedException>
-    func  compareTo()  throws: 
-      var:other=(Enum)o
-      var:self=this
+      new CloneNotSupportedException()
+    func  compareTo(o)  throws: 
+      Decl: other=(Enum)o
+      Decl: self=this
       cond-branch cond:self.getClass() NE other.getClass() Land self.getDeclaringClass() NE other.getDeclaringClass()
       true branch :
-        new ClassCastException<ClassCastException>
-      false branch :
+        new ClassCastException()      false branch :
 
       return self.ordinal Sub other.ordinal
     func  getDeclaringClass()  throws: 
-      var:clazz=getClass()
-      var:zuper=clazz.getSuperclass()
+      Decl: clazz=getClass()
+      Decl: zuper=clazz.getSuperclass()
       return 
-    func  valueOf()  throws: 
+    func  valueOf(enumType,name)  throws: 
       cond-branch cond:enumType EQ null
       true branch :
-        new NullPointerException<NullPointerException>
+        new NullPointerException("enumType == null")
       false branch :
 
       cond-branch cond:name EQ null
       true branch :
-        new NullPointerException<NullPointerException>
+        new NullPointerException("name == null")
       false branch :
 
-      var:values=getSharedConstants(enumType)
+      Decl: values=getSharedConstants(enumType)
       cond-branch cond:values EQ null
       true branch :
-        new IllegalArgumentException<IllegalArgumentException>
+        new IllegalArgumentException(enumType.toString() Add " is not an enum type.")
       false branch :
 
       for ( )
-        var:value=
+        Decl: value=
         cond-branch cond:name.equals(value.name())
         true branch :
           return value
         false branch :
 
 
-      new IllegalArgumentException<IllegalArgumentException>
-    func  getSharedConstants()  throws: 
+      new IllegalArgumentException("No enum constant " Add enumType.getCanonicalName() Add "." Add name)
+    func  getSharedConstants(enumType)  throws: 
       return (T[])sharedConstantsCache.get(enumType)
     func  finalize()  throws: 
-    func  readObject()  throws:     IOException    ClassNotFoundException
-      new InvalidObjectException<InvalidObjectException>
+    func  readObject(in)  throws:     IOException    ClassNotFoundException
+      new InvalidObjectException("can't deserialize enum")
     func  readObjectNoData()  throws:     ObjectStreamException
-      new InvalidObjectException<InvalidObjectException>
+      new InvalidObjectException("can't deserialize enum")
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/openjdk/EnumConstantNotPresentException.java b/src/MapleFE/test/java/openjdk/EnumConstantNotPresentException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/EnumConstantNotPresentException.java
rename to src/MapleFE/test/java/openjdk/EnumConstantNotPresentException.java
diff --git a/src/MapleFE/test/openjdk/EnumConstantNotPresentException.java.result b/src/MapleFE/test/java/openjdk/EnumConstantNotPresentException.java.result
similarity index 78%
rename from src/MapleFE/test/openjdk/EnumConstantNotPresentException.java.result
rename to src/MapleFE/test/java/openjdk/EnumConstantNotPresentException.java.result
index e1e8b1230b1af6a155ea5a8c2f4f1b74a256be72..b4d1d6a141a842aef6d533c1087756cb49f5874f 100644
--- a/src/MapleFE/test/openjdk/EnumConstantNotPresentException.java.result
+++ b/src/MapleFE/test/java/openjdk/EnumConstantNotPresentException.java.result
@@ -1,16 +1,15 @@
 Matched 5 tokens.
-Matched 105 tokens.
+Matched 104 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  EnumConstantNotPresentException
   Fields: 
-    serialVersionUID=Sub
-  180673940    enumType    constantName
+    serialVersionUID=-180673940    enumType    constantName
   Instance Initializer: 
   Constructors: 
-    constructor  EnumConstantNotPresentException()  throws: 
+    constructor  EnumConstantNotPresentException(enumType,constantName)  throws: 
       this.enumType Assign enumType
       this.constantName Assign constantName
   Methods: 
diff --git a/src/MapleFE/test/openjdk/Error.java b/src/MapleFE/test/java/openjdk/Error.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Error.java
rename to src/MapleFE/test/java/openjdk/Error.java
diff --git a/src/MapleFE/test/openjdk/Error.java.result b/src/MapleFE/test/java/openjdk/Error.java.result
similarity index 58%
rename from src/MapleFE/test/openjdk/Error.java.result
rename to src/MapleFE/test/java/openjdk/Error.java.result
index 5dd4622ea7053655bf6e1c4dcc81bba7800f9fb3..51113c2cd922e448298aebd5378e04c5c9ec02d8 100644
--- a/src/MapleFE/test/openjdk/Error.java.result
+++ b/src/MapleFE/test/java/openjdk/Error.java.result
@@ -10,10 +10,10 @@ class  Error
   Instance Initializer: 
   Constructors: 
     constructor  Error()  throws: 
-    constructor  Error()  throws: 
-    constructor  Error()  throws: 
-    constructor  Error()  throws: 
-    constructor  Error()  throws: 
+    constructor  Error(message)  throws: 
+    constructor  Error(message,cause)  throws: 
+    constructor  Error(cause)  throws: 
+    constructor  Error(message,cause,enableSuppression,writableStackTrace)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/Exception.java b/src/MapleFE/test/java/openjdk/Exception.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Exception.java
rename to src/MapleFE/test/java/openjdk/Exception.java
diff --git a/src/MapleFE/test/openjdk/Exception.java.result b/src/MapleFE/test/java/openjdk/Exception.java.result
similarity index 47%
rename from src/MapleFE/test/openjdk/Exception.java.result
rename to src/MapleFE/test/java/openjdk/Exception.java.result
index be76c0a91de7ca3202633ccc22099abc4729e97c..f47c721d29f22195f9da1f72a77ebe994d9999a6 100644
--- a/src/MapleFE/test/openjdk/Exception.java.result
+++ b/src/MapleFE/test/java/openjdk/Exception.java.result
@@ -1,20 +1,19 @@
 Matched 5 tokens.
-Matched 102 tokens.
+Matched 101 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  Exception
   Fields: 
-    serialVersionUID=Sub
-  -440081604
+    serialVersionUID=440081604
   Instance Initializer: 
   Constructors: 
     constructor  Exception()  throws: 
-    constructor  Exception()  throws: 
-    constructor  Exception()  throws: 
-    constructor  Exception()  throws: 
-    constructor  Exception()  throws: 
+    constructor  Exception(message)  throws: 
+    constructor  Exception(message,cause)  throws: 
+    constructor  Exception(cause)  throws: 
+    constructor  Exception(message,cause,enableSuppression,writableStackTrace)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/ExceptionInInitializerError.java b/src/MapleFE/test/java/openjdk/ExceptionInInitializerError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/ExceptionInInitializerError.java
rename to src/MapleFE/test/java/openjdk/ExceptionInInitializerError.java
diff --git a/src/MapleFE/test/openjdk/ExceptionInInitializerError.java.result b/src/MapleFE/test/java/openjdk/ExceptionInInitializerError.java.result
similarity index 82%
rename from src/MapleFE/test/openjdk/ExceptionInInitializerError.java.result
rename to src/MapleFE/test/java/openjdk/ExceptionInInitializerError.java.result
index cafc9f7c7352ee5c569011a0e8f5d1fa3b724cb6..23df8f7d4d6f1ebc4424ebe5708fe741390d7c04 100644
--- a/src/MapleFE/test/openjdk/ExceptionInInitializerError.java.result
+++ b/src/MapleFE/test/java/openjdk/ExceptionInInitializerError.java.result
@@ -11,10 +11,10 @@ class  ExceptionInInitializerError
   Constructors: 
     constructor  ExceptionInInitializerError()  throws: 
       initCause(null)
-    constructor  ExceptionInInitializerError()  throws: 
+    constructor  ExceptionInInitializerError(thrown)  throws: 
       initCause(null)
       this.exception Assign thrown
-    constructor  ExceptionInInitializerError()  throws: 
+    constructor  ExceptionInInitializerError(s)  throws: 
       initCause(null)
   Methods: 
     func  getException()  throws: 
diff --git a/src/MapleFE/test/openjdk/Float.java b/src/MapleFE/test/java/openjdk/Float.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Float.java
rename to src/MapleFE/test/java/openjdk/Float.java
diff --git a/src/MapleFE/test/openjdk/Float.java.result b/src/MapleFE/test/java/openjdk/Float.java.result
similarity index 54%
rename from src/MapleFE/test/openjdk/Float.java.result
rename to src/MapleFE/test/java/openjdk/Float.java.result
index d1727db3e9bb575fcc88b0116c9f43d413c189b3..25f8d35f633b02d35b2f9e4cdabb6647e0e56b50 100644
--- a/src/MapleFE/test/openjdk/Float.java.result
+++ b/src/MapleFE/test/java/openjdk/Float.java.result
@@ -2,7 +2,7 @@ Matched 5 tokens.
 Matched 12 tokens.
 Matched 19 tokens.
 Matched 26 tokens.
-Matched 848 tokens.
+Matched 844 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
@@ -15,39 +15,36 @@ import sun.misc.DoubleConsts
 == Sub Tree ==
 class  Float
   Fields: 
-    POSITIVE_INFINITY=    NEGATIVE_INFINITY=    NaN=    MAX_VALUE=3.40282e+38    MIN_NORMAL=1.17549e-38    MIN_VALUE=1.4013e-45    MAX_EXPONENT=127    MIN_EXPONENT=Sub
-  126    SIZE=32    BYTES=    TYPE=()    value    serialVersionUID=Sub
-  616763156
+    POSITIVE_INFINITY=1 Div 0    NEGATIVE_INFINITY=-1 Div 0    NaN=0 Div 0    MAX_VALUE=3.40282e+38    MIN_NORMAL=1.17549e-38    MIN_VALUE=1.4013e-45    MAX_EXPONENT=127    MIN_EXPONENT=-126    SIZE=32    BYTES=SIZE Div Byte.SIZE    TYPE=()float.getComponentType()    value    serialVersionUID=-616763156
   Instance Initializer: 
   Constructors: 
-    constructor  Float()  throws: 
+    constructor  Float(value)  throws: 
       this.value Assign value
-    constructor  Float()  throws: 
+    constructor  Float(value)  throws: 
       this.value Assign (float)value
-    constructor  Float()  throws: 
+    constructor  Float(s)  throws: 
       value Assign parseFloat(s)
   Methods: 
-    func  toString()  throws: 
+    func  toString(f)  throws: 
       return FloatingDecimal.toJavaFormatString(f)
-    func  toHexString()  throws: 
+    func  toHexString(f)  throws: 
       cond-branch cond:Math.abs(f) LT FloatConsts.MIN_NORMAL Land f NE 0
       true branch :
-        var:s=Double.toHexString(Math.scalb((double)f,DoubleConsts.MIN_EXPONENT Sub FloatConsts.MIN_EXPONENT))
+        Decl: s=Double.toHexString(Math.scalb((double)f,DoubleConsts.MIN_EXPONENT Sub FloatConsts.MIN_EXPONENT))
         return s.replaceFirst("p-1022$","p-126")
       false branch :
         return Double.toHexString(f)
-
-    func  valueOf()  throws:     NumberFormatException
-      return new Float<Float>
-    func  valueOf()  throws: 
-      return new Float<Float>
-    func  parseFloat()  throws:     NumberFormatException
+    func  valueOf(s)  throws:     NumberFormatException
+      return new Float(parseFloat(s))
+    func  valueOf(f)  throws: 
+      return new Float(f)
+    func  parseFloat(s)  throws:     NumberFormatException
       return FloatingDecimal.parseFloat(s)
-    func  isNaN()  throws: 
+    func  isNaN(v)  throws: 
       return (v NE v)
-    func  isInfinite()  throws: 
+    func  isInfinite(v)  throws: 
       return (v EQ POSITIVE_INFINITY) Lor (v EQ NEGATIVE_INFINITY)
-    func  isFinite()  throws: 
+    func  isFinite(f)  throws: 
       return Math.abs(f) LE FloatConsts.MAX_VALUE
     func  isNaN()  throws: 
       return isNaN(value)
@@ -69,42 +66,38 @@ class  Float
       return (double)value
     func  hashCode()  throws: 
       return Float.hashCode(value)
-    func  hashCode()  throws: 
+    func  hashCode(value)  throws: 
       return floatToIntBits(value)
-    func  equals()  throws: 
-      return () Land (floatToIntBits((Float)obj.value) EQ floatToIntBits(value))
-    func  floatToIntBits()  throws: 
-      var:result=floatToRawIntBits(value)
+    func  equals(obj)  throws: 
+      return (obj instanceof Float) Land (floatToIntBits((Float)obj.value) EQ floatToIntBits(value))
+    func  floatToIntBits(value)  throws: 
+      Decl: result=floatToRawIntBits(value)
       cond-branch cond:((result Band FloatConsts.EXP_BIT_MASK) EQ FloatConsts.EXP_BIT_MASK) Land (result Band FloatConsts.SIGNIF_BIT_MASK) NE 0
       true branch :
-        result Assign 2143289344
-      false branch :
+        result Assign 2143289344      false branch :
 
       return result
-    func  floatToRawIntBits()  throws: 
-    func  intBitsToFloat()  throws: 
-    func  compareTo()  throws: 
+    func  floatToRawIntBits(value)  throws: 
+    func  intBitsToFloat(bits)  throws: 
+    func  compareTo(anotherFloat)  throws: 
       return Float.compare(value,anotherFloat.value)
-    func  compare()  throws: 
+    func  compare(f1,f2)  throws: 
       cond-branch cond:f1 LT f2
       true branch :
-        return Sub
-  1
-      false branch :
+        return -1      false branch :
 
       cond-branch cond:f1 GT f2
       true branch :
-        return 1
-      false branch :
+        return 1      false branch :
 
-      var:thisBits=Float.floatToIntBits(f1)
-      var:anotherBits=Float.floatToIntBits(f2)
+      Decl: thisBits=Float.floatToIntBits(f1)
+      Decl: anotherBits=Float.floatToIntBits(f2)
       return ()
-    func  sum()  throws: 
+    func  sum(a,b)  throws: 
       return a Add b
-    func  max()  throws: 
+    func  max(a,b)  throws: 
       return Math.max(a,b)
-    func  min()  throws: 
+    func  min(a,b)  throws: 
       return Math.min(a,b)
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/FunctionalInterface.java b/src/MapleFE/test/java/openjdk/FunctionalInterface.java
similarity index 100%
rename from src/MapleFE/test/openjdk/FunctionalInterface.java
rename to src/MapleFE/test/java/openjdk/FunctionalInterface.java
diff --git a/src/MapleFE/test/openjdk/FunctionalInterface.java.result b/src/MapleFE/test/java/openjdk/FunctionalInterface.java.result
similarity index 100%
rename from src/MapleFE/test/openjdk/FunctionalInterface.java.result
rename to src/MapleFE/test/java/openjdk/FunctionalInterface.java.result
diff --git a/src/MapleFE/test/openjdk/IllegalAccessError.java b/src/MapleFE/test/java/openjdk/IllegalAccessError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/IllegalAccessError.java
rename to src/MapleFE/test/java/openjdk/IllegalAccessError.java
diff --git a/src/MapleFE/test/openjdk/IllegalAccessError.java.result b/src/MapleFE/test/java/openjdk/IllegalAccessError.java.result
similarity index 72%
rename from src/MapleFE/test/openjdk/IllegalAccessError.java.result
rename to src/MapleFE/test/java/openjdk/IllegalAccessError.java.result
index 901d3350b0a4bfbed762b29a13590ceb71be2bdc..ee810c6fa19c6471f03a7890f4fe6eb372772f8c 100644
--- a/src/MapleFE/test/openjdk/IllegalAccessError.java.result
+++ b/src/MapleFE/test/java/openjdk/IllegalAccessError.java.result
@@ -1,17 +1,16 @@
 Matched 5 tokens.
-Matched 44 tokens.
+Matched 43 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  IllegalAccessError
   Fields: 
-    serialVersionUID=Sub
-  -2047083421
+    serialVersionUID=2047083421
   Instance Initializer: 
   Constructors: 
     constructor  IllegalAccessError()  throws: 
-    constructor  IllegalAccessError()  throws: 
+    constructor  IllegalAccessError(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/IllegalAccessException.java b/src/MapleFE/test/java/openjdk/IllegalAccessException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/IllegalAccessException.java
rename to src/MapleFE/test/java/openjdk/IllegalAccessException.java
diff --git a/src/MapleFE/test/openjdk/IllegalAccessException.java.result b/src/MapleFE/test/java/openjdk/IllegalAccessException.java.result
similarity index 86%
rename from src/MapleFE/test/openjdk/IllegalAccessException.java.result
rename to src/MapleFE/test/java/openjdk/IllegalAccessException.java.result
index 77c6d9fc962f50bb6aa151c2d40484d8735d3355..0f015ed019a86553dfc8e3ba415a62f922910507 100644
--- a/src/MapleFE/test/openjdk/IllegalAccessException.java.result
+++ b/src/MapleFE/test/java/openjdk/IllegalAccessException.java.result
@@ -10,7 +10,7 @@ class  IllegalAccessException
   Instance Initializer: 
   Constructors: 
     constructor  IllegalAccessException()  throws: 
-    constructor  IllegalAccessException()  throws: 
+    constructor  IllegalAccessException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/IllegalArgumentException.java b/src/MapleFE/test/java/openjdk/IllegalArgumentException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/IllegalArgumentException.java
rename to src/MapleFE/test/java/openjdk/IllegalArgumentException.java
diff --git a/src/MapleFE/test/openjdk/IllegalArgumentException.java.result b/src/MapleFE/test/java/openjdk/IllegalArgumentException.java.result
similarity index 55%
rename from src/MapleFE/test/openjdk/IllegalArgumentException.java.result
rename to src/MapleFE/test/java/openjdk/IllegalArgumentException.java.result
index ab0c987eeb13c769b7c4f476ceefdba5a1adb147..4a49c834ef69e8256d44a33bc036570a35ac0077 100644
--- a/src/MapleFE/test/openjdk/IllegalArgumentException.java.result
+++ b/src/MapleFE/test/java/openjdk/IllegalArgumentException.java.result
@@ -1,19 +1,18 @@
 Matched 5 tokens.
-Matched 75 tokens.
+Matched 74 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  IllegalArgumentException
   Fields: 
-    serialVersionUID=Sub
-  -2103873468
+    serialVersionUID=2103873468
   Instance Initializer: 
   Constructors: 
     constructor  IllegalArgumentException()  throws: 
-    constructor  IllegalArgumentException()  throws: 
-    constructor  IllegalArgumentException()  throws: 
-    constructor  IllegalArgumentException()  throws: 
+    constructor  IllegalArgumentException(s)  throws: 
+    constructor  IllegalArgumentException(message,cause)  throws: 
+    constructor  IllegalArgumentException(cause)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/IllegalMonitorStateException.java b/src/MapleFE/test/java/openjdk/IllegalMonitorStateException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/IllegalMonitorStateException.java
rename to src/MapleFE/test/java/openjdk/IllegalMonitorStateException.java
diff --git a/src/MapleFE/test/openjdk/IllegalMonitorStateException.java.result b/src/MapleFE/test/java/openjdk/IllegalMonitorStateException.java.result
similarity index 85%
rename from src/MapleFE/test/openjdk/IllegalMonitorStateException.java.result
rename to src/MapleFE/test/java/openjdk/IllegalMonitorStateException.java.result
index 40ea298ea916adf631527d36b962e3c27db9b05e..95aafffda59dce3ef79436e4408a2b565d85e670 100644
--- a/src/MapleFE/test/openjdk/IllegalMonitorStateException.java.result
+++ b/src/MapleFE/test/java/openjdk/IllegalMonitorStateException.java.result
@@ -10,7 +10,7 @@ class  IllegalMonitorStateException
   Instance Initializer: 
   Constructors: 
     constructor  IllegalMonitorStateException()  throws: 
-    constructor  IllegalMonitorStateException()  throws: 
+    constructor  IllegalMonitorStateException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/IllegalStateException.java b/src/MapleFE/test/java/openjdk/IllegalStateException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/IllegalStateException.java
rename to src/MapleFE/test/java/openjdk/IllegalStateException.java
diff --git a/src/MapleFE/test/openjdk/IllegalStateException.java.result b/src/MapleFE/test/java/openjdk/IllegalStateException.java.result
similarity index 55%
rename from src/MapleFE/test/openjdk/IllegalStateException.java.result
rename to src/MapleFE/test/java/openjdk/IllegalStateException.java.result
index 2e476ee0c2acf14ed9bfa1399d5202d7cbc4e9fc..783d279016e888712683788de8a8642a415974ee 100644
--- a/src/MapleFE/test/openjdk/IllegalStateException.java.result
+++ b/src/MapleFE/test/java/openjdk/IllegalStateException.java.result
@@ -1,19 +1,18 @@
 Matched 5 tokens.
-Matched 74 tokens.
+Matched 73 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  IllegalStateException
   Fields: 
-    serialVersionUID=Sub
-  1706626488
+    serialVersionUID=-1706626488
   Instance Initializer: 
   Constructors: 
     constructor  IllegalStateException()  throws: 
-    constructor  IllegalStateException()  throws: 
-    constructor  IllegalStateException()  throws: 
-    constructor  IllegalStateException()  throws: 
+    constructor  IllegalStateException(s)  throws: 
+    constructor  IllegalStateException(message,cause)  throws: 
+    constructor  IllegalStateException(cause)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/IllegalThreadStateException.java b/src/MapleFE/test/java/openjdk/IllegalThreadStateException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/IllegalThreadStateException.java
rename to src/MapleFE/test/java/openjdk/IllegalThreadStateException.java
diff --git a/src/MapleFE/test/openjdk/IllegalThreadStateException.java.result b/src/MapleFE/test/java/openjdk/IllegalThreadStateException.java.result
similarity index 72%
rename from src/MapleFE/test/openjdk/IllegalThreadStateException.java.result
rename to src/MapleFE/test/java/openjdk/IllegalThreadStateException.java.result
index e38f91928f4e02d5d561399a4f4146e84394e4c6..f6bb4fa7292cb4e106a708430caa3bd3d11b6fd6 100644
--- a/src/MapleFE/test/openjdk/IllegalThreadStateException.java.result
+++ b/src/MapleFE/test/java/openjdk/IllegalThreadStateException.java.result
@@ -1,17 +1,16 @@
 Matched 5 tokens.
-Matched 44 tokens.
+Matched 43 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  IllegalThreadStateException
   Fields: 
-    serialVersionUID=Sub
-  944817870
+    serialVersionUID=-944817870
   Instance Initializer: 
   Constructors: 
     constructor  IllegalThreadStateException()  throws: 
-    constructor  IllegalThreadStateException()  throws: 
+    constructor  IllegalThreadStateException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/IncompatibleClassChangeError.java b/src/MapleFE/test/java/openjdk/IncompatibleClassChangeError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/IncompatibleClassChangeError.java
rename to src/MapleFE/test/java/openjdk/IncompatibleClassChangeError.java
diff --git a/src/MapleFE/test/openjdk/IncompatibleClassChangeError.java.result b/src/MapleFE/test/java/openjdk/IncompatibleClassChangeError.java.result
similarity index 72%
rename from src/MapleFE/test/openjdk/IncompatibleClassChangeError.java.result
rename to src/MapleFE/test/java/openjdk/IncompatibleClassChangeError.java.result
index 25ca234a7efa329407ffe8986d32037f14a742c2..f60b99e0394340369de81923419ee8cf2b0be7d0 100644
--- a/src/MapleFE/test/openjdk/IncompatibleClassChangeError.java.result
+++ b/src/MapleFE/test/java/openjdk/IncompatibleClassChangeError.java.result
@@ -1,17 +1,16 @@
 Matched 5 tokens.
-Matched 44 tokens.
+Matched 43 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  IncompatibleClassChangeError
   Fields: 
-    serialVersionUID=Sub
-  241186759
+    serialVersionUID=-241186759
   Instance Initializer: 
   Constructors: 
     constructor  IncompatibleClassChangeError()  throws: 
-    constructor  IncompatibleClassChangeError()  throws: 
+    constructor  IncompatibleClassChangeError(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/IndexOutOfBoundsException.java b/src/MapleFE/test/java/openjdk/IndexOutOfBoundsException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/IndexOutOfBoundsException.java
rename to src/MapleFE/test/java/openjdk/IndexOutOfBoundsException.java
diff --git a/src/MapleFE/test/openjdk/IndexOutOfBoundsException.java.result b/src/MapleFE/test/java/openjdk/IndexOutOfBoundsException.java.result
similarity index 85%
rename from src/MapleFE/test/openjdk/IndexOutOfBoundsException.java.result
rename to src/MapleFE/test/java/openjdk/IndexOutOfBoundsException.java.result
index a9a24df9ace72b094554679225d98135c255e81d..e6b7f17cecc4299420eacca954aea24cfafdde28 100644
--- a/src/MapleFE/test/openjdk/IndexOutOfBoundsException.java.result
+++ b/src/MapleFE/test/java/openjdk/IndexOutOfBoundsException.java.result
@@ -10,7 +10,7 @@ class  IndexOutOfBoundsException
   Instance Initializer: 
   Constructors: 
     constructor  IndexOutOfBoundsException()  throws: 
-    constructor  IndexOutOfBoundsException()  throws: 
+    constructor  IndexOutOfBoundsException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/InheritableThreadLocal.java b/src/MapleFE/test/java/openjdk/InheritableThreadLocal.java
similarity index 100%
rename from src/MapleFE/test/openjdk/InheritableThreadLocal.java
rename to src/MapleFE/test/java/openjdk/InheritableThreadLocal.java
diff --git a/src/MapleFE/test/openjdk/InheritableThreadLocal.java.result b/src/MapleFE/test/java/openjdk/InheritableThreadLocal.java.result
similarity index 67%
rename from src/MapleFE/test/openjdk/InheritableThreadLocal.java.result
rename to src/MapleFE/test/java/openjdk/InheritableThreadLocal.java.result
index 0b33682f73eef1c10daa3f17b985c1ae414280df..bc6d651cb6cdcaf8b1e8026f564c4f67cb7a9bf4 100644
--- a/src/MapleFE/test/openjdk/InheritableThreadLocal.java.result
+++ b/src/MapleFE/test/java/openjdk/InheritableThreadLocal.java.result
@@ -13,12 +13,12 @@ class  InheritableThreadLocal
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  childValue()  throws: 
+    func  childValue(parentValue)  throws: 
       return parentValue
-    func  getMap()  throws: 
+    func  getMap(t)  throws: 
       return t.inheritableThreadLocals
-    func  createMap()  throws: 
-      t.inheritableThreadLocals Assign new ThreadLocalMap<ThreadLocalMap>
+    func  createMap(t,firstValue)  throws: 
+      t.inheritableThreadLocals Assign new ThreadLocalMap(this,firstValue)
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/openjdk/InstantiationError.java b/src/MapleFE/test/java/openjdk/InstantiationError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/InstantiationError.java
rename to src/MapleFE/test/java/openjdk/InstantiationError.java
diff --git a/src/MapleFE/test/openjdk/InstantiationError.java.result b/src/MapleFE/test/java/openjdk/InstantiationError.java.result
similarity index 72%
rename from src/MapleFE/test/openjdk/InstantiationError.java.result
rename to src/MapleFE/test/java/openjdk/InstantiationError.java.result
index f0d4db7ccc4b17645252db9359af8d444201ecf3..7964f147d622897c77e3113656d4a2a0d65d86be 100644
--- a/src/MapleFE/test/openjdk/InstantiationError.java.result
+++ b/src/MapleFE/test/java/openjdk/InstantiationError.java.result
@@ -1,17 +1,16 @@
 Matched 5 tokens.
-Matched 44 tokens.
+Matched 43 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  InstantiationError
   Fields: 
-    serialVersionUID=Sub
-  522274964
+    serialVersionUID=-522274964
   Instance Initializer: 
   Constructors: 
     constructor  InstantiationError()  throws: 
-    constructor  InstantiationError()  throws: 
+    constructor  InstantiationError(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/InstantiationException.java b/src/MapleFE/test/java/openjdk/InstantiationException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/InstantiationException.java
rename to src/MapleFE/test/java/openjdk/InstantiationException.java
diff --git a/src/MapleFE/test/openjdk/InstantiationException.java.result b/src/MapleFE/test/java/openjdk/InstantiationException.java.result
similarity index 72%
rename from src/MapleFE/test/openjdk/InstantiationException.java.result
rename to src/MapleFE/test/java/openjdk/InstantiationException.java.result
index 318389f21526ffc3a14de3431ebfe07c80245d46..88f6bce0e263177027356f7d18a53bfcb6822430 100644
--- a/src/MapleFE/test/openjdk/InstantiationException.java.result
+++ b/src/MapleFE/test/java/openjdk/InstantiationException.java.result
@@ -1,17 +1,16 @@
 Matched 5 tokens.
-Matched 44 tokens.
+Matched 43 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  InstantiationException
   Fields: 
-    serialVersionUID=Sub
-  -1305838986
+    serialVersionUID=1305838986
   Instance Initializer: 
   Constructors: 
     constructor  InstantiationException()  throws: 
-    constructor  InstantiationException()  throws: 
+    constructor  InstantiationException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/Integer.java b/src/MapleFE/test/java/openjdk/Integer.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Integer.java
rename to src/MapleFE/test/java/openjdk/Integer.java
diff --git a/src/MapleFE/test/openjdk/Integer.java.result b/src/MapleFE/test/java/openjdk/Integer.java.result
similarity index 47%
rename from src/MapleFE/test/openjdk/Integer.java.result
rename to src/MapleFE/test/java/openjdk/Integer.java.result
index 99b7f591bf6b48af36ed1562f11c662a67264f8b..a5effda89d9f5254c3e76dd7ecc9f00f776e0f64 100644
--- a/src/MapleFE/test/openjdk/Integer.java.result
+++ b/src/MapleFE/test/java/openjdk/Integer.java.result
@@ -1,8 +1,6 @@
 Matched 5 tokens.
 Matched 14 tokens.
-Matched 3758 tokens.
-Convert unary --> binary
-Convert unary --> binary
+Matched 3756 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
@@ -11,103 +9,123 @@ import java.lang.annotation.Native
 == Sub Tree ==
 class  Integer
   Fields: 
-    MIN_VALUE=-2147483648    MAX_VALUE=2147483647    TYPE=()    digits=    SMALL_NEG_VALUES=    SMALL_NONNEG_VALUES=    DigitTens=    DigitOnes=    sizeTable=    value    SIZE=32    BYTES=    serialVersionUID=-142506184
+    MIN_VALUE=-2147483648    MAX_VALUE=2147483647    TYPE=()int.getComponentType()    digits=    SMALL_NEG_VALUES=    SMALL_NONNEG_VALUES=    DigitTens=    DigitOnes=    sizeTable=    value    SIZE=32    BYTES=SIZE Div Byte.SIZE    serialVersionUID=-142506184
   Instance Initializer: 
   Constructors: 
-    constructor  Integer()  throws: 
+    constructor  Integer(value)  throws: 
       this.value Assign value
-    constructor  Integer()  throws: 
+    constructor  Integer(s)  throws: 
       this.value Assign parseInt(s,10)
   Methods: 
-    func  toString()  throws: 
+    func  toString(i,radix)  throws: 
       cond-branch cond:radix LT Character.MIN_RADIX Lor radix GT Character.MAX_RADIX
       true branch :
-        radix Assign 10
-      false branch :
+        radix Assign 10      false branch :
 
       cond-branch cond:radix EQ 10
       true branch :
         return toString(i)
       false branch :
 
-      var:buf=[]
-      var:negative=(i LT 0)
-      var:charPos=32
+      Decl: buf=[]
+      Decl: negative=(i LT 0)
+      Decl: charPos=32
       cond-branch cond:negative
       true branch :
-        i Assign Sub
-  i
+        i Assign Minus i
       false branch :
 
-      while i LE Sub
-  radix         Assign digits Sub ()
-        i Assign 
+      while i LE Minus radix         Assign 
+        i Assign i Div radix
 
-       Assign digits Sub i
+       Assign 
       cond-branch cond:negative
       true branch :
          Assign -
       false branch :
 
-      return new String<String>
-    func  toUnsignedString()  throws: 
+      return new String(buf,charPos,(33 Sub charPos))
+    func  toUnsignedString(i,radix)  throws: 
       return Long.toUnsignedString(toUnsignedLong(i),radix)
-    func  toHexString()  throws: 
+    func  toHexString(i)  throws: 
       return toUnsignedString0(i,4)
-    func  toOctalString()  throws: 
+    func  toOctalString(i)  throws: 
       return toUnsignedString0(i,3)
-    func  toBinaryString()  throws: 
+    func  toBinaryString(i)  throws: 
       return toUnsignedString0(i,1)
-    func  toUnsignedString0()  throws: 
-      var:mag=Integer.SIZE Sub Integer.numberOfLeadingZeros(val)
-      var:chars=Math.max(((mag Add (shift Sub 1))shift)1)
-      var:buf=
+    func  toUnsignedString0(val,shift)  throws: 
+      Decl: mag=Integer.SIZE Sub Integer.numberOfLeadingZeros(val)
+      Decl: chars=Math.max(((mag Add (shift Sub 1)) Div shift)1)
+      Decl: buf=
       formatUnsignedInt(val,shift,buf,0,chars)
-      return new String<String>
-    func  formatUnsignedInt()  throws: 
-      var:charPos=len
-      var:radix=1 Shl shift
-      var:mask=radix Sub 1
+      return new String(buf)
+    func  formatUnsignedInt(val,shift,buf,offset,len)  throws: 
+      Decl: charPos=len
+      Decl: radix=1 Shl shift
+      Decl: mask=radix Sub 1
       do          Assign 
         val ZextAssign shift
 while val NE 0 Land charPos GT 0
       return charPos
-    func  toString()  throws: 
+    func  toString(i)  throws: 
       cond-branch cond:i EQ Integer.MIN_VALUE
       true branch :
-        return "-2147483648"
-      false branch :
+        return "-2147483648"      false branch :
 
-      var:negative=i LT 0
-      var:small=
+      Decl: negative=i LT 0
+      Decl: small=
       cond-branch cond:small
       true branch :
-        var:smallValues=
+        Decl: smallValues=
+        cond-branch cond:negative
+        true branch :
+          i Assign Minus i
+          cond-branch cond: EQ null
+          true branch :
+             Assign 
+          false branch :
 
+        false branch :
+          cond-branch cond: EQ null
+          true branch :
+             Assign 
+          false branch :
+
+
+        return 
       false branch :
 
-      var:size=
-      var:buf=
+      Decl: size=
+      Decl: buf=
       getChars(i,size,buf)
-      return new String<String>
-    func  toUnsignedString()  throws: 
+      return new String(buf)
+    func  toUnsignedString(i)  throws: 
       return Long.toString(toUnsignedLong(i))
-    func  getChars()  throws: 
-      var:q,r
-      var:charPos=index
-      var:sign=0
+    func  getChars(i,index,buf)  throws: 
+      Decl: q,r
+      Decl: charPos=index
+      Decl: sign=0
       cond-branch cond:i LT 0
       true branch :
         sign Assign -
-        i Assign Sub
-  i
+        i Assign Minus i
       false branch :
 
-      while i GE 65536        q Assign 
-
+      while i GE 65536        q Assign i Div 100
+        r Assign i Sub ((q Shl 6) Add (q Shl 5) Add (q Shl 2))
+        i Assign q
+         Assign 
+         Assign 
 
       for ( )
-        q Assign () Zext (16 Add 3)
+        q Assign (i Mul 52429) Zext (16 Add 3)
+        r Assign i Sub ((q Shl 3) Add (q Shl 1))
+         Assign 
+        i Assign q
+        cond-branch cond:i EQ 0
+        true branch :
+          break:
+        false branch :
 
 
       cond-branch cond:sign NE 0
@@ -115,90 +133,125 @@ while val NE 0 Land charPos GT 0
          Assign sign
       false branch :
 
-    func  stringSize()  throws: 
+    func  stringSize(x)  throws: 
       for ( )
         cond-branch cond:x LE 
         true branch :
-          return i Add 1
-        false branch :
-
+          return i Add 1        false branch :
 
-    func  parseInt()  throws:     NumberFormatException
+    func  parseInt(s,radix)  throws:     NumberFormatException
       cond-branch cond:s EQ null
       true branch :
-        new NumberFormatException<NumberFormatException>
+        new NumberFormatException("s == null")
       false branch :
 
       cond-branch cond:radix LT Character.MIN_RADIX
       true branch :
-        new NumberFormatException<NumberFormatException>
+        new NumberFormatException("radix " Add radix Add " less than Character.MIN_RADIX")
       false branch :
 
       cond-branch cond:radix GT Character.MAX_RADIX
       true branch :
-        new NumberFormatException<NumberFormatException>
+        new NumberFormatException("radix " Add radix Add " greater than Character.MAX_RADIX")
       false branch :
 
-      var:result=0
-      var:negative=false
-      var:i=0,len=s.length()
-      var:limit=Sub
-  Integer.MAX_VALUE
-      var:multmin
-      var:digit
+      Decl: result=0
+      Decl: negative=false
+      Decl: i=0,len=s.length()
+      Decl: limit=Minus Integer.MAX_VALUE
+      Decl: multmin
+      Decl: digit
       cond-branch cond:len GT 0
       true branch :
-        var:firstChar=s.charAt(0)
+        Decl: firstChar=s.charAt(0)
+        cond-branch cond:firstChar LT 0
+        true branch :
+          cond-branch cond:firstChar EQ -
+          true branch :
+            negative Assign true
+            limit Assign Integer.MIN_VALUE
+          false branch :
+            cond-branch cond:firstChar NE +
+            true branch :
+              NumberFormatException.forInputString(s)            false branch :
+
+          cond-branch cond:len EQ 1
+          true branch :
+            NumberFormatException.forInputString(s)          false branch :
+
+          i Inc
+
+        false branch :
+
+        multmin Assign limit Div radix
+        while i LT len          digit Assign Character.digit(s.charAt(i Inc
+),radix)
+          cond-branch cond:digit LT 0
+          true branch :
+            NumberFormatException.forInputString(s)
+          false branch :
+
+          cond-branch cond:result LT multmin
+          true branch :
+            NumberFormatException.forInputString(s)
+          false branch :
+
+          result MulAssign radix
+          cond-branch cond:result LT limit Add digit
+          true branch :
+            NumberFormatException.forInputString(s)
+          false branch :
+
+          result SubAssign digit
 
       false branch :
         NumberFormatException.forInputString(s)
 
       return 
-    func  parseInt()  throws:     NumberFormatException
+    func  parseInt(s)  throws:     NumberFormatException
       return parseInt(s,10)
-    func  parseUnsignedInt()  throws:     NumberFormatException
+    func  parseUnsignedInt(s,radix)  throws:     NumberFormatException
       cond-branch cond:s EQ null
       true branch :
-        new NumberFormatException<NumberFormatException>
+        new NumberFormatException("null")
       false branch :
 
-      var:len=s.length()
+      Decl: len=s.length()
       cond-branch cond:len GT 0
       true branch :
-        var:firstChar=s.charAt(0)
+        Decl: firstChar=s.charAt(0)
         cond-branch cond:firstChar EQ -
         true branch :
-          new NumberFormatException<NumberFormatException>
+          new NumberFormatException(String.format("Illegal leading minus sign " Add "on unsigned string %s.",s))
         false branch :
           cond-branch cond:len LE 5 Lor (radix EQ 10 Land len LE 9)
           true branch :
             return parseInt(s,radix)
           false branch :
-            var:ell=Long.parseLong(s,radix)
+            Decl: ell=Long.parseLong(s,radix)
             cond-branch cond:(ell Band 0) EQ 0
             true branch :
               return (int)ell
             false branch :
-              new NumberFormatException<NumberFormatException>
+              new NumberFormatException(String.format("String value %s exceeds " Add "range of unsigned int.",s))
 
 
 
       false branch :
         NumberFormatException.forInputString(s)
 
-    func  parseUnsignedInt()  throws:     NumberFormatException
+    func  parseUnsignedInt(s)  throws:     NumberFormatException
       return parseUnsignedInt(s,10)
-    func  valueOf()  throws:     NumberFormatException
+    func  valueOf(s,radix)  throws:     NumberFormatException
       return Integer.valueOf(parseInt(s,radix))
-    func  valueOf()  throws:     NumberFormatException
+    func  valueOf(s)  throws:     NumberFormatException
       return Integer.valueOf(parseInt(s,10))
-    func  valueOf()  throws: 
+    func  valueOf(i)  throws: 
       cond-branch cond:i GE IntegerCache.low Land i LE IntegerCache.high
       true branch :
-        return 
-      false branch :
+        return       false branch :
 
-      return new Integer<Integer>
+      return new Integer(i)
     func  byteValue()  throws: 
       return (byte)value
     func  shortValue()  throws: 
@@ -215,57 +268,59 @@ while val NE 0 Land charPos GT 0
       return toString(value)
     func  hashCode()  throws: 
       return Integer.hashCode(value)
-    func  hashCode()  throws: 
+    func  hashCode(value)  throws: 
       return value
-    func  equals()  throws: 
-      cond-branch cond:
+    func  equals(obj)  throws: 
+      cond-branch cond:obj instanceof Integer
       true branch :
-        return value EQ ((Integer)obj)intValue
+        return value EQ (Integer)obj.intValue()
       false branch :
 
       return false
-    func  getInteger()  throws: 
+    func  getInteger(nm)  throws: 
       return getInteger(nm,null)
-    func  getInteger()  throws: 
-      var:result=getInteger(nm,null)
+    func  getInteger(nm,val)  throws: 
+      Decl: result=getInteger(nm,null)
       return 
-    func  getInteger()  throws: 
-      var:v=null
+    func  getInteger(nm,val)  throws: 
+      Decl: v=null
       v Assign System.getProperty(nm)
 
+      IllegalArgumentException
+      NullPointerException
+      e
 
       cond-branch cond:v NE null
       true branch :
         return Integer.decode(v)
 
+        NumberFormatException
+        e
 
       false branch :
 
       return val
-    func  decode()  throws:     NumberFormatException
-      var:radix=10
-      var:index=0
-      var:negative=false
-      var:result
+    func  decode(nm)  throws:     NumberFormatException
+      Decl: radix=10
+      Decl: index=0
+      Decl: negative=false
+      Decl: result
       cond-branch cond:nm.length() EQ 0
       true branch :
-        new NumberFormatException<NumberFormatException>
-      false branch :
+        new NumberFormatException("Zero length string")      false branch :
 
-      var:firstChar=nm.charAt(0)
+      Decl: firstChar=nm.charAt(0)
       cond-branch cond:firstChar EQ -
       true branch :
         negative Assign true
-                  indexInc
+        index Inc
 
       false branch :
         cond-branch cond:firstChar EQ +
         true branch :
-                      indexInc
-
+          index Inc
         false branch :
 
-
       cond-branch cond:nm.startsWith("0x",index) Lor nm.startsWith("0X",index)
       true branch :
         index AddAssign 2
@@ -273,55 +328,57 @@ while val NE 0 Land charPos GT 0
       false branch :
         cond-branch cond:nm.startsWith("#",index)
         true branch :
-                      indexInc
+          index Inc
 
           radix Assign 16
         false branch :
           cond-branch cond:nm.startsWith("0",index) Land nm.length() GT 1 Add index
           true branch :
-                          indexInc
+            index Inc
 
             radix Assign 8
           false branch :
 
-
-
       cond-branch cond:nm.startsWith("-",index) Lor nm.startsWith("+",index)
       true branch :
-        new NumberFormatException<NumberFormatException>
-      false branch :
+        new NumberFormatException("Sign character in wrong position")      false branch :
 
+      result Assign Integer.valueOf(nm.substring(index),radix)
+      result Assign 
+
+      NumberFormatException
+      e
+      Decl: constant=
+      result Assign Integer.valueOf(constant,radix)
 
       return result
-    func  compareTo()  throws: 
+    func  compareTo(anotherInteger)  throws: 
       return compare(this.value,anotherInteger.value)
-    func  compare()  throws: 
+    func  compare(x,y)  throws: 
       return 
-    func  compareUnsigned()  throws: 
+    func  compareUnsigned(x,y)  throws: 
       return compare(x Add MIN_VALUE,y Add MIN_VALUE)
-    func  toUnsignedLong()  throws: 
+    func  toUnsignedLong(x)  throws: 
       return ((long)x) Band -1
-    func  divideUnsigned()  throws: 
-      return (int)()
-    func  remainderUnsigned()  throws: 
-      return (int)()
-    func  highestOneBit()  throws: 
+    func  divideUnsigned(dividend,divisor)  throws: 
+      return (int)(toUnsignedLong(dividend) Div toUnsignedLong(divisor))
+    func  remainderUnsigned(dividend,divisor)  throws: 
+      return (int)(toUnsignedLong(dividend) Mod toUnsignedLong(divisor))
+    func  highestOneBit(i)  throws: 
       i BorAssign (i Shr 1)
       i BorAssign (i Shr 2)
       i BorAssign (i Shr 4)
       i BorAssign (i Shr 8)
       i BorAssign (i Shr 16)
       return i Sub (i Zext 1)
-    func  lowestOneBit()  throws: 
-      return i Band Sub
-  i
-    func  numberOfLeadingZeros()  throws: 
+    func  lowestOneBit(i)  throws: 
+      return i Band Minus i
+    func  numberOfLeadingZeros(i)  throws: 
       cond-branch cond:i EQ 0
       true branch :
-        return 32
-      false branch :
+        return 32      false branch :
 
-      var:n=1
+      Decl: n=1
       cond-branch cond:i Zext 16 EQ 0
       true branch :
         n AddAssign 16
@@ -348,14 +405,13 @@ while val NE 0 Land charPos GT 0
 
       n SubAssign i Zext 31
       return n
-    func  numberOfTrailingZeros()  throws: 
-      var:y
+    func  numberOfTrailingZeros(i)  throws: 
+      Decl: y
       cond-branch cond:i EQ 0
       true branch :
-        return 32
-      false branch :
+        return 32      false branch :
 
-      var:n=31
+      Decl: n=31
       y Assign i Shl 16
       cond-branch cond:y NE 0
       true branch :
@@ -385,41 +441,37 @@ while val NE 0 Land charPos GT 0
       false branch :
 
       return n Sub ((i Shl 1) Zext 31)
-    func  bitCount()  throws: 
+    func  bitCount(i)  throws: 
       i Assign i Sub ((i Zext 1) Band 1431655765)
       i Assign (i Band 858993459) Add ((i Zext 2) Band 858993459)
       i Assign (i Add (i Zext 4)) Band 252645135
       i Assign i Add (i Zext 8)
       i Assign i Add (i Zext 16)
       return i Band 63
-    func  rotateLeft()  throws: 
-      return (i Shl distance) Bor (i Zext Sub
-  distance)
-    func  rotateRight()  throws: 
-      return (i Zext distance) Bor (i Shl Sub
-  distance)
-    func  reverse()  throws: 
+    func  rotateLeft(i,distance)  throws: 
+      return (i Shl distance) Bor (i Zext Minus distance)
+    func  rotateRight(i,distance)  throws: 
+      return (i Zext distance) Bor (i Shl Minus distance)
+    func  reverse(i)  throws: 
       i Assign (i Band 1431655765) Shl 1 Bor (i Zext 1) Band 1431655765
       i Assign (i Band 858993459) Shl 2 Bor (i Zext 2) Band 858993459
       i Assign (i Band 252645135) Shl 4 Bor (i Zext 4) Band 252645135
       i Assign (i Shl 24) Bor ((i Band 65280) Shl 8) Bor ((i Zext 8) Band 65280) Bor (i Zext 24)
       return i
-    func  signum()  throws: 
-      return (i Shr 31) Bor (Sub
-  i Zext 31)
-    func  reverseBytes()  throws: 
+    func  signum(i)  throws: 
+      return (i Shr 31) Bor (Minus i Zext 31)
+    func  reverseBytes(i)  throws: 
       return ((i Zext 24)) Bor ((i Shr 8) Band 65280) Bor ((i Shl 8) Band 16711680) Bor ((i Shl 24))
-    func  sum()  throws: 
+    func  sum(a,b)  throws: 
       return a Add b
-    func  max()  throws: 
+    func  max(a,b)  throws: 
       return Math.max(a,b)
-    func  min()  throws: 
+    func  min(a,b)  throws: 
       return Math.min(a,b)
   LocalClasses: 
     class  IntegerCache
       Fields: 
-        low=Sub
-  128        high        cache[]
+        low=-128        high        cache[]
       Instance Initializer: 
         InstInit- 0
       Constructors: 
@@ -429,3 +481,17 @@ while val NE 0 Land charPos GT 0
       LocalInterfaces: 
   LocalInterfaces: 
 
+Identifier:v has no decl.
+Identifier:IllegalArgumentException has no decl.
+Identifier:NullPointerException has no decl.
+Identifier:e has no decl.
+Identifier:result has no decl.
+Identifier:result has no decl.
+Identifier:NumberFormatException has no decl.
+Identifier:e has no decl.
+Identifier:result has no decl.
+Identifier:n has no decl.
+Identifier:y has no decl.
+Identifier:y has no decl.
+Identifier:y has no decl.
+Identifier:y has no decl.
diff --git a/src/MapleFE/test/openjdk/InternalError.java b/src/MapleFE/test/java/openjdk/InternalError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/InternalError.java
rename to src/MapleFE/test/java/openjdk/InternalError.java
diff --git a/src/MapleFE/test/openjdk/InternalError.java.result b/src/MapleFE/test/java/openjdk/InternalError.java.result
similarity index 56%
rename from src/MapleFE/test/openjdk/InternalError.java.result
rename to src/MapleFE/test/java/openjdk/InternalError.java.result
index aa5aa18b05260e49ae3bd60fbf7b7c82c21a1211..52e5fe44bddeaf366d900e102b77ce79752153bf 100644
--- a/src/MapleFE/test/openjdk/InternalError.java.result
+++ b/src/MapleFE/test/java/openjdk/InternalError.java.result
@@ -1,19 +1,18 @@
 Matched 5 tokens.
-Matched 75 tokens.
+Matched 74 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
 == Sub Tree ==
 class  InternalError
   Fields: 
-    serialVersionUID=Sub
-  1073036797
+    serialVersionUID=-1073036797
   Instance Initializer: 
   Constructors: 
     constructor  InternalError()  throws: 
-    constructor  InternalError()  throws: 
-    constructor  InternalError()  throws: 
-    constructor  InternalError()  throws: 
+    constructor  InternalError(message)  throws: 
+    constructor  InternalError(message,cause)  throws: 
+    constructor  InternalError(cause)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/InterruptedException.java b/src/MapleFE/test/java/openjdk/InterruptedException.java
similarity index 100%
rename from src/MapleFE/test/openjdk/InterruptedException.java
rename to src/MapleFE/test/java/openjdk/InterruptedException.java
diff --git a/src/MapleFE/test/openjdk/InterruptedException.java.result b/src/MapleFE/test/java/openjdk/InterruptedException.java.result
similarity index 86%
rename from src/MapleFE/test/openjdk/InterruptedException.java.result
rename to src/MapleFE/test/java/openjdk/InterruptedException.java.result
index bc6668075dd302f708c1d2663feb797dd1dae816..4b5a4410f404b13956d2eb630afa274728926e7a 100644
--- a/src/MapleFE/test/openjdk/InterruptedException.java.result
+++ b/src/MapleFE/test/java/openjdk/InterruptedException.java.result
@@ -10,7 +10,7 @@ class  InterruptedException
   Instance Initializer: 
   Constructors: 
     constructor  InterruptedException()  throws: 
-    constructor  InterruptedException()  throws: 
+    constructor  InterruptedException(s)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/Iterable.java b/src/MapleFE/test/java/openjdk/Iterable.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Iterable.java
rename to src/MapleFE/test/java/openjdk/Iterable.java
diff --git a/src/MapleFE/test/openjdk/Iterable.java.result b/src/MapleFE/test/java/openjdk/Iterable.java.result
similarity index 95%
rename from src/MapleFE/test/openjdk/Iterable.java.result
rename to src/MapleFE/test/java/openjdk/Iterable.java.result
index 712993fa4593bdbc490a20d453e69e13494d2fe8..79077a8567f50708cb59801ee147234b37165d22 100644
--- a/src/MapleFE/test/openjdk/Iterable.java.result
+++ b/src/MapleFE/test/java/openjdk/Iterable.java.result
@@ -24,7 +24,7 @@ interface  Iterable
 
   Methods: 
     func  iterator()  throws: 
-    func  forEach()  throws: 
+    func  forEach(action)  throws: 
       Objects.requireNonNull(action)
       T
       t
diff --git a/src/MapleFE/test/openjdk/JavaLangAccess.java b/src/MapleFE/test/java/openjdk/JavaLangAccess.java
similarity index 100%
rename from src/MapleFE/test/openjdk/JavaLangAccess.java
rename to src/MapleFE/test/java/openjdk/JavaLangAccess.java
diff --git a/src/MapleFE/test/openjdk/JavaLangAccess.java.result b/src/MapleFE/test/java/openjdk/JavaLangAccess.java.result
similarity index 86%
rename from src/MapleFE/test/openjdk/JavaLangAccess.java.result
rename to src/MapleFE/test/java/openjdk/JavaLangAccess.java.result
index 48ac6364014e58a1577560ba18036244a7e84c6e..df7b84bd64b7f464a202153cc11ab302c5b79a28 100644
--- a/src/MapleFE/test/openjdk/JavaLangAccess.java.result
+++ b/src/MapleFE/test/java/openjdk/JavaLangAccess.java.result
@@ -11,7 +11,7 @@ class  JavaLangAccess
   Constructors: 
     constructor  JavaLangAccess()  throws: 
   Methods: 
-    func  getEnumConstantsShared()  throws: 
+    func  getEnumConstantsShared(klass)  throws: 
       return klass.getEnumConstantsShared()
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/LinkageError.java b/src/MapleFE/test/java/openjdk/LinkageError.java
similarity index 100%
rename from src/MapleFE/test/openjdk/LinkageError.java
rename to src/MapleFE/test/java/openjdk/LinkageError.java
diff --git a/src/MapleFE/test/openjdk/LinkageError.java.result b/src/MapleFE/test/java/openjdk/LinkageError.java.result
similarity index 77%
rename from src/MapleFE/test/openjdk/LinkageError.java.result
rename to src/MapleFE/test/java/openjdk/LinkageError.java.result
index b6b70d10cc091620ed09dba39f5ee9c613776f18..25e4a97982edf6748707966b4502f0e63b60f305 100644
--- a/src/MapleFE/test/openjdk/LinkageError.java.result
+++ b/src/MapleFE/test/java/openjdk/LinkageError.java.result
@@ -10,8 +10,8 @@ class  LinkageError
   Instance Initializer: 
   Constructors: 
     constructor  LinkageError()  throws: 
-    constructor  LinkageError()  throws: 
-    constructor  LinkageError()  throws: 
+    constructor  LinkageError(s)  throws: 
+    constructor  LinkageError(s,cause)  throws: 
   Methods: 
   LocalClasses: 
   LocalInterfaces: 
diff --git a/src/MapleFE/test/openjdk/Long.java b/src/MapleFE/test/java/openjdk/Long.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Long.java
rename to src/MapleFE/test/java/openjdk/Long.java
diff --git a/src/MapleFE/test/openjdk/Long.java.result b/src/MapleFE/test/java/openjdk/Long.java.result
similarity index 47%
rename from src/MapleFE/test/openjdk/Long.java.result
rename to src/MapleFE/test/java/openjdk/Long.java.result
index bfd8e31deed5cc374eed04142ec59f642f62aef4..883f0af4538bc7c6061d3d85e876a8a0d797c913 100644
--- a/src/MapleFE/test/openjdk/Long.java.result
+++ b/src/MapleFE/test/java/openjdk/Long.java.result
@@ -1,7 +1,7 @@
 Matched 5 tokens.
 Matched 14 tokens.
 Matched 21 tokens.
-Matched 3482 tokens.
+Matched 3480 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
@@ -12,37 +12,33 @@ import java.math
 == Sub Tree ==
 class  Long
   Fields: 
-    MIN_VALUE=0    MAX_VALUE=-1    TYPE=()    value    SIZE=64    BYTES=    serialVersionUID=-863034401
+    MIN_VALUE=0    MAX_VALUE=-1    TYPE=()long.getComponentType()    value    SIZE=64    BYTES=SIZE Div Byte.SIZE    serialVersionUID=-863034401
   Instance Initializer: 
   Constructors: 
-    constructor  Long()  throws: 
+    constructor  Long(value)  throws: 
       this.value Assign value
-    constructor  Long()  throws: 
+    constructor  Long(s)  throws: 
       this.value Assign parseLong(s,10)
   Methods: 
-    func  toString()  throws: 
+    func  toString(i,radix)  throws: 
       cond-branch cond:radix LT Character.MIN_RADIX Lor radix GT Character.MAX_RADIX
       true branch :
-        radix Assign 10
-      false branch :
+        radix Assign 10      false branch :
 
       cond-branch cond:radix EQ 10
       true branch :
-        return toString(i)
-      false branch :
+        return toString(i)      false branch :
 
-      var:buf=
-      var:charPos=64
-      var:negative=(i LT 0)
+      Decl: buf=
+      Decl: charPos=64
+      Decl: negative=(i LT 0)
       cond-branch cond:negative
       true branch :
-        i Assign Sub
-  i
+        i Assign Minus i
       false branch :
 
-      while i LE Sub
-  radix         Assign 
-        i Assign 
+      while i LE Minus radix         Assign 
+        i Assign i Div radix
 
        Assign 
       cond-branch cond:negative
@@ -50,77 +46,87 @@ class  Long
          Assign -
       false branch :
 
-      return new String<String>
-    func  toUnsignedString()  throws: 
+      return new String(buf,charPos,(65 Sub charPos))
+    func  toUnsignedString(i,radix)  throws: 
       cond-branch cond:i GE 0
       true branch :
-        return toString(i,radix)
-      false branch :
+        return toString(i,radix)      false branch :
         A switch
 
 
-    func  toUnsignedBigInteger()  throws: 
+    func  toUnsignedBigInteger(i)  throws: 
       cond-branch cond:i GE 0
       true branch :
-        return BigInteger.valueOf(i)
-      false branch :
-        var:upper=(int)(i Zext 32)
-
+        return BigInteger.valueOf(i)      false branch :
+        Decl: upper=(int)(i Zext 32)
+        Decl: lower=(int)i
+        return BigInteger.valueOf(Integer.toUnsignedLong(upper)).shiftLeft(32).add(BigInteger.valueOf(Integer.toUnsignedLong(lower)))
 
-    func  toHexString()  throws: 
+    func  toHexString(i)  throws: 
       return toUnsignedString0(i,4)
-    func  toOctalString()  throws: 
+    func  toOctalString(i)  throws: 
       return toUnsignedString0(i,3)
-    func  toBinaryString()  throws: 
+    func  toBinaryString(i)  throws: 
       return toUnsignedString0(i,1)
-    func  toUnsignedString0()  throws: 
-      var:mag=Long.SIZE Sub Long.numberOfLeadingZeros(val)
-      var:chars=Math.max(((mag Add (shift Sub 1))shift)1)
-      var:buf=
+    func  toUnsignedString0(val,shift)  throws: 
+      Decl: mag=Long.SIZE Sub Long.numberOfLeadingZeros(val)
+      Decl: chars=Math.max(((mag Add (shift Sub 1)) Div shift)1)
+      Decl: buf=
       formatUnsignedLong(val,shift,buf,0,chars)
-      return new String<String>
-    func  formatUnsignedLong()  throws: 
-      var:charPos=len
-      var:radix=1 Shl shift
-      var:mask=radix Sub 1
+      return new String(buf)
+    func  formatUnsignedLong(val,shift,buf,offset,len)  throws: 
+      Decl: charPos=len
+      Decl: radix=1 Shl shift
+      Decl: mask=radix Sub 1
       do          Assign 
         val ZextAssign shift
 while val NE 0 Land charPos GT 0
       return charPos
-    func  toString()  throws: 
+    func  toString(i)  throws: 
       cond-branch cond:i EQ Long.MIN_VALUE
       true branch :
-        return "-9223372036854775808"
-      false branch :
+        return "-9223372036854775808"      false branch :
 
-      var:size=
-      var:buf=
+      Decl: size=
+      Decl: buf=
       getChars(i,size,buf)
-      return new String<String>
-    func  toUnsignedString()  throws: 
+      return new String(buf)
+    func  toUnsignedString(i)  throws: 
       return toUnsignedString(i,10)
-    func  getChars()  throws: 
-      var:q
-      var:r
-      var:charPos=index
-      var:sign=0
+    func  getChars(i,index,buf)  throws: 
+      Decl: q
+      Decl: r
+      Decl: charPos=index
+      Decl: sign=0
       cond-branch cond:i LT 0
       true branch :
         sign Assign -
-        i Assign Sub
-  i
+        i Assign Minus i
       false branch :
 
-      while i GT Integer.MAX_VALUE        q Assign 
-
-
-      var:q2
-      var:i2=(int)i
-      while i2 GE 65536        q2 Assign 
+      while i GT Integer.MAX_VALUE        q Assign i Div 100
+        r Assign (int)(i Sub ((q Shl 6) Add (q Shl 5) Add (q Shl 2)))
+        i Assign q
+         Assign 
+         Assign 
 
+      Decl: q2
+      Decl: i2=(int)i
+      while i2 GE 65536        q2 Assign i2 Div 100
+        r Assign i2 Sub ((q2 Shl 6) Add (q2 Shl 5) Add (q2 Shl 2))
+        i2 Assign q2
+         Assign 
+         Assign 
 
       for ( )
-        q2 Assign () Zext (16 Add 3)
+        q2 Assign (i2 Mul 52429) Zext (16 Add 3)
+        r Assign i2 Sub ((q2 Shl 3) Add (q2 Shl 1))
+         Assign 
+        i2 Assign q2
+        cond-branch cond:i2 EQ 0
+        true branch :
+          break:
+        false branch :
 
 
       cond-branch cond:sign NE 0
@@ -128,113 +134,159 @@ while val NE 0 Land charPos GT 0
          Assign sign
       false branch :
 
-    func  stringSize()  throws: 
-      var:p=10
+    func  stringSize(x)  throws: 
+      Decl: p=10
       for ( )
         cond-branch cond:x LT p
         true branch :
-          return i
-        false branch :
+          return i        false branch :
 
-        p Assign 
+        p Assign 10 Mul p
 
       return 19
-    func  parseLong()  throws:     NumberFormatException
+    func  parseLong(s,radix)  throws:     NumberFormatException
       cond-branch cond:s EQ null
       true branch :
-        new NumberFormatException<NumberFormatException>
+        new NumberFormatException("null")
       false branch :
 
       cond-branch cond:radix LT Character.MIN_RADIX
       true branch :
-        new NumberFormatException<NumberFormatException>
+        new NumberFormatException("radix " Add radix Add " less than Character.MIN_RADIX")
       false branch :
 
       cond-branch cond:radix GT Character.MAX_RADIX
       true branch :
-        new NumberFormatException<NumberFormatException>
+        new NumberFormatException("radix " Add radix Add " greater than Character.MAX_RADIX")
       false branch :
 
-      var:result=0
-      var:negative=false
-      var:i=0,len=s.length()
-      var:limit=Sub
-  Long.MAX_VALUE
-      var:multmin
-      var:digit
+      Decl: result=0
+      Decl: negative=false
+      Decl: i=0,len=s.length()
+      Decl: limit=Minus Long.MAX_VALUE
+      Decl: multmin
+      Decl: digit
       cond-branch cond:len GT 0
       true branch :
-        var:firstChar=s.charAt(0)
+        Decl: firstChar=s.charAt(0)
+        cond-branch cond:firstChar LT 0
+        true branch :
+          cond-branch cond:firstChar EQ -
+          true branch :
+            negative Assign true
+            limit Assign Long.MIN_VALUE
+          false branch :
+            cond-branch cond:firstChar NE +
+            true branch :
+              NumberFormatException.forInputString(s)            false branch :
+
+          cond-branch cond:len EQ 1
+          true branch :
+            NumberFormatException.forInputString(s)          false branch :
+
+          i Inc
+
+        false branch :
+
+        multmin Assign limit Div radix
+        while i LT len          digit Assign Character.digit(s.charAt(i Inc
+),radix)
+          cond-branch cond:digit LT 0
+          true branch :
+            NumberFormatException.forInputString(s)
+          false branch :
+
+          cond-branch cond:result LT multmin
+          true branch :
+            NumberFormatException.forInputString(s)
+          false branch :
+
+          result MulAssign radix
+          cond-branch cond:result LT limit Add digit
+          true branch :
+            NumberFormatException.forInputString(s)
+          false branch :
+
+          result SubAssign digit
 
       false branch :
         NumberFormatException.forInputString(s)
 
       return 
-    func  parseLong()  throws:     NumberFormatException
+    func  parseLong(s)  throws:     NumberFormatException
       return parseLong(s,10)
-    func  parseUnsignedLong()  throws:     NumberFormatException
+    func  parseUnsignedLong(s,radix)  throws:     NumberFormatException
       cond-branch cond:s EQ null
       true branch :
-        new NumberFormatException<NumberFormatException>
+        new NumberFormatException("null")
       false branch :
 
-      var:len=s.length()
+      Decl: len=s.length()
       cond-branch cond:len GT 0
       true branch :
-        var:firstChar=s.charAt(0)
+        Decl: firstChar=s.charAt(0)
         cond-branch cond:firstChar EQ -
         true branch :
-          new NumberFormatException<NumberFormatException>
+          new NumberFormatException(String.format("Illegal leading minus sign " Add "on unsigned string %s.",s))
         false branch :
           cond-branch cond:len LE 12 Lor (radix EQ 10 Land len LE 18)
           true branch :
             return parseLong(s,radix)
           false branch :
 
+          Decl: first=parseLong(s.substring(0,len Sub 1),radix)
+          Decl: second=Character.digit(s.charAt(len Sub 1),radix)
+          cond-branch cond:second LT 0
+          true branch :
+            new NumberFormatException("Bad digit at end of " Add s)
+          false branch :
 
+          Decl: result=first Mul radix Add second
+          cond-branch cond:compareUnsigned(result,first) LT 0
+          true branch :
+            new NumberFormatException(String.format("String value %s exceeds " Add "range of unsigned long.",s))
+          false branch :
+
+          return result
 
       false branch :
         NumberFormatException.forInputString(s)
 
-    func  parseUnsignedLong()  throws:     NumberFormatException
+    func  parseUnsignedLong(s)  throws:     NumberFormatException
       return parseUnsignedLong(s,10)
-    func  valueOf()  throws:     NumberFormatException
+    func  valueOf(s,radix)  throws:     NumberFormatException
       return Long.valueOf(parseLong(s,radix))
-    func  valueOf()  throws:     NumberFormatException
+    func  valueOf(s)  throws:     NumberFormatException
       return Long.valueOf(parseLong(s,10))
-    func  valueOf()  throws: 
-      var:offset=128
-      cond-branch cond:l GE Sub
-  128 Land l LE 127
+    func  valueOf(l)  throws: 
+      Decl: offset=128
+      cond-branch cond:l GE -128 Land l LE 127
       true branch :
         return 
       false branch :
 
-      return new Long<Long>
-    func  decode()  throws:     NumberFormatException
-      var:radix=10
-      var:index=0
-      var:negative=false
-      var:result
+      return new Long(l)
+    func  decode(nm)  throws:     NumberFormatException
+      Decl: radix=10
+      Decl: index=0
+      Decl: negative=false
+      Decl: result
       cond-branch cond:nm.length() EQ 0
       true branch :
-        new NumberFormatException<NumberFormatException>
-      false branch :
+        new NumberFormatException("Zero length string")      false branch :
 
-      var:firstChar=nm.charAt(0)
+      Decl: firstChar=nm.charAt(0)
       cond-branch cond:firstChar EQ -
       true branch :
         negative Assign true
-                  indexInc
+        index Inc
 
       false branch :
         cond-branch cond:firstChar EQ +
         true branch :
-                      indexInc
-
+          index Inc
         false branch :
 
-
       cond-branch cond:nm.startsWith("0x",index) Lor nm.startsWith("0X",index)
       true branch :
         index AddAssign 2
@@ -242,24 +294,28 @@ while val NE 0 Land charPos GT 0
       false branch :
         cond-branch cond:nm.startsWith("#",index)
         true branch :
-                      indexInc
+          index Inc
 
           radix Assign 16
         false branch :
           cond-branch cond:nm.startsWith("0",index) Land nm.length() GT 1 Add index
           true branch :
-                          indexInc
+            index Inc
 
             radix Assign 8
           false branch :
 
-
-
       cond-branch cond:nm.startsWith("-",index) Lor nm.startsWith("+",index)
       true branch :
-        new NumberFormatException<NumberFormatException>
-      false branch :
+        new NumberFormatException("Sign character in wrong position")      false branch :
 
+      result Assign Long.valueOf(nm.substring(index),radix)
+      result Assign 
+
+      NumberFormatException
+      e
+      Decl: constant=
+      result Assign Long.valueOf(constant,radix)
 
       return result
     func  byteValue()  throws: 
@@ -278,40 +334,45 @@ while val NE 0 Land charPos GT 0
       return toString(value)
     func  hashCode()  throws: 
       return Long.hashCode(value)
-    func  hashCode()  throws: 
+    func  hashCode(value)  throws: 
       return (int)(value Bxor (value Zext 32))
-    func  equals()  throws: 
-      cond-branch cond:
+    func  equals(obj)  throws: 
+      cond-branch cond:obj instanceof Long
       true branch :
-        return value EQ ((Long)obj)longValue
+        return value EQ (Long)obj.longValue()
       false branch :
 
       return false
-    func  getLong()  throws: 
+    func  getLong(nm)  throws: 
       return getLong(nm,null)
-    func  getLong()  throws: 
-      var:result=Long.getLong(nm,null)
+    func  getLong(nm,val)  throws: 
+      Decl: result=Long.getLong(nm,null)
       return 
-    func  getLong()  throws: 
-      var:v=null
+    func  getLong(nm,val)  throws: 
+      Decl: v=null
       v Assign System.getProperty(nm)
 
+      IllegalArgumentException
+      NullPointerException
+      e
 
       cond-branch cond:v NE null
       true branch :
         return Long.decode(v)
 
+        NumberFormatException
+        e
 
       false branch :
 
       return val
-    func  compareTo()  throws: 
+    func  compareTo(anotherLong)  throws: 
       return compare(this.value,anotherLong.value)
-    func  compare()  throws: 
+    func  compare(x,y)  throws: 
       return 
-    func  compareUnsigned()  throws: 
+    func  compareUnsigned(x,y)  throws: 
       return compare(x Add MIN_VALUE,y Add MIN_VALUE)
-    func  divideUnsigned()  throws: 
+    func  divideUnsigned(dividend,divisor)  throws: 
       cond-branch cond:divisor LT 0
       true branch :
         return 
@@ -319,23 +380,20 @@ while val NE 0 Land charPos GT 0
 
       cond-branch cond:dividend GT 0
       true branch :
-        return 
-      false branch :
-        return 
+        return dividend Div divisor      false branch :
+        return toUnsignedBigInteger(dividend).divide(toUnsignedBigInteger(divisor)).longValue()
 
-    func  remainderUnsigned()  throws: 
+    func  remainderUnsigned(dividend,divisor)  throws: 
       cond-branch cond:dividend GT 0 Land divisor GT 0
       true branch :
-        return 
+        return dividend Mod divisor
       false branch :
         cond-branch cond:compareUnsigned(dividend,divisor) LT 0
         true branch :
-          return dividend
-        false branch :
-          return 
-
+          return dividend        false branch :
+          return toUnsignedBigInteger(dividend).remainder(toUnsignedBigInteger(divisor)).longValue()
 
-    func  highestOneBit()  throws: 
+    func  highestOneBit(i)  throws: 
       i BorAssign (i Shr 1)
       i BorAssign (i Shr 2)
       i BorAssign (i Shr 4)
@@ -343,17 +401,15 @@ while val NE 0 Land charPos GT 0
       i BorAssign (i Shr 16)
       i BorAssign (i Shr 32)
       return i Sub (i Zext 1)
-    func  lowestOneBit()  throws: 
-      return i Band Sub
-  i
-    func  numberOfLeadingZeros()  throws: 
+    func  lowestOneBit(i)  throws: 
+      return i Band Minus i
+    func  numberOfLeadingZeros(i)  throws: 
       cond-branch cond:i EQ 0
       true branch :
-        return 64
-      false branch :
+        return 64      false branch :
 
-      var:n=1
-      var:x=(int)(i Zext 32)
+      Decl: n=1
+      Decl: x=(int)(i Zext 32)
       cond-branch cond:x EQ 0
       true branch :
         n AddAssign 32
@@ -386,14 +442,13 @@ while val NE 0 Land charPos GT 0
 
       n SubAssign x Zext 31
       return n
-    func  numberOfTrailingZeros()  throws: 
-      var:x,y
+    func  numberOfTrailingZeros(i)  throws: 
+      Decl: x,y
       cond-branch cond:i EQ 0
       true branch :
-        return 64
-      false branch :
+        return 64      false branch :
 
-      var:n=63
+      Decl: n=63
       y Assign (int)i
       cond-branch cond:y NE 0
       true branch :
@@ -401,7 +456,6 @@ while val NE 0 Land charPos GT 0
         x Assign y
       false branch :
         x Assign (int)(i Zext 32)
-
       y Assign x Shl 16
       cond-branch cond:y NE 0
       true branch :
@@ -431,7 +485,7 @@ while val NE 0 Land charPos GT 0
       false branch :
 
       return n Sub ((x Shl 1) Zext 31)
-    func  bitCount()  throws: 
+    func  bitCount(i)  throws: 
       i Assign i Sub ((i Zext 1) Band 1431655765)
       i Assign (i Band 858993459) Add ((i Zext 2) Band 858993459)
       i Assign (i Add (i Zext 4)) Band -252645121
@@ -439,30 +493,27 @@ while val NE 0 Land charPos GT 0
       i Assign i Add (i Zext 16)
       i Assign i Add (i Zext 32)
       return (int)i Band 127
-    func  rotateLeft()  throws: 
-      return (i Shl distance) Bor (i Zext Sub
-  distance)
-    func  rotateRight()  throws: 
-      return (i Zext distance) Bor (i Shl Sub
-  distance)
-    func  reverse()  throws: 
+    func  rotateLeft(i,distance)  throws: 
+      return (i Shl distance) Bor (i Zext Minus distance)
+    func  rotateRight(i,distance)  throws: 
+      return (i Zext distance) Bor (i Shl Minus distance)
+    func  reverse(i)  throws: 
       i Assign (i Band 1431655765) Shl 1 Bor (i Zext 1) Band 1431655765
       i Assign (i Band 858993459) Shl 2 Bor (i Zext 2) Band 858993459
       i Assign (i Band -252645121) Shl 4 Bor (i Zext 4) Band -252645121
       i Assign (i Band 267390975) Shl 8 Bor (i Zext 8) Band 267390975
       i Assign (i Shl 48) Bor ((i Band -1048576) Shl 16) Bor ((i Zext 16) Band -1048576) Bor (i Zext 48)
       return i
-    func  signum()  throws: 
-      return (int)((i Shr 63) Bor (Sub
-  i Zext 63))
-    func  reverseBytes()  throws: 
+    func  signum(i)  throws: 
+      return (int)((i Shr 63) Bor (Minus i Zext 63))
+    func  reverseBytes(i)  throws: 
       i Assign (i Band 267390975) Shl 8 Bor (i Zext 8) Band 267390975
       return (i Shl 48) Bor ((i Band -1048576) Shl 16) Bor ((i Zext 16) Band -1048576) Bor (i Zext 48)
-    func  sum()  throws: 
+    func  sum(a,b)  throws: 
       return a Add b
-    func  max()  throws: 
+    func  max(a,b)  throws: 
       return Math.max(a,b)
-    func  min()  throws: 
+    func  min(a,b)  throws: 
       return Math.min(a,b)
   LocalClasses: 
     class  LongCache
@@ -477,3 +528,23 @@ while val NE 0 Land charPos GT 0
       LocalInterfaces: 
   LocalInterfaces: 
 
+Identifier:result has no decl.
+Identifier:result has no decl.
+Identifier:NumberFormatException has no decl.
+Identifier:e has no decl.
+Identifier:result has no decl.
+Identifier:v has no decl.
+Identifier:IllegalArgumentException has no decl.
+Identifier:NullPointerException has no decl.
+Identifier:e has no decl.
+Identifier:n has no decl.
+Identifier:x has no decl.
+Identifier:y has no decl.
+Identifier:y has no decl.
+Identifier:x has no decl.
+Identifier:y has no decl.
+Identifier:x has no decl.
+Identifier:y has no decl.
+Identifier:x has no decl.
+Identifier:y has no decl.
+Identifier:x has no decl.
diff --git a/src/MapleFE/test/openjdk/Math.java b/src/MapleFE/test/java/openjdk/Math.java
similarity index 100%
rename from src/MapleFE/test/openjdk/Math.java
rename to src/MapleFE/test/java/openjdk/Math.java
diff --git a/src/MapleFE/test/openjdk/Math.java.result b/src/MapleFE/test/java/openjdk/Math.java.result
similarity index 48%
rename from src/MapleFE/test/openjdk/Math.java.result
rename to src/MapleFE/test/java/openjdk/Math.java.result
index a18f75bee0181b780ab8522c42a24c036ac53fbf..47d7b98538b0be951dfc432801ba38c220114992 100644
--- a/src/MapleFE/test/openjdk/Math.java.result
+++ b/src/MapleFE/test/java/openjdk/Math.java.result
@@ -3,9 +3,7 @@ Matched 14 tokens.
 Matched 21 tokens.
 Matched 28 tokens.
 Matched 35 tokens.
-Matched 3300 tokens.
-Convert unary --> binary
-Convert unary --> binary
+Matched 3286 tokens.
 ============= Module ===========
 == Sub Tree ==
 package java.lang
@@ -20,213 +18,214 @@ import sun.misc.DoubleConsts
 == Sub Tree ==
 class  Math
   Fields: 
-    E=2.71828    PI=3.14159    negativeZeroFloatBits=Float.floatToRawIntBits(Sub
-  0)    negativeZeroDoubleBits=Double.doubleToRawLongBits(Sub
-  0)    twoToTheDoubleScaleUp=powerOfTwoD(512)    twoToTheDoubleScaleDown=powerOfTwoD(Sub
-  512)
+    E=2.71828    PI=3.14159    negativeZeroFloatBits=Float.floatToRawIntBits(-0)    negativeZeroDoubleBits=Double.doubleToRawLongBits(-0)    twoToTheDoubleScaleUp=powerOfTwoD(512)    twoToTheDoubleScaleDown=powerOfTwoD(-512)
   Instance Initializer: 
   Constructors: 
     constructor  Math()  throws: 
   Methods: 
-    func  sin()  throws: 
-    func  cos()  throws: 
-    func  tan()  throws: 
-    func  asin()  throws: 
-    func  acos()  throws: 
-    func  atan()  throws: 
-    func  toRadians()  throws: 
-      return 
-    func  toDegrees()  throws: 
-      return 
-    func  exp()  throws: 
-    func  log()  throws: 
-    func  log10()  throws: 
-    func  sqrt()  throws: 
-    func  cbrt()  throws: 
-    func  IEEEremainder()  throws: 
-    func  ceil()  throws: 
-    func  floor()  throws: 
-    func  rint()  throws: 
-    func  atan2()  throws: 
-    func  pow()  throws: 
-    func  round()  throws: 
-      var:intBits=Float.floatToRawIntBits(a)
-      var:biasedExp=(intBits Band FloatConsts.EXP_BIT_MASK) Shr (FloatConsts.SIGNIFICAND_WIDTH Sub 1)
-      var:shift=(FloatConsts.SIGNIFICAND_WIDTH Sub 2 Add FloatConsts.EXP_BIAS) Sub biasedExp
-      cond-branch cond:(shift Band Sub
-  32) EQ 0
-      true branch :
-        var:r=((intBits Band FloatConsts.SIGNIF_BIT_MASK) Bor (FloatConsts.SIGNIF_BIT_MASK Add 1))
+    func  sin(a)  throws: 
+    func  cos(a)  throws: 
+    func  tan(a)  throws: 
+    func  asin(a)  throws: 
+    func  acos(a)  throws: 
+    func  atan(a)  throws: 
+    func  toRadians(angdeg)  throws: 
+      return angdeg Div 180 Mul PI
+    func  toDegrees(angrad)  throws: 
+      return angrad Mul 180 Div PI
+    func  exp(a)  throws: 
+    func  log(a)  throws: 
+    func  log10(a)  throws: 
+    func  sqrt(a)  throws: 
+    func  cbrt(a)  throws: 
+    func  IEEEremainder(f1,f2)  throws: 
+    func  ceil(a)  throws: 
+    func  floor(a)  throws: 
+    func  rint(a)  throws: 
+    func  atan2(y,x)  throws: 
+    func  pow(a,b)  throws: 
+    func  round(a)  throws: 
+      Decl: intBits=Float.floatToRawIntBits(a)
+      Decl: biasedExp=(intBits Band FloatConsts.EXP_BIT_MASK) Shr (FloatConsts.SIGNIFICAND_WIDTH Sub 1)
+      Decl: shift=(FloatConsts.SIGNIFICAND_WIDTH Sub 2 Add FloatConsts.EXP_BIAS) Sub biasedExp
+      cond-branch cond:(shift Band -32) EQ 0
+      true branch :
+        Decl: r=((intBits Band FloatConsts.SIGNIF_BIT_MASK) Bor (FloatConsts.SIGNIF_BIT_MASK Add 1))
+        cond-branch cond:intBits LT 0
+        true branch :
+          r Assign Minus r
+        false branch :
 
+        return ((r Shr shift) Add 1) Shr 1
       false branch :
         return (int)a
 
-    func  round()  throws: 
-      var:longBits=Double.doubleToRawLongBits(a)
-      var:biasedExp=(longBits Band DoubleConsts.EXP_BIT_MASK) Shr (DoubleConsts.SIGNIFICAND_WIDTH Sub 1)
-      var:shift=(DoubleConsts.SIGNIFICAND_WIDTH Sub 2 Add DoubleConsts.EXP_BIAS) Sub biasedExp
-      cond-branch cond:(shift Band Sub
-  64) EQ 0
+    func  round(a)  throws: 
+      Decl: longBits=Double.doubleToRawLongBits(a)
+      Decl: biasedExp=(longBits Band DoubleConsts.EXP_BIT_MASK) Shr (DoubleConsts.SIGNIFICAND_WIDTH Sub 1)
+      Decl: shift=(DoubleConsts.SIGNIFICAND_WIDTH Sub 2 Add DoubleConsts.EXP_BIAS) Sub biasedExp
+      cond-branch cond:(shift Band -64) EQ 0
       true branch :
-        var:r=((longBits Band DoubleConsts.SIGNIF_BIT_MASK) Bor (DoubleConsts.SIGNIF_BIT_MASK Add 1))
+        Decl: r=((longBits Band DoubleConsts.SIGNIF_BIT_MASK) Bor (DoubleConsts.SIGNIF_BIT_MASK Add 1))
+        cond-branch cond:longBits LT 0
+        true branch :
+          r Assign Minus r
+        false branch :
 
+        return ((r Shr shift) Add 1) Shr 1
       false branch :
         return (long)a
 
     func  random()  throws: 
       return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble()
-    func  setRandomSeedInternal()  throws: 
+    func  setRandomSeedInternal(seed)  throws: 
       RandomNumberGeneratorHolder.randomNumberGenerator.setSeed(seed)
     func  randomIntInternal()  throws: 
       return RandomNumberGeneratorHolder.randomNumberGenerator.nextInt()
     func  randomLongInternal()  throws: 
       return RandomNumberGeneratorHolder.randomNumberGenerator.nextLong()
-    func  addExact()  throws: 
-      var:r=x Add y
+    func  addExact(x,y)  throws: 
+      Decl: r=x Add y
       cond-branch cond:((x Bxor r) Band (y Bxor r)) LT 0
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("integer overflow")
       false branch :
 
       return r
-    func  addExact()  throws: 
-      var:r=x Add y
+    func  addExact(x,y)  throws: 
+      Decl: r=x Add y
       cond-branch cond:((x Bxor r) Band (y Bxor r)) LT 0
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("long overflow")
       false branch :
 
       return r
-    func  subtractExact()  throws: 
-      var:r=x Sub y
+    func  subtractExact(x,y)  throws: 
+      Decl: r=x Sub y
       cond-branch cond:((x Bxor y) Band (x Bxor r)) LT 0
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("integer overflow")
       false branch :
 
       return r
-    func  subtractExact()  throws: 
-      var:r=x Sub y
+    func  subtractExact(x,y)  throws: 
+      Decl: r=x Sub y
       cond-branch cond:((x Bxor y) Band (x Bxor r)) LT 0
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("long overflow")
       false branch :
 
       return r
-    func  multiplyExact()  throws: 
-      var:r=
+    func  multiplyExact(x,y)  throws: 
+      Decl: r=(long)x Mul (long)y
       cond-branch cond:(int)r NE r
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("integer overflow")
       false branch :
 
       return (int)r
-    func  multiplyExact()  throws: 
-      var:r=
-      var:ax=Math.abs(x)
-      var:ay=Math.abs(y)
+    func  multiplyExact(x,y)  throws: 
+      Decl: r=x Mul y
+      Decl: ax=Math.abs(x)
+      Decl: ay=Math.abs(y)
       cond-branch cond:((ax Bor ay) Zext 31 NE 0)
       true branch :
-        cond-branch cond:((y NE 0) Land ( NE x)) Lor (x EQ Long.MIN_VALUE Land y EQ Sub
-  1)
+        cond-branch cond:((y NE 0) Land (r Div y NE x)) Lor (x EQ Long.MIN_VALUE Land y EQ -1)
         true branch :
-          new ArithmeticException<ArithmeticException>
+          new ArithmeticException("long overflow")
         false branch :
 
       false branch :
 
       return r
-    func  incrementExact()  throws: 
+    func  incrementExact(a)  throws: 
       cond-branch cond:a EQ Integer.MAX_VALUE
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("integer overflow")
       false branch :
 
       return a Add 1
-    func  incrementExact()  throws: 
+    func  incrementExact(a)  throws: 
       cond-branch cond:a EQ Long.MAX_VALUE
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("long overflow")
       false branch :
 
       return a Add 1
-    func  decrementExact()  throws: 
+    func  decrementExact(a)  throws: 
       cond-branch cond:a EQ Integer.MIN_VALUE
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("integer overflow")
       false branch :
 
       return a Sub 1
-    func  decrementExact()  throws: 
+    func  decrementExact(a)  throws: 
       cond-branch cond:a EQ Long.MIN_VALUE
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("long overflow")
       false branch :
 
       return a Sub 1
-    func  negateExact()  throws: 
+    func  negateExact(a)  throws: 
       cond-branch cond:a EQ Integer.MIN_VALUE
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("integer overflow")
       false branch :
 
-      return Sub
-  a
-    func  negateExact()  throws: 
+      return Minus a
+    func  negateExact(a)  throws: 
       cond-branch cond:a EQ Long.MIN_VALUE
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("long overflow")
       false branch :
 
-      return Sub
-  a
-    func  toIntExact()  throws: 
+      return Minus a
+    func  toIntExact(value)  throws: 
       cond-branch cond:(int)value NE value
       true branch :
-        new ArithmeticException<ArithmeticException>
+        new ArithmeticException("integer overflow")
       false branch :
 
       return (int)value
-    func  floorDiv()  throws: 
-      var:r=
-      cond-branch cond:(x Bxor y) LT 0 Land ( NE x)
+    func  floorDiv(x,y)  throws: 
+      Decl: r=x Div y
+      cond-branch cond:(x Bxor y) LT 0 Land (r Mul y NE x)
       true branch :
-                  rDec
+        r Dec
 
       false branch :
 
       return r
-    func  floorDiv()  throws: 
-      var:r=
-      cond-branch cond:(x Bxor y) LT 0 Land ( NE x)
+    func  floorDiv(x,y)  throws: 
+      Decl: r=x Div y
+      cond-branch cond:(x Bxor y) LT 0 Land (r Mul y NE x)
       true branch :
-                  rDec
+        r Dec
 
       false branch :
 
       return r
-    func  floorMod()  throws: 
-      var:r=x Sub 
+    func  floorMod(x,y)  throws: 
+      Decl: r=x Sub floorDiv(x,y) Mul y
       return r
-    func  floorMod()  throws: 
-      return x Sub 
-    func  abs()  throws: 
+    func  floorMod(x,y)  throws: 
+      return x Sub floorDiv(x,y) Mul y
+    func  abs(a)  throws: 
       return 
-    func  abs()  throws: 
+    func  abs(a)  throws: 
       return 
-    func  abs()  throws: 
+    func  abs(a)  throws: 
       return Float.intBitsToFloat(2147483647 Band Float.floatToRawIntBits(a))
-    func  abs()  throws: 
+    func  abs(a)  throws: 
       return Double.longBitsToDouble(-1 Band Double.doubleToRawLongBits(a))
-    func  max()  throws: 
+    func  max(a,b)  throws: 
       return 
-    func  max()  throws: 
+    func  max(a,b)  throws: 
       return 
-    func  max()  throws: 
+    func  max(a,b)  throws: 
       cond-branch cond:a NE a
       true branch :
-        return a
-      false branch :
+        return a      false branch :
 
       cond-branch cond:(a EQ 0) Land (b EQ 0) Land (Float.floatToRawIntBits(a) EQ negativeZeroFloatBits)
       true branch :
@@ -234,11 +233,10 @@ class  Math
       false branch :
 
       return 
-    func  max()  throws: 
+    func  max(a,b)  throws: 
       cond-branch cond:a NE a
       true branch :
-        return a
-      false branch :
+        return a      false branch :
 
       cond-branch cond:(a EQ 0) Land (b EQ 0) Land (Double.doubleToRawLongBits(a) EQ negativeZeroDoubleBits)
       true branch :
@@ -246,15 +244,14 @@ class  Math
       false branch :
 
       return 
-    func  min()  throws: 
+    func  min(a,b)  throws: 
       return 
-    func  min()  throws: 
+    func  min(a,b)  throws: 
       return 
-    func  min()  throws: 
+    func  min(a,b)  throws: 
       cond-branch cond:a NE a
       true branch :
-        return a
-      false branch :
+        return a      false branch :
 
       cond-branch cond:(a EQ 0) Land (b EQ 0) Land (Float.floatToRawIntBits(b) EQ negativeZeroFloatBits)
       true branch :
@@ -262,11 +259,10 @@ class  Math
       false branch :
 
       return 
-    func  min()  throws: 
+    func  min(a,b)  throws: 
       cond-branch cond:a NE a
       true branch :
-        return a
-      false branch :
+        return a      false branch :
 
       cond-branch cond:(a EQ 0) Land (b EQ 0) Land (Double.doubleToRawLongBits(b) EQ negativeZeroDoubleBits)
       true branch :
@@ -274,33 +270,33 @@ class  Math
       false branch :
 
       return 
-    func  ulp()  throws: 
-      var:exp=getExponent(d)
+    func  ulp(d)  throws: 
+      Decl: exp=getExponent(d)
       A switch
 
-    func  ulp()  throws: 
-      var:exp=getExponent(f)
+    func  ulp(f)  throws: 
+      Decl: exp=getExponent(f)
       A switch
 
-    func  signum()  throws: 
+    func  signum(d)  throws: 
       return 
-    func  signum()  throws: 
+    func  signum(f)  throws: 
       return 
-    func  sinh()  throws: 
-    func  cosh()  throws: 
-    func  tanh()  throws: 
-    func  hypot()  throws: 
-    func  expm1()  throws: 
-    func  log1p()  throws: 
-    func  copySign()  throws: 
+    func  sinh(x)  throws: 
+    func  cosh(x)  throws: 
+    func  tanh(x)  throws: 
+    func  hypot(x,y)  throws: 
+    func  expm1(x)  throws: 
+    func  log1p(x)  throws: 
+    func  copySign(magnitude,sign)  throws: 
       return Double.longBitsToDouble((Double.doubleToRawLongBits(sign) Band (DoubleConsts.SIGN_BIT_MASK)) Bor (Double.doubleToRawLongBits(magnitude) Band (DoubleConsts.EXP_BIT_MASK Bor DoubleConsts.SIGNIF_BIT_MASK)))
-    func  copySign()  throws: 
+    func  copySign(magnitude,sign)  throws: 
       return Float.intBitsToFloat((Float.floatToRawIntBits(sign) Band (FloatConsts.SIGN_BIT_MASK)) Bor (Float.floatToRawIntBits(magnitude) Band (FloatConsts.EXP_BIT_MASK Bor FloatConsts.SIGNIF_BIT_MASK)))
-    func  getExponent()  throws: 
+    func  getExponent(f)  throws: 
       return ((Float.floatToRawIntBits(f) Band FloatConsts.EXP_BIT_MASK) Shr (FloatConsts.SIGNIFICAND_WIDTH Sub 1)) Sub FloatConsts.EXP_BIAS
-    func  getExponent()  throws: 
+    func  getExponent(d)  throws: 
       return (int)(((Double.doubleToRawLongBits(d) Band DoubleConsts.EXP_BIT_MASK) Shr (DoubleConsts.SIGNIFICAND_WIDTH Sub 1)) Sub DoubleConsts.EXP_BIAS)
-    func  nextAfter()  throws: 
+    func  nextAfter(start,direction)  throws: 
       cond-branch cond:Double.isNaN(start) Lor Double.isNaN(direction)
       true branch :
         return start Add direction
@@ -309,11 +305,23 @@ class  Math
         true branch :
           return direction
         false branch :
-          var:transducer=Double.doubleToRawLongBits(start Add 0)
-
-
-
-    func  nextAfter()  throws: 
+          Decl: transducer=Double.doubleToRawLongBits(start Add 0)
+          cond-branch cond:direction GT start
+          true branch :
+            transducer Assign transducer Add ()
+          false branch :
+            assert direction LT start : 
+            cond-branch cond:transducer GT 0
+            true branch :
+              PreDec transducer            false branch :
+              cond-branch cond:transducer LT 0
+              true branch :
+                PreInc transducer              false branch :
+                transducer Assign DoubleConsts.SIGN_BIT_MASK Bor 1
+
+          return Double.longBitsToDouble(transducer)
+
+    func  nextAfter(start,direction)  throws: 
       cond-branch cond:Float.isNaN(start) Lor Double.isNaN(direction)
       true branch :
         return start Add (float)direction
@@ -322,67 +330,70 @@ class  Math
         true branch :
           return (float)direction
         false branch :
-          var:transducer=Float.floatToRawIntBits(start Add 0)
-
-
-
-    func  nextUp()  throws: 
+          Decl: transducer=Float.floatToRawIntBits(start Add 0)
+          cond-branch cond:direction GT start
+          true branch :
+            transducer Assign transducer Add ()
+          false branch :
+            assert direction LT start : 
+            cond-branch cond:transducer GT 0
+            true branch :
+              PreDec transducer            false branch :
+              cond-branch cond:transducer LT 0
+              true branch :
+                PreInc transducer              false branch :
+                transducer Assign FloatConsts.SIGN_BIT_MASK Bor 1
+
+          return Float.intBitsToFloat(transducer)
+
+    func  nextUp(d)  throws: 
       cond-branch cond:Double.isNaN(d) Lor d EQ Double.POSITIVE_INFINITY
       true branch :
-        return d
-      false branch :
+        return d      false branch :
         d AddAssign 0
         return Double.longBitsToDouble(Double.doubleToRawLongBits(d) Add ())
 
-    func  nextUp()  throws: 
+    func  nextUp(f)  throws: 
       cond-branch cond:Float.isNaN(f) Lor f EQ FloatConsts.POSITIVE_INFINITY
       true branch :
-        return f
-      false branch :
+        return f      false branch :
         f AddAssign 0
         return Float.intBitsToFloat(Float.floatToRawIntBits(f) Add ())
 
-    func  nextDown()  throws: 
+    func  nextDown(d)  throws: 
       cond-branch cond:Double.isNaN(d) Lor d EQ Double.NEGATIVE_INFINITY
       true branch :
-        return d
-      false branch :
+        return d      false branch :
         cond-branch cond:d EQ 0
         true branch :
-          return Sub
-  Double.MIN_VALUE
-        false branch :
+          return Minus Double.MIN_VALUE        false branch :
           return Double.longBitsToDouble(Double.doubleToRawLongBits(d) Add ())
 
-
-    func  nextDown()  throws: 
+    func  nextDown(f)  throws: 
       cond-branch cond:Float.isNaN(f) Lor f EQ Float.NEGATIVE_INFINITY
       true branch :
-        return f
-      false branch :
+        return f      false branch :
         cond-branch cond:f EQ 0
         true branch :
-          return Sub
-  Float.MIN_VALUE
-        false branch :
+          return Minus Float.MIN_VALUE        false branch :
           return Float.intBitsToFloat(Float.floatToRawIntBits(f) Add ())
 
-
-    func  scalb()  throws: 
-      var:MAX_SCALE=DoubleConsts.MAX_EXPONENT Add Sub
-  DoubleConsts.MIN_EXPONENT Add DoubleConsts.SIGNIFICAND_WIDTH Add 1
-      var:exp_adjust=0
-      var:scale_increment=0
-      var:exp_delta=Double.NaN
+    func  scalb(d,scaleFactor)  throws: 
+      Decl: MAX_SCALE=DoubleConsts.MAX_EXPONENT Add Minus DoubleConsts.MIN_EXPONENT Add DoubleConsts.SIGNIFICAND_WIDTH Add 1
+      Decl: exp_adjust=0
+      Decl: scale_increment=0
+      Decl: exp_delta=Double.NaN
       cond-branch cond:scaleFactor LT 0
       true branch :
-        scaleFactor Assign Math.max(scaleFactor Sub MAX_SCALE)
-
+        scaleFactor Assign Math.max(scaleFactor,Minus MAX_SCALE)
+        scale_increment Assign -512
+        exp_delta Assign twoToTheDoubleScaleDown
       false branch :
         scaleFactor Assign Math.min(scaleFactor,MAX_SCALE)
+        scale_increment Assign 512
+        exp_delta Assign twoToTheDoubleScaleUp
 
-
-      var:t=(scaleFactor Shr 9 Sub 1) Zext 32 Sub 9
+      Decl: t=(scaleFactor Shr 9 Sub 1) Zext 32 Sub 9
       exp_adjust Assign ((scaleFactor Add t) Band (512 Sub 1)) Sub t
       d MulAssign powerOfTwoD(exp_adjust)
       scaleFactor SubAssign exp_adjust
@@ -390,21 +401,20 @@ class  Math
         scaleFactor SubAssign scale_increment
 
       return d
-    func  scalb()  throws: 
-      var:MAX_SCALE=FloatConsts.MAX_EXPONENT Add Sub
-  FloatConsts.MIN_EXPONENT Add FloatConsts.SIGNIFICAND_WIDTH Add 1
-      scaleFactor Assign Math.max(Math.min(scaleFactor,MAX_SCALE) Sub MAX_SCALE)
-      return (float)()
-    func  powerOfTwoD()  throws: 
+    func  scalb(f,scaleFactor)  throws: 
+      Decl: MAX_SCALE=FloatConsts.MAX_EXPONENT Add Minus FloatConsts.MIN_EXPONENT Add FloatConsts.SIGNIFICAND_WIDTH Add 1
+      scaleFactor Assign Math.max(Math.min(scaleFactor,MAX_SCALE),Minus MAX_SCALE)
+      return (float)((double)f Mul powerOfTwoD(scaleFactor))
+    func  powerOfTwoD(n)  throws: 
       assert (n GE DoubleConsts.MIN_EXPONENT Land n LE DoubleConsts.MAX_EXPONENT) : 
       return Double.longBitsToDouble((((long)n Add (long)DoubleConsts.EXP_BIAS) Shl (DoubleConsts.SIGNIFICAND_WIDTH Sub 1)) Band DoubleConsts.EXP_BIT_MASK)
-    func  powerOfTwoF()  throws: 
+    func  powerOfTwoF(n)  throws: 
       assert (n GE FloatConsts.MIN_EXPONENT Land n LE FloatConsts.MAX_EXPONENT) : 
       return Float.intBitsToFloat(((n Add FloatConsts.EXP_BIAS) Shl (FloatConsts.SIGNIFICAND_WIDTH Sub 1)) Band FloatConsts.EXP_BIT_MASK)
   LocalClasses: 
     class  RandomNumberGeneratorHolder
       Fields: 
-        randomNumberGenerator=new Random<Random>
+        randomNumberGenerator=new Random()
       Instance Initializer: 
       Constructors: 
       Methods: 
@@ -412,3 +422,6 @@ class  Math
       LocalInterfaces: 
   LocalInterfaces: 
 
+Identifier:exp_adjust has no decl.
+Identifier:t has no decl.
+Identifier:exp_adjust has no decl.
diff --git a/src/MapleFE/test/java/openjdk/NegativeArraySizeException.java b/src/MapleFE/test/java/openjdk/NegativeArraySizeException.java
new file mode 100644
index 0000000000000000000000000000000000000000..a90c8157e5ba879eebcc1498498ba1481f43fe6b
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NegativeArraySizeException.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown if an application tries to create an array with negative size.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NegativeArraySizeException extends RuntimeException {
+    private static final long serialVersionUID = -8960118058596991861L;
+
+    /**
+     * Constructs a <code>NegativeArraySizeException</code> with no
+     * detail message.
+     */
+    public NegativeArraySizeException() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NegativeArraySizeException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NegativeArraySizeException(String s) {
+        super(s);
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/NegativeArraySizeException.java.result b/src/MapleFE/test/java/openjdk/NegativeArraySizeException.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..c3722843d45de39a0e0df2186fe8e19593ab976d
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NegativeArraySizeException.java.result
@@ -0,0 +1,17 @@
+Matched 5 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  NegativeArraySizeException
+  Fields: 
+    serialVersionUID=868449419
+  Instance Initializer: 
+  Constructors: 
+    constructor  NegativeArraySizeException()  throws: 
+    constructor  NegativeArraySizeException(s)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/NoClassDefFoundError.java b/src/MapleFE/test/java/openjdk/NoClassDefFoundError.java
new file mode 100644
index 0000000000000000000000000000000000000000..869c8d9fb2ba8ab303b3211433fd37149e0f37e9
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoClassDefFoundError.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown if the Java Virtual Machine or a <code>ClassLoader</code> instance
+ * tries to load in the definition of a class (as part of a normal method call
+ * or as part of creating a new instance using the <code>new</code> expression)
+ * and no definition of the class could be found.
+ * <p>
+ * The searched-for class definition existed when the currently
+ * executing class was compiled, but the definition can no longer be
+ * found.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NoClassDefFoundError extends LinkageError {
+    private static final long serialVersionUID = 9095859863287012458L;
+
+    /**
+     * Constructs a <code>NoClassDefFoundError</code> with no detail message.
+     */
+    public NoClassDefFoundError() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NoClassDefFoundError</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NoClassDefFoundError(String s) {
+        super(s);
+    }
+
+    /**
+     * Constructs a new {@code NoClassDefFoundError} with the current stack
+     * trace, the specified detail message and the specified cause. Used
+     * internally by the Android runtime.
+     *
+     * @param detailMessage
+     *            the detail message for this error.
+     * @param throwable
+     *            the cause of this error.
+     */
+    private NoClassDefFoundError(String detailMessage, Throwable throwable) {
+        super(detailMessage, throwable);
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/NoClassDefFoundError.java.result b/src/MapleFE/test/java/openjdk/NoClassDefFoundError.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..cc0491c55d3f01d700fcd1ec5edfb7530fee872e
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoClassDefFoundError.java.result
@@ -0,0 +1,18 @@
+Matched 5 tokens.
+Matched 61 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  NoClassDefFoundError
+  Fields: 
+    serialVersionUID=-1913349014
+  Instance Initializer: 
+  Constructors: 
+    constructor  NoClassDefFoundError()  throws: 
+    constructor  NoClassDefFoundError(s)  throws: 
+    constructor  NoClassDefFoundError(detailMessage,throwable)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/NoSuchFieldError.java b/src/MapleFE/test/java/openjdk/NoSuchFieldError.java
new file mode 100644
index 0000000000000000000000000000000000000000..735adbbf0953a919fceb1bf37ccb340afbbb8ebc
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoSuchFieldError.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown if an application tries to access or modify a specified
+ * field of an object, and that object no longer has that field.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NoSuchFieldError extends IncompatibleClassChangeError {
+    private static final long serialVersionUID = -3456430195886129035L;
+
+    /**
+     * Constructs a <code>NoSuchFieldError</code> with no detail message.
+     */
+    public NoSuchFieldError() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NoSuchFieldError</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NoSuchFieldError(String s) {
+        super(s);
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/NoSuchFieldError.java.result b/src/MapleFE/test/java/openjdk/NoSuchFieldError.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..a0036f96ccd68048e728cac3d1f88141a434110a
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoSuchFieldError.java.result
@@ -0,0 +1,17 @@
+Matched 5 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  NoSuchFieldError
+  Fields: 
+    serialVersionUID=-1085931403
+  Instance Initializer: 
+  Constructors: 
+    constructor  NoSuchFieldError()  throws: 
+    constructor  NoSuchFieldError(s)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/NoSuchFieldException.java b/src/MapleFE/test/java/openjdk/NoSuchFieldException.java
new file mode 100644
index 0000000000000000000000000000000000000000..0058264e5a719e205d66d91ae57170ae58370f78
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoSuchFieldException.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 1996, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Signals that the class doesn't have a field of a specified name.
+ *
+ * @author  unascribed
+ * @since   JDK1.1
+ */
+public class NoSuchFieldException extends ReflectiveOperationException {
+    private static final long serialVersionUID = -6143714805279938260L;
+
+    /**
+     * Constructor.
+     */
+    public NoSuchFieldException() {
+        super();
+    }
+
+    /**
+     * Constructor with a detail message.
+     *
+     * @param s the detail message
+     */
+    public NoSuchFieldException(String s) {
+        super(s);
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/NoSuchFieldException.java.result b/src/MapleFE/test/java/openjdk/NoSuchFieldException.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..6bb1d4f27cb61fefbd8af53f9f7d896cea44ce58
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoSuchFieldException.java.result
@@ -0,0 +1,17 @@
+Matched 5 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  NoSuchFieldException
+  Fields: 
+    serialVersionUID=1979394348
+  Instance Initializer: 
+  Constructors: 
+    constructor  NoSuchFieldException()  throws: 
+    constructor  NoSuchFieldException(s)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/NoSuchMethodError.java b/src/MapleFE/test/java/openjdk/NoSuchMethodError.java
new file mode 100644
index 0000000000000000000000000000000000000000..248de62667c4915f189bbe7af2975559f1a92815
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoSuchMethodError.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown if an application tries to call a specified method of a
+ * class (either static or instance), and that class no longer has a
+ * definition of that method.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NoSuchMethodError extends IncompatibleClassChangeError {
+    private static final long serialVersionUID = -3765521442372831335L;
+
+    /**
+     * Constructs a <code>NoSuchMethodError</code> with no detail message.
+     */
+    public NoSuchMethodError() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NoSuchMethodError</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NoSuchMethodError(String s) {
+        super(s);
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/NoSuchMethodError.java.result b/src/MapleFE/test/java/openjdk/NoSuchMethodError.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..091ac4af475856ec5f928564149b33513bff24cf
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoSuchMethodError.java.result
@@ -0,0 +1,17 @@
+Matched 5 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  NoSuchMethodError
+  Fields: 
+    serialVersionUID=-515885159
+  Instance Initializer: 
+  Constructors: 
+    constructor  NoSuchMethodError()  throws: 
+    constructor  NoSuchMethodError(s)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/NoSuchMethodException.java b/src/MapleFE/test/java/openjdk/NoSuchMethodException.java
new file mode 100644
index 0000000000000000000000000000000000000000..701437c9887b2f65f9a0c3887e912ea66ba5fd18
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoSuchMethodException.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when a particular method cannot be found.
+ *
+ * @author     unascribed
+ * @since      JDK1.0
+ */
+public
+class NoSuchMethodException extends ReflectiveOperationException {
+    private static final long serialVersionUID = 5034388446362600923L;
+
+    /**
+     * Constructs a <code>NoSuchMethodException</code> without a detail message.
+     */
+    public NoSuchMethodException() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NoSuchMethodException</code> with a detail message.
+     *
+     * @param      s   the detail message.
+     */
+    public NoSuchMethodException(String s) {
+        super(s);
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/NoSuchMethodException.java.result b/src/MapleFE/test/java/openjdk/NoSuchMethodException.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..29371ab7362ed4e9940537e646b7ed999580ade4
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NoSuchMethodException.java.result
@@ -0,0 +1,17 @@
+Matched 5 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  NoSuchMethodException
+  Fields: 
+    serialVersionUID=1590035931
+  Instance Initializer: 
+  Constructors: 
+    constructor  NoSuchMethodException()  throws: 
+    constructor  NoSuchMethodException(s)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/NullPointerException.java b/src/MapleFE/test/java/openjdk/NullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b87ec4fd7c96bf2f7e70e68c8d40e9806c2ca75
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NullPointerException.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when an application attempts to use {@code null} in a
+ * case where an object is required. These include:
+ * <ul>
+ * <li>Calling the instance method of a {@code null} object.
+ * <li>Accessing or modifying the field of a {@code null} object.
+ * <li>Taking the length of {@code null} as if it were an array.
+ * <li>Accessing or modifying the slots of {@code null} as if it
+ *     were an array.
+ * <li>Throwing {@code null} as if it were a {@code Throwable}
+ *     value.
+ * </ul>
+ * <p>
+ * Applications should throw instances of this class to indicate
+ * other illegal uses of the {@code null} object.
+ *
+ * {@code NullPointerException} objects may be constructed by the
+ * virtual machine as if {@linkplain Throwable#Throwable(String,
+ * Throwable, boolean, boolean) suppression were disabled and/or the
+ * stack trace was not writable}.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NullPointerException extends RuntimeException {
+    private static final long serialVersionUID = 5162710183389028792L;
+
+    /**
+     * Constructs a {@code NullPointerException} with no detail message.
+     */
+    public NullPointerException() {
+        super();
+    }
+
+    /**
+     * Constructs a {@code NullPointerException} with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NullPointerException(String s) {
+        super(s);
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/NullPointerException.java.result b/src/MapleFE/test/java/openjdk/NullPointerException.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..7553e10f11f1111adae6258d9fc53e9e8a21db99
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NullPointerException.java.result
@@ -0,0 +1,17 @@
+Matched 5 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  NullPointerException
+  Fields: 
+    serialVersionUID=-13508168
+  Instance Initializer: 
+  Constructors: 
+    constructor  NullPointerException()  throws: 
+    constructor  NullPointerException(s)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/Number.java b/src/MapleFE/test/java/openjdk/Number.java
new file mode 100644
index 0000000000000000000000000000000000000000..d901609571b1ef1a6675bcb4caf096c858af3512
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Number.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * The abstract class {@code Number} is the superclass of platform
+ * classes representing numeric values that are convertible to the
+ * primitive types {@code byte}, {@code double}, {@code float}, {@code
+ * int}, {@code long}, and {@code short}.
+ *
+ * The specific semantics of the conversion from the numeric value of
+ * a particular {@code Number} implementation to a given primitive
+ * type is defined by the {@code Number} implementation in question.
+ *
+ * For platform classes, the conversion is often analogous to a
+ * narrowing primitive conversion or a widening primitive conversion
+ * as defining in <cite>The Java&trade; Language Specification</cite>
+ * for converting between primitive types.  Therefore, conversions may
+ * lose information about the overall magnitude of a numeric value, may
+ * lose precision, and may even return a result of a different sign
+ * than the input.
+ *
+ * See the documentation of a given {@code Number} implementation for
+ * conversion details.
+ *
+ * @author      Lee Boynton
+ * @author      Arthur van Hoff
+ * @jls 5.1.2 Widening Primitive Conversions
+ * @jls 5.1.3 Narrowing Primitive Conversions
+ * @since   JDK1.0
+ */
+public abstract class Number implements java.io.Serializable {
+    /**
+     * Returns the value of the specified number as an {@code int},
+     * which may involve rounding or truncation.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code int}.
+     */
+    public abstract int intValue();
+
+    /**
+     * Returns the value of the specified number as a {@code long},
+     * which may involve rounding or truncation.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code long}.
+     */
+    public abstract long longValue();
+
+    /**
+     * Returns the value of the specified number as a {@code float},
+     * which may involve rounding.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code float}.
+     */
+    public abstract float floatValue();
+
+    /**
+     * Returns the value of the specified number as a {@code double},
+     * which may involve rounding.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code double}.
+     */
+    public abstract double doubleValue();
+
+    /**
+     * Returns the value of the specified number as a {@code byte},
+     * which may involve rounding or truncation.
+     *
+     * <p>This implementation returns the result of {@link #intValue} cast
+     * to a {@code byte}.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code byte}.
+     * @since   JDK1.1
+     */
+    public byte byteValue() {
+        return (byte)intValue();
+    }
+
+    /**
+     * Returns the value of the specified number as a {@code short},
+     * which may involve rounding or truncation.
+     *
+     * <p>This implementation returns the result of {@link #intValue} cast
+     * to a {@code short}.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code short}.
+     * @since   JDK1.1
+     */
+    public short shortValue() {
+        return (short)intValue();
+    }
+
+    /** use serialVersionUID from JDK 1.0.2 for interoperability */
+    private static final long serialVersionUID = -8742448824652078965L;
+}
diff --git a/src/MapleFE/test/java/openjdk/Number.java.result b/src/MapleFE/test/java/openjdk/Number.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..1893622d300feeefb89605521d99af6279a948cb
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Number.java.result
@@ -0,0 +1,23 @@
+Matched 5 tokens.
+Matched 83 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  Number
+  Fields: 
+    serialVersionUID=194306187
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  intValue()  throws: 
+    func  longValue()  throws: 
+    func  floatValue()  throws: 
+    func  doubleValue()  throws: 
+    func  byteValue()  throws: 
+      return (byte)intValue()
+    func  shortValue()  throws: 
+      return (short)intValue()
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/NumberFormatException.java b/src/MapleFE/test/java/openjdk/NumberFormatException.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea1ec9fd7714269e46a839c1810133afbbc8da6b
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NumberFormatException.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown to indicate that the application has attempted to convert
+ * a string to one of the numeric types, but that the string does not
+ * have the appropriate format.
+ *
+ * @author  unascribed
+ * @see     java.lang.Integer#parseInt(String)
+ * @since   JDK1.0
+ */
+public
+class NumberFormatException extends IllegalArgumentException {
+    static final long serialVersionUID = -2848938806368998894L;
+
+    /**
+     * Constructs a <code>NumberFormatException</code> with no detail message.
+     */
+    public NumberFormatException () {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NumberFormatException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NumberFormatException (String s) {
+        super (s);
+    }
+
+    /**
+     * Factory method for making a <code>NumberFormatException</code>
+     * given the specified input which caused the error.
+     *
+     * @param   s   the input causing the error
+     */
+    static NumberFormatException forInputString(String s) {
+        return new NumberFormatException("For input string: \"" + s + "\"");
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/NumberFormatException.java.result b/src/MapleFE/test/java/openjdk/NumberFormatException.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..3641aa05de9998fffb8fd18a83d8408c5a14bd58
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/NumberFormatException.java.result
@@ -0,0 +1,19 @@
+Matched 5 tokens.
+Matched 62 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  NumberFormatException
+  Fields: 
+    serialVersionUID=-74651118
+  Instance Initializer: 
+  Constructors: 
+    constructor  NumberFormatException()  throws: 
+    constructor  NumberFormatException(s)  throws: 
+  Methods: 
+    func  forInputString(s)  throws: 
+      return new NumberFormatException("For input string: \"" Add s Add "\"")
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/Object.java b/src/MapleFE/test/java/openjdk/Object.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9728e08224a92e160ed2b6fe3672a8a28973ff0
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Object.java
@@ -0,0 +1,582 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.optimization.FastNative;
+
+/**
+ * Class {@code Object} is the root of the class hierarchy.
+ * Every class has {@code Object} as a superclass. All objects,
+ * including arrays, implement the methods of this class.
+ *
+ * @author  unascribed
+ * @see     java.lang.Class
+ * @since   JDK1.0
+ */
+public class Object {
+
+    private transient Class<?> shadow$_klass_;
+    private transient int shadow$_monitor_;
+
+    /**
+     * Returns the runtime class of this {@code Object}. The returned
+     * {@code Class} object is the object that is locked by {@code
+     * static synchronized} methods of the represented class.
+     *
+     * <p><b>The actual result type is {@code Class<? extends |X|>}
+     * where {@code |X|} is the erasure of the static type of the
+     * expression on which {@code getClass} is called.</b> For
+     * example, no cast is required in this code fragment:</p>
+     *
+     * <p>
+     * {@code Number n = 0;                             }<br>
+     * {@code Class<? extends Number> c = n.getClass(); }
+     * </p>
+     *
+     * @return The {@code Class} object that represents the runtime
+     *         class of this object.
+     * @jls 15.8.2 Class Literals
+     */
+    public final Class<?> getClass() {
+      return shadow$_klass_;
+    }
+
+    /**
+     * Returns a hash code value for the object. This method is
+     * supported for the benefit of hash tables such as those provided by
+     * {@link java.util.HashMap}.
+     * <p>
+     * The general contract of {@code hashCode} is:
+     * <ul>
+     * <li>Whenever it is invoked on the same object more than once during
+     *     an execution of a Java application, the {@code hashCode} method
+     *     must consistently return the same integer, provided no information
+     *     used in {@code equals} comparisons on the object is modified.
+     *     This integer need not remain consistent from one execution of an
+     *     application to another execution of the same application.
+     * <li>If two objects are equal according to the {@code equals(Object)}
+     *     method, then calling the {@code hashCode} method on each of
+     *     the two objects must produce the same integer result.
+     * <li>It is <em>not</em> required that if two objects are unequal
+     *     according to the {@link java.lang.Object#equals(java.lang.Object)}
+     *     method, then calling the {@code hashCode} method on each of the
+     *     two objects must produce distinct integer results.  However, the
+     *     programmer should be aware that producing distinct integer results
+     *     for unequal objects may improve the performance of hash tables.
+     * </ul>
+     * <p>
+     * As much as is reasonably practical, the hashCode method defined by
+     * class {@code Object} does return distinct integers for distinct
+     * objects. (This is typically implemented by converting the internal
+     * address of the object into an integer, but this implementation
+     * technique is not required by the
+     * Java&trade; programming language.)
+     *
+     * @return  a hash code value for this object.
+     * @see     java.lang.Object#equals(java.lang.Object)
+     * @see     java.lang.System#identityHashCode
+     */
+    public int hashCode() {
+        return identityHashCode(this);
+    }
+
+    // Android-changed: add a local helper for identityHashCode.
+    // Package-private to be used by j.l.System. We do the implementation here
+    // to avoid Object.hashCode doing a clinit check on j.l.System, and also
+    // to avoid leaking shadow$_monitor_ outside of this class.
+    /* package-private */ static int identityHashCode(Object obj) {
+        int lockWord = obj.shadow$_monitor_;
+        final int lockWordStateMask = 0xC0000000;  // Top 2 bits.
+        final int lockWordStateHash = 0x80000000;  // Top 2 bits are value 2 (kStateHash).
+        final int lockWordHashMask = 0x0FFFFFFF;  // Low 28 bits.
+        if ((lockWord & lockWordStateMask) == lockWordStateHash) {
+            return lockWord & lockWordHashMask;
+        }
+        return identityHashCodeNative(obj);
+    }
+
+    @FastNative
+    private static native int identityHashCodeNative(Object obj);
+
+    /**
+     * Indicates whether some other object is "equal to" this one.
+     * <p>
+     * The {@code equals} method implements an equivalence relation
+     * on non-null object references:
+     * <ul>
+     * <li>It is <i>reflexive</i>: for any non-null reference value
+     *     {@code x}, {@code x.equals(x)} should return
+     *     {@code true}.
+     * <li>It is <i>symmetric</i>: for any non-null reference values
+     *     {@code x} and {@code y}, {@code x.equals(y)}
+     *     should return {@code true} if and only if
+     *     {@code y.equals(x)} returns {@code true}.
+     * <li>It is <i>transitive</i>: for any non-null reference values
+     *     {@code x}, {@code y}, and {@code z}, if
+     *     {@code x.equals(y)} returns {@code true} and
+     *     {@code y.equals(z)} returns {@code true}, then
+     *     {@code x.equals(z)} should return {@code true}.
+     * <li>It is <i>consistent</i>: for any non-null reference values
+     *     {@code x} and {@code y}, multiple invocations of
+     *     {@code x.equals(y)} consistently return {@code true}
+     *     or consistently return {@code false}, provided no
+     *     information used in {@code equals} comparisons on the
+     *     objects is modified.
+     * <li>For any non-null reference value {@code x},
+     *     {@code x.equals(null)} should return {@code false}.
+     * </ul>
+     * <p>
+     * The {@code equals} method for class {@code Object} implements
+     * the most discriminating possible equivalence relation on objects;
+     * that is, for any non-null reference values {@code x} and
+     * {@code y}, this method returns {@code true} if and only
+     * if {@code x} and {@code y} refer to the same object
+     * ({@code x == y} has the value {@code true}).
+     * <p>
+     * Note that it is generally necessary to override the {@code hashCode}
+     * method whenever this method is overridden, so as to maintain the
+     * general contract for the {@code hashCode} method, which states
+     * that equal objects must have equal hash codes.
+     *
+     * @param   obj   the reference object with which to compare.
+     * @return  {@code true} if this object is the same as the obj
+     *          argument; {@code false} otherwise.
+     * @see     #hashCode()
+     * @see     java.util.HashMap
+     */
+    public boolean equals(Object obj) {
+        return (this == obj);
+    }
+
+    /**
+     * Creates and returns a copy of this object.  The precise meaning
+     * of "copy" may depend on the class of the object. The general
+     * intent is that, for any object {@code x}, the expression:
+     * <blockquote>
+     * <pre>
+     * x.clone() != x</pre></blockquote>
+     * will be true, and that the expression:
+     * <blockquote>
+     * <pre>
+     * x.clone().getClass() == x.getClass()</pre></blockquote>
+     * will be {@code true}, but these are not absolute requirements.
+     * While it is typically the case that:
+     * <blockquote>
+     * <pre>
+     * x.clone().equals(x)</pre></blockquote>
+     * will be {@code true}, this is not an absolute requirement.
+     * <p>
+     * By convention, the returned object should be obtained by calling
+     * {@code super.clone}.  If a class and all of its superclasses (except
+     * {@code Object}) obey this convention, it will be the case that
+     * {@code x.clone().getClass() == x.getClass()}.
+     * <p>
+     * By convention, the object returned by this method should be independent
+     * of this object (which is being cloned).  To achieve this independence,
+     * it may be necessary to modify one or more fields of the object returned
+     * by {@code super.clone} before returning it.  Typically, this means
+     * copying any mutable objects that comprise the internal "deep structure"
+     * of the object being cloned and replacing the references to these
+     * objects with references to the copies.  If a class contains only
+     * primitive fields or references to immutable objects, then it is usually
+     * the case that no fields in the object returned by {@code super.clone}
+     * need to be modified.
+     * <p>
+     * The method {@code clone} for class {@code Object} performs a
+     * specific cloning operation. First, if the class of this object does
+     * not implement the interface {@code Cloneable}, then a
+     * {@code CloneNotSupportedException} is thrown. Note that all arrays
+     * are considered to implement the interface {@code Cloneable} and that
+     * the return type of the {@code clone} method of an array type {@code T[]}
+     * is {@code T[]} where T is any reference or primitive type.
+     * Otherwise, this method creates a new instance of the class of this
+     * object and initializes all its fields with exactly the contents of
+     * the corresponding fields of this object, as if by assignment; the
+     * contents of the fields are not themselves cloned. Thus, this method
+     * performs a "shallow copy" of this object, not a "deep copy" operation.
+     * <p>
+     * The class {@code Object} does not itself implement the interface
+     * {@code Cloneable}, so calling the {@code clone} method on an object
+     * whose class is {@code Object} will result in throwing an
+     * exception at run time.
+     *
+     * @return     a clone of this instance.
+     * @throws  CloneNotSupportedException  if the object's class does not
+     *               support the {@code Cloneable} interface. Subclasses
+     *               that override the {@code clone} method can also
+     *               throw this exception to indicate that an instance cannot
+     *               be cloned.
+     * @see java.lang.Cloneable
+     */
+    protected Object clone() throws CloneNotSupportedException {
+        if (!(this instanceof Cloneable)) {
+            throw new CloneNotSupportedException("Class " + getClass().getName() +
+                                                 " doesn't implement Cloneable");
+        }
+
+        return internalClone();
+    }
+
+    /*
+     * Native helper method for cloning.
+     */
+    @FastNative
+    private native Object internalClone();
+
+
+    /**
+     * Returns a string representation of the object. In general, the
+     * {@code toString} method returns a string that
+     * "textually represents" this object. The result should
+     * be a concise but informative representation that is easy for a
+     * person to read.
+     * It is recommended that all subclasses override this method.
+     * <p>
+     * The {@code toString} method for class {@code Object}
+     * returns a string consisting of the name of the class of which the
+     * object is an instance, the at-sign character `{@code @}', and
+     * the unsigned hexadecimal representation of the hash code of the
+     * object. In other words, this method returns a string equal to the
+     * value of:
+     * <blockquote>
+     * <pre>
+     * getClass().getName() + '@' + Integer.toHexString(hashCode())
+     * </pre></blockquote>
+     *
+     * @return  a string representation of the object.
+     */
+    public String toString() {
+        return getClass().getName() + "@" + Integer.toHexString(hashCode());
+    }
+
+    /**
+     * Wakes up a single thread that is waiting on this object's
+     * monitor. If any threads are waiting on this object, one of them
+     * is chosen to be awakened. The choice is arbitrary and occurs at
+     * the discretion of the implementation. A thread waits on an object's
+     * monitor by calling one of the {@code wait} methods.
+     * <p>
+     * The awakened thread will not be able to proceed until the current
+     * thread relinquishes the lock on this object. The awakened thread will
+     * compete in the usual manner with any other threads that might be
+     * actively competing to synchronize on this object; for example, the
+     * awakened thread enjoys no reliable privilege or disadvantage in being
+     * the next thread to lock this object.
+     * <p>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. A thread becomes the owner of the
+     * object's monitor in one of three ways:
+     * <ul>
+     * <li>By executing a synchronized instance method of that object.
+     * <li>By executing the body of a {@code synchronized} statement
+     *     that synchronizes on the object.
+     * <li>For objects of type {@code Class,} by executing a
+     *     synchronized static method of that class.
+     * </ul>
+     * <p>
+     * Only one thread at a time can own an object's monitor.
+     *
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of this object's monitor.
+     * @see        java.lang.Object#notifyAll()
+     * @see        java.lang.Object#wait()
+     */
+    @FastNative
+    public final native void notify();
+
+    /**
+     * Wakes up all threads that are waiting on this object's monitor. A
+     * thread waits on an object's monitor by calling one of the
+     * {@code wait} methods.
+     * <p>
+     * The awakened threads will not be able to proceed until the current
+     * thread relinquishes the lock on this object. The awakened threads
+     * will compete in the usual manner with any other threads that might
+     * be actively competing to synchronize on this object; for example,
+     * the awakened threads enjoy no reliable privilege or disadvantage in
+     * being the next thread to lock this object.
+     * <p>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. See the {@code notify} method for a
+     * description of the ways in which a thread can become the owner of
+     * a monitor.
+     *
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of this object's monitor.
+     * @see        java.lang.Object#notify()
+     * @see        java.lang.Object#wait()
+     */
+    @FastNative
+    public final native void notifyAll();
+
+    /**
+     * Causes the current thread to wait until either another thread invokes the
+     * {@link java.lang.Object#notify()} method or the
+     * {@link java.lang.Object#notifyAll()} method for this object, or a
+     * specified amount of time has elapsed.
+     * <p>
+     * The current thread must own this object's monitor.
+     * <p>
+     * This method causes the current thread (call it <var>T</var>) to
+     * place itself in the wait set for this object and then to relinquish
+     * any and all synchronization claims on this object. Thread <var>T</var>
+     * becomes disabled for thread scheduling purposes and lies dormant
+     * until one of four things happens:
+     * <ul>
+     * <li>Some other thread invokes the {@code notify} method for this
+     * object and thread <var>T</var> happens to be arbitrarily chosen as
+     * the thread to be awakened.
+     * <li>Some other thread invokes the {@code notifyAll} method for this
+     * object.
+     * <li>Some other thread {@linkplain Thread#interrupt() interrupts}
+     * thread <var>T</var>.
+     * <li>The specified amount of real time has elapsed, more or less.  If
+     * {@code timeout} is zero, however, then real time is not taken into
+     * consideration and the thread simply waits until notified.
+     * </ul>
+     * The thread <var>T</var> is then removed from the wait set for this
+     * object and re-enabled for thread scheduling. It then competes in the
+     * usual manner with other threads for the right to synchronize on the
+     * object; once it has gained control of the object, all its
+     * synchronization claims on the object are restored to the status quo
+     * ante - that is, to the situation as of the time that the {@code wait}
+     * method was invoked. Thread <var>T</var> then returns from the
+     * invocation of the {@code wait} method. Thus, on return from the
+     * {@code wait} method, the synchronization state of the object and of
+     * thread {@code T} is exactly as it was when the {@code wait} method
+     * was invoked.
+     * <p>
+     * A thread can also wake up without being notified, interrupted, or
+     * timing out, a so-called <i>spurious wakeup</i>.  While this will rarely
+     * occur in practice, applications must guard against it by testing for
+     * the condition that should have caused the thread to be awakened, and
+     * continuing to wait if the condition is not satisfied.  In other words,
+     * waits should always occur in loops, like this one:
+     * <pre>
+     *     synchronized (obj) {
+     *         while (&lt;condition does not hold&gt;)
+     *             obj.wait(timeout);
+     *         ... // Perform action appropriate to condition
+     *     }
+     * </pre>
+     * (For more information on this topic, see Section 3.2.3 in Doug Lea's
+     * "Concurrent Programming in Java (Second Edition)" (Addison-Wesley,
+     * 2000), or Item 50 in Joshua Bloch's "Effective Java Programming
+     * Language Guide" (Addison-Wesley, 2001).
+     *
+     * <p>If the current thread is {@linkplain java.lang.Thread#interrupt()
+     * interrupted} by any thread before or while it is waiting, then an
+     * {@code InterruptedException} is thrown.  This exception is not
+     * thrown until the lock status of this object has been restored as
+     * described above.
+     *
+     * <p>
+     * Note that the {@code wait} method, as it places the current thread
+     * into the wait set for this object, unlocks only this object; any
+     * other objects on which the current thread may be synchronized remain
+     * locked while the thread waits.
+     * <p>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. See the {@code notify} method for a
+     * description of the ways in which a thread can become the owner of
+     * a monitor.
+     *
+     * @param      millis   the maximum time to wait in milliseconds.
+     * @throws  IllegalArgumentException      if the value of timeout is
+     *               negative.
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of the object's monitor.
+     * @throws  InterruptedException if any thread interrupted the
+     *             current thread before or while the current thread
+     *             was waiting for a notification.  The <i>interrupted
+     *             status</i> of the current thread is cleared when
+     *             this exception is thrown.
+     * @see        java.lang.Object#notify()
+     * @see        java.lang.Object#notifyAll()
+     */
+    public final void wait(long millis) throws InterruptedException {
+        wait(millis, 0);
+    }
+
+    /**
+     * Causes the current thread to wait until another thread invokes the
+     * {@link java.lang.Object#notify()} method or the
+     * {@link java.lang.Object#notifyAll()} method for this object, or
+     * some other thread interrupts the current thread, or a certain
+     * amount of real time has elapsed.
+     * <p>
+     * This method is similar to the {@code wait} method of one
+     * argument, but it allows finer control over the amount of time to
+     * wait for a notification before giving up. The amount of real time,
+     * measured in nanoseconds, is given by:
+     * <blockquote>
+     * <pre>
+     * 1000000*timeout+nanos</pre></blockquote>
+     * <p>
+     * In all other respects, this method does the same thing as the
+     * method {@link #wait(long)} of one argument. In particular,
+     * {@code wait(0, 0)} means the same thing as {@code wait(0)}.
+     * <p>
+     * The current thread must own this object's monitor. The thread
+     * releases ownership of this monitor and waits until either of the
+     * following two conditions has occurred:
+     * <ul>
+     * <li>Another thread notifies threads waiting on this object's monitor
+     *     to wake up either through a call to the {@code notify} method
+     *     or the {@code notifyAll} method.
+     * <li>The timeout period, specified by {@code timeout}
+     *     milliseconds plus {@code nanos} nanoseconds arguments, has
+     *     elapsed.
+     * </ul>
+     * <p>
+     * The thread then waits until it can re-obtain ownership of the
+     * monitor and resumes execution.
+     * <p>
+     * As in the one argument version, interrupts and spurious wakeups are
+     * possible, and this method should always be used in a loop:
+     * <pre>
+     *     synchronized (obj) {
+     *         while (&lt;condition does not hold&gt;)
+     *             obj.wait(timeout, nanos);
+     *         ... // Perform action appropriate to condition
+     *     }
+     * </pre>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. See the {@code notify} method for a
+     * description of the ways in which a thread can become the owner of
+     * a monitor.
+     *
+     * @param      millis   the maximum time to wait in milliseconds.
+     * @param      nanos      additional time, in nanoseconds range
+     *                       0-999999.
+     * @throws  IllegalArgumentException      if the value of timeout is
+     *                      negative or the value of nanos is
+     *                      not in the range 0-999999.
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of this object's monitor.
+     * @throws  InterruptedException if any thread interrupted the
+     *             current thread before or while the current thread
+     *             was waiting for a notification.  The <i>interrupted
+     *             status</i> of the current thread is cleared when
+     *             this exception is thrown.
+     */
+    @FastNative
+    public final native void wait(long millis, int nanos) throws InterruptedException;
+
+    /**
+     * Causes the current thread to wait until another thread invokes the
+     * {@link java.lang.Object#notify()} method or the
+     * {@link java.lang.Object#notifyAll()} method for this object.
+     * In other words, this method behaves exactly as if it simply
+     * performs the call {@code wait(0)}.
+     * <p>
+     * The current thread must own this object's monitor. The thread
+     * releases ownership of this monitor and waits until another thread
+     * notifies threads waiting on this object's monitor to wake up
+     * either through a call to the {@code notify} method or the
+     * {@code notifyAll} method. The thread then waits until it can
+     * re-obtain ownership of the monitor and resumes execution.
+     * <p>
+     * As in the one argument version, interrupts and spurious wakeups are
+     * possible, and this method should always be used in a loop:
+     * <pre>
+     *     synchronized (obj) {
+     *         while (&lt;condition does not hold&gt;)
+     *             obj.wait();
+     *         ... // Perform action appropriate to condition
+     *     }
+     * </pre>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. See the {@code notify} method for a
+     * description of the ways in which a thread can become the owner of
+     * a monitor.
+     *
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of the object's monitor.
+     * @throws  InterruptedException if any thread interrupted the
+     *             current thread before or while the current thread
+     *             was waiting for a notification.  The <i>interrupted
+     *             status</i> of the current thread is cleared when
+     *             this exception is thrown.
+     * @see        java.lang.Object#notify()
+     * @see        java.lang.Object#notifyAll()
+     */
+    @FastNative
+    public final native void wait() throws InterruptedException;
+
+    /**
+     * Called by the garbage collector on an object when garbage collection
+     * determines that there are no more references to the object.
+     * A subclass overrides the {@code finalize} method to dispose of
+     * system resources or to perform other cleanup.
+     * <p>
+     * The general contract of {@code finalize} is that it is invoked
+     * if and when the Java&trade; virtual
+     * machine has determined that there is no longer any
+     * means by which this object can be accessed by any thread that has
+     * not yet died, except as a result of an action taken by the
+     * finalization of some other object or class which is ready to be
+     * finalized. The {@code finalize} method may take any action, including
+     * making this object available again to other threads; the usual purpose
+     * of {@code finalize}, however, is to perform cleanup actions before
+     * the object is irrevocably discarded. For example, the finalize method
+     * for an object that represents an input/output connection might perform
+     * explicit I/O transactions to break the connection before the object is
+     * permanently discarded.
+     * <p>
+     * The {@code finalize} method of class {@code Object} performs no
+     * special action; it simply returns normally. Subclasses of
+     * {@code Object} may override this definition.
+     * <p>
+     * The Java programming language does not guarantee which thread will
+     * invoke the {@code finalize} method for any given object. It is
+     * guaranteed, however, that the thread that invokes finalize will not
+     * be holding any user-visible synchronization locks when finalize is
+     * invoked. If an uncaught exception is thrown by the finalize method,
+     * the exception is ignored and finalization of that object terminates.
+     * <p>
+     * After the {@code finalize} method has been invoked for an object, no
+     * further action is taken until the Java virtual machine has again
+     * determined that there is no longer any means by which this object can
+     * be accessed by any thread that has not yet died, including possible
+     * actions by other objects or classes which are ready to be finalized,
+     * at which point the object may be discarded.
+     * <p>
+     * The {@code finalize} method is never invoked more than once by a Java
+     * virtual machine for any given object.
+     * <p>
+     * Any exception thrown by the {@code finalize} method causes
+     * the finalization of this object to be halted, but is otherwise
+     * ignored.
+     *
+     * @throws Throwable the {@code Exception} raised by this method
+     * @see java.lang.ref.WeakReference
+     * @see java.lang.ref.PhantomReference
+     * @jls 12.6 Finalization of Class Instances
+     */
+    protected void finalize() throws Throwable { }
+}
diff --git a/src/MapleFE/test/java/openjdk/Object.java.result b/src/MapleFE/test/java/openjdk/Object.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..d30bd56472a1e3a9411caeddeb4dbd5390e95311
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Object.java.result
@@ -0,0 +1,53 @@
+Matched 5 tokens.
+Matched 14 tokens.
+Matched 299 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import dalvik.annotation.optimization.FastNative
+== Sub Tree ==
+class  Object
+  Fields: 
+    shadow$_klass_    shadow$_monitor_
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  getClass()  throws: 
+      return shadow$_klass_
+    func  hashCode()  throws: 
+      return identityHashCode(this)
+    func  identityHashCode(obj)  throws: 
+      Decl: lockWord=obj.shadow$_monitor_
+      Decl: lockWordStateMask=-1073741824
+      Decl: lockWordStateHash=-2147483648
+      Decl: lockWordHashMask=268435455
+      cond-branch cond:(lockWord Band lockWordStateMask) EQ lockWordStateHash
+      true branch :
+        return lockWord Band lockWordHashMask
+      false branch :
+
+      return identityHashCodeNative(obj)
+    func  identityHashCodeNative(obj)  throws: 
+    func  equals(obj)  throws: 
+      return (this EQ obj)
+    func  clone()  throws:     CloneNotSupportedException
+      cond-branch cond:(this instanceof Cloneable)
+      true branch :
+        new CloneNotSupportedException("Class " Add getClass().getName() Add " doesn't implement Cloneable")
+      false branch :
+
+      return internalClone()
+    func  internalClone()  throws: 
+    func  toString()  throws: 
+      return getClass().getName() Add "@" Add Integer.toHexString(hashCode())
+    func  notify()  throws: 
+    func  notifyAll()  throws: 
+    func  wait(millis)  throws:     InterruptedException
+      wait(millis,0)
+    func  wait(millis,nanos)  throws:     InterruptedException
+    func  wait()  throws:     InterruptedException
+    func  finalize()  throws:     Throwable
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/OutOfMemoryError.java b/src/MapleFE/test/java/openjdk/OutOfMemoryError.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f9df4e2f16519225e69515e7bd162d778346c76
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/OutOfMemoryError.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when the Java Virtual Machine cannot allocate an object
+ * because it is out of memory, and no more memory could be made
+ * available by the garbage collector.
+ *
+ * {@code OutOfMemoryError} objects may be constructed by the virtual
+ * machine as if {@linkplain Throwable#Throwable(String, Throwable,
+ * boolean, boolean) suppression were disabled and/or the stack trace was not
+ * writable}.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public class OutOfMemoryError extends VirtualMachineError {
+    private static final long serialVersionUID = 8228564086184010517L;
+
+    /**
+     * Constructs an {@code OutOfMemoryError} with no detail message.
+     */
+    public OutOfMemoryError() {
+        super();
+    }
+
+    /**
+     * Constructs an {@code OutOfMemoryError} with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public OutOfMemoryError(String s) {
+        super(s);
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/OutOfMemoryError.java.result b/src/MapleFE/test/java/openjdk/OutOfMemoryError.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..75397242fea0e8bb190ddc82dd91d2eb10e47c1f
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/OutOfMemoryError.java.result
@@ -0,0 +1,17 @@
+Matched 5 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  OutOfMemoryError
+  Fields: 
+    serialVersionUID=-2004294891
+  Instance Initializer: 
+  Constructors: 
+    constructor  OutOfMemoryError()  throws: 
+    constructor  OutOfMemoryError(s)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/Override.java b/src/MapleFE/test/java/openjdk/Override.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf77344296cb6f07b940fc132e5a6a3963c4650a
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Override.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import java.lang.annotation.*;
+
+/**
+ * Indicates that a method declaration is intended to override a
+ * method declaration in a supertype. If a method is annotated with
+ * this annotation type compilers are required to generate an error
+ * message unless at least one of the following conditions hold:
+ *
+ * <ul><li>
+ * The method does override or implement a method declared in a
+ * supertype.
+ * </li><li>
+ * The method has a signature that is override-equivalent to that of
+ * any public method declared in {@linkplain Object}.
+ * </li></ul>
+ *
+ * @author  Peter von der Ah&eacute;
+ * @author  Joshua Bloch
+ * @jls 9.6.1.4 @Override
+ * @since 1.5
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.SOURCE)
+public @interface Override {
+}
diff --git a/src/MapleFE/test/java/openjdk/Override.java.result b/src/MapleFE/test/java/openjdk/Override.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..6f3311685210623aa18bcd56ecac4db5821da45d
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Override.java.result
@@ -0,0 +1,10 @@
+Matched 5 tokens.
+Matched 14 tokens.
+Matched 34 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import java.lang.annotation
+== Sub Tree ==
+annotation type : Override
diff --git a/src/MapleFE/test/java/openjdk/Package.java b/src/MapleFE/test/java/openjdk/Package.java
new file mode 100644
index 0000000000000000000000000000000000000000..55d2ba7df3299d9e49247e451ef828002efa2fbe
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Package.java
@@ -0,0 +1,657 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import java.lang.reflect.AnnotatedElement;
+import java.io.InputStream;
+import java.util.Enumeration;
+
+import java.util.StringTokenizer;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.URL;
+import java.net.MalformedURLException;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+import java.util.jar.JarInputStream;
+import java.util.jar.Manifest;
+import java.util.jar.Attributes;
+import java.util.jar.Attributes.Name;
+import java.util.jar.JarException;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import sun.net.www.ParseUtil;
+import sun.reflect.CallerSensitive;
+import dalvik.system.VMRuntime;
+import dalvik.system.VMStack;
+
+import java.lang.annotation.Annotation;
+
+/**
+ * {@code Package} objects contain version information
+ * about the implementation and specification of a Java package.
+ * This versioning information is retrieved and made available
+ * by the {@link ClassLoader} instance that
+ * loaded the class(es).  Typically, it is stored in the manifest that is
+ * distributed with the classes.
+ *
+ * <p>The set of classes that make up the package may implement a
+ * particular specification and if so the specification title, version number,
+ * and vendor strings identify that specification.
+ * An application can ask if the package is
+ * compatible with a particular version, see the {@link
+ * #isCompatibleWith isCompatibleWith}
+ * method for details.
+ *
+ * <p>Specification version numbers use a syntax that consists of nonnegative
+ * decimal integers separated by periods ".", for example "2.0" or
+ * "1.2.3.4.5.6.7".  This allows an extensible number to be used to represent
+ * major, minor, micro, etc. versions.  The version specification is described
+ * by the following formal grammar:
+ * <blockquote>
+ * <dl>
+ * <dt><i>SpecificationVersion:</i>
+ * <dd><i>Digits RefinedVersion<sub>opt</sub></i>
+
+ * <dt><i>RefinedVersion:</i>
+ * <dd>{@code .} <i>Digits</i>
+ * <dd>{@code .} <i>Digits RefinedVersion</i>
+ *
+ * <dt><i>Digits:</i>
+ * <dd><i>Digit</i>
+ * <dd><i>Digits</i>
+ *
+ * <dt><i>Digit:</i>
+ * <dd>any character for which {@link Character#isDigit} returns {@code true},
+ * e.g. 0, 1, 2, ...
+ * </dl>
+ * </blockquote>
+ *
+ * <p>The implementation title, version, and vendor strings identify an
+ * implementation and are made available conveniently to enable accurate
+ * reporting of the packages involved when a problem occurs. The contents
+ * all three implementation strings are vendor specific. The
+ * implementation version strings have no specified syntax and should
+ * only be compared for equality with desired version identifiers.
+ *
+ * <p>Within each {@code ClassLoader} instance all classes from the same
+ * java package have the same Package object.  The static methods allow a package
+ * to be found by name or the set of all packages known to the current class
+ * loader to be found.
+ *
+ * @see ClassLoader#definePackage
+ */
+public class Package implements java.lang.reflect.AnnotatedElement {
+    /**
+     * Return the name of this package.
+     *
+     * @return  The fully-qualified name of this package as defined in section 6.5.3 of
+     *          <cite>The Java&trade; Language Specification</cite>,
+     *          for example, {@code java.lang}
+     */
+    public String getName() {
+        return pkgName;
+    }
+
+
+    /**
+     * Return the title of the specification that this package implements.
+     * @return the specification title, null is returned if it is not known.
+     */
+    public String getSpecificationTitle() {
+        return specTitle;
+    }
+
+    /**
+     * Returns the version number of the specification
+     * that this package implements.
+     * This version string must be a sequence of nonnegative decimal
+     * integers separated by "."'s and may have leading zeros.
+     * When version strings are compared the most significant
+     * numbers are compared.
+     * @return the specification version, null is returned if it is not known.
+     */
+    public String getSpecificationVersion() {
+        return specVersion;
+    }
+
+    /**
+     * Return the name of the organization, vendor,
+     * or company that owns and maintains the specification
+     * of the classes that implement this package.
+     * @return the specification vendor, null is returned if it is not known.
+     */
+    public String getSpecificationVendor() {
+        return specVendor;
+    }
+
+    /**
+     * Return the title of this package.
+     * @return the title of the implementation, null is returned if it is not known.
+     */
+    public String getImplementationTitle() {
+        return implTitle;
+    }
+
+    /**
+     * Return the version of this implementation. It consists of any string
+     * assigned by the vendor of this implementation and does
+     * not have any particular syntax specified or expected by the Java
+     * runtime. It may be compared for equality with other
+     * package version strings used for this implementation
+     * by this vendor for this package.
+     * @return the version of the implementation, null is returned if it is not known.
+     */
+    public String getImplementationVersion() {
+        return implVersion;
+    }
+
+    /**
+     * Returns the name of the organization,
+     * vendor or company that provided this implementation.
+     * @return the vendor that implemented this package..
+     */
+    public String getImplementationVendor() {
+        return implVendor;
+    }
+
+    /**
+     * Returns true if this package is sealed.
+     *
+     * @return true if the package is sealed, false otherwise
+     */
+    public boolean isSealed() {
+        return sealBase != null;
+    }
+
+    /**
+     * Returns true if this package is sealed with respect to the specified
+     * code source url.
+     *
+     * @param url the code source url
+     * @return true if this package is sealed with respect to url
+     */
+    public boolean isSealed(URL url) {
+        return url.equals(sealBase);
+    }
+
+    /**
+     * Compare this package's specification version with a
+     * desired version. It returns true if
+     * this packages specification version number is greater than or equal
+     * to the desired version number. <p>
+     *
+     * Version numbers are compared by sequentially comparing corresponding
+     * components of the desired and specification strings.
+     * Each component is converted as a decimal integer and the values
+     * compared.
+     * If the specification value is greater than the desired
+     * value true is returned. If the value is less false is returned.
+     * If the values are equal the period is skipped and the next pair of
+     * components is compared.
+     *
+     * @param desired the version string of the desired version.
+     * @return true if this package's version number is greater
+     *          than or equal to the desired version number
+     *
+     * @exception NumberFormatException if the desired or current version
+     *          is not of the correct dotted form.
+     */
+    public boolean isCompatibleWith(String desired)
+        throws NumberFormatException
+    {
+        if (specVersion == null || specVersion.length() < 1) {
+            throw new NumberFormatException("Empty version string");
+        }
+
+        String [] sa = specVersion.split("\\.", -1);
+        int [] si = new int[sa.length];
+        for (int i = 0; i < sa.length; i++) {
+            si[i] = Integer.parseInt(sa[i]);
+            if (si[i] < 0)
+                throw NumberFormatException.forInputString("" + si[i]);
+        }
+
+        String [] da = desired.split("\\.", -1);
+        int [] di = new int[da.length];
+        for (int i = 0; i < da.length; i++) {
+            di[i] = Integer.parseInt(da[i]);
+            if (di[i] < 0)
+                throw NumberFormatException.forInputString("" + di[i]);
+        }
+
+        int len = Math.max(di.length, si.length);
+        for (int i = 0; i < len; i++) {
+            int d = (i < di.length ? di[i] : 0);
+            int s = (i < si.length ? si[i] : 0);
+            if (s < d)
+                return false;
+            if (s > d)
+                return true;
+        }
+        return true;
+    }
+
+    /**
+     * Find a package by name in the callers {@code ClassLoader} instance.
+     * The callers {@code ClassLoader} instance is used to find the package
+     * instance corresponding to the named class. If the callers
+     * {@code ClassLoader} instance is null then the set of packages loaded
+     * by the system {@code ClassLoader} instance is searched to find the
+     * named package. <p>
+     *
+     * Packages have attributes for versions and specifications only if the class
+     * loader created the package instance with the appropriate attributes. Typically,
+     * those attributes are defined in the manifests that accompany the classes.
+     *
+     * @param name a package name, for example, java.lang.
+     * @return the package of the requested name. It may be null if no package
+     *          information is available from the archive or codebase.
+     */
+    @CallerSensitive
+    public static Package getPackage(String name) {
+        ClassLoader l = VMStack.getCallingClassLoader();
+        if (l != null) {
+            return l.getPackage(name);
+        } else {
+            return getSystemPackage(name);
+        }
+    }
+
+    /**
+     * Get all the packages currently known for the caller's {@code ClassLoader}
+     * instance.  Those packages correspond to classes loaded via or accessible by
+     * name to that {@code ClassLoader} instance.  If the caller's
+     * {@code ClassLoader} instance is the bootstrap {@code ClassLoader}
+     * instance, which may be represented by {@code null} in some implementations,
+     * only packages corresponding to classes loaded by the bootstrap
+     * {@code ClassLoader} instance will be returned.
+     *
+     * @return a new array of packages known to the callers {@code ClassLoader}
+     * instance.  An zero length array is returned if none are known.
+     */
+    @CallerSensitive
+    public static Package[] getPackages() {
+        ClassLoader l = VMStack.getCallingClassLoader();
+        if (l != null) {
+            return l.getPackages();
+        } else {
+            return getSystemPackages();
+        }
+    }
+
+    /**
+     * Get the package for the specified class.
+     * The class's class loader is used to find the package instance
+     * corresponding to the specified class. If the class loader
+     * is the bootstrap class loader, which may be represented by
+     * {@code null} in some implementations, then the set of packages
+     * loaded by the bootstrap class loader is searched to find the package.
+     * <p>
+     * Packages have attributes for versions and specifications only
+     * if the class loader created the package
+     * instance with the appropriate attributes. Typically those
+     * attributes are defined in the manifests that accompany
+     * the classes.
+     *
+     * @param c the class to get the package of.
+     * @return the package of the class. It may be null if no package
+     *          information is available from the archive or codebase.  */
+    static Package getPackage(Class<?> c) {
+        String name = c.getName();
+        int i = name.lastIndexOf('.');
+        if (i != -1) {
+            name = name.substring(0, i);
+            ClassLoader cl = c.getClassLoader();
+            if (cl != null) {
+                return cl.getPackage(name);
+            } else {
+                return getSystemPackage(name);
+            }
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Return the hash code computed from the package name.
+     * @return the hash code computed from the package name.
+     */
+    public int hashCode(){
+        return pkgName.hashCode();
+    }
+
+    /**
+     * Returns the string representation of this Package.
+     * Its value is the string "package " and the package name.
+     * If the package title is defined it is appended.
+     * If the package version is defined it is appended.
+     * @return the string representation of the package.
+     */
+    public String toString() {
+        // Android-changed start
+        // Several apps try to parse the output of toString(). This is a really
+        // bad idea - especially when there's a Package.getName() function as well as a
+        // Class.getName() function that can be used instead.
+        // Starting from the API level 25 the proper output is generated.
+        final int targetSdkVersion = VMRuntime.getRuntime().getTargetSdkVersion();
+        if (targetSdkVersion > 0 && targetSdkVersion <= 24) {
+            return "package " + pkgName;
+        }
+        // Android-changed end
+
+        String spec = specTitle;
+        String ver =  specVersion;
+        if (spec != null && spec.length() > 0)
+            spec = ", " + spec;
+        else
+            spec = "";
+        if (ver != null && ver.length() > 0)
+            ver = ", version " + ver;
+        else
+            ver = "";
+        return "package " + pkgName + spec + ver;
+    }
+
+    private Class<?> getPackageInfo() {
+        if (packageInfo == null) {
+            try {
+                packageInfo = Class.forName(pkgName + ".package-info", false, loader);
+            } catch (ClassNotFoundException ex) {
+                // store a proxy for the package info that has no annotations
+                class PackageInfoProxy {}
+                packageInfo = PackageInfoProxy.class;
+            }
+        }
+        return packageInfo;
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.5
+     */
+    public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
+        return getPackageInfo().getAnnotation(annotationClass);
+    }
+
+    /**
+     * {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.5
+     */
+    @Override
+    public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return AnnotatedElement.super.isAnnotationPresent(annotationClass);
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.8
+     */
+    @Override
+    public  <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationClass) {
+        return getPackageInfo().getAnnotationsByType(annotationClass);
+    }
+
+    /**
+     * @since 1.5
+     */
+    public Annotation[] getAnnotations() {
+        return getPackageInfo().getAnnotations();
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.8
+     */
+    @Override
+    public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass) {
+        return getPackageInfo().getDeclaredAnnotation(annotationClass);
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.8
+     */
+    @Override
+    public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationClass) {
+        return getPackageInfo().getDeclaredAnnotationsByType(annotationClass);
+    }
+
+    /**
+     * @since 1.5
+     */
+    public Annotation[] getDeclaredAnnotations()  {
+        return getPackageInfo().getDeclaredAnnotations();
+    }
+
+    /**
+     * Construct a package instance with the specified version
+     * information.
+     * @param name the name of the package
+     * @param spectitle the title of the specification
+     * @param specversion the version of the specification
+     * @param specvendor the organization that maintains the specification
+     * @param impltitle the title of the implementation
+     * @param implversion the version of the implementation
+     * @param implvendor the organization that maintains the implementation
+     */
+    Package(String name,
+            String spectitle, String specversion, String specvendor,
+            String impltitle, String implversion, String implvendor,
+            URL sealbase, ClassLoader loader)
+    {
+        pkgName = name;
+        implTitle = impltitle;
+        implVersion = implversion;
+        implVendor = implvendor;
+        specTitle = spectitle;
+        specVersion = specversion;
+        specVendor = specvendor;
+        sealBase = sealbase;
+        this.loader = loader;
+    }
+
+    /*
+     * Construct a package using the attributes from the specified manifest.
+     *
+     * @param name the package name
+     * @param man the optional manifest for the package
+     * @param url the optional code source url for the package
+     */
+    private Package(String name, Manifest man, URL url, ClassLoader loader) {
+        String path = name.replace('.', '/').concat("/");
+        String sealed = null;
+        String specTitle= null;
+        String specVersion= null;
+        String specVendor= null;
+        String implTitle= null;
+        String implVersion= null;
+        String implVendor= null;
+        URL sealBase= null;
+        Attributes attr = man.getAttributes(path);
+        if (attr != null) {
+            specTitle   = attr.getValue(Name.SPECIFICATION_TITLE);
+            specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
+            specVendor  = attr.getValue(Name.SPECIFICATION_VENDOR);
+            implTitle   = attr.getValue(Name.IMPLEMENTATION_TITLE);
+            implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);
+            implVendor  = attr.getValue(Name.IMPLEMENTATION_VENDOR);
+            sealed      = attr.getValue(Name.SEALED);
+        }
+        attr = man.getMainAttributes();
+        if (attr != null) {
+            if (specTitle == null) {
+                specTitle = attr.getValue(Name.SPECIFICATION_TITLE);
+            }
+            if (specVersion == null) {
+                specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
+            }
+            if (specVendor == null) {
+                specVendor = attr.getValue(Name.SPECIFICATION_VENDOR);
+            }
+            if (implTitle == null) {
+                implTitle = attr.getValue(Name.IMPLEMENTATION_TITLE);
+            }
+            if (implVersion == null) {
+                implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);
+            }
+            if (implVendor == null) {
+                implVendor = attr.getValue(Name.IMPLEMENTATION_VENDOR);
+            }
+            if (sealed == null) {
+                sealed = attr.getValue(Name.SEALED);
+            }
+        }
+        if ("true".equalsIgnoreCase(sealed)) {
+            sealBase = url;
+        }
+        pkgName = name;
+        this.specTitle = specTitle;
+        this.specVersion = specVersion;
+        this.specVendor = specVendor;
+        this.implTitle = implTitle;
+        this.implVersion = implVersion;
+        this.implVendor = implVendor;
+        this.sealBase = sealBase;
+        this.loader = loader;
+    }
+
+    /*
+     * Returns the loaded system package for the specified name.
+     */
+    static Package getSystemPackage(String name) {
+        synchronized (pkgs) {
+            Package pkg = pkgs.get(name);
+            if (pkg == null) {
+                name = name.replace('.', '/').concat("/");
+                String fn = getSystemPackage0(name);
+                if (fn != null) {
+                    pkg = defineSystemPackage(name, fn);
+                }
+            }
+            return pkg;
+        }
+    }
+
+    /*
+     * Return an array of loaded system packages.
+     */
+    static Package[] getSystemPackages() {
+        // First, update the system package map with new package names
+        String[] names = getSystemPackages0();
+        synchronized (pkgs) {
+            for (int i = 0; i < names.length; i++) {
+                defineSystemPackage(names[i], getSystemPackage0(names[i]));
+            }
+            return pkgs.values().toArray(new Package[pkgs.size()]);
+        }
+    }
+
+    private static Package defineSystemPackage(final String iname,
+                                               final String fn)
+    {
+        return AccessController.doPrivileged(new PrivilegedAction<Package>() {
+            public Package run() {
+                String name = iname;
+                // Get the cached code source url for the file name
+                URL url = urls.get(fn);
+                if (url == null) {
+                    // URL not found, so create one
+                    File file = new File(fn);
+                    try {
+                        url = ParseUtil.fileToEncodedURL(file);
+                    } catch (MalformedURLException e) {
+                    }
+                    if (url != null) {
+                        urls.put(fn, url);
+                        // If loading a JAR file, then also cache the manifest
+                        if (file.isFile()) {
+                            mans.put(fn, loadManifest(fn));
+                        }
+                    }
+                }
+                // Convert to "."-separated package name
+                name = name.substring(0, name.length() - 1).replace('/', '.');
+                Package pkg;
+                Manifest man = mans.get(fn);
+                if (man != null) {
+                    pkg = new Package(name, man, url, null);
+                } else {
+                    pkg = new Package(name, null, null, null,
+                                      null, null, null, null, null);
+                }
+                pkgs.put(name, pkg);
+                return pkg;
+            }
+        });
+    }
+
+    /*
+     * Returns the Manifest for the specified JAR file name.
+     */
+    private static Manifest loadManifest(String fn) {
+        try (FileInputStream fis = new FileInputStream(fn);
+             JarInputStream jis = new JarInputStream(fis, false))
+        {
+            return jis.getManifest();
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    // The map of loaded system packages
+    private static Map<String, Package> pkgs = new HashMap<>(31);
+
+    // Maps each directory or zip file name to its corresponding url
+    private static Map<String, URL> urls = new HashMap<>(10);
+
+    // Maps each code source url for a jar file to its manifest
+    private static Map<String, Manifest> mans = new HashMap<>(10);
+
+    private static native String getSystemPackage0(String name);
+    private static native String[] getSystemPackages0();
+
+    /*
+     * Private storage for the package name and attributes.
+     */
+    private final String pkgName;
+    private final String specTitle;
+    private final String specVersion;
+    private final String specVendor;
+    private final String implTitle;
+    private final String implVersion;
+    private final String implVendor;
+    private final URL sealBase;
+    private transient final ClassLoader loader;
+    private transient Class<?> packageInfo;
+}
diff --git a/src/MapleFE/test/java/openjdk/Package.java.result b/src/MapleFE/test/java/openjdk/Package.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..018c563d1a7ccc902d87058ea27f9426d1b2a4c8
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Package.java.result
@@ -0,0 +1,367 @@
+Matched 5 tokens.
+Matched 14 tokens.
+Matched 21 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+Matched 42 tokens.
+Matched 49 tokens.
+Matched 56 tokens.
+Matched 63 tokens.
+Matched 70 tokens.
+Matched 77 tokens.
+Matched 84 tokens.
+Matched 91 tokens.
+Matched 100 tokens.
+Matched 109 tokens.
+Matched 118 tokens.
+Matched 129 tokens.
+Matched 138 tokens.
+Matched 145 tokens.
+Matched 152 tokens.
+Matched 159 tokens.
+Matched 168 tokens.
+Matched 175 tokens.
+Matched 182 tokens.
+Matched 189 tokens.
+Matched 198 tokens.
+Matched 2146 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import java.lang.reflect.AnnotatedElement
+== Sub Tree ==
+import java.io.InputStream
+== Sub Tree ==
+import java.util.Enumeration
+== Sub Tree ==
+import java.util.StringTokenizer
+== Sub Tree ==
+import java.io.File
+== Sub Tree ==
+import java.io.FileInputStream
+== Sub Tree ==
+import java.io.FileNotFoundException
+== Sub Tree ==
+import java.io.IOException
+== Sub Tree ==
+import java.net.URL
+== Sub Tree ==
+import java.net.MalformedURLException
+== Sub Tree ==
+import java.security.AccessController
+== Sub Tree ==
+import java.security.PrivilegedAction
+== Sub Tree ==
+import java.util.jar.JarInputStream
+== Sub Tree ==
+import java.util.jar.Manifest
+== Sub Tree ==
+import java.util.jar.Attributes
+== Sub Tree ==
+import java.util.jar.Attributes.Name
+== Sub Tree ==
+import java.util.jar.JarException
+== Sub Tree ==
+import java.util.Map
+== Sub Tree ==
+import java.util.HashMap
+== Sub Tree ==
+import java.util.Iterator
+== Sub Tree ==
+import sun.net.www.ParseUtil
+== Sub Tree ==
+import sun.reflect.CallerSensitive
+== Sub Tree ==
+import dalvik.system.VMRuntime
+== Sub Tree ==
+import dalvik.system.VMStack
+== Sub Tree ==
+import java.lang.annotation.Annotation
+== Sub Tree ==
+class  Package
+  Fields: 
+    pkgs=new HashMap(31)    urls=new HashMap(10)    mans=new HashMap(10)    pkgName    specTitle    specVersion    specVendor    implTitle    implVersion    implVendor    sealBase    loader    packageInfo
+  Instance Initializer: 
+  Constructors: 
+    constructor  Package(name,spectitle,specversion,specvendor,impltitle,implversion,implvendor,sealbase,loader)  throws: 
+      pkgName Assign name
+      implTitle Assign impltitle
+      implVersion Assign implversion
+      implVendor Assign implvendor
+      specTitle Assign spectitle
+      specVersion Assign specversion
+      specVendor Assign specvendor
+      sealBase Assign sealbase
+      this.loader Assign loader
+    constructor  Package(name,man,url,loader)  throws: 
+      Decl: path=name.replace(.,/).concat("/")
+      Decl: sealed=null
+      Decl: specTitle=null
+      Decl: specVersion=null
+      Decl: specVendor=null
+      Decl: implTitle=null
+      Decl: implVersion=null
+      Decl: implVendor=null
+      Decl: sealBase=null
+      Decl: attr=man.getAttributes(path)
+      cond-branch cond:attr NE null
+      true branch :
+        specTitle Assign attr.getValue(Name.SPECIFICATION_TITLE)
+        specVersion Assign attr.getValue(Name.SPECIFICATION_VERSION)
+        specVendor Assign attr.getValue(Name.SPECIFICATION_VENDOR)
+        implTitle Assign attr.getValue(Name.IMPLEMENTATION_TITLE)
+        implVersion Assign attr.getValue(Name.IMPLEMENTATION_VERSION)
+        implVendor Assign attr.getValue(Name.IMPLEMENTATION_VENDOR)
+        sealed Assign attr.getValue(Name.SEALED)
+      false branch :
+
+      attr Assign man.getMainAttributes()
+      cond-branch cond:attr NE null
+      true branch :
+        cond-branch cond:specTitle EQ null
+        true branch :
+          specTitle Assign attr.getValue(Name.SPECIFICATION_TITLE)
+        false branch :
+
+        cond-branch cond:specVersion EQ null
+        true branch :
+          specVersion Assign attr.getValue(Name.SPECIFICATION_VERSION)
+        false branch :
+
+        cond-branch cond:specVendor EQ null
+        true branch :
+          specVendor Assign attr.getValue(Name.SPECIFICATION_VENDOR)
+        false branch :
+
+        cond-branch cond:implTitle EQ null
+        true branch :
+          implTitle Assign attr.getValue(Name.IMPLEMENTATION_TITLE)
+        false branch :
+
+        cond-branch cond:implVersion EQ null
+        true branch :
+          implVersion Assign attr.getValue(Name.IMPLEMENTATION_VERSION)
+        false branch :
+
+        cond-branch cond:implVendor EQ null
+        true branch :
+          implVendor Assign attr.getValue(Name.IMPLEMENTATION_VENDOR)
+        false branch :
+
+        cond-branch cond:sealed EQ null
+        true branch :
+          sealed Assign attr.getValue(Name.SEALED)
+        false branch :
+
+      false branch :
+
+      cond-branch cond:"true".equalsIgnoreCase(sealed)
+      true branch :
+        sealBase Assign url
+      false branch :
+
+      pkgName Assign name
+      this.specTitle Assign specTitle
+      this.specVersion Assign specVersion
+      this.specVendor Assign specVendor
+      this.implTitle Assign implTitle
+      this.implVersion Assign implVersion
+      this.implVendor Assign implVendor
+      this.sealBase Assign sealBase
+      this.loader Assign loader
+  Methods: 
+    func  getName()  throws: 
+      return pkgName
+    func  getSpecificationTitle()  throws: 
+      return specTitle
+    func  getSpecificationVersion()  throws: 
+      return specVersion
+    func  getSpecificationVendor()  throws: 
+      return specVendor
+    func  getImplementationTitle()  throws: 
+      return implTitle
+    func  getImplementationVersion()  throws: 
+      return implVersion
+    func  getImplementationVendor()  throws: 
+      return implVendor
+    func  isSealed()  throws: 
+      return sealBase NE null
+    func  isSealed(url)  throws: 
+      return url.equals(sealBase)
+    func  isCompatibleWith(desired)  throws:     NumberFormatException
+      cond-branch cond:specVersion EQ null Lor specVersion.length() LT 1
+      true branch :
+        new NumberFormatException("Empty version string")
+      false branch :
+
+      Decl: sa=specVersion.split("\\.",-1)
+      Decl: si=
+      for ( )
+         Assign Integer.parseInt(sa,i)
+        cond-branch cond: LT 0
+        true branch :
+          NumberFormatException.forInputString("" Add )        false branch :
+
+
+      Decl: da=desired.split("\\.",-1)
+      Decl: di=
+      for ( )
+         Assign Integer.parseInt(da,i)
+        cond-branch cond: LT 0
+        true branch :
+          NumberFormatException.forInputString("" Add )        false branch :
+
+
+      Decl: len=Math.max(di.length,si.length)
+      for ( )
+        Decl: d=()
+        Decl: s=()
+        cond-branch cond:s LT d
+        true branch :
+          return false        false branch :
+
+        cond-branch cond:s GT d
+        true branch :
+          return true        false branch :
+
+
+      return true
+    func  getPackage(name)  throws: 
+      Decl: l=VMStack.getCallingClassLoader()
+      cond-branch cond:l NE null
+      true branch :
+        return l.getPackage(name)
+      false branch :
+        return getSystemPackage(name)
+
+    func  getPackages()  throws: 
+      Decl: l=VMStack.getCallingClassLoader()
+      cond-branch cond:l NE null
+      true branch :
+        return l.getPackages()
+      false branch :
+        return getSystemPackages()
+
+    func  getPackage(c)  throws: 
+      Decl: name=c.getName()
+      Decl: i=name.lastIndexOf(.)
+      cond-branch cond:i NE -1
+      true branch :
+        name Assign name.substring(0,i)
+        Decl: cl=c.getClassLoader()
+        cond-branch cond:cl NE null
+        true branch :
+          return cl.getPackage(name)
+        false branch :
+          return getSystemPackage(name)
+
+      false branch :
+        return null
+
+    func  hashCode()  throws: 
+      return pkgName.hashCode()
+    func  toString()  throws: 
+      Decl: targetSdkVersion=VMRuntime.getRuntime().getTargetSdkVersion()
+      cond-branch cond:targetSdkVersion GT 0 Land targetSdkVersion LE 24
+      true branch :
+        return "package " Add pkgName
+      false branch :
+
+      Decl: spec=specTitle
+      Decl: ver=specVersion
+      cond-branch cond:spec NE null Land spec.length() GT 0
+      true branch :
+        spec Assign ", " Add spec      false branch :
+        spec Assign ""
+      cond-branch cond:ver NE null Land ver.length() GT 0
+      true branch :
+        ver Assign ", version " Add ver      false branch :
+        ver Assign ""
+      return "package " Add pkgName Add spec Add ver
+    func  getPackageInfo()  throws: 
+      cond-branch cond:packageInfo EQ null
+      true branch :
+        packageInfo Assign Class.forName(pkgName Add ".package-info",false,loader)
+
+        ClassNotFoundException
+        ex
+        class  PackageInfoProxy
+          Fields: 
+
+          Instance Initializer: 
+          Constructors: 
+          Methods: 
+          LocalClasses: 
+          LocalInterfaces: 
+
+        packageInfo Assign PackageInfoProxy
+
+      false branch :
+
+      return packageInfo
+    func  getAnnotation(annotationClass)  throws: 
+      return getPackageInfo().getAnnotation(annotationClass)
+    func  isAnnotationPresent(annotationClass)  throws: 
+      return 
+    func  getAnnotationsByType(annotationClass)  throws: 
+      return getPackageInfo().getAnnotationsByType(annotationClass)
+    func  getAnnotations()  throws: 
+      return getPackageInfo().getAnnotations()
+    func  getDeclaredAnnotation(annotationClass)  throws: 
+      return getPackageInfo().getDeclaredAnnotation(annotationClass)
+    func  getDeclaredAnnotationsByType(annotationClass)  throws: 
+      return getPackageInfo().getDeclaredAnnotationsByType(annotationClass)
+    func  getDeclaredAnnotations()  throws: 
+      return getPackageInfo().getDeclaredAnnotations()
+    func  getSystemPackage(name)  throws: 
+      Decl: pkg=pkgs.get(name)
+      cond-branch cond:pkg EQ null
+      true branch :
+        name Assign name.replace(.,/).concat("/")
+        Decl: fn=getSystemPackage0(name)
+        cond-branch cond:fn NE null
+        true branch :
+          pkg Assign defineSystemPackage(name,fn)
+        false branch :
+
+      false branch :
+
+      return pkg
+
+    func  getSystemPackages()  throws: 
+      Decl: names=getSystemPackages0()
+      for ( )
+        defineSystemPackage(names,i,getSystemPackage0(names,i))
+
+      return pkgs.values().toArray(Package,pkgs.size())
+
+    func  defineSystemPackage(iname,fn)  throws: 
+      return AccessController.doPrivileged(new PrivilegedAction())
+    func  loadManifest(fn)  throws: 
+      FileInputStream
+      fis
+      new FileInputStream(fn)
+      JarInputStream
+      jis
+      new JarInputStream(fis,false)
+      return jis.getManifest()
+
+      IOException
+      e
+      return null
+
+    func  getSystemPackage0(name)  throws: 
+    func  getSystemPackages0()  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+Identifier:FileInputStream has no decl.
+Identifier:fis has no decl.
+UserType:FileInputStream has no decl.
+Identifier:JarInputStream has no decl.
+Identifier:jis has no decl.
+UserType:JarInputStream has no decl.
+Identifier:fis has no decl.
+Identifier:IOException has no decl.
+Identifier:e has no decl.
diff --git a/src/MapleFE/test/java/openjdk/Process.java b/src/MapleFE/test/java/openjdk/Process.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e94538246540920f91e8de412274c50a19b18ce
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Process.java
@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) 1995, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import java.io.*;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * The {@link ProcessBuilder#start()} and
+ * {@link Runtime#exec(String[],String[],File) Runtime.exec}
+ * methods create a native process and return an instance of a
+ * subclass of {@code Process} that can be used to control the process
+ * and obtain information about it.  The class {@code Process}
+ * provides methods for performing input from the process, performing
+ * output to the process, waiting for the process to complete,
+ * checking the exit status of the process, and destroying (killing)
+ * the process.
+ *
+ * <p>The methods that create processes may not work well for special
+ * processes on certain native platforms, such as native windowing
+ * processes, daemon processes, Win16/DOS processes on Microsoft
+ * Windows, or shell scripts.
+ *
+ * <p>By default, the created subprocess does not have its own terminal
+ * or console.  All its standard I/O (i.e. stdin, stdout, stderr)
+ * operations will be redirected to the parent process, where they can
+ * be accessed via the streams obtained using the methods
+ * {@link #getOutputStream()},
+ * {@link #getInputStream()}, and
+ * {@link #getErrorStream()}.
+ * The parent process uses these streams to feed input to and get output
+ * from the subprocess.  Because some native platforms only provide
+ * limited buffer size for standard input and output streams, failure
+ * to promptly write the input stream or read the output stream of
+ * the subprocess may cause the subprocess to block, or even deadlock.
+ *
+ * <p>Where desired, <a href="ProcessBuilder.html#redirect-input">
+ * subprocess I/O can also be redirected</a>
+ * using methods of the {@link ProcessBuilder} class.
+ *
+ * <p>The subprocess is not killed when there are no more references to
+ * the {@code Process} object, but rather the subprocess
+ * continues executing asynchronously.
+ *
+ * <p>There is no requirement that a process represented by a {@code
+ * Process} object execute asynchronously or concurrently with respect
+ * to the Java process that owns the {@code Process} object.
+ *
+ * <p>As of 1.5, {@link ProcessBuilder#start()} is the preferred way
+ * to create a {@code Process}.
+ *
+ * @since   JDK1.0
+ */
+public abstract class Process {
+    /**
+     * Returns the output stream connected to the normal input of the
+     * subprocess.  Output to the stream is piped into the standard
+     * input of the process represented by this {@code Process} object.
+     *
+     * <p>If the standard input of the subprocess has been redirected using
+     * {@link ProcessBuilder#redirectInput(Redirect)
+     * ProcessBuilder.redirectInput}
+     * then this method will return a
+     * <a href="ProcessBuilder.html#redirect-input">null output stream</a>.
+     *
+     * <p>Implementation note: It is a good idea for the returned
+     * output stream to be buffered.
+     *
+     * @return the output stream connected to the normal input of the
+     *         subprocess
+     */
+    public abstract OutputStream getOutputStream();
+
+    /**
+     * Returns the input stream connected to the normal output of the
+     * subprocess.  The stream obtains data piped from the standard
+     * output of the process represented by this {@code Process} object.
+     *
+     * <p>If the standard output of the subprocess has been redirected using
+     * {@link ProcessBuilder#redirectOutput(Redirect)
+     * ProcessBuilder.redirectOutput}
+     * then this method will return a
+     * <a href="ProcessBuilder.html#redirect-output">null input stream</a>.
+     *
+     * <p>Otherwise, if the standard error of the subprocess has been
+     * redirected using
+     * {@link ProcessBuilder#redirectErrorStream(boolean)
+     * ProcessBuilder.redirectErrorStream}
+     * then the input stream returned by this method will receive the
+     * merged standard output and the standard error of the subprocess.
+     *
+     * <p>Implementation note: It is a good idea for the returned
+     * input stream to be buffered.
+     *
+     * @return the input stream connected to the normal output of the
+     *         subprocess
+     */
+    public abstract InputStream getInputStream();
+
+    /**
+     * Returns the input stream connected to the error output of the
+     * subprocess.  The stream obtains data piped from the error output
+     * of the process represented by this {@code Process} object.
+     *
+     * <p>If the standard error of the subprocess has been redirected using
+     * {@link ProcessBuilder#redirectError(Redirect)
+     * ProcessBuilder.redirectError} or
+     * {@link ProcessBuilder#redirectErrorStream(boolean)
+     * ProcessBuilder.redirectErrorStream}
+     * then this method will return a
+     * <a href="ProcessBuilder.html#redirect-output">null input stream</a>.
+     *
+     * <p>Implementation note: It is a good idea for the returned
+     * input stream to be buffered.
+     *
+     * @return the input stream connected to the error output of
+     *         the subprocess
+     */
+    public abstract InputStream getErrorStream();
+
+    /**
+     * Causes the current thread to wait, if necessary, until the
+     * process represented by this {@code Process} object has
+     * terminated.  This method returns immediately if the subprocess
+     * has already terminated.  If the subprocess has not yet
+     * terminated, the calling thread will be blocked until the
+     * subprocess exits.
+     *
+     * @return the exit value of the subprocess represented by this
+     *         {@code Process} object.  By convention, the value
+     *         {@code 0} indicates normal termination.
+     * @throws InterruptedException if the current thread is
+     *         {@linkplain Thread#interrupt() interrupted} by another
+     *         thread while it is waiting, then the wait is ended and
+     *         an {@link InterruptedException} is thrown.
+     */
+    public abstract int waitFor() throws InterruptedException;
+
+    /**
+     * Causes the current thread to wait, if necessary, until the
+     * subprocess represented by this {@code Process} object has
+     * terminated, or the specified waiting time elapses.
+     *
+     * <p>If the subprocess has already terminated then this method returns
+     * immediately with the value {@code true}.  If the process has not
+     * terminated and the timeout value is less than, or equal to, zero, then
+     * this method returns immediately with the value {@code false}.
+     *
+     * <p>The default implementation of this methods polls the {@code exitValue}
+     * to check if the process has terminated. Concrete implementations of this
+     * class are strongly encouraged to override this method with a more
+     * efficient implementation.
+     *
+     * @param timeout the maximum time to wait
+     * @param unit the time unit of the {@code timeout} argument
+     * @return {@code true} if the subprocess has exited and {@code false} if
+     *         the waiting time elapsed before the subprocess has exited.
+     * @throws InterruptedException if the current thread is interrupted
+     *         while waiting.
+     * @throws NullPointerException if unit is null
+     * @since 1.8
+     */
+    public boolean waitFor(long timeout, TimeUnit unit)
+        throws InterruptedException
+    {
+        long startTime = System.nanoTime();
+        long rem = unit.toNanos(timeout);
+
+        do {
+            try {
+                exitValue();
+                return true;
+            } catch(IllegalThreadStateException ex) {
+                if (rem > 0)
+                    Thread.sleep(
+                        Math.min(TimeUnit.NANOSECONDS.toMillis(rem) + 1, 100));
+            }
+            rem = unit.toNanos(timeout) - (System.nanoTime() - startTime);
+        } while (rem > 0);
+        return false;
+    }
+
+    /**
+     * Returns the exit value for the subprocess.
+     *
+     * @return the exit value of the subprocess represented by this
+     *         {@code Process} object.  By convention, the value
+     *         {@code 0} indicates normal termination.
+     * @throws IllegalThreadStateException if the subprocess represented
+     *         by this {@code Process} object has not yet terminated
+     */
+    public abstract int exitValue();
+
+    /**
+     * Kills the subprocess. Whether the subprocess represented by this
+     * {@code Process} object is forcibly terminated or not is
+     * implementation dependent.
+     */
+    public abstract void destroy();
+
+    /**
+     * Kills the subprocess. The subprocess represented by this
+     * {@code Process} object is forcibly terminated.
+     *
+     * <p>The default implementation of this method invokes {@link #destroy}
+     * and so may not forcibly terminate the process. Concrete implementations
+     * of this class are strongly encouraged to override this method with a
+     * compliant implementation.  Invoking this method on {@code Process}
+     * objects returned by {@link ProcessBuilder#start} and
+     * {@link Runtime#exec} will forcibly terminate the process.
+     *
+     * <p>Note: The subprocess may not terminate immediately.
+     * i.e. {@code isAlive()} may return true for a brief period
+     * after {@code destroyForcibly()} is called. This method
+     * may be chained to {@code waitFor()} if needed.
+     *
+     * @return the {@code Process} object representing the
+     *         subprocess to be forcibly destroyed.
+     * @since 1.8
+     */
+    public Process destroyForcibly() {
+        destroy();
+        return this;
+    }
+
+    /**
+     * Tests whether the subprocess represented by this {@code Process} is
+     * alive.
+     *
+     * @return {@code true} if the subprocess represented by this
+     *         {@code Process} object has not yet terminated.
+     * @since 1.8
+     */
+    public boolean isAlive() {
+        try {
+            exitValue();
+            return false;
+        } catch(IllegalThreadStateException e) {
+            return true;
+        }
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/Process.java.result b/src/MapleFE/test/java/openjdk/Process.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..e3747d710b6c90f237343ebdfc614d92287055b2
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Process.java.result
@@ -0,0 +1,56 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 21 tokens.
+Matched 223 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import java.io
+== Sub Tree ==
+import java.util.concurrent.TimeUnit
+== Sub Tree ==
+class  Process
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  getOutputStream()  throws: 
+    func  getInputStream()  throws: 
+    func  getErrorStream()  throws: 
+    func  waitFor()  throws:     InterruptedException
+    func  waitFor(timeout,unit)  throws:     InterruptedException
+      Decl: startTime=System.nanoTime()
+      Decl: rem=unit.toNanos(timeout)
+      do         exitValue()
+        return true
+
+        IllegalThreadStateException
+        ex
+        cond-branch cond:rem GT 0
+        true branch :
+          Thread.sleep(Math.min(TimeUnit.NANOSECONDS.toMillis(rem) Add 1,100))        false branch :
+
+
+        rem Assign unit.toNanos(timeout) Sub (System.nanoTime() Sub startTime)
+while rem GT 0
+      return false
+    func  exitValue()  throws: 
+    func  destroy()  throws: 
+    func  destroyForcibly()  throws: 
+      destroy()
+      return this
+    func  isAlive()  throws: 
+      exitValue()
+      return false
+
+      IllegalThreadStateException
+      e
+      return true
+
+  LocalClasses: 
+  LocalInterfaces: 
+
+Identifier:IllegalThreadStateException has no decl.
+Identifier:e has no decl.
diff --git a/src/MapleFE/test/java/openjdk/ProcessBuilder.java b/src/MapleFE/test/java/openjdk/ProcessBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c892c2358d7474157290aa1e7e6f994987972a2
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/ProcessBuilder.java
@@ -0,0 +1,1055 @@
+/*
+ * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This class is used to create operating system processes.
+ *
+ * <p>Each {@code ProcessBuilder} instance manages a collection
+ * of process attributes.  The {@link #start()} method creates a new
+ * {@link Process} instance with those attributes.  The {@link
+ * #start()} method can be invoked repeatedly from the same instance
+ * to create new subprocesses with identical or related attributes.
+ *
+ * <p>Each process builder manages these process attributes:
+ *
+ * <ul>
+ *
+ * <li>a <i>command</i>, a list of strings which signifies the
+ * external program file to be invoked and its arguments, if any.
+ * Which string lists represent a valid operating system command is
+ * system-dependent.  For example, it is common for each conceptual
+ * argument to be an element in this list, but there are operating
+ * systems where programs are expected to tokenize command line
+ * strings themselves - on such a system a Java implementation might
+ * require commands to contain exactly two elements.
+ *
+ * <li>an <i>environment</i>, which is a system-dependent mapping from
+ * <i>variables</i> to <i>values</i>.  The initial value is a copy of
+ * the environment of the current process (see {@link System#getenv()}).
+ *
+ * <li>a <i>working directory</i>.  The default value is the current
+ * working directory of the current process, usually the directory
+ * named by the system property {@code user.dir}.
+ *
+ * <li><a name="redirect-input">a source of <i>standard input</i>.
+ * By default, the subprocess reads input from a pipe.  Java code
+ * can access this pipe via the output stream returned by
+ * {@link Process#getOutputStream()}.  However, standard input may
+ * be redirected to another source using
+ * {@link #redirectInput(Redirect) redirectInput}.
+ * In this case, {@link Process#getOutputStream()} will return a
+ * <i>null output stream</i>, for which:
+ *
+ * <ul>
+ * <li>the {@link OutputStream#write(int) write} methods always
+ * throw {@code IOException}
+ * <li>the {@link OutputStream#close() close} method does nothing
+ * </ul>
+ *
+ * <li><a name="redirect-output">a destination for <i>standard output</i>
+ * and <i>standard error</i>.  By default, the subprocess writes standard
+ * output and standard error to pipes.  Java code can access these pipes
+ * via the input streams returned by {@link Process#getInputStream()} and
+ * {@link Process#getErrorStream()}.  However, standard output and
+ * standard error may be redirected to other destinations using
+ * {@link #redirectOutput(Redirect) redirectOutput} and
+ * {@link #redirectError(Redirect) redirectError}.
+ * In this case, {@link Process#getInputStream()} and/or
+ * {@link Process#getErrorStream()} will return a <i>null input
+ * stream</i>, for which:
+ *
+ * <ul>
+ * <li>the {@link InputStream#read() read} methods always return
+ * {@code -1}
+ * <li>the {@link InputStream#available() available} method always returns
+ * {@code 0}
+ * <li>the {@link InputStream#close() close} method does nothing
+ * </ul>
+ *
+ * <li>a <i>redirectErrorStream</i> property.  Initially, this property
+ * is {@code false}, meaning that the standard output and error
+ * output of a subprocess are sent to two separate streams, which can
+ * be accessed using the {@link Process#getInputStream()} and {@link
+ * Process#getErrorStream()} methods.
+ *
+ * <p>If the value is set to {@code true}, then:
+ *
+ * <ul>
+ * <li>standard error is merged with the standard output and always sent
+ * to the same destination (this makes it easier to correlate error
+ * messages with the corresponding output)
+ * <li>the common destination of standard error and standard output can be
+ * redirected using
+ * {@link #redirectOutput(Redirect) redirectOutput}
+ * <li>any redirection set by the
+ * {@link #redirectError(Redirect) redirectError}
+ * method is ignored when creating a subprocess
+ * <li>the stream returned from {@link Process#getErrorStream()} will
+ * always be a <a href="#redirect-output">null input stream</a>
+ * </ul>
+ *
+ * </ul>
+ *
+ * <p>Modifying a process builder's attributes will affect processes
+ * subsequently started by that object's {@link #start()} method, but
+ * will never affect previously started processes or the Java process
+ * itself.
+ *
+ * <p>Most error checking is performed by the {@link #start()} method.
+ * It is possible to modify the state of an object so that {@link
+ * #start()} will fail.  For example, setting the command attribute to
+ * an empty list will not throw an exception unless {@link #start()}
+ * is invoked.
+ *
+ * <p><strong>Note that this class is not synchronized.</strong>
+ * If multiple threads access a {@code ProcessBuilder} instance
+ * concurrently, and at least one of the threads modifies one of the
+ * attributes structurally, it <i>must</i> be synchronized externally.
+ *
+ * <p>Starting a new process which uses the default working directory
+ * and environment is easy:
+ *
+ * <pre> {@code
+ * Process p = new ProcessBuilder("myCommand", "myArg").start();
+ * }</pre>
+ *
+ * <p>Here is an example that starts a process with a modified working
+ * directory and environment, and redirects standard output and error
+ * to be appended to a log file:
+ *
+ * <pre> {@code
+ * ProcessBuilder pb =
+ *   new ProcessBuilder("myCommand", "myArg1", "myArg2");
+ * Map<String, String> env = pb.environment();
+ * env.put("VAR1", "myValue");
+ * env.remove("OTHERVAR");
+ * env.put("VAR2", env.get("VAR1") + "suffix");
+ * pb.directory(new File("myDir"));
+ * File log = new File("log");
+ * pb.redirectErrorStream(true);
+ * pb.redirectOutput(Redirect.appendTo(log));
+ * Process p = pb.start();
+ * assert pb.redirectInput() == Redirect.PIPE;
+ * assert pb.redirectOutput().file() == log;
+ * assert p.getInputStream().read() == -1;
+ * }</pre>
+ *
+ * <p>To start a process with an explicit set of environment
+ * variables, first call {@link java.util.Map#clear() Map.clear()}
+ * before adding environment variables.
+ *
+ * @author Martin Buchholz
+ * @since 1.5
+ */
+
+public final class ProcessBuilder
+{
+    private List<String> command;
+    private File directory;
+    private Map<String,String> environment;
+    private boolean redirectErrorStream;
+    private Redirect[] redirects;
+
+    /**
+     * Constructs a process builder with the specified operating
+     * system program and arguments.  This constructor does <i>not</i>
+     * make a copy of the {@code command} list.  Subsequent
+     * updates to the list will be reflected in the state of the
+     * process builder.  It is not checked whether
+     * {@code command} corresponds to a valid operating system
+     * command.
+     *
+     * @param  command the list containing the program and its arguments
+     * @throws NullPointerException if the argument is null
+     */
+    public ProcessBuilder(List<String> command) {
+        if (command == null)
+            throw new NullPointerException();
+        this.command = command;
+    }
+
+    /**
+     * Constructs a process builder with the specified operating
+     * system program and arguments.  This is a convenience
+     * constructor that sets the process builder's command to a string
+     * list containing the same strings as the {@code command}
+     * array, in the same order.  It is not checked whether
+     * {@code command} corresponds to a valid operating system
+     * command.
+     *
+     * @param command a string array containing the program and its arguments
+     */
+    public ProcessBuilder(String... command) {
+        this.command = new ArrayList<>(command.length);
+        for (String arg : command)
+            this.command.add(arg);
+    }
+
+    /**
+     * Sets this process builder's operating system program and
+     * arguments.  This method does <i>not</i> make a copy of the
+     * {@code command} list.  Subsequent updates to the list will
+     * be reflected in the state of the process builder.  It is not
+     * checked whether {@code command} corresponds to a valid
+     * operating system command.
+     *
+     * @param  command the list containing the program and its arguments
+     * @return this process builder
+     *
+     * @throws NullPointerException if the argument is null
+     */
+    public ProcessBuilder command(List<String> command) {
+        if (command == null)
+            throw new NullPointerException();
+        this.command = command;
+        return this;
+    }
+
+    /**
+     * Sets this process builder's operating system program and
+     * arguments.  This is a convenience method that sets the command
+     * to a string list containing the same strings as the
+     * {@code command} array, in the same order.  It is not
+     * checked whether {@code command} corresponds to a valid
+     * operating system command.
+     *
+     * @param  command a string array containing the program and its arguments
+     * @return this process builder
+     */
+    public ProcessBuilder command(String... command) {
+        this.command = new ArrayList<>(command.length);
+        for (String arg : command)
+            this.command.add(arg);
+        return this;
+    }
+
+    /**
+     * Returns this process builder's operating system program and
+     * arguments.  The returned list is <i>not</i> a copy.  Subsequent
+     * updates to the list will be reflected in the state of this
+     * process builder.
+     *
+     * @return this process builder's program and its arguments
+     */
+    public List<String> command() {
+        return command;
+    }
+
+    /**
+     * Returns a string map view of this process builder's environment.
+     *
+     * Whenever a process builder is created, the environment is
+     * initialized to a copy of the current process environment (see
+     * {@link System#getenv()}).  Subprocesses subsequently started by
+     * this object's {@link #start()} method will use this map as
+     * their environment.
+     *
+     * <p>The returned object may be modified using ordinary {@link
+     * java.util.Map Map} operations.  These modifications will be
+     * visible to subprocesses started via the {@link #start()}
+     * method.  Two {@code ProcessBuilder} instances always
+     * contain independent process environments, so changes to the
+     * returned map will never be reflected in any other
+     * {@code ProcessBuilder} instance or the values returned by
+     * {@link System#getenv System.getenv}.
+     *
+     * <p>If the system does not support environment variables, an
+     * empty map is returned.
+     *
+     * <p>The returned map does not permit null keys or values.
+     * Attempting to insert or query the presence of a null key or
+     * value will throw a {@link NullPointerException}.
+     * Attempting to query the presence of a key or value which is not
+     * of type {@link String} will throw a {@link ClassCastException}.
+     *
+     * <p>The behavior of the returned map is system-dependent.  A
+     * system may not allow modifications to environment variables or
+     * may forbid certain variable names or values.  For this reason,
+     * attempts to modify the map may fail with
+     * {@link UnsupportedOperationException} or
+     * {@link IllegalArgumentException}
+     * if the modification is not permitted by the operating system.
+     *
+     * <p>Since the external format of environment variable names and
+     * values is system-dependent, there may not be a one-to-one
+     * mapping between them and Java's Unicode strings.  Nevertheless,
+     * the map is implemented in such a way that environment variables
+     * which are not modified by Java code will have an unmodified
+     * native representation in the subprocess.
+     *
+     * <p>The returned map and its collection views may not obey the
+     * general contract of the {@link Object#equals} and
+     * {@link Object#hashCode} methods.
+     *
+     * <p>The returned map is typically case-sensitive on all platforms.
+     *
+     * <p>If a security manager exists, its
+     * {@link SecurityManager#checkPermission checkPermission} method
+     * is called with a
+     * {@link RuntimePermission}{@code ("getenv.*")} permission.
+     * This may result in a {@link SecurityException} being thrown.
+     *
+     * <p>When passing information to a Java subprocess,
+     * <a href=System.html#EnvironmentVSSystemProperties>system properties</a>
+     * are generally preferred over environment variables.
+     *
+     * @return this process builder's environment
+     *
+     * @throws SecurityException
+     *         if a security manager exists and its
+     *         {@link SecurityManager#checkPermission checkPermission}
+     *         method doesn't allow access to the process environment
+     *
+     * @see    Runtime#exec(String[],String[],java.io.File)
+     * @see    System#getenv()
+     */
+    public Map<String,String> environment() {
+        SecurityManager security = System.getSecurityManager();
+        if (security != null)
+            security.checkPermission(new RuntimePermission("getenv.*"));
+
+        if (environment == null)
+            environment = ProcessEnvironment.environment();
+
+        assert environment != null;
+
+        return environment;
+    }
+
+    // Only for use by Runtime.exec(...envp...)
+    ProcessBuilder environment(String[] envp) {
+        assert environment == null;
+        if (envp != null) {
+            environment = ProcessEnvironment.emptyEnvironment(envp.length);
+            assert environment != null;
+
+            for (String envstring : envp) {
+                // Before 1.5, we blindly passed invalid envstrings
+                // to the child process.
+                // We would like to throw an exception, but do not,
+                // for compatibility with old broken code.
+
+                // Silently discard any trailing junk.
+                if (envstring.indexOf((int) '\u0000') != -1)
+                    envstring = envstring.replaceFirst("\u0000.*", "");
+
+                int eqlsign =
+                    envstring.indexOf('=', ProcessEnvironment.MIN_NAME_LENGTH);
+                // Silently ignore envstrings lacking the required `='.
+                if (eqlsign != -1)
+                    environment.put(envstring.substring(0,eqlsign),
+                                    envstring.substring(eqlsign+1));
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Returns this process builder's working directory.
+     *
+     * Subprocesses subsequently started by this object's {@link
+     * #start()} method will use this as their working directory.
+     * The returned value may be {@code null} -- this means to use
+     * the working directory of the current Java process, usually the
+     * directory named by the system property {@code user.dir},
+     * as the working directory of the child process.
+     *
+     * @return this process builder's working directory
+     */
+    public File directory() {
+        return directory;
+    }
+
+    /**
+     * Sets this process builder's working directory.
+     *
+     * Subprocesses subsequently started by this object's {@link
+     * #start()} method will use this as their working directory.
+     * The argument may be {@code null} -- this means to use the
+     * working directory of the current Java process, usually the
+     * directory named by the system property {@code user.dir},
+     * as the working directory of the child process.
+     *
+     * @param  directory the new working directory
+     * @return this process builder
+     */
+    public ProcessBuilder directory(File directory) {
+        this.directory = directory;
+        return this;
+    }
+
+    // ---------------- I/O Redirection ----------------
+
+    /**
+     * Implements a <a href="#redirect-output">null input stream</a>.
+     */
+    static class NullInputStream extends InputStream {
+        static final NullInputStream INSTANCE = new NullInputStream();
+        private NullInputStream() {}
+        public int read()      { return -1; }
+        public int available() { return 0; }
+    }
+
+    /**
+     * Implements a <a href="#redirect-input">null output stream</a>.
+     */
+    static class NullOutputStream extends OutputStream {
+        static final NullOutputStream INSTANCE = new NullOutputStream();
+        private NullOutputStream() {}
+        public void write(int b) throws IOException {
+            throw new IOException("Stream closed");
+        }
+    }
+
+    /**
+     * Represents a source of subprocess input or a destination of
+     * subprocess output.
+     *
+     * Each {@code Redirect} instance is one of the following:
+     *
+     * <ul>
+     * <li>the special value {@link #PIPE Redirect.PIPE}
+     * <li>the special value {@link #INHERIT Redirect.INHERIT}
+     * <li>a redirection to read from a file, created by an invocation of
+     *     {@link Redirect#from Redirect.from(File)}
+     * <li>a redirection to write to a file,  created by an invocation of
+     *     {@link Redirect#to Redirect.to(File)}
+     * <li>a redirection to append to a file, created by an invocation of
+     *     {@link Redirect#appendTo Redirect.appendTo(File)}
+     * </ul>
+     *
+     * <p>Each of the above categories has an associated unique
+     * {@link Type Type}.
+     *
+     * @since 1.7
+     */
+    public static abstract class Redirect {
+        /**
+         * The type of a {@link Redirect}.
+         */
+        public enum Type {
+            /**
+             * The type of {@link Redirect#PIPE Redirect.PIPE}.
+             */
+            PIPE,
+
+            /**
+             * The type of {@link Redirect#INHERIT Redirect.INHERIT}.
+             */
+            INHERIT,
+
+            /**
+             * The type of redirects returned from
+             * {@link Redirect#from Redirect.from(File)}.
+             */
+            READ,
+
+            /**
+             * The type of redirects returned from
+             * {@link Redirect#to Redirect.to(File)}.
+             */
+            WRITE,
+
+            /**
+             * The type of redirects returned from
+             * {@link Redirect#appendTo Redirect.appendTo(File)}.
+             */
+            APPEND
+        };
+
+        /**
+         * Returns the type of this {@code Redirect}.
+         * @return the type of this {@code Redirect}
+         */
+        public abstract Type type();
+
+        /**
+         * Indicates that subprocess I/O will be connected to the
+         * current Java process over a pipe.
+         *
+         * This is the default handling of subprocess standard I/O.
+         *
+         * <p>It will always be true that
+         *  <pre> {@code
+         * Redirect.PIPE.file() == null &&
+         * Redirect.PIPE.type() == Redirect.Type.PIPE
+         * }</pre>
+         */
+        public static final Redirect PIPE = new Redirect() {
+                public Type type() { return Type.PIPE; }
+                public String toString() { return type().toString(); }};
+
+        /**
+         * Indicates that subprocess I/O source or destination will be the
+         * same as those of the current process.  This is the normal
+         * behavior of most operating system command interpreters (shells).
+         *
+         * <p>It will always be true that
+         *  <pre> {@code
+         * Redirect.INHERIT.file() == null &&
+         * Redirect.INHERIT.type() == Redirect.Type.INHERIT
+         * }</pre>
+         */
+        public static final Redirect INHERIT = new Redirect() {
+                public Type type() { return Type.INHERIT; }
+                public String toString() { return type().toString(); }};
+
+        /**
+         * Returns the {@link File} source or destination associated
+         * with this redirect, or {@code null} if there is no such file.
+         *
+         * @return the file associated with this redirect,
+         *         or {@code null} if there is no such file
+         */
+        public File file() { return null; }
+
+        /**
+         * When redirected to a destination file, indicates if the output
+         * is to be written to the end of the file.
+         */
+        boolean append() {
+            throw new UnsupportedOperationException();
+        }
+
+        /**
+         * Returns a redirect to read from the specified file.
+         *
+         * <p>It will always be true that
+         *  <pre> {@code
+         * Redirect.from(file).file() == file &&
+         * Redirect.from(file).type() == Redirect.Type.READ
+         * }</pre>
+         *
+         * @param file The {@code File} for the {@code Redirect}.
+         * @throws NullPointerException if the specified file is null
+         * @return a redirect to read from the specified file
+         */
+        public static Redirect from(final File file) {
+            if (file == null)
+                throw new NullPointerException();
+            return new Redirect() {
+                    public Type type() { return Type.READ; }
+                    public File file() { return file; }
+                    public String toString() {
+                        return "redirect to read from file \"" + file + "\"";
+                    }
+                };
+        }
+
+        /**
+         * Returns a redirect to write to the specified file.
+         * If the specified file exists when the subprocess is started,
+         * its previous contents will be discarded.
+         *
+         * <p>It will always be true that
+         *  <pre> {@code
+         * Redirect.to(file).file() == file &&
+         * Redirect.to(file).type() == Redirect.Type.WRITE
+         * }</pre>
+         *
+         * @param file The {@code File} for the {@code Redirect}.
+         * @throws NullPointerException if the specified file is null
+         * @return a redirect to write to the specified file
+         */
+        public static Redirect to(final File file) {
+            if (file == null)
+                throw new NullPointerException();
+            return new Redirect() {
+                    public Type type() { return Type.WRITE; }
+                    public File file() { return file; }
+                    public String toString() {
+                        return "redirect to write to file \"" + file + "\"";
+                    }
+                    boolean append() { return false; }
+                };
+        }
+
+        /**
+         * Returns a redirect to append to the specified file.
+         * Each write operation first advances the position to the
+         * end of the file and then writes the requested data.
+         * Whether the advancement of the position and the writing
+         * of the data are done in a single atomic operation is
+         * system-dependent and therefore unspecified.
+         *
+         * <p>It will always be true that
+         *  <pre> {@code
+         * Redirect.appendTo(file).file() == file &&
+         * Redirect.appendTo(file).type() == Redirect.Type.APPEND
+         * }</pre>
+         *
+         * @param file The {@code File} for the {@code Redirect}.
+         * @throws NullPointerException if the specified file is null
+         * @return a redirect to append to the specified file
+         */
+        public static Redirect appendTo(final File file) {
+            if (file == null)
+                throw new NullPointerException();
+            return new Redirect() {
+                    public Type type() { return Type.APPEND; }
+                    public File file() { return file; }
+                    public String toString() {
+                        return "redirect to append to file \"" + file + "\"";
+                    }
+                    boolean append() { return true; }
+                };
+        }
+
+        /**
+         * Compares the specified object with this {@code Redirect} for
+         * equality.  Returns {@code true} if and only if the two
+         * objects are identical or both objects are {@code Redirect}
+         * instances of the same type associated with non-null equal
+         * {@code File} instances.
+         */
+        public boolean equals(Object obj) {
+            if (obj == this)
+                return true;
+            if (! (obj instanceof Redirect))
+                return false;
+            Redirect r = (Redirect) obj;
+            if (r.type() != this.type())
+                return false;
+            assert this.file() != null;
+            return this.file().equals(r.file());
+        }
+
+        /**
+         * Returns a hash code value for this {@code Redirect}.
+         * @return a hash code value for this {@code Redirect}
+         */
+        public int hashCode() {
+            File file = file();
+            if (file == null)
+                return super.hashCode();
+            else
+                return file.hashCode();
+        }
+
+        /**
+         * No public constructors.  Clients must use predefined
+         * static {@code Redirect} instances or factory methods.
+         */
+        private Redirect() {}
+    }
+
+    private Redirect[] redirects() {
+        if (redirects == null)
+            redirects = new Redirect[] {
+                Redirect.PIPE, Redirect.PIPE, Redirect.PIPE
+            };
+        return redirects;
+    }
+
+    /**
+     * Sets this process builder's standard input source.
+     *
+     * Subprocesses subsequently started by this object's {@link #start()}
+     * method obtain their standard input from this source.
+     *
+     * <p>If the source is {@link Redirect#PIPE Redirect.PIPE}
+     * (the initial value), then the standard input of a
+     * subprocess can be written to using the output stream
+     * returned by {@link Process#getOutputStream()}.
+     * If the source is set to any other value, then
+     * {@link Process#getOutputStream()} will return a
+     * <a href="#redirect-input">null output stream</a>.
+     *
+     * @param  source the new standard input source
+     * @return this process builder
+     * @throws IllegalArgumentException
+     *         if the redirect does not correspond to a valid source
+     *         of data, that is, has type
+     *         {@link Redirect.Type#WRITE WRITE} or
+     *         {@link Redirect.Type#APPEND APPEND}
+     * @since  1.7
+     */
+    public ProcessBuilder redirectInput(Redirect source) {
+        if (source.type() == Redirect.Type.WRITE ||
+            source.type() == Redirect.Type.APPEND)
+            throw new IllegalArgumentException(
+                "Redirect invalid for reading: " + source);
+        redirects()[0] = source;
+        return this;
+    }
+
+    /**
+     * Sets this process builder's standard output destination.
+     *
+     * Subprocesses subsequently started by this object's {@link #start()}
+     * method send their standard output to this destination.
+     *
+     * <p>If the destination is {@link Redirect#PIPE Redirect.PIPE}
+     * (the initial value), then the standard output of a subprocess
+     * can be read using the input stream returned by {@link
+     * Process#getInputStream()}.
+     * If the destination is set to any other value, then
+     * {@link Process#getInputStream()} will return a
+     * <a href="#redirect-output">null input stream</a>.
+     *
+     * @param  destination the new standard output destination
+     * @return this process builder
+     * @throws IllegalArgumentException
+     *         if the redirect does not correspond to a valid
+     *         destination of data, that is, has type
+     *         {@link Redirect.Type#READ READ}
+     * @since  1.7
+     */
+    public ProcessBuilder redirectOutput(Redirect destination) {
+        if (destination.type() == Redirect.Type.READ)
+            throw new IllegalArgumentException(
+                "Redirect invalid for writing: " + destination);
+        redirects()[1] = destination;
+        return this;
+    }
+
+    /**
+     * Sets this process builder's standard error destination.
+     *
+     * Subprocesses subsequently started by this object's {@link #start()}
+     * method send their standard error to this destination.
+     *
+     * <p>If the destination is {@link Redirect#PIPE Redirect.PIPE}
+     * (the initial value), then the error output of a subprocess
+     * can be read using the input stream returned by {@link
+     * Process#getErrorStream()}.
+     * If the destination is set to any other value, then
+     * {@link Process#getErrorStream()} will return a
+     * <a href="#redirect-output">null input stream</a>.
+     *
+     * <p>If the {@link #redirectErrorStream redirectErrorStream}
+     * attribute has been set {@code true}, then the redirection set
+     * by this method has no effect.
+     *
+     * @param  destination the new standard error destination
+     * @return this process builder
+     * @throws IllegalArgumentException
+     *         if the redirect does not correspond to a valid
+     *         destination of data, that is, has type
+     *         {@link Redirect.Type#READ READ}
+     * @since  1.7
+     */
+    public ProcessBuilder redirectError(Redirect destination) {
+        if (destination.type() == Redirect.Type.READ)
+            throw new IllegalArgumentException(
+                "Redirect invalid for writing: " + destination);
+        redirects()[2] = destination;
+        return this;
+    }
+
+    /**
+     * Sets this process builder's standard input source to a file.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * {@code redirectInput(file)}
+     * behaves in exactly the same way as the invocation
+     * {@link #redirectInput(Redirect) redirectInput}
+     * {@code (Redirect.from(file))}.
+     *
+     * @param  file the new standard input source
+     * @return this process builder
+     * @since  1.7
+     */
+    public ProcessBuilder redirectInput(File file) {
+        return redirectInput(Redirect.from(file));
+    }
+
+    /**
+     * Sets this process builder's standard output destination to a file.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * {@code redirectOutput(file)}
+     * behaves in exactly the same way as the invocation
+     * {@link #redirectOutput(Redirect) redirectOutput}
+     * {@code (Redirect.to(file))}.
+     *
+     * @param  file the new standard output destination
+     * @return this process builder
+     * @since  1.7
+     */
+    public ProcessBuilder redirectOutput(File file) {
+        return redirectOutput(Redirect.to(file));
+    }
+
+    /**
+     * Sets this process builder's standard error destination to a file.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * {@code redirectError(file)}
+     * behaves in exactly the same way as the invocation
+     * {@link #redirectError(Redirect) redirectError}
+     * {@code (Redirect.to(file))}.
+     *
+     * @param  file the new standard error destination
+     * @return this process builder
+     * @since  1.7
+     */
+    public ProcessBuilder redirectError(File file) {
+        return redirectError(Redirect.to(file));
+    }
+
+    /**
+     * Returns this process builder's standard input source.
+     *
+     * Subprocesses subsequently started by this object's {@link #start()}
+     * method obtain their standard input from this source.
+     * The initial value is {@link Redirect#PIPE Redirect.PIPE}.
+     *
+     * @return this process builder's standard input source
+     * @since  1.7
+     */
+    public Redirect redirectInput() {
+        return (redirects == null) ? Redirect.PIPE : redirects[0];
+    }
+
+    /**
+     * Returns this process builder's standard output destination.
+     *
+     * Subprocesses subsequently started by this object's {@link #start()}
+     * method redirect their standard output to this destination.
+     * The initial value is {@link Redirect#PIPE Redirect.PIPE}.
+     *
+     * @return this process builder's standard output destination
+     * @since  1.7
+     */
+    public Redirect redirectOutput() {
+        return (redirects == null) ? Redirect.PIPE : redirects[1];
+    }
+
+    /**
+     * Returns this process builder's standard error destination.
+     *
+     * Subprocesses subsequently started by this object's {@link #start()}
+     * method redirect their standard error to this destination.
+     * The initial value is {@link Redirect#PIPE Redirect.PIPE}.
+     *
+     * @return this process builder's standard error destination
+     * @since  1.7
+     */
+    public Redirect redirectError() {
+        return (redirects == null) ? Redirect.PIPE : redirects[2];
+    }
+
+    /**
+     * Sets the source and destination for subprocess standard I/O
+     * to be the same as those of the current Java process.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     *  <pre> {@code
+     * pb.inheritIO()
+     * }</pre>
+     * behaves in exactly the same way as the invocation
+     *  <pre> {@code
+     * pb.redirectInput(Redirect.INHERIT)
+     *   .redirectOutput(Redirect.INHERIT)
+     *   .redirectError(Redirect.INHERIT)
+     * }</pre>
+     *
+     * This gives behavior equivalent to most operating system
+     * command interpreters, or the standard C library function
+     * {@code system()}.
+     *
+     * @return this process builder
+     * @since  1.7
+     */
+    public ProcessBuilder inheritIO() {
+        Arrays.fill(redirects(), Redirect.INHERIT);
+        return this;
+    }
+
+    /**
+     * Tells whether this process builder merges standard error and
+     * standard output.
+     *
+     * <p>If this property is {@code true}, then any error output
+     * generated by subprocesses subsequently started by this object's
+     * {@link #start()} method will be merged with the standard
+     * output, so that both can be read using the
+     * {@link Process#getInputStream()} method.  This makes it easier
+     * to correlate error messages with the corresponding output.
+     * The initial value is {@code false}.
+     *
+     * @return this process builder's {@code redirectErrorStream} property
+     */
+    public boolean redirectErrorStream() {
+        return redirectErrorStream;
+    }
+
+    /**
+     * Sets this process builder's {@code redirectErrorStream} property.
+     *
+     * <p>If this property is {@code true}, then any error output
+     * generated by subprocesses subsequently started by this object's
+     * {@link #start()} method will be merged with the standard
+     * output, so that both can be read using the
+     * {@link Process#getInputStream()} method.  This makes it easier
+     * to correlate error messages with the corresponding output.
+     * The initial value is {@code false}.
+     *
+     * @param  redirectErrorStream the new property value
+     * @return this process builder
+     */
+    public ProcessBuilder redirectErrorStream(boolean redirectErrorStream) {
+        this.redirectErrorStream = redirectErrorStream;
+        return this;
+    }
+
+    /**
+     * Starts a new process using the attributes of this process builder.
+     *
+     * <p>The new process will
+     * invoke the command and arguments given by {@link #command()},
+     * in a working directory as given by {@link #directory()},
+     * with a process environment as given by {@link #environment()}.
+     *
+     * <p>This method checks that the command is a valid operating
+     * system command.  Which commands are valid is system-dependent,
+     * but at the very least the command must be a non-empty list of
+     * non-null strings.
+     *
+     * <p>A minimal set of system dependent environment variables may
+     * be required to start a process on some operating systems.
+     * As a result, the subprocess may inherit additional environment variable
+     * settings beyond those in the process builder's {@link #environment()}.
+     *
+     * <p>If there is a security manager, its
+     * {@link SecurityManager#checkExec checkExec}
+     * method is called with the first component of this object's
+     * {@code command} array as its argument. This may result in
+     * a {@link SecurityException} being thrown.
+     *
+     * <p>Starting an operating system process is highly system-dependent.
+     * Among the many things that can go wrong are:
+     * <ul>
+     * <li>The operating system program file was not found.
+     * <li>Access to the program file was denied.
+     * <li>The working directory does not exist.
+     * </ul>
+     *
+     * <p>In such cases an exception will be thrown.  The exact nature
+     * of the exception is system-dependent, but it will always be a
+     * subclass of {@link IOException}.
+     *
+     * <p>Subsequent modifications to this process builder will not
+     * affect the returned {@link Process}.
+     *
+     * @return a new {@link Process} object for managing the subprocess
+     *
+     * @throws NullPointerException
+     *         if an element of the command list is null
+     *
+     * @throws IndexOutOfBoundsException
+     *         if the command is an empty list (has size {@code 0})
+     *
+     * @throws SecurityException
+     *         if a security manager exists and
+     *         <ul>
+     *
+     *         <li>its
+     *         {@link SecurityManager#checkExec checkExec}
+     *         method doesn't allow creation of the subprocess, or
+     *
+     *         <li>the standard input to the subprocess was
+     *         {@linkplain #redirectInput redirected from a file}
+     *         and the security manager's
+     *         {@link SecurityManager#checkRead checkRead} method
+     *         denies read access to the file, or
+     *
+     *         <li>the standard output or standard error of the
+     *         subprocess was
+     *         {@linkplain #redirectOutput redirected to a file}
+     *         and the security manager's
+     *         {@link SecurityManager#checkWrite checkWrite} method
+     *         denies write access to the file
+     *
+     *         </ul>
+     *
+     * @throws IOException if an I/O error occurs
+     *
+     * @see Runtime#exec(String[], String[], java.io.File)
+     */
+    public Process start() throws IOException {
+        // Must convert to array first -- a malicious user-supplied
+        // list might try to circumvent the security check.
+        String[] cmdarray = command.toArray(new String[command.size()]);
+        cmdarray = cmdarray.clone();
+
+        for (String arg : cmdarray)
+            if (arg == null)
+                throw new NullPointerException();
+        // Throws IndexOutOfBoundsException if command is empty
+        String prog = cmdarray[0];
+
+        SecurityManager security = System.getSecurityManager();
+        if (security != null)
+            security.checkExec(prog);
+
+        String dir = directory == null ? null : directory.toString();
+
+        for (int i = 1; i < cmdarray.length; i++) {
+            if (cmdarray[i].indexOf('\u0000') >= 0) {
+                throw new IOException("invalid null character in command");
+            }
+        }
+
+        try {
+            return ProcessImpl.start(cmdarray,
+                                     environment,
+                                     dir,
+                                     redirects,
+                                     redirectErrorStream);
+        } catch (IOException | IllegalArgumentException e) {
+            String exceptionInfo = ": " + e.getMessage();
+            Throwable cause = e;
+            if ((e instanceof IOException) && security != null) {
+                // Can not disclose the fail reason for read-protected files.
+                try {
+                    security.checkRead(prog);
+                } catch (SecurityException se) {
+                    exceptionInfo = "";
+                    cause = se;
+                }
+            }
+            // It's much easier for us to create a high-quality error
+            // message than the low-level C code which found the problem.
+            throw new IOException(
+                "Cannot run program \"" + prog + "\""
+                + (dir == null ? "" : " (in directory \"" + dir + "\")")
+                + exceptionInfo,
+                cause);
+        }
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/ProcessBuilder.java.result b/src/MapleFE/test/java/openjdk/ProcessBuilder.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..b94bef0597edd4df522c431578f4fbc3d2436a9f
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/ProcessBuilder.java.result
@@ -0,0 +1,305 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+Matched 33 tokens.
+Matched 40 tokens.
+Matched 47 tokens.
+Matched 54 tokens.
+Matched 61 tokens.
+Matched 1635 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import java.io.File
+== Sub Tree ==
+import java.io.IOException
+== Sub Tree ==
+import java.io.InputStream
+== Sub Tree ==
+import java.io.OutputStream
+== Sub Tree ==
+import java.util.Arrays
+== Sub Tree ==
+import java.util.ArrayList
+== Sub Tree ==
+import java.util.List
+== Sub Tree ==
+import java.util.Map
+== Sub Tree ==
+class  ProcessBuilder
+  Fields: 
+    command    directory    environment    redirectErrorStream    redirects
+  Instance Initializer: 
+  Constructors: 
+    constructor  ProcessBuilder(command)  throws: 
+      cond-branch cond:command EQ null
+      true branch :
+        new NullPointerException()      false branch :
+
+      this.command Assign command
+    constructor  ProcessBuilder(command)  throws: 
+      this.command Assign new ArrayList(command.length)
+      String
+      arg
+      command
+      this.command.add(arg)
+  Methods: 
+    func  command(command)  throws: 
+      cond-branch cond:command EQ null
+      true branch :
+        new NullPointerException()      false branch :
+
+      this.command Assign command
+      return this
+    func  command(command)  throws: 
+      this.command Assign new ArrayList(command.length)
+      String
+      arg
+      command
+      this.command.add(arg)
+      return this
+    func  command()  throws: 
+      return command
+    func  environment()  throws: 
+      Decl: security=System.getSecurityManager()
+      cond-branch cond:security NE null
+      true branch :
+        security.checkPermission(new RuntimePermission("getenv.*"))      false branch :
+
+      cond-branch cond:environment EQ null
+      true branch :
+        environment Assign ProcessEnvironment.environment()      false branch :
+
+      assert environment NE null : 
+      return environment
+    func  environment(envp)  throws: 
+      assert environment EQ null : 
+      cond-branch cond:envp NE null
+      true branch :
+        environment Assign ProcessEnvironment.emptyEnvironment(envp.length)
+        assert environment NE null : 
+        String
+        envstring
+        envp
+        cond-branch cond:envstring.indexOf((int)0) NE -1
+        true branch :
+          envstring Assign envstring.replaceFirst("\u0000.*","")        false branch :
+
+        Decl: eqlsign=envstring.indexOf(=,ProcessEnvironment.MIN_NAME_LENGTH)
+        cond-branch cond:eqlsign NE -1
+        true branch :
+          environment.put(envstring.substring(0,eqlsign),envstring.substring(eqlsign Add 1))        false branch :
+
+
+      false branch :
+
+      return this
+    func  directory()  throws: 
+      return directory
+    func  directory(directory)  throws: 
+      this.directory Assign directory
+      return this
+    func  redirects()  throws: 
+      cond-branch cond:redirects EQ null
+      true branch :
+        redirects Assign       false branch :
+
+      return redirects
+    func  redirectInput(source)  throws: 
+      cond-branch cond:source.type() EQ Redirect.Type.WRITE Lor source.type() EQ Redirect.Type.APPEND
+      true branch :
+        new IllegalArgumentException("Redirect invalid for reading: " Add source)      false branch :
+
+       Assign source
+      return this
+    func  redirectOutput(destination)  throws: 
+      cond-branch cond:destination.type() EQ Redirect.Type.READ
+      true branch :
+        new IllegalArgumentException("Redirect invalid for writing: " Add destination)      false branch :
+
+       Assign destination
+      return this
+    func  redirectError(destination)  throws: 
+      cond-branch cond:destination.type() EQ Redirect.Type.READ
+      true branch :
+        new IllegalArgumentException("Redirect invalid for writing: " Add destination)      false branch :
+
+       Assign destination
+      return this
+    func  redirectInput(file)  throws: 
+      return redirectInput(Redirect.from(file))
+    func  redirectOutput(file)  throws: 
+      return redirectOutput(Redirect.to(file))
+    func  redirectError(file)  throws: 
+      return redirectError(Redirect.to(file))
+    func  redirectInput()  throws: 
+      return 
+    func  redirectOutput()  throws: 
+      return 
+    func  redirectError()  throws: 
+      return 
+    func  inheritIO()  throws: 
+      Arrays.fill(redirects(),Redirect.INHERIT)
+      return this
+    func  redirectErrorStream()  throws: 
+      return redirectErrorStream
+    func  redirectErrorStream(redirectErrorStream)  throws: 
+      this.redirectErrorStream Assign redirectErrorStream
+      return this
+    func  start()  throws:     IOException
+      Decl: cmdarray=command.toArray(String,command.size())
+      cmdarray Assign cmdarray.clone()
+      String
+      arg
+      cmdarray
+      cond-branch cond:arg EQ null
+      true branch :
+        new NullPointerException()      false branch :
+
+      Decl: prog=
+      Decl: security=System.getSecurityManager()
+      cond-branch cond:security NE null
+      true branch :
+        security.checkExec(prog)      false branch :
+
+      Decl: dir=
+      for ( )
+        cond-branch cond:.indexOf(0) GE 0
+        true branch :
+          new IOException("invalid null character in command")
+        false branch :
+
+
+      return ProcessImpl.start(cmdarray,environment,dir,redirects,redirectErrorStream)
+
+      IOException
+      IllegalArgumentException
+      e
+      Decl: exceptionInfo=": " Add e.getMessage()
+      Decl: cause=e
+      cond-branch cond:(e instanceof IOException) Land security NE null
+      true branch :
+        security.checkRead(prog)
+
+        SecurityException
+        se
+        exceptionInfo Assign ""
+        cause Assign se
+
+      false branch :
+
+      new IOException("Cannot run program \"" Add prog Add "\"" Add () Add exceptionInfo,cause)
+
+  LocalClasses: 
+    class  NullInputStream
+      Fields: 
+        INSTANCE=new NullInputStream()
+      Instance Initializer: 
+      Constructors: 
+        constructor  NullInputStream()  throws: 
+      Methods: 
+        func  read()  throws: 
+          return -1
+        func  available()  throws: 
+          return 0
+      LocalClasses: 
+      LocalInterfaces: 
+    class  NullOutputStream
+      Fields: 
+        INSTANCE=new NullOutputStream()
+      Instance Initializer: 
+      Constructors: 
+        constructor  NullOutputStream()  throws: 
+      Methods: 
+        func  write(b)  throws:     IOException
+          new IOException("Stream closed")
+      LocalClasses: 
+      LocalInterfaces: 
+    class  Redirect
+      Fields: 
+        PIPE=new Redirect()        INHERIT=new Redirect()
+      Instance Initializer: 
+      Constructors: 
+        constructor  Redirect()  throws: 
+      Methods: 
+        func  type()  throws: 
+        func  file()  throws: 
+          return null
+        func  append()  throws: 
+          new UnsupportedOperationException()
+        func  from(file)  throws: 
+          cond-branch cond:file EQ null
+          true branch :
+            new NullPointerException()          false branch :
+
+          return new Redirect()
+        func  to(file)  throws: 
+          cond-branch cond:file EQ null
+          true branch :
+            new NullPointerException()          false branch :
+
+          return new Redirect()
+        func  appendTo(file)  throws: 
+          cond-branch cond:file EQ null
+          true branch :
+            new NullPointerException()          false branch :
+
+          return new Redirect()
+        func  equals(obj)  throws: 
+          cond-branch cond:obj EQ this
+          true branch :
+            return true          false branch :
+
+          cond-branch cond:(obj instanceof Redirect)
+          true branch :
+            return false          false branch :
+
+          Decl: r=(Redirect)obj
+          cond-branch cond:r.type() NE this.type()
+          true branch :
+            return false          false branch :
+
+          assert this.file() NE null : 
+          return this.file().equals(r.file())
+        func  hashCode()  throws: 
+          Decl: file=file()
+          cond-branch cond:file EQ null
+          true branch :
+            return super.hashCode()          false branch :
+            return file.hashCode()
+      LocalClasses: 
+        class[JavaEnum]  Type
+          Fields: 
+
+          Instance Initializer: 
+          Constructors: 
+          Methods: 
+          LocalClasses: 
+          LocalInterfaces: 
+      LocalInterfaces: 
+  LocalInterfaces: 
+
+Field Decl Duplication! Identifier:command is duplicated with Function:command
+Field Decl Duplication! Identifier:command is duplicated with Function:command
+Field Decl Duplication! Identifier:command is duplicated with Function:command
+Field Decl Duplication! Identifier:directory is duplicated with Function:directory
+Field Decl Duplication! Identifier:directory is duplicated with Function:directory
+Field Decl Duplication! Identifier:environment is duplicated with Function:environment
+Field Decl Duplication! Identifier:environment is duplicated with Function:environment
+Field Decl Duplication! Identifier:redirectErrorStream is duplicated with Function:redirectErrorStream
+Field Decl Duplication! Identifier:redirectErrorStream is duplicated with Function:redirectErrorStream
+Field Decl Duplication! Identifier:redirects is duplicated with Function:redirects
+UserType:ArrayList has no decl.
+Identifier:String has no decl.
+Identifier:arg has no decl.
+Identifier:cmdarray has no decl.
+Identifier:String has no decl.
+Identifier:arg has no decl.
+Identifier:cmdarray has no decl.
+Identifier:IOException has no decl.
+Identifier:IllegalArgumentException has no decl.
+Identifier:e has no decl.
+UserType:IOException has no decl.
+Identifier:cause has no decl.
diff --git a/src/MapleFE/test/java/openjdk/ProcessEnvironment.java b/src/MapleFE/test/java/openjdk/ProcessEnvironment.java
new file mode 100644
index 0000000000000000000000000000000000000000..08d260cf4a3cd3a66a11d435d99ae404b68e9d8e
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/ProcessEnvironment.java
@@ -0,0 +1,440 @@
+/*
+ * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/* We use APIs that access the standard Unix environ array, which
+ * is defined by UNIX98 to look like:
+ *
+ *    char **environ;
+ *
+ * These are unsorted, case-sensitive, null-terminated arrays of bytes
+ * of the form FOO=BAR\000 which are usually encoded in the user's
+ * default encoding (file.encoding is an excellent choice for
+ * encoding/decoding these).  However, even though the user cannot
+ * directly access the underlying byte representation, we take pains
+ * to pass on the child the exact byte representation we inherit from
+ * the parent process for any environment name or value not created by
+ * Javaland.  So we keep track of all the byte representations.
+ *
+ * Internally, we define the types Variable and Value that exhibit
+ * String/byteArray duality.  The internal representation of the
+ * environment then looks like a Map<Variable,Value>.  But we don't
+ * expose this to the user -- we only provide a Map<String,String>
+ * view, although we could also provide a Map<byte[],byte[]> view.
+ *
+ * The non-private methods in this class are not for general use even
+ * within this package.  Instead, they are the system-dependent parts
+ * of the system-independent method of the same name.  Don't even
+ * think of using this class unless your method's name appears below.
+ *
+ * @author  Martin Buchholz
+ * @since   1.5
+ */
+
+package java.lang;
+
+import java.io.*;
+import java.util.*;
+
+
+final class ProcessEnvironment
+{
+    private static final HashMap<Variable,Value> theEnvironment;
+    private static final Map<String,String> theUnmodifiableEnvironment;
+    static final int MIN_NAME_LENGTH = 0;
+
+    static {
+        // We cache the C environment.  This means that subsequent calls
+        // to putenv/setenv from C will not be visible from Java code.
+        byte[][] environ = environ();
+        theEnvironment = new HashMap<>(environ.length/2 + 3);
+        // Read environment variables back to front,
+        // so that earlier variables override later ones.
+        for (int i = environ.length-1; i > 0; i-=2)
+            theEnvironment.put(Variable.valueOf(environ[i-1]),
+                               Value.valueOf(environ[i]));
+
+        theUnmodifiableEnvironment
+            = Collections.unmodifiableMap
+            (new StringEnvironment(theEnvironment));
+    }
+
+    /* Only for use by System.getenv(String) */
+    static String getenv(String name) {
+        return theUnmodifiableEnvironment.get(name);
+    }
+
+    /* Only for use by System.getenv() */
+    static Map<String,String> getenv() {
+        return theUnmodifiableEnvironment;
+    }
+
+    /* Only for use by ProcessBuilder.environment() */
+    @SuppressWarnings("unchecked")
+    static Map<String,String> environment() {
+        return new StringEnvironment
+            ((Map<Variable,Value>)(theEnvironment.clone()));
+    }
+
+    /* Only for use by Runtime.exec(...String[]envp...) */
+    static Map<String,String> emptyEnvironment(int capacity) {
+        return new StringEnvironment(new HashMap<Variable,Value>(capacity));
+    }
+
+    private static native byte[][] environ();
+
+    // This class is not instantiable.
+    private ProcessEnvironment() {}
+
+    // Check that name is suitable for insertion into Environment map
+    private static void validateVariable(String name) {
+        if (name.indexOf('=')      != -1 ||
+            name.indexOf('\u0000') != -1)
+            throw new IllegalArgumentException
+                ("Invalid environment variable name: \"" + name + "\"");
+    }
+
+    // Check that value is suitable for insertion into Environment map
+    private static void validateValue(String value) {
+        if (value.indexOf('\u0000') != -1)
+            throw new IllegalArgumentException
+                ("Invalid environment variable value: \"" + value + "\"");
+    }
+
+    // A class hiding the byteArray-String duality of
+    // text data on Unixoid operating systems.
+    private static abstract class ExternalData {
+        protected final String str;
+        protected final byte[] bytes;
+
+        protected ExternalData(String str, byte[] bytes) {
+            this.str = str;
+            this.bytes = bytes;
+        }
+
+        public byte[] getBytes() {
+            return bytes;
+        }
+
+        public String toString() {
+            return str;
+        }
+
+        public boolean equals(Object o) {
+            return o instanceof ExternalData
+                && arrayEquals(getBytes(), ((ExternalData) o).getBytes());
+        }
+
+        public int hashCode() {
+            return arrayHash(getBytes());
+        }
+    }
+
+    private static class Variable
+        extends ExternalData implements Comparable<Variable>
+    {
+        protected Variable(String str, byte[] bytes) {
+            super(str, bytes);
+        }
+
+        public static Variable valueOfQueryOnly(Object str) {
+            return valueOfQueryOnly((String) str);
+        }
+
+        public static Variable valueOfQueryOnly(String str) {
+            return new Variable(str, str.getBytes());
+        }
+
+        public static Variable valueOf(String str) {
+            validateVariable(str);
+            return valueOfQueryOnly(str);
+        }
+
+        public static Variable valueOf(byte[] bytes) {
+            return new Variable(new String(bytes), bytes);
+        }
+
+        public int compareTo(Variable variable) {
+            return arrayCompare(getBytes(), variable.getBytes());
+        }
+
+        public boolean equals(Object o) {
+            return o instanceof Variable && super.equals(o);
+        }
+    }
+
+    private static class Value
+        extends ExternalData implements Comparable<Value>
+    {
+        protected Value(String str, byte[] bytes) {
+            super(str, bytes);
+        }
+
+        public static Value valueOfQueryOnly(Object str) {
+            return valueOfQueryOnly((String) str);
+        }
+
+        public static Value valueOfQueryOnly(String str) {
+            return new Value(str, str.getBytes());
+        }
+
+        public static Value valueOf(String str) {
+            validateValue(str);
+            return valueOfQueryOnly(str);
+        }
+
+        public static Value valueOf(byte[] bytes) {
+            return new Value(new String(bytes), bytes);
+        }
+
+        public int compareTo(Value value) {
+            return arrayCompare(getBytes(), value.getBytes());
+        }
+
+        public boolean equals(Object o) {
+            return o instanceof Value && super.equals(o);
+        }
+    }
+
+    // This implements the String map view the user sees.
+    private static class StringEnvironment
+        extends AbstractMap<String,String>
+    {
+        private Map<Variable,Value> m;
+        private static String toString(Value v) {
+            return v == null ? null : v.toString();
+        }
+        public StringEnvironment(Map<Variable,Value> m) {this.m = m;}
+        public int size()        {return m.size();}
+        public boolean isEmpty() {return m.isEmpty();}
+        public void clear()      {       m.clear();}
+        public boolean containsKey(Object key) {
+            return m.containsKey(Variable.valueOfQueryOnly(key));
+        }
+        public boolean containsValue(Object value) {
+            return m.containsValue(Value.valueOfQueryOnly(value));
+        }
+        public String get(Object key) {
+            return toString(m.get(Variable.valueOfQueryOnly(key)));
+        }
+        public String put(String key, String value) {
+            return toString(m.put(Variable.valueOf(key),
+                                  Value.valueOf(value)));
+        }
+        public String remove(Object key) {
+            return toString(m.remove(Variable.valueOfQueryOnly(key)));
+        }
+        public Set<String> keySet() {
+            return new StringKeySet(m.keySet());
+        }
+        public Set<Map.Entry<String,String>> entrySet() {
+            return new StringEntrySet(m.entrySet());
+        }
+        public Collection<String> values() {
+            return new StringValues(m.values());
+        }
+
+        // It is technically feasible to provide a byte-oriented view
+        // as follows:
+        //      public Map<byte[],byte[]> asByteArrayMap() {
+        //          return new ByteArrayEnvironment(m);
+        //      }
+
+
+        // Convert to Unix style environ as a monolithic byte array
+        // inspired by the Windows Environment Block, except we work
+        // exclusively with bytes instead of chars, and we need only
+        // one trailing NUL on Unix.
+        // This keeps the JNI as simple and efficient as possible.
+        public byte[] toEnvironmentBlock(int[]envc) {
+            int count = m.size() * 2; // For added '=' and NUL
+            for (Map.Entry<Variable,Value> entry : m.entrySet()) {
+                count += entry.getKey().getBytes().length;
+                count += entry.getValue().getBytes().length;
+            }
+
+            byte[] block = new byte[count];
+
+            int i = 0;
+            for (Map.Entry<Variable,Value> entry : m.entrySet()) {
+                byte[] key   = entry.getKey  ().getBytes();
+                byte[] value = entry.getValue().getBytes();
+                System.arraycopy(key, 0, block, i, key.length);
+                i+=key.length;
+                block[i++] = (byte) '=';
+                System.arraycopy(value, 0, block, i, value.length);
+                i+=value.length + 1;
+                // No need to write NUL byte explicitly
+                //block[i++] = (byte) '\u0000';
+            }
+            envc[0] = m.size();
+            return block;
+        }
+    }
+
+    static byte[] toEnvironmentBlock(Map<String,String> map, int[]envc) {
+        return map == null ? null :
+            ((StringEnvironment)map).toEnvironmentBlock(envc);
+    }
+
+
+    private static class StringEntry
+        implements Map.Entry<String,String>
+    {
+        private final Map.Entry<Variable,Value> e;
+        public StringEntry(Map.Entry<Variable,Value> e) {this.e = e;}
+        public String getKey()   {return e.getKey().toString();}
+        public String getValue() {return e.getValue().toString();}
+        public String setValue(String newValue) {
+            return e.setValue(Value.valueOf(newValue)).toString();
+        }
+        public String toString() {return getKey() + "=" + getValue();}
+        public boolean equals(Object o) {
+            return o instanceof StringEntry
+                && e.equals(((StringEntry)o).e);
+        }
+        public int hashCode()    {return e.hashCode();}
+    }
+
+    private static class StringEntrySet
+        extends AbstractSet<Map.Entry<String,String>>
+    {
+        private final Set<Map.Entry<Variable,Value>> s;
+        public StringEntrySet(Set<Map.Entry<Variable,Value>> s) {this.s = s;}
+        public int size()        {return s.size();}
+        public boolean isEmpty() {return s.isEmpty();}
+        public void clear()      {       s.clear();}
+        public Iterator<Map.Entry<String,String>> iterator() {
+            return new Iterator<Map.Entry<String,String>>() {
+                Iterator<Map.Entry<Variable,Value>> i = s.iterator();
+                public boolean hasNext() {return i.hasNext();}
+                public Map.Entry<String,String> next() {
+                    return new StringEntry(i.next());
+                }
+                public void remove() {i.remove();}
+            };
+        }
+        private static Map.Entry<Variable,Value> vvEntry(final Object o) {
+            if (o instanceof StringEntry)
+                return ((StringEntry)o).e;
+            return new Map.Entry<Variable,Value>() {
+                public Variable getKey() {
+                    return Variable.valueOfQueryOnly(((Map.Entry)o).getKey());
+                }
+                public Value getValue() {
+                    return Value.valueOfQueryOnly(((Map.Entry)o).getValue());
+                }
+                public Value setValue(Value value) {
+                    throw new UnsupportedOperationException();
+                }
+            };
+        }
+        public boolean contains(Object o) { return s.contains(vvEntry(o)); }
+        public boolean remove(Object o)   { return s.remove(vvEntry(o)); }
+        public boolean equals(Object o) {
+            return o instanceof StringEntrySet
+                && s.equals(((StringEntrySet) o).s);
+        }
+        public int hashCode() {return s.hashCode();}
+    }
+
+    private static class StringValues
+          extends AbstractCollection<String>
+    {
+        private final Collection<Value> c;
+        public StringValues(Collection<Value> c) {this.c = c;}
+        public int size()        {return c.size();}
+        public boolean isEmpty() {return c.isEmpty();}
+        public void clear()      {       c.clear();}
+        public Iterator<String> iterator() {
+            return new Iterator<String>() {
+                Iterator<Value> i = c.iterator();
+                public boolean hasNext() {return i.hasNext();}
+                public String next()     {return i.next().toString();}
+                public void remove()     {i.remove();}
+            };
+        }
+        public boolean contains(Object o) {
+            return c.contains(Value.valueOfQueryOnly(o));
+        }
+        public boolean remove(Object o) {
+            return c.remove(Value.valueOfQueryOnly(o));
+        }
+        public boolean equals(Object o) {
+            return o instanceof StringValues
+                && c.equals(((StringValues)o).c);
+        }
+        public int hashCode() {return c.hashCode();}
+    }
+
+    private static class StringKeySet extends AbstractSet<String> {
+        private final Set<Variable> s;
+        public StringKeySet(Set<Variable> s) {this.s = s;}
+        public int size()        {return s.size();}
+        public boolean isEmpty() {return s.isEmpty();}
+        public void clear()      {       s.clear();}
+        public Iterator<String> iterator() {
+            return new Iterator<String>() {
+                Iterator<Variable> i = s.iterator();
+                public boolean hasNext() {return i.hasNext();}
+                public String next()     {return i.next().toString();}
+                public void remove()     {       i.remove();}
+            };
+        }
+        public boolean contains(Object o) {
+            return s.contains(Variable.valueOfQueryOnly(o));
+        }
+        public boolean remove(Object o) {
+            return s.remove(Variable.valueOfQueryOnly(o));
+        }
+    }
+
+    // Replace with general purpose method someday
+    private static int arrayCompare(byte[]x, byte[] y) {
+        int min = x.length < y.length ? x.length : y.length;
+        for (int i = 0; i < min; i++)
+            if (x[i] != y[i])
+                return x[i] - y[i];
+        return x.length - y.length;
+    }
+
+    // Replace with general purpose method someday
+    private static boolean arrayEquals(byte[] x, byte[] y) {
+        if (x.length != y.length)
+            return false;
+        for (int i = 0; i < x.length; i++)
+            if (x[i] != y[i])
+                return false;
+        return true;
+    }
+
+    // Replace with general purpose method someday
+    private static int arrayHash(byte[] x) {
+        int hash = 0;
+        for (int i = 0; i < x.length; i++)
+            hash = 31 * hash + x[i];
+        return hash;
+    }
+
+}
diff --git a/src/MapleFE/test/java/openjdk/ProcessEnvironment.java.result b/src/MapleFE/test/java/openjdk/ProcessEnvironment.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..10edbc49196cff4198a5bfaacd3f0319fd209597
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/ProcessEnvironment.java.result
@@ -0,0 +1,296 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 2531 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import java.io
+== Sub Tree ==
+import java.util
+== Sub Tree ==
+class  ProcessEnvironment
+  Fields: 
+    theEnvironment    theUnmodifiableEnvironment    MIN_NAME_LENGTH=0
+  Instance Initializer: 
+    InstInit- 0
+  Constructors: 
+    constructor  ProcessEnvironment()  throws: 
+  Methods: 
+    func  getenv(name)  throws: 
+      return theUnmodifiableEnvironment.get(name)
+    func  getenv()  throws: 
+      return theUnmodifiableEnvironment
+    func  environment()  throws: 
+      return new StringEnvironment(()(theEnvironment.clone()))
+    func  emptyEnvironment(capacity)  throws: 
+      return new StringEnvironment(new HashMap(capacity))
+    func  environ()  throws: 
+    func  validateVariable(name)  throws: 
+      cond-branch cond:name.indexOf(=) NE -1 Lor name.indexOf(0) NE -1
+      true branch :
+        new IllegalArgumentException("Invalid environment variable name: \"" Add name Add "\"")      false branch :
+
+    func  validateValue(value)  throws: 
+      cond-branch cond:value.indexOf(0) NE -1
+      true branch :
+        new IllegalArgumentException("Invalid environment variable value: \"" Add value Add "\"")      false branch :
+
+    func  toEnvironmentBlock(map,envc)  throws: 
+      return 
+    func  arrayCompare(x,y)  throws: 
+      Decl: min=
+      for ( )
+        cond-branch cond: NE 
+        true branch :
+          return  Sub         false branch :
+
+      return x.length Sub y.length
+    func  arrayEquals(x,y)  throws: 
+      cond-branch cond:x.length NE y.length
+      true branch :
+        return false      false branch :
+
+      for ( )
+        cond-branch cond: NE 
+        true branch :
+          return false        false branch :
+
+      return true
+    func  arrayHash(x)  throws: 
+      Decl: hash=0
+      for ( )
+        hash Assign 31 Mul hash Add 
+      return hash
+  LocalClasses: 
+    class  ExternalData
+      Fields: 
+        str        bytes
+      Instance Initializer: 
+      Constructors: 
+        constructor  ExternalData(str,bytes)  throws: 
+          this.str Assign str
+          this.bytes Assign bytes
+      Methods: 
+        func  getBytes()  throws: 
+          return bytes
+        func  toString()  throws: 
+          return str
+        func  equals(o)  throws: 
+          return o instanceof ExternalData Land arrayEquals(getBytes(),(ExternalData)o.getBytes())
+        func  hashCode()  throws: 
+          return arrayHash(getBytes())
+      LocalClasses: 
+      LocalInterfaces: 
+    class  Variable
+      Fields: 
+
+      Instance Initializer: 
+      Constructors: 
+        constructor  Variable(str,bytes)  throws: 
+      Methods: 
+        func  valueOfQueryOnly(str)  throws: 
+          return valueOfQueryOnly((String)str)
+        func  valueOfQueryOnly(str)  throws: 
+          return new Variable(str,str.getBytes())
+        func  valueOf(str)  throws: 
+          validateVariable(str)
+          return valueOfQueryOnly(str)
+        func  valueOf(bytes)  throws: 
+          return new Variable(new String(bytes),bytes)
+        func  compareTo(variable)  throws: 
+          return arrayCompare(getBytes(),variable.getBytes())
+        func  equals(o)  throws: 
+          return o instanceof Variable Land super.equals(o)
+      LocalClasses: 
+      LocalInterfaces: 
+    class  Value
+      Fields: 
+
+      Instance Initializer: 
+      Constructors: 
+        constructor  Value(str,bytes)  throws: 
+      Methods: 
+        func  valueOfQueryOnly(str)  throws: 
+          return valueOfQueryOnly((String)str)
+        func  valueOfQueryOnly(str)  throws: 
+          return new Value(str,str.getBytes())
+        func  valueOf(str)  throws: 
+          validateValue(str)
+          return valueOfQueryOnly(str)
+        func  valueOf(bytes)  throws: 
+          return new Value(new String(bytes),bytes)
+        func  compareTo(value)  throws: 
+          return arrayCompare(getBytes(),value.getBytes())
+        func  equals(o)  throws: 
+          return o instanceof Value Land super.equals(o)
+      LocalClasses: 
+      LocalInterfaces: 
+    class  StringEnvironment
+      Fields: 
+        m
+      Instance Initializer: 
+      Constructors: 
+        constructor  StringEnvironment(m)  throws: 
+          this.m Assign m
+      Methods: 
+        func  toString(v)  throws: 
+          return 
+        func  size()  throws: 
+          return m.size()
+        func  isEmpty()  throws: 
+          return m.isEmpty()
+        func  clear()  throws: 
+          m.clear()
+        func  containsKey(key)  throws: 
+          return m.containsKey(Variable.valueOfQueryOnly(key))
+        func  containsValue(value)  throws: 
+          return m.containsValue(Value.valueOfQueryOnly(value))
+        func  get(key)  throws: 
+          return toString(m.get(Variable.valueOfQueryOnly(key)))
+        func  put(key,value)  throws: 
+          return toString(m.put(Variable.valueOf(key),Value.valueOf(value)))
+        func  remove(key)  throws: 
+          return toString(m.remove(Variable.valueOfQueryOnly(key)))
+        func  keySet()  throws: 
+          return new StringKeySet(m.keySet())
+        func  entrySet()  throws: 
+          return new StringEntrySet(m.entrySet())
+        func  values()  throws: 
+          return new StringValues(m.values())
+        func  toEnvironmentBlock(envc)  throws: 
+          Decl: count=m.size() Mul 2
+          Map
+          Entry
+          Variable
+          Value
+          entry
+          m.entrySet()
+          count AddAssign entry.getKey().getBytes().length
+          count AddAssign entry.getValue().getBytes().length
+
+          Decl: block=
+          Decl: i=0
+          Map
+          Entry
+          Variable
+          Value
+          entry
+          m.entrySet()
+          Decl: key=entry.getKey().getBytes()
+          Decl: value=entry.getValue().getBytes()
+          System.arraycopy(key,0,block,i,key.length)
+          i AddAssign key.length
+           Assign (byte)=
+          System.arraycopy(value,0,block,i,value.length)
+          i AddAssign value.length Add 1
+
+           Assign m.size()
+          return block
+      LocalClasses: 
+      LocalInterfaces: 
+    class  StringEntry
+      Fields: 
+        e
+      Instance Initializer: 
+      Constructors: 
+        constructor  StringEntry(e)  throws: 
+          this.e Assign e
+      Methods: 
+        func  getKey()  throws: 
+          return e.getKey().toString()
+        func  getValue()  throws: 
+          return e.getValue().toString()
+        func  setValue(newValue)  throws: 
+          return e.setValue(Value.valueOf(newValue)).toString()
+        func  toString()  throws: 
+          return getKey() Add "=" Add getValue()
+        func  equals(o)  throws: 
+          return o instanceof StringEntry Land e.equals((StringEntry)o.e)
+        func  hashCode()  throws: 
+          return e.hashCode()
+      LocalClasses: 
+      LocalInterfaces: 
+    class  StringEntrySet
+      Fields: 
+        s
+      Instance Initializer: 
+      Constructors: 
+        constructor  StringEntrySet(s)  throws: 
+          this.s Assign s
+      Methods: 
+        func  size()  throws: 
+          return s.size()
+        func  isEmpty()  throws: 
+          return s.isEmpty()
+        func  clear()  throws: 
+          s.clear()
+        func  iterator()  throws: 
+          return new Iterator()
+        func  vvEntry(o)  throws: 
+          cond-branch cond:o instanceof StringEntry
+          true branch :
+            return (StringEntry)o.e          false branch :
+
+          return new Map()
+        func  contains(o)  throws: 
+          return s.contains(vvEntry(o))
+        func  remove(o)  throws: 
+          return s.remove(vvEntry(o))
+        func  equals(o)  throws: 
+          return o instanceof StringEntrySet Land s.equals((StringEntrySet)o.s)
+        func  hashCode()  throws: 
+          return s.hashCode()
+      LocalClasses: 
+      LocalInterfaces: 
+    class  StringValues
+      Fields: 
+        c
+      Instance Initializer: 
+      Constructors: 
+        constructor  StringValues(c)  throws: 
+          this.c Assign c
+      Methods: 
+        func  size()  throws: 
+          return c.size()
+        func  isEmpty()  throws: 
+          return c.isEmpty()
+        func  clear()  throws: 
+          c.clear()
+        func  iterator()  throws: 
+          return new Iterator()
+        func  contains(o)  throws: 
+          return c.contains(Value.valueOfQueryOnly(o))
+        func  remove(o)  throws: 
+          return c.remove(Value.valueOfQueryOnly(o))
+        func  equals(o)  throws: 
+          return o instanceof StringValues Land c.equals((StringValues)o.c)
+        func  hashCode()  throws: 
+          return c.hashCode()
+      LocalClasses: 
+      LocalInterfaces: 
+    class  StringKeySet
+      Fields: 
+        s
+      Instance Initializer: 
+      Constructors: 
+        constructor  StringKeySet(s)  throws: 
+          this.s Assign s
+      Methods: 
+        func  size()  throws: 
+          return s.size()
+        func  isEmpty()  throws: 
+          return s.isEmpty()
+        func  clear()  throws: 
+          s.clear()
+        func  iterator()  throws: 
+          return new Iterator()
+        func  contains(o)  throws: 
+          return s.contains(Variable.valueOfQueryOnly(o))
+        func  remove(o)  throws: 
+          return s.remove(Variable.valueOfQueryOnly(o))
+      LocalClasses: 
+      LocalInterfaces: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/Runtime.java b/src/MapleFE/test/java/openjdk/Runtime.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d5281479e13c4825896dc4fe34a0ee19dc6f3b1
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Runtime.java
@@ -0,0 +1,1161 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.optimization.FastNative;
+import java.io.*;
+import java.util.StringTokenizer;
+import sun.reflect.CallerSensitive;
+import java.lang.ref.FinalizerReference;
+import java.util.ArrayList;
+import java.util.List;
+import dalvik.system.BaseDexClassLoader;
+import dalvik.system.VMDebug;
+import dalvik.system.VMStack;
+import dalvik.system.VMRuntime;
+import libcore.io.IoUtils;
+import libcore.io.Libcore;
+import libcore.util.EmptyArray;
+import static android.system.OsConstants._SC_NPROCESSORS_CONF;
+
+/**
+ * Every Java application has a single instance of class
+ * <code>Runtime</code> that allows the application to interface with
+ * the environment in which the application is running. The current
+ * runtime can be obtained from the <code>getRuntime</code> method.
+ * <p>
+ * An application cannot create its own instance of this class.
+ *
+ * @author  unascribed
+ * @see     java.lang.Runtime#getRuntime()
+ * @since   JDK1.0
+ */
+
+public class Runtime {
+    private static Runtime currentRuntime = new Runtime();
+
+    /**
+     * Holds the list of threads to run when the VM terminates
+     */
+    private List<Thread> shutdownHooks = new ArrayList<Thread>();
+
+    /**
+     * Reflects whether finalization should be run for all objects
+     * when the VM terminates.
+     */
+    private static boolean finalizeOnExit;
+
+    /**
+     * Reflects whether we are already shutting down the VM.
+     */
+    private boolean shuttingDown;
+
+    /**
+     * Reflects whether we are tracing method calls.
+     */
+    private boolean tracingMethods;
+
+    private static native void nativeExit(int code);
+
+    /**
+     * Returns the runtime object associated with the current Java application.
+     * Most of the methods of class <code>Runtime</code> are instance
+     * methods and must be invoked with respect to the current runtime object.
+     *
+     * @return  the <code>Runtime</code> object associated with the current
+     *          Java application.
+     */
+    public static Runtime getRuntime() {
+        return currentRuntime;
+    }
+
+    /** Don't let anyone else instantiate this class */
+    private Runtime() {}
+
+    /**
+     * Terminates the currently running Java virtual machine by initiating its
+     * shutdown sequence.  This method never returns normally.  The argument
+     * serves as a status code; by convention, a nonzero status code indicates
+     * abnormal termination.
+     *
+     * <p> The virtual machine's shutdown sequence consists of two phases.  In
+     * the first phase all registered {@link #addShutdownHook shutdown hooks},
+     * if any, are started in some unspecified order and allowed to run
+     * concurrently until they finish.  In the second phase all uninvoked
+     * finalizers are run if {@link #runFinalizersOnExit finalization-on-exit}
+     * has been enabled.  Once this is done the virtual machine {@link #halt
+     * halts}.
+     *
+     * <p> If this method is invoked after the virtual machine has begun its
+     * shutdown sequence then if shutdown hooks are being run this method will
+     * block indefinitely.  If shutdown hooks have already been run and on-exit
+     * finalization has been enabled then this method halts the virtual machine
+     * with the given status code if the status is nonzero; otherwise, it
+     * blocks indefinitely.
+     *
+     * <p> The <tt>{@link System#exit(int) System.exit}</tt> method is the
+     * conventional and convenient means of invoking this method. <p>
+     *
+     * @param  status
+     *         Termination status.  By convention, a nonzero status code
+     *         indicates abnormal termination.
+     *
+     * @throws SecurityException
+     *         If a security manager is present and its <tt>{@link
+     *         SecurityManager#checkExit checkExit}</tt> method does not permit
+     *         exiting with the specified status
+     *
+     * @see java.lang.SecurityException
+     * @see java.lang.SecurityManager#checkExit(int)
+     * @see #addShutdownHook
+     * @see #removeShutdownHook
+     * @see #runFinalizersOnExit
+     * @see #halt(int)
+     */
+    public void exit(int status) {
+        // Make sure we don't try this several times
+        synchronized(this) {
+            if (!shuttingDown) {
+                shuttingDown = true;
+
+                Thread[] hooks;
+                synchronized (shutdownHooks) {
+                    // create a copy of the hooks
+                    hooks = new Thread[shutdownHooks.size()];
+                    shutdownHooks.toArray(hooks);
+                }
+
+                // Start all shutdown hooks concurrently
+                for (Thread hook : hooks) {
+                    hook.start();
+                }
+
+                // Wait for all shutdown hooks to finish
+                for (Thread hook : hooks) {
+                    try {
+                        hook.join();
+                    } catch (InterruptedException ex) {
+                        // Ignore, since we are at VM shutdown.
+                    }
+                }
+
+                // Ensure finalization on exit, if requested
+                if (finalizeOnExit) {
+                    runFinalization();
+                }
+
+                // Get out of here finally...
+                nativeExit(status);
+            }
+        }
+    }
+
+    /**
+     * Registers a new virtual-machine shutdown hook.
+     *
+     * <p> The Java virtual machine <i>shuts down</i> in response to two kinds
+     * of events:
+     *
+     *   <ul>
+     *
+     *   <li> The program <i>exits</i> normally, when the last non-daemon
+     *   thread exits or when the <tt>{@link #exit exit}</tt> (equivalently,
+     *   {@link System#exit(int) System.exit}) method is invoked, or
+     *
+     *   <li> The virtual machine is <i>terminated</i> in response to a
+     *   user interrupt, such as typing <tt>^C</tt>, or a system-wide event,
+     *   such as user logoff or system shutdown.
+     *
+     *   </ul>
+     *
+     * <p> A <i>shutdown hook</i> is simply an initialized but unstarted
+     * thread.  When the virtual machine begins its shutdown sequence it will
+     * start all registered shutdown hooks in some unspecified order and let
+     * them run concurrently.  When all the hooks have finished it will then
+     * run all uninvoked finalizers if finalization-on-exit has been enabled.
+     * Finally, the virtual machine will halt.  Note that daemon threads will
+     * continue to run during the shutdown sequence, as will non-daemon threads
+     * if shutdown was initiated by invoking the <tt>{@link #exit exit}</tt>
+     * method.
+     *
+     * <p> Once the shutdown sequence has begun it can be stopped only by
+     * invoking the <tt>{@link #halt halt}</tt> method, which forcibly
+     * terminates the virtual machine.
+     *
+     * <p> Once the shutdown sequence has begun it is impossible to register a
+     * new shutdown hook or de-register a previously-registered hook.
+     * Attempting either of these operations will cause an
+     * <tt>{@link IllegalStateException}</tt> to be thrown.
+     *
+     * <p> Shutdown hooks run at a delicate time in the life cycle of a virtual
+     * machine and should therefore be coded defensively.  They should, in
+     * particular, be written to be thread-safe and to avoid deadlocks insofar
+     * as possible.  They should also not rely blindly upon services that may
+     * have registered their own shutdown hooks and therefore may themselves in
+     * the process of shutting down.  Attempts to use other thread-based
+     * services such as the AWT event-dispatch thread, for example, may lead to
+     * deadlocks.
+     *
+     * <p> Shutdown hooks should also finish their work quickly.  When a
+     * program invokes <tt>{@link #exit exit}</tt> the expectation is
+     * that the virtual machine will promptly shut down and exit.  When the
+     * virtual machine is terminated due to user logoff or system shutdown the
+     * underlying operating system may only allow a fixed amount of time in
+     * which to shut down and exit.  It is therefore inadvisable to attempt any
+     * user interaction or to perform a long-running computation in a shutdown
+     * hook.
+     *
+     * <p> Uncaught exceptions are handled in shutdown hooks just as in any
+     * other thread, by invoking the <tt>{@link ThreadGroup#uncaughtException
+     * uncaughtException}</tt> method of the thread's <tt>{@link
+     * ThreadGroup}</tt> object.  The default implementation of this method
+     * prints the exception's stack trace to <tt>{@link System#err}</tt> and
+     * terminates the thread; it does not cause the virtual machine to exit or
+     * halt.
+     *
+     * <p> In rare circumstances the virtual machine may <i>abort</i>, that is,
+     * stop running without shutting down cleanly.  This occurs when the
+     * virtual machine is terminated externally, for example with the
+     * <tt>SIGKILL</tt> signal on Unix or the <tt>TerminateProcess</tt> call on
+     * Microsoft Windows.  The virtual machine may also abort if a native
+     * method goes awry by, for example, corrupting internal data structures or
+     * attempting to access nonexistent memory.  If the virtual machine aborts
+     * then no guarantee can be made about whether or not any shutdown hooks
+     * will be run. <p>
+     *
+     * @param   hook
+     *          An initialized but unstarted <tt>{@link Thread}</tt> object
+     *
+     * @throws  IllegalArgumentException
+     *          If the specified hook has already been registered,
+     *          or if it can be determined that the hook is already running or
+     *          has already been run
+     *
+     * @throws  IllegalStateException
+     *          If the virtual machine is already in the process
+     *          of shutting down
+     *
+     * @throws  SecurityException
+     *          If a security manager is present and it denies
+     *          <tt>{@link RuntimePermission}("shutdownHooks")</tt>
+     *
+     * @see #removeShutdownHook
+     * @see #halt(int)
+     * @see #exit(int)
+     * @since 1.3
+     */
+    public void addShutdownHook(Thread hook) {
+        // Sanity checks
+        if (hook == null) {
+            throw new NullPointerException("hook == null");
+        }
+
+        if (shuttingDown) {
+            throw new IllegalStateException("VM already shutting down");
+        }
+
+        if (hook.started) {
+            throw new IllegalArgumentException("Hook has already been started");
+        }
+
+        synchronized (shutdownHooks) {
+            if (shutdownHooks.contains(hook)) {
+                throw new IllegalArgumentException("Hook already registered.");
+            }
+
+            shutdownHooks.add(hook);
+        }
+    }
+
+    /**
+     * De-registers a previously-registered virtual-machine shutdown hook. <p>
+     *
+     * @param hook the hook to remove
+     * @return <tt>true</tt> if the specified hook had previously been
+     * registered and was successfully de-registered, <tt>false</tt>
+     * otherwise.
+     *
+     * @throws  IllegalStateException
+     *          If the virtual machine is already in the process of shutting
+     *          down
+     *
+     * @throws  SecurityException
+     *          If a security manager is present and it denies
+     *          <tt>{@link RuntimePermission}("shutdownHooks")</tt>
+     *
+     * @see #addShutdownHook
+     * @see #exit(int)
+     * @since 1.3
+     */
+    public boolean removeShutdownHook(Thread hook) {
+        // Sanity checks
+        if (hook == null) {
+            throw new NullPointerException("hook == null");
+        }
+
+        if (shuttingDown) {
+            throw new IllegalStateException("VM already shutting down");
+        }
+
+        synchronized (shutdownHooks) {
+            return shutdownHooks.remove(hook);
+        }
+    }
+
+    /**
+     * Forcibly terminates the currently running Java virtual machine.  This
+     * method never returns normally.
+     *
+     * <p> This method should be used with extreme caution.  Unlike the
+     * <tt>{@link #exit exit}</tt> method, this method does not cause shutdown
+     * hooks to be started and does not run uninvoked finalizers if
+     * finalization-on-exit has been enabled.  If the shutdown sequence has
+     * already been initiated then this method does not wait for any running
+     * shutdown hooks or finalizers to finish their work. <p>
+     *
+     * @param  status
+     *         Termination status.  By convention, a nonzero status code
+     *         indicates abnormal termination.  If the <tt>{@link Runtime#exit
+     *         exit}</tt> (equivalently, <tt>{@link System#exit(int)
+     *         System.exit}</tt>) method has already been invoked then this
+     *         status code will override the status code passed to that method.
+     *
+     * @throws SecurityException
+     *         If a security manager is present and its <tt>{@link
+     *         SecurityManager#checkExit checkExit}</tt> method does not permit
+     *         an exit with the specified status
+     *
+     * @see #exit
+     * @see #addShutdownHook
+     * @see #removeShutdownHook
+     * @since 1.3
+     */
+    public void halt(int status) {
+        nativeExit(status);
+    }
+
+    /**
+     * Enable or disable finalization on exit; doing so specifies that the
+     * finalizers of all objects that have finalizers that have not yet been
+     * automatically invoked are to be run before the Java runtime exits.
+     * By default, finalization on exit is disabled.
+     *
+     * <p>If there is a security manager,
+     * its <code>checkExit</code> method is first called
+     * with 0 as its argument to ensure the exit is allowed.
+     * This could result in a SecurityException.
+     *
+     * @param value true to enable finalization on exit, false to disable
+     * @deprecated  This method is inherently unsafe.  It may result in
+     *      finalizers being called on live objects while other threads are
+     *      concurrently manipulating those objects, resulting in erratic
+     *      behavior or deadlock.
+     *
+     * @throws  SecurityException
+     *        if a security manager exists and its <code>checkExit</code>
+     *        method doesn't allow the exit.
+     *
+     * @see     java.lang.Runtime#exit(int)
+     * @see     java.lang.Runtime#gc()
+     * @see     java.lang.SecurityManager#checkExit(int)
+     * @since   JDK1.1
+     */
+    @Deprecated
+    public static void runFinalizersOnExit(boolean value) {
+        finalizeOnExit = value;
+    }
+
+    /**
+     * Executes the specified string command in a separate process.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(command)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String, String[], File) exec}(command, null, null)</tt>.
+     *
+     * @param   command   a specified system command.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>command</code> is <code>null</code>
+     *
+     * @throws  IllegalArgumentException
+     *          If <code>command</code> is empty
+     *
+     * @see     #exec(String[], String[], File)
+     * @see     ProcessBuilder
+     */
+    public Process exec(String command) throws IOException {
+        return exec(command, null, null);
+    }
+
+    /**
+     * Executes the specified string command in a separate process with the
+     * specified environment.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(command, envp)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String, String[], File) exec}(command, envp, null)</tt>.
+     *
+     * @param   command   a specified system command.
+     *
+     * @param   envp      array of strings, each element of which
+     *                    has environment variable settings in the format
+     *                    <i>name</i>=<i>value</i>, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the environment of the current process.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>command</code> is <code>null</code>,
+     *          or one of the elements of <code>envp</code> is <code>null</code>
+     *
+     * @throws  IllegalArgumentException
+     *          If <code>command</code> is empty
+     *
+     * @see     #exec(String[], String[], File)
+     * @see     ProcessBuilder
+     */
+    public Process exec(String command, String[] envp) throws IOException {
+        return exec(command, envp, null);
+    }
+
+    /**
+     * Executes the specified string command in a separate process with the
+     * specified environment and working directory.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(command, envp, dir)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String[], String[], File) exec}(cmdarray, envp, dir)</tt>,
+     * where <code>cmdarray</code> is an array of all the tokens in
+     * <code>command</code>.
+     *
+     * <p>More precisely, the <code>command</code> string is broken
+     * into tokens using a {@link StringTokenizer} created by the call
+     * <code>new {@link StringTokenizer}(command)</code> with no
+     * further modification of the character categories.  The tokens
+     * produced by the tokenizer are then placed in the new string
+     * array <code>cmdarray</code>, in the same order.
+     *
+     * @param   command   a specified system command.
+     *
+     * @param   envp      array of strings, each element of which
+     *                    has environment variable settings in the format
+     *                    <i>name</i>=<i>value</i>, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the environment of the current process.
+     *
+     * @param   dir       the working directory of the subprocess, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the working directory of the current process.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>command</code> is <code>null</code>,
+     *          or one of the elements of <code>envp</code> is <code>null</code>
+     *
+     * @throws  IllegalArgumentException
+     *          If <code>command</code> is empty
+     *
+     * @see     ProcessBuilder
+     * @since 1.3
+     */
+    public Process exec(String command, String[] envp, File dir)
+        throws IOException {
+        if (command.length() == 0)
+            throw new IllegalArgumentException("Empty command");
+
+        StringTokenizer st = new StringTokenizer(command);
+        String[] cmdarray = new String[st.countTokens()];
+        for (int i = 0; st.hasMoreTokens(); i++)
+            cmdarray[i] = st.nextToken();
+        return exec(cmdarray, envp, dir);
+    }
+
+    /**
+     * Executes the specified command and arguments in a separate process.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(cmdarray)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String[], String[], File) exec}(cmdarray, null, null)</tt>.
+     *
+     * @param   cmdarray  array containing the command to call and
+     *                    its arguments.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>cmdarray</code> is <code>null</code>
+     *
+     * @throws  IndexOutOfBoundsException
+     *          If <code>cmdarray</code> is an empty array
+     *          (has length <code>0</code>)
+     *
+     * @see     ProcessBuilder
+     */
+    public Process exec(String cmdarray[]) throws IOException {
+        return exec(cmdarray, null, null);
+    }
+
+    /**
+     * Executes the specified command and arguments in a separate process
+     * with the specified environment.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(cmdarray, envp)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String[], String[], File) exec}(cmdarray, envp, null)</tt>.
+     *
+     * @param   cmdarray  array containing the command to call and
+     *                    its arguments.
+     *
+     * @param   envp      array of strings, each element of which
+     *                    has environment variable settings in the format
+     *                    <i>name</i>=<i>value</i>, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the environment of the current process.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>envp</code> is <code>null</code>
+     *
+     * @throws  IndexOutOfBoundsException
+     *          If <code>cmdarray</code> is an empty array
+     *          (has length <code>0</code>)
+     *
+     * @see     ProcessBuilder
+     */
+    public Process exec(String[] cmdarray, String[] envp) throws IOException {
+        return exec(cmdarray, envp, null);
+    }
+
+
+    /**
+     * Executes the specified command and arguments in a separate process with
+     * the specified environment and working directory.
+     *
+     * <p>Given an array of strings <code>cmdarray</code>, representing the
+     * tokens of a command line, and an array of strings <code>envp</code>,
+     * representing "environment" variable settings, this method creates
+     * a new process in which to execute the specified command.
+     *
+     * <p>This method checks that <code>cmdarray</code> is a valid operating
+     * system command.  Which commands are valid is system-dependent,
+     * but at the very least the command must be a non-empty list of
+     * non-null strings.
+     *
+     * <p>If <tt>envp</tt> is <tt>null</tt>, the subprocess inherits the
+     * environment settings of the current process.
+     *
+     * <p>A minimal set of system dependent environment variables may
+     * be required to start a process on some operating systems.
+     * As a result, the subprocess may inherit additional environment variable
+     * settings beyond those in the specified environment.
+     *
+     * <p>{@link ProcessBuilder#start()} is now the preferred way to
+     * start a process with a modified environment.
+     *
+     * <p>The working directory of the new subprocess is specified by <tt>dir</tt>.
+     * If <tt>dir</tt> is <tt>null</tt>, the subprocess inherits the
+     * current working directory of the current process.
+     *
+     * <p>If a security manager exists, its
+     * {@link SecurityManager#checkExec checkExec}
+     * method is invoked with the first component of the array
+     * <code>cmdarray</code> as its argument. This may result in a
+     * {@link SecurityException} being thrown.
+     *
+     * <p>Starting an operating system process is highly system-dependent.
+     * Among the many things that can go wrong are:
+     * <ul>
+     * <li>The operating system program file was not found.
+     * <li>Access to the program file was denied.
+     * <li>The working directory does not exist.
+     * </ul>
+     *
+     * <p>In such cases an exception will be thrown.  The exact nature
+     * of the exception is system-dependent, but it will always be a
+     * subclass of {@link IOException}.
+     *
+     *
+     * @param   cmdarray  array containing the command to call and
+     *                    its arguments.
+     *
+     * @param   envp      array of strings, each element of which
+     *                    has environment variable settings in the format
+     *                    <i>name</i>=<i>value</i>, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the environment of the current process.
+     *
+     * @param   dir       the working directory of the subprocess, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the working directory of the current process.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>envp</code> is <code>null</code>
+     *
+     * @throws  IndexOutOfBoundsException
+     *          If <code>cmdarray</code> is an empty array
+     *          (has length <code>0</code>)
+     *
+     * @see     ProcessBuilder
+     * @since 1.3
+     */
+    public Process exec(String[] cmdarray, String[] envp, File dir)
+        throws IOException {
+        return new ProcessBuilder(cmdarray)
+            .environment(envp)
+            .directory(dir)
+            .start();
+    }
+
+    /**
+     * Returns the number of processors available to the Java virtual machine.
+     *
+     * <p> This value may change during a particular invocation of the virtual
+     * machine.  Applications that are sensitive to the number of available
+     * processors should therefore occasionally poll this property and adjust
+     * their resource usage appropriately. </p>
+     *
+     * @return  the maximum number of processors available to the virtual
+     *          machine; never smaller than one
+     * @since 1.4
+     */
+    public int availableProcessors() {
+        return (int) Libcore.os.sysconf(_SC_NPROCESSORS_CONF);
+    }
+
+    /**
+     * Returns the amount of free memory in the Java Virtual Machine.
+     * Calling the
+     * <code>gc</code> method may result in increasing the value returned
+     * by <code>freeMemory.</code>
+     *
+     * @return  an approximation to the total amount of memory currently
+     *          available for future allocated objects, measured in bytes.
+     */
+    @FastNative
+    public native long freeMemory();
+
+    /**
+     * Returns the total amount of memory in the Java virtual machine.
+     * The value returned by this method may vary over time, depending on
+     * the host environment.
+     * <p>
+     * Note that the amount of memory required to hold an object of any
+     * given type may be implementation-dependent.
+     *
+     * @return  the total amount of memory currently available for current
+     *          and future objects, measured in bytes.
+     */
+    @FastNative
+    public native long totalMemory();
+
+    /**
+     * Returns the maximum amount of memory that the Java virtual machine will
+     * attempt to use.  If there is no inherent limit then the value {@link
+     * java.lang.Long#MAX_VALUE} will be returned.
+     *
+     * @return  the maximum amount of memory that the virtual machine will
+     *          attempt to use, measured in bytes
+     * @since 1.4
+     */
+    @FastNative
+    public native long maxMemory();
+
+    /**
+     * Runs the garbage collector.
+     * Calling this method suggests that the Java virtual machine expend
+     * effort toward recycling unused objects in order to make the memory
+     * they currently occupy available for quick reuse. When control
+     * returns from the method call, the virtual machine has made
+     * its best effort to recycle all discarded objects.
+     * <p>
+     * The name <code>gc</code> stands for "garbage
+     * collector". The virtual machine performs this recycling
+     * process automatically as needed, in a separate thread, even if the
+     * <code>gc</code> method is not invoked explicitly.
+     * <p>
+     * The method {@link System#gc()} is the conventional and convenient
+     * means of invoking this method.
+     */
+    public native void gc();
+
+    /* Wormhole for calling java.lang.ref.Finalizer.runFinalization */
+    private static native void runFinalization0();
+
+    /**
+     * Runs the finalization methods of any objects pending finalization.
+     * Calling this method suggests that the Java virtual machine expend
+     * effort toward running the <code>finalize</code> methods of objects
+     * that have been found to be discarded but whose <code>finalize</code>
+     * methods have not yet been run. When control returns from the
+     * method call, the virtual machine has made a best effort to
+     * complete all outstanding finalizations.
+     * <p>
+     * The virtual machine performs the finalization process
+     * automatically as needed, in a separate thread, if the
+     * <code>runFinalization</code> method is not invoked explicitly.
+     * <p>
+     * The method {@link System#runFinalization()} is the conventional
+     * and convenient means of invoking this method.
+     *
+     * @see     java.lang.Object#finalize()
+     */
+    public void runFinalization() {
+        VMRuntime.runFinalization(0);
+    }
+
+    /**
+     * Enables/Disables tracing of instructions.
+     * If the <code>boolean</code> argument is <code>true</code>, this
+     * method suggests that the Java virtual machine emit debugging
+     * information for each instruction in the virtual machine as it
+     * is executed. The format of this information, and the file or other
+     * output stream to which it is emitted, depends on the host environment.
+     * The virtual machine may ignore this request if it does not support
+     * this feature. The destination of the trace output is system
+     * dependent.
+     * <p>
+     * If the <code>boolean</code> argument is <code>false</code>, this
+     * method causes the virtual machine to stop performing the
+     * detailed instruction trace it is performing.
+     *
+     * @param   on   <code>true</code> to enable instruction tracing;
+     *               <code>false</code> to disable this feature.
+     */
+    public void traceInstructions(boolean on) {
+    }
+
+    /**
+     * Enables/Disables tracing of method calls.
+     * If the <code>boolean</code> argument is <code>true</code>, this
+     * method suggests that the Java virtual machine emit debugging
+     * information for each method in the virtual machine as it is
+     * called. The format of this information, and the file or other output
+     * stream to which it is emitted, depends on the host environment. The
+     * virtual machine may ignore this request if it does not support
+     * this feature.
+     * <p>
+     * Calling this method with argument false suggests that the
+     * virtual machine cease emitting per-call debugging information.
+     * <p>
+     * Calling this method on Android Lollipop or later (API level >= 21)
+     * with {@code true} argument will cause it to throw an
+     * {@code UnsupportedOperationException}.
+     *
+     * @param   on   <code>true</code> to enable instruction tracing;
+     *               <code>false</code> to disable this feature.
+     */
+    public void traceMethodCalls(boolean on) {
+        if (on != tracingMethods) {
+            if (on) {
+                VMDebug.startMethodTracing();
+            } else {
+                VMDebug.stopMethodTracing();
+            }
+            tracingMethods = on;
+        }
+    }
+
+    /**
+     * Loads the native library specified by the filename argument.  The filename
+     * argument must be an absolute path name.
+     * (for example
+     * <code>Runtime.getRuntime().load("/home/avh/lib/libX11.so");</code>).
+     *
+     * If the filename argument, when stripped of any platform-specific library
+     * prefix, path, and file extension, indicates a library whose name is,
+     * for example, L, and a native library called L is statically linked
+     * with the VM, then the JNI_OnLoad_L function exported by the library
+     * is invoked rather than attempting to load a dynamic library.
+     * A filename matching the argument does not have to exist in the file
+     * system. See the JNI Specification for more details.
+     *
+     * Otherwise, the filename argument is mapped to a native library image in
+     * an implementation-dependent manner.
+     * <p>
+     * First, if there is a security manager, its <code>checkLink</code>
+     * method is called with the <code>filename</code> as its argument.
+     * This may result in a security exception.
+     * <p>
+     * This is similar to the method {@link #loadLibrary(String)}, but it
+     * accepts a general file name as an argument rather than just a library
+     * name, allowing any file of native code to be loaded.
+     * <p>
+     * The method {@link System#load(String)} is the conventional and
+     * convenient means of invoking this method.
+     *
+     * @param      filename   the file to load.
+     * @exception  SecurityException  if a security manager exists and its
+     *             <code>checkLink</code> method doesn't allow
+     *             loading of the specified dynamic library
+     * @exception  UnsatisfiedLinkError  if either the filename is not an
+     *             absolute path name, the native library is not statically
+     *             linked with the VM, or the library cannot be mapped to
+     *             a native library image by the host system.
+     * @exception  NullPointerException if <code>filename</code> is
+     *             <code>null</code>
+     * @see        java.lang.Runtime#getRuntime()
+     * @see        java.lang.SecurityException
+     * @see        java.lang.SecurityManager#checkLink(java.lang.String)
+     */
+    @CallerSensitive
+    public void load(String filename) {
+        load0(VMStack.getStackClass1(), filename);
+    }
+
+    /** Check target sdk, if it's higher than N, we throw an UnsupportedOperationException */
+    private void checkTargetSdkVersionForLoad(String methodName) {
+        final int targetSdkVersion = VMRuntime.getRuntime().getTargetSdkVersion();
+        if (targetSdkVersion > 24) {
+            throw new UnsupportedOperationException(methodName + " is not supported on SDK " +
+                                                    targetSdkVersion);
+        }
+    }
+
+    // Fixes b/25859957 regression. Depending on private methods is bad, mkay.
+    void load(String absolutePath, ClassLoader loader) {
+        checkTargetSdkVersionForLoad("java.lang.Runtime#load(String, ClassLoader)");
+
+        java.lang.System.logE("java.lang.Runtime#load(String, ClassLoader)" +
+                              " is private and will be removed in a future Android release");
+        if (absolutePath == null) {
+            throw new NullPointerException("absolutePath == null");
+        }
+        String error = doLoad(absolutePath, loader);
+        if (error != null) {
+            throw new UnsatisfiedLinkError(error);
+        }
+    }
+
+    synchronized void load0(Class<?> fromClass, String filename) {
+        if (!(new File(filename).isAbsolute())) {
+            throw new UnsatisfiedLinkError(
+                "Expecting an absolute path of the library: " + filename);
+        }
+        if (filename == null) {
+            throw new NullPointerException("filename == null");
+        }
+        String error = doLoad(filename, fromClass.getClassLoader());
+        if (error != null) {
+            throw new UnsatisfiedLinkError(error);
+        }
+    }
+
+    /**
+     * Loads the native library specified by the <code>libname</code>
+     * argument.  The <code>libname</code> argument must not contain any platform
+     * specific prefix, file extension or path. If a native library
+     * called <code>libname</code> is statically linked with the VM, then the
+     * JNI_OnLoad_<code>libname</code> function exported by the library is invoked.
+     * See the JNI Specification for more details.
+     *
+     * Otherwise, the libname argument is loaded from a system library
+     * location and mapped to a native library image in an implementation-
+     * dependent manner.
+     * <p>
+     * First, if there is a security manager, its <code>checkLink</code>
+     * method is called with the <code>libname</code> as its argument.
+     * This may result in a security exception.
+     * <p>
+     * The method {@link System#loadLibrary(String)} is the conventional
+     * and convenient means of invoking this method. If native
+     * methods are to be used in the implementation of a class, a standard
+     * strategy is to put the native code in a library file (call it
+     * <code>LibFile</code>) and then to put a static initializer:
+     * <blockquote><pre>
+     * static { System.loadLibrary("LibFile"); }
+     * </pre></blockquote>
+     * within the class declaration. When the class is loaded and
+     * initialized, the necessary native code implementation for the native
+     * methods will then be loaded as well.
+     * <p>
+     * If this method is called more than once with the same library
+     * name, the second and subsequent calls are ignored.
+     *
+     * @param      libname   the name of the library.
+     * @exception  SecurityException  if a security manager exists and its
+     *             <code>checkLink</code> method doesn't allow
+     *             loading of the specified dynamic library
+     * @exception  UnsatisfiedLinkError if either the libname argument
+     *             contains a file path, the native library is not statically
+     *             linked with the VM,  or the library cannot be mapped to a
+     *             native library image by the host system.
+     * @exception  NullPointerException if <code>libname</code> is
+     *             <code>null</code>
+     * @see        java.lang.SecurityException
+     * @see        java.lang.SecurityManager#checkLink(java.lang.String)
+     */
+    @CallerSensitive
+    public void loadLibrary(String libname) {
+        loadLibrary0(VMStack.getCallingClassLoader(), libname);
+    }
+
+    /**
+     * Temporarily preserved for backward compatibility. Applications call this
+     * method using reflection.
+     *
+     * **** THIS METHOD WILL BE REMOVED IN A FUTURE ANDROID VERSION ****
+     *
+     * http://b/26217329
+     *
+     * @hide
+     */
+    public void loadLibrary(String libname, ClassLoader classLoader) {
+        checkTargetSdkVersionForLoad("java.lang.Runtime#loadLibrary(String, ClassLoader)");
+        java.lang.System.logE("java.lang.Runtime#loadLibrary(String, ClassLoader)" +
+                              " is private and will be removed in a future Android release");
+        loadLibrary0(classLoader, libname);
+    }
+
+    synchronized void loadLibrary0(ClassLoader loader, String libname) {
+        if (libname.indexOf((int)File.separatorChar) != -1) {
+            throw new UnsatisfiedLinkError(
+    "Directory separator should not appear in library name: " + libname);
+        }
+        String libraryName = libname;
+        if (loader != null) {
+            String filename = loader.findLibrary(libraryName);
+            if (filename == null) {
+                // It's not necessarily true that the ClassLoader used
+                // System.mapLibraryName, but the default setup does, and it's
+                // misleading to say we didn't find "libMyLibrary.so" when we
+                // actually searched for "liblibMyLibrary.so.so".
+                throw new UnsatisfiedLinkError(loader + " couldn't find \"" +
+                                               System.mapLibraryName(libraryName) + "\"");
+            }
+            String error = doLoad(filename, loader);
+            if (error != null) {
+                throw new UnsatisfiedLinkError(error);
+            }
+            return;
+        }
+
+        String filename = System.mapLibraryName(libraryName);
+        List<String> candidates = new ArrayList<String>();
+        String lastError = null;
+        for (String directory : getLibPaths()) {
+            String candidate = directory + filename;
+            candidates.add(candidate);
+
+            if (IoUtils.canOpenReadOnly(candidate)) {
+                String error = doLoad(candidate, loader);
+                if (error == null) {
+                    return; // We successfully loaded the library. Job done.
+                }
+                lastError = error;
+            }
+        }
+
+        if (lastError != null) {
+            throw new UnsatisfiedLinkError(lastError);
+        }
+        throw new UnsatisfiedLinkError("Library " + libraryName + " not found; tried " + candidates);
+    }
+
+    private volatile String[] mLibPaths = null;
+
+    private String[] getLibPaths() {
+        if (mLibPaths == null) {
+            synchronized(this) {
+                if (mLibPaths == null) {
+                    mLibPaths = initLibPaths();
+                }
+            }
+        }
+        return mLibPaths;
+    }
+
+    private static String[] initLibPaths() {
+        String javaLibraryPath = System.getProperty("java.library.path");
+        if (javaLibraryPath == null) {
+            return EmptyArray.STRING;
+        }
+        String[] paths = javaLibraryPath.split(":");
+        // Add a '/' to the end of each directory so we don't have to do it every time.
+        for (int i = 0; i < paths.length; ++i) {
+            if (!paths[i].endsWith("/")) {
+                paths[i] += "/";
+            }
+        }
+        return paths;
+    }
+    private String doLoad(String name, ClassLoader loader) {
+        // Android apps are forked from the zygote, so they can't have a custom LD_LIBRARY_PATH,
+        // which means that by default an app's shared library directory isn't on LD_LIBRARY_PATH.
+
+        // The PathClassLoader set up by frameworks/base knows the appropriate path, so we can load
+        // libraries with no dependencies just fine, but an app that has multiple libraries that
+        // depend on each other needed to load them in most-dependent-first order.
+
+        // We added API to Android's dynamic linker so we can update the library path used for
+        // the currently-running process. We pull the desired path out of the ClassLoader here
+        // and pass it to nativeLoad so that it can call the private dynamic linker API.
+
+        // We didn't just change frameworks/base to update the LD_LIBRARY_PATH once at the
+        // beginning because multiple apks can run in the same process and third party code can
+        // use its own BaseDexClassLoader.
+
+        // We didn't just add a dlopen_with_custom_LD_LIBRARY_PATH call because we wanted any
+        // dlopen(3) calls made from a .so's JNI_OnLoad to work too.
+
+        // So, find out what the native library search path is for the ClassLoader in question...
+        String librarySearchPath = null;
+        if (loader != null && loader instanceof BaseDexClassLoader) {
+            BaseDexClassLoader dexClassLoader = (BaseDexClassLoader) loader;
+            librarySearchPath = dexClassLoader.getLdLibraryPath();
+        }
+        // nativeLoad should be synchronized so there's only one LD_LIBRARY_PATH in use regardless
+        // of how many ClassLoaders are in the system, but dalvik doesn't support synchronized
+        // internal natives.
+        synchronized (this) {
+            return nativeLoad(name, loader, librarySearchPath);
+        }
+    }
+
+    // TODO: should be synchronized, but dalvik doesn't support synchronized internal natives.
+    private static native String nativeLoad(String filename, ClassLoader loader,
+                                            String librarySearchPath);
+
+    /**
+     * Creates a localized version of an input stream. This method takes
+     * an <code>InputStream</code> and returns an <code>InputStream</code>
+     * equivalent to the argument in all respects except that it is
+     * localized: as characters in the local character set are read from
+     * the stream, they are automatically converted from the local
+     * character set to Unicode.
+     * <p>
+     * If the argument is already a localized stream, it may be returned
+     * as the result.
+     *
+     * @param      in InputStream to localize
+     * @return     a localized input stream
+     * @see        java.io.InputStream
+     * @see        java.io.BufferedReader#BufferedReader(java.io.Reader)
+     * @see        java.io.InputStreamReader#InputStreamReader(java.io.InputStream)
+     * @deprecated As of JDK&nbsp;1.1, the preferred way to translate a byte
+     * stream in the local encoding into a character stream in Unicode is via
+     * the <code>InputStreamReader</code> and <code>BufferedReader</code>
+     * classes.
+     */
+    @Deprecated
+    public InputStream getLocalizedInputStream(InputStream in) {
+        return in;
+    }
+
+    /**
+     * Creates a localized version of an output stream. This method
+     * takes an <code>OutputStream</code> and returns an
+     * <code>OutputStream</code> equivalent to the argument in all respects
+     * except that it is localized: as Unicode characters are written to
+     * the stream, they are automatically converted to the local
+     * character set.
+     * <p>
+     * If the argument is already a localized stream, it may be returned
+     * as the result.
+     *
+     * @deprecated As of JDK&nbsp;1.1, the preferred way to translate a
+     * Unicode character stream into a byte stream in the local encoding is via
+     * the <code>OutputStreamWriter</code>, <code>BufferedWriter</code>, and
+     * <code>PrintWriter</code> classes.
+     *
+     * @param      out OutputStream to localize
+     * @return     a localized output stream
+     * @see        java.io.OutputStream
+     * @see        java.io.BufferedWriter#BufferedWriter(java.io.Writer)
+     * @see        java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)
+     * @see        java.io.PrintWriter#PrintWriter(java.io.OutputStream)
+     */
+    @Deprecated
+    public OutputStream getLocalizedOutputStream(OutputStream out) {
+        return out;
+    }
+
+}
diff --git a/src/MapleFE/test/java/openjdk/Runtime.java.result b/src/MapleFE/test/java/openjdk/Runtime.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..7e96553a7a5b9943a44f7411a2714915bfad15db
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Runtime.java.result
@@ -0,0 +1,319 @@
+Matched 5 tokens.
+Matched 14 tokens.
+Matched 21 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+Matched 44 tokens.
+Matched 51 tokens.
+Matched 58 tokens.
+Matched 65 tokens.
+Matched 72 tokens.
+Matched 79 tokens.
+Matched 86 tokens.
+Matched 93 tokens.
+Matched 100 tokens.
+Matched 107 tokens.
+Matched 117 tokens.
+Matched 1578 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import dalvik.annotation.optimization.FastNative
+== Sub Tree ==
+import java.io
+== Sub Tree ==
+import java.util.StringTokenizer
+== Sub Tree ==
+import sun.reflect.CallerSensitive
+== Sub Tree ==
+import java.lang.ref.FinalizerReference
+== Sub Tree ==
+import java.util.ArrayList
+== Sub Tree ==
+import java.util.List
+== Sub Tree ==
+import dalvik.system.BaseDexClassLoader
+== Sub Tree ==
+import dalvik.system.VMDebug
+== Sub Tree ==
+import dalvik.system.VMStack
+== Sub Tree ==
+import dalvik.system.VMRuntime
+== Sub Tree ==
+import libcore.io.IoUtils
+== Sub Tree ==
+import libcore.io.Libcore
+== Sub Tree ==
+import libcore.util.EmptyArray
+== Sub Tree ==
+import static android.system.OsConstants._SC_NPROCESSORS_CONF
+== Sub Tree ==
+class  Runtime
+  Fields: 
+    currentRuntime=new Runtime()    shutdownHooks=new ArrayList()    finalizeOnExit    shuttingDown    tracingMethods    mLibPaths=null
+  Instance Initializer: 
+  Constructors: 
+    constructor  Runtime()  throws: 
+  Methods: 
+    func  nativeExit(code)  throws: 
+    func  getRuntime()  throws: 
+      return currentRuntime
+    func  exit(status)  throws: 
+      cond-branch cond:shuttingDown
+      true branch :
+        shuttingDown Assign true
+        Decl: hooks
+        hooks Assign 
+        shutdownHooks.toArray(hooks)
+
+        Thread
+        hook
+        hooks
+        hook.start()
+
+        Thread
+        hook
+        hooks
+        hook.join()
+
+        InterruptedException
+        ex
+
+
+        cond-branch cond:finalizeOnExit
+        true branch :
+          runFinalization()
+        false branch :
+
+        nativeExit(status)
+      false branch :
+
+
+    func  addShutdownHook(hook)  throws: 
+      cond-branch cond:hook EQ null
+      true branch :
+        new NullPointerException("hook == null")
+      false branch :
+
+      cond-branch cond:shuttingDown
+      true branch :
+        new IllegalStateException("VM already shutting down")
+      false branch :
+
+      cond-branch cond:hook.started
+      true branch :
+        new IllegalArgumentException("Hook has already been started")
+      false branch :
+
+      cond-branch cond:shutdownHooks.contains(hook)
+      true branch :
+        new IllegalArgumentException("Hook already registered.")
+      false branch :
+
+      shutdownHooks.add(hook)
+
+    func  removeShutdownHook(hook)  throws: 
+      cond-branch cond:hook EQ null
+      true branch :
+        new NullPointerException("hook == null")
+      false branch :
+
+      cond-branch cond:shuttingDown
+      true branch :
+        new IllegalStateException("VM already shutting down")
+      false branch :
+
+      return shutdownHooks.remove(hook)
+
+    func  halt(status)  throws: 
+      nativeExit(status)
+    func  runFinalizersOnExit(value)  throws: 
+      finalizeOnExit Assign value
+    func  exec(command)  throws:     IOException
+      return exec(command,null,null)
+    func  exec(command,envp)  throws:     IOException
+      return exec(command,envp,null)
+    func  exec(command,envp,dir)  throws:     IOException
+      cond-branch cond:command.length() EQ 0
+      true branch :
+        new IllegalArgumentException("Empty command")      false branch :
+
+      Decl: st=new StringTokenizer(command)
+      Decl: cmdarray=
+      for ( )
+         Assign st.nextToken()
+      return exec(cmdarray,envp,dir)
+    func  exec(cmdarray[])  throws:     IOException
+      return exec(cmdarray,null,null)
+    func  exec(cmdarray,envp)  throws:     IOException
+      return exec(cmdarray,envp,null)
+    func  exec(cmdarray,envp,dir)  throws:     IOException
+      return new ProcessBuilder(cmdarray).environment(envp).directory(dir).start()
+    func  availableProcessors()  throws: 
+      return (int)Libcore.os.sysconf(_SC_NPROCESSORS_CONF)
+    func  freeMemory()  throws: 
+    func  totalMemory()  throws: 
+    func  maxMemory()  throws: 
+    func  gc()  throws: 
+    func  runFinalization0()  throws: 
+    func  runFinalization()  throws: 
+      VMRuntime.runFinalization(0)
+    func  traceInstructions(on)  throws: 
+    func  traceMethodCalls(on)  throws: 
+      cond-branch cond:on NE tracingMethods
+      true branch :
+        cond-branch cond:on
+        true branch :
+          VMDebug.startMethodTracing()
+        false branch :
+          VMDebug.stopMethodTracing()
+
+        tracingMethods Assign on
+      false branch :
+
+    func  load(filename)  throws: 
+      load0(VMStack.getStackClass1(),filename)
+    func  checkTargetSdkVersionForLoad(methodName)  throws: 
+      Decl: targetSdkVersion=VMRuntime.getRuntime().getTargetSdkVersion()
+      cond-branch cond:targetSdkVersion GT 24
+      true branch :
+        new UnsupportedOperationException(methodName Add " is not supported on SDK " Add targetSdkVersion)
+      false branch :
+
+    func  load(absolutePath,loader)  throws: 
+      checkTargetSdkVersionForLoad("java.lang.Runtime#load(String, ClassLoader)")
+      java.lang.System.logE("java.lang.Runtime#load(String, ClassLoader)" Add " is private and will be removed in a future Android release")
+      cond-branch cond:absolutePath EQ null
+      true branch :
+        new NullPointerException("absolutePath == null")
+      false branch :
+
+      Decl: error=doLoad(absolutePath,loader)
+      cond-branch cond:error NE null
+      true branch :
+        new UnsatisfiedLinkError(error)
+      false branch :
+
+    func  load0(fromClass,filename)  throws: 
+      cond-branch cond:(new File(filename).isAbsolute())
+      true branch :
+        new UnsatisfiedLinkError("Expecting an absolute path of the library: " Add filename)
+      false branch :
+
+      cond-branch cond:filename EQ null
+      true branch :
+        new NullPointerException("filename == null")
+      false branch :
+
+      Decl: error=doLoad(filename,fromClass.getClassLoader())
+      cond-branch cond:error NE null
+      true branch :
+        new UnsatisfiedLinkError(error)
+      false branch :
+
+    func  loadLibrary(libname)  throws: 
+      loadLibrary0(VMStack.getCallingClassLoader(),libname)
+    func  loadLibrary(libname,classLoader)  throws: 
+      checkTargetSdkVersionForLoad("java.lang.Runtime#loadLibrary(String, ClassLoader)")
+      java.lang.System.logE("java.lang.Runtime#loadLibrary(String, ClassLoader)" Add " is private and will be removed in a future Android release")
+      loadLibrary0(classLoader,libname)
+    func  loadLibrary0(loader,libname)  throws: 
+      cond-branch cond:libname.indexOf((int)File.separatorChar) NE -1
+      true branch :
+        new UnsatisfiedLinkError("Directory separator should not appear in library name: " Add libname)
+      false branch :
+
+      Decl: libraryName=libname
+      cond-branch cond:loader NE null
+      true branch :
+        Decl: filename=loader.findLibrary(libraryName)
+        cond-branch cond:filename EQ null
+        true branch :
+          new UnsatisfiedLinkError(loader Add " couldn't find \"" Add System.mapLibraryName(libraryName) Add "\"")
+        false branch :
+
+        Decl: error=doLoad(filename,loader)
+        cond-branch cond:error NE null
+        true branch :
+          new UnsatisfiedLinkError(error)
+        false branch :
+
+        return 
+      false branch :
+
+      Decl: filename=System.mapLibraryName(libraryName)
+      Decl: candidates=new ArrayList()
+      Decl: lastError=null
+      String
+      directory
+      getLibPaths()
+      Decl: candidate=directory Add filename
+      candidates.add(candidate)
+      cond-branch cond:IoUtils.canOpenReadOnly(candidate)
+      true branch :
+        Decl: error=doLoad(candidate,loader)
+        cond-branch cond:error EQ null
+        true branch :
+          return 
+        false branch :
+
+        lastError Assign error
+      false branch :
+
+
+      cond-branch cond:lastError NE null
+      true branch :
+        new UnsatisfiedLinkError(lastError)
+      false branch :
+
+      new UnsatisfiedLinkError("Library " Add libraryName Add " not found; tried " Add candidates)
+    func  getLibPaths()  throws: 
+      cond-branch cond:mLibPaths EQ null
+      true branch :
+        cond-branch cond:mLibPaths EQ null
+        true branch :
+          mLibPaths Assign initLibPaths()
+        false branch :
+
+
+      false branch :
+
+      return mLibPaths
+    func  initLibPaths()  throws: 
+      Decl: javaLibraryPath=System.getProperty("java.library.path")
+      cond-branch cond:javaLibraryPath EQ null
+      true branch :
+        return EmptyArray.STRING
+      false branch :
+
+      Decl: paths=javaLibraryPath.split(":")
+      for ( )
+        cond-branch cond:.endsWith("/")
+        true branch :
+           AddAssign "/"
+        false branch :
+
+
+      return paths
+    func  doLoad(name,loader)  throws: 
+      Decl: librarySearchPath=null
+      cond-branch cond:loader NE null Land loader instanceof BaseDexClassLoader
+      true branch :
+        Decl: dexClassLoader=(BaseDexClassLoader)loader
+        librarySearchPath Assign dexClassLoader.getLdLibraryPath()
+      false branch :
+
+      return nativeLoad(name,loader,librarySearchPath)
+
+    func  nativeLoad(filename,loader,librarySearchPath)  throws: 
+    func  getLocalizedInputStream(in)  throws: 
+      return in
+    func  getLocalizedOutputStream(out)  throws: 
+      return out
+  LocalClasses: 
+  LocalInterfaces: 
+
+Identifier:String has no decl.
+Identifier:directory has no decl.
+UserType:UnsatisfiedLinkError has no decl.
diff --git a/src/MapleFE/test/java/openjdk/SafeVarargs.java b/src/MapleFE/test/java/openjdk/SafeVarargs.java
new file mode 100644
index 0000000000000000000000000000000000000000..243b9f1fc95c746a69ab290aeab6b377ac12f73e
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/SafeVarargs.java
@@ -0,0 +1,33 @@
+
+/*
+ * Copyright (C) 2013 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.
+ */
+package java.lang;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+/**
+ * Claims to the compiler that the annotation target does nothing potentially unsafe
+ * to its varargs argument.
+ *
+ * @since 1.7
+ */
+@Documented
+@Retention(value=RetentionPolicy.RUNTIME)
+@Target(value={ElementType.CONSTRUCTOR, ElementType.METHOD})
+public @interface SafeVarargs {
+}
diff --git a/src/MapleFE/test/java/openjdk/SafeVarargs.java.result b/src/MapleFE/test/java/openjdk/SafeVarargs.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..1d1ab5064a0f9d34c5e0e8c17c9a389ff739eeb6
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/SafeVarargs.java.result
@@ -0,0 +1,22 @@
+Matched 5 tokens.
+Matched 14 tokens.
+Matched 23 tokens.
+Matched 32 tokens.
+Matched 41 tokens.
+Matched 50 tokens.
+Matched 82 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import java.lang.annotation.Documented
+== Sub Tree ==
+import java.lang.annotation.ElementType
+== Sub Tree ==
+import java.lang.annotation.Retention
+== Sub Tree ==
+import java.lang.annotation.RetentionPolicy
+== Sub Tree ==
+import java.lang.annotation.Target
+== Sub Tree ==
+annotation type : SafeVarargs
diff --git a/src/MapleFE/test/java/openjdk/SecurityManager.java b/src/MapleFE/test/java/openjdk/SecurityManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..2182ca6e22322ce1beb9638cc301e29014d7cc8e
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/SecurityManager.java
@@ -0,0 +1,108 @@
+
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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.
+ */
+package java.lang;
+import java.io.FileDescriptor;
+import java.net.InetAddress;
+import java.security.Permission;
+/**
+ * Legacy security code; do not use.
+ *
+ * <p>Security managers do <strong>not</strong> provide a
+ * secure environment for executing untrusted code. Untrusted code cannot be
+ * safely isolated within the Dalvik VM.
+ */
+public class SecurityManager {
+    /**
+     * @deprecated Use {@link #checkPermission}
+     */
+    @Deprecated
+    protected boolean inCheck;
+    public SecurityManager() { }
+    public void checkAccept(String host, int port) { }
+    public void checkAccess(Thread thread) { }
+    public void checkAccess(ThreadGroup group) { }
+    public void checkConnect(String host, int port) { }
+    public void checkConnect(String host, int port, Object context) { }
+    public void checkCreateClassLoader() { }
+    public void checkDelete(String file) { }
+    public void checkExec(String cmd) { }
+    public void checkExit(int status) { }
+    public void checkLink(String libName) { }
+    public void checkListen(int port) { }
+    public void checkMemberAccess(Class<?> cls, int type) { }
+    public void checkMulticast(InetAddress maddr) { }
+    /**
+     * @deprecated use {@link #checkMulticast(java.net.InetAddress)}
+     */
+    @Deprecated public void checkMulticast(InetAddress maddr, byte ttl) { }
+    public void checkPackageAccess(String packageName) { }
+    public void checkPackageDefinition(String packageName) { }
+    public void checkPropertiesAccess() { }
+    public void checkPropertyAccess(String key) { }
+    public void checkRead(FileDescriptor fd) { }
+    public void checkRead(String file) { }
+    public void checkRead(String file, Object context) { }
+    public void checkSecurityAccess(String target) { }
+    public void checkSetFactory() { }
+    public boolean checkTopLevelWindow(Object window) { return true; }
+    public void checkSystemClipboardAccess() { }
+    public void checkAwtEventQueueAccess() { }
+    public void checkPrintJobAccess() { }
+    public void checkWrite(FileDescriptor fd) { }
+    public void checkWrite(String file) { }
+    /**
+     * @deprecated Use {@link #checkPermission}.
+     */
+    @Deprecated public boolean getInCheck() { return inCheck; }
+    protected Class[] getClassContext() { return null; }
+    /**
+     * @deprecated Use {@link #checkPermission}.
+     */
+    @Deprecated protected ClassLoader currentClassLoader() { return null; }
+    /**
+     * @deprecated Use {@link #checkPermission}.
+     */
+    @Deprecated protected int classLoaderDepth() {
+        return -1;
+    }
+    /**
+     * @deprecated Use {@link #checkPermission}.
+     */
+    @Deprecated protected Class<?> currentLoadedClass() { return null; }
+    /**
+     * @deprecated Use {@link #checkPermission}.
+     */
+    @Deprecated protected int classDepth(String name) { return -1; }
+    /**
+     * @deprecated Use {@link #checkPermission}.
+     */
+    @Deprecated protected boolean inClass(String name) { return false; }
+    /**
+     * @deprecated Use {@link #checkPermission}
+     */
+    @Deprecated protected boolean inClassLoader() { return false; }
+    /**
+     * Returns the current thread's thread group.
+     */
+    public ThreadGroup getThreadGroup() {
+        return Thread.currentThread().getThreadGroup();
+    }
+    public Object getSecurityContext() { return null; }
+    public void checkPermission(Permission permission) { }
+    public void checkPermission(Permission permission, Object context) { }
+}
diff --git a/src/MapleFE/test/java/openjdk/SecurityManager.java.result b/src/MapleFE/test/java/openjdk/SecurityManager.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..fad7670e870adc19712c7ccac717013294dc6a74
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/SecurityManager.java.result
@@ -0,0 +1,77 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+Matched 475 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import java.io.FileDescriptor
+== Sub Tree ==
+import java.net.InetAddress
+== Sub Tree ==
+import java.security.Permission
+== Sub Tree ==
+class  SecurityManager
+  Fields: 
+    inCheck
+  Instance Initializer: 
+  Constructors: 
+    constructor  SecurityManager()  throws: 
+  Methods: 
+    func  checkAccept(host,port)  throws: 
+    func  checkAccess(thread)  throws: 
+    func  checkAccess(group)  throws: 
+    func  checkConnect(host,port)  throws: 
+    func  checkConnect(host,port,context)  throws: 
+    func  checkCreateClassLoader()  throws: 
+    func  checkDelete(file)  throws: 
+    func  checkExec(cmd)  throws: 
+    func  checkExit(status)  throws: 
+    func  checkLink(libName)  throws: 
+    func  checkListen(port)  throws: 
+    func  checkMemberAccess(cls,type)  throws: 
+    func  checkMulticast(maddr)  throws: 
+    func  checkMulticast(maddr,ttl)  throws: 
+    func  checkPackageAccess(packageName)  throws: 
+    func  checkPackageDefinition(packageName)  throws: 
+    func  checkPropertiesAccess()  throws: 
+    func  checkPropertyAccess(key)  throws: 
+    func  checkRead(fd)  throws: 
+    func  checkRead(file)  throws: 
+    func  checkRead(file,context)  throws: 
+    func  checkSecurityAccess(target)  throws: 
+    func  checkSetFactory()  throws: 
+    func  checkTopLevelWindow(window)  throws: 
+      return true
+    func  checkSystemClipboardAccess()  throws: 
+    func  checkAwtEventQueueAccess()  throws: 
+    func  checkPrintJobAccess()  throws: 
+    func  checkWrite(fd)  throws: 
+    func  checkWrite(file)  throws: 
+    func  getInCheck()  throws: 
+      return inCheck
+    func  getClassContext()  throws: 
+      return null
+    func  currentClassLoader()  throws: 
+      return null
+    func  classLoaderDepth()  throws: 
+      return -1
+    func  currentLoadedClass()  throws: 
+      return null
+    func  classDepth(name)  throws: 
+      return -1
+    func  inClass(name)  throws: 
+      return false
+    func  inClassLoader()  throws: 
+      return false
+    func  getThreadGroup()  throws: 
+      return Thread.currentThread().getThreadGroup()
+    func  getSecurityContext()  throws: 
+      return null
+    func  checkPermission(permission)  throws: 
+    func  checkPermission(permission,context)  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/java/openjdk/Short.java b/src/MapleFE/test/java/openjdk/Short.java
new file mode 100644
index 0000000000000000000000000000000000000000..17324fb296bcf3ca873934de606ca7da3b3b85e6
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Short.java
@@ -0,0 +1,290 @@
+
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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.
+ */
+package java.lang;
+/**
+ * The wrapper for the primitive type {@code short}.
+ *
+ * @see java.lang.Number
+ * @since 1.1
+ */
+@FindBugsSuppressWarnings("DM_NUMBER_CTOR")
+public final class Short extends Number implements Comparable<Short> {
+    private static final long serialVersionUID = 7515723908773894738L;
+    /**
+     * The value which the receiver represents.
+     */
+    private final short value;
+    /**
+     * Constant for the maximum {@code short} value, 2<sup>15</sup>-1.
+     */
+    public static final short MAX_VALUE = (short) 0x7FFF;
+    /**
+     * Constant for the minimum {@code short} value, -2<sup>15</sup>.
+     */
+    public static final short MIN_VALUE = (short) 0x8000;
+    /**
+     * Constant for the number of bits needed to represent a {@code short} in
+     * two's complement form.
+     *
+     * @since 1.5
+     */
+    public static final int SIZE = 16;
+    /**
+     * The {@link Class} object that represents the primitive type {@code
+     * short}.
+     */
+    @SuppressWarnings("unchecked")
+    public static final Class<Short> TYPE
+            = (Class<Short>) short[].class.getComponentType();
+    // Note: Short.TYPE can't be set to "short.class", since *that* is
+    // defined to be "java.lang.Short.TYPE";
+    /**
+     * Constructs a new {@code Short} from the specified string.
+     *
+     * @param string
+     *            the string representation of a short value.
+     * @throws NumberFormatException
+     *             if {@code string} cannot be parsed as a short value.
+     * @see #parseShort(String)
+     */
+    public Short(String string) throws NumberFormatException {
+        this(parseShort(string));
+    }
+    /**
+     * Constructs a new {@code Short} with the specified primitive short value.
+     *
+     * @param value
+     *            the primitive short value to store in the new instance.
+     */
+    public Short(short value) {
+        this.value = value;
+    }
+    @Override
+    public byte byteValue() {
+        return (byte) value;
+    }
+    /**
+     * Compares this object to the specified short object to determine their
+     * relative order.
+     *
+     * @param object
+     *            the short object to compare this object to.
+     * @return a negative value if the value of this short is less than the
+     *         value of {@code object}; 0 if the value of this short and the
+     *         value of {@code object} are equal; a positive value if the value
+     *         of this short is greater than the value of {@code object}.
+     * @throws NullPointerException
+     *             if {@code object} is null.
+     * @see java.lang.Comparable
+     * @since 1.2
+     */
+    public int compareTo(Short object) {
+        return compare(value, object.value);
+    }
+    /**
+     * Compares two {@code short} values.
+     * @return 0 if lhs = rhs, less than 0 if lhs &lt; rhs, and greater than 0 if lhs &gt; rhs.
+     * @since 1.7
+     */
+    public static int compare(short lhs, short rhs) {
+        return lhs > rhs ? 1 : (lhs < rhs ? -1 : 0);
+    }
+    /**
+     * Parses the specified string and returns a {@code Short} instance if the
+     * string can be decoded into a short value. The string may be an optional
+     * minus sign "-" followed by a hexadecimal ("0x..." or "#..."), octal
+     * ("0..."), or decimal ("...") representation of a short.
+     *
+     * @param string
+     *            a string representation of a short value.
+     * @return a {@code Short} containing the value represented by
+     *         {@code string}.
+     * @throws NumberFormatException
+     *             if {@code string} cannot be parsed as a short value.
+     */
+    public static Short decode(String string) throws NumberFormatException {
+        int intValue = Integer.decode(string).intValue();
+        short result = (short) intValue;
+        if (result == intValue) {
+            return valueOf(result);
+        }
+        throw new NumberFormatException("Value out of range for short: \"" + string + "\"");
+    }
+    @Override
+    public double doubleValue() {
+        return value;
+    }
+    /**
+     * Compares this instance with the specified object and indicates if they
+     * are equal. In order to be equal, {@code object} must be an instance of
+     * {@code Short} and have the same short value as this object.
+     *
+     * @param object
+     *            the object to compare this short with.
+     * @return {@code true} if the specified object is equal to this
+     *         {@code Short}; {@code false} otherwise.
+     */
+    @Override
+    public boolean equals(Object object) {
+        return (object instanceof Short) && (((Short) object).value == value);
+    }
+    @Override
+    public float floatValue() {
+        return value;
+    }
+    @Override
+    public int hashCode() {
+        return value;
+    }
+    @Override
+    public int intValue() {
+        return value;
+    }
+    @Override
+    public long longValue() {
+        return value;
+    }
+    /**
+     * Parses the specified string as a signed decimal short value. The ASCII
+     * character \u002d ('-') is recognized as the minus sign.
+     *
+     * @param string
+     *            the string representation of a short value.
+     * @return the primitive short value represented by {@code string}.
+     * @throws NumberFormatException
+     *             if {@code string} cannot be parsed as a short value.
+     */
+    public static short parseShort(String string) throws NumberFormatException {
+        return parseShort(string, 10);
+    }
+    /**
+     * Parses the specified string as a signed short value using the specified
+     * radix. The ASCII character \u002d ('-') is recognized as the minus sign.
+     *
+     * @param string
+     *            the string representation of a short value.
+     * @param radix
+     *            the radix to use when parsing.
+     * @return the primitive short value represented by {@code string} using
+     *         {@code radix}.
+     * @throws NumberFormatException
+     *             if {@code string} cannot be parsed as a short value, or
+     *             {@code radix < Character.MIN_RADIX ||
+     *             radix > Character.MAX_RADIX}.
+     */
+    public static short parseShort(String string, int radix) throws NumberFormatException {
+        int intValue = Integer.parseInt(string, radix);
+        short result = (short) intValue;
+        if (result == intValue) {
+            return result;
+        }
+        throw new NumberFormatException("Value out of range for short: \"" + string + "\"");
+    }
+    /**
+     * Gets the primitive value of this short.
+     *
+     * @return this object's primitive value.
+     */
+    @Override
+    public short shortValue() {
+        return value;
+    }
+    @Override
+    public String toString() {
+        return Integer.toString(value);
+    }
+    /**
+     * Returns a string containing a concise, human-readable description of the
+     * specified short value with radix 10.
+     *
+     * @param value
+     *             the short to convert to a string.
+     * @return a printable representation of {@code value}.
+     */
+    public static String toString(short value) {
+        return Integer.toString(value);
+    }
+    /**
+     * Parses the specified string as a signed decimal short value.
+     *
+     * @param string
+     *            the string representation of a short value.
+     * @return a {@code Short} instance containing the short value represented
+     *         by {@code string}.
+     * @throws NumberFormatException
+     *             if {@code string} cannot be parsed as a short value.
+     * @see #parseShort(String)
+     */
+    public static Short valueOf(String string) throws NumberFormatException {
+        return valueOf(parseShort(string));
+    }
+    /**
+     * Parses the specified string as a signed short value using the specified
+     * radix.
+     *
+     * @param string
+     *            the string representation of a short value.
+     * @param radix
+     *            the radix to use when parsing.
+     * @return a {@code Short} instance containing the short value represented
+     *         by {@code string} using {@code radix}.
+     * @throws NumberFormatException
+     *             if {@code string} cannot be parsed as a short value, or
+     *             {@code radix < Character.MIN_RADIX ||
+     *             radix > Character.MAX_RADIX}.
+     * @see #parseShort(String, int)
+     */
+    public static Short valueOf(String string, int radix) throws NumberFormatException {
+        return valueOf(parseShort(string, radix));
+    }
+    /**
+     * Reverses the bytes of the specified short.
+     *
+     * @param s
+     *            the short value for which to reverse bytes.
+     * @return the reversed value.
+     * @since 1.5
+     */
+    public static short reverseBytes(short s) {
+        return (short) ((s << 8) | ((s >>> 8) & 0xFF));
+    }
+    /**
+     * Returns a {@code Short} instance for the specified short value.
+     * <p>
+     * If it is not necessary to get a new {@code Short} instance, it is
+     * recommended to use this method instead of the constructor, since it
+     * maintains a cache of instances which may result in better performance.
+     *
+     * @param s
+     *            the short value to store in the instance.
+     * @return a {@code Short} instance containing {@code s}.
+     * @since 1.5
+     */
+    public static Short valueOf(short s) {
+        return s < -128 || s >= 128 ? new Short(s) : SMALL_VALUES[s + 128];
+    }
+    /**
+     * A cache of instances used by {@link Short#valueOf(short)} and auto-boxing.
+     */
+    private static final Short[] SMALL_VALUES = new Short[256];
+    static {
+        for (int i = -128; i < 128; i++) {
+            SMALL_VALUES[i + 128] = new Short((short) i);
+        }
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/Short.java.result b/src/MapleFE/test/java/openjdk/Short.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..f2e1a293dd41b0f80a45ed23d2c3a9570974d0ad
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/Short.java.result
@@ -0,0 +1,73 @@
+Matched 5 tokens.
+Matched 627 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+class  Short
+  Fields: 
+    serialVersionUID=878762578    value    MAX_VALUE=(short)32767    MIN_VALUE=(short)32768    SIZE=16    TYPE=()short.getComponentType()    SMALL_VALUES=
+  Instance Initializer: 
+    InstInit- 0
+  Constructors: 
+    constructor  Short(string)  throws: 
+    constructor  Short(value)  throws: 
+      this.value Assign value
+  Methods: 
+    func  byteValue()  throws: 
+      return (byte)value
+    func  compareTo(object)  throws: 
+      return compare(value,object.value)
+    func  compare(lhs,rhs)  throws: 
+      return 
+    func  decode(string)  throws:     NumberFormatException
+      Decl: intValue=Integer.decode(string).intValue()
+      Decl: result=(short)intValue
+      cond-branch cond:result EQ intValue
+      true branch :
+        return valueOf(result)
+      false branch :
+
+      new NumberFormatException("Value out of range for short: \"" Add string Add "\"")
+    func  doubleValue()  throws: 
+      return value
+    func  equals(object)  throws: 
+      return (object instanceof Short) Land ((Short)object.value EQ value)
+    func  floatValue()  throws: 
+      return value
+    func  hashCode()  throws: 
+      return value
+    func  intValue()  throws: 
+      return value
+    func  longValue()  throws: 
+      return value
+    func  parseShort(string)  throws:     NumberFormatException
+      return parseShort(string,10)
+    func  parseShort(string,radix)  throws:     NumberFormatException
+      Decl: intValue=Integer.parseInt(string,radix)
+      Decl: result=(short)intValue
+      cond-branch cond:result EQ intValue
+      true branch :
+        return result
+      false branch :
+
+      new NumberFormatException("Value out of range for short: \"" Add string Add "\"")
+    func  shortValue()  throws: 
+      return value
+    func  toString()  throws: 
+      return Integer.toString(value)
+    func  toString(value)  throws: 
+      return Integer.toString(value)
+    func  valueOf(string)  throws:     NumberFormatException
+      return valueOf(parseShort(string))
+    func  valueOf(string,radix)  throws:     NumberFormatException
+      return valueOf(parseShort(string,radix))
+    func  reverseBytes(s)  throws: 
+      return (short)((s Shl 8) Bor ((s Zext 8) Band 255))
+    func  valueOf(s)  throws: 
+      return 
+  LocalClasses: 
+  LocalInterfaces: 
+
+UserType:NumberFormatException has no decl.
+UserType:NumberFormatException has no decl.
diff --git a/src/MapleFE/test/java/openjdk/StackTraceElement.java b/src/MapleFE/test/java/openjdk/StackTraceElement.java
new file mode 100644
index 0000000000000000000000000000000000000000..e519fea26af9e97cba4e99e6981c10b60dd13446
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/StackTraceElement.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import java.util.Objects;
+
+/**
+ * An element in a stack trace, as returned by {@link
+ * Throwable#getStackTrace()}.  Each element represents a single stack frame.
+ * All stack frames except for the one at the top of the stack represent
+ * a method invocation.  The frame at the top of the stack represents the
+ * execution point at which the stack trace was generated.  Typically,
+ * this is the point at which the throwable corresponding to the stack trace
+ * was created.
+ *
+ * @since  1.4
+ * @author Josh Bloch
+ */
+public final class StackTraceElement implements java.io.Serializable {
+    // Normally initialized by VM (public constructor added in 1.5)
+    private String declaringClass;
+    private String methodName;
+    private String fileName;
+    private int    lineNumber;
+
+    /**
+     * Creates a stack trace element representing the specified execution
+     * point.
+     *
+     * @param declaringClass the fully qualified name of the class containing
+     *        the execution point represented by the stack trace element
+     * @param methodName the name of the method containing the execution point
+     *        represented by the stack trace element
+     * @param fileName the name of the file containing the execution point
+     *         represented by the stack trace element, or {@code null} if
+     *         this information is unavailable
+     * @param lineNumber the line number of the source line containing the
+     *         execution point represented by this stack trace element, or
+     *         a negative number if this information is unavailable. A value
+     *         of -2 indicates that the method containing the execution point
+     *         is a native method
+     * @throws NullPointerException if {@code declaringClass} or
+     *         {@code methodName} is null
+     * @since 1.5
+     */
+    public StackTraceElement(String declaringClass, String methodName,
+                             String fileName, int lineNumber) {
+        this.declaringClass = Objects.requireNonNull(declaringClass, "Declaring class is null");
+        this.methodName     = Objects.requireNonNull(methodName, "Method name is null");
+        this.fileName       = fileName;
+        this.lineNumber     = lineNumber;
+    }
+
+    /**
+     * Returns the name of the source file containing the execution point
+     * represented by this stack trace element.  Generally, this corresponds
+     * to the {@code SourceFile} attribute of the relevant {@code class}
+     * file (as per <i>The Java Virtual Machine Specification</i>, Section
+     * 4.7.7).  In some systems, the name may refer to some source code unit
+     * other than a file, such as an entry in source repository.
+     *
+     * @return the name of the file containing the execution point
+     *         represented by this stack trace element, or {@code null} if
+     *         this information is unavailable.
+     */
+    public String getFileName() {
+        return fileName;
+    }
+
+    /**
+     * Returns the line number of the source line containing the execution
+     * point represented by this stack trace element.  Generally, this is
+     * derived from the {@code LineNumberTable} attribute of the relevant
+     * {@code class} file (as per <i>The Java Virtual Machine
+     * Specification</i>, Section 4.7.8).
+     *
+     * @return the line number of the source line containing the execution
+     *         point represented by this stack trace element, or a negative
+     *         number if this information is unavailable.
+     */
+    public int getLineNumber() {
+        return lineNumber;
+    }
+
+    /**
+     * Returns the fully qualified name of the class containing the
+     * execution point represented by this stack trace element.
+     *
+     * @return the fully qualified name of the {@code Class} containing
+     *         the execution point represented by this stack trace element.
+     */
+    public String getClassName() {
+        return declaringClass;
+    }
+
+    /**
+     * Returns the name of the method containing the execution point
+     * represented by this stack trace element.  If the execution point is
+     * contained in an instance or class initializer, this method will return
+     * the appropriate <i>special method name</i>, {@code <init>} or
+     * {@code <clinit>}, as per Section 3.9 of <i>The Java Virtual
+     * Machine Specification</i>.
+     *
+     * @return the name of the method containing the execution point
+     *         represented by this stack trace element.
+     */
+    public String getMethodName() {
+        return methodName;
+    }
+
+    /**
+     * Returns true if the method containing the execution point
+     * represented by this stack trace element is a native method.
+     *
+     * @return {@code true} if the method containing the execution point
+     *         represented by this stack trace element is a native method.
+     */
+    public boolean isNativeMethod() {
+        return lineNumber == -2;
+    }
+
+    /**
+     * Returns a string representation of this stack trace element.  The
+     * format of this string depends on the implementation, but the following
+     * examples may be regarded as typical:
+     * <ul>
+     * <li>
+     *   {@code "MyClass.mash(MyClass.java:9)"} - Here, {@code "MyClass"}
+     *   is the <i>fully-qualified name</i> of the class containing the
+     *   execution point represented by this stack trace element,
+     *   {@code "mash"} is the name of the method containing the execution
+     *   point, {@code "MyClass.java"} is the source file containing the
+     *   execution point, and {@code "9"} is the line number of the source
+     *   line containing the execution point.
+     * <li>
+     *   {@code "MyClass.mash(MyClass.java)"} - As above, but the line
+     *   number is unavailable.
+     * <li>
+     *   {@code "MyClass.mash(Unknown Source)"} - As above, but neither
+     *   the file name nor the line  number are available.
+     * <li>
+     *   {@code "MyClass.mash(Native Method)"} - As above, but neither
+     *   the file name nor the line  number are available, and the method
+     *   containing the execution point is known to be a native method.
+     * </ul>
+     * @see    Throwable#printStackTrace()
+     */
+    public String toString() {
+        // Android-changed: When ART cannot find a line number, the lineNumber field is set
+        // to the dex_pc and the fileName field is set to null.
+        StringBuilder result = new StringBuilder();
+        result.append(getClassName()).append(".").append(methodName);
+        if (isNativeMethod()) {
+            result.append("(Native Method)");
+        } else if (fileName != null) {
+            if (lineNumber >= 0) {
+                result.append("(").append(fileName).append(":").append(lineNumber).append(")");
+            } else {
+                result.append("(").append(fileName).append(")");
+            }
+        } else {
+            if (lineNumber >= 0) {
+                // The line number is actually the dex pc.
+                result.append("(Unknown Source:").append(lineNumber).append(")");
+            } else {
+                result.append("(Unknown Source)");
+            }
+        }
+        return result.toString();
+    }
+
+    /**
+     * Returns true if the specified object is another
+     * {@code StackTraceElement} instance representing the same execution
+     * point as this instance.  Two stack trace elements {@code a} and
+     * {@code b} are equal if and only if:
+     * <pre>{@code
+     *     equals(a.getFileName(), b.getFileName()) &&
+     *     a.getLineNumber() == b.getLineNumber()) &&
+     *     equals(a.getClassName(), b.getClassName()) &&
+     *     equals(a.getMethodName(), b.getMethodName())
+     * }</pre>
+     * where {@code equals} has the semantics of {@link
+     * java.util.Objects#equals(Object, Object) Objects.equals}.
+     *
+     * @param  obj the object to be compared with this stack trace element.
+     * @return true if the specified object is another
+     *         {@code StackTraceElement} instance representing the same
+     *         execution point as this instance.
+     */
+    public boolean equals(Object obj) {
+        if (obj==this)
+            return true;
+        if (!(obj instanceof StackTraceElement))
+            return false;
+        StackTraceElement e = (StackTraceElement)obj;
+        return e.declaringClass.equals(declaringClass) &&
+            e.lineNumber == lineNumber &&
+            Objects.equals(methodName, e.methodName) &&
+            Objects.equals(fileName, e.fileName);
+    }
+
+    /**
+     * Returns a hash code value for this stack trace element.
+     */
+    public int hashCode() {
+        int result = 31*declaringClass.hashCode() + methodName.hashCode();
+        result = 31*result + Objects.hashCode(fileName);
+        result = 31*result + lineNumber;
+        return result;
+    }
+
+    private static final long serialVersionUID = 6992337162326171013L;
+}
diff --git a/src/MapleFE/test/java/openjdk/StackTraceElement.java.result b/src/MapleFE/test/java/openjdk/StackTraceElement.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..610f5efb0019c2a9debe1daa437eab8762710876
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/StackTraceElement.java.result
@@ -0,0 +1,77 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 438 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import java.util.Objects
+== Sub Tree ==
+class  StackTraceElement
+  Fields: 
+    declaringClass    methodName    fileName    lineNumber    serialVersionUID=641129861
+  Instance Initializer: 
+  Constructors: 
+    constructor  StackTraceElement(declaringClass,methodName,fileName,lineNumber)  throws: 
+      this.declaringClass Assign Objects.requireNonNull(declaringClass,"Declaring class is null")
+      this.methodName Assign Objects.requireNonNull(methodName,"Method name is null")
+      this.fileName Assign fileName
+      this.lineNumber Assign lineNumber
+  Methods: 
+    func  getFileName()  throws: 
+      return fileName
+    func  getLineNumber()  throws: 
+      return lineNumber
+    func  getClassName()  throws: 
+      return declaringClass
+    func  getMethodName()  throws: 
+      return methodName
+    func  isNativeMethod()  throws: 
+      return lineNumber EQ -2
+    func  toString()  throws: 
+      Decl: result=new StringBuilder()
+      result.append(getClassName()).append(".").append(methodName)
+      cond-branch cond:isNativeMethod()
+      true branch :
+        result.append("(Native Method)")
+      false branch :
+        cond-branch cond:fileName NE null
+        true branch :
+          cond-branch cond:lineNumber GE 0
+          true branch :
+            result.append("(").append(fileName).append(":").append(lineNumber).append(")")
+          false branch :
+            result.append("(").append(fileName).append(")")
+
+        false branch :
+          cond-branch cond:lineNumber GE 0
+          true branch :
+            result.append("(Unknown Source:").append(lineNumber).append(")")
+          false branch :
+            result.append("(Unknown Source)")
+
+
+      return result.toString()
+    func  equals(obj)  throws: 
+      cond-branch cond:obj EQ this
+      true branch :
+        return true      false branch :
+
+      cond-branch cond:(obj instanceof StackTraceElement)
+      true branch :
+        return false      false branch :
+
+      Decl: e=(StackTraceElement)obj
+      return e.declaringClass.equals(declaringClass) Land e.lineNumber EQ lineNumber Land Objects.equals(methodName,e.methodName) Land Objects.equals(fileName,e.fileName)
+    func  hashCode()  throws: 
+      Decl: result=31 Mul declaringClass.hashCode() Add methodName.hashCode()
+      result Assign 31 Mul result Add Objects.hashCode(fileName)
+      result Assign 31 Mul result Add lineNumber
+      return result
+  LocalClasses: 
+  LocalInterfaces: 
+
+Identifier:result has no decl.
+Identifier:result has no decl.
+Identifier:result has no decl.
+Identifier:result has no decl.
diff --git a/src/MapleFE/test/java/openjdk/StrictMath.java b/src/MapleFE/test/java/openjdk/StrictMath.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae4af2bcac896b7a804e2d7cef1ab3ac7cef6c38
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/StrictMath.java
@@ -0,0 +1,1710 @@
+/*
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+import java.util.Random;
+import sun.misc.DoubleConsts;
+
+/**
+ * The class {@code StrictMath} contains methods for performing basic
+ * numeric operations such as the elementary exponential, logarithm,
+ * square root, and trigonometric functions.
+ *
+ * <p>To help ensure portability of Java programs, the definitions of
+ * some of the numeric functions in this package require that they
+ * produce the same results as certain published algorithms. These
+ * algorithms are available from the well-known network library
+ * {@code netlib} as the package "Freely Distributable Math
+ * Library," <a
+ * href="ftp://ftp.netlib.org/fdlibm.tar">{@code fdlibm}</a>. These
+ * algorithms, which are written in the C programming language, are
+ * then to be understood as executed with all floating-point
+ * operations following the rules of Java floating-point arithmetic.
+ *
+ * <p>The Java math library is defined with respect to
+ * {@code fdlibm} version 5.3. Where {@code fdlibm} provides
+ * more than one definition for a function (such as
+ * {@code acos}), use the "IEEE 754 core function" version
+ * (residing in a file whose name begins with the letter
+ * {@code e}).  The methods which require {@code fdlibm}
+ * semantics are {@code sin}, {@code cos}, {@code tan},
+ * {@code asin}, {@code acos}, {@code atan},
+ * {@code exp}, {@code log}, {@code log10},
+ * {@code cbrt}, {@code atan2}, {@code pow},
+ * {@code sinh}, {@code cosh}, {@code tanh},
+ * {@code hypot}, {@code expm1}, and {@code log1p}.
+ *
+ * <p>
+ * The platform uses signed two's complement integer arithmetic with
+ * int and long primitive types.  The developer should choose
+ * the primitive type to ensure that arithmetic operations consistently
+ * produce correct results, which in some cases means the operations
+ * will not overflow the range of values of the computation.
+ * The best practice is to choose the primitive type and algorithm to avoid
+ * overflow. In cases where the size is {@code int} or {@code long} and
+ * overflow errors need to be detected, the methods {@code addExact},
+ * {@code subtractExact}, {@code multiplyExact}, and {@code toIntExact}
+ * throw an {@code ArithmeticException} when the results overflow.
+ * For other arithmetic operations such as divide, absolute value,
+ * increment, decrement, and negation overflow occurs only with
+ * a specific minimum or maximum value and should be checked against
+ * the minimum or maximum as appropriate.
+ *
+ * @author  unascribed
+ * @author  Joseph D. Darcy
+ * @since   1.3
+ */
+
+public final class StrictMath {
+
+    /**
+     * Don't let anyone instantiate this class.
+     */
+    private StrictMath() {}
+
+    /**
+     * The {@code double} value that is closer than any other to
+     * <i>e</i>, the base of the natural logarithms.
+     */
+    public static final double E = 2.7182818284590452354;
+
+    /**
+     * The {@code double} value that is closer than any other to
+     * <i>pi</i>, the ratio of the circumference of a circle to its
+     * diameter.
+     */
+    public static final double PI = 3.14159265358979323846;
+
+    /**
+     * Returns the trigonometric sine of an angle. Special cases:
+     * <ul><li>If the argument is NaN or an infinity, then the
+     * result is NaN.
+     * <li>If the argument is zero, then the result is a zero with the
+     * same sign as the argument.</ul>
+     *
+     * @param   a   an angle, in radians.
+     * @return  the sine of the argument.
+     */
+    public static native double sin(double a);
+
+    /**
+     * Returns the trigonometric cosine of an angle. Special cases:
+     * <ul><li>If the argument is NaN or an infinity, then the
+     * result is NaN.</ul>
+     *
+     * @param   a   an angle, in radians.
+     * @return  the cosine of the argument.
+     */
+    public static native double cos(double a);
+
+    /**
+     * Returns the trigonometric tangent of an angle. Special cases:
+     * <ul><li>If the argument is NaN or an infinity, then the result
+     * is NaN.
+     * <li>If the argument is zero, then the result is a zero with the
+     * same sign as the argument.</ul>
+     *
+     * @param   a   an angle, in radians.
+     * @return  the tangent of the argument.
+     */
+    public static native double tan(double a);
+
+    /**
+     * Returns the arc sine of a value; the returned angle is in the
+     * range -<i>pi</i>/2 through <i>pi</i>/2.  Special cases:
+     * <ul><li>If the argument is NaN or its absolute value is greater
+     * than 1, then the result is NaN.
+     * <li>If the argument is zero, then the result is a zero with the
+     * same sign as the argument.</ul>
+     *
+     * @param   a   the value whose arc sine is to be returned.
+     * @return  the arc sine of the argument.
+     */
+    public static native double asin(double a);
+
+    /**
+     * Returns the arc cosine of a value; the returned angle is in the
+     * range 0.0 through <i>pi</i>.  Special case:
+     * <ul><li>If the argument is NaN or its absolute value is greater
+     * than 1, then the result is NaN.</ul>
+     *
+     * @param   a   the value whose arc cosine is to be returned.
+     * @return  the arc cosine of the argument.
+     */
+    public static native double acos(double a);
+
+    /**
+     * Returns the arc tangent of a value; the returned angle is in the
+     * range -<i>pi</i>/2 through <i>pi</i>/2.  Special cases:
+     * <ul><li>If the argument is NaN, then the result is NaN.
+     * <li>If the argument is zero, then the result is a zero with the
+     * same sign as the argument.</ul>
+     *
+     * @param   a   the value whose arc tangent is to be returned.
+     * @return  the arc tangent of the argument.
+     */
+    public static native double atan(double a);
+
+    /**
+     * Converts an angle measured in degrees to an approximately
+     * equivalent angle measured in radians.  The conversion from
+     * degrees to radians is generally inexact.
+     *
+     * @param   angdeg   an angle, in degrees
+     * @return  the measurement of the angle {@code angdeg}
+     *          in radians.
+     */
+    public static strictfp double toRadians(double angdeg) {
+        // Do not delegate to Math.toRadians(angdeg) because
+        // this method has the strictfp modifier.
+        return angdeg / 180.0 * PI;
+    }
+
+    /**
+     * Converts an angle measured in radians to an approximately
+     * equivalent angle measured in degrees.  The conversion from
+     * radians to degrees is generally inexact; users should
+     * <i>not</i> expect {@code cos(toRadians(90.0))} to exactly
+     * equal {@code 0.0}.
+     *
+     * @param   angrad   an angle, in radians
+     * @return  the measurement of the angle {@code angrad}
+     *          in degrees.
+     */
+    public static strictfp double toDegrees(double angrad) {
+        // Do not delegate to Math.toDegrees(angrad) because
+        // this method has the strictfp modifier.
+        return angrad * 180.0 / PI;
+    }
+
+    /**
+     * Returns Euler's number <i>e</i> raised to the power of a
+     * {@code double} value. Special cases:
+     * <ul><li>If the argument is NaN, the result is NaN.
+     * <li>If the argument is positive infinity, then the result is
+     * positive infinity.
+     * <li>If the argument is negative infinity, then the result is
+     * positive zero.</ul>
+     *
+     * @param   a   the exponent to raise <i>e</i> to.
+     * @return  the value <i>e</i><sup>{@code a}</sup>,
+     *          where <i>e</i> is the base of the natural logarithms.
+     */
+    public static native double exp(double a);
+
+    /**
+     * Returns the natural logarithm (base <i>e</i>) of a {@code double}
+     * value. Special cases:
+     * <ul><li>If the argument is NaN or less than zero, then the result
+     * is NaN.
+     * <li>If the argument is positive infinity, then the result is
+     * positive infinity.
+     * <li>If the argument is positive zero or negative zero, then the
+     * result is negative infinity.</ul>
+     *
+     * @param   a   a value
+     * @return  the value ln&nbsp;{@code a}, the natural logarithm of
+     *          {@code a}.
+     */
+    public static native double log(double a);
+
+
+    /**
+     * Returns the base 10 logarithm of a {@code double} value.
+     * Special cases:
+     *
+     * <ul><li>If the argument is NaN or less than zero, then the result
+     * is NaN.
+     * <li>If the argument is positive infinity, then the result is
+     * positive infinity.
+     * <li>If the argument is positive zero or negative zero, then the
+     * result is negative infinity.
+     * <li> If the argument is equal to 10<sup><i>n</i></sup> for
+     * integer <i>n</i>, then the result is <i>n</i>.
+     * </ul>
+     *
+     * @param   a   a value
+     * @return  the base 10 logarithm of  {@code a}.
+     * @since 1.5
+     */
+    public static native double log10(double a);
+
+    /**
+     * Returns the correctly rounded positive square root of a
+     * {@code double} value.
+     * Special cases:
+     * <ul><li>If the argument is NaN or less than zero, then the result
+     * is NaN.
+     * <li>If the argument is positive infinity, then the result is positive
+     * infinity.
+     * <li>If the argument is positive zero or negative zero, then the
+     * result is the same as the argument.</ul>
+     * Otherwise, the result is the {@code double} value closest to
+     * the true mathematical square root of the argument value.
+     *
+     * @param   a   a value.
+     * @return  the positive square root of {@code a}.
+     */
+    public static native double sqrt(double a);
+
+    /**
+     * Returns the cube root of a {@code double} value.  For
+     * positive finite {@code x}, {@code cbrt(-x) ==
+     * -cbrt(x)}; that is, the cube root of a negative value is
+     * the negative of the cube root of that value's magnitude.
+     * Special cases:
+     *
+     * <ul>
+     *
+     * <li>If the argument is NaN, then the result is NaN.
+     *
+     * <li>If the argument is infinite, then the result is an infinity
+     * with the same sign as the argument.
+     *
+     * <li>If the argument is zero, then the result is a zero with the
+     * same sign as the argument.
+     *
+     * </ul>
+     *
+     * @param   a   a value.
+     * @return  the cube root of {@code a}.
+     * @since 1.5
+     */
+    public static native double cbrt(double a);
+
+    /**
+     * Computes the remainder operation on two arguments as prescribed
+     * by the IEEE 754 standard.
+     * The remainder value is mathematically equal to
+     * <code>f1&nbsp;-&nbsp;f2</code>&nbsp;&times;&nbsp;<i>n</i>,
+     * where <i>n</i> is the mathematical integer closest to the exact
+     * mathematical value of the quotient {@code f1/f2}, and if two
+     * mathematical integers are equally close to {@code f1/f2},
+     * then <i>n</i> is the integer that is even. If the remainder is
+     * zero, its sign is the same as the sign of the first argument.
+     * Special cases:
+     * <ul><li>If either argument is NaN, or the first argument is infinite,
+     * or the second argument is positive zero or negative zero, then the
+     * result is NaN.
+     * <li>If the first argument is finite and the second argument is
+     * infinite, then the result is the same as the first argument.</ul>
+     *
+     * @param   f1   the dividend.
+     * @param   f2   the divisor.
+     * @return  the remainder when {@code f1} is divided by
+     *          {@code f2}.
+     */
+    public static native double IEEEremainder(double f1, double f2);
+
+    /**
+     * Returns the smallest (closest to negative infinity)
+     * {@code double} value that is greater than or equal to the
+     * argument and is equal to a mathematical integer. Special cases:
+     * <ul><li>If the argument value is already equal to a
+     * mathematical integer, then the result is the same as the
+     * argument.  <li>If the argument is NaN or an infinity or
+     * positive zero or negative zero, then the result is the same as
+     * the argument.  <li>If the argument value is less than zero but
+     * greater than -1.0, then the result is negative zero.</ul> Note
+     * that the value of {@code StrictMath.ceil(x)} is exactly the
+     * value of {@code -StrictMath.floor(-x)}.
+     *
+     * @param   a   a value.
+     * @return  the smallest (closest to negative infinity)
+     *          floating-point value that is greater than or equal to
+     *          the argument and is equal to a mathematical integer.
+     */
+    public static double ceil(double a) {
+        return floorOrCeil(a, -0.0, 1.0, 1.0);
+    }
+
+    /**
+     * Returns the largest (closest to positive infinity)
+     * {@code double} value that is less than or equal to the
+     * argument and is equal to a mathematical integer. Special cases:
+     * <ul><li>If the argument value is already equal to a
+     * mathematical integer, then the result is the same as the
+     * argument.  <li>If the argument is NaN or an infinity or
+     * positive zero or negative zero, then the result is the same as
+     * the argument.</ul>
+     *
+     * @param   a   a value.
+     * @return  the largest (closest to positive infinity)
+     *          floating-point value that less than or equal to the argument
+     *          and is equal to a mathematical integer.
+     */
+    public static double floor(double a) {
+        return floorOrCeil(a, -1.0, 0.0, -1.0);
+    }
+
+    /**
+     * Internal method to share logic between floor and ceil.
+     *
+     * @param a the value to be floored or ceiled
+     * @param negativeBoundary result for values in (-1, 0)
+     * @param positiveBoundary result for values in (0, 1)
+     * @param increment value to add when the argument is non-integral
+     */
+    private static double floorOrCeil(double a,
+                                      double negativeBoundary,
+                                      double positiveBoundary,
+                                      double sign) {
+        int exponent = Math.getExponent(a);
+
+        if (exponent < 0) {
+            /*
+             * Absolute value of argument is less than 1.
+             * floorOrceil(-0.0) => -0.0
+             * floorOrceil(+0.0) => +0.0
+             */
+            return ((a == 0.0) ? a :
+                    ( (a < 0.0) ?  negativeBoundary : positiveBoundary) );
+        } else if (exponent >= 52) {
+            /*
+             * Infinity, NaN, or a value so large it must be integral.
+             */
+            return a;
+        }
+        // Else the argument is either an integral value already XOR it
+        // has to be rounded to one.
+        assert exponent >= 0 && exponent <= 51;
+
+        long doppel = Double.doubleToRawLongBits(a);
+        long mask   = DoubleConsts.SIGNIF_BIT_MASK >> exponent;
+
+        if ( (mask & doppel) == 0L )
+            return a; // integral value
+        else {
+            double result = Double.longBitsToDouble(doppel & (~mask));
+            if (sign*a > 0.0)
+                result = result + sign;
+            return result;
+        }
+    }
+
+    /**
+     * Returns the {@code double} value that is closest in value
+     * to the argument and is equal to a mathematical integer. If two
+     * {@code double} values that are mathematical integers are
+     * equally close to the value of the argument, the result is the
+     * integer value that is even. Special cases:
+     * <ul><li>If the argument value is already equal to a mathematical
+     * integer, then the result is the same as the argument.
+     * <li>If the argument is NaN or an infinity or positive zero or negative
+     * zero, then the result is the same as the argument.</ul>
+     *
+     * @param   a   a value.
+     * @return  the closest floating-point value to {@code a} that is
+     *          equal to a mathematical integer.
+     * @author Joseph D. Darcy
+     */
+    public static double rint(double a) {
+        /*
+         * If the absolute value of a is not less than 2^52, it
+         * is either a finite integer (the double format does not have
+         * enough significand bits for a number that large to have any
+         * fractional portion), an infinity, or a NaN.  In any of
+         * these cases, rint of the argument is the argument.
+         *
+         * Otherwise, the sum (twoToThe52 + a ) will properly round
+         * away any fractional portion of a since ulp(twoToThe52) ==
+         * 1.0; subtracting out twoToThe52 from this sum will then be
+         * exact and leave the rounded integer portion of a.
+         *
+         * This method does *not* need to be declared strictfp to get
+         * fully reproducible results.  Whether or not a method is
+         * declared strictfp can only make a difference in the
+         * returned result if some operation would overflow or
+         * underflow with strictfp semantics.  The operation
+         * (twoToThe52 + a ) cannot overflow since large values of a
+         * are screened out; the add cannot underflow since twoToThe52
+         * is too large.  The subtraction ((twoToThe52 + a ) -
+         * twoToThe52) will be exact as discussed above and thus
+         * cannot overflow or meaningfully underflow.  Finally, the
+         * last multiply in the return statement is by plus or minus
+         * 1.0, which is exact too.
+         */
+        double twoToThe52 = (double)(1L << 52); // 2^52
+        double sign = Math.copySign(1.0, a); // preserve sign info
+        a = Math.abs(a);
+
+        if (a < twoToThe52) { // E_min <= ilogb(a) <= 51
+            a = ((twoToThe52 + a ) - twoToThe52);
+        }
+
+        return sign * a; // restore original sign
+    }
+
+    /**
+     * Returns the angle <i>theta</i> from the conversion of rectangular
+     * coordinates ({@code x},&nbsp;{@code y}) to polar
+     * coordinates (r,&nbsp;<i>theta</i>).
+     * This method computes the phase <i>theta</i> by computing an arc tangent
+     * of {@code y/x} in the range of -<i>pi</i> to <i>pi</i>. Special
+     * cases:
+     * <ul><li>If either argument is NaN, then the result is NaN.
+     * <li>If the first argument is positive zero and the second argument
+     * is positive, or the first argument is positive and finite and the
+     * second argument is positive infinity, then the result is positive
+     * zero.
+     * <li>If the first argument is negative zero and the second argument
+     * is positive, or the first argument is negative and finite and the
+     * second argument is positive infinity, then the result is negative zero.
+     * <li>If the first argument is positive zero and the second argument
+     * is negative, or the first argument is positive and finite and the
+     * second argument is negative infinity, then the result is the
+     * {@code double} value closest to <i>pi</i>.
+     * <li>If the first argument is negative zero and the second argument
+     * is negative, or the first argument is negative and finite and the
+     * second argument is negative infinity, then the result is the
+     * {@code double} value closest to -<i>pi</i>.
+     * <li>If the first argument is positive and the second argument is
+     * positive zero or negative zero, or the first argument is positive
+     * infinity and the second argument is finite, then the result is the
+     * {@code double} value closest to <i>pi</i>/2.
+     * <li>If the first argument is negative and the second argument is
+     * positive zero or negative zero, or the first argument is negative
+     * infinity and the second argument is finite, then the result is the
+     * {@code double} value closest to -<i>pi</i>/2.
+     * <li>If both arguments are positive infinity, then the result is the
+     * {@code double} value closest to <i>pi</i>/4.
+     * <li>If the first argument is positive infinity and the second argument
+     * is negative infinity, then the result is the {@code double}
+     * value closest to 3*<i>pi</i>/4.
+     * <li>If the first argument is negative infinity and the second argument
+     * is positive infinity, then the result is the {@code double} value
+     * closest to -<i>pi</i>/4.
+     * <li>If both arguments are negative infinity, then the result is the
+     * {@code double} value closest to -3*<i>pi</i>/4.</ul>
+     *
+     * @param   y   the ordinate coordinate
+     * @param   x   the abscissa coordinate
+     * @return  the <i>theta</i> component of the point
+     *          (<i>r</i>,&nbsp;<i>theta</i>)
+     *          in polar coordinates that corresponds to the point
+     *          (<i>x</i>,&nbsp;<i>y</i>) in Cartesian coordinates.
+     */
+    public static native double atan2(double y, double x);
+
+
+    /**
+     * Returns the value of the first argument raised to the power of the
+     * second argument. Special cases:
+     *
+     * <ul><li>If the second argument is positive or negative zero, then the
+     * result is 1.0.
+     * <li>If the second argument is 1.0, then the result is the same as the
+     * first argument.
+     * <li>If the second argument is NaN, then the result is NaN.
+     * <li>If the first argument is NaN and the second argument is nonzero,
+     * then the result is NaN.
+     *
+     * <li>If
+     * <ul>
+     * <li>the absolute value of the first argument is greater than 1
+     * and the second argument is positive infinity, or
+     * <li>the absolute value of the first argument is less than 1 and
+     * the second argument is negative infinity,
+     * </ul>
+     * then the result is positive infinity.
+     *
+     * <li>If
+     * <ul>
+     * <li>the absolute value of the first argument is greater than 1 and
+     * the second argument is negative infinity, or
+     * <li>the absolute value of the
+     * first argument is less than 1 and the second argument is positive
+     * infinity,
+     * </ul>
+     * then the result is positive zero.
+     *
+     * <li>If the absolute value of the first argument equals 1 and the
+     * second argument is infinite, then the result is NaN.
+     *
+     * <li>If
+     * <ul>
+     * <li>the first argument is positive zero and the second argument
+     * is greater than zero, or
+     * <li>the first argument is positive infinity and the second
+     * argument is less than zero,
+     * </ul>
+     * then the result is positive zero.
+     *
+     * <li>If
+     * <ul>
+     * <li>the first argument is positive zero and the second argument
+     * is less than zero, or
+     * <li>the first argument is positive infinity and the second
+     * argument is greater than zero,
+     * </ul>
+     * then the result is positive infinity.
+     *
+     * <li>If
+     * <ul>
+     * <li>the first argument is negative zero and the second argument
+     * is greater than zero but not a finite odd integer, or
+     * <li>the first argument is negative infinity and the second
+     * argument is less than zero but not a finite odd integer,
+     * </ul>
+     * then the result is positive zero.
+     *
+     * <li>If
+     * <ul>
+     * <li>the first argument is negative zero and the second argument
+     * is a positive finite odd integer, or
+     * <li>the first argument is negative infinity and the second
+     * argument is a negative finite odd integer,
+     * </ul>
+     * then the result is negative zero.
+     *
+     * <li>If
+     * <ul>
+     * <li>the first argument is negative zero and the second argument
+     * is less than zero but not a finite odd integer, or
+     * <li>the first argument is negative infinity and the second
+     * argument is greater than zero but not a finite odd integer,
+     * </ul>
+     * then the result is positive infinity.
+     *
+     * <li>If
+     * <ul>
+     * <li>the first argument is negative zero and the second argument
+     * is a negative finite odd integer, or
+     * <li>the first argument is negative infinity and the second
+     * argument is a positive finite odd integer,
+     * </ul>
+     * then the result is negative infinity.
+     *
+     * <li>If the first argument is finite and less than zero
+     * <ul>
+     * <li> if the second argument is a finite even integer, the
+     * result is equal to the result of raising the absolute value of
+     * the first argument to the power of the second argument
+     *
+     * <li>if the second argument is a finite odd integer, the result
+     * is equal to the negative of the result of raising the absolute
+     * value of the first argument to the power of the second
+     * argument
+     *
+     * <li>if the second argument is finite and not an integer, then
+     * the result is NaN.
+     * </ul>
+     *
+     * <li>If both arguments are integers, then the result is exactly equal
+     * to the mathematical result of raising the first argument to the power
+     * of the second argument if that result can in fact be represented
+     * exactly as a {@code double} value.</ul>
+     *
+     * <p>(In the foregoing descriptions, a floating-point value is
+     * considered to be an integer if and only if it is finite and a
+     * fixed point of the method {@link #ceil ceil} or,
+     * equivalently, a fixed point of the method {@link #floor
+     * floor}. A value is a fixed point of a one-argument
+     * method if and only if the result of applying the method to the
+     * value is equal to the value.)
+     *
+     * @param   a   base.
+     * @param   b   the exponent.
+     * @return  the value {@code a}<sup>{@code b}</sup>.
+     */
+    public static native double pow(double a, double b);
+
+    /**
+     * Returns the closest {@code int} to the argument, with ties
+     * rounding to positive infinity.
+     *
+     * <p>Special cases:
+     * <ul><li>If the argument is NaN, the result is 0.
+     * <li>If the argument is negative infinity or any value less than or
+     * equal to the value of {@code Integer.MIN_VALUE}, the result is
+     * equal to the value of {@code Integer.MIN_VALUE}.
+     * <li>If the argument is positive infinity or any value greater than or
+     * equal to the value of {@code Integer.MAX_VALUE}, the result is
+     * equal to the value of {@code Integer.MAX_VALUE}.</ul>
+     *
+     * @param   a   a floating-point value to be rounded to an integer.
+     * @return  the value of the argument rounded to the nearest
+     *          {@code int} value.
+     * @see     java.lang.Integer#MAX_VALUE
+     * @see     java.lang.Integer#MIN_VALUE
+     */
+    public static int round(float a) {
+        return Math.round(a);
+    }
+
+    /**
+     * Returns the closest {@code long} to the argument, with ties
+     * rounding to positive infinity.
+     *
+     * <p>Special cases:
+     * <ul><li>If the argument is NaN, the result is 0.
+     * <li>If the argument is negative infinity or any value less than or
+     * equal to the value of {@code Long.MIN_VALUE}, the result is
+     * equal to the value of {@code Long.MIN_VALUE}.
+     * <li>If the argument is positive infinity or any value greater than or
+     * equal to the value of {@code Long.MAX_VALUE}, the result is
+     * equal to the value of {@code Long.MAX_VALUE}.</ul>
+     *
+     * @param   a  a floating-point value to be rounded to a
+     *          {@code long}.
+     * @return  the value of the argument rounded to the nearest
+     *          {@code long} value.
+     * @see     java.lang.Long#MAX_VALUE
+     * @see     java.lang.Long#MIN_VALUE
+     */
+    public static long round(double a) {
+        return Math.round(a);
+    }
+
+    private static final class RandomNumberGeneratorHolder {
+        static final Random randomNumberGenerator = new Random();
+    }
+
+    /**
+     * Returns a {@code double} value with a positive sign, greater
+     * than or equal to {@code 0.0} and less than {@code 1.0}.
+     * Returned values are chosen pseudorandomly with (approximately)
+     * uniform distribution from that range.
+     *
+     * <p>When this method is first called, it creates a single new
+     * pseudorandom-number generator, exactly as if by the expression
+     *
+     * <blockquote>{@code new java.util.Random()}</blockquote>
+     *
+     * This new pseudorandom-number generator is used thereafter for
+     * all calls to this method and is used nowhere else.
+     *
+     * <p>This method is properly synchronized to allow correct use by
+     * more than one thread. However, if many threads need to generate
+     * pseudorandom numbers at a great rate, it may reduce contention
+     * for each thread to have its own pseudorandom-number generator.
+     *
+     * @return  a pseudorandom {@code double} greater than or equal
+     * to {@code 0.0} and less than {@code 1.0}.
+     * @see Random#nextDouble()
+     */
+    public static double random() {
+        return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
+    }
+
+    /**
+     * Returns the sum of its arguments,
+     * throwing an exception if the result overflows an {@code int}.
+     *
+     * @param x the first value
+     * @param y the second value
+     * @return the result
+     * @throws ArithmeticException if the result overflows an int
+     * @see Math#addExact(int,int)
+     * @since 1.8
+     */
+    public static int addExact(int x, int y) {
+        return Math.addExact(x, y);
+    }
+
+    /**
+     * Returns the sum of its arguments,
+     * throwing an exception if the result overflows a {@code long}.
+     *
+     * @param x the first value
+     * @param y the second value
+     * @return the result
+     * @throws ArithmeticException if the result overflows a long
+     * @see Math#addExact(long,long)
+     * @since 1.8
+     */
+    public static long addExact(long x, long y) {
+        return Math.addExact(x, y);
+    }
+
+    /**
+     * Returns the difference of the arguments,
+     * throwing an exception if the result overflows an {@code int}.
+     *
+     * @param x the first value
+     * @param y the second value to subtract from the first
+     * @return the result
+     * @throws ArithmeticException if the result overflows an int
+     * @see Math#subtractExact(int,int)
+     * @since 1.8
+     */
+    public static int subtractExact(int x, int y) {
+        return Math.subtractExact(x, y);
+    }
+
+    /**
+     * Returns the difference of the arguments,
+     * throwing an exception if the result overflows a {@code long}.
+     *
+     * @param x the first value
+     * @param y the second value to subtract from the first
+     * @return the result
+     * @throws ArithmeticException if the result overflows a long
+     * @see Math#subtractExact(long,long)
+     * @since 1.8
+     */
+    public static long subtractExact(long x, long y) {
+        return Math.subtractExact(x, y);
+    }
+
+    /**
+     * Returns the product of the arguments,
+     * throwing an exception if the result overflows an {@code int}.
+     *
+     * @param x the first value
+     * @param y the second value
+     * @return the result
+     * @throws ArithmeticException if the result overflows an int
+     * @see Math#multiplyExact(int,int)
+     * @since 1.8
+     */
+    public static int multiplyExact(int x, int y) {
+        return Math.multiplyExact(x, y);
+    }
+
+    /**
+     * Returns the product of the arguments,
+     * throwing an exception if the result overflows a {@code long}.
+     *
+     * @param x the first value
+     * @param y the second value
+     * @return the result
+     * @throws ArithmeticException if the result overflows a long
+     * @see Math#multiplyExact(long,long)
+     * @since 1.8
+     */
+    public static long multiplyExact(long x, long y) {
+        return Math.multiplyExact(x, y);
+    }
+
+    /**
+     * Returns the value of the {@code long} argument;
+     * throwing an exception if the value overflows an {@code int}.
+     *
+     * @param value the long value
+     * @return the argument as an int
+     * @throws ArithmeticException if the {@code argument} overflows an int
+     * @see Math#toIntExact(long)
+     * @since 1.8
+     */
+    public static int toIntExact(long value) {
+        return Math.toIntExact(value);
+    }
+
+    /**
+     * Returns the largest (closest to positive infinity)
+     * {@code int} value that is less than or equal to the algebraic quotient.
+     * There is one special case, if the dividend is the
+     * {@linkplain Integer#MIN_VALUE Integer.MIN_VALUE} and the divisor is {@code -1},
+     * then integer overflow occurs and
+     * the result is equal to the {@code Integer.MIN_VALUE}.
+     * <p>
+     * See {@link Math#floorDiv(int, int) Math.floorDiv} for examples and
+     * a comparison to the integer division {@code /} operator.
+     *
+     * @param x the dividend
+     * @param y the divisor
+     * @return the largest (closest to positive infinity)
+     * {@code int} value that is less than or equal to the algebraic quotient.
+     * @throws ArithmeticException if the divisor {@code y} is zero
+     * @see Math#floorDiv(int, int)
+     * @see Math#floor(double)
+     * @since 1.8
+     */
+    public static int floorDiv(int x, int y) {
+        return Math.floorDiv(x, y);
+    }
+
+    /**
+     * Returns the largest (closest to positive infinity)
+     * {@code long} value that is less than or equal to the algebraic quotient.
+     * There is one special case, if the dividend is the
+     * {@linkplain Long#MIN_VALUE Long.MIN_VALUE} and the divisor is {@code -1},
+     * then integer overflow occurs and
+     * the result is equal to the {@code Long.MIN_VALUE}.
+     * <p>
+     * See {@link Math#floorDiv(int, int) Math.floorDiv} for examples and
+     * a comparison to the integer division {@code /} operator.
+     *
+     * @param x the dividend
+     * @param y the divisor
+     * @return the largest (closest to positive infinity)
+     * {@code long} value that is less than or equal to the algebraic quotient.
+     * @throws ArithmeticException if the divisor {@code y} is zero
+     * @see Math#floorDiv(long, long)
+     * @see Math#floor(double)
+     * @since 1.8
+     */
+    public static long floorDiv(long x, long y) {
+        return Math.floorDiv(x, y);
+    }
+
+    /**
+     * Returns the floor modulus of the {@code int} arguments.
+     * <p>
+     * The floor modulus is {@code x - (floorDiv(x, y) * y)},
+     * has the same sign as the divisor {@code y}, and
+     * is in the range of {@code -abs(y) < r < +abs(y)}.
+     * <p>
+     * The relationship between {@code floorDiv} and {@code floorMod} is such that:
+     * <ul>
+     *   <li>{@code floorDiv(x, y) * y + floorMod(x, y) == x}
+     * </ul>
+     * <p>
+     * See {@link Math#floorMod(int, int) Math.floorMod} for examples and
+     * a comparison to the {@code %} operator.
+     *
+     * @param x the dividend
+     * @param y the divisor
+     * @return the floor modulus {@code x - (floorDiv(x, y) * y)}
+     * @throws ArithmeticException if the divisor {@code y} is zero
+     * @see Math#floorMod(int, int)
+     * @see StrictMath#floorDiv(int, int)
+     * @since 1.8
+     */
+    public static int floorMod(int x, int y) {
+        return Math.floorMod(x , y);
+    }
+    /**
+     * Returns the floor modulus of the {@code long} arguments.
+     * <p>
+     * The floor modulus is {@code x - (floorDiv(x, y) * y)},
+     * has the same sign as the divisor {@code y}, and
+     * is in the range of {@code -abs(y) < r < +abs(y)}.
+     * <p>
+     * The relationship between {@code floorDiv} and {@code floorMod} is such that:
+     * <ul>
+     *   <li>{@code floorDiv(x, y) * y + floorMod(x, y) == x}
+     * </ul>
+     * <p>
+     * See {@link Math#floorMod(int, int) Math.floorMod} for examples and
+     * a comparison to the {@code %} operator.
+     *
+     * @param x the dividend
+     * @param y the divisor
+     * @return the floor modulus {@code x - (floorDiv(x, y) * y)}
+     * @throws ArithmeticException if the divisor {@code y} is zero
+     * @see Math#floorMod(long, long)
+     * @see StrictMath#floorDiv(long, long)
+     * @since 1.8
+     */
+    public static long floorMod(long x, long y) {
+        return Math.floorMod(x, y);
+    }
+
+    /**
+     * Returns the absolute value of an {@code int} value.
+     * If the argument is not negative, the argument is returned.
+     * If the argument is negative, the negation of the argument is returned.
+     *
+     * <p>Note that if the argument is equal to the value of
+     * {@link Integer#MIN_VALUE}, the most negative representable
+     * {@code int} value, the result is that same value, which is
+     * negative.
+     *
+     * @param   a   the  argument whose absolute value is to be determined.
+     * @return  the absolute value of the argument.
+     */
+    public static int abs(int a) {
+        return Math.abs(a);
+    }
+
+    /**
+     * Returns the absolute value of a {@code long} value.
+     * If the argument is not negative, the argument is returned.
+     * If the argument is negative, the negation of the argument is returned.
+     *
+     * <p>Note that if the argument is equal to the value of
+     * {@link Long#MIN_VALUE}, the most negative representable
+     * {@code long} value, the result is that same value, which
+     * is negative.
+     *
+     * @param   a   the  argument whose absolute value is to be determined.
+     * @return  the absolute value of the argument.
+     */
+    public static long abs(long a) {
+        return Math.abs(a);
+    }
+
+    /**
+     * Returns the absolute value of a {@code float} value.
+     * If the argument is not negative, the argument is returned.
+     * If the argument is negative, the negation of the argument is returned.
+     * Special cases:
+     * <ul><li>If the argument is positive zero or negative zero, the
+     * result is positive zero.
+     * <li>If the argument is infinite, the result is positive infinity.
+     * <li>If the argument is NaN, the result is NaN.</ul>
+     * In other words, the result is the same as the value of the expression:
+     * <p>{@code Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))}
+     *
+     * @param   a   the argument whose absolute value is to be determined
+     * @return  the absolute value of the argument.
+     */
+    public static float abs(float a) {
+        return Math.abs(a);
+    }
+
+    /**
+     * Returns the absolute value of a {@code double} value.
+     * If the argument is not negative, the argument is returned.
+     * If the argument is negative, the negation of the argument is returned.
+     * Special cases:
+     * <ul><li>If the argument is positive zero or negative zero, the result
+     * is positive zero.
+     * <li>If the argument is infinite, the result is positive infinity.
+     * <li>If the argument is NaN, the result is NaN.</ul>
+     * In other words, the result is the same as the value of the expression:
+     * <p>{@code Double.longBitsToDouble((Double.doubleToLongBits(a)<<1)>>>1)}
+     *
+     * @param   a   the argument whose absolute value is to be determined
+     * @return  the absolute value of the argument.
+     */
+    public static double abs(double a) {
+        return Math.abs(a);
+    }
+
+    /**
+     * Returns the greater of two {@code int} values. That is, the
+     * result is the argument closer to the value of
+     * {@link Integer#MAX_VALUE}. If the arguments have the same value,
+     * the result is that same value.
+     *
+     * @param   a   an argument.
+     * @param   b   another argument.
+     * @return  the larger of {@code a} and {@code b}.
+     */
+    public static int max(int a, int b) {
+        return Math.max(a, b);
+    }
+
+    /**
+     * Returns the greater of two {@code long} values. That is, the
+     * result is the argument closer to the value of
+     * {@link Long#MAX_VALUE}. If the arguments have the same value,
+     * the result is that same value.
+     *
+     * @param   a   an argument.
+     * @param   b   another argument.
+     * @return  the larger of {@code a} and {@code b}.
+        */
+    public static long max(long a, long b) {
+        return Math.max(a, b);
+    }
+
+    /**
+     * Returns the greater of two {@code float} values.  That is,
+     * the result is the argument closer to positive infinity. If the
+     * arguments have the same value, the result is that same
+     * value. If either value is NaN, then the result is NaN.  Unlike
+     * the numerical comparison operators, this method considers
+     * negative zero to be strictly smaller than positive zero. If one
+     * argument is positive zero and the other negative zero, the
+     * result is positive zero.
+     *
+     * @param   a   an argument.
+     * @param   b   another argument.
+     * @return  the larger of {@code a} and {@code b}.
+     */
+    public static float max(float a, float b) {
+        return Math.max(a, b);
+    }
+
+    /**
+     * Returns the greater of two {@code double} values.  That
+     * is, the result is the argument closer to positive infinity. If
+     * the arguments have the same value, the result is that same
+     * value. If either value is NaN, then the result is NaN.  Unlike
+     * the numerical comparison operators, this method considers
+     * negative zero to be strictly smaller than positive zero. If one
+     * argument is positive zero and the other negative zero, the
+     * result is positive zero.
+     *
+     * @param   a   an argument.
+     * @param   b   another argument.
+     * @return  the larger of {@code a} and {@code b}.
+     */
+    public static double max(double a, double b) {
+        return Math.max(a, b);
+    }
+
+    /**
+     * Returns the smaller of two {@code int} values. That is,
+     * the result the argument closer to the value of
+     * {@link Integer#MIN_VALUE}.  If the arguments have the same
+     * value, the result is that same value.
+     *
+     * @param   a   an argument.
+     * @param   b   another argument.
+     * @return  the smaller of {@code a} and {@code b}.
+     */
+    public static int min(int a, int b) {
+        return Math.min(a, b);
+    }
+
+    /**
+     * Returns the smaller of two {@code long} values. That is,
+     * the result is the argument closer to the value of
+     * {@link Long#MIN_VALUE}. If the arguments have the same
+     * value, the result is that same value.
+     *
+     * @param   a   an argument.
+     * @param   b   another argument.
+     * @return  the smaller of {@code a} and {@code b}.
+     */
+    public static long min(long a, long b) {
+        return Math.min(a, b);
+    }
+
+    /**
+     * Returns the smaller of two {@code float} values.  That is,
+     * the result is the value closer to negative infinity. If the
+     * arguments have the same value, the result is that same
+     * value. If either value is NaN, then the result is NaN.  Unlike
+     * the numerical comparison operators, this method considers
+     * negative zero to be strictly smaller than positive zero.  If
+     * one argument is positive zero and the other is negative zero,
+     * the result is negative zero.
+     *
+     * @param   a   an argument.
+     * @param   b   another argument.
+     * @return  the smaller of {@code a} and {@code b.}
+     */
+    public static float min(float a, float b) {
+        return Math.min(a, b);
+    }
+
+    /**
+     * Returns the smaller of two {@code double} values.  That
+     * is, the result is the value closer to negative infinity. If the
+     * arguments have the same value, the result is that same
+     * value. If either value is NaN, then the result is NaN.  Unlike
+     * the numerical comparison operators, this method considers
+     * negative zero to be strictly smaller than positive zero. If one
+     * argument is positive zero and the other is negative zero, the
+     * result is negative zero.
+     *
+     * @param   a   an argument.
+     * @param   b   another argument.
+     * @return  the smaller of {@code a} and {@code b}.
+     */
+    public static double min(double a, double b) {
+        return Math.min(a, b);
+    }
+
+    /**
+     * Returns the size of an ulp of the argument.  An ulp, unit in
+     * the last place, of a {@code double} value is the positive
+     * distance between this floating-point value and the {@code
+     * double} value next larger in magnitude.  Note that for non-NaN
+     * <i>x</i>, <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.
+     *
+     * <p>Special Cases:
+     * <ul>
+     * <li> If the argument is NaN, then the result is NaN.
+     * <li> If the argument is positive or negative infinity, then the
+     * result is positive infinity.
+     * <li> If the argument is positive or negative zero, then the result is
+     * {@code Double.MIN_VALUE}.
+     * <li> If the argument is &plusmn;{@code Double.MAX_VALUE}, then
+     * the result is equal to 2<sup>971</sup>.
+     * </ul>
+     *
+     * @param d the floating-point value whose ulp is to be returned
+     * @return the size of an ulp of the argument
+     * @author Joseph D. Darcy
+     * @since 1.5
+     */
+    public static double ulp(double d) {
+        return Math.ulp(d);
+    }
+
+    /**
+     * Returns the size of an ulp of the argument.  An ulp, unit in
+     * the last place, of a {@code float} value is the positive
+     * distance between this floating-point value and the {@code
+     * float} value next larger in magnitude.  Note that for non-NaN
+     * <i>x</i>, <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.
+     *
+     * <p>Special Cases:
+     * <ul>
+     * <li> If the argument is NaN, then the result is NaN.
+     * <li> If the argument is positive or negative infinity, then the
+     * result is positive infinity.
+     * <li> If the argument is positive or negative zero, then the result is
+     * {@code Float.MIN_VALUE}.
+     * <li> If the argument is &plusmn;{@code Float.MAX_VALUE}, then
+     * the result is equal to 2<sup>104</sup>.
+     * </ul>
+     *
+     * @param f the floating-point value whose ulp is to be returned
+     * @return the size of an ulp of the argument
+     * @author Joseph D. Darcy
+     * @since 1.5
+     */
+    public static float ulp(float f) {
+        return Math.ulp(f);
+    }
+
+    /**
+     * Returns the signum function of the argument; zero if the argument
+     * is zero, 1.0 if the argument is greater than zero, -1.0 if the
+     * argument is less than zero.
+     *
+     * <p>Special Cases:
+     * <ul>
+     * <li> If the argument is NaN, then the result is NaN.
+     * <li> If the argument is positive zero or negative zero, then the
+     *      result is the same as the argument.
+     * </ul>
+     *
+     * @param d the floating-point value whose signum is to be returned
+     * @return the signum function of the argument
+     * @author Joseph D. Darcy
+     * @since 1.5
+     */
+    public static double signum(double d) {
+        return Math.signum(d);
+    }
+
+    /**
+     * Returns the signum function of the argument; zero if the argument
+     * is zero, 1.0f if the argument is greater than zero, -1.0f if the
+     * argument is less than zero.
+     *
+     * <p>Special Cases:
+     * <ul>
+     * <li> If the argument is NaN, then the result is NaN.
+     * <li> If the argument is positive zero or negative zero, then the
+     *      result is the same as the argument.
+     * </ul>
+     *
+     * @param f the floating-point value whose signum is to be returned
+     * @return the signum function of the argument
+     * @author Joseph D. Darcy
+     * @since 1.5
+     */
+    public static float signum(float f) {
+        return Math.signum(f);
+    }
+
+    /**
+     * Returns the hyperbolic sine of a {@code double} value.
+     * The hyperbolic sine of <i>x</i> is defined to be
+     * (<i>e<sup>x</sup>&nbsp;-&nbsp;e<sup>-x</sup></i>)/2
+     * where <i>e</i> is {@linkplain Math#E Euler's number}.
+     *
+     * <p>Special cases:
+     * <ul>
+     *
+     * <li>If the argument is NaN, then the result is NaN.
+     *
+     * <li>If the argument is infinite, then the result is an infinity
+     * with the same sign as the argument.
+     *
+     * <li>If the argument is zero, then the result is a zero with the
+     * same sign as the argument.
+     *
+     * </ul>
+     *
+     * @param   x The number whose hyperbolic sine is to be returned.
+     * @return  The hyperbolic sine of {@code x}.
+     * @since 1.5
+     */
+    public static native double sinh(double x);
+
+    /**
+     * Returns the hyperbolic cosine of a {@code double} value.
+     * The hyperbolic cosine of <i>x</i> is defined to be
+     * (<i>e<sup>x</sup>&nbsp;+&nbsp;e<sup>-x</sup></i>)/2
+     * where <i>e</i> is {@linkplain Math#E Euler's number}.
+     *
+     * <p>Special cases:
+     * <ul>
+     *
+     * <li>If the argument is NaN, then the result is NaN.
+     *
+     * <li>If the argument is infinite, then the result is positive
+     * infinity.
+     *
+     * <li>If the argument is zero, then the result is {@code 1.0}.
+     *
+     * </ul>
+     *
+     * @param   x The number whose hyperbolic cosine is to be returned.
+     * @return  The hyperbolic cosine of {@code x}.
+     * @since 1.5
+     */
+    public static native double cosh(double x);
+
+    /**
+     * Returns the hyperbolic tangent of a {@code double} value.
+     * The hyperbolic tangent of <i>x</i> is defined to be
+     * (<i>e<sup>x</sup>&nbsp;-&nbsp;e<sup>-x</sup></i>)/(<i>e<sup>x</sup>&nbsp;+&nbsp;e<sup>-x</sup></i>),
+     * in other words, {@linkplain Math#sinh
+     * sinh(<i>x</i>)}/{@linkplain Math#cosh cosh(<i>x</i>)}.  Note
+     * that the absolute value of the exact tanh is always less than
+     * 1.
+     *
+     * <p>Special cases:
+     * <ul>
+     *
+     * <li>If the argument is NaN, then the result is NaN.
+     *
+     * <li>If the argument is zero, then the result is a zero with the
+     * same sign as the argument.
+     *
+     * <li>If the argument is positive infinity, then the result is
+     * {@code +1.0}.
+     *
+     * <li>If the argument is negative infinity, then the result is
+     * {@code -1.0}.
+     *
+     * </ul>
+     *
+     * @param   x The number whose hyperbolic tangent is to be returned.
+     * @return  The hyperbolic tangent of {@code x}.
+     * @since 1.5
+     */
+    public static native double tanh(double x);
+
+    /**
+     * Returns sqrt(<i>x</i><sup>2</sup>&nbsp;+<i>y</i><sup>2</sup>)
+     * without intermediate overflow or underflow.
+     *
+     * <p>Special cases:
+     * <ul>
+     *
+     * <li> If either argument is infinite, then the result
+     * is positive infinity.
+     *
+     * <li> If either argument is NaN and neither argument is infinite,
+     * then the result is NaN.
+     *
+     * </ul>
+     *
+     * @param x a value
+     * @param y a value
+     * @return sqrt(<i>x</i><sup>2</sup>&nbsp;+<i>y</i><sup>2</sup>)
+     * without intermediate overflow or underflow
+     * @since 1.5
+     */
+    public static native double hypot(double x, double y);
+
+    /**
+     * Returns <i>e</i><sup>x</sup>&nbsp;-1.  Note that for values of
+     * <i>x</i> near 0, the exact sum of
+     * {@code expm1(x)}&nbsp;+&nbsp;1 is much closer to the true
+     * result of <i>e</i><sup>x</sup> than {@code exp(x)}.
+     *
+     * <p>Special cases:
+     * <ul>
+     * <li>If the argument is NaN, the result is NaN.
+     *
+     * <li>If the argument is positive infinity, then the result is
+     * positive infinity.
+     *
+     * <li>If the argument is negative infinity, then the result is
+     * -1.0.
+     *
+     * <li>If the argument is zero, then the result is a zero with the
+     * same sign as the argument.
+     *
+     * </ul>
+     *
+     * @param   x   the exponent to raise <i>e</i> to in the computation of
+     *              <i>e</i><sup>{@code x}</sup>&nbsp;-1.
+     * @return  the value <i>e</i><sup>{@code x}</sup>&nbsp;-&nbsp;1.
+     * @since 1.5
+     */
+    public static native double expm1(double x);
+
+    /**
+     * Returns the natural logarithm of the sum of the argument and 1.
+     * Note that for small values {@code x}, the result of
+     * {@code log1p(x)} is much closer to the true result of ln(1
+     * + {@code x}) than the floating-point evaluation of
+     * {@code log(1.0+x)}.
+     *
+     * <p>Special cases:
+     * <ul>
+     *
+     * <li>If the argument is NaN or less than -1, then the result is
+     * NaN.
+     *
+     * <li>If the argument is positive infinity, then the result is
+     * positive infinity.
+     *
+     * <li>If the argument is negative one, then the result is
+     * negative infinity.
+     *
+     * <li>If the argument is zero, then the result is a zero with the
+     * same sign as the argument.
+     *
+     * </ul>
+     *
+     * @param   x   a value
+     * @return the value ln({@code x}&nbsp;+&nbsp;1), the natural
+     * log of {@code x}&nbsp;+&nbsp;1
+     * @since 1.5
+     */
+    public static native double log1p(double x);
+
+    /**
+     * Returns the first floating-point argument with the sign of the
+     * second floating-point argument.  For this method, a NaN
+     * {@code sign} argument is always treated as if it were
+     * positive.
+     *
+     * @param magnitude  the parameter providing the magnitude of the result
+     * @param sign   the parameter providing the sign of the result
+     * @return a value with the magnitude of {@code magnitude}
+     * and the sign of {@code sign}.
+     * @since 1.6
+     */
+    public static double copySign(double magnitude, double sign) {
+        return Math.copySign(magnitude, (Double.isNaN(sign)?1.0d:sign));
+    }
+
+    /**
+     * Returns the first floating-point argument with the sign of the
+     * second floating-point argument.  For this method, a NaN
+     * {@code sign} argument is always treated as if it were
+     * positive.
+     *
+     * @param magnitude  the parameter providing the magnitude of the result
+     * @param sign   the parameter providing the sign of the result
+     * @return a value with the magnitude of {@code magnitude}
+     * and the sign of {@code sign}.
+     * @since 1.6
+     */
+    public static float copySign(float magnitude, float sign) {
+        return Math.copySign(magnitude, (Float.isNaN(sign)?1.0f:sign));
+    }
+    /**
+     * Returns the unbiased exponent used in the representation of a
+     * {@code float}.  Special cases:
+     *
+     * <ul>
+     * <li>If the argument is NaN or infinite, then the result is
+     * {@link Float#MAX_EXPONENT} + 1.
+     * <li>If the argument is zero or subnormal, then the result is
+     * {@link Float#MIN_EXPONENT} -1.
+     * </ul>
+     * @param f a {@code float} value
+     * @return the unbiased exponent of the argument
+     * @since 1.6
+     */
+    public static int getExponent(float f) {
+        return Math.getExponent(f);
+    }
+
+    /**
+     * Returns the unbiased exponent used in the representation of a
+     * {@code double}.  Special cases:
+     *
+     * <ul>
+     * <li>If the argument is NaN or infinite, then the result is
+     * {@link Double#MAX_EXPONENT} + 1.
+     * <li>If the argument is zero or subnormal, then the result is
+     * {@link Double#MIN_EXPONENT} -1.
+     * </ul>
+     * @param d a {@code double} value
+     * @return the unbiased exponent of the argument
+     * @since 1.6
+     */
+    public static int getExponent(double d) {
+        return Math.getExponent(d);
+    }
+
+    /**
+     * Returns the floating-point number adjacent to the first
+     * argument in the direction of the second argument.  If both
+     * arguments compare as equal the second argument is returned.
+     *
+     * <p>Special cases:
+     * <ul>
+     * <li> If either argument is a NaN, then NaN is returned.
+     *
+     * <li> If both arguments are signed zeros, {@code direction}
+     * is returned unchanged (as implied by the requirement of
+     * returning the second argument if the arguments compare as
+     * equal).
+     *
+     * <li> If {@code start} is
+     * &plusmn;{@link Double#MIN_VALUE} and {@code direction}
+     * has a value such that the result should have a smaller
+     * magnitude, then a zero with the same sign as {@code start}
+     * is returned.
+     *
+     * <li> If {@code start} is infinite and
+     * {@code direction} has a value such that the result should
+     * have a smaller magnitude, {@link Double#MAX_VALUE} with the
+     * same sign as {@code start} is returned.
+     *
+     * <li> If {@code start} is equal to &plusmn;
+     * {@link Double#MAX_VALUE} and {@code direction} has a
+     * value such that the result should have a larger magnitude, an
+     * infinity with same sign as {@code start} is returned.
+     * </ul>
+     *
+     * @param start  starting floating-point value
+     * @param direction value indicating which of
+     * {@code start}'s neighbors or {@code start} should
+     * be returned
+     * @return The floating-point number adjacent to {@code start} in the
+     * direction of {@code direction}.
+     * @since 1.6
+     */
+    public static double nextAfter(double start, double direction) {
+        return Math.nextAfter(start, direction);
+    }
+
+    /**
+     * Returns the floating-point number adjacent to the first
+     * argument in the direction of the second argument.  If both
+     * arguments compare as equal a value equivalent to the second argument
+     * is returned.
+     *
+     * <p>Special cases:
+     * <ul>
+     * <li> If either argument is a NaN, then NaN is returned.
+     *
+     * <li> If both arguments are signed zeros, a value equivalent
+     * to {@code direction} is returned.
+     *
+     * <li> If {@code start} is
+     * &plusmn;{@link Float#MIN_VALUE} and {@code direction}
+     * has a value such that the result should have a smaller
+     * magnitude, then a zero with the same sign as {@code start}
+     * is returned.
+     *
+     * <li> If {@code start} is infinite and
+     * {@code direction} has a value such that the result should
+     * have a smaller magnitude, {@link Float#MAX_VALUE} with the
+     * same sign as {@code start} is returned.
+     *
+     * <li> If {@code start} is equal to &plusmn;
+     * {@link Float#MAX_VALUE} and {@code direction} has a
+     * value such that the result should have a larger magnitude, an
+     * infinity with same sign as {@code start} is returned.
+     * </ul>
+     *
+     * @param start  starting floating-point value
+     * @param direction value indicating which of
+     * {@code start}'s neighbors or {@code start} should
+     * be returned
+     * @return The floating-point number adjacent to {@code start} in the
+     * direction of {@code direction}.
+     * @since 1.6
+     */
+    public static float nextAfter(float start, double direction) {
+        return Math.nextAfter(start, direction);
+    }
+
+    /**
+     * Returns the floating-point value adjacent to {@code d} in
+     * the direction of positive infinity.  This method is
+     * semantically equivalent to {@code nextAfter(d,
+     * Double.POSITIVE_INFINITY)}; however, a {@code nextUp}
+     * implementation may run faster than its equivalent
+     * {@code nextAfter} call.
+     *
+     * <p>Special Cases:
+     * <ul>
+     * <li> If the argument is NaN, the result is NaN.
+     *
+     * <li> If the argument is positive infinity, the result is
+     * positive infinity.
+     *
+     * <li> If the argument is zero, the result is
+     * {@link Double#MIN_VALUE}
+     *
+     * </ul>
+     *
+     * @param d starting floating-point value
+     * @return The adjacent floating-point value closer to positive
+     * infinity.
+     * @since 1.6
+     */
+    public static double nextUp(double d) {
+        return Math.nextUp(d);
+    }
+
+    /**
+     * Returns the floating-point value adjacent to {@code f} in
+     * the direction of positive infinity.  This method is
+     * semantically equivalent to {@code nextAfter(f,
+     * Float.POSITIVE_INFINITY)}; however, a {@code nextUp}
+     * implementation may run faster than its equivalent
+     * {@code nextAfter} call.
+     *
+     * <p>Special Cases:
+     * <ul>
+     * <li> If the argument is NaN, the result is NaN.
+     *
+     * <li> If the argument is positive infinity, the result is
+     * positive infinity.
+     *
+     * <li> If the argument is zero, the result is
+     * {@link Float#MIN_VALUE}
+     *
+     * </ul>
+     *
+     * @param f starting floating-point value
+     * @return The adjacent floating-point value closer to positive
+     * infinity.
+     * @since 1.6
+     */
+    public static float nextUp(float f) {
+        return Math.nextUp(f);
+    }
+
+    /**
+     * Returns the floating-point value adjacent to {@code d} in
+     * the direction of negative infinity.  This method is
+     * semantically equivalent to {@code nextAfter(d,
+     * Double.NEGATIVE_INFINITY)}; however, a
+     * {@code nextDown} implementation may run faster than its
+     * equivalent {@code nextAfter} call.
+     *
+     * <p>Special Cases:
+     * <ul>
+     * <li> If the argument is NaN, the result is NaN.
+     *
+     * <li> If the argument is negative infinity, the result is
+     * negative infinity.
+     *
+     * <li> If the argument is zero, the result is
+     * {@code -Double.MIN_VALUE}
+     *
+     * </ul>
+     *
+     * @param d  starting floating-point value
+     * @return The adjacent floating-point value closer to negative
+     * infinity.
+     * @since 1.8
+     */
+    public static double nextDown(double d) {
+        return Math.nextDown(d);
+    }
+
+    /**
+     * Returns the floating-point value adjacent to {@code f} in
+     * the direction of negative infinity.  This method is
+     * semantically equivalent to {@code nextAfter(f,
+     * Float.NEGATIVE_INFINITY)}; however, a
+     * {@code nextDown} implementation may run faster than its
+     * equivalent {@code nextAfter} call.
+     *
+     * <p>Special Cases:
+     * <ul>
+     * <li> If the argument is NaN, the result is NaN.
+     *
+     * <li> If the argument is negative infinity, the result is
+     * negative infinity.
+     *
+     * <li> If the argument is zero, the result is
+     * {@code -Float.MIN_VALUE}
+     *
+     * </ul>
+     *
+     * @param f  starting floating-point value
+     * @return The adjacent floating-point value closer to negative
+     * infinity.
+     * @since 1.8
+     */
+    public static float nextDown(float f) {
+        return Math.nextDown(f);
+    }
+
+    /**
+     * Returns {@code d} &times;
+     * 2<sup>{@code scaleFactor}</sup> rounded as if performed
+     * by a single correctly rounded floating-point multiply to a
+     * member of the double value set.  See the Java
+     * Language Specification for a discussion of floating-point
+     * value sets.  If the exponent of the result is between {@link
+     * Double#MIN_EXPONENT} and {@link Double#MAX_EXPONENT}, the
+     * answer is calculated exactly.  If the exponent of the result
+     * would be larger than {@code Double.MAX_EXPONENT}, an
+     * infinity is returned.  Note that if the result is subnormal,
+     * precision may be lost; that is, when {@code scalb(x, n)}
+     * is subnormal, {@code scalb(scalb(x, n), -n)} may not equal
+     * <i>x</i>.  When the result is non-NaN, the result has the same
+     * sign as {@code d}.
+     *
+     * <p>Special cases:
+     * <ul>
+     * <li> If the first argument is NaN, NaN is returned.
+     * <li> If the first argument is infinite, then an infinity of the
+     * same sign is returned.
+     * <li> If the first argument is zero, then a zero of the same
+     * sign is returned.
+     * </ul>
+     *
+     * @param d number to be scaled by a power of two.
+     * @param scaleFactor power of 2 used to scale {@code d}
+     * @return {@code d} &times; 2<sup>{@code scaleFactor}</sup>
+     * @since 1.6
+     */
+    public static double scalb(double d, int scaleFactor) {
+        return Math.scalb(d, scaleFactor);
+    }
+
+    /**
+     * Returns {@code f} &times;
+     * 2<sup>{@code scaleFactor}</sup> rounded as if performed
+     * by a single correctly rounded floating-point multiply to a
+     * member of the float value set.  See the Java
+     * Language Specification for a discussion of floating-point
+     * value sets.  If the exponent of the result is between {@link
+     * Float#MIN_EXPONENT} and {@link Float#MAX_EXPONENT}, the
+     * answer is calculated exactly.  If the exponent of the result
+     * would be larger than {@code Float.MAX_EXPONENT}, an
+     * infinity is returned.  Note that if the result is subnormal,
+     * precision may be lost; that is, when {@code scalb(x, n)}
+     * is subnormal, {@code scalb(scalb(x, n), -n)} may not equal
+     * <i>x</i>.  When the result is non-NaN, the result has the same
+     * sign as {@code f}.
+     *
+     * <p>Special cases:
+     * <ul>
+     * <li> If the first argument is NaN, NaN is returned.
+     * <li> If the first argument is infinite, then an infinity of the
+     * same sign is returned.
+     * <li> If the first argument is zero, then a zero of the same
+     * sign is returned.
+     * </ul>
+     *
+     * @param f number to be scaled by a power of two.
+     * @param scaleFactor power of 2 used to scale {@code f}
+     * @return {@code f} &times; 2<sup>{@code scaleFactor}</sup>
+     * @since 1.6
+     */
+    public static float scalb(float f, int scaleFactor) {
+        return Math.scalb(f, scaleFactor);
+    }
+}
diff --git a/src/MapleFE/test/java/openjdk/StrictMath.java.result b/src/MapleFE/test/java/openjdk/StrictMath.java.result
new file mode 100644
index 0000000000000000000000000000000000000000..43c673cea33cbea5851d6c80142ce66fa203db18
--- /dev/null
+++ b/src/MapleFE/test/java/openjdk/StrictMath.java.result
@@ -0,0 +1,176 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 1469 tokens.
+============= Module ===========
+== Sub Tree ==
+package java.lang
+== Sub Tree ==
+import java.util.Random
+== Sub Tree ==
+import sun.misc.DoubleConsts
+== Sub Tree ==
+class  StrictMath
+  Fields: 
+    E=2.71828    PI=3.14159
+  Instance Initializer: 
+  Constructors: 
+    constructor  StrictMath()  throws: 
+  Methods: 
+    func  sin(a)  throws: 
+    func  cos(a)  throws: 
+    func  tan(a)  throws: 
+    func  asin(a)  throws: 
+    func  acos(a)  throws: 
+    func  atan(a)  throws: 
+    func  toRadians(angdeg)  throws: 
+      return angdeg Div 180 Mul PI
+    func  toDegrees(angrad)  throws: 
+      return angrad Mul 180 Div PI
+    func  exp(a)  throws: 
+    func  log(a)  throws: 
+    func  log10(a)  throws: 
+    func  sqrt(a)  throws: 
+    func  cbrt(a)  throws: 
+    func  IEEEremainder(f1,f2)  throws: 
+    func  ceil(a)  throws: 
+      return floorOrCeil(a,-0,1,1)
+    func  floor(a)  throws: 
+      return floorOrCeil(a,-1,0,-1)
+    func  floorOrCeil(a,negativeBoundary,positiveBoundary,sign)  throws: 
+      Decl: exponent=Math.getExponent(a)
+      cond-branch cond:exponent LT 0
+      true branch :
+        return ()
+      false branch :
+        cond-branch cond:exponent GE 52
+        true branch :
+          return a
+        false branch :
+
+      assert exponent GE 0 Land exponent LE 51 : 
+      Decl: doppel=Double.doubleToRawLongBits(a)
+      Decl: mask=DoubleConsts.SIGNIF_BIT_MASK Shr exponent
+      cond-branch cond:(mask Band doppel) EQ 0
+      true branch :
+        return a      false branch :
+        Decl: result=Double.longBitsToDouble(doppel Band (mask))
+        cond-branch cond:sign Mul a GT 0
+        true branch :
+          result Assign result Add sign        false branch :
+
+        return result
+
+    func  rint(a)  throws: 
+      Decl: twoToThe52=(double)(1 Shl 52)
+      Decl: sign=Math.copySign(1,a)
+      a Assign Math.abs(a)
+      cond-branch cond:a LT twoToThe52
+      true branch :
+        a Assign ((twoToThe52 Add a) Sub twoToThe52)
+      false branch :
+
+      return sign Mul a
+    func  atan2(y,x)  throws: 
+    func  pow(a,b)  throws: 
+    func  round(a)  throws: 
+      return Math.round(a)
+    func  round(a)  throws: 
+      return Math.round(a)
+    func  random()  throws: 
+      return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble()
+    func  addExact(x,y)  throws: 
+      return Math.addExact(x,y)
+    func  addExact(x,y)  throws: 
+      return Math.addExact(x,y)
+    func  subtractExact(x,y)  throws: 
+      return Math.subtractExact(x,y)
+    func  subtractExact(x,y)  throws: 
+      return Math.subtractExact(x,y)
+    func  multiplyExact(x,y)  throws: 
+      return Math.multiplyExact(x,y)
+    func  multiplyExact(x,y)  throws: 
+      return Math.multiplyExact(x,y)
+    func  toIntExact(value)  throws: 
+      return Math.toIntExact(value)
+    func  floorDiv(x,y)  throws: 
+      return Math.floorDiv(x,y)
+    func  floorDiv(x,y)  throws: 
+      return Math.floorDiv(x,y)
+    func  floorMod(x,y)  throws: 
+      return Math.floorMod(x,y)
+    func  floorMod(x,y)  throws: 
+      return Math.floorMod(x,y)
+    func  abs(a)  throws: 
+      return Math.abs(a)
+    func  abs(a)  throws: 
+      return Math.abs(a)
+    func  abs(a)  throws: 
+      return Math.abs(a)
+    func  abs(a)  throws: 
+      return Math.abs(a)
+    func  max(a,b)  throws: 
+      return Math.max(a,b)
+    func  max(a,b)  throws: 
+      return Math.max(a,b)
+    func  max(a,b)  throws: 
+      return Math.max(a,b)
+    func  max(a,b)  throws: 
+      return Math.max(a,b)
+    func  min(a,b)  throws: 
+      return Math.min(a,b)
+    func  min(a,b)  throws: 
+      return Math.min(a,b)
+    func  min(a,b)  throws: 
+      return Math.min(a,b)
+    func  min(a,b)  throws: 
+      return Math.min(a,b)
+    func  ulp(d)  throws: 
+      return Math.ulp(d)
+    func  ulp(f)  throws: 
+      return Math.ulp(f)
+    func  signum(d)  throws: 
+      return Math.signum(d)
+    func  signum(f)  throws: 
+      return Math.signum(f)
+    func  sinh(x)  throws: 
+    func  cosh(x)  throws: 
+    func  tanh(x)  throws: 
+    func  hypot(x,y)  throws: 
+    func  expm1(x)  throws: 
+    func  log1p(x)  throws: 
+    func  copySign(magnitude,sign)  throws: 
+      return Math.copySign(magnitude,())
+    func  copySign(magnitude,sign)  throws: 
+      return Math.copySign(magnitude,())
+    func  getExponent(f)  throws: 
+      return Math.getExponent(f)
+    func  getExponent(d)  throws: 
+      return Math.getExponent(d)
+    func  nextAfter(start,direction)  throws: 
+      return Math.nextAfter(start,direction)
+    func  nextAfter(start,direction)  throws: 
+      return Math.nextAfter(start,direction)
+    func  nextUp(d)  throws: 
+      return Math.nextUp(d)
+    func  nextUp(f)  throws: 
+      return Math.nextUp(f)
+    func  nextDown(d)  throws: 
+      return Math.nextDown(d)
+    func  nextDown(f)  throws: 
+      return Math.nextDown(f)
+    func  scalb(d,scaleFactor)  throws: 
+      return Math.scalb(d,scaleFactor)
+    func  scalb(f,scaleFactor)  throws: 
+      return Math.scalb(f,scaleFactor)
+  LocalClasses: 
+    class  RandomNumberGeneratorHolder
+      Fields: 
+        randomNumberGenerator=new Random()
+      Instance Initializer: 
+      Constructors: 
+      Methods: 
+      LocalClasses: 
+      LocalInterfaces: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/openjdk/generate-result.sh b/src/MapleFE/test/java/openjdk/generate-result.sh
similarity index 92%
rename from src/MapleFE/test/openjdk/generate-result.sh
rename to src/MapleFE/test/java/openjdk/generate-result.sh
index bbd3acd878bd41d3a31fc5123972e954d7c9fcd0..08b3acc3b58dc1585fb15888064b004629e72007 100755
--- a/src/MapleFE/test/openjdk/generate-result.sh
+++ b/src/MapleFE/test/java/openjdk/generate-result.sh
@@ -17,5 +17,5 @@ FILES=$(pwd)/*.java
 for f in $FILES
 do
   echo "Generating result for $f ..."
-  ../../output/java/java2mpl $f > $f.result
+  ../../../output/java/java/java2mpl $f > $f.result
 done
diff --git a/src/MapleFE/test/others/ChatTest-1.java b/src/MapleFE/test/java/others/ChatTest-1.java
similarity index 100%
rename from src/MapleFE/test/others/ChatTest-1.java
rename to src/MapleFE/test/java/others/ChatTest-1.java
diff --git a/src/MapleFE/test/others/ChatTest-1.java.result b/src/MapleFE/test/java/others/ChatTest-1.java.result
similarity index 57%
rename from src/MapleFE/test/others/ChatTest-1.java.result
rename to src/MapleFE/test/java/others/ChatTest-1.java.result
index d55049c9bf1d5050a278afd07f004dded5f5b1e1..199b485acd4c4704be2e0e6aed2e3025a514e691 100644
--- a/src/MapleFE/test/others/ChatTest-1.java.result
+++ b/src/MapleFE/test/java/others/ChatTest-1.java.result
@@ -28,7 +28,7 @@ class  ChatTest
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  main()  throws:     Throwable
+    func  main(args)  throws:     Throwable
       testStartStop()
       testPortOpen()
       testAsksForName()
@@ -37,57 +37,63 @@ class  ChatTest
       testUsernameAndMessage()
       testDontReceiveMessageInNameState()
     func  startServer()  throws:     IOException
-      var:server=new ChatServer<ChatServer>
-      var:address=(InetSocketAddress)server.getSocketAddress()
+      Decl: server=new ChatServer(0)
+      Decl: address=(InetSocketAddress)server.getSocketAddress()
       listeningPort Assign address.getPort()
       server.run()
       return server
     func  testStartStop()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       server.shutdown()
     func  testPortOpen()  throws:     Exception
-      var:server=startServer()
-      var:socket=new Socket<Socket>
+      Decl: server=startServer()
+      Decl: socket=new Socket("localhost",listeningPort)
       cond-branch cond:socket.isConnected()
       true branch :
-        new RuntimeException<RuntimeException>
+        new RuntimeException("Failed to connect to server: port not open")
       false branch :
 
 
       server.shutdown()
 
     func  testAsksForName()  throws:     Exception
-      var:server=startServer()
-      var:socket=new Socket<Socket>
+      Decl: server=startServer()
+      Decl: socket=new Socket("localhost",listeningPort)
+      Decl: reader=new BufferedReader(new InputStreamReader(socket.getInputStream()))
+      Decl: string=readAvailableString(reader)
+      cond-branch cond:string.equals("Name: ")
+      true branch :
+        new RuntimeException("Server doesn't send Name: ")
+      false branch :
 
 
       server.shutdown()
 
     func  testUseName()  throws:     Throwable
-      var:server=startServer()
+      Decl: server=startServer()
       performTestUseName()
 
       server.shutdown()
 
     func  testConnectDisconnectConnect()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       performTestConnectDisconnectConnect()
 
       server.shutdown()
 
     func  testUsernameAndMessage()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       performTestUsernameAndMessage()
 
       server.shutdown()
 
     func  testDontReceiveMessageInNameState()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       performDontReceiveMessageInNameState()
 
       server.shutdown()
 
-    func  assertEqual()  throws: 
+    func  assertEqual(exception,value,expected)  throws: 
       cond-branch cond:expected EQ value
       true branch :
         return 
@@ -95,23 +101,23 @@ class  ChatTest
 
       cond-branch cond:expected EQ null
       true branch :
-        exception.add(new RuntimeException<RuntimeException>)
+        exception.add(new RuntimeException("Expected null, but was: " Add value))
         return 
       false branch :
 
       cond-branch cond:expected.equals(value)
       true branch :
-        exception.add(new RuntimeException<RuntimeException>)
+        exception.add(new RuntimeException("Expected: " Add expected Add " but was: " Add value))
         return 
       false branch :
 
     func  performDontReceiveMessageInNameState()  throws:     Exception
-      var:barrier1=new CyclicBarrier<CyclicBarrier>
-      var:barrier2=new CyclicBarrier<CyclicBarrier>
-      var:barrier3=new CyclicBarrier<CyclicBarrier>
-      var:exceptions=Collections.synchronizedList(new ArrayList<Exception>)
-      var:chatConnection=new ChatConnection<ChatConnection>
-      var:client2=new Thread<Thread>
+      Decl: barrier1=new CyclicBarrier(2)
+      Decl: barrier2=new CyclicBarrier(2)
+      Decl: barrier3=new CyclicBarrier(2)
+      Decl: exceptions=Collections.synchronizedList(new ArrayList())
+      Decl: chatConnection=new ChatConnection()
+      Decl: client2=new Thread(new ChatConnection())
       client2.start()
       chatConnection.run()
       cond-branch cond:exceptions.isEmpty()
@@ -119,17 +125,17 @@ class  ChatTest
         exceptions.get(0)
       false branch :
 
-    func  waitForJoin()  throws:     IOException
-      var:joined
+    func  waitForJoin(reader,s)  throws:     IOException
+      Decl: joined
       do         joined Assign readAvailableString(reader)
 while (joined NE null Land joined.contains("Welcome " Add s))
     func  performTestUsernameAndMessage()  throws:     Exception
-      var:barrier1=new CyclicBarrier<CyclicBarrier>
-      var:barrier2=new CyclicBarrier<CyclicBarrier>
-      var:barrier3=new CyclicBarrier<CyclicBarrier>
-      var:exceptions=Collections.synchronizedList(new ArrayList<Exception>)
-      var:chatConnection=new ChatConnection<ChatConnection>
-      var:client2=new Thread<Thread>
+      Decl: barrier1=new CyclicBarrier(2)
+      Decl: barrier2=new CyclicBarrier(2)
+      Decl: barrier3=new CyclicBarrier(2)
+      Decl: exceptions=Collections.synchronizedList(new ArrayList())
+      Decl: chatConnection=new ChatConnection()
+      Decl: client2=new Thread(new ChatConnection())
       client2.start()
       chatConnection.run()
       cond-branch cond:exceptions.isEmpty()
@@ -137,18 +143,19 @@ while (joined NE null Land joined.contains("Welcome " Add s))
         exceptions.get(0)
       false branch :
 
-    func  readAvailableString()  throws:     IOException
+    func  readAvailableString(reader)  throws:     IOException
       return readAvailableString(reader,false)
-    func  readAvailableString()  throws:     IOException
-      var:builder=new StringBuilder<StringBuilder>
-      var:bytes
+    func  readAvailableString(reader,now)  throws:     IOException
+      Decl: builder=new StringBuilder()
+      Decl: bytes
       cond-branch cond:now Land reader.ready()
       true branch :
         return null
       false branch :
 
-      do         var:buf=
-
+      do         Decl: buf=
+        bytes Assign reader.read(buf)
+        builder.append(buf,0,bytes)
 while bytes EQ 256
       return builder.toString()
   LocalClasses: 
@@ -161,13 +168,21 @@ while bytes EQ 256
         func  run()  throws: 
           Socket
           socket
-          new Socket<Socket>
-
+          new Socket("localhost",listeningPort)
+          BufferedReader
+          reader
+          new BufferedReader(new InputStreamReader(socket.getInputStream()))
+          Writer
+          writer
+          new FlushingWriter(new OutputStreamWriter(socket.getOutputStream()))
           socket.setTcpNoDelay(true)
           run(socket,reader,writer)
 
+          Exception
+          e
+          exception Assign e
 
-        func  run()  throws:     Exception
+        func  run(socket,reader,writer)  throws:     Exception
       LocalClasses: 
       LocalInterfaces: 
     class  FlushingWriter
@@ -175,18 +190,17 @@ while bytes EQ 256
         delegate
       Instance Initializer: 
       Constructors: 
-        constructor  FlushingWriter()  throws: 
+        constructor  FlushingWriter(delegate)  throws: 
           this.delegate Assign delegate
       Methods: 
-        func  write()  throws:     IOException
+        func  write(cbuf,off,len)  throws:     IOException
           delegate.write(cbuf,off,len)
         func  flush()  throws:     IOException
           delegate.flush()
         func  close()  throws:     IOException
           delegate.close()
-        func  write()  throws:     IOException
-          write
-          str
+        func  write(str)  throws:     IOException
+          super.write(str)
           flush()
       LocalClasses: 
       LocalInterfaces: 
diff --git a/src/MapleFE/test/others/ChatTest-2.java b/src/MapleFE/test/java/others/ChatTest-2.java
similarity index 100%
rename from src/MapleFE/test/others/ChatTest-2.java
rename to src/MapleFE/test/java/others/ChatTest-2.java
diff --git a/src/MapleFE/test/others/ChatTest-2.java.result b/src/MapleFE/test/java/others/ChatTest-2.java.result
similarity index 84%
rename from src/MapleFE/test/others/ChatTest-2.java.result
rename to src/MapleFE/test/java/others/ChatTest-2.java.result
index c0aa2ba566e42a8972817cc2e3032afd719d2436..18139019faa869c267dead7f165103cf6f5280af 100644
--- a/src/MapleFE/test/others/ChatTest-2.java.result
+++ b/src/MapleFE/test/java/others/ChatTest-2.java.result
@@ -8,7 +8,7 @@ class  ChatTest
   Constructors: 
   Methods: 
     func  performDontReceiveMessageInNameState()  throws: 
-      var:exceptions=new ArrayList<Exception>
+      Decl: exceptions=new ArrayList()
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/others/ChatTest-full.java b/src/MapleFE/test/java/others/ChatTest-full.java
similarity index 100%
rename from src/MapleFE/test/others/ChatTest-full.java
rename to src/MapleFE/test/java/others/ChatTest-full.java
diff --git a/src/MapleFE/test/others/ChatTest-full.java.result b/src/MapleFE/test/java/others/ChatTest-full.java.result
similarity index 56%
rename from src/MapleFE/test/others/ChatTest-full.java.result
rename to src/MapleFE/test/java/others/ChatTest-full.java.result
index 7117d4628595fdbaf3125491e34a7678146b49da..c8e02b22089dab33690a75a5a774d208074d1823 100644
--- a/src/MapleFE/test/others/ChatTest-full.java.result
+++ b/src/MapleFE/test/java/others/ChatTest-full.java.result
@@ -29,11 +29,11 @@ class  ChatTest
   Constructors: 
   Methods: 
     func  performTestConnectDisconnectConnect()  throws:     Exception
-      var:barrier1=new CyclicBarrier<CyclicBarrier>
-      var:barrier2=new CyclicBarrier<CyclicBarrier>
-      var:barrier3=new CyclicBarrier<CyclicBarrier>
-      var:exceptions=new ArrayList<Exception>
-    func  main()  throws:     Throwable
+      Decl: barrier1=new CyclicBarrier(2)
+      Decl: barrier2=new CyclicBarrier(2)
+      Decl: barrier3=new CyclicBarrier(2)
+      Decl: exceptions=new ArrayList()
+    func  main(args)  throws:     Throwable
       testStartStop()
       testPortOpen()
       testAsksForName()
@@ -42,57 +42,63 @@ class  ChatTest
       testUsernameAndMessage()
       testDontReceiveMessageInNameState()
     func  startServer()  throws:     IOException
-      var:server=new ChatServer<ChatServer>
-      var:address=(InetSocketAddress)server.getSocketAddress()
+      Decl: server=new ChatServer(0)
+      Decl: address=(InetSocketAddress)server.getSocketAddress()
       listeningPort Assign address.getPort()
       server.run()
       return server
     func  testStartStop()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       server.shutdown()
     func  testPortOpen()  throws:     Exception
-      var:server=startServer()
-      var:socket=new Socket<Socket>
+      Decl: server=startServer()
+      Decl: socket=new Socket("localhost",listeningPort)
       cond-branch cond:socket.isConnected()
       true branch :
-        new RuntimeException<RuntimeException>
+        new RuntimeException("Failed to connect to server: port not open")
       false branch :
 
 
       server.shutdown()
 
     func  testAsksForName()  throws:     Exception
-      var:server=startServer()
-      var:socket=new Socket<Socket>
+      Decl: server=startServer()
+      Decl: socket=new Socket("localhost",listeningPort)
+      Decl: reader=new BufferedReader(new InputStreamReader(socket.getInputStream()))
+      Decl: string=readAvailableString(reader)
+      cond-branch cond:string.equals("Name: ")
+      true branch :
+        new RuntimeException("Server doesn't send Name: ")
+      false branch :
 
 
       server.shutdown()
 
     func  testUseName()  throws:     Throwable
-      var:server=startServer()
+      Decl: server=startServer()
       performTestUseName()
 
       server.shutdown()
 
     func  testConnectDisconnectConnect()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       performTestConnectDisconnectConnect()
 
       server.shutdown()
 
     func  testUsernameAndMessage()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       performTestUsernameAndMessage()
 
       server.shutdown()
 
     func  testDontReceiveMessageInNameState()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       performDontReceiveMessageInNameState()
 
       server.shutdown()
 
-    func  assertEqual()  throws: 
+    func  assertEqual(exception,value,expected)  throws: 
       cond-branch cond:expected EQ value
       true branch :
         return 
@@ -100,23 +106,23 @@ class  ChatTest
 
       cond-branch cond:expected EQ null
       true branch :
-        exception.add(new RuntimeException<RuntimeException>)
+        exception.add(new RuntimeException("Expected null, but was: " Add value))
         return 
       false branch :
 
       cond-branch cond:expected.equals(value)
       true branch :
-        exception.add(new RuntimeException<RuntimeException>)
+        exception.add(new RuntimeException("Expected: " Add expected Add " but was: " Add value))
         return 
       false branch :
 
     func  performDontReceiveMessageInNameState()  throws:     Exception
-      var:barrier1=new CyclicBarrier<CyclicBarrier>
-      var:barrier2=new CyclicBarrier<CyclicBarrier>
-      var:barrier3=new CyclicBarrier<CyclicBarrier>
-      var:exceptions=Collections.synchronizedList(new ArrayList<Exception>)
-      var:chatConnection=new ChatConnection<ChatConnection>
-      var:client2=new Thread<Thread>
+      Decl: barrier1=new CyclicBarrier(2)
+      Decl: barrier2=new CyclicBarrier(2)
+      Decl: barrier3=new CyclicBarrier(2)
+      Decl: exceptions=Collections.synchronizedList(new ArrayList())
+      Decl: chatConnection=new ChatConnection()
+      Decl: client2=new Thread(new ChatConnection())
       client2.start()
       chatConnection.run()
       cond-branch cond:exceptions.isEmpty()
@@ -124,17 +130,17 @@ class  ChatTest
         exceptions.get(0)
       false branch :
 
-    func  waitForJoin()  throws:     IOException
-      var:joined
+    func  waitForJoin(reader,s)  throws:     IOException
+      Decl: joined
       do         joined Assign readAvailableString(reader)
 while (joined NE null Land joined.contains("Welcome " Add s))
     func  performTestUsernameAndMessage()  throws:     Exception
-      var:barrier1=new CyclicBarrier<CyclicBarrier>
-      var:barrier2=new CyclicBarrier<CyclicBarrier>
-      var:barrier3=new CyclicBarrier<CyclicBarrier>
-      var:exceptions=Collections.synchronizedList(new ArrayList<Exception>)
-      var:chatConnection=new ChatConnection<ChatConnection>
-      var:client2=new Thread<Thread>
+      Decl: barrier1=new CyclicBarrier(2)
+      Decl: barrier2=new CyclicBarrier(2)
+      Decl: barrier3=new CyclicBarrier(2)
+      Decl: exceptions=Collections.synchronizedList(new ArrayList())
+      Decl: chatConnection=new ChatConnection()
+      Decl: client2=new Thread(new ChatConnection())
       client2.start()
       chatConnection.run()
       cond-branch cond:exceptions.isEmpty()
@@ -143,13 +149,13 @@ while (joined NE null Land joined.contains("Welcome " Add s))
       false branch :
 
     func  performTestConnectDisconnectConnect()  throws:     Exception
-      var:barrier1=new CyclicBarrier<CyclicBarrier>
-      var:barrier2=new CyclicBarrier<CyclicBarrier>
-      var:barrier3=new CyclicBarrier<CyclicBarrier>
-      var:exceptions=new ArrayList<Exception>
-      var:chatConnection=new ChatConnection<ChatConnection>
-      var:chatConnection2=new ChatConnection<ChatConnection>
-      var:client2=new Thread<Thread>
+      Decl: barrier1=new CyclicBarrier(2)
+      Decl: barrier2=new CyclicBarrier(2)
+      Decl: barrier3=new CyclicBarrier(2)
+      Decl: exceptions=new ArrayList()
+      Decl: chatConnection=new ChatConnection()
+      Decl: chatConnection2=new ChatConnection()
+      Decl: client2=new Thread(new ChatConnection())
       client2.start()
       chatConnection.run()
       chatConnection2.run()
@@ -159,12 +165,12 @@ while (joined NE null Land joined.contains("Welcome " Add s))
       false branch :
 
     func  performTestUseName()  throws:     Exception
-      var:barrier1=new CyclicBarrier<CyclicBarrier>
-      var:barrier2=new CyclicBarrier<CyclicBarrier>
-      var:barrier3=new CyclicBarrier<CyclicBarrier>
-      var:exceptions=new ArrayList<Exception>
-      var:chatConnection=new ChatConnection<ChatConnection>
-      var:client2=new Thread<Thread>
+      Decl: barrier1=new CyclicBarrier(2)
+      Decl: barrier2=new CyclicBarrier(2)
+      Decl: barrier3=new CyclicBarrier(2)
+      Decl: exceptions=new ArrayList()
+      Decl: chatConnection=new ChatConnection()
+      Decl: client2=new Thread(new ChatConnection())
       client2.start()
       chatConnection.run()
       cond-branch cond:exceptions.isEmpty()
@@ -172,18 +178,19 @@ while (joined NE null Land joined.contains("Welcome " Add s))
         exceptions.get(0)
       false branch :
 
-    func  readAvailableString()  throws:     IOException
+    func  readAvailableString(reader)  throws:     IOException
       return readAvailableString(reader,false)
-    func  readAvailableString()  throws:     IOException
-      var:builder=new StringBuilder<StringBuilder>
-      var:bytes
+    func  readAvailableString(reader,now)  throws:     IOException
+      Decl: builder=new StringBuilder()
+      Decl: bytes
       cond-branch cond:now Land reader.ready()
       true branch :
         return null
       false branch :
 
-      do         var:buf=
-
+      do         Decl: buf=
+        bytes Assign reader.read(buf)
+        builder.append(buf,0,bytes)
 while bytes EQ 256
       return builder.toString()
   LocalClasses: 
@@ -196,13 +203,21 @@ while bytes EQ 256
         func  run()  throws: 
           Socket
           socket
-          new Socket<Socket>
-
+          new Socket("localhost",listeningPort)
+          BufferedReader
+          reader
+          new BufferedReader(new InputStreamReader(socket.getInputStream()))
+          Writer
+          writer
+          new FlushingWriter(new OutputStreamWriter(socket.getOutputStream()))
           socket.setTcpNoDelay(true)
           run(socket,reader,writer)
 
+          Exception
+          e
+          exception Assign e
 
-        func  run()  throws:     Exception
+        func  run(socket,reader,writer)  throws:     Exception
       LocalClasses: 
       LocalInterfaces: 
     class  FlushingWriter
@@ -210,18 +225,17 @@ while bytes EQ 256
         delegate
       Instance Initializer: 
       Constructors: 
-        constructor  FlushingWriter()  throws: 
+        constructor  FlushingWriter(delegate)  throws: 
           this.delegate Assign delegate
       Methods: 
-        func  write()  throws:     IOException
+        func  write(cbuf,off,len)  throws:     IOException
           delegate.write(cbuf,off,len)
         func  flush()  throws:     IOException
           delegate.flush()
         func  close()  throws:     IOException
           delegate.close()
-        func  write()  throws:     IOException
-          write
-          str
+        func  write(str)  throws:     IOException
+          super.write(str)
           flush()
       LocalClasses: 
       LocalInterfaces: 
diff --git a/src/MapleFE/test/others/ChatTest.java b/src/MapleFE/test/java/others/ChatTest.java
similarity index 100%
rename from src/MapleFE/test/others/ChatTest.java
rename to src/MapleFE/test/java/others/ChatTest.java
diff --git a/src/MapleFE/test/others/ChatTest.java.result b/src/MapleFE/test/java/others/ChatTest.java.result
similarity index 55%
rename from src/MapleFE/test/others/ChatTest.java.result
rename to src/MapleFE/test/java/others/ChatTest.java.result
index c1c0ddabe2350f16c28c717327eb8783de0da2d9..d1ced6a9bec630e4c5b309f54e27d0f8e28e9d8b 100644
--- a/src/MapleFE/test/others/ChatTest.java.result
+++ b/src/MapleFE/test/java/others/ChatTest.java.result
@@ -7,7 +7,7 @@ class  ChatTest
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  main()  throws:     Throwable
+    func  main(args)  throws:     Throwable
       testStartStop()
       testPortOpen()
       testAsksForName()
@@ -16,57 +16,63 @@ class  ChatTest
       testUsernameAndMessage()
       testDontReceiveMessageInNameState()
     func  startServer()  throws:     IOException
-      var:server=new ChatServer<ChatServer>
-      var:address=(InetSocketAddress)server.getSocketAddress()
+      Decl: server=new ChatServer(0)
+      Decl: address=(InetSocketAddress)server.getSocketAddress()
       listeningPort Assign address.getPort()
       server.run()
       return server
     func  testStartStop()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       server.shutdown()
     func  testPortOpen()  throws:     Exception
-      var:server=startServer()
-      var:socket=new Socket<Socket>
+      Decl: server=startServer()
+      Decl: socket=new Socket("localhost",listeningPort)
       cond-branch cond:socket.isConnected()
       true branch :
-        new RuntimeException<RuntimeException>
+        new RuntimeException("Failed to connect to server: port not open")
       false branch :
 
 
       server.shutdown()
 
     func  testAsksForName()  throws:     Exception
-      var:server=startServer()
-      var:socket=new Socket<Socket>
+      Decl: server=startServer()
+      Decl: socket=new Socket("localhost",listeningPort)
+      Decl: reader=new BufferedReader(new InputStreamReader(socket.getInputStream()))
+      Decl: string=readAvailableString(reader)
+      cond-branch cond:string.equals("Name: ")
+      true branch :
+        new RuntimeException("Server doesn't send Name: ")
+      false branch :
 
 
       server.shutdown()
 
     func  testUseName()  throws:     Throwable
-      var:server=startServer()
+      Decl: server=startServer()
       performTestUseName()
 
       server.shutdown()
 
     func  testConnectDisconnectConnect()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       performTestConnectDisconnectConnect()
 
       server.shutdown()
 
     func  testUsernameAndMessage()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       performTestUsernameAndMessage()
 
       server.shutdown()
 
     func  testDontReceiveMessageInNameState()  throws:     Exception
-      var:server=startServer()
+      Decl: server=startServer()
       performDontReceiveMessageInNameState()
 
       server.shutdown()
 
-    func  assertEqual()  throws: 
+    func  assertEqual(exception,value,expected)  throws: 
       cond-branch cond:expected EQ value
       true branch :
         return 
@@ -74,23 +80,23 @@ class  ChatTest
 
       cond-branch cond:expected EQ null
       true branch :
-        exception.add(new RuntimeException<RuntimeException>)
+        exception.add(new RuntimeException("Expected null, but was: " Add value))
         return 
       false branch :
 
       cond-branch cond:expected.equals(value)
       true branch :
-        exception.add(new RuntimeException<RuntimeException>)
+        exception.add(new RuntimeException("Expected: " Add expected Add " but was: " Add value))
         return 
       false branch :
 
     func  performDontReceiveMessageInNameState()  throws:     Exception
-      var:barrier1=new CyclicBarrier<CyclicBarrier>
-      var:barrier2=new CyclicBarrier<CyclicBarrier>
-      var:barrier3=new CyclicBarrier<CyclicBarrier>
-      var:exceptions=Collections.synchronizedList(new ArrayList<Exception>)
-      var:chatConnection=new ChatConnection<ChatConnection>
-      var:client2=new Thread<Thread>
+      Decl: barrier1=new CyclicBarrier(2)
+      Decl: barrier2=new CyclicBarrier(2)
+      Decl: barrier3=new CyclicBarrier(2)
+      Decl: exceptions=Collections.synchronizedList(new ArrayList())
+      Decl: chatConnection=new ChatConnection()
+      Decl: client2=new Thread(new ChatConnection())
       client2.start()
       chatConnection.run()
       cond-branch cond:exceptions.isEmpty()
@@ -98,17 +104,17 @@ class  ChatTest
         exceptions.get(0)
       false branch :
 
-    func  waitForJoin()  throws:     IOException
-      var:joined
+    func  waitForJoin(reader,s)  throws:     IOException
+      Decl: joined
       do         joined Assign readAvailableString(reader)
 while (joined NE null Land joined.contains("Welcome " Add s))
     func  performTestUsernameAndMessage()  throws:     Exception
-      var:barrier1=new CyclicBarrier<CyclicBarrier>
-      var:barrier2=new CyclicBarrier<CyclicBarrier>
-      var:barrier3=new CyclicBarrier<CyclicBarrier>
-      var:exceptions=Collections.synchronizedList(new ArrayList<Exception>)
-      var:chatConnection=new ChatConnection<ChatConnection>
-      var:client2=new Thread<Thread>
+      Decl: barrier1=new CyclicBarrier(2)
+      Decl: barrier2=new CyclicBarrier(2)
+      Decl: barrier3=new CyclicBarrier(2)
+      Decl: exceptions=Collections.synchronizedList(new ArrayList())
+      Decl: chatConnection=new ChatConnection()
+      Decl: client2=new Thread(new ChatConnection())
       client2.start()
       chatConnection.run()
       cond-branch cond:exceptions.isEmpty()
diff --git a/src/MapleFE/test/java2mpl/generate-result.sh b/src/MapleFE/test/java/others/generate-result.sh
similarity index 92%
rename from src/MapleFE/test/java2mpl/generate-result.sh
rename to src/MapleFE/test/java/others/generate-result.sh
index bbd3acd878bd41d3a31fc5123972e954d7c9fcd0..08b3acc3b58dc1585fb15888064b004629e72007 100755
--- a/src/MapleFE/test/java2mpl/generate-result.sh
+++ b/src/MapleFE/test/java/others/generate-result.sh
@@ -17,5 +17,5 @@ FILES=$(pwd)/*.java
 for f in $FILES
 do
   echo "Generating result for $f ..."
-  ../../output/java/java2mpl $f > $f.result
+  ../../../output/java/java/java2mpl $f > $f.result
 done
diff --git a/src/MapleFE/test/others/plotter.java b/src/MapleFE/test/java/others/plotter.java
similarity index 100%
rename from src/MapleFE/test/others/plotter.java
rename to src/MapleFE/test/java/others/plotter.java
diff --git a/src/MapleFE/test/others/plotter.java.result b/src/MapleFE/test/java/others/plotter.java.result
similarity index 67%
rename from src/MapleFE/test/others/plotter.java.result
rename to src/MapleFE/test/java/others/plotter.java.result
index 78be976165d420319bc69a4617fcea334bcd11cf..c266a3188f1edb757c066e00dfa72b56d962494a 100644
--- a/src/MapleFE/test/others/plotter.java.result
+++ b/src/MapleFE/test/java/others/plotter.java.result
@@ -37,15 +37,23 @@ class  Plotter
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  main()  throws:     IOException
-      var:path=Paths.get("footprint.csv")
+    func  main(args)  throws:     IOException
+      Decl: path=Paths.get("footprint.csv")
       BufferedWriter
       stream
       Files.newBufferedWriter(path,StandardOpenOption.CREATE)
-      stream.write("bits,bool,bitset
-")
+      stream.write("bits,bool,bitset\n")
       for ( )
         System.out.println("Number of bits => " Add i)
+        Decl: ba=
+        Decl: bitSet=new BitSet(i)
+        Decl: baSize=ClassLayout.parseInstance(ba).instanceSize()
+        Decl: bitSetSize=GraphLayout.parseInstance(bitSet).totalSize()
+        stream.write((i Add "," Add baSize Add "," Add bitSetSize Add "\n"))
+        cond-branch cond:i Mod 10000 EQ 0
+        true branch :
+          stream.flush()
+        false branch :
 
 
 
diff --git a/src/MapleFE/test/others/receiver.java b/src/MapleFE/test/java/others/receiver.java
similarity index 84%
rename from src/MapleFE/test/others/receiver.java
rename to src/MapleFE/test/java/others/receiver.java
index 7bd8f8a09b64773ccf5d519d6532b88a320d74ab..280035847267b28da7e4d6ebe8c84d629ff79504 100644
--- a/src/MapleFE/test/others/receiver.java
+++ b/src/MapleFE/test/java/others/receiver.java
@@ -19,11 +19,13 @@ class Outer {
   Outer() {}
   void m(Outer this) {}
   class Inner {
-    Inner(Outer Outer.this) {}
+    //Inner(Outer Outer.this) {}
+    Inner(Outer Outer) {}
     void m(Inner this) {}
     class B {
-      B(Outer.Inner Inner.this) {}
-      void m(Outer.Inner.B this) {}
+      //B(Outer.Inner Inner.this) {}
+      B(Inner Inner) {}
+      void m(Outer this) {}
     }
   }
 }
diff --git a/src/MapleFE/test/others/receiver.java.result b/src/MapleFE/test/java/others/receiver.java.result
similarity index 71%
rename from src/MapleFE/test/others/receiver.java.result
rename to src/MapleFE/test/java/others/receiver.java.result
index e3f63c08a412c4f8164eeb5573606acca0063cce..adb36777b5f0d0f38dddcd088e3376e437b01c49 100644
--- a/src/MapleFE/test/others/receiver.java.result
+++ b/src/MapleFE/test/java/others/receiver.java.result
@@ -1,4 +1,4 @@
-Matched 65 tokens.
+Matched 55 tokens.
 ============= Module ===========
 == Sub Tree ==
 class  Outer
@@ -8,25 +8,25 @@ class  Outer
   Constructors: 
     constructor  Outer()  throws: 
   Methods: 
-    func  m()  throws: 
+    func  m(Outer)  throws: 
   LocalClasses: 
     class  Inner
       Fields: 
 
       Instance Initializer: 
       Constructors: 
-        constructor  Inner()  throws: 
+        constructor  Inner(Outer)  throws: 
       Methods: 
-        func  m()  throws: 
+        func  m(Inner)  throws: 
       LocalClasses: 
         class  B
           Fields: 
 
           Instance Initializer: 
           Constructors: 
-            constructor  B()  throws: 
+            constructor  B(Inner)  throws: 
           Methods: 
-            func  m()  throws: 
+            func  m(Outer)  throws: 
           LocalClasses: 
           LocalInterfaces: 
       LocalInterfaces: 
diff --git a/src/MapleFE/test/others/sizing.java b/src/MapleFE/test/java/others/sizing.java
similarity index 100%
rename from src/MapleFE/test/others/sizing.java
rename to src/MapleFE/test/java/others/sizing.java
diff --git a/src/MapleFE/test/others/sizing.java.result b/src/MapleFE/test/java/others/sizing.java.result
similarity index 66%
rename from src/MapleFE/test/others/sizing.java.result
rename to src/MapleFE/test/java/others/sizing.java.result
index 5a9bf938c5873e9237d34bb5e7a59e0ba0d8121f..950e89f28d0fc42010b2bf592287eb68dab6f054 100644
--- a/src/MapleFE/test/others/sizing.java.result
+++ b/src/MapleFE/test/java/others/sizing.java.result
@@ -19,11 +19,11 @@ class  Sizing
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  main()  throws: 
-      var:ba=
-      System.out.println(ClassLayout.parseInstance(ba),toPrintable)
-      var:bitSet=new BitSet<BitSet>
-      System.out.println(GraphLayout.parseInstance(bitSet),toPrintable)
+    func  main(args)  throws: 
+      Decl: ba=
+      System.out.println(ClassLayout.parseInstance(ba).toPrintable())
+      Decl: bitSet=new BitSet(10000)
+      System.out.println(GraphLayout.parseInstance(bitSet).toPrintable())
   LocalClasses: 
   LocalInterfaces: 
 
diff --git a/src/MapleFE/test/java/syntaxonly/generate-result.sh b/src/MapleFE/test/java/syntaxonly/generate-result.sh
new file mode 100755
index 0000000000000000000000000000000000000000..08b3acc3b58dc1585fb15888064b004629e72007
--- /dev/null
+++ b/src/MapleFE/test/java/syntaxonly/generate-result.sh
@@ -0,0 +1,21 @@
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
+#!/bin/bash
+FILES=$(pwd)/*.java
+for f in $FILES
+do
+  echo "Generating result for $f ..."
+  ../../../output/java/java/java2mpl $f > $f.result
+done
diff --git a/src/MapleFE/test/syntaxonly/var-scope-1.java b/src/MapleFE/test/java/syntaxonly/var-scope-1.java
similarity index 100%
rename from src/MapleFE/test/syntaxonly/var-scope-1.java
rename to src/MapleFE/test/java/syntaxonly/var-scope-1.java
diff --git a/src/MapleFE/test/syntaxonly/var-scope-1.java.result b/src/MapleFE/test/java/syntaxonly/var-scope-1.java.result
similarity index 55%
rename from src/MapleFE/test/syntaxonly/var-scope-1.java.result
rename to src/MapleFE/test/java/syntaxonly/var-scope-1.java.result
index e2618617a5bfc8b1f83178266e81bd1a8bd3a168..5ca73a8308698c869f6edb6f3cd94e27b28a511b 100644
--- a/src/MapleFE/test/syntaxonly/var-scope-1.java.result
+++ b/src/MapleFE/test/java/syntaxonly/var-scope-1.java.result
@@ -7,12 +7,20 @@ class  A
   Instance Initializer: 
   Constructors: 
   Methods: 
-    func  foo()  throws: 
+    func  foo(x)  throws: 
       a Assign x
       cond-branch cond:a EQ 2
       true branch :
-        var:a=2
+        Decl: a=2
+        x Assign a Add this.a Add 2
+        a Assign x Add 2
+        cond-branch cond:a EQ 4
+        true branch :
+          Decl: a=4
+          x Assign a Add this.a Add 4
+        false branch :
 
+        x Assign a Add 5
       false branch :
 
       a Assign x Add this.a Add a
diff --git a/src/MapleFE/test/java2mpl_runtests.pl b/src/MapleFE/test/java2mpl_runtests.pl
deleted file mode 100755
index 6a7b7af8b263d6ebd8d8df21b8bc0d015b1faa0e..0000000000000000000000000000000000000000
--- a/src/MapleFE/test/java2mpl_runtests.pl
+++ /dev/null
@@ -1,193 +0,0 @@
-#!/usr/bin/perl -w
-use Cwd;
-use warnings;
-
-my $pwd = getcwd;
-
-#print "here1 current pwd $pwd\n";
-
-if ((!(defined $ARGV[0])) || ($ARGV[0] ne "java2mpl")) {
-  print "------------------------------------------------\n";
-  print "usage: java2mpl_runtests.pl java2mpl\n";
-  print "------------------------------------------------\n";
-  exit;
-}
-
-$dirname = "./$ARGV[0]";
-
-my $outdir = "$pwd/java2mpl_output";
-my $diffdir = "$pwd/java2mpl_diff";
-my $notexistsdir = "$pwd/java2mpl_notexists";
-if(!(-e "$outdir")) {
-  system("mkdir -p $outdir");
-}
-
-my @failed_java2mpl_file;
-my @successed_file;
-
-my $count = 0;
-my $countJAVA2MPL = 0; 
-
-
-chdir $dirname;
-$dirname = "./";
-opendir (DIR, $dirname ) || die "Error in opening dir $dirname\n";
-
-#print "here2 dirname $dirname\n";
-
-print("\n====================== run tests: $ARGV[0] =====================\n");
-
-while( ($srcdir = readdir(DIR))){
-  if(-d $srcdir and $srcdir ne ".." and $srcdir ne "output" and $srcdir ne "temp") {
-    my $predir = getcwd;
-    chdir $srcdir;
-    my @javafiles;
-    @javafiles = <*.java>;
-
-#print "here3 source directory $srcdir\n";
-#print "here4 predir $predir\n";
-
-    my @allfiles = (@javafiles);
-    foreach $fullname (@allfiles) {
-      $count ++;
-      (my $file = $fullname) =~ s/\.[^.]+$//;
-      if(defined $ARGV[1]) {
-        print "\n$file";
-      } else {
-        print ".";
-      }
-      if ($count % 50 == 0) {
-        print " $count\n";
-      }
-      my $flag = 0;
-      my $src_file = $fullname;
-      my $java2mpl_oresult_file = $file.'.java.result';
-      my $java2mpl_log_file = $file.'.java2mpl.log';
-      my $java2mpl_result_file = $file.'.java.java2mpl.result';
-      my $java2mpl_err_file = $file.'.err';
-      my $java2mpl_diff_file = $file.'.java.diff';
-
-      if(!(-e "$outdir")) {
-        system("mkdir -p $outdir");
-      }
-
-#print "here5 outdir $outdir\n";
-#print "here6 src_file $src_file\n";
-
-      system("cp $src_file $outdir/$src_file");
-      $res = system("cd $pwd/..; $BUILDDIR/java/java2mpl $outdir/$src_file > $outdir/$java2mpl_result_file");
-      if ($res > 0) {
-        print "\ngdb --args $BUILDDIR/java/java2mpl $outdir/$src_file\n";
-        print " ==java2mpl===> $file\n\n";
-        $countJAVA2MPL ++;
-        push(@failed_java2mpl_file, $file);
-        $flag ++;
-        next;
-      } 
-
-#print "here7 diff src_file $pwd/java2mpl/$java2mpl_oresult_file\n";
-#print "here8 diff java2mpl_result_file $java2mpl_result_file\n";
-
-      if (!(-e $java2mpl_oresult_file)) {
-        if(!(-e "$notexistsdir")) {
-          system("mkdir -p $notexistsdir");
-        }
-
-#print "here9 $java2mpl_oresult_file NOT exists\n";
-        print "Original file $java2mpl_oresult_file does NOT exists!\n";
-        system("touch $notexistsdir/$java2mpl_oresult_file");
-        $countJAVA2MPL ++;  
-        push(@failed_java2mpl_file, $file);
-      }
-      else {
-#print "here10 java2mpl_result_file $outdir/$java2mpl_result_file\n";
-         if ((!(-e "$outdir/$java2mpl_result_file")) || (-z "$outdir/$java2mpl_result_file")) {
-            if(!(-e "$notexistsdir")) {
-               system("mkdir -p $notexistsdir");
-            }
- 
-#print "here11 $outdir/$java2mpl_result_file NOT exists\n";
-           print "$java2mpl_result_file either empty or not exists!\n";
-           system("touch $notexistsdir/$java2mpl_result_file");
-           $countJAVA2MPL ++;
-           push(@failed_java2mpl_file, $file);
-        } else {
-           $res2 = system("diff $pwd/java2mpl/$java2mpl_oresult_file $outdir/$java2mpl_result_file");
-           if ($res2 > 0) {
-             if(!(-e "$diffdir")) {
-                system("mkdir -p $diffdir");
-             }
-
-#print "here12 $java2mpl_diff_file  Different!!!\n";
-             print "$java2mpl_oresult_file $java2mpl_result_file are different!!!\n";
-             system("touch $diffdir/$java2mpl_diff_file");
-             $countJAVA2MPL ++;
-             push(@failed_java2mpl_file, $file);
-           } else {
-             push(@successed_file, $file);
-           }
-
-         } 
-      }
-
-#      if($flag eq 0){
-#        push(@successed_file, $file);
-#      }
-      next;
-
-      if ($flag eq -1) {
-        push(@successed_file, $file);
-        system("rm -f $outdir/$src_file");
-        system("rm -f $outdir/$java2mpl_log_file");
-        system("rm -f $outdir/$java2mpl_oresult_file");
-        system("rm -f $outdir/$java2mpl_result_file");
-        system("rm -f $outdir/$java2mpl_err_file");
-        system("rm -f $diffdir/$java2mpl_diff_file");
-        system("rm -f $notexists/$java2mpl_oresult_file");
-        system("rm -f $notexists/$java2mpl_result_file");
-        next;
-      }
-    }
-    chdir $predir;
-  }
-}
-
-print " $count\n";
-closedir(DIR);
-chdir $pwd;
-
-my $countFailed = $countJAVA2MPL ;
-my $countPassed = $count - $countFailed;
-
-my $reportFile = 'java2mpl_report.txt';
-open(my $fh, '>', $reportFile) or die "Could not open file '$reportFile' $!";
-print $fh "$ARGV[0] report: \n";
-
-if ($countFailed eq 0) {
-  print("\n all $count tests passed\n");
-  print("======================================================\n");
-  print $fh "all $count tests passed\n";
-  close $fh;
-} else {
-  print "\n\n=====Scan Result=====\n\n";
-  print "Total Test Cases: $count\n";
-  if(scalar(@successed_file) > 0) {
-    print "\n=========================\npassed $countPassed tests:\n\n";
-    foreach $passed (@successed_file) {
-      print $passed."\n";
-    }
-    print $fh "$countPassed testcases passed\n";
-  }
-  print "\n=========================\nfailed $countFailed tests:\n\n";
-  if(scalar(@failed_java2mpl_file) > 0){
-    print("=== failed java2mpl: $countJAVA2MPL tests\n");
-    print $fh "$countJAVA2MPL testcases failed\n";
-
-    foreach $failed (@failed_java2mpl_file) {
-      print $failed."\n";
-    }
-    print "\n";
-  }
-  print "=========================\n";
-  close $fh;
-}
diff --git a/src/MapleFE/test/msts_test.sh b/src/MapleFE/test/msts_test.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b502845fdc33c1ba5df9e3d406fbdec49c2b0686
--- /dev/null
+++ b/src/MapleFE/test/msts_test.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+[ -n "$MAPLEFE_ROOT" ] || { echo MAPLE_ROOT not set. Please source envsetup.sh.; exit 1; }
+cd ${MAPLEFE_ROOT}/test
+
+if [ ! -d ${MAPLEFE_ROOT}/test/TypeScript ]; then
+  git clone -b release-1.8 https://github.com/microsoft/TypeScript.git
+fi
+
+if [ -f ${MAPLEFE_ROOT}/test/msts_testlist ]; then
+  cat msts_testlist | xargs -n1 -I % sh -c '{ rm -f typescript/ms_tests/%; cp -f TypeScript/tests/cases/compiler/% typescript/ms_tests/; cp -f TypeScript/LICENSE.txt typescript/ms_tests/; }'
+fi
+
+# setup files only. do not run test
+if [ "x$1" = "xsetup" ]; then
+  exit 0
+fi
+
+# export is for sh -c in xargs
+export TS2AST=$MAPLEFE_ROOT/output/typescript/bin/ts2ast
+export PASS_LIST=msts_passed.txt
+FAIL_LIST=msts_failed.txt
+MSTEST_DIR=$MAPLEFE_ROOT/test/TypeScript/tests/cases/compiler
+N_JOBS=16
+
+[ -n "$MAPLE_ROOT" ] || { echo MAPLE_ROOT not set. Please source envsetup.sh.; exit 1; }
+if [ ! -d $MSTEST_DIR ]; then
+  echo "$MSTEST_DIR" does not exist. Please git clone https://github.com/microsoft/TypeScript.git under "$MAPLEFE_ROOT/test"
+  exit 1
+fi
+
+cd $MAPLEFE_ROOT/test
+rm -f $PASS_LIST
+find $MSTEST_DIR -name "*.ts" | xargs -n1 -P$N_JOBS -I % sh -c '{ $TS2AST %; exitcode=$?; if [ $exitcode -eq 0 ]; then basename % >> $PASS_LIST; fi }'
+cd $MSTEST_DIR
+ls *.ts | grep -v -x -f $MAPLEFE_ROOT/test/$PASS_LIST /dev/stdin  > $MAPLEFE_ROOT/test/$FAIL_LIST
+cd -
+sort -o $PASS_LIST $PASS_LIST
+echo
+echo "Microsoft Typescript compiler testcases: Passed: " `wc -l < $PASS_LIST` " Failed: " `wc -l < $FAIL_LIST`
+echo "List of passed and failed cases are in $PASS_LIST and $FAIL_LIST"
+echo
+echo "Note: Add testcase name from above lists into mstest_testlist if"
+echo "      you want it included in make test"
+echo
+cd - > /dev/null
diff --git a/src/MapleFE/test/msts_testlist b/src/MapleFE/test/msts_testlist
new file mode 100644
index 0000000000000000000000000000000000000000..5444b5c452e1b8e2c7a778b0cda3c34ff9efeb49
--- /dev/null
+++ b/src/MapleFE/test/msts_testlist
@@ -0,0 +1,5 @@
+checkInterfaceBases.ts
+getsetReturnTypes.ts
+reExportGlobalDeclaration3.ts
+library_ObjectPrototypeProperties.ts
+
diff --git a/src/MapleFE/test/new_runtests.pl b/src/MapleFE/test/new_runtests.pl
new file mode 100755
index 0000000000000000000000000000000000000000..06479ff92804476597d5731effb295d0039554d3
--- /dev/null
+++ b/src/MapleFE/test/new_runtests.pl
@@ -0,0 +1,228 @@
+#!/usr/bin/perl
+
+use Cwd;
+use warnings;
+use experimental 'smartmatch';
+use File::Find;
+use File::Basename;
+
+use File::Find qw(find);
+
+if(!(defined $ARGV[0])) {
+  print "------------------------------------------------\n";
+  print "usage: runtests.pl [ java | java/subdirectory | typescript | typescript/subdirectory ]\n";
+  print "------------------------------------------------\n";
+  exit;
+}
+
+my $lang = $ARGV[0];
+my $pwd = getcwd;
+my $currdir = "$pwd";
+
+my @failed_file;
+my @failed_file1;
+my @failed_file2;
+my @successed_file;
+
+my $count = 0;
+my $counttotal = 0;
+my $countfailedcases = 0;
+my $countfailedcases1 = 0;
+my $countfailedcases2 = 0;
+my $countsub = 0;
+
+my $pinput = '';
+my $cmnd = '';
+my $outroot = '';
+print "Running $lang\n";
+if ($lang =~ /\Qjava\E/) {
+  $pinput = "java";
+  $cmnd = "../output/java/bin/java2ast";
+  $cmnd1 = "../output/java/bin/ast2mpl";
+  $flag = "";
+  $outroot = "$currdir/../output/$pinput/test";
+} elsif ($lang =~ /\Qtypescript\E/) {
+  $pinput = "ts";
+  $cmnd = "../output/typescript/bin/ts2ast";
+  $cmnd1 = "../output/typescript/bin/ast2cpp";
+  $flag = "--no-imported";
+  $outroot = "$currdir/../output/typescript/test";
+} else {
+  print "$lang is an invalid option\n";
+  exit;
+}
+
+my $testdir = $lang;
+# get specified directory to test if other than $lang
+if(defined $ARGV[1]) {
+  $testdir = $ARGV[1];
+}
+
+system("rm -Rf $outroot/report.txt $outroot/diff $outroot/notexists");
+
+if(!(-e "$outroot")) {
+  system("mkdir -p $outroot");
+}
+
+opendir (my $DIR, $testdir) || die "Error in opening $testdir directory\n";
+
+sub listdirs {
+  my @dirs = @_;
+  my @files;
+
+  if ( $pinput ~~ [qw( java ts )] ) {
+    find({ wanted => sub { push @files, glob "\"$_/{*.$pinput,*.$pinput.result}\"" } , no_chdir => 1 }, @dirs);
+  } else {
+    find({ wanted => sub { push @files, $_ } , no_chdir => 1 }, @dirs);
+  }
+
+  return @files;
+}
+
+my @paths = listdirs($testdir) ;
+
+foreach my $file (@paths) {
+  my ($filename) = ( $file =~ /([^\\\/]+)$/s ) ;
+  my ($pathname) = dirname($file);
+
+  if ( $pinput ~~ [qw( java ts )] ) {
+    system("rm -rf $outroot/$file; cp -rp --parents $file $outroot/");
+
+    if ( ($filename =~ (/(.+)[.]java$/)) || ($filename =~ (/(.+)[.]ts$/)) ) {
+
+      my $origresult = "$pwd/$file.result";
+      my $outresult = $file.'.result.'.$pinput;
+      my $diff_file = $file.'.result.diff'; 
+      my $notexistsdir = "$outroot/notexists";
+      my $diffdir = "$outroot/diff";
+
+      $count ++;
+      print ".";
+      if ($count % 50 == 0) {
+        print " $count\n";
+      }
+
+      #my $res = system("$pwd/$cmnd $outroot/$file > $outroot/$outresult");
+      #my $res = system('$pwd/$cmnd $outroot/$file; $pwd/$cmnd1 $outroot/$file.ast > $outroot/$outresult');
+      my $res = system("$pwd/$cmnd $outroot/$file > $outroot/$outresult");
+      #print "$pwd/$cmnd $outroot/$file > $outroot/$outresult";
+
+      if ($res > 0) {
+        print " ==$pinput===> $file\n";
+        print "$pwd/$cmnd $outroot/$file\n";
+        $countfailedcases ++;
+        push(@failed_file, $pinput.":  ".$file);
+        #print "---------------------------\n";
+        next;
+      } else {
+        my $res1 = system("$cmnd1 $outroot/$file.ast $flag > $outroot/$outresult.1");
+        #print "$cmnd1 $outroot/$file.ast $flag > $outroot/$outresult.1";
+
+        if ($res1 > 0) {
+          print " ==$pinput===> $file\n";
+          print "$cmnd1 $outroot/$file.ast\n";
+          $countfailedcases1 ++;
+          push(@failed_file1, $pinput.":  ".$file);
+          #print "---------------------------\n";
+          next;
+        }
+      }
+
+      if (!(-e $origresult) ) {
+        if(!(-e "$notexistsdir")) {
+          system("mkdir -p $notexistsdir");
+        }
+        print "\nOriginal file $origresult does NOT exists!\n";
+        system("mkdir -p $notexistsdir/$file && touch $notexistsdir/$file");
+        $countfailedcases2 ++;
+        push(@failed_file2, $pinput.": result file not exists: ".$origresult);
+      } else {
+        if ((!(-e "$outroot/$outresult")) || (-z "$outroot/$outresult")) {
+          if(!(-e "$notexistsdir")) {
+            system("mkdir -p $notexistsdir");
+          }
+
+          print "\n$outroot/$outresult either empty or not exists!\n";
+          system("mkdir -p $notexistsdir/$file && touch $notexistsdir/$file");
+          $countfailedcases2 ++;
+          push(@failed_file2, $pinput.": file empty or not exists: ".$file);
+        } else {
+          my $res2 = system("diff $origresult $outroot/$outresult");
+          if ($res2 > 0) {
+            if(!(-e "$diffdir")) {
+              system("mkdir -p $diffdir");
+            }
+
+            print "\n$origresult $outroot/$outresult are different!!!\n";
+            print "\ncp $outroot/$outresult $origresult\n";
+            system("mkdir -p $diffdir/$diff_file && touch $diffdir/$diff_file");
+            $countfailedcases2 ++;
+            push(@failed_file2, $pinput.": result files diff: ".$origresult);
+          } else {
+            push(@successed_file, $file." ".$pinput);
+          }
+        }
+      }
+    } # if #2
+
+  }  # if #1
+
+}
+
+my $countFailed = $countfailedcases + $countfailedcases1 + $countfailedcases2;
+my $countPassed = $count - $countFailed;
+
+my $reportFile = "$outroot/report.txt";
+open(my $fh, '>', $reportFile) or die "Could not open file '$reportFile' $!";
+
+if ($countFailed eq 0) {
+  print "\n\n=====Scan Result=====\n\n";
+  print("\n all $count tests passed\n");
+  print("======================================================\n");
+  print $fh "all $count tests passed\n";
+  close $fh;
+} else {
+  print "\n\n=====Scan Result=====\n\n";
+  print "Total Test Cases: $count\n";
+  if(scalar(@successed_file) > 0) {
+    print "\n=========================\npassed $countPassed tests:\n\n";
+    #foreach $passed (@successed_file) {
+    #  print $passed."\n";
+    #}
+    #print $fh "$countPassed testcases passed\n";
+  }
+  print "\n=========================\nfailed $countFailed tests:\n\n";
+  if(scalar(@failed_file) > 0){
+    print("=== failed : $countfailedcases tests - $cmnd\n");
+    print $fh "$countfailedcases testcases failed\n";
+
+    foreach $failed (@failed_file) {
+      print $failed."\n";
+      print $fh $failed."\n";
+    }
+    print "\n";
+  }
+  if(scalar(@failed_file1) > 0){
+    print("=== failed : $countfailedcases1 tests - $cmnd1\n");
+    print $fh "$countfailedcases1 testcases failed\n";
+
+    foreach $failed (@failed_file1) {
+      print $failed."\n";
+      print $fh $failed."\n";
+    }
+    print "\n";
+  }
+  if(scalar(@failed_file2) > 0){
+    print("=== failed : $countfailedcases2 tests - result\n");
+    print $fh "$countfailedcases2 testcases failed\n";
+
+    foreach $failed (@failed_file2) {
+      print $failed."\n";
+      print $fh $failed."\n";
+    }
+    print "\n";
+  }
+  print "=========================\n";
+  close $fh;
+}
+
diff --git a/src/MapleFE/test/openjdk/AbstractStringBuilder-simplified.java.result b/src/MapleFE/test/openjdk/AbstractStringBuilder-simplified.java.result
deleted file mode 100644
index e91770236ddee7cd6da5c826ea9abf44bc7271ac..0000000000000000000000000000000000000000
--- a/src/MapleFE/test/openjdk/AbstractStringBuilder-simplified.java.result
+++ /dev/null
@@ -1,43 +0,0 @@
-Matched 329 tokens.
-============= Module ===========
-== Sub Tree ==
-class  AbstractStringBuilder
-  Fields: 
-    value    count    MAX_ARRAY_SIZE=Integer.MAX_VALUE Sub 8
-  Instance Initializer: 
-  Constructors: 
-    constructor  AbstractStringBuilder()  throws: 
-    constructor  AbstractStringBuilder()  throws: 
-  Methods: 
-    func  length()  throws: 
-    func  capacity()  throws: 
-    func  ensureCapacity()  throws: 
-    func  ensureCapacityInternal()  throws: 
-    func  newCapacity()  throws: 
-    func  hugeCapacity()  throws: 
-    func  trimToSize()  throws: 
-    func  setLength()  throws: 
-    func  charAt()  throws: 
-    func  codePointAt()  throws: 
-    func  codePointBefore()  throws: 
-    func  codePointCount()  throws: 
-    func  offsetByCodePoints()  throws: 
-    func  getChars()  throws: 
-    func  setCharAt()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  appendNull()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-    func  append()  throws: 
-  LocalClasses: 
-  LocalInterfaces: 
-
diff --git a/src/MapleFE/test/openjdk/Character-1.java.result b/src/MapleFE/test/openjdk/Character-1.java.result
deleted file mode 100644
index f13200748e4839d4e7b77a073301d734d18c6f81..0000000000000000000000000000000000000000
--- a/src/MapleFE/test/openjdk/Character-1.java.result
+++ /dev/null
@@ -1,95 +0,0 @@
-Matched 5 tokens.
-Matched 14 tokens.
-Matched 21 tokens.
-Matched 28 tokens.
-Matched 35 tokens.
-Matched 42 tokens.
-Matched 5259 tokens.
-============= Module ===========
-== Sub Tree ==
-package java.lang
-== Sub Tree ==
-import dalvik.annotation.optimization.FastNative
-== Sub Tree ==
-import java.util.Arrays
-== Sub Tree ==
-import java.util.HashMap
-== Sub Tree ==
-import java.util.Locale
-== Sub Tree ==
-import java.util.Map
-== Sub Tree ==
-class  Character
-  Fields: 
-    MIN_RADIX=2    MAX_RADIX=36    MIN_VALUE=0    MAX_VALUE=65535    TYPE=()    UNASSIGNED=0    UPPERCASE_LETTER=1    LOWERCASE_LETTER=2    TITLECASE_LETTER=3    MODIFIER_LETTER=4    OTHER_LETTER=5    NON_SPACING_MARK=6    ENCLOSING_MARK=7    COMBINING_SPACING_MARK=8    DECIMAL_DIGIT_NUMBER=9    LETTER_NUMBER=10    OTHER_NUMBER=11    SPACE_SEPARATOR=12    LINE_SEPARATOR=13    PARAGRAPH_SEPARATOR=14    CONTROL=15    FORMAT=16    PRIVATE_USE=18    SURROGATE=19    DASH_PUNCTUATION=20    START_PUNCTUATION=21    END_PUNCTUATION=22    CONNECTOR_PUNCTUATION=23    OTHER_PUNCTUATION=24    MATH_SYMBOL=25    CURRENCY_SYMBOL=26    MODIFIER_SYMBOL=27    OTHER_SYMBOL=28    INITIAL_QUOTE_PUNCTUATION=29    FINAL_QUOTE_PUNCTUATION=30    ERROR=-1    DIRECTIONALITY_UNDEFINED=Sub
-  1    DIRECTIONALITY_LEFT_TO_RIGHT=0    DIRECTIONALITY_RIGHT_TO_LEFT=1    DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC=2    DIRECTIONALITY_EUROPEAN_NUMBER=3    DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR=4    DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR=5    DIRECTIONALITY_ARABIC_NUMBER=6    DIRECTIONALITY_COMMON_NUMBER_SEPARATOR=7    DIRECTIONALITY_NONSPACING_MARK=8    DIRECTIONALITY_BOUNDARY_NEUTRAL=9    DIRECTIONALITY_PARAGRAPH_SEPARATOR=10    DIRECTIONALITY_SEGMENT_SEPARATOR=11    DIRECTIONALITY_WHITESPACE=12    DIRECTIONALITY_OTHER_NEUTRALS=13    DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING=14    DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE=15    DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING=16    DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE=17    DIRECTIONALITY_POP_DIRECTIONAL_FORMAT=18    MIN_HIGH_SURROGATE=55296    MAX_HIGH_SURROGATE=56319    MIN_LOW_SURROGATE=56320    MAX_LOW_SURROGATE=57343    MIN_SURROGATE=MIN_HIGH_SURROGATE    MAX_SURROGATE=MAX_LOW_SURROGATE    MIN_SUPPLEMENTARY_CODE_POINT=65536    MIN_CODE_POINT=0    MAX_CODE_POINT=1114111    DIRECTIONALITY=
-  Instance Initializer: 
-  Constructors: 
-  Methods: 
-  LocalClasses: 
-    class  Subset
-      Fields: 
-        name
-      Instance Initializer: 
-      Constructors: 
-        constructor  Subset()  throws: 
-          cond-branch cond:name EQ null
-          true branch :
-            new NullPointerException<NullPointerException>
-          false branch :
-
-          this.name Assign name
-      Methods: 
-        func  equals()  throws: 
-          return (this EQ obj)
-        func  hashCode()  throws: 
-          return hashCode
-        func  toString()  throws: 
-          return name
-      LocalClasses: 
-      LocalInterfaces: 
-    class  UnicodeBlock
-      Fields: 
-        map=new HashMap        BASIC_LATIN=new UnicodeBlock<UnicodeBlock>        LATIN_1_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_B=new UnicodeBlock<UnicodeBlock>        IPA_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        SPACING_MODIFIER_LETTERS=new UnicodeBlock<UnicodeBlock>        COMBINING_DIACRITICAL_MARKS=new UnicodeBlock<UnicodeBlock>        GREEK=new UnicodeBlock<UnicodeBlock>        CYRILLIC=new UnicodeBlock<UnicodeBlock>        ARMENIAN=new UnicodeBlock<UnicodeBlock>        HEBREW=new UnicodeBlock<UnicodeBlock>        ARABIC=new UnicodeBlock<UnicodeBlock>        DEVANAGARI=new UnicodeBlock<UnicodeBlock>        BENGALI=new UnicodeBlock<UnicodeBlock>        GURMUKHI=new UnicodeBlock<UnicodeBlock>        GUJARATI=new UnicodeBlock<UnicodeBlock>        ORIYA=new UnicodeBlock<UnicodeBlock>        TAMIL=new UnicodeBlock<UnicodeBlock>        TELUGU=new UnicodeBlock<UnicodeBlock>        KANNADA=new UnicodeBlock<UnicodeBlock>        MALAYALAM=new UnicodeBlock<UnicodeBlock>        THAI=new UnicodeBlock<UnicodeBlock>        LAO=new UnicodeBlock<UnicodeBlock>        TIBETAN=new UnicodeBlock<UnicodeBlock>        GEORGIAN=new UnicodeBlock<UnicodeBlock>        HANGUL_JAMO=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_ADDITIONAL=new UnicodeBlock<UnicodeBlock>        GREEK_EXTENDED=new UnicodeBlock<UnicodeBlock>        GENERAL_PUNCTUATION=new UnicodeBlock<UnicodeBlock>        SUPERSCRIPTS_AND_SUBSCRIPTS=new UnicodeBlock<UnicodeBlock>        CURRENCY_SYMBOLS=new UnicodeBlock<UnicodeBlock>        COMBINING_MARKS_FOR_SYMBOLS=new UnicodeBlock<UnicodeBlock>        LETTERLIKE_SYMBOLS=new UnicodeBlock<UnicodeBlock>        NUMBER_FORMS=new UnicodeBlock<UnicodeBlock>        ARROWS=new UnicodeBlock<UnicodeBlock>        MATHEMATICAL_OPERATORS=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_TECHNICAL=new UnicodeBlock<UnicodeBlock>        CONTROL_PICTURES=new UnicodeBlock<UnicodeBlock>        OPTICAL_CHARACTER_RECOGNITION=new UnicodeBlock<UnicodeBlock>        ENCLOSED_ALPHANUMERICS=new UnicodeBlock<UnicodeBlock>        BOX_DRAWING=new UnicodeBlock<UnicodeBlock>        BLOCK_ELEMENTS=new UnicodeBlock<UnicodeBlock>        GEOMETRIC_SHAPES=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_SYMBOLS=new UnicodeBlock<UnicodeBlock>        DINGBATS=new UnicodeBlock<UnicodeBlock>        CJK_SYMBOLS_AND_PUNCTUATION=new UnicodeBlock<UnicodeBlock>        HIRAGANA=new UnicodeBlock<UnicodeBlock>        KATAKANA=new UnicodeBlock<UnicodeBlock>        BOPOMOFO=new UnicodeBlock<UnicodeBlock>        HANGUL_COMPATIBILITY_JAMO=new UnicodeBlock<UnicodeBlock>        KANBUN=new UnicodeBlock<UnicodeBlock>        ENCLOSED_CJK_LETTERS_AND_MONTHS=new UnicodeBlock<UnicodeBlock>        CJK_COMPATIBILITY=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS=new UnicodeBlock<UnicodeBlock>        HANGUL_SYLLABLES=new UnicodeBlock<UnicodeBlock>        PRIVATE_USE_AREA=new UnicodeBlock<UnicodeBlock>        CJK_COMPATIBILITY_IDEOGRAPHS=new UnicodeBlock<UnicodeBlock>        ALPHABETIC_PRESENTATION_FORMS=new UnicodeBlock<UnicodeBlock>        ARABIC_PRESENTATION_FORMS_A=new UnicodeBlock<UnicodeBlock>        COMBINING_HALF_MARKS=new UnicodeBlock<UnicodeBlock>        CJK_COMPATIBILITY_FORMS=new UnicodeBlock<UnicodeBlock>        SMALL_FORM_VARIANTS=new UnicodeBlock<UnicodeBlock>        ARABIC_PRESENTATION_FORMS_B=new UnicodeBlock<UnicodeBlock>        HALFWIDTH_AND_FULLWIDTH_FORMS=new UnicodeBlock<UnicodeBlock>        SPECIALS=new UnicodeBlock<UnicodeBlock>        SURROGATES_AREA=new UnicodeBlock<UnicodeBlock>        SYRIAC=new UnicodeBlock<UnicodeBlock>        THAANA=new UnicodeBlock<UnicodeBlock>        SINHALA=new UnicodeBlock<UnicodeBlock>        MYANMAR=new UnicodeBlock<UnicodeBlock>        ETHIOPIC=new UnicodeBlock<UnicodeBlock>        CHEROKEE=new UnicodeBlock<UnicodeBlock>        UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS=new UnicodeBlock<UnicodeBlock>        OGHAM=new UnicodeBlock<UnicodeBlock>        RUNIC=new UnicodeBlock<UnicodeBlock>        KHMER=new UnicodeBlock<UnicodeBlock>        MONGOLIAN=new UnicodeBlock<UnicodeBlock>        BRAILLE_PATTERNS=new UnicodeBlock<UnicodeBlock>        CJK_RADICALS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        KANGXI_RADICALS=new UnicodeBlock<UnicodeBlock>        IDEOGRAPHIC_DESCRIPTION_CHARACTERS=new UnicodeBlock<UnicodeBlock>        BOPOMOFO_EXTENDED=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A=new UnicodeBlock<UnicodeBlock>        YI_SYLLABLES=new UnicodeBlock<UnicodeBlock>        YI_RADICALS=new UnicodeBlock<UnicodeBlock>        CYRILLIC_SUPPLEMENTARY=new UnicodeBlock<UnicodeBlock>        TAGALOG=new UnicodeBlock<UnicodeBlock>        HANUNOO=new UnicodeBlock<UnicodeBlock>        BUHID=new UnicodeBlock<UnicodeBlock>        TAGBANWA=new UnicodeBlock<UnicodeBlock>        LIMBU=new UnicodeBlock<UnicodeBlock>        TAI_LE=new UnicodeBlock<UnicodeBlock>        KHMER_SYMBOLS=new UnicodeBlock<UnicodeBlock>        PHONETIC_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTAL_ARROWS_A=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTAL_ARROWS_B=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTAL_MATHEMATICAL_OPERATORS=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_SYMBOLS_AND_ARROWS=new UnicodeBlock<UnicodeBlock>        KATAKANA_PHONETIC_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        YIJING_HEXAGRAM_SYMBOLS=new UnicodeBlock<UnicodeBlock>        VARIATION_SELECTORS=new UnicodeBlock<UnicodeBlock>        LINEAR_B_SYLLABARY=new UnicodeBlock<UnicodeBlock>        LINEAR_B_IDEOGRAMS=new UnicodeBlock<UnicodeBlock>        AEGEAN_NUMBERS=new UnicodeBlock<UnicodeBlock>        OLD_ITALIC=new UnicodeBlock<UnicodeBlock>        GOTHIC=new UnicodeBlock<UnicodeBlock>        UGARITIC=new UnicodeBlock<UnicodeBlock>        DESERET=new UnicodeBlock<UnicodeBlock>        SHAVIAN=new UnicodeBlock<UnicodeBlock>        OSMANYA=new UnicodeBlock<UnicodeBlock>        CYPRIOT_SYLLABARY=new UnicodeBlock<UnicodeBlock>        BYZANTINE_MUSICAL_SYMBOLS=new UnicodeBlock<UnicodeBlock>        MUSICAL_SYMBOLS=new UnicodeBlock<UnicodeBlock>        TAI_XUAN_JING_SYMBOLS=new UnicodeBlock<UnicodeBlock>        MATHEMATICAL_ALPHANUMERIC_SYMBOLS=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B=new UnicodeBlock<UnicodeBlock>        CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        TAGS=new UnicodeBlock<UnicodeBlock>        VARIATION_SELECTORS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTARY_PRIVATE_USE_AREA_A=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTARY_PRIVATE_USE_AREA_B=new UnicodeBlock<UnicodeBlock>        HIGH_SURROGATES=new UnicodeBlock<UnicodeBlock>        HIGH_PRIVATE_USE_SURROGATES=new UnicodeBlock<UnicodeBlock>        LOW_SURROGATES=new UnicodeBlock<UnicodeBlock>        ARABIC_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        NKO=new UnicodeBlock<UnicodeBlock>        SAMARITAN=new UnicodeBlock<UnicodeBlock>        MANDAIC=new UnicodeBlock<UnicodeBlock>        ETHIOPIC_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED=new UnicodeBlock<UnicodeBlock>        NEW_TAI_LUE=new UnicodeBlock<UnicodeBlock>        BUGINESE=new UnicodeBlock<UnicodeBlock>        TAI_THAM=new UnicodeBlock<UnicodeBlock>        BALINESE=new UnicodeBlock<UnicodeBlock>        SUNDANESE=new UnicodeBlock<UnicodeBlock>        BATAK=new UnicodeBlock<UnicodeBlock>        LEPCHA=new UnicodeBlock<UnicodeBlock>        OL_CHIKI=new UnicodeBlock<UnicodeBlock>        VEDIC_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        PHONETIC_EXTENSIONS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        COMBINING_DIACRITICAL_MARKS_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        GLAGOLITIC=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_C=new UnicodeBlock<UnicodeBlock>        COPTIC=new UnicodeBlock<UnicodeBlock>        GEORGIAN_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        TIFINAGH=new UnicodeBlock<UnicodeBlock>        ETHIOPIC_EXTENDED=new UnicodeBlock<UnicodeBlock>        CYRILLIC_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        SUPPLEMENTAL_PUNCTUATION=new UnicodeBlock<UnicodeBlock>        CJK_STROKES=new UnicodeBlock<UnicodeBlock>        LISU=new UnicodeBlock<UnicodeBlock>        VAI=new UnicodeBlock<UnicodeBlock>        CYRILLIC_EXTENDED_B=new UnicodeBlock<UnicodeBlock>        BAMUM=new UnicodeBlock<UnicodeBlock>        MODIFIER_TONE_LETTERS=new UnicodeBlock<UnicodeBlock>        LATIN_EXTENDED_D=new UnicodeBlock<UnicodeBlock>        SYLOTI_NAGRI=new UnicodeBlock<UnicodeBlock>        COMMON_INDIC_NUMBER_FORMS=new UnicodeBlock<UnicodeBlock>        PHAGS_PA=new UnicodeBlock<UnicodeBlock>        SAURASHTRA=new UnicodeBlock<UnicodeBlock>        DEVANAGARI_EXTENDED=new UnicodeBlock<UnicodeBlock>        KAYAH_LI=new UnicodeBlock<UnicodeBlock>        REJANG=new UnicodeBlock<UnicodeBlock>        HANGUL_JAMO_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        JAVANESE=new UnicodeBlock<UnicodeBlock>        CHAM=new UnicodeBlock<UnicodeBlock>        MYANMAR_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        TAI_VIET=new UnicodeBlock<UnicodeBlock>        ETHIOPIC_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        MEETEI_MAYEK=new UnicodeBlock<UnicodeBlock>        HANGUL_JAMO_EXTENDED_B=new UnicodeBlock<UnicodeBlock>        VERTICAL_FORMS=new UnicodeBlock<UnicodeBlock>        ANCIENT_GREEK_NUMBERS=new UnicodeBlock<UnicodeBlock>        ANCIENT_SYMBOLS=new UnicodeBlock<UnicodeBlock>        PHAISTOS_DISC=new UnicodeBlock<UnicodeBlock>        LYCIAN=new UnicodeBlock<UnicodeBlock>        CARIAN=new UnicodeBlock<UnicodeBlock>        OLD_PERSIAN=new UnicodeBlock<UnicodeBlock>        IMPERIAL_ARAMAIC=new UnicodeBlock<UnicodeBlock>        PHOENICIAN=new UnicodeBlock<UnicodeBlock>        LYDIAN=new UnicodeBlock<UnicodeBlock>        KHAROSHTHI=new UnicodeBlock<UnicodeBlock>        OLD_SOUTH_ARABIAN=new UnicodeBlock<UnicodeBlock>        AVESTAN=new UnicodeBlock<UnicodeBlock>        INSCRIPTIONAL_PARTHIAN=new UnicodeBlock<UnicodeBlock>        INSCRIPTIONAL_PAHLAVI=new UnicodeBlock<UnicodeBlock>        OLD_TURKIC=new UnicodeBlock<UnicodeBlock>        RUMI_NUMERAL_SYMBOLS=new UnicodeBlock<UnicodeBlock>        BRAHMI=new UnicodeBlock<UnicodeBlock>        KAITHI=new UnicodeBlock<UnicodeBlock>        CUNEIFORM=new UnicodeBlock<UnicodeBlock>        CUNEIFORM_NUMBERS_AND_PUNCTUATION=new UnicodeBlock<UnicodeBlock>        EGYPTIAN_HIEROGLYPHS=new UnicodeBlock<UnicodeBlock>        BAMUM_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        KANA_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        ANCIENT_GREEK_MUSICAL_NOTATION=new UnicodeBlock<UnicodeBlock>        COUNTING_ROD_NUMERALS=new UnicodeBlock<UnicodeBlock>        MAHJONG_TILES=new UnicodeBlock<UnicodeBlock>        DOMINO_TILES=new UnicodeBlock<UnicodeBlock>        PLAYING_CARDS=new UnicodeBlock<UnicodeBlock>        ENCLOSED_ALPHANUMERIC_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        ENCLOSED_IDEOGRAPHIC_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS=new UnicodeBlock<UnicodeBlock>        EMOTICONS=new UnicodeBlock<UnicodeBlock>        TRANSPORT_AND_MAP_SYMBOLS=new UnicodeBlock<UnicodeBlock>        ALCHEMICAL_SYMBOLS=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C=new UnicodeBlock<UnicodeBlock>        CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D=new UnicodeBlock<UnicodeBlock>        ARABIC_EXTENDED_A=new UnicodeBlock<UnicodeBlock>        SUNDANESE_SUPPLEMENT=new UnicodeBlock<UnicodeBlock>        MEETEI_MAYEK_EXTENSIONS=new UnicodeBlock<UnicodeBlock>        MEROITIC_HIEROGLYPHS=new UnicodeBlock<UnicodeBlock>        MEROITIC_CURSIVE=new UnicodeBlock<UnicodeBlock>        SORA_SOMPENG=new UnicodeBlock<UnicodeBlock>        CHAKMA=new UnicodeBlock<UnicodeBlock>        SHARADA=new UnicodeBlock<UnicodeBlock>        TAKRI=new UnicodeBlock<UnicodeBlock>        MIAO=new UnicodeBlock<UnicodeBlock>        ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS=new UnicodeBlock<UnicodeBlock>        blockStarts=[]        blocks=
-      Instance Initializer: 
-      Constructors: 
-        constructor  UnicodeBlock()  throws: 
-        constructor  UnicodeBlock()  throws: 
-          cond-branch cond:isMap
-          true branch :
-            map.put(idName,this)
-          false branch :
-
-        constructor  UnicodeBlock()  throws: 
-          map.put(alias,this)
-        constructor  UnicodeBlock()  throws: 
-          String
-          alias
-          aliases
-          map.put(alias,this)
-      Methods: 
-        func  of()  throws: 
-          return of((int)c)
-        func  of()  throws: 
-          cond-branch cond:isValidCodePoint(codePoint)
-          true branch :
-            new IllegalArgumentException<IllegalArgumentException>
-          false branch :
-
-          var:top,bottom,current
-          bottom Assign 0
-          top Assign blockStarts.length
-          current Assign 
-          while top Sub bottom GT 1            cond-branch cond:codePoint GE 
-            true branch :
-              bottom Assign current
-            false branch :
-              top Assign current
-
-            current Assign (top Add bottom)2
-
-          return 
-      LocalClasses: 
-      LocalInterfaces: 
-  LocalInterfaces: 
-
diff --git a/src/MapleFE/test/runtests.pl b/src/MapleFE/test/runtests.pl
index 7824d713863e65f3ece5fcc3b3d0d2df7e038db4..f1bd481822ca842ced060d3e79754e7b0f63ccf7 100755
--- a/src/MapleFE/test/runtests.pl
+++ b/src/MapleFE/test/runtests.pl
@@ -52,7 +52,7 @@ my $countsub = 0;
 system("rm -Rf report.txt $pwd/output $pwd/diff $pwd/notexists");
 
 my $currdir = "$pwd";
-my $outroot = "$currdir/../output/test";
+my $outroot = "$currdir/../output/java/test";
 if(!(-e "$outroot")) {
   system("mkdir -p $outroot");
 }
@@ -106,37 +106,37 @@ foreach my $dir (@dirname) {
 #print "here15 dir $dir\n";
 #print "here16 src_file $src_file\n";
         if ($dir eq "java2mpl") {
-          $res = system("$pwd/../output/java/java2mpl $outdir/$src_file > $outdir/$result_file");
+          $res = system("$pwd/../output/java/java/java2mpl $outdir/$src_file > $outdir/$result_file");
         }
         if ($dir eq "errtest") {
-          $res = system("$pwd/../output/java/java2mpl $outdir/$src_file > $outdir/$result_file");
+          $res = system("$pwd/../output/java/java/java2mpl $outdir/$src_file > $outdir/$result_file");
         }
         if ($dir eq "others") {
-          $res = system("$pwd/../output/java/java2mpl $outdir/$src_file > $outdir/$result_file");
+          $res = system("$pwd/../output/java/java/java2mpl $outdir/$src_file > $outdir/$result_file");
         }
         if ($dir eq "openjdk") {
-          $res = system("$pwd/../output/java/java2mpl $outdir/$src_file > $outdir/$result_file");
+          $res = system("$pwd/../output/java/java/java2mpl $outdir/$src_file > $outdir/$result_file");
         }
         if ($dir eq "syntaxonly") {
-          $res = system("$pwd/../output/java/java2mpl $outdir/$src_file > $outdir/$result_file");
+          $res = system("$pwd/../output/java/java/java2mpl $outdir/$src_file > $outdir/$result_file");
         }
         
         if ($res > 0) {
 #print "over here1...\n";
           if ($dir eq "java2mpl") { 
-            print "$pwd/../output/java/java2mpl $outdir/$src_file\n";
+            print "$pwd/../output/java/java/java2mpl $outdir/$src_file\n";
           }
           if ($dir eq "errtest") { 
-            print "$pwd/../output/java/java2mpl $outdir/$src_file\n";
+            print "$pwd/../output/java/java/java2mpl $outdir/$src_file\n";
           }
           if ($dir eq "others") {
-            print "$pwd/../output/java/java2mpl $outdir/$src_file\n";
+            print "$pwd/../output/java/java/java2mpl $outdir/$src_file\n";
           }
           if ($dir eq "openjdk") {
-            print "$pwd/../output/java/java2mpl $outdir/$src_file\n";
+            print "$pwd/../output/java/java/java2mpl $outdir/$src_file\n";
           }
           if ($dir eq "syntaxonly") {
-            print "$pwd/../output/java/java2mpl $outdir/$src_file\n";
+            print "$pwd/../output/java/java/java2mpl $outdir/$src_file\n";
           }
           print " ==$dir===> $file\n";
           $countfailedjava ++;
diff --git a/src/MapleFE/test/sharedfe/add2.java.result b/src/MapleFE/test/sharedfe/add2.java.result
deleted file mode 100644
index 651c3b881b2baed1eb034ff2218c979c64aeba1e..0000000000000000000000000000000000000000
--- a/src/MapleFE/test/sharedfe/add2.java.result
+++ /dev/null
@@ -1,35 +0,0 @@
-!!! Stack match result:  1
-!!! Stack match result:  1
-!!! Stack match result:  1
-
-
-============================== function ==============================
-func foo (int a, int b) {
-    LocalVariableDeclarationStatement
-      "int"
-      Identifier
-        "c"
-    Assignment
-      LeftHandSide + AssignmentOperator + Expression
-        Identifier
-          "c"
-        '='
-        Expression
-          BinaryExpression
-            AdditiveExpression
-              AdditiveExpression + '+' + MultiplicativeExpression
-                Identifier
-                  "a"
-                '+'
-                Identifier
-                  "b"
-    StatementWithoutTrailingSubstatement
-      ReturnStatement
-        "return" + ZEROORONE(Expression) + ';'
-          "return"
-          Identifier
-            "c"
-}
-======================================================================
-
-
diff --git a/src/MapleFE/test/sharedfe/add3.java.result b/src/MapleFE/test/sharedfe/add3.java.result
deleted file mode 100644
index 7512d871815b308b5b203154fbec1c8109d90954..0000000000000000000000000000000000000000
--- a/src/MapleFE/test/sharedfe/add3.java.result
+++ /dev/null
@@ -1,40 +0,0 @@
-!!! Stack match result:  1
-!!! Stack match result:  1
-!!! Stack match result:  1
-
-
-============================== function ==============================
-func foo (int a, int b) {
-    LocalVariableDeclarationStatement
-      "int"
-      Identifier
-        "c"
-    Assignment
-      LeftHandSide + AssignmentOperator + Expression
-        Identifier
-          "c"
-        '='
-        Expression
-          BinaryExpression
-            AdditiveExpression
-              AdditiveExpression + '+' + MultiplicativeExpression
-                AdditiveExpression
-                  AdditiveExpression + '+' + MultiplicativeExpression
-                    Identifier
-                      "a"
-                    '+'
-                    Identifier
-                      "b"
-                '+'
-                Identifier
-                  "c"
-    StatementWithoutTrailingSubstatement
-      ReturnStatement
-        "return" + ZEROORONE(Expression) + ';'
-          "return"
-          Identifier
-            "c"
-}
-======================================================================
-
-
diff --git a/src/MapleFE/test/sharedfe/run b/src/MapleFE/test/sharedfe/run
deleted file mode 100755
index 1a06476d61d839c098c166018c83898a812c2939..0000000000000000000000000000000000000000
--- a/src/MapleFE/test/sharedfe/run
+++ /dev/null
@@ -1,8 +0,0 @@
-#! /bin/bash
-DIR=`pwd | sed "s/MapleFE.*/MapleFE/"`
-echo DIR=${DIR}
-cd $BUILDDIR/autogen
-
-#test t.java
-echo testing ... t.java
-./sharedfe ../../test/sharedfe/t.java
diff --git a/src/MapleFE/test/sharedfe_runtests.pl b/src/MapleFE/test/sharedfe_runtests.pl
deleted file mode 100755
index 9e9a0d8c1c9da801ba72d4e0d5a8a8121736dfa2..0000000000000000000000000000000000000000
--- a/src/MapleFE/test/sharedfe_runtests.pl
+++ /dev/null
@@ -1,193 +0,0 @@
-#!/usr/bin/perl -w
-use Cwd;
-use warnings;
-
-my $pwd = getcwd;
-
-#print "here1 current pwd $pwd\n";
-
-if ((!(defined $ARGV[0])) || ($ARGV[0] ne "sharedfe")) {
-  print "------------------------------------------------\n";
-  print "usage: sharedfe_runtests.pl sharedfe            \n";
-  print "------------------------------------------------\n";
-  exit;
-}
-
-$dirname = "./$ARGV[0]";
-
-my $outdir = "$pwd/sharedfe_output";
-my $diffdir = "$pwd/sharedfe_diff";
-my $notexistsdir = "$pwd/sharedfe_notexists";
-if(!(-e "$outdir")) {
-  system("mkdir -p $outdir");
-}
-
-my @failed_sharedfe_file;
-my @successed_file;
-
-my $count = 0;
-my $countsharedfe = 0; 
-
-
-chdir $dirname;
-$dirname = "./";
-opendir (DIR, $dirname ) || die "Error in opening dir $dirname\n";
-
-#print "here2 dirname $dirname\n";
-
-print("\n====================== run tests: $ARGV[0] =====================\n");
-
-while( ($srcdir = readdir(DIR))){
-  if(-d $srcdir and $srcdir ne ".." and $srcdir ne "output" and $srcdir ne "temp") {
-    my $predir = getcwd;
-    chdir $srcdir;
-    my @javafiles;
-    @javafiles = <*.java>;
-
-#print "here3 source directory $srcdir\n";
-#print "here4 predir $predir\n";
-
-    my @allfiles = (@javafiles);
-    foreach $fullname (@allfiles) {
-      $count ++;
-      (my $file = $fullname) =~ s/\.[^.]+$//;
-      if(defined $ARGV[1]) {
-        print "\n$file";
-      } else {
-        print ".";
-      }
-      if ($count % 50 == 0) {
-        print " $count\n";
-      }
-      my $flag = 0;
-      my $src_file = $fullname;
-      my $sharedfe_oresult_file = $file.'.java.result';
-      my $sharedfe_log_file = $file.'.sharedfe.log';
-      my $sharedfe_result_file = $file.'.java.sharedfe.result';
-      my $sharedfe_err_file = $file.'.err';
-      my $sharedfe_diff_file = $file.'.java.diff';
-
-      if(!(-e "$outdir")) {
-        system("mkdir -p $outdir");
-      }
-
-#print "here5 outdir $outdir\n";
-#print "here6 src_file $src_file\n";
-
-      system("cp $src_file $outdir/$src_file");
-      $res = system("cd $BUILDDIR/autogen; ./sharedfe $outdir/$src_file > $outdir/$sharedfe_result_file");
-      if ($res > 0) {
-        print "\n(cd $BUILDDIR/autogen; gdb --args ./sharedfe $outdir/$src_file)\n";
-        print " ==sharedfe===> $file\n";
-#        $countsharedfe ++;
-#        push(@failed_sharedfe_file, $file);
-        $flag ++;
-        next;
-      } 
-
-#print "here7 diff src_file $pwd/sharedfe/$sharedfe_oresult_file\n";
-#print "here8 diff sharedfe_result_file $sharedfe_result_file\n";
-
-      if (!(-e $sharedfe_oresult_file)) {
-        if(!(-e "$notexistsdir")) {
-          system("mkdir -p $notexistsdir");
-        }
-
-#print "here9 $sharedfe_oresult_file NOT exists\n";
-        print "Original file $sharedfe_oresult_file does NOT exists!\n";
-        system("touch $notexistsdir/$sharedfe_oresult_file");
-        $countsharedfe ++;  
-        push(@failed_sharedfe_file, $file);
-      }
-      else {
-#print "here10 sharedfe_result_file $outdir/$sharedfe_result_file\n";
-         if ((!(-e "$outdir/$sharedfe_result_file")) || (-z "$outdir/$sharedfe_result_file")) {
-            if(!(-e "$notexistsdir")) {
-               system("mkdir -p $notexistsdir");
-            }
- 
-#print "here11 $outdir/$sharedfe_result_file NOT exists\n";
-           print "$sharedfe_result_file either empty or not exists!\n";
-           system("touch $notexistsdir/$sharedfe_result_file");
-           $countsharedfe ++;
-           push(@failed_sharedfe_file, $file);
-        } else {
-           $res2 = system("diff $pwd/sharedfe/$sharedfe_oresult_file $outdir/$sharedfe_result_file");
-           if ($res2 > 0) {
-             if(!(-e "$diffdir")) {
-                system("mkdir -p $diffdir");
-             }
-
-#print "here12 $sharedfe_diff_file  Different!!!\n";
-             print "$sharedfe_oresult_file $sharedfe_result_file are different!!!\n";
-             system("touch $diffdir/$sharedfe_diff_file");
-             $countsharedfe ++;
-             push(@failed_sharedfe_file, $file);
-           } else {
-             push(@successed_file, $file);
-           }
-
-         } 
-      }
-
-#      if($flag eq 0){
-#        push(@successed_file, $file);
-#      }
-      next;
-
-      if ($flag eq -1) {
-        push(@successed_file, $file);
-        system("rm -f $outdir/$src_file");
-        system("rm -f $outdir/$sharedfe_log_file");
-        system("rm -f $outdir/$sharedfe_oresult_file");
-        system("rm -f $outdir/$sharedfe_result_file");
-        system("rm -f $outdir/$sharedfe_err_file");
-        system("rm -f $diffdir/$sharedfe_diff_file");
-        system("rm -f $notexists/$sharedfe_oresult_file");
-        system("rm -f $notexists/$sharedfe_result_file");
-        next;
-      }
-    }
-    chdir $predir;
-  }
-}
-
-print " $count\n";
-closedir(DIR);
-chdir $pwd;
-
-my $countFailed = $countsharedfe ;
-my $countPassed = $count - $countFailed;
-
-my $reportFile = 'sharedfe_report.txt';
-open(my $fh, '>', $reportFile) or die "Could not open file '$reportFile' $!";
-print $fh "$ARGV[0] report: \n";
-
-if ($countFailed eq 0) {
-  print("\n all $count tests passed\n");
-  print("======================================================\n");
-  print $fh "all $count tests passed\n";
-  close $fh;
-} else {
-  print "\n\n=====Scan Result=====\n\n";
-  print "Total Test Cases: $count\n";
-  if(scalar(@successed_file) > 0) {
-    print "\n=========================\npassed $countPassed tests:\n\n";
-    foreach $passed (@successed_file) {
-      print $passed."\n";
-    }
-    print $fh "$countPassed testcases passed\n";
-  }
-  print "\n=========================\nfailed $countFailed tests:\n\n";
-  if(scalar(@failed_sharedfe_file) > 0){
-    print("=== failed sharedfe: $countsharedfe tests\n");
-    print $fh "$countsharedfe testcases failed\n";
-
-    foreach $failed (@failed_sharedfe_file) {
-      print $failed."\n";
-    }
-    print "\n";
-  }
-  print "=========================\n";
-  close $fh;
-}
diff --git a/src/MapleFE/test/typescript/generate-result.sh b/src/MapleFE/test/typescript/generate-result.sh
new file mode 100755
index 0000000000000000000000000000000000000000..5e3e9c5354afa6bc5edbf0428348ba74db0f96c9
--- /dev/null
+++ b/src/MapleFE/test/typescript/generate-result.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
+FILES=`find . -name "*.ts"`
+for f in $FILES
+do
+  echo "Generating result for $f ..."
+  $MAPLEFE_ROOT/output/typescript/bin/ts2ast $f > $f.result
+done
diff --git a/src/MapleFE/test/typescript/ms_tests/README b/src/MapleFE/test/typescript/ms_tests/README
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/MapleFE/test/typescript/ms_tests/checkInterfaceBases.ts.result b/src/MapleFE/test/typescript/ms_tests/checkInterfaceBases.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..06e1681196983bfca57f375df768dced69a0d430
--- /dev/null
+++ b/src/MapleFE/test/typescript/ms_tests/checkInterfaceBases.ts.result
@@ -0,0 +1,13 @@
+Matched 16 tokens.
+Matched 24 tokens.
+Matched 32 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: JQueryEventObjectTest {data;which;metaKey }
+== Sub Tree ==
+trip-slash reference path = "jquery.d.ts"
+== Sub Tree ==
+ts_interface: SecondEvent {data }
+== Sub Tree ==
+ts_interface: Third { }
diff --git a/src/MapleFE/test/typescript/ms_tests/getsetReturnTypes.ts.result b/src/MapleFE/test/typescript/ms_tests/getsetReturnTypes.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e0ca09b6180bf1a841fd45c57c16dc3775ae03e1
--- /dev/null
+++ b/src/MapleFE/test/typescript/ms_tests/getsetReturnTypes.ts.result
@@ -0,0 +1,14 @@
+Matched 22 tokens.
+Matched 32 tokens.
+Matched 44 tokens.
+============= Module ===========
+== Sub Tree ==
+func  makePoint(x)  throws: 
+  return  {x:get x()  throws: 
+  return x
+}
+
+== Sub Tree ==
+js_var Decl: x=makePoint(2).x
+== Sub Tree ==
+js_var Decl: y=makePoint(2).x
diff --git a/src/MapleFE/test/typescript/ms_tests/library_ObjectPrototypeProperties.ts.result b/src/MapleFE/test/typescript/ms_tests/library_ObjectPrototypeProperties.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1cf0e482cb7d522e06cb8c2022e407bc2f85119f
--- /dev/null
+++ b/src/MapleFE/test/typescript/ms_tests/library_ObjectPrototypeProperties.ts.result
@@ -0,0 +1,22 @@
+Matched 6 tokens.
+Matched 14 tokens.
+Matched 22 tokens.
+Matched 30 tokens.
+Matched 39 tokens.
+Matched 48 tokens.
+Matched 57 tokens.
+============= Module ===========
+== Sub Tree ==
+Object.prototype.constructor
+== Sub Tree ==
+Object.prototype.toString()
+== Sub Tree ==
+Object.prototype.toLocaleString()
+== Sub Tree ==
+Object.prototype.valueOf()
+== Sub Tree ==
+Object.prototype.hasOwnProperty("string")
+== Sub Tree ==
+Object.prototype.isPrototypeOf(Object)
+== Sub Tree ==
+Object.prototype.propertyIsEnumerable("string")
diff --git a/src/MapleFE/test/typescript/ms_tests/reExportGlobalDeclaration3.ts.result b/src/MapleFE/test/typescript/ms_tests/reExportGlobalDeclaration3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c0e6053f15e6add6d4b1949ee1355d75bbe1c288
--- /dev/null
+++ b/src/MapleFE/test/typescript/ms_tests/reExportGlobalDeclaration3.ts.result
@@ -0,0 +1,23 @@
+Matched 11 tokens.
+Matched 22 tokens.
+Matched 31 tokens.
+Matched 40 tokens.
+Matched 47 tokens.
+Matched 54 tokens.
+============= Module ===========
+== Sub Tree ==
+declare namespace  NS1
+  export {js_var Decl: foo} 
+
+== Sub Tree ==
+declare namespace  NS2
+  export {js_var Decl: foo} 
+
+== Sub Tree ==
+export {NS1,NS1 as NNS1} 
+== Sub Tree ==
+export {NS2,NS2 as NNS2} 
+== Sub Tree ==
+export {NS1 as NNNS1} 
+== Sub Tree ==
+export {NS2 as NNNS2} 
diff --git a/src/MapleFE/test/typescript/ts2cxx-test.sh b/src/MapleFE/test/typescript/ts2cxx-test.sh
new file mode 100755
index 0000000000000000000000000000000000000000..33897fa18fd607b8c978d4a89637679d88b8f66d
--- /dev/null
+++ b/src/MapleFE/test/typescript/ts2cxx-test.sh
@@ -0,0 +1,115 @@
+#!/bin/bash
+# Usage: cd MapleFE/test/typescript/unit_tests; ../ts2cpp-test.sh *.ts
+[ $# -lt 1 ] && exec $0 $(git ls-files "*.ts")
+SUCC=
+MPLFEPATH=$(cd $(dirname $0)/../../; pwd)
+TSOUT=$MPLFEPATH/output/typescript
+RTSRC=$MPLFEPATH/ast2cpp/runtime/src
+RTINC=$MPLFEPATH/ast2cpp/runtime/include
+ASTINC=$MPLFEPATH/astopt/include
+TS2AST=$TSOUT/bin/ts2ast
+AST2CPP=$TSOUT/bin/ast2cpp
+TSCSH=$(dirname $0)/tsc.sh
+
+# Acquire/release a lock
+typeset -i LockVar
+LockVar=1
+function AcquireLock {
+    while [[ $LockVar -ne 0 ]] || sleep 0.1; do
+        ln -s Lock_$2 $1-lock-$((LockVar=(LockVar+1)%$3)) > /dev/null 2>&1 && break
+    done
+}
+function ReleaseLock {
+    rm -f $1-lock-$LockVar
+}
+trap "{ pstree -p $$ | tr ')' '\n' | sed 's/.*(//' | xargs kill -9 2> /dev/null; rm -f ts2cpp-lock-*; }" SIGINT SIGQUIT SIGKILL SIGTERM
+rm -rf ts2cpp-lock-* *-ts2cpp.out ts2cpp.summary.out ts2cpp.failures*.out
+cnt=0
+if [ $# -gt 1 ]; then
+  list1=$(grep -L -e "^ *import " -e "^ *export .* from " "$@")
+  list2=$(grep -l -e "^ *import " -e "^ *export .* from " "$@")
+else
+  list1="$@" list2=
+fi
+single="no"
+for list in "$list1" "$list2"; do
+for f in $list; do
+  echo $((++cnt)): $f
+  t=$(basename $f .ts)
+  [ -f $t.ts ] && f=$t.ts
+  AcquireLock ts2cpp for_$t $(nproc)
+  (set -x
+  while true; do
+    $TS2AST $f || { echo "(ts2ast)$f" >> ts2cpp.failures.out; break; }
+    dep=$(sed 's/[ ,:|]\(import(\)/\n\1/g' "$f" | grep -E "^ *[ei][xm]port.*( from |require|\( *['\"])" | \
+      sed -r "s/^ *[ei][xm]port.*( from |require *\(|\() *['\"]([^'\"]*).*/\2.cpp/" | sort -u)
+    for cpp in $dep; do
+      ts=$(sed 's/\.cpp/.ts/' <<< "$cpp")
+      $TS2AST $ts
+      dep="$dep "$(sed 's/[ ,:|]\(import(\)/\n\1/g' "$ts" | grep -E "^ *[ei][xm]port.*( from |require|\( *['\"])" | \
+        sed -r "s/^ *[ei][xm]port.*( from |require *\(|\() *['\"]([^'\"]*).*/\2.cpp/" | sort -u)
+    done
+    dep=$(echo $dep | xargs -n1 | sort -u)
+    $AST2CPP $f.ast || { echo "(ast2cpp)$f" >> ts2cpp.failures.out; break; }
+    g++ -std=c++17 -g -I$RTINC -I$ASTINC $t.cpp $RTSRC/*.cpp $dep -o $t.out || { echo "(g++)$f" >> ts2cpp.failures2.out; break; }
+    ./$t.out 2>&1 > $f-run.out || { echo "(run)$f" >> ts2cpp.failures2.out; break; }
+    $TSCSH $f
+    diff $f-run.out $f-nodejs.out
+    if [ $? -ne 0 ]; then
+       sed -e 's/^[A-Za-z]* {/{/' $f-run.out | diff - $f-nodejs.out
+       if [ $? -ne 0 ]; then
+         sed -e 's/^[A-Za-z]* {/{/' -e 's/} [A-Za-z]* {/} {/' $f-run.out | diff - $f-nodejs.out
+         if [ $? -ne 0 ]; then
+           echo "(result)$f" >> ts2cpp.failures3.out
+           break
+         fi
+       fi
+    fi
+    echo $t >> ts2cpp.summary.out
+    break
+  done
+  ReleaseLock ts2cpp
+  ) >& $f-ts2cpp.out &
+  if [ $single = "yes" ]; then
+    wait
+  fi
+done 2>&1 
+wait
+single="yes"
+done
+num=$(echo $list1 $list2 | wc -w)
+total=$(git ls-files "*.ts" | wc -w)
+log=cxx-tmp.log
+[ $num -eq $total ] && log=cxx.log
+if [ -f ts2cpp.summary.out ]; then
+  echo -e "\nDate: $(date)\nTest cases passed:" | tee -a $log
+  sort ts2cpp.summary.out | xargs -n1 | nl | tee -a $log
+fi
+if [ -f ts2cpp.failures3.out ]; then
+  echo -e "\nTest cases failed due to unexpected results:" | tee -a $log
+  sort ts2cpp.failures3.out | xargs -n1 | nl | tee -a $log
+  if [ $num -eq 1 ]; then
+    echo -e  "\ndiff $t.ts-nodejs.out $t.ts-run.out"
+    diff $t.ts-nodejs.out $t.ts-run.out
+  fi
+fi
+if [ -f ts2cpp.failures2.out ]; then
+  echo -e "\nTest cases failed due to g++ or run:" | tee -a $log
+  sort ts2cpp.failures2.out | xargs -n1 | nl | tee -a $log
+  if [ $num -eq 1 ]; then
+    echo -e  "\nCommand line to compile $t.cpp:"
+    grep -- "-std=c++17" $t.ts-ts2cpp.out | sed 's/^+/ /'
+  fi
+fi
+if [ -f ts2cpp.failures.out ]; then
+  echo -e "\nTest cases failed due to ts2ast or ast2cpp:" | tee -a $log
+  sort ts2cpp.failures.out | xargs -n1 | nl | tee -a $log
+fi
+if [ $num -eq $total ]; then
+  grep -c ": error:" *.ts-ts2cpp.out | sort -nrt: -k2 | grep -v :0 | sed 's/-ts2cpp.out//' > cxx-error.log
+  lines=$(grep -n -e "Test cases passed:" -e "Test cases failed due to g++ or run:" $log | \
+    grep -A1 ":Test cases passed:" | tail -2 | cut -d: -f1)
+  sed -n $(echo $lines | sed 's/[^0-9]/,/')p $log | grep "[0-9]" | expand | cut -c9- > cxx-succ.log
+else
+  echo Saved testing results to file $log
+fi
diff --git a/src/MapleFE/test/typescript/tsc.sh b/src/MapleFE/test/typescript/tsc.sh
new file mode 100755
index 0000000000000000000000000000000000000000..1b2579cc6aa8169abb928c804af71e7c6cd88ce3
--- /dev/null
+++ b/src/MapleFE/test/typescript/tsc.sh
@@ -0,0 +1,63 @@
+#!/bin/bash
+# Acquire/release a lock
+typeset -i LockVar
+LockVar=1
+function AcquireLock {
+    while [[ $LockVar -ne 0 ]] || sleep 0.1; do
+        ln -s Lock_$2 $1-lock-$((LockVar=(LockVar+1)%$3)) > /dev/null 2>&1 && break
+    done
+}
+function ReleaseLock {
+    rm -f $1-lock-$LockVar
+}
+rm -rf -- tsc-lock-* *-tsc.out tsc.summary.out tsc.failures*.out
+
+OPT="--target es2017 \
+     --lib es2015,es2017,dom \
+     --module commonjs \
+     --downlevelIteration \
+     --esModuleInterop \
+     --experimentalDecorators"
+# --sourceMap \
+# --isolatedModules \
+while [ "x${1:0:1}" = "x-" ]; do
+ OPT="$OPT $1"
+ shift
+done
+i=0
+for f; do
+  echo $((++i)). $f
+  js=$(dirname $f)/$(basename $f .ts).js
+  rm -f $js
+  AcquireLock tsc for_$t $(nproc)
+  (bash -x -c "tsc --strict $OPT $f"
+   if [ $? -ne 0 ]; then
+     echo "(--strict)"$f >> tsc.failures.out
+     bash -x -c "tsc $OPT $f" || echo "(non-strict)"$f >> tsc.failures.out
+   fi
+   if [ -f "$js" ]; then
+     bash -x -c "node $js"
+     [ $? -ne 0 ] && echo "(nodejs)"$f >> tsc.failures.out
+   fi 2>&1 > $f-nodejs.out
+   ReleaseLock tsc
+  ) >& $f-tsc.out &
+done
+wait
+rc=0
+if [ -f tsc.failures.out ]; then
+  echo -e "\nTest cases failed with tsc strict mode enabled:"
+  sort tsc.failures.out | grep "(--strict)" | xargs -n1 | nl
+  grep -q -e "(non-strict)" -e "(nodejs)" tsc.failures.out
+  if [ $? -eq 0 ]; then
+    echo -e "\nTest cases failed with non-strict mode or nodejs:"
+    sort tsc.failures.out | grep -e "(non-strict)" -e "(nodejs)" | xargs -n1 | nl
+    rc=2
+  else
+    echo -e "\nAll passed with tsc non-strict mode."
+    rc=1
+  fi
+elif [ $# -gt 0 ]; then
+  echo All passed
+fi
+[ $i -eq 1 -a -f $f-tsc.out ] && cat $f-tsc.out $f-nodejs.out
+exit $rc
diff --git a/src/MapleFE/test/typescript/unit_tests/App-copy.ts b/src/MapleFE/test/typescript/unit_tests/App-copy.ts
new file mode 100644
index 0000000000000000000000000000000000000000..da2bce06f59f6ae0d2be5ec42666819bf150768d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App-copy.ts
@@ -0,0 +1,4 @@
+import myX, * as M from "./M-copy";
+console.log(myX, M.getx());
+M.setx(3);
+console.log(myX, M.getx());
diff --git a/src/MapleFE/test/typescript/unit_tests/App-copy.ts.result b/src/MapleFE/test/typescript/unit_tests/App-copy.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..29130fe6ddec7df47adeb50b2666ef352d4ba485
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App-copy.ts.result
@@ -0,0 +1,13 @@
+Matched 9 tokens.
+Matched 22 tokens.
+Matched 29 tokens.
+Matched 42 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as myX, * as M} "./M-copy"
+== Sub Tree ==
+console.log(myX,M.getx())
+== Sub Tree ==
+M.setx(3)
+== Sub Tree ==
+console.log(myX,M.getx())
diff --git a/src/MapleFE/test/typescript/unit_tests/App-import.ts b/src/MapleFE/test/typescript/unit_tests/App-import.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f00203e409f8a420d35178f31005ed05f2c63119
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App-import.ts
@@ -0,0 +1,5 @@
+import myX, * as M from "./M";
+import getx = M.getx;
+console.log(myX, getx());
+M.setx(3);
+console.log(myX, getx());
diff --git a/src/MapleFE/test/typescript/unit_tests/App-import.ts.result b/src/MapleFE/test/typescript/unit_tests/App-import.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..da9ea239e3f9c3568bec0a928d882cc1ba3f292a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App-import.ts.result
@@ -0,0 +1,16 @@
+Matched 9 tokens.
+Matched 16 tokens.
+Matched 27 tokens.
+Matched 34 tokens.
+Matched 45 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as myX, * as M} "./M"
+== Sub Tree ==
+import {M.getx as getx} 
+== Sub Tree ==
+console.log(myX,getx())
+== Sub Tree ==
+M.setx(3)
+== Sub Tree ==
+console.log(myX,getx())
diff --git a/src/MapleFE/test/typescript/unit_tests/App-re-export.ts b/src/MapleFE/test/typescript/unit_tests/App-re-export.ts
new file mode 100644
index 0000000000000000000000000000000000000000..666b1b1a9253d51e8a1dc0c014afecc1159e701a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App-re-export.ts
@@ -0,0 +1,4 @@
+import myX, * as M from "./re-export";
+console.log(myX, M.getx());
+M.setx(3);
+console.log(myX, M.getx());
diff --git a/src/MapleFE/test/typescript/unit_tests/App-re-export.ts.result b/src/MapleFE/test/typescript/unit_tests/App-re-export.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5c98f56a103bf8886bc56404fa09eada9d8eba5c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App-re-export.ts.result
@@ -0,0 +1,13 @@
+Matched 9 tokens.
+Matched 22 tokens.
+Matched 29 tokens.
+Matched 42 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as myX, * as M} "./re-export"
+== Sub Tree ==
+console.log(myX,M.getx())
+== Sub Tree ==
+M.setx(3)
+== Sub Tree ==
+console.log(myX,M.getx())
diff --git a/src/MapleFE/test/typescript/unit_tests/App-re-export2.ts b/src/MapleFE/test/typescript/unit_tests/App-re-export2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c6dbb897f9b7df1aa5acf345eea33c946ebdc796
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App-re-export2.ts
@@ -0,0 +1,7 @@
+import myX, * as M from "./re-export2";
+import {Y as y} from "./re-export2";
+console.log(y);
+console.log(myX, M.getx());
+M.setx(3);
+console.log(myX, M.getx());
+console.log(y);
diff --git a/src/MapleFE/test/typescript/unit_tests/App-re-export2.ts.result b/src/MapleFE/test/typescript/unit_tests/App-re-export2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..fd84b06b35dafc531d8f2f20cb9f4ff01840c9ff
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App-re-export2.ts.result
@@ -0,0 +1,22 @@
+Matched 9 tokens.
+Matched 18 tokens.
+Matched 25 tokens.
+Matched 38 tokens.
+Matched 45 tokens.
+Matched 58 tokens.
+Matched 65 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as myX, * as M} "./re-export2"
+== Sub Tree ==
+import {Y as y} "./re-export2"
+== Sub Tree ==
+console.log(y)
+== Sub Tree ==
+console.log(myX,M.getx())
+== Sub Tree ==
+M.setx(3)
+== Sub Tree ==
+console.log(myX,M.getx())
+== Sub Tree ==
+console.log(y)
diff --git a/src/MapleFE/test/typescript/unit_tests/App.ts b/src/MapleFE/test/typescript/unit_tests/App.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc80a709ec968705cc976b4fd1cbd89c006638ab
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App.ts
@@ -0,0 +1,4 @@
+import myX, * as M from "./M";
+console.log(myX, M.getx());
+M.setx(3);
+console.log(myX, M.getx());
diff --git a/src/MapleFE/test/typescript/unit_tests/App.ts.result b/src/MapleFE/test/typescript/unit_tests/App.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..dd6dc8f514ff7e2f7a5196cc3325fbfa8cb8ad52
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App.ts.result
@@ -0,0 +1,13 @@
+Matched 9 tokens.
+Matched 22 tokens.
+Matched 29 tokens.
+Matched 42 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as myX, * as M} "./M"
+== Sub Tree ==
+console.log(myX,M.getx())
+== Sub Tree ==
+M.setx(3)
+== Sub Tree ==
+console.log(myX,M.getx())
diff --git a/src/MapleFE/test/typescript/unit_tests/App2.ts b/src/MapleFE/test/typescript/unit_tests/App2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..217529e23913ed6c6a6009119b7d42e8f2412584
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App2.ts
@@ -0,0 +1,6 @@
+import myX from "./M";
+import * as M from "./M";
+import { X } from "./export-default-as";
+console.log(myX, M.getx(), X);
+M.setx(3);
+console.log(myX, M.getx(), X);
diff --git a/src/MapleFE/test/typescript/unit_tests/App2.ts.result b/src/MapleFE/test/typescript/unit_tests/App2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..249a408c8184c473415bb95033b63cd89e62eb49
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App2.ts.result
@@ -0,0 +1,19 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 34 tokens.
+Matched 41 tokens.
+Matched 56 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as myX} "./M"
+== Sub Tree ==
+import { * as M} "./M"
+== Sub Tree ==
+import {X} "./export-default-as"
+== Sub Tree ==
+console.log(myX,M.getx(),X)
+== Sub Tree ==
+M.setx(3)
+== Sub Tree ==
+console.log(myX,M.getx(),X)
diff --git a/src/MapleFE/test/typescript/unit_tests/App3.ts b/src/MapleFE/test/typescript/unit_tests/App3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..48559a7bebd0451f08d473e81e46fefed7759d34
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App3.ts
@@ -0,0 +1,6 @@
+import myX from "./export-default-as2";
+import * as M from "./M";
+import { X } from "./export-default-as";
+console.log(myX, M.getx(), X);
+M.setx(3);
+console.log(myX, M.getx(), X);
diff --git a/src/MapleFE/test/typescript/unit_tests/App3.ts.result b/src/MapleFE/test/typescript/unit_tests/App3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..34009cc2f9199603cd7e9429abc9032f194971e9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App3.ts.result
@@ -0,0 +1,19 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 34 tokens.
+Matched 41 tokens.
+Matched 56 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as myX} "./export-default-as2"
+== Sub Tree ==
+import { * as M} "./M"
+== Sub Tree ==
+import {X} "./export-default-as"
+== Sub Tree ==
+console.log(myX,M.getx(),X)
+== Sub Tree ==
+M.setx(3)
+== Sub Tree ==
+console.log(myX,M.getx(),X)
diff --git a/src/MapleFE/test/typescript/unit_tests/App4.ts b/src/MapleFE/test/typescript/unit_tests/App4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6de0137d3fede63ed01fd51f5dc0b6e318c66b7c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App4.ts
@@ -0,0 +1,4 @@
+import myX, { MM as M } from "./re-export4";
+console.log(myX, M.getx());
+M.setx(3);
+console.log(myX, M.getx());
diff --git a/src/MapleFE/test/typescript/unit_tests/App4.ts.result b/src/MapleFE/test/typescript/unit_tests/App4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0de69f258027c851b846ec14eaea36156dfc37fd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App4.ts.result
@@ -0,0 +1,13 @@
+Matched 11 tokens.
+Matched 24 tokens.
+Matched 31 tokens.
+Matched 44 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as myX,MM as M} "./re-export4"
+== Sub Tree ==
+console.log(myX,M.getx())
+== Sub Tree ==
+M.setx(3)
+== Sub Tree ==
+console.log(myX,M.getx())
diff --git a/src/MapleFE/test/typescript/unit_tests/App5.ts b/src/MapleFE/test/typescript/unit_tests/App5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9dacf6d73f2d8479e0ef0b6a01a48ce08e7d2b92
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App5.ts
@@ -0,0 +1,2 @@
+import { getx } from "./export-import2";
+console.log(getx());
diff --git a/src/MapleFE/test/typescript/unit_tests/App5.ts.result b/src/MapleFE/test/typescript/unit_tests/App5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6fbc351181248dd3fa552c65e36ad67a2c53d059
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/App5.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+import {getx} "./export-import2"
+== Sub Tree ==
+console.log(getx())
diff --git a/src/MapleFE/test/typescript/unit_tests/M-copy.ts b/src/MapleFE/test/typescript/unit_tests/M-copy.ts
new file mode 100644
index 0000000000000000000000000000000000000000..252e1655aa8a80a9e04449a87bbb4b55b67b83f2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/M-copy.ts
@@ -0,0 +1,10 @@
+var x: number = 2;
+//export { x as default }; // ref
+export default x; // copy
+x = 12;
+export function getx(): number {
+  return x;
+}
+export function setx(v: number): void {
+  x = v;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/M-copy.ts.result b/src/MapleFE/test/typescript/unit_tests/M-copy.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..73f2fb1c3534788e3ecc2c278ec0a14a184ea86b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/M-copy.ts.result
@@ -0,0 +1,20 @@
+Matched 7 tokens.
+Matched 11 tokens.
+Matched 15 tokens.
+Matched 27 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=2
+== Sub Tree ==
+export { default as x} 
+== Sub Tree ==
+x Assign 12
+== Sub Tree ==
+export {func  getx()  throws: 
+  return x
+} 
+== Sub Tree ==
+export {func  setx(v)  throws: 
+  x Assign v
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/M.ts b/src/MapleFE/test/typescript/unit_tests/M.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f49b68cf52af8d098313ad690b3cc54097ce1892
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/M.ts
@@ -0,0 +1,9 @@
+var x: number = 2;
+export { x as default }; // ref
+//export default x;      // copy
+export function getx(): number {
+  return x;
+}
+export function setx(v: number): void {
+  x = v;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/M.ts.result b/src/MapleFE/test/typescript/unit_tests/M.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..84952de63aa56f4a000dbe0fa74eb6d3a75dab10
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/M.ts.result
@@ -0,0 +1,17 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 26 tokens.
+Matched 42 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=2
+== Sub Tree ==
+export {x as default} 
+== Sub Tree ==
+export {func  getx()  throws: 
+  return x
+} 
+== Sub Tree ==
+export {func  setx(v)  throws: 
+  x Assign v
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/Promise-catch.ts b/src/MapleFE/test/typescript/unit_tests/Promise-catch.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b2edeed401c7e645fe6ce65e583c98fa143eed49
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/Promise-catch.ts
@@ -0,0 +1,11 @@
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch
+// cocos: director.ts, root.ts
+// tsc --lib es2015,dom Promise-catch.ts
+const promise1 = new Promise((resolve, reject) => {
+  throw "something happened";
+});
+
+promise1.catch((error) => {
+  console.log(error);
+});
diff --git a/src/MapleFE/test/typescript/unit_tests/Promise-catch.ts.result b/src/MapleFE/test/typescript/unit_tests/Promise-catch.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d82e45128883669847aed9b2698cc4e230e710a0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/Promise-catch.ts.result
@@ -0,0 +1,10 @@
+Matched 19 tokens.
+Matched 38 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: promise1=new Promise((resolve,reject) -> throw "something happened"
+
+)
+== Sub Tree ==
+promise1.catch((error) -> console.log(error)
+)
diff --git a/src/MapleFE/test/typescript/unit_tests/abstract-class.ts b/src/MapleFE/test/typescript/unit_tests/abstract-class.ts
new file mode 100644
index 0000000000000000000000000000000000000000..90eb9824872b87bbcfcf3c315081b644267b9bc7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/abstract-class.ts
@@ -0,0 +1,8 @@
+abstract class Foo {
+  public f1: number = 0;
+  private f2: number = 0;
+  constructor(a: number, b: number) {
+    this.f1 = a;
+    this.f2 = b;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/abstract-class.ts.result b/src/MapleFE/test/typescript/unit_tests/abstract-class.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..888597a8042fcead4b747ddfda25adef9c8c8a3f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/abstract-class.ts.result
@@ -0,0 +1,15 @@
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    f1=0    f2=0
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.f1 Assign a
+      this.f2 Assign b
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/abstract-class2.ts b/src/MapleFE/test/typescript/unit_tests/abstract-class2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..993d6e5eaa91ec5c86b8bdc383caeaee0eb5ec53
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/abstract-class2.ts
@@ -0,0 +1,3 @@
+abstract class Klass {
+  public abstract func(): void;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/abstract-class2.ts.result b/src/MapleFE/test/typescript/unit_tests/abstract-class2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c2dbc106515111dc84188ca97656c49f6e4b91bd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/abstract-class2.ts.result
@@ -0,0 +1,13 @@
+Matched 13 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func()  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/abstract-new.ts b/src/MapleFE/test/typescript/unit_tests/abstract-new.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bd1ffeb4a8e0f587f8db27ec313ff848b2651539
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/abstract-new.ts
@@ -0,0 +1,2 @@
+type Type<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;
+
diff --git a/src/MapleFE/test/typescript/unit_tests/abstract-new.ts.result b/src/MapleFE/test/typescript/unit_tests/abstract-new.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e3e36bcc0bd887c67b0e743e6f9b6cdae543ea9c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/abstract-new.ts.result
@@ -0,0 +1,4 @@
+Matched 35 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Type<T> = T extends new (args) ->  ? P : never
diff --git a/src/MapleFE/test/typescript/unit_tests/add.ts b/src/MapleFE/test/typescript/unit_tests/add.ts
new file mode 100644
index 0000000000000000000000000000000000000000..583789b9c703e11801e5e96f32be11aa57f887cc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/add.ts
@@ -0,0 +1,4 @@
+var a: number = 1;
+var b: number = 1;
+var c: number;
+c = a + b;
diff --git a/src/MapleFE/test/typescript/unit_tests/add.ts.result b/src/MapleFE/test/typescript/unit_tests/add.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..028434f5242c519543c3021c12c790eaa8ea4cce
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/add.ts.result
@@ -0,0 +1,13 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 19 tokens.
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: a=1
+== Sub Tree ==
+js_var Decl: b=1
+== Sub Tree ==
+js_var Decl: c
+== Sub Tree ==
+c Assign a Add b
diff --git a/src/MapleFE/test/typescript/unit_tests/array-default.ts b/src/MapleFE/test/typescript/unit_tests/array-default.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0b75ed259ae31964b932df4d5acc402ac21bdf5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-default.ts
@@ -0,0 +1,5 @@
+// the type of arr element is never by default
+const arr: [] = [];
+(arr as any[]).push([]);
+arr.push.apply(arr, {} as any);
+console.log(arr);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-default.ts.result b/src/MapleFE/test/typescript/unit_tests/array-default.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0b7026b4dd2e7ebaf64824e9cab98a44bcfbc052
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-default.ts.result
@@ -0,0 +1,13 @@
+Matched 9 tokens.
+Matched 23 tokens.
+Matched 37 tokens.
+Matched 44 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: arr=[]
+== Sub Tree ==
+arr.push([])
+== Sub Tree ==
+arr.push.apply(arr, {})
+== Sub Tree ==
+console.log(arr)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-elem-as-type.ts b/src/MapleFE/test/typescript/unit_tests/array-elem-as-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f73d2cbfcec10db79c64055237a4099cf9931e71
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-elem-as-type.ts
@@ -0,0 +1,10 @@
+var arr: number[] = [7, 4, 5, 9, 2, 8, 1, 6, 3];
+var sum: number = 0;
+var i;
+var len;
+(i = 0), (len = arr.length);
+for (; i < len; ++i) {
+  var x = arr[i] as number;
+  sum += x;
+}
+console.log(sum);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-elem-as-type.ts.result b/src/MapleFE/test/typescript/unit_tests/array-elem-as-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f173498338d57b001c80dd07f7ad73761857096d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-elem-as-type.ts.result
@@ -0,0 +1,27 @@
+Matched 27 tokens.
+Matched 34 tokens.
+Matched 37 tokens.
+Matched 40 tokens.
+Matched 54 tokens.
+Matched 80 tokens.
+Matched 87 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[7,4,5,9,2,8,1,6,3]
+== Sub Tree ==
+js_var Decl: sum=0
+== Sub Tree ==
+js_var Decl: i
+== Sub Tree ==
+js_var Decl: len
+== Sub Tree ==
+i Assign 0
+== Sub Tree ==
+len Assign arr.length
+== Sub Tree ==
+for ( )
+  js_var Decl: x=arr[i]
+  sum AddAssign x
+
+== Sub Tree ==
+console.log(sum)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-elem-casting.ts b/src/MapleFE/test/typescript/unit_tests/array-elem-casting.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4b31f0e78b75023a77b181744e1f62ba023e066a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-elem-casting.ts
@@ -0,0 +1,21 @@
+class Base {
+  str: string;
+  constructor(s: string) { this.str = s; }
+}
+
+class Derived extends Base {
+  num: number;
+  constructor(s: string, n: number) { super(s); this.num = n; } 
+}
+
+function func(...args: Base[]): Derived {
+  if (args.length === 1 && args[0] instanceof Derived) {
+    return <Derived>args[0];
+  }
+  return { str: "Unkown", num: 0 }; 
+}
+
+var b: Base = new Base("Base");
+console.log(func(b));
+var d: Derived = new Derived("Derived", 123);
+console.log(func(d));
diff --git a/src/MapleFE/test/typescript/unit_tests/array-elem-casting.ts.result b/src/MapleFE/test/typescript/unit_tests/array-elem-casting.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..59337de3cda4b0b4191755eb8c7aaba2e86ea13e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-elem-casting.ts.result
@@ -0,0 +1,50 @@
+Matched 22 tokens.
+Matched 55 tokens.
+Matched 106 tokens.
+Matched 117 tokens.
+Matched 127 tokens.
+Matched 140 tokens.
+Matched 150 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Base
+  Fields: 
+    str
+  Instance Initializer: 
+  Constructors: 
+    constructor  (s)  throws: 
+      this.str Assign s
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Derived
+  Fields: 
+    num
+  Instance Initializer: 
+  Constructors: 
+    constructor  (s,n)  throws: 
+      super(s)
+      this.num Assign n
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func(...args)  throws: 
+  cond-branch cond:args.length StEq 1 Land args[0] instanceof Derived
+  true branch :
+    return (Derived)args[0]
+  false branch :
+
+  return  {str:"Unkown", num:0}
+
+== Sub Tree ==
+js_var Decl: b=new Base("Base")
+== Sub Tree ==
+console.log(func(b))
+== Sub Tree ==
+js_var Decl: d=new Derived("Derived",123)
+== Sub Tree ==
+console.log(func(d))
diff --git a/src/MapleFE/test/typescript/unit_tests/array-in-ctor.ts b/src/MapleFE/test/typescript/unit_tests/array-in-ctor.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b07b07525bb2d8d56c392da58000ff3701fcc84b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-in-ctor.ts
@@ -0,0 +1,19 @@
+class Klass {
+  data: any;
+  constructor() {
+    {
+      this.data = [
+        new Array(123, 456)
+      ];
+    }
+  }
+  public dump (value: number) {
+    switch (value) {
+      case 1:
+        console.log(value, this.data);
+    }
+  }
+}
+
+let obj: Klass = new Klass();
+obj.dump(1);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-in-ctor.ts.result b/src/MapleFE/test/typescript/unit_tests/array-in-ctor.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c8d8cb19b4ad241057695b6f79d93fe33c3625ad
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-in-ctor.ts.result
@@ -0,0 +1,24 @@
+Matched 58 tokens.
+Matched 68 tokens.
+Matched 75 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    data
+  Instance Initializer: 
+  Constructors: 
+    constructor  ()  throws: 
+      this.data Assign [new Array(123,456)]
+
+  Methods: 
+    func  dump(value)  throws: 
+      A switch
+
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: obj=new Klass()
+== Sub Tree ==
+obj.dump(1)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-keyof.ts b/src/MapleFE/test/typescript/unit_tests/array-keyof.ts
new file mode 100644
index 0000000000000000000000000000000000000000..73934390e2193181394511892587acaeeb1d0425
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-keyof.ts
@@ -0,0 +1 @@
+export declare type Type<T> = { t: Array<keyof T | [keyof T, any]>; };
diff --git a/src/MapleFE/test/typescript/unit_tests/array-keyof.ts.result b/src/MapleFE/test/typescript/unit_tests/array-keyof.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ba0b4104c0a161528b642857ea94a2561245f387
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-keyof.ts.result
@@ -0,0 +1,4 @@
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare  type Type<T> =  {t }} 
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal.ts b/src/MapleFE/test/typescript/unit_tests/array-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a2b8c3d09d56a2057504ee21541a7e3d414cca2a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal.ts
@@ -0,0 +1,2 @@
+var arr: number[] = [Math.ceil(5 / 3)];
+console.log(arr);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..bc92f1cb5f4257ee738e4d02aa35e34deb011554
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal.ts.result
@@ -0,0 +1,7 @@
+Matched 18 tokens.
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[Math.ceil(5 Div 3)]
+== Sub Tree ==
+console.log(arr)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal10.ts b/src/MapleFE/test/typescript/unit_tests/array-literal10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..03553ff2a936d7103bab8a77bae243fc6f70900a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal10.ts
@@ -0,0 +1,23 @@
+class Foo {
+  [key: string]: number;
+  public f1: number = 0;
+  private f2: number = 0;
+  constructor(a: number, b: number) {
+    this.f1 = a;
+    this.f2 = b;
+  }
+}
+var funcs = [
+  function func(): Foo {
+    console.log("Returning a new object");
+    return new Foo(789, 0);
+  },
+];
+var obj: Foo | undefined = undefined;
+var i: number = 1;
+var res: number = (obj || funcs[0]())[`f${i}`];
+console.log(res);
+obj = new Foo(123, 456);
+++i;
+res = (obj || funcs[0]())[`f${i}`];
+console.log(res);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal10.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal10.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..759ae8eefbf133e6fd24499b4449484476c3c410
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal10.ts.result
@@ -0,0 +1,47 @@
+Matched 50 tokens.
+Matched 81 tokens.
+Matched 90 tokens.
+Matched 97 tokens.
+Matched 116 tokens.
+Matched 123 tokens.
+Matched 133 tokens.
+Matched 136 tokens.
+Matched 152 tokens.
+Matched 159 tokens.
+Matched 160 tokens.
+Matched 161 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    number    f1=0    f2=0
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.f1 Assign a
+      this.f2 Assign b
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: funcs=[func  func()  throws: 
+  console.log("Returning a new object")
+  return new Foo(789,0)
+]
+== Sub Tree ==
+js_var Decl: obj=undefined
+== Sub Tree ==
+js_var Decl: i=1
+== Sub Tree ==
+js_var Decl: res=obj Lor funcs[0]()[ template-literal: "f",i]
+== Sub Tree ==
+console.log(res)
+== Sub Tree ==
+obj Assign new Foo(123,456)
+== Sub Tree ==
+PreInc i
+== Sub Tree ==
+res Assign obj Lor funcs[0]()[ template-literal: "f",i]
+== Sub Tree ==
+console.log(res)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal11.ts b/src/MapleFE/test/typescript/unit_tests/array-literal11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b6381be5e07c99952d7fb382738ea71b72d29f4c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal11.ts
@@ -0,0 +1,7 @@
+enum Direction {
+  LEFT,
+  RIGHT,
+}
+
+const rec = [true ? Direction.LEFT : Direction.RIGHT];
+console.log(rec);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal11.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal11.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a863b9610058f07b873ae3f4e747ccaccd0cc05c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal11.ts.result
@@ -0,0 +1,10 @@
+Matched 8 tokens.
+Matched 23 tokens.
+Matched 30 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: Direction {LEFT;RIGHT }
+== Sub Tree ==
+js_const Decl: rec=[true ? Direction.LEFT : Direction.RIGHT]
+== Sub Tree ==
+console.log(rec)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal2.ts b/src/MapleFE/test/typescript/unit_tests/array-literal2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..76f552860cd11ba7e0aa23d919045491b7c1b1f8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal2.ts
@@ -0,0 +1,3 @@
+var arr: number[] = [1, 2, 3];
+arr = [9, arr[2], arr[1]];
+console.log(arr);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal2.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..bca281e730440eca5ee46297f21f163cb920a0d7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal2.ts.result
@@ -0,0 +1,10 @@
+Matched 15 tokens.
+Matched 31 tokens.
+Matched 38 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[1,2,3]
+== Sub Tree ==
+arr Assign [9,arr[2],arr[1]]
+== Sub Tree ==
+console.log(arr)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal3.ts b/src/MapleFE/test/typescript/unit_tests/array-literal3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4322acdc44cb19d6289d1fc5ab9ef574f7ce4c46
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal3.ts
@@ -0,0 +1,3 @@
+var _2 = 0;
+this["_2"] = 22;
+console.log(this["_2"]);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal3.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..38a609320e0d7402555c34ffc5ee0df7b0d6999a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal3.ts.result
@@ -0,0 +1,10 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: _2=0
+== Sub Tree ==
+this["_2"] Assign 22
+== Sub Tree ==
+console.log(this["_2"])
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal4.ts b/src/MapleFE/test/typescript/unit_tests/array-literal4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8ea00dcf819bf765a527e7eaed054eda0f623933
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal4.ts
@@ -0,0 +1,7 @@
+enum E {
+  LEFT = "left",
+  RIGHT = "right",
+}
+
+var arr: E[] = [E.LEFT, E.RIGHT];
+console.log(arr);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal4.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ff97cb533540cb4a98ea44cff7951289d5f8506e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal4.ts.result
@@ -0,0 +1,10 @@
+Matched 12 tokens.
+Matched 29 tokens.
+Matched 36 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: E {LEFT="left";RIGHT="right" }
+== Sub Tree ==
+js_var Decl: arr=[E.LEFT,E.RIGHT]
+== Sub Tree ==
+console.log(arr)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal5.ts b/src/MapleFE/test/typescript/unit_tests/array-literal5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c92f992fd391cc6347b5376be7f2f14e11ac02e0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal5.ts
@@ -0,0 +1,7 @@
+enum Direction {
+  LEFT,
+  RIGHT,
+}
+
+const rec = [Direction.LEFT, Direction.RIGHT];
+console.log(rec);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal5.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..fcba11dd60be145c61ad30095c8b87323b16e6c0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal5.ts.result
@@ -0,0 +1,10 @@
+Matched 8 tokens.
+Matched 21 tokens.
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: Direction {LEFT;RIGHT }
+== Sub Tree ==
+js_const Decl: rec=[Direction.LEFT,Direction.RIGHT]
+== Sub Tree ==
+console.log(rec)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal6.ts b/src/MapleFE/test/typescript/unit_tests/array-literal6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7c221537c71678f56557feda48bf07e667b1cdc4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal6.ts
@@ -0,0 +1,3 @@
+var i = 10;
+var face = [0, i + 1, i + 2];
+console.log(face);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal6.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal6.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..92c4549e714868a092af165169005f6c4fc85f63
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal6.ts.result
@@ -0,0 +1,10 @@
+Matched 5 tokens.
+Matched 20 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: i=10
+== Sub Tree ==
+js_var Decl: face=[0,i Add 1,i Add 2]
+== Sub Tree ==
+console.log(face)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal7.ts b/src/MapleFE/test/typescript/unit_tests/array-literal7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..42358e48c70aadc11d7bf9f5d786dcb1ea65f0ef
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal7.ts
@@ -0,0 +1,11 @@
+const arr: (() => void)[] = [
+  () => {
+    console.log("Lambda0");
+  },
+  () => {
+    console.log("Lambda1");
+  },
+];
+console.log(arr);
+arr[0]();
+arr[1]();
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal7.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal7.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4cf433c3c169d9e2ec8f63929edd281582bf5651
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal7.ts.result
@@ -0,0 +1,15 @@
+Matched 41 tokens.
+Matched 48 tokens.
+Matched 55 tokens.
+Matched 62 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: arr=[() -> console.log("Lambda0")
+,() -> console.log("Lambda1")
+]
+== Sub Tree ==
+console.log(arr)
+== Sub Tree ==
+arr[0]()
+== Sub Tree ==
+arr[1]()
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal8.ts b/src/MapleFE/test/typescript/unit_tests/array-literal8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d64691ed229ff2b4d7cd5bdc4c2526cb251c9fea
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal8.ts
@@ -0,0 +1,3 @@
+var i = 10;
+var face = [0, i - 2, -i];
+console.log(face);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal8.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal8.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3f249815bd52fe43ab00d43a493ce98c4ee89601
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal8.ts.result
@@ -0,0 +1,10 @@
+Matched 5 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: i=10
+== Sub Tree ==
+js_var Decl: face=[0,i Sub 2,Minus i]
+== Sub Tree ==
+console.log(face)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal9.ts b/src/MapleFE/test/typescript/unit_tests/array-literal9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2837536a26a0ae85f63a05ca0c96b2582e867dc4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal9.ts
@@ -0,0 +1,21 @@
+class Foo {
+  [key: string]: number;
+  public f1: number = 0;
+  private f2: number = 0;
+  constructor(a: number, b: number) {
+    this.f1 = a;
+    this.f2 = b;
+  }
+}
+function func(): Foo {
+  console.log("Returning a new object");
+  return new Foo(789, 0);
+}
+var obj: Foo | undefined = undefined;
+var i: number = 1;
+var res: number = (obj || func())[`f${i}`];
+console.log(res);
+obj = new Foo(123, 456);
+++i;
+res = (obj || func())[`f${i}`];
+console.log(res);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-literal9.ts.result b/src/MapleFE/test/typescript/unit_tests/array-literal9.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a0665e2795510928f1805094a2424ac4bd05ecb0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-literal9.ts.result
@@ -0,0 +1,47 @@
+Matched 50 tokens.
+Matched 74 tokens.
+Matched 83 tokens.
+Matched 90 tokens.
+Matched 106 tokens.
+Matched 113 tokens.
+Matched 123 tokens.
+Matched 126 tokens.
+Matched 139 tokens.
+Matched 146 tokens.
+Matched 147 tokens.
+Matched 148 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    number    f1=0    f2=0
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.f1 Assign a
+      this.f2 Assign b
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func()  throws: 
+  console.log("Returning a new object")
+  return new Foo(789,0)
+
+== Sub Tree ==
+js_var Decl: obj=undefined
+== Sub Tree ==
+js_var Decl: i=1
+== Sub Tree ==
+js_var Decl: res=obj Lor func()[ template-literal: "f",i]
+== Sub Tree ==
+console.log(res)
+== Sub Tree ==
+obj Assign new Foo(123,456)
+== Sub Tree ==
+PreInc i
+== Sub Tree ==
+res Assign obj Lor func()[ template-literal: "f",i]
+== Sub Tree ==
+console.log(res)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-multi-dims.ts b/src/MapleFE/test/typescript/unit_tests/array-multi-dims.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc36afe28914bc6577aba29b1498360c045fdff1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-multi-dims.ts
@@ -0,0 +1,7 @@
+const arr = [
+  [4, 9, 2],
+  [3, 5, 7],
+  [8, 1, 6],
+];
+console.log(arr[0][0] + arr[1][1] + arr[2][2]);
+console.log(arr[0][2] + arr[1][1] + arr[2][0]);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-multi-dims.ts.result b/src/MapleFE/test/typescript/unit_tests/array-multi-dims.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2fba0af866e109ed8ee7e50a7715ae0442c2eb1f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-multi-dims.ts.result
@@ -0,0 +1,10 @@
+Matched 30 tokens.
+Matched 59 tokens.
+Matched 88 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: arr=[[4,9,2],[3,5,7],[8,1,6]]
+== Sub Tree ==
+console.log(arr[0][0] Add arr[1][1] Add arr[2][2])
+== Sub Tree ==
+console.log(arr[0][2] Add arr[1][1] Add arr[2][0])
diff --git a/src/MapleFE/test/typescript/unit_tests/array-multi-dims2.ts b/src/MapleFE/test/typescript/unit_tests/array-multi-dims2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4b2f295fd5204dd0c1672a8f9c40d052207b4692
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-multi-dims2.ts
@@ -0,0 +1,6 @@
+const arr = [
+  [4, 9, 2],
+  [3, 5, 7],
+  [8, 1, 6],
+];
+console.log(arr[0][0] + 1);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-multi-dims2.ts.result b/src/MapleFE/test/typescript/unit_tests/array-multi-dims2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..28342ba99577fba4f8fef191c59f343d1da9f9bf
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-multi-dims2.ts.result
@@ -0,0 +1,7 @@
+Matched 30 tokens.
+Matched 45 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: arr=[[4,9,2],[3,5,7],[8,1,6]]
+== Sub Tree ==
+console.log(arr[0][0] Add 1)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-new-elem.ts b/src/MapleFE/test/typescript/unit_tests/array-new-elem.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ab299a77f92d3d6c3e4141044a00470ab297e051
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-new-elem.ts
@@ -0,0 +1,2 @@
+var arr: Object[] = [new Object(), new Object()];
+console.log(arr);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-new-elem.ts.result b/src/MapleFE/test/typescript/unit_tests/array-new-elem.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..39fdc1a6f79b334c411d27613f4cc237bb4e62fb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-new-elem.ts.result
@@ -0,0 +1,7 @@
+Matched 19 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[new Object(),new Object()]
+== Sub Tree ==
+console.log(arr)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-object.ts b/src/MapleFE/test/typescript/unit_tests/array-object.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f77faff98b2a8f58e9ef3ce91447da273ec2b552
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-object.ts
@@ -0,0 +1,6 @@
+function func(arg: any) {
+  console.log(arg);
+}
+func([ [`Number`, { type: Number, count: 1, }],
+       [`String`, { type: String, count: 2, }],
+     ] as Array<[ name: string, value: any, ]>);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-object.ts.result b/src/MapleFE/test/typescript/unit_tests/array-object.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..93c56af98019afa2b9f3410874718c9c9b1f9dfb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-object.ts.result
@@ -0,0 +1,9 @@
+Matched 16 tokens.
+Matched 66 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(arg)  throws: 
+  console.log(arg)
+
+== Sub Tree ==
+func([[ template-literal: "Number",NULL, {type:Number, count:1}],[ template-literal: "String",NULL, {type:String, count:2}]])
diff --git a/src/MapleFE/test/typescript/unit_tests/array-typeof.ts b/src/MapleFE/test/typescript/unit_tests/array-typeof.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6a0bf0f58983e8d4ddf5ea627f39aad87a1100c3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-typeof.ts
@@ -0,0 +1,5 @@
+class VType {}
+class V2 extends VType {s: string = "abc"}
+class V3 extends VType {n: number = 123}
+
+const BuiltinVTypes: typeof VType[] = [V2, V3];
diff --git a/src/MapleFE/test/typescript/unit_tests/array-typeof.ts.result b/src/MapleFE/test/typescript/unit_tests/array-typeof.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2619a263e550753b67d5adfd0a498975b6f8cff9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-typeof.ts.result
@@ -0,0 +1,37 @@
+Matched 4 tokens.
+Matched 15 tokens.
+Matched 26 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+class  VType
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  V2
+  Fields: 
+    s="abc"
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  V3
+  Fields: 
+    n=123
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_const Decl: BuiltinVTypes=[V2,V3]
diff --git a/src/MapleFE/test/typescript/unit_tests/array-with-any.ts b/src/MapleFE/test/typescript/unit_tests/array-with-any.ts
new file mode 100644
index 0000000000000000000000000000000000000000..978def01bdb8a14df648564e58a162029c58ffe1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-with-any.ts
@@ -0,0 +1,6 @@
+class Klass {
+  protected n: Map<string, (...args: any[any]) => void> = new Map();
+}
+
+var obj: Klass = new Klass();
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-with-any.ts.result b/src/MapleFE/test/typescript/unit_tests/array-with-any.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..68721240385785d491d4a00636796bcb8492764a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-with-any.ts.result
@@ -0,0 +1,18 @@
+Matched 29 tokens.
+Matched 39 tokens.
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    n=new Map()
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/array-with-template-literal.ts b/src/MapleFE/test/typescript/unit_tests/array-with-template-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..34c66adddf4f8080f2ae08229dc6fb2870fd5fe5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-with-template-literal.ts
@@ -0,0 +1,2 @@
+var arr = [null, [`template literal`, null] as unknown as (Array<string> | null)[]];
+console.log(arr);
diff --git a/src/MapleFE/test/typescript/unit_tests/array-with-template-literal.ts.result b/src/MapleFE/test/typescript/unit_tests/array-with-template-literal.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..95703f0d9280e671aec08b05ca33a88c33696189
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/array-with-template-literal.ts.result
@@ -0,0 +1,7 @@
+Matched 26 tokens.
+Matched 33 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[null,[ template-literal: "template literal",NULL,null]]
+== Sub Tree ==
+console.log(arr)
diff --git a/src/MapleFE/test/typescript/unit_tests/arrow-func.ts b/src/MapleFE/test/typescript/unit_tests/arrow-func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..187f525abab4d92014240b72687e3d5692db660d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/arrow-func.ts
@@ -0,0 +1,5 @@
+let f1 = (x: number): number => {
+  return x / 3;
+};
+let f2 = (x: number): number => x / 3;
+console.log(f1(6), f2(9));
diff --git a/src/MapleFE/test/typescript/unit_tests/arrow-func.ts.result b/src/MapleFE/test/typescript/unit_tests/arrow-func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..414e71ab055ea3bcb572cfab1e8f4836ced30d42
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/arrow-func.ts.result
@@ -0,0 +1,11 @@
+Matched 19 tokens.
+Matched 34 tokens.
+Matched 49 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: f1=(x) -> return x Div 3
+
+== Sub Tree ==
+js_let Decl: f2=(x) -> x Div 3
+== Sub Tree ==
+console.log(f1(6),f2(9))
diff --git a/src/MapleFE/test/typescript/unit_tests/as-any.ts b/src/MapleFE/test/typescript/unit_tests/as-any.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f8a7913ef1fa1febe692064759b7bce4a10f34c8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-any.ts
@@ -0,0 +1,5 @@
+function func() {
+  return { list: [1, 2, 3] };
+}
+let s = func().list as any;
+console.log(s);
diff --git a/src/MapleFE/test/typescript/unit_tests/as-any.ts.result b/src/MapleFE/test/typescript/unit_tests/as-any.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..55b43f4ae642cdb62f7e204b6b6de20327205967
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-any.ts.result
@@ -0,0 +1,12 @@
+Matched 19 tokens.
+Matched 30 tokens.
+Matched 37 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+  return  {list:[1,2,3]}
+
+== Sub Tree ==
+js_let Decl: s=func().list
+== Sub Tree ==
+console.log(s)
diff --git a/src/MapleFE/test/typescript/unit_tests/as-const.ts b/src/MapleFE/test/typescript/unit_tests/as-const.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a2929ff44bf7ee07757023c317692bcb32f387c0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-const.ts
@@ -0,0 +1,2 @@
+let s = "abc" as const;
+console.log(s);
diff --git a/src/MapleFE/test/typescript/unit_tests/as-const.ts.result b/src/MapleFE/test/typescript/unit_tests/as-const.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..99ca9082fab295b78836515677a59c2b1cd77aae
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-const.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 14 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: s="abc"
+== Sub Tree ==
+console.log(s)
diff --git a/src/MapleFE/test/typescript/unit_tests/as-const2.ts b/src/MapleFE/test/typescript/unit_tests/as-const2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a434946630930b4a7f4c856a45b7ba576b4354e7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-const2.ts
@@ -0,0 +1,5 @@
+enum Color {
+  Blue = "blue",
+}
+let s = Color.Blue as const;
+console.log(s);
diff --git a/src/MapleFE/test/typescript/unit_tests/as-const2.ts.result b/src/MapleFE/test/typescript/unit_tests/as-const2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5dd5949f6656a05ee1df9f073e4949398ac96472
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-const2.ts.result
@@ -0,0 +1,10 @@
+Matched 8 tokens.
+Matched 17 tokens.
+Matched 24 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: Color {Blue="blue" }
+== Sub Tree ==
+js_let Decl: s=Color.Blue
+== Sub Tree ==
+console.log(s)
diff --git a/src/MapleFE/test/typescript/unit_tests/as-const3.ts b/src/MapleFE/test/typescript/unit_tests/as-const3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49781c19f481bdeb0b76af2dbb190320ef45e8e2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-const3.ts
@@ -0,0 +1,5 @@
+enum Color {
+  Blue = "blue",
+}
+const s = (Color.Blue) as const;
+console.log(s);
diff --git a/src/MapleFE/test/typescript/unit_tests/as-const3.ts.result b/src/MapleFE/test/typescript/unit_tests/as-const3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c6224047ba7ca9528a6274e8f06df7188ff37917
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-const3.ts.result
@@ -0,0 +1,10 @@
+Matched 8 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: Color {Blue="blue" }
+== Sub Tree ==
+js_const Decl: s=Color.Blue
+== Sub Tree ==
+console.log(s)
diff --git a/src/MapleFE/test/typescript/unit_tests/as-function-type.ts b/src/MapleFE/test/typescript/unit_tests/as-function-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..31ec2a2235020ea85ff759517ff7c5bb31e958bd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-function-type.ts
@@ -0,0 +1,12 @@
+function func(cb: (s: string) => number): string {
+  console.log(cb("abc"));
+  return "OK";
+}
+
+var fn = function (s: string): number {
+  console.log(s);
+  return 123;
+};
+
+const f = func(fn as (s: string) => number);
+console.log(f);
diff --git a/src/MapleFE/test/typescript/unit_tests/as-function-type.ts.result b/src/MapleFE/test/typescript/unit_tests/as-function-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..45dce72dc6432c23a4d5673651c5c6bf964b315a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-function-type.ts.result
@@ -0,0 +1,19 @@
+Matched 30 tokens.
+Matched 54 tokens.
+Matched 70 tokens.
+Matched 77 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(cb)  throws: 
+  console.log(cb("abc"))
+  return "OK"
+
+== Sub Tree ==
+js_var Decl: fn=func  (s)  throws: 
+  console.log(s)
+  return 123
+
+== Sub Tree ==
+js_const Decl: f=func(fn)
+== Sub Tree ==
+console.log(f)
diff --git a/src/MapleFE/test/typescript/unit_tests/as-namespace.d.ts b/src/MapleFE/test/typescript/unit_tests/as-namespace.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0a893306950046bc266722e31af034a505fda3b4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-namespace.d.ts
@@ -0,0 +1,6 @@
+// Proposal: export as namespace for UMD module output
+// https://github.com/microsoft/TypeScript/issues/26532
+
+// https://www.typescriptlang.org/docs/handbook/modules.html#umd-modules
+export var x: number;
+export as namespace NS;
diff --git a/src/MapleFE/test/typescript/unit_tests/as-namespace.d.ts.result b/src/MapleFE/test/typescript/unit_tests/as-namespace.d.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..819b72b7c97e7689470604c34869967973d67359
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/as-namespace.d.ts.result
@@ -0,0 +1,7 @@
+Matched 6 tokens.
+Matched 11 tokens.
+============= Module ===========
+== Sub Tree ==
+export {js_var Decl: x} 
+== Sub Tree ==
+export {NS} 
diff --git a/src/MapleFE/test/typescript/unit_tests/ascii_escape.ts b/src/MapleFE/test/typescript/unit_tests/ascii_escape.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4976e247f6f5b188ed972d25e592b9fb486e055e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ascii_escape.ts
@@ -0,0 +1 @@
+var x = "\\\n\"'\b\f\r";
diff --git a/src/MapleFE/test/typescript/unit_tests/ascii_escape.ts.result b/src/MapleFE/test/typescript/unit_tests/ascii_escape.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a031f7282aff0e7c32eed9ee8194e37174775a2f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ascii_escape.ts.result
@@ -0,0 +1,4 @@
+Matched 5 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x="\\\n\"'\b\f\r"
diff --git a/src/MapleFE/test/typescript/unit_tests/asserts-condition.ts b/src/MapleFE/test/typescript/unit_tests/asserts-condition.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a382744e5bf8716d4bf4cf64b06015e2015ec6fc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/asserts-condition.ts
@@ -0,0 +1,8 @@
+function nonNullable<T>(e: T): asserts e is NonNullable<T> {
+  if (e === null || e === undefined) throw new Error("Assertion failure");
+  console.log("nonNullable", e);
+}
+
+class Klass {}
+var obj: Klass = new Klass();
+nonNullable<Klass>(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/asserts-condition.ts.result b/src/MapleFE/test/typescript/unit_tests/asserts-condition.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..09373fda959de25aab57ea0b472794c7dad8d8f5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/asserts-condition.ts.result
@@ -0,0 +1,28 @@
+Matched 46 tokens.
+Matched 50 tokens.
+Matched 60 tokens.
+Matched 68 tokens.
+============= Module ===========
+== Sub Tree ==
+func  nonNullable<T>(e) : assert e is NonNullable<T> :   throws: 
+  cond-branch cond:e StEq null Lor e StEq undefined
+  true branch :
+    throw new Error("Assertion failure")
+  false branch :
+
+  console.log("nonNullable",e)
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+nonNullable<Klass>(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/assign-quotes.ts b/src/MapleFE/test/typescript/unit_tests/assign-quotes.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2e8bd5285e81cd8f2b2a6ef418b2c89a56dd93b2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/assign-quotes.ts
@@ -0,0 +1,4 @@
+var foo;
+if (foo === "") {
+  foo = '""';
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/assign-quotes.ts.result b/src/MapleFE/test/typescript/unit_tests/assign-quotes.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a9c2370b68c52f084740b2416a1e806a9582c386
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/assign-quotes.ts.result
@@ -0,0 +1,11 @@
+Matched 3 tokens.
+Matched 15 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: foo
+== Sub Tree ==
+cond-branch cond:foo StEq ""
+true branch :
+  foo Assign """"
+false branch :
+
diff --git a/src/MapleFE/test/typescript/unit_tests/async-function.ts b/src/MapleFE/test/typescript/unit_tests/async-function.ts
new file mode 100644
index 0000000000000000000000000000000000000000..09efbe49be53e3795f87c17e3cd3314dd711d65f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/async-function.ts
@@ -0,0 +1,8 @@
+async function func() {
+  return "done";
+}
+
+(async () => {
+    const val = await func();
+    console.log(val);
+})();
diff --git a/src/MapleFE/test/typescript/unit_tests/async-function.ts.result b/src/MapleFE/test/typescript/unit_tests/async-function.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..942cc2667a90d02078203623716deec0f37a0833
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/async-function.ts.result
@@ -0,0 +1,11 @@
+Matched 10 tokens.
+Matched 36 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+  return "done"
+
+== Sub Tree ==
+() -> js_const Decl: val= await func()
+console.log(val)
+()
diff --git a/src/MapleFE/test/typescript/unit_tests/async-in-literal.ts b/src/MapleFE/test/typescript/unit_tests/async-in-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..18c4e2fd48a8fd2629aade8ffda24995ff018043
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/async-in-literal.ts
@@ -0,0 +1,9 @@
+function func() {
+  return {
+    async message() {
+      return "done";
+    },
+  };
+}
+
+console.log(func().message());
diff --git a/src/MapleFE/test/typescript/unit_tests/async-in-literal.ts.result b/src/MapleFE/test/typescript/unit_tests/async-in-literal.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e514d99fc30f5e9e56102068be896253d426bfe7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/async-in-literal.ts.result
@@ -0,0 +1,11 @@
+Matched 20 tokens.
+Matched 33 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+  return  {message:func  message()  throws: 
+  return "done"
+}
+
+== Sub Tree ==
+console.log(func().message())
diff --git a/src/MapleFE/test/typescript/unit_tests/await-import.ts b/src/MapleFE/test/typescript/unit_tests/await-import.ts
new file mode 100644
index 0000000000000000000000000000000000000000..47ea73929177b224e463a6d08a1566e23bc489da
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/await-import.ts
@@ -0,0 +1,6 @@
+(async () => {
+  const { default: myX, getx, setx } = await import("./M");  
+  console.log(myX, getx());
+  setx(3);
+  console.log(myX, getx());
+})();
diff --git a/src/MapleFE/test/typescript/unit_tests/await-import.ts.result b/src/MapleFE/test/typescript/unit_tests/await-import.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3fa7f89a3b3ae1d4bc56d6399820055735a04bb0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/await-import.ts.result
@@ -0,0 +1,8 @@
+Matched 55 tokens.
+============= Module ===========
+== Sub Tree ==
+() -> js_const Decl: {default:myX, :getx, :setx}
+console.log(myX,getx())
+setx(3)
+console.log(myX,getx())
+()
diff --git a/src/MapleFE/test/typescript/unit_tests/bin-op-scoped.ts b/src/MapleFE/test/typescript/unit_tests/bin-op-scoped.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7f3f85714803e399e2fd2a8810a5dd1698cda9bb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/bin-op-scoped.ts
@@ -0,0 +1,35 @@
+var a: number = 1;
+
+var b: number = 1;
+
+var c: number;
+
+c = a + b;
+
+c = a - b;
+
+c = a * b;
+
+c = a / b;
+
+c = a % b;
+
+{
+  // Should generate a BlockNode here
+
+  let a: number = 2;
+
+  let b: number = 2;
+
+  let c: number;
+
+  c = a + b;
+
+  c = a - b;
+
+  c = a * b;
+
+  c = a / b;
+
+  c = a % b;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/bin-op-scoped.ts.result b/src/MapleFE/test/typescript/unit_tests/bin-op-scoped.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5a9d4b024703c0e882b626088bc56d6a8c700ed7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/bin-op-scoped.ts.result
@@ -0,0 +1,36 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 19 tokens.
+Matched 25 tokens.
+Matched 31 tokens.
+Matched 37 tokens.
+Matched 43 tokens.
+Matched 49 tokens.
+Matched 100 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: a=1
+== Sub Tree ==
+js_var Decl: b=1
+== Sub Tree ==
+js_var Decl: c
+== Sub Tree ==
+c Assign a Add b
+== Sub Tree ==
+c Assign a Sub b
+== Sub Tree ==
+c Assign a Mul b
+== Sub Tree ==
+c Assign a Div b
+== Sub Tree ==
+c Assign a Mod b
+== Sub Tree ==
+js_let Decl: a=2
+js_let Decl: b=2
+js_let Decl: c
+c Assign a Add b
+c Assign a Sub b
+c Assign a Mul b
+c Assign a Div b
+c Assign a Mod b
+
diff --git a/src/MapleFE/test/typescript/unit_tests/bin_op.ts b/src/MapleFE/test/typescript/unit_tests/bin_op.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ab73727295fca09696bf5b480045c8a00b55f182
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/bin_op.ts
@@ -0,0 +1,14 @@
+var a: number = 1;
+var b: number = 1;
+var c: number;
+c = a + b;
+c = a - b;
+c = a * b;
+c = a / b;
+c = a % b;
+c = a >> b;
+c = a << b;
+c = a >>> b;
+var d: boolean;
+d = a < b;
+d = a <= b;
diff --git a/src/MapleFE/test/typescript/unit_tests/bin_op.ts.result b/src/MapleFE/test/typescript/unit_tests/bin_op.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..226184c6a19aab5d26cb953227cb9d0a8f8e8412
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/bin_op.ts.result
@@ -0,0 +1,43 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 19 tokens.
+Matched 25 tokens.
+Matched 31 tokens.
+Matched 37 tokens.
+Matched 43 tokens.
+Matched 49 tokens.
+Matched 55 tokens.
+Matched 61 tokens.
+Matched 67 tokens.
+Matched 72 tokens.
+Matched 78 tokens.
+Matched 84 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: a=1
+== Sub Tree ==
+js_var Decl: b=1
+== Sub Tree ==
+js_var Decl: c
+== Sub Tree ==
+c Assign a Add b
+== Sub Tree ==
+c Assign a Sub b
+== Sub Tree ==
+c Assign a Mul b
+== Sub Tree ==
+c Assign a Div b
+== Sub Tree ==
+c Assign a Mod b
+== Sub Tree ==
+c Assign a Shr b
+== Sub Tree ==
+c Assign a Shl b
+== Sub Tree ==
+c Assign a Zext b
+== Sub Tree ==
+js_var Decl: d
+== Sub Tree ==
+d Assign a LT b
+== Sub Tree ==
+d Assign a LE b
diff --git a/src/MapleFE/test/typescript/unit_tests/binary-search.ts b/src/MapleFE/test/typescript/unit_tests/binary-search.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9aaa1bcdf814d86e74c691eb2509c42c7a641244
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/binary-search.ts
@@ -0,0 +1,19 @@
+function binarySearch(array: number[], value: number): number {
+  var low: number = 0;
+  var high: number = array.length - 1;
+  var mid: number = high >>> 1;
+  for (; low <= high; mid = (low + high) >>> 1) {
+    const test = array[mid];
+    if (test > value) {
+      high = mid - 1;
+    } else if (test < value) {
+      low = mid + 1;
+    } else {
+      return mid;
+    }
+  }
+  return ~low;
+}
+
+var sequence: number[] = [13, 21, 34, 55, 89, 144];
+console.log(binarySearch(sequence, 144));
diff --git a/src/MapleFE/test/typescript/unit_tests/binary-search.ts.result b/src/MapleFE/test/typescript/unit_tests/binary-search.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6303a4639f9eb62830475cb37afca3416c35ef61
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/binary-search.ts.result
@@ -0,0 +1,28 @@
+Matched 110 tokens.
+Matched 131 tokens.
+Matched 143 tokens.
+============= Module ===========
+== Sub Tree ==
+func  binarySearch(array,value)  throws: 
+  js_var Decl: low=0
+  js_var Decl: high=array.length Sub 1
+  js_var Decl: mid=high Zext 1
+  for ( )
+    js_const Decl: test=array[mid]
+    cond-branch cond:test GT value
+    true branch :
+      high Assign mid Sub 1
+    false branch :
+      cond-branch cond:test LT value
+      true branch :
+        low Assign mid Add 1
+      false branch :
+        return mid
+
+
+  return Bcomp low
+
+== Sub Tree ==
+js_var Decl: sequence=[13,21,34,55,89,144]
+== Sub Tree ==
+console.log(binarySearch(sequence,144))
diff --git a/src/MapleFE/test/typescript/unit_tests/binding-pattern.ts b/src/MapleFE/test/typescript/unit_tests/binding-pattern.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4abf0710d4ed9f6e32463c43667e6749a0c12439
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/binding-pattern.ts
@@ -0,0 +1,7 @@
+interface IFace {
+    Num: number;
+    Str: string;
+}
+
+declare const func: ({ Num: num, Str: str }?: IFace) => boolean;
+export { IFace, func };
diff --git a/src/MapleFE/test/typescript/unit_tests/binding-pattern.ts.result b/src/MapleFE/test/typescript/unit_tests/binding-pattern.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7e28023e40ee9f1e1371f29d4cf9afe4ba4e96b4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/binding-pattern.ts.result
@@ -0,0 +1,10 @@
+Matched 12 tokens.
+Matched 33 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {Num;Str }
+== Sub Tree ==
+declare js_const Decl: func
+== Sub Tree ==
+export {IFace,func} 
diff --git a/src/MapleFE/test/typescript/unit_tests/bracket-notation.ts b/src/MapleFE/test/typescript/unit_tests/bracket-notation.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3da12ff7cd3217233b81605cacc55312b0c49dfd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/bracket-notation.ts
@@ -0,0 +1,7 @@
+interface Foo {
+  [key: string]: number;
+}
+
+let bar: Foo = {};
+bar["key1"] = 1;
+console.log(bar["key1"]);
diff --git a/src/MapleFE/test/typescript/unit_tests/bracket-notation.ts.result b/src/MapleFE/test/typescript/unit_tests/bracket-notation.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cf441e4309529b1a2ec0cf8efc52ca2ebe835eed
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/bracket-notation.ts.result
@@ -0,0 +1,13 @@
+Matched 12 tokens.
+Matched 20 tokens.
+Matched 27 tokens.
+Matched 37 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Foo {string index type: number }
+== Sub Tree ==
+js_let Decl: bar= {}
+== Sub Tree ==
+bar["key1"] Assign 1
+== Sub Tree ==
+console.log(bar["key1"])
diff --git a/src/MapleFE/test/typescript/unit_tests/call-array-ctor.ts b/src/MapleFE/test/typescript/unit_tests/call-array-ctor.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c4524f59b731e58903b4a953e86d37606959f8a2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/call-array-ctor.ts
@@ -0,0 +1,3 @@
+var obj1: string[] = Array("first", "second", "third");
+var obj2: string[] = new Array("1", "2", "3");
+console.log(obj1, obj2);
diff --git a/src/MapleFE/test/typescript/unit_tests/call-array-ctor.ts.result b/src/MapleFE/test/typescript/unit_tests/call-array-ctor.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..285f106fa9963fafb9cfe99e55064ea2ba56f600
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/call-array-ctor.ts.result
@@ -0,0 +1,10 @@
+Matched 16 tokens.
+Matched 33 tokens.
+Matched 42 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: obj1=Array("first","second","third")
+== Sub Tree ==
+js_var Decl: obj2=new Array("1","2","3")
+== Sub Tree ==
+console.log(obj1,obj2)
diff --git a/src/MapleFE/test/typescript/unit_tests/call-func.ts b/src/MapleFE/test/typescript/unit_tests/call-func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d18e988373d9cb1bd9207a5cb4470d09e7c15178
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/call-func.ts
@@ -0,0 +1,12 @@
+function func(o: Object): Object {
+  return o;
+}
+
+class Klass {
+  [key: string]: number;
+  x: number = 123;
+}
+
+var obj: Klass = { x: 1 };
+(func(obj) as Klass)["x"] = 2;
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/call-func.ts.result b/src/MapleFE/test/typescript/unit_tests/call-func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4d0e7c34ab048b4fc85ac6d6364d8de83f674076
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/call-func.ts.result
@@ -0,0 +1,26 @@
+Matched 14 tokens.
+Matched 32 tokens.
+Matched 43 tokens.
+Matched 57 tokens.
+Matched 64 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(o)  throws: 
+  return o
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+    number    x=123
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj= {x:1}
+== Sub Tree ==
+func(obj)["x"] Assign 2
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/car.ts b/src/MapleFE/test/typescript/unit_tests/car.ts
new file mode 100644
index 0000000000000000000000000000000000000000..26410d7987d970e5b10bd076e335deac66c1cdc7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/car.ts
@@ -0,0 +1,13 @@
+class Vehicle {
+  name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
+}
+class Car extends Vehicle {
+  constructor(name: string) {
+    super(name);
+  }
+}
+let car: Car = new Car("A car");
+console.log(car.name);
diff --git a/src/MapleFE/test/typescript/unit_tests/car.ts.result b/src/MapleFE/test/typescript/unit_tests/car.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..79f120f5d1e290e03d2c08da60bf10d809446024
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/car.ts.result
@@ -0,0 +1,33 @@
+Matched 22 tokens.
+Matched 41 tokens.
+Matched 52 tokens.
+Matched 61 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Vehicle
+  Fields: 
+    name
+  Instance Initializer: 
+  Constructors: 
+    constructor  (name)  throws: 
+      this.name Assign name
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Car
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+    constructor  (name)  throws: 
+      super(name)
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: car=new Car("A car")
+== Sub Tree ==
+console.log(car.name)
diff --git a/src/MapleFE/test/typescript/unit_tests/casting-with-generic-type.ts b/src/MapleFE/test/typescript/unit_tests/casting-with-generic-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c9652eaecfce913e0a55bd1599962ba08cdd069c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/casting-with-generic-type.ts
@@ -0,0 +1,3 @@
+function func<T>(f: Function) {
+  return <() => Array<T>>f;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/casting-with-generic-type.ts.result b/src/MapleFE/test/typescript/unit_tests/casting-with-generic-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..26122598b2a01c577e7f6caf04b546b75110b997
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/casting-with-generic-type.ts.result
@@ -0,0 +1,6 @@
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func<T>(f)  throws: 
+  return (() -> )f
+
diff --git a/src/MapleFE/test/typescript/unit_tests/class-deco.ts b/src/MapleFE/test/typescript/unit_tests/class-deco.ts
new file mode 100644
index 0000000000000000000000000000000000000000..93c2869d1ebe1ddc870ccccab38b3f25f4beeafc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-deco.ts
@@ -0,0 +1,6 @@
+function class_deco(ctor: Function): void {
+  console.log("Class constructor is :", ctor);
+}
+@class_deco
+class Klass {}
+var o = new Klass();
diff --git a/src/MapleFE/test/typescript/unit_tests/class-deco.ts.result b/src/MapleFE/test/typescript/unit_tests/class-deco.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ed9f8b106b87edfb0c302c2bd35a5213fdb7d672
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-deco.ts.result
@@ -0,0 +1,20 @@
+Matched 20 tokens.
+Matched 26 tokens.
+Matched 34 tokens.
+============= Module ===========
+== Sub Tree ==
+func  class_deco(ctor)  throws: 
+  console.log("Class constructor is :",ctor)
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: o=new Klass()
diff --git a/src/MapleFE/test/typescript/unit_tests/class-deco2.ts b/src/MapleFE/test/typescript/unit_tests/class-deco2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fe783cc93145707009fbc1536d5c6080df34efdb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-deco2.ts
@@ -0,0 +1,9 @@
+function class_deco(name: string): Function {
+  function deco(ctor: Function): void {
+    console.log("Class constructor is :", ctor, ", Name is: ", name);
+  }
+  return deco;
+}
+@class_deco("Deco")
+class Klass {}
+var o = new Klass();
diff --git a/src/MapleFE/test/typescript/unit_tests/class-deco2.ts.result b/src/MapleFE/test/typescript/unit_tests/class-deco2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..626101c9d23cbb6d5100f514d28e81e4966f7709
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-deco2.ts.result
@@ -0,0 +1,23 @@
+Matched 38 tokens.
+Matched 47 tokens.
+Matched 55 tokens.
+============= Module ===========
+== Sub Tree ==
+func  class_deco(name)  throws: 
+  func  deco(ctor)  throws: 
+    console.log("Class constructor is :",ctor,", Name is: ",name)
+
+  return deco
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: o=new Klass()
diff --git a/src/MapleFE/test/typescript/unit_tests/class-deco3.ts b/src/MapleFE/test/typescript/unit_tests/class-deco3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e599b2155c6c1712aafee180d57f2582731cba9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-deco3.ts
@@ -0,0 +1,29 @@
+function class_deco(name: string): Function {
+  function deco(ctor: Function): void {
+    console.log("Class constructor is :", ctor, ", Name is: ", name);
+  }
+  return deco;
+}
+
+@class_deco('Klass')
+class Klass {
+  data: any = null;
+  public setData(value: any) {
+    this.data= [
+      {
+        n: value,
+      },
+    ];
+  }
+
+  public dump (value: number) {
+    switch (value) {
+      case 1:
+        console.log(value, this.data);
+    }
+  }
+}
+
+let obj: Klass = new Klass();
+obj.setData(123);
+obj.dump(1);
diff --git a/src/MapleFE/test/typescript/unit_tests/class-deco3.ts.result b/src/MapleFE/test/typescript/unit_tests/class-deco3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d150e86876fa5ca48788a0859c9f42299389c81c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-deco3.ts.result
@@ -0,0 +1,34 @@
+Matched 38 tokens.
+Matched 105 tokens.
+Matched 115 tokens.
+Matched 122 tokens.
+Matched 129 tokens.
+============= Module ===========
+== Sub Tree ==
+func  class_deco(name)  throws: 
+  func  deco(ctor)  throws: 
+    console.log("Class constructor is :",ctor,", Name is: ",name)
+
+  return deco
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+    data=null
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  setData(value)  throws: 
+      this.data Assign [ {n:value}]
+    func  dump(value)  throws: 
+      A switch
+
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: obj=new Klass()
+== Sub Tree ==
+obj.setData(123)
+== Sub Tree ==
+obj.dump(1)
diff --git a/src/MapleFE/test/typescript/unit_tests/class-deco4.ts b/src/MapleFE/test/typescript/unit_tests/class-deco4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9174fb8079897328c8aaf3a4c02bbcb31e156753
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-deco4.ts
@@ -0,0 +1,22 @@
+function class_deco(name: string): Function {
+  function deco(ctor: Function): void {
+    console.log("Class constructor is :", ctor, ", Name is: ", name);
+  }
+  return deco;
+}
+
+@class_deco('Klass')
+class Klass {
+  data:
+    {n: number} = {n : 123};
+
+  public dump (value: number) {
+    switch (value) {
+      case 1:
+        console.log(value, this.data);
+    }
+  }
+}
+
+let obj: Klass = new Klass();
+obj.dump(1);
diff --git a/src/MapleFE/test/typescript/unit_tests/class-deco4.ts.result b/src/MapleFE/test/typescript/unit_tests/class-deco4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b52fdf7351455c144a4bf82ff4623a2dd1db1b91
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-deco4.ts.result
@@ -0,0 +1,29 @@
+Matched 38 tokens.
+Matched 90 tokens.
+Matched 100 tokens.
+Matched 107 tokens.
+============= Module ===========
+== Sub Tree ==
+func  class_deco(name)  throws: 
+  func  deco(ctor)  throws: 
+    console.log("Class constructor is :",ctor,", Name is: ",name)
+
+  return deco
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+    data= {n:123}
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  dump(value)  throws: 
+      A switch
+
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: obj=new Klass()
+== Sub Tree ==
+obj.dump(1)
diff --git a/src/MapleFE/test/typescript/unit_tests/class-direct-fd.ts b/src/MapleFE/test/typescript/unit_tests/class-direct-fd.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f68d085fd6f21b6d5d2cd41575ffc5c00a39dedc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-direct-fd.ts
@@ -0,0 +1,32 @@
+class Foo {
+  public f1: number = 0;
+  public f2: number = 0;
+  constructor(a: number, b: number) {
+    this.f1 = a;
+    this.f2 = b;
+  }
+}
+
+var bar : Foo = {f1:1, f2:2};
+bar.f1    = 3;            // direct dot
+bar["f1"] = 4;            // direct prop
+bar["p1"] = 10;           // prop
+
+bar.f2    = bar.f1;       // direct dot = direct dot
+bar.f2    = bar["f1"];    // direct dot = direct prop
+bar["f1"] = bar["f2"];    // direct prop = direct prop
+bar["f1"] = bar["p1"];    // direct prop = prop
+
+bar["p2"] = bar["f2"];    // prop = direct prop
+bar["p2"] = bar["p1"];    // prop = prop
+bar["p2"] = bar["p2"] >>  bar["p1"];  // (int32_t)(xxx)  = yyy >> zzz
+bar["p2"] = bar["p2"] >>> bar["p1"];  // (uint32_t)(xxx) = yyy >> zzz
+
+
+console.log(bar.f1);
+console.log(bar.f2);
+console.log(bar["f1"]);
+console.log(bar["f2"]);
+console.log(bar["p1"]);
+console.log(bar["p2"]);
+
diff --git a/src/MapleFE/test/typescript/unit_tests/class-direct-fd.ts.result b/src/MapleFE/test/typescript/unit_tests/class-direct-fd.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1863507c9b01e410acbaafa80ad19103ce446590
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-direct-fd.ts.result
@@ -0,0 +1,69 @@
+Matched 42 tokens.
+Matched 57 tokens.
+Matched 63 tokens.
+Matched 70 tokens.
+Matched 77 tokens.
+Matched 85 tokens.
+Matched 94 tokens.
+Matched 104 tokens.
+Matched 114 tokens.
+Matched 124 tokens.
+Matched 134 tokens.
+Matched 149 tokens.
+Matched 164 tokens.
+Matched 173 tokens.
+Matched 182 tokens.
+Matched 192 tokens.
+Matched 202 tokens.
+Matched 212 tokens.
+Matched 222 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    f1=0    f2=0
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.f1 Assign a
+      this.f2 Assign b
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: bar= {f1:1, f2:2}
+== Sub Tree ==
+bar.f1 Assign 3
+== Sub Tree ==
+bar["f1"] Assign 4
+== Sub Tree ==
+bar["p1"] Assign 10
+== Sub Tree ==
+bar.f2 Assign bar.f1
+== Sub Tree ==
+bar.f2 Assign bar["f1"]
+== Sub Tree ==
+bar["f1"] Assign bar["f2"]
+== Sub Tree ==
+bar["f1"] Assign bar["p1"]
+== Sub Tree ==
+bar["p2"] Assign bar["f2"]
+== Sub Tree ==
+bar["p2"] Assign bar["p1"]
+== Sub Tree ==
+bar["p2"] Assign bar["p2"] Shr bar["p1"]
+== Sub Tree ==
+bar["p2"] Assign bar["p2"] Zext bar["p1"]
+== Sub Tree ==
+console.log(bar.f1)
+== Sub Tree ==
+console.log(bar.f2)
+== Sub Tree ==
+console.log(bar["f1"])
+== Sub Tree ==
+console.log(bar["f2"])
+== Sub Tree ==
+console.log(bar["p1"])
+== Sub Tree ==
+console.log(bar["p2"])
diff --git a/src/MapleFE/test/typescript/unit_tests/class-extends.ts b/src/MapleFE/test/typescript/unit_tests/class-extends.ts
new file mode 100644
index 0000000000000000000000000000000000000000..176d1555e8b04bf5a36576c675ed0b9dc541cfa5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-extends.ts
@@ -0,0 +1,23 @@
+class Car {
+  private _make: string;
+  constructor(make: string) {
+    this._make = make;
+  }
+  public getMake(): string {
+    return this._make;
+  }
+}
+
+class Model extends Car {
+  private _model: string;
+  constructor(make: string, model: string) {
+    super(make);
+    this._model = model;
+  }
+  public getModel(): string {
+    return this._model;
+  }
+}
+
+let passat: Model = new Model("VW", "Passat");
+console.log(passat.getMake(), passat.getModel());
diff --git a/src/MapleFE/test/typescript/unit_tests/class-extends.ts.result b/src/MapleFE/test/typescript/unit_tests/class-extends.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..194818d19c823c5616d1de1765403897d2f8f277
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-extends.ts.result
@@ -0,0 +1,38 @@
+Matched 36 tokens.
+Matched 83 tokens.
+Matched 96 tokens.
+Matched 113 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Car
+  Fields: 
+    _make
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make)  throws: 
+      this._make Assign make
+  Methods: 
+    func  getMake()  throws: 
+      return this._make
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Model
+  Fields: 
+    _model
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make,model)  throws: 
+      super(make)
+      this._model Assign model
+  Methods: 
+    func  getModel()  throws: 
+      return this._model
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: passat=new Model("VW","Passat")
+== Sub Tree ==
+console.log(passat.getMake(),passat.getModel())
diff --git a/src/MapleFE/test/typescript/unit_tests/class-extends2.ts b/src/MapleFE/test/typescript/unit_tests/class-extends2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ae538bf8cfdfab1c4fc94e3500908224f81b982f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-extends2.ts
@@ -0,0 +1,23 @@
+class Car {
+  private _make: string;
+  constructor(make: string) {
+    this._make = make;
+  }
+  public getMake(): string {
+    return this._make;
+  }
+}
+
+class Model extends Car {
+  private _model: string;
+  constructor(make: string, model: string) {
+    super(make);
+    this._model = super.getMake() + model;
+  }
+  public getModel(): string {
+    return this._model;
+  }
+}
+
+let passat: Model = new Model("VW", "Passat");
+console.log(passat.getMake(), passat.getModel());
diff --git a/src/MapleFE/test/typescript/unit_tests/class-extends2.ts.result b/src/MapleFE/test/typescript/unit_tests/class-extends2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2ad27f7c11b90658965008e57e37cefcd85e8d61
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-extends2.ts.result
@@ -0,0 +1,38 @@
+Matched 36 tokens.
+Matched 89 tokens.
+Matched 102 tokens.
+Matched 119 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Car
+  Fields: 
+    _make
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make)  throws: 
+      this._make Assign make
+  Methods: 
+    func  getMake()  throws: 
+      return this._make
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Model
+  Fields: 
+    _model
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make,model)  throws: 
+      super(make)
+      this._model Assign super.getMake() Add model
+  Methods: 
+    func  getModel()  throws: 
+      return this._model
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: passat=new Model("VW","Passat")
+== Sub Tree ==
+console.log(passat.getMake(),passat.getModel())
diff --git a/src/MapleFE/test/typescript/unit_tests/class-extends3.ts b/src/MapleFE/test/typescript/unit_tests/class-extends3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..356bf07792ee304fab0458f781062929096a0044
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-extends3.ts
@@ -0,0 +1,22 @@
+class Car {
+  private _make: string;
+  constructor(make: string) {
+    this._make = make;
+  }
+  public getMake(): string {
+    return this._make;
+  }
+}
+
+class Model extends Car {
+  private _model: string;
+  constructor(make: string, model: string) {
+    super(make) this._model = super.getMake() + model;
+  }
+  public getModel(): string {
+    return this._model;
+  }
+}
+
+let passat: Model = new Model("VW", "Passat");
+console.log(passat.getMake(), passat.getModel());
diff --git a/src/MapleFE/test/typescript/unit_tests/class-extends3.ts.result b/src/MapleFE/test/typescript/unit_tests/class-extends3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5368fc30da365058f5d1934d73ee3dfecd5b2e61
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-extends3.ts.result
@@ -0,0 +1,38 @@
+Matched 36 tokens.
+Matched 88 tokens.
+Matched 101 tokens.
+Matched 118 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Car
+  Fields: 
+    _make
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make)  throws: 
+      this._make Assign make
+  Methods: 
+    func  getMake()  throws: 
+      return this._make
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Model
+  Fields: 
+    _model
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make,model)  throws: 
+      super(make)
+      this._model Assign super.getMake() Add model
+  Methods: 
+    func  getModel()  throws: 
+      return this._model
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: passat=new Model("VW","Passat")
+== Sub Tree ==
+console.log(passat.getMake(),passat.getModel())
diff --git a/src/MapleFE/test/typescript/unit_tests/class-generics-arrowfunc.ts b/src/MapleFE/test/typescript/unit_tests/class-generics-arrowfunc.ts
new file mode 100644
index 0000000000000000000000000000000000000000..28f611a4e94a9086fa416f9e52208c49078a3b3e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-generics-arrowfunc.ts
@@ -0,0 +1,25 @@
+// Class with generics and arrow function.
+// - Class constructor takes a function as parameter and saves it.
+// - The saved function allocates and return an object with generics type.
+// - Class method alloc() calls the saved function to allocate and return an obj.
+class Foo<T> {
+  private _ctor: () => T;
+
+  constructor(ctor: () => T) {
+    this._ctor = ctor;
+  }
+
+  public alloc(): T {
+    return this._ctor();
+  }
+}
+
+// Create class object with String type
+// - Create class object with type String
+// - Pass an arrow function (that returns a new String object) to the class constructor
+const FooString: Foo<String> = new Foo<String>(() => new String("foo"));
+
+// Optional check.
+// - Call alloc() of new class object to get a new object and
+// - call the object's builtin toString() method to display it.
+console.log(FooString.alloc().toString());
diff --git a/src/MapleFE/test/typescript/unit_tests/class-generics-arrowfunc.ts.result b/src/MapleFE/test/typescript/unit_tests/class-generics-arrowfunc.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a83ce45d57efe59786174ed01db3b6b11892246d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-generics-arrowfunc.ts.result
@@ -0,0 +1,22 @@
+Matched 47 tokens.
+Matched 71 tokens.
+Matched 86 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+<T,>  Fields: 
+    _ctor
+  Instance Initializer: 
+  Constructors: 
+    constructor  (ctor)  throws: 
+      this._ctor Assign ctor
+  Methods: 
+    func  alloc()  throws: 
+      return this._ctor()
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_const Decl: FooString=new Foo(() -> new String("foo"))
+== Sub Tree ==
+console.log(FooString.alloc().toString())
diff --git a/src/MapleFE/test/typescript/unit_tests/class-implements-interface.ts b/src/MapleFE/test/typescript/unit_tests/class-implements-interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d4bf9e97f3cdf069f9b9f72a96eb4731d4ff5dec
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-implements-interface.ts
@@ -0,0 +1,5 @@
+interface Intf1 {}
+class C1 implements Intf1 {}
+
+interface Intf2<T> {}
+class C2<T> implements Intf2<T> {}
diff --git a/src/MapleFE/test/typescript/unit_tests/class-implements-interface.ts.result b/src/MapleFE/test/typescript/unit_tests/class-implements-interface.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..89303989da48c640f2cfedff34ca4d1addec4ac6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-implements-interface.ts.result
@@ -0,0 +1,29 @@
+Matched 4 tokens.
+Matched 10 tokens.
+Matched 17 tokens.
+Matched 29 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Intf1 { }
+== Sub Tree ==
+class  C1
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+ts_interface: Intf2<T,> { }
+== Sub Tree ==
+class  C2
+<T,>  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/class-in-func.ts b/src/MapleFE/test/typescript/unit_tests/class-in-func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..42a5e9634d166e994c1f1cf10812e8ca70dd2ff5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-in-func.ts
@@ -0,0 +1,6 @@
+function func(): Function {
+  class Car {}
+  return Car;
+}
+console.log(func());
+
diff --git a/src/MapleFE/test/typescript/unit_tests/class-in-func.ts.result b/src/MapleFE/test/typescript/unit_tests/class-in-func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..382cdd5a0ba7c0731a823653f9643b9f4658cfce
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-in-func.ts.result
@@ -0,0 +1,18 @@
+Matched 15 tokens.
+Matched 24 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+  class  Car
+    Fields: 
+
+    Instance Initializer: 
+    Constructors: 
+    Methods: 
+    LocalClasses: 
+    LocalInterfaces: 
+
+  return Car
+
+== Sub Tree ==
+console.log(func())
diff --git a/src/MapleFE/test/typescript/unit_tests/class-type.ts b/src/MapleFE/test/typescript/unit_tests/class-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..af4104977e7dbab267736e405600e69122dd892f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-type.ts
@@ -0,0 +1,2 @@
+console.log(typeof new (class {}));
+console.log(new (class {f: number = 123;}));
diff --git a/src/MapleFE/test/typescript/unit_tests/class-type.ts.result b/src/MapleFE/test/typescript/unit_tests/class-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..51e6940208ca513dab8d0f3517c1f9dc23440aee
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class-type.ts.result
@@ -0,0 +1,7 @@
+Matched 13 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log( typeof new ())
+== Sub Tree ==
+console.log(new ())
diff --git a/src/MapleFE/test/typescript/unit_tests/class.ts b/src/MapleFE/test/typescript/unit_tests/class.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6103ec8a6fe6a680ec46e13c950211da090f45bf
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class.ts
@@ -0,0 +1,8 @@
+class Foo {
+  public f1: number = 0;
+  private f2: number = 0;
+  constructor(a: number, b: number) {
+    this.f1 = a;
+    this.f2 = b;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/class.ts.result b/src/MapleFE/test/typescript/unit_tests/class.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..01b7a8b13f627aae8015a633428937e4d1bb71cd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class.ts.result
@@ -0,0 +1,15 @@
+Matched 42 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    f1=0    f2=0
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.f1 Assign a
+      this.f2 Assign b
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/class1.ts b/src/MapleFE/test/typescript/unit_tests/class1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..721b9a69277d69ef5bed73071021c144876645ca
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class1.ts
@@ -0,0 +1,30 @@
+class Bar {
+  public b1: number = 5;
+  public b2: number = 6;
+}
+
+class Foo {
+  public f1: number = 0;
+  public f2: number = 0;
+  public bar: Bar;
+  constructor(a: number, b: number) {
+    this.f1 = a;
+    this.f2 = b;
+    this.bar= new Bar();
+  }
+}
+
+class App {
+  public foo: Foo;
+  constructor(a: number, b: number) {
+    this.foo = new Foo(a, b);
+  }
+}
+
+var foo: Foo = new Foo(1, 2);
+console.log(foo);
+
+var app: App = new App(3, 4);
+console.log(app);
+
+
diff --git a/src/MapleFE/test/typescript/unit_tests/class1.ts.result b/src/MapleFE/test/typescript/unit_tests/class1.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..42cfac29ee3fbb55d509d9712f3490e3438b7e71
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class1.ts.result
@@ -0,0 +1,52 @@
+Matched 18 tokens.
+Matched 74 tokens.
+Matched 107 tokens.
+Matched 120 tokens.
+Matched 127 tokens.
+Matched 140 tokens.
+Matched 147 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Bar
+  Fields: 
+    b1=5    b2=6
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Foo
+  Fields: 
+    f1=0    f2=0    bar
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.f1 Assign a
+      this.f2 Assign b
+      this.bar Assign new Bar()
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  App
+  Fields: 
+    foo
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.foo Assign new Foo(a,b)
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: foo=new Foo(1,2)
+== Sub Tree ==
+console.log(foo)
+== Sub Tree ==
+js_var Decl: app=new App(3,4)
+== Sub Tree ==
+console.log(app)
diff --git a/src/MapleFE/test/typescript/unit_tests/class2.ts b/src/MapleFE/test/typescript/unit_tests/class2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cef2e430e977d30ec47fa8da745e5329873b0f71
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class2.ts
@@ -0,0 +1,15 @@
+class Klass {}
+class Foo {
+  public f1: number = 0;
+  private f2: number = 0;
+  constructor(a: number, b: number) {
+    this.f1 = a;
+    this.f2 = b;
+  }
+  public static test(obj: unknown): obj is Klass {
+    return obj instanceof Klass;
+  }
+}
+
+var obj: Klass = new Klass();
+console.log(Foo.test(obj));
diff --git a/src/MapleFE/test/typescript/unit_tests/class2.ts.result b/src/MapleFE/test/typescript/unit_tests/class2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cc2dbc1ecfa7502adae0f99f43a7a19c8d2944da
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class2.ts.result
@@ -0,0 +1,34 @@
+Matched 4 tokens.
+Matched 65 tokens.
+Matched 75 tokens.
+Matched 87 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Foo
+  Fields: 
+    f1=0    f2=0
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.f1 Assign a
+      this.f2 Assign b
+  Methods: 
+    func  test(obj)  throws: 
+      return obj instanceof Klass
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(Foo.test(obj))
diff --git a/src/MapleFE/test/typescript/unit_tests/class3.ts b/src/MapleFE/test/typescript/unit_tests/class3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9b2b79c39f13cdb9b6c9dca8454420dccb7a4052
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class3.ts
@@ -0,0 +1,11 @@
+class Foo {
+  public out: number = 0;
+  public in: number = 0;
+  constructor(a: number, b: number) {
+    this.out = a;
+    this.in = b;
+  }
+}
+
+var obj: Foo = new Foo(12, 34);
+console.log(obj.in);
diff --git a/src/MapleFE/test/typescript/unit_tests/class3.ts.result b/src/MapleFE/test/typescript/unit_tests/class3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a659f6a71e5e584e1a54c9b0e6b15f07b065d60d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class3.ts.result
@@ -0,0 +1,21 @@
+Matched 42 tokens.
+Matched 55 tokens.
+Matched 64 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    out=0    in=0
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.out Assign a
+      this.in Assign b
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Foo(12,34)
+== Sub Tree ==
+console.log(obj.in)
diff --git a/src/MapleFE/test/typescript/unit_tests/class4.ts b/src/MapleFE/test/typescript/unit_tests/class4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f9aea57360141cf48427de02147514af1aaff5ec
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class4.ts
@@ -0,0 +1,12 @@
+class Foo {
+  public s: string;
+  constructor(f: (args?: [d: string, i: string], obj?: string) => string) {
+    this.s = f();
+  }
+}
+
+function func(args?: [d: string, i: string], obj?: string): string {
+  return "abc";
+}
+var obj: Foo = new Foo(func);
+console.log(obj.s);
diff --git a/src/MapleFE/test/typescript/unit_tests/class4.ts.result b/src/MapleFE/test/typescript/unit_tests/class4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0c805813345d538628820d057ab095d144a32c03
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class4.ts.result
@@ -0,0 +1,25 @@
+Matched 45 tokens.
+Matched 73 tokens.
+Matched 84 tokens.
+Matched 93 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    s
+  Instance Initializer: 
+  Constructors: 
+    constructor  (f)  throws: 
+      this.s Assign f()
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func(args?,obj?)  throws: 
+  return "abc"
+
+== Sub Tree ==
+js_var Decl: obj=new Foo(func)
+== Sub Tree ==
+console.log(obj.s)
diff --git a/src/MapleFE/test/typescript/unit_tests/class5.ts b/src/MapleFE/test/typescript/unit_tests/class5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e6a4413d95e9586a6973e8328f0b1823eedc63b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class5.ts
@@ -0,0 +1,6 @@
+class Klass {
+  public switch: number = 0;
+}
+
+var obj: Klass = new Klass();
+console.log(obj, obj.switch);
diff --git a/src/MapleFE/test/typescript/unit_tests/class5.ts.result b/src/MapleFE/test/typescript/unit_tests/class5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1c10c42ffd7ecc28a2d1728c35432b3c9ebdd502
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class5.ts.result
@@ -0,0 +1,18 @@
+Matched 11 tokens.
+Matched 21 tokens.
+Matched 32 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    switch=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(obj,obj.switch)
diff --git a/src/MapleFE/test/typescript/unit_tests/class6.ts b/src/MapleFE/test/typescript/unit_tests/class6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ad924fc06795ae44aa9fc447ddf7a8480482c9f2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class6.ts
@@ -0,0 +1,20 @@
+class Klass {
+  public num: number = 1;
+  
+  if(n: number): boolean {
+    return this.num == n;
+  }
+
+  try(n: number): void {
+    if(n == this.num)
+      console.log("EQ");
+    else
+      console.log("NE");
+  }
+}
+
+var obj: Klass = new Klass();
+console.log(obj.if(0));
+console.log(obj.if(1));
+obj.try(0);
+obj.try(1);
diff --git a/src/MapleFE/test/typescript/unit_tests/class6.ts.result b/src/MapleFE/test/typescript/unit_tests/class6.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..08a20f91d9cb7bde8eba40afc7635cd73adeb7ca
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/class6.ts.result
@@ -0,0 +1,34 @@
+Matched 61 tokens.
+Matched 71 tokens.
+Matched 83 tokens.
+Matched 95 tokens.
+Matched 102 tokens.
+Matched 109 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    num=1
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  if(n)  throws: 
+      return this.num EQ n
+    func  try(n)  throws: 
+      cond-branch cond:n EQ this.num
+      true branch :
+        console.log("EQ")      false branch :
+        console.log("NE")
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(obj.if(0))
+== Sub Tree ==
+console.log(obj.if(1))
+== Sub Tree ==
+obj.try(0)
+== Sub Tree ==
+obj.try(1)
diff --git a/src/MapleFE/test/typescript/unit_tests/classFactory.ts b/src/MapleFE/test/typescript/unit_tests/classFactory.ts
new file mode 100644
index 0000000000000000000000000000000000000000..08904c0b24442466500662faebd735fff8e1b422
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/classFactory.ts
@@ -0,0 +1,24 @@
+/* 1. class factory */
+
+// Generic constructor interface
+type Constructor<T = {}> = new (...args: any[]) => T;
+
+// A standard interface to be incorporated into all generated classes
+interface someStandardInterface {}
+
+// Class factory that takes a base class and generates a new class with a standard interface
+function ClassFactory<TBase>(
+  base: Constructor<TBase>
+): Constructor<TBase & someStandardInterface> {
+  class GeneratedClass extends (base as unknown as any) {}
+
+  return GeneratedClass as unknown as any;
+}
+
+/* 2. Usage of the class factory */
+
+// A class to be use as base for generating one with some standard interface
+class someBaseClass {}
+
+// A class that uses ClassFactory to generate a new class with standard inteface
+class newClassWithStandardInterface extends ClassFactory(someBaseClass) {}
diff --git a/src/MapleFE/test/typescript/unit_tests/classFactory.ts.result b/src/MapleFE/test/typescript/unit_tests/classFactory.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cce1551435250ee21f4aa440a66ef697e6288c8f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/classFactory.ts.result
@@ -0,0 +1,43 @@
+Matched 21 tokens.
+Matched 25 tokens.
+Matched 66 tokens.
+Matched 70 tokens.
+Matched 79 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Constructor<T=> = new (args) -> 
+== Sub Tree ==
+ts_interface: someStandardInterface { }
+== Sub Tree ==
+func  ClassFactory<TBase>(base)  throws: 
+  class  GeneratedClass
+    Fields: 
+
+    Instance Initializer: 
+    Constructors: 
+    Methods: 
+    LocalClasses: 
+    LocalInterfaces: 
+
+  return GeneratedClass
+
+== Sub Tree ==
+class  someBaseClass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  newClassWithStandardInterface
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/classFactory2.ts b/src/MapleFE/test/typescript/unit_tests/classFactory2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dc4f599ee9ce6c0c27a975d9799aead1a34c61d5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/classFactory2.ts
@@ -0,0 +1,10 @@
+type Constructor<T = {}> = new (...args: any[]) => T;
+interface someStandardInterface {}
+function ClassFactory<TBase>(
+  base: Constructor<TBase>
+): Constructor<TBase & someStandardInterface> {
+  class GeneratedClass extends (base as unknown as any) {}
+  return GeneratedClass as unknown as any;
+}
+class someBaseClass {}
+class newClassWithStandardInterface extends ClassFactory(someBaseClass) {}
diff --git a/src/MapleFE/test/typescript/unit_tests/classFactory2.ts.result b/src/MapleFE/test/typescript/unit_tests/classFactory2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cce1551435250ee21f4aa440a66ef697e6288c8f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/classFactory2.ts.result
@@ -0,0 +1,43 @@
+Matched 21 tokens.
+Matched 25 tokens.
+Matched 66 tokens.
+Matched 70 tokens.
+Matched 79 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Constructor<T=> = new (args) -> 
+== Sub Tree ==
+ts_interface: someStandardInterface { }
+== Sub Tree ==
+func  ClassFactory<TBase>(base)  throws: 
+  class  GeneratedClass
+    Fields: 
+
+    Instance Initializer: 
+    Constructors: 
+    Methods: 
+    LocalClasses: 
+    LocalInterfaces: 
+
+  return GeneratedClass
+
+== Sub Tree ==
+class  someBaseClass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  newClassWithStandardInterface
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/closure-let.ts b/src/MapleFE/test/typescript/unit_tests/closure-let.ts
new file mode 100644
index 0000000000000000000000000000000000000000..50f508b22cac66fa3033165004779f505361ece5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/closure-let.ts
@@ -0,0 +1,12 @@
+let funcs: (() => void)[] = [];
+function initialize() {
+  var msgs: [string, string] = ["Hello", "World"];
+  for (var i = 0; i < msgs.length; i++) {
+    let msg: string = msgs[i];
+    funcs[i] = () => console.log(msg);
+  }
+}
+initialize();
+for (var i = 0; i < funcs.length; i++) {
+  funcs[i]();
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/closure-let.ts.result b/src/MapleFE/test/typescript/unit_tests/closure-let.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..fa793762dcd6d0452eca806758d0436aa4a7cdb3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/closure-let.ts.result
@@ -0,0 +1,21 @@
+Matched 15 tokens.
+Matched 79 tokens.
+Matched 83 tokens.
+Matched 108 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: funcs=[]
+== Sub Tree ==
+func  initialize()  throws: 
+  js_var Decl: msgs=["Hello","World"]
+  for ( )
+    js_let Decl: msg=msgs[i]
+    funcs[i] Assign () -> console.log(msg)
+
+
+== Sub Tree ==
+initialize()
+== Sub Tree ==
+for ( )
+  funcs[i]()
+
diff --git a/src/MapleFE/test/typescript/unit_tests/closure.ts b/src/MapleFE/test/typescript/unit_tests/closure.ts
new file mode 100644
index 0000000000000000000000000000000000000000..880b66a5a31e55ab49992d5bb280290469a6b3e4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/closure.ts
@@ -0,0 +1,17 @@
+var base: number = 10;
+
+function counter(private_count: number): () => number {
+  function increment(): number {
+    private_count += 1;
+    return base + private_count;
+  }
+
+  return increment;
+}
+
+var count: () => number = counter(0);
+console.log(count()); // output: 11
+console.log(count()); // output: 12
+var count2: () => number = counter(100);
+console.log(count2()); // output: 111
+console.log(count2()); // output: 112
diff --git a/src/MapleFE/test/typescript/unit_tests/closure.ts.result b/src/MapleFE/test/typescript/unit_tests/closure.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9672af69ac71c39bf99703d626b268cd38c671f6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/closure.ts.result
@@ -0,0 +1,31 @@
+Matched 7 tokens.
+Matched 41 tokens.
+Matched 54 tokens.
+Matched 63 tokens.
+Matched 72 tokens.
+Matched 85 tokens.
+Matched 94 tokens.
+Matched 103 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: base=10
+== Sub Tree ==
+func  counter(private_count)  throws: 
+  func  increment()  throws: 
+    private_count AddAssign 1
+    return base Add private_count
+
+  return increment
+
+== Sub Tree ==
+js_var Decl: count=counter(0)
+== Sub Tree ==
+console.log(count())
+== Sub Tree ==
+console.log(count())
+== Sub Tree ==
+js_var Decl: count2=counter(100)
+== Sub Tree ==
+console.log(count2())
+== Sub Tree ==
+console.log(count2())
diff --git a/src/MapleFE/test/typescript/unit_tests/comma.ts b/src/MapleFE/test/typescript/unit_tests/comma.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e2da02e7bce092263500ab2019fe72e2aa446074
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/comma.ts
@@ -0,0 +1,9 @@
+var arr: number[] = [7, 4, 5, 9, 2, 8, 1, 6, 3];
+var sum: number = 0;
+var i;
+var len;
+(i = 0), (len = arr.length);
+for (; i < len; ++i) {
+  sum += arr[i];
+}
+console.log(sum);
diff --git a/src/MapleFE/test/typescript/unit_tests/comma.ts.result b/src/MapleFE/test/typescript/unit_tests/comma.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..228d2770b375c7a582b8f79b54951b5234a6b64d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/comma.ts.result
@@ -0,0 +1,26 @@
+Matched 27 tokens.
+Matched 34 tokens.
+Matched 37 tokens.
+Matched 40 tokens.
+Matched 54 tokens.
+Matched 73 tokens.
+Matched 80 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[7,4,5,9,2,8,1,6,3]
+== Sub Tree ==
+js_var Decl: sum=0
+== Sub Tree ==
+js_var Decl: i
+== Sub Tree ==
+js_var Decl: len
+== Sub Tree ==
+i Assign 0
+== Sub Tree ==
+len Assign arr.length
+== Sub Tree ==
+for ( )
+  sum AddAssign arr[i]
+
+== Sub Tree ==
+console.log(sum)
diff --git a/src/MapleFE/test/typescript/unit_tests/comma2.ts b/src/MapleFE/test/typescript/unit_tests/comma2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4aec7822ab8bd4b4c1739d29fbaa0a362929bdc0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/comma2.ts
@@ -0,0 +1,9 @@
+var arr: number[] = [-1, +4, 5, 9, 2, 8, 1, 6, 3];
+var sum: number = 0;
+var i;
+var len;
+(i = 0), (len = arr.length);
+for (; i < len; ++i) {
+  sum += arr[i];
+}
+console.log(sum);
diff --git a/src/MapleFE/test/typescript/unit_tests/comma2.ts.result b/src/MapleFE/test/typescript/unit_tests/comma2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6448754f63ebf97c9d608070aaf46a8fcdc8fa15
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/comma2.ts.result
@@ -0,0 +1,26 @@
+Matched 27 tokens.
+Matched 34 tokens.
+Matched 37 tokens.
+Matched 40 tokens.
+Matched 54 tokens.
+Matched 73 tokens.
+Matched 80 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[-1,4,5,9,2,8,1,6,3]
+== Sub Tree ==
+js_var Decl: sum=0
+== Sub Tree ==
+js_var Decl: i
+== Sub Tree ==
+js_var Decl: len
+== Sub Tree ==
+i Assign 0
+== Sub Tree ==
+len Assign arr.length
+== Sub Tree ==
+for ( )
+  sum AddAssign arr[i]
+
+== Sub Tree ==
+console.log(sum)
diff --git a/src/MapleFE/test/typescript/unit_tests/computed-func-name.ts b/src/MapleFE/test/typescript/unit_tests/computed-func-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56d7ac01ea9c030c8514c9b7511a2cfe3b78c565
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/computed-func-name.ts
@@ -0,0 +1,11 @@
+let prop: string = "foo";
+
+class Klass {
+  [key: string]: () => void;
+  public [prop]() {
+    console.log(prop);
+  }
+}
+
+var obj: Klass = new Klass();
+obj[prop]();
diff --git a/src/MapleFE/test/typescript/unit_tests/computed-func-name.ts.result b/src/MapleFE/test/typescript/unit_tests/computed-func-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..820936de5bffb8298c0271c93bf259163fc7ed80
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/computed-func-name.ts.result
@@ -0,0 +1,23 @@
+Matched 7 tokens.
+Matched 37 tokens.
+Matched 47 tokens.
+Matched 54 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: prop="foo"
+== Sub Tree ==
+class  Klass
+  Fields: 
+    () -> 
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  ()  throws: 
+      console.log(prop)
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj[prop]()
diff --git a/src/MapleFE/test/typescript/unit_tests/computed-func-name2.js.result b/src/MapleFE/test/typescript/unit_tests/computed-func-name2.js.result
new file mode 100644
index 0000000000000000000000000000000000000000..f20041335dcc2d91f460d5dcddf3a16b4830dc12
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/computed-func-name2.js.result
@@ -0,0 +1,38 @@
+Matched 5 tokens.
+Matched 68 tokens.
+Matched 76 tokens.
+Matched 83 tokens.
+Matched 90 tokens.
+Matched 94 tokens.
+Matched 102 tokens.
+Matched 109 tokens.
+Matched 116 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: prop="foo"
+== Sub Tree ==
+js_var Decl: Klass=func  ()  throws: 
+  func  Klass()  throws: 
+
+  Klass.prototype[prop] Assign func  ()  throws: 
+  console.log("prop =",prop)
+
+  Klass.prototype.bar Assign func  ()  throws: 
+  console.log("Function bar()")
+
+  return Klass
+()
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj[prop]()
+== Sub Tree ==
+obj["foo"]()
+== Sub Tree ==
+prop Assign "bar"
+== Sub Tree ==
+js_var Decl: obj2=new Klass()
+== Sub Tree ==
+obj2[prop]()
+== Sub Tree ==
+obj2["foo"]()
diff --git a/src/MapleFE/test/typescript/unit_tests/computed-func-name2.ts b/src/MapleFE/test/typescript/unit_tests/computed-func-name2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..65c6ee4e70f34935d330cc3f9e4cffba10721511
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/computed-func-name2.ts
@@ -0,0 +1,20 @@
+let prop: string = "foo";
+
+class Klass {
+  [key: string]: () => void;
+  public [prop]() {
+    console.log("prop =", prop);
+  }
+  public bar() {
+    console.log("Function bar()");
+  }
+}
+
+var obj: Klass = new Klass();
+obj[prop](); // prop = foo
+obj["foo"](); // prop = foo
+
+prop = "bar";
+var obj2: Klass = new Klass();
+obj2[prop](); // Function bar()
+obj2["foo"](); // prop = bar
diff --git a/src/MapleFE/test/typescript/unit_tests/computed-func-name2.ts.result b/src/MapleFE/test/typescript/unit_tests/computed-func-name2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..59e2da842e36c91ce29d0aca4700b0de56d05c85
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/computed-func-name2.ts.result
@@ -0,0 +1,40 @@
+Matched 7 tokens.
+Matched 52 tokens.
+Matched 62 tokens.
+Matched 69 tokens.
+Matched 76 tokens.
+Matched 80 tokens.
+Matched 90 tokens.
+Matched 97 tokens.
+Matched 104 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: prop="foo"
+== Sub Tree ==
+class  Klass
+  Fields: 
+    () -> 
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  ()  throws: 
+      console.log("prop =",prop)
+    func  bar()  throws: 
+      console.log("Function bar()")
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj[prop]()
+== Sub Tree ==
+obj["foo"]()
+== Sub Tree ==
+prop Assign "bar"
+== Sub Tree ==
+js_var Decl: obj2=new Klass()
+== Sub Tree ==
+obj2[prop]()
+== Sub Tree ==
+obj2["foo"]()
diff --git a/src/MapleFE/test/typescript/unit_tests/computed-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/computed-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..404decc67c4709da9921e7ad00db4c0df0614a50
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/computed-prop-name.ts
@@ -0,0 +1,8 @@
+const prop = "flag";
+
+class Klass {
+  public [prop]?: string = "example";
+}
+
+var obj: Klass = new Klass();
+console.log(obj[prop]);
diff --git a/src/MapleFE/test/typescript/unit_tests/computed-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/computed-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..80ebc2aad4aa944c9902c7df182d0d9181efce22
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/computed-prop-name.ts.result
@@ -0,0 +1,21 @@
+Matched 5 tokens.
+Matched 19 tokens.
+Matched 29 tokens.
+Matched 39 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: prop="flag"
+== Sub Tree ==
+class  Klass
+  Fields: 
+    [prop] : string
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(obj[prop])
diff --git a/src/MapleFE/test/typescript/unit_tests/computed-prop-name2.ts b/src/MapleFE/test/typescript/unit_tests/computed-prop-name2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2c9d4f65e21c5494f015a247023c3b6cb6e13709
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/computed-prop-name2.ts
@@ -0,0 +1,9 @@
+function func() {
+  return {[prop] : "abc" };
+}
+
+var prop: string | number = "my key";
+console.log(func());
+prop = -12.3;
+console.log(func());
+
diff --git a/src/MapleFE/test/typescript/unit_tests/computed-prop-name2.ts.result b/src/MapleFE/test/typescript/unit_tests/computed-prop-name2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..90b354456c6c4b3fa99e322159ab0f783c088cdc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/computed-prop-name2.ts.result
@@ -0,0 +1,18 @@
+Matched 15 tokens.
+Matched 24 tokens.
+Matched 33 tokens.
+Matched 37 tokens.
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+  return  {[prop] : :"abc"}
+
+== Sub Tree ==
+js_var Decl: prop="my key"
+== Sub Tree ==
+console.log(func())
+== Sub Tree ==
+prop Assign -12.3
+== Sub Tree ==
+console.log(func())
diff --git a/src/MapleFE/test/typescript/unit_tests/conditional-type.ts b/src/MapleFE/test/typescript/unit_tests/conditional-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..34aeef2a1635e481bd8ac2a3e85c35e65bcba5bf
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/conditional-type.ts
@@ -0,0 +1,5 @@
+export type X<A extends boolean = false> = A extends true ? any[] : string;
+
+var x: X<true> = [1, 2, 3];
+var y: X = "abc";
+console.log(x, y);
diff --git a/src/MapleFE/test/typescript/unit_tests/conditional-type.ts.result b/src/MapleFE/test/typescript/unit_tests/conditional-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cc85ca05590b18ccc7942827ca9700dcaecf897e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/conditional-type.ts.result
@@ -0,0 +1,13 @@
+Matched 21 tokens.
+Matched 37 tokens.
+Matched 44 tokens.
+Matched 53 tokens.
+============= Module ===========
+== Sub Tree ==
+export { type X<A=> = A extends true ? prim array-TBD : string} 
+== Sub Tree ==
+js_var Decl: x=[1,2,3]
+== Sub Tree ==
+js_var Decl: y="abc"
+== Sub Tree ==
+console.log(x,y)
diff --git a/src/MapleFE/test/typescript/unit_tests/conditional-type2.ts b/src/MapleFE/test/typescript/unit_tests/conditional-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d0e37de5d617f885f8f06d78b54ef1e3db109b30
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/conditional-type2.ts
@@ -0,0 +1 @@
+type Type<B, T> = { [K in keyof B]: B[K] extends T ? never : K };
diff --git a/src/MapleFE/test/typescript/unit_tests/conditional-type2.ts.result b/src/MapleFE/test/typescript/unit_tests/conditional-type2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..486f6911c9ab3a89fc244803614bfbc34bed6212
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/conditional-type2.ts.result
@@ -0,0 +1,4 @@
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Type<B,T> =  {[K in  keyof B] : B[K] extends T ? never : K }
diff --git a/src/MapleFE/test/typescript/unit_tests/conditional-type3.ts b/src/MapleFE/test/typescript/unit_tests/conditional-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5ee4d803b9334354adba4c0e0b0182b124bbe60d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/conditional-type3.ts
@@ -0,0 +1,2 @@
+type Names<T> = { [K in keyof T]: T[K] extends (...args: Array<any>) => any ? K : never; }[keyof T] & string;
+type MyType<T extends {}, M extends Names<Required<T>>> = Required<T>[M] extends (...args: any[]) => any ? string : number;
diff --git a/src/MapleFE/test/typescript/unit_tests/conditional-type3.ts.result b/src/MapleFE/test/typescript/unit_tests/conditional-type3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..916713c050178409e45d488605ab3d378df5f608
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/conditional-type3.ts.result
@@ -0,0 +1,7 @@
+Matched 43 tokens.
+Matched 83 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Names<T> = intersect  =  {[K in  keyof T] : T[K] extends (args) ->  ? K : never }[ keyof T] & string
+== Sub Tree ==
+ type MyType<T,M> = Required<T>[M] extends (args) ->  ? string : number
diff --git a/src/MapleFE/test/typescript/unit_tests/const-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/const-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aae109523dd5f3dfa52d66712606f8607a4e2e9f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/const-as-prop-name.ts
@@ -0,0 +1,3 @@
+interface IFace {
+    const: boolean | null;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/const-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/const-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..fc72ca5a897a23ab14653ae1e49983a10df33626
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/const-as-prop-name.ts.result
@@ -0,0 +1,4 @@
+Matched 10 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {const }
diff --git a/src/MapleFE/test/typescript/unit_tests/construct-signature.ts b/src/MapleFE/test/typescript/unit_tests/construct-signature.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d74e3ed3bba353b2f62117087add916faa578bda
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/construct-signature.ts
@@ -0,0 +1,13 @@
+// https://www.typescriptlang.org/docs/handbook/2/classes.html#abstract-construct-signatures
+// used in cocos creator deserialize.ts
+
+// construct signature using generics
+// This creates a type alias for <T> constructors that takes no arguments
+type T_Ctor<T> = new () => T;
+
+interface I_Class<T> extends T_Ctor<T> {
+  __vals__: string[];
+}
+
+type AnyCtor = T_Ctor<Object>;
+type AnyClass = I_Class<Object>;
diff --git a/src/MapleFE/test/typescript/unit_tests/construct-signature.ts.result b/src/MapleFE/test/typescript/unit_tests/construct-signature.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..716378336f60110d57d3a1d8c2568dd93c4985c4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/construct-signature.ts.result
@@ -0,0 +1,13 @@
+Matched 12 tokens.
+Matched 30 tokens.
+Matched 38 tokens.
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+ type T_Ctor<T> = new () -> 
+== Sub Tree ==
+ts_interface: I_Class<T,> {__vals__ }
+== Sub Tree ==
+ type AnyCtor = T_Ctor<Object>
+== Sub Tree ==
+ type AnyClass = I_Class<Object>
diff --git a/src/MapleFE/test/typescript/unit_tests/constructor-1.ts b/src/MapleFE/test/typescript/unit_tests/constructor-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..637dcf847794cb2d0913102a555b0cc23590715e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/constructor-1.ts
@@ -0,0 +1,11 @@
+// Constructor function for Person objects
+function Person(first, last, age, eye) {
+  this.firstName = first;
+  this.lastName = last;
+  this.age = age;
+  this.eyeColor = eye;
+}
+
+//// Create a Person object
+var myFather = new Person("John", "Doe", 50, "blue");
+console.log(myFather.age);
diff --git a/src/MapleFE/test/typescript/unit_tests/constructor-1.ts.result b/src/MapleFE/test/typescript/unit_tests/constructor-1.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c89f8c461daa73f532e12811afc55542b9cfe116
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/constructor-1.ts.result
@@ -0,0 +1,15 @@
+Matched 37 tokens.
+Matched 52 tokens.
+Matched 61 tokens.
+============= Module ===========
+== Sub Tree ==
+func  Person(first,last,age,eye)  throws: 
+  this.firstName Assign first
+  this.lastName Assign last
+  this.age Assign age
+  this.eyeColor Assign eye
+
+== Sub Tree ==
+js_var Decl: myFather=new Person("John","Doe",50,"blue")
+== Sub Tree ==
+console.log(myFather.age)
diff --git a/src/MapleFE/test/typescript/unit_tests/constructor-prop.ts b/src/MapleFE/test/typescript/unit_tests/constructor-prop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7bb638b9992913d33a374532397cd45f59711c9b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/constructor-prop.ts
@@ -0,0 +1,11 @@
+// object constructor property used in cocos-creator class.ts
+function func() {}
+let f = new func();
+console.log(f.constructor);
+f.constructor.prop1 = 1;
+Object.defineProperty(f.constructor, "prop2", {
+  value: 2,
+  writable: true,
+  enumerable: true,
+});
+console.log(f.constructor);
diff --git a/src/MapleFE/test/typescript/unit_tests/constructor-prop.ts.result b/src/MapleFE/test/typescript/unit_tests/constructor-prop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..56d9cde7d9d948cc2890f1c64d0dc0c4233a8059
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/constructor-prop.ts.result
@@ -0,0 +1,20 @@
+Matched 6 tokens.
+Matched 14 tokens.
+Matched 23 tokens.
+Matched 31 tokens.
+Matched 57 tokens.
+Matched 66 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+
+== Sub Tree ==
+js_let Decl: f=new func()
+== Sub Tree ==
+console.log(f.constructor)
+== Sub Tree ==
+f.constructor.prop1 Assign 1
+== Sub Tree ==
+Object.defineProperty(f.constructor,"prop2", {value:2, writable:true, enumerable:true})
+== Sub Tree ==
+console.log(f.constructor)
diff --git a/src/MapleFE/test/typescript/unit_tests/continue-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/continue-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..871a70a35a3315bab7e1c0c06eb8035f6403a3b0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/continue-as-prop-name.ts
@@ -0,0 +1,3 @@
+interface IFace {
+    continue: string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/continue-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/continue-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..fd863b8f4c7b5e3441bc5eb7169e8eeb8eecc51f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/continue-as-prop-name.ts.result
@@ -0,0 +1,4 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {continue }
diff --git a/src/MapleFE/test/typescript/unit_tests/continue-stmt.ts b/src/MapleFE/test/typescript/unit_tests/continue-stmt.ts
new file mode 100644
index 0000000000000000000000000000000000000000..244d1a8e6ee42a3c7d8038075ab9546a989630f0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/continue-stmt.ts
@@ -0,0 +1,8 @@
+for (var i: number = 1; i < 10; ++i) {
+  if (i < 5) {
+    console.log(i, " is less than 5");
+    continue;
+  }
+  if (i == 8) break;
+  console.log(i, " is greater than 4");
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/continue-stmt.ts.result b/src/MapleFE/test/typescript/unit_tests/continue-stmt.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1bd275e2d03beac414c6c52a7ef469cb4814dbe1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/continue-stmt.ts.result
@@ -0,0 +1,18 @@
+Matched 54 tokens.
+============= Module ===========
+== Sub Tree ==
+for ( )
+  cond-branch cond:i LT 5
+  true branch :
+    console.log(i," is less than 5")
+    continue:
+
+  false branch :
+
+  cond-branch cond:i EQ 8
+  true branch :
+    break:
+  false branch :
+
+  console.log(i," is greater than 4")
+
diff --git a/src/MapleFE/test/typescript/unit_tests/ctor-interface.ts b/src/MapleFE/test/typescript/unit_tests/ctor-interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5a164709fcdbc19a1d481ef07b3de1e13ac54cba
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ctor-interface.ts
@@ -0,0 +1,6 @@
+class Klass {
+  f: number = 123;
+}
+interface KlassConstructor {
+  new (): Klass;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/ctor-interface.ts.result b/src/MapleFE/test/typescript/unit_tests/ctor-interface.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8bd1120216f391c703ae39114e638d66d319d89d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ctor-interface.ts.result
@@ -0,0 +1,16 @@
+Matched 10 tokens.
+Matched 20 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    f=123
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+ts_interface: KlassConstructor {func  ()  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/ctor-signature.ts b/src/MapleFE/test/typescript/unit_tests/ctor-signature.ts
new file mode 100644
index 0000000000000000000000000000000000000000..90c39ba9443c1bee72e1699e6143f40853ca36b0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ctor-signature.ts
@@ -0,0 +1,21 @@
+interface IFace {
+  name: string;
+}
+
+interface ICtor {
+  new(name: string): IFace;
+}
+
+class Car implements IFace {
+  name: string;
+  constructor(n: string) {
+    this.name = n;
+  }
+}
+
+function carFactory(myClass: ICtor, name: string) {
+  return new myClass(name);
+}
+
+let car = carFactory(Car, "myCar");
+console.log(car);
diff --git a/src/MapleFE/test/typescript/unit_tests/ctor-signature.ts.result b/src/MapleFE/test/typescript/unit_tests/ctor-signature.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..931c9a50452fa3eeeff76328cbc63b4a65cbec00
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ctor-signature.ts.result
@@ -0,0 +1,32 @@
+Matched 8 tokens.
+Matched 21 tokens.
+Matched 45 tokens.
+Matched 65 tokens.
+Matched 75 tokens.
+Matched 82 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {name }
+== Sub Tree ==
+ts_interface: ICtor {func  (name)  throws: 
+ }
+== Sub Tree ==
+class  Car
+  Fields: 
+    name
+  Instance Initializer: 
+  Constructors: 
+    constructor  (n)  throws: 
+      this.name Assign n
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  carFactory(myClass,name)  throws: 
+  return new myClass(name)
+
+== Sub Tree ==
+js_let Decl: car=carFactory(Car,"myCar")
+== Sub Tree ==
+console.log(car)
diff --git a/src/MapleFE/test/typescript/unit_tests/ctor-with-function.ts b/src/MapleFE/test/typescript/unit_tests/ctor-with-function.ts
new file mode 100644
index 0000000000000000000000000000000000000000..62f6a90078fb43af2a843e2a91f3380fd0bc23c8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ctor-with-function.ts
@@ -0,0 +1,11 @@
+//const obj = new Pool<IAdditiveLightPass>(() => ({ subModel: null!, passIdx: -1, dynamicOffsets: [], lights: [] }), 16);
+class Klass {
+  func: () => any;
+  num: number;
+  constructor(f: () => any, n: number) {
+    this.func = f;
+    this.num = n;
+  }
+}
+const obj = new Klass(() => ({ n: 1 }), 16);
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/ctor-with-function.ts.result b/src/MapleFE/test/typescript/unit_tests/ctor-with-function.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3a5f7caf3a3e905858b6f3eb3cf55d534f295c90
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ctor-with-function.ts.result
@@ -0,0 +1,21 @@
+Matched 42 tokens.
+Matched 62 tokens.
+Matched 69 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    func    num
+  Instance Initializer: 
+  Constructors: 
+    constructor  (f,n)  throws: 
+      this.func Assign f
+      this.num Assign n
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_const Decl: obj=new Klass(() ->  {n:1},16)
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/ctor-with-function2.ts b/src/MapleFE/test/typescript/unit_tests/ctor-with-function2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d05c98b56d6a49618409cd6042c58978fea10ea3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ctor-with-function2.ts
@@ -0,0 +1,10 @@
+class Klass {
+  func: () => any;
+  num: number;
+  constructor(f: () => any, n: number) {
+    this.func = f;
+    this.num = n;
+  }
+}
+const obj = new Klass(() => { n: 1 }, 16);
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/ctor-with-function2.ts.result b/src/MapleFE/test/typescript/unit_tests/ctor-with-function2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ec43f0446f217e607308eaf652d9b396185b269e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ctor-with-function2.ts.result
@@ -0,0 +1,21 @@
+Matched 42 tokens.
+Matched 60 tokens.
+Matched 67 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    func    num
+  Instance Initializer: 
+  Constructors: 
+    constructor  (f,n)  throws: 
+      this.func Assign f
+      this.num Assign n
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_const Decl: obj=new Klass(() ->  {n:1},16)
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/debugger.ts b/src/MapleFE/test/typescript/unit_tests/debugger.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6131fe0b02277946b4b75a16da0e37a498da8959
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/debugger.ts
@@ -0,0 +1,3 @@
+if (true) {
+  debugger;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/debugger.ts.result b/src/MapleFE/test/typescript/unit_tests/debugger.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8aedf7ee087ab5ddb5ef28cf23a4ff28b5d089a5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/debugger.ts.result
@@ -0,0 +1,8 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+cond-branch cond:true
+true branch :
+  debugger
+false branch :
+
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-class-with-ctor.ts b/src/MapleFE/test/typescript/unit_tests/declare-class-with-ctor.ts
new file mode 100644
index 0000000000000000000000000000000000000000..72198abe66005438467d2f1bc5353b2aeeb465a1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-class-with-ctor.ts
@@ -0,0 +1,8 @@
+declare class Klass {
+  constructor (name: string)
+  name: string;
+}
+declare class Klass2 {
+  constructor (name: string);
+  name: string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-class-with-ctor.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-class-with-ctor.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..36dd5d810502e717caa8e6933edbd9b29e67faa2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-class-with-ctor.ts.result
@@ -0,0 +1,25 @@
+Matched 15 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+declare class  Klass
+  Fields: 
+    name
+  Instance Initializer: 
+  Constructors: 
+    constructor  (name)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+declare class  Klass2
+  Fields: 
+    name
+  Instance Initializer: 
+  Constructors: 
+    constructor  (name)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-class.ts b/src/MapleFE/test/typescript/unit_tests/declare-class.ts
new file mode 100644
index 0000000000000000000000000000000000000000..27a8f6bbd9af48aee64a160e71944ab2155b04a6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-class.ts
@@ -0,0 +1,3 @@
+export declare class Klass {
+  obj: Object;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-class.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-class.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c76ea7abe40e06fe503f4fd97f89177e328b861d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-class.ts.result
@@ -0,0 +1,12 @@
+Matched 10 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare class  Klass
+  Fields: 
+    obj
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-const.ts b/src/MapleFE/test/typescript/unit_tests/declare-const.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7e6a6408d6e237f09d26567cc0a6353e0fcd734f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-const.ts
@@ -0,0 +1 @@
+declare const x: any;
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-const.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-const.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..66fb19511fe51abeb85b400a83ec8720eb9efd82
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-const.ts.result
@@ -0,0 +1,4 @@
+Matched 6 tokens.
+============= Module ===========
+== Sub Tree ==
+declare js_const Decl: x
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-global.ts b/src/MapleFE/test/typescript/unit_tests/declare-global.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7aaeaa55cd472a2f79fbc1b88a9af9415926a914
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-global.ts
@@ -0,0 +1,5 @@
+// declare an interface in the global scope
+declare global {
+  interface IFace { name: string; }
+}
+export var obj: IFace = { name: "abc" };
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-global.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-global.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..83c9e73a4321b788057672bccc87565eacbd3e68
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-global.ts.result
@@ -0,0 +1,7 @@
+Matched 12 tokens.
+Matched 24 tokens.
+============= Module ===========
+== Sub Tree ==
+declare ts_interface: IFace {name }
+== Sub Tree ==
+export {js_var Decl: obj= {name:"abc"}} 
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-global2.ts b/src/MapleFE/test/typescript/unit_tests/declare-global2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ae33b890770a09d1deeb7d5980b37794a9cb074a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-global2.ts
@@ -0,0 +1,6 @@
+export interface IFace { }
+
+declare global {
+  const flag1: boolean;
+  const flag2: boolean;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-global2.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-global2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..28811e1ed540364440cad01e257bf91dedc0ac8a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-global2.ts.result
@@ -0,0 +1,7 @@
+Matched 5 tokens.
+Matched 19 tokens.
+============= Module ===========
+== Sub Tree ==
+export {ts_interface: IFace { }} 
+== Sub Tree ==
+declare js_const Decl: flag1js_const Decl: flag2
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-interface.ts b/src/MapleFE/test/typescript/unit_tests/declare-interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..060b2debb46a0a15920a4e5f29a9dcd5f1f28d5c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-interface.ts
@@ -0,0 +1,4 @@
+declare interface IFace<T> {
+  readonly n: number;
+  [index: number]: T;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-interface.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-interface.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a8cc988e84ff89312aaa153d057346772352ffbe
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-interface.ts.result
@@ -0,0 +1,4 @@
+Matched 21 tokens.
+============= Module ===========
+== Sub Tree ==
+declare ts_interface: IFace<T,> {numeric index type: Tn }
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-module.ts b/src/MapleFE/test/typescript/unit_tests/declare-module.ts
new file mode 100644
index 0000000000000000000000000000000000000000..85bf919ac9bb5130c82f5e667f7b08351e746162
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-module.ts
@@ -0,0 +1,3 @@
+declare module Module {
+  function func(s: string): string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-module.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-module.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..91105793f7e036902b7a378d583bcc2b551d6b02
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-module.ts.result
@@ -0,0 +1,8 @@
+Matched 15 tokens.
+============= Module ===========
+== Sub Tree ==
+declare ============= Module ===========
+== Sub Tree ==
+func  func(s)  throws: 
+
+
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-module2.ts b/src/MapleFE/test/typescript/unit_tests/declare-module2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..be0850e00dc80128aecea7f16248ddf395db0da6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-module2.ts
@@ -0,0 +1,4 @@
+declare module "FuncModule" {
+  const func: () => boolean;
+  export = func;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-module2.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-module2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f033bda5aa548b7d452da14a315493b66c978793
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-module2.ts.result
@@ -0,0 +1,9 @@
+Matched 17 tokens.
+============= Module ===========
+== Sub Tree ==
+declare ============= Module ===========
+== Sub Tree ==
+js_const Decl: func
+== Sub Tree ==
+export { SINGLE func} 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-module3.ts b/src/MapleFE/test/typescript/unit_tests/declare-module3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c637d62d2f948ec9afe5a190f08889e38ec31158
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-module3.ts
@@ -0,0 +1 @@
+declare module "mod/runtime" {}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-module3.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-module3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..de33fd5c99bb131cbcd4bf76152e63a0b73c3e80
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-module3.ts.result
@@ -0,0 +1,5 @@
+Matched 5 tokens.
+============= Module ===========
+== Sub Tree ==
+declare ============= Module ===========
+
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-module4.ts b/src/MapleFE/test/typescript/unit_tests/declare-module4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..931c5ee5519199619f90912bc78c8154bca0b814
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-module4.ts
@@ -0,0 +1,8 @@
+export var x: number;
+declare global {
+    module Module {
+        interface IFace {
+            expect: string;
+        }
+    }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-module4.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-module4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5a444572ab6cbf9a1af96a66f9729b7f5440adc9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-module4.ts.result
@@ -0,0 +1,10 @@
+Matched 6 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+export {js_var Decl: x} 
+== Sub Tree ==
+declare ============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {expect }
+
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-namespace.ts b/src/MapleFE/test/typescript/unit_tests/declare-namespace.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d5204a4e29c0928d15c36a7ded51a62d8264609d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-namespace.ts
@@ -0,0 +1,9 @@
+export function func(opt?: func.Opts) {
+  opt = opt || {};
+}
+
+export declare namespace func {
+  export interface Opts {
+    debug?: boolean;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-namespace.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-namespace.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..eeca548ef01d5c27ef2dda4be85fb6397e5024c7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-namespace.ts.result
@@ -0,0 +1,11 @@
+Matched 20 tokens.
+Matched 36 tokens.
+============= Module ===========
+== Sub Tree ==
+export {func  func(opt?)  throws: 
+  opt Assign opt Lor  {}
+} 
+== Sub Tree ==
+export {declare namespace  func
+  export {ts_interface: Opts {debug? }} 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-namespace2.ts b/src/MapleFE/test/typescript/unit_tests/declare-namespace2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d8d87c5b390936a736cd477c1794dff509f3d231
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-namespace2.ts
@@ -0,0 +1 @@
+declare namespace NS {}
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-namespace2.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-namespace2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..681699f524d5d233a2feff9d5af1adbd54a40427
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-namespace2.ts.result
@@ -0,0 +1,5 @@
+Matched 5 tokens.
+============= Module ===========
+== Sub Tree ==
+declare namespace  NS
+
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-var.ts b/src/MapleFE/test/typescript/unit_tests/declare-var.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bcf2fa2a5ee28208c9c68fb04950c4003b82fcb0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-var.ts
@@ -0,0 +1 @@
+declare var x: number;
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-var.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-var.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..707d1adb0c6a26a07d99595f40cb86d5bd00d667
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-var.ts.result
@@ -0,0 +1,4 @@
+Matched 6 tokens.
+============= Module ===========
+== Sub Tree ==
+declare js_var Decl: x
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-var2.ts b/src/MapleFE/test/typescript/unit_tests/declare-var2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7814fc2d7009074f76edbbcda8d1485b4dda6b21
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-var2.ts
@@ -0,0 +1 @@
+declare var v: JSON;
diff --git a/src/MapleFE/test/typescript/unit_tests/declare-var2.ts.result b/src/MapleFE/test/typescript/unit_tests/declare-var2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..87a5be12d2f9c654e9e232e54d6e857b716f706d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/declare-var2.ts.result
@@ -0,0 +1,4 @@
+Matched 6 tokens.
+============= Module ===========
+== Sub Tree ==
+declare js_var Decl: v
diff --git a/src/MapleFE/test/typescript/unit_tests/deco-module.ts b/src/MapleFE/test/typescript/unit_tests/deco-module.ts
new file mode 100644
index 0000000000000000000000000000000000000000..299de200d618a6e79b5f819d838ac09d006ee326
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/deco-module.ts
@@ -0,0 +1,5 @@
+export function prop_deco(msg: string) {
+  return function (target: any, name: string) {
+    console.log("Accessed", name, msg, target);
+  };
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/deco-module.ts.result b/src/MapleFE/test/typescript/unit_tests/deco-module.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..726b8d368545a27168f9496a7f13290e26d0a749
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/deco-module.ts.result
@@ -0,0 +1,8 @@
+Matched 37 tokens.
+============= Module ===========
+== Sub Tree ==
+export {func  prop_deco(msg)  throws: 
+  return func  (target,name)  throws: 
+  console.log("Accessed",name,msg,target)
+
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/default-prop.ts b/src/MapleFE/test/typescript/unit_tests/default-prop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2f78feb3c49a972a8426ecac3a2f41a050c1cabb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/default-prop.ts
@@ -0,0 +1,4 @@
+const obj = {
+  default: {},
+};
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/default-prop.ts.result b/src/MapleFE/test/typescript/unit_tests/default-prop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3a075fd8c45ec326c8d8352eccd399c55a7d1745
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/default-prop.ts.result
@@ -0,0 +1,7 @@
+Matched 11 tokens.
+Matched 18 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {default: {}}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/define-prop-get-set.ts b/src/MapleFE/test/typescript/unit_tests/define-prop-get-set.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a99c1546b9bbfb138839726cc96a27d95a89382f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/define-prop-get-set.ts
@@ -0,0 +1,16 @@
+var obj = { x: "abc", name: "" };
+
+Object.defineProperty(obj, "name", {
+  get(this) {
+    console.log("Return obj.x");
+    return this["x"];
+  },
+  set(this, val: any) {
+    console.log(`Set obj.x to '${val}'`);
+    this["x"] = val;
+  },
+  enumerable: false,
+});
+
+obj.name = "def";
+console.log(obj, obj.name);
diff --git a/src/MapleFE/test/typescript/unit_tests/define-prop-get-set.ts.result b/src/MapleFE/test/typescript/unit_tests/define-prop-get-set.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..180a0342af27f281ec3ae9cad50d23c2a111b34b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/define-prop-get-set.ts.result
@@ -0,0 +1,20 @@
+Matched 13 tokens.
+Matched 74 tokens.
+Matched 80 tokens.
+Matched 91 tokens.
+Matched 92 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: obj= {x:"abc", name:""}
+== Sub Tree ==
+Object.defineProperty(obj,"name", {get:func  get(this)  throws: 
+  console.log("Return obj.x")
+  return this["x"]
+, set:func  set(this,val)  throws: 
+  console.log( template-literal: "Set obj.x to '",val,"'",NULL)
+  this["x"] Assign val
+, enumerable:false})
+== Sub Tree ==
+obj.name Assign "def"
+== Sub Tree ==
+console.log(obj,obj.name)
diff --git a/src/MapleFE/test/typescript/unit_tests/delete-func.ts b/src/MapleFE/test/typescript/unit_tests/delete-func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a5e6cf1014b2bfb358fb561639342da827b5a9a7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/delete-func.ts
@@ -0,0 +1,8 @@
+class Klass {
+  public delete(s: string) {
+    console.log("delete " + s);
+  }
+}
+
+var obj: Klass = new Klass();
+obj.delete("key");
diff --git a/src/MapleFE/test/typescript/unit_tests/delete-func.ts.result b/src/MapleFE/test/typescript/unit_tests/delete-func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..51eeece4050078672c37fa0780d657d6b6820b5b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/delete-func.ts.result
@@ -0,0 +1,20 @@
+Matched 22 tokens.
+Matched 32 tokens.
+Matched 39 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  delete(s)  throws: 
+      console.log("delete " Add s)
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj.delete("key")
diff --git a/src/MapleFE/test/typescript/unit_tests/delete.ts b/src/MapleFE/test/typescript/unit_tests/delete.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0af59349c38d6457823f8186a075bb398696b6f4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/delete.ts
@@ -0,0 +1,5 @@
+class A {
+  a?: number = 0;
+}
+var x: A = new A();
+delete x.a;
diff --git a/src/MapleFE/test/typescript/unit_tests/delete.ts.result b/src/MapleFE/test/typescript/unit_tests/delete.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..50d626c96650493b032c8df2d858fffff665357d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/delete.ts.result
@@ -0,0 +1,18 @@
+Matched 11 tokens.
+Matched 21 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+    a?=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: x=new A()
+== Sub Tree ==
+ delete x.a
diff --git a/src/MapleFE/test/typescript/unit_tests/direct-fd.ts b/src/MapleFE/test/typescript/unit_tests/direct-fd.ts
new file mode 100644
index 0000000000000000000000000000000000000000..40cbd1365d05c7c731f74fd5087e20a48b443ddd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/direct-fd.ts
@@ -0,0 +1,8 @@
+class Foo {
+  public f1: number = 0;
+}
+
+var bar : Foo = new Foo;
+bar.f1    = 456;
+console.log(bar);
+
diff --git a/src/MapleFE/test/typescript/unit_tests/direct-fd.ts.result b/src/MapleFE/test/typescript/unit_tests/direct-fd.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..005189032378f76e6db9609a96ff8b76934a182b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/direct-fd.ts.result
@@ -0,0 +1,21 @@
+Matched 11 tokens.
+Matched 19 tokens.
+Matched 25 tokens.
+Matched 32 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    f1=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: bar=new Foo()
+== Sub Tree ==
+bar.f1 Assign 456
+== Sub Tree ==
+console.log(bar)
diff --git a/src/MapleFE/test/typescript/unit_tests/do-while-stmt.ts b/src/MapleFE/test/typescript/unit_tests/do-while-stmt.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9c119e130d4a78251f48c1d8ea218f0f412fb8c5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/do-while-stmt.ts
@@ -0,0 +1,5 @@
+var k: number = 1;
+do {
+  console.log(k);
+  k++;
+} while (k < 10);
diff --git a/src/MapleFE/test/typescript/unit_tests/do-while-stmt.ts.result b/src/MapleFE/test/typescript/unit_tests/do-while-stmt.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..200759d76d99509b98327e1470263451e213cebd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/do-while-stmt.ts.result
@@ -0,0 +1,10 @@
+Matched 7 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: k=1
+== Sub Tree ==
+do   console.log(k)
+  k Inc
+
+while k LT 10
diff --git a/src/MapleFE/test/typescript/unit_tests/dynamic-import.ts b/src/MapleFE/test/typescript/unit_tests/dynamic-import.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cd79bcfcd82568e002d54c387a4e329bbd542aeb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/dynamic-import.ts
@@ -0,0 +1,2 @@
+const x: { f: typeof import("./M") } = {} as any;
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/dynamic-import.ts.result b/src/MapleFE/test/typescript/unit_tests/dynamic-import.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ed15e7f81b3b3cda11b07f941dcaa9693cd01bc5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/dynamic-import.ts.result
@@ -0,0 +1,7 @@
+Matched 18 tokens.
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: x= {}
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/else-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/else-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dd9965a57cfc8382a32c2ae6a50b371fa371ef6d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/else-as-prop-name.ts
@@ -0,0 +1,6 @@
+class Klass {
+  else: number = 0;
+}
+
+var obj: Klass = new Klass();
+console.log(obj, obj.else);
diff --git a/src/MapleFE/test/typescript/unit_tests/else-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/else-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b14f7e7d22946f638f60fdd316acf89110a295ee
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/else-as-prop-name.ts.result
@@ -0,0 +1,18 @@
+Matched 10 tokens.
+Matched 20 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    else=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(obj,obj.else)
diff --git a/src/MapleFE/test/typescript/unit_tests/empty-func.ts b/src/MapleFE/test/typescript/unit_tests/empty-func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5ec57fbdc559363f006b0ec83652cbd4f3b3f9d4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/empty-func.ts
@@ -0,0 +1 @@
+function func() {}
diff --git a/src/MapleFE/test/typescript/unit_tests/empty-func.ts.result b/src/MapleFE/test/typescript/unit_tests/empty-func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..159c2abca77a363e9b562cdb2ddab1f732415556
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/empty-func.ts.result
@@ -0,0 +1,5 @@
+Matched 6 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/enum-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/enum-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..413d5b35d0e89424ac23ff66e6a4efd6189b61dc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum-as-prop-name.ts
@@ -0,0 +1,3 @@
+interface IFace {
+    enum?: string[];
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/enum-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/enum-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b672b9baab75017a47b4172777339453b4c412e5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum-as-prop-name.ts.result
@@ -0,0 +1,4 @@
+Matched 11 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {enum? }
diff --git a/src/MapleFE/test/typescript/unit_tests/enum-function-prop.ts b/src/MapleFE/test/typescript/unit_tests/enum-function-prop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7ae2919fc6f049c73b137475db570fa7db557201
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum-function-prop.ts
@@ -0,0 +1,5 @@
+enum E {
+    function = "function"
+}
+
+console.log(E.function);
diff --git a/src/MapleFE/test/typescript/unit_tests/enum-function-prop.ts.result b/src/MapleFE/test/typescript/unit_tests/enum-function-prop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f5d20c02151036ace2241ae8da485a3176253572
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum-function-prop.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: E {function="function" }
+== Sub Tree ==
+console.log(E.function)
diff --git a/src/MapleFE/test/typescript/unit_tests/enum-function-prop2.ts b/src/MapleFE/test/typescript/unit_tests/enum-function-prop2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eb2fbd1b7509805546537c8bb2a9e76bec13edcd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum-function-prop2.ts
@@ -0,0 +1,5 @@
+enum E {
+    function = "function"
+}
+
+type T = Array<E.function>;
diff --git a/src/MapleFE/test/typescript/unit_tests/enum-function-prop2.ts.result b/src/MapleFE/test/typescript/unit_tests/enum-function-prop2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5f5b36d334dc04882bcaffa84e426c82787fc0ea
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum-function-prop2.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 17 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: E {function="function" }
+== Sub Tree ==
+ type T = Array<E.function>
diff --git a/src/MapleFE/test/typescript/unit_tests/enum.ts b/src/MapleFE/test/typescript/unit_tests/enum.ts
new file mode 100644
index 0000000000000000000000000000000000000000..29e2a13ca0ffa3abb8e0180b146007acae389fcd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum.ts
@@ -0,0 +1,7 @@
+enum ET {
+  TOP = "top",
+  BOTTOM = "bottom",
+}
+
+let et = ET.TOP;
+console.log(et);
diff --git a/src/MapleFE/test/typescript/unit_tests/enum.ts.result b/src/MapleFE/test/typescript/unit_tests/enum.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e4afff30c02415e10dfeab2420a63675b1286d5d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum.ts.result
@@ -0,0 +1,10 @@
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: ET {TOP="top";BOTTOM="bottom" }
+== Sub Tree ==
+js_let Decl: et=ET.TOP
+== Sub Tree ==
+console.log(et)
diff --git a/src/MapleFE/test/typescript/unit_tests/enum2.ts b/src/MapleFE/test/typescript/unit_tests/enum2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..430229eff9a22d1754690fbb81837d8989f7f88c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum2.ts
@@ -0,0 +1,7 @@
+export enum ET {
+  TOP = 1 << 0,
+  BOTTOM = 1 << 1,
+}
+
+let et = ET.TOP;
+console.log(et);
diff --git a/src/MapleFE/test/typescript/unit_tests/enum2.ts.result b/src/MapleFE/test/typescript/unit_tests/enum2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..60b0b04f50f3e6fa98ce66861d33f92b5ee837cd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum2.ts.result
@@ -0,0 +1,10 @@
+Matched 17 tokens.
+Matched 24 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+export {ts_enum: ET {TOP=1 Shl 0;BOTTOM=1 Shl 1 }} 
+== Sub Tree ==
+js_let Decl: et=ET.TOP
+== Sub Tree ==
+console.log(et)
diff --git a/src/MapleFE/test/typescript/unit_tests/enum3.ts b/src/MapleFE/test/typescript/unit_tests/enum3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4e588449ceda7d493db9e7cf6d6afbb083195dcf
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum3.ts
@@ -0,0 +1,3 @@
+enum E {
+  "<None>" = 0,
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/enum3.ts.result b/src/MapleFE/test/typescript/unit_tests/enum3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b9c2c344fee749b41b2484ce4597c74d1c0eb511
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum3.ts.result
@@ -0,0 +1,4 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: E {"<None>" = 0 }
diff --git a/src/MapleFE/test/typescript/unit_tests/enum4.ts b/src/MapleFE/test/typescript/unit_tests/enum4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7f096dc9a006ef37a5cf17f7361a2d3df629cc20
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum4.ts
@@ -0,0 +1,4 @@
+export declare enum ET {
+  TOP = "top",
+  BOTTOM = "bottom",
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/enum4.ts.result b/src/MapleFE/test/typescript/unit_tests/enum4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..701cda2962b78fae780c7c8bec9d2783dcdf9577
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/enum4.ts.result
@@ -0,0 +1,4 @@
+Matched 14 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare ts_enum: ET {TOP="top";BOTTOM="bottom" }} 
diff --git a/src/MapleFE/test/typescript/unit_tests/exp.ts b/src/MapleFE/test/typescript/unit_tests/exp.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f2cade21f7e97e57720bd9f96be46380b049b6ab
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/exp.ts
@@ -0,0 +1,2 @@
+var x: number = 10;
+console.log(x ** (2 ** 3));
diff --git a/src/MapleFE/test/typescript/unit_tests/exp.ts.result b/src/MapleFE/test/typescript/unit_tests/exp.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ef802eb258e4623a51b6e0cedae277248f20db02
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/exp.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 20 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=10
+== Sub Tree ==
+console.log(x Exp 2 Exp 3)
diff --git a/src/MapleFE/test/typescript/unit_tests/export-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/export-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7d2c55a8dd22d80698da49c821b1b1e390e1dc53
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-as-prop-name.ts
@@ -0,0 +1,6 @@
+interface IFace {
+  export() : string;
+}
+
+var obj: IFace = { export: () => "Export" };
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/export-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/export-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..10708b76b405f378ac63a0d03d00b1a2f35e633c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-as-prop-name.ts.result
@@ -0,0 +1,11 @@
+Matched 10 tokens.
+Matched 24 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {func  export()  throws: 
+ }
+== Sub Tree ==
+js_var Decl: obj= {export:() -> "Export"}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/export-as-prop-name2.ts b/src/MapleFE/test/typescript/unit_tests/export-as-prop-name2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c1a13a308c4f6208f4a3552767c3606bd8678b25
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-as-prop-name2.ts
@@ -0,0 +1,3 @@
+declare class Klass {
+  export(arg: number): string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/export-as-prop-name2.ts.result b/src/MapleFE/test/typescript/unit_tests/export-as-prop-name2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5102c905c5b420e51d3ec11a98a2ec30bba2f100
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-as-prop-name2.ts.result
@@ -0,0 +1,13 @@
+Matched 14 tokens.
+============= Module ===========
+== Sub Tree ==
+declare class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  export(arg)  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/export-as-super.ts b/src/MapleFE/test/typescript/unit_tests/export-as-super.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3eb9fb29cce720932f685e6b8f16bba1d86a30ba
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-as-super.ts
@@ -0,0 +1,2 @@
+declare function func(): number;
+export { func as super };
diff --git a/src/MapleFE/test/typescript/unit_tests/export-as-super.ts.result b/src/MapleFE/test/typescript/unit_tests/export-as-super.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..04c1408eb3d4b3dfd856cd0f5efe2f91ddaad437
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-as-super.ts.result
@@ -0,0 +1,8 @@
+Matched 8 tokens.
+Matched 15 tokens.
+============= Module ===========
+== Sub Tree ==
+declare func  func()  throws: 
+
+== Sub Tree ==
+export {func as super} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-class.ts b/src/MapleFE/test/typescript/unit_tests/export-class.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b78a31ce1715a775609bf6539dc0288ee2394ada
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-class.ts
@@ -0,0 +1,9 @@
+class Foo {
+  public f1: number = 0;
+  private f2: number = 0;
+  constructor(a: number, b: number) {
+    this.f1 = a;
+    this.f2 = b;
+  }
+}
+export = Foo;
diff --git a/src/MapleFE/test/typescript/unit_tests/export-class.ts.result b/src/MapleFE/test/typescript/unit_tests/export-class.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..63c191f909c73cf2f3f4082df34f7a8c69c08237
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-class.ts.result
@@ -0,0 +1,18 @@
+Matched 42 tokens.
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    f1=0    f2=0
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.f1 Assign a
+      this.f2 Assign b
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+export { SINGLE Foo} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-declare-func.ts b/src/MapleFE/test/typescript/unit_tests/export-declare-func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6be8b9b40d17f990a289fea959b18af8bd5513a1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-declare-func.ts
@@ -0,0 +1,2 @@
+export {};
+export declare function func<T>(d: T): T;
diff --git a/src/MapleFE/test/typescript/unit_tests/export-declare-func.ts.result b/src/MapleFE/test/typescript/unit_tests/export-declare-func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2492af15c1738254d462e2f2b09a3d4f010bfae8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-declare-func.ts.result
@@ -0,0 +1,8 @@
+Matched 4 tokens.
+Matched 19 tokens.
+============= Module ===========
+== Sub Tree ==
+export 
+== Sub Tree ==
+export {declare func  func<T>(d)  throws: 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-declare-func2.ts b/src/MapleFE/test/typescript/unit_tests/export-declare-func2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8d8443bba14a4adae8428e7b622ef76747a4a5c9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-declare-func2.ts
@@ -0,0 +1 @@
+export declare function isPromise<T>(obj: T | Promise<T>): obj is Promise<T>;
diff --git a/src/MapleFE/test/typescript/unit_tests/export-declare-func2.ts.result b/src/MapleFE/test/typescript/unit_tests/export-declare-func2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e0e1b6179a7ec2e907a15cc324b81d428f833719
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-declare-func2.ts.result
@@ -0,0 +1,5 @@
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare func  isPromise<T>(obj)  throws: 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-deco.ts b/src/MapleFE/test/typescript/unit_tests/export-deco.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ff6123a355ac8cbb85bcbc104cb7ac865240f837
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-deco.ts
@@ -0,0 +1,8 @@
+function class_deco(ctor: Function): void {
+  console.log("Class constructor is :", ctor);
+}
+
+@class_deco
+export class Foo {
+  readonly foo_var: number = 1;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/export-deco.ts.result b/src/MapleFE/test/typescript/unit_tests/export-deco.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5c959e46ace88c7ac6ac00ead8c6d4533debd4e0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-deco.ts.result
@@ -0,0 +1,17 @@
+Matched 20 tokens.
+Matched 34 tokens.
+============= Module ===========
+== Sub Tree ==
+func  class_deco(ctor)  throws: 
+  console.log("Class constructor is :",ctor)
+
+== Sub Tree ==
+export {class  Foo
+  Fields: 
+    foo_var=1
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-default-as.ts b/src/MapleFE/test/typescript/unit_tests/export-default-as.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b4a0da2eac8654d28ca6e4e4c6c49282ec3261d8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-default-as.ts
@@ -0,0 +1 @@
+export { default as X } from "./M";
diff --git a/src/MapleFE/test/typescript/unit_tests/export-default-as.ts.result b/src/MapleFE/test/typescript/unit_tests/export-default-as.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3aa8d5dfc340238c8a13ef36bf8f1fd6c99be5af
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-default-as.ts.result
@@ -0,0 +1,4 @@
+Matched 9 tokens.
+============= Module ===========
+== Sub Tree ==
+export {default as X} "./M"
diff --git a/src/MapleFE/test/typescript/unit_tests/export-default-as2.ts b/src/MapleFE/test/typescript/unit_tests/export-default-as2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..497f6885918126ec8beea47e47380b8f502f5638
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-default-as2.ts
@@ -0,0 +1 @@
+export { default as default } from "./M";
diff --git a/src/MapleFE/test/typescript/unit_tests/export-default-as2.ts.result b/src/MapleFE/test/typescript/unit_tests/export-default-as2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..aff9533e078dcc35dabcffafcf7ab756b6fc2e70
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-default-as2.ts.result
@@ -0,0 +1,4 @@
+Matched 9 tokens.
+============= Module ===========
+== Sub Tree ==
+export {default as default} "./M"
diff --git a/src/MapleFE/test/typescript/unit_tests/export-default-class.ts b/src/MapleFE/test/typescript/unit_tests/export-default-class.ts
new file mode 100644
index 0000000000000000000000000000000000000000..387684c291bd160ef90a476efdc1d6aec287e6f7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-default-class.ts
@@ -0,0 +1,5 @@
+export default class {
+  f1: number = 0;
+  f2: string = "";
+}
+
diff --git a/src/MapleFE/test/typescript/unit_tests/export-default-class.ts.result b/src/MapleFE/test/typescript/unit_tests/export-default-class.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..623d94e2a205f45382ad5cb95201b3b8dbf8bd9e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-default-class.ts.result
@@ -0,0 +1,12 @@
+Matched 17 tokens.
+============= Module ===========
+== Sub Tree ==
+export { default as class  
+  Fields: 
+    f1=0    f2=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-default-function.ts b/src/MapleFE/test/typescript/unit_tests/export-default-function.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0ee9984fb9fd9147ff9fc7f5a253fb2c97c7c555
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-default-function.ts
@@ -0,0 +1,3 @@
+export default function<T> (arg: T): T[] {
+  return [arg];
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/export-default-function.ts.result b/src/MapleFE/test/typescript/unit_tests/export-default-function.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..421d240a1b0378622e3f2af2013cf207c240b702
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-default-function.ts.result
@@ -0,0 +1,6 @@
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+export { default as func  <T>(arg)  throws: 
+  return [arg]
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-func-as-import.ts b/src/MapleFE/test/typescript/unit_tests/export-func-as-import.ts
new file mode 100644
index 0000000000000000000000000000000000000000..93c7e958e8c08c795b8787ff8b80ac3b156fd671
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-func-as-import.ts
@@ -0,0 +1,4 @@
+function func(n: string, o?: string): Promise<any> {
+  return new Promise<any>((resolve, reject) => { resolve("OK"); });
+}
+export { func as import }; 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-func-as-import.ts.result b/src/MapleFE/test/typescript/unit_tests/export-func-as-import.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c42ee9868155c334f0f8a9c5302c15a2241bdcba
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-func-as-import.ts.result
@@ -0,0 +1,10 @@
+Matched 41 tokens.
+Matched 48 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(n,o?)  throws: 
+  return new Promise((resolve,reject) -> resolve("OK")
+)
+
+== Sub Tree ==
+export {func as import} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-import.ts b/src/MapleFE/test/typescript/unit_tests/export-import.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f8311317972b4b0ffe51e39bbe51c6bc46239826
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-import.ts
@@ -0,0 +1,4 @@
+import * as M from "./M";
+declare namespace NS {
+  export import MM = M;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/export-import.ts.result b/src/MapleFE/test/typescript/unit_tests/export-import.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8660fdc0bb88ec7ef9cc0d9b31c225e22d557c2d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-import.ts.result
@@ -0,0 +1,9 @@
+Matched 7 tokens.
+Matched 18 tokens.
+============= Module ===========
+== Sub Tree ==
+import { * as M} "./M"
+== Sub Tree ==
+declare namespace  NS
+  export {import {M as MM} } 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/export-import2.ts b/src/MapleFE/test/typescript/unit_tests/export-import2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..483b9ad6397ec420f302ea790aea5b0e36585dc2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-import2.ts
@@ -0,0 +1,5 @@
+import myX, * as M from "./M";
+export import getx = M.getx;
+console.log(myX, getx());
+M.setx(3);
+console.log(myX, getx());
diff --git a/src/MapleFE/test/typescript/unit_tests/export-import2.ts.result b/src/MapleFE/test/typescript/unit_tests/export-import2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..bbda54c0caf3a899e3c1c39685e62a5bcb1cb1fc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-import2.ts.result
@@ -0,0 +1,16 @@
+Matched 9 tokens.
+Matched 17 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as myX, * as M} "./M"
+== Sub Tree ==
+export {import {M.getx as getx} } 
+== Sub Tree ==
+console.log(myX,getx())
+== Sub Tree ==
+M.setx(3)
+== Sub Tree ==
+console.log(myX,getx())
diff --git a/src/MapleFE/test/typescript/unit_tests/export-in-namespace.ts b/src/MapleFE/test/typescript/unit_tests/export-in-namespace.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a2b718d2d750b1ca891a61be12c1c3e973e2023b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-in-namespace.ts
@@ -0,0 +1,4 @@
+export declare namespace ns {
+  class Klass {}
+  export { Klass };
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/export-in-namespace.ts.result b/src/MapleFE/test/typescript/unit_tests/export-in-namespace.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5f86a5325c1fe955130e409e4889f17b956c1a6f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-in-namespace.ts.result
@@ -0,0 +1,15 @@
+Matched 15 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare namespace  ns
+  class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+  export {Klass} 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-interface.ts b/src/MapleFE/test/typescript/unit_tests/export-interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8fcaaf808f30dcdc7ff88153b9b128f611667e86
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-interface.ts
@@ -0,0 +1,3 @@
+export interface MapLike<T> {
+    [index: string]: T;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/export-interface.ts.result b/src/MapleFE/test/typescript/unit_tests/export-interface.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7085ccc02b9c0e0b5f72fc9449009a10f06646b7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-interface.ts.result
@@ -0,0 +1,4 @@
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+export {ts_interface: MapLike<T,> {string index type: T }} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-module.d.ts b/src/MapleFE/test/typescript/unit_tests/export-module.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7ed719cbd4202180d58496739f3a377fe060545b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-module.d.ts
@@ -0,0 +1,5 @@
+declare module "export-module" {
+  export module Module {
+    const func: () => boolean;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/export-module.d.ts.result b/src/MapleFE/test/typescript/unit_tests/export-module.d.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..be802a82355a77c30467f280ea39d7fb2b2cf749
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-module.d.ts.result
@@ -0,0 +1,10 @@
+Matched 18 tokens.
+============= Module ===========
+== Sub Tree ==
+declare ============= Module ===========
+== Sub Tree ==
+export {============= Module ===========
+== Sub Tree ==
+js_const Decl: func
+} 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/export-single.ts b/src/MapleFE/test/typescript/unit_tests/export-single.ts
new file mode 100644
index 0000000000000000000000000000000000000000..63c0c96edfea8fd0152dc34a47713119cb6f880a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-single.ts
@@ -0,0 +1,4 @@
+class Klass {
+  name: string = "";
+}
+export = Klass;
diff --git a/src/MapleFE/test/typescript/unit_tests/export-single.ts.result b/src/MapleFE/test/typescript/unit_tests/export-single.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..530373f531e6a8529f1487355532497834ed7591
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-single.ts.result
@@ -0,0 +1,15 @@
+Matched 10 tokens.
+Matched 14 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    name=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+export { SINGLE Klass} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-type.ts b/src/MapleFE/test/typescript/unit_tests/export-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..779287f898611afb4e2c780310c2dcc3e751007c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-type.ts
@@ -0,0 +1,10 @@
+class Foo {
+  public out: number = 0;
+  public in: number = 0;
+  constructor(a: number, b: number) {
+    this.out = a;
+    this.in = b;
+  }
+}
+
+export type { Foo };
diff --git a/src/MapleFE/test/typescript/unit_tests/export-type.ts.result b/src/MapleFE/test/typescript/unit_tests/export-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..fb266b095ac7a49342bbaf2b55163d9f00e9fb03
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-type.ts.result
@@ -0,0 +1,18 @@
+Matched 42 tokens.
+Matched 48 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    out=0    in=0
+  Instance Initializer: 
+  Constructors: 
+    constructor  (a,b)  throws: 
+      this.out Assign a
+      this.in Assign b
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+export type {Foo} 
diff --git a/src/MapleFE/test/typescript/unit_tests/export-type2.ts b/src/MapleFE/test/typescript/unit_tests/export-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5b131b5b183d860a60ca338472abd67c8f9bb4a2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-type2.ts
@@ -0,0 +1 @@
+export type { Foo } from "./export-type";
diff --git a/src/MapleFE/test/typescript/unit_tests/export-type2.ts.result b/src/MapleFE/test/typescript/unit_tests/export-type2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..efee0ee0257e1c87546028bec8b3eb5ae44298f0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-type2.ts.result
@@ -0,0 +1,4 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+export type {Foo} "./export-type"
diff --git a/src/MapleFE/test/typescript/unit_tests/export-type3.ts b/src/MapleFE/test/typescript/unit_tests/export-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d3c109ca03bbf74654d82a323bd8da4cd14d6ec2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-type3.ts
@@ -0,0 +1,4 @@
+export type Type<B, K extends keyof B = keyof B>
+= Pick<B, Exclude<keyof B, K>>
+& Partial<Pick<B, K>> extends infer U ? {[KT in keyof U]: U[KT]} : never;
+
diff --git a/src/MapleFE/test/typescript/unit_tests/export-type3.ts.result b/src/MapleFE/test/typescript/unit_tests/export-type3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a77c87d926640d0525ca1f33f0cb213be7d25c8a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/export-type3.ts.result
@@ -0,0 +1,4 @@
+Matched 55 tokens.
+============= Module ===========
+== Sub Tree ==
+export { type Type<B,K=> = intersect  = Pick<B,Exclude< keyof B,K>> & Partial<Pick<B,K>> extends  infer U ?  {[KT in  keyof U] : U[KT] } : never} 
diff --git a/src/MapleFE/test/typescript/unit_tests/extends-infer.ts b/src/MapleFE/test/typescript/unit_tests/extends-infer.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c02b328cff278ec8ab93e9ce99aadbabb040c6d1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/extends-infer.ts
@@ -0,0 +1,3 @@
+export declare type NT<T> = {
+    [K in keyof T]: NonNullable<T[K]> extends boolean ? K : never;
+  } extends { [_ in keyof T]: infer U; } ? U : never;
diff --git a/src/MapleFE/test/typescript/unit_tests/extends-infer.ts.result b/src/MapleFE/test/typescript/unit_tests/extends-infer.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d674cbdb1ff8292e64d108b9e6c1f9f15ec34943
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/extends-infer.ts.result
@@ -0,0 +1,4 @@
+Matched 49 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare  type NT<T> =  {[K in  keyof T] : NonNullable<T[K]> extends boolean ? K : never } extends  {[_ in  keyof T] :  infer U } ? U : never} 
diff --git a/src/MapleFE/test/typescript/unit_tests/fibonacci.ts b/src/MapleFE/test/typescript/unit_tests/fibonacci.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2ac2de9082600be3198b3bd64a0e6b418f7b6d47
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/fibonacci.ts
@@ -0,0 +1,16 @@
+function fibonacci(m: number) {
+  var f0: number = 0;
+  var f1: number = 1;
+  var f2: number | undefined;
+  var i: number;
+  if (m <= 1) {
+    return m;
+  } else {
+    for (i = 2; i <= m; i++) {
+      f2 = f0 + f1;
+      f0 = f1;
+      f1 = f2;
+    }
+    return f2;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/fibonacci.ts.result b/src/MapleFE/test/typescript/unit_tests/fibonacci.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..bf4d4d25ac1bc77785f201d751b2faa2b065761e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/fibonacci.ts.result
@@ -0,0 +1,20 @@
+Matched 81 tokens.
+============= Module ===========
+== Sub Tree ==
+func  fibonacci(m)  throws: 
+  js_var Decl: f0=0
+  js_var Decl: f1=1
+  js_var Decl: f2
+  js_var Decl: i
+  cond-branch cond:m LE 1
+  true branch :
+    return m
+  false branch :
+    for ( )
+      f2 Assign f0 Add f1
+      f0 Assign f1
+      f1 Assign f2
+
+    return f2
+
+
diff --git a/src/MapleFE/test/typescript/unit_tests/field-func.ts b/src/MapleFE/test/typescript/unit_tests/field-func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b87a09fe7b0d98a4fe9ef95dc8845e1267ac73da
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/field-func.ts
@@ -0,0 +1,2 @@
+interface cs {}
+declare const calls: { (): cs[] };
diff --git a/src/MapleFE/test/typescript/unit_tests/field-func.ts.result b/src/MapleFE/test/typescript/unit_tests/field-func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c00be998c394437e2dc100d3e1ee49916a116768
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/field-func.ts.result
@@ -0,0 +1,7 @@
+Matched 4 tokens.
+Matched 17 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: cs { }
+== Sub Tree ==
+declare js_const Decl: calls
diff --git a/src/MapleFE/test/typescript/unit_tests/for-in-stmt-1.ts b/src/MapleFE/test/typescript/unit_tests/for-in-stmt-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b553722369e3af586716557a82694d326cc3475
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-in-stmt-1.ts
@@ -0,0 +1,10 @@
+class Klass {
+  [key: string]: number | string;
+  x: number = 0;
+  s: string = "";
+}
+
+var obj: Klass = { x: 1, s: "123" };
+for (const k in obj) {
+  console.log(k, obj[k]);
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/for-in-stmt-1.ts.result b/src/MapleFE/test/typescript/unit_tests/for-in-stmt-1.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..637f2e422c010a68a832b49954ebfff6bf321a0f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-in-stmt-1.ts.result
@@ -0,0 +1,20 @@
+Matched 26 tokens.
+Matched 41 tokens.
+Matched 62 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    union  = number | string    x=0    s=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj= {x:1, s:"123"}
+== Sub Tree ==
+for ( )
+  console.log(k,obj[k])
+
diff --git a/src/MapleFE/test/typescript/unit_tests/for-in-stmt.ts b/src/MapleFE/test/typescript/unit_tests/for-in-stmt.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0cad8e5fa5a9e32ed4a643e90d0aca6abcaab63a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-in-stmt.ts
@@ -0,0 +1,10 @@
+class Klass {
+  [key: string]: number | string;
+  x: number = 0;
+  s: string = "";
+}
+
+var obj: Klass = { x: 1, s: "123" };
+for (var k in obj) {
+  console.log(k, obj[k]);
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/for-in-stmt.ts.result b/src/MapleFE/test/typescript/unit_tests/for-in-stmt.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..637f2e422c010a68a832b49954ebfff6bf321a0f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-in-stmt.ts.result
@@ -0,0 +1,20 @@
+Matched 26 tokens.
+Matched 41 tokens.
+Matched 62 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    union  = number | string    x=0    s=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj= {x:1, s:"123"}
+== Sub Tree ==
+for ( )
+  console.log(k,obj[k])
+
diff --git a/src/MapleFE/test/typescript/unit_tests/for-let.ts b/src/MapleFE/test/typescript/unit_tests/for-let.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4f9c93f7a61ccea17d0d732e6f0665014e94607e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-let.ts
@@ -0,0 +1,3 @@
+for (let i = 0; i < 5; i++) {
+  console.log(i);
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/for-let.ts.result b/src/MapleFE/test/typescript/unit_tests/for-let.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8283bf2da4b2f1e9736efff2db680204a4dd84f2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-let.ts.result
@@ -0,0 +1,6 @@
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+for ( )
+  console.log(i)
+
diff --git a/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits.ts b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a02de7c5d5e568265dc1e876fa8c6f9c4a8d0c62
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits.ts
@@ -0,0 +1 @@
+for (let i = 0, j = 3; i < j; i++) console.log(i, j);
diff --git a/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits.ts.result b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b27c90e9ea35dcbf7ff637525d063dc58a89791a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits.ts.result
@@ -0,0 +1,5 @@
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+for ( )
+  console.log(i,j)
diff --git a/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits2.ts b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..998beff737361ead9b61fe174198a3f0d2c56c19
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits2.ts
@@ -0,0 +1,12 @@
+class Klass {
+  items: number[] = [];
+
+  func(num: number) {
+    let i, list;
+    for (i = 0, list = this.items; i < num; i++) console.log(i, list[i]);
+  }
+}
+
+var obj: Klass = new Klass();
+obj.items.push(1, 2, 3, 4, 5, 6);
+obj.func(6);
diff --git a/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits2.ts.result b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..81669289b69486f5920246da19dffd3c8d5469d7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits2.ts.result
@@ -0,0 +1,26 @@
+Matched 57 tokens.
+Matched 67 tokens.
+Matched 86 tokens.
+Matched 93 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    items=[]
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func(num)  throws: 
+      js_let Decl: i
+      js_let Decl: list
+      for ( )
+        console.log(i,list[i])
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj.items.push(1,2,3,4,5,6)
+== Sub Tree ==
+obj.func(6)
diff --git a/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits3.ts b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c028beddbfe0dacdff4947a2767dbf3b8081e2d6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits3.ts
@@ -0,0 +1,13 @@
+class Klass {
+  items: number[] = [];
+
+  func() {
+    let i, list, len;
+    for (i = 0, list = this.items, len = this.items.length; i < len; i++)
+      console.log(i, list[i]);
+  }
+}
+
+var obj: Klass = new Klass();
+obj.items.push(1, 2, 3, 4, 5, 6);
+obj.func();
diff --git a/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits3.ts.result b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..98b323a089f1cd34e55057d364690d0dcaf8c08b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-inits3.ts.result
@@ -0,0 +1,27 @@
+Matched 64 tokens.
+Matched 74 tokens.
+Matched 93 tokens.
+Matched 99 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    items=[]
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func()  throws: 
+      js_let Decl: i
+      js_let Decl: list
+      js_let Decl: len
+      for ( )
+        console.log(i,list[i])
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj.items.push(1,2,3,4,5,6)
+== Sub Tree ==
+obj.func()
diff --git a/src/MapleFE/test/typescript/unit_tests/for-loop-multi-updates.ts b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-updates.ts
new file mode 100644
index 0000000000000000000000000000000000000000..252807f5ccc5f4350c15a576ce8cdafab35d3ff3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-updates.ts
@@ -0,0 +1 @@
+for (let i = 0, j = 3, k = 6; i < j + k; i += 3, j++, k++) console.log(i, j, k);
diff --git a/src/MapleFE/test/typescript/unit_tests/for-loop-multi-updates.ts.result b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-updates.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9c170dfa5ac3ffc4970be942865299bf74b10af1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-loop-multi-updates.ts.result
@@ -0,0 +1,5 @@
+Matched 42 tokens.
+============= Module ===========
+== Sub Tree ==
+for ( )
+  console.log(i,j,k)
diff --git a/src/MapleFE/test/typescript/unit_tests/for-of-stmt.ts b/src/MapleFE/test/typescript/unit_tests/for-of-stmt.ts
new file mode 100644
index 0000000000000000000000000000000000000000..73764b9435314483f5509160d637d29883deca64
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-of-stmt.ts
@@ -0,0 +1,4 @@
+var arr = [1, 2, 3];
+for (var v of arr) {
+  console.log(v);
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/for-of-stmt.ts.result b/src/MapleFE/test/typescript/unit_tests/for-of-stmt.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f0611630907487a5e31026d8d58a1450f5e1844b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-of-stmt.ts.result
@@ -0,0 +1,9 @@
+Matched 11 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[1,2,3]
+== Sub Tree ==
+for ( )
+  console.log(v)
+
diff --git a/src/MapleFE/test/typescript/unit_tests/for-switch-mixed.ts b/src/MapleFE/test/typescript/unit_tests/for-switch-mixed.ts
new file mode 100644
index 0000000000000000000000000000000000000000..71d7d33cb24f5f206c189de160c9db838f66af36
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-switch-mixed.ts
@@ -0,0 +1,19 @@
+const nums: number[] = [3, 9, 8, 2, 7, 5, 1, 6, 4];
+
+for (const n of nums) {
+  switch (true) {
+    case n < 5:
+      console.log(n, " is less than 5");
+    case n > 2 && n < 5:
+      console.log(n, " + 1 is equal to", n + 1);
+      break;
+    case n == 6:
+      console.log(n, " is equal to 6");
+      break;
+    case n < 8:
+      console.log(n, " is greater than 4 and less than 8");
+      break;
+    default:
+      console.log(n, " is greater than 7");
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/for-switch-mixed.ts.result b/src/MapleFE/test/typescript/unit_tests/for-switch-mixed.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3d64cd1d402e63411a62f81196a0ceef9225cf64
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/for-switch-mixed.ts.result
@@ -0,0 +1,10 @@
+Matched 27 tokens.
+Matched 123 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: nums=[3,9,8,2,7,5,1,6,4]
+== Sub Tree ==
+for ( )
+  A switch
+
+
diff --git a/src/MapleFE/test/typescript/unit_tests/func-builtin.ts b/src/MapleFE/test/typescript/unit_tests/func-builtin.ts
new file mode 100644
index 0000000000000000000000000000000000000000..88a893009c6ae2ef31607c869f8c17f4859df287
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func-builtin.ts
@@ -0,0 +1,37 @@
+interface Employee {
+  firstName: string;
+  lastName: string;
+}
+
+let john: Employee = {
+  firstName: "John",
+  lastName: "Smith",
+};
+
+let jane: Employee = {
+  firstName: "Jane",
+  lastName: "Doe",
+};
+
+var func;
+var res;
+
+function fullName(this: Employee): string {
+  return this.firstName + " " + this.lastName;
+}
+
+// call() and apply() returns the result of calling the function directly with the obj instance arg
+res = fullName.call(john);
+console.log("Name: " + res); // output: "Name: John Smith"
+res = fullName.call(jane);
+console.log("Name: " + res); // output: "Name: Jane Doe"
+res = fullName.apply(john);
+console.log("Name: " + res); // output: "Name: John Smith"
+res = fullName.apply(jane);
+console.log("Name: " + res); // output: "Name: Jane Doe"
+
+// bind() returns a copy of the function bound to the obj instance arg
+func = fullName.bind(john);
+console.log("Name: " + func()); // output: "Name: John Smith"
+func = fullName.bind(jane);
+console.log("Name: " + func()); // output: "Name: Jane Doe"
diff --git a/src/MapleFE/test/typescript/unit_tests/func-builtin.ts.result b/src/MapleFE/test/typescript/unit_tests/func-builtin.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..84146a9752502f9167057c6864f80c1a950d9ea7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func-builtin.ts.result
@@ -0,0 +1,57 @@
+Matched 12 tokens.
+Matched 28 tokens.
+Matched 44 tokens.
+Matched 47 tokens.
+Matched 50 tokens.
+Matched 72 tokens.
+Matched 81 tokens.
+Matched 90 tokens.
+Matched 99 tokens.
+Matched 108 tokens.
+Matched 117 tokens.
+Matched 126 tokens.
+Matched 135 tokens.
+Matched 144 tokens.
+Matched 153 tokens.
+Matched 164 tokens.
+Matched 173 tokens.
+Matched 184 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Employee {firstName;lastName }
+== Sub Tree ==
+js_let Decl: john= {firstName:"John", lastName:"Smith"}
+== Sub Tree ==
+js_let Decl: jane= {firstName:"Jane", lastName:"Doe"}
+== Sub Tree ==
+js_var Decl: func
+== Sub Tree ==
+js_var Decl: res
+== Sub Tree ==
+func  fullName(this)  throws: 
+  return this.firstName Add " " Add this.lastName
+
+== Sub Tree ==
+res Assign fullName.call(john)
+== Sub Tree ==
+console.log("Name: " Add res)
+== Sub Tree ==
+res Assign fullName.call(jane)
+== Sub Tree ==
+console.log("Name: " Add res)
+== Sub Tree ==
+res Assign fullName.apply(john)
+== Sub Tree ==
+console.log("Name: " Add res)
+== Sub Tree ==
+res Assign fullName.apply(jane)
+== Sub Tree ==
+console.log("Name: " Add res)
+== Sub Tree ==
+func Assign fullName.bind(john)
+== Sub Tree ==
+console.log("Name: " Add func())
+== Sub Tree ==
+func Assign fullName.bind(jane)
+== Sub Tree ==
+console.log("Name: " Add func())
diff --git a/src/MapleFE/test/typescript/unit_tests/func-call.ts b/src/MapleFE/test/typescript/unit_tests/func-call.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0efe45f8133a835e013384634669a76adc364c1c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func-call.ts
@@ -0,0 +1,6 @@
+function func(a: number, b: number, c: number): number {
+  return a + b + c;
+}
+
+var num = 10;
+console.log(func(1, 5, -num));
diff --git a/src/MapleFE/test/typescript/unit_tests/func-call.ts.result b/src/MapleFE/test/typescript/unit_tests/func-call.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3b091ae645deb09f0cd555761266dede80492a0b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func-call.ts.result
@@ -0,0 +1,12 @@
+Matched 26 tokens.
+Matched 31 tokens.
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(a,b,c)  throws: 
+  return a Add b Add c
+
+== Sub Tree ==
+js_var Decl: num=10
+== Sub Tree ==
+console.log(func(1,5,Minus num))
diff --git a/src/MapleFE/test/typescript/unit_tests/func2.ts b/src/MapleFE/test/typescript/unit_tests/func2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1569fa1aae54cb54667f30504857a64e6a92150c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func2.ts
@@ -0,0 +1,12 @@
+function func(this: any, arg: number) {
+  var x:number;
+  this.val1 = arg;
+  x = this.val1;
+  this.val2 = x;
+}
+
+var a = {};
+var b = new (func as any)(456);  // allocate an object and call func as constructor
+func.call(a, 123);               // pass an existing object to func
+console.log(a);
+console.log(b);
diff --git a/src/MapleFE/test/typescript/unit_tests/func2.ts.result b/src/MapleFE/test/typescript/unit_tests/func2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..625e3d3318cb55f35c53863f451beff326e78473
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func2.ts.result
@@ -0,0 +1,24 @@
+Matched 36 tokens.
+Matched 42 tokens.
+Matched 55 tokens.
+Matched 64 tokens.
+Matched 71 tokens.
+Matched 78 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(this,arg)  throws: 
+  js_var Decl: x
+  this.val1 Assign arg
+  x Assign this.val1
+  this.val2 Assign x
+
+== Sub Tree ==
+js_var Decl: a= {}
+== Sub Tree ==
+js_var Decl: b=new func(456)
+== Sub Tree ==
+func.call(a,123)
+== Sub Tree ==
+console.log(a)
+== Sub Tree ==
+console.log(b)
diff --git a/src/MapleFE/test/typescript/unit_tests/func3.ts b/src/MapleFE/test/typescript/unit_tests/func3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..193eef9e3605b7b2b8ce481abe6ee84ebb8a34d4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func3.ts
@@ -0,0 +1,17 @@
+interface Foo {
+  val1: number;
+  val2: number;
+};
+
+function func(this: Foo , arg: number) {
+  var x:number;
+  this.val1 = arg;
+  x = this.val1;
+  this.val2 = x;
+}
+
+var a: Foo = {val1:0, val2:0};
+var b = new (func as any)(456);  // allocate an object and call func as constructor
+func.call(a, 123);               // pass an existing object to func
+console.log(a);
+console.log(b);
diff --git a/src/MapleFE/test/typescript/unit_tests/func3.ts.result b/src/MapleFE/test/typescript/unit_tests/func3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a316b87d3fdb55370db56143852baa5b263dae61
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func3.ts.result
@@ -0,0 +1,28 @@
+Matched 12 tokens.
+Matched 13 tokens.
+Matched 49 tokens.
+Matched 64 tokens.
+Matched 77 tokens.
+Matched 86 tokens.
+Matched 93 tokens.
+Matched 100 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Foo {val1;val2 }
+== Sub Tree ==
+func  func(this,arg)  throws: 
+  js_var Decl: x
+  this.val1 Assign arg
+  x Assign this.val1
+  this.val2 Assign x
+
+== Sub Tree ==
+js_var Decl: a= {val1:0, val2:0}
+== Sub Tree ==
+js_var Decl: b=new func(456)
+== Sub Tree ==
+func.call(a,123)
+== Sub Tree ==
+console.log(a)
+== Sub Tree ==
+console.log(b)
diff --git a/src/MapleFE/test/typescript/unit_tests/func4.ts b/src/MapleFE/test/typescript/unit_tests/func4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0ecb7843b2d7d2dfa13564ae4d76692782a6770f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func4.ts
@@ -0,0 +1,17 @@
+class Foo {
+  public val1: number = 0;
+  public val2: number = 0;
+};
+
+function func(this: Foo , arg: number) {
+  var x:number;
+  this.val1 = arg;
+  x = this.val1;
+  this.val2 = x;
+}
+
+var a = new  Foo();
+var b = new (func as any)(456);  // allocate an object and call func as constructor
+func.call(a, 123);               // pass an existing object to func
+console.log(a);
+console.log(b);
diff --git a/src/MapleFE/test/typescript/unit_tests/func4.ts.result b/src/MapleFE/test/typescript/unit_tests/func4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..bd8ceb2fffed5b2005807c4b3e703831fcc92e33
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func4.ts.result
@@ -0,0 +1,36 @@
+Matched 18 tokens.
+Matched 19 tokens.
+Matched 55 tokens.
+Matched 63 tokens.
+Matched 76 tokens.
+Matched 85 tokens.
+Matched 92 tokens.
+Matched 99 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    val1=0    val2=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func(this,arg)  throws: 
+  js_var Decl: x
+  this.val1 Assign arg
+  x Assign this.val1
+  this.val2 Assign x
+
+== Sub Tree ==
+js_var Decl: a=new Foo()
+== Sub Tree ==
+js_var Decl: b=new func(456)
+== Sub Tree ==
+func.call(a,123)
+== Sub Tree ==
+console.log(a)
+== Sub Tree ==
+console.log(b)
diff --git a/src/MapleFE/test/typescript/unit_tests/func5.ts b/src/MapleFE/test/typescript/unit_tests/func5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..07b11f4dbdf8e1528f29059c9047d068967bb4b2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func5.ts
@@ -0,0 +1,8 @@
+function func(arg: number): number {
+  return arg;;
+}
+
+var a = new (func as any)(123);
+console.log(a);
+console.log(func(123));
+
diff --git a/src/MapleFE/test/typescript/unit_tests/func5.ts.result b/src/MapleFE/test/typescript/unit_tests/func5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..590d2ebbdbd504c9382d5447229f6987690dc0fb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/func5.ts.result
@@ -0,0 +1,15 @@
+Matched 15 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+Matched 45 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(arg)  throws: 
+  return arg
+
+== Sub Tree ==
+js_var Decl: a=new func(123)
+== Sub Tree ==
+console.log(a)
+== Sub Tree ==
+console.log(func(123))
diff --git a/src/MapleFE/test/typescript/unit_tests/function-1.ts b/src/MapleFE/test/typescript/unit_tests/function-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cba43a07774dad3191704949e40f7d9a4f114f11
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-1.ts
@@ -0,0 +1,6 @@
+function add(a: number, b: number) {
+  return a + b;
+}
+
+var c = add(1, 2);
+console.log(c);
diff --git a/src/MapleFE/test/typescript/unit_tests/function-1.ts.result b/src/MapleFE/test/typescript/unit_tests/function-1.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..20ef4e8dbefea7b97213d5aa8ee02f751acaaa8a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-1.ts.result
@@ -0,0 +1,12 @@
+Matched 18 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+============= Module ===========
+== Sub Tree ==
+func  add(a,b)  throws: 
+  return a Add b
+
+== Sub Tree ==
+js_var Decl: c=add(1,2)
+== Sub Tree ==
+console.log(c)
diff --git a/src/MapleFE/test/typescript/unit_tests/function-2.ts b/src/MapleFE/test/typescript/unit_tests/function-2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aad00728c6cfecb86c45a5fd4bfe59c4a4903fc4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-2.ts
@@ -0,0 +1,7 @@
+function add(a: number, b: number) {
+  return a + b;
+}
+
+// Allowed by ECMAScript 2017
+var c = add(1, 2);
+console.log(c);
diff --git a/src/MapleFE/test/typescript/unit_tests/function-2.ts.result b/src/MapleFE/test/typescript/unit_tests/function-2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..20ef4e8dbefea7b97213d5aa8ee02f751acaaa8a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-2.ts.result
@@ -0,0 +1,12 @@
+Matched 18 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+============= Module ===========
+== Sub Tree ==
+func  add(a,b)  throws: 
+  return a Add b
+
+== Sub Tree ==
+js_var Decl: c=add(1,2)
+== Sub Tree ==
+console.log(c)
diff --git a/src/MapleFE/test/typescript/unit_tests/function-3.ts b/src/MapleFE/test/typescript/unit_tests/function-3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..06a994b1570bc4fd78318043b679427c30b45647
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-3.ts
@@ -0,0 +1,9 @@
+function func(x: number) {
+  //if (x < 0) {x = 0};
+  if (x < 0) {
+    x = 0;
+  }
+  console.log(x);
+}
+func(10);
+func(-10);
diff --git a/src/MapleFE/test/typescript/unit_tests/function-3.ts.result b/src/MapleFE/test/typescript/unit_tests/function-3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..175ff10d9c688788dc56fce8c1a81e31675c9b06
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-3.ts.result
@@ -0,0 +1,17 @@
+Matched 28 tokens.
+Matched 33 tokens.
+Matched 38 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(x)  throws: 
+  cond-branch cond:x LT 0
+  true branch :
+    x Assign 0
+  false branch :
+
+  console.log(x)
+
+== Sub Tree ==
+func(10)
+== Sub Tree ==
+func(-10)
diff --git a/src/MapleFE/test/typescript/unit_tests/function-arg-obj-literal.ts b/src/MapleFE/test/typescript/unit_tests/function-arg-obj-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cedf317fd74b0158feb7c7a9285e2eea9db38f2f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-arg-obj-literal.ts
@@ -0,0 +1,6 @@
+const f1: number = 1;
+const f2: number = 2;
+
+function foo(arg: any) {}
+
+foo({ f1, f2 });
diff --git a/src/MapleFE/test/typescript/unit_tests/function-arg-obj-literal.ts.result b/src/MapleFE/test/typescript/unit_tests/function-arg-obj-literal.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..25f072ce4b3fb244444d4bdf15c89d7f480b9286
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-arg-obj-literal.ts.result
@@ -0,0 +1,14 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 23 tokens.
+Matched 32 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: f1=1
+== Sub Tree ==
+js_const Decl: f2=2
+== Sub Tree ==
+func  foo(arg)  throws: 
+
+== Sub Tree ==
+foo( {:f1, :f2})
diff --git a/src/MapleFE/test/typescript/unit_tests/function-type.ts b/src/MapleFE/test/typescript/unit_tests/function-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b82962914789605b311d4ca0c90c2c36af303777
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-type.ts
@@ -0,0 +1,3 @@
+let f: (x: number) => number;
+f = (x: number): number => x / 3;
+console.log(f(6));
diff --git a/src/MapleFE/test/typescript/unit_tests/function-type.ts.result b/src/MapleFE/test/typescript/unit_tests/function-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..31a87da43ac52c1c41ce6a96becc14929bed746e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-type.ts.result
@@ -0,0 +1,10 @@
+Matched 11 tokens.
+Matched 25 tokens.
+Matched 35 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: f
+== Sub Tree ==
+f Assign (x) -> x Div 3
+== Sub Tree ==
+console.log(f(6))
diff --git a/src/MapleFE/test/typescript/unit_tests/function-with-this.ts b/src/MapleFE/test/typescript/unit_tests/function-with-this.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8512d316801d98d8ed90762288c959f04ea8f8d0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-with-this.ts
@@ -0,0 +1,3 @@
+interface Foo<T> {
+  func<T>(callback: (this: void, v: T) => v is T, thisArg?: any): T;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/function-with-this.ts.result b/src/MapleFE/test/typescript/unit_tests/function-with-this.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b4073672ad44981d9989f58b6c38315bbf1f3512
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/function-with-this.ts.result
@@ -0,0 +1,5 @@
+Matched 36 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Foo<T,> {func  func<T>(callback,thisArg?)  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/generate-result.sh b/src/MapleFE/test/typescript/unit_tests/generate-result.sh
new file mode 100755
index 0000000000000000000000000000000000000000..8666e69ca4928442d8c44d64076f7704d59f348c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generate-result.sh
@@ -0,0 +1,23 @@
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+# 
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+# 
+#  http://license.coscl.org.cn/MulanPSL2
+# 
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# 
+
+#!/bin/bash
+FILES=( class-implements-interface.ts construct-signature.ts interface-keyof.ts)
+
+
+for f in ${FILES[@]}
+do
+  echo "Generating result for $f ..."
+  ../../../output/typescript/bin/ts2ast $f > $f.result
+done
diff --git a/src/MapleFE/test/typescript/unit_tests/generator.ts b/src/MapleFE/test/typescript/unit_tests/generator.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6841e1c54cbd89c745f6ddd5b794b6996b931f02
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generator.ts
@@ -0,0 +1,15 @@
+function* gen(n: number): Generator<number, string, boolean> {
+  for (var i = 1; i <= n; i++) {
+    let res = yield i;
+    console.log(res);
+    if (res)
+      break;
+  }
+  return "done";
+}
+
+const obj: Generator<number, string, boolean> = gen(10);
+console.log(obj.next());
+console.log(obj.next(false));
+console.log(obj.next(true));
+console.log(obj.next());
diff --git a/src/MapleFE/test/typescript/unit_tests/generator.ts.result b/src/MapleFE/test/typescript/unit_tests/generator.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3bde9f39cf03cfd0dc24a61c026635c834548833
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generator.ts.result
@@ -0,0 +1,30 @@
+Matched 57 tokens.
+Matched 74 tokens.
+Matched 85 tokens.
+Matched 97 tokens.
+Matched 109 tokens.
+Matched 120 tokens.
+============= Module ===========
+== Sub Tree ==
+generator gen(n)  throws: 
+  for ( )
+    js_let Decl: res=yield i
+    console.log(res)
+    cond-branch cond:res
+    true branch :
+      break:
+    false branch :
+
+
+  return "done"
+
+== Sub Tree ==
+js_const Decl: obj=gen(10)
+== Sub Tree ==
+console.log(obj.next())
+== Sub Tree ==
+console.log(obj.next(false))
+== Sub Tree ==
+console.log(obj.next(true))
+== Sub Tree ==
+console.log(obj.next())
diff --git a/src/MapleFE/test/typescript/unit_tests/generator2.ts b/src/MapleFE/test/typescript/unit_tests/generator2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d6c34586107e1575f9ac5c265d2bc9a71f34ac90
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generator2.ts
@@ -0,0 +1,20 @@
+function* delegate(num: number) : Generator<number> {
+  let r = yield num + 100;
+  return r;
+}
+
+function* gen(n: number): Generator<number, string, boolean> {
+  for (var i = 1; i <= n; i++) {
+    let res = yield* delegate(i);
+    console.log(res);
+    if (res)
+      break;
+  }
+  return "done";
+}
+
+const obj: Generator<number, string, boolean> = gen(10);
+console.log(obj.next());
+console.log(obj.next(false));
+console.log(obj.next(true));
+console.log(obj.next());
diff --git a/src/MapleFE/test/typescript/unit_tests/generator2.ts.result b/src/MapleFE/test/typescript/unit_tests/generator2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2ea5af65bc91b406983534dca5e4ecbd3891dff6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generator2.ts.result
@@ -0,0 +1,36 @@
+Matched 26 tokens.
+Matched 87 tokens.
+Matched 104 tokens.
+Matched 115 tokens.
+Matched 127 tokens.
+Matched 139 tokens.
+Matched 150 tokens.
+============= Module ===========
+== Sub Tree ==
+generator delegate(num)  throws: 
+  js_let Decl: r=yield num Add 100
+  return r
+
+== Sub Tree ==
+generator gen(n)  throws: 
+  for ( )
+    js_let Decl: res=yield* delegate(i)
+    console.log(res)
+    cond-branch cond:res
+    true branch :
+      break:
+    false branch :
+
+
+  return "done"
+
+== Sub Tree ==
+js_const Decl: obj=gen(10)
+== Sub Tree ==
+console.log(obj.next())
+== Sub Tree ==
+console.log(obj.next(false))
+== Sub Tree ==
+console.log(obj.next(true))
+== Sub Tree ==
+console.log(obj.next())
diff --git a/src/MapleFE/test/typescript/unit_tests/generator3.ts b/src/MapleFE/test/typescript/unit_tests/generator3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bebfbb653f42a09ff2d5c5085169a6fe4247fb0d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generator3.ts
@@ -0,0 +1,14 @@
+function* foo(index: number) {
+  while (index < 2) {
+    yield index;
+    index++;
+  }
+}
+
+const iterator = foo(0);
+
+console.log(iterator.next().value);
+// expected output: 0
+
+console.log(iterator.next().value);
+// expected output: 1
diff --git a/src/MapleFE/test/typescript/unit_tests/generator3.ts.result b/src/MapleFE/test/typescript/unit_tests/generator3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..dee32f9b52d6f90a88b406dcf35a2244e10976f0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generator3.ts.result
@@ -0,0 +1,18 @@
+Matched 24 tokens.
+Matched 32 tokens.
+Matched 45 tokens.
+Matched 58 tokens.
+============= Module ===========
+== Sub Tree ==
+generator foo(index)  throws: 
+  while index LT 2    yield index
+    index Inc
+
+
+
+== Sub Tree ==
+js_const Decl: iterator=foo(0)
+== Sub Tree ==
+console.log(iterator.next().value)
+== Sub Tree ==
+console.log(iterator.next().value)
diff --git a/src/MapleFE/test/typescript/unit_tests/generator4.ts b/src/MapleFE/test/typescript/unit_tests/generator4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8d61465c3a387781224ed42ecf6c87ceeff6dc51
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generator4.ts
@@ -0,0 +1,25 @@
+class IterableClass {
+  public elements: number[];
+
+  constructor() {
+    this.elements = [];
+  }
+
+  add(element:number) {
+    this.elements.push(element);
+  }
+
+  * [Symbol.iterator]() {
+    let element:number;
+    for (element of this.elements) {
+      yield element;
+    }
+  }
+}
+
+let obj = new IterableClass();
+obj.add(123);
+obj.add(456);
+for (let e of obj) {
+  console.log(e);
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/generator4.ts.result b/src/MapleFE/test/typescript/unit_tests/generator4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b09da6af24a7c4b6cb26f6b81171329ead8cb5d8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generator4.ts.result
@@ -0,0 +1,35 @@
+Matched 68 tokens.
+Matched 76 tokens.
+Matched 83 tokens.
+Matched 90 tokens.
+Matched 106 tokens.
+============= Module ===========
+== Sub Tree ==
+class  IterableClass
+  Fields: 
+    elements
+  Instance Initializer: 
+  Constructors: 
+    constructor  ()  throws: 
+      this.elements Assign []
+  Methods: 
+    func  add(element)  throws: 
+      this.elements.push(element)
+    func  ()  throws: 
+      js_let Decl: element
+      for ( )
+        yield element
+
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: obj=new IterableClass()
+== Sub Tree ==
+obj.add(123)
+== Sub Tree ==
+obj.add(456)
+== Sub Tree ==
+for ( )
+  console.log(e)
+
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-func-in-interface.ts b/src/MapleFE/test/typescript/unit_tests/generic-func-in-interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4f22113aacf9aea268ca30e23dc9c8a66e26c665
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-func-in-interface.ts
@@ -0,0 +1,3 @@
+interface IFace {
+    any<T>(arg: (T | Iterable<T>)[] | string): Iterable<T>;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-func-in-interface.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-func-in-interface.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3e9868346023bbbfbfa187744b32abb2f5779acf
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-func-in-interface.ts.result
@@ -0,0 +1,5 @@
+Matched 30 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {func  any<T>(arg)  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-function.ts b/src/MapleFE/test/typescript/unit_tests/generic-function.ts
new file mode 100644
index 0000000000000000000000000000000000000000..770e5fa265e6d3f7f641e61227cd00f0f5e1b079
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-function.ts
@@ -0,0 +1,8 @@
+class Klass {
+  func<T extends (...any: any) => void>(cb: T): typeof cb {
+    return cb;
+  }
+}
+
+var obj: Klass = new Klass();
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-function.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-function.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f70238895d88062d4df73e715ea244b774516cce
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-function.ts.result
@@ -0,0 +1,20 @@
+Matched 30 tokens.
+Matched 40 tokens.
+Matched 47 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func<T>(cb)  throws: 
+      return cb
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-function2.ts b/src/MapleFE/test/typescript/unit_tests/generic-function2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4b4462f6ba2240c51da6023455630269c2fc6aa0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-function2.ts
@@ -0,0 +1,5 @@
+class Klass {
+  func<T extends (...any: any) => void>(cb: T): typeof cb {
+    return cb;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-function2.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-function2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..532d8cd1717395cac197f1156d302af708ebe5dc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-function2.ts.result
@@ -0,0 +1,14 @@
+Matched 30 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func<T>(cb)  throws: 
+      return cb
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-lambda.ts b/src/MapleFE/test/typescript/unit_tests/generic-lambda.ts
new file mode 100644
index 0000000000000000000000000000000000000000..abd3301280adb0d6c90a5a9076e2a5afdce4f4ff
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-lambda.ts
@@ -0,0 +1,2 @@
+const func = (() => (<T>(x: any): x is T[] => x && typeof x.length === 'number'))();
+console.log(func([1,2]));
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-lambda.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-lambda.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..15adaddb422ef8b456b40b469b76e2cdaee8117e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-lambda.ts.result
@@ -0,0 +1,7 @@
+Matched 36 tokens.
+Matched 50 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: func=() -> (x) -> x Land  typeof x.length StEq "number"()
+== Sub Tree ==
+console.log(func([1,2]))
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-prim-array.ts b/src/MapleFE/test/typescript/unit_tests/generic-prim-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bc7ecd71559b91547597ac57cbbc3b80359a23a1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-prim-array.ts
@@ -0,0 +1,9 @@
+class Klass<T> {
+  f: T | undefined = undefined;
+}
+
+const t = new Klass<number[]>();
+t.f = [123, 456];
+console.log(typeof t);
+
+export type MyType = Klass<typeof t>;
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-prim-array.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-prim-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..add060b50d7fb34a9516c23e4f87675edd064c91
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-prim-array.ts.result
@@ -0,0 +1,24 @@
+Matched 15 tokens.
+Matched 28 tokens.
+Matched 38 tokens.
+Matched 46 tokens.
+Matched 56 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+<T,>  Fields: 
+    f=undefined
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_const Decl: t=new Klass()
+== Sub Tree ==
+t.f Assign [123,456]
+== Sub Tree ==
+console.log( typeof t)
+== Sub Tree ==
+export { type MyType = Klass< typeof t>} 
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-type.ts b/src/MapleFE/test/typescript/unit_tests/generic-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7f615ab1c8cee4e83d473a591cb1049ce3e45bf3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-type.ts
@@ -0,0 +1 @@
+type TYPE<T, K extends keyof T> = { [P in K]?: T[P] };
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-type.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9dba2969ad3ff698e1d3531d3915c036563c9e91
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-type.ts.result
@@ -0,0 +1,4 @@
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+ type TYPE<T,K> =  {[P in K] : T[P] }
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-type2.ts b/src/MapleFE/test/typescript/unit_tests/generic-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..38e7871591b036632e47aa66e5cae7b90941a97f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-type2.ts
@@ -0,0 +1,9 @@
+class Klass {
+  [x: string]: number;
+}
+
+class EXT<B, T> {
+  [key: string]: B;
+}
+
+type TYPE<B, T> = EXT<B, T>[keyof Klass];
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-type2.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-type2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..bcb9d64635b5da0e17549af29ad74868693c613f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-type2.ts.result
@@ -0,0 +1,26 @@
+Matched 12 tokens.
+Matched 29 tokens.
+Matched 48 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    number
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  EXT
+<B,T,>  Fields: 
+    B
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+ type TYPE<B,T> = EXT<B,T>[ keyof Klass]
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-type3.ts b/src/MapleFE/test/typescript/unit_tests/generic-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5d109408f3f7b20d113a13d4a0a61a416904c5cc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-type3.ts
@@ -0,0 +1,3 @@
+interface IFace {
+    func<T>(): Promise<T extends PromiseLike<infer U> ? U : T>;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-type3.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-type3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a6f568ecd31d56fb1fe8e20f36b00be8e3f386af
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-type3.ts.result
@@ -0,0 +1,5 @@
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {func  func<T>()  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-type4.ts b/src/MapleFE/test/typescript/unit_tests/generic-type4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d9b3d4ab6c6f9460f11cdcfcb427250ae8603eef
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-type4.ts
@@ -0,0 +1,2 @@
+type NT<T, R> = ((args: Array<T>) => PromiseLike<Array<R>>) | ((args: Array<T>) => Array<R>) | ((args: Array<T>) => void);
+
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-type4.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-type4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..64505c225af2ad79852ee5abebe2f0e1f41826ea
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-type4.ts.result
@@ -0,0 +1,4 @@
+Matched 55 tokens.
+============= Module ===========
+== Sub Tree ==
+ type NT<T,R> = union  = (args) ->  | (args) ->  | (args) -> 
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-typeof.ts b/src/MapleFE/test/typescript/unit_tests/generic-typeof.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a2df74ba0364c61193d881848145bc34c2132333
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-typeof.ts
@@ -0,0 +1,9 @@
+class Klass<T> {
+  f: T | undefined = undefined;
+}
+
+const t = new Klass<number>();
+t.f = 123;
+console.log(typeof t);
+
+export type MyType = Klass<typeof t>;
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-typeof.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-typeof.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e506463ca15a6fe7960c1a4a6239d6a257a124f1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-typeof.ts.result
@@ -0,0 +1,24 @@
+Matched 15 tokens.
+Matched 26 tokens.
+Matched 32 tokens.
+Matched 40 tokens.
+Matched 50 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+<T,>  Fields: 
+    f=undefined
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_const Decl: t=new Klass()
+== Sub Tree ==
+t.f Assign 123
+== Sub Tree ==
+console.log( typeof t)
+== Sub Tree ==
+export { type MyType = Klass< typeof t>} 
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-typeof2.ts b/src/MapleFE/test/typescript/unit_tests/generic-typeof2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9afd4945d80956963161c92a58d17e38f57695af
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-typeof2.ts
@@ -0,0 +1,17 @@
+class Klass<T> {
+  f: T;
+  constructor(t: T) {
+    this.f = t;
+  }
+}
+class Foo {
+  foo: number;
+  constructor(n: number) {
+    this.foo = n;
+  }
+}
+const PROP = "foo";
+type FooType = Klass<Foo[typeof PROP]>;
+
+var obj: FooType = new Klass<Foo[typeof PROP]>(123);
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-typeof2.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-typeof2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e38a4c22cdbb31899776b7e81a965b4d541ee02a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-typeof2.ts.result
@@ -0,0 +1,39 @@
+Matched 25 tokens.
+Matched 47 tokens.
+Matched 52 tokens.
+Matched 64 tokens.
+Matched 82 tokens.
+Matched 89 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+<T,>  Fields: 
+    f
+  Instance Initializer: 
+  Constructors: 
+    constructor  (t)  throws: 
+      this.f Assign t
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Foo
+  Fields: 
+    foo
+  Instance Initializer: 
+  Constructors: 
+    constructor  (n)  throws: 
+      this.foo Assign n
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_const Decl: PROP="foo"
+== Sub Tree ==
+ type FooType = Klass<Foo[ typeof PROP]>
+== Sub Tree ==
+js_var Decl: obj=new Klass(123)
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-with-func.ts b/src/MapleFE/test/typescript/unit_tests/generic-with-func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1983eb47463a1799a076cc9cb7863b11a334712d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-with-func.ts
@@ -0,0 +1,2 @@
+var map: Map<string, (e: number) => void> = new Map();
+console.log(map);
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-with-func.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-with-func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..040306f38b2205de3b09b7e54a0fe44038ee439e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-with-func.ts.result
@@ -0,0 +1,7 @@
+Matched 21 tokens.
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: map=new Map()
+== Sub Tree ==
+console.log(map)
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-with-init.ts b/src/MapleFE/test/typescript/unit_tests/generic-with-init.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b30c847907193b6aeab06a753f3e559db991cec0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-with-init.ts
@@ -0,0 +1,9 @@
+class Klass {
+  u: number = 0;
+  v: string = "";
+
+  constructor ({u, v}: Partial<Klass>= {}) {
+    this.u = u ? u : this.u;
+    this.v = v ? v : this.v;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/generic-with-init.ts.result b/src/MapleFE/test/typescript/unit_tests/generic-with-init.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2eae95e289350e27ee9220b4904ce31491de6b99
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generic-with-init.ts.result
@@ -0,0 +1,15 @@
+Matched 58 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    u=0    v=""
+  Instance Initializer: 
+  Constructors: 
+    constructor  ({:u, :v})  throws: 
+      this.u Assign u ? u : this.u
+      this.v Assign v ? v : this.v
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/generics-array.ts b/src/MapleFE/test/typescript/unit_tests/generics-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d5fb5bb87c2efaeb61e9285f3e5ad2f782158641
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generics-array.ts
@@ -0,0 +1,32 @@
+// Define generic element pool using array
+class Pool<T> {
+  private _pool: T[] = [];
+
+  public put(element: T) {
+    this._pool.push(element);
+  }
+  public get(): T | undefined{
+    return this._pool.pop();
+  }
+  public size(): number {
+    return this._pool.length;
+  }
+}
+
+class Foo {
+  public _id: number;
+
+  constructor(id: number) {
+    this._id = id;
+  }
+}
+
+// Create array of primary type values
+const primPool = new Pool<number>();
+primPool.put(10);
+console.log(primPool.get());
+
+// Create array of objects
+const objPool = new Pool<Foo>();
+objPool.put(new Foo(100));
+console.log(objPool.get()?._id);
diff --git a/src/MapleFE/test/typescript/unit_tests/generics-array.ts.result b/src/MapleFE/test/typescript/unit_tests/generics-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c330b689fe8a683f11e9156c3df428f819cacddd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generics-array.ts.result
@@ -0,0 +1,49 @@
+Matched 69 tokens.
+Matched 92 tokens.
+Matched 103 tokens.
+Matched 110 tokens.
+Matched 121 tokens.
+Matched 132 tokens.
+Matched 143 tokens.
+Matched 156 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Pool
+<T,>  Fields: 
+    _pool=[]
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  put(element)  throws: 
+      this._pool.push(element)
+    func  get()  throws: 
+      return this._pool.pop()
+    func  size()  throws: 
+      return this._pool.length
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Foo
+  Fields: 
+    _id
+  Instance Initializer: 
+  Constructors: 
+    constructor  (id)  throws: 
+      this._id Assign id
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_const Decl: primPool=new Pool()
+== Sub Tree ==
+primPool.put(10)
+== Sub Tree ==
+console.log(primPool.get())
+== Sub Tree ==
+js_const Decl: objPool=new Pool()
+== Sub Tree ==
+objPool.put(new Foo(100))
+== Sub Tree ==
+console.log(objPool.get()._id)
diff --git a/src/MapleFE/test/typescript/unit_tests/generics.ts b/src/MapleFE/test/typescript/unit_tests/generics.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0202303b548f143be66feaad72d31cf4448e3bed
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generics.ts
@@ -0,0 +1,7 @@
+function foo<T>(arg: T): T {
+  return arg;
+}
+
+let output = foo<string>("abc");
+
+console.log(output);
diff --git a/src/MapleFE/test/typescript/unit_tests/generics.ts.result b/src/MapleFE/test/typescript/unit_tests/generics.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0d04416aa8ff7aa45337bb340f4562741eacbf0c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generics.ts.result
@@ -0,0 +1,12 @@
+Matched 17 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+============= Module ===========
+== Sub Tree ==
+func  foo<T>(arg)  throws: 
+  return arg
+
+== Sub Tree ==
+js_let Decl: output=foo<string>("abc")
+== Sub Tree ==
+console.log(output)
diff --git a/src/MapleFE/test/typescript/unit_tests/generics2.ts b/src/MapleFE/test/typescript/unit_tests/generics2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..67ae8d57f8c3637d1428f21ae860a5e807c0d311
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generics2.ts
@@ -0,0 +1,11 @@
+class E<T> {
+  t: T | undefined = undefined;
+}
+
+class Klass {
+  public n: E<{ s: string }> | undefined = undefined;
+}
+
+var obj: Klass = new Klass();
+obj.n = { t: { s: "example" } };
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/generics2.ts.result b/src/MapleFE/test/typescript/unit_tests/generics2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2c8b746200f832bbb7c110000a9f3fbd2e689ecf
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/generics2.ts.result
@@ -0,0 +1,32 @@
+Matched 15 tokens.
+Matched 35 tokens.
+Matched 45 tokens.
+Matched 59 tokens.
+Matched 66 tokens.
+============= Module ===========
+== Sub Tree ==
+class  E
+<T,>  Fields: 
+    t=undefined
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+    n=undefined
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj.n Assign  {t: {s:"example"}}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/getter-setter.ts b/src/MapleFE/test/typescript/unit_tests/getter-setter.ts
new file mode 100644
index 0000000000000000000000000000000000000000..373eafc9ddfb268597ee4033fba1c8c45af72b9f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/getter-setter.ts
@@ -0,0 +1,13 @@
+const obj = {
+  prop: "foo",
+  get getProp(): string {
+    return this.prop;
+  },
+  set setProp(newVal: string) {
+    this.prop = newVal;
+  },
+};
+
+console.log(obj.getProp);
+obj.setProp = "bar";
+console.log(obj.getProp);
diff --git a/src/MapleFE/test/typescript/unit_tests/getter-setter.ts.result b/src/MapleFE/test/typescript/unit_tests/getter-setter.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..da6ab4a6d553a4606e2a71d8606eea5ee9c4505c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/getter-setter.ts.result
@@ -0,0 +1,17 @@
+Matched 40 tokens.
+Matched 49 tokens.
+Matched 55 tokens.
+Matched 64 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {prop:"foo", getProp:get getProp()  throws: 
+  return this.prop
+, setProp:set setProp(newVal)  throws: 
+  this.prop Assign newVal
+}
+== Sub Tree ==
+console.log(obj.getProp)
+== Sub Tree ==
+obj.setProp Assign "bar"
+== Sub Tree ==
+console.log(obj.getProp)
diff --git a/src/MapleFE/test/typescript/unit_tests/getter.ts b/src/MapleFE/test/typescript/unit_tests/getter.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c4319fd45d12068e4166543eb704810856a8446c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/getter.ts
@@ -0,0 +1,3 @@
+var obj = { name: "dummy" };
+Object.defineProperty(obj, "name", { get() { return "Name"; } });
+console.log(obj.name);
diff --git a/src/MapleFE/test/typescript/unit_tests/getter.ts.result b/src/MapleFE/test/typescript/unit_tests/getter.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..67c69550bb773a969a1da079103858e5d6ce29b3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/getter.ts.result
@@ -0,0 +1,12 @@
+Matched 9 tokens.
+Matched 29 tokens.
+Matched 38 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: obj= {name:"dummy"}
+== Sub Tree ==
+Object.defineProperty(obj,"name", {get:func  get()  throws: 
+  return "Name"
+})
+== Sub Tree ==
+console.log(obj.name)
diff --git a/src/MapleFE/test/typescript/unit_tests/global-in-module.ts b/src/MapleFE/test/typescript/unit_tests/global-in-module.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d10410d40a7eba58de62d2a88c65d5740f62b5cb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/global-in-module.ts
@@ -0,0 +1,6 @@
+declare module "Module" {
+  global {
+    const flag: boolean;
+  }
+}
+
diff --git a/src/MapleFE/test/typescript/unit_tests/global-in-module.ts.result b/src/MapleFE/test/typescript/unit_tests/global-in-module.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f113982c133c24b05e6342d5d88203fb4e47c389
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/global-in-module.ts.result
@@ -0,0 +1,7 @@
+Matched 13 tokens.
+============= Module ===========
+== Sub Tree ==
+declare ============= Module ===========
+== Sub Tree ==
+declare js_const Decl: flag
+
diff --git a/src/MapleFE/test/typescript/unit_tests/helloworld.ts b/src/MapleFE/test/typescript/unit_tests/helloworld.ts
new file mode 100644
index 0000000000000000000000000000000000000000..940a3ff0ec202582f037ef6f743d606fadab9f32
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/helloworld.ts
@@ -0,0 +1 @@
+console.log("Hello world!");
diff --git a/src/MapleFE/test/typescript/unit_tests/helloworld.ts.result b/src/MapleFE/test/typescript/unit_tests/helloworld.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ffe76bce9eb05088e26e69f3499b49ccd80654ba
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/helloworld.ts.result
@@ -0,0 +1,4 @@
+Matched 7 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log("Hello world!")
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers.ts b/src/MapleFE/test/typescript/unit_tests/identifiers.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf4114c78248c87813d45bf7b23e322a6c007938
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers.ts
@@ -0,0 +1,10 @@
+// Valid identifiers:
+//   abstract as async await
+//   constructor declare from get
+//   is module namespace of
+//   require set type
+
+function type() {
+  return "type";
+}
+console.log(type());
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a15445adc884360ece9677f9ceb6a8f5ce727d6e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers.ts.result
@@ -0,0 +1,9 @@
+Matched 9 tokens.
+Matched 18 tokens.
+============= Module ===========
+== Sub Tree ==
+func  type()  throws: 
+  return "type"
+
+== Sub Tree ==
+console.log(type())
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers10.ts b/src/MapleFE/test/typescript/unit_tests/identifiers10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e1b196a6a6ee5451dba73b5dd2b1957edf077059
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers10.ts
@@ -0,0 +1,3 @@
+interface IFace {
+  throw?: boolean;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers10.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers10.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7444472b77e087220bf902b1d2a17477039e76d6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers10.ts.result
@@ -0,0 +1,4 @@
+Matched 9 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {throw? }
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers11.ts b/src/MapleFE/test/typescript/unit_tests/identifiers11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5e364b1047e3f264333bf85adb13aef5da68cd1a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers11.ts
@@ -0,0 +1,7 @@
+enum ET {
+    type = "type",
+    with = "with"
+}
+abstract class Base<U extends ET, V extends ET> { f1: U | null = null; f2: V | null = null; }
+declare class Klass extends Base<ET.type, ET.with> {}
+
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers11.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers11.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f9e41d0f91caa8d444bf5cd3f7d36044f9562ea2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers11.ts.result
@@ -0,0 +1,26 @@
+Matched 11 tokens.
+Matched 41 tokens.
+Matched 57 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: ET {type="type";with="with" }
+== Sub Tree ==
+class  Base
+<U,V,>  Fields: 
+    f1=null    f2=null
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+declare class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers12.ts b/src/MapleFE/test/typescript/unit_tests/identifiers12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6aa95479017d778d0a3703d6ce09e3fe27743e84
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers12.ts
@@ -0,0 +1,10 @@
+class Klass {
+  f1: number = 123;
+  f2: string = "abc";
+}
+const obj = {
+  func: (o: Klass) : Klass => {
+    return <any> { ...o, private: false };
+  },
+};
+console.log(obj.func(new Klass()));
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers12.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers12.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..87ebf81724a87661aaf93e7663b789129ced54ac
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers12.ts.result
@@ -0,0 +1,19 @@
+Matched 16 tokens.
+Matched 48 tokens.
+Matched 63 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    f1=123    f2="abc"
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_const Decl: obj= {func:(o) -> return (any) {:...o, private:false}
+}
+== Sub Tree ==
+console.log(obj.func(new Klass()))
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers13.ts b/src/MapleFE/test/typescript/unit_tests/identifiers13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0f84141b35505d04c131242a9923031e3bb9269c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers13.ts
@@ -0,0 +1,4 @@
+interface IFace {
+    type:  string;
+    break: boolean;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers13.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers13.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..83468c8dd5fca97802cce142ce32f59e8e9706c8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers13.ts.result
@@ -0,0 +1,4 @@
+Matched 12 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {type;break }
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers14.ts b/src/MapleFE/test/typescript/unit_tests/identifiers14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9279f9018ad0e8b6d63540a4bd3033be726e7414
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers14.ts
@@ -0,0 +1,3 @@
+interface IFace {
+    static(n: number): string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers14.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers14.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..323821496c69a5b309b580ec9fae0460784bb42c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers14.ts.result
@@ -0,0 +1,5 @@
+Matched 13 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {func  static(n)  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers15.ts b/src/MapleFE/test/typescript/unit_tests/identifiers15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a49d4aceb2713a97d9bab889f56a00567c3db13d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers15.ts
@@ -0,0 +1,2 @@
+const obj: { class: any } = { class : "Class" };
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers15.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers15.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4874d30a5c52a3a9d6be7ae319cfb17ac0022368
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers15.ts.result
@@ -0,0 +1,7 @@
+Matched 15 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {class:"Class"}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers16.ts b/src/MapleFE/test/typescript/unit_tests/identifiers16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d907f06d33903035f39e1ace80e5b29e4186d26e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers16.ts
@@ -0,0 +1,2 @@
+const obj: { unknown: any } = { unknown : "Unknown" };
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers16.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers16.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e3c738868ecca035515409697f480231b028c3e1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers16.ts.result
@@ -0,0 +1,7 @@
+Matched 15 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {unknown:"Unknown"}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers17.ts b/src/MapleFE/test/typescript/unit_tests/identifiers17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dea0e73a4f5c357848ab07bdbc00d44781954bf6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers17.ts
@@ -0,0 +1,2 @@
+const obj: { do: any } = { do : "do" };
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers17.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers17.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..eef4e0a980e5fb42aaeb9310582494dcd1375a67
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers17.ts.result
@@ -0,0 +1,7 @@
+Matched 15 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {do:"do"}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers18.ts b/src/MapleFE/test/typescript/unit_tests/identifiers18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b6ae53f9809719f8a8fb08c30ab8ee04db36ea5b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers18.ts
@@ -0,0 +1,5 @@
+interface IFace {
+  if?: string;
+  then?: string;
+  else?: string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers18.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers18.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..dc287fd11da7f2cf24c1e6a186f2208ece445b83
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers18.ts.result
@@ -0,0 +1,4 @@
+Matched 19 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {if?;then?;else? }
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers19.ts b/src/MapleFE/test/typescript/unit_tests/identifiers19.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c0a7c875a11c3b4da0b3591fd6030d2f03d37138
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers19.ts
@@ -0,0 +1,3 @@
+interface IFace {
+  continue(): void;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers19.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers19.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..57e221624fb012faa2709aba01a73f22454a67ab
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers19.ts.result
@@ -0,0 +1,5 @@
+Matched 10 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {func  continue()  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers2.ts b/src/MapleFE/test/typescript/unit_tests/identifiers2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..766bd3d702050e868c326e124a9bb38a6890eff6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers2.ts
@@ -0,0 +1,75 @@
+// Valid identifiers:
+//   abstract as async await
+//   constructor declare from get
+//   is module namespace of
+//   require set type
+
+function abstract() {
+  return "abstract";
+}
+console.log(abstract());
+
+function as() {
+  return "as";
+}
+console.log(as());
+
+function async() {
+  return "async";
+}
+console.log(async());
+
+function await() {
+  return "await";
+}
+console.log(await());
+
+function constructor() {
+  return "constructor";
+}
+console.log(constructor());
+
+function declare() {
+  return "declare";
+}
+console.log(declare());
+
+function from() {
+  return "from";
+}
+console.log(from());
+
+function get() {
+  return "get";
+}
+console.log(get());
+
+function is() {
+  return "is";
+}
+console.log(is());
+
+function module() {
+  return "module";
+}
+console.log(module());
+
+function namespace() {
+  return "namespace";
+}
+console.log(namespace());
+
+function of() {
+  return "of";
+}
+console.log(of());
+
+function require() {
+  return "require";
+}
+console.log(require());
+
+function set() {
+  return "set";
+}
+console.log(set());
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers2.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2171c7e9c0c72fbc1c1bd8656bd4a91605c2b8e4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers2.ts.result
@@ -0,0 +1,113 @@
+Matched 9 tokens.
+Matched 18 tokens.
+Matched 27 tokens.
+Matched 36 tokens.
+Matched 45 tokens.
+Matched 54 tokens.
+Matched 63 tokens.
+Matched 72 tokens.
+Matched 81 tokens.
+Matched 90 tokens.
+Matched 99 tokens.
+Matched 108 tokens.
+Matched 117 tokens.
+Matched 126 tokens.
+Matched 135 tokens.
+Matched 144 tokens.
+Matched 153 tokens.
+Matched 162 tokens.
+Matched 171 tokens.
+Matched 180 tokens.
+Matched 189 tokens.
+Matched 198 tokens.
+Matched 207 tokens.
+Matched 216 tokens.
+Matched 225 tokens.
+Matched 234 tokens.
+Matched 243 tokens.
+Matched 252 tokens.
+============= Module ===========
+== Sub Tree ==
+func  abstract()  throws: 
+  return "abstract"
+
+== Sub Tree ==
+console.log(abstract())
+== Sub Tree ==
+func  as()  throws: 
+  return "as"
+
+== Sub Tree ==
+console.log(as())
+== Sub Tree ==
+func  async()  throws: 
+  return "async"
+
+== Sub Tree ==
+console.log(async())
+== Sub Tree ==
+func  await()  throws: 
+  return "await"
+
+== Sub Tree ==
+console.log(await())
+== Sub Tree ==
+func  constructor()  throws: 
+  return "constructor"
+
+== Sub Tree ==
+console.log(constructor())
+== Sub Tree ==
+func  declare()  throws: 
+  return "declare"
+
+== Sub Tree ==
+console.log(declare())
+== Sub Tree ==
+func  from()  throws: 
+  return "from"
+
+== Sub Tree ==
+console.log(from())
+== Sub Tree ==
+func  get()  throws: 
+  return "get"
+
+== Sub Tree ==
+console.log(get())
+== Sub Tree ==
+func  is()  throws: 
+  return "is"
+
+== Sub Tree ==
+console.log(is())
+== Sub Tree ==
+func  module()  throws: 
+  return "module"
+
+== Sub Tree ==
+console.log(module())
+== Sub Tree ==
+func  namespace()  throws: 
+  return "namespace"
+
+== Sub Tree ==
+console.log(namespace())
+== Sub Tree ==
+func  of()  throws: 
+  return "of"
+
+== Sub Tree ==
+console.log(of())
+== Sub Tree ==
+func  require()  throws: 
+  return "require"
+
+== Sub Tree ==
+console.log(require())
+== Sub Tree ==
+func  set()  throws: 
+  return "set"
+
+== Sub Tree ==
+console.log(set())
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers20.ts b/src/MapleFE/test/typescript/unit_tests/identifiers20.ts
new file mode 100644
index 0000000000000000000000000000000000000000..afe4d26516226adf676dc6949e8967248f417174
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers20.ts
@@ -0,0 +1,11 @@
+class Klass {
+  items: number[] = [];
+  break() {
+    for (const i of this.items)
+      console.log(i);
+  }
+}
+
+var obj: Klass = new Klass();
+obj.items.push(6, 2, 1, 4, 5, 3);
+obj.break();
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers20.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers20.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e9df6598ad3261266dd98f7b1cf95cb3c98d99a9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers20.ts.result
@@ -0,0 +1,24 @@
+Matched 34 tokens.
+Matched 44 tokens.
+Matched 63 tokens.
+Matched 69 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    items=[]
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  break()  throws: 
+      for ( )
+        console.log(i)
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj.items.push(6,2,1,4,5,3)
+== Sub Tree ==
+obj.break()
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers3.ts b/src/MapleFE/test/typescript/unit_tests/identifiers3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..af4744e292e7bd55cea6f78b7655a522711dee51
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers3.ts
@@ -0,0 +1,6 @@
+export declare class Foo {
+  asserts: boolean;
+  trueType: string;
+  falseType: string;
+  constructor(asserts: boolean, trueType: string, falseType: string);
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers3.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..649256342bff594978c925f4f3330c1601ae6cc1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers3.ts.result
@@ -0,0 +1,13 @@
+Matched 33 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare class  Foo
+  Fields: 
+    asserts    trueType    falseType
+  Instance Initializer: 
+  Constructors: 
+    constructor  (asserts,trueType,falseType)  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers4.ts b/src/MapleFE/test/typescript/unit_tests/identifiers4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dc8534dae2baabc0e5d0e74d7b31d494719c1822
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers4.ts
@@ -0,0 +1,4 @@
+interface Inferf {
+  return(v: string): string;
+  throw(e: string): string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers4.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..145b8050dea45cd04f47baa3bf9c962cde3fef56
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers4.ts.result
@@ -0,0 +1,6 @@
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Inferf {func  return(v)  throws: 
+;func  throw(e)  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers5.ts b/src/MapleFE/test/typescript/unit_tests/identifiers5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..afe36ce702b0083941acd589e6e52070543222e2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers5.ts
@@ -0,0 +1,3 @@
+interface IFace<T> {
+  finally(): IFace<T>;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers5.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5377924b5cd82ebf89a9a70847c55e0ba2aaa86e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers5.ts.result
@@ -0,0 +1,5 @@
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace<T,> {func  finally()  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers6.ts b/src/MapleFE/test/typescript/unit_tests/identifiers6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1c13d2ae8877e80973c37af912747f538402cae3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers6.ts
@@ -0,0 +1,3 @@
+interface IFace {
+  for(s: string): any;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers6.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers6.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..bb3cb69bf520b441d046957bc591bb1d67d4625b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers6.ts.result
@@ -0,0 +1,5 @@
+Matched 13 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {func  for(s)  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers7.ts b/src/MapleFE/test/typescript/unit_tests/identifiers7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..975eed4d538faead8b25369477fa3d4e0b389798
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers7.ts
@@ -0,0 +1,4 @@
+interface Inferf {
+  return?(v?: string): string;
+  throw?(e?: string): string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers7.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers7.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ac09659add4eeebbb331a3cee7eaa2618c2c1b2c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers7.ts.result
@@ -0,0 +1,6 @@
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Inferf {func  return?(v?)  throws: 
+;func  throw?(e?)  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers8.ts b/src/MapleFE/test/typescript/unit_tests/identifiers8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1f2107c4064055b927c4815733ef310d85390a33
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers8.ts
@@ -0,0 +1,3 @@
+var func = () => 1;
+export { func as function };
+
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers8.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers8.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0b3473672a7a2b78f3b66cee0fd9e67af175ce1d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers8.ts.result
@@ -0,0 +1,7 @@
+Matched 8 tokens.
+Matched 15 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: func=() -> 1
+== Sub Tree ==
+export {func as function} 
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers9.ts b/src/MapleFE/test/typescript/unit_tests/identifiers9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8d2c02a8a9dacd626ac4b3bdfb0d36de596a3267
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers9.ts
@@ -0,0 +1,6 @@
+enum E {
+    package = "package"
+}
+
+var x: E = E.package;
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/identifiers9.ts.result b/src/MapleFE/test/typescript/unit_tests/identifiers9.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1f59266a702a0a2b14eb28988a4279f7fd21dc3e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/identifiers9.ts.result
@@ -0,0 +1,10 @@
+Matched 7 tokens.
+Matched 16 tokens.
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: E {package="package" }
+== Sub Tree ==
+js_var Decl: x=E.package
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/if-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c61336ffad50ab0113d6456c62f247e95ad7c504
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name.ts
@@ -0,0 +1,3 @@
+interface IFace {
+    if: string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/if-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b20da9ed661b00c1224343241f99eba3d7d75399
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name.ts.result
@@ -0,0 +1,4 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {if }
diff --git a/src/MapleFE/test/typescript/unit_tests/if-as-prop-name2.ts b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..558b7aea596503d97597f5410cf6b0f279996440
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name2.ts
@@ -0,0 +1,4 @@
+class Klass {
+    static if: string = "prop";
+}
+console.log(Klass.if);
diff --git a/src/MapleFE/test/typescript/unit_tests/if-as-prop-name2.ts.result b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f788043747f3ecbc48cd44e7948e59567f37e69e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name2.ts.result
@@ -0,0 +1,15 @@
+Matched 11 tokens.
+Matched 20 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    if="prop"
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+console.log(Klass.if)
diff --git a/src/MapleFE/test/typescript/unit_tests/if-as-prop-name3.ts b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a9cdaf09c6b2f2fc3866dca7ceb072072669d7ea
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name3.ts
@@ -0,0 +1,2 @@
+const obj = { if() { console.log("if"); } }
+obj.if();
diff --git a/src/MapleFE/test/typescript/unit_tests/if-as-prop-name3.ts.result b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..171ccc1b720dd1ef2071cd28c39e3182fa1189bb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-as-prop-name3.ts.result
@@ -0,0 +1,9 @@
+Matched 17 tokens.
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {if:func  if()  throws: 
+  console.log("if")
+}
+== Sub Tree ==
+obj.if()
diff --git a/src/MapleFE/test/typescript/unit_tests/if-else-1.ts b/src/MapleFE/test/typescript/unit_tests/if-else-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0edb1d0abd2f9fed9a11d7980826a6e2e9519f8e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-else-1.ts
@@ -0,0 +1,4 @@
+var a: number = 1;
+var b: number = 2;
+if (a > b) console.log("bigger");
+else console.log("smaller");
diff --git a/src/MapleFE/test/typescript/unit_tests/if-else-1.ts.result b/src/MapleFE/test/typescript/unit_tests/if-else-1.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..22c29c9f261138b846a88d1bcf341ce961a71789
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-else-1.ts.result
@@ -0,0 +1,13 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 35 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: a=1
+== Sub Tree ==
+js_var Decl: b=2
+== Sub Tree ==
+cond-branch cond:a GT b
+true branch :
+  console.log("bigger")false branch :
+  console.log("smaller")
diff --git a/src/MapleFE/test/typescript/unit_tests/if-else-2.ts b/src/MapleFE/test/typescript/unit_tests/if-else-2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1fb2acaadf2221aa6d7f6eb2371b8bfa0cbf3152
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-else-2.ts
@@ -0,0 +1,4 @@
+var a: number = 2;
+var b: number = 1;;
+if (1) a + b;
+else a - b;
diff --git a/src/MapleFE/test/typescript/unit_tests/if-else-2.ts.result b/src/MapleFE/test/typescript/unit_tests/if-else-2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..add6831277eb203efe3bbd8feea79e13e0b949f7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-else-2.ts.result
@@ -0,0 +1,14 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 15 tokens.
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: a=2
+== Sub Tree ==
+js_var Decl: b=1
+== Sub Tree ==
+cond-branch cond:1
+true branch :
+  a Add bfalse branch :
+  a Sub b
diff --git a/src/MapleFE/test/typescript/unit_tests/if-else-3.ts b/src/MapleFE/test/typescript/unit_tests/if-else-3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..68d525a28faa6e0bb14b599725bbeaf21a49537a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-else-3.ts
@@ -0,0 +1,7 @@
+var x: number = 1;
+var a: number = 2;
+var b: number = 3;
+if (x) a + b;
+else if (x) a - b;
+else if (x) a * b;
+else a / b;
diff --git a/src/MapleFE/test/typescript/unit_tests/if-else-3.ts.result b/src/MapleFE/test/typescript/unit_tests/if-else-3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..93d0ecb30469890b7b1edbe10813b908ad7a39eb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-else-3.ts.result
@@ -0,0 +1,22 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 21 tokens.
+Matched 52 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=1
+== Sub Tree ==
+js_var Decl: a=2
+== Sub Tree ==
+js_var Decl: b=3
+== Sub Tree ==
+cond-branch cond:x
+true branch :
+  a Add bfalse branch :
+  cond-branch cond:x
+  true branch :
+    a Sub b  false branch :
+    cond-branch cond:x
+    true branch :
+      a Mul b    false branch :
+      a Div b
diff --git a/src/MapleFE/test/typescript/unit_tests/if-stmt-return.ts b/src/MapleFE/test/typescript/unit_tests/if-stmt-return.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a0c9900940d3a7ddb2f83abe1fa3404c313f2c2c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-stmt-return.ts
@@ -0,0 +1,5 @@
+function func(x: number): void {
+  if (x > 10) return;
+  console.log(x);
+}
+func(2);
diff --git a/src/MapleFE/test/typescript/unit_tests/if-stmt-return.ts.result b/src/MapleFE/test/typescript/unit_tests/if-stmt-return.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9c4909c8379577be7814160d02b9770a695f6ef1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/if-stmt-return.ts.result
@@ -0,0 +1,13 @@
+Matched 26 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(x)  throws: 
+  cond-branch cond:x GT 10
+  true branch :
+    return   false branch :
+
+  console.log(x)
+
+== Sub Tree ==
+func(2)
diff --git a/src/MapleFE/test/typescript/unit_tests/iife.ts b/src/MapleFE/test/typescript/unit_tests/iife.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf2f22435ebe42212862e609cec140b3c1386ebf
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/iife.ts
@@ -0,0 +1,4 @@
+let x: number = 3;
+(function () {
+  console.log(x * x);
+})();
diff --git a/src/MapleFE/test/typescript/unit_tests/iife.ts.result b/src/MapleFE/test/typescript/unit_tests/iife.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f2a003a9a9ae16dbc648b813b6843daa965bb912
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/iife.ts.result
@@ -0,0 +1,9 @@
+Matched 7 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: x=3
+== Sub Tree ==
+func  ()  throws: 
+  console.log(x Mul x)
+()
diff --git a/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49dfd11867a37486316b085c3c68a0ee359de450
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name.ts
@@ -0,0 +1,6 @@
+interface IFace {
+  implements : string;
+}
+
+var obj: IFace = { implements: "implements" };
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..85611f66fef88942c741d238ce59e61daf25548e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name.ts.result
@@ -0,0 +1,10 @@
+Matched 8 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {implements }
+== Sub Tree ==
+js_var Decl: obj= {implements:"implements"}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name2.ts b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b5bae426828e40b8cd9770450e747a965843f426
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name2.ts
@@ -0,0 +1,6 @@
+interface IFace {
+  implements? : string;
+}
+
+var obj: IFace = { implements: "implements" };
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name2.ts.result b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d491d27e0bf901e973ed0cf90ee7e782e3ebac13
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name2.ts.result
@@ -0,0 +1,10 @@
+Matched 9 tokens.
+Matched 20 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {implements? }
+== Sub Tree ==
+js_var Decl: obj= {implements:"implements"}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name3.ts b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d457cadedcb3dedc87f55f38531ef4eaeb68b675
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name3.ts
@@ -0,0 +1,6 @@
+interface IFace {
+  implements? : string;
+}
+
+var obj: IFace = { implements: "implements" };
+console.log(obj.implements);
diff --git a/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name3.ts.result b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cc7ad1ff5167b09d496af637e30ca13940684cf1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/implements-as-prop-name3.ts.result
@@ -0,0 +1,10 @@
+Matched 9 tokens.
+Matched 20 tokens.
+Matched 29 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {implements? }
+== Sub Tree ==
+js_var Decl: obj= {implements:"implements"}
+== Sub Tree ==
+console.log(obj.implements)
diff --git a/src/MapleFE/test/typescript/unit_tests/import-ambient-module.ts b/src/MapleFE/test/typescript/unit_tests/import-ambient-module.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9f98d352e05f8124c1a09b25ceceb52540d2c595
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-ambient-module.ts
@@ -0,0 +1,3 @@
+/// <reference path="import-in-module.ts"/>
+import { X } from "M1";
+import { NS } from "M2";
diff --git a/src/MapleFE/test/typescript/unit_tests/import-ambient-module.ts.result b/src/MapleFE/test/typescript/unit_tests/import-ambient-module.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c71e900f9a1c38da2856901eb5858a378b61611c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-ambient-module.ts.result
@@ -0,0 +1,10 @@
+Matched 8 tokens.
+Matched 15 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+trip-slash reference path = "import-in-module.ts"
+== Sub Tree ==
+import {X} "M1"
+== Sub Tree ==
+import {NS} "M2"
diff --git a/src/MapleFE/test/typescript/unit_tests/import-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/import-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..98e0884aa562bc94c8fecdaf61e1bab04a2a9749
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-as-prop-name.ts
@@ -0,0 +1,3 @@
+declare interface Load {
+  import(n: string, o?: string): Promise<any>;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/import-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/import-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3cb7c20598b67fac6a040d32bcdc13d1d0696e0c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-as-prop-name.ts.result
@@ -0,0 +1,5 @@
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+declare ts_interface: Load {func  import(n,o?)  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/import-class.ts b/src/MapleFE/test/typescript/unit_tests/import-class.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fc319f54b4dc05e65d586f1621822291b3494dee
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-class.ts
@@ -0,0 +1,3 @@
+import Bar = require("./export-class");
+let obj = new Bar(123, 456);
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/import-class.ts.result b/src/MapleFE/test/typescript/unit_tests/import-class.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3660e1fc6f0565bc73149797f2ed1ec1a524e5d3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-class.ts.result
@@ -0,0 +1,10 @@
+Matched 8 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+import { SINGLE "./export-class" as Bar} 
+== Sub Tree ==
+js_let Decl: obj=new Bar(123,456)
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/import-class2.ts b/src/MapleFE/test/typescript/unit_tests/import-class2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..579dd6551cd5d8d37403afe44d6e2a5611b1b53d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-class2.ts
@@ -0,0 +1,3 @@
+import { default as Bar } from "./export-class";
+let obj = new Bar(123, 456);
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/import-class2.ts.result b/src/MapleFE/test/typescript/unit_tests/import-class2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9f2aae989ad862ee6a2d93cdcce2ed2684efdbef
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-class2.ts.result
@@ -0,0 +1,10 @@
+Matched 9 tokens.
+Matched 20 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+import {default as Bar} "./export-class"
+== Sub Tree ==
+js_let Decl: obj=new Bar(123,456)
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/import-deco.ts b/src/MapleFE/test/typescript/unit_tests/import-deco.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ed4af2f38218a42f5e9de614d3b1d638e6eb7094
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-deco.ts
@@ -0,0 +1,12 @@
+import * as deco from "./deco-module";
+
+class Klass {
+  @deco.prop_deco("of")
+  x: number;
+  constructor(i: number) {
+    this.x = i;
+  }
+}
+
+var c = new Klass(3);
+console.log(c.x);
diff --git a/src/MapleFE/test/typescript/unit_tests/import-deco.ts.result b/src/MapleFE/test/typescript/unit_tests/import-deco.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b416506be02af92be2390cfdb75dd15052db926e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-deco.ts.result
@@ -0,0 +1,23 @@
+Matched 7 tokens.
+Matched 36 tokens.
+Matched 45 tokens.
+Matched 54 tokens.
+============= Module ===========
+== Sub Tree ==
+import { * as deco} "./deco-module"
+== Sub Tree ==
+class  Klass
+  Fields: 
+    x
+  Instance Initializer: 
+  Constructors: 
+    constructor  (i)  throws: 
+      this.x Assign i
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: c=new Klass(3)
+== Sub Tree ==
+console.log(c.x)
diff --git a/src/MapleFE/test/typescript/unit_tests/import-default-class.ts b/src/MapleFE/test/typescript/unit_tests/import-default-class.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fdfa5581e5e59b0c7bac91cb4f0b2457361ae6f4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-default-class.ts
@@ -0,0 +1,3 @@
+import type Klass from "./export-default-class";
+var obj: Klass = { f1: 123, f2: "abc" };
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/import-default-class.ts.result b/src/MapleFE/test/typescript/unit_tests/import-default-class.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..85e020e5d1ba8d1c4b4bd96398f26e7e12b7c77b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-default-class.ts.result
@@ -0,0 +1,10 @@
+Matched 6 tokens.
+Matched 21 tokens.
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+import { default as Klass} "./export-default-class"
+== Sub Tree ==
+js_var Decl: obj= {f1:123, f2:"abc"}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/import-in-module.ts b/src/MapleFE/test/typescript/unit_tests/import-in-module.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cd706044623cdefc7e52f80b0f2821e9516f0fe9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-in-module.ts
@@ -0,0 +1,9 @@
+declare module 'M1' {
+  export interface X {}
+}
+
+declare module 'M2' {
+    import { X } from "M1";
+    export namespace NS {
+    }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/import-in-module.ts.result b/src/MapleFE/test/typescript/unit_tests/import-in-module.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1dc7f0b4475a3f28245bb162d2f6a339efa8f1e7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-in-module.ts.result
@@ -0,0 +1,16 @@
+Matched 10 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+declare ============= Module ===========
+== Sub Tree ==
+export {ts_interface: X { }} 
+
+== Sub Tree ==
+declare ============= Module ===========
+== Sub Tree ==
+import {X} "M1"
+== Sub Tree ==
+export {namespace  NS
+} 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/import-promise.ts b/src/MapleFE/test/typescript/unit_tests/import-promise.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e3ee013a75a19c62f9517bd469905b43edaf889
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-promise.ts
@@ -0,0 +1,2 @@
+import("./M").then(() => { console.log("Completed") } );
+
diff --git a/src/MapleFE/test/typescript/unit_tests/import-promise.ts.result b/src/MapleFE/test/typescript/unit_tests/import-promise.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e9813196aa05ea002db4b550d65a4d48c7f8cf3a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-promise.ts.result
@@ -0,0 +1,5 @@
+Matched 20 tokens.
+============= Module ===========
+== Sub Tree ==
+import "./M".then(() -> console.log("Completed")
+)
diff --git a/src/MapleFE/test/typescript/unit_tests/import-promise2.ts b/src/MapleFE/test/typescript/unit_tests/import-promise2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5426f510aea1adc4d2e8a4ff99779ef0e2552f35
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-promise2.ts
@@ -0,0 +1,6 @@
+const m : string = "./M";
+import(`${m}`).then(() => {
+  console.log("Completed")
+}).catch(() => {
+  console.log("Failed")
+});
diff --git a/src/MapleFE/test/typescript/unit_tests/import-promise2.ts.result b/src/MapleFE/test/typescript/unit_tests/import-promise2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..919ef976f976b0c311810a71d2efa0dddd6706f5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-promise2.ts.result
@@ -0,0 +1,10 @@
+Matched 7 tokens.
+Matched 42 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: m="./M"
+== Sub Tree ==
+import  template-literal: NULL,m.then(() -> console.log("Completed")
+).catch(() -> console.log("Failed")
+)
diff --git a/src/MapleFE/test/typescript/unit_tests/import-type.ts b/src/MapleFE/test/typescript/unit_tests/import-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8a61f6f18a5164570d361f7607fd17635f0d09b9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-type.ts
@@ -0,0 +1 @@
+import type { Foo } from "./export-type";
diff --git a/src/MapleFE/test/typescript/unit_tests/import-type.ts.result b/src/MapleFE/test/typescript/unit_tests/import-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..202238fb32e24ef6a8669810faa478cb867fa005
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-type.ts.result
@@ -0,0 +1,4 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+import {Foo} "./export-type"
diff --git a/src/MapleFE/test/typescript/unit_tests/import-type2.ts b/src/MapleFE/test/typescript/unit_tests/import-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..214a68b24edceea1adc80ca6d92353339d1c7ea9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-type2.ts
@@ -0,0 +1 @@
+import type { Foo } from "./export-type2";
diff --git a/src/MapleFE/test/typescript/unit_tests/import-type2.ts.result b/src/MapleFE/test/typescript/unit_tests/import-type2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..99a5ed674470358edcc9961ee0ed6be5083bce3f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-type2.ts.result
@@ -0,0 +1,4 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+import {Foo} "./export-type2"
diff --git a/src/MapleFE/test/typescript/unit_tests/import-type3.ts b/src/MapleFE/test/typescript/unit_tests/import-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..093737c50ae88d4521035b70944c883b0ac61d06
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-type3.ts
@@ -0,0 +1 @@
+import type * as TY from "./export-type2";
diff --git a/src/MapleFE/test/typescript/unit_tests/import-type3.ts.result b/src/MapleFE/test/typescript/unit_tests/import-type3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..fe57c8b11faf12ffe743e2e0e0e32da2fab13a00
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-type3.ts.result
@@ -0,0 +1,4 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+import { * as TY} "./export-type2"
diff --git a/src/MapleFE/test/typescript/unit_tests/import-type4.ts b/src/MapleFE/test/typescript/unit_tests/import-type4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..21cacbd55c1103bf01d4704cc6e56b2940912681
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-type4.ts
@@ -0,0 +1,4 @@
+declare const obj: {
+  readonly 'X.Foo': Record<string, import("./export-type").Foo>;
+};
+export { obj };
diff --git a/src/MapleFE/test/typescript/unit_tests/import-type4.ts.result b/src/MapleFE/test/typescript/unit_tests/import-type4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..defa7e018de68be5a31a77516b014e8e348d1127
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/import-type4.ts.result
@@ -0,0 +1,7 @@
+Matched 22 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+declare js_const Decl: obj
+== Sub Tree ==
+export {obj} 
diff --git a/src/MapleFE/test/typescript/unit_tests/imported-type.ts b/src/MapleFE/test/typescript/unit_tests/imported-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5ebc576861d532c59d68842b2f40aaf84a53e4b0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/imported-type.ts
@@ -0,0 +1,3 @@
+declare class Klass {
+    public get flag(): import("./enum2").ET;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/imported-type.ts.result b/src/MapleFE/test/typescript/unit_tests/imported-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d39d2f1ca4f41e9ff4e7c6be60e0b6f7f14f114f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/imported-type.ts.result
@@ -0,0 +1,13 @@
+Matched 18 tokens.
+============= Module ===========
+== Sub Tree ==
+declare class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    get flag()  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/in-operator.ts b/src/MapleFE/test/typescript/unit_tests/in-operator.ts
new file mode 100644
index 0000000000000000000000000000000000000000..574e83ca148e24328aa87bb481b611510bd0ad4e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/in-operator.ts
@@ -0,0 +1,3 @@
+var arr: number[] = [1, 2, 3, 4, 5];
+console.log(3 in arr);
+console.log(7 in arr);
diff --git a/src/MapleFE/test/typescript/unit_tests/in-operator.ts.result b/src/MapleFE/test/typescript/unit_tests/in-operator.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4a97d98d41df6c250bc686cb7c6582001c9bbee9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/in-operator.ts.result
@@ -0,0 +1,10 @@
+Matched 19 tokens.
+Matched 28 tokens.
+Matched 37 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[1,2,3,4,5]
+== Sub Tree ==
+console.log(3 in arr)
+== Sub Tree ==
+console.log(7 in arr)
diff --git a/src/MapleFE/test/typescript/unit_tests/in-operator2.ts b/src/MapleFE/test/typescript/unit_tests/in-operator2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0d0f5ffe7ab5510fe31d8826a9049149da56e804
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/in-operator2.ts
@@ -0,0 +1,8 @@
+type T = {
+  name: string;
+  age: number;
+};
+
+var obj: T = { name: "John", age: 30 };
+console.log("name" in obj);
+console.log("Age" in obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/in-operator2.ts.result b/src/MapleFE/test/typescript/unit_tests/in-operator2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a2534da4adfedc1fe7a6e3c2b35d0c4bfc5e2e7b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/in-operator2.ts.result
@@ -0,0 +1,13 @@
+Matched 14 tokens.
+Matched 29 tokens.
+Matched 38 tokens.
+Matched 47 tokens.
+============= Module ===========
+== Sub Tree ==
+ type T =  {name;age }
+== Sub Tree ==
+js_var Decl: obj= {name:"John", age:30}
+== Sub Tree ==
+console.log("name" in obj)
+== Sub Tree ==
+console.log("Age" in obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/index-signature-1.ts b/src/MapleFE/test/typescript/unit_tests/index-signature-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..54764a60512f5490c3173692eb894e5670eddfe6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/index-signature-1.ts
@@ -0,0 +1,4 @@
+interface dictionary {
+  [index: string]: number;
+  id: number;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/index-signature-1.ts.result b/src/MapleFE/test/typescript/unit_tests/index-signature-1.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..44784cbe74a45d9e4f156bff07344e7bdce3b31b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/index-signature-1.ts.result
@@ -0,0 +1,4 @@
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: dictionary {string index type: numberid }
diff --git a/src/MapleFE/test/typescript/unit_tests/index-signature-2.ts b/src/MapleFE/test/typescript/unit_tests/index-signature-2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f4666349860fe800649cb94f27b28e01448fcdca
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/index-signature-2.ts
@@ -0,0 +1,5 @@
+class Klass {
+  [key: string]: number;
+};
+ 
+type MyArray<T extends { type: string }> = Array<Klass[T['type']]>;
diff --git a/src/MapleFE/test/typescript/unit_tests/index-signature-2.ts.result b/src/MapleFE/test/typescript/unit_tests/index-signature-2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8d4f6fe7da05e49b9238e4cdaf927572bc62ec59
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/index-signature-2.ts.result
@@ -0,0 +1,16 @@
+Matched 12 tokens.
+Matched 13 tokens.
+Matched 36 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    number
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+ type MyArray<T> = Array<Klass[T["type"]]>
diff --git a/src/MapleFE/test/typescript/unit_tests/infer-type.ts b/src/MapleFE/test/typescript/unit_tests/infer-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3b4603d30c2b26ede91fbd5d663917a0269ba08f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/infer-type.ts
@@ -0,0 +1,2 @@
+type U = { n: number };
+type E<T> = T extends Array<infer U> ? T : U;
diff --git a/src/MapleFE/test/typescript/unit_tests/infer-type.ts.result b/src/MapleFE/test/typescript/unit_tests/infer-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0500019406dc00110d0225630086c31d28962974
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/infer-type.ts.result
@@ -0,0 +1,7 @@
+Matched 9 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+ type U =  {n }
+== Sub Tree ==
+ type E<T> = T extends Array< infer U> ? T : U
diff --git a/src/MapleFE/test/typescript/unit_tests/infer-type2.ts b/src/MapleFE/test/typescript/unit_tests/infer-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0e826c6314f637744d5f0764ddf5c8f5551b04b0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/infer-type2.ts
@@ -0,0 +1,8 @@
+// Extracted from https://github.com/cocos-creator/engine/blob/develop/cocos/core/gfx/pipeline-state.jsb.ts#L33
+declare type RecursivePartial<T> = {
+  [P in keyof T]?: T[P] extends Array<infer U>
+    ? Array<RecursivePartial<U>>
+    : T[P] extends ReadonlyArray<infer V>
+    ? ReadonlyArray<RecursivePartial<V>>
+    : RecursivePartial<T[P]>;
+};
diff --git a/src/MapleFE/test/typescript/unit_tests/infer-type2.ts.result b/src/MapleFE/test/typescript/unit_tests/infer-type2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..489bad3ffdcc6f5007bd545dc3b37712ae98863e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/infer-type2.ts.result
@@ -0,0 +1,4 @@
+Matched 62 tokens.
+============= Module ===========
+== Sub Tree ==
+declare  type RecursivePartial<T> =  {[P in  keyof T] : T[P] extends Array< infer U> ? Array<RecursivePartial<U>> : T[P] extends ReadonlyArray< infer V> ? ReadonlyArray<RecursivePartial<V>> : RecursivePartial<T[P]> }
diff --git a/src/MapleFE/test/typescript/unit_tests/infer-type3.ts b/src/MapleFE/test/typescript/unit_tests/infer-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3418e72f9e37f5ab0309396b6461d88277b6f55a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/infer-type3.ts
@@ -0,0 +1,4 @@
+// Extracted from https://github.com/cocos-creator/engine/blob/develop/cocos/core/gfx/pipeline-state.jsb.ts#L33
+export declare type NT<T> = {
+  [P in keyof T]: T[P] extends Record<string, infer U> ? Exclude<U, string> | keyof T[P] : T[P];
+};
diff --git a/src/MapleFE/test/typescript/unit_tests/infer-type3.ts.result b/src/MapleFE/test/typescript/unit_tests/infer-type3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7ab557f1d216eb726ec60eb33ce02c3d713907ff
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/infer-type3.ts.result
@@ -0,0 +1,4 @@
+Matched 49 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare  type NT<T> =  {[P in  keyof T] : T[P] extends Record<string, infer U> ? union  = Exclude<U,string> |  keyof T[P] : T[P] }} 
diff --git a/src/MapleFE/test/typescript/unit_tests/infer-type4.ts b/src/MapleFE/test/typescript/unit_tests/infer-type4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..47da6d2db2892b9851f32701905ddc7675158338
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/infer-type4.ts
@@ -0,0 +1 @@
+type MyType<K extends string[]> = K extends [infer U, ...infer V] ? Extract<V, string[]> : K;
diff --git a/src/MapleFE/test/typescript/unit_tests/infer-type4.ts.result b/src/MapleFE/test/typescript/unit_tests/infer-type4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..039d0a6d76a5a89bb60ddf692d872949c63dbe72
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/infer-type4.ts.result
@@ -0,0 +1,4 @@
+Matched 32 tokens.
+============= Module ===========
+== Sub Tree ==
+ type MyType<K> = K extends  [  :  infer U ,  :  infer V ,  ]  ? Extract<V,prim array-TBD> : K
diff --git a/src/MapleFE/test/typescript/unit_tests/instanceof-1.ts b/src/MapleFE/test/typescript/unit_tests/instanceof-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6be225473aaa871c83a5532f6fe8f0d44d17a691
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/instanceof-1.ts
@@ -0,0 +1,13 @@
+class Foo {}
+
+class Bar {
+  foo: Function = () => null;
+}
+
+var foo:Foo = new Foo();
+var bar:Bar = new Bar();
+bar.foo = Foo;
+console.log(foo instanceof Bar);
+console.log(foo instanceof bar.foo);
+console.log(bar.foo instanceof Bar);
+
diff --git a/src/MapleFE/test/typescript/unit_tests/instanceof-1.ts.result b/src/MapleFE/test/typescript/unit_tests/instanceof-1.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6137523453960a1ceb93ec0b398681e2978958eb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/instanceof-1.ts.result
@@ -0,0 +1,41 @@
+Matched 4 tokens.
+Matched 17 tokens.
+Matched 27 tokens.
+Matched 37 tokens.
+Matched 43 tokens.
+Matched 52 tokens.
+Matched 63 tokens.
+Matched 74 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Bar
+  Fields: 
+    foo=() -> null
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: foo=new Foo()
+== Sub Tree ==
+js_var Decl: bar=new Bar()
+== Sub Tree ==
+bar.foo Assign Foo
+== Sub Tree ==
+console.log(foo instanceof Bar)
+== Sub Tree ==
+console.log(foo instanceof bar.foo)
+== Sub Tree ==
+console.log(bar.foo instanceof Bar)
diff --git a/src/MapleFE/test/typescript/unit_tests/instanceof.ts b/src/MapleFE/test/typescript/unit_tests/instanceof.ts
new file mode 100644
index 0000000000000000000000000000000000000000..55b72c52ea082d47550af61b77176f77e07a2355
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/instanceof.ts
@@ -0,0 +1,2 @@
+var x: any = 3;
+console.log(x instanceof Number);
diff --git a/src/MapleFE/test/typescript/unit_tests/instanceof.ts.result b/src/MapleFE/test/typescript/unit_tests/instanceof.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..dc62911090503f0b87e40735cf502c0f4059f9f6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/instanceof.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=3
+== Sub Tree ==
+console.log(x instanceof Number)
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-extends.ts b/src/MapleFE/test/typescript/unit_tests/interface-extends.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2796b9867fc612d460451bb249b2c5a262564070
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-extends.ts
@@ -0,0 +1,12 @@
+interface Base {
+  name: string;
+}
+interface Derived extends Base {
+  age: number;
+}
+function dump(obj: Derived) {
+  console.log(obj.name, obj.age);
+}
+
+let o = { name: "John", age: 30 };
+dump(o);
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-extends.ts.result b/src/MapleFE/test/typescript/unit_tests/interface-extends.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ecb6a0965eb37387c924d6af8213367101b2229a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-extends.ts.result
@@ -0,0 +1,18 @@
+Matched 8 tokens.
+Matched 18 tokens.
+Matched 40 tokens.
+Matched 53 tokens.
+Matched 58 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Base {name }
+== Sub Tree ==
+ts_interface: Derived {age }
+== Sub Tree ==
+func  dump(obj)  throws: 
+  console.log(obj.name,obj.age)
+
+== Sub Tree ==
+js_let Decl: o= {name:"John", age:30}
+== Sub Tree ==
+dump(o)
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-extends2.ts b/src/MapleFE/test/typescript/unit_tests/interface-extends2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6cb460097753b5a55cf6ff219fa836b6e8b794f4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-extends2.ts
@@ -0,0 +1,14 @@
+interface Base {
+  name: string;
+}
+interface Derived extends Base {
+  age: number;
+  readonly impl?: any;
+  initialize?(c: number): void;
+}
+function dump(obj: Derived) {
+  console.log(obj.name, obj.age);
+}
+
+let o = { name: "John", age: 30 };
+dump(o);
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-extends2.ts.result b/src/MapleFE/test/typescript/unit_tests/interface-extends2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2575af09f78a5135b326e560caf263129fc04d9e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-extends2.ts.result
@@ -0,0 +1,19 @@
+Matched 8 tokens.
+Matched 34 tokens.
+Matched 56 tokens.
+Matched 69 tokens.
+Matched 74 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Base {name }
+== Sub Tree ==
+ts_interface: Derived {age;impl?func  initialize?(c)  throws: 
+ }
+== Sub Tree ==
+func  dump(obj)  throws: 
+  console.log(obj.name,obj.age)
+
+== Sub Tree ==
+js_let Decl: o= {name:"John", age:30}
+== Sub Tree ==
+dump(o)
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-func.ts b/src/MapleFE/test/typescript/unit_tests/interface-func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..01e5a0799bb87aa404d7a0a85e5dabd4c7fcfd97
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-func.ts
@@ -0,0 +1,9 @@
+class Klass {}
+
+export interface Interf {
+  [key: string]: any;
+}
+
+export interface Interf2 {
+  func(component: Klass): Interf;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-func.ts.result b/src/MapleFE/test/typescript/unit_tests/interface-func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..fa4ee3c2d9b8041f904d6ac04384dd8e24220609
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-func.ts.result
@@ -0,0 +1,19 @@
+Matched 4 tokens.
+Matched 17 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+export {ts_interface: Interf {string index type: any }} 
+== Sub Tree ==
+export {ts_interface: Interf2 {func  func(component)  throws: 
+ }} 
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-indexable.ts b/src/MapleFE/test/typescript/unit_tests/interface-indexable.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2299b8034efdc1de5b6a3595f55cba7412573901
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-indexable.ts
@@ -0,0 +1,13 @@
+const enum TypeID {
+  Array_Class = 0,
+  Array,
+}
+
+class Klass {}
+
+interface DataTypes {
+  [TypeID.Array_Class]: DataTypes[TypeID.Array][];
+  [TypeID.Array]: Klass;
+}
+
+type TYPE = DataTypes[Exclude<keyof DataTypes, TypeID.Array_Class>];
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-indexable.ts.result b/src/MapleFE/test/typescript/unit_tests/interface-indexable.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b5b74c76cd51dabbcb08a5d456131390d249f903
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-indexable.ts.result
@@ -0,0 +1,21 @@
+Matched 11 tokens.
+Matched 15 tokens.
+Matched 42 tokens.
+Matched 58 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: TypeID {Array_Class=0;Array }
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+ts_interface: DataTypes {[TypeID.Array_Class] : DataTypes[TypeID.Array][];[TypeID.Array] : Klass }
+== Sub Tree ==
+ type TYPE = DataTypes[Exclude< keyof DataTypes,TypeID.Array_Class>]
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-intersect-nonnullable-intf-fd.ts b/src/MapleFE/test/typescript/unit_tests/interface-intersect-nonnullable-intf-fd.ts
new file mode 100644
index 0000000000000000000000000000000000000000..673654135f5736d516b9fdbe83f2ea905c528078
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-intersect-nonnullable-intf-fd.ts
@@ -0,0 +1,6 @@
+// ref: cocos game.ts line 922
+interface IntfX {
+  IntfX_fd: boolean;
+}
+
+type Test = IntfX & { intersect_fd: NonNullable<IntfX["IntfX_fd"]> };
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-intersect-nonnullable-intf-fd.ts.result b/src/MapleFE/test/typescript/unit_tests/interface-intersect-nonnullable-intf-fd.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6f7d95622df3540c51ccb5af37021ad1934d0620
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-intersect-nonnullable-intf-fd.ts.result
@@ -0,0 +1,7 @@
+Matched 8 tokens.
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IntfX {IntfX_fd }
+== Sub Tree ==
+ type Test = intersect  = IntfX &  {intersect_fd }
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-keyof.ts b/src/MapleFE/test/typescript/unit_tests/interface-keyof.ts
new file mode 100644
index 0000000000000000000000000000000000000000..df837365df7199f215bf50c55b73383ae9df86ed
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-keyof.ts
@@ -0,0 +1,4 @@
+interface Interf<T> {
+  name: keyof T;
+  val: T[keyof T];
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-keyof.ts.result b/src/MapleFE/test/typescript/unit_tests/interface-keyof.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..eaf8faa25e936c057e33e33b4f64de8b6da2a488
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-keyof.ts.result
@@ -0,0 +1,4 @@
+Matched 20 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Interf<T,> {name;val }
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-opt-def.ts b/src/MapleFE/test/typescript/unit_tests/interface-opt-def.ts
new file mode 100644
index 0000000000000000000000000000000000000000..33ee72d0d54b759f175e46cace3e86658e219de5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-opt-def.ts
@@ -0,0 +1,11 @@
+interface I {
+  a: number;
+  b?: number;
+}
+
+function f({ a, b = 1 }: I): number {
+  return a + b;
+}
+
+console.log(f({ a: 1 }));
+console.log(f({ a: 1, b: 2 }));
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-opt-def.ts.result b/src/MapleFE/test/typescript/unit_tests/interface-opt-def.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..46e46a34bcba99730ef9417d1de2207c356d0591
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-opt-def.ts.result
@@ -0,0 +1,15 @@
+Matched 13 tokens.
+Matched 35 tokens.
+Matched 49 tokens.
+Matched 67 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: I {a;b? }
+== Sub Tree ==
+func  f({:a, :b=1})  throws: 
+  return a Add b
+
+== Sub Tree ==
+console.log(f( {a:1}))
+== Sub Tree ==
+console.log(f( {a:1, b:2}))
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-optional-field.ts b/src/MapleFE/test/typescript/unit_tests/interface-optional-field.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3708b9805c41233d33346a17c0ba105fc6ec97bd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-optional-field.ts
@@ -0,0 +1,3 @@
+interface Interf {
+  readonly?: boolean | { flag?: boolean };
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/interface-optional-field.ts.result b/src/MapleFE/test/typescript/unit_tests/interface-optional-field.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c92b24340b56389cab065ffce386791c466d58ae
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface-optional-field.ts.result
@@ -0,0 +1,4 @@
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Interf {readonly? }
diff --git a/src/MapleFE/test/typescript/unit_tests/interface.ts b/src/MapleFE/test/typescript/unit_tests/interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1306b78f98647975d8180b677560e4ec9c06347a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface.ts
@@ -0,0 +1,14 @@
+interface Employee {
+  firstName: string;
+  lastName: string;
+}
+
+let john: Employee = {
+  firstName: "John",
+  lastName: "Smith",
+};
+
+let jane: Employee = {
+  firstName: "Jane",
+  lastName: "Doe",
+};
diff --git a/src/MapleFE/test/typescript/unit_tests/interface.ts.result b/src/MapleFE/test/typescript/unit_tests/interface.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5b1138ffa5a23ec70f0fdbc6db712ee534db602f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface.ts.result
@@ -0,0 +1,10 @@
+Matched 12 tokens.
+Matched 28 tokens.
+Matched 44 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Employee {firstName;lastName }
+== Sub Tree ==
+js_let Decl: john= {firstName:"John", lastName:"Smith"}
+== Sub Tree ==
+js_let Decl: jane= {firstName:"Jane", lastName:"Doe"}
diff --git a/src/MapleFE/test/typescript/unit_tests/interface2.ts b/src/MapleFE/test/typescript/unit_tests/interface2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..490ad712035327a8e20301394fe28d6b3753bca6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface2.ts
@@ -0,0 +1,3 @@
+interface Interf {
+  obj: { import: string[] };
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/interface2.ts.result b/src/MapleFE/test/typescript/unit_tests/interface2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b619a930d755f8bfef79827f7c005e2a944c3368
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface2.ts.result
@@ -0,0 +1,4 @@
+Matched 14 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Interf {obj }
diff --git a/src/MapleFE/test/typescript/unit_tests/interface3.ts b/src/MapleFE/test/typescript/unit_tests/interface3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5412585d451cdcd705afbd4c89c1a9812564ed53
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface3.ts
@@ -0,0 +1,7 @@
+// tsc -t es6
+interface IFace {
+  create<T = any>(
+    args: Iterable<readonly [PropertyKey, T]>
+  ): { [k: string]: T };
+  create(args: Iterable<readonly any[]>): any;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/interface3.ts.result b/src/MapleFE/test/typescript/unit_tests/interface3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..94e3727736aa37357359b50b82b32fb1c42c69e3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/interface3.ts.result
@@ -0,0 +1,6 @@
+Matched 49 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {func  create<T=>(args)  throws: 
+;func  create(args)  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/intersection-type.ts b/src/MapleFE/test/typescript/unit_tests/intersection-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..774714751c5d4aec81009cb9da7373834c8011b9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/intersection-type.ts
@@ -0,0 +1,14 @@
+interface A {
+  id: number;
+}
+
+interface B {
+  name: string;
+}
+
+type I = A & B;
+let v: I;
+v!.id = 10;
+v!.name = "B";
+
+console.log(v!.id, v!.name);
diff --git a/src/MapleFE/test/typescript/unit_tests/intersection-type.ts.result b/src/MapleFE/test/typescript/unit_tests/intersection-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5d33332ee88b24e3d03543bbf9e2ee142962dda5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/intersection-type.ts.result
@@ -0,0 +1,22 @@
+Matched 8 tokens.
+Matched 16 tokens.
+Matched 23 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+Matched 42 tokens.
+Matched 57 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: A {id }
+== Sub Tree ==
+ts_interface: B {name }
+== Sub Tree ==
+ type I = intersect  = A & B
+== Sub Tree ==
+js_let Decl: v
+== Sub Tree ==
+v!.id Assign 10
+== Sub Tree ==
+v!.name Assign "B"
+== Sub Tree ==
+console.log(v!.id,v!.name)
diff --git a/src/MapleFE/test/typescript/unit_tests/intersection-type2.ts b/src/MapleFE/test/typescript/unit_tests/intersection-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6070c19c10b8f81b7f1d157db4a257b6c968069e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/intersection-type2.ts
@@ -0,0 +1,18 @@
+class A {
+  id: number = 0;
+}
+
+class B {
+  flag: false = false;
+}
+
+class C {
+  name: string = "";
+}
+
+type I = A & (B["flag"] extends true ? B : C);
+let v: I = {id: 0, name: ""};
+v!.id = 10;
+v!.name = "B";
+
+console.log(v!.id, v!.name);
diff --git a/src/MapleFE/test/typescript/unit_tests/intersection-type2.ts.result b/src/MapleFE/test/typescript/unit_tests/intersection-type2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0995e58a7314d0af79726755e62fdd9ce8c48f60
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/intersection-type2.ts.result
@@ -0,0 +1,49 @@
+Matched 10 tokens.
+Matched 20 tokens.
+Matched 30 tokens.
+Matched 48 tokens.
+Matched 63 tokens.
+Matched 70 tokens.
+Matched 77 tokens.
+Matched 92 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+    id=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  B
+  Fields: 
+    flag=false
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  C
+  Fields: 
+    name=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+ type I = intersect  = A & B["flag"] extends true ? B : C
+== Sub Tree ==
+js_let Decl: v= {id:0, name:""}
+== Sub Tree ==
+v!.id Assign 10
+== Sub Tree ==
+v!.name Assign "B"
+== Sub Tree ==
+console.log(v!.id,v!.name)
diff --git a/src/MapleFE/test/typescript/unit_tests/intersection-type3.ts b/src/MapleFE/test/typescript/unit_tests/intersection-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8af426e92796bca034e477453a69fc0c884ae8be
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/intersection-type3.ts
@@ -0,0 +1 @@
+declare type Type<T> = { [K in keyof T]: K; }[keyof T] & string;
diff --git a/src/MapleFE/test/typescript/unit_tests/intersection-type3.ts.result b/src/MapleFE/test/typescript/unit_tests/intersection-type3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..dfbcdc17edc3cab50bde1dbe039b00a17eafb9b2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/intersection-type3.ts.result
@@ -0,0 +1,4 @@
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+declare  type Type<T> = intersect  =  {[K in  keyof T] : K }[ keyof T] & string
diff --git a/src/MapleFE/test/typescript/unit_tests/iterator.ts b/src/MapleFE/test/typescript/unit_tests/iterator.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e4d1e33a670c592af51db17254537877feae63f9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/iterator.ts
@@ -0,0 +1,14 @@
+interface Iface {
+    name: string;
+}
+
+const myIter: Iterator<Iface> = Object.freeze({
+  next () {
+    return { done: true, value: undefined, };
+  },
+});
+
+
+const iter: Iterable<Iface> = Object.freeze({
+    [Symbol.iterator] () { return myIter; },
+});
diff --git a/src/MapleFE/test/typescript/unit_tests/iterator.ts.result b/src/MapleFE/test/typescript/unit_tests/iterator.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d4048a3631bf33d36e2c4eb6e05802618574424b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/iterator.ts.result
@@ -0,0 +1,14 @@
+Matched 8 tokens.
+Matched 42 tokens.
+Matched 71 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Iface {name }
+== Sub Tree ==
+js_const Decl: myIter=Object.freeze( {next:func  next()  throws: 
+  return  {done:true, value:undefined}
+})
+== Sub Tree ==
+js_const Decl: iter=Object.freeze( {[Symbol.iterator] : :func  ()  throws: 
+  return myIter
+})
diff --git a/src/MapleFE/test/typescript/unit_tests/keyof-property.ts b/src/MapleFE/test/typescript/unit_tests/keyof-property.ts
new file mode 100644
index 0000000000000000000000000000000000000000..855d0e42a03ccf24e035a95c9ab4f0122a66abc1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/keyof-property.ts
@@ -0,0 +1,6 @@
+class Klass {
+  prop: { field: number } = { field: 0};
+}
+export type T = keyof Klass["prop"];
+var n: T = "field";
+console.log(n);
diff --git a/src/MapleFE/test/typescript/unit_tests/keyof-property.ts.result b/src/MapleFE/test/typescript/unit_tests/keyof-property.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7f5be0ce67791d42fc56be3315998309e988a78d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/keyof-property.ts.result
@@ -0,0 +1,21 @@
+Matched 18 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+Matched 42 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    prop= {field:0}
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+export { type T =  keyof Klass["prop"]} 
+== Sub Tree ==
+js_var Decl: n="field"
+== Sub Tree ==
+console.log(n)
diff --git a/src/MapleFE/test/typescript/unit_tests/keyof.ts b/src/MapleFE/test/typescript/unit_tests/keyof.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a8eaa08ab49c0e1c012d0d5b3891b03f5ddef0f7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/keyof.ts
@@ -0,0 +1,7 @@
+class Klass {
+  [x: string]: number;
+}
+var o: Klass = { abc: 10 };
+var x: keyof Klass = "abc";
+console.log(o[x]);
+o[x] = 3;
diff --git a/src/MapleFE/test/typescript/unit_tests/keyof.ts.result b/src/MapleFE/test/typescript/unit_tests/keyof.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3812d5e9488fd4a4af9ac8939adedea8f0d022a7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/keyof.ts.result
@@ -0,0 +1,24 @@
+Matched 12 tokens.
+Matched 23 tokens.
+Matched 31 tokens.
+Matched 41 tokens.
+Matched 48 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    number
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: o= {abc:10}
+== Sub Tree ==
+js_var Decl: x="abc"
+== Sub Tree ==
+console.log(o[x])
+== Sub Tree ==
+o[x] Assign 3
diff --git a/src/MapleFE/test/typescript/unit_tests/keyof2.ts b/src/MapleFE/test/typescript/unit_tests/keyof2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..824c5b16f34a05b1226ad862eab89fd4ee76c6dd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/keyof2.ts
@@ -0,0 +1,7 @@
+class Klass {
+  [x: string]: number;
+}
+var o: Klass = { abc: 10 };
+var x: keyof typeof o = "abc";
+console.log(o[x]);
+o[x] = 3;
diff --git a/src/MapleFE/test/typescript/unit_tests/keyof2.ts.result b/src/MapleFE/test/typescript/unit_tests/keyof2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9c56663543344013cf20078ef8dc07ce87fdaff3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/keyof2.ts.result
@@ -0,0 +1,24 @@
+Matched 12 tokens.
+Matched 23 tokens.
+Matched 32 tokens.
+Matched 42 tokens.
+Matched 49 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    number
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: o= {abc:10}
+== Sub Tree ==
+js_var Decl: x="abc"
+== Sub Tree ==
+console.log(o[x])
+== Sub Tree ==
+o[x] Assign 3
diff --git a/src/MapleFE/test/typescript/unit_tests/keyof3.ts b/src/MapleFE/test/typescript/unit_tests/keyof3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..824c5b16f34a05b1226ad862eab89fd4ee76c6dd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/keyof3.ts
@@ -0,0 +1,7 @@
+class Klass {
+  [x: string]: number;
+}
+var o: Klass = { abc: 10 };
+var x: keyof typeof o = "abc";
+console.log(o[x]);
+o[x] = 3;
diff --git a/src/MapleFE/test/typescript/unit_tests/keyof3.ts.result b/src/MapleFE/test/typescript/unit_tests/keyof3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9c56663543344013cf20078ef8dc07ce87fdaff3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/keyof3.ts.result
@@ -0,0 +1,24 @@
+Matched 12 tokens.
+Matched 23 tokens.
+Matched 32 tokens.
+Matched 42 tokens.
+Matched 49 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    number
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: o= {abc:10}
+== Sub Tree ==
+js_var Decl: x="abc"
+== Sub Tree ==
+console.log(o[x])
+== Sub Tree ==
+o[x] Assign 3
diff --git a/src/MapleFE/test/typescript/unit_tests/labeled-block.ts b/src/MapleFE/test/typescript/unit_tests/labeled-block.ts
new file mode 100644
index 0000000000000000000000000000000000000000..080acf9cfebe603c78ae9899556812ca395fc6c3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/labeled-block.ts
@@ -0,0 +1,12 @@
+var x: number = 10;
+
+outer: {
+  if (x > 5) {
+    if (x > 8) {
+      console.log("x is greater than 8");
+      break outer;
+    }
+    console.log("x is greater than 5");
+  } else console.log("x is less than or equal to 5");
+  console.log("out of block");
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/labeled-block.ts.result b/src/MapleFE/test/typescript/unit_tests/labeled-block.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3fa087629698ce26f806c1b7b7e726bcf3950c47
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/labeled-block.ts.result
@@ -0,0 +1,21 @@
+Matched 7 tokens.
+Matched 59 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=10
+== Sub Tree ==
+outer:
+cond-branch cond:x GT 5
+true branch :
+  cond-branch cond:x GT 8
+  true branch :
+    console.log("x is greater than 8")
+    break:outer
+
+  false branch :
+
+  console.log("x is greater than 5")
+false branch :
+  console.log("x is less than or equal to 5")
+console.log("out of block")
+
diff --git a/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt-in-loop.ts b/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt-in-loop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8a98d672373c03d15fc58bdd170ddc7948e7f663
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt-in-loop.ts
@@ -0,0 +1,15 @@
+var x: number = 10;
+for (var i = 0; i < 10; ++i) {
+  x--;
+  outer: if (x > 0) {
+    if (x > 5) {
+      if (x > 8) {
+        console.log("x is greater than 8");
+        break outer;
+      }
+      console.log("x is greater than 5");
+      break;
+    } else console.log("x is less than or equal to 5");
+    console.log("out of nested if-stmt");
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt-in-loop.ts.result b/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt-in-loop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a381c1c4ff519e34f01ffbeffeca61285866f19e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt-in-loop.ts.result
@@ -0,0 +1,30 @@
+Matched 7 tokens.
+Matched 86 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=10
+== Sub Tree ==
+for ( )
+  x Dec
+
+  outer:
+  cond-branch cond:x GT 0
+  true branch :
+    cond-branch cond:x GT 5
+    true branch :
+      cond-branch cond:x GT 8
+      true branch :
+        console.log("x is greater than 8")
+        break:outer
+
+      false branch :
+
+      console.log("x is greater than 5")
+      break:
+
+    false branch :
+      console.log("x is less than or equal to 5")
+    console.log("out of nested if-stmt")
+  false branch :
+
+
diff --git a/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt.ts b/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt.ts
new file mode 100644
index 0000000000000000000000000000000000000000..183b80995227e21c976176cab0c273793429588f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt.ts
@@ -0,0 +1,10 @@
+var x: number = 10;
+if (x > 0) {
+  outer: if (x > 5) {
+    if (x > 8) {
+      console.log("x is greater than 8");
+      break outer;
+    }
+    console.log("x is greater than 5");
+  } else console.log("x is less than or equal to 5");
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt.ts.result b/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..29aa37d8b7d71faa0dc795bdbbffb1217c9a2106
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/labeled-if-stmt.ts.result
@@ -0,0 +1,23 @@
+Matched 7 tokens.
+Matched 58 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=10
+== Sub Tree ==
+cond-branch cond:x GT 0
+true branch :
+  outer:
+  cond-branch cond:x GT 5
+  true branch :
+    cond-branch cond:x GT 8
+    true branch :
+      console.log("x is greater than 8")
+      break:outer
+
+    false branch :
+
+    console.log("x is greater than 5")
+  false branch :
+    console.log("x is less than or equal to 5")
+false branch :
+
diff --git a/src/MapleFE/test/typescript/unit_tests/labeled-loop.ts b/src/MapleFE/test/typescript/unit_tests/labeled-loop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e3724dbfcccc2f4bd6fef274568759709050c8b6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/labeled-loop.ts
@@ -0,0 +1,12 @@
+var arr: number[] = [7, 4, 5, 9, 2, 8, 1, 6, 3];
+var len: number = arr.length;
+var sum: number = 0;
+outer: for (var i = 0; i < len; ++i) {
+  for (var j = i + 1; j < len; ++j) {
+    sum += arr[i];
+    console.log(sum);
+    if (arr[j] > 5) continue outer;
+    if (sum >= 60) break outer;
+  }
+}
+console.log(sum);
diff --git a/src/MapleFE/test/typescript/unit_tests/labeled-loop.ts.result b/src/MapleFE/test/typescript/unit_tests/labeled-loop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ad0f4192f4dc37582d42ad0061377fb54b121b5a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/labeled-loop.ts.result
@@ -0,0 +1,32 @@
+Matched 27 tokens.
+Matched 36 tokens.
+Matched 43 tokens.
+Matched 114 tokens.
+Matched 121 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[7,4,5,9,2,8,1,6,3]
+== Sub Tree ==
+js_var Decl: len=arr.length
+== Sub Tree ==
+js_var Decl: sum=0
+== Sub Tree ==
+outer:
+for ( )
+  for ( )
+    sum AddAssign arr[i]
+    console.log(sum)
+    cond-branch cond:arr[j] GT 5
+    true branch :
+      continue:outer
+    false branch :
+
+    cond-branch cond:sum GE 60
+    true branch :
+      break:outer
+    false branch :
+
+
+
+== Sub Tree ==
+console.log(sum)
diff --git a/src/MapleFE/test/typescript/unit_tests/lambda.ts b/src/MapleFE/test/typescript/unit_tests/lambda.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e1303aa1555b657369ca3099566539e7bbdb65b2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/lambda.ts
@@ -0,0 +1,4 @@
+var add = (x: number, y: number): number => {
+  return x + y;
+};
+console.log(add(2, 3));
diff --git a/src/MapleFE/test/typescript/unit_tests/lambda.ts.result b/src/MapleFE/test/typescript/unit_tests/lambda.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f51402f201435e2a0672de19a4de0e3f7a17c8f1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/lambda.ts.result
@@ -0,0 +1,8 @@
+Matched 23 tokens.
+Matched 35 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: add=(x,y) -> return x Add y
+
+== Sub Tree ==
+console.log(add(2,3))
diff --git a/src/MapleFE/test/typescript/unit_tests/lambda2.ts b/src/MapleFE/test/typescript/unit_tests/lambda2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..180811544bbaf5207cb361def63f2fbe35b418d0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/lambda2.ts
@@ -0,0 +1,2 @@
+var sqare: (x: number) => number = (x) => x * x;
+console.log(sqare(2));
diff --git a/src/MapleFE/test/typescript/unit_tests/lambda2.ts.result b/src/MapleFE/test/typescript/unit_tests/lambda2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5c31f72bdcdd397ad1ee96be0944c14f251cccfb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/lambda2.ts.result
@@ -0,0 +1,7 @@
+Matched 19 tokens.
+Matched 29 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: sqare=(x) -> x Mul x
+== Sub Tree ==
+console.log(sqare(2))
diff --git a/src/MapleFE/test/typescript/unit_tests/lambda3.ts b/src/MapleFE/test/typescript/unit_tests/lambda3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b8b89b94fef7dbb892f35191c52354fb4a17154b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/lambda3.ts
@@ -0,0 +1,8 @@
+// ref: cocos scheduler.ts line 58
+class CLS_test {
+  public static get = () => {
+    return 1;
+  };
+}
+
+console.log(CLS_test.get());
diff --git a/src/MapleFE/test/typescript/unit_tests/lambda3.ts.result b/src/MapleFE/test/typescript/unit_tests/lambda3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..354262be7c4ced3a0df15737cfd69e6b3d814837
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/lambda3.ts.result
@@ -0,0 +1,16 @@
+Matched 17 tokens.
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+class  CLS_test
+  Fields: 
+    get=() -> return 1
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+console.log(CLS_test.get())
diff --git a/src/MapleFE/test/typescript/unit_tests/let-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/let-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0fee34fb08d4d74cedd49c0a0b9a30e0f8a80ff7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/let-as-prop-name.ts
@@ -0,0 +1,32 @@
+export function func(arg: {let: Function | null}): void {
+  if (!arg.let) {
+    console.log("null");
+  } else {
+    arg.let();
+  }
+}
+
+func({let: null});
+func({let: () => { console.log("calling let()"); }});
+
+export function func1(arg: {var: Function | null}): void {
+  if (!arg.var) {
+    console.log("null");
+  } else {
+    arg.var();
+  }
+}
+
+func1({var: null});
+func1({var: () => { console.log("calling var()"); }});
+
+export function func2(arg: {break: Function | null}): void {
+  if (!arg.break) {
+    console.log("null");
+  } else {
+    arg.break();
+  }
+}
+
+func2({break: null});
+func2({break: () => { console.log("calling break()"); }});
diff --git a/src/MapleFE/test/typescript/unit_tests/let-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/let-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5ecae0f33fd4d81d52516d162c474d52fbfcf9fc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/let-as-prop-name.ts.result
@@ -0,0 +1,52 @@
+Matched 43 tokens.
+Matched 52 tokens.
+Matched 72 tokens.
+Matched 115 tokens.
+Matched 124 tokens.
+Matched 144 tokens.
+Matched 187 tokens.
+Matched 196 tokens.
+Matched 216 tokens.
+============= Module ===========
+== Sub Tree ==
+export {func  func(arg)  throws: 
+  cond-branch cond:Not arg.let
+  true branch :
+    console.log("null")
+  false branch :
+    arg.let()
+
+} 
+== Sub Tree ==
+func( {let:null})
+== Sub Tree ==
+func( {let:() -> console.log("calling let()")
+})
+== Sub Tree ==
+export {func  func1(arg)  throws: 
+  cond-branch cond:Not arg.var
+  true branch :
+    console.log("null")
+  false branch :
+    arg.var()
+
+} 
+== Sub Tree ==
+func1( {var:null})
+== Sub Tree ==
+func1( {var:() -> console.log("calling var()")
+})
+== Sub Tree ==
+export {func  func2(arg)  throws: 
+  cond-branch cond:Not arg.break
+  true branch :
+    console.log("null")
+  false branch :
+    arg.break()
+
+} 
+== Sub Tree ==
+func2( {break:null})
+== Sub Tree ==
+func2( {break:() -> console.log("calling break()")
+})
diff --git a/src/MapleFE/test/typescript/unit_tests/let-multi-decls.ts b/src/MapleFE/test/typescript/unit_tests/let-multi-decls.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b3f44de9688766101aa9072b18f38f3b14c6ee6e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/let-multi-decls.ts
@@ -0,0 +1,5 @@
+let i: number,
+  j = 3,
+  k = 5;
+i = 10;
+console.log(i + j + k);
diff --git a/src/MapleFE/test/typescript/unit_tests/let-multi-decls.ts.result b/src/MapleFE/test/typescript/unit_tests/let-multi-decls.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..61311782f069bcb318ced21cd6a6605b8ab759b8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/let-multi-decls.ts.result
@@ -0,0 +1,14 @@
+Matched 13 tokens.
+Matched 17 tokens.
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: i
+== Sub Tree ==
+js_let Decl: j=3
+== Sub Tree ==
+js_let Decl: k=5
+== Sub Tree ==
+i Assign 10
+== Sub Tree ==
+console.log(i Add j Add k)
diff --git a/src/MapleFE/test/typescript/unit_tests/let-multi-decls2.ts b/src/MapleFE/test/typescript/unit_tests/let-multi-decls2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4de255fbb6deac156255950f8b84f650ff2faa6f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/let-multi-decls2.ts
@@ -0,0 +1,11 @@
+function func() {
+  let i = 1,
+    j = 2,
+    k;
+  i = 10;
+  j = 3;
+  k = 5;
+  console.log(i + j + k);
+}
+
+func();
diff --git a/src/MapleFE/test/typescript/unit_tests/let-multi-decls2.ts.result b/src/MapleFE/test/typescript/unit_tests/let-multi-decls2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a3bff642f5297036c4d30db6426ba8737485c92e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/let-multi-decls2.ts.result
@@ -0,0 +1,15 @@
+Matched 40 tokens.
+Matched 44 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+  js_let Decl: i=1
+  js_let Decl: j=2
+  js_let Decl: k
+  i Assign 10
+  j Assign 3
+  k Assign 5
+  console.log(i Add j Add k)
+
+== Sub Tree ==
+func()
diff --git a/src/MapleFE/test/typescript/unit_tests/literal-type.ts b/src/MapleFE/test/typescript/unit_tests/literal-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..af5b84b57d5f3a63def536bf38b53a6516a46e3d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/literal-type.ts
@@ -0,0 +1,4 @@
+var x: 0 | -1 = 0;
+console.log(x);
+x = -1;
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/literal-type.ts.result b/src/MapleFE/test/typescript/unit_tests/literal-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4597f8a34230202abe303aa580fe746b40c07cec
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/literal-type.ts.result
@@ -0,0 +1,13 @@
+Matched 9 tokens.
+Matched 16 tokens.
+Matched 20 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=0
+== Sub Tree ==
+console.log(x)
+== Sub Tree ==
+x Assign -1
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/long-string.ts b/src/MapleFE/test/typescript/unit_tests/long-string.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4a3f849389269ee2960233a3b17ca6e382b2b36c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/long-string.ts
@@ -0,0 +1,5 @@
+const obj = {
+  str: "this is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...",
+};
+
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/long-string.ts.result b/src/MapleFE/test/typescript/unit_tests/long-string.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..96d27c6557181486010fb6d34da5f2d99640294c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/long-string.ts.result
@@ -0,0 +1,7 @@
+Matched 10 tokens.
+Matched 17 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {str:"this is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string...\nthis is a long long long string..."}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/mapped-type-with-modifier.ts b/src/MapleFE/test/typescript/unit_tests/mapped-type-with-modifier.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b45c6f5d9fcef9a78f17bfffc6abe75708c2a651
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/mapped-type-with-modifier.ts
@@ -0,0 +1,6 @@
+// ref: cocos splash-screen.ts line 59.
+// ref: https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#mapping-modifiers
+
+type mutableType<T> = {
+  -readonly [prop in keyof T]: T[prop];
+};
diff --git a/src/MapleFE/test/typescript/unit_tests/mapped-type-with-modifier.ts.result b/src/MapleFE/test/typescript/unit_tests/mapped-type-with-modifier.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b5634f4b07b05db1f5f2f83e352b5f42510b2ca4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/mapped-type-with-modifier.ts.result
@@ -0,0 +1,4 @@
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+ type mutableType<T> =  {[prop in  keyof T] : T[prop] }
diff --git a/src/MapleFE/test/typescript/unit_tests/mapped-type.ts b/src/MapleFE/test/typescript/unit_tests/mapped-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7b53529ee2da333b564d1a80f43237a91098913b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/mapped-type.ts
@@ -0,0 +1,9 @@
+class Base {
+  [key: string]: number | string;
+}
+class Derived extends Base {}
+type T<E extends Base> = { [key in E[keyof E]]: string };
+
+var obj: T<Derived> = { str: "abc" };
+obj[0] = "zero";
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/mapped-type.ts.result b/src/MapleFE/test/typescript/unit_tests/mapped-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8df9e1714836cfd209ca567021afe6fbde22755d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/mapped-type.ts.result
@@ -0,0 +1,35 @@
+Matched 14 tokens.
+Matched 20 tokens.
+Matched 42 tokens.
+Matched 56 tokens.
+Matched 63 tokens.
+Matched 70 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Base
+  Fields: 
+    union  = number | string
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Derived
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+ type T<E> =  {[key in E[ keyof E]] : string }
+== Sub Tree ==
+js_var Decl: obj= {str:"abc"}
+== Sub Tree ==
+obj[0] Assign "zero"
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/mapping-modifier.ts b/src/MapleFE/test/typescript/unit_tests/mapping-modifier.ts
new file mode 100644
index 0000000000000000000000000000000000000000..884989b2e1e1e291a87423f7ada1b91e7c16e56a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/mapping-modifier.ts
@@ -0,0 +1,16 @@
+type Concrete<T> = {
+  [P in keyof T]-?: T[P];
+};
+
+interface IFace {
+  name: string;
+  age?: number;
+}
+
+class Klass implements Concrete<IFace> {
+  name: string = "No-name";
+  age: number = 0;
+}
+
+var obj: Klass = new Klass();
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/mapping-modifier.ts.result b/src/MapleFE/test/typescript/unit_tests/mapping-modifier.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3769a5b1ddd713aa96dcec088ce2baa0119c5ed8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/mapping-modifier.ts.result
@@ -0,0 +1,24 @@
+Matched 23 tokens.
+Matched 36 tokens.
+Matched 57 tokens.
+Matched 67 tokens.
+Matched 74 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Concrete<T> =  {[P in  keyof T] : T[P] }
+== Sub Tree ==
+ts_interface: IFace {name;age? }
+== Sub Tree ==
+class  Klass
+  Fields: 
+    name="No-name"    age=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/member-function-with-callback.ts b/src/MapleFE/test/typescript/unit_tests/member-function-with-callback.ts
new file mode 100644
index 0000000000000000000000000000000000000000..935df78071b308aa2d1961fcb7bd34f444be9b26
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/member-function-with-callback.ts
@@ -0,0 +1,19 @@
+abstract class Base {
+  func(f: () => void): void {
+    f();
+  }
+  public abstract func2(f: () => void): void;
+}
+
+class Klass extends Base {
+  func2(f: () => void): void {
+    f();
+  }
+}
+
+function foo(): void {
+  console.log("foo");
+}
+
+var obj: Klass = new Klass();
+obj.func(foo);
diff --git a/src/MapleFE/test/typescript/unit_tests/member-function-with-callback.ts.result b/src/MapleFE/test/typescript/unit_tests/member-function-with-callback.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e397573a814cc33d5c5e09d37f064bcdf952214e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/member-function-with-callback.ts.result
@@ -0,0 +1,39 @@
+Matched 36 tokens.
+Matched 59 tokens.
+Matched 74 tokens.
+Matched 84 tokens.
+Matched 91 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Base
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func(f)  throws: 
+      f()
+    func  func2(f)  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func2(f)  throws: 
+      f()
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  foo()  throws: 
+  console.log("foo")
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj.func(foo)
diff --git a/src/MapleFE/test/typescript/unit_tests/member-functions.ts b/src/MapleFE/test/typescript/unit_tests/member-functions.ts
new file mode 100644
index 0000000000000000000000000000000000000000..510006896b64fabdb2bda9055aeca02586a88ff1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/member-functions.ts
@@ -0,0 +1,20 @@
+class MyClass {
+  operand: number;
+
+  constructor(opr: number) {
+    this.operand = opr;
+  }
+
+  calc?: (x: number) => number;
+
+  add = (x: number): number => this.operand + x;
+}
+
+MyClass.prototype.calc = function (this: MyClass, x: number) {
+  return this.operand + x;
+};
+
+var myObj = new MyClass(1);
+
+console.log(myObj.calc!(2));
+console.log(myObj.add(3));
diff --git a/src/MapleFE/test/typescript/unit_tests/member-functions.ts.result b/src/MapleFE/test/typescript/unit_tests/member-functions.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1b0eefdc31cfa556f681a8c6766d65cfbcf9df9a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/member-functions.ts.result
@@ -0,0 +1,28 @@
+Matched 49 tokens.
+Matched 75 tokens.
+Matched 84 tokens.
+Matched 97 tokens.
+Matched 109 tokens.
+============= Module ===========
+== Sub Tree ==
+class  MyClass
+  Fields: 
+    operand    calc?    add=(x) -> this.operand Add x
+  Instance Initializer: 
+  Constructors: 
+    constructor  (opr)  throws: 
+      this.operand Assign opr
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+MyClass.prototype.calc Assign func  (this,x)  throws: 
+  return this.operand Add x
+
+== Sub Tree ==
+js_var Decl: myObj=new MyClass(1)
+== Sub Tree ==
+console.log(myObj.calc!(2))
+== Sub Tree ==
+console.log(myObj.add(3))
diff --git a/src/MapleFE/test/typescript/unit_tests/method-of-interface.ts b/src/MapleFE/test/typescript/unit_tests/method-of-interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..17c6a390b7d9ea2a6f16f352109a7abec77beb87
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/method-of-interface.ts
@@ -0,0 +1,9 @@
+interface Klass1 {}
+
+interface Klass2 {
+  name: string;
+}
+
+interface Klass3 {
+  getObj(o: Klass1): Klass2;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/method-of-interface.ts.result b/src/MapleFE/test/typescript/unit_tests/method-of-interface.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0eacf21e19f3cd9b7640007aabadedd32ae5e140
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/method-of-interface.ts.result
@@ -0,0 +1,11 @@
+Matched 4 tokens.
+Matched 12 tokens.
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Klass1 { }
+== Sub Tree ==
+ts_interface: Klass2 {name }
+== Sub Tree ==
+ts_interface: Klass3 {func  getObj(o)  throws: 
+ }
diff --git a/src/MapleFE/test/typescript/unit_tests/method-with-return-as-name.ts b/src/MapleFE/test/typescript/unit_tests/method-with-return-as-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..abdbb740153406141e2d96b5ece5574a456df3f6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/method-with-return-as-name.ts
@@ -0,0 +1,11 @@
+class Klass {
+  return(x: number) {
+    console.log(x);
+  }
+  foo(x: number) {
+    this.return(x);
+  }
+}
+
+var obj: Klass = new Klass();
+obj.foo(10);
diff --git a/src/MapleFE/test/typescript/unit_tests/method-with-return-as-name.ts.result b/src/MapleFE/test/typescript/unit_tests/method-with-return-as-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5cca1761f0b53ba18d5fc67ad77223d03288031f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/method-with-return-as-name.ts.result
@@ -0,0 +1,22 @@
+Matched 34 tokens.
+Matched 44 tokens.
+Matched 51 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  return(x)  throws: 
+      console.log(x)
+    func  foo(x)  throws: 
+      this.return(x)
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj.foo(10)
diff --git a/src/MapleFE/test/typescript/unit_tests/module-a.ts b/src/MapleFE/test/typescript/unit_tests/module-a.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e514f1b27e2be2e0a93d5eab7b58ee2a2fec9906
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/module-a.ts
@@ -0,0 +1,3 @@
+import { add } from "./module-b";
+var x: number = 20;
+console.log(add(x));
diff --git a/src/MapleFE/test/typescript/unit_tests/module-a.ts.result b/src/MapleFE/test/typescript/unit_tests/module-a.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3a3b8908dae1bd8e0c91149bae1d9a88ff430b54
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/module-a.ts.result
@@ -0,0 +1,10 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 24 tokens.
+============= Module ===========
+== Sub Tree ==
+import {add} "./module-b"
+== Sub Tree ==
+js_var Decl: x=20
+== Sub Tree ==
+console.log(add(x))
diff --git a/src/MapleFE/test/typescript/unit_tests/module-b.ts b/src/MapleFE/test/typescript/unit_tests/module-b.ts
new file mode 100644
index 0000000000000000000000000000000000000000..071ca9289a55d6b3a6af41bb232c2d9ce844fc6a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/module-b.ts
@@ -0,0 +1,4 @@
+var x: number = 10;
+export function add(y: number) {
+  return x + y;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/module-b.ts.result b/src/MapleFE/test/typescript/unit_tests/module-b.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..59eb90cbd7e943c75ea5b74a72d52b8e2a40ae13
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/module-b.ts.result
@@ -0,0 +1,9 @@
+Matched 7 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=10
+== Sub Tree ==
+export {func  add(y)  throws: 
+  return x Add y
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/module-c.ts b/src/MapleFE/test/typescript/unit_tests/module-c.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7c69ac6668f1151318cdbec775f00724102b7565
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/module-c.ts
@@ -0,0 +1,2 @@
+import * as x from "./module-b";
+console.log(x.add(100));
diff --git a/src/MapleFE/test/typescript/unit_tests/module-c.ts.result b/src/MapleFE/test/typescript/unit_tests/module-c.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..426f361cf0ca0dd0d4d6b5fd7e41af3dd913851f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/module-c.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 19 tokens.
+============= Module ===========
+== Sub Tree ==
+import { * as x} "./module-b"
+== Sub Tree ==
+console.log(x.add(100))
diff --git a/src/MapleFE/test/typescript/unit_tests/module-vs-namespace.ts b/src/MapleFE/test/typescript/unit_tests/module-vs-namespace.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a5fbe24b3e2fbb615004c17788a984a93892080b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/module-vs-namespace.ts
@@ -0,0 +1,24 @@
+module m_for_in {
+    let arr : Array<number> = [12, 34, 56];
+    for (let x in arr) {
+        console.log(x, arr[x]);
+    }
+}
+module m_for_of {
+    let arr : Array<number> = [11, 22, 33];
+    for (let x of arr) {
+        console.log(x);
+    }
+}
+namespace ns_for_in {
+    let arr : Array<number> = [12, 34, 56];
+    for (let x in arr) {
+        console.log(x, arr[x]);
+    }
+}
+namespace ns_for_of {
+    let arr : Array<number> = [11, 22, 33];
+    for (let x of arr) {
+        console.log(x);
+    }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/module-vs-namespace.ts.result b/src/MapleFE/test/typescript/unit_tests/module-vs-namespace.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c569cd8d5134a72cd3038fc769ebf5a17ec55257
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/module-vs-namespace.ts.result
@@ -0,0 +1,37 @@
+Matched 41 tokens.
+Matched 77 tokens.
+Matched 118 tokens.
+Matched 154 tokens.
+============= Module ===========
+== Sub Tree ==
+============= Module ===========
+== Sub Tree ==
+js_let Decl: arr=[12,34,56]
+== Sub Tree ==
+for ( )
+  console.log(x,arr[x])
+
+
+== Sub Tree ==
+============= Module ===========
+== Sub Tree ==
+js_let Decl: arr=[11,22,33]
+== Sub Tree ==
+for ( )
+  console.log(x)
+
+
+== Sub Tree ==
+namespace  ns_for_in
+  js_let Decl: arr=[12,34,56]
+  for ( )
+  console.log(x,arr[x])
+
+
+== Sub Tree ==
+namespace  ns_for_of
+  js_let Decl: arr=[11,22,33]
+  for ( )
+  console.log(x)
+
+
diff --git a/src/MapleFE/test/typescript/unit_tests/multi-dim-array.ts b/src/MapleFE/test/typescript/unit_tests/multi-dim-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..615b0602ccdfd19e65692507e3e89c6217b46f02
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/multi-dim-array.ts
@@ -0,0 +1 @@
+type Type = { func: () => Array<Array<string>>; };
diff --git a/src/MapleFE/test/typescript/unit_tests/multi-dim-array.ts.result b/src/MapleFE/test/typescript/unit_tests/multi-dim-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..18f2ae887f4b1242a010cc3bf86159bb4cc81d68
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/multi-dim-array.ts.result
@@ -0,0 +1,4 @@
+Matched 18 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Type =  {func }
diff --git a/src/MapleFE/test/typescript/unit_tests/multi-line-string-literal.ts b/src/MapleFE/test/typescript/unit_tests/multi-line-string-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..26e132fab12b23e33936c24408faf09f8fedf865
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/multi-line-string-literal.ts
@@ -0,0 +1,4 @@
+var str: string = "This \
+is \
+a string literal";
+console.log(str);
diff --git a/src/MapleFE/test/typescript/unit_tests/multi-line-string-literal.ts.result b/src/MapleFE/test/typescript/unit_tests/multi-line-string-literal.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7a631af42512bbc917e468232fa4ac02bdac890c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/multi-line-string-literal.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 14 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: str="This is a string literal"
+== Sub Tree ==
+console.log(str)
diff --git a/src/MapleFE/test/typescript/unit_tests/multi-vars.ts b/src/MapleFE/test/typescript/unit_tests/multi-vars.ts
new file mode 100644
index 0000000000000000000000000000000000000000..db336810cdcb5ebf7ef079ca24fc1b0a82e3931c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/multi-vars.ts
@@ -0,0 +1,2 @@
+var x: number, y: number, z: number;
+x = y = z = 1;
diff --git a/src/MapleFE/test/typescript/unit_tests/multi-vars.ts.result b/src/MapleFE/test/typescript/unit_tests/multi-vars.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..abc43558d167ef5df41fd1541ff3fa3a8183d66c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/multi-vars.ts.result
@@ -0,0 +1,11 @@
+Matched 13 tokens.
+Matched 21 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x
+== Sub Tree ==
+js_var Decl: y
+== Sub Tree ==
+js_var Decl: z
+== Sub Tree ==
+x Assign y Assign z Assign 1
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace-with-closure.ts b/src/MapleFE/test/typescript/unit_tests/namespace-with-closure.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4adc7d8c09b8ec05265a671f6fc83e6bbc33aa9e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace-with-closure.ts
@@ -0,0 +1,16 @@
+namespace ns {
+  export function func() : Function {
+    let i: number = 10;
+    return () => ++i;
+  }
+}
+
+import myFunc = ns.func;
+
+var f: Function = myFunc();
+console.log(f());
+console.log(f());
+
+f = ns.func();
+console.log(f());
+console.log(f());
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace-with-closure.ts.result b/src/MapleFE/test/typescript/unit_tests/namespace-with-closure.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3c7a2f5a188279e7137694a6266b8470a849d27c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace-with-closure.ts.result
@@ -0,0 +1,30 @@
+Matched 27 tokens.
+Matched 34 tokens.
+Matched 43 tokens.
+Matched 52 tokens.
+Matched 61 tokens.
+Matched 69 tokens.
+Matched 78 tokens.
+Matched 87 tokens.
+============= Module ===========
+== Sub Tree ==
+namespace  ns
+  export {func  func()  throws: 
+  js_let Decl: i=10
+  return () -> PreInc i
+} 
+
+== Sub Tree ==
+import {ns.func as myFunc} 
+== Sub Tree ==
+js_var Decl: f=myFunc()
+== Sub Tree ==
+console.log(f())
+== Sub Tree ==
+console.log(f())
+== Sub Tree ==
+f Assign ns.func()
+== Sub Tree ==
+console.log(f())
+== Sub Tree ==
+console.log(f())
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace-with-closure2.ts b/src/MapleFE/test/typescript/unit_tests/namespace-with-closure2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7d574427d5eb747f51d950fa45eb7649bec1c480
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace-with-closure2.ts
@@ -0,0 +1,16 @@
+namespace ns {
+  let i: number = 10;
+  export function func() : Function {
+    return () => ++i;
+  }
+}
+
+import myFunc = ns.func;
+
+var f: Function = myFunc();
+console.log(f());
+console.log(f());
+
+f = ns.func();
+console.log(f());
+console.log(f());
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace-with-closure2.ts.result b/src/MapleFE/test/typescript/unit_tests/namespace-with-closure2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..575d2bbaa036fb2a261238713849b0c26c47f524
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace-with-closure2.ts.result
@@ -0,0 +1,30 @@
+Matched 27 tokens.
+Matched 34 tokens.
+Matched 43 tokens.
+Matched 52 tokens.
+Matched 61 tokens.
+Matched 69 tokens.
+Matched 78 tokens.
+Matched 87 tokens.
+============= Module ===========
+== Sub Tree ==
+namespace  ns
+  js_let Decl: i=10
+  export {func  func()  throws: 
+  return () -> PreInc i
+} 
+
+== Sub Tree ==
+import {ns.func as myFunc} 
+== Sub Tree ==
+js_var Decl: f=myFunc()
+== Sub Tree ==
+console.log(f())
+== Sub Tree ==
+console.log(f())
+== Sub Tree ==
+f Assign ns.func()
+== Sub Tree ==
+console.log(f())
+== Sub Tree ==
+console.log(f())
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace.ts b/src/MapleFE/test/typescript/unit_tests/namespace.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0063f3281a004f26a4ef1b65ede34749f5456c02
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace.ts
@@ -0,0 +1,8 @@
+namespace ns_a {
+  var hello: string = "hello";
+  export function foo(): string {
+    return hello;
+  }
+}
+console.log(ns_a.foo());
+export { ns_a as ns_1 };
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace.ts.result b/src/MapleFE/test/typescript/unit_tests/namespace.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5bf02293716c720a8fc021ad99f67d75326cf63e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace.ts.result
@@ -0,0 +1,15 @@
+Matched 23 tokens.
+Matched 34 tokens.
+Matched 41 tokens.
+============= Module ===========
+== Sub Tree ==
+namespace  ns_a
+  js_var Decl: hello="hello"
+  export {func  foo()  throws: 
+  return hello
+} 
+
+== Sub Tree ==
+console.log(ns_a.foo())
+== Sub Tree ==
+export {ns_a as ns_1} 
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace2.ts b/src/MapleFE/test/typescript/unit_tests/namespace2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..daf0a9e0e53b67d0d35d05944387690cc344ddc6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace2.ts
@@ -0,0 +1,10 @@
+namespace ns_a {
+  var x: number = 10;
+  var hello: string = "hello";
+  export function foo(): string {
+    return hello;
+  }
+  for (var i = 0; i < x; ++i) console.log(i);
+}
+console.log(ns_a.foo());
+export { ns_a as ns_1 };
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace2.ts.result b/src/MapleFE/test/typescript/unit_tests/namespace2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4cedbcd03f32b0053c73e2f37da2373d190a9e5e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace2.ts.result
@@ -0,0 +1,18 @@
+Matched 51 tokens.
+Matched 62 tokens.
+Matched 69 tokens.
+============= Module ===========
+== Sub Tree ==
+namespace  ns_a
+  js_var Decl: x=10
+  js_var Decl: hello="hello"
+  export {func  foo()  throws: 
+  return hello
+} 
+  for ( )
+  console.log(i)
+
+== Sub Tree ==
+console.log(ns_a.foo())
+== Sub Tree ==
+export {ns_a as ns_1} 
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace3.ts b/src/MapleFE/test/typescript/unit_tests/namespace3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d4e3550e0e43ed8db691f96cbba102d5bc69f397
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace3.ts
@@ -0,0 +1,7 @@
+namespace ns.a {
+  var hello: string = "hello";
+  export function foo(): string {
+    return hello;
+  }
+}
+console.log(ns.a.foo());
diff --git a/src/MapleFE/test/typescript/unit_tests/namespace3.ts.result b/src/MapleFE/test/typescript/unit_tests/namespace3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..39f5a1f51e0770d99a529b86247cce0e6329f80d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/namespace3.ts.result
@@ -0,0 +1,12 @@
+Matched 25 tokens.
+Matched 38 tokens.
+============= Module ===========
+== Sub Tree ==
+namespace  ns.a
+  js_var Decl: hello="hello"
+  export {func  foo()  throws: 
+  return hello
+} 
+
+== Sub Tree ==
+console.log(ns.a.foo())
diff --git a/src/MapleFE/test/typescript/unit_tests/nested-loop.ts b/src/MapleFE/test/typescript/unit_tests/nested-loop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bf840bd995669375a43dab0b299876cd9eff1035
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nested-loop.ts
@@ -0,0 +1,12 @@
+var arr: number[] = [7, 4, 5, 9, 2, 8, 1, 6, 3];
+var len: number = arr.length;
+for (var i = 1; i < len; ++i) {
+  var j: number = i - 1;
+  var n = arr[i];
+  while (n < arr[j] && j >= 0) {
+    arr[j + 1] = arr[j];
+    --j;
+  }
+  arr[j + 1] = n;
+}
+console.log(arr);
diff --git a/src/MapleFE/test/typescript/unit_tests/nested-loop.ts.result b/src/MapleFE/test/typescript/unit_tests/nested-loop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2f6bfa14e1794283fb23017275fa6b9f0c322e7f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nested-loop.ts.result
@@ -0,0 +1,20 @@
+Matched 27 tokens.
+Matched 36 tokens.
+Matched 108 tokens.
+Matched 115 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[7,4,5,9,2,8,1,6,3]
+== Sub Tree ==
+js_var Decl: len=arr.length
+== Sub Tree ==
+for ( )
+  js_var Decl: j=i Sub 1
+  js_var Decl: n=arr[i]
+  while n LT arr[j] Land j GE 0    arr[j Add 1] Assign arr[j]
+    PreDec j
+
+  arr[j Add 1] Assign n
+
+== Sub Tree ==
+console.log(arr)
diff --git a/src/MapleFE/test/typescript/unit_tests/nested-switch.ts b/src/MapleFE/test/typescript/unit_tests/nested-switch.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5c5169341037312f061a69a01d82760808fbd242
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nested-switch.ts
@@ -0,0 +1,23 @@
+var n: number = 3;
+outer: switch (true) {
+  case n < 5:
+    console.log(n, " is less than 5");
+  case n > 2 && n < 5:
+    switch (n) {
+      case 3:
+        console.log(3);
+        break outer;
+      case 4:
+        console.log(4);
+    }
+    console.log(n, " + 1 is equal to", n + 1);
+    break;
+  case n == 6:
+    console.log(n, " is equal to 6");
+    break;
+  case n < 8:
+    console.log(n, " is greater than 4 and less than 8");
+    break;
+  default:
+    console.log(n, " is greater than 7");
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/nested-switch.ts.result b/src/MapleFE/test/typescript/unit_tests/nested-switch.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d3cc51c43e971c32eeaa11cd84f0b1048cb026b4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nested-switch.ts.result
@@ -0,0 +1,8 @@
+Matched 7 tokens.
+Matched 125 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: n=3
+== Sub Tree ==
+A switch
+
diff --git a/src/MapleFE/test/typescript/unit_tests/nested.ts b/src/MapleFE/test/typescript/unit_tests/nested.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aa3a1265240d29bd72004b89f33d2c5e5b247c80
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nested.ts
@@ -0,0 +1,11 @@
+let x: number = 10;
+
+function outer(y: number): number {
+  let x: number = 20;
+  function inner(): number {
+    return x + y;
+  }
+  return inner();
+}
+
+console.log(outer(100));
diff --git a/src/MapleFE/test/typescript/unit_tests/nested.ts.result b/src/MapleFE/test/typescript/unit_tests/nested.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0eb487d7f9410554c4bf0c4b89dc3e742e4b6cc5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nested.ts.result
@@ -0,0 +1,16 @@
+Matched 7 tokens.
+Matched 43 tokens.
+Matched 53 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: x=10
+== Sub Tree ==
+func  outer(y)  throws: 
+  js_let Decl: x=20
+  func  inner()  throws: 
+    return x Add y
+
+  return inner()
+
+== Sub Tree ==
+console.log(outer(100))
diff --git a/src/MapleFE/test/typescript/unit_tests/new-array.ts b/src/MapleFE/test/typescript/unit_tests/new-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5b43f4bd71e633f38ca7c4fc5801100d33a9db9e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/new-array.ts
@@ -0,0 +1,6 @@
+var v: boolean = (() => {
+  const buf = new ArrayBuffer(2);
+  new DataView(buf).setInt16(0, 256, true);
+  return new Int16Array(buf)[0] === 256;
+})();
+console.log(v);
diff --git a/src/MapleFE/test/typescript/unit_tests/new-array.ts.result b/src/MapleFE/test/typescript/unit_tests/new-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..343c86d07ff381b8ec2bfe9c59df0657bd2fb08b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/new-array.ts.result
@@ -0,0 +1,10 @@
+Matched 51 tokens.
+Matched 58 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: v=() -> js_const Decl: buf=new ArrayBuffer(2)
+new DataView(buf).setInt16(0,256,true)
+return new Int16Array(buf)[0] StEq 256
+()
+== Sub Tree ==
+console.log(v)
diff --git a/src/MapleFE/test/typescript/unit_tests/new-typed.ts b/src/MapleFE/test/typescript/unit_tests/new-typed.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b4ce46d179ff0d57b7eb08fcdbb81337778a4670
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/new-typed.ts
@@ -0,0 +1,5 @@
+class A {
+  a: number = 0;
+}
+var x : Function = A;
+var y : A  = new A();
diff --git a/src/MapleFE/test/typescript/unit_tests/new-typed.ts.result b/src/MapleFE/test/typescript/unit_tests/new-typed.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..061c44ed79a8fba937f33fdb2cc90d852af9ca1b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/new-typed.ts.result
@@ -0,0 +1,18 @@
+Matched 10 tokens.
+Matched 17 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+    a=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: x=A
+== Sub Tree ==
+js_var Decl: y=new A()
diff --git a/src/MapleFE/test/typescript/unit_tests/new.ts b/src/MapleFE/test/typescript/unit_tests/new.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e15cd8cf434620b82476a358ed2d8fb1d73ad417
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/new.ts
@@ -0,0 +1,5 @@
+class A {
+  a: number = 0;
+}
+var x = A;
+var y = new A();
diff --git a/src/MapleFE/test/typescript/unit_tests/new.ts.result b/src/MapleFE/test/typescript/unit_tests/new.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b04a81a2f86a804f93954656c46a02a950ebb11e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/new.ts.result
@@ -0,0 +1,18 @@
+Matched 10 tokens.
+Matched 15 tokens.
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+    a=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: x=A
+== Sub Tree ==
+js_var Decl: y=new A()
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion-this.ts b/src/MapleFE/test/typescript/unit_tests/non-null-assertion-this.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56e3e9b6072acfea70473ecce6e42c59d2b202c2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion-this.ts
@@ -0,0 +1,6 @@
+class Foo {
+  public _val: number = 0;
+  public func(): number {
+    return this._val! as number;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion-this.ts.result b/src/MapleFE/test/typescript/unit_tests/non-null-assertion-this.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c1164fc9ae80badf698158420119fd189d987dae
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion-this.ts.result
@@ -0,0 +1,14 @@
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    _val=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func()  throws: 
+      return this._val!
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion.ts b/src/MapleFE/test/typescript/unit_tests/non-null-assertion.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f45fb51b3d4b3642942aef6c8a293f3105bf68e2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion.ts
@@ -0,0 +1,6 @@
+// https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-0.html#non-null-assertion-operator
+// used in cocos director.ts
+function processEntity(e?: any) {
+  let s = e!.name; // Assert that e is non-null and access name
+  let t = e.name!;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion.ts.result b/src/MapleFE/test/typescript/unit_tests/non-null-assertion.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6128e1977886dfada07b6d220535976a53290442
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion.ts.result
@@ -0,0 +1,7 @@
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+func  processEntity(e?)  throws: 
+  js_let Decl: s=e!.name
+  js_let Decl: t=e.name!
+
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion2.ts b/src/MapleFE/test/typescript/unit_tests/non-null-assertion2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f9baf6a8064932ecf8e720b1dbf0f9779a5e8cad
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion2.ts
@@ -0,0 +1,9 @@
+function foo(): Object | null {
+  return new Object();
+}
+
+export const obj = (() => {
+  return foo()!;
+})();
+
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion2.ts.result b/src/MapleFE/test/typescript/unit_tests/non-null-assertion2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..eeb0773123f8b1a989b172ced8916c6d6168658c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion2.ts.result
@@ -0,0 +1,13 @@
+Matched 16 tokens.
+Matched 36 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+func  foo()  throws: 
+  return new Object()
+
+== Sub Tree ==
+export {js_const Decl: obj=() -> return foo()
+()} 
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion3.ts b/src/MapleFE/test/typescript/unit_tests/non-null-assertion3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a14849ff45cfbd56822b5391d7458c0ccf6de887
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion3.ts
@@ -0,0 +1,9 @@
+function foo(): Object | null {
+  return new Array();
+}
+
+export const obj = (() => {
+  return foo()! as unknown as Array<number>;
+})();
+
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion3.ts.result b/src/MapleFE/test/typescript/unit_tests/non-null-assertion3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c1e0b4969cc0c35977380fb5b41128d91db051a1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion3.ts.result
@@ -0,0 +1,13 @@
+Matched 16 tokens.
+Matched 43 tokens.
+Matched 50 tokens.
+============= Module ===========
+== Sub Tree ==
+func  foo()  throws: 
+  return new Array()
+
+== Sub Tree ==
+export {js_const Decl: obj=() -> return foo()
+()} 
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion4.ts b/src/MapleFE/test/typescript/unit_tests/non-null-assertion4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..594f1d1799a4b8c7a2f75c4879ce0341a14fd7e9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion4.ts
@@ -0,0 +1,3 @@
+var arr: Object[] = [new Object()];
+var obj = arr[0]!;
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/non-null-assertion4.ts.result b/src/MapleFE/test/typescript/unit_tests/non-null-assertion4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1cb1d5237e689f6223c691aeb4b9d1cff6001dd3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/non-null-assertion4.ts.result
@@ -0,0 +1,10 @@
+Matched 14 tokens.
+Matched 23 tokens.
+Matched 30 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[new Object()]
+== Sub Tree ==
+js_var Decl: obj=arr[0]
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/nullish-assignment.ts b/src/MapleFE/test/typescript/unit_tests/nullish-assignment.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0624026d18104f1dad29eb3c55f0828b44c90cd9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nullish-assignment.ts
@@ -0,0 +1,6 @@
+function func(num?: number): number {
+  num ??= 2;
+  return num * num;
+}
+console.log(func(10));
+console.log(func());
diff --git a/src/MapleFE/test/typescript/unit_tests/nullish-assignment.ts.result b/src/MapleFE/test/typescript/unit_tests/nullish-assignment.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f46445509ede779ac84e48bc3951eb61442bf54c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nullish-assignment.ts.result
@@ -0,0 +1,13 @@
+Matched 21 tokens.
+Matched 31 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(num?)  throws: 
+  num NullAssign 2
+  return num Mul num
+
+== Sub Tree ==
+console.log(func(10))
+== Sub Tree ==
+console.log(func())
diff --git a/src/MapleFE/test/typescript/unit_tests/nullist-coalescing.ts b/src/MapleFE/test/typescript/unit_tests/nullist-coalescing.ts
new file mode 100644
index 0000000000000000000000000000000000000000..958714e1fce13126fb96c2bc6cdd325c0c86db5e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nullist-coalescing.ts
@@ -0,0 +1,4 @@
+// https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#nullish-coalescing
+let a: any = null;
+let b: boolean = a ?? true;
+console.log(a, b);
diff --git a/src/MapleFE/test/typescript/unit_tests/nullist-coalescing.ts.result b/src/MapleFE/test/typescript/unit_tests/nullist-coalescing.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ef193ece82ba4def24b6c52122acf3b35243f346
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nullist-coalescing.ts.result
@@ -0,0 +1,10 @@
+Matched 7 tokens.
+Matched 16 tokens.
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: a=null
+== Sub Tree ==
+js_let Decl: b=a NullCoalesce true
+== Sub Tree ==
+console.log(a,b)
diff --git a/src/MapleFE/test/typescript/unit_tests/nullist-coalescing2.ts b/src/MapleFE/test/typescript/unit_tests/nullist-coalescing2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2df1b8b9292897fd467b8844b3d9c1192adb7892
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nullist-coalescing2.ts
@@ -0,0 +1,7 @@
+function func(x: any): any {
+  return x;
+}
+let a: any = { f: false };
+// https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#optional-chaining
+let b: boolean = func(a)?.f ?? true;
+console.log(a, b);
diff --git a/src/MapleFE/test/typescript/unit_tests/nullist-coalescing2.ts.result b/src/MapleFE/test/typescript/unit_tests/nullist-coalescing2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..949c3926980ec2d7f6934f77de6333c1a022fc8e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/nullist-coalescing2.ts.result
@@ -0,0 +1,15 @@
+Matched 14 tokens.
+Matched 25 tokens.
+Matched 39 tokens.
+Matched 48 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(x)  throws: 
+  return x
+
+== Sub Tree ==
+js_let Decl: a= {f:false}
+== Sub Tree ==
+js_let Decl: b=func(a).f NullCoalesce true
+== Sub Tree ==
+console.log(a,b)
diff --git a/src/MapleFE/test/typescript/unit_tests/number-array.ts b/src/MapleFE/test/typescript/unit_tests/number-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d4db7ddbcd1e3fcb4294e87be3f9fb035d09e967
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/number-array.ts
@@ -0,0 +1,2 @@
+var arr: number[];
+var arr: number[] = [1];
diff --git a/src/MapleFE/test/typescript/unit_tests/number-array.ts.result b/src/MapleFE/test/typescript/unit_tests/number-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..95c41af3f33de13ad52751301695806a37248bff
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/number-array.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 18 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr
+== Sub Tree ==
+js_var Decl: arr=[1]
diff --git a/src/MapleFE/test/typescript/unit_tests/number-literal.ts b/src/MapleFE/test/typescript/unit_tests/number-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..901536ae9582089642c65f4959d052483f7ba2d9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/number-literal.ts
@@ -0,0 +1,3 @@
+const x: number = .2;
+const y: number = -.2;
+console.log(x, y);
diff --git a/src/MapleFE/test/typescript/unit_tests/number-literal.ts.result b/src/MapleFE/test/typescript/unit_tests/number-literal.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..577b2fff51d9752b137b0d5ba212dff293b9c373
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/number-literal.ts.result
@@ -0,0 +1,10 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: x=0.2
+== Sub Tree ==
+js_const Decl: y=-0.2
+== Sub Tree ==
+console.log(x,y)
diff --git a/src/MapleFE/test/typescript/unit_tests/number-var.ts b/src/MapleFE/test/typescript/unit_tests/number-var.ts
new file mode 100644
index 0000000000000000000000000000000000000000..257f24faa4df5439f6cf4f99501500eb9092f555
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/number-var.ts
@@ -0,0 +1,7 @@
+var func: (number: number) => string;
+function conv(number: number): string {
+  return number as unknown as string;
+}
+
+func = conv;
+console.log(func(123));
diff --git a/src/MapleFE/test/typescript/unit_tests/number-var.ts.result b/src/MapleFE/test/typescript/unit_tests/number-var.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a1d0390d3fd0ea86fc6899efcd842cb7db124c69
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/number-var.ts.result
@@ -0,0 +1,15 @@
+Matched 11 tokens.
+Matched 29 tokens.
+Matched 33 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: func
+== Sub Tree ==
+func  conv(number)  throws: 
+  return number
+
+== Sub Tree ==
+func Assign conv
+== Sub Tree ==
+console.log(func(123))
diff --git a/src/MapleFE/test/typescript/unit_tests/number.ts b/src/MapleFE/test/typescript/unit_tests/number.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b0ed7e5f07171b97cbba2cf2ce4a08b2940dde42
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/number.ts
@@ -0,0 +1,4 @@
+var x = 4278190335;
+console.log(x);
+x = -1;
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/number.ts.result b/src/MapleFE/test/typescript/unit_tests/number.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..836c3a5037a175231a1c1e698785a51d0f4eedb8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/number.ts.result
@@ -0,0 +1,13 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 16 tokens.
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=4278190335
+== Sub Tree ==
+console.log(x)
+== Sub Tree ==
+x Assign -1
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/obj.ts b/src/MapleFE/test/typescript/unit_tests/obj.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1582c89d2e038dd77e8dda82d9b9fc76b2e0e6b4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/obj.ts
@@ -0,0 +1,3 @@
+let john = {
+  lastName: "Smith"
+};
diff --git a/src/MapleFE/test/typescript/unit_tests/obj.ts.result b/src/MapleFE/test/typescript/unit_tests/obj.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9c213f7401e72104ae4458172b7e61bfacb2ed20
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/obj.ts.result
@@ -0,0 +1,4 @@
+Matched 9 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: john= {lastName:"Smith"}
diff --git a/src/MapleFE/test/typescript/unit_tests/object-destructing.ts b/src/MapleFE/test/typescript/unit_tests/object-destructing.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9a189b6f038798483f376138a50ef441b841ac5d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-destructing.ts
@@ -0,0 +1,4 @@
+var x = [{ a: 1 }, { b: 2 }, { c: 3 }];
+console.log(x.length);
+var [{ a: u }, { b: v }] = x;
+console.log(u, v);
diff --git a/src/MapleFE/test/typescript/unit_tests/object-destructing.ts.result b/src/MapleFE/test/typescript/unit_tests/object-destructing.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..91161a894104ece0a4634175afda0438c20f6eee
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-destructing.ts.result
@@ -0,0 +1,13 @@
+Matched 23 tokens.
+Matched 32 tokens.
+Matched 49 tokens.
+Matched 58 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=[ {a:1}, {b:2}, {c:3}]
+== Sub Tree ==
+console.log(x.length)
+== Sub Tree ==
+js_var Decl: {{a:u}, {b:v}}
+== Sub Tree ==
+console.log(u,v)
diff --git a/src/MapleFE/test/typescript/unit_tests/object-destructing2.ts b/src/MapleFE/test/typescript/unit_tests/object-destructing2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0dfbec3fd8ae78fa700968e7fad94b84f13eafb9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-destructing2.ts
@@ -0,0 +1,6 @@
+function func(args: any): any {
+  const {foo, ...others} = args;
+  return others;
+}
+
+console.log(func({foo: "Foo", bar: "Bar", tee: "Tee"}));
diff --git a/src/MapleFE/test/typescript/unit_tests/object-destructing2.ts.result b/src/MapleFE/test/typescript/unit_tests/object-destructing2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6fc4e5d75956688e09ecf1d36a431fe684dae084
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-destructing2.ts.result
@@ -0,0 +1,10 @@
+Matched 24 tokens.
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(args)  throws: 
+  js_const Decl: {:foo, :...others}
+  return others
+
+== Sub Tree ==
+console.log(func( {foo:"Foo", bar:"Bar", tee:"Tee"}))
diff --git a/src/MapleFE/test/typescript/unit_tests/object-func-prop.ts b/src/MapleFE/test/typescript/unit_tests/object-func-prop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..178b591ac2ab36db3bed90ac019d3e067689bd7b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-func-prop.ts
@@ -0,0 +1,7 @@
+const initializer: any = {
+  foo(data: string) {
+    console.log(data);
+  },
+};
+
+initializer.foo("test");
diff --git a/src/MapleFE/test/typescript/unit_tests/object-func-prop.ts.result b/src/MapleFE/test/typescript/unit_tests/object-func-prop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3fbfed7752d0f03706a8c021e16058787818956c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-func-prop.ts.result
@@ -0,0 +1,9 @@
+Matched 24 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: initializer= {foo:func  foo(data)  throws: 
+  console.log(data)
+}
+== Sub Tree ==
+initializer.foo("test")
diff --git a/src/MapleFE/test/typescript/unit_tests/object-keys-arr-map.ts b/src/MapleFE/test/typescript/unit_tests/object-keys-arr-map.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49a05a210e6a0d7bc1375281636431b25957b98c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-keys-arr-map.ts
@@ -0,0 +1,4 @@
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map
+var objA = { objB: { objC: {} } };
+const list = Object.keys(objA.objB.objC).map((x) => objA.objB.objC[x]);
diff --git a/src/MapleFE/test/typescript/unit_tests/object-keys-arr-map.ts.result b/src/MapleFE/test/typescript/unit_tests/object-keys-arr-map.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..60163cf00d8476cecead062e5c0c3b47276d79e1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-keys-arr-map.ts.result
@@ -0,0 +1,7 @@
+Matched 14 tokens.
+Matched 44 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: objA= {objB: {objC: {}}}
+== Sub Tree ==
+js_const Decl: list=Object.keys(objA.objB.objC).map((x) -> objA.objB.objC[x])
diff --git a/src/MapleFE/test/typescript/unit_tests/object-literal.ts b/src/MapleFE/test/typescript/unit_tests/object-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..701e019ea40eeee9a9444f576f93cb35dbd8148b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-literal.ts
@@ -0,0 +1,2 @@
+var x: any = { n: [-1.5, 0, 1.0] };
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/object-literal.ts.result b/src/MapleFE/test/typescript/unit_tests/object-literal.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e5424fa6f8f3ef9115ccebc1bec2a4faf5d2f44f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/object-literal.ts.result
@@ -0,0 +1,7 @@
+Matched 17 tokens.
+Matched 24 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x= {n:[-1.5,0,1]}
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/objects.ts b/src/MapleFE/test/typescript/unit_tests/objects.ts
new file mode 100644
index 0000000000000000000000000000000000000000..15f2f507ab535d94d382ee52ea7e4278c5e7fe36
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/objects.ts
@@ -0,0 +1,22 @@
+// different ways of creating an object
+
+function func() {}
+
+let funcObj = function (name: string) {
+  this._name = name;
+};
+
+class ObjClass {
+  private _name: string;
+  constructor(name: string) {
+    this._name = name;
+  }
+}
+
+let obj_a: Object = {};
+let obj_b: Object = Object.create({});
+let obj_c: Object = Object.create(null);
+let obj_d: Object = new Object();
+let obj_e: Object = new func();
+let obj_f: Object = new funcObj("John");
+let obj_g: Object = new ObjClass("John");
diff --git a/src/MapleFE/test/typescript/unit_tests/objects.ts.result b/src/MapleFE/test/typescript/unit_tests/objects.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1888e60831d18dbe197bf43457cc8b20dc138707
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/objects.ts.result
@@ -0,0 +1,44 @@
+Matched 6 tokens.
+Matched 24 tokens.
+Matched 47 tokens.
+Matched 55 tokens.
+Matched 68 tokens.
+Matched 80 tokens.
+Matched 90 tokens.
+Matched 100 tokens.
+Matched 111 tokens.
+Matched 122 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+
+== Sub Tree ==
+js_let Decl: funcObj=func  (name)  throws: 
+  this._name Assign name
+
+== Sub Tree ==
+class  ObjClass
+  Fields: 
+    _name
+  Instance Initializer: 
+  Constructors: 
+    constructor  (name)  throws: 
+      this._name Assign name
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: obj_a= {}
+== Sub Tree ==
+js_let Decl: obj_b=Object.create( {})
+== Sub Tree ==
+js_let Decl: obj_c=Object.create(null)
+== Sub Tree ==
+js_let Decl: obj_d=new Object()
+== Sub Tree ==
+js_let Decl: obj_e=new func()
+== Sub Tree ==
+js_let Decl: obj_f=new funcObj("John")
+== Sub Tree ==
+js_let Decl: obj_g=new ObjClass("John")
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-chaining.ts b/src/MapleFE/test/typescript/unit_tests/optional-chaining.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c17627bdbe8af6e60d5a3aeea6e2c5bee0645bbe
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-chaining.ts
@@ -0,0 +1,7 @@
+function func(arr?: number[]) {
+  return arr?.[0];
+}
+
+let arr: number[] = [1, 2, 3];
+console.log(func(arr));
+console.log(func());
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-chaining.ts.result b/src/MapleFE/test/typescript/unit_tests/optional-chaining.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f08105ea81725c5c5454525f8d18adb18bfb86db
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-chaining.ts.result
@@ -0,0 +1,15 @@
+Matched 19 tokens.
+Matched 34 tokens.
+Matched 44 tokens.
+Matched 53 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(arr?)  throws: 
+  return arr?[0]
+
+== Sub Tree ==
+js_let Decl: arr=[1,2,3]
+== Sub Tree ==
+console.log(func(arr))
+== Sub Tree ==
+console.log(func())
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-chaining2.ts b/src/MapleFE/test/typescript/unit_tests/optional-chaining2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7b62c4ca9453e63f1fca540343ab5bc5efa2c4df
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-chaining2.ts
@@ -0,0 +1,6 @@
+const obj = {
+  func: function () {
+    return 123;
+  },
+};
+console.log(obj.func?.());
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-chaining2.ts.result b/src/MapleFE/test/typescript/unit_tests/optional-chaining2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3d0d7d1474b2f473ba1360e1985b5b97f1f9d1bb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-chaining2.ts.result
@@ -0,0 +1,9 @@
+Matched 17 tokens.
+Matched 29 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {func:func  ()  throws: 
+  return 123
+}
+== Sub Tree ==
+console.log(obj.func())
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-chaining3.ts b/src/MapleFE/test/typescript/unit_tests/optional-chaining3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..69722086d3e21fe50e10b751cfc3577011d72c55
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-chaining3.ts
@@ -0,0 +1,10 @@
+const obj = {
+  func: function () {
+    return 123;
+  },
+};
+
+function foo() {
+  return obj;
+}
+console.log(foo()?.func?.());
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-chaining3.ts.result b/src/MapleFE/test/typescript/unit_tests/optional-chaining3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..958a6fde5c0f84277c676150dabbff01cd10b563
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-chaining3.ts.result
@@ -0,0 +1,14 @@
+Matched 17 tokens.
+Matched 26 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {func:func  ()  throws: 
+  return 123
+}
+== Sub Tree ==
+func  foo()  throws: 
+  return obj
+
+== Sub Tree ==
+console.log(foo().func())
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-method.ts b/src/MapleFE/test/typescript/unit_tests/optional-method.ts
new file mode 100644
index 0000000000000000000000000000000000000000..585b9d26f326619164d176d53812903416b4540b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-method.ts
@@ -0,0 +1,3 @@
+class Klass {
+  protected func?(): void;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-method.ts.result b/src/MapleFE/test/typescript/unit_tests/optional-method.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1e36537786314b0f5e55efb76027d902fc1a223d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-method.ts.result
@@ -0,0 +1,13 @@
+Matched 12 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func?()  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-param.ts b/src/MapleFE/test/typescript/unit_tests/optional-param.ts
new file mode 100644
index 0000000000000000000000000000000000000000..44d22da25c68181a5a71f3ff275137923836e813
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-param.ts
@@ -0,0 +1,10 @@
+class Foo {
+  public a: string = "";
+}
+
+function func(x?: Foo): Foo {
+  return x ? x : { a: "default:a" };
+}
+
+console.log(func());
+console.log(func({ a: "Foo:a" }));
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-param.ts.result b/src/MapleFE/test/typescript/unit_tests/optional-param.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..fb05f46048eb9cc0d723b79fd7b1f3d747561fd0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-param.ts.result
@@ -0,0 +1,23 @@
+Matched 11 tokens.
+Matched 34 tokens.
+Matched 43 tokens.
+Matched 57 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    a=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func(x?)  throws: 
+  return x ? x :  {a:"default:a"}
+
+== Sub Tree ==
+console.log(func())
+== Sub Tree ==
+console.log(func( {a:"Foo:a"}))
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-prop.ts b/src/MapleFE/test/typescript/unit_tests/optional-prop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d635013d7e144fc5bffbebfd3f427200b35209f3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-prop.ts
@@ -0,0 +1,11 @@
+class Klass {
+  a: number = 0;
+  b?: number;
+}
+
+function f({ a, b = 1 }: Klass): number {
+  return a + b;
+}
+
+console.log(f({ a: 1 }));
+console.log(f({ a: 1, b: 2 }));
diff --git a/src/MapleFE/test/typescript/unit_tests/optional-prop.ts.result b/src/MapleFE/test/typescript/unit_tests/optional-prop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1dd4128a6ba5c4ffa15c49f2ec29766006cf2704
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/optional-prop.ts.result
@@ -0,0 +1,23 @@
+Matched 15 tokens.
+Matched 37 tokens.
+Matched 51 tokens.
+Matched 69 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    a=0    b?
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  f({:a, :b=1})  throws: 
+  return a Add b
+
+== Sub Tree ==
+console.log(f( {a:1}))
+== Sub Tree ==
+console.log(f( {a:1, b:2}))
diff --git a/src/MapleFE/test/typescript/unit_tests/pick-key.ts b/src/MapleFE/test/typescript/unit_tests/pick-key.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a8ba3a4bc304b0ab536d985022bbea1427937241
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/pick-key.ts
@@ -0,0 +1,6 @@
+interface IFace {
+  s: string;
+  n: number;
+}
+declare type Type = { [K in keyof Pick<IFace, "s">]: true; };
+
diff --git a/src/MapleFE/test/typescript/unit_tests/pick-key.ts.result b/src/MapleFE/test/typescript/unit_tests/pick-key.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..03c535cb9bdf5df29aeb068ed4d28f20fca2d1e0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/pick-key.ts.result
@@ -0,0 +1,7 @@
+Matched 12 tokens.
+Matched 33 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {s;n }
+== Sub Tree ==
+declare  type Type =  {[K in  keyof Pick<IFace,"s">] : true }
diff --git a/src/MapleFE/test/typescript/unit_tests/priv-declare.ts b/src/MapleFE/test/typescript/unit_tests/priv-declare.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8babfc0eeb8ece6cfa8e0b3a04f260f829a8c2e3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/priv-declare.ts
@@ -0,0 +1,3 @@
+class CLS_test {
+  private declare priv_fd: number;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/priv-declare.ts.result b/src/MapleFE/test/typescript/unit_tests/priv-declare.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2c1241d605350d8dd7d5c873694daefc5696e6ec
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/priv-declare.ts.result
@@ -0,0 +1,13 @@
+Matched 10 tokens.
+============= Module ===========
+== Sub Tree ==
+class  CLS_test
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+  Declares: 
+    declare js_var Decl: priv_fd
diff --git a/src/MapleFE/test/typescript/unit_tests/private-constructor.ts b/src/MapleFE/test/typescript/unit_tests/private-constructor.ts
new file mode 100644
index 0000000000000000000000000000000000000000..280daea9af883d7eefca14378dc8cdebf33ad1ca
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/private-constructor.ts
@@ -0,0 +1,6 @@
+declare namespace NS {
+  class Klass {
+    n: number;
+    private constructor();
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/private-constructor.ts.result b/src/MapleFE/test/typescript/unit_tests/private-constructor.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ff6c6a0630e64923c7d45837a6072f9843fdbbb5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/private-constructor.ts.result
@@ -0,0 +1,15 @@
+Matched 18 tokens.
+============= Module ===========
+== Sub Tree ==
+declare namespace  NS
+  class  Klass
+  Fields: 
+    n
+  Instance Initializer: 
+  Constructors: 
+    constructor  ()  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+
diff --git a/src/MapleFE/test/typescript/unit_tests/private-field.d.ts b/src/MapleFE/test/typescript/unit_tests/private-field.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..70fb72ce9d09c8f65d5aa8e226f9cd7a06a7df2c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/private-field.d.ts
@@ -0,0 +1,7 @@
+// #private; for ECMAScript’s pound (#) private fields
+// https://www.typescriptlang.org/docs/handbook/2/classes.html#caveats
+// https://github.com/microsoft/TypeScript/issues/38050
+declare class Klass {
+    #private;
+    constructor();
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/private-field.d.ts.result b/src/MapleFE/test/typescript/unit_tests/private-field.d.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7375df4dcbb2cf727e745c73eb8aa1818d5ff888
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/private-field.d.ts.result
@@ -0,0 +1,13 @@
+Matched 12 tokens.
+============= Module ===========
+== Sub Tree ==
+declare class  Klass
+  Fields: 
+    private
+  Instance Initializer: 
+  Constructors: 
+    constructor  ()  throws: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/private-prop.ts b/src/MapleFE/test/typescript/unit_tests/private-prop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f59dc26801875779246b6c39d23851493ac83077
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/private-prop.ts
@@ -0,0 +1,5 @@
+class Klass {
+    private "Klass.#private" = "abc";
+}
+var obj : Klass = new Klass();
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/private-prop.ts.result b/src/MapleFE/test/typescript/unit_tests/private-prop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8804c42005a08a0b80281bbc1dfe7c3fe449577d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/private-prop.ts.result
@@ -0,0 +1,18 @@
+Matched 9 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    "Klass.#private" = "abc"
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/prop-name-extends.ts b/src/MapleFE/test/typescript/unit_tests/prop-name-extends.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8a7afdd521d8706a8e00cbc5e200c22a8ea57938
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/prop-name-extends.ts
@@ -0,0 +1 @@
+function func(arg: { extends: null | Function }) {}
diff --git a/src/MapleFE/test/typescript/unit_tests/prop-name-extends.ts.result b/src/MapleFE/test/typescript/unit_tests/prop-name-extends.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b8774ca191a1440ea1eaebd14c13818adafd5721
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/prop-name-extends.ts.result
@@ -0,0 +1,5 @@
+Matched 15 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(arg)  throws: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/property-deco.ts b/src/MapleFE/test/typescript/unit_tests/property-deco.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cefae64156bc3fdd2374ab837e508db7fec6f399
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/property-deco.ts
@@ -0,0 +1,16 @@
+function prop_deco(msg: string) {
+  return function (target: any, name: string) {
+    console.log("Accessed", name, msg, target);
+  };
+}
+
+class Klass {
+  @prop_deco("of")
+  x: number;
+  constructor(i: number) {
+    this.x = i;
+  }
+}
+
+var c = new Klass(3);
+console.log(c.x);
diff --git a/src/MapleFE/test/typescript/unit_tests/property-deco.ts.result b/src/MapleFE/test/typescript/unit_tests/property-deco.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1ab368a50744badc22012660a8e8a7a6d211698d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/property-deco.ts.result
@@ -0,0 +1,27 @@
+Matched 36 tokens.
+Matched 63 tokens.
+Matched 72 tokens.
+Matched 81 tokens.
+============= Module ===========
+== Sub Tree ==
+func  prop_deco(msg)  throws: 
+  return func  (target,name)  throws: 
+  console.log("Accessed",name,msg,target)
+
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+    x
+  Instance Initializer: 
+  Constructors: 
+    constructor  (i)  throws: 
+      this.x Assign i
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: c=new Klass(3)
+== Sub Tree ==
+console.log(c.x)
diff --git a/src/MapleFE/test/typescript/unit_tests/property-deco2.ts b/src/MapleFE/test/typescript/unit_tests/property-deco2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5727298d19469dfcdcb8d5ba4cf7657d53a7ce2b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/property-deco2.ts
@@ -0,0 +1,20 @@
+function prop_deco(msg: string) {
+  return function (target: any, name: string) {
+    console.log("Accessed", name, msg, target);
+  };
+}
+
+class Klass {
+  _x: number;
+  constructor(i: number) {
+    this._x = i;
+  }
+
+  @prop_deco("of")
+  get x() {
+    return this._x;
+  }
+}
+
+var c = new Klass(3);
+console.log(c.x);
diff --git a/src/MapleFE/test/typescript/unit_tests/property-deco2.ts.result b/src/MapleFE/test/typescript/unit_tests/property-deco2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3870d964ac97e61a58afca083c1530b5b2a8128c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/property-deco2.ts.result
@@ -0,0 +1,29 @@
+Matched 36 tokens.
+Matched 74 tokens.
+Matched 83 tokens.
+Matched 92 tokens.
+============= Module ===========
+== Sub Tree ==
+func  prop_deco(msg)  throws: 
+  return func  (target,name)  throws: 
+  console.log("Accessed",name,msg,target)
+
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+    _x
+  Instance Initializer: 
+  Constructors: 
+    constructor  (i)  throws: 
+      this._x Assign i
+  Methods: 
+    get x()  throws: 
+      return this._x
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: c=new Klass(3)
+== Sub Tree ==
+console.log(c.x)
diff --git a/src/MapleFE/test/typescript/unit_tests/property-deco3.ts b/src/MapleFE/test/typescript/unit_tests/property-deco3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3f9686568426ed71dfd8b6a7e85bd5b01b7a6e01
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/property-deco3.ts
@@ -0,0 +1,16 @@
+function type(msg: string) {
+  return function (target: any, name: string) {
+    console.log("Accessed", name, msg, target);
+  };
+}
+
+class Klass {
+  @type("of")
+  x: number;
+  constructor(i: number) {
+    this.x = i;
+  }
+}
+
+var c = new Klass(3);
+console.log(c.x);
diff --git a/src/MapleFE/test/typescript/unit_tests/property-deco3.ts.result b/src/MapleFE/test/typescript/unit_tests/property-deco3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e1ebece167f1202a4fa8d0e70f8eab7f754cc60d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/property-deco3.ts.result
@@ -0,0 +1,27 @@
+Matched 36 tokens.
+Matched 63 tokens.
+Matched 72 tokens.
+Matched 81 tokens.
+============= Module ===========
+== Sub Tree ==
+func  type(msg)  throws: 
+  return func  (target,name)  throws: 
+  console.log("Accessed",name,msg,target)
+
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+    x
+  Instance Initializer: 
+  Constructors: 
+    constructor  (i)  throws: 
+      this.x Assign i
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: c=new Klass(3)
+== Sub Tree ==
+console.log(c.x)
diff --git a/src/MapleFE/test/typescript/unit_tests/property-deco4.ts b/src/MapleFE/test/typescript/unit_tests/property-deco4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..539811a971930c13f0f9fd145bf259a0b1350c4d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/property-deco4.ts
@@ -0,0 +1,21 @@
+function type(msg: string) {
+  return function (target: any, name: string) {
+    console.log("Accessed", name, msg, target);
+  };
+}
+
+function deco(target: any, name: string) {
+  console.log("Accessed", name, "OF", target);
+}
+
+class Klass {
+  @deco
+  @type("of")
+  x: number;
+  constructor(i: number) {
+    this.x = i;
+  }
+}
+
+var c = new Klass(3);
+console.log(c.x);
diff --git a/src/MapleFE/test/typescript/unit_tests/property-deco4.ts.result b/src/MapleFE/test/typescript/unit_tests/property-deco4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9aa9229bb9e5ebfd33877ffb7ade40f59dd11358
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/property-deco4.ts.result
@@ -0,0 +1,32 @@
+Matched 36 tokens.
+Matched 62 tokens.
+Matched 91 tokens.
+Matched 100 tokens.
+Matched 109 tokens.
+============= Module ===========
+== Sub Tree ==
+func  type(msg)  throws: 
+  return func  (target,name)  throws: 
+  console.log("Accessed",name,msg,target)
+
+
+== Sub Tree ==
+func  deco(target,name)  throws: 
+  console.log("Accessed",name,"OF",target)
+
+== Sub Tree ==
+class  Klass
+  Fields: 
+    x
+  Instance Initializer: 
+  Constructors: 
+    constructor  (i)  throws: 
+      this.x Assign i
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: c=new Klass(3)
+== Sub Tree ==
+console.log(c.x)
diff --git a/src/MapleFE/test/typescript/unit_tests/public-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/public-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..19784d994c4a50459b669a7b8fdac749a57847e0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/public-as-prop-name.ts
@@ -0,0 +1,3 @@
+interface IFace {
+    public: string;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/public-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/public-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..55d9de52e70c78571eb902a72d547fc194f37043
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/public-as-prop-name.ts.result
@@ -0,0 +1,4 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {public }
diff --git a/src/MapleFE/test/typescript/unit_tests/re-export.ts b/src/MapleFE/test/typescript/unit_tests/re-export.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dea206bb65b44a718d251b8587b08ac6019a319a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/re-export.ts
@@ -0,0 +1,4 @@
+export * from "./M";
+export { default as x } from "./M";
+import { default as x } from "./M";
+export { x as default };
diff --git a/src/MapleFE/test/typescript/unit_tests/re-export.ts.result b/src/MapleFE/test/typescript/unit_tests/re-export.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cd3ee09e619a0c75c2353490484d6898c513b07e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/re-export.ts.result
@@ -0,0 +1,13 @@
+Matched 5 tokens.
+Matched 14 tokens.
+Matched 23 tokens.
+Matched 30 tokens.
+============= Module ===========
+== Sub Tree ==
+export { *} "./M"
+== Sub Tree ==
+export {default as x} "./M"
+== Sub Tree ==
+import {default as x} "./M"
+== Sub Tree ==
+export {x as default} 
diff --git a/src/MapleFE/test/typescript/unit_tests/re-export2.ts b/src/MapleFE/test/typescript/unit_tests/re-export2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..387bd489e6ab49fbeb3d2832e7979469a1ac4d97
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/re-export2.ts
@@ -0,0 +1,5 @@
+export * from "./M";
+export { default as Y } from "./M";
+import { default as x } from "./M";
+export { x as default };
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/re-export2.ts.result b/src/MapleFE/test/typescript/unit_tests/re-export2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9794f6a145438cc1d64fab0250b29722b9e5f5e6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/re-export2.ts.result
@@ -0,0 +1,16 @@
+Matched 5 tokens.
+Matched 14 tokens.
+Matched 23 tokens.
+Matched 30 tokens.
+Matched 37 tokens.
+============= Module ===========
+== Sub Tree ==
+export { *} "./M"
+== Sub Tree ==
+export {default as Y} "./M"
+== Sub Tree ==
+import {default as x} "./M"
+== Sub Tree ==
+export {x as default} 
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/re-export4.ts b/src/MapleFE/test/typescript/unit_tests/re-export4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..63ca2a02303b91f291aa96355171cc1a13c5f580
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/re-export4.ts
@@ -0,0 +1,2 @@
+export * as MM from "./M";
+export { default as default } from "./M";
diff --git a/src/MapleFE/test/typescript/unit_tests/re-export4.ts.result b/src/MapleFE/test/typescript/unit_tests/re-export4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..877e3451ab06c83951e3d35059a90f57ecf1af12
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/re-export4.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+export { * as MM} "./M"
+== Sub Tree ==
+export {default as default} "./M"
diff --git a/src/MapleFE/test/typescript/unit_tests/readonly-return.ts b/src/MapleFE/test/typescript/unit_tests/readonly-return.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6fd9bb123332380f7d89f5814cc8610e446fa723
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/readonly-return.ts
@@ -0,0 +1,6 @@
+function foo(): readonly number[] {
+  var v: number = 1;
+  return [v, v];
+}
+
+console.log(foo());
diff --git a/src/MapleFE/test/typescript/unit_tests/readonly-return.ts.result b/src/MapleFE/test/typescript/unit_tests/readonly-return.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4c57aa2b0093bd379d0d19f9037a1f84bb80d844
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/readonly-return.ts.result
@@ -0,0 +1,10 @@
+Matched 25 tokens.
+Matched 34 tokens.
+============= Module ===========
+== Sub Tree ==
+func  foo()  throws: 
+  js_var Decl: v=1
+  return [v,v]
+
+== Sub Tree ==
+console.log(foo())
diff --git a/src/MapleFE/test/typescript/unit_tests/readonly-return2.ts b/src/MapleFE/test/typescript/unit_tests/readonly-return2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1754cffadfc19ee8679584edd24160437c0388cb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/readonly-return2.ts
@@ -0,0 +1,6 @@
+class Klass {}
+
+export interface Interface {
+  foo(): readonly Klass[];
+  bar(): void;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/readonly-return2.ts.result b/src/MapleFE/test/typescript/unit_tests/readonly-return2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..08c169df65f6fd8f75bbdb2858c91e49abaef68a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/readonly-return2.ts.result
@@ -0,0 +1,17 @@
+Matched 4 tokens.
+Matched 24 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+export {ts_interface: Interface {func  foo()  throws: 
+;func  bar()  throws: 
+ }} 
diff --git a/src/MapleFE/test/typescript/unit_tests/readonly.ts b/src/MapleFE/test/typescript/unit_tests/readonly.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c8744efac8f3502a85c0d856571dd7d7f7a2f69f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/readonly.ts
@@ -0,0 +1,3 @@
+export class Foo {
+  readonly foo_var: number = 1;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/readonly.ts.result b/src/MapleFE/test/typescript/unit_tests/readonly.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0be5e3d965213c608c710de39a5c8a81b6755575
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/readonly.ts.result
@@ -0,0 +1,12 @@
+Matched 12 tokens.
+============= Module ===========
+== Sub Tree ==
+export {class  Foo
+  Fields: 
+    foo_var=1
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/record-parameter.ts b/src/MapleFE/test/typescript/unit_tests/record-parameter.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b6a2d644b8ced589ebe37d1671d212326d94d7dc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/record-parameter.ts
@@ -0,0 +1,3 @@
+class Klass {
+  func(map: Record<string, ({ n, m }: { n: number, m: string }, s: string) => void>) {}
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/record-parameter.ts.result b/src/MapleFE/test/typescript/unit_tests/record-parameter.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e84b88f33294cce537889c15676d3940720a379d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/record-parameter.ts.result
@@ -0,0 +1,13 @@
+Matched 39 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func(map)  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/record.ts b/src/MapleFE/test/typescript/unit_tests/record.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9f71dde3de55dfe187008f0c2ffd36dbfeb3d2ab
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/record.ts
@@ -0,0 +1,12 @@
+enum Direction {
+  LEFT,
+  RIGHT,
+}
+
+const rec: Record<string, string> = {
+  [Direction.LEFT]: "left",
+  [Direction.RIGHT]: "right",
+  default: "Unknown",
+};
+
+console.log(rec);
diff --git a/src/MapleFE/test/typescript/unit_tests/record.ts.result b/src/MapleFE/test/typescript/unit_tests/record.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ac4d471a66850d660556cc5a15a014052cf182f9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/record.ts.result
@@ -0,0 +1,10 @@
+Matched 8 tokens.
+Matched 41 tokens.
+Matched 48 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: Direction {LEFT;RIGHT }
+== Sub Tree ==
+js_const Decl: rec= {[Direction.LEFT] : :"left", [Direction.RIGHT] : :"right", default:"Unknown"}
+== Sub Tree ==
+console.log(rec)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp-array.ts b/src/MapleFE/test/typescript/unit_tests/regexp-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9622797aa2089c79a9c0f5c7bc6923f588b3c7d9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp-array.ts
@@ -0,0 +1,7 @@
+const obj = {
+  arr: [
+    /[/\\]@cocos1/,
+    /[/\\]@cocos2/,
+  ],
+};
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp-array.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ef3e3385429d05a519a0a4c67c3cbb3508b85ad4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp-array.ts.result
@@ -0,0 +1,7 @@
+Matched 15 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {arr:[reg expr :  [/\\]@cocos1,reg expr :  [/\\]@cocos2]}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp-array2.ts b/src/MapleFE/test/typescript/unit_tests/regexp-array2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cd8922dc441a16dacdc86f2464f1274fdb4aee8c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp-array2.ts
@@ -0,0 +1,7 @@
+const obj = {
+  arr: [{
+    ex1: /[/\\]@cocos1/,
+    ex2: /[/\\]@cocos2/,
+  }],
+};
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp-array2.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp-array2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e1e3c3558685c6a71d9f4b9c5a3cdbc20b7f43a4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp-array2.ts.result
@@ -0,0 +1,7 @@
+Matched 21 tokens.
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {arr:[ {ex1:reg expr :  [/\\]@cocos1, ex2:reg expr :  [/\\]@cocos2}]}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp-array3.ts b/src/MapleFE/test/typescript/unit_tests/regexp-array3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8188aebbf0c52f880aefa5799c82e931ee5eabe1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp-array3.ts
@@ -0,0 +1,4 @@
+const obj = {
+  arr : [ /[/\\]@cocos1/, /[/\\]@cocos2/]
+};
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp-array3.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp-array3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a170be2cd1c56ef5ce70110dda04c63793c40d45
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp-array3.ts.result
@@ -0,0 +1,7 @@
+Matched 13 tokens.
+Matched 20 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {arr:[reg expr :  [/\\]@cocos1,reg expr :  [/\\]@cocos2]}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp-in-array.ts b/src/MapleFE/test/typescript/unit_tests/regexp-in-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ab5b96853e42e1dd45b7ba167f70a1e449245858
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp-in-array.ts
@@ -0,0 +1,3 @@
+var x: Array<[RegExp, string]> = [];
+x.push([/&lt;/g, "<"]);
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp-in-array.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp-in-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..643a8cebf99c240a6111a4d15a6bdb75b3a3a27e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp-in-array.ts.result
@@ -0,0 +1,10 @@
+Matched 15 tokens.
+Matched 26 tokens.
+Matched 33 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=[]
+== Sub Tree ==
+x.push([reg expr :  &lt;  g,"<"])
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp.ts b/src/MapleFE/test/typescript/unit_tests/regexp.ts
new file mode 100644
index 0000000000000000000000000000000000000000..78e2c0dfbb6ebdc2fa530060df5421717cbb2de1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp.ts
@@ -0,0 +1,4 @@
+var str: string = "abcba";
+console.log(str);
+str = str.replace(/b/g, "B");
+console.log(str);
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2562eb3a8b49eee841b3ba10fe403d999d336e51
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp.ts.result
@@ -0,0 +1,13 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 25 tokens.
+Matched 32 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: str="abcba"
+== Sub Tree ==
+console.log(str)
+== Sub Tree ==
+str Assign str.replace(reg expr :  b  g,"B")
+== Sub Tree ==
+console.log(str)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp2.ts b/src/MapleFE/test/typescript/unit_tests/regexp2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8145277a03845be1179d65075b731565db26802e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp2.ts
@@ -0,0 +1,4 @@
+function repl(s: string) {
+  return s.replace(/\s\S/g, ".");
+}
+console.log(repl("abc def gh"));
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp2.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..19c8b14acbddb03a6003b9e69cba5b5e77fecb72
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp2.ts.result
@@ -0,0 +1,9 @@
+Matched 19 tokens.
+Matched 29 tokens.
+============= Module ===========
+== Sub Tree ==
+func  repl(s)  throws: 
+  return s.replace(reg expr :  \s\S  g,".")
+
+== Sub Tree ==
+console.log(repl("abc def gh"))
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp3.ts b/src/MapleFE/test/typescript/unit_tests/regexp3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ec93450ba34f8c801a0c0f0d40eb165062148812
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp3.ts
@@ -0,0 +1,3 @@
+var s = "abc de fg";
+s = s.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+console.log(s);
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp3.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b6c6aa92deba4b1ca791a99c5f2115f262f11288
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp3.ts.result
@@ -0,0 +1,10 @@
+Matched 5 tokens.
+Matched 16 tokens.
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: s="abc de fg"
+== Sub Tree ==
+s Assign s.replace(reg expr :  [^A-Za-z0-9\+\/\=]  g,"")
+== Sub Tree ==
+console.log(s)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp4.ts b/src/MapleFE/test/typescript/unit_tests/regexp4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..50e475c0b422254e6077879251892e1854c0e755
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp4.ts
@@ -0,0 +1,5 @@
+var str: string = "abc/ab/1234abcdef";
+var re = /.*[/\\][0-9a-fA-F]{2}[/\\]([0-9a-fA-F-@]{8,}).*/;
+console.log(str);
+str = str.replace(re, "replaced");
+console.log(str);
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp4.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c3641c93a5c57867aff677abd58f16559fae3028
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp4.ts.result
@@ -0,0 +1,16 @@
+Matched 7 tokens.
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 30 tokens.
+Matched 37 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: str="abc/ab/1234abcdef"
+== Sub Tree ==
+js_var Decl: re=reg expr :  .*[/\\][0-9a-fA-F]{2}[/\\]([0-9a-fA-F-@]{8,}).*
+== Sub Tree ==
+console.log(str)
+== Sub Tree ==
+str Assign str.replace(re,"replaced")
+== Sub Tree ==
+console.log(str)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp5.ts b/src/MapleFE/test/typescript/unit_tests/regexp5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..feec44b29704eb4c28475e9a85d9ac025f49f5ac
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp5.ts
@@ -0,0 +1,2 @@
+var x = true && /\/t/.test("/test");
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp5.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4b499ad4e3a5f7d3eefd34c22db3148c1a5cc09e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp5.ts.result
@@ -0,0 +1,7 @@
+Matched 12 tokens.
+Matched 19 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=true Land reg expr :  \/t.test("/test")
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp6.ts b/src/MapleFE/test/typescript/unit_tests/regexp6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7c93d2254f766ac6cbe8074fe07642b976597b58
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp6.ts
@@ -0,0 +1,3 @@
+const str = "foo bar tee";
+let res: null | any[] = /Foo/.exec(str) || /bar/.exec(str);
+console.log(res);
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp6.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp6.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4c7a7ef2c6cf41c6d2c5b1d948d8f2923dee0af8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp6.ts.result
@@ -0,0 +1,10 @@
+Matched 5 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: str="foo bar tee"
+== Sub Tree ==
+js_let Decl: res=reg expr :  Foo.exec(str) Lor reg expr :  bar.exec(str)
+== Sub Tree ==
+console.log(res)
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp7.ts b/src/MapleFE/test/typescript/unit_tests/regexp7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c9af3f44c5cab284ff0bdc1a41c4dec8bb34d1c9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp7.ts
@@ -0,0 +1,2 @@
+export const re =
+  /["\u0000-\u001f]/g
diff --git a/src/MapleFE/test/typescript/unit_tests/regexp7.ts.result b/src/MapleFE/test/typescript/unit_tests/regexp7.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b272ca0aea8e35cf16f504ab4e4c193d4ba3b6c1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regexp7.ts.result
@@ -0,0 +1,4 @@
+Matched 5 tokens.
+============= Module ===========
+== Sub Tree ==
+export {js_const Decl: re=reg expr :  ["\u0000-\u001f]  g} 
diff --git a/src/MapleFE/test/typescript/unit_tests/regular-type.ts b/src/MapleFE/test/typescript/unit_tests/regular-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d78d711bd0597d5c8a52a922ed1f93954dd473f2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regular-type.ts
@@ -0,0 +1,3 @@
+class Klass {}
+type K = Klass;
+var a: K;
diff --git a/src/MapleFE/test/typescript/unit_tests/regular-type.ts.result b/src/MapleFE/test/typescript/unit_tests/regular-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..bcc4082835a4e0350e46b808105292def0d5fc17
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/regular-type.ts.result
@@ -0,0 +1,18 @@
+Matched 4 tokens.
+Matched 9 tokens.
+Matched 14 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+ type K = Klass
+== Sub Tree ==
+js_var Decl: a
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-in-array.ts b/src/MapleFE/test/typescript/unit_tests/rest-in-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0701d0a959d2cf15b64849d072608c91eeeb17d8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-in-array.ts
@@ -0,0 +1,6 @@
+const enum TypeID {
+  Array_Class = 0,
+  Array,
+}
+
+type TYPE = [string, string[], number, ...TypeID[]];
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-in-array.ts.result b/src/MapleFE/test/typescript/unit_tests/rest-in-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8f69208f6e74b4388dbea5b833a559233a2f6f88
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-in-array.ts.result
@@ -0,0 +1,7 @@
+Matched 11 tokens.
+Matched 29 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: TypeID {Array_Class=0;Array }
+== Sub Tree ==
+ type TYPE =  [  : string ,  : prim array-TBD ,  : number ,  : ...TypeID[] ,  ] 
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-in-array2.ts b/src/MapleFE/test/typescript/unit_tests/rest-in-array2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..403d8e2af74983e42cea05db5c19c81a392c73da
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-in-array2.ts
@@ -0,0 +1,4 @@
+module M {
+  let arr : Array<string> = ["a", "b"];
+  console.log([...arr, "c"]);
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-in-array2.ts.result b/src/MapleFE/test/typescript/unit_tests/rest-in-array2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f9a4286d2aee7e12ebae0f702b84d0a7b70302b7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-in-array2.ts.result
@@ -0,0 +1,9 @@
+Matched 30 tokens.
+============= Module ===========
+== Sub Tree ==
+============= Module ===========
+== Sub Tree ==
+js_let Decl: arr=["a","b"]
+== Sub Tree ==
+console.log([...arr,"c"])
+
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-object-literal.ts b/src/MapleFE/test/typescript/unit_tests/rest-object-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cd6a6ec0ccc71868e1aa2d647bf92d379d32dd91
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-object-literal.ts
@@ -0,0 +1,8 @@
+function func<T>(x: T): T {
+  return x;
+}
+var list = { f1: 0, f2: 1 };
+class Klass {
+  public static fd = func({ ...list });
+}
+console.log(Klass.fd);
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-object-literal.ts.result b/src/MapleFE/test/typescript/unit_tests/rest-object-literal.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b30f75590b39455c4352e517e3555ecd3abfb098
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-object-literal.ts.result
@@ -0,0 +1,23 @@
+Matched 17 tokens.
+Matched 30 tokens.
+Matched 46 tokens.
+Matched 55 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func<T>(x)  throws: 
+  return x
+
+== Sub Tree ==
+js_var Decl: list= {f1:0, f2:1}
+== Sub Tree ==
+class  Klass
+  Fields: 
+    fd=func( {:...list})
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+console.log(Klass.fd)
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-object-literal2.ts b/src/MapleFE/test/typescript/unit_tests/rest-object-literal2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..54f1135ba1b380cffadcb676d275254861bcaa70
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-object-literal2.ts
@@ -0,0 +1,6 @@
+class Klass {
+  list = { f1: 0, f2: 1 };
+}
+var obj: Klass = new Klass();
+var list2 = true ? { ...obj.list } : obj.list;
+console.log(list2);
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-object-literal2.ts.result b/src/MapleFE/test/typescript/unit_tests/rest-object-literal2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..eedd040f94d5af412ce4e590fea6e01f2fd7f553
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-object-literal2.ts.result
@@ -0,0 +1,21 @@
+Matched 16 tokens.
+Matched 26 tokens.
+Matched 42 tokens.
+Matched 49 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    list= {f1:0, f2:1}
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+js_var Decl: list2=true ?  {:obj.list} : obj.list
+== Sub Tree ==
+console.log(list2)
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-object-literal3.ts b/src/MapleFE/test/typescript/unit_tests/rest-object-literal3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b746a03c57b68d454631bd74026d885540c25664
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-object-literal3.ts
@@ -0,0 +1,6 @@
+class Klass {
+  arr = [{ list: { f1: 0, f2: 1 } }];
+}
+var obj: Klass = new Klass();
+var list2 = true ? { ...obj.arr[0] } : obj.arr[0].list;
+console.log(list2);
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-object-literal3.ts.result b/src/MapleFE/test/typescript/unit_tests/rest-object-literal3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..555f965426b909d0ac2d6d29a53d68b160095939
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-object-literal3.ts.result
@@ -0,0 +1,21 @@
+Matched 22 tokens.
+Matched 32 tokens.
+Matched 56 tokens.
+Matched 63 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    arr=[ {list: {f1:0, f2:1}}]
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+js_var Decl: list2=true ?  {:obj.arr[0]} : obj.arr[0].list
+== Sub Tree ==
+console.log(list2)
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-params.ts b/src/MapleFE/test/typescript/unit_tests/rest-params.ts
new file mode 100644
index 0000000000000000000000000000000000000000..977851d3b76b9ae7008600072cd4a7e90f7467d7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-params.ts
@@ -0,0 +1,5 @@
+function func(msg: string, ...params: any[]) {
+  console.log(msg, params);
+}
+
+func("Rest: ", 1, 2, 3, "abc", "def");
diff --git a/src/MapleFE/test/typescript/unit_tests/rest-params.ts.result b/src/MapleFE/test/typescript/unit_tests/rest-params.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..41eea9e79e3ce410c5b851e16d0140d2f81f1cc5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/rest-params.ts.result
@@ -0,0 +1,9 @@
+Matched 25 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(msg,...params)  throws: 
+  console.log(msg,params)
+
+== Sub Tree ==
+func("Rest: ",1,2,3,"abc","def")
diff --git a/src/MapleFE/test/typescript/unit_tests/return-as-any.ts b/src/MapleFE/test/typescript/unit_tests/return-as-any.ts
new file mode 100644
index 0000000000000000000000000000000000000000..758d806c20e513dd666b5280fe081bd76f7c22e8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/return-as-any.ts
@@ -0,0 +1,2 @@
+const func = () => 0 as any;
+console.log(func);
diff --git a/src/MapleFE/test/typescript/unit_tests/return-as-any.ts.result b/src/MapleFE/test/typescript/unit_tests/return-as-any.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4e68a8a2716740a6e91fd36a430e406a07884273
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/return-as-any.ts.result
@@ -0,0 +1,7 @@
+Matched 10 tokens.
+Matched 17 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: func=() -> 0
+== Sub Tree ==
+console.log(func)
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a418f65ca258ae23ba4ca0e9adf74d2621f4e640
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing.ts
@@ -0,0 +1,10 @@
+class Klass {}
+
+export interface Interf {
+  [key: string]: any;
+}
+
+export interface Interf2 {
+  func(component: Klass): Interf;
+  func2(component: Klass): Interf;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8b1f0dd44491b6d303a9c5243986f0117df2c3b3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing.ts.result
@@ -0,0 +1,20 @@
+Matched 4 tokens.
+Matched 17 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+export {ts_interface: Interf {string index type: any }} 
+== Sub Tree ==
+export {ts_interface: Interf2 {func  func(component)  throws: 
+;func  func2(component)  throws: 
+ }} 
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing10.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..88c2e5ad80a6eb91cbd1d00d4eeb60a6333a60e9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing10.ts
@@ -0,0 +1,11 @@
+function func(arr: Array<number>): number {
+  var len = arr.length;
+  var sum = 0;
+  while(len > 0) {
+    len--
+    sum += arr[len];
+  }
+  return sum;
+}
+
+console.log(func([1, 2, 3, 4]));
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing10.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing10.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..dca83fd7b5dc81f4341cce66d1d3f8332c48a468
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing10.ts.result
@@ -0,0 +1,15 @@
+Matched 46 tokens.
+Matched 64 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(arr)  throws: 
+  js_var Decl: len=arr.length
+  js_var Decl: sum=0
+  while len GT 0    len Dec
+
+    sum AddAssign arr[len]
+
+  return sum
+
+== Sub Tree ==
+console.log(func([1,2,3,4]))
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing11.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5d563b22096797e7a6d4aaf7714839dbbc2b700a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing11.ts
@@ -0,0 +1,3 @@
+export type Type =
+  | string
+  | number
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing11.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing11.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b3595f039db09b7776161fbc660c2ed0fc7ada81
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing11.ts.result
@@ -0,0 +1,4 @@
+Matched 8 tokens.
+============= Module ===========
+== Sub Tree ==
+export { type Type = union  = string | number} 
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing12.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..08a3a4bbe0c6f7723a75520983fe2d9dda70d20f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing12.ts
@@ -0,0 +1,2 @@
+console.log('Hello')
+console.log
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing12.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing12.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c499b0516d5c4150e7c79c227737c21af60edb8b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing12.ts.result
@@ -0,0 +1,7 @@
+Matched 6 tokens.
+Matched 9 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log("Hello")
+== Sub Tree ==
+console.log
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing13.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..31d304467719e802d76e2cde45fb395b1086a5be
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing13.ts
@@ -0,0 +1,2 @@
+console.log
+console.log(null)
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing13.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing13.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a2f1cd875bc566c3ab5a97f1cdefe2334ab24e3b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing13.ts.result
@@ -0,0 +1,7 @@
+Matched 3 tokens.
+Matched 9 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log
+== Sub Tree ==
+console.log(null)
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing14.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2311369e565c20dfa593325081aab7dc46b80c02
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing14.ts
@@ -0,0 +1,21 @@
+class Car {
+  private _make: string;
+  constructor(make: string) {
+    this._make = make;
+  }
+  public getMake(): string {
+    return this._make;
+  }
+}
+
+class Model extends Car {
+  private _model: string;
+  constructor(make: string, model: string) {super(make) this._model = super.getMake() + model;
+  }
+  public getModel(): string {
+    return this._model;
+  }
+}
+
+let passat: Model = new Model("VW", "Passat");
+console.log(passat.getMake(), passat.getModel());
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing14.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing14.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5368fc30da365058f5d1934d73ee3dfecd5b2e61
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing14.ts.result
@@ -0,0 +1,38 @@
+Matched 36 tokens.
+Matched 88 tokens.
+Matched 101 tokens.
+Matched 118 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Car
+  Fields: 
+    _make
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make)  throws: 
+      this._make Assign make
+  Methods: 
+    func  getMake()  throws: 
+      return this._make
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Model
+  Fields: 
+    _model
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make,model)  throws: 
+      super(make)
+      this._model Assign super.getMake() Add model
+  Methods: 
+    func  getModel()  throws: 
+      return this._model
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: passat=new Model("VW","Passat")
+== Sub Tree ==
+console.log(passat.getMake(),passat.getModel())
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing15.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a21a6ce8a1190aa1bc6a8f85e5d85179ee1dbbb8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing15.ts
@@ -0,0 +1,16 @@
+var n: number = 1;
+switch (true) {
+  case n < 5:
+    console.log(n, " is less than 5");
+  case n > 2 && n < 5:
+    console.log(n, " + 1 is equal to", n + 1);
+    break;
+  case n == 6:
+    console.log(n, " is equal to 6");
+    break;
+  case n < 8:
+    console.log(n, " is greater than 4 and less than 8");
+    break
+  default:
+    console.log(n, " is greater than 7");
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing15.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing15.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..78c460f980018fd17fd60b48153b7b3b98ca4a9e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing15.ts.result
@@ -0,0 +1,8 @@
+Matched 7 tokens.
+Matched 93 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: n=1
+== Sub Tree ==
+A switch
+
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing16.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3caad616a659fe6951afcd48192e7063c6a0f87c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing16.ts
@@ -0,0 +1,8 @@
+function func(arg: number): number | undefined {
+  if(arg < 1) return
+  for(let i = 0; i < arg; i++)
+     console.log(i);
+  return arg * 10;
+}
+console.log(func(3));
+
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing16.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing16.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5a85dd3971104c3fd5b7e648634c0a1e7b0ff316
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing16.ts.result
@@ -0,0 +1,15 @@
+Matched 46 tokens.
+Matched 56 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(arg)  throws: 
+  cond-branch cond:arg LT 1
+  true branch :
+    return   false branch :
+
+  for ( )
+    console.log(i)
+  return arg Mul 10
+
+== Sub Tree ==
+console.log(func(3))
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing17.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f5c4aff91fda35a3bfecf34ccd70dfe72cdf7624
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing17.ts
@@ -0,0 +1,9 @@
+function func(arg: number): number | undefined {
+  for(let i = 0; i < arg; i++) {
+    if(i % 2 > 0) continue
+     console.log(i);
+  }
+  return arg * 10;
+}
+console.log(func(5));
+
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing17.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing17.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6de52c4b72ce0abb85198d4eeeaf62bc051bb110
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing17.ts.result
@@ -0,0 +1,17 @@
+Matched 50 tokens.
+Matched 60 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(arg)  throws: 
+  for ( )
+    cond-branch cond:i Mod 2 GT 0
+    true branch :
+      continue:
+    false branch :
+
+    console.log(i)
+
+  return arg Mul 10
+
+== Sub Tree ==
+console.log(func(5))
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing2.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..99880ccb1eac73c69c9625ca9eb44b5f06691f42
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing2.ts
@@ -0,0 +1,5 @@
+export abstract class Klass {
+  public abstract f1(a: boolean): void;
+  public abstract f2(a: boolean): void;
+  public abstract f3(): void;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing2.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..13effeab0dfc010356ebd8f18422ff1e5105af5f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing2.ts.result
@@ -0,0 +1,15 @@
+Matched 36 tokens.
+============= Module ===========
+== Sub Tree ==
+export {class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  f1(a)  throws: 
+    func  f2(a)  throws: 
+    func  f3()  throws: 
+  LocalClasses: 
+  LocalInterfaces: 
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing3.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..426aba5e7a0bbd8a1f28fbbd5878ee92575821f6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing3.ts
@@ -0,0 +1,4 @@
+let func = function (n: number): number {
+  return n;
+};
+console.log(func(123));
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing3.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8aa220a9386b4d42d86b7d616c74e1f6cc36c38a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing3.ts.result
@@ -0,0 +1,9 @@
+Matched 17 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: func=func  (n)  throws: 
+  return n
+
+== Sub Tree ==
+console.log(func(123))
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing4.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e97a274786ba79926076cd2c814ef01bf381b09e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing4.ts
@@ -0,0 +1,11 @@
+class Klass {
+  func?: (n: number) => number;
+}
+var obj: Klass = new Klass();
+obj.func = function (n: number): number {
+  return n;
+};
+
+export function show() {
+  console.log(obj.func!(123));
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing4.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..75efc0950a5dab815e9838e99d620abbca3e49ff
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing4.ts.result
@@ -0,0 +1,25 @@
+Matched 15 tokens.
+Matched 25 tokens.
+Matched 43 tokens.
+Matched 63 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    func?
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj.func Assign func  (n)  throws: 
+  return n
+
+== Sub Tree ==
+export {func  show()  throws: 
+  console.log(obj.func!(123))
+} 
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing5.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c9172d85056a295a43e80f7849f69f8aa1d14f33
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing5.ts
@@ -0,0 +1,17 @@
+class Klass {
+  prop: string = "";
+  get getProp(): string {
+    return this.prop;
+  }
+  init(val: string) {
+    this.prop = val;
+  }
+  set setProp(newVal: string) {
+    this.init(newVal);
+  }
+}
+
+var obj: Klass = new Klass();
+console.log(obj.getProp);
+obj.setProp = "bar";
+console.log(obj.getProp);
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing5.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..89bf2f9ee60c3a0ce49bf43ff3d95a91d766069c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing5.ts.result
@@ -0,0 +1,30 @@
+Matched 53 tokens.
+Matched 63 tokens.
+Matched 72 tokens.
+Matched 78 tokens.
+Matched 87 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    prop=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    get getProp()  throws: 
+      return this.prop
+    func  init(val)  throws: 
+      this.prop Assign val
+    set setProp(newVal)  throws: 
+      this.init(newVal)
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(obj.getProp)
+== Sub Tree ==
+obj.setProp Assign "bar"
+== Sub Tree ==
+console.log(obj.getProp)
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing6.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..db3654a5e2d29f83342e24b2627cd03a8f074d5c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing6.ts
@@ -0,0 +1,4 @@
+export declare function func(s: string): string | null;
+export declare function func2(s: string): string | null;
+export declare const re1: RegExp;
+export declare const re2: RegExp;
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing6.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing6.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ae1342002187e83e5e53b08ce875ebd74acb167f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing6.ts.result
@@ -0,0 +1,15 @@
+Matched 14 tokens.
+Matched 28 tokens.
+Matched 35 tokens.
+Matched 42 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare func  func(s)  throws: 
+} 
+== Sub Tree ==
+export {declare func  func2(s)  throws: 
+} 
+== Sub Tree ==
+export {declare js_const Decl: re1} 
+== Sub Tree ==
+export {declare js_const Decl: re2} 
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing7.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2b33409dbeae625edc38d0e58fe5f6b53043c4fd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing7.ts
@@ -0,0 +1,4 @@
+declare namespace NS {
+  const num: number
+  interface IFace { }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing7.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing7.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..05a1750950448b03ed5e993826e4d5d394d35d05
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing7.ts.result
@@ -0,0 +1,7 @@
+Matched 13 tokens.
+============= Module ===========
+== Sub Tree ==
+declare namespace  NS
+  js_const Decl: num
+  ts_interface: IFace { }
+
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing8.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1dbb25e8f5d11d002e2f93fa50404e4e35b707bd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing8.ts
@@ -0,0 +1,8 @@
+function func(f: Function): void {
+  f();
+}
+
+func((e:any) => {
+  if (e) throw e
+  console.log('OK')
+})
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing8.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing8.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ddb68873c2ab84dac90529c3ad1053b9c0c53b00
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing8.ts.result
@@ -0,0 +1,15 @@
+Matched 15 tokens.
+Matched 38 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(f)  throws: 
+  f()
+
+== Sub Tree ==
+func((e) -> cond-branch cond:e
+true branch :
+  throw e
+false branch :
+
+console.log("OK")
+)
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing9.ts b/src/MapleFE/test/typescript/unit_tests/semicolon-missing9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0c3d27d2febe5cc14b4a7467a93fef56731a57ea
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing9.ts
@@ -0,0 +1,3 @@
+console.log("hello")
+console.log;
+console.log("world")
diff --git a/src/MapleFE/test/typescript/unit_tests/semicolon-missing9.ts.result b/src/MapleFE/test/typescript/unit_tests/semicolon-missing9.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7106ec4ab1e08bd860ff523ba58da85e5a904ca0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/semicolon-missing9.ts.result
@@ -0,0 +1,10 @@
+Matched 6 tokens.
+Matched 10 tokens.
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log("hello")
+== Sub Tree ==
+console.log
+== Sub Tree ==
+console.log("world")
diff --git a/src/MapleFE/test/typescript/unit_tests/shebang.ts b/src/MapleFE/test/typescript/unit_tests/shebang.ts
new file mode 100644
index 0000000000000000000000000000000000000000..114bffa6991b2997b4bb27fe419b528762dd4962
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/shebang.ts
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+console.log("Hello world!");
diff --git a/src/MapleFE/test/typescript/unit_tests/shebang.ts.result b/src/MapleFE/test/typescript/unit_tests/shebang.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ffe76bce9eb05088e26e69f3499b49ccd80654ba
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/shebang.ts.result
@@ -0,0 +1,4 @@
+Matched 7 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log("Hello world!")
diff --git a/src/MapleFE/test/typescript/unit_tests/some.ts b/src/MapleFE/test/typescript/unit_tests/some.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3990a95e2ca6e87beada2fc49f0e7fb76a1c5ec2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/some.ts
@@ -0,0 +1,3 @@
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some
+console.log([2, 5, 8, 1, 4].some((x) => x > 10)); // false
+console.log([12, 5, 8, 1, 4].some((x) => x > 10)); // true
diff --git a/src/MapleFE/test/typescript/unit_tests/some.ts.result b/src/MapleFE/test/typescript/unit_tests/some.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ea756cf94adbc08570cf333fc5a0c4e89c516530
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/some.ts.result
@@ -0,0 +1,7 @@
+Matched 28 tokens.
+Matched 56 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log([2,5,8,1,4].some((x) -> x GT 10))
+== Sub Tree ==
+console.log([12,5,8,1,4].some((x) -> x GT 10))
diff --git a/src/MapleFE/test/typescript/unit_tests/spread-param.d.ts b/src/MapleFE/test/typescript/unit_tests/spread-param.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0a2a6bedb2b34d62770a667684e4e1a3994bcfcf
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/spread-param.d.ts
@@ -0,0 +1,2 @@
+declare function func<T, U>( s1: T, s2: T | U, ...ss: Array< T | U | ((e: T | null) => void)>,): T;
+
diff --git a/src/MapleFE/test/typescript/unit_tests/spread-param.d.ts.result b/src/MapleFE/test/typescript/unit_tests/spread-param.d.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..78d64c1b433ff33b1c4dc7838ced36ace25c6f17
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/spread-param.d.ts.result
@@ -0,0 +1,5 @@
+Matched 45 tokens.
+============= Module ===========
+== Sub Tree ==
+declare func  func<T,U>(s1,s2,...ss)  throws: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/spread.ts b/src/MapleFE/test/typescript/unit_tests/spread.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6f62a3faf38feb28f2aec371f1ca7bb2de8ce8f9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/spread.ts
@@ -0,0 +1,9 @@
+const arr: number[] = [1, 2, 3];
+var arr2 = [ 0, ...arr ];
+console.log(arr2);
+
+function func() {
+ return { f1: 123, f2: "abc" };
+}
+var obj2 = { f0: "OK", ...func() };
+console.log(obj2);
diff --git a/src/MapleFE/test/typescript/unit_tests/spread.ts.result b/src/MapleFE/test/typescript/unit_tests/spread.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..99807845e80260e556cfbd48c0a0050d644ce2c6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/spread.ts.result
@@ -0,0 +1,21 @@
+Matched 15 tokens.
+Matched 25 tokens.
+Matched 32 tokens.
+Matched 49 tokens.
+Matched 63 tokens.
+Matched 70 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: arr=[1,2,3]
+== Sub Tree ==
+js_var Decl: arr2=[0,...arr]
+== Sub Tree ==
+console.log(arr2)
+== Sub Tree ==
+func  func()  throws: 
+  return  {f1:123, f2:"abc"}
+
+== Sub Tree ==
+js_var Decl: obj2= {f0:"OK", :func()}
+== Sub Tree ==
+console.log(obj2)
diff --git a/src/MapleFE/test/typescript/unit_tests/static-readonly.ts b/src/MapleFE/test/typescript/unit_tests/static-readonly.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eeaf2b3f5673f100122aa9a28e7f444cb68dc197
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/static-readonly.ts
@@ -0,0 +1,3 @@
+class Foo {
+  static readonly x: number = 0;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/static-readonly.ts.result b/src/MapleFE/test/typescript/unit_tests/static-readonly.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..42288272104e2894c17a108a743c00a5f83a4575
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/static-readonly.ts.result
@@ -0,0 +1,12 @@
+Matched 12 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    x=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/static.ts b/src/MapleFE/test/typescript/unit_tests/static.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fbfac9dfb4f115725ec0f167f42fe079936c6d80
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/static.ts
@@ -0,0 +1,9 @@
+class Foo {
+  static x: number = 1;
+  static inc(y: number) {
+    return this.x + y;
+  }
+}
+
+console.log(Foo.x);
+console.log(Foo.inc(10));
diff --git a/src/MapleFE/test/typescript/unit_tests/static.ts.result b/src/MapleFE/test/typescript/unit_tests/static.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3c0381cbd6314dae3720c496e1acdfd9699d1932
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/static.ts.result
@@ -0,0 +1,20 @@
+Matched 27 tokens.
+Matched 36 tokens.
+Matched 48 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    x=1
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  inc(y)  throws: 
+      return this.x Add y
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+console.log(Foo.x)
+== Sub Tree ==
+console.log(Foo.inc(10))
diff --git a/src/MapleFE/test/typescript/unit_tests/string-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/string-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a1ddbdd1e005b91a095748138ae2fa5c8315a478
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/string-as-prop-name.ts
@@ -0,0 +1,6 @@
+interface IFace {
+  "func-name"() : string;
+}
+
+var obj: IFace = { "func-name": () => "Function name" };
+console.log(obj);
diff --git a/src/MapleFE/test/typescript/unit_tests/string-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/string-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..47937f1f5d539a47af772c519227becc30709fa2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/string-as-prop-name.ts.result
@@ -0,0 +1,11 @@
+Matched 10 tokens.
+Matched 24 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {func  ()  throws: 
+ }
+== Sub Tree ==
+js_var Decl: obj= {"func-name":() -> "Function name"}
+== Sub Tree ==
+console.log(obj)
diff --git a/src/MapleFE/test/typescript/unit_tests/stringString.ts b/src/MapleFE/test/typescript/unit_tests/stringString.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8ce486a185eb399671b0cc6cd0ba72573886a0ba
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/stringString.ts
@@ -0,0 +1,6 @@
+class Student {
+  name: string = "";
+};
+class Parent {
+  name: String = "";
+};
diff --git a/src/MapleFE/test/typescript/unit_tests/stringString.ts.result b/src/MapleFE/test/typescript/unit_tests/stringString.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..19f19f0de5f7a28448d744781c09d982c18a117d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/stringString.ts.result
@@ -0,0 +1,25 @@
+Matched 10 tokens.
+Matched 11 tokens.
+Matched 21 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Student
+  Fields: 
+    name=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Parent
+  Fields: 
+    name=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/structural-typing.ts b/src/MapleFE/test/typescript/unit_tests/structural-typing.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c1c067e52b792e6d744f48a4e0bbda60c4c76f60
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/structural-typing.ts
@@ -0,0 +1,16 @@
+class Foo {
+  f1: number = 0;
+  f2: string = "";
+}
+
+class Bar {
+  f1: number = 0;
+  f2: string = "";
+}
+
+var x = { f1: 123, f2: "John" };
+var y: Foo;
+var z: Bar;
+y = x;
+z = y;
+console.log(y, z);
diff --git a/src/MapleFE/test/typescript/unit_tests/structural-typing.ts.result b/src/MapleFE/test/typescript/unit_tests/structural-typing.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6ba4006bdf6be05974e90d09b395a3bb1873624b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/structural-typing.ts.result
@@ -0,0 +1,41 @@
+Matched 16 tokens.
+Matched 32 tokens.
+Matched 45 tokens.
+Matched 50 tokens.
+Matched 55 tokens.
+Matched 59 tokens.
+Matched 63 tokens.
+Matched 72 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    f1=0    f2=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Bar
+  Fields: 
+    f1=0    f2=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: x= {f1:123, f2:"John"}
+== Sub Tree ==
+js_var Decl: y
+== Sub Tree ==
+js_var Decl: z
+== Sub Tree ==
+y Assign x
+== Sub Tree ==
+z Assign y
+== Sub Tree ==
+console.log(y,z)
diff --git a/src/MapleFE/test/typescript/unit_tests/switch-in-loop.ts b/src/MapleFE/test/typescript/unit_tests/switch-in-loop.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1d2fd8889ec1d233929e172c08f29003bd3a02b9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/switch-in-loop.ts
@@ -0,0 +1,19 @@
+for (var i: number = 1; i < 10; ++i) {
+  if (i < 5)
+    switch (i) {
+      case 2:
+        console.log(i, ", continue");
+        continue;
+      case 3:
+        console.log(i, ", fall-through");
+      case 4:
+        console.log(i, ", break");
+        break;
+      default:
+        console.log(i, ", default");
+    }
+  else {
+    console.log(i, ", else branch");
+    break;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/switch-in-loop.ts.result b/src/MapleFE/test/typescript/unit_tests/switch-in-loop.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2a2cbafd0e41b584a9c38e06861d9dd36b2ab782
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/switch-in-loop.ts.result
@@ -0,0 +1,13 @@
+Matched 95 tokens.
+============= Module ===========
+== Sub Tree ==
+for ( )
+  cond-branch cond:i LT 5
+  true branch :
+    A switch
+  false branch :
+    console.log(i,", else branch")
+    break:
+
+
+
diff --git a/src/MapleFE/test/typescript/unit_tests/switch-in-loop2.ts b/src/MapleFE/test/typescript/unit_tests/switch-in-loop2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a569c469f9e35d5954e75aa5769569bd78d7eb8d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/switch-in-loop2.ts
@@ -0,0 +1,18 @@
+class Klass {
+  [key: number]: string;
+}
+function func() {
+  var obj: Klass = {};
+  for (var i: number = 1; i < 4; ++i) {
+    switch (i) {
+      case 2:
+        break;
+      default:
+        obj[i] = "OK";
+        break;
+    }
+  }
+  return obj;
+}
+
+console.log(func());
diff --git a/src/MapleFE/test/typescript/unit_tests/switch-in-loop2.ts.result b/src/MapleFE/test/typescript/unit_tests/switch-in-loop2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3d3d8dcc03457c6e80a6696b1ff77224ee97f98e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/switch-in-loop2.ts.result
@@ -0,0 +1,25 @@
+Matched 12 tokens.
+Matched 69 tokens.
+Matched 78 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    string
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func()  throws: 
+  js_var Decl: obj= {}
+  for ( )
+    A switch
+
+
+  return obj
+
+== Sub Tree ==
+console.log(func())
diff --git a/src/MapleFE/test/typescript/unit_tests/switch-stmt-case.ts b/src/MapleFE/test/typescript/unit_tests/switch-stmt-case.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ad2a522153e283538fcb3105740c4c63975625b6
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/switch-stmt-case.ts
@@ -0,0 +1,8 @@
+let obj: number = 1;
+
+switch (typeof obj) {
+  case "number":
+  case "string":
+    console.log(obj);
+    break;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/switch-stmt-case.ts.result b/src/MapleFE/test/typescript/unit_tests/switch-stmt-case.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1595ff943185d42c79f846e64828056b090f69aa
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/switch-stmt-case.ts.result
@@ -0,0 +1,8 @@
+Matched 7 tokens.
+Matched 29 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: obj=1
+== Sub Tree ==
+A switch
+
diff --git a/src/MapleFE/test/typescript/unit_tests/switch-stmt.ts b/src/MapleFE/test/typescript/unit_tests/switch-stmt.ts
new file mode 100644
index 0000000000000000000000000000000000000000..51c42c254b34d4cfef490a40e1797b48d57bc89f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/switch-stmt.ts
@@ -0,0 +1,16 @@
+var n: number = 1;
+switch (true) {
+  case n < 5:
+    console.log(n, " is less than 5");
+  case n > 2 && n < 5:
+    console.log(n, " + 1 is equal to", n + 1);
+    break;
+  case n == 6:
+    console.log(n, " is equal to 6");
+    break;
+  case n < 8:
+    console.log(n, " is greater than 4 and less than 8");
+    break;
+  default:
+    console.log(n, " is greater than 7");
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/switch-stmt.ts.result b/src/MapleFE/test/typescript/unit_tests/switch-stmt.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7f4347709053422b86a49935942a0c76ddf5f791
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/switch-stmt.ts.result
@@ -0,0 +1,8 @@
+Matched 7 tokens.
+Matched 94 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: n=1
+== Sub Tree ==
+A switch
+
diff --git a/src/MapleFE/test/typescript/unit_tests/symbol-as-key.ts b/src/MapleFE/test/typescript/unit_tests/symbol-as-key.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dd746c034c05f67221086af6961b8e80be42e597
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/symbol-as-key.ts
@@ -0,0 +1,18 @@
+// tsc --target es2015
+const tag: unique symbol = Symbol("my symbol");
+interface IFace {
+  [tag]?: number;
+}
+
+class Klass implements IFace {
+  [tag]: number;
+  s: string = "example";
+}
+
+var obj: Klass = new Klass();
+obj[tag] = 123;
+console.log(obj);
+console.log(Symbol.keyFor(tag));
+
+const shared: symbol = Symbol.for("shared symbol");
+console.log(Symbol.keyFor(shared));
diff --git a/src/MapleFE/test/typescript/unit_tests/symbol-as-key.ts.result b/src/MapleFE/test/typescript/unit_tests/symbol-as-key.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ad51f89159c1cdc33f5af4558aed683808eccaf0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/symbol-as-key.ts.result
@@ -0,0 +1,36 @@
+Matched 11 tokens.
+Matched 22 tokens.
+Matched 40 tokens.
+Matched 50 tokens.
+Matched 57 tokens.
+Matched 64 tokens.
+Matched 76 tokens.
+Matched 88 tokens.
+Matched 100 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: tag=Symbol("my symbol")
+== Sub Tree ==
+ts_interface: IFace {[tag] : number }
+== Sub Tree ==
+class  Klass
+  Fields: 
+    [tag] : number    s="example"
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+obj[tag] Assign 123
+== Sub Tree ==
+console.log(obj)
+== Sub Tree ==
+console.log(Symbol.keyFor(tag))
+== Sub Tree ==
+js_const Decl: shared=Symbol.for("shared symbol")
+== Sub Tree ==
+console.log(Symbol.keyFor(shared))
diff --git a/src/MapleFE/test/typescript/unit_tests/tagged-template.ts b/src/MapleFE/test/typescript/unit_tests/tagged-template.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aa39ee7a152f3e7b23e67a207d2472ac603e490d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/tagged-template.ts
@@ -0,0 +1,12 @@
+// Tagged Template Literal
+function bar(a: TemplateStringsArray, b:number, c:string) {
+  return "bar: a=[" + a + "] b=[" + b + "] c=[" + c + "]";
+}
+function f() {
+  let x: number = 10;
+  let y: string = "abc";
+  return bar`PX
+  ${x}px${y}PX
+  `;
+}
+console.log(f());
diff --git a/src/MapleFE/test/typescript/unit_tests/tagged-template.ts.result b/src/MapleFE/test/typescript/unit_tests/tagged-template.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..9d34dab4a01b6db066facfbae2e991c7add09c19
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/tagged-template.ts.result
@@ -0,0 +1,18 @@
+Matched 32 tokens.
+Matched 56 tokens.
+Matched 65 tokens.
+Matched 66 tokens.
+Matched 67 tokens.
+============= Module ===========
+== Sub Tree ==
+func  bar(a,b,c)  throws: 
+  return "bar: a=[" Add a Add "] b=[" Add b Add "] c=[" Add c Add "]"
+
+== Sub Tree ==
+func  f()  throws: 
+  js_let Decl: x=10
+  js_let Decl: y="abc"
+  return bar()
+
+== Sub Tree ==
+console.log(f())
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literal-as-type.ts b/src/MapleFE/test/typescript/unit_tests/template-literal-as-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f8f2ece1da5366386c807255c8e160979b11fc42
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literal-as-type.ts
@@ -0,0 +1,4 @@
+const X = "X";
+const T: `${typeof X}type` = `${X}type`;
+console.log(typeof T);
+console.log(T);
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literal-as-type.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literal-as-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e209915dffe9b82f8a18836edc7377d1be4210b2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literal-as-type.ts.result
@@ -0,0 +1,15 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 20 tokens.
+Matched 27 tokens.
+Matched 29 tokens.
+Matched 30 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: X="X"
+== Sub Tree ==
+js_const Decl: T= template-literal: NULL,X,"type",NULL
+== Sub Tree ==
+console.log( typeof T)
+== Sub Tree ==
+console.log(T)
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literal-in.ts b/src/MapleFE/test/typescript/unit_tests/template-literal-in.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3cab93dc7dabf5318ed0458a6ab2b9d17bf64ca9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literal-in.ts
@@ -0,0 +1,3 @@
+type MyType<B extends Record<string|number, any>> = {
+  [K in`${Extract<keyof B, string|number>}`]: B[K]
+};
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literal-in.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literal-in.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..da3d29940e4fd9b84cddd9c1b867d564208ebdab
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literal-in.ts.result
@@ -0,0 +1,5 @@
+Matched 27 tokens.
+Matched 36 tokens.
+============= Module ===========
+== Sub Tree ==
+ type MyType<B> =  {[K in  template-literal: NULL,Extract< keyof B,union  = string | number>] : B[K] }
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literal-infer.ts b/src/MapleFE/test/typescript/unit_tests/template-literal-infer.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c94cf4771ce39a9e357cd30219973e68cda9a568
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literal-infer.ts
@@ -0,0 +1,11 @@
+// https://github.com/microsoft/TypeScript/pull/40336
+type Split<S extends string, D extends string> =
+    string extends S ? string[] :
+    S extends '' ? [] :
+    S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] :
+    [S];
+
+type T40 = Split<'foo', '.'>;          // ['foo']
+type T41 = Split<'foo.bar.baz', '.'>;  // ['foo', 'bar', 'baz']
+type T42 = Split<'foo.bar', ''>;       // ['f', 'o', 'o', '.', 'b', 'a', 'r']
+type T43 = Split<any, '.'>;            // string[]
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literal-infer.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literal-infer.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1798d6ece23d77e6e2dafcba54644f57b0e74d80
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literal-infer.ts.result
@@ -0,0 +1,19 @@
+Matched 47 tokens.
+Matched 57 tokens.
+Matched 67 tokens.
+Matched 77 tokens.
+Matched 87 tokens.
+Matched 89 tokens.
+Matched 90 tokens.
+Matched 92 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Split<S,D> = string extends S ? prim array-TBD : S extends "" ? prim array-TBD : S extends  template-literal: NULL, infer T,NULL,D,NULL, infer U ?  [  : T ,  : Split<U,D> ,  ]  :  [  : S ,  ] 
+== Sub Tree ==
+ type T40 = Split<"foo",".">
+== Sub Tree ==
+ type T41 = Split<"foo.bar.baz",".">
+== Sub Tree ==
+ type T42 = Split<"foo.bar","">
+== Sub Tree ==
+ type T43 = Split<any,".">
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literal-type.ts b/src/MapleFE/test/typescript/unit_tests/template-literal-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..073bae7598a49870fb29a75da43f6c479ed99402
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literal-type.ts
@@ -0,0 +1,12 @@
+class Num {
+  neg: boolean = false;
+  val: number = 0;
+}
+
+function func(v: Num): `${string}n` | `-${string}n` {
+  return `${v.neg ? '-' : ''}${v.val}n`;
+}
+
+var obj : Num = {neg: true, val: 123};
+console.log(func(obj));
+console.log(typeof func(obj));
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literal-type.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literal-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..70ca48c63fb79ef537785175df99a5d33a80e5f2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literal-type.ts.result
@@ -0,0 +1,30 @@
+Matched 16 tokens.
+Matched 32 tokens.
+Matched 47 tokens.
+Matched 57 tokens.
+Matched 68 tokens.
+Matched 69 tokens.
+Matched 70 tokens.
+Matched 77 tokens.
+Matched 80 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Num
+  Fields: 
+    neg=false    val=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func(v)  throws: 
+  return  template-literal: NULL,v.neg ? "-" : "",NULL,v.val,"n",NULL
+
+== Sub Tree ==
+js_var Decl: obj= {neg:true, val:123}
+== Sub Tree ==
+console.log(func(obj))
+== Sub Tree ==
+console.log( typeof func(obj))
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals.ts b/src/MapleFE/test/typescript/unit_tests/template-literals.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c8a9c9453dcb712fbf151594ac4d09940a7cb93d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals.ts
@@ -0,0 +1,7 @@
+// Template Literal
+let x = 10;
+let y: number = 20;
+let Left = `${x}px`;
+let Right: string = `${x}px`;
+let Top = `${y}px`;
+let Bottom: string = `${y}px`;
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..17888604cec117983ac361103ca68b3ebf8166d2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals.ts.result
@@ -0,0 +1,23 @@
+Matched 5 tokens.
+Matched 12 tokens.
+Matched 17 tokens.
+Matched 24 tokens.
+Matched 29 tokens.
+Matched 36 tokens.
+Matched 37 tokens.
+Matched 38 tokens.
+Matched 39 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: x=10
+== Sub Tree ==
+js_let Decl: y=20
+== Sub Tree ==
+js_let Decl: Left= template-literal: NULL,x,"px",NULL
+== Sub Tree ==
+js_let Decl: Right= template-literal: NULL,x,"px",NULL
+== Sub Tree ==
+js_let Decl: Top= template-literal: NULL,y,"px",NULL
+== Sub Tree ==
+js_let Decl: Bottom= template-literal: NULL,y,"px",NULL
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals10.ts b/src/MapleFE/test/typescript/unit_tests/template-literals10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..03f001540185e855c1b3f0357465a76ff312e734
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals10.ts
@@ -0,0 +1,6 @@
+var flag = false;
+var a = ".x";
+console.log(
+  `${`if(typeof ${flag ? "(prop)" : "prop"}!=="object"){` + "o"}${a}=prop;` +
+    `}`
+);
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals10.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals10.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..959e7eeac8353c83c9073b71840ba10f000c8d13
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals10.ts.result
@@ -0,0 +1,13 @@
+Matched 5 tokens.
+Matched 10 tokens.
+Matched 19 tokens.
+Matched 22 tokens.
+Matched 23 tokens.
+Matched 28 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: flag=false
+== Sub Tree ==
+js_var Decl: a=".x"
+== Sub Tree ==
+console.log( template-literal: NULL, template-literal: "if(typeof ",flag ? "(prop)" : "prop","!=="object"){",NULL Add "o",NULL,a,"=prop;",NULL Add  template-literal: "}",NULL)
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals11.ts b/src/MapleFE/test/typescript/unit_tests/template-literals11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..723fb535f8673d9c1cc854db4c6df38a90b24340
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals11.ts
@@ -0,0 +1,3 @@
+function func(name: string) {
+  return Function("target", `${"try {\n" + "  target."}${name}();\n` + `}`);
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals11.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals11.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ebe9d1b700acf828762510171e4a15bd80e330dd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals11.ts.result
@@ -0,0 +1,8 @@
+Matched 19 tokens.
+Matched 22 tokens.
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(name)  throws: 
+  return Function("target", template-literal: NULL,"try {\n" Add "  target.",NULL,name,"();\n",NULL Add  template-literal: "}",NULL)
+
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals2.ts b/src/MapleFE/test/typescript/unit_tests/template-literals2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7945e9ce5bf481797cb1073d68e205309ceb47dd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals2.ts
@@ -0,0 +1,5 @@
+// Template Literal
+function func(msg: string): string {
+  return "MSG: " + msg;
+}
+console.log(`Status: ${func("OK")}`);
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals2.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5ba2dd8e30834f775d51197b5461a189c6a0b26d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals2.ts.result
@@ -0,0 +1,10 @@
+Matched 16 tokens.
+Matched 23 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(msg)  throws: 
+  return "MSG: " Add msg
+
+== Sub Tree ==
+console.log( template-literal: "Status: ",func("OK"))
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals3.ts b/src/MapleFE/test/typescript/unit_tests/template-literals3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aee708bb7fbf93c373981d704ba01a2d52e3d35d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals3.ts
@@ -0,0 +1,2 @@
+var x: number = 20;
+let Left = `${x}px`;
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals3.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..4359ca868c85380f840515525338bbceede24871
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals3.ts.result
@@ -0,0 +1,8 @@
+Matched 7 tokens.
+Matched 12 tokens.
+Matched 13 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=20
+== Sub Tree ==
+js_let Decl: Left= template-literal: NULL,x,"px",NULL
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals4.ts b/src/MapleFE/test/typescript/unit_tests/template-literals4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a04949c7aec8aa1dd36e0700bac24970a469138d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals4.ts
@@ -0,0 +1,6 @@
+var x: number = 2;
+var y: number = 4;
+var z: number = 6;
+
+let px = `${x + y}px and ${z ? x + z : y + z}px`;
+console.log(px);
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals4.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b90002372ff4582ca9ac1f4293e5daa176bb8401
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals4.ts.result
@@ -0,0 +1,18 @@
+Matched 7 tokens.
+Matched 14 tokens.
+Matched 21 tokens.
+Matched 26 tokens.
+Matched 33 tokens.
+Matched 36 tokens.
+Matched 45 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=2
+== Sub Tree ==
+js_var Decl: y=4
+== Sub Tree ==
+js_var Decl: z=6
+== Sub Tree ==
+js_let Decl: px= template-literal: NULL,x Add y,"px and ",z ? x Add z : y Add z,"px",NULL
+== Sub Tree ==
+console.log(px)
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals5.ts b/src/MapleFE/test/typescript/unit_tests/template-literals5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d04070aa091d9388f8d3625a35a328117a60179e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals5.ts
@@ -0,0 +1,3 @@
+var x: number = 20;
+let Left = `${x}px`;
+console.log(Left);
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals5.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6ef3205e3dffededef95c6b69605836fc7c6f62e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals5.ts.result
@@ -0,0 +1,11 @@
+Matched 7 tokens.
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 20 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=20
+== Sub Tree ==
+js_let Decl: Left= template-literal: NULL,x,"px",NULL
+== Sub Tree ==
+console.log(Left)
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals6.ts b/src/MapleFE/test/typescript/unit_tests/template-literals6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bd273860a3cfdf95fdb5b3510b11f24db1d267dc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals6.ts
@@ -0,0 +1,2 @@
+console.log(`string text line 1
+string text line 2`);
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals6.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals6.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..217df2d2d9560b9142ef8187de7b7cb1bb76298c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals6.ts.result
@@ -0,0 +1,5 @@
+Matched 7 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log( template-literal: "string text line 1
+string text line 2",NULL)
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals7.ts b/src/MapleFE/test/typescript/unit_tests/template-literals7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..68d7abbd0909d3eac4fa71894b14184edb24740a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals7.ts
@@ -0,0 +1,3 @@
+var arr: number[] = [1, 2, 3];
+var s: string = `${arr[0] + 1}/${arr[1] + 1}/${arr[2] + 1}`;
+console.log(s);
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals7.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals7.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b4e72dc0a251032ac79f6856d19450f84da53a25
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals7.ts.result
@@ -0,0 +1,13 @@
+Matched 15 tokens.
+Matched 22 tokens.
+Matched 29 tokens.
+Matched 35 tokens.
+Matched 41 tokens.
+Matched 47 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[1,2,3]
+== Sub Tree ==
+js_var Decl: s= template-literal: NULL,arr[0] Add 1,"/",arr[1] Add 1,"/",arr[2] Add 1
+== Sub Tree ==
+console.log(s)
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals8.ts b/src/MapleFE/test/typescript/unit_tests/template-literals8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e5dbf4db9cf53febe8cba505acdecf59f4459d32
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals8.ts
@@ -0,0 +1,5 @@
+function func() {
+  return `${{}}`;
+}
+
+console.log(func());
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals8.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals8.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6f3e6604c048c3440cee9f6354000a535a841b02
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals8.ts.result
@@ -0,0 +1,10 @@
+Matched 9 tokens.
+Matched 18 tokens.
+Matched 20 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+  return  template-literal: NULL, {}
+
+== Sub Tree ==
+console.log(func())
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals9.ts b/src/MapleFE/test/typescript/unit_tests/template-literals9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..723fb535f8673d9c1cc854db4c6df38a90b24340
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals9.ts
@@ -0,0 +1,3 @@
+function func(name: string) {
+  return Function("target", `${"try {\n" + "  target."}${name}();\n` + `}`);
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/template-literals9.ts.result b/src/MapleFE/test/typescript/unit_tests/template-literals9.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ebe9d1b700acf828762510171e4a15bd80e330dd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/template-literals9.ts.result
@@ -0,0 +1,8 @@
+Matched 19 tokens.
+Matched 22 tokens.
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(name)  throws: 
+  return Function("target", template-literal: NULL,"try {\n" Add "  target.",NULL,name,"();\n",NULL Add  template-literal: "}",NULL)
+
diff --git a/src/MapleFE/test/typescript/unit_tests/ternary-op-1.ts b/src/MapleFE/test/typescript/unit_tests/ternary-op-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c8c730a03b379f30c2a94db988402c5af2634c62
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ternary-op-1.ts
@@ -0,0 +1,8 @@
+function func(x: number): number {
+  return (x > 10 ? x : x * x) ? x * 2 : x * 3;
+}
+
+let r = func(12);
+console.log(r);
+r = func(3);
+console.log(r);
diff --git a/src/MapleFE/test/typescript/unit_tests/ternary-op-1.ts.result b/src/MapleFE/test/typescript/unit_tests/ternary-op-1.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7890ae20aab32b63d32e01246dcacad6c25ce37d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ternary-op-1.ts.result
@@ -0,0 +1,18 @@
+Matched 32 tokens.
+Matched 40 tokens.
+Matched 47 tokens.
+Matched 54 tokens.
+Matched 61 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(x)  throws: 
+  return x GT 10 ? x : x Mul x ? x Mul 2 : x Mul 3
+
+== Sub Tree ==
+js_let Decl: r=func(12)
+== Sub Tree ==
+console.log(r)
+== Sub Tree ==
+r Assign func(3)
+== Sub Tree ==
+console.log(r)
diff --git a/src/MapleFE/test/typescript/unit_tests/ternary-op.ts b/src/MapleFE/test/typescript/unit_tests/ternary-op.ts
new file mode 100644
index 0000000000000000000000000000000000000000..96a416388641155447c5ac7cce9cc819540216aa
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ternary-op.ts
@@ -0,0 +1,8 @@
+function func(x: number): number {
+  return x > 10 ? x : x * x;
+}
+
+let r = func(12);
+console.log(r);
+r = func(3);
+console.log(r);
diff --git a/src/MapleFE/test/typescript/unit_tests/ternary-op.ts.result b/src/MapleFE/test/typescript/unit_tests/ternary-op.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2c97387863fe9be8681cf371febd97e63997442e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ternary-op.ts.result
@@ -0,0 +1,18 @@
+Matched 22 tokens.
+Matched 30 tokens.
+Matched 37 tokens.
+Matched 44 tokens.
+Matched 51 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(x)  throws: 
+  return x GT 10 ? x : x Mul x
+
+== Sub Tree ==
+js_let Decl: r=func(12)
+== Sub Tree ==
+console.log(r)
+== Sub Tree ==
+r Assign func(3)
+== Sub Tree ==
+console.log(r)
diff --git a/src/MapleFE/test/typescript/unit_tests/this-as-any.ts b/src/MapleFE/test/typescript/unit_tests/this-as-any.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5eb26e6910a2dba57f7f0a2847cae53661171d29
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/this-as-any.ts
@@ -0,0 +1,23 @@
+class Car {
+  private _make: string;
+  constructor(make: string) {
+    this._make = make;
+  }
+  public getMake(): string {
+    return this._make;
+  }
+}
+
+class Model extends Car {
+  private _model?: string;
+  constructor(make: string, model: string) {
+    super(make);
+    (this as any)._model = model;
+  }
+  public getModel(): string {
+    return this._model!;
+  }
+}
+
+let passat: Model = new Model("VW", "Passat");
+console.log(passat.getMake(), passat.getModel());
diff --git a/src/MapleFE/test/typescript/unit_tests/this-as-any.ts.result b/src/MapleFE/test/typescript/unit_tests/this-as-any.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..948cd8e6b5e2334da5cf0f8bf4b014c2e07cd41d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/this-as-any.ts.result
@@ -0,0 +1,38 @@
+Matched 36 tokens.
+Matched 89 tokens.
+Matched 102 tokens.
+Matched 119 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Car
+  Fields: 
+    _make
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make)  throws: 
+      this._make Assign make
+  Methods: 
+    func  getMake()  throws: 
+      return this._make
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Model
+  Fields: 
+    _model?
+  Instance Initializer: 
+  Constructors: 
+    constructor  (make,model)  throws: 
+      super(make)
+      this._model Assign model
+  Methods: 
+    func  getModel()  throws: 
+      return this._model!
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: passat=new Model("VW","Passat")
+== Sub Tree ==
+console.log(passat.getMake(),passat.getModel())
diff --git a/src/MapleFE/test/typescript/unit_tests/this-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/this-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8e35935ccc41c875c6d85539a7476d87692ea293
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/this-as-prop-name.ts
@@ -0,0 +1,7 @@
+interface IFace {
+  this: Object;
+};
+
+var obj: IFace = { this: {name: "Name"} };
+console.log(obj);
+console.log(obj["this"]);
diff --git a/src/MapleFE/test/typescript/unit_tests/this-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/this-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cf25f818b82006fb4e16b6dc769cedd2d8c78590
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/this-as-prop-name.ts.result
@@ -0,0 +1,14 @@
+Matched 8 tokens.
+Matched 9 tokens.
+Matched 24 tokens.
+Matched 31 tokens.
+Matched 41 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {this }
+== Sub Tree ==
+js_var Decl: obj= {this: {name:"Name"}}
+== Sub Tree ==
+console.log(obj)
+== Sub Tree ==
+console.log(obj["this"])
diff --git a/src/MapleFE/test/typescript/unit_tests/this-parameter.ts b/src/MapleFE/test/typescript/unit_tests/this-parameter.ts
new file mode 100644
index 0000000000000000000000000000000000000000..909c2a101c0ce74fd7e57827a893d14b6f7f658b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/this-parameter.ts
@@ -0,0 +1,26 @@
+class Klass {
+  [key: string]: Function | number;
+}
+
+var func = (obj: Klass) => {
+  const desc = Object.getOwnPropertyDescriptor(obj, "f");
+  console.log(desc);
+  if (typeof desc!.value === "function") {
+    const v = desc!.value;
+    obj["f"] = function (this) {
+      console.log("Calling the new function");
+      return v.call(this, ...arguments);
+    };
+  }
+};
+
+var o = {
+  n: 123,
+  f: function () {
+    console.log("Calling f()");
+    return this;
+  },
+};
+
+func(o);
+console.log(o.f());
diff --git a/src/MapleFE/test/typescript/unit_tests/this-parameter.ts.result b/src/MapleFE/test/typescript/unit_tests/this-parameter.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..397e70c685d2143e702fd7d88f347e71ef5909c5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/this-parameter.ts.result
@@ -0,0 +1,38 @@
+Matched 14 tokens.
+Matched 95 tokens.
+Matched 123 tokens.
+Matched 128 tokens.
+Matched 139 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    union  = Function | number
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: func=(obj) -> js_const Decl: desc=Object.getOwnPropertyDescriptor(obj,"f")
+console.log(desc)
+cond-branch cond: typeof desc!.value StEq "function"
+true branch :
+  js_const Decl: v=desc!.value
+  obj["f"] Assign func  (this)  throws: 
+  console.log("Calling the new function")
+  return v.call(this,...arguments)
+
+false branch :
+
+
+== Sub Tree ==
+js_var Decl: o= {n:123, f:func  ()  throws: 
+  console.log("Calling f()")
+  return this
+}
+== Sub Tree ==
+func(o)
+== Sub Tree ==
+console.log(o.f())
diff --git a/src/MapleFE/test/typescript/unit_tests/three-dim-array.ts b/src/MapleFE/test/typescript/unit_tests/three-dim-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ef80ea4042f85508a7f9b4a9d42848bf60caa227
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/three-dim-array.ts
@@ -0,0 +1,6 @@
+class Klass {
+  n: number[][][] = [[[3]]];
+}
+
+var c = new Klass();
+console.log(c);
diff --git a/src/MapleFE/test/typescript/unit_tests/three-dim-array.ts.result b/src/MapleFE/test/typescript/unit_tests/three-dim-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..2091e6f5a3cdd08dd9b15e1b7018b250c0cae068
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/three-dim-array.ts.result
@@ -0,0 +1,18 @@
+Matched 22 tokens.
+Matched 30 tokens.
+Matched 37 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    n=[[[3]]]
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: c=new Klass()
+== Sub Tree ==
+console.log(c)
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_call.ts b/src/MapleFE/test/typescript/unit_tests/ti_call.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c4f2d88d11bbae6e7bbcea747deae6495996f5ac
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_call.ts
@@ -0,0 +1,5 @@
+function bar(value: number): number {
+  return value;
+}
+
+bar(13);
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_call.ts.result b/src/MapleFE/test/typescript/unit_tests/ti_call.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7c335d8840e91417f3ba2277d8b755c650768431
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_call.ts.result
@@ -0,0 +1,9 @@
+Matched 14 tokens.
+Matched 19 tokens.
+============= Module ===========
+== Sub Tree ==
+func  bar(value)  throws: 
+  return value
+
+== Sub Tree ==
+bar(13)
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_call2.ts b/src/MapleFE/test/typescript/unit_tests/ti_call2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..61245bfe40820426ebbf6e88e1be5d27b62123f2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_call2.ts
@@ -0,0 +1,6 @@
+function bar(value: number): number {
+  return value;
+}
+
+bar(13);
+bar(13.9);
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_call2.ts.result b/src/MapleFE/test/typescript/unit_tests/ti_call2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e07fd001e55edc36c077d8cdb6082de6a70e0040
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_call2.ts.result
@@ -0,0 +1,12 @@
+Matched 14 tokens.
+Matched 19 tokens.
+Matched 24 tokens.
+============= Module ===========
+== Sub Tree ==
+func  bar(value)  throws: 
+  return value
+
+== Sub Tree ==
+bar(13)
+== Sub Tree ==
+bar(13.9)
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_call_array.ts b/src/MapleFE/test/typescript/unit_tests/ti_call_array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..099c7511c64003dd5cae9c4db22ff849da00fc7a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_call_array.ts
@@ -0,0 +1,6 @@
+function foo(array: number[], value: number): number {
+  return 0;
+}
+
+var arr: number[] = [13, 21];
+foo(arr, 13);
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_call_array.ts.result b/src/MapleFE/test/typescript/unit_tests/ti_call_array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3d9b30e817b14a4dd300e064b91cc5b543403e76
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_call_array.ts.result
@@ -0,0 +1,12 @@
+Matched 20 tokens.
+Matched 33 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+func  foo(array,value)  throws: 
+  return 0
+
+== Sub Tree ==
+js_var Decl: arr=[13,21]
+== Sub Tree ==
+foo(arr,13)
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_call_array2.ts b/src/MapleFE/test/typescript/unit_tests/ti_call_array2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7be49ffe3f4975c94b9d08253a84b337e6fb8c20
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_call_array2.ts
@@ -0,0 +1,8 @@
+function foo(array: number[], value: number): number {
+  return 0;
+}
+
+var arr: number[] = [13, 21];
+foo(arr, 13);
+var arrf: number[] = [13.5, 21.5];
+foo(arrf, 13.5);
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_call_array2.ts.result b/src/MapleFE/test/typescript/unit_tests/ti_call_array2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..21a6c20b1bd8626041366302837a0538123acfcc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_call_array2.ts.result
@@ -0,0 +1,18 @@
+Matched 20 tokens.
+Matched 33 tokens.
+Matched 40 tokens.
+Matched 53 tokens.
+Matched 60 tokens.
+============= Module ===========
+== Sub Tree ==
+func  foo(array,value)  throws: 
+  return 0
+
+== Sub Tree ==
+js_var Decl: arr=[13,21]
+== Sub Tree ==
+foo(arr,13)
+== Sub Tree ==
+js_var Decl: arrf=[13.5,21.5]
+== Sub Tree ==
+foo(arrf,13.5)
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_export_func.ts b/src/MapleFE/test/typescript/unit_tests/ti_export_func.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c5de99ce61e765984fc2646a2c084eb56f3cabb1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_export_func.ts
@@ -0,0 +1,5 @@
+export function bar(value: number): number {
+  return value;
+}
+
+bar(13);
diff --git a/src/MapleFE/test/typescript/unit_tests/ti_export_func.ts.result b/src/MapleFE/test/typescript/unit_tests/ti_export_func.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8cad8e66135ff3ac57ead29d7e64239c9e3d9603
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ti_export_func.ts.result
@@ -0,0 +1,9 @@
+Matched 15 tokens.
+Matched 20 tokens.
+============= Module ===========
+== Sub Tree ==
+export {func  bar(value)  throws: 
+  return value
+} 
+== Sub Tree ==
+bar(13)
diff --git a/src/MapleFE/test/typescript/unit_tests/trailing-commas.ts b/src/MapleFE/test/typescript/unit_tests/trailing-commas.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aea4967b6dbb44b774e9d60d13cfe4fc47f6af46
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/trailing-commas.ts
@@ -0,0 +1,15 @@
+export { a, o, func, u as U, v as V };
+
+var a: number[] = [1, 2, 3];
+console.log(a.length);
+
+var o: Object = { x: 1, y: "abc" };
+console.log(o);
+
+function func(n: number): number {
+  return n * n;
+}
+console.log(func(10));
+
+var [u, v] = a;
+console.log(u, v);
diff --git a/src/MapleFE/test/typescript/unit_tests/trailing-commas.ts.result b/src/MapleFE/test/typescript/unit_tests/trailing-commas.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..019848c0dd0af7b13854c195a814aa40e67ba0b0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/trailing-commas.ts.result
@@ -0,0 +1,30 @@
+Matched 17 tokens.
+Matched 32 tokens.
+Matched 41 tokens.
+Matched 56 tokens.
+Matched 63 tokens.
+Matched 79 tokens.
+Matched 89 tokens.
+Matched 98 tokens.
+Matched 107 tokens.
+============= Module ===========
+== Sub Tree ==
+export {a,o,func,u as U,v as V} 
+== Sub Tree ==
+js_var Decl: a=[1,2,3]
+== Sub Tree ==
+console.log(a.length)
+== Sub Tree ==
+js_var Decl: o= {x:1, y:"abc"}
+== Sub Tree ==
+console.log(o)
+== Sub Tree ==
+func  func(n)  throws: 
+  return n Mul n
+
+== Sub Tree ==
+console.log(func(10))
+== Sub Tree ==
+js_var Decl: {:u, :v}
+== Sub Tree ==
+console.log(u,v)
diff --git a/src/MapleFE/test/typescript/unit_tests/trailing-commas2.ts b/src/MapleFE/test/typescript/unit_tests/trailing-commas2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6003c285d2efcf74774e250b16a847c43f8a44e3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/trailing-commas2.ts
@@ -0,0 +1,9 @@
+class Klass<T> {
+  n: T | undefined = undefined;
+}
+
+function func(x = 0.5, y: Klass<number> = { n: 3 }): number {
+  return x + y.n!;
+}
+
+console.log(func());
diff --git a/src/MapleFE/test/typescript/unit_tests/trailing-commas2.ts.result b/src/MapleFE/test/typescript/unit_tests/trailing-commas2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..905afb4210f3344d535611006e77fc03ebd62cd7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/trailing-commas2.ts.result
@@ -0,0 +1,20 @@
+Matched 15 tokens.
+Matched 47 tokens.
+Matched 56 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+<T,>  Fields: 
+    n=undefined
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func(x=0.5,y= {n:3})  throws: 
+  return x Add y.n!
+
+== Sub Tree ==
+console.log(func())
diff --git a/src/MapleFE/test/typescript/unit_tests/trailing-commas3.ts b/src/MapleFE/test/typescript/unit_tests/trailing-commas3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b84579b57c617df71bc019a5a80481b049da4a63
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/trailing-commas3.ts
@@ -0,0 +1,7 @@
+class Klass {}
+function func(m?: Klass | number) {
+  return m;
+}
+
+var obj: Klass = new Klass();
+console.log(func(obj));
diff --git a/src/MapleFE/test/typescript/unit_tests/trailing-commas3.ts.result b/src/MapleFE/test/typescript/unit_tests/trailing-commas3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..78af9b55080e024e39e4490864f098e0c3f8efd9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/trailing-commas3.ts.result
@@ -0,0 +1,23 @@
+Matched 4 tokens.
+Matched 19 tokens.
+Matched 29 tokens.
+Matched 39 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func(m?)  throws: 
+  return m
+
+== Sub Tree ==
+js_var Decl: obj=new Klass()
+== Sub Tree ==
+console.log(func(obj))
diff --git a/src/MapleFE/test/typescript/unit_tests/trailing-commas4.ts b/src/MapleFE/test/typescript/unit_tests/trailing-commas4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf7481284cabbd766f05027ed46f64236855227b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/trailing-commas4.ts
@@ -0,0 +1,7 @@
+var obj = {
+  x: false,
+};
+var obj2 = {
+  x: false,
+};
+console.log(obj, obj2);
diff --git a/src/MapleFE/test/typescript/unit_tests/trailing-commas4.ts.result b/src/MapleFE/test/typescript/unit_tests/trailing-commas4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0c861a083e6c5d23c4eb4c1961677354017873bb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/trailing-commas4.ts.result
@@ -0,0 +1,10 @@
+Matched 10 tokens.
+Matched 20 tokens.
+Matched 29 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: obj= {x:false}
+== Sub Tree ==
+js_var Decl: obj2= {x:false}
+== Sub Tree ==
+console.log(obj,obj2)
diff --git a/src/MapleFE/test/typescript/unit_tests/triple-slash-comment.ts b/src/MapleFE/test/typescript/unit_tests/triple-slash-comment.ts
new file mode 100644
index 0000000000000000000000000000000000000000..29e5a31ca3b3a3ba94f49fbc89206d3bd06ec68c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/triple-slash-comment.ts
@@ -0,0 +1,10 @@
+enum ET {
+  TOP = "top", /// < top string
+  BOTTOM = "bottom", ///< bottom string
+}
+
+/// <param name="pn"></param>
+/// <returns></returns>
+
+let et = ET.TOP;
+console.log(et);
diff --git a/src/MapleFE/test/typescript/unit_tests/triple-slash-comment.ts.result b/src/MapleFE/test/typescript/unit_tests/triple-slash-comment.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e4afff30c02415e10dfeab2420a63675b1286d5d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/triple-slash-comment.ts.result
@@ -0,0 +1,10 @@
+Matched 12 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_enum: ET {TOP="top";BOTTOM="bottom" }
+== Sub Tree ==
+js_let Decl: et=ET.TOP
+== Sub Tree ==
+console.log(et)
diff --git a/src/MapleFE/test/typescript/unit_tests/triple-slash-dir.d.ts b/src/MapleFE/test/typescript/unit_tests/triple-slash-dir.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c083b3bd4df8491a83d938882dca65783f30fa18
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/triple-slash-dir.d.ts
@@ -0,0 +1,2 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="es5" />
diff --git a/src/MapleFE/test/typescript/unit_tests/triple-slash-dir.d.ts.result b/src/MapleFE/test/typescript/unit_tests/triple-slash-dir.d.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0e74c743cd4c0c3b70270bc58d388ad13603002f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/triple-slash-dir.d.ts.result
@@ -0,0 +1,7 @@
+Matched 8 tokens.
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+trip-slash reference no-default-lib = "true"
+== Sub Tree ==
+trip-slash reference lib = "es5"
diff --git a/src/MapleFE/test/typescript/unit_tests/try-catch.ts b/src/MapleFE/test/typescript/unit_tests/try-catch.ts
new file mode 100644
index 0000000000000000000000000000000000000000..25c2b3928a413450936c5b1e2ee40933c7d0a07f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/try-catch.ts
@@ -0,0 +1,10 @@
+for (var i = 3; i >= 0; --i) {
+  try {
+    if (i == 0) throw new Error("Zero");
+    console.log("try", 3 / i);
+  } catch (err) {
+    console.log("catch", err);
+  } finally {
+    console.log("finally", i);
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/try-catch.ts.result b/src/MapleFE/test/typescript/unit_tests/try-catch.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..619a4107820fac62047cc6d3f43f2881d4552701
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/try-catch.ts.result
@@ -0,0 +1,14 @@
+Matched 70 tokens.
+============= Module ===========
+== Sub Tree ==
+for ( )
+  try     cond-branch cond:i EQ 0
+    true branch :
+      throw new Error("Zero")
+    false branch :
+
+    console.log("try",3 Div i)
+  catch()    console.log("catch",err)
+  finally     console.log("finally",i)
+
+
diff --git a/src/MapleFE/test/typescript/unit_tests/try-catch2.ts b/src/MapleFE/test/typescript/unit_tests/try-catch2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8e1f52c7ac07882bd5d0c33f2110ce5974cdcfd9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/try-catch2.ts
@@ -0,0 +1,17 @@
+class Klass {
+  str: string = "no";
+}
+function func(obj: Klass) {
+  if (obj.str === "yes") {
+    return obj;
+  } else {
+    try {
+      throw "Exception";
+    } catch (e: unknown) {
+      console.log(e);
+      return obj;
+    }
+  }
+}
+
+console.log(func(new Klass()));
diff --git a/src/MapleFE/test/typescript/unit_tests/try-catch2.ts.result b/src/MapleFE/test/typescript/unit_tests/try-catch2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7ba89ee85c6afd8dba50bf6aca8355ccc46ff421
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/try-catch2.ts.result
@@ -0,0 +1,29 @@
+Matched 10 tokens.
+Matched 59 tokens.
+Matched 72 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    str="no"
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+func  func(obj)  throws: 
+  cond-branch cond:obj.str StEq "yes"
+  true branch :
+    return obj
+  false branch :
+    try       throw "Exception"
+
+    catch()      console.log(e)
+      return obj
+
+
+
+== Sub Tree ==
+console.log(func(new Klass()))
diff --git a/src/MapleFE/test/typescript/unit_tests/try-catch3.ts b/src/MapleFE/test/typescript/unit_tests/try-catch3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a2e76318bc62f93506435685ac50fa02826aa276
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/try-catch3.ts
@@ -0,0 +1,7 @@
+for (var i = 3; i >= 0; --i) {
+  try {
+    if (i == 0) throw new Error("Zero");
+    console.log("try", 3 / i);
+  } catch {
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/try-catch3.ts.result b/src/MapleFE/test/typescript/unit_tests/try-catch3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..49ac9127a4893cb5c77f4947eb002ba7c50f5785
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/try-catch3.ts.result
@@ -0,0 +1,12 @@
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+for ( )
+  try     cond-branch cond:i EQ 0
+    true branch :
+      throw new Error("Zero")
+    false branch :
+
+    console.log("try",3 Div i)
+  catch()
+
diff --git a/src/MapleFE/test/typescript/unit_tests/ts-maplike.d.ts b/src/MapleFE/test/typescript/unit_tests/ts-maplike.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7b447e47157c5e18fc2d28050d07616f9ec8c827
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ts-maplike.d.ts
@@ -0,0 +1 @@
+export declare const map: (m: import("./export-interface").MapLike<string[]>) => string;
diff --git a/src/MapleFE/test/typescript/unit_tests/ts-maplike.d.ts.result b/src/MapleFE/test/typescript/unit_tests/ts-maplike.d.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d25ca12a57a2ebd394b583994396179135a9cd52
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/ts-maplike.d.ts.result
@@ -0,0 +1,4 @@
+Matched 23 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare js_const Decl: map} 
diff --git a/src/MapleFE/test/typescript/unit_tests/tuple-type.ts b/src/MapleFE/test/typescript/unit_tests/tuple-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1dbec1d7edc0790d2253797478554d7615fdea60
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/tuple-type.ts
@@ -0,0 +1,6 @@
+function func(t: Function | [Function] | any): string {
+  return typeof t;
+}
+
+var f: Function = func;
+console.log(func(f));
diff --git a/src/MapleFE/test/typescript/unit_tests/tuple-type.ts.result b/src/MapleFE/test/typescript/unit_tests/tuple-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f3c4b75bb345ff34d1017b1f23a3b0c98465722f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/tuple-type.ts.result
@@ -0,0 +1,12 @@
+Matched 21 tokens.
+Matched 28 tokens.
+Matched 38 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(t)  throws: 
+  return  typeof t
+
+== Sub Tree ==
+js_var Decl: f=func
+== Sub Tree ==
+console.log(func(f))
diff --git a/src/MapleFE/test/typescript/unit_tests/tuple-type2.ts b/src/MapleFE/test/typescript/unit_tests/tuple-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ccbb98b125039c8b6efef21c98a39d20177d0240
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/tuple-type2.ts
@@ -0,0 +1,2 @@
+const x: Record<number, [string, number]> = {};
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/tuple-type2.ts.result b/src/MapleFE/test/typescript/unit_tests/tuple-type2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6ca8e406818f231dad3ad132cac6e2e21bd3fa0b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/tuple-type2.ts.result
@@ -0,0 +1,7 @@
+Matched 17 tokens.
+Matched 24 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: x= {}
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/two-dim-array.ts b/src/MapleFE/test/typescript/unit_tests/two-dim-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b89e718d091878d176728582eec14bed4a5a9b7c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/two-dim-array.ts
@@ -0,0 +1,7 @@
+var arr: number[][] = [
+  [1, 2, 3],
+  [4, 5, 6],
+];
+console.log(arr[0][1]);
+console.log(arr[1][0]);
+console.log(arr);
diff --git a/src/MapleFE/test/typescript/unit_tests/two-dim-array.ts.result b/src/MapleFE/test/typescript/unit_tests/two-dim-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e0f27cff73934a255016676bb7cdc43fc69dab19
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/two-dim-array.ts.result
@@ -0,0 +1,13 @@
+Matched 28 tokens.
+Matched 41 tokens.
+Matched 54 tokens.
+Matched 61 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: arr=[[1,2,3],[4,5,6]]
+== Sub Tree ==
+console.log(arr[0][1])
+== Sub Tree ==
+console.log(arr[1][0])
+== Sub Tree ==
+console.log(arr)
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias.ts b/src/MapleFE/test/typescript/unit_tests/type-alias.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d632a4656fad6d9f448fd3cad8539deb4385888a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias.ts
@@ -0,0 +1,7 @@
+type Foo = { name: "foo" };
+type Bar = { name: "bar" };
+type Tee = Foo | Bar;
+
+var f: Tee = { name: "foo" };
+var b: Tee = { name: "bar" };
+console.log(f, b);
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias.ts.result b/src/MapleFE/test/typescript/unit_tests/type-alias.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3c1b4194ed51d235c91a2ebb14423e508a751671
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias.ts.result
@@ -0,0 +1,19 @@
+Matched 9 tokens.
+Matched 18 tokens.
+Matched 25 tokens.
+Matched 36 tokens.
+Matched 47 tokens.
+Matched 56 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Foo =  {name }
+== Sub Tree ==
+ type Bar =  {name }
+== Sub Tree ==
+ type Tee = union  = Foo | Bar
+== Sub Tree ==
+js_var Decl: f= {name:"foo"}
+== Sub Tree ==
+js_var Decl: b= {name:"bar"}
+== Sub Tree ==
+console.log(f,b)
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias2.ts b/src/MapleFE/test/typescript/unit_tests/type-alias2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1111d0624f8bc92dfa03036c33c4ddef2ffacf75
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias2.ts
@@ -0,0 +1,4 @@
+type UT<T, I extends number> = {
+  base: T;
+  ext: T extends ReadonlyArray<infer U> ? UT<U, [-1, 0, 1, 2][I]> : T;
+}[I extends -1 ? "base" : "ext"];
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias2.ts.result b/src/MapleFE/test/typescript/unit_tests/type-alias2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3f929a59f616245895ca6fe1737ccab5d9c0c277
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias2.ts.result
@@ -0,0 +1,4 @@
+Matched 56 tokens.
+============= Module ===========
+== Sub Tree ==
+ type UT<T,I> =  {base;ext }[I extends -1 ? "base" : "ext"]
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias3.ts b/src/MapleFE/test/typescript/unit_tests/type-alias3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0dd747577fcbda545425b5f5102f2a4a926eeaf2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias3.ts
@@ -0,0 +1,8 @@
+type Default = "default";
+type DefaultUnknown = "unknown";
+
+type MyType = {
+    [K: string]: typeof K extends Default ? string :
+      typeof K extends DefaultUnknown ? unknown : never
+};
+
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias3.ts.result b/src/MapleFE/test/typescript/unit_tests/type-alias3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b0d79f9a442e6c4dec640eac1b53bfc9a762a5d4
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias3.ts.result
@@ -0,0 +1,10 @@
+Matched 5 tokens.
+Matched 10 tokens.
+Matched 37 tokens.
+============= Module ===========
+== Sub Tree ==
+ type Default = "default"
+== Sub Tree ==
+ type DefaultUnknown = "unknown"
+== Sub Tree ==
+ type MyType =  {string index type:  typeof K extends Default ? string :  typeof K extends DefaultUnknown ? unknown : never }
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias4.ts b/src/MapleFE/test/typescript/unit_tests/type-alias4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..98d356dc0ee7449aaa685389e05929284ee0cefc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias4.ts
@@ -0,0 +1,2 @@
+type MyType<T> = T extends string ? T : string;
+type UT<T> = MyType<T> extends string ? string : number;
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias4.ts.result b/src/MapleFE/test/typescript/unit_tests/type-alias4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d4a6dbad714c0183de803f17d3e2eb3135e4b5d8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias4.ts.result
@@ -0,0 +1,7 @@
+Matched 14 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+ type MyType<T> = T extends string ? T : string
+== Sub Tree ==
+ type UT<T> = MyType<T> extends string ? string : number
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias5.ts b/src/MapleFE/test/typescript/unit_tests/type-alias5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3d5a7e8727089856075d67170b4b96036690995b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias5.ts
@@ -0,0 +1 @@
+type U<T> = T extends unknown ? unknown extends T ? T extends true ? true : false : false : false;
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias5.ts.result b/src/MapleFE/test/typescript/unit_tests/type-alias5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5541ed585ab913028dc7444372a12fae127dce32
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias5.ts.result
@@ -0,0 +1,4 @@
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+ type U<T> = T extends unknown ? unknown extends T ? T extends true ? true : false : false : false
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias6.ts b/src/MapleFE/test/typescript/unit_tests/type-alias6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0dbe94b9a61ff87efe7c7def6a28ff46a693b517
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias6.ts
@@ -0,0 +1,3 @@
+type RemoveFirstType<T extends any[]> = 
+  T['length'] extends 0 ? undefined :
+  (((...b: T) => void) extends (a: any, ...b: infer I) => void ? I : [])
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias6.ts.result b/src/MapleFE/test/typescript/unit_tests/type-alias6.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..d0bda51d72b5ecc93698426cf5fd96c8f36235f5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias6.ts.result
@@ -0,0 +1,4 @@
+Matched 50 tokens.
+============= Module ===========
+== Sub Tree ==
+ type RemoveFirstType<T> = T["length"] extends 0 ? undefined : (b) ->  extends (a,b) ->  ? I : prim array-TBD
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias7.ts b/src/MapleFE/test/typescript/unit_tests/type-alias7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c1ea47795e0e05bc6074a897d1cac15f05df0a51
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias7.ts
@@ -0,0 +1,6 @@
+class Klass {
+  value: number = 0;
+  key: string = "";
+}
+
+type MyType<T extends Klass>= Array<Array<T>>;
diff --git a/src/MapleFE/test/typescript/unit_tests/type-alias7.ts.result b/src/MapleFE/test/typescript/unit_tests/type-alias7.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..20e1da6916ecde0509ef457e5cb217444e5dd219
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-alias7.ts.result
@@ -0,0 +1,15 @@
+Matched 16 tokens.
+Matched 31 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    value=0    key=""
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+ type MyType<T> = Array<Array<T>>
diff --git a/src/MapleFE/test/typescript/unit_tests/type-assertion-as.ts b/src/MapleFE/test/typescript/unit_tests/type-assertion-as.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3d35b9c66907e1e9935c79e0e180fdff24bff1d8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-assertion-as.ts
@@ -0,0 +1,2 @@
+let code: any = 123;
+let employeeCode = code as number;
diff --git a/src/MapleFE/test/typescript/unit_tests/type-assertion-as.ts.result b/src/MapleFE/test/typescript/unit_tests/type-assertion-as.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..83ded8c5176f2f819c11eb07f6731688b3aa1fee
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-assertion-as.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 14 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: code=123
+== Sub Tree ==
+js_let Decl: employeeCode=code
diff --git a/src/MapleFE/test/typescript/unit_tests/type-assertion-as2.ts b/src/MapleFE/test/typescript/unit_tests/type-assertion-as2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e585d7121f97f6462f9097dfc3096aafcebbb5f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-assertion-as2.ts
@@ -0,0 +1,6 @@
+function func<T>(e: T) : Array<T> {
+  return [e];
+}
+function foo<T>(arg: any) {
+  return func<T>(arg)[0] as T;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/type-assertion-as2.ts.result b/src/MapleFE/test/typescript/unit_tests/type-assertion-as2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8a4fb1dbd6372aeaf04f7e7c1ec3ef0faf3ede99
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-assertion-as2.ts.result
@@ -0,0 +1,11 @@
+Matched 22 tokens.
+Matched 48 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func<T>(e)  throws: 
+  return [e]
+
+== Sub Tree ==
+func  foo<T>(arg)  throws: 
+  return func<T>(arg)[0]
+
diff --git a/src/MapleFE/test/typescript/unit_tests/type-assertion-retval.ts b/src/MapleFE/test/typescript/unit_tests/type-assertion-retval.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7e94c7c6c291de0b644044d7a6f185b778835176
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-assertion-retval.ts
@@ -0,0 +1,7 @@
+class Foo {
+  public func() {
+    return 10;
+  }
+}
+let obj = new Foo();
+let employeeCode = obj.func() as number;
diff --git a/src/MapleFE/test/typescript/unit_tests/type-assertion-retval.ts.result b/src/MapleFE/test/typescript/unit_tests/type-assertion-retval.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ba9e0c2d31c761e58b928187bef6ea8ce49b6077
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-assertion-retval.ts.result
@@ -0,0 +1,20 @@
+Matched 13 tokens.
+Matched 21 tokens.
+Matched 32 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func()  throws: 
+      return 10
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_let Decl: obj=new Foo()
+== Sub Tree ==
+js_let Decl: employeeCode=obj.func()
diff --git a/src/MapleFE/test/typescript/unit_tests/type-assertion-this.ts b/src/MapleFE/test/typescript/unit_tests/type-assertion-this.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d7d0c97a5d0852b14ad172c9faf676cde041a287
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-assertion-this.ts
@@ -0,0 +1,6 @@
+class Foo {
+  public _val: number = 0;
+  public func(): number {
+    return this._val as number;
+  }
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/type-assertion-this.ts.result b/src/MapleFE/test/typescript/unit_tests/type-assertion-this.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..69d1ccc316f88a7d554168f5ec87bf9d1b9a6909
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-assertion-this.ts.result
@@ -0,0 +1,14 @@
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Foo
+  Fields: 
+    _val=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  func()  throws: 
+      return this._val
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/type-cast.ts b/src/MapleFE/test/typescript/unit_tests/type-cast.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2bdac558b996636acc0fe27c56a77233a5788ee8
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-cast.ts
@@ -0,0 +1,18 @@
+interface Base {
+  name: string;
+}
+interface Derived extends Base {
+  age: number;
+}
+
+let o = { name: "John", age: 30 };
+
+function dump(obj: Base) {
+  console.log(obj.name, (<Derived>obj).age);
+}
+dump(o);
+
+function dump2(obj: Base) {
+  console.log(obj.name, (obj as Derived).age);
+}
+dump2(o);
diff --git a/src/MapleFE/test/typescript/unit_tests/type-cast.ts.result b/src/MapleFE/test/typescript/unit_tests/type-cast.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b1e67b53bf15ff1e0587607fe54c0ff88972e57f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-cast.ts.result
@@ -0,0 +1,26 @@
+Matched 8 tokens.
+Matched 18 tokens.
+Matched 31 tokens.
+Matched 58 tokens.
+Matched 63 tokens.
+Matched 89 tokens.
+Matched 94 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Base {name }
+== Sub Tree ==
+ts_interface: Derived {age }
+== Sub Tree ==
+js_let Decl: o= {name:"John", age:30}
+== Sub Tree ==
+func  dump(obj)  throws: 
+  console.log(obj.name,(Derived)obj.age)
+
+== Sub Tree ==
+dump(o)
+== Sub Tree ==
+func  dump2(obj)  throws: 
+  console.log(obj.name,obj.age)
+
+== Sub Tree ==
+dump2(o)
diff --git a/src/MapleFE/test/typescript/unit_tests/type-only-export.ts b/src/MapleFE/test/typescript/unit_tests/type-only-export.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9152f5d448eedbe119eed47461f71eb880d5403e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-only-export.ts
@@ -0,0 +1,4 @@
+class Klass {
+  n: number = 0;
+}
+export type K = Klass;
diff --git a/src/MapleFE/test/typescript/unit_tests/type-only-export.ts.result b/src/MapleFE/test/typescript/unit_tests/type-only-export.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a81448254ce65483220fbf223428b10515c71b0d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-only-export.ts.result
@@ -0,0 +1,15 @@
+Matched 10 tokens.
+Matched 16 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    n=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+export { type K = Klass} 
diff --git a/src/MapleFE/test/typescript/unit_tests/type-only-import.ts b/src/MapleFE/test/typescript/unit_tests/type-only-import.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9505ab8d55aebdf2a1ded8646778077bf4c6f55d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-only-import.ts
@@ -0,0 +1,4 @@
+import type { K } from "./type-only-export";
+
+var x: K = { n: 123 };
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/type-only-import.ts.result b/src/MapleFE/test/typescript/unit_tests/type-only-import.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..389dcc86a93b459f9d207dde338115a4dd50b242
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-only-import.ts.result
@@ -0,0 +1,10 @@
+Matched 8 tokens.
+Matched 19 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+import {K} "./type-only-export"
+== Sub Tree ==
+js_var Decl: x= {n:123}
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/type-predicate.ts b/src/MapleFE/test/typescript/unit_tests/type-predicate.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7c8df56a02bcbd316f51592e442f657ca333a564
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-predicate.ts
@@ -0,0 +1,24 @@
+interface Foo {
+    foo: number;
+}
+
+interface Bar {
+    bar: number;
+}
+
+function isFoo(arg: any): arg is Foo {
+    return arg.foo !== undefined;
+}
+
+// user defined type guard
+function doStuff(arg: Foo | Bar) {
+    if (isFoo(arg)) {
+        console.log(arg.foo);
+    }
+    else {
+        console.log(arg.bar);
+    }
+}
+
+doStuff({ foo: 123 });
+doStuff({ bar: 123 });
diff --git a/src/MapleFE/test/typescript/unit_tests/type-predicate.ts.result b/src/MapleFE/test/typescript/unit_tests/type-predicate.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e51159f7779d196b7b0be90db2c6dce2ab6fe59d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/type-predicate.ts.result
@@ -0,0 +1,28 @@
+Matched 8 tokens.
+Matched 16 tokens.
+Matched 36 tokens.
+Matched 77 tokens.
+Matched 86 tokens.
+Matched 95 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Foo {foo }
+== Sub Tree ==
+ts_interface: Bar {bar }
+== Sub Tree ==
+func  isFoo(arg)  throws: 
+  return arg.foo StNe undefined
+
+== Sub Tree ==
+func  doStuff(arg)  throws: 
+  cond-branch cond:isFoo(arg)
+  true branch :
+    console.log(arg.foo)
+  false branch :
+    console.log(arg.bar)
+
+
+== Sub Tree ==
+doStuff( {foo:123})
+== Sub Tree ==
+doStuff( {bar:123})
diff --git a/src/MapleFE/test/typescript/unit_tests/typed-array.ts b/src/MapleFE/test/typescript/unit_tests/typed-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e30281a9778cdc16822dbf57201c942448771833
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/typed-array.ts
@@ -0,0 +1,49 @@
+let buf = new ArrayBuffer(16);
+let bytes = new Uint8Array(buf);
+for (let i = 0; i < bytes.length; i++)
+  bytes[i] = i * 15;
+
+console.log("\nInt8Array", Int8Array);
+let Int8View = new Int8Array(buf);
+for (let i = 0; i < Int8View.length; i++)
+  console.log(i, Int8View[i]);
+console.log("\nUint8Array", Uint8Array);
+let Uint8View = new Uint8Array(buf);
+for (let i = 0; i < Uint8View.length; i++)
+  console.log(i, Uint8View[i]);
+console.log("\nUint8ClampedArray", Uint8ClampedArray);
+let Uint8ClampedView = new Uint8ClampedArray(buf);
+for (let i = 0; i < Uint8ClampedView.length; i++)
+  console.log(i, Uint8ClampedView[i]);
+console.log("\nInt16Array", Int16Array);
+let Int16View = new Int16Array(buf);
+for (let i = 0; i < Int16View.length; i++)
+  console.log(i, Int16View[i]);
+console.log("\nUint16Array", Uint16Array);
+let Uint16View = new Uint16Array(buf);
+for (let i = 0; i < Uint16View.length; i++)
+  console.log(i, Uint16View[i]);
+console.log("\nInt32Array", Int32Array);
+let Int32View = new Int32Array(buf);
+for (let i = 0; i < Int32View.length; i++)
+  console.log(i, Int32View[i]);
+console.log("\nUint32Array", Uint32Array);
+let Uint32View = new Uint32Array(buf);
+for (let i = 0; i < Uint32View.length; i++)
+  console.log(i, Uint32View[i]);
+console.log("\nFloat32Array", Float32Array);
+let Float32View = new Float32Array(buf);
+for (let i = 0; i < Float32View.length; i++)
+  console.log(i, Float32View[i]);
+console.log("\nFloat64Array", Float64Array);
+let Float64View = new Float64Array(buf);
+for (let i = 0; i < Float64View.length; i++)
+  console.log(i, Float64View[i]);
+// console.log("\nBigInt64Array", BigInt64Array);
+// let BigInt64View = new BigInt64Array(buf);
+// for (let i = 0; i < BigInt64View.length; i++)
+//   console.log(i, BigInt64View[i]);
+// console.log("\nBigUint64Array", BigUint64Array);
+// let BigUint64View = new BigUint64Array(buf);
+// for (let i = 0; i < BigUint64View.length; i++)
+//   console.log(i, BigUint64View[i]);
diff --git a/src/MapleFE/test/typescript/unit_tests/typed-array.ts.result b/src/MapleFE/test/typescript/unit_tests/typed-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..543fad1c4316b00ca8dca19dae69cea805a88a16
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/typed-array.ts.result
@@ -0,0 +1,101 @@
+Matched 9 tokens.
+Matched 18 tokens.
+Matched 43 tokens.
+Matched 52 tokens.
+Matched 61 tokens.
+Matched 89 tokens.
+Matched 98 tokens.
+Matched 107 tokens.
+Matched 135 tokens.
+Matched 144 tokens.
+Matched 153 tokens.
+Matched 181 tokens.
+Matched 190 tokens.
+Matched 199 tokens.
+Matched 227 tokens.
+Matched 236 tokens.
+Matched 245 tokens.
+Matched 273 tokens.
+Matched 282 tokens.
+Matched 291 tokens.
+Matched 319 tokens.
+Matched 328 tokens.
+Matched 337 tokens.
+Matched 365 tokens.
+Matched 374 tokens.
+Matched 383 tokens.
+Matched 411 tokens.
+Matched 420 tokens.
+Matched 429 tokens.
+Matched 457 tokens.
+============= Module ===========
+== Sub Tree ==
+js_let Decl: buf=new ArrayBuffer(16)
+== Sub Tree ==
+js_let Decl: bytes=new Uint8Array(buf)
+== Sub Tree ==
+for ( )
+  bytes[i] Assign i Mul 15
+== Sub Tree ==
+console.log("\nInt8Array",Int8Array)
+== Sub Tree ==
+js_let Decl: Int8View=new Int8Array(buf)
+== Sub Tree ==
+for ( )
+  console.log(i,Int8View[i])
+== Sub Tree ==
+console.log("\nUint8Array",Uint8Array)
+== Sub Tree ==
+js_let Decl: Uint8View=new Uint8Array(buf)
+== Sub Tree ==
+for ( )
+  console.log(i,Uint8View[i])
+== Sub Tree ==
+console.log("\nUint8ClampedArray",Uint8ClampedArray)
+== Sub Tree ==
+js_let Decl: Uint8ClampedView=new Uint8ClampedArray(buf)
+== Sub Tree ==
+for ( )
+  console.log(i,Uint8ClampedView[i])
+== Sub Tree ==
+console.log("\nInt16Array",Int16Array)
+== Sub Tree ==
+js_let Decl: Int16View=new Int16Array(buf)
+== Sub Tree ==
+for ( )
+  console.log(i,Int16View[i])
+== Sub Tree ==
+console.log("\nUint16Array",Uint16Array)
+== Sub Tree ==
+js_let Decl: Uint16View=new Uint16Array(buf)
+== Sub Tree ==
+for ( )
+  console.log(i,Uint16View[i])
+== Sub Tree ==
+console.log("\nInt32Array",Int32Array)
+== Sub Tree ==
+js_let Decl: Int32View=new Int32Array(buf)
+== Sub Tree ==
+for ( )
+  console.log(i,Int32View[i])
+== Sub Tree ==
+console.log("\nUint32Array",Uint32Array)
+== Sub Tree ==
+js_let Decl: Uint32View=new Uint32Array(buf)
+== Sub Tree ==
+for ( )
+  console.log(i,Uint32View[i])
+== Sub Tree ==
+console.log("\nFloat32Array",Float32Array)
+== Sub Tree ==
+js_let Decl: Float32View=new Float32Array(buf)
+== Sub Tree ==
+for ( )
+  console.log(i,Float32View[i])
+== Sub Tree ==
+console.log("\nFloat64Array",Float64Array)
+== Sub Tree ==
+js_let Decl: Float64View=new Float64Array(buf)
+== Sub Tree ==
+for ( )
+  console.log(i,Float64View[i])
diff --git a/src/MapleFE/test/typescript/unit_tests/typename-as-var.ts b/src/MapleFE/test/typescript/unit_tests/typename-as-var.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4aa37a9a22f356ec02a890abe03afbc5306c0ba7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/typename-as-var.ts
@@ -0,0 +1,7 @@
+const boolean = Boolean;
+var b = new boolean(false);
+console.log(boolean, b);
+
+const string = String;
+var s = new string("abc");
+console.log(string, s);
diff --git a/src/MapleFE/test/typescript/unit_tests/typename-as-var.ts.result b/src/MapleFE/test/typescript/unit_tests/typename-as-var.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..b13ac1054fdcc3f0e2088ac0c47b328aa453ed9c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/typename-as-var.ts.result
@@ -0,0 +1,19 @@
+Matched 5 tokens.
+Matched 14 tokens.
+Matched 23 tokens.
+Matched 28 tokens.
+Matched 37 tokens.
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: boolean=Boolean
+== Sub Tree ==
+js_var Decl: b=new boolean(false)
+== Sub Tree ==
+console.log(boolean,b)
+== Sub Tree ==
+js_const Decl: string=String
+== Sub Tree ==
+js_var Decl: s=new string("abc")
+== Sub Tree ==
+console.log(string,s)
diff --git a/src/MapleFE/test/typescript/unit_tests/typeof.d.ts b/src/MapleFE/test/typescript/unit_tests/typeof.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..da86045759b7942cfee07feb09f277189b22ef71
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/typeof.d.ts
@@ -0,0 +1,3 @@
+export declare const E: readonly ["left", "right", "top", "down"];
+export declare type A = (typeof E)[number];
+
diff --git a/src/MapleFE/test/typescript/unit_tests/typeof.d.ts.result b/src/MapleFE/test/typescript/unit_tests/typeof.d.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..dc4d89f967c5db2a1158279a2b0cddaf331d6722
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/typeof.d.ts.result
@@ -0,0 +1,7 @@
+Matched 16 tokens.
+Matched 29 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare js_const Decl: E} 
+== Sub Tree ==
+export {declare  type A =  typeof E[number]} 
diff --git a/src/MapleFE/test/typescript/unit_tests/types.ts b/src/MapleFE/test/typescript/unit_tests/types.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf9e393b3e7fd6fedf04bb6e6411ecb2a9d1ba44
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/types.ts
@@ -0,0 +1,48 @@
+// ECMAScript language types (aka primitive type, literal type, etc..)
+console.log(typeof(undefined));    // undefined
+console.log(typeof(null));         // object (javascrupt legacy)
+console.log(typeof(true));         // boolean
+console.log(typeof(false));        // boolean
+console.log(typeof("abc"));        // string
+console.log(typeof(Symbol()));     // symbol
+console.log(typeof(123));          // number
+//console.log(typeof(123n));         // bigint
+//console.log(typeof(BigInt(123)));  // bigint
+
+// complex/compound type
+console.log(typeof({}));           // object
+console.log({} instanceof Object); // true
+console.log(typeof([]));
+console.log([] instanceof Array);
+console.log(typeof(new Array));
+console.log("====");
+console.log(typeof Object());      // object
+console.log(typeof new Object());  // object
+console.log(Object() instanceof Object);    // true
+console.log(new Object instanceof Object);  // true
+
+// builtin objects
+console.log(typeof(String()));           // string
+console.log(typeof(Boolean()));          // boolean
+console.log(typeof(Date()));             // string
+console.log(typeof(Number()));           // number
+//console.log(typeof(BigInt(123)));        // bigint
+console.log(typeof(new String()));       // object
+console.log(typeof(new Boolean()));      // object
+console.log(typeof(new Date()));         // object
+console.log(typeof(new Number()));       // object
+
+//console.log(String()  instanceof String); 
+//console.log(Boolean() instanceof Boolean);
+//console.log(Date()    instanceof Date);
+//console.log(Number()  instanceof Number);
+console.log(new String()  instanceof String);  // true
+console.log(new Boolean() instanceof Boolean); // true
+console.log(new Date()    instanceof Date);    // true
+console.log(new Number()  instanceof Number);  // true
+
+console.log(typeof(class {} ));          // function
+console.log(class{} instanceof Function);// Function
+console.log(typeof(new class {} ));      // object
+console.log(new class {} instanceof Object); // object
+
diff --git a/src/MapleFE/test/typescript/unit_tests/types.ts.result b/src/MapleFE/test/typescript/unit_tests/types.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..daf52ff17fb31e35eb90acea22e0008ff0690444
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/types.ts.result
@@ -0,0 +1,116 @@
+Matched 10 tokens.
+Matched 20 tokens.
+Matched 30 tokens.
+Matched 40 tokens.
+Matched 50 tokens.
+Matched 62 tokens.
+Matched 72 tokens.
+Matched 83 tokens.
+Matched 93 tokens.
+Matched 104 tokens.
+Matched 114 tokens.
+Matched 125 tokens.
+Matched 132 tokens.
+Matched 142 tokens.
+Matched 153 tokens.
+Matched 164 tokens.
+Matched 174 tokens.
+Matched 186 tokens.
+Matched 198 tokens.
+Matched 210 tokens.
+Matched 222 tokens.
+Matched 235 tokens.
+Matched 248 tokens.
+Matched 261 tokens.
+Matched 274 tokens.
+Matched 286 tokens.
+Matched 298 tokens.
+Matched 310 tokens.
+Matched 322 tokens.
+Matched 334 tokens.
+Matched 345 tokens.
+Matched 358 tokens.
+Matched 370 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log( typeof undefined)
+== Sub Tree ==
+console.log( typeof null)
+== Sub Tree ==
+console.log( typeof true)
+== Sub Tree ==
+console.log( typeof false)
+== Sub Tree ==
+console.log( typeof "abc")
+== Sub Tree ==
+console.log( typeof Symbol())
+== Sub Tree ==
+console.log( typeof 123)
+== Sub Tree ==
+console.log( typeof  {})
+== Sub Tree ==
+console.log( {} instanceof Object)
+== Sub Tree ==
+console.log( typeof [])
+== Sub Tree ==
+console.log([] instanceof Array)
+== Sub Tree ==
+console.log( typeof new Array())
+== Sub Tree ==
+console.log("====")
+== Sub Tree ==
+console.log( typeof Object())
+== Sub Tree ==
+console.log( typeof new Object())
+== Sub Tree ==
+console.log(Object() instanceof Object)
+== Sub Tree ==
+console.log(new Object() instanceof Object)
+== Sub Tree ==
+console.log( typeof String())
+== Sub Tree ==
+console.log( typeof Boolean())
+== Sub Tree ==
+console.log( typeof Date())
+== Sub Tree ==
+console.log( typeof Number())
+== Sub Tree ==
+console.log( typeof new String())
+== Sub Tree ==
+console.log( typeof new Boolean())
+== Sub Tree ==
+console.log( typeof new Date())
+== Sub Tree ==
+console.log( typeof new Number())
+== Sub Tree ==
+console.log(new String() instanceof String)
+== Sub Tree ==
+console.log(new Boolean() instanceof Boolean)
+== Sub Tree ==
+console.log(new Date() instanceof Date)
+== Sub Tree ==
+console.log(new Number() instanceof Number)
+== Sub Tree ==
+console.log( typeof class  
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+)
+== Sub Tree ==
+console.log(class  
+  Fields: 
+
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+ instanceof Function)
+== Sub Tree ==
+console.log( typeof new ())
+== Sub Tree ==
+console.log(new () instanceof Object)
diff --git a/src/MapleFE/test/typescript/unit_tests/unary_op.ts b/src/MapleFE/test/typescript/unit_tests/unary_op.ts
new file mode 100644
index 0000000000000000000000000000000000000000..34893c274ab5c0094b0329a96c925fba46dc2300
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/unary_op.ts
@@ -0,0 +1,27 @@
+class A {
+  a?: number = 0;
+  b: number = 0;
+}
+var x: A = {a: 1, b: 2};
+delete x.a;
+
+console.log(void 0);
+
+console.log(typeof 8);
+
+var a: number = 8;
+console.log(++a);
+console.log(--a);
+
+console.log(+8);
+console.log(+"-8");
+
+console.log(-"8");
+console.log(-a);
+
+console.log(~8);
+console.log(~"8");
+console.log(~a);
+
+console.log(!false);
+console.log(!true);
diff --git a/src/MapleFE/test/typescript/unit_tests/unary_op.ts.result b/src/MapleFE/test/typescript/unit_tests/unary_op.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..44e37f79c25eb54a182e3e0b76a14104c195739c
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/unary_op.ts.result
@@ -0,0 +1,60 @@
+Matched 17 tokens.
+Matched 32 tokens.
+Matched 37 tokens.
+Matched 45 tokens.
+Matched 53 tokens.
+Matched 60 tokens.
+Matched 68 tokens.
+Matched 76 tokens.
+Matched 83 tokens.
+Matched 91 tokens.
+Matched 99 tokens.
+Matched 107 tokens.
+Matched 115 tokens.
+Matched 123 tokens.
+Matched 131 tokens.
+Matched 139 tokens.
+Matched 147 tokens.
+============= Module ===========
+== Sub Tree ==
+class  A
+  Fields: 
+    a?=0    b=0
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+js_var Decl: x= {a:1, b:2}
+== Sub Tree ==
+ delete x.a
+== Sub Tree ==
+console.log(void)
+== Sub Tree ==
+console.log( typeof 8)
+== Sub Tree ==
+js_var Decl: a=8
+== Sub Tree ==
+console.log(PreInc a)
+== Sub Tree ==
+console.log(PreDec a)
+== Sub Tree ==
+console.log(8)
+== Sub Tree ==
+console.log(Plus "-8")
+== Sub Tree ==
+console.log(Minus "8")
+== Sub Tree ==
+console.log(Minus a)
+== Sub Tree ==
+console.log(Bcomp 8)
+== Sub Tree ==
+console.log(Bcomp "8")
+== Sub Tree ==
+console.log(Bcomp a)
+== Sub Tree ==
+console.log(Not false)
+== Sub Tree ==
+console.log(Not true)
diff --git a/src/MapleFE/test/typescript/unit_tests/undefined-assign.ts b/src/MapleFE/test/typescript/unit_tests/undefined-assign.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d3677a2574853dea16c54071dc58e2b006899cf1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/undefined-assign.ts
@@ -0,0 +1 @@
+var x = undefined;
diff --git a/src/MapleFE/test/typescript/unit_tests/undefined-assign.ts.result b/src/MapleFE/test/typescript/unit_tests/undefined-assign.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..06beeb38ee7c3d68b0b9f5aed1b4fc79404025f9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/undefined-assign.ts.result
@@ -0,0 +1,4 @@
+Matched 5 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=undefined
diff --git a/src/MapleFE/test/typescript/unit_tests/undefined-type.ts b/src/MapleFE/test/typescript/unit_tests/undefined-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0e3c2e89988257e58d32b2283b301ce4c12137a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/undefined-type.ts
@@ -0,0 +1,9 @@
+function func(x: unknown): number | undefined {
+  if (typeof x === "number") return x * x;
+  return undefined;
+}
+
+let v = func("a");
+console.log(v);
+v = func(3);
+console.log(v);
diff --git a/src/MapleFE/test/typescript/unit_tests/undefined-type.ts.result b/src/MapleFE/test/typescript/unit_tests/undefined-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..1f6d4c0e72c7c45e604a7413f242f2df326f6b2a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/undefined-type.ts.result
@@ -0,0 +1,22 @@
+Matched 28 tokens.
+Matched 36 tokens.
+Matched 43 tokens.
+Matched 50 tokens.
+Matched 57 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(x)  throws: 
+  cond-branch cond: typeof x StEq "number"
+  true branch :
+    return x Mul x  false branch :
+
+  return undefined
+
+== Sub Tree ==
+js_let Decl: v=func("a")
+== Sub Tree ==
+console.log(v)
+== Sub Tree ==
+v Assign func(3)
+== Sub Tree ==
+console.log(v)
diff --git a/src/MapleFE/test/typescript/unit_tests/unicode-string.ts b/src/MapleFE/test/typescript/unit_tests/unicode-string.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9ba9688f86fe738ce3ee1f8b19e8411e4bde6810
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/unicode-string.ts
@@ -0,0 +1 @@
+console.log("cd/m²");
diff --git a/src/MapleFE/test/typescript/unit_tests/unicode-string.ts.result b/src/MapleFE/test/typescript/unit_tests/unicode-string.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a88eebc76c306d06da149cceb7082e77bc5df551
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/unicode-string.ts.result
@@ -0,0 +1,4 @@
+Matched 7 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log("cd/m²")
diff --git a/src/MapleFE/test/typescript/unit_tests/unicode-string2.ts b/src/MapleFE/test/typescript/unit_tests/unicode-string2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ef5a5d83d01f52dc678ee48daa431cf4ceb9110a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/unicode-string2.ts
@@ -0,0 +1 @@
+console.log("你好");
diff --git a/src/MapleFE/test/typescript/unit_tests/unicode-string2.ts.result b/src/MapleFE/test/typescript/unit_tests/unicode-string2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..da685ec3174d1781efee3e577deaa9681cd33c11
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/unicode-string2.ts.result
@@ -0,0 +1,4 @@
+Matched 7 tokens.
+============= Module ===========
+== Sub Tree ==
+console.log("你好")
diff --git a/src/MapleFE/test/typescript/unit_tests/unicode-string3.ts b/src/MapleFE/test/typescript/unit_tests/unicode-string3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1d285ea0dc11a1e4b4f2539c3d798b55790ee95e
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/unicode-string3.ts
@@ -0,0 +1,5 @@
+var 变量: string | number = "abc";
+// UTF-16 codes for 变量: 53d8 91cf
+console.log(变量);
+变量 = 123;
+console.log(变量);
diff --git a/src/MapleFE/test/typescript/unit_tests/unicode-string4.ts b/src/MapleFE/test/typescript/unit_tests/unicode-string4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9f2aa9007640701f1f5ab6375c796acd49a86eea
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/unicode-string4.ts
@@ -0,0 +1,2 @@
+const str = "\u001F";
+console.log(str);
diff --git a/src/MapleFE/test/typescript/unit_tests/unicode-string4.ts.result b/src/MapleFE/test/typescript/unit_tests/unicode-string4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3b23caffe9b938ea8c8863e6fd0b0dc2c94cc840
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/unicode-string4.ts.result
@@ -0,0 +1,7 @@
+Matched 5 tokens.
+Matched 12 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: str="\u001F"
+== Sub Tree ==
+console.log(str)
diff --git a/src/MapleFE/test/typescript/unit_tests/union-import-types.d.ts b/src/MapleFE/test/typescript/unit_tests/union-import-types.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..35f88d5860cf8136f1cb7a33e0ec2e3c7fea88d3
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-import-types.d.ts
@@ -0,0 +1 @@
+export declare var x: { f: typeof import("./M") | import("./enum2").ET };
diff --git a/src/MapleFE/test/typescript/unit_tests/union-import-types.d.ts.result b/src/MapleFE/test/typescript/unit_tests/union-import-types.d.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..258f571ece0e0a0ecc73ad3117aa406503b01384
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-import-types.d.ts.result
@@ -0,0 +1,4 @@
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+export {declare js_var Decl: x} 
diff --git a/src/MapleFE/test/typescript/unit_tests/union-of-literals.ts b/src/MapleFE/test/typescript/unit_tests/union-of-literals.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6bcb1d3d3763db2aa116640d020aa279890af4be
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-of-literals.ts
@@ -0,0 +1,6 @@
+var x: 0 | 1 | 2;
+x = 1;
+console.log(x);
+var y: "left" | "right";
+y = "left";
+console.log(y);
diff --git a/src/MapleFE/test/typescript/unit_tests/union-of-literals.ts.result b/src/MapleFE/test/typescript/unit_tests/union-of-literals.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..70069d55f920008984d3e0594a1879d77bb783e0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-of-literals.ts.result
@@ -0,0 +1,19 @@
+Matched 9 tokens.
+Matched 13 tokens.
+Matched 20 tokens.
+Matched 27 tokens.
+Matched 31 tokens.
+Matched 38 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x
+== Sub Tree ==
+x Assign 1
+== Sub Tree ==
+console.log(x)
+== Sub Tree ==
+js_var Decl: y
+== Sub Tree ==
+y Assign "left"
+== Sub Tree ==
+console.log(y)
diff --git a/src/MapleFE/test/typescript/unit_tests/union-of-literals2.ts b/src/MapleFE/test/typescript/unit_tests/union-of-literals2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56fb44c11dd899b62925c176bb5c7987988016a1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-of-literals2.ts
@@ -0,0 +1,3 @@
+var y: "left" | "right" | string | undefined;
+y = "left";
+console.log(y);
diff --git a/src/MapleFE/test/typescript/unit_tests/union-of-literals2.ts.result b/src/MapleFE/test/typescript/unit_tests/union-of-literals2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e04ce3af94ad93c2c09053dae77cd908911e1ead
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-of-literals2.ts.result
@@ -0,0 +1,10 @@
+Matched 11 tokens.
+Matched 15 tokens.
+Matched 22 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: y
+== Sub Tree ==
+y Assign "left"
+== Sub Tree ==
+console.log(y)
diff --git a/src/MapleFE/test/typescript/unit_tests/union-of-prim-array.ts b/src/MapleFE/test/typescript/unit_tests/union-of-prim-array.ts
new file mode 100644
index 0000000000000000000000000000000000000000..89331dd9f6efc0d056b83994ceb74818bbabf37a
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-of-prim-array.ts
@@ -0,0 +1,4 @@
+var x: number[] | string[] = [1, 2, 3];
+console.log(x);
+x = ["abc", "def"];
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/union-of-prim-array.ts.result b/src/MapleFE/test/typescript/unit_tests/union-of-prim-array.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cd5ee9bb2c95af4127fa23d80982f35852249412
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-of-prim-array.ts.result
@@ -0,0 +1,13 @@
+Matched 19 tokens.
+Matched 26 tokens.
+Matched 34 tokens.
+Matched 41 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=[1,2,3]
+== Sub Tree ==
+console.log(x)
+== Sub Tree ==
+x Assign ["abc","def"]
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type.ts b/src/MapleFE/test/typescript/unit_tests/union-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f78209a4fdf5508ebd5cd43ac29d2aba2be8a2ce
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type.ts
@@ -0,0 +1,7 @@
+type UnionType = number | string;
+function add(x: UnionType, y: UnionType): UnionType {
+  if (typeof x === "number" && typeof y == "number") return x + y;
+  else return x.toString() + y.toString();
+}
+console.log(add(1, 2));
+console.log(add("a", "b"));
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type.ts.result b/src/MapleFE/test/typescript/unit_tests/union-type.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..590db9e8c87f10865dcac5d536883101e0b5b763
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type.ts.result
@@ -0,0 +1,18 @@
+Matched 7 tokens.
+Matched 53 tokens.
+Matched 65 tokens.
+Matched 77 tokens.
+============= Module ===========
+== Sub Tree ==
+ type UnionType = union  = number | string
+== Sub Tree ==
+func  add(x,y)  throws: 
+  cond-branch cond: typeof x StEq "number" Land  typeof y EQ "number"
+  true branch :
+    return x Add y  false branch :
+    return x.toString() Add y.toString()
+
+== Sub Tree ==
+console.log(add(1,2))
+== Sub Tree ==
+console.log(add("a","b"))
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type2.ts b/src/MapleFE/test/typescript/unit_tests/union-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..22a02a0c38c5ffb464190190b43a56d25edd02a5
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type2.ts
@@ -0,0 +1,7 @@
+type UT = string | ((k: number) => number);
+var s: UT = "abc";
+console.log(s);
+s = function func(k: number): number {
+  return k + k;
+};
+console.log(s, s(3));
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type2.ts.result b/src/MapleFE/test/typescript/unit_tests/union-type2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f368b31edb44b8836b9cf8b6b111ca760d09b6a7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type2.ts.result
@@ -0,0 +1,18 @@
+Matched 15 tokens.
+Matched 22 tokens.
+Matched 29 tokens.
+Matched 48 tokens.
+Matched 60 tokens.
+============= Module ===========
+== Sub Tree ==
+ type UT = union  = string | (k) -> 
+== Sub Tree ==
+js_var Decl: s="abc"
+== Sub Tree ==
+console.log(s)
+== Sub Tree ==
+s Assign func  func(k)  throws: 
+  return k Add k
+
+== Sub Tree ==
+console.log(s,s(3))
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type3.ts b/src/MapleFE/test/typescript/unit_tests/union-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..42629ed59ec65e77aade9dbe3e95734c29663874
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type3.ts
@@ -0,0 +1,9 @@
+function func(k: number): number {
+  return k + k;
+}
+
+type UT = string | typeof func;
+var s: UT = "abc";
+console.log(s);
+s = func;
+console.log(s, s(3));
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type3.ts.result b/src/MapleFE/test/typescript/unit_tests/union-type3.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..3851bff8bc5ce2d7843d5b859a4e7f1091e0474b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type3.ts.result
@@ -0,0 +1,21 @@
+Matched 16 tokens.
+Matched 24 tokens.
+Matched 31 tokens.
+Matched 38 tokens.
+Matched 42 tokens.
+Matched 54 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(k)  throws: 
+  return k Add k
+
+== Sub Tree ==
+ type UT = union  = string |  typeof func
+== Sub Tree ==
+js_var Decl: s="abc"
+== Sub Tree ==
+console.log(s)
+== Sub Tree ==
+s Assign func
+== Sub Tree ==
+console.log(s,s(3))
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type4.ts b/src/MapleFE/test/typescript/unit_tests/union-type4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..994b3993c430f861e8ecd0bff161573ddd9d3929
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type4.ts
@@ -0,0 +1,11 @@
+function func(k: number): number {
+  return k + k;
+}
+
+type UT = string | typeof func | Array<string>;
+var s: UT = "abc";
+console.log(s);
+s = func;
+console.log(s, s(3));
+s = new Array("first", "second");
+console.log(s);
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type4.ts.result b/src/MapleFE/test/typescript/unit_tests/union-type4.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..cb4401473c8420858aa766a4dbf9ec2d59c4ca32
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type4.ts.result
@@ -0,0 +1,27 @@
+Matched 16 tokens.
+Matched 29 tokens.
+Matched 36 tokens.
+Matched 43 tokens.
+Matched 47 tokens.
+Matched 59 tokens.
+Matched 69 tokens.
+Matched 76 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(k)  throws: 
+  return k Add k
+
+== Sub Tree ==
+ type UT = union  = string |  typeof func | Array<string>
+== Sub Tree ==
+js_var Decl: s="abc"
+== Sub Tree ==
+console.log(s)
+== Sub Tree ==
+s Assign func
+== Sub Tree ==
+console.log(s,s(3))
+== Sub Tree ==
+s Assign new Array("first","second")
+== Sub Tree ==
+console.log(s)
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type5.ts b/src/MapleFE/test/typescript/unit_tests/union-type5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..81947c80bc1ac1bc570eae8b920db913aa9a346b
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type5.ts
@@ -0,0 +1,2 @@
+var x: { [key: string]: number } | null = null;
+console.log(x);
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type5.ts.result b/src/MapleFE/test/typescript/unit_tests/union-type5.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..e586c3fc840d25af28e83b6ae36cd8bd8b63b4ea
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type5.ts.result
@@ -0,0 +1,7 @@
+Matched 17 tokens.
+Matched 24 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=null
+== Sub Tree ==
+console.log(x)
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type6.ts b/src/MapleFE/test/typescript/unit_tests/union-type6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..28b76547e39b54d70539067d76c5a4c055d80c43
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type6.ts
@@ -0,0 +1,6 @@
+var s: string | number | undefined = 123;
+console.log(s);
+s = "abc";
+console.log(s);
+s = undefined;
+console.log(s);
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type6.ts.result b/src/MapleFE/test/typescript/unit_tests/union-type6.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ba46d8f7a64b4ecd4d111c9ad498efe876a7d021
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type6.ts.result
@@ -0,0 +1,19 @@
+Matched 11 tokens.
+Matched 18 tokens.
+Matched 22 tokens.
+Matched 29 tokens.
+Matched 33 tokens.
+Matched 40 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: s=123
+== Sub Tree ==
+console.log(s)
+== Sub Tree ==
+s Assign "abc"
+== Sub Tree ==
+console.log(s)
+== Sub Tree ==
+s Assign undefined
+== Sub Tree ==
+console.log(s)
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type7.ts b/src/MapleFE/test/typescript/unit_tests/union-type7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..596d4563ff945c39883b00ad48c05ba4c1e4e7b0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type7.ts
@@ -0,0 +1 @@
+type AType = (new() => Error) | Error;
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type7.ts.result b/src/MapleFE/test/typescript/unit_tests/union-type7.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..87d45a853db99d735fbbb05f038519ed1238fdd9
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type7.ts.result
@@ -0,0 +1,4 @@
+Matched 13 tokens.
+============= Module ===========
+== Sub Tree ==
+ type AType = union  = new () ->  | Error
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type8.ts b/src/MapleFE/test/typescript/unit_tests/union-type8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2e43c4f8d1a1009015f18bbde2c41049fba3a7cc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type8.ts
@@ -0,0 +1,9 @@
+interface IFace {
+  num: number;
+}
+
+interface IFace2<
+T extends null | IFace,
+> extends IFace {
+  prop: T;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/union-type8.ts.result b/src/MapleFE/test/typescript/unit_tests/union-type8.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0275638610cec08579102cb7492bf5ced8c1c685
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/union-type8.ts.result
@@ -0,0 +1,7 @@
+Matched 8 tokens.
+Matched 26 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: IFace {num }
+== Sub Tree ==
+ts_interface: IFace2<T,> {prop }
diff --git a/src/MapleFE/test/typescript/unit_tests/utility-type-instancetype.ts b/src/MapleFE/test/typescript/unit_tests/utility-type-instancetype.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ca53fcb7d1ff15dc2284e19987196f87b6b34a00
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/utility-type-instancetype.ts
@@ -0,0 +1,10 @@
+class Klass {
+  x: number = 33;
+  public getNum() {
+    return this.x >> 2;
+  }
+}
+
+class Klass2 {
+  map: Map<number, InstanceType<typeof Klass>> | undefined = undefined;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/utility-type-instancetype.ts.result b/src/MapleFE/test/typescript/unit_tests/utility-type-instancetype.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..06c16c8b85c9a43a8f376755c90bec74f4748f3f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/utility-type-instancetype.ts.result
@@ -0,0 +1,25 @@
+Matched 23 tokens.
+Matched 43 tokens.
+============= Module ===========
+== Sub Tree ==
+class  Klass
+  Fields: 
+    x=33
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+    func  getNum()  throws: 
+      return this.x Shr 2
+  LocalClasses: 
+  LocalInterfaces: 
+
+== Sub Tree ==
+class  Klass2
+  Fields: 
+    map=undefined
+  Instance Initializer: 
+  Constructors: 
+  Methods: 
+  LocalClasses: 
+  LocalInterfaces: 
+
diff --git a/src/MapleFE/test/typescript/unit_tests/utility-type-nonnullable.ts b/src/MapleFE/test/typescript/unit_tests/utility-type-nonnullable.ts
new file mode 100644
index 0000000000000000000000000000000000000000..55b36eb5650f6a5daca29469a1d2d6c019c868f1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/utility-type-nonnullable.ts
@@ -0,0 +1,7 @@
+interface Interf {
+  prop: {
+    pos: Object;
+  };
+}
+
+type TYPE = NonNullable<Interf["prop"]["pos"]>;
diff --git a/src/MapleFE/test/typescript/unit_tests/utility-type-nonnullable.ts.result b/src/MapleFE/test/typescript/unit_tests/utility-type-nonnullable.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..733641e3852fb19e3bc1d2aa320a4f0062cd5a02
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/utility-type-nonnullable.ts.result
@@ -0,0 +1,7 @@
+Matched 13 tokens.
+Matched 27 tokens.
+============= Module ===========
+== Sub Tree ==
+ts_interface: Interf {prop }
+== Sub Tree ==
+ type TYPE = NonNullable<Interf["prop"]["pos"]>
diff --git a/src/MapleFE/test/typescript/unit_tests/utility-type-parameters.ts b/src/MapleFE/test/typescript/unit_tests/utility-type-parameters.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0f9ef082bc38ba80af812d4931a219eda88213cc
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/utility-type-parameters.ts
@@ -0,0 +1,6 @@
+var list = { f1: 0, f2: "abc" };
+function f(...list: any[]) {}
+function func(t: Parameters<typeof f>[0]): Parameters<typeof f>[1] {
+  return list.f2 + t;
+}
+console.log(func(123));
diff --git a/src/MapleFE/test/typescript/unit_tests/utility-type-parameters.ts.result b/src/MapleFE/test/typescript/unit_tests/utility-type-parameters.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..5ba7c640a1851e4c661b4cdc47ce455ce072921d
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/utility-type-parameters.ts.result
@@ -0,0 +1,16 @@
+Matched 13 tokens.
+Matched 25 tokens.
+Matched 57 tokens.
+Matched 67 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: list= {f1:0, f2:"abc"}
+== Sub Tree ==
+func  f(...list)  throws: 
+
+== Sub Tree ==
+func  func(t)  throws: 
+  return list.f2 Add t
+
+== Sub Tree ==
+console.log(func(123))
diff --git a/src/MapleFE/test/typescript/unit_tests/utility-type-parameters2.ts b/src/MapleFE/test/typescript/unit_tests/utility-type-parameters2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..730ac18acb3457c414ac6ada64924b34c909c954
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/utility-type-parameters2.ts
@@ -0,0 +1,12 @@
+function func(n: number, s: string): string {
+  return n + s;
+}
+
+function wrapper(
+  n: Parameters<typeof func>[0],
+  s: Parameters<typeof func>[1] | undefined
+): string {
+  return func(n, s!);
+}
+
+console.log(wrapper(123, "abc"));
diff --git a/src/MapleFE/test/typescript/unit_tests/utility-type-parameters2.ts.result b/src/MapleFE/test/typescript/unit_tests/utility-type-parameters2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..a2f0036f2bb1f283383ebcc2a3030ea1d2abc5df
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/utility-type-parameters2.ts.result
@@ -0,0 +1,14 @@
+Matched 20 tokens.
+Matched 60 tokens.
+Matched 72 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func(n,s)  throws: 
+  return n Add s
+
+== Sub Tree ==
+func  wrapper(n,s)  throws: 
+  return func(n,s!)
+
+== Sub Tree ==
+console.log(wrapper(123,"abc"))
diff --git a/src/MapleFE/test/typescript/unit_tests/values.ts b/src/MapleFE/test/typescript/unit_tests/values.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a57009b4ba6947604df116a233182bcfd0f6ab95
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/values.ts
@@ -0,0 +1 @@
+export const values = [{ brand: "BMW", model: "325" }, {}];
diff --git a/src/MapleFE/test/typescript/unit_tests/values.ts.result b/src/MapleFE/test/typescript/unit_tests/values.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..19f5259985cf2198eeb7e6f60eb2f36ff9ccc5f2
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/values.ts.result
@@ -0,0 +1,4 @@
+Matched 19 tokens.
+============= Module ===========
+== Sub Tree ==
+export {js_const Decl: values=[ {brand:"BMW", model:"325"}, {}]} 
diff --git a/src/MapleFE/test/typescript/unit_tests/var-as-prop-name.ts b/src/MapleFE/test/typescript/unit_tests/var-as-prop-name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bd97f5cab3b2af51e3f45bca1c7320496a53b5ff
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-as-prop-name.ts
@@ -0,0 +1,10 @@
+const obj = { 
+  else() {
+    return this;
+  },
+  var() {
+    console.log("var");
+  }
+}
+
+obj.else().var();
diff --git a/src/MapleFE/test/typescript/unit_tests/var-as-prop-name.ts.result b/src/MapleFE/test/typescript/unit_tests/var-as-prop-name.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7fcef6b23a7beaf3d03a4115b40cfebcf5da9d1f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-as-prop-name.ts.result
@@ -0,0 +1,11 @@
+Matched 26 tokens.
+Matched 36 tokens.
+============= Module ===========
+== Sub Tree ==
+js_const Decl: obj= {else:func  else()  throws: 
+  return this
+, var:func  var()  throws: 
+  console.log("var")
+}
+== Sub Tree ==
+obj.else().var()
diff --git a/src/MapleFE/test/typescript/unit_tests/var-const.ts b/src/MapleFE/test/typescript/unit_tests/var-const.ts
new file mode 100644
index 0000000000000000000000000000000000000000..70ad5911b8e2534198fcd0e5afeb2f8df39919b7
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-const.ts
@@ -0,0 +1,10 @@
+function foo(j: number): number {
+  {
+    const i: number = 4;
+    j += 10 * i;
+  }
+  var i = 8;
+  return i + j;
+}
+
+console.log(foo(5));
diff --git a/src/MapleFE/test/typescript/unit_tests/var-const.ts.result b/src/MapleFE/test/typescript/unit_tests/var-const.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..ae3c888bc2c46dc035ef4e6b1eea66c280e10644
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-const.ts.result
@@ -0,0 +1,13 @@
+Matched 36 tokens.
+Matched 46 tokens.
+============= Module ===========
+== Sub Tree ==
+func  foo(j)  throws: 
+  js_const Decl: i=4
+  j AddAssign 10 Mul i
+
+  js_var Decl: i=8
+  return i Add j
+
+== Sub Tree ==
+console.log(foo(5))
diff --git a/src/MapleFE/test/typescript/unit_tests/var-dup.ts b/src/MapleFE/test/typescript/unit_tests/var-dup.ts
new file mode 100644
index 0000000000000000000000000000000000000000..935641621371303cef7f1dbeb0077525d6903beb
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-dup.ts
@@ -0,0 +1,14 @@
+function foo(a: number) {
+  var sum = 0;
+  for (var i = 0; i < a; i++) {
+    var i = 4;
+    for (var i = 0; i < a; i++) {
+      let i = 8;
+      sum += i;
+    }
+  }
+
+  return sum;
+}
+
+console.log(foo(10));
diff --git a/src/MapleFE/test/typescript/unit_tests/var-dup.ts.result b/src/MapleFE/test/typescript/unit_tests/var-dup.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..8eb5ad8a69fec678a79cafa4625152bb409834b1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-dup.ts.result
@@ -0,0 +1,17 @@
+Matched 63 tokens.
+Matched 73 tokens.
+============= Module ===========
+== Sub Tree ==
+func  foo(a)  throws: 
+  js_var Decl: sum=0
+  for ( )
+    js_var Decl: i=4
+    for ( )
+      js_let Decl: i=8
+      sum AddAssign i
+
+
+  return sum
+
+== Sub Tree ==
+console.log(foo(10))
diff --git a/src/MapleFE/test/typescript/unit_tests/var-in-function.ts b/src/MapleFE/test/typescript/unit_tests/var-in-function.ts
new file mode 100644
index 0000000000000000000000000000000000000000..71f0660cbef5dac84cfbdaa37e3584ccf16bcd47
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-in-function.ts
@@ -0,0 +1,7 @@
+function func() {
+  const res = {
+    pos: [0.5, -0.5, 0],
+  };
+  return res;
+}
+console.log(func());
diff --git a/src/MapleFE/test/typescript/unit_tests/var-in-function.ts.result b/src/MapleFE/test/typescript/unit_tests/var-in-function.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..02502c6870f4d9eb02ef83cd7aa344191ed7e352
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-in-function.ts.result
@@ -0,0 +1,10 @@
+Matched 25 tokens.
+Matched 34 tokens.
+============= Module ===========
+== Sub Tree ==
+func  func()  throws: 
+  js_const Decl: res= {pos:[0.5,-0.5,0]}
+  return res
+
+== Sub Tree ==
+console.log(func())
diff --git a/src/MapleFE/test/typescript/unit_tests/var-scope.ts b/src/MapleFE/test/typescript/unit_tests/var-scope.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7ccfeb6eabeb9aabd71aa4cc2cd5aeacbf3618cd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-scope.ts
@@ -0,0 +1,16 @@
+var i: number = 5;
+
+function foo(j: number): number {
+  i = j;
+  {
+    let i: number = 2;
+    j += 100 * i;
+  }
+  {
+    let i: number = 4;
+    j += 10 * i;
+  }
+  return i + j;
+}
+
+console.log(foo(5));
diff --git a/src/MapleFE/test/typescript/unit_tests/var-scope.ts.result b/src/MapleFE/test/typescript/unit_tests/var-scope.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..f8c807fa7c41397190bc3766d0d85e958374086f
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-scope.ts.result
@@ -0,0 +1,19 @@
+Matched 7 tokens.
+Matched 57 tokens.
+Matched 67 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: i=5
+== Sub Tree ==
+func  foo(j)  throws: 
+  i Assign j
+  js_let Decl: i=2
+  j AddAssign 100 Mul i
+
+  js_let Decl: i=4
+  j AddAssign 10 Mul i
+
+  return i Add j
+
+== Sub Tree ==
+console.log(foo(5))
diff --git a/src/MapleFE/test/typescript/unit_tests/var-use-first.ts b/src/MapleFE/test/typescript/unit_tests/var-use-first.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0c3d35b44361aef9696cc25634c9903d70819be
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-use-first.ts
@@ -0,0 +1,7 @@
+function foo(j: number): number {
+  i = j;
+  var i: number = 4;
+  return i + j;
+}
+
+console.log(foo(5));
diff --git a/src/MapleFE/test/typescript/unit_tests/var-use-first.ts.result b/src/MapleFE/test/typescript/unit_tests/var-use-first.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0a4550222ae6c27478f607b1c206fcdc04582983
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var-use-first.ts.result
@@ -0,0 +1,11 @@
+Matched 27 tokens.
+Matched 37 tokens.
+============= Module ===========
+== Sub Tree ==
+func  foo(j)  throws: 
+  i Assign j
+  js_var Decl: i=4
+  return i Add j
+
+== Sub Tree ==
+console.log(foo(5))
diff --git a/src/MapleFE/test/typescript/unit_tests/var.ts b/src/MapleFE/test/typescript/unit_tests/var.ts
new file mode 100644
index 0000000000000000000000000000000000000000..370d5d30f71af1090875871aba51068550bc39bf
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var.ts
@@ -0,0 +1,2 @@
+var a: number = 1;
+console.log(a);
diff --git a/src/MapleFE/test/typescript/unit_tests/var.ts.result b/src/MapleFE/test/typescript/unit_tests/var.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..c9c995c9ef89f05aed1a00e3bf818a13d1da5eda
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/var.ts.result
@@ -0,0 +1,7 @@
+Matched 7 tokens.
+Matched 14 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: a=1
+== Sub Tree ==
+console.log(a)
diff --git a/src/MapleFE/test/typescript/unit_tests/void-zero.ts b/src/MapleFE/test/typescript/unit_tests/void-zero.ts
new file mode 100644
index 0000000000000000000000000000000000000000..96176e42e8c0e3152540dd449059e5618a50aad1
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/void-zero.ts
@@ -0,0 +1,3 @@
+var x: number | undefined = void 0;
+console.log(x);
+console.log(typeof x);
diff --git a/src/MapleFE/test/typescript/unit_tests/void-zero.ts.result b/src/MapleFE/test/typescript/unit_tests/void-zero.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..7debc43dd58ea3dda242c7f773be3a7ad2dbda04
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/void-zero.ts.result
@@ -0,0 +1,10 @@
+Matched 10 tokens.
+Matched 17 tokens.
+Matched 25 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=void
+== Sub Tree ==
+console.log(x)
+== Sub Tree ==
+console.log( typeof x)
diff --git a/src/MapleFE/test/typescript/unit_tests/void-zero2.ts b/src/MapleFE/test/typescript/unit_tests/void-zero2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..caf1ac79394882cf39ce65dae45dc54d3eed14d0
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/void-zero2.ts
@@ -0,0 +1,6 @@
+var x: number | undefined = void 0;
+console.log(x);
+console.log(typeof x);
+x = 123;
+console.log(x);
+console.log(typeof x);
diff --git a/src/MapleFE/test/typescript/unit_tests/void-zero2.ts.result b/src/MapleFE/test/typescript/unit_tests/void-zero2.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..0a400cde2108a958f4bf5259e47fb18b0f84c5cd
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/void-zero2.ts.result
@@ -0,0 +1,19 @@
+Matched 10 tokens.
+Matched 17 tokens.
+Matched 25 tokens.
+Matched 29 tokens.
+Matched 36 tokens.
+Matched 44 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: x=void
+== Sub Tree ==
+console.log(x)
+== Sub Tree ==
+console.log( typeof x)
+== Sub Tree ==
+x Assign 123
+== Sub Tree ==
+console.log(x)
+== Sub Tree ==
+console.log( typeof x)
diff --git a/src/MapleFE/test/typescript/unit_tests/while-stmt.ts b/src/MapleFE/test/typescript/unit_tests/while-stmt.ts
new file mode 100644
index 0000000000000000000000000000000000000000..828da50719d0e1ccbef4dc4ba7a2eac2ce8d5161
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/while-stmt.ts
@@ -0,0 +1,6 @@
+var k: number = 1;
+while (k < 10) {
+  console.log(k);
+  if (k == 8) break;
+  k++;
+}
diff --git a/src/MapleFE/test/typescript/unit_tests/while-stmt.ts.result b/src/MapleFE/test/typescript/unit_tests/while-stmt.ts.result
new file mode 100644
index 0000000000000000000000000000000000000000..6364c9367e427b8de5e1aa50ff47e940ce2b0d83
--- /dev/null
+++ b/src/MapleFE/test/typescript/unit_tests/while-stmt.ts.result
@@ -0,0 +1,15 @@
+Matched 7 tokens.
+Matched 33 tokens.
+============= Module ===========
+== Sub Tree ==
+js_var Decl: k=1
+== Sub Tree ==
+while k LT 10  console.log(k)
+  cond-branch cond:k EQ 8
+  true branch :
+    break:
+  false branch :
+
+  k Inc
+
+
diff --git a/src/MapleFE/autogen/include/expr_gen.h b/src/MapleFE/tools/obfuscate/include/obfuscate.h
similarity index 47%
rename from src/MapleFE/autogen/include/expr_gen.h
rename to src/MapleFE/tools/obfuscate/include/obfuscate.h
index cef6a1a7c20e9013cae0d8cb1a79a24528a4e20c..63574ba6d02657eb5293605a36236e4a14374fe3 100644
--- a/src/MapleFE/autogen/include/expr_gen.h
+++ b/src/MapleFE/tools/obfuscate/include/obfuscate.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved.
 *
 * OpenArkFE is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
@@ -12,29 +12,41 @@
 * FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PSL v2 for more details.
 */
-////////////////////////////////////////////////////////////////////////
-//                     Expr Generation                                //
-////////////////////////////////////////////////////////////////////////
 
-#ifndef __EXPR_GEN_H__
-#define __EXPR_GEN_H__
+//////////////////////////////////////////////////////////////////////////////////////////////
+//                This is the interface to translate AST to C++
+//////////////////////////////////////////////////////////////////////////////////////////////
 
-#include "base_gen.h"
-#include "all_supported.h"
+#ifndef __OBFUSCATE_HEADER__
+#define __OBFUSCATE_HEADER__
+
+#include "astopt.h"
+#include "ast_handler.h"
+#include "ast_module.h"
 
 namespace maplefe {
 
-class ExprGen : public BaseGen {
+class Obfuscate : public AstOpt {
+private:
+  AST_Handler *mASTHandler;
+  unsigned     mFlags;
+  unsigned     mIndexImported;
+
 public:
-  ExprGen(const char *dfile, const char *hfile, const char *cfile)
-      : BaseGen(dfile, hfile, cfile) {}
-  ~ExprGen(){}
+  explicit Obfuscate(AST_Handler *h, unsigned flags) :
+    AstOpt(h, flags),
+    mASTHandler(h),
+    mFlags(flags),
+    mIndexImported(0) {}
+  ~Obfuscate() = default;
 
-  void Generate();
-  void GenCppFile();
-  void GenHeaderFile();
+  void EmitTS();
+  bool LoadImportedModules();
+
+  // return 0 if successful
+  // return non-zero if failed
+  int ProcessAST();
 };
 
 }
-
 #endif
diff --git a/src/MapleFE/tools/obfuscate/src/main.cpp b/src/MapleFE/tools/obfuscate/src/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0865f8545ed5116743448c3bb710b7e33cb9289a
--- /dev/null
+++ b/src/MapleFE/tools/obfuscate/src/main.cpp
@@ -0,0 +1,109 @@
+/*
+* Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2022] Tencent. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <sstream>
+#include <fstream>
+#include <iterator>
+#include "gen_astload.h"
+#include "ast_handler.h"
+#include "obfuscate.h"
+
+static void help() {
+  std::cout << "obfuscate a.ast[,b.ast] [options]:" << std::endl;
+  std::cout << "   --out=x.ts       : ts output file" << std::endl;
+  std::cout << "   --help           : print this help" << std::endl;
+  std::cout << "   --trace=n        : Emit trace with 4-bit combo levels 1...15" << std::endl;
+  std::cout << "           1        : Emit ast tree visits" << std::endl;
+  std::cout << "           2        : Emit graph" << std::endl;
+  std::cout << "   --emit-ts-only   : Emit ts code only" << std::endl;
+  std::cout << "   --emit-ts        : Emit ts code" << std::endl;
+  std::cout << "   --format-cpp     : Format cpp" << std::endl;
+  std::cout << "   --no-imported    : Do not process the imported modules" << std::endl;
+  std::cout << "default out name uses the first input name: a.cpp" << std::endl;
+}
+
+int main (int argc, char *argv[]) {
+  if (argc == 1 || (!strncmp(argv[1], "--help", 6) && (strlen(argv[1]) == 6))) {
+    help();
+    exit(-1);
+  }
+
+  unsigned flags;
+  // one or more input .ast files separated by ','
+  const char *inputname = argv[1];
+  // output .ast file
+  const char *outputname = nullptr;
+
+  // Parse the argument
+  for (unsigned i = 2; i < argc; i++) {
+    if (!strncmp(argv[i], "--trace=", 8)) {
+      int val = atoi(argv[i] + 8);
+      if (val < 1 || val > 15) {
+        help();
+        exit(-1);
+      }
+      flags |= val;
+    } else if (!strncmp(argv[i], "--emit-ts-only", 14)) {
+      flags |= maplefe::FLG_emit_ts_only;
+    } else if (!strncmp(argv[i], "--emit-ts", 9)) {
+      flags |= maplefe::FLG_emit_ts;
+    } else if (!strncmp(argv[i], "--format-cpp", 12)) {
+      flags |= maplefe::FLG_format_cpp;
+    } else if (!strncmp(argv[i], "--no-imported", 13)) {
+      flags |= maplefe::FLG_no_imported;
+    } else if (!strncmp(argv[i], "--in=", 5)) {
+      inputname = argv[i]+5;
+    } else if (!strncmp(argv[i], "--out=", 6)) {
+      outputname = argv[i]+6;
+    } else {
+      std::cerr << "unknown option " << argv[i] << std::endl;
+      exit(-1);
+    }
+  }
+
+  // input ast files
+  std::vector<std::string> inputfiles;
+  if (inputname) {
+    std::stringstream ss;
+    ss.str(inputname);
+    std::string item;
+    while (std::getline(ss, item, ',')) {
+      // std::cout << "item " << item << " xxx"<< std::endl;
+      inputfiles.push_back(item);
+    }
+  }
+
+  unsigned trace = (flags & maplefe::FLG_trace);
+  maplefe::AST_Handler handler(trace);
+  for (auto astfile: inputfiles) {
+    std::ifstream input(astfile, std::ifstream::binary);
+    input >> std::noskipws;
+    std::istream_iterator<uint8_t> s(input), e;
+    maplefe::AstBuffer vec(s, e);
+    maplefe::AstLoad loadAst;
+    maplefe::ModuleNode *mod = loadAst.LoadFromAstBuf(vec);
+    // add mod to the vector
+    while(mod) {
+      handler.AddModule(mod);
+      mod = loadAst.Next();
+    }
+  }
+
+  maplefe::Obfuscate *obfuscate = new maplefe::Obfuscate(&handler, flags);
+  int res = obfuscate->ProcessAST();
+
+  return res;
+}
diff --git a/src/MapleFE/tools/obfuscate/src/obfuscate.cpp b/src/MapleFE/tools/obfuscate/src/obfuscate.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cec38cbc9cd61b600310f72967651b849431cc77
--- /dev/null
+++ b/src/MapleFE/tools/obfuscate/src/obfuscate.cpp
@@ -0,0 +1,168 @@
+/*
+* Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved.
+* Copyright (C) [2022] Tencent. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <queue>
+#include <sstream>
+#include <fstream>
+#include <iterator>
+#include <cstdlib>
+
+#include "obfuscate.h"
+#include "ast_handler.h"
+#include "gen_astdump.h"
+#include "gen_astgraph.h"
+#include "gen_aststore.h"
+#include "gen_astload.h"
+#include "cpp_definition.h"
+#include "cpp_declaration.h"
+#include "a2c_util.h"
+
+namespace maplefe {
+
+bool Obfuscate::LoadImportedModules() {
+  std::queue<std::string> queue;
+  for (HandlerIndex i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+    ImportedFiles imported(module);
+    imported.VisitTreeNode(module);
+    for(const auto &e: imported.mFilenames)
+      queue.push(e);
+  }
+
+  bool err = false;
+  while(!queue.empty()) {
+    std::string filename = queue.front();
+    queue.pop();
+    if(mASTHandler->GetHandlerIndex(filename.c_str()) == HandlerNotFound) {
+      std::ifstream input(filename, std::ifstream::binary);
+      if(input.fail()) {
+        std::cerr << "Error: File " << filename << " not found for imported module" << std::endl;
+        err = true;
+        continue;
+      }
+      input >> std::noskipws;
+      std::istream_iterator<uint8_t> s(input), e;
+      maplefe::AstBuffer vec(s, e);
+      maplefe::AstLoad loadAst;
+      maplefe::ModuleNode *mod = loadAst.LoadFromAstBuf(vec);
+      // add mod to the vector
+      while(mod) {
+        mASTHandler->AddModule(mod);
+        ImportedFiles imported(mod);
+        imported.VisitTreeNode(mod);
+        for(const auto &e: imported.mFilenames)
+          queue.push(e);
+        mod = loadAst.Next();
+      }
+    }
+  }
+  return err;
+}
+
+// starting point of AST
+int Obfuscate::ProcessAST() {
+  mIndexImported = GetModuleNum();
+
+  // load all imported modules
+  if (!(mFlags & FLG_no_imported)) {
+    if (LoadImportedModules()) {
+      return 1;
+    }
+  }
+
+  // loop through module handlers
+  for (HandlerIndex i = 0; i < GetModuleNum(); i++) {
+    Module_Handler *handler = mASTHandler->GetModuleHandler(i);
+    ModuleNode *module = handler->GetASTModule();
+
+    if (mFlags & FLG_trace_1) {
+      std::cout << "============= in ProcessAST ===========" << std::endl;
+      std::cout << "srcLang : " << module->GetSrcLangString() << std::endl;
+
+      for(unsigned k = 0; k < module->GetTreesNum(); k++) {
+        TreeNode *tnode = module->GetTree(k);
+        if (mFlags & FLG_trace_1) {
+          tnode->Dump(0);
+          std::cout << std::endl;
+        }
+      }
+    }
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= AstGraph ===========" << std::endl;
+      AstGraph graph(module);
+      graph.DumpGraph("After LoadFromAstBuf()", &std::cout);
+    }
+  }
+
+  // build dependency of modules
+  PreprocessModules();
+
+  // loop through module handlers in import/export dependency order
+  for (auto handler: mHandlersInOrder) {
+    ModuleNode *module = handler->GetASTModule();
+
+    // basic analysis
+    handler->BasicAnalysis();
+
+    if (mFlags & FLG_trace_2) {
+      std::cout << "============= After BasicAnalysis ===========" << std::endl;
+      for(unsigned k = 0; k < module->GetTreesNum(); k++) {
+        TreeNode *tnode = module->GetTree(k);
+        if (mFlags & FLG_trace_1) {
+          tnode->Dump(0);
+          std::cout << std::endl;
+        }
+      }
+      AstGraph graph(module);
+      graph.DumpGraph("After BasicAnalysis()", &std::cout);
+    }
+  }
+
+  if (mFlags & FLG_trace_3) {
+    gStringPool.Dump();
+  }
+
+  gStringPool.SetAltStrIdxMap();
+
+  if (mFlags & FLG_trace_3) {
+    gStringPool.Dump();
+    gStringPool.DumpAlt();
+  }
+
+  gStringPool.SetUseAltStr(true);
+
+  for (auto handler: mHandlersInOrder) {
+    ModuleNode *module = handler->GetASTModule();
+
+    std::cout << "============= Emitter ===========" << std::endl;
+    maplefe::Emitter emitter(handler);
+    std::string code = emitter.Emit("Convert AST to TypeScript code");
+
+    // Emit to file
+    std::string of_name(module->GetFilename());
+    of_name += ".obf";
+    std::ofstream ofs;
+    ofs.open(of_name.c_str(), std::ofstream::out);
+    ofs << code;
+    ofs.close();
+  }
+
+  return 0;
+}
+
+} // namespace maplefe
diff --git a/src/MapleFE/typescript/Makefile b/src/MapleFE/typescript/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..266eec091a2e64f82189cca8c5f43e40f0207878
--- /dev/null
+++ b/src/MapleFE/typescript/Makefile
@@ -0,0 +1,26 @@
+# Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#  http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+include ../Makefile.in
+
+TARGS = ts2cpp
+
+$(TARGS):
+	$(MAKE) -C src
+
+clean:
+	rm -rf $(BUILDDIR)/typescript
+
+.PHONY: $(TARGS)
+
diff --git a/src/MapleFE/java/local_var.spec b/src/MapleFE/typescript/attr.spec
similarity index 41%
rename from src/MapleFE/java/local_var.spec
rename to src/MapleFE/typescript/attr.spec
index 3c7d8ac3c032e56b8eb60d2abe453cf12aa4869c..a632ede282f8dc13a14de62879ffafb1afacd429 100644
--- a/src/MapleFE/java/local_var.spec
+++ b/src/MapleFE/typescript/attr.spec
@@ -12,29 +12,29 @@
 # See the Mulan PSL v2 for more details.
 #
 ###################################################################################
-# This file defines the Java Local Variable declaration.
+# This file defines the Attribute, Modifier, or any other terms which are used
+# to describe some features of certian syntax component.
 #
+# The keyword duplex is defined as <"keyword", AttributeId>. The AttributeId is defined
+# in shared/supported_attributes.def and included in shared/supported.h. The 'keyword'
+# is the keyword in a language defining that specific attribute.
 ###################################################################################
 
-####include "type.spec"
 
-###rule VariableModifier: (one of) Annotation final
-rule VariableModifier: "final"
+STRUCT Attribute : (("abstract", abstract),
+                    ("const", const),
+                    ("volatile", volatile),
+                    ("final", final),
+                    ("native", native),
+                    ("private", private),
+                    ("protected", protected),
+                    ("public", public),
+                    ("readonly", readonly),
+                    ("static", static),
+                    ("strictfp", strictfp),
+                    ("default", default),
+                    ("get", getter),
+                    ("set", setter),
+                    ("async", async),
+                    ("synchronized", synchronized))
 
-#rule VariableDeclarator : VariableDeclaratorId + ZEROORONE('=' + VariableInitializer)
-rule VariableDeclarator : VariableDeclaratorId
-rule VariableDeclaratorList : VariableDeclarator + ZEROORMORE(',' + VariableDeclarator)
-
-###rule VariableDeclaratorId : Identifier [Dims]
-rule VariableDeclaratorId : Identifier
-
-#rule UnannPrimitiveType : ONEOF(NumericType, Boolean)
-rule UnannPrimitiveType : ONEOF("int", "boolean")
-
-###rule UnannType : ONEOF(UnannPrimitiveType, UnannReferenceType)
-rule UnannType : ONEOF(UnannPrimitiveType)
-
-###rule LocalVariableDeclaration : ZEROORMORE(VariableModifier) + UnannType + VariableDeclaratorList
-rule LocalVariableDeclaration : UnannType + VariableDeclaratorList
-
-rule LocalVariableDeclarationStatement : LocalVariableDeclaration + ';'
diff --git a/src/MapleFE/typescript/identifier.spec b/src/MapleFE/typescript/identifier.spec
new file mode 100644
index 0000000000000000000000000000000000000000..5723b480b3cd59e04d86d6d935f9bd949971c926
--- /dev/null
+++ b/src/MapleFE/typescript/identifier.spec
@@ -0,0 +1,20 @@
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#  http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+# An identifier is an unlimited-length sequence of Java letters and Java digits, the
+# first of which must be a Java letter
+#
+rule JavaChar : ONEOF(CHAR, '_' , '$')
+rule CharOrDigit : ONEOF(JavaChar, DIGIT)
+rule Identifier : ONEOF("no-default-lib",
+                        JavaChar + ZEROORMORE(CharOrDigit))
diff --git a/src/MapleFE/typescript/include/lang_builtin.def b/src/MapleFE/typescript/include/lang_builtin.def
new file mode 100644
index 0000000000000000000000000000000000000000..791452525da5c9d65a88608d27840c712bfd885e
--- /dev/null
+++ b/src/MapleFE/typescript/include/lang_builtin.def
@@ -0,0 +1,66 @@
+// Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved.
+//
+// OpenArkFE is licensed under the Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+//
+//  http://license.coscl.org.cn/MulanPSL2
+//
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+// FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+//
+
+// refer to docs/builtin-constructors.md
+
+// javascript builtin object types
+BUILTIN(AggregateError)
+BUILTIN(Array)
+BUILTIN(ArrayBuffer)
+BUILTIN(AsyncFunction)
+BUILTIN(BigInt64Array)
+BUILTIN(BigUint64Array)
+BUILTIN(Boolean)
+BUILTIN(DataView)
+BUILTIN(Date)
+BUILTIN(Error)
+BUILTIN(EvalError)
+BUILTIN(FinalizationRegistry)
+BUILTIN(Float32Array)
+BUILTIN(Float64Array)
+BUILTIN(Function)
+BUILTIN(Generator)
+BUILTIN(GeneratorFunction)
+BUILTIN(Int16Array)
+BUILTIN(Int32Array)
+BUILTIN(Int8Array)
+BUILTIN(InternalError (Mozilla only))
+BUILTIN(Map)
+BUILTIN(Number)
+BUILTIN(Object)
+BUILTIN(Promise)
+BUILTIN(Proxy)
+BUILTIN(RangeError)
+BUILTIN(ReferenceError)
+BUILTIN(RegExp)
+BUILTIN(Set)
+BUILTIN(SharedArrayBuffer)
+BUILTIN(String)
+BUILTIN(Symbol)
+BUILTIN(SyntaxError)
+BUILTIN(TypeError)
+BUILTIN(Uint16Array)
+BUILTIN(Uint32Array)
+BUILTIN(Uint8Array)
+BUILTIN(Uint8ClampedArray)
+BUILTIN(URIError)
+BUILTIN(WeakMap)
+BUILTIN(WeakRef)
+BUILTIN(WeakSet)
+
+// typescript builtin object types
+BUILTIN(Record)
+BUILTIN(Tuple)
+BUILTIN(Iterable)
+BUILTIN(Iterator)
diff --git a/src/MapleFE/typescript/include/lang_keywords.def b/src/MapleFE/typescript/include/lang_keywords.def
new file mode 100644
index 0000000000000000000000000000000000000000..096966bd2bc2907809676225773b9e3120929021
--- /dev/null
+++ b/src/MapleFE/typescript/include/lang_keywords.def
@@ -0,0 +1,122 @@
+// Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+//
+// OpenArkFE is licensed under the Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+//
+//  http://license.coscl.org.cn/MulanPSL2
+//
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+// FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+//
+
+LANGKEYWORD(boolean)
+LANGKEYWORD(number)
+LANGKEYWORD(string)
+LANGKEYWORD(symbol)
+LANGKEYWORD(unique)
+LANGKEYWORD(any)
+LANGKEYWORD(unknown)
+LANGKEYWORD(never)
+LANGKEYWORD(undefined)
+LANGKEYWORD(type)
+
+LANGKEYWORD(get)
+LANGKEYWORD(set)
+LANGKEYWORD(as)
+LANGKEYWORD(from)
+LANGKEYWORD(constructor)
+LANGKEYWORD(namespace)
+LANGKEYWORD(module)
+LANGKEYWORD(declare)
+
+LANGKEYWORD(break)
+LANGKEYWORD(do)
+LANGKEYWORD(in)
+LANGKEYWORD(is)
+LANGKEYWORD(of)
+LANGKEYWORD(typeof)
+LANGKEYWORD(keyof)
+LANGKEYWORD(infer)
+LANGKEYWORD(case)
+LANGKEYWORD(else)
+LANGKEYWORD(instanceof)
+LANGKEYWORD(var)
+LANGKEYWORD(catch)
+LANGKEYWORD(export)
+LANGKEYWORD(new)
+LANGKEYWORD(void)
+LANGKEYWORD(class)
+LANGKEYWORD(extends)
+LANGKEYWORD(return)
+LANGKEYWORD(while)
+LANGKEYWORD(const)
+LANGKEYWORD(finally)
+LANGKEYWORD(super)
+LANGKEYWORD(with)
+LANGKEYWORD(continue)
+LANGKEYWORD(for)
+LANGKEYWORD(switch)
+LANGKEYWORD(yield)
+LANGKEYWORD(debugger)
+LANGKEYWORD(function)
+// LANGKEYWORD(this)
+LANGKEYWORD(default)
+LANGKEYWORD(if)
+LANGKEYWORD(throw)
+LANGKEYWORD(delete)
+LANGKEYWORD(import)
+LANGKEYWORD(require)
+LANGKEYWORD(try)
+LANGKEYWORD(asserts)
+
+LANGKEYWORD(let)
+LANGKEYWORD(static)
+LANGKEYWORD(implements)
+LANGKEYWORD(protected)
+LANGKEYWORD(interface)
+LANGKEYWORD(private)
+LANGKEYWORD(public)
+LANGKEYWORD(abstract)
+
+LANGKEYWORD(readonly)
+
+LANGKEYWORD(enum)
+LANGKEYWORD(await)
+LANGKEYWORD(async)
+
+LANGKEYWORD(global)
+
+// Utility Types
+LANGKEYWORD(Partial)
+LANGKEYWORD(Required)
+LANGKEYWORD(Readonly)
+LANGKEYWORD(Record)
+LANGKEYWORD(Pick)
+LANGKEYWORD(Omit)
+LANGKEYWORD(Exclude)
+LANGKEYWORD(Extract)
+LANGKEYWORD(NonNullable)
+LANGKEYWORD(Parameters)
+LANGKEYWORD(ConstructorParameters)
+LANGKEYWORD(ReturnType)
+LANGKEYWORD(InstanceType)
+LANGKEYWORD(ThisParameterType)
+LANGKEYWORD(OmitThisParameter)
+LANGKEYWORD(ThisType)
+LANGKEYWORD(Uppercase)
+LANGKEYWORD(Lowercase)
+LANGKEYWORD(Capitalize)
+LANGKEYWORD(Uncapitalize)
+
+LANGKEYWORD(Error)
+LANGKEYWORD(toString)
+
+// extra
+
+LANGKEYWORD(console)
+LANGKEYWORD(log)
+
+LANGKEYWORD(null)
diff --git a/src/MapleFE/typescript/include/lang_spec.h b/src/MapleFE/typescript/include/lang_spec.h
new file mode 100644
index 0000000000000000000000000000000000000000..96aef8bf12195fd32df8cf8630e6beb6632f8c9a
--- /dev/null
+++ b/src/MapleFE/typescript/include/lang_spec.h
@@ -0,0 +1,68 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+/////////////////////////////////////////////////////////////////////////////////
+//            Language Specific Implementations                                //
+/////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __LANG_SPEC_H__
+#define __LANG_SPEC_H__
+
+#include "stringutil.h"
+#include "token.h"
+#include "lexer.h"
+#include "parser.h"
+
+namespace maplefe {
+
+class StringToValueImpl : public StringToValue {
+public:
+  float  StringToFloat(std::string &s);
+  double StringToDouble(std::string &s);
+  bool   StringToBool(std::string &s);
+  Char   StringToChar(std::string &s);
+  bool   StringIsNull(std::string &s);
+  const char* StringToString(std::string &);
+};
+
+extern LitData ProcessLiteral(LitId type, const char *str);
+
+////////////////////////////////////////////////////////////////////////////////////
+//                              Typescript Lexer
+////////////////////////////////////////////////////////////////////////////////////
+
+class TypescriptLexer : public Lexer {
+public:
+  bool CharIsSeparator(const char);
+
+  TempLitData* GetTempLit();
+  bool FindNextTLFormat(unsigned start, std::string& s, unsigned& end);
+  bool FindNextTLPlaceHolder(unsigned start, std::string& s, unsigned& end);
+  bool FindTripleSlash();
+};
+
+////////////////////////////////////////////////////////////////////////////////////
+//                              Typescript Parser
+////////////////////////////////////////////////////////////////////////////////////
+
+class TypescriptParser : public Parser {
+public:
+  TypescriptParser(const char *f) : Parser(f) {}
+  Token* GetRegExpr(Token *t);
+  bool TokenSplit(Token *);
+  bool TraverseASI(RuleTable*, AppealNode*, AppealNode *&);
+};
+
+}
+#endif
diff --git a/src/MapleFE/typescript/keyword.spec b/src/MapleFE/typescript/keyword.spec
new file mode 100644
index 0000000000000000000000000000000000000000..cbc04c0c4085bb06aed62e0ae3c951f539f7f4ec
--- /dev/null
+++ b/src/MapleFE/typescript/keyword.spec
@@ -0,0 +1,104 @@
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#  http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+##################################################################################
+# This file contains the keyword of a language. It doesn't clarify the semantics
+# of a keyword, which will be done by RULEs, i.e., the parser will check the keyword
+# while traversing the rule tables.
+#
+# The generated table of keywords are only used for
+#  (1) Parser to check while traversing rule tables
+#  (2) check the correctness of names so as not to conflict with keywords
+##################################################################################
+
+STRUCT KeyWord : ((boolean),
+                  (number),
+                  (string),
+                  (symbol),
+                  (unique),
+                  (any),
+                  (unknown),
+                  (never),
+                  (undefined),
+                  (type),
+
+                  (get),
+                  (set),
+                  (as),
+                  (from),
+                  (constructor),
+                  (namespace),
+                  (module),
+                  (declare),
+
+                  (break),
+                  (do),
+                  (in),
+                  (is),
+                  (of),
+                  (typeof),
+                  (keyof),
+                  (infer),
+                  (case),
+                  (else),
+                  (instanceof),
+                  (var),
+                  (catch),
+                  (export),
+                  (new),
+                  (void),
+                  (class),
+                  (extends),
+                  (return),
+                  (while),
+                  (const),
+                  (finally),
+                  (super),
+                  (with),
+                  (continue),
+                  (for),
+                  (switch),
+                  (yield),
+                  (debugger),
+                  (function),
+                  (this),
+                  (default),
+                  (if),
+                  (throw),
+                  (delete),
+                  (import),
+                  (require),
+                  (try),
+                  (asserts),
+
+#this part is for strict mode
+                  (let),
+                  (static),
+                  (implements),
+                  (protected),
+                  (interface),
+                  (private),
+                  (public),
+                  (abstract),
+
+                  (readonly),
+
+#this part is for future reserved
+                  (enum),
+                  (await),
+                  (async),
+
+                  (global),
+
+#this is for 'fake rule only'
+                  (this_is_for_fake_rule))
diff --git a/src/MapleFE/typescript/literal.spec b/src/MapleFE/typescript/literal.spec
new file mode 100644
index 0000000000000000000000000000000000000000..c2d61bb1213c8138ac01d449458ab29f0cba73b7
--- /dev/null
+++ b/src/MapleFE/typescript/literal.spec
@@ -0,0 +1,158 @@
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#  http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+# A literal is the source code representation of a value of a primitive type, the
+# String type, or the null type.
+#
+# NOTE: Make sure there is a 'rule Literal'. This is the official rule recognized
+#       by autogen.
+
+#########################################################################
+##                          Integer                                    ##
+#########################################################################
+
+### Decimal rules
+
+rule NonZeroDigit   : ONEOF('1', '2', '3', '4', '5', '6', '7', '8', '9')
+rule Underscores    : '_' + ZEROORMORE('_')
+rule Digit          : ONEOF('0', NonZeroDigit)
+rule DigitOrUnderscore : ONEOF(Digit, '_')
+rule DigitsAndUnderscores : DigitOrUnderscore + ZEROORMORE(DigitOrUnderscore)
+rule Digits         : ONEOF(Digit, Digit + ZEROORONE(DigitsAndUnderscores) + Digit)
+  attr.property.%2 : SecondTry
+
+rule DecimalNumeral : ONEOF('0', NonZeroDigit + ZEROORONE(Digits),
+                            NonZeroDigit + Underscores + Digits)
+
+### Hexadecimal rules
+
+rule HexDigit   : ONEOF('0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        'a', 'b', 'c', 'd', 'e', 'f',
+                        'A', 'B', 'C', 'D', 'E', 'F')
+rule HexDigitOrUnderscore : ONEOF(HexDigit, '_')
+rule HexDigitsAndUnderscores:HexDigitOrUnderscore + ZEROORMORE(HexDigitOrUnderscore)
+rule HexDigits  : ONEOF(HexDigit,
+                        HexDigit + ZEROORONE(HexDigitsAndUnderscores) + HexDigit)
+  attr.property.%2 : SecondTry
+rule HexNumeral : ONEOF("0x" + HexDigits, "0X" + HexDigits)
+
+### Octal rules
+
+rule OctalDigit   : ONEOF('0', '1', '2', '3', '4', '5', '6', '7')
+rule OctalDigitOrUnderscore : ONEOF(OctalDigit, '_')
+rule OctalDigitsAndUnderscores:OctalDigitOrUnderscore + ZEROORMORE(OctalDigitOrUnderscore)
+rule OctalDigits  : ONEOF(OctalDigit,
+                    OctalDigit + ZEROORONE(OctalDigitsAndUnderscores) + OctalDigit)
+  attr.property.%2 : SecondTry
+rule OctalNumeral : ONEOF('0' + OctalDigits, '0' + Underscores + OctalDigits)
+
+### Binary rules
+
+rule BinDigit   : ONEOF('0', '1')
+rule BinDigitOrUnderscore : ONEOF(BinDigit, '_')
+rule BinDigitsAndUnderscores:BinDigitOrUnderscore + ZEROORMORE(BinDigitOrUnderscore)
+rule BinDigits  : ONEOF(BinDigit,
+                        BinDigit + ZEROORONE(BinDigitsAndUnderscores) + BinDigit)
+  attr.property.%2 : SecondTry
+rule BinNumeral : ONEOF("0b" + BinDigits, "0B" + BinDigits)
+
+##########
+
+rule IntegerTypeSuffix : ONEOF('L', 'l')
+
+rule DecimalIntegerLiteral: DecimalNumeral + ZEROORONE(IntegerTypeSuffix)
+rule HexIntegerLiteral    : HexNumeral + ZEROORONE(IntegerTypeSuffix)
+rule OctalIntegerLiteral  : OctalNumeral + ZEROORONE(IntegerTypeSuffix)
+rule BinaryIntegerLiteral : BinNumeral + ZEROORONE(IntegerTypeSuffix)
+
+rule IntegerLiteral: ONEOF(DecimalIntegerLiteral,
+                           HexIntegerLiteral,
+                           OctalIntegerLiteral,
+                           BinaryIntegerLiteral)
+
+#########################################################################
+##                       Floating Point                                ##
+#########################################################################
+
+##### Decimal floating point literal
+
+rule Sign : ONEOF('+', '-')
+rule FloatTypeSuffix : ONEOF('f', 'F', 'd', 'D')
+rule ExponentIndicator : ONEOF('e', 'E')
+rule SignedInteger : ZEROORONE(Sign) + Digits
+rule ExponentPart : ExponentIndicator + SignedInteger
+
+rule DecFPLiteral : ONEOF(Digits + '.' + ZEROORONE(Digits) + ZEROORONE(ExponentPart) + ZEROORONE(FloatTypeSuffix),
+                    '.'+Digits + ZEROORONE(ExponentPart) + ZEROORONE(FloatTypeSuffix),
+                    Digits + ExponentPart + ZEROORONE(FloatTypeSuffix),
+                    Digits + ZEROORONE(ExponentPart))
+
+####### Hex floating point literal
+
+rule BinaryExponentIndicator : ONEOF('p', 'P')
+rule BinaryExponent : BinaryExponentIndicator + SignedInteger
+rule HexSignificand : ONEOF(HexNumeral + ZEROORONE('.'),
+                            "0x" + ZEROORONE(HexDigits) + '.' + HexDigits,
+                            "0X" + ZEROORONE(HexDigits) + '.' + HexDigits)
+rule HexFPLiteral: HexSignificand + BinaryExponent + ZEROORONE(FloatTypeSuffix)
+
+######  Floating POint Literal
+
+rule FPLiteral : ONEOF(DecFPLiteral, HexFPLiteral)
+
+#########################################################################
+##                           Boolean                                   ##
+#########################################################################
+
+rule BooleanLiteral : ONEOF ("true", "false")
+
+#########################################################################
+##                           Character                                 ##
+## ESCAPE is a reserved rule in reserved.spec.                         ##
+#########################################################################
+
+# I decided to simplify the unicode escape a little bit. I don't want to
+# handle all odd cases.
+rule UnicodeEscape: '\' + 'u' + HEXDIGIT + HEXDIGIT + HEXDIGIT + HEXDIGIT
+rule RawInputCharacter : ONEOF(ASCII, ESCAPE, UTF8)
+rule SingleCharacter: ONEOF(UnicodeEscape, RawInputCharacter)
+
+rule OctalEscape : ONEOF('\' + '0', '\' + '1')
+rule EscapeSequence : ONEOF(ESCAPE, OctalEscape)
+rule CharacterLiteral : ''' + ONEOF(SingleCharacter, EscapeSequence) + '''
+
+#########################################################################
+##                           String                                    ##
+#########################################################################
+# The UnicodeEscape is limited from \u0000 to \u00ff.
+rule StringUnicodeEscape: '\' + 'u' + '0' + '0' + HEXDIGIT + HEXDIGIT
+rule SingleStringCharater: ONEOF(StringUnicodeEscape, RawInputCharacter, IRREGULAR_CHAR, '"')
+rule DoubleStringCharater: ONEOF(StringUnicodeEscape, RawInputCharacter, IRREGULAR_CHAR, ''')
+rule StringLiteral : ONEOF('"' + ZEROORMORE(DoubleStringCharater) + '"',
+                           ''' + ZEROORMORE(SingleStringCharater) + ''')
+
+#########################################################################
+##                           Null                                      ##
+#########################################################################
+
+rule NullLiteral : "null"
+
+#########################################################################
+##                           Literal                                   ##
+#########################################################################
+
+rule Literal : ONEOF(IntegerLiteral,
+                     FPLiteral,
+                     BooleanLiteral,
+                     StringLiteral,
+                     NullLiteral)
diff --git a/src/MapleFE/typescript/operator.spec b/src/MapleFE/typescript/operator.spec
new file mode 100644
index 0000000000000000000000000000000000000000..d09db223d3cdc7069e1300fde8861a08f6ff9b8d
--- /dev/null
+++ b/src/MapleFE/typescript/operator.spec
@@ -0,0 +1,79 @@
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#  http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+##########################################################################
+# The syntax of operator.spec contains two parts.
+#  1. The Keyword STRUCT defining the <keyword,opr> of all operations.
+#        keyword : the text defined in the language
+#        opr     : the standard Autogen defined operator.
+#                  See autogen/include/supported_operators.def
+#  2. The rule part, defining the language restrictions of each operator.
+##########################################################################
+
+# NOTE
+# Some languages could have one synatx belonging to both separator and operators.
+# eg., ':' in Java 8, it's both a separator colon and operator select.
+# We need avoid such duplication in .spec files.
+
+STRUCT Operator : (
+                    # Arithmetic
+                    ("+",    Add),
+                    ("-",    Sub),
+                    ("*",    Mul),
+                    ("/",    Div),
+                    ("%",    Mod),
+                    ("++",   Inc),
+                    ("--",   Dec),
+                    ("**",   Exp),
+                    ("??",   NullCoalesce),
+                    ("??=",  NullAssign),
+                    # Relation
+                    ("==",   EQ),
+                    ("!=",   NE),
+                    (">",    GT),
+                    ("<",    LT),
+                    (">=",   GE),
+                    ("<=",   LE),
+                    ("===",  StEq),
+                    ("!==",  StNe),
+                    # Bitwise
+                    ("&",    Band),
+                    ("|",    Bor),
+                    ("^",    Bxor),
+                    ("~",    Bcomp),
+                    # Shift
+                    ("<<",   Shl),
+                    (">>",   Shr),
+                    (">>>",  Zext),
+                    # Logical
+                    ("&&",   Land),
+                    ("||",   Lor),
+                    ("!",    Not),
+                    # Assign
+                    ("=",    Assign),
+                    ("+=",   AddAssign),
+                    ("-=",   SubAssign),
+                    ("*=",   MulAssign),
+                    ("/=",   DivAssign),
+                    ("%=",   ModAssign),
+                    ("<<=",  ShlAssign),
+                    (">>=",  ShrAssign),
+                    ("&=",   BandAssign),
+                    ("|=",   BorAssign),
+                    ("^=",   BxorAssign),
+                    (">>>=", ZextAssign),
+
+                    ("///",  TripleSlash),
+
+                    # arrow function
+                    ("=>",   ArrowFunction))
diff --git a/src/MapleFE/typescript/separator.spec b/src/MapleFE/typescript/separator.spec
new file mode 100644
index 0000000000000000000000000000000000000000..b06a949337eb48de6e69c481724f8b14af47f545
--- /dev/null
+++ b/src/MapleFE/typescript/separator.spec
@@ -0,0 +1,45 @@
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#  http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+# NOTE - 1
+#
+# This file defines the separator. The separators are defined using a STRUCT.
+# Each separator in this STRUCT is a set of 2 elements.
+# STRUCT Separator : ( ("(", LeftParenthesis),
+#                      (")", RightParenthesis),
+# The first element is the literal name of separator, it needs to be a string
+# The second is the ID of the separator. Please check shared/include/supported_separators.def
+# to see the supported separator ID.
+
+# NOTE - 2
+# Some languages could have one synatx belonging to both separator and operators.
+# eg., ':' in Java 8, it's both a separator colon and operator select.
+# We need avoid such duplication in .spec files.
+
+STRUCT Separator : ((" ", Whitespace),
+                    ("(", Lparen),
+                    (")", Rparen),
+                    ("{", Lbrace),
+                    ("}", Rbrace),
+                    ("[", Lbrack),
+                    ("]", Rbrack),
+                    (";", Semicolon),
+                    (",", Comma),
+                    (".", Dot),
+                    ("...", Dotdotdot),
+                    (":", Colon),
+                    ("?", Select),
+                    ("?.",Optional),
+                    ("@", At),
+                    ("#", Pound),
+                    ("\t", Tab))
diff --git a/src/MapleFE/typescript/src/Makefile b/src/MapleFE/typescript/src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..392dc308bc7852a4e8b14578efad9d2f52306413
--- /dev/null
+++ b/src/MapleFE/typescript/src/Makefile
@@ -0,0 +1,80 @@
+# Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#  http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+include ../../Makefile.in
+BUILDBIN=$(BUILDDIR)/bin
+BUILD=$(BUILDDIR)/typescript
+BUILDGEN=$(BUILDDIR)/gen
+BUILDASTGEN=$(BUILDDIR)/ast_gen/shared
+$(shell $(MKDIR_P) $(BUILD) $(BUILDGEN))
+
+SRC=$(wildcard *.cpp)
+OBJ :=$(patsubst %.cpp,%.o,$(SRC))
+DEP :=$(patsubst %.cpp,%.d,$(SRC))
+
+SRCG := $(wildcard $(BUILDGEN)/gen*.cpp)
+OBJG := $(patsubst %.cpp, %.o, $(SRCG))
+DEPG := $(patsubst %.cpp, %.d, $(SRCG))
+
+OBJS :=$(foreach obj,$(OBJ), $(BUILD)/$(obj)) $(OBJG)
+DEPS :=$(foreach dep,$(DEP), $(BUILD)/$(dep)) $(DEPG)
+
+INCLUDES := -I $(MAPLEFE_ROOT)/shared/include \
+            -I $(MAPLEFE_ROOT)/typescript/include \
+            -I $(MAPLEFE_ROOT)/autogen/include \
+	    -I ${BUILDDIR}/ast_gen/shared \
+            -I $(BUILDGEN)
+
+INCLUDEGEN := -I $(BUILDGEN) -I $(MAPLEFE_ROOT)/shared/include
+
+TARGET=ts2ast
+
+SHAREDLIB = $(BUILDDIR)/shared/shared.a $(BUILDASTGEN)/genast.a
+
+.PHONY: all
+all: $(BUILDBIN)/$(TARGET)
+
+-include $(DEPS)
+.PHONY: clean
+
+vpath %.o $(BUILD)
+vpath %.d $(BUILD)
+
+# Pattern Rules
+$(BUILD)/%.o : %.cpp
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDES) -w -c $< -o $@
+
+$(BUILD)/%.d : %.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDES) $< > $@
+	@mv -f $(BUILD)/$*.d $(BUILD)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILD)/$*.o:|' < $(BUILD)/$*.d.tmp > $(BUILD)/$*.d
+	@rm -f $(BUILD)/$*.d.tmp
+
+$(BUILDGEN)/%.o : $(BUILDGEN)/%.cpp $(BUILDGEN)/%.d
+	$(CXX) $(CXXFLAGS) -fpermissive $(INCLUDEGEN) -w -c $< -o $@
+
+$(BUILDGEN)/%.d : $(BUILDGEN)/%.cpp
+	@$(CXX) $(CXXFLAGS) -std=c++11 -MM $(INCLUDEGEN) $< > $@
+	@mv -f $(BUILDGEN)/$*.d $(BUILDGEN)/$*.d.tmp
+	@sed -e 's|.*:|$(BUILDGEN)/$*.o:|' < $(BUILDGEN)/$*.d.tmp > $(BUILDGEN)/$*.d
+	@rm -f $(BUILDGEN)/$*.d.tmp
+
+# TARGET depends on OBJS and shared OBJS from shared directory
+# as well as mapleall libraries
+$(BUILDBIN)/$(TARGET): $(OBJS) $(SHAREDLIB)
+	@mkdir -p $(BUILDBIN)
+	$(LD) -o $(BUILDBIN)/$(TARGET) $(OBJS) $(SHAREDLIB)
+
+clean:
+	rm -rf $(BUILD)
diff --git a/src/MapleFE/typescript/src/lang_spec.cpp b/src/MapleFE/typescript/src/lang_spec.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d51d1f312d0184badb28eac07e422c6a24a65632
--- /dev/null
+++ b/src/MapleFE/typescript/src/lang_spec.cpp
@@ -0,0 +1,661 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+#include "lang_spec.h"
+#include "stringpool.h"
+
+namespace maplefe {
+
+// For all the string to value functions below, we assume the syntax of 's' is correct
+// for a literal in Java.
+
+float  StringToValueImpl::StringToFloat(std::string &s) {
+  return stof(s);
+}
+
+// Java use 'd' or 'D' as double suffix. C++ use 'l' or 'L'.
+double StringToValueImpl::StringToDouble(std::string &s) {
+  std::string str = s;
+  char suffix = str[str.length() - 1];
+  if (suffix == 'd' || suffix == 'D')
+    str[str.length() - 1] = 'L';
+  return stod(str);
+}
+
+bool StringToValueImpl::StringToBool(std::string &s) {
+  if ((s.size() == 4) && (s.compare("true") == 0))
+    return true;
+  else if ((s.size() == 5) && (s.compare("false") == 0))
+    return false;
+  else
+    MERROR("unknown bool literal");
+}
+
+bool StringToValueImpl::StringIsNull(std::string &s) {return false;}
+
+const char* StringToValueImpl::StringToString(std::string &in_str) {
+  std::string target;
+
+  // For most languages, the input 'in_str' still contains the leading " or ' and the
+  // ending " or '. They need to be removed.
+  std::string str;
+
+  // If empty string literal, return the empty 'target'.
+  if (in_str.size() == 2) {
+    const char *s = gStringPool.FindString(target);
+    return s;
+  } else {
+    str.assign(in_str, 1, in_str.size() - 2);
+  }
+
+  // For typescript, if a string literal is:
+  //    s : string = "abc \
+  //                   efg";
+  // The \ is actually connnecting the next line into the string literal.
+  // We need handle the connection.
+
+  std::string s_ret;
+  for (unsigned i = 0; i < str.length(); i++) {
+    char c = str[i];
+    if (c == '\\') {
+      if ((i < str.length() - 1) && (str[i+1] == '\n')) {
+        // skip \ and \n
+        i += 1;
+        continue;
+      }
+    }
+    s_ret.push_back(c);
+  }
+
+  const char *s = gStringPool.FindString(s_ret);
+  return s;
+}
+
+static char DeEscape(char c) {
+  switch(c) {
+  case 'b':
+    return '\b';
+  case 't':
+    return '\t';
+  case 'n':
+    return '\n';
+  case 'f':
+    return '\f';
+  case 'r':
+    return '\r';
+  case '"':
+    return '\"';
+  case '\'':
+    return '\'';
+  case '\\':
+    return '\\';
+  case '0':
+    return '\0';
+  default:
+    MERROR("Unsupported in DeEscape().");
+  }
+}
+
+static int char2int(char c) {
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  else if (c >= 'a' && c <= 'f')
+    return c - 'a' + 10;
+  else if (c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+  else
+    MERROR("Unsupported char in char2int().");
+}
+
+Char StringToValueImpl::StringToChar(std::string &s) {
+  Char ret_char;
+  ret_char.mIsUnicode = false;
+  MASSERT (s[0] == '\'');
+  if (s[1] == '\\') {
+    if (s[2] == 'u') {
+      ret_char.mIsUnicode = true;
+      int first = char2int(s[3]);
+      int second = char2int(s[4]);
+      int third = char2int(s[5]);
+      int forth = char2int(s[6]);
+      MASSERT(s[7] == '\'');
+      ret_char.mData.mUniValue = (first << 12) + (second << 8)
+                               + (third << 4) + forth;
+    } else {
+      ret_char.mData.mChar = DeEscape(s[2]);
+    }
+  } else {
+    MASSERT(s[2] == '\'');
+    ret_char.mData.mChar = s[1];
+  }
+  return ret_char;
+}
+
+// Each language has its own format of literal. So this function handles Typescript literals.
+// It translate a string into a literal.
+//
+// 'str' is in the Lexer's string pool.
+//
+LitData ProcessLiteral(LitId id, const char *str) {
+  LitData data;
+  std::string value_text(str);
+  StringToValueImpl s2v;
+
+  switch (id) {
+  case LT_IntegerLiteral: {
+    long l = s2v.StringToLong(value_text);
+    data.mType = LT_IntegerLiteral;
+    data.mData.mInt = l;
+    break;
+  }
+  case LT_FPLiteral: {
+    // Java spec doesn't define rules for double. Both float and double
+    // are covered by Float Point. But we need differentiate here.
+    // Check if it's a float of double. Non-suffix means double.
+    char suffix = value_text[value_text.length() - 1];
+    if (suffix == 'f' || suffix == 'F') {
+      float f = s2v.StringToFloat(value_text);
+      data.mType = LT_FPLiteral;
+      data.mData.mFloat = f;
+    } else {
+      double d = s2v.StringToDouble(value_text);
+      data.mType = LT_DoubleLiteral;
+      data.mData.mDouble = d;
+    }
+    break;
+  }
+  case LT_BooleanLiteral: {
+    bool b = s2v.StringToBool(value_text);
+    data.mType = LT_BooleanLiteral;
+    data.mData.mBool = b;
+    break; }
+  case LT_CharacterLiteral: {
+    Char c = s2v.StringToChar(value_text);
+    data.mType = LT_CharacterLiteral;
+    data.mData.mChar = c;
+    break; }
+  case LT_StringLiteral: {
+    const char *s = s2v.StringToString(value_text);
+    data.mType = LT_StringLiteral;
+    data.mData.mStrIdx = gStringPool.GetStrIdx(s);
+    break; }
+  case LT_NullLiteral: {
+    // Just need set the id
+    data.mType = LT_NullLiteral;
+    break; }
+  case LT_NA:    // N/A,
+  default:
+    data.mType = LT_NA;
+    break;
+  }
+
+  return data;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+//                   Implementation of typescript Lexer
+/////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+
+bool TypescriptLexer::CharIsSeparator(const char c) {
+  if (c == '`')
+    return true;
+  return false;
+}
+
+// NOTE: right now we rely on 'tsc' to assure the input is legal,
+//       so I'll make many things easier and will skip many lexical
+//       checks. Just make it easy for now.
+//       Also, I assume we don't handle multiple line template literal
+//       for the time being.
+TempLitData* TypescriptLexer::GetTempLit() {
+  TempLitData *tld = NULL;
+  unsigned old_cur_idx = curidx;
+
+  if (line[curidx] == '`') {
+    // It's certain that this is a template literal because tsc assures it.
+    tld = new TempLitData;
+
+    unsigned start_idx;
+    unsigned end_idx;
+    start_idx = curidx + 1;
+    while(1) {
+      // Try string
+      end_idx = 0;
+      std::string fmt_str = "";
+      bool s_found = FindNextTLFormat(start_idx, fmt_str, end_idx);
+      const char *addr = NULL;
+      if (s_found) {
+        MASSERT(fmt_str.size() > 0 && "found token has 0 data?");
+        addr = gStringPool.FindString(fmt_str);
+        start_idx = end_idx + 1;
+      }
+
+      // Try pattern
+      end_idx = 0;
+      const char *addr_ph = NULL;
+      std::string pl_str = "";
+      bool p_found = FindNextTLPlaceHolder(start_idx, pl_str, end_idx);
+      if (p_found) {
+        unsigned len = pl_str.size();
+        MASSERT(len > 0 && "found token has 0 data?");
+        addr_ph = gStringPool.FindString(pl_str);
+        // We need skip the ending '}' of a pattern.
+        start_idx = end_idx + 2;
+      }
+
+      // If both string and pattern failed to be found
+      if (!s_found && !p_found) {
+        break;
+      } else {
+        tld->mStrings.PushBack(addr);
+        tld->mStrings.PushBack(addr_ph);
+      }
+    }
+
+    // It's for sure that this is the ending '`'.
+    MASSERT(line[start_idx] == '`');
+    curidx = start_idx + 1;
+  }
+
+  return tld;
+}
+
+// Find the pure string of a template literal.
+// Set end_idx as the last char of string.
+bool TypescriptLexer::FindNextTLFormat(unsigned start_idx, std::string &str, unsigned& end_idx) {
+  unsigned working_idx = start_idx;
+  while(1) {
+    if ((line[working_idx] == '$' && line[working_idx+1] == '{')
+        || line[working_idx] == '`' ){
+      end_idx = working_idx - 1;
+      break;
+    }
+
+    // Template Literal allows \n in format and place holder.
+    // the \n was removed by Lexer in the beginning of ReadALine();
+    if (working_idx == current_line_size) {
+      str += '\n';
+      ReadALine();
+      if (endoffile)
+        return false;
+      working_idx = 0;
+      continue;
+    }
+
+    str += line[working_idx];
+    working_idx++;
+  }
+
+  if (str.size() > 0)
+    return true;
+  else
+    return false;
+}
+
+// Find the pattern string of a template literal.
+// Set end_idx as the last char of string.
+//
+// [NOTE] For nested template literals, we will matching the outmost
+//        template literal and treat the inner template literal as
+//        a plain string. The innter template literal will later
+//        be handled by the parsing of the outmost template literal.
+//        This makes things easier.
+//
+// [NOTE] We only support two level of nesting temp lit !!
+
+bool TypescriptLexer::FindNextTLPlaceHolder(unsigned start_idx, std::string& str, unsigned& end_idx) {
+  unsigned working_idx = start_idx;
+  if (line[working_idx] != '$' || line[working_idx+1] != '{')
+    return false;
+
+  working_idx = start_idx + 2;
+
+  // There could be {..} inside placeholder.
+  unsigned num_left_brace = 0;
+
+  // There could be string literal inside placeholder,
+  bool in_string_literal = false;
+
+  // There could be nested template literal inside a place holder.
+  bool in_nested_temp_lit = false;
+  bool waiting_right_brace = false;
+  unsigned num_left_brace_inner = 0; // there could be {..} for inner temp lit.
+
+  while(1) {
+
+    if (line[working_idx] == '`') {
+      if (in_nested_temp_lit) {
+        // finish inner temp lit. Need clear the status.
+        in_nested_temp_lit = false;
+        num_left_brace_inner = 0;
+      } else {
+        in_nested_temp_lit = true;
+      }
+    } else if (line[working_idx] == '$' && line[working_idx+1] == '{') {
+      MASSERT(in_nested_temp_lit);
+      str += line[working_idx];
+      str += line[working_idx + 1];
+      working_idx += 2;
+      waiting_right_brace = true;
+      continue;
+    } else if (line[working_idx] == '\'' || line[working_idx] == '\"') {
+      in_string_literal = in_string_literal ? false : true;
+    } else if (line[working_idx] == '{') {
+      if (!in_string_literal) {
+        if (in_nested_temp_lit)
+          num_left_brace_inner++;
+        else
+          num_left_brace++;
+      }
+    } else if (line[working_idx] == '}') {
+      if (!in_string_literal) {
+        if (waiting_right_brace)
+          waiting_right_brace = false;
+        else if (!in_nested_temp_lit && num_left_brace > 0)
+          num_left_brace--;
+        else if (in_nested_temp_lit && num_left_brace_inner > 0)
+          num_left_brace_inner--;
+        else
+          break;
+      }
+    }
+
+    // Template Literal allows \n in format and place holder.
+    // the \n was removed by Lexer in the beginning of ReadALine();
+    // 
+    // I don't need worry about if the template literal is ended or not,
+    // since tsc guarantees it's correct.
+    if (working_idx == current_line_size) {
+      str += '\n';
+      ReadALine();
+      if (endoffile)
+        return false;
+      working_idx = 0;
+    } else {
+      str += line[working_idx];
+      working_idx++;
+    }
+  }
+
+  end_idx = working_idx - 1;
+  return true;
+}
+
+// This is to catch TS triple-slash directives : /// <reference
+bool TypescriptLexer::FindTripleSlash() {
+  unsigned i = curidx;
+  if (line[i] == '/' && line[i+1] == '/' && line[i+2] == '/'){
+    i += 3;
+    // skip the whitespace
+    while(1) {
+      if (line[i] == ' ') {
+        i++;
+      } else if (line[i] == '<') {
+        // Need make sure the following word is 'reference',
+        // or 'amd-module', or 'amd-dependency'
+        i++;
+        while(line[i] == ' ') {
+          i++;
+        }
+        if (!strncmp(line + i, "reference", 9) ||
+            !strncmp(line + i, "amd-module", 10) ||
+            !strncmp(line + i, "amd-dependency", 14)) {
+          if (i < current_line_size)
+            return true;
+        }
+      } else {
+        return false;
+      }
+    }
+  }
+  return false;
+}
+
+//
+Lexer* CreateLexer() {
+  Lexer *lexer = new TypescriptLexer();
+  return lexer;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+//                   Implementation of typescript Parser
+/////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+
+// Return a reg expr token instead of t if t is the beginning of a regular expression.
+// Or return t.
+Token* TypescriptParser::GetRegExpr(Token *t) {
+  if (!t->IsOperator())
+    return t;
+
+  if (t->GetOprId() != OPR_Div)
+    return t;
+
+  unsigned size = mActiveTokens.GetNum();
+  if (size < 2)
+    return t;
+
+  // We take care of only the following scenarios.
+  // If more need support, we will add later.
+  //   (/abc*/g, )
+  //   [/abc*/g, ]
+  //   =/abc*/g;
+  //   &&  /abc*/g;
+  //   ,/abc*/g;
+  //   : /abc*/g;
+  //   || /abc*/g;
+
+  Token *sep = mActiveTokens.ValueAtIndex(size - 1);
+  bool is_sep = false;
+  if (sep->IsSeparator() && (sep->GetSepId() == SEP_Lparen))
+    is_sep = true;
+  if (sep->IsSeparator() && (sep->GetSepId() == SEP_Lbrack))
+    is_sep = true;
+  if (sep->IsSeparator() && (sep->GetSepId() == SEP_Comma))
+    is_sep = true;
+  if (sep->IsSeparator() && (sep->GetSepId() == SEP_Colon))
+    is_sep = true;
+  if (sep->IsOperator() && (sep->GetOprId() == OPR_Assign))
+    is_sep = true;
+  if (sep->IsOperator() && (sep->GetOprId() == OPR_Land))
+    is_sep = true;
+  if (sep->IsOperator() && (sep->GetOprId() == OPR_Lor))
+    is_sep = true;
+  if (!is_sep)
+    return t;
+
+  Token *regexpr = mLexer->FindRegExprToken();
+  if (regexpr)
+    t = regexpr;
+
+  return t;
+}
+
+// return true if t should be split into multiple tokens.
+// [NOTE] t is not push into mActiveTokens yet.
+//
+// We will handle these cases specifically.
+//
+// We take care of only one scenarios right now..
+//   typename<typearg>= initval
+// Look at the '>='. It first recognazied by lexer as GE,
+// but it's actually a > and a =.
+//
+// Another case is
+//   typename<t extends T>= s;
+
+bool TypescriptParser::TokenSplit(Token *t) {
+  if (!t->IsOperator() || t->GetOprId() != OPR_GE)
+    return false;
+  unsigned size = mActiveTokens.GetNum();
+  if (size < 2)
+    return false;
+
+  Token *type_arg = mActiveTokens.ValueAtIndex(size - 1);
+  if (!type_arg->IsIdentifier())
+    return false;
+
+  Token *extends_token = FindKeywordToken("extends");
+
+  Token *lt = mActiveTokens.ValueAtIndex(size - 2);
+
+  if (lt->Equal(extends_token)) {
+    // This is a good candidate. Do nothing
+  } else {
+    if (!lt->IsOperator() || lt->GetOprId() != OPR_LT)
+      return false;
+
+    Token *type_name = mActiveTokens.ValueAtIndex(size - 3);
+    if (!type_name->IsIdentifier())
+      return false;
+  }
+
+  // Now we got a matching case.
+  Token *gt_token = FindOperatorToken(OPR_GT);
+  Token *assign_token = FindOperatorToken(OPR_Assign);
+  mActiveTokens.PushBack(gt_token);
+  mActiveTokens.PushBack(assign_token);
+
+  if (mLexer->mTrace) {
+    std::cout << "Split >= to > and =" << std::endl;
+  }
+
+  return true;
+}
+
+
+// 'appeal' is the node of 'rule_table'.
+// 'child' was NULL when passed in.
+bool TypescriptParser::TraverseASI(RuleTable *rule_table,
+                                   AppealNode *appeal,
+                                   AppealNode *&child) {
+  // Usually mCurToken is a new token to be matched. So if it's end of file, we simply return false.
+  // However, (1) if mCurToken is actually an ATMToken, which means it needs to be matched
+  //              multiple times, we are NOT at the end yet.
+  //          (2) If we are traverse a Concatenate rule, and the previous sub-rule has multiple matches,
+  //              and we are trying the current sub-rule, ie. 'data', using one of the matches.
+  //              The lexer actually reaches the EndOfFile in previous matchings, but the mCurToken
+  //              we are working on right now is not the last token. It's one of the previous matches.
+  // So we need check if we are matching the last token.
+  //if (mEndOfFile && mCurToken >= mActiveTokens.GetNum()) {
+  //  if (!(mInAltTokensMatching && (mCurToken == mATMToken)))
+  //    return false;
+  //}
+
+  if (mCurToken <= 1)
+    return false;
+
+  if (mEndOfFile && mCurToken == mActiveTokens.GetNum())
+    return true;
+
+  unsigned old_pos = mCurToken;
+  bool     found = false;
+  Token   *curr_token = GetActiveToken(mCurToken);
+  Token   *prev_token = GetActiveToken(mCurToken - 1);
+
+  MASSERT((rule_table->mNum == 1) && "ASI node has more than one elements?");
+
+  TableData *data = rule_table->mData;
+  MASSERT(data->mType == DT_Token && "ASI data is not a token?");
+
+  Token *semicolon = &gSystemTokens[data->mData.mTokenId];
+  MASSERT(semicolon->IsSeparator());
+  MASSERT(semicolon->GetSepId() == SEP_Semicolon);
+
+  if (curr_token->Equal(semicolon)) {
+    // To simplify the code, I reused TraverseToken().
+    found = TraverseToken(semicolon, appeal, child);
+  } else {
+    // case 1. We are crossing lines.
+    if (curr_token->mLineBegin && prev_token->mLineEnd) {
+      // If prev token (line end) is a separator
+      if (prev_token->IsSeparator() &&
+           (prev_token->GetSepId() == SEP_Rbrace ||
+            prev_token->GetSepId() == SEP_Rbrack ||
+            prev_token->GetSepId() == SEP_Rparen)) {
+        if (mTraceTable) {
+          std::cout << "TraverseASI, Auto-insert one semicolon." << std::endl;
+        }
+        found = true;
+      }
+
+      // if prev token is identifier or keyword AND the curr token is also id or keyword
+      // we can try to insert semicolon. A simple case is:
+      //        a    <-- we can insert semicolon
+      //        console.log();
+      if ( (prev_token->IsIdentifier() || prev_token->IsKeyword()) &&
+           (curr_token->IsIdentifier() || curr_token->IsKeyword()) ){
+        if (mTraceTable) {
+          std::cout << "TraverseASI, Auto-insert one semicolon." << std::endl;
+        }
+        found = true;
+      }
+
+      if (found)
+        return found;
+    }
+
+    // case 2. like:
+    //     {foo()}   <-- , is missed before }
+    if (curr_token->IsSeparator() && (curr_token->GetSepId() == SEP_Rbrace))
+      return true;
+
+    // case 3. This is a special case we want to catch:
+    //     foo(x) a=b;  <-- , is missing before a=b
+    //    { foo(x) a=b; } <-- , is missing before a=b
+    // There could be many more similar cases, but we just match this special one in our
+    // unit test. We don't encourage people write weird code.
+    if ( (curr_token->IsIdentifier() || curr_token->IsKeyword()) &&
+         (prev_token->IsSeparator() && (prev_token->GetSepId() == SEP_Rparen)) &&
+         mActiveTokens.GetNum() > 4 ){
+      Token *prev_2_token = GetActiveToken(mCurToken - 2);
+      Token *prev_3_token = GetActiveToken(mCurToken - 3);
+      Token *prev_4_token = GetActiveToken(mCurToken - 4);
+
+      bool lbrace_ok = false;
+      if (mActiveTokens.GetNum() > 5){
+        Token *prev_5_token = GetActiveToken(mCurToken - 5);
+        if (prev_5_token->IsSeparator() && (prev_5_token->GetSepId() == SEP_Lbrace))
+          lbrace_ok = true;
+      }
+
+      if ( (prev_4_token->mLineBegin || lbrace_ok) &&
+           (prev_4_token->IsIdentifier() || prev_4_token->IsKeyword()) &&
+           (prev_2_token->IsIdentifier() || prev_2_token->IsKeyword()) &&
+           (prev_3_token->IsSeparator() && (prev_3_token->GetSepId() == SEP_Lparen)) ){
+        // NOTE: Need make sure foo(x) is not if(x) or while(x).
+        found = true;
+        if (prev_4_token->IsKeyword() &&
+             (!strncmp(prev_4_token->GetName(), "if", 2) ||
+              !strncmp(prev_4_token->GetName(), "while", 5)) )
+          found = false;
+
+        if (found)
+          return true;
+      }
+    }
+  }
+
+  if (child) {
+    child->SetChildIndex(0);
+    appeal->CopyMatch(child);
+  }
+
+  return found;
+}
+
+}
diff --git a/src/MapleFE/typescript/src/main.cpp b/src/MapleFE/typescript/src/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a999a29d72b96978293c0b6f6127e023771e605b
--- /dev/null
+++ b/src/MapleFE/typescript/src/main.cpp
@@ -0,0 +1,125 @@
+/*
+* Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+*
+* OpenArkFE is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*  http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <fstream>      // std::ofstream
+#include "parser.h"
+#include "token.h"
+#include "common_header_autogen.h"
+#include "ruletable_util.h"
+#include "gen_summary.h"
+#include "gen_aststore.h"
+#include "gen_astdump.h"
+#include "gen_astgraph.h"
+#include "lang_spec.h"
+
+static void help() {
+  std::cout << "ts2ast sourcefile [options]:\n" << std::endl;
+  std::cout << "   --help            : print this help" << std::endl;
+  std::cout << "   --trace-lexer     : Trace lexing" << std::endl;
+  std::cout << "   --trace-table     : Trace rule table when entering and exiting" << std::endl;
+  std::cout << "   --trace-left-rec  : Trace left recursion parsing" << std::endl;
+  std::cout << "   --trace-appeal    : Trace appeal process" << std::endl;
+  std::cout << "   --trace-failed    : Trace failed tokens of table" << std::endl;
+  std::cout << "   --trace-timing    : Trace parsing time" << std::endl;
+  std::cout << "   --trace-stack     : Trace visited-token stack of table" << std::endl;
+  std::cout << "   --trace-sortout   : Trace SortOut" << std::endl;
+  std::cout << "   --trace-ast-build : Trace AST Builder" << std::endl;
+  std::cout << "   --trace-patch-was-succ : Trace Patching of WasSucc nodes" << std::endl;
+  std::cout << "   --trace-warning   : Print Warning" << std::endl;
+  std::cout << "   --dump-ast        : Dump AST in text format" << std::endl;
+  std::cout << "   --dump-dot        : Dump AST in dot format" << std::endl;
+}
+
+int main (int argc, char *argv[]) {
+  if (argc == 1 || (!strncmp(argv[1], "--help", 6) && (strlen(argv[1]) == 6))) {
+    help();
+    exit(-1);
+  }
+
+  maplefe::Parser *parser = new maplefe::TypescriptParser(argv[1]);
+
+  bool dump_ast = false;
+  bool dump_dot = false;
+  bool succ;
+
+  // Parse the argument
+  for (unsigned i = 2; i < argc; i++) {
+    if (!strncmp(argv[i], "--trace-lexer", 13) && (strlen(argv[i]) == 13)) {
+      parser->SetLexerTrace();
+    } else if (!strncmp(argv[i], "--trace-table", 13) && (strlen(argv[i]) == 13)) {
+      parser->mTraceTable = true;
+    } else if (!strncmp(argv[i], "--trace-left-rec", 16) && (strlen(argv[i]) == 16)) {
+      parser->mTraceLeftRec = true;
+    } else if (!strncmp(argv[i], "--trace-appeal", 14) && (strlen(argv[i]) == 14)) {
+      parser->mTraceAppeal = true;
+    } else if (!strncmp(argv[i], "--trace-stack", 13) && (strlen(argv[i]) == 13)) {
+      parser->mTraceVisited = true;
+    } else if (!strncmp(argv[i], "--trace-failed", 14) && (strlen(argv[i]) == 14)) {
+      parser->mTraceFailed = true;
+    } else if (!strncmp(argv[i], "--trace-timing", 14) && (strlen(argv[i]) == 14)) {
+      parser->mTraceTiming = true;
+    } else if (!strncmp(argv[i], "--trace-sortout", 15) && (strlen(argv[i]) == 15)) {
+      parser->mTraceSortOut = true;
+    } else if (!strncmp(argv[i], "--trace-ast-build", 17) && (strlen(argv[i]) == 17)) {
+      parser->mTraceAstBuild = true;
+    } else if (!strncmp(argv[i], "--trace-patch-was-succ", 22) && (strlen(argv[i]) == 22)) {
+      parser->mTracePatchWasSucc = true;
+    } else if (!strncmp(argv[i], "--trace-warning", 15) && (strlen(argv[i]) == 15)) {
+      parser->mTraceWarning = true;
+    } else if (!strncmp(argv[i], "--dump-ast", 10) && (strlen(argv[i]) == 10)) {
+      dump_ast = true;
+    } else if (!strncmp(argv[i], "--dump-dot", 10) && (strlen(argv[i]) == 10)) {
+      dump_dot = true;
+    } else {
+      std::cerr << "unknown option " << argv[i] << std::endl;
+      exit(-1);
+    }
+  }
+
+  parser->InitRecursion();
+  succ = parser->Parse();
+  if (!succ) {
+    delete parser;
+    return 1;
+  }
+
+  // the module from parser
+  maplefe::ModuleNode *module = parser->GetModule();
+
+  if(dump_ast) {
+    maplefe::AstDump astdump(module);
+    astdump.Dump("ts2ast: Initial AST", &std::cout);
+  }
+
+  if(dump_dot) {
+    maplefe::AstGraph graph(module);
+    graph.DumpGraph("ts2ast: Initial AST", &std::cout);
+  }
+
+  maplefe::AstStore saveAst(module);
+  saveAst.StoreInAstBuf();
+  maplefe::AstBuffer &ast_buf = saveAst.GetAstBuf();
+
+  std::ofstream ofs;
+  std::string fname(module->GetFilename());
+  fname += ".ast";
+  ofs.open(fname, std::ofstream::out);
+  const char *addr = (const char *)(&(ast_buf[0]));
+  ofs.write(addr, ast_buf.size());
+  ofs.close();
+
+  delete parser;
+  return 0;
+}
diff --git a/src/MapleFE/typescript/stmt.spec b/src/MapleFE/typescript/stmt.spec
new file mode 100644
index 0000000000000000000000000000000000000000..4bce8140eb6f1eb77e346f706f1f7210234aba67
--- /dev/null
+++ b/src/MapleFE/typescript/stmt.spec
@@ -0,0 +1,2491 @@
+# Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+# Copyright 2022 Tencent. All rights reverved.
+#
+# MapleFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#  http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+#-------------------------------------------------------------------------------
+#                                    A.1 Lexical Grammar
+#-------------------------------------------------------------------------------
+
+####   Template and TemplateLiteral are too complicated to be described
+####   in rules. We handle them specifically in the source code of lexer.
+
+##Template ::
+##NoSubstitutionTemplate
+##TemplateHead
+
+##NoSubstitutionTemplate ::
+##` TemplateCharactersopt `
+
+##TemplateHead ::
+##` TemplateCharactersopt ${
+
+##See 11.8.6
+##TemplateSubstitutionTail ::
+##TemplateMiddle
+##TemplateTail
+##See 11.8.6
+##TemplateMiddle ::
+##} TemplateCharactersopt ${
+##See 11.8.6
+##TemplateTail ::
+##} TemplateCharactersopt `
+
+##TemplateCharacters ::
+##TemplateCharacter TemplateCharactersopt
+
+##TemplateCharacter ::
+##$ [lookahead ≠ { ]
+##\ EscapeSequence
+##LineContinuation
+##LineTerminatorSequence
+##SourceCharacter but not one of ` or \ or $ or LineTerminator
+
+#-------------------------------------------------------------------------------
+#                                    A.2 Expressions
+#-------------------------------------------------------------------------------
+
+rule KeywordIdentifier : ONEOF("type",
+                               "with",
+                               "boolean",
+                               "string",
+                               "catch",
+                               "get",
+                               "set",
+                               "undefined",
+                               "never",
+                               "number",
+                               "symbol",
+                               "unique",
+                               "any",
+                               "constructor",
+                               "delete",
+                               "abstract",
+                               "private",
+                               "static",
+                               "as",
+                               "async",
+                               "await",
+                               "finally",
+                               "from",
+                               "is",
+                               "in",
+                               "of",
+                               "declare",
+                               "readonly",
+                               "debugger",
+                               "default",
+                               "namespace",
+                               "module",
+                               "switch",
+                               "infer",
+                               "asserts",
+                               "require",
+                               "global",
+                               "throw",
+                               "class",
+                               "unknown",
+                               "do",
+                               "for")
+## "
+  attr.action : BuildIdentifier()
+
+rule JSIdentifier: ONEOF(Identifier,
+                         KeywordIdentifier,
+                         Identifier + '!',
+                         Identifier + '?',
+                         KeywordIdentifier + '?')
+  attr.action.%3 : SetIsNonNull(%1)
+  attr.action.%4 : SetIsOptional(%1)
+  attr.action.%5 : SetIsOptional(%1)
+
+rule AsType : "as" + Type
+  attr.action : BuildAsType(%2)
+
+##-----------------------------------
+##rule IdentifierReference[Yield] :
+##  Identifier
+##  [~Yield] yield
+
+rule IdentifierReference : ONEOF(
+  JSIdentifier)
+#  "yield")
+
+##-----------------------------------
+##rule BindingIdentifier[Yield] :
+##  Identifier
+##  [~Yield] yield
+
+rule BindingIdentifier : ONEOF(JSIdentifier)
+
+##-----------------------------------
+##rule LabelIdentifier[Yield] :
+##  Identifier
+##  [~Yield] yield
+rule LabelIdentifier : ONEOF(
+  JSIdentifier)
+
+##-----------------------------------
+##rule Identifier :
+##  IdentifierName but not ReservedWord
+##
+## Identifier and IdentifierName are tricky in Javascript.
+## (1) Some 'keywords' like 'get', 'set', should be keyword and reserved,
+##     however, they are allowed as identifiers.
+## (2) Identifier is a reserved rule in 'autogen', we won't define it
+##     in this spec.
+##
+## I decided to use JSIdentifier instead of Identifier and then I
+## can include 'get', 'set' in the JSIdentifier.
+
+##-----------------------------------
+##rule PrimaryExpression[Yield] :
+##  this
+##  IdentifierReference[?Yield]
+##  Literal
+##  ArrayLiteral[?Yield]
+##  ObjectLiteral[?Yield]
+##  FunctionExpression
+##  ClassExpression[?Yield]
+##  GeneratorExpression
+##  RegularExpressionLiteral
+##  TemplateLiteral[?Yield]
+##  CoverParenthesizedExpressionAndArrowParameterList[?Yield]
+
+rule PrimaryExpression : ONEOF("this",
+                               "super",
+                               IdentifierReference,
+                               Literal,
+                               ArrayLiteral,
+                               ObjectLiteral,
+                               FunctionExpression,
+#                              ClassExpression[?Yield]
+#                              GeneratorExpression
+                               RegularExpression,
+                               TemplateLiteral,
+                               ParenthesizedExpression)
+
+##-----------------------------------
+##rule CoverParenthesizedExpressionAndArrowParameterList[Yield] :
+##  ( Expression[In, ?Yield] )
+##  ( )
+##  ( ... BindingIdentifier[?Yield] )
+##  ( Expression[In, ?Yield] , ... BindingIdentifier[?Yield] )
+##  When processing the production
+##        PrimaryExpression[Yield] : CoverParenthesizedExpressionAndArrowParameterList[?Yield]
+##  the interpretation of CoverParenthesizedExpressionAndArrowParameterList is refined using the following grammar:
+##  ParenthesizedExpression[Yield] :
+##  ( Expression[In, ?Yield] )
+rule ParenthesizedExpression : '(' + Expression + ')'
+
+rule CoverParenthesizedExpressionAndArrowParameterList : ONEOF(
+  '(' + Expression + ')',
+  '(' + ')',
+  '(' + "..." + BindingIdentifier + ')',
+  '(' + "..." + BindingPattern + ')',
+  '(' + Expression + ',' + "..." + BindingIdentifier + ')',
+  '(' + Expression + ',' + "..." + BindingPattern + ')')
+
+##-----------------------------------
+
+##-----------------------------------
+##rule Literal :
+##  NullLiteral
+##  BooleanLiteral
+##  NumericLiteral
+##  StringLiteral
+
+# Literal is handled in lexer as a token. Also we don't do any Lookahead detect or recursion detect
+# inside Literal. So it means parsing stops at Literal. This works for most languages.
+#
+# NullLiteral, BooleanLiteral, NumericLiteral, StringLiteral can be handled specifically in parser
+# to see if it's a string literal.
+
+##-----------------------------------
+##rule ArrayLiteral[Yield] :
+##  [ Elisionopt ]
+##  [ ElementList[?Yield] ]
+##  [ ElementList[?Yield] , Elisionopt ]
+rule ArrayLiteral : ONEOF(
+  '[' + ZEROORONE(Elision) + ']'
+  '[' + ElementList + ']'
+  '[' + ElementList + ',' + ZEROORONE(Elision) + ']')
+  attr.action.%1,%2,%3 : BuildArrayLiteral(%2)
+
+##-----------------------------------
+##rule ElementList[Yield] :
+##  Elisionopt AssignmentExpression[In, ?Yield]
+##  Elisionopt SpreadElement[?Yield]
+##  ElementList[?Yield] , Elisionopt AssignmentExpression[In, ?Yield]
+##  ElementList[?Yield] , Elisionopt SpreadElement[?Yield]
+rule ElementList : ONEOF(
+  ZEROORONE(Elision) + AssignmentExpression,
+  ZEROORONE(Elision) + SpreadElement,
+  ElementList + ',' + ZEROORONE(Elision) + AssignmentExpression,
+  ElementList + ',' + ZEROORONE(Elision) + SpreadElement)
+  attr.action.%1,%2 : PassChild(%2)
+  attr.action.%3,%4 : BuildExprList(%1, %4)
+
+##-----------------------------------
+##rule Elision :
+##  ,
+##  Elision ,
+
+rule Elision : ONEOF(',',
+                     Elision + ',')
+
+##-----------------------------------
+##rule SpreadElement[Yield] :
+##  ... AssignmentExpression[In, ?Yield]
+rule SpreadElement : "..." + AssignmentExpression + ZEROORONE(TypeArguments)
+  attr.action : SetIsRest(%2)
+  attr.action : PassChild(%2)
+
+##-----------------------------------
+##rule ObjectLiteral[Yield] :
+##  { }
+##  { PropertyDefinitionList[?Yield] }
+##  { PropertyDefinitionList[?Yield] , }
+rule ObjectLiteral : ONEOF('{' + '}',
+                           '{' + PropertyDefinitionList + '}',
+                           '{' + PropertyDefinitionList + ',' + '}')
+  attr.action.%1    : BuildStructLiteral()
+  attr.action.%2,%3 : BuildStructLiteral(%2)
+
+##-----------------------------------
+##rule PropertyDefinitionList[Yield] :
+##  PropertyDefinition[?Yield]
+##  PropertyDefinitionList[?Yield] , PropertyDefinition[?Yield]
+rule PropertyDefinitionList : ONEOF(
+  PropertyDefinition,
+  PropertyDefinitionList + ',' + PropertyDefinition)
+
+##-----------------------------------
+# modified in 2016
+##rule PropertyDefinition[Yield] :
+##  IdentifierReference[?Yield]
+##  CoverInitializedName[?Yield]
+##  PropertyName[?Yield] : AssignmentExpression[In, ?Yield]
+##  MethodDefinition[?Yield]
+
+##-----------------------------------
+##rule PropertyName[Yield] :
+##  LiteralPropertyName
+##  ComputedPropertyName[?Yield]
+rule PropertyName : ONEOF(LiteralPropertyName,
+                          ComputedPropertyName)
+
+##-----------------------------------
+##rule LiteralPropertyName :
+##  IdentifierName
+##  StringLiteral
+##  NumericLiteral
+
+# I used Identifier instead of IdentifierName because keywords
+# are processed before Identifier, and so Identifier is the same
+# as IdentifierName here.
+#
+# I extend StringLiteral/NumericLiteral to Literal. 'tsc' will
+# make sure it's legal and I don't need worry about it.
+
+rule LiteralPropertyName : ONEOF(JSIdentifier, Literal)
+
+##-----------------------------------
+##rule ComputedPropertyName[Yield] :
+##  [ AssignmentExpression[In, ?Yield] ]
+rule ComputedPropertyName : ONEOF(
+  '[' + AssignmentExpression + ']',
+  ZEROORONE(IndexSigPrefix) + ZEROORONE(IndexSigModifier) + '[' + AssignmentExpression + ']' + ZEROORONE(IndexSigPrefix) + ZEROORONE(IndexSigModifier))
+  attr.action.%1 : BuildComputedName(%2)
+  attr.action.%2 : BuildComputedName(%4)
+  attr.action.%2 : AddModifier(%1, %2)
+  attr.action.%2 : AddModifier(%6, %7)
+
+##-----------------------------------
+##rule CoverInitializedName[Yield] :
+##  IdentifierReference[?Yield] Initializer[In, ?Yield]
+rule CoverInitializedName : IdentifierReference + Initializer
+
+##-----------------------------------
+##rule Initializer[In, Yield] :
+##  = AssignmentExpression[?In, ?Yield]
+rule Initializer : '=' + AssignmentExpression
+
+##-----------------------------------
+##rule TemplateLiteral[Yield] :
+##  NoSubstitutionTemplate
+##  TemplateHead Expression[In, ?Yield] TemplateSpans[?Yield]
+##
+## NOTE: TemplateLiteral will be handled specifically in lexer code.
+## rule TemplateLiteral : "this_is_for_fake_rule" is defined in reserved.spec
+
+##-----------------------------------
+##rule TemplateSpans[Yield] :
+##  TemplateTail
+##  TemplateMiddleList[?Yield] TemplateTail
+
+##-----------------------------------
+##rule TemplateMiddleList[Yield] :
+##  TemplateMiddle Expression[In, ?Yield]
+##  TemplateMiddleList[?Yield] TemplateMiddle Expression[In, ?Yield]
+
+##-----------------------------------
+##rule MemberExpression[Yield] :
+##  PrimaryExpression[?Yield]
+##  MemberExpression[?Yield] [ Expression[In, ?Yield] ]
+##  MemberExpression[?Yield] . IdentifierName
+##  MemberExpression[?Yield] TemplateLiteral[?Yield]
+##  SuperProperty[?Yield]
+##  MetaProperty
+##  new MemberExpression[?Yield] Arguments[?Yield]
+
+rule KeywordPropName : ONEOF("break",
+                             "this",
+                             "public",
+                             "export",
+                             "const",
+                             "if",
+                             "try",
+                             "else",
+                             "continue",
+                             "implements",
+                             "enum",
+                             "function",
+                             "let",
+                             "return",
+                             "extends",
+                             "import",
+                             "get",
+                             "set",
+                             "var")
+  attr.action : BuildIdentifier()
+
+rule MemberExpression : ONEOF(
+  PrimaryExpression + ZEROORMORE(AsType),
+  MemberExpression + '[' + Expression + ']' + ZEROORMORE(AsType),
+  MemberExpression + '.' + JSIdentifier + ZEROORMORE(AsType),
+  MemberExpression + "?." + JSIdentifier + ZEROORMORE(AsType),
+  MemberExpression + TemplateLiteral,
+#  SuperProperty[?Yield]
+#  MetaProperty
+  "new" + MemberExpression + ZEROORONE(Arguments),
+# NOTE: I created this rule. Typescript extended Type system and allow 'new'
+#       on a TypeReference
+  "new" + TypeReference + ZEROORONE(Arguments),
+  MemberExpression + "?." + '[' + Expression + ']' + ZEROORMORE(AsType),
+  IsExpression,
+  MemberExpression + '[' + KeyOf + ']',
+  MemberExpression + '!',
+  MemberExpression + "as" + "const",
+  '<' + Type + '>' + MemberExpression,
+  MemberExpression + '.' + KeywordPropName)
+  attr.action.%1 : AddAsType(%1, %2)
+  attr.action.%2 : BuildArrayElement(%1, %3)
+  attr.action.%2 : AddAsType(%5)
+  attr.action.%3 : BuildField(%1, %3)
+  attr.action.%3 : AddAsType(%4)
+  attr.action.%4 : SetIsOptional(%1)
+  attr.action.%4 : BuildField(%1, %3)
+  attr.action.%4 : AddAsType(%4)
+  attr.action.%6,%7 : BuildNewOperation(%2, %3)
+  attr.action.%8 : SetIsOptional(%1)
+  attr.action.%8 : BuildArrayElement(%1, %4)
+  attr.action.%8 : AddAsType(%6)
+  attr.action.%10: BuildArrayElement(%1, %3)
+  attr.action.%11: SetIsNonNull(%1)
+  attr.action.%12: SetIsConst(%1)
+  attr.action.%13: BuildCast(%2, %4)
+  attr.action.%14 : BuildField(%1, %3)
+
+rule IsExpression: ONEOF(PrimaryExpression + "is" + Type,
+                         ArrowFunction + "is" + Type)
+  attr.action.%1,%2 : BuildIs(%1, %3)
+
+rule AssertExpression : "asserts" + MemberExpression
+  attr.action : BuildAssert(%2)
+
+##-----------------------------------
+##rule SuperProperty[Yield] :
+##  super [ Expression[In, ?Yield] ]
+##  super . IdentifierName
+
+##-----------------------------------
+##rule MetaProperty :
+##  NewTarget
+
+##-----------------------------------
+##rule NewTarget :
+##  new . target
+
+##-----------------------------------
+##rule NewExpression[Yield] :
+##  MemberExpression[?Yield]
+##  new NewExpression[?Yield]
+rule NewExpression : ONEOF(MemberExpression,
+                           "new" + NewExpression,
+                           "new" + ClassDeclaration,
+                           "new" + '(' + ClassDeclaration + ')')
+  attr.action.%2,%3 : BuildNewOperation(%2)
+  attr.action.%4    : BuildNewOperation(%3)
+
+##-----------------------------------
+##rule CallExpression[Yield] :
+##  MemberExpression[?Yield] Arguments[?Yield]
+##  SuperCall[?Yield]
+##  CallExpression[?Yield] Arguments[?Yield]
+##  CallExpression[?Yield] [ Expression[In, ?Yield] ]
+##  CallExpression[?Yield] . IdentifierName
+##  CallExpression[?Yield] TemplateLiteral[?Yield]
+
+rule ImportFunction : ONEOF("import" + '(' + Literal + ')',
+                            "import" + '(' + TemplateLiteral + ')')
+  attr.action.%1,%2 : BuildImport()
+  attr.action.%1,%2 : SetFromModule(%3)
+
+rule CallExpression : ONEOF(
+  MemberExpression + ZEROORONE(TypeArguments) + Arguments + ZEROORMORE(AsType),
+  SuperCall,
+  CallExpression + Arguments + ZEROORMORE(AsType),
+  CallExpression + '[' + Expression + ']' + ZEROORONE(AsType),
+  CallExpression + '.' + JSIdentifier + ZEROORMORE(AsType),
+  CallExpression + TemplateLiteral,
+  CallExpression + '!' + ZEROORMORE(AsType),
+  CallExpression + "?." + JSIdentifier + ZEROORMORE(AsType),
+  MemberExpression + "?." + ZEROORONE(TypeArguments) + Arguments + ZEROORMORE(AsType),
+  "set" + ZEROORONE(TypeArguments) + Arguments + ZEROORMORE(AsType),
+  "get" + ZEROORONE(TypeArguments) + Arguments + ZEROORMORE(AsType),
+  CallExpression + "?." + Arguments + ZEROORMORE(AsType),
+  ImportFunction,
+  CallExpression + '.' + KeywordPropName + ZEROORMORE(AsType))
+  attr.action.%1,%3,%10,%11 : BuildCall(%1)
+  attr.action.%1,%10,%11 : AddAsType(%4)
+  attr.action.%1,%10,%11 : AddTypeGenerics(%2)
+  attr.action.%1,%10,%11 : AddArguments(%3)
+  attr.action.%3 : AddArguments(%2)
+  attr.action.%3 : AddAsType(%3)
+  attr.action.%4 : BuildArrayElement(%1, %3)
+  attr.action.%4 : AddAsType(%5)
+  attr.action.%5,%14 : BuildField(%1, %3)
+  attr.action.%5,%14 : AddAsType(%4)
+  attr.action.%7 : SetIsNonNull(%1)
+  attr.action.%7 : AddAsType(%1, %3)
+  attr.action.%8 : SetIsOptional(%1)
+  attr.action.%8 : BuildField(%1, %3)
+  attr.action.%8 : AddAsType(%4)
+  attr.action.%9 : SetIsOptional(%1)
+  attr.action.%9 : BuildCall(%1)
+  attr.action.%9 : AddTypeGenerics(%3)
+  attr.action.%9 : AddArguments(%4)
+  attr.action.%9 : AddAsType(%5)
+  attr.action.%12: SetIsOptional(%1)
+  attr.action.%12: BuildCall(%1)
+  attr.action.%12: AddArguments(%3)
+  attr.action.%12: AddAsType(%4)
+
+##-----------------------------------
+##rule SuperCall[Yield] :
+##  super Arguments[?Yield]
+rule SuperCall : "super" + Arguments
+
+##-----------------------------------
+##rule Arguments[Yield] :
+##  ( )
+##  ( ArgumentList[?Yield] )
+
+rule Arguments : ONEOF(
+  '(' + ')',
+  '(' + ArgumentList + ')')
+  attr.action.%2 : PassChild(%2)
+
+##-----------------------------------
+##rule ArgumentList[Yield] :
+##  AssignmentExpression[In, ?Yield]
+##  ... AssignmentExpression[In, ?Yield]
+##  ArgumentList[?Yield] , AssignmentExpression[In, ?Yield]
+##  ArgumentList[?Yield] , ... AssignmentExpression[In, ?Yield]
+
+## child #3, I added ZEROORONE() since ECMAScript 2017 allows empty argument after ','.
+rule ArgumentList : ONEOF(AssignmentExpression,
+                          "..." + AssignmentExpression,
+                          ArgumentList + ',' + ZEROORONE(AssignmentExpression),
+                          ArgumentList + ',' + "..." + AssignmentExpression)
+  attr.action.%2 : SetIsRest(%2)
+  attr.action.%4 : SetIsRest(%4)
+
+##-----------------------------------
+##rule LeftHandSideExpression[Yield] :
+##  NewExpression[?Yield]
+##  CallExpression[?Yield]
+
+rule LeftHandSideExpression : ONEOF(NewExpression,
+                                    CallExpression,
+                                    "..." + NewExpression,
+                                    "..." + CallExpression,
+                                    "await" + CallExpression,
+                                    "await" + NewExpression)
+  attr.action.%3,%4 : SetIsRest(%2)
+  attr.action.%5,%6 : BuildAwait(%2)
+
+##-----------------------------------
+##rule PostfixExpression[Yield] :
+##  LeftHandSideExpression[?Yield]
+##  LeftHandSideExpression[?Yield] [no LineTerminator here] ++
+##  LeftHandSideExpression[?Yield] [no LineTerminator here] --
+
+rule PostfixExpression : ONEOF(
+  LeftHandSideExpression,
+  LeftHandSideExpression + "++",
+  LeftHandSideExpression + "--")
+  attr.action.%2,%3 : BuildPostfixOperation(%2, %1)
+
+##-----------------------------------
+##rule UnaryExpression[Yield] :
+##  PostfixExpression[?Yield]
+##  delete UnaryExpression[?Yield]
+##  void UnaryExpression[?Yield]
+##  typeof UnaryExpression[?Yield]
+##  ++ UnaryExpression[?Yield]
+##  -- UnaryExpression[?Yield]
+##  + UnaryExpression[?Yield]
+##  - UnaryExpression[?Yield]
+##  ~ UnaryExpression[?Yield]
+##  ! UnaryExpression[?Yield]
+
+rule UnaryExpression : ONEOF(
+  PostfixExpression,
+  "delete" + UnaryExpression,
+  "void" + UnaryExpression,
+  "typeof" + UnaryExpression,
+  "++" + UnaryExpression,
+   "--" + UnaryExpression,
+   '+' + UnaryExpression,
+   '-' + UnaryExpression,
+   '~' + UnaryExpression,
+   '!' + UnaryExpression,
+  "typeof" + '(' + ClassDeclaration + ')')
+  attr.action.%2 : BuildDeleteOperation(%2)
+  attr.action.%3 : BuildLiteral(%1)
+  attr.action.%4 : BuildTypeOf(%2)
+  attr.action.%5,%6,%7,%8,%9,%10 : BuildUnaryOperation(%1, %2)
+  attr.action.%11 : BuildTypeOf(%3)
+
+## UpdateExpression[Yield]:
+## LeftHandSideExpression[?Yield]
+## LeftHandSideExpression[?Yield][no LineTerminator here]++
+## LeftHandSideExpression[?Yield][no LineTerminator here]--
+## ++UnaryExpression[?Yield]
+## --UnaryExpression[?Yield]
+rule UpdateExpression : ONEOF(LeftHandSideExpression,
+                              LeftHandSideExpression + "++",
+                              LeftHandSideExpression + "--",
+                              "++" + UnaryExpression,
+                              "--" + UnaryExpression)
+  attr.action.%2,%3 : BuildPostfixOperation(%2, %1)
+  attr.action.%4,%5: BuildUnaryOperation(%1, %2)
+
+
+## Added in 2016
+## ExponentiationExpression[Yield]:
+## UnaryExpression[?Yield]
+## UpdateExpression[?Yield]**ExponentiationExpression[?Yield]
+rule ExponentiationExpression : ONEOF(UnaryExpression,
+                                      UpdateExpression + "**" + ExponentiationExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule MultiplicativeExpression[Yield] :
+##  UnaryExpression[?Yield]
+##  MultiplicativeExpression[?Yield] MultiplicativeOperator UnaryExpression[?Yield]
+## 2016
+## MultiplicativeExpression[Yield]:
+## ExponentiationExpression[?Yield]
+## MultiplicativeExpression[?Yield]MultiplicativeOperatorExponentiationExpression[?Yield]
+
+rule MultiplicativeExpression : ONEOF(
+  ExponentiationExpression,
+  MultiplicativeExpression + MultiplicativeOperator + ExponentiationExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule MultiplicativeOperator : one of
+##  * / %
+
+rule MultiplicativeOperator : ONEOF( '*', '/', '%')
+
+##-----------------------------------
+##rule AdditiveExpression[Yield] :
+##  MultiplicativeExpression[?Yield]
+##  AdditiveExpression[?Yield] + MultiplicativeExpression[?Yield]
+##  AdditiveExpression[?Yield] - MultiplicativeExpression[?Yield]
+
+rule AdditiveExpression : ONEOF(
+  MultiplicativeExpression,
+  AdditiveExpression + '+' + MultiplicativeExpression,
+  AdditiveExpression + '-' + MultiplicativeExpression)
+  attr.action.%2,%3 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule ShiftExpression[Yield] :
+##  AdditiveExpression[?Yield]
+##  ShiftExpression[?Yield] << AdditiveExpression[?Yield]
+##  ShiftExpression[?Yield] >> AdditiveExpression[?Yield]
+##  ShiftExpression[?Yield] >>> AdditiveExpression[?Yield]
+rule ShiftExpression : ONEOF(AdditiveExpression,
+                             ShiftExpression + "<<" + AdditiveExpression,
+                             ShiftExpression + ">>" + AdditiveExpression,
+                             ShiftExpression + ">>>" + AdditiveExpression)
+  attr.action.%2,%3,%4 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule RelationalExpression[In, Yield] :
+##  ShiftExpression[?Yield]
+##  RelationalExpression[?In, ?Yield] < ShiftExpression[?Yield]
+##  RelationalExpression[?In, ?Yield] > ShiftExpression[?Yield]
+##  RelationalExpression[?In, ?Yield] <= ShiftExpression[? Yield]
+##  RelationalExpression[?In, ?Yield] >= ShiftExpression[?Yield]
+##  RelationalExpression[?In, ?Yield] instanceof ShiftExpression[?Yield]
+##  [+In] RelationalExpression[In, ?Yield] in ShiftExpression[?Yield]
+
+rule InExpression : RelationalExpression + "in" + ONEOF(ShiftExpression, Type)
+## "
+  attr.action : BuildIn(%1, %3)
+
+rule RelationalExpression : ONEOF(ShiftExpression,
+                                  RelationalExpression + '<' + ShiftExpression,
+                                  RelationalExpression + '>' + ShiftExpression,
+                                  RelationalExpression + "<=" + ShiftExpression,
+                                  RelationalExpression + ">=" + ShiftExpression,
+                                  RelationalExpression + "instanceof" + ShiftExpression,
+                                  ClassDeclaration + "instanceof" + ShiftExpression,
+                                  InExpression)
+  attr.property.%3 : NoAltToken
+  attr.action.%2,%3,%4,%5 : BuildBinaryOperation(%1, %2, %3)
+  attr.action.%6,%7 : BuildInstanceOf(%1, %3)
+
+
+##-----------------------------------
+##rule EqualityExpression[In, Yield] :
+##  RelationalExpression[?In, ?Yield]
+##  EqualityExpression[?In, ?Yield] == RelationalExpression[?In, ?Yield]
+##  EqualityExpression[?In, ?Yield] != RelationalExpression[?In, ?Yield]
+##  EqualityExpression[?In, ?Yield] === RelationalExpression[?In, ?Yield]
+##  EqualityExpression[?In, ?Yield] !== RelationalExpression[?In, ?Yield]
+
+rule EqualityExpression : ONEOF(
+  RelationalExpression,
+  EqualityExpression + "==" + RelationalExpression,
+  EqualityExpression + "!=" + RelationalExpression,
+  EqualityExpression + "===" + RelationalExpression,
+  EqualityExpression + "!==" + RelationalExpression)
+  attr.action.%2,%3,%4,%5 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule BitwiseANDExpression[In, Yield] :
+##  EqualityExpression[?In, ?Yield]
+##  BitwiseANDExpression[?In, ?Yield] & EqualityExpression[?In, ?Yield]
+
+rule BitwiseANDExpression : ONEOF(
+  EqualityExpression,
+  BitwiseANDExpression + '&' + EqualityExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule BitwiseXORExpression[In, Yield] :
+##  BitwiseANDExpression[?In, ?Yield]
+##  BitwiseXORExpression[?In, ?Yield] ^ BitwiseANDExpression[?In, ?Yield]
+
+rule BitwiseXORExpression : ONEOF(
+  BitwiseANDExpression,
+  BitwiseXORExpression + '^' + BitwiseANDExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule BitwiseORExpression[In, Yield] :
+##  BitwiseXORExpression[?In, ?Yield]
+##  BitwiseORExpression[?In, ?Yield] | BitwiseXORExpression[?In, ?Yield]
+
+rule BitwiseORExpression : ONEOF(
+  BitwiseXORExpression,
+  BitwiseORExpression + '|' + BitwiseXORExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule LogicalANDExpression[In, Yield] :
+##  BitwiseORExpression[?In, ?Yield]
+##  LogicalANDExpression[?In, ?Yield] && BitwiseORExpression[?In, ?Yield]
+
+rule LogicalANDExpression : ONEOF(
+  BitwiseORExpression,
+  LogicalANDExpression + "&&" + BitwiseORExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule LogicalORExpression[In, Yield] :
+##  LogicalANDExpression[?In, ?Yield]
+##  LogicalORExpression[?In, ?Yield] || LogicalANDExpression[?In, ?Yield]
+
+rule LogicalORExpression : ONEOF(
+  LogicalANDExpression,
+  LogicalORExpression + "||" + LogicalANDExpression)
+  attr.action.%2 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule ConditionalExpression[In, Yield] :
+##  LogicalORExpression[?In, ?Yield]
+##  LogicalORExpression[?In,?Yield] ? AssignmentExpression[In, ?Yield] : AssignmentExpression[?In, ?Yield]
+rule ConditionalExpression : ONEOF(
+  LogicalORExpression,
+  LogicalORExpression + '?' + AssignmentExpression + ':' + AssignmentExpression,
+  ConditionalExpression + "??" + ConditionalExpression)
+  attr.action.%2 : BuildTernaryOperation(%1, %3, %5)
+  attr.action.%3 : BuildBinaryOperation(%1, %2, %3)
+
+##-----------------------------------
+##rule AssignmentExpression[In, Yield] :
+##  ConditionalExpression[?In, ?Yield]
+##  [+Yield] YieldExpression[?In]
+##  ArrowFunction[?In, ?Yield]
+##  LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield]
+##  LeftHandSideExpression[?Yield] AssignmentOperator AssignmentExpression[?In, ?Yield]
+
+rule AssignmentExpression : ONEOF(
+  ConditionalExpression,
+  YieldExpression,
+  ArrowFunction,
+  LeftHandSideExpression + '=' + AssignmentExpression,
+  LeftHandSideExpression + AssignmentOperator + AssignmentExpression)
+  attr.action.%4,%5 : BuildAssignment(%1, %2, %3)
+
+rule AssignmentOperator : ONEOF("*=", "/=", "%=", "+=", "-=", "<<=", ">>=", ">>>=", "&=", "^=", "|=", "??=")
+
+##-----------------------------------
+##rule Expression[In, Yield] :
+##  AssignmentExpression[?In, ?Yield]
+##  Expression[?In, ?Yield] , AssignmentExpression[?In, ?Yield]
+
+## NOTE. I added "undefined" to expression because "undefined" is both a type and
+##       a value in Typescript. This is a weird rule.
+rule Expression : ONEOF(
+  AssignmentExpression,
+  Expression + ',' + AssignmentExpression,
+  "undefined")
+
+#-------------------------------------------------------------------------------
+#                                    Statements
+#-------------------------------------------------------------------------------
+
+rule TripleSlash : ONEOF( "///" + '<' + "reference" + "path" + '=' + Literal + '/' + '>',
+                          "///" + '<' + "reference" + "types"  + '=' + Literal + '/' + '>',
+                          "///" + '<' + "reference" + "lib"  + '=' + Literal + '/' + '>',
+                          "///" + '<' + "reference" + "no-default-lib"  + '=' + Literal + '/' + '>')
+  attr.action.%1,%2,%3,%4 : BuildTripleSlash(%4, %6)
+
+##-----------------------------------
+##rule Statement[Yield, Return] :
+##  BlockStatement[?Yield, ?Return]
+##  VariableStatement[?Yield]
+##  EmptyStatement
+##  ExpressionStatement[?Yield]
+##  IfStatement[?Yield, ?Return]
+##  BreakableStatement[?Yield, ?Return]
+##  ContinueStatement[?Yield]
+##  BreakStatement[?Yield]
+##  [+Return] ReturnStatement[?Yield]
+##  WithStatement[?Yield, ?Return]
+##  LabelledStatement[?Yield, ?Return]
+##  ThrowStatement[?Yield]
+##  TryStatement[?Yield, ?Return]
+##  DebuggerStatement
+
+rule Statement : ONEOF(
+  BlockStatement,
+  VariableStatement,
+  EmptyStatement,
+  ExpressionStatement,
+  IfStatement,
+  BreakableStatement,
+  ContinueStatement,
+  BreakStatement,
+  ReturnStatement,
+#  WithStatement[?Yield, ?Return]
+  LabelledStatement,
+  ThrowStatement,
+  TryStatement,
+  TripleSlash)
+#  DebuggerStatement
+  attr.property : Top
+  attr.property : Single  # This is extremely important to give CallExpression the
+                          # last chance IFF all previous rules fail.
+
+##-----------------------------------
+##rule Declaration[Yield] :
+##  HoistableDeclaration[?Yield]
+##  ClassDeclaration[?Yield]
+##  LexicalDeclaration[In, ?Yield]
+
+## NOTE. Typescript added InterfaceDeclaration, TypeAliasDeclaration, EnumDeclaration
+rule Declaration : ONEOF(HoistableDeclaration,
+                         ClassDeclaration,
+                         LexicalDeclaration + ZEROORONE(';'),
+                         InterfaceDeclaration,
+                         TypeAliasDeclaration,
+                         EnumDeclaration,
+                         NamespaceDeclaration,
+                         ExternalDeclaration,
+                         GlobalDeclaration)
+  attr.property : Top
+
+##-----------------------------------
+##rule HoistableDeclaration[Yield, Default] :
+##  FunctionDeclaration[?Yield,?Default]
+##  GeneratorDeclaration[?Yield, ?Default]
+rule HoistableDeclaration : ONEOF(FunctionDeclaration,
+                                  GeneratorDeclaration)
+
+##-----------------------------------
+##rule BreakableStatement[Yield, Return] :
+##  IterationStatement[?Yield, ?Return]
+##  SwitchStatement[?Yield, ?Return]
+rule BreakableStatement : ONEOF(IterationStatement,
+                                SwitchStatement)
+
+##-----------------------------------
+##rule BlockStatement[Yield, Return] :
+##  Block[?Yield, ?Return]
+rule BlockStatement : Block
+
+##-----------------------------------
+##rule Block[Yield, Return] :
+##  { StatementList[?Yield, ?Return]opt }
+rule Block : '{' + ZEROORONE(StatementList) + '}'
+  attr.action : BuildBlock(%2)
+
+##-----------------------------------
+##rule StatementList[Yield, Return] :
+##  StatementListItem[?Yield, ?Return]
+##  StatementList[?Yield, ?Return] StatementListItem[?Yield, ?Return]
+rule StatementList : ONEOF(StatementListItem,
+                           StatementList + StatementListItem)
+
+##-----------------------------------
+##rule StatementListItem[Yield, Return] :
+##  Statement[?Yield, ?Return]
+##  Declaration[?Yield]
+rule StatementListItem : ONEOF(Statement, Declaration)
+
+##-----------------------------------
+##rule LexicalDeclaration[In, Yield] :
+##  LetOrConst BindingList[?In, ?Yield] ;
+rule LexicalDeclaration : ONEOF("let" + BindingList,
+                                "const" + BindingList)
+  attr.action.%1,%2 : BuildDecl(%2)
+  attr.action.%1    : SetJSLet()
+  attr.action.%2    : SetJSConst()
+
+##-----------------------------------
+##rule LetOrConst :
+##  let
+##  const
+rule LetOrConst : ONEOF("let", "const")
+
+##-----------------------------------
+##rule BindingList[In, Yield] :
+##  LexicalBinding[?In, ?Yield]
+##  BindingList[?In, ?Yield] , LexicalBinding[?In, ?Yield]
+rule BindingList : ONEOF(LexicalBinding,
+                         BindingList + ',' + LexicalBinding)
+
+##-----------------------------------
+##rule LexicalBinding[In, Yield] :
+##  BindingIdentifier[?Yield] Initializer[?In, ?Yield]opt
+##  BindingPattern[?Yield] Initializer[?In, ?Yield]
+rule LexicalBinding : ONEOF(BindingIdentifier + ZEROORONE(Initializer),
+                            BindingIdentifier + ":" + Type + ZEROORONE(Initializer),
+                            BindingPattern    + ZEROORONE(Initializer),
+                            BindingPattern    + ":" + Type + ZEROORONE(Initializer))
+  attr.action.%1,%3 : AddInitTo(%1, %2)
+  attr.action.%2,%4 : AddInitTo(%1, %4)
+  attr.action.%2,%4 : AddType(%1, %3)
+
+##-----------------------------------
+##rule VariableStatement[Yield] :
+##  var VariableDeclarationList[In, ?Yield] ;
+rule VariableStatement : "var" + VariableDeclarationList + ZEROORONE(';')
+  attr.action : PassChild(%2)
+
+##-----------------------------------
+##rule VariableDeclarationList[In, Yield] :
+##  VariableDeclaration[?In, ?Yield]
+##  VariableDeclarationList[?In, ?Yield] , VariableDeclaration[?In, ?Yield]
+rule VariableDeclarationList : ONEOF(
+  VariableDeclaration,
+  VariableDeclarationList + ',' + VariableDeclaration)
+
+##-----------------------------------
+##rule VariableDeclaration[In, Yield] :
+##  BindingIdentifier[?Yield] Initializer[?In, ?Yield]opt
+##  BindingPattern[?Yield] Initializer[?In, ?Yield]
+
+# Typescript ask for explicit type. But it also allows implicit type if referrable.
+rule VariableDeclaration : ONEOF(BindingIdentifier + ':' + Type + ZEROORONE(Initializer),
+                                 BindingIdentifier + ZEROORONE(Initializer),
+                                 BindingPattern + ZEROORONE(TypeAnnotation) + Initializer)
+  attr.action.%1 : AddInitTo(%1, %4)
+  attr.action.%1 : BuildDecl(%3, %1)
+  attr.action.%1 : SetJSVar()
+  attr.action.%2 : AddInitTo(%1, %2)
+  attr.action.%2 : BuildDecl(%1)
+  attr.action.%2 : SetJSVar()
+  attr.action.%3 : AddInitTo(%1, %3)
+  attr.action.%3 : BuildDecl(%2, %1)
+  attr.action.%3 : SetJSVar()
+
+##-----------------------------------
+##rule BindingPattern[Yield] :
+##  ObjectBindingPattern[?Yield]
+##  ArrayBindingPattern[?Yield]
+rule BindingPattern : ONEOF(ObjectBindingPattern, ArrayBindingPattern)
+
+##-----------------------------------
+##rule ObjectBindingPattern[Yield] :
+##  { }
+##  { BindingPropertyList[?Yield] }
+##  { BindingPropertyList[?Yield] , }
+rule ObjectBindingPattern : ONEOF('{' + '}',
+                                  '{' + BindingPropertyList + '}',
+                                  '{' + BindingPropertyList + ',' + '}')
+  attr.action.%1 :    BuildBindingPattern()
+  attr.action.%2,%3 : BuildBindingPattern(%2)
+  attr.action.%1,%2,%3 : SetObjectBinding()
+
+##-----------------------------------
+##rule ArrayBindingPattern[Yield] :
+##  [ Elisionopt BindingRestElement[?Yield]opt ]
+##  [ BindingElementList[?Yield] ]
+##  [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+rule ArrayBindingPattern : ONEOF(
+  '[' + ZEROORONE(Elision) + ZEROORONE(BindingRestElement) + ']',
+  '[' + BindingElementList + ']',
+  '[' + BindingElementList + ',' + ZEROORONE(Elision) + ZEROORONE(BindingRestElement) + ']')
+  attr.action.%1 :    BuildBindingPattern(%3)
+  attr.action.%2,%3 : BuildBindingPattern(%2)
+  attr.action.%1,%2,%3 : SetArrayBinding()
+
+##-----------------------------------
+##rule BindingPropertyList[Yield] :
+##  BindingProperty[?Yield]
+##  BindingPropertyList[?Yield] , BindingProperty[?Yield]
+rule BindingPropertyList : ONEOF(BindingProperty,
+                                 BindingPropertyList + ',' + BindingProperty,
+                                 BindingPropertyList + ',' + BindingRestProperty)
+
+##-----------------------------------
+##rule BindingElementList[Yield] :
+##  BindingElisionElement[?Yield]
+##  BindingElementList[?Yield] , BindingElisionElement[?Yield]
+rule BindingElementList : ONEOF(
+  BindingElisionElement,
+  BindingElementList + ',' + BindingElisionElement)
+
+##-----------------------------------
+##rule BindingElisionElement[Yield] :
+##  Elisionopt BindingElement[?Yield]
+rule BindingElisionElement : ZEROORONE(Elision) + BindingElement
+  attr.action : PassChild(%2)
+
+##-----------------------------------
+##rule BindingProperty[Yield] :
+##  SingleNameBinding[?Yield]
+##  PropertyName[?Yield] : BindingElement[?Yield]
+rule BindingProperty : ONEOF(SingleNameBinding,
+                             PropertyName + ':' + BindingElement)
+  attr.action.%2 : BuildBindingElement(%1, %3)
+
+rule BindingRestProperty : BindingRestElement
+
+##-----------------------------------
+##rule BindingElement[Yield] :
+##  SingleNameBinding[?Yield]
+##  BindingPattern[?Yield] Initializer[In, ?Yield]opt
+rule BindingElement : ONEOF(SingleNameBinding,
+                            BindingPattern + ZEROORONE(Initializer))
+  attr.action.%2 : AddInitTo(%1, %2)
+
+##-----------------------------------
+##rule SingleNameBinding[Yield] :
+##  BindingIdentifier[?Yield] Initializer[In, ?Yield]opt
+rule SingleNameBinding : BindingIdentifier + ZEROORONE(Initializer)
+  attr.action : AddInitTo(%1, %2)
+  attr.action : BuildBindingElement(%1)
+
+##-----------------------------------
+##rule BindingRestElement[Yield] :
+##  ... BindingIdentifier[?Yield]
+rule BindingRestElement : "..." + BindingIdentifier
+  attr.action : SetIsRest(%2)
+  attr.action : BuildBindingElement(%2)
+
+##-----------------------------------
+##rule EmptyStatement :
+##  ;
+rule EmptyStatement : ';'
+
+##-----------------------------------
+##rule ExpressionStatement[Yield] :
+##  [lookahead NotIn {{, function, class, let [}] Expression[In, ?Yield] ;
+
+rule ExpressionStatement : ONEOF(
+                                 ConditionalExpression + ASI(';'),
+                                 YieldExpression + ';',
+                                 ArrowFunction + ';',
+                                 LeftHandSideExpression + '=' + AssignmentExpression + ZEROORONE(';'),
+                                 LeftHandSideExpression + AssignmentOperator + AssignmentExpression + ZEROORONE(';'),
+                                 Expression + ',' + AssignmentExpression + ';',
+                                 "undefined" + ';',
+                                 LeftHandSideExpression + "++",
+                                 LeftHandSideExpression + "--")
+
+  attr.action.%4,%5 : BuildAssignment(%1, %2, %3)
+  attr.action.%8,%9 : BuildPostfixOperation(%2, %1)
+
+##-----------------------------------
+##rule IfStatement[Yield, Return] :
+##  if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else Statement[?Yield, ?Return]
+##  if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return]
+rule IfStatement : ONEOF(
+  "if" + '(' + Expression + ')' + Statement + "else" + Statement,
+  "if" + '(' + Expression + ')' + Statement)
+  attr.action.%1,%2: BuildCondBranch(%3)
+  attr.action.%1,%2: AddCondBranchTrueStatement(%5)
+  attr.action.%1:    AddCondBranchFalseStatement(%7)
+
+## " // This line is to make my vim in right color
+
+##-----------------------------------
+##rule IterationStatement[Yield, Return] :
+##  do Statement[?Yield, ?Return] while ( Expression[In, ?Yield] ) ;
+##  while ( Expression[In, ?Yield] ) Statement[?Yield, ?Return]
+##  for ( [lookahead NotIn {let [}] Expression[?Yield]opt ; Expression[In, ?Yield]opt ; Expression[In, ?Yield]opt ) Statement[?Yield, ?Return]
+##  for ( var VariableDeclarationList[?Yield] ; Expression[In, ?Yield]opt ; Expression[In, ?Yield]opt ) Statement[?Yield, ?Return]
+##  for ( LexicalDeclaration[?Yield] Expression[In, ?Yield]opt ; Expression[In, ?Yield]opt ) Statement[?Yield, ?Return]
+##  for ( [lookahead NotIn {let [}] LeftHandSideExpression[?Yield] in Expression[In, ?Yield] ) Statement[?Yield, ?Return]
+##  for ( var ForBinding[?Yield] in Expression[In, ?Yield] ) Statement[?Yield, ?Return]
+##  for ( ForDeclaration[?Yield] in Expression[In, ?Yield] ) Statement[?Yield, ?Return]
+##  for ( [lookahead NotEq let ] LeftHandSideExpression[?Yield] of AssignmentExpression[In, ?Yield] ) Statement[?Yield, ?Return]
+##  for ( var ForBinding[?Yield] of AssignmentExpression[In, ?Yield] ) Statement[?Yield, ?Return]
+##  for ( ForDeclaration[?Yield] of AssignmentExpression[In, ?Yield] ) Statement[?Yield, ?Return]
+rule IterationStatement : ONEOF(
+  "do" + Statement + "while" + '(' + Expression + ')' + ';',
+  "while" + '(' + Expression + ')' + Statement,
+  "for" + '(' + ZEROORONE(Expression) + ';' + ZEROORONE(Expression) + ';' + ZEROORONE(Expression) + ')' + Statement,
+  "for" + '(' + "var" + VariableDeclarationList + ';' + ZEROORONE(Expression) + ';' + ZEROORONE(Expression) + ')' + Statement,
+  "for" + '(' + LexicalDeclaration + ';' + ZEROORONE(Expression) + ';' + ZEROORONE(Expression) + ')' + Statement,
+  "for" + '(' + LeftHandSideExpression + "in" + Expression + ')' + Statement,
+  "for" + '(' + "var" + ForBinding + "in" + Expression + ')' + Statement,
+  "for" + '(' + ForDeclaration + "in" + Expression + ')' + Statement,
+  "for" + '(' + LeftHandSideExpression + "of" + AssignmentExpression + ')' + Statement,
+  "for" + '(' + "var" + ForBinding + "of" + AssignmentExpression + ')' + Statement,
+  "for" + '(' + "let" + ForBinding + "of" + AssignmentExpression + ')' + Statement,
+  "for" + '(' + "const" + ForBinding + "of" + AssignmentExpression + ')' + Statement,
+  )
+  attr.action.%1 : BuildDoLoop(%5, %2)
+  attr.action.%2 : BuildWhileLoop(%3, %5)
+  attr.action.%3 : BuildForLoop(%3, %5, %7, %9)
+  attr.action.%4 : BuildForLoop(%4, %6, %8, %10)
+  attr.action.%5 : BuildForLoop(%3, %5, %7, %9)
+
+  attr.action.%7,%10 : BuildDecl(%4)
+  attr.action.%7,%10 : SetJSVar()
+  attr.action.%7 :    BuildForLoop_In(%6, %8)
+  attr.action.%6,%8 : BuildForLoop_In(%3, %5, %7)
+  attr.action.%9    : BuildForLoop_Of(%3, %5, %7)
+  attr.action.%10 :   BuildForLoop_Of(%6, %8)
+
+  attr.action.%11,%12 : BuildDecl(%4)
+  attr.action.%11 : SetJSLet()
+  attr.action.%12 : SetJSConst()
+  attr.action.%11,%12 : BuildForLoop_Of(%6, %8)
+
+##-----------------------------------
+##rule ForDeclaration[Yield] :
+##  LetOrConst ForBinding[?Yield]
+rule ForDeclaration : ONEOF("let" + ForBinding,
+                            "const" + ForBinding)
+  attr.action.%1,%2 : BuildDecl(%2)
+  attr.action.%1    : SetJSLet()
+  attr.action.%2    : SetJSConst()
+
+##-----------------------------------
+##rule ForBinding[Yield] :
+##  BindingIdentifier[?Yield]
+##  BindingPattern[?Yield]
+rule ForBinding : ONEOF(BindingIdentifier,
+                        BindingPattern)
+
+##-----------------------------------
+##rule ContinueStatement[Yield] :
+##  continue ;
+##  continue [no LineTerminator here] LabelIdentifier[?Yield] ;
+rule ContinueStatement : ONEOF(
+  "continue" + ZEROORONE(';'),
+  "continue" + NoLineTerminator + LabelIdentifier + ZEROORONE(';'))
+  attr.action.%1 : BuildContinue()
+  attr.action.%2 : BuildContinue(%3)
+
+##-----------------------------------
+##rule BreakStatement[Yield] :
+##  break ;
+##  break [no LineTerminator here] LabelIdentifier[?Yield] ;
+rule BreakStatement : ONEOF(
+  "break" + ZEROORONE(';'),
+  "break" + NoLineTerminator + LabelIdentifier + ZEROORONE(';'))
+  attr.action.%1 : BuildBreak()
+  attr.action.%2 : BuildBreak(%3)
+
+##-----------------------------------
+##rule ReturnStatement[Yield] :
+##  return ;
+##  return [no LineTerminator here] Expression[In, ?Yield] ;
+rule ReturnStatement :ONEOF("return" + ZEROORONE(';'),
+                            "return" + NoLineTerminator + Expression + ZEROORONE(';'))
+  attr.action.%1 : BuildReturn()
+  attr.action.%2 : BuildReturn(%3)
+
+##-----------------------------------
+##rule WithStatement[Yield, Return] :
+##  with ( Expression[In, ?Yield] ) Statement[?Yield, ?Return]
+
+##-----------------------------------
+##rule SwitchStatement[Yield, Return] :
+##  switch ( Expression[In, ?Yield] ) CaseBlock[?Yield, ?Return]
+rule SwitchStatement :
+  "switch" + '(' + Expression + ')' + CaseBlock
+  attr.action : BuildSwitch(%3, %5)
+
+##-----------------------------------
+##rule CaseBlock[Yield, Return] :
+##  { CaseClauses[?Yield, ?Return]opt }
+##  { CaseClauses[?Yield, ?Return]opt DefaultClause[?Yield, ?Return] CaseClauses[?Yield, ?Return]opt }
+rule CaseBlock : ONEOF(
+  '{' + ZEROORONE(CaseClauses) + '}',
+  '{' + ZEROORONE(CaseClauses) + DefaultClause + ZEROORONE(CaseClauses) + '}')
+
+##-----------------------------------
+##rule CaseClauses[Yield, Return] :
+##  CaseClause[?Yield, ?Return]
+##  CaseClauses[?Yield, ?Return] CaseClause[?Yield, ?Return]
+rule CaseClauses : ONEOF(
+  CaseClause,
+  CaseClauses + CaseClause)
+
+##-----------------------------------
+##rule CaseClause[Yield, Return] :
+##  case Expression[In, ?Yield] : StatementList[?Yield, ?Return]opt
+rule CaseClause :
+  "case" + Expression + ':' + ZEROORONE(StatementList)
+  attr.action : BuildSwitchLabel(%2)
+  attr.action : BuildOneCase(%4)
+
+##-----------------------------------
+##rule DefaultClause[Yield, Return] :
+##  default : StatementList[?Yield, ?Return]opt
+rule DefaultClause :
+  "default" + ':' + ZEROORONE(StatementList)
+  attr.action : BuildDefaultSwitchLabel()
+  attr.action : BuildOneCase(%3)
+
+##-----------------------------------
+##rule LabelledStatement[Yield, Return] :
+##  LabelIdentifier[?Yield] : LabelledItem[?Yield, ?Return]
+rule LabelledStatement :
+  LabelIdentifier + ':' + LabelledItem
+  attr.action : AddLabel(%3, %1)
+
+##-----------------------------------
+##rule LabelledItem[Yield, Return] :
+##  Statement[?Yield, ?Return]
+##  FunctionDeclaration[?Yield]
+rule LabelledItem : ONEOF(Statement, FunctionDeclaration)
+
+##-----------------------------------
+##rule ThrowStatement[Yield] :
+##  throw [no LineTerminator here] Expression[In, ?Yield] ;
+rule ThrowStatement : "throw" + Expression + ZEROORONE(';')
+  attr.action : BuildThrows(%2)
+
+##-----------------------------------
+##rule TryStatement[Yield, Return] :
+##  try Block[?Yield, ?Return] Catch[?Yield, ?Return]
+##  try Block[?Yield, ?Return] Finally[?Yield, ?Return]
+##  try Block[?Yield, ?Return] Catch[?Yield, ?Return] Finally[?Yield, ?Return]
+rule TryStatement : ONEOF(
+  "try" + Block + Catch,
+  "try" + Block + Finally,
+  "try" + Block + Catch + Finally)
+  attr.action.%1,%2,%3 : BuildTry(%2)
+  attr.action.%1,%3 : AddCatch(%3)
+  attr.action.%2 : AddFinally(%3)
+  attr.action.%3 : AddFinally(%4)
+
+##-----------------------------------
+##rule Catch[Yield, Return] :
+##  catch ( CatchParameter[?Yield] ) Block[?Yield, ?Return]
+rule Catch : ONEOF("catch" + '(' + CatchParameter + ')' + Block,
+                   "catch" + Block)
+  attr.action.%1 : BuildCatch(%3, %5)
+  attr.action.%2 : BuildCatch(%2)
+
+##-----------------------------------
+##rule Finally[Yield, Return] :
+##  finally Block[?Yield, ?Return]
+rule Finally : "finally" + Block
+  attr.action : BuildFinally(%2)
+
+##-----------------------------------
+##rule CatchParameter[Yield] :
+##  BindingIdentifier[?Yield]
+##  BindingPattern[?Yield]
+rule CatchParameter : ONEOF(BindingIdentifier + ZEROORONE(TypeAnnotation),
+                            BindingPattern)
+  attr.action.%1 : AddType(%1, %2)
+
+##-----------------------------------
+rule DebuggerStatement : "debugger" + ';'
+
+
+######################################################################
+##                      Function and Class
+######################################################################
+
+## NOTE: Replaced by TS 
+## FunctionDeclaration[Yield, Default] :
+## function BindingIdentifier[?Yield] ( FormalParameters ) { FunctionBody }
+## [+Default] function ( FormalParameters ) { FunctionBody }
+
+##
+## FunctionExpression :
+## function BindingIdentifieropt ( FormalParameters ) { FunctionBody }
+
+##
+## StrictFormalParameters[Yield] :
+## FormalParameters[?Yield]
+rule StrictFormalParameters : FormalParameters
+
+##
+## FormalParameters[Yield] :
+## [empty]
+## FormalParameterList[?Yield]
+rule FormalParameters : ZEROORONE(FormalParameterList)
+
+##
+## FormalParameterList[Yield] :
+## FunctionRestParameter[?Yield]
+## FormalsList[?Yield]
+## FormalsList[?Yield] , FunctionRestParameter[?Yield]
+rule FormalParameterList : ONEOF(FunctionRestParameter,
+                                 FormalsList,
+                                 FormalsList + ',' + FunctionRestParameter)
+
+##
+## FormalsList[Yield] :
+## FormalParameter[?Yield]
+## FormalsList[?Yield] , FormalParameter[?Yield]
+rule FormalsList : ONEOF(FormalParameter,
+                         FormalsList + ',' + FormalParameter)
+
+##
+## FunctionRestParameter[Yield] :
+## BindingRestElement[?Yield]
+rule FunctionRestParameter : BindingRestElement
+
+##
+## FormalParameter[Yield] :
+## BindingElement[?Yield]
+
+## Typescript requires type. So this is different than JS spec.
+rule FormalParameter : BindingElement
+  attr.action : BuildDecl(%3, %1)
+
+##
+## FunctionBody[Yield] :
+## FunctionStatementList[?Yield]
+## NOTE. I used ZEROORONE(StatementList) directly in order to avoid
+##       an issue where FunctionStatementList fail when looking for
+##       its lookahead, if function body is empty.
+rule FunctionBody : ZEROORONE(StatementList)
+  attr.action : BuildBlock(%1)
+
+##
+## FunctionStatementList[Yield] :
+## StatementList[?Yield, Return]opt
+rule FunctionStatementList : ZEROORONE(StatementList)
+
+## See 14.2
+## ArrowFunction[In, Yield] :
+## ArrowParameters[?Yield] [no LineTerminator here] => ConciseBody[?In]
+
+# (1) I inline ArrowParameters
+# (2) In CoverParent.... is replaced by ArrowFormalParameters which in turn is changed
+#     to CallSignature in Typescript. I inline CallSignature here.
+rule ArrowFunction : ONEOF(
+  BindingIdentifier + "=>" + ConciseBody,
+  ZEROORONE(AccessibilityModifier) + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation) + "=>" + ConciseBody)
+  attr.action.%1 : BuildLambda(%1, %3)
+  attr.action.%2 : BuildLambda(%4, %8)
+  attr.action.%2 : AddType(%6)
+  attr.action.%2 : AddTypeGenerics(%2)
+  attr.action.%2 : AddModifier(%1)
+  attr.action.%1,%2 : SetArrowFunction()
+
+## See 14.2
+## ArrowParameters[Yield] :
+## BindingIdentifier[?Yield]
+## CoverParenthesizedExpressionAndArrowParameterList[?Yield]
+## When the production ArrowParameters:CoverParenthesizedExpressionAndArrowParameterList is recognized the following
+## grammar is used to refine the interpretation of CoverParenthesizedExpressionAndArrowParameterList:
+##ArrowFormalParameters[Yield]:
+##(StrictFormalParameters[?Yield])
+rule ArrowParameters : ONEOF(BindingIdentifier,
+                             ArrowFormalParameters)
+
+rule ArrowFormalParameters : '(' + StrictFormalParameters + ')'
+
+## See 14.2
+## ConciseBody[In] :
+## [lookahead ≠ { ] AssignmentExpression[?In]
+## { FunctionBody }
+rule ConciseBody : ONEOF(AssignmentExpression,
+                         '{' + FunctionBody + '}')
+
+## 
+## See 14.3
+## MethodDefinition[Yield] :
+## PropertyName[?Yield] ( StrictFormalParameters ) { FunctionBody }
+## GeneratorMethod[?Yield]
+## get PropertyName[?Yield] ( ) { FunctionBody }
+## set PropertyName[?Yield] ( PropertySetParameterList ) { FunctionBody }
+
+## See 14.3
+## PropertySetParameterList :
+## FormalParameter
+## See 14.4
+## GeneratorMethod[Yield] :
+## * PropertyName[?Yield] ( StrictFormalParameters[Yield] ) { GeneratorBody }
+
+## See 14.4
+## GeneratorDeclaration[Yield, Default] :
+## function * BindingIdentifier[?Yield] ( FormalParameters[Yield] ) { GeneratorBody }
+## [+Default] function * ( FormalParameters[Yield] ) { GeneratorBody }
+rule GeneratorDeclaration :
+ "function" + '*' + BindingIdentifier + '(' + ZEROORONE(ParameterList) + ')' + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}'
+  attr.action : BuildFunction(%3)
+  attr.action : AddParams(%5)
+  attr.action : AddType(%7)
+  attr.action : AddFunctionBody(%9)
+  attr.action : SetIsGenerator()
+
+## See 14.4
+## GeneratorExpression :
+## function * BindingIdentifier[Yield]opt ( FormalParameters[Yield] ) { GeneratorBody }
+
+## See 14.4
+## GeneratorBody :
+## FunctionBody[Yield]
+
+## See 14.4
+## YieldExpression[In] :
+## yield
+## yield [no LineTerminator here] AssignmentExpression[?In, Yield]
+## yield [no LineTerminator here] * AssignmentExpression[?In, Yield]
+
+rule YieldExpression : ONEOF("yield",
+                             "yield" + AssignmentExpression,
+                             "yield" + '*' + AssignmentExpression)
+  attr.action.%1: BuildYield()
+  attr.action.%2: BuildYield(%2)
+  attr.action.%3: BuildYield(%3)
+  attr.action.%3: SetIsTransfer()
+
+## See 14.5
+## ClassDeclaration[Yield, Default] :
+## class BindingIdentifier[?Yield] ClassTail[?Yield]
+## [+Default] class ClassTail[?Yield]
+## See 14.5
+## ClassExpression[Yield] :
+## class BindingIdentifier[?Yield]opt ClassTail[?Yield]
+## See 14.5
+## ClassTail[Yield] :
+## ClassHeritage[?Yield]opt { ClassBody[?Yield]opt }
+## See 14.5
+## ClassHeritage[Yield] :
+## extends LeftHandSideExpression[?Yield]
+
+## See 14.5
+## ClassBody[Yield] :
+## ClassElementList[?Yield]
+rule ClassBody : ClassElementList
+  attr.action: BuildBlock(%1)
+
+## See 14.5
+## ClassElementList[Yield] :
+## ClassElement[?Yield]
+## ClassElementList[?Yield] ClassElement[?Yield]
+rule ClassElementList : ONEOF(ClassElement,
+                              ClassElementList + ClassElement)
+
+## See 14.5
+## ClassElement[Yield] :
+## MethodDefinition[?Yield]
+## static MethodDefinition[?Yield]
+## ;
+
+#############################################################################
+##                   A.5 Scripts and Modules
+#############################################################################
+
+## See 15.1
+## Script : ## ScriptBodyopt
+rule Script : ZEROORONE(ScriptBody)
+
+## See 15.1
+## ScriptBody : ## StatementList
+rule ScriptBody : StatementList
+
+## Module : ModuleBodyopt
+rule Module : ZEROORONE(ModuleBody)
+
+## ModuleBody : ModuleItemList
+rule ModuleBody : ModuleItemList
+
+## ModuleItemList :
+## ModuleItem
+## ModuleItemList ModuleItem
+rule ModuleItemList : ONEOF(ModuleItem,
+                            ModuleItemList + ModuleItem)
+
+## ModuleItem :
+## ImportDeclaration
+## ExportDeclaration
+## StatementListItem
+rule ModuleItem : ONEOF(ImportDeclaration,
+                        ExportDeclaration,
+                        StatementListItem)
+
+## ImportDeclaration :
+## import ImportClause FromClause ;
+## import ModuleSpecifier ;
+rule ImportDeclaration : ONEOF("import" + ImportClause + FromClause + ZEROORONE(';'),
+                               "import" + ModuleSpecifier + ZEROORONE(';'),
+                               "import" + BindingIdentifier + '=' + "require" + '(' + AssignmentExpression + ')' + ZEROORONE(';'),
+                               "import" + "type" + NamedImports + FromClause + ZEROORONE(';'),
+                               "import" + "type" + NameSpaceImport + FromClause + ZEROORONE(';'),
+                               "import" + "type" + ImportedDefaultBinding + FromClause + ZEROORONE(';'),
+                               ImportAliasDeclaration)
+  attr.property : Top
+  attr.action.%1,%2,%3,%4,%5,%6 : BuildImport()
+  attr.action.%1 :    SetPairs(%2)
+  attr.action.%1 :    SetFromModule(%3)
+  attr.action.%2 :    SetFromModule(%2)
+  attr.action.%3 :    SetSinglePairs(%6, %2)
+  attr.action.%4,%5,%6 : SetPairs(%3)
+  attr.action.%4,%5,%6 : SetFromModule(%4)
+  attr.action.%4,%5,%6 : SetIsXXportType()
+
+## ImportClause :
+## ImportedDefaultBinding
+## NameSpaceImport
+## NamedImports
+## ImportedDefaultBinding , NameSpaceImport
+## ImportedDefaultBinding , NamedImports
+rule ImportClause : ONEOF(ImportedDefaultBinding,
+                          NameSpaceImport,
+                          NamedImports,
+                          ImportedDefaultBinding + ',' + NameSpaceImport,
+                          ImportedDefaultBinding + ',' + NamedImports)
+
+## See 15.2.2
+## ImportedDefaultBinding :
+## ImportedBinding
+rule ImportedDefaultBinding : ImportedBinding
+  attr.action : BuildXXportAsPairDefault(%1)
+
+## See 15.2.2
+## NameSpaceImport :
+## * as ImportedBinding
+rule NameSpaceImport : '*' + "as" + ImportedBinding
+  attr.action : BuildXXportAsPairEverything(%3)
+
+## See 15.2.2
+## NamedImports :
+## { }
+## { ImportsList }
+## { ImportsList , }
+rule NamedImports : ONEOF('{' + '}',
+                          '{' + ImportsList + '}',
+                          '{' + ImportsList + ',' + '}')
+
+## See 15.2.2
+## FromClause :
+## from ModuleSpecifier
+rule FromClause : "from" + ModuleSpecifier
+
+## See 15.2.2
+## ImportsList :
+## ImportSpecifier
+## ImportsList , ImportSpecifier
+rule ImportsList : ONEOF(ImportSpecifier,
+                         ImportsList + ',' + ImportSpecifier)
+
+## See 15.2.2
+## ImportSpecifier :
+## ImportedBinding
+## IdentifierName as ImportedBinding
+rule ImportSpecifier : ONEOF(ImportedBinding,
+                             JSIdentifier + "as" + ImportedBinding,
+                             "default" + "as" + ImportedBinding)
+  attr.action.%2 : BuildXXportAsPair(%1, %3)
+  attr.action.%3 : BuildXXportAsPairDefault(%3)
+
+## See 15.2.2
+## ModuleSpecifier :
+## StringLiteral
+## NOTE. I extend StringLiteral to Literal to ease parser. 'tsc' will make sure
+##       it's a string literal.
+rule ModuleSpecifier : Literal
+
+## See 15.2.2
+## ImportedBinding :
+## BindingIdentifier
+rule ImportedBinding : BindingIdentifier
+
+## See 15.2.3
+## ExportDeclaration :
+## export * FromClause ;
+## export ExportClause FromClause ;
+## export ExportClause ;
+## export VariableStatement
+## export Declaration
+## export default HoistableDeclaration[Default]
+## export default ClassDeclaration[Default]
+## export default [lookahead ∉ {function, class}] AssignmentExpression[In] ;
+
+# export = expr;
+# is for export single syntax.
+rule ExportDeclaration : ONEOF(ZEROORMORE(Annotation) + "export" + '*' + FromClause + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + ExportClause + FromClause + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + ExportClause + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + VariableStatement,
+                               ZEROORMORE(Annotation) + "export" + Declaration + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + "default" + HoistableDeclaration,
+                               ZEROORMORE(Annotation) + "export" + "default" + ClassDeclaration,
+                               ZEROORMORE(Annotation) + "export" + "default" + AssignmentExpression + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + "=" + AssignmentExpression + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + "type" + ExportClause + FromClause + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + "type" + ExportClause + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + AsNamespace + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + ExternalModuleDeclaration + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + NameSpaceExport + FromClause + ZEROORONE(';'),
+                               ZEROORMORE(Annotation) + "export" + ImportAliasDeclaration,
+                               ZEROORMORE(Annotation) + "export" + TypeAliasDeclaration + ZEROORONE(';'))
+  attr.property : Top
+  attr.action.%1,%2,%3,%4,%5,%6,%7,%8,%9,%10,%11,%12,%13,%14,%15,%16 : BuildExport()
+  attr.action.%1,%2,%3,%4,%5,%6,%7,%8,%9,%10,%11,%12,%13,%14,%15,%16 : AddModifier(%1)
+  attr.action.%1       :    SetIsEverything()
+  attr.action.%2,%3,%4,%5,%12,%13,%14,%15,%16 : SetPairs(%3)
+  attr.action.%6,%7,%8 :    SetDefaultPairs(%4)
+  attr.action.%1,%2,%14 :   SetFromModule(%4)
+  attr.action.%9          : SetSinglePairs(%4)
+  attr.action.%10,%11     : SetPairs(%4)
+  attr.action.%10,%11     : SetIsXXportType()
+  attr.action.%10         : SetFromModule(%5)
+
+rule AsNamespace : "as" + "namespace" + JSIdentifier
+  attr.action : BuildXXportAsPair(%3)
+  attr.action : SetAsNamespace()
+
+rule NameSpaceExport : '*' + "as" + JSIdentifier
+  attr.action : BuildXXportAsPairEverything(%3)
+
+## See 15.2.3
+## ExportClause :
+## { }
+## { ExportsList }
+## { ExportsList , }
+rule ExportClause : ONEOF('{' + '}',
+                          '{' + ExportsList + '}',
+                          '{' + ExportsList + ',' + '}')
+
+## ExportsList :
+## ExportSpecifier
+## ExportsList , ExportSpecifier
+rule ExportsList : ONEOF(ExportSpecifier,
+                         ExportsList + ',' + ExportSpecifier)
+
+## See 15.2.3
+## ExportSpecifier :
+## IdentifierName
+## IdentifierName as IdentifierName
+rule KeywordExportName : ONEOF("import")
+  attr.action : BuildIdentifier()
+
+rule ExportSpecifier : ONEOF(JSIdentifier,
+                             JSIdentifier + "as" + BindingIdentifier,
+                             JSIdentifier + "as" + "default",
+                             "default" + "as" + JSIdentifier,
+                             JSIdentifier + "as" + "super",
+                             JSIdentifier + "as" + "function",
+                             JSIdentifier + "as" + KeywordExportName)
+  attr.action.%2,%5,%6,%7 : BuildXXportAsPair(%1, %3)
+  attr.action.%3 : BuildXXportAsPairDefault(%1)
+  attr.action.%4 : BuildXXportAsPairDefault(%3)
+
+#############################################################################
+#############################################################################
+#############################################################################
+##                    Below is Typescript specific
+#############################################################################
+#############################################################################
+#############################################################################
+
+#############################################################################
+##                        A.1 Type section
+#############################################################################
+
+## rule TypeParameters: < TypeParameterList >
+rule TypeParameters: '<' + TypeParameterList + '>'
+
+rule TypeParameterList: ONEOF(TypeParameter + ZEROORONE(Elision),
+                              TypeParameterList + ',' + TypeParameter + ZEROORONE(Elision))
+
+## rule TypeParameter: BindingIdentifier Constraintopt
+## It supports default type value of type parameter now.
+rule TypeParameter: BindingIdentifier + ZEROORONE(Constraint) + ZEROORONE(TypeInitializer)
+  attr.action : BuildTypeParameter(%1)
+  attr.action : AddInit(%3)
+  attr.action : AddTypeParameterExtends(%2)
+
+rule TypeInitializer : '=' + Type
+
+## rule Constraint: extends Type
+rule Constraint: "extends" + Type
+  attr.action : PassChild(%2)
+
+## rule TypeArguments: < TypeArgumentList >
+rule TypeArguments: '<' + TypeArgumentList + '>'
+
+## rule TypeArgumentList: TypeArgument TypeArgumentList , TypeArgument
+rule TypeArgumentList: ONEOF(TypeArgument,
+                             TypeArgumentList + ',' + TypeArgument)
+
+## rule TypeArgument: Type
+rule TypeArgument: Type
+
+rule ConditionalType : ONEOF(MemberExpression + "extends" + Type + '?' + Type + ':' + Type,
+                             TypeReference + "extends" + Type + '?' + Type + ':' + Type,
+                             ObjectType + "extends" + Type + '?' + Type + ':' + Type,
+                             "unknown" + "extends" + Type + '?' + Type + ':' + Type,
+                             PrimaryType + "extends" + Type + '?' + Type + ':' + Type,
+                             TypeQuery + "extends" + Type + '?' + Type + ':' + Type,
+                             TypeArray + "extends" + Type + '?' + Type + ':' + Type)
+  attr.action.%1,%2,%3,%4,%5,%6,%7 : BuildConditionalType(%1, %3, %5, %7)
+
+rule KeyOf : ONEOF("keyof" + Identifier,
+                   "keyof" + '(' + TypeQuery + ')',
+                   "keyof" + TypeQuery,
+                   "keyof" + MemberExpression,
+                   "keyof" + TypeReference)
+  attr.action.%1,%3,%4,%5 : BuildKeyOf(%2)
+  attr.action.%2 : BuildKeyOf(%3)
+
+rule InferType : "infer" + Identifier
+  attr.action : BuildInfer(%2)
+
+rule TypeArray : ONEOF(PrimaryType + '[' + PrimaryExpression + ']',
+                       PrimaryType + '[' + TypeReference + ']',
+                       TypeArray + '[' + PrimaryExpression + ']',
+                       PrimaryType + '[' + ConditionalType + ']',
+                       PrimaryType + '[' + TypeArray + ']')
+  attr.action.%1,%2,%3,%4,%5 : BuildArrayElement(%1, %3)
+
+rule PrimaryTypeKeyOf : PrimaryType + '[' + KeyOf + ']'
+  attr.action : BuildArrayElement(%1, %3)
+
+#rule Type : ONEOF(UnionOrIntersectionOrPrimaryType,
+#                  FunctionType,
+#                  ConstructorType)
+rule Type : ONEOF(UnionOrIntersectionOrPrimaryType,
+                  FunctionType,
+                  ConstructorType,
+                  KeyOf,
+                  ConditionalType,
+                  # Typescript interface[index] can be seen as a type
+                  TypeArray,
+                  MemberExpression + '[' + KeyOf + ']',
+                  PrimaryTypeKeyOf,
+                  InferType,
+                  IsExpression,
+                  PrimaryType + '[' + TypeQuery + ']',
+                  TemplateLiteral)
+  attr.action.%7,%11 : BuildArrayElement(%1, %3)
+
+#rule UnionOrIntersectionOrPrimaryType: ONEOF(UnionType,
+#                                             IntersectionOrPrimaryType)
+rule UnionOrIntersectionOrPrimaryType: ONEOF(UnionType,
+                                             IntersectionOrPrimaryType)
+
+#rule IntersectionOrPrimaryType : ONEOF(IntersectionType,
+#                                       PrimaryType)
+rule IntersectionOrPrimaryType : ONEOF(IntersectionType, PrimaryType, TypeArray)
+
+## rule PrimaryType: ParenthesizedType PredefinedType TypeReference ObjectType ArrayType TupleType TypeQuery ThisType
+rule PrimaryType: ONEOF(ParenthesizedType,
+                        PredefinedType,
+                        TypeReference,
+                        ObjectType,
+                        ArrayType,
+                        TupleType,
+                        TypeQuery,
+                        ThisType,
+                        NeverArrayType,
+                        Literal,
+                        ArrayLiteral,
+                        ImportFunction,
+                        ImportFunction + '.' + TypeReference)
+  attr.action.%13 : BuildField(%1, %3)
+
+rule NeverArrayType : '[' + ']'
+  attr.action : BuildNeverArrayType()
+
+## rule ParenthesizedType: ( Type )
+rule ParenthesizedType: '(' + Type + ')'
+
+## rule PredefinedType: any number boolean string symbol void
+rule PredefinedType: ONEOF(TYPE,
+                           "unique" + TYPE)
+  attr.action.%2 : SetIsUnique(%2)
+
+## rule TypeReference: TypeName [no LineTerminator here] TypeArgumentsopt
+rule TypeReference: TypeName + ZEROORONE(TypeArguments) + ZEROORMORE(AsType)
+  attr.action : BuildUserType(%1)
+  attr.action : AddTypeGenerics(%2)
+  attr.action : AddAsType(%3)
+
+## rule TypeName: IdentifierReference NamespaceName . IdentifierReference
+rule TypeName: ONEOF(IdentifierReference,
+                     NamespaceName + '.' + IdentifierReference,
+                     NamespaceName + '.' + KeywordPropName,
+                     '(' + IdentifierReference + ')',
+                     '(' + NamespaceName + '.' + IdentifierReference + ')')
+  attr.action.%2,%3 : BuildField(%1, %3)
+  attr.action.%5 : BuildField(%2, %4)
+
+## rule NamespaceName: IdentifierReference NamespaceName . IdentifierReference
+rule NamespaceName: ONEOF(IdentifierReference,
+                          NamespaceName + '.' + IdentifierReference)
+  attr.action.%2 : BuildField(%1, %3)
+
+## rule ObjectType: { TypeBodyopt }
+rule ObjectType : '{' + ZEROORONE(TypeBody) + '}'
+  attr.action : BuildStruct()
+  attr.action : AddStructField(%2)
+
+## rule TypeBody: TypeMemberList ;opt TypeMemberList ,opt
+rule TypeBody : ONEOF(TypeMemberList + ZEROORONE(';'),
+                      TypeMemberList + ZEROORONE(','))
+
+## rule TypeMemberList: TypeMember TypeMemberList ; TypeMember TypeMemberList , TypeMember
+rule TypeMemberList : ONEOF(TypeMember,
+                            TypeMemberList + ZEROORONE(';') + TypeMember,
+                            TypeMemberList + ZEROORONE(',') + TypeMember)
+
+## rule TypeMember: PropertySignature CallSignature ConstructSignature IndexSignature MethodSignature
+rule TypeMember : ONEOF(PropertySignature,
+                        CallSignature,
+                        ConstructSignature,
+                        IndexSignature,
+                        MethodSignature)
+
+## rule ArrayType: PrimaryType [no LineTerminator here] [ ]
+rule ArrayType: ONEOF(ZEROORONE("readonly") + PrimaryType + '[' + ']',
+                      SpreadElement + '[' + ']',
+                      MemberExpression + '[' + ']')
+  attr.action.%1 : BuildArrayType(%2, %2)
+  attr.action.%1 : AddModifier(%1)
+  attr.action.%2 : BuildArrayType(%1, %1)
+  attr.action.%3 : BuildArrayType(%1, %1)
+
+## rule TupleType: [ TupleElementTypes ]
+rule TupleType: ZEROORONE("readonly") + '[' + TupleElementTypes + ZEROORONE(Elision) + ']'
+  attr.action : BuildTupleType()
+  attr.action : AddModifier(%1)
+  attr.action : AddStructField(%3)
+
+## rule TupleElementTypes: TupleElementType TupleElementTypes , TupleElementType
+rule TupleElementTypes: ONEOF(TupleElementType,
+                              TupleElementTypes + ',' + TupleElementType)
+
+## rule TupleElementType: Type
+rule TupleElementType: ONEOF(ZEROORONE(JSIdentifier + ':') + Type,
+                             "..." + Type)
+  attr.action.%1 : BuildNameTypePair(%1, %2)
+  attr.action.%2 : SetIsRest(%2)
+  attr.action.%2 : BuildNameTypePair(%2)
+
+## rule UnionType: UnionOrIntersectionOrPrimaryType | IntersectionOrPrimaryType
+rule UnionType : ONEOF(ZEROORONE('|') + UnionOrIntersectionOrPrimaryType + '|' + IntersectionOrPrimaryType,
+                       UnionOrIntersectionOrPrimaryType + '|' + KeyOf,
+                       KeyOf + '|' + UnionOrIntersectionOrPrimaryType,
+                       TypeQuery + '|' + UnionOrIntersectionOrPrimaryType,
+                       TemplateLiteral + '|' + TemplateLiteral)
+  attr.action.%1 : BuildUnionUserType(%2, %4)
+  attr.action.%2,%3,%4,%5 : BuildUnionUserType(%1, %3)
+
+## rule IntersectionType: IntersectionOrPrimaryType & PrimaryType
+rule IntersectionType: ONEOF(IntersectionOrPrimaryType + '&' + PrimaryType,
+                             IntersectionOrPrimaryType + '&' + ConditionalType,
+                             PrimaryTypeKeyOf + '&' + PrimaryType)
+  attr.action.%1,%2,%3 : BuildInterUserType(%1, %3)
+
+## rule FunctionType: TypeParametersopt ( ParameterListopt ) => Type
+rule FunctionType: ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList) + ')' + "=>" + Type
+  attr.action : BuildLambda(%3)
+  attr.action : AddType(%6)
+  attr.action : AddTypeGenerics(%1)
+
+## rule ConstructorType: new TypeParametersopt ( ParameterListopt ) => Type
+## This actually a literal.
+rule ConstructorType: ZEROORONE(AccessibilityModifier) + "new" + FunctionType
+  attr.action : BuildNewOperation(%3)
+  attr.action : AddModifier(%1)
+
+## rule TypeQuery: typeof TypeQueryExpression
+rule TypeQuery: ONEOF("typeof" + TypeQueryExpression,
+                      "typeof" + '(' + ClassDeclaration + ')')
+  attr.action.%1 : BuildTypeOf(%2)
+  attr.action.%2 : BuildTypeOf(%3)
+
+## rule TypeQueryExpression: IdentifierReference TypeQueryExpression . IdentifierName
+rule TypeQueryExpression: ONEOF(IdentifierReference,
+                                TypeQueryExpression + '.' + JSIdentifier,
+                                UnaryExpression,
+                                ImportFunction)
+  attr.action.%2 : BuildField(%1, %3)
+
+## rule ThisType: this
+rule ThisType: "this"
+
+rule PropertySignatureName : ONEOF(PropertyName, KeywordPropName)
+
+## rule PropertySignature: PropertyName ?opt TypeAnnotationopt
+##
+## NOTE: for KeywordPropName we require them to have an explicit TypeAnnotation, or ',' or ';'
+##       following it. Otherwise there will be ambiguity, like:
+##          interface A {
+##                export() : string;
+##          }
+##       It could be parsed as one property 'export' and one call signature "() : string".
+
+rule PropertySignature: ONEOF(ZEROORONE(AccessibilityModifier) + PropertyName + ZEROORONE(TypeAnnotation),
+                              ZEROORONE(AccessibilityModifier) + PropertySignatureName + '?' + ZEROORONE(TypeAnnotation),
+                              ZEROORONE(AccessibilityModifier) + KeywordPropName + TypeAnnotation,
+                              ZEROORONE(AccessibilityModifier) + KeywordPropName + ',',
+                              ZEROORONE(AccessibilityModifier) + KeywordPropName + ';')
+  attr.action.%1,%3 : AddType(%2, %3)
+  attr.action.%2 : AddType(%2, %4)
+  attr.action.%2 : SetIsOptional(%2)
+  attr.action.%1,%2,%3,%4,%5: AddModifierTo(%2, %1)
+
+## JS ECMA has more definition than this Typescript one. I use ECMA one.
+## rule PropertyName: IdentifierName StringLiteral NumericLiteral
+##rule PropertyName : ONEOF(JSIdentifier,
+                          ##StringLiteral,
+                          ##NumericLiteral,
+##                         )
+
+## rule TypeAnnotation: : Type
+rule TypeAnnotation: ':' + Type
+
+## rule CallSignature: TypeParametersopt ( ParameterListopt ) TypeAnnotationopt
+rule CallSignature: ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation)
+  attr.action : BuildFunction()
+  attr.action : AddParams(%3)
+  attr.action : AddType(%5)
+  attr.action : SetCallSignature()
+
+## rule ParameterList: RequiredParameterList OptionalParameterList RestParameter RequiredParameterList , OptionalParameterList RequiredParameterList , RestParameter OptionalParameterList , RestParameter RequiredParameterList , OptionalParameterList , RestParameter
+rule ParameterList: ONEOF(RequiredParameterList + ZEROORONE(Elision),
+                          OptionalParameterList + ZEROORONE(Elision),
+                          RestParameter + ZEROORONE(Elision),
+                          RequiredParameterList + ',' + OptionalParameterList + ZEROORONE(Elision),
+                          RequiredParameterList + ',' + RestParameter + ZEROORONE(Elision),
+                          OptionalParameterList + ',' + RestParameter + ZEROORONE(Elision),
+                          RequiredParameterList + ',' + OptionalParameterList + ',' + RestParameter + ZEROORONE(Elision))
+
+## rule RequiredParameterList: RequiredParameter RequiredParameterList , RequiredParameter
+rule RequiredParameterList: ONEOF(RequiredParameter,
+                                  RequiredParameterList + ',' + RequiredParameter)
+
+## rule RequiredParameter: AccessibilityModifieropt BindingIdentifierOrPattern TypeAnnotationopt BindingIdentifier : StringLiteral
+## NOTE: I extend StringLiteral to Literal.
+## NOTE: I Added initializer. I guess the spec missed this part.
+rule RequiredParameter: ONEOF(
+  ZEROORMORE(AccessibilityModifier) + BindingIdentifierOrPattern + ZEROORONE(TypeAnnotation) + ZEROORONE(Initializer),
+  "this" + ZEROORONE(TypeAnnotation),
+  BindingIdentifier + ':' + Literal,
+  ObjectType)
+  attr.action.%1 : AddInitTo(%2, %4)
+  attr.action.%1 : BuildDecl(%3, %2)
+  attr.action.%2 : BuildDecl(%2, %1)
+
+## rule AccessibilityModifier: public private protected
+rule AccessibilityModifier: ONEOF("public", "private", "protected", "readonly", "static", "abstract", "async")
+
+## rule BindingIdentifierOrPattern: BindingIdentifier BindingPattern
+rule BindingIdentifierOrPattern: ONEOF(BindingIdentifier, BindingPattern)
+
+## rule OptionalParameterList: OptionalParameter OptionalParameterList , OptionalParameter
+rule OptionalParameterList: ONEOF(OptionalParameter,
+                                  OptionalParameterList + ',' + OptionalParameter)
+
+## rule OptionalParameter: AccessibilityModifieropt BindingIdentifierOrPattern ? TypeAnnotationopt AccessibilityModifieropt BindingIdentifierOrPattern TypeAnnotationopt Initializer BindingIdentifier ? : StringLiteral
+rule OptionalParameter: ONEOF(
+  ZEROORMORE(AccessibilityModifier) + BindingIdentifierOrPattern + '?' + ZEROORONE(TypeAnnotation),
+  ZEROORMORE(AccessibilityModifier) + BindingIdentifierOrPattern + ZEROORONE(TypeAnnotation) + Initializer,
+  BindingIdentifier + '?' + ':' + Literal)
+  attr.action.%1 : SetIsOptional(%2)
+  attr.action.%1 : BuildDecl(%4, %2)
+  attr.action.%2 : AddInitTo(%2, %4)
+  attr.action.%2 : BuildDecl(%3, %2)
+  attr.action.%3 : SetIsOptional(%1)
+
+## rule RestParameter: ... BindingIdentifier TypeAnnotationopt
+rule RestParameter: "..." + BindingIdentifier + ZEROORONE(TypeAnnotation)
+  attr.action : AddType(%2, %3)
+  attr.action : SetIsRest(%2)
+
+## rule ConstructSignature: new TypeParametersopt ( ParameterListopt ) TypeAnnotationopt
+rule ConstructSignature :
+  "new" + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList) + ')' + ZEROORONE(TypeAnnotation)
+  attr.action : BuildFunction()
+  attr.action : AddParams(%4)
+  attr.action : AddType(%6)
+  attr.action : SetConstructSignature()
+
+## rule IndexSignature: [ BindingIdentifier : string ] TypeAnnotation [ BindingIdentifier : number ] TypeAnnotation
+rule IndexSigPrefix : ONEOF('+', '-')
+rule IndexSigModifier : ONEOF("readonly", '?')
+
+rule IndexSignature: ONEOF(
+  ZEROORONE(IndexSigPrefix) + ZEROORONE(IndexSigModifier) + '[' + BindingIdentifier + ':' + "string" + ']' + ZEROORONE(IndexSigPrefix) + ZEROORONE(IndexSigModifier) + TypeAnnotation,
+  ZEROORONE(IndexSigPrefix) + ZEROORONE(IndexSigModifier) + '[' + BindingIdentifier + ':' + "number" + ']' + ZEROORONE(IndexSigPrefix) + ZEROORONE(IndexSigModifier) + TypeAnnotation)
+  attr.action.%1 : BuildStrIndexSig(%4, %10)
+  attr.action.%2 : BuildNumIndexSig(%4, %10)
+
+rule KeywordMethodName : ONEOF("return",
+                               "throw",
+                               "continue",
+                               "if",
+                               "import",
+                               "export")
+  attr.action : BuildIdentifier()
+
+## rule MethodSignature: PropertyName ?opt CallSignature
+## I inlined CallSignature
+rule MethodSignature: ONEOF(
+    PropertyName + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation),
+    PropertyName + '?' + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation),
+    KeywordMethodName  + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation),
+    KeywordMethodName  + '?' + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation))
+  attr.action.%1,%2,%3,%4 : BuildFunction(%1)
+  attr.action.%1,%3 : AddParams(%4)
+  attr.action.%1,%3 : AddType(%6)
+  attr.action.%1,%3 : AddTypeGenerics(%2)
+  attr.action.%2,%4 : SetIsOptional(%1)
+  attr.action.%2,%4 : AddParams(%5)
+  attr.action.%2,%4 : AddType(%7)
+  attr.action.%2,%4 : AddTypeGenerics(%3)
+
+## rule TypeAliasDeclaration: type BindingIdentifier TypeParametersopt = Type ;
+rule TypeAliasDeclaration: "type" + BindingIdentifier + ZEROORONE(TypeParameters) + '=' + Type + ZEROORONE(';')
+  attr.action : BuildTypeAlias(%2, %5)
+  attr.action : AddTypeGenerics(%3)
+
+
+##############################################################################################
+##                              A.2 Expression
+##############################################################################################
+
+rule AllPropertyName : ONEOF(PropertyName, KeywordPropName)
+
+## PropertyDefinition: ( Modified ) IdentifierReference CoverInitializedName PropertyName : AssignmentExpression PropertyName CallSignature { FunctionBody } GetAccessor SetAccessor
+rule PropertyDefinition: ONEOF(IdentifierReference,
+                               CoverInitializedName,
+                               AllPropertyName + ':' + AssignmentExpression,
+                               ZEROORONE(AccessibilityModifier) + AllPropertyName + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')'
+                                 + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}',
+                               GetAccessor,
+                               SetAccessor,
+                               SpreadElement)
+  attr.action.%3 : BuildFieldLiteral(%1, %3)
+  attr.action.%4 : BuildFunction(%2)
+  attr.action.%4 : AddType(%7)
+  attr.action.%4 : AddParams(%5)
+  attr.action.%4 : AddFunctionBody(%9)
+
+## GetAccessor: get PropertyName ( ) TypeAnnotationopt { FunctionBody }
+rule GetAccessor: ONEOF(ZEROORONE(AccessibilityModifier) + "get" + PropertyName + '(' + ')' + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}',
+                        ZEROORONE(AccessibilityModifier) + "get" + '(' + "this" + ')' + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}',
+                        ZEROORONE(AccessibilityModifier) + "get" + PropertyName + '(' + ')' + ZEROORONE(TypeAnnotation) + ';',
+                        ZEROORONE(AccessibilityModifier) + "get" + '(' + "this" + ')' + ZEROORONE(TypeAnnotation) + ';',
+                        ZEROORONE(AccessibilityModifier) + "get" + '(' + ')' + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}')
+  attr.action.%1,%3 : BuildFunction(%3)
+  attr.action.%1,%3 : SetGetAccessor()
+  attr.action.%1,%3 : AddType(%6)
+  attr.action.%1 : AddFunctionBody(%8)
+  attr.action.%1,%3 : AddModifier(%2)
+  attr.action.%1,%3 : AddModifier(%1)
+  attr.action.%2,%4,%5 : BuildFunction(%2)
+  attr.action.%2,%4,%5 : SetGetAccessor()
+  attr.action.%2,%4 : AddType(%6)
+  attr.action.%2 : AddFunctionBody(%8)
+  attr.action.%2,%4 : AddModifier(%2)
+  attr.action.%2,%4 : AddModifier(%1)
+  attr.action.%5 : AddType(%5)
+  attr.action.%5 : AddFunctionBody(%7)
+
+## SetAccessor: set PropertyName ( BindingIdentifierOrPattern TypeAnnotationopt ) { FunctionBody }
+rule SetAccessor: ONEOF(ZEROORONE(AccessibilityModifier) + "set" + PropertyName + '(' + BindingIdentifierOrPattern + ZEROORONE(TypeAnnotation) + ')' + '{' + FunctionBody + '}',
+                        ZEROORONE(AccessibilityModifier) + "set" + '(' + "this" + ',' + BindingIdentifierOrPattern + ZEROORONE(TypeAnnotation) + ')' + '{' + FunctionBody + '}',
+                        ZEROORONE(AccessibilityModifier) + "set" + PropertyName + '(' + BindingIdentifierOrPattern + ZEROORONE(TypeAnnotation) + ')' + ';',
+                        ZEROORONE(AccessibilityModifier) + "set" + '(' + "this" + ',' + BindingIdentifierOrPattern + ZEROORONE(TypeAnnotation) + ')' + ';',
+                        ZEROORONE(AccessibilityModifier) + "set" + '(' BindingIdentifierOrPattern + ZEROORONE(TypeAnnotation) + ')' + '{' + FunctionBody + '}')
+  attr.action.%1,%3 : AddType(%5, %6)
+  attr.action.%1,%3 : BuildFunction(%3)
+  attr.action.%1,%3 : SetSetAccessor()
+  attr.action.%1,%3 : AddParams(%5)
+  attr.action.%1 : AddFunctionBody(%9)
+  attr.action.%1,%3 : AddModifier(%2)
+  attr.action.%1,%3 : AddModifier(%1)
+  attr.action.%2,%4 : AddType(%6, %7)
+  attr.action.%2,%4,%5 : BuildFunction()
+  attr.action.%2,%4,%5 : SetSetAccessor()
+  attr.action.%2,%4 : AddParams(%6)
+  attr.action.%2 : AddFunctionBody(%10)
+  attr.action.%2,%4 : AddModifier(%2)
+  attr.action.%2,%4 : AddModifier(%1)
+  attr.action.%5 : AddParams(%4)
+  attr.action.%5 : AddFunctionBody(%8)
+  attr.action.%5 : AddModifier(%1)
+
+## We allow get/set as identifier for function name only.
+## we don't want to see keywords as identifier happening in everywhere.
+rule FunctionNameKeyword : ONEOF("get", "set")
+rule FunctionName : ONEOF(BindingIdentifier, FunctionNameKeyword)
+
+## FunctionExpression: ( Modified ) function BindingIdentifieropt CallSignature { FunctionBody }
+## FunctionExpression has the same syntax as FunctionDeclaration. But it appears as an expression. We will build it
+## as a FunctionNode in AST.
+rule FunctionExpression :
+  "function" + ZEROORONE(FunctionName) + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}'
+  attr.action : BuildFunction(%2)
+  attr.action : AddTypeGenerics(%3)
+  attr.action : AddParams(%5)
+  attr.action : AddType(%7)
+  attr.action : AddFunctionBody(%9)
+
+# ArrowFormalParameter is used in ArrowFunction, and Typescript modified
+# it to be CallSignature. As usual, I'd like to inline CallSignature in
+# those rules.
+## ArrowFormalParameters: ( Modified ) CallSignature
+
+## Arguments: ( Modified ) TypeArgumentsopt ( ArgumentListopt )
+## UnaryExpression: ( Modified ) … < Type > UnaryExpression
+
+##############################################################################################
+##                              A.4 Functions
+##############################################################################################
+
+## FunctionDeclaration: ( Modified )
+## function BindingIdentifieropt CallSignature { FunctionBody }
+## function BindingIdentifieropt CallSignature ;
+
+# NOTE: Inline Call signature to make it easier to write action.
+rule FunctionDeclaration : ONEOF(
+  ZEROORMORE(AccessibilityModifier) + "function" + ZEROORONE(FunctionName) + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}',
+  ZEROORMORE(AccessibilityModifier) + "function" + ZEROORONE(FunctionName) + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ':' + AssertExpression + '{' + FunctionBody + '}',
+  ZEROORMORE(AccessibilityModifier) + "function" + ZEROORONE(FunctionName) + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ':' + IsExpression + '{' + FunctionBody + '}',
+  ZEROORMORE(AccessibilityModifier) + "function" + ZEROORONE(FunctionName) + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation)  + ZEROORONE(';'),
+  ZEROORMORE(AccessibilityModifier) + "function" + ZEROORONE(FunctionName) + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ':' + IsExpression + ZEROORONE(';'))
+  attr.action.%1,%2,%3,%4,%5 : BuildFunction(%3)
+  attr.action.%1,%2,%3,%4,%5 : AddParams(%6)
+  attr.action.%1,%2,%3,%4,%5 : AddModifier(%1)
+  attr.action.%1,%4    : AddType(%8)
+  attr.action.%1,%2,%3,%4,%5 : AddTypeGenerics(%4)
+  attr.action.%2,%3,%5 : AddAssert(%9)
+  attr.action.%1       : AddFunctionBody(%10)
+  attr.action.%2,%3    : AddFunctionBody(%11)
+
+##############################################################################################
+##                               A.5 Interface
+##############################################################################################
+
+##InterfaceDeclaration: interface BindingIdentifier TypeParametersopt InterfaceExtendsClauseopt ObjectType
+rule InterfaceDeclaration :
+  "interface" + BindingIdentifier + ZEROORONE(TypeParameters) + ZEROORONE(InterfaceExtendsClause) + '{' + ZEROORONE(TypeBody) + '}' 
+  attr.action : BuildStruct(%2)
+  attr.action : SetTSInterface()
+  attr.action : AddTypeGenerics(%3)
+  attr.action : AddStructField(%6)
+  attr.action : AddSuperInterface(%4)
+
+##InterfaceExtendsClause: extends ClassOrInterfaceTypeList
+rule InterfaceExtendsClause: "extends" + ClassOrInterfaceTypeList
+
+##ClassOrInterfaceTypeList: ClassOrInterfaceType ClassOrInterfaceTypeList , ClassOrInterfaceType
+rule ClassOrInterfaceTypeList: ONEOF(ClassOrInterfaceType,
+                                     ClassOrInterfaceTypeList + ',' + ClassOrInterfaceType)
+
+##ClassOrInterfaceType: TypeReference
+rule ClassOrInterfaceType: TypeReference
+
+##############################################################################################
+##                             A.6 Class declaration
+##############################################################################################
+
+## ClassDeclaration: ( Modified ) class BindingIdentifieropt TypeParametersopt ClassHeritage { ClassBody }
+## NOTE. I inlined ClassHeritage to avoid 'lookahead fail'
+rule ClassDeclaration:
+  ZEROORMORE(Annotation) + ZEROORONE("abstract") + "class" + ZEROORONE(BindingIdentifier) + ZEROORONE(TypeParameters) + ZEROORONE(ClassExtendsClause) + ZEROORONE(ImplementsClause) + '{' + ZEROORONE(ClassBody) + '}'
+  attr.action : BuildClass(%4)
+  attr.action : AddModifier(%1)
+  attr.action : AddModifier(%2)
+  attr.action : AddTypeGenerics(%5)
+  attr.action : AddSuperClass(%6)
+  attr.action : AddSuperInterface(%7)
+  attr.action : AddClassBody(%9)
+
+rule Annotation : '@' + MemberExpression + ZEROORONE(Arguments)
+  attr.action : BuildAnnotation(%2)
+  attr.action : AddArguments(%3)
+
+## ClassHeritage: ( Modified ) ClassExtendsClauseopt ImplementsClauseopt
+rule ClassHeritage: ZEROORONE(ClassExtendsClause) + ZEROORONE(ImplementsClause)
+
+## ClassExtendsClause: extends ClassType
+rule ClassExtendsClause: ONEOF("extends" + ZEROORONE('(') + ClassType + ZEROORONE(')'),
+                               "extends" + CallExpression)
+
+## ClassType: TypeReference
+rule ClassType: TypeReference
+
+## ImplementsClause: implements ClassOrInterfaceTypeList
+rule ImplementsClause: "implements" + ClassOrInterfaceTypeList
+
+## ClassElement: ( Modified ) ConstructorDeclaration PropertyMemberDeclaration IndexMemberDeclaration
+rule ClassElement: ONEOF(ConstructorDeclaration,
+                         PropertyMemberDeclaration,
+                         IndexMemberDeclaration)
+  attr.property : Single
+
+## ConstructorDeclaration: AccessibilityModifieropt constructor ( ParameterListopt ) { FunctionBody } AccessibilityModifieropt constructor ( ParameterListopt ) ;
+rule ConstructorDeclaration: ONEOF(
+  ZEROORONE(AccessibilityModifier) + "constructor" + '(' + ZEROORONE(ParameterList) + ')' + '{' + FunctionBody + '}',
+  ZEROORONE(AccessibilityModifier) + "constructor" + '(' + ZEROORONE(ParameterList) + ')' + ';')
+  attr.action.%1,%2 : BuildConstructor()
+  attr.action.%1,%2 : AddParams(%4)
+  attr.action.%1,%2 : AddModifier(%1)
+  attr.action.%1 : AddFunctionBody(%7)
+
+## PropertyMemberDeclaration: MemberVariableDeclaration MemberFunctionDeclaration MemberAccessorDeclaration
+rule PropertyMemberDeclaration: ONEOF(MemberVariableDeclaration,
+                                      MemberFunctionDeclaration + ZEROORONE(';'),
+                                      MemberAccessorDeclaration + ZEROORONE(';'),
+                                      MemberExternalDeclaration)
+
+## MemberVariableDeclaration: AccessibilityModifieropt staticopt PropertyName TypeAnnotationopt Initializeropt ;
+rule MemberVariableDeclaration: ONEOF(
+  ZEROORMORE(Annotation) + ZEROORMORE(AccessibilityModifier) + PropertySignatureName + ZEROORONE(TypeAnnotation) + ZEROORONE(Initializer) + ZEROORONE(';'),
+  ZEROORMORE(Annotation) + ZEROORMORE(AccessibilityModifier) + PropertySignatureName + '?' + ZEROORONE(TypeAnnotation) + ZEROORONE(Initializer) + ZEROORONE(';'),
+  ZEROORMORE(Annotation) + ZEROORMORE(AccessibilityModifier) + "get" + '=' + ArrowFunction + ZEROORONE(';'),
+  ZEROORMORE(Annotation) + ZEROORMORE(AccessibilityModifier) + "set" + '=' + ArrowFunction + ZEROORONE(';'),
+  '#' + PropertySignatureName + ZEROORONE(TypeAnnotation) + ZEROORONE(Initializer) + ZEROORONE(';'),
+  '#' + "private" + ZEROORONE(TypeAnnotation) + ZEROORONE(Initializer) + ZEROORONE(';'),
+  ZEROORMORE(Annotation) + ZEROORMORE(AccessibilityModifier) + "if" + ZEROORONE(TypeAnnotation) + ZEROORONE(Initializer) + ZEROORONE(';'))
+  attr.action.%1: AddInitTo(%3, %5)
+  attr.action.%1: AddType(%3, %4)
+  attr.action.%1: AddModifierTo(%3, %2)
+  attr.action.%1: AddModifierTo(%3, %1)
+  attr.action.%1: BuildDecl(%4, %3)
+  attr.action.%2: AddInitTo(%3, %6)
+  attr.action.%2: AddType(%3, %5)
+  attr.action.%2: AddModifierTo(%3, %2)
+  attr.action.%2: AddModifierTo(%3, %1)
+  attr.action.%2: SetIsOptional(%3)
+  attr.action.%2: BuildDecl(%4, %3)
+  attr.action.%3,%4: BuildIdentifier(%3)
+  attr.action.%3,%4: AddInitTo(%5)
+  attr.action.%3,%4: AddModifier(%2)
+  attr.action.%3,%4: AddModifier(%1)
+  attr.action.%3,%4: BuildDecl()
+  attr.action.%5:    AddInitTo(%2, %4)
+  attr.action.%6:    BuildIdentifier(%2)
+  attr.action.%6:    AddInitTo(%4)
+  attr.action.%5,%6: AddType(%3)
+  attr.action.%5,%6: AddModifier(%1)
+  attr.action.%5,%6: BuildDecl()
+  attr.action.%7 : BuildIdentifier(%3)
+  attr.action.%7 : AddType(%4)
+  attr.action.%7 : AddModifier(%1)
+  attr.action.%7 : AddModifier(%2)
+  attr.action.%7 : AddInitTo(%5)
+  attr.action.%7 : BuildDecl()
+
+rule KeywordMemberFunctionName : ONEOF("return",
+                                       "get",
+                                       "set",
+                                       "continue",
+                                       "break",
+                                       "const",
+                                       "let",
+                                       "var",
+                                       "if",
+                                       "else",
+                                       "for",
+                                       "try",
+                                       "export")
+  attr.action : BuildIdentifier()
+
+## MemberFunctionDeclaration: AccessibilityModifieropt staticopt PropertyName CallSignature { FunctionBody } AccessibilityModifieropt staticopt PropertyName CallSignature ;
+#NOTE: I inlined CallSignature to make it easier for building function.
+#rule CallSignature: ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation)
+rule MemberFunctionDeclaration: ONEOF(
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + PropertyName + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}',
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + PropertyName + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation) + ZEROORONE(';'),
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + PropertyName + '?' + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}',
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + PropertyName + '?' + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation) + ZEROORONE(';'),
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + PropertyName + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ':' + IsExpression + '{' + FunctionBody + '}',
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + PropertyName + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ':' + IsExpression + ZEROORONE(';'),
+
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + KeywordMemberFunctionName + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation) + '{' + FunctionBody + '}',
+
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + KeywordMemberFunctionName + ZEROORONE(TypeParameters) + '(' + ZEROORONE(ParameterList)  + ')' + ZEROORONE(TypeAnnotation) + ZEROORONE(';'),
+  '*' + '[' + MemberExpression + ']' + '(' + ')' + '{' + FunctionBody + '}')
+  attr.action.%1,%2,%3,%4,%5,%6,%7,%8,%9 : BuildFunction(%3)
+  attr.action.%1,%2,%3,%4,%5,%6,%7,%8 : AddModifier(%2)
+  attr.action.%1,%2,%3,%4,%5,%6,%7,%8 : AddModifier(%1)
+  attr.action.%1,%2,%5,%6,%7,%8 : AddTypeGenerics(%4)
+  attr.action.%1,%2,%5,%6,%7,%8 : AddParams(%6)
+  attr.action.%1,%2,%7,%8 : AddType(%8)
+  attr.action.%1,%7    : AddFunctionBody(%10)
+  attr.action.%3,%4 : AddTypeGenerics(%5)
+  attr.action.%3,%4 : AddParams(%7)
+  attr.action.%3,%4 : AddType(%9)
+  attr.action.%3    : AddFunctionBody(%11)
+  attr.action.%3,%4 : SetIsOptional(%3)
+  attr.action.%5,%6 : AddType(%9)
+  attr.action.%5    : AddFunctionBody(%11)
+  attr.action.%9    : SetIsIterator()
+  attr.action.%9    : AddFunctionBody(%8)
+
+## MemberAccessorDeclaration: AccessibilityModifieropt staticopt GetAccessor AccessibilityModifieropt staticopt SetAccessor
+rule MemberAccessorDeclaration: ONEOF(
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + GetAccessor,
+  ZEROORONE(Annotation) + ZEROORMORE(AccessibilityModifier) + SetAccessor)
+  attr.action.%1,%2 : AddModifierTo(%3, %1)
+
+## IndexMemberDeclaration: IndexSignature ;
+rule IndexMemberDeclaration: IndexSignature + ZEROORONE(';')
+
+rule MemberExternalDeclaration : ZEROORMORE(AccessibilityModifier) + "declare" + VariableDeclaration + ';'
+  attr.action : BuildExternalDeclaration(%3)
+  attr.action : AddModifier(%1)
+#################################################################################################
+#                                          A.7 Enums
+#################################################################################################
+## EnumDeclaration: constopt enum BindingIdentifier { EnumBodyopt }
+rule EnumDeclaration:
+  ZEROORONE("const") + "enum" + BindingIdentifier + '{' + ZEROORONE(EnumBody) + '}'
+  attr.action : BuildStruct(%3)
+  attr.action : SetTSEnum()
+  attr.action : AddStructField(%5)
+
+## EnumBody: EnumMemberList ,opt
+rule EnumBody: EnumMemberList + ZEROORONE(',')
+
+## EnumMemberList: EnumMember EnumMemberList , EnumMember
+rule EnumMemberList: ONEOF(EnumMember,
+                           EnumMemberList + ',' + EnumMember)
+
+## EnumMember: PropertyName PropertyName = EnumValue
+rule EnumMember: ONEOF(PropertyName,
+                       PropertyName + '=' + EnumValue,
+                       KeywordPropName + '=' + EnumValue)
+  attr.action.%2,%3 : AddInitTo(%1, %3)
+
+## EnumValue: AssignmentExpression
+rule EnumValue: AssignmentExpression
+
+#################################################################################################
+##                                  A.8 Namespaces
+#################################################################################################
+
+##NamespaceDeclaration: namespace IdentifierPath { NamespaceBody }
+rule NamespaceDeclaration: "namespace" + IdentifierPath + '{' + NamespaceBody + '}'
+  attr.property : Top
+  attr.action : BuildNamespace(%2)
+  attr.action : AddNamespaceBody(%4)
+
+##IdentifierPath: BindingIdentifier IdentifierPath . BindingIdentifier
+rule IdentifierPath: ONEOF(BindingIdentifier,
+                           IdentifierPath + '.' + BindingIdentifier)
+  attr.action.%2 : BuildField(%1, %3)
+
+##NamespaceBody: NamespaceElementsopt
+rule NamespaceBody: ZEROORONE(NamespaceElements)
+
+##NamespaceElements: NamespaceElement NamespaceElements NamespaceElement
+rule NamespaceElements: ONEOF(NamespaceElement,
+                              NamespaceElements + NamespaceElement)
+
+##NamespaceElement: Statement LexicalDeclaration FunctionDeclaration GeneratorDeclaration ClassDeclaration InterfaceDeclaration TypeAliasDeclaration EnumDeclaration NamespaceDeclaration AmbientDeclaration ImportAliasDeclaration ExportNamespaceElement
+rule NamespaceElement: ONEOF(Statement,
+                             LexicalDeclaration + ZEROORONE(';'),
+                             FunctionDeclaration,
+                             #GeneratorDeclaration,
+                             ClassDeclaration,
+                             InterfaceDeclaration,
+                             TypeAliasDeclaration,
+                             EnumDeclaration,
+                             NamespaceDeclaration,
+                             #AmbientDeclaration,
+                             ImportAliasDeclaration,
+                             ExportNamespaceElement)
+
+##ExportNamespaceElement: export VariableStatement export LexicalDeclaration export FunctionDeclaration export GeneratorDeclaration export ClassDeclaration export InterfaceDeclaration export TypeAliasDeclaration export EnumDeclaration export NamespaceDeclaration export AmbientDeclaration export ImportAliasDeclaration
+rule ExportNamespaceElement: ONEOF("export" + VariableStatement,
+                                   "export" + LexicalDeclaration + ZEROORONE(';'),
+                                   "export" + FunctionDeclaration,
+#                                   "export" + GeneratorDeclaration,
+                                   "export" + ClassDeclaration,
+                                   "export" + InterfaceDeclaration,
+                                   "export" + TypeAliasDeclaration,
+                                   "export" + EnumDeclaration,
+                                   "export" + NamespaceDeclaration,
+#                                   "export" + AmbientDeclaration,
+                                   "export" + ImportAliasDeclaration,
+                                   ExportDeclaration)
+  attr.action.%1,%2,%3,%4,%5,%6,%7,%8,%9 : BuildExport()
+  attr.action.%1,%2,%3,%4,%5,%6,%7,%8,%9 : SetPairs(%2)
+
+##ImportAliasDeclaration: import BindingIdentifier = EntityName ;
+rule NamespaceImportPair: BindingIdentifier + '=' + EntityName
+  attr.action : BuildXXportAsPair(%3, %1)
+
+rule ImportAliasDeclaration: "import" + NamespaceImportPair + ';'
+  attr.action : BuildImport()
+  attr.action : SetPairs(%2)
+
+##EntityName: NamespaceName NamespaceName . IdentifierReference
+rule EntityName: ONEOF(NamespaceName,
+                       NamespaceName + '.' + IdentifierReference)
+  attr.action.%2 : BuildField(%1, %3)
+
+#################################################################################################
+#                      declare syntax
+#################################################################################################
+
+rule ExternalDeclaration : ONEOF("declare" + NamespaceDeclaration,
+                                 "declare" + LexicalDeclaration + ZEROORONE(';'),
+                                 "declare" + ClassDeclaration,
+                                 "declare" + InterfaceDeclaration,
+                                 "declare" + FunctionDeclaration,
+                                 "declare" + VariableStatement,
+                                 "declare" + TypeAliasDeclaration,
+                                 "declare" + EnumDeclaration,
+                                 "declare" + ExternalModuleDeclaration)
+  attr.action.%1,%2,%3,%4,%5,%6,%7,%8,%9 : BuildExternalDeclaration(%2)
+
+## for global declaration
+## https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-modifying-module-d-ts.html
+rule GlobalDeclMember : ONEOF(NamespaceDeclaration,
+                              LexicalDeclaration + ZEROORONE(';'),
+                              ClassDeclaration,
+                              InterfaceDeclaration,
+                              FunctionDeclaration,
+                              VariableStatement,
+                              TypeAliasDeclaration,
+                              EnumDeclaration,
+                              ExternalModuleDeclaration)
+rule GlobalDeclMembers : "global" + '{' + ZEROORMORE(GlobalDeclMember) + '}'
+  attr.action : BuildGlobalExternalDeclaration(%3)
+rule GlobalDeclaration : "declare" + GlobalDeclMembers
+  attr.action : PassChild(%2)
+
+#################################################################################################
+#                                 A.9 Scripts and Modules
+#################################################################################################
+
+# The module name could be an identifier or string literal.
+rule ExternalModuleDeclaration : ONEOF("module" + IdentifierReference + '{' + DeclarationModule + '}',
+                                       "module" + Literal + '{' + DeclarationModule + '}')
+  attr.property : Top
+  attr.action.%1,%2 : BuildModule(%2)
+  attr.action.%1,%2 : AddModuleBody(%4)
+  attr.action.%2    : SetIsAmbient()
+
+#DeclarationElement: InterfaceDeclaration TypeAliasDeclaration NamespaceDeclaration AmbientDeclaration ImportAliasDeclaration
+rule DeclarationElement: ONEOF(InterfaceDeclaration,
+                               TypeAliasDeclaration,
+                               LexicalDeclaration + ZEROORONE(';'),
+                               VariableDeclaration,
+                               FunctionDeclaration,
+                               ClassDeclaration,
+                               EnumDeclaration,
+                               NamespaceDeclaration,
+                               AmbientDeclaration,
+                               GlobalDeclMembers,
+                               ImportAliasDeclaration)
+
+# ImplementationModule: ImplementationModuleElementsopt
+# ImplementationModuleElements: ImplementationModuleElement ImplementationModuleElements ImplementationModuleElement
+# ImplementationModuleElement: ImplementationElement ImportDeclaration ImportAliasDeclaration ImportRequireDeclaration ExportImplementationElement ExportDefaultImplementationElement ExportListDeclaration ExportAssignment
+
+# DeclarationModule: DeclarationModuleElementsopt
+rule DeclarationModule: ZEROORONE(DeclarationModuleElements)
+
+# DeclarationModuleElements: DeclarationModuleElement DeclarationModuleElements DeclarationModuleElement
+rule DeclarationModuleElements: ONEOF(DeclarationModuleElement,
+                                      DeclarationModuleElements + DeclarationModuleElement)
+
+# DeclarationModuleElement: DeclarationElement ImportDeclaration ImportAliasDeclaration ExportDeclarationElement ExportDefaultDeclarationElement ExportListDeclaration ExportAssignment
+rule DeclarationModuleElement: ONEOF(DeclarationElement,
+                                     ImportDeclaration,
+                                     ImportAliasDeclaration,
+                                     ExportDeclaration,
+                                     Statement)
+                                     #ExportDefaultDeclarationElement,
+                                     #ExportListDeclaration,
+                                     #ExportAssignment)
+
+#################################################################################################
+#                                 A.10 Ambient
+# NOTE : I changed the rules a lot, making it quite different than v1.8 spec.
+#################################################################################################
+
+# AmbientDeclaration: declare AmbientVariableDeclaration declare AmbientFunctionDeclaration declare AmbientClassDeclaration declare AmbientEnumDeclaration declare AmbientNamespaceDeclaration
+rule AmbientDeclaration: ONEOF("declare" + VariableDeclaration,
+                               "declare" + FunctionDeclaration,
+                               "declare" + ClassDeclaration,
+                               "declare" + EnumDeclaration,
+                               "declare" + NamespaceDeclaration)
+  attr.action.%1,%2,%3,%4,%5 : BuildExternalDeclaration(%2)
diff --git a/src/MapleFE/typescript/type.spec b/src/MapleFE/typescript/type.spec
new file mode 100644
index 0000000000000000000000000000000000000000..42f739d09b86610e5d10efc2602feae3666b4848
--- /dev/null
+++ b/src/MapleFE/typescript/type.spec
@@ -0,0 +1,81 @@
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkFE is licensed under the Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#  http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+###################################################################################
+# This file defines the Java types.
+#
+#  1. Child rules have to be defined before parent rules.
+#  2. For type.spec, Autogen allows the programmer to have special keyword section to
+#     define the individual <keyword, meaning>. Please keep in mind this
+#     keyword section has to appear before the rule section.
+#
+#     Keyword section is defined through STRUCT().
+#
+#  3. Autogen will first read in the keyword section by TypeGen functions, then
+#     read the rules section by inheriting BaseGen::Parse, etc.
+#  4. The keyword duplex is defined as <TYPE, "keyword">.
+#     [NOTE] TYPE should be one of those recognized by the "parser". Please refer
+#            to ../shared/include/type.h. The data representation of same type
+#            doesnt have to be the same in each language, we just need have the
+#            same name of TYPE. The physical representation of each type of
+#            different language will be handled by HandleType() by each language.
+#            e.g. Char in java and in C are different. but Autogen doesnt care.
+#            java2mpl and c2mpl will provide their own HandleType() to map this
+#            to the correct types in Maple IR.
+#
+#     So there are 4 type systems involved in frontend.
+#     (1) Types in the .spec file, of each language
+#     (2) Types in Autogen. Super set of (1) in all languages.
+#         types in Autogen have an exact mapping to those in Parser.
+#         Autogen will generate type related files used in parser, mapping
+#         types to it.
+#     (3) Types in Parser. From now on, physical representation is defined.
+#         Each language has its own HandleTypes() to map type in Parser to
+#         those in MapleIR, considering physical representation.
+#     (4) Types in Maple IR. This is the only place where types have physical
+#         representation.
+#
+#  5. The supported STRUCT in type.spec is:
+#         Keyword
+#     Right now, only one STRUCT is supported.
+#
+#     It is highly possible that a .spec file needs more than one STRUCT.
+###################################################################################
+
+# The types recoganized by Autogen are in shared/supported_types.def
+# where Boolean, Byte, .. are defined. That said, "Boolean" and the likes are
+# used in type.spec as a keyword.
+#
+# This STRUCT tells the primitive types
+
+STRUCT Keyword : (("boolean",   Boolean),
+                  ("string",    String),
+                  ("number",    Number),
+                  ("symbol",    Symbol),
+                  ("any",       Any),
+                  ("void",      Void),
+                  ("unknown",   Unknown),
+                  ("never",     Never),
+                  ("undefined", Undefined))
+
+rule BooleanType : "boolean"
+rule NumberType  : "number"
+rule SymbolType  : "symbol"
+rule AnyType     : "any"
+rule StringType  : "string"
+rule VoidType    : "void"
+rule UnknownType : "unknown"
+rule NeverType   : "never"
+rule UndefinedType : "undefined"
+
+rule TYPE : ONEOF(BooleanType, NumberType, SymbolType, AnyType, StringType, VoidType, UnknownType, NeverType, UndefinedType)
diff --git a/src/hir2mpl/BUILD.gn b/src/hir2mpl/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..070069af66364053092d7f2a42d8e74337924070
--- /dev/null
+++ b/src/hir2mpl/BUILD.gn
@@ -0,0 +1,431 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+if (COV_CHECK == 1) {
+  cflags = [ "-DENABLE_COV_CHECK=1" ]
+}
+
+cflags += [
+  "-DMIR_FEATURE_FULL=1",
+  "-DHIR2MPL_FULL_INFO_DUMP=1",
+  "-DJAVA_OBJ_IN_MFILE=1",
+]
+
+if (ONLY_C == 1) {
+  cflags += [
+    "-w",
+    "-DONLY_C",
+  ]
+}
+
+if (MAST == 1) {
+  cflags += [
+    "-w",
+    "-DENABLE_MAST",
+  ]
+}
+
+include_directories = [
+  "${HIR2MPL_ROOT}/common/include",
+  "${HIR2MPL_ROOT}/optimize/include",
+  "${HIR2MPL_ROOT}/bytecode_input/class/include",
+  "${HIR2MPL_ROOT}/bytecode_input/common/include",
+  "${HIR2MPL_ROOT}/bytecode_input/dex/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include/old",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_phase/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/mpl2mpl/include",
+  "${MAPLEALL_ROOT}/maple_me/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  "${HIR2MPL_ROOT}/ast_input/clang/include",
+  "${HIR2MPL_ROOT}/ast_input/clang/lib",
+  "${HIR2MPL_ROOT}/ast_input/common/include",
+  "${HIR2MPL_ROOT}/ast_input/maple/include",
+  "${HIR2MPL_ROOT}/ast_input/maple/lib",
+  "${LLVMINC}",
+  "${THIRD_PARTY_ROOT}/llvm_modified/clang/tools",
+]
+
+if (MAST == 1) {
+  include_directories += [
+    "${MAPLE_PARSER_PATH}/output/c/ast_gen/shared",
+    "${MAPLE_PARSER_PATH}/shared/include",
+    "${MAPLE_PARSER_PATH}/astopt/include",
+  ]
+}
+
+static_library("lib_hir2mpl_common") {
+  sources = [
+    "${HIR2MPL_ROOT}/common/src/base64.cpp",
+    "${HIR2MPL_ROOT}/common/src/basic_io.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_config_parallel.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_file_ops.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_file_type.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_function.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_function_phase_result.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_input_helper.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_java_string_manager.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_manager.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_options.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_struct_elem_info.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_timer_ns.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_type_hierarchy.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_type_manager.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_utils.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_utils_ast.cpp",
+    "${HIR2MPL_ROOT}/common/src/fe_utils_java.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_builder.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_stmt.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_type.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_type_helper.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_type_infer.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_var.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_var_name.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_var_reg.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_var_type_scatter.cpp",
+    "${HIR2MPL_ROOT}/common/src/hir2mpl_compiler.cpp",
+    "${HIR2MPL_ROOT}/common/src/hir2mpl_compiler_component.cpp",
+    "${HIR2MPL_ROOT}/common/src/hir2mpl_env.cpp",
+    "${HIR2MPL_ROOT}/common/src/hir2mpl_options.cpp",
+    "${HIR2MPL_ROOT}/common/src/hir2mpl_option.cpp",
+    "${HIR2MPL_ROOT}/common/src/simple_xml.cpp",
+    "${HIR2MPL_ROOT}/common/src/simple_zip.cpp",
+    "${HIR2MPL_ROOT}/common/src/generic_attrs.cpp",
+    "${HIR2MPL_ROOT}/common/src/enhance_c_checker.cpp",
+    "${HIR2MPL_ROOT}/common/src/feir_scope.cpp",
+  ]
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/ar"
+
+  if (MAJOR_VERSION != "") {
+    cflags_cc += [ "-DMAJOR_VERSION=${MAJOR_VERSION}", ]
+  }
+
+  if (MINOR_VERSION != "") {
+    cflags_cc += [ "-DMINOR_VERSION=${MINOR_VERSION}", ]
+  }
+
+  if (RELEASE_VERSION != "") {
+    cflags_cc += [ "-DRELEASE_VERSION=\"${RELEASE_VERSION}\"", ]
+  }
+
+  if (BUILD_VERSION != "") {
+    cflags_cc += [ "-DBUILD_VERSION=${BUILD_VERSION}", ]
+  }
+
+  if (GIT_REVISION != "") {
+    cflags_cc += [ "-DGIT_REVISION=\"${GIT_REVISION}\"", ]
+  }
+}
+
+static_library("lib_hir2mpl_optimize") {
+  sources = [
+    "${HIR2MPL_ROOT}/optimize/src/ror.cpp",
+    "${HIR2MPL_ROOT}/optimize/src/conditional_operator.cpp",
+    "${HIR2MPL_ROOT}/optimize/src/feir_lower.cpp",
+    "${HIR2MPL_ROOT}/optimize/src/feir_bb.cpp",
+    "${HIR2MPL_ROOT}/optimize/src/feir_cfg.cpp",
+    "${HIR2MPL_ROOT}/optimize/src/feir_dfg.cpp"
+  ]
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/ar"
+}
+
+static_library("lib_hir2mpl_input_helper") {
+  sources = [ "${HIR2MPL_ROOT}/common/src/fe_input_helper.cpp" ]
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/ar"
+}
+
+executable("hir2mpl") {
+  sources = [ "${HIR2MPL_ROOT}/common/src/hir2mpl.cpp" ]
+  include_dirs = include_directories
+  deps = [
+    ":lib_hir2mpl_ast_input_clang",
+    ":lib_hir2mpl_ast_input_common",
+    ":lib_hir2mpl_input_helper",
+    ":lib_hir2mpl_common",
+    ":lib_hir2mpl_optimize",
+    "${MAPLEALL_ROOT}/maple_driver:libdriver_option",
+    "${MAPLEALL_ROOT}/maple_driver:libmaple_driver",
+    "${MAPLEALL_ROOT}/maple_ir:libmplir",
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/mempool:libmempool",
+    "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
+  ]
+
+  if (ONLY_C != 1) {
+    deps += [
+      ":lib_hir2mpl_bytecode_input_common",
+      ":lib_hir2mpl_bytecode_input_dex",
+      ":lib_hir2mpl_bytecode_input_class",
+    ]
+  }
+
+  if (MAST == 1) {
+    deps += [
+      ":lib_hir2mpl_ast_input_maple",
+    ]
+  }
+  ldflags = [
+    "-lz",
+    "-rdynamic",
+    "-L${LLVMLIBDIR}/",
+  ]
+
+  if (MAST == 1) {
+    ldflags += [
+      "-lstdc++fs",
+      "-L${MAPLE_PARSER_PATH}/output/c/ast_gen/shared",
+    ]
+  }
+  if (COV == 1) {
+    ldflags += ["--coverage"]
+    cflags_cc += [
+      "-fprofile-arcs",
+      "-ftest-coverage"
+    ]
+  }
+  if (GPROF == 1) {
+    ldflags += ["-pg"]
+    cflags_cc += ["-pg"]
+  }
+}
+
+include_bytecode_input_jbc_directories = [
+  "${HIR2MPL_ROOT}/common/include",
+  "${HIR2MPL_ROOT}/optimize/include",
+  "${HIR2MPL_ROOT}/bytecode_input/class/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+]
+
+static_library("lib_hir2mpl_bytecode_input_class") {
+  sources = [
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_attr.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_attr_item.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_bb.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_class.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_class2fe_helper.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_class_const.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_class_const_pool.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_compiler_component.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_function.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_function_context.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_input.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_opcode.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_opcode_helper.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_stack2fe_helper.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_stack_helper.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_stmt.cpp",
+    "${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_util.cpp",
+  ]
+  include_dirs = include_bytecode_input_jbc_directories
+  output_dir = "${root_out_dir}/ar"
+}
+
+if (ONLY_C != 1) {
+  include_bytecode_input_common_directories = [
+    "${HIR2MPL_ROOT}/common/include",
+    "${HIR2MPL_ROOT}/optimize/include",
+    "${HIR2MPL_ROOT}/bytecode_input/common/include",
+    "${HIR2MPL_ROOT}/bytecode_input/dex/include",
+    "${MAPLEALL_ROOT}/maple_ir/include",
+    "${MAPLEALL_ROOT}/maple_util/include",
+    "${MAPLEALL_ROOT}/maple_driver/include",
+    "${MAPLEALL_ROOT}/mempool/include",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  ]
+
+  static_library("lib_hir2mpl_bytecode_input_common") {
+    sources = [
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/ark_annotation_map.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/ark_annotation_processor.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/bc_class.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/bc_class2fe_helper.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/bc_function.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/bc_instruction.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/bc_io.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/bc_parser_base.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/bc_pragma.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/bc_util.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/common/src/rc_setter.cpp",
+    ]
+    include_dirs = include_bytecode_input_common_directories
+    output_dir = "${root_out_dir}/ar"
+  }
+
+  include_bytecode_input_dex_directories = [
+    "${HIR2MPL_ROOT}/common/include",
+    "${HIR2MPL_ROOT}/optimize/include",
+    "${HIR2MPL_ROOT}/bytecode_input/common/include",
+    "${HIR2MPL_ROOT}/bytecode_input/dex/include",
+    "${MAPLEALL_ROOT}/maple_ir/include",
+    "${MAPLEALL_ROOT}/maple_util/include",
+    "${MAPLEALL_ROOT}/maple_driver/include",
+    "${MAPLEALL_ROOT}/mempool/include",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  ]
+
+  static_library("lib_hir2mpl_bytecode_input_dex") {
+    sources = [
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/class_linker.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/class_loader_context.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_class.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_class2fe_helper.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_encode_value.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_file_util.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_op.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_pragma.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_strfac.cpp",
+    ]
+
+    # for libdexfile
+    include_dirs_dex = [ "${THIRD_PARTY_ROOT}/aosp_modified/system/core/include" ]
+    include_dirs_libdexfile = [
+      #for libdexfile -start
+      "${THIRD_PARTY_ROOT}/aosp_modified/system/core/liblog/include",
+      "${THIRD_PARTY_ROOT}/aosp_modified/system/core/libutils/include",
+      "${THIRD_PARTY_ROOT}/aosp_modified/system/core/base/include",
+      "${THIRD_PARTY_ROOT}/aosp_modified/system/core/libziparchive/include",
+      "${THIRD_PARTY_ROOT}/aosp_modified/art/libartpalette/include",
+      "${THIRD_PARTY_ROOT}/aosp_modified/art/libartbase",
+      "${THIRD_PARTY_ROOT}/aosp_modified/art/libdexfile",
+      "${THIRD_PARTY_ROOT}/aosp_modified/include",
+      "${THIRD_PARTY_ROOT}/aosp_modified/libnativehelper/include_jni",
+
+      #for libdexfile -end
+    ]
+
+    sources += [
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_parser.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_reader.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dexfile_factory.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dexfile_interface.cpp",
+      "${HIR2MPL_ROOT}/bytecode_input/dex/src/dexfile_libdexfile.cpp",
+    ]
+    deps_libdexfile = [
+      "${THIRD_PARTY_ROOT}/aosp_modified/art/libdexfile:libdexfile",
+      "${THIRD_PARTY_ROOT}/aosp_modified/system/core/libziparchive:libziparchive",
+      "${THIRD_PARTY_ROOT}/aosp_modified/system/core/base:libbase",
+    ]
+    lib_dex = [ "${THIRD_PARTY_ROOT}/aosp_modified/system/core/liblog/liblog.a" ]
+    deps = deps_libdexfile
+    libs = lib_dex
+    include_dirs =
+        include_bytecode_input_dex_directories + include_dirs_libdexfile + include_dirs_dex
+    output_dir = "${root_out_dir}/ar"
+  }
+}
+
+static_library("lib_hir2mpl_ast_input_clang_lib") {
+  sources = [ "${HIR2MPL_ROOT}/ast_input/clang/lib/ast_interface.cpp" ]
+  include_dirs = include_directories
+  defines = [
+    "CLANG_ENABLE_ARCMT",
+    "CLANG_ENABLE_OBJC_REWRITER",
+    "CLANG_ENABLE_STATIC_ANALYZER",
+    "GTEST_HAS_RTTI=0",
+    "_DEBUG",
+    "_GNU_SOURCE",
+    "__STDC_CONSTANT_MACROS",
+    "__STDC_FORMAT_MACROS",
+    "__STDC_LIMIT_MACROS",
+  ]
+
+  output_dir = "${root_out_dir}/ar"
+  libs = [
+    "${LLVMLIBDIR}/libclang.so",
+    "${LLVMLIBDIR}/libclang-cpp.so",
+    "${LLVMLIBDIR}/libclangFrontend.a",
+    "${LLVMLIBDIR}/libclangDriver.a",
+    "${LLVMLIBDIR}/libclangSerialization.a",
+    "${LLVMLIBDIR}/libclangParse.a",
+    "${LLVMLIBDIR}/libclangSema.a",
+    "${LLVMLIBDIR}/libclangEdit.a",
+    "${LLVMLIBDIR}/libclangLex.a",
+    "${LLVMLIBDIR}/libclangAnalysis.a",
+    "${LLVMLIBDIR}/libclangAST.a",
+    "${LLVMLIBDIR}/libclangBasic.a",
+    "${LLVMLIBDIR}/libLLVMDemangle.a",
+    "${LLVMLIBDIR}/libLLVMMCParser.a",
+    "${LLVMLIBDIR}/libLLVMMC.a",
+    "${LLVMLIBDIR}/libLLVMBitReader.a",
+    "${LLVMLIBDIR}/libLLVMCore.a",
+    "${LLVMLIBDIR}/libLLVMBinaryFormat.a",
+    "${LLVMLIBDIR}/libLLVMProfileData.a",
+    "${LLVMLIBDIR}/libLLVMOption.a",
+    "${LLVMLIBDIR}/libLLVMSupport.a",
+  ]
+}
+
+static_library("lib_hir2mpl_ast_input_common") {
+  sources = [
+    "${HIR2MPL_ROOT}/ast_input/common/src/ast_decl.cpp",
+  ]
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/ar"
+}
+
+static_library("lib_hir2mpl_ast_input_clang") {
+  sources = [
+    "${HIR2MPL_ROOT}/ast_input/clang/lib/ast_type.cpp",
+    "${HIR2MPL_ROOT}/ast_input/clang/lib/ast_util.cpp",
+    "${HIR2MPL_ROOT}/ast_input/clang/src/ast_expr.cpp",
+    "${HIR2MPL_ROOT}/ast_input/clang/src/ast_function.cpp",
+    "${HIR2MPL_ROOT}/ast_input/clang/src/ast_parser.cpp",
+    "${HIR2MPL_ROOT}/ast_input/clang/src/ast_parser_builting_func.cpp",
+    "${HIR2MPL_ROOT}/ast_input/clang/src/ast_stmt.cpp",
+    "${HIR2MPL_ROOT}/ast_input/clang/src/ast_struct2fe_helper.cpp",
+  ]
+  include_dirs = include_directories
+  deps = [ ":lib_hir2mpl_ast_input_clang_lib" ]
+  output_dir = "${root_out_dir}/ar"
+}
+
+if (MAST == 1) {
+  static_library("lib_hir2mpl_ast_input_maple_lib") {
+    sources = [ "${HIR2MPL_ROOT}/ast_input/maple/lib/maple_ast_interface.cpp" ]
+    include_dirs = include_directories
+    defines = [
+      "DEBUG",
+    ]
+    output_dir = "${root_out_dir}/ar"
+    libs = [
+      "${MAPLE_PARSER_PATH}/output/c/ast_gen/shared/genast.a",
+      "${MAPLE_PARSER_PATH}/output/c/shared/shared.a",
+      "${MAPLE_PARSER_PATH}/output/c/gen/gen.a",
+      "${MAPLE_PARSER_PATH}/output/c/astopt/astopt.a",
+    ]
+  }
+
+  static_library("lib_hir2mpl_ast_input_maple") {
+    sources = [
+      "${HIR2MPL_ROOT}/ast_input/maple/src/maple_ast_parser.cpp",
+    ]
+    include_dirs = include_directories
+    deps = [ ":lib_hir2mpl_ast_input_maple_lib" ]
+    output_dir = "${root_out_dir}/ar"
+  }
+}
+
diff --git a/src/hir2mpl/CMakeLists.txt b/src/hir2mpl/CMakeLists.txt
new file mode 100755
index 0000000000000000000000000000000000000000..e8d5a1176235593df8dff9873e0cf5ccee627a1a
--- /dev/null
+++ b/src/hir2mpl/CMakeLists.txt
@@ -0,0 +1,490 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN AS IS BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+if (${COV_CHECK} STREQUAL "1")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DENABLE_COV_CHECK=1")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DENABLE_COV_CHECK=1")
+endif()
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMIR_FEATURE_FULL=1 -DHIR2MPL_FULL_INFO_DUMP=1 -DJAVA_OBJ_IN_MFILE=1")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DMIR_FEATURE_FULL=1 -DHIR2MPL_FULL_INFO_DUMP=1 -DJAVA_OBJ_IN_MFILE=1")
+
+if (${ONLY_C} STREQUAL "1")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w -DONLY_C")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w -DONLY_C")
+endif()
+
+if (${MAST} STREQUAL "1")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w -DENABLE_MAST")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w -DENABLE_MAST")
+endif()
+
+set(include_directories
+  ${HIR2MPL_ROOT}/common/include
+  ${HIR2MPL_ROOT}/optimize/include
+  ${HIR2MPL_ROOT}/bytecode_input/class/include
+  ${HIR2MPL_ROOT}/bytecode_input/common/include
+  ${HIR2MPL_ROOT}/bytecode_input/dex/include
+  ${MAPLEALL_ROOT}/maple_ir/include
+  ${MAPLEALL_ROOT}/maple_ipa/include
+  ${MAPLEALL_ROOT}/maple_ipa/include/old
+  ${MAPLEALL_ROOT}/maple_util/include
+  ${MAPLEALL_ROOT}/maple_phase/include
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${MAPLEALL_ROOT}/mpl2mpl/include
+  ${MAPLEALL_ROOT}/maple_me/include
+  ${MAPLEALL_ROOT}/mempool/include
+  ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+  ${HIR2MPL_ROOT}/ast_input/clang/include
+  ${HIR2MPL_ROOT}/ast_input/clang/lib
+  ${HIR2MPL_ROOT}/ast_input/common/include
+  ${HIR2MPL_ROOT}/ast_input/maple/include
+  ${HIR2MPL_ROOT}/ast_input/maple/lib
+  ${LLVMINC}
+  ${THIRD_PARTY_ROOT}/llvm_modified/clang/tools
+)
+
+if (${MAST} STREQUAL "1")
+  set(include_directories
+    ${include_directories}
+    ${MAPLE_PARSER_PATH}/output/c/ast_gen/shared
+    ${MAPLE_PARSER_PATH}/shared/include
+    ${MAPLE_PARSER_PATH}/astopt/include
+  )
+endif()
+
+set(src_lib_hir2mpl_common
+  ${HIR2MPL_ROOT}/common/src/base64.cpp
+  ${HIR2MPL_ROOT}/common/src/basic_io.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_config_parallel.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_file_ops.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_file_type.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_function.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_function_phase_result.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_input_helper.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_java_string_manager.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_manager.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_options.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_struct_elem_info.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_timer_ns.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_type_hierarchy.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_type_manager.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_utils.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_utils_ast.cpp
+  ${HIR2MPL_ROOT}/common/src/fe_utils_java.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_builder.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_stmt.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_type.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_type_helper.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_type_infer.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_var.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_var_name.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_var_reg.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_var_type_scatter.cpp
+  ${HIR2MPL_ROOT}/common/src/hir2mpl_compiler.cpp
+  ${HIR2MPL_ROOT}/common/src/hir2mpl_compiler_component.cpp
+  ${HIR2MPL_ROOT}/common/src/hir2mpl_env.cpp
+  ${HIR2MPL_ROOT}/common/src/hir2mpl_options.cpp
+  ${HIR2MPL_ROOT}/common/src/hir2mpl_option.cpp
+  ${HIR2MPL_ROOT}/common/src/simple_xml.cpp
+  ${HIR2MPL_ROOT}/common/src/simple_zip.cpp
+  ${HIR2MPL_ROOT}/common/src/generic_attrs.cpp
+  ${HIR2MPL_ROOT}/common/src/enhance_c_checker.cpp
+  ${HIR2MPL_ROOT}/common/src/feir_scope.cpp
+)
+if (NOT ${MAJOR_VERSION} STREQUAL "")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMAJOR_VERSION=${MAJOR_VERSION}")
+endif()
+if (NOT ${MINOR_VERSION} STREQUAL "")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMINOR_VERSION=${MINOR_VERSION}")
+endif()
+if (NOT ${RELEASE_VERSION} STREQUAL "")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DRELEASE_VERSION=\\\"${RELEASE_VERSION}\\\"")
+endif()
+if (NOT ${BUILD_VERSION} STREQUAL "")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DBUILD_VERSION=${BUILD_VERSION}")
+endif()
+if (NOT ${GIT_REVISION} STREQUAL "")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGIT_REVISION=\\\"${GIT_REVISION}\\\"")
+endif()
+#lib_hir2mpl_common
+add_library(lib_hir2mpl_common STATIC ${src_lib_hir2mpl_common})
+set_target_properties(lib_hir2mpl_common PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${include_directories}"
+    LINK_LIBRARIES ""
+    ARCHIVE_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/ar"
+    COMPILE_FLAGS ""
+)
+
+set(src_lib_hir2mpl_optimize
+  ${HIR2MPL_ROOT}/optimize/src/ror.cpp
+  ${HIR2MPL_ROOT}/optimize/src/conditional_operator.cpp
+  ${HIR2MPL_ROOT}/optimize/src/feir_lower.cpp
+  ${HIR2MPL_ROOT}/optimize/src/feir_bb.cpp
+  ${HIR2MPL_ROOT}/optimize/src/feir_cfg.cpp
+  ${HIR2MPL_ROOT}/optimize/src/feir_dfg.cpp
+)
+
+#lib_hir2mpl_optimize
+add_library(lib_hir2mpl_optimize STATIC ${src_lib_hir2mpl_optimize})
+set_target_properties(lib_hir2mpl_optimize PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${include_directories}"
+    LINK_LIBRARIES ""
+    ARCHIVE_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/ar"
+)
+
+#lib_hir2mpl_input_helper
+add_library(lib_hir2mpl_input_helper STATIC "${HIR2MPL_ROOT}/common/src/fe_input_helper.cpp")
+set_target_properties(lib_hir2mpl_input_helper PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${include_directories}"
+    LINK_LIBRARIES ""
+    ARCHIVE_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/ar"
+)
+
+set(src_hir2mpl
+  ${HIR2MPL_ROOT}/common/src/hir2mpl.cpp
+)
+
+set(deps_hir2mpl
+    ${LLVMLIBDIR}/libclang.so
+    ${LLVMLIBDIR}/libclang-cpp.so
+    ${LLVMLIBDIR}/libclangFrontend.a
+    ${LLVMLIBDIR}/libclangDriver.a
+    ${LLVMLIBDIR}/libclangSerialization.a
+    ${LLVMLIBDIR}/libclangParse.a
+    ${LLVMLIBDIR}/libclangSema.a
+    ${LLVMLIBDIR}/libclangEdit.a
+    ${LLVMLIBDIR}/libclangLex.a
+    ${LLVMLIBDIR}/libclangAnalysis.a
+    ${LLVMLIBDIR}/libclangAST.a
+    ${LLVMLIBDIR}/libclangBasic.a
+    ${LLVMLIBDIR}/libLLVMDemangle.a
+    ${LLVMLIBDIR}/libLLVMMCParser.a
+    ${LLVMLIBDIR}/libLLVMMC.a
+    ${LLVMLIBDIR}/libLLVMBitReader.a
+    ${LLVMLIBDIR}/libLLVMCore.a
+    ${LLVMLIBDIR}/libLLVMBinaryFormat.a
+    ${LLVMLIBDIR}/libLLVMProfileData.a
+    ${LLVMLIBDIR}/libLLVMOption.a
+    ${LLVMLIBDIR}/libLLVMSupport.a
+    lib_hir2mpl_ast_input_clang_lib
+    libmplphase
+    libcommandline
+    lib_hir2mpl_ast_input_clang
+    lib_hir2mpl_ast_input_common
+    lib_hir2mpl_input_helper
+    lib_hir2mpl_common
+    lib_hir2mpl_optimize
+    libdriver_option
+    libmaple_driver
+    libmplir
+    libmplutil
+    libmempool
+    libmpl2mpl
+    libHWSecureC
+)
+
+if (NOT ${ONLY_C} STREQUAL "1")
+    list(APPEND deps_hir2mpl
+		lib_hir2mpl_bytecode_input_common
+		lib_hir2mpl_bytecode_input_dex
+		lib_hir2mpl_bytecode_input_class
+		libdexfile
+		libziparchive
+		libbase
+		${THIRD_PARTY_ROOT}/aosp_modified/system/core/liblog/liblog.a
+    )
+endif()
+if (${MAST} STREQUAL "1")
+    list(APPEND deps_hir2mpl
+		lib_hir2mpl_ast_input_maple_lib
+	    lib_hir2mpl_ast_input_maple
+    )
+endif()
+
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lz -rdynamic -L${LLVMLIBDIR}/")
+
+if (${MAST} STREQUAL "1")
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lstdc++fs -L${MAPLE_PARSER_PATH}/output/c/ast_gen/shared")
+endif()
+
+if (${COV} STREQUAL "1")
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+endif()
+
+if (${GPROF} STREQUAL "1")
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg")
+endif()
+
+#hir2mpl
+add_executable(hir2mpl "${src_hir2mpl}")
+set_target_properties(hir2mpl PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${include_directories}"
+    LINK_LIBRARIES "${deps_hir2mpl}"
+    RUNTIME_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/bin"
+
+)
+
+set(inc_lib_hir2mpl_bytecode_input_class
+  ${HIR2MPL_ROOT}/common/include
+  ${HIR2MPL_ROOT}/optimize/include
+  ${HIR2MPL_ROOT}/bytecode_input/class/include
+  ${MAPLEALL_ROOT}/maple_ir/include
+  ${MAPLEALL_ROOT}/maple_util/include
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${MAPLEALL_ROOT}/mempool/include
+  ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+)
+
+set(src_lib_hir2mpl_bytecode_input_class
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_attr.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_attr_item.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_bb.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_class.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_class2fe_helper.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_class_const.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_class_const_pool.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_compiler_component.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_function.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_function_context.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_input.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_opcode.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_opcode_helper.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_stack2fe_helper.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_stack_helper.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_stmt.cpp
+  ${HIR2MPL_ROOT}/bytecode_input/class/src/jbc_util.cpp
+)
+
+# lib_hir2mpl_bytecode_input_class
+add_library(lib_hir2mpl_bytecode_input_class STATIC ${src_lib_hir2mpl_bytecode_input_class})
+set_target_properties(lib_hir2mpl_bytecode_input_class PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${inc_lib_hir2mpl_bytecode_input_class}"
+  LINK_LIBRARIES ""
+  RUNTIME_OUTPUT_DIRECTORY "${root_out_dir}/ar"
+)
+
+if (NOT ${ONLY_C} STREQUAL "1")
+	set(inc_lib_hir2mpl_bytecode_input_common
+      ${HIR2MPL_ROOT}/common/include
+      ${HIR2MPL_ROOT}/optimize/include
+      ${HIR2MPL_ROOT}/bytecode_input/common/include
+      ${HIR2MPL_ROOT}/bytecode_input/dex/include
+      ${MAPLEALL_ROOT}/maple_ir/include
+      ${MAPLEALL_ROOT}/maple_util/include
+      ${MAPLEALL_ROOT}/maple_driver/include
+      ${MAPLEALL_ROOT}/mempool/include
+      ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+	)
+
+	set(src_lib_hir2mpl_bytecode_input_common
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/ark_annotation_map.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/ark_annotation_processor.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/bc_class.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/bc_class2fe_helper.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/bc_function.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/bc_instruction.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/bc_io.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/bc_parser_base.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/bc_pragma.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/bc_util.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/common/src/rc_setter.cpp
+	)
+	# lib_hir2mpl_bytecode_input_common
+	add_library(lib_hir2mpl_bytecode_input_common STATIC ${src_lib_hir2mpl_bytecode_input_common})
+	set_target_properties(lib_hir2mpl_bytecode_input_common PROPERTIES
+	  COMPILE_FLAGS ""
+	  INCLUDE_DIRECTORIES "${inc_lib_hir2mpl_bytecode_input_common}"
+	  LINK_LIBRARIES ""
+	  RUNTIME_OUTPUT_DIRECTORY "${root_out_dir}/ar"
+	)
+
+	set(include_bytecode_input_dex_directories
+      ${HIR2MPL_ROOT}/common/include
+      ${HIR2MPL_ROOT}/optimize/include
+      ${HIR2MPL_ROOT}/bytecode_input/common/include
+      ${HIR2MPL_ROOT}/bytecode_input/dex/include
+      ${MAPLEALL_ROOT}/maple_ir/include
+      ${MAPLEALL_ROOT}/maple_util/include
+      ${MAPLEALL_ROOT}/maple_driver/include
+      ${MAPLEALL_ROOT}/mempool/include
+      ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+	)
+
+	set(src_lib_hir2mpl_bytecode_input_dex
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/class_linker.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/class_loader_context.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_class.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_class2fe_helper.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_encode_value.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_file_util.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_op.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_pragma.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_strfac.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_parser.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dex_reader.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dexfile_factory.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dexfile_interface.cpp
+      ${HIR2MPL_ROOT}/bytecode_input/dex/src/dexfile_libdexfile.cpp
+	)
+
+	list(APPEND include_bytecode_input_dex_directories
+	  ${THIRD_PARTY_ROOT}/aosp_modified/system/core/include
+	)
+
+	list(APPEND include_bytecode_input_dex_directories
+      ${THIRD_PARTY_ROOT}/aosp_modified/system/core/liblog/include
+      ${THIRD_PARTY_ROOT}/aosp_modified/system/core/libutils/include
+      ${THIRD_PARTY_ROOT}/aosp_modified/system/core/base/include
+      ${THIRD_PARTY_ROOT}/aosp_modified/system/core/libziparchive/include
+      ${THIRD_PARTY_ROOT}/aosp_modified/art/libartpalette/include
+      ${THIRD_PARTY_ROOT}/aosp_modified/art/libartbase
+      ${THIRD_PARTY_ROOT}/aosp_modified/art/libdexfile
+      ${THIRD_PARTY_ROOT}/aosp_modified/include
+      ${THIRD_PARTY_ROOT}/aosp_modified/libnativehelper/include_jni
+	)
+
+	set(deps_libdexfile
+	  libdexfile
+	  libziparchive
+	  libbase
+	  ${THIRD_PARTY_ROOT}/aosp_modified/system/core/liblog/liblog.a
+	)
+
+	# lib_hir2mpl_bytecode_input_dex
+	add_library(lib_hir2mpl_bytecode_input_dex STATIC ${src_lib_hir2mpl_bytecode_input_dex})
+	set_target_properties(lib_hir2mpl_bytecode_input_dex PROPERTIES
+	  COMPILE_FLAGS ""
+	  INCLUDE_DIRECTORIES "${include_bytecode_input_dex_directories}"
+	  LINK_LIBRARIES "${deps_libdexfile}"
+	  RUNTIME_OUTPUT_DIRECTORY "${root_out_dir}/ar"
+	)
+endif()
+
+set(src_lib_hir2mpl_ast_input_clang_lib
+  ${HIR2MPL_ROOT}/ast_input/clang/lib/ast_interface.cpp
+)
+
+set(deps_lib_hir2mpl_ast_input_clang_lib
+  ${LLVMLIBDIR}/libclang.so
+  ${LLVMLIBDIR}/libclang-cpp.so
+  ${LLVMLIBDIR}/libclangFrontend.a
+  ${LLVMLIBDIR}/libclangDriver.a
+  ${LLVMLIBDIR}/libclangSerialization.a
+  ${LLVMLIBDIR}/libclangParse.a
+  ${LLVMLIBDIR}/libclangSema.a
+  ${LLVMLIBDIR}/libclangEdit.a
+  ${LLVMLIBDIR}/libclangLex.a
+  ${LLVMLIBDIR}/libclangAnalysis.a
+  ${LLVMLIBDIR}/libclangAST.a
+  ${LLVMLIBDIR}/libclangBasic.a
+  ${LLVMLIBDIR}/libLLVMDemangle.a
+  ${LLVMLIBDIR}/libLLVMMCParser.a
+  ${LLVMLIBDIR}/libLLVMMC.a
+  ${LLVMLIBDIR}/libLLVMBitReader.a
+  ${LLVMLIBDIR}/libLLVMCore.a
+  ${LLVMLIBDIR}/libLLVMBinaryFormat.a
+  ${LLVMLIBDIR}/libLLVMProfileData.a
+  ${LLVMLIBDIR}/libLLVMOption.a
+  ${LLVMLIBDIR}/libLLVMSupport.a
+)
+
+set(defines
+  CLANG_ENABLE_ARCMT
+  CLANG_ENABLE_OBJC_REWRITER
+  CLANG_ENABLE_STATIC_ANALYZER
+  GTEST_HAS_RTTI=0
+  _DEBUG
+  _GNU_SOURCE
+  __STDC_CONSTANT_MACROS
+  __STDC_FORMAT_MACROS
+  __STDC_LIMIT_MACROS
+)
+
+# lib_hir2mpl_ast_input_clang_lib
+add_library(lib_hir2mpl_ast_input_clang_lib STATIC ${src_lib_hir2mpl_ast_input_clang_lib})
+set_target_properties(lib_hir2mpl_ast_input_clang_lib PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${include_directories}"
+  LINK_LIBRARIES "${deps_lib_hir2mpl_ast_input_clang_lib}"
+  RUNTIME_OUTPUT_DIRECTORY "${root_out_dir}/ar"
+  DEFINE_SYMBOL "${defines}"
+)
+
+# lib_hir2mpl_ast_input_common
+add_library(lib_hir2mpl_ast_input_common STATIC "${HIR2MPL_ROOT}/ast_input/common/src/ast_decl.cpp")
+set_target_properties(lib_hir2mpl_ast_input_common PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${include_directories}"
+  LINK_LIBRARIES ""
+  RUNTIME_OUTPUT_DIRECTORY "${root_out_dir}/ar"
+)
+
+set(src_lib_hir2mpl_ast_input_clang
+  ${HIR2MPL_ROOT}/ast_input/clang/lib/ast_type.cpp
+  ${HIR2MPL_ROOT}/ast_input/clang/lib/ast_util.cpp
+  ${HIR2MPL_ROOT}/ast_input/clang/src/ast_expr.cpp
+  ${HIR2MPL_ROOT}/ast_input/clang/src/ast_function.cpp
+  ${HIR2MPL_ROOT}/ast_input/clang/src/ast_parser.cpp
+  ${HIR2MPL_ROOT}/ast_input/clang/src/ast_parser_builting_func.cpp
+  ${HIR2MPL_ROOT}/ast_input/clang/src/ast_stmt.cpp
+  ${HIR2MPL_ROOT}/ast_input/clang/src/ast_struct2fe_helper.cpp
+)
+
+set(deps_lib_hir2mpl_ast_input_clang
+  lib_hir2mpl_ast_input_clang_lib
+)
+
+# lib_hir2mpl_ast_input_clang
+add_library(lib_hir2mpl_ast_input_clang STATIC ${src_lib_hir2mpl_ast_input_clang})
+set_target_properties(lib_hir2mpl_ast_input_clang PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${include_directories}"
+  LINK_LIBRARIES "${deps_lib_hir2mpl_ast_input_clang}"
+  RUNTIME_OUTPUT_DIRECTORY "${root_out_dir}/ar"
+)
+
+if (${MAST} STREQUAL "1")
+	set(deps_lib_hir2mpl_ast_input_maple_lib
+      ${MAPLE_PARSER_PATH}/output/c/ast_gen/shared/genast.a
+      ${MAPLE_PARSER_PATH}/output/c/shared/shared.a
+      ${MAPLE_PARSER_PATH}/output/c/gen/gen.a
+      ${MAPLE_PARSER_PATH}/output/c/astopt/astopt.a
+	)
+# lib_hir2mpl_ast_input_maple_lib
+	add_library(lib_hir2mpl_ast_input_maple_lib STATIC "${HIR2MPL_ROOT}/ast_input/maple/lib/maple_ast_interface.cpp")
+	set_target_properties(lib_hir2mpl_ast_input_maple_lib PROPERTIES
+	  COMPILE_FLAGS ""
+	  INCLUDE_DIRECTORIES "${include_directories}"
+	  LINK_LIBRARIES "${deps_lib_hir2mpl_ast_input_maple_lib}"
+	  RUNTIME_OUTPUT_DIRECTORY "${root_out_dir}/ar"
+	  DEFINE_SYMBOL "DEBUG"
+	)
+# lib_hir2mpl_ast_input_maple
+	add_library(lib_hir2mpl_ast_input_maple STATIC "${HIR2MPL_ROOT}/ast_input/maple/src/maple_ast_parser.cpp")
+	set_target_properties(lib_hir2mpl_ast_input_maple PROPERTIES
+	  COMPILE_FLAGS ""
+	  INCLUDE_DIRECTORIES "${include_directories}"
+	  LINK_LIBRARIES "lib_hir2mpl_ast_input_maple_lib"
+	  RUNTIME_OUTPUT_DIRECTORY "${root_out_dir}/ar"
+	  DEFINE_SYMBOL "DEBUG"
+	)
+endif()
diff --git a/src/hir2mpl/README.md b/src/hir2mpl/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ce48eeaad2359730fbff5b92d4f0f74db6395bdf
--- /dev/null
+++ b/src/hir2mpl/README.md
@@ -0,0 +1,108 @@
+```
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+```
+
+Hir2mpl supports .ast, .dex, .class and .jar as inputs. Currently, .class and .jar are not enabled.
+hir2mpl enables the corresponding compilation process based on the inputs.
+
+## Building hir2mpl
+
+source build/envsetup.sh arm release/debug
+
+make hir2mpl
+
+## Usage
+
+hir2mpl -h to view available options
+
+## Compile .dex
+
+First, use java2dex to generate the required xxx.dex file from xxx.java.
+
+bash ${OUT_ROOT}/tools/bin/java2dex  -o xxx.dex -p <classpath> -i xxx.java
+
+If the xxx.dex file depends on other files, use the -mplt command to add the depended file.
+
+the depended mplts need to compile firstly. Also, you can use the -Xbootclasspath to
+
+load the dependent JAR package.
+
+${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl -mplt <classpath mplt> xxx.dex -o xxx.mpl
+
+${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl -Xbootclasspath=<classpath> xxx.dex -o xxx.mpl
+
+Note:
+1. The GC mode is used for memory management by default.
+   If you want to use the RC mode, you can use the "-rc" option to switch.
+2. Invalid option scope "ast Compile Options" and "Security Check".
+
+## Compile .ast
+
+First, use clang to generate the required xxx.ast file from xxx.c.
+
+${MAPLE_ROOT}/tools/clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/clang -emit-ast xxx.c -o xxx.ast
+
+${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl xxx.ast -o xxx.mpl
+
+Note:
+1. The backend supports variable arrays that are incomplete.
+   By default, the frontend intercepts variable arrays.
+   You can use the "-enable-variable-array" option to enable the frontend to support variable arrays.
+
+2. hir2mpl supports static security check and check statement insertion based on source code annotation.
+   However, the source code must be compiled using the Clang binary provided by the Maple community.
+   You can enable the corresponding check by selecting the corresponding option "-npe-check-dynamic"
+   and "-boundary-check-dynamic".
+
+3. Invalid option scope "BC Bytecode Compile Options" and "On Demand Type Creation".
+
+## UT Test
+
+Building UT target : make hir2mplUT
+
+Before running the UT test, compile the libcore which the UT depends.
+
+make libcore
+
+bash $MAPLE_ROOT/src/hir2mpl/test/hir2mplUT_check.sh
+
+## Directory structure
+
+hir2mpl
+├── ast_input                     # .ast/.mast parser
+│   ├── clang
+│   ├── common
+│   └── maple
+├── BUILD.gn                      # build configuration files
+├── bytecode_input                # .class/.dex parser
+│   ├── class
+│   ├── common
+│   └── dex
+├── common                        # feir part
+│   ├── include
+│   └── src
+├── optimize                      # lower/cfg/dfg(TODO Refactoring) and pattern match opt
+│   ├── include
+│   └── src
+├── README.md
+└── test                          # UT test
+    ├── ast_input
+    ├── BUILD.gn
+    ├── bytecode_input
+    ├── common
+    ├── cov_check.sh
+    ├── hir2mplUT_check.sh
+    └── ops_ut_check.sh
diff --git a/src/hir2mpl/ast_input/clang/include/ast_builtin_func.def b/src/hir2mpl/ast_input/clang/include/ast_builtin_func.def
new file mode 100644
index 0000000000000000000000000000000000000000..4577b601397825a0f5b93205b2ed5d00fbc5ed66
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/include/ast_builtin_func.def
@@ -0,0 +1,33 @@
+// BUILTIN_FUNC(funcName)
+BUILTIN_FUNC(printf)
+BUILTIN_FUNC(snprintf)
+BUILTIN_FUNC(strncpy)
+BUILTIN_FUNC(strcpy)
+BUILTIN_FUNC(strcmp)
+BUILTIN_FUNC(strlen)
+BUILTIN_FUNC(strchr)
+BUILTIN_FUNC(strrchr)
+BUILTIN_FUNC(memcmp)
+BUILTIN_FUNC(memcpy)
+BUILTIN_FUNC(memset)
+BUILTIN_FUNC(memmove)
+BUILTIN_FUNC(__memcpy_chk)
+BUILTIN_FUNC(__memset_chk)
+BUILTIN_FUNC(__strncpy_chk)
+BUILTIN_FUNC(__strcpy_chk)
+BUILTIN_FUNC(__stpcpy_chk)
+BUILTIN_FUNC(__vsprintf_chk)
+BUILTIN_FUNC(__vsnprintf_chk)
+BUILTIN_FUNC(__snprintf_chk)
+BUILTIN_FUNC(__sprintf_chk)
+BUILTIN_FUNC(__strcat_chk)
+BUILTIN_FUNC(__strncat_chk)
+BUILTIN_FUNC(__mempcpy_chk)
+BUILTIN_FUNC(__memmove_chk)
+
+BUILTIN_FUNC(abs)
+BUILTIN_FUNC(abort)
+BUILTIN_FUNC(frame_address)
+BUILTIN_FUNC(setjmp)
+BUILTIN_FUNC(longjmp)
+BUILTIN_FUNC(mul_overflow)
diff --git a/src/hir2mpl/ast_input/clang/include/ast_expr.h b/src/hir2mpl/ast_input/clang/include/ast_expr.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec1ad8ca92f091dbe099df7e3fa80ae441afc41c
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/include/ast_expr.h
@@ -0,0 +1,1863 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_INPUT_INCLUDE_AST_EXPR_H
+#define HIR2MPL_AST_INPUT_INCLUDE_AST_EXPR_H
+#include <variant>
+#include "ast_op.h"
+#include "feir_stmt.h"
+
+namespace maple {
+class ASTDecl;
+class ASTFunc;
+class ASTStmt;
+struct ASTValue {
+  union Value {
+    uint8 u8;
+    uint16 u16;
+    uint32 u32;
+    uint64 u64;
+    int8 i8;
+    int16 i16;
+    int32 i32;
+    float f32;
+    int64 i64;
+    double f64;
+    UStrIdx strIdx;
+  } val = { 0 };
+  PrimType pty = PTY_begin;
+
+  PrimType GetPrimType() const {
+    return pty;
+  }
+
+  MIRConst *Translate2MIRConst() const;
+};
+
+enum class ParentFlag {
+  kNoParent,
+  kArrayParent,
+  kStructParent
+};
+
+enum EvaluatedFlag : uint8 {
+  kEvaluatedAsZero,
+  kEvaluatedAsNonZero,
+  kNotEvaluated
+};
+
+class ASTExpr {
+ public:
+  explicit ASTExpr(ASTOp o) : op(o) {}
+  virtual ~ASTExpr() = default;
+  UniqueFEIRExpr Emit2FEExpr(std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr ImplicitInitFieldValue(MIRType &type, std::list<UniqueFEIRStmt> &stmts) const;
+
+  virtual MIRType *GetType() const {
+    return mirType;
+  }
+
+  void SetType(MIRType *type) {
+    mirType = type;
+  }
+
+  void SetASTDecl(ASTDecl *astDecl) {
+    refedDecl = astDecl;
+  }
+
+  ASTDecl *GetASTDecl() const {
+    return GetASTDeclImpl();
+  }
+
+  ASTOp GetASTOp() const {
+    return op;
+  }
+
+  void SetConstantValue(ASTValue *val) {
+    isConstantFolded = (val != nullptr);
+    value = val;
+  }
+
+  void SetIsConstantFolded(bool flag) {
+    isConstantFolded = flag;
+  }
+
+  bool IsConstantFolded() const {
+    return isConstantFolded;
+  }
+
+  ASTValue *GetConstantValue() const {
+    return GetConstantValueImpl();
+  }
+
+  MIRConst *GenerateMIRConst() const {
+    return GenerateMIRConstImpl();
+  }
+
+  void SetSrcLoc(const Loc &l) {
+    loc = l;
+  }
+
+  Loc GetSrcLoc() const {
+    return loc;
+  }
+
+  uint32 GetSrcFileIdx() const {
+    return loc.fileIdx;
+  }
+
+  uint32 GetSrcFileLineNum() const {
+    return loc.line;
+  }
+
+  uint32 GetSrcFileColumn() const {
+    return loc.column;
+  }
+
+  void SetEvaluatedFlag(EvaluatedFlag flag) {
+    evaluatedflag = flag;
+    return;
+  }
+
+  EvaluatedFlag GetEvaluatedFlag() const {
+    return evaluatedflag;
+  }
+
+  bool IsRValue() const {
+    return isRValue;
+  }
+
+  void SetRValue(bool flag) {
+    isRValue = flag;
+  }
+
+  virtual void SetShortCircuitIdx(uint32 leftIdx, uint32 rightIdx) {}
+
+  ASTExpr *IgnoreParens() {
+    return IgnoreParensImpl();
+  }
+
+ protected:
+  virtual ASTValue *GetConstantValueImpl() const {
+    return value;
+  }
+  virtual MIRConst *GenerateMIRConstImpl() const;
+  virtual UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const = 0;
+  virtual ASTExpr *IgnoreParensImpl();
+
+  virtual ASTDecl *GetASTDeclImpl() const {
+    return refedDecl;
+  }
+
+  ASTOp op;
+  MIRType *mirType = nullptr;
+  ASTDecl *refedDecl = nullptr;
+  bool isConstantFolded = false;
+  ASTValue *value = nullptr;
+  Loc loc = {0, 0, 0};
+  EvaluatedFlag evaluatedflag = kNotEvaluated;
+  bool isRValue = false;
+};
+
+class ASTCastExpr : public ASTExpr {
+ public:
+  explicit ASTCastExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpCast) {
+    (void)allocatorIn;
+  }
+  ~ASTCastExpr() = default;
+
+  void SetASTExpr(ASTExpr *expr) {
+    child = expr;
+  }
+
+  const ASTExpr *GetASTExpr() const {
+    return child;
+  }
+
+  void SetSrcType(MIRType *type) {
+    src = type;
+  }
+
+  const MIRType *GetSrcType() const {
+    return src;
+  }
+
+  void SetDstType(MIRType *type) {
+    dst = type;
+  }
+
+  const MIRType *GetDstType() const {
+    return dst;
+  }
+
+  void SetNeededCvt(bool cvt) {
+    isNeededCvt = cvt;
+  }
+
+  bool IsNeededCvt(const UniqueFEIRExpr &expr) const {
+    if (!isNeededCvt || expr == nullptr || dst == nullptr) {
+      return false;
+    }
+    PrimType srcPrimType = expr->GetPrimType();
+    return srcPrimType != dst->GetPrimType() && srcPrimType != PTY_agg && srcPrimType != PTY_void;
+  }
+
+  void SetComplexType(MIRType *type) {
+    complexType = type;
+  }
+
+  void SetComplexCastKind(bool flag) {
+    imageZero = flag;
+  }
+
+  void SetIsArrayToPointerDecay(bool flag) {
+    isArrayToPointerDecay = flag;
+  }
+
+  void SetIsFunctionToPointerDecay(bool flag) {
+    isFunctionToPointerDecay = flag;
+  }
+
+  bool IsBuilinFunc() const {
+    return isBuilinFunc;
+  }
+
+  void SetBuilinFunc(bool flag) {
+    isBuilinFunc = flag;
+  }
+
+  void SetUnionCast(bool flag) {
+    isUnoinCast = flag;
+  }
+
+  void SetBitCast(bool flag) {
+    isBitCast = flag;
+  }
+
+  void SetVectorSplat(bool flag) {
+    isVectorSplat = flag;
+  }
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+
+  ASTDecl *GetASTDeclImpl() const override {
+    return child->GetASTDecl();
+  }
+
+  UniqueFEIRExpr Emit2FEExprForComplex(const UniqueFEIRExpr &subExpr, const UniqueFEIRType &srcType,
+                                       std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr Emit2FEExprForFunctionOrArray2Pointer(std::list<UniqueFEIRStmt> &stmts) const;
+
+ private:
+  MIRConst *GenerateMIRDoubleConst() const;
+  MIRConst *GenerateMIRFloatConst() const;
+  MIRConst *GenerateMIRIntConst() const;
+  UniqueFEIRExpr EmitExprVdupVector(PrimType primtype, UniqueFEIRExpr &subExpr) const;
+
+  ASTExpr *child = nullptr;
+  MIRType *src = nullptr;
+  MIRType *dst = nullptr;
+  bool isNeededCvt = false;
+  bool isBitCast = false;
+  MIRType *complexType = nullptr;
+  bool imageZero = false;
+  bool isArrayToPointerDecay = false;
+  bool isFunctionToPointerDecay = false;
+  bool isBuilinFunc = false;
+  bool isUnoinCast = false;
+  bool isVectorSplat = false;
+};
+
+class ASTDeclRefExpr : public ASTExpr {
+ public:
+  explicit ASTDeclRefExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpRef) {
+    (void)allocatorIn;
+  }
+  ~ASTDeclRefExpr() = default;
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTUnaryOperatorExpr : public ASTExpr {
+ public:
+  explicit ASTUnaryOperatorExpr(ASTOp o) : ASTExpr(o) {}
+  ASTUnaryOperatorExpr(MapleAllocator &allocatorIn, ASTOp o) : ASTExpr(o) {
+    (void)allocatorIn;
+  }
+  virtual ~ASTUnaryOperatorExpr() = default;
+  void SetUOExpr(ASTExpr *astExpr);
+
+  const ASTExpr *GetUOExpr() const {
+    return expr;
+  }
+
+  void SetSubType(MIRType *type);
+
+  const MIRType *GetMIRType() const {
+    return subType;
+  }
+
+  void SetUOType(MIRType *type) {
+    uoType = type;
+  }
+
+  const MIRType *GetUOType() const {
+    return uoType;
+  }
+
+  void SetPointeeLen(int64 len) {
+    pointeeLen = len;
+  }
+
+  int64 GetPointeeLen() const {
+    return pointeeLen;
+  }
+
+  void SetGlobal(bool isGlobalArg) {
+    isGlobal = isGlobalArg;
+  }
+
+  bool IsGlobal() const {
+    return isGlobal;
+  }
+
+  UniqueFEIRExpr ASTUOSideEffectExpr(Opcode op, std::list<UniqueFEIRStmt> &stmts,
+      const std::string &varName = "", bool post = false) const;
+
+ protected:
+  bool isGlobal = false;
+  ASTExpr *expr = nullptr;
+  MIRType *subType = nullptr;
+  MIRType *uoType = nullptr;
+  int64 pointeeLen = 0;
+};
+
+class ASTUOMinusExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOMinusExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpMinus) {}
+  ~ASTUOMinusExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTUONotExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUONotExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpNot) {}
+  ~ASTUONotExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTUOLNotExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOLNotExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpLNot) {}
+  ~ASTUOLNotExpr() = default;
+
+  void SetShortCircuitIdx(uint32 leftIdx, uint32 rightIdx) override {
+    trueIdx = leftIdx;
+    falseIdx = rightIdx;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  uint32 trueIdx = 0;
+  uint32 falseIdx = 0;
+};
+
+class ASTUOPostIncExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOPostIncExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpPostInc),
+      tempVarName(FEUtils::GetSequentialName("postinc_")) {}
+  ~ASTUOPostIncExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  std::string tempVarName;
+};
+
+class ASTUOPostDecExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOPostDecExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpPostDec),
+      tempVarName(FEUtils::GetSequentialName("postdec_")) {}
+  ~ASTUOPostDecExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  std::string tempVarName;
+};
+
+class ASTUOPreIncExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOPreIncExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpPreInc) {}
+  ~ASTUOPreIncExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTUOPreDecExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOPreDecExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpPreDec) {}
+  ~ASTUOPreDecExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  std::string tempVarName;
+};
+
+class ASTUOAddrOfExpr : public ASTUnaryOperatorExpr {
+ public:
+  ASTUOAddrOfExpr() : ASTUnaryOperatorExpr(kASTOpAddrOf) {}
+  explicit ASTUOAddrOfExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpAddrOf) {}
+  ~ASTUOAddrOfExpr() = default;
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTUOAddrOfLabelExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOAddrOfLabelExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpAddrOfLabel),
+      labelName("", allocatorIn.GetMemPool()) {}
+  ~ASTUOAddrOfLabelExpr() = default;
+
+  void SetLabelName(const std::string &name) {
+    labelName = name;
+  }
+
+  const std::string GetLabelName() const {
+    return labelName.c_str() == nullptr ? "" : labelName.c_str();
+  }
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MapleString labelName;
+};
+
+class ASTUODerefExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUODerefExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpDeref) {}
+  ~ASTUODerefExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  void InsertNonnullChecking(std::list<UniqueFEIRStmt> &stmts, UniqueFEIRExpr baseExpr) const;
+  bool InsertBoundaryChecking(std::list<UniqueFEIRStmt> &stmts, UniqueFEIRExpr expr) const;
+};
+
+class ASTUOPlusExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOPlusExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpPlus) {}
+  ~ASTUOPlusExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTUORealExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUORealExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpReal) {}
+  ~ASTUORealExpr() = default;
+
+  void SetElementType(MIRType *type) {
+    elementType = type;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MIRType *elementType = nullptr;
+};
+
+class ASTUOImagExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOImagExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpImag) {}
+  ~ASTUOImagExpr() = default;
+
+  void SetElementType(MIRType *type) {
+    elementType = type;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MIRType *elementType = nullptr;
+};
+
+class ASTUOExtensionExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOExtensionExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpExtension) {}
+  ~ASTUOExtensionExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTUOCoawaitExpr : public ASTUnaryOperatorExpr {
+ public:
+  explicit ASTUOCoawaitExpr(MapleAllocator &allocatorIn) : ASTUnaryOperatorExpr(allocatorIn, kASTOpCoawait) {}
+  ~ASTUOCoawaitExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTPredefinedExpr : public ASTExpr {
+ public:
+  explicit ASTPredefinedExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpPredefined) {
+    (void)allocatorIn;
+  }
+  ~ASTPredefinedExpr() = default;
+  void SetASTExpr(ASTExpr *astExpr);
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  ASTExpr *child = nullptr;
+};
+
+class ASTOpaqueValueExpr : public ASTExpr {
+ public:
+  explicit ASTOpaqueValueExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpOpaqueValue) {
+    (void)allocatorIn;
+  }
+  ~ASTOpaqueValueExpr() = default;
+  void SetASTExpr(ASTExpr *astExpr);
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  ASTExpr *child = nullptr;
+};
+
+class ASTNoInitExpr : public ASTExpr {
+ public:
+  explicit ASTNoInitExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpNoInitExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTNoInitExpr() = default;
+  void SetNoInitType(MIRType *type);
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MIRType *noInitType = nullptr;
+};
+
+class ASTCompoundLiteralExpr : public ASTExpr {
+ public:
+  explicit ASTCompoundLiteralExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpCompoundLiteralExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTCompoundLiteralExpr() = default;
+  void SetCompoundLiteralType(MIRType *clType);
+  void SetASTExpr(ASTExpr *astExpr);
+
+  void SetAddrof(bool flag) {
+    isAddrof = flag;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MIRConst *GenerateMIRConstImpl() const override;
+  MIRConst *GenerateMIRPtrConst() const;
+  ASTExpr *child = nullptr;
+  MIRType *compoundLiteralType = nullptr;
+  bool isAddrof = false;
+};
+
+class ASTOffsetOfExpr : public ASTExpr {
+ public:
+  explicit ASTOffsetOfExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpOffsetOfExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTOffsetOfExpr() = default;
+  void SetStructType(MIRType *stype);
+  void SetFieldName(const std::string &fName);
+
+  void SetOffset(size_t val) {
+    offset = val;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MIRType *structType = nullptr;
+  std::string fieldName;
+  size_t offset = 0;
+};
+
+class ASTInitListExpr : public ASTExpr {
+ public:
+  explicit ASTInitListExpr(MapleAllocator &allocatorIn)
+      : ASTExpr(kASTOpInitListExpr), initExprs(allocatorIn.Adapter()), varName("", allocatorIn.GetMemPool()) {}
+  ~ASTInitListExpr() = default;
+  void SetInitExprs(ASTExpr *astExpr);
+  void SetInitListType(MIRType *type);
+
+  const MIRType *GetInitListType() const {
+    return initListType;
+  }
+
+  MapleVector<ASTExpr*> GetInitExprs() const {
+    return initExprs;
+  }
+
+  void SetInitListVarName(const std::string &argVarName) {
+    varName = argVarName;
+  }
+
+  const std::string GetInitListVarName() const {
+    return varName.c_str() == nullptr ? "" : varName.c_str();
+  }
+
+  void SetParentFlag(ParentFlag argParentFlag) {
+    parentFlag = argParentFlag;
+  }
+
+  void SetUnionInitFieldIdx(uint32 idx) {
+    unionInitFieldIdx = idx;
+  }
+
+  uint32 GetUnionInitFieldIdx() const {
+    return unionInitFieldIdx;
+  }
+
+  void SetHasArrayFiller(bool flag) {
+    hasArrayFiller = flag;
+  }
+
+  bool HasArrayFiller() const {
+    return hasArrayFiller;
+  }
+
+  void SetTransparent(bool flag) {
+    isTransparent = flag;
+  }
+
+  bool IsTransparent() const {
+    return isTransparent;
+  }
+
+  void SetArrayFiller(ASTExpr *expr) {
+    arrayFillerExpr = expr;
+  }
+
+  const ASTExpr *GetArrayFillter() const {
+    return arrayFillerExpr;
+  }
+
+  void SetHasVectorType(bool flag) {
+    hasVectorType = flag;
+  }
+
+  bool HasVectorType() const {
+    return hasVectorType;
+  }
+
+ private:
+  MIRConst *GenerateMIRConstImpl() const override;
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  void ProcessInitList(std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                       const ASTInitListExpr &initList, std::list<UniqueFEIRStmt> &stmts) const;
+  void ProcessArrayInitList(const UniqueFEIRExpr &addrOfArray, const ASTInitListExpr &initList,
+                            std::list<UniqueFEIRStmt> &stmts) const;
+  void SolveArrayElementInitWithInitListExpr(const UniqueFEIRExpr &addrOfArray, const UniqueFEIRExpr &addrOfElementExpr,
+                                             const MIRType &elementType, const ASTExpr &subExpr, size_t index,
+                                             std::list<UniqueFEIRStmt> &stmts) const;
+  void HandleImplicitInitSections(const UniqueFEIRExpr &addrOfArray, const ASTInitListExpr &initList,
+                                  const MIRType &elementType, std::list<UniqueFEIRStmt> &stmts) const;
+  void ProcessStructInitList(std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                             const ASTInitListExpr &initList, std::list<UniqueFEIRStmt> &stmts) const;
+  void SolveInitListFullOfZero(const MIRStructType &baseStructType, FieldID baseFieldID, const UniqueFEIRVar &var,
+                               const ASTInitListExpr &initList, std::list<UniqueFEIRStmt> &stmts) const;
+  bool SolveInitListPartialOfZero(std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                                  FieldID fieldID, uint32 &index, const ASTInitListExpr &initList,
+                                  std::list<UniqueFEIRStmt> &stmts) const;
+  void SolveInitListExprOrDesignatedInitUpdateExpr(FieldID fieldID, ASTExpr &initExpr,
+      const UniqueFEIRType &baseStructPtrType, std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+      std::list<UniqueFEIRStmt> &stmts) const;
+  void SolveStructFieldOfArrayTypeInitWithStringLiteral(std::tuple<FieldID, uint32, MIRType*> fieldInfo,
+      const ASTExpr &initExpr, const UniqueFEIRType &baseStructPtrType,
+      std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base, std::list<UniqueFEIRStmt> &stmts) const;
+  void SolveStructFieldOfBasicType(FieldID fieldID, const ASTExpr &initExpr, const UniqueFEIRType &baseStructPtrType,
+                                   std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                                   std::list<UniqueFEIRStmt> &stmts) const;
+  std::tuple<FieldID, uint32, MIRType*> GetStructFieldInfo(uint32 fieldIndex, FieldID baseFieldID,
+                                                           MIRStructType &structMirType) const;
+  UniqueFEIRExpr CalculateStartAddressForMemset(const UniqueFEIRVar &varIn, uint32 initSizeIn, FieldID fieldIDIn,
+      const std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &baseIn) const;
+  UniqueFEIRExpr GetAddrofArrayFEExprByStructArrayField(MIRType &fieldType,
+                                                        const UniqueFEIRExpr &addrOfArrayField) const;
+  void ProcessVectorInitList(std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                             const ASTInitListExpr &initList, std::list<UniqueFEIRStmt> &stmts) const;
+  MIRIntrinsicID SetVectorSetLane(const MIRType &type) const;
+  void ProcessDesignatedInitUpdater(std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                                    ASTExpr *expr, std::list<UniqueFEIRStmt> &stmts) const;
+  void ProcessStringLiteralInitList(const UniqueFEIRExpr &addrOfCharArray, const UniqueFEIRExpr &addrOfStringLiteral,
+                                    size_t stringLength, std::list<UniqueFEIRStmt> &stmts) const;
+  void ProcessImplicitInit(const UniqueFEIRExpr &addrExpr, uint32 initSize, uint32 total, uint32 elemSize,
+                           std::list<UniqueFEIRStmt> &stmts, const Loc loc = {0, 0, 0}) const;
+  MIRConst *GenerateMIRConstForArray() const;
+  MIRConst *GenerateMIRConstForStruct() const;
+  MapleVector<ASTExpr*> initExprs;
+  ASTExpr *arrayFillerExpr = nullptr;
+  MIRType *initListType = nullptr;
+  MapleString varName;
+  ParentFlag parentFlag = ParentFlag::kNoParent;
+  uint32 unionInitFieldIdx = UINT32_MAX;
+  bool hasArrayFiller = false;
+  bool isTransparent = false;
+  bool hasVectorType = false;
+  mutable bool isGenerating = false;
+};
+
+class ASTBinaryConditionalOperator : public ASTExpr {
+ public:
+  explicit ASTBinaryConditionalOperator(MapleAllocator &allocatorIn) : ASTExpr(kASTOpBinaryConditionalOperator) {
+    (void)allocatorIn;
+  }
+  ~ASTBinaryConditionalOperator() = default;
+  void SetCondExpr(ASTExpr *expr);
+  void SetFalseExpr(ASTExpr *expr);
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  ASTExpr *condExpr = nullptr;
+  ASTExpr *falseExpr = nullptr;
+};
+
+class ASTBinaryOperatorExpr : public ASTExpr {
+ public:
+  ASTBinaryOperatorExpr(MapleAllocator &allocatorIn, ASTOp o) : ASTExpr(o) {
+    (void)allocatorIn;
+  }
+  explicit ASTBinaryOperatorExpr(MapleAllocator &allocatorIn)
+      : ASTExpr(kASTOpBO), varName(FEUtils::GetSequentialName(FEUtils::kCondGoToStmtLabelNamePrefix),
+        allocatorIn.GetMemPool()) {}
+
+  ~ASTBinaryOperatorExpr() override = default;
+
+  void SetRetType(MIRType *type) {
+    retType = type;
+  }
+
+  MIRType *GetRetType() const {
+    return retType;
+  }
+
+  void SetLeftExpr(ASTExpr *expr) {
+    leftExpr = expr;
+  }
+
+  void SetRightExpr(ASTExpr *expr) {
+    rightExpr = expr;
+  }
+
+  void SetOpcode(Opcode op) {
+    opcode = op;
+  }
+
+  Opcode GetOp() const {
+    return opcode;
+  }
+
+  void SetComplexElementType(MIRType *type) {
+    complexElementType = type;
+  }
+
+  void SetComplexLeftRealExpr(ASTExpr *expr) {
+    leftRealExpr = expr;
+  }
+
+  void SetComplexLeftImagExpr(ASTExpr *expr) {
+    leftImagExpr = expr;
+  }
+
+  void SetComplexRightRealExpr(ASTExpr *expr) {
+    rightRealExpr = expr;
+  }
+
+  void SetComplexRightImagExpr(ASTExpr *expr) {
+    rightImagExpr = expr;
+  }
+
+  void SetCvtNeeded(bool needed) {
+    cvtNeeded = needed;
+  }
+
+  void SetShortCircuitIdx(uint32 leftIdx, uint32 rightIdx) override {
+    trueIdx = leftIdx;
+    falseIdx = rightIdx;
+  }
+
+  std::string GetVarName() const {
+    return varName.c_str() == nullptr ? "" : varName.c_str();
+  }
+
+  UniqueFEIRType SelectBinaryOperatorType(UniqueFEIRExpr &left, UniqueFEIRExpr &right) const;
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+  MIRConst *SolveOpcodeLiorOrCior(const MIRConst &leftConst) const;
+  MIRConst *SolveOpcodeLandOrCand(const MIRConst &leftConst, const MIRConst &rightConst) const;
+  MIRConst *SolveOpcodeAdd(const MIRConst &leftConst, const MIRConst &rightConst) const;
+  MIRConst *SolveOpcodeSub(const MIRConst &leftConst, const MIRConst &rightConst) const;
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  UniqueFEIRExpr Emit2FEExprComplexCalculations(std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr Emit2FEExprComplexCompare(std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr Emit2FEExprLogicOperate(std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr Emit2FEExprLogicOperateSimplify(std::list<UniqueFEIRStmt> &stmts) const;
+
+  Opcode opcode = OP_undef;
+  MIRType *retType = nullptr;
+  MIRType *complexElementType = nullptr;
+  ASTExpr *leftExpr = nullptr;
+  ASTExpr *rightExpr = nullptr;
+  ASTExpr *leftRealExpr = nullptr;
+  ASTExpr *leftImagExpr = nullptr;
+  ASTExpr *rightRealExpr = nullptr;
+  ASTExpr *rightImagExpr = nullptr;
+  bool cvtNeeded = false;
+  MapleString varName;
+  uint32 trueIdx = 0;
+  uint32 falseIdx = 0;
+};
+
+class ASTImplicitValueInitExpr : public ASTExpr {
+ public:
+  explicit ASTImplicitValueInitExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTImplicitValueInitExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTImplicitValueInitExpr() = default;
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTStringLiteral : public ASTExpr {
+ public:
+  explicit ASTStringLiteral(MapleAllocator &allocatorIn) : ASTExpr(kASTStringLiteral),
+      codeUnits(allocatorIn.Adapter()), str(allocatorIn.Adapter()) {}
+  ~ASTStringLiteral() = default;
+
+  void SetLength(size_t len) {
+    length = len;
+  }
+
+  size_t GetLength() const {
+    return length;
+  }
+
+  void SetCodeUnits(MapleVector<uint32> &units) {
+    codeUnits = std::move(units);
+  }
+
+  const MapleVector<uint32> &GetCodeUnits() const {
+    return codeUnits;
+  }
+
+  void SetStr(const std::string &strIn) {
+    if (str.size() > 0) {
+      str.clear();
+      str.shrink_to_fit();
+    }
+    (void)str.insert(str.cend(), strIn.cbegin(), strIn.cend());
+  }
+
+  const std::string GetStr() const {
+    return std::string(str.cbegin(), str.cend());
+  }
+
+  void SetIsArrayToPointerDecay(bool argIsArrayToPointerDecay) {
+    isArrayToPointerDecay = argIsArrayToPointerDecay;
+  }
+
+  bool IsArrayToPointerDecay() const {
+    return isArrayToPointerDecay;
+  }
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  size_t length = 0;
+  MapleVector<uint32> codeUnits;
+  MapleVector<char> str;  // Ascii string
+  bool isArrayToPointerDecay = false;
+};
+
+class ASTArraySubscriptExpr : public ASTExpr {
+ public:
+  explicit ASTArraySubscriptExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTSubscriptExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTArraySubscriptExpr() = default;
+
+  void SetBaseExpr(ASTExpr *astExpr) {
+    baseExpr = astExpr;
+  }
+
+  const ASTExpr *GetBaseExpr() const {
+    return baseExpr;
+  }
+
+  void SetIdxExpr(ASTExpr *astExpr) {
+    idxExpr = astExpr;
+  }
+
+  const ASTExpr *GetIdxExpr() const {
+    return idxExpr;
+  }
+
+  void SetArrayType(MIRType *ty) {
+    arrayType = ty;
+  }
+
+  const MIRType *GetArrayType() const {
+    return arrayType;
+  }
+
+  size_t CalculateOffset() const;
+
+  void SetIsVLA(bool flag) {
+    isVLA = flag;
+  }
+
+  void SetVLASizeExpr(ASTExpr *expr) {
+    vlaSizeExpr = expr;
+  }
+
+ private:
+  ASTExpr *FindFinalBase() const;
+  MIRConst *GenerateMIRConstImpl() const override;
+  bool CheckFirstDimIfZero(const MIRType *arrType) const;
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MIRType *GetArrayTypeForPointerArray() const;
+  UniqueFEIRExpr SolveMultiDimArray(UniqueFEIRExpr &baseAddrFEExpr, UniqueFEIRType &arrayFEType,
+                                    bool isArrayTypeOpt, std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr SolveOtherArrayType(const UniqueFEIRExpr &baseAddrFEExpr, std::list<UniqueFEIRStmt> &stmts) const;
+  void InsertNonnullChecking(std::list<UniqueFEIRStmt> &stmts, const UniqueFEIRExpr &indexExpr,
+                             const UniqueFEIRExpr &baseAddrExpr) const;
+  bool InsertBoundaryChecking(std::list<UniqueFEIRStmt> &stmts, UniqueFEIRExpr indexExpr,
+                              UniqueFEIRExpr baseAddrFEExpr) const;
+
+  ASTExpr *baseExpr = nullptr;
+  MIRType *arrayType = nullptr;
+  ASTExpr *idxExpr = nullptr;
+  bool isVLA = false;
+  ASTExpr *vlaSizeExpr = nullptr;
+};
+
+class ASTExprUnaryExprOrTypeTraitExpr : public ASTExpr {
+ public:
+  explicit ASTExprUnaryExprOrTypeTraitExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTExprUnaryExprOrTypeTraitExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTExprUnaryExprOrTypeTraitExpr() = default;
+
+  void SetIsType(bool type) {
+    isType = type;
+  }
+
+  void SetArgType(MIRType *type) {
+    argType = type;
+  }
+
+  void SetArgExpr(ASTExpr *astExpr) {
+    argExpr = astExpr;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  bool isType = false;
+  MIRType *argType = nullptr;
+  ASTExpr *argExpr = nullptr;
+};
+
+class ASTMemberExpr : public ASTExpr {
+ public:
+  explicit ASTMemberExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTMemberExpr),
+      memberName("", allocatorIn.GetMemPool()) {}
+  ~ASTMemberExpr() = default;
+
+  void SetBaseExpr(ASTExpr *astExpr) {
+    baseExpr = astExpr;
+  }
+
+  const ASTExpr *GetBaseExpr() const {
+    return baseExpr;
+  }
+
+  void SetMemberName(std::string name) {
+    memberName = std::move(name);
+  }
+
+  std::string GetMemberName() const {
+    return memberName.c_str() == nullptr ? "" : memberName.c_str();
+  }
+
+  void SetMemberType(MIRType *type) {
+    memberType = type;
+  }
+
+  void SetBaseType(MIRType *type) {
+    baseType = type;
+  }
+
+  const MIRType *GetMemberType() const {
+    return memberType;
+  }
+
+  const MIRType *GetBaseType() const {
+    return baseType;
+  }
+
+  void SetIsArrow(bool arrow) {
+    isArrow = arrow;
+  }
+
+  bool GetIsArrow() const {
+    return isArrow;
+  }
+
+  void SetFiledOffsetBits(uint64 offset) {
+    fieldOffsetBits = offset;
+  }
+
+  uint64 GetFieldOffsetBits() const {
+    return fieldOffsetBits;
+  }
+
+ private:
+  MIRConst *GenerateMIRConstImpl() const override;
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  const ASTMemberExpr &FindFinalMember(const ASTMemberExpr &startExpr, std::list<std::string> &memberNames) const;
+  void InsertNonnullChecking(std::list<UniqueFEIRStmt> &stmts, UniqueFEIRExpr baseFEExpr) const;
+
+  ASTExpr *baseExpr = nullptr;
+  MapleString memberName;
+  MIRType *memberType = nullptr;
+  MIRType *baseType = nullptr;
+  bool isArrow = false;
+  uint64 fieldOffsetBits = 0;
+};
+
+class ASTDesignatedInitUpdateExpr : public ASTExpr {
+ public:
+  explicit ASTDesignatedInitUpdateExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTASTDesignatedInitUpdateExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTDesignatedInitUpdateExpr() = default;
+
+  void SetBaseExpr(ASTExpr *astExpr) {
+    baseExpr = astExpr;
+  }
+
+  const ASTExpr *GetBaseExpr() const{
+    return baseExpr;
+  }
+
+  void SetUpdaterExpr(ASTExpr *astExpr) {
+    updaterExpr = astExpr;
+  }
+
+  const ASTExpr *GetUpdaterExpr() const{
+    return updaterExpr;
+  }
+
+  void SetInitListType(MIRType *type) {
+    initListType = type;
+  }
+
+  const MIRType *GetInitListType() const {
+    return initListType;
+  }
+
+  void SetInitListVarName(const std::string &name) {
+    initListVarName = name;
+  }
+
+  const std::string &GetInitListVarName() const {
+    return initListVarName;
+  }
+
+ private:
+  MIRConst *GenerateMIRConstImpl() const override;
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  ASTExpr *baseExpr = nullptr;
+  ASTExpr *updaterExpr = nullptr;
+  MIRType *initListType = nullptr;
+  std::string initListVarName;
+};
+
+class ASTAssignExpr : public ASTBinaryOperatorExpr {
+ public:
+  explicit ASTAssignExpr(MapleAllocator &allocatorIn) : ASTBinaryOperatorExpr(allocatorIn, kASTOpAssign),
+      isCompoundAssign(false) {}
+  ~ASTAssignExpr() override = default;
+
+  void SetIsCompoundAssign(bool argIsCompoundAssign) {
+    isCompoundAssign = argIsCompoundAssign;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  void GetActualRightExpr(UniqueFEIRExpr &right, const UniqueFEIRExpr &left) const;
+  bool IsInsertNonnullChecking(const UniqueFEIRExpr &rExpr) const;
+  bool isCompoundAssign = false;
+};
+
+class ASTBOComma : public ASTBinaryOperatorExpr {
+ public:
+  explicit ASTBOComma(MapleAllocator &allocatorIn) : ASTBinaryOperatorExpr(allocatorIn, kASTOpComma) {}
+  ~ASTBOComma() override = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTBOPtrMemExpr : public ASTBinaryOperatorExpr {
+ public:
+  explicit ASTBOPtrMemExpr(MapleAllocator &allocatorIn) : ASTBinaryOperatorExpr(allocatorIn, kASTOpPtrMemD) {}
+  ~ASTBOPtrMemExpr() override = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTCallExpr : public ASTExpr {
+ public:
+  explicit ASTCallExpr(MapleAllocator &allocatorIn)
+      : ASTExpr(kASTOpCall), args(allocatorIn.Adapter()), funcName("", allocatorIn.GetMemPool()),
+        varName(FEUtils::GetSequentialName("retVar_"), allocatorIn.GetMemPool()) {}
+  ~ASTCallExpr() = default;
+  void SetCalleeExpr(ASTExpr *astExpr) {
+    calleeExpr = astExpr;
+  }
+
+  const ASTExpr *GetCalleeExpr() const {
+    return calleeExpr;
+  }
+
+  void SetArgs(MapleVector<ASTExpr*> &argsVector) {
+    args = std::move(argsVector);
+  }
+
+  const MapleVector<ASTExpr*> &GetArgsExpr() const {
+    return args;
+  }
+
+  MIRType *GetRetType() const {
+    return mirType;
+  }
+
+  const std::string GetRetVarName() const {
+    return varName.c_str() == nullptr ? "" : varName.c_str();
+  }
+
+  void SetFuncName(const std::string &name) {
+    funcName = name;
+  }
+
+  const std::string GetFuncName() const {
+    return funcName.c_str() == nullptr ? "" : funcName.c_str();
+  }
+
+  void SetFuncAttrs(const FuncAttrs &attrs) {
+    funcAttrs = attrs;
+  }
+
+  const FuncAttrs &GetFuncAttrs() const {
+    return funcAttrs;
+  }
+
+  void SetIcall(bool icall) {
+    isIcall = icall;
+  }
+
+  bool IsIcall() const {
+    return isIcall;
+  }
+
+  bool IsNeedRetExpr() const {
+    return mirType->GetPrimType() != PTY_void;
+  }
+
+  bool IsFirstArgRet() const {
+    // If the return value exceeds 16 bytes, it is passed as the first parameter.
+    return mirType->GetPrimType() == PTY_agg && mirType->GetSize() > 16;
+  }
+
+  void SetFuncDecl(ASTFunc *decl) {
+    funcDecl = decl;
+  }
+
+  void SetReturnVarAttrs(const GenericAttrs &attrs) {
+    returnVarAttrs = attrs;
+  }
+
+  const GenericAttrs &GetReturnVarAttrs() const {
+    return returnVarAttrs;
+  }
+
+  std::string CvtBuiltInFuncName(std::string builtInName) const;
+  UniqueFEIRExpr ProcessBuiltinFunc(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const;
+  std::unique_ptr<FEIRStmtAssign> GenCallStmt() const;
+  void AddArgsExpr(const std::unique_ptr<FEIRStmtAssign> &callStmt, std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr AddRetExpr(const std::unique_ptr<FEIRStmtAssign> &callStmt) const;
+  void InsertBoundaryCheckingInArgs(std::list<UniqueFEIRStmt> &stmts) const;
+  void InsertBoundaryCheckingInArgsForICall(std::list<UniqueFEIRStmt> &stmts, const UniqueFEIRExpr &calleeFEExpr) const;
+  void InsertBoundaryVarInRet(std::list<UniqueFEIRStmt> &stmts) const;
+  void InsertNonnullCheckingForIcall(const UniqueFEIRExpr &expr, std::list<UniqueFEIRStmt> &stmts) const;
+  void CheckNonnullFieldInStruct() const;
+
+ private:
+  using FuncPtrBuiltinFunc = UniqueFEIRExpr (ASTCallExpr::*)(std::list<UniqueFEIRStmt> &stmts) const;
+  static std::unordered_map<std::string, FuncPtrBuiltinFunc> InitBuiltinFuncPtrMap();
+  UniqueFEIRExpr CreateIntrinsicopForC(std::list<UniqueFEIRStmt> &stmts, MIRIntrinsicID argIntrinsicID,
+                                       bool genTempVar = true) const;
+  UniqueFEIRExpr CreateIntrinsicCallAssignedForC(std::list<UniqueFEIRStmt> &stmts, MIRIntrinsicID argIntrinsicID) const;
+  UniqueFEIRExpr CreateBinaryExpr(std::list<UniqueFEIRStmt> &stmts, Opcode op) const;
+  UniqueFEIRExpr EmitBuiltinFunc(std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr EmitBuiltinVectorLoad(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const;
+  UniqueFEIRExpr EmitBuiltinVectorStore(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const;
+  UniqueFEIRExpr EmitBuiltinVectorShli(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const;
+  UniqueFEIRExpr EmitBuiltinVectorShri(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const;
+  UniqueFEIRExpr EmitBuiltinVectorShru(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const;
+  UniqueFEIRExpr EmitBuiltinVectorZip(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const;
+  UniqueFEIRExpr EmitBuiltinRotate(std::list<UniqueFEIRStmt> &stmts, PrimType rotType, bool isLeft) const;
+#define EMIT_BUILTIIN_FUNC(FUNC) EmitBuiltin##FUNC(std::list<UniqueFEIRStmt> &stmts) const
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Ctz);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Ctzl);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Clz);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Clzl);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Popcount);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Popcountl);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Popcountll);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Parity);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Parityl);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Parityll);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Clrsb);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Clrsbl);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Clrsbll);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Ffs);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Ffsl);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Ffsll);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(IsAligned);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(AlignUp);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(AlignDown);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Alloca);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Expect);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(VaStart);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(VaEnd);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(VaCopy);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Prefetch);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Abs);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(ACos);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(ACosf);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(ASin);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(ASinf);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(ATan);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(ATanf);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Cos);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Cosf);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Cosh);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Coshf);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Sin);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Sinf);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Sinh);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Sinhf);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Exp);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Expf);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Fmax);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Bswap64);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Bswap32);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Bswap16);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Fmin);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Log);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Logf);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Log10);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Log10f);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Isunordered);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Isless);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Islessequal);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Isgreater);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Isgreaterequal);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Islessgreater);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(WarnMemsetZeroLen);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(RotateLeft8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(RotateLeft16);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(RotateLeft32);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(RotateLeft64);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(RotateRight8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(RotateRight16);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(RotateRight32);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(RotateRight64);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncAddAndFetch8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncAddAndFetch4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncAddAndFetch2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncAddAndFetch1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncSubAndFetch8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncSubAndFetch4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncSubAndFetch2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncSubAndFetch1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndSub8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndSub4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndSub2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndSub1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndAdd8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndAdd4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndAdd2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndAdd1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncBoolCompareAndSwap1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncBoolCompareAndSwap2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncBoolCompareAndSwap4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncBoolCompareAndSwap8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncLockTestAndSet8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncLockTestAndSet4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncLockTestAndSet2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncLockTestAndSet1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncValCompareAndSwap8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncValCompareAndSwap4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncValCompareAndSwap2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncValCompareAndSwap1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncLockRelease8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncLockRelease4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncLockRelease2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncLockRelease1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndAnd1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndAnd2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndAnd4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndAnd8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndOr1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndOr2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndOr4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndOr8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndXor1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndXor2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndXor4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndXor8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndNand1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndNand2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndNand4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncFetchAndNand8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncAndAndFetch1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncAndAndFetch2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncAndAndFetch4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncAndAndFetch8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncOrAndFetch1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncOrAndFetch2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncOrAndFetch4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncOrAndFetch8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncXorAndFetch1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncXorAndFetch2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncXorAndFetch4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncXorAndFetch8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncNandAndFetch1);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncNandAndFetch2);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncNandAndFetch4);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncNandAndFetch8);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(SyncSynchronize);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(AtomicExchangeN);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(ObjectSize);
+
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(ReturnAddress);
+  UniqueFEIRExpr EMIT_BUILTIIN_FUNC(ExtractReturnAddr);
+
+// vector builtinfunc
+#define DEF_MIR_INTRINSIC(STR, NAME, INTRN_CLASS, RETURN_TYPE, ...)         \
+UniqueFEIRExpr EmitBuiltin##STR(std::list<UniqueFEIRStmt> &stmts) const;
+#include "intrinsic_vector.def"
+#undef DEF_MIR_INTRINSIC
+
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+
+  static std::unordered_map<std::string, FuncPtrBuiltinFunc> builtingFuncPtrMap;
+  MapleVector<ASTExpr*> args;
+  ASTExpr *calleeExpr = nullptr;
+  MapleString funcName;
+  FuncAttrs funcAttrs;
+  bool isIcall = false;
+  MapleString varName;
+  ASTFunc *funcDecl = nullptr;
+  GenericAttrs returnVarAttrs;
+};
+
+class ASTParenExpr : public ASTExpr {
+ public:
+  explicit ASTParenExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTParen) {
+    (void)allocatorIn;
+  }
+  ~ASTParenExpr() = default;
+
+  void SetASTExpr(ASTExpr *astExpr) {
+    child = astExpr;
+  }
+
+  void SetShortCircuitIdx(uint32 leftIdx, uint32 rightIdx) override {
+    trueIdx = leftIdx;
+    falseIdx = rightIdx;
+  }
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override {
+    return child->GenerateMIRConst();
+  }
+
+  ASTExpr *IgnoreParensImpl() override {
+    return child->IgnoreParens();
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+
+  ASTValue *GetConstantValueImpl() const override {
+    return child->GetConstantValue();
+  }
+
+  ASTExpr *child = nullptr;
+  uint32 trueIdx = 0;
+  uint32 falseIdx = 0;
+};
+
+class ASTIntegerLiteral : public ASTExpr {
+ public:
+  explicit ASTIntegerLiteral(MapleAllocator &allocatorIn) : ASTExpr(kASTIntegerLiteral) {
+    (void)allocatorIn;
+  }
+  ~ASTIntegerLiteral() = default;
+
+  int64 GetVal() const {
+    return val;
+  }
+
+  void SetVal(int64 valIn) {
+    val = valIn;
+  }
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+
+  int64 val = 0;
+};
+
+enum class FloatKind {
+  F32,
+  F64
+};
+
+class ASTFloatingLiteral : public ASTExpr {
+ public:
+  explicit ASTFloatingLiteral(MapleAllocator &allocatorIn) : ASTExpr(kASTFloatingLiteral) {
+    (void)allocatorIn;
+  }
+  ~ASTFloatingLiteral() = default;
+
+  double GetVal() const {
+    return val;
+  }
+
+  void SetVal(double valIn) {
+    val = valIn;
+  }
+
+  void SetKind(FloatKind argKind) {
+    kind = argKind;
+  }
+
+  FloatKind GetKind() const {
+    return kind;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MIRConst *GenerateMIRConstImpl() const override;
+  double val = 0;
+  FloatKind kind = FloatKind::F32;
+};
+
+class ASTCharacterLiteral : public ASTExpr {
+ public:
+  explicit ASTCharacterLiteral(MapleAllocator &allocatorIn) : ASTExpr(kASTCharacterLiteral) {
+    (void)allocatorIn;
+  }
+  ~ASTCharacterLiteral() = default;
+
+  int64 GetVal() const {
+    return val;
+  }
+
+  void SetVal(int64 valIn) {
+    val = valIn;
+  }
+
+  void SetPrimType(PrimType primType) {
+    type = primType;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  int64 val = 0;
+  PrimType type = PTY_begin;
+};
+
+struct VaArgInfo {
+  bool isGPReg;  // GP or FP/SIMD arg reg
+  int regOffset;
+  int stackOffset;
+  // If the argument type is a Composite Type that is larger than 16 bytes,
+  // then the argument is copied to memory allocated by the caller and replaced by a pointer to the copy.
+  bool isCopyedMem;
+  MIRType *HFAType;  // Homogeneous Floating-point Aggregate
+};
+
+class ASTVAArgExpr : public ASTExpr {
+ public:
+  explicit ASTVAArgExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTVAArgExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTVAArgExpr() = default;
+
+  void SetASTExpr(ASTExpr *astExpr) {
+    child = astExpr;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  VaArgInfo ProcessValistArgInfo(const MIRType &type) const;
+  MIRType *IsHFAType(const MIRStructType &type) const;
+  void CvtHFA2Struct(const MIRStructType &type, MIRType &fieldType, const UniqueFEIRVar &vaArgVar,
+                     std::list<UniqueFEIRStmt> &stmts) const;
+  void ProcessBigEndianForReg(std::list<UniqueFEIRStmt> &stmts, MIRType &vaArgType,
+                              const UniqueFEIRVar &offsetVar, const VaArgInfo &info) const;
+  void ProcessBigEndianForStack(std::list<UniqueFEIRStmt> &stmts, MIRType &vaArgType,
+                                const UniqueFEIRVar &vaArgVar) const;
+
+  ASTExpr *child = nullptr;
+};
+
+class ASTConstantExpr : public ASTExpr {
+ public:
+  explicit ASTConstantExpr(MapleAllocator &allocatorIn) : ASTExpr(kConstantExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTConstantExpr() = default;
+  void SetASTExpr(ASTExpr *astExpr) {
+    child = astExpr;
+  }
+
+  const ASTExpr *GetChild() const{
+    return child;
+  }
+
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+
+ private:
+  ASTExpr *child = nullptr;
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTImaginaryLiteral : public ASTExpr {
+ public:
+  explicit ASTImaginaryLiteral(MapleAllocator &allocatorIn) : ASTExpr(kASTImaginaryLiteral) {
+    (void)allocatorIn;
+  }
+  ~ASTImaginaryLiteral() = default;
+  void SetASTExpr(ASTExpr *astExpr) {
+    child = astExpr;
+  }
+
+  void SetComplexType(MIRType *structType) {
+    complexType = structType;
+  }
+
+  void SetElemType(MIRType *type) {
+    elemType = type;
+  }
+
+ private:
+  MIRType *complexType = nullptr;
+  MIRType *elemType = nullptr;
+  ASTExpr *child = nullptr;
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTConditionalOperator : public ASTExpr {
+ public:
+  explicit ASTConditionalOperator(MapleAllocator &allocatorIn) : ASTExpr(kASTConditionalOperator) {
+    (void)allocatorIn;
+  }
+  ~ASTConditionalOperator() = default;
+
+  void SetCondExpr(ASTExpr *astExpr) {
+    condExpr = astExpr;
+  }
+
+  void SetTrueExpr(ASTExpr *astExpr) {
+    trueExpr = astExpr;
+  }
+
+  void SetFalseExpr(ASTExpr *astExpr) {
+    falseExpr = astExpr;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+
+  MIRConst *GenerateMIRConstImpl() const override {
+    MIRConst *condConst = condExpr->GenerateMIRConst();
+    if (condConst->IsZero()) {
+      return falseExpr->GenerateMIRConst();
+    } else {
+      return trueExpr->GenerateMIRConst();
+    }
+  }
+
+  ASTExpr *condExpr = nullptr;
+  ASTExpr *trueExpr = nullptr;
+  ASTExpr *falseExpr = nullptr;
+  std::string varName = FEUtils::GetSequentialName("levVar_");
+};
+
+class ASTArrayInitLoopExpr : public ASTExpr {
+ public:
+  explicit ASTArrayInitLoopExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpArrayInitLoop) {
+    (void)allocatorIn;
+  }
+  ~ASTArrayInitLoopExpr() = default;
+
+  void SetCommonExpr(ASTExpr *expr) {
+    commonExpr = expr;
+  }
+
+  const ASTExpr *GetCommonExpr() const {
+    return commonExpr;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  ASTExpr* commonExpr = nullptr;
+};
+
+class ASTArrayInitIndexExpr : public ASTExpr {
+ public:
+  explicit ASTArrayInitIndexExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpArrayInitLoop) {
+    (void)allocatorIn;
+  }
+  ~ASTArrayInitIndexExpr() = default;
+
+  void SetPrimType(MIRType *pType) {
+    primType = pType;
+  }
+
+  void SetValueStr(const std::string &val) {
+    valueStr = val;
+  }
+
+  const MIRType *GetPrimeType() const {
+    return primType;
+  }
+
+  std::string GetValueStr() const {
+    return valueStr;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MIRType *primType = nullptr;
+  std::string valueStr;
+};
+
+class ASTExprWithCleanups : public ASTExpr {
+ public:
+  explicit ASTExprWithCleanups(MapleAllocator &allocatorIn) : ASTExpr(kASTOpExprWithCleanups) {
+    (void)allocatorIn;
+  }
+  ~ASTExprWithCleanups() = default;
+
+  void SetSubExpr(ASTExpr *sub) {
+    subExpr = sub;
+  }
+
+  const ASTExpr *GetSubExpr() const {
+    return subExpr;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  ASTExpr *subExpr = nullptr;
+};
+
+class ASTMaterializeTemporaryExpr : public ASTExpr {
+ public:
+  explicit ASTMaterializeTemporaryExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpMaterializeTemporary) {
+    (void)allocatorIn;
+  }
+  ~ASTMaterializeTemporaryExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTSubstNonTypeTemplateParmExpr : public ASTExpr {
+ public:
+  explicit ASTSubstNonTypeTemplateParmExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpSubstNonTypeTemplateParm) {
+    (void)allocatorIn;
+  }
+  ~ASTSubstNonTypeTemplateParmExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTDependentScopeDeclRefExpr : public ASTExpr {
+ public:
+  explicit ASTDependentScopeDeclRefExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpDependentScopeDeclRef) {
+    (void)allocatorIn;
+  }
+  ~ASTDependentScopeDeclRefExpr() = default;
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+};
+
+class ASTAtomicExpr : public ASTExpr {
+ public:
+  explicit ASTAtomicExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpAtomic) {
+    (void)allocatorIn;
+  }
+  ~ASTAtomicExpr() = default;
+
+  void SetRefType(MIRType *ref) {
+    refType = ref;
+  }
+
+  void SetAtomicOp(ASTAtomicOp op) {
+    atomicOp = op;
+  }
+
+  const MIRType *GetRefType() const {
+    return refType;
+  }
+
+  ASTAtomicOp GetAtomicOp() const {
+    return atomicOp;
+  }
+
+  void SetValExpr1(ASTExpr *val) {
+    valExpr1 = val;
+  }
+
+  void SetValExpr2(ASTExpr *val) {
+    valExpr2 = val;
+  }
+
+  void SetObjExpr(ASTExpr *obj) {
+    objExpr = obj;
+  }
+
+  void SetOrderExpr(ASTExpr *order) {
+    orderExpr = order;
+  }
+
+  const ASTExpr *GetValExpr1() const {
+    return valExpr1;
+  }
+
+  const ASTExpr *GetValExpr2() const {
+    return valExpr2;
+  }
+
+  const ASTExpr *GetObjExpr() const {
+    return objExpr;
+  }
+
+  const ASTExpr *GetOrderExpr() const {
+    return orderExpr;
+  }
+
+  void SetVal1Type(MIRType *ty) {
+    val1Type = ty;
+  }
+
+  void SetVal2Type(MIRType *ty) {
+    val2Type = ty;
+  }
+
+  void SetFromStmt(bool fromStmt) {
+    isFromStmt = fromStmt;
+  }
+
+  bool IsFromStmt() const {
+    return isFromStmt;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  MIRType *refType = nullptr;
+  MIRType *val1Type = nullptr;
+  MIRType *val2Type = nullptr;
+  ASTExpr *objExpr = nullptr;
+  ASTExpr *valExpr1 = nullptr;
+  ASTExpr *valExpr2 = nullptr;
+  ASTExpr *orderExpr = nullptr;
+  ASTAtomicOp atomicOp = kAtomicOpUndefined;
+  bool isFromStmt = false;
+};
+
+class ASTExprStmtExpr : public ASTExpr {
+ public:
+  explicit ASTExprStmtExpr(MapleAllocator &allocatorIn) : ASTExpr(kASTOpStmtExpr) {
+    (void)allocatorIn;
+  }
+  ~ASTExprStmtExpr() = default;
+  void SetCompoundStmt(ASTStmt *sub) {
+    cpdStmt = sub;
+  }
+
+  const ASTStmt *GetSubExpr() const {
+    return cpdStmt;
+  }
+
+ private:
+  UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+
+  ASTStmt *cpdStmt = nullptr;
+};
+}
+#endif // HIR2MPL_AST_INPUT_INCLUDE_AST_EXPR_H
diff --git a/src/hir2mpl/ast_input/clang/include/ast_function.h b/src/hir2mpl/ast_input/clang/include/ast_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..814c3c34a212947db099de9191eacbc47466a029
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/include/ast_function.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_AST_INPUT_AST_FUNTION_H
+#define MPL_FE_AST_INPUT_AST_FUNTION_H
+#include "fe_function.h"
+#include "ast_struct2fe_helper.h"
+
+namespace maple {
+class ASTFunction : public FEFunction {
+ public:
+  ASTFunction(const ASTFunc2FEHelper &argMethodHelper, MIRFunction &mirFunc,
+              const std::unique_ptr<FEFunctionPhaseResult> &argPhaseResultTotal);
+  virtual ~ASTFunction() = default;
+
+ protected:
+  bool GenerateGeneralStmt(const std::string &phaseName) override {
+    WARN(kLncWarn, "Phase: %s may not need.", phaseName.c_str());
+    return true;
+  }
+
+  bool GenerateArgVarList(const std::string &phaseName) override;
+  bool GenerateAliasVars(const std::string &phaseName) override;
+
+  bool PreProcessTypeNameIdx() override {
+    return true;
+  }
+
+  void GenerateGeneralStmtFailCallBack() override {}
+
+  void GenerateGeneralDebugInfo() override {}
+
+  bool VerifyGeneral() override {
+    return true;
+  }
+
+  void VerifyGeneralFailCallBack() override {}
+
+  bool HasThis() override {
+    return funcHelper.HasThis();
+  }
+
+  bool IsNative() override {
+    return funcHelper.IsNative();
+  }
+
+  bool EmitToFEIRStmt(const std::string &phaseName) override;
+
+  void PreProcessImpl() override;
+  bool ProcessImpl() override;
+  bool ProcessFEIRFunction() override;
+  void FinishImpl() override;
+  bool EmitToMIR(const std::string &phaseName) override;
+  void SetMIRFunctionInfo();
+  void AddVLACleanupStmts(std::list<UniqueFEIRStmt> &stmts) override;
+
+  const ASTFunc2FEHelper &funcHelper;
+  ASTFunc &astFunc;
+  std::list<UniqueFEIRStmt> vlaCleanupStmts;
+  bool error = false;
+};
+}  // namespace maple
+#endif  // MPL_FE_AST_INPUT_AST_FUNTION_H
\ No newline at end of file
diff --git a/src/hir2mpl/ast_input/clang/include/ast_op.h b/src/hir2mpl/ast_input/clang/include/ast_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1f8802e8aae2d2aa71398e33509e905f8cd676c
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/include/ast_op.h
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_INPUT_INCLUDE_AST_OP_H
+#define HIR2MPL_AST_INPUT_INCLUDE_AST_OP_H
+namespace maple {
+enum ASTOp {
+  kASTOpNone = 0,
+  kASTStringLiteral,
+  kASTSubscriptExpr,
+  kASTExprUnaryExprOrTypeTraitExpr,
+  kASTMemberExpr,
+  kASTASTDesignatedInitUpdateExpr,
+  kASTImplicitValueInitExpr,
+  kASTOpRef,
+
+  // unaryopcode
+  kASTOpMinus,
+  kASTOpNot,
+  kASTOpLNot,
+  kASTOpPostInc,
+  kASTOpPostDec,
+  kASTOpPreInc,
+  kASTOpPreDec,
+  kASTOpAddrOf,
+  kASTOpAddrOfLabel,
+  kASTOpDeref,
+  kASTOpPlus,
+  kASTOpReal,
+  kASTOpImag,
+  kASTOpExtension,
+  kASTOpCoawait,
+
+  // BinaryOperators
+  // [C++ 5.5] Pointer-to-member operators.
+  kASTOpBO,
+  kASTOpCompoundAssign,
+  kASTOpPtrMemD,
+  kASTOpPtrMemI,
+  // [C99 6.5.5] Multiplicative operators.
+  kASTOpMul,
+  kASTOpDiv,
+  kASTOpRem,
+  // [C99 6.5.6] Additive operators.
+  kASTOpAdd,
+  kASTOpSub,
+  // [C99 6.5.7] Bitwise shift operators.
+  kASTOpShl,
+  kASTOpShr,
+  // [C99 6.5.8] Relational operators.
+  kASTOpLT,
+  kASTOpGT,
+  kASTOpLE,
+  kASTOpGE,
+  // [C99 6.5.9] Equality operators.
+  kASTOpEQ,
+  kASTOpNE,
+  // [C99 6.5.10] Bitwise AND operator.
+  kASTOpAnd,
+  // [C99 6.5.11] Bitwise XOR operator.
+  kASTOpXor,
+  // [C99 6.5.12] Bitwise OR operator.
+  kASTOpOr,
+  // [C99 6.5.13] Logical AND operator.
+  kASTOpLAnd,
+  // [C99 6.5.14] Logical OR operator.
+  kASTOpLOr,
+  // [C99 6.5.16] Assignment operators.
+  kASTOpAssign,
+  kASTOpMulAssign,
+  kASTOpDivAssign,
+  kASTOpRemAssign,
+  kASTOpAddAssign,
+  kASTOpSubAssign,
+  kASTOpShlAssign,
+  kASTOpShrAssign,
+  kASTOpAndAssign,
+  kASTOpXorAssign,
+  kASTOpOrAssign,
+  // [C99 6.5.17] Comma operator.
+  kASTOpComma,
+  // cast
+  kASTOpCast,
+
+  // call
+  kASTOpCall,
+
+  kASTParen,
+  kASTIntegerLiteral,
+  kASTFloatingLiteral,
+  kASTCharacterLiteral,
+  kASTConditionalOperator,
+  kConstantExpr,
+  kASTImaginaryLiteral,
+  kASTCallExpr,
+  kCpdAssignOp,
+  kASTVAArgExpr,
+
+  // others
+  kASTOpPredefined,
+  kASTOpOpaqueValue,
+  kASTOpBinaryConditionalOperator,
+  kASTOpNoInitExpr,
+  kASTOpCompoundLiteralExpr,
+  kASTOpOffsetOfExpr,
+  kASTOpGenericSelectionExpr,
+  kASTOpInitListExpr,
+  kASTOpArrayInitLoop,
+  kASTOpArrayInitIndex,
+  kASTOpExprWithCleanups,
+  kASTOpMaterializeTemporary,
+  kASTOpSubstNonTypeTemplateParm,
+  kASTOpDependentScopeDeclRef,
+  kASTOpAtomic,
+  kASTOpStmtExpr,
+};
+
+enum ASTStmtOp {
+  kASTStmtNone,
+  kASTStmtDummy,
+  // branch
+  kASTStmtIf,
+  kASTStmtGoto,
+  kASTStmtIndirectGoto,
+
+  kASTStmtLabel,
+  kASTStmtAddrOfLabelExpr,
+
+  kASTStmtDo,
+  kASTStmtFor,
+  kASTStmtWhile,
+  kASTStmtBreak,
+  kASTStmtContinue,
+
+  kASTStmtReturn,
+  kASTStmtBO,
+  kASTStmtBOAssign,
+  kASTStmtBOCompoundAssign,
+  kASTStmtUO,
+  kASTStmtCompound,
+  kASTStmtSwitch,
+  kASTStmtCase,
+  kASTStmtDefault,
+  kASTStmtNull,
+  kASTStmtDecl,
+  kASTStmtCAO,
+  kASTStmtImplicitCastExpr,
+  kASTStmtParenExpr,
+  kASTStmtIntegerLiteral,
+  kASTStmtFloatingLiteral,
+  kASTStmtVAArgExpr,
+  kASTStmtConditionalOperator,
+  kASTStmtCharacterLiteral,
+  kASTStmtStmtExpr,
+  kASTStmtCStyleCastExpr,
+  kASTStmtCallExpr,
+  kASTStmtAtomicExpr,
+  kASTStmtGCCAsmStmt,
+  kASTOffsetOfStmt,
+  kASTGenericSelectionExprStmt,
+  kASTStmtAttributed,
+  kASTStmtDeclRefExpr,
+  kASTStmtUnaryExprOrTypeTraitExpr,
+};
+}  // namespace maple
+#endif  // HIR2MPL_AST_INPUT_INCLUDE_AST_OP_H
diff --git a/src/hir2mpl/ast_input/clang/include/ast_parser.h b/src/hir2mpl/ast_input/clang/include/ast_parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff4ae96a72d1625880d71903667bdf59cc2b0d83
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/include/ast_parser.h
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_INPUT_INCLUDE_AST_PARSER_H
+#define HIR2MPL_AST_INPUT_INCLUDE_AST_PARSER_H
+#include <string>
+#include <functional>
+#include "mempool_allocator.h"
+#include "ast_decl.h"
+#include "ast_interface.h"
+
+namespace maple {
+class ASTParser {
+ public:
+  ASTParser(MapleAllocator &allocatorIn, uint32 fileIdxIn, const std::string &fileNameIn,
+            MapleList<ASTStruct*> &astStructsIn, MapleList<ASTFunc*> &astFuncsIn, MapleList<ASTVar*> &astVarsIn,
+            MapleList<ASTFileScopeAsm*> &astFileScopeAsmsIn, MapleList<ASTEnumDecl*> &astEnumsIn)
+      : fileIdx(fileIdxIn), fileName(fileNameIn, allocatorIn.GetMemPool()), globalVarDecles(allocatorIn.Adapter()),
+        funcDecles(allocatorIn.Adapter()), recordDecles(allocatorIn.Adapter()),
+        globalEnumDecles(allocatorIn.Adapter()), globalTypeDefDecles(allocatorIn.Adapter()),
+        globalFileScopeAsm(allocatorIn.Adapter()), astStructs(astStructsIn), astFuncs(astFuncsIn),
+        astVars(astVarsIn), astFileScopeAsms(astFileScopeAsmsIn), astEnums(astEnumsIn),
+        vlaSizeMap(allocatorIn.Adapter()) {}
+  virtual ~ASTParser() = default;
+  bool OpenFile(MapleAllocator &allocator);
+  bool Release() const;
+
+  bool Verify() const;
+  bool PreProcessAST();
+
+  bool RetrieveStructs(MapleAllocator &allocator);
+  bool RetrieveFuncs(MapleAllocator &allocator);
+  bool RetrieveGlobalVars(MapleAllocator &allocator);
+  bool RetrieveFileScopeAsms(MapleAllocator &allocator);
+  bool RetrieveGlobalTypeDef(MapleAllocator &allocator);
+  bool RetrieveEnums(MapleAllocator &allocator);
+
+  const std::string GetSourceFileName() const;
+  const uint32 GetFileIdx() const;
+
+  // ProcessStmt
+  ASTStmt *ProcessStmt(MapleAllocator &allocator, const clang::Stmt &stmt);
+  ASTStmt *ProcessFunctionBody(MapleAllocator &allocator, const clang::CompoundStmt &compoundStmt);
+#define PROCESS_STMT(CLASS) ProcessStmt##CLASS(MapleAllocator&, const clang::CLASS&)
+  ASTStmt *PROCESS_STMT(AttributedStmt);
+  ASTStmt *PROCESS_STMT(UnaryOperator);
+  ASTStmt *PROCESS_STMT(BinaryOperator);
+  ASTStmt *PROCESS_STMT(CompoundAssignOperator);
+  ASTStmt *PROCESS_STMT(ImplicitCastExpr);
+  ASTStmt *PROCESS_STMT(ParenExpr);
+  ASTStmt *PROCESS_STMT(IntegerLiteral);
+  ASTStmt *PROCESS_STMT(FloatingLiteral);
+  ASTStmt *PROCESS_STMT(VAArgExpr);
+  ASTStmt *PROCESS_STMT(ConditionalOperator);
+  ASTStmt *PROCESS_STMT(CharacterLiteral);
+  ASTStmt *PROCESS_STMT(StmtExpr);
+  ASTStmt *PROCESS_STMT(CallExpr);
+  ASTStmt *PROCESS_STMT(ReturnStmt);
+  ASTStmt *PROCESS_STMT(IfStmt);
+  ASTStmt *PROCESS_STMT(ForStmt);
+  ASTStmt *PROCESS_STMT(WhileStmt);
+  ASTStmt *PROCESS_STMT(DoStmt);
+  ASTStmt *PROCESS_STMT(BreakStmt);
+  ASTStmt *PROCESS_STMT(LabelStmt);
+  ASTStmt *PROCESS_STMT(ContinueStmt);
+  ASTStmt *PROCESS_STMT(CompoundStmt);
+  ASTStmt *PROCESS_STMT(GotoStmt);
+  ASTStmt *PROCESS_STMT(IndirectGotoStmt);
+  ASTStmt *PROCESS_STMT(SwitchStmt);
+  ASTStmt *PROCESS_STMT(CaseStmt);
+  ASTStmt *PROCESS_STMT(DefaultStmt);
+  ASTStmt *PROCESS_STMT(NullStmt);
+  ASTStmt *PROCESS_STMT(CStyleCastExpr);
+  ASTStmt *PROCESS_STMT(DeclStmt);
+  ASTStmt *PROCESS_STMT(AtomicExpr);
+  ASTStmt *PROCESS_STMT(GCCAsmStmt);
+  ASTStmt *PROCESS_STMT(OffsetOfExpr);
+  ASTStmt *PROCESS_STMT(GenericSelectionExpr);
+  ASTStmt *PROCESS_STMT(DeclRefExpr);
+  ASTStmt *PROCESS_STMT(UnaryExprOrTypeTraitExpr);
+  ASTStmt *PROCESS_STMT(AddrLabelExpr);
+  bool HasDefault(const clang::Stmt &stmt);
+
+  // ProcessExpr
+  const clang::Expr *PeelParen(const clang::Expr &expr) const;
+  const clang::Expr *PeelParen2(const clang::Expr &expr) const;
+  ASTUnaryOperatorExpr *AllocUnaryOperatorExpr(MapleAllocator &allocator, const clang::UnaryOperator &expr) const;
+  ASTValue *AllocASTValue(const MapleAllocator &allocator) const;
+  ASTValue *TranslateExprEval(MapleAllocator &allocator, const clang::Expr *expr) const;
+  ASTExpr *EvaluateExprAsConst(MapleAllocator &allocator, const clang::Expr *expr);
+  bool HasLabelStmt(const clang::Stmt *expr);
+  ASTExpr *ProcessExpr(MapleAllocator &allocator, const clang::Expr *expr);
+  void SaveVLASizeExpr(MapleAllocator &allocator, const clang::QualType &qualType, std::list<ASTExpr*> &vlaSizeExprs);
+  ASTBinaryOperatorExpr *AllocBinaryOperatorExpr(MapleAllocator &allocator, const clang::BinaryOperator &bo) const;
+  ASTExpr *ProcessExprCastExpr(MapleAllocator &allocator, const clang::CastExpr &expr);
+  ASTExpr *SolvePointerOffsetOperation(MapleAllocator &allocator, const clang::BinaryOperator &bo,
+                                       ASTBinaryOperatorExpr &astBinOpExpr, ASTExpr &astRExpr, ASTExpr &astLExpr);
+  ASTExpr *SolvePointerSubPointerOperation(MapleAllocator &allocator, const clang::BinaryOperator &bo,
+                                           ASTBinaryOperatorExpr &astBinOpExpr) const;
+#define PROCESS_EXPR(CLASS) ProcessExpr##CLASS(MapleAllocator&, const clang::CLASS&)
+  ASTExpr *PROCESS_EXPR(UnaryOperator);
+  ASTExpr *PROCESS_EXPR(AddrLabelExpr);
+  ASTExpr *PROCESS_EXPR(NoInitExpr);
+  ASTExpr *PROCESS_EXPR(PredefinedExpr);
+  ASTExpr *PROCESS_EXPR(OpaqueValueExpr);
+  ASTExpr *PROCESS_EXPR(BinaryConditionalOperator);
+  ASTExpr *PROCESS_EXPR(CompoundLiteralExpr);
+  ASTExpr *PROCESS_EXPR(OffsetOfExpr);
+  ASTExpr *PROCESS_EXPR(InitListExpr);
+  ASTExpr *PROCESS_EXPR(BinaryOperator);
+  ASTExpr *PROCESS_EXPR(ImplicitValueInitExpr);
+  ASTExpr *PROCESS_EXPR(StringLiteral);
+  ASTExpr *PROCESS_EXPR(ArraySubscriptExpr);
+  ASTExpr *PROCESS_EXPR(UnaryExprOrTypeTraitExpr);
+  ASTExpr *PROCESS_EXPR(MemberExpr);
+  ASTExpr *PROCESS_EXPR(DesignatedInitUpdateExpr);
+  ASTExpr *PROCESS_EXPR(ImplicitCastExpr);
+  ASTExpr *PROCESS_EXPR(DeclRefExpr);
+  ASTExpr *PROCESS_EXPR(ParenExpr);
+  ASTExpr *PROCESS_EXPR(IntegerLiteral);
+  ASTExpr *PROCESS_EXPR(FloatingLiteral);
+  ASTExpr *PROCESS_EXPR(CharacterLiteral);
+  ASTExpr *PROCESS_EXPR(ConditionalOperator);
+  ASTExpr *PROCESS_EXPR(VAArgExpr);
+  ASTExpr *PROCESS_EXPR(GNUNullExpr);
+  ASTExpr *PROCESS_EXPR(SizeOfPackExpr);
+  ASTExpr *PROCESS_EXPR(UserDefinedLiteral);
+  ASTExpr *PROCESS_EXPR(ShuffleVectorExpr);
+  ASTExpr *PROCESS_EXPR(TypeTraitExpr);
+  ASTExpr *PROCESS_EXPR(ConstantExpr);
+  ASTExpr *PROCESS_EXPR(ImaginaryLiteral);
+  ASTExpr *PROCESS_EXPR(CallExpr);
+  ASTExpr *PROCESS_EXPR(CompoundAssignOperator);
+  ASTExpr *PROCESS_EXPR(StmtExpr);
+  ASTExpr *PROCESS_EXPR(CStyleCastExpr);
+  ASTExpr *PROCESS_EXPR(ArrayInitLoopExpr);
+  ASTExpr *PROCESS_EXPR(ArrayInitIndexExpr);
+  ASTExpr *PROCESS_EXPR(ExprWithCleanups);
+  ASTExpr *PROCESS_EXPR(MaterializeTemporaryExpr);
+  ASTExpr *PROCESS_EXPR(SubstNonTypeTemplateParmExpr);
+  ASTExpr *PROCESS_EXPR(DependentScopeDeclRefExpr);
+  ASTExpr *PROCESS_EXPR(AtomicExpr);
+  ASTExpr *PROCESS_EXPR(ChooseExpr);
+  ASTExpr *PROCESS_EXPR(GenericSelectionExpr);
+
+  MapleVector<ASTDecl*> SolveFuncParameterDecls(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                                MapleVector<MIRType*> &typeDescIn, std::list<ASTStmt*> &stmts);
+  GenericAttrs SolveFunctionAttributes(const clang::FunctionDecl &funcDecl, std::string &funcName) const;
+  ASTDecl *ProcessDecl(MapleAllocator &allocator, const clang::Decl &decl);
+  ASTStmt *SolveFunctionBody(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl, ASTFunc &astFunc,
+                             const std::list<ASTStmt*> &stmts);
+
+  void SetInitExprForASTVar(MapleAllocator &allocator, const clang::VarDecl &varDecl, const GenericAttrs &attrs,
+                            ASTVar &astVar);
+  void SetAlignmentForASTVar(const clang::VarDecl &varDecl, ASTVar &astVar) const;
+#define PROCESS_DECL(CLASS) ProcessDecl##CLASS##Decl(MapleAllocator &allocator, const clang::CLASS##Decl&)
+  ASTDecl *PROCESS_DECL(Field);
+  ASTDecl *PROCESS_DECL(Function);
+  ASTDecl *PROCESS_DECL(Record);
+  ASTDecl *PROCESS_DECL(Var);
+  ASTDecl *PROCESS_DECL(ParmVar);
+  ASTDecl *PROCESS_DECL(Enum);
+  ASTDecl *PROCESS_DECL(Typedef);
+  ASTDecl *PROCESS_DECL(EnumConstant);
+  ASTDecl *PROCESS_DECL(FileScopeAsm);
+  ASTDecl *PROCESS_DECL(Label);
+  ASTDecl *PROCESS_DECL(StaticAssert);
+
+  static ASTExpr *GetAddrShiftExpr(MapleAllocator &allocator, ASTExpr &expr, uint32 typeSize);
+  static ASTExpr *GetSizeMulExpr(MapleAllocator &allocator, ASTExpr &expr, ASTExpr &ptrSizeExpr);
+
+ private:
+  void ProcessNonnullFuncAttrs(const clang::FunctionDecl &funcDecl, ASTFunc &astFunc) const;
+  void ProcessNonnullFuncPtrAttrs(MapleAllocator &allocator, const clang::ValueDecl &valueDecl, ASTDecl &astVar);
+  void ProcessBoundaryFuncAttrs(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl, ASTFunc &astFunc);
+  void ProcessByteBoundaryFuncAttrs(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl, ASTFunc &astFunc);
+  void ProcessBoundaryFuncAttrsByIndex(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                       ASTFunc &astFunc);
+  void ProcessBoundaryParamAttrs(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl, ASTFunc &astFunc);
+  void ProcessBoundaryParamAttrsByIndex(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                        ASTFunc &astFunc);
+  void ProcessBoundaryVarAttrs(MapleAllocator &allocator, const clang::VarDecl &varDecl, ASTVar &astVar);
+  void ProcessBoundaryFieldAttrs(MapleAllocator &allocator, const ASTStruct &structDecl,
+                                 const clang::RecordDecl &recDecl);
+  void ProcessBoundaryFuncPtrAttrs(MapleAllocator &allocator, const clang::ValueDecl &valueDecl, ASTDecl &astDecl);
+  template <typename T>
+  bool ProcessBoundaryFuncPtrAttrsForParams(T *attr, MapleAllocator &allocator, const MIRFuncType &funcType,
+                                            const clang::FunctionProtoType &proto, std::vector<TypeAttrs> &attrsVec);
+  template <typename T>
+  bool ProcessBoundaryFuncPtrAttrsForRet(T *attr, MapleAllocator &allocator, const MIRFuncType &funcType,
+                                         const clang::FunctionType &clangFuncType, TypeAttrs &retAttr);
+  void ProcessBoundaryFuncPtrAttrsByIndex(MapleAllocator &allocator, const clang::ValueDecl &valueDecl,
+                                          ASTDecl &astDecl, const MIRFuncType &funcType);
+  template <typename T>
+  bool ProcessBoundaryFuncPtrAttrsByIndexForParams(T *attr, ASTDecl &astDecl, const MIRFuncType &funcType,
+                                                   std::vector<TypeAttrs> &attrsVec) const;
+  void ProcessBoundaryLenExpr(MapleAllocator &allocator, ASTDecl &ptrDecl, const clang::QualType &qualType,
+                              const std::function<ASTExpr* ()> &getLenExprFromStringLiteral,
+                              ASTExpr *lenExpr, bool isSize);
+  void ProcessBoundaryLenExprInFunc(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                    unsigned int idx, ASTFunc &astFunc, ASTExpr *lenExpr, bool isSize);
+  void ProcessBoundaryLenExprInFunc(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                    unsigned int idx, ASTFunc &astFunc, unsigned int lenIdx, bool isSize);
+  void ProcessBoundaryLenExprInVar(MapleAllocator &allocator, ASTDecl &ptrDecl, const clang::VarDecl &varDecl,
+                                   ASTExpr *lenExpr, bool isSize);
+  void ProcessBoundaryLenExprInVar(MapleAllocator &allocator, ASTDecl &ptrDecl, const clang::QualType &qualType,
+                                   ASTExpr *lenExpr, bool isSize);
+  void ProcessBoundaryLenExprInField(MapleAllocator &allocator, ASTDecl &ptrDecl, const ASTStruct &structDecl,
+                                     const clang::QualType &qualType, ASTExpr *lenExpr, bool isSize);
+  ASTValue *TranslateConstantValue2ASTValue(MapleAllocator &allocator, const clang::Expr *expr) const;
+  ASTValue *TranslateLValue2ASTValue(MapleAllocator &allocator,
+      const clang::Expr::EvalResult &result, const clang::Expr *expr) const;
+  void TraverseDecl(const clang::Decl *decl, std::function<void (clang::Decl*)> const &functor) const;
+  ASTDecl *GetAstDeclOfDeclRefExpr(MapleAllocator &allocator, const clang::Expr &expr);
+  uint32 GetSizeFromQualType(const clang::QualType qualType) const;
+  ASTExpr *GetTypeSizeFromQualType(MapleAllocator &allocator, const clang::QualType qualType);
+  uint32_t GetAlignOfType(const clang::QualType currQualType, clang::UnaryExprOrTypeTrait exprKind) const;
+  uint32_t GetAlignOfExpr(const clang::Expr &expr, clang::UnaryExprOrTypeTrait exprKind) const;
+  ASTExpr *BuildExprToComputeSizeFromVLA(MapleAllocator &allocator, const clang::QualType &qualType);
+  ASTExpr *ProcessExprBinaryOperatorComplex(MapleAllocator &allocator, const clang::BinaryOperator &bo);
+
+using FuncPtrBuiltinFunc = ASTExpr *(ASTParser::*)(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                                   std::stringstream &ss) const;
+static std::map<std::string, FuncPtrBuiltinFunc> InitBuiltinFuncPtrMap();
+ASTExpr *ProcessBuiltinFuncByName(MapleAllocator &allocator, const clang::CallExpr &expr, std::stringstream &ss,
+                                  const std::string &name) const;
+ASTExpr *ParseBuiltinFunc(MapleAllocator &allocator, const clang::CallExpr &expr, std::stringstream &ss) const;
+#define PARSE_BUILTIIN_FUNC(FUNC) ParseBuiltin##FUNC(MapleAllocator &allocator, const clang::CallExpr &expr, \
+                                                     std::stringstream &ss) const
+  ASTExpr *PARSE_BUILTIIN_FUNC(ClassifyType);
+  ASTExpr *PARSE_BUILTIIN_FUNC(ConstantP);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Isinfsign);
+  ASTExpr *PARSE_BUILTIIN_FUNC(HugeVal);
+  ASTExpr *PARSE_BUILTIIN_FUNC(HugeValf);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Inf);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Inff);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Nan);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Nanf);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Signbit);
+  ASTExpr *PARSE_BUILTIIN_FUNC(SignBitf);
+  ASTExpr *PARSE_BUILTIIN_FUNC(SignBitl);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Trap);
+  ASTExpr *PARSE_BUILTIIN_FUNC(IsUnordered);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Copysignf);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Copysign);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Copysignl);
+  ASTExpr *PARSE_BUILTIIN_FUNC(Objectsize);
+
+  static std::map<std::string, FuncPtrBuiltinFunc> builtingFuncPtrMap;
+  uint32 fileIdx;
+  const MapleString fileName;
+  LibAstFile *astFile = nullptr;
+  const AstUnitDecl *astUnitDecl = nullptr;
+  MapleList<clang::Decl*> globalVarDecles;
+  MapleList<clang::Decl*> funcDecles;
+  MapleList<clang::Decl*> recordDecles;
+  MapleList<clang::Decl*> globalEnumDecles;
+  MapleList<clang::Decl*> globalTypeDefDecles;
+  MapleList<clang::Decl*> globalFileScopeAsm;
+
+  MapleList<ASTStruct*> &astStructs;
+  MapleList<ASTFunc*> &astFuncs;
+  MapleList<ASTVar*> &astVars;
+  MapleList<ASTFileScopeAsm*> &astFileScopeAsms;
+  MapleList<ASTEnumDecl*> &astEnums;
+  MapleMap<clang::Expr*, ASTExpr*> vlaSizeMap;
+};
+}  // namespace maple
+#endif // HIR2MPL_AST_INPUT_INCLUDE_AST_PARSER_H
diff --git a/src/hir2mpl/ast_input/clang/include/ast_stmt.h b/src/hir2mpl/ast_input/clang/include/ast_stmt.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea910bbba7be8e3dcde4855e07d0330c52900ca0
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/include/ast_stmt.h
@@ -0,0 +1,713 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_INPUT_INCLUDE_AST_STMT_H
+#define HIR2MPL_AST_INPUT_INCLUDE_AST_STMT_H
+#include "ast_op.h"
+#include "ast_expr.h"
+#include "feir_stmt.h"
+
+namespace maple {
+class ASTDecl;
+
+enum class SafeSS {
+  kNoneSS,
+  kSafeSS,
+  kUnsafeSS,
+};
+
+class ASTStmt {
+ public:
+  explicit ASTStmt(MapleAllocator &allocatorIn, ASTStmtOp o = kASTStmtNone) : exprs(allocatorIn.Adapter()), op(o) {}
+  virtual ~ASTStmt() = default;
+  void SetASTExpr(ASTExpr* astExpr);
+
+  std::list<UniqueFEIRStmt> Emit2FEStmt() const {
+    auto stmts = Emit2FEStmtImpl();
+    for (UniqueFEIRStmt &stmt : stmts) {
+      if (stmt != nullptr && !stmt->HasSetLOCInfo()) {
+        stmt->SetSrcLoc(loc);
+      }
+    }
+    return stmts;
+  }
+
+  ASTStmtOp GetASTStmtOp() const {
+    return op;
+  }
+
+  const MapleVector<ASTExpr*> &GetExprs() const {
+    return exprs;
+  }
+
+  void SetSrcLoc(const Loc &l) {
+    loc = l;
+  }
+
+  const Loc &GetSrcLoc() const {
+    return loc;
+  }
+
+  uint32 GetSrcFileIdx() const {
+    return loc.fileIdx;
+  }
+
+  uint32 GetSrcFileLineNum() const {
+    return loc.line;
+  }
+
+ protected:
+  virtual std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const = 0;
+  MapleVector<ASTExpr*> exprs;
+  ASTStmtOp op;
+  Loc loc = {0, 0, 0};
+};
+
+class ASTStmtDummy : public ASTStmt {
+ public:
+  explicit ASTStmtDummy(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtDummy) {}
+  ~ASTStmtDummy() = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTCompoundStmt : public ASTStmt {
+ public:
+  explicit ASTCompoundStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtCompound),
+      astStmts(allocatorIn.Adapter()) {}
+  ~ASTCompoundStmt() = default;
+  void SetASTStmt(ASTStmt *astStmt);
+  void InsertASTStmtsAtFront(const std::list<ASTStmt*> &stmts);
+  const MapleList<ASTStmt*> &GetASTStmtList() const;
+
+  void SetSafeSS(SafeSS state) {
+    safeSS = state;
+  }
+
+  SafeSS GetSafeSS() const {
+    return safeSS;
+  }
+
+  void SetEndLoc(const Loc &loc) {
+    endLoc = loc;
+  }
+
+  const Loc &GetEndLoc() const {
+    return endLoc;
+  }
+
+ private:
+  SafeSS safeSS = SafeSS::kNoneSS;
+  MapleList<ASTStmt*> astStmts; // stmts
+  Loc endLoc = {0, 0, 0};
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  mutable bool hasEmitted2MIRScope = false;
+};
+
+// Any other expressions or stmts should be extended here
+class ASTReturnStmt : public ASTStmt {
+ public:
+  explicit ASTReturnStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtReturn) {}
+  ~ASTReturnStmt() = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTAttributedStmt : public ASTStmt {
+ public:
+  explicit ASTAttributedStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtAttributed) {}
+  ~ASTAttributedStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override{ return {}; };
+};
+
+class ASTIfStmt : public ASTStmt {
+ public:
+  explicit ASTIfStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtIf) {}
+  ~ASTIfStmt() override = default;
+
+  void SetCondExpr(ASTExpr *astExpr) {
+    condExpr = astExpr;
+  }
+
+  void SetThenStmt(ASTStmt *astStmt) {
+    thenStmt = astStmt;
+  }
+
+  void SetElseStmt(ASTStmt *astStmt) {
+    elseStmt = astStmt;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  ASTExpr *condExpr = nullptr;
+  ASTStmt *thenStmt = nullptr;
+  ASTStmt *elseStmt = nullptr;
+};
+
+class ASTForStmt : public ASTStmt {
+ public:
+  explicit ASTForStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtFor) {}
+  ~ASTForStmt() override = default;
+
+  void SetInitStmt(ASTStmt *astStmt) {
+    initStmt = astStmt;
+  }
+
+  void SetCondExpr(ASTExpr *astExpr) {
+    condExpr = astExpr;
+  }
+
+  void SetIncExpr(ASTExpr *astExpr) {
+    incExpr = astExpr;
+  }
+
+  void SetBodyStmt(ASTStmt *astStmt) {
+    bodyStmt = astStmt;
+  }
+
+  void SetEndLoc(const Loc &loc) {
+    endLoc = loc;
+  }
+
+  const Loc &GetEndLoc() const {
+    return endLoc;
+  }
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  ASTStmt *initStmt = nullptr;
+  ASTExpr *condExpr = nullptr;
+  ASTExpr *incExpr = nullptr;
+  ASTStmt *bodyStmt = nullptr;
+  Loc endLoc = {0, 0, 0};
+  mutable bool hasEmitted2MIRScope = false;
+};
+
+class ASTWhileStmt : public ASTStmt {
+ public:
+  explicit ASTWhileStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtWhile) {}
+  ~ASTWhileStmt() override = default;
+
+  void SetCondExpr(ASTExpr *astExpr) {
+    condExpr = astExpr;
+  }
+
+  void SetBodyStmt(ASTStmt *astStmt) {
+    bodyStmt = astStmt;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  ASTExpr *condExpr = nullptr;
+  ASTStmt *bodyStmt = nullptr;
+  mutable bool hasEmitted2MIRScope = false;
+};
+
+class ASTDoStmt : public ASTStmt {
+ public:
+  explicit ASTDoStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtDo) {}
+  ~ASTDoStmt() override = default;
+
+  void SetBodyStmt(ASTStmt *astStmt) {
+    bodyStmt = astStmt;
+  }
+
+  void SetCondExpr(ASTExpr *astExpr) {
+    condExpr = astExpr;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  ASTStmt *bodyStmt = nullptr;
+  ASTExpr *condExpr = nullptr;
+  mutable bool hasEmitted2MIRScope = false;
+};
+
+class ASTBreakStmt : public ASTStmt {
+ public:
+  explicit ASTBreakStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtBreak) {}
+  ~ASTBreakStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTLabelStmt : public ASTStmt {
+ public:
+  explicit ASTLabelStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtLabel),
+      labelName("", allocatorIn.GetMemPool()) {}
+  ~ASTLabelStmt() override = default;
+
+  void SetSubStmt(ASTStmt *stmt) {
+    subStmt = stmt;
+  }
+
+  const ASTStmt* GetSubStmt() const {
+    return subStmt;
+  }
+
+  void SetLabelName(const std::string &name) {
+    labelName = name;
+  }
+
+  const std::string GetLabelName() const {
+    return labelName.c_str() == nullptr ? "" : labelName.c_str();
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  MapleString labelName;
+  ASTStmt *subStmt = nullptr;
+};
+
+class ASTContinueStmt : public ASTStmt {
+ public:
+  explicit ASTContinueStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtContinue) {}
+  ~ASTContinueStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTUnaryOperatorStmt : public ASTStmt {
+ public:
+  explicit ASTUnaryOperatorStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtUO) {}
+  ~ASTUnaryOperatorStmt() = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTBinaryOperatorStmt : public ASTStmt {
+ public:
+  explicit ASTBinaryOperatorStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtBO) {}
+  ~ASTBinaryOperatorStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTGotoStmt : public ASTStmt {
+ public:
+  explicit ASTGotoStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtGoto),
+      labelName("", allocatorIn.GetMemPool()) {}
+  ~ASTGotoStmt() = default;
+
+  std::string GetLabelName() const {
+    return labelName.c_str() == nullptr ? "" : labelName.c_str();
+  }
+
+  void SetLabelName(const std::string &name) {
+    labelName = name;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  MapleString labelName;
+};
+
+class ASTIndirectGotoStmt : public ASTStmt {
+ public:
+  explicit ASTIndirectGotoStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtIndirectGoto) {}
+  ~ASTIndirectGotoStmt() = default;
+
+ protected:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTSwitchStmt : public ASTStmt {
+ public:
+  explicit ASTSwitchStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtSwitch) {}
+  ~ASTSwitchStmt() = default;
+
+  void SetCondStmt(ASTStmt *cond) {
+    condStmt = cond;
+  }
+
+  void SetBodyStmt(ASTStmt *body) {
+    bodyStmt = body;
+  }
+
+  void SetCondExpr(ASTExpr *cond) {
+    condExpr = cond;
+  }
+
+  const ASTStmt *GetCondStmt() const {
+    return condStmt;
+  }
+
+  const ASTExpr *GetCondExpr() const {
+    return condExpr;
+  }
+
+  const ASTStmt *GetBodyStmt() const {
+    return bodyStmt;
+  }
+
+  void SetHasDefault(bool argHasDefault) {
+    hasDefualt = argHasDefault;
+  }
+
+  bool HasDefault() const {
+    return hasDefualt;
+  }
+
+  void SetCondType(MIRType *type) {
+    condType = type;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  ASTStmt *condStmt = nullptr;
+  ASTExpr *condExpr = nullptr;
+  ASTStmt *bodyStmt = nullptr;
+  MIRType *condType = nullptr;
+  bool hasDefualt = false;
+  mutable bool hasEmitted2MIRScope = false;
+};
+
+class ASTCaseStmt : public ASTStmt {
+ public:
+  explicit ASTCaseStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtCase) {}
+  ~ASTCaseStmt() = default;
+
+  void SetLHS(ASTExpr *l) {
+    lhs = l;
+  }
+
+  void SetRHS(ASTExpr *r) {
+    rhs = r;
+  }
+
+  void SetSubStmt(ASTStmt *sub) {
+    subStmt = sub;
+  }
+
+  const ASTExpr *GetLHS() const {
+    return lhs;
+  }
+
+  const ASTExpr *GetRHS() const {
+    return rhs;
+  }
+
+  const ASTStmt *GetSubStmt() const {
+    return subStmt;
+  }
+
+  int64 GetLCaseTag() const {
+    return lCaseTag;
+  }
+
+  int64 GetRCaseTag() const {
+    return rCaseTag;
+  }
+
+  void SetLCaseTag(int64 l) {
+    lCaseTag = l;
+  }
+
+  void SetRCaseTag(int64 r) {
+    rCaseTag = r;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  ASTExpr *lhs = nullptr;
+  ASTExpr *rhs = nullptr;
+  ASTStmt *subStmt = nullptr;
+  int64 lCaseTag = 0;
+  int64 rCaseTag = 0;
+};
+
+class ASTDefaultStmt : public ASTStmt {
+ public:
+  explicit ASTDefaultStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtDefault) {}
+  ~ASTDefaultStmt() = default;
+
+  void SetChildStmt(ASTStmt* ch) {
+    child = ch;
+  }
+
+  const ASTStmt* GetChildStmt() const {
+    return child;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  ASTStmt* child = nullptr;
+};
+
+class ASTNullStmt : public ASTStmt {
+ public:
+  explicit ASTNullStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtNull) {}
+  ~ASTNullStmt() = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTDeclStmt : public ASTStmt {
+ public:
+  explicit ASTDeclStmt(MapleAllocator &allocatorIn)
+      : ASTStmt(allocatorIn, kASTStmtDecl),
+        subDecls(allocatorIn.Adapter()),
+        subDeclInfos(allocatorIn.Adapter()) {}
+  ~ASTDeclStmt() = default;
+
+  void SetSubDecl(ASTDecl *decl) {
+    subDecls.emplace_back(decl);
+    (void)subDeclInfos.emplace_back(decl);
+  }
+
+  void SetVLASizeExpr(ASTExpr *astExpr) {
+    (void)subDeclInfos.emplace_back(astExpr);
+  }
+
+  const MapleList<ASTDecl*> &GetSubDecls() const {
+    return subDecls;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+
+  MapleList<ASTDecl*> subDecls;
+  // saved vla size exprs before a vla decl
+  MapleList<std::variant<ASTDecl*, ASTExpr*>> subDeclInfos;
+};
+
+class ASTCompoundAssignOperatorStmt : public ASTStmt {
+ public:
+  explicit ASTCompoundAssignOperatorStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtCAO) {}
+  ~ASTCompoundAssignOperatorStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTImplicitCastExprStmt : public ASTStmt {
+ public:
+  explicit ASTImplicitCastExprStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtImplicitCastExpr) {}
+  ~ASTImplicitCastExprStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTParenExprStmt : public ASTStmt {
+ public:
+  explicit ASTParenExprStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtParenExpr) {}
+  ~ASTParenExprStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTIntegerLiteralStmt : public ASTStmt {
+ public:
+  explicit ASTIntegerLiteralStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtIntegerLiteral) {}
+  ~ASTIntegerLiteralStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTFloatingLiteralStmt : public ASTStmt {
+ public:
+  explicit ASTFloatingLiteralStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtFloatingLiteral) {}
+  ~ASTFloatingLiteralStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTVAArgExprStmt : public ASTStmt {
+ public:
+  explicit ASTVAArgExprStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtVAArgExpr) {}
+  ~ASTVAArgExprStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTConditionalOperatorStmt : public ASTStmt {
+ public:
+  explicit ASTConditionalOperatorStmt(MapleAllocator &allocatorIn)
+      : ASTStmt(allocatorIn, kASTStmtConditionalOperator) {}
+  ~ASTConditionalOperatorStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTCharacterLiteralStmt : public ASTStmt {
+ public:
+  explicit ASTCharacterLiteralStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtCharacterLiteral) {}
+  ~ASTCharacterLiteralStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTStmtExprStmt : public ASTStmt {
+ public:
+  explicit ASTStmtExprStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtStmtExpr) {}
+  ~ASTStmtExprStmt() override = default;
+
+  void SetBodyStmt(ASTStmt *stmt) {
+    cpdStmt = stmt;
+  }
+
+  const ASTStmt *GetBodyStmt() const {
+    return cpdStmt;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+
+  ASTStmt *cpdStmt = nullptr;
+};
+
+class ASTCStyleCastExprStmt : public ASTStmt {
+ public:
+  explicit ASTCStyleCastExprStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtCStyleCastExpr) {}
+  ~ASTCStyleCastExprStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTCallExprStmt : public ASTStmt {
+ public:
+  ASTCallExprStmt(MapleAllocator &allocatorIn, const std::string &varNameIn)
+      : ASTStmt(allocatorIn, kASTStmtCallExpr), varName(varNameIn) {}
+  ~ASTCallExprStmt() override = default;
+
+ private:
+  using FuncPtrBuiltinFunc = std::list<UniqueFEIRStmt> (ASTCallExprStmt::*)() const;
+  static std::map<std::string, FuncPtrBuiltinFunc> InitFuncPtrMap();
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+
+  std::string varName;
+};
+
+class ASTAtomicExprStmt : public ASTStmt {
+ public:
+  explicit ASTAtomicExprStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtAtomicExpr) {}
+  ~ASTAtomicExprStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTGCCAsmStmt : public ASTStmt {
+ public:
+  explicit ASTGCCAsmStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtGCCAsmStmt),
+      asmStr("", allocatorIn.GetMemPool()), outputs(allocatorIn.Adapter()), inputs(allocatorIn.Adapter()),
+      clobbers(allocatorIn.Adapter()), labels(allocatorIn.Adapter()) {}
+  ~ASTGCCAsmStmt() override = default;
+
+  void SetAsmStr(const std::string &str) {
+    asmStr = str;
+  }
+
+  const std::string GetAsmStr() const {
+    return asmStr.c_str() == nullptr ? "" : asmStr.c_str();
+  }
+
+  void InsertOutput(std::tuple<std::string, std::string, bool> &&output) {
+    outputs.emplace_back(output);
+  }
+
+  void InsertInput(std::pair<std::string, std::string> &&input) {
+    inputs.emplace_back(input);
+  }
+
+  void InsertClobber(std::string &&clobber) {
+    clobbers.emplace_back(clobber);
+  }
+
+  void InsertLabel(const std::string &label) {
+    labels.emplace_back(label);
+  }
+
+  void SetIsGoto(bool flag) {
+    isGoto = flag;
+  }
+
+  void SetIsVolatile(bool flag) {
+    isVolatile = flag;
+  }
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  MapleString asmStr;
+  MapleVector<std::tuple<std::string, std::string, bool>> outputs;
+  MapleVector<std::pair<std::string, std::string>> inputs;
+  MapleVector<std::string> clobbers;
+  MapleVector<std::string> labels;
+  bool isGoto = false;
+  bool isVolatile = false;
+};
+
+class ASTOffsetOfStmt : public ASTStmt {
+ public:
+  explicit ASTOffsetOfStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTOffsetOfStmt) {}
+  ~ASTOffsetOfStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTGenericSelectionExprStmt : public ASTStmt {
+ public:
+  explicit ASTGenericSelectionExprStmt(MapleAllocator &allocatorIn)
+      : ASTStmt(allocatorIn, kASTGenericSelectionExprStmt) {}
+  ~ASTGenericSelectionExprStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTDeclRefExprStmt : public ASTStmt {
+ public:
+  explicit ASTDeclRefExprStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtDeclRefExpr) {}
+  ~ASTDeclRefExprStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTUnaryExprOrTypeTraitExprStmt : public ASTStmt {
+ public:
+  explicit ASTUnaryExprOrTypeTraitExprStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtDeclRefExpr) {}
+  ~ASTUnaryExprOrTypeTraitExprStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+
+class ASTUOAddrOfLabelExprStmt : public ASTStmt {
+ public:
+  explicit ASTUOAddrOfLabelExprStmt(MapleAllocator &allocatorIn) : ASTStmt(allocatorIn, kASTStmtAddrOfLabelExpr) {}
+  ~ASTUOAddrOfLabelExprStmt() override = default;
+
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+};
+}  // namespace maple
+#endif // HIR2MPL_AST_INPUT_INCLUDE_AST_STMT_H
diff --git a/src/hir2mpl/ast_input/clang/include/ast_struct2fe_helper.h b/src/hir2mpl/ast_input/clang/include/ast_struct2fe_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..3879607e44882f576f68a004eeb99765fb685e61
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/include/ast_struct2fe_helper.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_INPUT_INCLUDE_AST_STRUCT2FE_HELPER_H
+#define HIR2MPL_AST_INPUT_INCLUDE_AST_STRUCT2FE_HELPER_H
+#include "fe_input_helper.h"
+#include "ast_decl.h"
+#include "mempool_allocator.h"
+
+namespace maple {
+class ASTStruct2FEHelper : public FEInputStructHelper {
+ public:
+  ASTStruct2FEHelper(MapleAllocator &allocator, ASTStruct &structIn);
+  ~ASTStruct2FEHelper() = default;
+
+  const ASTStruct &GetASTStruct() const {
+    return astStruct;
+  }
+
+ protected:
+  bool ProcessDeclImpl() override;
+  void InitFieldHelpersImpl() override;
+  void InitMethodHelpersImpl() override;
+  TypeAttrs GetStructAttributeFromInputImpl() const override;
+  std::string GetStructNameOrinImpl() const override;
+  std::string GetStructNameMplImpl() const override;
+  std::list<std::string> GetSuperClassNamesImpl() const override;
+  std::vector<std::string> GetInterfaceNamesImpl() const override;
+  std::string GetSourceFileNameImpl() const override;
+  MIRStructType *CreateMIRStructTypeImpl(bool &error) const override;
+  uint64 GetRawAccessFlagsImpl() const override;
+  GStrIdx GetIRSrcFileSigIdxImpl() const override;
+  bool IsMultiDefImpl() const override;
+  std::string GetSrcFileNameImpl() const override;
+
+  ASTStruct &astStruct;
+};
+
+class ASTGlobalVar2FEHelper : public FEInputGlobalVarHelper {
+ public:
+  ASTGlobalVar2FEHelper(MapleAllocator &allocatorIn, const ASTVar &varIn)
+      : FEInputGlobalVarHelper(allocatorIn),
+        astVar(varIn) {}
+  ~ASTGlobalVar2FEHelper() = default;
+
+ protected:
+  bool ProcessDeclImpl(MapleAllocator &allocator) override;
+  const ASTVar &astVar;
+};
+
+class ASTFileScopeAsm2FEHelper : public FEInputFileScopeAsmHelper {
+ public:
+  ASTFileScopeAsm2FEHelper(MapleAllocator &allocatorIn, const ASTFileScopeAsm &astAsmIn)
+      : FEInputFileScopeAsmHelper(allocatorIn),
+        astAsm(astAsmIn) {}
+  ~ASTFileScopeAsm2FEHelper() = default;
+
+ protected:
+  bool ProcessDeclImpl(MapleAllocator &allocator) override;
+  const ASTFileScopeAsm &astAsm;
+};
+
+class ASTEnum2FEHelper : public FEInputEnumHelper {
+ public:
+  ASTEnum2FEHelper(MapleAllocator &allocatorIn, const ASTEnumDecl &astEnumIn)
+      : FEInputEnumHelper(allocatorIn),
+        astEnum(astEnumIn) {}
+  ~ASTEnum2FEHelper() = default;
+
+ protected:
+  bool ProcessDeclImpl(MapleAllocator &allocator) override;
+  const ASTEnumDecl &astEnum;
+};
+
+class ASTStructField2FEHelper : public FEInputFieldHelper {
+ public:
+  ASTStructField2FEHelper(MapleAllocator &allocator, ASTField &fieldIn, MIRType &structTypeIn)
+      : FEInputFieldHelper(allocator),
+        field(fieldIn), structType(structTypeIn) {}
+  ~ASTStructField2FEHelper() = default;
+
+ protected:
+  bool ProcessDeclImpl(MapleAllocator &allocator) override;
+  bool ProcessDeclWithContainerImpl(MapleAllocator &allocator) override;
+  ASTField &field;
+  MIRType &structType;
+};
+
+class ASTFunc2FEHelper : public FEInputMethodHelper {
+ public:
+  ASTFunc2FEHelper(MapleAllocator &allocator, ASTFunc &funcIn)
+      : FEInputMethodHelper(allocator),
+        func(funcIn) {
+    srcLang = kSrcLangC;
+  }
+  ~ASTFunc2FEHelper() = default;
+  ASTFunc &GetMethod() const {
+    return func;
+  }
+
+  const std::string GetSrcFileName() const;
+
+ protected:
+  bool ProcessDeclImpl(MapleAllocator &allocator) override;
+  void SolveReturnAndArgTypesImpl(MapleAllocator &allocator) override;
+  std::string GetMethodNameImpl(bool inMpl, bool full) const override;
+  bool IsVargImpl() const override;
+  bool HasThisImpl() const override;
+  MIRType *GetTypeForThisImpl() const override;
+  FuncAttrs GetAttrsImpl() const override;
+  bool IsStaticImpl() const override;
+  bool IsVirtualImpl() const override;
+  bool IsNativeImpl() const override;
+  bool HasCodeImpl() const override;
+
+  void SolveFunctionArguments() const;
+  void SolveFunctionAttributes();
+  ASTFunc &func;
+  bool firstArgRet = false;
+};
+}  // namespace maple
+#endif // HIR2MPL_AST_INPUT_INCLUDE_AST_STRUCT2FE_HELPER_H
diff --git a/src/hir2mpl/ast_input/clang/include/builtin_func_emit.def b/src/hir2mpl/ast_input/clang/include/builtin_func_emit.def
new file mode 100644
index 0000000000000000000000000000000000000000..cbf2a41f2c88906bafe44a2067789c72c9b28009
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/include/builtin_func_emit.def
@@ -0,0 +1,186 @@
+BUILTIN_FUNC_EMIT("alloca", &ASTCallExpr::EmitBuiltinAlloca)
+BUILTIN_FUNC_EMIT("__builtin_ctz", &ASTCallExpr::EmitBuiltinCtz)
+BUILTIN_FUNC_EMIT("__builtin_ctzl", &ASTCallExpr::EmitBuiltinCtzl)
+BUILTIN_FUNC_EMIT("__builtin_ctzll", &ASTCallExpr::EmitBuiltinCtzl)
+BUILTIN_FUNC_EMIT("__builtin_clz", &ASTCallExpr::EmitBuiltinClz)
+BUILTIN_FUNC_EMIT("__builtin_clzl", &ASTCallExpr::EmitBuiltinClzl)
+BUILTIN_FUNC_EMIT("__builtin_clzll", &ASTCallExpr::EmitBuiltinClzl)
+BUILTIN_FUNC_EMIT("__builtin_popcount", &ASTCallExpr::EmitBuiltinPopcount)
+BUILTIN_FUNC_EMIT("__builtin_popcountl", &ASTCallExpr::EmitBuiltinPopcountl)
+BUILTIN_FUNC_EMIT("__builtin_popcountll", &ASTCallExpr::EmitBuiltinPopcountll)
+BUILTIN_FUNC_EMIT("__builtin_parity", &ASTCallExpr::EmitBuiltinParity)
+BUILTIN_FUNC_EMIT("__builtin_parityl", &ASTCallExpr::EmitBuiltinParityl)
+BUILTIN_FUNC_EMIT("__builtin_parityll", &ASTCallExpr::EmitBuiltinParityll)
+BUILTIN_FUNC_EMIT("__builtin_clrsb", &ASTCallExpr::EmitBuiltinClrsb)
+BUILTIN_FUNC_EMIT("__builtin_clrsbl", &ASTCallExpr::EmitBuiltinClrsbl)
+BUILTIN_FUNC_EMIT("__builtin_clrsbll", &ASTCallExpr::EmitBuiltinClrsbll)
+BUILTIN_FUNC_EMIT("__builtin_ffs", &ASTCallExpr::EmitBuiltinFfs)
+BUILTIN_FUNC_EMIT("__builtin_ffsl", &ASTCallExpr::EmitBuiltinFfsl)
+BUILTIN_FUNC_EMIT("__builtin_ffsll", &ASTCallExpr::EmitBuiltinFfsll)
+BUILTIN_FUNC_EMIT("__builtin_is_aligned", &ASTCallExpr::EmitBuiltinIsAligned)
+BUILTIN_FUNC_EMIT("__builtin_align_up", &ASTCallExpr::EmitBuiltinAlignUp)
+BUILTIN_FUNC_EMIT("__builtin_align_down", &ASTCallExpr::EmitBuiltinAlignDown)
+BUILTIN_FUNC_EMIT("__builtin_alloca", &ASTCallExpr::EmitBuiltinAlloca)
+BUILTIN_FUNC_EMIT("__builtin_expect", &ASTCallExpr::EmitBuiltinExpect)
+BUILTIN_FUNC_EMIT("__builtin_va_start", &ASTCallExpr::EmitBuiltinVaStart)
+BUILTIN_FUNC_EMIT("__builtin_va_end", &ASTCallExpr::EmitBuiltinVaEnd)
+BUILTIN_FUNC_EMIT("__builtin_va_copy", &ASTCallExpr::EmitBuiltinVaCopy)
+BUILTIN_FUNC_EMIT("__builtin_prefetch", &ASTCallExpr::EmitBuiltinPrefetch)
+BUILTIN_FUNC_EMIT("__builtin_abs", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("__builtin_fabs", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("__builtin_fabsf", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("__builtin_fabsl", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("__builtin_fabsf16", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("__builtin_fabsf128", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("__builtin_labs", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("__builtin_llabs", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("abs", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("labs", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("llabs", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("fabs", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("fabsf", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("fabsl", &ASTCallExpr::EmitBuiltinAbs)
+BUILTIN_FUNC_EMIT("__builtin_acos", &ASTCallExpr::EmitBuiltinACos)
+BUILTIN_FUNC_EMIT("acos", &ASTCallExpr::EmitBuiltinACos)
+BUILTIN_FUNC_EMIT("__builtin_acosf", &ASTCallExpr::EmitBuiltinACosf)
+BUILTIN_FUNC_EMIT("acosf", &ASTCallExpr::EmitBuiltinACosf)
+BUILTIN_FUNC_EMIT("__builtin_asin", &ASTCallExpr::EmitBuiltinASin)
+BUILTIN_FUNC_EMIT("asin", &ASTCallExpr::EmitBuiltinASin)
+BUILTIN_FUNC_EMIT("__builtin_asinf", &ASTCallExpr::EmitBuiltinASinf)
+BUILTIN_FUNC_EMIT("asinf", &ASTCallExpr::EmitBuiltinASinf)
+BUILTIN_FUNC_EMIT("__builtin_atan", &ASTCallExpr::EmitBuiltinATan)
+BUILTIN_FUNC_EMIT("atan", &ASTCallExpr::EmitBuiltinATan)
+BUILTIN_FUNC_EMIT("__builtin_atanf", &ASTCallExpr::EmitBuiltinATanf)
+BUILTIN_FUNC_EMIT("atanf", &ASTCallExpr::EmitBuiltinATanf)
+BUILTIN_FUNC_EMIT("__builtin_cos", &ASTCallExpr::EmitBuiltinCos)
+BUILTIN_FUNC_EMIT("cos", &ASTCallExpr::EmitBuiltinCos)
+BUILTIN_FUNC_EMIT("__builtin_cosf", &ASTCallExpr::EmitBuiltinCosf)
+BUILTIN_FUNC_EMIT("cosf", &ASTCallExpr::EmitBuiltinCosf)
+BUILTIN_FUNC_EMIT("__builtin_cosh", &ASTCallExpr::EmitBuiltinCosh)
+BUILTIN_FUNC_EMIT("cosh", &ASTCallExpr::EmitBuiltinCosh)
+BUILTIN_FUNC_EMIT("__builtin_coshf", &ASTCallExpr::EmitBuiltinCoshf)
+BUILTIN_FUNC_EMIT("coshf", &ASTCallExpr::EmitBuiltinCoshf)
+BUILTIN_FUNC_EMIT("__builtin_sin", &ASTCallExpr::EmitBuiltinSin)
+BUILTIN_FUNC_EMIT("sin", &ASTCallExpr::EmitBuiltinSin)
+BUILTIN_FUNC_EMIT("__builtin_sinf", &ASTCallExpr::EmitBuiltinSinf)
+BUILTIN_FUNC_EMIT("sinf", &ASTCallExpr::EmitBuiltinSinf)
+BUILTIN_FUNC_EMIT("__builtin_sinh", &ASTCallExpr::EmitBuiltinSinh)
+BUILTIN_FUNC_EMIT("sinh", &ASTCallExpr::EmitBuiltinSinh)
+BUILTIN_FUNC_EMIT("__builtin_sinhf", &ASTCallExpr::EmitBuiltinSinhf)
+BUILTIN_FUNC_EMIT("sinhf", &ASTCallExpr::EmitBuiltinSinhf)
+BUILTIN_FUNC_EMIT("__builtin_exp", &ASTCallExpr::EmitBuiltinExp)
+BUILTIN_FUNC_EMIT("exp", &ASTCallExpr::EmitBuiltinExp)
+BUILTIN_FUNC_EMIT("__builtin_expf", &ASTCallExpr::EmitBuiltinExpf)
+BUILTIN_FUNC_EMIT("expf", &ASTCallExpr::EmitBuiltinExpf)
+BUILTIN_FUNC_EMIT("__builtin_fmax", &ASTCallExpr::EmitBuiltinFmax)
+BUILTIN_FUNC_EMIT("__builtin_fmaxf", &ASTCallExpr::EmitBuiltinFmax)
+BUILTIN_FUNC_EMIT("__builtin_fmaxf16", &ASTCallExpr::EmitBuiltinFmax)
+BUILTIN_FUNC_EMIT("__builtin_fmaxl", &ASTCallExpr::EmitBuiltinFmax)
+BUILTIN_FUNC_EMIT("fmax", &ASTCallExpr::EmitBuiltinFmax)
+BUILTIN_FUNC_EMIT("fmaxf", &ASTCallExpr::EmitBuiltinFmax)
+BUILTIN_FUNC_EMIT("fmaxl", &ASTCallExpr::EmitBuiltinFmax)
+BUILTIN_FUNC_EMIT("__builtin_fmin", &ASTCallExpr::EmitBuiltinFmin)
+BUILTIN_FUNC_EMIT("__builtin_fminf", &ASTCallExpr::EmitBuiltinFmin)
+BUILTIN_FUNC_EMIT("__builtin_fmin16", &ASTCallExpr::EmitBuiltinFmin)
+BUILTIN_FUNC_EMIT("__builtin_fminl", &ASTCallExpr::EmitBuiltinFmin)
+BUILTIN_FUNC_EMIT("fmin", &ASTCallExpr::EmitBuiltinFmin)
+BUILTIN_FUNC_EMIT("fminf", &ASTCallExpr::EmitBuiltinFmin)
+BUILTIN_FUNC_EMIT("fminl", &ASTCallExpr::EmitBuiltinFmin)
+BUILTIN_FUNC_EMIT("__builtin_log", &ASTCallExpr::EmitBuiltinLog)
+BUILTIN_FUNC_EMIT("__builtin_logf", &ASTCallExpr::EmitBuiltinLogf)
+BUILTIN_FUNC_EMIT("__builtin_log10", &ASTCallExpr::EmitBuiltinLog10)
+BUILTIN_FUNC_EMIT("__builtin_log10f", &ASTCallExpr::EmitBuiltinLog10f)
+BUILTIN_FUNC_EMIT("__builtin_isunordered", &ASTCallExpr::EmitBuiltinIsunordered)
+BUILTIN_FUNC_EMIT("__builtin_isless", &ASTCallExpr::EmitBuiltinIsless)
+BUILTIN_FUNC_EMIT("__builtin_islessequal", &ASTCallExpr::EmitBuiltinIslessequal)
+BUILTIN_FUNC_EMIT("__builtin_isgreater", &ASTCallExpr::EmitBuiltinIsgreater)
+BUILTIN_FUNC_EMIT("__builtin_isgreaterequal", &ASTCallExpr::EmitBuiltinIsgreaterequal)
+BUILTIN_FUNC_EMIT("__builtin_islessgreater", &ASTCallExpr::EmitBuiltinIslessgreater)
+BUILTIN_FUNC_EMIT("__warn_memset_zero_len", &ASTCallExpr::EmitBuiltinWarnMemsetZeroLen)
+BUILTIN_FUNC_EMIT("__builtin_rotateleft8", &ASTCallExpr::EmitBuiltinRotateLeft8)
+BUILTIN_FUNC_EMIT("__builtin_rotateleft16", &ASTCallExpr::EmitBuiltinRotateLeft16)
+BUILTIN_FUNC_EMIT("__builtin_rotateleft32", &ASTCallExpr::EmitBuiltinRotateLeft32)
+BUILTIN_FUNC_EMIT("__builtin_rotateleft64", &ASTCallExpr::EmitBuiltinRotateLeft64)
+BUILTIN_FUNC_EMIT("__builtin_rotateright8", &ASTCallExpr::EmitBuiltinRotateRight8)
+BUILTIN_FUNC_EMIT("__builtin_rotateright16", &ASTCallExpr::EmitBuiltinRotateRight16)
+BUILTIN_FUNC_EMIT("__builtin_rotateright32", &ASTCallExpr::EmitBuiltinRotateRight32)
+BUILTIN_FUNC_EMIT("__builtin_rotateright64", &ASTCallExpr::EmitBuiltinRotateRight64)
+
+BUILTIN_FUNC_EMIT("__sync_add_and_fetch_8", &ASTCallExpr::EmitBuiltinSyncAddAndFetch8)
+BUILTIN_FUNC_EMIT("__sync_add_and_fetch_4", &ASTCallExpr::EmitBuiltinSyncAddAndFetch4)
+BUILTIN_FUNC_EMIT("__sync_add_and_fetch_2", &ASTCallExpr::EmitBuiltinSyncAddAndFetch2)
+BUILTIN_FUNC_EMIT("__sync_add_and_fetch_1", &ASTCallExpr::EmitBuiltinSyncAddAndFetch1)
+BUILTIN_FUNC_EMIT("__sync_sub_and_fetch_8", &ASTCallExpr::EmitBuiltinSyncSubAndFetch8)
+BUILTIN_FUNC_EMIT("__sync_sub_and_fetch_4", &ASTCallExpr::EmitBuiltinSyncSubAndFetch4)
+BUILTIN_FUNC_EMIT("__sync_sub_and_fetch_2", &ASTCallExpr::EmitBuiltinSyncSubAndFetch2)
+BUILTIN_FUNC_EMIT("__sync_sub_and_fetch_1", &ASTCallExpr::EmitBuiltinSyncSubAndFetch1)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_sub_8", &ASTCallExpr::EmitBuiltinSyncFetchAndSub8)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_sub_4", &ASTCallExpr::EmitBuiltinSyncFetchAndSub4)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_sub_2", &ASTCallExpr::EmitBuiltinSyncFetchAndSub2)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_sub_1", &ASTCallExpr::EmitBuiltinSyncFetchAndSub1)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_add_8", &ASTCallExpr::EmitBuiltinSyncFetchAndAdd8)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_add_4", &ASTCallExpr::EmitBuiltinSyncFetchAndAdd4)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_add_2", &ASTCallExpr::EmitBuiltinSyncFetchAndAdd2)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_add_1", &ASTCallExpr::EmitBuiltinSyncFetchAndAdd1)
+BUILTIN_FUNC_EMIT("__sync_bool_compare_and_swap_8", &ASTCallExpr::EmitBuiltinSyncBoolCompareAndSwap8)
+BUILTIN_FUNC_EMIT("__sync_bool_compare_and_swap_4", &ASTCallExpr::EmitBuiltinSyncBoolCompareAndSwap4)
+BUILTIN_FUNC_EMIT("__sync_bool_compare_and_swap_2", &ASTCallExpr::EmitBuiltinSyncBoolCompareAndSwap2)
+BUILTIN_FUNC_EMIT("__sync_bool_compare_and_swap_1", &ASTCallExpr::EmitBuiltinSyncBoolCompareAndSwap1)
+BUILTIN_FUNC_EMIT("__sync_val_compare_and_swap_8", &ASTCallExpr::EmitBuiltinSyncValCompareAndSwap8)
+BUILTIN_FUNC_EMIT("__sync_val_compare_and_swap_4", &ASTCallExpr::EmitBuiltinSyncValCompareAndSwap4)
+BUILTIN_FUNC_EMIT("__sync_val_compare_and_swap_2", &ASTCallExpr::EmitBuiltinSyncValCompareAndSwap2)
+BUILTIN_FUNC_EMIT("__sync_val_compare_and_swap_1", &ASTCallExpr::EmitBuiltinSyncValCompareAndSwap1)
+BUILTIN_FUNC_EMIT("__sync_lock_test_and_set_8", &ASTCallExpr::EmitBuiltinSyncLockTestAndSet8)
+BUILTIN_FUNC_EMIT("__sync_lock_test_and_set_4", &ASTCallExpr::EmitBuiltinSyncLockTestAndSet4)
+BUILTIN_FUNC_EMIT("__sync_lock_test_and_set_2", &ASTCallExpr::EmitBuiltinSyncLockTestAndSet2)
+BUILTIN_FUNC_EMIT("__sync_lock_test_and_set_1", &ASTCallExpr::EmitBuiltinSyncLockTestAndSet1)
+BUILTIN_FUNC_EMIT("__sync_lock_release_8", &ASTCallExpr::EmitBuiltinSyncLockRelease8)
+BUILTIN_FUNC_EMIT("__sync_lock_release_4", &ASTCallExpr::EmitBuiltinSyncLockRelease4)
+BUILTIN_FUNC_EMIT("__sync_lock_release_2", &ASTCallExpr::EmitBuiltinSyncLockRelease2)
+BUILTIN_FUNC_EMIT("__sync_lock_release_1", &ASTCallExpr::EmitBuiltinSyncLockRelease1)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_and_1", &ASTCallExpr::EmitBuiltinSyncFetchAndAnd1)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_and_2", &ASTCallExpr::EmitBuiltinSyncFetchAndAnd2)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_and_4", &ASTCallExpr::EmitBuiltinSyncFetchAndAnd4)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_and_8", &ASTCallExpr::EmitBuiltinSyncFetchAndAnd8)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_or_1", &ASTCallExpr::EmitBuiltinSyncFetchAndOr1)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_or_2", &ASTCallExpr::EmitBuiltinSyncFetchAndOr2)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_or_4", &ASTCallExpr::EmitBuiltinSyncFetchAndOr4)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_or_8", &ASTCallExpr::EmitBuiltinSyncFetchAndOr8)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_xor_1", &ASTCallExpr::EmitBuiltinSyncFetchAndXor1)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_xor_2", &ASTCallExpr::EmitBuiltinSyncFetchAndXor2)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_xor_4", &ASTCallExpr::EmitBuiltinSyncFetchAndXor4)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_xor_8", &ASTCallExpr::EmitBuiltinSyncFetchAndXor8)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_nand_1", &ASTCallExpr::EmitBuiltinSyncFetchAndNand1)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_nand_2", &ASTCallExpr::EmitBuiltinSyncFetchAndNand2)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_nand_4", &ASTCallExpr::EmitBuiltinSyncFetchAndNand4)
+BUILTIN_FUNC_EMIT("__sync_fetch_and_nand_8", &ASTCallExpr::EmitBuiltinSyncFetchAndNand8)
+BUILTIN_FUNC_EMIT("__sync_and_and_fetch_1", &ASTCallExpr::EmitBuiltinSyncAndAndFetch1)
+BUILTIN_FUNC_EMIT("__sync_and_and_fetch_2", &ASTCallExpr::EmitBuiltinSyncAndAndFetch2)
+BUILTIN_FUNC_EMIT("__sync_and_and_fetch_4", &ASTCallExpr::EmitBuiltinSyncAndAndFetch4)
+BUILTIN_FUNC_EMIT("__sync_and_and_fetch_8", &ASTCallExpr::EmitBuiltinSyncAndAndFetch8)
+BUILTIN_FUNC_EMIT("__sync_or_and_fetch_1", &ASTCallExpr::EmitBuiltinSyncOrAndFetch1)
+BUILTIN_FUNC_EMIT("__sync_or_and_fetch_2", &ASTCallExpr::EmitBuiltinSyncOrAndFetch2)
+BUILTIN_FUNC_EMIT("__sync_or_and_fetch_4", &ASTCallExpr::EmitBuiltinSyncOrAndFetch4)
+BUILTIN_FUNC_EMIT("__sync_or_and_fetch_8", &ASTCallExpr::EmitBuiltinSyncOrAndFetch8)
+BUILTIN_FUNC_EMIT("__sync_xor_and_fetch_1", &ASTCallExpr::EmitBuiltinSyncXorAndFetch1)
+BUILTIN_FUNC_EMIT("__sync_xor_and_fetch_2", &ASTCallExpr::EmitBuiltinSyncXorAndFetch2)
+BUILTIN_FUNC_EMIT("__sync_xor_and_fetch_4", &ASTCallExpr::EmitBuiltinSyncXorAndFetch4)
+BUILTIN_FUNC_EMIT("__sync_xor_and_fetch_8", &ASTCallExpr::EmitBuiltinSyncXorAndFetch8)
+BUILTIN_FUNC_EMIT("__sync_nand_and_fetch_1", &ASTCallExpr::EmitBuiltinSyncNandAndFetch1)
+BUILTIN_FUNC_EMIT("__sync_nand_and_fetch_2", &ASTCallExpr::EmitBuiltinSyncNandAndFetch2)
+BUILTIN_FUNC_EMIT("__sync_nand_and_fetch_4", &ASTCallExpr::EmitBuiltinSyncNandAndFetch4)
+BUILTIN_FUNC_EMIT("__sync_nand_and_fetch_8", &ASTCallExpr::EmitBuiltinSyncNandAndFetch8)
+BUILTIN_FUNC_EMIT("__sync_synchronize", &ASTCallExpr::EmitBuiltinSyncSynchronize)
+
+BUILTIN_FUNC_EMIT("__atomic_exchange_1", &ASTCallExpr::EmitBuiltinAtomicExchangeN)
+BUILTIN_FUNC_EMIT("__atomic_exchange_2", &ASTCallExpr::EmitBuiltinAtomicExchangeN)
+BUILTIN_FUNC_EMIT("__atomic_exchange_4", &ASTCallExpr::EmitBuiltinAtomicExchangeN)
+BUILTIN_FUNC_EMIT("__atomic_exchange_8", &ASTCallExpr::EmitBuiltinAtomicExchangeN)
+
+BUILTIN_FUNC_EMIT("__builtin_return_address", &ASTCallExpr::EmitBuiltinReturnAddress)
+BUILTIN_FUNC_EMIT("__builtin_extract_return_addr", &ASTCallExpr::EmitBuiltinExtractReturnAddr)
+BUILTIN_FUNC_EMIT("__builtin_object_size", &ASTCallExpr::EmitBuiltinObjectSize)
+
+BUILTIN_FUNC_EMIT("__builtin_bswap64", &ASTCallExpr::EmitBuiltinBswap64)
+BUILTIN_FUNC_EMIT("__builtin_bswap32", &ASTCallExpr::EmitBuiltinBswap32)
+BUILTIN_FUNC_EMIT("__builtin_bswap16", &ASTCallExpr::EmitBuiltinBswap16)
\ No newline at end of file
diff --git a/src/hir2mpl/ast_input/clang/include/builtin_func_parse.def b/src/hir2mpl/ast_input/clang/include/builtin_func_parse.def
new file mode 100644
index 0000000000000000000000000000000000000000..9765fdb7b7b51a24ce6b4e0240e1e525649be7a3
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/include/builtin_func_parse.def
@@ -0,0 +1,19 @@
+BUILTIN_FUNC_PARSE("__builtin_classify_type", &ASTParser::ParseBuiltinClassifyType)
+BUILTIN_FUNC_PARSE("__builtin_constant_p", &ASTParser::ParseBuiltinConstantP)
+BUILTIN_FUNC_PARSE("__builtin_isinf_sign", &ASTParser::ParseBuiltinIsinfsign)
+BUILTIN_FUNC_PARSE("__builtin_huge_val", &ASTParser::ParseBuiltinHugeVal)
+BUILTIN_FUNC_PARSE("__builtin_huge_valf", &ASTParser::ParseBuiltinHugeValf)
+BUILTIN_FUNC_PARSE("__builtin_huge_vall", &ASTParser::ParseBuiltinHugeVal)
+BUILTIN_FUNC_PARSE("__builtin_inf", &ASTParser::ParseBuiltinInf)
+BUILTIN_FUNC_PARSE("__builtin_inff", &ASTParser::ParseBuiltinInff)
+BUILTIN_FUNC_PARSE("__builtin_infl", &ASTParser::ParseBuiltinInf)
+BUILTIN_FUNC_PARSE("__builtin_nan", &ASTParser::ParseBuiltinNan)
+BUILTIN_FUNC_PARSE("__builtin_nanf", &ASTParser::ParseBuiltinNanf)
+BUILTIN_FUNC_PARSE("__builtin_nanl", &ASTParser::ParseBuiltinNan)
+BUILTIN_FUNC_PARSE("__builtin_signbit", &ASTParser::ParseBuiltinSignbit)
+BUILTIN_FUNC_PARSE("__builtin_signbitf", &ASTParser::ParseBuiltinSignBitf)
+BUILTIN_FUNC_PARSE("__builtin_signbitl", &ASTParser::ParseBuiltinSignBitl)
+BUILTIN_FUNC_PARSE("__builtin_trap", &ASTParser::ParseBuiltinTrap)
+BUILTIN_FUNC_PARSE("__builtin_copysignf", &ASTParser::ParseBuiltinCopysignf)
+BUILTIN_FUNC_PARSE("__builtin_copysign", &ASTParser::ParseBuiltinCopysign)
+BUILTIN_FUNC_PARSE("__builtin_copysignl", &ASTParser::ParseBuiltinCopysignl)
\ No newline at end of file
diff --git a/src/hir2mpl/ast_input/clang/lib/ast_alias.h b/src/hir2mpl/ast_input/clang/lib/ast_alias.h
new file mode 100644
index 0000000000000000000000000000000000000000..e877a685fa0e66fcce0d2f70a6829cb2b6cffd65
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/lib/ast_alias.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_FILE_INCLUDE_AST_ALIAS_H
+#define HIR2MPL_AST_FILE_INCLUDE_AST_ALIAS_H
+#include "libclang/CIndexer.h"
+#include "libclang/CXTranslationUnit.h"
+#include "clang/Frontend/ASTUnit.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/AST.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/RecordLayout.h"
+#include "clang/AST/GlobalDecl.h"
+#include "clang/AST/Mangle.h"
+#include "clang/AST/VTableBuilder.h"
+#include "clang/AST/VTTBuilder.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/AST/DeclBase.h"
+
+namespace maple {
+  using AstASTContext = clang::ASTContext;
+  using AstUnitDecl = clang::TranslationUnitDecl;
+  using AstASTUnit = clang::ASTUnit;
+} // namespace maple
+#endif // HIR2MPL_AST_FILE_INCLUDE_AST_ALIAS_H
diff --git a/src/hir2mpl/ast_input/clang/lib/ast_interface.cpp b/src/hir2mpl/ast_input/clang/lib/ast_interface.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..441030d0e693539120b1bc6b7945e9f24e2061b1
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/lib/ast_interface.cpp
@@ -0,0 +1,656 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_interface.h"
+#include "mpl_logging.h"
+#include "ast_util.h"
+#include "fe_utils.h"
+#include "fe_manager.h"
+
+namespace maple {
+const std::unordered_map<clang::attr::Kind, std::string> kUnsupportedFuncAttrsMap = {
+    {clang::attr::NoInstrumentFunction, "no_instrument_function"},
+    {clang::attr::StdCall, "stdcall"},
+    {clang::attr::CDecl, "cdecl"},
+    {clang::attr::MipsLongCall, "mips_long_call"},
+    {clang::attr::MipsShortCall, "mips_short_call"},
+    {clang::attr::ARMInterrupt, "arm_interrupt"},
+    {clang::attr::AnyX86Interrupt, "x86_interrupt"},
+    {clang::attr::Naked, "naked"},
+    {clang::attr::AllocAlign, "alloc_align"},
+    {clang::attr::AssumeAligned, "assume_aligned"},
+    {clang::attr::Flatten, "flatten"},
+    {clang::attr::Cold, "cold"},
+    {clang::attr::IFunc, "ifunc"},
+    {clang::attr::NoSanitize, "no_sanitize"},
+    {clang::attr::NoSplitStack, "no_split_stack"},
+    {clang::attr::PatchableFunctionEntry, "patchable_function_entry"},
+    {clang::attr::Target, "target"}};
+const std::unordered_map<clang::attr::Kind, std::string> kUnsupportedVarAttrsMap = {
+    {clang::attr::Mode, "mode"},
+    {clang::attr::NoCommon, "nocommon"},
+    {clang::attr::TransparentUnion, "transparent_union"},
+    {clang::attr::Alias, "alias"},
+    {clang::attr::Cleanup, "cleanup"},
+    {clang::attr::Common, "common"},
+    {clang::attr::Uninitialized, "uninitialized"}};
+const std::unordered_map<clang::attr::Kind, std::string> kUnsupportedTypeAttrsMap = {
+    {clang::attr::MSStruct, "ms_struct"}};
+
+bool LibAstFile::Open(const MapleString &fileName,
+                      int excludeDeclFromPCH, int displayDiagnostics) {
+  astFileName = fileName;
+  index = clang_createIndex(excludeDeclFromPCH, displayDiagnostics);
+  translationUnit = clang_createTranslationUnit(index, fileName.c_str());
+  if (translationUnit == nullptr) {
+    return false;
+  }
+  clang::ASTUnit *astUnit = translationUnit->TheASTUnit;
+  if (astUnit == nullptr) {
+    return false;
+  }
+  astContext = &astUnit->getASTContext();
+  if (astContext == nullptr) {
+    return false;
+  }
+  astUnitDecl = astContext->getTranslationUnitDecl();
+  if (astUnitDecl == nullptr) {
+    return false;
+  }
+  mangleContext = astContext->createMangleContext();
+  if (mangleContext == nullptr) {
+    return false;
+  }
+  return true;
+}
+
+void LibAstFile::DisposeTranslationUnit() {
+    clang_disposeIndex(index);
+    clang_disposeTranslationUnit(translationUnit);
+    delete mangleContext;
+    mangleContext = nullptr;
+    translationUnit = nullptr;
+    index = nullptr;
+}
+
+const AstASTContext *LibAstFile::GetAstContext() const {
+  return astContext;
+}
+
+AstASTContext *LibAstFile::GetNonConstAstContext() const {
+  return astContext;
+}
+
+const AstUnitDecl *LibAstFile::GetAstUnitDecl() const {
+  return astUnitDecl;
+}
+
+std::string LibAstFile::GetMangledName(const clang::NamedDecl &decl) const {
+  std::string mangledName;
+  if (!mangleContext->shouldMangleDeclName(&decl)) {
+    mangledName = decl.getNameAsString();
+  } else {
+    llvm::raw_string_ostream ostream(mangledName);
+    if (llvm::isa<clang::CXXConstructorDecl>(&decl)) {
+      const auto *ctor = static_cast<const clang::CXXConstructorDecl*>(&decl);
+      mangleContext->mangleCtorBlock(ctor, static_cast<clang::CXXCtorType>(0), nullptr, ostream);
+    } else if (llvm::isa<clang::CXXDestructorDecl>(&decl)) {
+      const auto *dtor = static_cast<const clang::CXXDestructorDecl*>(&decl);
+      mangleContext->mangleDtorBlock(dtor, static_cast<clang::CXXDtorType>(0), nullptr, ostream);
+    } else {
+      mangleContext->mangleName(&decl, ostream);
+    }
+    ostream.flush();
+  }
+  return mangledName;
+}
+
+Loc LibAstFile::GetStmtLOC(const clang::Stmt &stmt) const {
+  return GetLOC(stmt.getBeginLoc());
+}
+
+Loc LibAstFile::GetExprLOC(const clang::Expr &expr) const {
+  return GetLOC(expr.getExprLoc());
+}
+
+Loc LibAstFile::GetLOC(const clang::SourceLocation &srcLoc) const {
+  clang::PresumedLoc pLoc = astContext->getSourceManager().getPresumedLoc(srcLoc);
+  if (pLoc.isInvalid()) {
+    return {0, 0, 0};
+  }
+  if (srcLoc.isFileID()) {
+    std::string fileName = pLoc.getFilename();
+    if (fileName.empty()) {
+      return {0, 0, 0};
+    }
+    unsigned line = pLoc.getLine();
+    unsigned colunm = pLoc.getColumn();
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fileName);
+    for (const auto &info : FEManager::GetModule().GetSrcFileInfo()) {
+      if (info.first == strIdx) {
+        return {info.second, static_cast<uint32>(line), static_cast<uint32>(colunm)};
+      }
+    }
+    if (FEManager::GetModule().GetSrcFileInfo().empty()) {
+      // src files start from 2, 1 is mpl file
+      FEManager::GetModule().PushbackFileInfo(MIRInfoPair(strIdx, 2));
+      return {2, static_cast<uint32>(line), static_cast<uint32>(colunm)};
+    } else {
+      auto last = FEManager::GetModule().GetSrcFileInfo().rbegin();
+      FEManager::GetModule().PushbackFileInfo(MIRInfoPair(strIdx, last->second + 1));
+      return {last->second + 1, static_cast<uint32>(line), static_cast<uint32>(colunm)};
+    }
+  } else {  // For macro line: The expansion location is the line in the source code where the macro was expanded
+    return GetLOC(astContext->getSourceManager().getExpansionLoc(srcLoc));
+  }
+}
+
+uint32 LibAstFile::GetMaxAlign(const clang::Decl &decl) const {
+  uint32 align = 0;
+  const clang::Decl *canonicalDecl = decl.getCanonicalDecl();
+  if (canonicalDecl->getKind() == clang::Decl::Field) {
+    const clang::FieldDecl *fieldDecl = llvm::cast<clang::FieldDecl>(canonicalDecl);
+    clang::QualType qualTy = fieldDecl->getType().getCanonicalType();
+    align = RetrieveAggTypeAlign(qualTy.getTypePtr());
+  }
+  uint32 selfAlign = canonicalDecl->getMaxAlignment();
+  return align > selfAlign ? align : selfAlign;
+}
+
+uint32 LibAstFile::RetrieveAggTypeAlign(const clang::Type *ty) const {
+  ASSERT_NOT_NULL(ty);
+  if (ty->isRecordType()) {
+    const auto *recordType = llvm::cast<clang::RecordType>(ty);
+    clang::RecordDecl *recordDecl = recordType->getDecl();
+    return (recordDecl->getMaxAlignment()) >> 3;  // 8 bit = 2^3 bit = 1 byte
+  } else if (ty->isArrayType()) {
+    const clang::Type *elemType = ty->getArrayElementTypeNoTypeQual();
+    return RetrieveAggTypeAlign(elemType);
+  }
+  return 0;
+}
+
+void LibAstFile::GetCVRAttrs(uint32_t qualifiers, GenericAttrs &genAttrs, bool isConst) const {
+  if (isConst && (qualifiers & clang::Qualifiers::Const) != 0) {
+    genAttrs.SetAttr(GENATTR_const);
+  }
+  if ((qualifiers & clang::Qualifiers::Restrict) != 0) {
+    genAttrs.SetAttr(GENATTR_restrict);
+  }
+  if ((qualifiers & clang::Qualifiers::Volatile) != 0) {
+    genAttrs.SetAttr(GENATTR_volatile);
+  }
+}
+
+void LibAstFile::GetSClassAttrs(const clang::StorageClass storageClass, GenericAttrs &genAttrs) const {
+  switch (storageClass) {
+    case clang::SC_Extern:
+    case clang::SC_PrivateExtern:
+      genAttrs.SetAttr(GENATTR_extern);
+      break;
+    case clang::SC_Static:
+      genAttrs.SetAttr(GENATTR_static);
+      break;
+    default:
+      break;
+  }
+}
+
+void LibAstFile::GetStorageAttrs(const clang::NamedDecl &decl, GenericAttrs &genAttrs) const {
+  switch (decl.getKind()) {
+    case clang::Decl::Function:
+    case clang::Decl::CXXMethod: {
+      const auto *funcDecl = llvm::cast<clang::FunctionDecl>(&decl);
+      const clang::StorageClass storageClass = funcDecl->getStorageClass();
+      GetSClassAttrs(storageClass, genAttrs);
+      // static or extern maybe missing in current FunctionDecls,
+      // Since a given function can be declared several times in a program,
+      // Only one of those FunctionDecls will be found when traversing the list of declarations in the context.
+      const clang::FunctionDecl *prev = funcDecl->getPreviousDecl();
+      while (prev != nullptr && prev->isDefined()) {
+        GetStorageAttrs(*prev, genAttrs);
+        prev = prev->getPreviousDecl();
+      }
+      break;
+    }
+    case clang::Decl::ParmVar:
+    case clang::Decl::Var: {
+      const auto *varDecl = llvm::cast<clang::VarDecl>(&decl);
+      const clang::StorageClass storageClass = varDecl->getStorageClass();
+      GetSClassAttrs(storageClass, genAttrs);
+      break;
+    }
+    case clang::Decl::Field:
+    default:
+      break;
+  }
+  return;
+}
+
+void LibAstFile::GetAccessAttrs(AccessKind access, GenericAttrs &genAttrs) const {
+  switch (access) {
+    case kPublic:
+      genAttrs.SetAttr(GENATTR_public);
+      break;
+    case kProtected:
+      genAttrs.SetAttr(GENATTR_protected);
+      break;
+    case kPrivate:
+      genAttrs.SetAttr(GENATTR_private);
+      break;
+    case kNone:
+      break;
+    default:
+      ASSERT(false, "shouldn't reach here");
+      break;
+  }
+  return;
+}
+
+void LibAstFile::GetQualAttrs(const clang::NamedDecl &decl, GenericAttrs &genAttrs) const {
+  switch (decl.getKind()) {
+    case clang::Decl::Function:
+    case clang::Decl::CXXMethod:
+    case clang::Decl::ParmVar:
+    case clang::Decl::Var:
+    case clang::Decl::Field: {
+      const auto *valueDecl = llvm::dyn_cast<clang::ValueDecl>(&decl);
+      ASSERT(valueDecl != nullptr, "ERROR:null pointer!");
+      const clang::QualType qualType = valueDecl->getType();
+      uint32_t qualifiers = qualType.getCVRQualifiers();
+      GetCVRAttrs(qualifiers, genAttrs);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void LibAstFile::GetQualAttrs(const clang::QualType &qualType, GenericAttrs &genAttrs, bool isSourceType) const {
+  uint32_t qualifiers = qualType.getCVRQualifiers();
+  GetCVRAttrs(qualifiers, genAttrs, isSourceType);
+}
+
+void LibAstFile::CollectAttrs(const clang::NamedDecl &decl, GenericAttrs &genAttrs, AccessKind access) const {
+  GetStorageAttrs(decl, genAttrs);
+  GetAccessAttrs(access, genAttrs);
+  GetQualAttrs(decl, genAttrs);
+  if (decl.isImplicit()) {
+    genAttrs.SetAttr(GENATTR_implicit);
+  }
+  if (decl.isUsed()) {
+    genAttrs.SetAttr(GENATTR_used);
+  }
+  if (decl.hasAttr<clang::WeakAttr>()) {
+    genAttrs.SetAttr(GENATTR_weak);
+  }
+  if (decl.hasAttr<clang::NonNullAttr>() && decl.getKind() != clang::Decl::Function) {
+    for (const auto *nonNull : decl.specific_attrs<clang::NonNullAttr>()) {
+      if (nonNull->args_size() > 0) {
+        // nonnull with args in function type pointers need special handling to mark nonnull arg
+        continue;
+      }
+      genAttrs.SetAttr(GENATTR_nonnull);
+    }
+  }
+}
+
+void LibAstFile::CollectFuncReturnVarAttrs(const clang::CallExpr &expr, GenericAttrs &genAttrs) const {
+  if (LibAstFile::IsOneElementVector(expr.getCallReturnType(*astContext))) {
+    genAttrs.SetAttr(GenericAttrKind::GENATTR_oneelem_simd);
+  }
+}
+
+void LibAstFile::CollectFuncAttrs(const clang::FunctionDecl &decl, GenericAttrs &genAttrs, AccessKind access) const {
+  CollectAttrs(decl, genAttrs, access);
+  if (decl.isVirtualAsWritten()) {
+    genAttrs.SetAttr(GENATTR_virtual);
+  }
+  if (decl.isDeletedAsWritten()) {
+    genAttrs.SetAttr(GENATTR_delete);
+  }
+  if (decl.isPure()) {
+    genAttrs.SetAttr(GENATTR_pure);
+  }
+  if (decl.isInlineSpecified()) {
+    genAttrs.SetAttr(GENATTR_inline);
+  } else if (decl.hasAttr<clang::NoInlineAttr>()) {
+    genAttrs.SetAttr(GENATTR_noinline);
+  }
+  if (decl.hasAttr<clang::AlwaysInlineAttr>()) {
+    genAttrs.SetAttr(GENATTR_always_inline);
+  }
+  if (decl.hasAttr<clang::GNUInlineAttr>()) {
+    genAttrs.SetAttr(GENATTR_gnu_inline);
+  }
+  if (decl.isDefaulted()) {
+    genAttrs.SetAttr(GENATTR_default);
+  }
+  if (decl.getKind() == clang::Decl::CXXConstructor) {
+    genAttrs.SetAttr(GENATTR_constructor);
+  }
+  if (decl.getKind() == clang::Decl::CXXDestructor) {
+    genAttrs.SetAttr(GENATTR_destructor);
+  }
+  if (decl.isVariadic()) {
+    genAttrs.SetAttr(GENATTR_varargs);
+  }
+  if (decl.isNoReturn()) {
+    genAttrs.SetAttr(GENATTR_noreturn);
+  }
+  clang::AliasAttr *aliasAttr = decl.getAttr<clang::AliasAttr>();
+  if (aliasAttr != nullptr) {
+    genAttrs.SetAttr(GENATTR_alias);
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(aliasAttr->getAliasee().str());
+    genAttrs.InsertStrIdxContentMap(GENATTR_alias, strIdx);
+  }
+  clang::ConstructorAttr *constructorAttr = decl.getAttr<clang::ConstructorAttr>();
+  if (constructorAttr != nullptr) {
+    genAttrs.SetAttr(GENATTR_constructor_priority);
+    genAttrs.InsertIntContentMap(GENATTR_constructor_priority, constructorAttr->getPriority());
+  }
+  clang::DestructorAttr *destructorAttr = decl.getAttr<clang::DestructorAttr>();
+  if (destructorAttr != nullptr) {
+    genAttrs.SetAttr(GENATTR_destructor_priority);
+    genAttrs.InsertIntContentMap(GENATTR_destructor_priority, destructorAttr->getPriority());
+  }
+  // one element vector type in rettype
+  if (LibAstFile::IsOneElementVector(decl.getReturnType())) {
+    genAttrs.SetAttr(GENATTR_oneelem_simd);
+  }
+  if (FEOptions::GetInstance().IsEnableSafeRegion()) {
+    if (decl.getSafeSpecifier() == clang::SS_Unsafe) {
+      genAttrs.SetAttr(GENATTR_unsafed);
+    } else if (decl.getSafeSpecifier() == clang::SS_Safe || FEOptions::GetInstance().IsDefaultSafe()) {
+      genAttrs.SetAttr(GENATTR_safed);
+    }
+  }
+  // If a non-static function defined with inline has non-static and non-inline function declaration, it should be
+  // an externally visible function.
+  if (decl.isThisDeclarationADefinition() && genAttrs.GetAttr(GENATTR_inline) && !genAttrs.GetAttr(GENATTR_static)) {
+    bool isExternallyVisible = false;
+    for (const clang::FunctionDecl *funcDecl : decl.redecls()) {
+      if (!funcDecl->isThisDeclarationADefinition() && !funcDecl->isInlineSpecified()) {
+        isExternallyVisible = true;
+        break;
+      }
+    }
+    if (isExternallyVisible) {
+      genAttrs.SetAttr(GENATTR_extern);
+    }
+  }
+  // If a function is defined with attrinute 'gnu_inline' but without 'extern', the 'extern' from function declarations
+  // should be ignored.
+  if (decl.isThisDeclarationADefinition() && genAttrs.GetAttr(GENATTR_gnu_inline) &&
+      (decl.getStorageClass() != clang::SC_Extern) && (decl.getStorageClass() != clang::SC_PrivateExtern) &&
+      genAttrs.GetAttr(GENATTR_extern)) {
+    genAttrs.ResetAttr(GENATTR_extern);
+  }
+  CheckUnsupportedFuncAttrs(decl);
+}
+
+void LibAstFile::CheckUnsupportedFuncAttrs(const clang::FunctionDecl &decl) const {
+  if (!decl.hasAttrs()) {
+    return;
+  }
+  std::string unsupportedFuncAttrs = "";
+  const clang::AttrVec &funcAttrs = decl.getAttrs();
+  for (const auto *attr : funcAttrs) {
+    clang::attr::Kind attrKind = attr->getKind();
+    auto iterator = kUnsupportedFuncAttrsMap.find(attrKind);
+    if (iterator != kUnsupportedFuncAttrsMap.end()) {
+      unsupportedFuncAttrs += iterator->second + " ";
+    }
+  }
+  CHECK_FATAL(unsupportedFuncAttrs.empty(), "%s:%d error: The function %s has unsupported attribute(s): %s",
+              FEManager::GetModule().GetFileNameFromFileNum(GetLOC(decl.getLocation()).fileIdx).c_str(),
+              GetLOC(decl.getLocation()).line,
+              GetMangledName(decl).c_str(),
+              unsupportedFuncAttrs.c_str());
+}
+
+void LibAstFile::CollectVarAttrs(const clang::VarDecl &decl, GenericAttrs &genAttrs, AccessKind access) const {
+  CollectAttrs(decl, genAttrs, access);
+  // handle __thread
+  if (decl.getTLSKind() == clang::VarDecl::TLS_Static) {
+    genAttrs.SetAttr(GENATTR_tls_static);
+  } else if (decl.getTLSKind() == clang::VarDecl::TLS_Dynamic) {
+    genAttrs.SetAttr(GENATTR_tls_dynamic);
+  }
+  // one elem vector type
+  if (IsOneElementVector(decl.getType())) {
+    genAttrs.SetAttr(GENATTR_oneelem_simd);
+  }
+  CheckUnsupportedVarAttrs(decl);
+}
+
+void LibAstFile::CheckUnsupportedVarAttrs(const clang::VarDecl &decl) const {
+  if (!decl.hasAttrs()) {
+    return;
+  }
+  std::string unsupportedVarAttrs = "";
+  const clang::AttrVec &varAttrs = decl.getAttrs();
+  for (const auto *attr : varAttrs) {
+    clang::attr::Kind attrKind = attr->getKind();
+    auto iterator = kUnsupportedVarAttrsMap.find(attrKind);
+    if (iterator != kUnsupportedVarAttrsMap.end()) {
+      unsupportedVarAttrs += iterator->second + " ";
+    }
+  }
+  CHECK_FATAL(unsupportedVarAttrs.empty(), "%s:%d error: The variable %s has unsupported attribute(s): %s",
+              FEManager::GetModule().GetFileNameFromFileNum(GetLOC(decl.getLocation()).fileIdx).c_str(),
+              GetLOC(decl.getLocation()).line,
+              GetMangledName(decl).c_str(),
+              unsupportedVarAttrs.c_str());
+}
+
+void LibAstFile::CollectRecordAttrs(const clang::RecordDecl &decl, GenericAttrs &genAttrs) const {
+  clang::PackedAttr *packedAttr = decl.getAttr<clang::PackedAttr>();
+  if (packedAttr != nullptr) {
+    genAttrs.SetAttr(GENATTR_pack);
+    genAttrs.InsertIntContentMap(GENATTR_pack, 1); // 1 byte
+  }
+  clang::MaxFieldAlignmentAttr *maxFieldAlignAttr = decl.getAttr<clang::MaxFieldAlignmentAttr>();
+  if (maxFieldAlignAttr != nullptr) {
+    genAttrs.SetAttr(GENATTR_pack);
+    int value = static_cast<int>(maxFieldAlignAttr->getAlignment() / 8); // bits to byte
+    genAttrs.InsertIntContentMap(GENATTR_pack, value);
+  }
+  CheckUnsupportedTypeAttrs(decl);
+}
+
+void LibAstFile::CheckUnsupportedTypeAttrs(const clang::RecordDecl &decl) const {
+  if (!decl.hasAttrs()) {
+    return;
+  }
+  std::string unsupportedTypeAttrs = "";
+  const clang::AttrVec &typeAttrs = decl.getAttrs();
+  for (const auto *attr : typeAttrs) {
+    clang::attr::Kind attrKind = attr->getKind();
+    auto iterator = kUnsupportedTypeAttrsMap.find(attrKind);
+    if (iterator != kUnsupportedTypeAttrsMap.end()) {
+      unsupportedTypeAttrs += iterator->second + " ";
+    }
+  }
+  CHECK_FATAL(unsupportedTypeAttrs.empty(), "%s:%d error: struct or union %s has unsupported type attribute(s): %s",
+              FEManager::GetModule().GetFileNameFromFileNum(GetLOC(decl.getLocation()).fileIdx).c_str(),
+              GetLOC(decl.getLocation()).line,
+              GetMangledName(decl).c_str(),
+              unsupportedTypeAttrs.c_str());
+}
+
+void LibAstFile::CollectFieldAttrs(const clang::FieldDecl &decl, GenericAttrs &genAttrs, AccessKind access) const {
+  CollectAttrs(decl, genAttrs, access);
+  clang::PackedAttr *packedAttr = decl.getAttr<clang::PackedAttr>();
+  if (packedAttr != nullptr) {
+    genAttrs.SetAttr(GENATTR_pack);
+    genAttrs.InsertIntContentMap(GENATTR_pack, 1); // 1 byte
+  }
+}
+
+void LibAstFile::EmitTypeName(const clang::QualType qualType, std::stringstream &ss) {
+  switch (qualType->getTypeClass()) {
+    case clang::Type::LValueReference: {
+      ss << "R";
+      const clang::QualType pointeeType = qualType->castAs<clang::ReferenceType>()->getPointeeType();
+      EmitTypeName(pointeeType, ss);
+      break;
+    }
+    case clang::Type::Pointer: {
+      ss << "P";
+      const clang::QualType pointeeType = qualType->castAs<clang::PointerType>()->getPointeeType();
+      EmitTypeName(pointeeType, ss);
+      break;
+    }
+    case clang::Type::Record: {
+      EmitTypeName(*qualType->getAs<clang::RecordType>(), ss);
+      break;
+    }
+    default: {
+      EmitQualifierName(qualType, ss);
+      MIRType *type = CvtType(qualType);
+      ss << ASTUtil::GetTypeString(*type);
+      break;
+    }
+  }
+}
+
+void LibAstFile::EmitQualifierName(const clang::QualType qualType, std::stringstream &ss) const {
+  uint32_t cvrQual = qualType.getCVRQualifiers();
+  if ((cvrQual & clang::Qualifiers::Const) != 0) {
+    ss << "K";
+  }
+  if ((cvrQual & clang::Qualifiers::Volatile) != 0) {
+    ss << "U";
+  }
+}
+
+const std::string LibAstFile::GetOrCreateMappedUnnamedName(const clang::Decl &decl) {
+  uint32 uid;
+  if (FEOptions::GetInstance().GetFuncInlineSize() != 0 && !decl.getLocation().isMacroID()) {
+    // use loc as key for wpaa mode
+    Loc l = GetLOC(decl.getLocation());
+    CHECK_FATAL(l.fileIdx != 0, "loc is invaild");
+    std::map<Loc, uint32>::const_iterator itLoc = unnamedLocMap.find(l);
+    if (itLoc == unnamedLocMap.cend()) {
+      uid = FEUtils::GetSequentialNumber();
+      unnamedLocMap[l] = uid;
+    } else {
+      uid = itLoc->second;
+    }
+    return FEUtils::GetSequentialName0("unnamed.", uid);
+  }
+  std::map<int64, uint32>::const_iterator it = unnamedSymbolMap.find(decl.getID());
+  if (it == unnamedSymbolMap.cend()) {
+    uid = FEUtils::GetSequentialNumber();
+    unnamedSymbolMap[decl.getID()] = uid;
+  } else {
+    uid = it->second;
+  }
+  return FEUtils::GetSequentialName0("unnamed.", uid);
+}
+
+const std::string LibAstFile::GetDeclName(const clang::NamedDecl &decl, bool isRename) {
+  std::string name = decl.getNameAsString();
+  if (name.empty()) {
+    name = GetOrCreateMappedUnnamedName(decl);
+  }
+  if (isRename && !decl.isDefinedOutsideFunctionOrMethod()) {
+    Loc l = GetLOC(decl.getLocation());
+    std::stringstream ss;
+    ss << name << "_" << l.line << "_" << l.column;
+    name = ss.str();
+  }
+  return name;
+}
+
+void LibAstFile::EmitTypeName(const clang::RecordType &recordType, std::stringstream &ss) {
+  clang::RecordDecl *recordDecl = recordType.getDecl();
+  std::string str = recordType.desugar().getAsString();
+  if (!recordDecl->isAnonymousStructOrUnion() && str.find("anonymous") == std::string::npos) {
+    clang::DeclContext *ctx = recordDecl->getDeclContext();
+    MapleStack<clang::NamedDecl*> nsStack(module->GetMPAllocator().Adapter());
+    while (!ctx->isTranslationUnit()) {
+      auto *primCtxNsDc = llvm::dyn_cast<clang::NamespaceDecl>(ctx->getPrimaryContext());
+      if (primCtxNsDc != nullptr) {
+        nsStack.push(primCtxNsDc);
+      }
+      auto *primCtxRecoDc = llvm::dyn_cast<clang::RecordDecl>(ctx->getPrimaryContext());
+      if (primCtxRecoDc != nullptr) {
+        nsStack.push(primCtxRecoDc);
+      }
+      ctx = ctx->getParent();
+    }
+    while (!nsStack.empty()) {
+      auto *nsDc = llvm::dyn_cast<clang::NamespaceDecl>(nsStack.top());
+      if (nsDc != nullptr) {
+        ss << nsDc->getName().data() << "|";
+      }
+      auto *rcDc = llvm::dyn_cast<clang::RecordDecl>(nsStack.top());
+      if (rcDc != nullptr) {
+        EmitTypeName(*rcDc->getTypeForDecl()->getAs<clang::RecordType>(), ss);
+      }
+      nsStack.pop();
+    }
+    auto nameStr = recordDecl->getName().str();
+    if (nameStr.empty()) {
+      nameStr = GetTypedefNameFromUnnamedStruct(*recordDecl);
+    }
+    if (nameStr.empty()) {
+      nameStr = GetOrCreateMappedUnnamedName(*recordDecl);
+    }
+    ss << nameStr;
+  } else {
+    ss << GetOrCreateMappedUnnamedName(*recordDecl);
+  }
+  if (FEOptions::GetInstance().GetFuncInlineSize() != 0) {
+    std::string recordStr = recordDecl->getDefinition() == nullptr ? "" : GetRecordLayoutString(*recordDecl);
+    std::string filename = astContext->getSourceManager().getFilename(recordDecl->getLocation()).str();
+    ss << FEUtils::GetFileNameHashStr(filename + recordStr);
+  }
+  CHECK_FATAL(ss.rdbuf()->in_avail() != 0, "stringstream is empty");
+}
+
+std::string LibAstFile::GetRecordLayoutString(const clang::RecordDecl &recordDecl) {
+  std::stringstream recordLayoutStr;
+  const clang::ASTRecordLayout &recordLayout = GetContext()->getASTRecordLayout(&recordDecl);
+  unsigned int fieldCount = recordLayout.getFieldCount();
+  uint64_t recordSize = static_cast<uint64_t>(recordLayout.getSize().getQuantity());
+  recordLayoutStr << std::to_string(fieldCount) << std::to_string(recordSize);
+  clang::RecordDecl::field_iterator it = recordDecl.field_begin();
+  for (unsigned i = 0, e = recordLayout.getFieldCount(); i != e; ++i, ++it) {
+    const clang::FieldDecl *fieldDecl = *it;
+    recordLayoutStr << std::to_string(recordLayout.getFieldOffset(i));
+    std::string fieldName = GetMangledName(*fieldDecl);
+    if (fieldName.empty()) {
+      fieldName = GetOrCreateMappedUnnamedName(*fieldDecl);
+    }
+    recordLayoutStr << fieldName;
+  }
+  return recordLayoutStr.str();
+}
+
+// get TypedefDecl name for the unnamed struct, e.g. typedef struct {} foo;
+std::string LibAstFile::GetTypedefNameFromUnnamedStruct(const clang::RecordDecl &recoDecl) const {
+  // typedef is parsed in debug mode
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    return std::string();
+  }
+  auto *defnameDcel = recoDecl.getTypedefNameForAnonDecl();
+  if (defnameDcel != nullptr) {
+    return defnameDcel->getQualifiedNameAsString();
+  }
+  return std::string();
+}
+} // namespace maple
diff --git a/src/hir2mpl/ast_input/clang/lib/ast_interface.h b/src/hir2mpl/ast_input/clang/lib/ast_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2476c06cac6a311efc4fcc3f5887b623531b1d6
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/lib/ast_interface.h
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_FILE_INCLUDE_AST_INTERFACE_H
+#define HIR2MPL_AST_FILE_INCLUDE_AST_INTERFACE_H
+#include <string>
+#include "ast_alias.h"
+#include "mir_type.h"
+#include "mir_nodes.h"
+#include "mpl_logging.h"
+#include "generic_attrs.h"
+#include "fe_utils.h"
+#include "clang/Basic/AttrKinds.h"
+
+namespace maple {
+enum AccessKind {
+  kPublic,
+  kProtected,
+  kPrivate,
+  kNone
+};
+
+class LibAstFile {
+ public:
+  explicit LibAstFile(MapleAllocator &allocatorIn, MapleList<clang::Decl*> &recordDeclesIn,
+                      MapleList<clang::Decl*> &enumDeclesIn)
+      : recordDeclSet(allocatorIn.Adapter()),
+        unnamedSymbolMap(allocatorIn.Adapter()), compoundLiteralExprInitSymbolMap(allocatorIn.Adapter()),
+        recordDecles(recordDeclesIn), enumDecles(enumDeclesIn), astFileName("", allocatorIn.GetMemPool()) {}
+  ~LibAstFile() = default;
+
+  bool Open(const MapleString &fileName,
+            int excludeDeclFromPCH, int displayDiagnostics);
+  void DisposeTranslationUnit();
+  const AstASTContext *GetAstContext() const;
+  AstASTContext *GetNonConstAstContext() const;
+  const AstUnitDecl *GetAstUnitDecl() const;
+  std::string GetMangledName(const clang::NamedDecl &decl) const;
+  const std::string GetOrCreateMappedUnnamedName(const clang::Decl &decl);
+  const std::string GetDeclName(const clang::NamedDecl &decl, bool isRename = false);
+  void EmitTypeName(const clang::QualType qualType, std::stringstream &ss);
+  void EmitTypeName(const clang::RecordType &recordType, std::stringstream &ss);
+  void EmitQualifierName(const clang::QualType qualType, std::stringstream &ss) const;
+  std::string GetTypedefNameFromUnnamedStruct(const clang::RecordDecl &recoDecl) const;
+  std::string GetRecordLayoutString(const clang::RecordDecl &recordDecl);
+  void CollectBaseEltTypeAndSizesFromConstArrayDecl(const clang::QualType &currQualType, MIRType *&elemType,
+                                                    TypeAttrs &elemAttr, std::vector<uint32_t> &operands,
+                                                    bool isSourceType);
+  void CollectBaseEltTypeAndDimFromVariaArrayDecl(const clang::QualType &currQualType, MIRType *&elemType,
+                                                  TypeAttrs &elemAttr, uint8_t &dim, bool isSourceType);
+  void CollectBaseEltTypeAndDimFromDependentSizedArrayDecl(const clang::QualType currQualType, MIRType *&elemType,
+                                                           TypeAttrs &elemAttr, std::vector<uint32_t> &operands,
+                                                           bool isSourceType);
+  void CollectBaseEltTypeFromArrayDecl(const clang::QualType &currQualType, MIRType *&elemType, TypeAttrs &elemAttr,
+                                       bool isSourceType = false);
+  void GetCVRAttrs(uint32_t qualifiers, GenericAttrs &genAttrs, bool isConst = true) const;
+  void GetSClassAttrs(const clang::StorageClass storageClass, GenericAttrs &genAttrs) const;
+  void GetStorageAttrs(const clang::NamedDecl &decl, GenericAttrs &genAttrs) const;
+  void GetAccessAttrs(AccessKind access, GenericAttrs &genAttrs) const;
+  void GetQualAttrs(const clang::NamedDecl &decl, GenericAttrs &genAttrs) const;
+  void GetQualAttrs(const clang::QualType &qualType, GenericAttrs &genAttrs, bool isSourceType) const;
+  void CollectAttrs(const clang::NamedDecl &decl, GenericAttrs &genAttrs, AccessKind access) const;
+  void CollectFuncAttrs(const clang::FunctionDecl &decl, GenericAttrs &genAttrs, AccessKind access) const;
+  void CollectFuncReturnVarAttrs(const clang::CallExpr &expr, GenericAttrs &genAttrs) const;
+  void CheckUnsupportedFuncAttrs(const clang::FunctionDecl &decl) const;
+  void CollectVarAttrs(const clang::VarDecl &decl, GenericAttrs &genAttrs, AccessKind access) const;
+  void CheckUnsupportedVarAttrs(const clang::VarDecl &decl) const;
+  void CollectRecordAttrs(const clang::RecordDecl &decl, GenericAttrs &genAttrs) const;
+  void CheckUnsupportedTypeAttrs(const clang::RecordDecl &decl) const;
+  void CollectFieldAttrs(const clang::FieldDecl &decl, GenericAttrs &genAttrs, AccessKind access) const;
+  MIRType *CvtPrimType(const clang::QualType qualType, bool isSourceType = false) const;
+  PrimType CvtPrimType(const clang::BuiltinType::Kind kind, bool isSourceType) const;
+  MIRType *CvtPrimType2SourceType(const clang::BuiltinType::Kind kind) const;
+  MIRType *CvtSourceType(const clang::QualType qualType);
+  MIRType *CvtType(const clang::QualType qualType, bool isSourceType = false);
+  MIRType *CvtOtherType(const clang::QualType srcType, bool isSourceType);
+  MIRType *CvtArrayType(const clang::QualType &srcType, bool isSourceType);
+  MIRType *CvtFunctionType(const clang::QualType srcType, bool isSourceType);
+  MIRType *CvtEnumType(const clang::QualType &qualType, bool isSourceType);
+  MIRType *CvtRecordType(const clang::QualType qualType);
+  MIRType *CvtFieldType(const clang::NamedDecl &decl);
+  MIRType *CvtComplexType(const clang::QualType srcType) const;
+  MIRType *CvtVectorType(const clang::QualType srcType);
+  MIRType *CvtTypedef(const clang::QualType &qualType);
+  MIRType *CvtTypedefDecl(const clang::TypedefNameDecl &typedefDecl);
+  bool TypeHasMayAlias(const clang::QualType srcType) const;
+  static bool IsOneElementVector(const clang::QualType &qualType);
+  static bool IsOneElementVector(const clang::Type &type);
+
+  const clang::ASTContext *GetContext() const {
+    return astContext;
+  }
+
+  const std::string GetAstFileNameHashStr() const {
+    std::string fileName = (astFileName.c_str() == nullptr ? "" : astFileName.c_str());
+    return FEUtils::GetFileNameHashStr(fileName);
+  }
+
+  Loc GetStmtLOC(const clang::Stmt &stmt) const;
+  Loc GetExprLOC(const clang::Expr &expr) const;
+  Loc GetLOC(const clang::SourceLocation &srcLoc) const;
+  uint32 GetMaxAlign(const clang::Decl &decl) const;
+  uint32 RetrieveAggTypeAlign(const clang::Type *ty) const;
+
+ private:
+  MapleSet<const clang::Decl*> recordDeclSet;
+  MapleMap<int64, uint32> unnamedSymbolMap;
+  MapleMap<uint32_t, std::string> compoundLiteralExprInitSymbolMap;
+  MIRModule *module = nullptr;
+
+  MapleList<clang::Decl*> &recordDecles;
+  MapleList<clang::Decl*> &enumDecles;
+
+  clang::ASTContext *astContext = nullptr;
+  clang::TranslationUnitDecl *astUnitDecl = nullptr;
+  clang::MangleContext *mangleContext = nullptr;
+  CXTranslationUnit translationUnit = nullptr;
+  CXIndex index = nullptr;
+  MapleString astFileName;
+  static std::map<Loc, uint32> unnamedLocMap;
+};
+} // namespace maple
+#endif // HIR2MPL_AST_FILE_INCLUDE_AST_INTERFACE_H
diff --git a/src/hir2mpl/ast_input/clang/lib/ast_macros.h b/src/hir2mpl/ast_input/clang/lib/ast_macros.h
new file mode 100644
index 0000000000000000000000000000000000000000..87e9f0555863d0b837913de7ddd3ac6b6e82a646
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/lib/ast_macros.h
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef AST2MPL_INCLUDE_ASTMACROS_H
+#define AST2MPL_INCLUDE_ASTMACROS_H
+#include <iostream>
+
+namespace maple {
+const uint32_t kSrcFileNum = 2;
+
+// ast2mpl options
+// these values can be use such as -o=1 at command lines
+const uint32_t kCheckAssertion = 1;
+const uint32_t kNoComment = 2;
+const uint32_t kNoLoc = 4;
+
+// these values can be use such as -d=3 at command lines
+const int kDebugLevelZero = 0;
+const int kDebugLevelOne = 1;
+const int kDebugLevelTwo = 2;
+const int kDebugLevelThree = 3;
+
+const int kComplexRealID = 1;
+const int kComplexImagID = 2;
+
+const int kBitToByteShift = 3;
+
+const uint32_t kFloat128Size = 2;
+const uint32_t kInt32Width = 32;
+const uint32_t kInt32Mask = 0xFFFFFFFFULL;
+const int kDefaultIndent = 1;
+
+#define ASTDEBUG
+#ifdef ASTDEBUG
+#define LOCATION __func__ << "() at " << __FILE__ << ":" << __LINE__
+
+#define DUMPINFO(stmtClass, s)                      \
+  do {                                              \
+    if (maple::ast2mplDebug > kDebugLevelOne) {     \
+      std::cout << LOCATION << '\n';                \
+      s->dump();                                    \
+      std::cout << " " << '\n';                     \
+    }                                               \
+  } while (0)
+
+#define NOTYETHANDLED(s)                                                                                            \
+  do {                                                                                                              \
+    std::cout << "\n" << LOCATION << " <<<<<<<<<<<<<<<<<< Not Yet Handled: " << s << "<<<<<<<<<<<<<<<<<<" << '\n';  \
+    if ((maple::ast2mplOption & kCheckAssertion) != 0) {                                                            \
+      ASSERT(false, "Not yet handled");                                                                             \
+    }                                                                                                               \
+  } while (0)
+
+// print empty line
+#define DEBUGPRINT_N(n)                           \
+  do {                                            \
+    if (maple::ast2mplDebug >= n) {               \
+      std::cout << " " << '\n';                   \
+    }                                             \
+  } while (0)
+
+// print indent
+#define DEBUGPRINTIND(n)                          \
+  do {                                            \
+    if (maple::ast2mplDebug > kDebugLevelZero) {  \
+      PrintIndentation(n);                        \
+    }                                             \
+  } while (0)
+
+// print str
+#define DEBUGPRINT_S_LEVEL(str, level)            \
+  do {                                            \
+    if (maple::ast2mplDebug >= level) {           \
+      PrintIndentation(ast2mplDebugIndent);       \
+      std::cout << " " << str << '\n';            \
+    }                                             \
+  } while (0)
+
+#define DEBUGPRINT_FUNC(name)                     \
+  do {                                            \
+    int ind = maple::ast2mplDebugIndent;          \
+    Util::SetIndent(kDefaultIndent);              \
+    if (maple::ast2mplDebug > kDebugLevelZero) {  \
+      PrintIndentation(ast2mplDebugIndent);       \
+      std::cout << name << " {" << '\n';          \
+    }                                             \
+    Util::SetIndent(ind);                         \
+  } while (0)
+
+#define DEBUGPRINT_FUNC_END(name)                 \
+  do {                                            \
+    int ind = maple::ast2mplDebugIndent;          \
+    Util::SetIndent(kDefaultIndent);              \
+    if (maple::ast2mplDebug > kDebugLevelZero) {  \
+      PrintIndentation(ast2mplDebugIndent);       \
+      std::cout << "}\n" << '\n';                 \
+    }                                             \
+    Util::SetIndent(ind);                         \
+  } while (0)
+
+#define DEBUGPRINT_NODE(node, type)                                                       \
+  do {                                                                                    \
+    if (maple::ast2mplDebug > kDebugLevelOne) {                                           \
+      PrintIndentation(maple::ast2mplDebugIndent);                                        \
+      std::cout << "  >> node: ";                                                         \
+      static_cast<const type*>(node)->Print(static_cast<const MIRModule*>(module), 0);    \
+      std::cout << "\n";                                                                  \
+    }                                                                                     \
+  } while (0)
+
+// print var = val
+#define DEBUGPRINT_V_LEVEL(var, level)                                    \
+  do {                                                                    \
+    if (maple::ast2mplDebug >= level) {                                   \
+      PrintIndentation(maple::ast2mplDebugIndent);                        \
+      std::cout << LOCATION << " " << #var << " = " << var << '\n';       \
+    }                                                                     \
+  } while (0)
+
+#define DEBUGPRINT_X_LEVEL(var, level)                                                                    \
+  do {                                                                                                    \
+    if (maple::ast2mplDebug >= level) {                                                                   \
+      PrintIndentation(maple::ast2mplDebugIndent);                                                        \
+      std::cout << LOCATION << " " << #var << " = " << std::hex << "0x" << var << std::dec << '\n';       \
+    }                                                                                                     \
+  } while (0)
+
+// print var = val
+#define DEBUGPRINT_V_LEVEL_PURE(var, level)           \
+  do {                                                \
+    if (maple::ast2mplDebug >= level) {               \
+      PrintIndentation(maple::ast2mplDebugIndent);    \
+      std::cout << #var << " = " << var << '\n';      \
+    }                                                 \
+  } while (0)
+
+// print val0 val1
+#define DEBUGPRINT_NN_LEVEL(var0, var1, level)        \
+  do {                                                \
+    if (maple::ast2mplDebug >= level) {               \
+      PrintIndentation(maple::ast2mplDebugIndent);    \
+      std::cout << var0 << " " << var1;               \
+    }                                                 \
+  } while (0)
+
+// print var0 = val0, var1 = val1
+#define DEBUGPRINT_VV_LEVEL(var0, var1, level)                                                                \
+  do {                                                                                                        \
+    if (maple::ast2mplDebug >= level) {                                                                       \
+      PrintIndentation(maple::ast2mplDebugIndent);                                                            \
+      std::cout << LOCATION << " " << #var0 << " = " << var0 << ", " << #var1 << " = " << var1 << '\n';       \
+    }                                                                                                         \
+  } while (0)
+
+// print val0, var = val
+#define DEBUGPRINT_SV_LEVEL(val0, var, level)                                                    \
+  do {                                                                                           \
+    if (maple::ast2mplDebug >= level) {                                                          \
+      PrintIndentation(maple::ast2mplDebugIndent);                                               \
+      std::cout << LOCATION << " " << val0 << ", " << #var << " = " << var << '\n';              \
+    }                                                                                            \
+  } while (0)
+
+#define DEBUGPRINT_SX_LEVEL(val0, var, level)                                                                      \
+  do {                                                                                                             \
+    if (maple::ast2mplDebug >= level) {                                                                            \
+      PrintIndentation(maple::ast2mplDebugIndent);                                                                 \
+      std::cout << LOCATION << " " << val0 << ", " << #var << " = " << std::hex << "0x" << var << std::dec         \
+                << '\n';                                                                                           \
+    }                                                                                                              \
+  } while (0)
+#else
+
+#define DUMPINFO(stmtClass, s)
+#define NOTHANDLED
+#define DEBUGPRINT_N(n)
+#define DEBUGPRINTIND(n)
+#define DEBUGPRINT_S_LEVEL(str, level)
+#define DEBUGPRINT_FUNC(name)
+#define DEBUGPRINT_FUNC_END(name)
+#define DEBUGPRINT_NODE(node, type)
+#define DEBUGPRINT_V_LEVEL(var, level)
+#define DEBUGPRINT_X_LEVEL(var, level)
+#define DEBUGPRINT_V_LEVEL_PURE(var, level)
+#define DEBUGPRINT_NN_LEVEL(var0, var1, level)
+#define DEBUGPRINT_VV_LEVEL(var0, var1, level)
+#define DEBUGPRINT_SV_LEVEL(val0, var, level)
+#endif
+
+#define DEBUGPRINT00 DEBUGPRINT_N(0)
+#define DEBUGPRINT01 DEBUGPRINT_N(1)
+#define DEBUGPRINT02 DEBUGPRINT_N(2)
+#define DEBUGPRINT03 DEBUGPRINT_N(3)
+
+#define DEBUGPRINT_S(var) DEBUGPRINT_S_LEVEL(var, 1)
+#define DEBUGPRINT_S2(var) DEBUGPRINT_S_LEVEL(var, 2)
+#define DEBUGPRINT_S3(var) DEBUGPRINT_S_LEVEL(var, 3)
+#define DEBUGPRINT_S4(var) DEBUGPRINT_S_LEVEL(var, 4)
+#define DEBUGPRINT_S5(var) DEBUGPRINT_S_LEVEL(var, 5)
+#define DEBUGPRINT_S6(var) DEBUGPRINT_S_LEVEL(var, 6)
+
+#define DEBUGPRINT0(var) DEBUGPRINT_V_LEVEL(var, 0)
+#define DEBUGPRINT(var) DEBUGPRINT_V_LEVEL(var, 1)
+#define DEBUGPRINT2(var) DEBUGPRINT_V_LEVEL(var, 2)
+#define DEBUGPRINT3(var) DEBUGPRINT_V_LEVEL(var, 3)
+#define DEBUGPRINT4(var) DEBUGPRINT_V_LEVEL(var, 4)
+#define DEBUGPRINT5(var) DEBUGPRINT_V_LEVEL(var, 5)
+#define DEBUGPRINT6(var) DEBUGPRINT_V_LEVEL(var, 6)
+
+#define DEBUGPRINT_X(var) DEBUGPRINT_X_LEVEL(var, 1)
+#define DEBUGPRINT_X2(var) DEBUGPRINT_X_LEVEL(var, 2)
+#define DEBUGPRINT_X3(var) DEBUGPRINT_X_LEVEL(var, 3)
+#define DEBUGPRINT_X4(var) DEBUGPRINT_X_LEVEL(var, 4)
+#define DEBUGPRINT_X5(var) DEBUGPRINT_X_LEVEL(var, 5)
+#define DEBUGPRINT_X6(var) DEBUGPRINT_X_LEVEL(var, 6)
+
+#define DEBUGPRINT_PURE(var) DEBUGPRINT_V_LEVEL_PURE(var, 1)
+#define DEBUGPRINT2_PURE(var) DEBUGPRINT_V_LEVEL_PURE(var, 2)
+#define DEBUGPRINT3_PURE(var) DEBUGPRINT_V_LEVEL_PURE(var, 3)
+#define DEBUGPRINT4_PURE(var) DEBUGPRINT_V_LEVEL_PURE(var, 4)
+#define DEBUGPRINT5_PURE(var) DEBUGPRINT_V_LEVEL_PURE(var, 5)
+#define DEBUGPRINT6_PURE(var) DEBUGPRINT_V_LEVEL_PURE(var, 6)
+
+#define DEBUGPRINT_NN(var0, var1) DEBUGPRINT_NN_LEVEL(var0, var1, 1)
+#define DEBUGPRINT_NN_2(var0, var1) DEBUGPRINT_NN_LEVEL(var0, var1, 2)
+#define DEBUGPRINT_NN_3(var0, var1) DEBUGPRINT_NN_LEVEL(var0, var1, 3)
+
+#define DEBUGPRINT_VV(var0, var1) DEBUGPRINT_VV_LEVEL(var0, var1, 1)
+#define DEBUGPRINT_VV_2(var0, var1) DEBUGPRINT_VV_LEVEL(var0, var1, 2)
+#define DEBUGPRINT_VV_3(var0, var1) DEBUGPRINT_VV_LEVEL(var0, var1, 3)
+
+#define DEBUGPRINT_SV(var0, var) DEBUGPRINT_SV_LEVEL(var0, var, 1)
+#define DEBUGPRINT_SV_2(var0, var) DEBUGPRINT_SV_LEVEL(var0, var, 2)
+#define DEBUGPRINT_SV_3(var0, var) DEBUGPRINT_SV_LEVEL(var0, var, 3)
+
+#define DEBUGPRINT_SX(var0, var) DEBUGPRINT_SX_LEVEL(var0, var, 1)
+#define DEBUGPRINT_SX_2(var0, var) DEBUGPRINT_SX_LEVEL(var0, var, 2)
+#define DEBUGPRINT_SX_3(var0, var) DEBUGPRINT_SX_LEVEL(var0, var, 3)
+
+// A: module->fileinfo,   B:"filename",
+// C: stridx,              D:module->fileinfo_isstring,  E:true;
+#define SET_INFO_PAIR(a, b, c, d, e)                               \
+  do {                                                             \
+    (a).emplace_back(builder->GetOrCreateStringIndex(b), c);       \
+    (d).emplace_back(e)                                            \
+  } while (0)
+} // namespace maple
+#endif  // AST2MPL_INCLUDE_ASTMACROS_H
diff --git a/src/hir2mpl/ast_input/clang/lib/ast_type.cpp b/src/hir2mpl/ast_input/clang/lib/ast_type.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5613458f5dcdcbce7373d487739e4773546aeca4
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/lib/ast_type.cpp
@@ -0,0 +1,615 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_macros.h"
+#include "ast_interface.h"
+#include "ast_util.h"
+#include "fe_manager.h"
+#include "fe_options.h"
+#include "driver_options.h"
+#include "triple.h"
+
+namespace maple {
+std::map<Loc, uint32> LibAstFile::unnamedLocMap;
+MIRType *LibAstFile::CvtPrimType(const clang::QualType qualType, bool isSourceType) const {
+  clang::QualType srcType = qualType.getCanonicalType();
+  if (srcType.isNull()) {
+    return nullptr;
+  }
+
+  MIRType *destType = nullptr;
+  if (llvm::isa<clang::BuiltinType>(srcType)) {
+    const auto *builtinType = llvm::cast<clang::BuiltinType>(srcType);
+    if (isSourceType) {
+      MIRType *sourceType = CvtPrimType2SourceType(builtinType->getKind());
+      if (sourceType != nullptr) {
+        return sourceType;
+      }
+    }
+    PrimType primType = CvtPrimType(builtinType->getKind(), isSourceType);
+    destType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(primType);
+  }
+  return destType;
+}
+
+MIRType *LibAstFile::CvtPrimType2SourceType(const clang::BuiltinType::Kind kind) const {
+  switch (kind) {
+    case clang::BuiltinType::ULong:
+      return FEManager::GetTypeManager().GetOrCreateTypeByNameType(kDbgULong);
+    case clang::BuiltinType::Long:
+      return FEManager::GetTypeManager().GetOrCreateTypeByNameType(kDbgLong);
+    case clang::BuiltinType::LongDouble:
+      return FEManager::GetTypeManager().GetOrCreateTypeByNameType(kDbgLongDouble);
+    default:
+      return nullptr;
+  }
+}
+
+PrimType LibAstFile::CvtPrimType(const clang::BuiltinType::Kind kind, bool isSourceType) const {
+  switch (kind) {
+    case clang::BuiltinType::Bool:
+      return PTY_u1;
+    case clang::BuiltinType::Char_U:
+      return (FEOptions::GetInstance().IsUseSignedChar() || isSourceType) ? PTY_i8 : PTY_u8;
+    case clang::BuiltinType::UChar:
+      return PTY_u8;
+    case clang::BuiltinType::WChar_U:
+      return (FEOptions::GetInstance().IsUseSignedChar() || isSourceType) ? PTY_i16 : PTY_u16;
+    case clang::BuiltinType::UShort:
+      return PTY_u16;
+    case clang::BuiltinType::UInt:
+      return PTY_u32;
+    case clang::BuiltinType::ULong:
+      return Triple::GetTriple().GetEnvironment() == Triple::GNUILP32 ? PTY_u32 : PTY_u64;
+    case clang::BuiltinType::ULongLong:
+      return PTY_u64;
+    case clang::BuiltinType::UInt128:
+      return PTY_u128;
+    case clang::BuiltinType::Char_S:
+    case clang::BuiltinType::SChar:
+      return PTY_i8;
+    case clang::BuiltinType::WChar_S:
+    case clang::BuiltinType::Short:
+    case clang::BuiltinType::Char16:
+      return PTY_i16;
+    case clang::BuiltinType::Char32:
+    case clang::BuiltinType::Int:
+      return PTY_i32;
+    case clang::BuiltinType::Long:
+      return Triple::GetTriple().GetEnvironment() == Triple::GNUILP32 ? PTY_i32 : PTY_i64;
+    case clang::BuiltinType::LongLong:
+      return PTY_i64;
+    case clang::BuiltinType::Int128:
+      return PTY_i128;
+    case clang::BuiltinType::Float:
+      return PTY_f32;
+    case clang::BuiltinType::Double:
+    case clang::BuiltinType::LongDouble:
+      return PTY_f64;
+    case clang::BuiltinType::Float128:
+      return PTY_f64;
+    case clang::BuiltinType::NullPtr: // default 64-bit, need to update
+      return PTY_a64;
+    case clang::BuiltinType::Half:    // PTY_f16, NOTYETHANDLED
+    case clang::BuiltinType::Float16:
+      CHECK_FATAL(false, "Float16 types not implemented yet");
+      return PTY_void;
+    case clang::BuiltinType::Void:
+    default:
+      return PTY_void;
+  }
+}
+
+bool LibAstFile::TypeHasMayAlias(const clang::QualType srcType) const {
+  auto *td = srcType->getAsTagDecl();
+  if (td != nullptr && td->hasAttr<clang::MayAliasAttr>()) {
+    return true;
+  }
+
+  clang::QualType qualType = srcType;
+  while (auto *tt = qualType->getAs<clang::TypedefType>()) {
+    if (tt->getDecl()->hasAttr<clang::MayAliasAttr>()) {
+      return true;
+    }
+    qualType = tt->desugar();
+  }
+
+  return false;
+}
+
+MIRType *LibAstFile::CvtTypedef(const clang::QualType &qualType) {
+  const clang::TypedefType *typedefType = llvm::dyn_cast<clang::TypedefType>(qualType);
+  if (typedefType == nullptr) {
+    return nullptr;
+  }
+  return CvtTypedefDecl(*typedefType->getDecl());
+}
+
+MIRType *LibAstFile::CvtTypedefDecl(const clang::TypedefNameDecl &typedefDecl) {
+  std::string typedefName = GetDeclName(typedefDecl, true);
+  MIRTypeByName *typdefType = nullptr;
+  clang::QualType underlyTy = typedefDecl.getCanonicalDecl()->getUnderlyingType();
+  MIRType *type = CvtType(underlyTy, true);
+  if (type != nullptr) {
+    typdefType = FEManager::GetTypeManager().CreateTypedef(typedefName, *type);
+  }
+  return typdefType;
+}
+
+MIRType *LibAstFile::CvtSourceType(const clang::QualType qualType) {
+  return CvtType(qualType, true);
+}
+
+MIRType *LibAstFile::CvtType(const clang::QualType qualType, bool isSourceType) {
+  clang::QualType srcType = qualType.getCanonicalType();
+  if (isSourceType) {
+    MIRType *nameType = CvtTypedef(qualType);
+    if (nameType != nullptr) {
+      return nameType;
+    }
+    srcType = qualType;
+  }
+  if (srcType.isNull()) {
+    return nullptr;
+  }
+
+  MIRType *destType = CvtPrimType(srcType, isSourceType);
+  if (destType != nullptr) {
+    return destType;
+  }
+
+  // handle pointer types
+  const clang::QualType srcPteType = srcType->getPointeeType();
+  if (!srcPteType.isNull()) {
+    MIRType *mirPointeeType = CvtType(srcPteType, isSourceType);
+    if (mirPointeeType == nullptr) {
+      return nullptr;
+    }
+
+    GenericAttrs genAttrs;
+    GetQualAttrs(srcPteType, genAttrs, isSourceType);
+    TypeAttrs attrs = genAttrs.ConvertToTypeAttrs();
+    // Get alignment from the pointee type
+    uint32 alignmentBits = astContext->getTypeAlignIfKnown(srcPteType);
+    if (alignmentBits != 0) {
+      if (alignmentBits > astContext->getTypeUnadjustedAlign(srcPteType)) {
+        attrs.SetAlign(alignmentBits / 8); // bits to byte
+      }
+    }
+    if (IsOneElementVector(srcPteType)) {
+      attrs.SetAttr(ATTR_oneelem_simd);
+    }
+
+    // Currently, only the pointer type is needed to handle may alias.
+    // The input parameter must be the raw pointee type.
+    if (TypeHasMayAlias(qualType->getPointeeType())) {
+      attrs.SetAttr(ATTR_may_alias);
+    }
+    // Variably Modified type is the type of a Variable Length Array. (C99 6.7.5)
+    // Convert the vla to a single-dimensional pointer, e.g. int(*)[N]
+    if (qualType->isVariablyModifiedType() && mirPointeeType->IsMIRPtrType()) {
+      static_cast<MIRPtrType*>(mirPointeeType)->SetTypeAttrs(attrs);
+      return mirPointeeType;
+    }
+    MIRType *prtType;
+    if (attrs == TypeAttrs()) {
+      prtType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirPointeeType);
+    } else {
+      prtType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirPointeeType, PTY_ptr, attrs);
+    }
+    return prtType;
+  }
+
+  return CvtOtherType(srcType, isSourceType);
+}
+
+MIRType *LibAstFile::CvtOtherType(const clang::QualType srcType, bool isSourceType) {
+  MIRType *destType = nullptr;
+  if (srcType->isArrayType()) {
+    destType = CvtArrayType(srcType, isSourceType);
+  } else if (srcType->isRecordType()) {
+    destType = CvtRecordType(srcType);
+  // isComplexType() does not include complex integers (a GCC extension)
+  } else if (srcType->isAnyComplexType()) {
+    destType = CvtComplexType(srcType);
+  } else if (srcType->isFunctionType()) {
+    destType = CvtFunctionType(srcType, isSourceType);
+  } else if (srcType->isEnumeralType()) {
+    destType = CvtEnumType(srcType, isSourceType);
+  } else if (srcType->isAtomicType()) {
+    const auto *atomicType = llvm::cast<clang::AtomicType>(srcType);
+    destType = CvtType(atomicType->getValueType());
+  } else if (srcType->isVectorType()) {
+    destType = CvtVectorType(srcType);
+  }
+  CHECK_FATAL(destType != nullptr, "unsuport type %s", srcType.getAsString().c_str());
+  return destType;
+}
+
+MIRType *LibAstFile::CvtEnumType(const clang::QualType &qualType, bool isSourceType) {
+  const clang::EnumType *enumTy = llvm::dyn_cast<clang::EnumType>(qualType.getCanonicalType());
+  CHECK_NULL_FATAL(enumTy);
+  clang::EnumDecl *enumDecl = enumTy->getDecl();
+  if (enumDecl->getDefinition() != nullptr) {
+    enumDecl = enumDecl->getDefinition();
+  }
+  MIRType *type;
+  if (isSourceType) {
+    auto itor = std::find(enumDecles.cbegin(), enumDecles.cend(), enumDecl);
+    if (itor == enumDecles.end()) {
+      (void)enumDecles.emplace_back(enumDecl);
+    }
+    std::string enumName = GetDeclName(*enumDecl, true);
+    MIRTypeByName *typdefType = FEManager::GetTypeManager().GetOrCreateTypeByNameType(enumName);
+    type = typdefType;
+  } else {
+    clang::QualType qt = enumDecl->getIntegerType();
+    type = CvtType(qt, isSourceType);
+  }
+  return type;
+}
+
+MIRType *LibAstFile::CvtRecordType(const clang::QualType qualType) {
+  clang::QualType srcType = qualType.getCanonicalType();
+  const auto *recordType = llvm::cast<clang::RecordType>(srcType);
+  clang::RecordDecl *recordDecl = recordType->getDecl();
+  if (!recordDecl->isLambda() && recordDeclSet.emplace(recordDecl).second) {
+    auto itor = std::find(recordDecles.cbegin(), recordDecles.cend(), recordDecl);
+    if (itor == recordDecles.end()) {
+      recordDecles.emplace_back(recordDecl);
+    }
+  }
+  MIRStructType *type = nullptr;
+  std::stringstream ss;
+  EmitTypeName(srcType, ss);
+  std::string name(ss.str());
+  if (!recordDecl->isDefinedOutsideFunctionOrMethod()) {
+    Loc l = GetLOC(recordDecl->getLocation());
+    std::stringstream ss;
+    ss << name << "_" << l.line << "_" << l.column;
+    name = ss.str();
+  }
+  type = FEManager::GetTypeManager().GetOrCreateStructType(name);
+  type->SetMIRTypeKind(srcType->isUnionType() ? kTypeUnion : kTypeStruct);
+  if (recordType->isIncompleteType()) {
+    type->SetMIRTypeKind(kTypeStructIncomplete);
+  }
+  return recordDecl->isLambda() ? GlobalTables::GetTypeTable().GetOrCreatePointerType(*type) : type;
+}
+
+MIRType *LibAstFile::CvtArrayType(const clang::QualType &srcType, bool isSourceType) {
+  MIRType *elemType = nullptr;
+  TypeAttrs elemAttrs;
+  std::vector<uint32_t> operands;
+  uint8_t dim = 0;
+  if (srcType->isConstantArrayType()) {
+    CollectBaseEltTypeAndSizesFromConstArrayDecl(srcType, elemType, elemAttrs, operands, isSourceType);
+    ASSERT(operands.size() < kMaxArrayDim, "The max array dimension is kMaxArrayDim");
+    dim = static_cast<uint8_t>(operands.size());
+  } else if (srcType->isIncompleteArrayType()) {
+    const clang::ArrayType *arrType = srcType->getAsArrayTypeUnsafe();
+    const auto *inArrType = llvm::cast<clang::IncompleteArrayType>(arrType);
+    CollectBaseEltTypeAndSizesFromConstArrayDecl(
+        inArrType->getElementType(), elemType, elemAttrs, operands, isSourceType);
+    dim = static_cast<uint8_t>(operands.size());
+    ASSERT(operands.size() < kMaxArrayDim, "The max array dimension is kMaxArrayDim");
+  } else if (srcType->isVariableArrayType()) {
+    CollectBaseEltTypeAndDimFromVariaArrayDecl(srcType, elemType, elemAttrs, dim, isSourceType);
+  } else if (srcType->isDependentSizedArrayType()) {
+    CollectBaseEltTypeAndDimFromDependentSizedArrayDecl(srcType, elemType, elemAttrs, operands, isSourceType);
+    ASSERT(operands.size() < kMaxArrayDim, "The max array dimension is kMaxArrayDim");
+    dim = static_cast<uint8_t>(operands.size());
+  } else {
+    NOTYETHANDLED(srcType.getAsString().c_str());
+  }
+  uint32_t *sizeArray = nullptr;
+  uint32_t tempSizeArray[kMaxArrayDim];
+  MIRType *retType = nullptr;
+  if (dim > 0) {
+    CHECK_NULL_FATAL(elemType);
+    if (!srcType->isVariableArrayType()) {
+      for (uint8_t k = 0; k < dim; ++k) {
+        tempSizeArray[k] = operands[k];
+      }
+      sizeArray = tempSizeArray;
+      retType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*elemType, dim, sizeArray, elemAttrs);
+    } else {
+      retType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType, PTY_ptr, elemAttrs);
+    }
+  } else {
+    bool asFlag = srcType->isIncompleteArrayType();
+    CHECK_FATAL(asFlag, "Incomplete Array Type");
+    retType = elemType;
+  }
+
+  if (srcType->isIncompleteArrayType()) {
+    // For an incomplete array type, assume a length of 1. If enable MIRFarrayType, delete ATTR_incomplete_array
+    elemAttrs.SetAttr(ATTR_incomplete_array);
+    retType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*retType, 1, elemAttrs);
+  }
+  return retType;
+}
+
+MIRType *LibAstFile::CvtComplexType(const clang::QualType srcType) const {
+  clang::QualType srcElemType = llvm::cast<clang::ComplexType>(srcType)->getElementType();
+  MIRType *destElemType = CvtPrimType(srcElemType);
+  CHECK_NULL_FATAL(destElemType);
+  return FEManager::GetTypeManager().GetOrCreateComplexStructType(*destElemType);
+}
+
+MIRType *LibAstFile::CvtFunctionType(const clang::QualType srcType, bool isSourceType) {
+  const auto *funcType = srcType.getTypePtr()->castAs<clang::FunctionType>();
+  CHECK_NULL_FATAL(funcType);
+  MIRType *retType = CvtType(funcType->getReturnType(), isSourceType);
+  std::vector<TyIdx> argsVec;
+  std::vector<TypeAttrs> attrsVec;
+  bool isFirstArgRet = false;
+  const clang::QualType &retQualType = funcType->getReturnType().getCanonicalType();
+  // setup first_arg_retrun if ret struct size > 16
+  if (!isSourceType && retQualType->isRecordType()) {
+    const auto *recordType = llvm::cast<clang::RecordType>(retQualType);
+    clang::RecordDecl *recordDecl = recordType->getDecl();
+    const clang::ASTRecordLayout &layout = astContext->getASTRecordLayout(recordDecl->getDefinition());
+    const unsigned twoByteSize = 16;
+    if (layout.getSize().getQuantity() > twoByteSize) {
+      MIRType *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*retType);
+      GenericAttrs genAttrs;
+      if (IsOneElementVector(retQualType)) {
+        genAttrs.SetAttr(GENATTR_oneelem_simd);
+      }
+      attrsVec.push_back(genAttrs.ConvertToTypeAttrs());
+      argsVec.push_back(ptrType->GetTypeIndex());
+      retType = GlobalTables::GetTypeTable().GetVoid();
+      isFirstArgRet = true;
+    }
+  }
+  if (funcType->isFunctionProtoType()) {
+    const auto *funcProtoType = funcType->castAs<clang::FunctionProtoType>();
+    using ItType = clang::FunctionProtoType::param_type_iterator;
+    for (ItType it = funcProtoType->param_type_begin(); it != funcProtoType->param_type_end(); ++it) {
+      clang::QualType protoQualType = *it;
+      argsVec.push_back(CvtType(protoQualType, isSourceType)->GetTypeIndex());
+      GenericAttrs genAttrs;
+      // collect storage class, access, and qual attributes
+      // ASTCompiler::GetSClassAttrs(SC_Auto, genAttrs); -- no-op
+      // ASTCompiler::GetAccessAttrs(genAttrs); -- no-op for params
+      GetCVRAttrs(protoQualType.getCVRQualifiers(), genAttrs);
+      if (IsOneElementVector(protoQualType)) {
+        genAttrs.SetAttr(GENATTR_oneelem_simd);
+      }
+      attrsVec.push_back(genAttrs.ConvertToTypeAttrs());
+    }
+    // The 'void' is allowed only as a single parameter to a function with no other parameters (C99 6.7.5.3p10).
+    // e.g. 'int foo(void)'. But parameter list of FunctionProtoType is empty.
+    // The void parameter source type is needs to be recorded in the debuginfo.
+    if (isSourceType && argsVec.empty()) {
+      argsVec.push_back(GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex());
+    }
+  }
+  MIRType *mirFuncType = GlobalTables::GetTypeTable().GetOrCreateFunctionType(
+      retType->GetTypeIndex(), argsVec, attrsVec);
+  if (isFirstArgRet) {
+    static_cast<MIRFuncType*>(mirFuncType)->SetFirstArgReturn();
+  }
+  return GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirFuncType);
+}
+
+
+void LibAstFile::CollectBaseEltTypeAndSizesFromConstArrayDecl(const clang::QualType &currQualType, MIRType *&elemType,
+                                                              TypeAttrs &elemAttr, std::vector<uint32_t> &operands,
+                                                              bool isSourceType) {
+  if (isSourceType) {
+    MIRType *nameType = CvtTypedef(currQualType);
+    if (nameType != nullptr) {
+      elemType = nameType;
+      return;
+    }
+  }
+  const clang::Type *ptrType = currQualType.getTypePtrOrNull();
+  ASSERT(ptrType != nullptr, "Null type", currQualType.getAsString().c_str());
+  if (ptrType->isArrayType()) {
+    const clang::ArrayType *arrType = ptrType->getAsArrayTypeUnsafe();
+    ASSERT(arrType->isConstantArrayType(), "Must be a ConstantArrayType", currQualType.getAsString().c_str());
+    const auto *constArrayType = llvm::dyn_cast<clang::ConstantArrayType>(arrType);
+    ASSERT(constArrayType != nullptr, "ERROR : null pointer!");
+    llvm::APInt size = constArrayType->getSize();
+    ASSERT(size.getSExtValue() >= 0, "Array Size must be positive or zero", currQualType.getAsString().c_str());
+    operands.push_back(size.getSExtValue());
+    CollectBaseEltTypeAndSizesFromConstArrayDecl(constArrayType->getElementType(), elemType, elemAttr, operands,
+                                                 isSourceType);
+  } else {
+    CollectBaseEltTypeFromArrayDecl(currQualType, elemType, elemAttr, isSourceType);
+  }
+}
+
+void LibAstFile::CollectBaseEltTypeAndDimFromVariaArrayDecl(const clang::QualType &currQualType, MIRType *&elemType,
+                                                            TypeAttrs &elemAttr, uint8_t &dim, bool isSourceType) {
+  if (isSourceType) {
+    MIRType *nameType = CvtTypedef(currQualType);
+    if (nameType != nullptr) {
+      elemType = nameType;
+      return;
+    }
+  }
+  const clang::Type *ptrType = currQualType.getTypePtrOrNull();
+  ASSERT(ptrType != nullptr, "Null type", currQualType.getAsString().c_str());
+  if (ptrType->isArrayType()) {
+    const auto *arrayType = ptrType->getAsArrayTypeUnsafe();
+    CollectBaseEltTypeAndDimFromVariaArrayDecl(arrayType->getElementType(), elemType, elemAttr, dim, isSourceType);
+    ++dim;
+  } else {
+    CollectBaseEltTypeFromArrayDecl(currQualType, elemType, elemAttr, isSourceType);
+  }
+}
+
+void LibAstFile::CollectBaseEltTypeAndDimFromDependentSizedArrayDecl(
+    const clang::QualType currQualType, MIRType *&elemType, TypeAttrs &elemAttr, std::vector<uint32_t> &operands,
+    bool isSourceType) {
+  if (isSourceType) {
+    MIRType *nameType = CvtTypedef(currQualType);
+    if (nameType != nullptr) {
+      elemType = nameType;
+      return;
+    }
+  }
+  const clang::Type *ptrType = currQualType.getTypePtrOrNull();
+  ASSERT(ptrType != nullptr, "ERROR:null pointer!");
+  if (ptrType->isArrayType()) {
+    const auto *arrayType = ptrType->getAsArrayTypeUnsafe();
+    ASSERT(arrayType != nullptr, "ERROR:null pointer!");
+    // variable sized
+    operands.push_back(0);
+    CollectBaseEltTypeAndDimFromDependentSizedArrayDecl(arrayType->getElementType(), elemType, elemAttr, operands,
+                                                        isSourceType);
+  } else {
+    CollectBaseEltTypeFromArrayDecl(currQualType, elemType, elemAttr, isSourceType);
+  }
+}
+
+void LibAstFile::CollectBaseEltTypeFromArrayDecl(const clang::QualType &currQualType,
+                                                 MIRType *&elemType, TypeAttrs &elemAttr, bool isSourceType) {
+  elemType = CvtType(currQualType, isSourceType);
+  // Get alignment from the element type
+  uint32 alignmentBits = astContext->getTypeAlignIfKnown(currQualType);
+  if (alignmentBits != 0) {
+    if (alignmentBits > astContext->getTypeUnadjustedAlign(currQualType)) {
+      elemAttr.SetAlign(alignmentBits / 8); // bits to byte
+    }
+  }
+  if (IsOneElementVector(currQualType)) {
+    elemAttr.SetAttr(ATTR_oneelem_simd);
+  }
+}
+
+MIRType *LibAstFile::CvtVectorType(const clang::QualType srcType) {
+  const auto *vectorType = llvm::cast<clang::VectorType>(srcType);
+  MIRType *elemType = CvtType(vectorType->getElementType());
+  unsigned numElems = vectorType->getNumElements();
+  MIRType *destType = nullptr;
+  switch (elemType->GetPrimType()) {
+    case PTY_i64:
+      if (numElems == 1) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_i64);
+      } else if (numElems == 2) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v2i64);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    case PTY_i32:
+      if (numElems == 1) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_i64);
+      } else if (numElems == 2) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v2i32);
+      } else if (numElems == 4) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v4i32);
+      } else if (numElems == 8) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v8i16);
+      } else if (numElems == 16) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v16i8);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    case PTY_i16:
+      if (numElems == 4) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v4i16);
+      } else if (numElems == 8) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v8i16);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    case PTY_i8:
+      if (numElems == 8) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v8i8);
+      } else if (numElems == 16) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v16i8);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    case PTY_u64:
+      if (numElems == 1) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_u64);
+      } else if (numElems == 2) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v2u64);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    case PTY_u32:
+      if (numElems == 2) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v2u32);
+      } else if (numElems == 4) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v4u32);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    case PTY_u16:
+      if (numElems == 4) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v4u16);
+      } else if (numElems == 8) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v8u16);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    case PTY_u8:
+      if (numElems == 8) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v8u8);
+      } else if (numElems == 16) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v16u8);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    case PTY_f64:
+      if (numElems == 1) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_f64);
+      } else if (numElems == 2) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v2f64);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    case PTY_f32:
+      if (numElems == 2) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v2f32);
+      } else if (numElems == 4) {
+        destType = GlobalTables::GetTypeTable().GetPrimType(PTY_v4f32);
+      } else {
+        CHECK_FATAL(false, "Unsupported vector type");
+      }
+      break;
+    default:
+      CHECK_FATAL(false, "Unsupported vector type");
+      break;
+  }
+  return destType;
+}
+
+bool LibAstFile::IsOneElementVector(const clang::QualType &qualType) {
+  return IsOneElementVector(*qualType.getTypePtr());
+}
+
+bool LibAstFile::IsOneElementVector(const clang::Type &type) {
+  const clang::VectorType *vectorType = llvm::dyn_cast<clang::VectorType>(type.getUnqualifiedDesugaredType());
+  if (vectorType != nullptr && vectorType->getNumElements() == 1) {
+    return true;
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/ast_input/clang/lib/ast_util.cpp b/src/hir2mpl/ast_input/clang/lib/ast_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2759e5cf443f9b82d380fef7f0449e2fec8ad527
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/lib/ast_util.cpp
@@ -0,0 +1,346 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "ast_util.h"
+#include "clang/AST/AST.h"
+#include "clang/Serialization/ASTDeserializationListener.h"
+#include "mir_nodes.h"
+#include "mir_builder.h"
+#include "ast_macros.h"
+#include "fe_utils_ast.h"
+
+namespace maple {
+int ast2mplDebug = 0;
+int ast2mplDebugIndent = 0;
+uint32_t ast2mplOption = kCheckAssertion;
+const char *checkFuncName = nullptr;
+
+void ASTUtil::AdjIndent(int n) {
+  ast2mplDebugIndent += n;
+}
+
+void ASTUtil::SetIndent(int n) {
+  ast2mplDebugIndent = n;
+}
+
+bool ASTUtil::ValidInName(char c) {
+  return isalnum(c) || (c == '_' || c == '|' || c == ';' || c == '/' || c == '$');
+}
+
+bool ASTUtil::IsValidName(const std::string &name) {
+  for (size_t i = 0; i < name.length(); ++i) {
+    if (!ValidInName(name[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool ASTUtil::IsSignedType(const MIRType &type) {
+  PrimType primType = type.GetPrimType();
+  if (primType == PTY_i8 || primType == PTY_i16 || primType == PTY_i32 || primType == PTY_i64) {
+    return true;
+  }
+  return false;
+}
+
+void ASTUtil::AdjustName(std::string &name) {
+  for (size_t i = 0; name[i] != '\0'; ++i) {
+    char c = name[i];
+    if (ASTUtil::ValidInName(c)) {
+      name[i] = c;
+      continue;
+    }
+    switch (c) {
+      case '(':
+      case ')':
+      case '<':
+      case '>':
+      case '-':
+      case ' ':
+        name[i] = '_';
+        break;
+      case '[':
+        name[i] = 'A';
+        break;
+      case ']':
+        name[i] = 'B';
+        break;
+      default:
+        name[i] = '$';
+        break;
+    }
+  }
+}
+
+std::string ASTUtil::GetAdjustVarName(const std::string &name, uint32_t &num) {
+  std::stringstream ss;
+  ss << name << "." << num;
+
+  DEBUGPRINT2(ss.str());
+  ++num;
+  return ss.str();
+}
+
+std::string ASTUtil::GetNameWithSuffix(const std::string &origName, const std::string &suffix) {
+  std::stringstream ss;
+  ss << origName << suffix;
+
+  return ss.str();
+}
+
+Opcode ASTUtil::CvtBinaryOpcode(uint32_t opcode, PrimType pty) {
+  switch (opcode) {
+    case clang::BO_Mul:
+      return OP_mul;    // "*"
+    case clang::BO_Div:
+      return OP_div;    // "/"
+    case clang::BO_Rem:
+      return OP_rem;    // "%"
+    case clang::BO_Add:
+      return OP_add;    // "+"
+    case clang::BO_Sub:
+      return OP_sub;    // "-"
+    case clang::BO_Shl:
+      return OP_shl;    // "<<"
+    case clang::BO_Shr:
+      return IsUnsignedInteger(pty) ? OP_lshr : OP_ashr;   // ">>"
+    case clang::BO_LT:
+      return OP_lt;     // "<"
+    case clang::BO_GT:
+      return OP_gt;     // ">"
+    case clang::BO_LE:
+      return OP_le;     // "<="
+    case clang::BO_GE:
+      return OP_ge;     // ">="
+    case clang::BO_EQ:
+      return OP_eq;     // "=="
+    case clang::BO_NE:
+      return OP_ne;     // "!="
+    case clang::BO_And:
+      return OP_band;   // "&"
+    case clang::BO_Xor:
+      return OP_bxor;   // "^"
+    case clang::BO_Or:
+      return OP_bior;   // "|"
+    case clang::BO_LAnd:
+      return OP_cand;   // "&&"
+    case clang::BO_LOr:
+      return OP_cior;   // "||"
+    default:
+      return OP_undef;
+  }
+}
+
+// these do not have equivalent opcode in mapleir
+Opcode ASTUtil::CvtBinaryAssignOpcode(uint32_t opcode) {
+  switch (opcode) {
+    case clang::BO_Assign:
+      return OP_eq;     // "="
+    case clang::BO_MulAssign:
+      return OP_mul;    // "*="
+    case clang::BO_DivAssign:
+      return OP_div;    // "/="
+    case clang::BO_RemAssign:
+      return OP_rem;    // "%="
+    case clang::BO_AddAssign:
+      return OP_add;    // "+="
+    case clang::BO_SubAssign:
+      return OP_sub;    // "-="
+    case clang::BO_ShlAssign:
+      return OP_shl;    // "<<="
+    case clang::BO_ShrAssign:
+      return OP_lshr;   // ">>="
+    case clang::BO_AndAssign:
+      return OP_band;   // "&="
+    case clang::BO_XorAssign:
+      return OP_bxor;   // "^="
+    case clang::BO_OrAssign:
+      return OP_bior;   // "|="
+    case clang::BO_Comma:
+      return OP_undef;  // ","
+    case clang::BO_PtrMemD:
+      return OP_undef;  // ".*"
+    case clang::BO_PtrMemI:
+      return OP_undef;  // "->*"
+    default:
+      return OP_undef;
+  }
+}
+
+Opcode ASTUtil::CvtUnaryOpcode(uint32_t opcode) {
+  switch (opcode) {
+    case clang::UO_Minus:
+      return OP_neg;    // "-"
+    case clang::UO_Not:
+      return OP_bnot;   // "~"
+    case clang::UO_LNot:
+      return OP_lnot;   // "!"
+    case clang::UO_PostInc:
+      return OP_add;    // "++"
+    case clang::UO_PostDec:
+      return OP_sub;    // "--"
+    case clang::UO_PreInc:
+      return OP_add;    // "++"
+    case clang::UO_PreDec:
+      return OP_sub;    // "--"
+    case clang::UO_AddrOf:
+      return OP_addrof; // "&"
+    case clang::UO_Deref:
+      return OP_undef;  // "*"
+    case clang::UO_Plus:
+      return OP_undef;  // "+"
+    case clang::UO_Real:
+      return OP_undef;  // "__real"
+    case clang::UO_Imag:
+      return OP_undef;  // "__imag"
+    case clang::UO_Extension:
+      return OP_undef;  // "__extension__"
+    case clang::UO_Coawait:
+      return OP_undef;  // "co_await"
+    default:
+      CHECK_FATAL(false, "NYI ASTUtil::CvtUnaryOpcode", opcode);
+  }
+}
+
+uint32 ASTUtil::GetDim(MIRType &type) {
+  MIRType *ptrType = &type;
+  if (type.GetKind() == kTypePointer) {
+    auto *ptr = static_cast<MIRPtrType*>(&type);
+    ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptr->GetPointedTyIdx());
+  }
+  uint32 dim = 0;
+  while (ptrType->GetKind() == kTypeArray) {
+    auto *array = static_cast<MIRArrayType*>(ptrType);
+    ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(array->GetElemTyIdx());
+    if (ptrType->GetKind() == kTypePointer) {
+      auto *ptr = static_cast<MIRPtrType*>(ptrType);
+      ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptr->GetPointedTyIdx());
+    }
+    ++dim;
+  }
+
+  DEBUGPRINT2(dim);
+  return dim;
+}
+
+std::string ASTUtil::GetTypeString(MIRType &type) {
+  std::stringstream ss;
+  if (ast2mplDebug > kDebugLevelThree) {
+    type.Dump(1);
+  }
+  switch (type.GetKind()) {
+    case kTypeScalar:
+      ss << FEUtilAST::Type2Label(type.GetPrimType());
+      break;
+    case kTypeStruct:
+    case kTypeClass:
+    case kTypeInterface:
+    case kTypeBitField:
+    case kTypeByName:
+    case kTypeParam: {
+      ss << GlobalTables::GetStrTable().GetStringFromStrIdx(type.GetNameStrIdx()).c_str() << ";";
+      break;
+    }
+    case kTypeArray: {
+      auto &array = static_cast<MIRArrayType&>(type);
+      MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(array.GetElemTyIdx());
+      uint32 dim = GetDim(type);
+      for (size_t i = 0; i < dim; ++i) {
+        ss << 'A';
+      }
+      ss << GetTypeString(*elemType);
+      break;
+    }
+    case kTypePointer: {
+      auto &ptr = static_cast<MIRPtrType&>(type);
+      MIRType *pType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptr.GetPointedTyIdx());
+      ss << "P";
+      std::string str = GetTypeString(*pType);
+      ss << str;
+      break;
+    }
+    default:
+      break;
+  }
+
+  return ss.str();
+}
+
+void ASTUtil::DumpMplTypes() {
+  uint32 size = static_cast<uint32>(GlobalTables::GetTypeTable().GetTypeTableSize());
+  DEBUGPRINT(size);
+  DEBUGPRINT_S(" dump type table ");
+  for (uint32 i = 1; i < size; ++i) {
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeTable()[i];
+    std::string name = GlobalTables::GetStrTable().GetStringFromStrIdx(type->GetNameStrIdx());
+    (void)printf("%-4u %4u %s\n", i, type->GetNameStrIdx().GetIdx(), name.c_str());
+  }
+  DEBUGPRINT_S(" end dump type table ");
+}
+
+void ASTUtil::DumpMplStrings() {
+  size_t size = GlobalTables::GetStrTable().StringTableSize();
+  DEBUGPRINT(size);
+  DEBUGPRINT_S(" dump string table ");
+  for (size_t i = 1; i < size; ++i) {
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeTable()[i];
+    const std::string &str = GlobalTables::GetStrTable().GetStringFromStrIdx(type->GetNameStrIdx());
+    (void)printf("%-4d %4d %s\n", static_cast<int>(i), static_cast<int>(str.length()), str.c_str());
+  }
+  DEBUGPRINT_S(" end dump string table ");
+}
+
+bool ASTUtil::IsVoidPointerType(const TyIdx &tyIdx) {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  auto *ptr = static_cast<MIRPtrType*>(type);
+  type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptr->GetPointedTyIdx());
+  if (type->GetPrimType() == PTY_void) {
+    return true;
+  }
+  return false;
+}
+
+std::string ASTUtil::AdjustFuncName(std::string funcName) {
+  std::size_t found = funcName.find('\"');
+  const std::size_t offsetByTwoChar = 2;  // skip the replaced char
+  while (found != std::string::npos) {
+    (void)funcName.replace(found, 1, "\\\"");
+    found += offsetByTwoChar;
+    found = funcName.find('\"', found);
+  }
+  return funcName;
+}
+
+bool ASTUtil::InsertFuncSet(const GStrIdx &idx) {
+  static std::set<GStrIdx> funcIdxSet;
+  return funcIdxSet.insert(idx).second;
+}
+
+bool ASTUtil::HasTypdefType(clang::QualType qualType) {
+  if (llvm::isa<clang::TypedefType>(qualType)) {
+    return true;
+  }
+  auto pointerType = llvm::dyn_cast<clang::PointerType>(qualType);
+  if (pointerType != nullptr) {
+    return HasTypdefType(qualType->getPointeeType());
+  }
+  const auto *arrayType = llvm::dyn_cast<clang::ArrayType>(qualType);
+  if (arrayType != nullptr) {
+    return HasTypdefType(arrayType->getElementType());
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/ast_input/clang/lib/ast_util.h b/src/hir2mpl/ast_input/clang/lib/ast_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..af364ffe73c1765f184cb1666bb794b7ca3875e4
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/lib/ast_util.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef AST2MPL_INCLUDE_ASTUTIL_H
+#define AST2MPL_INCLUDE_ASTUTIL_H
+#include "clang/AST/AST.h"
+#include "clang/AST/RecordLayout.h"
+#include "mir_type.h"
+#include "ast_macros.h"
+
+namespace maple {
+extern int ast2mplDebug;
+extern int ast2mplDebugIndent;
+extern uint32_t ast2mplOption;
+extern const char *checkFuncName;
+
+class ASTUtil {
+ public:
+  static const int opcodeNameLength = 228;
+  static const char *opcodeName[opcodeNameLength];
+  static void AdjIndent(int n);
+  static void SetIndent(int n);
+  static bool ValidInName(char c);
+  static bool IsValidName(const std::string &name);
+  static bool IsSignedType(const MIRType &type);
+  static void AdjustName(std::string &name);
+  static std::string GetAdjustVarName(const std::string &name, uint32_t &num);
+  static std::string GetNameWithSuffix(const std::string &origName, const std::string &suffix);
+
+  static void DumpMplStrings();
+  static void DumpMplTypes();
+
+  static uint32 GetDim(MIRType &type);
+  static std::string GetTypeString(MIRType &type);
+  static Opcode CvtUnaryOpcode(uint32_t opcode);
+  static Opcode CvtBinaryOpcode(uint32_t opcode, PrimType pty = PTY_begin);
+  static Opcode CvtBinaryAssignOpcode(uint32_t opcode);
+
+  static bool IsVoidPointerType(const TyIdx &tyIdx);
+  static std::string AdjustFuncName(std::string funcName);
+  static bool InsertFuncSet(const GStrIdx &idx);
+  static bool HasTypdefType(clang::QualType qualType);
+
+  template <typename Range, typename Value = typename Range::value_type>
+  static std::string Join(const Range &elements, const char *delimiter) {
+    std::ostringstream os;
+    auto b = begin(elements);
+    auto e = end(elements);
+    if (b != e) {
+      std::copy(b, prev(e), std::ostream_iterator<Value>(os, delimiter));
+      b = prev(e);
+    }
+    if (b != e) {
+      os << *b;
+    }
+    return os.str();
+  }
+};
+}  // namespace maple
+#endif  // AST2MPL_INCLUDE_ASTUTIL_H_
diff --git a/src/hir2mpl/ast_input/clang/lib/sys/arm_neon.h b/src/hir2mpl/ast_input/clang/lib/sys/arm_neon.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4942b09fb34819e9cfbb5c4aabcfa7ae1c725f4
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/lib/sys/arm_neon.h
@@ -0,0 +1,1435 @@
+/*===---- arm_neon.h - ARM Neon intrinsics ---------------------------------===
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_NEON_H
+#define __ARM_NEON_H
+
+#include <stdint.h>
+
+typedef float float32_t;
+#ifdef __aarch64__
+typedef double float64_t;
+#endif
+
+typedef __attribute__((neon_vector_type(8))) int8_t int8x8_t;
+typedef __attribute__((neon_vector_type(16))) int8_t int8x16_t;
+typedef __attribute__((neon_vector_type(4))) int16_t int16x4_t;
+typedef __attribute__((neon_vector_type(8))) int16_t int16x8_t;
+typedef __attribute__((neon_vector_type(2))) int32_t int32x2_t;
+typedef __attribute__((neon_vector_type(4))) int32_t int32x4_t;
+typedef __attribute__((neon_vector_type(1))) int64_t int64x1_t;
+typedef __attribute__((neon_vector_type(2))) int64_t int64x2_t;
+typedef __attribute__((neon_vector_type(8))) uint8_t uint8x8_t;
+typedef __attribute__((neon_vector_type(16))) uint8_t uint8x16_t;
+typedef __attribute__((neon_vector_type(4))) uint16_t uint16x4_t;
+typedef __attribute__((neon_vector_type(8))) uint16_t uint16x8_t;
+typedef __attribute__((neon_vector_type(2))) uint32_t uint32x2_t;
+typedef __attribute__((neon_vector_type(4))) uint32_t uint32x4_t;
+typedef __attribute__((neon_vector_type(1))) uint64_t uint64x1_t;
+typedef __attribute__((neon_vector_type(2))) uint64_t uint64x2_t;
+typedef __attribute__((neon_vector_type(2))) float32_t float32x2_t;
+typedef __attribute__((neon_vector_type(4))) float32_t float32x4_t;
+#ifdef __aarch64__
+typedef __attribute__((neon_vector_type(1))) float64_t float64x1_t;
+typedef __attribute__((neon_vector_type(2))) float64_t float64x2_t;
+#endif
+
+typedef struct int8x8x2_t {
+  int8x8_t val[2];
+} int8x8x2_t;
+
+typedef struct int16x4x2_t {
+  int16x4_t val[2];
+} int16x4x2_t;
+
+typedef struct int32x2x2_t {
+  int32x2_t val[2];
+} int32x2x2_t;
+
+typedef struct uint8x8x2_t {
+  uint8x8_t val[2];
+} uint8x8x2_t;
+
+typedef struct uint16x4x2_t {
+  uint16x4_t val[2];
+} uint16x4x2_t;
+
+typedef struct uint32x2x2_t {
+  uint32x2_t val[2];
+} uint32x2x2_t;
+
+typedef struct float32x2x2_t {
+  float32x2_t val[2];
+} float32x2x2_t;
+
+// vecTy vector_abs(vecTy src)
+//     Create a vector by getting the absolute value of the elements in src.
+int8x8_t __builtin_mpl_vector_abs_v8i8(int8x8_t);
+int16x4_t __builtin_mpl_vector_abs_v4i16(int16x4_t);
+int32x2_t __builtin_mpl_vector_abs_v2i32(int32x2_t);
+int64x1_t __builtin_mpl_vector_abs_v1i64(int64x1_t);
+float32x2_t __builtin_mpl_vector_abs_v2f32(float32x2_t);
+float64x1_t __builtin_mpl_vector_abs_v1f64(float64x1_t);
+int8x16_t __builtin_mpl_vector_abs_v16i8(int8x16_t);
+int16x8_t __builtin_mpl_vector_abs_v8i16(int16x8_t);
+int32x4_t __builtin_mpl_vector_abs_v4i32(int32x4_t);
+int64x2_t __builtin_mpl_vector_abs_v2i64(int64x2_t);
+float32x4_t __builtin_mpl_vector_abs_v4f32(float32x4_t);
+float64x2_t __builtin_mpl_vector_abs_v2f64(float64x2_t);
+
+// vecTy vector_mov_narrow(vecTy src)
+//     copies each element of the operand vector to the corresponding element of the destination vector.
+//     The result element is half the width of the operand element, and values are saturated to the result width.
+//     The results are the same type as the operands.
+uint8x8_t __builtin_mpl_vector_mov_narrow_v8u16(uint16x8_t);
+uint16x4_t __builtin_mpl_vector_mov_narrow_v4u32(uint32x4_t);
+uint32x2_t __builtin_mpl_vector_mov_narrow_v2u64(uint64x2_t);
+int8x8_t __builtin_mpl_vector_mov_narrow_v8i16(int16x8_t);
+int16x4_t __builtin_mpl_vector_mov_narrow_v4i32(int32x4_t);
+int32x2_t __builtin_mpl_vector_mov_narrow_v2i64(int64x2_t);
+
+// vecTy vector_addl_low(vecTy src1, vecTy src2)
+//     Add each element of the source vector to second source
+//     widen the result into the destination vector.
+int16x8_t __builtin_mpl_vector_addl_low_v8i8(int8x8_t, int8x8_t);
+int32x4_t __builtin_mpl_vector_addl_low_v4i16(int16x4_t, int16x4_t);
+int64x2_t __builtin_mpl_vector_addl_low_v2i32(int32x2_t, int32x2_t);
+uint16x8_t __builtin_mpl_vector_addl_low_v8u8(uint8x8_t, uint8x8_t);
+uint32x4_t __builtin_mpl_vector_addl_low_v4u16(uint16x4_t, uint16x4_t);
+uint64x2_t __builtin_mpl_vector_addl_low_v2u32(uint32x2_t, uint32x2_t);
+
+// vecTy vector_addl_high(vecTy src1, vecTy src2)
+//     Add each element of the source vector to upper half of second source
+//     widen the result into the destination vector.
+int16x8_t __builtin_mpl_vector_addl_high_v8i8(int8x16_t, int8x16_t);
+int32x4_t __builtin_mpl_vector_addl_high_v4i16(int16x8_t, int16x8_t);
+int64x2_t __builtin_mpl_vector_addl_high_v2i32(int32x4_t, int32x4_t);
+uint16x8_t __builtin_mpl_vector_addl_high_v8u8(uint8x16_t, uint8x16_t);
+uint32x4_t __builtin_mpl_vector_addl_high_v4u16(uint16x8_t, uint16x8_t);
+uint64x2_t __builtin_mpl_vector_addl_high_v2u32(uint32x4_t, uint32x4_t);
+
+// vecTy vector_addw_low(vecTy src1, vecTy src2)
+//     Add each element of the source vector to second source
+//     widen the result into the destination vector.
+int16x8_t __builtin_mpl_vector_addw_low_v8i8(int16x8_t, int8x8_t);
+int32x4_t __builtin_mpl_vector_addw_low_v4i16(int32x4_t, int16x4_t);
+int64x2_t __builtin_mpl_vector_addw_low_v2i32(int64x2_t, int32x2_t);
+uint16x8_t __builtin_mpl_vector_addw_low_v8u8(uint16x8_t, uint8x8_t);
+uint32x4_t __builtin_mpl_vector_addw_low_v4u16(uint32x4_t, uint16x4_t);
+uint64x2_t __builtin_mpl_vector_addw_low_v2u32(uint64x2_t, uint32x2_t);
+
+// vecTy vector_addw_high(vecTy src1, vecTy src2)
+//     Add each element of the source vector to upper half of second source
+//     widen the result into the destination vector.
+int16x8_t __builtin_mpl_vector_addw_high_v8i8(int16x8_t, int8x16_t);
+int32x4_t __builtin_mpl_vector_addw_high_v4i16(int32x4_t, int16x8_t);
+int64x2_t __builtin_mpl_vector_addw_high_v2i32(int64x2_t, int32x4_t);
+uint16x8_t __builtin_mpl_vector_addw_high_v8u8(uint16x8_t, uint8x16_t);
+uint32x4_t __builtin_mpl_vector_addw_high_v4u16(uint32x4_t, uint16x8_t);
+uint64x2_t __builtin_mpl_vector_addw_high_v2u32(uint64x2_t, uint32x4_t);
+
+// vectTy vector_from_scalar(scalarTy val)
+//      Create a vector by replicating the scalar value to all elements of the
+//      vector.
+int64x2_t __builtin_mpl_vector_from_scalar_v2i64(int64_t);
+int32x4_t __builtin_mpl_vector_from_scalar_v4i32(int32_t);
+int16x8_t __builtin_mpl_vector_from_scalar_v8i16(int16_t);
+int8x16_t __builtin_mpl_vector_from_scalar_v16i8(int8_t);
+uint64x2_t __builtin_mpl_vector_from_scalar_v2u64(uint64_t);
+uint32x4_t __builtin_mpl_vector_from_scalar_v4u32(uint32_t);
+uint16x8_t __builtin_mpl_vector_from_scalar_v8u16(uint16_t);
+uint8x16_t __builtin_mpl_vector_from_scalar_v16u8(uint8_t);
+float64x2_t __builtin_mpl_vector_from_scalar_v2f64(float64_t);
+float32x4_t __builtin_mpl_vector_from_scalar_v4f32(float32_t);
+int64x1_t __builtin_mpl_vector_from_scalar_v1i64(int64_t);
+int32x2_t __builtin_mpl_vector_from_scalar_v2i32(int32_t);
+int16x4_t __builtin_mpl_vector_from_scalar_v4i16(int16_t);
+int8x8_t __builtin_mpl_vector_from_scalar_v8i8(int8_t);
+uint64x1_t __builtin_mpl_vector_from_scalar_v1u64(uint64_t);
+uint32x2_t __builtin_mpl_vector_from_scalar_v2u32(uint32_t);
+uint16x4_t __builtin_mpl_vector_from_scalar_v4u16(uint16_t);
+uint8x8_t __builtin_mpl_vector_from_scalar_v8u8(uint8_t);
+float64x1_t __builtin_mpl_vector_from_scalar_v1f64(float64_t);
+float32x2_t __builtin_mpl_vector_from_scalar_v2f32(float32_t);
+
+// vecTy2 vector_madd(vecTy2 accum, vecTy1 src1, vecTy1 src2)
+//      Multiply the elements of src1 and src2, then accumulate into accum.
+//      Elements of vecTy2 are twice as long as elements of vecTy1.
+int64x2_t __builtin_mpl_vector_madd_v2i32(int64x2_t, int32x2_t, int32x2_t);
+int32x4_t __builtin_mpl_vector_madd_v4i16(int32x4_t, int16x4_t, int16x4_t);
+int16x8_t __builtin_mpl_vector_madd_v8i8(int16x8_t, int8x8_t, int8x8_t);
+uint64x2_t __builtin_mpl_vector_madd_v2u32(uint64x2_t, uint32x2_t, uint32x2_t);
+uint32x4_t __builtin_mpl_vector_madd_v4u16(uint32x4_t, uint16x4_t, uint16x4_t);
+uint16x8_t __builtin_mpl_vector_madd_v8u8(uint16x8_t, uint8x8_t, uint8x8_t);
+
+// vecTy2 vector_mull_low(vecTy1 src1, vecTy1 src2)
+//      Multiply the elements of src1 and src2. Elements of vecTy2 are twice as
+//      long as elements of vecTy1.
+int64x2_t __builtin_mpl_vector_mull_low_v2i32(int32x2_t, int32x2_t);
+int32x4_t __builtin_mpl_vector_mull_low_v4i16(int16x4_t, int16x4_t);
+int16x8_t __builtin_mpl_vector_mull_low_v8i8(int8x8_t, int8x8_t);
+uint64x2_t __builtin_mpl_vector_mull_low_v2u32(uint32x2_t, uint32x2_t);
+uint32x4_t __builtin_mpl_vector_mull_low_v4u16(uint16x4_t, uint16x4_t);
+uint16x8_t __builtin_mpl_vector_mull_low_v8u8(uint8x8_t, uint8x8_t);
+
+// vecTy2 vector_mull_high(vecTy1 src1, vecTy1 src2)
+//      Multiply the upper elements of src1 and src2. Elements of vecTy2 are twice
+//      as long as elements of vecTy1.
+int64x2_t __builtin_mpl_vector_mull_high_v2i32(int32x4_t, int32x4_t);
+int32x4_t __builtin_mpl_vector_mull_high_v4i16(int16x8_t, int16x8_t);
+int16x8_t __builtin_mpl_vector_mull_high_v8i8(int8x16_t, int8x16_t);
+uint64x2_t __builtin_mpl_vector_mull_high_v2u32(uint32x4_t, uint32x4_t);
+uint32x4_t __builtin_mpl_vector_mull_high_v4u16(uint16x8_t, uint16x8_t);
+uint16x8_t __builtin_mpl_vector_mull_high_v8u8(uint8x16_t, uint8x16_t);
+
+// vecTy vector_merge(vecTy src1, vecTy src2, int n)
+//     Create a vector by concatenating the high elements of src1, starting
+//     with the nth element, followed by the low elements of src2.
+int64x2_t __builtin_mpl_vector_merge_v2i64(int64x2_t, int64x2_t, int32_t);
+int32x4_t __builtin_mpl_vector_merge_v4i32(int32x4_t, int32x4_t, int32_t);
+int16x8_t __builtin_mpl_vector_merge_v8i16(int16x8_t, int16x8_t, int32_t);
+int8x16_t __builtin_mpl_vector_merge_v16i8(int8x16_t, int8x16_t, int32_t);
+uint64x2_t __builtin_mpl_vector_merge_v2u64(uint64x2_t, uint64x2_t, int32_t);
+uint32x4_t __builtin_mpl_vector_merge_v4u32(uint32x4_t, uint32x4_t, int32_t);
+uint16x8_t __builtin_mpl_vector_merge_v8u16(uint16x8_t, uint16x8_t, int32_t);
+uint8x16_t __builtin_mpl_vector_merge_v16u8(uint8x16_t, uint8x16_t, int32_t);
+float64x2_t __builtin_mpl_vector_merge_v2f64(float64x2_t, float64x2_t, int32_t);
+float32x4_t __builtin_mpl_vector_merge_v4f32(float32x4_t, float32x4_t, int32_t);
+int64x1_t __builtin_mpl_vector_merge_v1i64(int64x1_t, int64x1_t, int32_t);
+int32x2_t __builtin_mpl_vector_merge_v2i32(int32x2_t, int32x2_t, int32_t);
+int16x4_t __builtin_mpl_vector_merge_v4i16(int16x4_t, int16x4_t, int32_t);
+int8x8_t __builtin_mpl_vector_merge_v8i8(int8x8_t, int8x8_t, int32_t);
+uint64x1_t __builtin_mpl_vector_merge_v1u64(uint64x1_t, uint64x1_t, int32_t);
+uint32x2_t __builtin_mpl_vector_merge_v2u32(uint32x2_t, uint32x2_t, int32_t);
+uint16x4_t __builtin_mpl_vector_merge_v4u16(uint16x4_t, uint16x4_t, int32_t);
+uint8x8_t __builtin_mpl_vector_merge_v8u8(uint8x8_t, uint8x8_t, int32_t);
+float64x1_t __builtin_mpl_vector_merge_v1f64(float64x1_t, float64x1_t, int32_t);
+float32x2_t __builtin_mpl_vector_merge_v2f32(float32x2_t, float32x2_t, int32_t);
+
+// vecTy2 vector_get_low(vecTy1 src)
+//     Create a vector from the low part of the source vector.
+int64x1_t __builtin_mpl_vector_get_low_v2i64(int64x2_t);
+int32x2_t __builtin_mpl_vector_get_low_v4i32(int32x4_t);
+int16x4_t __builtin_mpl_vector_get_low_v8i16(int16x8_t);
+int8x8_t __builtin_mpl_vector_get_low_v16i8(int8x16_t);
+uint64x1_t __builtin_mpl_vector_get_low_v2u64(uint64x2_t);
+uint32x2_t __builtin_mpl_vector_get_low_v4u32(uint32x4_t);
+uint16x4_t __builtin_mpl_vector_get_low_v8u16(uint16x8_t);
+uint8x8_t __builtin_mpl_vector_get_low_v16u8(uint8x16_t);
+float64x1_t __builtin_mpl_vector_get_low_v2f64(float64x2_t);
+float32x2_t __builtin_mpl_vector_get_low_v4f32(float32x4_t);
+
+// vecTy2 vector_get_high(vecTy1 src)
+//     Create a vector from the high part of the source vector.
+int64x1_t __builtin_mpl_vector_get_high_v2i64(int64x2_t);
+int32x2_t __builtin_mpl_vector_get_high_v4i32(int32x4_t);
+int16x4_t __builtin_mpl_vector_get_high_v8i16(int16x8_t);
+int8x8_t __builtin_mpl_vector_get_high_v16i8(int8x16_t);
+uint64x1_t __builtin_mpl_vector_get_high_v2u64(uint64x2_t);
+uint32x2_t __builtin_mpl_vector_get_high_v4u32(uint32x4_t);
+uint16x4_t __builtin_mpl_vector_get_high_v8u16(uint16x8_t);
+uint8x8_t __builtin_mpl_vector_get_high_v16u8(uint8x16_t);
+float64x1_t __builtin_mpl_vector_get_high_v2f64(float64x2_t);
+float32x2_t __builtin_mpl_vector_get_high_v4f32(float32x4_t);
+
+// scalarTy vector_get_element(vecTy src, int n)
+//     Get the nth element of the source vector.
+int64_t __builtin_mpl_vector_get_element_v2i64(int64x2_t, int32_t);
+int32_t __builtin_mpl_vector_get_element_v4i32(int32x4_t, int32_t);
+int16_t __builtin_mpl_vector_get_element_v8i16(int16x8_t, int32_t);
+int8_t __builtin_mpl_vector_get_element_v16i8(int8x16_t, int32_t);
+uint64_t __builtin_mpl_vector_get_element_v2u64(uint64x2_t, int32_t);
+uint32_t __builtin_mpl_vector_get_element_v4u32(uint32x4_t, int32_t);
+uint16_t __builtin_mpl_vector_get_element_v8u16(uint16x8_t, int32_t);
+uint8_t __builtin_mpl_vector_get_element_v16u8(uint8x16_t, int32_t);
+float64_t __builtin_mpl_vector_get_element_v2f64(float64x2_t, int32_t);
+float32_t __builtin_mpl_vector_get_element_v4f32(float32x4_t, int32_t);
+int64_t __builtin_mpl_vector_get_element_v1i64(int64x1_t, int32_t);
+int32_t __builtin_mpl_vector_get_element_v2i32(int32x2_t, int32_t);
+int16_t __builtin_mpl_vector_get_element_v4i16(int16x4_t, int32_t);
+int8_t __builtin_mpl_vector_get_element_v8i8(int8x8_t, int32_t);
+uint64_t __builtin_mpl_vector_get_element_v1u64(uint64x1_t, int32_t);
+uint32_t __builtin_mpl_vector_get_element_v2u32(uint32x2_t, int32_t);
+uint16_t __builtin_mpl_vector_get_element_v4u16(uint16x4_t, int32_t);
+uint8_t __builtin_mpl_vector_get_element_v8u8(uint8x8_t, int32_t);
+float64_t __builtin_mpl_vector_get_element_v1f64(float64x1_t, int32_t);
+float32_t __builtin_mpl_vector_get_element_v2f32(float32x2_t, int32_t);
+
+// vecTy vector_set_element(ScalarTy value, VecTy vec, int n)
+//     Set the nth element of the source vector to value.
+int64x2_t __builtin_mpl_vector_set_element_v2i64(int64_t, int64x2_t, int32_t);
+int32x4_t __builtin_mpl_vector_set_element_v4i32(int32_t, int32x4_t, int32_t);
+int16x8_t __builtin_mpl_vector_set_element_v8i16(int16_t, int16x8_t, int32_t);
+int8x16_t __builtin_mpl_vector_set_element_v16i8(int8_t, int8x16_t, int32_t);
+uint64x2_t __builtin_mpl_vector_set_element_v2u64(uint64_t, uint64x2_t,
+                                                  int32_t);
+uint32x4_t __builtin_mpl_vector_set_element_v4u32(uint32_t, uint32x4_t,
+                                                  int32_t);
+uint16x8_t __builtin_mpl_vector_set_element_v8u16(uint16_t, uint16x8_t,
+                                                  int32_t);
+uint8x16_t __builtin_mpl_vector_set_element_v16u8(uint8_t, uint8x16_t, int32_t);
+float64x2_t __builtin_mpl_vector_set_element_v2f64(float64_t, float64x2_t,
+                                                   int32_t);
+float32x4_t __builtin_mpl_vector_set_element_v4f32(float32_t, float32x4_t,
+                                                   int32_t);
+int64x1_t __builtin_mpl_vector_set_element_v1i64(int64_t, int64x1_t, int32_t);
+int32x2_t __builtin_mpl_vector_set_element_v2i32(int32_t, int32x2_t, int32_t);
+int16x4_t __builtin_mpl_vector_set_element_v4i16(int16_t, int16x4_t, int32_t);
+int8x8_t __builtin_mpl_vector_set_element_v8i8(int8_t, int8x8_t, int32_t);
+uint64x1_t __builtin_mpl_vector_set_element_v1u64(uint64_t, uint64x1_t,
+                                                  int32_t);
+uint32x2_t __builtin_mpl_vector_set_element_v2u32(uint32_t, uint32x2_t,
+                                                  int32_t);
+uint16x4_t __builtin_mpl_vector_set_element_v4u16(uint16_t, uint16x4_t,
+                                                  int32_t);
+uint8x8_t __builtin_mpl_vector_set_element_v8u8(uint8_t, uint8x8_t, int32_t);
+float64x1_t __builtin_mpl_vector_set_element_v1f64(float64_t, float64x1_t,
+                                                   int32_t);
+float32x2_t __builtin_mpl_vector_set_element_v2f32(float32_t, float32x2_t,
+                                                   int32_t);
+
+// vecTy2 vector_abdl(vectTy1 src2, vectTy2 src2)
+//     Create a widened vector by getting the abs value of subtracted arguments.
+int16x8_t __builtin_mpl_vector_labssub_low_v8i8(int8x8_t, int8x8_t);
+int32x4_t __builtin_mpl_vector_labssub_low_v4i16(int16x4_t, int16x4_t);
+int64x2_t __builtin_mpl_vector_labssub_low_v2i32(int32x2_t, int32x2_t);
+uint16x8_t __builtin_mpl_vector_labssub_low_v8u8(uint8x8_t, uint8x8_t);
+uint32x4_t __builtin_mpl_vector_labssub_low_v4u16(uint16x4_t, uint16x4_t);
+uint64x2_t __builtin_mpl_vector_labssub_low_v2u32(uint32x2_t, uint32x2_t);
+
+// vecTy2 vector_abdl_high(vectTy1 src2, vectTy2 src2)
+//     Create a widened vector by getting the abs value of subtracted high arguments.
+int16x8_t __builtin_mpl_vector_labssub_high_v8i8(int8x16_t, int8x16_t);
+int32x4_t __builtin_mpl_vector_labssub_high_v4i16(int16x8_t, int16x8_t);
+int64x2_t __builtin_mpl_vector_labssub_high_v2i32(int32x4_t, int32x4_t);
+uint16x8_t __builtin_mpl_vector_labssub_high_v8u8(uint8x16_t, uint8x16_t);
+uint32x4_t __builtin_mpl_vector_labssub_high_v4u16(uint16x8_t, uint16x8_t);
+uint64x2_t __builtin_mpl_vector_labssub_high_v2u32(uint32x4_t, uint32x4_t);
+
+// vecTy2 vector_narrow_low(vecTy1 src)
+//     Narrow each element of the source vector to half of the original width,
+//     writing the lower half into the destination vector.
+int32x2_t __builtin_mpl_vector_narrow_low_v2i64(int64x2_t);
+int16x4_t __builtin_mpl_vector_narrow_low_v4i32(int32x4_t);
+int8x8_t __builtin_mpl_vector_narrow_low_v8i16(int16x8_t);
+uint32x2_t __builtin_mpl_vector_narrow_low_v2u64(uint64x2_t);
+uint16x4_t __builtin_mpl_vector_narrow_low_v4u32(uint32x4_t);
+uint8x8_t __builtin_mpl_vector_narrow_low_v8u16(uint16x8_t);
+
+// vecTy2 vector_narrow_high(vecTy1 src1, vecTy2 src2)
+//     Narrow each element of the source vector to half of the original width,
+//     concatenate the upper half into the destination vector.
+int32x4_t __builtin_mpl_vector_narrow_high_v2i64(int32x2_t, int64x2_t);
+int16x8_t __builtin_mpl_vector_narrow_high_v4i32(int16x4_t, int32x4_t);
+int8x16_t __builtin_mpl_vector_narrow_high_v8i16(int8x8_t, int16x8_t);
+uint32x4_t __builtin_mpl_vector_narrow_high_v2u64(uint32x2_t, uint64x2_t);
+uint16x8_t __builtin_mpl_vector_narrow_high_v4u32(uint16x4_t, uint32x4_t);
+uint8x16_t __builtin_mpl_vector_narrow_high_v8u16(uint8x8_t, uint16x8_t);
+
+// vecTy1 vector_adapl(vecTy1 src1, vecTy2 src2)
+//     Vector pairwise addition and accumulate
+int16x4_t __builtin_mpl_vector_pairwise_adalp_v8i8(int16x4_t, int8x8_t);
+int32x2_t __builtin_mpl_vector_pairwise_adalp_v4i16(int32x2_t, int16x4_t);
+int64x1_t __builtin_mpl_vector_pairwise_adalp_v2i32(int64x1_t, int32x2_t);
+uint16x4_t __builtin_mpl_vector_pairwise_adalp_v8u8(uint16x4_t, uint8x8_t);
+uint32x2_t __builtin_mpl_vector_pairwise_adalp_v4u16(uint32x2_t, uint16x4_t);
+uint64x1_t __builtin_mpl_vector_pairwise_adalp_v2u32(uint64x1_t, uint32x2_t);
+int16x8_t __builtin_mpl_vector_pairwise_adalp_v16i8(int16x8_t, int8x16_t);
+int32x4_t __builtin_mpl_vector_pairwise_adalp_v8i16(int32x4_t, int16x8_t);
+int64x2_t __builtin_mpl_vector_pairwise_adalp_v4i32(int64x2_t, int32x4_t);
+uint16x8_t __builtin_mpl_vector_pairwise_adalp_v16u8(uint16x8_t, uint8x16_t);
+uint32x4_t __builtin_mpl_vector_pairwise_adalp_v8u16(uint32x4_t, uint16x8_t);
+uint64x2_t __builtin_mpl_vector_pairwise_adalp_v4u32(uint64x2_t, uint32x4_t);
+
+// vecTy2 vector_pairwise_add(vecTy1 src)
+//     Add pairs of elements from the source vector and put the result into the
+//     destination vector, whose element size is twice and the number of
+//     elements is half of the source vector type.
+int64x2_t __builtin_mpl_vector_pairwise_add_v4i32(int32x4_t);
+int32x4_t __builtin_mpl_vector_pairwise_add_v8i16(int16x8_t);
+int16x8_t __builtin_mpl_vector_pairwise_add_v16i8(int8x16_t);
+uint64x2_t __builtin_mpl_vector_pairwise_add_v4u32(uint32x4_t);
+uint32x4_t __builtin_mpl_vector_pairwise_add_v8u16(uint16x8_t);
+uint16x8_t __builtin_mpl_vector_pairwise_add_v16u8(uint8x16_t);
+int64x1_t __builtin_mpl_vector_pairwise_add_v2i32(int32x2_t);
+int32x2_t __builtin_mpl_vector_pairwise_add_v4i16(int16x4_t);
+int16x4_t __builtin_mpl_vector_pairwise_add_v8i8(int8x8_t);
+uint64x1_t __builtin_mpl_vector_pairwise_add_v2u32(uint32x2_t);
+uint32x2_t __builtin_mpl_vector_pairwise_add_v4u16(uint16x4_t);
+uint16x4_t __builtin_mpl_vector_pairwise_add_v8u8(uint8x8_t);
+
+// vecTy vector_reverse(vecTy src)
+//     Create a vector by reversing the order of the elements in src.
+int64x2_t __builtin_mpl_vector_reverse_v2i64(int64x2_t);
+int32x4_t __builtin_mpl_vector_reverse_v4i32(int32x4_t);
+int16x8_t __builtin_mpl_vector_reverse_v8i16(int16x8_t);
+int8x16_t __builtin_mpl_vector_reverse_v16i8(int8x16_t);
+uint64x2_t __builtin_mpl_vector_reverse_v2u64(uint64x2_t);
+uint32x4_t __builtin_mpl_vector_reverse_v4u32(uint32x4_t);
+uint16x8_t __builtin_mpl_vector_reverse_v8u16(uint16x8_t);
+uint8x16_t __builtin_mpl_vector_reverse_v16u8(uint8x16_t);
+float64x2_t __builtin_mpl_vector_reverse_v2f64(float64x2_t);
+float32x4_t __builtin_mpl_vector_reverse_v4f32(float32x4_t);
+int64x1_t __builtin_mpl_vector_reverse_v1i64(int64x1_t);
+int32x2_t __builtin_mpl_vector_reverse_v2i32(int32x2_t);
+int16x4_t __builtin_mpl_vector_reverse_v4i16(int16x4_t);
+int8x8_t __builtin_mpl_vector_reverse_v8i8(int8x8_t);
+uint64x1_t __builtin_mpl_vector_reverse_v1u64(uint64x1_t);
+uint32x2_t __builtin_mpl_vector_reverse_v2u32(uint32x2_t);
+uint16x4_t __builtin_mpl_vector_reverse_v4u16(uint16x4_t);
+uint8x8_t __builtin_mpl_vector_reverse_v8u8(uint8x8_t);
+float64x1_t __builtin_mpl_vector_reverse_v1f64(float64x1_t);
+float32x2_t __builtin_mpl_vector_reverse_v2f32(float32x2_t);
+
+// vecTy vector_shli(vecTy src, const int n)
+//     Shift each element in the vector left by n.
+int64x2_t __builtin_mpl_vector_shli_v2i64(int64x2_t, const int);
+int32x4_t __builtin_mpl_vector_shli_v4i32(int32x4_t, const int);
+int16x8_t __builtin_mpl_vector_shli_v8i16(int16x8_t, const int);
+int8x16_t __builtin_mpl_vector_shli_v16i8(int8x16_t, const int);
+uint64x2_t __builtin_mpl_vector_shli_v2u64(uint64x2_t, const int);
+uint32x4_t __builtin_mpl_vector_shli_v4u32(uint32x4_t, const int);
+uint16x8_t __builtin_mpl_vector_shli_v8u16(uint16x8_t, const int);
+uint8x16_t __builtin_mpl_vector_shli_v16u8(uint8x16_t, const int);
+int64x1_t __builtin_mpl_vector_shli_v1i64(int64x1_t, const int);
+int32x2_t __builtin_mpl_vector_shli_v2i32(int32x2_t, const int);
+int16x4_t __builtin_mpl_vector_shli_v4i16(int16x4_t, const int);
+int8x8_t __builtin_mpl_vector_shli_v8i8(int8x8_t, const int);
+uint64x1_t __builtin_mpl_vector_shli_v1u64(uint64x1_t, const int);
+uint32x2_t __builtin_mpl_vector_shli_v2u32(uint32x2_t, const int);
+uint16x4_t __builtin_mpl_vector_shli_v4u16(uint16x4_t, const int);
+uint8x8_t __builtin_mpl_vector_shli_v8u8(uint8x8_t, const int);
+
+// vecTy vector_shri(vecTy src, const int n)
+//     Shift each element in the vector right by n.
+int64x2_t __builtin_mpl_vector_shri_v2i64(int64x2_t, const int);
+int32x4_t __builtin_mpl_vector_shri_v4i32(int32x4_t, const int);
+int16x8_t __builtin_mpl_vector_shri_v8i16(int16x8_t, const int);
+int8x16_t __builtin_mpl_vector_shri_v16i8(int8x16_t, const int);
+uint64x2_t __builtin_mpl_vector_shru_v2u64(uint64x2_t, const int);
+uint32x4_t __builtin_mpl_vector_shru_v4u32(uint32x4_t, const int);
+uint16x8_t __builtin_mpl_vector_shru_v8u16(uint16x8_t, const int);
+uint8x16_t __builtin_mpl_vector_shru_v16u8(uint8x16_t, const int);
+int64x1_t __builtin_mpl_vector_shri_v1i64(int64x1_t, const int);
+int32x2_t __builtin_mpl_vector_shri_v2i32(int32x2_t, const int);
+int16x4_t __builtin_mpl_vector_shri_v4i16(int16x4_t, const int);
+int8x8_t __builtin_mpl_vector_shri_v8i8(int8x8_t, const int);
+uint64x1_t __builtin_mpl_vector_shru_v1u64(uint64x1_t, const int);
+uint32x2_t __builtin_mpl_vector_shru_v2u32(uint32x2_t, const int);
+uint16x4_t __builtin_mpl_vector_shru_v4u16(uint16x4_t, const int);
+uint8x8_t __builtin_mpl_vector_shru_v8u8(uint8x8_t, const int);
+
+// vecTy2 vector_shift_narrow_low(vecTy1 src, const int n)
+//     Shift each element in the vector right by n, narrow each element to half
+//     of the original width (truncating), then write the result to the lower
+//     half of the destination vector.
+int32x2_t __builtin_mpl_vector_shr_narrow_low_v2i64(int64x2_t, const int);
+int16x4_t __builtin_mpl_vector_shr_narrow_low_v4i32(int32x4_t, const int);
+int8x8_t __builtin_mpl_vector_shr_narrow_low_v8i16(int16x8_t, const int);
+uint32x2_t __builtin_mpl_vector_shr_narrow_low_v2u64(uint64x2_t, const int);
+uint16x4_t __builtin_mpl_vector_shr_narrow_low_v4u32(uint32x4_t, const int);
+uint8x8_t __builtin_mpl_vector_shr_narrow_low_v8u16(uint16x8_t, const int);
+
+// scalarTy vector_sum(vecTy src)
+//     Sum all of the elements in the vector into a scalar.
+int64_t __builtin_mpl_vector_sum_v2i64(int64x2_t);
+int32_t __builtin_mpl_vector_sum_v4i32(int32x4_t);
+int16_t __builtin_mpl_vector_sum_v8i16(int16x8_t);
+int8_t __builtin_mpl_vector_sum_v16i8(int8x16_t);
+uint64_t __builtin_mpl_vector_sum_v2u64(uint64x2_t);
+uint32_t __builtin_mpl_vector_sum_v4u32(uint32x4_t);
+uint16_t __builtin_mpl_vector_sum_v8u16(uint16x8_t);
+uint8_t __builtin_mpl_vector_sum_v16u8(uint8x16_t);
+float64_t __builtin_mpl_vector_sum_v2f64(float64x2_t);
+float32_t __builtin_mpl_vector_sum_v4f32(float32x4_t);
+int32_t __builtin_mpl_vector_sum_v2i32(int32x2_t);
+int16_t __builtin_mpl_vector_sum_v4i16(int16x4_t);
+int8_t __builtin_mpl_vector_sum_v8i8(int8x8_t);
+uint32_t __builtin_mpl_vector_sum_v2u32(uint32x2_t);
+uint16_t __builtin_mpl_vector_sum_v4u16(uint16x4_t);
+uint8_t __builtin_mpl_vector_sum_v8u8(uint8x8_t);
+float32_t __builtin_mpl_vector_sum_v2f32(float32x2_t);
+
+// vecTy table_lookup(vecTy tbl, vecTy idx)
+//     Performs a table vector lookup.
+int64x2_t __builtin_mpl_vector_table_lookup_v2i64(int64x2_t, int64x2_t);
+int32x4_t __builtin_mpl_vector_table_lookup_v4i32(int32x4_t, int32x4_t);
+int16x8_t __builtin_mpl_vector_table_lookup_v8i16(int16x8_t, int16x8_t);
+int8x16_t __builtin_mpl_vector_table_lookup_v16i8(int8x16_t, int8x16_t);
+uint64x2_t __builtin_mpl_vector_table_lookup_v2u64(uint64x2_t, uint64x2_t);
+uint32x4_t __builtin_mpl_vector_table_lookup_v4u32(uint32x4_t, uint32x4_t);
+uint16x8_t __builtin_mpl_vector_table_lookup_v8u16(uint16x8_t, uint16x8_t);
+uint8x16_t __builtin_mpl_vector_table_lookup_v16u8(uint8x16_t, uint8x16_t);
+float64x2_t __builtin_mpl_vector_table_lookup_v2f64(float64x2_t, float64x2_t);
+float32x4_t __builtin_mpl_vector_table_lookup_v4f32(float32x4_t, float32x4_t);
+int64x1_t __builtin_mpl_vector_table_lookup_v1i64(int64x1_t, int64x1_t);
+int32x2_t __builtin_mpl_vector_table_lookup_v2i32(int32x2_t, int32x2_t);
+int16x4_t __builtin_mpl_vector_table_lookup_v4i16(int16x4_t, int16x4_t);
+int8x8_t __builtin_mpl_vector_table_lookup_v8i8(int8x8_t, int8x8_t);
+uint64x1_t __builtin_mpl_vector_table_lookup_v1u64(uint64x1_t, uint64x1_t);
+uint32x2_t __builtin_mpl_vector_table_lookup_v2u32(uint32x2_t, uint32x2_t);
+uint16x4_t __builtin_mpl_vector_table_lookup_v4u16(uint16x4_t, uint16x4_t);
+uint8x8_t __builtin_mpl_vector_table_lookup_v8u8(uint8x8_t, uint8x8_t);
+float64x1_t __builtin_mpl_vector_table_lookup_v1f64(float64x1_t, float64x1_t);
+float32x2_t __builtin_mpl_vector_table_lookup_v2f32(float32x2_t, float32x2_t);
+
+// vecTy2 vector_widen_low(vecTy1 src)
+//     Widen each element of the source vector to half of the original width,
+//     writing the lower half into the destination vector.
+int64x2_t __builtin_mpl_vector_widen_low_v2i32(int32x2_t);
+int32x4_t __builtin_mpl_vector_widen_low_v4i16(int16x4_t);
+int16x8_t __builtin_mpl_vector_widen_low_v8i8(int8x8_t);
+uint64x2_t __builtin_mpl_vector_widen_low_v2u32(uint32x2_t);
+uint32x4_t __builtin_mpl_vector_widen_low_v4u16(uint16x4_t);
+uint16x8_t __builtin_mpl_vector_widen_low_v8u8(uint8x8_t);
+
+// vecTy2 vector_widen_high(vecTy1 src)
+//     Widen each element of the source vector to half of the original width,
+//     writing the higher half into the destination vector.
+int64x2_t __builtin_mpl_vector_widen_high_v2i32(int32x4_t);
+int32x4_t __builtin_mpl_vector_widen_high_v4i16(int16x8_t);
+int16x8_t __builtin_mpl_vector_widen_high_v8i8(int8x16_t);
+uint64x2_t __builtin_mpl_vector_widen_high_v2u32(uint32x4_t);
+uint32x4_t __builtin_mpl_vector_widen_high_v4u16(uint16x8_t);
+uint16x8_t __builtin_mpl_vector_widen_high_v8u8(uint8x16_t);
+
+// vecArrTy vector_zip(vecTy a, vecTy b)
+//     Interleave the upper half of elements from a and b into the destination
+//     vector.
+int32x2x2_t __builtin_mpl_vector_zip_v2i32(int32x2_t, int32x2_t);
+int16x4x2_t __builtin_mpl_vector_zip_v4i16(int16x4_t, int16x4_t);
+int8x8x2_t __builtin_mpl_vector_zip_v8i8(int8x8_t, int8x8_t);
+uint32x2x2_t __builtin_mpl_vector_zip_v2u32(uint32x2_t, uint32x2_t);
+uint16x4x2_t __builtin_mpl_vector_zip_v4u16(uint16x4_t, uint16x4_t);
+uint8x8x2_t __builtin_mpl_vector_zip_v8u8(uint8x8_t, uint8x8_t);
+float32x2x2_t __builtin_mpl_vector_zip_v2f32(float32x2_t, float32x2_t);
+
+// vecTy vector_load(scalarTy *ptr)
+//     Load the elements pointed to by ptr into a vector.
+int64x2_t __builtin_mpl_vector_load_v2i64(int64_t *);
+int32x4_t __builtin_mpl_vector_load_v4i32(int32_t *);
+int16x8_t __builtin_mpl_vector_load_v8i16(int16_t *);
+int8x16_t __builtin_mpl_vector_load_v16i8(int8_t *);
+uint64x2_t __builtin_mpl_vector_load_v2u64(uint64_t *);
+uint32x4_t __builtin_mpl_vector_load_v4u32(uint32_t *);
+uint16x8_t __builtin_mpl_vector_load_v8u16(uint16_t *);
+uint8x16_t __builtin_mpl_vector_load_v16u8(uint8_t *);
+float64x2_t __builtin_mpl_vector_load_v2f64(float64_t *);
+float32x4_t __builtin_mpl_vector_load_v4f32(float32_t *);
+int64x1_t __builtin_mpl_vector_load_v1i64(int64_t *);
+int32x2_t __builtin_mpl_vector_load_v2i32(int32_t *);
+int16x4_t __builtin_mpl_vector_load_v4i16(int16_t *);
+int8x8_t __builtin_mpl_vector_load_v8i8(int8_t *);
+uint64x1_t __builtin_mpl_vector_load_v1u64(uint64_t *);
+uint32x2_t __builtin_mpl_vector_load_v2u32(uint32_t *);
+uint16x4_t __builtin_mpl_vector_load_v4u16(uint16_t *);
+uint8x8_t __builtin_mpl_vector_load_v8u8(uint8_t *);
+float64x1_t __builtin_mpl_vector_load_v1f64(float64_t *);
+float32x2_t __builtin_mpl_vector_load_v2f32(float32_t *);
+
+// void vector_store(scalarTy *ptr, vecTy src)
+//     Store the elements from src into the memory pointed to by ptr.
+void __builtin_mpl_vector_store_v2i64(int64_t *, int64x2_t);
+void __builtin_mpl_vector_store_v4i32(int32_t *, int32x4_t);
+void __builtin_mpl_vector_store_v8i16(int16_t *, int16x8_t);
+void __builtin_mpl_vector_store_v16i8(int8_t *, int8x16_t);
+void __builtin_mpl_vector_store_v2u64(uint64_t *, uint64x2_t);
+void __builtin_mpl_vector_store_v4u32(uint32_t *, uint32x4_t);
+void __builtin_mpl_vector_store_v8u16(uint16_t *, uint16x8_t);
+void __builtin_mpl_vector_store_v16u8(uint8_t *, uint8x16_t);
+void __builtin_mpl_vector_store_v2f64(float64_t *, float64x2_t);
+void __builtin_mpl_vector_store_v4f32(float32_t *, float32x4_t);
+void __builtin_mpl_vector_store_v1i64(int64_t *, int64x1_t);
+void __builtin_mpl_vector_store_v2i32(int32_t *, int32x2_t);
+void __builtin_mpl_vector_store_v4i16(int16_t *, int16x4_t);
+void __builtin_mpl_vector_store_v8i8(int8_t *, int8x8_t);
+void __builtin_mpl_vector_store_v1u64(uint64_t *, uint64x1_t);
+void __builtin_mpl_vector_store_v2u32(uint32_t *, uint32x2_t);
+void __builtin_mpl_vector_store_v4u16(uint16_t *, uint16x4_t);
+void __builtin_mpl_vector_store_v8u8(uint8_t *, uint8x8_t);
+void __builtin_mpl_vector_store_v1f64(float64_t *, float64x1_t);
+void __builtin_mpl_vector_store_v2f32(float32_t *, float32x2_t);
+
+// vecTy vector_subl_low(vecTy src1, vecTy src2)
+//     Subtract each element of the source vector to second source
+//     widen the result into the destination vector.
+int16x8_t __builtin_mpl_vector_subl_low_v8i8(int8x8_t, int8x8_t);
+int32x4_t __builtin_mpl_vector_subl_low_v4i16(int16x4_t, int16x4_t);
+int64x2_t __builtin_mpl_vector_subl_low_v2i32(int32x2_t, int32x2_t);
+uint16x8_t __builtin_mpl_vector_subl_low_v8u8(uint8x8_t, uint8x8_t);
+uint32x4_t __builtin_mpl_vector_subl_low_v4u16(uint16x4_t, uint16x4_t);
+uint64x2_t __builtin_mpl_vector_subl_low_v2u32(uint32x2_t, uint32x2_t);
+
+// vecTy vector_subl_high(vecTy src1, vecTy src2)
+//     Subtract each element of the source vector to upper half of second source
+//     widen the result into the destination vector.
+int16x8_t __builtin_mpl_vector_subl_high_v8i8(int8x16_t, int8x16_t);
+int32x4_t __builtin_mpl_vector_subl_high_v4i16(int16x8_t, int16x8_t);
+int64x2_t __builtin_mpl_vector_subl_high_v2i32(int32x4_t, int32x4_t);
+uint16x8_t __builtin_mpl_vector_subl_high_v8u8(uint8x16_t, uint8x16_t);
+uint32x4_t __builtin_mpl_vector_subl_high_v4u16(uint16x8_t, uint16x8_t);
+uint64x2_t __builtin_mpl_vector_subl_high_v2u32(uint32x4_t, uint32x4_t);
+
+// vecTy vector_subw_low(vecTy src1, vecTy src2)
+//     Subtract each element of the source vector to second source
+//     widen the result into the destination vector.
+int16x8_t __builtin_mpl_vector_subw_low_v8i8(int16x8_t, int8x8_t);
+int32x4_t __builtin_mpl_vector_subw_low_v4i16(int32x4_t, int16x4_t);
+int64x2_t __builtin_mpl_vector_subw_low_v2i32(int64x2_t, int32x2_t);
+uint16x8_t __builtin_mpl_vector_subw_low_v8u8(uint16x8_t, uint8x8_t);
+uint32x4_t __builtin_mpl_vector_subw_low_v4u16(uint32x4_t, uint16x4_t);
+uint64x2_t __builtin_mpl_vector_subw_low_v2u32(uint64x2_t, uint32x2_t);
+
+// vecTy vector_subw_high(vecTy src1, vecTy src2)
+//     Subtract each element of the source vector to upper half of second source
+//     widen the result into the destination vector.
+int16x8_t __builtin_mpl_vector_subw_high_v8i8(int16x8_t, int8x16_t);
+int32x4_t __builtin_mpl_vector_subw_high_v4i16(int32x4_t, int16x8_t);
+int64x2_t __builtin_mpl_vector_subw_high_v2i32(int64x2_t, int32x4_t);
+uint16x8_t __builtin_mpl_vector_subw_high_v8u8(uint16x8_t, uint8x16_t);
+uint32x4_t __builtin_mpl_vector_subw_high_v4u16(uint32x4_t, uint16x8_t);
+uint64x2_t __builtin_mpl_vector_subw_high_v2u32(uint64x2_t, uint32x4_t);
+
+// *************************
+// Supported Neon Intrinsics
+// *************************
+
+// vabdl
+#define vabdl_s8(a, b) __builtin_mpl_vector_labssub_low_v8i8(a, b)
+#define vabdl_s16(a, b) __builtin_mpl_vector_labssub_low_v4i16(a, b)
+#define vabdl_s32(a, b) __builtin_mpl_vector_labssub_low_v2i32(a, b)
+#define vabdl_u8(a, b) __builtin_mpl_vector_labssub_low_v8u8(a, b)
+#define vabdl_u16(a, b) __builtin_mpl_vector_labssub_low_v4u16(a, b)
+#define vabdl_u32(a, b) __builtin_mpl_vector_labssub_low_v2u32(a, b)
+
+// vabdl_high
+#define vabdl_high_s8(a, b) __builtin_mpl_vector_labssub_high_v8i8(a, b)
+#define vabdl_high_s16(a, b) __builtin_mpl_vector_labssub_high_v4i16(a, b)
+#define vabdl_high_s32(a, b) __builtin_mpl_vector_labssub_high_v2i32(a, b)
+#define vabdl_high_u8(a, b) __builtin_mpl_vector_labssub_high_v8u8(a, b)
+#define vabdl_high_u16(a, b) __builtin_mpl_vector_labssub_high_v4u16(a, b)
+#define vabdl_high_u32(a, b) __builtin_mpl_vector_labssub_high_v2u32(a, b)
+
+// vabs
+#define vabs_s8(a) __builtin_mpl_vector_abs_v8i8(a)
+#define vabs_s16(a) __builtin_mpl_vector_abs_v4i16(a)
+#define vabs_s32(a) __builtin_mpl_vector_abs_v2i32(a)
+#define vabs_s64(a) __builtin_mpl_vector_abs_v1i64(a)
+#define vabs_f32(a) __builtin_mpl_vector_abs_v2f32(a)
+#define vabs_f64(a) __builtin_mpl_vector_abs_v1f64(a)
+#define vabsq_s8(a) __builtin_mpl_vector_abs_v16i8(a)
+#define vabsq_s16(a) __builtin_mpl_vector_abs_v8i16(a)
+#define vabsq_s32(a) __builtin_mpl_vector_abs_v4i32(a)
+#define vabsq_s64(a) __builtin_mpl_vector_abs_v2i64(a)
+#define vabsq_f32(a) __builtin_mpl_vector_abs_v4f32(a)
+#define vabsq_f64(a) __builtin_mpl_vector_abs_v2f64(a)
+
+// vaddv
+#define vaddv_s8(a)  __builtin_mpl_vector_sum_v8i8(a)
+#define vaddv_s16(a) __builtin_mpl_vector_sum_v4i16(a)
+#define vaddv_s32(a) __builtin_mpl_vector_sum_v2i32(a)
+#define vaddv_u8 (a) __builtin_mpl_vector_sum_v8u8(a)
+#define vaddv_u16(a) __builtin_mpl_vector_sum_v4u16(a)
+#define vaddv_u32(a) __builtin_mpl_vector_sum_v2u32(a)
+#define vaddv_f32(a) __builtin_mpl_vector_sum_v2f32(a)
+#define vaddvq_s8(a) __builtin_mpl_vector_sum_v16i8(a)
+#define vaddvq_s16(a) __builtin_mpl_vector_sum_v8i16(a)
+#define vaddvq_s32(a) __builtin_mpl_vector_sum_v4i32(a)
+#define vaddvq_s64(a) __builtin_mpl_vector_sum_v2i64(a)
+#define vaddvq_u8(a) __builtin_mpl_vector_sum_v16u8(a)
+#define vaddvq_u16(a) __builtin_mpl_vector_sum_v8u16(a)
+#define vaddvq_u32(a) __builtin_mpl_vector_sum_v4u32(a)
+#define vaddvq_u64(a) __builtin_mpl_vector_sum_v2u64(a)
+#define vaddvq_f32(a) __builtin_mpl_vector_sum_v4f32(a)
+#define vaddvq_f64(a) __builtin_mpl_vector_sum_v2f64(a)
+
+// vqmovn
+#define vqmovn_u16(a) __builtin_mpl_vector_mov_narrow_v8u16(a)
+#define vqmovn_u32(a) __builtin_mpl_vector_mov_narrow_v4u32(a)
+#define vqmovn_u64(a) __builtin_mpl_vector_mov_narrow_v2u64(a)
+#define vqmovn_s16(a) __builtin_mpl_vector_mov_narrow_v8i16(a)
+#define vqmovn_s32(a) __builtin_mpl_vector_mov_narrow_v4i32(a)
+#define vqmovn_s64(a) __builtin_mpl_vector_mov_narrow_v2i64(a)
+
+// vaddl
+#define vaddl_s8(a, b) __builtin_mpl_vector_addl_low_v8i8(a, b)
+#define vaddl_s16(a, b) __builtin_mpl_vector_addl_low_v4i16(a, b)
+#define vaddl_s32(a, b) __builtin_mpl_vector_addl_low_v2i32(a, b)
+#define vaddl_u8(a, b) __builtin_mpl_vector_addl_low_v8u8(a, b)
+#define vaddl_u16(a, b) __builtin_mpl_vector_addl_low_v4u16(a, b)
+#define vaddl_u32(a, b) __builtin_mpl_vector_addl_low_v2u32(a, b)
+
+// vaddl_high
+#define vaddl_high_s8(a, b) __builtin_mpl_vector_addl_high_v8i8(a, b)
+#define vaddl_high_s16(a, b) __builtin_mpl_vector_addl_high_v4i16(a, b)
+#define vaddl_high_s32(a, b) __builtin_mpl_vector_addl_high_v2i32(a, b)
+#define vaddl_high_u8(a, b) __builtin_mpl_vector_addl_high_v8u8(a, b)
+#define vaddl_high_u16(a, b) __builtin_mpl_vector_addl_high_v4u16(a, b)
+#define vaddl_high_u32(a, b) __builtin_mpl_vector_addl_high_v2u32(a, b)
+
+// vaddw
+#define vaddw_s8(a, b) __builtin_mpl_vector_addw_low_v8i8(a, b)
+#define vaddw_s16(a, b) __builtin_mpl_vector_addw_low_v4i16(a, b)
+#define vaddw_s32(a, b) __builtin_mpl_vector_addw_low_v2i32(a, b)
+#define vaddw_u8(a, b) __builtin_mpl_vector_addw_low_v8u8(a, b)
+#define vaddw_u16(a, b) __builtin_mpl_vector_addw_low_v4u16(a, b)
+#define vaddw_u32(a, b) __builtin_mpl_vector_addw_low_v2u32(a, b)
+
+// vaddw_high
+#define vaddw_high_s8(a, b) __builtin_mpl_vector_addw_high_v8i8(a, b)
+#define vaddw_high_s16(a, b) __builtin_mpl_vector_addw_high_v4i16(a, b)
+#define vaddw_high_s32(a, b) __builtin_mpl_vector_addw_high_v2i32(a, b)
+#define vaddw_high_u8(a, b) __builtin_mpl_vector_addw_high_v8u8(a, b)
+#define vaddw_high_u16(a, b) __builtin_mpl_vector_addw_high_v4u16(a, b)
+#define vaddw_high_u32(a, b) __builtin_mpl_vector_addw_high_v2u32(a, b)
+
+// vadd
+#define vadd_s8(a, b) (a + b)
+#define vadd_s16(a, b) (a + b)
+#define vadd_s32(a, b) (a + b)
+#define vadd_s64(a, b) (a + b)
+#define vadd_u8(a, b) (a + b)
+#define vadd_u16(a, b) (a + b)
+#define vadd_u32(a, b) (a + b)
+#define vadd_u64(a, b) (a + b)
+#define vadd_f16(a, b) (a + b)
+#define vadd_f32(a, b) (a + b)
+#define vadd_f64(a, b) (a + b)
+#define vaddq_s8(a, b) (a + b)
+#define vaddq_s16(a, b) (a + b)
+#define vaddq_s32(a, b) (a + b)
+#define vaddq_s64(a, b) (a + b)
+#define vaddq_u8(a, b) (a + b)
+#define vaddq_u16(a, b) (a + b)
+#define vaddq_u32(a, b) (a + b)
+#define vaddq_u64(a, b) (a + b)
+#define vaddq_f16(a, b) (a + b)
+#define vaddq_f32(a, b) (a + b)
+#define vaddq_f64(a, b) (a + b)
+
+// vand
+#define vand_s8(a, b) (a & b)
+#define vand_s16(a, b) (a & b)
+#define vand_s32(a, b) (a & b)
+#define vand_s64(a, b) (a & b)
+#define vand_u8(a, b) (a & b)
+#define vand_u16(a, b) (a & b)
+#define vand_u32(a, b) (a & b)
+#define vand_u64(a, b) (a & b)
+#define vandq_s8(a, b) (a & b)
+#define vandq_s16(a, b) (a & b)
+#define vandq_s32(a, b) (a & b)
+#define vandq_s64(a, b) (a & b)
+#define vandq_u8(a, b) (a & b)
+#define vandq_u16(a, b) (a & b)
+#define vandq_u32(a, b) (a & b)
+#define vandq_u64(a, b) (a & b)
+
+// vand
+#define vorr_s8(a, b) (a | b)
+#define vorr_s16(a, b) (a | b)
+#define vorr_s32(a, b) (a | b)
+#define vorr_s64(a, b) (a | b)
+#define vorr_u8(a, b) (a | b)
+#define vorr_u16(a, b) (a | b)
+#define vorr_u32(a, b) (a | b)
+#define vorr_u64(a, b) (a | b)
+#define vorrq_s8(a, b) (a | b)
+#define vorrq_s16(a, b) (a | b)
+#define vorrq_s32(a, b) (a | b)
+#define vorrq_s64(a, b) (a | b)
+#define vorrq_u8(a, b) (a | b)
+#define vorrq_u16(a, b) (a | b)
+#define vorrq_u32(a, b) (a | b)
+#define vorrq_u64(a, b) (a | b)
+
+// vdup
+#define vdup_n_s8(a)  __builtin_mpl_vector_from_scalar_v8i8(a)
+#define vdup_n_s16(a) __builtin_mpl_vector_from_scalar_v4i16(a)
+#define vdup_n_s32(a) __builtin_mpl_vector_from_scalar_v2i32(a)
+#define vdup_n_s64(a) __builtin_mpl_vector_from_scalar_v1i64(a)
+#define vdup_n_u8(a) __builtin_mpl_vector_from_scalar_v8u8(a)
+#define vdup_n_u16(a) __builtin_mpl_vector_from_scalar_v4u16(a)
+#define vdup_n_u32(a) __builtin_mpl_vector_from_scalar_v2u32(a)
+#define vdup_n_u64(a) __builtin_mpl_vector_from_scalar_v1u64(a)
+#define vdup_n_f16(a) __builtin_mpl_vector_from_scalar_v4f16(a)
+#define vdup_n_f32(a) __builtin_mpl_vector_from_scalar_v2f32(a)
+#define vdup_n_f64(a) __builtin_mpl_vector_from_scalar_v1f64(a)
+#define vdupq_n_s8(a) __builtin_mpl_vector_from_scalar_v16i8(a)
+#define vdupq_n_s16(a) __builtin_mpl_vector_from_scalar_v8i16(a)
+#define vdupq_n_s32(a) __builtin_mpl_vector_from_scalar_v4i32(a)
+#define vdupq_n_s64(a) __builtin_mpl_vector_from_scalar_v2i64(a)
+#define vdupq_n_u8(a) __builtin_mpl_vector_from_scalar_v16u8(a)
+#define vdupq_n_u16(a) __builtin_mpl_vector_from_scalar_v8u16(a)
+#define vdupq_n_u32(a) __builtin_mpl_vector_from_scalar_v4u32(a)
+#define vdupq_n_u64(a) __builtin_mpl_vector_from_scalar_v2u64(a)
+#define vdupq_n_f16(a) __builtin_mpl_vector_from_scalar_v8f16(a)
+#define vdupq_n_f32(a) __builtin_mpl_vector_from_scalar_v4f32(a)
+#define vdupq_n_f64(a) __builtin_mpl_vector_from_scalar_v2f64(a)
+
+// vceq
+#define vceq_s8(a, b) (a == b)
+#define vceq_s16(a, b) (a == b)
+#define vceq_s32(a, b) (a == b)
+#define vceq_s64(a, b) (a == b)
+#define vceq_u8(a, b) (a == b)
+#define vceq_u16(a, b) (a == b)
+#define vceq_u32(a, b) (a == b)
+#define vceq_u64(a, b) (a == b)
+#define vceq_f16(a, b) (a == b)
+#define vceq_f32(a, b) (a == b)
+#define vceq_f64(a, b) (a == b)
+#define vceqq_s8(a, b) (a == b)
+#define vceqq_s16(a, b) (a == b)
+#define vceqq_s32(a, b) (a == b)
+#define vceqq_s64(a, b) (a == b)
+#define vceqq_u8(a, b) (a == b)
+#define vceqq_u16(a, b) (a == b)
+#define vceqq_u32(a, b) (a == b)
+#define vceqq_u64(a, b) (a == b)
+#define vceqq_f16(a, b) (a == b)
+#define vceqq_f32(a, b) (a == b)
+#define vceqq_f64(a, b) (a == b)
+
+// vcgt
+#define vcgt_s8(a, b) (a > b)
+#define vcgt_s16(a, b) (a > b)
+#define vcgt_s32(a, b) (a > b)
+#define vcgt_s64(a, b) (a > b)
+#define vcgt_u8(a, b) (a > b)
+#define vcgt_u16(a, b) (a > b)
+#define vcgt_u32(a, b) (a > b)
+#define vcgt_u64(a, b) (a > b)
+#define vcgt_f16(a, b) (a > b)
+#define vcgt_f32(a, b) (a > b)
+#define vcgt_f64(a, b) (a > b)
+#define vcgtq_s8(a, b) (a > b)
+#define vcgtq_s16(a, b) (a > b)
+#define vcgtq_s32(a, b) (a > b)
+#define vcgtq_s64(a, b) (a > b)
+#define vcgtq_u8(a, b) (a > b)
+#define vcgtq_u16(a, b) (a > b)
+#define vcgtq_u32(a, b) (a > b)
+#define vcgtq_u64(a, b) (a > b)
+#define vcgtq_f16(a, b) (a > b)
+#define vcgtq_f32(a, b) (a > b)
+#define vcgtq_f64(a, b) (a > b)
+
+// vcge
+#define vcge_s8(a, b) (a >= b)
+#define vcge_s16(a, b) (a >= b)
+#define vcge_s32(a, b) (a >= b)
+#define vcge_s64(a, b) (a >= b)
+#define vcge_u8(a, b) (a >= b)
+#define vcge_u16(a, b) (a >= b)
+#define vcge_u32(a, b) (a >= b)
+#define vcge_u64(a, b) (a >= b)
+#define vcge_f16(a, b) (a >= b)
+#define vcge_f32(a, b) (a >= b)
+#define vcge_f64(a, b) (a >= b)
+#define vcgeq_s8(a, b) (a >= b)
+#define vcgeq_s16(a, b) (a >= b)
+#define vcgeq_s32(a, b) (a >= b)
+#define vcgeq_s64(a, b) (a >= b)
+#define vcgeq_u8(a, b) (a >= b)
+#define vcgeq_u16(a, b) (a >= b)
+#define vcgeq_u32(a, b) (a >= b)
+#define vcgeq_u64(a, b) (a >= b)
+#define vcgeq_f16(a, b) (a >= b)
+#define vcgeq_f32(a, b) (a >= b)
+#define vcgeq_f64(a, b) (a >= b)
+
+// vclt
+#define vclt_s8(a, b) (a < b)
+#define vclt_s16(a, b) (a < b)
+#define vclt_s32(a, b) (a < b)
+#define vclt_s64(a, b) (a < b)
+#define vclt_u8(a, b) (a < b)
+#define vclt_u16(a, b) (a < b)
+#define vclt_u32(a, b) (a < b)
+#define vclt_u64(a, b) (a < b)
+#define vclt_f16(a, b) (a < b)
+#define vclt_f32(a, b) (a < b)
+#define vclt_f64(a, b) (a < b)
+#define vcltq_s8(a, b) (a < b)
+#define vcltq_s16(a, b) (a < b)
+#define vcltq_s32(a, b) (a < b)
+#define vcltq_s64(a, b) (a < b)
+#define vcltq_u8(a, b) (a < b)
+#define vcltq_u16(a, b) (a < b)
+#define vcltq_u32(a, b) (a < b)
+#define vcltq_u64(a, b) (a < b)
+#define vcltq_f16(a, b) (a < b)
+#define vcltq_f32(a, b) (a < b)
+#define vcltq_f64(a, b) (a < b)
+
+// vcle
+#define vcle_s8(a, b) (a <= b)
+#define vcle_s16(a, b) (a <= b)
+#define vcle_s32(a, b) (a <= b)
+#define vcle_s64(a, b) (a <= b)
+#define vcle_u8(a, b) (a <= b)
+#define vcle_u16(a, b) (a <= b)
+#define vcle_u32(a, b) (a <= b)
+#define vcle_u64(a, b) (a <= b)
+#define vcle_f16(a, b) (a <= b)
+#define vcle_f32(a, b) (a <= b)
+#define vcle_f64(a, b) (a <= b)
+#define vcleq_s8(a, b) (a <= b)
+#define vcleq_s16(a, b) (a <= b)
+#define vcleq_s32(a, b) (a <= b)
+#define vcleq_s64(a, b) (a <= b)
+#define vcleq_u8(a, b) (a <= b)
+#define vcleq_u16(a, b) (a <= b)
+#define vcleq_u32(a, b) (a <= b)
+#define vcleq_u64(a, b) (a <= b)
+#define vcleq_f16(a, b) (a <= b)
+#define vcleq_f32(a, b) (a <= b)
+#define vcleq_f64(a, b) (a <= b)
+
+// veor
+#define veor_s8(a, b) (a ^ b)
+#define veor_s16(a, b) (a ^ b)
+#define veor_s32(a, b) (a ^ b)
+#define veor_s64(a, b) (a ^ b)
+#define veor_u8(a, b) (a ^ b)
+#define veor_u16(a, b) (a ^ b)
+#define veor_u32(a, b) (a ^ b)
+#define veor_u64(a, b) (a ^ b)
+#define veorq_s8(a, b) (a ^ b)
+#define veorq_s16(a, b) (a ^ b)
+#define veorq_s32(a, b) (a ^ b)
+#define veorq_s64(a, b) (a ^ b)
+#define veorq_u8(a, b) (a ^ b)
+#define veorq_u16(a, b) (a ^ b)
+#define veorq_u32(a, b) (a ^ b)
+#define veorq_u64(a, b) (a ^ b)
+
+// vext
+#define vext_s8(a, b, n)  __builtin_mpl_vector_merge_v8i8(a, b, n)
+#define vext_s16(a, b, n) __builtin_mpl_vector_merge_v4i16(a, b, n)
+#define vext_s32(a, b, n) __builtin_mpl_vector_merge_v2i32(a, b, n)
+#define vext_s64(a, b, n) __builtin_mpl_vector_merge_v1i64(a, b, n)
+#define vext_u8(a, b, n) __builtin_mpl_vector_merge_v8u8(a, b, n)
+#define vext_u16(a, b, n) __builtin_mpl_vector_merge_v4u16(a, b, n)
+#define vext_u32(a, b, n) __builtin_mpl_vector_merge_v2u32(a, b, n)
+#define vext_u64(a, b, n) __builtin_mpl_vector_merge_v1u64(a, b, n)
+#define vext_f16(a, b, n) __builtin_mpl_vector_merge_v4f16(a, b, n)
+#define vext_f32(a, b, n) __builtin_mpl_vector_merge_v2f32(a, b, n)
+#define vext_f64(a, b, n) __builtin_mpl_vector_merge_v1f64(a, b, n)
+#define vextq_s8(a, b, n) __builtin_mpl_vector_merge_v16i8(a, b, n)
+#define vextq_s16(a, b, n) __builtin_mpl_vector_merge_v8i16(a, b, n)
+#define vextq_s32(a, b, n) __builtin_mpl_vector_merge_v4i32(a, b, n)
+#define vextq_s64(a, b, n) __builtin_mpl_vector_merge_v2i64(a, b, n)
+#define vextq_u8(a, b, n) __builtin_mpl_vector_merge_v16u8(a, b, n)
+#define vextq_u16(a, b, n) __builtin_mpl_vector_merge_v8u16(a, b, n)
+#define vextq_u32(a, b, n) __builtin_mpl_vector_merge_v4u32(a, b, n)
+#define vextq_u64(a, b, n) __builtin_mpl_vector_merge_v2u64(a, b, n)
+#define vextq_f16(a, b, n) __builtin_mpl_vector_merge_v8f16(a, b, n)
+#define vextq_f32(a, b, n) __builtin_mpl_vector_merge_v4f32(a, b, n)
+#define vextq_f64(a, b, n) __builtin_mpl_vector_merge_v2f64(a, b, n)
+
+// vget_high
+#define vget_high_s8(a)  __builtin_mpl_vector_get_high_v16i8(a)
+#define vget_high_s16(a) __builtin_mpl_vector_get_high_v8i16(a)
+#define vget_high_s32(a) __builtin_mpl_vector_get_high_v4i32(a)
+#define vget_high_s64(a) __builtin_mpl_vector_get_high_v2i64(a)
+#define vget_high_u8(a) __builtin_mpl_vector_get_high_v16u8(a)
+#define vget_high_u16(a) __builtin_mpl_vector_get_high_v8u16(a)
+#define vget_high_u32(a) __builtin_mpl_vector_get_high_v4u32(a)
+#define vget_high_u64(a) __builtin_mpl_vector_get_high_v2u64(a)
+#define vget_high_f16(a) __builtin_mpl_vector_get_high_v4f16(a)
+#define vget_high_f32(a) __builtin_mpl_vector_get_high_v2f32(a)
+#define vget_high_f64(a) __builtin_mpl_vector_get_high_v1f64(a)
+
+// vget_lane
+#define vget_lane_s8(a, n)  __builtin_mpl_vector_get_element_v8i8(a, n)
+#define vget_lane_s16(a, n) __builtin_mpl_vector_get_element_v4i16(a, n)
+#define vget_lane_s32(a, n) __builtin_mpl_vector_get_element_v2i32(a, n)
+#define vget_lane_s64(a, n) __builtin_mpl_vector_get_element_v1i64(a, n)
+#define vget_lane_u8(a, n) __builtin_mpl_vector_get_element_v8u8(a, n)
+#define vget_lane_u16(a, n) __builtin_mpl_vector_get_element_v4u16(a, n)
+#define vget_lane_u32(a, n) __builtin_mpl_vector_get_element_v2u32(a, n)
+#define vget_lane_u64(a, n) __builtin_mpl_vector_get_element_v1u64(a, n)
+#define vget_lane_f16(a, n) __builtin_mpl_vector_get_element_v4f16(a, n)
+#define vget_lane_f32(a, n) __builtin_mpl_vector_get_element_v2f32(a, n)
+#define vget_lane_f64(a, n) __builtin_mpl_vector_get_element_v1f64(a, n)
+#define vgetq_lane_s8(a, n) __builtin_mpl_vector_get_element_v16i8(a, n)
+#define vgetq_lane_s16(a, n) __builtin_mpl_vector_get_element_v8i16(a, n)
+#define vgetq_lane_s32(a, n) __builtin_mpl_vector_get_element_v4i32(a, n)
+#define vgetq_lane_s64(a, n) __builtin_mpl_vector_get_element_v2i64(a, n)
+#define vgetq_lane_u8(a, n) __builtin_mpl_vector_get_element_v16u8(a, n)
+#define vgetq_lane_u16(a, n) __builtin_mpl_vector_get_element_v8u16(a, n)
+#define vgetq_lane_u32(a, n) __builtin_mpl_vector_get_element_v4u32(a, n)
+#define vgetq_lane_u64(a, n) __builtin_mpl_vector_get_element_v2u64(a, n)
+#define vgetq_lane_f16(a, n) __builtin_mpl_vector_get_element_v8f16(a, n)
+#define vgetq_lane_f32(a, n) __builtin_mpl_vector_get_element_v4f32(a, n)
+#define vgetq_lane_f64(a, n) __builtin_mpl_vector_get_element_v2f64(a, n)
+
+// vget_low
+#define vget_low_s8(a)  __builtin_mpl_vector_get_low_v16i8(a)
+#define vget_low_s16(a) __builtin_mpl_vector_get_low_v8i16(a)
+#define vget_low_s32(a) __builtin_mpl_vector_get_low_v4i32(a)
+#define vget_low_s64(a) __builtin_mpl_vector_get_low_v2i64(a)
+#define vget_low_u8(a) __builtin_mpl_vector_get_low_v16u8(a)
+#define vget_low_u16(a) __builtin_mpl_vector_get_low_v8u16(a)
+#define vget_low_u32(a) __builtin_mpl_vector_get_low_v4u32(a)
+#define vget_low_u64(a) __builtin_mpl_vector_get_low_v2u64(a)
+#define vget_low_f16(a) __builtin_mpl_vector_get_low_v4f16(a)
+#define vget_low_f32(a) __builtin_mpl_vector_get_low_v2f32(a)
+#define vget_low_f64(a) __builtin_mpl_vector_get_low_v1f64(a)
+
+// vld1
+#define vld1_s8(a)  __builtin_mpl_vector_load_v8i8(a)
+#define vld1_s16(a) __builtin_mpl_vector_load_v4i16(a)
+#define vld1_s32(a) __builtin_mpl_vector_load_v2i32(a)
+#define vld1_s64(a) __builtin_mpl_vector_load_v1i64(a)
+#define vld1_u8(a) __builtin_mpl_vector_load_v8u8(a)
+#define vld1_u16(a) __builtin_mpl_vector_load_v4u16(a)
+#define vld1_u32(a) __builtin_mpl_vector_load_v2u32(a)
+#define vld1_u64(a) __builtin_mpl_vector_load_v1u64(a)
+#define vld1_f16(a) __builtin_mpl_vector_load_v4f16(a)
+#define vld1_f32(a) __builtin_mpl_vector_load_v2f32(a)
+#define vld1_f64(a) __builtin_mpl_vector_load_v1f64(a)
+#define vld1q_s8(a) __builtin_mpl_vector_load_v16i8(a)
+#define vld1q_s16(a) __builtin_mpl_vector_load_v8i16(a)
+#define vld1q_s32(a) __builtin_mpl_vector_load_v4i32(a)
+#define vld1q_s64(a) __builtin_mpl_vector_load_v2i64(a)
+#define vld1q_u8(a) __builtin_mpl_vector_load_v16u8(a)
+#define vld1q_u16(a) __builtin_mpl_vector_load_v8u16(a)
+#define vld1q_u32(a) __builtin_mpl_vector_load_v4u32(a)
+#define vld1q_u64(a) __builtin_mpl_vector_load_v2u64(a)
+#define vld1q_f16(a) __builtin_mpl_vector_load_v8f16(a)
+#define vld1q_f32(a) __builtin_mpl_vector_load_v4f32(a)
+#define vld1q_f64(a) __builtin_mpl_vector_load_v2f64(a)
+
+// vmlal
+#define vmlal_s8(acc, a, b)  __builtin_mpl_vector_madd_v8i8(acc, a, b)
+#define vmlal_s16(acc, a, b) __builtin_mpl_vector_madd_v4i16(acc, a, b)
+#define vmlal_s32(acc, a, b) __builtin_mpl_vector_madd_v2i32(acc, a, b)
+#define vmlal_u8(acc, a, b) __builtin_mpl_vector_madd_v8u8(acc, a, b)
+#define vmlal_u16(acc, a, b) __builtin_mpl_vector_madd_v4u16(acc, a, b)
+#define vmlal_u32(acc, a, b) __builtin_mpl_vector_madd_v2u32(acc, a, b)
+
+// vmovl
+#define vmovl_s32(a) __builtin_mpl_vector_widen_low_v2i32(a)
+#define vmovl_s16(a) __builtin_mpl_vector_widen_low_v4i16(a)
+#define vmovl_s8(a) __builtin_mpl_vector_widen_low_v8i8(a)
+#define vmovl_u32(a) __builtin_mpl_vector_widen_low_v2u32(a)
+#define vmovl_u16(a) __builtin_mpl_vector_widen_low_v4u16(a)
+#define vmovl_u8(a) __builtin_mpl_vector_widen_low_v8u8(a)
+
+// vmovl_high
+#define vmovl_high_s32(a) __builtin_mpl_vector_widen_high_v2i32(a)
+#define vmovl_high_s16(a) __builtin_mpl_vector_widen_high_v4i16(a)
+#define vmovl_high_s8(a) __builtin_mpl_vector_widen_high_v8i8(a)
+#define vmovl_high_u32(a) __builtin_mpl_vector_widen_high_v2u32(a)
+#define vmovl_high_u16(a) __builtin_mpl_vector_widen_high_v4u16(a)
+#define vmovl_high_u8(a) __builtin_mpl_vector_widen_high_v8u8(a)
+
+// vmovn
+#define vmovn_s64(a) __builtin_mpl_vector_narrow_low_v2i64(a)
+#define vmovn_s32(a) __builtin_mpl_vector_narrow_low_v4i32(a)
+#define vmovn_s16(a) __builtin_mpl_vector_narrow_low_v8i16(a)
+#define vmovn_u64(a) __builtin_mpl_vector_narrow_low_v2u64(a)
+#define vmovn_u32(a) __builtin_mpl_vector_narrow_low_v4u32(a)
+#define vmovn_u16(a) __builtin_mpl_vector_narrow_low_v8u16(a)
+
+// vmovn_high
+#define vmovn_high_s64(a, b) __builtin_mpl_vector_narrow_high_v2i64(a, b)
+#define vmovn_high_s32(a, b) __builtin_mpl_vector_narrow_high_v4i32(a, b)
+#define vmovn_high_s16(a, b) __builtin_mpl_vector_narrow_high_v8i16(a, b)
+#define vmovn_high_u64(a, b) __builtin_mpl_vector_narrow_high_v2u64(a, b)
+#define vmovn_high_u32(a, b) __builtin_mpl_vector_narrow_high_v4u32(a, b)
+#define vmovn_high_u16(a, b) __builtin_mpl_vector_narrow_high_v8u16(a, b)
+
+// vmull
+#define vmull_s8(a, b)  __builtin_mpl_vector_mull_low_v8i8(a, b)
+#define vmull_s16(a, b) __builtin_mpl_vector_mull_low_v4i16(a, b)
+#define vmull_s32(a, b) __builtin_mpl_vector_mull_low_v2i32(a, b)
+#define vmull_u8(a, b) __builtin_mpl_vector_mull_low_v8u8(a, b)
+#define vmull_u16(a, b) __builtin_mpl_vector_mull_low_v4u16(a, b)
+#define vmull_u32(a, b) __builtin_mpl_vector_mull_low_v2u32(a, b)
+
+// vmull_high
+#define vmull_high_s8(a, b)  __builtin_mpl_vector_mull_high_v8i8(a, b)
+#define vmull_high_s16(a, b) __builtin_mpl_vector_mull_high_v4i16(a, b)
+#define vmull_high_s32(a, b) __builtin_mpl_vector_mull_high_v2i32(a, b)
+#define vmull_high_u8(a, b) __builtin_mpl_vector_mull_high_v8u8(a, b)
+#define vmull_high_u16(a, b) __builtin_mpl_vector_mull_high_v4u16(a, b)
+#define vmull_high_u32(a, b) __builtin_mpl_vector_mull_high_v2u32(a, b)
+
+// vor
+#define vor_s8(a, b) (a | b)
+#define vor_s16(a, b) (a | b)
+#define vor_s32(a, b) (a | b)
+#define vor_s64(a, b) (a | b)
+#define vor_u8(a, b) (a | b)
+#define vor_u16(a, b) (a | b)
+#define vor_u32(a, b) (a | b)
+#define vor_u64(a, b) (a | b)
+#define vorq_s8(a, b) (a | b)
+#define vorq_s16(a, b) (a | b)
+#define vorq_s32(a, b) (a | b)
+#define vorq_s64(a, b) (a | b)
+#define vorq_u8(a, b) (a | b)
+#define vorq_u16(a, b) (a | b)
+#define vorq_u32(a, b) (a | b)
+#define vorq_u64(a, b) (a | b)
+
+// vpadal (add and accumulate long pairwise)
+#define vpadal_s8(a, b) __builtin_mpl_vector_pairwise_adalp_v8i8(a, b)
+#define vpadal_s16(a, b) __builtin_mpl_vector_pairwise_adalp_v4i16(a, b)
+#define vpadal_s32(a, b) __builtin_mpl_vector_pairwise_adalp_v2i32(a, b)
+#define vpadal_u8(a, b) __builtin_mpl_vector_pairwise_adalp_v8u8(a, b)
+#define vpadal_u16(a, b) __builtin_mpl_vector_pairwise_adalp_v4u16(a, b)
+#define vpadal_u32(a, b) __builtin_mpl_vector_pairwise_adalp_v2u32(a, b)
+#define vpadalq_s8(a, b) __builtin_mpl_vector_pairwise_adalp_v16i8(a, b)
+#define vpadalq_s16(a, b) __builtin_mpl_vector_pairwise_adalp_v8i16(a, b)
+#define vpadalq_s32(a, b) __builtin_mpl_vector_pairwise_adalp_v4i32(a, b)
+#define vpadalq_u8(a, b) __builtin_mpl_vector_pairwise_adalp_v16u8(a, b)
+#define vpadalq_u16(a, b) __builtin_mpl_vector_pairwise_adalp_v8u16(a, b)
+#define vpadalq_u32(a, b) __builtin_mpl_vector_pairwise_adalp_v4u32(a, b)
+
+// vpaddl
+#define vpaddl_s8(a)  __builtin_mpl_vector_pairwise_add_v8i8(a)
+#define vpaddl_s16(a) __builtin_mpl_vector_pairwise_add_v4i16(a)
+#define vpaddl_s32(a) __builtin_mpl_vector_pairwise_add_v2i32(a)
+#define vpaddl_u8(a) __builtin_mpl_vector_pairwise_add_v8u8(a)
+#define vpaddl_u16(a) __builtin_mpl_vector_pairwise_add_v4u16(a)
+#define vpaddl_u32(a) __builtin_mpl_vector_pairwise_add_v2u32(a)
+#define vpaddlq_s8(a)  __builtin_mpl_vector_pairwise_add_v16i8(a)
+#define vpaddlq_s16(a) __builtin_mpl_vector_pairwise_add_v8i16(a)
+#define vpaddlq_s32(a) __builtin_mpl_vector_pairwise_add_v4i32(a)
+#define vpaddlq_u8(a) __builtin_mpl_vector_pairwise_add_v16u8(a)
+#define vpaddlq_u16(a) __builtin_mpl_vector_pairwise_add_v8u16(a)
+#define vpaddlq_u32(a) __builtin_mpl_vector_pairwise_add_v4u32(a)
+
+// vqtbl1
+#define vqtbl1_s8(a, b) __builtin_mpl_vector_table_lookup_v8i8(a, b)
+#define vqtbl1_u8(a, b) __builtin_mpl_vector_table_lookup_v8u8(a, b)
+#define vqtbl1q_s8(a, b) __builtin_mpl_vector_table_lookup_v16i8(a, b)
+#define vqtbl1q_u8(a, b) __builtin_mpl_vector_table_lookup_v16u8(a, b)
+
+// vreinterpret 8
+#define vreinterpret_s16_s8(a) ((int16x4_t)a)
+#define vreinterpret_s32_s8(a) ((int32x2_t)a)
+#define vreinterpret_s64_s8(a) ((int64x1_t)a)
+#define vreinterpret_u16_u8(a) ((uint16x4_t)a)
+#define vreinterpret_u32_u8(a) ((uint32x2_t)a)
+#define vreinterpret_u64_u8(a) ((uint64x1_t)a)
+#define vreinterpret_f16_s8(a) ((float16x4_t)a)
+#define vreinterpret_f32_s8(a) ((float32x2_t)a)
+#define vreinterpret_f64_s8(a) ((float64x1_t)a)
+#define vreinterpret_f16_u8(a) ((float16x4_t)a)
+#define vreinterpret_f32_u8(a) ((float32x2_t)a)
+#define vreinterpret_f64_u8(a) ((float64x1_t)a)
+#define vreinterpretq_s16_s8(a) ((int16x8_t)a)
+#define vreinterpretq_s32_s8(a) ((int32x4_t)a)
+#define vreinterpretq_s64_s8(a) ((int64x2_t)a)
+#define vreinterpretq_u16_u8(a) ((uint16x8_t)a)
+#define vreinterpretq_u32_u8(a) ((uint32x4_t)a)
+#define vreinterpretq_u64_u8(a) ((uint64x2_t)a)
+#define vreinterpretq_f16_s8(a) ((float16x8_t)a)
+#define vreinterpretq_f32_s8(a) ((float32x4_t)a)
+#define vreinterpretq_f64_s8(a) ((float64x2_t)a)
+#define vreinterpretq_f16_u8(a) ((float16x8_t)a)
+#define vreinterpretq_f32_u8(a) ((float32x4_t)a)
+#define vreinterpretq_f64_u8(a) ((float64x2_t)a)
+
+// vreinterpret 16
+#define vreinterpret_s8_s16(a) ((int8x8_t)a)
+#define vreinterpret_s32_s16(a) ((int32x2_t)a)
+#define vreinterpret_s64_s16(a) ((int64x1_t)a)
+#define vreinterpret_u8_u16(a) ((uint8x8_t)a)
+#define vreinterpret_u32_u16(a) ((uint32x2_t)a)
+#define vreinterpret_u64_u16(a) ((uint64x1_t)a)
+#define vreinterpret_f16_s16(a) ((float16x4_t)a)
+#define vreinterpret_f32_s16(a) ((float32x2_t)a)
+#define vreinterpret_f64_s16(a) ((float64x1_t)a)
+#define vreinterpret_f16_u16(a) ((float16x4_t)a)
+#define vreinterpret_f32_u16(a) ((float32x2_t)a)
+#define vreinterpret_f64_u16(a) ((float64x1_t)a)
+#define vreinterpretq_s8_s16(a) ((int16x8_t)a)
+#define vreinterpretq_s32_s16(a) ((int32x4_t)a)
+#define vreinterpretq_s64_s16(a) ((int64x2_t)a)
+#define vreinterpretq_u8_u16(a) ((uint16x8_t)a)
+#define vreinterpretq_u32_u16(a) ((uint32x4_t)a)
+#define vreinterpretq_u64_u16(a) ((uint64x2_t)a)
+#define vreinterpretq_f16_s16(a) ((float16x8_t)a)
+#define vreinterpretq_f32_s16(a) ((float32x4_t)a)
+#define vreinterpretq_f64_s16(a) ((float64x2_t)a)
+#define vreinterpretq_f16_u16(a) ((float16x8_t)a)
+#define vreinterpretq_f32_u16(a) ((float32x4_t)a)
+#define vreinterpretq_f64_u16(a) ((float64x2_t)a)
+
+// vreinterpret 32
+#define vreinterpret_s8_s32(a) ((int8x8_t)a)
+#define vreinterpret_s16_s32(a) ((int16x4_t)a)
+#define vreinterpret_s64_s32(a) ((int64x1_t)a)
+#define vreinterpret_u8_u32(a) ((uint8x8_t)a)
+#define vreinterpret_u16_u32(a) ((uint16x4_t)a)
+#define vreinterpret_u64_u32(a) ((uint64x1_t)a)
+#define vreinterpret_f16_s32(a) ((float16x4_t)a)
+#define vreinterpret_f32_s32(a) ((float32x2_t)a)
+#define vreinterpret_f64_s32(a) ((float64x1_t)a)
+#define vreinterpret_f16_u32(a) ((float16x4_t)a)
+#define vreinterpret_f32_u32(a) ((float32x2_t)a)
+#define vreinterpret_f64_u32(a) ((float64x1_t)a)
+#define vreinterpretq_s8_s32(a) ((int16x8_t)a)
+#define vreinterpretq_s16_s32(a) ((int16x8_t)a)
+#define vreinterpretq_s64_s32(a) ((int64x2_t)a)
+#define vreinterpretq_u8_u32(a) ((uint16x8_t)a)
+#define vreinterpretq_u16_u32(a) ((uint16x8_t)a)
+#define vreinterpretq_u64_u32(a) ((uint64x2_t)a)
+#define vreinterpretq_f16_s32(a) ((float16x8_t)a)
+#define vreinterpretq_f32_s32(a) ((float32x4_t)a)
+#define vreinterpretq_f64_s32(a) ((float64x2_t)a)
+#define vreinterpretq_f16_u32(a) ((float16x8_t)a)
+#define vreinterpretq_f32_u32(a) ((float32x4_t)a)
+#define vreinterpretq_f64_u32(a) ((float64x2_t)a)
+
+// vreinterpret 64
+#define vreinterpret_s8_s64(a) ((int8x8_t)a)
+#define vreinterpret_s16_s64(a) ((int16x4_t)a)
+#define vreinterpret_s32_s64(a) ((int32x2_t)a)
+#define vreinterpret_u8_u64(a) ((uint8x8_t)a)
+#define vreinterpret_u16_u64(a) ((uint16x4_t)a)
+#define vreinterpret_u32_u64(a) ((uint32x2_t)a)
+#define vreinterpret_f16_s64(a) ((float16x4_t)a)
+#define vreinterpret_f32_s64(a) ((float32x2_t)a)
+#define vreinterpret_f64_s64(a) ((float64x1_t)a)
+#define vreinterpret_f16_u64(a) ((float16x4_t)a)
+#define vreinterpret_f32_u64(a) ((float32x2_t)a)
+#define vreinterpret_f64_u64(a) ((float64x1_t)a)
+#define vreinterpretq_s8_s64(a) ((int8x16_t)a)
+#define vreinterpretq_s16_s64(a) ((int16x8_t)a)
+#define vreinterpretq_s32_s64(a) ((int32x4_t)a)
+#define vreinterpretq_u8_u64(a) ((uint8x16_t)a)
+#define vreinterpretq_u16_u64(a) ((uint16x8_t)a)
+#define vreinterpretq_u32_u64(a) ((uint32x4_t)a)
+#define vreinterpretq_f16_s64(a) ((float16x8_t)a)
+#define vreinterpretq_f32_s64(a) ((float32x4_t)a)
+#define vreinterpretq_f64_s64(a) ((float64x2_t)a)
+#define vreinterpretq_f16_u64(a) ((float16x8_t)a)
+#define vreinterpretq_f32_u64(a) ((float32x4_t)a)
+#define vreinterpretq_f64_u64(a) ((float64x2_t)a)
+
+// vrev32
+#define vrev32_s8(a) __builtin_mpl_vector_reverse_v8i8(a)
+#define vrev32_s16(a) __builtin_mpl_vector_reverse_v4i16(a)
+#define vrev32_u8(a) __builtin_mpl_vector_reverse_v8u8(a)
+#define vrev32_u16(a) __builtin_mpl_vector_reverse_v4u16(a)
+#define vrev32q_s8(a) __builtin_mpl_vector_reverse_v16i8(a)
+#define vrev32q_s16(a) __builtin_mpl_vector_reverse_v8i16(a)
+#define vrev32q_u8(a) __builtin_mpl_vector_reverse_v16u8(a)
+#define vrev32q_u16(a) __builtin_mpl_vector_reverse_v8u16(a)
+
+// vset_lane
+#define vset_lane_s8(v, a, n)  __builtin_mpl_vector_set_element_v8i8(v, a, n)
+#define vset_lane_s16(v, a, n) __builtin_mpl_vector_set_element_v4i16(v, a, n)
+#define vset_lane_s32(v, a, n) __builtin_mpl_vector_set_element_v2i32(v, a, n)
+#define vset_lane_s64(v, a, n) __builtin_mpl_vector_set_element_v1i64(v, a, n)
+#define vset_lane_u8(v, a, n) __builtin_mpl_vector_set_element_v8u8(v, a, n)
+#define vset_lane_u16(v, a, n) __builtin_mpl_vector_set_element_v4u16(v, a, n)
+#define vset_lane_u32(v, a, n) __builtin_mpl_vector_set_element_v2u32(v, a, n)
+#define vset_lane_u64(v, a, n) __builtin_mpl_vector_set_element_v1u64(v, a, n)
+#define vset_lane_f16(v, a, n) __builtin_mpl_vector_set_element_v4f16(v, a, n)
+#define vset_lane_f32(v, a, n) __builtin_mpl_vector_set_element_v2f32(v, a, n)
+#define vset_lane_f64(v, a, n) __builtin_mpl_vector_set_element_v1f64(v, a, n)
+#define vsetq_lane_s8(v, a, n) __builtin_mpl_vector_set_element_v16i8(v, a, n)
+#define vsetq_lane_s16(v, a, n) __builtin_mpl_vector_set_element_v8i16(v, a, n)
+#define vsetq_lane_s32(v, a, n) __builtin_mpl_vector_set_element_v4i32(v, a, n)
+#define vsetq_lane_s64(v, a, n) __builtin_mpl_vector_set_element_v2i64(v, a, n)
+#define vsetq_lane_u8(v, a, n) __builtin_mpl_vector_set_element_v16u8(v, a, n)
+#define vsetq_lane_u16(v, a, n) __builtin_mpl_vector_set_element_v8u16(v, a, n)
+#define vsetq_lane_u32(v, a, n) __builtin_mpl_vector_set_element_v4u32(v, a, n)
+#define vsetq_lane_u64(v, a, n) __builtin_mpl_vector_set_element_v2u64(v, a, n)
+#define vsetq_lane_f16(v, a, n) __builtin_mpl_vector_set_element_v8f16(v, a, n)
+#define vsetq_lane_f32(v, a, n) __builtin_mpl_vector_set_element_v4f32(v, a, n)
+#define vsetq_lane_f64(v, a, n) __builtin_mpl_vector_set_element_v2f64(v, a, n)
+
+// vshl
+#define vshl_s8(a, b) (a << b)
+#define vshl_s16(a, b) (a << b)
+#define vshl_s32(a, b) (a << b)
+#define vshl_s64(a, b) (a << b)
+#define vshl_u8(a, b) (a << b)
+#define vshl_u16(a, b) (a << b)
+#define vshl_u32(a, b) (a << b)
+#define vshl_u64(a, b) (a << b)
+#define vshlq_s8(a, b) (a << b)
+#define vshlq_s16(a, b) (a << b)
+#define vshlq_s32(a, b) (a << b)
+#define vshlq_s64(a, b) (a << b)
+#define vshlq_u8(a, b) (a << b)
+#define vshlq_u16(a, b) (a << b)
+#define vshlq_u32(a, b) (a << b)
+#define vshlq_u64(a, b) (a << b)
+
+// vshl_n
+#define vshlq_n_s64(a, n) __builtin_mpl_vector_shli_v2i64(a, n)
+#define vshlq_n_s32(a, n) __builtin_mpl_vector_shli_v4i32(a, n)
+#define vshlq_n_s16(a, n) __builtin_mpl_vector_shli_v8i16(a, n)
+#define vshlq_n_s8(a, n) __builtin_mpl_vector_shli_v16i8(a, n)
+#define vshlq_n_u64(a, n) __builtin_mpl_vector_shli_v2u64(a, n)
+#define vshlq_n_u32(a, n) __builtin_mpl_vector_shli_v4u32(a, n)
+#define vshlq_n_u16(a, n) __builtin_mpl_vector_shli_v8u16(a, n)
+#define vshlq_n_u8(a, n) __builtin_mpl_vector_shli_v16u8(a, n)
+#define vshl_n_s64(a, n) __builtin_mpl_vector_shli_v1i64(a, n)
+#define vshl_n_s32(a, n) __builtin_mpl_vector_shli_v2i32(a, n)
+#define vshl_n_s16(a, n) __builtin_mpl_vector_shli_v4i16(a, n)
+#define vshl_n_s8(a, n) __builtin_mpl_vector_shli_v8i8(a, n)
+#define vshl_n_u64(a, n) __builtin_mpl_vector_shli_v1u64(a, n)
+#define vshl_n_u32(a, n) __builtin_mpl_vector_shli_v2u32(a, n)
+#define vshl_n_u16(a, n) __builtin_mpl_vector_shli_v4u16(a, n)
+#define vshl_n_u8(a, n) __builtin_mpl_vector_shli_v8u8(a, n)
+
+// vshr
+#define vshr_s8(a, b) (a >> b)
+#define vshr_s16(a, b) (a >> b)
+#define vshr_s32(a, b) (a >> b)
+#define vshr_s64(a, b) (a >> b)
+#define vshr_u8(a, b) (a >> b)
+#define vshr_u16(a, b) (a >> b)
+#define vshr_u32(a, b) (a >> b)
+#define vshr_u64(a, b) (a >> b)
+#define vshrq_s8(a, b) (a >> b)
+#define vshrq_s16(a, b) (a >> b)
+#define vshrq_s32(a, b) (a >> b)
+#define vshrq_s64(a, b) (a >> b)
+#define vshrq_u8(a, b) (a >> b)
+#define vshrq_u16(a, b) (a >> b)
+#define vshrq_u32(a, b) (a >> b)
+#define vshrq_u64(a, b) (a >> b)
+
+// vshr_n
+#define vshrq_n_s64(a, n) __builtin_mpl_vector_shri_v2i64(a, n)
+#define vshrq_n_s32(a, n) __builtin_mpl_vector_shri_v4i32(a, n)
+#define vshrq_n_s16(a, n) __builtin_mpl_vector_shri_v8i16(a, n)
+#define vshrq_n_s8(a, n) __builtin_mpl_vector_shri_v16i8(a, n)
+#define vshrq_n_u64(a, n) __builtin_mpl_vector_shru_v2u64(a, n)
+#define vshrq_n_u32(a, n) __builtin_mpl_vector_shru_v4u32(a, n)
+#define vshrq_n_u16(a, n) __builtin_mpl_vector_shru_v8u16(a, n)
+#define vshrq_n_u8(a, n) __builtin_mpl_vector_shru_v16u8(a, n)
+#define vshr_n_s64(a, n) __builtin_mpl_vector_shri_v1i64(a, n)
+#define vshr_n_s32(a, n) __builtin_mpl_vector_shri_v2i32(a, n)
+#define vshr_n_s16(a, n) __builtin_mpl_vector_shri_v4i16(a, n)
+#define vshr_n_s8(a, n) __builtin_mpl_vector_shri_v8i8(a, n)
+#define vshr_n_u64(a, n) __builtin_mpl_vector_shru_v1u64(a, n)
+#define vshr_n_u32(a, n) __builtin_mpl_vector_shru_v2u32(a, n)
+#define vshr_n_u16(a, n) __builtin_mpl_vector_shru_v4u16(a, n)
+#define vshr_n_u8(a, n) __builtin_mpl_vector_shru_v8u8(a, n)
+
+// vshrn_n
+#define vshrn_n_s16(a, n) __builtin_mpl_vector_shr_narrow_low_v8i16(a, n)
+#define vshrn_n_s32(a, n) __builtin_mpl_vector_shr_narrow_low_v4i32(a, n)
+#define vshrn_n_s64(a, n) __builtin_mpl_vector_shr_narrow_low_v2i64(a, n)
+#define vshrn_n_u16(a, n) __builtin_mpl_vector_shr_narrow_low_v8u16(a, n)
+#define vshrn_n_u32(a, n) __builtin_mpl_vector_shr_narrow_low_v4u32(a, n)
+#define vshrn_n_u64(a, n) __builtin_mpl_vector_shr_narrow_low_v2u64(a, n)
+
+// vst1
+#define vst1_s8(p, v)  __builtin_mpl_vector_store_v8i8(p, v)
+#define vst1_s16(p, v) __builtin_mpl_vector_store_v4i16(p, v)
+#define vst1_s32(p, v) __builtin_mpl_vector_store_v2i32(p, v)
+#define vst1_s64(p, v) __builtin_mpl_vector_store_v1i64(p, v)
+#define vst1_u8(p, v) __builtin_mpl_vector_store_v8u8(p, v)
+#define vst1_u16(p, v) __builtin_mpl_vector_store_v4u16(p, v)
+#define vst1_u32(p, v) __builtin_mpl_vector_store_v2u32(p, v)
+#define vst1_u64(p, v) __builtin_mpl_vector_store_v1u64(p, v)
+#define vst1_f16(p, v) __builtin_mpl_vector_store_v4f16(p, v)
+#define vst1_f32(p, v) __builtin_mpl_vector_store_v2f32(p, v)
+#define vst1_f64(p, v) __builtin_mpl_vector_store_v1f64(p, v)
+#define vst1q_s8(p, v) __builtin_mpl_vector_store_v16i8(p, v)
+#define vst1q_s16(p, v) __builtin_mpl_vector_store_v8i16(p, v)
+#define vst1q_s32(p, v) __builtin_mpl_vector_store_v4i32(p, v)
+#define vst1q_s64(p, v) __builtin_mpl_vector_store_v2i64(p, v)
+#define vst1q_u8(p, v) __builtin_mpl_vector_store_v16u8(p, v)
+#define vst1q_u16(p, v) __builtin_mpl_vector_store_v8u16(p, v)
+#define vst1q_u32(p, v) __builtin_mpl_vector_store_v4u32(p, v)
+#define vst1q_u64(p, v) __builtin_mpl_vector_store_v2u64(p, v)
+#define vst1q_f16(p, v) __builtin_mpl_vector_store_v8f16(p, v)
+#define vst1q_f32(p, v) __builtin_mpl_vector_store_v4f32(p, v)
+#define vst1q_f64(p, v) __builtin_mpl_vector_store_v2f64(p, v)
+
+// vsub
+#define vsub_s8(a, b) (a - b)
+#define vsub_s16(a, b) (a - b)
+#define vsub_s32(a, b) (a - b)
+#define vsub_s64(a, b) (a - b)
+#define vsub_u8(a, b) (a - b)
+#define vsub_u16(a, b) (a - b)
+#define vsub_u32(a, b) (a - b)
+#define vsub_u64(a, b) (a - b)
+#define vsub_f16(a, b) (a - b)
+#define vsub_f32(a, b) (a - b)
+#define vsub_f64(a, b) (a - b)
+#define vsubq_s8(a, b) (a - b)
+#define vsubq_s16(a, b) (a - b)
+#define vsubq_s32(a, b) (a - b)
+#define vsubq_s64(a, b) (a - b)
+#define vsubq_u8(a, b) (a - b)
+#define vsubq_u16(a, b) (a - b)
+#define vsubq_u32(a, b) (a - b)
+#define vsubq_u64(a, b) (a - b)
+#define vsubq_f16(a, b) (a - b)
+#define vsubq_f32(a, b) (a - b)
+#define vsubq_f64(a, b) (a - b)
+
+// vsub[lw]
+#define vsubl_s8(a, b) __builtin_mpl_vector_subl_low_v8i8(a, b)
+#define vsubl_s16(a, b) __builtin_mpl_vector_subl_low_v4i16(a, b)
+#define vsubl_s32(a, b) __builtin_mpl_vector_subl_low_v2i32(a, b)
+#define vsubl_u8(a, b) __builtin_mpl_vector_subl_low_v8u8(a, b)
+#define vsubl_u16(a, b) __builtin_mpl_vector_subl_low_v4u16(a, b)
+#define vsubl_u32(a, b) __builtin_mpl_vector_subl_low_v2u32(a, b)
+#define vsubl_high_s8(a, b) __builtin_mpl_vector_subl_high_v8i8(a, b)
+#define vsubl_high_s16(a, b) __builtin_mpl_vector_subl_high_v4i16(a, b)
+#define vsubl_high_s32(a, b) __builtin_mpl_vector_subl_high_v2i32(a, b)
+#define vsubl_high_u8(a, b) __builtin_mpl_vector_subl_high_v8u8(a, b)
+#define vsubl_high_u16(a, b) __builtin_mpl_vector_subl_high_v4u16(a, b)
+#define vsubl_high_u32(a, b) __builtin_mpl_vector_subl_high_v2u32(a, b)
+#define vsubw_s8(a, b) __builtin_mpl_vector_subw_low_v8i8(a, b)
+#define vsubw_s16(a, b) __builtin_mpl_vector_subw_low_v4i16(a, b)
+#define vsubw_s32(a, b) __builtin_mpl_vector_subw_low_v2i32(a, b)
+#define vsubw_u8(a, b) __builtin_mpl_vector_subw_low_v8u8(a, b)
+#define vsubw_u16(a, b) __builtin_mpl_vector_subw_low_v4u16(a, b)
+#define vsubw_u32(a, b) __builtin_mpl_vector_subw_low_v2u32(a, b)
+#define vsubw_high_s8(a, b) __builtin_mpl_vector_subw_high_v8i8(a, b)
+#define vsubw_high_s16(a, b) __builtin_mpl_vector_subw_high_v4i16(a, b)
+#define vsubw_high_s32(a, b) __builtin_mpl_vector_subw_high_v2i32(a, b)
+#define vsubw_high_u8(a, b) __builtin_mpl_vector_subw_high_v8u8(a, b)
+#define vsubw_high_u16(a, b) __builtin_mpl_vector_subw_high_v4u16(a, b)
+#define vsubw_high_u32(a, b) __builtin_mpl_vector_subw_high_v2u32(a, b)
+
+// vzip
+#define vzip_s8(a, b) __builtin_mpl_vector_zip_v8i8(a, b)
+#define vzip_s16(a, b) __builtin_mpl_vector_zip_v4i16(a, b)
+#define vzip_s32(a, b) __builtin_mpl_vector_zip_v2i32(a, b)
+#define vzip_u8(a, b) __builtin_mpl_vector_zip_v8u8(a, b)
+#define vzip_u16(a, b) __builtin_mpl_vector_zip_v4u16(a, b)
+#define vzip_u32(a, b) __builtin_mpl_vector_zip_v2u32(a, b)
+#define vzip_f32(a, b) __builtin_mpl_vector_zip_v2f32(a, b)
+
+#endif /* __ARM_NEON_H */
diff --git a/src/hir2mpl/ast_input/clang/src/ast_expr.cpp b/src/hir2mpl/ast_input/clang/src/ast_expr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..939940c59a1d384f0a6956952ff37cd442e032bf
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/src/ast_expr.cpp
@@ -0,0 +1,2963 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_expr.h"
+#include "ast_decl.h"
+#include "ast_macros.h"
+#include "mpl_logging.h"
+#include "feir_stmt.h"
+#include "feir_builder.h"
+#include "fe_utils_ast.h"
+#include "feir_type_helper.h"
+#include "fe_manager.h"
+#include "ast_stmt.h"
+#include "ast_util.h"
+#include "enhance_c_checker.h"
+#include "ror.h"
+#include "conditional_operator.h"
+
+#include <optional>
+
+namespace maple {
+
+namespace {
+
+const uint32 kOneByte = 8;
+
+template <class T>
+std::optional<T> GenerateConstCommon(Opcode op, const T p0, const T p1) {
+  switch (op) {
+    case OP_add: {
+      return p0 + p1;
+    }
+    case OP_sub: {
+      return p0 - p1;
+    }
+    case OP_mul: {
+      return p0 * p1;
+    }
+    case OP_div: {
+      return p0 / p1;
+    }
+    default: {
+      return std::nullopt;
+    }
+  }
+}
+
+template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
+T GenerateConst(Opcode op, T p0, T p1) {
+  auto res = GenerateConstCommon(op, p0, p1);
+  ASSERT(res, "invalid operations for floating point values");
+  return *res;
+}
+
+IntVal GenerateConst(Opcode op, const IntVal &p0, const IntVal &p1) {
+  ASSERT(p0.GetBitWidth() == p1.GetBitWidth() && p0.IsSigned() == p1.IsSigned(), "width and sign must be the same");
+
+  if (auto res = GenerateConstCommon(op, p0, p1)) {
+    return *res;
+  }
+
+  switch (op) {
+    case OP_rem: {
+      return p0 % p1;
+    }
+    case OP_shl: {
+      return p0 << p1;
+    }
+    case OP_lshr:
+    case OP_ashr: {
+      return p0 >> p1;
+    }
+    case OP_bior: {
+      return p0 | p1;
+    }
+    case OP_band: {
+      return p0 & p1;
+    }
+    case OP_bxor: {
+      return p0 ^ p1;
+    }
+    case OP_land:
+    case OP_cand: {
+      return IntVal(p0.GetExtValue() && p1.GetExtValue(), p0.GetBitWidth(), p0.IsSigned());
+    }
+    case OP_lior:
+    case OP_cior: {
+      return IntVal(p0.GetExtValue() || p1.GetExtValue(), p0.GetBitWidth(), p0.IsSigned());
+    }
+    default:
+      CHECK_FATAL(false, "unsupported operation");
+  }
+}
+
+MIRConst *MIRConstGenerator(MemPool *mp, MIRConst *konst0, MIRConst *konst1, Opcode op) {
+#define RET_VALUE_IF_CONST_TYPE_IS(TYPE)                                                         \
+  do {                                                                                           \
+    auto *c0 = safe_cast<TYPE>(konst0);                                                          \
+    if (c0) {                                                                                    \
+      auto *c1 = safe_cast<TYPE>(konst1);                                                        \
+      ASSERT(c1, "invalid const type");                                                          \
+      ASSERT(c0->GetType().GetPrimType() == c1->GetType().GetPrimType(), "types are not equal"); \
+      return mp->New<TYPE>(GenerateConst(op, c0->GetValue(), c1->GetValue()), c0->GetType());    \
+    }                                                                                            \
+  } while (0)
+
+  RET_VALUE_IF_CONST_TYPE_IS(MIRIntConst);
+  RET_VALUE_IF_CONST_TYPE_IS(MIRFloatConst);
+  RET_VALUE_IF_CONST_TYPE_IS(MIRDoubleConst);
+
+#undef RET_VALUE_IF_CONST_TYPE_IS
+
+  CHECK_FATAL(false, "unreachable code");
+}
+
+} // anonymous namespace
+
+// ---------- ASTValue ----------
+MIRConst *ASTValue::Translate2MIRConst() const {
+  switch (pty) {
+    case PTY_u1: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          val.u8, *GlobalTables::GetTypeTable().GetPrimType(PTY_u1));
+    }
+    case PTY_u8: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          val.u8, *GlobalTables::GetTypeTable().GetPrimType(PTY_u8));
+    }
+    case PTY_u16: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          val.u16, *GlobalTables::GetTypeTable().GetPrimType(PTY_u16));
+    }
+    case PTY_u32: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          val.u32, *GlobalTables::GetTypeTable().GetPrimType(PTY_u32));
+    }
+    case PTY_u64: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          val.u64, *GlobalTables::GetTypeTable().GetPrimType(PTY_u64));
+    }
+    case PTY_i8: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          static_cast<uint64>(static_cast<int64>(val.i8)), *GlobalTables::GetTypeTable().GetPrimType(PTY_i8));
+    }
+    case PTY_i16: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          static_cast<uint64>(static_cast<int64>(val.i16)), *GlobalTables::GetTypeTable().GetPrimType(PTY_i16));
+    }
+    case PTY_i32: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          static_cast<uint64>(static_cast<int64>(val.i32)), *GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+    }
+    case PTY_i64: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          static_cast<uint64>(val.i64), *GlobalTables::GetTypeTable().GetPrimType(PTY_i64));
+    }
+    case PTY_f32: {
+      return FEManager::GetModule().GetMemPool()->New<MIRFloatConst>(
+          val.f32, *GlobalTables::GetTypeTable().GetPrimType(PTY_f32));
+    }
+    case PTY_f64: {
+      return FEManager::GetModule().GetMemPool()->New<MIRDoubleConst>(
+          val.f64, *GlobalTables::GetTypeTable().GetPrimType(PTY_f64));
+    }
+    case PTY_a64: {
+      return FEManager::GetModule().GetMemPool()->New<MIRStrConst>(
+          val.strIdx, *GlobalTables::GetTypeTable().GetPrimType(PTY_a64));
+    }
+    default: {
+      CHECK_FATAL(false, "Unsupported Primitive type: %d", pty);
+    }
+  }
+}
+
+// ---------- ASTExpr ----------
+UniqueFEIRExpr ASTExpr::Emit2FEExpr(std::list<UniqueFEIRStmt> &stmts) const {
+  auto feirExpr = Emit2FEExprImpl(stmts);
+  if (feirExpr != nullptr) {
+    feirExpr->SetLoc(loc);
+  }
+  for (auto &stmt : stmts) {
+    if (!stmt->HasSetLOCInfo()) {
+      stmt->SetSrcLoc(loc);
+    }
+  }
+  return feirExpr;
+}
+
+UniqueFEIRExpr ASTExpr::ImplicitInitFieldValue(MIRType &type, std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRExpr implicitInitFieldExpr;
+  MIRTypeKind noInitExprKind = type.GetKind();
+  if (noInitExprKind == kTypeStruct || noInitExprKind == kTypeUnion) {
+    auto *structType = static_cast<MIRStructType*>(&type);
+    std::string tmpName = FEUtils::GetSequentialName("implicitInitStruct_");
+    UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, type);
+    for (size_t i = 0; i < structType->GetFieldsSize(); ++i) {
+      FieldID fieldID = 0;
+      FEUtils::TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID);
+      MIRType *fieldType = structType->GetFieldType(fieldID);
+      UniqueFEIRExpr fieldExpr = ImplicitInitFieldValue(*fieldType, stmts);
+      UniqueFEIRStmt fieldStmt = std::make_unique<FEIRStmtDAssign>(tmpVar->Clone(), std::move(fieldExpr), fieldID);
+      stmts.emplace_back(std::move(fieldStmt));
+    }
+    implicitInitFieldExpr = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
+  } else if (noInitExprKind == kTypeArray) {
+    auto *arrayType = static_cast<MIRArrayType*>(&type);
+    size_t elemSize = arrayType->GetElemType()->GetSize();
+    CHECK_FATAL(elemSize != 0, "elemSize is 0");
+    size_t numElems = arrayType->GetSize() / elemSize;
+    UniqueFEIRType typeNative = FEIRTypeHelper::CreateTypeNative(type);
+    std::string tmpName = FEUtils::GetSequentialName("implicitInitArray_");
+    UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, type);
+    UniqueFEIRExpr arrayExpr = FEIRBuilder::CreateExprDRead(tmpVar->Clone());
+    for (uint32 i = 0; i < numElems; ++i) {
+      UniqueFEIRExpr exprIndex = FEIRBuilder::CreateExprConstI32(i);
+      MIRType *fieldType = arrayType->GetElemType();
+      UniqueFEIRExpr exprElem = ImplicitInitFieldValue(*fieldType, stmts);
+      UniqueFEIRType typeNativeTmp = typeNative->Clone();
+      UniqueFEIRExpr arrayExprTmp = arrayExpr->Clone();
+      auto stmt = FEIRBuilder::CreateStmtArrayStoreOneStmtForC(std::move(exprElem), std::move(arrayExprTmp),
+                                                               std::move(exprIndex), std::move(typeNativeTmp),
+                                                               tmpName);
+      stmts.emplace_back(std::move(stmt));
+    }
+    implicitInitFieldExpr = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
+  } else if (noInitExprKind == kTypePointer) {
+    implicitInitFieldExpr = std::make_unique<FEIRExprConst>(static_cast<int64>(0), PTY_ptr);
+  } else {
+    CHECK_FATAL(noInitExprKind == kTypeScalar, "noInitExprKind isn't kTypeScalar");
+    implicitInitFieldExpr = FEIRBuilder::CreateExprConstAnyScalar(type.GetPrimType(), 0);
+  }
+  return implicitInitFieldExpr;
+}
+
+MIRConst *ASTExpr::GenerateMIRConstImpl() const {
+  CHECK_FATAL(isConstantFolded && value != nullptr, "Unsupported for ASTExpr: %d", op);
+  return value->Translate2MIRConst();
+}
+
+ASTExpr *ASTExpr::IgnoreParensImpl() {
+  return this;
+}
+
+// ---------- ASTDeclRefExpr ---------
+MIRConst *ASTDeclRefExpr::GenerateMIRConstImpl() const {
+  MIRType *mirType = refedDecl->GetTypeDesc().front();
+  if (mirType->GetKind() == kTypePointer &&
+      static_cast<MIRPtrType*>(mirType)->GetPointedType()->GetKind() == kTypeFunction) {
+    GStrIdx idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(refedDecl->GetName());
+    MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(idx);
+    CHECK_FATAL(funcSymbol != nullptr, "Should process func decl before var decl");
+    MIRFunction *mirFunc = funcSymbol->GetFunction();
+    CHECK_FATAL(mirFunc != nullptr, "Same name symbol with function: %s", refedDecl->GetName().c_str());
+    return FEManager::GetModule().GetMemPool()->New<MIRAddroffuncConst>(mirFunc->GetPuidx(), *mirType);
+  } else if (!isConstantFolded) {
+    ASTDecl *var = refedDecl;
+    MIRSymbol *mirSymbol;
+    if (var->IsGlobal()) {
+      mirSymbol = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl(
+          var->GenerateUniqueVarName(), *(var->GetTypeDesc().front()));
+    } else {
+      mirSymbol = FEManager::GetMIRBuilder().GetOrCreateLocalDecl(
+          var->GenerateUniqueVarName(), *(var->GetTypeDesc().front()));
+    }
+    return FEManager::GetModule().GetMemPool()->New<MIRAddrofConst>(
+        mirSymbol->GetStIdx(), 0, *(var->GetTypeDesc().front()));
+  } else {
+    return GetConstantValue()->Translate2MIRConst();
+  }
+}
+
+UniqueFEIRExpr ASTDeclRefExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  MIRType *mirType = refedDecl->GetTypeDesc().front();
+  UniqueFEIRExpr feirRefExpr;
+  auto attrs = refedDecl->GetGenericAttrs();
+  if (mirType->GetKind() == kTypePointer &&
+      static_cast<MIRPtrType*>(mirType)->GetPointedType()->GetKind() == kTypeFunction) {
+    feirRefExpr = FEIRBuilder::CreateExprAddrofFunc(refedDecl->GetName());
+  } else {
+    if (refedDecl->GetDeclKind() == kASTEnumConstant) {
+      return FEIRBuilder::CreateExprConstAnyScalar(refedDecl->GetTypeDesc().front()->GetPrimType(),
+          static_cast<ASTEnumConstant*>(refedDecl)->GetValue().GetExtValue());
+    }
+    UniqueFEIRVar feirVar =
+        FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *mirType, refedDecl->IsGlobal(), false);
+    feirVar->SetAttrs(attrs);
+    if (mirType->GetKind() == kTypeArray) {
+      feirRefExpr = FEIRBuilder::CreateExprAddrofVar(std::move(feirVar));
+    } else {
+      feirRefExpr = FEIRBuilder::CreateExprDRead(std::move(feirVar));
+    }
+  }
+  if (refedDecl->IsParam() && refedDecl->GetDeclKind() == kASTVar) {
+    PrimType promoted = static_cast<ASTVar*>(refedDecl)->GetPromotedType();
+    if (promoted != PTY_void) {
+      feirRefExpr = FEIRBuilder::CreateExprCastPrim(std::move(feirRefExpr), promoted);
+    }
+  }
+  return feirRefExpr;
+}
+
+// ---------- ASTCallExpr ----------
+std::string ASTCallExpr::CvtBuiltInFuncName(std::string builtInName) const {
+#define BUILTIN_FUNC(funcName) \
+    {"__builtin_"#funcName, #funcName},
+  static std::map<std::string, std::string> cvtMap = {
+#include "ast_builtin_func.def"
+#undef BUILTIN_FUNC
+  };
+  std::map<std::string, std::string>::const_iterator it = cvtMap.find(builtInName);
+  if (it != cvtMap.cend()) {
+    return cvtMap.find(builtInName)->second;
+  } else {
+    return builtInName;
+  }
+}
+
+std::unordered_map<std::string, ASTCallExpr::FuncPtrBuiltinFunc> ASTCallExpr::builtingFuncPtrMap =
+     ASTCallExpr::InitBuiltinFuncPtrMap();
+
+void ASTCallExpr::AddArgsExpr(const std::unique_ptr<FEIRStmtAssign> &callStmt, std::list<UniqueFEIRStmt> &stmts) const {
+  for (int32 i = (static_cast<int32>(args.size()) - 1); i >= 0; --i) {
+    UniqueFEIRExpr expr = args[i]->Emit2FEExpr(stmts);
+    callStmt->AddExprArgReverse(std::move(expr));
+  }
+  if (IsFirstArgRet()) {
+    UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(GetRetVarName(), *mirType, false, false);
+    UniqueFEIRExpr expr = FEIRBuilder::CreateExprAddrofVar(var->Clone());
+    callStmt->AddExprArgReverse(std::move(expr));
+  }
+  if (isIcall) {
+    UniqueFEIRExpr expr = calleeExpr->Emit2FEExpr(stmts);
+    InsertNonnullCheckingForIcall(expr, stmts);
+    InsertBoundaryCheckingInArgsForICall(stmts, expr);
+    callStmt->AddExprArgReverse(std::move(expr));
+  }
+  InsertBoundaryCheckingInArgs(stmts);
+  CheckNonnullFieldInStruct();
+}
+
+void ASTCallExpr::InsertNonnullCheckingForIcall(const UniqueFEIRExpr &expr, std::list<UniqueFEIRStmt> &stmts) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || expr->GetPrimType() != PTY_ptr) {
+    return;
+  }
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtAssertNonnull>(OP_assertnonnull, expr->Clone());
+  stmts.emplace_back(std::move(stmt));
+}
+
+UniqueFEIRExpr ASTCallExpr::AddRetExpr(const std::unique_ptr<FEIRStmtAssign> &callStmt) const {
+  UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(GetRetVarName(), *mirType, false, false);
+  var->SetAttrs(GetReturnVarAttrs());
+  UniqueFEIRVar dreadVar = var->Clone();
+  if (!IsFirstArgRet()) {
+    callStmt->SetVar(var->Clone());
+  }
+  return FEIRBuilder::CreateExprDRead(dreadVar->Clone());
+}
+
+std::unique_ptr<FEIRStmtAssign> ASTCallExpr::GenCallStmt() const {
+  MemPool *mp = FEManager::GetManager().GetStructElemMempool();
+  std::unique_ptr<FEIRStmtAssign> callStmt;
+  if (isIcall) {
+    auto icallStmt = std::make_unique<FEIRStmtICallAssign>();
+    CHECK_FATAL(calleeExpr->GetType()->IsMIRPtrType(), "cannot find func pointer for icall");
+    MIRFuncType *funcType = static_cast<MIRPtrType*>(calleeExpr->GetType())->GetPointedFuncType();
+    CHECK_FATAL(funcType != nullptr, "cannot find func prototype for icall");
+    icallStmt->SetPrototype(FEIRTypeHelper::CreateTypeNative(*funcType));
+    callStmt = std::move(icallStmt);
+  } else {
+    StructElemNameIdx *nameIdx = mp->New<StructElemNameIdx>(GetFuncName());
+    ASSERT_NOT_NULL(nameIdx);
+    FEStructMethodInfo *info = static_cast<FEStructMethodInfo*>(
+        FEManager::GetTypeManager().RegisterStructMethodInfo(*nameIdx, kSrcLangC, false));
+    ASSERT_NOT_NULL(info);
+    info->SetFuncAttrs(funcAttrs);
+    FEIRTypeNative *retTypeInfo = nullptr;
+    if (IsFirstArgRet()) {
+      retTypeInfo = mp->New<FEIRTypeNative>(*GlobalTables::GetTypeTable().GetPrimType(PTY_void));
+    } else {
+      retTypeInfo = mp->New<FEIRTypeNative>(*mirType);
+    }
+    info->SetReturnType(retTypeInfo);
+    Opcode op;
+    if (retTypeInfo->GetPrimType() != PTY_void) {
+      op = OP_callassigned;
+    } else {
+      op = OP_call;
+    }
+    callStmt = std::make_unique<FEIRStmtCallAssign>(*info, op, nullptr, false);
+  }
+  return callStmt;
+}
+
+UniqueFEIRExpr ASTCallExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  if (!isIcall) {
+    bool isFinish = false;
+    UniqueFEIRExpr buitinExpr = ProcessBuiltinFunc(stmts, isFinish);
+    if (isFinish) {
+      return buitinExpr;
+    }
+  }
+  std::unique_ptr<FEIRStmtAssign> callStmt = GenCallStmt();
+  AddArgsExpr(callStmt, stmts);
+  UniqueFEIRExpr retExpr = nullptr;
+  if (IsNeedRetExpr()) {
+    retExpr = AddRetExpr(callStmt);
+  }
+  stmts.emplace_back(std::move(callStmt));
+  InsertBoundaryVarInRet(stmts);
+  return retExpr;
+}
+
+// ---------- ASTCastExpr ----------
+MIRConst *ASTCastExpr::GenerateMIRConstImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  auto feExpr = child->Emit2FEExpr(stmts);
+  if (isArrayToPointerDecay && feExpr->GetKind() == FEIRNodeKind::kExprAddrof) {
+    return FEManager::GetModule().GetMemPool()->New<MIRStrConst>(
+        GetConstantValue()->val.strIdx, *GlobalTables::GetTypeTable().GetPrimType(PTY_a64));
+  } else if (isArrayToPointerDecay && child->IgnoreParens()->GetASTOp() == kASTOpCompoundLiteralExpr) {
+    static_cast<ASTCompoundLiteralExpr*>(child->IgnoreParens())->SetAddrof(true);
+    return child->GenerateMIRConst();
+  } else if (isNeededCvt) {
+    if (dst->GetPrimType() == PTY_f64) {
+      return GenerateMIRDoubleConst();
+    } else if (dst->GetPrimType() == PTY_f32) {
+      return GenerateMIRFloatConst();
+    } else {
+      return GenerateMIRIntConst();
+    }
+  } else {
+    return child->GenerateMIRConst();
+  }
+}
+
+MIRConst *ASTCastExpr::GenerateMIRDoubleConst() const {
+  MIRConst *childConst = child->GenerateMIRConst();
+  if (childConst == nullptr) {
+    return nullptr;
+  }
+  switch (childConst->GetKind()) {
+    case kConstFloatConst: {
+      return FEManager::GetModule().GetMemPool()->New<MIRDoubleConst>(
+          static_cast<double>(static_cast<MIRFloatConst*>(childConst)->GetValue()),
+          *GlobalTables::GetTypeTable().GetPrimType(PTY_f64));
+    }
+    case kConstInt: {
+      return FEManager::GetModule().GetMemPool()->New<MIRDoubleConst>(
+          static_cast<double>(static_cast<MIRIntConst*>(childConst)->GetExtValue()),
+          *GlobalTables::GetTypeTable().GetPrimType(PTY_f64));
+    }
+    case kConstDoubleConst: {
+      return FEManager::GetModule().GetMemPool()->New<MIRDoubleConst>(
+          static_cast<double>(static_cast<MIRDoubleConst*>(childConst)->GetValue()),
+          *GlobalTables::GetTypeTable().GetPrimType(PTY_f64));
+    }
+    default: {
+      CHECK_FATAL(false, "Unsupported pty type: %d", GetConstantValue()->pty);
+      return nullptr;
+    }
+  }
+}
+
+MIRConst *ASTCastExpr::GenerateMIRFloatConst() const {
+  MIRConst *childConst = child->GenerateMIRConst();
+  if (childConst == nullptr) {
+    return nullptr;
+  }
+  switch (childConst->GetKind()) {
+    case kConstDoubleConst: {
+      return FEManager::GetModule().GetMemPool()->New<MIRFloatConst>(
+          static_cast<float>(static_cast<MIRDoubleConst*>(childConst)->GetValue()),
+          *GlobalTables::GetTypeTable().GetPrimType(PTY_f32));
+    }
+    case kConstInt: {
+      return FEManager::GetModule().GetMemPool()->New<MIRFloatConst>(
+          static_cast<float>(static_cast<MIRIntConst*>(childConst)->GetExtValue()),
+          *GlobalTables::GetTypeTable().GetPrimType(PTY_f32));
+    }
+    default: {
+      CHECK_FATAL(false, "Unsupported pty type: %d", GetConstantValue()->pty);
+      return nullptr;
+    }
+  }
+}
+
+MIRConst *ASTCastExpr::GenerateMIRIntConst() const {
+  MIRConst *childConst = child->GenerateMIRConst();
+  if (childConst == nullptr) {
+    return nullptr;
+  }
+  switch (childConst->GetKind()) {
+    case kConstDoubleConst:
+    case kConstInt: {
+      int64 val = childConst->GetKind() == kConstDoubleConst
+                      ? static_cast<int64>(static_cast<MIRDoubleConst *>(childConst)->GetValue())
+                      : static_cast<MIRIntConst *>(childConst)->GetExtValue();
+
+      PrimType destPrimType = mirType->GetPrimType();
+      switch (destPrimType) {
+        case PTY_i8:
+          val = static_cast<int8>(val);
+          break;
+        case PTY_i16:
+          val = static_cast<int16>(val);
+          break;
+        case PTY_i32:
+          val = static_cast<int32>(val);
+          break;
+        case PTY_i64:
+          val = static_cast<int64>(val);
+          break;
+        case PTY_u8:
+          val = static_cast<uint8>(val);
+          break;
+        case PTY_u16:
+          val = static_cast<uint16>(val);
+          break;
+        case PTY_u32:
+          val = static_cast<uint32>(val);
+          break;
+        case PTY_u64:
+          val = static_cast<uint64>(val);
+          break;
+        default:
+          break;
+      }
+      return FEManager::GetModule().GetMemPool()->New<MIRIntConst>(
+          val, *GlobalTables::GetTypeTable().GetPrimType(PTY_i64));
+    }
+    case kConstStrConst: {
+      return FEManager::GetModule().GetMemPool()->New<MIRIntConst>(
+          static_cast<int64>(static_cast<MIRStrConst*>(childConst)->GetValue()),
+          *GlobalTables::GetTypeTable().GetPrimType(PTY_a64));
+    }
+    case kConstAddrof: {
+      return FEManager::GetModule().GetMemPool()->New<MIRIntConst>(
+          static_cast<int64>(static_cast<MIRAddrofConst*>(childConst)->GetOffset()),
+          *GlobalTables::GetTypeTable().GetPrimType(PTY_i64));
+    }
+    case kConstLblConst: {
+      // init by initListExpr, Only MIRConst kind is set here.
+      return childConst;
+    }
+    default: {
+      CHECK_FATAL(false, "Unsupported pty type: %d", GetConstantValue()->pty);
+      return nullptr;
+    }
+  }
+}
+
+UniqueFEIRExpr ASTCastExpr::Emit2FEExprForComplex(const UniqueFEIRExpr &subExpr, const UniqueFEIRType &srcType,
+                                                  std::list<UniqueFEIRStmt> &stmts) const {
+  std::string tmpName = FEUtils::GetSequentialName("Complex_");
+  UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *complexType);
+  UniqueFEIRExpr dreadAgg;
+  if (imageZero) {
+    UniqueFEIRStmt realStmtNode = std::make_unique<FEIRStmtDAssign>(tmpVar->Clone(),
+        subExpr->Clone(), kComplexRealID);
+    stmts.emplace_back(std::move(realStmtNode));
+    UniqueFEIRExpr imagExpr = FEIRBuilder::CreateExprConstAnyScalar(src->GetPrimType(), 0);
+    UniqueFEIRStmt imagStmtNode = std::make_unique<FEIRStmtDAssign>(tmpVar->Clone(),
+        imagExpr->Clone(), kComplexImagID);
+    stmts.emplace_back(std::move(imagStmtNode));
+    dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
+    static_cast<FEIRExprDRead*>(dreadAgg.get())->SetFieldType(srcType->Clone());
+  } else {
+    UniqueFEIRExpr realExpr;
+    UniqueFEIRExpr imagExpr;
+    FEIRNodeKind subNodeKind = subExpr->GetKind();
+    UniqueFEIRExpr cloneSubExpr = subExpr->Clone();
+    if (subNodeKind == kExprIRead) {
+      static_cast<FEIRExprIRead*>(subExpr.get())->SetFieldID(kComplexRealID);
+      static_cast<FEIRExprIRead*>(cloneSubExpr.get())->SetFieldID(kComplexImagID);
+    } else if (subNodeKind == kExprDRead) {
+      static_cast<FEIRExprDRead*>(subExpr.get())->SetFieldID(kComplexRealID);
+      static_cast<FEIRExprDRead*>(subExpr.get())->SetFieldType(srcType->Clone());
+      static_cast<FEIRExprDRead*>(cloneSubExpr.get())->SetFieldID(kComplexImagID);
+      static_cast<FEIRExprDRead*>(cloneSubExpr.get())->SetFieldType(srcType->Clone());
+    }
+    realExpr = FEIRBuilder::CreateExprCastPrim(subExpr->Clone(), dst->GetPrimType());
+    imagExpr = FEIRBuilder::CreateExprCastPrim(std::move(cloneSubExpr), dst->GetPrimType());
+    UniqueFEIRStmt realStmt = std::make_unique<FEIRStmtDAssign>(tmpVar->Clone(), std::move(realExpr), kComplexRealID);
+    stmts.emplace_back(std::move(realStmt));
+    UniqueFEIRStmt imagStmt = std::make_unique<FEIRStmtDAssign>(tmpVar->Clone(), std::move(imagExpr), kComplexImagID);
+    stmts.emplace_back(std::move(imagStmt));
+    dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
+  }
+  return dreadAgg;
+}
+
+UniqueFEIRExpr ASTCastExpr::Emit2FEExprForFunctionOrArray2Pointer(std::list<UniqueFEIRStmt> &stmts) const {
+  const ASTExpr *childExpr = child;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  auto childFEExpr = childExpr->Emit2FEExpr(stmts);
+  if (childFEExpr->GetKind() == kExprDRead) {
+    return std::make_unique<FEIRExprAddrofVar>(
+        static_cast<FEIRExprDRead*>(childFEExpr.get())->GetVar()->Clone(), childFEExpr->GetFieldID());
+  } else if (childFEExpr->GetKind() == kExprIRead) {
+    auto iread = static_cast<FEIRExprIRead*>(childFEExpr.get());
+    if (iread->GetFieldID() == 0) {
+      auto addrOfExpr = iread->GetClonedOpnd();
+      ENCChecker::ReduceBoundaryChecking(stmts, addrOfExpr);
+      return addrOfExpr;
+    } else {
+      return std::make_unique<FEIRExprIAddrof>(iread->GetClonedPtrType(), iread->GetFieldID(), iread->GetClonedOpnd());
+    }
+  } else if (childFEExpr->GetKind() == kExprIAddrof || childFEExpr->GetKind() == kExprAddrofVar ||
+             childFEExpr->GetKind() == kExprAddrofFunc || childFEExpr->GetKind() == kExprAddrof) {
+    return childFEExpr;
+  } else {
+    CHECK_FATAL(false, "unsupported expr kind %d", childFEExpr->GetKind());
+  }
+}
+
+UniqueFEIRExpr ASTCastExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  const ASTExpr *childExpr = child;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  if (isArrayToPointerDecay || isFunctionToPointerDecay) {
+    return Emit2FEExprForFunctionOrArray2Pointer(stmts);
+  }
+  UniqueFEIRExpr subExpr = childExpr->Emit2FEExpr(stmts);
+  if (isUnoinCast && dst->GetKind() == kTypeUnion) {
+    std::string varName = FEUtils::GetSequentialName("anon.union.");
+    UniqueFEIRType dstType = std::make_unique<FEIRTypeNative>(*dst);
+    UniqueFEIRVar unionVar = FEIRBuilder::CreateVarNameForC(varName, std::move(dstType));
+    UniqueFEIRStmt unionStmt = FEIRBuilder::CreateStmtDAssign(unionVar->Clone(), subExpr->Clone());
+    (void)stmts.emplace_back(std::move(unionStmt));
+    return FEIRBuilder::CreateExprDRead(std::move(unionVar));
+  }
+  if (isBitCast) {
+    if (src->GetPrimType() == dst->GetPrimType() && src->IsScalarType()) {
+      // This case may show up when casting from a 1-element vector to its scalar type.
+      return subExpr;
+    }
+    UniqueFEIRType dstType = std::make_unique<FEIRTypeNative>(*dst);
+    if (dst->GetKind() == kTypePointer) {
+      MIRType *funcType = static_cast<MIRPtrType*>(dst)->GetPointedFuncType();
+      if (funcType != nullptr) {
+        return std::make_unique<FEIRExprTypeCvt>(std::move(dstType), OP_retype, std::move(subExpr));
+      } else {
+        return subExpr;
+      }
+    } else {
+      return std::make_unique<FEIRExprTypeCvt>(std::move(dstType), OP_retype, std::move(subExpr));
+    }
+  }
+  if (isVectorSplat) {
+    return EmitExprVdupVector(dst->GetPrimType(), subExpr);
+  }
+  if (complexType != nullptr) {
+    UniqueFEIRType srcType = std::make_unique<FEIRTypeNative>(*src);
+    return Emit2FEExprForComplex(subExpr, srcType, stmts);
+  }
+  if (!IsNeededCvt(subExpr)) {
+    return subExpr;
+  }
+  if (IsPrimitiveFloat(subExpr->GetPrimType()) && IsPrimitiveInteger(dst->GetPrimType()) &&
+      dst->GetPrimType() != PTY_u1) {
+    return FEIRBuilder::CreateExprCvtPrim(OP_trunc, std::move(subExpr), dst->GetPrimType());
+  }
+  return FEIRBuilder::CreateExprCastPrim(std::move(subExpr), dst->GetPrimType());
+}
+
+UniqueFEIRExpr ASTCastExpr::EmitExprVdupVector(PrimType primtype, UniqueFEIRExpr &subExpr) const {
+MIRIntrinsicID intrinsic;
+  switch (primtype) {
+#define SET_VDUP(TY)                                                          \
+    case PTY_##TY:                                                            \
+      intrinsic = INTRN_vector_from_scalar_##TY;                              \
+      break;
+
+    SET_VDUP(v2i64)
+    SET_VDUP(v4i32)
+    SET_VDUP(v8i16)
+    SET_VDUP(v16i8)
+    SET_VDUP(v2u64)
+    SET_VDUP(v4u32)
+    SET_VDUP(v8u16)
+    SET_VDUP(v16u8)
+    SET_VDUP(v2f64)
+    SET_VDUP(v4f32)
+    SET_VDUP(v2i32)
+    SET_VDUP(v4i16)
+    SET_VDUP(v8i8)
+    SET_VDUP(v2u32)
+    SET_VDUP(v4u16)
+    SET_VDUP(v8u8)
+    SET_VDUP(v2f32)
+    case PTY_i64:
+      intrinsic = INTRN_vector_from_scalar_v1i64;
+      break;
+    case PTY_u64:
+      intrinsic = INTRN_vector_from_scalar_v1f64;
+      break;
+    case PTY_f64:
+      intrinsic = INTRN_vector_from_scalar_v1f64;
+      break;
+    default:
+      CHECK_FATAL(false, "Unhandled vector type in CreateExprVdupAnyVector");
+  }
+  UniqueFEIRType feType = FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPrimType(primtype));
+  std::vector<std::unique_ptr<FEIRExpr>> argOpnds;
+  argOpnds.push_back(std::move(subExpr));
+  return std::make_unique<FEIRExprIntrinsicopForC>(std::move(feType), intrinsic, argOpnds);
+}
+
+// ---------- ASTUnaryOperatorExpr ----------
+void ASTUnaryOperatorExpr::SetUOExpr(ASTExpr *astExpr) {
+  expr = astExpr;
+}
+
+void ASTUnaryOperatorExpr::SetSubType(MIRType *type) {
+  subType = type;
+}
+
+UniqueFEIRExpr ASTUOMinusExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  ASTExpr *childExpr = expr;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts);
+  PrimType dstType = uoType->GetPrimType();
+  CHECK_NULL_FATAL(subType);
+  if (childFEIRExpr->GetPrimType() != dstType) {
+    UniqueFEIRExpr minusExpr = std::make_unique<FEIRExprUnary>(
+        FEIRTypeHelper::CreateTypeNative(*subType), OP_neg, std::move(childFEIRExpr));
+    return FEIRBuilder::CreateExprCastPrim(std::move(minusExpr), dstType);
+  }
+  return std::make_unique<FEIRExprUnary>(FEIRTypeHelper::CreateTypeNative(*subType), OP_neg, std::move(childFEIRExpr));
+}
+
+UniqueFEIRExpr ASTUOPlusExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  ASTExpr *childExpr = expr;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  UniqueFEIRExpr plusExpr = childExpr->Emit2FEExpr(stmts);
+  return plusExpr;
+}
+
+UniqueFEIRExpr ASTUONotExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  ASTExpr *childExpr = expr;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts);
+  PrimType dstType = uoType->GetPrimType();
+  CHECK_NULL_FATAL(subType);
+  if (childFEIRExpr->GetPrimType() != dstType) {
+    UniqueFEIRExpr notExpr = std::make_unique<FEIRExprUnary>(
+        FEIRTypeHelper::CreateTypeNative(*subType), OP_bnot, std::move(childFEIRExpr));
+    return FEIRBuilder::CreateExprCastPrim(std::move(notExpr), dstType);
+  }
+  return std::make_unique<FEIRExprUnary>(FEIRTypeHelper::CreateTypeNative(*subType), OP_bnot, std::move(childFEIRExpr));
+}
+
+UniqueFEIRExpr ASTUOLNotExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  ASTExpr *childExpr = expr;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  childExpr->SetShortCircuitIdx(falseIdx, trueIdx);
+  UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts);
+  if (childFEIRExpr != nullptr) {
+    return FEIRBuilder::CreateExprZeroCompare(OP_eq, std::move(childFEIRExpr));
+  }
+  return childFEIRExpr;
+}
+
+UniqueFEIRExpr ASTUnaryOperatorExpr::ASTUOSideEffectExpr(Opcode op, std::list<UniqueFEIRStmt> &stmts,
+    const std::string &varName, bool post) const {
+  ASTExpr *childExpr = expr;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts);
+  UniqueFEIRVar tempVar;
+  if (post) {
+    tempVar = FEIRBuilder::CreateVarNameForC(varName, *subType);
+    UniqueFEIRStmt readSelfstmt = FEIRBuilder::CreateStmtDAssign(tempVar->Clone(), childFEIRExpr->Clone());
+    if (!IsRValue()) {
+      readSelfstmt->SetDummy();
+    }
+    stmts.emplace_back(std::move(readSelfstmt));
+  }
+
+  PrimType subPrimType = subType->GetPrimType();
+  UniqueFEIRExpr subExpr = (subPrimType == PTY_ptr) ? std::make_unique<FEIRExprConst>(pointeeLen, PTY_i32) :
+      FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1);
+  UniqueFEIRExpr sideEffectExpr = FEIRBuilder::CreateExprMathBinary(op, childFEIRExpr->Clone(), std::move(subExpr));
+  UniqueFEIRStmt sideEffectStmt = FEIRBuilder::AssginStmtField(childFEIRExpr->Clone(), std::move(sideEffectExpr), 0);
+  stmts.emplace_back(std::move(sideEffectStmt));
+
+  if (post) {
+    return FEIRBuilder::CreateExprDRead(std::move(tempVar));
+  }
+  return childFEIRExpr;
+}
+
+UniqueFEIRExpr ASTUOPostIncExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return ASTUOSideEffectExpr(OP_add, stmts, tempVarName, true);
+}
+
+UniqueFEIRExpr ASTUOPostDecExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return ASTUOSideEffectExpr(OP_sub, stmts, tempVarName, true);
+}
+
+UniqueFEIRExpr ASTUOPreIncExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return ASTUOSideEffectExpr(OP_add, stmts);
+}
+
+UniqueFEIRExpr ASTUOPreDecExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return ASTUOSideEffectExpr(OP_sub, stmts);
+}
+
+MIRConst *ASTUOAddrOfExpr::GenerateMIRConstImpl() const {
+  switch (expr->GetASTOp()) {
+    case kASTOpCompoundLiteralExpr: {
+      static_cast<ASTCompoundLiteralExpr*>(expr)->SetAddrof(true);
+      return expr->GenerateMIRConst();
+    }
+    case kASTOpRef: {
+      expr->SetIsConstantFolded(false);
+      return expr->GenerateMIRConst();
+    }
+    case kASTSubscriptExpr:
+    case kASTMemberExpr: {
+      return expr->GenerateMIRConst();
+    }
+    case kASTStringLiteral: {
+      return FEManager::GetModule().GetMemPool()->New<MIRStrConst>(
+          expr->GetConstantValue()->val.strIdx, *GlobalTables::GetTypeTable().GetPrimType(PTY_a64));
+    }
+    default: {
+      CHECK_FATAL(false, "lValue in expr: %d NIY", expr->GetASTOp());
+    }
+  }
+  return nullptr;
+}
+
+UniqueFEIRExpr ASTUOAddrOfExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  ASTExpr *childExpr = expr;
+  UniqueFEIRExpr addrOfExpr;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts);
+  if (childFEIRExpr->GetKind() == kExprDRead) {
+    addrOfExpr = std::make_unique<FEIRExprAddrofVar>(
+        static_cast<FEIRExprDRead*>(childFEIRExpr.get())->GetVar()->Clone(), childFEIRExpr->GetFieldID());
+  } else if (childFEIRExpr->GetKind() == kExprIRead) {
+    auto ireadExpr = static_cast<FEIRExprIRead*>(childFEIRExpr.get());
+    if (ireadExpr->GetFieldID() == 0) {
+      addrOfExpr = ireadExpr->GetClonedOpnd();
+      ENCChecker::ReduceBoundaryChecking(stmts, addrOfExpr);
+    } else {
+      addrOfExpr = std::make_unique<FEIRExprIAddrof>(ireadExpr->GetClonedPtrType(), ireadExpr->GetFieldID(),
+                                                     ireadExpr->GetClonedOpnd());
+    }
+  } else if (childFEIRExpr->GetKind() == kExprIAddrof || childFEIRExpr->GetKind() == kExprAddrofVar ||
+      childFEIRExpr->GetKind() == kExprAddrofFunc || childFEIRExpr->GetKind() == kExprAddrof) {
+    return childFEIRExpr;
+  } else if (childFEIRExpr->GetKind() == kExprConst) {
+    std::string tmpName = FEUtils::GetSequentialName("tmpvar_");
+    UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, childFEIRExpr->GetType()->Clone());
+    auto tmpStmt = FEIRBuilder::CreateStmtDAssign(tmpVar->Clone(), std::move(childFEIRExpr));
+    (void)stmts.emplace_back(std::move(tmpStmt));
+    return FEIRBuilder::CreateExprAddrofVar(std::move(tmpVar));
+  } else {
+    CHECK_FATAL(false, "unsupported expr kind %d", childFEIRExpr->GetKind());
+  }
+  return addrOfExpr;
+}
+
+// ---------- ASTUOAddrOfLabelExpr ---------
+MIRConst *ASTUOAddrOfLabelExpr::GenerateMIRConstImpl() const {
+  return FEManager::GetMIRBuilder().GetCurrentFuncCodeMp()->New<MIRLblConst>(
+      FEManager::GetMIRBuilder().GetOrCreateMIRLabel(GetLabelName()),
+      FEManager::GetMIRBuilder().GetCurrentFunction()->GetPuidx(),  // GetCurrentFunction need to be optimized
+      *GlobalTables::GetTypeTable().GetVoidPtr());                  // when parallel features
+}
+
+UniqueFEIRExpr ASTUOAddrOfLabelExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  return FEIRBuilder::CreateExprAddrofLabel(GetLabelName(), std::make_unique<FEIRTypeNative>(*uoType));
+}
+
+UniqueFEIRExpr ASTUODerefExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  std::list<UniqueFEIRStmt> subStmts;  // To delete redundant bounds checks in one ASTUODerefExpr stmts.
+  ASTExpr *childExpr = expr;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(subStmts);
+  UniqueFEIRType retType = std::make_unique<FEIRTypeNative>(*uoType);
+  UniqueFEIRType ptrType = std::make_unique<FEIRTypeNative>(*subType);
+  InsertNonnullChecking(subStmts, childFEIRExpr->Clone());
+  if (InsertBoundaryChecking(subStmts, childFEIRExpr->Clone())) {
+    childFEIRExpr->SetIsBoundaryChecking(true);
+  }
+  UniqueFEIRExpr derefExpr = FEIRBuilder::CreateExprIRead(std::move(retType), std::move(ptrType),
+                                                          std::move(childFEIRExpr));
+  stmts.splice(stmts.end(), subStmts);
+  return derefExpr;
+}
+
+void ASTUODerefExpr::InsertNonnullChecking(std::list<UniqueFEIRStmt> &stmts, UniqueFEIRExpr baseExpr) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic()) {
+    return;
+  }
+  if (baseExpr->GetPrimType() == PTY_ptr) {
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtAssertNonnull>(OP_assertnonnull, std::move(baseExpr));
+    stmts.emplace_back(std::move(stmt));
+  }
+}
+
+UniqueFEIRExpr ASTUORealExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  ASTExpr *childExpr = expr;
+  ASTOp astOP = childExpr->GetASTOp();
+  UniqueFEIRExpr subFEIRExpr;
+  if (astOP == kASTStringLiteral || astOP == kASTIntegerLiteral || astOP == kASTFloatingLiteral ||
+      astOP == kASTCharacterLiteral || astOP == kASTImaginaryLiteral) {
+    subFEIRExpr = childExpr->Emit2FEExpr(stmts);
+  } else {
+    subFEIRExpr = childExpr->Emit2FEExpr(stmts);
+    FEIRNodeKind subNodeKind = subFEIRExpr->GetKind();
+    if (subNodeKind == kExprIRead) {
+      static_cast<FEIRExprIRead*>(subFEIRExpr.get())->SetFieldID(kComplexRealID);
+    } else if (subNodeKind == kExprDRead) {
+      static_cast<FEIRExprDRead*>(subFEIRExpr.get())->SetFieldID(kComplexRealID);
+      UniqueFEIRType elementFEType = std::make_unique<FEIRTypeNative>(*elementType);
+      static_cast<FEIRExprDRead*>(subFEIRExpr.get())->SetFieldType(std::move(elementFEType));
+    } else {
+      CHECK_FATAL(false, "NIY");
+    }
+  }
+  return subFEIRExpr;
+}
+
+UniqueFEIRExpr ASTUOImagExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  ASTExpr *childrenExpr = expr;
+  ASTOp astOP = childrenExpr->GetASTOp();
+  UniqueFEIRExpr subFEIRExpr;
+  if (astOP == kASTStringLiteral || astOP == kASTCharacterLiteral || astOP == kASTImaginaryLiteral ||
+      astOP == kASTIntegerLiteral || astOP == kASTFloatingLiteral) {
+    subFEIRExpr = childrenExpr->Emit2FEExpr(stmts);
+  } else {
+    subFEIRExpr = childrenExpr->Emit2FEExpr(stmts);
+    FEIRNodeKind subNodeKind = subFEIRExpr->GetKind();
+    if (subNodeKind == kExprIRead) {
+      static_cast<FEIRExprIRead*>(subFEIRExpr.get())->SetFieldID(kComplexImagID);
+    } else if (subNodeKind == kExprDRead) {
+      static_cast<FEIRExprDRead*>(subFEIRExpr.get())->SetFieldID(kComplexImagID);
+      UniqueFEIRType elementFEType = std::make_unique<FEIRTypeNative>(*elementType);
+      static_cast<FEIRExprDRead*>(subFEIRExpr.get())->SetFieldType(std::move(elementFEType));
+    } else {
+      CHECK_FATAL(false, "NIY");
+    }
+  }
+  return subFEIRExpr;
+}
+
+UniqueFEIRExpr ASTUOExtensionExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return expr->Emit2FEExpr(stmts);
+}
+
+UniqueFEIRExpr ASTUOCoawaitExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  CHECK_FATAL(false, "C++ feature");
+  return nullptr;
+}
+
+// ---------- ASTPredefinedExpr ----------
+UniqueFEIRExpr ASTPredefinedExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return child->Emit2FEExpr(stmts);
+}
+
+void ASTPredefinedExpr::SetASTExpr(ASTExpr *astExpr) {
+  child = astExpr;
+}
+
+// ---------- ASTOpaqueValueExpr ----------
+UniqueFEIRExpr ASTOpaqueValueExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return child->Emit2FEExpr(stmts);
+}
+
+void ASTOpaqueValueExpr::SetASTExpr(ASTExpr *astExpr) {
+  child = astExpr;
+}
+
+// ---------- ASTBinaryConditionalOperator ----------
+UniqueFEIRExpr ASTBinaryConditionalOperator::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRExpr condFEIRExpr = condExpr->Emit2FEExpr(stmts);
+  UniqueFEIRExpr trueFEIRExpr;
+  CHECK_NULL_FATAL(mirType);
+  // if a conditional expr is noncomparative, e.g., b = a ?: c
+  // the conditional expr will be use for trueExpr before it will be converted to comparative expr
+  if (!(condFEIRExpr->GetKind() == kExprBinary && static_cast<FEIRExprBinary*>(condFEIRExpr.get())->IsComparative())) {
+    trueFEIRExpr = condFEIRExpr->Clone();
+    condFEIRExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(condFEIRExpr));
+  } else {
+    // if a conditional expr already is comparative (only return u1 val 0 or 1), e.g., b = (a < 0) ?: c
+    // the conditional expr will be assigned var used for comparative expr and true expr meanwhile
+    MIRType *condType = condFEIRExpr->GetType()->GenerateMIRTypeAuto();
+    ASSERT_NOT_NULL(condType);
+    UniqueFEIRVar condVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("condVal_"), *condType);
+    UniqueFEIRVar condVarCloned = condVar->Clone();
+    UniqueFEIRVar condVarCloned2 = condVar->Clone();
+    UniqueFEIRStmt condStmt = FEIRBuilder::CreateStmtDAssign(std::move(condVar), std::move(condFEIRExpr));
+    stmts.emplace_back(std::move(condStmt));
+    condFEIRExpr = FEIRBuilder::CreateExprDRead(std::move(condVarCloned));
+    if (condType->GetPrimType() != mirType->GetPrimType()) {
+      trueFEIRExpr = FEIRBuilder::CreateExprCvtPrim(std::move(condVarCloned2), mirType->GetPrimType());
+    } else {
+      trueFEIRExpr = FEIRBuilder::CreateExprDRead(std::move(condVarCloned2));
+    }
+  }
+  std::list<UniqueFEIRStmt> falseStmts;
+  UniqueFEIRExpr falseFEIRExpr = falseExpr->Emit2FEExpr(falseStmts);
+  // There are no extra nested statements in false expressions, (e.g., a < 1 ?: 2), use ternary FEIRExpr
+  if (falseStmts.empty()) {
+    UniqueFEIRType type = std::make_unique<FEIRTypeNative>(*mirType);
+    return FEIRBuilder::CreateExprTernary(OP_select, std::move(type), std::move(condFEIRExpr),
+                                          std::move(trueFEIRExpr), std::move(falseFEIRExpr));
+  }
+  // Otherwise, (e.g., a < 1 ?: a++) create a temporary var to hold the return trueExpr or falseExpr value
+  CHECK_FATAL(falseFEIRExpr->GetPrimType() == mirType->GetPrimType(), "The type of falseFEIRExpr are inconsistent");
+  UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("levVar_"), *mirType);
+  UniqueFEIRVar tempVarCloned1 = tempVar->Clone();
+  UniqueFEIRVar tempVarCloned2 = tempVar->Clone();
+  UniqueFEIRStmt retTrueStmt = FEIRBuilder::CreateStmtDAssign(std::move(tempVar), std::move(trueFEIRExpr));
+  retTrueStmt->SetSrcLoc(condExpr->GetSrcLoc());
+  std::list<UniqueFEIRStmt> trueStmts;
+  trueStmts.emplace_back(std::move(retTrueStmt));
+  UniqueFEIRStmt retFalseStmt = FEIRBuilder::CreateStmtDAssign(std::move(tempVarCloned1), std::move(falseFEIRExpr));
+  retFalseStmt->SetSrcLoc(falseExpr->GetSrcLoc());
+  falseStmts.emplace_back(std::move(retFalseStmt));
+  UniqueFEIRStmt stmtIf = FEIRBuilder::CreateStmtIf(std::move(condFEIRExpr), trueStmts, falseStmts);
+  stmts.emplace_back(std::move(stmtIf));
+  return FEIRBuilder::CreateExprDRead(std::move(tempVarCloned2));
+}
+
+void ASTBinaryConditionalOperator::SetCondExpr(ASTExpr *expr) {
+  condExpr = expr;
+}
+
+void ASTBinaryConditionalOperator::SetFalseExpr(ASTExpr *expr) {
+  falseExpr = expr;
+}
+
+// ---------- ASTNoInitExpr ----------
+UniqueFEIRExpr ASTNoInitExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return ImplicitInitFieldValue(*noInitType, stmts);
+}
+
+void ASTNoInitExpr::SetNoInitType(MIRType *type) {
+  noInitType = type;
+}
+
+// ---------- ASTCompoundLiteralExpr ----------
+UniqueFEIRExpr ASTCompoundLiteralExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRExpr feirExpr;
+  if (!IsRValue() || child->GetASTOp() == kASTOpInitListExpr) { // other potential expr should concern
+    std::string tmpName = FEUtils::GetSequentialName("clvar_");
+    if (child->GetASTOp() == kASTOpInitListExpr) {
+      static_cast<ASTInitListExpr*>(child)->SetInitListVarName(tmpName);
+    }
+    UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *compoundLiteralType);
+    auto expr = child->Emit2FEExpr(stmts);
+    if (expr != nullptr) {
+      auto tmpStmt = FEIRBuilder::CreateStmtDAssign(tmpVar->Clone(), std::move(expr));
+      (void)stmts.emplace_back(std::move(tmpStmt));
+    }
+    feirExpr = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
+  } else {
+    feirExpr = child->Emit2FEExpr(stmts);
+  }
+  return feirExpr;
+}
+
+MIRConst *ASTCompoundLiteralExpr::GenerateMIRPtrConst() const {
+  CHECK_NULL_FATAL(compoundLiteralType);
+  std::string tmpName = FEUtils::GetSequentialName("cle.");
+  if (FEOptions::GetInstance().GetFuncInlineSize() != 0) {
+    tmpName = tmpName + FEUtils::GetFileNameHashStr(FEManager::GetModule().GetFileName());
+  }
+  // If a var is pointer type, agg value cannot be directly assigned to it
+  // Create a temporary symbol for addrof agg value
+  MIRSymbol *cleSymbol = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl(
+      tmpName, *compoundLiteralType);
+  auto mirConst = child->GenerateMIRConst(); // InitListExpr in CompoundLiteral gen struct
+  cleSymbol->SetKonst(mirConst);
+  MIRAddrofConst *mirAddrofConst = FEManager::GetModule().GetMemPool()->New<MIRAddrofConst>(
+  cleSymbol->GetStIdx(), 0, *compoundLiteralType);
+  return mirAddrofConst;
+}
+
+MIRConst *ASTCompoundLiteralExpr::GenerateMIRConstImpl() const {
+  if (isAddrof) {
+    return GenerateMIRPtrConst();
+  }
+  return child->GenerateMIRConst();
+}
+
+void ASTCompoundLiteralExpr::SetCompoundLiteralType(MIRType *clType) {
+  compoundLiteralType = clType;
+}
+
+void ASTCompoundLiteralExpr::SetASTExpr(ASTExpr *astExpr) {
+  child = astExpr;
+}
+
+// ---------- ASTOffsetOfExpr ----------
+void ASTOffsetOfExpr::SetStructType(MIRType *stype) {
+  structType = stype;
+}
+
+void ASTOffsetOfExpr::SetFieldName(const std::string &fName) {
+  fieldName = fName;
+}
+
+UniqueFEIRExpr ASTOffsetOfExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  return FEIRBuilder::CreateExprConstU64(static_cast<uint64>(offset));
+}
+
+// ---------- ASTInitListExpr ----------
+MIRConst *ASTInitListExpr::GenerateMIRConstImpl() const {
+  // avoid the infinite loop
+  if (isGenerating) {
+    return nullptr;
+  }
+  isGenerating = true;
+  if (initListType->GetKind() == kTypeArray) {
+    return GenerateMIRConstForArray();
+  } else if (initListType->GetKind() == kTypeStruct || initListType->GetKind() == kTypeUnion) {
+    return GenerateMIRConstForStruct();
+  } else if (isTransparent) {
+    return initExprs[0]->GenerateMIRConst();
+  } else {
+    CHECK_FATAL(false, "not handle now");
+  }
+}
+
+MIRConst *ASTInitListExpr::GenerateMIRConstForArray() const {
+  CHECK_FATAL(initListType->GetKind() == kTypeArray, "Must be array type");
+  auto arrayMirType = static_cast<MIRArrayType*>(initListType);
+  if (arrayMirType->GetDim() == 1 && initExprs.size() == 1 && initExprs[0]->GetASTOp() == kASTStringLiteral) {
+    return initExprs[0]->GenerateMIRConst();
+  }
+  MIRAggConst *aggConst = FEManager::GetModule().GetMemPool()->New<MIRAggConst>(FEManager::GetModule(), *initListType);
+  CHECK_FATAL(initExprs.size() <= arrayMirType->GetSizeArrayItem(0), "InitExpr size must less or equal array size");
+  for (size_t i = 0; i < initExprs.size(); ++i) {
+    auto konst = initExprs[i]->GenerateMIRConst();
+    if (konst == nullptr) {
+      return nullptr;
+    }
+    aggConst->AddItem(konst, 0);
+  }
+  if (HasArrayFiller()) {
+    auto fillerConst = arrayFillerExpr->GenerateMIRConst();
+    for (uint32 i = initExprs.size(); i < arrayMirType->GetSizeArrayItem(0); ++i) {
+      aggConst->AddItem(fillerConst, 0);
+    }
+  }
+  return aggConst;
+}
+
+MIRConst *ASTInitListExpr::GenerateMIRConstForStruct() const {
+  if (initExprs.empty()) {
+    return nullptr; // No var constant generation
+  }
+  bool hasFiller = false;
+  for (auto e : initExprs) {
+    if (e != nullptr) {
+      hasFiller = true;
+      break;
+    }
+  }
+  if (!hasFiller) {
+    return nullptr;
+  }
+  MIRAggConst *aggConst = FEManager::GetModule().GetMemPool()->New<MIRAggConst>(FEManager::GetModule(), *initListType);
+  CHECK_FATAL(initExprs.size() <= UINT_MAX, "Too large elem size");
+  if (initListType->GetKind() == kTypeUnion) {
+    CHECK_FATAL(initExprs.size() == 1, "union should only have one elem");
+  }
+  for (uint32 i = 0; i < static_cast<uint32>(initExprs.size()); ++i) {
+    if (initExprs[i] == nullptr) {
+      continue;
+    }
+    auto konst = initExprs[i]->GenerateMIRConst();
+    if (konst == nullptr) {
+      continue;
+    }
+    if (konst->GetKind() == kConstLblConst) {
+      // init by initListExpr, Only MIRConst kind is set here.
+      return konst;
+    }
+    uint32 fieldIdx = (initListType->GetKind() == kTypeUnion) ? unionInitFieldIdx : i;
+    aggConst->AddItem(konst, fieldIdx + 1);
+  }
+  ENCChecker::CheckNullFieldInGlobalStruct(*initListType, *aggConst, initExprs);
+  return aggConst;
+}
+
+UniqueFEIRExpr ASTInitListExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(GetInitListVarName(), *initListType);
+  if (initListType->GetKind() == MIRTypeKind::kTypeArray) {
+    UniqueFEIRExpr arrayExpr = FEIRBuilder::CreateExprAddrofVar(feirVar->Clone());
+    auto base = std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr>(arrayExpr->Clone());
+    ProcessInitList(base, *this, stmts);
+  } else if (initListType->IsStructType()) {
+    auto base = std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr>(std::make_pair(feirVar->Clone(), 0));
+    ProcessInitList(base, *this, stmts);
+  } else if (isTransparent) {
+    CHECK_FATAL(initExprs.size() == 1, "Transparent init list size must be 1");
+    return initExprs[0]->Emit2FEExpr(stmts);
+  } else if (hasVectorType) {
+    auto base = std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr>(std::make_pair(feirVar->Clone(), 0));
+    ProcessInitList(base, *this, stmts);
+  } else {
+    CHECK_FATAL(true, "Unsupported init list type");
+  }
+  return nullptr;
+}
+
+void ASTInitListExpr::ProcessInitList(std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                                      const ASTInitListExpr &initList,
+                                      std::list<UniqueFEIRStmt> &stmts) const {
+  if (initList.initListType->GetKind() == kTypeArray) {
+    if (std::holds_alternative<UniqueFEIRExpr>(base)) {
+      ProcessArrayInitList(std::get<UniqueFEIRExpr>(base)->Clone(), initList, stmts);
+    } else {
+      auto addrExpr = std::make_unique<FEIRExprAddrofVar>(
+          std::get<std::pair<UniqueFEIRVar, FieldID>>(base).first->Clone());
+      addrExpr->SetFieldID(std::get<std::pair<UniqueFEIRVar, FieldID>>(base).second);
+      ProcessArrayInitList(addrExpr->Clone(), initList, stmts);
+    }
+  } else if (initList.initListType->GetKind() == kTypeStruct || initList.initListType->GetKind() == kTypeUnion) {
+    ProcessStructInitList(base, initList, stmts);
+  } else if (initList.isTransparent) {
+    CHECK_FATAL(initList.initExprs.size() == 1, "Transparent init list size must be 1");
+    auto feExpr = initList.initExprs[0]->Emit2FEExpr(stmts);
+    MIRType *retType = initList.initListType;
+    MIRType *retPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*retType);
+    UniqueFEIRType fePtrType = std::make_unique<FEIRTypeNative>(*retPtrType);
+    if (std::holds_alternative<UniqueFEIRExpr>(base)) {
+      auto stmt = FEIRBuilder::CreateStmtIAssign(fePtrType->Clone(), std::get<UniqueFEIRExpr>(base)->Clone(),
+                                                 feExpr->Clone(), 0);
+      stmts.emplace_back(std::move(stmt));
+    } else {
+      UniqueFEIRVar feirVar = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).first->Clone();
+      FieldID fieldID = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).second;
+      auto stmt = FEIRBuilder::CreateStmtDAssignAggField(feirVar->Clone(), feExpr->Clone(), fieldID);
+      stmts.emplace_back(std::move(stmt));
+    }
+  } else if (initList.HasVectorType()) {
+    ProcessVectorInitList(base, initList, stmts);
+  }
+}
+
+void ASTInitListExpr::ProcessStringLiteralInitList(const UniqueFEIRExpr &addrOfCharArray,
+                                                   const UniqueFEIRExpr &addrOfStringLiteral,
+                                                   size_t stringLength, std::list<UniqueFEIRStmt> &stmts) const {
+  std::unique_ptr<std::list<UniqueFEIRExpr>> argExprList = std::make_unique<std::list<UniqueFEIRExpr>>();
+  argExprList->emplace_back(addrOfCharArray->Clone());
+  argExprList->emplace_back(addrOfStringLiteral->Clone());
+  CHECK_FATAL(stringLength <= INT_MAX, "Too large length range");
+  argExprList->emplace_back(FEIRBuilder::CreateExprConstI32(static_cast<int32>(stringLength)));
+  std::unique_ptr<FEIRStmtIntrinsicCallAssign> memcpyStmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+      INTRN_C_memcpy, nullptr, nullptr, std::move(argExprList));
+  memcpyStmt->SetSrcLoc(addrOfStringLiteral->GetLoc());
+  stmts.emplace_back(std::move(memcpyStmt));
+
+  // Handling Implicit Initialization When Incomplete Initialization
+  if (addrOfCharArray->GetKind() != kExprAddrofArray) {
+    return;
+  }
+  auto type = static_cast<FEIRExprAddrofArray*>(addrOfCharArray.get())->GetTypeArray()->Clone();
+  MIRType *mirType = type->GenerateMIRType();
+  if (mirType->GetKind() == kTypeArray) {
+    MIRArrayType *arrayType = static_cast<MIRArrayType*>(mirType);
+    if (arrayType->GetDim() > 2) { // only processing one or two dimensional arrays.
+      return;
+    }
+    uint32 dimSize = arrayType->GetSizeArrayItem(static_cast<uint32>(arrayType->GetDim() - 1));
+    uint32 elemSize = static_cast<uint32>(arrayType->GetElemType()->GetSize());
+    ProcessImplicitInit(addrOfCharArray->Clone(), stringLength, dimSize, elemSize, stmts,
+                        addrOfStringLiteral->GetLoc());
+  }
+}
+
+void ASTInitListExpr::ProcessImplicitInit(const UniqueFEIRExpr &addrExpr, uint32 initSize, uint32 total,
+    uint32 elemSize, std::list<UniqueFEIRStmt> &stmts, const Loc loc) const {
+  if (initSize >= total) {
+    return;
+  }
+  std::unique_ptr<std::list<UniqueFEIRExpr>> argExprList = std::make_unique<std::list<UniqueFEIRExpr>>();
+  UniqueFEIRExpr realAddr = addrExpr->Clone();
+  CHECK_FATAL(elemSize <= INT_MAX, "Too large elem size");
+  CHECK_FATAL(initSize <= INT_MAX, "Too large init size");
+  UniqueFEIRExpr elemSizeExpr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(elemSize));
+  if (initSize != 0) {
+    UniqueFEIRExpr initSizeExpr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(initSize));
+    if (elemSize != 1) {
+      initSizeExpr = FEIRBuilder::CreateExprBinary(OP_mul, std::move(initSizeExpr), elemSizeExpr->Clone());
+    }
+    realAddr = FEIRBuilder::CreateExprBinary(OP_add, std::move(realAddr), initSizeExpr->Clone());
+  }
+  argExprList->emplace_back(std::move(realAddr));
+  argExprList->emplace_back(FEIRBuilder::CreateExprConstI32(0));
+  UniqueFEIRExpr cntExpr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(total - initSize));
+  if (elemSize != 1) {
+    cntExpr = FEIRBuilder::CreateExprBinary(OP_mul, std::move(cntExpr), elemSizeExpr->Clone());
+  }
+  argExprList->emplace_back(std::move(cntExpr));
+  std::unique_ptr<FEIRStmtIntrinsicCallAssign> memsetStmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+      INTRN_C_memset, nullptr, nullptr, std::move(argExprList));
+  if (loc.fileIdx != 0) {
+    memsetStmt->SetSrcLoc(loc);
+  }
+  stmts.emplace_back(std::move(memsetStmt));
+}
+
+void ASTInitListExpr::ProcessDesignatedInitUpdater(
+    std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+    ASTExpr *expr, std::list<UniqueFEIRStmt> &stmts) const {
+  auto designatedInitUpdateExpr = static_cast<ASTDesignatedInitUpdateExpr*>(expr);
+  const ASTExpr *baseExpr = designatedInitUpdateExpr->GetBaseExpr();
+  const ASTExpr *updaterExpr = designatedInitUpdateExpr->GetUpdaterExpr();
+  auto feExpr = baseExpr->Emit2FEExpr(stmts);
+  if (std::holds_alternative<UniqueFEIRExpr>(base)) {
+    const MIRType *mirType = designatedInitUpdateExpr->GetInitListType();
+    MIRType *mirPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType);
+    UniqueFEIRType fePtrType = std::make_unique<FEIRTypeNative>(*mirPtrType);
+    auto stmt = FEIRBuilder::CreateStmtIAssign(fePtrType->Clone(), std::get<UniqueFEIRExpr>(base)->Clone(),
+                                               feExpr->Clone(), 0);
+    stmts.emplace_back(std::move(stmt));
+  } else {
+    UniqueFEIRVar feirVar = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).first->Clone();
+    FieldID fieldID = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).second;
+    auto stmt = FEIRBuilder::CreateStmtDAssignAggField(feirVar->Clone(), feExpr->Clone(), fieldID);
+    stmts.emplace_back(std::move(stmt));
+  }
+  ProcessInitList(base, *(static_cast<const ASTInitListExpr*>(updaterExpr)), stmts);
+}
+
+UniqueFEIRExpr ASTInitListExpr::CalculateStartAddressForMemset(const UniqueFEIRVar &varIn, uint32 initSizeIn,
+    FieldID fieldIDIn, const std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &baseIn) const {
+  UniqueFEIRExpr addrOfExpr;
+  if (std::holds_alternative<UniqueFEIRExpr>(baseIn)) {
+    UniqueFEIRExpr offsetExpr = FEIRBuilder::CreateExprConstU32(initSizeIn);
+    addrOfExpr = FEIRBuilder::CreateExprBinary(OP_add, std::get<UniqueFEIRExpr>(baseIn)->Clone(),
+                                               std::move(offsetExpr));
+  } else {
+    addrOfExpr = std::make_unique<FEIRExprAddrofVar>(varIn->Clone(), fieldIDIn);
+  }
+  return addrOfExpr;
+}
+
+std::tuple<FieldID, uint32, MIRType*> ASTInitListExpr::GetStructFieldInfo(uint32 fieldIndex,
+                                                                          FieldID baseFieldID,
+                                                                          MIRStructType &structMirType) const {
+  FieldID curFieldID = 0;
+  (void)FEUtils::TraverseToNamedField(structMirType, structMirType.GetElemStrIdx(fieldIndex), curFieldID);
+  FieldID fieldID = baseFieldID + curFieldID;
+  MIRType *fieldMirType = structMirType.GetFieldType(curFieldID);
+  uint32 fieldTypeSize = static_cast<uint32>(fieldMirType->GetSize());
+  return std::make_tuple(fieldID, fieldTypeSize, fieldMirType);
+}
+
+void ASTInitListExpr::SolveInitListFullOfZero(const MIRStructType &baseStructType, FieldID baseFieldID,
+                                              const UniqueFEIRVar &var, const ASTInitListExpr &initList,
+                                              std::list<UniqueFEIRStmt> &stmts) const {
+  MIRStructType *currStructType = static_cast<MIRStructType*>(initList.initListType);
+  if (baseStructType.GetKind() == kTypeStruct) {
+    std::tuple<FieldID, uint32, MIRType*> fieldInfo = GetStructFieldInfo(0, baseFieldID, *currStructType);
+    FieldID fieldID = std::get<0>(fieldInfo);
+    // Use 'fieldID - 1' (start address of the nested struct or union) instead of 'fieldID' (start address of the
+    // first field in the nested struct or union), because even though these two addresses have the same value,
+    // they have different pointer type.
+    UniqueFEIRExpr addrOfExpr = std::make_unique<FEIRExprAddrofVar>(var->Clone(), fieldID - 1);
+    ProcessImplicitInit(addrOfExpr->Clone(), 0, static_cast<uint32>(currStructType->GetSize()), 1, stmts,
+                        initList.GetSrcLoc());
+  } else { // kTypeUnion
+    UniqueFEIRExpr addrOfExpr = std::make_unique<FEIRExprAddrofVar>(var->Clone(), 0);
+    ProcessImplicitInit(addrOfExpr->Clone(), 0, static_cast<uint32>(currStructType->GetSize()), 1, stmts,
+                        initList.GetSrcLoc());
+  }
+}
+
+bool ASTInitListExpr::SolveInitListPartialOfZero(std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+    FieldID fieldID, uint32 &index, const ASTInitListExpr &initList, std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRVar var;
+  MIRStructType *baseStructMirType = nullptr;
+  if (std::holds_alternative<UniqueFEIRExpr>(base)) {
+    var = std::get<UniqueFEIRExpr>(base)->GetVarUses().front()->Clone();
+    baseStructMirType = static_cast<MIRStructType*>(initList.initListType);
+  } else {
+    var = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).first->Clone();
+    baseStructMirType = static_cast<MIRStructType*>(var->GetType()->GenerateMIRTypeAuto());
+  }
+  FieldID baseFieldID = 0;
+  if (!std::holds_alternative<UniqueFEIRExpr>(base)) {
+    baseFieldID = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).second;
+  }
+  MIRStructType *curStructMirType = static_cast<MIRStructType*>(initList.initListType);
+  uint32 fieldsCount = 0;
+  int64 initBitSize = baseStructMirType->GetBitOffsetFromBaseAddr(fieldID);  // in bit
+  uint32 fieldSizeOfLastZero = 0;                                            // in byte
+  FieldID fieldIdOfLastZero = fieldID;
+  uint32 start = index;
+  while (index < initList.initExprs.size() && initList.initExprs[index] != nullptr &&
+         initList.initExprs[index]->GetEvaluatedFlag() == kEvaluatedAsZero) {
+    std::tuple<FieldID, uint32, MIRType*> fieldInfo = GetStructFieldInfo(index, baseFieldID, *curStructMirType);
+    uint32 curFieldTypeSize = std::get<1>(fieldInfo);
+    MIRType *fieldMirType = std::get<2>(fieldInfo);
+    if (fieldMirType->GetKind() == kTypeBitField) {
+      break;
+    }
+    fieldSizeOfLastZero = curFieldTypeSize;
+    fieldIdOfLastZero = std::get<0>(fieldInfo);
+    ++fieldsCount;
+    ++index;
+  }
+  // consider struct alignment
+  int64 fieldsBitSize =
+      (baseStructMirType->GetBitOffsetFromBaseAddr(fieldIdOfLastZero) + fieldSizeOfLastZero * kOneByte) - initBitSize;
+  if (fieldsCount >= 2 && fieldsBitSize % kOneByte == 0 && (fieldsBitSize / kOneByte) % 4 == 0) {
+    auto addrOfExpr = CalculateStartAddressForMemset(var, static_cast<uint32>(initBitSize / 8), fieldID, base);
+    ProcessImplicitInit(addrOfExpr->Clone(), 0, static_cast<uint32>(fieldsBitSize / kOneByte), 1, stmts,
+                        initList.initExprs[start]->GetSrcLoc());
+    --index;
+    return true;
+  } else {
+    index -= fieldsCount;
+    return false;
+  }
+}
+
+void ASTInitListExpr::SolveInitListExprOrDesignatedInitUpdateExpr(FieldID fieldID, ASTExpr &initExpr,
+    const UniqueFEIRType &baseStructPtrType, std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+    std::list<UniqueFEIRStmt> &stmts) const {
+  std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> subBase;
+  if (std::holds_alternative<UniqueFEIRExpr>(base)) {
+    auto addrOfElemExpr = std::make_unique<FEIRExprIAddrof>(baseStructPtrType->Clone(), fieldID,
+                                                            std::get<UniqueFEIRExpr>(base)->Clone());
+    subBase = std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr>(addrOfElemExpr->Clone());
+  } else {
+    auto subVar = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).first->Clone();
+    subBase = std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr>(
+        std::make_pair<UniqueFEIRVar, FieldID>(subVar->Clone(), static_cast<FieldID>(fieldID)));
+  }
+  if (initExpr.GetASTOp() == kASTOpInitListExpr) {
+    ProcessInitList(subBase, *(static_cast<ASTInitListExpr*>(&initExpr)), stmts);
+  } else {
+    ProcessDesignatedInitUpdater(subBase, static_cast<ASTInitListExpr*>(&initExpr), stmts);
+  }
+}
+
+void ASTInitListExpr::SolveStructFieldOfArrayTypeInitWithStringLiteral(std::tuple<FieldID, uint32, MIRType*> fieldInfo,
+    const ASTExpr &initExpr, const UniqueFEIRType &baseStructPtrType,
+    std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base, std::list<UniqueFEIRStmt> &stmts) const {
+  auto elemExpr = initExpr.Emit2FEExpr(stmts);
+  if (elemExpr == nullptr) {
+    return;
+  }
+  FieldID fieldID = std::get<0>(fieldInfo);
+  MIRType *fieldMirType = std::get<2>(fieldInfo);
+  if (std::holds_alternative<UniqueFEIRExpr>(base)) {
+    auto addrOfElement = std::make_unique<FEIRExprIAddrof>(baseStructPtrType->Clone(), fieldID,
+                                                           std::get<UniqueFEIRExpr>(base)->Clone());
+    auto addrOfArrayExpr =  GetAddrofArrayFEExprByStructArrayField(*fieldMirType, addrOfElement->Clone());
+    ProcessStringLiteralInitList(addrOfArrayExpr->Clone(), elemExpr->Clone(),
+                                 static_cast<const ASTStringLiteral*>(&initExpr)->GetLength(), stmts);
+  } else {
+    auto subVar = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).first->Clone();
+    auto addrOfElement = std::make_unique<FEIRExprAddrofVar>(subVar->Clone());
+    addrOfElement->SetFieldID(fieldID);
+    auto addrOfArrayExpr =  GetAddrofArrayFEExprByStructArrayField(*fieldMirType, addrOfElement->Clone());
+    ProcessStringLiteralInitList(addrOfArrayExpr->Clone(), elemExpr->Clone(),
+                                 static_cast<const ASTStringLiteral*>(&initExpr)->GetLength(), stmts);
+  }
+}
+
+void ASTInitListExpr::SolveStructFieldOfBasicType(FieldID fieldID, const ASTExpr &initExpr,
+                                                  const UniqueFEIRType &baseStructPtrType,
+                                                  std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                                                  std::list<UniqueFEIRStmt> &stmts) const {
+  auto elemExpr = initExpr.Emit2FEExpr(stmts);
+  if (elemExpr == nullptr) {
+    return;
+  }
+  if (std::holds_alternative<UniqueFEIRExpr>(base)) {
+    auto stmt = std::make_unique<FEIRStmtIAssign>(baseStructPtrType->Clone(), std::get<UniqueFEIRExpr>(base)->Clone(),
+                                                  elemExpr->Clone(), fieldID);
+    stmt->SetSrcLoc(initExpr.GetSrcLoc());
+    (void)stmts.emplace_back(std::move(stmt));
+  } else {
+    auto subVar = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).first->Clone();
+    auto stmt = std::make_unique<FEIRStmtDAssign>(subVar->Clone(), elemExpr->Clone(), fieldID);
+    stmt->SetSrcLoc(initExpr.GetSrcLoc());
+    (void)stmts.emplace_back(std::move(stmt));
+  }
+}
+
+void ASTInitListExpr::ProcessStructInitList(std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                                            const ASTInitListExpr &initList,
+                                            std::list<UniqueFEIRStmt> &stmts) const {
+  MIRType *baseStructMirPtrType = nullptr;
+  MIRStructType *baseStructMirType = nullptr;
+  UniqueFEIRType baseStructFEType = nullptr;
+  UniqueFEIRType baseStructFEPtrType = nullptr;
+  MIRStructType *curStructMirType = static_cast<MIRStructType*>(initList.initListType);
+  UniqueFEIRVar var;
+  if (std::holds_alternative<UniqueFEIRExpr>(base)) {
+    var = std::get<UniqueFEIRExpr>(base)->GetVarUses().front()->Clone();
+    baseStructMirType = static_cast<MIRStructType*>(initList.initListType);
+    baseStructMirPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*baseStructMirType);
+    baseStructFEType = FEIRTypeHelper::CreateTypeNative(*baseStructMirType);
+    baseStructFEPtrType = std::make_unique<FEIRTypeNative>(*baseStructMirPtrType);
+  } else {
+    var = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).first->Clone();
+    baseStructFEType = var->GetType()->Clone();
+    baseStructMirType = static_cast<MIRStructType*>(baseStructFEType->GenerateMIRTypeAuto());
+    baseStructMirPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*baseStructMirType);
+    baseStructFEPtrType = std::make_unique<FEIRTypeNative>(*baseStructMirPtrType);
+  }
+
+  FieldID baseFieldID = 0;
+  if (!std::holds_alternative<UniqueFEIRExpr>(base)) {
+    baseFieldID = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).second;
+  }
+
+  if (initList.initExprs.size() == 0) {
+    UniqueFEIRExpr addrOfExpr = std::make_unique<FEIRExprAddrofVar>(var->Clone(), 0);
+    ProcessImplicitInit(addrOfExpr->Clone(), 0, static_cast<uint32>(curStructMirType->GetSize()), 1, stmts,
+                        initList.GetSrcLoc());
+    return;
+  }
+
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() && initList.GetEvaluatedFlag() == kEvaluatedAsZero) {
+    SolveInitListFullOfZero(*baseStructMirType, baseFieldID, var, initList, stmts);
+    return;
+  }
+
+  uint32 curFieldTypeSize = 0;
+  uint32 offset = 0;
+  for (uint32 i = 0; i < initList.initExprs.size(); ++i) {
+    if (initList.initExprs[i] == nullptr) {
+      continue; // skip anonymous field
+    }
+
+    uint32 fieldIdx = (curStructMirType->GetKind() == kTypeUnion) ? initList.GetUnionInitFieldIdx() : i;
+    std::tuple<FieldID, uint32, MIRType*> fieldInfo = GetStructFieldInfo(fieldIdx, baseFieldID, *curStructMirType);
+    FieldID fieldID = std::get<0>(fieldInfo);
+    curFieldTypeSize = std::get<1>(fieldInfo);
+    MIRType *fieldMirType = std::get<2>(fieldInfo);
+    offset += curFieldTypeSize;
+    // use one instrinsic call memset to initialize zero for partial continuous fields of struct to need reduce code
+    // size need to follow these three rules: (1) offset from the start address of the continuous fields to the start
+    // addresss of struct should be an integer multiples of 4 bytes (2) size of the continuous fields should be an
+    // integer multiples of 4 bytes (3) the continuous fields count should be two at least
+    if (!FEOptions::GetInstance().IsNpeCheckDynamic() &&
+        curStructMirType->GetKind() == kTypeStruct &&
+        fieldMirType->GetKind() != kTypeBitField && // skip bitfield type field because it not follows byte alignment
+        initList.initExprs[i]->GetEvaluatedFlag() == kEvaluatedAsZero &&
+        (baseStructMirType->GetBitOffsetFromBaseAddr(fieldID) / kOneByte) % 4 == 0) {
+        if (SolveInitListPartialOfZero(base, fieldID, i, initList, stmts)) {
+          continue;
+        }
+    }
+
+    if (initList.initExprs[i]->GetASTOp() == kASTImplicitValueInitExpr && fieldMirType->GetPrimType() == PTY_agg) {
+      auto addrOfExpr = CalculateStartAddressForMemset(var, offset - curFieldTypeSize, fieldID, base);
+      ProcessImplicitInit(addrOfExpr->Clone(), 0, static_cast<uint32>(fieldMirType->GetSize()), 1, stmts,
+                          initList.initExprs[i]->GetSrcLoc());
+      continue;
+    }
+
+    if (initList.initExprs[i]->GetASTOp() == kASTOpInitListExpr ||
+        initList.initExprs[i]->GetASTOp() == kASTASTDesignatedInitUpdateExpr) {
+      SolveInitListExprOrDesignatedInitUpdateExpr(fieldID, *(initList.initExprs[i]), baseStructFEPtrType, base, stmts);
+    } else if (fieldMirType->GetKind() == kTypeArray && initList.initExprs[i]->GetASTOp() == kASTStringLiteral) {
+      SolveStructFieldOfArrayTypeInitWithStringLiteral(fieldInfo, *(initList.initExprs[i]),
+                                                       baseStructFEPtrType, base, stmts);
+    } else {
+      SolveStructFieldOfBasicType(fieldID, *(initList.initExprs[i]), baseStructFEPtrType, base, stmts);
+    }
+  }
+
+  // Handling Incomplete Union Initialization
+  if (curStructMirType->GetKind() == kTypeUnion) {
+    UniqueFEIRExpr addrOfExpr = std::make_unique<FEIRExprAddrofVar>(var->Clone(), baseFieldID);
+    ProcessImplicitInit(addrOfExpr->Clone(), curFieldTypeSize,
+                        curStructMirType->GetSize(), 1, stmts, initList.GetSrcLoc());
+  }
+}
+
+UniqueFEIRExpr ASTInitListExpr::GetAddrofArrayFEExprByStructArrayField(MIRType &fieldType,
+                                                                       const UniqueFEIRExpr &addrOfArrayField) const {
+  CHECK_FATAL(fieldType.GetKind() == kTypeArray, "invalid field type");
+  auto arrayFEType = FEIRTypeHelper::CreateTypeNative(fieldType);
+  std::list<UniqueFEIRExpr> indexExprs;
+  auto indexExpr = FEIRBuilder::CreateExprConstI32(0);
+  indexExprs.emplace_back(std::move(indexExpr));
+  auto addrOfArrayExpr = FEIRBuilder::CreateExprAddrofArray(arrayFEType->Clone(), addrOfArrayField->Clone(),
+                                                            "", indexExprs);
+  return addrOfArrayExpr;
+}
+
+void ASTInitListExpr::SolveArrayElementInitWithInitListExpr(const UniqueFEIRExpr &addrOfArray,
+                                                            const UniqueFEIRExpr &addrOfElementExpr,
+                                                            const MIRType &elementType, const ASTExpr &subExpr,
+                                                            size_t index, std::list<UniqueFEIRStmt> &stmts) const {
+  auto base = std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr>(addrOfElementExpr->Clone());
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() && subExpr.GetEvaluatedFlag() == kEvaluatedAsZero) {
+    UniqueFEIRExpr realAddr = addrOfArray->Clone();
+    if (index > 0) {
+      UniqueFEIRExpr idxExpr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(index));
+      UniqueFEIRExpr elemSizeExpr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(elementType.GetSize()));
+      UniqueFEIRExpr offsetSizeExpr = FEIRBuilder::CreateExprBinary(OP_mul, std::move(idxExpr), elemSizeExpr->Clone());
+      realAddr = FEIRBuilder::CreateExprBinary(OP_add, std::move(realAddr), offsetSizeExpr->Clone());
+    }
+    ProcessImplicitInit(realAddr->Clone(), 0, static_cast<uint32>(elementType.GetSize()), 1, stmts,
+                        subExpr.GetSrcLoc());
+  } else {
+    ProcessInitList(base, *(static_cast<const ASTInitListExpr*>(&subExpr)), stmts);
+  }
+}
+
+void ASTInitListExpr::HandleImplicitInitSections(const UniqueFEIRExpr &addrOfArray, const ASTInitListExpr &initList,
+                                                 const MIRType &elementType, std::list<UniqueFEIRStmt> &stmts) const {
+  auto arrayMirType = static_cast<MIRArrayType*>(initList.initListType);
+  auto allSize = arrayMirType->GetSize();
+  auto elemSize = elementType.GetSize();
+  CHECK_FATAL(elemSize != 0, "elemSize should not 0");
+  auto allElemCnt = allSize / elemSize;
+  ProcessImplicitInit(addrOfArray->Clone(), static_cast<uint32>(initList.initExprs.size()), allElemCnt, elemSize, stmts,
+                      initList.GetSrcLoc());
+}
+
+void ASTInitListExpr::ProcessArrayInitList(const UniqueFEIRExpr &addrOfArray, const ASTInitListExpr &initList,
+                                           std::list<UniqueFEIRStmt> &stmts) const {
+  auto arrayMirType = static_cast<MIRArrayType*>(initList.initListType);
+  UniqueFEIRType arrayFEType = FEIRTypeHelper::CreateTypeNative(*arrayMirType);
+  MIRType *elementType;
+  if (arrayMirType->GetDim() > 1) {
+    uint32 subSizeArray[arrayMirType->GetDim()];
+    for (int dim = 1; dim < arrayMirType->GetDim(); ++dim) {
+      subSizeArray[dim - 1] = arrayMirType->GetSizeArrayItem(static_cast<uint32>(dim));
+    }
+    elementType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*arrayMirType->GetElemType(),
+        static_cast<uint8>(arrayMirType->GetDim() - 1), subSizeArray);
+  } else {
+    elementType = arrayMirType->GetElemType();
+  }
+  auto elementPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elementType);
+  CHECK_FATAL(initExprs.size() <= INT_MAX, "invalid index");
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() && initList.GetEvaluatedFlag() == kEvaluatedAsZero) {
+    ProcessImplicitInit(addrOfArray->Clone(), 0, static_cast<uint32>(arrayMirType->GetSize()), 1, stmts,
+                        initList.GetSrcLoc());
+    return;
+  }
+  for (size_t i = 0; i < initList.initExprs.size(); ++i) {
+    std::list<UniqueFEIRExpr> indexExprs;
+    UniqueFEIRExpr indexExpr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(i));
+    indexExprs.emplace_back(std::move(indexExpr));
+    auto addrOfElemExpr = FEIRBuilder::CreateExprAddrofArray(arrayFEType->Clone(), addrOfArray->Clone(), "",
+                                                             indexExprs);
+    const ASTExpr *subExpr = initList.initExprs[i];
+    while (subExpr->GetASTOp() == kConstantExpr) {
+      subExpr = static_cast<const ASTConstantExpr*>(subExpr)->GetChild();
+    }
+    if (subExpr->GetASTOp() == kASTOpInitListExpr) {
+      SolveArrayElementInitWithInitListExpr(addrOfArray, addrOfElemExpr, *elementType, *subExpr, i, stmts);
+      continue;
+    }
+    UniqueFEIRExpr elemExpr = subExpr->Emit2FEExpr(stmts);
+    if ((elementType->GetKind() == kTypeArray || arrayMirType->GetDim() == 1) &&
+        subExpr->GetASTOp() == kASTStringLiteral) {
+      ProcessStringLiteralInitList(addrOfElemExpr->Clone(), elemExpr->Clone(),
+                                   static_cast<const ASTStringLiteral*>(subExpr)->GetLength(), stmts);
+      if (arrayMirType->GetDim() == 1) {
+        return;
+      }
+      continue;
+    }
+    auto stmt = FEIRBuilder::CreateStmtIAssign(FEIRTypeHelper::CreateTypeNative(*elementPtrType)->Clone(),
+                                               addrOfElemExpr->Clone(), elemExpr->Clone(), 0);
+    stmt->SetSrcLoc(initList.initExprs[i]->GetSrcLoc());
+    stmts.emplace_back(std::move(stmt));
+  }
+
+  HandleImplicitInitSections(addrOfArray, initList, *elementType, stmts);
+}
+
+void ASTInitListExpr::ProcessVectorInitList(std::variant<std::pair<UniqueFEIRVar, FieldID>, UniqueFEIRExpr> &base,
+                                            const ASTInitListExpr &initList, std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRType srcType = FEIRTypeHelper::CreateTypeNative(*(initList.initListType));
+  if (std::holds_alternative<UniqueFEIRExpr>(base)) {
+    CHECK_FATAL(false, "unsupported case");
+  } else {
+    UniqueFEIRVar srcVar = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).first->Clone();
+    FieldID fieldID = std::get<std::pair<UniqueFEIRVar, FieldID>>(base).second;
+    UniqueFEIRExpr dreadVar;
+    if (fieldID != 0) {
+      dreadVar = FEIRBuilder::CreateExprDReadAggField(srcVar->Clone(), fieldID, srcType->Clone());
+    } else {
+      dreadVar = FEIRBuilder::CreateExprDRead(srcVar->Clone());
+    }
+    for (size_t index = 0; index < initList.initExprs.size(); ++index) {
+      UniqueFEIRExpr indexExpr = FEIRBuilder::CreateExprConstI32(index);
+      UniqueFEIRExpr elemExpr = initList.initExprs[index]->Emit2FEExpr(stmts);
+      std::vector<std::unique_ptr<FEIRExpr>> argOpnds;
+      argOpnds.push_back(std::move(elemExpr));
+      argOpnds.push_back(dreadVar->Clone());
+      argOpnds.push_back(std::move(indexExpr));
+      UniqueFEIRExpr intrinsicExpr = std::make_unique<FEIRExprIntrinsicopForC>(
+          srcType->Clone(), SetVectorSetLane(*(initList.initListType)), argOpnds);
+      auto stmt = FEIRBuilder::CreateStmtDAssignAggField(srcVar->Clone(), std::move(intrinsicExpr), fieldID);
+      stmts.emplace_back(std::move(stmt));
+    }
+  }
+}
+
+MIRIntrinsicID ASTInitListExpr::SetVectorSetLane(const MIRType &type) const {
+  MIRIntrinsicID intrinsic;
+  switch (type.GetPrimType()) {
+#define SETQ_LANE(TY)                                                          \
+    case PTY_##TY:                                                             \
+      intrinsic = INTRN_vector_set_element_##TY;                               \
+      break;
+
+    SETQ_LANE(v2i64)
+    SETQ_LANE(v4i32)
+    SETQ_LANE(v8i16)
+    SETQ_LANE(v16i8)
+    SETQ_LANE(v2u64)
+    SETQ_LANE(v4u32)
+    SETQ_LANE(v8u16)
+    SETQ_LANE(v16u8)
+    SETQ_LANE(v2f64)
+    SETQ_LANE(v4f32)
+    SETQ_LANE(v2i32)
+    SETQ_LANE(v4i16)
+    SETQ_LANE(v8i8)
+    SETQ_LANE(v2u32)
+    SETQ_LANE(v4u16)
+    SETQ_LANE(v8u8)
+    SETQ_LANE(v2f32)
+    case PTY_i64:
+      intrinsic = INTRN_vector_set_element_v1i64;
+      break;
+    case PTY_u64:
+      intrinsic = INTRN_vector_set_element_v1u64;
+      break;
+    case PTY_f64:
+      intrinsic = INTRN_vector_set_element_v1f64;
+      break;
+    default:
+      CHECK_FATAL(false, "Unhandled vector type");
+      return INTRN_UNDEFINED;
+  }
+  return intrinsic;
+}
+
+void ASTInitListExpr::SetInitExprs(ASTExpr *astExpr) {
+  initExprs.emplace_back(astExpr);
+}
+
+void ASTInitListExpr::SetInitListType(MIRType *type) {
+  initListType = type;
+}
+
+// ---------- ASTImplicitValueInitExpr ----------
+MIRConst *ASTImplicitValueInitExpr::GenerateMIRConstImpl() const {
+  return FEUtils::CreateImplicitConst(mirType);
+}
+
+UniqueFEIRExpr ASTImplicitValueInitExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return ImplicitInitFieldValue(*mirType, stmts);
+}
+
+MIRConst *ASTStringLiteral::GenerateMIRConstImpl() const {
+  auto *arrayType = static_cast<MIRArrayType*>(mirType);
+  uint32 arraySize = arrayType->GetSizeArrayItem(0);
+  auto elemType = arrayType->GetElemType();
+  auto *val = FEManager::GetModule().GetMemPool()->New<MIRAggConst>(FEManager::GetModule(), *arrayType);
+  for (uint32 i = 0; i < arraySize; ++i) {
+    MIRConst *cst;
+    if (i < codeUnits.size()) {
+      cst = FEManager::GetModule().GetMemPool()->New<MIRIntConst>(codeUnits[i], *elemType);
+    } else {
+      cst = FEManager::GetModule().GetMemPool()->New<MIRIntConst>(0, *elemType);
+    }
+    val->PushBack(cst);
+  }
+  return val;
+}
+
+UniqueFEIRExpr ASTStringLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  MIRType *elemType = static_cast<MIRArrayType*>(mirType)->GetElemType();
+  std::vector<uint32> codeUnitsVec;
+  (void)codeUnitsVec.insert(codeUnitsVec.cend(), codeUnits.cbegin(), codeUnits.cend());
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprAddrofConstArray>(codeUnitsVec, elemType, GetStr());
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+// ---------- ASTArraySubscriptExpr ----------
+size_t ASTArraySubscriptExpr::CalculateOffset() const {
+  size_t offset = 0;
+  CHECK_FATAL(idxExpr->GetConstantValue() != nullptr, "Not constant value for constant initializer");
+  offset += mirType->GetSize() * static_cast<std::size_t>(idxExpr->GetConstantValue()->val.i64);
+  return offset;
+}
+
+ASTExpr *ASTArraySubscriptExpr::FindFinalBase() const {
+  if (baseExpr->GetASTOp() == kASTSubscriptExpr) {
+    return static_cast<ASTArraySubscriptExpr*>(baseExpr)->FindFinalBase();
+  }
+  return baseExpr;
+}
+
+MIRConst *ASTArraySubscriptExpr::GenerateMIRConstImpl() const {
+  size_t offset = CalculateOffset();
+  const ASTExpr *base = FindFinalBase();
+  MIRConst *baseConst = base->GenerateMIRConst();
+  if (baseConst->GetKind() == kConstStrConst) {
+    MIRStrConst *strConst = static_cast<MIRStrConst*>(baseConst);
+    std::string str = GlobalTables::GetUStrTable().GetStringFromStrIdx(strConst->GetValue());
+    CHECK_FATAL(str.length() >= offset, "Invalid operation");
+    str = str.substr(offset);
+    UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str);
+    return FEManager::GetModule().GetMemPool()->New<MIRStrConst>(
+        strIdx, *GlobalTables::GetTypeTable().GetPrimType(PTY_a64));
+  } else if (baseConst->GetKind() == kConstAddrof) {
+    MIRAddrofConst *konst = static_cast<MIRAddrofConst*>(baseConst);
+    CHECK_FATAL(offset <= INT_MAX, "Invalid operation");
+    return FEManager::GetModule().GetMemPool()->New<MIRAddrofConst>(konst->GetSymbolIndex(), konst->GetFieldID(),
+        konst->GetType(), konst->GetOffset() + static_cast<int32>(offset));
+  } else {
+    CHECK_FATAL(false, "Unsupported MIRConst: %d", baseConst->GetKind());
+  }
+}
+
+bool ASTArraySubscriptExpr::CheckFirstDimIfZero(const MIRType *arrType) const {
+  auto tmpArrayType = static_cast<const MIRArrayType*>(arrType);
+  uint32 size = tmpArrayType->GetSizeArrayItem(0);
+  uint32 oriDim = tmpArrayType->GetDim();
+  if (size == 0 && oriDim >= 2) { // 2 is the array dim
+    return true;
+  }
+  return false;
+}
+
+void ASTArraySubscriptExpr::InsertNonnullChecking(std::list<UniqueFEIRStmt> &stmts, const UniqueFEIRExpr &indexExpr,
+                                                  const UniqueFEIRExpr &baseAddrExpr) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || indexExpr->GetKind() != kExprConst) {
+    return;
+  }
+  if (FEIRBuilder::IsZeroConstExpr(indexExpr)) {  // insert nonnull checking when ptr[0]
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtAssertNonnull>(OP_assertnonnull, baseAddrExpr->Clone());
+    stmt->SetSrcLoc(loc);
+    stmts.emplace_back(std::move(stmt));
+  }
+}
+
+MIRType *ASTArraySubscriptExpr::GetArrayTypeForPointerArray() const {
+  MIRType *arrayTypeOpt = nullptr;
+  MIRPtrType *ptrTy = static_cast<MIRPtrType*>(arrayType);
+  MIRType *pointedTy = ptrTy->GetPointedType();
+  if (pointedTy->GetKind() == kTypeArray) {
+    MIRArrayType *pointedArrTy = static_cast<MIRArrayType*>(pointedTy);
+    std::vector<uint32> sizeArray{1};
+    for (uint32 i = 0; i < pointedArrTy->GetDim(); ++i) {
+      sizeArray.push_back(pointedArrTy->GetSizeArrayItem(i));
+    }
+    MIRArrayType newArrTy(pointedArrTy->GetElemTyIdx(), sizeArray);
+    arrayTypeOpt = static_cast<MIRArrayType*>(GlobalTables::GetTypeTable().GetOrCreateMIRTypeNode(newArrTy));
+  } else {
+    arrayTypeOpt = GlobalTables::GetTypeTable().GetOrCreateArrayType(*pointedTy, 1);
+  }
+  return arrayTypeOpt;
+}
+
+UniqueFEIRExpr ASTArraySubscriptExpr::SolveMultiDimArray(UniqueFEIRExpr &baseAddrFEExpr, UniqueFEIRType &arrayFEType,
+                                                         bool isArrayTypeOpt, std::list<UniqueFEIRStmt> &stmts) const {
+  std::list<UniqueFEIRExpr> feIdxExprs;
+  if (baseAddrFEExpr->GetKind() == kExprAddrofArray && !isArrayTypeOpt) {
+    auto baseArrayExpr = static_cast<FEIRExprAddrofArray*>(baseAddrFEExpr.get());
+    for (auto &e : baseArrayExpr->GetExprIndexs()) {
+      (void)feIdxExprs.emplace_back(e->Clone());
+    }
+    arrayFEType = baseArrayExpr->GetTypeArray()->Clone();
+    baseAddrFEExpr = baseArrayExpr->GetExprArray()->Clone();
+  }
+  auto feIdxExpr = idxExpr->Emit2FEExpr(stmts);
+  if (isArrayTypeOpt) {
+    InsertNonnullChecking(stmts, feIdxExpr, baseAddrFEExpr);
+  }
+  (void)feIdxExprs.emplace_back(std::move(feIdxExpr));
+  return FEIRBuilder::CreateExprAddrofArray(arrayFEType->Clone(), baseAddrFEExpr->Clone(), "", feIdxExprs);
+}
+
+UniqueFEIRExpr ASTArraySubscriptExpr::SolveOtherArrayType(const UniqueFEIRExpr &baseAddrFEExpr,
+                                                          std::list<UniqueFEIRStmt> &stmts) const {
+  std::vector<UniqueFEIRExpr> offsetExprs;
+  UniqueFEIRExpr offsetExpr;
+  auto feIdxExpr = idxExpr->Emit2FEExpr(stmts);
+  PrimType indexPty = feIdxExpr->GetPrimType();
+  UniqueFEIRType sizeType = IsSignedInteger(indexPty) ? std::make_unique<FEIRTypeNative>(*GlobalTables::GetTypeTable().
+      GetPrimType(PTY_i64)) : std::make_unique<FEIRTypeNative>(*GlobalTables::GetTypeTable().GetPrimType(PTY_ptr));
+  feIdxExpr = IsSignedInteger(indexPty) ? FEIRBuilder::CreateExprCvtPrim(std::move(feIdxExpr), GetRegPrimType(
+      indexPty), PTY_i64) : FEIRBuilder::CreateExprCvtPrim(std::move(feIdxExpr), GetRegPrimType(indexPty), PTY_ptr);
+  if (isVLA) {
+    auto feSizeExpr = vlaSizeExpr->Emit2FEExpr(stmts);
+    feIdxExpr = FEIRBuilder::CreateExprBinary(sizeType->Clone(), OP_mul, std::move(feIdxExpr), std::move(feSizeExpr));
+  } else if (mirType->GetSize() != 1) {
+    auto typeSizeExpr = std::make_unique<FEIRExprConst>(mirType->GetSize(), sizeType->GetPrimType());
+    feIdxExpr = FEIRBuilder::CreateExprBinary(sizeType->Clone(), OP_mul, std::move(feIdxExpr), std::move(typeSizeExpr));
+  }
+  (void)offsetExprs.emplace_back(std::move(feIdxExpr));
+  if (offsetExprs.size() != 0) {
+    offsetExpr = std::move(offsetExprs[0]);
+    for (size_t i = 1; i < offsetExprs.size(); i++) {
+      offsetExpr = FEIRBuilder::CreateExprBinary(std::move(sizeType), OP_add, std::move(offsetExpr),
+                                                 std::move(offsetExprs[i]));
+    }
+  }
+  return FEIRBuilder::CreateExprBinary(std::move(sizeType), OP_add, baseAddrFEExpr->Clone(), std::move(offsetExpr));
+}
+
+UniqueFEIRExpr ASTArraySubscriptExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  std::list<UniqueFEIRStmt> subStmts;  // To delete redundant bounds checks in one ASTArraySubscriptExpr stmts.
+  auto baseAddrFEExpr = baseExpr->Emit2FEExpr(subStmts);
+  auto retFEType = std::make_unique<FEIRTypeNative>(*mirType);
+  MIRType *arrayTypeOpt = arrayType;
+  bool isArrayTypeOpt = false;
+  if (arrayTypeOpt->GetKind() == kTypePointer && !isVLA) {
+    arrayTypeOpt = GetArrayTypeForPointerArray();
+    isArrayTypeOpt = true;
+  }
+  UniqueFEIRType arrayFEType = std::make_unique<FEIRTypeNative>(*arrayTypeOpt);
+  auto mirPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType);
+  auto fePtrType = std::make_unique<FEIRTypeNative>(*mirPtrType);
+  UniqueFEIRExpr addrOfArray;
+  if (arrayTypeOpt->GetKind() == MIRTypeKind::kTypeArray && !isVLA) {
+    if (CheckFirstDimIfZero(arrayTypeOpt)) {
+      // return multi-dim array addr directly if its first dim size was 0.
+      stmts.splice(stmts.end(), subStmts);
+      return baseAddrFEExpr;
+    }
+    addrOfArray = SolveMultiDimArray(baseAddrFEExpr, arrayFEType, isArrayTypeOpt, subStmts);
+  } else {
+    addrOfArray = SolveOtherArrayType(baseAddrFEExpr, subStmts);
+  }
+  if (InsertBoundaryChecking(subStmts, addrOfArray->Clone(), std::move(baseAddrFEExpr))) {
+    addrOfArray->SetIsBoundaryChecking(true);
+  }
+  stmts.splice(stmts.end(), subStmts);
+  return FEIRBuilder::CreateExprIRead(std::move(retFEType), fePtrType->Clone(), addrOfArray->Clone());
+}
+
+UniqueFEIRExpr ASTExprUnaryExprOrTypeTraitExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+MIRConst *ASTMemberExpr::GenerateMIRConstImpl() const {
+  uint64 fieldOffset = fieldOffsetBits / kOneByte;
+  const ASTExpr *base = baseExpr;
+  while (base->GetASTOp() == kASTMemberExpr) {  // find final BaseExpr and calculate FieldOffsets
+    const ASTMemberExpr *memberExpr = static_cast<const ASTMemberExpr*>(base);
+    fieldOffset += memberExpr->GetFieldOffsetBits() / kOneByte;
+    base = memberExpr->GetBaseExpr();
+  }
+  MIRConst *baseConst = base->GenerateMIRConst();
+  MIRAddrofConst *konst = nullptr;
+  if (baseConst->GetKind() == kConstAddrof) {
+    konst = static_cast<MIRAddrofConst*>(baseConst);
+  } else if (baseConst->GetKind() == kConstInt) {
+    return FEManager::GetModule().GetMemPool()->New<MIRIntConst>(static_cast<int64>(fieldOffset),
+                                                                 *GlobalTables::GetTypeTable().GetInt64());
+  } else {
+    CHECK_FATAL(false, "base const kind NYI.");
+  }
+  MIRType *baseStructType =
+      base->GetType()->IsMIRPtrType() ? static_cast<MIRPtrType*>(base->GetType())->GetPointedType() :
+      base->GetType();
+  CHECK_FATAL(baseStructType->IsMIRStructType() || baseStructType->GetKind() == kTypeUnion, "Invalid");
+  return FEManager::GetModule().GetMemPool()->New<MIRAddrofConst>(konst->GetSymbolIndex(), konst->GetFieldID(),
+      konst->GetType(), konst->GetOffset() + static_cast<int32>(fieldOffset));
+}
+
+const ASTMemberExpr &ASTMemberExpr::FindFinalMember(const ASTMemberExpr &startExpr,
+                                                    std::list<std::string> &memberNames) const {
+  (void)memberNames.emplace_back(startExpr.GetMemberName());
+  if (startExpr.isArrow || startExpr.baseExpr->GetASTOp() != kASTMemberExpr) {
+    return startExpr;
+  }
+  return FindFinalMember(*(static_cast<ASTMemberExpr*>(startExpr.baseExpr)), memberNames);
+}
+
+void ASTMemberExpr::InsertNonnullChecking(std::list<UniqueFEIRStmt> &stmts, UniqueFEIRExpr baseFEExpr) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic()) {
+    return;
+  }
+  if (baseFEExpr->GetPrimType() == PTY_ptr) {
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtAssertNonnull>(OP_assertnonnull, std::move(baseFEExpr));
+    stmt->SetSrcLoc(loc);
+    stmts.emplace_back(std::move(stmt));
+  }
+}
+
+UniqueFEIRExpr ASTMemberExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRExpr baseFEExpr;
+  std::string fieldName = GetMemberName();
+  bool tmpIsArrow = this->isArrow;
+  MIRType *tmpBaseType = this->baseType;
+  if (baseExpr->GetASTOp() == kASTMemberExpr) {
+    std::list<std::string> memberNameList;
+    (void)memberNameList.emplace_back(GetMemberName());
+    const ASTMemberExpr &finalMember = FindFinalMember(*(static_cast<ASTMemberExpr*>(baseExpr)), memberNameList);
+    baseFEExpr = finalMember.baseExpr->Emit2FEExpr(stmts);
+    tmpIsArrow = finalMember.isArrow;
+    tmpBaseType = finalMember.baseType;
+    fieldName = ASTUtil::Join(memberNameList, "$");  // add structure nesting relationship
+  } else {
+    baseFEExpr = baseExpr->Emit2FEExpr(stmts);
+  }
+  UniqueFEIRType baseFEType = std::make_unique<FEIRTypeNative>(*tmpBaseType);
+  if (tmpIsArrow) {
+    CHECK_FATAL(tmpBaseType->IsMIRPtrType(), "Must be ptr type!");
+    MIRPtrType *mirPtrType = static_cast<MIRPtrType*>(tmpBaseType);
+    MIRType *pointedMirType = mirPtrType->GetPointedType();
+    CHECK_FATAL(pointedMirType->IsStructType(), "pointedMirType must be StructType");
+    MIRStructType *structType = static_cast<MIRStructType*>(pointedMirType);
+    FieldID fieldID = FEUtils::GetStructFieldID(structType, fieldName);
+    MIRType *reType = FEUtils::GetStructFieldType(structType, fieldID);
+    CHECK_FATAL(reType->GetPrimType() == memberType->GetPrimType(), "traverse fieldID error, type is inconsistent");
+    UniqueFEIRType retFEType = std::make_unique<FEIRTypeNative>(*reType);
+    if (retFEType->IsArray()) {
+      return std::make_unique<FEIRExprIAddrof>(std::move(baseFEType), fieldID, std::move(baseFEExpr));
+    } else {
+      InsertNonnullChecking(stmts, baseFEExpr->Clone());
+      return FEIRBuilder::CreateExprIRead(std::move(retFEType), std::move(baseFEType), std::move(baseFEExpr), fieldID);
+    }
+  } else {
+    CHECK_FATAL(tmpBaseType->IsStructType(), "basetype must be StructType");
+    MIRStructType *structType = static_cast<MIRStructType*>(tmpBaseType);
+    FieldID fieldID = FEUtils::GetStructFieldID(structType, fieldName);
+    MIRType *reType = FEUtils::GetStructFieldType(structType, fieldID);
+    CHECK_FATAL(reType->GetPrimType() == memberType->GetPrimType(), "traverse fieldID error, type is inconsistent");
+    UniqueFEIRType reFEType = std::make_unique<FEIRTypeNative>(*reType);
+    FieldID baseID = baseFEExpr->GetFieldID();
+    if (baseFEExpr->GetKind() == FEIRNodeKind::kExprIRead) {
+      baseFEExpr->SetFieldID(baseID + fieldID);
+      baseFEExpr->SetType(std::move(reFEType));
+      return baseFEExpr;
+    }
+    UniqueFEIRVar tmpVar = static_cast<FEIRExprDRead*>(baseFEExpr.get())->GetVar()->Clone();
+    if (reFEType->IsArray()) {
+      auto addrofExpr = std::make_unique<FEIRExprAddrofVar>(std::move(tmpVar));
+      addrofExpr->SetFieldID(baseID + fieldID);
+      return addrofExpr;
+    } else {
+      return FEIRBuilder::CreateExprDReadAggField(std::move(tmpVar), baseID + fieldID, std::move(reFEType));
+    }
+  }
+}
+
+// ---------- ASTDesignatedInitUpdateExpr ----------
+MIRConst *ASTDesignatedInitUpdateExpr::GenerateMIRConstImpl() const {
+  return FEManager::GetModule().GetMemPool()->New<MIRAggConst>(FEManager::GetModule(), *initListType);
+}
+
+UniqueFEIRExpr ASTDesignatedInitUpdateExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(initListVarName, *initListType);
+  UniqueFEIRExpr baseFEIRExpr = baseExpr->Emit2FEExpr(stmts);
+  UniqueFEIRStmt baseFEIRStmt = std::make_unique<FEIRStmtDAssign>(std::move(feirVar), std::move(baseFEIRExpr), 0);
+  stmts.emplace_back(std::move(baseFEIRStmt));
+  static_cast<ASTInitListExpr*>(updaterExpr)->SetInitListVarName(initListVarName);
+  updaterExpr->Emit2FEExpr(stmts);
+  return nullptr;
+}
+
+MIRConst *ASTBinaryOperatorExpr::SolveOpcodeLiorOrCior(const MIRConst &leftConst) const {
+  if (!leftConst.IsZero()) {
+    return GlobalTables::GetIntConstTable().GetOrCreateIntConst(1, *GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+  } else {
+    MIRConst *rightConst = rightExpr->GenerateMIRConst();
+    if (!rightConst->IsZero()) {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          1, *GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+    } else {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+    }
+  }
+}
+
+MIRConst *ASTBinaryOperatorExpr::SolveOpcodeLandOrCand(const MIRConst &leftConst, const MIRConst &rightConst) const {
+  if (leftConst.IsZero()) {
+    return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        0, *GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+  } else if (rightConst.IsZero()) {
+    return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        0, *GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+  } else {
+    return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        1, *GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+  }
+}
+
+MIRConst *ASTBinaryOperatorExpr::SolveOpcodeAdd(const MIRConst &leftConst, const MIRConst &rightConst) const {
+  const MIRIntConst *constInt = nullptr;
+  const MIRConst *baseConst = nullptr;
+  if (leftConst.GetKind() == kConstInt) {
+    constInt = static_cast<const MIRIntConst*>(&leftConst);
+    baseConst = &rightConst;
+  } else if (rightConst.GetKind() == kConstInt) {
+    constInt = static_cast<const MIRIntConst*>(&rightConst);
+    baseConst = &leftConst;
+  } else {
+    CHECK_FATAL(false, "Unsupported yet");
+  }
+  int64 value = constInt->GetExtValue();
+  ASSERT_NOT_NULL(baseConst);
+  if (baseConst->GetKind() == kConstStrConst) {
+    std::string str = GlobalTables::GetUStrTable().GetStringFromStrIdx(
+        static_cast<const MIRStrConst*>(baseConst)->GetValue());
+    CHECK_FATAL(str.length() >= static_cast<std::size_t>(value), "Invalid operation");
+    str = str.substr(static_cast<std::size_t>(value));
+    UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str);
+    return FEManager::GetModule().GetMemPool()->New<MIRStrConst>(
+        strIdx, *GlobalTables::GetTypeTable().GetPrimType(PTY_a64));
+  } else if (baseConst->GetKind() == kConstAddrof) {
+    const MIRAddrofConst *konst = static_cast<const MIRAddrofConst*>(baseConst);
+    auto idx = konst->GetSymbolIndex();
+    auto id = konst->GetFieldID();
+    auto ty = konst->GetType();
+    auto offset = konst->GetOffset();
+    return FEManager::GetModule().GetMemPool()->New<MIRAddrofConst>(idx, id, ty, offset + value);
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+}
+
+MIRConst *ASTBinaryOperatorExpr::SolveOpcodeSub(const MIRConst &leftConst, const MIRConst &rightConst) const {
+  CHECK_FATAL(leftConst.GetKind() == kConstAddrof && rightConst.GetKind() == kConstInt, "Unsupported");
+  const MIRAddrofConst *konst = static_cast<const MIRAddrofConst*>(&leftConst);
+  auto idx = konst->GetSymbolIndex();
+  auto id = konst->GetFieldID();
+  auto ty = konst->GetType();
+  auto offset = konst->GetOffset();
+  int64 value = static_cast<const MIRIntConst*>(&rightConst)->GetExtValue();
+  return FEManager::GetModule().GetMemPool()->New<MIRAddrofConst>(idx, id, ty, offset - value);
+}
+
+MIRConst *ASTBinaryOperatorExpr::GenerateMIRConstImpl() const {
+  MIRConst *leftConst = leftExpr->GenerateMIRConst();
+  MIRConst *rightConst = nullptr;
+  if (opcode == OP_lior || opcode == OP_cior) {
+    return SolveOpcodeLiorOrCior(*leftConst);
+  }
+  rightConst = rightExpr->GenerateMIRConst();
+  if (leftConst->GetKind() == kConstLblConst || rightConst->GetKind() == kConstLblConst) {
+    // if left or right is label mirconst, not currently implemented
+    return nullptr;
+  }
+  if (opcode == OP_land || opcode == OP_cand) {
+    return SolveOpcodeLandOrCand(*leftConst, *rightConst);
+  }
+  if (leftConst->GetKind() == rightConst->GetKind()) {
+    if (isConstantFolded) {
+      return value->Translate2MIRConst();
+    }
+    switch (leftConst->GetKind()) {
+      case kConstInt: {
+        return MIRConstGenerator(FEManager::GetModule().GetMemPool(), static_cast<MIRIntConst*>(leftConst),
+                                 static_cast<MIRIntConst*>(rightConst), opcode);
+      }
+      case kConstFloatConst: {
+        return MIRConstGenerator(FEManager::GetModule().GetMemPool(), static_cast<MIRFloatConst*>(leftConst),
+                                 static_cast<MIRFloatConst*>(rightConst), opcode);
+      }
+      case kConstDoubleConst: {
+        return MIRConstGenerator(FEManager::GetModule().GetMemPool(), static_cast<MIRDoubleConst*>(leftConst),
+                                 static_cast<MIRDoubleConst*>(rightConst), opcode);
+      }
+      default: {
+        CHECK_FATAL(false, "Unsupported yet");
+        return nullptr;
+      }
+    }
+  }
+  if (opcode == OP_add) {
+    return SolveOpcodeAdd(*leftConst, *rightConst);
+  } else if (opcode == OP_sub) {
+    return SolveOpcodeSub(*leftConst, *rightConst);
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  return nullptr;
+}
+
+UniqueFEIRType ASTBinaryOperatorExpr::SelectBinaryOperatorType(UniqueFEIRExpr &left, UniqueFEIRExpr &right) const {
+  // For arithmetical calculation only
+  std::map<PrimType, uint8> binaryTypePriority = {
+    {PTY_u1, 0},
+    {PTY_i8, 1},
+    {PTY_u8, 2},
+    {PTY_i16, 3},
+    {PTY_u16, 4},
+    {PTY_i32, 5},
+    {PTY_u32, 6},
+    {PTY_i64, 7},
+    {PTY_u64, 8},
+    {PTY_f32, 9},
+    {PTY_f64, 10}
+  };
+  UniqueFEIRType feirType = std::make_unique<FEIRTypeNative>(*retType);
+  if (!cvtNeeded) {
+    return feirType;
+  }
+  if (binaryTypePriority.find(left->GetPrimType()) == binaryTypePriority.end() ||
+      binaryTypePriority.find(right->GetPrimType()) == binaryTypePriority.end()) {
+    if (left->GetPrimType() != feirType->GetPrimType()) {
+      left = FEIRBuilder::CreateExprCastPrim(std::move(left), feirType->GetPrimType());
+    }
+    if (right->GetPrimType() != feirType->GetPrimType()) {
+      right = FEIRBuilder::CreateExprCastPrim(std::move(right), feirType->GetPrimType());
+    }
+    return feirType;
+  }
+  MIRType *dstType;
+  if (binaryTypePriority[left->GetPrimType()] > binaryTypePriority[right->GetPrimType()]) {
+    right = FEIRBuilder::CreateExprCastPrim(std::move(right), left->GetPrimType());
+    dstType = left->GetType()->GenerateMIRTypeAuto();
+  } else {
+    left = FEIRBuilder::CreateExprCastPrim(std::move(left), right->GetPrimType());
+    dstType = right->GetType()->GenerateMIRTypeAuto();
+  }
+  return std::make_unique<FEIRTypeNative>(*dstType);
+}
+
+UniqueFEIRExpr ASTBinaryOperatorExpr::Emit2FEExprComplexCalculations(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("Complex_"), *retType);
+  auto complexElementFEType = std::make_unique<FEIRTypeNative>(*complexElementType);
+  UniqueFEIRExpr realFEExpr = FEIRBuilder::CreateExprBinary(complexElementFEType->Clone(), opcode,
+                                                            leftRealExpr->Emit2FEExpr(stmts),
+                                                            rightRealExpr->Emit2FEExpr(stmts));
+  UniqueFEIRExpr imagFEExpr = FEIRBuilder::CreateExprBinary(complexElementFEType->Clone(), opcode,
+                                                            leftImagExpr->Emit2FEExpr(stmts),
+                                                            rightImagExpr->Emit2FEExpr(stmts));
+  auto realStmt = FEIRBuilder::CreateStmtDAssignAggField(tempVar->Clone(), std::move(realFEExpr), kComplexRealID);
+  auto imagStmt = FEIRBuilder::CreateStmtDAssignAggField(tempVar->Clone(), std::move(imagFEExpr), kComplexImagID);
+  stmts.emplace_back(std::move(realStmt));
+  stmts.emplace_back(std::move(imagStmt));
+  auto dread = FEIRBuilder::CreateExprDRead(std::move(tempVar));
+  static_cast<FEIRExprDRead*>(dread.get())->SetFieldType(std::move(complexElementFEType));
+  return dread;
+}
+
+UniqueFEIRExpr ASTBinaryOperatorExpr::Emit2FEExprComplexCompare(std::list<UniqueFEIRStmt> &stmts) const {
+  auto boolFEType = std::make_unique<FEIRTypeNative>(*GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+  UniqueFEIRExpr realFEExpr = FEIRBuilder::CreateExprBinary(boolFEType->Clone(), opcode,
+                                                            leftRealExpr->Emit2FEExpr(stmts),
+                                                            rightRealExpr->Emit2FEExpr(stmts));
+  UniqueFEIRExpr imagFEExpr = FEIRBuilder::CreateExprBinary(boolFEType->Clone(), opcode,
+                                                            leftImagExpr->Emit2FEExpr(stmts),
+                                                            rightImagExpr->Emit2FEExpr(stmts));
+  UniqueFEIRExpr finalExpr;
+  if (opcode == OP_eq) {
+    finalExpr = FEIRBuilder::CreateExprBinary(boolFEType->Clone(), OP_land, std::move(realFEExpr),
+                                              std::move(imagFEExpr));
+  } else {
+    finalExpr = FEIRBuilder::CreateExprBinary(boolFEType->Clone(), OP_lior, std::move(realFEExpr),
+                                              std::move(imagFEExpr));
+  }
+  return finalExpr;
+}
+
+UniqueFEIRExpr ASTBinaryOperatorExpr::Emit2FEExprLogicOperate(std::list<UniqueFEIRStmt> &stmts) const {
+  bool inShortCircuit = true;
+  uint32 trueLabelIdx = trueIdx;
+  uint32 falseLabelIdx = falseIdx;
+  uint32 fallthrouLabelIdx, jumpToLabelIdx;
+  uint32 rightCondLabelIdx = FEUtils::GetSequentialNumber();
+  MIRType *tempVarType = GlobalTables::GetTypeTable().GetUInt32();
+  UniqueFEIRVar shortCircuit = FEIRBuilder::CreateVarNameForC(GetVarName(), *tempVarType);
+
+  // check short circuit boundary
+  if (trueLabelIdx == 0) {
+    trueLabelIdx = FEUtils::GetSequentialNumber();
+    falseLabelIdx = FEUtils::GetSequentialNumber();
+    inShortCircuit = false;
+  }
+
+  Opcode op = opcode == OP_cior ? OP_brtrue : OP_brfalse;
+  if (op == OP_brtrue) {
+    fallthrouLabelIdx = falseLabelIdx;
+    jumpToLabelIdx = trueLabelIdx;
+    leftExpr->SetShortCircuitIdx(jumpToLabelIdx, rightCondLabelIdx);
+  } else {
+    fallthrouLabelIdx = trueLabelIdx;
+    jumpToLabelIdx = falseLabelIdx;
+    leftExpr->SetShortCircuitIdx(rightCondLabelIdx, jumpToLabelIdx);
+  }
+  rightExpr->SetShortCircuitIdx(trueLabelIdx, falseLabelIdx);
+
+  std::string rightCondLabel = FEUtils::GetSequentialName0(FEUtils::kCondGoToStmtLabelNamePrefix, rightCondLabelIdx);
+  std::string fallthrouLabel = FEUtils::GetSequentialName0(FEUtils::kCondGoToStmtLabelNamePrefix, fallthrouLabelIdx);
+  std::string jumpToLabel = FEUtils::GetSequentialName0(FEUtils::kCondGoToStmtLabelNamePrefix, jumpToLabelIdx);
+
+  // brfalse/brtrue label (leftCond)
+  auto leftFEExpr = leftExpr->Emit2FEExpr(stmts);
+  if (leftFEExpr != nullptr) {
+    auto leftCond = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(leftFEExpr));
+    UniqueFEIRStmt leftCondGoToExpr = std::make_unique<FEIRStmtCondGotoForC>(leftCond->Clone(), op, jumpToLabel);
+    leftCondGoToExpr->SetSrcLoc(leftExpr->GetSrcLoc());
+    stmts.emplace_back(std::move(leftCondGoToExpr));
+  }
+
+  auto rightCondlabelStmt = std::make_unique<FEIRStmtLabel>(rightCondLabel);
+  rightCondlabelStmt->SetSrcLoc(loc);
+  stmts.emplace_back(std::move(rightCondlabelStmt));
+
+  // brfalse/brtrue label (rightCond)
+  auto rightFEExpr = rightExpr->Emit2FEExpr(stmts);
+  if (rightFEExpr != nullptr) {
+    auto rightCond = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(rightFEExpr));
+    UniqueFEIRStmt rightCondGoToExpr = std::make_unique<FEIRStmtCondGotoForC>(rightCond->Clone(), op, jumpToLabel);
+    rightCondGoToExpr->SetSrcLoc(rightExpr->GetSrcLoc());
+    UniqueFEIRStmt goStmt = FEIRBuilder::CreateStmtGoto(fallthrouLabel);
+    goStmt->SetSrcLoc(rightExpr->GetSrcLoc());
+    stmts.emplace_back(std::move(rightCondGoToExpr));
+    stmts.emplace_back(std::move(goStmt));
+  }
+
+  UniqueFEIRExpr returnValue(nullptr);
+  // when reaching the outer layer of a short circuit, return explicit value for each branch
+  if (!inShortCircuit) {
+    std::string nextLabel = FEUtils::GetSequentialName(FEUtils::kCondGoToStmtLabelNamePrefix);
+    UniqueFEIRExpr trueConst = FEIRBuilder::CreateExprConstAnyScalar(PTY_u32, 1);
+    UniqueFEIRExpr falseConst = FEIRBuilder::CreateExprConstAnyScalar(PTY_u32, 0);
+    UniqueFEIRStmt goStmt = FEIRBuilder::CreateStmtGoto(nextLabel);
+    goStmt->SetSrcLoc(rightExpr->GetSrcLoc());
+    auto trueCircuit = std::make_unique<FEIRStmtDAssign>(shortCircuit->Clone(), std::move(trueConst), 0);
+    trueCircuit->SetSrcLoc(rightExpr->GetSrcLoc());
+    auto falseCircuit = std::make_unique<FEIRStmtDAssign>(shortCircuit->Clone(), std::move(falseConst), 0);
+    falseCircuit->SetSrcLoc(rightExpr->GetSrcLoc());
+    auto labelFallthrouStmt = std::make_unique<FEIRStmtLabel>(fallthrouLabel);
+    labelFallthrouStmt->SetSrcLoc(rightExpr->GetSrcLoc());
+    auto labelJumpToStmt = std::make_unique<FEIRStmtLabel>(jumpToLabel);
+    labelJumpToStmt->SetSrcLoc(rightExpr->GetSrcLoc());
+    auto labelNextStmt = std::make_unique<FEIRStmtLabel>(nextLabel);
+    labelNextStmt->SetSrcLoc(rightExpr->GetSrcLoc());
+    stmts.emplace_back(std::move(labelFallthrouStmt));
+    stmts.emplace_back(op == OP_brtrue ? std::move(falseCircuit) : std::move(trueCircuit));
+    stmts.emplace_back(std::move(goStmt));
+    stmts.emplace_back(std::move(labelJumpToStmt));
+    stmts.emplace_back(op == OP_brtrue ? std::move(trueCircuit) : std::move(falseCircuit));
+    stmts.emplace_back(std::move(labelNextStmt));
+    returnValue = FEIRBuilder::CreateExprDRead(shortCircuit->Clone());
+  }
+  return returnValue;
+}
+
+UniqueFEIRExpr ASTBinaryOperatorExpr::Emit2FEExprLogicOperateSimplify(std::list<UniqueFEIRStmt> &stmts) const {
+  std::list<UniqueFEIRStmt> lStmts;
+  std::list<UniqueFEIRStmt> cStmts;
+  std::list<UniqueFEIRStmt> rStmts;
+  Opcode op = opcode == OP_cior ? OP_brtrue : OP_brfalse;
+  MIRType *tempVarType = GlobalTables::GetTypeTable().GetInt32();
+  UniqueFEIRType tempFeirType = std::make_unique<FEIRTypeNative>(*tempVarType);
+  UniqueFEIRVar shortCircuit = FEIRBuilder::CreateVarNameForC(GetVarName(), *tempVarType);
+  std::string labelName = FEUtils::GetSequentialName(FEUtils::kCondGoToStmtLabelNamePrefix + "label_");
+  auto leftFEExpr = leftExpr->Emit2FEExpr(lStmts);
+  leftFEExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(leftFEExpr));
+  auto leftStmt = std::make_unique<FEIRStmtDAssign>(shortCircuit->Clone(), leftFEExpr->Clone(), 0);
+  cStmts.emplace_back(std::move(leftStmt));
+  auto dreadExpr = FEIRBuilder::CreateExprDRead(shortCircuit->Clone());
+  UniqueFEIRStmt condGoToExpr = std::make_unique<FEIRStmtCondGotoForC>(dreadExpr->Clone(), op, labelName);
+  cStmts.emplace_back(std::move(condGoToExpr));
+  auto rightFEExpr = rightExpr->Emit2FEExpr(rStmts);
+  rightFEExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(rightFEExpr));
+  if (rStmts.empty()) {
+    stmts.splice(stmts.end(), lStmts);
+    UniqueFEIRType feirType = SelectBinaryOperatorType(leftFEExpr, rightFEExpr);
+    return FEIRBuilder::CreateExprBinary(std::move(feirType), opcode, std::move(leftFEExpr), std::move(rightFEExpr));
+  }
+  auto rightStmt = std::make_unique<FEIRStmtDAssign>(shortCircuit->Clone(), rightFEExpr->Clone(), 0);
+  rStmts.emplace_back(std::move(rightStmt));
+  auto labelStmt = std::make_unique<FEIRStmtLabel>(labelName);
+  rStmts.emplace_back(std::move(labelStmt));
+  stmts.splice(stmts.end(), lStmts);
+  stmts.splice(stmts.end(), cStmts);
+  stmts.splice(stmts.end(), rStmts);
+  return FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(dreadExpr));
+}
+
+UniqueFEIRExpr ASTBinaryOperatorExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  if (complexElementType != nullptr) {
+    if (opcode == OP_add || opcode == OP_sub) {
+      return Emit2FEExprComplexCalculations(stmts);
+    } else if (opcode == OP_eq || opcode == OP_ne) {
+      return Emit2FEExprComplexCompare(stmts);
+    } else {
+      CHECK_FATAL(false, "NIY");
+    }
+  } else {
+    if (opcode == OP_cior || opcode == OP_cand) {
+      if (FEOptions::GetInstance().IsSimplifyShortCircuit()) {
+        return Emit2FEExprLogicOperateSimplify(stmts);
+      } else {
+        return Emit2FEExprLogicOperate(stmts);
+      }
+    }
+    auto leftFEExpr = leftExpr->Emit2FEExpr(stmts);
+    auto rightFEExpr = rightExpr->Emit2FEExpr(stmts);
+    if (FEOptions::GetInstance().IsO2()) {
+      Ror ror(opcode, leftFEExpr, rightFEExpr);
+      auto rorExpr = ror.Emit2FEExpr();
+      if (rorExpr != nullptr) {
+        return rorExpr;
+      }
+    }
+    UniqueFEIRType feirType = SelectBinaryOperatorType(leftFEExpr, rightFEExpr);
+    return FEIRBuilder::CreateExprBinary(std::move(feirType), opcode, std::move(leftFEExpr), std::move(rightFEExpr));
+  }
+}
+
+void ASTAssignExpr::GetActualRightExpr(UniqueFEIRExpr &right, const UniqueFEIRExpr &left) const {
+  if (right->GetPrimType() != left->GetPrimType() &&
+      right->GetPrimType() != PTY_void &&
+      right->GetPrimType() != PTY_agg) {
+    PrimType dstType = left->GetPrimType();
+    if (right->GetPrimType() == PTY_f32 || right->GetPrimType() == PTY_f64) {
+      if (left->GetPrimType() == PTY_u8 || left->GetPrimType() == PTY_u16) {
+        dstType = PTY_u32;
+      }
+      if (left->GetPrimType() == PTY_i8 || left->GetPrimType() == PTY_i16) {
+        dstType = PTY_i32;
+      }
+    }
+    right = FEIRBuilder::CreateExprCastPrim(std::move(right), dstType);
+  }
+}
+
+UniqueFEIRExpr ASTAssignExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRExpr rightFEExpr = rightExpr->Emit2FEExpr(stmts); // parse the right expr to generate stmt first
+  UniqueFEIRExpr leftFEExpr;
+  if (isCompoundAssign) {
+    std::list<UniqueFEIRStmt> dummyStmts;
+    leftFEExpr = leftExpr->Emit2FEExpr(dummyStmts);
+  } else {
+    leftFEExpr = leftExpr->Emit2FEExpr(stmts);
+  }
+  // C89 does not support lvalue casting, but cxx support, needs to improve here
+  if (leftFEExpr->GetKind() == FEIRNodeKind::kExprDRead && !leftFEExpr->GetType()->IsArray()) {
+    auto dreadFEExpr = static_cast<FEIRExprDRead*>(leftFEExpr.get());
+    FieldID fieldID = dreadFEExpr->GetFieldID();
+    UniqueFEIRVar var = dreadFEExpr->GetVar()->Clone();
+    if (ConditionalOptimize::DeleteRedundantTmpVar(rightFEExpr, stmts, var, leftFEExpr->GetPrimType(), fieldID)) {
+      return leftFEExpr;
+    }
+    GetActualRightExpr(rightFEExpr, leftFEExpr);
+    auto preStmt = std::make_unique<FEIRStmtDAssign>(std::move(var), rightFEExpr->Clone(), fieldID);
+    stmts.emplace_back(std::move(preStmt));
+    return leftFEExpr;
+  } else if (leftFEExpr->GetKind() == FEIRNodeKind::kExprIRead) {
+    auto ireadFEExpr = static_cast<FEIRExprIRead*>(leftFEExpr.get());
+    FieldID fieldID = ireadFEExpr->GetFieldID();
+    GetActualRightExpr(rightFEExpr, leftFEExpr);
+    auto preStmt = std::make_unique<FEIRStmtIAssign>(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(),
+                                                     rightFEExpr->Clone(), fieldID);
+    stmts.emplace_back(std::move(preStmt));
+    return leftFEExpr;
+  }
+  return nullptr;
+}
+
+bool ASTAssignExpr::IsInsertNonnullChecking(const UniqueFEIRExpr &rExpr) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic()) {
+    return false;
+  }
+  // The pointer assignment
+  if (retType == nullptr || !(retType->IsMIRPtrType())) {
+    return false;
+  }
+  // The Rvalue is a pointer type
+  if ((rExpr->GetKind() == kExprDRead && rExpr->GetPrimType() == PTY_ptr) ||
+      (rExpr->GetKind() == kExprIRead && rExpr->GetFieldID() != 0 && rExpr->GetPrimType() == PTY_ptr)) {
+    return true;
+  }
+  // The Rvalue is NULL
+  if (ENCChecker::HasNullExpr(rExpr)) {
+    return true;
+  }
+  return false;
+}
+
+UniqueFEIRExpr ASTBOComma::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)leftExpr->Emit2FEExpr(stmts);
+  return rightExpr->Emit2FEExpr(stmts);
+}
+
+UniqueFEIRExpr ASTBOPtrMemExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  CHECK_FATAL(false, "NYI");
+  return nullptr;
+}
+
+// ---------- ASTParenExpr ----------
+UniqueFEIRExpr ASTParenExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  ASTExpr *childExpr = child;
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  childExpr->SetShortCircuitIdx(trueIdx, falseIdx);
+  return childExpr->Emit2FEExpr(stmts);
+}
+
+// ---------- ASTIntegerLiteral ----------
+MIRConst *ASTIntegerLiteral::GenerateMIRConstImpl() const {
+  return GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<uint64>(val),
+                                                              *GlobalTables::GetTypeTable().GetPrimType(PTY_i64));
+}
+
+UniqueFEIRExpr ASTIntegerLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  UniqueFEIRExpr constExpr = std::make_unique<FEIRExprConst>(val, mirType->GetPrimType());
+  return constExpr;
+}
+
+// ---------- ASTFloatingLiteral ----------
+MIRConst *ASTFloatingLiteral::GenerateMIRConstImpl() const {
+  MemPool *mp = FEManager::GetModule().GetMemPool();
+  MIRConst *cst;
+  MIRType *type;
+  if (kind == FloatKind::F32) {
+    type = GlobalTables::GetTypeTable().GetPrimType(PTY_f32);
+    cst = mp->New<MIRFloatConst>(static_cast<float>(val), *type);
+  } else {
+    type = GlobalTables::GetTypeTable().GetPrimType(PTY_f64);
+    cst = mp->New<MIRDoubleConst>(val, *type);
+  }
+  return cst;
+}
+
+UniqueFEIRExpr ASTFloatingLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  UniqueFEIRExpr expr;
+  if (kind == FloatKind::F32) {
+    expr = FEIRBuilder::CreateExprConstF32(static_cast<float>(val));
+  } else {
+    expr = FEIRBuilder::CreateExprConstF64(val);
+  }
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+// ---------- ASTCharacterLiteral ----------
+UniqueFEIRExpr ASTCharacterLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  UniqueFEIRExpr constExpr = FEIRBuilder::CreateExprConstAnyScalar(type, val);
+  return constExpr;
+}
+
+// ---------- ASTConditionalOperator ----------
+UniqueFEIRExpr ASTConditionalOperator::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRExpr condFEIRExpr = condExpr->Emit2FEExpr(stmts);
+  // a noncomparative conditional expr need to be converted a comparative conditional expr
+  if (!(condFEIRExpr->GetKind() == kExprBinary && static_cast<FEIRExprBinary*>(condFEIRExpr.get())->IsComparative())) {
+    condFEIRExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(condFEIRExpr));
+  }
+  std::list<UniqueFEIRStmt> trueStmts;
+  UniqueFEIRExpr trueFEIRExpr = trueExpr->Emit2FEExpr(trueStmts);
+  std::list<UniqueFEIRStmt> falseStmts;
+  UniqueFEIRExpr falseFEIRExpr = falseExpr->Emit2FEExpr(falseStmts);
+  // when subExpr is void
+  if (trueFEIRExpr == nullptr || falseFEIRExpr == nullptr || mirType->GetPrimType() == PTY_void) {
+    UniqueFEIRStmt stmtIf = FEIRBuilder::CreateStmtIf(std::move(condFEIRExpr), trueStmts, falseStmts);
+    stmts.emplace_back(std::move(stmtIf));
+    return nullptr;
+  }
+  // Otherwise, (e.g., a < 1 ? 1 : a++) create a temporary var to hold the return trueExpr or falseExpr value
+  MIRType *retType = mirType;
+  if (retType->GetKind() == kTypeBitField) {
+    retType = GlobalTables::GetTypeTable().GetPrimType(retType->GetPrimType());
+  }
+  trueFEIRExpr->SetIsEnhancedChecking(false);
+  falseFEIRExpr->SetIsEnhancedChecking(false);
+  UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(varName, *retType);
+  UniqueFEIRVar tempVarCloned1 = tempVar->Clone();
+  UniqueFEIRVar tempVarCloned2 = tempVar->Clone();
+  UniqueFEIRStmt retTrueStmt = FEIRBuilder::CreateStmtDAssign(std::move(tempVar), std::move(trueFEIRExpr));
+  retTrueStmt->SetSrcLoc(trueExpr->GetSrcLoc());
+  trueStmts.emplace_back(std::move(retTrueStmt));
+  UniqueFEIRStmt retFalseStmt = FEIRBuilder::CreateStmtDAssign(std::move(tempVarCloned1), std::move(falseFEIRExpr));
+  retFalseStmt->SetSrcLoc(falseExpr->GetSrcLoc());
+  falseStmts.emplace_back(std::move(retFalseStmt));
+  UniqueFEIRStmt stmtIf = FEIRBuilder::CreateStmtIf(std::move(condFEIRExpr), trueStmts, falseStmts);
+  stmts.emplace_back(std::move(stmtIf));
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(tempVarCloned2));
+  expr->SetIsEnhancedChecking(false);
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || !FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    expr->SetKind(kExprTernary);
+  }
+  return expr;
+}
+
+// ---------- ASTConstantExpr ----------
+UniqueFEIRExpr ASTConstantExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  return child->Emit2FEExpr(stmts);
+}
+
+MIRConst *ASTConstantExpr::GenerateMIRConstImpl() const {
+  if (child->GetConstantValue() == nullptr || child->GetConstantValue()->GetPrimType() == PTY_begin) {
+    return child->GenerateMIRConst();
+  } else {
+    return child->GetConstantValue()->Translate2MIRConst();
+  }
+}
+
+// ---------- ASTImaginaryLiteral ----------
+UniqueFEIRExpr ASTImaginaryLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  CHECK_NULL_FATAL(complexType);
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(FEUtils::GetSequentialName("Complex_"));
+  UniqueFEIRVar complexVar = FEIRBuilder::CreateVarNameForC(nameIdx, *complexType);
+  UniqueFEIRVar clonedComplexVar = complexVar->Clone();
+  UniqueFEIRVar clonedComplexVar2 = complexVar->Clone();
+  // real number
+  UniqueFEIRExpr zeroConstExpr = FEIRBuilder::CreateExprConstAnyScalar(elemType->GetPrimType(), 0);
+  UniqueFEIRStmt realStmt = std::make_unique<FEIRStmtDAssign>(std::move(complexVar), std::move(zeroConstExpr), 1);
+  stmts.emplace_back(std::move(realStmt));
+  // imaginary number
+  CHECK_FATAL(child != nullptr, "childExpr is nullptr");
+  UniqueFEIRExpr childFEIRExpr = child->Emit2FEExpr(stmts);
+  UniqueFEIRStmt imagStmt = std::make_unique<FEIRStmtDAssign>(std::move(clonedComplexVar), std::move(childFEIRExpr), 2);
+  stmts.emplace_back(std::move(imagStmt));
+  // return expr to parent operation
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(clonedComplexVar2));
+  return expr;
+}
+
+// ---------- ASTVAArgExpr ----------
+UniqueFEIRExpr ASTVAArgExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  CHECK_NULL_FATAL(mirType);
+  VaArgInfo info = ProcessValistArgInfo(*mirType);
+  UniqueFEIRExpr readVaList = child->Emit2FEExpr(stmts);
+  // The va_arg_offset temp var is created and assigned from __gr_offs or __vr_offs of va_list
+  MIRType *int32Type = GlobalTables::GetTypeTable().GetInt32();
+  UniqueFEIRType int32FETRType = std::make_unique<FEIRTypeNative>(*int32Type);
+  UniqueFEIRVar offsetVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("va_arg_offs_"), *int32Type);
+  UniqueFEIRExpr dreadVaListOffset = FEIRBuilder::ReadExprField(
+      readVaList->Clone(), info.isGPReg ? 4 : 5, int32FETRType->Clone());
+  UniqueFEIRStmt dassignOffsetVar = FEIRBuilder::CreateStmtDAssign(offsetVar->Clone(), dreadVaListOffset->Clone());
+  stmts.emplace_back(std::move(dassignOffsetVar));
+  UniqueFEIRExpr dreadOffsetVar = FEIRBuilder::CreateExprDRead(offsetVar->Clone());
+  // The va_arg temp var is created and assigned in tow following way:
+  // If the va_arg_offs is vaild, i.e., its value should be (0 - (8 - named_arg) * 8)  ~  0,
+  // the va_arg will be got from GP or FP/SIMD arg reg, otherwise va_arg will be got from stack.
+  // See https://developer.arm.com/documentation/ihi0055/latest/?lang=en#the-va-arg-macro for more info
+  const std::string onStackStr = FEUtils::GetSequentialName("va_on_stack_");
+  UniqueFEIRExpr cond1 = FEIRBuilder::CreateExprBinary(  // checking validity: regOffs >= 0, goto on_stack
+      OP_ge, dreadOffsetVar->Clone(), FEIRBuilder::CreateExprConstI32(0));
+  UniqueFEIRStmt condGoTo1 = std::make_unique<FEIRStmtCondGotoForC>(cond1->Clone(), OP_brtrue, onStackStr);
+  stmts.emplace_back(std::move(condGoTo1));
+  // The va_arg set next reg setoff
+  UniqueFEIRExpr argAUnitOffs = FEIRBuilder::CreateExprBinary(
+      OP_add, dreadOffsetVar->Clone(), FEIRBuilder::CreateExprConstI32(info.regOffset));
+  UniqueFEIRStmt assignArgNextOffs = FEIRBuilder::AssginStmtField(
+      readVaList->Clone(), std::move(argAUnitOffs), info.isGPReg ? 4 : 5);
+  stmts.emplace_back(std::move(assignArgNextOffs));
+  UniqueFEIRExpr cond2 = FEIRBuilder::CreateExprBinary(  // checking validity: regOffs + next offset > 0, goto on_stack
+      OP_gt, dreadVaListOffset->Clone(), FEIRBuilder::CreateExprConstI32(0));
+  UniqueFEIRStmt condGoTo2 = std::make_unique<FEIRStmtCondGotoForC>(cond2->Clone(), OP_brtrue, onStackStr);
+  stmts.emplace_back(std::move(condGoTo2));
+  // The va_arg will be got from GP or FP/SIMD arg reg
+  MIRType *sizeType = GlobalTables::GetTypeTable().GetPtrType();
+  UniqueFEIRType sizeFEIRType = std::make_unique<FEIRTypeNative>(*sizeType);
+  MIRType *vaArgType = !info.isCopyedMem ? mirType : GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType);
+  MIRType *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*vaArgType);
+  UniqueFEIRVar vaArgVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("va_arg_"), *ptrType);
+  UniqueFEIRExpr dreadVaArgTop = FEIRBuilder::ReadExprField(
+      readVaList->Clone(), info.isGPReg ? 2 : 3, sizeFEIRType->Clone());
+  ProcessBigEndianForReg(stmts, *vaArgType, offsetVar, info); // process big endian for reg
+  UniqueFEIRExpr cvtOffset = FEIRBuilder::CreateExprCastPrim(dreadOffsetVar->Clone(), PTY_i64);
+  UniqueFEIRExpr addTopAndOffs = FEIRBuilder::CreateExprBinary(OP_add, std::move(dreadVaArgTop), std::move(cvtOffset));
+  UniqueFEIRStmt dassignVaArgFromReg = FEIRBuilder::CreateStmtDAssign(vaArgVar->Clone(), std::move(addTopAndOffs));
+  stmts.emplace_back(std::move(dassignVaArgFromReg));
+  if (info.HFAType != nullptr && !info.isCopyedMem) {
+    CvtHFA2Struct(*static_cast<MIRStructType*>(mirType), *info.HFAType, vaArgVar->Clone(), stmts);
+  }
+  const std::string endStr = FEUtils::GetSequentialName("va_end_");
+  UniqueFEIRStmt goToEnd = FEIRBuilder::CreateStmtGoto(endStr);
+  stmts.emplace_back(std::move(goToEnd));
+  // Otherwise, the va_arg will be got from stack and set next stack setoff
+  UniqueFEIRStmt onStackLabelStmt = std::make_unique<FEIRStmtLabel>(onStackStr);
+  stmts.emplace_back(std::move(onStackLabelStmt));
+  UniqueFEIRExpr dreadStackTop = FEIRBuilder::ReadExprField(readVaList->Clone(), 1, sizeFEIRType->Clone());
+  UniqueFEIRStmt dassignVaArgFromStack = FEIRBuilder::CreateStmtDAssign(vaArgVar->Clone(), dreadStackTop->Clone());
+  UniqueFEIRExpr stackAUnitOffs = FEIRBuilder::CreateExprBinary(
+      OP_add, dreadStackTop->Clone(), FEIRBuilder::CreateExprConstPtr(info.stackOffset));
+  stmts.emplace_back(std::move(dassignVaArgFromStack));
+  UniqueFEIRStmt dassignStackNextOffs = FEIRBuilder::AssginStmtField(
+      readVaList->Clone(), std::move(stackAUnitOffs), 1);
+  stmts.emplace_back(std::move(dassignStackNextOffs));
+  ProcessBigEndianForStack(stmts, *vaArgType, vaArgVar);  // process big endian for stack
+  // return va_arg
+  UniqueFEIRStmt endLabelStmt = std::make_unique<FEIRStmtLabel>(endStr);
+  stmts.emplace_back(std::move(endLabelStmt));
+  UniqueFEIRExpr dreadRetVar = FEIRBuilder::CreateExprDRead(vaArgVar->Clone());
+  UniqueFEIRType ptrFEIRType = std::make_unique<FEIRTypeNative>(*ptrType);
+  if (info.isCopyedMem) {
+    MIRType *tmpType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType);
+    UniqueFEIRType tmpFETRType = std::make_unique<FEIRTypeNative>(*tmpType);
+    dreadRetVar = FEIRBuilder::CreateExprIRead(tmpFETRType->Clone(), ptrFEIRType->Clone(), std::move(dreadRetVar));
+    ptrFEIRType = std::move(tmpFETRType);
+  }
+  UniqueFEIRType baseFEIRType = std::make_unique<FEIRTypeNative>(*mirType);
+  UniqueFEIRExpr retExpr = FEIRBuilder::CreateExprIRead(
+      std::move(baseFEIRType), std::move(ptrFEIRType), std::move(dreadRetVar));
+  return retExpr;
+}
+
+void ASTVAArgExpr::ProcessBigEndianForReg(std::list<UniqueFEIRStmt> &stmts, MIRType &vaArgType,
+                                          const UniqueFEIRVar &offsetVar, const VaArgInfo &info) const {
+  if (!FEOptions::GetInstance().IsBigEndian()) {
+    return;
+  }
+  int offset = 0;
+  if (info.isGPReg && !vaArgType.IsStructType() && vaArgType.GetSize() < 8) {  // general reg
+    offset = 8 - static_cast<int>(vaArgType.GetSize());
+  } else if (info.HFAType != nullptr) {  // HFA
+    offset = 16 - static_cast<int>(info.HFAType->GetSize());
+  } else if (!info.isGPReg && !vaArgType.IsStructType() && vaArgType.GetSize() < 16) {  // fp/simd reg
+    offset = 16 - static_cast<int>(vaArgType.GetSize());
+  }
+  if (offset == 0) {
+    return;
+  }
+  UniqueFEIRExpr addExpr = FEIRBuilder::CreateExprBinary(
+      OP_add, FEIRBuilder::CreateExprDRead(offsetVar->Clone()), FEIRBuilder::CreateExprConstI32(offset));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(offsetVar->Clone(), std::move(addExpr));
+  stmts.emplace_back(std::move(stmt));
+}
+
+void ASTVAArgExpr::ProcessBigEndianForStack(std::list<UniqueFEIRStmt> &stmts, MIRType &vaArgType,
+                                            const UniqueFEIRVar &vaArgVar) const {
+  if (!FEOptions::GetInstance().IsBigEndian()) {
+    return;
+  }
+  int offset = 0;
+  if (!vaArgType.IsStructType() && vaArgType.GetSize() < 8) {
+    offset = 8 - static_cast<int>(vaArgType.GetSize());
+  }
+  if (offset == 0) {
+    return;
+  }
+  UniqueFEIRExpr addExpr = FEIRBuilder::CreateExprBinary(
+      OP_add, FEIRBuilder::CreateExprDRead(vaArgVar->Clone()), FEIRBuilder::CreateExprConstU64(offset));
+  UniqueFEIRExpr dreadRetVar = FEIRBuilder::CreateExprDRead(vaArgVar->Clone());
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(vaArgVar->Clone(), std::move(addExpr));
+  stmts.emplace_back(std::move(stmt));
+}
+
+VaArgInfo ASTVAArgExpr::ProcessValistArgInfo(const MIRType &type) const {
+  VaArgInfo info;
+  if (type.IsScalarType()) {
+    switch (type.GetPrimType()) {
+      case PTY_f32:  // float is automatically promoted to double when passed to va_arg
+        WARN(kLncWarn, "error: float is promoted to double when passed to va_arg");
+      case PTY_f64:  // double
+        info = { false, 16, 8, false, nullptr };
+        break;
+      case PTY_i32:
+      case PTY_u32:
+      case PTY_i64:
+      case PTY_u64:
+        info = { true, 8, 8, false, nullptr };
+        break;
+      default:  // bool, char, short, and unscoped enumerations are converted to int or wider integer types
+        WARN(kLncWarn, "error: bool, char, short, and unscoped enumerations are promoted to int or "\
+                       "wider integer types when passed to va_arg");
+        info = { true, 8, 8, false, nullptr };
+        break;
+    }
+  } else if (type.IsMIRPtrType()) {
+    info = { true, 8, 8, false, nullptr };
+  } else if (type.IsStructType()) {
+    MIRStructType structType = static_cast<const MIRStructType&>(type);
+    size_t size = structType.GetSize();
+    size = (size + 7) & -8;  // size round up 8
+    if (size > 16) {
+      info = { true, 8, 8, true, nullptr };
+    } else {
+      MIRType *hfa = IsHFAType(structType);
+      if (hfa != nullptr) {
+        int fieldsNum = static_cast<int>(structType.GetSize() / hfa->GetSize());
+        info = { false, fieldsNum * 16, static_cast<int>(size), false, hfa };
+      } else {
+        info = { true, static_cast<int>(size), static_cast<int>(size), false, nullptr };
+      }
+    }
+  } else {
+    CHECK_FATAL(false, "unsupport mirtype");
+  }
+  return info;
+}
+
+// Homogeneous Floating-point Aggregate:
+// A data type with 2 to 4 identical floating-point members, either floats or doubles.
+// (including 1 members here, struct nested array)
+MIRType *ASTVAArgExpr::IsHFAType(const MIRStructType &type) const {
+  uint32 size = static_cast<uint32>(type.GetFieldsSize());
+  if (size < 1 || size > 4) {
+    return nullptr;
+  }
+  MIRType *firstType = nullptr;
+  for (uint32 i = 0; i < size; ++i) {
+    MIRType *fieldType = type.GetElemType(i);
+    if (fieldType->GetKind() == kTypeArray) {
+      MIRArrayType *arrayType = static_cast<MIRArrayType*>(fieldType);
+      MIRType *elemType = arrayType->GetElemType();
+      if (elemType->GetPrimType() != PTY_f32 && elemType->GetPrimType() != PTY_f64) {
+        return nullptr;
+      }
+      fieldType = elemType;
+    } else if (fieldType->GetPrimType() != PTY_f32 && fieldType->GetPrimType() != PTY_f64) {
+      return nullptr;
+    }
+    if (firstType == nullptr) {
+      firstType = fieldType;
+    } else if (fieldType != firstType) {
+      return nullptr;
+    }
+  }
+  return firstType;
+}
+
+// When va_arg is HFA struct,
+// if it is passed as parameter in register then each uniquely addressable field goes in its own register.
+// So its fields in FP/SIMD arg reg are still 128 bit and should be converted float or double type fields.
+void ASTVAArgExpr::CvtHFA2Struct(const MIRStructType &type, MIRType &fieldType, const UniqueFEIRVar &vaArgVar,
+                                 std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRVar copyedVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("va_arg_struct_"), *mirType);
+  MIRType *ptrMirType = GlobalTables::GetTypeTable().GetOrCreatePointerType(fieldType);
+  UniqueFEIRType baseType = std::make_unique<FEIRTypeNative>(fieldType);
+  UniqueFEIRType ptrType = std::make_unique<FEIRTypeNative>(*ptrMirType);
+  size_t size = type.GetSize() / fieldType.GetSize();  // fieldType must be nonzero
+  for (size_t i = 0; i < size; ++i) {
+    UniqueFEIRExpr dreadVaArg = FEIRBuilder::CreateExprDRead(vaArgVar->Clone());
+    if (i != 0) {
+      dreadVaArg = FEIRBuilder::CreateExprBinary(
+          OP_add, std::move(dreadVaArg), FEIRBuilder::CreateExprConstPtr(static_cast<int64>(16 * i)));
+    }
+    UniqueFEIRExpr ireadVaArg = FEIRBuilder::CreateExprIRead(baseType->Clone(), ptrType->Clone(), dreadVaArg->Clone());
+    UniqueFEIRExpr addrofVar = FEIRBuilder::CreateExprAddrofVar(copyedVar->Clone());
+    if (i != 0) {
+      addrofVar = FEIRBuilder::CreateExprBinary(
+          OP_add, std::move(addrofVar), FEIRBuilder::CreateExprConstPtr(static_cast<int64>(fieldType.GetSize() * i)));
+    }
+    MIRType *fieldPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(fieldType);
+    UniqueFEIRType fieldFEIRType = std::make_unique<FEIRTypeNative>(*fieldPtrType);
+    UniqueFEIRStmt iassignCopyedVar = FEIRBuilder::CreateStmtIAssign(
+        std::move(fieldFEIRType), std::move(addrofVar), std::move(ireadVaArg));
+    stmts.emplace_back(std::move(iassignCopyedVar));
+  }
+  UniqueFEIRExpr addrofCopyedVar = FEIRBuilder::CreateExprAddrofVar(copyedVar->Clone());
+  UniqueFEIRStmt assignVar = FEIRBuilder::CreateStmtDAssign(vaArgVar->Clone(), std::move(addrofCopyedVar));
+  stmts.emplace_back(std::move(assignVar));
+}
+
+// ---------- ASTArrayInitLoopExpr ----------
+UniqueFEIRExpr ASTArrayInitLoopExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+// ---------- ASTArrayInitIndexExpr ----------
+UniqueFEIRExpr ASTArrayInitIndexExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+// ---------- ASTExprWithCleanups ----------
+UniqueFEIRExpr ASTExprWithCleanups::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+// ---------- ASTMaterializeTemporaryExpr ----------
+UniqueFEIRExpr ASTMaterializeTemporaryExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+// ---------- ASTSubstNonTypeTemplateParmExpr ----------
+UniqueFEIRExpr ASTSubstNonTypeTemplateParmExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+// ---------- ASTDependentScopeDeclRefExpr ----------
+UniqueFEIRExpr ASTDependentScopeDeclRefExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+// ---------- ASTAtomicExpr ----------
+UniqueFEIRExpr ASTAtomicExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  auto atomicExpr = std::make_unique<FEIRExprAtomic>(mirType, refType, objExpr->Emit2FEExpr(stmts), atomicOp);
+  if (atomicOp != kAtomicOpLoadN) {
+    static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal1Expr(valExpr1->Emit2FEExpr(stmts));
+    static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal1Type(val1Type);
+  }
+  if (atomicOp == kAtomicOpExchange) {
+    static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal2Expr(valExpr2->Emit2FEExpr(stmts));
+    static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal2Type(val2Type);
+  }
+  static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetOrderExpr(orderExpr->Emit2FEExpr(stmts));
+  auto var = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("ret.var."), *refType, false, false);
+  atomicExpr->SetValVar(var->Clone());
+  if (!isFromStmt) {
+    auto stmt = std::make_unique<FEIRStmtAtomic>(std::move(atomicExpr));
+    stmts.emplace_back(std::move(stmt));
+    return FEIRBuilder::CreateExprDRead(var->Clone());
+  }
+  return atomicExpr;
+}
+
+// ---------- ASTExprStmtExpr ----------
+UniqueFEIRExpr ASTExprStmtExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  CHECK_FATAL(cpdStmt->GetASTStmtOp() == kASTStmtCompound, "Invalid in ASTExprStmtExpr");
+  const auto *lastCpdStmt = static_cast<ASTCompoundStmt *>(cpdStmt);
+  while (lastCpdStmt->GetASTStmtList().back()->GetASTStmtOp() == kASTStmtStmtExpr) {
+    auto bodyStmt = static_cast<ASTStmtExprStmt*>(lastCpdStmt->GetASTStmtList().back())->GetBodyStmt();
+    lastCpdStmt = static_cast<const ASTCompoundStmt*>(bodyStmt);
+  }
+  UniqueFEIRExpr feirExpr = nullptr;
+  std::list<UniqueFEIRStmt> stmts0;
+  if (lastCpdStmt->GetASTStmtList().size() != 0 && lastCpdStmt->GetASTStmtList().back()->GetExprs().size() != 0) {
+    feirExpr = lastCpdStmt->GetASTStmtList().back()->GetExprs().back()->Emit2FEExpr(stmts0);
+    lastCpdStmt->GetASTStmtList().back()->GetExprs().back()->SetRValue(true);
+  }
+  stmts0 = cpdStmt->Emit2FEStmt();
+  for (auto &stmt : stmts0) {
+    stmts.emplace_back(std::move(stmt));
+  }
+  return feirExpr;
+}
+}
diff --git a/src/hir2mpl/ast_input/clang/src/ast_function.cpp b/src/hir2mpl/ast_input/clang/src/ast_function.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..08baa5a6599e56da0ef657a361ed2a60406cbf76
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/src/ast_function.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_function.h"
+#include "fe_macros.h"
+#include "fe_manager.h"
+
+namespace maple {
+ASTFunction::ASTFunction(const ASTFunc2FEHelper &argMethodHelper, MIRFunction &mirFunc,
+                         const std::unique_ptr<FEFunctionPhaseResult> &argPhaseResultTotal)
+    : FEFunction(mirFunc, argPhaseResultTotal),
+      funcHelper(argMethodHelper),
+      astFunc(funcHelper.GetMethod()) {}
+
+bool ASTFunction::GenerateArgVarList(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  argVarList = astFunc.GenArgVarList();
+  // EnhanceC: Initialize and assign args boundary
+  std::list<UniqueFEIRStmt> boundaryStmts = astFunc.InitArgsBoundaryVar(mirFunction);
+  AppendFEIRStmts(boundaryStmts);
+  return phaseResult.Finish();
+}
+
+bool ASTFunction::GenerateAliasVars(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  return phaseResult.Finish(true);
+}
+
+bool ASTFunction::EmitToFEIRStmt(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  std::list<UniqueFEIRStmt> feirStmts = astFunc.EmitASTStmtToFEIR();
+  AppendFEIRStmts(feirStmts);
+  AppendFEIRStmts(vlaCleanupStmts);
+  return phaseResult.Finish(true);
+}
+
+void ASTFunction::PreProcessImpl() {
+  CHECK_FATAL(false, "NIY");
+}
+
+void ASTFunction::SetMIRFunctionInfo() {
+  GStrIdx idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(astFunc.GetName());
+  mirFunction.PushbackMIRInfo(MIRInfoPair(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_fullname"), idx));
+  mirFunction.PushbackIsString(true);
+}
+
+void ASTFunction::AddVLACleanupStmts(std::list<UniqueFEIRStmt> &stmts) {
+  vlaCleanupStmts.splice(vlaCleanupStmts.end(), stmts);
+}
+
+bool ASTFunction::ProcessImpl() {
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "ASTFunction::Process() for %s", astFunc.GetName().c_str());
+  bool success = true;
+  mirFunction.NewBody();
+  FEManager::GetMIRBuilder().SetCurrentFunction(mirFunction);
+  FEManager::SetCurrentFEFunction(*this);
+  SetMIRFunctionInfo();
+  success = success && GenerateArgVarList("gen arg var list");
+  success = success && EmitToFEIRStmt("emit to feir");
+  return success;
+}
+
+bool ASTFunction::ProcessFEIRFunction() {
+  CHECK_FATAL(false, "NIY");
+  return false;
+}
+
+void ASTFunction::FinishImpl() {
+  if (FEOptions::GetInstance().IsDumpFEIRBB()) {
+    (void)LowerFunc("low feir func");
+    (void)DumpFEIRBBs("dump bb list");
+  }
+  if (FEOptions::GetInstance().IsDumpFEIRCFGGraph(GetGeneralFuncName())) {
+    (void)LowerFunc("low feir func");
+    (void)DumpFEIRCFGGraph("dump cfg graph");
+  }
+  (void)EmitToMIR("finish/emit to mir");
+  (void)GenerateAliasVars("finish/generate alias vars");
+}
+
+bool ASTFunction::EmitToMIR(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  EmitToMIRStmt();
+  return phaseResult.Finish();
+}
+} // namespace maple
diff --git a/src/hir2mpl/ast_input/clang/src/ast_parser.cpp b/src/hir2mpl/ast_input/clang/src/ast_parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a12ad01de7c9d63c9d25d715603d1eaec402965f
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/src/ast_parser.cpp
@@ -0,0 +1,3062 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_parser.h"
+#include "driver_options.h"
+#include "mpl_logging.h"
+#include "mir_module.h"
+#include "mpl_logging.h"
+#include "ast_decl_builder.h"
+#include "ast_interface.h"
+#include "ast_decl.h"
+#include "ast_macros.h"
+#include "ast_util.h"
+#include "ast_input.h"
+#include "fe_manager.h"
+#include "enhance_c_checker.h"
+#include "fe_macros.h"
+
+namespace maple {
+std::map<int64, ASTDecl*> ASTDeclsBuilder::declesTable;
+
+bool ASTParser::OpenFile(MapleAllocator &allocator) {
+  astFile = allocator.GetMemPool()->New<LibAstFile>(allocator, recordDecles, globalEnumDecles);
+  bool res = astFile->Open(fileName, 0, 0);
+  if (!res) {
+    return false;
+  }
+  astUnitDecl = astFile->GetAstUnitDecl();
+  return true;
+}
+
+bool ASTParser::Release() const {
+  astFile->DisposeTranslationUnit();
+  ASTDeclsBuilder::Clear();
+  return true;
+}
+
+bool ASTParser::Verify() const {
+  return true;
+}
+
+ASTBinaryOperatorExpr *ASTParser::AllocBinaryOperatorExpr(MapleAllocator &allocator,
+                                                          const clang::BinaryOperator &bo) const {
+  if (bo.isAssignmentOp() && !bo.isCompoundAssignmentOp()) {
+    return ASTDeclsBuilder::ASTExprBuilder<ASTAssignExpr>(allocator);
+  }
+  if (bo.getOpcode() == clang::BO_Comma) {
+    return ASTDeclsBuilder::ASTExprBuilder<ASTBOComma>(allocator);
+  }
+  // [C++ 5.5] Pointer-to-member operators.
+  if (bo.isPtrMemOp()) {
+    return ASTDeclsBuilder::ASTExprBuilder<ASTBOPtrMemExpr>(allocator);
+  }
+  MIRType *lhTy = astFile->CvtType(bo.getLHS()->getType());
+  ASSERT_NOT_NULL(lhTy);
+  auto opcode = bo.getOpcode();
+  if (bo.isCompoundAssignmentOp()) {
+    opcode = clang::BinaryOperator::getOpForCompoundAssignment(bo.getOpcode());
+  }
+  Opcode mirOpcode = ASTUtil::CvtBinaryOpcode(opcode, lhTy->GetPrimType());
+  CHECK_FATAL(mirOpcode != OP_undef, "Opcode not support!");
+  auto *expr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  expr->SetOpcode(mirOpcode);
+  return expr;
+}
+
+ASTStmt *ASTParser::ProcessFunctionBody(MapleAllocator &allocator, const clang::CompoundStmt &compoundStmt) {
+  CHECK_FATAL(false, "NIY");
+  return ProcessStmtCompoundStmt(allocator, compoundStmt);
+}
+
+ASTStmt *ASTParser::ProcessStmtCompoundStmt(MapleAllocator &allocator, const clang::CompoundStmt &cpdStmt) {
+  ASTCompoundStmt *astCompoundStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTCompoundStmt>(allocator);
+  CHECK_FATAL(astCompoundStmt != nullptr, "astCompoundStmt is nullptr");
+  astCompoundStmt->SetEndLoc(astFile->GetLOC(cpdStmt.getEndLoc()));
+  clang::CompoundStmt::const_body_iterator it;
+  ASTStmt *childStmt = nullptr;
+  for (it = cpdStmt.body_begin(); it != cpdStmt.body_end(); ++it) {
+    childStmt = ProcessStmt(allocator, **it);
+    if (childStmt != nullptr) {
+      astCompoundStmt->SetASTStmt(childStmt);
+    } else {
+      continue;
+    }
+  }
+
+  if (FEOptions::GetInstance().IsEnableSafeRegion()) {
+    switch (cpdStmt.getSafeSpecifier()) {
+      case clang::SS_None:
+        astCompoundStmt->SetSafeSS(SafeSS::kNoneSS);
+        break;
+      case clang::SS_Unsafe:
+        astCompoundStmt->SetSafeSS(SafeSS::kUnsafeSS);
+        break;
+      case clang::SS_Safe:
+        astCompoundStmt->SetSafeSS(SafeSS::kSafeSS);
+        break;
+      default: break;
+    }
+  }
+  return astCompoundStmt;
+}
+
+#define STMT_CASE(CLASS)                                                              \
+  case clang::Stmt::CLASS##Class: {                                                   \
+    ASTStmt *astStmt = ProcessStmt##CLASS(allocator, llvm::cast<clang::CLASS>(stmt)); \
+    Loc loc = astFile->GetStmtLOC(stmt);                                              \
+    astStmt->SetSrcLoc(loc);                                                          \
+    return astStmt;                                                                   \
+  }
+
+ASTStmt *ASTParser::ProcessStmt(MapleAllocator &allocator, const clang::Stmt &stmt) {
+  switch (stmt.getStmtClass()) {
+    STMT_CASE(UnaryOperator);
+    STMT_CASE(BinaryOperator);
+    STMT_CASE(CompoundAssignOperator);
+    STMT_CASE(ImplicitCastExpr);
+    STMT_CASE(ParenExpr);
+    STMT_CASE(IntegerLiteral);
+    STMT_CASE(FloatingLiteral);
+    STMT_CASE(VAArgExpr);
+    STMT_CASE(ConditionalOperator);
+    STMT_CASE(CharacterLiteral);
+    STMT_CASE(StmtExpr);
+    STMT_CASE(CallExpr);
+    STMT_CASE(ReturnStmt);
+    STMT_CASE(CompoundStmt);
+    STMT_CASE(IfStmt);
+    STMT_CASE(ForStmt);
+    STMT_CASE(WhileStmt);
+    STMT_CASE(DoStmt);
+    STMT_CASE(BreakStmt);
+    STMT_CASE(LabelStmt);
+    STMT_CASE(ContinueStmt);
+    STMT_CASE(GotoStmt);
+    STMT_CASE(IndirectGotoStmt);
+    STMT_CASE(SwitchStmt);
+    STMT_CASE(CaseStmt);
+    STMT_CASE(DefaultStmt);
+    STMT_CASE(CStyleCastExpr);
+    STMT_CASE(DeclStmt);
+    STMT_CASE(NullStmt);
+    STMT_CASE(AtomicExpr);
+    STMT_CASE(GCCAsmStmt);
+    STMT_CASE(OffsetOfExpr);
+    STMT_CASE(GenericSelectionExpr);
+    STMT_CASE(AttributedStmt);
+    STMT_CASE(DeclRefExpr);
+    STMT_CASE(UnaryExprOrTypeTraitExpr);
+    STMT_CASE(AddrLabelExpr);
+    default: {
+      CHECK_FATAL(false, "ASTStmt: %s NIY", stmt.getStmtClassName());
+      return nullptr;
+    }
+  }
+}
+
+ASTStmt *ASTParser::ProcessStmtAttributedStmt(MapleAllocator &allocator, const clang::AttributedStmt &attrStmt) {
+  ASSERT(clang::hasSpecificAttr<clang::FallThroughAttr>(attrStmt.getAttrs()), "AttrStmt is not fallthrough");
+  ASTAttributedStmt *astAttributedStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTAttributedStmt>(allocator);
+  CHECK_FATAL(astAttributedStmt != nullptr, "astAttributedStmt is nullptr");
+  return astAttributedStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtOffsetOfExpr(MapleAllocator &allocator, const clang::OffsetOfExpr &expr) {
+  auto *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTOffsetOfStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &expr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astStmt->SetASTExpr(astExpr);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtGenericSelectionExpr(MapleAllocator &allocator,
+                                                    const clang::GenericSelectionExpr &expr) {
+  auto *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTOffsetOfStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &expr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astStmt->SetASTExpr(astExpr);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtUnaryOperator(MapleAllocator &allocator, const clang::UnaryOperator &unaryOp) {
+  ASTUnaryOperatorStmt *astUOStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTUnaryOperatorStmt>(allocator);
+  CHECK_FATAL(astUOStmt != nullptr, "astUOStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &unaryOp);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astUOStmt->SetASTExpr(astExpr);
+  return astUOStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtBinaryOperator(MapleAllocator &allocator, const clang::BinaryOperator &binaryOp) {
+  ASTBinaryOperatorStmt *astBOStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTBinaryOperatorStmt>(allocator);
+  CHECK_FATAL(astBOStmt != nullptr, "astBOStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &binaryOp);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astBOStmt->SetASTExpr(astExpr);
+  return astBOStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtCallExpr(MapleAllocator &allocator, const clang::CallExpr &callExpr) {
+  ASTExpr *astExpr = ProcessExpr(allocator, &callExpr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  ASTCallExprStmt *astCallExprStmt =
+      allocator.GetMemPool()->New<ASTCallExprStmt>(allocator, static_cast<ASTCallExpr*>(astExpr)->GetRetVarName());
+  CHECK_FATAL(astCallExprStmt != nullptr, "astCallExprStmt is nullptr");
+  astCallExprStmt->SetASTExpr(astExpr);
+  return astCallExprStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtImplicitCastExpr(MapleAllocator &allocator,
+                                                const clang::ImplicitCastExpr &implicitCastExpr) {
+  ASTImplicitCastExprStmt *astImplicitCastExprStmt =
+      ASTDeclsBuilder::ASTStmtBuilder<ASTImplicitCastExprStmt>(allocator);
+  CHECK_FATAL(astImplicitCastExprStmt != nullptr, "astImplicitCastExprStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &implicitCastExpr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astImplicitCastExprStmt->SetASTExpr(astExpr);
+  return astImplicitCastExprStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtParenExpr(MapleAllocator &allocator, const clang::ParenExpr &parenExpr) {
+  ASTParenExprStmt *astParenExprStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTParenExprStmt>(allocator);
+  CHECK_FATAL(astParenExprStmt != nullptr, "astCallExprStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &parenExpr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astParenExprStmt->SetASTExpr(astExpr);
+  return astParenExprStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtIntegerLiteral(MapleAllocator &allocator, const clang::IntegerLiteral &integerLiteral) {
+  ASTIntegerLiteralStmt *astIntegerLiteralStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTIntegerLiteralStmt>(allocator);
+  CHECK_FATAL(astIntegerLiteralStmt != nullptr, "astIntegerLiteralStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &integerLiteral);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astIntegerLiteralStmt->SetASTExpr(astExpr);
+  return astIntegerLiteralStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtFloatingLiteral(MapleAllocator &allocator,
+                                               const clang::FloatingLiteral &floatingLiteral) {
+  ASTFloatingLiteralStmt *astFloatingLiteralStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTFloatingLiteralStmt>(allocator);
+  CHECK_FATAL(astFloatingLiteralStmt != nullptr, "astFloatingLiteralStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &floatingLiteral);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astFloatingLiteralStmt->SetASTExpr(astExpr);
+  return astFloatingLiteralStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtVAArgExpr(MapleAllocator &allocator, const clang::VAArgExpr &vAArgExpr) {
+  ASTVAArgExprStmt *astVAArgExprStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTVAArgExprStmt>(allocator);
+  CHECK_FATAL(astVAArgExprStmt != nullptr, "astVAArgExprStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &vAArgExpr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astVAArgExprStmt->SetASTExpr(astExpr);
+  return astVAArgExprStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtConditionalOperator(MapleAllocator &allocator,
+                                                   const clang::ConditionalOperator &conditionalOperator) {
+  ASTConditionalOperatorStmt *astConditionalOperatorStmt =
+      ASTDeclsBuilder::ASTStmtBuilder<ASTConditionalOperatorStmt>(allocator);
+  CHECK_FATAL(astConditionalOperatorStmt != nullptr, "astConditionalOperatorStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &conditionalOperator);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astConditionalOperatorStmt->SetASTExpr(astExpr);
+  return astConditionalOperatorStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtCharacterLiteral(MapleAllocator &allocator,
+                                                const clang::CharacterLiteral &characterLiteral) {
+  ASTCharacterLiteralStmt *astCharacterLiteralStmt =
+      ASTDeclsBuilder::ASTStmtBuilder<ASTCharacterLiteralStmt>(allocator);
+  CHECK_FATAL(astCharacterLiteralStmt != nullptr, "astCharacterLiteralStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &characterLiteral);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astCharacterLiteralStmt->SetASTExpr(astExpr);
+  return astCharacterLiteralStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtCStyleCastExpr(MapleAllocator &allocator, const clang::CStyleCastExpr &cStyleCastExpr) {
+  ASTCStyleCastExprStmt *astCStyleCastExprStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTCStyleCastExprStmt>(allocator);
+  CHECK_FATAL(astCStyleCastExprStmt != nullptr, "astCStyleCastExprStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &cStyleCastExpr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astCStyleCastExprStmt->SetASTExpr(astExpr);
+  return astCStyleCastExprStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtStmtExpr(MapleAllocator &allocator, const clang::StmtExpr &stmtExpr) {
+  ASTStmtExprStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTStmtExprStmt>(allocator);
+  const clang::CompoundStmt *cpdStmt = stmtExpr.getSubStmt();
+  ASTStmt *astCompoundStmt = ProcessStmt(allocator, *cpdStmt);
+  astStmt->SetBodyStmt(astCompoundStmt);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtCompoundAssignOperator(MapleAllocator &allocator,
+                                                      const clang::CompoundAssignOperator &cpdAssignOp) {
+  ASTCompoundAssignOperatorStmt *astCAOStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTCompoundAssignOperatorStmt>(allocator);
+  CHECK_FATAL(astCAOStmt != nullptr, "astCAOStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &cpdAssignOp);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astCAOStmt->SetASTExpr(astExpr);
+  return astCAOStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtAtomicExpr(MapleAllocator &allocator, const clang::AtomicExpr &atomicExpr) {
+  ASTAtomicExprStmt *astAtomicExprStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTAtomicExprStmt>(allocator);
+  CHECK_FATAL(astAtomicExprStmt != nullptr, "astAtomicExprStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &atomicExpr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  static_cast<ASTAtomicExpr*>(astExpr)->SetFromStmt(true);
+  astAtomicExprStmt->SetASTExpr(astExpr);
+  return astAtomicExprStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtReturnStmt(MapleAllocator &allocator, const clang::ReturnStmt &retStmt) {
+  ASTReturnStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTReturnStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, retStmt.getRetValue());
+  astStmt->SetASTExpr(astExpr);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtIfStmt(MapleAllocator &allocator, const clang::IfStmt &ifStmt) {
+  auto *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTIfStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, ifStmt.getCond());
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astStmt->SetCondExpr(astExpr);
+  ASTStmt *astThenStmt = nullptr;
+  const clang::Stmt *thenStmt = ifStmt.getThen();
+  if (thenStmt->getStmtClass() == clang::Stmt::CompoundStmtClass) {
+    astThenStmt = ProcessStmt(allocator, *llvm::cast<clang::CompoundStmt>(thenStmt));
+  } else {
+    astThenStmt = ProcessStmt(allocator, *thenStmt);
+  }
+  astStmt->SetThenStmt(astThenStmt);
+  if (ifStmt.hasElseStorage()) {
+    ASTStmt *astElseStmt = nullptr;
+    const clang::Stmt *elseStmt = ifStmt.getElse();
+    if (elseStmt->getStmtClass() == clang::Stmt::CompoundStmtClass) {
+      astElseStmt = ProcessStmt(allocator, *llvm::cast<clang::CompoundStmt>(elseStmt));
+    } else {
+      astElseStmt = ProcessStmt(allocator, *elseStmt);
+    }
+    astStmt->SetElseStmt(astElseStmt);
+  }
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtForStmt(MapleAllocator &allocator, const clang::ForStmt &forStmt) {
+  auto *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTForStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  astStmt->SetEndLoc(astFile->GetLOC(forStmt.getEndLoc()));
+  if (forStmt.getInit() != nullptr) {
+    ASTStmt *initStmt = ProcessStmt(allocator, *forStmt.getInit());
+    if (initStmt == nullptr) {
+      return nullptr;
+    }
+    astStmt->SetInitStmt(initStmt);
+  }
+  if (forStmt.getCond() != nullptr) {
+    ASTExpr *condExpr = ProcessExpr(allocator, forStmt.getCond());
+    if (condExpr == nullptr) {
+      return nullptr;
+    }
+    astStmt->SetCondExpr(condExpr);
+  }
+  if (forStmt.getInc() != nullptr) {
+    ASTExpr *incExpr = ProcessExpr(allocator, forStmt.getInc());
+    if (incExpr == nullptr) {
+      return nullptr;
+    }
+    astStmt->SetIncExpr(incExpr);
+  }
+  ASTStmt *bodyStmt = nullptr;
+  if (forStmt.getBody()->getStmtClass() == clang::Stmt::CompoundStmtClass) {
+    const auto *tmpCpdStmt = llvm::cast<clang::CompoundStmt>(forStmt.getBody());
+    bodyStmt = ProcessStmt(allocator, *tmpCpdStmt);
+  } else {
+    bodyStmt = ProcessStmt(allocator, *forStmt.getBody());
+  }
+  astStmt->SetBodyStmt(bodyStmt);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtWhileStmt(MapleAllocator &allocator, const clang::WhileStmt &whileStmt) {
+  ASTWhileStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTWhileStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASTExpr *condExpr = ProcessExpr(allocator, whileStmt.getCond());
+  if (condExpr == nullptr) {
+    return nullptr;
+  }
+  astStmt->SetCondExpr(condExpr);
+  ASTStmt *bodyStmt = ProcessStmt(allocator, *whileStmt.getBody());
+  astStmt->SetBodyStmt(bodyStmt);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtGotoStmt(MapleAllocator &allocator, const clang::GotoStmt &gotoStmt) {
+  ASTGotoStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTGotoStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASSERT_NOT_NULL(gotoStmt.getLabel());
+  ASTDecl *astDecl = ProcessDecl(allocator, *gotoStmt.getLabel());
+  astStmt->SetLabelName(astDecl->GetName());
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtIndirectGotoStmt(MapleAllocator &allocator, const clang::IndirectGotoStmt &iGotoStmt) {
+  ASTIndirectGotoStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTIndirectGotoStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  astStmt->SetASTExpr(ProcessExpr(allocator, iGotoStmt.getTarget()));
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtGCCAsmStmt(MapleAllocator &allocator, const clang::GCCAsmStmt &asmStmt) {
+  ASTGCCAsmStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTGCCAsmStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  astStmt->SetAsmStr(asmStmt.generateAsmString(*(astFile->GetAstContext())));
+  // set output
+  for (unsigned i = 0; i < asmStmt.getNumOutputs(); ++i) {
+    bool isPlusConstraint = asmStmt.isOutputPlusConstraint(i);
+    astStmt->InsertOutput(std::make_tuple(asmStmt.getOutputName(i).str(),
+                                          asmStmt.getOutputConstraint(i).str(), isPlusConstraint));
+    astStmt->SetASTExpr(ProcessExpr(allocator, asmStmt.getOutputExpr(i)));
+  }
+  // set input
+  for (unsigned i = 0; i < asmStmt.getNumInputs(); ++i) {
+    astStmt->InsertInput(std::make_pair(asmStmt.getInputName(i).str(), asmStmt.getInputConstraint(i).str()));
+    astStmt->SetASTExpr(ProcessExpr(allocator, asmStmt.getInputExpr(i)));
+  }
+  // set clobbers
+  for (unsigned i = 0; i < asmStmt.getNumClobbers(); ++i) {
+    astStmt->InsertClobber(asmStmt.getClobber(i).str());
+  }
+  // set label
+  for (unsigned i = 0; i < asmStmt.getNumLabels(); ++i) {
+    astStmt->InsertLabel(asmStmt.getLabelName(i).str());
+  }
+  // set goto/volatile flag
+  if (asmStmt.isVolatile()) {
+    astStmt->SetIsVolatile(true);
+  }
+  if (asmStmt.isAsmGoto()) {
+    astStmt->SetIsGoto(true);
+  }
+  return astStmt;
+}
+
+bool ASTParser::HasDefault(const clang::Stmt &stmt) {
+  if (llvm::isa<const clang::DefaultStmt>(stmt)) {
+    return true;
+  } else if (llvm::isa<const clang::CompoundStmt>(stmt)) {
+    const auto *cpdStmt = llvm::cast<const clang::CompoundStmt>(&stmt);
+    clang::CompoundStmt::const_body_iterator it;
+    for (it = cpdStmt->body_begin(); it != cpdStmt->body_end(); ++it) {
+      const auto *bodyStmt = llvm::dyn_cast<const clang::Stmt>(*it);
+      if (bodyStmt == nullptr) {
+        continue;
+      }
+      if (HasDefault(*bodyStmt)) {
+        return true;
+      }
+    }
+  } else if (llvm::isa<const clang::CaseStmt>(stmt)) {
+    const auto *caseStmt = llvm::cast<const clang::CaseStmt>(&stmt);
+    if (HasDefault(*caseStmt->getSubStmt())) {
+      return true;
+    }
+  } else if (llvm::isa<const clang::LabelStmt>(stmt)) {
+    const auto *labelStmt = llvm::cast<const clang::LabelStmt>(&stmt);
+    if (HasDefault(*labelStmt->getSubStmt())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+ASTStmt *ASTParser::ProcessStmtSwitchStmt(MapleAllocator &allocator, const clang::SwitchStmt &switchStmt) {
+  // if switch cond expr has var decl, we need to handle it.
+  ASTSwitchStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTSwitchStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASTStmt *condStmt = switchStmt.getConditionVariableDeclStmt() == nullptr ? nullptr :
+      ProcessStmt(allocator, *switchStmt.getConditionVariableDeclStmt());
+  astStmt->SetCondStmt(condStmt);
+  // switch cond expr
+  ASTExpr *condExpr = switchStmt.getCond() == nullptr ? nullptr : ProcessExpr(allocator, switchStmt.getCond());
+  if (condExpr != nullptr) {
+    astStmt->SetCondType(astFile->CvtType(switchStmt.getCond()->getType()));
+  }
+  astStmt->SetCondExpr(condExpr);
+  // switch body stmt
+  ASTStmt *bodyStmt = switchStmt.getBody() == nullptr ? nullptr :
+      ProcessStmt(allocator, *switchStmt.getBody());
+  astStmt->SetBodyStmt(bodyStmt);
+  astStmt->SetHasDefault(HasDefault(*switchStmt.getBody()));
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtDoStmt(MapleAllocator &allocator, const clang::DoStmt &doStmt) {
+  ASTDoStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTDoStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASTExpr *condExpr = ProcessExpr(allocator, doStmt.getCond());
+  if (condExpr == nullptr) {
+    return nullptr;
+  }
+  astStmt->SetCondExpr(condExpr);
+  ASTStmt *bodyStmt = ProcessStmt(allocator, *doStmt.getBody());
+  astStmt->SetBodyStmt(bodyStmt);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtBreakStmt(MapleAllocator &allocator, const clang::BreakStmt &breakStmt) {
+  (void)breakStmt;
+  auto *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTBreakStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtLabelStmt(MapleAllocator &allocator, const clang::LabelStmt &stmt) {
+  auto *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTLabelStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  std::string name;
+  ASTStmt *astSubStmt = ProcessStmt(allocator, *stmt.getSubStmt());
+  if (stmt.getDecl() != nullptr) {
+    ASTDecl *astDecl = ProcessDecl(allocator, *stmt.getDecl());
+    name = astDecl->GetName();
+  } else {
+    name = stmt.getName();
+  }
+  astStmt->SetLabelName(name);
+  astStmt->SetSubStmt(astSubStmt);
+  if (astSubStmt->GetExprs().size() != 0 && astSubStmt->GetExprs().back() != nullptr) {
+    astStmt->SetASTExpr(astSubStmt->GetExprs().back());
+  }
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtAddrLabelExpr(MapleAllocator &allocator, const clang::AddrLabelExpr &expr) {
+  ASTUOAddrOfLabelExprStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTUOAddrOfLabelExprStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &expr);
+  CHECK_FATAL(astExpr != nullptr, "astExpr is nullptr");
+  astStmt->SetASTExpr(astExpr);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtCaseStmt(MapleAllocator &allocator, const clang::CaseStmt &caseStmt) {
+  ASTCaseStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTCaseStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  astStmt->SetLHS(ProcessExpr(allocator, caseStmt.getLHS()));
+  astStmt->SetRHS(ProcessExpr(allocator, caseStmt.getRHS()));
+  clang::Expr::EvalResult resL;
+  (void)caseStmt.getLHS()->EvaluateAsInt(resL, *astFile->GetAstContext());
+  astStmt->SetLCaseTag(resL.Val.getInt().getExtValue());
+  if (caseStmt.getRHS() != nullptr) {
+    clang::Expr::EvalResult resR;
+    (void)caseStmt.getLHS()->EvaluateAsInt(resR, *astFile->GetAstContext());
+    astStmt->SetRCaseTag(resR.Val.getInt().getExtValue());
+  } else {
+    astStmt->SetRCaseTag(resL.Val.getInt().getExtValue());
+  }
+  ASTStmt* subStmt = caseStmt.getSubStmt() == nullptr ? nullptr : ProcessStmt(allocator, *caseStmt.getSubStmt());
+  astStmt->SetSubStmt(subStmt);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtDefaultStmt(MapleAllocator &allocator, const clang::DefaultStmt &defaultStmt) {
+  ASTDefaultStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTDefaultStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  auto *subStmt = defaultStmt.getSubStmt() == nullptr ? nullptr : ProcessStmt(allocator, *defaultStmt.getSubStmt());
+  astStmt->SetChildStmt(subStmt);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtNullStmt(MapleAllocator &allocator, const clang::NullStmt &nullStmt) {
+  (void)nullStmt;
+  ASTNullStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTNullStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtContinueStmt(MapleAllocator &allocator, const clang::ContinueStmt &continueStmt) {
+  (void)continueStmt;
+  auto *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTContinueStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtDeclStmt(MapleAllocator &allocator, const clang::DeclStmt &declStmt) {
+  ASTDeclStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTDeclStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  std::list<const clang::Decl*> decls;
+  if (declStmt.isSingleDecl()) {
+    const clang::Decl *decl = declStmt.getSingleDecl();
+    if (decl != nullptr) {
+      (void)decls.emplace_back(decl);
+    }
+  } else {
+    // multiple decls
+    clang::DeclGroupRef declGroupRef = declStmt.getDeclGroup();
+    clang::DeclGroupRef::const_iterator it;
+    for (it = declGroupRef.begin(); it != declGroupRef.end(); ++it) {
+      (void)decls.emplace_back(*it);
+    }
+  }
+  for (auto decl : std::as_const(decls)) {
+    // save vla size expr
+    std::list<ASTExpr*> astExprs;
+    if (decl->getKind() == clang::Decl::Var) {
+      const clang::VarDecl *varDecl = llvm::cast<clang::VarDecl>(decl);
+      SaveVLASizeExpr(allocator, varDecl->getType(), astExprs);
+    } else if (decl->getKind() == clang::Decl::Typedef) {
+      clang::QualType underType = llvm::cast<clang::TypedefNameDecl>(decl)->getUnderlyingType();
+      SaveVLASizeExpr(allocator, underType, astExprs);
+    }
+    for (auto expr : std::as_const(astExprs)) {
+      astStmt->SetVLASizeExpr(expr);
+    }
+    ASTDecl *ad = ProcessDecl(allocator, *decl);
+    // extern func decl in function
+    if (decl->getKind() == clang::Decl::Function) {
+      const clang::FunctionDecl *funcDecl = llvm::cast<clang::FunctionDecl>(decl);
+      if (!funcDecl->isDefined()) {
+        astFuncs.emplace_back(static_cast<ASTFunc*>(ad));
+      }
+    }
+    if (ad != nullptr) {
+      astStmt->SetSubDecl(ad);
+    }
+  }
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtDeclRefExpr(MapleAllocator &allocator, const clang::DeclRefExpr &expr) {
+  ASTDeclRefExprStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTDeclRefExprStmt>(allocator);
+  ASTExpr *astExpr = ProcessExpr(allocator, &expr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astStmt->SetASTExpr(astExpr);
+  return astStmt;
+}
+
+ASTStmt *ASTParser::ProcessStmtUnaryExprOrTypeTraitExpr(MapleAllocator &allocator,
+                                                        const clang::UnaryExprOrTypeTraitExpr &expr) {
+  auto *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTUnaryExprOrTypeTraitExprStmt>(allocator);
+  ASTExpr *astExpr = ProcessExpr(allocator, &expr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astStmt->SetASTExpr(astExpr);
+  return astStmt;
+}
+
+ASTValue *ASTParser::TranslateConstantValue2ASTValue(MapleAllocator &allocator, const clang::Expr *expr) const {
+  ASSERT_NOT_NULL(expr);
+  ASTValue *astValue = nullptr;
+  clang::Expr::EvalResult result;
+  if (expr->getStmtClass() == clang::Stmt::StringLiteralClass &&
+      expr->EvaluateAsLValue(result, *(astFile->GetContext()))) {
+    return TranslateLValue2ASTValue(allocator, result, expr);
+  }
+  if (expr->EvaluateAsRValue(result, *(astFile->GetContext()))) {
+    if (result.Val.isLValue()) {
+      return TranslateLValue2ASTValue(allocator, result, expr);
+    }
+    auto *constMirType = astFile->CvtType(expr->getType().getCanonicalType());
+    ASSERT_NOT_NULL(constMirType);
+    if (result.Val.isInt()) {
+      astValue = AllocASTValue(allocator);
+      switch (constMirType->GetPrimType()) {
+        case PTY_i8:
+          astValue->val.i8 = static_cast<int8>(result.Val.getInt().getExtValue());
+          astValue->pty = PTY_i8;
+          break;
+        case PTY_i16:
+          astValue->val.i16 = static_cast<int16>(result.Val.getInt().getExtValue());
+          astValue->pty = PTY_i16;
+          break;
+        case PTY_i32:
+          if (expr->getStmtClass() == clang::Stmt::CharacterLiteralClass) {
+            if (FEOptions::GetInstance().IsUseSignedChar()) {
+              astValue->val.i8 = static_cast<int8>(llvm::cast<clang::CharacterLiteral>(expr)->getValue());
+              astValue->pty = PTY_i8;
+            } else {
+              astValue->val.u8 = static_cast<uint8>(llvm::cast<clang::CharacterLiteral>(expr)->getValue());
+              astValue->pty = PTY_u8;
+            }
+          } else {
+            astValue->val.i32 = static_cast<int32>(result.Val.getInt().getExtValue());
+            astValue->pty = PTY_i32;
+          }
+          break;
+        case PTY_i64:
+          if (result.Val.getInt().getBitWidth() > 64) {
+            astValue->val.i64 = static_cast<int64>(result.Val.getInt().getSExtValue());
+          } else {
+            astValue->val.i64 = static_cast<int64>(result.Val.getInt().getExtValue());
+          }
+          astValue->pty = PTY_i64;
+          break;
+        case PTY_i128:
+          astValue->val.i64 = static_cast<int64>(result.Val.getInt().getSExtValue());
+          astValue->pty = PTY_i128;
+          static bool i128Warning = true;
+          if (i128Warning) {
+            WARN(kLncWarn, "%s:%d PTY_i128 is not fully supported",
+                 FEManager::GetModule().GetFileNameFromFileNum(astFile->GetExprLOC(*expr).fileIdx).c_str(),
+                 astFile->GetExprLOC(*expr).line);
+            i128Warning = false;
+          }
+          break;
+        case PTY_u8:
+          astValue->val.u8 = static_cast<uint8>(result.Val.getInt().getExtValue());
+          astValue->pty = PTY_u8;
+          break;
+        case PTY_u16:
+          astValue->val.u16 = static_cast<uint16>(result.Val.getInt().getExtValue());
+          astValue->pty = PTY_u16;
+          break;
+        case PTY_u32:
+          astValue->val.u32 = static_cast<uint32>(result.Val.getInt().getExtValue());
+          astValue->pty = PTY_u32;
+          break;
+        case PTY_u64:
+          if (result.Val.getInt().getBitWidth() > 64) {
+            astValue->val.u64 = static_cast<uint64>(result.Val.getInt().getZExtValue());
+          } else {
+            astValue->val.u64 = static_cast<uint64>(result.Val.getInt().getExtValue());
+          }
+          astValue->pty = PTY_u64;
+          break;
+        case PTY_u128:
+          astValue->val.u64 = static_cast<uint64>(result.Val.getInt().getZExtValue());
+          astValue->pty = PTY_u128;
+          static bool u128Warning = true;
+          if (u128Warning) {
+            WARN(kLncWarn, "%s:%d PTY_u128 is not fully supported",
+                 FEManager::GetModule().GetFileNameFromFileNum(astFile->GetExprLOC(*expr).fileIdx).c_str(),
+                 astFile->GetExprLOC(*expr).line);
+            u128Warning = false;
+          }
+          break;
+        case PTY_u1:
+          astValue->val.u8 = (result.Val.getInt().getExtValue() == 0 ? 0 : 1);
+          astValue->pty = PTY_u1;
+          break;
+        default: {
+          CHECK_FATAL(false, "Invalid");
+          break;
+        }
+      }
+    } else if (result.Val.isFloat()) {
+      astValue = AllocASTValue(allocator);
+      llvm::APFloat fValue = result.Val.getFloat();
+      llvm::APFloat::Semantics semantics = llvm::APFloatBase::SemanticsToEnum(fValue.getSemantics());
+      switch (semantics) {
+        case llvm::APFloat::S_IEEEsingle:
+          astValue->val.f32 = fValue.convertToFloat();
+          break;
+        case llvm::APFloat::S_IEEEdouble:
+          astValue->val.f64 = fValue.convertToDouble();
+          break;
+        case llvm::APFloat::S_IEEEquad:
+        case llvm::APFloat::S_PPCDoubleDouble:
+        case llvm::APFloat::S_x87DoubleExtended: {
+          auto ty = expr->getType().getCanonicalType();
+          static bool f128Warning = true;
+          if (f128Warning && (ty->isFloat128Type() ||
+              (ty->isRealFloatingType() && astFile->GetAstContext()->getTypeSize(ty) == 128))) {
+            WARN(kLncWarn, "%s:%d PTY_f128 is not fully supported",
+                 FEManager::GetModule().GetFileNameFromFileNum(astFile->GetExprLOC(*expr).fileIdx).c_str(),
+                 astFile->GetExprLOC(*expr).line);
+            f128Warning = false;
+          }
+          bool losesInfo;
+          if (constMirType->GetPrimType() == PTY_f64) {
+            (void)fValue.convert(llvm::APFloat::IEEEdouble(),
+                                 llvm::APFloatBase::rmNearestTiesToAway,
+                                 &losesInfo);
+            astValue->val.f64 = fValue.convertToDouble();
+          } else {
+            (void)fValue.convert(llvm::APFloat::IEEEsingle(),
+                                 llvm::APFloatBase::rmNearestTiesToAway,
+                                 &losesInfo);
+            astValue->val.f32 = fValue.convertToFloat();
+          }
+          break;
+        }
+        default:
+          CHECK_FATAL(false, "unsupported semantics");
+      }
+      astValue->pty = constMirType->GetPrimType();
+    } else if (result.Val.isComplexInt() || result.Val.isComplexFloat()) {
+      WARN(kLncWarn, "Unsupported complex value in MIR");
+    } else if (result.Val.isVector()) {
+      // vector type var must be init by initListExpr
+      return nullptr;
+    } else if (result.Val.isMemberPointer()) {
+      CHECK_FATAL(false, "NIY");
+    }
+    // Others: Agg const processed in `InitListExpr`
+  }
+  return astValue;
+}
+
+ASTValue *ASTParser::TranslateLValue2ASTValue(
+    MapleAllocator &allocator, const clang::Expr::EvalResult &result, const clang::Expr *expr) const {
+  ASSERT_NOT_NULL(expr);
+  ASTValue *astValue = nullptr;
+  const clang::APValue::LValueBase &lvBase = result.Val.getLValueBase();
+  if (lvBase.is<const clang::Expr*>()) {
+    const clang::Expr *lvExpr = lvBase.get<const clang::Expr*>();
+    if (lvExpr == nullptr) {
+      return astValue;
+    }
+    if (expr->getStmtClass() == clang::Stmt::MemberExprClass) {
+      // meaningless, just for Initialization
+      astValue = AllocASTValue(allocator);
+      astValue->pty = PTY_i32;
+      astValue->val.i64 = 0;
+      return astValue;
+    }
+    switch (lvExpr->getStmtClass()) {
+      case clang::Stmt::StringLiteralClass: {
+        const clang::StringLiteral &strExpr = llvm::cast<const clang::StringLiteral>(*lvExpr);
+        std::string str = "";
+        if (strExpr.isWide() || strExpr.isUTF16() || strExpr.isUTF32()) {
+          static bool wcharWarning = true;
+          if (wcharWarning && strExpr.isWide()) {
+            WARN(kLncWarn, "%s:%d wchar is not fully supported",
+                 FEManager::GetModule().GetFileNameFromFileNum(astFile->GetExprLOC(*lvExpr).fileIdx).c_str(),
+                 astFile->GetExprLOC(*lvExpr).line);
+            wcharWarning = false;
+          }
+          str = strExpr.getBytes().str();
+        } else {
+          str = strExpr.getString().str();
+        }
+        astValue = AllocASTValue(allocator);
+        UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str);
+        astValue->val.strIdx = strIdx;
+        astValue->pty = PTY_a64;
+        break;
+      }
+      case clang::Stmt::PredefinedExprClass: {
+        astValue = AllocASTValue(allocator);
+        std::string str = llvm::cast<const clang::PredefinedExpr>(*lvExpr).getFunctionName()->getString().str();
+        UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str);
+        astValue->val.strIdx = strIdx;
+        astValue->pty = PTY_a64;
+        break;
+      }
+      case clang::Stmt::AddrLabelExprClass:
+      case clang::Stmt::CompoundLiteralExprClass: {
+        // Processing in corresponding expr, skipping
+        break;
+      }
+      default: {
+        CHECK_FATAL(false, "Unsupported expr :%s in LValue", lvExpr->getStmtClassName());
+      }
+    }
+  } else {
+    // `valueDecl` processed in corresponding expr
+    bool isValueDeclInLValueBase = lvBase.is<const clang::ValueDecl*>();
+    CHECK_FATAL(isValueDeclInLValueBase, "Unsupported lValue base");
+  }
+
+  return astValue;
+}
+
+ASTValue *ASTParser::TranslateExprEval(MapleAllocator &allocator, const clang::Expr *expr) const {
+  return TranslateConstantValue2ASTValue(allocator, expr);
+}
+
+#define EXPR_CASE(CLASS)                                                                        \
+  case clang::Stmt::CLASS##Class: {                                                             \
+    ASTExpr *astExpr = EvaluateExprAsConst(allocator, expr);                                    \
+    if (astExpr == nullptr) {                                                                   \
+      astExpr = ProcessExpr##CLASS(allocator, llvm::cast<clang::CLASS>(*expr));                 \
+      if (astExpr == nullptr) {                                                                 \
+        return nullptr;                                                                         \
+      }                                                                                         \
+    }                                                                                           \
+    MIRType *exprType = astFile->CvtType(expr->getType());                                      \
+    astExpr->SetType(exprType);                                                                 \
+    if (expr->isConstantInitializer(*astFile->GetNonConstAstContext(), false, nullptr)) {       \
+      astExpr->SetConstantValue(TranslateExprEval(allocator, expr));                            \
+    }                                                                                           \
+    Loc loc = astFile->GetExprLOC(*expr);                                                       \
+    astExpr->SetSrcLoc(loc);                                                                    \
+    return astExpr;                                                                             \
+  }
+
+ASTExpr *ASTParser::EvaluateExprAsConst(MapleAllocator &allocator, const clang::Expr *expr) {
+  ASSERT_NOT_NULL(expr);
+  clang::Expr::EvalResult constResult;
+  if (!expr->EvaluateAsConstantExpr(constResult, *astFile->GetNonConstAstContext())) {
+    return nullptr;
+  }
+
+  // Supplement SideEffects for EvaluateAsConstantExpr,
+  // If the expression contains a LabelStmt, the expression is unfoldable
+  // e.g. int x = 0 && ({ a : 1; }); goto a;
+  if (HasLabelStmt(expr)) {
+    return nullptr;
+  }
+
+  clang::APValue constVal = constResult.Val;
+  if (constVal.isInt()) {
+    ASTIntegerLiteral *intExpr = allocator.New<ASTIntegerLiteral>(allocator);
+    llvm::APSInt intVal = constVal.getInt();
+    intExpr->SetVal(intVal.getExtValue());
+    if (intVal.getExtValue() == 0) {
+      intExpr->SetEvaluatedFlag(kEvaluatedAsZero);
+    } else {
+      intExpr->SetEvaluatedFlag(kEvaluatedAsNonZero);
+    }
+    return intExpr;
+  } else if (constVal.isFloat()) {
+    ASTFloatingLiteral *floatExpr = allocator.New<ASTFloatingLiteral>(allocator);
+    llvm::APFloat floatVal = constVal.getFloat();
+    const llvm::fltSemantics &fltSem = floatVal.getSemantics();
+    double val = 0;
+    if (&fltSem == &llvm::APFloat::IEEEsingle()) {
+      val = static_cast<double>(floatVal.convertToFloat());
+      floatExpr->SetKind(FloatKind::F32);
+      floatExpr->SetVal(val);
+    } else if (&fltSem == &llvm::APFloat::IEEEdouble()) {
+      val = static_cast<double>(floatVal.convertToDouble());
+      floatExpr->SetKind(FloatKind::F64);
+      floatExpr->SetVal(val);
+    } else if (&fltSem == &llvm::APFloat::IEEEquad() || &fltSem == &llvm::APFloat::x87DoubleExtended()) {
+      bool losesInfo;
+      (void)floatVal.convert(llvm::APFloat::IEEEdouble(), llvm::APFloatBase::rmNearestTiesToAway, &losesInfo);
+      val = static_cast<double>(floatVal.convertToDouble());
+      floatExpr->SetKind(FloatKind::F64);
+      floatExpr->SetVal(val);
+    } else {
+      return nullptr;
+    }
+    if (floatVal.isPosZero()) {
+      floatExpr->SetEvaluatedFlag(kEvaluatedAsZero);
+    } else {
+      floatExpr->SetEvaluatedFlag(kEvaluatedAsNonZero);
+    }
+    return floatExpr;
+  }
+  return nullptr;
+}
+
+bool ASTParser::HasLabelStmt(const clang::Stmt *expr) {
+  ASSERT_NOT_NULL(expr);
+  if (expr->getStmtClass() == clang::Stmt::LabelStmtClass) {
+    return true;
+  }
+  for (const clang::Stmt *subStmt : expr->children()) {
+    if (subStmt == nullptr) {
+      continue;
+    }
+    if (HasLabelStmt(subStmt)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+ASTExpr *ASTParser::ProcessExpr(MapleAllocator &allocator, const clang::Expr *expr) {
+  if (expr == nullptr) {
+    return nullptr;
+  }
+  switch (expr->getStmtClass()) {
+    EXPR_CASE(UnaryOperator);
+    EXPR_CASE(AddrLabelExpr);
+    EXPR_CASE(NoInitExpr);
+    EXPR_CASE(PredefinedExpr);
+    EXPR_CASE(OpaqueValueExpr);
+    EXPR_CASE(BinaryConditionalOperator);
+    EXPR_CASE(CompoundLiteralExpr);
+    EXPR_CASE(OffsetOfExpr);
+    EXPR_CASE(InitListExpr);
+    EXPR_CASE(BinaryOperator);
+    EXPR_CASE(ImplicitValueInitExpr);
+    EXPR_CASE(ArraySubscriptExpr);
+    EXPR_CASE(UnaryExprOrTypeTraitExpr);
+    EXPR_CASE(MemberExpr);
+    EXPR_CASE(DesignatedInitUpdateExpr);
+    EXPR_CASE(ImplicitCastExpr);
+    EXPR_CASE(DeclRefExpr);
+    EXPR_CASE(ParenExpr);
+    EXPR_CASE(IntegerLiteral);
+    EXPR_CASE(CharacterLiteral);
+    EXPR_CASE(StringLiteral);
+    EXPR_CASE(FloatingLiteral);
+    EXPR_CASE(ConditionalOperator);
+    EXPR_CASE(VAArgExpr);
+    EXPR_CASE(GNUNullExpr);
+    EXPR_CASE(SizeOfPackExpr);
+    EXPR_CASE(UserDefinedLiteral);
+    EXPR_CASE(ShuffleVectorExpr);
+    EXPR_CASE(TypeTraitExpr);
+    EXPR_CASE(ConstantExpr);
+    EXPR_CASE(ImaginaryLiteral);
+    EXPR_CASE(CallExpr);
+    EXPR_CASE(CompoundAssignOperator);
+    EXPR_CASE(StmtExpr);
+    EXPR_CASE(CStyleCastExpr);
+    EXPR_CASE(ArrayInitLoopExpr);
+    EXPR_CASE(ArrayInitIndexExpr);
+    EXPR_CASE(ExprWithCleanups);
+    EXPR_CASE(MaterializeTemporaryExpr);
+    EXPR_CASE(SubstNonTypeTemplateParmExpr);
+    EXPR_CASE(DependentScopeDeclRefExpr);
+    EXPR_CASE(AtomicExpr);
+    EXPR_CASE(ChooseExpr);
+    EXPR_CASE(GenericSelectionExpr);
+    default:
+      CHECK_FATAL(false, "ASTExpr %s NIY", expr->getStmtClassName());
+      return nullptr;
+  }
+}
+
+void ASTParser::SaveVLASizeExpr(MapleAllocator &allocator, const clang::QualType &qualType,
+                                std::list<ASTExpr*> &vlaSizeExprs) {
+  const clang::Type *type = qualType.getCanonicalType().getTypePtr();
+  if (!type->isVariableArrayType()) {
+    return;
+  }
+  const clang::VariableArrayType *vlaType = llvm::cast<clang::VariableArrayType>(type);
+  if (vlaSizeMap.find(vlaType->getSizeExpr()) != vlaSizeMap.cend()) {
+    return;  // vla size expr already exists
+  }
+  ASTExpr *vlaSizeExpr = BuildExprToComputeSizeFromVLA(allocator, qualType.getCanonicalType());
+  if (vlaSizeExpr == nullptr) {
+    return;
+  }
+  ASTDeclRefExpr *vlaSizeVarExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  MIRType *vlaSizeType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_u64);
+  ASTDecl *vlaSizeVar = ASTDeclsBuilder::ASTDeclBuilder(
+      allocator, MapleString("", allocator.GetMemPool()), FEUtils::GetSequentialName("vla_size."),
+      MapleVector<MIRType*>({vlaSizeType}, allocator.Adapter()));
+  vlaSizeVar->SetIsParam(true);
+  vlaSizeVarExpr->SetASTDecl(vlaSizeVar);
+  ASTAssignExpr *expr = ASTDeclsBuilder::ASTStmtBuilder<ASTAssignExpr>(allocator);
+  expr->SetLeftExpr(vlaSizeVarExpr);
+  expr->SetRightExpr(vlaSizeExpr);
+  vlaSizeMap[vlaType->getSizeExpr()] = vlaSizeVarExpr;
+  (void)vlaSizeExprs.emplace_back(expr);
+  SaveVLASizeExpr(allocator, vlaType->getElementType(), vlaSizeExprs);
+}
+
+ASTUnaryOperatorExpr *ASTParser::AllocUnaryOperatorExpr(MapleAllocator &allocator,
+                                                        const clang::UnaryOperator &expr) const {
+  clang::UnaryOperator::Opcode clangOpCode = expr.getOpcode();
+  switch (clangOpCode) {
+    case clang::UO_Minus:     // "-"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOMinusExpr>(allocator);
+    case clang::UO_Not:       // "~"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUONotExpr>(allocator);
+    case clang::UO_LNot:      // "!"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOLNotExpr>(allocator);
+    case clang::UO_PostInc:   // "++"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOPostIncExpr>(allocator);
+    case clang::UO_PostDec:   // "--"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOPostDecExpr>(allocator);
+    case clang::UO_PreInc:    // "++"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOPreIncExpr>(allocator);
+    case clang::UO_PreDec:    // "--"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOPreDecExpr>(allocator);
+    case clang::UO_AddrOf:    // "&"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOAddrOfExpr>(allocator);
+    case clang::UO_Deref:     // "*"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUODerefExpr>(allocator);
+    case clang::UO_Plus:      // "+"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOPlusExpr>(allocator);
+    case clang::UO_Real:      // "__real"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUORealExpr>(allocator);
+    case clang::UO_Imag:      // "__imag"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOImagExpr>(allocator);
+    case clang::UO_Extension: // "__extension__"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOExtensionExpr>(allocator);
+    case clang::UO_Coawait:   // "co_await"
+      return ASTDeclsBuilder::ASTExprBuilder<ASTUOCoawaitExpr>(allocator);
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+}
+
+ASTValue *ASTParser::AllocASTValue(const MapleAllocator &allocator) const {
+  return allocator.GetMemPool()->New<ASTValue>();
+}
+
+const clang::Expr *ASTParser::PeelParen(const clang::Expr &expr) const {
+  const clang::Expr *exprPtr = &expr;
+  while (llvm::isa<clang::ParenExpr>(exprPtr) ||
+         (llvm::isa<clang::UnaryOperator>(exprPtr) &&
+          llvm::cast<clang::UnaryOperator>(exprPtr)->getOpcode() == clang::UO_Extension) ||
+         (llvm::isa<clang::ImplicitCastExpr>(exprPtr) &&
+          llvm::cast<clang::ImplicitCastExpr>(exprPtr)->getCastKind() == clang::CK_LValueToRValue)) {
+    if (llvm::isa<clang::ParenExpr>(exprPtr)) {
+      exprPtr = llvm::cast<clang::ParenExpr>(exprPtr)->getSubExpr();
+    } else if (llvm::isa<clang::ImplicitCastExpr>(exprPtr)) {
+      exprPtr = llvm::cast<clang::ImplicitCastExpr>(exprPtr)->getSubExpr();
+    } else {
+      exprPtr = llvm::cast<clang::UnaryOperator>(exprPtr)->getSubExpr();
+    }
+  }
+  return exprPtr;
+}
+
+const clang::Expr *ASTParser::PeelParen2(const clang::Expr &expr) const {
+  const clang::Expr *exprPtr = &expr;
+  while (llvm::isa<clang::ParenExpr>(exprPtr) ||
+         (llvm::isa<clang::UnaryOperator>(exprPtr) &&
+          llvm::cast<clang::UnaryOperator>(exprPtr)->getOpcode() == clang::UO_Extension)) {
+    if (llvm::isa<clang::ParenExpr>(exprPtr)) {
+      exprPtr = llvm::cast<clang::ParenExpr>(exprPtr)->getSubExpr();
+    } else {
+      exprPtr = llvm::cast<clang::UnaryOperator>(exprPtr)->getSubExpr();
+    }
+  }
+  return exprPtr;
+}
+
+ASTExpr *ASTParser::ProcessExprUnaryOperator(MapleAllocator &allocator, const clang::UnaryOperator &uo) {
+  ASTUnaryOperatorExpr *astUOExpr = AllocUnaryOperatorExpr(allocator, uo);
+  CHECK_FATAL(astUOExpr != nullptr, "astUOExpr is nullptr");
+  const clang::Expr *subExpr = PeelParen(*uo.getSubExpr());
+  clang::UnaryOperator::Opcode clangOpCode = uo.getOpcode();
+  MIRType *subType = astFile->CvtType(subExpr->getType());
+  astUOExpr->SetSubType(subType);
+  MIRType *uoType = astFile->CvtType(uo.getType());
+  astUOExpr->SetUOType(uoType);
+  if (clangOpCode == clang::UO_PostInc || clangOpCode == clang::UO_PostDec ||
+      clangOpCode == clang::UO_PreInc || clangOpCode == clang::UO_PreDec) {
+    const auto *declRefExpr = llvm::dyn_cast<clang::DeclRefExpr>(subExpr);
+    if (declRefExpr != nullptr && declRefExpr->getDecl()->getKind() == clang::Decl::Var) {
+      const auto *varDecl = llvm::cast<clang::VarDecl>(declRefExpr->getDecl()->getCanonicalDecl());
+      astUOExpr->SetGlobal(!varDecl->isLocalVarDeclOrParm());
+    }
+    if (subType->GetPrimType() == PTY_ptr) {
+      int64 len;
+      const clang::QualType qualType = subExpr->getType()->getPointeeType();
+      if (astFile->CvtType(qualType) != nullptr && astFile->CvtType(qualType)->GetPrimType() == PTY_ptr) {
+        MIRType *pointeeType = GlobalTables::GetTypeTable().GetPtr();
+        len = static_cast<int64>(pointeeType->GetSize());
+      } else {
+        const clang::QualType desugaredType = qualType.getDesugaredType(*(astFile->GetContext()));
+        len = astFile->GetContext()->getTypeSizeInChars(desugaredType).getQuantity();
+      }
+      astUOExpr->SetPointeeLen(len);
+    }
+  }
+  if (clangOpCode == clang::UO_Imag || clangOpCode == clang::UO_Real) {
+    clang::QualType elementType = llvm::cast<clang::ComplexType>(
+        uo.getSubExpr()->getType().getCanonicalType())->getElementType();
+    MIRType *elementMirType = astFile->CvtType(elementType);
+    if (clangOpCode == clang::UO_Real) {
+      static_cast<ASTUORealExpr*>(astUOExpr)->SetElementType(elementMirType);
+    } else {
+      static_cast<ASTUOImagExpr*>(astUOExpr)->SetElementType(elementMirType);
+    }
+  }
+  ASTExpr *astExpr = ProcessExpr(allocator, subExpr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  // vla as a pointer is not need to be addrof
+  if (clangOpCode == clang::UO_AddrOf && subExpr->getType()->isVariableArrayType()) {
+    return astExpr;
+  }
+  astUOExpr->SetASTDecl(astExpr->GetASTDecl());
+  astUOExpr->SetUOExpr(astExpr);
+  return astUOExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprAddrLabelExpr(MapleAllocator &allocator, const clang::AddrLabelExpr &expr) {
+  ASTUOAddrOfLabelExpr *astAddrOfLabelExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOAddrOfLabelExpr>(allocator);
+  const clang::LabelDecl *lbDecl = expr.getLabel();
+  CHECK_NULL_FATAL(lbDecl);
+  ASTDecl *astDecl = ProcessDecl(allocator, *lbDecl);
+  astAddrOfLabelExpr->SetLabelName(astDecl->GetName());
+  astAddrOfLabelExpr->SetUOType(GlobalTables::GetTypeTable().GetPrimType(PTY_ptr));
+  return astAddrOfLabelExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprNoInitExpr(MapleAllocator &allocator, const clang::NoInitExpr &expr) {
+  ASTNoInitExpr *astNoInitExpr = ASTDeclsBuilder::ASTExprBuilder<ASTNoInitExpr>(allocator);
+  CHECK_FATAL(astNoInitExpr != nullptr, "astNoInitExpr is nullptr");
+  clang::QualType qualType = expr.getType();
+  MIRType *noInitType = astFile->CvtType(qualType);
+  astNoInitExpr->SetNoInitType(noInitType);
+  return astNoInitExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprPredefinedExpr(MapleAllocator &allocator, const clang::PredefinedExpr &expr) {
+  ASTPredefinedExpr *astPredefinedExpr = ASTDeclsBuilder::ASTExprBuilder<ASTPredefinedExpr>(allocator);
+  CHECK_FATAL(astPredefinedExpr != nullptr, "astPredefinedExpr is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, expr.getFunctionName());
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astPredefinedExpr->SetASTExpr(astExpr);
+  return astPredefinedExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprOpaqueValueExpr(MapleAllocator &allocator, const clang::OpaqueValueExpr &expr) {
+  ASTOpaqueValueExpr *astOpaqueValueExpr = ASTDeclsBuilder::ASTExprBuilder<ASTOpaqueValueExpr>(allocator);
+  CHECK_FATAL(astOpaqueValueExpr != nullptr, "astOpaqueValueExpr is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, expr.getSourceExpr());
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astOpaqueValueExpr->SetASTExpr(astExpr);
+  return astOpaqueValueExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprBinaryConditionalOperator(MapleAllocator &allocator,
+                                                         const clang::BinaryConditionalOperator &expr) {
+  ASTBinaryConditionalOperator *astBinaryConditionalOperator =
+      ASTDeclsBuilder::ASTExprBuilder<ASTBinaryConditionalOperator>(allocator);
+  CHECK_FATAL(astBinaryConditionalOperator != nullptr, "astBinaryConditionalOperator is nullptr");
+  ASTExpr *condExpr = ProcessExpr(allocator, expr.getCond());
+  if (condExpr == nullptr) {
+    return nullptr;
+  }
+  astBinaryConditionalOperator->SetCondExpr(condExpr);
+  ASTExpr *falseExpr = ProcessExpr(allocator, expr.getFalseExpr());
+  if (falseExpr == nullptr) {
+    return nullptr;
+  }
+  astBinaryConditionalOperator->SetFalseExpr(falseExpr);
+  astBinaryConditionalOperator->SetType(astFile->CvtType(expr.getType()));
+  return astBinaryConditionalOperator;
+}
+
+ASTExpr *ASTParser::ProcessExprCompoundLiteralExpr(MapleAllocator &allocator,
+                                                   const clang::CompoundLiteralExpr &expr) {
+  ASTCompoundLiteralExpr *astCompoundLiteralExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCompoundLiteralExpr>(allocator);
+  CHECK_FATAL(astCompoundLiteralExpr != nullptr, "astCompoundLiteralExpr is nullptr");
+  const clang::Expr *initExpr = expr.getInitializer();
+  CHECK_FATAL(initExpr != nullptr, "initExpr is nullptr");
+  clang::QualType qualType = initExpr->getType();
+  astCompoundLiteralExpr->SetCompoundLiteralType(astFile->CvtType(qualType));
+  ASTExpr *astExpr = ProcessExpr(allocator, initExpr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astCompoundLiteralExpr->SetASTExpr(astExpr);
+  return astCompoundLiteralExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprInitListExpr(MapleAllocator &allocator, const clang::InitListExpr &expr) {
+  ASTInitListExpr *astInitListExpr = ASTDeclsBuilder::ASTExprBuilder<ASTInitListExpr>(allocator);
+  CHECK_FATAL(astInitListExpr != nullptr, "ASTInitListExpr is nullptr");
+  MIRType *initListType = astFile->CvtType(expr.getType());
+  clang::QualType aggType = expr.getType().getCanonicalType();
+  astInitListExpr->SetInitListType(initListType);
+  const clang::FieldDecl *fieldDecl = expr.getInitializedFieldInUnion();
+  if (fieldDecl != nullptr) {
+    astInitListExpr->SetUnionInitFieldIdx(fieldDecl->getFieldIndex());
+  }
+  uint32 n = expr.getNumInits();
+  clang::Expr * const *le = expr.getInits();
+  std::unordered_set<EvaluatedFlag> evaluatedFlags;
+  if (aggType->isRecordType()) {
+    const auto *recordType = llvm::cast<clang::RecordType>(aggType);
+    clang::RecordDecl *recordDecl = recordType->getDecl();
+    ASTDecl *astDecl = ProcessDecl(allocator, *recordDecl);
+    CHECK_FATAL(astDecl != nullptr && astDecl->GetDeclKind() == kASTStruct, "Undefined record type");
+    uint i = 0;
+    for (const auto field : static_cast<ASTStruct*>(astDecl)->GetFields()) {
+      if (field->IsAnonymousField() && fieldDecl == nullptr &&
+          n != static_cast<ASTStruct*>(astDecl)->GetFields().size()) {
+        astInitListExpr->SetInitExprs(nullptr);
+      } else {
+        if (i < n) {
+          const clang::Expr *eExpr = le[i];
+          ASTExpr *astExpr = ProcessExpr(allocator, eExpr);
+          CHECK_FATAL(astExpr != nullptr, "Invalid InitListExpr");
+          (void)evaluatedFlags.insert(astExpr->GetEvaluatedFlag());
+          astInitListExpr->SetInitExprs(astExpr);
+          i++;
+        }
+      }
+    }
+  } else {
+    if (expr.hasArrayFiller()) {
+      auto *astFilterExpr = ProcessExpr(allocator, expr.getArrayFiller());
+      astInitListExpr->SetArrayFiller(astFilterExpr);
+      astInitListExpr->SetHasArrayFiller(true);
+    }
+    if (expr.isTransparent()) {
+      astInitListExpr->SetTransparent(true);
+    }
+    if (aggType->isVectorType()) {
+      astInitListExpr->SetHasVectorType(true);
+      // for one elem vector type
+      if (LibAstFile::IsOneElementVector(aggType)) {
+        astInitListExpr->SetTransparent(true);
+      }
+    }
+    for (uint32 i = 0; i < n; ++i) {
+      const clang::Expr *eExpr = le[i];
+      ASTExpr *astExpr = ProcessExpr(allocator, eExpr);
+      if (astExpr == nullptr) {
+        return nullptr;
+      }
+      (void)evaluatedFlags.insert(astExpr->GetEvaluatedFlag());
+      astInitListExpr->SetInitExprs(astExpr);
+    }
+  }
+  if (evaluatedFlags.count(kNotEvaluated) > 0 || evaluatedFlags.count(kEvaluatedAsNonZero) > 0) {
+    astInitListExpr->SetEvaluatedFlag(kEvaluatedAsNonZero);
+  } else {
+    astInitListExpr->SetEvaluatedFlag(kEvaluatedAsZero);
+  }
+  return astInitListExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprOffsetOfExpr(MapleAllocator &allocator, const clang::OffsetOfExpr &expr) {
+  if (expr.isEvaluatable(*astFile->GetContext())) {
+    clang::Expr::EvalResult result;
+    bool success = expr.EvaluateAsInt(result, *astFile->GetContext());
+    if (success) {
+      auto astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+      astExpr->SetVal(result.Val.getInt().getExtValue());
+      astExpr->SetType(GlobalTables::GetTypeTable().GetUInt64());
+      return astExpr;
+    }
+  }
+  int64_t offset = 0;
+  std::vector<ASTExpr*> vlaOffsetExprs;
+  for (unsigned i = 0; i < expr.getNumComponents(); i++) {
+    auto comp = expr.getComponent(i);
+    if (comp.getKind() == clang::OffsetOfNode::Kind::Field) {
+      uint filedIdx = comp.getField()->getFieldIndex();
+      offset += static_cast<int64_t>(astFile->GetContext()->getASTRecordLayout(
+          comp.getField()->getParent()).getFieldOffset(filedIdx) >> kBitToByteShift);
+    } else if (comp.getKind() == clang::OffsetOfNode::Kind::Array) {
+      uint32 idx = comp.getArrayExprIndex();
+      auto idxExpr = expr.getIndexExpr(idx);
+      auto leftExpr = ProcessExpr(allocator, idxExpr);
+      ASSERT(i >= 1, "arg should be nonnegative number");
+      auto arrayType = expr.getComponent(i - 1).getField()->getType();
+      auto elementType = llvm::cast<clang::ArrayType>(arrayType)->getElementType();
+      uint32 elementSize = GetSizeFromQualType(elementType);
+      if (elementSize == 1) {
+        vlaOffsetExprs.emplace_back(leftExpr);
+      } else {
+        auto astSizeExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+        astSizeExpr->SetVal(elementSize);
+        astSizeExpr->SetType(GlobalTables::GetTypeTable().GetUInt64());
+        auto astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+        astExpr->SetOpcode(OP_mul);
+        astExpr->SetLeftExpr(leftExpr);
+        astExpr->SetRightExpr(astSizeExpr);
+        astExpr->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_u64));
+        vlaOffsetExprs.emplace_back(astExpr);
+      }
+    } else {
+      CHECK_FATAL(false, "NIY");
+    }
+  }
+  ASTExpr *vlaOffsetExpr = nullptr;
+  if (vlaOffsetExprs.size() == 1) {
+    vlaOffsetExpr = vlaOffsetExprs[0];
+  } else if (vlaOffsetExprs.size() >= 2) {
+    auto astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+    astExpr->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_u64));
+    astExpr->SetLeftExpr(vlaOffsetExprs[0]);
+    astExpr->SetRightExpr(vlaOffsetExprs[1]);
+    if (vlaOffsetExprs.size() >= 3) {
+      for (size_t i = 2; i < vlaOffsetExprs.size(); i++) {
+        auto astSubExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+        astSubExpr->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_u64));
+        astSubExpr->SetLeftExpr(astExpr);
+        astSubExpr->SetRightExpr(vlaOffsetExprs[i]);
+        astExpr = astSubExpr;
+      }
+    }
+    vlaOffsetExpr = astExpr;
+  }
+  auto astSizeExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  astSizeExpr->SetVal(offset);
+  astSizeExpr->SetType(GlobalTables::GetTypeTable().GetUInt64());
+  auto astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  astExpr->SetOpcode(OP_add);
+  astExpr->SetLeftExpr(astSizeExpr);
+  astExpr->SetRightExpr(vlaOffsetExpr);
+  astExpr->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_u64));
+  return astExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprVAArgExpr(MapleAllocator &allocator, const clang::VAArgExpr &expr) {
+  ASTVAArgExpr *astVAArgExpr = ASTDeclsBuilder::ASTExprBuilder<ASTVAArgExpr>(allocator);
+  ASSERT(astVAArgExpr != nullptr, "astVAArgExpr is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, expr.getSubExpr());
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astVAArgExpr->SetASTExpr(astExpr);
+  astVAArgExpr->SetType(astFile->CvtType(expr.getType()));
+  return astVAArgExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprImplicitValueInitExpr(MapleAllocator &allocator,
+                                                     const clang::ImplicitValueInitExpr &expr) {
+  auto *astImplicitValueInitExpr = ASTDeclsBuilder::ASTExprBuilder<ASTImplicitValueInitExpr>(allocator);
+  CHECK_FATAL(astImplicitValueInitExpr != nullptr, "astImplicitValueInitExpr is nullptr");
+  astImplicitValueInitExpr->SetType(astFile->CvtType(expr.getType()));
+  astImplicitValueInitExpr->SetEvaluatedFlag(kEvaluatedAsZero);
+  return astImplicitValueInitExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprStringLiteral(MapleAllocator &allocator, const clang::StringLiteral &expr) {
+  auto *astStringLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTStringLiteral>(allocator);
+  CHECK_FATAL(astStringLiteral != nullptr, "astStringLiteral is nullptr");
+  astStringLiteral->SetType(astFile->CvtType(expr.getType()));
+  astStringLiteral->SetLength(expr.getLength());
+  MapleVector<uint32_t> codeUnits(allocator.Adapter());
+  for (size_t i = 0; i < expr.getLength(); ++i) {
+    codeUnits.emplace_back(expr.getCodeUnit(i));
+  }
+  astStringLiteral->SetCodeUnits(codeUnits);
+  if (expr.isAscii()) {
+    astStringLiteral->SetStr(expr.getString().str());
+  }
+  return astStringLiteral;
+}
+
+ASTExpr *ASTParser::ProcessExprArraySubscriptExpr(MapleAllocator &allocator, const clang::ArraySubscriptExpr &expr) {
+  auto *astArraySubscriptExpr = ASTDeclsBuilder::ASTExprBuilder<ASTArraySubscriptExpr>(allocator);
+  CHECK_FATAL(astArraySubscriptExpr != nullptr, "astArraySubscriptExpr is nullptr");
+  auto base = expr.getBase();
+
+  base = PeelParen2(*base);
+  ASTExpr *idxExpr = ProcessExpr(allocator, expr.getIdx());
+  astArraySubscriptExpr->SetIdxExpr(idxExpr);
+
+  clang::QualType arrayQualType = base->getType().getCanonicalType();
+  if (base->getStmtClass() == clang::Stmt::ImplicitCastExprClass &&
+      !static_cast<const clang::ImplicitCastExpr*>(base)->isPartOfExplicitCast()) {
+    arrayQualType = static_cast<const clang::ImplicitCastExpr*>(base)->getSubExpr()->getType().getCanonicalType();
+  }
+  auto arrayMirType = astFile->CvtType(arrayQualType);
+  astArraySubscriptExpr->SetArrayType(arrayMirType);
+
+  clang::QualType exprType = expr.getType().getCanonicalType();
+  if (arrayQualType->isVariablyModifiedType()) {
+    astArraySubscriptExpr->SetIsVLA(true);
+    ASTExpr *vlaTypeSizeExpr = BuildExprToComputeSizeFromVLA(allocator, exprType);
+    astArraySubscriptExpr->SetVLASizeExpr(vlaTypeSizeExpr);
+  }
+  ASTExpr *astBaseExpr = ProcessExpr(allocator, base);
+  astArraySubscriptExpr->SetBaseExpr(astBaseExpr);
+  auto *mirType = astFile->CvtType(exprType);
+  astArraySubscriptExpr->SetType(mirType);
+  return astArraySubscriptExpr;
+}
+
+uint32 ASTParser::GetSizeFromQualType(const clang::QualType qualType) const {
+  const clang::QualType desugaredType = qualType.getDesugaredType(*astFile->GetContext());
+  return astFile->GetContext()->getTypeSizeInChars(desugaredType).getQuantity();
+}
+
+ASTExpr *ASTParser::GetTypeSizeFromQualType(MapleAllocator &allocator, const clang::QualType qualType) {
+  const clang::QualType desugaredType = qualType.getDesugaredType(*astFile->GetContext());
+  if (llvm::isa<clang::VariableArrayType>(desugaredType)) {
+    ASTExpr *vlaSizeExpr = ProcessExpr(allocator, llvm::cast<clang::VariableArrayType>(desugaredType)->getSizeExpr());
+    ASTExpr *vlaElemTypeSizeExpr =
+        GetTypeSizeFromQualType(allocator, llvm::cast<clang::VariableArrayType>(desugaredType)->getElementType());
+    ASTBinaryOperatorExpr *sizeExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+    sizeExpr->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_i64));
+    sizeExpr->SetOpcode(OP_mul);
+    sizeExpr->SetLeftExpr(vlaSizeExpr);
+    sizeExpr->SetRightExpr(vlaElemTypeSizeExpr);
+    return sizeExpr;
+  } else {
+    ASTIntegerLiteral *sizeExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+    sizeExpr->SetVal(astFile->GetContext()->getTypeSizeInChars(desugaredType).getQuantity());
+    sizeExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+    return sizeExpr;
+  }
+}
+
+uint32_t ASTParser::GetAlignOfType(const clang::QualType currQualType, clang::UnaryExprOrTypeTrait exprKind) const {
+  clang::QualType qualType = currQualType;
+  clang::CharUnits alignInCharUnits = clang::CharUnits::Zero();
+  if (const auto *ref = currQualType->getAs<clang::ReferenceType>()) {
+    qualType = ref->getPointeeType();
+  }
+  if (qualType.getQualifiers().hasUnaligned()) {
+    alignInCharUnits = clang::CharUnits::One();
+  }
+  if (exprKind == clang::UETT_AlignOf) {
+    alignInCharUnits = astFile->GetContext()->getTypeAlignInChars(qualType.getTypePtr());
+  } else if (exprKind == clang::UETT_PreferredAlignOf) {
+    alignInCharUnits = astFile->GetContext()->toCharUnitsFromBits(
+        astFile->GetContext()->getPreferredTypeAlign(qualType.getTypePtr()));
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  return static_cast<uint32_t>(alignInCharUnits.getQuantity());
+}
+
+uint32_t ASTParser::GetAlignOfExpr(const clang::Expr &expr, clang::UnaryExprOrTypeTrait exprKind) const {
+  clang::CharUnits alignInCharUnits = clang::CharUnits::Zero();
+  const clang::Expr *exprNoParens = expr.IgnoreParens();
+  if (const auto *declRefExpr = clang::dyn_cast<clang::DeclRefExpr>(exprNoParens)) {
+    alignInCharUnits = astFile->GetContext()->getDeclAlign(declRefExpr->getDecl(), true);
+  } else if (const auto *memberExpr = clang::dyn_cast<clang::MemberExpr>(exprNoParens)) {
+    alignInCharUnits = astFile->GetContext()->getDeclAlign(memberExpr->getMemberDecl(), true);
+  } else {
+    return GetAlignOfType(exprNoParens->getType(), exprKind);
+  }
+  return static_cast<uint32_t>(alignInCharUnits.getQuantity());
+}
+
+ASTExpr *ASTParser::GetAddrShiftExpr(MapleAllocator &allocator, ASTExpr &expr, uint32 typeSize) {
+  MIRType *retType = nullptr;
+  if (IsSignedInteger(expr.GetType()->GetPrimType())) {
+    retType = GlobalTables::GetTypeTable().GetInt64();
+  } else {
+    retType = GlobalTables::GetTypeTable().GetPtr();
+  }
+  if (expr.GetASTOp() == kASTIntegerLiteral) {
+    auto intExpr = static_cast<ASTIntegerLiteral*>(&expr);
+    auto retExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+    retExpr->SetVal(intExpr->GetVal() * typeSize);
+    retExpr->SetType(retType);
+    return retExpr;
+  }
+  auto ptrSizeExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  ptrSizeExpr->SetVal(typeSize);
+  ptrSizeExpr->SetType(retType);
+  auto shiftExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  shiftExpr->SetLeftExpr(&expr);
+  shiftExpr->SetRightExpr(ptrSizeExpr);
+  shiftExpr->SetOpcode(OP_mul);
+  shiftExpr->SetRetType(retType);
+  shiftExpr->SetCvtNeeded(true);
+  shiftExpr->SetSrcLoc(expr.GetSrcLoc());
+  return shiftExpr;
+}
+
+ASTExpr *ASTParser::GetSizeMulExpr(MapleAllocator &allocator, ASTExpr &expr, ASTExpr &ptrSizeExpr) {
+  MIRType *retType = nullptr;
+  if (IsSignedInteger(expr.GetType()->GetPrimType())) {
+    retType = GlobalTables::GetTypeTable().GetInt64();
+  } else {
+    retType = GlobalTables::GetTypeTable().GetPtr();
+  }
+  auto shiftExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  shiftExpr->SetLeftExpr(&expr);
+  shiftExpr->SetRightExpr(&ptrSizeExpr);
+  shiftExpr->SetOpcode(OP_mul);
+  shiftExpr->SetRetType(retType);
+  shiftExpr->SetCvtNeeded(true);
+  shiftExpr->SetSrcLoc(expr.GetSrcLoc());
+  return shiftExpr;
+}
+
+ASTExpr *ASTParser::BuildExprToComputeSizeFromVLA(MapleAllocator &allocator, const clang::QualType &qualType) {
+  if (llvm::isa<clang::ArrayType>(qualType)) {
+    ASTExpr *lhs = BuildExprToComputeSizeFromVLA(allocator, llvm::cast<clang::ArrayType>(qualType)->getElementType());
+    ASTExpr *rhs = nullptr;
+    CHECK_FATAL(llvm::isa<clang::ArrayType>(qualType), "the type must be array type");
+    clang::Expr *sizeExpr = nullptr;
+    if (llvm::isa<clang::VariableArrayType>(qualType)) {
+      sizeExpr = llvm::cast<clang::VariableArrayType>(qualType)->getSizeExpr();
+      if (sizeExpr == nullptr) {
+        return nullptr;
+      }
+      MapleMap<clang::Expr*, ASTExpr*>::const_iterator iter = vlaSizeMap.find(sizeExpr);
+      if (iter != vlaSizeMap.cend()) {
+        return iter->second;
+      }
+      rhs = ProcessExpr(allocator, sizeExpr);
+      CHECK_FATAL(sizeExpr->getType()->isIntegerType(), "the type should be integer");
+    } else if (llvm::isa<clang::ConstantArrayType>(qualType)) {
+      uint32 size = static_cast<uint32>(llvm::cast<clang::ConstantArrayType>(qualType)->getSize().getSExtValue());
+      if (size == 1) {
+        return lhs;
+      }
+      auto astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+      astExpr->SetVal(size);
+      astExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+      rhs = astExpr;
+    } else {
+      CHECK_FATAL(false, "NIY");
+    }
+    auto *astBOExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+    astBOExpr->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_u64));
+    astBOExpr->SetOpcode(OP_mul);
+    astBOExpr->SetLeftExpr(lhs);
+    astBOExpr->SetRightExpr(rhs);
+    return astBOExpr;
+  }
+  uint32 size = GetSizeFromQualType(qualType);
+  auto integerExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  integerExpr->SetType(GlobalTables::GetTypeTable().GetUInt64());
+  integerExpr->SetVal(size);
+  return integerExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprUnaryExprOrTypeTraitExpr(MapleAllocator &allocator,
+                                                        const clang::UnaryExprOrTypeTraitExpr &expr) {
+  auto *astExprUnaryExprOrTypeTraitExpr = ASTDeclsBuilder::ASTExprBuilder<ASTExprUnaryExprOrTypeTraitExpr>(allocator);
+  CHECK_FATAL(astExprUnaryExprOrTypeTraitExpr != nullptr, "astExprUnaryExprOrTypeTraitExpr is nullptr");
+  switch (expr.getKind()) {
+    case clang::UETT_SizeOf: {
+      clang::QualType qualType = expr.isArgumentType() ? expr.getArgumentType().getCanonicalType()
+                                                       : expr.getArgumentExpr()->getType().getCanonicalType();
+      if (llvm::isa<clang::VariableArrayType>(qualType)) {
+        return BuildExprToComputeSizeFromVLA(allocator, qualType);
+      }
+      uint32 size = GetSizeFromQualType(qualType);
+      auto integerExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+      integerExpr->SetType(GlobalTables::GetTypeTable().GetUInt64());
+      integerExpr->SetVal(size);
+      return integerExpr;
+    }
+    case clang::UETT_PreferredAlignOf:
+    case clang::UETT_AlignOf: {
+      // C11 specification: ISO/IEC 9899:201x
+      uint32_t align;
+      if (expr.isArgumentType()) {
+        align = GetAlignOfType(expr.getArgumentType(), expr.getKind());
+      } else {
+        align = GetAlignOfExpr(*expr.getArgumentExpr(), expr.getKind());
+      }
+      auto integerExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+      integerExpr->SetType(GlobalTables::GetTypeTable().GetUInt64());
+      integerExpr->SetVal(align);
+      return integerExpr;
+    }
+    case clang::UETT_VecStep:
+      CHECK_FATAL(false, "NIY");
+      break;
+    case clang::UETT_OpenMPRequiredSimdAlign:
+      CHECK_FATAL(false, "NIY");
+      break;
+  }
+  return astExprUnaryExprOrTypeTraitExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprMemberExpr(MapleAllocator &allocator, const clang::MemberExpr &expr) {
+  auto *astMemberExpr = ASTDeclsBuilder::ASTExprBuilder<ASTMemberExpr>(allocator);
+  CHECK_FATAL(astMemberExpr != nullptr, "astMemberExpr is nullptr");
+  ASTExpr *baseExpr = ProcessExpr(allocator, expr.getBase());
+  if (baseExpr == nullptr) {
+    return nullptr;
+  }
+  astMemberExpr->SetBaseExpr(baseExpr);
+  astMemberExpr->SetBaseType(astFile->CvtType(expr.getBase()->getType()));
+  auto memberName = expr.getMemberDecl()->getNameAsString();
+  if (memberName.empty()) {
+    memberName = astFile->GetOrCreateMappedUnnamedName(*expr.getMemberDecl());
+  }
+  astMemberExpr->SetMemberName(memberName);
+  astMemberExpr->SetMemberType(astFile->CvtType(expr.getMemberDecl()->getType()));
+  astMemberExpr->SetIsArrow(expr.isArrow());
+  uint64_t offsetBits = astFile->GetContext()->getFieldOffset(expr.getMemberDecl());
+  astMemberExpr->SetFiledOffsetBits(offsetBits);
+  return astMemberExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprDesignatedInitUpdateExpr(MapleAllocator &allocator,
+                                                        const clang::DesignatedInitUpdateExpr &expr) {
+  auto *astDesignatedInitUpdateExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDesignatedInitUpdateExpr>(allocator);
+  CHECK_FATAL(astDesignatedInitUpdateExpr != nullptr, "astDesignatedInitUpdateExpr is nullptr");
+  ASTExpr *baseExpr = ProcessExpr(allocator, expr.getBase());
+  if (baseExpr == nullptr) {
+    return nullptr;
+  }
+  astDesignatedInitUpdateExpr->SetBaseExpr(baseExpr);
+  clang::InitListExpr *initListExpr = expr.getUpdater();
+  MIRType *initListType = astFile->CvtType(expr.getType());
+  astDesignatedInitUpdateExpr->SetInitListType(initListType);
+  ASTExpr *updaterExpr = ProcessExpr(allocator, initListExpr);
+  if (updaterExpr == nullptr) {
+    return nullptr;
+  }
+  astDesignatedInitUpdateExpr->SetUpdaterExpr(updaterExpr);
+  return astDesignatedInitUpdateExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprStmtExpr(MapleAllocator &allocator, const clang::StmtExpr &expr) {
+  ASTExprStmtExpr *astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTExprStmtExpr>(allocator);
+  ASTStmt *compoundStmt = ProcessStmt(allocator, *expr.getSubStmt());
+  astExpr->SetCompoundStmt(compoundStmt);
+  return astExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprConditionalOperator(MapleAllocator &allocator, const clang::ConditionalOperator &expr) {
+  ASTConditionalOperator *astConditionalOperator = ASTDeclsBuilder::ASTExprBuilder<ASTConditionalOperator>(allocator);
+  ASSERT(astConditionalOperator != nullptr, "astConditionalOperator is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, expr.getCond());
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astConditionalOperator->SetCondExpr(astExpr);
+  ASTExpr *astTrueExpr = ProcessExpr(allocator, expr.getTrueExpr());
+  if (astTrueExpr == nullptr) {
+    return nullptr;
+  }
+  astConditionalOperator->SetTrueExpr(astTrueExpr);
+  ASTExpr *astFalseExpr = ProcessExpr(allocator, expr.getFalseExpr());
+  if (astFalseExpr == nullptr) {
+    return nullptr;
+  }
+  astConditionalOperator->SetFalseExpr(astFalseExpr);
+  astConditionalOperator->SetType(astFile->CvtType(expr.getType()));
+  return astConditionalOperator;
+}
+
+ASTExpr *ASTParser::ProcessExprCompoundAssignOperator(MapleAllocator &allocator,
+                                                      const clang::CompoundAssignOperator &expr) {
+  return  ProcessExprBinaryOperator(allocator, expr);
+}
+
+ASTExpr *ASTParser::ProcessExprSizeOfPackExpr(MapleAllocator &allocator, const clang::SizeOfPackExpr &expr) {
+  // CXX feature
+  (void)allocator;
+  (void)expr;
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ProcessExprUserDefinedLiteral(MapleAllocator &allocator, const clang::UserDefinedLiteral &expr) {
+  // CXX feature
+  (void)allocator;
+  (void)expr;
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ProcessExprTypeTraitExpr(MapleAllocator &allocator, const clang::TypeTraitExpr &expr) {
+  ASTIntegerLiteral *astIntegerLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  if (expr.getValue()) {
+    astIntegerLiteral->SetVal(1);
+  } else {
+    astIntegerLiteral->SetVal(0);
+  }
+  astIntegerLiteral->SetType(astFile->CvtType(expr.getType()));
+  return astIntegerLiteral;
+}
+
+ASTExpr *ASTParser::ProcessExprShuffleVectorExpr(MapleAllocator &allocator, const clang::ShuffleVectorExpr &expr) {
+  (void)allocator;
+  (void)expr;
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ProcessExprGNUNullExpr(MapleAllocator &allocator, const clang::GNUNullExpr &expr) {
+  (void)allocator;
+  (void)expr;
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ProcessExprConstantExpr(MapleAllocator &allocator, const clang::ConstantExpr &expr) {
+  ASTConstantExpr *astConstantExpr = ASTDeclsBuilder::ASTExprBuilder<ASTConstantExpr>(allocator);
+  ASSERT(astConstantExpr != nullptr, "astConstantExpr is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, expr.getSubExpr());
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astConstantExpr->SetASTExpr(astExpr);
+  return astConstantExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprImaginaryLiteral(MapleAllocator &allocator, const clang::ImaginaryLiteral &expr) {
+  clang::QualType complexQualType = expr.getType().getCanonicalType();
+  MIRType *complexType = astFile->CvtType(complexQualType);
+  CHECK_NULL_FATAL(complexType);
+  clang::QualType elemQualType = llvm::cast<clang::ComplexType>(complexQualType)->getElementType();
+  MIRType *elemType = astFile->CvtType(elemQualType);
+  CHECK_NULL_FATAL(elemType);
+  ASTImaginaryLiteral *astImaginaryLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTImaginaryLiteral>(allocator);
+  astImaginaryLiteral->SetComplexType(complexType);
+  astImaginaryLiteral->SetElemType(elemType);
+  ASTExpr *astExpr = ProcessExpr(allocator, expr.getSubExpr());
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astImaginaryLiteral->SetASTExpr(astExpr);
+  return astImaginaryLiteral;
+}
+
+std::map<std::string, ASTParser::FuncPtrBuiltinFunc> ASTParser::builtingFuncPtrMap =
+     ASTParser::InitBuiltinFuncPtrMap();
+
+ASTExpr *ASTParser::ProcessExprCallExpr(MapleAllocator &allocator, const clang::CallExpr &expr) {
+  ASTCallExpr *astCallExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCallExpr>(allocator);
+  ASSERT(astCallExpr != nullptr, "astCallExpr is nullptr");
+  // callee
+  ASTExpr *astCallee = ProcessExpr(allocator, expr.getCallee());
+  if (astCallee == nullptr) {
+    return nullptr;
+  }
+  astCallExpr->SetCalleeExpr(astCallee);
+  // return
+  astCallExpr->SetType(astFile->CvtType(expr.getType()));
+  // return var attrs
+  GenericAttrs returnVarAttrs;
+  astFile->CollectFuncReturnVarAttrs(expr, returnVarAttrs);
+  astCallExpr->SetReturnVarAttrs(returnVarAttrs);
+  // args
+  MapleVector<ASTExpr*> args(allocator.Adapter());
+  for (uint32_t i = 0; i < expr.getNumArgs(); ++i) {
+    const clang::Expr *subExpr = expr.getArg(i);
+    ASTExpr *arg = ProcessExpr(allocator, subExpr);
+    arg->SetType(astFile->CvtType(subExpr->getType()));
+    args.push_back(arg);
+  }
+  astCallExpr->SetArgs(args);
+  // Obtain the function name directly
+  const clang::FunctionDecl *funcDecl = expr.getDirectCallee();
+  if (funcDecl != nullptr) {
+    std::string funcName = astFile->GetMangledName(*funcDecl);
+    funcName = astCallExpr->CvtBuiltInFuncName(funcName);
+    if (!ASTUtil::IsValidName(funcName)) {
+      ASTUtil::AdjustName(funcName);
+    }
+
+    if (builtingFuncPtrMap.find(funcName) != builtingFuncPtrMap.end()) {
+      static std::stringstream ss;
+      ss.clear();
+      ss.str(std::string());
+      ss << funcName;
+      ASTExpr *builtinFuncExpr = ParseBuiltinFunc(allocator, expr, ss);
+      if (builtinFuncExpr != nullptr) {
+        return builtinFuncExpr;
+      }
+      funcName = ss.str();
+    }
+
+    GenericAttrs attrs = SolveFunctionAttributes(*funcDecl, funcName);
+    astCallExpr->SetFuncName(funcName);
+    astCallExpr->SetFuncAttrs(attrs.ConvertToFuncAttrs());
+    ASTFunc *astFunc = static_cast<ASTFunc*>(ProcessDecl(allocator, *funcDecl));
+    if (astFunc != nullptr) {
+      astCallExpr->SetFuncDecl(astFunc);
+    }
+  } else {
+    astCallExpr->SetIcall(true);
+  }
+  return astCallExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprParenExpr(MapleAllocator &allocator, const clang::ParenExpr &expr) {
+  ASTParenExpr *astParenExpr = ASTDeclsBuilder::ASTExprBuilder<ASTParenExpr>(allocator);
+  ASSERT(astParenExpr != nullptr, "astParenExpr is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, expr.getSubExpr());
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astParenExpr->SetEvaluatedFlag(astExpr->GetEvaluatedFlag());
+  astParenExpr->SetASTExpr(astExpr);
+  return astParenExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprCharacterLiteral(MapleAllocator &allocator, const clang::CharacterLiteral &expr) {
+  ASTCharacterLiteral *astCharacterLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTCharacterLiteral>(allocator);
+  ASSERT(astCharacterLiteral != nullptr, "astCharacterLiteral is nullptr");
+  const clang::QualType qualType = expr.getType();
+  const auto *type = llvm::cast<clang::BuiltinType>(qualType.getTypePtr());
+  clang::BuiltinType::Kind kind = type->getKind();
+  if (qualType->isPromotableIntegerType()) {
+    kind = clang::BuiltinType::Int;
+  }
+  PrimType primType = PTY_i32;
+  switch (kind) {
+    case clang::BuiltinType::UInt:
+      primType = PTY_u32;
+      break;
+    case clang::BuiltinType::Int:
+      primType = PTY_i32;
+      break;
+    case clang::BuiltinType::ULong:
+    case clang::BuiltinType::ULongLong:
+      primType = PTY_u64;
+      break;
+    case clang::BuiltinType::Long:
+    case clang::BuiltinType::LongLong:
+      primType = PTY_i64;
+      break;
+    default:
+      break;
+  }
+  astCharacterLiteral->SetVal(expr.getValue());
+  astCharacterLiteral->SetPrimType(primType);
+  return astCharacterLiteral;
+}
+
+ASTExpr *ASTParser::ProcessExprIntegerLiteral(MapleAllocator &allocator, const clang::IntegerLiteral &expr) {
+  ASTIntegerLiteral *astIntegerLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  ASSERT(astIntegerLiteral != nullptr, "astIntegerLiteral is nullptr");
+  MIRType *type = nullptr;
+  llvm::APInt api = expr.getValue();
+  int64 val = api.getSExtValue();
+  if (api.getBitWidth() > kInt32Width) {
+    type = expr.getType()->isSignedIntegerOrEnumerationType() ?
+           GlobalTables::GetTypeTable().GetInt64() : GlobalTables::GetTypeTable().GetUInt64();
+  } else {
+    type = expr.getType()->isSignedIntegerOrEnumerationType() ?
+           GlobalTables::GetTypeTable().GetInt32() : GlobalTables::GetTypeTable().GetUInt32();
+  }
+  astIntegerLiteral->SetVal(val);
+  astIntegerLiteral->SetType(type);
+  return astIntegerLiteral;
+}
+
+ASTExpr *ASTParser::ProcessExprFloatingLiteral(MapleAllocator &allocator, const clang::FloatingLiteral &expr) {
+  ASTFloatingLiteral *astFloatingLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  ASSERT(astFloatingLiteral != nullptr, "astFloatingLiteral is nullptr");
+  llvm::APFloat apf = expr.getValue();
+  const llvm::fltSemantics &fltSem = expr.getSemantics();
+  double val = 0;
+  if (&fltSem == &llvm::APFloat::IEEEdouble()) {
+    val = static_cast<double>(apf.convertToDouble());
+    astFloatingLiteral->SetKind(FloatKind::F64);
+    astFloatingLiteral->SetVal(val);
+  } else if (&fltSem == &llvm::APFloat::IEEEsingle()) {
+    val = static_cast<double>(apf.convertToFloat());
+    astFloatingLiteral->SetKind(FloatKind::F32);
+    astFloatingLiteral->SetVal(val);
+  } else if (&fltSem == &llvm::APFloat::IEEEquad() || &fltSem == &llvm::APFloat::x87DoubleExtended()) {
+    bool losesInfo;
+    (void)apf.convert(llvm::APFloat::IEEEdouble(),
+                      llvm::APFloatBase::rmNearestTiesToAway,
+                      &losesInfo);
+    val = static_cast<double>(apf.convertToDouble());
+    astFloatingLiteral->SetKind(FloatKind::F64);
+    astFloatingLiteral->SetVal(val);
+  } else {
+    CHECK_FATAL(false, "unsupported floating literal");
+  }
+  return astFloatingLiteral;
+}
+
+ASTExpr *ASTParser::ProcessExprCastExpr(MapleAllocator &allocator, const clang::CastExpr &expr) {
+  ASTCastExpr *astCastExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCastExpr>(allocator);
+  CHECK_FATAL(astCastExpr != nullptr, "astCastExpr is nullptr");
+  MIRType *srcType = astFile->CvtType(expr.getSubExpr()->getType());
+  MIRType *toType = astFile->CvtType(expr.getType());
+  astCastExpr->SetSrcType(srcType);
+  astCastExpr->SetDstType(toType);
+
+  switch (expr.getCastKind()) {
+    case clang::CK_NoOp:
+    case clang::CK_ToVoid:
+      break;
+    case clang::CK_FunctionToPointerDecay:
+      astCastExpr->SetIsFunctionToPointerDecay(true);
+      break;
+    case clang::CK_LValueToRValue:
+      astCastExpr->SetRValue(true);
+      break;
+    case clang::CK_BitCast:
+      astCastExpr->SetBitCast(true);
+      break;
+    case clang::CK_ArrayToPointerDecay:
+      if (!(expr.getSubExpr()->getType()->isVariableArrayType() &&
+            expr.getSubExpr()->getStmtClass() == clang::Stmt::DeclRefExprClass)) {
+        astCastExpr->SetIsArrayToPointerDecay(true);  // vla as a pointer is not need to be addrof
+      }
+      break;
+    case clang::CK_BuiltinFnToFnPtr:
+      astCastExpr->SetBuilinFunc(true);
+      break;
+    case clang::CK_VectorSplat:
+      astCastExpr->SetVectorSplat(true);
+      CHECK_FATAL(expr.getType()->isVectorType(), "dst type must be vector type in VectorSplat");
+      break;
+    case clang::CK_NullToPointer:
+    case clang::CK_IntegralToPointer:
+    case clang::CK_FloatingToIntegral:
+    case clang::CK_IntegralToFloating:
+    case clang::CK_FloatingCast:
+    case clang::CK_IntegralCast:
+    case clang::CK_IntegralToBoolean:
+    case clang::CK_PointerToBoolean:
+    case clang::CK_FloatingToBoolean:
+    case clang::CK_PointerToIntegral:
+      astCastExpr->SetNeededCvt(true);
+      break;
+    case clang::CK_ToUnion:
+      astCastExpr->SetUnionCast(true);
+      break;
+    case clang::CK_IntegralRealToComplex:
+    case clang::CK_FloatingRealToComplex:
+    case clang::CK_IntegralComplexCast:
+    case clang::CK_FloatingComplexCast:
+    case clang::CK_IntegralComplexToFloatingComplex:
+    case clang::CK_FloatingComplexToIntegralComplex:
+    case clang::CK_FloatingComplexToReal:
+    case clang::CK_IntegralComplexToReal:
+    case clang::CK_FloatingComplexToBoolean:
+    case clang::CK_IntegralComplexToBoolean: {
+      clang::QualType qualType = expr.getType().getCanonicalType();
+      astCastExpr->SetComplexType(astFile->CvtType(qualType));
+      clang::QualType dstQualType = llvm::cast<clang::ComplexType>(qualType)->getElementType();
+      astCastExpr->SetDstType(astFile->CvtType(dstQualType));
+      astCastExpr->SetNeededCvt(true);
+      if (expr.getCastKind() == clang::CK_IntegralRealToComplex ||
+          expr.getCastKind() == clang::CK_FloatingRealToComplex) {
+        astCastExpr->SetComplexCastKind(true);
+        astCastExpr->SetSrcType(astFile->CvtType(expr.getSubExpr()->getType().getCanonicalType()));
+      } else {
+        clang::QualType subQualType = expr.getSubExpr()->getType().getCanonicalType();
+        clang::QualType srcQualType = llvm::cast<clang::ComplexType>(subQualType)->getElementType();
+        astCastExpr->SetSrcType(astFile->CvtType(srcQualType));
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "NIY");
+      return nullptr;
+  }
+  ASTExpr *astExpr = ProcessExpr(allocator, expr.getSubExpr());
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  astExpr->SetRValue(astCastExpr->IsRValue());
+  astCastExpr->SetEvaluatedFlag(astExpr->GetEvaluatedFlag());
+  astCastExpr->SetASTExpr(astExpr);
+  return astCastExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprImplicitCastExpr(MapleAllocator &allocator, const clang::ImplicitCastExpr &expr) {
+  return ProcessExprCastExpr(allocator, expr);
+}
+
+ASTExpr *ASTParser::ProcessExprDeclRefExpr(MapleAllocator &allocator, const clang::DeclRefExpr &expr) {
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  CHECK_FATAL(astRefExpr != nullptr, "astRefExpr is nullptr");
+  if (auto enumConst = llvm::dyn_cast<clang::EnumConstantDecl>(expr.getDecl())) {
+    const llvm::APSInt value = enumConst->getInitVal();
+    ASTIntegerLiteral *astIntegerLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+    astIntegerLiteral->SetVal(value.getExtValue());
+    astIntegerLiteral->SetType(astFile->CvtType(expr.getType()));
+    return astIntegerLiteral;
+  }
+  switch (expr.getStmtClass()) {
+    case clang::Stmt::DeclRefExprClass: {
+      ASTDecl *astDecl = ASTDeclsBuilder::GetASTDecl(expr.getDecl()->getCanonicalDecl()->getID());
+      if (astDecl == nullptr) {
+        astDecl = ProcessDecl(allocator, *(expr.getDecl()->getCanonicalDecl()));
+      }
+      astRefExpr->SetASTDecl(astDecl);
+      astRefExpr->SetType(astDecl->GetTypeDesc().front());
+      return astRefExpr;
+    }
+    default:
+      CHECK_FATAL(false, "NIY");
+      return nullptr;
+  }
+}
+
+ASTExpr *ASTParser::ProcessExprBinaryOperatorComplex(MapleAllocator &allocator, const clang::BinaryOperator &bo) {
+  ASTBinaryOperatorExpr *astBinOpExpr = AllocBinaryOperatorExpr(allocator, bo);
+  CHECK_FATAL(astBinOpExpr != nullptr, "astBinOpExpr is nullptr");
+  clang::QualType qualType = bo.getType();
+  astBinOpExpr->SetRetType(astFile->CvtType(qualType));
+  ASTExpr *astRExpr = ProcessExpr(allocator, bo.getRHS());
+  ASTExpr *astLExpr = ProcessExpr(allocator, bo.getLHS());
+  clang::QualType elementType = llvm::cast<clang::ComplexType>(
+      bo.getLHS()->getType().getCanonicalType())->getElementType();
+  MIRType *elementMirType = astFile->CvtType(elementType);
+  astBinOpExpr->SetComplexElementType(elementMirType);
+  auto *leftImage = ASTDeclsBuilder::ASTExprBuilder<ASTUOImagExpr>(allocator);
+  leftImage->SetUOExpr(astLExpr);
+  leftImage->SetElementType(elementMirType);
+  astBinOpExpr->SetComplexLeftImagExpr(leftImage);
+  auto *leftReal = ASTDeclsBuilder::ASTExprBuilder<ASTUORealExpr>(allocator);
+  leftReal->SetUOExpr(astLExpr);
+  leftReal->SetElementType(elementMirType);
+  astBinOpExpr->SetComplexLeftRealExpr(leftReal);
+  auto *rightImage = ASTDeclsBuilder::ASTExprBuilder<ASTUOImagExpr>(allocator);
+  rightImage->SetUOExpr(astRExpr);
+  rightImage->SetElementType(elementMirType);
+  astBinOpExpr->SetComplexRightImagExpr(rightImage);
+  auto *rightReal = ASTDeclsBuilder::ASTExprBuilder<ASTUORealExpr>(allocator);
+  rightReal->SetUOExpr(astRExpr);
+  rightReal->SetElementType(elementMirType);
+  astBinOpExpr->SetComplexRightRealExpr(rightReal);
+  return astBinOpExpr;
+}
+
+ASTExpr *ASTParser::SolvePointerOffsetOperation(MapleAllocator &allocator, const clang::BinaryOperator &bo,
+                                                ASTBinaryOperatorExpr &astBinOpExpr, ASTExpr &astRExpr,
+                                                ASTExpr &astLExpr) {
+  auto boType = bo.getType().getCanonicalType();
+  auto lhsType = bo.getLHS()->getType().getCanonicalType();
+  auto rhsType = bo.getRHS()->getType().getCanonicalType();
+  auto boMirType = astFile->CvtType(boType);
+  auto ptrType = lhsType->isPointerType() ? lhsType : rhsType;
+  auto astSizeExpr = lhsType->isPointerType() ? &astRExpr : &astLExpr;
+  if (ptrType->getPointeeType()->isVariableArrayType()) {
+    ASTExpr *vlaTypeSizeExpr = BuildExprToComputeSizeFromVLA(allocator, ptrType->getPointeeType());
+    astSizeExpr = GetSizeMulExpr(allocator, *astSizeExpr, *vlaTypeSizeExpr);
+  } else {
+    auto typeSize = GetSizeFromQualType(boType->getPointeeType());
+    MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(
+        static_cast<MIRPtrType*>(boMirType)->GetPointedTyIdx());
+    if (pointedType->GetPrimType() == PTY_f64) {
+      typeSize = 8; // 8 is f64 byte num, because now f128 also cvt to f64
+    }
+    astSizeExpr = GetAddrShiftExpr(allocator, *astSizeExpr, typeSize);
+  }
+  astBinOpExpr.SetCvtNeeded(false); // the type cannot be cvt.
+  return astSizeExpr;
+}
+
+ASTExpr *ASTParser::SolvePointerSubPointerOperation(MapleAllocator &allocator, const clang::BinaryOperator &bo,
+                                                    ASTBinaryOperatorExpr &astBinOpExpr) const {
+  auto rhsType = bo.getRHS()->getType().getCanonicalType();
+  auto ptrSizeExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  ptrSizeExpr->SetType(astBinOpExpr.GetRetType());
+  ptrSizeExpr->SetVal(GetSizeFromQualType(rhsType->getPointeeType()));
+  auto retASTExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  retASTExpr->SetLeftExpr(&astBinOpExpr);
+  retASTExpr->SetRightExpr(ptrSizeExpr);
+  retASTExpr->SetOpcode(OP_div);
+  retASTExpr->SetRetType(astBinOpExpr.GetRetType());
+  return retASTExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprBinaryOperator(MapleAllocator &allocator, const clang::BinaryOperator &bo) {
+  ASTBinaryOperatorExpr *astBinOpExpr = AllocBinaryOperatorExpr(allocator, bo);
+  CHECK_FATAL(astBinOpExpr != nullptr, "astBinOpExpr is nullptr");
+  auto boType = bo.getType().getCanonicalType();
+  auto lhsType = bo.getLHS()->getType().getCanonicalType();
+  auto rhsType = bo.getRHS()->getType().getCanonicalType();
+  auto leftMirType = astFile->CvtType(lhsType);
+  auto rightMirType = astFile->CvtType(rhsType);
+  auto clangOpCode = bo.getOpcode();
+  astBinOpExpr->SetRetType(astFile->CvtType(boType));
+  if (bo.isCompoundAssignmentOp()) {
+    clangOpCode = clang::BinaryOperator::getOpForCompoundAssignment(clangOpCode);
+    clang::QualType res = llvm::cast<clang::CompoundAssignOperator>(bo).getComputationLHSType().getCanonicalType();
+    astBinOpExpr->SetRetType(astFile->CvtType(res));
+  }
+  if ((boType->isAnyComplexType() &&
+       (clang::BinaryOperator::isAdditiveOp(clangOpCode) || clang::BinaryOperator::isMultiplicativeOp(clangOpCode))) ||
+      (clang::BinaryOperator::isEqualityOp(clangOpCode) && lhsType->isAnyComplexType() &&
+       rhsType->isAnyComplexType())) {
+    return ProcessExprBinaryOperatorComplex(allocator, bo);
+  }
+  ASTExpr *astRExpr = ProcessExpr(allocator, bo.getRHS());
+  ASTExpr *astLExpr = ProcessExpr(allocator, bo.getLHS());
+  ASSERT_NOT_NULL(astRExpr);
+  ASSERT_NOT_NULL(astLExpr);
+  if (clangOpCode == clang::BO_Div || clangOpCode == clang::BO_Mul ||
+      clangOpCode == clang::BO_DivAssign || clangOpCode == clang::BO_MulAssign) {
+    if (astBinOpExpr->GetRetType()->GetPrimType() == PTY_u16 || astBinOpExpr->GetRetType()->GetPrimType() == PTY_u8) {
+      astBinOpExpr->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_u32));
+    }
+    if (astBinOpExpr->GetRetType()->GetPrimType() == PTY_i16 || astBinOpExpr->GetRetType()->GetPrimType() == PTY_i8) {
+      astBinOpExpr->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+    }
+  }
+  if ((leftMirType->GetPrimType() != astBinOpExpr->GetRetType()->GetPrimType() ||
+       rightMirType->GetPrimType() != astBinOpExpr->GetRetType()->GetPrimType()) &&
+      (clang::BinaryOperator::isAdditiveOp(clangOpCode) || clang::BinaryOperator::isMultiplicativeOp(clangOpCode))) {
+    astBinOpExpr->SetCvtNeeded(true);
+  }
+  // ptr +/-
+  if (boType->isPointerType() && clang::BinaryOperator::isAdditiveOp(clangOpCode) &&
+      ((lhsType->isPointerType() && rhsType->isIntegerType()) ||
+       (lhsType->isIntegerType() && rhsType->isPointerType())) &&
+      !boType->isVoidPointerType() && GetSizeFromQualType(boType->getPointeeType()) != 1) {
+    ASTExpr *astSizeExpr = SolvePointerOffsetOperation(allocator, bo, *astBinOpExpr, *astRExpr, *astLExpr);
+    if (lhsType->isPointerType()) {
+      astRExpr = astSizeExpr;
+    } else {
+      astLExpr = astSizeExpr;
+    }
+  }
+  astBinOpExpr->SetLeftExpr(astLExpr);
+  astBinOpExpr->SetRightExpr(astRExpr);
+  // ptr - ptr
+  if (clangOpCode == clang::BO_Sub && rhsType->isPointerType() &&
+      lhsType->isPointerType() && !rhsType->isVoidPointerType() &&
+      GetSizeFromQualType(rhsType->getPointeeType()) != 1) {
+    astBinOpExpr = static_cast<ASTBinaryOperatorExpr*>(SolvePointerSubPointerOperation(allocator, bo, *astBinOpExpr));
+  }
+  if (bo.isCompoundAssignmentOp()) {
+    auto assignExpr = ASTDeclsBuilder::ASTExprBuilder<ASTAssignExpr>(allocator);
+    assignExpr->SetLeftExpr(astLExpr);
+    assignExpr->SetRightExpr(astBinOpExpr);
+    assignExpr->SetRetType(astBinOpExpr->GetRetType());
+    assignExpr->SetIsCompoundAssign(true);
+    return assignExpr;
+  }
+  return astBinOpExpr;
+}
+
+ASTDecl *ASTParser::GetAstDeclOfDeclRefExpr(MapleAllocator &allocator, const clang::Expr &expr) {
+  switch (expr.getStmtClass()) {
+    case clang::Stmt::DeclRefExprClass:
+      return static_cast<ASTDeclRefExpr*>(ProcessExpr(allocator, &expr))->GetASTDecl();
+    case clang::Stmt::ImplicitCastExprClass:
+    case clang::Stmt::CXXStaticCastExprClass:
+    case clang::Stmt::CXXReinterpretCastExprClass:
+    case clang::Stmt::CStyleCastExprClass:
+      return GetAstDeclOfDeclRefExpr(allocator, *llvm::cast<clang::CastExpr>(expr).getSubExpr());
+    case clang::Stmt::ParenExprClass:
+      return GetAstDeclOfDeclRefExpr(allocator, *llvm::cast<clang::ParenExpr>(expr).getSubExpr());
+    case clang::Stmt::UnaryOperatorClass:
+      return GetAstDeclOfDeclRefExpr(allocator, *llvm::cast<clang::UnaryOperator>(expr).getSubExpr());
+    case clang::Stmt::ConstantExprClass:
+      return GetAstDeclOfDeclRefExpr(allocator, *llvm::cast<clang::ConstantExpr>(expr).getSubExpr());
+    default:
+      break;
+  }
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ProcessExprCStyleCastExpr(MapleAllocator &allocator, const clang::CStyleCastExpr &castExpr) {
+  return ProcessExprCastExpr(allocator, castExpr);
+}
+
+ASTExpr *ASTParser::ProcessExprArrayInitLoopExpr(MapleAllocator &allocator,
+                                                 const clang::ArrayInitLoopExpr &arrInitLoopExpr) {
+  ASTArrayInitLoopExpr *astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTArrayInitLoopExpr>(allocator);
+  CHECK_FATAL(astExpr != nullptr, "astCastExpr is nullptr");
+  ASTExpr *common = arrInitLoopExpr.getCommonExpr() == nullptr ? nullptr :
+      ProcessExpr(allocator, arrInitLoopExpr.getCommonExpr());
+  astExpr->SetCommonExpr(common);
+  return astExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprArrayInitIndexExpr(MapleAllocator &allocator,
+                                                  const clang::ArrayInitIndexExpr &arrInitIndexExpr) {
+  ASTArrayInitIndexExpr *astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTArrayInitIndexExpr>(allocator);
+  CHECK_FATAL(astExpr != nullptr, "astCastExpr is nullptr");
+  astExpr->SetPrimType(astFile->CvtType(arrInitIndexExpr.getType()));
+  astExpr->SetValueStr("0");
+  return astExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprAtomicExpr(MapleAllocator &allocator,
+                                          const clang::AtomicExpr &atomicExpr) {
+  ASTAtomicExpr *astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTAtomicExpr>(allocator);
+  CHECK_FATAL(astExpr != nullptr, "astCastExpr is nullptr");
+  astExpr->SetObjExpr(ProcessExpr(allocator, atomicExpr.getPtr()));
+  astExpr->SetType(astFile->CvtType(atomicExpr.getPtr()->getType()));
+  astExpr->SetRefType(astFile->CvtType(atomicExpr.getPtr()->getType()->getPointeeType()));
+  if (atomicExpr.getOp() != clang::AtomicExpr::AO__atomic_load_n) {
+    astExpr->SetValExpr1(ProcessExpr(allocator, atomicExpr.getVal1()));
+    astExpr->SetVal1Type(astFile->CvtType(atomicExpr.getVal1()->getType()));
+  }
+  if (atomicExpr.getOp() == clang::AtomicExpr::AO__atomic_exchange) {
+    astExpr->SetValExpr2(ProcessExpr(allocator, atomicExpr.getVal2()));
+    astExpr->SetVal2Type(astFile->CvtType(atomicExpr.getVal2()->getType()));
+  }
+  astExpr->SetOrderExpr(ProcessExpr(allocator, atomicExpr.getOrder()));
+
+  static std::unordered_map<clang::AtomicExpr::AtomicOp, ASTAtomicOp> astOpMap = {
+    {clang::AtomicExpr::AO__atomic_load_n, kAtomicOpLoadN},
+    {clang::AtomicExpr::AO__atomic_load, kAtomicOpLoad},
+    {clang::AtomicExpr::AO__atomic_store_n, kAtomicOpStoreN},
+    {clang::AtomicExpr::AO__atomic_store, kAtomicOpStore},
+    {clang::AtomicExpr::AO__atomic_exchange, kAtomicOpExchange},
+    {clang::AtomicExpr::AO__atomic_exchange_n, kAtomicOpExchangeN},
+    {clang::AtomicExpr::AO__atomic_add_fetch, kAtomicOpAddFetch},
+    {clang::AtomicExpr::AO__atomic_sub_fetch, kAtomicOpSubFetch},
+    {clang::AtomicExpr::AO__atomic_and_fetch, kAtomicOpAndFetch},
+    {clang::AtomicExpr::AO__atomic_xor_fetch, kAtomicOpXorFetch},
+    {clang::AtomicExpr::AO__atomic_or_fetch, kAtomicOpOrFetch},
+    {clang::AtomicExpr::AO__atomic_fetch_add, kAtomicOpFetchAdd},
+    {clang::AtomicExpr::AO__atomic_fetch_sub, kAtomicOpFetchSub},
+    {clang::AtomicExpr::AO__atomic_fetch_and, kAtomicOpFetchAnd},
+    {clang::AtomicExpr::AO__atomic_fetch_xor, kAtomicOpFetchXor},
+    {clang::AtomicExpr::AO__atomic_fetch_or, kAtomicOpFetchOr},
+  };
+  ASSERT(astOpMap.find(atomicExpr.getOp()) != astOpMap.end(), "%s:%d error: atomic expr op not supported!",
+      FEManager::GetModule().GetFileNameFromFileNum(astFile->GetLOC(atomicExpr.getBuiltinLoc()).fileIdx).c_str(),
+      astFile->GetLOC(atomicExpr.getBuiltinLoc()).line);
+  astExpr->SetAtomicOp(astOpMap[atomicExpr.getOp()]);
+  return astExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprExprWithCleanups(MapleAllocator &allocator,
+                                                const clang::ExprWithCleanups &cleanupsExpr) {
+  ASTExprWithCleanups *astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTExprWithCleanups>(allocator);
+  CHECK_FATAL(astExpr != nullptr, "astCastExpr is nullptr");
+  ASTExpr *sub = cleanupsExpr.getSubExpr() == nullptr ? nullptr : ProcessExpr(allocator, cleanupsExpr.getSubExpr());
+  astExpr->SetSubExpr(sub);
+  return astExpr;
+}
+
+ASTExpr *ASTParser::ProcessExprMaterializeTemporaryExpr(MapleAllocator &allocator,
+                                                        const clang::MaterializeTemporaryExpr &matTempExpr) {
+  // cxx feature
+  (void)allocator;
+  (void)matTempExpr;
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ProcessExprSubstNonTypeTemplateParmExpr(MapleAllocator &allocator,
+                                                            const clang::SubstNonTypeTemplateParmExpr &subTempExpr) {
+  // cxx feature
+  (void)allocator;
+  (void)subTempExpr;
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ProcessExprDependentScopeDeclRefExpr(MapleAllocator &allocator,
+                                                         const clang::DependentScopeDeclRefExpr &depScopeExpr) {
+  // cxx feature
+  (void)allocator;
+  (void)depScopeExpr;
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ProcessExprChooseExpr(MapleAllocator &allocator, const clang::ChooseExpr &chs) {
+  return ProcessExpr(allocator, chs.getChosenSubExpr());
+}
+
+ASTExpr *ASTParser::ProcessExprGenericSelectionExpr(MapleAllocator &allocator, const clang::GenericSelectionExpr &gse) {
+  return ProcessExpr(allocator, gse.getResultExpr());
+}
+
+bool ASTParser::PreProcessAST() {
+  TraverseDecl(astUnitDecl, [this](clang::Decl *child) {
+    ASSERT_NOT_NULL(child);
+    switch (child->getKind()) {
+      case clang::Decl::Var: {
+        globalVarDecles.emplace_back(child);
+        break;
+      }
+      case clang::Decl::Function: {
+        funcDecles.emplace_back(child);
+        break;
+      }
+      case clang::Decl::Record: {
+        recordDecles.emplace_back(child);
+        break;
+      }
+      case clang::Decl::Typedef:
+        globalTypeDefDecles.emplace_back(child);
+        break;
+      case clang::Decl::Enum:
+        globalEnumDecles.emplace_back(child);
+        break;
+      case clang::Decl::FileScopeAsm:
+        globalFileScopeAsm.emplace_back(child);
+        break;
+      case clang::Decl::Empty:
+      case clang::Decl::StaticAssert:
+        break;
+      default: {
+        WARN(kLncWarn, "Unsupported decl kind: %u", child->getKind());
+      }
+    }
+  });
+  return true;
+}
+
+#define DECL_CASE(CLASS)                                                                                  \
+  case clang::Decl::CLASS: {                                                                              \
+    ASTDecl *astDeclaration = ProcessDecl##CLASS##Decl(allocator, llvm::cast<clang::CLASS##Decl>(decl));  \
+    if (astDeclaration != nullptr) {                                                                      \
+      astDeclaration->SetGlobal(decl.isDefinedOutsideFunctionOrMethod());                                 \
+      if (astDeclaration->GetSrcFileIdx() == 0) {                                                         \
+        Loc loc = astFile->GetLOC(decl.getLocation());                                                    \
+        astDeclaration->SetSrcLoc(loc);                                                                   \
+      }                                                                                                   \
+    }                                                                                                     \
+    return astDeclaration;                                                                                \
+  }
+ASTDecl *ASTParser::ProcessDecl(MapleAllocator &allocator, const clang::Decl &decl) {
+  ASTDecl *astDecl = ASTDeclsBuilder::GetASTDecl(decl.getID());
+  if (astDecl != nullptr) {
+    return astDecl;
+  }
+  switch (decl.getKind()) {
+    DECL_CASE(Function);
+    DECL_CASE(Field);
+    DECL_CASE(Record);
+    DECL_CASE(Var);
+    DECL_CASE(ParmVar);
+    DECL_CASE(Enum);
+    DECL_CASE(Typedef);
+    DECL_CASE(EnumConstant);
+    DECL_CASE(Label);
+    DECL_CASE(StaticAssert);
+    DECL_CASE(FileScopeAsm);
+    default:
+      CHECK_FATAL(false, "ASTDecl: %s NIY", decl.getDeclKindName());
+      return nullptr;
+  }
+}
+
+ASTDecl *ASTParser::ProcessDeclStaticAssertDecl(MapleAllocator &allocator, const clang::StaticAssertDecl &assertDecl) {
+  (void)allocator;
+  (void)assertDecl;
+  return nullptr;
+}
+
+ASTDecl *ASTParser::ProcessDeclRecordDecl(MapleAllocator &allocator, const clang::RecordDecl &recDecl) {
+  ASTStruct *curStructOrUnion = static_cast<ASTStruct*>(ASTDeclsBuilder::GetASTDecl(recDecl.getID()));
+  if (curStructOrUnion != nullptr) {
+    return curStructOrUnion;
+  }
+  std::stringstream recName;
+  clang::QualType qType = recDecl.getTypeForDecl()->getCanonicalTypeInternal();
+  astFile->EmitTypeName(*qType->getAs<clang::RecordType>(), recName);
+  MIRType *recType = astFile->CvtType(qType);
+  if (recType == nullptr) {
+    return nullptr;
+  }
+  GenericAttrs attrs;
+  astFile->CollectRecordAttrs(recDecl, attrs);
+  std::string structName = recName.str();
+  curStructOrUnion = ASTDeclsBuilder::ASTStructBuilder(allocator,
+                                                       fileName,
+                                                       structName,
+                                                       MapleVector<MIRType*>({recType}, allocator.Adapter()),
+                                                       attrs,
+                                                       recDecl.getID());
+  if (recDecl.isUnion()) {
+    curStructOrUnion->SetIsUnion();
+  }
+  const auto *declContext = llvm::dyn_cast<clang::DeclContext>(&recDecl);
+  if (declContext == nullptr) {
+    return nullptr;
+  }
+  for (auto *loadDecl : declContext->decls()) {
+    if (loadDecl == nullptr) {
+      return nullptr;
+    }
+    auto *fieldDecl = llvm::dyn_cast<clang::FieldDecl>(loadDecl);
+    if (llvm::isa<clang::RecordDecl>(loadDecl)) {
+      clang::RecordDecl *subRecordDecl = llvm::cast<clang::RecordDecl>(loadDecl->getCanonicalDecl());
+      ASTStruct *sub = static_cast<ASTStruct*>(ProcessDecl(allocator, *subRecordDecl));
+      if (sub == nullptr) {
+        return nullptr;
+      }
+    }
+
+    if (llvm::isa<clang::FieldDecl>(loadDecl)) {
+      ASTField *af = static_cast<ASTField*>(ProcessDecl(allocator, *fieldDecl));
+      if (af == nullptr) {
+        return nullptr;
+      }
+      curStructOrUnion->SetField(af);
+    }
+  }
+  if (!recDecl.isDefinedOutsideFunctionOrMethod()) {
+    // Record function scope type decl in global with unique suffix identified
+    auto itor = std::find(astStructs.cbegin(), astStructs.cend(), curStructOrUnion);
+    if (itor == astStructs.end()) {
+      astStructs.emplace_back(curStructOrUnion);
+    }
+  }
+  ProcessBoundaryFieldAttrs(allocator, *curStructOrUnion, recDecl);
+  return curStructOrUnion;
+}
+
+MapleVector<ASTDecl*> ASTParser::SolveFuncParameterDecls(MapleAllocator &allocator,
+                                                         const clang::FunctionDecl &funcDecl,
+                                                         MapleVector<MIRType*> &typeDescIn,
+                                                         std::list<ASTStmt*> &stmts) {
+  MapleVector<ASTDecl*> paramDecls(allocator.Adapter());
+  unsigned int numParam = funcDecl.getNumParams();
+  for (uint32_t i = 0; i < numParam; ++i) {
+    const clang::ParmVarDecl *parmDecl = funcDecl.getParamDecl(i);
+    std::list<ASTExpr*> astExprs;
+    SaveVLASizeExpr(allocator, parmDecl->getOriginalType(), astExprs);
+    ASTStmtDummy *stmt = ASTDeclsBuilder::ASTStmtBuilder<ASTStmtDummy>(allocator);
+    for (auto expr : std::as_const(astExprs)) {
+      stmt->SetASTExpr(expr);
+    }
+    (void)stmts.emplace_back(stmt);
+    ASTDecl *parmVarDecl = ProcessDecl(allocator, *parmDecl);
+    ASSERT_NOT_NULL(parmVarDecl);
+    paramDecls.push_back(parmVarDecl);
+    typeDescIn.push_back(parmVarDecl->GetTypeDesc().front());
+  }
+  return paramDecls;
+}
+
+GenericAttrs ASTParser::SolveFunctionAttributes(const clang::FunctionDecl &funcDecl, std::string &funcName) const {
+  GenericAttrs attrs;
+  astFile->CollectFuncAttrs(funcDecl, attrs, kPublic);
+  // for inline optimize
+  if (attrs.GetAttr(GENATTR_static) && FEOptions::GetInstance().GetFuncInlineSize() != 0) {
+    funcName = funcName + astFile->GetAstFileNameHashStr();
+  }
+
+  // set inline functions as weak symbols as it's in C++
+  if (opts::inlineAsWeak == true && attrs.GetAttr(GENATTR_inline) && !attrs.GetAttr(GENATTR_static)) {
+    attrs.SetAttr(GENATTR_weak);
+  }
+
+  return attrs;
+}
+
+ASTStmt *ASTParser::SolveFunctionBody(MapleAllocator &allocator,
+                                      const clang::FunctionDecl &funcDecl,
+                                      ASTFunc &astFunc, const std::list<ASTStmt*> &stmts) {
+  ASTStmt *astCompoundStmt = ProcessStmt(allocator, *llvm::cast<clang::CompoundStmt>(funcDecl.getBody()));
+  if (astCompoundStmt != nullptr) {
+    astFunc.SetCompoundStmt(astCompoundStmt);
+    astFunc.InsertStmtsIntoCompoundStmtAtFront(stmts);
+  } else {
+    return nullptr;
+  }
+  return astCompoundStmt;
+}
+
+ASTDecl *ASTParser::ProcessDeclFunctionDecl(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl) {
+  ASTFunc *astFunc = static_cast<ASTFunc*>(ASTDeclsBuilder::GetASTDecl(funcDecl.getID()));
+  if (astFunc != nullptr) {
+    return astFunc;
+  }
+  std::string funcName = astFile->GetMangledName(funcDecl);
+  if (funcName.empty()) {
+    return nullptr;
+  }
+  if (!ASTUtil::IsValidName(funcName)) {
+    ASTUtil::AdjustName(funcName);
+  }
+  MapleVector<MIRType*> typeDescIn(allocator.Adapter());
+  clang::QualType funcQualType = funcDecl.getType();
+  MIRType *mirFuncType = astFile->CvtType(funcQualType);
+  typeDescIn.push_back(mirFuncType);
+  clang::QualType qualType = funcDecl.getReturnType();
+  MIRType *retType = astFile->CvtType(qualType);
+  if (retType == nullptr) {
+    return nullptr;
+  }
+  typeDescIn.push_back(retType);
+
+  std::list<ASTStmt*> implicitStmts;
+  MapleVector<ASTDecl*> paramDecls = SolveFuncParameterDecls(allocator, funcDecl, typeDescIn, implicitStmts);
+  GenericAttrs attrs = SolveFunctionAttributes(funcDecl, funcName);
+  astFunc = ASTDeclsBuilder::ASTFuncBuilder(
+      allocator, fileName, funcName, typeDescIn, attrs, paramDecls, funcDecl.getID());
+  CHECK_FATAL(astFunc != nullptr, "astFunc is nullptr");
+  clang::SectionAttr *sa = funcDecl.getAttr<clang::SectionAttr>();
+  if (sa != nullptr && !sa->isImplicit()) {
+    astFunc->SetSectionAttr(sa->getName().str());
+  }
+  // collect EnhanceC func attr
+  ProcessNonnullFuncAttrs(funcDecl, *astFunc);
+  ProcessBoundaryFuncAttrs(allocator, funcDecl, *astFunc);
+  ProcessBoundaryParamAttrs(allocator, funcDecl, *astFunc);
+  clang::WeakRefAttr *weakrefAttr = funcDecl.getAttr<clang::WeakRefAttr>();
+  if (weakrefAttr != nullptr) {
+    astFunc->SetWeakrefAttr(std::pair<bool, std::string>{true, weakrefAttr->getAliasee().str()});
+  }
+  if (funcDecl.hasBody()) {
+    if (SolveFunctionBody(allocator, funcDecl, *astFunc, implicitStmts) == nullptr) {
+      return nullptr;
+    }
+  }
+  return astFunc;
+}
+
+void ASTParser::ProcessNonnullFuncAttrs(const clang::FunctionDecl &funcDecl, ASTFunc &astFunc) const {
+  if (funcDecl.hasAttr<clang::ReturnsNonNullAttr>()) {
+    astFunc.SetAttr(GENATTR_nonnull);
+  }
+  for (const auto *nonNull : funcDecl.specific_attrs<clang::NonNullAttr>()) {
+    if (nonNull->args_size() == 0) {
+      // Lack of attribute parameters means that all of the pointer parameters are
+      // implicitly marked as nonnull.
+      for (auto paramDecl : astFunc.GetParamDecls()) {
+        if (paramDecl->GetTypeDesc().front()->IsMIRPtrType()) {
+          paramDecl->SetAttr(GENATTR_nonnull);
+        }
+      }
+      break;
+    }
+    for (const clang::ParamIdx &paramIdx : nonNull->args()) {
+      // The clang ensures that nonnull attribute only applies to pointer parameter
+      unsigned int idx = paramIdx.getASTIndex();
+      if (idx >= astFunc.GetParamDecls().size()) {
+        continue;
+      }
+      astFunc.GetParamDecls()[idx]->SetAttr(GENATTR_nonnull);
+    }
+  }
+}
+
+ASTDecl *ASTParser::ProcessDeclFieldDecl(MapleAllocator &allocator, const clang::FieldDecl &decl) {
+  ASTField *astField = static_cast<ASTField*>(ASTDeclsBuilder::GetASTDecl(decl.getID()));
+  if (astField != nullptr) {
+    return astField;
+  }
+  clang::QualType qualType = decl.getType();
+  std::string fieldName = astFile->GetMangledName(decl);
+  bool isAnonymousField = false;
+  if (fieldName.empty()) {
+    isAnonymousField = true;
+    fieldName = astFile->GetOrCreateMappedUnnamedName(decl);
+  }
+  CHECK_FATAL(!fieldName.empty(), "fieldName is empty");
+  MIRType *fieldType = astFile->CvtType(qualType);
+  if (fieldType == nullptr) {
+    return nullptr;
+  }
+  if (decl.isBitField()) {
+    unsigned bitSize = decl.getBitWidthValue(*(astFile->GetContext()));
+    MIRBitFieldType mirBFType(static_cast<uint8>(bitSize), fieldType->GetPrimType());
+    auto bfTypeIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&mirBFType);
+    fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(bfTypeIdx);
+  }
+  GenericAttrs attrs;
+  astFile->CollectFieldAttrs(decl, attrs, kNone);
+  // one elem vector type
+  if (LibAstFile::IsOneElementVector(qualType)) {
+    attrs.SetAttr(GENATTR_oneelem_simd);
+  }
+  auto fieldDecl = ASTDeclsBuilder::ASTFieldBuilder(
+      allocator, fileName, fieldName, MapleVector<MIRType*>({fieldType}, allocator.Adapter()),
+      attrs, decl.getID(), isAnonymousField);
+  clang::CharUnits alignment = astFile->GetContext()->getDeclAlign(&decl);
+  clang::CharUnits unadjust = astFile->GetContext()->toCharUnitsFromBits(
+      astFile->GetContext()->getTypeUnadjustedAlign(qualType));
+  uint32 maxAlign = std::max(alignment.getQuantity(), unadjust.getQuantity());
+  fieldDecl->SetAlign(maxAlign);
+  const auto *valueDecl = llvm::dyn_cast<clang::ValueDecl>(&decl);
+  if (valueDecl != nullptr) {
+    ProcessNonnullFuncPtrAttrs(allocator, *valueDecl, *fieldDecl);
+    ProcessBoundaryFuncPtrAttrs(allocator, *valueDecl, *fieldDecl);
+  }
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    MIRType *sourceType = astFile->CvtSourceType(qualType);
+    fieldDecl->SetSourceType(sourceType);
+  }
+  return fieldDecl;
+}
+
+void ASTParser::SetInitExprForASTVar(MapleAllocator &allocator, const clang::VarDecl &varDecl,
+                                     const GenericAttrs &attrs, ASTVar &astVar) {
+  bool isStaticStorageVar = (varDecl.getStorageDuration() == clang::SD_Static || attrs.GetAttr(GENATTR_tls_static));
+  astVar.SetSrcLoc(astFile->GetLOC(varDecl.getLocation()));
+  auto initExpr = varDecl.getInit();
+  auto astInitExpr = ProcessExpr(allocator, initExpr);
+  ASSERT_NOT_NULL(astInitExpr);
+  if (initExpr->getStmtClass() == clang::Stmt::InitListExprClass && astInitExpr->GetASTOp() == kASTOpInitListExpr) {
+    static_cast<ASTInitListExpr*>(astInitExpr)->SetInitListVarName(astVar.GenerateUniqueVarName());
+  }
+  EvaluatedFlag flag = astInitExpr->GetEvaluatedFlag();
+  // For thoese global and static local variables initialized with zero or the init list only
+  // has zero, they won't be set initExpr and will be stored into .bss section instead of .data section
+  // to reduce code size.
+  if (!isStaticStorageVar || flag != kEvaluatedAsZero) {
+    astVar.SetInitExpr(astInitExpr);
+  } else {
+    astVar.SetAttr(GENATTR_static_init_zero); // used to distinguish with uninitialized vars
+  }
+}
+
+void ASTParser::SetAlignmentForASTVar(const clang::VarDecl &varDecl, ASTVar &astVar) const {
+  int64 naturalAlignment = astFile->GetContext()->toCharUnitsFromBits(
+      astFile->GetContext()->getTypeUnadjustedAlign(varDecl.getType())).getQuantity();
+  // Get alignment from the decl
+  uint32 alignmentBits = varDecl.getMaxAlignment();
+  if (alignmentBits != 0) {
+    uint32 alignment = alignmentBits / 8;
+    if (alignment > naturalAlignment) {
+      astVar.SetAlign(alignment);
+    }
+  }
+  // Get alignment from the type
+  alignmentBits = astFile->GetContext()->getTypeAlignIfKnown(varDecl.getType());
+  if (alignmentBits != 0) {
+    uint32 alignment = alignmentBits / 8;
+    if (alignment > astVar.GetAlign() && alignment > naturalAlignment) {
+      astVar.SetAlign(alignment);
+    }
+  }
+}
+
+ASTDecl *ASTParser::ProcessDeclVarDecl(MapleAllocator &allocator, const clang::VarDecl &varDecl) {
+  ASTVar *astVar = static_cast<ASTVar*>(ASTDeclsBuilder::GetASTDecl(varDecl.getID()));
+  if (astVar != nullptr) {
+    return astVar;
+  }
+  std::string varName = astFile->GetMangledName(varDecl);
+  if (varName.empty()) {
+    return nullptr;
+  }
+  clang::QualType qualType = varDecl.getType();
+  MIRType *varType = astFile->CvtType(qualType);
+  if (varType == nullptr) {
+    return nullptr;
+  }
+  GenericAttrs attrs;
+  astFile->CollectVarAttrs(varDecl, attrs, kNone);
+  // for inline optimize
+  if (attrs.GetAttr(GENATTR_static) && FEOptions::GetInstance().GetFuncInlineSize() != 0) {
+    varName = varName + astFile->GetAstFileNameHashStr();
+  }
+  if (varType->IsMIRIncompleteStructType() && !attrs.GetAttr(GENATTR_extern)) {
+    FE_ERR(kLncErr, astFile->GetLOC(varDecl.getLocation()), "tentative definition of variable '%s' has incomplete"
+        " struct type 'struct '%s''", varName.c_str(), varType->GetName().c_str());
+  }
+  astVar = ASTDeclsBuilder::ASTVarBuilder(
+      allocator, fileName, varName, MapleVector<MIRType*>({varType}, allocator.Adapter()), attrs, varDecl.getID());
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    MIRType *sourceType = astFile->CvtSourceType(qualType);
+    astVar->SetSourceType(sourceType);
+  }
+  astVar->SetIsMacro(varDecl.getLocation().isMacroID());
+  clang::SectionAttr *sa = varDecl.getAttr<clang::SectionAttr>();
+  if (sa != nullptr && !sa->isImplicit()) {
+    astVar->SetSectionAttr(sa->getName().str());
+  }
+  clang::AsmLabelAttr *ala = varDecl.getAttr<clang::AsmLabelAttr>();
+  if (ala != nullptr) {
+    astVar->SetAsmAttr(ala->getLabel().str());
+  }
+  if (varDecl.hasInit()) {
+    SetInitExprForASTVar(allocator, varDecl, attrs, *astVar);
+  }
+  if (llvm::isa<clang::VariableArrayType>(qualType.getCanonicalType())) {
+    ASTExpr *lenExpr = BuildExprToComputeSizeFromVLA(allocator, qualType.getCanonicalType());
+    astVar->SetVariableArrayExpr(lenExpr);
+    astVar->SetBoundaryLenExpr(lenExpr);
+  }
+  if (!varDecl.getType()->isIncompleteType()) {
+    SetAlignmentForASTVar(varDecl, *astVar);
+  }
+  const auto *valueDecl = llvm::dyn_cast<clang::ValueDecl>(&varDecl);
+  if (valueDecl != nullptr) {
+    ProcessNonnullFuncPtrAttrs(allocator, *valueDecl, *astVar);
+    ProcessBoundaryFuncPtrAttrs(allocator, *valueDecl, *astVar);
+  }
+  ProcessBoundaryVarAttrs(allocator, varDecl, *astVar);
+  return astVar;
+}
+
+ASTDecl *ASTParser::ProcessDeclParmVarDecl(MapleAllocator &allocator, const clang::ParmVarDecl &parmVarDecl) {
+  ASTVar *parmVar = static_cast<ASTVar*>(ASTDeclsBuilder::GetASTDecl(parmVarDecl.getID()));
+  if (parmVar != nullptr) {
+    return parmVar;
+  }
+  const clang::QualType parmQualType = parmVarDecl.getType();
+  std::string parmName = parmVarDecl.getNameAsString();
+  if (parmName.length() == 0) {
+    parmName = FEUtils::GetSequentialName("arg|");
+  }
+  MIRType *paramType = astFile->CvtType(parmQualType);
+  if (paramType == nullptr) {
+    return nullptr;
+  }
+  // C99 6.5.2.2.
+  // If the expression that denotes the called function has a type
+  // that does not include a prototype, the integer promotions are
+  // performed on each argument, and arguments that have type float
+  // are promoted to double.
+  PrimType promotedType = PTY_void;
+  if (parmVarDecl.isKNRPromoted()) {
+    promotedType = paramType->GetPrimType();
+    paramType = FEUtils::IsInteger(paramType->GetPrimType()) ?
+        GlobalTables::GetTypeTable().GetInt32() : GlobalTables::GetTypeTable().GetDouble();
+  }
+  GenericAttrs attrs;
+  astFile->CollectAttrs(parmVarDecl, attrs, kNone);
+  if (LibAstFile::IsOneElementVector(parmQualType)) {
+    attrs.SetAttr(GENATTR_oneelem_simd);
+  }
+  parmVar = ASTDeclsBuilder::ASTVarBuilder(allocator,
+                                           fileName,
+                                           parmName,
+                                           MapleVector<MIRType*>({paramType}, allocator.Adapter()),
+                                           attrs,
+                                           parmVarDecl.getID());
+  parmVar->SetIsParam(true);
+  parmVar->SetPromotedType(promotedType);
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    MIRType *sourceType = astFile->CvtSourceType(parmQualType);
+    parmVar->SetSourceType(sourceType);
+  }
+  const auto *valueDecl = llvm::dyn_cast<clang::ValueDecl>(&parmVarDecl);
+  if (valueDecl != nullptr) {
+    ProcessNonnullFuncPtrAttrs(allocator, *valueDecl, *parmVar);
+    ProcessBoundaryFuncPtrAttrs(allocator, *valueDecl, *parmVar);
+  }
+  return parmVar;
+}
+
+ASTDecl *ASTParser::ProcessDeclFileScopeAsmDecl(MapleAllocator &allocator, const clang::FileScopeAsmDecl &asmDecl) {
+  ASTFileScopeAsm *astAsmDecl = allocator.GetMemPool()->New<ASTFileScopeAsm>(allocator, fileName);
+  astAsmDecl->SetAsmStr(asmDecl.getAsmString()->getString().str());
+  return astAsmDecl;
+}
+
+ASTDecl *ASTParser::ProcessDeclEnumDecl(MapleAllocator &allocator, const clang::EnumDecl &rawEnumDecl) {
+  const clang::EnumDecl *enumDecl = rawEnumDecl.getDefinition();
+  if (enumDecl == nullptr) {
+    enumDecl = &rawEnumDecl;
+  }
+  ASTEnumDecl *astEnum = static_cast<ASTEnumDecl*>(ASTDeclsBuilder::GetASTDecl(enumDecl->getID()));
+  if (astEnum != nullptr) {
+    return astEnum;
+  }
+  GenericAttrs attrs;
+  astFile->CollectAttrs(*enumDecl, attrs, kNone);
+  std::string enumName = astFile->GetDeclName(*enumDecl);
+  MIRType *mirType;
+  if (enumDecl->getPromotionType().isNull()) {
+    mirType = GlobalTables::GetTypeTable().GetInt32();
+  } else {
+    mirType = astFile->CvtType(enumDecl->getPromotionType());
+  }
+  astEnum = ASTDeclsBuilder::ASTLocalEnumDeclBuilder(allocator, fileName, enumName,
+      MapleVector<MIRType*>({mirType}, allocator.Adapter()), attrs, enumDecl->getID());
+  TraverseDecl(enumDecl, [&astEnum, &allocator, this](clang::Decl *child) {
+    ASSERT_NOT_NULL(child);
+    CHECK_FATAL(child->getKind() == clang::Decl::EnumConstant, "Unsupported decl kind: %u", child->getKind());
+    astEnum->PushConstant(static_cast<ASTEnumConstant*>(ProcessDecl(allocator, *child)));
+  });
+  Loc l = astFile->GetLOC(enumDecl->getLocation());
+  astEnum->SetSrcLoc(l);
+  auto itor = std::find(astEnums.cbegin(), astEnums.cend(), astEnum);
+  if (itor == astEnums.end()) {
+    (void)astEnums.emplace_back(astEnum);
+  }
+  return astEnum;
+}
+
+ASTDecl *ASTParser::ProcessDeclEnumConstantDecl(MapleAllocator &allocator, const clang::EnumConstantDecl &decl) {
+  ASTEnumConstant *astConst = static_cast<ASTEnumConstant*>(ASTDeclsBuilder::GetASTDecl(decl.getID()));
+  if (astConst != nullptr) {
+    return astConst;
+  }
+  GenericAttrs attrs;
+  astFile->CollectAttrs(decl, attrs, kNone);
+  const std::string &varName = decl.getNameAsString();
+  MIRType *mirType = astFile->CvtType(decl.getType());
+  CHECK_NULL_FATAL(mirType);
+  astConst = ASTDeclsBuilder::ASTEnumConstBuilder(
+      allocator, fileName, varName, MapleVector<MIRType*>({mirType}, allocator.Adapter()), attrs, decl.getID());
+  IntVal val(decl.getInitVal().getExtValue(), mirType->GetPrimType());
+  astConst->SetValue(val);
+  return astConst;
+}
+
+ASTDecl *ASTParser::ProcessDeclTypedefDecl(MapleAllocator &allocator, const clang::TypedefDecl &decl) {
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    ASTTypedefDecl *astTypedef = static_cast<ASTTypedefDecl*>(ASTDeclsBuilder::GetASTDecl(decl.getID()));
+    if (astTypedef != nullptr) {
+      return astTypedef;
+    }
+    std::string typedefName = astFile->GetDeclName(decl);
+    GenericAttrs attrs;
+    astFile->CollectAttrs(decl, attrs, kNone);
+    clang::QualType underlyTy = decl.getUnderlyingType();
+    MIRType *type = astFile->CvtType(underlyTy, true);
+    CHECK_NULL_FATAL(type);
+    astTypedef = ASTDeclsBuilder::ASTTypedefBuilder(
+        allocator, fileName, typedefName, MapleVector<MIRType*>({type}, allocator.Adapter()), attrs, decl.getID());
+    const clang::TypedefType *underlyingTypedefType = llvm::dyn_cast<clang::TypedefType>(underlyTy);
+    if (underlyingTypedefType != nullptr) {
+      auto *subTypedeDecl = static_cast<ASTTypedefDecl*>(ProcessDecl(allocator, *underlyingTypedefType->getDecl()));
+      astTypedef->SetSubTypedefDecl(subTypedeDecl);
+    }
+    if (decl.isDefinedOutsideFunctionOrMethod()) {
+      astTypedef->SetGlobal(true);
+    }
+    return astTypedef;
+  }
+  clang::QualType underlyCanonicalTy = decl.getCanonicalDecl()->getUnderlyingType().getCanonicalType();
+  if (underlyCanonicalTy->isRecordType()) {
+    const auto *recordType = llvm::cast<clang::RecordType>(underlyCanonicalTy);
+    clang::RecordDecl *recordDecl = recordType->getDecl();
+    if (recordDecl->isImplicit()) {
+      return ProcessDecl(allocator, *recordDecl);
+    }
+  }
+  return nullptr;
+}
+
+ASTDecl *ASTParser::ProcessDeclLabelDecl(MapleAllocator &allocator, const clang::LabelDecl &decl) {
+  ASTDecl *astDecl = static_cast<ASTVar*>(ASTDeclsBuilder::GetASTDecl(decl.getID()));
+  if (astDecl != nullptr) {
+    return astDecl;
+  }
+  std::string varName = astFile->GetMangledName(decl);
+  CHECK_FATAL(!varName.empty(), "label string is null");
+  varName = FEUtils::GetSequentialName0(varName + "@", FEUtils::GetSequentialNumber());
+  MapleVector<MIRType*> typeDescVec(allocator.Adapter());
+  astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, fileName, varName, typeDescVec, decl.getID());
+  return astDecl;
+}
+
+bool ASTParser::RetrieveStructs(MapleAllocator &allocator) {
+  for (auto &decl : std::as_const(recordDecles)) {
+    clang::RecordDecl *recDecl = llvm::cast<clang::RecordDecl>(decl->getCanonicalDecl());
+    if (!recDecl->isCompleteDefinition()) {
+      clang::RecordDecl *recDeclDef = recDecl->getDefinition();
+      if (recDeclDef == nullptr) {
+        continue;
+      } else {
+        recDecl = recDeclDef;
+      }
+    }
+    ASTStruct *curStructOrUnion = static_cast<ASTStruct*>(ProcessDecl(allocator, *recDecl));
+    if (curStructOrUnion == nullptr) {
+      return false;
+    }
+    auto itor = std::find(astStructs.cbegin(), astStructs.cend(), curStructOrUnion);
+    if (itor != astStructs.end()) {
+    } else {
+      astStructs.emplace_back(curStructOrUnion);
+    }
+  }
+  return true;
+}
+
+bool ASTParser::RetrieveFuncs(MapleAllocator &allocator) {
+  for (auto &func : std::as_const(funcDecles)) {
+    clang::FunctionDecl *funcDecl = llvm::cast<clang::FunctionDecl>(func);
+    CHECK_NULL_FATAL(funcDecl);
+    if (funcDecl->isDefined()) {
+      clang::SafeScopeSpecifier spec = funcDecl->getSafeSpecifier();
+      funcDecl = funcDecl->getDefinition();
+      if (funcDecl->getSafeSpecifier() != spec) {
+        if (funcDecl->getSafeSpecifier() != clang::SS_None && spec != clang::SS_None) {
+          std::string funcName = astFile->GetMangledName(*funcDecl);
+          Loc loc = astFile->GetLOC(funcDecl->getLocation());
+          FE_ERR(kLncWarn, loc, "The function %s declaration and definition security attributes "
+                 "are inconsistent.", funcName.c_str());
+        } else if (funcDecl->getSafeSpecifier() == clang::SS_None) {
+          funcDecl->setSafeSpecifier(spec);
+        }
+      }
+    }
+    ASTFunc *af = static_cast<ASTFunc*>(ProcessDecl(allocator, *funcDecl));
+    if (af == nullptr) {
+      return false;
+    }
+    af->SetGlobal(true);
+    astFuncs.emplace_back(af);
+  }
+  return true;
+}
+
+// seperate MP with astparser
+bool ASTParser::RetrieveGlobalVars(MapleAllocator &allocator) {
+  for (auto &decl : std::as_const(globalVarDecles)) {
+    clang::VarDecl *varDecl = llvm::cast<clang::VarDecl>(decl);
+    ASTVar *val = static_cast<ASTVar*>(ProcessDecl(allocator, *varDecl));
+    if (val == nullptr) {
+      return false;
+    }
+    astVars.emplace_back(val);
+  }
+  return true;
+}
+
+bool ASTParser::RetrieveFileScopeAsms(MapleAllocator &allocator) {
+  for (auto &decl : std::as_const(globalFileScopeAsm)) {
+    clang::FileScopeAsmDecl *fileScopeAsmDecl = llvm::cast<clang::FileScopeAsmDecl>(decl);
+    ASTFileScopeAsm *asmDecl = static_cast<ASTFileScopeAsm*>(ProcessDecl(allocator, *fileScopeAsmDecl));
+    if (asmDecl == nullptr) {
+      return false;
+    }
+    astFileScopeAsms.emplace_back(asmDecl);
+  }
+  return true;
+}
+
+bool ASTParser::RetrieveGlobalTypeDef(MapleAllocator &allocator) {
+  for (auto &gTypeDefDecl : std::as_const(globalTypeDefDecles)) {
+    if (gTypeDefDecl->isImplicit()) {
+      continue;
+    }
+    (void)ProcessDecl(allocator, *gTypeDefDecl);
+  }
+  return true;
+}
+
+bool ASTParser::RetrieveEnums(MapleAllocator &allocator) {
+  for (auto &decl : std::as_const(globalEnumDecles)) {
+    clang::EnumDecl *enumDecl = llvm::cast<clang::EnumDecl>(decl->getCanonicalDecl());
+    ASTEnumDecl *astEnum = static_cast<ASTEnumDecl*>(ProcessDecl(allocator, *enumDecl));
+    if (astEnum == nullptr) {
+      return false;
+    }
+    (void)astEnums.emplace_back(astEnum);
+  }
+  return true;
+}
+
+const std::string ASTParser::GetSourceFileName() const {
+  return fileName.c_str() == nullptr ? "" : fileName.c_str();
+}
+
+const uint32 ASTParser::GetFileIdx() const {
+  return fileIdx;
+}
+
+void ASTParser::TraverseDecl(const clang::Decl *decl, std::function<void (clang::Decl*)> const &functor) const {
+  if (decl == nullptr) {
+    return;
+  }
+  ASSERT_NOT_NULL(clang::dyn_cast<const clang::DeclContext>(decl));
+  for (auto *child : clang::dyn_cast<const clang::DeclContext>(decl)->decls()) {
+    if (child != nullptr) {
+      functor(child);
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/ast_input/clang/src/ast_parser_builting_func.cpp b/src/hir2mpl/ast_input/clang/src/ast_parser_builting_func.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e02610b225814e74a5bf09b5828cb941af8024b7
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/src/ast_parser_builting_func.cpp
@@ -0,0 +1,1060 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_expr.h"
+#include "ast_decl.h"
+#include "ast_decl_builder.h"
+#include "ast_interface.h"
+#include "ast_util.h"
+#include "ast_input.h"
+#include "ast_stmt.h"
+#include "ast_parser.h"
+#include "feir_stmt.h"
+#include "feir_builder.h"
+#include "fe_utils_ast.h"
+#include "feir_type_helper.h"
+#include "fe_manager.h"
+#include "mir_module.h"
+#include "mpl_logging.h"
+#include "fe_macros.h"
+
+namespace maple {
+std::unordered_map<std::string, ASTCallExpr::FuncPtrBuiltinFunc> ASTCallExpr::InitBuiltinFuncPtrMap() {
+  std::unordered_map<std::string, FuncPtrBuiltinFunc> ans;
+#define BUILTIN_FUNC_EMIT(funcName, FuncPtrBuiltinFunc) \
+  ans[funcName] = FuncPtrBuiltinFunc;
+#include "builtin_func_emit.def"
+#undef BUILTIN_FUNC_EMIT
+  // vector builtinfunc
+#define DEF_MIR_INTRINSIC(STR, NAME, INTRN_CLASS, RETURN_TYPE, ...)                                \
+  ans["__builtin_mpl_"#STR] = &ASTCallExpr::EmitBuiltin##STR;
+#include "intrinsic_vector.def"
+#undef DEF_MIR_INTRINSIC
+
+  return ans;
+}
+
+UniqueFEIRExpr ASTCallExpr::CreateIntrinsicopForC(std::list<UniqueFEIRStmt> &stmts,
+                                                  MIRIntrinsicID argIntrinsicID, bool genTempVar) const {
+  auto feTy = std::make_unique<FEIRTypeNative>(*mirType);
+  std::vector<std::unique_ptr<FEIRExpr>> argOpnds;
+  for (auto arg : args) {
+    argOpnds.push_back(arg->Emit2FEExpr(stmts));
+  }
+  auto feExpr = std::make_unique<FEIRExprIntrinsicopForC>(std::move(feTy), argIntrinsicID, argOpnds);
+  if (mirType->GetPrimType() == PTY_void) {
+    std::list<UniqueFEIRExpr> feExprs;
+    feExprs.emplace_back(std::move(feExpr));
+    UniqueFEIRStmt evalStmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(evalStmt));
+    return nullptr;
+  } else {
+    if (!genTempVar) {
+      return feExpr;
+    }
+    std::string tmpName = FEUtils::GetSequentialName("intrinsicop_var_");
+    UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType);
+    UniqueFEIRStmt dAssign = std::make_unique<FEIRStmtDAssign>(tmpVar->Clone(), std::move(feExpr), 0);
+    stmts.emplace_back(std::move(dAssign));
+    auto dread = FEIRBuilder::CreateExprDRead(tmpVar->Clone());
+    return dread;
+  }
+}
+
+UniqueFEIRExpr ASTCallExpr::CreateIntrinsicCallAssignedForC(std::list<UniqueFEIRStmt> &stmts,
+                                                            MIRIntrinsicID argIntrinsicID) const {
+  std::unique_ptr<std::list<UniqueFEIRExpr>> argExprList = std::make_unique<std::list<UniqueFEIRExpr>>();
+  for (auto arg : args) {
+    (void)argExprList->emplace_back(arg->Emit2FEExpr(stmts));
+  }
+  if (!IsNeedRetExpr()) {
+    auto stmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(argIntrinsicID, nullptr, nullptr,
+                                                              std::move(argExprList));
+    stmts.emplace_back(std::move(stmt));
+    return nullptr;
+  }
+  UniqueFEIRVar retVar = FEIRBuilder::CreateVarNameForC(GetRetVarName(), *mirType, false);
+  auto stmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(argIntrinsicID, nullptr, retVar->Clone(),
+                                                            std::move(argExprList));
+  stmts.emplace_back(std::move(stmt));
+  UniqueFEIRExpr dread = FEIRBuilder::CreateExprDRead(std::move(retVar));
+  return dread;
+}
+
+UniqueFEIRExpr ASTCallExpr::CreateBinaryExpr(std::list<UniqueFEIRStmt> &stmts, Opcode op) const {
+  auto feTy = std::make_unique<FEIRTypeNative>(*mirType);
+  auto arg1 = args[0]->Emit2FEExpr(stmts);
+  auto arg2 = args[1]->Emit2FEExpr(stmts);
+  return std::make_unique<FEIRExprBinary>(std::move(feTy), op, std::move(arg1), std::move(arg2));
+}
+
+UniqueFEIRExpr ASTCallExpr::ProcessBuiltinFunc(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const {
+  // process a kind of builtinFunc
+  std::string prefix = "__builtin_mpl_vector_load";
+  if (GetFuncName().compare(0, prefix.size(), prefix) == 0) {
+    return EmitBuiltinVectorLoad(stmts, isFinish);
+  }
+  prefix = "__builtin_mpl_vector_store";
+  if (GetFuncName().compare(0, prefix.size(), prefix) == 0) {
+    return EmitBuiltinVectorStore(stmts, isFinish);
+  }
+  prefix = "__builtin_mpl_vector_zip";
+  if (GetFuncName().compare(0, prefix.size(), prefix) == 0) {
+    return EmitBuiltinVectorZip(stmts, isFinish);
+  }
+  prefix = "__builtin_mpl_vector_shli";
+  if (GetFuncName().compare(0, prefix.size(), prefix) == 0) {
+    return EmitBuiltinVectorShli(stmts, isFinish);
+  }
+  prefix = "__builtin_mpl_vector_shri";
+  if (GetFuncName().compare(0, prefix.size(), prefix) == 0) {
+    return EmitBuiltinVectorShri(stmts, isFinish);
+  }
+  prefix = "__builtin_mpl_vector_shru";
+  if (GetFuncName().compare(0, prefix.size(), prefix) == 0) {
+    return EmitBuiltinVectorShru(stmts, isFinish);
+  }
+  // process a single builtinFunc
+  auto ptrFunc = builtingFuncPtrMap.find(GetFuncName());
+  if (ptrFunc != builtingFuncPtrMap.end()) {
+    isFinish = true;
+    return EmitBuiltinFunc(stmts);
+  }
+  isFinish = false;
+  if (FEOptions::GetInstance().GetDumpLevel() >= FEOptions::kDumpLevelInfo) {
+    prefix = "__builtin";
+    if (GetFuncName().compare(0, prefix.size(), prefix) == 0) {
+      FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "%s:%d BuiltinFunc (%s) has not been implemented",
+                    FEManager::GetModule().GetFileNameFromFileNum(GetSrcFileIdx()).c_str(), GetSrcFileLineNum(),
+                    GetFuncName().c_str());
+    }
+  }
+  return nullptr;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinFunc(std::list<UniqueFEIRStmt> &stmts) const {
+  return (this->*(builtingFuncPtrMap[GetFuncName()]))(stmts);
+}
+
+#define DEF_MIR_INTRINSIC(STR, NAME, INTRN_CLASS, RETURN_TYPE, ...)                                \
+UniqueFEIRExpr ASTCallExpr::EmitBuiltin##STR(std::list<UniqueFEIRStmt> &stmts) const {             \
+  auto feType = FEIRTypeHelper::CreateTypeNative(*mirType);                                        \
+  std::vector<std::unique_ptr<FEIRExpr>> argOpnds;                                                 \
+  for (auto arg : args) {                                                                          \
+    argOpnds.push_back(arg->Emit2FEExpr(stmts));                                                   \
+  }                                                                                                \
+  return std::make_unique<FEIRExprIntrinsicopForC>(std::move(feType), INTRN_##STR, argOpnds);      \
+}
+#include "intrinsic_vector.def"
+#undef DEF_MIR_INTRINSIC
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinVectorLoad(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const {
+  auto argExpr = args[0]->Emit2FEExpr(stmts);
+  UniqueFEIRType type = FEIRTypeHelper::CreateTypeNative(*mirType);
+  UniqueFEIRType ptrType = FEIRTypeHelper::CreateTypeNative(
+      *GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType));
+  isFinish = true;
+  return FEIRBuilder::CreateExprIRead(std::move(type), std::move(ptrType), std::move(argExpr));
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinVectorStore(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const {
+  auto arg1Expr = args[0]->Emit2FEExpr(stmts);
+  auto arg2Expr = args[1]->Emit2FEExpr(stmts);
+  UniqueFEIRType type = FEIRTypeHelper::CreateTypeNative(
+      *GlobalTables::GetTypeTable().GetOrCreatePointerType(*args[1]->GetType()));
+  auto stmt = FEIRBuilder::CreateStmtIAssign(std::move(type), std::move(arg1Expr), std::move(arg2Expr));
+  (void)stmts.emplace_back(std::move(stmt));
+  isFinish = true;
+  return nullptr;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinVectorShli(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const {
+  isFinish = true;
+  UniqueFEIRType type = FEIRTypeHelper::CreateTypeNative(*args[0]->GetType());
+  auto arg1Expr = args[0]->Emit2FEExpr(stmts);
+  auto arg2Expr = args[1]->Emit2FEExpr(stmts);
+  return FEIRBuilder::CreateExprBinary(std::move(type), OP_shl, std::move(arg1Expr), std::move(arg2Expr));
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinVectorShri(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const {
+  isFinish = true;
+  UniqueFEIRType type = FEIRTypeHelper::CreateTypeNative(*args[0]->GetType());
+  auto arg1Expr = args[0]->Emit2FEExpr(stmts);
+  auto arg2Expr = args[1]->Emit2FEExpr(stmts);
+  return FEIRBuilder::CreateExprBinary(std::move(type), OP_ashr, std::move(arg1Expr), std::move(arg2Expr));
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinVectorShru(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const {
+  isFinish = true;
+  UniqueFEIRType type = FEIRTypeHelper::CreateTypeNative(*args[0]->GetType());
+  auto arg1Expr = args[0]->Emit2FEExpr(stmts);
+  auto arg2Expr = args[1]->Emit2FEExpr(stmts);
+  return FEIRBuilder::CreateExprBinary(std::move(type), OP_lshr, std::move(arg1Expr), std::move(arg2Expr));
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinVectorZip(std::list<UniqueFEIRStmt> &stmts, bool &isFinish) const {
+  std::unique_ptr<std::list<UniqueFEIRExpr>> argExprList = std::make_unique<std::list<UniqueFEIRExpr>>();
+  for (auto arg : args) {
+    UniqueFEIRExpr expr = arg->Emit2FEExpr(stmts);
+    argExprList->emplace_back(std::move(expr));
+  }
+  CHECK_NULL_FATAL(mirType);
+  std::string retName = FEUtils::GetSequentialName("vector_zip_retvar_");
+  UniqueFEIRVar retVar = FEIRBuilder::CreateVarNameForC(retName, *mirType);
+
+#define VECTOR_INTRINSICCALL_TYPE(OP_NAME, VECTY)                                                \
+  if (FEUtils::EndsWith(GetFuncName(), #VECTY)) {                                                \
+    stmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(                                        \
+        INTRN_vector_##OP_NAME##_##VECTY, nullptr, retVar->Clone(), std::move(argExprList));     \
+  }
+  UniqueFEIRStmt stmt;
+
+  VECTOR_INTRINSICCALL_TYPE(zip, v2i32)
+  else VECTOR_INTRINSICCALL_TYPE(zip, v4i16)
+  else VECTOR_INTRINSICCALL_TYPE(zip, v8i8)
+  else VECTOR_INTRINSICCALL_TYPE(zip, v2u32)
+  else VECTOR_INTRINSICCALL_TYPE(zip, v4u16)
+  else VECTOR_INTRINSICCALL_TYPE(zip, v8u8)
+  else VECTOR_INTRINSICCALL_TYPE(zip, v2f32)
+
+  stmts.emplace_back(std::move(stmt));
+  isFinish = true;
+  return FEIRBuilder::CreateExprDRead(std::move(retVar));
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinVaStart(std::list<UniqueFEIRStmt> &stmts) const {
+  // args
+  auto exprArgList = std::make_unique<std::list<UniqueFEIRExpr>>();
+  for (auto arg : args) {
+    UniqueFEIRExpr expr = arg->Emit2FEExpr(stmts);
+    exprArgList->emplace_back(std::move(expr));
+  }
+  // addrof va_list instead of dread va_list
+  exprArgList->front()->SetAddrof(true);
+  std::unique_ptr<FEIRStmtIntrinsicCallAssign> stmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+      INTRN_C_va_start, nullptr /* type */, nullptr /* retVar */, std::move(exprArgList));
+  stmts.emplace_back(std::move(stmt));
+  return nullptr;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinVaEnd(std::list<UniqueFEIRStmt> &stmts) const {
+  // args
+  ASSERT(args.size() == 1, "va_end expects 1 arguments");
+  std::list<UniqueFEIRExpr> exprArgList;
+  for (auto arg : args) {
+    UniqueFEIRExpr expr = arg->Emit2FEExpr(stmts);
+    // addrof va_list instead of dread va_list
+    expr->SetAddrof(true);
+    exprArgList.emplace_back(std::move(expr));
+  }
+  auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(exprArgList));
+  stmts.emplace_back(std::move(stmt));
+  return nullptr;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinVaCopy(std::list<UniqueFEIRStmt> &stmts) const {
+  // args
+  auto exprArgList = std::make_unique<std::list<UniqueFEIRExpr>>();
+  UniqueFEIRType vaListType;
+  for (auto arg : args) {
+    UniqueFEIRExpr expr = arg->Emit2FEExpr(stmts);
+    // addrof va_list instead of dread va_list
+    expr->SetAddrof(true);
+    vaListType = expr->GetType()->Clone();
+    exprArgList->emplace_back(std::move(expr));
+  }
+  // Add the size of the va_list structure as the size to memcpy.
+  size_t elemSizes = vaListType->GenerateMIRTypeAuto()->GetSize();
+  CHECK_FATAL(elemSizes <= INT_MAX, "Too large elem size");
+  UniqueFEIRExpr sizeExpr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(elemSizes));
+  exprArgList->emplace_back(std::move(sizeExpr));
+  std::unique_ptr<FEIRStmtIntrinsicCallAssign> stmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+      INTRN_C_memcpy, nullptr /* type */, nullptr /* retVar */, std::move(exprArgList));
+  stmts.emplace_back(std::move(stmt));
+  return nullptr;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinPrefetch(std::list<UniqueFEIRStmt> &stmts) const {
+  // __builtin_prefetch is not supported, only parsing args including stmts
+  for (size_t i = 0; i <= args.size() - 1; ++i) {
+    (void)args[i]->Emit2FEExpr(stmts);
+  }
+  return nullptr;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinCtz(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_ctz32);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinCtzl(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_ctz64);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinClz(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_clz32);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinClzl(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_clz64);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinPopcount(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_popcount32);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinPopcountl(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_popcount64);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinPopcountll(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_popcount64);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinParity(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_parity32);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinParityl(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_parity64);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinParityll(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_parity64);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinClrsb(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_clrsb32);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinClrsbl(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_clrsb64);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinClrsbll(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_clrsb64);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinFfs(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_ffs);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinFfsl(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_ffs);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinFfsll(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_ffs);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinIsAligned(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_isaligned);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinAlignUp(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_alignup);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinAlignDown(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_aligndown);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncAddAndFetch8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_add_and_fetch_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncAddAndFetch4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_add_and_fetch_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncAddAndFetch2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_add_and_fetch_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncAddAndFetch1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_add_and_fetch_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncSubAndFetch8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_sub_and_fetch_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncSubAndFetch4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_sub_and_fetch_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncSubAndFetch2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_sub_and_fetch_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncSubAndFetch1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_sub_and_fetch_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndSub8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_sub_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndSub4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_sub_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndSub2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_sub_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndSub1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_sub_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndAdd8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_add_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndAdd4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_add_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndAdd2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_add_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndAdd1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_add_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncValCompareAndSwap8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_val_compare_and_swap_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncValCompareAndSwap4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_val_compare_and_swap_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncValCompareAndSwap2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_val_compare_and_swap_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncValCompareAndSwap1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_val_compare_and_swap_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncLockRelease8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_lock_release_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncLockRelease4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_lock_release_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncLockRelease2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_lock_release_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncLockRelease1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_lock_release_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncBoolCompareAndSwap8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_bool_compare_and_swap_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncBoolCompareAndSwap4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_bool_compare_and_swap_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncBoolCompareAndSwap2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_bool_compare_and_swap_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncBoolCompareAndSwap1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_bool_compare_and_swap_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncLockTestAndSet8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_lock_test_and_set_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncLockTestAndSet4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_lock_test_and_set_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncLockTestAndSet2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_lock_test_and_set_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncLockTestAndSet1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_lock_test_and_set_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndAnd1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_and_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndAnd2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_and_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndAnd4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_and_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndAnd8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_and_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndOr1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_or_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndOr2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_or_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndOr4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_or_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndOr8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_or_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndXor1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_xor_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndXor2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_xor_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndXor4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_xor_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndXor8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_xor_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndNand1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_nand_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndNand2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_nand_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndNand4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_nand_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncFetchAndNand8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_fetch_and_nand_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncAndAndFetch1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_and_and_fetch_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncAndAndFetch2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_and_and_fetch_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncAndAndFetch4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_and_and_fetch_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncAndAndFetch8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_and_and_fetch_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncOrAndFetch1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_or_and_fetch_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncOrAndFetch2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_or_and_fetch_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncOrAndFetch4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_or_and_fetch_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncOrAndFetch8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_or_and_fetch_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncXorAndFetch1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_xor_and_fetch_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncXorAndFetch2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_xor_and_fetch_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncXorAndFetch4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_xor_and_fetch_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncXorAndFetch8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_xor_and_fetch_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncNandAndFetch1(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_nand_and_fetch_1);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncNandAndFetch2(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_nand_and_fetch_2);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncNandAndFetch4(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_nand_and_fetch_4);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncNandAndFetch8(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_nand_and_fetch_8);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSyncSynchronize(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___sync_synchronize);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinAtomicExchangeN(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___atomic_exchange_n);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinObjectSize(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicCallAssignedForC(stmts, INTRN_C___builtin_object_size);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinReturnAddress(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C__builtin_return_address);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinExtractReturnAddr(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C__builtin_extract_return_addr);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinAlloca(std::list<UniqueFEIRStmt> &stmts) const {
+  auto arg = args[0]->Emit2FEExpr(stmts);
+  CHECK_NULL_FATAL(mirType);
+  auto alloca = std::make_unique<FEIRExprUnary>(FEIRTypeHelper::CreateTypeNative(*mirType), OP_alloca, std::move(arg));
+  return alloca;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinExpect(std::list<UniqueFEIRStmt> &stmts) const {
+  ASSERT(args.size() == 2, "__builtin_expect requires two arguments");
+  std::list<UniqueFEIRStmt> subStmts;
+  UniqueFEIRExpr feExpr = CreateIntrinsicopForC(subStmts, INTRN_C___builtin_expect, false);
+  bool isOptimized = false;
+  for (auto &stmt : std::as_const(subStmts)) {
+    // If there are mutiple conditions combined with logical AND '&&' or logical OR '||' in __builtin_expect, generate
+    // a __builtin_expect intrinsicop for each one condition in mpl
+    if (stmt->GetKind() == FEIRNodeKind::kStmtCondGoto) {
+      isOptimized = true;
+      auto *condGotoStmt = static_cast<FEIRStmtCondGotoForC*>(stmt.get());
+      // skip if condition label name not starts with <kCondGoToStmtLabelNamePrefix>
+      if (condGotoStmt->GetLabelName().rfind(FEUtils::kCondGoToStmtLabelNamePrefix, 0) != 0) {
+        continue;
+      }
+      const auto &conditionExpr = condGotoStmt->GetConditionExpr();
+      // skip if __builtin_expect intrinsicop has been generated for condition expr
+      if (conditionExpr->GetKind() == kExprBinary) {
+        auto &opnd0 = static_cast<FEIRExprBinary*>(conditionExpr.get())->GetOpnd0();
+        if (opnd0->GetKind() == FEIRNodeKind::kExprIntrinsicop &&
+            static_cast<FEIRExprIntrinsicopForC*>(opnd0.get())->GetIntrinsicID() == INTRN_C___builtin_expect) {
+          continue;
+        }
+      }
+      std::vector<std::unique_ptr<FEIRExpr>> argOpnds;
+      auto &builtInExpectArgs = static_cast<FEIRExprIntrinsicopForC*>(feExpr.get())->GetOpnds();
+      auto cvtFeExpr = FEIRBuilder::CreateExprCvtPrim(conditionExpr->Clone(), builtInExpectArgs.front()->GetPrimType());
+      argOpnds.push_back(std::move(cvtFeExpr));
+      argOpnds.push_back(builtInExpectArgs.back()->Clone());
+      auto returnType = std::make_unique<FEIRTypeNative>(*mirType);
+      auto builtinExpectExpr = std::make_unique<FEIRExprIntrinsicopForC>(std::move(returnType),
+                                                                         INTRN_C___builtin_expect, argOpnds);
+      auto newConditionExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(builtinExpectExpr));
+      condGotoStmt->SetCondtionExpr(newConditionExpr);
+    }
+  }
+  stmts.splice(stmts.end(), subStmts);
+  return isOptimized ? static_cast<FEIRExprIntrinsicopForC*>(feExpr.get())->GetOpnds().front()->Clone()
+                     : feExpr->Clone();
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinAbs(std::list<UniqueFEIRStmt> &stmts) const {
+  auto arg = args[0]->Emit2FEExpr(stmts);
+  CHECK_NULL_FATAL(mirType);
+  auto abs = std::make_unique<FEIRExprUnary>(FEIRTypeHelper::CreateTypeNative(*mirType), OP_abs, std::move(arg));
+  auto feType = std::make_unique<FEIRTypeNative>(*mirType);
+  abs->SetType(std::move(feType));
+  return abs;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinACos(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_acos);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinACosf(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_acosf);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinASin(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_asin);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinASinf(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_asinf);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinATan(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_atan);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinATanf(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_atanf);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinCos(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_cos);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinCosf(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_cosf);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinCosh(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_cosh);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinCoshf(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_coshf);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSin(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_sin);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSinf(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_sinf);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSinh(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_sinh);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinSinhf(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_sinhf);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinExp(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_exp);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinExpf(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_expf);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinBswap64(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_bswap64);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinBswap32(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_bswap32);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinBswap16(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_bswap16);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinFmax(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateBinaryExpr(stmts, OP_max);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinFmin(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateBinaryExpr(stmts, OP_min);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinLog(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_log);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinLogf(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_logf);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinLog10(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_log10);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinLog10f(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateIntrinsicopForC(stmts, INTRN_C_log10f);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinIsunordered(std::list<UniqueFEIRStmt> &stmts) const {
+  auto feTy = std::make_unique<FEIRTypeNative>(*mirType);
+  auto arg1 = args[0]->Emit2FEExpr(stmts);
+  auto arg2 = args[1]->Emit2FEExpr(stmts);
+  auto nan1 = std::make_unique<FEIRExprBinary>(feTy->Clone(), OP_ne, arg1->Clone(), arg1->Clone());
+  auto nan2 = std::make_unique<FEIRExprBinary>(feTy->Clone(), OP_ne, arg2->Clone(), arg2->Clone());
+  auto res = std::make_unique<FEIRExprBinary>(feTy->Clone(), OP_lior, std::move(nan1), std::move(nan2));
+  return res;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinIsless(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateBinaryExpr(stmts, OP_lt);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinIslessequal(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateBinaryExpr(stmts, OP_le);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinIsgreater(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateBinaryExpr(stmts, OP_gt);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinIsgreaterequal(std::list<UniqueFEIRStmt> &stmts) const {
+  return CreateBinaryExpr(stmts, OP_ge);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinIslessgreater(std::list<UniqueFEIRStmt> &stmts) const {
+  auto feTy = std::make_unique<FEIRTypeNative>(*mirType);
+  auto arg1 = args[0]->Emit2FEExpr(stmts);
+  auto arg2 = args[1]->Emit2FEExpr(stmts);
+  auto cond1 = std::make_unique<FEIRExprBinary>(feTy->Clone(), OP_lt, arg1->Clone(), arg2->Clone());
+  auto cond2 = std::make_unique<FEIRExprBinary>(feTy->Clone(), OP_gt, arg1->Clone(), arg2->Clone());
+  auto res = std::make_unique<FEIRExprBinary>(feTy->Clone(), OP_lior, std::move(cond1), std::move(cond2));
+  return res;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinWarnMemsetZeroLen(std::list<UniqueFEIRStmt> &stmts) const {
+  (void)stmts;
+  return nullptr;
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinRotateLeft8(std::list<UniqueFEIRStmt> &stmts) const {
+  return EmitBuiltinRotate(stmts, PTY_u8, true);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinRotateLeft16(std::list<UniqueFEIRStmt> &stmts) const {
+  return EmitBuiltinRotate(stmts, PTY_u16, true);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinRotateLeft32(std::list<UniqueFEIRStmt> &stmts) const {
+  return EmitBuiltinRotate(stmts, PTY_u32, true);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinRotateLeft64(std::list<UniqueFEIRStmt> &stmts) const {
+  return EmitBuiltinRotate(stmts, PTY_u64, true);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinRotateRight8(std::list<UniqueFEIRStmt> &stmts) const {
+  return EmitBuiltinRotate(stmts, PTY_u8, false);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinRotateRight16(std::list<UniqueFEIRStmt> &stmts) const {
+  return EmitBuiltinRotate(stmts, PTY_u16, false);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinRotateRight32(std::list<UniqueFEIRStmt> &stmts) const {
+  return EmitBuiltinRotate(stmts, PTY_u32, false);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinRotateRight64(std::list<UniqueFEIRStmt> &stmts) const {
+  return EmitBuiltinRotate(stmts, PTY_u64, false);
+}
+
+UniqueFEIRExpr ASTCallExpr::EmitBuiltinRotate(std::list<UniqueFEIRStmt> &stmts, PrimType rotType, bool isLeft) const {
+  const int mask = FEUtils::GetWidth(rotType) - 1;
+  UniqueFEIRExpr maskExpr = FEIRBuilder::CreateExprConstAnyScalar(rotType, mask);
+  UniqueFEIRExpr valExpr = args[0]->Emit2FEExpr(stmts);
+  UniqueFEIRExpr bitExpr = args[1]->Emit2FEExpr(stmts);
+  bitExpr = FEIRBuilder::CreateExprBinary(OP_band, bitExpr->Clone(), maskExpr->Clone());
+  // RotateLeft: (val >> bit) | (val << ((-bit) & mask))
+  // RotateRight: (val << bit) | (val >> ((-bit) & mask))
+  return FEIRBuilder::CreateExprBinary(OP_bior,
+      FEIRBuilder::CreateExprBinary((isLeft ? OP_shl : OP_lshr), valExpr->Clone(), bitExpr->Clone()),
+      FEIRBuilder::CreateExprBinary((isLeft ? OP_lshr : OP_shl),
+          valExpr->Clone(),
+          FEIRBuilder::CreateExprBinary(OP_band,
+              FEIRBuilder::CreateExprMathUnary(OP_neg, bitExpr->Clone()),
+              maskExpr->Clone())));
+}
+
+std::map<std::string, ASTParser::FuncPtrBuiltinFunc> ASTParser::InitBuiltinFuncPtrMap() {
+  std::map<std::string, FuncPtrBuiltinFunc> ans;
+#define BUILTIN_FUNC_PARSE(funcName, FuncPtrBuiltinFunc) \
+  ans[funcName] = FuncPtrBuiltinFunc;
+#include "builtin_func_parse.def"
+#undef BUILTIN_FUNC_PARSE
+  return ans;
+}
+
+ASTExpr *ASTParser::ParseBuiltinFunc(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                     std::stringstream &ss) const {
+  return (this->*(builtingFuncPtrMap[ss.str()]))(allocator, expr, ss);
+}
+
+ASTExpr *ASTParser::ProcessBuiltinFuncByName(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                             std::stringstream &ss, const std::string &name) const {
+  (void)allocator;
+  (void)expr;
+  ss.clear();
+  ss.str(std::string());
+  ss << name;
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ParseBuiltinClassifyType(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                             std::stringstream &ss) const {
+  (void)ss;
+  clang::Expr::EvalResult res;
+  bool success = expr.EvaluateAsInt(res, *(astFile->GetContext()));
+  CHECK_FATAL(success, "Failed to evaluate __builtin_classify_type");
+  llvm::APSInt apVal = res.Val.getInt();
+  ASTIntegerLiteral *astIntegerLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  astIntegerLiteral->SetVal(apVal.getExtValue());
+  astIntegerLiteral->SetType(GlobalTables::GetTypeTable().GetInt32());
+  return astIntegerLiteral;
+}
+
+ASTExpr *ASTParser::ParseBuiltinConstantP(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                          std::stringstream &ss) const {
+  (void)ss;
+  int64 constP = expr.getArg(0)->isConstantInitializer(*astFile->GetNonConstAstContext(), false) ? 1 : 0;
+  // Pointers are not considered constant
+  if (expr.getArg(0)->getType()->isPointerType() &&
+      !llvm::isa<clang::StringLiteral>(expr.getArg(0)->IgnoreParenCasts())) {
+    constP = 0;
+  }
+  ASTIntegerLiteral *astIntegerLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  astIntegerLiteral->SetVal(constP);
+  astIntegerLiteral->SetType(astFile->CvtType(expr.getType()));
+  return astIntegerLiteral;
+}
+
+ASTExpr *ASTParser::ParseBuiltinSignbit(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                        std::stringstream &ss) const {
+  return ProcessBuiltinFuncByName(allocator, expr, ss, "__signbit");
+}
+
+ASTExpr *ASTParser::ParseBuiltinIsinfsign(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                          std::stringstream &ss) const {
+  (void)allocator;
+  ss.clear();
+  ss.str(std::string());
+  MIRType *mirType = astFile->CvtType(expr.getArg(0)->getType());
+  if (mirType != nullptr) {
+    PrimType type = mirType->GetPrimType();
+    if (type == PTY_f64) {
+      ss << "__isinf";
+    } else if (type == PTY_f32) {
+      ss << "__isinff";
+    } else {
+      ASSERT(false, "Unsupported type passed to isinf");
+    }
+  }
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ParseBuiltinHugeVal(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                        std::stringstream &ss) const {
+  (void)expr;
+  (void)ss;
+  ASTFloatingLiteral *astFloatingLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  astFloatingLiteral->SetKind(FloatKind::F64);
+  astFloatingLiteral->SetVal(std::numeric_limits<double>::infinity());
+  return astFloatingLiteral;
+}
+
+ASTExpr *ASTParser::ParseBuiltinHugeValf(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                         std::stringstream &ss) const {
+  (void)expr;
+  (void)ss;
+  ASTFloatingLiteral *astFloatingLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  astFloatingLiteral->SetKind(FloatKind::F32);
+  astFloatingLiteral->SetVal(std::numeric_limits<float>::infinity());
+  return astFloatingLiteral;
+}
+
+ASTExpr *ASTParser::ParseBuiltinInf(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                    std::stringstream &ss) const {
+  (void)expr;
+  (void)ss;
+  ASTFloatingLiteral *astFloatingLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  astFloatingLiteral->SetKind(FloatKind::F64);
+  astFloatingLiteral->SetVal(std::numeric_limits<float>::infinity());
+  return astFloatingLiteral;
+}
+
+ASTExpr *ASTParser::ParseBuiltinInff(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                     std::stringstream &ss) const {
+  (void)expr;
+  (void)ss;
+  ASTFloatingLiteral *astFloatingLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  astFloatingLiteral->SetKind(FloatKind::F32);
+  astFloatingLiteral->SetVal(std::numeric_limits<float>::infinity());
+  return astFloatingLiteral;
+}
+
+ASTExpr *ASTParser::ParseBuiltinNan(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                    std::stringstream &ss) const {
+  (void)expr;
+  (void)ss;
+  ASTFloatingLiteral *astFloatingLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  astFloatingLiteral->SetKind(FloatKind::F64);
+  astFloatingLiteral->SetVal(nan(""));
+  return astFloatingLiteral;
+}
+
+ASTExpr *ASTParser::ParseBuiltinNanf(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                     std::stringstream &ss) const {
+  (void)expr;
+  (void)ss;
+  ASTFloatingLiteral *astFloatingLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  astFloatingLiteral->SetKind(FloatKind::F32);
+  astFloatingLiteral->SetVal(nanf(""));
+  return astFloatingLiteral;
+}
+
+ASTExpr *ASTParser::ParseBuiltinSignBitf(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                         std::stringstream &ss) const {
+  return ProcessBuiltinFuncByName(allocator, expr, ss, "__signbitf");
+}
+
+ASTExpr *ASTParser::ParseBuiltinSignBitl(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                         std::stringstream &ss) const {
+  return ProcessBuiltinFuncByName(allocator, expr, ss, "__signbitl");
+}
+
+ASTExpr *ASTParser::ParseBuiltinTrap(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                     std::stringstream &ss) const {
+  return ProcessBuiltinFuncByName(allocator, expr, ss, "abort");
+}
+
+ASTExpr *ASTParser::ParseBuiltinCopysignf(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                          std::stringstream &ss) const {
+  return ProcessBuiltinFuncByName(allocator, expr, ss, "copysignf");
+}
+
+ASTExpr *ASTParser::ParseBuiltinCopysign(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                         std::stringstream &ss) const {
+  return ProcessBuiltinFuncByName(allocator, expr, ss, "copysign");
+}
+
+ASTExpr *ASTParser::ParseBuiltinCopysignl(MapleAllocator &allocator, const clang::CallExpr &expr,
+                                          std::stringstream &ss) const {
+  return ProcessBuiltinFuncByName(allocator, expr, ss, "copysignl");
+}
+} // namespace maple
diff --git a/src/hir2mpl/ast_input/clang/src/ast_stmt.cpp b/src/hir2mpl/ast_input/clang/src/ast_stmt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c91a562df0f3cc9d1b67bfea6e1ff9f5d002b071
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/src/ast_stmt.cpp
@@ -0,0 +1,681 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_stmt.h"
+#include "ast_decl.h"
+#include "ast_util.h"
+#include "mpl_logging.h"
+#include "feir_stmt.h"
+#include "feir_builder.h"
+#include "fe_utils_ast.h"
+#include "fe_manager.h"
+#include "ast_util.h"
+#include "enhance_c_checker.h"
+#include "conditional_operator.h"
+
+namespace maple {
+// ---------- ASTStmt ----------
+void ASTStmt::SetASTExpr(ASTExpr *astExpr) {
+  exprs.emplace_back(astExpr);
+}
+
+// ---------- ASTStmtDummy ----------
+std::list<UniqueFEIRStmt> ASTStmtDummy::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  for (auto expr : exprs) {
+    (void)expr->Emit2FEExpr(stmts);
+  }
+  return stmts;
+}
+
+// ---------- ASTCompoundStmt ----------
+void ASTCompoundStmt::SetASTStmt(ASTStmt *astStmt) {
+  astStmts.emplace_back(astStmt);
+}
+
+void ASTCompoundStmt::InsertASTStmtsAtFront(const std::list<ASTStmt*> &stmts) {
+  (void)astStmts.insert(astStmts.cbegin(), stmts.cbegin(), stmts.cend());
+}
+
+const MapleList<ASTStmt*> &ASTCompoundStmt::GetASTStmtList() const {
+  return astStmts;
+}
+
+std::list<UniqueFEIRStmt> ASTCompoundStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  auto insertStmt = [&stmts, this](bool flag) {
+    if (!FEOptions::GetInstance().IsEnableSafeRegion()) {
+      return;
+    }
+    UniqueFEIRStmt stmt;
+    if (safeSS == SafeSS::kSafeSS) {
+      stmt = std::make_unique<FEIRStmtPesudoSafe>(flag);
+    } else if (safeSS == SafeSS::kUnsafeSS) {
+      stmt = std::make_unique<FEIRStmtPesudoUnsafe>(flag);
+    }
+    if (stmt != nullptr) {
+      if (flag) {
+        stmt->SetSrcLoc(endLoc);
+      }
+      stmts.emplace_back(std::move(stmt));
+    }
+  };
+  insertStmt(false);
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  if (!hasEmitted2MIRScope) {
+    feFunction.PushStmtScope(FEUtils::CvtLoc2SrcPosition(GetSrcLoc()), FEUtils::CvtLoc2SrcPosition(GetEndLoc()));
+  }
+  for (auto it : astStmts) {
+    stmts.splice(stmts.end(), it->Emit2FEStmt());
+  }
+  if (!hasEmitted2MIRScope) {
+    UniqueFEIRScope scope = feFunction.PopTopScope();
+    if (scope->GetVLASavedStackVar() != nullptr) {
+      auto stackRestoreStmt = scope->GenVLAStackRestoreStmt();
+      stackRestoreStmt->SetSrcLoc(endLoc);
+      (void)stmts.emplace_back(std::move(stackRestoreStmt));
+    }
+    hasEmitted2MIRScope = true;
+  }
+  insertStmt(true);
+  return stmts;
+}
+
+// ---------- ASTReturnStmt ----------
+std::list<UniqueFEIRStmt> ASTReturnStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  auto astExpr = exprs.front();
+  UniqueFEIRExpr feExpr = (astExpr != nullptr) ? astExpr->Emit2FEExpr(stmts) : nullptr;
+  if (astExpr != nullptr && ConditionalOptimize::DeleteRedundantTmpVar(feExpr, stmts)) {
+    return stmts;
+  }
+  FEIRBuilder::EmitVLACleanupStmts(FEManager::GetCurrentFEFunction(), stmts);
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtReturn>(std::move(feExpr));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ---------- ASTIfStmt ----------
+std::list<UniqueFEIRStmt> ASTIfStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRStmt> thenStmts;
+  std::list<UniqueFEIRStmt> elseStmts;
+  if (thenStmt != nullptr) {
+    thenStmts = thenStmt->Emit2FEStmt();
+  }
+  if (elseStmt != nullptr) {
+    elseStmts = elseStmt->Emit2FEStmt();
+  }
+  UniqueFEIRExpr condFEExpr = condExpr->Emit2FEExpr(stmts);
+  condFEExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(condFEExpr));
+  UniqueFEIRStmt ifStmt = FEIRBuilder::CreateStmtIf(std::move(condFEExpr), thenStmts, elseStmts);
+  ifStmt->SetSrcLoc(loc);
+  stmts.emplace_back(std::move(ifStmt));
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTForStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  std::string loopBodyEndLabelName = FEUtils::GetSequentialName("dowhile_body_end_");
+  std::string loopEndLabelName = FEUtils::GetSequentialName("dowhile_end_");
+  AstLoopUtil::Instance().PushContinue(loopBodyEndLabelName);
+  AstLoopUtil::Instance().PushBreak(loopEndLabelName);
+  auto labelBodyEndStmt = std::make_unique<FEIRStmtLabel>(loopBodyEndLabelName);
+  auto labelLoopEndStmt = std::make_unique<FEIRStmtLabel>(loopEndLabelName);
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  if (!hasEmitted2MIRScope) {
+    feFunction.PushStmtScope(FEUtils::CvtLoc2SrcPosition(GetSrcLoc()),
+                             FEUtils::CvtLoc2SrcPosition(GetEndLoc()), true);
+  }
+  if (initStmt != nullptr) {
+    std::list<UniqueFEIRStmt> feStmts = initStmt->Emit2FEStmt();
+    stmts.splice(stmts.cend(), feStmts);
+  }
+  std::list<UniqueFEIRStmt> bodyFEStmts = bodyStmt->Emit2FEStmt();
+  if (AstLoopUtil::Instance().IsCurrentContinueLabelUsed()) {
+    bodyFEStmts.emplace_back(std::move(labelBodyEndStmt));
+  }
+  UniqueFEIRExpr condFEExpr;
+  if (condExpr != nullptr) {
+    (void)condExpr->Emit2FEExpr(stmts);
+  } else {
+    condFEExpr = std::make_unique<FEIRExprConst>(static_cast<int64>(1), PTY_i32);
+  }
+  if (incExpr != nullptr) {
+    std::list<UniqueFEIRStmt> incStmts;
+    UniqueFEIRExpr incFEExpr = incExpr->Emit2FEExpr(incStmts);
+    if (incFEExpr != nullptr && incStmts.size() == 2 && incStmts.front()->IsDummy()) {
+      incStmts.pop_front();
+    }
+    bodyFEStmts.splice(bodyFEStmts.cend(), incStmts);
+  }
+  if (condExpr != nullptr) {
+    std::list<UniqueFEIRStmt> condStmts;
+    condFEExpr = condExpr->Emit2FEExpr(condStmts);
+    bodyFEStmts.splice(bodyFEStmts.cend(), condStmts);
+  }
+  condFEExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(condFEExpr));
+  UniqueFEIRStmt whileStmt = std::make_unique<FEIRStmtDoWhile>(OP_while, std::move(condFEExpr), std::move(bodyFEStmts));
+  whileStmt->SetSrcLoc(loc);
+  stmts.emplace_back(std::move(whileStmt));
+  if (AstLoopUtil::Instance().IsCurrentBreakLabelUsed()) {
+    stmts.emplace_back(std::move(labelLoopEndStmt));
+  }
+  if (!hasEmitted2MIRScope) {
+    UniqueFEIRScope feirScope = feFunction.PopTopScope();
+    if (feirScope->GetVLASavedStackVar() != nullptr) {
+      auto stkRestoreStmt = feirScope->GenVLAStackRestoreStmt();
+      stkRestoreStmt->SetSrcLoc(endLoc);
+      (void)stmts.emplace_back(std::move(stkRestoreStmt));
+    }
+    hasEmitted2MIRScope = true;
+  }
+  AstLoopUtil::Instance().PopCurrentBreak();
+  AstLoopUtil::Instance().PopCurrentContinue();
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTWhileStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  std::string loopBodyEndLabelName = FEUtils::GetSequentialName("dowhile_body_end_");
+  std::string loopEndLabelName = FEUtils::GetSequentialName("dowhile_end_");
+  AstLoopUtil::Instance().PushBreak(loopEndLabelName);
+  AstLoopUtil::Instance().PushContinue(loopBodyEndLabelName);
+  auto labelBodyEndStmt = std::make_unique<FEIRStmtLabel>(loopBodyEndLabelName);
+  auto labelLoopEndStmt = std::make_unique<FEIRStmtLabel>(loopEndLabelName);
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  if (!hasEmitted2MIRScope) {
+    feFunction.PushStmtScope(true);
+  }
+  std::list<UniqueFEIRStmt> bodyFEStmts = bodyStmt->Emit2FEStmt();
+  std::list<UniqueFEIRStmt> condStmts;
+  std::list<UniqueFEIRStmt> condPreStmts;
+  UniqueFEIRExpr condFEExpr = condExpr->Emit2FEExpr(condStmts);
+  (void)condExpr->Emit2FEExpr(condPreStmts);
+  if (AstLoopUtil::Instance().IsCurrentContinueLabelUsed()) {
+    bodyFEStmts.emplace_back(std::move(labelBodyEndStmt));
+  }
+  bodyFEStmts.splice(bodyFEStmts.end(), condPreStmts);
+  condFEExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(condFEExpr));
+  auto whileStmt = std::make_unique<FEIRStmtDoWhile>(OP_while, std::move(condFEExpr), std::move(bodyFEStmts));
+  whileStmt->SetSrcLoc(loc);
+  stmts.splice(stmts.end(), condStmts);
+  stmts.emplace_back(std::move(whileStmt));
+  if (AstLoopUtil::Instance().IsCurrentBreakLabelUsed()) {
+    stmts.emplace_back(std::move(labelLoopEndStmt));
+  }
+  AstLoopUtil::Instance().PopCurrentBreak();
+  AstLoopUtil::Instance().PopCurrentContinue();
+  if (!hasEmitted2MIRScope) {
+    (void)feFunction.PopTopScope();
+    hasEmitted2MIRScope = true;
+  }
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTDoStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> feStmts;
+  FEFunction &feFunc = FEManager::GetCurrentFEFunction();
+  if (!hasEmitted2MIRScope) {
+    feFunc.PushStmtScope(true);
+  }
+  std::string loopBodyEndLabelName = FEUtils::GetSequentialName("dowhile_body_end_");
+  std::string loopEndLabelName = FEUtils::GetSequentialName("dowhile_end_");
+  AstLoopUtil::Instance().PushBreak(loopEndLabelName);
+  AstLoopUtil::Instance().PushContinue(loopBodyEndLabelName);
+  auto labelBodyEndStmt = std::make_unique<FEIRStmtLabel>(loopBodyEndLabelName);
+  auto labelLoopEndStmt = std::make_unique<FEIRStmtLabel>(loopEndLabelName);
+  std::list<UniqueFEIRStmt> bodyFEStmts;
+  if (bodyStmt != nullptr) {
+    bodyFEStmts = bodyStmt->Emit2FEStmt();
+  }
+  if (AstLoopUtil::Instance().IsCurrentContinueLabelUsed()) {
+    bodyFEStmts.emplace_back(std::move(labelBodyEndStmt));
+  }
+  std::list<UniqueFEIRStmt> condStmts;
+  UniqueFEIRExpr condFEExpr = condExpr->Emit2FEExpr(condStmts);
+  bodyFEStmts.splice(bodyFEStmts.end(), condStmts);
+  condFEExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(condFEExpr));
+  UniqueFEIRStmt whileStmt = std::make_unique<FEIRStmtDoWhile>(OP_dowhile, std::move(condFEExpr),
+                                                               std::move(bodyFEStmts));
+  whileStmt->SetSrcLoc(loc);
+  (void)feStmts.emplace_back(std::move(whileStmt));
+  if (AstLoopUtil::Instance().IsCurrentBreakLabelUsed()) {
+    (void)feStmts.emplace_back(std::move(labelLoopEndStmt));
+  }
+  AstLoopUtil::Instance().PopCurrentBreak();
+  AstLoopUtil::Instance().PopCurrentContinue();
+  if (!hasEmitted2MIRScope) {
+    (void)feFunc.PopTopScope();
+    hasEmitted2MIRScope = true;
+  }
+  return feStmts;
+}
+
+std::list<UniqueFEIRStmt> ASTBreakStmt::Emit2FEStmtImpl() const {
+  std::string breakName;
+  if (!AstLoopUtil::Instance().IsBreakLabelsEmpty()) {
+    breakName = AstLoopUtil::Instance().GetCurrentBreak();
+  }
+  std::string vlaLabelName = FEIRBuilder::EmitVLACleanupStmts(FEManager::GetCurrentFEFunction(), breakName, loc);
+  if (!vlaLabelName.empty()) {
+    breakName = vlaLabelName;
+  }
+  std::list<UniqueFEIRStmt> stmts;
+  auto stmt = std::make_unique<FEIRStmtBreak>();
+  stmt->SetBreakLabelName(breakName);
+  stmt->SetSrcLoc(loc);
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTLabelStmt::Emit2FEStmtImpl() const {
+  // collect scopes of label stmt
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  std::map<uint32, UniqueFEIRScope> scopes;
+  for (const auto &scope : feFunction.GetScopeStack()) {
+    scopes.insert(std::make_pair(scope->GetID(), scope->Clone()));
+  }
+  feFunction.SetLabelWithScopes(GetLabelName(), std::move(scopes));
+  std::list<UniqueFEIRStmt> stmts;
+  auto feStmt = std::make_unique<FEIRStmtLabel>(GetLabelName());
+  feStmt->SetSrcLoc(loc);
+  stmts.emplace_back(std::move(feStmt));
+  stmts.splice(stmts.end(), subStmt->Emit2FEStmt());
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTContinueStmt::Emit2FEStmtImpl() const {
+  std::string continueName = AstLoopUtil::Instance().GetCurrentContinue();
+  std::string vlaLabelName = FEIRBuilder::EmitVLACleanupStmts(FEManager::GetCurrentFEFunction(), continueName, loc);
+  if (!vlaLabelName.empty()) {
+    continueName = vlaLabelName;
+  }
+  std::list<UniqueFEIRStmt> stmts;
+  auto stmt = std::make_unique<FEIRStmtContinue>();
+  stmt->SetLabelName(continueName);
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ---------- ASTUnaryOperatorStmt ----------
+std::list<UniqueFEIRStmt> ASTUnaryOperatorStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> feExprs;
+  auto feExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feExpr != nullptr) {
+    if (stmts.size() == 2 && stmts.front()->IsDummy()) {
+      stmts.pop_front();
+      return stmts;
+    }
+    feExprs.emplace_back(std::move(feExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+// ---------- ASTGotoStmt ----------
+std::list<UniqueFEIRStmt> ASTGotoStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  auto stmt = std::make_unique<FEIRStmtGotoForC>(GetLabelName());
+  // collect scopes with vla of goto stmt
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  std::vector<std::pair<uint32, UniqueFEIRVar>> vlaSvaedStackVars;
+  for (const auto &scope : feFunction.GetScopeStack()) {
+    if (scope->GetVLASavedStackVar() != nullptr) {
+      stmt->AddVLASvaedStackVars(scope->GetID(), scope->GetVLASavedStackVar()->Clone());
+    }
+  }
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ---------- ASTIndirectGotoStmt ----------
+std::list<UniqueFEIRStmt> ASTIndirectGotoStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRExpr targetExpr = exprs.front()->Emit2FEExpr(stmts);
+  stmts.emplace_back(FEIRBuilder::CreateStmtIGoto(std::move(targetExpr)));
+  return stmts;
+}
+
+// ---------- ASTSwitchStmt ----------
+std::list<UniqueFEIRStmt> ASTSwitchStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  if (!hasEmitted2MIRScope) {
+    feFunction.PushStmtScope(true);
+  }
+  UniqueFEIRExpr expr = condExpr->Emit2FEExpr(stmts);
+  std::string exitName = AstSwitchUtil::Instance().CreateEndOrExitLabelName();
+  AstLoopUtil::Instance().PushBreak(exitName);
+  std::string tmpName = FEUtils::GetSequentialName("switch_cond");
+  UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *condType);
+  UniqueFEIRStmt condFEStmt = FEIRBuilder::CreateStmtDAssign(tmpVar->Clone(), std::move(expr));
+  stmts.emplace_back(std::move(condFEStmt));
+  auto dread = FEIRBuilder::CreateExprDRead(tmpVar->Clone());
+  auto switchStmt = std::make_unique<FEIRStmtSwitchForC>(std::move(dread), hasDefualt);
+  switchStmt->SetBreakLabelName(exitName);
+  for (auto &s : bodyStmt->Emit2FEStmt()) {
+    switchStmt.get()->AddFeirStmt(std::move(s));
+  }
+  stmts.emplace_back(std::move(switchStmt));
+  AstLoopUtil::Instance().PopCurrentBreak();
+  if (!hasEmitted2MIRScope) {
+    (void)feFunction.PopTopScope();
+    hasEmitted2MIRScope = true;
+  }
+  return stmts;
+}
+
+// ---------- ASTCaseStmt ----------
+std::list<UniqueFEIRStmt> ASTCaseStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  auto caseStmt = std::make_unique<FEIRStmtCaseForC>(lCaseTag);
+  caseStmt.get()->AddCaseTag2CaseVec(lCaseTag, rCaseTag);
+  for (auto &s : subStmt->Emit2FEStmt()) {
+    caseStmt.get()->AddFeirStmt(std::move(s));
+  }
+  stmts.emplace_back(std::move(caseStmt));
+  return stmts;
+}
+
+// ---------- ASTDefaultStmt ----------
+std::list<UniqueFEIRStmt> ASTDefaultStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  auto defaultStmt = std::make_unique<FEIRStmtDefaultForC>();
+  for (auto &s : child->Emit2FEStmt()) {
+    defaultStmt.get()->AddFeirStmt(std::move(s));
+  }
+  stmts.emplace_back(std::move(defaultStmt));
+  return stmts;
+}
+
+// ---------- ASTNullStmt ----------
+std::list<UniqueFEIRStmt> ASTNullStmt::Emit2FEStmtImpl() const {
+  // there is no need to process this stmt
+  std::list<UniqueFEIRStmt> stmts;
+  return stmts;
+}
+
+// ---------- ASTDeclStmt ----------
+std::list<UniqueFEIRStmt> ASTDeclStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  for (auto declInfo : subDeclInfos) {
+    if (std::holds_alternative<ASTExpr*>(declInfo)) {
+      ASTExpr *vlaSizeExpr = std::get<ASTExpr*>(declInfo);
+      if (vlaSizeExpr == nullptr) {
+        continue;
+      }
+      (void)vlaSizeExpr->Emit2FEExpr(stmts);
+    } else {
+      ASTDecl *decl = std::get<ASTDecl*>(declInfo);
+      if (decl == nullptr) {
+        continue;
+      }
+      decl->GenerateInitStmt(stmts);
+    }
+  }
+  return stmts;
+}
+
+// ---------- ASTCallExprStmt ----------
+std::list<UniqueFEIRStmt> ASTCallExprStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  ASTCallExpr *callExpr = static_cast<ASTCallExpr*>(exprs.front());
+  if (!callExpr->IsIcall()) {
+    bool isFinish = false;
+    (void)callExpr->ProcessBuiltinFunc(stmts, isFinish);
+    if (isFinish) {
+      return stmts;
+    }
+  }
+  std::unique_ptr<FEIRStmtAssign> callStmt = callExpr->GenCallStmt();
+  callExpr->AddArgsExpr(callStmt, stmts);
+  if (callExpr->IsNeedRetExpr()) {
+    UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *callExpr->GetRetType(), false, false);
+    callStmt->SetVar(std::move(var));
+  }
+  stmts.emplace_back(std::move(callStmt));
+  return stmts;
+}
+
+// ---------- ASTImplicitCastExprStmt ----------
+std::list<UniqueFEIRStmt> ASTImplicitCastExprStmt::Emit2FEStmtImpl() const {
+  CHECK_FATAL(exprs.size() == 1, "Only one sub expr supported!");
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRExpr feirExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feirExpr != nullptr) {
+    std::list<UniqueFEIRExpr> feirExprs;
+    feirExprs.emplace_back(std::move(feirExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feirExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+// ---------- ASTParenExprStmt ----------
+std::list<UniqueFEIRStmt> ASTParenExprStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  exprs.front()->Emit2FEExpr(stmts);
+  return stmts;
+}
+
+// ---------- ASTIntegerLiteralStmt ----------
+std::list<UniqueFEIRStmt> ASTIntegerLiteralStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> feExprs;
+  auto feExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feExpr != nullptr) {
+    feExprs.emplace_back(std::move(feExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+// ---------- ASTFloatingLiteralStmt ----------
+std::list<UniqueFEIRStmt> ASTFloatingLiteralStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> feExprs;
+  auto feExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feExpr != nullptr) {
+    feExprs.emplace_back(std::move(feExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+// ---------- ASTVAArgExprStmt ----------
+std::list<UniqueFEIRStmt> ASTVAArgExprStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  exprs.front()->Emit2FEExpr(stmts);
+  return stmts;
+}
+
+// ---------- ASTConditionalOperatorStmt ----------
+std::list<UniqueFEIRStmt> ASTConditionalOperatorStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> feExprs;
+  auto feExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feExpr != nullptr) {
+    feExprs.emplace_back(std::move(feExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+// ---------- ASTCharacterLiteralStmt ----------
+std::list<UniqueFEIRStmt> ASTCharacterLiteralStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> feExprs;
+  auto feExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feExpr != nullptr) {
+    feExprs.emplace_back(std::move(feExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+// ---------- ASTStmtExprStmt ----------
+std::list<UniqueFEIRStmt> ASTStmtExprStmt::Emit2FEStmtImpl() const {
+  return cpdStmt->Emit2FEStmt();
+}
+
+// ---------- ASTCStyleCastExprStmt ----------
+std::list<UniqueFEIRStmt> ASTCStyleCastExprStmt::Emit2FEStmtImpl() const {
+  CHECK_FATAL(exprs.front() != nullptr, "child expr must not be nullptr!");
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> feExprs;
+  auto feExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feExpr != nullptr) {
+    feExprs.emplace_back(std::move(feExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+// ---------- ASTCompoundAssignOperatorStmt ----------
+std::list<UniqueFEIRStmt> ASTCompoundAssignOperatorStmt::Emit2FEStmtImpl() const {
+  CHECK_FATAL(exprs.size() == 1, "ASTCompoundAssignOperatorStmt must contain only one bo expr!");
+  std::list<UniqueFEIRStmt> stmts;
+  CHECK_FATAL(static_cast<ASTAssignExpr*>(exprs.front()) != nullptr, "Child expr must be ASTCompoundAssignOperator!");
+  exprs.front()->Emit2FEExpr(stmts);
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTBinaryOperatorStmt::Emit2FEStmtImpl() const {
+  CHECK_FATAL(exprs.size() == 1, "ASTBinaryOperatorStmt must contain only one bo expr!");
+  std::list<UniqueFEIRStmt> stmts;
+  auto boExpr = static_cast<ASTBinaryOperatorExpr*>(exprs.front());
+  if (boExpr->GetASTOp() == kASTOpBO) {
+    UniqueFEIRExpr boFEExpr = boExpr->Emit2FEExpr(stmts);
+    if (boFEExpr != nullptr) {
+      std::list<UniqueFEIRExpr> exprs;
+      exprs.emplace_back(std::move(boFEExpr));
+      auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(exprs));
+      stmts.emplace_back(std::move(stmt));
+    }
+  } else {
+    // has been processed by child expr emit, skip here
+    UniqueFEIRExpr boFEExpr = boExpr->Emit2FEExpr(stmts);
+    return stmts;
+  }
+  return stmts;
+}
+
+// ---------- ASTAtomicExprStmt ----------
+std::list<UniqueFEIRStmt> ASTAtomicExprStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  auto astExpr = exprs.front();
+  UniqueFEIRExpr feExpr = astExpr->Emit2FEExpr(stmts);
+  auto stmt = std::make_unique<FEIRStmtAtomic>(std::move(feExpr));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ---------- ASTGCCAsmStmt ----------
+std::list<UniqueFEIRStmt> ASTGCCAsmStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  std::vector<UniqueFEIRExpr> outputsExprs;
+  std::vector<UniqueFEIRExpr> inputsExprs;
+  std::unique_ptr<FEIRStmtGCCAsm> stmt = std::make_unique<FEIRStmtGCCAsm>(GetAsmStr(), isGoto, isVolatile);
+  std::vector<std::tuple<std::string, std::string, bool>> outputsVec(outputs.begin(), outputs.end());
+  stmt->SetOutputs(outputsVec);
+  for (uint32 i = 0; i < outputs.size(); ++i) {
+    outputsExprs.emplace_back(exprs[i]->Emit2FEExpr(stmts));
+  }
+  stmt->SetOutputsExpr(outputsExprs);
+  std::vector<std::pair<std::string, std::string>> inputsVec(inputs.begin(), inputs.end());
+  stmt->SetInputs(inputsVec);
+  for (uint32 i = 0; i < inputs.size(); ++i) {
+    UniqueFEIRExpr expr;
+    if (inputs[i].second == "m") {
+      std::unique_ptr<ASTUOAddrOfExpr> addrOf = std::make_unique<ASTUOAddrOfExpr>();
+      addrOf->SetUOExpr(exprs[i + outputs.size()]);
+      expr = addrOf->Emit2FEExpr(stmts);
+    } else {
+      expr = exprs[i + outputs.size()]->Emit2FEExpr(stmts);
+    }
+    inputsExprs.emplace_back(std::move(expr));
+  }
+  stmt->SetInputsExpr(inputsExprs);
+  std::vector<std::string> clobbersVec(clobbers.begin(), clobbers.end());
+  stmt->SetClobbers(clobbersVec);
+  std::vector<std::string> labelsVec(labels.begin(), labels.end());
+  stmt->SetLabels(labelsVec);
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTOffsetOfStmt::Emit2FEStmtImpl() const {
+  CHECK_FATAL(exprs.front() != nullptr, "child expr must not be nullptr!");
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> feExprs;
+  auto feExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feExpr != nullptr) {
+    feExprs.emplace_back(std::move(feExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTGenericSelectionExprStmt::Emit2FEStmtImpl() const {
+  CHECK_FATAL(exprs.front() != nullptr, "child expr must not be nullptr!");
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> feExprs;
+  auto feExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feExpr != nullptr) {
+    feExprs.emplace_back(std::move(feExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTDeclRefExprStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  for (auto expr : exprs) {
+    (void)expr->Emit2FEExpr(stmts);
+  }
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTUnaryExprOrTypeTraitExprStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  for (auto expr : exprs) {
+    (void)expr->Emit2FEExpr(stmts);
+  }
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> ASTUOAddrOfLabelExprStmt::Emit2FEStmtImpl() const {
+  CHECK_FATAL(exprs.size() == 1, "ASTUOAddrOfLabelExprStmt must contain only one expr!");
+  CHECK_FATAL(exprs.front() != nullptr, "child expr must not be nullptr!");
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> feExprs;
+  UniqueFEIRExpr feExpr = exprs.front()->Emit2FEExpr(stmts);
+  if (feExpr != nullptr) {
+    feExprs.emplace_back(std::move(feExpr));
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+} // namespace maple
diff --git a/src/hir2mpl/ast_input/clang/src/ast_struct2fe_helper.cpp b/src/hir2mpl/ast_input/clang/src/ast_struct2fe_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2e73ac1c498d855f029073881077bf0769364f9a
--- /dev/null
+++ b/src/hir2mpl/ast_input/clang/src/ast_struct2fe_helper.cpp
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_struct2fe_helper.h"
+#include "fe_manager.h"
+#include "feir_builder.h"
+#include "fe_utils_ast.h"
+#include "ast_util.h"
+#include "ast_decl_builder.h"
+#include "enhance_c_checker.h"
+
+namespace maple {
+// ---------- ASTStruct2FEHelper ----------
+bool ASTStruct2FEHelper::ProcessDeclImpl() {
+  if (isSkipped) {
+    astStruct.ClearGenericAttrsContentMap();
+    return true;
+  }
+  if (mirStructType == nullptr) {
+    astStruct.ClearGenericAttrsContentMap();
+    return false;
+  }
+  mirStructType->SetTypeAttrs(GetStructAttributeFromInput());
+  // Process Fields
+  InitFieldHelpers();
+  ProcessFieldDef();
+  // Process Methods
+  InitMethodHelpers();
+  ProcessMethodDef();
+  astStruct.ClearGenericAttrsContentMap();
+  return true;
+}
+
+void ASTStruct2FEHelper::InitFieldHelpersImpl() {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mem pool is nullptr");
+  for (ASTField *field : astStruct.GetFields()) {
+    ASSERT(field != nullptr, "field is nullptr");
+    ASTStructField2FEHelper *fieldHelper = mp->New<ASTStructField2FEHelper>(
+        allocator, *field, *astStruct.GetTypeDesc().front());
+    fieldHelpers.push_back(fieldHelper);
+  }
+}
+
+void ASTStruct2FEHelper::InitMethodHelpersImpl() {
+}
+
+TypeAttrs ASTStruct2FEHelper::GetStructAttributeFromInputImpl() const {
+  GenericAttrs attrs = astStruct.GetGenericAttrs();
+  return attrs.ConvertToTypeAttrs();
+}
+
+ASTStruct2FEHelper::ASTStruct2FEHelper(MapleAllocator &allocator, ASTStruct &structIn)
+    : FEInputStructHelper(allocator), astStruct(structIn) {
+  srcLang = kSrcLangC;
+}
+
+std::string ASTStruct2FEHelper::GetStructNameOrinImpl() const {
+  return astStruct.GetStructName(false);
+}
+
+std::string ASTStruct2FEHelper::GetStructNameMplImpl() const {
+  return astStruct.GetStructName(true);
+}
+
+std::list<std::string> ASTStruct2FEHelper::GetSuperClassNamesImpl() const {
+  CHECK_FATAL(false, "NIY");
+  return std::list<std::string> {};
+}
+
+std::vector<std::string> ASTStruct2FEHelper::GetInterfaceNamesImpl() const {
+  CHECK_FATAL(false, "NIY");
+  return std::vector<std::string> {};
+}
+
+std::string ASTStruct2FEHelper::GetSourceFileNameImpl() const {
+  return astStruct.GetSrcFileName();
+}
+
+std::string ASTStruct2FEHelper::GetSrcFileNameImpl() const {
+  return astStruct.GetSrcFileName();
+}
+
+MIRStructType *ASTStruct2FEHelper::CreateMIRStructTypeImpl(bool &error) const {
+  std::string name = GetStructNameOrinImpl();
+  if (name.empty()) {
+    error = true;
+    ERR(kLncErr, "class name is empty");
+    return nullptr;
+  }
+  MIRStructType *type = FEManager::GetTypeManager().GetOrCreateStructType(astStruct.GenerateUniqueVarName());
+  error = false;
+  if (astStruct.IsUnion()) {
+    type->SetMIRTypeKind(kTypeUnion);
+  } else {
+    type->SetMIRTypeKind(kTypeStruct);
+  }
+  if (FEOptions::GetInstance().IsDbgFriendly() && type->GetAlias() == nullptr) {
+    MIRAlias *alias = allocator.GetMemPool()->New<MIRAlias>(&FEManager::GetModule());
+    type->SetAlias(alias);
+  }
+  return type;
+}
+
+uint64 ASTStruct2FEHelper::GetRawAccessFlagsImpl() const {
+  CHECK_FATAL(false, "NIY");
+  return 0;
+}
+
+GStrIdx ASTStruct2FEHelper::GetIRSrcFileSigIdxImpl() const {
+  // Not implemented, just return a invalid value
+  return GStrIdx(0);
+}
+
+bool ASTStruct2FEHelper::IsMultiDefImpl() const {
+  // Not implemented, alway return false
+  return false;
+}
+
+// ---------- ASTGlobalVar2FEHelper ---------
+bool ASTStructField2FEHelper::ProcessDeclImpl(MapleAllocator &allocator) {
+  (void)allocator;
+  CHECK_FATAL(false, "should not run here");
+  return false;
+}
+
+bool ASTStructField2FEHelper::ProcessDeclWithContainerImpl(MapleAllocator &allocator) {
+  (void)allocator;
+  std::string fieldName = field.GetName();
+  GStrIdx idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fieldName);
+  FieldAttrs attrs = field.GetGenericAttrs().ConvertToFieldAttrs();
+  attrs.SetAlign(field.GetAlign());
+  MIRType *fieldType = field.GetTypeDesc().front();
+  ASSERT(fieldType != nullptr, "nullptr check for fieldType");
+  ENCChecker::InsertBoundaryInAtts(attrs, field.GetBoundaryInfo());
+  if (attrs.GetAttr(FLDATTR_nonnull) ||
+      FEManager::GetTypeManager().IsOwnedNonnullFieldStructSet(fieldType->GetTypeIndex())) {  // nested struct
+    FEManager::GetTypeManager().InsertOwnedNonnullFieldStructSet(structType.GetTypeIndex());
+  }
+  mirFieldPair.first = idx;
+  mirFieldPair.second.first = fieldType->GetTypeIndex();
+  mirFieldPair.second.second = attrs;
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    MIRAlias *mirAlias = static_cast<MIRStructType&>(structType).GetAlias();
+    CHECK_NULL_FATAL(mirAlias);
+    TypeAttrs typeAttrs = field.GetGenericAttrs().ConvertToTypeAttrs();
+    MIRAliasVars aliasVar = FEUtils::AddAlias(idx, field.GetSourceType(), typeAttrs);
+    mirAlias->SetAliasVarMap(idx, aliasVar);
+  }
+  field.ClearGenericAttrsContentMap();
+  return true;
+}
+
+// ---------- ASTGlobalVar2FEHelper ---------
+bool ASTGlobalVar2FEHelper::ProcessDeclImpl(MapleAllocator &allocator) {
+  (void)allocator;
+  const std::string varName = astVar.GetName();
+  MIRType *type = astVar.GetTypeDesc().front();
+  TypeAttrs typeAttrs = astVar.GetGenericAttrs().ConvertToTypeAttrs();
+  ENCChecker::InsertBoundaryInAtts(typeAttrs, astVar.GetBoundaryInfo());
+  MIRSymbol *mirSymbol = FEManager::GetMIRBuilder().GetGlobalDecl(varName);
+  if (mirSymbol != nullptr) {
+    // do not allow extern var override global var
+    if (mirSymbol->GetStorageClass() != MIRStorageClass::kScExtern && typeAttrs.GetAttr(ATTR_extern)) {
+      typeAttrs.ResetAttr(ATTR_extern);
+    } else if (mirSymbol->GetStorageClass() == MIRStorageClass::kScExtern && !typeAttrs.GetAttr(ATTR_extern)) {
+      mirSymbol->SetStorageClass(MIRStorageClass::kScGlobal);
+    }
+  } else {
+    mirSymbol = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl(varName, *type);
+  }
+  if (mirSymbol == nullptr) {
+    return false;
+  }
+  // Set the type here in case a previous declaration had an incomplete
+  // array type and the definition has the complete type.
+  if (mirSymbol->GetType()->GetTypeIndex() != type->GetTypeIndex()) {
+    mirSymbol->SetTyIdx(type->GetTypeIndex());
+  }
+  if (mirSymbol->GetSrcPosition().LineNum() == 0) {
+    mirSymbol->SetSrcPosition(FEUtils::CvtLoc2SrcPosition(astVar.GetSrcLoc()));
+  }
+  if (typeAttrs.GetAttr(ATTR_extern)) {
+    mirSymbol->SetStorageClass(MIRStorageClass::kScExtern);
+    typeAttrs.ResetAttr(AttrKind::ATTR_extern);
+  } else if (typeAttrs.GetAttr(ATTR_static)) {
+    mirSymbol->SetStorageClass(MIRStorageClass::kScFstatic);
+  } else {
+    mirSymbol->SetStorageClass(MIRStorageClass::kScGlobal);
+  }
+  typeAttrs.SetAlign(astVar.GetAlign());
+  mirSymbol->AddAttrs(typeAttrs);
+  if (!astVar.GetSectionAttr().empty()) {
+    mirSymbol->sectionAttr = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(astVar.GetSectionAttr());
+  }
+  if (!astVar.GetAsmAttr().empty()) {
+    mirSymbol->SetAsmAttr(GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(astVar.GetAsmAttr()));
+  }
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    MIRScope *scope = FEManager::GetModule().GetScope();
+    FEUtils::AddAliasInMIRScope(*scope, varName, *mirSymbol, astVar.GetSourceType());
+  }
+  const ASTExpr *initExpr = astVar.GetInitExpr();
+  MIRConst *cst = nullptr;
+  if (initExpr != nullptr) {
+    cst = initExpr->GenerateMIRConst();
+    mirSymbol->SetKonst(cst);
+  }
+  ENCChecker::CheckNonnullGlobalVarInit(*mirSymbol, cst);
+  return true;
+}
+
+// ---------- ASTFileScopeAsm2FEHelper ---------
+bool ASTFileScopeAsm2FEHelper::ProcessDeclImpl(MapleAllocator &allocator) {
+  MapleString asmDecl(astAsm.GetAsmStr().c_str(), allocator.GetMemPool());
+  FEManager::GetModule().GetAsmDecls().emplace_back(asmDecl);
+  return true;
+}
+
+// ---------- ASTEnum2FEHelper ---------
+bool ASTEnum2FEHelper::ProcessDeclImpl(MapleAllocator &allocator) {
+  (void)allocator;
+  MIREnum *enumType = FEManager::GetTypeManager().GetOrCreateEnum(
+      astEnum.GenerateUniqueVarName(), astEnum.GetTypeDesc().front()->GetPrimType());
+  if (!astEnum.GetEnumConstants().empty() && enumType->GetElements().empty()) {
+    for (auto elem : astEnum.GetEnumConstants()) {
+      GStrIdx elemNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(elem->GetName());
+      enumType->NewElement(elemNameIdx, elem->GetValue());
+    }
+    enumType->SetPrimType(astEnum.GetEnumConstants().front()->GetTypeDesc().front()->GetPrimType());
+  }
+  return true;
+}
+
+// ---------- ASTFunc2FEHelper ----------
+bool ASTFunc2FEHelper::ProcessDeclImpl(MapleAllocator &allocator) {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  ASSERT(srcLang != kSrcLangUnknown, "src lang not set");
+  std::string methodShortName = GetMethodName(false, false);
+  CHECK_FATAL(!methodShortName.empty(), "error: method name is empty");
+  if (methodShortName.compare("main") == 0) {
+    FEManager::GetMIRBuilder().GetMirModule().SetEntryFuncName(methodShortName);
+  }
+  methodNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(methodShortName);
+  if (!ASTUtil::InsertFuncSet(methodNameIdx)) {
+    func.ClearGenericAttrsContentMap();
+    return true;
+  }
+  SolveReturnAndArgTypes(allocator);
+  bool isStatic = IsStatic();
+  bool isVarg = IsVarg();
+  CHECK_FATAL(retMIRType != nullptr, "function must have return type");
+  std::vector<TyIdx> argsTypeIdx;
+  for (auto *type : argMIRTypes) {
+    argsTypeIdx.push_back(type->GetTypeIndex());
+  }
+  mirFunc = FEManager::GetTypeManager().CreateFunction(methodNameIdx, retMIRType->GetTypeIndex(),
+                                                       argsTypeIdx, isVarg, isStatic);
+  mirFunc->SetSrcPosition(FEUtils::CvtLoc2SrcPosition(func.GetSrcLoc()));
+  MIRSymbol *funSym = mirFunc->GetFuncSymbol();
+  ASSERT_NOT_NULL(funSym);
+  if (!func.GetSectionAttr().empty()) {
+    funSym->sectionAttr = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(func.GetSectionAttr());
+  }
+  if (func.GetWeakrefAttr().first) {
+    std::string attrStr = func.GetWeakrefAttr().second;
+    UStrIdx idx { 0 };
+    if (!attrStr.empty()) {
+      idx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(attrStr);
+    }
+    funSym->SetWeakrefAttr(std::pair<bool, UStrIdx> { true, idx });
+  }
+  SolveFunctionArguments();
+  SolveFunctionAttributes();
+  func.ClearGenericAttrsContentMap();
+  return true;
+}
+
+void ASTFunc2FEHelper::SolveFunctionArguments() const {
+  MapleVector<ASTDecl*> paramDecls = func.GetParamDecls();
+  if (firstArgRet) {
+    ASTDecl *returnParamVar = ASTDeclsBuilder::ASTVarBuilder(allocator, MapleString("", allocator.GetMemPool()),
+        "first_arg_return", MapleVector<MIRType*>({}, allocator.Adapter()), GenericAttrs());
+    returnParamVar->SetIsParam(true);
+    (void)paramDecls.insert(paramDecls.cbegin(), returnParamVar);
+  }
+  for (uint32 i = 0; i < paramDecls.size(); ++i) {
+    MIRSymbol *sym = FEManager::GetMIRBuilder().GetOrCreateDeclInFunc(
+        paramDecls[i]->GetName(), *argMIRTypes[i], *mirFunc);
+    ASSERT_NOT_NULL(sym);
+    sym->SetStorageClass(kScFormal);
+    sym->SetSKind(kStVar);
+    TypeAttrs typeAttrs = paramDecls[i]->GetGenericAttrs().ConvertToTypeAttrs();
+    ENCChecker::InsertBoundaryInAtts(typeAttrs, paramDecls[i]->GetBoundaryInfo());
+    sym->AddAttrs(typeAttrs);
+    mirFunc->AddArgument(sym);
+    if (FEOptions::GetInstance().IsDbgFriendly() && paramDecls[i]->GetDeclKind() == kASTVar &&
+        (!firstArgRet || i != 0)) {
+      FEUtils::AddAliasInMIRScope(*mirFunc->GetScope(), paramDecls[i]->GetName(), *sym,
+                                  static_cast<ASTVar*>(paramDecls[i])->GetSourceType());
+    }
+  }
+}
+
+void ASTFunc2FEHelper::SolveFunctionAttributes() {
+  FuncAttrs attrs = GetAttrs();
+  if (firstArgRet) {
+    attrs.SetAttr(FUNCATTR_firstarg_return);
+  }
+  mirMethodPair.first = mirFunc->GetStIdx();
+  mirMethodPair.second.first = mirFunc->GetMIRFuncType()->GetTypeIndex();
+  ENCChecker::InsertBoundaryInAtts(attrs, func.GetBoundaryInfo());
+  mirMethodPair.second.second = attrs;
+  mirFunc->SetFuncAttrs(attrs);
+  if (firstArgRet) {
+    mirFunc->GetMIRFuncType()->funcAttrs.SetAttr(FUNCATTR_firstarg_return);
+  }
+}
+
+const std::string ASTFunc2FEHelper::GetSrcFileName() const {
+  return func.GetSrcFileName();
+}
+
+void ASTFunc2FEHelper::SolveReturnAndArgTypesImpl(MapleAllocator &allocator) {
+  (void)allocator;
+  const MapleVector<MIRType*> &returnAndArgTypeNames = func.GetTypeDesc();
+  retMIRType = returnAndArgTypeNames[1];
+  // skip funcType and returnType
+  (void)argMIRTypes.insert(argMIRTypes.cbegin(), returnAndArgTypeNames.cbegin() + 2, returnAndArgTypeNames.cend());
+  if (retMIRType->GetPrimType() == PTY_agg && retMIRType->GetSize() > 16) {
+    firstArgRet = true;
+    MIRType *retPointerType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*retMIRType);
+    (void)argMIRTypes.insert(argMIRTypes.cbegin(), retPointerType);
+    retMIRType = GlobalTables::GetTypeTable().GetPrimType(PTY_void);
+  }
+}
+
+std::string ASTFunc2FEHelper::GetMethodNameImpl(bool inMpl, bool full) const {
+  std::string funcName = func.GetName();
+  if (!full) {
+    return inMpl ? namemangler::EncodeName(funcName) : funcName;
+  }
+  // fullName not implemented yet
+  return funcName;
+}
+
+bool ASTFunc2FEHelper::IsVargImpl() const {
+  return false;
+}
+
+bool ASTFunc2FEHelper::HasThisImpl() const {
+  CHECK_FATAL(false, "NIY");
+  return false;
+}
+
+MIRType *ASTFunc2FEHelper::GetTypeForThisImpl() const {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+FuncAttrs ASTFunc2FEHelper::GetAttrsImpl() const {
+  return func.GetGenericAttrs().ConvertToFuncAttrs();
+}
+
+bool ASTFunc2FEHelper::IsStaticImpl() const {
+  return false;
+}
+
+bool ASTFunc2FEHelper::IsVirtualImpl() const {
+  CHECK_FATAL(false, "NIY");
+  return false;
+}
+bool ASTFunc2FEHelper::IsNativeImpl() const {
+  CHECK_FATAL(false, "NIY");
+  return false;
+}
+
+bool ASTFunc2FEHelper::HasCodeImpl() const {
+  return func.HasCode();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/ast_input/common/include/ast_compiler_component-inl.h b/src/hir2mpl/ast_input/common/include/ast_compiler_component-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..019bc25d1730b078593fc5a7cb86869ad937f199
--- /dev/null
+++ b/src/hir2mpl/ast_input/common/include/ast_compiler_component-inl.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_compiler_component.h"
+#include "ast_struct2fe_helper.h"
+#include "ast_function.h"
+#include "fe_timer.h"
+#include "fe_manager.h"
+
+namespace maple {
+template<class T>
+ASTCompilerComponent<T>::ASTCompilerComponent(MIRModule &module)
+    : HIR2MPLCompilerComponent(module, kSrcLangC),
+      mp(FEUtils::NewMempool("MemPool for ASTCompilerComponent", false /* isLcalPool */)),
+      allocator(mp),
+      astInput(module, allocator) {}
+
+template<class T>
+ASTCompilerComponent<T>::~ASTCompilerComponent() {
+  mp = nullptr;
+}
+
+template<class T>
+bool ASTCompilerComponent<T>::ParseInputImpl() {
+  FETimer timer;
+  bool success = true;
+  timer.StartAndDump("ASTCompilerComponent::ParseInput()");
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process ASTCompilerComponent::ParseInput() =====");
+  std::vector<std::string> inputNames;
+  if (typeid(T) == typeid(ASTParser)) {
+    inputNames = FEOptions::GetInstance().GetInputASTFiles();
+#ifdef ENABLE_MAST
+  } else if (typeid(T) == typeid(MapleASTParser)) {
+    inputNames = FEOptions::GetInstance().GetInputMASTFiles();
+#endif
+  }
+  success = success && astInput.ReadASTFiles(allocator, inputNames);
+  CHECK_FATAL(success, "ASTCompilerComponent::ParseInput failed. Exit.");
+  ParseInputStructs();
+  ParseInputFuncs();
+
+  for (auto &astVar : astInput.GetASTVars()) {
+    FEInputGlobalVarHelper *varHelper = allocator.GetMemPool()->New<ASTGlobalVar2FEHelper>(allocator, *astVar);
+    globalVarHelpers.emplace_back(varHelper);
+  }
+
+  for (auto &astFileScopeAsm : astInput.GetASTFileScopeAsms()) {
+    FEInputFileScopeAsmHelper *asmHelper = allocator.GetMemPool()->New<ASTFileScopeAsm2FEHelper>(
+        allocator, *astFileScopeAsm);
+    globalFileScopeAsmHelpers.emplace_back(asmHelper);
+  }
+
+  for (auto &astEnum : astInput.GetASTEnums()) {
+    ASTEnum2FEHelper *enumHelper = allocator.GetMemPool()->New<ASTEnum2FEHelper>(allocator, *astEnum);
+    (void)enumHelpers.emplace_back(enumHelper);
+  }
+  timer.StopAndDumpTimeMS("ASTCompilerComponent::ParseInput()");
+  return success;
+}
+
+template<class T>
+void ASTCompilerComponent<T>::ParseInputStructs() {
+  for (auto &astStruct : astInput.GetASTStructs()) {
+    std::string structName = astStruct->GenerateUniqueVarName();
+    // skip same name structs
+    if (structNameSet.find(structName) != structNameSet.cend()) {
+      continue;
+    }
+    FEInputStructHelper *structHelper = allocator.GetMemPool()->New<ASTStruct2FEHelper>(allocator, *astStruct);
+    structHelpers.emplace_back(structHelper);
+    structNameSet.insert(structName);
+  }
+}
+
+template<class T>
+void ASTCompilerComponent<T>::ParseInputFuncs() {
+  for (auto &astFunc : astInput.GetASTFuncs()) {
+    auto it = funcNameMap.find(astFunc->GetName());
+    if (it != funcNameMap.cend()) {
+      // save the function with funcbody
+      if (it->second->HasCode() && !astFunc->HasCode()) {
+        continue;
+      } else {
+        (void)funcNameMap.erase(it);
+        auto itHelper = std::find_if(std::begin(globalFuncHelpers), std::end(globalFuncHelpers),
+            [&astFunc](FEInputMethodHelper *s) -> bool {
+              return (s->GetMethodName(false) == astFunc->GetName());
+            });
+        CHECK_FATAL(itHelper != globalFuncHelpers.end(), "astFunc not found");
+        (void)globalFuncHelpers.erase(itHelper);
+      }
+    }
+    FEInputMethodHelper *funcHelper = allocator.GetMemPool()->New<ASTFunc2FEHelper>(allocator, *astFunc);
+    globalFuncHelpers.emplace_back(funcHelper);
+    funcNameMap.insert(std::make_pair(astFunc->GetName(), funcHelper));
+  }
+}
+
+template<class T>
+bool ASTCompilerComponent<T>::PreProcessDeclImpl() {
+  FETimer timer;
+  timer.StartAndDump("ASTCompilerComponent::PreProcessDecl()");
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process ASTCompilerComponent::PreProcessDecl() =====");
+  bool success = true;
+  for (FEInputStructHelper *helper : structHelpers) {
+    ASSERT_NOT_NULL(helper);
+    success = helper->PreProcessDecl() ? success : false;
+  }
+  timer.StopAndDumpTimeMS("ASTCompilerComponent::PreProcessDecl()");
+  return success;
+}
+
+template<class T>
+std::unique_ptr<FEFunction> ASTCompilerComponent<T>::CreatFEFunctionImpl(FEInputMethodHelper *methodHelper) {
+  ASTFunc2FEHelper *astFuncHelper = static_cast<ASTFunc2FEHelper*>(methodHelper);
+  GStrIdx methodNameIdx = methodHelper->GetMethodNameIdx();
+  bool isStatic = methodHelper->IsStatic();
+  MIRFunction *mirFunc = FEManager::GetTypeManager().GetMIRFunction(methodNameIdx, isStatic);
+  CHECK_NULL_FATAL(mirFunc);
+  module.AddFunction(mirFunc);
+  std::unique_ptr<FEFunction> feFunction = std::make_unique<ASTFunction>(*astFuncHelper, *mirFunc, phaseResultTotal);
+  feFunction->Init();
+  return feFunction;
+}
+
+template<class T>
+bool ASTCompilerComponent<T>::ProcessFunctionSerialImpl() {
+  std::stringstream ss;
+  ss << GetComponentName() << "::ProcessFunctionSerial()";
+  FETimer timer;
+  timer.StartAndDump(ss.str());
+  bool success = true;
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process %s =====", ss.str().c_str());
+  for (FEInputMethodHelper *methodHelper : globalFuncHelpers) {
+    ASSERT_NOT_NULL(methodHelper);
+    if (methodHelper->HasCode()) {
+      ASTFunc2FEHelper *astFuncHelper = static_cast<ASTFunc2FEHelper*>(methodHelper);
+      std::unique_ptr<FEFunction> feFunction = CreatFEFunction(methodHelper);
+      feFunction->SetSrcFileName(astFuncHelper->GetSrcFileName());
+      bool processResult = feFunction->Process();
+      if (!processResult) {
+        (void)compileFailedFEFunctions.insert(feFunction.get());
+      }
+      success = success && processResult;
+      feFunction->Finish();
+    }
+    funcSize++;
+  }
+  timer.StopAndDumpTimeMS(ss.str());
+  return success;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/ast_input/common/include/ast_compiler_component.h b/src/hir2mpl/ast_input/common/include/ast_compiler_component.h
new file mode 100644
index 0000000000000000000000000000000000000000..be00e27ab356d0c60bd1e70dfa29084da80d24b6
--- /dev/null
+++ b/src/hir2mpl/ast_input/common/include/ast_compiler_component.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_INPUT_INCLUDE_AST_COMPILER_COMPONENT_H
+#define HIR2MPL_AST_INPUT_INCLUDE_AST_COMPILER_COMPONENT_H
+#include "fe_macros.h"
+#include "hir2mpl_compiler_component.h"
+#include "ast_input.h"
+#include "ast_input-inl.h"
+
+namespace maple {
+template<class T>
+class ASTCompilerComponent : public HIR2MPLCompilerComponent {
+ public:
+  explicit ASTCompilerComponent(MIRModule &module);
+  ~ASTCompilerComponent() override;
+
+ protected:
+  bool ParseInputImpl() override;
+  bool PreProcessDeclImpl() override;
+  std::unique_ptr<FEFunction> CreatFEFunctionImpl(FEInputMethodHelper *methodHelper) override;
+  bool ProcessFunctionSerialImpl() override;
+  std::string GetComponentNameImpl() const override {
+    return "ASTCompilerComponent";
+  }
+  bool ParallelableImpl() const override {
+    return true;
+  }
+  void DumpPhaseTimeTotalImpl() const override {
+    INFO(kLncInfo, "[PhaseTime] ASTCompilerComponent");
+    HIR2MPLCompilerComponent::DumpPhaseTimeTotalImpl();
+  }
+  void ReleaseMemPoolImpl() override {
+    FEUtils::DeleteMempoolPtr(mp);
+  }
+
+ private:
+  MemPool *mp;
+  MapleAllocator allocator;
+  ASTInput<T> astInput;
+  std::unordered_set<std::string> structNameSet;
+  std::unordered_map<std::string, FEInputMethodHelper*> funcNameMap;
+
+  void ParseInputStructs();
+  void ParseInputFuncs();
+};  // class ASTCompilerComponent
+}  // namespace maple
+#endif  // HIR2MPL_AST_INPUT_INCLUDE_AST_COMPILER_COMPONENT_H
diff --git a/src/hir2mpl/ast_input/common/include/ast_decl.h b/src/hir2mpl/ast_input/common/include/ast_decl.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e7069d22a05343ec03eee23bce5846ab60b2116
--- /dev/null
+++ b/src/hir2mpl/ast_input/common/include/ast_decl.h
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_INPUT_INCLUDE_AST_DECL_H
+#define HIR2MPL_AST_INPUT_INCLUDE_AST_DECL_H
+#include <string>
+#include <list>
+#include <vector>
+#include "types_def.h"
+#include "ast_stmt.h"
+#include "feir_var.h"
+#include "fe_function.h"
+#include "generic_attrs.h"
+
+namespace maple {
+enum DeclKind {
+  kUnknownDecl = 0,
+  kASTDecl,
+  kASTField,
+  kASTFunc,
+  kASTStruct,
+  kASTVar,
+  kASTEnumConstant,
+  kASTEnumDecl,
+  kASTFileScopeAsm,
+  kASTTypedefDecl,
+};
+
+struct BoundaryInfo {
+  ASTExpr *lenExpr = nullptr;
+  int8 lenParamIdx = -1;  // -1 means not on the parameter
+  bool isBytedLen = false;
+};
+
+class ASTDecl {
+ public:
+  ASTDecl(const MapleString &srcFile, const MapleString &nameIn, const MapleVector<MIRType*> &typeDescIn)
+      : isGlobalDecl(false), srcFileName(srcFile), name(nameIn), typeDesc(typeDescIn) {}
+  virtual ~ASTDecl() = default;
+  const std::string GetSrcFileName() const;
+  const std::string GetName() const;
+  const MapleVector<MIRType*> &GetTypeDesc() const;
+  void SetTypeDesc(const MapleVector<MIRType*> &typeVecIn);
+  GenericAttrs GetGenericAttrs() const {
+    return genAttrs;
+  }
+
+  void SetGlobal(bool isGlobal) {
+    isGlobalDecl = isGlobal;
+  }
+
+  bool IsGlobal() const {
+    return isGlobalDecl;
+  }
+
+  void SetIsParam(bool flag) {
+    isParam = flag;
+  }
+
+  bool IsParam() const {
+    return isParam;
+  }
+
+  void SetIsMacro(bool flag) {
+    if (flag) {
+      isMacroID = FEUtils::GetSequentialNumber();
+    } else {
+      isMacroID = static_cast<uint32>(flag);
+    }
+  }
+
+  uint32 IsMacroID() const {
+    return isMacroID;
+  }
+
+  void SetAlign(uint32 n) {
+    if (n > align) {
+      align = n;
+    }
+  }
+
+  uint32 GetAlign() const {
+    return align;
+  }
+
+  void SetAttr(GenericAttrKind attrKind) {
+    genAttrs.SetAttr(attrKind);
+  }
+
+  void SetSectionAttr(const std::string &str) {
+    sectionAttr = str;
+  }
+
+  const std::string &GetSectionAttr() const {
+    return sectionAttr;
+  }
+
+  void GenerateInitStmt(std::list<UniqueFEIRStmt> &stmts) {
+    return GenerateInitStmtImpl(stmts);
+  }
+
+  void SetSrcLoc(const Loc &l) {
+    loc = l;
+  }
+
+  const Loc &GetSrcLoc() const {
+    return loc;
+  }
+
+  uint32 GetSrcFileIdx() const {
+    return loc.fileIdx;
+  }
+
+  uint32 GetSrcFileLineNum() const {
+    return loc.line;
+  }
+
+  uint32 GetSrcFileColumn() const {
+    return loc.column;
+  }
+
+  DeclKind GetDeclKind() const {
+    return declKind;
+  }
+
+  MIRConst *Translate2MIRConst() const;
+
+  std::string GenerateUniqueVarName() const;
+
+  void SetBoundaryLenExpr(ASTExpr *expr) {
+    boundary.lenExpr = expr;
+  }
+
+  const BoundaryInfo &GetBoundaryInfo() const {
+    return boundary;
+  }
+
+  ASTExpr *GetBoundaryLenExpr() const {
+    return boundary.lenExpr;
+  }
+
+  void SetBoundaryLenParamIdx(int8 idx) {
+    boundary.lenParamIdx = idx;
+  }
+
+  int8 GetBoundaryLenParamIdx() const {
+    return boundary.lenParamIdx;
+  }
+
+  void SetIsBytedLen(bool flag) {
+    boundary.isBytedLen = flag;
+  }
+
+  bool IsBytedLen() const {
+    return boundary.isBytedLen;
+  }
+
+  void ClearGenericAttrsContentMap() {
+    genAttrs.ClearContentMap();
+  }
+
+  const MIRType *GetSourceType() const {
+    return sourceType;
+  }
+
+  void SetSourceType(MIRType *type) {
+    sourceType = type;
+  }
+
+ protected:
+  virtual MIRConst *Translate2MIRConstImpl() const {
+    CHECK_FATAL(false, "Maybe implemented for other ASTDecls");
+    return nullptr;
+  }
+  virtual void GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) {}
+  bool isGlobalDecl;
+  bool isParam = false;
+  uint32 align = 1; // in byte
+  const MapleString srcFileName;
+
+  MapleString name;
+  MapleVector<MIRType*> typeDesc;
+  GenericAttrs genAttrs;
+  Loc loc = { 0, 0, 0 };
+  uint32 isMacroID = false;
+  DeclKind declKind = kASTDecl;
+  BoundaryInfo boundary;
+  std::string sectionAttr;
+  MIRType *sourceType = nullptr;
+};
+
+class ASTField : public ASTDecl {
+ public:
+  ASTField(const MapleString &srcFile, const MapleString &nameIn, const MapleVector<MIRType*> &typeDescIn,
+           const GenericAttrs &genAttrsIn, bool isAnonymous = false)
+      : ASTDecl(srcFile, nameIn, typeDescIn), isAnonymousField(isAnonymous) {
+    genAttrs = genAttrsIn;
+    declKind = kASTField;
+  }
+  ~ASTField() = default;
+  bool IsAnonymousField() const {
+    return isAnonymousField;
+  }
+
+ private:
+  bool isAnonymousField = false;
+};
+
+class ASTFunc : public ASTDecl {
+ public:
+  ASTFunc(const MapleString &srcFile, const MapleString &nameIn, const MapleVector<MIRType*> &typeDescIn,
+          const GenericAttrs &genAttrsIn, const MapleVector<ASTDecl*> &paramDeclsIn)
+      : ASTDecl(srcFile, nameIn, typeDescIn), compound(nullptr), paramDecls(paramDeclsIn) {
+    genAttrs = genAttrsIn;
+    declKind = kASTFunc;
+  }
+  ~ASTFunc() override {
+    compound = nullptr;
+  }
+  void SetCompoundStmt(ASTStmt *astCompoundStmt);
+  void InsertStmtsIntoCompoundStmtAtFront(const std::list<ASTStmt*> &stmts) const;
+  const ASTStmt *GetCompoundStmt() const;
+  const MapleVector<ASTDecl*> &GetParamDecls() const {
+    return paramDecls;
+  }
+  std::vector<std::unique_ptr<FEIRVar>> GenArgVarList() const;
+  std::list<UniqueFEIRStmt> EmitASTStmtToFEIR() const;
+  std::list<UniqueFEIRStmt> InitArgsBoundaryVar(MIRFunction &mirFunc) const;
+  void InsertBoundaryCheckingInRet(std::list<UniqueFEIRStmt> &stmts) const;
+
+  void SetWeakrefAttr(const std::pair<bool, std::string> &attr) {
+    weakrefAttr = attr;
+  }
+
+  const std::pair<bool, std::string> &GetWeakrefAttr() const {
+    return weakrefAttr;
+  }
+
+  bool HasCode() const {
+    if (compound == nullptr) {
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  // typeDesc format: [funcType, retType, arg0, arg1 ... argN]
+  ASTStmt *compound = nullptr;  // func body
+  MapleVector<ASTDecl*> paramDecls;
+  std::pair<bool, std::string> weakrefAttr;
+};
+
+class ASTStruct : public ASTDecl {
+ public:
+  ASTStruct(MapleAllocator &allocatorIn, const MapleString &srcFile, const MapleString &nameIn,
+            const MapleVector<MIRType*> &typeDescIn, const GenericAttrs &genAttrsIn)
+      : ASTDecl(srcFile, nameIn, typeDescIn),
+        isUnion(false), fields(allocatorIn.Adapter()), methods(allocatorIn.Adapter()) {
+    genAttrs = genAttrsIn;
+    declKind = kASTStruct;
+  }
+  ~ASTStruct() = default;
+
+  std::string GetStructName(bool mapled) const;
+
+  void SetField(ASTField *f) {
+    fields.emplace_back(f);
+  }
+
+  const MapleList<ASTField*> &GetFields() const {
+    return fields;
+  }
+
+  void SetIsUnion() {
+    isUnion = true;
+  }
+
+  bool IsUnion() const {
+    return isUnion;
+  }
+
+ private:
+  void GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) override;
+
+  bool isUnion = false;
+  MapleList<ASTField*> fields;
+  MapleList<ASTFunc*> methods;
+};
+
+class ASTVar : public ASTDecl {
+ public:
+  ASTVar(const MapleString &srcFile, const MapleString &nameIn, const MapleVector<MIRType*> &typeDescIn,
+         const GenericAttrs &genAttrsIn)
+      : ASTDecl(srcFile, nameIn, typeDescIn) {
+    genAttrs = genAttrsIn;
+    declKind = kASTVar;
+  }
+  virtual ~ASTVar() = default;
+
+  void SetInitExpr(ASTExpr *init) {
+    initExpr = init;
+  }
+
+  const ASTExpr *GetInitExpr() const {
+    return initExpr;
+  }
+
+  void SetAsmAttr(const std::string &str) {
+    asmAttr = str;
+  }
+
+  const std::string &GetAsmAttr() const {
+    return asmAttr;
+  }
+
+  void SetVariableArrayExpr(ASTExpr *expr) {
+    variableArrayExpr = expr;
+  }
+
+  void SetPromotedType(PrimType primType) {
+    promotedType = primType;
+  }
+
+  PrimType GetPromotedType() const {
+    return promotedType;
+  }
+
+  std::unique_ptr<FEIRVar> Translate2FEIRVar() const;
+  MIRSymbol *Translate2MIRSymbol() const;
+
+ private:
+  MIRConst *Translate2MIRConstImpl() const override;
+  void GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) override;
+  void GenerateInitStmt4StringLiteral(const ASTExpr *initASTExpr, const UniqueFEIRVar &feirVar,
+                                      const UniqueFEIRExpr &initFeirExpr, std::list<UniqueFEIRStmt> &stmts) const;
+  ASTExpr *initExpr = nullptr;
+  std::string asmAttr;
+  ASTExpr *variableArrayExpr = nullptr;
+  PrimType promotedType = PTY_void;
+  bool hasAddedInMIRScope = false;
+};
+
+class ASTFileScopeAsm : public ASTDecl {
+ public:
+  ASTFileScopeAsm(MapleAllocator &allocatorIn, const MapleString &srcFile)
+      : ASTDecl(srcFile, MapleString("", allocatorIn.GetMemPool()), MapleVector<MIRType*>(allocatorIn.Adapter())) {
+    declKind = kASTFileScopeAsm;
+  }
+  ~ASTFileScopeAsm() = default;
+
+  void SetAsmStr(const std::string &str) {
+    asmStr = str;
+  }
+
+  const std::string &GetAsmStr() const {
+    return asmStr;
+  }
+
+ private:
+  std::string asmStr;
+};
+
+class ASTEnumConstant : public ASTDecl {
+ public:
+  ASTEnumConstant(const MapleString &srcFile, const MapleString &nameIn, const MapleVector<MIRType*> &typeDescIn,
+                  const GenericAttrs &genAttrsIn)
+      : ASTDecl(srcFile, nameIn, typeDescIn) {
+    genAttrs = genAttrsIn;
+    declKind = kASTEnumConstant;
+  }
+  ~ASTEnumConstant() = default;
+
+  void SetValue(const IntVal &val);
+  const IntVal &GetValue() const;
+
+ private:
+  MIRConst *Translate2MIRConstImpl() const override;
+  IntVal value;
+};
+
+class ASTEnumDecl : public ASTDecl {
+ public:
+  ASTEnumDecl(MapleAllocator &allocatorIn, const MapleString &srcFile, const MapleString &nameIn,
+              const MapleVector<MIRType*> &typeDescIn, const GenericAttrs &genAttrsIn)
+      : ASTDecl(srcFile, nameIn, typeDescIn), consts(allocatorIn.Adapter()) {
+    genAttrs = genAttrsIn;
+    declKind = kASTEnumDecl;
+  }
+  ~ASTEnumDecl() = default;
+
+  void PushConstant(ASTEnumConstant *c) {
+    consts.emplace_back(c);
+  }
+
+  const MapleList<ASTEnumConstant*> &GetEnumConstants() const {
+    return consts;
+  }
+
+ private:
+  void GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) override;
+
+  MapleList<ASTEnumConstant*> consts;
+};
+
+class ASTTypedefDecl : public ASTDecl {
+ public:
+  ASTTypedefDecl(const MapleString &srcFile, const MapleString &nameIn,
+                 const MapleVector<MIRType*> &typeDescIn, const GenericAttrs &genAttrsIn)
+      : ASTDecl(srcFile, nameIn, typeDescIn) {
+    genAttrs = genAttrsIn;
+    declKind = kASTTypedefDecl;
+  }
+  ~ASTTypedefDecl() = default;
+
+  void SetSubTypedefDecl(ASTTypedefDecl *decl) {
+    subTypedefDecl = decl;
+  }
+
+  const ASTTypedefDecl *GetSubTypedefDecl() const {
+    return subTypedefDecl;
+  }
+
+ private:
+  void GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) override;
+
+  ASTTypedefDecl* subTypedefDecl = nullptr;
+
+};
+}  // namespace maple
+#endif // HIR2MPL_AST_INPUT_INCLUDE_AST_DECL_H
diff --git a/src/hir2mpl/ast_input/common/include/ast_decl_builder.h b/src/hir2mpl/ast_input/common/include/ast_decl_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b4272f8812a2c3809e767ea93f1c8acc424b8d6
--- /dev/null
+++ b/src/hir2mpl/ast_input/common/include/ast_decl_builder.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_INPUT_INCLUDE_AST_DECL_BUILDER_H
+#define HIR2MPL_AST_INPUT_INCLUDE_AST_DECL_BUILDER_H
+#include "ast_decl.h"
+#include "mempool_allocator.h"
+
+namespace maple {
+class ASTDeclsBuilder {
+ public:
+  static ASTDecl *GetASTDecl(int64 id) {
+    ASTDecl *decl = declesTable[id];
+    return decl;
+  }
+
+  static void Clear() {
+    declesTable.clear();
+  }
+
+  static ASTDecl *ASTDeclBuilder(const MapleAllocator &allocator, const MapleString &srcFile,
+      const std::string &nameIn, const MapleVector<MIRType*> &typeDescIn, int64 id = INT64_MAX) {
+    MapleString nameStr(nameIn, allocator.GetMemPool());
+    if (id == INT64_MAX) {
+      return allocator.GetMemPool()->New<ASTDecl>(srcFile, nameStr, typeDescIn);  // for temp decl
+    } else if (declesTable[id] == nullptr) {
+      declesTable[id] = allocator.GetMemPool()->New<ASTDecl>(srcFile, nameStr, typeDescIn);
+    }
+    return declesTable[id];
+  }
+
+  static ASTVar *ASTVarBuilder(const MapleAllocator &allocator, const MapleString &srcFile, const std::string &varName,
+      const MapleVector<MIRType*> &desc, const GenericAttrs &genAttrsIn, int64 id = INT64_MAX) {
+    MapleString varNameStr(varName, allocator.GetMemPool());
+    if (id == INT64_MAX) {
+      return allocator.GetMemPool()->New<ASTVar>(srcFile, varNameStr, desc, genAttrsIn);
+    } else if (declesTable[id] == nullptr) {
+      declesTable[id] = allocator.GetMemPool()->New<ASTVar>(srcFile, varNameStr, desc, genAttrsIn);
+    }
+    return static_cast<ASTVar*>(declesTable[id]);
+  }
+
+  static ASTEnumConstant *ASTEnumConstBuilder(const MapleAllocator &allocator, const MapleString &srcFile,
+      const std::string &varName, const MapleVector<MIRType*> &desc,
+      const GenericAttrs &genAttrsIn, int64 id = INT64_MAX) {
+    MapleString varNameStr(varName, allocator.GetMemPool());
+    if (id == INT64_MAX) {
+      return allocator.GetMemPool()->New<ASTEnumConstant>(srcFile, varNameStr, desc, genAttrsIn);
+    } else if (declesTable[id] == nullptr) {
+      declesTable[id] = allocator.GetMemPool()->New<ASTEnumConstant>(srcFile, varNameStr, desc, genAttrsIn);
+    }
+    return static_cast<ASTEnumConstant*>(declesTable[id]);
+  }
+
+  static ASTEnumDecl *ASTLocalEnumDeclBuilder(MapleAllocator &allocator, const MapleString &srcFile,
+      const std::string &varName, const MapleVector<MIRType*> &desc, const GenericAttrs &genAttrsIn,
+      int64 id = INT64_MAX) {
+    MapleString varNameStr(varName, allocator.GetMemPool());
+    if (id == INT64_MAX) {
+      return allocator.GetMemPool()->New<ASTEnumDecl>(allocator, srcFile, varNameStr, desc, genAttrsIn);
+    } else if (declesTable[id] == nullptr) {
+      declesTable[id] = allocator.GetMemPool()->New<ASTEnumDecl>(allocator, srcFile, varNameStr, desc, genAttrsIn);
+    }
+    return static_cast<ASTEnumDecl*>(declesTable[id]);
+  }
+
+  static ASTFunc *ASTFuncBuilder(const MapleAllocator &allocator, const MapleString &srcFile, const std::string &nameIn,
+                                 const MapleVector<MIRType*> &typeDescIn, const GenericAttrs &genAttrsIn,
+                                 MapleVector<ASTDecl*> &paramDeclsIn, int64 id = INT64_MAX) {
+    MapleString funcNameStr(nameIn, allocator.GetMemPool());
+    if (id == INT64_MAX) {
+      return allocator.GetMemPool()->New<ASTFunc>(srcFile, funcNameStr, typeDescIn, genAttrsIn, paramDeclsIn);
+    } else if (declesTable[id] == nullptr) {
+      declesTable[id] = allocator.GetMemPool()->New<ASTFunc>(srcFile, funcNameStr, typeDescIn, genAttrsIn,
+                                                             paramDeclsIn);
+    }
+    return static_cast<ASTFunc*>(declesTable[id]);
+  }
+
+  static ASTTypedefDecl *ASTTypedefBuilder(const MapleAllocator &allocator, const MapleString &srcFile,
+      const std::string &varName, const MapleVector<MIRType*> &desc,
+      const GenericAttrs &genAttrsIn, int64 id = INT64_MAX) {
+    MapleString varNameStr(varName, allocator.GetMemPool());
+    if (id == INT64_MAX) {
+      return allocator.GetMemPool()->New<ASTTypedefDecl>(srcFile, varNameStr, desc, genAttrsIn);
+    } else if (declesTable[id] == nullptr) {
+      declesTable[id] = allocator.GetMemPool()->New<ASTTypedefDecl>(srcFile, varNameStr, desc, genAttrsIn);
+    }
+    return static_cast<ASTTypedefDecl*>(declesTable[id]);
+  }
+
+  template<typename T>
+  static T *ASTStmtBuilder(MapleAllocator &allocator) {
+    return allocator.GetMemPool()->New<T>(allocator);
+  }
+
+  template<typename T>
+  static T *ASTExprBuilder(MapleAllocator &allocator) {
+    return allocator.GetMemPool()->New<T>(allocator);
+  }
+
+  static ASTStruct *ASTStructBuilder(MapleAllocator &allocator, const MapleString &srcFile,
+                                     const std::string &nameIn, const MapleVector<MIRType*> &typeDescIn,
+                                     const GenericAttrs &genAttrsIn, int64 id = INT64_MAX) {
+    MapleString structNameStr(nameIn, allocator.GetMemPool());
+    if (id == INT64_MAX) {
+      return allocator.GetMemPool()->New<ASTStruct>(allocator, srcFile, structNameStr, typeDescIn, genAttrsIn);
+    } else if (declesTable[id] == nullptr) {
+      declesTable[id] = allocator.GetMemPool()->New<ASTStruct>(allocator, srcFile, structNameStr, typeDescIn,
+                                                               genAttrsIn);
+    }
+    return static_cast<ASTStruct*>(declesTable[id]);
+  }
+
+  static ASTField *ASTFieldBuilder(const MapleAllocator &allocator, const MapleString &srcFile,
+                                   const std::string &varName, const MapleVector<MIRType*> &desc,
+                                   const GenericAttrs &genAttrsIn, int64 id = INT64_MAX,
+                                   bool isAnonymous = false) {
+    MapleString varNameStr(varName, allocator.GetMemPool());
+    if (id == INT64_MAX) {
+      return allocator.GetMemPool()->New<ASTField>(srcFile, varNameStr, desc, genAttrsIn, isAnonymous);
+    } else if (declesTable[id] == nullptr) {
+      declesTable[id] = allocator.GetMemPool()->New<ASTField>(srcFile, varNameStr, desc, genAttrsIn,
+                                                              isAnonymous);
+    }
+    return static_cast<ASTField*>(declesTable[id]);
+  }
+
+ private:
+  static std::map<int64, ASTDecl*> declesTable;
+};
+}  // namespace maple
+#endif  // HIR2MPL_AST_INPUT_INCLUDE_AST_DECL_BUILDER_H
diff --git a/src/hir2mpl/ast_input/common/include/ast_input-inl.h b/src/hir2mpl/ast_input/common/include/ast_input-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..536ea52f6cecde1b36fc866bb0b8f2244455a5eb
--- /dev/null
+++ b/src/hir2mpl/ast_input/common/include/ast_input-inl.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_input.h"
+#include "global_tables.h"
+#include "fe_macros.h"
+
+namespace maple {
+template<class T>
+ASTInput<T>::ASTInput(MIRModule &moduleIn, MapleAllocator &allocatorIn)
+    : module(moduleIn), allocator(allocatorIn), parserMap(allocatorIn.Adapter()),
+      astStructs(allocatorIn.Adapter()), astFuncs(allocatorIn.Adapter()), astVars(allocatorIn.Adapter()),
+      astFileScopeAsms(allocatorIn.Adapter()), astEnums(allocatorIn.Adapter()) {}
+
+template<class T>
+bool ASTInput<T>::ReadASTFile(MapleAllocator &allocatorIn, uint32 index, const std::string &fileName) {
+  T *parser = allocator.GetMemPool()->New<T>(allocator, index, fileName,
+                                             astStructs, astFuncs, astVars,
+                                             astFileScopeAsms, astEnums);
+  TRY_DO(parser->OpenFile(allocatorIn));
+  TRY_DO(parser->Verify());
+  TRY_DO(parser->PreProcessAST());
+  // Some implicit record or enum decl would be retrieved in func body at use,
+  // so we put `RetrieveFuncs` before `RetrieveStructs`
+  TRY_DO(parser->RetrieveFuncs(allocatorIn));
+  TRY_DO(parser->RetrieveStructs(allocatorIn));
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    TRY_DO(parser->RetrieveEnums(allocatorIn));
+    TRY_DO(parser->RetrieveGlobalTypeDef(allocatorIn));
+  }
+  TRY_DO(parser->RetrieveGlobalVars(allocatorIn));
+  TRY_DO(parser->RetrieveFileScopeAsms(allocatorIn));
+  TRY_DO(parser->Release());
+  parserMap.emplace(fileName, parser);
+  return true;
+}
+
+template<class T>
+bool ASTInput<T>::ReadASTFiles(MapleAllocator &allocatorIn, const std::vector<std::string> &fileNames) {
+  bool res = true;
+  for (uint32 i = 0; res && i < fileNames.size(); ++i) {
+    FETimer timer;
+    std::stringstream ss;
+    ss << "ReadASTFile[" << (i + 1) << "/" << fileNames.size() << "]: " << fileNames[i];
+    timer.StartAndDump(ss.str());
+    res = res && ReadASTFile(allocatorIn, i, fileNames[i]);
+    RegisterFileInfo(fileNames[i]);
+    timer.StopAndDumpTimeMS(ss.str());
+  }
+  return res;
+}
+
+template<class T>
+void ASTInput<T>::RegisterFileInfo(const std::string &fileName) {
+  GStrIdx fileNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fileName);
+  GStrIdx fileInfoIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_filename");
+  module.PushFileInfoPair(MIRInfoPair(fileInfoIdx, fileNameIdx));
+  module.PushFileInfoIsString(true);
+}
+}
\ No newline at end of file
diff --git a/src/hir2mpl/ast_input/common/include/ast_input.h b/src/hir2mpl/ast_input/common/include/ast_input.h
new file mode 100644
index 0000000000000000000000000000000000000000..f06532b33404f2fcc719d5dff97f3841448a1658
--- /dev/null
+++ b/src/hir2mpl/ast_input/common/include/ast_input.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_AST_INPUT_INCLUDE_AST_INPUT_H
+#define HIR2MPL_AST_INPUT_INCLUDE_AST_INPUT_H
+#include <string>
+#include "mir_module.h"
+#include "ast_decl.h"
+#include "ast_parser.h"
+#ifdef ENABLE_MAST
+#include "maple_ast_parser.h"
+#endif
+
+namespace maple {
+template<class T>
+class ASTInput {
+ public:
+  ASTInput(MIRModule &moduleIn, MapleAllocator &allocatorIn);
+  ~ASTInput() = default;
+  bool ReadASTFile(MapleAllocator &allocatorIn, uint32 index, const std::string &fileName);
+  bool ReadASTFiles(MapleAllocator &allocatorIn, const std::vector<std::string> &fileNames);
+  const MIRModule &GetModule() const {
+    return module;
+  }
+
+  void RegisterFileInfo(const std::string &fileName);
+  const MapleList<ASTStruct*> &GetASTStructs() const {
+    return astStructs;
+  }
+
+  void AddASTStruct(ASTStruct *astStruct) {
+    auto itor = std::find(astStructs.begin(), astStructs.end(), astStruct);
+    if (itor == astStructs.end()) {
+      astStructs.emplace_back(astStruct);
+    }
+  }
+
+  const MapleList<ASTFunc*> &GetASTFuncs() const {
+    return astFuncs;
+  }
+
+  void AddASTFunc(ASTFunc *astFunc) {
+    astFuncs.emplace_back(astFunc);
+  }
+
+  const MapleList<ASTVar*> &GetASTVars() const {
+    return astVars;
+  }
+
+  void AddASTVar(ASTVar *astVar) {
+    astVars.emplace_back(astVar);
+  }
+
+  const MapleList<ASTFileScopeAsm*> &GetASTFileScopeAsms() const {
+    return astFileScopeAsms;
+  }
+
+  void AddASTFileScopeAsm(ASTFileScopeAsm *fileScopeAsm) {
+    astFileScopeAsms.emplace_back(fileScopeAsm);
+  }
+
+  const MapleList<ASTEnumDecl*> &GetASTEnums() const {
+    return astEnums;
+  }
+
+ private:
+  MIRModule &module;
+  MapleAllocator &allocator;
+  MapleMap<std::string, T*> parserMap;
+
+  MapleList<ASTStruct*> astStructs;
+  MapleList<ASTFunc*> astFuncs;
+  MapleList<ASTVar*> astVars;
+  MapleList<ASTFileScopeAsm*> astFileScopeAsms;
+  MapleList<ASTEnumDecl*> astEnums;
+};
+}
+#endif  // HIR2MPL_AST_INPUT_INCLUDE_AST_INPUT_H
\ No newline at end of file
diff --git a/src/hir2mpl/ast_input/common/src/ast_decl.cpp b/src/hir2mpl/ast_input/common/src/ast_decl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0548df17d15bfa9fa4cf462373ef34b9f504200d
--- /dev/null
+++ b/src/hir2mpl/ast_input/common/src/ast_decl.cpp
@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_decl.h"
+#include "ast_parser.h"
+#include "global_tables.h"
+#include "ast_stmt.h"
+#include "feir_var_name.h"
+#include "feir_builder.h"
+#include "fe_manager.h"
+#include "enhance_c_checker.h"
+#include "conditional_operator.h"
+
+namespace maple {
+// ---------- ASTDecl ---------
+const std::string ASTDecl::GetSrcFileName() const {
+  return srcFileName.c_str() == nullptr ? "" : srcFileName.c_str();
+}
+
+const std::string ASTDecl::GetName() const {
+  return name.c_str() == nullptr ? "" : name.c_str();
+}
+
+const MapleVector<MIRType*> &ASTDecl::GetTypeDesc() const {
+  return typeDesc;
+}
+
+void ASTDecl::SetTypeDesc(const MapleVector<MIRType*> &typeVecIn) {
+  typeDesc = typeVecIn;
+}
+
+MIRConst *ASTDecl::Translate2MIRConst() const {
+  return Translate2MIRConstImpl();
+}
+
+std::string ASTDecl::GenerateUniqueVarName() const {
+  // add `_line_column` suffix for avoiding local var name conflict
+  if (isGlobalDecl || isParam) {
+    return GetName();
+  } else {
+    std::stringstream os;
+    os << GetName();
+    if (isMacroID != 0) {
+      // for macro expansion, variable names of same location need to be unique
+      os << "_" << std::to_string(isMacroID);
+    } else {
+      os << "_" << std::to_string(loc.line) << "_" << std::to_string(loc.column);
+    }
+    return os.str();
+  }
+}
+
+// ---------- ASTVar ----------
+std::unique_ptr<FEIRVar> ASTVar::Translate2FEIRVar() const {
+  CHECK_FATAL(typeDesc.size() == 1, "Invalid ASTVar");
+  auto feirVar =
+      std::make_unique<FEIRVarName>(GenerateUniqueVarName(), std::make_unique<FEIRTypeNative>(*(typeDesc[0])));
+  feirVar->SetGlobal(isGlobalDecl);
+  feirVar->SetAttrs(genAttrs);
+  feirVar->SetSrcLoc(loc);
+  feirVar->SetSectionAttr(sectionAttr);
+  if (boundary.lenExpr != nullptr) {
+    std::list<UniqueFEIRStmt> nullStmts;
+    UniqueFEIRExpr lenExpr = boundary.lenExpr->Emit2FEExpr(nullStmts);
+    feirVar->SetBoundaryLenExpr(std::move(lenExpr));
+  }
+  return feirVar;
+}
+
+MIRConst *ASTVar::Translate2MIRConstImpl() const {
+  return initExpr->GenerateMIRConst();
+}
+
+void ASTVar::GenerateInitStmt4StringLiteral(const ASTExpr *initASTExpr, const UniqueFEIRVar &feirVar,
+    const UniqueFEIRExpr &initFeirExpr, std::list<UniqueFEIRStmt> &stmts) const {
+  if (!static_cast<const ASTStringLiteral*>(initASTExpr)->IsArrayToPointerDecay()) {
+    std::unique_ptr<std::list<UniqueFEIRExpr>> argExprList = std::make_unique<std::list<UniqueFEIRExpr>>();
+    UniqueFEIRExpr dstExpr = FEIRBuilder::CreateExprAddrofVar(feirVar->Clone());
+    uint32 stringLiteralSize = static_cast<FEIRExprAddrofConstArray*>(initFeirExpr.get())->GetStringLiteralSize();
+    auto uDstExpr = dstExpr->Clone();
+    auto uSrcExpr = initFeirExpr->Clone();
+    argExprList->emplace_back(std::move(uDstExpr));
+    argExprList->emplace_back(std::move(uSrcExpr));
+    MIRType *mirArrayType = feirVar->GetType()->GenerateMIRTypeAuto();
+    UniqueFEIRExpr sizeExpr;
+    if (mirArrayType->GetKind() == kTypeArray &&
+      static_cast<MIRArrayType*>(mirArrayType)->GetElemType()->GetSize() != 1) {
+      UniqueFEIRExpr leftExpr = FEIRBuilder::CreateExprConstI32(stringLiteralSize);
+      size_t elemSizes = static_cast<MIRArrayType*>(mirArrayType)->GetElemType()->GetSize();
+      CHECK_FATAL(elemSizes <= INT_MAX, "Too large elem size");
+      UniqueFEIRExpr rightExpr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(elemSizes));
+      sizeExpr = FEIRBuilder::CreateExprBinary(OP_mul, std::move(leftExpr), std::move(rightExpr));
+    } else {
+      sizeExpr = FEIRBuilder::CreateExprConstI32(stringLiteralSize);
+    }
+    argExprList->emplace_back(sizeExpr->Clone());
+    std::unique_ptr<FEIRStmtIntrinsicCallAssign> memcpyStmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+        INTRN_C_memcpy, nullptr, nullptr, std::move(argExprList));
+    memcpyStmt->SetSrcLoc(initFeirExpr->GetLoc());
+    stmts.emplace_back(std::move(memcpyStmt));
+    if (mirArrayType->GetKind() != kTypeArray) {
+      return;
+    }
+    auto allSize = static_cast<MIRArrayType*>(mirArrayType)->GetSize();
+    auto elemSize = static_cast<MIRArrayType*>(mirArrayType)->GetElemType()->GetSize();
+    CHECK_FATAL(elemSize != 0, "elemSize should not 0");
+    auto allElemCnt = allSize / elemSize;
+    uint32 needInitFurtherCnt = static_cast<uint32>(allElemCnt - stringLiteralSize);
+    if (needInitFurtherCnt > 0) {
+      argExprList = std::make_unique<std::list<UniqueFEIRExpr>>();
+      auto addExpr = FEIRBuilder::CreateExprBinary(OP_add, std::move(dstExpr), sizeExpr->Clone());
+      argExprList->emplace_back(std::move(addExpr));
+      argExprList->emplace_back(FEIRBuilder::CreateExprConstI32(0));
+      argExprList->emplace_back(FEIRBuilder::CreateExprConstI32(needInitFurtherCnt * elemSize));
+      std::unique_ptr<FEIRStmtIntrinsicCallAssign> memsetStmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+          INTRN_C_memset, nullptr, nullptr, std::move(argExprList));
+      memsetStmt->SetSrcLoc(initFeirExpr->GetLoc());
+      stmts.emplace_back(std::move(memsetStmt));
+    }
+    return;
+  }
+}
+
+void ASTVar::GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) {
+  MIRSymbol *sym = Translate2MIRSymbol();
+  ENCChecker::CheckNonnullLocalVarInit(*sym, initExpr);
+  UniqueFEIRVar feirVar = Translate2FEIRVar();
+  if (FEOptions::GetInstance().IsDbgFriendly() && !hasAddedInMIRScope) {
+    FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+    MIRScope *mirScope = feFunction.GetTopMIRScope();
+    FEUtils::AddAliasInMIRScope(*mirScope, GetName(), *sym, sourceType);
+    hasAddedInMIRScope = true;
+  }
+  if (variableArrayExpr != nullptr) {  // vla declaration point
+    FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+    if (feFunction.GetTopFEIRScopePtr() != nullptr &&
+        feFunction.GetTopFEIRScopePtr()->GetVLASavedStackVar() == nullptr) {
+      // stack save
+      MIRType *retType = GlobalTables::GetTypeTable().GetOrCreatePointerType(
+          *GlobalTables::GetTypeTable().GetPrimType(PTY_void));
+      auto stackVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("saved_stack."), *retType, false);
+      std::unique_ptr<std::list<UniqueFEIRExpr>> argExprList = std::make_unique<std::list<UniqueFEIRExpr>>();
+      auto stackSaveStmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(INTRN_C_stack_save, nullptr, stackVar->Clone(),
+                                                                         std::move(argExprList));
+      stackSaveStmt->SetSrcLoc(feirVar->GetSrcLoc());
+      (void)stmts.emplace_back(std::move(stackSaveStmt));
+      // push saved stack var into scope
+      feFunction.GetTopFEIRScopePtr()->SetVLASavedStackVar(std::move(stackVar));
+    }
+    // alloca
+    UniqueFEIRExpr variableArrayFEIRExpr = variableArrayExpr->Emit2FEExpr(stmts);
+    MIRType *mirType = GlobalTables::GetTypeTable().GetPrimType(PTY_a64);
+    UniqueFEIRType feType = std::make_unique<FEIRTypeNative>(*mirType);
+    UniqueFEIRExpr allocaExpr = std::make_unique<FEIRExprUnary>(std::move(feType), OP_alloca,
+                                                                std::move(variableArrayFEIRExpr));
+    UniqueFEIRStmt allocaStmt = FEIRBuilder::CreateStmtDAssign(feirVar->Clone(), std::move(allocaExpr));
+    allocaStmt->SetSrcLoc(feirVar->GetSrcLoc());
+    (void)stmts.emplace_back(std::move(allocaStmt));
+  }
+  ENCChecker::InsertBoundaryVar(*this, stmts);
+  if (initExpr == nullptr) {
+    return;
+  }
+  if (genAttrs.GetAttr(GENATTR_static) && sym->GetKonst() != nullptr) {
+    return;
+  }
+  UniqueFEIRExpr initFeirExpr = initExpr->Emit2FEExpr(stmts);
+  if (initFeirExpr == nullptr) {
+    return;
+  }
+  ENCChecker::CheckNonnullLocalVarInit(*sym, initFeirExpr, stmts);
+  if (initExpr->GetASTOp() == kASTStringLiteral) { // init for StringLiteral
+    return GenerateInitStmt4StringLiteral(initExpr, feirVar, initFeirExpr, stmts);
+  }
+
+  if (ConditionalOptimize::DeleteRedundantTmpVar(initFeirExpr, stmts, feirVar, feirVar->GetType()->GetPrimType())) {
+    return;
+  }
+
+  PrimType srcPrimType = initFeirExpr->GetPrimType();
+  UniqueFEIRStmt stmt;
+  if (srcPrimType != feirVar->GetType()->GetPrimType() && srcPrimType != PTY_agg && srcPrimType != PTY_void) {
+    auto castExpr = FEIRBuilder::CreateExprCastPrim(std::move(initFeirExpr), feirVar->GetType()->GetPrimType());
+    stmt = FEIRBuilder::CreateStmtDAssign(feirVar->Clone(), std::move(castExpr));
+  } else {
+    stmt = FEIRBuilder::CreateStmtDAssign(feirVar->Clone(), std::move(initFeirExpr));
+  }
+  stmt->SetSrcLoc(feirVar->GetSrcLoc());
+  stmts.emplace_back(std::move(stmt));
+}
+
+MIRSymbol *ASTVar::Translate2MIRSymbol() const {
+  UniqueFEIRVar feirVar = Translate2FEIRVar();
+  MIRSymbol *mirSymbol = feirVar->GenerateMIRSymbol(FEManager::GetMIRBuilder());
+  if (initExpr != nullptr && genAttrs.GetAttr(GENATTR_static)) {
+    MIRConst *cst = initExpr->GenerateMIRConst();
+    if (cst != nullptr && cst->GetKind() != kConstInvalid) {
+      mirSymbol->SetKonst(cst);
+    }
+  }
+  if (!sectionAttr.empty()) {
+    mirSymbol->sectionAttr = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(sectionAttr);
+  }
+  if (!asmAttr.empty()) {
+    mirSymbol->SetAsmAttr(GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(asmAttr));
+  }
+  return mirSymbol;
+}
+
+// ---------- ASTEnumConstant ----------
+void ASTEnumConstant::SetValue(const IntVal &val) {
+  value = val;
+}
+
+const IntVal &ASTEnumConstant::GetValue() const {
+  return value;
+}
+
+MIRConst *ASTEnumConstant::Translate2MIRConstImpl() const {
+  return GlobalTables::GetIntConstTable().GetOrCreateIntConst(value, *typeDesc.front());
+}
+
+// ---------- ASTFunc ---------
+void ASTFunc::SetCompoundStmt(ASTStmt *astCompoundStmt) {
+  compound = astCompoundStmt;
+}
+
+void ASTFunc::InsertStmtsIntoCompoundStmtAtFront(const std::list<ASTStmt*> &stmts) const {
+  static_cast<ASTCompoundStmt*>(compound)->InsertASTStmtsAtFront(stmts);
+}
+
+const ASTStmt *ASTFunc::GetCompoundStmt() const {
+  return compound;
+}
+
+std::vector<std::unique_ptr<FEIRVar>> ASTFunc::GenArgVarList() const {
+  std::vector<std::unique_ptr<FEIRVar>> args;
+  return args;
+}
+
+std::list<UniqueFEIRStmt> ASTFunc::EmitASTStmtToFEIR() const {
+  std::list<UniqueFEIRStmt> stmts;
+  const ASTStmt *astStmt = GetCompoundStmt();
+  if (astStmt == nullptr) {
+    return stmts;
+  }
+  const ASTCompoundStmt *astCpdStmt = static_cast<const ASTCompoundStmt*>(astStmt);
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  feFunction.PushFuncScope(FEUtils::CvtLoc2SrcPosition(astCpdStmt->GetSrcLoc()),
+                           FEUtils::CvtLoc2SrcPosition(astCpdStmt->GetEndLoc()));
+  const MapleList<ASTStmt*> &astStmtList = astCpdStmt->GetASTStmtList();
+  for (auto stmtNode : astStmtList) {
+    std::list<UniqueFEIRStmt> childStmts = stmtNode->Emit2FEStmt();
+    for (auto &stmt : childStmts) {
+      // Link jump stmt not implemented yet
+      stmts.emplace_back(std::move(stmt));
+    }
+  }
+  UniqueFEIRScope scope = feFunction.PopTopScope();
+  // fix int main() no return 0 and void func() no return. there are multiple branches, insert return at the end.
+  if (stmts.size() == 0 || stmts.back()->GetKind() != kStmtReturn) {
+    if (scope->GetVLASavedStackVar() != nullptr) {
+      auto stackRestoreStmt = scope->GenVLAStackRestoreStmt();
+      stackRestoreStmt->SetSrcLoc(astCpdStmt->GetEndLoc());
+      (void)stmts.emplace_back(std::move(stackRestoreStmt));
+    }
+    UniqueFEIRExpr retExpr = nullptr;
+    PrimType retType = typeDesc[1]->GetPrimType();
+    if (retType != PTY_void) {
+      if (!typeDesc[1]->IsScalarType()) {
+        retType = PTY_i32;
+      }
+      retExpr = FEIRBuilder::CreateExprConstAnyScalar(retType, static_cast<int64>(0));
+    }
+    UniqueFEIRStmt retStmt = std::make_unique<FEIRStmtReturn>(std::move(retExpr));
+    Loc endLoc = astCpdStmt->GetEndLoc();
+    endLoc.column = 0;
+    retStmt->SetSrcLoc(endLoc);
+    stmts.emplace_back(std::move(retStmt));
+  }
+  InsertBoundaryCheckingInRet(stmts);
+  return stmts;
+}
+
+// ---------- ASTStruct ----------
+std::string ASTStruct::GetStructName(bool mapled) const {
+  return mapled ? namemangler::EncodeName(GetName()) : GetName();
+}
+
+void ASTStruct::GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) {
+  (void)stmts;
+  if (!FEOptions::GetInstance().IsDbgFriendly()) {
+    return;
+  }
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  MIRScope *mirScope = feFunction.GetTopMIRScope();
+  mirScope->SetTypeAliasMap(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(GetName()),
+                            typeDesc.front()->GetTypeIndex());
+}
+
+// ---------- ASTEnumDecl ----------
+void ASTEnumDecl::GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) {
+  (void)stmts;
+  if (!FEOptions::GetInstance().IsDbgFriendly()) {
+    return;
+  }
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  MIRScope *mirScope = feFunction.GetTopMIRScope();
+  MIRTypeByName *type = FEManager::GetTypeManager().GetOrCreateTypeByNameType(GenerateUniqueVarName());
+  mirScope->SetTypeAliasMap(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(GetName()), type->GetTypeIndex());
+}
+
+// ---------- ASTTypedefDecl ----------
+void ASTTypedefDecl::GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) {
+  (void)stmts;
+  if (!FEOptions::GetInstance().IsDbgFriendly()) {
+    return;
+  }
+  FEFunction &feFunction = FEManager::GetCurrentFEFunction();
+  MIRScope *mirScope = feFunction.GetTopMIRScope();
+  const ASTTypedefDecl *astTypedef = this;
+  while (astTypedef != nullptr && !astTypedef->isGlobalDecl) {
+    MIRTypeByName *type = FEManager::GetTypeManager().CreateTypedef(
+        astTypedef->GenerateUniqueVarName(), *astTypedef->GetTypeDesc().front());
+    mirScope->SetTypeAliasMap(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        astTypedef->GetName()), type->GetTypeIndex());
+    astTypedef = astTypedef->GetSubTypedefDecl();
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/ast_input/maple/include/maple_ast_parser.h b/src/hir2mpl/ast_input/maple/include/maple_ast_parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..f38e3c3ba222b5e2f8ba40bce3e26ab8fd131f88
--- /dev/null
+++ b/src/hir2mpl/ast_input/maple/include/maple_ast_parser.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_AST_PARSER_H
+#define MAPLE_AST_PARSER_H
+#include <string>
+#include <stdio.h>
+#include "mempool_allocator.h"
+#include "ast_decl.h"
+#include "maple_ast_interface.h"
+#include "ast.h"
+
+namespace maple {
+class MapleASTParser {
+ public:
+  MapleASTParser(MapleAllocator &allocatorIn, uint32 fileIdxIn, const std::string &fileNameIn,
+                 MapleList<ASTStruct*> &astStructsIn, MapleList<ASTFunc*> &astFuncsIn, MapleList<ASTVar*> &astVarsIn,
+                 MapleList<ASTFileScopeAsm*> &astFileScopeAsmsIn)
+      : fileIdx(fileIdxIn), fileName(fileNameIn),
+        globalVarDecles(allocatorIn.Adapter()), funcDecles(allocatorIn.Adapter()),
+        astStructs(astStructsIn), astFuncs(astFuncsIn),
+        astVars(astVarsIn), astFileScopeAsms(astFileScopeAsmsIn),
+        astFuncMap(allocatorIn.Adapter()) {}
+  virtual ~MapleASTParser() = default;
+  bool OpenFile();
+  const uint32 GetFileIdx() const;
+  bool Verify() const;
+  bool PreProcessAST();
+
+  std::list<ASTDecl*> ProcessDeclNode(MapleAllocator &allocator, maplefe::DeclNode *decl);
+  ASTDecl *ProcessDecl(MapleAllocator &allocator, maplefe::TreeNode *decl);
+#define MAPLE_PROCESS_DECL(CLASS) ProcessDecl##CLASS##Node(MapleAllocator &allocator, maplefe::CLASS##Node*)
+  ASTDecl *MAPLE_PROCESS_DECL(Function);
+  ASTDecl *MAPLE_PROCESS_DECL(Identifier);
+
+  ASTStmt *ProcessStmt(MapleAllocator &allocator, maplefe::TreeNode *stmt);
+#define MAPLE_PROCESS_STMT(CLASS) ProcessStmt##CLASS##Node(MapleAllocator&, maplefe::CLASS##Node*)
+  ASTStmt *MAPLE_PROCESS_STMT(Block);
+  ASTStmt *MAPLE_PROCESS_STMT(Decl);
+  ASTStmt *MAPLE_PROCESS_STMT(Return);
+
+  ASTExpr *ProcessExpr(MapleAllocator &allocator, maplefe::TreeNode *expr);
+#define MAPLE_PROCESS_EXPR(CLASS) ProcessExpr##CLASS##Node(MapleAllocator&, maplefe::CLASS##Node*)
+  ASTExpr *MAPLE_PROCESS_EXPR(Literal);
+  ASTExpr *MAPLE_PROCESS_EXPR(Call);
+  ASTExpr *MAPLE_PROCESS_EXPR(Identifier);
+
+  bool RetrieveStructs(MapleAllocator &allocator);
+  bool RetrieveFuncs(MapleAllocator &allocator);
+  bool RetrieveGlobalVars(MapleAllocator &allocator);
+  bool RetrieveFileScopeAsms(MapleAllocator &allocator);
+
+ private:
+  uint32 fileIdx;
+  const std::string fileName;
+  std::unique_ptr<LibMapleAstFile> astFile;
+  MapleList<maplefe::TreeNode*> globalVarDecles;
+  MapleList<maplefe::TreeNode*> funcDecles;
+  MapleList<ASTStruct*> &astStructs;
+  MapleList<ASTFunc*> &astFuncs;
+  MapleList<ASTVar*> &astVars;
+  MapleList<ASTFileScopeAsm*> &astFileScopeAsms;
+  MapleMap<uint32, ASTFunc*> astFuncMap;
+};
+} // namespace maple
+#endif // MAPLE_AST_PARSER_H
diff --git a/src/hir2mpl/ast_input/maple/lib/maple_ast_interface.cpp b/src/hir2mpl/ast_input/maple/lib/maple_ast_interface.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..678f3c15dc9093543eee615cbcb79cecc9f58dc8
--- /dev/null
+++ b/src/hir2mpl/ast_input/maple/lib/maple_ast_interface.cpp
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "maple_ast_interface.h"
+#include <fstream>
+#include <iterator>
+#include "gen_aststore.h"
+#include "gen_astload.h"
+#include "global_tables.h"
+
+namespace maple {
+bool LibMapleAstFile::Open(const std::string &fileName) {
+  std::ifstream input(fileName, std::ifstream::binary);
+  input >> std::noskipws;
+  std::istream_iterator<uint8_t> s(input), e;
+  maplefe::AstBuffer vec(s, e);
+  maplefe::AstLoad loadAst;
+  maplefe::ModuleNode *mod = loadAst.LoadFromAstBuf(vec);
+  // add mod to the vector
+  while (mod) {
+    handler.AddModule(mod);
+    mod = loadAst.Next();
+  }
+  return true;
+}
+
+PrimType LibMapleAstFile::MapPrim(maplefe::TypeId id) {
+  PrimType prim;
+  switch (id) {
+    case maplefe::TY_Boolean:
+      prim = PTY_u1;
+      break;
+    case maplefe::TY_Byte:
+      prim = PTY_u8;
+      break;
+    case maplefe::TY_Short:
+      prim = PTY_i16;
+      break;
+    case maplefe::TY_Int:
+      prim = PTY_i32;
+      break;
+    case maplefe::TY_Long:
+      prim = PTY_i64;
+      break;
+    case maplefe::TY_Char:
+      prim = PTY_u16;
+      break;
+    case maplefe::TY_Float:
+      prim = PTY_f32;
+      break;
+    case maplefe::TY_Double:
+      prim = PTY_f64;
+      break;
+    case maplefe::TY_Void:
+      prim = PTY_void;
+      break;
+    case maplefe::TY_Null:
+      prim = PTY_void;
+      break;
+    default:
+      CHECK_FATAL(false, "Unsupported PrimType");
+      break;
+  }
+  return prim;
+}
+
+MIRType *LibMapleAstFile::MapPrimType(maplefe::TypeId id) {
+  PrimType prim = MapPrim(id);
+  TyIdx tid(prim);
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(tid);
+}
+
+MIRType *LibMapleAstFile::MapPrimType(maplefe::PrimTypeNode *ptnode) {
+  return MapPrimType(ptnode->GetPrimType());
+}
+
+MIRType *LibMapleAstFile::MapType(maplefe::TreeNode *type) {
+  if (type == nullptr) {
+    return GlobalTables::GetTypeTable().GetVoid();
+  }
+
+  MIRType *mirType = nullptr;
+  if (type->IsPrimType()) {
+    maplefe::PrimTypeNode *ptnode = static_cast<maplefe::PrimTypeNode*>(type);
+    mirType = MapPrimType(ptnode);
+  } else if (type->IsUserType()) {
+    if (type->IsIdentifier()) {
+      maplefe::IdentifierNode *inode = static_cast<maplefe::IdentifierNode*>(type);
+      mirType = MapType(inode->GetType());
+    } else {
+      CHECK_FATAL(false, "MapType IsUserType");
+    }
+  } else {
+    CHECK_FATAL(false, "MapType unknown type");
+  }
+
+  return mirType;
+}
+}
\ No newline at end of file
diff --git a/src/hir2mpl/ast_input/maple/lib/maple_ast_interface.h b/src/hir2mpl/ast_input/maple/lib/maple_ast_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..77d8b4f9e7559d578790d3c81760062938b5f4ca
--- /dev/null
+++ b/src/hir2mpl/ast_input/maple/lib/maple_ast_interface.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_AST_INTERFACE_H
+#define MAPLE_AST_INTERFACE_H
+#include <string>
+#include "ast_handler.h"
+#include "mir_type.h"
+
+namespace maple {
+class LibMapleAstFile {
+ public:
+  LibMapleAstFile() : handler(maplefe::FLG_trace) {}
+  ~LibMapleAstFile() = default;
+
+  bool Open(const std::string &fileName);
+
+  maplefe::AST_Handler &GetASTHandler() {
+    return handler;
+  }
+
+  PrimType MapPrim(maplefe::TypeId id);
+  MIRType *MapPrimType(maplefe::TypeId id);
+  MIRType *MapPrimType(maplefe::PrimTypeNode *ptnode);
+  MIRType *MapType(maplefe::TreeNode *type);
+
+ private:
+  maplefe::AST_Handler handler;
+};
+} // namespace maple
+#endif // MAPLE_AST_INTERFACE_H
\ No newline at end of file
diff --git a/src/hir2mpl/ast_input/maple/src/maple_ast_parser.cpp b/src/hir2mpl/ast_input/maple/src/maple_ast_parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..33b6137e56451963c6d41f254821fdd251ef9c5a
--- /dev/null
+++ b/src/hir2mpl/ast_input/maple/src/maple_ast_parser.cpp
@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "maple_ast_parser.h"
+#include "ast_decl_builder.h"
+
+namespace maple {
+bool MapleASTParser::OpenFile() {
+  (void)astStructs;
+  (void)astFileScopeAsms;
+  astFile = std::make_unique<LibMapleAstFile>();
+  bool res = astFile->Open(fileName);
+  if (!res) {
+    return false;
+  }
+  return true;
+}
+
+const uint32 MapleASTParser::GetFileIdx() const {
+  return fileIdx;
+}
+
+bool MapleASTParser::Verify() const {
+  return true;
+}
+
+bool MapleASTParser::PreProcessAST() {
+  for (uint32 i = 0; i < astFile->GetASTHandler().GetSize(); ++i) {
+    maplefe::Module_Handler *handler = astFile->GetASTHandler().GetModuleHandler(i);
+    maplefe::ModuleNode *module = handler->GetASTModule();
+    for (uint32 i = 0; i < module->GetTreesNum(); ++i) {
+      maplefe::TreeNode *node = module->GetTree(i);
+      switch (node->GetKind()) {
+        case maplefe::NK_Decl:
+          globalVarDecles.emplace_back(node);
+          break;
+        case maplefe::NK_Function:
+          funcDecles.emplace_back(node);
+          break;
+        default: break;
+      }
+    }
+  }
+  return true;
+}
+
+
+#define MAPLE_DECL_CASE(CLASS)                                                                           \
+  case maplefe::NK_##CLASS: {                                                                            \
+    ASTDecl *astDecl = ProcessDecl##CLASS##Node(allocator, static_cast<maplefe::CLASS##Node*>(decl));    \
+    return astDecl;                                                                                      \
+  }
+
+ASTDecl *MapleASTParser::ProcessDecl(MapleAllocator &allocator, maplefe::TreeNode *decl) {
+  ASTDecl *astDecl = ASTDeclsBuilder::GetASTDecl(decl->GetNodeId());
+  if (astDecl != nullptr) {
+    return astDecl;
+  }
+
+  switch (decl->GetKind()) {
+    MAPLE_DECL_CASE(Function)
+    MAPLE_DECL_CASE(Identifier)
+    default:
+      decl->Dump(0);
+      CHECK_FATAL(false, "ASTDecl NIY");
+      return nullptr;
+  }
+}
+
+ASTDecl *MapleASTParser::ProcessDeclIdentifierNode(MapleAllocator &allocator, maplefe::IdentifierNode *identifierDecl) {
+  ASTVar *astVar = static_cast<ASTVar*>(ASTDeclsBuilder::GetASTDecl(identifierDecl->GetNodeId()));
+  if (astVar != nullptr) {
+    return astVar;
+  }
+
+  std::string varName = identifierDecl->GetName();
+  if (varName.empty()) {
+    return nullptr;
+  }
+  MIRType *varType = astFile->MapType(identifierDecl->GetType());
+  if (varType == nullptr) {
+    return nullptr;
+  }
+  GenericAttrs attrs;
+  astVar = ASTDeclsBuilder::ASTVarBuilder(
+      allocator, fileName, varName, MapleVector<MIRType*>{varType}, attrs, identifierDecl->GetNodeId());
+
+  if (identifierDecl->GetInit() != nullptr) {
+    auto astInitExpr = ProcessExpr(allocator, identifierDecl->GetInit());
+    astVar->SetInitExpr(astInitExpr);
+  }
+
+  return astVar;
+}
+
+std::list<ASTDecl*> MapleASTParser::ProcessDeclNode(MapleAllocator &allocator, maplefe::DeclNode *varDecl) {
+  maplefe::VarListNode *varList = static_cast<maplefe::VarListNode*>(varDecl->GetVar());
+  std::list<ASTDecl*> astVars;
+  for (uint32 i = 0; i < varList->GetVarsNum(); ++i) {
+    maplefe::IdentifierNode *iNode = varList->GetVarAtIndex(i);
+    ASTVar *astVar = static_cast<ASTVar*>(ProcessDecl(allocator, iNode));
+    astVars.emplace_back(astVar);
+  }
+  return astVars;
+}
+
+ASTDecl *MapleASTParser::ProcessDeclFunctionNode(MapleAllocator &allocator, maplefe::FunctionNode *funcDecl) {
+  ASTFunc *astFunc = static_cast<ASTFunc*>(ASTDeclsBuilder::GetASTDecl(funcDecl->GetNodeId()));
+  if (astFunc != nullptr) {
+    return astFunc;
+  }
+
+  std::string funcName = funcDecl->GetName();
+  if (funcName.empty()) {
+    return nullptr;
+  }
+
+  MapleVector<MIRType*> typeDescIn;
+  typeDescIn.push_back(nullptr); // mirFuncType
+  MIRType *retType = astFile->MapType(funcDecl->GetType());
+  if (retType == nullptr) {
+    return nullptr;
+  }
+  typeDescIn.push_back(retType);
+
+  MapleVector<ASTDecl*> paramDecls;
+  uint32 numParam = funcDecl->GetParamsNum();
+  for (uint32 i = 0; i < numParam; ++i) {
+    maplefe::TreeNode *param = funcDecl->GetParam(i);
+    ASTDecl *parmVarDecl = nullptr;
+    if (param->IsIdentifier()) {
+      parmVarDecl = ProcessDecl(allocator, param);
+    } else {
+      continue;
+    }
+    paramDecls.push_back(parmVarDecl);
+    typeDescIn.push_back(parmVarDecl->GetTypeDesc().front());
+  }
+
+  GenericAttrs attrs;
+  astFunc = ASTDeclsBuilder::ASTFuncBuilder(
+      allocator, fileName, funcName, typeDescIn, attrs, paramDecls, funcDecl->GetNodeId());
+  CHECK_FATAL(astFunc != nullptr, "astFunc is nullptr");
+
+  maplefe::BlockNode *astBody = funcDecl->GetBody();
+  if (astBody != nullptr) {
+    ASTStmt *astCompoundStmt = ProcessStmt(allocator, astBody);
+    if (astCompoundStmt != nullptr) {
+      astFunc->SetCompoundStmt(astCompoundStmt);
+    }
+  }
+  astFuncMap[funcDecl->GetStrIdx()] = astFunc;
+  return astFunc;
+}
+
+
+#define MAPLE_STMT_CASE(CLASS)                                                                        \
+  case maplefe::NK_##CLASS: {                                                                         \
+    ASTStmt *astStmt = ProcessStmt##CLASS##Node(allocator, static_cast<maplefe::CLASS##Node*>(stmt)); \
+    return astStmt;                                                                                   \
+  }
+
+ASTStmt *MapleASTParser::ProcessStmt(MapleAllocator &allocator, maplefe::TreeNode *stmt) {
+  switch (stmt->GetKind()) {
+    MAPLE_STMT_CASE(Block);
+    MAPLE_STMT_CASE(Decl);
+    MAPLE_STMT_CASE(Return);
+    default: {
+      stmt->Dump(0);
+      CHECK_FATAL(false, "ASTStmt NIY");
+      return nullptr;
+    }
+  }
+}
+
+ASTStmt *MapleASTParser::ProcessStmtBlockNode(MapleAllocator &allocator, maplefe::BlockNode *stmt) {
+  ASTCompoundStmt *astCompoundStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTCompoundStmt>(allocator);
+  CHECK_FATAL(astCompoundStmt != nullptr, "astCompoundStmt is nullptr");
+  ASTStmt *childStmt = nullptr;
+  for (uint32 i = 0; i < stmt->GetChildrenNum(); ++i) {
+    maplefe::TreeNode *child = stmt->GetChildAtIndex(i);
+    childStmt = ProcessStmt(allocator, child);
+    if (childStmt != nullptr) {
+      astCompoundStmt->SetASTStmt(childStmt);
+    } else {
+      continue;
+    }
+  }
+  return astCompoundStmt;
+}
+
+ASTStmt *MapleASTParser::ProcessStmtDeclNode(MapleAllocator &allocator, maplefe::DeclNode *stmt) {
+  ASTDeclStmt *declStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTDeclStmt>(allocator);
+  std::list<ASTDecl*> astVars = ProcessDeclNode(allocator, stmt);
+  for (auto &var : astVars) {
+    declStmt->SetSubDecl(var);
+  }
+  return declStmt;
+}
+
+ASTStmt *MapleASTParser::ProcessStmtReturnNode(MapleAllocator &allocator, maplefe::ReturnNode *stmt) {
+  ASTReturnStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTReturnStmt>(allocator);
+  CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, stmt->GetResult());
+  astStmt->SetASTExpr(astExpr);
+  return astStmt;
+}
+
+#define MAPLE_EXPR_CASE(CLASS)                                                                         \
+  case maplefe::NK_##CLASS: {                                                                          \
+    ASTExpr *astExpr = ProcessExpr##CLASS##Node(allocator, static_cast<maplefe::CLASS##Node*>(expr));  \
+    return astExpr;                                                                                    \
+  }
+
+ASTExpr *MapleASTParser::ProcessExpr(MapleAllocator &allocator, maplefe::TreeNode *expr) {
+  if (expr == nullptr) {
+    return nullptr;
+  }
+
+  switch (expr->GetKind()) {
+    MAPLE_EXPR_CASE(Literal);
+    MAPLE_EXPR_CASE(Call);
+    MAPLE_EXPR_CASE(Identifier);
+    default:
+      expr->Dump(0);
+      CHECK_FATAL(false, "ASTExpr NIY");
+      return nullptr;
+  }
+}
+
+ASTExpr *MapleASTParser::ProcessExprLiteralNode(MapleAllocator &allocator, maplefe::LiteralNode *expr) {
+  ASTExpr *literalExpr = nullptr;
+  switch (expr->GetData().mType) {
+    case maplefe::LT_IntegerLiteral:
+      literalExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+      literalExpr->SetType(GlobalTables::GetTypeTable().GetInt64());
+      static_cast<ASTIntegerLiteral*>(literalExpr)->SetVal(expr->GetData().mData.mInt64);
+      break;
+    case maplefe::LT_FPLiteral:
+      literalExpr = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+      literalExpr->SetType(GlobalTables::GetTypeTable().GetFloat());
+      static_cast<ASTFloatingLiteral*>(literalExpr)->SetVal(expr->GetData().mData.mFloat);
+      break;
+    case maplefe::LT_DoubleLiteral:
+      literalExpr = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+      literalExpr->SetType(GlobalTables::GetTypeTable().GetDouble());
+      static_cast<ASTFloatingLiteral*>(literalExpr)->SetVal(expr->GetData().mData.mDouble);
+      break;
+    default:
+      CHECK_FATAL(false, "NYI");
+      break;
+  }
+  return literalExpr;
+}
+
+ASTExpr *MapleASTParser::ProcessExprIdentifierNode(MapleAllocator &allocator, maplefe::IdentifierNode *expr) {
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  CHECK_FATAL(astRefExpr != nullptr, "astRefExpr is nullptr");
+  ASTDecl *astDecl = ASTDeclsBuilder::GetASTDecl(expr->GetNodeId());
+  if (astDecl == nullptr) {
+    astDecl = ProcessDecl(allocator, expr);
+  }
+  astRefExpr->SetASTDecl(astDecl);
+  astRefExpr->SetType(astDecl->GetTypeDesc().front());
+  return astRefExpr;
+}
+
+ASTExpr *MapleASTParser::ProcessExprCallNode(MapleAllocator &allocator, maplefe::CallNode *expr) {
+  ASTCallExpr *astCallExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCallExpr>(allocator);
+  ASSERT(astCallExpr != nullptr, "astCallExpr is nullptr");
+  // callee
+  ASTExpr *astCallee = ProcessExpr(allocator, expr->GetMethod());
+  if (astCallee == nullptr) {
+    return nullptr;
+  }
+  astCallExpr->SetCalleeExpr(astCallee);
+  // return
+  // C language function names can be used as unique identifiers
+  MIRType *retType = astFuncMap[expr->GetMethod()->GetStrIdx()]->GetTypeDesc()[1];
+  astCallExpr->SetRetType(retType);
+  // args
+  std::vector<ASTExpr*> args;
+  for (uint32_t i = 0; i < expr->GetArgsNum(); ++i) {
+    maplefe::TreeNode *subExpr = expr->GetArg(i);
+    ASTExpr *arg = ProcessExpr(allocator, subExpr);
+    args.push_back(arg);
+  }
+  astCallExpr->SetArgs(args);
+  if (expr->GetMethod() != nullptr) {
+    GenericAttrs attrs;
+    astCallExpr->SetFuncName(astCallee->GetASTDecl()->GetName());
+    astCallExpr->SetFuncAttrs(attrs.ConvertToFuncAttrs());
+  } else {
+    astCallExpr->SetIcall(true);
+  }
+  return astCallExpr;
+}
+
+bool MapleASTParser::RetrieveStructs(MapleAllocator &allocator) {
+  return true;
+}
+
+bool MapleASTParser::RetrieveFuncs(MapleAllocator &allocator) {
+  for (auto &decl : funcDecles) {
+    ASTFunc *funcDecl = static_cast<ASTFunc*>(ProcessDecl(allocator, decl));
+    if (funcDecl == nullptr) {
+      return false;
+    }
+    funcDecl->SetGlobal(true);
+    astFuncs.emplace_back(funcDecl);
+  }
+  return true;
+}
+
+bool MapleASTParser::RetrieveGlobalVars(MapleAllocator &allocator) {
+  for (auto &decl : globalVarDecles) {
+    std::list<ASTDecl*> astVarList = ProcessDeclNode(allocator, static_cast<maplefe::DeclNode*>(decl));
+    for (auto &astVar : astVarList) {
+      astVars.emplace_back(static_cast<ASTVar*>(astVar));
+    }
+  }
+  return true;
+}
+
+bool MapleASTParser::RetrieveFileScopeAsms(MapleAllocator &allocator) {
+  return true;
+}
+} // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_attr.def b/src/hir2mpl/bytecode_input/class/include/jbc_attr.def
new file mode 100644
index 0000000000000000000000000000000000000000..4fe4da2e62a49bb97ac696d9897181e4a2eb36bf
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_attr.def
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+JBC_ATTR("ConstantValue", ConstantValue)
+JBC_ATTR("Code", Code)
+JBC_ATTR("StackMapTable", StackMapTable)
+JBC_ATTR("Exceptions", Exception)
+JBC_ATTR("InnerClasses", InnerClass)
+JBC_ATTR("EnclosingMethod", EnclosingMethod)
+JBC_ATTR("Synthetic", Synthetic)
+JBC_ATTR("Signature", Signature)
+JBC_ATTR("SourceFile", SourceFile)
+JBC_ATTR("SourceDebugExtension", SourceDebugEx)
+JBC_ATTR("LineNumberTable", LineNumberTable)
+JBC_ATTR("LocalVariableTable", LocalVariableTable)
+JBC_ATTR("LocalVariableTypeTable", LocalVariableTypeTable)
+JBC_ATTR("Deprecated", Deprecated)
+JBC_ATTR("RuntimeVisibleAnnotations", RTVisAnnotations)
+JBC_ATTR("RuntimeInvisibleAnnotations", RTInvisAnnotations)
+JBC_ATTR("RuntimeVisibleParameterAnnotations", RTVisParamAnnotations)
+JBC_ATTR("RuntimeInvisibleParameterAnnotations", RTInvisParamAnnotations)
+JBC_ATTR("RuntimeVisibleTypeAnnotations", RTVisTypeAnnotations)
+JBC_ATTR("RuntimeInvisibleTypeAnnotations", RTInvisTypeAnnotations)
+JBC_ATTR("AnnotationDefault", AnnotationDefault)
+JBC_ATTR("BootstrapMethods", BootstrapMethods)
+JBC_ATTR("MethodParameters", MethodParameters)
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_attr.h b/src/hir2mpl/bytecode_input/class/include/jbc_attr.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea6ccc9f535724d6bab36cea2fb6cd49bb74efcc
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_attr.h
@@ -0,0 +1,583 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_ATTR_H
+#define HIR2MPL_INCLUDE_JBC_ATTR_H
+#include "mempool_allocator.h"
+#include "types_def.h"
+#include "fe_configs.h"
+#include "basic_io.h"
+#include "jbc_class_const_pool.h"
+#include "jbc_attr_item.h"
+#include "jbc_opcode.h"
+
+namespace maple {
+namespace jbc {
+const static uint32 kInvalidPC = UINT32_MAX;
+const static uint16 kInvalidPC16 = UINT16_MAX;
+const static uint32 kMaxPC32 = 0x0000FFFF;
+
+enum JBCAttrKind : uint8 {
+  kAttrUnknown,
+  kAttrRaw,
+#undef JBC_ATTR
+#define JBC_ATTR(name, type) kAttr##type,
+#include "jbc_attr.def"
+#undef JBC_ATTR
+};
+
+class JBCAttr {
+ public:
+  JBCAttr(JBCAttrKind kindIn, uint16 nameIdxIn, uint32 lengthIn);
+  virtual ~JBCAttr() = default;
+  static JBCAttr *InAttr(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool);
+  static JBCAttrKind AttrKind(const std::string &str);
+  JBCAttrKind GetKind() const {
+    return kind;
+  }
+
+  bool ParseFile(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+    return ParseFileImpl(allocator, io, constPool);
+  }
+
+  bool PreProcess(const JBCConstPool &constPool) {
+    return PreProcessImpl(constPool);
+  }
+
+  SimpleXMLElem *GenXmlElem(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const {
+    return GenXmlElemImpl(allocator, constPool, idx);
+  }
+
+ protected:
+  virtual bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) = 0;
+  virtual bool PreProcessImpl(const JBCConstPool &constPool) = 0;
+  virtual SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const = 0;
+
+  JBCAttrKind kind;
+  uint16 nameIdx;
+  uint32 length;
+};
+
+class JBCAttrMap {
+ public:
+  explicit JBCAttrMap(MapleAllocator &allocatorIn);
+  ~JBCAttrMap() = default;
+  void RegisterAttr(JBCAttr &attr);
+  std::list<JBCAttr*> GetAttrs(JBCAttrKind kind) const;
+  const JBCAttr *GetAttr(JBCAttrKind kind) const;
+  bool PreProcess(const JBCConstPool &constPool);
+
+ private:
+  MapleAllocator &allocator;
+  MapleMap<JBCAttrKind, MapleList<JBCAttr*>*> mapAttrs;
+};
+
+class JBCAttrRaw : public JBCAttr {
+ public:
+  JBCAttrRaw(const MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrRaw() override;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint8 *rawData;
+};
+
+struct JavaAttrLocalVariableInfoItem {
+  JavaAttrLocalVariableInfoItem()
+      : slotIdx(0),
+        start(0),
+        length(0),
+        nameIdx(0),
+        feirType(nullptr),
+        signatureNameIdx(0) {}
+
+  uint16 slotIdx;
+  uint16 start;
+  uint16 length;
+  GStrIdx nameIdx;           // in java format
+  const FEIRType *feirType;
+  GStrIdx signatureNameIdx;  // in java format
+};
+
+class JBCAttrLocalVariableInfo {
+ public:
+  explicit JBCAttrLocalVariableInfo(MapleAllocator &argAllocator);
+  ~JBCAttrLocalVariableInfo() = default;
+  void RegisterItem(const attr::LocalVariableTableItem &itemAttr);
+  void RegisterTypeItem(const attr::LocalVariableTypeTableItem &itemAttr);
+  const JavaAttrLocalVariableInfoItem &GetItemByStart(uint16 slotIdx, uint16 start) const;
+  uint16 GetStart(uint16 slotIdx, uint16 pc) const;
+  std::list<std::string> EmitToStrings() const;
+  static bool IsInvalidLocalVariableInfoItem(const JavaAttrLocalVariableInfoItem &item);
+
+ private:
+  void AddSlotStartMap(uint16 slotIdx, uint16 startPC);
+  void CheckItemAvaiable(uint16 slotIdx, uint16 start) const;
+  JavaAttrLocalVariableInfoItem *GetItemByStartInternal(uint16 slotIdx, uint16 start);
+
+  MapleAllocator &allocator;
+  MapleMap<uint16, MapleSet<uint16>> slotStartMap;  // map<slotIdx, set<start>>
+  MapleMap<std::pair<uint16, uint16>, JavaAttrLocalVariableInfoItem> itemMap;
+  static JavaAttrLocalVariableInfoItem kInvalidInfoItem;
+};
+
+// ConstantValue Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.2
+class JBCAttrConstantValue : public JBCAttr {
+ public:
+  JBCAttrConstantValue(const MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrConstantValue() override;
+  const JBCConst *GetConstValue() const {
+    return constValue;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 constIdx;
+  JBCConst *constValue;
+};
+
+// Code Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.3
+class JBCAttrLocalVariableInfo;
+class JBCOp;
+class JBCAttrCode : public JBCAttr {
+ public:
+  JBCAttrCode(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrCode() override;
+  void InitLocalVarInfo();
+  void SetLoadStoreType() const;
+  const MapleMap<const uint32, JBCOp*> &GetInstMap() const {
+    return instructions;
+  }
+
+  uint16 GetMaxStack() const {
+    return maxStack;
+  }
+
+  uint16 GetMaxLocals() const {
+    return maxLocals;
+  }
+
+  uint32 GetCodeLength() const {
+    return codeLength;
+  }
+
+  LLT_MOCK_TARGET const MapleVector<attr::ExceptionTableItem*> &GetExceptionInfos() const {
+    return exceptions;
+  }
+
+  const JBCAttr *GetAttr(JBCAttrKind kind) const {
+    return attrMap.GetAttr(kind);
+  }
+
+  const std::list<JBCAttr*> GetAttrs(JBCAttrKind kind) const {
+    return attrMap.GetAttrs(kind);
+  }
+
+  std::list<std::string> GetLocalVarInfoByString() const {
+    return localVarInfo.EmitToStrings();
+  }
+
+  const JBCAttrLocalVariableInfo &GetLocalVarInfo() const {
+    return localVarInfo;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  bool ParseOpcodes(MapleAllocator &allocator);
+
+  uint16 maxStack;
+  uint16 maxLocals;
+  uint32 codeLength;
+  uint8 *code;
+  uint16 nException;
+  MapleVector<attr::ExceptionTableItem*> exceptions;
+  uint16 nAttr;
+  MapleVector<JBCAttr*> attrs;
+  MapleMap<const uint32, JBCOp*> instructions;
+  JBCAttrMap attrMap;
+  JBCAttrLocalVariableInfo localVarInfo;
+};
+
+// StackMapTable Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.4
+class JBCAttrStackMapTable : public JBCAttr {
+ public:
+  JBCAttrStackMapTable(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrStackMapTable() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 count;
+  MapleVector<attr::StackMapFrameItem*> entries;
+};
+
+// Exceptions Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.5
+class JBCAttrException : public JBCAttr {
+ public:
+  JBCAttrException(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrException() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 count;
+  MapleVector<uint16> tbExceptionIdx;
+};
+
+// InnerClass Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.6
+class JBCAttrInnerClass : public JBCAttr {
+ public:
+  JBCAttrInnerClass(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrInnerClass() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 count;
+  MapleVector<attr::InnerClassItem*> tbClasses;
+};
+
+// EnclosingMethod Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.7
+class JBCAttrEnclosingMethod : public JBCAttr {
+ public:
+  JBCAttrEnclosingMethod(const MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrEnclosingMethod() override;
+  const JBCConstClass *GetConstClass() const {
+    return constClass;
+  }
+
+  const JBCConstNameAndType *GetConstNameAndType() const {
+    return constNameAndType;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 classIdx;
+  uint16 methodIdx;
+  JBCConstClass *constClass;
+  JBCConstNameAndType *constNameAndType;
+};
+
+// Synthetic Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.8
+class JBCAttrSynthetic : public JBCAttr {
+ public:
+  JBCAttrSynthetic(const MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrSynthetic() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+};
+
+// Signature Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.9
+class JBCAttrSignature : public JBCAttr {
+ public:
+  JBCAttrSignature(const MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrSignature() override;
+  const JBCConstUTF8 *GetConstSignatureName() const {
+    return constSignatureName;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 signatureIdx;
+  JBCConstUTF8 *constSignatureName;
+};
+
+// SourceFile Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.10
+class JBCAttrSourceFile : public JBCAttr {
+ public:
+  JBCAttrSourceFile(const MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrSourceFile() override;
+  const JBCConstUTF8 *GetConstFileName() const {
+    return constFileName;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 sourceFileIdx;
+  const JBCConstUTF8 *constFileName;
+};
+
+// SourceDebugExtension Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.11
+class JBCAttrSourceDebugEx : public JBCAttr {
+ public:
+  JBCAttrSourceDebugEx(const MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrSourceDebugEx() override;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  char *data;
+};
+
+// LineNumberTable Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.12
+class JBCAttrLineNumberTable : public JBCAttr {
+ public:
+  JBCAttrLineNumberTable(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrLineNumberTable() = default;
+  const MapleVector<attr::LineNumberTableItem*> &GetLineNums() const {
+    return lineNums;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 size;
+  MapleVector<attr::LineNumberTableItem*> lineNums;
+};
+
+// LocalVariableTable Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.13
+class JBCAttrLocalVariableTable : public JBCAttr {
+ public:
+  JBCAttrLocalVariableTable(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrLocalVariableTable() = default;
+  const MapleVector<attr::LocalVariableTableItem*> &GetLocalVarInfos() const {
+    return localVarInfos;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 size;
+  MapleVector<attr::LocalVariableTableItem*> localVarInfos;
+};
+
+// LocalVariableTypeTable Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.14
+class JBCAttrLocalVariableTypeTable : public JBCAttr {
+ public:
+  JBCAttrLocalVariableTypeTable(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrLocalVariableTypeTable() = default;
+  const MapleVector<attr::LocalVariableTypeTableItem*> &GetLocalVarTypeInfos() const {
+    return localVarTypeInfos;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 size;
+  MapleVector<attr::LocalVariableTypeTableItem*> localVarTypeInfos;
+};
+
+// Deprecated Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.15
+class JBCAttrDeprecated : public JBCAttr {
+ public:
+  JBCAttrDeprecated(const MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrDeprecated() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+};
+
+// RuntimeAnnoations Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.16
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.17
+class JBCAttrRTAnnotations : public JBCAttr {
+ public:
+  JBCAttrRTAnnotations(MapleAllocator &allocator, JBCAttrKind kindIn, uint16 nameIdx, uint32 length);
+  virtual ~JBCAttrRTAnnotations() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+  uint16 size;
+  MapleVector<attr::Annotation*> annotations;
+};
+
+class JBCAttrRTVisAnnotations : public JBCAttrRTAnnotations {
+ public:
+  JBCAttrRTVisAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrRTVisAnnotations() = default;
+};
+
+class JBCAttrRTInvisAnnotations : public JBCAttrRTAnnotations {
+ public:
+  JBCAttrRTInvisAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrRTInvisAnnotations() = default;
+};
+
+// RuntimeParamAnnoations Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.18
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.19
+class JBCAttrRTParamAnnotations : public JBCAttr {
+ public:
+  JBCAttrRTParamAnnotations(MapleAllocator &allocator, JBCAttrKind kindIn, uint16 nameIdx, uint32 length);
+  virtual ~JBCAttrRTParamAnnotations() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+  uint8 size;
+  MapleVector<attr::ParamAnnotationItem*> annotations;
+};
+
+class JBCAttrRTVisParamAnnotations : public JBCAttrRTParamAnnotations {
+ public:
+  JBCAttrRTVisParamAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrRTVisParamAnnotations() override {}
+};
+
+class JBCAttrRTInvisParamAnnotations : public JBCAttrRTParamAnnotations {
+ public:
+  JBCAttrRTInvisParamAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrRTInvisParamAnnotations() override {}
+};
+
+// RuntimeVisibleTypeAnnotations Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.20
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.21
+class JBCAttrRTTypeAnnotations : public JBCAttr {
+ public:
+  JBCAttrRTTypeAnnotations(MapleAllocator &allocator, JBCAttrKind kindIn, uint16 nameIdx, uint32 length);
+  virtual ~JBCAttrRTTypeAnnotations() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+  uint16 size;
+  MapleVector<attr::TypeAnnotationItem*> annotations;
+};
+
+class JBCAttrRTVisTypeAnnotations : public JBCAttrRTTypeAnnotations {
+ public:
+  JBCAttrRTVisTypeAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrRTVisTypeAnnotations() = default;
+};
+
+class JBCAttrRTInvisTypeAnnotations : public JBCAttrRTTypeAnnotations {
+ public:
+  JBCAttrRTInvisTypeAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrRTInvisTypeAnnotations() = default;
+};
+
+// AnnotationDefault Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.22
+class JBCAttrAnnotationDefault : public JBCAttr {
+ public:
+  JBCAttrAnnotationDefault(const MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrAnnotationDefault() override;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  attr::ElementValue *value;
+};
+
+// BootstrapMethods Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.23
+class JBCAttrBootstrapMethods : public JBCAttr {
+ public:
+  JBCAttrBootstrapMethods(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrBootstrapMethods() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 size;
+  MapleVector<attr::BootstrapMethodItem*> methods;
+};
+
+// MethodParameters Attribute
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.24
+class JBCAttrMethodParameters : public JBCAttr {
+ public:
+  JBCAttrMethodParameters(MapleAllocator &allocator, uint16 nameIdx, uint32 length);
+  ~JBCAttrMethodParameters() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint8 size;
+  MapleVector<attr::MethodParamItem*> params;
+};
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_ATTR_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_attr_item.h b/src/hir2mpl/bytecode_input/class/include/jbc_attr_item.h
new file mode 100644
index 0000000000000000000000000000000000000000..e94c7d12c58877e5f036c4dc968083bb0cf2e75a
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_attr_item.h
@@ -0,0 +1,912 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_ATTR_ITEM_H
+#define HIR2MPL_INCLUDE_JBC_ATTR_ITEM_H
+#include <map>
+#include <string>
+#include "mempool_allocator.h"
+#include "types_def.h"
+#include "jbc_class_const_pool.h"
+
+namespace maple {
+namespace jbc {
+namespace attr {
+// ElementValueItem
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.16
+enum ElementValueKind : uint8 {
+  kElementValueDefault = 0,
+  kElementValueConst,
+  kElementValueEnum,
+  kElementValueClassInfo,
+  kElementValueAnnotation,
+  kElementValueArray
+};
+
+class JBCAttrItem {
+ public:
+  JBCAttrItem() = default;
+  virtual ~JBCAttrItem() = default;
+  bool ParseFile(MapleAllocator &allocator, BasicIORead &io) {
+    return ParseFileImpl(allocator, io);
+  }
+
+  bool PreProcess(const JBCConstPool &constPool) {
+    return PreProcessImpl(constPool);
+  }
+
+  SimpleXMLElem *GenXmlElem(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const {
+    return GenXmlElemImpl(allocator, constPool, idx);
+  }
+
+ protected:
+  virtual bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) = 0;
+  virtual bool PreProcessImpl(const JBCConstPool &constPool) = 0;
+  virtual SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const = 0;
+};
+
+// ExceptiionTableItem in Code Attr
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.3
+class ExceptionTableItem : public JBCAttrItem {
+ public:
+  ExceptionTableItem();
+  ~ExceptionTableItem() override;
+  uint16 GetStartPC() const {
+    return startPC;
+  }
+
+  uint16 GetEndPC() const {
+    return endPC;
+  }
+
+  uint16 GetHandlerPC() const {
+    return handlerPC;
+  }
+
+  const JBCConstClass *GetCatchType() const {
+    return catchType;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 startPC;
+  uint16 endPC;
+  uint16 handlerPC;
+  uint16 catchTypeIdx;
+  const JBCConstClass *catchType;
+};
+
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.4
+enum VerificationTypeInfoTag : uint8 {
+  kVerTypeInfoItemTop = 0,
+  kVerTypeInfoItemInteger = 1,
+  kVerTypeInfoItemFloat = 2,
+  kVerTypeInfoItemDouble = 3,
+  kVerTypeInfoItemLong = 4,
+  kVerTypeInfoItemNull = 5,
+  kVerTypeInfoItemUninitializedThis = 6,
+  kVerTypeInfoItemObject = 7,
+  kVerTypeInfoItemUninitialized = 8,
+  kVerTypeInfoItemUnknown = 0xFF,
+};
+
+class VerificationTypeInfo : public JBCAttrItem {
+ public:
+  VerificationTypeInfo();
+  ~VerificationTypeInfo() override;
+  static std::map<VerificationTypeInfoTag, std::string> InitTagNameMap();
+  static std::string TagName(VerificationTypeInfoTag t);
+  const JBCConstClass &GetClassInfoRef() const {
+    CHECK_NULL_FATAL(classInfo);
+    return *classInfo;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  VerificationTypeInfoTag tag;
+  union {
+    uint16 cpoolIdx;
+    uint16 offset;
+    uint16 raw;
+  } data;
+  JBCConstClass *classInfo;
+  static std::map<VerificationTypeInfoTag, std::string> tagNameMap;
+};
+
+enum StackMapFrameItemTag : uint8 {
+  kStackSame,
+  kStackSameLocals1StackItem,
+  kStackSameLocals1StackItemEx,
+  kStackChop,
+  kStackSameFrameEx,
+  kStackAppend,
+  kStackFullFrame,
+  kStackReserved,
+};
+
+class StackMapFrameItem : public JBCAttrItem {
+ public:
+  StackMapFrameItem(uint8 frameTypeIn, StackMapFrameItemTag tagIn);
+  virtual ~StackMapFrameItem() = default;
+  static std::map<StackMapFrameItemTag, std::string> InitTagName();
+  static std::string TagName(StackMapFrameItemTag tag);
+  static StackMapFrameItemTag FrameType2Tag(uint8 frameType);
+  static StackMapFrameItem *NewItem(MapleAllocator &allocator, BasicIORead &io, uint8 frameType);
+
+ protected:
+  StackMapFrameItemTag tag;
+  uint8 frameType;
+  static std::map<StackMapFrameItemTag, std::string> tagNameMap;
+};
+
+class StackMapFrameItemSame : public StackMapFrameItem {
+ public:
+  explicit StackMapFrameItemSame(uint8 frameType);
+  ~StackMapFrameItemSame() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+};
+
+class StackMapFrameItemSameLocals1 : public StackMapFrameItem {
+ public:
+  explicit StackMapFrameItemSameLocals1(uint8 frameType);
+  ~StackMapFrameItemSameLocals1() override;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  VerificationTypeInfo *stack;
+};
+
+class StackMapFrameItemSameLocals1Ex : public StackMapFrameItem {
+ public:
+  explicit StackMapFrameItemSameLocals1Ex(uint8 frameType);
+  ~StackMapFrameItemSameLocals1Ex() override;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 offsetDelta;
+  VerificationTypeInfo *stack;
+};
+
+class StackMapFrameItemChop : public StackMapFrameItem {
+ public:
+  explicit StackMapFrameItemChop(uint8 frameType);
+  ~StackMapFrameItemChop() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 offsetDelta;
+};
+
+class StackMapFrameItemSameEx : public StackMapFrameItem {
+ public:
+  explicit StackMapFrameItemSameEx(uint8 frameType);
+  ~StackMapFrameItemSameEx() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 offsetDelta;
+};
+
+class StackMapFrameItemAppend : public StackMapFrameItem {
+ public:
+  StackMapFrameItemAppend(MapleAllocator &allocator, uint8 frameType);
+  ~StackMapFrameItemAppend() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 offsetDelta;
+  MapleVector<VerificationTypeInfo*> locals;
+};
+
+class StackMapFrameItemFull : public StackMapFrameItem {
+ public:
+  StackMapFrameItemFull(MapleAllocator &allocator, uint8 frameType);
+  ~StackMapFrameItemFull() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 offsetDelta;
+  uint16 nLocals;
+  MapleVector<VerificationTypeInfo*> locals;
+  uint16 nStacks;
+  MapleVector<VerificationTypeInfo*> stacks;
+};
+
+// InnerClassItem in Attr InnerClass
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.6
+class InnerClassItem : public JBCAttrItem {
+ public:
+  InnerClassItem();
+  ~InnerClassItem() override;
+  const JBCConstClass *GetConstClassInnerRef() const {
+    return constClassInner;
+  }
+
+  const JBCConstClass *GetConstClassOuter() const {
+    return constClassOuter;
+  }
+
+  const JBCConstUTF8 *GetConstNameInner() const {
+    return constNameInner;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 innerClassInfoIdx;
+  uint16 outerClassInfoIdx;
+  uint16 innerNameIdx;
+  uint16 innerClassAccessFlag;
+  JBCConstClass *constClassInner;
+  JBCConstClass *constClassOuter;
+  JBCConstUTF8 *constNameInner;
+};
+
+// LineNumberTableItem in Attr LineNumberTable
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.12
+class LineNumberTableItem : public JBCAttrItem {
+ public:
+  LineNumberTableItem();
+  ~LineNumberTableItem() = default;
+  uint16 GetStartPC() const {
+    return startPC;
+  }
+
+  uint16 GetLineNumber() const {
+    return lineNumber;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 startPC;
+  uint16 lineNumber;
+};
+
+// LocalVariableTableItem in Attr LocalVariableTable
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.13
+class LocalVariableTableItem : public JBCAttrItem {
+ public:
+  LocalVariableTableItem();
+  ~LocalVariableTableItem() override;
+  const JBCConstUTF8 *GetConstName() const {
+    return constName;
+  }
+
+  const JBCConstUTF8 *GetConstDesc() const {
+    return constDesc;
+  }
+
+  uint16 GetStartPC() const {
+    return startPC;
+  }
+
+  uint16 GetLength() const {
+    return length;
+  }
+
+  uint16 GetIndex() const {
+    return index;
+  }
+
+  GStrIdx GetNameStrIdx() const {
+    CHECK_NULL_FATAL(constName);
+    return constName->GetStrIdx();
+  }
+
+  const FEIRType *GetFEIRType() const {
+    return feirType;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 startPC;
+  uint16 length;
+  uint16 nameIdx;
+  uint16 descIdx;
+  uint16 index;
+  const JBCConstUTF8 *constName;
+  const JBCConstUTF8 *constDesc;
+  GStrIdx nameIdxMpl;
+  const FEIRType *feirType;
+};
+
+// LocalVariableTypeTableItem in Attr LocalVariableTypeTable
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.14
+class LocalVariableTypeTableItem : public JBCAttrItem {
+ public:
+  LocalVariableTypeTableItem();
+  ~LocalVariableTypeTableItem() override;
+  const JBCConstUTF8 *GetConstName() const {
+    return constName;
+  }
+
+  const JBCConstUTF8 *GetConstSignature() const {
+    return constSignature;
+  }
+
+  uint16 GetStartPC() const {
+    return startPC;
+  }
+
+  uint16 GetLength() const {
+    return length;
+  }
+
+  uint16 GetIndex() const {
+    return index;
+  }
+
+  GStrIdx GetNameStrIdx() const {
+    CHECK_NULL_FATAL(constName);
+    return constName->GetStrIdx();
+  }
+
+  GStrIdx GetSignatureStrIdx() const {
+    CHECK_NULL_FATAL(constSignature);
+    return constSignature->GetStrIdx();
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 startPC;
+  uint16 length;
+  uint16 nameIdx;
+  uint16 signatureIdx;
+  uint16 index;
+  const JBCConstUTF8 *constName;
+  const JBCConstUTF8 *constSignature;
+  GStrIdx nameIdxMpl;
+};
+
+class ElementValueItem : public JBCAttrItem {
+ public:
+  ElementValueItem(ElementValueKind kindIn, char tagIn);
+  virtual ~ElementValueItem() = default;
+  static std::map<char, ElementValueKind> InitTagKindMap();
+  static std::map<ElementValueKind, std::string> InitKindNameMap();
+  static std::string KindName(ElementValueKind kind);
+  static ElementValueKind TagToKind(char tag);
+  static ElementValueItem *NewItem(MapleAllocator &allocator, BasicIORead &io, char tag);
+
+ protected:
+  ElementValueKind kind;
+  char tag;
+  static std::map<char, ElementValueKind> tagKindMap;
+  static std::map<ElementValueKind, std::string> kindNameMap;
+};
+
+class ElementValue : public JBCAttrItem {
+ public:
+  ElementValue();
+  ~ElementValue() override;
+  ElementValueKind GetKind() const {
+    return kind;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  char tag;
+  ElementValueKind kind;
+  ElementValueItem *value;
+};
+
+class ElementValuePair : public JBCAttrItem {
+ public:
+  ElementValuePair();
+  ~ElementValuePair() override;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 nameIdx;
+  ElementValue *value;
+};
+
+// Annotation
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.16
+class Annotation : public JBCAttrItem {
+ public:
+  explicit Annotation(MapleAllocator &allocator);
+  ~Annotation() override;
+  const JBCConstUTF8 *GetConstTypeName() const {
+    return constTypeName;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 typeIdx;
+  uint16 nElemPairs;
+  MapleVector<ElementValuePair*> tbElemPairs;
+  JBCConstUTF8 *constTypeName;
+};
+
+// ParamAnnotationItem in Attr ParamAnnotation
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.18
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.19
+class ParamAnnotationItem : public JBCAttrItem {
+ public:
+  explicit ParamAnnotationItem(MapleAllocator &allocator);
+  ~ParamAnnotationItem() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 count;
+  MapleVector<Annotation*> annotations;
+};
+
+// BootstrapMethodItem in Attr BootstrapMethod
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.23
+class BootstrapMethodItem : public JBCAttrItem {
+ public:
+  explicit BootstrapMethodItem(MapleAllocator &allocator);
+  ~BootstrapMethodItem() override;
+  const JBCConstMethodHandleInfo *GetConstMethodHandleInfo() const {
+    return methodHandle;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 methodRefIdx;
+  uint16 nArgs;
+  MapleVector<uint16> argsIdx;
+  JBCConstMethodHandleInfo *methodHandle;
+  MapleVector<JBCConst*> args;
+};
+
+// MethodParamItem in Attr MethodParam
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.24
+class MethodParamItem : public JBCAttrItem {
+ public:
+  MethodParamItem();
+  ~MethodParamItem() override;
+  const JBCConstUTF8 *GetConstName() const {
+    return constName;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 nameIdx;
+  uint16 accessFlag;
+  JBCConstUTF8 *constName;
+};
+
+class ElementValuePair;
+
+class ElementValueConst : public ElementValueItem {
+ public:
+  explicit ElementValueConst(uint8 t);
+  ~ElementValueConst() override;
+  const JBCConst *GetConstValue() const {
+    return constValue;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 constValueIdx;
+  JBCConst *constValue;
+};
+
+class ElementValueEnum : public ElementValueItem {
+ public:
+  ElementValueEnum();
+  ~ElementValueEnum() override;
+  const JBCConstUTF8 *GetConstTypeName() const {
+    return constTypeName;
+  }
+
+  const JBCConstUTF8 *GetConstName() const {
+    return constName;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 typeNameIdx;
+  uint16 constNameIdx;
+  JBCConstUTF8 *constTypeName;
+  JBCConstUTF8 *constName;
+};
+
+class ElementValueClassInfo : public ElementValueItem {
+ public:
+  ElementValueClassInfo();
+  ~ElementValueClassInfo() override;
+  const JBCConstUTF8 *GetConstClassInfo() const {
+    return constClassInfo;
+  }
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 classInfoIdx;
+  JBCConstUTF8 *constClassInfo;
+};
+
+class ElementValueAnnotation : public ElementValueItem {
+ public:
+  ElementValueAnnotation();
+  ~ElementValueAnnotation() override;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  Annotation *annotation;
+};
+
+class ElementValueArray : public ElementValueItem {
+ public:
+  explicit ElementValueArray(MapleAllocator &allocator);
+  ~ElementValueArray() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 size;
+  MapleVector<ElementValue*> values;
+};
+
+// TargetInfo
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.20.1
+enum TargetInfoItemTag : uint8 {
+  kTargetTagUndefine,
+  kTargetTagTypeParam,
+  kTargetTagSuperType,
+  kTargetTagTypeParamBound,
+  kTargetTagEmpty,
+  kTargetTagFormalParam,
+  kTargetTagThrows,
+  kTargetTagLocalVar,
+  kTargetTagCatch,
+  kTargetTagOffset,
+  kTargetTagTypeArg,
+};
+
+enum TargetInfoItemType : uint8 {
+  kTargetTypeParamClass = 0x00,
+  kTargetTypeParamMethod = 0x01,
+  kTargetTypeHierarchy = 0x10,
+  kTargetTypeBoundClass = 0x11,
+  kTargetTypeBoundMethod = 0x12,
+  kTargetTypeFieldDecl = 0x13,
+  kTargetTypeReturn = 0x14,
+  kTargetTypeReceiver = 0x15,
+  kTargetTypeFormal = 0x16,
+  kTargetTypeThrows = 0x17,
+  kTargetTypeLocalVar = 0x40,
+  kTargetTypeResourceVar = 0x41,
+  kTargetTypeExpectionParam = 0x42,
+  kTargetTypeInstanceof = 0x43,
+  kTargetTypeNew = 0x44,
+  kTargetTypeMethodRefNew = 0x45,
+  kTargetTypeMethodRefIdentifier = 0x46,
+  kTargetTypeCast = 0x47,
+  kTargetTypeConstructorInvoke = 0x48,
+  kTargetTypeMethodInvoke = 0x49,
+  kTargetTypeConstructorNew = 0x4A,
+  kTargetTypeConstructorIdentifier = 0x4B,
+};
+
+class TargetInfoItem : public JBCAttrItem {
+ public:
+  explicit TargetInfoItem(TargetInfoItemTag tagIn);
+  virtual ~TargetInfoItem() = default;
+  static std::map<TargetInfoItemType, TargetInfoItemTag> InitTypeTagMap();
+  static TargetInfoItemTag TargetType2Tag(TargetInfoItemType type);
+  static TargetInfoItem *NewItem(MapleAllocator &allocator, BasicIORead &io, TargetInfoItemType targetType);
+
+ protected:
+  TargetInfoItemTag tag;
+  static std::map<TargetInfoItemType, TargetInfoItemTag> typeTagMap;
+};
+
+class TargetTypeParam : public TargetInfoItem {
+ public:
+  TargetTypeParam();
+  ~TargetTypeParam() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint8 paramIdx;
+};
+
+class TargetSuperType : public TargetInfoItem {
+ public:
+  TargetSuperType();
+  ~TargetSuperType() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 index;
+};
+
+class TargetTypeParamBound : public TargetInfoItem {
+ public:
+  TargetTypeParamBound();
+  ~TargetTypeParamBound() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint8 paramIdx;
+  uint8 boundIdx;
+};
+
+class TargetEmpty : public TargetInfoItem {
+ public:
+  TargetEmpty();
+  ~TargetEmpty() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+};
+
+class TargetFormalParam : public TargetInfoItem {
+ public:
+  TargetFormalParam();
+  ~TargetFormalParam() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint8 paramIdx;
+};
+
+class TargetThrows : public TargetInfoItem {
+ public:
+  TargetThrows();
+  ~TargetThrows() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 typeIdx;
+};
+
+class TargetLocalVarItem : public TargetInfoItem {
+ public:
+  TargetLocalVarItem();
+  ~TargetLocalVarItem() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 startPC;
+  uint16 length;
+  uint16 index;
+};
+
+class TargetLocalVar : public TargetInfoItem {
+ public:
+  explicit TargetLocalVar(MapleAllocator &allocator);
+  ~TargetLocalVar() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 size;
+  MapleVector<TargetLocalVarItem*> table;
+};
+
+class TargetCatch : public TargetInfoItem {
+ public:
+  TargetCatch();
+  ~TargetCatch() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 exTableIdx;
+};
+
+class TargetOffset : public TargetInfoItem {
+ public:
+  TargetOffset();
+  ~TargetOffset() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 offset;
+};
+
+class TargetTypeArg : public TargetInfoItem {
+ public:
+  TargetTypeArg();
+  ~TargetTypeArg() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint16 offset;
+  uint8 typeArgIdx;
+};
+
+class TypePathItem : public JBCAttrItem {
+ public:
+  TypePathItem();
+  ~TypePathItem() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint8 typePathKind;
+  uint8 typeArgIdx;
+};
+
+// TypePath
+// ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.20.2
+class TypePath : public JBCAttrItem {
+ public:
+  explicit TypePath(MapleAllocator &allocator);
+  ~TypePath() = default;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  uint8 pathLength;
+  MapleVector<TypePathItem*> tbPath;
+};
+
+class TypeAnnotationItem : public JBCAttrItem {
+ public:
+  explicit TypeAnnotationItem(MapleAllocator &allocator);
+  ~TypeAnnotationItem() override;
+
+ protected:
+  bool ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const override;
+
+ private:
+  TargetInfoItemType targetType;
+  TargetInfoItem *targetInfo;
+  TypePath *targetPath;
+  uint16 typeIdx;
+  uint16 nElemPairs;
+  MapleVector<ElementValuePair*> elemPairs;
+};
+}  // namespace attr
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_ATTR_ITEM_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_bb.h b/src/hir2mpl/bytecode_input/class/include/jbc_bb.h
new file mode 100644
index 0000000000000000000000000000000000000000..889e994988a1b7faca88d448e50caa71f3e36059
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_bb.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_BB_H
+#define HIR2MPL_INCLUDE_JBC_BB_H
+#include <memory>
+#include "feir_bb.h"
+#include "jbc_stack_helper.h"
+
+namespace maple {
+class JBCBB : public FEIRBB {
+ public:
+  JBCBB(const jbc::JBCConstPool &argConstPool);
+  JBCBB(uint8 argBBKind, const jbc::JBCConstPool &argConstPool);
+  ~JBCBB() override = default;
+  bool InitForFuncHeader();
+  bool InitForCatch();
+  bool UpdateStack();
+  bool UpdateStackByPredBB(const JBCBB &bb);
+  bool UpdateStackByPredBBEnd() const;
+  bool CheckStack();
+  uint32 GetSwapSize() const;
+  bool GetStackError() const {
+    return stackError;
+  }
+
+  const JBCStackHelper &GetMinStackIn() const {
+    return minStackIn;
+  }
+
+  const JBCStackHelper &GetMinStackOut() const {
+    return minStackOut;
+  }
+
+ protected:
+  void Dump() const override;
+
+ private:
+  const jbc::JBCConstPool &constPool;
+  bool stackError : 1;
+  bool stackInUpdated : 1;
+  bool stackOutUpdated : 1;
+  bool updatePredEnd : 1;
+  JBCStackHelper minStackIn;
+  JBCStackHelper minStackOut;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_BB_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_class.h b/src/hir2mpl/bytecode_input/class/include/jbc_class.h
new file mode 100644
index 0000000000000000000000000000000000000000..39e20721cab501ead4c94a95fe9072a88112108f
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_class.h
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_CLASS_H
+#define HIR2MPL_INCLUDE_JBC_CLASS_H
+#include "mempool_allocator.h"
+#include "fe_configs.h"
+#include "jbc_class_access.h"
+#include "jbc_class_header.h"
+#include "jbc_class_const_pool.h"
+#include "jbc_attr.h"
+
+namespace maple {
+namespace jbc {
+class JBCClass;
+class JBCClassElem {
+ public:
+  JBCClassElem(MapleAllocator &allocator, const JBCClass &argKlass);
+  virtual ~JBCClassElem() = default;
+  bool ParseFile(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool);
+  const JBCConstPool &GetConstPool() const;
+  std::string GetFullName() const;
+  LLT_MOCK_TARGET uint16 GetAccessFlag() const {
+    return accessFlag;
+  }
+
+  LLT_MOCK_TARGET bool IsStatic() const {
+    return (accessFlag & kAccFieldStatic) != 0;
+  }
+
+  LLT_MOCK_TARGET std::string GetClassName() const;
+
+  LLT_MOCK_TARGET std::string GetName(const JBCConstPool &constPool) const {
+    return constPool.GetStringByConstUTF8(nameIdx);
+  }
+
+  LLT_MOCK_TARGET std::string GetName() const {
+    return GetConstPool().GetStringByConstUTF8(nameIdx);
+  }
+
+  LLT_MOCK_TARGET std::string GetDescription(const JBCConstPool &constPool) const {
+    return constPool.GetStringByConstUTF8(descIdx);
+  }
+
+  LLT_MOCK_TARGET std::string GetDescription() const {
+    return GetConstPool().GetStringByConstUTF8(descIdx);
+  }
+
+  uint16 GetNameIdx() const {
+    return nameIdx;
+  }
+
+  uint16 GetDescriptionIdx() const {
+    return descIdx;
+  }
+
+  const JBCClass &GetClass() const {
+    return klass;
+  }
+
+  const JBCAttr *GetAttr(JBCAttrKind kind) const {
+    return attrMap.GetAttr(kind);
+  }
+
+  const std::list<JBCAttr*> GetAttrs(JBCAttrKind kind) const {
+    return attrMap.GetAttrs(kind);
+  }
+
+  SimpleXMLElem *GenXmlElem(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) {
+    return GenXmlElemImpl(allocator, constPool, idx);
+  }
+
+ protected:
+  virtual SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) = 0;
+
+  const JBCClass &klass;
+  uint16 accessFlag;
+  uint16 nameIdx;
+  uint16 descIdx;
+  uint16 nAttr;
+  MapleVector<JBCAttr*> attrs;
+  JBCAttrMap attrMap;
+};
+
+class JBCClassField : public JBCClassElem {
+ public:
+  JBCClassField(MapleAllocator &allocator, const JBCClass &argKlass);
+  ~JBCClassField() = default;
+
+ protected:
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) override;
+};
+
+class JBCClassMethod : public JBCClassElem {
+ public:
+  JBCClassMethod(MapleAllocator &allocator, const JBCClass &argKlass);
+  ~JBCClassMethod() = default;
+  bool PreProcess();
+  const JBCAttrCode *GetCode() const;
+  bool IsVirtual() const;
+  bool IsNative() const;
+  bool HasCode() const;
+
+ protected:
+  SimpleXMLElem *GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) override;
+};
+
+class JBCClass {
+ public:
+  JBCClass(MapleAllocator &allocatorIn);
+  LLT_MOCK_TARGET ~JBCClass() = default;
+
+  bool ParseFile(BasicIORead &io);
+  bool PreProcess();
+  GStrIdx GetClassNameIdxOrin() const;
+  GStrIdx GetClassNameIdxMpl() const;
+  LLT_MOCK_TARGET std::string GetClassNameOrin() const;
+  LLT_MOCK_TARGET std::string GetClassNameMpl() const;
+  LLT_MOCK_TARGET std::string GetSourceFileName() const;
+  LLT_MOCK_TARGET std::string GetSuperClassName() const;
+  LLT_MOCK_TARGET std::vector<std::string> GetInterfaceNames() const;
+  static JBCClass *InClass(MapleAllocator &allocator, BasicIORead &io);
+
+  uint16 GetAccessFlag() const {
+    return header.accessFlag;
+  }
+
+  const JBCConstPool &GetConstPool() const {
+    return constPool;
+  }
+
+  uint16 GetConstPoolCount() const {
+    return header.constPoolCount;
+  }
+
+  uint16 GetFieldCount() const {
+    return header.fieldsCount;
+  }
+
+  uint16 GetMethodCount() const {
+    return header.methodsCount;
+  }
+
+  uint16 GetAttrCount() const {
+    return header.attrsCount;
+  }
+
+  bool IsInterface() const {
+    return (header.accessFlag & JBCClassAccessFlag::kAccClassInterface) != 0;
+  }
+
+  const MapleVector<JBCClassField*> &GetFields() const {
+    return tbFields;
+  }
+
+  const MapleVector<JBCClassMethod*> &GetMethods() const {
+    return tbMethods;
+  }
+
+  void SetFilePathName(const std::string &name) {
+    filePathName = name;
+  }
+
+  const std::string GetFilePathName() const {
+    return filePathName.length() == 0 ? "" : std::string(filePathName.c_str());
+  }
+
+  const std::string GetFileName() const {
+    return fileName.length() == 0 ? "" : std::string(fileName.c_str());
+  }
+
+  void SetSrcFileInfoIdx(uint32 idx) {
+    srcFileInfoIdx = idx;
+  }
+
+  uint32 GetSrcFileInfoIdx() const {
+    return srcFileInfoIdx;
+  }
+
+  const JBCAttr *GetAttr(JBCAttrKind kind) const {
+    return attrMap.GetAttr(kind);
+  }
+
+  std::list<JBCAttr*> GetAttrs(JBCAttrKind kind) const {
+    return attrMap.GetAttrs(kind);
+  }
+
+ LLT_PRIVATE:
+  void InitHeader();
+  bool ParseFileForConstPool(BasicIORead &io);
+  bool ParseFileForFields(BasicIORead &io);
+  bool ParseFileForMethods(BasicIORead &io);
+  bool ParseFileForAttrs(BasicIORead &io);
+
+  struct {
+    uint32 magic;
+    uint16 minorVersion;
+    uint16 majorVersion;
+    uint16 constPoolCount;
+    uint16 accessFlag;
+    uint16 thisClass;
+    uint16 superClass;
+    uint16 interfacesCount;
+    uint16 fieldsCount;
+    uint16 methodsCount;
+    uint16 attrsCount;
+  } header;
+  MapleAllocator &allocator;
+  JBCConstPool constPool;
+  MapleVector<uint16> tbInterfaces;
+  MapleVector<JBCClassField*> tbFields;
+  MapleVector<JBCClassMethod*> tbMethods;
+  MapleVector<JBCAttr*> tbAttrs;
+  JBCAttrMap attrMap;
+  MapleString filePathName;
+  MapleString fileName;
+  uint32 srcFileInfoIdx = 0;
+};
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_CLASS_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_class2fe_helper.h b/src/hir2mpl/bytecode_input/class/include/jbc_class2fe_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb73f924090a3193cf8c741d9612a1f690d99f9c
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_class2fe_helper.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC2FE_INPUT_HELPER_STRUCT_H
+#define HIR2MPL_INCLUDE_JBC2FE_INPUT_HELPER_STRUCT_H
+#include "fe_configs.h"
+#include "jbc_class.h"
+#include "jbc_input.h"
+#include "fe_input_helper.h"
+
+namespace maple {
+class JBCClass2FEHelper : public FEInputStructHelper {
+ public:
+  JBCClass2FEHelper(MapleAllocator &allocator, const jbc::JBCClass &klassIn);
+  ~JBCClass2FEHelper() = default;
+  const jbc::JBCConstPool &GetConstPool() const {
+    return klass.GetConstPool();
+  }
+
+  LLT_MOCK_TARGET bool IsStaticFieldProguard() const {
+    return isStaticFieldProguard;
+  }
+
+ protected:
+  std::string GetStructNameOrinImpl() const override;
+  std::string GetStructNameMplImpl() const override;
+  std::list<std::string> GetSuperClassNamesImpl() const override;
+  std::vector<std::string> GetInterfaceNamesImpl() const override;
+  std::string GetSourceFileNameImpl() const override;
+  MIRStructType *CreateMIRStructTypeImpl(bool &error) const override;
+  TypeAttrs GetStructAttributeFromInputImpl() const override;
+  uint64 GetRawAccessFlagsImpl() const override;
+  GStrIdx GetIRSrcFileSigIdxImpl() const override;
+  bool IsMultiDefImpl() const override;
+  void InitFieldHelpersImpl() override;
+  void InitMethodHelpersImpl() override;
+  std::string GetSrcFileNameImpl() const override;
+
+ private:
+  const jbc::JBCClass &klass;
+  bool isStaticFieldProguard;
+};
+
+class JBCClassField2FEHelper : public FEInputFieldHelper {
+ public:
+  JBCClassField2FEHelper(MapleAllocator &allocator, const jbc::JBCClassField &fieldIn)
+      : FEInputFieldHelper(allocator),
+        field(fieldIn) {}
+  ~JBCClassField2FEHelper() = default;
+  static FieldAttrs AccessFlag2Attribute(uint16 accessFlag);
+
+ protected:
+  bool ProcessDeclImpl(MapleAllocator &allocator) override;
+  bool ProcessDeclWithContainerImpl(MapleAllocator &allocator) override;
+
+ private:
+  const jbc::JBCClassField &field;
+};
+
+class JBCClassMethod2FEHelper : public FEInputMethodHelper {
+ public:
+  JBCClassMethod2FEHelper(MapleAllocator &allocator, const jbc::JBCClassMethod &methodIn);
+  ~JBCClassMethod2FEHelper() = default;
+  const jbc::JBCClassMethod &GetMethod() const {
+    return method;
+  }
+
+ protected:
+  bool ProcessDeclImpl(MapleAllocator &allocator) override;
+  void SolveReturnAndArgTypesImpl(MapleAllocator &allocator) override;
+  std::string GetMethodNameImpl(bool inMpl, bool full) const override;
+  FuncAttrs GetAttrsImpl() const override;
+  bool IsStaticImpl() const override;
+  bool IsVargImpl() const override;
+  bool HasThisImpl() const override;
+  MIRType *GetTypeForThisImpl() const override;
+  bool IsVirtualImpl() const override;
+  bool IsNativeImpl() const override;
+  bool HasCodeImpl() const override;
+
+ private:
+  bool IsClinit() const;
+  bool IsInit() const;
+
+  const jbc::JBCClassMethod &method;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC2FE_INPUT_HELPER_STRUCT_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_class_access.h b/src/hir2mpl/bytecode_input/class/include/jbc_class_access.h
new file mode 100644
index 0000000000000000000000000000000000000000..d38ba68c4e20e8760d230b020689f7f367c9510f
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_class_access.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_CLASS_ACCESS_H
+#define HIR2MPL_INCLUDE_JBC_CLASS_ACCESS_H
+
+namespace maple {
+namespace jbc {
+enum JBCClassAccessFlag: uint16 {
+  kAccClassPublic = 0x0001,
+  kAccClassFinal = 0x0010,
+  kAccClassSuper = 0x0020,
+  kAccClassInterface = 0x0200,
+  kAccClassAbstract = 0x0400,
+  kAccClassSynthetic = 0x1000,
+  kAccClassAnnotation = 0x2000,
+  kAccClassEnum = 0x4000,
+};
+
+enum JBCClassFieldAccessFlag {
+  kAccFieldPublic = 0x0001,
+  kAccFieldPrivate = 0x0002,
+  kAccFieldProtected = 0x0004,
+  kAccFieldStatic = 0x0008,
+  kAccFieldFinal = 0x0010,
+  kAccFieldVolatile = 0x0040,
+  kAccFieldTransient = 0x0080,
+  kAccFieldSynthetic = 0x1000,
+  kAccFieldEnum = 0x4000,
+};
+
+enum JBCClassMethodAccessFlag: uint16 {
+  kAccMethodPublic = 0x0001,
+  kAccMethodPrivate = 0x0002,
+  kAccMethodProtected = 0x0004,
+  kAccMethodStatic = 0x0008,
+  kAccMethodFinal = 0x0010,
+  kAccMethodSynchronized = 0x0020,
+  kAccMethodBridge = 0x0040,
+  kAccMethodVarargs = 0x0080,
+  kAccMethodNative = 0x0100,
+  kAccMethodAbstract = 0x0400,
+  kAccMethodStrict = 0x0800,
+  kAccMethodSynthetic = 0x1000,
+};
+
+enum JBCAccessFlag {
+  kAccPublic = 0x0001,
+  kAccPrivate = 0x0002,
+  kAccProtected = 0x0004,
+  kAccStatic = 0x0008,
+  kAccFinal = 0x0010,
+  kAccSuperOrSynchronized = 0x0020,
+  kAccBridgeOrVolatile = 0x0040,
+  kAccVarargsOrTransient = 0x0080,
+  kAccNative = 0x0100,
+  kAccInterface = 0x0200,
+  kAccAbstract = 0x0400,
+  kAccStrict = 0x0800,
+  kAccSynthetic = 0x1000,
+  kAccAnnotation = 0x2000,
+  kAccEnum = 0x4000,
+};
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_CLASS_ACCESS_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_class_builder.h b/src/hir2mpl/bytecode_input/class/include/jbc_class_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..99760fc2965b16a31a7142f21e63ca409e2f8287
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_class_builder.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_CLASS_BUILDER_H
+#define HIR2MPL_INCLUDE_JBC_CLASS_BUILDER_H
+#include "jbc_class.h"
+
+namespace maple {
+namespace jbc {
+class JBCClassBuilder {
+ public:
+  JBCClassBuilder() = default;
+  ~JBCClassBuilder() = default;
+
+ public:
+};
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_CLASS_BUILDER_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_class_const.def b/src/hir2mpl/bytecode_input/class/include/jbc_class_const.def
new file mode 100644
index 0000000000000000000000000000000000000000..49ef783b5ef68f320d45bf65488ca09cf4864f13
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_class_const.def
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// JBC_CONST(tag, tagName, className)
+JBC_CONST(kConstUTF8, "ConstUTF8", JBCConstUTF8)
+JBC_CONST(kConstInteger, "ConstInteger", JBCConst4Byte)
+JBC_CONST(kConstFloat, "ConstFloat", JBCConst4Byte)
+JBC_CONST(kConstLong, "ConstLong", JBCConst8Byte)
+JBC_CONST(kConstDouble, "ConstDouble", JBCConst8Byte)
+JBC_CONST(kConstClass, "ConstClass", JBCConstClass)
+JBC_CONST(kConstString, "ConstString", JBCConstString)
+JBC_CONST(kConstFieldRef, "ConstFieldRef", JBCConstRef)
+JBC_CONST(kConstMethodRef, "ConstMethodRef", JBCConstRef)
+JBC_CONST(kConstInterfaceMethodRef, "ConstInterfaceMethodRef", JBCConstRef)
+JBC_CONST(kConstNameAndType, "ConstNameAndType", JBCConstNameAndType)
+JBC_CONST(kConstMethodHandleInfo, "ConstMethodHandleInfo", JBCConstMethodHandleInfo)
+JBC_CONST(kConstMethodType, "ConstMethodType", JBCConstMethodType)
+JBC_CONST(kConstInvokeDynamic, "ConstInvokeDynamic", JBCConstInvokeDynamic)
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_class_const.h b/src/hir2mpl/bytecode_input/class/include/jbc_class_const.h
new file mode 100644
index 0000000000000000000000000000000000000000..e15f6648e1ee93f0f5d8619f4b2d609a0e5e3a37
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_class_const.h
@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_CLASS_CONST_H
+#define HIR2MPL_INCLUDE_JBC_CLASS_CONST_H
+#include <map>
+#include <string>
+#include "mempool_allocator.h"
+#include "maple_string.h"
+#include "global_tables.h"
+#include "types_def.h"
+#include "simple_xml.h"
+#include "basic_io.h"
+#include "fe_struct_elem_info.h"
+#include "feir_type.h"
+
+namespace maple {
+namespace jbc {
+// Const Kind
+enum JBCConstTag : uint8 {
+  kConstUnknown = 0,
+  kConstUTF8 = 1,
+  kConstInteger = 3,
+  kConstFloat = 4,
+  kConstLong = 5,
+  kConstDouble = 6,
+  kConstClass = 7,
+  kConstString = 8,
+  kConstFieldRef = 9,
+  kConstMethodRef = 10,
+  kConstInterfaceMethodRef = 11,
+  kConstNameAndType = 12,
+  kConstMethodHandleInfo = 15,
+  kConstMethodType = 16,
+  kConstInvokeDynamic = 18,
+};
+
+enum JavaRefKind : uint8 {
+  kRefGetField = 1,
+  kRefGetStatic = 2,
+  kRefPutField = 3,
+  kRefPutStatic = 4,
+  kRefInvokeVirtual = 5,
+  kRefInvokeStatic = 6,
+  kRefInvokeSpecial = 7,
+  kRefNewInvokeSpecial = 8,
+  kRefInvokeInterface = 9,
+};
+
+class JBCConstTagName {
+ public:
+  JBCConstTagName() = default;
+  ~JBCConstTagName() = default;
+  static std::map<JBCConstTag, std::string> InitTagNameMap();
+  static std::string GetTagName(JBCConstTag tag);
+
+ private:
+  static std::map<JBCConstTag, std::string> tagNameMap;
+};
+
+class JBCConstPool;
+class JBCConst {
+ public:
+  JBCConst(MapleAllocator &allocIn, JBCConstTag t) : alloc(allocIn), tag(t) {}
+  virtual ~JBCConst() = default;
+  static JBCConst *InConst(MapleAllocator &alloc, BasicIORead &io);
+  static std::string InternalNameToFullName(const std::string &name);
+  static std::string FullNameToInternalName(const std::string &name);
+  JBCConstTag GetTag() const {
+    return tag;
+  }
+
+  bool IsWide() const {
+  return (tag == kConstLong || tag == kConstDouble);
+  }
+
+  bool IsValue() const {
+    return (tag == kConstInteger || tag == kConstLong || tag == kConstFloat || tag == kConstDouble);
+  }
+
+  bool IsValue4Byte() const {
+    return (tag == kConstInteger || tag == kConstFloat);
+  }
+
+  bool IsValue8Byte() const {
+    return (tag == kConstLong || tag == kConstDouble);
+  }
+
+  bool ParseFile(BasicIORead &io) {
+    return ParseFileImpl(io);
+  }
+
+  bool PreProcess(const JBCConstPool &constPool) {
+    return PreProcessImpl(constPool);
+  }
+
+  SimpleXMLElem *GenXMLElem(MapleAllocator &allocIn, uint32 id) const {
+    return GenXMLElemImpl(allocIn, id);
+  }
+
+ protected:
+  virtual bool ParseFileImpl(BasicIORead &io) = 0;
+  virtual bool PreProcessImpl(const JBCConstPool &constPool) = 0;
+  virtual SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const;
+  const std::string MapleStringToStd(const MapleString &mapleStr) const {
+    return mapleStr.length() == 0 ? "" : std::string(mapleStr.c_str());
+  }
+
+  MapleAllocator &alloc;
+  JBCConstTag tag;
+};
+
+using JBCConstPoolIdx = uint16;
+
+class JBCConstUTF8 : public JBCConst {
+ public:
+  JBCConstUTF8(MapleAllocator &alloc, JBCConstTag t);
+  JBCConstUTF8(MapleAllocator &alloc, JBCConstTag t, const std::string &argStr);
+  ~JBCConstUTF8() = default;
+
+  const std::string GetString() const {
+    return MapleStringToStd(str);
+  }
+
+  GStrIdx GetStrIdx() const {
+    return strIdx;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  uint16 length;
+  GStrIdx strIdx;
+  MapleString str;
+};
+
+class JBCConst4Byte : public JBCConst {
+ public:
+  JBCConst4Byte(MapleAllocator &alloc, JBCConstTag t);
+  JBCConst4Byte(MapleAllocator &alloc, JBCConstTag t, int32 arg);
+  JBCConst4Byte(MapleAllocator &alloc, JBCConstTag t, float arg);
+  ~JBCConst4Byte() = default;
+  int32 GetInt32() const {
+    return value.ivalue;
+  }
+
+  float GetFloat() const {
+    return value.fvalue;
+  }
+
+  uint32 GetRaw() const {
+    return value.raw;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  union {
+    int32 ivalue;
+    float fvalue;
+    uint32 raw;
+  } value;
+};
+
+class JBCConst8Byte : public JBCConst {
+ public:
+  JBCConst8Byte(MapleAllocator &alloc, JBCConstTag t);
+  JBCConst8Byte(MapleAllocator &alloc, JBCConstTag t, int64 arg);
+  JBCConst8Byte(MapleAllocator &alloc, JBCConstTag t, double arg);
+  ~JBCConst8Byte() = default;
+
+  int64 GetInt64() const {
+    return value.lvalue;
+  }
+
+  double GetDouble() const {
+    return value.dvalue;
+  }
+
+  uint64 GetRaw() const {
+    return value.raw;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  union {
+    int64 lvalue;
+    double dvalue;
+    uint64 raw;
+  } value;
+};
+
+class JBCConstClass : public JBCConst {
+ public:
+  JBCConstClass(MapleAllocator &alloc, JBCConstTag t);
+  JBCConstClass(MapleAllocator &alloc, JBCConstTag t, JBCConstPoolIdx argNameIdx);
+  ~JBCConstClass() override;
+
+  GStrIdx GetClassNameIdxOrin() const {
+    return strIdxOrin;
+  }
+
+  GStrIdx GetClassNameIdxMpl() const {
+    return strIdxMpl;
+  }
+
+  const std::string GetClassNameOrin() const {
+    return MapleStringToStd(nameOrin);
+  }
+
+  const std::string GetClassNameMpl() const {
+    return MapleStringToStd(nameMpl);
+  }
+
+  const FEIRType *GetFEIRType() const {
+    return feType;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  struct {
+    JBCConstPoolIdx nameIdx;
+  } rawData;
+  const JBCConstUTF8 *constUTF8;
+  GStrIdx strIdxOrin;
+  GStrIdx strIdxMpl;
+  MapleString nameOrin;
+  MapleString nameMpl;
+  FEIRType *feType = nullptr;
+};
+
+class JBCConstString : public JBCConst {
+ public:
+  JBCConstString(MapleAllocator &alloc, JBCConstTag t);
+  JBCConstString(MapleAllocator &alloc, JBCConstTag t, JBCConstPoolIdx argStringIdx);
+  ~JBCConstString() = default;
+  void SetValue(const GStrIdx &argStrIdx) {
+    strIdx = argStrIdx;
+    str = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+  }
+
+  GStrIdx GetStrIdx() const {
+    return strIdx;
+  }
+
+  const std::string GetString() const {
+    return MapleStringToStd(str);
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  struct {
+    JBCConstPoolIdx stringIdx;
+  } rawData;
+  GStrIdx strIdx;
+  MapleString str;
+};
+
+class JBCConstNameAndType : public JBCConst {
+ public:
+  JBCConstNameAndType(MapleAllocator &alloc, JBCConstTag t);
+  JBCConstNameAndType(MapleAllocator &alloc, JBCConstTag t, JBCConstPoolIdx argNameIdx, JBCConstPoolIdx argDescIdx);
+  ~JBCConstNameAndType() override;
+
+  const std::string GetName() const {
+    CHECK_FATAL(constName != nullptr, "invalid const index");
+    return constName->GetString();
+  }
+
+  const std::string GetDesc() const {
+    CHECK_FATAL(constDesc != nullptr, "invalid const index");
+    return constDesc->GetString();
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  struct {
+    JBCConstPoolIdx nameIdx;
+    JBCConstPoolIdx descIdx;
+  } rawData;
+  const JBCConstUTF8 *constName;
+  const JBCConstUTF8 *constDesc;
+};
+
+class JBCConstRef : public JBCConst {
+ public:
+  JBCConstRef(MapleAllocator &alloc, JBCConstTag t);
+  JBCConstRef(MapleAllocator &alloc, JBCConstTag t, JBCConstPoolIdx argClassIdx,
+              JBCConstPoolIdx argClassNameAndTypeIdx);
+  ~JBCConstRef() override;
+  bool PrepareFEStructElemInfo();
+  const std::string GetName() const;
+  const std::string GetDesc() const;
+
+  const JBCConstClass *GetConstClass() const {
+    return constClass;
+  }
+
+  FEStructElemInfo *GetFEStructElemInfo() const {
+    CHECK_NULL_FATAL(feStructElemInfo);
+    return feStructElemInfo;
+  }
+
+  const FEIRType *GetOwnerFEIRType() const {
+    CHECK_NULL_FATAL(constClass);
+    return constClass->GetFEIRType();
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  struct {
+    JBCConstPoolIdx classIdx;
+    JBCConstPoolIdx nameAndTypeIdx;
+  } rawData;
+  const JBCConstClass *constClass;
+  const JBCConstNameAndType *constNameAndType;
+  FEStructElemInfo *feStructElemInfo;
+};
+
+class JBCConstMethodHandleInfo : public JBCConst {
+ public:
+  JBCConstMethodHandleInfo(MapleAllocator &alloc, JBCConstTag t);
+  ~JBCConstMethodHandleInfo() override;
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  struct {
+    JBCConstPoolIdx refKind;
+    JBCConstPoolIdx refIdx;
+  } rawData;
+  const JBCConstRef *constRef;
+};
+
+class JBCConstMethodType : public JBCConst {
+ public:
+  JBCConstMethodType(MapleAllocator &alloc, JBCConstTag t);
+  ~JBCConstMethodType() override;
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  struct {
+    JBCConstPoolIdx descIdx;
+  } rawData;
+  const JBCConstUTF8 *constDesc;
+};
+
+class JBCConstInvokeDynamic : public JBCConst {
+ public:
+  JBCConstInvokeDynamic(MapleAllocator &alloc, JBCConstTag t);
+  ~JBCConstInvokeDynamic() override;
+  bool PrepareFEStructElemInfo(const std::string &ownerClassName);
+  JBCConstPoolIdx GetBSMAttrIdx() const {
+    return rawData.bsmAttrIdx;
+  }
+
+  const JBCConstNameAndType *GetConstNameAndType() const {
+    return constNameAndType;
+  }
+
+  FEStructElemInfo *GetFEStructElemInfo() const {
+    CHECK_NULL_FATAL(feStructElemInfo);
+    return feStructElemInfo;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  bool PreProcessImpl(const JBCConstPool &constPool) override;
+  SimpleXMLElem *GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const override;
+
+ private:
+  struct {
+    JBCConstPoolIdx bsmAttrIdx;
+    JBCConstPoolIdx nameAndTypeIdx;
+  } rawData;
+  const JBCConstNameAndType *constNameAndType;
+  FEStructElemInfo *feStructElemInfo;
+};
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_CLASS_CONST_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_class_const_pool.h b/src/hir2mpl/bytecode_input/class/include/jbc_class_const_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..0acdb08a6e2c2b8292631939b4f0204206626b66
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_class_const_pool.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_CLASS_CONST_POOL_H
+#define HIR2MPL_INCLUDE_JBC_CLASS_CONST_POOL_H
+#include "jbc_class_const.h"
+
+namespace maple {
+namespace jbc {
+class JBCConstPool {
+ public:
+  JBCConstPool(MapleAllocator &alloc);
+  ~JBCConstPool() = default;
+  uint16 InsertConst(JBCConst &objConst);
+  void InsertConstDummyForWide();
+
+  /*
+   * GetConstByIdx
+   * GetConstXXXByIdx
+   * If safe is true, the return value must be not nullptr or fatal and exit.
+   * If safe is false, the return value may be nullptr with error printed.
+   */
+  const JBCConst *GetConstByIdx(uint16 idx, bool safed = false) const;
+  const JBCConst *GetConstByIdxWithTag(uint16 idx, JBCConstTag tag, bool safed = false) const;
+  const JBCConst *GetConstValueByIdx(uint16 idx, bool safed = false) const;
+  const JBCConst *GetConstValue4ByteByIdx(uint16 idx, bool safed = false) const;
+  const JBCConst *GetConstValue8ByteByIdx(uint16 idx, bool safed = false) const;
+  std::string GetNameByClassInfoIdx(uint16 idx, bool safed = false) const;
+  bool PreProcess(uint16 argMajorVersion);
+  bool PrepareFEStructElemInfo(const std::string &ownerClassName);
+  JBCConstUTF8 *NewConstUTF8(uint16 &idx, const std::string &str);
+  JBCConst4Byte *NewConst4Byte(uint16 &idx, int32 value);
+  JBCConst4Byte *NewConst4Byte(uint16 &idx, float value);
+  JBCConst8Byte *NewConst8Byte(uint16 &idx, int64 value);
+  JBCConst8Byte *NewConst8Byte(uint16 &idx, double value);
+  JBCConstClass *NewConstClass(uint16 &idx, const std::string &className);
+  JBCConstString *NewConstString(uint16 &idx, const std::string &str);
+  JBCConstRef *NewConstRef(uint16 &idx, JBCConstTag tag, const std::string &className, const std::string &name,
+                           const std::string &desc);
+  JBCConstNameAndType *NewConstNameAndType(uint16 &idx,  const std::string &name, const std::string &desc);
+
+  uint16 GetMajorVersion() const {
+    return majorVersion;
+  }
+
+  std::string GetStringByConstUTF8(uint16 idx, bool safed = false) const {
+    const JBCConst *constUTF8 = GetConstByIdxWithTag(idx, JBCConstTag::kConstUTF8, safed);
+    return constUTF8 == nullptr ? "" : static_cast<const JBCConstUTF8*>(constUTF8)->GetString();
+  }
+
+ private:
+  MapleAllocator &allocator;
+  MapleVector<JBCConst*> pool;
+  uint16 majorVersion;
+};
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_CLASS_CONST_POOL_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_class_header.h b/src/hir2mpl/bytecode_input/class/include/jbc_class_header.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2605537ca5c43af54fc665c4714d87cfee631fd
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_class_header.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_CLASS_HEADER_H
+#define HIR2MPL_INCLUDE_JBC_CLASS_HEADER_H
+#include "types_def.h"
+#include "basic_io.h"
+
+namespace maple {
+namespace jbc {
+class JBCClassHeader {
+ public:
+  JBCClassHeader();
+  ~JBCClassHeader() = default;
+  bool ParseClassFile(BasicIORead &io) const;
+
+ private:
+  uint32 magic;
+  uint16 minorVersion;
+  uint16 majorVersion;
+  uint16 constPoolCount;
+  uint16 accessFlag;
+  uint16 thisClass;
+  uint16 superClass;
+  uint16 interfacesCount;
+  uint16 fieldsCount;
+  uint16 methodsCount;
+  uint16 attrsCount;
+};
+}  // namespace jbc
+}  // namespace maple
+#endif
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_compiler_component.h b/src/hir2mpl/bytecode_input/class/include/jbc_compiler_component.h
new file mode 100644
index 0000000000000000000000000000000000000000..bf8ea0f203e48205b9374c1b913a9c5dac1801af
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_compiler_component.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_COMPILER_COMPONENT_H
+#define HIR2MPL_INCLUDE_JBC_COMPILER_COMPONENT_H
+#include "fe_macros.h"
+#include "hir2mpl_compiler_component.h"
+#include "jbc_input.h"
+#include "fe_function_phase_result.h"
+
+namespace maple {
+class JBCCompilerComponent : public HIR2MPLCompilerComponent {
+ public:
+  JBCCompilerComponent(MIRModule &module);
+  ~JBCCompilerComponent() override;
+
+ protected:
+  bool ParseInputImpl() override;
+  bool LoadOnDemandTypeImpl() override;
+  void ProcessPragmaImpl() override;
+  std::unique_ptr<FEFunction> CreatFEFunctionImpl(FEInputMethodHelper *methodHelper) override;
+  std::string GetComponentNameImpl() const override;
+  bool ParallelableImpl() const override;
+  void DumpPhaseTimeTotalImpl() const override;
+  void ReleaseMemPoolImpl() override;
+
+ private:
+  MemPool *mp;
+  MapleAllocator allocator;
+  jbc::JBCInput jbcInput;
+};  // class JBCCompilerComponent
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_COMPILER_COMPONENT_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_function.h b/src/hir2mpl/bytecode_input/class/include/jbc_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f86e8c492c8efcc8ac25e79d62befe35b07f73c
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_function.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_JBC_FUNCTION_H
+#define HIR2MPL_INCLUDE_COMMON_JBC_FUNCTION_H
+#include <map>
+#include <vector>
+#include <set>
+#include <deque>
+#include <tuple>
+#include "fe_configs.h"
+#include "fe_function.h"
+#include "jbc_class.h"
+#include "jbc_attr.h"
+#include "jbc_stmt.h"
+#include "jbc_bb.h"
+#include "jbc_class2fe_helper.h"
+#include "jbc_stack2fe_helper.h"
+#include "jbc_function_context.h"
+
+namespace maple {
+class JBCBBPesudoCatchPred : public FEIRBB {
+ public:
+  static const uint8 kBBKindPesudoCatchPred = FEIRBBKind::kBBKindExt + 1;
+  JBCBBPesudoCatchPred()
+      : FEIRBB(kBBKindPesudoCatchPred) {}
+  ~JBCBBPesudoCatchPred() override = default;
+};  // class JBCBBPesudoCatchPred
+
+class JBCFunction : public FEFunction {
+ public:
+  JBCFunction(const JBCClassMethod2FEHelper &argMethodHelper, MIRFunction &mirFunc,
+              const std::unique_ptr<FEFunctionPhaseResult> &argPhaseResultTotal);
+  ~JBCFunction();
+
+ LLT_PROTECTED:
+  // run phase routines
+  bool GenerateGeneralStmt(const std::string &phaseName) override;
+  bool LabelLabelIdx(const std::string &phaseName);
+  bool CheckJVMStack(const std::string &phaseName);
+  bool GenerateArgVarList(const std::string &phaseName) override;
+  bool GenerateAliasVars(const std::string &phaseName) override;
+  bool ProcessFunctionArgs(const std::string &phaseName);
+  bool EmitLocalVarInfo(const std::string &phaseName);
+  bool EmitToFEIRStmt(const std::string &phaseName) override;
+
+  // interface implement
+  void InitImpl() override;
+  void PreProcessImpl() override;
+  bool ProcessImpl() override;
+  void FinishImpl() override;
+  bool PreProcessTypeNameIdx() override;
+  void GenerateGeneralStmtFailCallBack() override;
+  void GenerateGeneralDebugInfo() override;
+  bool VerifyGeneral() override;
+  void VerifyGeneralFailCallBack() override;
+  std::string GetGeneralFuncName() const override;
+
+  bool HasThis() override {
+    return methodHelper.HasThis();
+  }
+
+  bool IsNative() override {
+    return methodHelper.IsNative();
+  }
+
+  void EmitToFEIRStmt(const JBCBB &bb);
+
+ LLT_PRIVATE:
+  const JBCClassMethod2FEHelper &methodHelper;
+  const jbc::JBCClassMethod &method;
+  JBCStack2FEHelper stack2feHelper;
+  JBCFunctionContext context;
+  bool error = false;
+  FEIRBB *pesudoBBCatchPred = nullptr;
+
+  bool PreBuildJsrInfo(const jbc::JBCAttrCode &code);
+  bool BuildStmtFromInstruction(const jbc::JBCAttrCode &code);
+  FEIRStmt *BuildStmtFromInstructionForBranch(const jbc::JBCOp &op);
+  FEIRStmt *BuildStmtFromInstructionForGoto(const jbc::JBCOp &op);
+  FEIRStmt *BuildStmtFromInstructionForSwitch(const jbc::JBCOp &op);
+  FEIRStmt *BuildStmtFromInstructionForJsr(const jbc::JBCOp &op);
+  FEIRStmt *BuildStmtFromInstructionForRet(const jbc::JBCOp &op);
+  void BuildStmtForCatch(const jbc::JBCAttrCode &code);
+  void BuildStmtForTry(const jbc::JBCAttrCode &code);
+  void BuildTryInfo(const std::map<std::pair<uint32, uint32>, std::vector<uint32>> &rawInfo,
+                    std::map<uint32, uint32> &outMapStartEnd,
+                    std::map<uint32, std::vector<uint32>> &outMapStartCatch);
+  void BuildTryInfoCatch(const std::map<std::pair<uint32, uint32>, std::vector<uint32>> &rawInfo,
+                         const std::deque<std::pair<uint32, uint32>> &blockQueue,
+                         uint32 startPos,
+                         std::map<uint32, std::vector<uint32>> &outMapStartCatch);
+  void BuildStmtForLOC(const jbc::JBCAttrCode &code);
+  void BuildStmtForInstComment(const jbc::JBCAttrCode &code);
+  FEIRStmt *BuildAndUpdateLabel(uint32 dstPC, const std::unique_ptr<FEIRStmt> &srcStmt);
+  void ArrangeStmts();
+  bool CheckJVMStackResult();
+  void InitStack2FEHelper();
+  uint32 CalculateMaxSwapSize() const;
+  bool NeedConvertToInt32(const std::unique_ptr<FEIRVar> &var);
+};  // class JBCFunction
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_JBC_FUNCTION_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_function_context.h b/src/hir2mpl/bytecode_input/class/include/jbc_function_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..01ec6454e850c09cc861fb58cdc9cc35041a9d09
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_function_context.h
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_INPUT_JBC_FUNCTION_CONTEXT_H
+#define HIR2MPL_INCLUDE_JBC_INPUT_JBC_FUNCTION_CONTEXT_H
+#include "mir_type.h"
+#include "jbc_class_const_pool.h"
+#include "jbc_attr.h"
+#include "jbc_stack2fe_helper.h"
+#include "jbc_stmt.h"
+
+namespace maple {
+class JBCFunctionContext {
+ public:
+  JBCFunctionContext(const jbc::JBCConstPool &argConstPool,
+                     JBCStack2FEHelper &argStack2feHelper,
+                     const jbc::JBCAttrCode *argCode)
+      : constPool(argConstPool),
+        stack2feHelper(argStack2feHelper),
+        code(argCode) {}
+
+  ~JBCFunctionContext() {
+    code = nullptr;
+  }
+
+  int32 RegisterJsrSlotRetAddr(uint16 slotIdx, uint32 nextPC);
+  void ArrangeStmts();
+  const FEIRType *GetSlotType(uint16 slotIdx, uint32 pc) const;
+  const FEIRType *GetSlotType(uint16 slotIdx) const;
+
+  JBCStack2FEHelper &GetStack2FEHelper() {
+    return stack2feHelper;
+  }
+
+  const jbc::JBCConstPool &GetConstPool() const {
+    return constPool;
+  }
+
+  const jbc::JBCAttrCode *GetCode() const {
+    return code;
+  }
+
+  const std::map<uint32, FEIRStmt*> &GetMapPCStmtInst() const {
+    return mapPCStmtInst;
+  }
+
+  const std::map<uint32, JBCStmtPesudoTry*> &GetMapPCTryStmt() const {
+    return mapPCTryStmt;
+  }
+
+  const std::map<uint32, JBCStmtPesudoEndTry*> &GetMapPCEndTryStmt() const {
+    return mapPCEndTryStmt;
+  }
+
+  const std::map<uint32, JBCStmtPesudoCatch*> &GetMapPCCatchStmt() const {
+    return mapPCCatchStmt;
+  }
+
+  const std::map<uint32, JBCStmtPesudoLabel*> &GetMapPCLabelStmt() const {
+    return mapPCLabelStmt;
+  }
+
+  const std::map<uint32, JBCStmtPesudoLOC*> &GetMapPCStmtLOC() const {
+    return mapPCStmtLOC;
+  }
+
+  const std::map<uint32, JBCStmtPesudoComment*> &GetMapPCCommentStmt() const {
+    return mapPCCommentStmt;
+  }
+
+  const std::map<uint16, std::map<int32, uint32>> &GetMapJsrSlotRetAddr() const {
+    return mapJsrSlotRetAddr;
+  }
+
+  void UpdateMapPCStmtInst(uint32 pc, FEIRStmt *stmt) {
+    mapPCStmtInst[pc] = stmt;
+  }
+
+  void UpdateMapPCTryStmt(uint32 pc, JBCStmtPesudoTry *stmt) {
+    mapPCTryStmt[pc] = stmt;
+  }
+
+  void UpdateMapPCEndTryStmt(uint32 pc, JBCStmtPesudoEndTry *stmt) {
+    mapPCEndTryStmt[pc] = stmt;
+  }
+
+  void UpdateMapPCCatchStmt(uint32 pc, JBCStmtPesudoCatch *stmt) {
+    mapPCCatchStmt[pc] = stmt;
+  }
+
+  void UpdateMapPCLabelStmt(uint32 pc, JBCStmtPesudoLabel *stmt) {
+    mapPCLabelStmt[pc] = stmt;
+  }
+
+  void UpdateMapPCStmtLOC(uint32 pc, JBCStmtPesudoLOC *stmt) {
+    mapPCStmtLOC[pc] = stmt;
+  }
+
+  void UpdateMapPCCommentStmt(uint32 pc, JBCStmtPesudoComment *stmt) {
+    mapPCCommentStmt[pc] = stmt;
+  }
+
+  const jbc::JBCAttrLocalVariableInfo &GetLocalVarInfo() const {
+    CHECK_NULL_FATAL(code);
+    return code->GetLocalVarInfo();
+  }
+
+  void SetCurrPC(uint32 pc) {
+    currPC = pc;
+  }
+
+  uint32 GetCurrPC() const {
+    return currPC;
+  }
+
+ private:
+  const jbc::JBCConstPool &constPool;
+  JBCStack2FEHelper &stack2feHelper;
+  const jbc::JBCAttrCode *code;
+  std::map<uint32, FEIRStmt*> mapPCStmtInst;
+  std::map<uint32, JBCStmtPesudoTry*> mapPCTryStmt;  // key: tryStartPC, value: stmt
+  std::map<uint32, JBCStmtPesudoEndTry*> mapPCEndTryStmt;  // key: tryEndPC, value: stmt
+  std::map<uint32, JBCStmtPesudoCatch*> mapPCCatchStmt;  // key: handlePC, value: stmt
+  std::map<uint32, JBCStmtPesudoLabel*> mapPCLabelStmt;  // key: labelPC, value: stmt
+  std::map<uint32, JBCStmtPesudoLOC*> mapPCStmtLOC; // key: locPC, value: stmt
+  std::map<uint32, JBCStmtPesudoComment*> mapPCCommentStmt; // key: commentPC, value: stmt
+  std::map<uint16, std::map<int32, uint32>> mapJsrSlotRetAddr;  // key: slotIdx, value: map<jsrID, retAddr>
+  uint32 currPC = 0;
+};  // class JBCFunctionContext
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_INPUT_JBC_FUNCTION_CONTEXT_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_input.h b/src/hir2mpl/bytecode_input/class/include/jbc_input.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce211d00c68451bdf9d2c5338be491c964418f37
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_input.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_INPUT_H
+#define HIR2MPL_INCLUDE_JBC_INPUT_H
+#include <string>
+#include <list>
+#include "mempool_allocator.h"
+#include "jbc_class.h"
+
+namespace maple {
+namespace jbc {
+class JBCInput {
+ public:
+  explicit JBCInput(MIRModule &moduleIn);
+  ~JBCInput();
+  void ReleaseMemPool();
+  bool ReadClassFile(const std::string &fileName);
+  bool ReadClassFiles(const std::list<std::string> &fileNames);
+  bool ReadJarFile(const std::string &fileName);
+  bool ReadJarFiles(const std::list<std::string> &fileNames);
+  const JBCClass *GetFirstClass();
+  const JBCClass *GetNextClass();
+  void RegisterSrcFileInfo(JBCClass &klass);
+
+  const MIRModule &GetModule() const {
+    return module;
+  }
+
+ protected:
+  MIRModule &module;
+  MemPool *mp;
+  MapleAllocator allocator;
+  MapleList<JBCClass*> klassList;
+
+ private:
+  MapleList<JBCClass*>::const_iterator itKlass;
+};
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_INPUT_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_opcode.def b/src/hir2mpl/bytecode_input/class/include/jbc_opcode.def
new file mode 100644
index 0000000000000000000000000000000000000000..ede7d7eb28cd409b1e2d44dfb52a4fa5e63e2e11
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_opcode.def
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// JBC_OP(opcode, value, type, name, flags)
+JBC_OP(Nop, 0x00, Default, "nop", (kOpFlagFallThru))
+JBC_OP(AConstNull, 0x01, Const, "aconst_null", (kOpFlagFallThru))
+JBC_OP(IConstM1, 0x02, Const, "iconst_m1", (kOpFlagFallThru))
+JBC_OP(IConst0, 0x03, Const, "iconst_0", (kOpFlagFallThru))
+JBC_OP(IConst1, 0x04, Const, "iconst_1", (kOpFlagFallThru))
+JBC_OP(IConst2, 0x05, Const, "iconst_2", (kOpFlagFallThru))
+JBC_OP(IConst3, 0x06, Const, "iconst_3", (kOpFlagFallThru))
+JBC_OP(IConst4, 0x07, Const, "iconst_4", (kOpFlagFallThru))
+JBC_OP(IConst5, 0x08, Const, "iconst_5", (kOpFlagFallThru))
+JBC_OP(LConst0, 0x09, Const, "lconst_0", (kOpFlagFallThru))
+JBC_OP(LConst1, 0x0A, Const, "lconst_1", (kOpFlagFallThru))
+JBC_OP(FConst0, 0x0B, Const, "fconst_0", (kOpFlagFallThru))
+JBC_OP(FConst1, 0x0C, Const, "fconst_1", (kOpFlagFallThru))
+JBC_OP(FConst2, 0x0D, Const, "fconst_2", (kOpFlagFallThru))
+JBC_OP(DConst0, 0x0E, Const, "dconst_0", (kOpFlagFallThru))
+JBC_OP(DConst1, 0x0F, Const, "dconst_1", (kOpFlagFallThru))
+JBC_OP(BiPush, 0x10, Const, "bipush", (kOpFlagFallThru))
+JBC_OP(SiPush, 0x11, Const, "sipush", (kOpFlagFallThru))
+JBC_OP(Ldc, 0x12, Const, "ldc", (kOpFlagFallThru))
+JBC_OP(LdcW, 0x13, Const, "ldc_w", (kOpFlagFallThru))
+JBC_OP(Ldc2W, 0x14, Const, "ldc2_w", (kOpFlagFallThru))
+JBC_OP(ILoad, 0x15, Load, "iload", (kOpFlagFallThru))
+JBC_OP(LLoad, 0x16, Load, "lload", (kOpFlagFallThru))
+JBC_OP(FLoad, 0x17, Load, "fload", (kOpFlagFallThru))
+JBC_OP(DLoad, 0x18, Load, "dload", (kOpFlagFallThru))
+JBC_OP(ALoad, 0x19, Load, "aload", (kOpFlagFallThru))
+JBC_OP(ILoad0, 0x1A, Load, "iload_0", (kOpFlagFallThru))
+JBC_OP(ILoad1, 0x1B, Load, "iload_1", (kOpFlagFallThru))
+JBC_OP(ILoad2, 0x1C, Load, "iload_2", (kOpFlagFallThru))
+JBC_OP(ILoad3, 0x1D, Load, "iload_3", (kOpFlagFallThru))
+JBC_OP(LLoad0, 0x1E, Load, "lload_0", (kOpFlagFallThru))
+JBC_OP(LLoad1, 0x1F, Load, "lload_1", (kOpFlagFallThru))
+JBC_OP(LLoad2, 0x20, Load, "lload_2", (kOpFlagFallThru))
+JBC_OP(LLoad3, 0x21, Load, "lload_3", (kOpFlagFallThru))
+JBC_OP(FLoad0, 0x22, Load, "fload_0", (kOpFlagFallThru))
+JBC_OP(FLoad1, 0x23, Load, "fload_1", (kOpFlagFallThru))
+JBC_OP(FLoad2, 0x24, Load, "fload_2", (kOpFlagFallThru))
+JBC_OP(FLoad3, 0x25, Load, "fload_3", (kOpFlagFallThru))
+JBC_OP(DLoad0, 0x26, Load, "dload_0", (kOpFlagFallThru))
+JBC_OP(DLoad1, 0x27, Load, "dload_1", (kOpFlagFallThru))
+JBC_OP(DLoad2, 0x28, Load, "dload_2", (kOpFlagFallThru))
+JBC_OP(DLoad3, 0x29, Load, "dload_3", (kOpFlagFallThru))
+JBC_OP(ALoad0, 0x2A, Load, "aload_0", (kOpFlagFallThru))
+JBC_OP(ALoad1, 0x2B, Load, "aload_1", (kOpFlagFallThru))
+JBC_OP(ALoad2, 0x2C, Load, "aload_2", (kOpFlagFallThru))
+JBC_OP(ALoad3, 0x2D, Load, "aload_3", (kOpFlagFallThru))
+JBC_OP(IALoad, 0x2E, ArrayLoad, "iaload", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(LALoad, 0x2F, ArrayLoad, "laload", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(FALoad, 0x30, ArrayLoad, "faload", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(DALoad, 0x31, ArrayLoad, "daload", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(AALoad, 0x32, ArrayLoad, "aaload", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(BALoad, 0x33, ArrayLoad, "baload", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(CALoad, 0x34, ArrayLoad, "caload", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(SALoad, 0x35, ArrayLoad, "saload", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(IStore, 0x36, Store, "istore", (kOpFlagFallThru))
+JBC_OP(LStore, 0x37, Store, "lstore", (kOpFlagFallThru))
+JBC_OP(FStore, 0x38, Store, "fstore", (kOpFlagFallThru))
+JBC_OP(DStore, 0x39, Store, "dstore", (kOpFlagFallThru))
+JBC_OP(AStore, 0x3A, Store, "astore", (kOpFlagFallThru))
+JBC_OP(IStore0, 0x3B, Store, "istore_0", (kOpFlagFallThru))
+JBC_OP(IStore1, 0x3C, Store, "istore_1", (kOpFlagFallThru))
+JBC_OP(IStore2, 0x3D, Store, "istore_2", (kOpFlagFallThru))
+JBC_OP(IStore3, 0x3E, Store, "istore_3", (kOpFlagFallThru))
+JBC_OP(LStore0, 0x3F, Store, "lstore_0", (kOpFlagFallThru))
+JBC_OP(LStore1, 0x40, Store, "lstore_1", (kOpFlagFallThru))
+JBC_OP(LStore2, 0x41, Store, "lstore_2", (kOpFlagFallThru))
+JBC_OP(LStore3, 0x42, Store, "lstore_3", (kOpFlagFallThru))
+JBC_OP(FStore0, 0x43, Store, "fstore_0", (kOpFlagFallThru))
+JBC_OP(FStore1, 0x44, Store, "fstore_1", (kOpFlagFallThru))
+JBC_OP(FStore2, 0x45, Store, "fstore_2", (kOpFlagFallThru))
+JBC_OP(FStore3, 0x46, Store, "fstore_3", (kOpFlagFallThru))
+JBC_OP(DStore0, 0x47, Store, "dstore_0", (kOpFlagFallThru))
+JBC_OP(DStore1, 0x48, Store, "dstore_1", (kOpFlagFallThru))
+JBC_OP(DStore2, 0x49, Store, "dstore_2", (kOpFlagFallThru))
+JBC_OP(DStore3, 0x4A, Store, "dstore_3", (kOpFlagFallThru))
+JBC_OP(AStore0, 0x4B, Store, "astore_0", (kOpFlagFallThru))
+JBC_OP(AStore1, 0x4C, Store, "astore_1", (kOpFlagFallThru))
+JBC_OP(AStore2, 0x4D, Store, "astore_2", (kOpFlagFallThru))
+JBC_OP(AStore3, 0x4E, Store, "astore_3", (kOpFlagFallThru))
+JBC_OP(IAStore, 0x4F, ArrayStore, "iastore", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(LAStore, 0x50, ArrayStore, "lastore", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(FAStore, 0x51, ArrayStore, "fastore", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(DAStore, 0x52, ArrayStore, "dastore", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(AAStore, 0x53, ArrayStore, "aastore", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(BAStore, 0x54, ArrayStore, "bastore", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(CAStore, 0x55, ArrayStore, "castore", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(SAStore, 0x56, ArrayStore, "sastore", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(Pop, 0x57, Pop, "pop", (kOpFlagFallThru))
+JBC_OP(Pop2, 0x58, Pop, "pop2", (kOpFlagFallThru))
+JBC_OP(Dup, 0x59, Dup, "dup", (kOpFlagFallThru))
+JBC_OP(DupX1, 0x5A, Dup, "dup_x1", (kOpFlagFallThru))
+JBC_OP(DupX2, 0x5B, Dup, "dup_x2", (kOpFlagFallThru))
+JBC_OP(Dup2, 0x5C, Dup, "dup2", (kOpFlagFallThru))
+JBC_OP(Dup2X1, 0x5D, Dup, "dup2_x1", (kOpFlagFallThru))
+JBC_OP(Dup2X2, 0x5E, Dup, "dup2_x2", (kOpFlagFallThru))
+JBC_OP(Swap, 0x5F, Swap, "swap", (kOpFlagFallThru))
+JBC_OP(IAdd, 0x60, MathBinop, "iadd", (kOpFlagFallThru))
+JBC_OP(LAdd, 0x61, MathBinop, "ladd", (kOpFlagFallThru))
+JBC_OP(FAdd, 0x62, MathBinop, "fadd", (kOpFlagFallThru))
+JBC_OP(DAdd, 0x63, MathBinop, "dadd", (kOpFlagFallThru))
+JBC_OP(ISub, 0x64, MathBinop, "isub", (kOpFlagFallThru))
+JBC_OP(LSub, 0x65, MathBinop, "lsub", (kOpFlagFallThru))
+JBC_OP(FSub, 0x66, MathBinop, "fsub", (kOpFlagFallThru))
+JBC_OP(DSub, 0x67, MathBinop, "dsub", (kOpFlagFallThru))
+JBC_OP(IMul, 0x68, MathBinop, "imul", (kOpFlagFallThru))
+JBC_OP(LMul, 0x69, MathBinop, "lmul", (kOpFlagFallThru))
+JBC_OP(FMul, 0x6A, MathBinop, "fmul", (kOpFlagFallThru))
+JBC_OP(DMul, 0x6B, MathBinop, "dmul", (kOpFlagFallThru))
+JBC_OP(IDiv, 0x6C, MathBinop, "idiv", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(LDiv, 0x6D, MathBinop, "ldiv", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(FDiv, 0x6E, MathBinop, "fdiv", (kOpFlagFallThru))
+JBC_OP(DDiv, 0x6F, MathBinop, "ddiv", (kOpFlagFallThru))
+JBC_OP(IRem, 0x70, MathBinop, "irem", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(LRem, 0x71, MathBinop, "lrem", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(FRem, 0x72, MathBinop, "frem", (kOpFlagFallThru))
+JBC_OP(DRem, 0x73, MathBinop, "drem", (kOpFlagFallThru))
+JBC_OP(INeg, 0x74, MathUnop, "ineg", (kOpFlagFallThru))
+JBC_OP(LNeg, 0x75, MathUnop, "lneg", (kOpFlagFallThru))
+JBC_OP(FNeg, 0x76, MathUnop, "fneg", (kOpFlagFallThru))
+JBC_OP(DNeg, 0x77, MathUnop, "dneg", (kOpFlagFallThru))
+JBC_OP(IShl, 0x78, MathBinop, "ishl", (kOpFlagFallThru))
+JBC_OP(LShl, 0x79, MathBinop, "lshl", (kOpFlagFallThru))
+JBC_OP(IShr, 0x7A, MathBinop, "ishr", (kOpFlagFallThru))
+JBC_OP(LShr, 0x7B, MathBinop, "lshr", (kOpFlagFallThru))
+JBC_OP(IUShr, 0x7C, MathBinop, "iushr", (kOpFlagFallThru))
+JBC_OP(LUShr, 0x7D, MathBinop, "lushr", (kOpFlagFallThru))
+JBC_OP(IAnd, 0x7E, MathBinop, "iand", (kOpFlagFallThru))
+JBC_OP(LAnd, 0x7F, MathBinop, "land", (kOpFlagFallThru))
+JBC_OP(IOr, 0x80, MathBinop, "ior", (kOpFlagFallThru))
+JBC_OP(LOr, 0x81, MathBinop, "lor", (kOpFlagFallThru))
+JBC_OP(IXor, 0x82, MathBinop, "ixor", (kOpFlagFallThru))
+JBC_OP(LXor, 0x83, MathBinop, "lxor", (kOpFlagFallThru))
+JBC_OP(IInc, 0x84, MathInc, "iinc", (kOpFlagFallThru))
+JBC_OP(I2L, 0x85, Convert, "i2l", (kOpFlagFallThru))
+JBC_OP(I2F, 0x86, Convert, "i2f", (kOpFlagFallThru))
+JBC_OP(I2D, 0x87, Convert, "i2d", (kOpFlagFallThru))
+JBC_OP(L2I, 0x88, Convert, "l2i", (kOpFlagFallThru))
+JBC_OP(L2F, 0x89, Convert, "l2f", (kOpFlagFallThru))
+JBC_OP(L2D, 0x8A, Convert, "l2d", (kOpFlagFallThru))
+JBC_OP(F2I, 0x8B, Convert, "f2i", (kOpFlagFallThru))
+JBC_OP(F2L, 0x8C, Convert, "f2l", (kOpFlagFallThru))
+JBC_OP(F2D, 0x8D, Convert, "f2d", (kOpFlagFallThru))
+JBC_OP(D2I, 0x8E, Convert, "d2i", (kOpFlagFallThru))
+JBC_OP(D2L, 0x8F, Convert, "d2l", (kOpFlagFallThru))
+JBC_OP(D2F, 0x90, Convert, "d2f", (kOpFlagFallThru))
+JBC_OP(I2B, 0x91, Convert, "i2b", (kOpFlagFallThru))
+JBC_OP(I2C, 0x92, Convert, "i2c", (kOpFlagFallThru))
+JBC_OP(I2S, 0x93, Convert, "i2s", (kOpFlagFallThru))
+JBC_OP(LCmp, 0x94, Compare, "lcmp", (kOpFlagFallThru))
+JBC_OP(FCmpl, 0x95, Compare, "fcmpl", (kOpFlagFallThru))
+JBC_OP(FCmpg, 0x96, Compare, "fcmpg", (kOpFlagFallThru))
+JBC_OP(DCmpl, 0x97, Compare, "dcmpl", (kOpFlagFallThru))
+JBC_OP(DCmpg, 0x98, Compare, "dcmpg", (kOpFlagFallThru))
+JBC_OP(Ifeq, 0x99, Branch, "ifeq", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(Ifne, 0x9A, Branch, "ifne", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(Iflt, 0x9B, Branch, "iflt", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(Ifge, 0x9C, Branch, "ifge", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(Ifgt, 0x9D, Branch, "ifgt", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(Ifle, 0x9E, Branch, "ifle", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(IfICmpeq, 0x9F, Branch, "if_icmpeq", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(IfICmpne, 0xA0, Branch, "if_icmpne", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(IfICmplt, 0xA1, Branch, "if_icmplt", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(IfICmpge, 0xA2, Branch, "if_icmpge", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(IfICmpgt, 0xA3, Branch, "if_icmpgt", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(IfICmple, 0xA4, Branch, "if_icmple", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(IfACmpeq, 0xA5, Branch, "if_acmpeq", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(IfACmpne, 0xA6, Branch, "if_acmpne", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(Goto, 0xA7, Goto, "goto", (kOpFlagBranch))
+JBC_OP(Jsr, 0xA8, Jsr, "jsr", (kOpFlagBranch))
+JBC_OP(Ret, 0xA9, Ret, "ret", (kOpFlagBranch))
+JBC_OP(TableSwitch, 0xAA, Switch, "tableswitch", (kOpFlagBranch))
+JBC_OP(LookupSwitch, 0xAB, Switch, "lookupswitch", (kOpFlagBranch))
+JBC_OP(IReturn, 0xAC, Return, "ireturn", (kOpFlagThrowable))
+JBC_OP(LReturn, 0xAD, Return, "lreturn", (kOpFlagThrowable))
+JBC_OP(FReturn, 0xAE, Return, "freturn", (kOpFlagThrowable))
+JBC_OP(DReturn, 0xAF, Return, "dreturn", (kOpFlagThrowable))
+JBC_OP(AReturn, 0xB0, Return, "areturn", (kOpFlagThrowable))
+JBC_OP(Return, 0xB1, Return, "return", (kOpFlagThrowable))
+JBC_OP(GetStatic, 0xB2, StaticFieldOpr, "getstatic", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(PutStatic, 0xB3, StaticFieldOpr, "putstatic", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(GetField, 0xB4, FieldOpr, "getfield", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(PutField, 0xB5, FieldOpr, "putfield", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(InvokeVirtual, 0xB6, Invoke, "invokevirtual", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(InvokeSpecial, 0xB7, Invoke, "invokespecial", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(InvokeStatic, 0xB8, Invoke, "invokestatic", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(InvokeInterface, 0xB9, Invoke, "invokeinterface", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(InvokeDynamic, 0xBA, Invoke, "invokedynamic", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(New, 0xBB, New, "new", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(NewArray, 0xBC, New, "newarray", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(ANewArray, 0xBD, New, "anewarray", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(ArrayLength, 0xBE, ArrayLength, "arraylength", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(AThrow, 0xBF, Throw, "athrow", (kOpFlagThrowable))
+JBC_OP(CheckCast, 0xC0, TypeCheck, "checkcast", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(InstanceOf, 0xC1, TypeCheck, "instanceof", (kOpFlagFallThru))
+JBC_OP(MonitorEnter, 0xC2, Monitor, "monitorenter", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(MonitorExit, 0xC3, Monitor, "monitorexit", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(Wide, 0xC4, Default, "wide", (kOpFlagFallThru))
+JBC_OP(MultiANewArray, 0xC5, MultiANewArray, "multianewarray", (kOpFlagFallThru | kOpFlagThrowable))
+JBC_OP(IfNull, 0xC6, Branch, "ifnull", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(IfNonNull, 0xC7, Branch, "ifnonnull", (kOpFlagFallThru | kOpFlagBranch))
+JBC_OP(GotoW, 0xC8, Goto, "goto_w", (kOpFlagBranch))
+JBC_OP(JsrW, 0xC9, Jsr, "jsr_w", (kOpFlagBranch))
+JBC_OP(BreakPoint, 0xCA, Reversed, "breakpoint", (kOpFlagFallThru))
+JBC_OP(UnusedCB, 0xCB, Unused, "unused_cb", (kOpFlagFallThru))
+JBC_OP(UnusedCC, 0xCC, Unused, "unused_cc", (kOpFlagFallThru))
+JBC_OP(UnusedCD, 0xCD, Unused, "unused_cd", (kOpFlagFallThru))
+JBC_OP(UnusedCE, 0xCE, Unused, "unused_ce", (kOpFlagFallThru))
+JBC_OP(UnusedCF, 0xCF, Unused, "unused_cf", (kOpFlagFallThru))
+JBC_OP(UnusedD0, 0xD0, Unused, "unused_d0", (kOpFlagFallThru))
+JBC_OP(UnusedD1, 0xD1, Unused, "unused_d1", (kOpFlagFallThru))
+JBC_OP(UnusedD2, 0xD2, Unused, "unused_d2", (kOpFlagFallThru))
+JBC_OP(UnusedD3, 0xD3, Unused, "unused_d3", (kOpFlagFallThru))
+JBC_OP(UnusedD4, 0xD4, Unused, "unused_d4", (kOpFlagFallThru))
+JBC_OP(UnusedD5, 0xD5, Unused, "unused_d5", (kOpFlagFallThru))
+JBC_OP(UnusedD6, 0xD6, Unused, "unused_d6", (kOpFlagFallThru))
+JBC_OP(UnusedD7, 0xD7, Unused, "unused_d7", (kOpFlagFallThru))
+JBC_OP(UnusedD8, 0xD8, Unused, "unused_d8", (kOpFlagFallThru))
+JBC_OP(UnusedD9, 0xD9, Unused, "unused_d9", (kOpFlagFallThru))
+JBC_OP(UnusedDA, 0xDA, Unused, "unused_da", (kOpFlagFallThru))
+JBC_OP(UnusedDB, 0xDB, Unused, "unused_db", (kOpFlagFallThru))
+JBC_OP(UnusedDC, 0xDC, Unused, "unused_dc", (kOpFlagFallThru))
+JBC_OP(UnusedDD, 0xDD, Unused, "unused_dd", (kOpFlagFallThru))
+JBC_OP(UnusedDE, 0xDE, Unused, "unused_de", (kOpFlagFallThru))
+JBC_OP(UnusedDF, 0xDF, Unused, "unused_df", (kOpFlagFallThru))
+JBC_OP(UnusedE0, 0xE0, Unused, "unused_e0", (kOpFlagFallThru))
+JBC_OP(UnusedE1, 0xE1, Unused, "unused_e1", (kOpFlagFallThru))
+JBC_OP(UnusedE2, 0xE2, Unused, "unused_e2", (kOpFlagFallThru))
+JBC_OP(UnusedE3, 0xE3, Unused, "unused_e3", (kOpFlagFallThru))
+JBC_OP(UnusedE4, 0xE4, Unused, "unused_e4", (kOpFlagFallThru))
+JBC_OP(UnusedE5, 0xE5, Unused, "unused_e5", (kOpFlagFallThru))
+JBC_OP(UnusedE6, 0xE6, Unused, "unused_e6", (kOpFlagFallThru))
+JBC_OP(UnusedE7, 0xE7, Unused, "unused_e7", (kOpFlagFallThru))
+JBC_OP(UnusedE8, 0xE8, Unused, "unused_e8", (kOpFlagFallThru))
+JBC_OP(UnusedE9, 0xE9, Unused, "unused_e9", (kOpFlagFallThru))
+JBC_OP(UnusedEA, 0xEA, Unused, "unused_ea", (kOpFlagFallThru))
+JBC_OP(UnusedEB, 0xEB, Unused, "unused_eb", (kOpFlagFallThru))
+JBC_OP(UnusedEC, 0xEC, Unused, "unused_ec", (kOpFlagFallThru))
+JBC_OP(UnusedED, 0xED, Unused, "unused_ed", (kOpFlagFallThru))
+JBC_OP(UnusedEE, 0xEE, Unused, "unused_ee", (kOpFlagFallThru))
+JBC_OP(UnusedEF, 0xEF, Unused, "unused_ef", (kOpFlagFallThru))
+JBC_OP(UnusedF0, 0xF0, Unused, "unused_f0", (kOpFlagFallThru))
+JBC_OP(UnusedF1, 0xF1, Unused, "unused_f1", (kOpFlagFallThru))
+JBC_OP(UnusedF2, 0xF2, Unused, "unused_f2", (kOpFlagFallThru))
+JBC_OP(UnusedF3, 0xF3, Unused, "unused_f3", (kOpFlagFallThru))
+JBC_OP(UnusedF4, 0xF4, Unused, "unused_f4", (kOpFlagFallThru))
+JBC_OP(UnusedF5, 0xF5, Unused, "unused_f5", (kOpFlagFallThru))
+JBC_OP(UnusedF6, 0xF6, Unused, "unused_f6", (kOpFlagFallThru))
+JBC_OP(UnusedF7, 0xF7, Unused, "unused_f7", (kOpFlagFallThru))
+JBC_OP(UnusedF8, 0xF8, Unused, "unused_f8", (kOpFlagFallThru))
+JBC_OP(UnusedF9, 0xF9, Unused, "unused_f9", (kOpFlagFallThru))
+JBC_OP(UnusedFA, 0xFA, Unused, "unused_fa", (kOpFlagFallThru))
+JBC_OP(UnusedFB, 0xFB, Unused, "unused_fb", (kOpFlagFallThru))
+JBC_OP(UnusedFC, 0xFC, Unused, "unused_fc", (kOpFlagFallThru))
+JBC_OP(UnusedFD, 0xFD, Unused, "unused_fd", (kOpFlagFallThru))
+JBC_OP(ImpDep1, 0xFE, Reversed, "impdep1", (kOpFlagFallThru))
+JBC_OP(ImpDep2, 0xFF, Reversed, "impdep2", (kOpFlagFallThru))
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_opcode.h b/src/hir2mpl/bytecode_input/class/include/jbc_opcode.h
new file mode 100644
index 0000000000000000000000000000000000000000..d10e5e43654ea7ce48b5836809027bc27c1f8888
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_opcode.h
@@ -0,0 +1,691 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef HIR2MPL_INCLUDE_JBC_OPCODE_H
+#define HIR2MPL_INCLUDE_JBC_OPCODE_H
+#include <climits>
+#include <map>
+#include <string>
+#include <vector>
+#include "types_def.h"
+#include "mempool_allocator.h"
+#include "factory.h"
+#include "basic_io.h"
+#include "feir_type.h"
+
+namespace maple {
+namespace jbc {
+enum JBCOpcode : uint8 {
+#define JBC_OP(op, value, type, name, flag) \
+  kOp##op = value,
+#include "jbc_opcode.def"
+#undef JBC_OP
+};
+
+enum JBCOpcodeKind : uint8 {
+  kOpKindDefault = 0,
+#define JBC_OP_KIND(kind, name) \
+  kOpKind##kind,
+#include "jbc_opcode_kind.def"
+#undef JBC_OP_KIND
+  kOpKindSize
+};
+
+enum JBCPrimType : uint8 {
+  kTypeDefault = 0,
+  kTypeInt,
+  kTypeLong,
+  kTypeFloat,
+  kTypeDouble,
+  kTypeByteOrBoolean,
+  kTypeChar,
+  kTypeShort,
+  kTypeRef,
+  kTypeAddress,
+  kTypeLongDummy,
+  kTypeDoubleDummy,
+  kTypeSize
+};
+
+enum JBCOpcodeFlag : uint8 {
+  kOpFlagNone = 0,
+  kOpFlagFallThru = 1,
+  kOpFlagBranch = 1 << 1,
+  kOpFlagThrowable = 1 << 2
+};
+
+struct JBCOpcodeDesc {
+  JBCOpcodeKind kind;
+  std::string name;
+  uint8 flags;
+};
+
+class JBCOpcodeInfo {
+ public:
+  static const uint32 kOpSize = 0x100;
+  JBCOpcodeInfo();
+  ~JBCOpcodeInfo() = default;
+
+  JBCOpcodeKind GetOpcodeKind(JBCOpcode op) const {
+    return table[static_cast<uint8>(op)].kind;
+  }
+
+  const std::string &GetOpcodeName(JBCOpcode op) const {
+    return table[static_cast<uint8>(op)].name;
+  }
+
+  bool IsFallThru(JBCOpcode op) const {
+    return (table[static_cast<uint8>(op)].flags & kOpFlagFallThru) != 0;
+  }
+
+  bool IsBranch(JBCOpcode op) const {
+    return (table[static_cast<uint8>(op)].flags & kOpFlagBranch) != 0;
+  }
+
+  bool IsThrowable(JBCOpcode op) const {
+    return (table[static_cast<uint8>(op)].flags & kOpFlagThrowable) != 0;
+  }
+
+ private:
+  JBCOpcodeDesc table[kOpSize];
+};
+
+class JBCConstPool;
+class JBCOp {
+ public:
+  JBCOp(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  virtual ~JBCOp() = default;
+  bool CheckNotWide(const BasicIORead &io) const;
+  bool ParseFile(BasicIORead &io) {
+    return ParseFileImpl(io);
+  }
+
+  std::string Dump(const JBCConstPool &constPool) const {
+    return DumpImpl(constPool);
+  }
+
+  const std::vector<JBCPrimType> &GetInputTypesFromStack() const {
+    return GetInputTypesFromStackImpl();
+  }
+
+  std::vector<JBCPrimType> GetInputTypesFromStack(const JBCConstPool &constPool) const {
+    return GetInputTypesFromStackImpl(constPool);
+  }
+
+  JBCPrimType GetOutputTypesToStack() const {
+    return GetOutputTypesToStackImpl();
+  }
+
+  JBCPrimType GetOutputTypesToStack(const JBCConstPool &constPool) const {
+    return GetOutputTypesToStackImpl(constPool);
+  }
+
+  JBCOpcode GetOpcode() const {
+    return op;
+  }
+
+  JBCOpcodeKind GetOpcodeKind() const {
+    return kind;
+  }
+
+  bool IsWide() const {
+    return wide;
+  }
+
+  const std::string &GetOpcodeName() const {
+    return opcodeInfo.GetOpcodeName(op);
+  }
+
+  bool IsFallThru() const {
+    return opcodeInfo.IsFallThru(op);
+  }
+
+  bool IsBranch() const {
+    return opcodeInfo.IsBranch(op);
+  }
+
+  bool IsThrowable() const {
+    return opcodeInfo.IsThrowable(op);
+  }
+
+  static JBCOpcodeInfo &GetOpcodeInfo() {
+    return opcodeInfo;
+  }
+
+  static uint32 GetTargetbyInt64(int64 pc) {
+    if (pc < 0 || pc > UINT16_MAX) {
+      CHECK_FATAL(false, "invalid PC: %ld", pc);
+      return 0;
+    } else {
+      return static_cast<uint32>(pc);
+    }
+  }
+
+ protected:
+  virtual bool ParseFileImpl(BasicIORead &io) = 0;
+  virtual const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const;
+  virtual std::vector<JBCPrimType> GetInputTypesFromStackImpl(const JBCConstPool &constPool) const;
+  virtual JBCPrimType GetOutputTypesToStackImpl() const;
+  virtual JBCPrimType GetOutputTypesToStackImpl(const JBCConstPool &constPool) const;
+  virtual std::string DumpImpl(const JBCConstPool &constPool) const;
+
+  MapleAllocator &alloc;
+  JBCOpcode op : 8;
+  JBCOpcodeKind kind : 7;
+  bool wide : 1;
+  static JBCOpcodeInfo opcodeInfo;
+  static std::vector<JBCPrimType> emptyPrimTypes;
+};
+
+class JBCOpUnused : public JBCOp {
+ public:
+  JBCOpUnused(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpUnused() = default;
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+};
+
+class JBCOpReversed : public JBCOp {
+ public:
+  JBCOpReversed(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpReversed() = default;
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+};
+
+class JBCOpDefault : public JBCOp {
+ public:
+  JBCOpDefault(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpDefault() = default;
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const override;
+  JBCPrimType GetOutputTypesToStackImpl() const override;
+
+ private:
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> mapOpInputTypes;
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> InitMapOpInputTypes();
+  static std::map<JBCOpcode, JBCPrimType> mapOpOutputType;
+  static std::map<JBCOpcode, JBCPrimType> InitMapOpOutputType();
+  static void InitMapOpInputTypesForArrayLoad(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForArrayLoad(std::map<JBCOpcode, JBCPrimType> &ans);
+  static void InitMapOpInputTypesForArrayStore(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForArrayStore(std::map<JBCOpcode, JBCPrimType> &ans);
+  static void InitMapOpInputTypesForMathBinop(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForMathBinop(std::map<JBCOpcode, JBCPrimType> &ans);
+  static void InitMapOpInputTypesForMathUnop(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForMathUnop(std::map<JBCOpcode, JBCPrimType> &ans);
+  static void InitMapOpInputTypesForConvert(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForConvert(std::map<JBCOpcode, JBCPrimType> &ans);
+  static void InitMapOpInputTypesForCompare(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForCompare(std::map<JBCOpcode, JBCPrimType> &ans);
+  static void InitMapOpInputTypesForReturn(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForReturn(std::map<JBCOpcode, JBCPrimType> &ans);
+  static void InitMapOpInputTypesForThrow(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForThrow(std::map<JBCOpcode, JBCPrimType> &ans);
+  static void InitMapOpInputTypesForMonitor(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForMonitor(std::map<JBCOpcode, JBCPrimType> &ans);
+  static void InitMapOpInputTypesForArrayLength(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans);
+  static void InitMapOpOutputTypesForArrayLength(std::map<JBCOpcode, JBCPrimType> &ans);
+};
+
+class JBCOpConst : public JBCOp {
+ public:
+  JBCOpConst(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpConst() = default;
+  std::string DumpBiPush() const;
+  std::string DumpSiPush() const;
+  std::string DumpLdc(const JBCConstPool &constPool) const;
+  int32 GetValueInt() const;
+  int64 GetValueLong() const;
+  float GetValueFloat() const;
+  double GetValueDouble() const;
+  int8 GetValueByte() const;
+  int16 GetValueShort() const;
+  uint16 GetIndex() const {
+    return u.index;
+  }
+
+  void SetValue(int8 value) {
+    u.bvalue = value;
+  }
+
+  void SetValue(int16 value) {
+    u.svalue = value;
+  }
+
+  void SetIndex(uint16 argIdx) {
+    u.index = argIdx;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  JBCPrimType GetOutputTypesToStackImpl(const JBCConstPool &constPool) const override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  union {
+    int8 bvalue;
+    int16 svalue;
+    uint16 index;
+    uint16 raw;
+  } u;
+
+  static std::map<JBCOpcode, int32> InitValueMapI();
+  static std::map<JBCOpcode, int64> InitValueMapJ();
+  static std::map<JBCOpcode, float> InitValueMapF();
+  static std::map<JBCOpcode, double> InitValueMapD();
+
+  static std::map<JBCOpcode, int32> valueMapI;
+  static std::map<JBCOpcode, int64> valueMapJ;
+  static std::map<JBCOpcode, float> valueMapF;
+  static std::map<JBCOpcode, double> valueMapD;
+};
+
+class JBCOpSlotOpr : public JBCOp {
+ public:
+  JBCOpSlotOpr(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpSlotOpr() = default;
+  bool IsAStore() const;
+  uint16 GetSlotIdx() const {
+    return slotIdx;
+  }
+
+  void SetSlotIdx(uint16 argSlotIdx) {
+    slotIdx = argSlotIdx;
+  }
+
+  bool IsAddressOpr() const {
+    return isAddressOpr;
+  }
+
+  void SetAddressOpr() {
+    isAddressOpr = true;
+  }
+
+  void UnsetAddressOpr() {
+    isAddressOpr = false;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const override;
+  JBCPrimType GetOutputTypesToStackImpl() const override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  static std::map<JBCOpcode, std::pair<uint16, JBCPrimType>> InitMapSlotIdxAndType();
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> InitMapOpInputTypes();
+  static std::map<JBCOpcode, JBCPrimType> InitMapOpOutputType();
+
+  uint16 slotIdx;
+  bool isAddressOpr;
+  static std::map<JBCOpcode, std::pair<uint16, JBCPrimType>> mapSlotIdxAndType;
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> mapOpInputTypes;
+  static std::map<JBCOpcode, JBCPrimType> mapOpOutputType;
+  static std::vector<JBCPrimType> inputTypesAddressOpr;
+};
+
+class JBCOpMathInc : public JBCOp {
+ public:
+  JBCOpMathInc(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpMathInc() = default;
+  uint16 GetIndex() const {
+    return index;
+  }
+
+  void SetIndex(uint16 argIndex) {
+    index = argIndex;
+  }
+
+  int16 GetIncr() const {
+    return incr;
+  }
+
+  void SetIncr(int16 argIncr) {
+    incr = argIncr;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+
+ private:
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> InitMapOpInputTypes();
+  static std::map<JBCOpcode, JBCPrimType> InitMapOpOutputType();
+
+  uint16 index;
+  int16 incr;
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> mapOpInputTypes;
+  static std::map<JBCOpcode, JBCPrimType> mapOpOutputType;
+};
+
+class JBCOpBranch : public JBCOp {
+ public:
+  JBCOpBranch(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpBranch() = default;
+  uint32 GetTarget() const {
+    return target;
+  }
+
+  void SetTarget(uint32 argTarget) {
+    target = argTarget;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+  const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const override;
+
+ private:
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> InitMapOpInputTypes();
+
+  uint32 target;
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> mapOpInputTypes;
+};
+
+class JBCOpGoto : public JBCOp {
+ public:
+  JBCOpGoto(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpGoto() = default;
+  uint32 GetTarget() const {
+    return target;
+  }
+
+  void SetTarget(uint32 argTarget) {
+    target = argTarget;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  uint32 target;
+};
+
+class JBCOpSwitch : public JBCOp {
+ public:
+  JBCOpSwitch(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpSwitch() = default;
+  const MapleMap<int32, uint32> &GetTargets() const {
+    return targets;
+  }
+
+  void ClearTargets() {
+    targets.clear();
+  }
+
+  void AddOrSetTarget(int32 value, uint32 targetPC) {
+    targets[value] = targetPC;
+  }
+
+  uint32 GetDefaultTarget() const {
+    return targetDefault;
+  }
+
+  void SetDefaultTarget(uint32 targetPC) {
+    targetDefault = targetPC;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> InitMapOpInputTypes();
+
+  MapleMap<int32, uint32> targets;
+  uint32 targetDefault;
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> mapOpInputTypes;
+};
+
+class JBCOpFieldOpr : public JBCOp {
+ public:
+  JBCOpFieldOpr(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpFieldOpr() = default;
+  std::string GetFieldType(const JBCConstPool &constPool) const;
+  uint16 GetFieldIdx() const {
+    return fieldIdx;
+  }
+
+  void SetFieldIdx(uint16 idx) {
+    fieldIdx = idx;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const override;
+  std::vector<JBCPrimType> GetInputTypesFromStackImpl(const JBCConstPool &constPool) const override;
+  JBCPrimType GetOutputTypesToStackImpl() const override;
+  JBCPrimType GetOutputTypesToStackImpl(const JBCConstPool &constPool) const override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  std::vector<JBCPrimType> GetInputTypesFromStackForGet(const JBCConstPool &constPool) const;
+  std::vector<JBCPrimType> GetInputTypesFromStackForPut(const JBCConstPool &constPool) const;
+
+  uint16 fieldIdx;
+};
+
+class JBCOpInvoke : public JBCOp {
+ public:
+  JBCOpInvoke(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpInvoke() = default;
+  std::string GetMethodDescription(const JBCConstPool &constPool) const;
+  uint16 GetMethodIdx() const {
+    return methodIdx;
+  }
+
+  void SetMethodIdx(uint16 idx) {
+    methodIdx = idx;
+  }
+
+  uint8 GetCount() const {
+    return count;
+  }
+
+  void SetCount(uint8 argCount) {
+    count = argCount;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const override;
+  std::vector<JBCPrimType> GetInputTypesFromStackImpl(const JBCConstPool &constPool) const override;
+  JBCPrimType GetOutputTypesToStackImpl() const override;
+  JBCPrimType GetOutputTypesToStackImpl(const JBCConstPool &constPool) const override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  uint16 methodIdx;
+  uint8 count;
+};
+
+class JBCOpJsr : public JBCOp {
+ public:
+  JBCOpJsr(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpJsr() = default;
+  uint32 GetTarget() const {
+    return target;
+  }
+
+  void SetTarget(uint32 argTarget) {
+    target = argTarget;
+  }
+
+  uint16 GetSlotIdx() const {
+    return slotIdx;
+  }
+
+  void SetSlotIdx(uint32 argSlotIdx) {
+    slotIdx = static_cast<uint16>(argSlotIdx);
+  }
+
+  int32 GetJsrID() const {
+    return jsrID;
+  }
+
+  void SetJsrID(int32 argJsrID) {
+    jsrID = argJsrID;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  JBCPrimType GetOutputTypesToStackImpl() const override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  uint32 target;
+  uint16 slotIdx;
+  int32 jsrID;
+};
+
+class JBCOpRet : public JBCOp {
+ public:
+  JBCOpRet(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpRet() = default;
+  uint16 GetIndex() const {
+    return index;
+  }
+
+  void SetIndex(uint16 argIndex) {
+    index = argIndex;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  uint16 index;
+};
+
+class JBCOpNew : public JBCOp {
+ public:
+  enum PrimType : uint8 {
+    kPrimNone = 0,
+    kPrimBoolean = 4,
+    kPrimChar = 5,
+    kPrimFloat = 6,
+    kPrimDouble = 7,
+    kPrimByte = 8,
+    kPrimShort = 9,
+    kPrimInt = 10,
+    kPrimLong = 11
+  };
+
+  JBCOpNew(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpNew() = default;
+
+  GStrIdx GetTypeNameIdx(const JBCConstPool &constPool) const;
+  std::string GetTypeName(const JBCConstPool &constPool) const;
+  const FEIRType *GetFEIRType(const JBCConstPool &constPool) const;
+  uint16 GetRefTypeIdx() const {
+    return refTypeIdx;
+  }
+
+  void SetRefTypeIdx(uint16 idx) {
+    refTypeIdx = idx;
+  }
+
+  uint8 GetPrimType() const {
+    return primType;
+  }
+
+  void SetPrimType(uint8 type) {
+    primType = type;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const override;
+  JBCPrimType GetOutputTypesToStackImpl() const override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> InitMapOpInputTypes();
+  std::string GetPrimTypeName() const;
+  const UniqueFEIRType &GetPrimFEIRType() const;
+
+  uint16 refTypeIdx;
+  uint8 primType;
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> mapOpInputTypes;
+};
+
+class JBCOpMultiANewArray : public JBCOp {
+ public:
+  JBCOpMultiANewArray(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpMultiANewArray() = default;
+  uint16 GetRefTypeIdx() const {
+    return refTypeIdx;
+  }
+
+  void SetRefTypeIdx(uint16 idx) {
+    refTypeIdx = idx;
+  }
+
+  uint8 GetDim() const {
+    return dim;
+  }
+
+  void SetDim(uint8 argDim) {
+    dim = argDim;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const override;
+  std::vector<JBCPrimType> GetInputTypesFromStackImpl(const JBCConstPool &constPool) const override;
+  JBCPrimType GetOutputTypesToStackImpl() const override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  uint16 refTypeIdx;
+  uint8 dim;
+};
+
+class JBCOpTypeCheck : public JBCOp {
+ public:
+  JBCOpTypeCheck(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn);
+  ~JBCOpTypeCheck() = default;
+  uint16 GetTypeIdx() const {
+    return typeIdx;
+  }
+
+  void SetTypeIdx(uint16 idx) {
+    typeIdx = idx;
+  }
+
+ protected:
+  bool ParseFileImpl(BasicIORead &io) override;
+  const std::vector<JBCPrimType> &GetInputTypesFromStackImpl() const override;
+  JBCPrimType GetOutputTypesToStackImpl() const override;
+  std::string DumpImpl(const JBCConstPool &constPool) const override;
+
+ private:
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> InitMapOpInputTypes();
+  static std::map<JBCOpcode, JBCPrimType> InitMapOpOutputType();
+
+  uint16 typeIdx;
+  static std::map<JBCOpcode, std::vector<JBCPrimType>> mapOpInputTypes;
+  static std::map<JBCOpcode, JBCPrimType> mapOpOutputType;
+};
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_OPCODE_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_opcode_helper.h b/src/hir2mpl/bytecode_input/class/include/jbc_opcode_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..b20b3f7d7f79b45e67214e0e468033bca05c18fe
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_opcode_helper.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_JBC_OPCODE_HELPER_H
+#define HIR2MPL_INCLUDE_COMMON_JBC_OPCODE_HELPER_H
+#include <string>
+#include <sstream>
+#include <vector>
+#include <map>
+#include "mpl_logging.h"
+#include "jbc_opcode.h"
+#include "jbc_class.h"
+
+namespace maple {
+class JBCOpcodeHelper {
+ public:
+  JBCOpcodeHelper(const jbc::JBCClassMethod &argMethod);
+  ~JBCOpcodeHelper() = default;
+  std::string GetLastErorr() const {
+    return ssLastError.str();
+  }
+  std::vector<std::string> GetBaseTypeNamesForOP(const jbc::JBCOp &op, bool &success);
+  static std::vector<jbc::JBCPrimType> GetInputPrimTypeForOP(const jbc::JBCOp &op, const jbc::JBCConstPool &constPool);
+  static jbc::JBCPrimType GetOutputPrimTypeForOP(const jbc::JBCOp &op, const jbc::JBCConstPool &constPool);
+
+ LLT_PRIVATE:
+  using FuncPtrGetBaseTypeName = std::vector<std::string> (JBCOpcodeHelper::*)(const jbc::JBCOp &op, bool &success);
+  std::vector<std::string> GetBaseTypeNamesForOPDefault(bool &success) const;
+  std::vector<std::string> GetBaseTypeNamesForOPConst(const jbc::JBCOp &op, bool &success);
+  std::vector<std::string> GetBaseTypeNamesForOPFieldOpr(const jbc::JBCOp &op, bool &success);
+  std::vector<std::string> GetBaseTypeNamesForOPInvoke(const jbc::JBCOp &op, bool &success);
+  std::vector<std::string> GetBaseTypeNamesForOPNew(const jbc::JBCOp &op, bool &success);
+  std::vector<std::string> GetBaseTypeNamesForOPMultiANewArray(const jbc::JBCOp &op, bool &success);
+  std::vector<std::string> GetBaseTypeNamesForOPTypeCheck(const jbc::JBCOp &op, bool &success);
+  static std::map<jbc::JBCOpcode, std::vector<jbc::JBCPrimType>> InitMapOpInputPrimTypes();
+  static std::map<jbc::JBCOpcodeKind, FuncPtrGetBaseTypeName> InitFuncPtrMapGetBaseTypeName();
+  static void InitMapOpInputPrimTypesForConst(std::map<jbc::JBCOpcode, std::vector<jbc::JBCPrimType>> &ans);
+  static void InitMapOpInputPrimTypesForLoad();
+
+  const jbc::JBCClassMethod &method;
+  std::stringstream ssLastError;
+  static std::map<jbc::JBCOpcode, std::vector<jbc::JBCPrimType>> mapOpInputPrimTypes;
+  static std::map<jbc::JBCOpcodeKind, FuncPtrGetBaseTypeName> funcPtrMapGetBaseTypeName;
+};  // class JBCOpcodeHelper
+}  // namespace maple
+#endif
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_opcode_kind.def b/src/hir2mpl/bytecode_input/class/include/jbc_opcode_kind.def
new file mode 100644
index 0000000000000000000000000000000000000000..5e0bda7e42f79799cf0b12bf04eb74c4cb4bc7d7
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_opcode_kind.def
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// JBC_OP_KIND(kind, name)
+JBC_OP_KIND(Unused, "Unused")
+JBC_OP_KIND(Reversed, "Reversed")
+JBC_OP_KIND(Const, "Const")
+JBC_OP_KIND(SlotOpr, "SlotOpr")
+JBC_OP_KIND(Load, "Load")
+JBC_OP_KIND(Store, "Store")
+JBC_OP_KIND(ArrayLoad, "ArrayLoad")
+JBC_OP_KIND(ArrayStore, "ArrayStore")
+JBC_OP_KIND(Pop, "Pop")
+JBC_OP_KIND(Dup, "Dup")
+JBC_OP_KIND(Swap, "Swap")
+JBC_OP_KIND(Stack, "Stack")
+JBC_OP_KIND(MathBinop, "MathBinop")
+JBC_OP_KIND(MathUnop, "MathUnop")
+JBC_OP_KIND(MathInc, "MathInc")
+JBC_OP_KIND(Convert, "Convert")
+JBC_OP_KIND(Compare, "Compare")
+JBC_OP_KIND(Branch, "Branch")
+JBC_OP_KIND(Goto, "Goto")
+JBC_OP_KIND(Switch, "Switch")
+JBC_OP_KIND(Return, "Return")
+JBC_OP_KIND(StaticFieldOpr, "StaticFieldOpr")
+JBC_OP_KIND(FieldOpr, "FieldOpr")
+JBC_OP_KIND(Invoke, "Invoke")
+JBC_OP_KIND(Jsr, "Jsr")
+JBC_OP_KIND(Ret, "Ret")
+JBC_OP_KIND(New, "New")
+JBC_OP_KIND(MultiANewArray, "MultiANewArray")
+JBC_OP_KIND(Throw, "Throw")
+JBC_OP_KIND(TypeCheck, "TypeCheck")
+JBC_OP_KIND(Monitor, "Monitor")
+JBC_OP_KIND(ArrayLength, "ArrayLength")
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_stack2fe_helper.h b/src/hir2mpl/bytecode_input/class/include/jbc_stack2fe_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..9df0dac9a35313e2e77ae0d17dab6a6b49dd6d3b
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_stack2fe_helper.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_STACK2FE_HELPER_H
+#define HIR2MPL_INCLUDE_JBC_STACK2FE_HELPER_H
+#include <list>
+#include <vector>
+#include <set>
+#include <string>
+#include "mempool_allocator.h"
+#include "jbc_stack_helper.h"
+#include "feir_builder.h"
+#include "feir_var_reg.h"
+
+namespace maple {
+class JBCStack2FEHelper {
+ public:
+  static const uint8 kRegNumOff = 1;
+  static const uint8 kRegNumOffWide = 2;
+  explicit JBCStack2FEHelper(bool argUseNestExpr = false);
+  ~JBCStack2FEHelper() = default;
+  uint32 GetRegNumForSlot(uint32 slotNum) const;
+  uint32 GetRegNumForStack() const;
+  bool PushItem(UniqueFEIRVar var, PrimType pty);
+  UniqueFEIRVar PushItem(PrimType pty);
+  UniqueFEIRStmt PushItem(UniqueFEIRExpr expr, PrimType pty, bool hasException = false);
+  UniqueFEIRStmt PushItem(UniqueFEIRExpr expr, UniqueFEIRType type, bool hasException = false);
+  UniqueFEIRVar PopItem(PrimType pty);
+  UniqueFEIRVar PopItem(UniqueFEIRType type);
+  UniqueFEIRVar PopItem(bool isWide, PrimType &pty);
+  UniqueFEIRVar PopItemAuto(PrimType &pty);
+  bool Swap();
+  bool Pop(jbc::JBCOpcode opcode);
+  bool Dup(jbc::JBCOpcode opcode);
+  std::list<UniqueFEIRStmt> GenerateSwapStmts();
+  std::list<UniqueFEIRStmt> LoadSwapStack(const JBCStackHelper &stackHelper, bool &success);
+  std::string DumpStackInJavaFormat() const;
+  std::string DumpStackInInternalFormat() const;
+  void ClearStack() {
+    stack.clear();
+  }
+
+  void SetNStacks(uint32 argNStacks) {
+    nStacks = argNStacks;
+    regNumForStacks.clear();
+    for (uint32 i = 0; i < argNStacks; i++) {
+      CHECK_FATAL(regNumForStacks.insert(i).second, "regNumForStacks insert failed");
+    }
+  }
+
+  uint32 GetNStacks() const {
+    return nStacks;
+  }
+
+  void SetNSwaps(uint32 argNSwaps) {
+    nSwaps = argNSwaps;
+  }
+
+  uint32 GetNSwaps() const {
+    return nSwaps;
+  }
+
+  void SetNLocals(uint32 argNLocals) {
+    nLocals = argNLocals;
+  }
+
+  uint32 GetNLocals() const {
+    return nLocals;
+  }
+
+  void SetNArgs(uint32 argNArgs) {
+    nArgs = argNArgs;
+  }
+
+  uint32 GetNArgs() const {
+    return nArgs;
+  }
+
+  static PrimType JBCStackItemTypeToPrimType(jbc::JBCPrimType itemType);
+  static PrimType SimplifyPrimType(PrimType pty);
+
+ protected:
+  bool useNestExpr;
+  uint32 nStacks = 0;
+  uint32 nSwaps = 0;
+  uint32 nLocals = 0;
+  uint32 nArgs = 0;
+  using StackItem = std::pair<UniqueFEIRVar, PrimType>;
+  std::vector<StackItem> stack;   // list<pair<expr, isWide>>
+  std::set<uint32> regNumForStacks;
+  bool Pop();
+  bool Pop2();
+  bool Dup();
+  bool DupX1();
+  bool DupX2();
+  bool Dup2();
+  bool Dup2X1();
+  bool Dup2X2();
+  std::vector<PrimType> JBCStackItemTypesToPrimTypes(const std::vector<jbc::JBCPrimType> itemTypes);
+  bool CheckSwapValid(const std::vector<PrimType> items) const;
+  std::vector<std::pair<uint32, PrimType>> GeneralSwapRegNum(const std::vector<PrimType> items);
+  StackItem MakeStackItem(UniqueFEIRVar var, PrimType pty) const {
+    return std::make_pair(std::move(var), pty);
+  }
+
+  bool IsItemDummy(const StackItem &item) const {
+    return item.first == nullptr && IsPrimTypeWide(item.second);
+  }
+
+  bool IsItemNormal(const StackItem &item) const {
+    return item.first != nullptr && IsPrimTypeNormal(item.second);
+  }
+
+  bool IsItemWide(const StackItem &item) const {
+    return item.first != nullptr && IsPrimTypeWide(item.second);
+  }
+
+  bool IsPrimTypeNormal(PrimType pty) const {
+    return pty == PTY_i32 || pty == PTY_f32 || pty == PTY_ref || pty == PTY_a32;
+  }
+
+  bool IsPrimTypeWide(PrimType pty) const {
+    return pty == PTY_i64 || pty == PTY_f64;
+  }
+};  // class JBCStack2FEHelper
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_STACK2FE_HELPER_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_stack_helper.h b/src/hir2mpl/bytecode_input/class/include/jbc_stack_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..f34936f9d094d19b05ec923c23b40665a6f022aa
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_stack_helper.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_STACK_HELPER_H
+#define HIR2MPL_INCLUDE_JBC_STACK_HELPER_H
+#include "fe_configs.h"
+#include "jbc_opcode.h"
+#include "jbc_class_const_pool.h"
+
+namespace maple {
+class JBCStackHelper {
+ public:
+  JBCStackHelper() = default;
+  ~JBCStackHelper() = default;
+  void Reset();
+  bool StackChange(const jbc::JBCOp &op, const jbc::JBCConstPool &constPool);
+  void PushItem(jbc::JBCPrimType type);
+  void PushItems(const std::vector<jbc::JBCPrimType> &types);
+  bool PopItem(jbc::JBCPrimType type);
+  bool PopItems(const std::vector<jbc::JBCPrimType> &types);
+  void CopyFrom(const JBCStackHelper &src);
+  bool EqualTo(const JBCStackHelper &src);
+  bool Contains(const JBCStackHelper &src);
+  void Dump() const;
+  static std::string GetTypeName(jbc::JBCPrimType type);
+  std::vector<jbc::JBCPrimType> GetStackItems() const;
+  uint32 GetStackSize() const {
+    size_t stackSize = stack.size();
+    CHECK_FATAL(stackSize < UINT32_MAX, "stack size is too large");
+    return static_cast<uint32>(stackSize);
+  }
+
+ LLT_PRIVATE:
+  std::vector<jbc::JBCPrimType> stack;
+  bool Pop(jbc::JBCOpcode opcode);
+  bool Dup(jbc::JBCOpcode opcode);
+  bool Dup();
+  bool DupX1();
+  bool DupX2();
+  bool Dup2();
+  bool Dup2X1();
+  bool Dup2X2();
+  bool Swap();
+  bool IsType1(jbc::JBCPrimType type) const;
+  bool IsType2(jbc::JBCPrimType type) const;
+  bool IsType2Dummy(jbc::JBCPrimType type) const;
+  jbc::JBCPrimType GetGeneralType(jbc::JBCPrimType type) const;
+};  // class JBCStack
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_STACK_HELPER_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_stmt.h b/src/hir2mpl/bytecode_input/class/include/jbc_stmt.h
new file mode 100644
index 0000000000000000000000000000000000000000..bf04c3a2b804545832a8983e32d011255dfbebd6
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_stmt.h
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_STMT_H
+#define HIR2MPL_INCLUDE_JBC_STMT_H
+#include <memory>
+#include <list>
+#include "jbc_opcode.h"
+#include "jbc_stack2fe_helper.h"
+
+namespace maple {
+enum JBCStmtKind : uint8 {
+  kJBCStmtDefault = 0,
+  kJBCStmtFuncBeing,
+  kJBCStmtFuncEnd,
+  kJBCStmtInst,
+  kJBCStmtInstBranch,
+  kJBCStmtInstBranchRet,
+  kJBCStmtPesudoComment,
+  kJBCStmtPesudoLOC,
+  kJBCStmtPesudoLabel,
+  kJBCStmtPesudoTry,
+  kJBCStmtPesudoEndTry,
+  kJBCStmtPesudoCatch
+};
+
+class JBCFunctionContext;
+class JBCStmtKindHelper {
+ public:
+  static std::string JBCStmtKindName(JBCStmtKind kind);
+
+ private:
+  JBCStmtKindHelper() = default;
+  ~JBCStmtKindHelper() = default;
+};  // class JBCStmtKindHelper
+
+class JBCStmt : public FEIRStmt {
+ public:
+  explicit JBCStmt(JBCStmtKind argKind)
+      : FEIRStmt(kStmt), JBCkind(argKind),
+        pc(UINT32_MAX) {}
+
+  JBCStmt(FEIRNodeKind argGenKind, JBCStmtKind argKind)
+      : FEIRStmt(argGenKind),
+        JBCkind(argKind),
+        pc(UINT32_MAX) {}
+
+  virtual ~JBCStmt() = default;
+  std::list<UniqueFEIRStmt> EmitToFEIR(JBCFunctionContext &context, bool &success) const {
+    std::list<UniqueFEIRStmt> feirStmts = EmitToFEIRImpl(context, success);
+    return feirStmts;
+  }
+
+  JBCStmtKind GetJBCKind() const {
+    return JBCkind;
+  }
+
+  void SetJBCKind(JBCStmtKind argKind) {
+    JBCkind = argKind;
+  }
+
+  void SetPC(uint32 argPC) {
+    pc = argPC;
+  }
+
+  uint32 GetPC() const {
+    return pc;
+  }
+
+  bool IsJBCBranch() const {
+    return JBCkind == JBCStmtKind::kJBCStmtInstBranch || JBCkind == JBCStmtKind::kJBCStmtInstBranchRet;
+  }
+
+ protected:
+  virtual std::list<UniqueFEIRStmt> EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const = 0;
+
+  JBCStmtKind JBCkind;
+  uint32 pc;
+};
+
+class JBCStmtInst : public JBCStmt {
+ public:
+  explicit JBCStmtInst(const jbc::JBCOp &argOp);
+  ~JBCStmtInst() = default;
+  const jbc::JBCOp &GetOp() const {
+    return op;
+  }
+
+ protected:
+  bool IsStmtInstImpl() const override;
+  void DumpImpl(const std::string &prefix) const override;
+  std::string DumpDotStringImpl() const override;
+  std::list<UniqueFEIRStmt> EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const override;
+
+ private:
+  const jbc::JBCOp &op;
+  using FuncPtrEmitToFEIR =
+      std::list<UniqueFEIRStmt> (JBCStmtInst::*)(JBCFunctionContext &context, bool &success) const;
+  static std::map<jbc::JBCOpcodeKind, FuncPtrEmitToFEIR> funcPtrMapForEmitToFEIR;
+  static std::map<jbc::JBCOpcodeKind, FuncPtrEmitToFEIR> InitFuncPtrMapForEmitToFEIR();
+  static std::map<jbc::JBCOpcode, Opcode> opcodeMapForMathBinop;
+  static std::map<jbc::JBCOpcode, Opcode> InitOpcodeMapForMathBinop();
+  static std::map<jbc::JBCOpcode, Opcode> opcodeMapForMathUnop;
+  static std::map<jbc::JBCOpcode, Opcode> InitOpcodeMapForMathUnop();
+  static std::map<jbc::JBCOpcode, Opcode> opcodeMapForMonitor;
+  static std::map<jbc::JBCOpcode, Opcode> InitOpcodeMapForMonitor();
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpConst(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpConstCommon(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpAConstNull(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpIConst(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpLConst(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpFConst(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpDConst(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpBiPush(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpSiPush(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpLdc(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpLoad(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpStore(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpArrayLoad(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpArrayStore(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpPop(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpDup(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpSwap(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpMathBinop(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpMathUnop(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpMathInc(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpConvert(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpCompare(const JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpReturn(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpStaticFieldOpr(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpFieldOpr(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpInvoke(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpInvokeVirtual(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpInvokeStatic(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpInvokeInterface(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpInvokeSpecial(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpInvokeDynamic(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpNew(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpMultiANewArray(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpThrow(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpTypeCheck(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpMonitor(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpArrayLength(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRCommon(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRCommon2(JBCFunctionContext &context, bool &success) const;
+  UniqueFEIRStmt GenerateStmtForConstI32(JBCStack2FEHelper &stack2feHelper, int32 val, bool &success) const;
+  UniqueFEIRStmt GenerateStmtForConstI64(JBCStack2FEHelper &stack2feHelper, int64 val, bool &success) const;
+  UniqueFEIRStmt GenerateStmtForConstF32(JBCStack2FEHelper &stack2feHelper, float val, bool &success) const;
+  UniqueFEIRStmt GenerateStmtForConstF64(JBCStack2FEHelper &stack2feHelper, double val, bool &success) const;
+  void PrepareInvokeParametersAndReturn(JBCStack2FEHelper &stack2feHelper, const FEStructMethodInfo &info,
+                                        FEIRStmtCallAssign &callStmt, bool isStatic) const;
+};
+
+class JBCStmtPesudoLabel;
+
+class JBCStmtInstBranch : public JBCStmt {
+ public:
+  explicit JBCStmtInstBranch(const jbc::JBCOp &argOp);
+  ~JBCStmtInstBranch() = default;
+  const jbc::JBCOp &GetOp() const {
+    return op;
+  }
+
+ protected:
+  bool IsStmtInstImpl() const override;
+  void DumpImpl(const std::string &prefix) const override;
+  std::string DumpDotStringImpl() const override;
+  std::list<UniqueFEIRStmt> EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const override;
+  JBCStmtPesudoLabel *GetTarget(const std::map<uint32, JBCStmtPesudoLabel*> &mapPCStmtLabel, uint32 pc) const;
+  virtual std::list<UniqueFEIRStmt> EmitToFEIRForOpRetImpl(JBCFunctionContext &context, bool &success) const {
+    (void) context;
+    (void) success;
+    return std::list<UniqueFEIRStmt>();
+  }
+
+  const jbc::JBCOp &op;
+
+ private:
+  // bitwise mode
+  enum {
+    kModeDefault = 0,  // for int32 using normal opnd
+    kModeUseRef = 0x1,  // bit0: 1 for ref, 0 for int32
+    kModeUseZeroAsSecondOpnd = 0x2  // bit1: 1 for using 0 for 2nd opnd, 0 for using normal opnd
+  };
+
+  using FuncPtrEmitToFEIR =
+      std::list<UniqueFEIRStmt> (JBCStmtInstBranch::*)(JBCFunctionContext &context, bool &success) const;
+  static std::map<jbc::JBCOpcodeKind, FuncPtrEmitToFEIR> funcPtrMapForEmitToFEIR;
+  static std::map<jbc::JBCOpcodeKind, FuncPtrEmitToFEIR> InitFuncPtrMapForEmitToFEIR();
+  static std::map<jbc::JBCOpcode, std::tuple<Opcode, Opcode, uint8>> opcodeMapForCondGoto;
+  static std::map<jbc::JBCOpcode, std::tuple<Opcode, Opcode, uint8>> InitOpcodeMapForCondGoto();
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpGoto(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpBranch(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpSwitch(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpJsr(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpRet(JBCFunctionContext &context, bool &success) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRCommon(JBCFunctionContext &context, bool &success) const;
+};
+
+class JBCStmtInstBranchRet : public JBCStmtInstBranch {
+ public:
+  JBCStmtInstBranchRet(const jbc::JBCOp &argOp);
+  ~JBCStmtInstBranchRet() = default;
+
+ protected:
+  std::list<UniqueFEIRStmt> EmitToFEIRForOpRetImpl(JBCFunctionContext &context, bool &success) const override;
+};
+
+class JBCStmtPesudoLabel : public JBCStmt {
+ public:
+  JBCStmtPesudoLabel()
+      : JBCStmt(kStmtPesudo, kJBCStmtPesudoLabel),
+        labelIdx(0) {}
+
+  ~JBCStmtPesudoLabel() = default;
+  void SetLabelIdx(uint32 arg) {
+    labelIdx = arg;
+  }
+
+  uint32 GetLabelIdx() const {
+    return labelIdx;
+  }
+
+ protected:
+  void DumpImpl(const std::string &prefix) const override;
+  std::string DumpDotStringImpl() const override;
+  std::list<UniqueFEIRStmt> EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const override;
+
+  uint32 labelIdx;
+};
+
+class JBCStmtPesudoCatch : public JBCStmtPesudoLabel {
+ public:
+  JBCStmtPesudoCatch()
+      : JBCStmtPesudoLabel() {
+    JBCkind = kJBCStmtPesudoCatch;
+  }
+  ~JBCStmtPesudoCatch() = default;
+  void AddCatchTypeName(const GStrIdx &nameIdx) {
+    if (catchTypeNames.find(nameIdx) == catchTypeNames.end()) {
+      CHECK_FATAL(catchTypeNames.insert(nameIdx).second, "catchTypeNames insert failed");
+    }
+  }
+
+ protected:
+  void DumpImpl(const std::string &prefix) const override;
+  std::string DumpDotStringImpl() const override;
+  std::list<UniqueFEIRStmt> EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const override;
+
+ private:
+  std::set<GStrIdx> catchTypeNames;
+};
+
+class JBCStmtPesudoTry : public JBCStmt {
+ public:
+  JBCStmtPesudoTry()
+      : JBCStmt(kJBCStmtPesudoTry) {}
+
+  ~JBCStmtPesudoTry() = default;
+  void AddCatchStmt(JBCStmtPesudoCatch &stmt) {
+    catchStmts.push_back(&stmt);
+  }
+
+  size_t GetCatchCount() const {
+    return catchStmts.size();
+  }
+
+  JBCStmtPesudoCatch *GetCatchStmt(uint32 idx) {
+    ASSERT(idx < catchStmts.size(), "index out of range");
+    return static_cast<JBCStmtPesudoCatch*>(catchStmts[idx]);
+  }
+
+ protected:
+  void DumpImpl(const std::string &prefix) const override;
+  std::string DumpDotStringImpl() const override;
+  std::list<UniqueFEIRStmt> EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const override;
+
+ private:
+  std::vector<JBCStmtPesudoCatch*> catchStmts;
+};
+
+class JBCStmtPesudoEndTry : public JBCStmt {
+ public:
+  JBCStmtPesudoEndTry()
+      : JBCStmt(kJBCStmtPesudoEndTry) {
+    isAuxPost = true;
+  }
+
+  ~JBCStmtPesudoEndTry() = default;
+
+ protected:
+  void DumpImpl(const std::string &prefix) const override;
+  std::string DumpDotStringImpl() const override;
+  std::list<UniqueFEIRStmt> EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const override;
+};
+
+class JBCStmtPesudoComment : public JBCStmt {
+ public:
+  explicit JBCStmtPesudoComment(const std::string &argContent)
+      : JBCStmt(kJBCStmtPesudoComment),
+        content(argContent) {
+    isAuxPre = true;
+  }
+
+  ~JBCStmtPesudoComment() = default;
+  void SetContent(const std::string &argContent) {
+    content = argContent;
+  }
+
+ protected:
+  void DumpImpl(const std::string &prefix) const override;
+  std::string DumpDotStringImpl() const override;
+  std::list<UniqueFEIRStmt> EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const override;
+
+ private:
+  std::string content = "";
+};  // class JBCStmtPesudoComment
+
+class JBCStmtPesudoLOC : public JBCStmt {
+ public:
+  JBCStmtPesudoLOC()
+      : JBCStmt(kJBCStmtPesudoLOC),
+        srcFileIdx(0),
+        lineNumber(0) {
+    isAuxPre = true;
+  }
+
+  JBCStmtPesudoLOC(uint32 argSrcFileIdx, uint32 argLineNumber)
+      : JBCStmt(kJBCStmtPesudoLOC),
+        srcFileIdx(argSrcFileIdx),
+        lineNumber(argLineNumber) {
+    isAuxPre = true;
+  }
+
+  ~JBCStmtPesudoLOC() = default;
+  void SetSrcFileIdx(uint32 idx) {
+    srcFileIdx = idx;
+  }
+
+  uint32 GetPesudoLOCSrcFileIdx() const {
+    return srcFileIdx;
+  }
+
+  void SetLineNumber(uint32 line) {
+    lineNumber = line;
+  }
+
+  uint32 GetLineNumber() const {
+    return lineNumber;
+  }
+
+ protected:
+  void DumpImpl(const std::string &prefix) const override;
+  std::string DumpDotStringImpl() const override;
+  std::list<UniqueFEIRStmt> EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const override;
+
+ private:
+  uint32 srcFileIdx;
+  uint32 lineNumber;
+};
+}
+#endif  // HIR2MPL_INCLUDE_JBC_STMT_H
diff --git a/src/hir2mpl/bytecode_input/class/include/jbc_util.h b/src/hir2mpl/bytecode_input/class/include/jbc_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6e1eff00b80e06d0bc4071c85252af91601b487
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/include/jbc_util.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_JBC_UTIL_H
+#define HIR2MPL_INCLUDE_JBC_UTIL_H
+#include <string>
+#include <vector>
+#include "jbc_opcode.h"
+
+namespace maple {
+namespace jbc {
+class JBCUtil {
+ public:
+  static std::string ClassInternalNameToFullName(const std::string &name);
+  static JBCPrimType GetPrimTypeForName(const std::string &name);
+
+ private:
+  JBCUtil() = default;
+  ~JBCUtil() = default;
+};
+}  // namespace jbc
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_JBC_UTIL_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_attr.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_attr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..40f7a215ee4e405c5a985086cb251e610ef6cb7d
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_attr.cpp
@@ -0,0 +1,1144 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_attr.h"
+#include "jbc_attr_item.h"
+
+namespace maple {
+namespace jbc {
+// ---------- JBCAttr ----------
+JBCAttr::JBCAttr(JBCAttrKind kindIn, uint16 nameIdxIn, uint32 lengthIn)
+    : kind(kindIn), nameIdx(nameIdxIn), length(lengthIn) {}
+
+JBCAttr* JBCAttr::InAttr(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  JBCAttr *attrInfo = nullptr;
+  uint16 nameIdx = io.ReadUInt16();
+  uint32 length = io.ReadUInt32();
+  uint32 posStart = io.GetPos();
+  const JBCConst *constNameRaw = constPool.GetConstByIdxWithTag(nameIdx, kConstUTF8);
+  if (constNameRaw == nullptr) {
+    ERR(kLncErr, "invalid nameIdx %d for attr name.", nameIdx);
+    return nullptr;
+  }
+  const JBCConstUTF8 *constName = static_cast<const JBCConstUTF8*>(constNameRaw);
+  std::string strName = constName->GetString();
+  if (strName.empty()) {
+    ERR(kLncErr, "AttrInfo@0x%x parse error: empty attr name.", posStart);
+#define JBC_ATTR(name, Type)                             \
+  } else if (strName.compare(name) == 0) {               \
+    attrInfo = mp->New<JBCAttr##Type>(allocator, nameIdx, length);  \
+    if (!attrInfo->ParseFile(allocator, io, constPool)) {   \
+      CHECK_FATAL(false, "failed to parse attr info");      \
+    }
+#include "jbc_attr.def"
+#undef JBC_ATTR
+  } else {
+    attrInfo = mp->New<JBCAttrRaw>(allocator, nameIdx, length);
+    if (!attrInfo->ParseFile(allocator, io, constPool)) {
+      CHECK_FATAL(false, "failed to parse attr info");
+    }
+  }
+  if (io.GetPos() - posStart != length) {
+    ERR(kLncErr, "AttrInfo@0x%x parse error: incorrect data length.", posStart);
+    io.SetPos(posStart + length);
+  }
+  return attrInfo;
+}
+
+JBCAttrKind JBCAttr::AttrKind(const std::string &str) {
+#define JBC_ATTR(name, type)        \
+  if (str.compare(name) == 0) {     \
+    return kAttr##type;        \
+  }
+#include "jbc_attr.def"
+#undef JBC_ATTR
+  return kAttrUnknown;
+}
+
+// ---------- JBCAttrMap ----------
+JBCAttrMap::JBCAttrMap(MapleAllocator &allocatorIn)
+    : allocator(allocatorIn), mapAttrs(std::less<JBCAttrKind>(), allocator.Adapter()) {}
+
+void JBCAttrMap::RegisterAttr(JBCAttr &attr) {
+  JBCAttrKind kind = attr.GetKind();
+  MapleMap<JBCAttrKind, MapleList<JBCAttr*>*>::const_iterator it = mapAttrs.find(kind);
+  if (it == mapAttrs.end()) {
+    MemPool *mp = allocator.GetMemPool();
+    MapleList<JBCAttr*> *attrList = mp->New<MapleList<JBCAttr*>>(allocator.Adapter());
+    attrList->push_back(&attr);
+    CHECK_FATAL(mapAttrs.insert(std::make_pair(kind, attrList)).second, "mapAttrs insert error");
+  } else {
+    it->second->push_back(&attr);
+  }
+}
+
+std::list<JBCAttr*> JBCAttrMap::GetAttrs(JBCAttrKind kind) const {
+  auto it = mapAttrs.find(kind);
+  if (it == mapAttrs.end()) {
+    return std::list<JBCAttr*>();
+  } else {
+    std::list<JBCAttr*> ans;
+    for (JBCAttr *attr : *(it->second)) {
+      ans.push_back(attr);
+    }
+    return ans;
+  }
+}
+
+const JBCAttr *JBCAttrMap::GetAttr(JBCAttrKind kind) const {
+  auto it = mapAttrs.find(kind);
+  if (it == mapAttrs.end()) {
+    return nullptr;
+  } else {
+    CHECK_FATAL(it->second->size() == 1, "more than one attrs");
+    return *(it->second->begin());
+  }
+}
+
+bool JBCAttrMap::PreProcess(const JBCConstPool &constPool) {
+  bool success = true;
+  for (auto itList : mapAttrs) {
+    for (JBCAttr *attr : *(itList.second)) {
+      switch (attr->GetKind()) {
+        case kAttrLocalVariableTable:
+        case kAttrLocalVariableTypeTable:
+          success = success && attr->PreProcess(constPool);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return success;
+}
+
+// ---------- JBCAttrRaw ----------
+JBCAttrRaw::JBCAttrRaw(const MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrRaw, nameIdx, length),
+      rawData(nullptr) {
+  (void) allocator;
+}
+
+JBCAttrRaw::~JBCAttrRaw() {
+  rawData = nullptr;
+}
+
+bool JBCAttrRaw::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  rawData = static_cast<uint8*>(mp->Malloc(length));
+  CHECK_NULL_FATAL(rawData);
+  io.ReadBufferUInt8(rawData, length, success);
+  return success;
+}
+
+bool JBCAttrRaw::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrRaw::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrLocalVariableInfo ----------
+JavaAttrLocalVariableInfoItem JBCAttrLocalVariableInfo::kInvalidInfoItem;
+
+JBCAttrLocalVariableInfo::JBCAttrLocalVariableInfo(MapleAllocator &argAllocator)
+    : allocator(argAllocator),
+      slotStartMap(allocator.Adapter()),
+      itemMap(allocator.Adapter()) {}
+
+void JBCAttrLocalVariableInfo::RegisterItem(const attr::LocalVariableTableItem &itemAttr) {
+  uint16 slotIdx = itemAttr.GetIndex();
+  uint16 startPC = itemAttr.GetStartPC();
+  uint16 length = itemAttr.GetLength();
+  JavaAttrLocalVariableInfoItem *item = GetItemByStartInternal(slotIdx, startPC);
+  if (item == nullptr) {
+    CheckItemAvaiable(slotIdx, startPC);
+    AddSlotStartMap(slotIdx, startPC);
+    JavaAttrLocalVariableInfoItem &itemRef = itemMap[std::make_pair(slotIdx, startPC)];
+    itemRef.slotIdx = slotIdx;
+    itemRef.start = startPC;
+    itemRef.length = length;
+    itemRef.nameIdx = itemAttr.GetNameStrIdx();
+    itemRef.feirType = itemAttr.GetFEIRType();
+  } else {
+    if (item->start == startPC && item->length == length && item->nameIdx == itemAttr.GetNameStrIdx()) {
+      CHECK_FATAL(item->feirType == nullptr, "Item already defined");
+      item->feirType = itemAttr.GetFEIRType();
+    } else {
+      CHECK_FATAL(false, "Item mismatch in RegisterItem()");
+    }
+  }
+}
+
+void JBCAttrLocalVariableInfo::RegisterTypeItem(const attr::LocalVariableTypeTableItem &itemAttr) {
+  uint16 slotIdx = itemAttr.GetIndex();
+  uint16 startPC = itemAttr.GetStartPC();
+  uint16 length = itemAttr.GetLength();
+  JavaAttrLocalVariableInfoItem *item = GetItemByStartInternal(slotIdx, startPC);
+  if (item == nullptr) {
+    CheckItemAvaiable(slotIdx, startPC);
+    AddSlotStartMap(slotIdx, startPC);
+    JavaAttrLocalVariableInfoItem &itemRef = itemMap[std::make_pair(slotIdx, startPC)];
+    itemRef.slotIdx = slotIdx;
+    itemRef.start = startPC;
+    itemRef.length = length;
+    itemRef.nameIdx = itemAttr.GetNameStrIdx();
+    itemRef.signatureNameIdx = itemAttr.GetSignatureStrIdx();
+  } else {
+    if (item->start == startPC && item->length == length && item->nameIdx == itemAttr.GetNameStrIdx()) {
+      CHECK_FATAL(item->signatureNameIdx == 0, "Item already defined");
+      item->signatureNameIdx = itemAttr.GetSignatureStrIdx();
+    } else {
+      CHECK_FATAL(false, "Item mismatch in RegisterItem()");
+    }
+  }
+}
+
+const JavaAttrLocalVariableInfoItem &JBCAttrLocalVariableInfo::GetItemByStart(uint16 slotIdx, uint16 start) const {
+  uint32 itemPCStart = GetStart(slotIdx, start);
+  if (itemPCStart != start) {
+    return kInvalidInfoItem;
+  }
+  std::map<std::pair<uint16, uint16>, JavaAttrLocalVariableInfoItem>::const_iterator it =
+      itemMap.find(std::make_pair(slotIdx, itemPCStart));
+  if (it != itemMap.end()) {
+    return it->second;
+  } else {
+    return kInvalidInfoItem;
+  }
+}
+
+JavaAttrLocalVariableInfoItem *JBCAttrLocalVariableInfo::GetItemByStartInternal(uint16 slotIdx, uint16 start) {
+  uint32 itemPCStart = GetStart(slotIdx, start);
+  if (itemPCStart != start) {
+    return nullptr;
+  }
+  std::map<std::pair<uint16, uint16>, JavaAttrLocalVariableInfoItem>::iterator it =
+      itemMap.find(std::make_pair(slotIdx, itemPCStart));
+  CHECK_FATAL(it != itemMap.end(), "Item@%d not found", start);
+  return &(it->second);
+}
+
+uint16 JBCAttrLocalVariableInfo::GetStart(uint16 slotIdx, uint16 pc) const {
+  MapleMap<uint16, MapleSet<uint16>>::const_iterator it = slotStartMap.find(slotIdx);
+  if (it == slotStartMap.end()) {
+    return jbc::kInvalidPC16;
+  }
+  uint16 startLast = jbc::kInvalidPC16;
+  for (uint16 start : it->second) {
+    if (pc == start) {
+      return start;
+    } else if (pc < start) {
+      return startLast;
+    }
+    startLast = start;
+  }
+  return startLast;
+}
+
+std::list<std::string> JBCAttrLocalVariableInfo::EmitToStrings() const {
+  std::list<std::string> ans;
+  std::stringstream ss;
+  ans.emplace_back("===== Local Variable Info =====");
+  for (const std::pair<const std::pair<uint16, uint16>, JavaAttrLocalVariableInfoItem> &itemPair : itemMap) {
+    const JavaAttrLocalVariableInfoItem &item = itemPair.second;
+    ss.str("");
+    ss << "slot[" << item.slotIdx << "]: ";
+    ss << "start=" << item.start << ", ";
+    ss << "lenght=" << item.length << ", ";
+    ss << "name=\'" << GlobalTables::GetStrTable().GetStringFromStrIdx(item.nameIdx) << "\', ";
+    ss << "type=\'" << item.feirType->GetTypeName() << "\', ";
+    ss << "signature=\'" << GlobalTables::GetStrTable().GetStringFromStrIdx(item.signatureNameIdx) << "\'";
+    ans.push_back(ss.str());
+  }
+  ans.emplace_back("===============================");
+  return ans;
+}
+
+bool JBCAttrLocalVariableInfo::IsInvalidLocalVariableInfoItem(const JavaAttrLocalVariableInfoItem &item) {
+  return (item.nameIdx == 0 && item.feirType == nullptr && item.signatureNameIdx == 0);
+}
+
+void JBCAttrLocalVariableInfo::AddSlotStartMap(uint16 slotIdx, uint16 startPC) {
+  auto it = slotStartMap.find(slotIdx);
+  if (it == slotStartMap.end()) {
+    MapleSet<uint16> startSet(allocator.Adapter());
+    CHECK_FATAL(startSet.insert(startPC).second, "insert failed");
+    CHECK_FATAL(slotStartMap.insert(std::make_pair(slotIdx, startSet)).second, "insert failed");
+  } else {
+    CHECK_FATAL(it->second.insert(startPC).second, "insert failed");
+  }
+}
+
+void JBCAttrLocalVariableInfo::CheckItemAvaiable(uint16 slotIdx, uint16 start) const {
+  uint32 itemPCStart = GetStart(slotIdx, start);
+  if (itemPCStart == jbc::kInvalidPC16) {
+    return;
+  }
+  CHECK_FATAL(itemPCStart <= jbc::kMaxPC32, "Invalid PC");
+  uint16 itemPCStart16 = static_cast<uint16>(itemPCStart);
+  const JavaAttrLocalVariableInfoItem &item = GetItemByStart(slotIdx, itemPCStart16);
+  CHECK_FATAL(!JBCAttrLocalVariableInfo::IsInvalidLocalVariableInfoItem(item), "Item@%d not found", itemPCStart16);
+  CHECK_FATAL(start >= item.start + item.length, "PC range overlapped");
+}
+
+// ---------- JBCAttrConstantValue ----------
+JBCAttrConstantValue::JBCAttrConstantValue(const MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrConstantValue, nameIdx, length),
+      constIdx(0),
+      constValue(nullptr) {
+  (void) allocator;
+}
+
+JBCAttrConstantValue::~JBCAttrConstantValue() {
+  constValue = nullptr;
+}
+
+bool JBCAttrConstantValue::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) allocator;
+  (void) constPool;
+  bool success = false;
+  constIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCAttrConstantValue::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrConstantValue::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                    uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrCode ----------
+JBCAttrCode::JBCAttrCode(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrCode, nameIdx, length),
+      maxStack(0),
+      maxLocals(0),
+      codeLength(0),
+      code(nullptr),
+      nException(0),
+      exceptions(allocator.Adapter()),
+      nAttr(0),
+      attrs(allocator.Adapter()),
+      instructions(allocator.Adapter()),
+      attrMap(allocator),
+      localVarInfo(allocator) {}
+
+JBCAttrCode::~JBCAttrCode() {
+  code = nullptr;
+}
+
+bool JBCAttrCode::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  CHECK_FATAL(mp, "mempool is nullptr");
+  maxStack = io.ReadUInt16(success);
+  maxLocals = io.ReadUInt16(success);
+  codeLength = io.ReadUInt32(success);
+  code = static_cast<uint8*>(mp->Malloc(codeLength));
+  CHECK_NULL_FATAL(code);
+  io.ReadBufferUInt8(code, codeLength, success);
+  nException = io.ReadUInt16(success);
+  for (uint16 i = 0; i < nException; i++) {
+    attr::ExceptionTableItem *item = mp->New<attr::ExceptionTableItem>();
+    success = item->ParseFile(allocator, io);
+    exceptions.push_back(item);
+  }
+  nAttr = io.ReadUInt16(success);
+  for (uint16 i = 0; i < nAttr; i++) {
+    JBCAttr *attr = nullptr;
+    attr = JBCAttr::InAttr(allocator, io, constPool);
+    if (attr == nullptr) {
+      return false;
+    }
+    attrs.push_back(attr);
+    attrMap.RegisterAttr(*attr);
+  }
+  // ParseOpcode
+  success = ParseOpcodes(allocator);
+  return success;
+}
+
+bool JBCAttrCode::PreProcessImpl(const JBCConstPool &constPool) {
+  bool success = true;
+  for (attr::ExceptionTableItem *item : exceptions) {
+    success = success && item->PreProcess(constPool);
+  }
+  success = success && attrMap.PreProcess(constPool);
+  InitLocalVarInfo();
+  return success;
+}
+
+SimpleXMLElem *JBCAttrCode::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// Remove const when implemented
+void JBCAttrCode::InitLocalVarInfo() {
+  // LocalVariableTable
+  std::list<JBCAttr*> localVars = attrMap.GetAttrs(jbc::kAttrLocalVariableTable);
+  for (JBCAttr *attrRaw : localVars) {
+    CHECK_NULL_FATAL(attrRaw);
+    JBCAttrLocalVariableTable *attr = static_cast<JBCAttrLocalVariableTable*>(attrRaw);
+    for (attr::LocalVariableTableItem *itemAttr : attr->GetLocalVarInfos()) {
+      localVarInfo.RegisterItem(*itemAttr);
+    }
+  }
+  // LocalVariableTypeTable
+  std::list<JBCAttr*> localVarTypes = attrMap.GetAttrs(jbc::kAttrLocalVariableTypeTable);
+  for (JBCAttr *attrRaw : localVarTypes) {
+    CHECK_NULL_FATAL(attrRaw);
+    JBCAttrLocalVariableTypeTable *attr = static_cast<JBCAttrLocalVariableTypeTable*>(attrRaw);
+    for (attr::LocalVariableTypeTableItem *itemAttr : attr->GetLocalVarTypeInfos()) {
+      localVarInfo.RegisterTypeItem(*itemAttr);
+    }
+  }
+}
+
+// Remove const when implemented
+void JBCAttrCode::SetLoadStoreType() const {
+}
+
+bool JBCAttrCode::ParseOpcodes(MapleAllocator &allocator) {
+  BasicIOMapFile file("code", code, codeLength);
+  BasicIORead io(file, true);
+  bool success = true;
+  bool wide = false;
+  JBCOp *objOP = nullptr;
+  uint32 pc = 0;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  while (io.GetPos() < codeLength && success) {
+    if (wide == false) {
+      pc = io.GetPos();
+    }
+    JBCOpcode opcode = static_cast<JBCOpcode>(io.ReadUInt8(success));
+    if (opcode == kOpWide) {
+      wide = true;
+      continue;
+    }
+    JBCOpcodeKind kind = JBCOp::GetOpcodeInfo().GetOpcodeKind(opcode);
+    switch (kind) {
+      case kOpKindArrayLoad:
+      case kOpKindArrayStore:
+      case kOpKindPop:
+      case kOpKindDup:
+      case kOpKindSwap:
+      case kOpKindStack:
+      case kOpKindMathBinop:
+      case kOpKindMathUnop:
+      case kOpKindConvert:
+      case kOpKindCompare:
+      case kOpKindReturn:
+      case kOpKindThrow:
+      case kOpKindMonitor:
+      case kOpKindArrayLength:
+        objOP = mp->New<JBCOpDefault>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindUnused:
+        objOP = mp->New<JBCOpUnused>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindReversed:
+        objOP = mp->New<JBCOpReversed>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindConst:
+        objOP = mp->New<JBCOpConst>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindLoad:
+      case kOpKindStore:
+        objOP = mp->New<JBCOpSlotOpr>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindMathInc:
+        objOP = mp->New<JBCOpMathInc>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindBranch:
+        objOP = mp->New<JBCOpBranch>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindGoto:
+        objOP = mp->New<JBCOpGoto>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindSwitch:
+        objOP = mp->New<JBCOpSwitch>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindStaticFieldOpr:
+      case kOpKindFieldOpr:
+        objOP = mp->New<JBCOpFieldOpr>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindInvoke:
+        objOP = mp->New<JBCOpInvoke>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindJsr:
+        objOP = mp->New<JBCOpJsr>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindRet:
+        objOP = mp->New<JBCOpRet>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindNew:
+        objOP = mp->New<JBCOpNew>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindMultiANewArray:
+        objOP = mp->New<JBCOpMultiANewArray>(allocator, opcode, kind, wide);
+        break;
+      case kOpKindTypeCheck:
+        objOP = mp->New<JBCOpTypeCheck>(allocator, opcode, kind, wide);
+        break;
+      default:
+        CHECK_NULL_FATAL(objOP);
+        break;
+    }
+    wide = false;
+    success = objOP->ParseFile(io);
+    if (success) {
+      instructions[pc] = objOP;
+    }
+  }
+  return success;
+}
+
+// ---------- JBCAttrStackMapTable ----------
+JBCAttrStackMapTable::JBCAttrStackMapTable(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrStackMapTable, nameIdx, length),
+      count(0),
+      entries(allocator.Adapter()) {}
+
+bool JBCAttrStackMapTable::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  count = io.ReadUInt16(success);
+  for (uint16 i = 0; i < count; i++) {
+    uint8 frameType = io.ReadUInt8();
+    attr::StackMapFrameItem *item = attr::StackMapFrameItem::NewItem(allocator, io, frameType);
+    if (item == nullptr) {
+      return false;
+    }
+    entries.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrStackMapTable::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrStackMapTable::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                    uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrException ----------
+JBCAttrException::JBCAttrException(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrException, nameIdx, length),
+      count(0),
+      tbExceptionIdx(allocator.Adapter()) {}
+
+bool JBCAttrException::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) allocator;
+  (void) constPool;
+  bool success = false;
+  count = io.ReadUInt16(success);
+  for (uint16 i = 0; i < count; i++) {
+    uint16 idx = io.ReadUInt16(success);
+    tbExceptionIdx.push_back(idx);
+  }
+  return success;
+}
+
+bool JBCAttrException::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrException::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrInnerClass ----------
+JBCAttrInnerClass::JBCAttrInnerClass(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrInnerClass, nameIdx, length),
+      count(0),
+      tbClasses(allocator.Adapter()) {}
+
+bool JBCAttrInnerClass::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  count = io.ReadUInt16(success);
+  for (uint16 i = 0; i < count; i++) {
+    attr::InnerClassItem *item = mp->New<attr::InnerClassItem>();
+    success = item->ParseFile(allocator, io);
+    tbClasses.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrInnerClass::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrInnerClass::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                 uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrEnclosingMethod ----------
+JBCAttrEnclosingMethod::JBCAttrEnclosingMethod(const MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrEnclosingMethod, nameIdx, length),
+      classIdx(0),
+      methodIdx(0),
+      constClass(nullptr),
+      constNameAndType(nullptr) {
+  (void) allocator;
+}
+
+JBCAttrEnclosingMethod::~JBCAttrEnclosingMethod() {
+  constClass = nullptr;
+  constNameAndType = nullptr;
+}
+
+bool JBCAttrEnclosingMethod::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) allocator;
+  (void) constPool;
+  bool success = false;
+  classIdx = io.ReadUInt16(success);
+  methodIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCAttrEnclosingMethod::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrEnclosingMethod::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                      uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrSynthetic ----------
+JBCAttrSynthetic::JBCAttrSynthetic(const MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrSynthetic, nameIdx, length) {
+  (void) allocator;
+}
+
+bool JBCAttrSynthetic::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) allocator;
+  (void) io;
+  (void) constPool;
+  return true;
+}
+
+bool JBCAttrSynthetic::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrSynthetic::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrSignature ----------
+JBCAttrSignature::JBCAttrSignature(const MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrSignature, nameIdx, length),
+      signatureIdx(0),
+      constSignatureName(nullptr) {
+  (void) allocator;
+}
+
+JBCAttrSignature::~JBCAttrSignature() {
+  constSignatureName = nullptr;
+}
+
+bool JBCAttrSignature::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) allocator;
+  (void) constPool;
+  bool success = false;
+  signatureIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCAttrSignature::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrSignature::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrSourceFile ----------
+JBCAttrSourceFile::JBCAttrSourceFile(const MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrSourceFile, nameIdx, length),
+      sourceFileIdx(0),
+      constFileName(nullptr) {
+  (void) allocator;
+}
+
+JBCAttrSourceFile::~JBCAttrSourceFile() {
+  constFileName = nullptr;
+}
+
+bool JBCAttrSourceFile::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) allocator;
+  (void) constPool;
+  bool success = false;
+  sourceFileIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCAttrSourceFile::PreProcessImpl(const JBCConstPool &constPool) {
+  const JBCConst *constRaw = constPool.GetConstByIdxWithTag(sourceFileIdx, JBCConstTag::kConstUTF8);
+  if (constRaw == nullptr) {
+    return false;
+  }
+  constFileName = static_cast<const JBCConstUTF8*>(constRaw);
+  return true;
+}
+
+SimpleXMLElem *JBCAttrSourceFile::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                 uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrSourceDebugEx ----------
+JBCAttrSourceDebugEx::JBCAttrSourceDebugEx(const MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrSourceDebugEx, nameIdx, length),
+      data(nullptr) {
+  (void) allocator;
+}
+
+JBCAttrSourceDebugEx::~JBCAttrSourceDebugEx() {
+  data = nullptr;
+}
+
+bool JBCAttrSourceDebugEx::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  bool success = false;
+  (void) constPool;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  if (length > 0) {
+    data = static_cast<char*>(mp->Malloc(length + 1));
+    CHECK_NULL_FATAL(data);
+    io.ReadBufferChar(data, length, success);
+    data[length] = 0;
+  }
+  return success;
+}
+
+bool JBCAttrSourceDebugEx::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrSourceDebugEx::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                    uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrLineNumberTable ----------
+JBCAttrLineNumberTable::JBCAttrLineNumberTable(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrLineNumberTable, nameIdx, length),
+      size(0),
+      lineNums(allocator.Adapter()) {}
+
+bool JBCAttrLineNumberTable::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt16(success);
+  for (uint16 i = 0; i < size && success; i++) {
+    attr::LineNumberTableItem *item = mp->New<attr::LineNumberTableItem>();
+    success = item->ParseFile(allocator, io);
+    lineNums.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrLineNumberTable::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *JBCAttrLineNumberTable::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                      uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrLocalVariableTable ----------
+JBCAttrLocalVariableTable::JBCAttrLocalVariableTable(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrLocalVariableTable, nameIdx, length), size(0), localVarInfos(allocator.Adapter()) {}
+
+bool JBCAttrLocalVariableTable::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io,
+                                              const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt16(success);
+  for (uint16 i = 0; i < size && success; i++) {
+    attr::LocalVariableTableItem *item = mp->New<attr::LocalVariableTableItem>();
+    success = item->ParseFile(allocator, io);
+    localVarInfos.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrLocalVariableTable::PreProcessImpl(const JBCConstPool &constPool) {
+  bool success = true;
+  for (attr::LocalVariableTableItem *info : localVarInfos) {
+    success = success && info->PreProcess(constPool);
+  }
+  return success;
+}
+
+SimpleXMLElem *JBCAttrLocalVariableTable::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                         uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrLocalVariableTypeTable ----------
+JBCAttrLocalVariableTypeTable::JBCAttrLocalVariableTypeTable(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrLocalVariableTypeTable, nameIdx, length), size(0), localVarTypeInfos(allocator.Adapter()) {}
+
+bool JBCAttrLocalVariableTypeTable::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io,
+                                                  const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt16(success);
+  for (uint16 i = 0; i < size && success; i++) {
+    attr::LocalVariableTypeTableItem *item = mp->New<attr::LocalVariableTypeTableItem>();
+    success = item->ParseFile(allocator, io);
+    localVarTypeInfos.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrLocalVariableTypeTable::PreProcessImpl(const JBCConstPool &constPool) {
+  bool success = true;
+  for (attr::LocalVariableTypeTableItem *info : localVarTypeInfos) {
+    success = success && info->PreProcess(constPool);
+  }
+  return success;
+}
+
+SimpleXMLElem *JBCAttrLocalVariableTypeTable::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                             uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrDeprecated ----------
+JBCAttrDeprecated::JBCAttrDeprecated(const MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrDeprecated, nameIdx, length) {
+  (void) allocator;
+}
+
+bool JBCAttrDeprecated::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) allocator;
+  (void) io;
+  (void) constPool;
+  return true;
+}
+
+bool JBCAttrDeprecated::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCAttrDeprecated::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                 uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrRTAnnotations ----------
+JBCAttrRTAnnotations::JBCAttrRTAnnotations(MapleAllocator &allocator, JBCAttrKind kindIn, uint16 nameIdx, uint32 length)
+    : JBCAttr(kindIn, nameIdx, length), size(0), annotations(allocator.Adapter()) {}
+
+bool JBCAttrRTAnnotations::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt16(success);
+  for (uint16 i = 0; i < size && success; i++) {
+    attr::Annotation *item = mp->New<attr::Annotation>(allocator);
+    success = item->ParseFile(allocator, io);
+    annotations.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrRTAnnotations::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCAttrRTAnnotations::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                    uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrRTVisAnnotations ----------
+JBCAttrRTVisAnnotations::JBCAttrRTVisAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttrRTAnnotations(allocator, kAttrRTVisAnnotations, nameIdx, length) {}
+
+// ---------- JBCAttrRTInvisAnnotations ----------
+JBCAttrRTInvisAnnotations::JBCAttrRTInvisAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttrRTAnnotations(allocator, kAttrRTInvisAnnotations, nameIdx, length) {}
+
+// ---------- JBCAttrRTParamAnnotations ----------
+JBCAttrRTParamAnnotations::JBCAttrRTParamAnnotations(MapleAllocator &allocator, JBCAttrKind kindIn, uint16 nameIdx,
+                                                     uint32 length)
+    : JBCAttr(kindIn, nameIdx, length), size(0), annotations(allocator.Adapter()) {}
+
+bool JBCAttrRTParamAnnotations::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io,
+                                              const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt8(success);
+  for (uint16 i = 0; i < size && success; i++) {
+    attr::ParamAnnotationItem *item = mp->New<attr::ParamAnnotationItem>(allocator);
+    success = item->ParseFile(allocator, io);
+    annotations.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrRTParamAnnotations::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCAttrRTParamAnnotations::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                         uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrRTVisParamAnnotations ----------
+JBCAttrRTVisParamAnnotations::JBCAttrRTVisParamAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttrRTParamAnnotations(allocator, kAttrRTVisParamAnnotations, nameIdx, length) {}
+
+// ---------- JBCAttrRTInvisParamAnnotations ----------
+JBCAttrRTInvisParamAnnotations::JBCAttrRTInvisParamAnnotations(MapleAllocator &allocator, uint16 nameIdx,
+                                                               uint32 length)
+    : JBCAttrRTParamAnnotations(allocator, kAttrRTInvisParamAnnotations, nameIdx, length) {}
+
+// ---------- JBCAttrRTTypeAnnotations ----------
+JBCAttrRTTypeAnnotations::JBCAttrRTTypeAnnotations(MapleAllocator &allocator, JBCAttrKind kindIn, uint16 nameIdx,
+                                                   uint32 length)
+    : JBCAttr(kindIn, nameIdx, length), size(0), annotations(allocator.Adapter()) {}
+
+bool JBCAttrRTTypeAnnotations::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io,
+                                             const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt16(success);
+  for (uint16 i = 0; i < size && success; i++) {
+    attr::TypeAnnotationItem *item = mp->New<attr::TypeAnnotationItem>(allocator);
+    success = item->ParseFile(allocator, io);
+    annotations.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrRTTypeAnnotations::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCAttrRTTypeAnnotations::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                        uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrRTVisTypeAnnotations ----------
+JBCAttrRTVisTypeAnnotations::JBCAttrRTVisTypeAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttrRTTypeAnnotations(allocator, kAttrRTVisTypeAnnotations, nameIdx, length) {}
+
+// ---------- JBCAttrRTInvisTypeAnnotations ----------
+JBCAttrRTInvisTypeAnnotations::JBCAttrRTInvisTypeAnnotations(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttrRTTypeAnnotations(allocator, kAttrRTInvisTypeAnnotations, nameIdx, length) {}
+
+// ---------- JBCAttrAnnotationDefault ----------
+JBCAttrAnnotationDefault::JBCAttrAnnotationDefault(const MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrAnnotationDefault, nameIdx, length), value(nullptr) {
+  (void) allocator;
+}
+
+JBCAttrAnnotationDefault::~JBCAttrAnnotationDefault() {
+  value = nullptr;
+}
+
+bool JBCAttrAnnotationDefault::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io,
+                                             const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  value = mp->New<attr::ElementValue>();
+  success = value->ParseFile(allocator, io);
+  return success;
+}
+
+bool JBCAttrAnnotationDefault::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCAttrAnnotationDefault::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                        uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrBootstrapMethods ----------
+JBCAttrBootstrapMethods::JBCAttrBootstrapMethods(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrBootstrapMethods, nameIdx, length), size(0), methods(allocator.Adapter()) {}
+
+bool JBCAttrBootstrapMethods::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt16(success);
+  for (uint16 i = 0; i < size && success; i++) {
+    attr::BootstrapMethodItem *item = mp->New<attr::BootstrapMethodItem>(allocator);
+    success = item->ParseFile(allocator, io);
+    methods.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrBootstrapMethods::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCAttrBootstrapMethods::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                       uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCAttrMethodParameters ----------
+JBCAttrMethodParameters::JBCAttrMethodParameters(MapleAllocator &allocator, uint16 nameIdx, uint32 length)
+    : JBCAttr(kAttrMethodParameters, nameIdx, length), size(0), params(allocator.Adapter()) {}
+
+bool JBCAttrMethodParameters::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  (void) constPool;
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt8(success);
+  for (uint8 i = 0; i < size && success; i++) {
+    attr::MethodParamItem *item = mp->New<attr::MethodParamItem>();
+    success = item->ParseFile(allocator, io);
+    params.push_back(item);
+  }
+  return success;
+}
+
+bool JBCAttrMethodParameters::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCAttrMethodParameters::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                       uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+}  // namespace jbc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_attr_item.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_attr_item.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..045b3bce202e3e24e8e0e51fc872cf73f23f35f3
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_attr_item.cpp
@@ -0,0 +1,1457 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_attr_item.h"
+#include "fe_manager.h"
+
+namespace maple {
+namespace jbc {
+namespace attr {
+inline GStrIdx GetOrCreateGStrIdx(const std::string &str) {
+  return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
+}
+
+inline GStrIdx GetOrCreateGStrIdxWithMangler(const std::string &str) {
+  return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(str));
+}
+
+// ---------- ExceptionTableItem ----------
+ExceptionTableItem::ExceptionTableItem() : startPC(0), endPC(0), handlerPC(0), catchTypeIdx(0), catchType(nullptr) {}
+
+ExceptionTableItem::~ExceptionTableItem() {
+  catchType = nullptr;
+}
+
+bool ExceptionTableItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  startPC = io.ReadUInt16(success);
+  endPC = io.ReadUInt16(success);
+  handlerPC = io.ReadUInt16(success);
+  catchTypeIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool ExceptionTableItem::PreProcessImpl(const JBCConstPool &constPool) {
+  if (catchTypeIdx == 0) {
+    return true;
+  }
+  const JBCConst *constRaw = constPool.GetConstByIdxWithTag(catchTypeIdx, kConstClass);
+  if (constRaw == nullptr) {
+    catchType = nullptr;
+    return false;
+  } else {
+    catchType = static_cast<const JBCConstClass*>(constRaw);
+    return true;
+  }
+}
+
+SimpleXMLElem *ExceptionTableItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                  uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- VerificationTypeInfo ----------
+std::map<VerificationTypeInfoTag, std::string> VerificationTypeInfo::tagNameMap =
+    VerificationTypeInfo::InitTagNameMap();
+
+VerificationTypeInfo::VerificationTypeInfo()
+    : tag(kVerTypeInfoItemUnknown),
+      classInfo(nullptr) {
+  data.raw = 0;
+}
+
+VerificationTypeInfo::~VerificationTypeInfo() {
+  classInfo = nullptr;
+}
+
+bool VerificationTypeInfo::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  uint8 t = io.ReadUInt8(success);
+  tag = static_cast<VerificationTypeInfoTag>(t);
+  switch (t) {
+    case kVerTypeInfoItemTop:
+    case kVerTypeInfoItemInteger:
+    case kVerTypeInfoItemFloat:
+    case kVerTypeInfoItemDouble:
+    case kVerTypeInfoItemLong:
+    case kVerTypeInfoItemNull:
+    case kVerTypeInfoItemUninitializedThis:
+      break;
+    case kVerTypeInfoItemObject:
+      data.cpoolIdx = io.ReadUInt16(success);
+      break;
+    case kVerTypeInfoItemUninitialized:
+      data.offset = io.ReadUInt16(success);
+      break;
+    default:
+      ERR(kLncErr, "undefined tag %d for verification_type_info", tag);
+      return false;
+  }
+  return success;
+}
+
+bool VerificationTypeInfo::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *VerificationTypeInfo::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                    uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+std::map<VerificationTypeInfoTag, std::string> VerificationTypeInfo::InitTagNameMap() {
+  std::map<VerificationTypeInfoTag, std::string> result;
+  result[kVerTypeInfoItemTop] = "ITEM_Top";
+  result[kVerTypeInfoItemInteger] = "ITEM_Integer";
+  result[kVerTypeInfoItemFloat] = "ITEM_Float";
+  result[kVerTypeInfoItemDouble] = "ITEM_Double";
+  result[kVerTypeInfoItemLong] = "ITEM_Long";
+  result[kVerTypeInfoItemNull] = "ITEM_Null";
+  result[kVerTypeInfoItemUninitializedThis] = "ITEM_UninitializedThis";
+  result[kVerTypeInfoItemObject] = "ITEM_Object";
+  result[kVerTypeInfoItemUninitialized] = "ITEM_Uninitialized";
+  return result;
+}
+
+std::string VerificationTypeInfo::TagName(VerificationTypeInfoTag t) {
+  std::map<VerificationTypeInfoTag, std::string>::const_iterator it = tagNameMap.find(t);
+  if (it != tagNameMap.end()) {
+    return it->second;
+  }
+  return "ITEM_Unknown";
+}
+
+// ---------- StackMapFrameItem ----------
+std::map<StackMapFrameItemTag, std::string> StackMapFrameItem::tagNameMap = StackMapFrameItem::InitTagName();
+
+StackMapFrameItem::StackMapFrameItem(uint8 frameTypeIn, StackMapFrameItemTag tagIn)
+    : tag(tagIn), frameType(frameTypeIn) {}
+
+std::map<StackMapFrameItemTag, std::string> StackMapFrameItem::InitTagName() {
+  std::map<StackMapFrameItemTag, std::string> result;
+  result[kStackSame] = "SAME";
+  result[kStackSameLocals1StackItem] = "SAME_LOCALS_1_STACK_ITEM";
+  result[kStackSameLocals1StackItemEx] = "SAME_LOCALS_1_STACK_ITEM_EXTENDED";
+  result[kStackChop] = "CHOP";
+  result[kStackSameFrameEx] = "SAME_FRAME_EXTENDED";
+  result[kStackAppend] = "APPEND";
+  result[kStackFullFrame] = "FULL_FRAME";
+  result[kStackReserved] = "RESERVED";
+  return result;
+}
+
+std::string StackMapFrameItem::TagName(StackMapFrameItemTag tag) {
+  std::map<StackMapFrameItemTag, std::string>::const_iterator it = tagNameMap.find(tag);
+  if (it != tagNameMap.end()) {
+    return it->second;
+  }
+  return "UNKNOWN";
+}
+
+StackMapFrameItemTag StackMapFrameItem::FrameType2Tag(uint8 frameType) {
+  // frame type tag : 64, 128, 247, 251, 255
+  if (frameType < 64) {
+    return kStackSame;
+  } else if (frameType < 128) {
+    return kStackSameLocals1StackItem;
+  } else if (frameType < 247) {
+    ERR(kLncErr, "Reserved frametype %d for stack_map_frame", frameType);
+    return kStackReserved;
+  } else if (frameType == 247) {
+    return kStackSameLocals1StackItemEx;
+  } else if (frameType < 251) {
+    return kStackChop;
+  } else if (frameType < 255) {
+    return kStackAppend;
+  } else {
+    return kStackFullFrame;
+  }
+}
+
+StackMapFrameItem *StackMapFrameItem::NewItem(MapleAllocator &allocator, BasicIORead &io, uint8 frameType) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  StackMapFrameItem *item = nullptr;
+  StackMapFrameItemTag tag = StackMapFrameItem::FrameType2Tag(frameType);
+  switch (tag) {
+    case kStackSame:
+      item = mp->New<StackMapFrameItemSame>(frameType);
+      break;
+    case kStackSameLocals1StackItem:
+      item = mp->New<StackMapFrameItemSameLocals1>(frameType);
+      break;
+    case kStackSameLocals1StackItemEx:
+      item = mp->New<StackMapFrameItemSameLocals1Ex>(frameType);
+      break;
+    case kStackChop:
+      item = mp->New<StackMapFrameItemChop>(frameType);
+      break;
+    case kStackSameFrameEx:
+      item = mp->New<StackMapFrameItemSameEx>(frameType);
+      break;
+    case kStackAppend:
+      item = mp->New<StackMapFrameItemAppend>(allocator, frameType);
+      break;
+    case kStackFullFrame:
+      item = mp->New<StackMapFrameItemFull>(allocator, frameType);
+      break;
+    default:
+      CHECK_FATAL(false, "Should not run here");
+  }
+  if (!item->ParseFile(allocator, io)) {
+    CHECK_FATAL(false, "Failed to new StackMapFrame item");
+    return nullptr;
+  }
+  return item;
+}
+
+// ---------- StackMapFrameItemSame ----------
+StackMapFrameItemSame::StackMapFrameItemSame(uint8 frameType) : StackMapFrameItem(frameType, kStackSame) {}
+
+bool StackMapFrameItemSame::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  (void) io;
+  return true;
+}
+
+bool StackMapFrameItemSame::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *StackMapFrameItemSame::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                     uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- StackMapFrameItemSameLocals1 ----------
+StackMapFrameItemSameLocals1::StackMapFrameItemSameLocals1(uint8 frameType)
+    : StackMapFrameItem(frameType, kStackSameLocals1StackItem),
+      stack(nullptr) {}
+
+StackMapFrameItemSameLocals1::~StackMapFrameItemSameLocals1() {
+  stack = nullptr;
+}
+
+bool StackMapFrameItemSameLocals1::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  stack = mp->New<VerificationTypeInfo>();
+  return stack->ParseFile(allocator, io);
+}
+
+bool StackMapFrameItemSameLocals1::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *StackMapFrameItemSameLocals1::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                            uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- StackMapFrameItemSameLocals1Ex ----------
+StackMapFrameItemSameLocals1Ex::StackMapFrameItemSameLocals1Ex(uint8 frameType)
+    : StackMapFrameItem(frameType, kStackSameLocals1StackItemEx),
+      offsetDelta(0),
+      stack(nullptr) {}
+
+StackMapFrameItemSameLocals1Ex::~StackMapFrameItemSameLocals1Ex() {
+  stack = nullptr;
+}
+
+bool StackMapFrameItemSameLocals1Ex::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  offsetDelta = io.ReadUInt16(success);
+  stack = mp->New<VerificationTypeInfo>();
+  success = stack->ParseFile(allocator, io);
+  return success;
+}
+
+bool StackMapFrameItemSameLocals1Ex::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *StackMapFrameItemSameLocals1Ex::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                              uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- StackMapFrameItemChop ----------
+StackMapFrameItemChop::StackMapFrameItemChop(uint8 frameType)
+    : StackMapFrameItem(frameType, kStackChop),
+      offsetDelta(0) {}
+
+bool StackMapFrameItemChop::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  offsetDelta = io.ReadUInt16(success);
+  return success;
+}
+
+bool StackMapFrameItemChop::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *StackMapFrameItemChop::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                     uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- StackMapFrameItemSameEx ----------
+StackMapFrameItemSameEx::StackMapFrameItemSameEx(uint8 frameType)
+    : StackMapFrameItem(frameType, kStackSameFrameEx),
+      offsetDelta(0) {}
+
+bool StackMapFrameItemSameEx::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  offsetDelta = io.ReadUInt16(success);
+  return success;
+}
+
+bool StackMapFrameItemSameEx::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *StackMapFrameItemSameEx::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                       uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- StackMapFrameItemAppend ----------
+StackMapFrameItemAppend::StackMapFrameItemAppend(MapleAllocator &allocator, uint8 frameType)
+    : StackMapFrameItem(frameType, kStackAppend),
+      offsetDelta(0),
+      locals(allocator.Adapter()) {}
+
+bool StackMapFrameItemAppend::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  offsetDelta = io.ReadUInt16(success);
+  for (uint8 i = 0; i < frameType - 251; i++) { // 251 : frame type tag
+    VerificationTypeInfo *local = mp->New<VerificationTypeInfo>();
+    success = local->ParseFile(allocator, io);
+    locals.push_back(local);
+  }
+  return success;
+}
+
+bool StackMapFrameItemAppend::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *StackMapFrameItemAppend::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                       uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- StackMapFrameItemFull ----------
+StackMapFrameItemFull::StackMapFrameItemFull(MapleAllocator &allocator, uint8 frameType)
+    : StackMapFrameItem(frameType, kStackFullFrame),
+      offsetDelta(0),
+      nLocals(0),
+      locals(allocator.Adapter()),
+      nStacks(0),
+      stacks(allocator.Adapter()) {}
+
+bool StackMapFrameItemFull::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  offsetDelta = io.ReadUInt16(success);
+  nLocals = io.ReadUInt16(success);
+  for (uint32 i = 0; i < nLocals; i++) {
+    VerificationTypeInfo *local = mp->New<VerificationTypeInfo>();
+    success = local->ParseFile(allocator, io);
+    locals.push_back(local);
+  }
+  nStacks = io.ReadUInt16(success);
+  for (uint32 i = 0; i < nStacks; i++) {
+    VerificationTypeInfo *stack = mp->New<VerificationTypeInfo>();
+    success = stack->ParseFile(allocator, io);
+    stacks.push_back(stack);
+  }
+  return success;
+}
+
+bool StackMapFrameItemFull::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *StackMapFrameItemFull::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                     uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- InnerClassItem ----------
+InnerClassItem::InnerClassItem()
+    : innerClassInfoIdx(0),
+      outerClassInfoIdx(0),
+      innerNameIdx(0),
+      innerClassAccessFlag(0),
+      constClassInner(nullptr),
+      constClassOuter(nullptr),
+      constNameInner(nullptr) {}
+
+InnerClassItem::~InnerClassItem() {
+  constClassInner = nullptr;
+  constClassOuter = nullptr;
+  constNameInner = nullptr;
+}
+
+bool InnerClassItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  innerClassInfoIdx = io.ReadUInt16(success);
+  outerClassInfoIdx = io.ReadUInt16(success);
+  innerNameIdx = io.ReadUInt16(success);
+  innerClassAccessFlag = io.ReadUInt16(success);
+  return success;
+}
+
+bool InnerClassItem::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *InnerClassItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                              uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- LineNumberTableItem ----------
+LineNumberTableItem::LineNumberTableItem() : startPC(0), lineNumber(0) {}
+
+bool LineNumberTableItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  startPC = io.ReadUInt16(success);
+  lineNumber = io.ReadUInt16(success);
+  return success;
+}
+
+bool LineNumberTableItem::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *LineNumberTableItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                   uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- LocalVariableTableItem ----------
+LocalVariableTableItem::LocalVariableTableItem()
+    : startPC(0),
+      length(0),
+      nameIdx(0),
+      descIdx(0),
+      index(0),
+      constName(nullptr),
+      constDesc(nullptr),
+      nameIdxMpl(0),
+      feirType(nullptr) {}
+
+LocalVariableTableItem::~LocalVariableTableItem() {
+  constName = nullptr;
+  constDesc = nullptr;
+  feirType = nullptr;
+}
+
+bool LocalVariableTableItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  startPC = io.ReadUInt16(success);
+  length = io.ReadUInt16(success);
+  nameIdx = io.ReadUInt16(success);
+  descIdx = io.ReadUInt16(success);
+  index = io.ReadUInt16(success);
+  return success;
+}
+
+bool LocalVariableTableItem::PreProcessImpl(const JBCConstPool &constPool) {
+  constName = static_cast<const JBCConstUTF8*>(constPool.GetConstByIdxWithTag(nameIdx, JBCConstTag::kConstUTF8));
+  constDesc = static_cast<const JBCConstUTF8*>(constPool.GetConstByIdxWithTag(descIdx, JBCConstTag::kConstUTF8));
+  if (constName == nullptr || constDesc == nullptr) {
+    return false;
+  }
+  nameIdxMpl = GetOrCreateGStrIdx(constName->GetString());
+  feirType = FEManager::GetTypeManager().GetOrCreateFEIRTypeByName(namemangler::EncodeName(constDesc->GetString()),
+                                                                   GStrIdx(0), kSrcLangJava);
+  return true;
+}
+
+SimpleXMLElem *LocalVariableTableItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                      uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- LocalVariableTypeTableItem ----------
+LocalVariableTypeTableItem::LocalVariableTypeTableItem()
+    : startPC(0),
+      length(0),
+      nameIdx(0),
+      signatureIdx(0),
+      index(0),
+      constName(nullptr),
+      constSignature(nullptr),
+      nameIdxMpl(0) {}
+
+LocalVariableTypeTableItem::~LocalVariableTypeTableItem() {
+  constName = nullptr;
+  constSignature = nullptr;
+}
+
+bool LocalVariableTypeTableItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  startPC = io.ReadUInt16(success);
+  length = io.ReadUInt16(success);
+  nameIdx = io.ReadUInt16(success);
+  signatureIdx = io.ReadUInt16(success);
+  index = io.ReadUInt16(success);
+  return success;
+}
+
+bool LocalVariableTypeTableItem::PreProcessImpl(const JBCConstPool &constPool) {
+  constName = static_cast<const JBCConstUTF8*>(constPool.GetConstByIdxWithTag(nameIdx, JBCConstTag::kConstUTF8));
+  constSignature =
+      static_cast<const JBCConstUTF8*>(constPool.GetConstByIdxWithTag(signatureIdx, JBCConstTag::kConstUTF8));
+  if (constName == nullptr || constSignature == nullptr) {
+    return false;
+  }
+  nameIdxMpl = GetOrCreateGStrIdx(constName->GetString());
+  return true;
+}
+
+SimpleXMLElem *LocalVariableTypeTableItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                          uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- ParamAnnotationItem ----------
+ParamAnnotationItem::ParamAnnotationItem(MapleAllocator &allocator)
+    : count(0), annotations(allocator.Adapter()) {}
+
+bool ParamAnnotationItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  count = io.ReadUInt16(success);
+  for (uint16 i = 0; i < count; i++) {
+    Annotation *anno = mp->New<Annotation>(allocator);
+    success = anno->ParseFile(allocator, io);
+    annotations.push_back(anno);
+  }
+  return success;
+}
+
+bool ParamAnnotationItem::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *ParamAnnotationItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                   uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- BootstrapMethodItem ----------
+BootstrapMethodItem::BootstrapMethodItem(MapleAllocator &allocator)
+    : methodRefIdx(0),
+      nArgs(0),
+      argsIdx(allocator.Adapter()),
+      methodHandle(nullptr),
+      args(allocator.Adapter()) {}
+
+BootstrapMethodItem::~BootstrapMethodItem() {
+  methodHandle = nullptr;
+}
+
+bool BootstrapMethodItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  methodRefIdx = io.ReadUInt16(success);
+  nArgs = io.ReadUInt16(success);
+  for (uint16 i = 0; i < nArgs; i++) {
+    uint16 idx = io.ReadUInt16(success);
+    argsIdx.push_back(idx);
+  }
+  return success;
+}
+
+bool BootstrapMethodItem::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *BootstrapMethodItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                   uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- MethodParamItem ----------
+MethodParamItem::MethodParamItem()
+    : nameIdx(0), accessFlag(0), constName(nullptr) {}
+
+MethodParamItem::~MethodParamItem() {
+  constName = nullptr;
+}
+
+bool MethodParamItem::MethodParamItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  nameIdx = io.ReadUInt16(success);
+  accessFlag = io.ReadUInt16(success);
+  return success;
+}
+
+bool MethodParamItem::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *MethodParamItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                               uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- Annotation ----------
+Annotation::Annotation(MapleAllocator &allocator)
+    : typeIdx(0), nElemPairs(0), tbElemPairs(allocator.Adapter()), constTypeName(nullptr) {}
+
+Annotation::~Annotation() {
+  constTypeName = nullptr;
+}
+
+bool Annotation::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  typeIdx = io.ReadUInt16(success);
+  nElemPairs = io.ReadUInt16(success);
+  for (uint16 i = 0; i < nElemPairs; i++) {
+    ElementValuePair *pair = mp->New<ElementValuePair>();
+    success = pair->ParseFile(allocator, io);
+    tbElemPairs.push_back(pair);
+  }
+  return success;
+}
+
+bool Annotation::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *Annotation::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- ElementValueItem ----------
+std::map<char, ElementValueKind> ElementValueItem::tagKindMap = ElementValueItem::InitTagKindMap();
+std::map<ElementValueKind, std::string> ElementValueItem::kindNameMap = ElementValueItem::InitKindNameMap();
+
+ElementValueItem::ElementValueItem(ElementValueKind kindIn, char tagIn) : kind(kindIn), tag(tagIn) {}
+
+std::map<char, ElementValueKind> ElementValueItem::InitTagKindMap() {
+  std::map<char, ElementValueKind> result;
+  result['B'] = kElementValueConst;
+  result['C'] = kElementValueConst;
+  result['D'] = kElementValueConst;
+  result['F'] = kElementValueConst;
+  result['I'] = kElementValueConst;
+  result['J'] = kElementValueConst;
+  result['S'] = kElementValueConst;
+  result['Z'] = kElementValueConst;
+  result['s'] = kElementValueConst;
+  result['e'] = kElementValueEnum;
+  result['c'] = kElementValueClassInfo;
+  result['@'] = kElementValueAnnotation;
+  result['['] = kElementValueArray;
+  return result;
+}
+
+std::map<ElementValueKind, std::string> ElementValueItem::InitKindNameMap() {
+  std::map<ElementValueKind, std::string> result;
+  result[kElementValueConst] = "ElementValueConst";
+  result[kElementValueEnum] = "ElementValueEnum";
+  result[kElementValueClassInfo] = "ElementValueClassInfo";
+  result[kElementValueAnnotation] = "ElementValueAnnotation";
+  result[kElementValueArray] = "ElementValueArray";
+  return result;
+}
+
+std::string ElementValueItem::KindName(ElementValueKind kind) {
+  std::map<ElementValueKind, std::string>::const_iterator it = kindNameMap.find(kind);
+  if (it != kindNameMap.end()) {
+    return it->second;
+  }
+  return "Unknown";
+}
+
+ElementValueKind ElementValueItem::TagToKind(char tag) {
+  std::map<char, ElementValueKind>::const_iterator it = tagKindMap.find(tag);
+  if (it != tagKindMap.end()) {
+    return it->second;
+  }
+  return kElementValueDefault;
+}
+
+ElementValueItem *ElementValueItem::NewItem(MapleAllocator &allocator, BasicIORead &io, char tag) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  ElementValueKind kind = ElementValueItem::TagToKind(tag);
+  ElementValueItem *item = nullptr;
+  switch (kind) {
+    case kElementValueConst:
+      item = mp->New<ElementValueConst>(tag);
+      break;
+    case kElementValueEnum:
+      item = mp->New<ElementValueEnum>();
+      break;
+    case kElementValueClassInfo:
+      item = mp->New<ElementValueClassInfo>();
+      break;
+    case kElementValueAnnotation:
+      item = mp->New<ElementValueAnnotation>();
+      break;
+    case kElementValueArray:
+      item = mp->New<ElementValueArray>(allocator);
+      break;
+    default:
+      ERR(kLncErr, "unsupported kind");
+      return nullptr;
+  }
+  if (item->ParseFile(allocator, io) == false) {
+    return nullptr;
+  }
+  return item;
+}
+
+// ---------- ElementValueConst ----------
+ElementValueConst::ElementValueConst(uint8 t)
+    : ElementValueItem(kElementValueConst, t), constValueIdx(0), constValue(nullptr) {}
+
+ElementValueConst::~ElementValueConst() {
+  constValue = nullptr;
+}
+
+bool ElementValueConst::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  constValueIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool ElementValueConst::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *ElementValueConst::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                 uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- ElementValueEnum ----------
+ElementValueEnum::ElementValueEnum()
+    : ElementValueItem(kElementValueEnum, 'e'),
+      typeNameIdx(0),
+      constNameIdx(0),
+      constTypeName(nullptr),
+      constName(nullptr) {}
+
+ElementValueEnum::~ElementValueEnum() {
+  constTypeName = nullptr;
+  constName = nullptr;
+}
+
+bool ElementValueEnum::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  typeNameIdx = io.ReadUInt16(success);
+  constNameIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool ElementValueEnum::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *ElementValueEnum::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- ElementValueClassInfo ----------
+ElementValueClassInfo::ElementValueClassInfo()
+    : ElementValueItem(kElementValueClassInfo, 'c'),
+      classInfoIdx(0),
+      constClassInfo(nullptr) {}
+
+ElementValueClassInfo::~ElementValueClassInfo() {
+  constClassInfo = nullptr;
+}
+
+bool ElementValueClassInfo::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  classInfoIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool ElementValueClassInfo::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *ElementValueClassInfo::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                     uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- ElementValueAnnotation ----------
+ElementValueAnnotation::ElementValueAnnotation()
+    : ElementValueItem(kElementValueAnnotation, '@'), annotation(nullptr) {}
+
+ElementValueAnnotation::~ElementValueAnnotation() {
+  annotation = nullptr;
+}
+
+bool ElementValueAnnotation::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  annotation = mp->New<Annotation>(allocator);
+  return annotation->ParseFile(allocator, io);
+}
+
+bool ElementValueAnnotation::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *ElementValueAnnotation::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                      uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- ElementValueArray ----------
+ElementValueArray::ElementValueArray(MapleAllocator &allocator)
+    : ElementValueItem(kElementValueArray, '['), size(0), values(allocator.Adapter()) {}
+
+bool ElementValueArray::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt16(success);
+  for (uint16 i = 0; i < size; i++) {
+    ElementValue *elem = mp->New<ElementValue>();
+    success = elem->ParseFile(allocator, io);
+    values.push_back(elem);
+  }
+  return success;
+}
+
+bool ElementValueArray::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *ElementValueArray::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                 uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- ElementValue ----------
+ElementValue::ElementValue()
+    : tag('\0'), kind(kElementValueDefault), value(nullptr) {}
+
+ElementValue::~ElementValue() {
+  value = nullptr;
+}
+
+bool ElementValue::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  tag = io.ReadChar(success);
+  value = ElementValueItem::NewItem(allocator, io, tag);
+  return success && value != nullptr;
+}
+
+bool ElementValue::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return false;
+}
+
+SimpleXMLElem *ElementValue::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                            uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- ElementValuePair ----------
+ElementValuePair::ElementValuePair()
+    : nameIdx(0), value(nullptr) {}
+
+ElementValuePair::~ElementValuePair() {
+  value = nullptr;
+}
+
+bool ElementValuePair::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  nameIdx = io.ReadUInt16(success);
+  value = mp->New<ElementValue>();
+  return (success && value->ParseFile(allocator, io));
+}
+
+bool ElementValuePair::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *ElementValuePair::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetInfoItem ----------
+std::map<TargetInfoItemType, TargetInfoItemTag> TargetInfoItem::typeTagMap = TargetInfoItem::InitTypeTagMap();
+
+TargetInfoItem::TargetInfoItem(TargetInfoItemTag tagIn) : tag(tagIn) {}
+
+std::map<TargetInfoItemType, TargetInfoItemTag> TargetInfoItem::InitTypeTagMap() {
+  std::map<TargetInfoItemType, TargetInfoItemTag> result;
+  result[kTargetTypeParamClass] = kTargetTagTypeParam;
+  result[kTargetTypeParamMethod] = kTargetTagTypeParam;
+  result[kTargetTypeHierarchy] = kTargetTagSuperType;
+  result[kTargetTypeBoundClass] = kTargetTagTypeParamBound;
+  result[kTargetTypeBoundMethod] = kTargetTagTypeParamBound;
+  result[kTargetTypeFieldDecl] = kTargetTagEmpty;
+  result[kTargetTypeReturn] = kTargetTagEmpty;
+  result[kTargetTypeReceiver] = kTargetTagEmpty;
+  result[kTargetTypeFormal] = kTargetTagFormalParam;
+  result[kTargetTypeThrows] = kTargetTagThrows;
+  result[kTargetTypeLocalVar] = kTargetTagLocalVar;
+  result[kTargetTypeResourceVar] = kTargetTagLocalVar;
+  result[kTargetTypeExpectionParam] = kTargetTagCatch;
+  result[kTargetTypeInstanceof] = kTargetTagOffset;
+  result[kTargetTypeNew] = kTargetTagOffset;
+  result[kTargetTypeMethodRefNew] = kTargetTagOffset;
+  result[kTargetTypeMethodRefIdentifier] = kTargetTagOffset;
+  result[kTargetTypeCast] = kTargetTagTypeArg;
+  result[kTargetTypeConstructorInvoke] = kTargetTagTypeArg;
+  result[kTargetTypeMethodInvoke] = kTargetTagTypeArg;
+  result[kTargetTypeConstructorNew] = kTargetTagTypeArg;
+  result[kTargetTypeConstructorIdentifier] = kTargetTagTypeArg;
+  return result;
+}
+
+TargetInfoItemTag TargetInfoItem::TargetType2Tag(TargetInfoItemType type) {
+  std::map<TargetInfoItemType, TargetInfoItemTag>::const_iterator it = typeTagMap.find(type);
+  if (it != typeTagMap.end()) {
+    return it->second;
+  }
+  return kTargetTagUndefine;
+}
+
+TargetInfoItem *TargetInfoItem::NewItem(MapleAllocator &allocator, BasicIORead &io, TargetInfoItemType targetType) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  TargetInfoItemTag tag = TargetInfoItem::TargetType2Tag(targetType);
+  TargetInfoItem *item = nullptr;
+  switch (tag) {
+    case kTargetTagTypeParam:
+      item = mp->New<TargetTypeParam>();
+      break;
+    case kTargetTagSuperType:
+      item = mp->New<TargetSuperType>();
+      break;
+    case kTargetTagTypeParamBound:
+      item = mp->New<TargetTypeParamBound>();
+      break;
+    case kTargetTagEmpty:
+      item = mp->New<TargetEmpty>();
+      break;
+    case kTargetTagFormalParam:
+      item = mp->New<TargetFormalParam>();
+      break;
+    case kTargetTagThrows:
+      item = mp->New<TargetThrows>();
+      break;
+    case kTargetTagLocalVar:
+      item = mp->New<TargetLocalVar>(allocator);
+      break;
+    case kTargetTagCatch:
+      item = mp->New<TargetCatch>();
+      break;
+    case kTargetTagOffset:
+      item = mp->New<TargetOffset>();
+      break;
+    case kTargetTagTypeArg:
+      item = mp->New<TargetTypeArg>();
+      break;
+    default:
+      ERR(kLncErr, "TargetInfoItem::NewItem(): undefined tag");
+      return nullptr;
+  }
+  if (item->ParseFile(allocator, io) == false) {
+    return nullptr;
+  }
+  return item;
+}
+
+// ---------- TargetTypeParam ----------
+TargetTypeParam::TargetTypeParam() : TargetInfoItem(kTargetTagTypeParam), paramIdx(0) {}
+
+bool TargetTypeParam::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  paramIdx = io.ReadUInt8(success);
+  return success;
+}
+
+bool TargetTypeParam::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetTypeParam::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                               uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetSuperType ----------
+TargetSuperType::TargetSuperType() : TargetInfoItem(kTargetTagSuperType), index(0) {}
+
+bool TargetSuperType::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  index = io.ReadUInt16(success);
+  return success;
+}
+
+bool TargetSuperType::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetSuperType::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                               uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetTypeParamBound ----------
+TargetTypeParamBound::TargetTypeParamBound() : TargetInfoItem(kTargetTagTypeParamBound), paramIdx(0), boundIdx(0) {}
+
+bool TargetTypeParamBound::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  paramIdx = io.ReadUInt8(success);
+  boundIdx = io.ReadUInt8(success);
+  return success;
+}
+
+bool TargetTypeParamBound::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetTypeParamBound::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                    uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetEmpty ----------
+TargetEmpty::TargetEmpty() : TargetInfoItem(kTargetTagEmpty) {}
+
+bool TargetEmpty::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  (void) io;
+  return true;
+}
+
+bool TargetEmpty::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetEmpty::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetFormalParam ----------
+TargetFormalParam::TargetFormalParam() : TargetInfoItem(kTargetTagFormalParam), paramIdx(0) {}
+
+bool TargetFormalParam::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  paramIdx = io.ReadUInt8(success);
+  return success;
+}
+
+bool TargetFormalParam::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetFormalParam::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                 uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetThrows ----------
+TargetThrows::TargetThrows() : TargetInfoItem(kTargetTagThrows), typeIdx(0) {}
+
+bool TargetThrows::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  typeIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool TargetThrows::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetThrows::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                            uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetLocalVarItem ----------
+TargetLocalVarItem::TargetLocalVarItem() : TargetInfoItem(kTargetTagLocalVar), startPC(0), length(0), index(0) {}
+
+bool TargetLocalVarItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  startPC = io.ReadUInt16(success);
+  length = io.ReadUInt16(success);
+  index = io.ReadUInt16(success);
+  return success;
+}
+bool TargetLocalVarItem::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetLocalVarItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                  uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetLocalVar ----------
+TargetLocalVar::TargetLocalVar(MapleAllocator &allocator)
+    : TargetInfoItem(kTargetTagLocalVar), size(0), table(allocator.Adapter()) {}
+
+bool TargetLocalVar::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  size = io.ReadUInt16(success);
+  for (uint16 i = 0; i < size; i++) {
+    TargetLocalVarItem *item = mp->New<TargetLocalVarItem>();
+    success = item->ParseFile(allocator, io);
+    table.push_back(item);
+  }
+  return success;
+}
+
+bool TargetLocalVar::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetLocalVar::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                              uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetCatch ----------
+TargetCatch::TargetCatch() : TargetInfoItem(kTargetTagCatch), exTableIdx(0) {}
+
+bool TargetCatch::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  exTableIdx = io.ReadUInt16(success);
+  return true;
+}
+
+bool TargetCatch::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetCatch::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetOffset ----------
+TargetOffset::TargetOffset() : TargetInfoItem(kTargetTagOffset), offset(0) {}
+
+bool TargetOffset::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  offset = io.ReadUInt16(success);
+  return success;
+}
+
+bool TargetOffset::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetOffset::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                            uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TargetTypeArg ----------
+TargetTypeArg::TargetTypeArg() : TargetInfoItem(kTargetTagTypeArg), offset(0), typeArgIdx(0) {}
+
+bool TargetTypeArg::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  offset = io.ReadUInt16(success);
+  typeArgIdx = io.ReadUInt8(success);
+  return success;
+}
+
+bool TargetTypeArg::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TargetTypeArg::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                             uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TypeAnnotationItem ----------
+TypeAnnotationItem::TypeAnnotationItem(MapleAllocator &allocator)
+    : targetType(kTargetTypeParamClass),
+      targetInfo(nullptr),
+      targetPath(nullptr),
+      typeIdx(0),
+      nElemPairs(0),
+      elemPairs(allocator.Adapter()) {}
+
+TypeAnnotationItem::~TypeAnnotationItem() {
+  targetInfo = nullptr;
+  targetPath = nullptr;
+}
+
+bool TypeAnnotationItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  targetType = static_cast<TargetInfoItemType>(io.ReadUInt8(success));
+  targetInfo = TargetInfoItem::NewItem(allocator, io, targetType);
+  targetPath = mp->New<TypePath>(allocator);
+  success = targetPath->ParseFile(allocator, io);
+  typeIdx = io.ReadUInt16(success);
+  nElemPairs = io.ReadUInt16(success);
+  for (uint16 i = 0; i < nElemPairs; i++) {
+    ElementValuePair *e = mp->New<ElementValuePair>();
+    success = e->ParseFile(allocator, io);
+    elemPairs.push_back(e);
+  }
+  return success;
+}
+
+bool TypeAnnotationItem::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TypeAnnotationItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                                  uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TypePathItem ----------
+TypePathItem::TypePathItem() : typePathKind(0), typeArgIdx(0) {}
+
+bool TypePathItem::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  (void) allocator;
+  bool success = false;
+  typePathKind = io.ReadUInt8(success);
+  typeArgIdx = io.ReadUInt8(success);
+  return success;
+}
+
+bool TypePathItem::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TypePathItem::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool,
+                                            uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- TypePath ----------
+TypePath::TypePath(MapleAllocator &allocator) : pathLength(0), tbPath(allocator.Adapter()) {}
+
+bool TypePath::ParseFileImpl(MapleAllocator &allocator, BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  pathLength = io.ReadUInt8(success);
+  for (uint8 i = 0; i < pathLength; i++) {
+    TypePathItem *path = mp->New<TypePathItem>();
+    success = path->ParseFile(allocator, io);
+    tbPath.push_back(path);
+  }
+  return success;
+}
+
+bool TypePath::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *TypePath::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) const {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+}  // namespace attr
+}  // namespace jbc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_bb.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_bb.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..784431e2fd4faf77679857b5b972a936572b53db
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_bb.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_bb.h"
+#include "jbc_stmt.h"
+#include "jbc_function.h"
+
+namespace maple {
+JBCBB::JBCBB(const jbc::JBCConstPool &argConstPool)
+    : JBCBB(FEIRBBKind::kBBKindDefault, argConstPool) {}
+
+JBCBB::JBCBB(uint8 argBBKind, const jbc::JBCConstPool &argConstPool)
+    : FEIRBB(argBBKind),
+      constPool(argConstPool),
+      stackError(false),
+      stackInUpdated(false),
+      stackOutUpdated(false),
+      updatePredEnd(false) {}
+
+bool JBCBB::InitForFuncHeader() {
+  updatePredEnd = true;
+  stackInUpdated = true;
+  return UpdateStack();
+}
+
+bool JBCBB::InitForCatch() {
+  updatePredEnd = true;
+  stackInUpdated = true;
+  minStackIn.PushItem(jbc::JBCPrimType::kTypeRef);
+  return UpdateStack();
+}
+
+bool JBCBB::UpdateStack() {
+  minStackOut.CopyFrom(minStackIn);
+  const JBCStmt *stmt = static_cast<const JBCStmt*>(stmtHead);
+  while (stmt != nullptr) {
+    JBCStmtKind kind = stmt->GetJBCKind();
+    if (kind == JBCStmtKind::kJBCStmtInst) {
+      const JBCStmtInst *stmtInst = static_cast<const JBCStmtInst*>(stmt);
+      const jbc::JBCOp &op = stmtInst->GetOp();
+      stackError = stackError || (!minStackOut.StackChange(op, constPool));
+    } else if (kind == JBCStmtKind::kJBCStmtInstBranch) {
+      const JBCStmtInstBranch *stmtInstBranch = static_cast<const JBCStmtInstBranch*>(stmt);
+      const jbc::JBCOp &op = stmtInstBranch->GetOp();
+      stackError = stackError || (!minStackOut.StackChange(op, constPool));
+    }
+    if (stackError) {
+      return false;
+    }
+    if (stmt == stmtTail) {
+      break;
+    }
+    const FELinkListNode *node = stmt->GetNext();
+    stmt = static_cast<const JBCStmt*>(node);
+  }
+  stackOutUpdated = true;
+  return true;
+}
+
+bool JBCBB::UpdateStackByPredBB(const JBCBB &bb) {
+  if (bb.stackError) {
+    return false;
+  }
+  if (!bb.stackOutUpdated) {
+    return true;
+  }
+  if (!stackInUpdated) {
+    minStackIn.CopyFrom(bb.minStackOut);
+    stackInUpdated = true;
+    return UpdateStack();
+  }
+  if (!minStackIn.EqualTo(bb.minStackOut)) {
+    stackError = true;
+    return false;
+  }
+  return true;
+}
+
+bool JBCBB::UpdateStackByPredBBEnd() const {
+  return updatePredEnd;
+}
+
+bool JBCBB::CheckStack() {
+  if (!stackInUpdated || !stackOutUpdated) {
+    return false;
+  }
+  if (stackError) {
+    return false;
+  }
+  for (FEIRBB *bb : GetPredBBs()) {
+    if (bb->GetBBKind() == FEIRBBKind::kBBKindPesudoHead) {
+      continue;
+    }
+    if (bb->GetBBKind() == JBCBBPesudoCatchPred::kBBKindPesudoCatchPred) {
+      continue;
+    }
+    JBCBB *jbcBB = static_cast<JBCBB*>(bb);
+    if (!minStackIn.EqualTo(jbcBB->minStackOut)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void JBCBB::Dump() const {
+  std::cout << "FEIRBB (id=" << GetID() << ", kind=" << GetBBKindName() <<
+               ", preds={";
+  for (FEIRBB *bb : GetPredBBs()) {
+    if (bb->GetBBKind() == FEIRBBKind::kBBKindPesudoHead) {
+      std::cout << "FuncHead ";
+    } else if (bb->GetBBKind() == JBCBBPesudoCatchPred::kBBKindPesudoCatchPred) {
+      std::cout << "CatchPred ";
+    } else {
+      std::cout << bb->GetID() << " ";
+    }
+  }
+  std::cout << "}, succs={";
+  for (FEIRBB *bb : GetSuccBBs()) {
+    std::cout << bb->GetID() << " ";
+  }
+  std::cout << "})" << std::endl;
+  std::cout << "  StackIn (" << (stackInUpdated ? "updated" : "") << "): ";
+  minStackIn.Dump();
+  std::cout << std::endl;
+  const FELinkListNode *nodeStmt = GetStmtHead();
+  while (nodeStmt != nullptr) {
+    const FEIRStmt *stmt = static_cast<const FEIRStmt*>(nodeStmt);
+    stmt->Dump("  ");
+    if (nodeStmt == stmtTail) {
+      break;
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+  std::cout << "  StackOut (" << (stackOutUpdated ? "updated" : "") << "): ";
+  minStackOut.Dump();
+  std::cout << std::endl;
+}
+
+uint32 JBCBB::GetSwapSize() const {
+  uint32 sizeIn = minStackIn.GetStackSize();
+  uint32 sizeOut = minStackOut.GetStackSize();
+  return sizeIn > sizeOut ? sizeIn : sizeOut;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_class.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7bf92f7d9e63e5890ea95d85cd9a132be4dce755
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_class.cpp
@@ -0,0 +1,351 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_class.h"
+#include <sstream>
+
+namespace maple {
+namespace {
+const uint32 kMagicJVMClass = 0xCAFEBABE;
+const uint32 kJavaClassNoIndex = 0;
+}
+
+namespace jbc {
+// ---------- JBCClassElem ----------
+JBCClassElem::JBCClassElem(MapleAllocator &allocator, const JBCClass &argKlass)
+    : klass(argKlass),
+      accessFlag(0),
+      nameIdx(0),
+      descIdx(0),
+      nAttr(0),
+      attrs(allocator.Adapter()),
+      attrMap(allocator) {}
+
+bool JBCClassElem::ParseFile(MapleAllocator &allocator, BasicIORead &io, const JBCConstPool &constPool) {
+  bool success = false;
+  accessFlag = io.ReadUInt16(success);
+  nameIdx = io.ReadUInt16(success);
+  descIdx = io.ReadUInt16(success);
+  nAttr = io.ReadUInt16(success);
+  for (uint16 i = 0; i < nAttr; i++) {
+    JBCAttr *attr = JBCAttr::InAttr(allocator, io, constPool);
+    if (attr == nullptr) {
+      return false;
+    }
+    attrs.push_back(attr);
+    attrMap.RegisterAttr(*attr);
+  }
+  return true;
+}
+
+std::string JBCClassElem::GetClassName() const {
+  return klass.GetClassNameOrin();
+}
+
+const JBCConstPool &JBCClassElem::GetConstPool() const {
+  return klass.GetConstPool();
+}
+
+std::string JBCClassElem::GetFullName() const {
+  std::stringstream ss;
+  ss << GetClassName() << "|" << GetName() << "|" << GetDescription();
+  return ss.str();
+}
+
+// ---------- JBCClassField ----------
+JBCClassField::JBCClassField(MapleAllocator &allocator, const JBCClass &argKlass)
+    : JBCClassElem(allocator, argKlass) {}
+
+SimpleXMLElem *JBCClassField::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+// ---------- JBCClassMethod ----------
+JBCClassMethod::JBCClassMethod(MapleAllocator &allocator, const JBCClass &argKlass)
+    : JBCClassElem(allocator, argKlass) {}
+
+SimpleXMLElem *JBCClassMethod::GenXmlElemImpl(MapleAllocator &allocator, const JBCConstPool &constPool, uint32 idx) {
+  (void) allocator;
+  (void) constPool;
+  (void) idx;
+  return nullptr;
+}
+
+bool JBCClassMethod::PreProcess() {
+  bool success = true;
+  for (JBCAttr *attr : attrs) {
+    switch (attr->GetKind()) {
+      case kAttrCode:
+      case kAttrLocalVariableTable:
+      case kAttrLocalVariableTypeTable:
+        success = success && attr->PreProcess(klass.GetConstPool());
+        break;
+      default:
+        break;
+    }
+  }
+  return success;
+}
+
+const JBCAttrCode *JBCClassMethod::GetCode() const {
+  return static_cast<const JBCAttrCode*>(attrMap.GetAttr(jbc::JBCAttrKind::kAttrCode));
+}
+
+bool JBCClassMethod::IsVirtual() const {
+  std::string classNameOrg = GetClass().GetClassNameOrin();
+  CHECK_FATAL(classNameOrg.length() > 2, "Invalid calss name: %s", classNameOrg.c_str()); // LclassName;
+  std::string className = classNameOrg.substr(1, classNameOrg.length() - 2);
+  return (accessFlag & kAccMethodFinal) == 0 && (accessFlag & kAccMethodPrivate) == 0 &&
+         (accessFlag & kAccMethodProtected) == 0 && (accessFlag & kAccMethodStatic) == 0 &&
+         GetName().compare(className) != 0 && GetName().compare("<init>") != 0 && GetName().compare("<clinit>") != 0;
+}
+
+bool JBCClassMethod::HasCode() const {
+  uint16 flag = GetAccessFlag();
+  return ((flag & kAccMethodAbstract) == 0) && ((flag & kAccMethodNative) == 0);
+}
+
+bool JBCClassMethod::IsNative() const {
+  uint16 flag = GetAccessFlag();
+  return flag & kAccMethodNative;
+}
+
+// ---------- JBCClass ----------
+JBCClass::JBCClass(MapleAllocator &allocatorIn)
+    : allocator(allocatorIn),
+      constPool(allocator),
+      tbInterfaces(allocator.Adapter()),
+      tbFields(allocator.Adapter()),
+      tbMethods(allocator.Adapter()),
+      tbAttrs(allocator.Adapter()),
+      attrMap(allocator),
+      filePathName("", allocator.GetMemPool()),
+      fileName("", allocator.GetMemPool()) {
+  InitHeader();
+}
+
+bool JBCClass::ParseFile(BasicIORead &io) {
+  // begin parsing
+  bool success = false;
+  header.magic = io.ReadUInt32(success);
+  if (header.magic != kMagicJVMClass) {
+    ERR(kLncErr, "JBCClass::ParseFile() failed: invalid java class file (wrong magic number).");
+    return false;
+  }
+  header.minorVersion = io.ReadUInt16(success);
+  header.majorVersion = io.ReadUInt16(success);
+  if (!ParseFileForConstPool(io)) {
+    return false;
+  }
+  header.accessFlag = io.ReadUInt16(success);
+  header.thisClass = io.ReadUInt16(success);
+  header.superClass = io.ReadUInt16(success);
+  header.interfacesCount = io.ReadUInt16(success);
+  for (uint16 i = 0; i < header.interfacesCount && success; i++) {
+    uint16 idx = io.ReadUInt16(success);
+    tbInterfaces.push_back(idx);
+  }
+  if (!success) {
+    return success;
+  }
+  if (!ParseFileForFields(io)) {
+    return false;
+  }
+  if (!ParseFileForMethods(io)) {
+    return false;
+  }
+  if (!ParseFileForAttrs(io)) {
+    return false;
+  }
+  return true;
+}
+
+bool JBCClass::ParseFileForConstPool(BasicIORead &io) {
+  bool success = false;
+  bool wide = false;
+  const uint8 kIdxOff = 1;
+  const uint8 kIdxOffWide = 2;
+  header.constPoolCount = io.ReadUInt16(success);
+  for (uint16_t i = 1; i < header.constPoolCount && success; i += (wide ? kIdxOffWide : kIdxOff)) {
+    JBCConst *objConst = JBCConst::InConst(allocator, io);
+    if (objConst != nullptr) {
+      (void)constPool.InsertConst(*objConst);
+      wide = objConst->IsWide();
+      if (wide) {
+        constPool.InsertConstDummyForWide();
+      }
+    } else {
+      ERR(kLncErr, "JBCClass::ParseFile() failed: invalid const @idx=%d", i);
+      success = false;
+    }
+  }
+  return success;
+}
+
+bool JBCClass::ParseFileForFields(BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  header.fieldsCount = io.ReadUInt16(success);
+  for (uint16 i = 0; i < header.fieldsCount && success; i++) {
+    JBCClassField *field = mp->New<JBCClassField>(allocator, *this);
+    success = field->ParseFile(allocator, io, constPool);
+    tbFields.push_back(field);
+  }
+  return success;
+}
+
+bool JBCClass::ParseFileForMethods(BasicIORead &io) {
+  bool success = false;
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  header.methodsCount = io.ReadUInt16(success);
+  for (uint16 i = 0; i < header.methodsCount && success; i++) {
+    JBCClassMethod *method = mp->New<JBCClassMethod>(allocator, *this);
+    success = method->ParseFile(allocator, io, constPool);
+    tbMethods.push_back(method);
+  }
+  return success;
+}
+
+bool JBCClass::ParseFileForAttrs(BasicIORead &io) {
+  bool success = false;
+  header.attrsCount = io.ReadUInt16(success);
+  for (uint16 i = 0; i < header.attrsCount && success; i++) {
+    JBCAttr *attr = JBCAttr::InAttr(allocator, io, constPool);
+    if (attr == nullptr) {
+      return false;
+    }
+    tbAttrs.push_back(attr);
+    attrMap.RegisterAttr(*attr);
+  }
+  return success;
+}
+
+bool JBCClass::PreProcess() {
+  bool success = true;
+  success = success && constPool.PreProcess(header.majorVersion);
+  success = success && constPool.PrepareFEStructElemInfo(GetClassNameOrin());
+  for (JBCClassMethod *method : tbMethods) {
+    success = success && method->PreProcess();
+  }
+  for (JBCAttr *attr : tbAttrs) {
+    if (attr->GetKind() == JBCAttrKind::kAttrSourceFile) {
+      success = success && attr->PreProcess(constPool);
+    }
+  }
+  return success;
+}
+
+GStrIdx JBCClass::GetClassNameIdxOrin() const {
+  const JBCConstClass *constClass =
+      static_cast<const JBCConstClass*>(constPool.GetConstByIdxWithTag(header.thisClass, kConstClass));
+  if (constClass != nullptr) {
+    return constClass->GetClassNameIdxOrin();
+  } else {
+    return GStrIdx(0);
+  }
+}
+
+GStrIdx JBCClass::GetClassNameIdxMpl() const {
+  const JBCConstClass *constClass =
+      static_cast<const JBCConstClass*>(constPool.GetConstByIdxWithTag(header.thisClass, kConstClass));
+  if (constClass != nullptr) {
+    return constClass->GetClassNameIdxMpl();
+  } else {
+    return GStrIdx(0);
+  }
+}
+
+std::string JBCClass::GetClassNameOrin() const {
+  GStrIdx idx = GetClassNameIdxOrin();
+  if (idx.GetIdx() == 0) {
+    return "";
+  } else {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(idx);
+  }
+}
+
+std::string JBCClass::GetClassNameMpl() const {
+  GStrIdx idx = GetClassNameIdxMpl();
+  if (idx.GetIdx() == 0) {
+    return "";
+  } else {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(idx);
+  }
+}
+
+std::string JBCClass::GetSourceFileName() const {
+  return "";
+}
+
+std::string JBCClass::GetSuperClassName() const {
+  if (header.superClass == kJavaClassNoIndex) {
+    return "";
+  } else {
+    return constPool.GetNameByClassInfoIdx(header.superClass);
+  }
+}
+
+std::vector<std::string> JBCClass::GetInterfaceNames() const {
+  std::vector<std::string> results;
+  for (uint16 idx : tbInterfaces) {
+    if (idx != kJavaClassNoIndex) {
+      std::string name = constPool.GetNameByClassInfoIdx(idx);
+      results.push_back(name);
+    }
+  }
+  return results;
+}
+
+JBCClass *JBCClass::InClass(MapleAllocator &allocator, BasicIORead &io) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp, "mempool is nullptr");
+  JBCClass *klass = mp->New<JBCClass>(allocator);
+  if (klass->ParseFile(io) == false) {
+    return nullptr;
+  }
+  if (klass->PreProcess() == false) {
+    return nullptr;
+  }
+  // update fileName
+  const JBCAttr *attrRaw = klass->attrMap.GetAttr(JBCAttrKind::kAttrSourceFile);
+  if (attrRaw == nullptr) {
+    klass->fileName = "unknown";
+  } else {
+    const JBCAttrSourceFile *attrSourceFile = static_cast<const JBCAttrSourceFile*>(attrRaw);
+    const JBCConstUTF8 *constName = attrSourceFile->GetConstFileName();
+    klass->fileName = constName->GetString();
+  }
+  return klass;
+}
+
+void JBCClass::InitHeader() {
+  header.magic = 0;
+  header.minorVersion = 0;
+  header.majorVersion = 0;
+  header.constPoolCount = 0;
+  header.accessFlag = 0;
+  header.thisClass = 0;
+  header.superClass = 0;
+  header.interfacesCount = 0;
+  header.fieldsCount = 0;
+  header.methodsCount = 0;
+  header.attrsCount = 0;
+}
+}  // namespace jbc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_class2fe_helper.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_class2fe_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2f1e3ca1571026ca1b144ff0e9b424f2faf04b44
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_class2fe_helper.cpp
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_class2fe_helper.h"
+#include "fe_configs.h"
+#include "fe_options.h"
+#include "fe_macros.h"
+#include "fe_manager.h"
+#include "fe_utils_java.h"
+
+namespace maple {
+// ---------- JBCClass2FEHelper ----------
+JBCClass2FEHelper::JBCClass2FEHelper(MapleAllocator &allocator, const jbc::JBCClass &klassIn)
+    : FEInputStructHelper(allocator),
+      klass(klassIn),
+      isStaticFieldProguard(false) {
+  srcLang = kSrcLangJava;
+}
+
+// interface implements
+std::string JBCClass2FEHelper::GetStructNameOrinImpl() const {
+  return klass.GetClassNameOrin();
+}
+
+std::string JBCClass2FEHelper::GetStructNameMplImpl() const {
+  return klass.GetClassNameMpl();
+}
+
+std::list<std::string> JBCClass2FEHelper::GetSuperClassNamesImpl() const {
+  std::string superName = klass.GetSuperClassName();
+  return std::list<std::string>({ superName });
+}
+
+std::vector<std::string> JBCClass2FEHelper::GetInterfaceNamesImpl() const {
+  return klass.GetInterfaceNames();
+}
+
+std::string JBCClass2FEHelper::GetSourceFileNameImpl() const {
+  return klass.GetSourceFileName();
+}
+
+MIRStructType *JBCClass2FEHelper::CreateMIRStructTypeImpl(bool &error) const {
+  std::string classNameOrin = klass.GetClassNameOrin();
+  std::string classNameMpl = klass.GetClassNameMpl();
+  if (classNameMpl.empty()) {
+    error = true;
+    ERR(kLncErr, "class name is empty");
+    return nullptr;
+  }
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "CreateMIRStrucType for %s", classNameOrin.c_str());
+  bool isCreate = false;
+  MIRStructType *type = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(classNameMpl, klass.IsInterface(),
+                                                                                    FETypeFlag::kSrcInput, isCreate);
+  error = false;
+  // fill global type name table
+  GStrIdx typeNameIdx = type->GetNameStrIdx();
+  TyIdx prevTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(typeNameIdx);
+  if (prevTyIdx == TyIdx(0)) {
+    GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(typeNameIdx, type->GetTypeIndex());
+  }
+  return isCreate ? type : nullptr;
+}
+
+TypeAttrs JBCClass2FEHelper::GetStructAttributeFromInputImpl() const {
+  const uint8 bitOfUInt16 = 16;
+  TypeAttrs attrs;
+  uint16 klassAccessFlag = klass.GetAccessFlag();
+  for (uint8 bit = 0; bit < bitOfUInt16; bit++) {
+    uint16 flag = static_cast<uint16>(klassAccessFlag & (1u << bit));
+    switch (flag) {
+      case jbc::kAccClassPublic:
+        attrs.SetAttr(ATTR_public);
+        break;
+      case jbc::kAccClassFinal:
+        attrs.SetAttr(ATTR_final);
+        break;
+      case jbc::kAccClassSuper:
+      case jbc::kAccClassInterface:
+        break;
+      case jbc::kAccClassAbstract:
+        attrs.SetAttr(ATTR_abstract);
+        break;
+      case jbc::kAccClassSynthetic:
+        attrs.SetAttr(ATTR_synthetic);
+        break;
+      case jbc::kAccClassAnnotation:
+        attrs.SetAttr(ATTR_annotation);
+        break;
+      case jbc::kAccClassEnum:
+        attrs.SetAttr(ATTR_enum);
+        break;
+      default:
+        break;
+    }
+  }
+  return attrs;
+}
+
+uint64 JBCClass2FEHelper::GetRawAccessFlagsImpl() const {
+  return uint64{ klass.GetAccessFlag() };
+}
+
+GStrIdx JBCClass2FEHelper::GetIRSrcFileSigIdxImpl() const {
+  // Not implemented, just return a invalid value
+  return GStrIdx(0);
+}
+
+bool JBCClass2FEHelper::IsMultiDefImpl() const {
+  // Not implemented, alway return false
+  return false;
+}
+
+void JBCClass2FEHelper::InitFieldHelpersImpl() {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mem pool is nullptr");
+  for (jbc::JBCClassField *field : klass.GetFields()) {
+    ASSERT(field != nullptr, "field is nullptr");
+    JBCClassField2FEHelper *fieldHelper = mp->New<JBCClassField2FEHelper>(allocator, *field);
+    fieldHelpers.push_back(fieldHelper);
+  }
+}
+
+void JBCClass2FEHelper::InitMethodHelpersImpl() {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mem pool is nullptr");
+  for (jbc::JBCClassMethod *method : klass.GetMethods()) {
+    ASSERT(method != nullptr, "method is nullptr");
+    JBCClassMethod2FEHelper *methodHelper = mp->New<JBCClassMethod2FEHelper>(allocator, *method);
+    methodHelpers.push_back(methodHelper);
+  }
+}
+
+std::string JBCClass2FEHelper::GetSrcFileNameImpl() const {
+  return klass.GetFileName();
+}
+
+// ---------- JBCClassField2FEHelper ----------
+bool JBCClassField2FEHelper::ProcessDeclImpl(MapleAllocator &allocator) {
+  (void) allocator;
+  CHECK_FATAL(false, "should not run here");
+  return false;
+}
+
+bool JBCClassField2FEHelper::ProcessDeclWithContainerImpl(MapleAllocator &allocator) {
+  std::string klassName = field.GetClassName();
+  std::string fieldName = field.GetName();
+  std::string typeName = field.GetDescription();
+  if (fieldName.empty()) {
+    ERR(kLncErr, "invalid name_index(%d) for field in class %s", field.GetNameIdx(), klassName.c_str());
+    return false;
+  }
+  if (typeName.empty()) {
+    ERR(kLncErr, "invalid descriptor_index(%d) for field in class %s", field.GetDescriptionIdx(), klassName.c_str());
+    return false;
+  }
+  FEOptions::ModeJavaStaticFieldName modeStaticField = FEOptions::GetInstance().GetModeJavaStaticFieldName();
+  bool withType = (modeStaticField == FEOptions::kAllType) ||
+                  (modeStaticField == FEOptions::kSmart && field.IsStatic());
+  std::string name = field.IsStatic() ? (klassName + "|") : "";
+  name += fieldName;
+  name += withType ? ("|" + typeName) : "";
+  GStrIdx idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name));
+  StructElemNameIdx *structElemNameIdx = allocator.GetMemPool()->New<StructElemNameIdx>(klassName, fieldName, typeName);
+  FEStructElemInfo *elemInfo = FEManager::GetTypeManager().RegisterStructFieldInfo(
+      *structElemNameIdx, kSrcLangJava, field.IsStatic());
+  elemInfo->SetDefined();
+  elemInfo->SetFromDex();
+  FieldAttrs attrs = AccessFlag2Attribute(field.GetAccessFlag());
+  std::string typeNameMpl = namemangler::EncodeName(typeName);
+  MIRType *fieldType = FEManager::GetTypeManager().GetOrCreateTypeFromName(typeNameMpl, FETypeFlag::kSrcUnknown, true);
+  ASSERT(fieldType != nullptr, "nullptr check for fieldType");
+  mirFieldPair.first = idx;
+  mirFieldPair.second.first = fieldType->GetTypeIndex();
+  mirFieldPair.second.second = attrs;
+  return true;
+}
+
+FieldAttrs JBCClassField2FEHelper::AccessFlag2Attribute(uint16 accessFlag) {
+  const uint32 bitOfUInt16 = 16;
+  FieldAttrs attrs;
+  for (uint32 bit = 0; bit < bitOfUInt16; bit++) {
+    uint16 flag = static_cast<uint16>(accessFlag & (1u << bit));
+    switch (flag) {
+      case jbc::JBCClassFieldAccessFlag::kAccFieldPublic:
+        attrs.SetAttr(FLDATTR_public);
+        break;
+      case jbc::JBCClassFieldAccessFlag::kAccFieldPrivate:
+        attrs.SetAttr(FLDATTR_private);
+        break;
+      case jbc::JBCClassFieldAccessFlag::kAccFieldProtected:
+        attrs.SetAttr(FLDATTR_protected);
+        break;
+      case jbc::JBCClassFieldAccessFlag::kAccFieldStatic:
+        attrs.SetAttr(FLDATTR_static);
+        break;
+      case jbc::JBCClassFieldAccessFlag::kAccFieldFinal:
+        attrs.SetAttr(FLDATTR_final);
+        break;
+      case jbc::JBCClassFieldAccessFlag::kAccFieldVolatile:
+        attrs.SetAttr(FLDATTR_volatile);
+        break;
+      case jbc::JBCClassFieldAccessFlag::kAccFieldTransient:
+        attrs.SetAttr(FLDATTR_transient);
+        break;
+      case jbc::JBCClassFieldAccessFlag::kAccFieldSynthetic:
+        attrs.SetAttr(FLDATTR_synthetic);
+        break;
+      case jbc::JBCClassFieldAccessFlag::kAccFieldEnum:
+        attrs.SetAttr(FLDATTR_enum);
+        break;
+      default:
+        break;
+    }
+  }
+  return attrs;
+}
+
+// ---------- JBCClassMethod2FEHelper ----------
+JBCClassMethod2FEHelper::JBCClassMethod2FEHelper(MapleAllocator &allocator, const jbc::JBCClassMethod &methodIn)
+    : FEInputMethodHelper(allocator),
+      method(methodIn) {
+  srcLang = kSrcLangJava;
+}
+
+bool JBCClassMethod2FEHelper::ProcessDeclImpl(MapleAllocator &allocator) {
+  StructElemNameIdx *structElemNameIdx = allocator.GetMemPool()->New<StructElemNameIdx>(
+      method.GetClassName(), method.GetName(), method.GetDescription());
+  FEStructElemInfo *elemInfo = FEManager::GetTypeManager().RegisterStructMethodInfo(
+      *structElemNameIdx, kSrcLangJava, IsStatic());
+  elemInfo->SetDefined();
+  elemInfo->SetFromDex();
+  return FEInputMethodHelper::ProcessDeclImpl(allocator);
+}
+
+void JBCClassMethod2FEHelper::SolveReturnAndArgTypesImpl(MapleAllocator &allocator) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  std::string klassName = method.GetClassName();
+  std::string methodName = GetMethodName(false);
+  if (HasThis()) {
+    FEIRTypeDefault *type = mp->New<FEIRTypeDefault>();
+    type->LoadFromJavaTypeName(klassName, false);
+    argTypes.push_back(type);
+  }
+  std::vector<std::string> returnAndArgTypeNames = FEUtilJava::SolveMethodSignature(methodName);
+  bool first = true;
+  for (const std::string &typeName : returnAndArgTypeNames) {
+    FEIRTypeDefault *type = mp->New<FEIRTypeDefault>();
+    type->LoadFromJavaTypeName(typeName, false);
+    if (first) {
+      retType = type;
+      first = false;
+    } else {
+      argTypes.push_back(type);
+    }
+  }
+}
+
+std::string JBCClassMethod2FEHelper::GetMethodNameImpl(bool inMpl, bool full) const {
+  const jbc::JBCConstPool &constPool = method.GetConstPool();
+  std::string klassName = method.GetClassName();
+  std::string methodName = method.GetName(constPool);
+  if (!full) {
+    return inMpl ? namemangler::EncodeName(methodName) : methodName;
+  }
+  std::string descName = method.GetDescription(constPool);
+  std::string fullName = klassName + "|" + methodName + "|" + descName;
+  return inMpl ? namemangler::EncodeName(fullName) : fullName;
+}
+
+FuncAttrs JBCClassMethod2FEHelper::GetAttrsImpl() const {
+  FuncAttrs attrs;
+  const uint32 bitOfUInt16 = 16;
+  uint16 accessFlag = method.GetAccessFlag();
+  for (uint32 bit = 0; bit < bitOfUInt16; bit++) {
+    uint16 flag = static_cast<uint16>(accessFlag & (1u << bit));
+    switch (flag) {
+      case jbc::JBCClassMethodAccessFlag::kAccMethodPublic:
+        attrs.SetAttr(FUNCATTR_public);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodPrivate:
+        attrs.SetAttr(FUNCATTR_private);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodProtected:
+        attrs.SetAttr(FUNCATTR_protected);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodStatic:
+        attrs.SetAttr(FUNCATTR_static);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodFinal:
+        attrs.SetAttr(FUNCATTR_final);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodSynchronized:
+        attrs.SetAttr(FUNCATTR_synchronized);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodBridge:
+        attrs.SetAttr(FUNCATTR_bridge);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodVarargs:
+        attrs.SetAttr(FUNCATTR_varargs);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodNative:
+        attrs.SetAttr(FUNCATTR_native);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodAbstract:
+        attrs.SetAttr(FUNCATTR_abstract);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodStrict:
+        attrs.SetAttr(FUNCATTR_strict);
+        break;
+      case jbc::JBCClassMethodAccessFlag::kAccMethodSynthetic:
+        attrs.SetAttr(FUNCATTR_synthetic);
+        break;
+      default:
+        break;
+    }
+    attrs.SetAttr(IsVirtual() ? FUNCATTR_virtual : static_cast<FuncAttrKind>(0));
+  }
+  return attrs;
+}
+
+bool JBCClassMethod2FEHelper::IsStaticImpl() const {
+  uint16 accessFlag = method.GetAccessFlag();
+  if ((accessFlag & jbc::JBCClassMethodAccessFlag::kAccMethodStatic) != 0) {
+    return true;
+  }
+  if (IsClinit()) {
+    return true;
+  }
+  return false;
+}
+
+bool JBCClassMethod2FEHelper::IsVargImpl() const {
+  return false;
+}
+
+bool JBCClassMethod2FEHelper::HasThisImpl() const {
+  return !IsStatic();
+}
+
+bool JBCClassMethod2FEHelper::IsClinit() const {
+  const jbc::JBCConstPool &constPool = method.GetConstPool();
+  std::string methodName = method.GetName(constPool);
+  return methodName.compare("<clinit>") == 0;
+}
+
+bool JBCClassMethod2FEHelper::IsInit() const {
+  const jbc::JBCConstPool &constPool = method.GetConstPool();
+  std::string methodName = method.GetName(constPool);
+  return methodName.compare("<init>") == 0;
+}
+
+bool JBCClassMethod2FEHelper::IsVirtualImpl() const {
+  return method.IsVirtual();
+}
+
+bool JBCClassMethod2FEHelper::IsNativeImpl() const {
+  return method.IsNative();
+}
+
+MIRType *JBCClassMethod2FEHelper::GetTypeForThisImpl() const {
+  FEIRTypeDefault type;
+  std::string klassName = method.GetClassName();
+  type.LoadFromJavaTypeName(klassName, false);
+  return type.GenerateMIRType(true);
+}
+
+bool JBCClassMethod2FEHelper::HasCodeImpl() const {
+  return method.HasCode();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_class_const.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_class_const.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..029e965631c6b145af5b46a4c0cd1bd44f72152e
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_class_const.cpp
@@ -0,0 +1,519 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_class_const.h"
+#include <sstream>
+#include "mpl_logging.h"
+#include "jbc_class.h"
+#include "jbc_util.h"
+#include "fe_manager.h"
+
+namespace maple {
+namespace jbc {
+// ---------- JBCConstTagName ----------
+std::map<JBCConstTag, std::string> JBCConstTagName::tagNameMap = JBCConstTagName::InitTagNameMap();
+std::map<JBCConstTag, std::string> JBCConstTagName::InitTagNameMap() {
+  std::map<JBCConstTag, std::string> ret;
+  ret[kConstUnknown] = "ConstUnknown";
+#undef JBC_CONST
+#define JBC_CONST(tag, tagName, className) \
+  ret[tag] = tagName;
+#include "jbc_class_const.def"
+#undef JBC_CONST
+  return ret;
+}
+
+std::string JBCConstTagName::GetTagName(JBCConstTag tag) {
+  std::map<JBCConstTag, std::string>::const_iterator it = tagNameMap.find(tag);
+  if (it != tagNameMap.end()) {
+    return it->second;
+  }
+  std::stringstream ss;
+  ss << "unknown tag (" << static_cast<uint32>(tag) << ")";
+  return ss.str();
+}
+
+// ---------- JBCConst ----------
+SimpleXMLElem *JBCConst::GenXMLElemImpl(MapleAllocator &allocIn, uint32 id) const {
+  (void) allocIn;
+  (void) id;
+  return nullptr;
+}
+
+JBCConst *JBCConst::InConst(MapleAllocator &alloc, BasicIORead &io) {
+  MemPool *mp = alloc.GetMemPool();
+  ASSERT(mp, "mp is nullptr");
+  JBCConst *constObj = nullptr;
+  uint8 t = io.ReadUInt8();
+  switch (t) {
+#undef JBC_CONST
+#define JBC_CONST(tag, tagName, ConstClassType) \
+    case tag: \
+      constObj = mp->New<ConstClassType>(alloc, static_cast<JBCConstTag>(t)); \
+      if (constObj->ParseFile(io) == false) { \
+        return nullptr; \
+      } \
+      break;
+#include "jbc_class_const.def"
+#undef JBC_CONST
+    default:
+      break;
+  }
+  return constObj;
+}
+
+std::string JBCConst::InternalNameToFullName(const std::string &name) {
+  // ref: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.4.1
+  if (name[0] == '[') {
+    return name;
+  } else {
+    return "L" + name + ";";
+  }
+}
+
+std::string JBCConst::FullNameToInternalName(const std::string &name) {
+  if (name[0] == '[') {
+    return name;
+  } else {
+    return name.substr(1, name.length() - 2); // 1 : start pos, name.length() - 2 : substr length
+  }
+}
+
+// ---------- JBCConstUTF8 ----------
+JBCConstUTF8::JBCConstUTF8(MapleAllocator &alloc, JBCConstTag t)
+    : JBCConst(alloc, t), length(0), strIdx(0), str("", alloc.GetMemPool()) {}
+
+JBCConstUTF8::JBCConstUTF8(MapleAllocator &alloc, JBCConstTag t, const std::string &argStr)
+    : JBCConst(alloc, t), str(argStr, alloc.GetMemPool()) {
+  CHECK_FATAL(t == kConstUTF8, "invalid tag");
+  size_t rawLength = str.length();
+  CHECK_FATAL(rawLength < UINT16_MAX, "input string is too long");
+  length = static_cast<uint16>(rawLength);
+  strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(MapleStringToStd(str));
+}
+
+bool JBCConstUTF8::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  length = io.ReadUInt16(success);
+  str = io.ReadString(length, success);
+  strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(MapleStringToStd(str));
+  return success;
+}
+
+bool JBCConstUTF8::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCConstUTF8::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+
+// ---------- JBCConst4Byte ----------
+JBCConst4Byte::JBCConst4Byte(MapleAllocator &alloc, JBCConstTag t) : JBCConst(alloc, t) {
+  value.raw = 0;
+}
+
+JBCConst4Byte::JBCConst4Byte(MapleAllocator &alloc, JBCConstTag t, int32 arg) : JBCConst(alloc, t) {
+  CHECK_FATAL(t == kConstInteger, "invalid tag");
+  value.ivalue = arg;
+}
+
+JBCConst4Byte::JBCConst4Byte(MapleAllocator &alloc, JBCConstTag t, float arg) : JBCConst(alloc, t) {
+  CHECK_FATAL(t == kConstFloat, "invalid tag");
+  value.fvalue = arg;
+}
+
+bool JBCConst4Byte::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  value.raw = io.ReadUInt32(success);
+  return success;
+}
+
+bool JBCConst4Byte::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCConst4Byte::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+
+// ---------- JBCConst8Byte ----------
+JBCConst8Byte::JBCConst8Byte(MapleAllocator &alloc, JBCConstTag t) : JBCConst(alloc, t) {
+  value.raw = 0;
+}
+
+JBCConst8Byte::JBCConst8Byte(MapleAllocator &alloc, JBCConstTag t, int64 arg) : JBCConst(alloc, t) {
+  CHECK_FATAL(t == kConstLong, "invalid tag");
+  value.lvalue = arg;
+}
+
+JBCConst8Byte::JBCConst8Byte(MapleAllocator &alloc, JBCConstTag t, double arg) : JBCConst(alloc, t) {
+  CHECK_FATAL(t == kConstDouble, "invalid tag");
+  value.dvalue = arg;
+}
+
+bool JBCConst8Byte::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  value.raw = io.ReadUInt64(success);
+  return success;
+}
+
+bool JBCConst8Byte::PreProcessImpl(const JBCConstPool &constPool) {
+  (void) constPool;
+  return true;
+}
+
+SimpleXMLElem *JBCConst8Byte::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+
+// ---------- JBCConstClass ----------
+JBCConstClass::JBCConstClass(MapleAllocator &alloc, JBCConstTag t)
+    : JBCConst(alloc, t),
+      constUTF8(nullptr),
+      strIdxOrin(0),
+      strIdxMpl(0),
+      nameOrin("", alloc.GetMemPool()),
+      nameMpl("", alloc.GetMemPool()) {
+  rawData.nameIdx = 0;
+  feType = alloc.GetMemPool()->New<FEIRTypeDefault>(PTY_ref);
+}
+
+JBCConstClass::JBCConstClass(MapleAllocator &alloc, JBCConstTag t, JBCConstPoolIdx argNameIdx)
+    : JBCConst(alloc, t),
+      constUTF8(nullptr),
+      strIdxOrin(0),
+      strIdxMpl(0),
+      nameOrin("", alloc.GetMemPool()),
+      nameMpl("", alloc.GetMemPool()) {
+  CHECK_FATAL(t == kConstClass, "invalid tag");
+  rawData.nameIdx = argNameIdx;
+  feType = alloc.GetMemPool()->New<FEIRTypeDefault>(PTY_ref);
+}
+
+JBCConstClass::~JBCConstClass() {
+  constUTF8 = nullptr;
+  feType = nullptr;
+}
+
+bool JBCConstClass::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  rawData.nameIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCConstClass::PreProcessImpl(const JBCConstPool &constPool) {
+  constUTF8 = static_cast<const JBCConstUTF8*>(constPool.GetConstByIdxWithTag(rawData.nameIdx, kConstUTF8));
+  if (constUTF8 == nullptr) {
+    return false;
+  }
+  const std::string &classNameInternal = constUTF8->GetString();
+  nameOrin = JBCUtil::ClassInternalNameToFullName(classNameInternal);
+  strIdxOrin = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(MapleStringToStd(nameOrin));
+  nameMpl = namemangler::EncodeName(nameOrin.c_str());
+  strIdxMpl = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(MapleStringToStd(nameMpl));
+  static_cast<FEIRTypeDefault*>(feType)->LoadFromJavaTypeName(MapleStringToStd(nameMpl), true);
+  return true;
+}
+
+SimpleXMLElem *JBCConstClass::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+
+// ---------- JBCConstString ----------
+JBCConstString::JBCConstString(MapleAllocator &alloc, JBCConstTag t)
+    : JBCConst(alloc, t), strIdx(0), str("", alloc.GetMemPool()) {
+  rawData.stringIdx = 0;
+}
+
+JBCConstString::JBCConstString(MapleAllocator &alloc, JBCConstTag t, JBCConstPoolIdx argStringIdx)
+    : JBCConst(alloc, t), strIdx(0), str("", alloc.GetMemPool()) {
+  CHECK_FATAL(t == kConstString, "invalid tag");
+  rawData.stringIdx = argStringIdx;
+}
+
+bool JBCConstString::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  rawData.stringIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCConstString::PreProcessImpl(const JBCConstPool &constPool) {
+  const JBCConstUTF8 *constUTF8 =
+      static_cast<const JBCConstUTF8*>(constPool.GetConstByIdxWithTag(rawData.stringIdx, kConstUTF8));
+  if (constUTF8 == nullptr) {
+    return false;
+  }
+  strIdx = constUTF8->GetStrIdx();
+  str = constUTF8->GetString();
+  return true;
+}
+
+SimpleXMLElem *JBCConstString::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+
+// ---------- JBCConstRef ----------
+JBCConstRef::JBCConstRef(MapleAllocator &alloc, JBCConstTag t)
+    : JBCConst(alloc, t), constClass(nullptr), constNameAndType(nullptr), feStructElemInfo(nullptr) {
+  rawData.classIdx = 0;
+  rawData.nameAndTypeIdx = 0;
+}
+
+JBCConstRef::JBCConstRef(MapleAllocator &alloc, JBCConstTag t, JBCConstPoolIdx argClassIdx,
+                         JBCConstPoolIdx argClassNameAndTypeIdx)
+    : JBCConst(alloc, t), constClass(nullptr), constNameAndType(nullptr), feStructElemInfo(nullptr) {
+  rawData.classIdx = argClassIdx;
+  rawData.nameAndTypeIdx = argClassNameAndTypeIdx;
+}
+
+JBCConstRef::~JBCConstRef() {
+  constClass = nullptr;
+  constNameAndType = nullptr;
+  feStructElemInfo = nullptr;
+}
+
+bool JBCConstRef::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  rawData.classIdx = io.ReadUInt16(success);
+  rawData.nameAndTypeIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCConstRef::PreProcessImpl(const JBCConstPool &constPool) {
+  constClass = static_cast<const JBCConstClass*>(constPool.GetConstByIdxWithTag(rawData.classIdx, kConstClass));
+  constNameAndType = static_cast<const JBCConstNameAndType*>(constPool.GetConstByIdxWithTag(rawData.nameAndTypeIdx,
+                                                                                            kConstNameAndType));
+  return (constClass != nullptr) && (constNameAndType != nullptr);
+}
+
+bool JBCConstRef::PrepareFEStructElemInfo() {
+  CHECK_NULL_FATAL(constClass);
+  CHECK_NULL_FATAL(constNameAndType);
+  const std::string &className = constClass->GetClassNameOrin();
+  const std::string &elemName = constNameAndType->GetName();
+  const std::string &descName = constNameAndType->GetDesc();
+  StructElemNameIdx *structElemNameIdx = alloc.GetMemPool()->New<StructElemNameIdx>(className, elemName, descName);
+  if (tag == kConstFieldRef) {
+    feStructElemInfo = FEManager::GetTypeManager().RegisterStructFieldInfo(
+        *structElemNameIdx, kSrcLangJava, false);
+  } else {
+    feStructElemInfo = FEManager::GetTypeManager().RegisterStructMethodInfo(
+        *structElemNameIdx, kSrcLangJava, false);
+  }
+  return feStructElemInfo != nullptr;
+}
+
+SimpleXMLElem *JBCConstRef::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+
+const std::string JBCConstRef::GetName() const {
+  CHECK_FATAL(constNameAndType != nullptr, "invalid const index");
+  return constNameAndType->GetName();
+}
+
+const std::string JBCConstRef::GetDesc() const {
+  CHECK_FATAL(constNameAndType != nullptr, "invalid const index");
+  return constNameAndType->GetDesc();
+}
+
+// ---------- JBCConstNameAndType ----------
+JBCConstNameAndType::JBCConstNameAndType(MapleAllocator &alloc, JBCConstTag t)
+    : JBCConst(alloc, t), constName(nullptr), constDesc(nullptr) {
+  rawData.nameIdx = 0;
+  rawData.descIdx = 0;
+}
+
+JBCConstNameAndType::JBCConstNameAndType(MapleAllocator &alloc, JBCConstTag t, JBCConstPoolIdx argNameIdx,
+                                         JBCConstPoolIdx argDescIdx)
+    : JBCConst(alloc, t), constName(nullptr), constDesc(nullptr) {
+  rawData.nameIdx = argNameIdx;
+  rawData.descIdx = argDescIdx;
+}
+
+JBCConstNameAndType::~JBCConstNameAndType() {
+  constName = nullptr;
+  constDesc = nullptr;
+}
+
+bool JBCConstNameAndType::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  rawData.nameIdx = io.ReadUInt16(success);
+  rawData.descIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCConstNameAndType::PreProcessImpl(const JBCConstPool &constPool) {
+  constName = static_cast<const JBCConstUTF8*>(constPool.GetConstByIdxWithTag(rawData.nameIdx, kConstUTF8));
+  constDesc = static_cast<const JBCConstUTF8*>(constPool.GetConstByIdxWithTag(rawData.descIdx, kConstUTF8));
+  return (constName != nullptr) && (constDesc != nullptr);
+}
+
+SimpleXMLElem *JBCConstNameAndType::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+
+// ---------- JBCConstMethodHandleInfo ----------
+JBCConstMethodHandleInfo::JBCConstMethodHandleInfo(MapleAllocator &alloc, JBCConstTag t)
+    : JBCConst(alloc, t), constRef(nullptr) {
+  rawData.refKind = 0;
+  rawData.refIdx = 0;
+}
+
+JBCConstMethodHandleInfo::~JBCConstMethodHandleInfo() {
+  constRef = nullptr;
+}
+
+bool JBCConstMethodHandleInfo::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  rawData.refKind = io.ReadUInt8(success);
+  rawData.refIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCConstMethodHandleInfo::PreProcessImpl(const JBCConstPool &constPool) {
+  constRef = nullptr;
+  switch (rawData.refKind) {
+    case kRefGetField:
+    case kRefGetStatic:
+    case kRefPutField:
+    case kRefPutStatic:
+      constRef = static_cast<const JBCConstRef*>(constPool.GetConstByIdxWithTag(rawData.refIdx, kConstFieldRef));
+      break;
+    case jbc::kRefInvokeVirtual:
+    case jbc::kRefNewInvokeSpecial:
+      constRef = static_cast<const JBCConstRef*>(constPool.GetConstByIdxWithTag(rawData.refIdx, kConstMethodRef));
+      break;
+    case jbc::kRefInvokeStatic:
+    case jbc::kRefInvokeSpecial:
+      if (constPool.GetMajorVersion() < 52) { // 52 : class file version number
+        constRef = static_cast<const JBCConstRef*>(constPool.GetConstByIdxWithTag(rawData.refIdx, kConstMethodRef));
+      } else {
+        constRef = static_cast<const JBCConstRef*>(constPool.GetConstByIdx(rawData.refIdx));
+        CHECK_NULL_FATAL(constRef);
+        if (constRef->GetTag() != kConstMethodRef && constRef->GetTag() != kConstInterfaceMethodRef) {
+          ERR(kLncErr, "Unexpected tag (%s) for const MethodHandle info. Expected %s or %s",
+              JBCConstTagName::GetTagName(constRef->GetTag()).c_str(),
+              JBCConstTagName::GetTagName(kConstMethodRef).c_str(),
+              JBCConstTagName::GetTagName(kConstInterfaceMethodRef).c_str());
+          return false;
+        }
+      }
+      break;
+    case jbc::kRefInvokeInterface:
+      constRef = static_cast<const JBCConstRef*>(constPool.GetConstByIdxWithTag(rawData.refIdx,
+                                                                                kConstInterfaceMethodRef));
+      break;
+    default:
+      CHECK_FATAL(false, "Unsupported ref kind (%d)", rawData.refKind);
+      break;
+  }
+  return constRef != nullptr;
+}
+
+SimpleXMLElem *JBCConstMethodHandleInfo::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+
+// ---------- JBCConstMethodType ----------
+JBCConstMethodType::JBCConstMethodType(MapleAllocator &alloc, JBCConstTag t)
+    : JBCConst(alloc, t), constDesc(nullptr) {
+  rawData.descIdx = 0;
+}
+
+JBCConstMethodType::~JBCConstMethodType() {
+  constDesc = nullptr;
+}
+
+bool JBCConstMethodType::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  rawData.descIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCConstMethodType::PreProcessImpl(const JBCConstPool &constPool) {
+  constDesc = static_cast<const JBCConstUTF8*>(constPool.GetConstByIdxWithTag(rawData.descIdx, kConstUTF8));
+  return constDesc != nullptr;
+}
+
+SimpleXMLElem *JBCConstMethodType::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+
+// ---------- JBCConstInvokeDynamic ----------
+JBCConstInvokeDynamic::JBCConstInvokeDynamic(MapleAllocator &alloc, JBCConstTag t)
+    : JBCConst(alloc, t), constNameAndType(nullptr), feStructElemInfo(nullptr) {
+  rawData.bsmAttrIdx = 0;
+  rawData.nameAndTypeIdx = 0;
+}
+
+JBCConstInvokeDynamic::~JBCConstInvokeDynamic() {
+  constNameAndType = nullptr;
+  feStructElemInfo = nullptr;
+}
+
+bool JBCConstInvokeDynamic::PrepareFEStructElemInfo(const std::string &ownerClassName) {
+  CHECK_NULL_FATAL(constNameAndType);
+  const std::string &className = ownerClassName + "$DynamicCall$";
+  const std::string &elemName = constNameAndType->GetName();
+  const std::string &descName = constNameAndType->GetDesc();
+  StructElemNameIdx *structElemNameIdx = alloc.GetMemPool()->New<StructElemNameIdx>(className, elemName, descName);
+  feStructElemInfo = FEManager::GetTypeManager().RegisterStructMethodInfo(
+      *structElemNameIdx, kSrcLangJava, false);
+  static_cast<FEStructMethodInfo*>(feStructElemInfo)->SetJavaDyamicCall();
+  return feStructElemInfo != nullptr;
+}
+
+bool JBCConstInvokeDynamic::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  rawData.bsmAttrIdx = io.ReadUInt16(success);
+  rawData.nameAndTypeIdx = io.ReadUInt16(success);
+  return success;
+}
+
+bool JBCConstInvokeDynamic::PreProcessImpl(const JBCConstPool &constPool) {
+  constNameAndType =
+      static_cast<const JBCConstNameAndType*>(constPool.GetConstByIdxWithTag(rawData.nameAndTypeIdx,
+                                                                             kConstNameAndType));
+  return constNameAndType != nullptr;
+}
+
+SimpleXMLElem *JBCConstInvokeDynamic::GenXMLElemImpl(MapleAllocator &alloc, uint32 id) const {
+  (void) alloc;
+  (void) id;
+  return nullptr;
+}
+}  // namespace jbc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_class_const_pool.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_class_const_pool.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..49703d94fbe329f927371864e79e78665792f72e
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_class_const_pool.cpp
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_class_const_pool.h"
+#include <sstream>
+
+namespace maple {
+namespace jbc {
+JBCConstPool::JBCConstPool(MapleAllocator &alloc)
+    : allocator(alloc),
+      pool(allocator.Adapter()),
+      majorVersion(0) {
+  pool.push_back(nullptr);
+}
+
+uint16 JBCConstPool::InsertConst(JBCConst &objConst) {
+  size_t ans = pool.size();
+  pool.push_back(&objConst);
+  CHECK_FATAL(ans < 0xFFFF, "const pool is full");
+  return static_cast<uint16>(ans);
+}
+
+void JBCConstPool::InsertConstDummyForWide() {
+  size_t ans = pool.size();
+  pool.push_back(nullptr);
+  CHECK_FATAL(ans < 0xFFFF, "const pool is full");
+}
+
+const JBCConst *JBCConstPool::GetConstByIdx(uint16 idx, bool safed) const {
+  if (idx == 0 || idx >= pool.size()) {
+    std::stringstream ss;
+    ss << "invalid const pool idx " << static_cast<uint32>(idx) << ".";
+    CHECK_FATAL(!safed, "%s", ss.str().c_str());
+    ERR(kLncErr, "%s", ss.str().c_str());
+    return nullptr;
+  }
+  return pool[idx];
+}
+
+const JBCConst *JBCConstPool::GetConstByIdxWithTag(uint16 idx, JBCConstTag tag, bool safed) const {
+  const JBCConst *obj = GetConstByIdx(idx, safed);
+  if (obj != nullptr && obj->GetTag() != tag) {
+    std::stringstream ss;
+    ss << "invalid const pool idx " << static_cast<uint32>(idx) << " (tag=" <<
+          JBCConstTagName::GetTagName(obj->GetTag()).c_str() << ", expect " <<
+          JBCConstTagName::GetTagName(tag).c_str() << ").";
+    CHECK_FATAL(!safed, "%s Exit.", ss.str().c_str());
+    ERR(kLncErr, "%s", ss.str().c_str());
+    return nullptr;
+  }
+  return obj;
+}
+
+const JBCConst *JBCConstPool::GetConstValueByIdx(uint16 idx, bool safed) const {
+  const JBCConst *obj = GetConstByIdx(idx, safed);
+  if (obj != nullptr && obj->IsValue() == false) {
+    std::stringstream ss;
+    ss << "invalid const pool idx " << static_cast<uint32>(idx) << " (not value const).";
+    CHECK_FATAL(!safed, "%s Exit.", ss.str().c_str());
+    ERR(kLncErr, "%s", ss.str().c_str());
+    return nullptr;
+  }
+  return obj;
+}
+
+const JBCConst *JBCConstPool::GetConstValue4ByteByIdx(uint16 idx, bool safed) const {
+  const JBCConst *obj = GetConstByIdx(idx, safed);
+  if (obj != nullptr && obj->IsValue4Byte() == false) {
+    std::stringstream ss;
+    ss << "invalid const pool idx " << static_cast<uint32>(idx) << " (not 4-byte value const).";
+    CHECK_FATAL(!safed, "%s Exit.", ss.str().c_str());
+    ERR(kLncErr, "%s", ss.str().c_str());
+    return nullptr;
+  }
+  return obj;
+}
+
+const JBCConst *JBCConstPool::GetConstValue8ByteByIdx(uint16 idx, bool safed) const {
+  const JBCConst *obj = GetConstByIdx(idx, safed);
+  if (obj != nullptr && obj->IsValue8Byte() == false) {
+    std::stringstream ss;
+    ss << "invalid const pool idx " << static_cast<uint32>(idx) << " (not 8-byte value const).";
+    CHECK_FATAL(!safed, "%s Exit.", ss.str().c_str());
+    ERR(kLncErr, "%s", ss.str().c_str());
+    return nullptr;
+  }
+  return obj;
+}
+
+std::string JBCConstPool::GetNameByClassInfoIdx(uint16 idx, bool safed) const {
+  const JBCConstClass *constClass = static_cast<const JBCConstClass*>(GetConstByIdxWithTag(idx, kConstClass, safed));
+  if (constClass == nullptr) {
+    return "";
+  } else {
+    return constClass->GetClassNameOrin();
+  }
+}
+
+bool JBCConstPool::PreProcess(uint16 argMajorVersion) {
+  majorVersion = argMajorVersion;
+  for (JBCConst *c : pool) {
+    if (c != nullptr && !c->PreProcess(*this)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool JBCConstPool::PrepareFEStructElemInfo(const std::string &ownerClassName) {
+  bool success = true;
+  for (JBCConst *c : pool) {
+    if (c == nullptr) {
+      continue;
+    }
+    JBCConstTag tag = c->GetTag();
+    if (tag == JBCConstTag::kConstFieldRef || tag == JBCConstTag::kConstMethodRef ||
+        tag == JBCConstTag::kConstInterfaceMethodRef) {
+      JBCConstRef *constRef = static_cast<JBCConstRef*>(c);
+      success = success && constRef->PrepareFEStructElemInfo();
+    }
+    if (tag == JBCConstTag::kConstInvokeDynamic) {
+      JBCConstInvokeDynamic *constRef = static_cast<JBCConstInvokeDynamic*>(c);
+      success = success && constRef->PrepareFEStructElemInfo(ownerClassName);
+    }
+  }
+  return success;
+}
+
+JBCConstUTF8 *JBCConstPool::NewConstUTF8(uint16 &idx, const std::string &str) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  JBCConstUTF8 *constItem = mp->New<JBCConstUTF8>(allocator, kConstUTF8, str);
+  idx = InsertConst(*constItem);
+  return constItem;
+}
+
+JBCConst4Byte *JBCConstPool::NewConst4Byte(uint16 &idx, int32 value) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  JBCConst4Byte *constItem = mp->New<JBCConst4Byte>(allocator, kConstInteger, value);
+  idx = InsertConst(*constItem);
+  return constItem;
+}
+
+JBCConst4Byte *JBCConstPool::NewConst4Byte(uint16 &idx, float value) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  JBCConst4Byte *constItem = mp->New<JBCConst4Byte>(allocator, kConstFloat, value);
+  idx = InsertConst(*constItem);
+  return constItem;
+}
+
+JBCConst8Byte *JBCConstPool::NewConst8Byte(uint16 &idx, int64 value) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  JBCConst8Byte *constItem = mp->New<JBCConst8Byte>(allocator, kConstLong, value);
+  idx = InsertConst(*constItem);
+  return constItem;
+}
+
+JBCConst8Byte *JBCConstPool::NewConst8Byte(uint16 &idx, double value) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  JBCConst8Byte *constItem = mp->New<JBCConst8Byte>(allocator, kConstDouble, value);
+  idx = InsertConst(*constItem);
+  return constItem;
+}
+
+JBCConstClass *JBCConstPool::NewConstClass(uint16 &idx, const std::string &className) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  std::string classNameInternal = JBCConst::FullNameToInternalName(className);
+  JBCConstUTF8 *constUTF8 = mp->New<JBCConstUTF8>(allocator, kConstUTF8, classNameInternal);
+  uint16 idxTmp = InsertConst(*constUTF8);
+  CHECK_FATAL(idxTmp != UINT16_MAX, "constpool insert failed");
+  JBCConstClass *constClass = mp->New<JBCConstClass>(allocator, kConstClass, idxTmp);
+  CHECK_FATAL(constClass->PreProcess(*this), "New ConstClass failed");
+  idx = InsertConst(*constClass);
+  return constClass;
+}
+
+JBCConstString *JBCConstPool::NewConstString(uint16 &idx, const std::string &str) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  JBCConstUTF8 *constUTF8 = mp->New<JBCConstUTF8>(allocator, kConstUTF8, str);
+  uint16 idxTmp = InsertConst(*constUTF8);
+  CHECK_FATAL(idxTmp != UINT16_MAX, "constpool insert failed");
+  JBCConstString *constString = mp->New<JBCConstString>(allocator, kConstString, idxTmp);
+  CHECK_FATAL(constString->PreProcess(*this), "New ConstClass failed");
+  idx = InsertConst(*constString);
+  return constString;
+}
+
+JBCConstRef *JBCConstPool::NewConstRef(uint16 &idx, JBCConstTag tag, const std::string &className,
+                                       const std::string &name, const std::string &desc) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  uint16 idxConstClass;
+  uint16 idxConstNameAndType;
+  JBCConstClass *constClass = NewConstClass(idxConstClass, className);
+  CHECK_FATAL(idxConstClass != UINT16_MAX, "constpool insert failed");
+  CHECK_NULL_FATAL(constClass);
+  JBCConstNameAndType *constNameAndType = NewConstNameAndType(idxConstNameAndType, name, desc);
+  CHECK_FATAL(idxConstNameAndType != UINT16_MAX, "constpool insert failed");
+  CHECK_NULL_FATAL(constNameAndType);
+  JBCConstRef *constRef = mp->New<JBCConstRef>(allocator, tag, idxConstClass, idxConstNameAndType);
+  CHECK_FATAL(constRef->PreProcess(*this), "New ConstClass failed");
+  idx = InsertConst(*constRef);
+  return constRef;
+}
+
+JBCConstNameAndType *JBCConstPool::NewConstNameAndType(uint16 &idx, const std::string &name, const std::string &desc) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  uint16 idxConstName;
+  uint16 idxConstDesc;
+  JBCConstUTF8 *constName = NewConstUTF8(idxConstName, name);
+  CHECK_FATAL(idxConstName != UINT16_MAX, "constpool insert failed");
+  CHECK_NULL_FATAL(constName);
+  JBCConstUTF8 *constDesc = NewConstUTF8(idxConstDesc, desc);
+  CHECK_FATAL(idxConstDesc != UINT16_MAX, "constpool insert failed");
+  CHECK_NULL_FATAL(constDesc);
+  JBCConstNameAndType *constNameAndType = mp->New<JBCConstNameAndType>(allocator, kConstNameAndType, idxConstName,
+                                                                       idxConstDesc);
+  CHECK_FATAL(constNameAndType->PreProcess(*this), "New ConstClass failed");
+  idx = InsertConst(*constNameAndType);
+  return constNameAndType;
+}
+}  // namespace jbc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_compiler_component.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_compiler_component.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc5be8e8fb76aaa26242151328dcd5606a61a4d8
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_compiler_component.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_compiler_component.h"
+#include "jbc_class2fe_helper.h"
+#include "fe_timer.h"
+#include "fe_manager.h"
+#include "jbc_function.h"
+
+namespace maple {
+JBCCompilerComponent::JBCCompilerComponent(MIRModule &module)
+    : HIR2MPLCompilerComponent(module, kSrcLangJava),
+      mp(FEUtils::NewMempool("MemPool for JBCCompilerComponent", false /* isLocalPool */)),
+      allocator(mp),
+      jbcInput(module) {}
+
+JBCCompilerComponent::~JBCCompilerComponent() {
+  mp = nullptr;
+}
+
+void JBCCompilerComponent::ReleaseMemPoolImpl() {
+  FEUtils::DeleteMempoolPtr(mp);
+}
+
+bool JBCCompilerComponent::ParseInputImpl() {
+  FETimer timer;
+  bool success = true;
+  timer.StartAndDump("JBCCompilerComponent::ParseInput()");
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process JBCCompilerComponent::ParseInput() =====");
+  const std::list<std::string> &inputClassNames = FEOptions::GetInstance().GetInputClassFiles();
+  const std::list<std::string> &inputJarNames = FEOptions::GetInstance().GetInputJarFiles();
+  success = success && jbcInput.ReadClassFiles(inputClassNames);
+  success = success && jbcInput.ReadJarFiles(inputJarNames);
+  CHECK_FATAL(success, "JBCCompilerComponent::ParseInput failed. Exit.");
+  const jbc::JBCClass *klass = jbcInput.GetFirstClass();
+  while (klass != nullptr) {
+    FEInputStructHelper *structHelper = allocator.GetMemPool()->New<JBCClass2FEHelper>(allocator, *klass);
+    structHelpers.push_back(structHelper);
+    klass = jbcInput.GetNextClass();
+  }
+  timer.StopAndDumpTimeMS("JBCCompilerComponent::ParseInput()");
+  return success;
+}
+
+bool JBCCompilerComponent::LoadOnDemandTypeImpl() {
+  return false;
+}
+
+void JBCCompilerComponent::ProcessPragmaImpl() {}
+
+std::unique_ptr<FEFunction> JBCCompilerComponent::CreatFEFunctionImpl(FEInputMethodHelper *methodHelper) {
+  JBCClassMethod2FEHelper *jbcMethodHelper = static_cast<JBCClassMethod2FEHelper*>(methodHelper);
+  GStrIdx methodNameIdx = methodHelper->GetMethodNameIdx();
+  bool isStatic = methodHelper->IsStatic();
+  MIRFunction *mirFunc = FEManager::GetTypeManager().GetMIRFunction(methodNameIdx, isStatic);
+  CHECK_NULL_FATAL(mirFunc);
+  std::unique_ptr<FEFunction> feFunction = std::make_unique<JBCFunction>(*jbcMethodHelper, *mirFunc, phaseResultTotal);
+  module.AddFunction(mirFunc);
+  feFunction->Init();
+  return feFunction;
+}
+
+std::string JBCCompilerComponent::GetComponentNameImpl() const {
+  return "JBCCompilerComponent";
+}
+
+bool JBCCompilerComponent::ParallelableImpl() const {
+  return true;
+}
+
+void JBCCompilerComponent::DumpPhaseTimeTotalImpl() const {
+  INFO(kLncInfo, "[PhaseTime] JBCCompilerComponent");
+  HIR2MPLCompilerComponent::DumpPhaseTimeTotalImpl();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_function.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_function.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..806b6a8654280671122aabf054e1a8d802cbc5de
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_function.cpp
@@ -0,0 +1,743 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_function.h"
+#include "unistd.h"
+#include "fe_macros.h"
+#include "fe_algorithm.h"
+#include "feir_var_reg.h"
+#include "jbc_attr.h"
+#include "fe_timer.h"
+
+namespace maple {
+JBCFunction::JBCFunction(const JBCClassMethod2FEHelper &argMethodHelper, MIRFunction &mirFunc,
+                         const std::unique_ptr<FEFunctionPhaseResult> &argPhaseResultTotal)
+    : FEFunction(mirFunc, argPhaseResultTotal),
+      methodHelper(argMethodHelper),
+      method(methodHelper.GetMethod()),
+      context(method.GetConstPool(), stack2feHelper, method.GetCode()) {
+  srcLang = MIRSrcLang::kSrcLangJava;
+}
+
+JBCFunction::~JBCFunction() {
+  pesudoBBCatchPred = nullptr;
+}
+
+void JBCFunction::InitImpl() {
+  FEFunction::InitImpl();
+  feirCFG = std::make_unique<FEIRCFG>(feirStmtHead, feirStmtHead);
+  feirCFG->Init();
+  pesudoBBCatchPred = RegisterFEIRBB(std::make_unique<JBCBBPesudoCatchPred>());
+}
+
+void JBCFunction::PreProcessImpl() {
+}
+
+bool JBCFunction::ProcessImpl() {
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "JBCFunction::Process() for %s", method.GetFullName().c_str());
+  bool success = true;
+  if (!methodHelper.HasCode()) {
+    return success;  // Skip abstract and native method, not emit it to mpl but mplts.
+  }
+  success = success && GenerateGeneralStmt("create general stmt");
+  success = success && LabelGeneralStmts("label general stmt");
+  success = success && LabelFEIRBBs("label general bb");
+  success = success && LabelLabelIdx("label label idx");
+  success = success && CheckJVMStack("check jvm stack");
+  success = success && GenerateArgVarList("gen arg var list");
+  success = success && ProcessFunctionArgs("process func args");
+  if (FEOptions::GetInstance().IsEmitJBCLocalVarInfo()) {
+    success = success && EmitLocalVarInfo("emit localvar info");
+  }
+  success = success && EmitToFEIRStmt("emit to feir");
+  success = success && ProcessFEIRFunction();
+  if (!success) {
+    error = true;
+    ERR(kLncErr, "JBCFunction::Process() failed for %s", method.GetFullName().c_str());
+  }
+  return success;
+}
+
+void JBCFunction::FinishImpl() {
+  bool dumpFunc = true;
+  dumpFunc = (FEOptions::GetInstance().IsDumpJBCErrorOnly() && error) ||
+             FEOptions::GetInstance().IsDumpJBCAll() ||
+             FEOptions::GetInstance().IsDumpJBCFuncName(method.GetFullName());
+  if (dumpFunc) {
+    (void)BuildGeneralStmtBBMap("gen stmt_bb_map");
+  }
+  if (FEOptions::GetInstance().IsDumpJBCStmt() && dumpFunc) {
+    DumpGeneralStmts();
+  }
+  if (FEOptions::GetInstance().IsDumpFEIRBB() && dumpFunc) {
+    INFO(kLncInfo, "not implemented");
+  }
+  if (FEOptions::GetInstance().IsDumpFEIRCFGGraph(method.GetFullName())) {
+    (void)DumpFEIRCFGGraph("dump cfg graph");
+  }
+  (void)UpdateFormal("finish/update formal");
+  // Not gen func body for abstract method
+  if (methodHelper.HasCode() || methodHelper.IsNative()) {
+    (void)EmitToMIR("finish/emit to mir");
+  }
+  bool recordTime = FEOptions::GetInstance().IsDumpPhaseTime() || FEOptions::GetInstance().IsDumpPhaseTimeDetail();
+  if (phaseResultTotal != nullptr && recordTime) {
+    phaseResultTotal->Combine(phaseResult);
+  }
+  if (FEOptions::GetInstance().IsDumpPhaseTimeDetail()) {
+    INFO(kLncInfo, "[PhaseTime] function: %s", method.GetFullName().c_str());
+    phaseResult.Dump();
+  }
+}
+
+bool JBCFunction::PreProcessTypeNameIdx() {
+  return false;
+}
+
+bool JBCFunction::GenerateGeneralStmt(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  const jbc::JBCAttrCode *code = method.GetCode();
+  if (phaseResult.IsSuccess() && code != nullptr) {
+    if (!PreBuildJsrInfo(*code)) {
+      return phaseResult.Finish(false);
+    }
+    if (!BuildStmtFromInstruction(*code)) {
+      return phaseResult.Finish(false);
+    }
+    BuildStmtForCatch(*code);
+    BuildStmtForTry(*code);
+    BuildStmtForLOC(*code);
+    if (FEOptions::GetInstance().IsDumpInstComment()) {
+      BuildStmtForInstComment(*code);
+    }
+    ArrangeStmts();
+  }
+  return phaseResult.Finish(true);
+}
+
+void JBCFunction::GenerateGeneralStmtFailCallBack() {
+}
+
+void JBCFunction::GenerateGeneralDebugInfo() {
+}
+
+bool JBCFunction::VerifyGeneral() {
+  return false;
+}
+
+void JBCFunction::VerifyGeneralFailCallBack() {
+}
+
+bool JBCFunction::GenerateAliasVars(const std::string &phaseName) {
+  (void) phaseName;
+  return true;
+}
+
+bool JBCFunction::GenerateArgVarList(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  InitStack2FEHelper();
+  uint32 slotIdx = 0;
+  for (FEIRType *type : methodHelper.GetArgTypes()) {
+    PrimType pt = type->GetPrimType();
+    std::unique_ptr<FEIRVar> var = std::make_unique<FEIRVarReg>(stack2feHelper.GetRegNumForSlot(slotIdx),
+                                                                type->Clone());
+    argVarList.push_back(std::move(var));
+    if (type->IsScalar() && (pt == PTY_i64 || pt == PTY_f64)) {
+      slotIdx += JBCStack2FEHelper::kRegNumOffWide;
+    } else {
+      slotIdx += JBCStack2FEHelper::kRegNumOff;
+    }
+  }
+  return phaseResult.Finish();
+}
+
+bool JBCFunction::ProcessFunctionArgs(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  for (const UniqueFEIRVar &argVar : argVarList) {
+    ASSERT(argVar != nullptr, "nullptr check for argVar");
+    const UniqueFEIRType &type = argVar->GetType();
+    ASSERT(type != nullptr, "nullptr check for type");
+    if (!type->IsScalar()) {
+      continue;
+    }
+    PrimType pty = type->GetPrimType();
+    bool useZExt = (pty == PTY_u1 || pty == PTY_u16);
+    bool useSExt = (pty == PTY_i8 || pty == PTY_i16);
+    if (useZExt || useSExt) {
+      UniqueFEIRVar dstVar = argVar->Clone();
+      dstVar->GetType()->SetPrimType(PTY_i32);
+      UniqueFEIRExpr exprExt = useZExt ? FEIRBuilder::CreateExprZExt(argVar->Clone()) :
+                                         FEIRBuilder::CreateExprSExt(argVar->Clone());
+      UniqueFEIRStmt stmtExt = FEIRBuilder::CreateStmtDAssign(std::move(dstVar), std::move(exprExt));
+      FEIRStmt *ptrFEIRStmt = RegisterFEIRStmt(std::move(stmtExt));
+      feirStmtTail->InsertBefore(ptrFEIRStmt);
+    }
+  }
+  return phaseResult.Finish();
+}
+
+bool JBCFunction::EmitLocalVarInfo(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  const jbc::JBCAttrCode *code = method.GetCode();
+  if (code == nullptr) {
+    return phaseResult.Finish();
+  }
+  FEIRStmt *insPos = feirStmtHead;
+  std::list<std::string> listInfo = code->GetLocalVarInfoByString();
+  for (const std::string &infoStr : listInfo) {
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtPesudoComment>(infoStr);
+    FEIRStmt *ptrFEIRStmt = RegisterFEIRStmt(std::move(stmt));
+    insPos->InsertAfter(ptrFEIRStmt);
+    insPos = ptrFEIRStmt;
+  }
+  return phaseResult.Finish();
+}
+
+bool JBCFunction::EmitToFEIRStmt(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  const FELinkListNode *bbNode = genBBHead->GetNext();
+  while (bbNode != nullptr && bbNode != genBBTail) {
+    const JBCBB *bb = static_cast<const JBCBB*>(bbNode);
+    EmitToFEIRStmt(*bb);
+    bbNode = bbNode->GetNext();
+  }
+  return phaseResult.Finish();
+}
+
+void JBCFunction::EmitToFEIRStmt(const JBCBB &bb) {
+  bool success = false;
+  std::list<UniqueFEIRStmt> feirStmts = stack2feHelper.LoadSwapStack(bb.GetMinStackIn(), success);
+  if (success == false) {
+    ERR(kLncErr, "LoadSwapStack Error for %s", method.GetFullName().c_str());
+    return;
+  }
+  AppendFEIRStmts(feirStmts);
+  const FELinkListNode *stmtNode = bb.GetStmtHead();
+  while (stmtNode != nullptr && success) {
+    const JBCStmt *stmt = static_cast<const JBCStmt*>(stmtNode);
+    feirStmts = stmt->EmitToFEIR(context, success);
+    AppendFEIRStmts(feirStmts);
+    if (stmtNode == bb.GetStmtTail()) {
+      break;
+    }
+    stmtNode = stmtNode->GetNext();
+  }
+}
+
+std::string JBCFunction::GetGeneralFuncName() const {
+  return method.GetFullName();
+}
+
+bool JBCFunction::CheckJVMStack(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  bool success = phaseResult.IsSuccess();
+  FELinkListNode *nodeBB = genBBHead->GetNext();
+  if (nodeBB == genBBTail) {
+    // empty function
+    return phaseResult.Finish(success);
+  }
+  // initialize function head
+  JBCBB *jbcBB = static_cast<JBCBB*>(nodeBB);
+  success = success && jbcBB->InitForFuncHeader();
+  // initialize catch
+  for (FEIRBB *bbCatch : pesudoBBCatchPred->GetSuccBBs()) {
+    JBCBB *jbcBBCatch = static_cast<JBCBB*>(bbCatch);
+    success = success && jbcBBCatch->InitForCatch();
+  }
+  // process
+  if (!success) {
+    return phaseResult.Finish(false);
+  }
+  std::map<JBCBB*, std::set<JBCBB*>> correlation;
+  while (nodeBB != genBBTail) {
+    jbcBB = static_cast<JBCBB*>(nodeBB);
+    for (FEIRBB *bb : jbcBB->GetPredBBs()) {
+      if (bb != genBBHead && bb != pesudoBBCatchPred) {
+        CHECK_FATAL(correlation[jbcBB].insert(static_cast<JBCBB*>(bb)).second, "correlation map insert failed");
+      }
+    }
+    nodeBB = nodeBB->GetNext();
+  }
+  CorrelativeMerge<JBCBB> stackUpdater(correlation, &JBCBB::UpdateStackByPredBB, &JBCBB::UpdateStackByPredBBEnd);
+  stackUpdater.ProcessAll();
+  success = !stackUpdater.GetError();
+  success = success && CheckJVMStackResult();
+  return phaseResult.Finish(success);
+}
+
+bool JBCFunction::CheckJVMStackResult() {
+  FELinkListNode *nodeBB = genBBHead->GetNext();
+  while (nodeBB != nullptr && nodeBB != genBBTail) {
+    JBCBB *jbcBB = static_cast<JBCBB*>(nodeBB);
+    if (!jbcBB->CheckStack()) {
+      return false;
+    }
+    nodeBB = nodeBB->GetNext();
+  }
+  return true;
+}
+
+bool JBCFunction::PreBuildJsrInfo(const jbc::JBCAttrCode &code) {
+  const MapleMap<const uint32, jbc::JBCOp*> &instMap = code.GetInstMap();
+  for (const std::pair<const uint32, jbc::JBCOp*> &it : instMap) {
+    uint32 pc = it.first;
+    jbc::JBCOp *op = it.second;
+    ASSERT_NOT_NULL(op);
+    jbc::JBCOpcode opcode = op->GetOpcode();
+    jbc::JBCOpcodeKind kind = op->GetOpcodeKind();
+    if (kind != jbc::kOpKindJsr) {
+      continue;
+    }
+    uint32 width = (opcode == jbc::kOpJsr ? 3 : 5);  // instruction width for jsr is 3, and for jsr_w is 5
+    uint32 nextPC = pc + width;
+    jbc::JBCOpJsr *opJsr = static_cast<jbc::JBCOpJsr*>(op);
+    auto itTarget = instMap.find(opJsr->GetTarget());
+    if (itTarget == instMap.end()) {
+      ERR(kLncErr, "invalid target %u for jsr @pc=%u", opJsr->GetTarget(), pc);
+      return false;
+    }
+    jbc::JBCOp *opTarget = itTarget->second;
+    if (opTarget->GetOpcodeKind() != jbc::kOpKindStore) {
+      ERR(kLncErr, "invalid target (without astore) for jsr @pc=%u", pc);
+      return false;
+    }
+    jbc::JBCOpSlotOpr *opSlotOpr = static_cast<jbc::JBCOpSlotOpr*>(opTarget);
+    uint16 slotIdx = opSlotOpr->GetSlotIdx();
+    opSlotOpr->SetAddressOpr();
+    opJsr->SetSlotIdx(slotIdx);
+    int32 jsrID = context.RegisterJsrSlotRetAddr(slotIdx, nextPC);
+    opJsr->SetJsrID(jsrID);
+  }
+  return true;
+}
+
+bool JBCFunction::BuildStmtFromInstruction(const jbc::JBCAttrCode &code) {
+  FEIRStmt *stmt = nullptr;
+  const MapleMap<const uint32, jbc::JBCOp*> &instMap = code.GetInstMap();
+  for (const std::pair<const uint32, jbc::JBCOp*> &it : instMap) {
+    uint32 pc = it.first;
+    const jbc::JBCOp *op = it.second;
+    ASSERT(op != nullptr, "null ptr check");
+    switch (op->GetOpcodeKind()) {
+      case jbc::kOpKindBranch:
+        stmt = BuildStmtFromInstructionForBranch(*op);
+        break;
+      case jbc::kOpKindGoto:
+        stmt = BuildStmtFromInstructionForGoto(*op);
+        break;
+      case jbc::kOpKindSwitch:
+        stmt = BuildStmtFromInstructionForSwitch(*op);
+        break;
+      case jbc::kOpKindJsr:
+        stmt = BuildStmtFromInstructionForJsr(*op);
+        break;
+      case jbc::kOpKindRet:
+        stmt = BuildStmtFromInstructionForRet(*op);
+        if (stmt == nullptr) {
+          return false;
+        }
+        break;
+      default:
+        stmt = RegisterFEIRStmt(std::make_unique<JBCStmtInst>(*op));
+        break;
+    }
+    stmt->SetThrowable(op->IsThrowable());
+    static_cast<JBCStmt*>(stmt)->SetPC(pc);
+    genStmtTail->InsertBefore(stmt);
+    context.UpdateMapPCStmtInst(pc, stmt);
+  }
+  context.UpdateMapPCStmtInst(code.GetCodeLength(), genStmtTail);
+  return true;
+}
+
+FEIRStmt *JBCFunction::BuildStmtFromInstructionForBranch(const jbc::JBCOp &op) {
+  const std::unique_ptr<FEIRStmt> &uniStmt =
+      RegisterGeneralStmtUniqueReturn(std::make_unique<JBCStmtInstBranch>(op));
+  FEIRStmt *stmt = uniStmt.get();
+  const jbc::JBCOpBranch &opBranch = static_cast<const jbc::JBCOpBranch&>(op);
+  FEIRStmt *target = BuildAndUpdateLabel(opBranch.GetTarget(), uniStmt);
+  static_cast<JBCStmtInstBranch*>(stmt)->AddExtraSucc(*target);
+  return stmt;
+}
+
+FEIRStmt *JBCFunction::BuildStmtFromInstructionForGoto(const jbc::JBCOp &op) {
+  const std::unique_ptr<FEIRStmt> &uniStmt =
+      RegisterGeneralStmtUniqueReturn(std::make_unique<JBCStmtInstBranch>(op));
+  FEIRStmt *stmt = uniStmt.get();
+  stmt->SetFallThru(false);
+  const jbc::JBCOpGoto &opGoto = static_cast<const jbc::JBCOpGoto&>(op);
+  FEIRStmt *target = BuildAndUpdateLabel(opGoto.GetTarget(), uniStmt);
+  static_cast<JBCStmtInstBranch*>(stmt)->AddExtraSucc(*target);
+  return stmt;
+}
+
+FEIRStmt *JBCFunction::BuildStmtFromInstructionForSwitch(const jbc::JBCOp &op) {
+  const std::unique_ptr<FEIRStmt> &uniStmt =
+      RegisterGeneralStmtUniqueReturn(std::make_unique<JBCStmtInstBranch>(op));
+  FEIRStmt *stmt = uniStmt.get();
+  stmt->SetFallThru(false);
+  const jbc::JBCOpSwitch &opSwitch = static_cast<const jbc::JBCOpSwitch&>(op);
+  for (const std::pair<const int32, uint32> &targetInfo : opSwitch.GetTargets()) {
+    FEIRStmt *target = BuildAndUpdateLabel(targetInfo.second, uniStmt);
+    static_cast<JBCStmtInstBranch*>(stmt)->AddExtraSucc(*target);
+  }
+  FEIRStmt *target = BuildAndUpdateLabel(opSwitch.GetDefaultTarget(), uniStmt);
+  static_cast<JBCStmtInstBranch*>(stmt)->AddExtraSucc(*target);
+  return stmt;
+}
+
+FEIRStmt *JBCFunction::BuildStmtFromInstructionForJsr(const jbc::JBCOp &op) {
+  const std::unique_ptr<FEIRStmt> &uniStmt =
+      RegisterGeneralStmtUniqueReturn(std::make_unique<JBCStmtInstBranch>(op));
+  FEIRStmt *stmt = uniStmt.get();
+  stmt->SetFallThru(false);
+  const jbc::JBCOpJsr &opJsr = static_cast<const jbc::JBCOpJsr&>(op);
+  FEIRStmt *target = BuildAndUpdateLabel(opJsr.GetTarget(), uniStmt);
+  static_cast<JBCStmtInstBranch*>(stmt)->AddExtraSucc(*target);
+  return stmt;
+}
+
+FEIRStmt *JBCFunction::BuildStmtFromInstructionForRet(const jbc::JBCOp &op) {
+  const std::map<uint16, std::map<int32, uint32>> &mapJsrSlotRetAddr = context.GetMapJsrSlotRetAddr();
+  const std::unique_ptr<FEIRStmt> &uniStmt =
+      RegisterGeneralStmtUniqueReturn(std::make_unique<JBCStmtInstBranchRet>(op));
+  FEIRStmt *stmt = uniStmt.get();
+  stmt->SetFallThru(false);
+  const jbc::JBCOpRet &opRet = static_cast<const jbc::JBCOpRet&>(op);
+  auto itJsrInfo = mapJsrSlotRetAddr.find(opRet.GetIndex());
+  if (itJsrInfo == mapJsrSlotRetAddr.end()) {
+    ERR(kLncWarn, "invalid slotIdx for ret instruction");
+    return nullptr;
+  }
+  for (auto itTarget : itJsrInfo->second) {
+    uint32 pc = itTarget.second;
+    FEIRStmt *target = BuildAndUpdateLabel(pc, uniStmt);
+    static_cast<JBCStmtInstBranch*>(stmt)->AddExtraSucc(*target);
+  }
+  return stmt;
+}
+
+void JBCFunction::BuildStmtForCatch(const jbc::JBCAttrCode &code) {
+  const std::map<uint32, JBCStmtPesudoCatch*> &mapPCCatchStmt = context.GetMapPCCatchStmt();
+  const MapleVector<jbc::attr::ExceptionTableItem*> &exceptionInfo = code.GetExceptionInfos();
+  for (const jbc::attr::ExceptionTableItem *item : exceptionInfo) {
+    uint16 handlerPC = item->GetHandlerPC();
+    JBCStmtPesudoCatch *stmtCatch = nullptr;
+    auto it = mapPCCatchStmt.find(handlerPC);
+    if (it == mapPCCatchStmt.end()) {
+      stmtCatch = static_cast<JBCStmtPesudoCatch*>(RegisterFEIRStmt(std::make_unique<JBCStmtPesudoCatch>()));
+      context.UpdateMapPCCatchStmt(handlerPC, stmtCatch);
+    } else {
+      stmtCatch = static_cast<JBCStmtPesudoCatch*>(it->second);
+    }
+    const jbc::JBCConstClass *catchType = item->GetCatchType();
+    if (catchType != nullptr) {
+      stmtCatch->AddCatchTypeName(catchType->GetClassNameIdxMpl());
+    } else {
+      stmtCatch->AddCatchTypeName(GStrIdx(0));
+    }
+  }
+}
+
+void JBCFunction::BuildStmtForTry(const jbc::JBCAttrCode &code) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  const std::map<uint32, JBCStmtPesudoCatch*> &mapPCCatchStmt = context.GetMapPCCatchStmt();
+  const MapleVector<jbc::attr::ExceptionTableItem*> &exceptionInfo = code.GetExceptionInfos();
+  for (const jbc::attr::ExceptionTableItem *item : exceptionInfo) {
+    uint32 start = item->GetStartPC();
+    uint32 end = item->GetEndPC();
+    uint32 handlerPC = item->GetHandlerPC();
+    rawInfo[std::make_pair(start, end)].push_back(handlerPC);
+  }
+  BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  for (const std::pair<const uint32, uint32> &startEnd : outMapStartEnd) {
+    // Try
+    JBCStmtPesudoTry *stmtTry =
+        static_cast<JBCStmtPesudoTry*>(RegisterFEIRStmt(std::make_unique<JBCStmtPesudoTry>()));
+    auto it = outMapStartCatch.find(startEnd.first);
+    CHECK_FATAL(it != outMapStartCatch.end(), "catch info not exist");
+    for (uint32 handlerPC : it->second) {
+      auto itHandler = mapPCCatchStmt.find(handlerPC);
+      CHECK_FATAL(itHandler != mapPCCatchStmt.end(), "catch stmt not exist");
+      stmtTry->AddCatchStmt(*(itHandler->second));
+    }
+    context.UpdateMapPCTryStmt(startEnd.first, stmtTry);
+    // EndTry
+    JBCStmtPesudoEndTry *stmtEndTry =
+        static_cast<JBCStmtPesudoEndTry*>(RegisterFEIRStmt(std::make_unique<JBCStmtPesudoEndTry>()));
+    context.UpdateMapPCEndTryStmt(startEnd.second, stmtEndTry);
+  }
+}
+
+void JBCFunction::BuildTryInfo(const std::map<std::pair<uint32, uint32>, std::vector<uint32>> &rawInfo,
+                               std::map<uint32, uint32> &outMapStartEnd,
+                               std::map<uint32, std::vector<uint32>> &outMapStartCatch) {
+  const uint8 flagStart = 0x1;
+  const uint8 flagEnd = 0x2;
+  const uint8 flagCatch = 0x4;
+  std::map<uint32, uint8> keyPoints;
+  std::map<uint32, std::set<uint32>> mapStartEnds;
+  std::map<uint32, std::set<uint32>> mapEndStarts;
+  for (auto info : rawInfo) {
+    keyPoints[info.first.first] |= flagStart;
+    keyPoints[info.first.second] |= flagEnd;
+    for (uint32 handlerPC : info.second) {
+      keyPoints[handlerPC] |= flagCatch;
+    }
+    CHECK_FATAL(mapStartEnds[info.first.first].insert(info.first.second).second, "mapStartEnds insert failed");
+    CHECK_FATAL(mapEndStarts[info.first.second].insert(info.first.first).second, "mapEndStarts insert failed");
+  }
+  std::deque<std::pair<uint32, uint32>> blockQueue;
+  const uint32 posInvalid = 0xFFFFFFFF;
+  uint32 startPos = posInvalid;
+  for (auto keyPoint : keyPoints) {
+    uint32 curPos = keyPoint.first;
+    uint8 flag = keyPoint.second;
+    // set try block
+    if (startPos != posInvalid) {
+      outMapStartEnd[startPos] = curPos;
+      BuildTryInfoCatch(rawInfo, blockQueue, startPos, outMapStartCatch);
+      startPos = curPos;
+    }
+    // process end
+    if ((flag & flagEnd) != 0) {
+      blockQueue.push_back(std::make_pair(posInvalid, posInvalid));
+      std::pair<uint32, uint32> top;
+      do {
+        top = blockQueue.front();
+        blockQueue.pop_front();
+        bool deleted = false;
+        if (top.second == curPos) {
+          ASSERT(mapEndStarts.find(curPos) != mapEndStarts.end(), "try end not found");
+          if (mapEndStarts[curPos].find(top.first) != mapEndStarts[curPos].end()) {
+            deleted = true;
+          }
+        }
+        if (!deleted && top.first != posInvalid) {
+          blockQueue.push_back(top);
+        }
+      } while (top.first != posInvalid);
+      if (blockQueue.size() == 0) {
+        startPos = posInvalid;
+      }
+    }
+    // process start
+    if ((flag & flagStart) != 0) {
+      startPos = curPos;
+      for (uint32 endPos : mapStartEnds[curPos]) {
+        blockQueue.push_back(std::make_pair(curPos, endPos));
+      }
+    }
+  }
+}
+
+void JBCFunction::BuildTryInfoCatch(const std::map<std::pair<uint32, uint32>, std::vector<uint32>> &rawInfo,
+                                    const std::deque<std::pair<uint32, uint32>> &blockQueue,
+                                    uint32 startPos,
+                                    std::map<uint32, std::vector<uint32>> &outMapStartCatch) {
+  std::set<uint32> catchSet;
+  for (const std::pair<uint32, uint32> &block : blockQueue) {
+    auto it = rawInfo.find(block);
+    CHECK_FATAL(it != rawInfo.end(), "block not found");
+    for (uint32 handlerPC : it->second) {
+      if (catchSet.find(handlerPC) == catchSet.end()) {
+        outMapStartCatch[startPos].push_back(handlerPC);
+        CHECK_FATAL(catchSet.insert(handlerPC).second, "catchSet insert failed");
+      }
+    }
+  }
+}
+
+void JBCFunction::BuildStmtForLOC(const jbc::JBCAttrCode &code) {
+  const jbc::JBCAttr *attrRaw = code.GetAttr(jbc::JBCAttrKind::kAttrLineNumberTable);
+  if (attrRaw == nullptr) {
+    return;
+  }
+  const jbc::JBCAttrLineNumberTable *attrLineNumTab = static_cast<const jbc::JBCAttrLineNumberTable*>(attrRaw);
+  uint32 srcFileIdx = method.GetClass().GetSrcFileInfoIdx();
+  const MapleVector<jbc::attr::LineNumberTableItem*> &lineNums = attrLineNumTab->GetLineNums();
+  for (const jbc::attr::LineNumberTableItem *item : lineNums) {
+    JBCStmtPesudoLOC *stmtLOC =
+        static_cast<JBCStmtPesudoLOC*>(RegisterFEIRStmt(std::make_unique<JBCStmtPesudoLOC>()));
+    stmtLOC->SetSrcFileIdx(srcFileIdx);
+    stmtLOC->SetLineNumber(item->GetLineNumber());
+    context.UpdateMapPCStmtLOC(item->GetStartPC(), stmtLOC);
+  }
+}
+
+void JBCFunction::BuildStmtForInstComment(const jbc::JBCAttrCode &code) {
+  const jbc::JBCAttr *attrRaw = code.GetAttr(jbc::JBCAttrKind::kAttrLineNumberTable);
+  std::map<uint32, uint16> mapPCLineNum;
+  if (attrRaw != nullptr) {
+    const jbc::JBCAttrLineNumberTable *attrLineNumTab = static_cast<const jbc::JBCAttrLineNumberTable*>(attrRaw);
+    const MapleVector<jbc::attr::LineNumberTableItem*> &lineNums = attrLineNumTab->GetLineNums();
+    for (const jbc::attr::LineNumberTableItem *item : lineNums) {
+      ASSERT_NOT_NULL(item);
+      mapPCLineNum[item->GetStartPC()] = item->GetLineNumber();
+    }
+  }
+  uint16 currLineNum = 0xFFFF;  // use 0xFFFF as invalid line number
+  std::stringstream ss;
+  const jbc::JBCConstPool &constPool = method.GetConstPool();
+  const MapleMap<const uint32, jbc::JBCOp*> &instMap = code.GetInstMap();
+  for (const std::pair<const uint32, jbc::JBCOp*> &it : instMap) {
+    uint32 pc = it.first;
+    jbc::JBCOp *op = it.second;
+    if (mapPCLineNum.find(pc) != mapPCLineNum.end()) {
+      currLineNum = mapPCLineNum[pc];
+    }
+    ASSERT(pc < 0x10000, "invalid pc");  // pc use 16bit in java bytecode (less than 0x10000)
+    ss << "LINE " << srcFileName << " : ";
+    if (currLineNum != 0xFFFF) {  // use 0xFFFF as invalid line number
+      ss << std::dec << currLineNum;
+    } else {
+      ss << "unknown";
+    }
+    ss << ", PC : " << std::setfill(' ') << std::setw(5) << pc << "||" <<
+          std::setfill('0') << std::setw(4) << std::hex << pc << " : " <<
+          op->Dump(constPool);
+    std::unique_ptr<JBCStmt> stmt = std::make_unique<JBCStmtPesudoComment>(ss.str());
+    JBCStmtPesudoComment *ptrStmt = static_cast<JBCStmtPesudoComment*>(RegisterFEIRStmt(std::move(stmt)));
+    context.UpdateMapPCCommentStmt(pc, ptrStmt);
+    ss.str("");
+  }
+}
+
+FEIRStmt *JBCFunction::BuildAndUpdateLabel(uint32 dstPC, const std::unique_ptr<FEIRStmt> &srcStmt) {
+  const std::map<uint32, JBCStmtPesudoLabel*> &mapPCLabelStmt = context.GetMapPCLabelStmt();
+  auto it = mapPCLabelStmt.find(dstPC);
+  JBCStmtPesudoLabel *stmtLabel = nullptr;
+  if (it == mapPCLabelStmt.end()) {
+    stmtLabel = static_cast<JBCStmtPesudoLabel*>(RegisterFEIRStmt(std::make_unique<JBCStmtPesudoLabel>()));
+    context.UpdateMapPCLabelStmt(dstPC, stmtLabel);
+  } else {
+    stmtLabel = it->second;
+  }
+  ASSERT(stmtLabel != nullptr, "null ptr check");
+  stmtLabel->AddExtraPred(*srcStmt);
+  return stmtLabel;
+}
+
+void JBCFunction::ArrangeStmts() {
+  context.ArrangeStmts();
+}
+
+void JBCFunction::InitStack2FEHelper() {
+  const jbc::JBCAttrCode *code = method.GetCode();
+  // args
+  uint32 nargs = 0;
+  for (FEIRType *type : methodHelper.GetArgTypes()) {
+    PrimType pt = type->GetPrimType();
+    if (type->IsScalar() && (pt == PTY_i64 || pt == PTY_f64)) {
+      nargs += JBCStack2FEHelper::kRegNumOffWide;
+    } else {
+      nargs += JBCStack2FEHelper::kRegNumOff;
+    }
+  }
+  if (code == nullptr) {
+    stack2feHelper.SetNArgs(nargs);
+    stack2feHelper.SetNLocals(0);
+    stack2feHelper.SetNStacks(0);
+    stack2feHelper.SetNSwaps(0);
+    return;
+  }
+  stack2feHelper.SetNArgs(nargs);
+  CHECK_FATAL(nargs <= code->GetMaxLocals(), "invalid jbc method");
+  stack2feHelper.SetNLocals(code->GetMaxLocals() - nargs);
+  stack2feHelper.SetNStacks(code->GetMaxStack());
+  stack2feHelper.SetNSwaps(CalculateMaxSwapSize());
+  if (!FEOptions::GetInstance().IsDumpInstComment()) {
+    return;
+  }
+  std::stringstream ss;
+  ss << "StackToReg Info: nStacks=" << stack2feHelper.GetNStacks() <<
+        ", nSwaps=" << stack2feHelper.GetNSwaps() <<
+        ", maxLocals=" << code->GetMaxLocals() <<
+        ", nArgs=" << stack2feHelper.GetNArgs();
+  feirStmtTail->InsertBefore(RegisterFEIRStmt(FEIRBuilder::CreateStmtComment(ss.str())));
+  feirStmtTail->InsertBefore(RegisterFEIRStmt(FEIRBuilder::CreateStmtComment("==== Reg Map ====")));
+  uint32 regStart = 0;
+  ss.str("");
+  ss << "  " << regStart << " - " << (regStart + stack2feHelper.GetNStacks() - 1) << ": stacks";
+  feirStmtTail->InsertBefore(RegisterFEIRStmt(FEIRBuilder::CreateStmtComment(ss.str())));
+  regStart += stack2feHelper.GetNStacks();
+  if (stack2feHelper.GetNSwaps() > 0) {
+    ss.str("");
+    ss << "  " << regStart << " - " << (regStart + stack2feHelper.GetNSwaps() - 1) << ": swaps";
+    feirStmtTail->InsertBefore(RegisterFEIRStmt(FEIRBuilder::CreateStmtComment(ss.str())));
+    regStart += stack2feHelper.GetNSwaps();
+  }
+  if (stack2feHelper.GetNLocals() > 0) {
+    ss.str("");
+    ss << "  " << regStart << " - " << (regStart + stack2feHelper.GetNLocals() - 1) << ": locals";
+    feirStmtTail->InsertBefore(RegisterFEIRStmt(FEIRBuilder::CreateStmtComment(ss.str())));
+    regStart += stack2feHelper.GetNLocals();
+  }
+  if (stack2feHelper.GetNArgs() > 0) {
+    ss.str("");
+    ss << "  " << regStart << " - " << (regStart + stack2feHelper.GetNArgs() - 1) << ": args";
+    feirStmtTail->InsertBefore(RegisterFEIRStmt(FEIRBuilder::CreateStmtComment(ss.str())));
+  }
+  feirStmtTail->InsertBefore(RegisterFEIRStmt(FEIRBuilder::CreateStmtComment("=================")));
+}
+
+uint32 JBCFunction::CalculateMaxSwapSize() const {
+  const FELinkListNode *nodeBB = genBBHead->GetNext();
+  uint32 size = 0;
+  while (nodeBB != nullptr && nodeBB != genBBTail) {
+    const JBCBB *bb = static_cast<const JBCBB*>(nodeBB);
+    uint32 tmp = bb->GetSwapSize();
+    size = size > tmp ? size : tmp;
+    nodeBB = nodeBB->GetNext();
+  }
+  return size;
+}
+
+bool JBCFunction::LabelLabelIdx(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  uint32 idx = 0;
+  FELinkListNode *nodeStmt = genStmtHead->GetNext();
+  while (nodeStmt != nullptr && nodeStmt != genStmtTail) {
+    JBCStmt *stmt = static_cast<JBCStmt*>(nodeStmt);
+    if (stmt->GetJBCKind() == JBCStmtKind::kJBCStmtPesudoLabel ||
+        stmt->GetJBCKind() == JBCStmtKind::kJBCStmtPesudoCatch) {
+      JBCStmtPesudoLabel *stmtLabel = static_cast<JBCStmtPesudoLabel*>(stmt);
+      stmtLabel->SetLabelIdx(idx);
+      idx++;
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+  return phaseResult.Finish();
+}
+
+bool JBCFunction::NeedConvertToInt32(const std::unique_ptr<FEIRVar> &var) {
+  ASSERT(var != nullptr, "nullptr check for var");
+  const std::unique_ptr<FEIRType> &type = var->GetType();
+  if (!type->IsScalar()) {
+    return false;
+  }
+  PrimType pty = type->GetPrimType();
+  // Z: PTY_u1
+  // B: PTY_i8
+  // C: PTY_u16
+  // S: PTY_i16
+  if (pty == PTY_u1 || pty == PTY_u8 || pty == PTY_i8 || pty == PTY_u16 || pty == PTY_i16) {
+    return true;
+  } else {
+    return false;
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_function_context.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_function_context.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..87ceb84e22b6108d8a08c48a41160354aa980f15
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_function_context.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_function_context.h"
+
+namespace maple {
+int32 JBCFunctionContext::RegisterJsrSlotRetAddr(uint16 slotIdx, uint32 nextPC) {
+  auto itInfo = mapJsrSlotRetAddr.find(slotIdx);
+  int32 jsrID;
+  if (itInfo == mapJsrSlotRetAddr.end()) {
+    jsrID = 0;
+  } else {
+    size_t size = itInfo->second.size();
+    CHECK_FATAL(size < INT32_MAX, "jsr ID out of range");
+    jsrID = static_cast<int32>(itInfo->second.size());
+  }
+  mapJsrSlotRetAddr[slotIdx][jsrID] = nextPC;
+  return jsrID;
+}
+
+void JBCFunctionContext::ArrangeStmts() {
+  /* Type of stmt: inst, label, try, endtry, catch, comment, loc
+   *   endtry
+   *   loc
+   *   catch
+   *   label
+   *   try
+   *   comment
+   *   inst
+   */
+  for (const std::pair<const uint32, FEIRStmt*> &pcInst : mapPCStmtInst) {
+    uint32 pc = pcInst.first;
+    FEIRStmt *stmtInst = pcInst.second;
+    if (mapPCEndTryStmt.find(pc) != mapPCEndTryStmt.end()) {
+      stmtInst->InsertBefore(mapPCEndTryStmt[pc]);
+    }
+    if (mapPCStmtLOC.find(pc) != mapPCStmtLOC.end()) {
+      stmtInst->InsertBefore(mapPCStmtLOC[pc]);
+    }
+    if (mapPCCatchStmt.find(pc) != mapPCCatchStmt.end()) {
+      stmtInst->InsertBefore(mapPCCatchStmt[pc]);
+    }
+    if (mapPCLabelStmt.find(pc) != mapPCLabelStmt.end()) {
+      stmtInst->InsertBefore(mapPCLabelStmt[pc]);
+    }
+    if (mapPCTryStmt.find(pc) != mapPCTryStmt.end()) {
+      stmtInst->InsertBefore(mapPCTryStmt[pc]);
+    }
+    if (mapPCCommentStmt.find(pc) != mapPCCommentStmt.end()) {
+      stmtInst->InsertBefore(mapPCCommentStmt[pc]);
+    }
+  }
+}
+
+const FEIRType *JBCFunctionContext::GetSlotType(uint16 slotIdx, uint32 pc) const {
+  CHECK_NULL_FATAL(code);
+  const jbc::JBCAttrLocalVariableInfo &localVarInfo = code->GetLocalVarInfo();
+  CHECK_FATAL(pc < UINT16_MAX, "pc out of range");
+  uint16 startPC = localVarInfo.GetStart(slotIdx, static_cast<uint16>(pc));
+  const jbc::JavaAttrLocalVariableInfoItem &info = localVarInfo.GetItemByStart(slotIdx, startPC);
+  return info.feirType;
+}
+
+const FEIRType *JBCFunctionContext::GetSlotType(uint16 slotIdx) const {
+  CHECK_NULL_FATAL(code);
+  const jbc::JBCAttrLocalVariableInfo &localVarInfo = code->GetLocalVarInfo();
+  CHECK_FATAL(currPC < UINT16_MAX, "pc out of range");
+  uint16 startPC = localVarInfo.GetStart(slotIdx, static_cast<uint16>(currPC));
+  const jbc::JavaAttrLocalVariableInfoItem &info = localVarInfo.GetItemByStart(slotIdx, startPC);
+  return info.feirType;
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_input.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_input.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..458dc34eed539fa484eb518575b139620279cc08
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_input.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_input.h"
+#include "basic_io.h"
+#include "simple_zip.h"
+#include "fe_macros.h"
+#include "fe_options.h"
+#include "hir2mpl_env.h"
+#include "fe_manager.h"
+
+namespace maple {
+namespace jbc {
+namespace {
+const std::string kClassFileSuffix = ".class";
+const uint32 kClassFileSuffixLength = 6;
+const std::string kJarMetaInf = "META-INF";
+const uint32 kJarMetaInfLength = 8;
+}
+JBCInput::JBCInput(MIRModule &moduleIn)
+    : module(moduleIn),
+      mp(FEUtils::NewMempool("mempool for JBC Input Helper", false /* isLocalPool */)),
+      allocator(mp),
+      klassList(allocator.Adapter()) {
+  itKlass = klassList.end();
+}
+
+JBCInput::~JBCInput() {
+  mp = nullptr;
+}
+
+void JBCInput::ReleaseMemPool() {
+  FEUtils::DeleteMempoolPtr(mp);
+}
+
+bool JBCInput::ReadClassFile(const std::string &fileName) {
+  (void)GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fileName);
+  BasicIOMapFile file(fileName);
+  BasicIORead io(file, true);
+  if (file.OpenAndMap() == false) {
+    ERR(kLncErr, "Unable to open class file %s", fileName.c_str());
+    return false;
+  }
+  JBCClass *klass = JBCClass::InClass(allocator, io);
+  if (klass == nullptr) {
+    ERR(kLncErr, "Unable to parse class file %s", fileName.c_str());
+    file.Close();
+    return false;
+  }
+  klass->SetFilePathName(fileName);
+  RegisterSrcFileInfo(*klass);
+  klassList.push_back(klass);
+  file.Close();
+  return true;
+}
+
+bool JBCInput::ReadClassFiles(const std::list<std::string> &fileNames) {
+  bool success = true;
+  for (const std::string &fileName : fileNames) {
+    FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "===== Process JBCInput::ReadClassFiles(%s) =====",
+                  fileName.c_str());
+    success = ReadClassFile(fileName) ? success : false;
+  }
+  return success;
+}
+
+bool JBCInput::ReadJarFile(const std::string &fileName) {
+  (void)GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fileName);
+  BasicIOMapFile file(fileName);
+  bool success = true;
+  if (file.OpenAndMap() == false) {
+    ERR(kLncErr, "Unable to open jar file %s", fileName.c_str());
+    return false;
+  }
+  SimpleZip zipFile(file);
+  zipFile.ParseFile();
+  for (const std::unique_ptr<ZipLocalFile> &zipLocalFile : zipFile.GetFiles()) {
+    std::string zipLocalFileName = zipLocalFile->GetFileName();
+    size_t len = zipLocalFileName.length();
+    if (len > kClassFileSuffixLength &&
+        zipLocalFileName.substr(len - kClassFileSuffixLength).compare(kClassFileSuffix) == 0) {
+      if (zipLocalFileName.length() >= kJarMetaInfLength &&
+          zipLocalFileName.substr(0, kJarMetaInfLength).compare(kJarMetaInf) == 0) {
+        continue;
+      }
+      // class file
+      BasicIOMapFile classFile(zipLocalFileName, zipLocalFile->GetUnCompData(), zipLocalFile->GetUnCompDataSize());
+      BasicIORead ioClassFile(classFile, true);
+      JBCClass *klass = JBCClass::InClass(allocator, ioClassFile);
+      if (klass == nullptr) {
+        ERR(kLncErr, "Unable to parse class file %s", zipLocalFileName.c_str());
+        success = false;
+      } else {
+        klass->SetFilePathName(zipLocalFileName);
+        RegisterSrcFileInfo(*klass);
+        klassList.push_back(klass);
+      }
+    }
+  }
+  file.Close();
+  if (!success) {
+    return false;
+  }
+  return true;
+}
+
+bool JBCInput::ReadJarFiles(const std::list<std::string> &fileNames) {
+  bool success = true;
+  for (const std::string &fileName : fileNames) {
+    FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "===== Process JBCInput::ReadJarFiles(%s) =====", fileName.c_str());
+    success = ReadJarFile(fileName) ? success : false;
+  }
+  return success;
+}
+
+const JBCClass *JBCInput::GetFirstClass() {
+  if (klassList.size() == 0) {
+    return nullptr;
+  }
+  itKlass = klassList.begin();
+  return *itKlass;
+}
+
+const JBCClass *JBCInput::GetNextClass() {
+  if (itKlass == klassList.end()) {
+    return nullptr;
+  }
+  ++itKlass;
+  if (itKlass == klassList.end()) {
+    return nullptr;
+  }
+  return *itKlass;
+}
+
+void JBCInput::RegisterSrcFileInfo(JBCClass &klass) {
+  GStrIdx fileNameIdx;
+  if (FEOptions::GetInstance().IsJBCInfoUsePathName()) {
+    fileNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(klass.GetFilePathName());
+  } else {
+    fileNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(klass.GetFileName());
+  }
+  uint32 srcFileIdx = HIR2MPLEnv::GetInstance().NewSrcFileIdx(fileNameIdx);
+  module.PushbackFileInfo(MIRInfoPair(fileNameIdx, srcFileIdx));
+  klass.SetSrcFileInfoIdx(srcFileIdx);
+}
+}  // namespace jbc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_opcode.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_opcode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a04f49c15e04b77182a112a42f732dafd516277
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_opcode.cpp
@@ -0,0 +1,1574 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_opcode.h"
+#include "jbc_class_const.h"
+#include "jbc_class_const_pool.h"
+#include "jbc_util.h"
+#include "fe_utils_java.h"
+#include "fe_type_manager.h"
+
+namespace maple {
+namespace jbc {
+// ---------- JBCOpcodeInfo ----------
+JBCOpcodeInfo::JBCOpcodeInfo() {
+#define JBC_OP(mOp, mValue, mKind, mName, mFlag) \
+  table[kOp##mOp].kind = kOpKind##mKind; \
+  table[kOp##mOp].name = mName; \
+  table[kOp##mOp].flags = mFlag;
+#include "jbc_opcode.def"
+#undef JBC_OP
+}
+
+// ---------- JBCOp ----------
+JBCOpcodeInfo JBCOp::opcodeInfo;
+std::vector<JBCPrimType> JBCOp::emptyPrimTypes;
+
+JBCOp::JBCOp(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : alloc(allocator), op(opIn), kind(kindIn), wide(wideIn) {}
+
+bool JBCOp::CheckNotWide(const BasicIORead &io) const {
+  // wide only can be used with i/f/l/d/aload, i/f/l/d/astore, ret, and iinc
+  if (wide) {
+    ERR(kLncErr, "opcode %s @ pc=%u can not own wide prefix", GetOpcodeName().c_str(), io.GetPos() - 1);
+    return false;
+  }
+  return true;
+}
+
+std::string JBCOp::DumpImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  return GetOpcodeName();
+}
+
+const std::vector<JBCPrimType> &JBCOp::GetInputTypesFromStackImpl() const {
+  return emptyPrimTypes;
+}
+
+std::vector<JBCPrimType> JBCOp::GetInputTypesFromStackImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  return GetInputTypesFromStackImpl();
+}
+
+JBCPrimType JBCOp::GetOutputTypesToStackImpl() const {
+  return kTypeDefault;
+}
+
+JBCPrimType JBCOp::GetOutputTypesToStackImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  return GetOutputTypesToStackImpl();
+}
+
+// ---------- JBCOpUnused ----------
+JBCOpUnused::JBCOpUnused(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn) {}
+
+bool JBCOpUnused::ParseFileImpl(BasicIORead &io) {
+  (void) io;
+  WARN(kLncWarn, "Unused opcode %s", GetOpcodeName().c_str());
+  return true;
+}
+
+// ---------- JBCOpReversed ----------
+JBCOpReversed::JBCOpReversed(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn) {}
+
+bool JBCOpReversed::ParseFileImpl(BasicIORead &io) {
+  (void) io;
+  ERR(kLncErr, "Reversed opcode %s", GetOpcodeName().c_str());
+  return false;
+}
+
+// ---------- JBCOpDefault ----------
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpDefault::mapOpInputTypes = JBCOpDefault::InitMapOpInputTypes();
+std::map<JBCOpcode, JBCPrimType> JBCOpDefault::mapOpOutputType = JBCOpDefault::InitMapOpOutputType();
+
+JBCOpDefault::JBCOpDefault(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn) {}
+
+bool JBCOpDefault::ParseFileImpl(BasicIORead &io) {
+  if (JBCOp::CheckNotWide(io) == false) {
+    return false;
+  }
+  return true;
+}
+
+const std::vector<JBCPrimType> &JBCOpDefault::GetInputTypesFromStackImpl() const {
+  auto it = mapOpInputTypes.find(op);
+  CHECK_FATAL(it != mapOpInputTypes.end(), "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+JBCPrimType JBCOpDefault::GetOutputTypesToStackImpl() const {
+  auto it = mapOpOutputType.find(op);
+  CHECK_FATAL(it != mapOpOutputType.end(), "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpDefault::InitMapOpInputTypes() {
+  std::map<JBCOpcode, std::vector<JBCPrimType>> ans;
+  ans[kOpNop] = emptyPrimTypes;
+  InitMapOpInputTypesForArrayLoad(ans);
+  InitMapOpInputTypesForArrayStore(ans);
+  InitMapOpInputTypesForMathBinop(ans);
+  InitMapOpInputTypesForMathUnop(ans);
+  InitMapOpInputTypesForConvert(ans);
+  InitMapOpInputTypesForCompare(ans);
+  InitMapOpInputTypesForReturn(ans);
+  InitMapOpInputTypesForThrow(ans);
+  InitMapOpInputTypesForMonitor(ans);
+  InitMapOpInputTypesForArrayLength(ans);
+  return ans;
+}
+
+std::map<JBCOpcode, JBCPrimType> JBCOpDefault::InitMapOpOutputType() {
+  std::map<JBCOpcode, JBCPrimType> ans;
+  ans[kOpNop] = kTypeDefault;
+  InitMapOpOutputTypesForArrayLoad(ans);
+  InitMapOpOutputTypesForArrayStore(ans);
+  InitMapOpOutputTypesForMathBinop(ans);
+  InitMapOpOutputTypesForMathUnop(ans);
+  InitMapOpOutputTypesForConvert(ans);
+  InitMapOpOutputTypesForCompare(ans);
+  InitMapOpOutputTypesForReturn(ans);
+  InitMapOpOutputTypesForThrow(ans);
+  InitMapOpOutputTypesForMonitor(ans);
+  InitMapOpOutputTypesForArrayLength(ans);
+  return ans;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForArrayLoad(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpIALoad] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt });
+  ans[kOpLALoad] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt });
+  ans[kOpFALoad] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt });
+  ans[kOpDALoad] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt });
+  ans[kOpAALoad] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt });
+  ans[kOpBALoad] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt });
+  ans[kOpCALoad] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt });
+  ans[kOpSALoad] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt });
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForArrayLoad(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpIALoad] = kTypeInt;
+  ans[kOpLALoad] = kTypeLong;
+  ans[kOpFALoad] = kTypeFloat;
+  ans[kOpDALoad] = kTypeDouble;
+  ans[kOpAALoad] = kTypeRef;
+  ans[kOpBALoad] = kTypeByteOrBoolean;
+  ans[kOpCALoad] = kTypeChar;
+  ans[kOpSALoad] = kTypeShort;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForArrayStore(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpIAStore] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt, kTypeInt });
+  ans[kOpLAStore] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt, kTypeLong });
+  ans[kOpFAStore] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt, kTypeFloat });
+  ans[kOpDAStore] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt, kTypeDouble });
+  ans[kOpAAStore] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt, kTypeRef });
+  ans[kOpBAStore] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt, kTypeByteOrBoolean });
+  ans[kOpCAStore] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt, kTypeChar });
+  ans[kOpSAStore] = std::vector<JBCPrimType>({ kTypeRef, kTypeInt, kTypeShort });
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForArrayStore(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpIAStore] = kTypeDefault;
+  ans[kOpLAStore] = kTypeDefault;
+  ans[kOpFAStore] = kTypeDefault;
+  ans[kOpDAStore] = kTypeDefault;
+  ans[kOpAAStore] = kTypeDefault;
+  ans[kOpBAStore] = kTypeDefault;
+  ans[kOpCAStore] = kTypeDefault;
+  ans[kOpSAStore] = kTypeDefault;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForMathBinop(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpIAdd] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLAdd] = std::vector<JBCPrimType>({ kTypeLong, kTypeLong });
+  ans[kOpFAdd] = std::vector<JBCPrimType>({ kTypeFloat, kTypeFloat });
+  ans[kOpDAdd] = std::vector<JBCPrimType>({ kTypeDouble, kTypeDouble });
+  ans[kOpISub] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLSub] = std::vector<JBCPrimType>({ kTypeLong, kTypeLong });
+  ans[kOpFSub] = std::vector<JBCPrimType>({ kTypeFloat, kTypeFloat });
+  ans[kOpDSub] = std::vector<JBCPrimType>({ kTypeDouble, kTypeDouble });
+  ans[kOpIMul] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLMul] = std::vector<JBCPrimType>({ kTypeLong, kTypeLong });
+  ans[kOpFMul] = std::vector<JBCPrimType>({ kTypeFloat, kTypeFloat });
+  ans[kOpDMul] = std::vector<JBCPrimType>({ kTypeDouble, kTypeDouble });
+  ans[kOpIDiv] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLDiv] = std::vector<JBCPrimType>({ kTypeLong, kTypeLong });
+  ans[kOpFDiv] = std::vector<JBCPrimType>({ kTypeFloat, kTypeFloat });
+  ans[kOpDDiv] = std::vector<JBCPrimType>({ kTypeDouble, kTypeDouble });
+  ans[kOpIRem] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLRem] = std::vector<JBCPrimType>({ kTypeLong, kTypeLong });
+  ans[kOpFRem] = std::vector<JBCPrimType>({ kTypeFloat, kTypeFloat });
+  ans[kOpDRem] = std::vector<JBCPrimType>({ kTypeDouble, kTypeDouble });
+  ans[kOpIShl] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLShl] = std::vector<JBCPrimType>({ kTypeLong, kTypeInt });
+  ans[kOpIShr] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLShr] = std::vector<JBCPrimType>({ kTypeLong, kTypeInt });
+  ans[kOpIUShr] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLUShr] = std::vector<JBCPrimType>({ kTypeLong, kTypeInt });
+  ans[kOpIAnd] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLAnd] = std::vector<JBCPrimType>({ kTypeLong, kTypeLong });
+  ans[kOpIOr] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLOr] = std::vector<JBCPrimType>({ kTypeLong, kTypeLong });
+  ans[kOpIXor] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpLXor] = std::vector<JBCPrimType>({ kTypeLong, kTypeLong });
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForMathBinop(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpIAdd] = kTypeInt;
+  ans[kOpLAdd] = kTypeLong;
+  ans[kOpFAdd] = kTypeFloat;
+  ans[kOpDAdd] = kTypeDouble;
+  ans[kOpISub] = kTypeInt;
+  ans[kOpLSub] = kTypeLong;
+  ans[kOpFSub] = kTypeFloat;
+  ans[kOpDSub] = kTypeDouble;
+  ans[kOpIMul] = kTypeInt;
+  ans[kOpLMul] = kTypeLong;
+  ans[kOpFMul] = kTypeFloat;
+  ans[kOpDMul] = kTypeDouble;
+  ans[kOpIDiv] = kTypeInt;
+  ans[kOpLDiv] = kTypeLong;
+  ans[kOpFDiv] = kTypeFloat;
+  ans[kOpDDiv] = kTypeDouble;
+  ans[kOpIRem] = kTypeInt;
+  ans[kOpLRem] = kTypeLong;
+  ans[kOpFRem] = kTypeFloat;
+  ans[kOpDRem] = kTypeDouble;
+  ans[kOpIShl] = kTypeInt;
+  ans[kOpLShl] = kTypeLong;
+  ans[kOpIShr] = kTypeInt;
+  ans[kOpLShr] = kTypeLong;
+  ans[kOpIUShr] = kTypeInt;
+  ans[kOpLUShr] = kTypeLong;
+  ans[kOpIAnd] = kTypeInt;
+  ans[kOpLAnd] = kTypeLong;
+  ans[kOpIOr] = kTypeInt;
+  ans[kOpLOr] = kTypeLong;
+  ans[kOpIXor] = kTypeInt;
+  ans[kOpLXor] = kTypeLong;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForMathUnop(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpINeg] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpLNeg] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpFNeg] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpDNeg] = std::vector<JBCPrimType>({ kTypeDouble });
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForMathUnop(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpINeg] = kTypeInt;
+  ans[kOpLNeg] = kTypeLong;
+  ans[kOpFNeg] = kTypeFloat;
+  ans[kOpDNeg] = kTypeDouble;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForConvert(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpI2L] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpI2F] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpI2D] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpL2I] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpL2F] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpL2D] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpF2I] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpF2L] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpF2D] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpD2I] = std::vector<JBCPrimType>({ kTypeDouble });
+  ans[kOpD2L] = std::vector<JBCPrimType>({ kTypeDouble });
+  ans[kOpD2F] = std::vector<JBCPrimType>({ kTypeDouble });
+  ans[kOpI2B] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpI2C] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpI2S] = std::vector<JBCPrimType>({ kTypeInt });
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForConvert(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpI2L] = kTypeLong;
+  ans[kOpI2F] = kTypeFloat;
+  ans[kOpI2D] = kTypeDouble;
+  ans[kOpL2I] = kTypeInt;
+  ans[kOpL2F] = kTypeFloat;
+  ans[kOpL2D] = kTypeDouble;
+  ans[kOpF2I] = kTypeInt;
+  ans[kOpF2L] = kTypeLong;
+  ans[kOpF2D] = kTypeDouble;
+  ans[kOpD2I] = kTypeInt;
+  ans[kOpD2L] = kTypeLong;
+  ans[kOpD2F] = kTypeFloat;
+  ans[kOpI2B] = kTypeByteOrBoolean;
+  ans[kOpI2C] = kTypeChar;
+  ans[kOpI2S] = kTypeShort;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForCompare(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpLCmp] = std::vector<JBCPrimType>({ kTypeLong, kTypeLong });
+  ans[kOpFCmpl] = std::vector<JBCPrimType>({ kTypeFloat, kTypeFloat });
+  ans[kOpFCmpg] = std::vector<JBCPrimType>({ kTypeFloat, kTypeFloat });
+  ans[kOpDCmpl] = std::vector<JBCPrimType>({ kTypeDouble, kTypeDouble });
+  ans[kOpDCmpg] = std::vector<JBCPrimType>({ kTypeDouble, kTypeDouble });
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForCompare(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpLCmp] = kTypeInt;
+  ans[kOpFCmpl] = kTypeInt;
+  ans[kOpFCmpg] = kTypeInt;
+  ans[kOpDCmpl] = kTypeInt;
+  ans[kOpDCmpg] = kTypeInt;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForReturn(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpIReturn] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpLReturn] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpFReturn] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpDReturn] = std::vector<JBCPrimType>({ kTypeDouble });
+  ans[kOpAReturn] = std::vector<JBCPrimType>({ kTypeRef });
+  ans[kOpReturn] = emptyPrimTypes;
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForReturn(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpIReturn] = kTypeDefault;
+  ans[kOpLReturn] = kTypeDefault;
+  ans[kOpFReturn] = kTypeDefault;
+  ans[kOpDReturn] = kTypeDefault;
+  ans[kOpAReturn] = kTypeDefault;
+  ans[kOpReturn] = kTypeDefault;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForThrow(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpAThrow] = std::vector<JBCPrimType>({ kTypeRef });
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForThrow(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpAThrow] = kTypeDefault;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForMonitor(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpMonitorEnter] = std::vector<JBCPrimType>({ kTypeRef });
+  ans[kOpMonitorExit] = std::vector<JBCPrimType>({ kTypeRef });
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForMonitor(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpMonitorEnter] = kTypeDefault;
+  ans[kOpMonitorExit] = kTypeDefault;
+}
+
+void JBCOpDefault::InitMapOpInputTypesForArrayLength(std::map<JBCOpcode, std::vector<JBCPrimType>> &ans) {
+  ans[kOpArrayLength] = std::vector<JBCPrimType>({ kTypeRef });
+}
+
+void JBCOpDefault::InitMapOpOutputTypesForArrayLength(std::map<JBCOpcode, JBCPrimType> &ans) {
+  ans[kOpArrayLength] = kTypeInt;
+}
+
+// ---------- JBCOpConst ----------
+std::map<JBCOpcode, int32> JBCOpConst::valueMapI = JBCOpConst::InitValueMapI();
+std::map<JBCOpcode, int64> JBCOpConst::valueMapJ = JBCOpConst::InitValueMapJ();
+std::map<JBCOpcode, float> JBCOpConst::valueMapF = JBCOpConst::InitValueMapF();
+std::map<JBCOpcode, double> JBCOpConst::valueMapD = JBCOpConst::InitValueMapD();
+
+JBCOpConst::JBCOpConst(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn) {
+  u.raw = 0;
+}
+
+bool JBCOpConst::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  if (CheckNotWide(io) == false) {
+    return false;
+  }
+  switch (op) {
+    case jbc::kOpBiPush:
+      u.bvalue = io.ReadInt8(success);
+      break;
+    case jbc::kOpSiPush:
+      u.svalue = io.ReadInt16(success);
+      break;
+    case jbc::kOpLdc:
+      u.index = io.ReadUInt8(success);
+      break;
+    case jbc::kOpLdcW:
+    case jbc::kOpLdc2W:
+      u.index = io.ReadUInt16(success);
+      break;
+    default:
+      success = true;
+      break;
+  }
+  return success;
+}
+
+JBCPrimType JBCOpConst::GetOutputTypesToStackImpl(const JBCConstPool &constPool) const {
+  switch (op) {
+    case jbc::kOpAConstNull:
+      return kTypeRef;
+    case jbc::kOpIConstM1:
+    case jbc::kOpIConst0:
+    case jbc::kOpIConst1:
+    case jbc::kOpIConst2:
+    case jbc::kOpIConst3:
+    case jbc::kOpIConst4:
+    case jbc::kOpIConst5:
+      return kTypeInt;
+    case jbc::kOpLConst0:
+    case jbc::kOpLConst1:
+      return kTypeLong;
+    case jbc::kOpFConst0:
+    case jbc::kOpFConst1:
+    case jbc::kOpFConst2:
+      return kTypeFloat;
+    case jbc::kOpDConst0:
+    case jbc::kOpDConst1:
+      return kTypeDouble;
+    case jbc::kOpBiPush:
+      return kTypeByteOrBoolean;
+    case jbc::kOpSiPush:
+      return kTypeShort;
+    case jbc::kOpLdc:
+    case jbc::kOpLdcW:
+    case jbc::kOpLdc2W: {
+      const JBCConst *constRaw = constPool.GetConstByIdx(GetIndex());
+      if (constRaw != nullptr) {
+        switch (constRaw->GetTag()) {
+          case kConstInteger:
+            return jbc::kTypeInt;
+          case kConstFloat:
+            return jbc::kTypeFloat;
+          case kConstLong:
+            return jbc::kTypeLong;
+          case kConstDouble:
+            return jbc::kTypeDouble;
+          case kConstClass:
+          case kConstString:
+            return jbc::kTypeRef;
+          default:
+            CHECK_FATAL(false, "Unsupported const tag %d", constRaw->GetTag());
+        }
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  }
+  return kTypeDefault;
+}
+
+std::string JBCOpConst::DumpImpl(const JBCConstPool &constPool) const {
+  switch (op) {
+    case jbc::kOpBiPush:
+      return DumpBiPush();
+    case jbc::kOpSiPush:
+      return DumpSiPush();
+    case jbc::kOpLdc:
+    case jbc::kOpLdcW:
+    case jbc::kOpLdc2W:
+      return DumpLdc(constPool);
+    default:
+      return JBCOp::DumpImpl(constPool);
+  }
+}
+
+std::string JBCOpConst::DumpBiPush() const {
+  std::stringstream ss;
+  ss << GetOpcodeName() << " byte " << static_cast<int32>(u.bvalue);
+  return ss.str();
+}
+
+std::string JBCOpConst::DumpSiPush() const {
+  std::stringstream ss;
+  ss << GetOpcodeName() << " short " << static_cast<int32>(u.svalue);
+  return ss.str();
+}
+
+std::string JBCOpConst::DumpLdc(const JBCConstPool &constPool) const {
+  std::stringstream ss;
+  ss << GetOpcodeName() << " ";
+  const JBCConst *constRaw = constPool.GetConstByIdx(GetIndex());
+  if (constRaw != nullptr) {
+    switch (constRaw->GetTag()) {
+      case kConstInteger:
+      case kConstFloat: {
+        const JBCConst4Byte *const4B = static_cast<const JBCConst4Byte*>(constRaw);
+        if (constRaw->GetTag() == kConstInteger) {
+          ss << "int " << const4B->GetInt32();
+        } else {
+          ss << "float " << const4B->GetFloat();
+        }
+        break;
+      }
+      case kConstLong:
+      case kConstDouble: {
+        const JBCConst8Byte *const8B = static_cast<const JBCConst8Byte*>(constRaw);
+        if (constRaw->GetTag() == kConstLong) {
+          ss << "long " << const8B->GetInt64();
+        } else {
+          ss << "double " << const8B->GetDouble();
+        }
+        break;
+      }
+      case kConstClass: {
+        const JBCConstClass *constClass = static_cast<const JBCConstClass*>(constRaw);
+        ss << "Class " << constClass->GetClassNameOrin();
+        break;
+      }
+      case kConstString: {
+        const JBCConstString *constString = static_cast<const JBCConstString*>(constRaw);
+        ss << "String " << "\"" << constString->GetString() << "\"";
+        break;
+      }
+      case kConstMethodType: {
+        ss << "MethodType ";
+        break;
+      }
+      case kConstMethodHandleInfo: {
+        ss << "MethodHandle ";
+        break;
+      }
+      default:
+        ss << "Unsupported const tag " << constRaw->GetTag();
+        break;
+    }
+  } else {
+    ss << "invalid const index";
+  }
+  return ss.str();
+}
+
+int32 JBCOpConst::GetValueInt() const {
+  auto it = valueMapI.find(op);
+  CHECK_FATAL(it != valueMapI.end(), "unsupport opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+int64 JBCOpConst::GetValueLong() const {
+  auto it = valueMapJ.find(op);
+  CHECK_FATAL(it != valueMapJ.end(), "unsupport opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+float JBCOpConst::GetValueFloat() const {
+  auto it = valueMapF.find(op);
+  CHECK_FATAL(it != valueMapF.end(), "unsupport opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+double JBCOpConst::GetValueDouble() const {
+  auto it = valueMapD.find(op);
+  CHECK_FATAL(it != valueMapD.end(), "unsupport opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+int8 JBCOpConst::GetValueByte() const {
+  CHECK_FATAL(op == kOpBiPush, "unsupport opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return u.bvalue;
+}
+
+int16 JBCOpConst::GetValueShort() const {
+  CHECK_FATAL(op == kOpSiPush, "unsupport opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return u.svalue;
+}
+
+std::map<JBCOpcode, int32> JBCOpConst::InitValueMapI() {
+  std::map<JBCOpcode, int32> valueMap;
+  valueMap[jbc::kOpIConstM1] = -1;
+  valueMap[jbc::kOpIConst0] = 0;
+  valueMap[jbc::kOpIConst1] = 1;
+  valueMap[jbc::kOpIConst2] = 2;
+  valueMap[jbc::kOpIConst3] = 3;
+  valueMap[jbc::kOpIConst4] = 4;
+  valueMap[jbc::kOpIConst5] = 5;
+  return valueMap;
+}
+
+std::map<JBCOpcode, int64> JBCOpConst::InitValueMapJ() {
+  std::map<JBCOpcode, int64> valueMap;
+  valueMap[jbc::kOpLConst0] = 0L;
+  valueMap[jbc::kOpLConst1] = 1L;
+  return valueMap;
+}
+
+std::map<JBCOpcode, float> JBCOpConst::InitValueMapF() {
+  std::map<JBCOpcode, float> valueMap;
+  valueMap[jbc::kOpFConst0] = 0.0F;
+  valueMap[jbc::kOpFConst1] = 1.0F;
+  valueMap[jbc::kOpFConst2] = 2.0F;
+  return valueMap;
+}
+
+std::map<JBCOpcode, double> JBCOpConst::InitValueMapD() {
+  std::map<JBCOpcode, double> valueMap;
+  valueMap[jbc::kOpDConst0] = 0.0;
+  valueMap[jbc::kOpDConst1] = 1.0;
+  return valueMap;
+}
+
+// ---------- JBCOpSlotOpr ----------
+std::map<JBCOpcode, std::pair<uint16, JBCPrimType>> JBCOpSlotOpr::mapSlotIdxAndType =
+    JBCOpSlotOpr::InitMapSlotIdxAndType();
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpSlotOpr::mapOpInputTypes = JBCOpSlotOpr::InitMapOpInputTypes();
+std::map<JBCOpcode, JBCPrimType> JBCOpSlotOpr::mapOpOutputType = JBCOpSlotOpr::InitMapOpOutputType();
+std::vector<JBCPrimType> JBCOpSlotOpr::inputTypesAddressOpr = { JBCPrimType::kTypeAddress };
+
+JBCOpSlotOpr::JBCOpSlotOpr(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), slotIdx(0), isAddressOpr(false) {}
+
+bool JBCOpSlotOpr::IsAStore() const {
+  switch (op) {
+    case jbc::kOpAStore:
+    case jbc::kOpAStore0:
+    case jbc::kOpAStore1:
+    case jbc::kOpAStore2:
+    case jbc::kOpAStore3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool JBCOpSlotOpr::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  switch (op) {
+    case jbc::kOpILoad:
+    case jbc::kOpLLoad:
+    case jbc::kOpFLoad:
+    case jbc::kOpDLoad:
+    case jbc::kOpALoad:
+    case jbc::kOpIStore:
+    case jbc::kOpLStore:
+    case jbc::kOpFStore:
+    case jbc::kOpDStore:
+    case jbc::kOpAStore:
+      if (wide) {
+        slotIdx = io.ReadUInt16(success);
+      } else {
+        slotIdx = io.ReadUInt8(success);
+      }
+      break;
+    default:
+      std::map<JBCOpcode, std::pair<uint16, JBCPrimType>>::const_iterator it = mapSlotIdxAndType.find(op);
+      if (it == mapSlotIdxAndType.end()) {
+        ERR(kLncErr, "Unexpected opcode %s for SlotOpr", GetOpcodeName().c_str());
+        success = false;
+      } else {
+        slotIdx = it->second.first;
+        success = true;
+      }
+      break;
+  }
+  return success;
+}
+
+const std::vector<JBCPrimType> &JBCOpSlotOpr::GetInputTypesFromStackImpl() const {
+  if (isAddressOpr) {
+    return inputTypesAddressOpr;
+  }
+  auto it = mapOpInputTypes.find(op);
+  CHECK_FATAL(it != mapOpInputTypes.end(), "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+JBCPrimType JBCOpSlotOpr::GetOutputTypesToStackImpl() const {
+  auto it = mapOpOutputType.find(op);
+  CHECK_FATAL(it != mapOpOutputType.end(), "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+std::string JBCOpSlotOpr::DumpImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  std::stringstream ss;
+  ss << GetOpcodeName() << " " << slotIdx;
+  return ss.str();
+}
+
+std::map<JBCOpcode, std::pair<uint16, JBCPrimType>> JBCOpSlotOpr::InitMapSlotIdxAndType() {
+  std::map<JBCOpcode, std::pair<uint16, JBCPrimType>> result;
+  result[kOpILoad] = std::make_pair(0, kTypeInt);
+  result[kOpLLoad] = std::make_pair(0, kTypeLong);
+  result[kOpFLoad] = std::make_pair(0, kTypeFloat);
+  result[kOpDLoad] = std::make_pair(0, kTypeDouble);
+  result[kOpALoad] = std::make_pair(0, kTypeRef);
+  result[kOpILoad0] = std::make_pair(0, kTypeInt);
+  result[kOpILoad1] = std::make_pair(1, kTypeInt);
+  result[kOpILoad2] = std::make_pair(2, kTypeInt);
+  result[kOpILoad3] = std::make_pair(3, kTypeInt);
+  result[kOpLLoad0] = std::make_pair(0, kTypeLong);
+  result[kOpLLoad1] = std::make_pair(1, kTypeLong);
+  result[kOpLLoad2] = std::make_pair(2, kTypeLong);
+  result[kOpLLoad3] = std::make_pair(3, kTypeLong);
+  result[kOpFLoad0] = std::make_pair(0, kTypeFloat);
+  result[kOpFLoad1] = std::make_pair(1, kTypeFloat);
+  result[kOpFLoad2] = std::make_pair(2, kTypeFloat);
+  result[kOpFLoad3] = std::make_pair(3, kTypeFloat);
+  result[kOpDLoad0] = std::make_pair(0, kTypeDouble);
+  result[kOpDLoad1] = std::make_pair(1, kTypeDouble);
+  result[kOpDLoad2] = std::make_pair(2, kTypeDouble);
+  result[kOpDLoad3] = std::make_pair(3, kTypeDouble);
+  result[kOpALoad0] = std::make_pair(0, kTypeRef);
+  result[kOpALoad1] = std::make_pair(1, kTypeRef);
+  result[kOpALoad2] = std::make_pair(2, kTypeRef);
+  result[kOpALoad3] = std::make_pair(3, kTypeRef);
+  result[kOpIStore] = std::make_pair(0, kTypeInt);
+  result[kOpLStore] = std::make_pair(0, kTypeLong);
+  result[kOpFStore] = std::make_pair(0, kTypeFloat);
+  result[kOpDStore] = std::make_pair(0, kTypeDouble);
+  result[kOpAStore] = std::make_pair(0, kTypeRef);
+  result[kOpIStore0] = std::make_pair(0, kTypeInt);
+  result[kOpIStore1] = std::make_pair(1, kTypeInt);
+  result[kOpIStore2] = std::make_pair(2, kTypeInt);
+  result[kOpIStore3] = std::make_pair(3, kTypeInt);
+  result[kOpLStore0] = std::make_pair(0, kTypeLong);
+  result[kOpLStore1] = std::make_pair(1, kTypeLong);
+  result[kOpLStore2] = std::make_pair(2, kTypeLong);
+  result[kOpLStore3] = std::make_pair(3, kTypeLong);
+  result[kOpFStore0] = std::make_pair(0, kTypeFloat);
+  result[kOpFStore1] = std::make_pair(1, kTypeFloat);
+  result[kOpFStore2] = std::make_pair(2, kTypeFloat);
+  result[kOpFStore3] = std::make_pair(3, kTypeFloat);
+  result[kOpDStore0] = std::make_pair(0, kTypeDouble);
+  result[kOpDStore1] = std::make_pair(1, kTypeDouble);
+  result[kOpDStore2] = std::make_pair(2, kTypeDouble);
+  result[kOpDStore3] = std::make_pair(3, kTypeDouble);
+  result[kOpAStore0] = std::make_pair(0, kTypeRef);
+  result[kOpAStore1] = std::make_pair(1, kTypeRef);
+  result[kOpAStore2] = std::make_pair(2, kTypeRef);
+  result[kOpAStore3] = std::make_pair(3, kTypeRef);
+  return result;
+}
+
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpSlotOpr::InitMapOpInputTypes() {
+  std::map<JBCOpcode, std::vector<JBCPrimType>> ans;
+  ans[kOpILoad] = emptyPrimTypes;
+  ans[kOpFLoad] = emptyPrimTypes;
+  ans[kOpLLoad] = emptyPrimTypes;
+  ans[kOpDLoad] = emptyPrimTypes;
+  ans[kOpALoad] = emptyPrimTypes;
+  ans[kOpILoad0] = emptyPrimTypes;
+  ans[kOpILoad1] = emptyPrimTypes;
+  ans[kOpILoad2] = emptyPrimTypes;
+  ans[kOpILoad3] = emptyPrimTypes;
+  ans[kOpLLoad0] = emptyPrimTypes;
+  ans[kOpLLoad1] = emptyPrimTypes;
+  ans[kOpLLoad2] = emptyPrimTypes;
+  ans[kOpLLoad3] = emptyPrimTypes;
+  ans[kOpFLoad0] = emptyPrimTypes;
+  ans[kOpFLoad1] = emptyPrimTypes;
+  ans[kOpFLoad2] = emptyPrimTypes;
+  ans[kOpFLoad3] = emptyPrimTypes;
+  ans[kOpDLoad0] = emptyPrimTypes;
+  ans[kOpDLoad1] = emptyPrimTypes;
+  ans[kOpDLoad2] = emptyPrimTypes;
+  ans[kOpDLoad3] = emptyPrimTypes;
+  ans[kOpALoad0] = emptyPrimTypes;
+  ans[kOpALoad1] = emptyPrimTypes;
+  ans[kOpALoad2] = emptyPrimTypes;
+  ans[kOpALoad3] = emptyPrimTypes;
+  ans[kOpIStore] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpLStore] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpFStore] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpDStore] = std::vector<JBCPrimType>({ kTypeDouble });
+  ans[kOpAStore] = std::vector<JBCPrimType>({ kTypeRef });
+  ans[kOpIStore0] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIStore1] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIStore2] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIStore3] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpLStore0] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpLStore1] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpLStore2] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpLStore3] = std::vector<JBCPrimType>({ kTypeLong });
+  ans[kOpFStore0] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpFStore1] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpFStore2] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpFStore3] = std::vector<JBCPrimType>({ kTypeFloat });
+  ans[kOpDStore0] = std::vector<JBCPrimType>({ kTypeDouble });
+  ans[kOpDStore1] = std::vector<JBCPrimType>({ kTypeDouble });
+  ans[kOpDStore2] = std::vector<JBCPrimType>({ kTypeDouble });
+  ans[kOpDStore3] = std::vector<JBCPrimType>({ kTypeDouble });
+  ans[kOpAStore0] = std::vector<JBCPrimType>({ kTypeRef });
+  ans[kOpAStore1] = std::vector<JBCPrimType>({ kTypeRef });
+  ans[kOpAStore2] = std::vector<JBCPrimType>({ kTypeRef });
+  ans[kOpAStore3] = std::vector<JBCPrimType>({ kTypeRef });
+  return ans;
+}
+
+std::map<JBCOpcode, JBCPrimType> JBCOpSlotOpr::InitMapOpOutputType() {
+  std::map<JBCOpcode, JBCPrimType> ans;
+  ans[kOpILoad] = kTypeInt;
+  ans[kOpFLoad] = kTypeFloat;
+  ans[kOpLLoad] = kTypeLong;
+  ans[kOpDLoad] = kTypeDouble;
+  ans[kOpALoad] = kTypeRef;
+  ans[kOpILoad0] = kTypeInt;
+  ans[kOpILoad1] = kTypeInt;
+  ans[kOpILoad2] = kTypeInt;
+  ans[kOpILoad3] = kTypeInt;
+  ans[kOpLLoad0] = kTypeLong;
+  ans[kOpLLoad1] = kTypeLong;
+  ans[kOpLLoad2] = kTypeLong;
+  ans[kOpLLoad3] = kTypeLong;
+  ans[kOpFLoad0] = kTypeFloat;
+  ans[kOpFLoad1] = kTypeFloat;
+  ans[kOpFLoad2] = kTypeFloat;
+  ans[kOpFLoad3] = kTypeFloat;
+  ans[kOpDLoad0] = kTypeDouble;
+  ans[kOpDLoad1] = kTypeDouble;
+  ans[kOpDLoad2] = kTypeDouble;
+  ans[kOpDLoad3] = kTypeDouble;
+  ans[kOpALoad0] = kTypeRef;
+  ans[kOpALoad1] = kTypeRef;
+  ans[kOpALoad2] = kTypeRef;
+  ans[kOpALoad3] = kTypeRef;
+  ans[kOpIStore] = kTypeDefault;
+  ans[kOpLStore] = kTypeDefault;
+  ans[kOpFStore] = kTypeDefault;
+  ans[kOpDStore] = kTypeDefault;
+  ans[kOpAStore] = kTypeDefault;
+  ans[kOpIStore0] = kTypeDefault;
+  ans[kOpIStore1] = kTypeDefault;
+  ans[kOpIStore2] = kTypeDefault;
+  ans[kOpIStore3] = kTypeDefault;
+  ans[kOpLStore0] = kTypeDefault;
+  ans[kOpLStore1] = kTypeDefault;
+  ans[kOpLStore2] = kTypeDefault;
+  ans[kOpLStore3] = kTypeDefault;
+  ans[kOpFStore0] = kTypeDefault;
+  ans[kOpFStore1] = kTypeDefault;
+  ans[kOpFStore2] = kTypeDefault;
+  ans[kOpFStore3] = kTypeDefault;
+  ans[kOpDStore0] = kTypeDefault;
+  ans[kOpDStore1] = kTypeDefault;
+  ans[kOpDStore2] = kTypeDefault;
+  ans[kOpDStore3] = kTypeDefault;
+  ans[kOpAStore0] = kTypeDefault;
+  ans[kOpAStore1] = kTypeDefault;
+  ans[kOpAStore2] = kTypeDefault;
+  ans[kOpAStore3] = kTypeDefault;
+  return ans;
+}
+
+// ---------- JBCOpMathInc ----------
+JBCOpMathInc::JBCOpMathInc(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), index(0), incr(0) {}
+
+bool JBCOpMathInc::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  if (wide) {
+    index = io.ReadUInt16(success);
+    incr = io.ReadInt16(success);
+  } else {
+    index = io.ReadUInt8(success);
+    incr = io.ReadInt8(success);
+  }
+  return success;
+}
+
+// ---------- JBCOpBranch ----------
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpBranch::mapOpInputTypes = JBCOpBranch::InitMapOpInputTypes();
+
+JBCOpBranch::JBCOpBranch(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), target(0) {}
+
+bool JBCOpBranch::ParseFileImpl(BasicIORead &io) {
+  if (JBCOp::CheckNotWide(io) == false) {
+    return false;
+  }
+  bool success = true;
+  int64 pc = io.GetPos() - 1;
+  target = GetTargetbyInt64(pc + io.ReadInt16(success));
+  return success;
+}
+
+std::string JBCOpBranch::DumpImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  std::stringstream ss;
+  ss << GetOpcodeName() << " " << target;
+  return ss.str();
+}
+
+const std::vector<JBCPrimType> &JBCOpBranch::GetInputTypesFromStackImpl() const {
+  auto it = mapOpInputTypes.find(op);
+  CHECK_FATAL(it != mapOpInputTypes.end(), "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpBranch::InitMapOpInputTypes() {
+  std::map<JBCOpcode, std::vector<JBCPrimType>> ans;
+  ans[kOpIfeq] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIfne] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIflt] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIfge] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIfgt] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIfle] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIfeq] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpIfICmpeq] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpIfICmpne] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpIfICmplt] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpIfICmpge] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpIfICmpgt] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpIfICmple] = std::vector<JBCPrimType>({ kTypeInt, kTypeInt });
+  ans[kOpIfACmpeq] = std::vector<JBCPrimType>({ kTypeRef, kTypeRef });
+  ans[kOpIfACmpne] = std::vector<JBCPrimType>({ kTypeRef, kTypeRef });
+  ans[kOpIfNull] = std::vector<JBCPrimType>({ kTypeRef });
+  ans[kOpIfNonNull] = std::vector<JBCPrimType>({ kTypeRef });
+  return ans;
+}
+
+// ---------- JBCOpGoto ----------
+JBCOpGoto::JBCOpGoto(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), target(0) {}
+
+bool JBCOpGoto::ParseFileImpl(BasicIORead &io) {
+  if (JBCOp::CheckNotWide(io) == false) {
+    return false;
+  }
+  bool success = true;
+  int64 pc = io.GetPos() - 1;
+  switch (op) {
+    case jbc::kOpGoto:
+      target = GetTargetbyInt64(pc + io.ReadInt16(success));
+      break;
+    case jbc::kOpGotoW:
+      target = GetTargetbyInt64(pc + io.ReadInt32(success));
+      break;
+    default:
+      CHECK_FATAL(false, "Unexpected opcode %s for Goto", GetOpcodeName().c_str());
+      return false;
+  }
+  return success;
+}
+
+std::string JBCOpGoto::DumpImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  std::stringstream ss;
+  ss << GetOpcodeName() << " " << target;
+  return ss.str();
+}
+
+// ---------- JBCOpSwitch ----------
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpSwitch::mapOpInputTypes = JBCOpSwitch::InitMapOpInputTypes();
+
+JBCOpSwitch::JBCOpSwitch(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn),
+      targets(std::less<int32>(), allocator.Adapter()),
+      targetDefault(0)  {}
+
+bool JBCOpSwitch::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  int64 pc = io.GetPos() - 1;
+  const uint32 kAlign32 = 4;
+  if (op == jbc::kOpTableSwitch) {
+    while (io.GetPos() % kAlign32 != 0) {
+      (void)io.ReadUInt8(success);
+    }
+    targetDefault = GetTargetbyInt64(pc + io.ReadUInt32(success));
+    int32 low = io.ReadInt32(success);
+    int32 high = io.ReadInt32(success);
+    for (int32 i = low; i <= high && success; ++i) {
+      int32 offset = io.ReadInt32(success);
+      CHECK_FATAL(targets.insert(std::make_pair(i, GetTargetbyInt64(offset + pc))).second, "targets insert failed");
+    }
+  } else if (op == jbc::kOpLookupSwitch) {
+    while (io.GetPos() % kAlign32 != 0) {
+      (void)io.ReadUInt8(success);
+    }
+    targetDefault = GetTargetbyInt64(pc + io.ReadUInt32(success));
+    uint32 npairs = io.ReadUInt32(success);
+    for (uint32 i = 0; i < npairs && success; ++i) {
+      int32 value = io.ReadInt32(success);
+      int32 offset = io.ReadInt32(success);
+      CHECK_FATAL(targets.insert(std::make_pair(value, GetTargetbyInt64(offset + pc))).second, "targets insert failed");
+    }
+  }
+  return success;
+}
+
+const std::vector<JBCPrimType> &JBCOpSwitch::GetInputTypesFromStackImpl() const {
+  auto it = mapOpInputTypes.find(op);
+  CHECK_FATAL(it != mapOpInputTypes.end(), "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+std::string JBCOpSwitch::DumpImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  std::stringstream ss;
+  ss << GetOpcodeName() << " { default=" << targetDefault;
+  for (auto it : targets) {
+    ss << "," << it.first << ":" << it.second;
+  }
+  ss << " }";
+  return ss.str();
+}
+
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpSwitch::InitMapOpInputTypes() {
+  std::map<JBCOpcode, std::vector<JBCPrimType>> ans;
+  ans[kOpTableSwitch] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpLookupSwitch] = std::vector<JBCPrimType>({ kTypeInt });
+  return ans;
+}
+
+// ---------- JBCOpFieldOpr ----------
+JBCOpFieldOpr::JBCOpFieldOpr(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), fieldIdx(0) {}
+
+bool JBCOpFieldOpr::ParseFileImpl(BasicIORead &io) {
+  if (JBCOp::CheckNotWide(io) == false) {
+    return false;
+  }
+  bool success = false;
+  fieldIdx = io.ReadUInt16(success);
+  return success;
+}
+
+const std::vector<JBCPrimType> &JBCOpFieldOpr::GetInputTypesFromStackImpl() const {
+  CHECK_FATAL(false, "Restricted Calls");
+  return emptyPrimTypes;
+}
+
+std::vector<JBCPrimType> JBCOpFieldOpr::GetInputTypesFromStackImpl(const JBCConstPool &constPool) const {
+  switch (op) {
+    case kOpGetField:
+    case kOpGetStatic:
+      return GetInputTypesFromStackForGet(constPool);
+    case kOpPutField:
+    case kOpPutStatic:
+      return GetInputTypesFromStackForPut(constPool);
+    default:
+      CHECK_FATAL(false, "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+      return emptyPrimTypes;
+  }
+}
+
+JBCPrimType JBCOpFieldOpr::GetOutputTypesToStackImpl() const {
+  CHECK_FATAL(false, "Restricted Calls");
+  return kTypeDefault;
+}
+
+JBCPrimType JBCOpFieldOpr::GetOutputTypesToStackImpl(const JBCConstPool &constPool) const {
+  switch (op) {
+    case kOpGetField:
+    case kOpGetStatic: {
+      std::string desc = GetFieldType(constPool);
+      return JBCUtil::GetPrimTypeForName(desc);
+    }
+    case kOpPutField:
+    case kOpPutStatic:
+      return kTypeDefault;
+    default:
+      CHECK_FATAL(false, "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+      return kTypeDefault;
+  }
+}
+
+std::string JBCOpFieldOpr::DumpImpl(const JBCConstPool &constPool) const {
+  std::stringstream ss;
+  ss << GetOpcodeName() << " ";
+  const JBCConst *constRaw = constPool.GetConstByIdxWithTag(fieldIdx, JBCConstTag::kConstFieldRef);
+  if (constRaw == nullptr) {
+    ss << "unknown";
+  } else {
+    const JBCConstRef *constRef = static_cast<const JBCConstRef*>(constRaw);
+    CHECK_NULL_FATAL(constRef->GetConstClass());
+    ss << constRef->GetConstClass()->GetClassNameOrin() << "." << constRef->GetName() << ":" <<
+          constRef->GetDesc();
+  }
+  return ss.str();
+}
+
+std::vector<JBCPrimType> JBCOpFieldOpr::GetInputTypesFromStackForGet(const JBCConstPool &constPool) const {
+  (void) constPool;
+  std::vector<JBCPrimType> ans;
+  if (op == kOpGetField) {
+    ans.push_back(kTypeRef);
+  }
+  return ans;
+}
+
+std::vector<JBCPrimType> JBCOpFieldOpr::GetInputTypesFromStackForPut(const JBCConstPool &constPool) const {
+  std::vector<JBCPrimType> ans;
+  std::string desc = GetFieldType(constPool);
+  if (op == kOpPutField) {
+    ans.push_back(kTypeRef);
+  }
+  ans.push_back(JBCUtil::GetPrimTypeForName(desc));
+  return ans;
+}
+
+std::string JBCOpFieldOpr::GetFieldType(const JBCConstPool &constPool) const {
+  std::string desc = "";
+  const JBCConst *constRaw = constPool.GetConstByIdxWithTag(fieldIdx, kConstFieldRef);
+  if (constRaw != nullptr) {
+    const JBCConstRef *constRef = static_cast<const JBCConstRef*>(constRaw);
+    desc = constRef->GetDesc();
+  }
+  return desc;
+}
+
+// ---------- JBCOpInvoke ----------
+JBCOpInvoke::JBCOpInvoke(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), methodIdx(0), count(0) {}
+
+bool JBCOpInvoke::ParseFileImpl(BasicIORead &io) {
+  if (JBCOp::CheckNotWide(io) == false) {
+    return false;
+  }
+  bool success = false;
+  switch (op) {
+    case jbc::kOpInvokeVirtual:
+    case jbc::kOpInvokeSpecial:
+    case jbc::kOpInvokeStatic:
+      methodIdx = io.ReadUInt16(success);
+      break;
+    case jbc::kOpInvokeInterface:
+      methodIdx = io.ReadUInt16(success);
+      count = io.ReadUInt8(success);
+      (void)io.ReadUInt8(success);
+      break;
+    case jbc::kOpInvokeDynamic:
+      methodIdx = io.ReadUInt16(success);
+      (void)io.ReadUInt8(success);
+      (void)io.ReadUInt8(success);
+      break;
+    default:
+      ASSERT(false, "Unexpected opcode %s for Invoke", GetOpcodeName().c_str());
+      return false;
+  }
+  return success;
+}
+
+const std::vector<JBCPrimType> &JBCOpInvoke::GetInputTypesFromStackImpl() const {
+  CHECK_FATAL(false, "Restricted Calls");
+  return emptyPrimTypes;
+}
+
+std::vector<JBCPrimType> JBCOpInvoke::GetInputTypesFromStackImpl(const JBCConstPool &constPool) const {
+  std::vector<JBCPrimType> ans;
+  std::string desc = GetMethodDescription(constPool);
+  std::vector<std::string> typeNames = FEUtilJava::SolveMethodSignature(desc);
+  CHECK_FATAL(typeNames.size() > 0, "Invalid method description: %s", desc.c_str());
+  if (op != kOpInvokeStatic && op != kOpInvokeDynamic) {
+    ans.push_back(kTypeRef);
+  }
+  for (size_t i = 1; i < typeNames.size(); i++) {
+    ans.push_back(JBCUtil::GetPrimTypeForName(typeNames[i]));
+  }
+  return ans;
+}
+
+JBCPrimType JBCOpInvoke::GetOutputTypesToStackImpl() const {
+  CHECK_FATAL(false, "Restricted Calls");
+  return kTypeDefault;
+}
+
+JBCPrimType JBCOpInvoke::GetOutputTypesToStackImpl(const JBCConstPool &constPool) const {
+  std::string desc = GetMethodDescription(constPool);
+  std::vector<std::string> typeNames = FEUtilJava::SolveMethodSignature(desc);
+  CHECK_FATAL(typeNames.size() > 0, "Invalid method description: %s", desc.c_str());
+  return JBCUtil::GetPrimTypeForName(typeNames[0]);
+}
+
+std::string JBCOpInvoke::DumpImpl(const JBCConstPool &constPool) const {
+  std::stringstream ss;
+  ss << GetOpcodeName() << " ";
+  const JBCConst *constRaw = constPool.GetConstByIdx(methodIdx);
+  CHECK_NULL_FATAL(constRaw);
+  JBCConstTag tag = constRaw->GetTag();
+  if (op == jbc::kOpInvokeDynamic) {
+    if (tag == kConstInvokeDynamic) {
+      const JBCConstInvokeDynamic *constInvokdDynamic = static_cast<const JBCConstInvokeDynamic*>(constRaw);
+      CHECK_NULL_FATAL(constInvokdDynamic->GetConstNameAndType());
+      ss << constInvokdDynamic->GetBSMAttrIdx() << ":" <<
+            constInvokdDynamic->GetConstNameAndType()->GetName() << ":" <<
+            constInvokdDynamic->GetConstNameAndType()->GetDesc();
+    } else {
+      ss << "invalid const tag";
+    }
+  } else {
+    if (tag == kConstMethodRef || tag == kConstInterfaceMethodRef) {
+      const JBCConstRef *constRef = static_cast<const JBCConstRef*>(constRaw);
+      CHECK_NULL_FATAL(constRef->GetConstClass());
+      ss << constRef->GetConstClass()->GetClassNameOrin() << "." << constRef->GetName() << ":" <<
+            constRef->GetDesc();
+    } else {
+      ss << "invalid const tag";
+    }
+  }
+  return ss.str();
+}
+
+std::string JBCOpInvoke::GetMethodDescription(const JBCConstPool &constPool) const {
+  std::string desc = "";
+  switch (op) {
+    case jbc::kOpInvokeVirtual: {
+      const JBCConst *constRaw = constPool.GetConstByIdxWithTag(methodIdx, kConstMethodRef);
+      if (constRaw != nullptr) {
+        const JBCConstRef *constRef = static_cast<const JBCConstRef*>(constRaw);
+        desc = constRef->GetDesc();
+      }
+      break;
+    }
+    case jbc::kOpInvokeInterface: {
+      const JBCConst *constRaw = constPool.GetConstByIdxWithTag(methodIdx, kConstInterfaceMethodRef);
+      if (constRaw != nullptr) {
+        const JBCConstRef *constRef = static_cast<const JBCConstRef*>(constRaw);
+        desc = constRef->GetDesc();
+      }
+      break;
+    }
+    case jbc::kOpInvokeStatic:
+    case jbc::kOpInvokeSpecial: {
+      const JBCConst *constRaw = constPool.GetConstByIdx(methodIdx);
+      if (constRaw != nullptr && (constRaw->GetTag() == kConstMethodRef ||
+                                  constRaw->GetTag() == kConstInterfaceMethodRef)) {
+        const JBCConstRef *constRef = static_cast<const JBCConstRef*>(constRaw);
+        desc = constRef->GetDesc();
+      }
+      break;
+    }
+    case jbc::kOpInvokeDynamic: {
+      const JBCConst *constRaw = constPool.GetConstByIdxWithTag(methodIdx, kConstInvokeDynamic);
+      if (constRaw != nullptr) {
+        const JBCConstInvokeDynamic *constDynamic = static_cast<const JBCConstInvokeDynamic*>(constRaw);
+        desc = constDynamic->GetConstNameAndType()->GetDesc();
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+      break;
+  }
+  return desc;
+}
+
+// ---------- JBCOpJsrRet ----------
+JBCOpJsr::JBCOpJsr(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), target(0), slotIdx(0), jsrID(0) {}
+
+bool JBCOpJsr::ParseFileImpl(BasicIORead &io) {
+  if (JBCOp::CheckNotWide(io) == false) {
+    return false;
+  }
+  bool success = false;
+  int64 pc = io.GetPos() - 1;
+  switch (op) {
+    case jbc::kOpJsr:
+      target = GetTargetbyInt64(pc + io.ReadInt16(success));
+      break;
+    case jbc::kOpJsrW:
+      target = GetTargetbyInt64(pc + io.ReadInt32(success));
+      break;
+    default:
+      ASSERT(false, "Unexpected opcode %s for JSR", GetOpcodeName().c_str());
+      return false;
+  }
+  return success;
+}
+
+JBCPrimType JBCOpJsr::GetOutputTypesToStackImpl() const {
+  return JBCPrimType::kTypeAddress;
+}
+
+std::string JBCOpJsr::DumpImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  std::stringstream ss;
+  ss << GetOpcodeName() << " " << target;
+  return ss.str();
+}
+
+// ---------- JBCOpRet ----------
+JBCOpRet::JBCOpRet(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), index(0) {}
+
+bool JBCOpRet::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  if (wide) {
+    index = io.ReadUInt16(success);
+  } else {
+    index = io.ReadUInt8(success);
+  }
+  return success;
+}
+
+std::string JBCOpRet::DumpImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  std::stringstream ss;
+  ss << GetOpcodeName() << " " << index;
+  return ss.str();
+}
+
+// ---------- JBCOpNew ----------
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpNew::mapOpInputTypes = JBCOpNew::InitMapOpInputTypes();
+
+JBCOpNew::JBCOpNew(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), refTypeIdx(0), primType(kPrimNone) {}
+
+bool JBCOpNew::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  switch (op) {
+    case jbc::kOpNew:
+    case jbc::kOpANewArray:
+      refTypeIdx = io.ReadUInt16(success);
+      break;
+    case jbc::kOpNewArray:
+      primType = io.ReadUInt8(success);
+      break;
+    default:
+      ASSERT(false, "Unexpected opcode %s for New", GetOpcodeName().c_str());
+      return false;
+  }
+  return success;
+}
+
+const std::vector<JBCPrimType> &JBCOpNew::GetInputTypesFromStackImpl() const {
+  auto it = mapOpInputTypes.find(op);
+  CHECK_FATAL(it != mapOpInputTypes.end(), "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+JBCPrimType JBCOpNew::GetOutputTypesToStackImpl() const {
+  return kTypeRef;
+}
+
+std::string JBCOpNew::DumpImpl(const JBCConstPool &constPool) const {
+  switch (op) {
+    case jbc::kOpNew:
+    case jbc::kOpANewArray: {
+      std::stringstream ss;
+      const JBCConst *constRaw = constPool.GetConstByIdxWithTag(refTypeIdx, JBCConstTag::kConstClass);
+      CHECK_NULL_FATAL(constRaw);
+      const JBCConstClass *constClass = static_cast<const JBCConstClass*>(constRaw);
+      ss << GetOpcodeName() << " " << constClass->GetClassNameOrin();
+      return ss.str();
+    }
+    case jbc::kOpNewArray: {
+      std::stringstream ss;
+      ss << GetOpcodeName() << " " << GetPrimTypeName();
+      return ss.str();
+    }
+    default:
+      ASSERT(false, "Unexpected opcode %s for New", GetOpcodeName().c_str());
+      return "";
+  }
+}
+
+GStrIdx JBCOpNew::GetTypeNameIdx(const JBCConstPool &constPool) const {
+  switch (op) {
+    case jbc::kOpNew:
+    case jbc::kOpANewArray: {
+      const JBCConst *constRaw = constPool.GetConstByIdxWithTag(refTypeIdx, JBCConstTag::kConstClass);
+      CHECK_NULL_FATAL(constRaw);
+      const JBCConstClass *constClass = static_cast<const JBCConstClass*>(constRaw);
+      return constClass->GetClassNameIdxMpl();
+    }
+    case jbc::kOpNewArray:
+      return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(GetPrimTypeName());
+    default:
+      ASSERT(false, "Unexpected opcode %s for New", GetOpcodeName().c_str());
+      return GStrIdx(0);
+  }
+}
+
+std::string JBCOpNew::GetTypeName(const JBCConstPool &constPool) const {
+  switch (op) {
+    case jbc::kOpNew:
+    case jbc::kOpANewArray: {
+      const JBCConst *constRaw = constPool.GetConstByIdxWithTag(refTypeIdx, JBCConstTag::kConstClass);
+      CHECK_NULL_FATAL(constRaw);
+      const JBCConstClass *constClass = static_cast<const JBCConstClass*>(constRaw);
+      return constClass->GetClassNameMpl();
+    }
+    case jbc::kOpNewArray:
+      return GetPrimTypeName();
+    default:
+      ASSERT(false, "Unexpected opcode %s for New", GetOpcodeName().c_str());
+      return "";
+  }
+}
+
+const FEIRType *JBCOpNew::GetFEIRType(const JBCConstPool &constPool) const {
+  switch (op) {
+    case jbc::kOpNew:
+    case jbc::kOpANewArray: {
+      const JBCConst *constRaw = constPool.GetConstByIdxWithTag(refTypeIdx, JBCConstTag::kConstClass);
+      CHECK_NULL_FATAL(constRaw);
+      const JBCConstClass *constClass = static_cast<const JBCConstClass*>(constRaw);
+      return constClass->GetFEIRType();
+    }
+    case jbc::kOpNewArray:
+      return GetPrimFEIRType().get();
+    default:
+      CHECK_FATAL(false, "Unexpected opcode %s for New", GetOpcodeName().c_str());
+      return FETypeManager::kPrimFEIRTypeUnknown.get();
+  }
+}
+
+std::string JBCOpNew::GetPrimTypeName() const {
+  switch (primType) {
+    case kPrimInt:
+      return "I";
+    case kPrimBoolean:
+      return "Z";
+    case kPrimByte:
+      return "B";
+    case kPrimShort:
+      return "S";
+    case kPrimChar:
+      return "C";
+    case kPrimLong:
+      return "J";
+    case kPrimFloat:
+      return "F";
+    case kPrimDouble:
+      return "D";
+    default:
+      return "undefined";
+  }
+}
+
+const UniqueFEIRType &JBCOpNew::GetPrimFEIRType() const {
+  switch (primType) {
+    case kPrimInt:
+      return FETypeManager::kPrimFEIRTypeI32;
+    case kPrimBoolean:
+      return FETypeManager::kPrimFEIRTypeU1;
+    case kPrimByte:
+      return FETypeManager::kPrimFEIRTypeI8;
+    case kPrimShort:
+      return FETypeManager::kPrimFEIRTypeI16;
+    case kPrimChar:
+      return FETypeManager::kPrimFEIRTypeU16;
+    case kPrimLong:
+      return FETypeManager::kPrimFEIRTypeI64;
+    case kPrimFloat:
+      return FETypeManager::kPrimFEIRTypeF32;
+    case kPrimDouble:
+      return FETypeManager::kPrimFEIRTypeF64;
+    default:
+      return FETypeManager::kPrimFEIRTypeUnknown;
+  }
+}
+
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpNew::InitMapOpInputTypes() {
+  std::map<JBCOpcode, std::vector<JBCPrimType>> ans;
+  ans[kOpNew] = emptyPrimTypes;
+  ans[kOpNewArray] = std::vector<JBCPrimType>({ kTypeInt });
+  ans[kOpANewArray] = std::vector<JBCPrimType>({ kTypeInt });
+  return ans;
+}
+
+// ---------- JBCOpMultiANewArray ----------
+JBCOpMultiANewArray::JBCOpMultiANewArray(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), refTypeIdx(0), dim(0) {}
+
+bool JBCOpMultiANewArray::ParseFileImpl(BasicIORead &io) {
+  bool success = false;
+  refTypeIdx = io.ReadUInt16(success);
+  dim = io.ReadUInt8(success);
+  return true;
+}
+
+const std::vector<JBCPrimType> &JBCOpMultiANewArray::GetInputTypesFromStackImpl() const {
+  CHECK_FATAL(false, "Restricted Calls");
+  return emptyPrimTypes;
+}
+
+std::vector<JBCPrimType> JBCOpMultiANewArray::GetInputTypesFromStackImpl(const JBCConstPool &constPool) const {
+  (void) constPool;
+  std::vector<JBCPrimType> ans;
+  for (uint8 i = 0; i < dim; i++) {
+    ans.push_back(kTypeInt);
+  }
+  return ans;
+}
+
+JBCPrimType JBCOpMultiANewArray::GetOutputTypesToStackImpl() const {
+  return kTypeRef;
+}
+
+std::string JBCOpMultiANewArray::DumpImpl(const JBCConstPool &constPool) const {
+  std::stringstream ss;
+  ss << GetOpcodeName() << " ";
+  const JBCConst *constRaw = constPool.GetConstByIdx(refTypeIdx);
+  CHECK_NULL_FATAL(constRaw);
+  if (constRaw->GetTag() == kConstClass) {
+    const JBCConstClass *constClass = static_cast<const JBCConstClass*>(constRaw);
+    ss << constClass->GetClassNameOrin() << " dim=" << uint32{ dim };
+  } else {
+    ss << "invalid const tag";
+  }
+  return ss.str();
+}
+
+// ---------- JBCOpTypeCheck ----------
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpTypeCheck::mapOpInputTypes = JBCOpTypeCheck::InitMapOpInputTypes();
+std::map<JBCOpcode, JBCPrimType> JBCOpTypeCheck::mapOpOutputType = JBCOpTypeCheck::InitMapOpOutputType();
+
+JBCOpTypeCheck::JBCOpTypeCheck(MapleAllocator &allocator, JBCOpcode opIn, JBCOpcodeKind kindIn, bool wideIn)
+    : JBCOp(allocator, opIn, kindIn, wideIn), typeIdx(0) {}
+
+bool JBCOpTypeCheck::ParseFileImpl(BasicIORead &io) {
+  if (JBCOp::CheckNotWide(io) == false) {
+    return false;
+  }
+  bool success = false;
+  switch (op) {
+    case jbc::kOpCheckCast:
+    case jbc::kOpInstanceOf:
+      typeIdx = io.ReadUInt16(success);
+      break;
+    default:
+      ASSERT(false, "Unexpected opcode %s for TypeCheck", GetOpcodeName().c_str());
+      return false;
+  }
+  return success;
+}
+
+const std::vector<JBCPrimType> &JBCOpTypeCheck::GetInputTypesFromStackImpl() const {
+  auto it = mapOpInputTypes.find(op);
+  CHECK_FATAL(it != mapOpInputTypes.end(), "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+JBCPrimType JBCOpTypeCheck::GetOutputTypesToStackImpl() const {
+  auto it = mapOpOutputType.find(op);
+  CHECK_FATAL(it != mapOpOutputType.end(), "Unsupported opcode %s", opcodeInfo.GetOpcodeName(op).c_str());
+  return it->second;
+}
+
+std::string JBCOpTypeCheck::DumpImpl(const JBCConstPool &constPool) const {
+  std::stringstream ss;
+  ss << GetOpcodeName() << " ";
+  const JBCConst *constRaw = constPool.GetConstByIdxWithTag(typeIdx, kConstClass);
+  if (constRaw == nullptr) {
+    ss << "invalid type idx";
+    return ss.str();
+  }
+  const JBCConstClass *constClass = static_cast<const JBCConstClass*>(constRaw);
+  ss << constClass->GetClassNameOrin();
+  return ss.str();
+}
+
+std::map<JBCOpcode, std::vector<JBCPrimType>> JBCOpTypeCheck::InitMapOpInputTypes() {
+  std::map<JBCOpcode, std::vector<JBCPrimType>> ans;
+  ans[kOpCheckCast] = std::vector<JBCPrimType>({ kTypeRef });
+  ans[kOpInstanceOf] = std::vector<JBCPrimType>({ kTypeRef });
+  return ans;
+}
+
+std::map<JBCOpcode, JBCPrimType> JBCOpTypeCheck::InitMapOpOutputType() {
+  std::map<JBCOpcode, JBCPrimType> ans;
+  ans[kOpCheckCast] = kTypeRef;
+  ans[kOpInstanceOf] = kTypeInt;
+  return ans;
+}
+}  // namespace jbc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_opcode_helper.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_opcode_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..736ba958ef132e9887decdb6dee6a96c47915e8b
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_opcode_helper.cpp
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_opcode_helper.h"
+#include "jbc_class_const.h"
+#include "fe_utils_java.h"
+#include "fe_type_manager.h"
+
+namespace maple {
+std::map<jbc::JBCOpcode, std::vector<jbc::JBCPrimType>> JBCOpcodeHelper::mapOpInputPrimTypes =
+    JBCOpcodeHelper::InitMapOpInputPrimTypes();
+
+std::map<jbc::JBCOpcodeKind, JBCOpcodeHelper::FuncPtrGetBaseTypeName> JBCOpcodeHelper::funcPtrMapGetBaseTypeName =
+    JBCOpcodeHelper::InitFuncPtrMapGetBaseTypeName();
+
+JBCOpcodeHelper::JBCOpcodeHelper(const jbc::JBCClassMethod &argMethod) : method(argMethod) {}
+
+std::vector<std::string> JBCOpcodeHelper::GetBaseTypeNamesForOP(const jbc::JBCOp &op, bool &success) {
+  auto it = funcPtrMapGetBaseTypeName.find(op.GetOpcodeKind());
+  if (it == funcPtrMapGetBaseTypeName.end()) {
+    return GetBaseTypeNamesForOPDefault(success);
+  } else {
+    return (this->*(it->second))(op, success);
+  }
+}
+
+std::map<jbc::JBCOpcodeKind, JBCOpcodeHelper::FuncPtrGetBaseTypeName> JBCOpcodeHelper::InitFuncPtrMapGetBaseTypeName() {
+  std::map<jbc::JBCOpcodeKind, JBCOpcodeHelper::FuncPtrGetBaseTypeName> ans;
+  ans[jbc::kOpKindConst] = &JBCOpcodeHelper::GetBaseTypeNamesForOPConst;
+  ans[jbc::kOpKindStaticFieldOpr] = &JBCOpcodeHelper::GetBaseTypeNamesForOPFieldOpr;
+  ans[jbc::kOpKindFieldOpr] = &JBCOpcodeHelper::GetBaseTypeNamesForOPFieldOpr;
+  ans[jbc::kOpKindInvoke] = &JBCOpcodeHelper::GetBaseTypeNamesForOPInvoke;
+  ans[jbc::kOpKindNew] = &JBCOpcodeHelper::GetBaseTypeNamesForOPNew;
+  ans[jbc::kOpKindMultiANewArray] = &JBCOpcodeHelper::GetBaseTypeNamesForOPMultiANewArray;
+  ans[jbc::kOpKindTypeCheck] = &JBCOpcodeHelper::GetBaseTypeNamesForOPTypeCheck;
+  return ans;
+}
+
+std::vector<std::string> JBCOpcodeHelper::GetBaseTypeNamesForOPDefault(bool &success) const {
+  success = true;
+  return std::vector<std::string>();
+}
+
+std::vector<std::string> JBCOpcodeHelper::GetBaseTypeNamesForOPConst(const jbc::JBCOp &op, bool &success) {
+  std::vector<std::string> ans;
+  const jbc::JBCOpConst &opConst = static_cast<const jbc::JBCOpConst&>(op);
+  if (op.GetOpcode() == jbc::kOpLdc || op.GetOpcode() == jbc::kOpLdcW) {
+    const jbc::JBCConstPool &constPool = method.GetConstPool();
+    const jbc::JBCConst *constItem = constPool.GetConstByIdx(opConst.GetIndex());
+    if (constItem == nullptr) {
+      ssLastError.str("");
+      ssLastError << "invalid const pool index (" << opConst.GetIndex() << ") in method "
+                  << method.GetClassName() << "." << method.GetName() << ":" << method.GetDescription();
+      success = false;
+      return ans;
+    }
+    if (constItem->GetTag() == jbc::kConstClass) {
+      success = true;
+      const jbc::JBCConstClass *constClass = static_cast<const jbc::JBCConstClass*>(constItem);
+      std::string typeName = constClass->GetClassNameOrin();
+      std::string baseTypeName = FETypeManager::GetBaseTypeName(typeName, false);
+      ans.push_back(baseTypeName);
+    }
+  }
+  success = true;
+  return ans;
+}
+
+std::vector<std::string> JBCOpcodeHelper::GetBaseTypeNamesForOPFieldOpr(const jbc::JBCOp &op, bool &success) {
+  std::vector<std::string> ans;
+  const jbc::JBCOpFieldOpr &opFieldOpr = static_cast<const jbc::JBCOpFieldOpr&>(op);
+  const jbc::JBCConstPool &constPool = method.GetConstPool();
+  const jbc::JBCConst *constItem = constPool.GetConstByIdxWithTag(opFieldOpr.GetFieldIdx(), jbc::kConstFieldRef);
+  if (constItem == nullptr) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstRef *constRef = static_cast<const jbc::JBCConstRef*>(constItem);
+  ans.push_back(FETypeManager::GetBaseTypeName(constRef->GetDesc(), false));
+  success = true;
+  return ans;
+}
+
+std::vector<std::string> JBCOpcodeHelper::GetBaseTypeNamesForOPInvoke(const jbc::JBCOp &op, bool &success) {
+  std::vector<std::string> ans;
+  const jbc::JBCOpInvoke &opInvoke = static_cast<const jbc::JBCOpInvoke&>(op);
+  const jbc::JBCConstPool &constPool = method.GetConstPool();
+  const jbc::JBCConst *constItem = constPool.GetConstByIdx(opInvoke.GetMethodIdx());
+  if (constItem == nullptr ||
+      (constItem->GetTag() != jbc::kConstMethodRef && constItem->GetTag() != jbc::kConstInterfaceMethodRef)) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstRef *constRef = static_cast<const jbc::JBCConstRef*>(constItem);
+  const std::string desc = constRef->GetDesc();
+  std::vector<std::string> typeNames = FEUtilJava::SolveMethodSignature(desc);
+  for (const std::string &typeName : typeNames) {
+    ans.push_back(FETypeManager::GetBaseTypeName(typeName, false));
+  }
+  success = true;
+  return ans;
+}
+
+std::vector<std::string> JBCOpcodeHelper::GetBaseTypeNamesForOPNew(const jbc::JBCOp &op, bool &success) {
+  std::vector<std::string> ans;
+  const jbc::JBCOpNew &opNew = static_cast<const jbc::JBCOpNew&>(op);
+  const jbc::JBCConstPool &constPool = method.GetConstPool();
+  if (op.GetOpcode() == jbc::kOpNew || op.GetOpcode() == jbc::kOpANewArray) {
+    const jbc::JBCConst *constItem = constPool.GetConstByIdxWithTag(opNew.GetRefTypeIdx(), jbc::kConstClass);
+    if (constItem == nullptr) {
+      success = false;
+      return ans;
+    }
+    const jbc::JBCConstClass *constClass = static_cast<const jbc::JBCConstClass*>(constItem);
+    ans.push_back(FETypeManager::GetBaseTypeName(constClass->GetClassNameOrin(), false));
+  }
+  success = true;
+  return ans;
+}
+
+std::vector<std::string> JBCOpcodeHelper::GetBaseTypeNamesForOPMultiANewArray(const jbc::JBCOp &op, bool &success) {
+  std::vector<std::string> ans;
+  const jbc::JBCOpMultiANewArray &opArray = static_cast<const jbc::JBCOpMultiANewArray&>(op);
+  const jbc::JBCConstPool &constPool = method.GetConstPool();
+  const jbc::JBCConst *constItem = constPool.GetConstByIdxWithTag(opArray.GetRefTypeIdx(), jbc::kConstClass);
+  if (constItem == nullptr) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstClass *constClass = static_cast<const jbc::JBCConstClass*>(constItem);
+  ans.push_back(FETypeManager::GetBaseTypeName(constClass->GetClassNameOrin(), false));
+  success = true;
+  return ans;
+}
+
+std::vector<std::string> JBCOpcodeHelper::GetBaseTypeNamesForOPTypeCheck(const jbc::JBCOp &op, bool &success) {
+  std::vector<std::string> ans;
+  const jbc::JBCOpTypeCheck &opTypeCheck = static_cast<const jbc::JBCOpTypeCheck&>(op);
+  const jbc::JBCConstPool &constPool = method.GetConstPool();
+  const jbc::JBCConst *constItem = constPool.GetConstByIdxWithTag(opTypeCheck.GetTypeIdx(), jbc::kConstClass);
+  if (constItem == nullptr) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstClass *constClass = static_cast<const jbc::JBCConstClass*>(constItem);
+  ans.push_back(FETypeManager::GetBaseTypeName(constClass->GetClassNameOrin(), false));
+  success = true;
+  return ans;
+}
+
+std::map<jbc::JBCOpcode, std::vector<jbc::JBCPrimType>> JBCOpcodeHelper::InitMapOpInputPrimTypes() {
+  std::map<jbc::JBCOpcode, std::vector<jbc::JBCPrimType>> ans;
+  InitMapOpInputPrimTypesForConst(ans);
+
+  return ans;
+}
+
+void JBCOpcodeHelper::InitMapOpInputPrimTypesForConst(std::map<jbc::JBCOpcode, std::vector<jbc::JBCPrimType>> &ans) {
+  ans[jbc::kOpAConstNull] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpIConstM1] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpIConst0] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpIConst1] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpIConst2] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpIConst3] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpIConst4] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpIConst5] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpLConst0] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpLConst1] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpFConst0] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpFConst1] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpFConst2] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpDConst0] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpDConst1] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpBiPush] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpSiPush] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpLdc] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpLdcW] = std::vector<jbc::JBCPrimType>();
+  ans[jbc::kOpLdc2W] = std::vector<jbc::JBCPrimType>();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_stack2fe_helper.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_stack2fe_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..916d2cbe0bfccd369c115ef4397fa2fc351e3afb
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_stack2fe_helper.cpp
@@ -0,0 +1,707 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_stack2fe_helper.h"
+#include <algorithm>
+#include "mpl_logging.h"
+
+namespace maple {
+JBCStack2FEHelper::JBCStack2FEHelper(bool argUseNestExpr)
+    : useNestExpr(argUseNestExpr) {}
+
+// Function Name: GetRegNumForSlot
+// Description: adjust slotNum using following layout
+//              set baseLocal as nStacks + nSwaps
+//              set allLocals as nLocals + nArgs
+//              0 ~ baseLocal - 1: stack reg (local)
+//              baseLocal ~ baseLocal + nLocals - 1: local var
+//                  (mapping to slotNum: nArgs ~ allLocals - 1)
+//              baseLocal + nLocals ~ baseLocal + allLocals - 1: args var
+//                  (mapping to slotNum: 0 ~ nArgs - 1)
+
+uint32 JBCStack2FEHelper::GetRegNumForSlot(uint32 slotNum) const {
+  uint32 baseLocal = nStacks + nSwaps;
+  uint32 allLocals = nLocals + nArgs;
+  CHECK_FATAL(slotNum < allLocals, "GetRegNumForSlot: out of range");
+  if (slotNum >= nArgs) {
+    // local var
+    // nArgs ~ nArgs + nLocals - 1 --> baseLocal ~ baseLocal + nLocals - 1
+    return baseLocal - nArgs + slotNum;
+  } else {
+    // arg var
+    // 0 ~ nArgs - 1 --> baseLocal + nLocals ~ baseLocal + nLocals + nArgs - 1
+    return baseLocal + nLocals + slotNum;
+  }
+}
+
+uint32 JBCStack2FEHelper::GetRegNumForStack() const {
+  std::set<uint32> setAvaliable = regNumForStacks;
+  for (const StackItem &item : stack) {
+    const UniqueFEIRVar &var = item.first;
+    if (IsItemDummy(item)) {
+      continue;
+    }
+    ASSERT(var->GetKind() == FEIRVarKind::kFEIRVarReg, "unsupported var kind");
+    FEIRVarReg *ptrVarReg = static_cast<FEIRVarReg*>(var.get());
+    (void)setAvaliable.erase(ptrVarReg->GetRegNum());
+    if (IsItemWide(item)) {
+      (void)setAvaliable.erase(ptrVarReg->GetRegNum() + 1);
+    }
+  }
+  CHECK_FATAL(setAvaliable.size() > 0, "no avaliable reg number to use");
+  return *(setAvaliable.begin());
+}
+
+bool JBCStack2FEHelper::PushItem(UniqueFEIRVar var, PrimType pty) {
+  if (stack.size() >= nStacks) {
+    ERR(kLncErr, "stack out of range");
+    return false;
+  }
+  stack.push_back(MakeStackItem(std::move(var), pty));
+  if (IsPrimTypeWide(pty)) {
+    stack.push_back(MakeStackItem(UniqueFEIRVar(nullptr), pty));
+  }
+  return true;
+}
+
+UniqueFEIRVar JBCStack2FEHelper::PushItem(PrimType pty) {
+  uint32 regNum = GetRegNumForStack();
+  UniqueFEIRVar var = FEIRBuilder::CreateVarReg(regNum, pty);
+  if (!PushItem(var->Clone(), pty)) {
+    return UniqueFEIRVar(nullptr);
+  } else {
+    return var;
+  }
+}
+
+UniqueFEIRStmt JBCStack2FEHelper::PushItem(UniqueFEIRExpr expr, PrimType pty, bool hasException) {
+  uint32 regNum = GetRegNumForStack();
+  UniqueFEIRVar varDst = FEIRBuilder::CreateVarReg(regNum, pty);
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(varDst->Clone(), std::move(expr), hasException);
+  if (PushItem(std::move(varDst), pty)) {
+    return UniqueFEIRStmt(nullptr);
+  } else {
+    return stmt;
+  }
+}
+
+UniqueFEIRStmt JBCStack2FEHelper::PushItem(UniqueFEIRExpr expr, UniqueFEIRType type, bool hasException) {
+  uint32 regNum = GetRegNumForStack();
+  UniqueFEIRVar varDst = FEIRBuilder::CreateVarReg(regNum, std::move(type));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(varDst->Clone(), std::move(expr), hasException);
+  PrimType pty = PTY_unknown;
+  if (!type->IsScalar()) {
+    pty = PTY_ref;
+  } else {
+    pty = type->GetPrimType();
+  }
+  if (!PushItem(std::move(varDst), pty)) {
+    return UniqueFEIRStmt(nullptr);
+  } else {
+    return stmt;
+  }
+}
+
+UniqueFEIRVar JBCStack2FEHelper::PopItem(PrimType pty) {
+  size_t size = stack.size();
+  if (IsPrimTypeWide(pty)) {
+    if (size < 2) {  // pop wide item operation need at least 2 items in stack
+      ERR(kLncErr, "stack items are not enough for pop operation");
+      return UniqueFEIRVar();
+    }
+    StackItem &item1 = stack[size - 1];  // the 1st item from top
+    StackItem &item2 = stack[size - 2];  // the 2nd item from top
+    if (IsItemDummy(item1) && IsItemWide(item2) && item2.second == pty) {
+      UniqueFEIRVar ans = std::move(item2.first);
+      stack.pop_back();
+      stack.pop_back();
+      return ans;
+    } else {
+      ERR(kLncErr, "invalid stack items for pop wide item operation");
+      return UniqueFEIRVar(nullptr);
+    }
+  } else {
+    if (size < 1) {  // pop normal item operation need at least 1 item in stack
+      ERR(kLncErr, "stack items are not enough for pop operation");
+      return UniqueFEIRVar(nullptr);
+    }
+    StackItem &item = stack[size - 1];  // the 1st item from top
+    if (IsItemNormal(item) && item.second == pty) {
+      UniqueFEIRVar ans = std::move(item.first);
+      stack.pop_back();
+      return ans;
+    } else {
+      ERR(kLncErr, "invalid stack items for pop item operation");
+      return UniqueFEIRVar(nullptr);
+    }
+  }
+}
+
+UniqueFEIRVar JBCStack2FEHelper::PopItem(UniqueFEIRType type) {
+  UniqueFEIRVar var = PopItem(type->GetPrimType());
+  var->SetType(std::move(type));
+  return var;
+}
+
+UniqueFEIRVar JBCStack2FEHelper::PopItem(bool isWide, PrimType &pty) {
+  size_t size = stack.size();
+  pty = PTY_unknown;
+  if (isWide) {
+    if (size < 2) {  // pop wide item operation need at least 2 items in stack
+      ERR(kLncErr, "stack items are not enough for pop operation");
+      return UniqueFEIRVar(nullptr);
+    }
+    StackItem &item1 = stack[size - 1];  // the 1st item from top
+    StackItem &item2 = stack[size - 2];  // the 2nd item from top
+    if (IsItemDummy(item1) && IsItemWide(item2)) {
+      UniqueFEIRVar ans = std::move(item2.first);
+      pty = item2.second;
+      stack.pop_back();
+      stack.pop_back();
+      return ans;
+    } else {
+      ERR(kLncErr, "invalid stack items for pop wide item operation");
+      return UniqueFEIRVar(nullptr);
+    }
+  } else {
+    if (size < 1) {  // pop normal item operation need at least 1 item in stack
+      ERR(kLncErr, "stack items are not enough for pop operation");
+      return UniqueFEIRVar(nullptr);
+    }
+    StackItem &item = stack[size - 1];  // the 1st item from top
+    if (IsItemNormal(item)) {
+      UniqueFEIRVar ans = std::move(item.first);
+      pty = item.second;
+      stack.pop_back();
+      return ans;
+    } else {
+      ERR(kLncErr, "invalid stack items for pop wide item operation");
+      return UniqueFEIRVar(nullptr);
+    }
+  }
+}
+
+UniqueFEIRVar JBCStack2FEHelper::PopItemAuto(PrimType &pty) {
+  size_t size = stack.size();
+  if (size < 1) {  // pop item operation need at least 1 item in stack
+    ERR(kLncErr, "stack items are not enough for pop operation");
+    return UniqueFEIRVar(nullptr);
+  }
+  pty = PTY_unknown;
+  StackItem &item1 = stack[size - 1];  // the 1st item from top
+  if (IsItemDummy(item1)) {
+    if (size < 2) {  // pop wide item operation need at least 2 items in stack
+      ERR(kLncErr, "stack items are not enough for pop operation");
+      return UniqueFEIRVar(nullptr);
+    }
+    StackItem &item2 = stack[size - 2];  // the 2nd item from top
+    if (IsItemWide(item2)) {
+      UniqueFEIRVar ans = std::move(item2.first);
+      pty = item2.second;
+      stack.pop_back();
+      stack.pop_back();
+      return ans;
+    } else {
+      ERR(kLncErr, "invalid stack items for pop wide item operation");
+      return UniqueFEIRVar(nullptr);
+    }
+  } else if (IsItemNormal(item1)) {
+    UniqueFEIRVar ans = std::move(item1.first);
+    pty = item1.second;
+    stack.pop_back();
+    return ans;
+  } else {
+    ERR(kLncErr, "invalid stack items for pop wide item operation");
+    return UniqueFEIRVar(nullptr);
+  }
+}
+
+bool JBCStack2FEHelper::Swap() {
+  size_t size = stack.size();
+  if (size < 2) {  // swap operation need at least 2 items in stack
+    ERR(kLncErr, "stack is not enough for swap operation");
+    return false;
+  }
+  StackItem &item1 = stack[size - 1];  // the 1st item from top
+  StackItem &item2 = stack[size - 2];  // the 2nd item from top
+  if (IsItemNormal(item1) && IsItemNormal(item2)) {
+    UniqueFEIRVar var1 = std::move(item1.first);
+    PrimType pty1 = item1.second;
+    UniqueFEIRVar var2 = std::move(item2.first);
+    PrimType pty2 = item2.second;
+    stack.pop_back();
+    stack.pop_back();
+    stack.push_back(MakeStackItem(std::move(var1), pty1));
+    stack.push_back(MakeStackItem(std::move(var2), pty2));
+    return true;
+  } else {
+    ERR(kLncErr, "invalid stack items for swap operation");
+    return false;
+  }
+}
+
+bool JBCStack2FEHelper::Pop(jbc::JBCOpcode opcode) {
+  switch (opcode) {
+    case jbc::kOpPop:
+      return Pop();
+    case jbc::kOpPop2:
+      return Pop2();
+    default:
+      ERR(kLncErr, "unsupported op: %s", jbc::JBCOp::GetOpcodeInfo().GetOpcodeName(opcode).c_str());
+      return false;
+  }
+}
+
+bool JBCStack2FEHelper::Dup(jbc::JBCOpcode opcode) {
+  switch (opcode) {
+    case jbc::kOpDup:
+      return Dup();
+    case jbc::kOpDupX1:
+      return DupX1();
+    case jbc::kOpDupX2:
+      return DupX2();
+    case jbc::kOpDup2:
+      return Dup2();
+    case jbc::kOpDup2X1:
+      return Dup2X1();
+    case jbc::kOpDup2X2:
+      return Dup2X2();
+    default:
+      ERR(kLncErr, "unsupported op: %s", jbc::JBCOp::GetOpcodeInfo().GetOpcodeName(opcode).c_str());
+      return false;
+  }
+}
+
+std::list<UniqueFEIRStmt> JBCStack2FEHelper::GenerateSwapStmts() {
+  std::list<UniqueFEIRStmt> ans;
+  PrimType pty = PTY_unknown;
+  UniqueFEIRVar varStack = PopItemAuto(pty);
+  uint32 swapRegNum = nStacks;
+  while (varStack != nullptr) {
+    UniqueFEIRVar varSwap = std::make_unique<FEIRVarReg>(swapRegNum, pty);
+    UniqueFEIRExpr exprDRead = FEIRBuilder::CreateExprDRead(std::move(varStack));
+    UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(std::move(varSwap), std::move(exprDRead));
+    ans.push_back(std::move(stmtDAssign));
+    if (pty == PTY_i64 || pty == PTY_f64) {
+      swapRegNum += kRegNumOffWide;
+    } else {
+      swapRegNum += kRegNumOff;
+    }
+    varStack = PopItemAuto(pty);
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStack2FEHelper::LoadSwapStack(const JBCStackHelper &stackHelper, bool &success) {
+  std::list<UniqueFEIRStmt> ans;
+  std::vector<jbc::JBCPrimType> jbcStackItems = stackHelper.GetStackItems();
+  std::vector<PrimType> primStackItems = JBCStackItemTypesToPrimTypes(jbcStackItems);
+  stack.clear();
+  if (!CheckSwapValid(primStackItems)) {
+    success = false;
+    return ans;
+  }
+  std::vector<std::pair<uint32, PrimType>> swapRegs = GeneralSwapRegNum(primStackItems);
+  uint32 regNumStack = 0;
+  for (const std::pair<uint32, PrimType> &item : swapRegs) {
+    PrimType pty = item.second;
+    UniqueFEIRVar varSwap = std::make_unique<FEIRVarReg>(item.first, pty);
+    UniqueFEIRVar varStack = std::make_unique<FEIRVarReg>(regNumStack, pty);
+    UniqueFEIRExpr exprDRead = FEIRBuilder::CreateExprDRead(std::move(varSwap));
+    UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(varStack->Clone(), std::move(exprDRead));
+    ans.push_back(std::move(stmtDAssign));
+    stack.push_back(MakeStackItem(std::move(varStack), pty));
+    if (pty == PTY_i64 || pty == PTY_f64) {
+      regNumStack += kRegNumOffWide;
+      stack.push_back(MakeStackItem(UniqueFEIRVar(nullptr), pty));
+    } else {
+      regNumStack += kRegNumOff;
+    }
+  }
+  success = true;
+  return ans;
+}
+
+PrimType JBCStack2FEHelper::JBCStackItemTypeToPrimType(jbc::JBCPrimType itemType) {
+  switch (itemType) {
+    case jbc::JBCPrimType::kTypeInt:
+    case jbc::JBCPrimType::kTypeByteOrBoolean:
+    case jbc::JBCPrimType::kTypeShort:
+    case jbc::JBCPrimType::kTypeChar:
+      return PTY_i32;
+    case jbc::JBCPrimType::kTypeLong:
+      return PTY_i64;
+    case jbc::JBCPrimType::kTypeFloat:
+      return PTY_f32;
+    case jbc::JBCPrimType::kTypeDouble:
+      return PTY_f64;
+    case jbc::JBCPrimType::kTypeRef:
+      return PTY_ref;
+    case jbc::JBCPrimType::kTypeAddress:
+      return PTY_a32;
+    case jbc::JBCPrimType::kTypeDefault:
+      return PTY_unknown;
+    default:
+      ERR(kLncErr, "Should not run here: unsupported type");
+      return PTY_unknown;
+  }
+}
+
+PrimType JBCStack2FEHelper::SimplifyPrimType(PrimType pty) {
+  switch (pty) {
+    case PTY_u1:   // boolean
+    case PTY_i8:   // byte
+    case PTY_i16:  // short
+    case PTY_u16:  // char
+      return PTY_i32;
+    default:
+      return pty;
+  }
+}
+
+std::vector<PrimType> JBCStack2FEHelper::JBCStackItemTypesToPrimTypes(const std::vector<jbc::JBCPrimType> itemTypes) {
+  std::vector<PrimType> primTypes;
+  for (jbc::JBCPrimType itemType : itemTypes) {
+    primTypes.push_back(JBCStackItemTypeToPrimType(itemType));
+  }
+  return primTypes;
+}
+
+bool JBCStack2FEHelper::CheckSwapValid(const std::vector<PrimType> items) const {
+  uint32 size = 0;
+  for (PrimType pty : items) {
+    if (pty == PTY_i64 || pty == PTY_f64) {
+      size += kRegNumOffWide;
+    } else {
+      size += kRegNumOff;
+    }
+  }
+  if (size > nSwaps) {
+    ERR(kLncErr, "swap stack out of range");
+    return false;
+  } else {
+    return true;
+  }
+}
+
+std::vector<std::pair<uint32, PrimType>> JBCStack2FEHelper::GeneralSwapRegNum(const std::vector<PrimType> items) {
+  std::vector<std::pair<uint32, PrimType>> ans;
+  size_t size = items.size();
+  uint32 regNum = nStacks;
+  for (size_t i = 1; i <= size; i++) {
+    PrimType pty = items[size - i];
+    ans.push_back(std::make_pair(regNum, pty));
+    if (pty == PTY_i64 || pty == PTY_f64) {
+      regNum += 2;  // wide type uses 2 stack items
+    } else {
+      regNum += 1;  // normal type uses 1 stack items
+    }
+  }
+  std::reverse(ans.begin(), ans.end());
+  return ans;
+}
+
+std::string JBCStack2FEHelper::DumpStackInJavaFormat() const {
+  std::string ans;
+  for (const StackItem &item : stack) {
+    switch (item.second) {
+      case PTY_i32:
+        ans.push_back('I');
+        break;
+      case PTY_i64:
+        ans.push_back('J');
+        break;
+      case PTY_f32:
+        ans.push_back('F');
+        break;
+      case PTY_f64:
+        ans.push_back('D');
+        break;
+      case PTY_ref:
+        ans.push_back('R');
+        break;
+      default:
+        return std::string("unsupport type") + GetPrimTypeName(item.second);
+    }
+  }
+  return ans;
+}
+
+std::string JBCStack2FEHelper::DumpStackInInternalFormat() const {
+  std::string ans;
+  for (const StackItem &item : stack) {
+    if (IsItemNormal(item)) {
+      ans.push_back('N');
+    } else if (IsItemWide(item)) {
+      ans.push_back('W');
+    } else if (IsItemDummy(item)) {
+      ans.push_back('D');
+    } else {
+      return "unsupport item";
+    }
+  }
+  return ans;
+}
+
+bool JBCStack2FEHelper::Pop() {
+  size_t size = stack.size();
+  if (size < 1) {
+    ERR(kLncErr, "stack is not enough for pop operation");
+    return false;
+  }
+  StackItem &item = stack[size - 1];  // the 1st item from top
+  if (IsItemNormal(item)) {
+    stack.pop_back();
+    return true;
+  } else {
+    ERR(kLncErr, "invalid stack top item for pop operation");
+    return false;
+  }
+}
+
+bool JBCStack2FEHelper::Pop2() {
+  size_t size = stack.size();
+  if (size < 2) { // 2 : The minimum size of the stack
+    ERR(kLncErr, "stack is not enough for pop2 operation");
+    return false;
+  }
+  StackItem &item1 = stack[size - 1];  // the 1st item from top
+  StackItem &item2 = stack[size - 2];  // the 2nd item from top
+  if ((IsItemDummy(item1) && IsItemWide(item2)) || (IsItemNormal(item1) && IsItemNormal(item2))) {
+    stack.pop_back();
+    stack.pop_back();
+    return true;
+  } else {
+    ERR(kLncErr, "invalid stack top item for pop2 operation");
+    return false;
+  }
+}
+
+// notation for value used in Dup
+//   value(N): normal value (i32, f32)
+//   value(W): wide value   (i64, f64)
+//   value(D): dummy value of wide value
+bool JBCStack2FEHelper::Dup() {
+  size_t size = stack.size();
+  if (size < 1) {  // dup operation need at least 1 item in stack
+    ERR(kLncErr, "stack is not enough for dup operation");
+    return false;
+  }
+  StackItem &item = stack[size - 1];  // the 1st item from top
+  if (IsItemNormal(item)) {
+    // before: ..., value(N) ->
+    // after:  ..., value(N), value(N) ->
+    UniqueFEIRVar var = item.first->Clone();
+    PrimType pty = item.second;
+    stack.push_back(MakeStackItem(std::move(var), pty));
+    return true;
+  } else {
+    ERR(kLncErr, "invalid stack items for dup operation");
+    return false;
+  }
+}
+
+bool JBCStack2FEHelper::DupX1() {
+  size_t size = stack.size();
+  if (size < 2) {  // dup_x1 operation need at least 2 item in stack
+    ERR(kLncErr, "stack is not enough for dup_x1 operation");
+    return false;
+  }
+  StackItem &item1 = stack[size - 1];  // the 1st item from top
+  StackItem &item2 = stack[size - 2];  // the 2nd item from top
+  if (IsItemNormal(item1) && IsItemNormal(item2)) {
+    // before: ..., value2(N), value1(N) ->
+    // after:  ..., value1(N), value2(N), value1(N) ->
+    UniqueFEIRVar var1 = item1.first->Clone();
+    PrimType pty1 = item1.second;
+    std::vector<StackItem>::iterator it = stack.end() - 2;  // the 2nd item position from top
+    CHECK_FATAL(stack.insert(it, MakeStackItem(std::move(var1), pty1)) != stack.end(), "stack insert failed");
+    return true;
+  } else {
+    ERR(kLncErr, "invalid stack items for dup_x1 operation");
+    return false;
+  }
+}
+
+bool JBCStack2FEHelper::DupX2() {
+  size_t size = stack.size();
+  if (size < 3) {  // dup_x1 operation need at least 3 item in stack
+    ERR(kLncErr, "stack is not enough for dup_x2 operation");
+    return false;
+  }
+  StackItem &item1 = stack[size - 1];  // the 1st item from top
+  StackItem &item2 = stack[size - 2];  // the 2nd item from top
+  StackItem &item3 = stack[size - 3];  // the 3rd item from top
+  // situation 1
+  //   before: ..., value3(N), value2(N), value1(N) ->
+  //   after:  ..., value1(N), value3(N), value2(N), value1(N) ->
+  bool isSituation1 = (IsItemNormal(item1) && IsItemNormal(item2) && IsItemNormal(item3));
+  // situation 2
+  //   before: ..., value3(W), value2(D), value1(N) ->
+  //   after:  ..., value1(N), value3(W), value2(D), value1(N) ->
+  bool isSituation2 = (IsItemNormal(item1) && IsItemDummy(item2) && IsItemWide(item3));
+  if (!(isSituation1 || isSituation2)) {
+    ERR(kLncErr, "invalid stack items for dup_x2 operation");
+    return false;
+  }
+  //         situation1  situation2
+  // value1      N           N
+  UniqueFEIRVar var1 = item1.first->Clone();
+  PrimType pty1 = item1.second;
+  // insert copy of value1 before the 3rd item from top
+  std::vector<StackItem>::iterator it = stack.end() - 3;
+  CHECK_FATAL(stack.insert(it, MakeStackItem(std::move(var1), pty1)) != stack.end(), "stack insert failed");
+  return true;
+}
+
+bool JBCStack2FEHelper::Dup2() {
+  size_t size = stack.size();
+  if (size < 2) {  // dup2 operation need at least 2 item in stack
+    ERR(kLncErr, "stack is not enough for dup2 operation");
+    return false;
+  }
+  StackItem &item1 = stack[size - 1];  // the 1st item from top
+  StackItem &item2 = stack[size - 2];  // the 2nd item from top
+  // situation 1
+  //   before: ..., value2(N), value1(N) ->
+  //   after:  ..., value2(N), value1(N), value2(N), value1(N) ->
+  bool isSituation1 = (IsItemNormal(item1) && IsItemNormal(item2));
+  // situation 2
+  //   before: ..., value2(W), value1(D) ->
+  //   after:  ..., value2(W), value1(D), value2(W), value1(D) ->
+  bool isSituation2 = (IsItemDummy(item1) && IsItemWide(item2));
+  if (!(isSituation1 || isSituation2)) {
+    ERR(kLncErr, "invalid stack items for dup2 operation");
+    return false;
+  }
+  //         situation1  situation2
+  // value1      N           D
+  // value2      N           W
+  UniqueFEIRVar var1;
+  UniqueFEIRVar var2;
+  PrimType pty1 = item1.second;
+  PrimType pty2 = item2.second;
+  if (isSituation1) {
+    var1 = item1.first->Clone();
+    var2 = item2.first->Clone();
+  } else {
+    var1 = UniqueFEIRVar(nullptr);
+    var2 = item2.first->Clone();
+  }
+  // insert copy of value2 before the 2nd item from top
+  std::vector<StackItem>::iterator it = stack.end() - 2;
+  CHECK_FATAL(stack.insert(it, MakeStackItem(std::move(var2), pty2)) != stack.end(), "stack insert failed");
+  // insert copy of value1 before the 2nd item from top
+  it = stack.end() - 2;
+  CHECK_FATAL(stack.insert(it, MakeStackItem(std::move(var1), pty1)) != stack.end(), "stack insert failed");
+  return true;
+}
+
+bool JBCStack2FEHelper::Dup2X1() {
+  size_t size = stack.size();
+  if (size < 3) {  // dup2_x1 operation need at least 3 item in stack
+    ERR(kLncErr, "stack is not enough for dup2_x1 operation");
+    return false;
+  }
+  StackItem &item1 = stack[size - 1];  // the 1st item from top
+  StackItem &item2 = stack[size - 2];  // the 2nd item from top
+  StackItem &item3 = stack[size - 3];  // the 3rd item from top
+  // situation 1
+  //   before: ..., value3(N), value2(N), value1(N) ->
+  //   after:  ..., value2(N), value1(N), value3(N), value2(N), value1(N) ->
+  bool isSituation1 = (IsItemNormal(item1) && IsItemNormal(item2) && IsItemNormal(item3));
+  // situation 2
+  //   before: ..., value3(N), value2(W), value1(D) ->
+  //   after:  ..., value2(W), value1(D), value3(N), value2(W), value1(D) ->
+  bool isSituation2 = (IsItemDummy(item1) && IsItemWide(item2) && IsItemNormal(item3));
+  if (!(isSituation1 || isSituation2)) {
+    ERR(kLncErr, "invalid stack items for dup2_x1 operation");
+    return false;
+  }
+  //         situation1  situation2
+  // value1      N           D
+  // value2      N           W
+  UniqueFEIRVar var1;
+  UniqueFEIRVar var2;
+  PrimType pty1 = item1.second;
+  PrimType pty2 = item2.second;
+  if (isSituation1) {
+    var1 = item1.first->Clone();
+    var2 = item2.first->Clone();
+  } else {
+    var1 = UniqueFEIRVar(nullptr);
+    var2 = item2.first->Clone();
+  }
+  // insert copy of value2 before the 3rd item from top
+  std::vector<StackItem>::iterator it = stack.end() - 3;
+  CHECK_FATAL(stack.insert(it, MakeStackItem(std::move(var2), pty2)) != stack.end(), "stack insert failed");
+  // insert copy of value1 before the 3rd item from top
+  it = stack.end() - 3;
+  CHECK_FATAL(stack.insert(it, MakeStackItem(std::move(var1), pty1)) != stack.end(), "stack insert failed");
+  return true;
+}
+
+bool JBCStack2FEHelper::Dup2X2() {
+  size_t size = stack.size();
+  if (size < 4) {  // dup2_x2 operation need at least 4 item in stack
+    ERR(kLncErr, "stack is not enough for dup2_x2 operation");
+    return false;
+  }
+  StackItem &item1 = stack[size - 1];  // the 1st item from top
+  StackItem &item2 = stack[size - 2];  // the 2nd item from top
+  StackItem &item3 = stack[size - 3];  // the 3rd item from top
+  StackItem &item4 = stack[size - 4];  // the 4th item from top
+  // situation 1
+  //   before: ..., value4(N), value3(N), value2(N), value1(N) ->
+  //   after:  ..., value2(N), value1(N), value4(N), value3(N), value2(N), value1(N) ->
+  bool isSituation1 = (IsItemNormal(item1) && IsItemNormal(item2) && IsItemNormal(item3) && IsItemNormal(item4));
+  // situation 2
+  //   before: ..., value4(N), value3(N), value2(W), value1(D) ->
+  //   after:  ..., value2(W), value1(D), value4(N), value3(N), value2(W), value1(D) ->
+  bool isSituation2 = (IsItemDummy(item1) && IsItemWide(item2) && IsItemNormal(item3) && IsItemNormal(item4));
+  // situation 3
+  //   before: ..., value4(W), value3(D), value2(N), value1(N) ->
+  //   after:  ..., value2(N), value1(N), value4(W), value3(D), value2(W), value1(D) ->
+  bool isSituation3 = (IsItemNormal(item1) && IsItemNormal(item2) && IsItemDummy(item3) && IsItemWide(item4));
+  // situation 4
+  //   before: ..., value4(W), value3(D), value2(W), value1(D) ->
+  //   after:  ..., value2(W), value1(D), value4(W), value3(D), value2(W), value1(D) ->
+  bool isSituation4 = (IsItemDummy(item1) && IsItemWide(item2) && IsItemDummy(item3) && IsItemWide(item4));
+  if (!(isSituation1 || isSituation2 || isSituation3 || isSituation4)) {
+    ERR(kLncErr, "invalid stack items for dup2_x1 operation");
+    return false;
+  }
+  //         situation1  situation2  situation3  situation4
+  // value1      N           D           N           D
+  // value2      N           W           N           W
+  UniqueFEIRVar var1;
+  UniqueFEIRVar var2;
+  PrimType pty1 = item1.second;
+  PrimType pty2 = item2.second;
+  if (isSituation1 || isSituation3) {
+    var1 = item1.first->Clone();
+    var2 = item2.first->Clone();
+  } else {
+    var1 = UniqueFEIRVar(nullptr);
+    var2 = item2.first->Clone();
+  }
+  // insert copy of value2 before the 4th item from top
+  std::vector<StackItem>::iterator it = stack.end() - 4;
+  CHECK_FATAL(stack.insert(it, MakeStackItem(std::move(var2), pty2)) != stack.end(), "stack insert failed");
+  // insert copy of value1 before the 4th item from top
+  it = stack.end() - 4;
+  CHECK_FATAL(stack.insert(it, MakeStackItem(std::move(var1), pty1)) != stack.end(), "stack insert failed");
+  return true;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_stack_helper.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_stack_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..326b089027d22a68cc2a6a22af24aa15e9527853
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_stack_helper.cpp
@@ -0,0 +1,426 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_stack_helper.h"
+
+namespace maple {
+namespace {
+const uint32 kSize1 = 1;
+const uint32 kSize2 = 2;
+const uint32 kSize3 = 3;
+const uint32 kSize4 = 4;
+}  // namespace
+
+void JBCStackHelper::Reset() {
+  stack.clear();
+}
+
+bool JBCStackHelper::StackChange(const jbc::JBCOp &op, const jbc::JBCConstPool &constPool) {
+  switch (op.GetOpcodeKind()) {
+    case jbc::kOpKindConst: {
+      jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack(constPool);
+      if (stackOutType != jbc::JBCPrimType::kTypeDefault) {
+        PushItem(stackOutType);
+      } else {
+        return false;
+      }
+      return true;
+    }
+    case jbc::kOpKindPop:
+      return Pop(op.GetOpcode());
+    case jbc::kOpKindDup:
+      return Dup(op.GetOpcode());
+    case jbc::kOpKindSwap:
+      return Swap();
+    case jbc::kOpKindFieldOpr:
+    case jbc::kOpKindStaticFieldOpr:
+    case jbc::kOpKindInvoke:
+    case jbc::kOpKindMultiANewArray: {
+      std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack(constPool);
+      jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack(constPool);
+      bool success = PopItems(stackInTypes);
+      if (success && stackOutType != jbc::JBCPrimType::kTypeDefault) {
+        PushItem(stackOutType);
+      }
+      return success;
+    }
+    default: {
+      const std::vector<jbc::JBCPrimType> &stackInTypes = op.GetInputTypesFromStack();
+      jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack();
+      bool success = PopItems(stackInTypes);
+      if (success && stackOutType != jbc::JBCPrimType::kTypeDefault) {
+        PushItem(stackOutType);
+      }
+      return success;
+    }
+  }
+}
+
+void JBCStackHelper::PushItem(jbc::JBCPrimType type) {
+  stack.push_back(GetGeneralType(type));
+  if (type == jbc::JBCPrimType::kTypeLong) {
+    stack.push_back(jbc::JBCPrimType::kTypeLongDummy);
+  } else if (type == jbc::JBCPrimType::kTypeDouble) {
+    stack.push_back(jbc::JBCPrimType::kTypeDoubleDummy);
+  } else {
+    // nothing to be done
+  }
+}
+
+void JBCStackHelper::PushItems(const std::vector<jbc::JBCPrimType> &types) {
+  for (jbc::JBCPrimType type : types) {
+    PushItem(type);
+  }
+}
+
+bool JBCStackHelper::PopItem(jbc::JBCPrimType type) {
+  if (stack.size() == 0) {
+    return false;
+  }
+  type = GetGeneralType(type);
+  switch (type) {
+    case jbc::JBCPrimType::kTypeInt:
+    case jbc::JBCPrimType::kTypeFloat:
+    case jbc::JBCPrimType::kTypeRef:
+    case jbc::JBCPrimType::kTypeAddress:
+      if (stack.size() >= kSize1 && stack.back() == type) {
+        stack.pop_back();
+        return true;
+      }
+      break;
+    case jbc::JBCPrimType::kTypeLong:
+      if (stack.size() >= kSize2 && stack.back() == jbc::JBCPrimType::kTypeLongDummy) {
+        stack.pop_back();
+        stack.pop_back();
+        return true;
+      }
+      break;
+    case jbc::JBCPrimType::kTypeDouble:
+      if (stack.size() >= kSize2 && stack.back() == jbc::JBCPrimType::kTypeDoubleDummy) {
+        stack.pop_back();
+        stack.pop_back();
+        return true;
+      }
+      break;
+    case jbc::JBCPrimType::kTypeDefault:
+      return true;
+    default:
+      CHECK_FATAL(false, "Should not run here: invalid type");
+      break;
+  }
+  return false;
+}
+
+bool JBCStackHelper::PopItems(const std::vector<jbc::JBCPrimType> &types) {
+  size_t idx = types.size() - 1;
+  for (size_t i = 0; i < types.size(); i++, idx--) {
+    if (PopItem(types[idx]) == false) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool JBCStackHelper::Pop(jbc::JBCOpcode opcode) {
+  switch (opcode) {
+    case jbc::kOpPop:
+      if (stack.size() >= kSize1 && IsType1(stack.back())) {
+        stack.pop_back();
+        return true;
+      }
+      break;
+    case jbc::kOpPop2:
+      if (stack.size() >= kSize2 && IsType2Dummy(stack.back())) {
+        stack.pop_back();
+        stack.pop_back();
+        return true;
+      }
+      break;
+    default:
+      CHECK_FATAL(false, "Unsupported opcode: %s", jbc::JBCOp::GetOpcodeInfo().GetOpcodeName(opcode).c_str());
+      break;
+  }
+  return false;
+}
+
+bool JBCStackHelper::Dup(jbc::JBCOpcode opcode) {
+  switch (opcode) {
+    case jbc::kOpDup:
+      return Dup();
+    case jbc::kOpDupX1:
+      return DupX1();
+    case jbc::kOpDupX2:
+      return DupX2();
+    case jbc::kOpDup2:
+      return Dup2();
+    case jbc::kOpDup2X1:
+      return Dup2X1();
+    case jbc::kOpDup2X2:
+      return Dup2X2();
+    default:
+      CHECK_FATAL(false, "Unsupported opcode: %s", jbc::JBCOp::GetOpcodeInfo().GetOpcodeName(opcode).c_str());
+      break;
+  }
+  return false;
+}
+
+bool JBCStackHelper::Dup() {
+  if (stack.size() < kSize1) {
+    return false;
+  }
+  jbc::JBCPrimType t = stack.back();
+  if (IsType1(t)) {
+    stack.push_back(t);
+    return true;
+  }
+  return false;
+}
+
+bool JBCStackHelper::DupX1() {
+  if (stack.size() < kSize2) {
+    return false;
+  }
+  jbc::JBCPrimType t1 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t2 = stack.back();
+  stack.pop_back();
+  bool success = (IsType1(t1) && IsType1(t2));
+  if (success) {
+    stack.push_back(t1);
+  }
+  stack.push_back(t2);
+  stack.push_back(t1);
+  return success;
+}
+
+bool JBCStackHelper::DupX2() {
+  if (stack.size() < kSize3) {
+    return false;
+  }
+  jbc::JBCPrimType t1 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t2 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t3 = stack.back();
+  stack.pop_back();
+  bool success = IsType1(t1);
+  if (success) {
+    stack.push_back(t1);
+  }
+  stack.push_back(t3);
+  stack.push_back(t2);
+  stack.push_back(t1);
+  return success;
+}
+
+bool JBCStackHelper::Dup2() {
+  if (stack.size() < kSize2) {
+    return false;
+  }
+  jbc::JBCPrimType t1 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t2 = stack.back();
+  stack.pop_back();
+  bool success = ((IsType1(t1) && IsType1(t2)) || (IsType2Dummy(t1) && IsType2(t2)));
+  if (success) {
+    stack.push_back(t2);
+    stack.push_back(t1);
+  }
+  stack.push_back(t2);
+  stack.push_back(t1);
+  return success;
+}
+
+bool JBCStackHelper::Dup2X1() {
+  if (stack.size() < kSize3) {
+    return false;
+  }
+  jbc::JBCPrimType t1 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t2 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t3 = stack.back();
+  stack.pop_back();
+  bool success = IsType1(t3);
+  if (success) {
+    stack.push_back(t2);
+    stack.push_back(t1);
+  }
+  stack.push_back(t3);
+  stack.push_back(t2);
+  stack.push_back(t1);
+  return success;
+}
+
+bool JBCStackHelper::Dup2X2() {
+  if (stack.size() < kSize4) {
+    return false;
+  }
+  jbc::JBCPrimType t1 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t2 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t3 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t4 = stack.back();
+  stack.pop_back();
+  stack.push_back(t2);
+  stack.push_back(t1);
+  stack.push_back(t4);
+  stack.push_back(t3);
+  stack.push_back(t2);
+  stack.push_back(t1);
+  return true;
+}
+
+bool JBCStackHelper::Swap() {
+  if (stack.size() < kSize2) {
+    return false;
+  }
+  jbc::JBCPrimType t1 = stack.back();
+  stack.pop_back();
+  jbc::JBCPrimType t2 = stack.back();
+  stack.pop_back();
+  if (IsType1(t1) && IsType1(t2)) {
+    stack.push_back(t1);
+    stack.push_back(t2);
+    return true;
+  } else {
+    stack.push_back(t2);
+    stack.push_back(t1);
+    return false;
+  }
+}
+
+bool JBCStackHelper::IsType1(jbc::JBCPrimType type) const {
+  if (type == jbc::JBCPrimType::kTypeInt || type == jbc::JBCPrimType::kTypeFloat ||
+      type == jbc::JBCPrimType::kTypeByteOrBoolean || type == jbc::JBCPrimType::kTypeChar ||
+      type == jbc::JBCPrimType::kTypeShort || type == jbc::JBCPrimType::kTypeRef ||
+      type == jbc::JBCPrimType::kTypeAddress) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool JBCStackHelper::IsType2(jbc::JBCPrimType type) const {
+  if (type == jbc::JBCPrimType::kTypeLong || type == jbc::JBCPrimType::kTypeDouble) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool JBCStackHelper::IsType2Dummy(jbc::JBCPrimType type) const {
+  if (type == jbc::JBCPrimType::kTypeLongDummy || type == jbc::JBCPrimType::kTypeDoubleDummy) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+jbc::JBCPrimType JBCStackHelper::GetGeneralType(jbc::JBCPrimType type) const {
+  if (type == jbc::JBCPrimType::kTypeByteOrBoolean || type == jbc::JBCPrimType::kTypeChar ||
+      type == jbc::JBCPrimType::kTypeShort) {
+    return jbc::JBCPrimType::kTypeInt;
+  } else {
+    return type;
+  }
+}
+
+void JBCStackHelper::CopyFrom(const JBCStackHelper &src) {
+  for (jbc::JBCPrimType item : src.stack) {
+    stack.push_back(item);
+  }
+}
+
+bool JBCStackHelper::EqualTo(const JBCStackHelper &src) {
+  if (stack.size() != src.stack.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < stack.size(); i++) {
+    if (stack[i] != src.stack[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool JBCStackHelper::Contains(const JBCStackHelper &src) {
+  // this contains src (this >= src)
+  if (EqualTo(src)) {
+    return true;
+  }
+  size_t size = stack.size();
+  size_t sizeSrc = src.stack.size();
+  if (size < sizeSrc) {
+    return false;
+  }
+  for (size_t i = 1; i <= sizeSrc; i++) {
+    if (stack[size - i] != src.stack[sizeSrc - 1]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void JBCStackHelper::Dump() const {
+  std::cout << "{";
+  for (jbc::JBCPrimType item : stack) {
+    std::cout << GetTypeName(item) << " ";
+  }
+  std::cout << "}";
+}
+
+std::string JBCStackHelper::GetTypeName(jbc::JBCPrimType type) {
+  switch (type) {
+    case jbc::JBCPrimType::kTypeDefault:
+      return "default";
+    case jbc::JBCPrimType::kTypeInt:
+      return "int";
+    case jbc::JBCPrimType::kTypeLong:
+      return "long";
+    case jbc::JBCPrimType::kTypeFloat:
+      return "float";
+    case jbc::JBCPrimType::kTypeDouble:
+      return "double";
+    case jbc::JBCPrimType::kTypeByteOrBoolean:
+      return "byte/boolean";
+    case jbc::JBCPrimType::kTypeChar:
+      return "char";
+    case jbc::JBCPrimType::kTypeShort:
+      return "short";
+    case jbc::JBCPrimType::kTypeRef:
+      return "ref";
+    case jbc::JBCPrimType::kTypeAddress:
+      return "address";
+    case jbc::JBCPrimType::kTypeLongDummy:
+      return "long-dummy";
+    case jbc::JBCPrimType::kTypeDoubleDummy:
+      return "double-dummy";
+    default:
+      return "unknown";
+  }
+}
+
+std::vector<jbc::JBCPrimType> JBCStackHelper::GetStackItems() const {
+  std::vector<jbc::JBCPrimType> ans;
+  for (jbc::JBCPrimType item : stack) {
+    if (item != jbc::JBCPrimType::kTypeLongDummy && item != jbc::JBCPrimType::kTypeDoubleDummy) {
+      ans.push_back(item);
+    }
+  }
+  return ans;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_stmt.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_stmt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..708395d4a5620ec2dc3be0a642ad5119b1276252
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_stmt.cpp
@@ -0,0 +1,1559 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_stmt.h"
+#include <string>
+#include <iostream>
+#include <algorithm>
+#include "opcodes.h"
+#include "feir_stmt.h"
+#include "feir_builder.h"
+#include "fe_struct_elem_info.h"
+#include "jbc_function_context.h"
+
+namespace maple {
+// ---------- JBCStmtKindHelper ----------
+std::string JBCStmtKindHelper::JBCStmtKindName(JBCStmtKind kind) {
+  switch (kind) {
+    case kJBCStmtDefault:
+      return "JBCStmtDefault";
+    case kJBCStmtFuncBeing:
+      return "JBCStmtFuncBegin";
+    case kJBCStmtFuncEnd:
+      return "JBCStmtFuncEnd";
+    case kJBCStmtInst:
+      return "JBCStmtInst";
+    case kJBCStmtInstBranch:
+      return "JBCStmtInstBranch";
+    case kJBCStmtPesudoComment:
+      return "JBCStmtPesudoComment";
+    case kJBCStmtPesudoLabel:
+      return "JBCStmtPesudoLabel";
+    case kJBCStmtPesudoLOC:
+      return "JBCStmtPesudoLOC";
+    case kJBCStmtPesudoTry:
+      return "JBCStmtPesudoTry";
+    case kJBCStmtPesudoEndTry:
+      return "JBCStmtPesudoEndTry";
+    case kJBCStmtPesudoCatch:
+      return "JBCStmtPesudoCatch";
+    default:
+      return "unknown";
+  }
+}
+
+// ---------- JBCStmtInst ----------
+std::map<jbc::JBCOpcodeKind, JBCStmtInst::FuncPtrEmitToFEIR> JBCStmtInst::funcPtrMapForEmitToFEIR =
+    JBCStmtInst::InitFuncPtrMapForEmitToFEIR();
+std::map<jbc::JBCOpcode, Opcode> JBCStmtInst::opcodeMapForMathBinop = JBCStmtInst::InitOpcodeMapForMathBinop();
+std::map<jbc::JBCOpcode, Opcode> JBCStmtInst::opcodeMapForMathUnop = JBCStmtInst::InitOpcodeMapForMathUnop();
+std::map<jbc::JBCOpcode, Opcode> JBCStmtInst::opcodeMapForMonitor = JBCStmtInst::InitOpcodeMapForMonitor();
+
+JBCStmtInst::JBCStmtInst(const jbc::JBCOp &argOp)
+    : JBCStmt(kJBCStmtInst),
+      op(argOp) {
+  SetFallThru(op.IsFallThru());
+}
+
+bool JBCStmtInst::IsStmtInstImpl() const {
+  return true;
+}
+
+void JBCStmtInst::DumpImpl(const std::string &prefix) const {
+  std::cout << prefix << "JBCStmtInst (id=" << id << ", " <<
+               "kind=" << JBCStmtKindHelper::JBCStmtKindName(JBCkind) << ", " <<
+               "op=" << op.GetOpcodeName() <<
+               ")" << std::endl;
+}
+
+std::string JBCStmtInst::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << op.GetOpcodeName();
+  return ss.str();
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const {
+  auto it = funcPtrMapForEmitToFEIR.find(op.GetOpcodeKind());
+  if (it != funcPtrMapForEmitToFEIR.end()) {
+    return (this->*(it->second))(context, success);
+  } else {
+    return EmitToFEIRCommon(context, success);
+  }
+}
+
+std::map<jbc::JBCOpcodeKind, JBCStmtInst::FuncPtrEmitToFEIR> JBCStmtInst::InitFuncPtrMapForEmitToFEIR() {
+  std::map<jbc::JBCOpcodeKind, FuncPtrEmitToFEIR> ans;
+  ans[jbc::JBCOpcodeKind::kOpKindConst] = &JBCStmtInst::EmitToFEIRForOpConst;
+  ans[jbc::JBCOpcodeKind::kOpKindLoad] = &JBCStmtInst::EmitToFEIRForOpLoad;
+  ans[jbc::JBCOpcodeKind::kOpKindStore] = &JBCStmtInst::EmitToFEIRForOpStore;
+  ans[jbc::JBCOpcodeKind::kOpKindArrayLoad] = &JBCStmtInst::EmitToFEIRForOpArrayLoad;
+  ans[jbc::JBCOpcodeKind::kOpKindArrayStore] = &JBCStmtInst::EmitToFEIRForOpArrayStore;
+  ans[jbc::JBCOpcodeKind::kOpKindPop] = &JBCStmtInst::EmitToFEIRForOpPop;
+  ans[jbc::JBCOpcodeKind::kOpKindDup] = &JBCStmtInst::EmitToFEIRForOpDup;
+  ans[jbc::JBCOpcodeKind::kOpKindSwap] = &JBCStmtInst::EmitToFEIRForOpSwap;
+  ans[jbc::JBCOpcodeKind::kOpKindMathBinop] = &JBCStmtInst::EmitToFEIRForOpMathBinop;
+  ans[jbc::JBCOpcodeKind::kOpKindMathUnop] = &JBCStmtInst::EmitToFEIRForOpMathUnop;
+  ans[jbc::JBCOpcodeKind::kOpKindMathInc] = &JBCStmtInst::EmitToFEIRForOpMathInc;
+  ans[jbc::JBCOpcodeKind::kOpKindConvert] = &JBCStmtInst::EmitToFEIRForOpConvert;
+  ans[jbc::JBCOpcodeKind::kOpKindCompare] = &JBCStmtInst::EmitToFEIRForOpMathBinop;
+  ans[jbc::JBCOpcodeKind::kOpKindReturn] = &JBCStmtInst::EmitToFEIRForOpReturn;
+  ans[jbc::JBCOpcodeKind::kOpKindStaticFieldOpr] = &JBCStmtInst::EmitToFEIRForOpStaticFieldOpr;
+  ans[jbc::JBCOpcodeKind::kOpKindFieldOpr] = &JBCStmtInst::EmitToFEIRForOpFieldOpr;
+  ans[jbc::JBCOpcodeKind::kOpKindInvoke] = &JBCStmtInst::EmitToFEIRForOpInvoke;
+  ans[jbc::JBCOpcodeKind::kOpKindNew] = &JBCStmtInst::EmitToFEIRForOpNew;
+  ans[jbc::JBCOpcodeKind::kOpKindMultiANewArray] = &JBCStmtInst::EmitToFEIRForOpMultiANewArray;
+  ans[jbc::JBCOpcodeKind::kOpKindThrow] = &JBCStmtInst::EmitToFEIRForOpThrow;
+  ans[jbc::JBCOpcodeKind::kOpKindTypeCheck] = &JBCStmtInst::EmitToFEIRForOpTypeCheck;
+  ans[jbc::JBCOpcodeKind::kOpKindMonitor] = &JBCStmtInst::EmitToFEIRForOpMonitor;
+  ans[jbc::JBCOpcodeKind::kOpKindArrayLength] = &JBCStmtInst::EmitToFEIRForOpArrayLength;
+  return ans;
+}
+
+std::map<jbc::JBCOpcode, Opcode> JBCStmtInst::InitOpcodeMapForMathBinop() {
+  std::map<jbc::JBCOpcode, Opcode> ans;
+  ans[jbc::kOpIAdd] = OP_add;
+  ans[jbc::kOpLAdd] = OP_add;
+  ans[jbc::kOpFAdd] = OP_add;
+  ans[jbc::kOpDAdd] = OP_add;
+  ans[jbc::kOpISub] = OP_sub;
+  ans[jbc::kOpLSub] = OP_sub;
+  ans[jbc::kOpFSub] = OP_sub;
+  ans[jbc::kOpDSub] = OP_sub;
+  ans[jbc::kOpIMul] = OP_mul;
+  ans[jbc::kOpLMul] = OP_mul;
+  ans[jbc::kOpFMul] = OP_mul;
+  ans[jbc::kOpDMul] = OP_mul;
+  ans[jbc::kOpIDiv] = OP_div;
+  ans[jbc::kOpLDiv] = OP_div;
+  ans[jbc::kOpFDiv] = OP_div;
+  ans[jbc::kOpDDiv] = OP_div;
+  ans[jbc::kOpIRem] = OP_rem;
+  ans[jbc::kOpLRem] = OP_rem;
+  ans[jbc::kOpFRem] = OP_rem;
+  ans[jbc::kOpDRem] = OP_rem;
+  ans[jbc::kOpIShl] = OP_shl;
+  ans[jbc::kOpLShl] = OP_shl;
+  ans[jbc::kOpIShr] = OP_ashr;
+  ans[jbc::kOpLShr] = OP_ashr;
+  ans[jbc::kOpIUShr] = OP_lshr;
+  ans[jbc::kOpLUShr] = OP_lshr;
+  ans[jbc::kOpIAnd] = OP_band;
+  ans[jbc::kOpLAnd] = OP_band;
+  ans[jbc::kOpIOr] = OP_bior;
+  ans[jbc::kOpLOr] = OP_bior;
+  ans[jbc::kOpIXor] = OP_bxor;
+  ans[jbc::kOpLXor] = OP_bxor;
+  ans[jbc::kOpLCmp] = OP_cmp;
+  ans[jbc::kOpFCmpl] = OP_cmpl;
+  ans[jbc::kOpFCmpg] = OP_cmpg;
+  ans[jbc::kOpDCmpl] = OP_cmpl;
+  ans[jbc::kOpDCmpg] = OP_cmpg;
+  return ans;
+}
+
+std::map<jbc::JBCOpcode, Opcode> JBCStmtInst::InitOpcodeMapForMathUnop() {
+  std::map<jbc::JBCOpcode, Opcode> ans;
+  ans[jbc::kOpINeg] = OP_neg;
+  ans[jbc::kOpLNeg] = OP_neg;
+  ans[jbc::kOpFNeg] = OP_neg;
+  ans[jbc::kOpDNeg] = OP_neg;
+  return ans;
+}
+
+std::map<jbc::JBCOpcode, Opcode> JBCStmtInst::InitOpcodeMapForMonitor() {
+  std::map<jbc::JBCOpcode, Opcode> ans;
+  ans[jbc::kOpMonitorEnter] = OP_syncenter;
+  ans[jbc::kOpMonitorExit] = OP_syncexit;
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpConst(JBCFunctionContext &context, bool &success) const {
+  switch (op.GetOpcode()) {
+    case jbc::kOpAConstNull:
+      return EmitToFEIRForOpAConstNull(context, success);
+    case jbc::kOpIConstM1:
+    case jbc::kOpIConst0:
+    case jbc::kOpIConst1:
+    case jbc::kOpIConst2:
+    case jbc::kOpIConst3:
+    case jbc::kOpIConst4:
+    case jbc::kOpIConst5:
+      return EmitToFEIRForOpIConst(context, success);
+    case jbc::kOpLConst0:
+    case jbc::kOpLConst1:
+      return EmitToFEIRForOpLConst(context, success);
+    case jbc::kOpFConst0:
+    case jbc::kOpFConst1:
+    case jbc::kOpFConst2:
+      return EmitToFEIRForOpFConst(context, success);
+    case jbc::kOpDConst0:
+    case jbc::kOpDConst1:
+      return EmitToFEIRForOpDConst(context, success);
+    case jbc::kOpBiPush:
+      return EmitToFEIRForOpBiPush(context, success);
+    case jbc::kOpSiPush:
+      return EmitToFEIRForOpSiPush(context, success);
+    case jbc::kOpLdc:
+    case jbc::kOpLdcW:
+    case jbc::kOpLdc2W:
+      return EmitToFEIRForOpLdc(context, success);
+    default:
+      ERR(kLncErr, "EmitToFEIRForOpConst: unsupport jbc opcode %s",
+          jbc::JBCOp::GetOpcodeInfo().GetOpcodeName(op.GetOpcode()).c_str());
+      success = false;
+      return std::list<UniqueFEIRStmt>();
+  }
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpConstCommon(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack(constPool);
+  if (stackOutType != jbc::JBCPrimType::kTypeDefault) {
+    PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+    UniqueFEIRVar var = stack2feHelper.PushItem(pty);
+    if (var == nullptr) {
+      success = false;
+    }
+  } else {
+    success = false;
+  }
+  if (!success) {
+    ERR(kLncErr, "Error when EmitToFEIRForOpConst");
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpAConstNull(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  UniqueFEIRExpr exprConst = FEIRBuilder::CreateExprConstRefNull();
+  UniqueFEIRVar varDst = stack2feHelper.PushItem(PTY_ref);
+  if (varDst == nullptr) {
+    success = false;
+    return ans;
+  }
+  UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(exprConst));
+  ans.push_back(std::move(stmtDAssign));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpIConst(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpConst &opConst = static_cast<const jbc::JBCOpConst&>(op);
+  int32 val = opConst.GetValueInt();
+  UniqueFEIRStmt stmtDAssign = GenerateStmtForConstI32(stack2feHelper, val, success);
+  if (success) {
+    ans.push_back(std::move(stmtDAssign));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpLConst(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpConst &opConst = static_cast<const jbc::JBCOpConst&>(op);
+  int64 val = opConst.GetValueLong();
+  UniqueFEIRStmt stmtDAssign = GenerateStmtForConstI64(stack2feHelper, val, success);
+  if (success) {
+    ans.push_back(std::move(stmtDAssign));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpFConst(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpConst &opConst = static_cast<const jbc::JBCOpConst&>(op);
+  float val = opConst.GetValueFloat();
+  UniqueFEIRStmt stmtDAssign = GenerateStmtForConstF32(stack2feHelper, val, success);
+  if (success) {
+    ans.push_back(std::move(stmtDAssign));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpDConst(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpConst &opConst = static_cast<const jbc::JBCOpConst&>(op);
+  double val = opConst.GetValueDouble();
+  UniqueFEIRStmt stmtDAssign = GenerateStmtForConstF64(stack2feHelper, val, success);
+  if (success) {
+    ans.push_back(std::move(stmtDAssign));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpBiPush(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpConst &opConst = static_cast<const jbc::JBCOpConst&>(op);
+  int8 val = opConst.GetValueByte();
+  UniqueFEIRStmt stmtDAssign = GenerateStmtForConstI32(stack2feHelper, int32{ val }, success);
+  if (success) {
+    ans.push_back(std::move(stmtDAssign));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpSiPush(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpConst &opConst = static_cast<const jbc::JBCOpConst&>(op);
+  int16 val = opConst.GetValueShort();
+  UniqueFEIRStmt stmtDAssign = GenerateStmtForConstI32(stack2feHelper, int32{ val }, success);
+  if (success) {
+    ans.push_back(std::move(stmtDAssign));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpLdc(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpConst &opConst = static_cast<const jbc::JBCOpConst&>(op);
+  const jbc::JBCConst *constRaw = constPool.GetConstByIdx(opConst.GetIndex());
+  if (constRaw == nullptr) {
+    success = false;
+    return ans;
+  }
+  UniqueFEIRStmt stmtDAssign;
+  switch (constRaw->GetTag()) {
+    case jbc::kConstInteger: {
+      const jbc::JBCConst4Byte *const4B = static_cast<const jbc::JBCConst4Byte*>(constRaw);
+      stmtDAssign = GenerateStmtForConstI32(stack2feHelper, const4B->GetInt32(), success);
+      break;
+    }
+    case jbc::kConstFloat: {
+      const jbc::JBCConst4Byte *const4B = static_cast<const jbc::JBCConst4Byte*>(constRaw);
+      stmtDAssign = GenerateStmtForConstF32(stack2feHelper, const4B->GetFloat(), success);
+      break;
+    }
+    case jbc::kConstLong: {
+      const jbc::JBCConst8Byte *const8B = static_cast<const jbc::JBCConst8Byte*>(constRaw);
+      stmtDAssign = GenerateStmtForConstI64(stack2feHelper, const8B->GetInt64(), success);
+      break;
+    }
+    case jbc::kConstDouble: {
+      const jbc::JBCConst8Byte *const8B = static_cast<const jbc::JBCConst8Byte*>(constRaw);
+      stmtDAssign = GenerateStmtForConstF64(stack2feHelper, const8B->GetDouble(), success);
+      break;
+    }
+    case jbc::kConstString: {
+      const jbc::JBCConstString *constString = static_cast<const jbc::JBCConstString*>(constRaw);
+      UniqueFEIRVar varDst = stack2feHelper.PushItem(PTY_ref);
+      stmtDAssign = FEIRBuilder::CreateStmtJavaConstString(std::move(varDst), constString->GetString());
+      break;
+    }
+    case jbc::kConstClass: {
+      const jbc::JBCConstClass *constClass = static_cast<const jbc::JBCConstClass*>(constRaw);
+      UniqueFEIRVar varDst = stack2feHelper.PushItem(PTY_ref);
+      stmtDAssign = FEIRBuilder::CreateStmtJavaConstClass(std::move(varDst), constClass->GetFEIRType()->Clone());
+      break;
+    }
+    default:
+      ERR(kLncErr, "EmitToFEIRForOpLdc: unsupported const kind");
+      success = false;
+  }
+  if (success && stmtDAssign != nullptr) {
+    ans.push_back(std::move(stmtDAssign));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpLoad(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpSlotOpr &opLoad = static_cast<const jbc::JBCOpSlotOpr&>(op);
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  CHECK_FATAL(stackInTypes.empty(), "no items should be popped");
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack();
+  PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+  uint32 regNum = stack2feHelper.GetRegNumForSlot(opLoad.GetSlotIdx());
+  const FEIRType *slotType = context.GetSlotType(opLoad.GetSlotIdx(), pc);
+  UniqueFEIRVar var;
+  UniqueFEIRVar varStack = stack2feHelper.PushItem(pty);
+  if (slotType != nullptr) {
+    var = FEIRBuilder::CreateVarReg(regNum, slotType->Clone());
+    varStack->SetType(slotType->Clone());
+  } else {
+    var = FEIRBuilder::CreateVarReg(regNum, pty);
+  }
+  success = success && (varStack != nullptr);
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(var));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(varStack), std::move(expr));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpStore(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpSlotOpr &opStore = static_cast<const jbc::JBCOpSlotOpr&>(op);
+  if (opStore.IsAddressOpr()) {
+    UniqueFEIRVar varTmp = stack2feHelper.PopItem(PTY_a32);
+    if (varTmp.get() == nullptr) {
+      success = false;
+    }
+    return ans;
+  }
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  CHECK_FATAL(stackInTypes.size() == 1, "store op need one stack opnd");
+  PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[0]);
+  uint32 regSlot = stack2feHelper.GetRegNumForSlot(opStore.GetSlotIdx());
+  const FEIRType *slotType = context.GetSlotType(opStore.GetSlotIdx(), pc);
+  UniqueFEIRVar varDst;
+  UniqueFEIRVar varSrc;
+  if (slotType != nullptr) {
+    varDst = FEIRBuilder::CreateVarReg(regSlot, slotType->Clone());
+    varSrc = stack2feHelper.PopItem(pty);
+    varSrc->SetType(slotType->Clone());
+  } else {
+    varDst = FEIRBuilder::CreateVarReg(regSlot, pty);
+    varSrc = stack2feHelper.PopItem(pty);
+  }
+  if (varSrc == nullptr) {
+    success = false;
+    return ans;
+  }
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(varSrc));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(expr));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpArrayLoad(JBCFunctionContext &context, bool &success) const {
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  // Process In
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  // ArrayLoad need 2 input opnds
+  CHECK_FATAL(stackInTypes.size() == 2, "invalid in types for ArrayLoad");
+  PrimType ptyArray = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[0]);  // opnd0: array
+  PrimType ptyIndex = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[1]);  // opnd1: index
+  UniqueFEIRVar varIndex = stack2feHelper.PopItem(ptyIndex);
+  UniqueFEIRVar varArray = stack2feHelper.PopItem(ptyArray);
+  // Process Out
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack();
+  CHECK_FATAL(stackOutType != jbc::JBCPrimType::kTypeDefault, "invalid out type for ArrayLoad");
+  PrimType ptyElem = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+  UniqueFEIRVar varElem = stack2feHelper.PushItem(ptyElem);
+  success = true;
+  return FEIRBuilder::CreateStmtArrayLoad(std::move(varElem), std::move(varArray), std::move(varIndex));
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpArrayStore(JBCFunctionContext &context, bool &success) const {
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  // Process In
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  // ArrayStore need 3 input opnds
+  CHECK_FATAL(stackInTypes.size() == 3, "invalid in types for ArrayStore");
+  PrimType ptyArray = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[0]);  // opnd0: array
+  PrimType ptyIndex = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[1]);  // opnd1: index
+  PrimType ptyElem = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[2]);  // opnd2: elem
+  UniqueFEIRVar varElem = stack2feHelper.PopItem(ptyElem);
+  UniqueFEIRVar varIndex = stack2feHelper.PopItem(ptyIndex);
+  UniqueFEIRVar varArray = stack2feHelper.PopItem(ptyArray);
+  success = true;
+  return FEIRBuilder::CreateStmtArrayStore(std::move(varElem), std::move(varArray), std::move(varIndex));
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpPop(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  success = stack2feHelper.Pop(op.GetOpcode());
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpDup(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  success = stack2feHelper.Dup(op.GetOpcode());
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpSwap(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  success = stack2feHelper.Swap();
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpMathBinop(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  // obtain in/out types
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  CHECK_FATAL(stackInTypes.size() == 2, "Not enough input opnds for math binary op"); // 2 : opnds num limit
+  PrimType pty0 = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[0]);
+  PrimType pty1 = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[1]);
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack();
+  PrimType ptyOut = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+  // stack operation
+  UniqueFEIRVar var1 = stack2feHelper.PopItem(pty1);
+  UniqueFEIRVar var0 = stack2feHelper.PopItem(pty0);
+  UniqueFEIRVar varOut = stack2feHelper.PushItem(ptyOut);
+  if (var1 == nullptr || var0 == nullptr || varOut == nullptr) {
+    success = false;
+    return ans;
+  }
+  auto it = opcodeMapForMathBinop.find(op.GetOpcode());
+  if (it == opcodeMapForMathBinop.end()) {
+    success = false;
+    ERR(kLncErr, "EmitToFEIRForOpMathBinop: unsupport opcode %s", op.GetOpcodeName().c_str());
+    return ans;
+  }
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprMathBinary(it->second, std::move(var0), std::move(var1));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(varOut), std::move(expr));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpMathUnop(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  // obtain in/out types
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  ASSERT(stackInTypes.size() == 1, "Not enough input opnds for math unary op");
+  PrimType pty0 = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[0]);
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack();
+  PrimType ptyOut = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+  // stack operation
+  UniqueFEIRVar var0 = stack2feHelper.PopItem(pty0);
+  UniqueFEIRVar varOut = stack2feHelper.PushItem(ptyOut);
+  if (var0 == nullptr || varOut == nullptr) {
+    success = false;
+    return ans;
+  }
+  auto it = opcodeMapForMathUnop.find(op.GetOpcode());
+  if (it == opcodeMapForMathUnop.end()) {
+    success = false;
+    ERR(kLncErr, "EmitToFEIRForOpMathUnop: unsupport opcode %s", op.GetOpcodeName().c_str());
+    return ans;
+  }
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprMathUnary(it->second, std::move(var0));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(varOut), std::move(expr));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpMathInc(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpMathInc &opInc = static_cast<const jbc::JBCOpMathInc&>(op);
+  // no stack operation
+  uint32 regNum = stack2feHelper.GetRegNumForSlot(opInc.GetIndex());
+  UniqueFEIRVar var0 = FEIRBuilder::CreateVarReg(regNum, PTY_i32);
+  UniqueFEIRVar varOut = var0->Clone();
+  UniqueFEIRExpr opnd0 = FEIRBuilder::CreateExprDRead(std::move(var0));
+  UniqueFEIRExpr opnd1 = FEIRBuilder::CreateExprConstI32(int32{ opInc.GetIncr() });
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprMathBinary(OP_add, std::move(opnd0), std::move(opnd1));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(varOut), std::move(expr));
+  ans.push_back(std::move(stmt));
+  success = true;
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpConvert(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  ASSERT(stackInTypes.size() == 1, "invalid in type for convert");
+  PrimType ptyIn = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[0]);
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack();
+  ASSERT(stackOutType != jbc::JBCPrimType::kTypeDefault, "invalid out type for convert");
+  PrimType ptyOut = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+  UniqueFEIRVar varIn = stack2feHelper.PopItem(ptyIn);
+  if (varIn == nullptr) {
+    success = false;
+    return ans;
+  }
+  UniqueFEIRVar varOut = stack2feHelper.PushItem(ptyOut);
+  if (varOut == nullptr) {
+    success = false;
+    return ans;
+  }
+  UniqueFEIRExpr expr(nullptr);
+  uint8 bitSize = 0;
+  Opcode opExt = OP_sext;
+  switch (op.GetOpcode()) {
+    case jbc::kOpI2B:
+      bitSize = 8;
+      opExt = OP_sext;
+      break;
+    case jbc::kOpI2C:
+      bitSize = 16;
+      opExt = OP_zext;
+      break;
+    case jbc::kOpI2S:
+      bitSize = 16;
+      opExt = OP_sext;
+      break;
+    default:
+      expr = FEIRBuilder::CreateExprCvtPrim(std::move(varIn), ptyOut);
+      break;
+  }
+  if (expr == nullptr) {
+    expr = (opExt == OP_sext) ? FEIRBuilder::CreateExprSExt(std::move(varIn)) :
+                                FEIRBuilder::CreateExprZExt(std::move(varIn));
+    FEIRExprExtractBits *ptrExprExt = static_cast<FEIRExprExtractBits*>(expr.get());
+    ptrExprExt->SetBitSize(bitSize);
+  }
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(varOut), std::move(expr));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpCompare(const JBCFunctionContext &context, bool &success) const {
+  (void) context;
+  std::list<UniqueFEIRStmt> ans;
+  success = true;
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpReturn(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  // obtain in/out types
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  if (op.GetOpcode() == jbc::kOpReturn) {
+    ASSERT(stackInTypes.empty(), "Not enough input opnds for return op");
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtReturn>(UniqueFEIRExpr(nullptr));
+    ans.push_back(std::move(stmt));
+  } else {
+    ASSERT(stackInTypes.size() == 1, "Not enough input opnds for return op");
+    PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[0]);
+    UniqueFEIRVar var = stack2feHelper.PopItem(pty);
+    if (var == nullptr) {
+      success = false;
+      return ans;
+    }
+    UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(var));
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtReturn>(std::move(expr));
+    ans.push_back(std::move(stmt));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpStaticFieldOpr(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpFieldOpr &opField = static_cast<const jbc::JBCOpFieldOpr&>(op);
+  const jbc::JBCConst *constRaw =
+      constPool.GetConstByIdxWithTag(opField.GetFieldIdx(), jbc::JBCConstTag::kConstFieldRef);
+  CHECK_NULL_FATAL(constRaw);
+  const jbc::JBCConstRef *constRef = static_cast<const jbc::JBCConstRef*>(constRaw);
+  FEStructFieldInfo *fieldInfo = static_cast<FEStructFieldInfo*>(constRef->GetFEStructElemInfo());
+  CHECK_NULL_FATAL(fieldInfo);
+  const FEIRType *fieldType = fieldInfo->GetType();
+  PrimType pty = fieldType->IsScalar() ? fieldType->GetPrimType() : PTY_ref;
+  pty = JBCStack2FEHelper::SimplifyPrimType(pty);
+  if (op.GetOpcode() == jbc::kOpGetStatic) {
+    UniqueFEIRVar var = stack2feHelper.PushItem(pty);
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtFieldLoad>(nullptr, std::move(var), *fieldInfo, true);
+    ans.push_back(std::move(stmt));
+  } else {
+    UniqueFEIRVar var = stack2feHelper.PopItem(pty);
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtFieldStore>(nullptr, std::move(var), *fieldInfo, true);
+    ans.push_back(std::move(stmt));
+  }
+  success = true;
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpFieldOpr(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpFieldOpr &opField = static_cast<const jbc::JBCOpFieldOpr&>(op);
+  const jbc::JBCConst *constRaw =
+      constPool.GetConstByIdxWithTag(opField.GetFieldIdx(), jbc::JBCConstTag::kConstFieldRef);
+  CHECK_NULL_FATAL(constRaw);
+  const jbc::JBCConstRef *constRef = static_cast<const jbc::JBCConstRef*>(constRaw);
+  FEStructFieldInfo *fieldInfo = static_cast<FEStructFieldInfo*>(constRef->GetFEStructElemInfo());
+  CHECK_NULL_FATAL(fieldInfo);
+  const FEIRType *fieldType = fieldInfo->GetType();
+  PrimType pty = fieldType->IsScalar() ? fieldType->GetPrimType() : PTY_ref;
+  pty = JBCStack2FEHelper::SimplifyPrimType(pty);
+  if (op.GetOpcode() == jbc::kOpGetField) {
+    UniqueFEIRVar varObj = stack2feHelper.PopItem(PTY_ref);
+    UniqueFEIRVar var = stack2feHelper.PushItem(pty);
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtFieldLoad>(std::move(varObj), std::move(var), *fieldInfo, false);
+    ans.push_back(std::move(stmt));
+  } else {
+    UniqueFEIRVar var = stack2feHelper.PopItem(pty);
+    UniqueFEIRVar varObj = stack2feHelper.PopItem(PTY_ref);
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtFieldStore>(std::move(varObj), std::move(var), *fieldInfo, false);
+    ans.push_back(std::move(stmt));
+  }
+  success = true;
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpInvoke(JBCFunctionContext &context, bool &success) const {
+  switch (op.GetOpcode()) {
+    case jbc::kOpInvokeVirtual:
+      return EmitToFEIRForOpInvokeVirtual(context, success);
+    case jbc::kOpInvokeSpecial:
+      return EmitToFEIRForOpInvokeSpecial(context, success);
+    case jbc::kOpInvokeStatic:
+      return EmitToFEIRForOpInvokeStatic(context, success);
+    case jbc::kOpInvokeInterface:
+      return EmitToFEIRForOpInvokeInterface(context, success);
+    case jbc::kOpInvokeDynamic:
+      return EmitToFEIRForOpInvokeDynamic(context, success);
+    default:
+      CHECK_FATAL(false, "unsupported op: %s", op.GetOpcodeName().c_str());
+      break;
+  }
+  return EmitToFEIRCommon2(context, success);
+}
+
+void JBCStmtInst::PrepareInvokeParametersAndReturn(JBCStack2FEHelper &stack2feHelper,
+                                                   const FEStructMethodInfo &info,
+                                                   FEIRStmtCallAssign &callStmt,
+                                                   bool isStatic) const {
+  const MapleVector<FEIRType*> &argTypes = info.GetArgTypes();
+  for (size_t i = argTypes.size(); i > 0; --i) {
+    const FEIRType *argType = argTypes[static_cast<uint32>(i - 1)];
+    PrimType pty = argType->GetPrimType();
+    UniqueFEIRVar var = stack2feHelper.PopItem(JBCStack2FEHelper::SimplifyPrimType(pty));
+    UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(var));
+    callStmt.AddExprArgReverse(std::move(expr));
+  }
+  if (!isStatic) {
+    // push this
+    const FEIRType *thisType = info.GetOwnerType();
+    PrimType pty = thisType->GetPrimType();
+    UniqueFEIRVar var = stack2feHelper.PopItem(JBCStack2FEHelper::SimplifyPrimType(pty));
+    UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(var));
+    callStmt.AddExprArgReverse(std::move(expr));
+  }
+  if (!info.IsReturnVoid()) {
+    const FEIRType *retType = info.GetReturnType();
+    PrimType pty = retType->GetPrimType();
+    UniqueFEIRVar var = stack2feHelper.PushItem(JBCStack2FEHelper::SimplifyPrimType(pty));
+    callStmt.SetVar(std::move(var));
+  }
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpInvokeVirtual(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpInvoke &opInvoke = static_cast<const jbc::JBCOpInvoke&>(op);
+  const jbc::JBCConst *constRaw = constPool.GetConstByIdx(opInvoke.GetMethodIdx());
+  if (constRaw == nullptr ||
+      (constRaw->GetTag() != jbc::JBCConstTag::kConstMethodRef &&
+       constRaw->GetTag() != jbc::JBCConstTag::kConstInterfaceMethodRef)) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstRef *constRef = static_cast<const jbc::JBCConstRef*>(constRaw);
+  FEStructMethodInfo *methodInfo = static_cast<FEStructMethodInfo*>(constRef->GetFEStructElemInfo());
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCallAssign>(*methodInfo, OP_virtualcall, nullptr, false);
+  FEIRStmtCallAssign *ptrStmt = static_cast<FEIRStmtCallAssign*>(stmt.get());
+  PrepareInvokeParametersAndReturn(stack2feHelper, *methodInfo, *ptrStmt, false);
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpInvokeStatic(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpInvoke &opInvoke = static_cast<const jbc::JBCOpInvoke&>(op);
+  const jbc::JBCConst *constRaw = constPool.GetConstByIdx(opInvoke.GetMethodIdx());
+  if (constRaw == nullptr ||
+      (constRaw->GetTag() != jbc::JBCConstTag::kConstMethodRef &&
+       constRaw->GetTag() != jbc::JBCConstTag::kConstInterfaceMethodRef)) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstRef *constRef = static_cast<const jbc::JBCConstRef*>(constRaw);
+  FEStructMethodInfo *methodInfo = static_cast<FEStructMethodInfo*>(constRef->GetFEStructElemInfo());
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCallAssign>(*methodInfo, OP_call, nullptr, true);
+  FEIRStmtCallAssign *ptrStmt = static_cast<FEIRStmtCallAssign*>(stmt.get());
+  PrepareInvokeParametersAndReturn(stack2feHelper, *methodInfo, *ptrStmt, true);
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpInvokeInterface(JBCFunctionContext &context,
+                                                                      bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpInvoke &opInvoke = static_cast<const jbc::JBCOpInvoke&>(op);
+  const jbc::JBCConst *constRaw = constPool.GetConstByIdx(opInvoke.GetMethodIdx());
+  if (constRaw == nullptr ||
+      (constRaw->GetTag() != jbc::JBCConstTag::kConstMethodRef &&
+       constRaw->GetTag() != jbc::JBCConstTag::kConstInterfaceMethodRef)) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstRef *constRef = static_cast<const jbc::JBCConstRef*>(constRaw);
+  FEStructMethodInfo *methodInfo = static_cast<FEStructMethodInfo*>(constRef->GetFEStructElemInfo());
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCallAssign>(*methodInfo, OP_interfacecall, nullptr, false);
+  FEIRStmtCallAssign *ptrStmt = static_cast<FEIRStmtCallAssign*>(stmt.get());
+  PrepareInvokeParametersAndReturn(stack2feHelper, *methodInfo, *ptrStmt, false);
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpInvokeSpecial(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpInvoke &opInvoke = static_cast<const jbc::JBCOpInvoke&>(op);
+  const jbc::JBCConst *constRaw = constPool.GetConstByIdx(opInvoke.GetMethodIdx());
+  if (constRaw == nullptr ||
+      (constRaw->GetTag() != jbc::JBCConstTag::kConstMethodRef &&
+       constRaw->GetTag() != jbc::JBCConstTag::kConstInterfaceMethodRef)) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstRef *constRef = static_cast<const jbc::JBCConstRef*>(constRaw);
+  FEStructMethodInfo *methodInfo = static_cast<FEStructMethodInfo*>(constRef->GetFEStructElemInfo());
+  Opcode mirOp = methodInfo->IsConstructor() ? OP_call : OP_superclasscall;
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCallAssign>(*methodInfo, mirOp, nullptr, false);
+  FEIRStmtCallAssign *ptrStmt = static_cast<FEIRStmtCallAssign*>(stmt.get());
+  PrepareInvokeParametersAndReturn(stack2feHelper, *methodInfo, *ptrStmt, false);
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpInvokeDynamic(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpInvoke &opInvoke = static_cast<const jbc::JBCOpInvoke&>(op);
+  const jbc::JBCConst *constRaw = constPool.GetConstByIdx(opInvoke.GetMethodIdx());
+  if (constRaw == nullptr || constRaw->GetTag() != jbc::JBCConstTag::kConstInvokeDynamic) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstInvokeDynamic *constDynamic = static_cast<const jbc::JBCConstInvokeDynamic*>(constRaw);
+  FEStructMethodInfo *methodInfo = static_cast<FEStructMethodInfo*>(constDynamic->GetFEStructElemInfo());
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCallAssign>(*methodInfo, OP_call, nullptr, true);
+  FEIRStmtCallAssign *ptrStmt = static_cast<FEIRStmtCallAssign*>(stmt.get());
+  PrepareInvokeParametersAndReturn(stack2feHelper, *methodInfo, *ptrStmt, true);
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpNew(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpNew &opNew = static_cast<const jbc::JBCOpNew&>(op);
+  UniqueFEIRType type = opNew.GetFEIRType(constPool)->Clone();
+  UniqueFEIRExpr expr(nullptr);
+  switch (op.GetOpcode()) {
+    case jbc::kOpNew: {
+      expr = FEIRBuilder::CreateExprJavaNewInstance(type->Clone());
+      break;
+    }
+    case jbc::kOpNewArray:
+    case jbc::kOpANewArray: {
+      UniqueFEIRVar varSize = stack2feHelper.PopItem(PTY_i32);
+      if (varSize == nullptr) {
+        success = false;
+        return ans;
+      }
+      (void)type->ArrayIncrDim();
+      UniqueFEIRExpr exprSize = FEIRBuilder::CreateExprDRead(std::move(varSize));
+      expr = FEIRBuilder::CreateExprJavaNewArray(type->Clone(), std::move(exprSize));
+      break;
+    }
+    default:
+      FATAL(kLncFatal, "should not run here");
+      return ans;
+  }
+  UniqueFEIRVar varDst = stack2feHelper.PushItem(PTY_ref);
+  if (varDst == nullptr || expr == nullptr) {
+    success = false;
+    return ans;
+  }
+  varDst->SetType(std::move(type));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(expr), true);
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpMultiANewArray(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCOpMultiANewArray &opArray = static_cast<const jbc::JBCOpMultiANewArray&>(op);
+  const jbc::JBCConst *constRaw = constPool.GetConstByIdxWithTag(opArray.GetRefTypeIdx(),
+                                                                 jbc::JBCConstTag::kConstClass);
+  if (constRaw == nullptr) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstClass *constClass = static_cast<const jbc::JBCConstClass*>(constRaw);
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtJavaMultiANewArray>(nullptr, constClass->GetFEIRType()->Clone(),
+                                                                     nullptr);
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack(constPool);
+  std::reverse(stackInTypes.begin(), stackInTypes.end());
+  FEIRStmtJavaMultiANewArray *javaMultiANewArray = static_cast<FEIRStmtJavaMultiANewArray*>(stmt.get());
+  for (jbc::JBCPrimType popType : stackInTypes) {
+    PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(popType);
+    UniqueFEIRVar var = stack2feHelper.PopItem(pty);
+    if (var == nullptr) {
+      success = false;
+      return ans;
+    }
+    javaMultiANewArray->AddVarSizeRev(std::move(var));
+  }
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack(constPool);
+  if (stackOutType == jbc::JBCPrimType::kTypeDefault) {
+    success = false;
+    return ans;
+  }
+  PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+  UniqueFEIRVar varRet = stack2feHelper.PushItem(pty);
+  javaMultiANewArray->SetArrayType(varRet->GetType()->Clone());
+  javaMultiANewArray->SetVar(std::move(varRet));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpThrow(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  // obtain in/out types
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  ASSERT(stackInTypes.size() == 1, "Not enough input opnds for return op");
+  PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackInTypes[0]);
+  UniqueFEIRVar var = stack2feHelper.PopItem(pty);
+  if (var == nullptr) {
+    success = false;
+    return ans;
+  }
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(var));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtUseOnly>(OP_throw, std::move(expr));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpTypeCheck(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  jbc::JBCOpcode opcode = op.GetOpcode();
+  const jbc::JBCOpTypeCheck &opTypeCheck = static_cast<const jbc::JBCOpTypeCheck&>(op);
+  PrimType ptyIn = PTY_ref;
+  PrimType ptyOut = (opcode == jbc::kOpCheckCast) ? PTY_ref : PTY_i32;
+  UniqueFEIRVar varIn = stack2feHelper.PopItem(ptyIn);
+  UniqueFEIRVar varOut = stack2feHelper.PushItem(ptyOut);
+  uint16 constIdx = opTypeCheck.GetTypeIdx();
+  const jbc::JBCConst *constRaw = constPool.GetConstByIdxWithTag(constIdx, jbc::JBCConstTag::kConstClass);
+  if (constRaw == nullptr) {
+    success = false;
+    return ans;
+  }
+  const jbc::JBCConstClass *constClass = static_cast<const jbc::JBCConstClass*>(constRaw);
+  UniqueFEIRType type = constClass->GetFEIRType()->Clone();
+  if (opcode == jbc::kOpCheckCast) {
+    UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtJavaCheckCast(std::move(varOut), std::move(varIn), std::move(type));
+    ans.push_back(std::move(stmt));
+  } else {
+    UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtJavaInstanceOf(std::move(varOut), std::move(varIn), std::move(type));
+    ans.push_back(std::move(stmt));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpMonitor(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  // stack operation
+  UniqueFEIRVar var = stack2feHelper.PopItem(PTY_ref);
+  if (var == nullptr) {
+    success = false;
+    return ans;
+  }
+  auto it = opcodeMapForMonitor.find(op.GetOpcode());
+  if (it == opcodeMapForMonitor.end()) {
+    success = false;
+    ERR(kLncErr, "EmitToFEIRForOpMathUnop: unsupport opcode %s", op.GetOpcodeName().c_str());
+    return ans;
+  }
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(var));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtUseOnly>(it->second, std::move(expr));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRForOpArrayLength(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  // stack operation
+  // in
+  UniqueFEIRVar varArray = stack2feHelper.PopItem(PTY_ref);
+  if (varArray == nullptr) {
+    success = false;
+    return ans;
+  }
+  // out
+  UniqueFEIRVar varDst = stack2feHelper.PushItem(PTY_i32);
+  if (varDst == nullptr) {
+    success = false;
+    return ans;
+  }
+  UniqueFEIRExpr exprArray = FEIRBuilder::CreateExprDRead(std::move(varArray));
+  UniqueFEIRExpr exprArrayLength = FEIRBuilder::CreateExprJavaArrayLength(std::move(exprArray));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(exprArrayLength), true);
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRCommon(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  std::reverse(stackInTypes.begin(), stackInTypes.end());
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack();
+  for (jbc::JBCPrimType popType : stackInTypes) {
+    PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(popType);
+    UniqueFEIRVar var = stack2feHelper.PopItem(pty);
+    if (var == nullptr) {
+      success = false;
+      break;
+    }
+  }
+  if (success && stackOutType != jbc::JBCPrimType::kTypeDefault) {
+    PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+    UniqueFEIRVar var = stack2feHelper.PushItem(pty);
+    if (var == nullptr) {
+      success = false;
+    }
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInst::EmitToFEIRCommon2(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const jbc::JBCConstPool &constPool = context.GetConstPool();
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack(constPool);
+  std::reverse(stackInTypes.begin(), stackInTypes.end());
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack(constPool);
+  for (jbc::JBCPrimType popType : stackInTypes) {
+    PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(popType);
+    UniqueFEIRVar var = stack2feHelper.PopItem(pty);
+    if (var == nullptr) {
+      success = false;
+      break;
+    }
+  }
+  if (success && stackOutType != jbc::JBCPrimType::kTypeDefault) {
+    PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+    UniqueFEIRVar var = stack2feHelper.PushItem(pty);
+    if (var == nullptr) {
+      success = false;
+    }
+  }
+  return ans;
+}
+
+UniqueFEIRStmt JBCStmtInst::GenerateStmtForConstI32(JBCStack2FEHelper &stack2feHelper, int32 val, bool &success) const {
+  UniqueFEIRExpr exprConst = FEIRBuilder::CreateExprConstI32(val);
+  UniqueFEIRVar varDst = stack2feHelper.PushItem(PTY_i32);
+  if (varDst == nullptr) {
+    success = false;
+    return UniqueFEIRStmt(nullptr);
+  }
+  UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(exprConst));
+  return stmtDAssign;
+}
+
+UniqueFEIRStmt JBCStmtInst::GenerateStmtForConstI64(JBCStack2FEHelper &stack2feHelper, int64 val, bool &success) const {
+  UniqueFEIRExpr exprConst = FEIRBuilder::CreateExprConstI64(val);
+  UniqueFEIRVar varDst = stack2feHelper.PushItem(PTY_i64);
+  if (varDst == nullptr) {
+    success = false;
+    return UniqueFEIRStmt(nullptr);
+  }
+  UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(exprConst));
+  return stmtDAssign;
+}
+
+UniqueFEIRStmt JBCStmtInst::GenerateStmtForConstF32(JBCStack2FEHelper &stack2feHelper, float val, bool &success) const {
+  UniqueFEIRExpr exprConst = FEIRBuilder::CreateExprConstF32(val);
+  UniqueFEIRVar varDst = stack2feHelper.PushItem(PTY_f32);
+  if (varDst == nullptr) {
+    success = false;
+    return UniqueFEIRStmt(nullptr);
+  }
+  UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(exprConst));
+  return stmtDAssign;
+}
+
+UniqueFEIRStmt JBCStmtInst::GenerateStmtForConstF64(JBCStack2FEHelper &stack2feHelper, double val,
+                                                    bool &success) const {
+  UniqueFEIRExpr exprConst = FEIRBuilder::CreateExprConstF64(val);
+  UniqueFEIRVar varDst = stack2feHelper.PushItem(PTY_f64);
+  if (varDst == nullptr) {
+    success = false;
+    return UniqueFEIRStmt(nullptr);
+  }
+  UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(exprConst));
+  return stmtDAssign;
+}
+
+// ---------- JBCStmtInstBranch ----------
+std::map<jbc::JBCOpcode, std::tuple<Opcode, Opcode, uint8>> JBCStmtInstBranch::opcodeMapForCondGoto =
+    JBCStmtInstBranch::InitOpcodeMapForCondGoto();
+
+std::map<jbc::JBCOpcodeKind, JBCStmtInstBranch::FuncPtrEmitToFEIR> JBCStmtInstBranch::funcPtrMapForEmitToFEIR =
+    JBCStmtInstBranch::InitFuncPtrMapForEmitToFEIR();
+
+JBCStmtInstBranch::JBCStmtInstBranch(const jbc::JBCOp &argOp)
+    : JBCStmt(kStmtPesudo, kJBCStmtInstBranch),
+      op(argOp) {
+  SetFallThru(op.IsFallThru());
+}
+
+bool JBCStmtInstBranch::IsStmtInstImpl() const {
+  return true;
+}
+
+void JBCStmtInstBranch::DumpImpl(const std::string &prefix) const {
+  std::cout << prefix << "JBCStmtInstBranch (id=" << id << ", " <<
+               "kind=" << JBCStmtKindHelper::JBCStmtKindName(JBCkind) << ", " <<
+               "op=" << op.GetOpcodeName() << ", " <<
+               "targets={";
+  for (FEIRStmt *stmt : extraSuccs) {
+    std::cout << stmt->GetID() << " ";
+  }
+  std::cout << "})" << std::endl;
+}
+
+std::string JBCStmtInstBranch::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << op.GetOpcodeName();
+  return ss.str();
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInstBranch::EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const {
+  auto it = funcPtrMapForEmitToFEIR.find(op.GetOpcodeKind());
+  if (it != funcPtrMapForEmitToFEIR.end()) {
+    return (this->*(it->second))(context, success);
+  } else {
+    return EmitToFEIRCommon(context, success);
+  }
+}
+
+JBCStmtPesudoLabel *JBCStmtInstBranch::GetTarget(const std::map<uint32, JBCStmtPesudoLabel*> &mapPCStmtLabel,
+                                                 uint32 pc) const {
+  auto itTarget = mapPCStmtLabel.find(pc);
+  if (itTarget == mapPCStmtLabel.end()) {
+    ERR(kLncErr, "target@pc=%u not found", pc);
+    return nullptr;
+  }
+  return itTarget->second;
+}
+
+std::map<jbc::JBCOpcodeKind, JBCStmtInstBranch::FuncPtrEmitToFEIR> JBCStmtInstBranch::InitFuncPtrMapForEmitToFEIR() {
+  std::map<jbc::JBCOpcodeKind, FuncPtrEmitToFEIR> ans;
+  ans[jbc::JBCOpcodeKind::kOpKindGoto] = &JBCStmtInstBranch::EmitToFEIRForOpGoto;
+  ans[jbc::JBCOpcodeKind::kOpKindBranch] = &JBCStmtInstBranch::EmitToFEIRForOpBranch;
+  ans[jbc::JBCOpcodeKind::kOpKindSwitch] = &JBCStmtInstBranch::EmitToFEIRForOpSwitch;
+  ans[jbc::JBCOpcodeKind::kOpKindJsr] = &JBCStmtInstBranch::EmitToFEIRForOpJsr;
+  ans[jbc::JBCOpcodeKind::kOpKindRet] = &JBCStmtInstBranch::EmitToFEIRForOpRet;
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInstBranch::EmitToFEIRForOpGoto(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const std::map<uint32, JBCStmtPesudoLabel*> &mapPCStmtLabel = context.GetMapPCLabelStmt();
+  const jbc::JBCOpGoto &opGoto = static_cast<const jbc::JBCOpGoto&>(op);
+  auto it = mapPCStmtLabel.find(opGoto.GetTarget());
+  if (it == mapPCStmtLabel.end()) {
+    ERR(kLncErr, "target not found for inst branch");
+    success = false;
+  } else {
+    JBCStmtPesudoLabel *stmtLabel = it->second;
+    CHECK_NULL_FATAL(stmtLabel);
+    UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtGoto(stmtLabel->GetLabelIdx());
+    ans.push_back(std::move(stmt));
+  }
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInstBranch::EmitToFEIRForOpBranch(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const std::map<uint32, JBCStmtPesudoLabel*> &mapPCStmtLabel = context.GetMapPCLabelStmt();
+  const jbc::JBCOpBranch &opBranch = static_cast<const jbc::JBCOpBranch&>(op);
+  auto itTarget = mapPCStmtLabel.find(opBranch.GetTarget());
+  if (itTarget == mapPCStmtLabel.end()) {
+    ERR(kLncErr, "target not found for inst branch");
+    success = false;
+    return ans;
+  }
+  JBCStmtPesudoLabel *stmtLabel = itTarget->second;
+  CHECK_NULL_FATAL(stmtLabel);
+  auto it = opcodeMapForCondGoto.find(op.GetOpcode());
+  if (it == opcodeMapForCondGoto.end()) {
+    ERR(kLncErr, "unsupport opcode %s", op.GetOpcodeName().c_str());
+    success = false;
+    return ans;
+  }
+  Opcode opStmt = std::get<0>(it->second);
+  Opcode opCompExpr = std::get<1>(it->second);
+  uint8 mode = std::get<2>(it->second);
+  // opnds
+  UniqueFEIRExpr expr0;
+  UniqueFEIRExpr expr1;
+  PrimType pty = ((mode & kModeUseRef) == 0) ? PTY_i32 : PTY_ref;
+  if ((mode & kModeUseZeroAsSecondOpnd) == 0) {
+    UniqueFEIRVar var1 = stack2feHelper.PopItem(pty);
+    if (var1 == nullptr) {
+      success = false;
+      return ans;
+    }
+    expr1 = FEIRBuilder::CreateExprDRead(std::move(var1));
+  } else {
+    expr1 = (pty == PTY_ref) ? FEIRBuilder::CreateExprConstRefNull() : FEIRBuilder::CreateExprConstI32(0);
+  }
+  UniqueFEIRVar var0 = stack2feHelper.PopItem(pty);
+  if (var0 == nullptr) {
+    success = false;
+    return ans;
+  }
+  expr0 = FEIRBuilder::CreateExprDRead(std::move(var0));
+  UniqueFEIRExpr exprComp = FEIRBuilder::CreateExprMathBinary(opCompExpr, std::move(expr0), std::move(expr1));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtCondGoto(stmtLabel->GetLabelIdx(), opStmt, std::move(exprComp));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInstBranch::EmitToFEIRForOpSwitch(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const std::map<uint32, JBCStmtPesudoLabel*> &mapPCStmtLabel = context.GetMapPCLabelStmt();
+  const jbc::JBCOpSwitch &opSwitch = static_cast<const jbc::JBCOpSwitch&>(op);
+  UniqueFEIRVar var = stack2feHelper.PopItem(PTY_i32);
+  if (var == nullptr) {
+    success = false;
+    return ans;
+  }
+  UniqueFEIRExpr exprValue = FEIRBuilder::CreateExprDRead(std::move(var));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtSwitch(std::move(exprValue));
+  FEIRStmtSwitch *ptrStmtSwitch = static_cast<FEIRStmtSwitch*>(stmt.get());
+  CHECK_NULL_FATAL(ptrStmtSwitch);
+  // default target
+  auto itTargetDefault = mapPCStmtLabel.find(opSwitch.GetDefaultTarget());
+  if (itTargetDefault == mapPCStmtLabel.end()) {
+    ERR(kLncErr, "target not found for inst switch");
+    success = false;
+    return ans;
+  }
+  CHECK_NULL_FATAL(itTargetDefault->second);
+  ptrStmtSwitch->SetDefaultLabelIdx(itTargetDefault->second->GetLabelIdx());
+  // value targets
+  for (const auto &itItem : opSwitch.GetTargets()) {
+    auto itTarget = mapPCStmtLabel.find(itItem.second);
+    if (itTarget == mapPCStmtLabel.end()) {
+      ERR(kLncErr, "target not found for inst switch");
+      success = false;
+      return ans;
+    }
+    CHECK_NULL_FATAL(itTarget->second);
+    ptrStmtSwitch->AddTarget(itItem.first, itTarget->second->GetLabelIdx());
+  }
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInstBranch::EmitToFEIRForOpJsr(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  const std::map<uint32, JBCStmtPesudoLabel*> &mapPCStmtLabel = context.GetMapPCLabelStmt();
+  const jbc::JBCOpJsr &opJsr = static_cast<const jbc::JBCOpJsr&>(op);
+  auto itTarget = mapPCStmtLabel.find(opJsr.GetTarget());
+  if (itTarget == mapPCStmtLabel.end()) {
+    ERR(kLncErr, "target not found for inst jsr");
+    success = false;
+    return ans;
+  }
+  JBCStmtPesudoLabel *stmtLabel = itTarget->second;
+  CHECK_NULL_FATAL(stmtLabel);
+  uint32 slotRegNum = stack2feHelper.GetRegNumForSlot(opJsr.GetSlotIdx());
+  UniqueFEIRVar var = FEIRBuilder::CreateVarReg(slotRegNum, PTY_i32, false);
+  (void)stack2feHelper.PushItem(var->Clone(), PTY_a32);
+  UniqueFEIRExpr exprConst = FEIRBuilder::CreateExprConstI32(opJsr.GetJsrID());
+  UniqueFEIRStmt stmtJsr = FEIRBuilder::CreateStmtDAssign(std::move(var), std::move(exprConst));
+  UniqueFEIRStmt stmtGoto = FEIRBuilder::CreateStmtGoto(stmtLabel->GetLabelIdx());
+  ans.push_back(std::move(stmtJsr));
+  ans.push_back(std::move(stmtGoto));
+  return ans;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInstBranch::EmitToFEIRForOpRet(JBCFunctionContext &context, bool &success) const {
+  return EmitToFEIRForOpRetImpl(context, success);
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInstBranch::EmitToFEIRCommon(JBCFunctionContext &context, bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  JBCStack2FEHelper &stack2feHelper = context.GetStack2FEHelper();
+  std::vector<jbc::JBCPrimType> stackInTypes = op.GetInputTypesFromStack();
+  std::reverse(stackInTypes.begin(), stackInTypes.end());
+  jbc::JBCPrimType stackOutType = op.GetOutputTypesToStack();
+  for (jbc::JBCPrimType popType : stackInTypes) {
+    PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(popType);
+    UniqueFEIRVar var = stack2feHelper.PopItem(pty);
+    if (var == nullptr) {
+      success = false;
+      break;
+    }
+  }
+  if (success && stackOutType != jbc::JBCPrimType::kTypeDefault) {
+    PrimType pty = JBCStack2FEHelper::JBCStackItemTypeToPrimType(stackOutType);
+    UniqueFEIRVar var = stack2feHelper.PushItem(pty);
+    if (var == nullptr) {
+      success = false;
+    }
+  }
+  return ans;
+}
+
+std::map<jbc::JBCOpcode, std::tuple<Opcode, Opcode, uint8>> JBCStmtInstBranch::InitOpcodeMapForCondGoto() {
+  std::map<jbc::JBCOpcode, std::tuple<Opcode, Opcode, uint8>> ans;
+  ans[jbc::kOpIfeq] = std::make_tuple(OP_brtrue, OP_eq, kModeUseZeroAsSecondOpnd);
+  ans[jbc::kOpIfne] = std::make_tuple(OP_brfalse, OP_eq, kModeUseZeroAsSecondOpnd);
+  ans[jbc::kOpIflt] = std::make_tuple(OP_brtrue, OP_lt, kModeUseZeroAsSecondOpnd);
+  ans[jbc::kOpIfge] = std::make_tuple(OP_brtrue, OP_ge, kModeUseZeroAsSecondOpnd);
+  ans[jbc::kOpIfgt] = std::make_tuple(OP_brtrue, OP_gt, kModeUseZeroAsSecondOpnd);
+  ans[jbc::kOpIfle] = std::make_tuple(OP_brtrue, OP_le, kModeUseZeroAsSecondOpnd);
+  ans[jbc::kOpIfICmpeq] = std::make_tuple(OP_brtrue, OP_eq, kModeDefault);
+  ans[jbc::kOpIfICmpne] = std::make_tuple(OP_brfalse, OP_eq, kModeDefault);
+  ans[jbc::kOpIfICmplt] = std::make_tuple(OP_brtrue, OP_lt, kModeDefault);
+  ans[jbc::kOpIfICmpge] = std::make_tuple(OP_brtrue, OP_ge, kModeDefault);
+  ans[jbc::kOpIfICmpgt] = std::make_tuple(OP_brtrue, OP_gt, kModeDefault);
+  ans[jbc::kOpIfICmple] = std::make_tuple(OP_brtrue, OP_le, kModeDefault);
+  ans[jbc::kOpIfACmpeq] = std::make_tuple(OP_brtrue, OP_eq, kModeUseRef);
+  ans[jbc::kOpIfACmpne] = std::make_tuple(OP_brfalse, OP_eq, kModeUseRef);
+  ans[jbc::kOpIfNull] = std::make_tuple(OP_brtrue, OP_eq, kModeUseRef | kModeUseZeroAsSecondOpnd);
+  ans[jbc::kOpIfNonNull] = std::make_tuple(OP_brfalse, OP_eq, kModeUseRef | kModeUseZeroAsSecondOpnd);
+  return ans;
+}
+
+// ---------- JBCStmtInstBranchRet ----------
+JBCStmtInstBranchRet::JBCStmtInstBranchRet(const jbc::JBCOp &argOp)
+    : JBCStmtInstBranch(argOp) {
+  JBCkind = kJBCStmtInstBranchRet;
+}
+
+std::list<UniqueFEIRStmt> JBCStmtInstBranchRet::EmitToFEIRForOpRetImpl(JBCFunctionContext &context,
+                                                                       bool &success) const {
+  std::list<UniqueFEIRStmt> ans;
+  const std::map<uint32, JBCStmtPesudoLabel*> &mapPCStmtLabel = context.GetMapPCLabelStmt();
+  const std::map<uint16, std::map<int32, uint32>> &mapJsrSlotRetAddr = context.GetMapJsrSlotRetAddr();
+  const jbc::JBCOpRet &opRet = static_cast<const jbc::JBCOpRet&>(op);
+  uint16 slotIdx = opRet.GetIndex();
+  auto itJsrInfo = mapJsrSlotRetAddr.find(slotIdx);
+  if (itJsrInfo == mapJsrSlotRetAddr.end()) {
+    WARN(kLncWarn, "jsr info not found");
+    success = false;
+    return ans;
+  }
+  const std::map<int32, uint32> &jsrInfo = itJsrInfo->second;
+  if (jsrInfo.size() == 1) {
+    auto itInfo = jsrInfo.begin();
+    JBCStmtPesudoLabel *stmtLabel = GetTarget(mapPCStmtLabel, itInfo->second);
+    if (stmtLabel == nullptr) {
+      success = false;
+      return ans;
+    }
+    UniqueFEIRStmt stmtGoto = FEIRBuilder::CreateStmtGoto(stmtLabel->GetLabelIdx());
+    ans.push_back(std::move(stmtGoto));
+  } else {
+    uint32 idx = 0;
+    UniqueFEIRVar var = FEIRBuilder::CreateVarReg(slotIdx, PTY_i32);
+    UniqueFEIRExpr exprValue = FEIRBuilder::CreateExprDRead(std::move(var));
+    UniqueFEIRStmt stmtSwitch = FEIRBuilder::CreateStmtSwitch(std::move(exprValue));
+    FEIRStmtSwitch *ptrStmtSwitch = static_cast<FEIRStmtSwitch*>(stmtSwitch.get());
+    for (auto itInfo : jsrInfo) {
+      JBCStmtPesudoLabel *stmtLabel = GetTarget(mapPCStmtLabel, itInfo.second);
+      if (stmtLabel == nullptr) {
+        success = false;
+        return ans;
+      }
+      if (idx == jsrInfo.size() - 1) {
+        ptrStmtSwitch->SetDefaultLabelIdx(stmtLabel->GetLabelIdx());
+      } else {
+        ptrStmtSwitch->AddTarget(itInfo.first, stmtLabel->GetLabelIdx());
+      }
+      ++idx;
+    }
+    ans.push_back(std::move(stmtSwitch));
+  }
+  return ans;
+}
+
+// ---------- JBCStmtPesudoLabel ----------
+void JBCStmtPesudoLabel::DumpImpl(const std::string &prefix) const {
+  std::cout << prefix << "JBCStmtPesudoLabel (id=" << id << "," <<
+               "kind=" << JBCStmtKindHelper::JBCStmtKindName(JBCkind) << ", " <<
+               "preds={";
+  for (FEIRStmt *stmt : extraPreds) {
+    std::cout << stmt->GetID() << " ";
+  }
+  std::cout << "})" << std::endl;
+}
+
+std::string JBCStmtPesudoLabel::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": label" << labelIdx;
+  return ss.str();
+}
+
+std::list<UniqueFEIRStmt> JBCStmtPesudoLabel::EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const {
+  (void) context;
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtPesudoLabel>(labelIdx);
+  ans.push_back(std::move(stmt));
+  success = true;
+  return ans;
+}
+
+// ---------- JBCStmtPesudoCatch ----------
+void JBCStmtPesudoCatch::DumpImpl(const std::string &prefix) const {
+  std::cout << prefix << "JBCStmtPesudoCatch (id=" << id << "," <<
+               "kind=" << JBCStmtKindHelper::JBCStmtKindName(JBCkind) << ", " <<
+               "preds={";
+  for (FEIRStmt *stmt : extraPreds) {
+    std::cout << stmt->GetID() << " ";
+  }
+  std::cout << "})" << std::endl;
+}
+
+std::string JBCStmtPesudoCatch::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": catch" << labelIdx;
+  return ss.str();
+}
+
+std::list<UniqueFEIRStmt> JBCStmtPesudoCatch::EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const {
+  (void) context;
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtPesudoCatch>(labelIdx);
+  FEIRStmtPesudoCatch *feirStmt = static_cast<FEIRStmtPesudoCatch*>(stmt.get());
+  for (GStrIdx typeNameIdx : catchTypeNames) {
+    feirStmt->AddCatchTypeNameIdx(typeNameIdx);
+  }
+  ans.push_back(std::move(stmt));
+  success = true;
+  return ans;
+}
+
+// ---------- JBCStmtPesudoTry ----------
+void JBCStmtPesudoTry::DumpImpl(const std::string &prefix) const {
+  std::cout << prefix << "JBCStmtPesudoTry (id=" << id << "," <<
+               "kind=" << JBCStmtKindHelper::JBCStmtKindName(JBCkind) << ", " <<
+               "succs={";
+  for (JBCStmtPesudoCatch *stmt : catchStmts) {
+    std::cout << stmt->GetID() << " ";
+  }
+  std::cout << "})" << std::endl;
+}
+
+std::string JBCStmtPesudoTry::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": try";
+  return ss.str();
+}
+
+std::list<UniqueFEIRStmt> JBCStmtPesudoTry::EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const {
+  (void) context;
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtPesudoJavaTry>();
+  FEIRStmtPesudoJavaTry *feirStmt = static_cast<FEIRStmtPesudoJavaTry*>(stmt.get());
+  for (JBCStmtPesudoCatch *stmtCatch : catchStmts) {
+    feirStmt->AddCatchLabelIdx(stmtCatch->GetLabelIdx());
+  }
+  ans.push_back(std::move(stmt));
+  success = true;
+  return ans;
+}
+
+// ---------- JBCStmtPesudoEndTry ----------
+void JBCStmtPesudoEndTry::DumpImpl(const std::string &prefix) const {
+  std::cout << prefix << "JBCStmtPesudoEndTry (id=" << id << ", " <<
+               "kind=" << JBCStmtKindHelper::JBCStmtKindName(JBCkind) <<
+               ")" << std::endl;
+}
+
+std::string JBCStmtPesudoEndTry::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": endtry";
+  return ss.str();
+}
+
+std::list<UniqueFEIRStmt> JBCStmtPesudoEndTry::EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const {
+  (void) context;
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtPesudoEndTry>();
+  ans.push_back(std::move(stmt));
+  success = true;
+  return ans;
+}
+
+// ---------- JBCStmtPesudoComment ----------
+void JBCStmtPesudoComment::DumpImpl(const std::string &prefix) const {
+  (void) prefix;
+}
+
+std::string JBCStmtPesudoComment::DumpDotStringImpl() const {
+  return "";
+}
+
+std::list<UniqueFEIRStmt> JBCStmtPesudoComment::EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const {
+  (void) context;
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtPesudoComment>(content);
+  ans.push_back(std::move(stmt));
+  success = true;
+  return ans;
+}
+
+// ---------- JBCStmtPesudoLOC ----------
+void JBCStmtPesudoLOC::DumpImpl(const std::string &prefix) const {
+  std::cout << prefix << "LOC " << srcFileIdx << " " << lineNumber << std::endl;
+}
+
+std::string JBCStmtPesudoLOC::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": LOC " << srcFileIdx << " " << lineNumber;
+  return ss.str();
+}
+
+std::list<UniqueFEIRStmt> JBCStmtPesudoLOC::EmitToFEIRImpl(JBCFunctionContext &context, bool &success) const {
+  (void) context;
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtPesudoLOC>(srcFileIdx, lineNumber);
+  ans.push_back(std::move(stmt));
+  success = true;
+  return ans;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/class/src/jbc_util.cpp b/src/hir2mpl/bytecode_input/class/src/jbc_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..951a5eb75e6c25d9b6d23e1d7b3b8351d41fc860
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/class/src/jbc_util.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "jbc_util.h"
+#include "mpl_logging.h"
+
+namespace maple {
+namespace jbc {
+std::string JBCUtil::ClassInternalNameToFullName(const std::string &name) {
+  if (name[0] == '[') {
+    return name;
+  } else {
+    return "L" + name + ";";
+  }
+}
+
+JBCPrimType JBCUtil::GetPrimTypeForName(const std::string &name) {
+  switch (name[0]) {
+    case '[':
+    case 'L':
+      return kTypeRef;
+    case 'I':
+      return kTypeInt;
+    case 'J':
+      return kTypeLong;
+    case 'F':
+      return kTypeFloat;
+    case 'D':
+      return kTypeDouble;
+    case 'B':
+      return kTypeByteOrBoolean;
+    case 'Z':
+      return kTypeByteOrBoolean;
+    case 'C':
+      return kTypeChar;
+    case 'S':
+      return kTypeShort;
+    case 'V':
+      return kTypeDefault;
+    default:
+      CHECK_FATAL(false, "Unsupported type name %s", name.c_str());
+  }
+  return kTypeDefault;
+}
+}  // namespace jbc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/ark_annotation_map.h b/src/hir2mpl/bytecode_input/common/include/ark_annotation_map.h
new file mode 100644
index 0000000000000000000000000000000000000000..c52e272deb996353866aab1577ddc32d5dec6a85
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/ark_annotation_map.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_ARK_ANNOTATION_MAP_H
+#define HIR2MPL_BC_INPUT_INCLUDE_ARK_ANNOTATION_MAP_H
+#include <map>
+#include "global_tables.h"
+
+namespace maple {
+namespace bc {
+class ArkAnnotationMap {
+ public:
+  inline static ArkAnnotationMap &GetArkAnnotationMap() {
+    return annotationMap;
+  }
+
+  void Init();
+  const std::string &GetAnnotationTypeName(const std::string &orinName);
+  const std::set<std::string> &GetArkAnnotationTypeNames() const {
+    return arkAnnotationTypeNames;
+  }
+
+ private:
+  ArkAnnotationMap() = default;
+  ~ArkAnnotationMap() = default;
+
+  static ArkAnnotationMap annotationMap;
+  std::map<std::string, std::string> pragmaTypeNameMap;
+  std::set<std::string> arkAnnotationTypeNames;
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_ARK_ANNOTATION_MAP_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/ark_annotation_processor.h b/src/hir2mpl/bytecode_input/common/include/ark_annotation_processor.h
new file mode 100644
index 0000000000000000000000000000000000000000..c4ba6b5d43529ad45304ecba98822ee5355fd5d7
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/ark_annotation_processor.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_ARK_ANNOTATION_PROCESSOR_H
+#define HIR2MPL_BC_INPUT_INCLUDE_ARK_ANNOTATION_PROCESSOR_H
+#include "global_tables.h"
+#include "namemangler.h"
+namespace maple {
+namespace bc {
+class ArkAnnotationProcessor {
+ public:
+  static void Process();
+};
+
+class ArkAnnotation {
+ public:
+  void Init();
+  bool IsFastNative(const TyIdx &tyIdx) const;
+  bool IsCriticalNative(const TyIdx &tyIdx) const;
+  bool IsCallerSensitive(const TyIdx &tyIdx) const;
+  bool IsPermanent(const TyIdx &tyIdx) const;
+  bool IsPermanent(const std::string &str) const;
+  bool IsRCUnowned(const TyIdx &tyIdx) const;
+  bool IsRCUnownedCap(const TyIdx &tyIdx) const;
+  bool IsRCUnownedCapList(const TyIdx &tyIdx) const;
+  bool IsRCUnownedLocal(const TyIdx &tyIdx) const;
+  bool IsRCUnownedLocalOld(const TyIdx &tyIdx) const;
+  bool IsRCUnownedThis(const TyIdx &tyIdx) const;
+  bool IsRCUnownedOuter(const TyIdx &tyIdx) const;
+  bool IsRCWeak(const TyIdx &tyIdx) const;
+  static ArkAnnotation &GetInstance() {
+    return instance;
+  }
+
+  static GStrIdx GetStrIdxFromDexName(const std::string &name) {
+    return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name));
+  }
+
+ private:
+  ArkAnnotation() = default;
+  ~ArkAnnotation() = default;
+  static MIRStructType *GetStructType(const TyIdx &tyIdx);
+
+  static ArkAnnotation instance;
+  std::set<GStrIdx> typeNameSetForFastNative;
+  std::set<GStrIdx> typeNameSetForCriticalNative;
+  std::set<GStrIdx> typeNameSetForCallerSensitive;
+  std::set<GStrIdx> typeNameSetForPermanent;
+  std::set<GStrIdx> typeNameSetForRCUnowned;
+  std::set<GStrIdx> typeNameSetForRCUnownedCap;
+  std::set<GStrIdx> typeNameSetForRCUnownedCapList;
+  std::set<GStrIdx> typeNameSetForRCUnownedLocal;
+  std::set<GStrIdx> typeNameSetForRCUnownedThis;
+  std::set<GStrIdx> typeNameSetForRCUnownedOuter;
+  std::set<GStrIdx> typeNameSetForRCWeak;
+  GStrIdx typeNameIdxForRCUnownedLocalOld;
+};
+}  // namespace bc
+}  // namespace maple
+#endif // HIR2MPL_BC_INPUT_INCLUDE_ARK_ANNOTATION_PROCESSOR_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_class.h b/src/hir2mpl/bytecode_input/common/include/bc_class.h
new file mode 100644
index 0000000000000000000000000000000000000000..c7d2422f054c0e1325906306dd3a0e6962cb36a7
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_class.h
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_CLASS_H
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_CLASS_H
+#include <vector>
+#include <list>
+#include <map>
+#include <memory>
+#include "types_def.h"
+#include "bc_instruction.h"
+#include "feir_stmt.h"
+#include "bc_parser_base.h"
+#include "feir_var.h"
+#include "mempool.h"
+#include "bc_pragma.h"
+
+namespace maple {
+namespace bc {
+using BCAttrKind = uint32;
+class BCClass;
+
+class BCAttr {
+ public:
+  BCAttr(BCAttrKind k, const GStrIdx &idx) : kind(k), nameIdx(idx) {}
+  ~BCAttr() = default;
+
+ protected:
+  BCAttrKind kind;
+  GStrIdx nameIdx;
+};
+
+class BCAttrMap {
+ public:
+  BCAttrMap() = default;
+  ~BCAttrMap() = default;
+
+ protected:
+  std::map<BCAttrKind, std::unique_ptr<std::list<std::unique_ptr<BCAttr>>>> mapAttrs;
+};
+
+class BCClassElem {
+ public:
+  BCClassElem(const BCClass &klassIn, uint32 acc, const std::string &nameIn, const std::string &descIn);
+  virtual ~BCClassElem() = default;
+  const std::string &GetName() const;
+  const std::string &GetDescription() const;
+  uint32 GetItemIdx() const;
+  uint32 GetIdx() const;
+  uint32 GetAccessFlag() const;
+  bool IsStatic() const;
+  const std::string &GetClassName() const;
+  const BCClass &GetBCClass() const;
+  GStrIdx GetClassNameMplIdx() const;
+
+ protected:
+  virtual uint32 GetItemIdxImpl() const = 0;
+  virtual uint32 GetIdxImpl() const = 0;
+  virtual bool IsStaticImpl() const = 0;
+  const BCClass &klass;
+  uint32 accessFlag;
+  std::string name;
+  std::string descriptor;
+  BCAttrMap attrMap;
+};
+
+class BCClassField : public BCClassElem {
+ public:
+  BCClassField(const BCClass &klassIn, uint32 acc, const std::string &nameIn, const std::string &descIn)
+      : BCClassElem(klassIn, acc, nameIn, descIn) {}
+  ~BCClassField() = default;
+
+ protected:
+  uint32 GetItemIdxImpl() const override = 0;
+  uint32 GetIdxImpl() const override = 0;
+};
+
+class BCCatchInfo {
+ public:
+  BCCatchInfo(uint32 handlerAddrIn, const GStrIdx &argExceptionNameIdx, bool isCatchAllIn);
+  ~BCCatchInfo() = default;
+
+  uint32 GetHandlerAddr() const {
+    return handlerAddr;
+  }
+
+  GStrIdx GetExceptionNameIdx() const {
+    return exceptionNameIdx;
+  }
+
+  bool GetIsCatchAll() const {
+    return isCatchAll;
+  }
+
+ protected:
+  uint32 handlerAddr;
+  GStrIdx exceptionNameIdx;
+  bool isCatchAll = false;
+};
+
+class BCTryInfo {
+ public:
+  BCTryInfo(uint32 startAddrIn, uint32 endAddrIn, std::unique_ptr<std::list<std::unique_ptr<BCCatchInfo>>> catchesIn)
+      : startAddr(startAddrIn), endAddr(endAddrIn), catches(std::move(catchesIn)) {}
+  ~BCTryInfo() = default;
+
+  uint32 GetStartAddr() const {
+    return startAddr;
+  }
+
+  uint32 GetEndAddr() const {
+    return endAddr;
+  }
+
+  const std::list<std::unique_ptr<BCCatchInfo>> *GetCatches() const {
+    return catches.get();
+  }
+  static void DumpTryCatchInfo(const std::unique_ptr<std::list<std::unique_ptr<BCTryInfo>>> &tryInfos);
+
+ protected:
+  uint32 startAddr;
+  uint32 endAddr;
+  std::unique_ptr<std::list<std::unique_ptr<BCCatchInfo>>> catches;
+};
+
+class BCClassMethod : public BCClassElem {
+ public:
+  BCClassMethod(const BCClass &klassIn, uint32 acc, bool isVirtualIn, const std::string &nameIn,
+                const std::string &descIn)
+      : BCClassElem(klassIn, acc, nameIn, descIn), isVirtual(isVirtualIn),
+        methodMp(FEUtils::NewMempool("MemPool for BCClassMethod", true /* isLcalPool */)),
+        allocator(methodMp) {}
+  ~BCClassMethod() {
+    methodMp = nullptr;
+  }
+  void SetPCBCInstructionMap(MapleMap<uint32, BCInstruction*> *mapIn) {
+    pcBCInstructionMap = mapIn;
+  }
+  void SetMethodInstOffset(const uint16 *pos);
+  void SetRegisterTotalSize(uint16 size);
+  uint16 GetRegisterTotalSize() const;
+  void SetRegisterInsSize(uint16 size);
+  void SetCodeOff(uint32 off);
+  uint32 GetCodeOff() const;
+  void AddMethodDepSet(const std::string &depType);
+  bool IsVirtual() const;
+  bool IsNative() const;
+  bool IsInit() const;
+  bool IsClinit() const;
+  std::string GetFullName() const;
+  void ProcessInstructions();
+  std::list<UniqueFEIRStmt> EmitInstructionsToFEIR() const;
+  const uint16 *GetInstPos() const;
+
+  void SetTryInfos(std::unique_ptr<std::list<std::unique_ptr<BCTryInfo>>> infos) {
+    tryInfos = std::move(infos);
+  }
+
+  std::size_t GetTriesSize() const {
+    return tryInfos->size();
+  }
+
+  uint32 GetThisRegNum() const {
+    return IsStatic() ? UINT32_MAX : static_cast<uint32>(registerTotalSize - registerInsSize);
+  }
+
+  void SetSrcPositionInfo(const std::map<uint32, uint32> &srcPosInfo) {
+#ifdef DEBUG
+    pSrcPosInfo = &srcPosInfo;
+#else
+    (void) srcPosInfo;
+#endif
+  }
+
+  const std::map<uint16, std::set<std::tuple<std::string, std::string, std::string>>> *GetSrcLocalInfoPtr() const {
+    return srcLocals.get();
+  }
+
+  void SetSrcLocalInfo(
+      std::unique_ptr<std::map<uint16, std::set<std::tuple<std::string, std::string, std::string>>>> srcLocalsIn) {
+    srcLocals = std::move(srcLocalsIn);
+  }
+
+  std::vector<std::unique_ptr<FEIRVar>> GenArgVarList() const;
+  void GenArgRegs();
+  std::vector<std::string> GetSigTypeNames() const {
+    return sigTypeNames;
+  }
+  bool HasCode() const {
+    return pcBCInstructionMap != nullptr && !pcBCInstructionMap->empty();
+  }
+
+  bool IsRcPermanent() const {
+    return isPermanent;
+  }
+
+  void SetIsRcPermanent(bool flag) {
+    isPermanent = flag;
+  }
+
+  const MemPool *GetMemPool() const {
+    return methodMp;
+  }
+
+  void ReleaseMempool() const {
+    FEUtils::DeleteMempoolPtr(methodMp);
+  }
+
+  MapleAllocator &GetAllocator() {
+    return allocator;
+  }
+
+ protected:
+  uint32 GetItemIdxImpl() const override = 0;
+  uint32 GetIdxImpl() const override = 0;
+  virtual bool IsVirtualImpl() const = 0;
+  virtual bool IsNativeImpl() const = 0;
+  virtual bool IsInitImpl() const = 0;
+  virtual bool IsClinitImpl() const = 0;
+  void ProcessTryCatch();
+  virtual std::vector<std::unique_ptr<FEIRVar>> GenArgVarListImpl() const = 0;
+  void TypeInfer();
+  void InsertPhi(const std::vector<TypeInferItem*> &dom, std::vector<TypeInferItem*> &src);
+  static TypeInferItem *ConstructTypeInferItem(MapleAllocator &alloc, uint32 pos, BCReg* bcReg, TypeInferItem *prev);
+  static std::vector<TypeInferItem*> ConstructNewRegTypeMap(MapleAllocator &alloc, uint32 pos,
+                                                            const std::vector<TypeInferItem*> &regTypeMap);
+  std::list<UniqueFEIRStmt> GenReTypeStmtsThroughArgs() const;
+  void Traverse(std::list<std::pair<uint32, std::vector<TypeInferItem*>>> &pcDefedRegsList,
+                std::vector<std::vector<TypeInferItem*>> &dominances,
+                std::set<uint32> &visitedSet);
+  void PrecisifyRegType();
+  virtual void GenArgRegsImpl() = 0;
+  static void LinkJumpTarget(const std::map<uint32, FEIRStmtPesudoLabel2*> &targetFEIRStmtMap,
+                             const std::list<FEIRStmtGoto2*> &gotoFEIRStmts,
+                             const std::list<FEIRStmtSwitch2*> &switchFEIRStmts);
+  void DumpBCInstructionMap() const;
+  void SetSrcPosInfo();
+  MapleMap<uint32, BCInstruction*> *pcBCInstructionMap = nullptr;
+  std::unique_ptr<std::list<std::unique_ptr<BCTryInfo>>> tryInfos;
+#ifdef DEBUG
+  const std::map<uint32, uint32> *pSrcPosInfo = nullptr;
+#endif
+  // map<regNum, set<tuple<name, typeName, signature>>>
+  std::unique_ptr<std::map<uint16, std::set<std::tuple<std::string, std::string, std::string>>>> srcLocals;
+  std::vector<std::unique_ptr<BCReg>> argRegs;
+  std::vector<std::string> sigTypeNames;
+  bool isVirtual = false;
+  uint16 registerTotalSize = UINT16_MAX;
+  uint16 registerInsSize = UINT16_MAX;
+  uint32 codeOff = UINT32_MAX;
+  const uint16 *instPos = nullptr;  // method instructions start pos in bc file
+  std::set<uint32> visitedPcSet;
+  std::set<uint32> multiInDegreeSet;
+  std::list<BCRegType*> regTypes;
+  // isPermanent is true means the rc annotation @Permanent is used
+  bool isPermanent = false;
+
+  MemPool *methodMp;
+  MapleAllocator allocator;
+};
+
+class BCClass {
+ public:
+  BCClass(uint32 idx, const BCParserBase &parserIn) : classIdx(idx), parser(parserIn) {}
+  ~BCClass() = default;
+
+  uint32 GetClassIdx() const {
+    return classIdx;
+  }
+
+  const BCParserBase &GetBCParser() const {
+    return parser;
+  }
+
+  bool IsInterface() const {
+    return isInterface;
+  }
+
+  void SetFilePathName(const std::string &path) {
+    filePathName = path;
+  }
+
+  void SetSrcFileInfo(const std::string &name);
+  void SetIRSrcFileSigIdx(const GStrIdx &strIdx) {
+    irSrcFileSigIdx = strIdx;
+  }
+
+  bool IsMultiDef() const {
+    return isMultiDef;
+  }
+
+  void SetIsMultiDef(bool flag) {
+    isMultiDef = flag;
+  }
+
+  uint32 GetSrcFileIdx() const {
+    return srcFileIdx;
+  }
+
+  void SetIsInterface(bool flag) {
+    isInterface = flag;
+  }
+  void SetSuperClasses(const std::list<std::string> &names);
+  void SetInterface(const std::string &name);
+  void SetAccFlag(uint32 flag);
+  void SetField(std::unique_ptr<BCClassField> field);
+  void SetMethod(std::unique_ptr<BCClassMethod> method);
+  void SetClassName(const std::string &classNameOrinIn);
+  void SetAnnotationsDirectory(std::unique_ptr<BCAnnotationsDirectory> annotationsDirectory);
+  void InsertStaticFieldConstVal(MIRConst *cst);
+  void InsertFinalStaticStringID(uint32 stringID);
+  std::vector<uint32> GetFinalStaticStringIDVec() const {
+    return finalStaticStringID;
+  }
+  std::vector<MIRConst*> GetStaticFieldsConstVal() const;
+  const std::string &GetClassName(bool mapled) const;
+
+  GStrIdx GetClassNameMplIdx() const {
+    return classNameMplIdx;
+  }
+
+  const std::list<std::string> &GetSuperClassNames() const;
+  const std::vector<std::string> &GetSuperInterfaceNames() const;
+  std::string GetSourceFileName() const;
+  GStrIdx GetIRSrcFileSigIdx() const;
+  uint32 GetAccessFlag() const;
+  int32 GetFileNameHashId() const;
+
+  const std::vector<std::unique_ptr<BCClassField>> &GetFields() const;
+  std::vector<std::unique_ptr<BCClassMethod>> &GetMethods();
+  const std::unique_ptr<BCAnnotationsDirectory> &GetAnnotationsDirectory() const;
+
+ protected:
+  bool isInterface = false;
+  bool isMultiDef = false;
+  uint32 classIdx;
+  uint32 srcFileIdx = 0;
+  uint32 accFlag = 0;
+  GStrIdx classNameOrinIdx;
+  GStrIdx classNameMplIdx;
+  GStrIdx srcFileNameIdx;
+  GStrIdx irSrcFileSigIdx;
+  const BCParserBase &parser;
+  std::list<std::string> superClassNameList;
+  std::vector<std::string> interfaces;
+  std::vector<std::unique_ptr<BCClassField>> fields;
+  std::vector<std::unique_ptr<BCClassMethod>> methods;
+  std::unique_ptr<BCAnnotationsDirectory> annotationsDirectory;
+  std::vector<MIRConst*> staticFieldsConstVal;
+  std::vector<uint32> finalStaticStringID;
+  BCAttrMap attrMap;
+  std::string filePathName;
+  mutable std::mutex bcClassMtx;
+};
+}
+}
+#endif // HIR2MPL_BC_INPUT_INCLUDE_BC_CLASS_H
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_class2fe_helper.h b/src/hir2mpl/bytecode_input/common/include/bc_class2fe_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..a66b6e6b5ed3a007f60e90b80dbe53c297fbe349
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_class2fe_helper.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_CLASS2FE_HELPER_H
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_CLASS2FE_HELPER_H
+#include "fe_input_helper.h"
+#include "bc_class.h"
+#include "bc_pragma.h"
+namespace maple {
+namespace bc {
+class BCClass2FEHelper : public FEInputStructHelper {
+ public:
+  BCClass2FEHelper(MapleAllocator &allocator, BCClass &klassIn);
+  ~BCClass2FEHelper() = default;
+
+ protected:
+  std::string GetStructNameOrinImpl() const override;
+  std::string GetStructNameMplImpl() const override;
+  std::list<std::string> GetSuperClassNamesImpl() const override;
+  std::vector<std::string> GetInterfaceNamesImpl() const override;
+  std::string GetSourceFileNameImpl() const override;
+  MIRStructType *CreateMIRStructTypeImpl(bool &error) const override;
+  uint64 GetRawAccessFlagsImpl() const override;
+  GStrIdx GetIRSrcFileSigIdxImpl() const override;
+  bool IsMultiDefImpl() const override;
+  std::string GetSrcFileNameImpl() const override;
+
+  BCClass &klass;
+
+ private:
+  void TryMarkMultiDefClass(MIRStructType &typeImported) const;
+};
+
+class BCClassField2FEHelper : public FEInputFieldHelper {
+ public:
+  BCClassField2FEHelper(MapleAllocator &allocator, const BCClassField &fieldIn)
+      : FEInputFieldHelper(allocator),
+        field(fieldIn) {}
+  ~BCClassField2FEHelper() = default;
+  FieldAttrs AccessFlag2Attribute(uint32 accessFlag) const;
+
+ protected:
+  virtual FieldAttrs AccessFlag2AttributeImpl(uint32 accessFlag) const = 0;
+  bool ProcessDeclImpl(MapleAllocator &allocator) override;
+  bool ProcessDeclWithContainerImpl(MapleAllocator &allocator) override;
+  const BCClassField &field;
+};
+
+class BCClassMethod2FEHelper : public FEInputMethodHelper {
+ public:
+  BCClassMethod2FEHelper(MapleAllocator &allocator, std::unique_ptr<BCClassMethod> &methodIn);
+  ~BCClassMethod2FEHelper() = default;
+  std::unique_ptr<BCClassMethod> &GetMethod() const {
+    return method;
+  }
+
+ protected:
+  bool ProcessDeclImpl(MapleAllocator &allocator) override;
+  void SolveReturnAndArgTypesImpl(MapleAllocator &allocator) override;
+  std::string GetMethodNameImpl(bool inMpl, bool full) const override;
+  bool IsVargImpl() const override;
+  bool HasThisImpl() const override;
+  MIRType *GetTypeForThisImpl() const override;
+
+  virtual bool IsClinit() const = 0;
+  virtual bool IsInit() const = 0;
+  bool IsVirtualImpl() const override;
+  bool IsNativeImpl() const override;
+  bool HasCodeImpl() const override;
+
+  std::unique_ptr<BCClassMethod> &method;
+};
+
+class BCInputPragmaHelper : public FEInputPragmaHelper {
+ public:
+  BCInputPragmaHelper(BCAnnotationsDirectory &bcAnnotationsDirectoryIn)
+      : bcAnnotationsDirectory(bcAnnotationsDirectoryIn) {}
+  virtual ~BCInputPragmaHelper() = default;
+
+ protected:
+  std::vector<MIRPragma*> &GenerateMIRPragmasImpl() override {
+    return bcAnnotationsDirectory.EmitPragmas();
+  }
+
+ private:
+  BCAnnotationsDirectory &bcAnnotationsDirectory;
+};
+}  // namespace bc
+}  // namespace maple
+#endif // HIR2MPL_BC_INPUT_INCLUDE_BC_CLASS2FE_HELPER_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_compiler_component-inl.h b/src/hir2mpl/bytecode_input/common/include/bc_compiler_component-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..4cc8a3fa7c6cd26bd7bd96bede8cc21af1549d75
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_compiler_component-inl.h
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_COMPILER_COMPONENT_INL_H_
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_COMPILER_COMPONENT_INL_H_
+#include "bc_compiler_component.h"
+#include "fe_timer.h"
+#include "bc_function.h"
+#include "dex_class2fe_helper.h"
+#include "fe_manager.h"
+#include "class_loader_context.h"
+#include "class_linker.h"
+
+namespace maple {
+namespace bc {
+template <class T>
+BCCompilerComponent<T>::BCCompilerComponent(MIRModule &module)
+    : HIR2MPLCompilerComponent(module, kSrcLangJava),
+      mp(FEUtils::NewMempool("MemPool for BCCompilerComponent", false /* isLcalPool */)),
+      allocator(mp),
+      bcInput(std::make_unique<bc::BCInput<T>>(module)) {}
+
+template <class T>
+BCCompilerComponent<T>::~BCCompilerComponent() {
+  mp = nullptr;
+}
+
+template <class T>
+bool BCCompilerComponent<T>::ParseInputImpl() {
+  FETimer timer;
+  bool success = true;
+  timer.StartAndDump("BCCompilerComponent::ParseInput()");
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process BCCompilerComponent::ParseInput() =====");
+  const std::list<std::string> &inputClassNames = {};
+  std::vector<std::string> inputNames;
+  if (typeid(T) == typeid(DexReader)) {
+    inputNames = FEOptions::GetInstance().GetInputDexFiles();
+  } else {
+    CHECK_FATAL(false, "Reader is not supported. Exit.");
+  }
+  success = success && bcInput->ReadBCFiles(inputNames, inputClassNames);
+  CHECK_FATAL(success, "BCCompilerComponent::ParseInput failed. Exit.");
+  bc::BCClass *klass = bcInput->GetFirstClass();
+  while (klass != nullptr) {
+    if (typeid(T) == typeid(DexReader)) {
+      FEInputStructHelper *structHelper = allocator.GetMemPool()->template New<DexClass2FEHelper>(allocator, *klass);
+      FEInputPragmaHelper *pragmaHelper =
+          allocator.GetMemPool()->template New<BCInputPragmaHelper>(*(klass->GetAnnotationsDirectory()));
+      structHelper->SetPragmaHelper(pragmaHelper);
+      structHelper->SetStaticFieldsConstVal(klass->GetStaticFieldsConstVal());
+      structHelpers.push_back(structHelper);
+    } else {
+      CHECK_FATAL(false, "Reader is not supported. Exit.");
+    }
+    klass = bcInput->GetNextClass();
+  }
+  timer.StopAndDumpTimeMS("BCCompilerComponent::ParseInput()");
+  return success;
+}
+
+template <class T>
+bool BCCompilerComponent<T>::LoadOnDemandTypeImpl() {
+  FETimer timer;
+  bool success = true;
+  timer.StartAndDump("BCCompilerComponent::LoadOnDemandType()");
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process BCCompilerComponent::LoadOnDemandType() =====");
+  // Collect dependent type names in dexfile
+  std::unordered_set<std::string> allDepSet;
+  success = success && bcInput->CollectDependentTypeNamesOnAllBCFiles(allDepSet);
+  CHECK_FATAL(success, "BCCompilerComponent::CollectDepTypeNames failed. Exit.");
+  // Collect class def type names in dexfile
+  std::unordered_set<std::string> allClassSet;
+  success = success && bcInput->CollectClassNamesOnAllBCFiles(allClassSet);
+  // Find dependent types and resolve types to bcClasses
+  std::list<std::unique_ptr<bc::BCClass>> klassList;
+  success = success && LoadOnDemandType2BCClass(allDepSet, allClassSet, klassList);
+  // All dependent bcClasses are loaded into the mir globaltable and used like mplt
+  std::list<std::unique_ptr<FEInputStructHelper>> structHelpers;
+  success = success && LoadOnDemandBCClass2FEClass(klassList, structHelpers, !FEOptions::GetInstance().IsNoMplFile());
+  timer.StopAndDumpTimeMS("BCCompilerComponent::LoadOnDemandType()");
+  return success;
+}
+
+template <class T>
+bool BCCompilerComponent<T>::LoadOnDemandType2BCClass(const std::unordered_set<std::string> &allDepsSet,
+                                                      const std::unordered_set<std::string> &allDefsSet,
+                                                      std::list<std::unique_ptr<bc::BCClass>> &klassList) {
+  FETimer timer;
+  timer.StartAndDump("LoadOnDemandType2BCClass::Open dep dexfiles");
+  bool success = true;
+  ClassLoaderContext *classLoaderContext = nullptr;
+  const ClassLoaderInfo *classLoader = nullptr;
+  std::vector<std::unique_ptr<bc::DexParser>> bootClassPaths;
+  std::string spec = FEOptions::GetInstance().GetXBootClassPath();
+  if (!spec.empty()) {  // Xbootclasspath
+    INFO(kLncInfo, "XBootClassPath=%s", spec.c_str());
+    success = success && ClassLoaderContext::OpenDexFiles(spec, bootClassPaths);
+  }
+  spec = FEOptions::GetInstance().GetClassLoaderContext();
+  if (!spec.empty()) {  // PCL
+    INFO(kLncInfo, "PCL=%s", spec.c_str());
+    classLoaderContext = ClassLoaderContext::Create(spec, *mp);
+    if (classLoaderContext != nullptr) {
+      classLoader = classLoaderContext->GetClassLoader();
+    }
+  }
+  timer.StopAndDumpTimeMS("LoadOnDemandType2BCClass::Open dep dexfiles");
+  ClassLinker *classLinker = mp->New<ClassLinker>(bootClassPaths);
+  for (const std::string &className : allDepsSet) {
+    classLinker->FindClass(className, nullptr, klassList);
+  }
+  // if same class name is existed in src dexFile and dependent set, import class from dependent set preferentially
+  for (const std::string &className : allDefsSet) {
+    classLinker->FindClass(className, nullptr, klassList, true);
+  }
+  return success;
+}
+
+template <class T>
+bool BCCompilerComponent<T>::LoadOnDemandBCClass2FEClass(
+    const std::list<std::unique_ptr<bc::BCClass>> &klassList,
+    std::list<std::unique_ptr<FEInputStructHelper>> &structHelpers,
+    bool isEmitDepsMplt) {
+  for (const std::unique_ptr<bc::BCClass> &klass : klassList) {
+    std::unique_ptr<FEInputStructHelper> structHelper = std::make_unique<bc::DexClass2FEHelper>(allocator, *klass);
+    FEInputPragmaHelper *pragmaHelper =
+        allocator.GetMemPool()->template New<bc::BCInputPragmaHelper>(*(klass->GetAnnotationsDirectory()));
+    structHelper->SetPragmaHelper(pragmaHelper);
+    structHelper->SetIsOnDemandLoad(true);
+    structHelpers.push_back(std::move(structHelper));
+  }
+  for (std::unique_ptr<FEInputStructHelper> const &helper : structHelpers) {
+    ASSERT_NOT_NULL(helper);
+    (void)helper->PreProcessDecl();
+  }
+  for (std::unique_ptr<FEInputStructHelper> const &helper : structHelpers) {
+    ASSERT_NOT_NULL(helper);
+    (void)helper->ProcessDecl();
+    helper->ProcessPragma();
+  }
+  if (isEmitDepsMplt) {
+    std::string outName = module.GetFileName();
+    size_t lastDot = outName.find_last_of(".");
+    std::string outNameWithoutType;
+    if (lastDot == std::string::npos) {
+      outNameWithoutType = outName;
+    } else {
+      outNameWithoutType = outName.substr(0, lastDot);
+    }
+    std::string depFileName = outNameWithoutType + ".Deps.mplt";
+    module.GetImportFiles().push_back(module.GetMIRBuilder()->GetOrCreateStringIndex(depFileName));
+    module.DumpToHeaderFile(!FEOptions::GetInstance().IsGenAsciiMplt(), depFileName);
+  }
+  FEOptions::ModeDepSameNamePolicy mode = FEOptions::GetInstance().GetModeDepSameNamePolicy();
+  switch (mode) {
+    case FEOptions::ModeDepSameNamePolicy::kSys:
+      // Set kSrcMpltSys flag, loading on-demand dependent types from system
+      FEManager::GetTypeManager().SetMirImportedTypes(FETypeFlag::kSrcMpltSys);
+      break;
+    case FEOptions::ModeDepSameNamePolicy::kSrc:
+      // Set kSrcMplt flag, same name types are then overridden from src file after loaded on-demand dependent type
+      FEManager::GetTypeManager().SetMirImportedTypes(FETypeFlag::kSrcMplt);
+      break;
+  }
+  for (uint32 i = 1; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbol(i);
+    if ((symbol != nullptr) && (symbol->GetSKind() == kStFunc)) {
+      symbol->SetIsImportedDecl(true);
+    }
+  }
+  return true;
+}
+
+template <class T>
+void BCCompilerComponent<T>::ProcessPragmaImpl() {
+  FETimer timer;
+  timer.StartAndDump("BCCompilerComponent::ProcessPragmaImpl()");
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process BCCompilerComponent::ProcessPragmaImpl() =====");
+  for (FEInputStructHelper *helper : structHelpers) {
+    ASSERT_NOT_NULL(helper);
+    helper->ProcessPragma();
+  }
+  timer.StopAndDumpTimeMS("BCCompilerComponent::ProcessPragmaImpl()");
+}
+
+template <class T>
+std::unique_ptr<FEFunction> BCCompilerComponent<T>::CreatFEFunctionImpl(FEInputMethodHelper *methodHelper) {
+  BCClassMethod2FEHelper *bcMethodHelper = static_cast<BCClassMethod2FEHelper*>(methodHelper);
+  GStrIdx methodNameIdx = methodHelper->GetMethodNameIdx();
+  bool isStatic = methodHelper->IsStatic();
+  MIRFunction *mirFunc = FEManager::GetTypeManager().GetMIRFunction(methodNameIdx, isStatic);
+  CHECK_NULL_FATAL(mirFunc);
+  std::unique_ptr<FEFunction> feFunction = std::make_unique<BCFunction>(*bcMethodHelper, *mirFunc, phaseResultTotal);
+  module.AddFunction(mirFunc);
+  feFunction->Init();
+  return feFunction;
+}
+
+template <class T>
+std::string BCCompilerComponent<T>::GetComponentNameImpl() const {
+  return "BCCompilerComponent";
+}
+
+template <class T>
+bool BCCompilerComponent<T>::ParallelableImpl() const {
+  return true;
+}
+
+template <class T>
+void BCCompilerComponent<T>::DumpPhaseTimeTotalImpl() const {
+  INFO(kLncInfo, "[PhaseTime] BCCompilerComponent");
+  HIR2MPLCompilerComponent::DumpPhaseTimeTotalImpl();
+}
+
+template <class T>
+void BCCompilerComponent<T>::ReleaseMemPoolImpl() {
+  FEUtils::DeleteMempoolPtr(mp);
+}
+}  // namespace bc
+}  // namespace maple
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_BC_COMPILER_COMPONENT_INL_H_
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_compiler_component.h b/src/hir2mpl/bytecode_input/common/include/bc_compiler_component.h
new file mode 100644
index 0000000000000000000000000000000000000000..b243f570e03f64974d57be3663b74416d8b9bfec
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_compiler_component.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_COMPILER_COMPONENT_H
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_COMPILER_COMPONENT_H
+#include "fe_macros.h"
+#include "hir2mpl_compiler_component.h"
+#include "bc_input.h"
+
+namespace maple {
+namespace bc {
+template <class T>
+class BCCompilerComponent : public HIR2MPLCompilerComponent {
+ public:
+  explicit BCCompilerComponent(MIRModule &module);
+  ~BCCompilerComponent() override;
+
+ protected:
+  bool ParseInputImpl() override;
+  bool LoadOnDemandTypeImpl() override;
+  void ProcessPragmaImpl() override;
+  std::unique_ptr<FEFunction> CreatFEFunctionImpl(FEInputMethodHelper *methodHelper) override;
+  std::string GetComponentNameImpl() const override;
+  bool ParallelableImpl() const override;
+  void DumpPhaseTimeTotalImpl() const override;
+  void ReleaseMemPoolImpl() override;
+
+ private:
+  bool LoadOnDemandType2BCClass(const std::unordered_set<std::string> &allDepsSet,
+                                const std::unordered_set<std::string> &allDefsSet,
+                                std::list<std::unique_ptr<bc::BCClass>> &klassList);
+  bool LoadOnDemandBCClass2FEClass(const std::list<std::unique_ptr<bc::BCClass>> &klassList,
+                                   std::list<std::unique_ptr<FEInputStructHelper>> &structHelpers,
+                                   bool isEmitDepsMplt);
+
+  MemPool *mp;
+  MapleAllocator allocator;
+  std::unique_ptr<bc::BCInput<T>> bcInput;
+};  // class BCCompilerComponent
+}  // namespace bc
+}  // namespace maple
+#include "bc_compiler_component-inl.h"
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_BC_COMPILER_COMPONENT_H
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_function.h b/src/hir2mpl/bytecode_input/common/include/bc_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..dedebf5387aeb9a1a17328c4820314f5a31944c0
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_function.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_BC_INPUT_BC_FUNTION_H
+#define MPL_FE_BC_INPUT_BC_FUNTION_H
+#include "fe_function.h"
+#include "bc_class2fe_helper.h"
+
+namespace maple {
+namespace bc {
+class BCFunction : public FEFunction {
+ public:
+  BCFunction(const BCClassMethod2FEHelper &argMethodHelper, MIRFunction &mirFunc,
+              const std::unique_ptr<FEFunctionPhaseResult> &argPhaseResultTotal);
+  virtual ~BCFunction() = default;
+
+ protected:
+  bool GenerateGeneralStmt(const std::string &phaseName) override {
+    WARN(kLncWarn, "Phase: %s may not need.", phaseName.c_str());
+    return true;
+  }
+
+  bool GenerateArgVarList(const std::string &phaseName) override;
+  bool GenerateAliasVars(const std::string &phaseName) override;
+
+  bool PreProcessTypeNameIdx() override {
+    return true;
+  }
+
+  void GenerateGeneralStmtFailCallBack() override {}
+
+  void GenerateGeneralDebugInfo() override {}
+
+  bool VerifyGeneral() override {
+    return true;
+  }
+
+  void VerifyGeneralFailCallBack() override {}
+
+  bool HasThis() override {
+    return methodHelper.HasThis();
+  }
+
+  bool IsNative() override {
+    return methodHelper.IsNative();
+  }
+
+  bool EmitToFEIRStmt(const std::string &phaseName) override;
+
+  void InitImpl() override;
+  void SetMIRFunctionInfo();
+  void PreProcessImpl() override;
+  bool ProcessImpl() override;
+  bool ProcessFEIRFunction() override;
+  void FinishImpl() override;
+  bool EmitToMIR(const std::string &phaseName) override;
+
+  const BCClassMethod2FEHelper &methodHelper;
+  std::unique_ptr<BCClassMethod> &method;
+  bool error = false;
+};
+}  // namespace bc
+}  // namespace maple
+#endif
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_input-inl.h b/src/hir2mpl/bytecode_input/common/include/bc_input-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a211e390462fc8ecb5d6ecdb0d55f713e693eb2
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_input-inl.h
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_INPUT_INL_H_
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_INPUT_INL_H_
+#include "bc_input.h"
+#include <typeinfo>
+#include "dex_parser.h"
+#include "hir2mpl_env.h"
+
+namespace maple {
+namespace bc {
+template <class T>
+bool BCInput<T>::ReadBCFile(uint32 index, const std::string &fileName, const std::list<std::string> &classNamesIn) {
+  std::unique_ptr<BCParserBase> bcParser;
+  if (typeid(T) == typeid(DexReader)) {
+    bcParser = std::make_unique<DexParser>(index, fileName, classNamesIn);
+  } else {
+    CHECK_FATAL(false, "Unsupported BC reader: %s in BCInput", typeid(T).name());
+  }
+  if (!bcParser->OpenFile()) {
+    return false;
+  }
+  if (!bcParser->ParseHeader()) {
+    ERR(kLncErr, "Parse Header failed in : %s.", fileName.c_str());
+    return false;
+  }
+  if (!bcParser->Verify()) {
+    ERR(kLncErr, "Verify file failed in : %s.", fileName.c_str());
+    return false;
+  }
+  if (bcParser->RetrieveClasses(bcClasses) == false) {
+    ERR(kLncErr, "Retrieve classes failed in : %s.", fileName.c_str());
+    return false;
+  }
+  (void)bcParserMap.insert(std::make_pair(fileName, std::move(bcParser)));
+  return true;
+}
+
+template <class T>
+bool BCInput<T>::ReadBCFiles(const std::vector<std::string> &fileNames, const std::list<std::string> &classNamesIn) {
+  for (uint32 i = 0; i < fileNames.size(); ++i) {
+    if (BCInput<T>::ReadBCFile(i, fileNames[i], classNamesIn) == false) {
+      return false;
+    }
+    RegisterFileInfo(fileNames[i]);
+  }
+  return true;
+}
+
+template <class T>
+BCClass *BCInput<T>::GetFirstClass() {
+  if (bcClasses.size() == 0) {
+    return nullptr;
+  }
+  itKlass = bcClasses.begin();
+  return itKlass->get();
+}
+
+template <class T>
+BCClass *BCInput<T>::GetNextClass() {
+  if (itKlass == bcClasses.end()) {
+    return nullptr;
+  }
+  ++itKlass;
+  if (itKlass == bcClasses.end()) {
+    return nullptr;
+  }
+  return itKlass->get();
+}
+
+template <class T>
+void BCInput<T>::RegisterFileInfo(const std::string &fileName) {
+  GStrIdx fileNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fileName);
+  GStrIdx fileInfoIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_filename");
+  module.PushFileInfoPair(MIRInfoPair(fileInfoIdx, fileNameIdx));
+  module.PushFileInfoIsString(true);
+}
+
+template <class T>
+bool BCInput<T>::CollectDependentTypeNamesOnAllBCFiles(std::unordered_set<std::string> &allDepSet) {
+  FEOptions::ModeCollectDepTypes mode = FEOptions::GetInstance().GetModeCollectDepTypes();
+  bool isSuccess = true;
+  switch (mode) {
+    case FEOptions::ModeCollectDepTypes::kAll:
+      isSuccess = CollectAllDepTypeNamesOnAllBCFiles(allDepSet);
+      break;
+    case FEOptions::ModeCollectDepTypes::kFunc:
+      isSuccess = CollectMethodDepTypeNamesOnAllBCFiles(allDepSet);
+      break;
+  }
+  return isSuccess;
+}
+
+template <class T>
+bool BCInput<T>::CollectAllDepTypeNamesOnAllBCFiles(std::unordered_set<std::string> &allDepSet) {
+  for (auto &item : bcParserMap) {
+    std::unordered_set<std::string> depSet;
+    if (item.second->CollectAllDepTypeNames(depSet) == false) {
+      ERR(kLncErr, "Collect all dependent typenames failed in : %s.", item.first.c_str());
+      return false;
+    }
+    allDepSet.insert(depSet.cbegin(), depSet.cend());
+  }
+  BCUtil::AddDefaultDepSet(allDepSet);  // allDepSet is equal to "DefaultTypeSet + TypeSet - ClassSet"
+  std::unordered_set<std::string> classSet;
+  (void)CollectClassNamesOnAllBCFiles(classSet);
+  for (const auto &elem : classSet) {
+    (void)allDepSet.erase(elem);
+  }
+  return true;
+}
+
+template <class T>
+bool BCInput<T>::CollectMethodDepTypeNamesOnAllBCFiles(std::unordered_set<std::string> &depSet) {
+  bool isSuccess = true;
+  for (const std::unique_ptr<BCClass> &klass : bcClasses) {
+    if (klass == nullptr) {
+      continue;
+    }
+    std::list<std::string> superClassNames = klass->GetSuperClassNames();
+    depSet.insert(superClassNames.cbegin(), superClassNames.cend());
+    std::vector<std::string> superInterfaceNames = klass->GetSuperInterfaceNames();
+    depSet.insert(superInterfaceNames.cbegin(), superInterfaceNames.cend());
+    for (const std::unique_ptr<BCClassMethod> &method : klass->GetMethods()) {
+      if (method == nullptr) {
+        continue;
+      }
+      (void)klass->GetBCParser().CollectMethodDepTypeNames(depSet, *method);
+    }
+  }
+  std::unordered_set<std::string> classSet;
+  isSuccess = isSuccess && CollectClassNamesOnAllBCFiles(classSet);
+  BCUtil::AddDefaultDepSet(depSet);  // DepSet is equal to "DefaultTypeSet + TypeSet - ClassSet"
+  for (const auto &elem : classSet) {
+    (void)depSet.erase(elem);
+  }
+  return isSuccess;
+}
+
+template <class T>
+bool BCInput<T>::CollectClassNamesOnAllBCFiles(std::unordered_set<std::string> &allClassSet) {
+  for (auto &item : bcParserMap) {
+    std::unordered_set<std::string> classSet;
+    if (item.second->CollectAllClassNames(classSet) == false) {
+      ERR(kLncErr, "Collect all class names failed in : %s.", item.first.c_str());
+      return false;
+    }
+    allClassSet.insert(classSet.cbegin(), classSet.cend());
+  }
+  return true;
+}
+}  // namespace bc
+}  // namespace maple
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_BC_INPUT_INL_H_
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_input.h b/src/hir2mpl/bytecode_input/common/include/bc_input.h
new file mode 100644
index 0000000000000000000000000000000000000000..21d657fc3a5de219f8212f22e7e8252d394159f3
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_input.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_INPUT_H
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_INPUT_H
+#include <string>
+#include <list>
+#include "mir_module.h"
+#include "bc_class.h"
+#include "bc_parser.h"
+
+namespace maple {
+namespace bc {
+template <class T>
+class BCInput {
+ public:
+  explicit BCInput(MIRModule &moduleIn) : module(moduleIn) {}
+  ~BCInput() = default;
+  bool ReadBCFile(uint32 index, const std::string &fileName, const std::list<std::string> &classNamesIn);
+  bool ReadBCFiles(const std::vector<std::string> &fileNames, const std::list<std::string> &classNamesIn);
+  const MIRModule &GetModule() const {
+    return module;
+  }
+  BCClass *GetFirstClass();
+  BCClass *GetNextClass();
+  void RegisterFileInfo(const std::string &fileName);
+  bool CollectDependentTypeNamesOnAllBCFiles(std::unordered_set<std::string> &allDepSet);
+  bool CollectClassNamesOnAllBCFiles(std::unordered_set<std::string> &allClassSet);
+
+ private:
+  bool CollectAllDepTypeNamesOnAllBCFiles(std::unordered_set<std::string> &allDepSet);
+  bool CollectMethodDepTypeNamesOnAllBCFiles(std::unordered_set<std::string> &allDepSet);
+
+  std::map<std::string, std::unique_ptr<BCParserBase>> bcParserMap;  // map<filename, BCParser>
+  MIRModule &module;
+
+  std::list<std::unique_ptr<BCClass>> bcClasses;
+  std::list<std::unique_ptr<BCClass>>::const_iterator itKlass;
+};
+}
+}
+#include "bc_input-inl.h"
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_BC_INPUT_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_instruction.h b/src/hir2mpl/bytecode_input/common/include/bc_instruction.h
new file mode 100644
index 0000000000000000000000000000000000000000..3673af772a73cad84d8084a2cf8de16bf4896d97
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_instruction.h
@@ -0,0 +1,448 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_INSTRUCTION_H
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_INSTRUCTION_H
+#include <string>
+#include <tuple>
+#include "types_def.h"
+#include "bc_util.h"
+#include "feir_stmt.h"
+#include "feir_var_reg.h"
+
+namespace maple {
+namespace bc {
+class BCClassMethod;
+struct BCReg;
+class BCInstruction {
+ public:
+  BCInstruction(MapleAllocator &allocatorIn, uint32 pcIn, uint8 opcodeIn)
+      : opcode(opcodeIn),
+        pc(pcIn),
+        allocator(allocatorIn),
+        catchedExTypeNamesIdx(allocator.Adapter()),
+        handlerTargets(allocator.Adapter()),
+        defedRegs(allocator.Adapter()),
+        usedRegs(allocator.Adapter()),
+        handlers(allocator.Adapter()) {}
+  virtual ~BCInstruction() = default;
+  void InitBCInStruction(uint16 kind, bool wide, bool throwable);
+  BCInstructionKind GetInstKind() const;
+  bool IsWide() const;
+  void SetInstructionKind(BCInstructionKind kind);
+  bool IsConditionBranch() const;
+  bool IsGoto() const;
+  bool IsSwitch() const;
+  bool IsTarget() const;
+  bool IsTryStart() const;
+  bool IsTryEnd() const;
+  bool IsCatch() const;
+  void SetReturnInst(BCInstruction *inst);
+  bool HasReturn() const;
+  bool IsReturn() const;
+  uint32 GetPC() const;
+  uint8 GetOpcode() const;
+  std::vector<uint32> GetTargets() const;
+  void SetDefaultTarget(BCInstruction *inst);
+  void AddHandler(BCInstruction *handler);
+  void SetWidth(uint8 size);
+  uint8 GetWidth() const;
+  void SetCatchable();
+  bool IsCatchable() const;
+  bool IsFallThru() const;
+  void SetBCRegType(const BCInstruction &inst);
+  void AddHandlerTarget(uint32 target);
+  MapleVector<uint32> GetHandlerTargets() const;
+  MapleList<BCReg*> *GetDefedRegs();
+  MapleList<BCReg*> *GetUsedRegs();
+  void SetRegTypeInTypeInfer();
+  void SetFuncNameIdx(const GStrIdx &methodIdx);
+  void SetSrcPositionInfo(uint32 fileIdxIn, uint32 lineNumIn);
+  void SetOpName(const char *name);
+  const char *GetOpName() const;
+  void Parse(BCClassMethod &method);
+  void SetExceptionType(const GStrIdx &typeNameIdx);
+  std::list<UniqueFEIRStmt> EmitToFEIRStmts();
+
+ protected:
+  virtual std::vector<uint32> GetTargetsImpl() const;
+  virtual void ParseImpl(BCClassMethod &method) = 0;
+  virtual std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() = 0;
+  void GenCommentStmt(std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRStmt GenLabelStmt() const;
+  UniqueFEIRStmt GenCatchStmt() const;
+  UniqueFEIRStmt GenTryLabelStmt() const;
+  UniqueFEIRStmt GenTryEndLabelStmt() const;
+  virtual void SetRegTypeInTypeInferImpl() {}
+  virtual void SetBCRegTypeImpl(const BCInstruction &inst) {
+    (void) inst;
+  }  // for move-result and move-exception
+  std::list<UniqueFEIRStmt> GenRetypeStmtsAfterDef() const;
+  std::list<UniqueFEIRStmt> GenRetypeStmtsBeforeUse() const;
+  void SetSrcFileInfo(std::list<UniqueFEIRStmt> &stmts) const;
+  bool isThrowable = false;
+  bool isWide = false;
+  bool isReturn = false;
+  bool isCatchable = false;
+  uint8 width = UINT8_MAX;  // Default value, unuseable
+  uint8 opcode;
+  BCInstructionKind instKind = kUnKnownKind;
+  uint32 funcNameIdx = UINT32_MAX;
+  uint32 srcFileIdx = 0;
+  uint32 srcFileLineNum = 0;
+  uint32 pc;
+#ifdef DEBUG
+  const char *opName = nullptr;
+#endif
+  BCInstruction *returnInst = nullptr;
+  BCInstruction *defaultTarget = nullptr;
+  MapleAllocator &allocator;
+  MapleSet<GStrIdx> catchedExTypeNamesIdx;
+  MapleVector<uint32> handlerTargets; // This instruction may throw exception and reach these handlers
+  MapleList<BCReg*> defedRegs;
+  MapleList<BCReg*> usedRegs;
+  MapleList<BCInstruction*> handlers;
+};
+
+// Forward declaration
+struct BCReg;
+struct TypeInferItem;
+
+struct BCRegTypeItem {
+  BCRegTypeItem(const GStrIdx &idx, bool isIndeterminateIn = false, bool isFromDefIn = false)
+      : typeNameIdx(idx),
+        isIndeterminate(isIndeterminateIn),
+        isFromDef(isFromDefIn) {}
+  BCRegTypeItem(const BCRegTypeItem &item)
+      : typeNameIdx(item.typeNameIdx),
+        isIndeterminate(item.isIndeterminate) {}
+  ~BCRegTypeItem() = default;
+
+  PrimType GetPrimType() const;
+  PrimType GetBasePrimType() const;
+  BCRegTypeItem *Clone(const MapleAllocator &allocator) {
+    return allocator.GetMemPool()->New<BCRegTypeItem>(typeNameIdx, isIndeterminate);
+  }
+
+  void Copy(const BCRegTypeItem &src) {
+    typeNameIdx = src.typeNameIdx;
+    isIndeterminate = src.isIndeterminate;
+    isFromDef = src.isFromDef;
+  }
+  bool operator==(const BCRegTypeItem &item) const {
+    return typeNameIdx == item.typeNameIdx;
+  }
+
+  bool IsRef() const {
+    return GetPrimType() == PTY_ref;
+  }
+
+  bool IsMorePreciseType(const BCRegTypeItem &typeItemIn) const;
+
+  // for debug
+  void DumpTypeName() const {
+    LogInfo::MapleLogger(kLlDbg) << GlobalTables::GetStrTable().GetStringFromStrIdx(typeNameIdx) << "\n";
+  }
+
+  void SetPos(uint32 pc) {
+    pos = pc;
+  }
+
+  void SetDom(bool flag) {
+    isDom = flag;
+  }
+
+  bool IsDom() const {
+    return isDom;
+  }
+
+  GStrIdx typeNameIdx;
+  bool isIndeterminate = false;
+  // means `is def ` or `come from def`
+  bool isFromDef = false;
+  uint32 pos = UINT32_MAX;
+
+  bool isDom = false;
+};
+
+class BCRegType {
+ public:
+  BCRegType(MapleAllocator &allocatorIn, BCReg &reg, const GStrIdx &typeNameIdxIn, bool isIndeterminateIn = false);
+  ~BCRegType() = default;
+  MapleAllocator &GetAllocator() {
+    return allocator;
+  }
+
+  void SetTypeNameIdx(const GStrIdx &idx) const {
+    regTypeItem->typeNameIdx = idx;
+  }
+
+  bool IsIndeterminate() const {
+    return regTypeItem->isIndeterminate;
+  }
+
+  void SetIsIndeterminate(bool flag) const {
+    regTypeItem->isIndeterminate = flag;
+  }
+
+  static void InsertUniqueTypeItem(MapleList<BCRegTypeItem*> &itemSet, BCRegTypeItem *item) {
+    for (auto const &elem : itemSet) {
+      if ((!elem->isIndeterminate && !item->isIndeterminate && (*elem) == (*item)) || elem == item) {
+        return;
+      }
+    }
+    itemSet.emplace_back(item);
+  }
+
+  void UpdateUsedSet(BCRegTypeItem *typeItem) {
+    if (typeItem->isIndeterminate) {
+      InsertUniqueTypeItem(fuzzyTypesUsedAs, typeItem);
+    }
+    InsertUniqueTypeItem(*typesUsedAs, typeItem);
+  }
+
+  void UpdateFuzzyUsedSet(BCRegTypeItem *typeItem) {
+    if (typeItem->isIndeterminate) {
+      InsertUniqueTypeItem(fuzzyTypesUsedAs, typeItem);
+    }
+  }
+
+  void SetRegTypeItem(BCRegTypeItem *item) {
+    regTypeItem = item;
+  }
+
+  const BCRegTypeItem *GetRegTypeItem() const {
+    return regTypeItem;
+  }
+
+  MapleList<BCRegTypeItem*> *GetUsedTypes() {
+    return typesUsedAs;
+  }
+
+  void PrecisifyTypes(bool isTry = false);
+
+  void PrecisifyRelatedTypes(const BCRegTypeItem *realType);
+
+  void PrecisifyElemTypes(const BCRegTypeItem *realType);
+
+  bool IsPrecisified() const {
+    return precisified;
+  }
+
+  static BCRegTypeItem *GetMostPreciseType(const MapleList<BCRegTypeItem*> &types);
+
+  void AddElemType(BCRegTypeItem *item) {
+    elemTypes.emplace(item);
+  }
+
+  void SetUsedTypes(MapleList<BCRegTypeItem*> *types) {
+    typesUsedAs = types;
+  }
+
+  void SetPos(uint32 pc) {
+    pos = pc;
+  }
+
+  uint32 GetPos() const {
+    return pos;
+  }
+
+  void RegisterRelatedBCRegType(BCRegType *ty) {
+    relatedBCRegTypes.emplace_back(ty);
+  }
+
+  void RegisterLivesInfo(uint32 posStart) {
+    livesBegins.emplace_back(posStart);
+  }
+
+  bool IsBefore(uint32 posCurr, uint32 end) const {
+    for (auto p : livesBegins) {
+      if (p == posCurr) {
+        return true;
+      }
+      if (p == end) {
+        return false;
+      }
+    }
+    CHECK_FATAL(false, "Should not get here.");
+    return true;
+  }
+
+ private:
+  MapleAllocator &allocator;
+  BCReg &curReg;
+  BCRegTypeItem *regTypeItem;
+  MapleList<BCRegTypeItem*> *typesUsedAs = nullptr;
+  MapleList<BCRegTypeItem*> fuzzyTypesUsedAs;
+  bool precisified = false;
+  MapleSet<BCRegTypeItem*> elemTypes;
+  uint32 pos = UINT32_MAX;
+  // `0` for args, `pc + 1` for local defs
+  MapleVector<uint32> livesBegins;
+
+  std::list<BCRegType*> relatedBCRegTypes;
+};
+
+struct BCRegValue {
+  union {
+    uint64 raw64 = 0;
+    uint32 raw32;
+  } primValue;
+};
+
+struct BCReg {
+  BCReg() = default;
+  virtual ~BCReg() = default;
+  bool isDef = false;
+  uint32 regNum = UINT32_MAX;
+  BCRegType *regType = nullptr;
+  BCRegValue *regValue = nullptr;
+  BCRegTypeItem *regTypeItem = nullptr;
+  bool IsConstZero() const;
+  UniqueFEIRType GenFEIRType() const;
+  UniqueFEIRVar GenFEIRVarReg() const;
+  std::list<UniqueFEIRStmt> GenRetypeStmtsAfterDef() const;
+  std::list<UniqueFEIRStmt> GenRetypeStmtsBeforeUse() const;
+  // a reg maybe store a primitive pointer type var.
+  // If it is a primitive ptr, GetPrimType() return a PTY_ref
+  //                           GetBasePrimType() return a corresponding prim type
+  // If it is not a primitive pointer type, GetPrimType() and GetBasePrimType() return a same PrimType.
+  PrimType GetPrimType() const;
+  PrimType GetBasePrimType() const;
+  std::unique_ptr<BCReg> Clone() const {
+    return CloneImpl();
+  }
+
+ protected:
+  virtual UniqueFEIRType GenFEIRTypeImpl() const;
+  virtual UniqueFEIRVar GenFEIRVarRegImpl() const;
+  virtual std::unique_ptr<BCReg> CloneImpl() const;
+};
+
+// for TypeInfer
+struct TypeInferItem {
+  TypeInferItem(MapleAllocator &alloc, uint32 pos, BCReg *regIn, TypeInferItem *prev)
+      : beginPos(pos),
+        prevs(alloc.Adapter()),
+        aliveUsedTypes(alloc.GetMemPool()->New<MapleList<BCRegTypeItem*>>(alloc.Adapter())),
+        reg(regIn) {
+    if (prev == nullptr) {
+      reg->regType->SetUsedTypes(aliveUsedTypes);
+    } else {
+      (void)RegisterInPrevs(prev);
+    }
+    reg->regType->RegisterLivesInfo(pos);
+  }
+
+  bool RegisterInPrevs(TypeInferItem *prev) {
+    for (auto const e : prevs) {
+      if (e == prev) {
+        return false;
+      }
+    }
+    prevs.emplace_back(prev);
+    return true;
+  }
+
+  void InsertUniqueAliveTypes(const TypeInferItem *end, const MapleList<BCRegTypeItem*> *types) {
+    if (end != nullptr && end->reg == this->reg && end->reg->regType->IsBefore(this->beginPos, end->beginPos)) {
+      return;
+    }
+    std::vector<TypeInferItem*> workList;
+    uint32 index = 0;
+    workList.emplace_back(this);
+    while (index < workList.size()) {
+      auto currItem = workList[index++];
+      currItem->isAlive = true;
+      for (auto type : *types) {
+        bool duplicate = false;
+        for (auto const ty : *(currItem->aliveUsedTypes)) {
+          if (ty == type) {
+            duplicate = true;
+            break;
+          }
+        }
+        if (!duplicate) {
+          currItem->aliveUsedTypes->emplace_back(type);
+          currItem->reg->regType->UpdateFuzzyUsedSet(type);
+        }
+      }
+      // insert into its prevs cyclely
+      for (auto const prev : currItem->prevs) {
+        if (end != nullptr && end->reg == prev->reg && end->reg->regType->IsBefore(prev->beginPos, end->beginPos)) {
+          continue;
+        }
+        bool exist = false;
+        for (uint32 i = 0; i < workList.size(); ++i) {
+          if (workList[i] == prev) {
+            exist = true;
+            break;
+          }
+        }
+        if (!exist) {
+          workList.emplace_back(prev);
+        }
+      }
+    }
+  }
+
+  void InsertUniqueAliveType(const TypeInferItem *end, BCRegTypeItem *type) {
+    if (end != nullptr && end->reg == this->reg && end->reg->regType->IsBefore(this->beginPos, end->beginPos)) {
+      return;
+    }
+    std::vector<TypeInferItem*> workList;
+    uint32 index = 0;
+    workList.emplace_back(this);
+    while (index < workList.size()) {
+      auto currItem = workList[index++];
+      currItem->isAlive = true;
+      bool duplicate = false;
+      for (auto const ty : *(currItem->aliveUsedTypes)) {
+        if (ty == type) {
+          duplicate = true;
+          break;
+        }
+      }
+      if (!duplicate) {
+        currItem->aliveUsedTypes->emplace_back(type);
+        currItem->reg->regType->UpdateFuzzyUsedSet(type);
+      }
+      // insert into its prevs cyclely
+      for (auto prev : std::as_const(currItem->prevs)) {
+        if (end != nullptr && end->reg == prev->reg && end->reg->regType->IsBefore(prev->beginPos, end->beginPos)) {
+          continue;
+        }
+        bool exist = false;
+        for (uint32 i = 0; i < workList.size(); ++i) {
+          if (workList[i] == prev) {
+            exist = true;
+            break;
+          }
+        }
+        if (!exist) {
+          workList.emplace_back(prev);
+        }
+      }
+    }
+  }
+
+  uint32 beginPos;
+  MapleList<TypeInferItem*> prevs;
+  MapleList<BCRegTypeItem*> *aliveUsedTypes = nullptr;
+  BCReg *reg = nullptr;
+  bool isAlive = false;
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_BC_INSTRUCTION_H
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_io.h b/src/hir2mpl/bytecode_input/common/include/bc_io.h
new file mode 100644
index 0000000000000000000000000000000000000000..e47cc2575371f4306a97e616350b13b9b9e3e5d9
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_io.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_BC_INPUT_BC_IO_H
+#define MPL_FE_BC_INPUT_BC_IO_H
+#include <string>
+#include "basic_io.h"
+
+namespace maple {
+namespace bc {
+class BCIO : public BasicIOMapFile {
+ public:
+  explicit BCIO(const std::string &fileName);
+  ~BCIO() = default;
+
+  static bool IsBigEndian() {
+    union {
+      uint16 v16;
+      uint8 a[sizeof(uint16) / sizeof(uint8)];
+    } u;
+    u.v16 = 0x1234;
+    return u.a[0] == 0x12;
+  }
+
+ protected:
+  bool isBigEndianHost = true;
+};
+
+struct RawData {
+  const uint8 *context;
+  uint32 size;
+};
+
+class BCReader : public BCIO, public BasicIORead {
+ public:
+  explicit BCReader(const std::string &fileName);
+  ~BCReader() override;
+  bool RetrieveHeader(RawData &data);
+  void SetEndianTag(bool isBigEndian);
+  template <typename T>
+  T GetRealInteger(T value) const {
+    if (isBigEndian == isBigEndianHost || sizeof(T) == sizeof(uint8)) {
+      return value; // Same Endian, not need to convert
+    } else {
+      union U {
+        uint8 a[sizeof(T)];
+        T val;
+      } u0;
+      u0.val = value;
+      U u1;
+      for (size_t i = 0; i < sizeof(T); ++i) {
+        u1.a[i] = u0.a[sizeof(T) - 1 - i];
+      }
+      return u1.val;
+    }
+  }
+
+  struct ClassElem {
+    std::string className;
+    std::string elemName;
+    std::string typeName;
+  };
+
+  std::string GetStringFromIdx(uint32 idx) const;
+  std::string GetTypeNameFromIdx(uint32 idx) const;
+  ClassElem GetClassMethodFromIdx(uint32 idx) const;
+  ClassElem GetClassFieldFromIdx(uint32 idx) const;
+  std::string GetSignature(uint32 idx) const;
+  uint32 GetFileIndex() const;
+  std::string GetIRSrcFileSignature() const;
+
+ protected:
+  virtual std::string GetStringFromIdxImpl(uint32 idx) const = 0;
+  virtual std::string GetTypeNameFromIdxImpl(uint32 idx) const = 0;
+  virtual ClassElem GetClassMethodFromIdxImpl(uint32 idx) const = 0;
+  virtual ClassElem GetClassFieldFromIdxImpl(uint32 idx) const = 0;
+  virtual std::string GetSignatureImpl(uint32 idx) const = 0;
+  virtual uint32 GetFileIndexImpl() const = 0;
+  virtual bool RetrieveHeaderImpl(RawData &data);
+  std::string irSrcFileSignature;
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // MPL_FE_BC_INPUT_BC_IO_H
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_op_factory.h b/src/hir2mpl/bytecode_input/common/include/bc_op_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca3c274ff2497a1ca4cc4e6bbe589f43c169a865
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_op_factory.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_BC_INPUT_BC_OP_FACTORY_H
+#define MPL_FE_BC_INPUT_BC_OP_FACTORY_H
+#include <map>
+#include <functional>
+#include "mempool_allocator.h"
+#include "types_def.h"
+#include "bc_instruction.h"
+
+namespace maple {
+namespace bc {
+class BCOpFactory {
+ public:
+  template<typename T, typename U, U opcode, uint16 kind, bool wide, bool throwable>
+  static BCInstruction *BCOpGenerator(MapleAllocator &allocator, uint32 pc) {
+    MemPool *mp = allocator.GetMemPool();
+    BCInstruction *op = mp->New<T>(allocator, pc, opcode);
+    op->InitBCInStruction(kind, wide, throwable);
+    return op;
+  }
+  using funcPtr = BCInstruction*(*)(MapleAllocator&, uint32);
+};
+}  // namespace bc
+}  // namespace maple
+#endif // MPL_FE_BC_INPUT_BC_OP_FACTORY_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_parser-inl.h b/src/hir2mpl/bytecode_input/common/include/bc_parser-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..48938f822d346e8a92dcee22d0996c5cf2ff8a0a
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_parser-inl.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_PARSER_INL_H_
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_PARSER_INL_H_
+#include "bc_parser.h"
+
+namespace maple {
+namespace bc {
+template<class T>
+BCParser<T>::BCParser(uint32 fileIdxIn, const std::string &fileNameIn, const std::list<std::string> &classNamesIn)
+    : BCParserBase(fileIdxIn, fileNameIn, classNamesIn), reader(std::make_unique<T>(fileIdxIn, fileNameIn)) {}
+
+template<class T>
+bool BCParser<T>::OpenFileImpl() {
+  return reader->OpenAndMap();
+}
+
+template<class T, class V>
+int MethodProcessTask<T, V>::RunImpl(MplTaskParam *param) {
+  (void)param;
+  parser.ProcessDexClassMethod(klass, isVirtual, index, idxPair);
+  return 0;
+}
+
+template<class T, class V>
+int MethodProcessTask<T, V>::FinishImpl(MplTaskParam *param) {
+  (void)param;
+  return 0;
+}
+
+template<class T, class V>
+void MethodProcessSchedular<T, V>::AddMethodProcessTask(T &parser,
+    std::unique_ptr<V> &klass, bool isVirtual, uint32 index, std::pair<uint32, uint32> &idxPair) {
+  std::unique_ptr<MethodProcessTask<T, V>> task =
+      std::make_unique<MethodProcessTask<T, V>>(parser, klass, isVirtual, index, idxPair);
+  AddTask(task.get());
+  tasks.push_back(std::move(task));
+}
+
+template<class T, class V>
+void MethodProcessSchedular<T, V>::CallbackThreadMainStart() {
+  std::thread::id tid = std::this_thread::get_id();
+  if (FEOptions::GetInstance().GetDumpLevel() >= FEOptions::kDumpLevelInfoDebug) {
+    INFO(kLncInfo, "Start Run Thread (tid=%lx)", std::hash<std::thread::id>{}(tid));
+  }
+  FEConfigParallel::GetInstance().RegisterRunThreadID(tid);
+}
+}  // namespace bc
+}  // namespace maple
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_BC_PARSER_INL_H_
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_parser.h b/src/hir2mpl/bytecode_input/common/include/bc_parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..25a5eb000594f13583850f8a34797020d3438270
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_parser.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_BC_INPUT_BC_PARSER_H
+#define MPL_FE_BC_INPUT_BC_PARSER_H
+#include <memory>
+#include <list>
+#include <string>
+#include "bc_io.h"
+#include "bc_class.h"
+#include "bc_parser_base.h"
+#include "mpl_scheduler.h"
+#include "fe_options.h"
+
+namespace maple {
+namespace bc {
+template <class T>
+class BCParser : public BCParserBase {
+ public:
+  BCParser(uint32 fileIdxIn, const std::string &fileNameIn, const std::list<std::string> &classNamesIn);
+  ~BCParser() = default;
+
+ protected:
+  bool OpenFileImpl();
+  uint32 CalculateCheckSumImpl(const uint8 *data, uint32 size) = 0;
+  bool ParseHeaderImpl() = 0;
+  bool VerifyImpl() = 0;
+  virtual bool RetrieveIndexTables() = 0;
+  bool RetrieveUserSpecifiedClasses(std::list<std::unique_ptr<BCClass>> &klasses) = 0;
+  bool RetrieveAllClasses(std::list<std::unique_ptr<BCClass>> &klasses) = 0;
+  bool CollectAllDepTypeNamesImpl(std::unordered_set<std::string> &depSet) = 0;
+  bool CollectMethodDepTypeNamesImpl(std::unordered_set<std::string> &depSet, BCClassMethod &bcMethod) const = 0;
+  bool CollectAllClassNamesImpl(std::unordered_set<std::string> &classSet) = 0;
+
+  std::unique_ptr<T> reader;
+};
+
+template <class T, class V>
+class MethodProcessTask : public MplTask {
+ public:
+  MethodProcessTask(T &argParser, std::unique_ptr<V> &argKlass,
+      bool argIsVirtual, uint32 index, std::pair<uint32, uint32> argIdxPair)
+      : isVirtual(argIsVirtual),
+        index(index),
+        klass(argKlass),
+        idxPair(argIdxPair),
+        parser(argParser) {}
+  virtual ~MethodProcessTask() = default;
+
+ protected:
+  int RunImpl(MplTaskParam *param) override;
+  int FinishImpl(MplTaskParam *param) override;
+
+ private:
+  bool isVirtual;
+  uint32 index;
+  std::unique_ptr<V> &klass;
+  std::pair<uint32, uint32> idxPair;
+  T &parser;
+};
+
+template <class T, class V>
+class MethodProcessSchedular : public MplScheduler {
+ public:
+  MethodProcessSchedular(const std::string &name)
+      : MplScheduler(name) {}
+  ~MethodProcessSchedular() override {
+    FEConfigParallel::GetInstance().RunThreadIDCleanUp();
+  }
+
+  void AddMethodProcessTask(T &parser, std::unique_ptr<V> &klass,
+      bool isVirtual, uint32 index, std::pair<uint32, uint32> &idxPair);
+  void SetDumpTime(bool arg) {
+    dumpTime = arg;
+  }
+
+ protected:
+  void CallbackThreadMainStart() override;
+
+ private:
+  std::list<std::unique_ptr<MethodProcessTask<T, V>>> tasks;
+};
+}  // namespace bc
+}  // namespace maple
+#include "bc_parser-inl.h"
+#endif  // MPL_FE_BC_INPUT_BC_PARSER_H
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_parser_base.h b/src/hir2mpl/bytecode_input/common/include/bc_parser_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..e23f02d9a2720dac3b38d74531d4c8398493ce85
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_parser_base.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_PARSER_BASE_H
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_PARSER_BASE_H
+#include <memory>
+#include <list>
+#include <string>
+#include "types_def.h"
+#include "bc_io.h"
+
+namespace maple {
+namespace bc {
+class BCClass;
+class BCClassMethod;
+class BCParserBase {
+ public:
+  BCParserBase(uint32 fileIdxIn, const std::string &fileNameIn, const std::list<std::string> &classNamesIn);
+  virtual ~BCParserBase() = default;
+  bool OpenFile();
+  bool ParseHeader();
+  bool Verify();
+  int32 GetFileNameHashId() const {
+    return fileNameHashId;
+  }
+  uint32 CalculateCheckSum(const uint8 *data, uint32 size);
+  bool RetrieveClasses(std::list<std::unique_ptr<BCClass>> &klasses);
+  const BCReader *GetReader() const;
+  bool CollectAllDepTypeNames(std::unordered_set<std::string> &depSet);
+  bool CollectMethodDepTypeNames(std::unordered_set<std::string> &depSet, BCClassMethod &bcMethod) const;
+  bool CollectAllClassNames(std::unordered_set<std::string> &classSet);
+  void ProcessMethodBody(BCClassMethod &method, uint32 classIdx, uint32 methodItemIdx, bool isVirtual) const {
+    ProcessMethodBodyImpl(method, classIdx, methodItemIdx, isVirtual);
+  }
+
+ protected:
+  virtual const BCReader *GetReaderImpl() const = 0;
+  virtual bool OpenFileImpl() = 0;
+  virtual uint32 CalculateCheckSumImpl(const uint8 *data, uint32 size) = 0;
+  virtual bool ParseHeaderImpl() = 0;
+  virtual bool VerifyImpl() = 0;
+  virtual bool RetrieveIndexTables() = 0;
+  virtual bool RetrieveUserSpecifiedClasses(std::list<std::unique_ptr<BCClass>> &klasses) = 0;
+  virtual bool RetrieveAllClasses(std::list<std::unique_ptr<BCClass>> &klasses) = 0;
+  virtual bool CollectAllDepTypeNamesImpl(std::unordered_set<std::string> &depSet) = 0;
+  virtual bool CollectMethodDepTypeNamesImpl(std::unordered_set<std::string> &depSet,
+      BCClassMethod &bcMethod) const = 0;
+  virtual bool CollectAllClassNamesImpl(std::unordered_set<std::string> &classSet) = 0;
+  virtual void ProcessMethodBodyImpl(BCClassMethod &method,
+      uint32 classIdx, uint32 methodItemIdx, bool isVirtual) const = 0;
+
+  uint32 fileIdx;
+  const std::string fileName;
+  const std::list<std::string> &classNames;
+  const int32 fileNameHashId;
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_BC_PARSER_BASE_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_pragma.h b/src/hir2mpl/bytecode_input/common/include/bc_pragma.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb33222911e76a5e5cf1cde05ddf86bda2f0a07e
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_pragma.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_PRAGMA_H
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_PRAGMA_H
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include "mir_module.h"
+#include "mir_pragma.h"
+#include "mempool.h"
+
+namespace maple {
+namespace bc {
+class BCAnnotationsDirectory {
+ public:
+  BCAnnotationsDirectory(MIRModule &moduleArg, MemPool &mpArg)
+      : module(moduleArg),
+        mp(mpArg) {}
+  virtual ~BCAnnotationsDirectory() = default;
+  std::vector<MIRPragma*> &EmitPragmas() {
+    return EmitPragmasImpl();
+  }
+
+ protected:
+  virtual std::vector<MIRPragma*> &EmitPragmasImpl() = 0;
+  MIRModule &module;
+  MemPool &mp;
+  std::vector<MIRPragma*> pragmas;
+};
+}  // namespace bc
+}  // namespace maple
+#endif // HIR2MPL_BC_INPUT_INCLUDE_BC_PRAGMA_H
diff --git a/src/hir2mpl/bytecode_input/common/include/bc_util.h b/src/hir2mpl/bytecode_input/common/include/bc_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..43ba35277f48bb07c5ba9b355515bf349ecd96f6
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/bc_util.h
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_BC_UTIL_H
+#define HIR2MPL_BC_INPUT_INCLUDE_BC_UTIL_H
+#include <string>
+#include <vector>
+#include <map>
+#include <unordered_set>
+#include "types_def.h"
+#include "cfg_primitive_types.h"
+#include "global_tables.h"
+namespace maple {
+namespace bc {
+enum BCInstructionKind : uint16 {
+  kUnKnownKind = 0,
+  kFallThru = 0x0001,
+  kConditionBranch = 0x0002,
+  kGoto = 0x0004,
+  kSwitch = 0x0008,
+  kTarget = 0x0010,
+  kTryStart = 0x0020,
+  kTryEnd = 0x0040,
+  kCatch = 0x0080,
+  kReturn = 0x0100,
+};
+
+enum BCRegVarType {
+  kUnknownType = 0,
+  kPrimitive = 1,
+  kBoolean = 3,
+  kLong = 17,
+  kFloat = 33,
+  kDouble = 65,
+  kRef = 2,
+};
+
+class BCUtil {
+ public:
+  static const std::string kUnknown;
+  static const std::string kPrimitive;
+  static const std::string kBoolean;
+  static const std::string kByte;
+  static const std::string kChar;
+  static const std::string kShort;
+  static const std::string kInt;
+  static const std::string kLong;
+  static const std::string kFloat;
+  static const std::string kDouble;
+  static const std::string kVoid;
+  static const std::string kWide;
+  static const std::string kAggregate;
+  static const std::string kJavaObjectName;
+  static const std::string kJavaStringName;
+  static const std::string kJavaByteClassName;
+  static const std::string kJavaShortClassName;
+  static const std::string kJavaIntClassName;
+  static const std::string kJavaLongClassName;
+  static const std::string kJavaFloatClassName;
+  static const std::string kJavaDoubleClassName;
+  static const std::string kJavaCharClassName;
+  static const std::string kJavaBoolClassName;
+  static const std::string kJavaClassName;
+  static const std::string kJavaMethodHandleName;
+  static const std::string kJavaExceptionName;
+  static const std::string kJavaThrowableName;
+
+  static const std::string kJavaMethodHandleInvoke;
+  static const std::string kJavaMethodHandleInvokeExact;
+
+  static const std::string kABoolean;
+  static const std::string kAByte;
+  static const std::string kAShort;
+  static const std::string kAChar;
+  static const std::string kAInt;
+  static const std::string kALong;
+  static const std::string kAFloat;
+  static const std::string kADouble;
+  static const std::string kAJavaObjectName;
+
+  static inline GStrIdx &GetBooleanIdx() {
+    static GStrIdx booleanIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kBoolean);
+    return booleanIdx;
+  }
+
+  static inline GStrIdx &GetIntIdx() {
+    static GStrIdx intIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kInt);
+    return intIdx;
+  }
+
+  static inline GStrIdx &GetLongIdx() {
+    static GStrIdx longIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kLong);
+    return longIdx;
+  }
+
+  static inline GStrIdx &GetFloatIdx() {
+    static GStrIdx floatIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kFloat);
+    return floatIdx;
+  }
+
+  static inline GStrIdx &GetDoubleIdx() {
+    static GStrIdx doubleIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kDouble);
+    return doubleIdx;
+  }
+
+  static inline GStrIdx &GetByteIdx() {
+    static GStrIdx byteIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kByte);
+    return byteIdx;
+  }
+
+  static inline GStrIdx &GetCharIdx() {
+    static GStrIdx charIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kChar);
+    return charIdx;
+  }
+
+  static inline GStrIdx &GetShortIdx() {
+    static GStrIdx shortIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kShort);
+    return shortIdx;
+  }
+
+  static inline GStrIdx &GetVoidIdx() {
+    static GStrIdx voidIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kVoid);
+    return voidIdx;
+  }
+
+  static inline GStrIdx &GetJavaObjectNameMplIdx() {
+    static GStrIdx javaObjectNameMplIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(kJavaObjectName));
+    return javaObjectNameMplIdx;
+  }
+
+  static inline GStrIdx &GetJavaStringNameMplIdx() {
+    static GStrIdx javaStringNameMplIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(kJavaStringName));
+    return javaStringNameMplIdx;
+  }
+
+  static inline GStrIdx &GetJavaClassNameMplIdx() {
+    static GStrIdx javaClassNameMplIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(kJavaClassName));
+    return javaClassNameMplIdx;
+  }
+
+  static inline GStrIdx &GetJavaExceptionNameMplIdx() {
+    static GStrIdx javaExceptionNameMplIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(kJavaExceptionName));
+    return javaExceptionNameMplIdx;
+  }
+
+  static inline GStrIdx &GetJavaThrowableNameMplIdx() {
+    static GStrIdx javaThrowableNameMplIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(kJavaThrowableName));
+    return javaThrowableNameMplIdx;
+  }
+
+  static inline GStrIdx &GetJavaMethodHandleNameMplIdx() {
+    static GStrIdx javaMethodHandleNameMplIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(kJavaMethodHandleName));
+    return javaMethodHandleNameMplIdx;
+  }
+
+  static inline GStrIdx &GetABooleanIdx() {
+    static GStrIdx aBooleanIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kABoolean);
+    return aBooleanIdx;
+  }
+
+  static inline GStrIdx &GetAIntIdx() {
+    static GStrIdx aIntIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kAInt);
+    return aIntIdx;
+  }
+
+  static inline GStrIdx &GetALongIdx() {
+    static GStrIdx aLongIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kALong);
+    return aLongIdx;
+  }
+
+  static inline GStrIdx &GetAByteIdx() {
+    static GStrIdx aByteIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kAByte);
+    return aByteIdx;
+  }
+
+  static inline GStrIdx &GetACharIdx() {
+    static GStrIdx aCharIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kAChar);
+    return aCharIdx;
+  }
+
+  static inline GStrIdx &GetAShortIdx() {
+    static GStrIdx aShortIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kAShort);
+    return aShortIdx;
+  }
+
+  static inline GStrIdx &GetAFloatIdx() {
+    static GStrIdx aFloatIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kAFloat);
+    return aFloatIdx;
+  }
+
+  static inline GStrIdx &GetADoubleIdx() {
+    static GStrIdx aDoubleIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kADouble);
+    return aDoubleIdx;
+  }
+
+  static inline GStrIdx &GetAJavaObjectNameMplIdx() {
+    static GStrIdx aJavaObjectNameMplIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(kAJavaObjectName));
+    return aJavaObjectNameMplIdx;
+  }
+
+  // JavaMultiANewArray
+  static inline GStrIdx &GetMultiANewArrayFullIdx() {
+    static GStrIdx multiANewArrayFullIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName("Ljava/lang/reflect/Array;|newInstance|(Ljava/lang/Class;[I)Ljava/lang/Object;"));
+    return multiANewArrayFullIdx;
+  }
+
+  static inline GStrIdx &GetMultiANewArrayClassIdx() {
+    static GStrIdx multiANewArrayClassIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName("Ljava/lang/reflect/Array;"));
+    return multiANewArrayClassIdx;
+  }
+
+  static inline GStrIdx &GetMultiANewArrayElemIdx() {
+    static GStrIdx multiANewArrayElemIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName("newInstance"));
+    return multiANewArrayElemIdx;
+  }
+
+  static inline GStrIdx &GetMultiANewArrayTypeIdx() {
+    static GStrIdx multiANewArrayTypeIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName("(Ljava/lang/Class;[I)Ljava/lang/Object;"));
+    return multiANewArrayTypeIdx;
+  }
+
+  // value element name
+  static inline GStrIdx &GetPragmaElementNameValueIdx() {
+    static GStrIdx pragmaElementNameValueIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("value");
+    return pragmaElementNameValueIdx;
+  }
+
+  static bool IsWideType(const GStrIdx &name);
+  static bool IsMorePrecisePrimitiveType(const GStrIdx &name0, const GStrIdx &name1);
+  static PrimType GetPrimType(const GStrIdx &name);
+  static bool IsJavaReferenceType(const GStrIdx &typeNameIdx);
+  static bool IsJavaPrimitveType(const GStrIdx &typeNameIdx);
+  static bool IsJavaPrimitiveTypeName(const std::string typeName);
+  static bool IsArrayType(const GStrIdx &typeNameIdx);
+  static std::string TrimArrayModifier(const std::string &typeName);
+  static void AddDefaultDepSet(std::unordered_set<std::string> &typeSet);
+  static uint32 Name2RegNum(const std::string &name);
+  static bool HasContainSuffix(const std::string &value, const std::string &suffix);
+};  // BCUtil
+}  // namespace bc
+}  // namespace maple
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_BC_UTIL_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/include/rc_setter.h b/src/hir2mpl/bytecode_input/common/include/rc_setter.h
new file mode 100644
index 0000000000000000000000000000000000000000..85116a18f052fc87a47472c0d1bab45b530f190e
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/include/rc_setter.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef BC_INPUT_INCLUDE_RC_SETTER_H
+#define BC_INPUT_INCLUDE_RC_SETTER_H
+#include <string>
+#include <map>
+#include <set>
+#include "types_def.h"
+#include "bc_class.h"
+#include "mir_type.h"
+#include "mir_function.h"
+
+namespace maple {
+namespace bc {
+class RCSetter {
+ public:
+  static RCSetter &GetRCSetter() {
+    ASSERT(rcSetter != nullptr, "rcSetter is not initialize");
+    return *rcSetter;
+  }
+
+  static void InitRCSetter(const std::string &whiteListName) {
+    rcSetter = new RCSetter(whiteListName);
+  }
+
+  static void ReleaseRCSetter() {
+    if (rcSetter != nullptr) {
+      delete rcSetter;
+      rcSetter = nullptr;
+    }
+  }
+
+  void ProcessClassRCAnnotation(const GStrIdx &classIdx, const std::vector<MIRPragma*> &pragmas);
+  void ProcessMethodRCAnnotation(MIRFunction &mirFunc, const std::string &className,
+                                 MIRStructType &structType, const MIRPragma &pragma);
+  void ProcessFieldRCAnnotation(const StructElemNameIdx &fieldElemNameIdx,
+                                const MIRType &fieldType, const std::vector<MIRPragma*> &pragmas);
+  void GetUnownedVarInLocalVars(const BCClassMethod &method, MIRFunction &mirFunction);
+  void CollectUnownedLocalFuncs(MIRFunction *func);
+  void CollectUnownedLocalVars(MIRFunction *func, const GStrIdx &strIdx);
+  void CollectInputStmtField(StmtNode *stmt, const GStrIdx &fieldName);
+  void SetRCFieldAttrByWhiteList(FieldAttrs &attr, const std::string &className, const std::string &fieldName);
+  void SetAttrRCunowned(MIRFunction &mirFunction, const std::set<uint16> &unownedRegNums) const;
+  void MarkRCAttributes() const;
+
+ private:
+  explicit RCSetter(const std::string &whiteListName)
+      : rcFieldAttrWhiteListName(whiteListName) {
+    if (!rcFieldAttrWhiteListName.empty()) {
+      LoadRCFieldAttrWhiteList(rcFieldAttrWhiteListName);
+    }
+  }
+  ~RCSetter() = default;
+  void MarkRCUnownedForUnownedLocalFunctions() const;
+  void MarkRCUnownedForAnonymousClasses() const;
+  void MarkRCUnownedForLambdaClasses() const;
+  void SetRCUnownedAttributeInternalSetFieldAttrRCUnowned(size_t opnd, const MIRFunction &calledFunc) const;
+  void SetRCUnownedAttribute(const CallNode &callNode, MIRFunction &func,
+                             const MIRFunction &calledFunc, const std::set<GStrIdx> &gStrIdx) const;
+  bool IsAnonymousInner(const MIRStructType &structType) const;
+  bool IsMethodEnclosing(const MIRFunction &func, const MIRStructType &structType) const;
+  void LoadRCFieldAttrWhiteList(const std::string &file);
+
+  static RCSetter *rcSetter;
+  const std::string rcFieldAttrWhiteListName;
+  std::map<std::string, std::map<std::string, std::vector<FieldAttrKind>>> rcFieldAttrWhiteListMap;
+  std::set<MIRFunction*> unownedLocalFuncs;
+  std::map<MIRFunction*, std::set<GStrIdx>> unownedLocalVars;
+  std::map<const StmtNode*, GStrIdx> iputStmtFieldMap;
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // BC_INPUT_INCLUDE_RC_SETTER_H
diff --git a/src/hir2mpl/bytecode_input/common/src/ark_annotation_map.cpp b/src/hir2mpl/bytecode_input/common/src/ark_annotation_map.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5a64cb4f3d5e791ab055a69d681d27e3cb9b6273
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/ark_annotation_map.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ark_annotation_map.h"
+
+namespace maple {
+namespace bc {
+ArkAnnotationMap ArkAnnotationMap::annotationMap;
+
+void ArkAnnotationMap::Init() {
+  // AnnotationDefault
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FAnnotationDefault_3B",
+                                          "Lark_2Fannotation_2FAnnotationDefault_3B"));
+  // EnclosingClass
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FEnclosingClass_3B",
+                                          "Lark_2Fannotation_2FEnclosingClass_3B"));
+  // EnclosingMethod
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FEnclosingMethod_3B",
+                                          "Lark_2Fannotation_2FEnclosingMethod_3B"));
+  // InnerClass
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FInnerClass_3B",
+                                          "Lark_2Fannotation_2FInnerClass_3B"));
+  // KnownFailure
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FKnownFailure_3B",
+                                          "Lark_2Fannotation_2FKnownFailure_3B"));
+  // MemberClasses
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FMemberClasses_3B",
+                                          "Lark_2Fannotation_2FMemberClasses_3B"));
+  // MethodParameters
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FMethodParameters_3B",
+                                          "Lark_2Fannotation_2FMethodParameters_3B"));
+  // Signature
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FSignature_3B",
+                                          "Lark_2Fannotation_2FSignature_3B"));
+  // SourceDebugExtension
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FSourceDebugExtension_3B",
+                                          "Lark_2Fannotation_2FSourceDebugExtension_3B"));
+  // TestTargetClass
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FTestTargetClass_3B",
+                                          "Lark_2Fannotation_2FTestTargetClass_3B"));
+  // TestTarget
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FTestTarget_3B",
+                                          "Lark_2Fannotation_2FTestTarget_3B"));
+  // Throws
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2FThrows_3B",
+                                          "Lark_2Fannotation_2FThrows_3B"));
+  // compact
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2Fcompat_2FUnsupportedAppUsage_3B",
+                                          "Lark_2Fannotation_2Fcompat_2FUnsupportedAppUsage_3B"));
+  // codegen
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2Fcodegen_2FCovariantReturnType_3B",
+                                          "Lark_2Fannotation_2Fcodegen_2FCovariantReturnType_3B"));
+  // optimization
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2Foptimization_2FCriticalNative_3B",
+                                          "Lark_2Fannotation_2Foptimization_2FCriticalNative_3B"));
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2Foptimization_2FDeadReferenceSafe_3B",
+                                          "Lark_2Fannotation_2Foptimization_2FDeadReferenceSafe_3B"));
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2Foptimization_2FFastNative_3B",
+                                          "Lark_2Fannotation_2Foptimization_2FFastNative_3B"));
+  pragmaTypeNameMap.insert(std::make_pair("Ldalvik_2Fannotation_2Foptimization_2FReachabilitySensitive_3B",
+                                          "Lark_2Fannotation_2Foptimization_2FReachabilitySensitive_3B"));
+  for (auto &it : pragmaTypeNameMap) {
+    (void)arkAnnotationTypeNames.insert(it.second);
+  }
+}
+
+const std::string &ArkAnnotationMap::GetAnnotationTypeName(const std::string &orinName) {
+  std::map<std::string, std::string>::iterator it = pragmaTypeNameMap.find(orinName);
+  if (it == pragmaTypeNameMap.end()) {
+    return orinName;
+  } else {
+    return it->second;
+  }
+}
+}  // namespace bc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/src/ark_annotation_processor.cpp b/src/hir2mpl/bytecode_input/common/src/ark_annotation_processor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..86d37127bc922c06fd2286071018347d6729368f
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/ark_annotation_processor.cpp
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ark_annotation_processor.h"
+#include "ark_annotation_map.h"
+#include "fe_manager.h"
+#include "mpl_logging.h"
+namespace maple {
+namespace bc {
+void ArkAnnotationProcessor::Process() {
+  ArkAnnotationMap::GetArkAnnotationMap().Init();
+  ArkAnnotation::GetInstance().Init();
+  const std::set<std::string> &arkAnnotationTypeNames =
+      ArkAnnotationMap::GetArkAnnotationMap().GetArkAnnotationTypeNames();
+  for (const std::string &arkAnnotationTypeName : arkAnnotationTypeNames) {
+    (void)FEManager::GetTypeManager().CreateClassOrInterfaceType(arkAnnotationTypeName, true, FETypeFlag::kSrcUnknown);
+  }
+}
+
+// ---------- ArkAnnotation ----------
+ArkAnnotation ArkAnnotation::instance;
+
+void ArkAnnotation::Init() {
+  // FastNative
+  typeNameSetForFastNative.insert(GetStrIdxFromDexName("Ldalvik/annotation/optimization/FastNative;"));
+  typeNameSetForFastNative.insert(GetStrIdxFromDexName("Lark/annotation/optimization/FastNative;"));
+  // CriticalNative
+  typeNameSetForCriticalNative.insert(GetStrIdxFromDexName("Ldalvik/annotation/optimization/CriticalNative;"));
+  typeNameSetForCriticalNative.insert(GetStrIdxFromDexName("Lark/annotation/optimization/CriticalNative;"));
+  // CallerSensitive
+  typeNameSetForCallerSensitive.insert(GetStrIdxFromDexName("Lsun/reflect/CallerSensitive;"));
+  // Permanent
+  typeNameSetForPermanent.insert(GetStrIdxFromDexName("Lcom/huawei/ark/annotation/Permanent;"));
+  typeNameSetForPermanent.insert(GetStrIdxFromDexName("Lharmonyos/annotation/Permanent;"));
+  typeNameSetForPermanent.insert(GetStrIdxFromDexName("Lark/annotation/Permanent;"));
+  // RCU
+  typeNameSetForRCUnowned.insert(GetStrIdxFromDexName("Ljava/lang/annotation/RCUnownedRef;"));
+  typeNameSetForRCUnowned.insert(GetStrIdxFromDexName("Lcom/huawei/ark/annotation/Unowned;"));
+  typeNameSetForRCUnowned.insert(GetStrIdxFromDexName("Lharmonyos/annotation/Unowned;"));
+  typeNameSetForRCUnowned.insert(GetStrIdxFromDexName("Lark/annotation/Unowned;"));
+  // RCUnownedCap
+  typeNameSetForRCUnownedCap.insert(GetStrIdxFromDexName("Ljava/lang/annotation/RCUnownedCapRef;"));
+  // RCUnownedCapList
+  typeNameSetForRCUnownedCapList.insert(GetStrIdxFromDexName("Ljava/lang/annotation/RCUnownedCapRef$List;"));
+  // RCUnownedLocal
+  typeNameSetForRCUnownedLocal.insert(GetStrIdxFromDexName("Lcom/huawei/ark/annotation/UnownedLocal;"));
+  typeNameSetForRCUnownedLocal.insert(GetStrIdxFromDexName("Lharmonyos/annotation/UnownedLocal;"));
+  typeNameSetForRCUnownedLocal.insert(GetStrIdxFromDexName("Lark/annotation/UnownedLocal;"));
+  // RCUnownedLocalOld
+  typeNameIdxForRCUnownedLocalOld = GetStrIdxFromDexName("Ljava/lang/annotation/RCLocalUnownedRef;");
+  // RCUnownedThis
+  typeNameSetForRCUnownedThis.insert(GetStrIdxFromDexName("Ljava/lang/annotation/RCUnownedThisRef;"));
+  // RCUnownedOuter
+  typeNameSetForRCUnownedOuter.insert(GetStrIdxFromDexName("Lcom/huawei/ark/annotation/UnownedOuter;"));
+  typeNameSetForRCUnownedOuter.insert(GetStrIdxFromDexName("Lharmonyos/annotation/UnownedOuter;"));
+  typeNameSetForRCUnownedOuter.insert(GetStrIdxFromDexName("Lark/annotation/UnownedOuter;"));
+  // RCWeak
+  typeNameSetForRCWeak.insert(GetStrIdxFromDexName("Ljava/lang/annotation/RCWeakRef;"));
+  typeNameSetForRCWeak.insert(GetStrIdxFromDexName("Lcom/huawei/ark/annotation/Weak;"));
+  typeNameSetForRCWeak.insert(GetStrIdxFromDexName("Lharmonyos/annotation/Weak;"));
+  typeNameSetForRCWeak.insert(GetStrIdxFromDexName("Lark/annotation/Weak;"));
+}
+
+bool ArkAnnotation::IsFastNative(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForFastNative.find(sType->GetNameStrIdx()) != typeNameSetForFastNative.end();
+}
+
+bool ArkAnnotation::IsCriticalNative(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForCriticalNative.find(sType->GetNameStrIdx()) != typeNameSetForCriticalNative.end();
+}
+
+bool ArkAnnotation::IsCallerSensitive(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForCallerSensitive.find(sType->GetNameStrIdx()) != typeNameSetForCallerSensitive.end();
+}
+
+bool ArkAnnotation::IsPermanent(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForPermanent.find(sType->GetNameStrIdx()) != typeNameSetForPermanent.end();
+}
+
+bool ArkAnnotation::IsPermanent(const std::string &str) const {
+  for (auto idx : typeNameSetForPermanent) {
+    std::string annoName = GlobalTables::GetStrTable().GetStringFromStrIdx(idx);
+    annoName = namemangler::DecodeName(annoName);
+    if (annoName.compare(str) == 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ArkAnnotation::IsRCUnowned(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForRCUnowned.find(sType->GetNameStrIdx()) != typeNameSetForRCUnowned.end();
+}
+
+bool ArkAnnotation::IsRCUnownedCap(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForRCUnownedCap.find(sType->GetNameStrIdx()) != typeNameSetForRCUnownedCap.end();
+}
+
+bool ArkAnnotation::IsRCUnownedCapList(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForRCUnownedCapList.find(sType->GetNameStrIdx()) != typeNameSetForRCUnownedCapList.end();
+}
+
+bool ArkAnnotation::IsRCUnownedLocal(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForRCUnownedLocal.find(sType->GetNameStrIdx()) != typeNameSetForRCUnownedLocal.end();
+}
+
+bool ArkAnnotation::IsRCUnownedLocalOld(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameIdxForRCUnownedLocalOld == sType->GetNameStrIdx();
+}
+
+bool ArkAnnotation::IsRCUnownedThis(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForRCUnownedThis.find(sType->GetNameStrIdx()) != typeNameSetForRCUnownedThis.end();
+}
+
+bool ArkAnnotation::IsRCUnownedOuter(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForRCUnownedOuter.find(sType->GetNameStrIdx()) != typeNameSetForRCUnownedOuter.end();
+}
+
+bool ArkAnnotation::IsRCWeak(const TyIdx &tyIdx) const {
+  MIRStructType *sType = GetStructType(tyIdx);
+  return sType == nullptr ?
+      false : typeNameSetForRCWeak.find(sType->GetNameStrIdx()) != typeNameSetForRCWeak.end();
+}
+
+MIRStructType *ArkAnnotation::GetStructType(const TyIdx &tyIdx) {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  if (!type->IsMIRClassType() && !type->IsMIRInterfaceType()) {
+    return nullptr;
+  }
+  return static_cast<MIRStructType*>(type);
+}
+}  // namespace bc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/src/bc_class.cpp b/src/hir2mpl/bytecode_input/common/src/bc_class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1cfb6e5ac6be776790882c66d9bfdc5e29489ab2
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/bc_class.cpp
@@ -0,0 +1,601 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bc_class.h"
+#include "global_tables.h"
+#include "fe_utils_java.h"
+#include "fe_utils.h"
+#include "fe_manager.h"
+#include "fe_options.h"
+
+namespace maple {
+namespace bc {
+// ========== BCClassElem ==========
+BCClassElem::BCClassElem(const BCClass &klassIn, uint32 acc, const std::string &nameIn, const std::string &descIn)
+    : klass(klassIn),
+      accessFlag(acc),
+      name(nameIn),
+      descriptor(descIn) {}
+
+const std::string &BCClassElem::GetName() const {
+  return name;
+}
+
+const std::string &BCClassElem::GetDescription() const {
+  return descriptor;
+}
+
+uint32 BCClassElem::GetItemIdx() const {
+  return GetItemIdxImpl();
+}
+
+uint32 BCClassElem::GetIdx() const {
+  return GetIdxImpl();
+}
+
+uint32 BCClassElem::GetAccessFlag() const {
+  return accessFlag;
+}
+
+bool BCClassElem::IsStatic() const {
+  return IsStaticImpl();
+}
+
+const std::string &BCClassElem::GetClassName() const {
+  return klass.GetClassName(false);
+}
+
+GStrIdx BCClassElem::GetClassNameMplIdx() const {
+  return klass.GetClassNameMplIdx();
+}
+
+const BCClass &BCClassElem::GetBCClass() const {
+  return klass;
+}
+
+// ========== BCTryInfo ==========
+void BCTryInfo::DumpTryCatchInfo(const std::unique_ptr<std::list<std::unique_ptr<BCTryInfo>>> &tryInfos) {
+  DEBUG_STMT(
+      for (const auto &tryInfo : *tryInfos) {
+        LogInfo::MapleLogger(kLlDbg) << "tryBlock: [" << std::hex << "0x" << tryInfo->GetStartAddr() << ", 0x" <<
+            tryInfo->GetEndAddr() << ")";
+        LogInfo::MapleLogger(kLlDbg) << "  handler: ";
+        for (const auto &e : (*tryInfo->GetCatches())) {
+          LogInfo::MapleLogger(kLlDbg) << "0x" << e->GetHandlerAddr() << " ";
+        }
+        LogInfo::MapleLogger(kLlDbg) << std::endl;
+      })
+}
+
+// ========== BCClassMethod ==========
+void BCClassMethod::SetMethodInstOffset(const uint16 *pos) {
+  instPos = pos;
+}
+
+void BCClassMethod::SetRegisterTotalSize(uint16 size) {
+  registerTotalSize = size;
+}
+
+uint16 BCClassMethod::GetRegisterTotalSize() const{
+  return registerTotalSize;
+}
+
+void BCClassMethod::SetCodeOff(uint32 off) {
+  codeOff = off;
+}
+
+uint32 BCClassMethod::GetCodeOff() const {
+  return codeOff;
+}
+
+void BCClassMethod::SetRegisterInsSize(uint16 size) {
+  registerInsSize = size;
+}
+
+bool BCClassMethod::IsVirtual() const {
+  return IsVirtualImpl();
+}
+
+bool BCClassMethod::IsNative() const {
+  return IsNativeImpl();
+}
+
+bool BCClassMethod::IsInit() const {
+  return IsInitImpl();
+}
+
+bool BCClassMethod::IsClinit() const {
+  return IsClinitImpl();
+}
+
+std::string BCClassMethod::GetFullName() const {
+  return GetClassName() + "|" + GetName() + "|" + GetDescription();
+}
+
+void BCClassMethod::SetSrcPosInfo() {
+#ifdef DEBUG
+  if ((FEOptions::GetInstance().IsDumpComment() || FEOptions::GetInstance().IsDumpLOC()) &&
+      pSrcPosInfo != nullptr) {
+    uint32 srcPos = 0;
+    for (auto &[pos, inst] : *pcBCInstructionMap) {
+      auto it = pSrcPosInfo->find(pos);
+      if (it != pSrcPosInfo->end()) {
+        srcPos = it->second;  // when pSrcPosInfo is valid, update srcPos
+      }
+      inst->SetSrcPositionInfo(klass.GetSrcFileIdx(), srcPos);
+    }
+  }
+#endif
+}
+
+void BCClassMethod::ProcessInstructions() {
+  if (pcBCInstructionMap->empty()) {
+    return;
+  }
+  // some instructions depend on exception handler, so we process try-catch info first
+  ProcessTryCatch();
+  visitedPcSet.emplace(pcBCInstructionMap->begin()->first);
+  GStrIdx methodIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(GetFullName()));
+  for (auto itor = pcBCInstructionMap->begin(); itor != pcBCInstructionMap->end();) {
+    BCInstruction *inst = itor->second;
+    inst->SetFuncNameIdx(methodIdx);
+    inst->Parse(*this);
+    ++itor;
+    if (inst->IsConditionBranch() || inst->IsGoto() || inst->IsSwitch()) {
+      std::vector<uint32> targets = inst->GetTargets();
+      for (uint32 target : targets) {
+        auto it = pcBCInstructionMap->find(target);
+        CHECK_FATAL(it != pcBCInstructionMap->end(), "Invalid branch target 0x%x in method: %s",
+            target, GetFullName().c_str());
+        it->second->SetInstructionKind(kTarget);
+        if (visitedPcSet.emplace(target).second == false) {
+          multiInDegreeSet.emplace(target);
+        }
+      }
+      if (inst->IsSwitch() && itor != pcBCInstructionMap->end()) {
+        itor->second->SetInstructionKind(kTarget);
+        inst->SetDefaultTarget(itor->second);
+      }
+    }
+    if (itor == pcBCInstructionMap->end()) {
+      continue;
+    }
+    if (inst->IsFallThru()) {
+      if (visitedPcSet.emplace(itor->first).second == false) {
+        multiInDegreeSet.emplace(itor->first);
+      }
+    }
+    if (itor->second->IsReturn()) {
+      inst->SetReturnInst(itor->second);
+    }
+  }
+  SetSrcPosInfo();
+  if (FEOptions::GetInstance().GetTypeInferKind() == FEOptions::kLinearScan) {
+    TypeInfer();
+  }
+}
+
+void BCClassMethod::ProcessTryCatch() {
+  if (tryInfos == nullptr) {
+    return;
+  }
+  for (const auto &e : *tryInfos) {
+    uint32 tryStart = e->GetStartAddr();
+    uint32 tryEnd = e->GetEndAddr();
+    auto it = pcBCInstructionMap->find(tryStart);
+    CHECK_FATAL(it != pcBCInstructionMap->end(), "Invalid try start pos 0x%x in method: %s", tryStart,
+        GetFullName().c_str());
+    it->second->SetInstructionKind(kTryStart);
+    BCInstruction *inst = it->second;
+    auto it1 = pcBCInstructionMap->find(tryEnd);
+    if (tryStart == tryEnd) {
+      it->second->SetInstructionKind(kTryEnd);
+    } else if (it1 != pcBCInstructionMap->end()) {
+      --it1;
+      it1->second->SetInstructionKind(kTryEnd);
+    } else {
+      // behind the last instruction
+      pcBCInstructionMap->rbegin()->second->SetInstructionKind(kTryEnd);
+    }
+    // Calculate catchable instructions
+    std::list<BCInstruction*> catchableInsts;
+    while (it->second->GetPC() < tryEnd) {
+      it->second->SetCatchable();
+      if (it->second->IsCatchable()) {
+        catchableInsts.emplace_back(it->second);
+      }
+      ++it;
+      if (it == pcBCInstructionMap->end()) {
+        break;
+      }
+    }
+    for (const auto &handler: *(e->GetCatches())) {
+      uint32 handlerPc = handler->GetHandlerAddr();
+      auto elem = pcBCInstructionMap->find(handlerPc);
+      CHECK_FATAL(elem != pcBCInstructionMap->end(), "Invalid catch pos 0x%x in method: %s", handlerPc,
+          GetFullName().c_str());
+      elem->second->SetInstructionKind(kCatch);
+      elem->second->SetExceptionType(handler->GetExceptionNameIdx());
+      inst->AddHandler(elem->second);
+      for (auto catchableInst : catchableInsts) {
+        catchableInst->AddHandlerTarget(handlerPc);
+        if (visitedPcSet.emplace(handlerPc).second == false) {
+          multiInDegreeSet.emplace(handlerPc);
+        }
+      }
+    }
+  }
+}
+
+// Use linear scan with SSA
+// We insert phi behind the def in a edge before the dominance if the reg is alive under this dominance.
+// A reg is default dead at its definition, we mark a reg alive only when it was used.
+// And insert the reg def-type into `used alive types` if it is defined in a determinate type.
+// We transfer reg live info through shared memory, record live-interval in dominancesMap and BCRegType::livesBegins.
+// After a multi-in pos, we create a new TypeInferItem for a new live range.
+// Insert `in-edge` into dominance `prevs`, for record complete reg use in circles by one pass.
+void BCClassMethod::TypeInfer() {
+  std::set<uint32> visitedSet;
+  // [pc, [regNum, TypeInferItem*]]
+  std::list<std::pair<uint32, std::vector<TypeInferItem*>>> pcDefedRegsList;
+  // [pc, [regNum, TypeInferItem*]]
+  std::vector<std::vector<TypeInferItem*>> dominances((*pcBCInstructionMap).rbegin()->first + 1);
+  std::vector<TypeInferItem*> regTypeMap(registerTotalSize, nullptr);
+  for (auto &reg : argRegs) {
+    regTypeMap[reg->regNum] = ConstructTypeInferItem(allocator, 0, reg.get(), nullptr);
+    regTypes.emplace_back(reg->regType);
+  }
+  visitedSet.emplace(0);
+  if (multiInDegreeSet.find(0) != multiInDegreeSet.end()) {
+    std::vector<TypeInferItem*> typeMap = ConstructNewRegTypeMap(allocator, 1, regTypeMap);
+    pcDefedRegsList.emplace_front(0, typeMap);
+    dominances[0] = typeMap;
+  } else {
+    pcDefedRegsList.emplace_front(0, regTypeMap);
+  }
+  Traverse(pcDefedRegsList, dominances, visitedSet);
+  PrecisifyRegType();
+}
+
+void BCClassMethod::Traverse(std::list<std::pair<uint32, std::vector<TypeInferItem*>>> &pcDefedRegsList,
+                             std::vector<std::vector<TypeInferItem*>> &dominances, std::set<uint32> &visitedSet) {
+  while (!pcDefedRegsList.empty()) {
+    auto head = pcDefedRegsList.front();
+    pcDefedRegsList.pop_front();
+    BCInstruction *currInst = (*pcBCInstructionMap)[head.first];
+    std::vector<TypeInferItem*> nextRegTypeMap = head.second;
+    auto usedRegs = currInst->GetUsedRegs();
+    for (auto usedReg : *usedRegs) {
+      auto defedItem = nextRegTypeMap[usedReg->regNum];
+      CHECK_FATAL(defedItem != nullptr && defedItem->reg != nullptr,
+          "Cannot find Reg%u defination at 0x%x:0x%x in method %s",
+          usedReg->regNum, head.first, currInst->GetOpcode(), GetFullName().c_str());
+      usedReg->regValue = defedItem->reg->regValue;
+      usedReg->regType = defedItem->reg->regType;
+      currInst->SetRegTypeInTypeInfer();
+      // Make the reg alive when it used, live range [defPos, usePos]
+      usedReg->regTypeItem->SetPos(currInst->GetPC());
+      defedItem->InsertUniqueAliveType(nullptr, usedReg->regTypeItem);
+    }
+    auto defedRegs = currInst->GetDefedRegs();
+    auto exHandlerTargets = currInst->GetHandlerTargets();
+    uint32 next = currInst->GetPC() + currInst->GetWidth();
+    for (auto exHandlerTarget : exHandlerTargets) {
+      if (visitedSet.emplace(exHandlerTarget).second == false) {
+        auto &domIt = dominances[exHandlerTarget];
+        InsertPhi(domIt, nextRegTypeMap);
+        continue;
+      }
+      if ((multiInDegreeSet.find(exHandlerTarget) != multiInDegreeSet.end())) {
+        std::vector<TypeInferItem*> typeMap = ConstructNewRegTypeMap(allocator, exHandlerTarget + 1, nextRegTypeMap);
+        pcDefedRegsList.emplace_front(exHandlerTarget, typeMap);
+        dominances[exHandlerTarget] = typeMap;
+      } else {
+        pcDefedRegsList.emplace_front(exHandlerTarget, nextRegTypeMap);
+      }
+      Traverse(pcDefedRegsList, dominances, visitedSet);
+    }
+    for (auto defedReg : *defedRegs) {
+      TypeInferItem *item = ConstructTypeInferItem(allocator, currInst->GetPC() + 1, defedReg, nullptr);
+      nextRegTypeMap[defedReg->regNum] = item;
+      defedReg->regType->SetPos(currInst->GetPC());
+      regTypes.emplace_back(defedReg->regType);
+    }
+    if (currInst->IsFallThru() && next <= pcBCInstructionMap->rbegin()->first) {
+      if (visitedSet.emplace(next).second == false) {
+        auto &domIt = dominances[next];
+        InsertPhi(domIt, nextRegTypeMap);
+      } else {
+        if (multiInDegreeSet.find(next) != multiInDegreeSet.end()) {
+          std::vector<TypeInferItem*> typeMap = ConstructNewRegTypeMap(allocator, next + 1, nextRegTypeMap);
+          pcDefedRegsList.emplace_front(next, typeMap);
+          dominances[next] = typeMap;
+        } else {
+          pcDefedRegsList.emplace_front(next, nextRegTypeMap);
+        }
+        // Use stack to replace recursive call, avoid `call stack` overflow in long `fallthru` code.
+        // And `fallthu` instructions can not disrupt visit order.
+        if (currInst->IsConditionBranch() || currInst->IsSwitch()) {
+          Traverse(pcDefedRegsList, dominances, visitedSet);
+        }
+      }
+    }
+    auto normalTargets = currInst->GetTargets();
+    for (auto normalTarget : normalTargets) {
+      if (visitedSet.emplace(normalTarget).second == false) {
+        auto &domIt = dominances[normalTarget];
+        InsertPhi(domIt, nextRegTypeMap);
+        continue;
+      }
+      if (multiInDegreeSet.find(normalTarget) != multiInDegreeSet.end()) {
+        std::vector<TypeInferItem*> typeMap = ConstructNewRegTypeMap(allocator, normalTarget + 1, nextRegTypeMap);
+        pcDefedRegsList.emplace_front(normalTarget, typeMap);
+        dominances[normalTarget] = typeMap;
+      } else {
+        pcDefedRegsList.emplace_front(normalTarget, nextRegTypeMap);
+      }
+      Traverse(pcDefedRegsList, dominances, visitedSet);
+    }
+  }
+}
+
+void BCClassMethod::InsertPhi(const std::vector<TypeInferItem*> &dom, std::vector<TypeInferItem*> &src) {
+  for (auto &d : dom) {
+    if (d == nullptr) {
+      continue;
+    }
+    auto srcItem = src[d->reg->regNum];
+    if (srcItem == d) {
+      continue;
+    }
+    if (d->RegisterInPrevs(srcItem) == false) {
+      continue;
+    }
+
+    if (d->isAlive == false) {
+      continue;
+    }
+    CHECK_FATAL(srcItem != nullptr, "ByteCode RA error.");
+    for (auto ty : *(d->aliveUsedTypes)) {
+      ty->SetDom(true);
+    }
+    srcItem->InsertUniqueAliveTypes(d, d->aliveUsedTypes);
+  }
+}
+
+TypeInferItem *BCClassMethod::ConstructTypeInferItem(
+    MapleAllocator &alloc, uint32 pos, BCReg *bcReg, TypeInferItem *prev) {
+  TypeInferItem *item = alloc.GetMemPool()->New<TypeInferItem>(alloc, pos, bcReg, prev);
+  return item;
+}
+
+std::vector<TypeInferItem*> BCClassMethod::ConstructNewRegTypeMap(MapleAllocator &alloc, uint32 pos,
+    const std::vector<TypeInferItem*> &regTypeMap) {
+  std::vector<TypeInferItem*> res(regTypeMap.size(), nullptr);
+  size_t i = 0;
+  for (const auto &elem : regTypeMap) {
+    if (elem != nullptr) {
+      res[i] = ConstructTypeInferItem(alloc, pos, elem->reg, elem);
+    }
+    ++i;
+  }
+  return res;
+}
+
+std::list<UniqueFEIRStmt> BCClassMethod::GenReTypeStmtsThroughArgs() const {
+  std::list<UniqueFEIRStmt> stmts;
+  for (const auto &argReg : argRegs) {
+    std::list<UniqueFEIRStmt> stmts0 = argReg->GenRetypeStmtsAfterDef();
+    for (auto &stmt : stmts0) {
+      stmts.emplace_back(std::move(stmt));
+    }
+  }
+  return stmts;
+}
+
+void BCClassMethod::PrecisifyRegType() {
+  for (auto elem : regTypes) {
+    elem->PrecisifyTypes();
+  }
+}
+
+std::list<UniqueFEIRStmt> BCClassMethod::EmitInstructionsToFEIR() const {
+  std::list<UniqueFEIRStmt> stmts;
+  if (!HasCode()) {
+    return stmts; // Skip abstract and native method, not emit it to mpl but mplt.
+  }
+  if (IsStatic() && GetName().compare("<clinit>") != 0) { // Not insert JAVA_CLINIT_CHECK in <clinit>
+    GStrIdx containerNameIdx = GetClassNameMplIdx();
+    uint32 typeID = UINT32_MAX;
+    if (FEOptions::GetInstance().IsAOT()) {
+      const std::string &mplClassName = GetBCClass().GetClassName(true);
+      int32 dexFileHashCode = GetBCClass().GetBCParser().GetFileNameHashId();
+      typeID = FEManager::GetTypeManager().GetTypeIDFromMplClassName(mplClassName, dexFileHashCode);
+    }
+    UniqueFEIRStmt stmt =
+        std::make_unique<FEIRStmtIntrinsicCallAssign>(INTRN_JAVA_CLINIT_CHECK,
+                                                      std::make_unique<FEIRTypeDefault>(PTY_ref, containerNameIdx),
+                                                      nullptr, typeID);
+    stmts.emplace_back(std::move(stmt));
+  }
+  std::map<uint32, FEIRStmtPesudoLabel2*> targetFEIRStmtMap;
+  std::list<FEIRStmtGoto2*> gotoFEIRStmts;
+  std::list<FEIRStmtSwitch2*> switchFEIRStmts;
+  std::list<UniqueFEIRStmt> retypeStmts = GenReTypeStmtsThroughArgs();
+  for (auto &stmt : retypeStmts) {
+    stmts.emplace_back(std::move(stmt));
+  }
+  for (const auto &elem : *pcBCInstructionMap) {
+    std::list<UniqueFEIRStmt> instStmts = elem.second->EmitToFEIRStmts();
+    for (auto &e : instStmts) {
+      if (e->GetKind() == kStmtPesudoLabel) {
+        targetFEIRStmtMap.emplace(static_cast<FEIRStmtPesudoLabel2*>(e.get())->GetPos(),
+                                  static_cast<FEIRStmtPesudoLabel2*>(e.get()));
+      }
+      if (e->GetKind() == kStmtGoto || e->GetKind() == kStmtCondGoto) {
+        gotoFEIRStmts.emplace_back(static_cast<FEIRStmtGoto2*>(e.get()));
+      }
+      if (e->GetKind() == kStmtSwitch) {
+        switchFEIRStmts.emplace_back(static_cast<FEIRStmtSwitch2*>(e.get()));
+      }
+      stmts.emplace_back(std::move(e));
+    }
+  }
+  LinkJumpTarget(targetFEIRStmtMap, gotoFEIRStmts, switchFEIRStmts); // Link jump target
+  return stmts;
+}
+
+void BCClassMethod::LinkJumpTarget(const std::map<uint32, FEIRStmtPesudoLabel2*> &targetFEIRStmtMap,
+                                   const std::list<FEIRStmtGoto2*> &gotoFEIRStmts,
+                                   const std::list<FEIRStmtSwitch2*> &switchFEIRStmts) {
+  for (auto &e : gotoFEIRStmts) {
+    auto target = targetFEIRStmtMap.find(e->GetTarget());
+    CHECK_FATAL(target != targetFEIRStmtMap.end(), "Cannot find the target for goto/condGoto");
+    e->SetStmtTarget(*(target->second));
+  }
+  for (auto &e : switchFEIRStmts) {
+    uint32 label = e->GetDefaultLabelIdx();
+    if (label != UINT32_MAX) {
+      auto defaultTarget = targetFEIRStmtMap.find(label);
+      CHECK_FATAL(defaultTarget != targetFEIRStmtMap.end(), "Cannot find the default target for Switch");
+      e->SetDefaultTarget(defaultTarget->second);
+    }
+    for (const auto &valueLabel : e->GetMapValueLabelIdx()) {
+      auto target = targetFEIRStmtMap.find(valueLabel.second);
+      CHECK_FATAL(target != targetFEIRStmtMap.end(), "Cannot find the target for Switch");
+      e->AddTarget(valueLabel.first, target->second);
+    }
+  }
+}
+
+void BCClassMethod::DumpBCInstructionMap() const {
+  // Only used in DEBUG manually
+  DEBUG_STMT(
+      uint32 idx = 0;
+      for (const auto &[pos, instPtr] : *pcBCInstructionMap) {
+        LogInfo::MapleLogger(kLlDbg) << "index: " << std::dec << idx++ << " pc: 0x" << std::hex << pos <<
+            " opcode: 0x" << instPtr->GetOpcode() << std::endl;
+      });
+}
+
+const uint16 *BCClassMethod::GetInstPos() const {
+  return instPos;
+}
+
+std::vector<std::unique_ptr<FEIRVar>> BCClassMethod::GenArgVarList() const {
+  return GenArgVarListImpl();
+}
+
+void BCClassMethod::GenArgRegs() {
+  return GenArgRegsImpl();
+}
+
+// ========== BCCatchInfo ==========
+BCCatchInfo::BCCatchInfo(uint32 handlerAddrIn, const GStrIdx &argExceptionNameIdx, bool iscatchAllIn)
+    : handlerAddr(handlerAddrIn),
+      exceptionNameIdx(argExceptionNameIdx),
+      isCatchAll(iscatchAllIn) {}
+// ========== BCClass ==========
+void BCClass::SetSrcFileInfo(const std::string &name) {
+  srcFileNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  srcFileIdx = FEManager::GetManager().RegisterSourceFileIdx(srcFileNameIdx);
+}
+
+void BCClass::SetSuperClasses(const std::list<std::string> &names) {
+  if (names.empty()) {
+    return;  // No parent class
+  }
+  superClassNameList = names;
+}
+
+void BCClass::SetInterface(const std::string &name) {
+  interfaces.push_back(name);
+}
+
+void BCClass::SetAccFlag(uint32 flag) {
+  accFlag = flag;
+}
+
+void BCClass::SetField(std::unique_ptr<BCClassField> field) {
+  fields.push_back(std::move(field));
+}
+
+void BCClass::SetMethod(std::unique_ptr<BCClassMethod> method) {
+  std::lock_guard<std::mutex> lock(bcClassMtx);
+  methods.push_back(std::move(method));
+}
+
+void BCClass::InsertFinalStaticStringID(uint32 stringID) {
+  finalStaticStringID.push_back(stringID);
+}
+
+void BCClass::SetClassName(const std::string &classNameOrin) {
+  classNameOrinIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(classNameOrin);
+  classNameMplIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(classNameOrin));
+}
+
+const std::unique_ptr<BCAnnotationsDirectory> &BCClass::GetAnnotationsDirectory() const {
+  return annotationsDirectory;
+}
+
+void BCClass::SetAnnotationsDirectory(std::unique_ptr<BCAnnotationsDirectory> annotationsDirectoryIn) {
+  annotationsDirectory = std::move(annotationsDirectoryIn);
+}
+
+std::vector<MIRConst*> BCClass::GetStaticFieldsConstVal() const {
+  return staticFieldsConstVal;
+}
+
+void BCClass::InsertStaticFieldConstVal(MIRConst *cst) {
+  staticFieldsConstVal.push_back(cst);
+}
+
+const std::string &BCClass::GetClassName(bool mapled) const {
+  return mapled ? GlobalTables::GetStrTable().GetStringFromStrIdx(classNameMplIdx) :
+                  GlobalTables::GetStrTable().GetStringFromStrIdx(classNameOrinIdx);
+}
+
+const std::list<std::string> &BCClass::GetSuperClassNames() const {
+  return superClassNameList;
+}
+
+const std::vector<std::string> &BCClass::GetSuperInterfaceNames() const {
+  return interfaces;
+}
+
+std::string BCClass::GetSourceFileName() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(srcFileNameIdx);
+}
+
+GStrIdx BCClass::GetIRSrcFileSigIdx() const {
+  return irSrcFileSigIdx;
+}
+
+int32 BCClass::GetFileNameHashId() const {
+  return parser.GetFileNameHashId();
+}
+
+uint32 BCClass::GetAccessFlag() const {
+  return accFlag;
+}
+
+const std::vector<std::unique_ptr<BCClassField>> &BCClass::GetFields() const {
+  return fields;
+}
+
+std::vector<std::unique_ptr<BCClassMethod>> &BCClass::GetMethods() {
+  return methods;
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/common/src/bc_class2fe_helper.cpp b/src/hir2mpl/bytecode_input/common/src/bc_class2fe_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..16454593af3942f3d6867afeaa99cbd63fac2cbf
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/bc_class2fe_helper.cpp
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bc_class2fe_helper.h"
+#include "fe_macros.h"
+#include "fe_manager.h"
+#include "fe_utils_java.h"
+namespace maple {
+namespace bc {
+BCClass2FEHelper::BCClass2FEHelper(MapleAllocator &allocator, bc::BCClass &klassIn)
+    : FEInputStructHelper(allocator), klass(klassIn) {
+  srcLang = kSrcLangJava;
+}
+
+std::string BCClass2FEHelper::GetStructNameOrinImpl() const {
+  return klass.GetClassName(false);
+}
+
+std::string BCClass2FEHelper::GetStructNameMplImpl() const {
+  return klass.GetClassName(true);
+}
+
+std::list<std::string> BCClass2FEHelper::GetSuperClassNamesImpl() const {
+  return klass.GetSuperClassNames();
+}
+
+std::vector<std::string> BCClass2FEHelper::GetInterfaceNamesImpl() const {
+  return klass.GetSuperInterfaceNames();
+}
+
+std::string BCClass2FEHelper::GetSourceFileNameImpl() const {
+  return klass.GetSourceFileName();
+}
+
+void BCClass2FEHelper::TryMarkMultiDefClass(MIRStructType &typeImported) const {
+  MIRTypeKind kind = typeImported.GetKind();
+  uint32 typeSrcSigIdx = 0;
+  static const GStrIdx keySignatureStrIdx =
+      GlobalTables::GetStrTable().GetStrIdxFromName("INFO_ir_srcfile_signature");
+  if (kind == kTypeClass || kind == kTypeClassIncomplete) {
+    auto &classType = static_cast<MIRClassType&>(typeImported);
+    typeSrcSigIdx = classType.GetInfo(keySignatureStrIdx);
+  } else if (kind == kTypeInterface || kind == kTypeInterfaceIncomplete) {
+    auto &interfaceType = static_cast<MIRInterfaceType&>(typeImported);
+    typeSrcSigIdx = interfaceType.GetInfo(keySignatureStrIdx);
+  }
+  // Find type definition in both dependent libraries and current compilation unit, mark the type multidef,
+  // and we will mark all it's methods multidef later.
+  // MiddleEnd will NOT inline the caller and callee with multidef attr.
+  if (typeSrcSigIdx != 0 && klass.GetIRSrcFileSigIdx() != typeSrcSigIdx) {
+    klass.SetIsMultiDef(true);
+  }
+}
+
+MIRStructType *BCClass2FEHelper::CreateMIRStructTypeImpl(bool &error) const {
+  std::string classNameMpl = GetStructNameMplImpl();
+  if (classNameMpl.empty()) {
+    error = true;
+    ERR(kLncErr, "class name is empty");
+    return nullptr;
+  }
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "CreateMIRStrucType for %s", classNameMpl.c_str());
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(classNameMpl);
+  MIRStructType *typeImported = FEManager::GetTypeManager().GetImportedType(nameIdx);
+  if (typeImported != nullptr) {
+    TryMarkMultiDefClass(*typeImported);
+  }
+
+  bool isCreate = false;
+  MIRStructType *type = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(nameIdx, klass.IsInterface(),
+                                                                                    FETypeFlag::kSrcInput, isCreate);
+  error = false;
+  // fill global type name table
+  GStrIdx typeNameIdx = type->GetNameStrIdx();
+  TyIdx prevTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(typeNameIdx);
+  if (prevTyIdx == TyIdx(0)) {
+    GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(typeNameIdx, type->GetTypeIndex());
+  }
+  // setup eh root type
+  if (FEManager::GetModule().GetThrowableTyIdx() == 0 &&
+      (type->GetKind() == kTypeClass || type->GetKind() == kTypeClassIncomplete)) {
+    GStrIdx ehTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr));
+    if (ehTypeNameIdx == type->GetNameStrIdx()) {
+      FEManager::GetModule().SetThrowableTyIdx(type->GetTypeIndex());
+    }
+  }
+  return isCreate ? type : nullptr;
+}
+
+uint64 BCClass2FEHelper::GetRawAccessFlagsImpl() const {
+  return static_cast<uint64>(klass.GetAccessFlag());
+}
+
+GStrIdx BCClass2FEHelper::GetIRSrcFileSigIdxImpl() const {
+  return klass.GetIRSrcFileSigIdx();
+}
+
+bool BCClass2FEHelper::IsMultiDefImpl() const {
+  return klass.IsMultiDef();
+}
+
+std::string BCClass2FEHelper::GetSrcFileNameImpl() const {
+  return klass.GetSourceFileName();
+}
+
+// ========== BCClassField2FEHelper ==========
+FieldAttrs BCClassField2FEHelper::AccessFlag2Attribute(uint32 accessFlag) const {
+  return AccessFlag2AttributeImpl(accessFlag);
+}
+
+bool BCClassField2FEHelper::ProcessDeclImpl(MapleAllocator &allocator) {
+  (void) allocator;
+  CHECK_FATAL(false, "should not run here");
+  return false;
+}
+
+bool BCClassField2FEHelper::ProcessDeclWithContainerImpl(MapleAllocator &allocator) {
+  (void) allocator;
+  std::string klassNameMpl;
+  std::string fieldNameMpl;
+  std::string typeNameMpl;
+  bool isStatic = field.IsStatic();
+  uint64 mapIdx = (static_cast<uint64>(field.GetBCClass().GetBCParser().GetReader()->GetFileIndex()) << 32) |
+      field.GetIdx();
+  StructElemNameIdx *structElemNameIdx = FEManager::GetManager().GetFieldStructElemNameIdx(mapIdx);
+  if (structElemNameIdx == nullptr) {
+    klassNameMpl = namemangler::EncodeName(field.GetClassName());
+    fieldNameMpl = namemangler::EncodeName(field.GetName());
+    typeNameMpl = namemangler::EncodeName(field.GetDescription());
+    if (fieldNameMpl.empty()) {
+      ERR(kLncErr, "invalid name for %s field: %u in class %s", field.IsStatic() ? "static" : "instance",
+          field.GetItemIdx(), klassNameMpl.c_str());
+      return false;
+    }
+    if (typeNameMpl.empty()) {
+      ERR(kLncErr, "invalid descriptor for %s field: %u in class %s", field.IsStatic() ? "static" : "instance",
+          field.GetItemIdx(), klassNameMpl.c_str());
+      return false;
+    }
+    structElemNameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(klassNameMpl),
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fieldNameMpl),
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeNameMpl),
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(klassNameMpl + namemangler::kNameSplitterStr +
+            fieldNameMpl + namemangler::kNameSplitterStr + typeNameMpl));
+    FEManager::GetManager().SetFieldStructElemNameIdx(mapIdx, *structElemNameIdx);
+  } else {
+    klassNameMpl = GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx->klass);
+    fieldNameMpl = GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx->elem);
+    typeNameMpl = GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx->type);
+  }
+  FEStructElemInfo *elemInfo = FEManager::GetTypeManager().RegisterStructFieldInfo(
+      *structElemNameIdx, kSrcLangJava, isStatic);
+  elemInfo->SetDefined();
+  elemInfo->SetFromDex();
+  // control anti-proguard through FEOptions only.
+  FEOptions::ModeJavaStaticFieldName modeStaticField = FEOptions::GetInstance().GetModeJavaStaticFieldName();
+  bool withType = (modeStaticField == FEOptions::kAllType) ||
+                  (isStatic && modeStaticField == FEOptions::kSmart);
+  GStrIdx idx;
+  if (!isStatic && !withType) {
+    idx = structElemNameIdx->elem;
+  } else if (isStatic && withType) {
+    idx = structElemNameIdx->full;
+  } else {
+    std::string name = isStatic ? (klassNameMpl + namemangler::kNameSplitterStr) : "";
+    name += fieldNameMpl;
+    name += withType ? (namemangler::kNameSplitterStr + typeNameMpl) : "";
+    idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  }
+  FieldAttrs attrs = AccessFlag2Attribute(field.GetAccessFlag());
+  MIRType *fieldType = FEManager::GetTypeManager().GetOrCreateTypeFromName(typeNameMpl, FETypeFlag::kSrcUnknown, true);
+  ASSERT(fieldType != nullptr, "nullptr check for fieldType");
+  mirFieldPair.first = idx;
+  mirFieldPair.second.first = fieldType->GetTypeIndex();
+  mirFieldPair.second.second = attrs;
+  return true;
+}
+
+// ========== BCClassMethod2FEHelper ==========
+BCClassMethod2FEHelper::BCClassMethod2FEHelper(MapleAllocator &allocator, std::unique_ptr<BCClassMethod> &methodIn)
+    : FEInputMethodHelper(allocator),
+      method(methodIn) {
+  srcLang = kSrcLangJava;
+}
+
+bool BCClassMethod2FEHelper::ProcessDeclImpl(MapleAllocator &allocator) {
+  uint64 mapIdx = (static_cast<uint64>(method->GetBCClass().GetBCParser().GetReader()->GetFileIndex()) << 32) |
+      method->GetIdx();
+  StructElemNameIdx *structElemNameIdx = FEManager::GetManager().GetMethodStructElemNameIdx(mapIdx);
+  if (structElemNameIdx == nullptr) {
+    structElemNameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(
+        method->GetClassName(), method->GetName(), method->GetDescription());
+    FEManager::GetManager().SetMethodStructElemNameIdx(mapIdx, *structElemNameIdx);
+  }
+  const std::string &methodShortName = method->GetName();
+  CHECK_FATAL(!methodShortName.empty(), "error: method name is empty");
+  if (methodShortName.compare("main") == 0) {
+    FEManager::GetMIRBuilder().GetMirModule().SetEntryFuncName(
+        GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx->full));
+  }
+  methodNameIdx = structElemNameIdx->full;
+  SolveReturnAndArgTypes(allocator);
+  FuncAttrs attrs = GetAttrs();
+  bool isStatic = IsStatic();
+  bool isVarg = IsVarg();
+  CHECK_FATAL(retType != nullptr, "function must have return type");
+  MIRType *mirReturnType = nullptr;
+  bool usePtr = (srcLang == kSrcLangJava);
+  if (retType->GetPrimType() == PTY_void) {
+    mirReturnType = retType->GenerateMIRType(srcLang, false);
+  } else {
+    mirReturnType = retType->GenerateMIRType(srcLang, usePtr);
+  }
+  ASSERT(mirReturnType != nullptr, "return type is nullptr");
+  std::vector<TyIdx> argsTypeIdx;
+  for (FEIRType *type : argTypes) {
+    MIRType *argType = type->GenerateMIRType(srcLang, usePtr);
+    argsTypeIdx.emplace_back(argType->GetTypeIndex());
+  }
+  FEStructElemInfo *elemInfo = FEManager::GetTypeManager().RegisterStructMethodInfo(
+      *structElemNameIdx, kSrcLangJava, isStatic);
+  elemInfo->SetDefined();
+  elemInfo->SetFromDex();
+  mirFunc = FEManager::GetTypeManager().CreateFunction(methodNameIdx, mirReturnType->GetTypeIndex(),
+                                                       argsTypeIdx, isVarg, isStatic);
+  mirMethodPair.first = mirFunc->GetStIdx();
+  mirMethodPair.second.first = mirFunc->GetMIRFuncType()->GetTypeIndex();
+  mirMethodPair.second.second = attrs;
+  mirFunc->SetFuncAttrs(attrs);
+  return true;
+}
+
+std::string BCClassMethod2FEHelper::GetMethodNameImpl(bool inMpl, bool full) const {
+  std::string klassName = method->GetClassName();
+  std::string methodName = method->GetName();
+  if (!full) {
+    return inMpl ? namemangler::EncodeName(methodName) : methodName;
+  }
+  std::string descName = method->GetDescription();
+  std::string fullName = klassName + "|" + methodName + "|" + descName;
+  return inMpl ? namemangler::EncodeName(fullName) : fullName;
+}
+
+void BCClassMethod2FEHelper::SolveReturnAndArgTypesImpl(MapleAllocator &allocator) {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  std::string klassName = method->GetClassName();
+  std::string methodName = GetMethodName(false);
+  if (HasThis()) {
+    FEIRTypeDefault *type = mp->New<FEIRTypeDefault>();
+    type->LoadFromJavaTypeName(klassName, false);
+    argTypes.push_back(type);
+  }
+  const std::vector<std::string> &returnAndArgTypeNames = FEUtilJava::SolveMethodSignature(methodName);
+  bool first = true;
+  for (const std::string &typeName : returnAndArgTypeNames) {
+    FEIRTypeDefault *type = mp->New<FEIRTypeDefault>();
+    type->LoadFromJavaTypeName(typeName, false);
+    if (first) {
+      retType = type;
+      first = false;
+    } else {
+      argTypes.push_back(type);
+    }
+  }
+}
+
+bool BCClassMethod2FEHelper::IsVargImpl() const {
+  return false;  // No variable arguments
+}
+
+bool BCClassMethod2FEHelper::HasThisImpl() const {
+  return !IsStatic();
+}
+
+MIRType *BCClassMethod2FEHelper::GetTypeForThisImpl() const {
+  FEIRTypeDefault type;
+  const std::string &klassName = method->GetClassName();
+  type.LoadFromJavaTypeName(klassName, false);
+  return type.GenerateMIRType(true);
+}
+
+bool BCClassMethod2FEHelper::IsVirtualImpl() const {
+  return method->IsVirtual();
+}
+
+bool BCClassMethod2FEHelper::IsNativeImpl() const {
+  return method->IsNative();
+}
+
+bool BCClassMethod2FEHelper::HasCodeImpl() const {
+  return method->HasCode();
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/common/src/bc_function.cpp b/src/hir2mpl/bytecode_input/common/src/bc_function.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9c5633b0992ab125b8f2309312418ac7a24c19bd
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/bc_function.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bc_function.h"
+#include "fe_macros.h"
+#include "fe_manager.h"
+#include "feir_type_helper.h"
+#include "feir_builder.h"
+#include "rc_setter.h"
+
+namespace maple {
+namespace bc {
+BCFunction::BCFunction(const BCClassMethod2FEHelper &argMethodHelper, MIRFunction &mirFunc,
+                       const std::unique_ptr<FEFunctionPhaseResult> &argPhaseResultTotal)
+    : FEFunction(mirFunc, argPhaseResultTotal),
+      methodHelper(argMethodHelper),
+      method(methodHelper.GetMethod()) {}
+
+void BCFunction::PreProcessImpl() {
+  ;  // Empty
+}
+
+void BCFunction::InitImpl() {
+  FEFunction::InitImpl();
+}
+
+void BCFunction::SetMIRFunctionInfo() {
+  GStrIdx idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(method->GetFullName());
+  SET_FUNC_INFO_PAIR(mirFunction, "INFO_fullname", idx, true);
+  idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(method->GetClassName());
+  SET_FUNC_INFO_PAIR(mirFunction, "INFO_classname", idx, true);
+  idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(method->GetName());
+  SET_FUNC_INFO_PAIR(mirFunction, "INFO_funcname", idx, true);
+  SET_FUNC_INFO_PAIR(mirFunction, "INFO_methodidx", method->GetIdx(), false);
+  SET_FUNC_INFO_PAIR(mirFunction, "INFO_registers", method->GetRegisterTotalSize(), false);
+  SET_FUNC_INFO_PAIR(mirFunction, "INFO_tries_size", method->GetTriesSize(), false);
+  SET_FUNC_INFO_PAIR(mirFunction, "INFO_dexthisreg", method->GetThisRegNum(), false);
+  SET_FUNC_INFO_PAIR(mirFunction, "INFO_codeoff", method->GetCodeOff(), false);
+}
+
+bool BCFunction::ProcessImpl() {
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "BCFunction::Process() for %s", method->GetFullName().c_str());
+  bool success = true;
+  method->GetBCClass().GetBCParser().ProcessMethodBody(*method,
+                                                       method->GetBCClass().GetClassIdx(),
+                                                       method->GetItemIdx(),
+                                                       method->IsVirtual());
+  SetMIRFunctionInfo();
+  success = success && GenerateArgVarList("gen arg var list");
+  success = success && EmitToFEIRStmt("emit to feir");
+  success = success && ProcessFEIRFunction();
+  if (!success) {
+    error = true;
+    ERR(kLncErr, "BCFunction::Process() failed for %s", method->GetFullName().c_str());
+  }
+  return success;
+}
+
+bool BCFunction::GenerateAliasVars(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  if (method == nullptr || method->GetSrcLocalInfoPtr() == nullptr) {
+    return phaseResult.Finish(true);
+  }
+  // map<regNum, set<tuple<name, typeName, signature>>>
+  for (auto &local : *method->GetSrcLocalInfoPtr()) {
+    for (auto &item : local.second) {
+      if (std::get<0>(item) == "this") {
+        continue;
+      }
+      UniqueFEIRType type = FEIRTypeHelper::CreateTypeByJavaName(std::get<1>(item), false, false);
+      MIRType *mirType = FEManager::GetTypeManager().GetOrCreateTypeFromName(
+          namemangler::EncodeName(std::get<1>(item)), FETypeFlag::kSrcUnknown, true);
+      UniqueFEIRVar localVar = FEIRBuilder::CreateVarReg(local.first, std::move(type));
+      GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::EncodeName(std::get<0>(item)));
+      MIRAliasVars aliasVar;
+      aliasVar.mplStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(localVar->GetName(*mirType));
+      aliasVar.atk = kATKType;
+      aliasVar.index = mirType->GetTypeIndex().GetIdx();
+      aliasVar.isLocal = !localVar->IsGlobal();
+      if (!std::get<2>(item).empty()) {
+        aliasVar.sigStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(std::get<2>(item));
+      }
+      mirFunction.SetAliasVarMap(nameIdx, aliasVar);
+    }
+  }
+  return phaseResult.Finish(true);
+}
+
+bool BCFunction::ProcessFEIRFunction() {
+  bool success = true;
+  success = success && UpdateRegNum2This("fe/update reg num to this pointer");
+  return success;
+}
+
+bool BCFunction::GenerateArgVarList(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  argVarList = method->GenArgVarList();
+  return phaseResult.Finish();
+}
+
+bool BCFunction::EmitToFEIRStmt(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  std::list<UniqueFEIRStmt> feirStmts = method->EmitInstructionsToFEIR();
+  AppendFEIRStmts(feirStmts);
+  return phaseResult.Finish(true);
+}
+
+void BCFunction::FinishImpl() {
+  (void)UpdateFormal("finish/update formal");
+  (void)EmitToMIR("finish/emit to mir");
+  (void)GenerateAliasVars("finish/generate alias vars");
+  if (FEOptions::GetInstance().IsRC()) {
+    RCSetter::GetRCSetter().GetUnownedVarInLocalVars(*method, mirFunction);
+  }
+  bool recordTime = FEOptions::GetInstance().IsDumpPhaseTime() || FEOptions::GetInstance().IsDumpPhaseTimeDetail();
+  if (phaseResultTotal != nullptr && recordTime) {
+    phaseResultTotal->Combine(phaseResult);
+  }
+  if (FEOptions::GetInstance().IsDumpPhaseTimeDetail()) {
+    INFO(kLncInfo, "[PhaseTime] function: %s", method->GetFullName().c_str());
+    phaseResult.Dump();
+  }
+  method->ReleaseMempool();
+  BCClassMethod *methodPtr = method.release();
+  delete methodPtr;
+}
+
+bool BCFunction::EmitToMIR(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  // Not gen funcbody for abstract method
+  if (methodHelper.HasCode() || methodHelper.IsNative()) {
+    mirFunction.NewBody();
+    FEManager::GetMIRBuilder().SetCurrentFunction(mirFunction);
+    FEManager::SetCurrentFEFunction(*this);
+    EmitToMIRStmt();
+  }
+  return phaseResult.Finish();
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/common/src/bc_instruction.cpp b/src/hir2mpl/bytecode_input/common/src/bc_instruction.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3edcf1646e55ea8dced98ceac506c33f0f8d2487
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/bc_instruction.cpp
@@ -0,0 +1,562 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bc_instruction.h"
+#include <algorithm>
+#include "bc_class.h"
+#include "feir_builder.h"
+#include "fe_manager.h"
+#include "fe_options.h"
+
+namespace maple {
+namespace bc {
+void BCInstruction::InitBCInStruction(uint16 kind, bool wide, bool throwable) {
+  instKind = static_cast<BCInstructionKind>(instKind | kind);
+  isWide = wide;
+  isThrowable = throwable;
+}
+
+void BCInstruction::SetWidth(uint8 size) {
+  width = size;
+}
+
+uint8 BCInstruction::GetWidth() const {
+  return width;
+}
+
+void BCInstruction::SetCatchable() {
+  isCatchable = isThrowable;
+}
+
+bool BCInstruction::IsCatchable() const {
+  return isCatchable;
+}
+
+BCInstructionKind BCInstruction::GetInstKind() const {
+  return instKind;
+}
+
+bool BCInstruction::IsWide() const {
+  return isWide;
+}
+
+void BCInstruction::SetInstructionKind(BCInstructionKind kind) {
+  instKind = static_cast<BCInstructionKind>(static_cast<uint32>(instKind) | static_cast<uint32>(kind));
+}
+
+void BCInstruction::Parse(BCClassMethod &method) {
+  ParseImpl(method);
+}
+
+void BCInstruction::SetExceptionType(const GStrIdx &typeNameIdx) {
+  catchedExTypeNamesIdx.emplace(typeNameIdx);
+  SetBCRegType(*this);
+}
+
+std::list<UniqueFEIRStmt> BCInstruction::EmitToFEIRStmts() {
+  std::list<UniqueFEIRStmt> stmts;
+  // Do not modify following stmt order
+  GenCommentStmt(stmts);
+  if ((instKind & kTarget) || (instKind & kCatch)) {
+    if (instKind & kCatch) {
+      UniqueFEIRStmt stmt = GenCatchStmt();
+      stmts.emplace_back(std::move(stmt));
+    } else {
+      UniqueFEIRStmt stmt = GenLabelStmt();
+      stmts.emplace_back(std::move(stmt));
+    }
+  }
+  if (instKind & kTryStart) {
+    UniqueFEIRStmt stmt = GenTryLabelStmt();
+    stmts.emplace_back(std::move(stmt));
+  }
+  std::list<UniqueFEIRStmt> instStmts = EmitToFEIRStmtsImpl();
+  for (auto it = instStmts.begin(); it != instStmts.end(); ++it) {
+    it->get()->SetThrowable(isThrowable);
+    if (FEOptions::GetInstance().IsAOT()) {
+      it->get()->SetHexPC(pc);
+    }
+    stmts.emplace_back(std::move(*it));
+  }
+  std::list<UniqueFEIRStmt> retypeStmts = GenRetypeStmtsAfterDef();
+  for (auto it = retypeStmts.begin(); it != retypeStmts.end(); ++it) {
+    stmts.emplace_back(std::move(*it));
+  }
+  if (instKind & kTryEnd) {
+    UniqueFEIRStmt stmt = GenTryEndLabelStmt();
+    stmts.emplace_back(std::move(stmt));
+  }
+  SetSrcFileInfo(stmts);
+  return stmts;
+}
+
+void BCInstruction::SetSrcFileInfo(std::list<UniqueFEIRStmt> &stmts) const {
+#ifdef DEBUG
+  if (FEOptions::GetInstance().IsDumpLOC() && !stmts.empty()) {
+    Loc loc = {srcFileIdx, srcFileLineNum, 0};
+    (*stmts.begin())->SetSrcLoc(loc);
+  }
+#else
+  (void) stmts;
+#endif
+}
+
+bool BCInstruction::IsFallThru() const {
+  return instKind & kFallThru;
+}
+
+bool BCInstruction::IsConditionBranch() const {
+  return instKind & kConditionBranch;
+}
+
+bool BCInstruction::IsGoto() const {
+  return instKind & kGoto;
+}
+
+bool BCInstruction::IsSwitch() const {
+  return instKind & kSwitch;
+}
+
+bool BCInstruction::IsTarget() const {
+  return instKind & kTarget;
+}
+
+bool BCInstruction::IsTryStart() const {
+  return instKind & kTryStart;
+}
+
+bool BCInstruction::IsTryEnd() const {
+  return instKind & kTryEnd;
+}
+
+bool BCInstruction::IsCatch() const {
+  return instKind & kCatch;
+}
+
+void BCInstruction::SetReturnInst(BCInstruction *inst) {
+  inst->SetBCRegType(*this);
+  returnInst = inst;
+}
+
+void BCInstruction::SetBCRegType(const BCInstruction &inst) {
+  SetBCRegTypeImpl(inst);
+}
+
+bool BCInstruction::HasReturn() const {
+  return returnInst != nullptr;
+}
+
+bool BCInstruction::IsReturn() const {
+  return isReturn;
+}
+
+uint32 BCInstruction::GetPC() const {
+  return pc;
+}
+
+uint8 BCInstruction::GetOpcode() const {
+  return opcode;
+}
+
+std::vector<uint32> BCInstruction::GetTargets() const {
+  return GetTargetsImpl();
+}
+
+void BCInstruction::SetDefaultTarget(BCInstruction *inst) {
+  defaultTarget = inst;
+}
+
+void BCInstruction::AddHandler(BCInstruction *handler) {
+  auto it = std::find(handlers.begin(), handlers.end(), handler);
+  if (it == handlers.end()) {
+    handlers.emplace_back(handler);
+  }
+}
+
+void BCInstruction::AddHandlerTarget(uint32 target) {
+  handlerTargets.emplace_back(target);
+}
+
+MapleVector<uint32> BCInstruction::GetHandlerTargets() const {
+  return handlerTargets;
+}
+
+MapleList<BCReg*> *BCInstruction::GetDefedRegs() {
+  return &defedRegs;
+}
+
+MapleList<BCReg*> *BCInstruction::GetUsedRegs() {
+  return &usedRegs;
+}
+
+void BCInstruction::SetRegTypeInTypeInfer() {
+  SetRegTypeInTypeInferImpl();
+}
+
+std::vector<uint32> BCInstruction::GetTargetsImpl() const {
+  return std::vector<uint32>{};  // Default empty, means invalid
+}
+
+void BCInstruction::GenCommentStmt(std::list<UniqueFEIRStmt> &stmts) const {
+#ifdef DEBUG
+  if (FEOptions::GetInstance().IsDumpComment()) {
+    std::ostringstream oss;
+    // 4 means 4-character width
+    oss << "LINE " << FEManager::GetManager().GetSourceFileNameFromIdx(srcFileIdx) << " : " << srcFileLineNum <<
+        ", INST_IDX : " << pc << " ||" << std::setfill('0') << std::setw(4) << std::hex << pc << ": " <<
+        (opName == nullptr ? "invalid op" : opName);
+    stmts.emplace_back(FEIRBuilder::CreateStmtComment(oss.str()));
+  }
+#else
+  (void) stmts;
+#endif
+}
+
+UniqueFEIRStmt BCInstruction::GenLabelStmt() const {
+  return std::make_unique<FEIRStmtPesudoLabel2>(funcNameIdx, pc);
+}
+
+UniqueFEIRStmt BCInstruction::GenCatchStmt() const {
+  std::unique_ptr<FEIRStmtPesudoCatch2> stmt = std::make_unique<FEIRStmtPesudoCatch2>(funcNameIdx, pc);
+  for (const auto &exTypeNameIdx : catchedExTypeNamesIdx) {
+    stmt->AddCatchTypeNameIdx(exTypeNameIdx);
+  }
+  return stmt;
+}
+
+UniqueFEIRStmt BCInstruction::GenTryLabelStmt() const {
+  std::unique_ptr<FEIRStmtPesudoJavaTry2>  javaTry = std::make_unique<FEIRStmtPesudoJavaTry2>(funcNameIdx);
+  for (const auto &handler : handlers) {
+    javaTry->AddCatchLabelIdx(handler->GetPC());
+  }
+  return javaTry;
+}
+
+UniqueFEIRStmt BCInstruction::GenTryEndLabelStmt() const {
+  return std::make_unique<FEIRStmtPesudoEndTry>();
+}
+
+std::list<UniqueFEIRStmt> BCInstruction::GenRetypeStmtsAfterDef() const {
+  std::list<UniqueFEIRStmt> stmts;
+  for (BCReg *reg : defedRegs) {
+    std::list<UniqueFEIRStmt> stmts0 = reg->GenRetypeStmtsAfterDef();
+    for (auto &stmt : stmts0) {
+      stmts.emplace_back(std::move(stmt));
+    }
+  }
+  return stmts;
+}
+
+std::list<UniqueFEIRStmt> BCInstruction::GenRetypeStmtsBeforeUse() const {
+  std::list<UniqueFEIRStmt> stmts;
+  for (BCReg *reg : usedRegs) {
+    std::list<UniqueFEIRStmt> stmts0 = reg->GenRetypeStmtsBeforeUse();
+    for (auto &stmt : stmts0) {
+      stmts.emplace_back(std::move(stmt));
+    }
+  }
+  return stmts;
+}
+
+void BCInstruction::SetFuncNameIdx(const GStrIdx &methodIdx) {
+  funcNameIdx = methodIdx;
+}
+
+void BCInstruction::SetSrcPositionInfo(uint32 fileIdxIn, uint32 lineNumIn) {
+  srcFileIdx = fileIdxIn;
+  srcFileLineNum = lineNumIn;
+}
+
+
+void BCInstruction::SetOpName(const char *name) {
+#ifdef DEBUG
+  opName = name;
+#else
+  (void) name;
+#endif
+}
+
+const char *BCInstruction::GetOpName() const {
+#ifdef DEBUG
+  return opName;
+#else
+  return nullptr;
+#endif
+}
+
+// ========== BCRegTypeItem ==========
+PrimType BCRegTypeItem::GetPrimType() const {
+  return GetBasePrimType();
+}
+
+PrimType BCRegTypeItem::GetBasePrimType() const {
+  return BCUtil::GetPrimType(typeNameIdx);
+}
+
+bool BCRegTypeItem::IsMorePreciseType(const BCRegTypeItem &typeItemIn) const {
+  if (IsRef() && !typeItemIn.IsRef()) {
+    return true;
+  } else if (!IsRef() && typeItemIn.IsRef()) {
+    return false;
+  } else if (IsRef() && typeItemIn.IsRef()) {
+    const std::string &name0 = GlobalTables::GetStrTable().GetStringFromStrIdx(typeNameIdx);
+    const std::string &name1 = GlobalTables::GetStrTable().GetStringFromStrIdx(typeItemIn.typeNameIdx);
+    uint8 dim0 = FEUtils::GetDim(name0);
+    uint8 dim1 = FEUtils::GetDim(name1);
+    if (dim0 == dim1) {
+      GStrIdx name0Idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name0.substr(dim0));
+      GStrIdx name1Idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name1.substr(dim0));
+      if (name0Idx == name1Idx || dim0 == 0) {
+        if (!isIndeterminate && typeItemIn.isIndeterminate) {
+          return true;
+        } else if (isIndeterminate && !typeItemIn.isIndeterminate) {
+          return false;
+        } else if (isIndeterminate && typeItemIn.isIndeterminate) {
+          return name1Idx == BCUtil::GetJavaObjectNameMplIdx();
+        } else {
+          return isFromDef ?
+                 (name0Idx == BCUtil::GetJavaObjectNameMplIdx() || name1Idx != BCUtil::GetJavaObjectNameMplIdx()) :
+                 (name0Idx != BCUtil::GetJavaObjectNameMplIdx() || name1Idx == BCUtil::GetJavaObjectNameMplIdx());
+        }
+      } else {
+        BCRegTypeItem item0(name0Idx, isIndeterminate);
+        BCRegTypeItem item1(name1Idx, typeItemIn.isIndeterminate);
+        return item0.IsMorePreciseType(item1);
+      }
+    } else {
+      return dim0 > dim1;
+    }
+  } else {
+    if (!isIndeterminate && typeItemIn.isIndeterminate) {
+      return true;
+    } else if (isIndeterminate && !typeItemIn.isIndeterminate) {
+      return false;
+    } else {
+      return BCUtil::IsMorePrecisePrimitiveType(typeNameIdx, typeItemIn.typeNameIdx);
+    }
+  }
+}
+
+// ========== BCRegType ==========
+BCRegType::BCRegType(MapleAllocator &allocatorIn, BCReg &reg, const GStrIdx &typeNameIdxIn, bool isIndeterminateIn)
+    : allocator(allocatorIn), curReg(reg),
+      regTypeItem(allocator.GetMemPool()->New<BCRegTypeItem>(typeNameIdxIn, isIndeterminateIn, true)),
+      fuzzyTypesUsedAs(allocator.Adapter()),
+      elemTypes(allocator.Adapter()),
+      livesBegins(allocator.Adapter()) {
+  curReg.regTypeItem = regTypeItem;
+  if (isIndeterminateIn) {
+    fuzzyTypesUsedAs.emplace_back(regTypeItem);
+  }
+}
+
+void BCRegType::PrecisifyTypes(bool isTry) {
+  if (precisified) {
+    return;
+  }
+  if (!isTry) {
+    precisified = true;
+  }
+  if (curReg.IsConstZero() || typesUsedAs == nullptr || typesUsedAs->empty()) {
+    return;
+  }
+  // insert defed type into `used`
+  typesUsedAs->emplace_back(regTypeItem);
+  BCRegTypeItem *realType = nullptr;
+  PrecisifyRelatedTypes(realType);
+  if (fuzzyTypesUsedAs.size() != 0 || realType == nullptr) {
+    if (realType == nullptr || realType->isIndeterminate) {
+      realType = GetMostPreciseType(*typesUsedAs);
+      if (realType != nullptr) {
+        for (auto &elem : fuzzyTypesUsedAs) {
+          elem->Copy(*realType);
+        }
+      }
+    }
+  }
+  if (!realType->isIndeterminate) {
+    PrecisifyElemTypes(realType);
+  }
+}
+
+void BCRegType::PrecisifyRelatedTypes(const BCRegTypeItem *realType) {
+  for (auto rType : relatedBCRegTypes) {
+    // try to get type from use first.
+    // if failed, get type from def.
+    rType->PrecisifyTypes(true);
+    if (rType->IsIndeterminate()) {
+      if (realType == nullptr) {
+        realType = GetMostPreciseType(*typesUsedAs);
+        if (realType != nullptr) {
+          for (auto &fuzzyTy : fuzzyTypesUsedAs) {
+            fuzzyTy->Copy(*realType);
+          }
+        }
+      }
+      if (!realType->isIndeterminate) {
+        rType->PrecisifyTypes(true);
+      }
+    } else {
+      rType->precisified = true;
+    }
+  }
+}
+
+void BCRegType::PrecisifyElemTypes(const BCRegTypeItem *arrayType) {
+  for (auto elem : elemTypes) {
+    if (elem->isIndeterminate) {
+      const std::string &arrTypeName = GlobalTables::GetStrTable().GetStringFromStrIdx(arrayType->typeNameIdx);
+      if (arrTypeName.size() > 1 && arrTypeName.at(0) == 'A') {
+        GStrIdx elemTypeIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(arrTypeName.substr(1));
+        elem->typeNameIdx = elemTypeIdx;
+        elem->isIndeterminate = false;
+      } else {
+        CHECK_FATAL(curReg.regValue != nullptr, "Not an array type or const 0");
+      }
+    }
+  }
+}
+
+BCRegTypeItem *BCRegType::GetMostPreciseType(const MapleList<BCRegTypeItem*> &types) {
+  BCRegTypeItem *retType = nullptr;
+  if (types.empty()) {
+    return retType;
+  }
+  auto it = types.begin();
+  retType = *it;
+  ++it;
+  while (it != types.end()) {
+    if ((*it)->IsMorePreciseType(*retType)) {
+      retType = *it;
+    }
+    ++it;
+  }
+  return retType;
+}
+
+// ========== BCReg ==========
+PrimType BCReg::GetPrimType() const {
+  return regTypeItem->GetPrimType();
+}
+
+PrimType BCReg::GetBasePrimType() const {
+  return regTypeItem->GetBasePrimType();
+}
+
+bool BCReg::IsConstZero() const {
+  if (regValue != nullptr) {
+    return regValue->primValue.raw32 == 0;
+  }
+  return false;
+}
+
+UniqueFEIRType BCReg::GenFEIRType() const {
+  return GenFEIRTypeImpl();
+}
+
+UniqueFEIRVar BCReg::GenFEIRVarReg() const {
+  return GenFEIRVarRegImpl();
+}
+
+UniqueFEIRVar BCReg::GenFEIRVarRegImpl() const {
+  return std::make_unique<FEIRVarReg>(regNum, GenFEIRTypeImpl());
+}
+
+UniqueFEIRType BCReg::GenFEIRTypeImpl() const {
+  PrimType pty = GetBasePrimType();
+  return std::make_unique<FEIRTypeDefault>(pty, regTypeItem->typeNameIdx);
+}
+
+std::list<UniqueFEIRStmt> BCReg::GenRetypeStmtsAfterDef() const {
+  std::list<UniqueFEIRStmt> retypeStmts;
+  // Not gen retype stmt for use reg, same def-use type reg.
+  if (!isDef) {
+    return retypeStmts;
+  }
+  std::unique_ptr<BCReg> dstReg = this->Clone();
+  std::unique_ptr<BCRegTypeItem> tmpItem = std::make_unique<BCRegTypeItem>(GStrIdx(0), false);
+  dstReg->regTypeItem = tmpItem.get();
+  PrimType ptyDef = regTypeItem->GetPrimType();
+
+  std::list<BCRegTypeItem*> unqTypeItems;
+  if (regType->GetUsedTypes() != nullptr) {
+    for (const auto &usedType : *(regType->GetUsedTypes())) {
+      bool exist = false;
+      for (auto &elem : unqTypeItems) {
+        if ((*usedType) == (*elem)) {
+          if (usedType->IsDom()) {
+            elem->SetDom(true);
+          }
+          exist = true;
+          break;
+        }
+      }
+      if (exist == false) {
+        unqTypeItems.emplace_back(usedType);
+      }
+    }
+  }
+
+  for (const auto &usedType : unqTypeItems) {
+    PrimType ptyUsed = usedType->GetPrimType();
+    if ((*usedType) == (*regTypeItem) ||
+        (usedType->isIndeterminate &&
+         ((ptyUsed == PTY_i64 && ptyDef == PTY_f64) || (ptyUsed == PTY_i32 && ptyDef == PTY_f32)))) {
+      continue;
+    }
+    // Create retype stmt
+    dstReg->regTypeItem->Copy(*usedType);
+    UniqueFEIRStmt retypeStmt =
+        FEIRBuilder::CreateStmtRetype(dstReg->GenFEIRVarReg(), this->GenFEIRVarReg());
+    if (retypeStmt != nullptr) {
+      if (FEOptions::GetInstance().IsAOT() && usedType->IsDom()) {
+        retypeStmt->SetHexPC(regType->GetPos());
+      }
+      retypeStmts.emplace_back(std::move(retypeStmt));
+    }
+  }
+  return retypeStmts;
+}
+
+std::list<UniqueFEIRStmt> BCReg::GenRetypeStmtsBeforeUse() const {
+  std::list<UniqueFEIRStmt> retypeStmts;
+  // Not gen retype stmt for def reg, same def-use type reg.
+  // And Not gen retype stmt, if the defiend type is indeterminate.
+  const BCRegTypeItem *defed = regType->GetRegTypeItem();
+  if (isDef) {
+    return retypeStmts;
+  }
+  if (!((*regTypeItem) == (*defed))) {
+    BCReg srcReg;
+    std::unique_ptr<BCRegTypeItem> tmpItem = std::make_unique<BCRegTypeItem>(GStrIdx(0), false);
+    srcReg.regTypeItem = tmpItem.get();
+    // Create retype stmt
+    srcReg.regNum = regNum;
+    srcReg.regTypeItem->Copy(*defed);
+    UniqueFEIRStmt retypeStmt =
+        FEIRBuilder::CreateStmtRetype(this->GenFEIRVarReg(), srcReg.GenFEIRVarReg());
+    if (retypeStmt != nullptr) {
+      retypeStmts.emplace_back(std::move(retypeStmt));
+    }
+  }
+  return retypeStmts;
+}
+
+std::unique_ptr<BCReg> BCReg::CloneImpl() const {
+  auto reg = std::make_unique<BCReg>();
+  *reg = *this;
+  return reg;
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/common/src/bc_io.cpp b/src/hir2mpl/bytecode_input/common/src/bc_io.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fab0438a6a3f3e437d0d38ca056382726f08d714
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/bc_io.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bc_io.h"
+namespace maple {
+namespace bc {
+BCIO::BCIO(const std::string &fileName) : BasicIOMapFile(fileName), isBigEndianHost(IsBigEndian()) {}
+
+BCReader::BCReader(const std::string &fileName) : BCIO(fileName), BasicIORead(*this, false) {}
+
+BCReader::~BCReader() {
+  Close();
+}
+
+bool BCReader::RetrieveHeader(RawData &data) {
+  return RetrieveHeaderImpl(data);
+}
+
+void BCReader::SetEndianTag(bool isBigEndianIn) {
+  isBigEndian = isBigEndianIn;
+}
+
+bool BCReader::RetrieveHeaderImpl(RawData &data) {
+  (void)data;
+  CHECK_FATAL(false, "NIY");
+  return false;
+}
+
+std::string BCReader::GetStringFromIdx(uint32 idx) const {
+  return GetStringFromIdxImpl(idx);
+}
+
+std::string BCReader::GetTypeNameFromIdx(uint32 idx) const {
+  return GetTypeNameFromIdxImpl(idx);
+}
+
+BCReader::ClassElem BCReader::GetClassMethodFromIdx(uint32 idx) const {
+  return GetClassMethodFromIdxImpl(idx);
+}
+
+BCReader::ClassElem BCReader::GetClassFieldFromIdx(uint32 idx) const {
+  return GetClassFieldFromIdxImpl(idx);
+}
+
+std::string BCReader::GetSignature(uint32 idx) const {
+  return GetSignatureImpl(idx);
+}
+
+uint32 BCReader::GetFileIndex() const {
+  return GetFileIndexImpl();
+}
+
+std::string BCReader::GetIRSrcFileSignature() const {
+  return irSrcFileSignature;
+}
+}  // namespace bc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/src/bc_parser_base.cpp b/src/hir2mpl/bytecode_input/common/src/bc_parser_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..89ba8f0bf287b5dac8d16c38843dca212df70876
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/bc_parser_base.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bc_parser_base.h"
+#include "mpl_logging.h"
+#include "mir_module.h"
+namespace maple {
+namespace bc {
+BCParserBase::BCParserBase(uint32 fileIdxIn, const std::string &fileNameIn, const std::list<std::string> &classNamesIn)
+    : fileIdx(fileIdxIn), fileName(fileNameIn), classNames(classNamesIn),
+      fileNameHashId(-1) {}
+
+const BCReader *BCParserBase::GetReader() const {
+  return GetReaderImpl();
+}
+
+bool BCParserBase::OpenFile() {
+  return OpenFileImpl();
+}
+
+bool BCParserBase::ParseHeader() {
+  return ParseHeaderImpl();
+}
+
+bool BCParserBase::Verify() {
+  return VerifyImpl();
+}
+
+uint32 BCParserBase::CalculateCheckSum(const uint8 *data, uint32 size) {
+  return CalculateCheckSumImpl(data, size);
+}
+
+bool BCParserBase::RetrieveClasses(std::list<std::unique_ptr<BCClass>> &klasses) {
+  if (RetrieveIndexTables() == false) {
+    ERR(kLncErr, "RetrieveIndexTables failed");
+    return false;
+  }
+  if (!classNames.empty()) {
+    return RetrieveUserSpecifiedClasses(klasses);
+  } else {
+    return RetrieveAllClasses(klasses);
+  }
+}
+
+bool BCParserBase::CollectAllDepTypeNames(std::unordered_set<std::string> &depSet) {
+  return CollectAllDepTypeNamesImpl(depSet);
+}
+
+bool BCParserBase::CollectMethodDepTypeNames(std::unordered_set<std::string> &depSet, BCClassMethod &bcMethod) const {
+  return CollectMethodDepTypeNamesImpl(depSet, bcMethod);
+}
+
+bool BCParserBase::CollectAllClassNames(std::unordered_set<std::string> &classSet) {
+  return CollectAllClassNamesImpl(classSet);
+}
+}  // namespace bc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/src/bc_pragma.cpp b/src/hir2mpl/bytecode_input/common/src/bc_pragma.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8d432ec58cae12dba602a297b3afa69bd96c5cbd
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/bc_pragma.cpp
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bc_pragma.h"
+namespace maple {
+namespace bc {
+std::vector<MIRPragma*> &BCAnnotationsDirectory::EmitPragmasImpl() {
+  CHECK_FATAL(false, "this method must be overrided!!!");
+  return pragmas;
+}
+}  // namespace bc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/common/src/bc_util.cpp b/src/hir2mpl/bytecode_input/common/src/bc_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c6f04d880e6223dd0560aa137f265b2bed35cc8b
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/bc_util.cpp
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bc_util.h"
+#include "fe_utils.h"
+#include "fe_options.h"
+#include "mpl_logging.h"
+namespace maple {
+namespace bc {
+const std::string BCUtil::kUnknown = "Unknown";
+const std::string BCUtil::kPrimitive = "Primitive";
+const std::string BCUtil::kBoolean = "Z";
+const std::string BCUtil::kByte = "B";
+const std::string BCUtil::kShort = "S";
+const std::string BCUtil::kChar = "C";
+const std::string BCUtil::kInt = "I";
+const std::string BCUtil::kLong = "J";
+const std::string BCUtil::kFloat = "F";
+const std::string BCUtil::kDouble = "D";
+const std::string BCUtil::kVoid = "V";
+const std::string BCUtil::kWide = "wide";
+const std::string BCUtil::kAggregate = "Aggregate";
+const std::string BCUtil::kJavaObjectName = "Ljava/lang/Object;";
+const std::string BCUtil::kJavaStringName = "Ljava/lang/String;";
+const std::string BCUtil::kJavaByteClassName = "Ljava/lang/Byte;";
+const std::string BCUtil::kJavaShortClassName = "Ljava/lang/Short;";
+const std::string BCUtil::kJavaIntClassName = "Ljava/lang/Integer;";
+const std::string BCUtil::kJavaLongClassName = "Ljava/lang/Long;";
+const std::string BCUtil::kJavaFloatClassName = "Ljava/lang/Float;";
+const std::string BCUtil::kJavaDoubleClassName = "Ljava/lang/Double;";
+const std::string BCUtil::kJavaCharClassName = "Ljava/lang/Character;";
+const std::string BCUtil::kJavaBoolClassName = "Ljava/lang/Boolean;";
+const std::string BCUtil::kJavaClassName = "Ljava/lang/Class;";
+const std::string BCUtil::kJavaMethodHandleName = "Ljava/lang/invoke/MethodHandle;";
+const std::string BCUtil::kJavaExceptionName = "Ljava/lang/Exception;";
+const std::string BCUtil::kJavaThrowableName = "Ljava/lang/Throwable;";
+
+const std::string BCUtil::kJavaMethodHandleInvoke = "Ljava/lang/invoke/MethodHandle;|invoke|";
+const std::string BCUtil::kJavaMethodHandleInvokeExact = "Ljava/lang/invoke/MethodHandle;|invokeExact|";
+
+const std::string BCUtil::kABoolean = "AZ";
+const std::string BCUtil::kAByte = "AB";
+const std::string BCUtil::kAShort = "AS";
+const std::string BCUtil::kAChar = "AC";
+const std::string BCUtil::kAInt = "AI";
+const std::string BCUtil::kALong = "AJ";
+const std::string BCUtil::kAFloat = "AF";
+const std::string BCUtil::kADouble = "AD";
+const std::string BCUtil::kAJavaObjectName = "ALjava/lang/Object;";
+
+bool BCUtil::IsWideType(const GStrIdx &name) {
+  return name == GetDoubleIdx() || name == GetLongIdx();
+}
+
+bool BCUtil::IsMorePrecisePrimitiveType(const GStrIdx &name0, const GStrIdx &name1) {
+  static std::vector<GStrIdx> typeWidthMap = {
+      BCUtil::GetVoidIdx(),
+      BCUtil::GetBooleanIdx(),
+      BCUtil::GetByteIdx(),
+      BCUtil::GetCharIdx(),
+      BCUtil::GetShortIdx(),
+      BCUtil::GetIntIdx(),
+      BCUtil::GetFloatIdx(),
+      BCUtil::GetLongIdx(),
+      BCUtil::GetDoubleIdx()
+  };
+  if (name0 == name1) {
+    return false;
+  }
+  uint32 name0Idx = UINT32_MAX;
+  uint32 name1Idx = UINT32_MAX;
+  for (uint32 i = 0; i < typeWidthMap.size(); ++i) {
+    if (typeWidthMap[i] == name0) {
+      name0Idx = i;
+      continue;
+    }
+    if (typeWidthMap[i] == name1) {
+      name1Idx = i;
+      continue;
+    }
+  }
+  CHECK_FATAL(name0Idx != UINT32_MAX && name1Idx != UINT32_MAX, "name0's or name1's primitive type is not supported.");
+  return name0Idx > name1Idx;
+}
+
+PrimType BCUtil::GetPrimType(const GStrIdx &typeNameIdx) {
+  if (typeNameIdx == BCUtil::GetBooleanIdx()) {
+    return PTY_u1;
+  }
+  if (typeNameIdx == BCUtil::GetByteIdx()) {
+    return PTY_i8;
+  }
+  if (typeNameIdx == BCUtil::GetShortIdx()) {
+    return PTY_i16;
+  }
+  if (typeNameIdx == BCUtil::GetCharIdx()) {
+    return PTY_u16;
+  }
+  if (typeNameIdx == BCUtil::GetIntIdx()) {
+    return PTY_i32;
+  }
+  if (typeNameIdx == BCUtil::GetLongIdx()) {
+    return PTY_i64;
+  }
+  if (typeNameIdx == BCUtil::GetFloatIdx()) {
+    return PTY_f32;
+  }
+  if (typeNameIdx == BCUtil::GetDoubleIdx()) {
+    return PTY_f64;
+  }
+  if (typeNameIdx == BCUtil::GetVoidIdx()) {
+    return PTY_void;
+  }
+  // Wide, Primitive, Agg
+  return PTY_ref;
+}
+
+bool BCUtil::IsJavaReferenceType(const GStrIdx &typeNameIdx) {
+  PrimType primType = GetPrimType(typeNameIdx);
+  return (primType == PTY_ref);
+}
+
+bool BCUtil::IsJavaPrimitveType(const GStrIdx &typeNameIdx) {
+  return !IsJavaReferenceType(typeNameIdx);
+}
+
+bool BCUtil::IsJavaPrimitiveTypeName(const std::string typeName) {
+  return ((typeName == kBoolean) || (typeName == kByte) || (typeName == kBoolean) || (typeName == kShort) ||
+          (typeName == kChar) || (typeName == kInt) || (typeName == kLong) || (typeName == kFloat) ||
+          (typeName == kDouble));
+}
+
+bool BCUtil::IsArrayType(const GStrIdx &typeNameIdx) {
+  std::string typeName = GlobalTables::GetStrTable().GetStringFromStrIdx(typeNameIdx);
+  uint8 dim = FEUtils::GetDim(typeName);
+  return dim != 0;
+}
+
+std::string BCUtil::TrimArrayModifier(const std::string &typeName) {
+  std::size_t index = 0;
+  for (; index < typeName.size(); ++index) {
+    if (typeName[index] != '[') {
+      break;
+    }
+  }
+  if (index != 0) {
+    return typeName.substr(index, typeName.size());
+  } else {
+    return typeName;
+  }
+}
+
+void BCUtil::AddDefaultDepSet(std::unordered_set<std::string> &typeTable) {
+  typeTable.emplace("Ljava/lang/Class;");
+  typeTable.emplace("Ljava/lang/Runnable;");
+  typeTable.emplace("Ljava/lang/ClassLoader;");
+  typeTable.emplace("Ljava/lang/StringFactory;");
+  // pre-load dependent types for maple_ipa preinline phase
+  typeTable.emplace("Ljava/lang/System;");
+  typeTable.emplace("Ljava/lang/String;");
+  typeTable.emplace("Ljava/lang/Math;");
+  typeTable.emplace("Ljava/lang/Long;");
+  typeTable.emplace("Ljava/lang/Throwable;");
+  typeTable.emplace("Ljava/io/PrintStream;");
+  typeTable.emplace("Ljava/io/InputStream;");
+  typeTable.emplace("Lsun/misc/FloatingDecimal;");
+  typeTable.emplace("Ljava/lang/reflect/Field;");
+  typeTable.emplace("Ljava/lang/annotation/Annotation;");
+  typeTable.emplace("Ljava/lang/AbstractStringBuilder;");
+  typeTable.emplace("Ljava/io/UnixFileSystem;");
+  typeTable.emplace("Ljava/util/concurrent/atomic/AtomicInteger;");
+  typeTable.emplace("Ljava/lang/reflect/Method;");
+}
+
+// get the serial number in register name, for example 2 in Reg2_I
+uint32 BCUtil::Name2RegNum(const std::string &name) {
+  const std::size_t regPrefixLen = strlen("Reg");
+  std::size_t numLen = name.length() - regPrefixLen;
+  // Nonreg names also reach here, e.g. "_this". Make sure they are not handle.
+  const std::size_t regVarMinLen = 6;
+  if (numLen < regVarMinLen - regPrefixLen || name.compare(0, regPrefixLen, "Reg") != 0) {
+    return UINT32_MAX;
+  }
+  std::string regName = name.substr(regPrefixLen);
+  std::size_t i = 0;
+  for (; i < numLen; i++) {
+    if (regName[i] < '0' || regName[i] > '9') {
+      break;
+    }
+  }
+
+  if (i == 0) {
+    return UINT32_MAX;
+  }
+  int regNum = std::stoi(regName.substr(0, i));
+  return static_cast<uint32>(regNum);
+}
+
+bool BCUtil::HasContainSuffix(const std::string &value, const std::string &suffix) {
+  if (suffix.size() > value.size()) {
+    return false;
+  }
+  return std::equal(suffix.rbegin(), suffix.rend(), value.rbegin());
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/common/src/rc_setter.cpp b/src/hir2mpl/bytecode_input/common/src/rc_setter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..526a82ab154937be12cc99fa4706de01416efa7c
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/common/src/rc_setter.cpp
@@ -0,0 +1,444 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "rc_setter.h"
+#include <fstream>
+#include "ark_annotation_map.h"
+#include "ark_annotation_processor.h"
+#include "fe_manager.h"
+#include "bc_util.h"
+
+namespace maple {
+namespace bc {
+RCSetter *RCSetter::rcSetter = nullptr;
+
+void RCSetter::ProcessClassRCAnnotation(const GStrIdx &classIdx, const std::vector<MIRPragma*> &pragmas) {
+  if (pragmas.empty()) {
+    return;
+  }
+  MIRStructType *type = FEManager::GetTypeManager().GetStructTypeFromName(classIdx);
+  for (auto pragma : pragmas) {
+    if (pragma->GetKind() != kPragmaClass || pragma->GetStrIdx() != type->GetNameStrIdx()) {
+      continue;
+    }
+    if (!ArkAnnotation::GetInstance().IsRCUnownedOuter(pragma->GetTyIdx()) &&
+        !ArkAnnotation::GetInstance().IsRCUnownedThis(pragma->GetTyIdx())) {
+      continue;
+    }
+    const std::string &className = type->GetName();
+    MIRSymbol *jcSymbol = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl(className, *type);
+    if (jcSymbol != nullptr) {
+      jcSymbol->SetAttr(ATTR_rcunownedthis);
+    }
+    for (auto &field : type->GetFields()) {
+      std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(field.first);
+      const std::string prefix = "this_24";
+      if (fieldName.compare(0, prefix.size(), prefix) == 0) {
+        field.second.second.SetAttr(FLDATTR_rcunowned);
+      }
+    }
+  }
+}
+
+void RCSetter::ProcessMethodRCAnnotation(MIRFunction &mirFunc, const std::string &className,
+                                         MIRStructType &structType, const MIRPragma &pragma) {
+  if (ArkAnnotation::GetInstance().IsRCUnownedOuter(pragma.GetTyIdx()) ||
+      ArkAnnotation::GetInstance().IsRCUnownedThis(pragma.GetTyIdx())) {
+    // set ATTR_rcunowned to the field this$n of local class
+    // the current function belongs to
+    MIRSymbol *jcSymbol = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl(className, structType);
+    if (jcSymbol != nullptr) {
+      jcSymbol->SetAttr(ATTR_rcunownedthis);
+    }
+    for (auto &field : structType.GetFields()) {
+      const std::string &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(field.first);
+      const std::string prefix = "this_24";
+      if (fieldName.compare(0, prefix.size(), prefix) == 0) {
+        field.second.second.SetAttr(FLDATTR_rcunowned);
+      }
+    }
+  } else if (ArkAnnotation::GetInstance().IsRCUnownedCap(pragma.GetTyIdx()) ||
+             ArkAnnotation::GetInstance().IsRCUnownedCapList(pragma.GetTyIdx())) {
+    // handle old RCUnownedCapRef annotation.
+    MIRPragmaElement *elem = pragma.GetElementVector()[0];
+    if (ArkAnnotation::GetInstance().IsRCUnownedCap(pragma.GetTyIdx())) {
+      GStrIdx strIdx(elem->GetI32Val());
+      CollectUnownedLocalVars(&mirFunc, strIdx);
+    } else if (ArkAnnotation::GetInstance().IsRCUnownedCapList(pragma.GetTyIdx())) {
+      for (auto eit : elem->GetSubElemVec()) {
+        if (eit->GetSubElemVec().empty()) {
+          continue;
+        }
+        MIRPragmaElement *e = eit->GetSubElemVec()[0];
+        GStrIdx strIdx(e->GetI32Val());
+        CollectUnownedLocalVars(&mirFunc, strIdx);
+      }
+    }
+  }
+}
+
+void RCSetter::ProcessFieldRCAnnotation(const StructElemNameIdx &fieldElemNameIdx,
+    const MIRType &fieldType, const std::vector<MIRPragma*> &pragmas) {
+  if (pragmas.empty()) {
+    return;
+  }
+  for (auto pragma : pragmas) {
+    if (pragma->GetKind() != kPragmaVar ||
+        pragma->GetStrIdx() != fieldElemNameIdx.elem ||
+        pragma->GetTyIdxEx() != fieldType.GetTypeIndex()) {
+      continue;
+    }
+    if (!ArkAnnotation::GetInstance().IsRCWeak(pragma->GetTyIdx()) &&
+        !ArkAnnotation::GetInstance().IsRCUnowned(pragma->GetTyIdx())) {
+      continue;
+    }
+    FieldAttrKind attr;
+    if (ArkAnnotation::GetInstance().IsRCWeak(pragma->GetTyIdx())) {
+      attr = FLDATTR_rcweak;
+    } else if (ArkAnnotation::GetInstance().IsRCUnowned(pragma->GetTyIdx())) {
+      attr = FLDATTR_rcunowned;
+    }
+    MIRStructType *structType = FEManager::GetTypeManager().GetStructTypeFromName(fieldElemNameIdx.klass);
+    for (auto &field : structType->GetFields()) {
+      if (field.first == fieldElemNameIdx.elem) {
+        field.second.second.SetAttr(attr);
+        break;
+      }
+    }
+  }
+}
+
+void RCSetter::GetUnownedVarInLocalVars(const BCClassMethod &method, MIRFunction &mirFunction) {
+  if (method.GetSrcLocalInfoPtr() == nullptr) {
+    return;
+  }
+  std::set<uint16> unownedRegNums;
+  // map<regNum, set<tuple<name, typeName, signature>>>
+  for (auto &local : *method.GetSrcLocalInfoPtr()) {
+    for (auto &item : local.second) {
+      bool isUnowned = BCUtil::HasContainSuffix(std::get<0>(item), "$unowned");
+      if (isUnowned) {
+        GStrIdx strIdx = FEManager::GetMIRBuilder().GetOrCreateStringIndex(namemangler::EncodeName(std::get<0>(item)));
+        CollectUnownedLocalVars(&mirFunction, strIdx);
+        (void)unownedRegNums.insert(local.first);
+      }
+    }
+  }
+  // set ATTR_rcunowned for symbols according their reg num.
+  SetAttrRCunowned(mirFunction, unownedRegNums);
+}
+
+void RCSetter::SetAttrRCunowned(MIRFunction &mirFunction, const std::set<uint16> &unownedRegNums) const {
+  if (unownedRegNums.empty()) {
+    return;
+  }
+  MIRSymbolTable *symTab = mirFunction.GetSymTab();
+  if (symTab == nullptr) {
+    return;
+  }
+  for (uint32 i = 0; i < mirFunction.GetSymTab()->GetSymbolTableSize(); ++i) {
+    MIRSymbol *symbol = mirFunction.GetSymTab()->GetSymbolFromStIdx(i);
+    if (symbol == nullptr) {
+      continue;
+    }
+    MIRType *ty = symbol->GetType();
+    if (ty->GetPrimType() == PTY_ref || ty->GetPrimType() == PTY_ptr) {
+      uint32 regNum = BCUtil::Name2RegNum(symbol->GetName());
+      if (unownedRegNums.find(regNum) != unownedRegNums.end()) {
+        symbol->SetAttr(ATTR_rcunowned);
+      }
+    }
+  }
+}
+
+void RCSetter::MarkRCUnownedForUnownedLocalFunctions() const {
+  // mark all local variables unowned for @UnownedLocal functions.
+  for (auto func : unownedLocalFuncs) {
+    for (uint32 idx = 0; idx < func->GetSymTab()->GetSymbolTableSize(); idx++) {
+      MIRSymbol *sym = func->GetSymTab()->GetSymbolFromStIdx(idx);
+      if (sym == nullptr) {
+        continue;
+      }
+      MIRType *ty = sym->GetType();
+      if (ty->GetPrimType() == PTY_ref || ty->GetPrimType() == PTY_ptr) {
+        sym->SetAttr(ATTR_rcunowned);
+      }
+    }
+  }
+}
+
+bool RCSetter::IsAnonymousInner(const MIRStructType &structType) const {
+  if (!(structType.GetKind() == kTypeClass || structType.GetKind() == kTypeInterface)) {
+    return false;
+  }
+  // inner class has annotation Ldalvik/annotation/InnerClass;
+  bool isCreat = false;
+  const std::string &className =
+      ArkAnnotationMap::GetArkAnnotationMap().GetAnnotationTypeName("Ldalvik_2Fannotation_2FInnerClass_3B");
+  MIRStructType *inner = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(
+      className, true, FETypeFlag::kSrcExtern, isCreat);
+  GStrIdx strIdx = FEManager::GetMIRBuilder().GetOrCreateStringIndex("name");
+  unsigned tyIdx = inner->GetTypeIndex();
+  if (structType.GetKind() == kTypeClass) {
+    const MIRClassType &classType = static_cast<const MIRClassType&>(structType);
+    for (auto it : classType.GetPragmaVec()) {
+      if (it->GetTyIdx() == tyIdx) {
+        for (auto eit : it->GetElementVector()) {
+          // inner class and has no name
+          if (eit->GetNameStrIdx() == strIdx && eit->GetI32Val() == 0) {
+            return true;
+          }
+        }
+      }
+    }
+  } else if (structType.GetKind() == kTypeInterface) {
+    const MIRInterfaceType &interfaceType = static_cast<const MIRInterfaceType&>(structType);
+    for (auto it : interfaceType.GetPragmaVec()) {
+      if (it->GetTyIdx() == tyIdx) {
+        for (auto eit : it->GetElementVector()) {
+          // inner class and has no name
+          if (eit->GetNameStrIdx() == strIdx && eit->GetI32Val() == 0) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
+bool RCSetter::IsMethodEnclosing(const MIRFunction &func, const MIRStructType &structType) const {
+  if (!(structType.GetKind() == kTypeClass || structType.GetKind() == kTypeInterface)) {
+    return false;
+  }
+  bool isCreat = false;
+  const std::string &className = namemangler::GetInternalNameLiteral(
+      ArkAnnotationMap::GetArkAnnotationMap().GetAnnotationTypeName("Ldalvik_2Fannotation_2FEnclosingMethod_3B"));
+  MIRStructType *inner = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(
+      className, true, FETypeFlag::kSrcExtern, isCreat);
+  unsigned tyIdx = inner->GetTypeIndex();
+  if (structType.GetKind() == kTypeClass) {
+    const MIRClassType &classType = static_cast<const MIRClassType&>(structType);
+    for (auto it : classType.GetPragmaVec()) {
+      if (it->GetTyIdx() == tyIdx && !(it->GetElementVector().empty()) &&
+          func.GetNameStrIdx() == it->GetElementVector()[0]->GetI32Val()) {
+        return true;
+      }
+    }
+  } else if (structType.GetKind() == kTypeInterface) {
+    const MIRInterfaceType &interfaceType = static_cast<const MIRInterfaceType&>(structType);
+    for (auto it : interfaceType.GetPragmaVec()) {
+      if (it->GetTyIdx() == tyIdx && (!it->GetElementVector().empty()) &&
+          func.GetNameStrIdx() == it->GetElementVector()[0]->GetI32Val()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void RCSetter::MarkRCUnownedForAnonymousClasses() const {
+  // mark captured unowned fields for anonymous class.
+  for (auto mit : unownedLocalVars) {
+    MIRFunction *func = mit.first;
+    // check for anonymous class
+    // mark captured var name aaa -> val$aaa (or val_24aaa) field in anonymous class
+    for (auto sit : FEManager::GetTypeManager().GetStructNameTypeMap()) {
+      ASSERT_NOT_NULL(sit.second.first);
+      if (IsAnonymousInner(*(sit.second.first)) && IsMethodEnclosing(*func, *(sit.second.first))) {
+        for (auto &fit : sit.second.first->GetFields()) {
+          const std::string &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fit.first);
+          constexpr size_t prefixLength = sizeof("val_24") - 1;
+          if (fieldName.compare(0, prefixLength, "val_24") == 0) {
+            std::string nameWithSuffix = fieldName + "_24unowned";
+            for (auto nit : mit.second) {
+              GStrIdx strIdx(nit);
+              const std::string &varName = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+              if (nameWithSuffix.compare(prefixLength, varName.length(), varName) == 0 ||
+                  fieldName.compare(prefixLength, varName.length(), varName) == 0) {
+                fit.second.second.SetAttr(FLDATTR_rcunowned);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+void RCSetter::SetRCUnownedAttributeInternalSetFieldAttrRCUnowned(size_t opnd, const MIRFunction &calledFunc) const {
+  const MIRSymbol *arg = calledFunc.GetFormal(opnd);
+  for (const StmtNode *s = calledFunc.GetBody()->GetFirst(); s != nullptr; s = s->GetNext()) {
+    // 1. checking iassign statements that assign parameter arg
+    if (s->GetOpCode() != OP_iassign) {
+      continue;
+    }
+    const IassignNode *ian = static_cast<const IassignNode*>(s);
+    const BaseNode *val = ian->GetRHS();
+    if (val->GetOpCode() != OP_dread) {
+      continue;
+    }
+    const DreadNode *valDrn = static_cast<const DreadNode*>(val);
+    const MIRSymbol *valSymbol = calledFunc.GetLocalOrGlobalSymbol(valDrn->GetStIdx());
+    const GStrIdx &valStrIdx = valSymbol->GetNameStrIdx();
+    if (valStrIdx != arg->GetNameStrIdx()) {
+      continue;
+    }
+    // 2. get the class fields of the iassign statement
+    auto it = iputStmtFieldMap.find(s);
+    if (it != iputStmtFieldMap.end()) {
+      const GStrIdx &fieldStrIdx = it->second;
+      // 3. set rcunwoned attribute for that field
+      const MIRType *type = calledFunc.GetClassType();
+      CHECK_NULL_FATAL(type);
+      MIRType *typePtr = GlobalTables::GetTypeTable().GetTypeFromTyIdx(type->GetTypeIndex());
+      MIRStructType *structType = static_cast<MIRStructType*>(typePtr);
+      for (auto &fit : structType->GetFields()) {
+        if (fit.first == fieldStrIdx) {
+          fit.second.second.SetAttr(FLDATTR_rcunowned);
+          break;
+        }
+      }
+    }
+  }
+}
+
+void RCSetter::SetRCUnownedAttribute(const CallNode &callNode, MIRFunction &func,
+                                     const MIRFunction &calledFunc, const std::set<GStrIdx> &gStrIdx) const {
+  for (size_t i = 0; i < callNode.NumOpnds(); ++i) {
+    BaseNode *bn = callNode.GetNopndAt(i);
+    if (bn->GetOpCode() != OP_dread) {
+      continue;
+    }
+    DreadNode *drn = static_cast<DreadNode*>(bn);
+    const MIRSymbol *symbol = func.GetLocalOrGlobalSymbol(drn->GetStIdx());
+    const GStrIdx &strIdx = symbol->GetNameStrIdx();
+    // checking maple name in ALIAS
+    for (auto als : func.GetAliasVarMap()) {
+      if (als.second.mplStrIdx != strIdx) {
+        continue;
+      }
+      for (auto sit : gStrIdx) {
+        if (sit != als.first) {
+          continue;
+        }
+        // now we have a link and a field need to be set rcunowned
+        //
+        // the focus is the i_th parameter arg.
+        // we will go through body of <init> of the lambda class
+        // 1. checking iassign statements that assign parameter arg
+        // 2. get the class fields of the iassign statement
+        // 3. set rcunwoned attribute for that field
+        SetRCUnownedAttributeInternalSetFieldAttrRCUnowned(i, calledFunc);
+      }
+    }
+  }
+}
+
+void RCSetter::MarkRCUnownedForLambdaClasses() const {
+  // mark captured unowned fields for lambda classes.
+  for (auto mit : unownedLocalVars) {
+    MIRFunction *func = mit.first;
+    // scan function body to find lambda functions used
+    // and set rcunowned attribute on corresponding captured fields
+    // of local classes for lambda functions
+    for (const StmtNode *stmt = func->GetBody()->GetFirst(); stmt != nullptr; stmt = stmt->GetNext()) {
+      if (stmt->GetOpCode() != OP_callassigned) {
+        continue;
+      }
+      const CallNode *call = static_cast<const CallNode*>(stmt);
+      MIRFunction *calledFunc = GlobalTables::GetFunctionTable().GetFuncTable().at(call->GetPUIdx());
+      // only care calling <init> of local classes for lambda functions
+      if (!(calledFunc->GetAttr(FUNCATTR_constructor) && calledFunc->GetAttr(FUNCATTR_public) &&
+            calledFunc->GetAttr(FUNCATTR_synthetic))) {
+        continue;
+      }
+      // go through call arguments to find maple names with ALIAS info
+      // and their src names matching captured var names
+      SetRCUnownedAttribute(*call, *func, *calledFunc, mit.second);
+    }
+  }
+}
+
+void RCSetter::MarkRCAttributes() const {
+  MarkRCUnownedForUnownedLocalFunctions();
+  MarkRCUnownedForAnonymousClasses();
+  MarkRCUnownedForLambdaClasses();
+}
+
+void RCSetter::CollectUnownedLocalFuncs(MIRFunction *func) {
+  (void)unownedLocalFuncs.insert(func);
+}
+
+void RCSetter::CollectUnownedLocalVars(MIRFunction *func, const GStrIdx &strIdx) {
+  (void)unownedLocalVars[func].insert(strIdx);
+}
+
+void RCSetter::CollectInputStmtField(StmtNode *stmt, const GStrIdx &fieldName) {
+  (void)iputStmtFieldMap.emplace(stmt, fieldName);
+}
+
+void RCSetter::LoadRCFieldAttrWhiteList(const std::string &file) {
+  std::string line;
+  std::ifstream infile(file);
+  uint32 lineNum = 0;
+  std::vector<std::string> vecItem;
+  std::vector<FieldAttrKind> vecAttr;
+  std::string item;
+  std::string className;
+  std::string fieldName;
+  CHECK_FATAL(infile.is_open(), "(ToIDEUser)RCFieldAttrWhiteList file %s open failed", file.c_str());
+  while (std::getline(infile, line)) {
+    lineNum++;
+    if (line.at(0) == '#') {
+      continue;
+    }
+    std::stringstream ss;
+    ss.str(line);
+    vecItem.clear();
+    while (std::getline(ss, item, ':')) {
+      vecItem.push_back(item);
+    }
+    CHECK_FATAL(vecItem.size() > 2, "(ToIDEUser)invalid line %d in RCFieldAttrWhiteList file %s", lineNum,
+                file.c_str());
+    className = vecItem[0];
+    fieldName = vecItem[1];
+    vecAttr.clear();
+    for (size_t i = 2; i < vecItem.size(); i++) {
+      std::string &strAttr = vecItem[i];
+      if (strAttr.compare("RCWeak") == 0) {
+        vecAttr.push_back(FLDATTR_rcweak);
+      } else if (strAttr.compare("RCUnowned") == 0) {
+        vecAttr.push_back(FLDATTR_rcunowned);
+      }
+    }
+    rcFieldAttrWhiteListMap[className][fieldName] = vecAttr;
+  }
+  infile.close();
+}
+
+void RCSetter::SetRCFieldAttrByWhiteList(FieldAttrs &attr, const std::string &className,
+                                         const std::string &fieldName) {
+  auto itClass = rcFieldAttrWhiteListMap.find(className);
+  if (itClass != rcFieldAttrWhiteListMap.end()) {
+    auto itField = itClass->second.find(fieldName);
+    if (itField != itClass->second.end()) {
+      for (auto &attrIt : itField->second) {
+        attr.SetAttr(attrIt);
+      }
+    }
+  }
+}
+}  // namespace bc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/class_linker.h b/src/hir2mpl/bytecode_input/dex/include/class_linker.h
new file mode 100644
index 0000000000000000000000000000000000000000..e76a7d9eb3c49ab5691c24d61d3492b4a2f1164a
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/class_linker.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef HIR2MPL_BC_INPUT_CLASS_LINKER_H
+#define HIR2MPL_BC_INPUT_CLASS_LINKER_H
+#include "class_loader_context.h"
+
+namespace maple {
+class ClassLinker {
+ public:
+  explicit ClassLinker(std::vector<std::unique_ptr<bc::DexParser>> &classPath);
+  virtual ~ClassLinker() = default;
+
+  void FindClass(const std::string &className, ClassLoaderInfo *classLoader,
+                 std::list<std::unique_ptr<bc::BCClass>> &list, bool isDefClass = false);
+  void LoadSuperAndInterfaces(const std::unique_ptr<bc::BCClass> &klass, ClassLoaderInfo *classLoader,
+                              std::list<std::unique_ptr<bc::BCClass>> &klassList);
+ private:
+  std::unique_ptr<bc::BCClass> FindInSharedLib(const std::string &className, ClassLoaderInfo &classLoader);
+  std::unique_ptr<bc::BCClass> FindInBaseClassLoader(const std::string &className, ClassLoaderInfo *classLoader);
+  std::unique_ptr<bc::BCClass> FindInClassLoaderClassPath(const std::string &className,
+                                                          ClassLoaderInfo &classLoader) const;
+  std::vector<std::unique_ptr<bc::DexParser>> bootClassPath;
+  std::unordered_set<GStrIdx, GStrIdxHash> processedClassName;
+};
+}  // end namespace maple
+#endif  // HIR2MPL_BC_INPUT_CLASS_LINKER_H
diff --git a/src/hir2mpl/bytecode_input/dex/include/class_loader_context.h b/src/hir2mpl/bytecode_input/dex/include/class_loader_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b2e09f915038a1ca1efc7585036b7270019e21a
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/class_loader_context.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_CLASS_LOADER_CONTEXT_H
+#define HIR2MPL_BC_INPUT_CLASS_LOADER_CONTEXT_H
+#include "dex_parser.h"
+
+namespace maple {
+enum ClassLoaderType {
+  kInvalidClassLoader = 0,
+  kPathClassLoader = 1,
+  kDelegateLastClassLoader = 2,
+  kInMemoryDexClassLoader = 3
+};
+
+class ClassLoaderInfo {
+ public:
+  ClassLoaderType type;
+  ClassLoaderInfo *parent;
+  std::vector<std::string> classPaths;
+  std::vector<std::unique_ptr<bc::DexParser>> hexElements;
+  std::vector<uint32_t> checksums;
+  std::vector<ClassLoaderInfo*> sharedLibraries;
+};
+
+class ClassLoaderContext {
+ public:
+  ClassLoaderContext(MemPool &mpIn) : mp(mpIn) {}
+  virtual ~ClassLoaderContext() {
+    loaderChain = nullptr;
+  }
+
+  static ClassLoaderContext *Create(const std::string &spec, MemPool &mp);
+  ClassLoaderInfo *CreateClassLoader(const std::string &spec);
+  static bool OpenDexFiles(const std::string &spec, std::vector<std::unique_ptr<bc::DexParser>> &dexFileParsers);
+
+  bool IsSpecialSharedLib() const {
+    return isSpecialSharedLib;
+  }
+
+  const ClassLoaderInfo *GetClassLoader() const {
+    return loaderChain;
+  }
+
+ private:
+  ClassLoaderType GetCLType(const std::string &clString);
+  const char *GetCLTypeName(ClassLoaderType type) const;
+  size_t FindMatchingSharedLibraryCloseMarker(const std::string& spec, size_t sharedLibraryOpenIndex);
+  ClassLoaderInfo *ParseInternal(const std::string &spec);
+  ClassLoaderInfo *ParseClassLoaderSpec(const std::string &spec);
+  bool ParseSharedLibraries(std::string &sharedLibrariesSpec, ClassLoaderInfo &info);
+  bool Parse(const std::string &spec);
+  ClassLoaderInfo *loaderChain = nullptr;
+  bool isSpecialSharedLib = false;
+  MemPool &mp;
+  static const char kPathClassLoaderString[];
+  static const char kDelegateLastClassLoaderString[];
+  static const char kInMemoryDexClassLoaderString[];
+  static const char kClassLoaderOpeningMark;
+  static const char kClassLoaderClosingMark;
+  static const char kClassLoaderSharedLibraryOpeningMark;
+  static const char kClassLoaderSharedLibraryClosingMark;
+  static const char kClassLoaderSharedLibrarySeparator;
+  static const char kClassLoaderSeparator;
+  static const char kClasspathSeparator;
+  static const char kSpecialSharedLib[];
+};
+}  // end namespace maple
+#endif  // HIR2MPL_BC_INPUT_CLASS_LOADER_CONTEXT_H
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_class.h b/src/hir2mpl/bytecode_input/dex/include/dex_class.h
new file mode 100644
index 0000000000000000000000000000000000000000..98829312fa78fcc81e02109ee55c1ac1ffdc8736
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_class.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_BC_INPUT_DEX_CLASS_H
+#define MPL_FE_BC_INPUT_DEX_CLASS_H
+#include "bc_class.h"
+namespace maple {
+namespace bc {
+class DexClass : public BCClass {
+ public:
+  DexClass(uint32 idx, const BCParserBase &parser) : BCClass(idx, parser) {}
+  ~DexClass() = default;
+};
+
+class DexClassField : public BCClassField {
+ public:
+  DexClassField(const BCClass &klassIn, uint32 itemIdxIn, uint32 idxIn, uint32 acc, const std::string &nameIn,
+                const std::string &descIn)
+      : BCClassField(klassIn, acc, nameIn, descIn),
+        itemIdx(itemIdxIn),
+        idx(idxIn) {}
+  ~DexClassField() = default;
+
+ protected:
+  uint32 GetItemIdxImpl() const override;
+  uint32 GetIdxImpl() const override;
+  bool IsStaticImpl() const override;
+  uint32 itemIdx;
+  uint32 idx;
+};
+
+class DEXTryInfo : public BCTryInfo {
+ public:
+  DEXTryInfo(uint32 startAddrIn, uint32 endAddrIn, std::unique_ptr<std::list<std::unique_ptr<BCCatchInfo>>> catchesIn)
+      : BCTryInfo(startAddrIn, endAddrIn, std::move(catchesIn)) {}
+  ~DEXTryInfo() = default;
+};
+
+class DEXCatchInfo : public BCCatchInfo {
+ public:
+  DEXCatchInfo(uint32 pcIn, const GStrIdx &exceptionNameIdx, bool catchAll)
+      : BCCatchInfo(pcIn, exceptionNameIdx, catchAll) {}
+  ~DEXCatchInfo() = default;
+};
+
+class DexClassMethod : public BCClassMethod {
+ public:
+  DexClassMethod(const BCClass &klassIn, uint32 itemIdxIn, uint32 idxIn, bool isVirtualIn, uint32 acc,
+                 const std::string &nameIn, const std::string &descIn)
+      : BCClassMethod(klassIn, acc, isVirtualIn, nameIn, descIn),
+        itemIdx(itemIdxIn),
+        idx(idxIn) {}
+  ~DexClassMethod() = default;
+
+ protected:
+  uint32 GetItemIdxImpl() const override;
+  uint32 GetIdxImpl() const override;
+  bool IsStaticImpl() const override;
+  bool IsVirtualImpl() const override;
+  bool IsNativeImpl() const override;
+  bool IsInitImpl() const override;
+  bool IsClinitImpl() const override;
+  std::vector<std::unique_ptr<FEIRVar>> GenArgVarListImpl() const override;
+  void GenArgRegsImpl() override;
+  uint32 itemIdx;
+  uint32 idx;
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // MPL_FE_BC_INPUT_DEX_CLASS_H
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_class2fe_helper.h b/src/hir2mpl/bytecode_input/dex/include/dex_class2fe_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..1980671e617a0b466bd625dc741fddfd1e5bfa48
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_class2fe_helper.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_DEX_CLASS2FE_HELPER_H
+#define HIR2MPL_BC_INPUT_INCLUDE_DEX_CLASS2FE_HELPER_H
+#include "bc_class2fe_helper.h"
+namespace maple {
+namespace bc {
+class DexClass2FEHelper : public BCClass2FEHelper {
+ public:
+  DexClass2FEHelper(MapleAllocator &allocator, bc::BCClass &klassIn);
+  ~DexClass2FEHelper() = default;
+
+ protected:
+  void InitFieldHelpersImpl() override;
+  void InitMethodHelpersImpl() override;
+  TypeAttrs GetStructAttributeFromInputImpl() const override;
+};
+
+class DexClassField2FEHelper : public BCClassField2FEHelper {
+ public:
+  DexClassField2FEHelper(MapleAllocator &allocator, const BCClassField &fieldIn)
+      : BCClassField2FEHelper(allocator, fieldIn) {}
+  ~DexClassField2FEHelper() = default;
+
+ protected:
+  FieldAttrs AccessFlag2AttributeImpl(uint32 accessFlag) const override;
+};
+
+class DexClassMethod2FEHelper : public BCClassMethod2FEHelper {
+ public:
+  DexClassMethod2FEHelper(MapleAllocator &allocator, std::unique_ptr<BCClassMethod> &methodIn)
+      : BCClassMethod2FEHelper(allocator, methodIn) {}
+  ~DexClassMethod2FEHelper() = default;
+
+ protected:
+  FuncAttrs GetAttrsImpl() const override;
+  bool IsStaticImpl() const override;
+
+  bool IsClinit() const override;
+  bool IsInit() const override;
+};
+}
+}
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_DEX_CLASS2FE_HELPER_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_encode_value.h b/src/hir2mpl/bytecode_input/dex/include/dex_encode_value.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5a1b2b3bb1b0331c72f0655f3e2b14f1f5c62e3
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_encode_value.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef DEX_ENCODE_VALUE_H
+#define DEX_ENCODE_VALUE_H
+#include "dex_class.h"
+#include "dexfile_interface.h"
+
+namespace maple {
+namespace bc {
+enum DexEncodeValueType {
+  kValueByte = 0x00,          // (none; must be 0)  ubyte[1]
+  kValueShort = 0x02,         // size - 1 (0…1)  ubyte[size]
+  kValueChar = 0x03,          // size - 1 (0…1)  ubyte[size]
+  kValueInt = 0x04,           // size - 1 (0…3)  ubyte[size]
+  kValueLong = 0x06,          // size - 1 (0…7)  ubyte[size]
+  kValueFloat = 0x10,         // size - 1 (0…3)  ubyte[size]
+  kValueDouble = 0x11,        // size - 1 (0…7)  ubyte[size]
+  kValueMethodType = 0x15,    // size - 1 (0…3)  ubyte[size]
+  kValueMethodHandle = 0x16,  // size - 1 (0…3)  ubyte[size]
+  kValueString = 0x17,        // size - 1 (0…3)  ubyte[size]
+  kValueType = 0x18,          // size - 1 (0…3)  ubyte[size]
+  kValueField = 0x19,         // size - 1 (0…3)  ubyte[size]
+  kValueMethod = 0x1a,        // size - 1 (0…3)  ubyte[size]
+  kValueEnum = 0x1b,          // size - 1 (0…3)  ubyte[size]
+  kValueArray = 0x1c,         // (none; must be 0) encoded_array
+  kValueAnnotation = 0x1d,    // (none; must be 0) encoded_annotation
+  kValueNull = 0x1e,          // (none; must be 0) (none)
+  kValueBoolean = 0x1f        // boolean (0…1)   (none)
+};
+
+class DexEncodeValue {
+ public:
+  DexEncodeValue(MemPool &mpIn, maple::IDexFile &dexFileIn) : mp(mpIn), dexFile(dexFileIn) {}
+  ~DexEncodeValue() = default;
+  void ProcessEncodedValue(const uint8 **data, uint8 valueType, uint8 valueArg, MIRConst *&cst, uint32 &stringID);
+
+ private:
+  uint64 GetUVal(const uint8 **data, uint8 len) const;
+  MIRType *GetTypeFromValueType(uint8 valueType) const;
+  void ProcessEncodedValue(const uint8 **data, MIRConst *&cst);
+  MIRStr16Const *ProcessStringValue(const uint8 **data, uint8 valueArg, uint32 &stringID);
+  MIRIntConst *ProcessIntValue(const uint8 **data, uint8 valueArg, MIRType &type);
+  MIRAggConst *ProcessArrayValue(const uint8 **data);
+  void ProcessAnnotationValue(const uint8 **data);
+
+  MemPool &mp;
+  maple::IDexFile &dexFile;
+  union {
+    int32 i;
+    int64 j;
+    uint64 u;
+    float f;
+    double d;
+  } valBuf;
+};
+} // namespace bc
+} // namespace maple
+#endif // DEX_ENCODE_VALUE_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_file_item_type.def b/src/hir2mpl/bytecode_input/dex/include/dex_file_item_type.def
new file mode 100644
index 0000000000000000000000000000000000000000..fb8dc93c63e0f2885049c2c81ec70a3ddfc5673e
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_file_item_type.def
@@ -0,0 +1,22 @@
+// DEX_FILE_ITEM_TYPE(name)
+// DEX_FILE_ITEM_TYPE(HeaderItem)
+DEX_FILE_ITEM_TYPE(StringIdItem)
+DEX_FILE_ITEM_TYPE(TypeIdItem)
+DEX_FILE_ITEM_TYPE(ProtoIdItem)
+DEX_FILE_ITEM_TYPE(FieldIdItem)
+DEX_FILE_ITEM_TYPE(MethodIdItem)
+DEX_FILE_ITEM_TYPE(ClassDefItem)
+DEX_FILE_ITEM_TYPE(CallSiteIdItem)
+DEX_FILE_ITEM_TYPE(MethodHandleItem)
+// DEX_FILE_ITEM_TYPE(MapList)
+DEX_FILE_ITEM_TYPE(TypeList)
+DEX_FILE_ITEM_TYPE(AnnotationSetRefList)
+DEX_FILE_ITEM_TYPE(AnnotationSetItem)
+/*DEX_FILE_ITEM_TYPE(ClassDataItem)
+DEX_FILE_ITEM_TYPE(CodeItem)
+DEX_FILE_ITEM_TYPE(StringDataItem)
+DEX_FILE_ITEM_TYPE(DebugInfoItem)
+DEX_FILE_ITEM_TYPE(AnnotationItem)
+DEX_FILE_ITEM_TYPE(EncodedArrayItem)
+DEX_FILE_ITEM_TYPE(AnnotationsDirectoryItem)
+DEX_FILE_ITEM_TYPE(HiddenapiClassDataItem)*/
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_file_util.h b/src/hir2mpl/bytecode_input/dex/include/dex_file_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..d2741f6ed83ff20bf18e79bd5909ec0867618b5c
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_file_util.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_BC_INPUT_DEX_FILE_UTIL_H
+#define MPL_FE_BC_INPUT_DEX_FILE_UTIL_H
+#include "types_def.h"
+namespace maple {
+namespace bc {
+enum DexOpCode {
+#define OP(opcode, category, kind, wide, throwable) kDexOp##opcode,
+#include "dex_opcode.def"
+#undef OP
+};
+
+class DexFileUtil {
+ public:
+  // Access flags
+  static constexpr uint32 kDexAccPublic = 0x0001;  // class, method, field
+  static constexpr uint32 kDexAccPrivate = 0x0002;  // method, field
+  static constexpr uint32 kDexAccProtected = 0x0004;  // method, field
+  static constexpr uint32 kDexAccStatic = 0x0008;  // method, field
+  static constexpr uint32 kDexAccFinal = 0x0010;  // class, method, field
+  static constexpr uint32 kAccDexSynchronized = 0x0020;  // method (only allowed on natives)
+  static constexpr uint32 kDexAccSuper = 0x0020;  // class
+  static constexpr uint32 kDexAccBridge = 0x0040;  // method
+  static constexpr uint32 kDexAccVolatile = 0x0040;  // field
+  static constexpr uint32 kDexAccVarargs = 0x0080;  // method, method
+  static constexpr uint32 kDexAccTransient = 0x0080;  // field
+  static constexpr uint32 kDexAccNative = 0x0100;  // method
+  static constexpr uint32 kDexAccInterface = 0x0200;  // class
+  static constexpr uint32 kDexAccAbstract = 0x0400;  // class, method
+  static constexpr uint32 kDexAccStrict = 0x0800;  // method
+  static constexpr uint32 kDexAccSynthetic = 0x1000;  // class, method
+  static constexpr uint32 kDexAccAnnotation = 0x2000;  // class
+  static constexpr uint32 kDexAccEnum = 0x4000;
+  static constexpr uint32 kDexAccConstructor = 0x00010000;  // method
+  static constexpr uint32 kDexDeclaredSynchronized = 0x00020000;
+
+  enum ItemType {
+    kTypeHeaderItem = 0x0000,
+    kTypeStringIdItem,
+    kTypeTypeIdItem,
+    kTypeProtoIdItem,
+    kTypeFieldIdItem,
+    kTypeMethodIdItem,
+    kTypeClassDefItem,
+    kTypeCallSiteIdItem,
+    kTypeMethodHandleItem,
+    kTypeMapList = 0x1000,
+    kTypeTypeList,
+    kTypeAnnotationSetRefList,
+    kTypeAnnotationSetItem,
+    kTypeClassDataItem = 0x2000,
+    kTypeCodeItem,
+    kTypeStringDataItem,
+    kTypeDebugInfoItem,
+    kTypeAnnotationItem,
+    kTypeEncodedArrayItem,
+    kTypeAnnotationsDirectoryItem,
+    kTypeHiddenapiClassDataItem = 0xF000
+  };
+
+  static uint32 Adler32(const uint8 *data, uint32 size);
+  static constexpr uint8 kMagicSize = 8;
+  static const uint8 kDexFileMagic[kMagicSize];
+  static constexpr uint32 kCheckSumDataOffSet = 12;
+  static constexpr uint32 kFileSizeOffSet = 32;
+  static constexpr uint32 kHeaderSizeOffSet = 36;
+  static constexpr uint32 kEndianTagOffSet = 40;
+  static const uint8 kEndianConstant[4]; // 0x12345678;
+  static const uint8 kReverseEndianConstant[4];  // 0x78563412;
+  static constexpr uint32 kNoIndex = 0xffffffff;
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // MPL_FE_BC_INPUT_DEX_FILE_UTIL_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_op.h b/src/hir2mpl/bytecode_input/dex/include/dex_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a98e2425a1d43ee8822b4cc182f8b4a2f11ee50
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_op.h
@@ -0,0 +1,718 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_DEX_OP_H
+#define HIR2MPL_BC_INPUT_INCLUDE_DEX_OP_H
+#include <vector>
+#include <list>
+#include "bc_op_factory.h"
+#include "bc_instruction.h"
+#include "dex_file_util.h"
+#include "bc_parser_base.h"
+#include "fe_manager.h"
+namespace maple {
+namespace bc {
+class DexOp : public BCInstruction {
+ public:
+  DexOp(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOp() = default;
+  void SetVA(uint32 num);
+  void SetVB(uint32 num);
+  void SetWideVB(uint64 num);
+  void SetArgs(const MapleList<uint32> &args);
+  void SetVC(uint32 num);
+  void SetVH(uint32 num);
+  static std::string GetArrayElementTypeFromArrayType(const std::string &typeName);
+
+ protected:
+  void ParseImpl(BCClassMethod &method) override {
+    (void) method;
+  }
+  // Should be removed after all instruction impled
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override {
+    return std::list<UniqueFEIRStmt>();
+  }
+
+  virtual void SetVAImpl(uint32 num) {}
+  virtual void SetVBImpl(uint32 num) {}
+  virtual void SetWideVBImpl(uint64 num) {}
+  virtual void SetArgsImpl(const MapleList<uint32> &args) {};
+  virtual void SetVCImpl(uint32 num) {}
+  virtual void SetVHImpl(uint32 num) {}
+
+  StructElemNameIdx *structElemNameIdx = nullptr;
+};
+
+struct DexReg : public BCReg {
+  uint32 dexLitStrIdx = UINT32_MAX;  // string idx of dex
+  uint32 dexTypeIdx = UINT32_MAX; // type idx of dex
+};
+
+class DexOpNop : public DexOp {
+ public:
+  DexOpNop(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpNop() = default;
+};
+
+// 0x01: move vA, vB ~ 0x09: move-object/16 vAAAA, vBBBB
+class DexOpMove : public DexOp {
+ public:
+  DexOpMove(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpMove() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetRegTypeInTypeInferImpl() override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+};
+
+// 0x0a: move-result vAA ~ 0x0c: move-result-object vAA
+class DexOpMoveResult : public DexOp {
+ public:
+  DexOpMoveResult(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpMoveResult() = default;
+  void SetVATypeNameIdx(const GStrIdx &idx);
+  DexReg GetVA() const;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetBCRegTypeImpl(const BCInstruction &inst) override;
+  DexReg vA;
+};
+
+// 0x0c
+class DexOpMoveException : public DexOp {
+ public:
+  DexOpMoveException(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpMoveException() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetBCRegTypeImpl(const BCInstruction &inst) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+};
+
+// 0x0e ~ 0x11
+class DexOpReturn : public DexOp {
+ public:
+  DexOpReturn(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpReturn() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  bool isReturnVoid = false;
+};
+
+// 0x12 ~ 0x19
+class DexOpConst : public DexOp {
+ public:
+  DexOpConst(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpConst() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetWideVBImpl(uint64 num) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+
+ private:
+  DexReg vA;
+};
+
+// 0x1a ~ 0x1b
+class DexOpConstString : public DexOp {
+ public:
+  DexOpConstString(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpConstString() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  uint32 fileIdx = 0;
+  DexReg vA;
+  MapleString strValue;
+};
+
+// 0x1c
+class DexOpConstClass : public DexOp {
+ public:
+  DexOpConstClass(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpConstClass() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  uint32 dexTypeIdx = 0;
+  GStrIdx mplTypeNameIdx;
+};
+
+// 0x1d ~ 0x1e
+class DexOpMonitor : public DexOp {
+ public:
+  DexOpMonitor(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpMonitor() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+};
+
+// 0x1f
+class DexOpCheckCast : public DexOp {
+ public:
+  DexOpCheckCast(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpCheckCast() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vDef;
+  uint32 targetDexTypeIdx = 0;
+  GStrIdx targetTypeNameIdx;
+};
+
+// 0x20
+class DexOpInstanceOf : public DexOp {
+ public:
+  DexOpInstanceOf(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpInstanceOf() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+  uint32 targetDexTypeIdx = 0;
+  std::string typeName;
+};
+
+// 0x21
+class DexOpArrayLength : public DexOp {
+ public:
+  DexOpArrayLength(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpArrayLength() = default;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+};
+
+// 0x22
+class DexOpNewInstance : public DexOp {
+ public:
+  DexOpNewInstance(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpNewInstance() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  bool isSkipNewString = false;
+  // isRcPermanent is true means the rc annotation @Permanent is used
+  bool isRcPermanent = false;
+};
+
+// 0x23
+class DexOpNewArray : public DexOp {
+ public:
+  DexOpNewArray(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpNewArray() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+  // isRcPermanent is true means the rc annotation @Permanent is used
+  bool isRcPermanent = false;
+};
+
+// 0x24 ~ 0x25
+class DexOpFilledNewArray : public DexOp {
+ public:
+  DexOpFilledNewArray(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpFilledNewArray() = default;
+  GStrIdx GetReturnType() const;
+
+ protected:
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetArgsImpl(const MapleList<uint32> &args) override;
+  void ParseImpl(BCClassMethod &method) override;
+  bool isRange = false;
+  uint32 argsSize = 0;
+  uint32 dexArrayTypeIdx = UINT32_MAX;
+  GStrIdx arrayTypeNameIdx;
+  GStrIdx elemTypeNameIdx;
+  MapleList<uint32> argRegs;
+  MapleVector<DexReg> vRegs;
+};
+
+// 0x26
+class DexOpFillArrayData : public DexOp {
+ public:
+  DexOpFillArrayData(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpFillArrayData() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  const int8 *arrayData = nullptr;
+  int32 offset = INT32_MAX;
+  uint32 size = 0;
+};
+
+// 0x27
+class DexOpThrow : public DexOp {
+ public:
+  DexOpThrow(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpThrow() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+};
+
+// 0x28 ~ 0x2a
+class DexOpGoto : public DexOp {
+ public:
+  DexOpGoto(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpGoto() = default;
+
+ private:
+  std::vector<uint32> GetTargetsImpl() const override;
+  void SetVAImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  int32 offset = 0;
+  uint32 target = 0;
+};
+
+// 0x2b ~ 0x2c
+class DexOpSwitch : public DexOp {
+ public:
+  DexOpSwitch(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpSwitch() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::vector<uint32> GetTargetsImpl() const override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  bool isPacked = false;
+  int32 offset = 0;
+  DexReg vA;
+  MapleMap<int32, std::pair<uint32, uint32>> keyTargetOPpcMap;
+};
+
+// 0x2d ~ 0x31
+class DexOpCompare : public DexOp {
+ public:
+  DexOpCompare(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpCompare() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  Opcode GetOpcodeFromDexIns() const;
+  DexReg vA;
+  DexReg vB;
+  DexReg vC;
+};
+
+// 0x32 ~ 0x37
+class DexOpIfTest : public DexOp {
+ public:
+  DexOpIfTest(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpIfTest() = default;
+
+ protected:
+  std::vector<uint32> GetTargetsImpl() const override;
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+  int32 offset = 0;
+  uint32 target = 0;
+};
+
+// 0x38 ~ 0x3d
+class DexOpIfTestZ : public DexOp {
+ public:
+  DexOpIfTestZ(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpIfTestZ() = default;
+
+ private:
+  std::vector<uint32> GetTargetsImpl() const override;
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  int32 offset = 0;
+  uint32 target = 0;
+};
+
+// 0x3e ~ 0x43, 0x73, 0x79 ~ 0x7a, 0xe3 ~ 0x f9
+class DexOpUnused : public DexOp {
+ public:
+  DexOpUnused(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpUnused() = default;
+};
+
+// 0x44 ~ 0x4a
+class DexOpAget : public DexOp {
+ public:
+  DexOpAget(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpAget() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  void SetRegTypeInTypeInferImpl() override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+  DexReg vC;
+};
+
+// 0x4a ~ 0x51
+class DexOpAput : public DexOp {
+ public:
+  DexOpAput(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpAput() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  void SetRegTypeInTypeInferImpl() override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+  DexReg vC;
+};
+
+// 0x52 ~ 0x58
+class DexOpIget : public DexOp {
+ public:
+  DexOpIget(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpIget() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+  uint32 index = UINT32_MAX;
+};
+
+// 0x59 ~ 0x5f
+class DexOpIput : public DexOp {
+ public:
+  DexOpIput(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpIput() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+  uint32 index = UINT32_MAX;
+};
+
+// 0x60 ~ 0x66
+class DexOpSget : public DexOp {
+ public:
+  DexOpSget(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpSget() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  uint32 index = UINT32_MAX;
+  GStrIdx containerNameIdx;
+  DexReg vA;
+  int32 dexFileHashCode = -1;
+};
+
+// 0x67 ~ 0x6d
+class DexOpSput : public DexOp {
+ public:
+  DexOpSput(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpSput() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  uint32 index = UINT32_MAX;
+  int32 dexFileHashCode = -1;
+};
+
+class DexOpInvoke : public DexOp {
+ public:
+  DexOpInvoke(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpInvoke() = default;
+  std::string GetReturnType() const;
+
+ protected:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  void SetArgsImpl(const MapleList<uint32> &args) override;
+  void ParseImpl(BCClassMethod &method) override;
+  void PrepareInvokeParametersAndReturn(const FEStructMethodInfo &feMethodInfo, FEIRStmtCallAssign &stmt) const;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  bool IsStatic() const;
+  bool ReplaceStringFactory(BCReader::ClassElem &methodInfo, MapleList<uint32> &argRegNums);
+  bool isStringFactory = false;
+  uint32 argSize = 0;
+  uint32 arg0VRegNum = UINT32_MAX;
+  uint32 methodIdx = 0;
+  MapleList<uint32> argRegs;
+  MapleVector<DexReg> argVRegs;
+  std::vector<std::string> retArgsTypeNames;
+  DexReg retReg;
+};
+
+// 0x6e, 0x74
+class DexOpInvokeVirtual : public DexOpInvoke {
+ public:
+  DexOpInvokeVirtual(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpInvokeVirtual() = default;
+};
+
+// 0x6f, 0x75
+class DexOpInvokeSuper : public DexOpInvoke {
+ public:
+  DexOpInvokeSuper(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpInvokeSuper() = default;
+};
+
+// 0x70, 0x76
+class DexOpInvokeDirect : public DexOpInvoke {
+ public:
+  DexOpInvokeDirect(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpInvokeDirect() = default;
+};
+
+// 0x71, 0x77
+class DexOpInvokeStatic : public DexOpInvoke {
+ public:
+  DexOpInvokeStatic(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpInvokeStatic() = default;
+};
+
+// 0x72, 0x78
+class DexOpInvokeInterface : public DexOpInvoke {
+ public:
+  DexOpInvokeInterface(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpInvokeInterface() = default;
+};
+
+// 0x7b, 0x8f
+class DexOpUnaryOp : public DexOp {
+ public:
+  DexOpUnaryOp(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpUnaryOp() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  static std::map<uint8, std::tuple<Opcode, GStrIdx, GStrIdx>> InitOpcodeMapForUnary();
+  // map<dexOpcode, tuple<mirOpcode, typeNameA, typeNameB>>
+  static inline std::map<uint8, std::tuple<Opcode, GStrIdx, GStrIdx>> &GetOpcodeMapForUnary() {
+    static std::map<uint8, std::tuple<Opcode, GStrIdx, GStrIdx>> opcodeMapForUnary = InitOpcodeMapForUnary();
+    return opcodeMapForUnary;
+  }
+  DexReg vA;
+  DexReg vB;
+  Opcode mirOp = OP_undef;
+};
+
+// 0x90, 0xaf
+class DexOpBinaryOp : public DexOp {
+ public:
+  DexOpBinaryOp(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpBinaryOp() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  Opcode GetOpcodeFromDexIns() const;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vA;
+  DexReg vB;
+  DexReg vC;
+};
+
+// 0xb0, 0xcf
+class DexOpBinaryOp2Addr : public DexOp {
+ public:
+  DexOpBinaryOp2Addr(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpBinaryOp2Addr() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  Opcode GetOpcodeFromDexIns() const;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  DexReg vDef;
+  DexReg vA;
+  DexReg vB;
+};
+
+// 0xd0 ~ 0xe2
+class DexOpBinaryOpLit : public DexOp {
+ public:
+  DexOpBinaryOpLit(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpBinaryOpLit() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  void SetVCImpl(uint32 num) override;
+  Opcode GetOpcodeFromDexIns() const;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  bool isLit8;  // 8 bits / 16 bits signed int constant
+  union {
+    int8 i8;
+    int16 i16;
+  } constValue;
+  DexReg vA;
+  DexReg vB;
+};
+
+// 0xfa ~ 0xfb
+class DexOpInvokePolymorphic: public DexOpInvoke {
+ public:
+  DexOpInvokePolymorphic(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpInvokePolymorphic() = default;
+
+ protected:
+  void SetVHImpl(uint32 num) override;
+  void ParseImpl(BCClassMethod &method) override;
+  std::list<UniqueFEIRStmt> EmitToFEIRStmtsImpl() override;
+  bool isStatic = false;
+  uint32 protoIdx = 0;
+  std::string fullNameMpl;
+  std::string protoName;
+  uint32 callerClassID = UINT32_MAX;
+};
+
+// 0xfc ~ 0xfd
+class DexOpInvokeCustom : public DexOp {
+ public:
+  DexOpInvokeCustom(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpInvokeCustom() = default;
+
+ private:
+  void SetVBImpl(uint32 num) override;
+  void SetArgsImpl(const MapleList<uint32> &args) override;
+  MapleList<uint32> argRegs;
+  MapleVector<DexReg> argVRegs;
+  uint32 callSiteIdx = 0;
+};
+
+// 0xfe
+class DexOpConstMethodHandle : public DexOp {
+ public:
+  DexOpConstMethodHandle(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpConstMethodHandle() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  DexReg vA;
+  uint32 mhIdx = 0;
+};
+
+// 0xff
+class DexOpConstMethodType : public DexOp {
+ public:
+  DexOpConstMethodType(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn);
+  ~DexOpConstMethodType() = default;
+
+ private:
+  void SetVAImpl(uint32 num) override;
+  void SetVBImpl(uint32 num) override;
+  DexReg vA;
+  uint32 protoIdx = 0;
+};
+
+constexpr BCOpFactory::funcPtr dexOpGeneratorMap[] = {
+#define OP(opcode, category, kind, wide, throwable) \
+  BCOpFactory::BCOpGenerator<DexOp##category, DexOpCode, kDexOp##opcode, k##kind, wide, throwable>,
+#include "dex_opcode.def"
+#undef OP
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // HIR2MPL_BC_INPUT_INCLUDE_DEX_OP_H
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_opcode.def b/src/hir2mpl/bytecode_input/dex/include/dex_opcode.def
new file mode 100644
index 0000000000000000000000000000000000000000..9ab9e739fb953b0139767393855a055663fb05d6
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_opcode.def
@@ -0,0 +1,257 @@
+// OP(name, category, kind, isWide, throwable)
+OP(Nop, Nop, FallThru, false, false)
+OP(Move, Move, FallThru, false, false)
+OP(MoveFrom16, Move, FallThru, false, false)
+OP(Move16, Move, FallThru, false, false)
+OP(MoveWide, Move, FallThru, true, false)
+OP(MoveWideFrom16, Move, FallThru, true, false)
+OP(MoveWide16, Move, FallThru, true, false)
+OP(MoveObject, Move, FallThru, false, false)
+OP(MoveObjectFrom16, Move, FallThru, false, false)
+OP(MoveObject16, Move, FallThru, false, false)
+OP(MoveResult, MoveResult, FallThru, false, false)
+OP(MoveResultWide, MoveResult, FallThru, true, false)
+OP(MoveResultObject, MoveResult, FallThru, false, false)
+OP(MoveException, MoveException, Catch | kFallThru, false, false)
+OP(ReturnVoid, Return, UnKnownKind, false, false)
+OP(Return, Return, UnKnownKind, false, false)
+OP(ReturnWide, Return, UnKnownKind, true, false)
+OP(ReturnObject, Return, UnKnownKind, false, false)
+OP(Const4, Const, FallThru, false, false)
+OP(Const16, Const, FallThru, false, false)
+OP(Const, Const, FallThru, false, false)
+OP(ConstHigh16, Const, FallThru, false, false)
+OP(ConstWide16, Const, FallThru, true, false)
+OP(ConstWide32, Const, FallThru, true, false)
+OP(ConstWide, Const, FallThru, true, false)
+OP(ConstWideHigh16, Const, FallThru, true, false)
+OP(ConstString, ConstString, FallThru, false, true)
+OP(ConstStringJumbo, ConstString, FallThru, false, true)
+OP(ConstClass, ConstClass, FallThru, false, true)
+OP(MonitorEnter, Monitor, FallThru, false, true)
+OP(MonitorExit, Monitor, FallThru, false, true)
+OP(CheckCast, CheckCast, FallThru, false, true)
+OP(InstanceOf, InstanceOf, FallThru, false, true)
+OP(ArrayLength, ArrayLength, FallThru, false, true)
+OP(NewInstance, NewInstance, FallThru, false, true)
+OP(NewArray, NewArray, FallThru, false, true)
+OP(FilledNewArray, FilledNewArray, FallThru, false, true)
+OP(FilledNewArrayRange, FilledNewArray, FallThru, false, true)
+OP(FillArrayData, FillArrayData, FallThru, false, true)
+OP(Throw, Throw, UnKnownKind, false, true)
+OP(Goto, Goto, Goto, false, false)
+OP(Goto16, Goto, Goto, false, false)
+OP(Goto32, Goto, Goto, false, false)
+OP(PackedSwitch, Switch, Switch | kFallThru, false, false)
+OP(SparseSwitch, Switch, Switch | kFallThru, false, false)
+OP(CmplFloat, Compare, FallThru, false, false)
+OP(CmpgFloat, Compare, FallThru, false, false)
+OP(CmplDouble, Compare, FallThru, true, false)
+OP(CmpgDouble, Compare, FallThru, true, false)
+OP(CmpLong, Compare, FallThru, true, false)
+OP(IfEq, IfTest, ConditionBranch | kFallThru, false, false)
+OP(IfNe, IfTest, ConditionBranch | kFallThru, false, false)
+OP(IfLt, IfTest, ConditionBranch | kFallThru, false, false)
+OP(IfGe, IfTest, ConditionBranch | kFallThru, false, false)
+OP(IfGt, IfTest, ConditionBranch | kFallThru, false, false)
+OP(IfLe, IfTest, ConditionBranch | kFallThru, false, false)
+OP(IfEqZ, IfTestZ, ConditionBranch | kFallThru, false, false)
+OP(IfNeZ, IfTestZ, ConditionBranch | kFallThru, false, false)
+OP(IfLtZ, IfTestZ, ConditionBranch | kFallThru, false, false)
+OP(IfGeZ, IfTestZ, ConditionBranch | kFallThru, false, false)
+OP(IfGtZ, IfTestZ, ConditionBranch | kFallThru, false, false)
+OP(IfLeZ, IfTestZ, ConditionBranch | kFallThru, false, false)
+OP(Unused3E, Unused, UnKnownKind, false, false)
+OP(Unused3F, Unused, UnKnownKind, false, false)
+OP(Unused40, Unused, UnKnownKind, false, false)
+OP(Unused41, Unused, UnKnownKind, false, false)
+OP(Unused42, Unused, UnKnownKind, false, false)
+OP(Unused43, Unused, UnKnownKind, false, false)
+OP(Aget, Aget, FallThru, false, true)
+OP(AgetWide, Aget, FallThru, true, true)
+OP(AgetObject, Aget, FallThru, false, true)
+OP(AgetBoolean, Aget, FallThru, false, true)
+OP(AgetByte, Aget, FallThru, false, true)
+OP(AgetChar, Aget, FallThru, false, true)
+OP(AgetShort, Aget, FallThru, false, true)
+OP(Aput, Aput, FallThru, false, true)
+OP(AputWide, Aput, FallThru, true, true)
+OP(AputObject, Aput, FallThru, false, true)
+OP(AputBoolean, Aput, FallThru, false, true)
+OP(AputByte, Aput, FallThru, false, true)
+OP(AputChar, Aput, FallThru, false, true)
+OP(AputShort, Aput, FallThru, false, true)
+OP(Iget, Iget, FallThru, false, true)
+OP(IgetWide, Iget, FallThru, true, true)
+OP(IgetObject, Iget, FallThru, false, true)
+OP(IgetBoolean, Iget, FallThru, false, true)
+OP(IgetByte, Iget, FallThru, false, true)
+OP(IgetChar, Iget, FallThru, false, true)
+OP(IgetShort, Iget, FallThru, false, true)
+OP(Iput, Iput, FallThru, false, true)
+OP(IputWide, Iput, FallThru, true, true)
+OP(IputObject, Iput, FallThru, false, true)
+OP(IputBoolean, Iput, FallThru, false, true)
+OP(IputByte, Iput, FallThru, false, true)
+OP(IputChar, Iput, FallThru, false, true)
+OP(IputShort, Iput, FallThru, false, true)
+OP(Sget, Sget, FallThru, false, true)
+OP(SgetWide, Sget, FallThru, true, true)
+OP(SgetObject, Sget, FallThru, false, true)
+OP(SgetBoolean, Sget, FallThru, false, true)
+OP(SgetByte, Sget, FallThru, false, true)
+OP(SgetChar, Sget, FallThru, false, true)
+OP(SgetShort, Sget, FallThru, false, true)
+OP(Sput, Sput, FallThru, false, true)
+OP(SputWide, Sput, FallThru, true, true)
+OP(SputObject, Sput, FallThru, false, true)
+OP(SputBoolean, Sput, FallThru, false, true)
+OP(SputByte, Sput, FallThru, false, true)
+OP(SputChar, Sput, FallThru, false, true)
+OP(SputShort, Sput, FallThru, false, true)
+OP(InvokeVirtual, InvokeVirtual, FallThru, false, true)
+OP(InvokeSuper, InvokeSuper, FallThru, false, true)
+OP(InvokeDirect, InvokeDirect, FallThru, false, true)
+OP(InvokeStatic, InvokeStatic, FallThru, false, true)
+OP(InvokeInterface, InvokeInterface, FallThru, false, true)
+OP(Unused73, Unused, UnKnownKind, false, false)
+OP(InvokeVirtualRange, InvokeVirtual, FallThru, false, true)
+OP(InvokeSuperRange, InvokeSuper, FallThru, false, true)
+OP(InvokeDirectRange, InvokeDirect, FallThru, false, true)
+OP(InvokeStaticRange, InvokeStatic, FallThru, false, true)
+OP(InvokeInterfaceRange, InvokeInterface, FallThru, false, true)
+OP(Unused79, Unused, UnKnownKind, false, false)
+OP(Unused7a, Unused, UnKnownKind, false, false)
+OP(NegInt, UnaryOp, FallThru, false, false)
+OP(NotInt, UnaryOp, FallThru, false, false)
+OP(NegLong, UnaryOp, FallThru, true, false)
+OP(NotLong, UnaryOp, FallThru, true, false)
+OP(NegFloat, UnaryOp, FallThru, false, false)
+OP(NegDouble, UnaryOp, FallThru, true, false)
+OP(IntToLong, UnaryOp, FallThru, true, false)
+OP(IntToFloat, UnaryOp, FallThru, false, false)
+OP(IntToDouble, UnaryOp, FallThru, true, false)
+OP(LongToInt, UnaryOp, FallThru, true, false)
+OP(LongToFloat, UnaryOp, FallThru, true, false)
+OP(LongToDouble, UnaryOp, FallThru, true, false)
+OP(FloatToInt, UnaryOp, FallThru, false, false)
+OP(FloatToLong, UnaryOp, FallThru, true, false)
+OP(FloatToDouble, UnaryOp, FallThru, true, false)
+OP(DoubleToInt, UnaryOp, FallThru, true, false)
+OP(DoubleToLong, UnaryOp, FallThru, true, false)
+OP(DoubleToFloat, UnaryOp, FallThru, true, false)
+OP(IntToByte, UnaryOp, FallThru, false, false)
+OP(IntToChar, UnaryOp, FallThru, false, false)
+OP(IntToShort, UnaryOp, FallThru, false, false)
+OP(AddInt, BinaryOp, FallThru, false, false)
+OP(SubInt, BinaryOp, FallThru, false, false)
+OP(MulInt, BinaryOp, FallThru, false, false)
+OP(DivInt, BinaryOp, FallThru, false, true)
+OP(RemInt, BinaryOp, FallThru, false, true)
+OP(AndInt, BinaryOp, FallThru, false, false)
+OP(OrInt, BinaryOp, FallThru, false, false)
+OP(XorInt, BinaryOp, FallThru, false, false)
+OP(ShlInt, BinaryOp, FallThru, false, false)
+OP(ShrInt, BinaryOp, FallThru, false, false)
+OP(UshrInt, BinaryOp, FallThru, false, false)
+OP(AddLong, BinaryOp, FallThru, true, false)
+OP(SubLong, BinaryOp, FallThru, true, false)
+OP(MulLong, BinaryOp, FallThru, true, false)
+OP(DivLong, BinaryOp, FallThru, true, true)
+OP(RemLong, BinaryOp, FallThru, true, true)
+OP(AndLong, BinaryOp, FallThru, true, false)
+OP(OrLong, BinaryOp, FallThru, true, false)
+OP(XorLong, BinaryOp, FallThru, true, false)
+OP(ShlLong, BinaryOp, FallThru, true, false)
+OP(ShrLong, BinaryOp, FallThru, true, false)
+OP(UshrLong, BinaryOp, FallThru, true, false)
+OP(AddFloat, BinaryOp, FallThru, false, false)
+OP(SubFloat, BinaryOp, FallThru, false, false)
+OP(MulFloat, BinaryOp, FallThru, false, false)
+OP(DivFloat, BinaryOp, FallThru, false, false)
+OP(RemFloat, BinaryOp, FallThru, false, false)
+OP(AddDouble, BinaryOp, FallThru, true, false)
+OP(SubDouble, BinaryOp, FallThru, true, false)
+OP(MulDouble, BinaryOp, FallThru, true, false)
+OP(DivDouble, BinaryOp, FallThru, true, false)
+OP(RemDouble, BinaryOp, FallThru, true, false)
+OP(AddInt2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(SubInt2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(MulInt2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(DivInt2Addr, BinaryOp2Addr, FallThru, false, true)
+OP(RemInt2Addr, BinaryOp2Addr, FallThru, false, true)
+OP(AndInt2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(OrInt2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(XorInt2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(ShlInt2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(ShrInt2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(UshrInt2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(AddLong2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(SubLong2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(MulLong2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(DivLong2Addr, BinaryOp2Addr, FallThru, true, true)
+OP(RemLong2Addr, BinaryOp2Addr, FallThru, true, true)
+OP(AndLong2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(OrLong2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(XorLong2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(ShlLong2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(ShrLong2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(UshrLong2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(AddFloat2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(SubFloat2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(MulFloat2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(DivFloat2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(RemFloat2Addr, BinaryOp2Addr, FallThru, false, false)
+OP(AddDouble2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(SubDouble2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(MulDouble2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(DivDouble2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(RemDouble2Addr, BinaryOp2Addr, FallThru, true, false)
+OP(AddIntLit16, BinaryOpLit, FallThru, false, false)
+OP(RsubInt, BinaryOpLit, FallThru, false, false)
+OP(MulIntLit16, BinaryOpLit, FallThru, false, false)
+OP(DivIntLit16, BinaryOpLit, FallThru, false, true)
+OP(RemIntLit16, BinaryOpLit, FallThru, false, true)
+OP(AndIntLit16, BinaryOpLit, FallThru, false, false)
+OP(OrIntLit16, BinaryOpLit, FallThru, false, false)
+OP(XorIntLit16, BinaryOpLit, FallThru, false, false)
+OP(AddIntLit8, BinaryOpLit, FallThru, false, false)
+OP(RsubIntLit8, BinaryOpLit, FallThru, false, false)
+OP(MulIntLit8, BinaryOpLit, FallThru, false, false)
+OP(DivIntLit8, BinaryOpLit, FallThru, false, true)
+OP(RemIntLit8, BinaryOpLit, FallThru, false, true)
+OP(AndIntLit8, BinaryOpLit, FallThru, false, false)
+OP(OrIntLit8, BinaryOpLit, FallThru, false, false)
+OP(XorIntLit8, BinaryOpLit, FallThru, false, false)
+OP(ShlIntLit8, BinaryOpLit, FallThru, false, false)
+OP(ShrIntLit8, BinaryOpLit, FallThru, false, false)
+OP(UshrIntLit8, BinaryOpLit, FallThru, false, false)
+OP(UnusedE3, Unused, UnKnownKind, false, false)
+OP(UnusedE4, Unused, UnKnownKind, false, false)
+OP(UnusedE5, Unused, UnKnownKind, false, false)
+OP(UnusedE6, Unused, UnKnownKind, false, false)
+OP(UnusedE7, Unused, UnKnownKind, false, false)
+OP(UnusedE8, Unused, UnKnownKind, false, false)
+OP(UnusedE9, Unused, UnKnownKind, false, false)
+OP(UnusedEA, Unused, UnKnownKind, false, false)
+OP(UnusedEB, Unused, UnKnownKind, false, false)
+OP(UnusedEC, Unused, UnKnownKind, false, false)
+OP(UnusedED, Unused, UnKnownKind, false, false)
+OP(UnusedEE, Unused, UnKnownKind, false, false)
+OP(UnusedEF, Unused, UnKnownKind, false, false)
+OP(UnusedF0, Unused, UnKnownKind, false, false)
+OP(UnusedF1, Unused, UnKnownKind, false, false)
+OP(UnusedF2, Unused, UnKnownKind, false, false)
+OP(UnusedF3, Unused, UnKnownKind, false, false)
+OP(UnusedF4, Unused, UnKnownKind, false, false)
+OP(UnusedF5, Unused, UnKnownKind, false, false)
+OP(UnusedF6, Unused, UnKnownKind, false, false)
+OP(UnusedF7, Unused, UnKnownKind, false, false)
+OP(UnusedF8, Unused, UnKnownKind, false, false)
+OP(UnusedF9, Unused, UnKnownKind, false, false)
+OP(InvokePolymorphic, InvokePolymorphic, FallThru, false, true)
+OP(InvokePolymorphicRange, InvokePolymorphic, FallThru, false, true)
+OP(InvokeCustom, InvokeCustom, FallThru, false, true)
+OP(InvokeCustomRange, InvokeCustom, FallThru, false, true)
+OP(ConstMethodHandle, ConstMethodHandle, FallThru, false, true)
+OP(ConstMethodType, ConstMethodType, FallThru, false, true)
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_parser.h b/src/hir2mpl/bytecode_input/dex/include/dex_parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..180c69f23e988a9be63a8c2d4fb2da860228d782
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_parser.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_DEX_INPUT_DEX_PARSER_H
+#define MPL_FE_DEX_INPUT_DEX_PARSER_H
+#include "bc_parser.h"
+#include "dex_reader.h"
+#include "dex_class.h"
+#include "types_def.h"
+
+namespace maple {
+namespace bc {
+class DexParser : public BCParser<DexReader> {
+ public:
+  DexParser(uint32 fileIdxIn, const std::string &fileNameIn, const std::list<std::string> &classNamesIn);
+  ~DexParser() = default;
+  void ProcessDexClassMethod(const std::unique_ptr<DexClass> &dexClass, bool isVirtual,
+                             uint32 index, std::pair<uint32, uint32> &idxPair);
+  void SetDexFile(std::unique_ptr<IDexFile> iDexFileIn);
+  std::unique_ptr<BCClass> FindClassDef(const std::string &className);
+
+ protected:
+  const BCReader *GetReaderImpl() const override;
+  uint32 CalculateCheckSumImpl(const uint8 *data, uint32 size) override;
+  bool ParseHeaderImpl() override;
+  bool VerifyImpl() override;
+  bool RetrieveIndexTables() override;
+  bool RetrieveUserSpecifiedClasses(std::list<std::unique_ptr<BCClass>> &klasses) override;
+  bool RetrieveAllClasses(std::list<std::unique_ptr<BCClass>> &klasses) override;
+  bool CollectAllDepTypeNamesImpl(std::unordered_set<std::string> &depSet) override;
+  bool CollectMethodDepTypeNamesImpl(std::unordered_set<std::string> &depSet, BCClassMethod &bcMethod) const override;
+  bool CollectAllClassNamesImpl(std::unordered_set<std::string> &classSet) override;
+  void ProcessMethodBodyImpl(BCClassMethod &method,
+      uint32 classIdx, uint32 methodItemIdx, bool isVirtual) const override;
+
+ private:
+  std::unique_ptr<DexClass> ProcessDexClass(uint32 classIdx);
+  void ProcessDexClassDef(const std::unique_ptr<DexClass> &dexClass);
+  void ProcessDexClassInterfaceParent(const std::unique_ptr<DexClass> &dexClass);
+  void ProcessDexClassFields(const std::unique_ptr<DexClass> &dexClass);
+  void ProcessDexClassMethods(const std::unique_ptr<DexClass> &dexClass, bool isVirtual);
+  void ProcessDexClassMethodDecls(const std::unique_ptr<DexClass> &dexClass, bool isVirtual);
+  void ProcessDexClassAnnotationDirectory(const std::unique_ptr<DexClass> &dexClass);
+  void ProcessDexClassStaticFieldInitValue(const std::unique_ptr<DexClass> &dexClass);
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // MPL_FE_DEX_INPUT_DEX_PARSER_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_pragma.h b/src/hir2mpl/bytecode_input/dex/include/dex_pragma.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6d0b00accb6aa96a10c7e41d4e5f597aff557f3
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_pragma.h
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_BC_INPUT_INCLUDE_DEX_PRAGMA_H
+#define HIR2MPL_BC_INPUT_INCLUDE_DEX_PRAGMA_H
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include "bc_pragma.h"
+#include "mir_module.h"
+#include "mir_const.h"
+#include "mempool.h"
+#include "dexfile_interface.h"
+
+namespace maple {
+namespace bc {
+class DexBCAnnotationElement {
+ public:
+  DexBCAnnotationElement(MIRModule &moduleArg, MemPool &mpArg, IDexFile &iDexFileArg, const uint8_t **annotationDataArg)
+      : module(moduleArg),
+        mp(mpArg),
+        iDexFile(iDexFileArg),
+        annotationData(annotationDataArg) {}
+  ~DexBCAnnotationElement() {
+    annotationData = nullptr;
+  }
+
+  static uint64 GetUVal(const uint8 **data, uint8 len) {
+    // get value, max 8 bytes, little-endian
+    uint64 val = 0;
+    for (uint8 j = 0; j <= len; j++) {
+      val |= (static_cast<uint64>(*(*data)++) << (j << 3));
+    }
+    return val;
+  }
+
+  MIRPragmaElement *EmitPragmaElement() {
+    return ProcessAnnotationElement(annotationData);
+  }
+
+ private:
+  MIRPragmaElement *ProcessAnnotationElement(const uint8 **data);
+  void ProcessAnnotationEncodedValue(const uint8 **data, MIRPragmaElement &element, MIRConst *&cst);
+  void ProcessAnnotationEncodedValue(const uint8 **data, MIRPragmaElement &element, PragmaValueType valueType,
+                                     uint8 valueArg, MIRConst *&cst);
+  MIRIntConst *ProcessAnnotationEncodedValueInternalProcessIntValue(const uint8 **data, MIRPragmaElement &element,
+                                                                    uint8 valueArg, MIRType &type);
+  MIRStr16Const *ProcessAnnotationEncodedValueInternalProcessStringValue(const uint8 **data, MIRPragmaElement &element,
+                                                                         uint8 valueArg);
+  void ProcessAnnotationEncodedValueInternalProcessTypeValue(const uint8 **data, MIRPragmaElement &element,
+                                                             uint8 valueArg);
+  void ProcessAnnotationEncodedValueInternalProcessFieldValue(const uint8 **data, MIRPragmaElement &element,
+                                                              uint8 valueArg);
+  void ProcessAnnotationEncodedValueInternalProcessMethodValue(const uint8 **data, MIRPragmaElement &element,
+                                                               uint8 valueArg);
+  MIRAggConst *ProcessAnnotationEncodedValueInternalProcessArrayValue(const uint8 **data, MIRPragmaElement &element);
+  void ProcessAnnotationEncodedValueInternalProcessAnnotationValue(const uint8 **data, MIRPragmaElement &element);
+  static MIRType *GetTypeFromValueType(PragmaValueType valueType);
+
+  MIRModule &module;
+  MemPool &mp;
+  IDexFile &iDexFile;
+  const uint8_t **annotationData;
+};
+
+class DexBCAnnotation {
+ public:
+  DexBCAnnotation(MIRModule &moduleArg, MemPool &mpArg, IDexFile &iDexFileArg, const IDexAnnotation *iDexAnnotationArg)
+      : module(moduleArg),
+        mp(mpArg),
+        iDexFile(iDexFileArg),
+        iDexAnnotation(iDexAnnotationArg) {}
+  ~DexBCAnnotation() {
+    iDexAnnotation = nullptr;
+  }
+
+  MIRPragma *EmitPragma(PragmaKind kind, const GStrIdx &pragIdx, int32 paramNum = -1, const TyIdx &tyIdxEx = TyIdx(0));
+
+ private:
+  MIRModule &module;
+  MemPool &mp;
+  IDexFile &iDexFile;
+  const IDexAnnotation *iDexAnnotation;
+};
+
+class DexBCAnnotationSet {
+ public:
+  DexBCAnnotationSet(MIRModule &moduleArg, MemPool &mpArg, IDexFile &iDexFileArg,
+                     const IDexAnnotationSet *iDexAnnotationSetArg)
+      : module(moduleArg),
+        mp(mpArg),
+        iDexFile(iDexFileArg),
+        iDexAnnotationSet(iDexAnnotationSetArg) {
+    Init();
+  }
+
+  ~DexBCAnnotationSet() {
+    iDexAnnotationSet = nullptr;
+    annotations.clear();
+  }
+
+  size_t GetSize() const {
+    return annotations.size();
+  }
+
+  const DexBCAnnotation &GetAnnotation(size_t idx) const {
+    return *(annotations[idx]);
+  }
+
+  void AddAnnotation(std::unique_ptr<DexBCAnnotation> annotation) {
+    annotations.push_back(std::move(annotation));
+  }
+
+  bool IsValid() const {
+    return iDexAnnotationSet->IsValid();
+  }
+
+  std::vector<MIRPragma*> &EmitPragmas(PragmaKind kind, const GStrIdx &pragIdx, int32 paramNum = -1,
+                                       const TyIdx &tyIdxEx = TyIdx(0));
+
+ private:
+  void Init();
+  MIRModule &module;
+  MemPool &mp;
+  IDexFile &iDexFile;
+  const IDexAnnotationSet *iDexAnnotationSet;
+  std::vector<std::unique_ptr<DexBCAnnotation>> annotations;
+  std::vector<MIRPragma*> pragmas;
+};
+
+class DexBCAnnotationSetList {
+ public:
+  DexBCAnnotationSetList(MIRModule &moduleArg, MemPool &mpArg, IDexFile &iDexFileArg,
+                         const IDexAnnotationSetList *iDexAnnotationSetListArg)
+      : module(moduleArg),
+        mp(mpArg),
+        iDexFile(iDexFileArg),
+        iDexAnnotationSetList(iDexAnnotationSetListArg) {
+    Init();
+  }
+
+  ~DexBCAnnotationSetList() {
+    iDexAnnotationSetList = nullptr;
+    annotationSets.clear();
+  }
+
+  std::vector<MIRPragma*> &EmitPragmas(PragmaKind kind, const GStrIdx &pragIdx);
+
+ private:
+  void Init();
+  MIRModule &module;
+  MemPool &mp;
+  IDexFile &iDexFile;
+  const IDexAnnotationSetList *iDexAnnotationSetList;
+  std::vector<std::unique_ptr<DexBCAnnotationSet>> annotationSets;
+  std::vector<MIRPragma*> pragmas;
+};
+
+class DexBCFieldAnnotations {
+ public:
+  DexBCFieldAnnotations(MIRModule &moduleArg, MemPool &mpArg, IDexFile &iDexFileArg,
+                        const IDexFieldAnnotations *iDexFieldAnnotationsArg)
+      : module(moduleArg),
+        mp(mpArg),
+        iDexFile(iDexFileArg),
+        iDexFieldAnnotations(iDexFieldAnnotationsArg) {
+    Init();
+  }
+
+  ~DexBCFieldAnnotations() {
+    iDexFieldAnnotations = nullptr;
+  }
+  std::vector<MIRPragma*> &EmitPragmas();
+
+ private:
+  void Init();
+  MIRModule &module;
+  MemPool &mp;
+  IDexFile &iDexFile;
+  const IDexFieldAnnotations *iDexFieldAnnotations;
+  std::unique_ptr<DexBCAnnotationSet> annotationSet;
+};
+
+class DexBCMethodAnnotations {
+ public:
+  DexBCMethodAnnotations(MIRModule &moduleArg, MemPool &mpArg, IDexFile &iDexFileArg,
+                         const IDexMethodAnnotations *iDexMethodAnnotationsArg)
+      : module(moduleArg),
+        mp(mpArg),
+        iDexFile(iDexFileArg),
+        iDexMethodAnnotations(iDexMethodAnnotationsArg) {
+    Init();
+  }
+
+  ~DexBCMethodAnnotations() {
+    iDexMethodAnnotations = nullptr;
+  }
+
+  std::vector<MIRPragma*> &EmitPragmas();
+
+ private:
+  void Init();
+  void SetupFuncAttrs();
+  void SetupFuncAttrWithPragma(MIRFunction &mirFunc, const MIRPragma &pragma);
+  MIRFunction *GetMIRFunction(const GStrIdx &nameIdx) const;
+  MIRModule &module;
+  MemPool &mp;
+  IDexFile &iDexFile;
+  const IDexMethodAnnotations *iDexMethodAnnotations = nullptr;
+  std::unique_ptr<DexBCAnnotationSet> annotationSet;
+  std::vector<MIRPragma*> *pragmasPtr = nullptr;
+  GStrIdx methodFullNameStrIdx;
+  const IDexMethodIdItem *methodID = nullptr;
+};
+
+class DexBCParameterAnnotations {
+ public:
+  DexBCParameterAnnotations(MIRModule &moduleArg, MemPool &mpArg, IDexFile &iDexFileArg,
+                            const IDexParameterAnnotations *iDexParameterAnnotationsArg)
+      : module(moduleArg),
+        mp(mpArg),
+        iDexFile(iDexFileArg),
+        iDexParameterAnnotations(iDexParameterAnnotationsArg) {
+    Init();
+  }
+
+  virtual ~DexBCParameterAnnotations() = default;
+  std::vector<MIRPragma*> &EmitPragmas();
+
+ private:
+  void Init();
+  MIRModule &module;
+  MemPool &mp;
+  IDexFile &iDexFile;
+  const IDexParameterAnnotations *iDexParameterAnnotations;
+  std::unique_ptr<DexBCAnnotationSetList> annotationSetList;
+  std::vector<MIRPragma*> pragmas;
+};
+
+class DexBCAnnotationsDirectory : public BCAnnotationsDirectory {
+ public:
+  DexBCAnnotationsDirectory(MIRModule &moduleArg, MemPool &mpArg, IDexFile &iDexFileArg,
+                            const std::string &classNameArg,
+                            const IDexAnnotationsDirectory *iDexAnnotationsDirectoryArg)
+      : BCAnnotationsDirectory(moduleArg, mpArg),
+        iDexFile(iDexFileArg),
+        className(classNameArg),
+        iDexAnnotationsDirectory(iDexAnnotationsDirectoryArg) {
+    Init();
+  }
+
+  ~DexBCAnnotationsDirectory() {
+    iDexAnnotationsDirectory = nullptr;
+  }
+
+ protected:
+  std::vector<MIRPragma*> &EmitPragmasImpl() override;
+
+ private:
+  void Init();
+  IDexFile &iDexFile;
+  std::string className;
+  const IDexAnnotationsDirectory *iDexAnnotationsDirectory;
+  std::unique_ptr<DexBCAnnotationSet> classAnnotationSet;
+  std::vector<std::unique_ptr<DexBCFieldAnnotations>> fieldAnnotationsItems;
+  std::vector<std::unique_ptr<DexBCMethodAnnotations>> methodAnnotationsItems;
+  std::vector<std::unique_ptr<DexBCParameterAnnotations>> parameterAnnotationsItems;
+};
+}  // namespace bc
+}  // namespace maple
+#endif // HIR2MPL_BC_INPUT_INCLUDE_DEX_PRAGMA_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_reader.h b/src/hir2mpl/bytecode_input/dex/include/dex_reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb99cc1bd1baa4c6f467f9630e3ef0b10fadb256
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_reader.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_DEX_INPUT_DEX_READER_H
+#define MPL_FE_DEX_INPUT_DEX_READER_H
+#include <string>
+#include <memory>
+#include "dexfile_interface.h"
+#include "types_def.h"
+#include "bc_instruction.h"
+#include "bc_class.h"
+#include "bc_io.h"
+
+namespace maple {
+namespace bc {
+typedef std::map<uint16, std::set<std::tuple<std::string, std::string, std::string>>> SrcLocalInfo;
+
+class DexReader : public BCReader {
+ public:
+  DexReader(uint32 fileIdxIn, const std::string &fileNameIn)
+      : BCReader(fileNameIn), fileIdx(fileIdxIn) {}
+  ~DexReader() = default;
+  void SetDexFile(std::unique_ptr<IDexFile> dexFile);
+  uint32 GetClassItemsSize() const;
+  const char *GetClassJavaSourceFileName(uint32 classIdx) const;
+  bool IsInterface(uint32 classIdx) const;
+  uint32 GetClassAccFlag(uint32 classIdx) const;
+  std::string GetClassName(uint32 classIdx) const;
+  std::list<std::string> GetSuperClasses(uint32 classIdx, bool mapled = false) const;
+  std::vector<std::string> GetClassInterfaceNames(uint32 classIdx, bool mapled = false) const;
+  std::string GetClassFieldName(uint32 fieldIdx, bool mapled = false) const;
+  std::string GetClassFieldTypeName(uint32 fieldIdx, bool mapled = false) const;
+  std::string GetClassMethodName(uint32 methodIdx, bool mapled = false) const;
+  std::string GetClassMethodDescName(uint32 methodIdx, bool mapled = false) const;
+  MapleMap<uint32, BCInstruction*> *ResolveInstructions(MapleAllocator &allocator,
+                                                        const IDexMethodItem* dexMethodItem,
+                                                        bool mapled = false) const;
+  std::unique_ptr<std::list<std::unique_ptr<BCTryInfo>>> ResolveTryInfos(const IDexMethodItem* dexMethodItem) const;
+  void ResovleSrcPositionInfo(const IDexMethodItem* dexMethodItem,
+                              std::map<uint32, uint32> &srcPosInfo) const;
+  std::unique_ptr<SrcLocalInfo> ResovleSrcLocalInfo(const IDexMethodItem &dexMethodItem) const;
+  bool ReadAllDepTypeNames(std::unordered_set<std::string> &depSet);
+  bool ReadMethodDepTypeNames(std::unordered_set<std::string> &depSet,
+                              uint32 classIdx, uint32 methodItemx, bool isVirtual) const;
+  bool ReadAllClassNames(std::unordered_set<std::string> &classSet) const;
+
+  maple::IDexFile &GetIDexFile() const {
+    return *iDexFile;
+  }
+  std::unordered_map<std::string, uint32> GetDefiningClassNameTypeIdMap() const; // for init
+  const uint16 *GetMethodInstOffset(const IDexMethodItem* dexMethodItem) const;
+  uint16 GetClassMethodRegisterTotalSize(const IDexMethodItem* dexMethodItem) const;
+  uint16 GetClassMethodRegisterInSize(const IDexMethodItem* dexMethodItem) const;
+  uint32 GetCodeOff(const IDexMethodItem* dexMethodItem) const;
+
+ protected:
+  bool OpenAndMapImpl() override;
+
+ private:
+  std::string GetStringFromIdxImpl(uint32 idx) const override;
+  std::string GetTypeNameFromIdxImpl(uint32 idx) const override;
+  ClassElem GetClassMethodFromIdxImpl(uint32 idx) const override;
+  ClassElem GetClassFieldFromIdxImpl(uint32 idx) const override;
+  std::string GetSignatureImpl(uint32 idx) const override;
+  uint32 GetFileIndexImpl() const override;
+  MapleMap<uint32, BCInstruction*> *ConstructBCPCInstructionMap(
+      MapleAllocator &allocator, const std::map<uint32, std::unique_ptr<IDexInstruction>> &pcInstMap) const;
+  BCInstruction *ConstructBCInstruction(MapleAllocator &allocator,
+      const std::pair<const uint32, std::unique_ptr<IDexInstruction>> &p) const;
+  std::unique_ptr<std::list<std::unique_ptr<BCTryInfo>>> ConstructBCTryInfoList(
+      uint32 codeOff, const std::vector<const IDexTryItem*> &tryItems) const;
+  std::unique_ptr<std::list<std::unique_ptr<BCCatchInfo>>> ConstructBCCatchList(
+      std::vector<IDexCatchHandlerItem> &catchHandlerItems) const;
+  uint32 GetVA(const IDexInstruction *inst) const;
+  uint32 GetVB(const IDexInstruction *inst) const;
+  uint64 GetWideVB(const IDexInstruction *inst) const;
+  uint32 GetVC(const IDexInstruction *inst) const;
+  void GetArgVRegs(const IDexInstruction *inst, MapleList<uint32> &vRegs) const;
+  uint32 GetVH(const IDexInstruction *inst) const;
+  uint8 GetWidth(const IDexInstruction *inst) const;
+  const char *GetOpName(const IDexInstruction *inst) const;
+  void ReadMethodTryCatchDepTypeNames(std::unordered_set<std::string> &depSet, const IDexMethodItem &method) const;
+  void AddDepTypeName(std::unordered_set<std::string> &depSet, const std::string &typeName, bool isTrim) const;
+
+  uint32 fileIdx;
+  std::unique_ptr<maple::IDexFile> iDexFile;
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // MPL_FE_DEX_INPUT_DEX_READER_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_strfac.h b/src/hir2mpl/bytecode_input/dex/include/dex_strfac.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b069b2c3cce4c2e24dfd63e1b83ce89422b8d11
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_strfac.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_BC_INPUT_DEX_STRFAC_H
+#define MPL_FE_BC_INPUT_DEX_STRFAC_H
+#include <string>
+
+namespace maple {
+class DexStrFactory {
+ public:
+  static std::string GetStringFactoryFuncname(const std::string &funcName);
+  static bool IsStringInit(const std::string &funcName);
+};
+}  // namespace maple
+#endif  // MPL_FE_BC_INPUT_DEX_STRFAC_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_strfac_map.def b/src/hir2mpl/bytecode_input/dex/include/dex_strfac_map.def
new file mode 100644
index 0000000000000000000000000000000000000000..0613bd0b291de7d26a8770798ffe962ca8719f60
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_strfac_map.def
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+const char * const strV2 = "Ljava/lang/String;|<init>|()V";
+const char * const strAB2 = "Ljava/lang/String;|<init>|([B)V";
+const char * const strABI2 = "Ljava/lang/String;|<init>|([BI)V";
+const char * const strABII2 = "Ljava/lang/String;|<init>|([BII)V";
+const char * const strABIII2 = "Ljava/lang/String;|<init>|([BIII)V";
+const char * const strABIIS2 = "Ljava/lang/String;|<init>|([BIILjava/lang/String;)V";
+const char * const strABIIT2 = "Ljava/lang/String;|<init>|([BIILjava/nio/charset/Charset;)V";
+const char * const strABS2 = "Ljava/lang/String;|<init>|([BLjava/lang/String;)V";
+const char * const strABT2 = "Ljava/lang/String;|<init>|([BLjava/nio/charset/Charset;)V";
+const char * const strAC2 = "Ljava/lang/String;|<init>|([C)V";
+const char * const strACZ2 = "Ljava/lang/String;|<init>|([CZ)V";
+const char * const strACII2 = "Ljava/lang/String;|<init>|([CII)V";
+const char * const strAIII2 = "Ljava/lang/String;|<init>|([III)V";
+const char * const strIIAC2 = "Ljava/lang/String;|<init>|(II[C)V";
+const char * const strS2 = "Ljava/lang/String;|<init>|(Ljava/lang/String;)V";
+const char * const strF2 = "Ljava/lang/String;|<init>|(Ljava/lang/StringBuffer;)V";
+const char * const strD2 = "Ljava/lang/String;|<init>|(Ljava/lang/StringBuilder;)V";
+const char * const strFacV2 = "Ljava/lang/StringFactory;|newEmptyString|()Ljava/lang/String;";
+const char * const strFacAB2 =
+    "Ljava/lang/StringFactory;|newStringFromBytes|([B)Ljava/lang/String;";
+const char * const strFacABI2 =
+    "Ljava/lang/StringFactory;|newStringFromBytes|([BI)Ljava/lang/String;";
+const char * const strFacABII2 =
+    "Ljava/lang/StringFactory;|newStringFromBytes|([BII)Ljava/lang/String;";
+const char * const strFacABIII2 =
+    "Ljava/lang/StringFactory;|newStringFromBytes|([BIII)Ljava/lang/String;";
+const char * const strFacABIIS2 =
+    "Ljava/lang/StringFactory;|newStringFromBytes|([BIILjava/lang/String;)Ljava/lang/String;";
+const char * const strFacABIIT2 =
+    "Ljava/lang/StringFactory;|newStringFromBytes|([BIILjava/nio/charset/Charset;)Ljava/lang/String;";
+const char * const strFacABS2 =
+    "Ljava/lang/StringFactory;|newStringFromBytes|([BLjava/lang/String;)Ljava/lang/String;";
+const char * const strFacABT2 =
+    "Ljava/lang/StringFactory;|newStringFromBytes|([BLjava/nio/charset/Charset;)Ljava/lang/String;";
+const char * const strFacAC2 =
+    "Ljava/lang/StringFactory;|newStringFromChars|([C)Ljava/lang/String;";
+const char * const strFacACII2 =
+    "Ljava/lang/StringFactory;|newStringFromChars|([CII)Ljava/lang/String;";
+const char * const strFacAIII2 =
+    "Ljava/lang/StringFactory;|newStringFromCodePoints|([III)Ljava/lang/String;";
+const char * const strFacIIAC2 =
+    "Ljava/lang/StringFactory;|newStringFromChars|(II[C)Ljava/lang/String;";
+const char * const strFacS2 =
+    "Ljava/lang/StringFactory;|newStringFromString|(Ljava/lang/String;)Ljava/lang/String;";
+const char * const strFacF2 =
+    "Ljava/lang/StringFactory;|newStringFromStringBuffer|(Ljava/lang/StringBuffer;)Ljava/lang/String;";
+const char * const strFacD2 =
+    "Ljava/lang/StringFactory;|newStringFromStringBuilder|(Ljava/lang/StringBuilder;)Ljava/lang/String;";
+
+STR_STRFAC_MAP2(strV2, strFacV2)
+STR_STRFAC_MAP2(strAB2, strFacAB2)
+STR_STRFAC_MAP2(strABI2, strFacABI2)
+STR_STRFAC_MAP2(strABII2, strFacABII2)
+STR_STRFAC_MAP2(strABIII2, strFacABIII2)
+STR_STRFAC_MAP2(strABIIS2, strFacABIIS2)
+STR_STRFAC_MAP2(strABIIT2, strFacABIIT2)
+STR_STRFAC_MAP2(strABS2, strFacABS2)
+STR_STRFAC_MAP2(strABT2, strFacABT2)
+STR_STRFAC_MAP2(strAC2, strFacAC2)
+STR_STRFAC_MAP2(strACZ2, strFacAC2)
+STR_STRFAC_MAP2(strACII2, strFacACII2)
+STR_STRFAC_MAP2(strAIII2, strFacAIII2)
+STR_STRFAC_MAP2(strIIAC2, strFacIIAC2)
+STR_STRFAC_MAP2(strS2, strFacS2)
+STR_STRFAC_MAP2(strF2, strFacF2)
+STR_STRFAC_MAP2(strD2, strFacD2)
diff --git a/src/hir2mpl/bytecode_input/dex/include/dex_util.h b/src/hir2mpl/bytecode_input/dex/include/dex_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c51e01b7e363b06be4c0a8d9a21618fba07d475
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dex_util.h
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_FE_BC_INPUT_DEX_UTIL_H
+#define MPL_FE_BC_INPUT_DEX_UTIL_H
+#include <map>
+#include "dex_op.h"
+#include "bc_instruction.h"
+#include "types_def.h"
+namespace maple {
+namespace bc {
+static std::map<uint8, Opcode> dexOp2MIROp = {
+    { kDexOpAddInt, OP_add },
+    { kDexOpSubInt, OP_sub },
+    { kDexOpMulInt, OP_mul },
+    { kDexOpDivInt, OP_div },
+    { kDexOpRemInt, OP_rem },
+    { kDexOpAndInt, OP_band },
+    { kDexOpOrInt, OP_bior },
+    { kDexOpXorInt, OP_bxor },
+    { kDexOpShlInt, OP_shl },
+    { kDexOpShrInt, OP_ashr },
+    { kDexOpUshrInt, OP_lshr },
+
+    { kDexOpAddLong, OP_add },
+    { kDexOpSubLong, OP_sub },
+    { kDexOpMulLong, OP_mul },
+    { kDexOpDivLong, OP_div },
+    { kDexOpRemLong, OP_rem },
+    { kDexOpAndLong, OP_band },
+    { kDexOpOrLong, OP_bior },
+    { kDexOpXorLong, OP_bxor },
+    { kDexOpShlLong, OP_shl },
+    { kDexOpShrLong, OP_ashr },
+    { kDexOpUshrLong, OP_lshr },
+
+    { kDexOpAddFloat, OP_add },
+    { kDexOpSubFloat, OP_sub },
+    { kDexOpMulFloat, OP_mul },
+    { kDexOpDivFloat, OP_div },
+    { kDexOpRemFloat, OP_rem },
+    { kDexOpAddDouble, OP_add },
+    { kDexOpSubDouble, OP_sub },
+    { kDexOpMulDouble, OP_mul },
+    { kDexOpDivDouble, OP_div },
+    { kDexOpRemDouble, OP_rem },
+};
+
+static std::map<uint8, Opcode> dexOp2Addr2MIROp = {
+    { kDexOpAddInt2Addr, OP_add },
+    { kDexOpSubInt2Addr, OP_sub },
+    { kDexOpMulInt2Addr, OP_mul },
+    { kDexOpDivInt2Addr, OP_div },
+    { kDexOpRemInt2Addr, OP_rem },
+    { kDexOpAndInt2Addr, OP_band },
+    { kDexOpOrInt2Addr, OP_bior },
+    { kDexOpXorInt2Addr, OP_bxor },
+    { kDexOpShlInt2Addr, OP_shl },
+    { kDexOpShrInt2Addr, OP_ashr },
+    { kDexOpUshrInt2Addr, OP_lshr },
+
+    { kDexOpAddLong2Addr, OP_add },
+    { kDexOpSubLong2Addr, OP_sub },
+    { kDexOpMulLong2Addr, OP_mul },
+    { kDexOpDivLong2Addr, OP_div },
+    { kDexOpRemLong2Addr, OP_rem },
+    { kDexOpAndLong2Addr, OP_band },
+    { kDexOpOrLong2Addr, OP_bior },
+    { kDexOpXorLong2Addr, OP_bxor },
+    { kDexOpShlLong2Addr, OP_shl },
+    { kDexOpShrLong2Addr, OP_ashr },
+    { kDexOpUshrLong2Addr, OP_lshr },
+
+    { kDexOpAddFloat2Addr, OP_add },
+    { kDexOpSubFloat2Addr, OP_sub },
+    { kDexOpMulFloat2Addr, OP_mul },
+    { kDexOpDivFloat2Addr, OP_div },
+    { kDexOpRemFloat2Addr, OP_rem },
+    { kDexOpAddDouble2Addr, OP_add },
+    { kDexOpSubDouble2Addr, OP_sub },
+    { kDexOpMulDouble2Addr, OP_mul },
+    { kDexOpDivDouble2Addr, OP_div },
+    { kDexOpRemDouble2Addr, OP_rem },
+};
+
+static std::map<uint8, Opcode> dexOpCmp2MIROp = {
+    { kDexOpCmpLong, OP_cmp },
+    { kDexOpCmplFloat, OP_cmpl },
+    { kDexOpCmpgFloat, OP_cmpg },
+    { kDexOpCmplDouble, OP_cmpl },
+    { kDexOpCmpgDouble, OP_cmpg },
+};
+
+static std::map<uint8, Opcode> dexOpLit2MIROp = {
+    { kDexOpAddIntLit16, OP_add },
+    { kDexOpRsubInt, OP_sub },
+    { kDexOpMulIntLit16, OP_mul },
+    { kDexOpDivIntLit16, OP_div },
+    { kDexOpRemIntLit16, OP_rem },
+    { kDexOpAndIntLit16, OP_band },
+    { kDexOpOrIntLit16, OP_bior },
+    { kDexOpXorIntLit16, OP_bxor },
+
+    { kDexOpAddIntLit8, OP_add },
+    { kDexOpRsubIntLit8, OP_sub },
+    { kDexOpMulIntLit8, OP_mul },
+    { kDexOpDivIntLit8, OP_div },
+    { kDexOpRemIntLit8, OP_rem },
+    { kDexOpAndIntLit8, OP_band },
+    { kDexOpOrIntLit8, OP_bior },
+    { kDexOpXorIntLit8, OP_bxor },
+    { kDexOpShlIntLit8, OP_shl },
+    { kDexOpShrIntLit8, OP_ashr },
+    { kDexOpUshrIntLit8, OP_lshr },
+};
+
+static std::map<DexOpCode, Opcode> dexOpConditionOp2MIROp = {
+    { kDexOpIfEq, OP_eq },
+    { kDexOpIfNe, OP_ne },
+    { kDexOpIfLt, OP_lt },
+    { kDexOpIfGe, OP_ge },
+    { kDexOpIfGt, OP_gt },
+    { kDexOpIfLe, OP_le },
+
+    { kDexOpIfEqZ, OP_eq },
+    { kDexOpIfNeZ, OP_ne },
+    { kDexOpIfLtZ, OP_lt },
+    { kDexOpIfGeZ, OP_ge },
+    { kDexOpIfGtZ, OP_gt },
+    { kDexOpIfLeZ, OP_le },
+};
+
+static std::map<DexOpCode, Opcode> dexOpInvokeOp2MIROp = {
+    { kDexOpInvokeVirtual, OP_virtualcallassigned },
+    { kDexOpInvokeVirtualRange, OP_virtualcallassigned },
+    { kDexOpInvokeSuper, OP_superclasscallassigned },
+    { kDexOpInvokeSuperRange, OP_superclasscallassigned },
+    { kDexOpInvokeDirect, OP_callassigned },
+    { kDexOpInvokeDirectRange, OP_callassigned },
+    { kDexOpInvokeStatic, OP_callassigned },
+    { kDexOpInvokeStaticRange, OP_callassigned },
+    { kDexOpInvokeInterface, OP_interfacecallassigned },
+    { kDexOpInvokeInterfaceRange, OP_interfacecallassigned },
+};
+
+class DEXUtil {
+ private:
+  DEXUtil() = default;
+  ~DEXUtil() = default;
+};
+}  // namespace bc
+}  // namespace maple
+#endif  // MPL_FE_BC_INPUT_DEX_UTIL_H
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/include/dexfile_factory.h b/src/hir2mpl/bytecode_input/dex/include/dexfile_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..9110ab59b64eb6d0cb2f105c9a497bdbc129fa1b
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dexfile_factory.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_DEX_INPUT_INCLUDE_DEXFILE_FACTORY_H
+#define HIR2MPL_DEX_INPUT_INCLUDE_DEXFILE_FACTORY_H
+
+#include <memory>
+#include "dexfile_interface.h"
+
+namespace maple {
+class DexFileFactory {
+ public:
+  std::unique_ptr<IDexFile> NewInstance() const;
+};
+} // namespace maple
+
+#endif /* HIR2MPL_DEX_INPUT_INCLUDE_DEXFILE_FACTORY_H_ */
diff --git a/src/hir2mpl/bytecode_input/dex/include/dexfile_interface.h b/src/hir2mpl/bytecode_input/dex/include/dexfile_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..57e9ee0ac2b11b9fc63cea77aa2496cf39f55123
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dexfile_interface.h
@@ -0,0 +1,750 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_DEX_INPUT_INCLUDE_DEXFILE_INTERFACE_H
+#define HIR2MPL_DEX_INPUT_INCLUDE_DEXFILE_INTERFACE_H
+
+#include <cstdint>
+#include <map>
+#include <unordered_map>
+#include <set>
+#include <vector>
+#include <iostream>
+#include <memory>
+#include <list>
+#include <functional>
+#include "namemangler.h"
+
+namespace  maple {
+enum ValueType {
+  kByte = 0x00,
+  kShort = 0x02,
+  kChar = 0x03,
+  kInt = 0x04,
+  kLong = 0x06,
+  kFloat = 0x10,
+  kDouble = 0x11,
+  kMethodType = 0x15,
+  kMethodHandle = 0x16,
+  kString = 0x17,
+  kType = 0x18,
+  kField = 0x19,
+  kMethod = 0x1a,
+  kEnum = 0x1b,
+  kArray = 0x1c,
+  kAnnotation = 0x1d,
+  kNull = 0x1e,
+  kBoolean = 0x1f
+};
+const uint16_t kIDexNumPackedOpcodes = 0x100;
+const uint16_t kIDexPackedSwitchSignature = 0x100;
+const uint16_t kIDexSparseSwitchSignature = 0x200;
+
+// opcode in dex file
+enum IDexOpcode : uint8_t {
+  kOpNop                          = 0x00,
+  kOpMove                         = 0x01,
+  kOpMoveFrom16                   = 0x02,
+  kOpMove16                       = 0x03,
+  kOpMoveWide                     = 0x04,
+  kOpMoveWideFrom16               = 0x05,
+  kOpMoveWide16                   = 0x06,
+  kOpMoveObject                   = 0x07,
+  kOpMoveObjectFrom16             = 0x08,
+  kOpMoveObject16                 = 0x09,
+  kOpMoveResult                   = 0x0a,
+  kOpMoveResultWide               = 0x0b,
+  kOpMoveResultObject             = 0x0c,
+  kOpMoveException                = 0x0d,
+  kOpReturnVoid                   = 0x0e,
+  kOpReturn                       = 0x0f,
+  kOpReturnWide                   = 0x10,
+  kOpReturnObject                 = 0x11,
+  kOpConst4                       = 0x12,
+  kOpConst16                      = 0x13,
+  kOpConst                        = 0x14,
+  kOpConstHigh16                  = 0x15,
+  kOpConstWide16                  = 0x16,
+  kOpConstWide32                  = 0x17,
+  kOpConstWide                    = 0x18,
+  kOpConstWideHigh16              = 0x19,
+  kOpConstString                  = 0x1a,
+  kOpConstStringJumbo             = 0x1b,
+  kOpConstClass                   = 0x1c,
+  kOpMonitorEnter                 = 0x1d,
+  kOpMonitorExit                  = 0x1e,
+  kOpCheckCast                    = 0x1f,
+  kOpInstanceOf                   = 0x20,
+  kOpArrayLength                  = 0x21,
+  kOpNewInstance                  = 0x22,
+  kOpNewArray                     = 0x23,
+  kOpFilledNewArray               = 0x24,
+  kOpFilledNewArrayRange          = 0x25,
+  kOpFillArrayData                = 0x26,
+  kOpThrow                        = 0x27,
+  kOpGoto                         = 0x28,
+  kOpGoto16                       = 0x29,
+  kOpGoto32                       = 0x2a,
+  kOpPackedSwitch                 = 0x2b,
+  kOpSparseSwitch                 = 0x2c,
+  kOpCmplFloat                    = 0x2d,
+  kOpCmpgFloat                    = 0x2e,
+  kOpCmplDouble                   = 0x2f,
+  kOpCmpgDouble                   = 0x30,
+  kOpCmpLong                      = 0x31,
+  kOpIfEq                         = 0x32,
+  kOpIfNe                         = 0x33,
+  kOpIfLt                         = 0x34,
+  kOpIfGe                         = 0x35,
+  kOpIfGt                         = 0x36,
+  kOpIfLe                         = 0x37,
+  kOpIfEqz                        = 0x38,
+  kOpIfNez                        = 0x39,
+  kOpIfLtz                        = 0x3a,
+  kOpIfGez                        = 0x3b,
+  kOpIfGtz                        = 0x3c,
+  kOpIfLez                        = 0x3d,
+  kOpUnused3E                     = 0x3e,
+  kOpUnused3F                     = 0x3f,
+  kOpUnused40                     = 0x40,
+  kOpUnused41                     = 0x41,
+  kOpUnused42                     = 0x42,
+  kOpUnused43                     = 0x43,
+  kOpAget                         = 0x44,
+  kOpAgetWide                     = 0x45,
+  kOpAgetObject                   = 0x46,
+  kOpAgetBoolean                  = 0x47,
+  kOpAgetByte                     = 0x48,
+  kOpAgetChar                     = 0x49,
+  kOpAgetShort                    = 0x4a,
+  kOpAput                         = 0x4b,
+  kOpAputWide                     = 0x4c,
+  kOpAputObject                   = 0x4d,
+  kOpAputBoolean                  = 0x4e,
+  kOpAputByte                     = 0x4f,
+  kOpAputChar                     = 0x50,
+  kOpAputShort                    = 0x51,
+  kOpIget                         = 0x52,
+  kOpIgetWide                     = 0x53,
+  kOpIgetObject                   = 0x54,
+  kOpIgetBoolean                  = 0x55,
+  kOpIgetByte                     = 0x56,
+  kOpIgetChar                     = 0x57,
+  kOpIgetShort                    = 0x58,
+  kOpIput                         = 0x59,
+  kOpIputWide                     = 0x5a,
+  kOpIputObject                   = 0x5b,
+  kOpIputBoolean                  = 0x5c,
+  kOpIputByte                     = 0x5d,
+  kOpIputChar                     = 0x5e,
+  kOpIputShort                    = 0x5f,
+  kOpSget                         = 0x60,
+  kOpSgetWide                     = 0x61,
+  kOpSgetObject                   = 0x62,
+  kOpSgetBoolean                  = 0x63,
+  kOpSgetByte                     = 0x64,
+  kOpSgetChar                     = 0x65,
+  kOpSgetShort                    = 0x66,
+  kOpSput                         = 0x67,
+  kOpSputWide                     = 0x68,
+  kOpSputObject                   = 0x69,
+  kOpSputBoolean                  = 0x6a,
+  kOpSputByte                     = 0x6b,
+  kOpSputChar                     = 0x6c,
+  kOpSputShort                    = 0x6d,
+  kOpInvokeVirtual                = 0x6e,
+  kOpInvokeSuper                  = 0x6f,
+  kOpInvokeDirect                 = 0x70,
+  kOpInvokeStatic                 = 0x71,
+  kOpInvokeInterface              = 0x72,
+  kOpUnused73                     = 0x73,
+  kOpInvokeVirtualRange           = 0x74,
+  kOpInvokeSuperRange             = 0x75,
+  kOpInvokeDirectRange            = 0x76,
+  kOpInvokeStaticRange            = 0x77,
+  kOpInvokeInterfaceRange         = 0x78,
+  kOpUnused79                     = 0x79,
+  kOpUnused7A                     = 0x7a,
+  kOpNegInt                       = 0x7b,
+  kOpNotInt                       = 0x7c,
+  kOpNegLong                      = 0x7d,
+  kOpNotLong                      = 0x7e,
+  kOpNegFloat                     = 0x7f,
+  kOpNegDouble                    = 0x80,
+  kOpIntToLong                    = 0x81,
+  kOpIntToFloat                   = 0x82,
+  kOpIntToDouble                  = 0x83,
+  kOpLongToInt                    = 0x84,
+  kOpLongToFloat                  = 0x85,
+  kOpLongToDouble                 = 0x86,
+  kOpFloatToInt                   = 0x87,
+  kOpFloatToLong                  = 0x88,
+  kOpFloatToDouble                = 0x89,
+  kOpDoubleToInt                  = 0x8a,
+  kOpDoubleToLong                 = 0x8b,
+  kOpDoubleToFloat                = 0x8c,
+  kOpIntToByte                    = 0x8d,
+  kOpIntToChar                    = 0x8e,
+  kOpIntToShort                   = 0x8f,
+  kOpAddInt                       = 0x90,
+  kOpSubInt                       = 0x91,
+  kOpMulInt                       = 0x92,
+  kOpDivInt                       = 0x93,
+  kOpRemInt                       = 0x94,
+  kOpAndInt                       = 0x95,
+  kOpOrInt                        = 0x96,
+  kOpXorInt                       = 0x97,
+  kOpShlInt                       = 0x98,
+  kOpShrInt                       = 0x99,
+  kOpUshrInt                      = 0x9a,
+  kOpAddLong                      = 0x9b,
+  kOpSubLong                      = 0x9c,
+  kOpMulLong                      = 0x9d,
+  kOpDivLong                      = 0x9e,
+  kOpRemLong                      = 0x9f,
+  kOpAndLong                      = 0xa0,
+  kOpOrLong                       = 0xa1,
+  kOpXorLong                      = 0xa2,
+  kOpShlLong                      = 0xa3,
+  kOpShrLong                      = 0xa4,
+  kOpUshrLong                     = 0xa5,
+  kOpAddFloat                     = 0xa6,
+  kOpSubFloat                     = 0xa7,
+  kOpMulFloat                     = 0xa8,
+  kOpDivFloat                     = 0xa9,
+  kOpRemFloat                     = 0xaa,
+  kOpAddDouble                    = 0xab,
+  kOpSubDouble                    = 0xac,
+  kOpMulDouble                    = 0xad,
+  kOpDivDouble                    = 0xae,
+  kOpRemDouble                    = 0xaf,
+  kOpAddInt2Addr                  = 0xb0,
+  kOpSubInt2Addr                  = 0xb1,
+  kOpMulInt2Addr                  = 0xb2,
+  kOpDivInt2Addr                  = 0xb3,
+  kOpRemInt2Addr                  = 0xb4,
+  kOpAndInt2Addr                  = 0xb5,
+  kOpOrInt2Addr                   = 0xb6,
+  kOpXorInt2Addr                  = 0xb7,
+  kOpShlInt2Addr                  = 0xb8,
+  kOpShrInt2Addr                  = 0xb9,
+  kOpUshrInt2Addr                 = 0xba,
+  kOpAddLong2Addr                 = 0xbb,
+  kOpSubLong2Addr                 = 0xbc,
+  kOpMulLong2Addr                 = 0xbd,
+  kOpDivLong2Addr                 = 0xbe,
+  kOpRemLong2Addr                 = 0xbf,
+  kOpAndLong2Addr                 = 0xc0,
+  kOpOrLong2Addr                  = 0xc1,
+  kOpXorLong2Addr                 = 0xc2,
+  kOpShlLong2Addr                 = 0xc3,
+  kOpShrLong2Addr                 = 0xc4,
+  kOpUshrLong2Addr                = 0xc5,
+  kOpAddFloat2Addr                = 0xc6,
+  kOpSubFloat2Addr                = 0xc7,
+  kOpMulFloat2Addr                = 0xc8,
+  kOpDivFloat2Addr                = 0xc9,
+  kOpRemFloat2Addr                = 0xca,
+  kOpAddDouble2Addr               = 0xcb,
+  kOpSubDouble2Addr               = 0xcc,
+  kOpMulDouble2Addr               = 0xcd,
+  kOpDivDouble2Addr               = 0xce,
+  kOpRemDouble2Addr               = 0xcf,
+  kOpAddIntLit16                  = 0xd0,
+  kOpRsubInt                      = 0xd1,
+  kOpMulIntLit16                  = 0xd2,
+  kOpDivIntLit16                  = 0xd3,
+  kOpRemIntLit16                  = 0xd4,
+  kOpAndIntLit16                  = 0xd5,
+  kOpOrIntLit16                   = 0xd6,
+  kOpXorIntLit16                  = 0xd7,
+  kOpAddIntLit8                   = 0xd8,
+  kOpRsubIntLit8                  = 0xd9,
+  kOpMulIntLit8                   = 0xda,
+  kOpDivIntLit8                   = 0xdb,
+  kOpRemIntLit8                   = 0xdc,
+  kOpAndIntLit8                   = 0xdd,
+  kOpOrIntLit8                    = 0xde,
+  kOpXorIntLit8                   = 0xdf,
+  kOpShlIntLit8                   = 0xe0,
+  kOpShrIntLit8                   = 0xe1,
+  kOpUshrIntLit8                  = 0xe2,
+  kOpIgetVolatile                 = 0xe3,
+  kOpIputVolatile                 = 0xe4,
+  kOpSgetVolatile                 = 0xe5,
+  kOpSputVolatile                 = 0xe6,
+  kOpIgetObjectVolatile           = 0xe7,
+  kOpIgetWideVolatile             = 0xe8,
+  kOpIputWideVolatile             = 0xe9,
+  kOpSgetWideVolatile             = 0xea,
+  kOpSputWideVolatile             = 0xeb,
+  kOpBreakpoint                   = 0xec,
+  kOpThrowVerificationError       = 0xed,
+  kOpExecuteInline                = 0xee,
+  kOpExecuteInlineRange           = 0xef,
+  kOpInvokeObjectInitRange        = 0xf0,
+  kOpReturnVoidBarrier            = 0xf1,
+  kOpIgetQuick                    = 0xf2,
+  kOpIgetWideQuick                = 0xf3,
+  kOpIgetObjectQuick              = 0xf4,
+  kOpIputQuick                    = 0xf5,
+  kOpIputWideQuick                = 0xf6,
+  kOpIputObjectQuick              = 0xf7,
+  kOpInvokeVirtualQuick           = 0xf8,
+  kOpInvokeVirtualQuickRange      = 0xf9,
+  kOpInvokePolymorphic            = 0xfa,
+  kOpInvokePolymorphicRange       = 0xfb,
+  kOpInvokeCustom                 = 0xfc,
+  kOpInvokeCustomRange            = 0xfd,
+  kOpSputObjectVolatile           = 0xfe,
+  kOpUnusedFF                     = 0xff
+};
+
+enum IDexInstructionIndexType : uint8_t {
+  kIDexIndexUnknown = 0,
+  kIDexIndexNone,               // has no index
+  kIDexIndexTypeRef,            // type reference index
+  kIDexIndexStringRef,          // string reference index
+  kIDexIndexMethodRef,          // method reference index
+  kIDexIndexFieldRef,           // field reference index
+  kIDexIndexFieldOffset,        // field offset (for static linked fields)
+  kIDexIndexVtableOffset,       // vtable offset (for static linked methods)
+  kIDexIndexMethodAndProtoRef,  // method index and proto indexv
+  kIDexIndexCallSiteRef,        // call site index
+  kIDexIndexInlineMethod,       // inline method index (for inline linked methods)
+  kIDexIndexVaries              // "It depends." Used for throw-verification-error
+};
+
+enum IDexInstructionFormat : uint8_t {
+  kIDexFmt10x,      // op
+  kIDexFmt12x,      // op vA, vB
+  kIDexFmt11n,      // op vA, #+B
+  kIDexFmt11x,      // op vAA
+  kIDexFmt10t,      // op +AA
+  kIDexFmt20t,      // op +AAAA
+  kIDexFmt22x,      // op vAA, vBBBB
+  kIDexFmt21t,      // op vAA, +BBBB
+  kIDexFmt21s,      // op vAA, #+BBBB
+  kIDexFmt21h,      // op vAA, #+BBBB00000[00000000]
+  kIDexFmt21c,      // op vAA, thing@BBBB
+  kIDexFmt23x,      // op vAA, vBB, vCC
+  kIDexFmt22b,      // op vAA, vBB, #+CC
+  kIDexFmt22t,      // op vA, vB, +CCCC
+  kIDexFmt22s,      // op vA, vB, #+CCCC
+  kIDexFmt22c,      // op vA, vB, thing@CCCC
+  kIDexFmt32x,      // op vAAAA, vBBBB
+  kIDexFmt30t,      // op +AAAAAAAA
+  kIDexFmt31t,      // op vAA, +BBBBBBBB
+  kIDexFmt31i,      // op vAA, #+BBBBBBBB
+  kIDexFmt31c,      // op vAA, string@BBBBBBBB
+  kIDexFmt35c,      // op {vC,vD,vE,vF,vG}, thing@BBBB
+  kIDexFmt3rc,      // op {vCCCC .. v(CCCC+AA-1)}, thing@BBBB
+  kIDexFmt45cc,     // op {vC, vD, vE, vF, vG}, meth@BBBB, proto@HHHH
+  kIDexFmt4rcc,     // op {VCCCC .. v(CCCC+AA-1)}, meth@BBBB, proto@HHHH
+  kIDexFmt51l       // op vAA, #+BBBBBBBBBBBBBBBB
+};
+
+class IDexFile;
+
+class IDexInstruction {
+ public:
+  IDexInstruction() = default;
+  virtual ~IDexInstruction() = default;
+  virtual IDexOpcode GetOpcode() const = 0;
+  virtual const char *GetOpcodeName() const = 0;
+  virtual uint32_t GetVRegA() const = 0;
+  virtual uint32_t GetVRegB() const = 0;
+  virtual uint64_t GetVRegBWide() const = 0;
+  virtual uint32_t GetVRegC() const = 0;
+  virtual uint32_t GetVRegH() const = 0;
+  virtual uint32_t GetArg(uint32_t index) const = 0;
+  virtual bool HasVRegA() const = 0;
+  virtual bool HasVRegB() const = 0;
+  virtual bool HasWideVRegB() const = 0;
+  virtual bool HasVRegC() const = 0;
+  virtual bool HasVRegH() const = 0;
+  virtual bool HasArgs() const = 0;
+  virtual IDexInstructionIndexType GetIndexType() const = 0;
+  virtual IDexInstructionFormat GetFormat() const = 0;
+  virtual size_t GetWidth() const = 0;
+  virtual void SetOpcode(IDexOpcode opcode) = 0;
+  virtual void SetVRegB(uint32_t vRegB) = 0;
+  virtual void SetVRegBWide(uint64_t vRegBWide) = 0;
+  virtual void SetIndexType(IDexInstructionIndexType indexType) = 0;
+};
+
+class IDexCatchHandlerItem {
+ public:
+  IDexCatchHandlerItem(uint32_t typeIdx, uint32_t address) : typeIdx(typeIdx), address(address) {}
+  ~IDexCatchHandlerItem() = default;
+  IDexCatchHandlerItem(const IDexCatchHandlerItem &item) = default;
+  IDexCatchHandlerItem &operator=(const IDexCatchHandlerItem&) = default;
+  uint32_t GetHandlerTypeIdx() const;
+  uint32_t GetHandlerAddress() const;
+  bool IsCatchAllHandlerType() const;
+
+ private:
+  uint32_t typeIdx;  // input parameter
+  uint32_t address;  // input parameter
+};
+
+class IDexTryItem {
+ public:
+  static const IDexTryItem *GetInstance(const void *item);
+  uint32_t GetStartAddr() const;
+  uint32_t GetEndAddr() const;
+  void GetCatchHandlerItems(const IDexFile &dexFile, uint32_t codeOff,
+                            std::vector<IDexCatchHandlerItem> &items) const;
+
+ private:
+  IDexTryItem() = default;
+  virtual ~IDexTryItem() = default;
+};
+
+class IDexProtoIdItem {
+ public:
+  static const IDexProtoIdItem *GetInstance(const IDexFile &dexFile, uint32_t index);
+  const char *GetReturnTypeName(const IDexFile &dexFile) const;
+  uint32_t GetParameterTypeSize(const IDexFile &dexFile) const;
+  void GetParameterTypeIndexes(const IDexFile &dexFile, std::vector<uint16_t> &indexes) const;
+  std::string GetDescriptor(const IDexFile &dexFile) const;
+  const char *GetShorty(const IDexFile &dexFile) const;
+
+ private:
+  IDexProtoIdItem() = default;
+  virtual ~IDexProtoIdItem() = default;
+};
+
+class IDexMethodIdItem {
+ public:
+  static const IDexMethodIdItem *GetInstance(const IDexFile &dexFile, uint32_t index);
+  uint32_t GetClassIdx() const;
+  const char *GetDefiningClassName(const IDexFile &dexFile) const;
+  uint16_t GetProtoIdx() const;
+  const IDexProtoIdItem *GetProtoIdItem(const IDexFile &dexFile) const;
+  uint32_t GetNameIdx() const;
+  const char *GetShortMethodName(const IDexFile &dexFile) const;
+  std::string GetDescriptor(const IDexFile &dexFile) const;
+
+ private:
+  IDexMethodIdItem() = default;
+  virtual ~IDexMethodIdItem() = default;
+};
+
+class IDexMethodItem {
+ public:
+  IDexMethodItem(uint32_t methodIdx, uint32_t accessFlags, uint32_t codeOff);
+  uint32_t GetMethodCodeOff(const IDexMethodItem *item) const;
+  virtual ~IDexMethodItem() = default;
+  uint32_t GetMethodIdx() const;
+  const IDexMethodIdItem *GetMethodIdItem(const IDexFile &dexFile) const;
+  uint32_t GetAccessFlags() const;
+  bool HasCode(const IDexFile &dexFile) const;
+  uint16_t GetRegistersSize(const IDexFile &dexFile) const;
+  uint16_t GetInsSize(const IDexFile &dexFile) const;
+  uint16_t GetOutsSize(const IDexFile &dexFile) const;
+  uint16_t GetTriesSize(const IDexFile &dexFile) const;
+  uint32_t GetInsnsSize(const IDexFile &dexFile) const;
+  const uint16_t *GetInsnsByOffset(const IDexFile &dexFile, uint32_t offset) const;
+  uint32_t GetCodeOff() const;
+  bool IsStatic() const;
+  void GetPCInstructionMap(const IDexFile &dexFile,
+                           std::map<uint32_t, std::unique_ptr<IDexInstruction>> &pcInstructionMap) const;
+  void GetTryItems(const IDexFile &dexFile, std::vector<const IDexTryItem*> &tryItems) const;
+  void GetSrcPositionInfo(const IDexFile &dexFile, std::map<uint32_t, uint32_t> &srcPosInfo) const;
+  void GetSrcLocalInfo(const IDexFile &dexFile,
+                       std::map<uint16_t, std::set<std::tuple<std::string, std::string, std::string>>> &srcLocal) const;
+
+ private:
+  uint32_t methodIdx;           // input parameter
+  uint32_t accessFlags;         // input parameter
+  uint32_t codeOff;             // input parameter
+};
+
+class IDexFieldIdItem {
+ public:
+  static const IDexFieldIdItem *GetInstance(const IDexFile &dexFile, uint32_t index);
+  uint32_t GetClassIdx() const;
+  const char *GetDefiningClassName(const IDexFile &dexFile) const;
+  uint32_t GetTypeIdx() const;
+  const char *GetFieldTypeName(const IDexFile &dexFile) const;
+  uint32_t GetNameIdx() const;
+  const char *GetShortFieldName(const IDexFile &dexFile) const;
+
+ private:
+  IDexFieldIdItem() = default;
+  virtual ~IDexFieldIdItem() = default;
+};
+
+class IDexFieldItem {
+ public:
+  IDexFieldItem(uint32_t fieldIndex, uint32_t accessFlags);
+  virtual ~IDexFieldItem() = default;
+  uint32_t GetFieldIdx() const;
+  const IDexFieldIdItem *GetFieldIdItem(const IDexFile &dexFile) const;
+  uint32_t GetAccessFlags() const;
+
+ private:
+  uint32_t fieldIndex;          // input parameter
+  uint32_t accessFlags;         // input parameter
+};
+
+class IDexAnnotation {
+ public:
+  static const IDexAnnotation *GetInstance(const void *data);
+  uint8_t GetVisibility() const;
+  const uint8_t *GetAnnotationData() const;
+
+ private:
+  IDexAnnotation() = default;
+  virtual ~IDexAnnotation() = default;
+};
+
+class IDexAnnotationSet {
+ public:
+  static const IDexAnnotationSet *GetInstance(const void *data);
+  void GetAnnotations(const IDexFile &dexFile, std::vector<const IDexAnnotation*> &item) const;
+  bool IsValid() const;
+
+ private:
+  IDexAnnotationSet() = default;
+  virtual ~IDexAnnotationSet() = default;
+};
+
+class IDexAnnotationSetList {
+ public:
+  static const IDexAnnotationSetList *GetInstance(const void *data);
+  void GetAnnotationSets(const IDexFile &dexFile, std::vector<const IDexAnnotationSet*> &items) const;
+
+ private:
+  IDexAnnotationSetList() = default;
+  virtual ~IDexAnnotationSetList() = default;
+};
+
+class IDexFieldAnnotations {
+ public:
+  static const IDexFieldAnnotations *GetInstance(const void *data);
+  const IDexFieldIdItem *GetFieldIdItem(const IDexFile &dexFile) const;
+  const IDexAnnotationSet *GetAnnotationSet(const IDexFile &dexFile) const;
+  uint32_t GetFieldIdx() const;
+
+ private:
+  IDexFieldAnnotations() = default;
+  virtual ~IDexFieldAnnotations() = default;
+};
+
+class IDexMethodAnnotations {
+ public:
+  static const IDexMethodAnnotations *GetInstance(const void *data);
+  const IDexMethodIdItem *GetMethodIdItem(const IDexFile &dexFile) const;
+  const IDexAnnotationSet *GetAnnotationSet(const IDexFile &dexFile) const;
+  uint32_t GetMethodIdx() const;
+
+ private:
+  IDexMethodAnnotations() = default;
+  virtual ~IDexMethodAnnotations() = default;
+};
+
+class IDexParameterAnnotations {
+ public:
+  static const IDexParameterAnnotations *GetInstance(const void *data);
+  const IDexMethodIdItem *GetMethodIdItem(const IDexFile &dexFile) const;
+  const IDexAnnotationSetList *GetAnnotationSetList(const IDexFile &dexFile) const;
+  uint32_t GetMethodIdx() const;
+
+ private:
+  IDexParameterAnnotations() = default;
+  virtual ~IDexParameterAnnotations() = default;
+};
+
+class IDexAnnotationsDirectory {
+ public:
+  static const IDexAnnotationsDirectory *GetInstance(const void *data);
+  bool HasClassAnnotationSet(const IDexFile &dexFile) const;
+  bool HasFieldAnnotationsItems(const IDexFile &dexFile) const;
+  bool HasMethodAnnotationsItems(const IDexFile &dexFile) const;
+  bool HasParameterAnnotationsItems(const IDexFile &dexFile) const;
+  const IDexAnnotationSet *GetClassAnnotationSet(const IDexFile &dexFile) const;
+  void GetFieldAnnotationsItems(const IDexFile &dexFile,
+                                std::vector<const IDexFieldAnnotations*> &items) const;
+  void GetMethodAnnotationsItems(const IDexFile &dexFile,
+                                 std::vector<const IDexMethodAnnotations*> &items) const;
+  void GetParameterAnnotationsItems(const IDexFile &dexFile,
+                                    std::vector<const IDexParameterAnnotations*> &items) const;
+
+ private:
+  IDexAnnotationsDirectory() = default;
+  virtual ~IDexAnnotationsDirectory() = default;
+};
+
+class IDexClassItem {
+ public:
+  uint32_t GetClassIdx() const;
+  const char *GetClassName(const IDexFile &dexFile) const;
+  uint32_t GetAccessFlags() const;
+  uint32_t GetSuperclassIdx() const;
+  const char *GetSuperClassName(const IDexFile &dexFile) const;
+  uint32_t GetInterfacesOff() const;
+  void GetInterfaceTypeIndexes(const IDexFile &dexFile, std::vector<uint16_t> &indexes) const;
+  void GetInterfaceNames(const IDexFile &dexFile, std::vector<const char*> &names) const;
+  uint32_t GetSourceFileIdx() const;
+  const char *GetJavaSourceFileName(const IDexFile &dexFile) const;
+  bool HasAnnotationsDirectory(const IDexFile &dexFile) const;
+  uint32_t GetAnnotationsOff() const;
+  const IDexAnnotationsDirectory *GetAnnotationsDirectory(const IDexFile &dexFile) const;
+  uint32_t GetClassDataOff() const;
+  std::vector<std::unique_ptr<IDexFieldItem>> GetFields(const IDexFile &dexFile) const;
+  bool HasStaticValuesList() const;
+  const uint8_t *GetStaticValuesList(const IDexFile &dexFile) const;
+  bool IsInterface() const;
+  bool IsSuperclassValid() const;
+  std::vector<std::pair<uint32_t, uint32_t>> GetMethodsIdxAndFlag(const IDexFile &dexFile, bool isVirtual) const;
+  std::unique_ptr<IDexMethodItem> GetDirectMethod(const IDexFile &dexFile, uint32_t index) const;
+  std::unique_ptr<IDexMethodItem> GetVirtualMethod(const IDexFile &dexFile, uint32_t index) const;
+
+ private:
+  IDexClassItem() = default;
+  virtual ~IDexClassItem() = default;
+};
+
+class IDexHeader {
+ public:
+  static const IDexHeader *GetInstance(const IDexFile &dexFile);
+  uint8_t GetMagic(uint32_t index) const;
+  uint32_t GetChecksum() const;
+  std::string GetSignature() const;
+  uint32_t GetFileSize() const;
+  uint32_t GetHeaderSize() const;
+  uint32_t GetEndianTag() const;
+  uint32_t GetLinkSize() const;
+  uint32_t GetLinkOff() const;
+  uint32_t GetMapOff() const;
+  uint32_t GetStringIdsSize() const;
+  uint32_t GetStringIdsOff() const;
+  uint32_t GetTypeIdsSize() const;
+  uint32_t GetTypeIdsOff() const;
+  uint32_t GetProtoIdsSize() const;
+  uint32_t GetProtoIdsOff() const;
+  uint32_t GetFieldIdsSize() const;
+  uint32_t GetFieldIdsOff() const;
+  uint32_t GetMethodIdsSize() const;
+  uint32_t GetMethodIdsOff() const;
+  uint32_t GetClassDefsSize() const;
+  uint32_t GetClassDefsOff() const;
+  uint32_t GetDataSize() const;
+  uint32_t GetDataOff() const;
+  std::string GetDexVesion() const;
+
+ private:
+  IDexHeader() = default;
+  virtual ~IDexHeader() = default;
+};
+
+class IDexMapList {
+ public:
+  static const IDexMapList *GetInstance(const void *data);
+  uint32_t GetSize() const;
+  uint16_t GetType(uint32_t index) const;
+  uint32_t GetTypeSize(uint32_t index) const;
+
+ private:
+  IDexMapList() = default;
+  virtual ~IDexMapList() = default;
+};
+
+class ResolvedMethodHandleItem;
+class ResolvedMethodType {
+ public:
+  static const ResolvedMethodType *GetInstance(const IDexFile &dexFile, const ResolvedMethodHandleItem &item);
+  static const ResolvedMethodType *GetInstance(const IDexFile &dexFile, uint32_t callSiteId);
+  static void SignatureTypes(const std::string &mt, std::list<std::string> &types);
+  static std::string SignatureReturnType(const std::string &mt);
+  const std::string GetReturnType(const IDexFile &dexFile) const;
+  const std::string GetRawType(const IDexFile &dexFile) const;
+  void GetArgTypes(const IDexFile &dexFile, std::list<std::string> &types) const;
+ private:
+  ResolvedMethodType() = default;
+  ~ResolvedMethodType() = default;
+};
+
+class ResolvedMethodHandleItem {
+ public:
+  static const ResolvedMethodHandleItem *GetInstance(const IDexFile &dexFile, uint32_t index);
+  bool IsInstance() const;
+  bool IsInvoke() const;
+  const std::string GetDeclaringClass(const IDexFile &dexFile) const;
+  const std::string GetMember(const IDexFile &dexFile) const;
+  const std::string GetMemeberProto(const IDexFile &dexFile) const;
+  const ResolvedMethodType *GetMethodType(const IDexFile &dexFile) const;
+  const std::string GetInvokeKind() const;
+
+ private:
+  ResolvedMethodHandleItem() = default;
+  ~ResolvedMethodHandleItem() = default;
+};
+
+class ResolvedCallSiteIdItem {
+ public:
+  static const ResolvedCallSiteIdItem *GetInstance(const IDexFile &dexFile, uint32_t index);
+  uint32_t GetDataOff() const;
+  uint32_t GetMethodHandleIndex(const IDexFile &dexFile) const;
+  const ResolvedMethodType *GetMethodType(const IDexFile &dexFile) const;
+  const std::string GetProto(const IDexFile &dexFile) const;
+  const std::string GetMethodName(const IDexFile &dexFile) const;
+  void GetLinkArgument(const IDexFile &dexFile, std::list<std::pair<ValueType, std::string>> &args) const;
+
+ private:
+  ResolvedCallSiteIdItem() = default;
+  ~ResolvedCallSiteIdItem() = default;
+};
+
+class IDexFile {
+ public:
+  IDexFile() = default;
+  virtual ~IDexFile() = default;
+  virtual bool Open(const std::string &fileName) = 0;
+  virtual const void *GetData() const = 0;
+  virtual uint32_t GetFileIdx() const = 0;
+  virtual void SetFileIdx(uint32_t fileIdxArg) = 0;
+  virtual const uint8_t *GetBaseAddress() const = 0;
+  virtual const IDexHeader *GetHeader() const = 0;
+  virtual const IDexMapList *GetMapList() const = 0;
+  virtual uint32_t GetStringDataOffset(uint32_t index) const = 0;
+  virtual uint32_t GetTypeDescriptorIndex(uint32_t index) const = 0;
+  virtual const char *GetStringByIndex(uint32_t index) const = 0;
+  virtual const char *GetStringByTypeIndex(uint32_t index) const = 0;
+  virtual const IDexProtoIdItem *GetProtoIdItem(uint32_t index) const = 0;
+  virtual const IDexFieldIdItem *GetFieldIdItem(uint32_t index) const = 0;
+  virtual const IDexMethodIdItem *GetMethodIdItem(uint32_t index) const = 0;
+  virtual uint32_t GetClassItemsSize() const = 0;
+  virtual const IDexClassItem *GetClassItem(uint32_t index) const = 0;
+  virtual bool IsNoIndex(uint32_t index) const = 0;
+  virtual uint32_t GetTypeIdFromName(const std::string &className) const = 0;
+  virtual uint32_t ReadUnsignedLeb128(const uint8_t **pStream) const = 0;
+  virtual uint32_t FindClassDefIdx(const std::string &descriptor) const = 0;
+  virtual std::unordered_map<std::string, uint32_t> GetDefiningClassNameTypeIdMap() const = 0;
+
+  // ===== DecodeDebug =====
+  using DebugNewPositionCallback = int (*)(void *cnxt, uint32_t address, uint32_t lineNum);
+  using DebugNewLocalCallback = void (*)(void *cnxt, uint16_t reg, uint32_t startAddress, uint32_t endAddress,
+                                         const char *name, const char *descriptor, const char *signature);
+  virtual void DecodeDebugLocalInfo(const IDexMethodItem &method, DebugNewLocalCallback newLocalCb) = 0;
+  virtual void DecodeDebugPositionInfo(const IDexMethodItem &method, DebugNewPositionCallback newPositionCb)  = 0;
+
+  // ===== Call Site =======
+  virtual const ResolvedCallSiteIdItem *GetCallSiteIdItem(uint32_t idx) const = 0;
+  virtual const ResolvedMethodHandleItem *GetMethodHandleItem(uint32_t idx) const = 0;
+};
+}  // namespace maple
+#endif  // HIR2MPL_DEX_INPUT_INCLUDE_DEXFILE_INTERFACE_H
diff --git a/src/hir2mpl/bytecode_input/dex/include/dexfile_libdexfile.h b/src/hir2mpl/bytecode_input/dex/include/dexfile_libdexfile.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbb2a59dd3e8656af312124183bfde7c94dfb7a3
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/dexfile_libdexfile.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_DEX_INPUT_INCLUDE_DEXFILE_LIBDEXFILE_H
+#define HIR2MPL_DEX_INPUT_INCLUDE_DEXFILE_LIBDEXFILE_H
+
+#include "dexfile_interface.h"
+#include <string.h>
+#include <string>
+#include <vector>
+#include <memory>
+#include <map>
+#include <vector>
+#include <list>
+#include <base/leb128.h>
+#include <dex/dex_file_loader.h>
+#include <dex/dex_file.h>
+#include <dex/code_item_accessors.h>
+#include <dex/dex_file_exception_helpers.h>
+
+namespace maple {
+class DexInstruction : public IDexInstruction {
+ public:
+  explicit DexInstruction(const art::Instruction &artInstruction);
+  ~DexInstruction() = default;
+  void Init();
+  IDexOpcode GetOpcode() const override;
+  const char *GetOpcodeName() const override;
+  uint32_t GetVRegA() const override;
+  uint32_t GetVRegB() const override;
+  uint64_t GetVRegBWide() const override;
+  uint32_t GetVRegC() const override;
+  uint32_t GetVRegH() const override;
+  bool HasVRegA() const override;
+  bool HasVRegB() const override;
+  bool HasWideVRegB() const override;
+  bool HasVRegC() const override;
+  bool HasVRegH() const override;
+  bool HasArgs() const override;
+  uint32_t GetArg(uint32_t index) const override;
+  IDexInstructionIndexType GetIndexType() const override;
+  IDexInstructionFormat GetFormat() const override;
+  size_t GetWidth() const override;
+  void SetOpcode(IDexOpcode opcode) override;
+  void SetVRegB(uint32_t vRegB) override;
+  void SetVRegBWide(uint64_t vRegBWide) override;
+  void SetIndexType(IDexInstructionIndexType indexType) override;
+
+ private:
+  IDexOpcode opcode;
+  IDexInstructionIndexType indexType;
+  uint32_t vA;
+  uint32_t vB;
+  uint64_t vBWide;
+  uint32_t vC;
+  uint32_t vH;
+  const art::Instruction *artInstruction = nullptr;  // input parameter
+  uint32_t arg[art::Instruction::kMaxVarArgRegs];
+};
+
+class LibDexFile : public IDexFile {
+ public:
+  LibDexFile() = default;
+  LibDexFile(std::unique_ptr<const art::DexFile> artDexFile,
+             std::unique_ptr<std::string> contentPtrIn);
+  ~LibDexFile();
+  bool Open(const std::string &fileName) override;
+  const void *GetData() const override {
+    return dexFile;
+  }
+
+  uint32_t GetFileIdx() const override {
+    return fileIdx;
+  }
+
+  void SetFileIdx(uint32_t fileIdxArg) override {
+    fileIdx = fileIdxArg;
+  }
+
+  const uint8_t *GetBaseAddress() const override;
+  const IDexHeader *GetHeader() const override;
+  const IDexMapList *GetMapList() const override;
+  uint32_t GetStringDataOffset(uint32_t index) const override;
+  uint32_t GetTypeDescriptorIndex(uint32_t index) const override;
+  const char *GetStringByIndex(uint32_t index) const override;
+  const char *GetStringByTypeIndex(uint32_t index) const override;
+  const IDexProtoIdItem *GetProtoIdItem(uint32_t index) const override;
+  const IDexFieldIdItem *GetFieldIdItem(uint32_t index) const override;
+  const IDexMethodIdItem *GetMethodIdItem(uint32_t index) const override;
+  uint32_t GetClassItemsSize() const override;
+  const IDexClassItem *GetClassItem(uint32_t index) const override;
+  bool IsNoIndex(uint32_t index) const override;
+  uint32_t GetTypeIdFromName(const std::string &className) const override;
+  uint32_t ReadUnsignedLeb128(const uint8_t **pStream) const override;
+  uint32_t FindClassDefIdx(const std::string &descriptor) const override;
+  std::unordered_map<std::string, uint32_t> GetDefiningClassNameTypeIdMap() const override;
+
+  // ===== DecodeDebug =====
+  void DecodeDebugLocalInfo(const IDexMethodItem &method, DebugNewLocalCallback newLocalCb) override;
+  void DecodeDebugPositionInfo(const IDexMethodItem &method, DebugNewPositionCallback newPositionCb) override;
+
+  // ===== Call Site =======
+  const ResolvedCallSiteIdItem *GetCallSiteIdItem(uint32_t idx) const override;
+  const ResolvedMethodHandleItem *GetMethodHandleItem(uint32_t idx) const override;
+
+ private:
+  void DebugNewLocalCb(void *context, const art::DexFile::LocalInfo &entry) const;
+  bool DebugNewPositionCb(void *context, const art::DexFile::PositionInfo &entry) const;
+  bool CheckFileSize(size_t fileSize);
+  uint32_t fileIdx = 0;
+  // use for save opened content when load on-demand type from opened dexfile
+  std::unique_ptr<std::string> contentPtr;
+  const art::DexFile *dexFile = nullptr;
+  const IDexHeader *header = nullptr;
+  const IDexMapList *mapList = nullptr;
+  DebugNewLocalCallback debugNewLocalCb = nullptr;
+  DebugNewPositionCallback debugNewPositionCb = nullptr;
+  std::string content;
+  std::vector<std::unique_ptr<const art::DexFile>> dexFiles;
+};
+}  // namespace maple
+#endif  // HIR2MPL_DEX_INPUT_INCLUDE_DEXFILE_LIBDEXFILE_H
diff --git a/src/hir2mpl/bytecode_input/dex/include/string_view_format.h b/src/hir2mpl/bytecode_input/dex/include/string_view_format.h
new file mode 100644
index 0000000000000000000000000000000000000000..7aafd7d83cb169d3c0fc7c7ccb853519aeb729a8
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/include/string_view_format.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef STRING_VIEW_FORMAT_H
+#define STRING_VIEW_FORMAT_H
+#if defined(USE_LLVM) || defined(__ANDROID__) || defined(DARWIN)
+#include <string_view>
+using StringView = std::string_view;
+#else
+#include <experimental/string_view>
+using StringView = std::experimental::string_view;
+#endif
+#endif // STRING_VIEW_FORMAT_H
diff --git a/src/hir2mpl/bytecode_input/dex/src/class_linker.cpp b/src/hir2mpl/bytecode_input/dex/src/class_linker.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f613b045766865408ddc2fbe3205fc2752ec12c4
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/class_linker.cpp
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "class_linker.h"
+#include "fe_macros.h"
+
+namespace maple {
+ClassLinker::ClassLinker(std::vector<std::unique_ptr<bc::DexParser>> &classPath) {
+  for (std::unique_ptr<bc::DexParser>& dexFileParser : classPath) {
+    bootClassPath.push_back(std::move(dexFileParser));
+  }
+}
+
+static std::unique_ptr<bc::BCClass> FindInClassPath(const std::string &descriptor,
+                                                    std::vector<std::unique_ptr<bc::DexParser>> &dexFileParsers) {
+  for (std::unique_ptr<bc::DexParser> &dexFileParser : dexFileParsers) {
+    CHECK_NULL_FATAL(dexFileParser);
+    std::unique_ptr<bc::BCClass> klass = dexFileParser->FindClassDef(descriptor);
+    if (klass != nullptr) {
+      return klass;
+    }
+  }
+  return nullptr;
+}
+
+std::unique_ptr<bc::BCClass> ClassLinker::FindInSharedLib(const std::string &className, ClassLoaderInfo &classLoader) {
+  for (uint32 i = 0; i < classLoader.sharedLibraries.size(); ++i) {
+    std::unique_ptr<bc::BCClass> result = FindInBaseClassLoader(className, classLoader.sharedLibraries[i]);
+    if (result) {
+      return result;
+    }
+  }
+  return nullptr;
+}
+
+std::unique_ptr<bc::BCClass> ClassLinker::FindInClassLoaderClassPath(const std::string &className,
+                                                                     ClassLoaderInfo &classLoader) const {
+  return FindInClassPath(className, classLoader.hexElements);
+}
+
+std::unique_ptr<bc::BCClass> ClassLinker::FindInBaseClassLoader(const std::string &className,
+                                                                ClassLoaderInfo *classLoader) {
+  if (classLoader == nullptr) {
+    return FindInClassPath(className, bootClassPath);
+  }
+  if (classLoader->type == kPathClassLoader || classLoader->type == kInMemoryDexClassLoader) {
+    // Parent; Shared Libraries; Class loader dex files
+    std::unique_ptr<bc::BCClass> result = FindInBaseClassLoader(className, classLoader->parent);
+    if (result != nullptr) {
+      return result;
+    }
+    result = FindInSharedLib(className, *classLoader);
+    if (result != nullptr) {
+      return result;
+    }
+    return FindInClassLoaderClassPath(className, *classLoader);
+  }
+  if (classLoader->type == kDelegateLastClassLoader) {
+    // Boot class path; Shared class path; Class loader dex files; Parent
+    std::unique_ptr<bc::BCClass> result = FindInClassPath(className, bootClassPath);
+    if (result != nullptr) {
+      return result;
+    }
+    result = FindInSharedLib(className, *classLoader);
+    if (result != nullptr) {
+      return result;
+    }
+    result = FindInClassLoaderClassPath(className, *classLoader);
+    if (result != nullptr) {
+      return result;
+    }
+    return FindInBaseClassLoader(className, classLoader->parent);
+  }
+  return nullptr;
+}
+
+void ClassLinker::LoadSuperAndInterfaces(const std::unique_ptr<bc::BCClass> &klass, ClassLoaderInfo *classLoader,
+                                         std::list<std::unique_ptr<bc::BCClass>> &klassList) {
+  if (klass->GetSuperClassNames().size() > 0) {
+    FindClass(klass->GetSuperClassNames().front(), classLoader, klassList);
+  }
+  for (std::string interfaceName : klass->GetSuperInterfaceNames()) {
+    FindClass(interfaceName, classLoader, klassList);
+  }
+}
+
+void ClassLinker::FindClass(const std::string &className, ClassLoaderInfo *classLoader,
+                            std::list<std::unique_ptr<bc::BCClass>> &klassList, bool isDefClass) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(className);
+  auto it = processedClassName.find(nameIdx);
+  if (it != processedClassName.end()) {
+    if (isDefClass) {
+      FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "Same class is existed: %s", className.c_str());
+    }
+    return;
+  }
+  // Find in bootclasspath
+  std::unique_ptr<bc::BCClass> klass;
+  if (classLoader == nullptr) {
+    klass = FindInClassPath(className, bootClassPath);
+  } else { // Find in classLoader files
+    klass = FindInBaseClassLoader(className, classLoader);
+  }
+  if (klass != nullptr) {
+    if (isDefClass) {
+      FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "Same class is existed: %s", className.c_str());
+    }
+    FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "klassName=%s", klass->GetClassName(false).c_str());
+    LoadSuperAndInterfaces(klass, classLoader, klassList);
+    (void)processedClassName.insert(nameIdx);
+    klassList.push_back(std::move(klass));
+  } else if (!isDefClass) {
+    WARN(kLncWarn, "Find class failed: %s", className.c_str());
+  }
+}
+}
diff --git a/src/hir2mpl/bytecode_input/dex/src/class_loader_context.cpp b/src/hir2mpl/bytecode_input/dex/src/class_loader_context.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c47b6e6d60d3b8d1b15d6d00b83fac6f1b76f623
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/class_loader_context.cpp
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <android-base/file.h>
+#include "dexfile_libdexfile.h"
+#include "class_loader_context.h"
+
+namespace maple {
+const char ClassLoaderContext::kPathClassLoaderString[] = "PCL";
+const char ClassLoaderContext::kDelegateLastClassLoaderString[] = "DLC";
+const char ClassLoaderContext::kInMemoryDexClassLoaderString[] = "IMC";
+const char ClassLoaderContext::kClassLoaderOpeningMark = '[';
+const char ClassLoaderContext::kClassLoaderClosingMark = ']';
+const char ClassLoaderContext::kClassLoaderSharedLibraryOpeningMark = '{';
+const char ClassLoaderContext::kClassLoaderSharedLibraryClosingMark = '}';
+const char ClassLoaderContext::kClassLoaderSharedLibrarySeparator = '#';
+const char ClassLoaderContext::kClassLoaderSeparator = ';';
+const char ClassLoaderContext::kClasspathSeparator = ',';
+const char ClassLoaderContext::kSpecialSharedLib[] = "&";
+
+size_t ClassLoaderContext::FindMatchingSharedLibraryCloseMarker(const std::string& spec,
+                                                                size_t sharedLibraryOpenIndex) {
+  uint32_t counter = 1;
+  size_t stringIndex = sharedLibraryOpenIndex + 1;
+  size_t sharedLibraryClose = std::string::npos;
+  while (counter != 0) {
+    sharedLibraryClose = spec.find_first_of(kClassLoaderSharedLibraryClosingMark, stringIndex);
+    size_t sharedLibraryOpen = spec.find_first_of(kClassLoaderSharedLibraryOpeningMark, stringIndex);
+    if (sharedLibraryClose == std::string::npos) {
+      break;
+    }
+    if ((sharedLibraryOpen == std::string::npos) ||
+        (sharedLibraryClose < sharedLibraryOpen)) {
+      --counter;
+      stringIndex = sharedLibraryClose + 1;
+    } else {
+      ++counter;
+      stringIndex = sharedLibraryOpen + 1;
+    }
+  }
+  return sharedLibraryClose;
+}
+
+ClassLoaderType ClassLoaderContext::GetCLType(const std::string& clString) {
+  if (clString.compare(0, strlen(kPathClassLoaderString), kPathClassLoaderString) == 0) {
+    return kPathClassLoader;
+  } else if (clString.compare(0, strlen(kDelegateLastClassLoaderString), kDelegateLastClassLoaderString) == 0) {
+    return kDelegateLastClassLoader;
+  } else if (clString.compare(0, strlen(kInMemoryDexClassLoaderString), kInMemoryDexClassLoaderString) == 0) {
+    return kInMemoryDexClassLoader;
+  }
+  return kInvalidClassLoader;
+}
+
+const char* ClassLoaderContext::GetCLTypeName(ClassLoaderType type) const {
+  switch (type) {
+    case kPathClassLoader: {
+      return kPathClassLoaderString;
+    }
+    case kDelegateLastClassLoader: {
+      return kDelegateLastClassLoaderString;
+    }
+    case kInMemoryDexClassLoader: {
+      return kInMemoryDexClassLoaderString;
+    }
+    default: {
+      return nullptr;
+    }
+  }
+}
+
+ClassLoaderInfo *ClassLoaderContext::ParseClassLoaderSpec(const std::string &spec) {
+  ClassLoaderType classLoaderType = GetCLType(spec);
+  if (classLoaderType == kInvalidClassLoader) {
+    return nullptr;
+  }
+  if (classLoaderType == kInMemoryDexClassLoader) {
+    return nullptr;
+  }
+  const char* classLoaderTypeStr = GetCLTypeName(classLoaderType);
+  CHECK_FATAL(classLoaderTypeStr != nullptr, "classLoaderTypeStr return a nullptr!");
+  size_t typeStrZize = strlen(classLoaderTypeStr);
+  // Check the opening and closing markers.
+  if (spec[typeStrZize] != kClassLoaderOpeningMark) {
+    return nullptr;
+  }
+  if ((spec[spec.length() - 1] != kClassLoaderClosingMark) &&
+      (spec[spec.length() - 1] != kClassLoaderSharedLibraryClosingMark)) {
+    return nullptr;
+  }
+  size_t closingIndex = spec.find_first_of(kClassLoaderClosingMark);
+  std::string classpath = spec.substr(typeStrZize + 1, closingIndex - typeStrZize - 1);
+  ClassLoaderInfo *info = mp.New<ClassLoaderInfo>();
+  info->type = classLoaderType;
+  if (!OpenDexFiles(classpath, info->hexElements)) {
+    return nullptr;
+  };
+  if ((spec[spec.length() - 1] == kClassLoaderSharedLibraryClosingMark) &&
+      (spec[spec.length() - 2] != kClassLoaderSharedLibraryOpeningMark)) {
+    size_t startIndex = spec.find_first_of(kClassLoaderSharedLibraryOpeningMark);
+    if (startIndex == std::string::npos) {
+      return nullptr;
+    }
+    std::string sharedLibrariesSpec = spec.substr(startIndex + 1, spec.length() - startIndex - 2);
+    if (!ParseSharedLibraries(sharedLibrariesSpec, *info)) {
+      return nullptr;
+    }
+  }
+  return info;
+}
+
+bool ClassLoaderContext::ParseSharedLibraries(std::string &sharedLibrariesSpec, ClassLoaderInfo &info) {
+  size_t cursor = 0;
+  while (cursor != sharedLibrariesSpec.length()) {
+    size_t sharedLibrarySeparator = sharedLibrariesSpec.find_first_of(kClassLoaderSharedLibrarySeparator, cursor);
+    size_t sharedLibraryOpen = sharedLibrariesSpec.find_first_of(kClassLoaderSharedLibraryOpeningMark, cursor);
+    std::string sharedLibrarySpec;
+    if (sharedLibrarySeparator == std::string::npos) {
+      sharedLibrarySpec = sharedLibrariesSpec.substr(cursor, sharedLibrariesSpec.length() - cursor);
+      cursor = sharedLibrariesSpec.length();
+    } else if ((sharedLibraryOpen == std::string::npos) || (sharedLibraryOpen > sharedLibrarySeparator)) {
+      sharedLibrarySpec = sharedLibrariesSpec.substr(cursor, sharedLibrarySeparator - cursor);
+      cursor = sharedLibrarySeparator + 1;
+    } else {
+      size_t closing_marker = FindMatchingSharedLibraryCloseMarker(sharedLibrariesSpec, sharedLibraryOpen);
+      if (closing_marker == std::string::npos) {
+        return false;
+      }
+      sharedLibrarySpec = sharedLibrariesSpec.substr(cursor, closing_marker + 1 - cursor);
+      cursor = closing_marker + 1;
+      if (cursor != sharedLibrariesSpec.length() &&
+          sharedLibrariesSpec[cursor] == kClassLoaderSharedLibrarySeparator) {
+        ++cursor;
+      }
+    }
+    ClassLoaderInfo *sharedLibrary = ParseInternal(sharedLibrarySpec);
+    if (sharedLibrary == nullptr) {
+      return false;
+    }
+    info.sharedLibraries.push_back(sharedLibrary);
+  }
+  return true;
+}
+
+ClassLoaderInfo *ClassLoaderContext::ParseInternal(const std::string &spec) {
+  std::string remaining = spec;
+  ClassLoaderInfo *first = nullptr;
+  ClassLoaderInfo *previousIteration = nullptr;
+  while (!remaining.empty()) {
+    std::string currentSpec;
+    size_t classLoaderSeparator = remaining.find_first_of(kClassLoaderSeparator);
+    size_t sharedLibraryOpen = remaining.find_first_of(kClassLoaderSharedLibraryOpeningMark);
+    if (classLoaderSeparator == std::string::npos) {
+      currentSpec = remaining;
+      remaining = "";
+    } else if ((sharedLibraryOpen == std::string::npos) || (sharedLibraryOpen > classLoaderSeparator)) {
+      currentSpec = remaining.substr(0, classLoaderSeparator);
+      remaining = remaining.substr(sharedLibraryOpen + 1, remaining.size() - classLoaderSeparator - 1);
+    } else {
+      size_t sharedLibraryClose = FindMatchingSharedLibraryCloseMarker(remaining, sharedLibraryOpen);
+      CHECK_FATAL(sharedLibraryClose != std::string::npos,
+                  "Invalid class loader spec: %s", currentSpec.c_str());
+      currentSpec = remaining.substr(0, sharedLibraryClose + 1);
+      if (remaining.size() == sharedLibraryClose + 1) {
+        remaining = "";
+      } else if ((remaining.size() == sharedLibraryClose + 2) ||
+                 (remaining.at(sharedLibraryClose + 1) != kClassLoaderSeparator)) {
+        CHECK_FATAL(false, "Invalid class loader spec: %s", currentSpec.c_str());
+        return nullptr;
+      } else {
+        remaining = remaining.substr(sharedLibraryClose + 2, remaining.size() - sharedLibraryClose - 2);
+      }
+    }
+    ClassLoaderInfo *info = ParseClassLoaderSpec(currentSpec);
+    CHECK_FATAL(info != nullptr, "Invalid class loader spec: %s", currentSpec.c_str());
+    if (first == nullptr) {
+      first = info;
+      previousIteration = first;
+    } else {
+      CHECK_NULL_FATAL(previousIteration);
+      previousIteration->parent = info;
+      previousIteration = previousIteration->parent;
+    }
+  }
+  return first;
+}
+
+// Process PCL/DLC string, and open the corresponding byte code file (dex/jar/apk)
+bool ClassLoaderContext::Parse(const std::string &spec) {
+  if (spec.empty()) {
+    return false;
+  }
+  // Output to IFile, used by collision check when trying to load IFile.
+  if (spec.compare(kSpecialSharedLib) == 0) {
+    isSpecialSharedLib = true;
+    return false;
+  }
+  loaderChain = ParseInternal(spec);
+  return loaderChain != nullptr;
+}
+
+// PCL
+ClassLoaderContext *ClassLoaderContext::Create(const std::string &spec, MemPool &mp) {
+  ClassLoaderContext *retv = mp.New<ClassLoaderContext>(mp);
+  if (retv->Parse(spec)) {
+    return retv;
+  } else {
+    return nullptr;
+  }
+}
+
+// compiled File
+ClassLoaderInfo *ClassLoaderContext::CreateClassLoader(const std::string &spec) {
+  ClassLoaderInfo *classLoader = mp.New<ClassLoaderInfo>();
+  classLoader->type = kPathClassLoader;
+  classLoader->parent = loaderChain;
+  loaderChain = classLoader;
+  if (!OpenDexFiles(spec, classLoader->hexElements)) {
+    CHECK_FATAL(false, "Fail to Open Dex Files!");
+  };
+  return loaderChain;
+}
+
+bool ClassLoaderContext::OpenDexFiles(const std::string &spec,
+                                      std::vector<std::unique_ptr<bc::DexParser>> &openedFileParsers) {
+  if (spec.empty()) {
+    return false;
+  }
+  bool isSuccess = true;
+  const std::vector<std::string> &fileNames = FEUtils::Split(spec, kClasspathSeparator);
+  uint depFileIdx = UINT32_MAX;
+  for (const std::string &fileName : fileNames) {
+    const bool verifyChecksum = true;
+    const bool verify = true;
+    std::unique_ptr<std::string> content = std::make_unique<std::string>();
+    // If the file is not a .dex file, the function tries .zip/.jar/.apk files,
+    // all of which are Zip archives with "classes.dex" inside.
+    if (!android::base::ReadFileToString(fileName, content.get())) {
+      WARN(kLncErr, "%s ReadFileToString failed", fileName.c_str());
+      isSuccess = false;
+      continue;
+    }
+    // content size must > 0, otherwise previous step return false
+    const art::DexFileLoader dexFileLoader;
+    art::DexFileLoaderErrorCode errorCode;
+    std::string errorMsg;
+    std::vector<std::unique_ptr<const art::DexFile>> dexFiles;
+    if (!dexFileLoader.OpenAll(reinterpret_cast<const uint8_t*>(content->data()), content->size(), fileName, verify,
+                               verifyChecksum, &errorCode, &errorMsg, &dexFiles)) {
+      // Display returned error message to user. Note that this error behavior
+      // differs from the error messages shown by the original Dalvik dexdump.
+      WARN(kLncErr, "%s open fialed, errorMsg: %s", fileName.c_str(), errorMsg.c_str());
+      isSuccess = false;
+      continue;
+    }
+    for (size_t i = 0; i < dexFiles.size(); ++i) {
+      std::unique_ptr<IDexFile> iDexFile = std::make_unique<LibDexFile>(
+          std::move(dexFiles[i]), std::move(content));
+      iDexFile->SetFileIdx(depFileIdx);
+      const std::list<std::string> &inputClassNames = {};
+      const std::string str = fileName + " (classes"  + std::to_string(i + 1) + ")";  // mark dependent dexfile name
+      std::unique_ptr<bc::DexParser> bcParser = std::make_unique<bc::DexParser>(depFileIdx, str, inputClassNames);
+      bcParser->SetDexFile(std::move(iDexFile));
+      openedFileParsers.push_back(std::move(bcParser));
+      --depFileIdx;
+    }
+  }
+  return isSuccess;
+}
+}
diff --git a/src/hir2mpl/bytecode_input/dex/src/dex_class.cpp b/src/hir2mpl/bytecode_input/dex/src/dex_class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90da7c6329d9c43fdb7010e672d783551c4c6d91
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dex_class.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dex_class.h"
+#include "dex_file_util.h"
+#include "dex_op.h"
+#include "fe_utils_java.h"
+namespace maple {
+namespace bc {
+// ========== DexClassField ==========
+bool DexClassField::IsStaticImpl() const {
+  return accessFlag & DexFileUtil::kDexAccStatic;
+}
+
+uint32 DexClassField::GetItemIdxImpl() const {
+  return itemIdx;
+}
+
+uint32 DexClassField::GetIdxImpl() const {
+  return idx;
+}
+
+// ========== DexClassMethod ==========
+bool DexClassMethod::IsStaticImpl() const {
+  return accessFlag & DexFileUtil::kDexAccStatic;
+}
+
+bool DexClassMethod::IsVirtualImpl() const {
+  return isVirtual;
+}
+
+bool DexClassMethod::IsNativeImpl() const {
+  return accessFlag & DexFileUtil::kDexAccNative;
+}
+
+bool DexClassMethod::IsInitImpl() const {
+  return GetName().compare("<init>") == 0;
+}
+
+bool DexClassMethod::IsClinitImpl() const {
+  return GetName().compare("<clinit>") == 0;
+}
+
+uint32 DexClassMethod::GetItemIdxImpl() const {
+  return itemIdx;
+}
+
+uint32 DexClassMethod::GetIdxImpl() const {
+  return idx;
+}
+
+std::vector<std::unique_ptr<FEIRVar>> DexClassMethod::GenArgVarListImpl() const {
+  std::vector<std::unique_ptr<FEIRVar>> args;
+  for (const auto &reg : argRegs) {
+    args.emplace_back(reg->GenFEIRVarReg());
+  }
+  return args;
+}
+
+void DexClassMethod::GenArgRegsImpl() {
+  uint32 regNum = registerTotalSize - registerInsSize;
+  std::string proto = GetDescription();
+  sigTypeNames = FEUtilJava::SolveMethodSignature(proto);
+  if (!IsClinit() && ((GetAccessFlag() & DexFileUtil::kDexAccStatic) == 0)) {
+    std::unique_ptr<BCReg> reg = std::make_unique<BCReg>();
+    reg->regNum = regNum;
+    reg->isDef = true;
+    regNum += 1;
+    reg->regType = allocator.GetMemPool()->New<BCRegType>(allocator, *reg, GetClassNameMplIdx());
+    argRegs.emplace_back(std::move(reg));
+  }
+  if (sigTypeNames.size() > 1) {
+    for (size_t i = 1; i < sigTypeNames.size(); ++i) {
+      std::unique_ptr<BCReg> reg = std::make_unique<BCReg>();
+      reg->regNum = regNum;
+      reg->isDef = true;
+      GStrIdx sigTypeNamesIdx =
+          GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(sigTypeNames.at(i)));
+      reg->regType = allocator.GetMemPool()->New<BCRegType>(allocator, *reg, sigTypeNamesIdx);
+      argRegs.emplace_back(std::move(reg));
+      regNum += (BCUtil::IsWideType(sigTypeNamesIdx) ? 2 : 1);
+    }
+  }
+}
+}  // namespace bc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/src/dex_class2fe_helper.cpp b/src/hir2mpl/bytecode_input/dex/src/dex_class2fe_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4e0d39b7b75ed1323aeda397023a530ef3ee196b
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dex_class2fe_helper.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dex_class2fe_helper.h"
+#include "dex_file_util.h"
+#include "fe_options.h"
+#include "mpl_logging.h"
+#include "fe_manager.h"
+namespace maple {
+namespace bc {
+// ========== DexClass2FEHelper ==========
+DexClass2FEHelper::DexClass2FEHelper(MapleAllocator &allocator, bc::BCClass &klassIn)
+    : BCClass2FEHelper(allocator, klassIn) {}
+
+TypeAttrs DexClass2FEHelper::GetStructAttributeFromInputImpl() const {
+  TypeAttrs attrs;
+  uint32 klassAccessFlag = klass.GetAccessFlag();
+  if (klassAccessFlag & DexFileUtil::kDexAccPublic) {
+    attrs.SetAttr(ATTR_public);
+  }
+  if (klassAccessFlag & DexFileUtil::kDexAccFinal) {
+    attrs.SetAttr(ATTR_final);
+  }
+  if (klassAccessFlag & DexFileUtil::kDexAccAbstract) {
+    attrs.SetAttr(ATTR_abstract);
+  }
+  if (klassAccessFlag & DexFileUtil::kDexAccSynthetic) {
+    attrs.SetAttr(ATTR_synthetic);
+  }
+  if (klassAccessFlag & DexFileUtil::kDexAccAnnotation) {
+    attrs.SetAttr(ATTR_annotation);
+  }
+  if (klassAccessFlag & DexFileUtil::kDexAccEnum) {
+    attrs.SetAttr(ATTR_enum);
+  }
+  return attrs;
+}
+
+void DexClass2FEHelper::InitFieldHelpersImpl() {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mem pool is nullptr");
+  for (const std::unique_ptr<BCClassField> &field : klass.GetFields()) {
+    ASSERT(field != nullptr, "field is nullptr");
+    BCClassField2FEHelper *fieldHelper = mp->New<DexClassField2FEHelper>(allocator, *field);
+    fieldHelpers.push_back(fieldHelper);
+  }
+}
+
+void DexClass2FEHelper::InitMethodHelpersImpl() {
+  MemPool *mp = allocator.GetMemPool();
+  ASSERT(mp != nullptr, "mem pool is nullptr");
+  for (std::unique_ptr<BCClassMethod> &method : klass.GetMethods()) {
+    ASSERT(method != nullptr, "method is nullptr");
+    BCClassMethod2FEHelper *methodHelper = mp->New<DexClassMethod2FEHelper>(allocator, method);
+    methodHelpers.push_back(methodHelper);
+  }
+}
+
+// ========== DexClassField2FEHelper ==========
+FieldAttrs DexClassField2FEHelper::AccessFlag2AttributeImpl(uint32 accessFlag) const {
+  FieldAttrs attrs;
+  if (accessFlag & DexFileUtil::kDexAccPublic) {
+    attrs.SetAttr(FLDATTR_public);
+  }
+  if (accessFlag & DexFileUtil::kDexAccPrivate) {
+    attrs.SetAttr(FLDATTR_private);
+  }
+  if (accessFlag & DexFileUtil::kDexAccProtected) {
+    attrs.SetAttr(FLDATTR_protected);
+  }
+  if (accessFlag & DexFileUtil::kDexAccStatic) {
+    attrs.SetAttr(FLDATTR_static);
+  }
+  if (accessFlag & DexFileUtil::kDexAccFinal) {
+    attrs.SetAttr(FLDATTR_final);
+  }
+  if (accessFlag & DexFileUtil::kDexAccVolatile) {
+    attrs.SetAttr(FLDATTR_volatile);
+  }
+  if (accessFlag & DexFileUtil::kDexAccTransient) {
+    attrs.SetAttr(FLDATTR_transient);
+  }
+  if (accessFlag & DexFileUtil::kDexAccSynthetic) {
+    attrs.SetAttr(FLDATTR_synthetic);
+  }
+  if (accessFlag & DexFileUtil::kDexAccEnum) {
+    attrs.SetAttr(FLDATTR_enum);
+  }
+  return attrs;
+}
+
+// ========== DexClassMethod2FEHelper ==========
+FuncAttrs DexClassMethod2FEHelper::GetAttrsImpl() const {
+  FuncAttrs attrs;
+  uint32 accessFlag = method->GetAccessFlag();
+  if (accessFlag & DexFileUtil::kDexAccPublic) {
+    attrs.SetAttr(FUNCATTR_public);
+  }
+  if (accessFlag & DexFileUtil::kDexAccPrivate) {
+    attrs.SetAttr(FUNCATTR_private);
+  }
+  if (accessFlag & DexFileUtil::kDexAccProtected) {
+    attrs.SetAttr(FUNCATTR_protected);
+  }
+  if (accessFlag & DexFileUtil::kDexAccStatic) {
+    attrs.SetAttr(FUNCATTR_static);
+  }
+  if (accessFlag & DexFileUtil::kDexAccFinal) {
+    attrs.SetAttr(FUNCATTR_final);
+  }
+  if (accessFlag & DexFileUtil::kAccDexSynchronized) {
+    attrs.SetAttr(FUNCATTR_synchronized);
+  }
+  if (accessFlag & DexFileUtil::kDexAccBridge) {
+    attrs.SetAttr(FUNCATTR_bridge);
+  }
+  if (accessFlag & DexFileUtil::kDexAccVarargs) {
+    attrs.SetAttr(FUNCATTR_varargs);
+  }
+  if (accessFlag & DexFileUtil::kDexAccNative) {
+    attrs.SetAttr(FUNCATTR_native);
+  }
+  if (accessFlag & DexFileUtil::kDexAccAbstract) {
+    attrs.SetAttr(FUNCATTR_abstract);
+  }
+  if (accessFlag & DexFileUtil::kDexAccStrict) {
+    attrs.SetAttr(FUNCATTR_strict);
+  }
+  if (accessFlag & DexFileUtil::kDexAccSynthetic) {
+    attrs.SetAttr(FUNCATTR_synthetic);
+  }
+  if (accessFlag & DexFileUtil::kDexAccConstructor) {
+    attrs.SetAttr(FUNCATTR_constructor);
+  }
+  if (accessFlag & DexFileUtil::kDexDeclaredSynchronized) {
+    attrs.SetAttr(FUNCATTR_declared_synchronized);
+  }
+  if (IsVirtual()) {
+    attrs.SetAttr(FUNCATTR_virtual);
+  }
+  return attrs;
+}
+
+bool DexClassMethod2FEHelper::IsStaticImpl() const {
+  if (IsClinit()) {
+    return true;
+  }
+  uint32 accessFlag = method->GetAccessFlag();
+  if ((accessFlag & DexFileUtil::kDexAccStatic) != 0) {
+    return true;
+  }
+  return false;
+}
+
+bool DexClassMethod2FEHelper::IsClinit() const {
+  return method->IsClinit();
+}
+
+bool DexClassMethod2FEHelper::IsInit() const {
+  return method->IsInit();
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/dex/src/dex_encode_value.cpp b/src/hir2mpl/bytecode_input/dex/src/dex_encode_value.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cd0ef7a118b25118d72b6c76b999a7c3af59ff27
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dex_encode_value.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dex_encode_value.h"
+#include "fe_manager.h"
+
+namespace maple {
+namespace bc {
+uint64 DexEncodeValue::GetUVal(const uint8 **data, uint8 len) const {
+  // get value, max 8 bytes, little-endian
+  uint64 val = 0;
+  for (uint8 j = 0; j <= len; j++) {
+    val |= (static_cast<uint64>(*(*data)++) << (j << 3));
+  }
+  return val;
+}
+
+MIRIntConst *DexEncodeValue::ProcessIntValue(const uint8 **data, uint8 valueArg, MIRType &type) {
+  // sign extended val
+  uint64 val = GetUVal(data, valueArg);
+  uint32 shiftBit = static_cast<uint32>((7 - valueArg) * 8); // 7 : max shift bit args
+  CHECK_FATAL(valueArg <= 7, "shiftBit positive check");
+  uint64 sVal = (static_cast<int64>(val) << shiftBit) >> shiftBit;
+  MIRIntConst *intCst = mp.New<MIRIntConst>(sVal, type);
+  return intCst;
+}
+
+MIRStr16Const *DexEncodeValue::ProcessStringValue(const uint8 **data, uint8 valueArg, uint32 &stringID) {
+  uint64 val = GetUVal(data, valueArg);
+  stringID = static_cast<uint32>(val);
+  std::string str = namemangler::GetOriginalNameLiteral(dexFile.GetStringByIndex(static_cast<uint32>(val)));
+  std::u16string str16;
+  (void)namemangler::UTF8ToUTF16(str16, str);
+  MIRStr16Const *strCst = mp.New<MIRStr16Const>(str16, *GlobalTables::GetTypeTable().GetPtr());
+  return strCst;
+}
+
+MIRType *DexEncodeValue::GetTypeFromValueType(uint8 valueType) const {
+  switch (valueType) {
+    case kValueBoolean:
+      return GlobalTables::GetTypeTable().GetInt8();
+    case kValueByte:
+      return GlobalTables::GetTypeTable().GetInt8();
+    case kValueShort:
+      return GlobalTables::GetTypeTable().GetInt16();
+    case kValueChar:
+      return GlobalTables::GetTypeTable().GetUInt16();
+    case kValueInt:
+      return GlobalTables::GetTypeTable().GetInt32();
+    case kValueLong:
+      return GlobalTables::GetTypeTable().GetInt64();
+    case kValueFloat:
+      return GlobalTables::GetTypeTable().GetFloat();
+    case kValueDouble:
+      return GlobalTables::GetTypeTable().GetDouble();
+    default:
+      return GlobalTables::GetTypeTable().GetPtr();
+  }
+}
+
+MIRAggConst *DexEncodeValue::ProcessArrayValue(const uint8 **data) {
+  unsigned arraySize = dexFile.ReadUnsignedLeb128(data);
+  uint64 dataVal = *(*data);
+  uint8 newValueType = dataVal & 0x1f;
+  MIRType *elemType = GetTypeFromValueType(static_cast<PragmaValueType>(newValueType));
+  MIRType *arrayTypeWithSize = GlobalTables::GetTypeTable().GetOrCreateArrayType(*elemType, 1, &arraySize);
+  MIRAggConst *aggCst = mp.New<MIRAggConst>(FEManager::GetModule(), *arrayTypeWithSize);
+  for (uint32 i = 0; i < arraySize; ++i) {
+    MIRConst *mirConst = nullptr;
+    ProcessEncodedValue(data, mirConst);
+    aggCst->PushBack(mirConst);
+  }
+  return aggCst;
+}
+
+void DexEncodeValue::ProcessAnnotationValue(const uint8 **data) {
+  uint32 annoSize = dexFile.ReadUnsignedLeb128(data);
+  MIRConst *mirConst = nullptr;
+  for (uint32 i = 0; i < annoSize; ++i) {
+    ProcessEncodedValue(data, mirConst);
+  }
+}
+
+void DexEncodeValue::ProcessEncodedValue(const uint8 **data, MIRConst *&cst) {
+  uint64 dataVal = *(*data)++;
+  uint32 noMeaning = 0;
+  // valueArgs : dataVal >> 5, The higher three bits are valid.
+  ProcessEncodedValue(data, static_cast<uint8>(dataVal & 0x1f), static_cast<uint8>(dataVal >> 5), cst, noMeaning);
+}
+
+void DexEncodeValue::ProcessEncodedValue(const uint8 **data, uint8 valueType, uint8 valueArg, MIRConst *&cst,
+                                         uint32 &stringID) {
+  uint64 val = 0;
+  cst = mp.New<MIRIntConst>(0, *GlobalTables::GetTypeTable().GetInt32());
+  switch (valueType) {
+    case kValueByte: {
+      val = GetUVal(data, valueArg);
+      cst = mp.New<MIRIntConst>(val, *GlobalTables::GetTypeTable().GetInt8());
+      break;
+    }
+    case kValueShort: {
+      cst = ProcessIntValue(data, valueArg, *GlobalTables::GetTypeTable().GetInt16());
+      break;
+    }
+    case kValueChar: {
+      val = GetUVal(data, valueArg);
+      cst = mp.New<MIRIntConst>(val, *GlobalTables::GetTypeTable().GetUInt16());
+      break;
+    }
+    case kValueInt: {
+      cst = ProcessIntValue(data, valueArg, *GlobalTables::GetTypeTable().GetInt32());
+      break;
+    }
+    case kValueLong: {
+      cst = ProcessIntValue(data, valueArg, *GlobalTables::GetTypeTable().GetInt64());
+      break;
+    }
+    case kValueFloat: {
+      val = GetUVal(data, valueArg);
+      // fill 0s for least significant bits
+      valBuf.u = val << ((3 - valueArg) << 3);
+      cst = mp.New<MIRFloatConst>(valBuf.f, *GlobalTables::GetTypeTable().GetFloat());
+      break;
+    }
+    case kValueDouble: {
+      val = GetUVal(data, valueArg);
+      // fill 0s for least significant bits
+      valBuf.u = val << ((7 - valueArg) << 3);
+      cst = mp.New<MIRDoubleConst>(valBuf.d, *GlobalTables::GetTypeTable().GetDouble());
+      break;
+    }
+    case kValueString: {
+      cst = ProcessStringValue(data, valueArg, stringID);
+      break;
+    }
+    case kValueMethodType: {
+      break;
+    }
+    case kValueType: {
+      (void)GetUVal(data, valueArg);
+      break;
+    }
+    case kValueMethodHandle: {
+      break;
+    }
+    case kValueEnum:
+      // should fallthrough
+      [[fallthrough]];
+    case kValueField: {
+      (void)GetUVal(data, valueArg);
+      break;
+    }
+    case kValueMethod: {
+      (void)GetUVal(data, valueArg);
+      break;
+    }
+    case kValueArray: {
+      CHECK_FATAL(!valueArg, "value_arg != 0");
+      cst = ProcessArrayValue(data);
+      break;
+    }
+    case kValueAnnotation: {
+      (void)GetUVal(data, valueArg);
+      break;
+    }
+    case kValueNull: {
+      CHECK_FATAL(!valueArg, "value_arg != 0");
+      cst = mp.New<MIRIntConst>(0, *GlobalTables::GetTypeTable().GetInt8());
+      break;
+    }
+    case kValueBoolean: {
+      cst = mp.New<MIRIntConst>(valueArg, *GlobalTables::GetTypeTable().GetInt8());
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+} // namespace bc
+} // namespace maple
diff --git a/src/hir2mpl/bytecode_input/dex/src/dex_file_util.cpp b/src/hir2mpl/bytecode_input/dex/src/dex_file_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6d09cc7c2c51f6516b975e6f9274de7b535e60f5
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dex_file_util.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dex_file_util.h"
+namespace maple {
+namespace bc {
+const uint8 DexFileUtil::kDexFileMagic[] = {0x64, 0x65, 0x78, 0x0a, 0x30, 0x33, 0x39, 0x00}; // dex\n039\0
+const uint8 DexFileUtil::kEndianConstant[] = {0x12, 0x34, 0x56, 0x78}; // 0x12345678
+const uint8 DexFileUtil::kReverseEndianConstant[] = {0x78, 0x56, 0x34, 0x12}; // 0x78563412
+
+uint32 DexFileUtil::Adler32(const uint8 *data, uint32 size) {
+  // May be different with adler32 in libz
+  uint32 kMod = 65521;
+  // Calculate A
+  uint16 a = 1;
+  for (uint32 i = 0; i < size; ++i) {
+    a += *(data + i); // truncate the data over 16bit
+  }
+  a %= kMod;
+
+  // Caculate B
+  uint16 item = 1;
+  uint16 b = 0;
+  for (uint32 i = 0; i < size; ++i) {
+    item = item + *(data + i);
+    b += item;
+  }
+  b %= kMod;
+
+  return (static_cast<uint32>(b) << 16) | static_cast<uint32>(a);
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/dex/src/dex_op.cpp b/src/hir2mpl/bytecode_input/dex/src/dex_op.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..24e85c957ad5ab3500414ed5e93d2e96bdd1c595
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dex_op.cpp
@@ -0,0 +1,1851 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dex_op.h"
+#include "dex_file_util.h"
+#include "mpl_logging.h"
+#include "namemangler.h"
+#include "global_tables.h"
+#include "bc_class.h"
+#include "feir_builder.h"
+#include "fe_utils_java.h"
+#include "dex_util.h"
+#include "feir_type_helper.h"
+#include "dex_strfac.h"
+#include "fe_options.h"
+#include "feir_var_name.h"
+#include "ark_annotation_processor.h"
+
+namespace maple {
+namespace bc {
+// ========== DexOp ==========
+DexOp::DexOp(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : BCInstruction(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOp::SetVA(uint32 num) {
+  SetVAImpl(num);
+}
+
+void DexOp::SetVB(uint32 num) {
+  SetVBImpl(num);
+}
+
+void DexOp::SetWideVB(uint64 num) {
+  SetWideVBImpl(num);
+}
+
+void DexOp::SetArgs(const MapleList<uint32> &args) {
+  SetArgsImpl(args);
+}
+
+void DexOp::SetVC(uint32 num) {
+  SetVCImpl(num);
+}
+
+void DexOp::SetVH(uint32 num) {
+  SetVHImpl(num);
+}
+
+std::string DexOp::GetArrayElementTypeFromArrayType(const std::string &typeName) {
+  CHECK_FATAL(!typeName.empty() && typeName[0] == 'A', "Invalid array type name %s", typeName.c_str());
+  return typeName.substr(1);
+}
+
+// ========== DexOpNop ==========
+DexOpNop::DexOpNop(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn) : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+// ========== DexOpMove ==========
+DexOpMove::DexOpMove(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpMove::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  GStrIdx typeNameIdx;
+  if (kDexOpMove <= opcode && opcode <= kDexOpMove16) {
+    typeNameIdx = BCUtil::GetIntIdx();
+  } else if (kDexOpMoveWide <= opcode && opcode <= kDexOpMoveWide16) {
+    typeNameIdx = BCUtil::GetLongIdx();
+  } else if (kDexOpMoveObject <= opcode && opcode <= kDexOpMoveObject16) {
+    typeNameIdx = BCUtil::GetJavaObjectNameMplIdx();
+  } else {
+    CHECK_FATAL(false, "invalid opcode: %x in `DexOpMove`", opcode);
+  }
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, typeNameIdx, true);
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpMove::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  vB.regTypeItem = vA.regTypeItem;
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpMove::SetRegTypeInTypeInferImpl() {
+  vB.regType->RegisterRelatedBCRegType(vA.regType);
+}
+
+std::list<UniqueFEIRStmt> DexOpMove::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  std::unique_ptr<FEIRExpr> dreadExpr = std::make_unique<FEIRExprDRead>(vB.GenFEIRVarReg());
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtDAssign>(vA.GenFEIRVarReg(), std::move(dreadExpr));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpMoveResult =========
+DexOpMoveResult::DexOpMoveResult(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {
+  isReturn = true;
+}
+
+void DexOpMoveResult::SetVATypeNameIdx(const GStrIdx &idx) {
+  vA.regType->SetTypeNameIdx(idx);
+}
+
+DexReg DexOpMoveResult::GetVA() const {
+  return vA;
+}
+
+void DexOpMoveResult::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpMoveResult::SetBCRegTypeImpl(const BCInstruction &inst) {
+  if ((kDexOpInvokeVirtual <= inst.GetOpcode() && inst.GetOpcode() <= kDexOpInvokeInterface) ||
+      (kDexOpInvokeVirtualRange <= inst.GetOpcode() && inst.GetOpcode() <= kDexOpInvokeInterfaceRange) ||
+      (kDexOpInvokePolymorphic <= inst.GetOpcode() && inst.GetOpcode() <= kDexOpInvokeCustomRange)) {
+    GStrIdx retTyIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName(static_cast<const DexOpInvoke&>(inst).GetReturnType()));
+    vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, retTyIdx);
+  } else if (inst.GetOpcode() == kDexOpFilledNewArray || inst.GetOpcode() == kDexOpFilledNewArrayRange) {
+    vA.regType = allocator.GetMemPool()->New<BCRegType>(
+        allocator, vA, static_cast<const DexOpFilledNewArray&>(inst).GetReturnType());
+  } else {
+    CHECK_FATAL(false, "the reg of opcode %u should be inserted in move-result", inst.GetOpcode());
+  }
+}
+
+// ========== DexOpMoveException ==========
+DexOpMoveException::DexOpMoveException(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpMoveException::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpMoveException::SetBCRegTypeImpl(const BCInstruction &inst) {
+  (void) inst;
+  GStrIdx exceptionTypeNameIdx = *(catchedExTypeNamesIdx.begin());
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, exceptionTypeNameIdx);
+  // If exception type is primitive type, it should be <* void>
+  if (vA.GetBasePrimType() != PTY_ref) {
+    vA.regTypeItem->typeNameIdx = BCUtil::GetJavaThrowableNameMplIdx();
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpMoveException::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  std::unique_ptr<FEIRExpr> readExpr = std::make_unique<FEIRExprRegRead>(PTY_ref, -kSregThrownval);
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtDAssign>(vA.GenFEIRVarReg(), std::move(readExpr));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpReturn ==========
+DexOpReturn::DexOpReturn(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpReturn::SetVAImpl(uint32 num) {
+  if (opcode == kDexOpReturnVoid) {
+    isReturnVoid = true;
+    return;
+  }
+  vA.regNum = num;
+  usedRegs.emplace_back(&vA);
+}
+
+void DexOpReturn::ParseImpl(BCClassMethod &method) {
+  GStrIdx usedTypeNameIdx =
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(method.GetSigTypeNames().at(0)));
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(usedTypeNameIdx);
+}
+
+std::list<UniqueFEIRStmt> DexOpReturn::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> ans;
+  if (isReturnVoid) {
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtReturn>(UniqueFEIRExpr(nullptr));
+    ans.emplace_back(std::move(stmt));
+  } else {
+    UniqueFEIRVar var = vA.GenFEIRVarReg();
+    UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(var));
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtReturn>(std::move(expr));
+    ans.emplace_back(std::move(stmt));
+  }
+  return ans;
+}
+
+// ========== DexOpConst ==========
+DexOpConst::DexOpConst(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpConst::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  vA.regValue = allocator.GetMemPool()->New<BCRegValue>();
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpConst::SetVBImpl(uint32 num) {
+  if (opcode != kDexOpConstWide) {
+    vA.regValue->primValue.raw32 = num;
+  }
+  if (!isWide) {
+    vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, BCUtil::GetIntIdx());
+  }
+}
+
+void DexOpConst::SetWideVBImpl(uint64 num) {
+  if (opcode == kDexOpConstWide) {
+    vA.regValue->primValue.raw64 = num;
+  }
+  if (isWide) {
+    vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, BCUtil::GetLongIdx());
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpConst::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRExpr expr;
+  DexReg vATmp;
+  vATmp.regNum = vA.regNum;
+  GStrIdx typeNameIdx;
+  if (isWide) {
+    typeNameIdx = BCUtil::GetLongIdx();
+  } else {
+    typeNameIdx = BCUtil::GetIntIdx();
+  }
+  vATmp.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vATmp, typeNameIdx, true);
+  switch (opcode) {
+    case kDexOpConst4: {
+      expr = FEIRBuilder::CreateExprConstI8(static_cast<int8>(vA.regValue->primValue.raw32));
+      expr = FEIRBuilder::CreateExprCvtPrim(std::move(expr), PTY_i32);
+      break;
+    }
+    case kDexOpConst16: {
+      expr = FEIRBuilder::CreateExprConstI16(static_cast<int16>(vA.regValue->primValue.raw32));
+      expr = FEIRBuilder::CreateExprCvtPrim(std::move(expr), PTY_i32);
+      break;
+    }
+    case kDexOpConst: {
+      expr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(vA.regValue->primValue.raw32));
+      break;
+    }
+    case kDexOpConstHigh16: {
+      expr = FEIRBuilder::CreateExprConstI16(static_cast<int16>(vA.regValue->primValue.raw32));
+      expr = FEIRBuilder::CreateExprCvtPrim(std::move(expr), PTY_i32);
+      UniqueFEIRExpr exprBit = FEIRBuilder::CreateExprConstI32(16);  // 16 means right-zero-extended to 32 bits
+      expr = FEIRBuilder::CreateExprMathBinary(OP_shl, std::move(expr), std::move(exprBit));
+      break;
+    }
+    case kDexOpConstWide16: {
+      expr = FEIRBuilder::CreateExprConstI16(static_cast<int16>(vA.regValue->primValue.raw64));
+      expr = FEIRBuilder::CreateExprCvtPrim(std::move(expr), PTY_i64);
+      break;
+    }
+    case kDexOpConstWide32: {
+      expr = FEIRBuilder::CreateExprConstI32(static_cast<int32>(vA.regValue->primValue.raw64));
+      expr = FEIRBuilder::CreateExprCvtPrim(std::move(expr), PTY_i64);
+      break;
+    }
+    case kDexOpConstWide: {
+      expr = FEIRBuilder::CreateExprConstI64(static_cast<int64>(vA.regValue->primValue.raw64));
+      break;
+    }
+    case kDexOpConstWideHigh16: {
+      expr = FEIRBuilder::CreateExprConstI16(static_cast<int16>(vA.regValue->primValue.raw64));
+      expr = FEIRBuilder::CreateExprCvtPrim(std::move(expr), PTY_i64);
+      UniqueFEIRExpr exprBit = FEIRBuilder::CreateExprConstI32(48);  // 48 means right-zero-extended to 64 bits
+      expr = FEIRBuilder::CreateExprMathBinary(OP_shl, std::move(expr), std::move(exprBit));
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "Unsupported const-op: %u", opcode);
+      break;
+    }
+  }
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(vATmp.GenFEIRVarReg(), std::move(expr));
+  ans.emplace_back(std::move(stmt));
+  if (!(*vA.regTypeItem == *vATmp.regTypeItem)) {
+    stmt = FEIRBuilder::CreateStmtRetype(vA.GenFEIRVarReg(), vATmp.GenFEIRVarReg());
+    ans.emplace_back(std::move(stmt));
+  }
+  return ans;
+}
+
+// ========== DexOpConstString ==========
+DexOpConstString::DexOpConstString(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn), strValue(allocator.GetMemPool()) {}
+
+void DexOpConstString::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, BCUtil::GetJavaStringNameMplIdx());
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpConstString::SetVBImpl(uint32 num) {
+  vA.dexLitStrIdx = num;
+}
+
+void DexOpConstString::ParseImpl(BCClassMethod &method) {
+  fileIdx = method.GetBCClass().GetBCParser().GetReader()->GetFileIndex();
+  strValue = method.GetBCClass().GetBCParser().GetReader()->GetStringFromIdx(vA.dexLitStrIdx);
+  if (FEOptions::GetInstance().IsRC() && !method.IsRcPermanent() &&
+      ArkAnnotation::GetInstance().IsPermanent(strValue.c_str())) {
+    // "Lcom/huawei/ark/annotation/Permanent;" and "Lark/annotation/Permanent;"
+    // indicates next new-instance / new-array Permanent object
+    method.SetIsRcPermanent(true);
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpConstString::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRVar dstVar = vA.GenFEIRVarReg();
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtJavaConstString>(std::move(dstVar), strValue.c_str(),
+                                                                  fileIdx, vA.dexLitStrIdx);
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpConstClass ==========
+DexOpConstClass::DexOpConstClass(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpConstClass::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, BCUtil::GetJavaClassNameMplIdx());
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpConstClass::SetVBImpl(uint32 num) {
+  dexTypeIdx = num;
+}
+
+void DexOpConstClass::ParseImpl(BCClassMethod &method) {
+  const std::string &typeName = method.GetBCClass().GetBCParser().GetReader()->GetTypeNameFromIdx(dexTypeIdx);
+  const std::string &mplTypeName = namemangler::EncodeName(typeName);
+  mplTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(mplTypeName);
+}
+
+std::list<UniqueFEIRStmt> DexOpConstClass::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRVar dstVar = vA.GenFEIRVarReg();
+  UniqueFEIRType refType = std::make_unique<FEIRTypeDefault>(BCUtil::GetPrimType(mplTypeNameIdx), mplTypeNameIdx);
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprIntrinsicop>(std::move(refType), INTRN_JAVA_CONST_CLASS,
+                                                              std::make_unique<FEIRTypeDefault>(PTY_ref), dexTypeIdx);
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtDAssign>(std::move(dstVar), std::move(expr));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpMonitor ==========
+DexOpMonitor::DexOpMonitor(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpMonitor::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetJavaObjectNameMplIdx(), true);
+  usedRegs.emplace_back(&vA);
+}
+
+std::list<UniqueFEIRStmt> DexOpMonitor::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  std::list<UniqueFEIRExpr> exprs;
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprDRead>(vA.GenFEIRVarReg());
+  exprs.emplace_back(std::move(expr));
+  if (opcode == kDexOpMonitorEnter) {
+    expr = std::make_unique<FEIRExprConst>(static_cast<int64>(2), PTY_i32);
+    exprs.emplace_back(std::move(expr));
+  }
+  UniqueFEIRStmt stmt =
+      std::make_unique<FEIRStmtNary>(opcode == kDexOpMonitorEnter ? OP_syncenter : OP_syncexit, std::move(exprs));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpCheckCast =========
+DexOpCheckCast::DexOpCheckCast(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpCheckCast::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetJavaObjectNameMplIdx(), true);
+  usedRegs.emplace_back(&vA); // use vA to gen vDef
+  vDef.regNum = num;
+  vDef.isDef = true;
+  defedRegs.emplace_back(&vDef);
+}
+
+void DexOpCheckCast::SetVBImpl(uint32 num) {
+  targetDexTypeIdx = num;
+}
+
+void DexOpCheckCast::ParseImpl(BCClassMethod &method) {
+  const std::string &typeName = method.GetBCClass().GetBCParser().GetReader()->GetTypeNameFromIdx(targetDexTypeIdx);
+  targetTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(typeName));
+  vDef.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vDef, targetTypeNameIdx);
+}
+
+std::list<UniqueFEIRStmt> DexOpCheckCast::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  if (vA.GetPrimType() == PTY_i32) {
+    // only null ptr approach here
+    UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtRetype(vDef.GenFEIRVarReg(), vA.GenFEIRVarReg());
+    stmts.emplace_back(std::move(stmt));
+    stmt = FEIRBuilder::CreateStmtJavaCheckCast(vDef.GenFEIRVarReg(), vDef.GenFEIRVarReg(),
+        FEIRBuilder::CreateTypeByJavaName(GlobalTables::GetStrTable().GetStringFromStrIdx(targetTypeNameIdx), true),
+        targetDexTypeIdx);
+    stmts.emplace_back(std::move(stmt));
+  } else {
+    UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtJavaCheckCast(vDef.GenFEIRVarReg(), vA.GenFEIRVarReg(),
+        FEIRBuilder::CreateTypeByJavaName(GlobalTables::GetStrTable().GetStringFromStrIdx(targetTypeNameIdx), true),
+        targetDexTypeIdx);
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+// ========== DexOpInstanceOf =========
+DexOpInstanceOf::DexOpInstanceOf(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpInstanceOf::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, BCUtil::GetBooleanIdx());
+}
+
+void DexOpInstanceOf::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetJavaObjectNameMplIdx(), true);
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpInstanceOf::SetVCImpl(uint32 num) {
+  targetDexTypeIdx = num;
+}
+
+void DexOpInstanceOf::ParseImpl(BCClassMethod &method) {
+  typeName = method.GetBCClass().GetBCParser().GetReader()->GetTypeNameFromIdx(targetDexTypeIdx);
+}
+
+std::list<UniqueFEIRStmt> DexOpInstanceOf::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  const std::string &targetTypeName = namemangler::EncodeName(typeName);
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtJavaInstanceOf(vA.GenFEIRVarReg(), vB.GenFEIRVarReg(),
+                                                              FEIRBuilder::CreateTypeByJavaName(targetTypeName, true),
+                                                              targetDexTypeIdx);
+  stmts.emplace_back(std::move(stmt));
+  typeName.clear();
+  typeName.shrink_to_fit();
+  return stmts;
+}
+
+// ========== DexOpArrayLength =========
+DexOpArrayLength::DexOpArrayLength(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpArrayLength::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, BCUtil::GetIntIdx());
+}
+
+void DexOpArrayLength::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetABooleanIdx(), true);
+  usedRegs.emplace_back(&vB);
+}
+
+std::list<UniqueFEIRStmt> DexOpArrayLength::EmitToFEIRStmtsImpl() {
+  CHECK_FATAL(BCUtil::IsArrayType(vB.regTypeItem->typeNameIdx),
+      "Invalid array type: %s in DexOpArrayLength",
+      GlobalTables::GetStrTable().GetStringFromStrIdx(vB.regTypeItem->typeNameIdx).c_str());
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtArrayLength(vA.GenFEIRVarReg(), vB.GenFEIRVarReg());
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpNewInstance =========
+DexOpNewInstance::DexOpNewInstance(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpNewInstance::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+}
+
+void DexOpNewInstance::SetVBImpl(uint32 num) {
+  vA.dexTypeIdx = num;
+}
+
+void DexOpNewInstance::ParseImpl(BCClassMethod &method) {
+  const std::string &typeName = method.GetBCClass().GetBCParser().GetReader()->GetTypeNameFromIdx(vA.dexTypeIdx);
+  // we should register vA in defs, even if it was new-instance java.lang.String.
+  // Though new-instance java.lang.String would be replaced by StringFactory at following java.lang.String.<init>,
+  // and vA is defed by StringFactory.
+  // In some cases, vA may be used between new-instance and its <init> invokation.
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA,
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(typeName)));
+  defedRegs.emplace_back(&vA);
+  if (method.IsRcPermanent()) {
+    isRcPermanent = true;
+    method.SetIsRcPermanent(false);
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpNewInstance::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  if (isSkipNewString) {
+    return stmts;
+  }
+  std::unique_ptr<FEIRStmtIntrinsicCallAssign> stmtCall = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+      INTRN_JAVA_CLINIT_CHECK, std::make_unique<FEIRTypeDefault>(PTY_ref, vA.regTypeItem->typeNameIdx), nullptr,
+                                                                 vA.dexTypeIdx);
+  stmts.emplace_back(std::move(stmtCall));
+  UniqueFEIRExpr exprJavaNewInstance = FEIRBuilder::CreateExprJavaNewInstance(
+      vA.GenFEIRType(), vA.dexTypeIdx, isRcPermanent);
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(vA.GenFEIRVarReg(), std::move(exprJavaNewInstance));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpNewArray =========
+DexOpNewArray::DexOpNewArray(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpNewArray::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpNewArray::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetIntIdx());
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpNewArray::SetVCImpl(uint32 num) {
+  vA.dexTypeIdx = num;
+}
+
+void DexOpNewArray::ParseImpl(BCClassMethod &method) {
+  const std::string &typeName = method.GetBCClass().GetBCParser().GetReader()->GetTypeNameFromIdx(vA.dexTypeIdx);
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA,
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(typeName)));
+  if (method.IsRcPermanent()) {
+    isRcPermanent = true;
+    method.SetIsRcPermanent(false);
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpNewArray::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRExpr exprSize = FEIRBuilder::CreateExprDRead(vB.GenFEIRVarReg());
+  UniqueFEIRExpr exprJavaNewArray = FEIRBuilder::CreateExprJavaNewArray(vA.GenFEIRType(), std::move(exprSize),
+                                                                        vA.dexTypeIdx, isRcPermanent);
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(vA.GenFEIRVarReg(), std::move(exprJavaNewArray));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpFilledNewArray =========
+DexOpFilledNewArray::DexOpFilledNewArray(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn), argRegs(allocator.Adapter()), vRegs(allocator.Adapter()) {
+  isRange = (opcode == kDexOpFilledNewArrayRange);
+}
+
+void DexOpFilledNewArray::SetVAImpl(uint32 num) {
+  argsSize = num;
+}
+
+void DexOpFilledNewArray::SetVBImpl(uint32 num) {
+  dexArrayTypeIdx = num;
+}
+
+void DexOpFilledNewArray::SetArgsImpl(const MapleList<uint32> &args) {
+  argRegs = args;
+}
+
+GStrIdx DexOpFilledNewArray::GetReturnType() const {
+  return arrayTypeNameIdx;
+}
+
+void DexOpFilledNewArray::ParseImpl(BCClassMethod &method) {
+  const std::string &typeName = method.GetBCClass().GetBCParser().GetReader()->GetTypeNameFromIdx(dexArrayTypeIdx);
+  const std::string &typeNameMpl = namemangler::EncodeName(typeName);
+  arrayTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeNameMpl);
+  const std::string &elemTypeName = GetArrayElementTypeFromArrayType(typeNameMpl);
+  elemTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(elemTypeName);
+  for (uint32 regNum : argRegs) {
+    DexReg reg;
+    reg.regNum = regNum;
+    reg.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(elemTypeNameIdx);
+    vRegs.emplace_back(reg);
+  }
+  for (auto &reg : vRegs) {
+    usedRegs.emplace_back(&reg);
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpFilledNewArray::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  auto exprRegList = std::make_unique<std::list<UniqueFEIRExpr>>();
+  for (auto vReg : vRegs) {
+    UniqueFEIRExpr exprReg = FEIRBuilder::CreateExprDRead(vReg.GenFEIRVarReg());
+    exprRegList->emplace_back(std::move(exprReg));
+  }
+  UniqueFEIRVar var = nullptr;
+  if (HasReturn()) {
+    static_cast<DexOpMoveResult*>(returnInst)->SetVATypeNameIdx(arrayTypeNameIdx);
+    var = static_cast<DexOpMoveResult*>(returnInst)->GetVA().GenFEIRVarReg();
+  } else {
+    return stmts;
+  }
+  const std::string &elemName = GlobalTables::GetStrTable().GetStringFromStrIdx(elemTypeNameIdx);
+  UniqueFEIRType elemType = FEIRTypeHelper::CreateTypeByJavaName(elemName, true, false);
+  std::unique_ptr<FEIRStmtIntrinsicCallAssign> stmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+      INTRN_JAVA_FILL_NEW_ARRAY, std::move(elemType), std::move(var), std::move(exprRegList));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpFillArrayData =========
+DexOpFillArrayData::DexOpFillArrayData(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpFillArrayData::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetVoidIdx(), true);
+  usedRegs.emplace_back(&vA);
+}
+
+void DexOpFillArrayData::SetVBImpl(uint32 num) {
+  offset = static_cast<int32>(num); // signed value in unsigned data buffer
+}
+
+void DexOpFillArrayData::ParseImpl(BCClassMethod &method) {
+  const uint16 *data = method.GetInstPos() + pc + offset;
+  size = *(reinterpret_cast<const uint32*>(&data[2]));
+  arrayData = reinterpret_cast<const int8*>(&data[4]);
+}
+
+std::list<UniqueFEIRStmt> DexOpFillArrayData::EmitToFEIRStmtsImpl() {
+  CHECK_FATAL(BCUtil::IsArrayType(vA.regTypeItem->typeNameIdx),
+      "Invalid array type: %s in DexOpFillArrayData",
+      GlobalTables::GetStrTable().GetStringFromStrIdx(vA.regTypeItem->typeNameIdx).c_str());
+  std::list<UniqueFEIRStmt> stmts;
+  thread_local static std::stringstream ss("");
+  ss.str("");
+  ss << "const_array_" << funcNameIdx << "_" << pc;
+  UniqueFEIRVar arrayReg = vA.GenFEIRVarReg();
+  const std::string &arrayTypeName = GlobalTables::GetStrTable().GetStringFromStrIdx(vA.regTypeItem->typeNameIdx);
+  CHECK_FATAL(arrayTypeName.size() > 1 && arrayTypeName.at(0) == 'A' &&
+      BCUtil::IsJavaPrimitveType(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(arrayTypeName.substr(1))),
+      "Invalid type %s", arrayTypeName.c_str());
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtJavaFillArrayData(std::move(arrayReg), arrayData, size, ss.str());
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpThrow =========
+DexOpThrow::DexOpThrow(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpThrow::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetJavaThrowableNameMplIdx(), true);
+  usedRegs.emplace_back(&vA);
+}
+
+std::list<UniqueFEIRStmt> DexOpThrow::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  if (BCUtil::IsJavaReferenceType(vA.regTypeItem->typeNameIdx)) {
+    UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(vA.GenFEIRVarReg());
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtUseOnly>(OP_throw, std::move(expr));
+    stmts.emplace_back(std::move(stmt));
+  } else {
+    CHECK_FATAL(vA.regValue != nullptr && vA.regValue->primValue.raw32 == 0, "only null or ref can be thrown.");
+    DexReg vAtmp;
+    vAtmp.regNum = vA.regNum;
+    vAtmp.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vAtmp, BCUtil::GetJavaThrowableNameMplIdx());
+    UniqueFEIRStmt retypeStmt = FEIRBuilder::CreateStmtRetype(vAtmp.GenFEIRVarReg(), vA.GenFEIRVarReg());
+    stmts.emplace_back(std::move(retypeStmt));
+    UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(vAtmp.GenFEIRVarReg());
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtUseOnly>(OP_throw, std::move(expr));
+    stmts.emplace_back(std::move(stmt));
+  }
+  return stmts;
+}
+
+// ========== DexOpGoto =========
+DexOpGoto::DexOpGoto(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpGoto::SetVAImpl(uint32 num) {
+  offset = static_cast<int32>(num);
+}
+
+std::vector<uint32> DexOpGoto::GetTargetsImpl() const {
+  std::vector<uint32> res;
+  res.emplace_back(static_cast<uint32>(offset + pc));
+  return res;
+}
+
+void DexOpGoto::ParseImpl(BCClassMethod &method) {
+  (void) method;
+  target = static_cast<uint32>(offset + pc);
+}
+
+std::list<UniqueFEIRStmt> DexOpGoto::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtGoto2>(funcNameIdx, target);
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpSwitch =========
+DexOpSwitch::DexOpSwitch(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn), keyTargetOPpcMap(allocator.Adapter()) {
+  isPacked = (opcode == kDexOpPackedSwitch);
+}
+
+void DexOpSwitch::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetIntIdx());
+  usedRegs.emplace_back(&vA);
+}
+
+void DexOpSwitch::SetVBImpl(uint32 num) {
+  offset = static_cast<int32>(num);
+}
+
+void DexOpSwitch::ParseImpl(BCClassMethod &method) {
+  const uint16 *data = method.GetInstPos() + pc + offset;
+  if (isPacked) {
+    uint16 size = data[1];
+    int32 key = *(reinterpret_cast<const int32*>(&data[2]));
+    const int32 *targets = reinterpret_cast<const int32*>(&data[4]);
+    for (uint16 i = 0; i < size; i++) {
+      uint32 target = static_cast<uint32>(pc + targets[i]);
+      keyTargetOPpcMap.emplace(key, std::make_pair(target, pc));
+      key = key + 1;
+    }
+  } else {
+    uint16 size = data[1];
+    const int32 *keys = reinterpret_cast<const int32*>(&data[2]);
+    const int32 *targets = reinterpret_cast<const int32*>(&data[2 + size * 2]);
+    for (uint16 i = 0; i < size; i++) {
+      int32 key = keys[i];
+      uint32 target = static_cast<uint32>(pc + targets[i]);
+      keyTargetOPpcMap.emplace(key, std::make_pair(target, pc));
+    }
+  }
+}
+
+std::vector<uint32> DexOpSwitch::GetTargetsImpl() const {
+  std::vector<uint32> res;
+  for (const auto &elem : keyTargetOPpcMap) {
+    res.emplace_back(elem.second.first);
+  }
+  return res;
+}
+
+std::list<UniqueFEIRStmt> DexOpSwitch::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprDRead>(vA.GenFEIRVarReg());
+  std::unique_ptr<FEIRStmtSwitch2> stmt = std::make_unique<FEIRStmtSwitch2>(funcNameIdx, std::move(expr));
+  if (defaultTarget == nullptr) {
+    stmt->SetDefaultLabelIdx(UINT32_MAX);  // no default target, switch is the last instruction of the file
+  } else {
+    stmt->SetDefaultLabelIdx(defaultTarget->GetPC());
+  }
+  for (auto &e : keyTargetOPpcMap) {
+    stmt->AddTarget(e.first, e.second.first);
+  }
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpCompare =========
+DexOpCompare::DexOpCompare(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+void DexOpCompare::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, BCUtil::GetIntIdx());
+}
+
+void DexOpCompare::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  GStrIdx typeNameIdx;
+  if (opcode == kDexOpCmplFloat || opcode == kDexOpCmpgFloat) {
+    typeNameIdx = BCUtil::GetFloatIdx();
+  } else if (opcode == kDexOpCmplDouble || opcode == kDexOpCmpgDouble) {
+    typeNameIdx = BCUtil::GetDoubleIdx();
+  } else {
+    // kDexOpCmpLong
+    typeNameIdx = BCUtil::GetLongIdx();
+  }
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(typeNameIdx);
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpCompare::SetVCImpl(uint32 num) {
+  vC = vB;
+  vC.regNum = num;
+  vC.regTypeItem = vB.regTypeItem;
+  usedRegs.emplace_back(&vC);
+}
+
+Opcode DexOpCompare::GetOpcodeFromDexIns() const {
+  auto mirOp = dexOpCmp2MIROp.find(opcode);
+  CHECK_FATAL(mirOp != dexOpCmp2MIROp.end(), "Invalid opcode: 0x%x in dexOpCmp2MIROp", opcode);
+  return mirOp->second;
+}
+
+std::list<UniqueFEIRStmt> DexOpCompare::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRExpr cmpExpr =
+      FEIRBuilder::CreateExprMathBinary(GetOpcodeFromDexIns(), vB.GenFEIRVarReg(), vC.GenFEIRVarReg());
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(vA.GenFEIRVarReg(), std::move(cmpExpr));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpIfTest =========
+DexOpIfTest::DexOpIfTest(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpIfTest::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetIntIdx(), true);
+  usedRegs.emplace_back(&vA);
+}
+
+void DexOpIfTest::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetIntIdx(), true);
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpIfTest::SetVCImpl(uint32 num) {
+  offset = static_cast<int32>(num);
+}
+
+std::vector<uint32> DexOpIfTest::GetTargetsImpl() const {
+  std::vector<uint32> res;
+  res.emplace_back(static_cast<uint32>(offset + pc));
+  return res;
+}
+
+void DexOpIfTest::ParseImpl(BCClassMethod &method) {
+  (void) method;
+  target = static_cast<uint32>(offset + pc);
+}
+
+std::list<UniqueFEIRStmt> DexOpIfTest::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  DexReg vATmp;
+  DexReg vBTmp;
+  vATmp = vA;
+  vBTmp = vB;
+  // opnd of if-test should be same PTY type.
+  // Or one opnd must be nullptr, such as const 0.
+  if (vA.GetPrimType() == PTY_ref && vB.GetPrimType() != PTY_ref) {
+    CHECK_FATAL(vB.regValue != nullptr && vB.regValue->primValue.raw32 == 0,
+        "Cannot compare a ref var with an integer.");
+    vBTmp.regTypeItem = vATmp.regTypeItem;
+    UniqueFEIRStmt retypeStmt = FEIRBuilder::CreateStmtRetype(vBTmp.GenFEIRVarReg(), vB.GenFEIRVarReg());
+    stmts.emplace_back(std::move(retypeStmt));
+  } else if (vA.GetPrimType() != PTY_ref && vB.GetPrimType() == PTY_ref) {
+    CHECK_FATAL(vA.regValue != nullptr && vA.regValue->primValue.raw32 == 0,
+        "Cannot compare a ref var with an integer.");
+    vATmp.regTypeItem = vBTmp.regTypeItem;
+    UniqueFEIRStmt retypeStmt = FEIRBuilder::CreateStmtRetype(vATmp.GenFEIRVarReg(), vA.GenFEIRVarReg());
+    stmts.emplace_back(std::move(retypeStmt));
+  }
+  UniqueFEIRExpr exprA = std::make_unique<FEIRExprDRead>(vATmp.GenFEIRVarReg());
+  UniqueFEIRExpr exprB = std::make_unique<FEIRExprDRead>(vBTmp.GenFEIRVarReg());
+  auto itor = dexOpConditionOp2MIROp.find(static_cast<DexOpCode>(opcode));
+  CHECK_FATAL(itor != dexOpConditionOp2MIROp.end(), "Invalid opcode: %u in DexOpIfTest", opcode);
+  // All primitive var should be compared in i32.
+  if (vATmp.GetPrimType() != PTY_ref) {
+    if (vATmp.GetPrimType() != PTY_i32) {
+      exprA = std::make_unique<FEIRExprTypeCvt>(std::make_unique<FEIRTypeDefault>(PTY_i32, BCUtil::GetIntIdx()),
+                                                OP_cvt, std::move(exprA));
+    }
+    if (vBTmp.GetPrimType() != PTY_i32) {
+      exprB = std::make_unique<FEIRExprTypeCvt>(std::make_unique<FEIRTypeDefault>(PTY_i32, BCUtil::GetIntIdx()),
+                                                OP_cvt, std::move(exprB));
+    }
+  }
+  std::unique_ptr<FEIRExprBinary> expr =
+      std::make_unique<FEIRExprBinary>(itor->second, std::move(exprA), std::move(exprB));
+  UniqueFEIRStmt stmt =
+      std::make_unique<FEIRStmtCondGoto2>(OP_brtrue, funcNameIdx, target, std::move(expr));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpIfTestZ =========
+DexOpIfTestZ::DexOpIfTestZ(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpIfTestZ::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetIntIdx(), true);
+  usedRegs.emplace_back(&vA);
+}
+
+void DexOpIfTestZ::SetVBImpl(uint32 num) {
+  offset = static_cast<int32>(num);
+}
+
+std::vector<uint32> DexOpIfTestZ::GetTargetsImpl() const {
+  std::vector<uint32> res;
+  res.emplace_back(static_cast<uint32>(offset + pc));
+  return res;
+}
+
+void DexOpIfTestZ::ParseImpl(BCClassMethod &method) {
+  (void) method;
+  target = static_cast<uint32>(offset + pc);
+}
+
+std::list<UniqueFEIRStmt> DexOpIfTestZ::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRStmt stmt = nullptr;
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(vA.GenFEIRVarReg());
+  if (vA.GetPrimType() == PTY_u1 && opcode == kDexOpIfEqZ) {
+    stmt = std::make_unique<FEIRStmtCondGoto2>(OP_brfalse, funcNameIdx, target, std::move(expr));
+  } else if (vA.GetPrimType() == PTY_u1 && opcode == kDexOpIfNeZ) {
+    stmt = std::make_unique<FEIRStmtCondGoto2>(OP_brtrue, funcNameIdx, target, std::move(expr));
+  } else {
+    UniqueFEIRExpr constExpr = std::make_unique<FEIRExprConst>(static_cast<int64>(0), vA.GetPrimType());
+    auto itor = dexOpConditionOp2MIROp.find(static_cast<DexOpCode>(opcode));
+    CHECK_FATAL(itor != dexOpConditionOp2MIROp.end(), "Invalid opcode: %u in DexOpIfTestZ", opcode);
+    expr = FEIRBuilder::CreateExprMathBinary(itor->second, std::move(expr), std::move(constExpr));
+    stmt = std::make_unique<FEIRStmtCondGoto2>(OP_brtrue, funcNameIdx, target, std::move(expr));
+  }
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpUnused =========
+DexOpUnused::DexOpUnused(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+// ========== DexOpAget =========
+DexOpAget::DexOpAget(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpAget::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpAget::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpAget::SetVCImpl(uint32 num) {
+  vC.regNum = num;
+  vC.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetIntIdx());
+  usedRegs.emplace_front(&vC);
+}
+
+void DexOpAget::ParseImpl(BCClassMethod &method) {
+  (void) method;
+  GStrIdx elemTypeNameIdx;
+  GStrIdx usedTypeNameIdx;
+  bool isIndeterminateType = false;
+  switch (opcode) {
+    case kDexOpAget: {
+      // int or float
+      elemTypeNameIdx = BCUtil::GetIntIdx();
+      usedTypeNameIdx = BCUtil::GetAIntIdx();
+      isIndeterminateType = true;
+      break;
+    }
+    case kDexOpAgetWide: {
+      elemTypeNameIdx = BCUtil::GetLongIdx();
+      usedTypeNameIdx = BCUtil::GetALongIdx();
+      isIndeterminateType = true;
+      break;
+    }
+    case kDexOpAgetObject: {
+      elemTypeNameIdx = BCUtil::GetJavaObjectNameMplIdx();
+      usedTypeNameIdx = BCUtil::GetAJavaObjectNameMplIdx();
+      isIndeterminateType = true;
+      break;
+    }
+    case kDexOpAgetBoolean: {
+      elemTypeNameIdx = BCUtil::GetBooleanIdx();
+      usedTypeNameIdx = BCUtil::GetABooleanIdx();
+      break;
+    }
+    case kDexOpAgetByte: {
+      elemTypeNameIdx = BCUtil::GetByteIdx();
+      usedTypeNameIdx = BCUtil::GetAByteIdx();
+      break;
+    }
+    case kDexOpAgetChar: {
+      elemTypeNameIdx = BCUtil::GetCharIdx();
+      usedTypeNameIdx = BCUtil::GetACharIdx();
+      break;
+    }
+    case kDexOpAgetShort: {
+      elemTypeNameIdx = BCUtil::GetShortIdx();
+      usedTypeNameIdx = BCUtil::GetAShortIdx();
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "Invalid opcode : 0x%x in DexOpAget", opcode);
+      break;
+    }
+  }
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, elemTypeNameIdx, isIndeterminateType);
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(usedTypeNameIdx, isIndeterminateType);
+}
+
+void DexOpAget::SetRegTypeInTypeInferImpl() {
+  if (vB.regType != nullptr && vC.regType != nullptr) {
+    vB.regType->AddElemType(vA.regTypeItem);
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpAget::EmitToFEIRStmtsImpl() {
+  DexReg vAtmp;
+  vAtmp.regNum = vA.regNum;
+  const std::string arrayTypeName = GlobalTables::GetStrTable().GetStringFromStrIdx(vB.regTypeItem->typeNameIdx);
+  if (arrayTypeName.size() > 1 && arrayTypeName.at(0) == 'A') {
+    vAtmp.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(arrayTypeName.substr(1)));
+  } else {
+    CHECK_FATAL(false, "Invalid array type %s", arrayTypeName.c_str());
+  }
+  std::list<UniqueFEIRStmt> stmts = FEIRBuilder::CreateStmtArrayLoad(vAtmp.GenFEIRVarReg(), vB.GenFEIRVarReg(),
+                                                                     vC.GenFEIRVarReg());
+
+  if (!((*vAtmp.regTypeItem) == (*vA.regTypeItem))) {
+    UniqueFEIRStmt retypeStmt =
+        FEIRBuilder::CreateStmtRetype(vA.GenFEIRVarReg(), vAtmp.GenFEIRVarReg());
+    stmts.emplace_back(std::move(retypeStmt));
+  }
+  return stmts;
+}
+
+// ========== DexOpAput =========
+DexOpAput::DexOpAput(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpAput::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  usedRegs.emplace_back(&vA);
+}
+
+void DexOpAput::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpAput::SetVCImpl(uint32 num) {
+  vC.regNum = num;
+  vC.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetIntIdx());
+  usedRegs.emplace_back(&vC);
+}
+
+void DexOpAput::ParseImpl(BCClassMethod &method) {
+  (void) method;
+  GStrIdx elemTypeNameIdx;
+  GStrIdx usedTypeNameIdx;
+  bool isIndeterminate = false;
+  switch (opcode) {
+    case kDexOpAput: {
+      // Int or float
+      elemTypeNameIdx = BCUtil::GetIntIdx();
+      usedTypeNameIdx = BCUtil::GetAIntIdx();
+      isIndeterminate = true;
+      break;
+    }
+    case kDexOpAputWide: {
+      elemTypeNameIdx = BCUtil::GetLongIdx();
+      usedTypeNameIdx = BCUtil::GetALongIdx();
+      isIndeterminate = true;
+      break;
+    }
+    case kDexOpAputObject: {
+      elemTypeNameIdx = BCUtil::GetJavaObjectNameMplIdx();
+      usedTypeNameIdx = BCUtil::GetAJavaObjectNameMplIdx();
+      isIndeterminate = true;
+      break;
+    }
+    case kDexOpAputBoolean: {
+      elemTypeNameIdx = BCUtil::GetBooleanIdx();
+      usedTypeNameIdx = BCUtil::GetABooleanIdx();
+      break;
+    }
+    case kDexOpAputByte: {
+      elemTypeNameIdx = BCUtil::GetByteIdx();
+      usedTypeNameIdx = BCUtil::GetAByteIdx();
+      break;
+    }
+    case kDexOpAputChar: {
+      elemTypeNameIdx = BCUtil::GetCharIdx();
+      usedTypeNameIdx = BCUtil::GetACharIdx();
+      break;
+    }
+    case kDexOpAputShort: {
+      elemTypeNameIdx = BCUtil::GetShortIdx();
+      usedTypeNameIdx = BCUtil::GetAShortIdx();
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "Invalid opcode : 0x%x in DexOpAput", opcode);
+      break;
+    }
+  }
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(elemTypeNameIdx, isIndeterminate);
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(usedTypeNameIdx, isIndeterminate);
+}
+
+void DexOpAput::SetRegTypeInTypeInferImpl() {
+  if (vA.regType != nullptr && vB.regType != nullptr && vC.regType != nullptr) {
+    vB.regType->AddElemType(vA.regTypeItem);
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpAput::EmitToFEIRStmtsImpl() {
+  DexReg vAtmp;
+  vAtmp.regNum = vA.regNum;
+  const std::string &arrayTypeName = GlobalTables::GetStrTable().GetStringFromStrIdx(vB.regTypeItem->typeNameIdx);
+  if (arrayTypeName.size() > 1 && arrayTypeName.at(0) == 'A') {
+    vAtmp.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(arrayTypeName.substr(1)));
+  } else {
+    CHECK_FATAL(false, "Invalid array type %s", arrayTypeName.c_str());
+  }
+  std::list<UniqueFEIRStmt> stmts = FEIRBuilder::CreateStmtArrayStore(vAtmp.GenFEIRVarReg(), vB.GenFEIRVarReg(),
+                                                                      vC.GenFEIRVarReg());
+  if (!((*vAtmp.regTypeItem) == (*vA.regTypeItem))) {
+    UniqueFEIRStmt retypeStmt =
+        FEIRBuilder::CreateStmtRetype(vAtmp.GenFEIRVarReg(), vA.GenFEIRVarReg());
+    stmts.emplace_front(std::move(retypeStmt));
+  }
+  return stmts;
+}
+
+// ========== DexOpIget =========
+DexOpIget::DexOpIget(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpIget::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpIget::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpIget::SetVCImpl(uint32 num) {
+  index = num;
+}
+
+void DexOpIget::ParseImpl(BCClassMethod &method) {
+  BCReader::ClassElem field = method.GetBCClass().GetBCParser().GetReader()->GetClassFieldFromIdx(index);
+  uint64 mapIdx = (static_cast<uint64>(method.GetBCClass().GetBCParser().GetReader()->GetFileIndex()) << 32) | index;
+  structElemNameIdx = FEManager::GetManager().GetFieldStructElemNameIdx(mapIdx);
+  if (structElemNameIdx == nullptr) {
+    structElemNameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(
+        field.className, field.elemName, field.typeName);
+    FEManager::GetManager().SetFieldStructElemNameIdx(mapIdx, *structElemNameIdx);
+  }
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, structElemNameIdx->type);
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(structElemNameIdx->klass);
+}
+
+std::list<UniqueFEIRStmt> DexOpIget::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  FEStructFieldInfo *fieldInfo = static_cast<FEStructFieldInfo*>(
+      FEManager::GetTypeManager().RegisterStructFieldInfo(*structElemNameIdx, kSrcLangJava, false));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtFieldLoad>(vB.GenFEIRVarReg(), vA.GenFEIRVarReg(), *fieldInfo, false);
+  stmts.push_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpIput =========
+DexOpIput::DexOpIput(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpIput::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  usedRegs.emplace_back(&vA);
+}
+
+void DexOpIput::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpIput::SetVCImpl(uint32 num) {
+  index = num;
+}
+
+void DexOpIput::ParseImpl(BCClassMethod &method) {
+  BCReader::ClassElem field = method.GetBCClass().GetBCParser().GetReader()->GetClassFieldFromIdx(index);
+  uint64 mapIdx = (static_cast<uint64>(method.GetBCClass().GetBCParser().GetReader()->GetFileIndex()) << 32) | index;
+  structElemNameIdx = FEManager::GetManager().GetFieldStructElemNameIdx(mapIdx);
+  if (structElemNameIdx == nullptr) {
+    structElemNameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(
+        field.className, field.elemName, field.typeName);
+    FEManager::GetManager().SetFieldStructElemNameIdx(mapIdx, *structElemNameIdx);
+  }
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(structElemNameIdx->type);
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(structElemNameIdx->klass);
+}
+
+std::list<UniqueFEIRStmt> DexOpIput::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  FEStructFieldInfo *fieldInfo = static_cast<FEStructFieldInfo*>(
+      FEManager::GetTypeManager().RegisterStructFieldInfo(*structElemNameIdx, kSrcLangJava, false));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtFieldStore>(vB.GenFEIRVarReg(), vA.GenFEIRVarReg(), *fieldInfo, false);
+  stmts.push_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpSget =========
+DexOpSget::DexOpSget(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpSget::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpSget::SetVBImpl(uint32 num) {
+  index = num;
+}
+
+void DexOpSget::ParseImpl(BCClassMethod &method) {
+  BCReader::ClassElem field = method.GetBCClass().GetBCParser().GetReader()->GetClassFieldFromIdx(index);
+  uint64 mapIdx = (static_cast<uint64>(method.GetBCClass().GetBCParser().GetReader()->GetFileIndex()) << 32) | index;
+  structElemNameIdx = FEManager::GetManager().GetFieldStructElemNameIdx(mapIdx);
+  if (structElemNameIdx == nullptr) {
+    structElemNameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(
+        field.className, field.elemName, field.typeName);
+    FEManager::GetManager().SetFieldStructElemNameIdx(mapIdx, *structElemNameIdx);
+  }
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, structElemNameIdx->type);
+  dexFileHashCode = method.GetBCClass().GetBCParser().GetFileNameHashId();
+}
+
+std::list<UniqueFEIRStmt> DexOpSget::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> ans;
+  FEStructFieldInfo *fieldInfo = static_cast<FEStructFieldInfo*>(
+      FEManager::GetTypeManager().RegisterStructFieldInfo(*structElemNameIdx, kSrcLangJava, true));
+  CHECK_NULL_FATAL(fieldInfo);
+  fieldInfo->SetFieldID(index);
+  UniqueFEIRVar var = vA.GenFEIRVarReg();
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtFieldLoad>(nullptr, std::move(var), *fieldInfo, true, dexFileHashCode);
+  ans.emplace_back(std::move(stmt));
+  return ans;
+}
+
+// ========== DexOpSput =========
+DexOpSput::DexOpSput(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpSput::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  usedRegs.emplace_back(&vA);
+}
+
+void DexOpSput::SetVBImpl(uint32 num) {
+  index = num;
+}
+
+void DexOpSput::ParseImpl(BCClassMethod &method) {
+  BCReader::ClassElem field = method.GetBCClass().GetBCParser().GetReader()->GetClassFieldFromIdx(index);
+  uint64 mapIdx = (static_cast<uint64>(method.GetBCClass().GetBCParser().GetReader()->GetFileIndex()) << 32) | index;
+  structElemNameIdx = FEManager::GetManager().GetFieldStructElemNameIdx(mapIdx);
+  if (structElemNameIdx == nullptr) {
+    structElemNameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(
+        field.className, field.elemName, field.typeName);
+    FEManager::GetManager().SetFieldStructElemNameIdx(mapIdx, *structElemNameIdx);
+  }
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(structElemNameIdx->type);
+  dexFileHashCode = method.GetBCClass().GetBCParser().GetFileNameHashId();
+}
+
+std::list<UniqueFEIRStmt> DexOpSput::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  FEStructFieldInfo *fieldInfo = static_cast<FEStructFieldInfo*>(
+      FEManager::GetTypeManager().RegisterStructFieldInfo(*structElemNameIdx, kSrcLangJava, true));
+  CHECK_NULL_FATAL(fieldInfo);
+  UniqueFEIRVar var = vA.GenFEIRVarReg();
+  fieldInfo->SetFieldID(index);
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtFieldStore>(nullptr, std::move(var), *fieldInfo, true,
+                                                             dexFileHashCode);
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpInvoke =========
+DexOpInvoke::DexOpInvoke(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn), argRegs(allocator.Adapter()), argVRegs(allocator.Adapter()) {}
+
+std::string DexOpInvoke::GetReturnType() const {
+  CHECK_FATAL(!retArgsTypeNames.empty(), "Should parse DexOpInvoke first for retrieving signature.");
+  return retArgsTypeNames[0];
+}
+
+void DexOpInvoke::SetVAImpl(uint32 num) {
+  argSize = num;
+}
+
+void DexOpInvoke::SetVBImpl(uint32 num) {
+  methodIdx = num;
+}
+
+void DexOpInvoke::SetVCImpl(uint32 num) {
+  arg0VRegNum = num;
+}
+
+void DexOpInvoke::SetArgsImpl(const MapleList<uint32> &args) {
+  argRegs = args;
+}
+
+bool DexOpInvoke::ReplaceStringFactory(BCReader::ClassElem &methodInfo, MapleList<uint32> &argRegNums) {
+  const std::string &fullName = methodInfo.className + "|" + methodInfo.elemName + "|" + methodInfo.typeName;
+  if (!DexStrFactory::IsStringInit(fullName)) {
+    return false;
+  }
+  isStringFactory = true;
+  std::string strFacCalleeName = DexStrFactory::GetStringFactoryFuncname(fullName);
+  CHECK_FATAL(!strFacCalleeName.empty(), "Can not find string factory call for %s", fullName.c_str());
+  std::vector<std::string> names = FEUtils::Split(strFacCalleeName, '|');
+  // 3 parts: ClassName|ElemName|Signature
+  CHECK_FATAL(names.size() == 3, "Invalid funcname %s", strFacCalleeName.c_str());
+  methodInfo.className = names.at(0);
+  methodInfo.elemName = names.at(1);
+  methodInfo.typeName = names.at(2);
+  // push this as return
+  retReg.regNum = argRegNums.front();
+  retReg.isDef = true;
+  argRegNums.pop_front();
+  retReg.regType = allocator.GetMemPool()->New<BCRegType>(allocator, retReg, BCUtil::GetJavaStringNameMplIdx());
+  defedRegs.emplace_back(&retReg);
+  return true;
+}
+
+void DexOpInvoke::ParseImpl(BCClassMethod &method) {
+  MapleList<uint32> &argRegNums = argRegs;
+  uint64 mapIdx = (static_cast<uint64>(method.GetBCClass().GetBCParser().GetReader()->GetFileIndex()) << 32) |
+      methodIdx;
+  BCReader::ClassElem methodInfo = method.GetBCClass().GetBCParser().GetReader()->GetClassMethodFromIdx(methodIdx);
+  // for string factory, the highest bit for string factory flag
+  if (ReplaceStringFactory(methodInfo, argRegNums)) {
+    mapIdx = mapIdx | 0x8000000000000000;
+  }
+  structElemNameIdx = FEManager::GetManager().GetMethodStructElemNameIdx(mapIdx);
+  if (structElemNameIdx == nullptr) {
+    structElemNameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(
+        methodInfo.className, methodInfo.elemName, methodInfo.typeName);
+    FEManager::GetManager().SetMethodStructElemNameIdx(mapIdx, *structElemNameIdx);
+  }
+  retArgsTypeNames = FEUtilJava::SolveMethodSignature(methodInfo.typeName);
+  DexReg reg;
+  if (!IsStatic()) {
+    reg.regNum = argRegNums.front();
+    argRegNums.pop_front();
+    reg.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(structElemNameIdx->klass);
+    argVRegs.emplace_back(reg);
+  }
+  for (size_t i = 1; i < retArgsTypeNames.size(); ++i) {
+    reg.regNum = argRegNums.front();
+    argRegNums.pop_front();
+    GStrIdx usedTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName(retArgsTypeNames[i]));
+    if (BCUtil::IsWideType(usedTypeNameIdx)) {
+      argRegNums.pop_front();  // next regNum is consumed by wide type(long, double)
+    }
+    reg.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(usedTypeNameIdx);
+    argVRegs.emplace_back(reg);
+  }
+  for (auto &vReg : argVRegs) {
+    usedRegs.emplace_back(&vReg);
+  }
+}
+
+void DexOpInvoke::PrepareInvokeParametersAndReturn(const FEStructMethodInfo &feMethodInfo,
+                                                   FEIRStmtCallAssign &stmt) const {
+  const MapleVector<FEIRType*> &argTypes = feMethodInfo.GetArgTypes();
+  for (size_t i = argTypes.size(); i > 0; --i) {
+    UniqueFEIRVar var = argVRegs[i - 1 + (IsStatic() ? 0 : 1)].GenFEIRVarReg();
+    UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(var));
+    stmt.AddExprArgReverse(std::move(expr));
+  }
+  if (!IsStatic()) {
+    // push this
+    UniqueFEIRVar var = argVRegs[0].GenFEIRVarReg();
+    UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(var));
+    stmt.AddExprArgReverse(std::move(expr));
+  }
+  if (HasReturn()) {
+    static_cast<DexOpMoveResult*>(returnInst)->SetVATypeNameIdx(
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(retArgsTypeNames.at(0))));
+    UniqueFEIRVar var = static_cast<DexOpMoveResult*>(returnInst)->GetVA().GenFEIRVarReg();
+    stmt.SetVar(std::move(var));
+  }
+  if (isStringFactory) {
+    stmt.SetVar(retReg.GenFEIRVarReg());
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpInvoke::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRStmt stmt;
+  FEStructMethodInfo *info = static_cast<FEStructMethodInfo*>(
+      FEManager::GetTypeManager().RegisterStructMethodInfo(*structElemNameIdx, kSrcLangJava, IsStatic()));
+  auto itor = dexOpInvokeOp2MIROp.find(static_cast<DexOpCode>(opcode));
+  CHECK_FATAL(itor != dexOpInvokeOp2MIROp.end(), "Unsupport opcode: 0x%x in DexOpInvoke", opcode);
+  stmt = std::make_unique<FEIRStmtCallAssign>(*info, itor->second, nullptr, IsStatic());
+  FEIRStmtCallAssign *ptrStmt = static_cast<FEIRStmtCallAssign*>(stmt.get());
+  PrepareInvokeParametersAndReturn(*info, *ptrStmt);
+  ans.emplace_back(std::move(stmt));
+  retArgsTypeNames.clear();
+  retArgsTypeNames.shrink_to_fit();
+  return ans;
+}
+
+bool DexOpInvoke::IsStatic() const {
+  return opcode == kDexOpInvokeStatic || opcode == kDexOpInvokeStaticRange || isStringFactory;
+}
+
+// ========== DexOpInvokeVirtual =========
+DexOpInvokeVirtual::DexOpInvokeVirtual(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOpInvoke(allocatorIn, pcIn, opcodeIn) {}
+
+// ========== DexOpInvokeSuper =========
+DexOpInvokeSuper::DexOpInvokeSuper(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOpInvoke(allocatorIn, pcIn, opcodeIn) {}
+
+// ========== DexOpInvokeDirect =========
+DexOpInvokeDirect::DexOpInvokeDirect(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOpInvoke(allocatorIn, pcIn, opcodeIn) {}
+
+// ========== DexOpInvokeStatic =========
+DexOpInvokeStatic::DexOpInvokeStatic(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOpInvoke(allocatorIn, pcIn, opcodeIn) {}
+
+// ========== DexOpInvokeInterface =========
+DexOpInvokeInterface::DexOpInvokeInterface(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOpInvoke(allocatorIn, pcIn, opcodeIn) {}
+
+// ========== DexOpUnaryOp =========
+DexOpUnaryOp::DexOpUnaryOp(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpUnaryOp::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+  auto it = GetOpcodeMapForUnary().find(opcode);
+  CHECK_FATAL(it != GetOpcodeMapForUnary().end(), "Invalid opcode: %u in DexOpUnaryOp", opcode);
+  mirOp = std::get<0>(it->second);
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, std::get<1>(it->second));
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(std::get<2>(it->second));
+}
+
+void DexOpUnaryOp::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  // vB's type is set in SetVAImpl
+  usedRegs.emplace_back(&vB);
+}
+
+std::list<UniqueFEIRStmt> DexOpUnaryOp::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRExpr exprDread = FEIRBuilder::CreateExprDRead(vB.GenFEIRVarReg());
+  UniqueFEIRExpr experUnary = nullptr;
+  switch (mirOp) {
+    case OP_cvt:
+      experUnary = FEIRBuilder::CreateExprCvtPrim(std::move(exprDread), vA.GetPrimType());
+      break;
+    case OP_sext:
+      experUnary = FEIRBuilder::CreateExprSExt(std::move(exprDread), vA.GetPrimType());
+      break;
+    case OP_zext:
+      experUnary = FEIRBuilder::CreateExprZExt(std::move(exprDread), vA.GetPrimType());
+      break;
+    case OP_neg:
+    case OP_bnot:
+      experUnary = FEIRBuilder::CreateExprMathUnary(mirOp, std::move(exprDread));
+      break;
+    default:
+      CHECK_FATAL(false, "Invalid mir opcode: %u in DexOpUnaryOp", mirOp);
+      break;
+  }
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(vA.GenFEIRVarReg(), std::move(experUnary));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+std::map<uint8, std::tuple<Opcode, GStrIdx, GStrIdx>> DexOpUnaryOp::InitOpcodeMapForUnary() {
+  std::map<uint8, std::tuple<Opcode, GStrIdx, GStrIdx>> ans;
+  ans[kDexOpIntToLong] = std::make_tuple(OP_cvt, BCUtil::GetLongIdx(), BCUtil::GetIntIdx());
+  ans[kDexOpIntToFloat] = std::make_tuple(OP_cvt, BCUtil::GetFloatIdx(), BCUtil::GetIntIdx());
+  ans[kDexOpIntToDouble] = std::make_tuple(OP_cvt, BCUtil::GetDoubleIdx(), BCUtil::GetIntIdx());
+  ans[kDexOpLongToInt] = std::make_tuple(OP_cvt, BCUtil::GetIntIdx(), BCUtil::GetLongIdx());
+  ans[kDexOpLongToFloat] = std::make_tuple(OP_cvt, BCUtil::GetFloatIdx(), BCUtil::GetLongIdx());
+  ans[kDexOpLongToDouble] = std::make_tuple(OP_cvt, BCUtil::GetDoubleIdx(), BCUtil::GetLongIdx());
+  ans[kDexOpFloatToInt] = std::make_tuple(OP_cvt, BCUtil::GetIntIdx(), BCUtil::GetFloatIdx());
+  ans[kDexOpFloatToLong] = std::make_tuple(OP_cvt, BCUtil::GetLongIdx(), BCUtil::GetFloatIdx());
+  ans[kDexOpFloatToDouble] = std::make_tuple(OP_cvt, BCUtil::GetDoubleIdx(), BCUtil::GetFloatIdx());
+  ans[kDexOpDoubleToInt] = std::make_tuple(OP_cvt, BCUtil::GetIntIdx(), BCUtil::GetDoubleIdx());
+  ans[kDexOpDoubleToLong] = std::make_tuple(OP_cvt, BCUtil::GetLongIdx(), BCUtil::GetDoubleIdx());
+  ans[kDexOpDoubleToFloat] = std::make_tuple(OP_cvt, BCUtil::GetFloatIdx(), BCUtil::GetDoubleIdx());
+  ans[kDexOpIntToByte] = std::make_tuple(OP_sext, BCUtil::GetByteIdx(), BCUtil::GetIntIdx());
+  ans[kDexOpIntToChar] = std::make_tuple(OP_zext, BCUtil::GetCharIdx(), BCUtil::GetIntIdx());
+  ans[kDexOpIntToShort] = std::make_tuple(OP_sext, BCUtil::GetShortIdx(), BCUtil::GetIntIdx());
+  ans[kDexOpNegInt] = std::make_tuple(OP_neg, BCUtil::GetIntIdx(), BCUtil::GetIntIdx());
+  ans[kDexOpNotInt] = std::make_tuple(OP_bnot, BCUtil::GetIntIdx(), BCUtil::GetIntIdx());
+  ans[kDexOpNegLong] = std::make_tuple(OP_neg, BCUtil::GetLongIdx(), BCUtil::GetLongIdx());
+  ans[kDexOpNotLong] = std::make_tuple(OP_bnot, BCUtil::GetLongIdx(), BCUtil::GetLongIdx());
+  ans[kDexOpNegFloat] = std::make_tuple(OP_neg, BCUtil::GetFloatIdx(), BCUtil::GetFloatIdx());
+  ans[kDexOpNegDouble] = std::make_tuple(OP_neg, BCUtil::GetDoubleIdx(), BCUtil::GetDoubleIdx());
+  return ans;
+}
+
+// ========== DexOpBinaryOp =========
+DexOpBinaryOp::DexOpBinaryOp(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpBinaryOp::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+  GStrIdx typeNameIdx; // typeName of A, B, C are same
+  if (kDexOpAddInt <= opcode && opcode <= kDexOpUshrInt) {
+    typeNameIdx = BCUtil::GetIntIdx();
+  } else if (kDexOpAddLong <= opcode && opcode <= kDexOpUshrLong) {
+    typeNameIdx = BCUtil::GetLongIdx();
+  } else if (kDexOpAddFloat <= opcode && opcode <= kDexOpRemFloat) {
+    typeNameIdx = BCUtil::GetFloatIdx();
+  } else if (kDexOpAddDouble <= opcode && opcode <= kDexOpRemDouble) {
+    typeNameIdx = BCUtil::GetDoubleIdx();
+  } else {
+    CHECK_FATAL(false, "Invalid opcode: 0x%x in DexOpBinaryOp", opcode);
+  }
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, typeNameIdx);
+}
+
+void DexOpBinaryOp::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(*(vA.regTypeItem));
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpBinaryOp::SetVCImpl(uint32 num) {
+  vC.regNum = num;
+  if (kDexOpShlLong <= opcode && opcode <= kDexOpUshrLong) {
+    vC.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetIntIdx());
+  } else {
+    vC.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(*(vA.regTypeItem));
+  }
+  usedRegs.emplace_back(&vC);
+}
+
+Opcode DexOpBinaryOp::GetOpcodeFromDexIns(void) const {
+  auto mirOp = dexOp2MIROp.find(opcode);
+  CHECK_FATAL(mirOp != dexOp2MIROp.end(), "Invalid opcode: 0x%x in DexOpBinaryOp", opcode);
+  return mirOp->second;
+}
+
+std::list<UniqueFEIRStmt> DexOpBinaryOp::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  if (kDexOpAddInt <= opcode && opcode <= kDexOpRemDouble) {
+    UniqueFEIRExpr exprB = std::make_unique<FEIRExprDRead>(vB.GenFEIRVarReg());
+    UniqueFEIRExpr exprC = std::make_unique<FEIRExprDRead>(vC.GenFEIRVarReg());
+    std::unique_ptr<FEIRExprBinary> binaryOp2AddrExpr =
+        std::make_unique<FEIRExprBinary>(GetOpcodeFromDexIns(), std::move(exprB), std::move(exprC));
+    UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(vA.GenFEIRVarReg(), std::move(binaryOp2AddrExpr));
+    stmts.emplace_back(std::move(stmt));
+  } else {
+    CHECK_FATAL(false, "Invalid opcode: 0x%x in DexOpBinaryOp", opcode);
+  }
+  return stmts;
+}
+
+// ========== DexOpBinaryOp2Addr =========
+DexOpBinaryOp2Addr::DexOpBinaryOp2Addr(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpBinaryOp2Addr::SetVAImpl(uint32 num) {
+  vDef.regNum = num;
+  vDef.isDef = true;
+  vA.regNum = num;
+  defedRegs.emplace_back(&vDef);
+  usedRegs.emplace_back(&vA);
+  // typeName of A, B are same, except `shl-long/2addr` ~ `ushr-long/2addr`
+  GStrIdx typeNameAIdx;
+  GStrIdx typeNameBIdx;
+  if (kDexOpAddInt2Addr <= opcode && opcode <= kDexOpUshrInt2Addr) {
+    typeNameAIdx = BCUtil::GetIntIdx();
+    typeNameBIdx = typeNameAIdx;
+  } else if (kDexOpAddLong2Addr <= opcode && opcode <= kDexOpXorLong2Addr) {
+    typeNameAIdx = BCUtil::GetLongIdx();
+    typeNameBIdx = typeNameAIdx;
+  } else if (kDexOpShlLong2Addr <= opcode && opcode <= kDexOpUshrLong2Addr) {
+    typeNameAIdx = BCUtil::GetLongIdx();
+    typeNameBIdx = BCUtil::GetIntIdx();
+  } else if (kDexOpAddFloat2Addr <= opcode && opcode <= kDexOpRemFloat2Addr) {
+    typeNameAIdx = BCUtil::GetFloatIdx();
+    typeNameBIdx = typeNameAIdx;
+  } else if (kDexOpAddDouble2Addr <= opcode && opcode <= kDexOpRemDouble2Addr) {
+    typeNameAIdx = BCUtil::GetDoubleIdx();
+    typeNameBIdx = typeNameAIdx;
+  } else {
+    CHECK_FATAL(false, "Invalid opcode: 0x%x in DexOpBinaryOp2Addr", opcode);
+  }
+  vDef.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vDef, typeNameAIdx);
+  vA.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(typeNameAIdx);
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(typeNameBIdx);
+}
+
+void DexOpBinaryOp2Addr::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  // type is set in SetVAImpl
+  usedRegs.emplace_back(&vB);
+}
+
+Opcode DexOpBinaryOp2Addr::GetOpcodeFromDexIns(void) const {
+  auto mirOp = dexOp2Addr2MIROp.find(opcode);
+  CHECK_FATAL(mirOp != dexOp2Addr2MIROp.end(), "Invalid opcode: 0x%x in DexOpBinaryOp2Addr", opcode);
+  return mirOp->second;
+}
+
+std::list<UniqueFEIRStmt> DexOpBinaryOp2Addr::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  if (kDexOpAddInt2Addr <= opcode && opcode <= kDexOpRemDouble2Addr) {
+    UniqueFEIRExpr exprDst = std::make_unique<FEIRExprDRead>(vA.GenFEIRVarReg());
+    UniqueFEIRExpr exprSrc = std::make_unique<FEIRExprDRead>(vB.GenFEIRVarReg());
+    std::unique_ptr<FEIRExprBinary> binaryOp2AddrExpr =
+        std::make_unique<FEIRExprBinary>(GetOpcodeFromDexIns(), std::move(exprDst), std::move(exprSrc));
+    UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(vA.GenFEIRVarReg(), std::move(binaryOp2AddrExpr));
+    stmts.emplace_back(std::move(stmt));
+  } else {
+    CHECK_FATAL(false, "Invalid opcode: 0x%x in DexOpBinaryOp2Addr", opcode);
+  }
+  return stmts;
+}
+
+// ========== DexOpBinaryOpLit =========
+DexOpBinaryOpLit::DexOpBinaryOpLit(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {
+  isLit8 = (kDexOpAddIntLit8 <= opcode && opcode <= kDexOpUshrIntLit8);
+}
+
+void DexOpBinaryOpLit::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+  vA.regType = allocator.GetMemPool()->New<BCRegType>(allocator, vA, BCUtil::GetIntIdx());
+}
+
+void DexOpBinaryOpLit::SetVBImpl(uint32 num) {
+  vB.regNum = num;
+  vB.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetIntIdx());
+  usedRegs.emplace_back(&vB);
+}
+
+void DexOpBinaryOpLit::SetVCImpl(uint32 num) {
+  if (isLit8) {
+    constValue.i8 = static_cast<int8>(num);
+  } else {
+    constValue.i16 = static_cast<int16>(num);
+  }
+}
+
+Opcode DexOpBinaryOpLit::GetOpcodeFromDexIns() const {
+  auto mirOp = dexOpLit2MIROp.find(opcode);
+  CHECK_FATAL(mirOp != dexOpLit2MIROp.end(), "Invalid opcode: 0x%x in DexOpBinaryOpLit", opcode);
+  return mirOp->second;
+}
+
+std::list<UniqueFEIRStmt> DexOpBinaryOpLit::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRExpr exprConst = isLit8 ? FEIRBuilder::CreateExprConstI8(constValue.i8) :
+                                      FEIRBuilder::CreateExprConstI16(constValue.i16);
+  UniqueFEIRExpr exprCvt = FEIRBuilder::CreateExprCvtPrim(std::move(exprConst), PTY_i32);
+  UniqueFEIRExpr exprDreadB = FEIRBuilder::CreateExprDRead(vB.GenFEIRVarReg());
+  UniqueFEIRExpr exprBinary = nullptr;
+  if (opcode == kDexOpRsubInt || opcode == kDexOpRsubIntLit8) {
+    // reverse opnd
+    exprBinary = FEIRBuilder::CreateExprMathBinary(GetOpcodeFromDexIns(), std::move(exprCvt), std::move(exprDreadB));
+  } else {
+    exprBinary = FEIRBuilder::CreateExprMathBinary(GetOpcodeFromDexIns(), std::move(exprDreadB), std::move(exprCvt));
+  }
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(vA.GenFEIRVarReg(), std::move(exprBinary));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
+
+// ========== DexOpInvokePolymorphic =========
+DexOpInvokePolymorphic::DexOpInvokePolymorphic(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOpInvoke(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpInvokePolymorphic::SetVHImpl(uint32 num) {
+  protoIdx = num;
+}
+
+void DexOpInvokePolymorphic::ParseImpl(BCClassMethod &method) {
+  isStatic = method.IsStatic();
+  const BCReader::ClassElem &methodInfo =
+      method.GetBCClass().GetBCParser().GetReader()->GetClassMethodFromIdx(methodIdx);
+  const std::string &funcName = methodInfo.className + "|" + methodInfo.elemName + "|" + methodInfo.typeName;
+  if (FEOptions::GetInstance().IsAOT()) {
+    std::string callerClassName = method.GetBCClass().GetClassName(true);
+    int32 dexFileHashCode = method.GetBCClass().GetBCParser().GetFileNameHashId();
+    callerClassID = FEManager::GetTypeManager().GetTypeIDFromMplClassName(callerClassName, dexFileHashCode);
+  }
+  fullNameMpl = namemangler::EncodeName(funcName);
+  protoName = method.GetBCClass().GetBCParser().GetReader()->GetSignature(protoIdx);
+  retArgsTypeNames = FEUtilJava::SolveMethodSignature(protoName);
+  DexReg reg;
+  MapleList<uint32> argRegNums = argRegs;
+  std::string typeName;
+  // Receiver
+  {
+    reg.regNum = arg0VRegNum;
+    reg.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(BCUtil::GetJavaMethodHandleNameMplIdx());
+    argVRegs.emplace_back(reg);
+  }
+  if (opcode == kDexOpInvokePolymorphicRange) {
+    argRegNums.pop_front(); // Skip first reg num for 'receiver'
+  }
+  for (size_t i = 1; i < retArgsTypeNames.size(); ++i) {
+    reg.regNum = argRegNums.front();
+    argRegNums.pop_front();
+    typeName = retArgsTypeNames[i];
+    typeName = namemangler::EncodeName(typeName);
+    GStrIdx usedTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+    if (BCUtil::IsWideType(usedTypeNameIdx)) {
+      argRegNums.pop_front();  // next regNum is consumed by wide type(long, double)
+    }
+    reg.regTypeItem = allocator.GetMemPool()->New<BCRegTypeItem>(usedTypeNameIdx);
+    argVRegs.emplace_back(reg);
+  }
+  for (auto &vReg : argVRegs) {
+    usedRegs.emplace_back(&vReg);
+  }
+}
+
+std::list<UniqueFEIRStmt> DexOpInvokePolymorphic::EmitToFEIRStmtsImpl() {
+  std::list<UniqueFEIRStmt> stmts;
+  std::unique_ptr<std::list<UniqueFEIRVar>> args = std::make_unique<std::list<UniqueFEIRVar>>();
+  for (const auto &reg : argVRegs) {
+    args->emplace_back(reg.GenFEIRVarReg());
+  }
+  std::unique_ptr<FEIRStmtIntrinsicCallAssign> stmt = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+      INTRN_JAVA_POLYMORPHIC_CALL, fullNameMpl, protoName, std::move(args), callerClassID, isStatic);
+  if (HasReturn()) {
+    static_cast<DexOpMoveResult*>(returnInst)->SetVATypeNameIdx(
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(retArgsTypeNames.at(0))));
+    UniqueFEIRVar var = static_cast<DexOpMoveResult*>(returnInst)->GetVA().GenFEIRVarReg();
+    stmt->SetVar(std::move(var));
+  } else if (retArgsTypeNames[0] != "V") {
+    GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("retvarpoly");
+    std::unique_ptr<FEIRType> retTmpVarType = FEIRBuilder::CreateTypeByJavaName(retArgsTypeNames[0], false);
+    UniqueFEIRVar retTmpVar = std::make_unique<FEIRVarName>(nameIdx, retTmpVarType->Clone(), false);
+    stmt->SetVar(std::move(retTmpVar));
+  }
+
+  stmts.emplace_back(std::move(stmt));
+  retArgsTypeNames.clear();
+  retArgsTypeNames.shrink_to_fit();
+  fullNameMpl.clear();
+  fullNameMpl.shrink_to_fit();
+  protoName.clear();
+  protoName.shrink_to_fit();
+  return stmts;
+}
+
+// ========== DexOpInvokeCustom =========
+DexOpInvokeCustom::DexOpInvokeCustom(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn), argRegs(allocator.Adapter()), argVRegs(allocator.Adapter()) {}
+
+void DexOpInvokeCustom::SetVBImpl(uint32 num) {
+  callSiteIdx = num;
+}
+
+void DexOpInvokeCustom::SetArgsImpl(const MapleList<uint32> &args) {
+  argRegs = args;
+}
+
+// ========== DexOpConstMethodHandle =========
+DexOpConstMethodHandle::DexOpConstMethodHandle(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpConstMethodHandle::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpConstMethodHandle::SetVBImpl(uint32 num) {
+  mhIdx = num;
+}
+// ========== DexOpConstMethodType =========
+DexOpConstMethodType::DexOpConstMethodType(MapleAllocator &allocatorIn, uint32 pcIn, DexOpCode opcodeIn)
+    : DexOp(allocatorIn, pcIn, opcodeIn) {}
+
+void DexOpConstMethodType::SetVAImpl(uint32 num) {
+  vA.regNum = num;
+  vA.isDef = true;
+  defedRegs.emplace_back(&vA);
+}
+
+void DexOpConstMethodType::SetVBImpl(uint32 num) {
+  protoIdx = num;
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/dex/src/dex_parser.cpp b/src/hir2mpl/bytecode_input/dex/src/dex_parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48092dd79bd2ead3f504036443a1899cde1ad465
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dex_parser.cpp
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dex_parser.h"
+#include "fe_manager.h"
+#include "dex_pragma.h"
+#include "dex_encode_value.h"
+#include "fe_manager.h"
+#include "fe_options.h"
+#include "dex_file_util.h"
+
+namespace maple {
+namespace bc {
+DexParser::DexParser(uint32 fileIdxIn, const std::string &fileNameIn, const std::list<std::string> &classNamesIn)
+    : BCParser<DexReader>(fileIdxIn, fileNameIn, classNamesIn) {}
+
+const BCReader *DexParser::GetReaderImpl() const {
+  return reader.get();
+}
+
+void DexParser::SetDexFile(std::unique_ptr<IDexFile> iDexFileIn) {
+  reader->SetDexFile(std::move(iDexFileIn));
+}
+
+uint32 DexParser::CalculateCheckSumImpl(const uint8 *data, uint32 size) {
+  (void) data;
+  (void) size;
+  return 0; // Not work in DexParser
+}
+
+bool DexParser::ParseHeaderImpl() {
+  return true; // Not work in DexParser
+}
+
+bool DexParser::VerifyImpl() {
+  return true; // Not work in DexParser
+}
+
+bool DexParser::RetrieveIndexTables() {
+  return true;
+}
+
+bool DexParser::RetrieveUserSpecifiedClasses(std::list<std::unique_ptr<BCClass>> &klasses) {
+  (void) klasses;
+  return false;
+}
+
+bool DexParser::RetrieveAllClasses(std::list<std::unique_ptr<BCClass>> &klasses) {
+  uint32 classItemsSize = reader->GetClassItemsSize();
+  for (uint32 classIdx = 0; classIdx < classItemsSize; ++classIdx) {
+    klasses.push_back(ProcessDexClass(classIdx));
+  }
+  return true;
+}
+
+bool DexParser::CollectAllDepTypeNamesImpl(std::unordered_set<std::string> &depSet) {
+  return reader->ReadAllDepTypeNames(depSet);
+}
+
+bool DexParser::CollectMethodDepTypeNamesImpl(std::unordered_set<std::string> &depSet, BCClassMethod &bcMethod) const {
+  return reader->ReadMethodDepTypeNames(depSet, bcMethod.GetBCClass().GetClassIdx(),
+                                        bcMethod.GetItemIdx(), bcMethod.IsVirtual());
+}
+
+bool DexParser::CollectAllClassNamesImpl(std::unordered_set<std::string> &classSet) {
+  return reader->ReadAllClassNames(classSet);
+}
+
+std::unique_ptr<BCClass> DexParser::FindClassDef(const std::string &className) {
+  const BCReader *reader = GetReader();
+  const DexReader *dexReader = static_cast<const DexReader*>(reader);
+  maple::IDexFile &iDexFile = dexReader->GetIDexFile();
+  uint32 classIdx = iDexFile.FindClassDefIdx(className);
+  if (classIdx == DexFileUtil::kNoIndex) {
+    return nullptr;
+  }
+  std::unique_ptr<DexClass> dexClass = std::make_unique<DexClass>(classIdx, *this);
+  ProcessDexClassDef(dexClass);
+  ProcessDexClassFields(dexClass);
+  ProcessDexClassMethodDecls(dexClass, false);
+  ProcessDexClassMethodDecls(dexClass, true);
+  ProcessDexClassAnnotationDirectory(dexClass);
+  return dexClass;
+}
+
+std::unique_ptr<DexClass> DexParser::ProcessDexClass(uint32 classIdx) {
+  std::unique_ptr<DexClass> dexClass = std::make_unique<DexClass>(classIdx, *this);
+  ProcessDexClassDef(dexClass);
+  ProcessDexClassFields(dexClass);
+  // direct methods are ahead of virtual methods in class
+  ProcessDexClassMethods(dexClass, false);
+  ProcessDexClassMethods(dexClass, true);
+  ProcessDexClassAnnotationDirectory(dexClass);
+  if (!FEOptions::GetInstance().IsGenMpltOnly()) {
+    ProcessDexClassStaticFieldInitValue(dexClass);
+  }
+  return dexClass;
+}
+
+void DexParser::ProcessDexClassDef(const std::unique_ptr<DexClass> &dexClass) {
+  uint32 classIdx = dexClass->GetClassIdx();
+  dexClass->SetFilePathName(fileName);
+  const char *srcFileName = reader->GetClassJavaSourceFileName(classIdx);
+  dexClass->SetSrcFileInfo(srcFileName == nullptr ? "unknown" : srcFileName);
+  dexClass->SetAccFlag(reader->GetClassAccFlag(classIdx));
+  const std::string &className = reader->GetClassName(classIdx);
+  dexClass->SetClassName(className);
+  dexClass->SetIsInterface(reader->IsInterface(classIdx));
+  dexClass->SetSuperClasses(reader->GetSuperClasses(classIdx));
+  GStrIdx irSrcFileSigIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(reader->GetIRSrcFileSignature());
+  dexClass->SetIRSrcFileSigIdx(irSrcFileSigIdx);
+  ProcessDexClassInterfaceParent(dexClass);
+}
+
+void DexParser::ProcessDexClassFields(const std::unique_ptr<DexClass> &dexClass) {
+  uint32 classIdx = dexClass->GetClassIdx();
+  maple::IDexFile &iDexFile = reader->GetIDexFile();
+  std::vector<std::unique_ptr<IDexFieldItem>> fieldItems = iDexFile.GetClassItem(classIdx)->GetFields(iDexFile);
+  for (uint32 idx = 0; idx < fieldItems.size(); ++idx) {
+    std::unique_ptr<DexClassField> dexClassField = std::make_unique<DexClassField>(
+        *dexClass, idx, fieldItems[idx]->GetFieldIdx(),
+        fieldItems[idx]->GetAccessFlags(),
+        reader->GetClassFieldName(fieldItems[idx]->GetFieldIdx()),
+        reader->GetClassFieldTypeName(fieldItems[idx]->GetFieldIdx()));
+    dexClass->SetField(std::move(dexClassField));
+  }
+}
+
+void DexParser::ProcessDexClassInterfaceParent(const std::unique_ptr<DexClass> &dexClass) {
+  uint32 classIdx = dexClass->GetClassIdx();
+  const std::vector<std::string> &names = reader->GetClassInterfaceNames(classIdx);
+  for (const auto &name : names) {
+    dexClass->SetInterface(name);
+  }
+}
+
+void DexParser::ProcessMethodBodyImpl(BCClassMethod &method,
+    uint32 classIdx, uint32 methodItemIdx, bool isVirtual) const {
+  maple::IDexFile &iDexFile = reader->GetIDexFile();
+  std::unique_ptr<IDexMethodItem> dexMethodItem;
+  if (isVirtual) {
+    dexMethodItem = iDexFile.GetClassItem(classIdx)->GetVirtualMethod(iDexFile, methodItemIdx);
+  } else {
+    dexMethodItem = iDexFile.GetClassItem(classIdx)->GetDirectMethod(iDexFile, methodItemIdx);
+  }
+  method.GenArgRegs();
+  method.SetMethodInstOffset(reader->GetMethodInstOffset(dexMethodItem.get()));
+  method.SetPCBCInstructionMap(
+      reader->ResolveInstructions(method.GetAllocator(), dexMethodItem.get()));
+  method.SetSrcLocalInfo(reader->ResovleSrcLocalInfo(*dexMethodItem));
+  method.SetTryInfos(reader->ResolveTryInfos(dexMethodItem.get()));
+#ifdef DEBUG
+  std::map<uint32_t, uint32_t> srcPosInfo;
+  reader->ResovleSrcPositionInfo(dexMethodItem.get(), srcPosInfo);
+  method.SetSrcPositionInfo(srcPosInfo);
+#endif
+  method.ProcessInstructions();
+}
+
+void DexParser::ProcessDexClassMethod(const std::unique_ptr<DexClass> &dexClass,
+    bool isVirtual, uint32 index, std::pair<uint32, uint32> &idxPair) {
+  std::unique_ptr<DexClassMethod> method = std::make_unique<DexClassMethod>(
+      *dexClass, index, idxPair.first, isVirtual, idxPair.second,
+      reader->GetClassMethodName(idxPair.first), reader->GetClassMethodDescName(idxPair.first));
+  uint32 classIdx = dexClass->GetClassIdx();
+  maple::IDexFile &iDexFile = reader->GetIDexFile();
+  std::unique_ptr<IDexMethodItem> dexMethodItem;
+  if (isVirtual) {
+    dexMethodItem = iDexFile.GetClassItem(classIdx)->GetVirtualMethod(iDexFile, method->GetItemIdx());
+  } else {
+    dexMethodItem = iDexFile.GetClassItem(classIdx)->GetDirectMethod(iDexFile, method->GetItemIdx());
+  }
+  method->SetRegisterTotalSize(reader->GetClassMethodRegisterTotalSize(dexMethodItem.get()));
+  method->SetRegisterInsSize(reader->GetClassMethodRegisterInSize(dexMethodItem.get()));
+  method->SetCodeOff(reader->GetCodeOff(dexMethodItem.get()));
+  dexClass->SetMethod(std::move(method));
+}
+
+void DexParser::ProcessDexClassMethods(const std::unique_ptr<DexClass> &dexClass, bool isVirtual) {
+  uint32 classIdx = dexClass->GetClassIdx();
+  maple::IDexFile &iDexFile = reader->GetIDexFile();
+  std::vector<std::pair<uint32, uint32>> methodItemsIdxAndFlag =
+      iDexFile.GetClassItem(classIdx)->GetMethodsIdxAndFlag(iDexFile, isVirtual);
+  uint32 index = 0;
+  for (auto idxPair : methodItemsIdxAndFlag) {
+    ProcessDexClassMethod(dexClass, isVirtual, index++, idxPair);
+  }
+}
+
+void DexParser::ProcessDexClassMethodDecls(const std::unique_ptr<DexClass> &dexClass, bool isVirtual) {
+  uint32 classIdx = dexClass->GetClassIdx();
+  maple::IDexFile &iDexFile = reader->GetIDexFile();
+  std::vector<std::pair<uint32, uint32>> methodItemsIdxAndFlag =
+      iDexFile.GetClassItem(classIdx)->GetMethodsIdxAndFlag(iDexFile, isVirtual);
+  uint32 index = 0;
+  for (auto idxPair : methodItemsIdxAndFlag) {
+    std::unique_ptr<DexClassMethod> method = std::make_unique<DexClassMethod>(
+        *dexClass, index++, idxPair.first, isVirtual, idxPair.second,
+        reader->GetClassMethodName(idxPair.first), reader->GetClassMethodDescName(idxPair.first));
+    dexClass->SetMethod(std::move(method));
+  }
+}
+
+void DexParser::ProcessDexClassAnnotationDirectory(const std::unique_ptr<DexClass> &dexClass) {
+  const BCReader *reader = GetReader();
+  const DexReader *dexReader = static_cast<const DexReader*>(reader);
+  maple::IDexFile &iDexFile = dexReader->GetIDexFile();
+  uint32 classDefIdx = dexClass->GetClassIdx();
+  const IDexClassItem *iDexClassItem = iDexFile.GetClassItem(classDefIdx);
+  const IDexAnnotationsDirectory *iDexAnnotationsDirectory = iDexClassItem->GetAnnotationsDirectory(iDexFile);
+  MIRModule &module = FEManager::GetModule();
+  std::unique_ptr<BCAnnotationsDirectory> annotationsDirectory =
+      std::make_unique<DexBCAnnotationsDirectory>(module, *(module.GetMemPool()), iDexFile,
+                                                  iDexClassItem->GetClassName(iDexFile), iDexAnnotationsDirectory);
+  dexClass->SetAnnotationsDirectory(std::move(annotationsDirectory));
+}
+
+void DexParser::ProcessDexClassStaticFieldInitValue(const std::unique_ptr<DexClass> &dexClass) {
+  const BCReader *reader = GetReader();
+  const DexReader *dexReader = static_cast<const DexReader*>(reader);
+  maple::IDexFile &iDexFile = dexReader->GetIDexFile();
+  std::unique_ptr<DexEncodeValue> dexEncodeValue =
+      std::make_unique<DexEncodeValue>(*FEManager::GetModule().GetMemPool(), iDexFile);
+  uint32 classDefIdx = dexClass->GetClassIdx();
+  const IDexClassItem *classItem = iDexFile.GetClassItem(classDefIdx);
+  const uint8 *staticValuesList = classItem->GetStaticValuesList(iDexFile);
+  if (staticValuesList == nullptr) {
+    return;
+  }
+  const uint8 **data = &staticValuesList;
+  uint32 size = iDexFile.ReadUnsignedLeb128(data);
+  for (uint32 i = 0; i < size; ++i) {
+    MIRConst *cst = nullptr;
+    uint64 dataVal = *(*data)++;
+    uint8 valueArg = static_cast<uint8>(dataVal >> 5); // valueArgs : dataVal >> 5, The higher three bits are valid.
+    uint8 valueType = dataVal & 0x1f;
+    // get initialization value, max 8 bytes, little-endian
+    uint32 stringID = 0;
+    dexEncodeValue->ProcessEncodedValue(data, valueType, valueArg, cst, stringID);
+    dexClass->InsertStaticFieldConstVal(cst);
+    if (FEOptions::GetInstance().IsAOT() && (valueType == kValueString)) {
+      dexClass->InsertFinalStaticStringID(stringID);
+    }
+  }
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/dex/src/dex_pragma.cpp b/src/hir2mpl/bytecode_input/dex/src/dex_pragma.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..da55cd4d955212289839918307aeed8bf6a8c1f3
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dex_pragma.cpp
@@ -0,0 +1,538 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dex_pragma.h"
+#include "global_tables.h"
+#include "ark_annotation_map.h"
+#include "fe_manager.h"
+#include "bc_util.h"
+#include "fe_manager.h"
+#include "ark_annotation_processor.h"
+#include "rc_setter.h"
+
+namespace maple {
+namespace bc {
+// ---------- DexBCAnnotationElement ----------
+MIRPragmaElement *DexBCAnnotationElement::ProcessAnnotationElement(const uint8 **data) {
+  uint32 nameIdx = iDexFile.ReadUnsignedLeb128(data);
+  const char *elemNameFieldOrig = iDexFile.GetStringByIndex(nameIdx);
+  const std::string elemNameField = namemangler::EncodeName(elemNameFieldOrig);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(elemNameField);
+  MIRPragmaElement *element = mp.New<MIRPragmaElement>(module);
+  element->SetNameStrIdx(strIdx);
+  // Process encoded value.
+  uint64 dataVal = *(*data)++;
+  uint8 valueArg = static_cast<uint8>(dataVal >> 5);
+  uint8 valueType = dataVal & 0x1f;
+  PragmaValueType pragmaValueType = static_cast<PragmaValueType>(valueType);
+  element->SetType(pragmaValueType);
+  MIRConst *cst = nullptr;
+  ProcessAnnotationEncodedValue(data, *element, pragmaValueType, valueArg, cst);
+  return element;
+}
+
+void DexBCAnnotationElement::ProcessAnnotationEncodedValue(const uint8 **data, MIRPragmaElement &element,
+                                                           MIRConst *&cst) {
+  uint64 dataVal = *(*data)++;
+  ProcessAnnotationEncodedValue(data, element, static_cast<PragmaValueType>(dataVal & 0x1f),
+                                static_cast<uint8>(dataVal >> 5), cst);
+}
+
+void DexBCAnnotationElement::ProcessAnnotationEncodedValue(const uint8 **data, MIRPragmaElement &element,
+                                                           PragmaValueType valueType, uint8 valueArg, MIRConst *&cst) {
+  element.SetType(valueType);
+  uint64 val = 0;
+  cst = mp.New<MIRIntConst>(0, *GlobalTables::GetTypeTable().GetInt32());
+  switch (valueType) {
+    case kValueByte: {
+      val = GetUVal(data, valueArg);
+      element.SetU64Val(val);
+      cst = mp.New<MIRIntConst>(val, *GlobalTables::GetTypeTable().GetInt8());
+      break;
+    }
+    case kValueShort: {
+      cst = ProcessAnnotationEncodedValueInternalProcessIntValue(data, element, valueArg,
+                                                                 *GlobalTables::GetTypeTable().GetInt16());
+      break;
+    }
+    case kValueChar: {
+      val = GetUVal(data, valueArg);
+      cst = mp.New<MIRIntConst>(val, *GlobalTables::GetTypeTable().GetUInt16());
+      element.SetU64Val(val);
+      break;
+    }
+    case kValueInt: {
+      cst = ProcessAnnotationEncodedValueInternalProcessIntValue(data, element, valueArg,
+                                                                 *GlobalTables::GetTypeTable().GetInt32());
+      break;
+    }
+    case kValueLong: {
+      cst = ProcessAnnotationEncodedValueInternalProcessIntValue(data, element, valueArg,
+                                                                 *GlobalTables::GetTypeTable().GetInt64());
+      break;
+    }
+    case kValueFloat: {
+      val = GetUVal(data, valueArg);
+      // fill 0s for least significant bits
+      element.SetU64Val(val << ((3 - valueArg) << 3));
+      cst = mp.New<MIRFloatConst>(element.GetFloatVal(), *GlobalTables::GetTypeTable().GetFloat());
+      break;
+    }
+    case kValueDouble: {
+      val = GetUVal(data, valueArg);
+      // fill 0s for least significant bits
+      element.SetU64Val(val << ((7 - valueArg) << 3));
+      cst = mp.New<MIRDoubleConst>(element.GetDoubleVal(), *GlobalTables::GetTypeTable().GetDouble());
+      break;
+    }
+    case kValueString: {
+      cst = ProcessAnnotationEncodedValueInternalProcessStringValue(data, element, valueArg);
+      break;
+    }
+    case kValueMethodType: {
+      element.SetU64Val(0xdeadbeef);
+      break;
+    }
+    case kValueType: {
+      ProcessAnnotationEncodedValueInternalProcessTypeValue(data, element, valueArg);
+      break;
+    }
+    case kValueMethodHandle: {
+      element.SetU64Val(0xdeadbeef);
+      break;
+    }
+    case kValueEnum:
+      // should fallthrough
+      [[fallthrough]];
+    case kValueField: {
+      ProcessAnnotationEncodedValueInternalProcessFieldValue(data, element, valueArg);
+      break;
+    }
+    case kValueMethod: {
+      ProcessAnnotationEncodedValueInternalProcessMethodValue(data, element, valueArg);
+      break;
+    }
+    case kValueArray: {
+      CHECK_FATAL(!valueArg, "value_arg != 0");
+      cst = ProcessAnnotationEncodedValueInternalProcessArrayValue(data, element);
+      break;
+    }
+    case kValueAnnotation: {
+      CHECK_FATAL(!valueArg, "value_arg != 0");
+      ProcessAnnotationEncodedValueInternalProcessAnnotationValue(data, element);
+      break;
+    }
+    case kValueNull: {
+      CHECK_FATAL(!valueArg, "value_arg != 0");
+      element.SetU64Val(0);
+      cst = mp.New<MIRIntConst>(0, *GlobalTables::GetTypeTable().GetInt8());
+      break;
+    }
+    case kValueBoolean: {
+      element.SetU64Val(valueArg);
+      cst = mp.New<MIRIntConst>(valueArg, *GlobalTables::GetTypeTable().GetInt8());
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+
+MIRIntConst *DexBCAnnotationElement::ProcessAnnotationEncodedValueInternalProcessIntValue(const uint8 **data,
+                                                                                          MIRPragmaElement &element,
+                                                                                          uint8 valueArg,
+                                                                                          MIRType &type) {
+  // sign extended val
+  uint64 val = GetUVal(data, valueArg);
+  uint32 shiftBit = static_cast<uint32>((7 - valueArg) * 8);
+  CHECK_FATAL(valueArg <= 7, "shiftBit positive check");
+  uint64 sVal = (static_cast<int64>(val) << shiftBit) >> shiftBit;
+  element.SetI64Val(static_cast<int64>(sVal));
+  MIRIntConst *intCst = mp.New<MIRIntConst>(sVal, type);
+  return intCst;
+}
+
+MIRStr16Const *DexBCAnnotationElement::ProcessAnnotationEncodedValueInternalProcessStringValue(const uint8 **data,
+                                                                                               MIRPragmaElement &ele,
+                                                                                               uint8 valueArg) {
+  uint64 val = GetUVal(data, valueArg);
+  std::string str = namemangler::GetOriginalNameLiteral(iDexFile.GetStringByIndex(static_cast<uint32>(val)));
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
+  ele.SetU64Val(static_cast<uint64>(strIdx));
+  std::u16string str16;
+  (void)namemangler::UTF8ToUTF16(str16, str);
+  MIRStr16Const *strCst = mp.New<MIRStr16Const>(str16, *GlobalTables::GetTypeTable().GetPtr());
+  return strCst;
+}
+
+void DexBCAnnotationElement::ProcessAnnotationEncodedValueInternalProcessTypeValue(const uint8 **data,
+                                                                                   MIRPragmaElement &element,
+                                                                                   uint8 valueArg) {
+  uint64 val = GetUVal(data, valueArg);
+  std::string str = iDexFile.GetStringByTypeIndex(static_cast<uint32>(val));
+  const std::string name = namemangler::EncodeName(str);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  element.SetU64Val(static_cast<uint64>(strIdx));
+}
+
+void DexBCAnnotationElement::ProcessAnnotationEncodedValueInternalProcessFieldValue(const uint8 **data,
+                                                                                    MIRPragmaElement &element,
+                                                                                    uint8 valueArg) {
+  uint64 val = GetUVal(data, valueArg);
+  const IDexFieldIdItem *fieldID = iDexFile.GetFieldIdItem(static_cast<uint32>(val));
+  ASSERT_NOT_NULL(fieldID);
+  std::string str = fieldID->GetShortFieldName(iDexFile);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
+  element.SetU64Val(static_cast<uint64>(strIdx));
+}
+
+void DexBCAnnotationElement::ProcessAnnotationEncodedValueInternalProcessMethodValue(const uint8 **data,
+                                                                                     MIRPragmaElement &element,
+                                                                                     uint8 valueArg) {
+  uint64 val = GetUVal(data, valueArg);
+  const IDexMethodIdItem *methodID = iDexFile.GetMethodIdItem(static_cast<uint32>(val));
+  ASSERT_NOT_NULL(methodID);
+  std::string fullName = std::string(methodID->GetDefiningClassName(iDexFile)) + "|" +
+                                     methodID->GetShortMethodName(iDexFile) + "|" +
+                                     methodID->GetDescriptor(iDexFile);
+  std::string funcName = namemangler::EncodeName(fullName);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  element.SetU64Val(static_cast<uint64>(strIdx));
+}
+
+MIRAggConst *DexBCAnnotationElement::ProcessAnnotationEncodedValueInternalProcessArrayValue(const uint8 **data,
+                                                                                            MIRPragmaElement &element) {
+  unsigned arraySize = iDexFile.ReadUnsignedLeb128(data);
+  uint64 dataVal = *(*data);
+  uint8 newValueType = dataVal & 0x1f;
+  MIRType *elemType = GetTypeFromValueType(static_cast<PragmaValueType>(newValueType));
+  MIRType *arrayTypeWithSize = GlobalTables::GetTypeTable().GetOrCreateArrayType(*elemType, 1, &arraySize);
+  MIRAggConst *aggCst = module.GetMemPool()->New<MIRAggConst>(module, *arrayTypeWithSize);
+  for (unsigned int i = 0; i < arraySize; ++i) {
+    MIRPragmaElement *subElement = mp.New<MIRPragmaElement>(module);
+    MIRConst *mirConst = nullptr;
+    ProcessAnnotationEncodedValue(data, *subElement, mirConst);
+    element.SubElemVecPushBack(subElement);
+    aggCst->PushBack(mirConst);
+  }
+  return aggCst;
+}
+
+void DexBCAnnotationElement::ProcessAnnotationEncodedValueInternalProcessAnnotationValue(const uint8 **data,
+                                                                                         MIRPragmaElement &element) {
+  unsigned typeIdx = iDexFile.ReadUnsignedLeb128(data);
+  std::string str = iDexFile.GetStringByTypeIndex(typeIdx);
+  const std::string name = namemangler::EncodeName(str);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  element.SetTypeStrIdx(strIdx);
+  unsigned annoSize = iDexFile.ReadUnsignedLeb128(data);
+  MIRConst *mirConst = nullptr;
+  for (unsigned int i = 0; i < annoSize; ++i) {
+    MIRPragmaElement *subElement = mp.New<MIRPragmaElement>(module);
+    unsigned nameIdx = iDexFile.ReadUnsignedLeb128(data);
+    str = iDexFile.GetStringByIndex(nameIdx);
+    strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
+    subElement->SetNameStrIdx(strIdx);
+    ProcessAnnotationEncodedValue(data, *subElement, mirConst);
+    element.SubElemVecPushBack(subElement);
+  }
+}
+
+MIRType *DexBCAnnotationElement::GetTypeFromValueType(PragmaValueType valueType) {
+  switch (valueType) {
+    case kValueBoolean:
+      return GlobalTables::GetTypeTable().GetInt8();
+    case kValueByte:
+      return GlobalTables::GetTypeTable().GetInt8();
+    case kValueShort:
+      return GlobalTables::GetTypeTable().GetInt16();
+    case kValueChar:
+      return GlobalTables::GetTypeTable().GetUInt16();
+    case kValueInt:
+      return GlobalTables::GetTypeTable().GetInt32();
+    case kValueLong:
+      return GlobalTables::GetTypeTable().GetInt64();
+    case kValueFloat:
+      return GlobalTables::GetTypeTable().GetFloat();
+    case kValueDouble:
+      return GlobalTables::GetTypeTable().GetDouble();
+    default:
+      return GlobalTables::GetTypeTable().GetPtr();
+  }
+}
+
+// ---------- DexBCAnnotation ----------
+MIRPragma *DexBCAnnotation::EmitPragma(PragmaKind kind, const GStrIdx &pragIdx, int32 paramNum, const TyIdx &tyIdxEx) {
+  uint8 visibility = iDexAnnotation->GetVisibility();
+  const uint8 *annotationData = iDexAnnotation->GetAnnotationData();
+  uint32 typeIdx = iDexFile.ReadUnsignedLeb128(&annotationData);
+  std::string className = namemangler::EncodeName(iDexFile.GetStringByTypeIndex(typeIdx));
+  className = ArkAnnotationMap::GetArkAnnotationMap().GetAnnotationTypeName(className);
+  bool isCreate = false;
+  MIRStructType *structType =
+      FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(className, false, FETypeFlag::kSrcUnknown, isCreate);
+  MIRPragma *pragma = mp.New<MIRPragma>(module);
+  pragma->SetKind(kind);
+  pragma->SetStrIdx(pragIdx);
+  pragma->SetTyIdx(structType->GetTypeIndex());
+  pragma->SetTyIdxEx(tyIdxEx);
+  pragma->SetVisibility(visibility);
+  pragma->SetParamNum(paramNum);
+  uint32 size = iDexFile.ReadUnsignedLeb128(&annotationData);
+  while (size-- != 0) {
+    DexBCAnnotationElement dexBCAnnotationElement(module, mp, iDexFile, &annotationData);
+    MIRPragmaElement *element = dexBCAnnotationElement.EmitPragmaElement();
+    pragma->PushElementVector(element);
+  }
+  return pragma;
+}
+
+// ---------- DexBCAnnotationSet ----------
+void DexBCAnnotationSet::Init() {
+  std::vector<const IDexAnnotation*> iDexAnnotations;
+  iDexAnnotationSet->GetAnnotations(iDexFile, iDexAnnotations);
+  for (uint32 i = 0; i < iDexAnnotations.size(); i++) {
+    const IDexAnnotation *iDexAnnotation = iDexAnnotations[i];
+    std::unique_ptr<DexBCAnnotation> annotation = std::make_unique<DexBCAnnotation>(module, mp, iDexFile,
+                                                                                    iDexAnnotation);
+    annotations.push_back(std::move(annotation));
+  }
+}
+
+std::vector<MIRPragma*> &DexBCAnnotationSet::EmitPragmas(PragmaKind kind, const GStrIdx &pragIdx, int32 paramNum,
+                                                         const TyIdx &tyIdxEx) {
+  pragmas.clear();
+  for (const std::unique_ptr<DexBCAnnotation> &annotation : annotations) {
+    MIRPragma *pragma = annotation->EmitPragma(kind, pragIdx, paramNum, tyIdxEx);
+    pragmas.push_back(pragma);
+  }
+  return pragmas;
+}
+
+// ---------- DexBCAnnotationSetList ----------
+void DexBCAnnotationSetList::Init() {
+  std::vector<const IDexAnnotationSet*> iDexAnnotationSets;
+  iDexAnnotationSetList->GetAnnotationSets(iDexFile, iDexAnnotationSets);
+  for (uint32 i = 0; i < iDexAnnotationSets.size(); i++) {
+    const IDexAnnotationSet *iDexAnnotationSet = iDexAnnotationSets[i];
+    std::unique_ptr<DexBCAnnotationSet> annotationSet = std::make_unique<DexBCAnnotationSet>(module, mp, iDexFile,
+                                                                                             iDexAnnotationSet);
+    annotationSets.push_back(std::move(annotationSet));
+  }
+}
+
+std::vector<MIRPragma*> &DexBCAnnotationSetList::EmitPragmas(PragmaKind kind, const GStrIdx &pragIdx) {
+  pragmas.clear();
+  for (uint32 i = 0; i < annotationSets.size(); i++) {
+    const std::unique_ptr<DexBCAnnotationSet> &annotationSet = annotationSets[i];
+    if (annotationSet->IsValid()) {
+      std::vector<MIRPragma*> &innerPragmas = annotationSet->EmitPragmas(kind, pragIdx, static_cast<int32>(i));
+      for (MIRPragma *pragma : innerPragmas) {
+        pragmas.push_back(pragma);
+      }
+    }
+  }
+  return pragmas;
+}
+
+// ---------- DexBCFieldAnnotations ----------
+void DexBCFieldAnnotations::Init() {
+  const IDexAnnotationSet *iDexAnnotationSet = iDexFieldAnnotations->GetAnnotationSet(iDexFile);
+  annotationSet = std::make_unique<DexBCAnnotationSet>(module, mp, iDexFile, iDexAnnotationSet);
+}
+
+std::vector<MIRPragma*> &DexBCFieldAnnotations::EmitPragmas() {
+  const IDexFieldIdItem *fieldID = iDexFieldAnnotations->GetFieldIdItem(iDexFile);
+  const std::string &fieldTypeName = namemangler::EncodeName(fieldID->GetFieldTypeName(iDexFile));
+  MIRType *fieldType = FEManager::GetTypeManager().GetOrCreateTypeFromName(fieldTypeName, FETypeFlag::kSrcUnknown,
+                                                                           true);
+  CHECK_NULL_FATAL(fieldType);
+  uint64 mapIdx = (static_cast<uint64>(iDexFile.GetFileIdx()) << 32) | iDexFieldAnnotations->GetFieldIdx();
+  StructElemNameIdx *structElemNameIdx = FEManager::GetManager().GetFieldStructElemNameIdx(mapIdx);
+  ASSERT(structElemNameIdx != nullptr, "structElemNameIdx is nullptr.");
+  std::vector<MIRPragma*> &pragmas =
+      annotationSet->EmitPragmas(kPragmaVar, structElemNameIdx->elem, -1, fieldType->GetTypeIndex());
+  if (FEOptions::GetInstance().IsRC()) {
+    RCSetter::GetRCSetter().ProcessFieldRCAnnotation(*structElemNameIdx, *fieldType, pragmas);
+  }
+  return pragmas;
+}
+
+// ---------- DexBCMethodAnnotations ----------
+void DexBCMethodAnnotations::Init() {
+  const IDexAnnotationSet *iDexAnnotationSet = iDexMethodAnnotations->GetAnnotationSet(iDexFile);
+  annotationSet = std::make_unique<DexBCAnnotationSet>(module, mp, iDexFile, iDexAnnotationSet);
+}
+
+std::vector<MIRPragma*> &DexBCMethodAnnotations::EmitPragmas() {
+  methodID = iDexMethodAnnotations->GetMethodIdItem(iDexFile);
+  uint64 mapIdx = (static_cast<uint64>(iDexFile.GetFileIdx()) << 32) | iDexMethodAnnotations->GetMethodIdx();
+  StructElemNameIdx *structElemNameIdx = FEManager::GetManager().GetMethodStructElemNameIdx(mapIdx);
+  ASSERT(structElemNameIdx != nullptr, "structElemNameIdx is nullptr.");
+  methodFullNameStrIdx = structElemNameIdx->full;
+  pragmasPtr = &(annotationSet->EmitPragmas(kPragmaFunc, methodFullNameStrIdx));
+  if (pragmasPtr->size() > 0) {
+    SetupFuncAttrs();
+  }
+  return *pragmasPtr;
+}
+
+void DexBCMethodAnnotations::SetupFuncAttrs() {
+  MIRFunction *func = GetMIRFunction(methodFullNameStrIdx);
+  CHECK_NULL_FATAL(func);
+  for (MIRPragma *pragma : *pragmasPtr) {
+    SetupFuncAttrWithPragma(*func, *pragma);
+  }
+}
+
+void DexBCMethodAnnotations::SetupFuncAttrWithPragma(MIRFunction &mirFunc, const MIRPragma &pragma) {
+  FuncAttrKind attr;
+  bool isAttrSet = true;
+  if (ArkAnnotation::GetInstance().IsFastNative(pragma.GetTyIdx())) {
+    attr = FUNCATTR_fast_native;
+  } else if (ArkAnnotation::GetInstance().IsCriticalNative(pragma.GetTyIdx())) {
+    attr = FUNCATTR_critical_native;
+  } else if (ArkAnnotation::GetInstance().IsCallerSensitive(pragma.GetTyIdx())) {
+    attr = FUNCATTR_callersensitive;
+  } else if (FEOptions::GetInstance().IsRC() &&
+             (ArkAnnotation::GetInstance().IsRCUnownedLocal(pragma.GetTyIdx()) ||
+              (ArkAnnotation::GetInstance().IsRCUnownedLocalOld(pragma.GetTyIdx()) &&
+               pragma.GetElementVector().empty()))) {
+    attr = FUNCATTR_rclocalunowned;
+    RCSetter::GetRCSetter().CollectUnownedLocalFuncs(&mirFunc);
+  } else {
+    isAttrSet = false;  // empty, for codedex cleanup
+  }
+  const char *definingClassName = methodID->GetDefiningClassName(iDexFile);
+  std::string mplClassName = namemangler::EncodeName(definingClassName);
+  MIRStructType *currStructType = FEManager::GetTypeManager().GetStructTypeFromName(mplClassName);
+  if (isAttrSet) {
+    mirFunc.SetAttr(attr);
+    // update method attribute in structure type as well
+    for (auto &mit : currStructType->GetMethods()) {
+      if (mit.first == mirFunc.GetStIdx()) {
+        mit.second.second.SetAttr(attr);
+        break;
+      }
+    }
+  }
+  if (FEOptions::GetInstance().IsRC()) {
+    RCSetter::GetRCSetter().ProcessMethodRCAnnotation(mirFunc, mplClassName, *currStructType, pragma);
+  }
+}
+
+MIRFunction *DexBCMethodAnnotations::GetMIRFunction(const GStrIdx &nameIdx) const {
+  MIRFunction *func = nullptr;
+  bool isStatic = true;
+  func = FEManager::GetTypeManager().GetMIRFunction(nameIdx, isStatic);
+  if (func != nullptr) {
+    return func;
+  }
+  isStatic = false;
+  func = FEManager::GetTypeManager().GetMIRFunction(nameIdx, isStatic);
+  return func;
+}
+
+// ---------- DexBCParameterAnnotations ----------
+void DexBCParameterAnnotations::Init() {
+  if (iDexParameterAnnotations == nullptr) {
+    return;
+  }
+  const IDexAnnotationSetList *iDexAnnotationSetList = iDexParameterAnnotations->GetAnnotationSetList(iDexFile);
+  if (iDexAnnotationSetList == nullptr) {
+    return;
+  }
+  annotationSetList = std::make_unique<DexBCAnnotationSetList>(module, mp, iDexFile, iDexAnnotationSetList);
+}
+
+std::vector<MIRPragma*> &DexBCParameterAnnotations::EmitPragmas() {
+  pragmas.clear();
+  if (annotationSetList == nullptr) {
+    return pragmas;
+  }
+  uint64 mapIdx = (static_cast<uint64>(iDexFile.GetFileIdx()) << 32) | iDexParameterAnnotations->GetMethodIdx();
+  StructElemNameIdx *structElemNameIdx = FEManager::GetManager().GetMethodStructElemNameIdx(mapIdx);
+  ASSERT(structElemNameIdx != nullptr, "structElemNameIdx is nullptr.");
+  return annotationSetList->EmitPragmas(kPragmaParam, structElemNameIdx->full);
+}
+
+// ---------- DexBCAnnotationsDirectory ----------
+void DexBCAnnotationsDirectory::Init() {
+  if (iDexAnnotationsDirectory == nullptr) {
+    return;
+  }
+  if (iDexAnnotationsDirectory->HasClassAnnotationSet(iDexFile)) {
+    classAnnotationSet = std::make_unique<DexBCAnnotationSet>(module, mp, iDexFile,
+        iDexAnnotationsDirectory->GetClassAnnotationSet(iDexFile));
+  }
+  if (iDexAnnotationsDirectory->HasFieldAnnotationsItems(iDexFile)) {
+    std::vector<const IDexFieldAnnotations*> iDexFieldAnnotationsItems;
+    iDexAnnotationsDirectory->GetFieldAnnotationsItems(iDexFile, iDexFieldAnnotationsItems);
+    for (const IDexFieldAnnotations* iDexFieldAnnotations : iDexFieldAnnotationsItems) {
+      std::unique_ptr<DexBCFieldAnnotations> fieldAnnotations =
+          std::make_unique<DexBCFieldAnnotations>(module, mp, iDexFile, iDexFieldAnnotations);
+      fieldAnnotationsItems.push_back(std::move(fieldAnnotations));
+    }
+  }
+  if (iDexAnnotationsDirectory->HasMethodAnnotationsItems(iDexFile)) {
+    std::vector<const IDexMethodAnnotations*> iDexMethodAnnotationsItems;
+    iDexAnnotationsDirectory->GetMethodAnnotationsItems(iDexFile, iDexMethodAnnotationsItems);
+    for (const IDexMethodAnnotations *iDexMethodAnnotations : iDexMethodAnnotationsItems) {
+      std::unique_ptr<DexBCMethodAnnotations> methodAnnotations =
+          std::make_unique<DexBCMethodAnnotations>(module, mp, iDexFile, iDexMethodAnnotations);
+      methodAnnotationsItems.push_back(std::move(methodAnnotations));
+    }
+  }
+  if (iDexAnnotationsDirectory->HasParameterAnnotationsItems(iDexFile)) {
+    std::vector<const IDexParameterAnnotations*> iDexParameterAnnotationsItems;
+    iDexAnnotationsDirectory->GetParameterAnnotationsItems(iDexFile, iDexParameterAnnotationsItems);
+    for (const IDexParameterAnnotations *iDexParameterAnnotations : iDexParameterAnnotationsItems) {
+      std::unique_ptr<DexBCParameterAnnotations> parameterAnnotations =
+          std::make_unique<DexBCParameterAnnotations>(module, mp, iDexFile, iDexParameterAnnotations);
+      parameterAnnotationsItems.push_back(std::move(parameterAnnotations));
+    }
+  }
+}
+
+std::vector<MIRPragma*> &DexBCAnnotationsDirectory::EmitPragmasImpl() {
+  pragmas.clear();
+  if (iDexAnnotationsDirectory == nullptr) {
+    return pragmas;
+  }
+  std::vector<MIRPragma*> pragmasInner;
+  if (classAnnotationSet != nullptr) {
+    const GStrIdx &strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(className));
+    pragmasInner = classAnnotationSet->EmitPragmas(kPragmaClass, strIdx);
+    if (FEOptions::GetInstance().IsRC()) {
+      RCSetter::GetRCSetter().ProcessClassRCAnnotation(strIdx, pragmasInner);
+    }
+    pragmas.insert(pragmas.end(), pragmasInner.begin(), pragmasInner.end());
+  }
+  for (const std::unique_ptr<DexBCFieldAnnotations> &fieldAnnotations : fieldAnnotationsItems) {
+    pragmasInner = fieldAnnotations->EmitPragmas();
+    pragmas.insert(pragmas.end(), pragmasInner.begin(), pragmasInner.end());
+  }
+  for (const std::unique_ptr<DexBCMethodAnnotations> &methodAnnotations : methodAnnotationsItems) {
+    pragmasInner = methodAnnotations->EmitPragmas();
+    pragmas.insert(pragmas.end(), pragmasInner.begin(), pragmasInner.end());
+  }
+  for (const std::unique_ptr<DexBCParameterAnnotations> &parameterAnnotations : parameterAnnotationsItems) {
+    pragmasInner = parameterAnnotations->EmitPragmas();
+    pragmas.insert(pragmas.end(), pragmasInner.begin(), pragmasInner.end());
+  }
+  return pragmas;
+}
+}  // namespace bc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/src/dex_reader.cpp b/src/hir2mpl/bytecode_input/dex/src/dex_reader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..88d62d251fc24cd62f2c2311eadd01bfdf8909b3
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dex_reader.cpp
@@ -0,0 +1,406 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dex_reader.h"
+#include "dexfile_factory.h"
+#include "mpl_logging.h"
+#include "dex_file_util.h"
+#include "dex_op.h"
+#include "dex_class.h"
+#include "fe_utils_java.h"
+
+namespace maple {
+namespace bc {
+bool DexReader::OpenAndMapImpl() {
+  DexFileFactory dexFileFactory;
+  iDexFile = dexFileFactory.NewInstance();
+  bool openResult = iDexFile->Open(fileName);
+  if (!openResult) {
+    ERR(kLncErr, "Failed to open dex file %s", fileName.c_str());
+    return false;
+  }
+  iDexFile->SetFileIdx(fileIdx);
+  irSrcFileSignature = iDexFile->GetHeader()->GetSignature();
+  return true;
+}
+
+void DexReader::SetDexFile(std::unique_ptr<IDexFile> iDexFileIn) {
+  iDexFile = std::move(iDexFileIn);
+}
+
+uint32 DexReader::GetClassItemsSize() const {
+  return iDexFile->GetClassItemsSize();
+}
+
+const char *DexReader::GetClassJavaSourceFileName(uint32 classIdx) const {
+  return iDexFile->GetClassItem(classIdx)->GetJavaSourceFileName(GetIDexFile());
+}
+
+bool DexReader::IsInterface(uint32 classIdx) const {
+  return iDexFile->GetClassItem(classIdx)->IsInterface();
+}
+
+uint32 DexReader::GetClassAccFlag(uint32 classIdx) const {
+  return iDexFile->GetClassItem(classIdx)->GetAccessFlags();
+}
+
+std::string DexReader::GetClassName(uint32 classIdx) const {
+  const char *className = iDexFile->GetClassItem(classIdx)->GetClassName(GetIDexFile());
+  CHECK_FATAL(className != nullptr, "class name of classItem: %u is empty.", classIdx);
+  return className;
+}
+
+std::list<std::string> DexReader::GetSuperClasses(uint32 classIdx, bool mapled) const {
+  const char *super = iDexFile->GetClassItem(classIdx)->GetSuperClassName(GetIDexFile());
+  std::list<std::string> superClasses;
+  if (super != nullptr) {
+    superClasses.emplace_back(mapled ? namemangler::EncodeName(super) : super);
+  }
+  return superClasses;
+}
+
+std::vector<std::string> DexReader::GetClassInterfaceNames(uint32 classIdx, bool mapled) const {
+  std::vector<const char*> names;
+  iDexFile->GetClassItem(classIdx)->GetInterfaceNames(GetIDexFile(), names);
+  std::vector<std::string> ret;
+  for (auto name : names) {
+    if (name != nullptr) {
+      ret.push_back(mapled ? namemangler::EncodeName(name) : name);
+    }
+  }
+  return ret;
+}
+
+std::string DexReader::GetClassFieldName(uint32 fieldIdx, bool mapled) const {
+  const IDexFieldIdItem *fieldIdItem = iDexFile->GetFieldIdItem(fieldIdx);
+  const char *name = iDexFile->GetStringByIndex(fieldIdItem->GetNameIdx());
+  return (mapled && name != nullptr) ? namemangler::EncodeName(name) : (name != nullptr ? name : "");
+}
+
+std::string DexReader::GetClassFieldTypeName(uint32 fieldIdx, bool mapled) const {
+  const IDexFieldIdItem *fieldIdItem = iDexFile->GetFieldIdItem(fieldIdx);
+  const char *name = fieldIdItem->GetFieldTypeName(GetIDexFile());
+  return (mapled && name != nullptr) ? namemangler::EncodeName(name) : (name != nullptr ? name : "");
+}
+
+std::string DexReader::GetClassMethodName(uint32 methodIdx, bool mapled) const {
+  const IDexMethodIdItem *methodIdItem = iDexFile->GetMethodIdItem(methodIdx);
+  const char *name = iDexFile->GetStringByIndex(methodIdItem->GetNameIdx());
+  return (mapled && name != nullptr) ? namemangler::EncodeName(name) : (name != nullptr ? name : "");
+}
+
+std::string DexReader::GetClassMethodDescName(uint32 methodIdx, bool mapled) const {
+  const IDexMethodIdItem *methodIdItem = iDexFile->GetMethodIdItem(methodIdx);
+  const std::string name = iDexFile->GetProtoIdItem(methodIdItem->GetProtoIdx())->GetDescriptor(GetIDexFile());
+  return mapled ? namemangler::EncodeName(name) : name;
+}
+
+std::string DexReader::GetStringFromIdxImpl(uint32 idx) const {
+  const char *str = iDexFile->GetStringByIndex(idx);
+  return str == nullptr ? "" : str;
+}
+
+std::string DexReader::GetTypeNameFromIdxImpl(uint32 idx) const {
+  const char *str = iDexFile->GetStringByTypeIndex(idx);
+  return str == nullptr ? "" : str;
+}
+
+BCReader::ClassElem DexReader::GetClassFieldFromIdxImpl(uint32 idx) const {
+  ClassElem elem;
+  const char *name = iDexFile->GetFieldIdItem(idx)->GetDefiningClassName(GetIDexFile());
+  CHECK_FATAL(name != nullptr, "Failed: field class name is empty.");
+  elem.className = name;
+  name = iDexFile->GetFieldIdItem(idx)->GetShortFieldName(GetIDexFile());
+  CHECK_FATAL(name != nullptr, "Failed: field name is empty.");
+  elem.elemName = name;
+  name = iDexFile->GetFieldIdItem(idx)->GetFieldTypeName(GetIDexFile());
+  CHECK_FATAL(name != nullptr, "Failed: field type name is empty.");
+  elem.typeName = name;
+  return elem;
+}
+
+std::unordered_map<std::string, uint32> DexReader::GetDefiningClassNameTypeIdMap() const {
+  return iDexFile->GetDefiningClassNameTypeIdMap();
+}
+
+const uint16 *DexReader::GetMethodInstOffset(const IDexMethodItem* dexMethodItem) const {
+  return dexMethodItem->GetInsnsByOffset(*iDexFile, 0);
+}
+
+uint16 DexReader::GetClassMethodRegisterTotalSize(const IDexMethodItem* dexMethodItem) const {
+  return dexMethodItem->GetRegistersSize(*iDexFile);
+}
+
+uint16 DexReader::GetClassMethodRegisterInSize(const IDexMethodItem* dexMethodItem) const {
+  return dexMethodItem->GetInsSize(*iDexFile);
+}
+
+uint32 DexReader::GetCodeOff(const IDexMethodItem* dexMethodItem) const {
+  return dexMethodItem->GetCodeOff();
+}
+
+BCReader::ClassElem DexReader::GetClassMethodFromIdxImpl(uint32 idx) const {
+  ClassElem elem;
+  const char *name = iDexFile->GetMethodIdItem(idx)->GetDefiningClassName(GetIDexFile());
+  CHECK_FATAL(name != nullptr, "Failed: field class name is empty.");
+  elem.className = name;
+  name = iDexFile->GetMethodIdItem(idx)->GetShortMethodName(GetIDexFile());
+  CHECK_FATAL(name != nullptr, "Failed: field name is empty.");
+  elem.elemName = name;
+  elem.typeName = iDexFile->GetMethodIdItem(idx)->GetDescriptor(GetIDexFile());
+  return elem;
+}
+
+std::string DexReader::GetSignatureImpl(uint32 idx) const {
+  return iDexFile->GetProtoIdItem(idx)->GetDescriptor(GetIDexFile());
+}
+
+uint32 DexReader::GetFileIndexImpl() const {
+  return iDexFile->GetFileIdx();
+}
+
+void DexReader::ResovleSrcPositionInfo(
+    const IDexMethodItem* dexMethodItem,
+    std::map<uint32, uint32> &srcPosInfo) const {
+  dexMethodItem->GetSrcPositionInfo(GetIDexFile(), srcPosInfo);
+}
+
+
+std::unique_ptr<SrcLocalInfo> DexReader::ResovleSrcLocalInfo(const IDexMethodItem &dexMethodItem) const {
+  auto srcLocals = std::make_unique<SrcLocalInfo>();
+  dexMethodItem.GetSrcLocalInfo(GetIDexFile(), *srcLocals);
+  return srcLocals;
+}
+
+MapleMap<uint32, BCInstruction*> *DexReader::ResolveInstructions(
+    MapleAllocator &allocator, const IDexMethodItem* dexMethodItem, bool mapled) const {
+  (void) mapled;
+  std::map<uint32, std::unique_ptr<IDexInstruction>> pcInstMap;
+  dexMethodItem->GetPCInstructionMap(GetIDexFile(), pcInstMap);
+  return ConstructBCPCInstructionMap(allocator, pcInstMap);
+}
+
+MapleMap<uint32, BCInstruction*> *DexReader::ConstructBCPCInstructionMap(
+    MapleAllocator &allocator, const std::map<uint32, std::unique_ptr<IDexInstruction>> &pcInstMap) const {
+  MapleMap<uint32, BCInstruction*> *pcBCInstMap =
+      allocator.GetMemPool()->New<MapleMap<uint32, BCInstruction*>>(allocator.Adapter());
+  for (const auto &pcInst : pcInstMap) {
+    pcBCInstMap->emplace(pcInst.first, ConstructBCInstruction(allocator, pcInst));
+  }
+  return pcBCInstMap;
+}
+
+BCInstruction *DexReader::ConstructBCInstruction(
+    MapleAllocator &allocator, const std::pair<const uint32, std::unique_ptr<IDexInstruction>> &p) const {
+  auto dexOp =
+      static_cast<DexOp*>(dexOpGeneratorMap[static_cast<DexOpCode>(p.second.get()->GetOpcode())](allocator, p.first));
+  dexOp->SetVA(GetVA(p.second.get()));
+  dexOp->SetVB(GetVB(p.second.get()));
+  dexOp->SetWideVB(GetWideVB(p.second.get()));
+  MapleList<uint32> vRegs(allocator.Adapter());
+  GetArgVRegs(p.second.get(), vRegs);
+  dexOp->SetArgs(vRegs);
+  dexOp->SetVC(GetVC(p.second.get()));
+  dexOp->SetVH(GetVH(p.second.get()));
+  dexOp->SetWidth(GetWidth(p.second.get()));
+  dexOp->SetOpName(GetOpName(p.second.get()));
+  return dexOp;
+}
+
+uint32 DexReader::GetVA(const IDexInstruction *inst) const {
+  return inst->GetVRegA();
+}
+
+uint32 DexReader::GetVB(const IDexInstruction *inst) const {
+  return inst->GetVRegB();
+}
+
+uint64 DexReader::GetWideVB(const IDexInstruction *inst) const {
+  return inst->GetVRegBWide();
+}
+
+uint32 DexReader::GetVC(const IDexInstruction *inst) const {
+  return inst->GetVRegC();
+}
+
+void DexReader::GetArgVRegs(const IDexInstruction *inst, MapleList<uint32> &vRegs) const {
+  if (inst->GetOpcode() == kOpFilledNewArray ||
+      (kOpInvokeVirtual <= inst->GetOpcode() && inst->GetOpcode() <= kOpInvokeInterface) ||
+      inst->GetOpcode() == kOpInvokePolymorphic ||
+      inst->GetOpcode() == kOpInvokeCustom) {
+    for (uint32 i = 0; i < inst->GetVRegA(); ++i) {
+      vRegs.push_back(inst->GetArg(i));
+    }
+  } else if (inst->GetOpcode() == kOpFilledNewArrayRange ||
+             (kOpInvokeVirtualRange <= inst->GetOpcode() && inst->GetOpcode() <= kOpInvokeInterfaceRange) ||
+             inst->GetOpcode() == kOpInvokePolymorphicRange ||
+             inst->GetOpcode() == kOpInvokeCustomRange) {
+    for (uint32 i = 0; i < inst->GetVRegA(); ++i) {
+      vRegs.push_back(inst->GetVRegC() + i);
+    }
+  }
+}
+
+uint32 DexReader::GetVH(const IDexInstruction *inst) const {
+  return inst->GetVRegH();
+}
+
+uint8 DexReader::GetWidth(const IDexInstruction *inst) const {
+  return inst->GetWidth();
+}
+
+const char *DexReader::GetOpName(const IDexInstruction *inst) const {
+  return inst->GetOpcodeName();
+}
+
+std::unique_ptr<std::list<std::unique_ptr<BCTryInfo>>> DexReader::ResolveTryInfos(
+    const IDexMethodItem* dexMethodItem) const {
+  std::vector<const IDexTryItem*> tryItems;
+  dexMethodItem->GetTryItems(GetIDexFile(), tryItems);
+  uint32 codeOff = dexMethodItem->GetCodeOff();
+  return ConstructBCTryInfoList(codeOff, tryItems);
+}
+
+std::unique_ptr<std::list<std::unique_ptr<BCTryInfo>>> DexReader::ConstructBCTryInfoList(
+    uint32 codeOff, const std::vector<const IDexTryItem*> &tryItems) const {
+  auto tryInfos =
+      std::make_unique<std::list<std::unique_ptr<BCTryInfo>>>();
+  std::list<std::unique_ptr<BCTryInfo>> info;
+  for (const auto *tryItem : tryItems) {
+    std::vector<IDexCatchHandlerItem> dexCatchItems;
+    tryItem->GetCatchHandlerItems(GetIDexFile(), codeOff, dexCatchItems);
+    std::unique_ptr<BCTryInfo> tryInfo = std::make_unique<DEXTryInfo>(
+        tryItem->GetStartAddr(),
+        tryItem->GetEndAddr(),
+        ConstructBCCatchList(dexCatchItems));
+    tryInfos->push_back(std::move(tryInfo));
+    info.push_back(std::move(tryInfo));
+  }
+  return tryInfos;
+}
+
+std::unique_ptr<std::list<std::unique_ptr<BCCatchInfo>>> DexReader::ConstructBCCatchList(
+    std::vector<IDexCatchHandlerItem> &catchHandlerItems) const {
+  std::unique_ptr<std::list<std::unique_ptr<BCCatchInfo>>> catches =
+    std::make_unique<std::list<std::unique_ptr<BCCatchInfo>>>();
+  for (const auto catchHandlerItem : catchHandlerItems) {
+    // Use V (void) catch <any> exceptions
+    GStrIdx exceptionNameIdx = catchHandlerItem.IsCatchAllHandlerType() ? BCUtil::GetVoidIdx() :
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+            namemangler::EncodeName(iDexFile->GetStringByTypeIndex(catchHandlerItem.GetHandlerTypeIdx())));
+    std::unique_ptr<BCCatchInfo> catchInfo = std::make_unique<DEXCatchInfo>(
+        catchHandlerItem.GetHandlerAddress(),
+        exceptionNameIdx,
+        catchHandlerItem.IsCatchAllHandlerType());
+    catches->push_back(std::move(catchInfo));
+  }
+  return catches;
+}
+
+bool DexReader::ReadAllDepTypeNames(std::unordered_set<std::string> &depSet) {
+  for (uint32 i = 0; i < iDexFile->GetHeader()->GetTypeIdsSize(); ++i) {
+    std::string typeName = iDexFile->GetStringByTypeIndex(i);
+    std::string trimmedTypeName = BCUtil::TrimArrayModifier(typeName);
+    if (trimmedTypeName.size() != 0 && trimmedTypeName[0] == 'L') {
+      depSet.insert(trimmedTypeName);
+    }
+  }
+  return true;
+}
+
+bool DexReader::ReadAllClassNames(std::unordered_set<std::string> &classSet) const {
+  for (uint32 classIdx = 0; classIdx < iDexFile->GetClassItemsSize(); ++classIdx) {
+    const IDexClassItem *classItem = iDexFile->GetClassItem(classIdx);
+    classSet.emplace(classItem->GetClassName(GetIDexFile()));
+  }
+  return true;
+}
+
+bool DexReader::ReadMethodDepTypeNames(std::unordered_set<std::string> &depSet,
+                                       uint32 classIdx, uint32 methodItemx, bool isVirtual) const {
+  std::unique_ptr<IDexMethodItem> method;
+  if (isVirtual) {
+    method = iDexFile->GetClassItem(classIdx)->GetVirtualMethod(*iDexFile, methodItemx);
+  } else {
+    method = iDexFile->GetClassItem(classIdx)->GetDirectMethod(*iDexFile, methodItemx);
+  }
+  CHECK_NULL_FATAL(method.get());
+  std::map<uint32, std::unique_ptr<IDexInstruction>> pcInstMap;
+  method->GetPCInstructionMap(GetIDexFile(), pcInstMap);
+  for (const auto &pcInst : pcInstMap) {
+    const std::unique_ptr<IDexInstruction> &inst = pcInst.second;
+    IDexOpcode op = inst->GetOpcode();
+    if (op >= kOpIget && op <= kOpIputShort) {
+      // field operation
+      const char *className = iDexFile->GetFieldIdItem(inst->GetVRegC())->GetDefiningClassName(GetIDexFile());
+      CHECK_FATAL(className != nullptr, "field class name is empty.");
+      AddDepTypeName(depSet, className, false);
+    } else if (op >= kOpSget && op <= kOpSputShort) {
+      // field operation
+      const char *className = iDexFile->GetFieldIdItem(inst->GetVRegB())->GetDefiningClassName(GetIDexFile());
+      CHECK_FATAL(className != nullptr, "field class name is empty.");
+      AddDepTypeName(depSet, className, false);
+    } else if (op >= kOpInvokeVirtual && op <= kOpInvokeInterfaceRange) {
+      // invoke inst
+      const IDexMethodIdItem *methodIdTmp = iDexFile->GetMethodIdItem(inst->GetVRegB());
+      const char *className = methodIdTmp->GetDefiningClassName(GetIDexFile());
+      CHECK_FATAL(className != nullptr, "method class name is empty.");
+      AddDepTypeName(depSet, className, true);
+      const std::string &typeName = methodIdTmp->GetDescriptor(GetIDexFile());
+      std::vector<std::string> retArgsTypeNames = FEUtilJava::SolveMethodSignature(typeName);
+      for (const std::string &item : retArgsTypeNames) {
+        AddDepTypeName(depSet, item, true);
+      }
+    } else if (op == kOpConstClass || op == kOpCheckCast || op == kOpFilledNewArray || op == kOpFilledNewArrayRange) {
+      AddDepTypeName(depSet, iDexFile->GetStringByTypeIndex(inst->GetVRegB()), true);
+    } else if (op == kOpInstanceOf || op == kOpNewArray) {
+      AddDepTypeName(depSet, iDexFile->GetStringByTypeIndex(inst->GetVRegC()), true);
+    } else if (op == kOpNewInstance) {
+      AddDepTypeName(depSet, iDexFile->GetStringByTypeIndex(inst->GetVRegB()), false);
+    }
+    ReadMethodTryCatchDepTypeNames(depSet, *method);
+  }
+  return true;
+}
+
+void DexReader::ReadMethodTryCatchDepTypeNames(std::unordered_set<std::string> &depSet,
+                                               const IDexMethodItem &method) const {
+  uint32 tryNum = method.GetTriesSize(GetIDexFile());
+  if (tryNum == 0) {
+    return;
+  }
+  std::vector<const IDexTryItem*> tryItems;
+  method.GetTryItems(GetIDexFile(), tryItems);
+  uint32 codeOff = method.GetCodeOff();
+  for (const auto tryItem : tryItems) {
+    std::vector<IDexCatchHandlerItem> dexCatchItems;
+    tryItem->GetCatchHandlerItems(GetIDexFile(), codeOff, dexCatchItems);
+    for (const auto &handler: dexCatchItems) {
+      if (!handler.IsCatchAllHandlerType()) {
+        uint32 typeIdx = handler.GetHandlerTypeIdx();
+        AddDepTypeName(depSet, iDexFile->GetStringByTypeIndex(typeIdx), false);
+      }
+    }
+  }
+}
+
+void DexReader::AddDepTypeName(std::unordered_set<std::string> &depSet,
+                               const std::string &typeName, bool isTrim) const {
+  const std::string &trimmedTypeName = isTrim ? BCUtil::TrimArrayModifier(typeName) : typeName;
+  if (trimmedTypeName.size() != 0 && trimmedTypeName[0] == 'L') {
+    depSet.insert(trimmedTypeName);
+  }
+}
+}  // namespace bc
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/dex/src/dex_strfac.cpp b/src/hir2mpl/bytecode_input/dex/src/dex_strfac.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..87aa86bc7c32e3ddd3a54fc93db10a273af9285b
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dex_strfac.cpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dex_strfac.h"
+#include "namemangler.h"
+
+namespace maple {
+std::string DexStrFactory::GetStringFactoryFuncname(const std::string &funcName) {
+#define STR_STRFAC_MAP2(N1, N2)                                                  \
+  if (funcName.compare(N1) == 0) {                                              \
+    return N2;                                                                  \
+  }
+#include "dex_strfac_map.def"
+#undef STR_STRFAC_MAP2
+  return "";
+}
+
+bool DexStrFactory::IsStringInit(const std::string &funcName) {
+  const std::string &mplName = "Ljava/lang/String;|<init>";
+  if (funcName.compare(0, mplName.length(), mplName) == 0) {
+    return true;
+  }
+  return false;
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/bytecode_input/dex/src/dexfile_factory.cpp b/src/hir2mpl/bytecode_input/dex/src/dexfile_factory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6d292b5d3493e58a12558d7d983e957b9c4eba8d
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dexfile_factory.cpp
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dexfile_factory.h"
+#include "dexfile_libdexfile.h"
+
+namespace maple {
+std::unique_ptr<IDexFile> DexFileFactory::NewInstance() const {
+  return std::make_unique<LibDexFile>();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/dex/src/dexfile_interface.cpp b/src/hir2mpl/bytecode_input/dex/src/dexfile_interface.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3027b0ce7182ba0c657d0a355e66b1dc1ab9fce6
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dexfile_interface.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dexfile_interface.h"
+#include "mpl_logging.h"
+
+namespace maple{
+void ResolvedMethodType::SignatureTypes(const std::string &mt, std::list<std::string> &types) {
+  // three pointers linear scan algo
+  size_t startPos = 1;  // pos 0 should be '('
+  size_t currentPos = startPos;
+  size_t endPos = mt.find(")");
+  CHECK_FATAL(endPos != std::string::npos, "(ToIDEUser)Invalid string format: %s", mt.c_str());
+  CHECK_FATAL(startPos <= endPos, "(ToIDEUser)Invalid string format: %s", mt.c_str());
+  while (startPos < endPos) {
+    switch (mt[currentPos]) {
+      case 'I':
+      case 'Z':
+      case 'B':
+      case 'C':
+      case 'V':
+      case 'S':
+      case 'J':
+      case 'F':
+      case 'D': {
+        types.push_back(namemangler::EncodeName(mt.substr(startPos, currentPos - startPos + 1)));
+        ++currentPos;
+        break;
+      }
+      case '[':
+        ++currentPos;
+        continue;
+      case 'L':
+        while (mt[currentPos++] != ';') {}  // empty
+        types.push_back(namemangler::EncodeName(mt.substr(startPos, currentPos - startPos)));
+        break;
+      default:
+        std::cerr << "ResolvedMethodType: catastrophic error" << std::endl;
+        break;
+    }
+    startPos = currentPos;
+  }
+}
+
+std::string ResolvedMethodType::SignatureReturnType(const std::string &mt) {
+  size_t endPos = mt.find(")");
+  return namemangler::EncodeName(mt.substr(endPos + 1));
+}
+}  // namespace maple
diff --git a/src/hir2mpl/bytecode_input/dex/src/dexfile_libdexfile.cpp b/src/hir2mpl/bytecode_input/dex/src/dexfile_libdexfile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4f5d067a1092577503c3f69fe54b814f81f0173e
--- /dev/null
+++ b/src/hir2mpl/bytecode_input/dex/src/dexfile_libdexfile.cpp
@@ -0,0 +1,1704 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dexfile_libdexfile.h"
+#include <cstring>
+#include <unistd.h>
+#include <fcntl.h>
+#include <memory>
+#include <sys/stat.h>
+#include <iostream>
+#ifdef DARWIN
+#include <malloc/malloc.h>
+#else
+#include <malloc.h>
+#endif
+
+#include <base/leb128.h>
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/stringprintf.h>
+#include <dex/class_accessor-inl.h>
+#include <dex/code_item_accessors-inl.h>
+#include <dex/dex_file-inl.h>
+#include <dex/dex_file_exception_helpers.h>
+#include <dex/dex_file_loader.h>
+#include <dex/dex_file_types.h>
+#include <dex/dex_instruction-inl.h>
+#include "securec.h"
+
+std::ostream &art::operator<<(std::ostream &os, const art::Instruction::Format &format) {
+  switch (format) {
+    case art::Instruction::k10x: {
+      os << "k10x";
+      break;
+    }
+    case art::Instruction::k12x: {
+      os << "k12x";
+      break;
+    }
+    case art::Instruction::k11n: {
+      os << "k11n";
+      break;
+    }
+    case art::Instruction::k11x: {
+      os << "k11x";
+      break;
+    }
+    case art::Instruction::k10t: {
+      os << "k10t";
+      break;
+    }
+    case art::Instruction::k20t: {
+      os << "k20t";
+      break;
+    }
+    case art::Instruction::k22x: {
+      os << "k22x";
+      break;
+    }
+    case art::Instruction::k21t: {
+      os << "k21t";
+      break;
+    }
+    case art::Instruction::k21s: {
+      os << "k21s";
+      break;
+    }
+    case art::Instruction::k21h: {
+      os << "k21h";
+      break;
+    }
+    case art::Instruction::k21c: {
+      os << "k21c";
+      break;
+    }
+    case art::Instruction::k23x: {
+      os << "k23x";
+      break;
+    }
+    case art::Instruction::k22b: {
+      os << "k22b";
+      break;
+    }
+    case art::Instruction::k22t: {
+      os << "k22t";
+      break;
+    }
+    case art::Instruction::k22s: {
+      os << "k22s";
+      break;
+    }
+    case art::Instruction::k22c: {
+      os << "k22c";
+      break;
+    }
+    case art::Instruction::k32x: {
+      os << "k32x";
+      break;
+    }
+    case art::Instruction::k30t: {
+      os << "k30t";
+      break;
+    }
+    case art::Instruction::k31t: {
+      os << "k31t";
+      break;
+    }
+    case art::Instruction::k31i: {
+      os << "k31i";
+      break;
+    }
+    case art::Instruction::k31c: {
+      os << "k31c";
+      break;
+    }
+    case art::Instruction::k35c: {
+      os << "k35c";
+      break;
+    }
+    case art::Instruction::k3rc: {
+      os << "k3rc";
+      break;
+    }
+    case art::Instruction::k45cc: {
+      os << "k45cc";
+      break;
+    }
+    case art::Instruction::k4rcc: {
+      os << "k4rcc";
+      break;
+    }
+    case art::Instruction::k51l: {
+      os << "k51l";
+      break;
+    }
+    default: {
+      os << "unknown";
+    }
+  }
+  return os;
+}
+
+std::ostream &art::operator<<(std::ostream &os, const art::EncodedArrayValueIterator::ValueType &code) {
+  switch (code) {
+    case art::EncodedArrayValueIterator::ValueType::kByte: {
+      os << "Byte";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kShort: {
+      os << "Short";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kChar: {
+      os << "Char";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kInt: {
+      os << "Int";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kLong: {
+      os << "Long";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kFloat: {
+      os << "Float";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kDouble: {
+      os << "Double";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kMethodType: {
+      os << "MethodType";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kMethodHandle: {
+      os << "MethodHandle";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kString: {
+      os << "String";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kType: {
+      os << "Type";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kField: {
+      os << "Field";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kMethod: {
+      os << "Method";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kEnum: {
+      os << "Enum";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kArray: {
+      os << "Array";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kAnnotation: {
+      os << "Annotation";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kNull: {
+      os << "Null";
+      break;
+    }
+    case art::EncodedArrayValueIterator::ValueType::kBoolean: {
+      os << "Boolean";
+      break;
+    }
+    default: {
+      os << "Unknown type (" << static_cast<int>(code) << ")";
+    }
+  }
+  return os;
+}
+
+namespace maple {
+const size_t kDexFileVersionStringLength = 3;
+// =====DexInstruction start======
+DexInstruction::DexInstruction(const art::Instruction &artInstruction)
+    : opcode(kOpNop),
+      indexType(kIDexIndexUnknown),
+      vA(UINT32_MAX),
+      vB(UINT32_MAX),
+      vBWide(UINT32_MAX),
+      vC(UINT32_MAX),
+      vH(UINT32_MAX),
+      artInstruction(&artInstruction) {}
+
+IDexOpcode DexInstruction::GetOpcode() const {
+  return opcode;
+}
+
+const char *DexInstruction::GetOpcodeName() const {
+  IDexOpcode iOpcode = GetOpcode();
+  const art::Instruction::Code &artCode = art::Instruction::Code(static_cast<uint8_t>(iOpcode));
+  return art::Instruction::Name(artCode);
+}
+
+uint32_t DexInstruction::GetVRegA() const {
+  return vA;
+}
+
+uint32_t DexInstruction::GetVRegB() const {
+  return vB;
+}
+
+uint64_t DexInstruction::GetVRegBWide() const {
+  return vBWide;
+}
+
+uint32_t DexInstruction::GetVRegC() const {
+  return vC;
+}
+
+uint32_t DexInstruction::GetVRegH() const {
+  return vH;
+}
+
+uint32_t DexInstruction::GetArg(uint32_t index) const {
+  return arg[index];
+}
+
+IDexInstructionIndexType DexInstruction::GetIndexType() const {
+  return indexType;
+}
+
+IDexInstructionFormat DexInstruction::GetFormat() const {
+  IDexOpcode iOpcode = GetOpcode();
+  art::Instruction::Code artCode = art::Instruction::Code(static_cast<uint8_t>(iOpcode));
+  art::Instruction::Format artFormat = art::Instruction::FormatOf(artCode);
+  IDexInstructionFormat iFormat = static_cast<IDexInstructionFormat>(artFormat);
+  return iFormat;
+}
+
+size_t DexInstruction::GetWidth() const {
+  return artInstruction->SizeInCodeUnits();
+}
+
+void DexInstruction::SetOpcode(IDexOpcode iOpCode) {
+  opcode = iOpCode;
+}
+
+void DexInstruction::SetVRegB(uint32_t vRegB) {
+  vB = vRegB;
+}
+
+void DexInstruction::SetVRegBWide(uint64_t vRegBWide) {
+  vBWide = vRegBWide;
+}
+
+void DexInstruction::SetIndexType(IDexInstructionIndexType iIndexType) {
+  indexType = iIndexType;
+}
+
+void DexInstruction::Init() {
+  art::Instruction::Code artCode = artInstruction->Opcode();
+  opcode = static_cast<IDexOpcode>(artCode);
+  if (artInstruction->HasVRegA()) {
+    vA = artInstruction->VRegA();
+  }
+  if (artInstruction->HasVRegB() && !artInstruction->HasWideVRegB()) {
+    vB = artInstruction->VRegB();
+  }
+  if (artInstruction->HasWideVRegB()) {
+    vBWide = artInstruction->WideVRegB();
+  }
+  if (artInstruction->HasVRegC()) {
+    vC = artInstruction->VRegC();
+  }
+  if (artInstruction->HasVRegH()) {
+    vH = artInstruction->VRegH();
+  }
+  if (artInstruction->HasVarArgs()) {
+    (void)artInstruction->GetVarArgs(arg);
+  }
+  if ((artInstruction->Opcode() == art::Instruction::INVOKE_POLYMORPHIC) ||
+      (artInstruction->Opcode() == art::Instruction::INVOKE_POLYMORPHIC_RANGE)) {
+    for (uint32_t i = 1; i < art::Instruction::kMaxVarArgRegs; i++) {
+      arg[i - 1] = arg[i];
+    }
+  }
+  art::Instruction::IndexType artIndexType = art::Instruction::IndexTypeOf(artCode);
+  indexType = static_cast<IDexInstructionIndexType>(artIndexType);
+}
+
+bool DexInstruction::HasVRegA() const {
+  return artInstruction->HasVRegA();
+}
+
+bool DexInstruction::HasVRegB() const {
+  return artInstruction->HasVRegB();
+}
+
+bool DexInstruction::HasWideVRegB() const {
+  return artInstruction->HasWideVRegB();
+}
+
+bool DexInstruction::HasVRegC() const {
+  return artInstruction->HasVRegC();
+}
+
+bool DexInstruction::HasVRegH() const {
+  return artInstruction->HasVRegH();
+}
+
+bool DexInstruction::HasArgs() const {
+  return artInstruction->HasVarArgs();
+}
+// =====DexInstruction end================
+// =====IDexCatchHandlerItem start=========
+const art::DexFile *GetDexFile(const IDexFile &dexFile) {
+  return reinterpret_cast<const art::DexFile*>(dexFile.GetData());
+}
+
+const art::dex::ClassDef *GetClassDef(const IDexClassItem *item) {
+  return reinterpret_cast<const art::dex::ClassDef*>(item);
+}
+
+uint32_t IDexCatchHandlerItem::GetHandlerTypeIdx() const {
+  return typeIdx;
+}
+
+uint32_t IDexCatchHandlerItem::GetHandlerAddress() const {
+  return address;
+}
+
+bool IDexCatchHandlerItem::IsCatchAllHandlerType() const {
+  return (typeIdx == art::DexFile::kDexNoIndex16);
+}
+// =====IDexCatchHandlerItem end===========
+// =====IDexTryItem start==================
+const art::dex::TryItem *GetTryItem(const IDexTryItem *item) {
+  return reinterpret_cast<const art::dex::TryItem*>(item);
+}
+
+const IDexTryItem *IDexTryItem::GetInstance(const void *item) {
+  return reinterpret_cast<const IDexTryItem*>(item);
+}
+
+uint32_t IDexTryItem::GetStartAddr() const {
+  return GetTryItem(this)->start_addr_;
+}
+
+uint32_t IDexTryItem::GetEndAddr() const {
+  return (GetTryItem(this)->start_addr_ + GetTryItem(this)->insn_count_);
+}
+
+void IDexTryItem::GetCatchHandlerItems(const IDexFile &dexFile, uint32_t codeOff,
+                                       std::vector<IDexCatchHandlerItem> &items) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(codeOff);
+  if (artCodeItem == nullptr) {
+    return;
+  }
+  art::CodeItemDataAccessor accessor(*GetDexFile(dexFile), artCodeItem);
+  art::CatchHandlerIterator handlerIterator(accessor, *GetTryItem(this));
+
+  while (handlerIterator.HasNext()) {
+    art::dex::TypeIndex artTypeIndex = handlerIterator.GetHandlerTypeIndex();
+    uint32_t address = handlerIterator.GetHandlerAddress();
+    uint16_t typeIdx = artTypeIndex.index_;
+    items.emplace_back(IDexCatchHandlerItem(typeIdx, address));
+    handlerIterator.Next();
+  }
+}
+// =====IDexTryItem end=====================
+// =====IDexProtoIdItem start===============
+const art::dex::ProtoId *GetProtoId(const IDexProtoIdItem *item) {
+  return reinterpret_cast<const art::dex::ProtoId*>(item);
+}
+
+const IDexProtoIdItem *GetDexProtoIdInstance(const art::DexFile &dexFile, uint32_t index) {
+  return reinterpret_cast<const IDexProtoIdItem*>(&(dexFile.GetProtoId(art::dex::ProtoIndex(index))));
+}
+
+const IDexProtoIdItem *IDexProtoIdItem::GetInstance(const IDexFile &dexFile, uint32_t index) {
+  return reinterpret_cast<const IDexProtoIdItem*>(&(GetDexFile(dexFile)->GetProtoId(art::dex::ProtoIndex(index))));
+}
+
+const char *IDexProtoIdItem::GetReturnTypeName(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->GetReturnTypeDescriptor(*GetProtoId(this));
+}
+
+uint32_t IDexProtoIdItem::GetParameterTypeSize(const IDexFile &dexFile) const {
+  const art::dex::TypeList *typeList = GetDexFile(dexFile)->GetProtoParameters(*GetProtoId(this));
+  if (typeList == nullptr) {
+    return 0;
+  }
+  return typeList->Size();
+}
+
+void IDexProtoIdItem::GetParameterTypeIndexes(const IDexFile &dexFile, std::vector<uint16_t> &indexes) const {
+  const art::dex::TypeList *typeList = GetDexFile(dexFile)->GetProtoParameters(*GetProtoId(this));
+  if (typeList == nullptr) {
+    return;
+  }
+  for (uint32_t i = 0; i < typeList->Size(); i++) {
+    uint16_t typeIndex = typeList->GetTypeItem(i).type_idx_.index_;
+    indexes.push_back(typeIndex);
+  }
+}
+
+std::string IDexProtoIdItem::GetDescriptor(const IDexFile &dexFile) const {
+  std::string desc = GetDexFile(dexFile)->GetProtoSignature(*GetProtoId(this)).ToString();
+  return desc;
+}
+
+const char *IDexProtoIdItem::GetShorty(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->StringDataByIdx(GetProtoId(this)->shorty_idx_);
+}
+// =====IDexProtoIdItem end=========
+// =====IDexMethodIdItem start======
+const art::dex::MethodId *GetMethodId(const IDexMethodIdItem *item) {
+  return reinterpret_cast<const art::dex::MethodId*>(item);
+}
+
+const IDexMethodIdItem *IDexMethodIdItem::GetInstance(const IDexFile &dexFile, uint32_t index) {
+  return reinterpret_cast<const IDexMethodIdItem*>(&(GetDexFile(dexFile)->GetMethodId(index)));
+}
+
+const IDexMethodIdItem *GetDexMethodIdInstance(const art::DexFile &dexFile, uint32_t index) {
+  return reinterpret_cast<const IDexMethodIdItem*>(&(dexFile.GetMethodId(index)));
+}
+
+uint32_t IDexMethodIdItem::GetClassIdx() const {
+  return GetMethodId(this)->class_idx_.index_;
+}
+
+const char *IDexMethodIdItem::GetDefiningClassName(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->StringByTypeIdx(GetMethodId(this)->class_idx_);
+}
+
+uint16_t IDexMethodIdItem::GetProtoIdx() const {
+  return GetMethodId(this)->proto_idx_.index_;
+}
+
+const IDexProtoIdItem *IDexMethodIdItem::GetProtoIdItem(const IDexFile &dexFile) const {
+  return IDexProtoIdItem::GetInstance(dexFile, GetMethodId(this)->proto_idx_.index_);
+}
+
+uint32_t IDexMethodIdItem::GetNameIdx() const {
+  return GetMethodId(this)->name_idx_.index_;
+}
+
+const char *IDexMethodIdItem::GetShortMethodName(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->StringDataByIdx(GetMethodId(this)->name_idx_);
+}
+
+std::string IDexMethodIdItem::GetDescriptor(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->GetMethodSignature(*GetMethodId(this)).ToString();
+}
+// =====IDexMethodIdItem end========
+// =====IDexMethodItem start========
+const art::ClassAccessor::Method *GetMethod(const IDexMethodItem *item) {
+  return reinterpret_cast<const art::ClassAccessor::Method*>(item);
+}
+
+IDexMethodItem::IDexMethodItem(uint32_t methodIdx, uint32_t accessFlags, uint32_t codeOff)
+    : methodIdx(methodIdx), accessFlags(accessFlags), codeOff(codeOff) {}
+
+uint32_t IDexMethodItem::GetMethodCodeOff(const IDexMethodItem *item) const {
+  (void) item;
+  return codeOff;
+}
+
+uint32_t IDexMethodItem::GetMethodIdx() const {
+  return methodIdx;
+}
+
+const IDexMethodIdItem *IDexMethodItem::GetMethodIdItem(const IDexFile &dexFile) const {
+  return IDexMethodIdItem::GetInstance(dexFile, GetMethodIdx());
+}
+
+uint32_t IDexMethodItem::GetAccessFlags() const {
+  return accessFlags;
+}
+
+bool IDexMethodItem::HasCode(const IDexFile &dexFile) const {
+  art::CodeItemDataAccessor accessor(*GetDexFile(dexFile), GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this)));
+  return accessor.HasCodeItem();
+}
+
+uint16_t IDexMethodItem::GetRegistersSize(const IDexFile &dexFile) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return 0;
+  }
+  art::CodeItemDataAccessor accessor(*GetDexFile(dexFile), artCodeItem);
+  return accessor.RegistersSize();
+}
+
+uint16_t IDexMethodItem::GetInsSize(const IDexFile &dexFile) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return 0;
+  }
+  art::CodeItemDataAccessor accessor(*GetDexFile(dexFile), artCodeItem);
+  return accessor.InsSize();
+}
+
+uint16_t IDexMethodItem::GetOutsSize(const IDexFile &dexFile) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return 0;
+  }
+  art::CodeItemDataAccessor accessor(*GetDexFile(dexFile), artCodeItem);
+  return accessor.OutsSize();
+}
+
+uint16_t IDexMethodItem::GetTriesSize(const IDexFile &dexFile) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return 0;
+  }
+  art::CodeItemDataAccessor accessor(*GetDexFile(dexFile), artCodeItem);
+  return accessor.TriesSize();
+}
+
+uint32_t IDexMethodItem::GetInsnsSize(const IDexFile &dexFile) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return 0;
+  }
+  art::CodeItemDataAccessor accessor(*GetDexFile(dexFile), artCodeItem);
+  return accessor.InsnsSizeInCodeUnits();
+}
+
+const uint16_t *IDexMethodItem::GetInsnsByOffset(const IDexFile &dexFile, uint32_t offset) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return nullptr;
+  }
+  art::CodeItemDataAccessor accessor(*GetDexFile(dexFile), artCodeItem);
+  return (accessor.Insns() + offset);
+}
+
+uint32_t IDexMethodItem::GetCodeOff() const {
+  return GetMethodCodeOff(this);
+}
+
+bool IDexMethodItem::IsStatic() const {
+  bool isStatic = ((GetAccessFlags() & art::kAccStatic) > 0) ? true : false;
+  return isStatic;
+}
+
+void IDexMethodItem::GetPCInstructionMap(const IDexFile &dexFile,
+                                         std::map<uint32_t, std::unique_ptr<IDexInstruction>> &pcInstructionMap) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return;
+  }
+  std::unique_ptr<art::CodeItemDataAccessor> artCodeItemDataAccessor =
+    std::make_unique<art::CodeItemDataAccessor>(*GetDexFile(dexFile), artCodeItem);
+  art::CodeItemDataAccessor &accessor = *(artCodeItemDataAccessor.get());
+
+  for (const art::DexInstructionPcPair &pair : accessor) {
+    uint32_t dexPc = pair.DexPc();
+    const art::Instruction &instruction = pair.Inst();
+    std::unique_ptr<DexInstruction> dexInstruction = std::make_unique<DexInstruction>(instruction);
+    dexInstruction->Init();
+    pcInstructionMap[dexPc] = std::move(dexInstruction);
+  }
+}
+
+void IDexMethodItem::GetTryItems(const IDexFile &dexFile, std::vector<const IDexTryItem*> &tryItems) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return;
+  }
+  art::CodeItemDataAccessor accessor(*GetDexFile(dexFile), artCodeItem);
+  uint32_t triesSize = accessor.TriesSize();
+  if (triesSize == 0) {
+    return;
+  }
+  const art::dex::TryItem *artTryItems = accessor.TryItems().begin();
+  for (uint32_t tryIndex = 0; tryIndex < triesSize; tryIndex++) {
+    const art::dex::TryItem *artTry = artTryItems + tryIndex;
+    tryItems.push_back(IDexTryItem::GetInstance(artTry));
+  }
+}
+
+void IDexMethodItem::GetSrcPositionInfo(const IDexFile &dexFile, std::map<uint32_t, uint32_t> &srcPosInfo) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return;
+  }
+  art::CodeItemDebugInfoAccessor accessor(*GetDexFile(dexFile), artCodeItem, GetMethodIdx());
+  bool succ = accessor.DecodeDebugPositionInfo([&](const art::DexFile::PositionInfo& entry) {
+    srcPosInfo.emplace(entry.address_, entry.line_);
+    return false;
+  });
+  if (!succ) {
+    LOG(ERROR) << "ReadFileToString failed";
+    return;
+  }
+}
+
+void IDexMethodItem::GetSrcLocalInfo(const IDexFile &dexFile,
+    std::map<uint16_t, std::set<std::tuple<std::string, std::string, std::string>>> &srcLocal) const {
+  const art::dex::CodeItem *artCodeItem = GetDexFile(dexFile)->GetCodeItem(GetMethodCodeOff(this));
+  if (artCodeItem == nullptr) {
+    return;
+  }
+  art::CodeItemDebugInfoAccessor accessor(*GetDexFile(dexFile), artCodeItem, this->GetMethodIdx());
+  (void)accessor.DecodeDebugLocalInfo(this->IsStatic(), this->GetMethodIdx(),
+                                      [&](const art::DexFile::LocalInfo &entry) {
+    if (entry.name_ != nullptr && entry.descriptor_ != nullptr) {
+      std::string signature = entry.signature_ != nullptr ? entry.signature_ : "";
+      auto item = std::make_tuple(entry.name_, entry.descriptor_, signature);
+      srcLocal[entry.reg_].insert(item);
+    }
+  });
+}
+// =====IDexMethodItem end==========
+// =====IDexFieldIdItem start=======
+const art::dex::FieldId *GetFieldId(const IDexFieldIdItem *item) {
+  return reinterpret_cast<const art::dex::FieldId*>(item);
+}
+
+const IDexFieldIdItem *IDexFieldIdItem::GetInstance(const IDexFile &dexFile, uint32_t index) {
+  return reinterpret_cast<const IDexFieldIdItem*>(&(GetDexFile(dexFile)->GetFieldId(index)));
+}
+
+const IDexFieldIdItem *GetDexFieldIdInstance(const art::DexFile &dexFile, uint32_t index) {
+  return reinterpret_cast<const IDexFieldIdItem*>(&(dexFile.GetFieldId(index)));
+}
+
+uint32_t IDexFieldIdItem::GetClassIdx() const {
+  return GetFieldId(this)->class_idx_.index_;
+}
+
+const char *IDexFieldIdItem::GetDefiningClassName(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->StringByTypeIdx(GetFieldId(this)->class_idx_);
+}
+
+uint32_t IDexFieldIdItem::GetTypeIdx() const {
+  return GetFieldId(this)->type_idx_.index_;
+}
+
+const char *IDexFieldIdItem::GetFieldTypeName(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->StringByTypeIdx(GetFieldId(this)->type_idx_);
+}
+
+uint32_t IDexFieldIdItem::GetNameIdx() const {
+  return GetFieldId(this)->name_idx_.index_;
+}
+
+const char *IDexFieldIdItem::GetShortFieldName(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->StringDataByIdx(GetFieldId(this)->name_idx_);
+}
+// =====IDexFieldIdItem end=========
+// =====IDexFieldItem start=========
+IDexFieldItem::IDexFieldItem(uint32_t fieldIndex, uint32_t accessFlags)
+    : fieldIndex(fieldIndex), accessFlags(accessFlags) {}
+
+uint32_t IDexFieldItem::GetFieldIdx() const {
+  return fieldIndex;
+}
+
+const IDexFieldIdItem *IDexFieldItem::GetFieldIdItem(const IDexFile &dexFile) const {
+  return IDexFieldIdItem::GetInstance(dexFile, GetFieldIdx());
+}
+
+uint32_t IDexFieldItem::GetAccessFlags() const {
+  return accessFlags;
+}
+// =====IDexFieldItem end===========
+// =====IDexAnnotation start========
+const art::dex::AnnotationItem *GetAnnotationItem(const IDexAnnotation *item) {
+  return reinterpret_cast<const art::dex::AnnotationItem*>(item);
+}
+
+const IDexAnnotation *IDexAnnotation::GetInstance(const void *data) {
+  return reinterpret_cast<const IDexAnnotation*>(data);
+}
+
+uint8_t IDexAnnotation::GetVisibility() const {
+  return GetAnnotationItem(this)->visibility_;
+}
+
+const uint8_t *IDexAnnotation::GetAnnotationData() const {
+  return GetAnnotationItem(this)->annotation_;
+}
+// =====IDexAnnotation end==========
+// =====IDexAnnotationSet start=====
+const art::dex::AnnotationSetItem *GetAnnotationSet(const IDexAnnotationSet *item) {
+  return reinterpret_cast<const art::dex::AnnotationSetItem*>(item);
+}
+
+const IDexAnnotationSet *IDexAnnotationSet::GetInstance(const void *data) {
+  return reinterpret_cast<const IDexAnnotationSet*>(data);
+}
+
+void IDexAnnotationSet::GetAnnotations(const IDexFile &dexFile, std::vector<const IDexAnnotation*> &items) const {
+  if (!IsValid()) {
+    return;
+  }
+
+  for (uint32_t i = 0; i < GetAnnotationSet(this)->size_; i++) {
+    const art::dex::AnnotationItem *artAnnotationItem =
+        GetDexFile(dexFile)->GetAnnotationItem(GetAnnotationSet(this), i);
+    items.push_back(IDexAnnotation::GetInstance(artAnnotationItem));
+  }
+}
+
+bool IDexAnnotationSet::IsValid() const {
+  return (GetAnnotationSet(this) != nullptr) && (GetAnnotationSet(this)->size_ > 0);
+}
+// =====IDexAnnotationSet end==========
+// =====IDexAnnotationSetList start====
+const art::dex::AnnotationSetRefList *GetAnnotationSetList(const IDexAnnotationSetList *list) {
+  return reinterpret_cast<const art::dex::AnnotationSetRefList*>(list);
+}
+
+const IDexAnnotationSetList *IDexAnnotationSetList::GetInstance(const void *data) {
+  return reinterpret_cast<const IDexAnnotationSetList*>(data);
+}
+
+void IDexAnnotationSetList::GetAnnotationSets(const IDexFile &dexFile,
+                                              std::vector<const IDexAnnotationSet*> &items) const {
+  for (uint32_t i = 0; i < GetAnnotationSetList(this)->size_; i++) {
+    const art::dex::AnnotationSetItem *setItem =
+        GetDexFile(dexFile)->GetSetRefItemItem(GetAnnotationSetList(this)->list_ + i);
+    // setItem == nullptr is a valid parameter, will check valid in later using.
+    items.push_back(IDexAnnotationSet::GetInstance(setItem));
+  }
+}
+// =====IDexAnnotationSetList end======
+// =====IDexFieldAnnotations start=====
+const art::dex::FieldAnnotationsItem *GetFieldAnnotations(const IDexFieldAnnotations *item) {
+  return reinterpret_cast<const art::dex::FieldAnnotationsItem*>(item);
+}
+
+const IDexFieldAnnotations *IDexFieldAnnotations::GetInstance(const void *data) {
+  return reinterpret_cast<const IDexFieldAnnotations*>(data);
+}
+
+const IDexFieldIdItem *IDexFieldAnnotations::GetFieldIdItem(const IDexFile &dexFile) const {
+  return IDexFieldIdItem::GetInstance(dexFile, GetFieldAnnotations(this)->field_idx_);
+}
+
+const IDexAnnotationSet *IDexFieldAnnotations::GetAnnotationSet(const IDexFile &dexFile) const {
+  const art::dex::AnnotationSetItem *artAnnotationSet =
+      GetDexFile(dexFile)->GetFieldAnnotationSetItem(*GetFieldAnnotations(this));
+  // artAnnotationSet == nullptr is a valid parameter, will check valid in later using.
+  return IDexAnnotationSet::GetInstance(artAnnotationSet);
+}
+
+uint32_t IDexFieldAnnotations::GetFieldIdx() const {
+  return GetFieldAnnotations(this)->field_idx_;
+}
+// =====IDexFieldAnnotations end=======
+// =====IDexMethodAnnotations start====
+const art::dex::MethodAnnotationsItem *GetMethodAnnotations(const IDexMethodAnnotations *item) {
+  return reinterpret_cast<const art::dex::MethodAnnotationsItem*>(item);
+}
+
+const IDexMethodAnnotations *IDexMethodAnnotations::GetInstance(const void *data) {
+  return reinterpret_cast<const IDexMethodAnnotations*>(data);
+}
+
+const IDexMethodIdItem *IDexMethodAnnotations::GetMethodIdItem(const IDexFile &dexFile) const {
+  return IDexMethodIdItem::GetInstance(dexFile, GetMethodAnnotations(this)->method_idx_);
+}
+
+const IDexAnnotationSet *IDexMethodAnnotations::GetAnnotationSet(const IDexFile &dexFile) const {
+  const art::dex::AnnotationSetItem *artAnnotationSetItem =
+      GetDexFile(dexFile)->GetMethodAnnotationSetItem(*GetMethodAnnotations(this));
+  // artAnnotationSetItem == nullptr is a valid parameter, will check valid in later using.
+  return IDexAnnotationSet::GetInstance(artAnnotationSetItem);
+}
+
+uint32_t IDexMethodAnnotations::GetMethodIdx() const {
+  return GetMethodAnnotations(this)->method_idx_;
+}
+// =====IDexMethodAnnotations end========
+// =====IDexParameterAnnotations start===
+const art::dex::ParameterAnnotationsItem *GetParameterAnnotations(const IDexParameterAnnotations *item) {
+  return reinterpret_cast<const art::dex::ParameterAnnotationsItem*>(item);
+}
+
+const IDexParameterAnnotations *IDexParameterAnnotations::GetInstance(const void *data) {
+  return reinterpret_cast<const IDexParameterAnnotations*>(data);
+}
+
+const IDexMethodIdItem *IDexParameterAnnotations::GetMethodIdItem(const IDexFile &dexFile) const {
+  return IDexMethodIdItem::GetInstance(dexFile, GetMethodIdx());
+}
+
+const IDexAnnotationSetList *IDexParameterAnnotations::GetAnnotationSetList(const IDexFile &dexFile) const {
+  const art::dex::AnnotationSetRefList *setRefList =
+      GetDexFile(dexFile)->GetParameterAnnotationSetRefList(GetParameterAnnotations(this));
+  if (setRefList == nullptr) {
+    return nullptr;
+  } else {
+    return IDexAnnotationSetList::GetInstance(setRefList);
+  }
+}
+
+uint32_t IDexParameterAnnotations::GetMethodIdx() const {
+  return GetParameterAnnotations(this)->method_idx_;
+}
+// =====IDexParameterAnnotations end=====
+// =====IDexAnnotationsDirectory start===
+const art::dex::AnnotationsDirectoryItem *GetAnnotationsDirectory(const IDexAnnotationsDirectory *item) {
+  return reinterpret_cast<const art::dex::AnnotationsDirectoryItem*>(item);
+}
+
+const IDexAnnotationsDirectory *IDexAnnotationsDirectory::GetInstance(const void *data) {
+  return reinterpret_cast<const IDexAnnotationsDirectory*>(data);
+}
+
+bool IDexAnnotationsDirectory::HasClassAnnotationSet(const IDexFile &dexFile) const {
+  const art::dex::AnnotationSetItem *classAnnotationSetItem =
+      GetDexFile(dexFile)->GetClassAnnotationSet(GetAnnotationsDirectory(this));
+  return classAnnotationSetItem != nullptr;
+}
+
+bool IDexAnnotationsDirectory::HasFieldAnnotationsItems(const IDexFile &dexFile) const {
+  const art::dex::FieldAnnotationsItem *artFieldAnnotationsItem =
+      GetDexFile(dexFile)->GetFieldAnnotations(GetAnnotationsDirectory(this));
+  return artFieldAnnotationsItem != nullptr;
+}
+
+bool IDexAnnotationsDirectory::HasMethodAnnotationsItems(const IDexFile &dexFile) const {
+  const art::dex::MethodAnnotationsItem *artMethodAnnotationsItem =
+      GetDexFile(dexFile)->GetMethodAnnotations(GetAnnotationsDirectory(this));
+  return artMethodAnnotationsItem != nullptr;
+}
+
+bool IDexAnnotationsDirectory::HasParameterAnnotationsItems(const IDexFile &dexFile) const {
+  const art::dex::ParameterAnnotationsItem *parameterItem =
+      GetDexFile(dexFile)->GetParameterAnnotations(GetAnnotationsDirectory(this));
+  return parameterItem != nullptr;
+}
+
+const IDexAnnotationSet *IDexAnnotationsDirectory::GetClassAnnotationSet(const IDexFile &dexFile) const {
+  const art::dex::AnnotationSetItem *classAnnotationSetItem =
+      GetDexFile(dexFile)->GetClassAnnotationSet(GetAnnotationsDirectory(this));
+  // classAnnotationSetItem == nullptr is a valid parameter, will check valid in later using.
+  return IDexAnnotationSet::GetInstance(classAnnotationSetItem);
+}
+
+void IDexAnnotationsDirectory::GetFieldAnnotationsItems(const IDexFile &dexFile,
+                                                        std::vector<const IDexFieldAnnotations*> &items) const {
+  const art::dex::FieldAnnotationsItem *artFieldAnnotationsItem =
+      GetDexFile(dexFile)->GetFieldAnnotations(GetAnnotationsDirectory(this));
+  if (artFieldAnnotationsItem == nullptr) {
+    return;
+  }
+  for (uint32_t i = 0; i < GetAnnotationsDirectory(this)->fields_size_; i++) {
+    items.push_back(IDexFieldAnnotations::GetInstance(artFieldAnnotationsItem + i));
+  }
+}
+
+void IDexAnnotationsDirectory::GetMethodAnnotationsItems(const IDexFile &dexFile,
+                                                         std::vector<const IDexMethodAnnotations*> &items) const {
+  const art::dex::MethodAnnotationsItem *artMethodAnnotationsItem =
+      GetDexFile(dexFile)->GetMethodAnnotations(GetAnnotationsDirectory(this));
+  if (artMethodAnnotationsItem == nullptr) {
+    return;
+  }
+  for (uint32_t i = 0; i < GetAnnotationsDirectory(this)->methods_size_; i++) {
+    items.push_back(IDexMethodAnnotations::GetInstance(artMethodAnnotationsItem + i));
+  }
+}
+
+void IDexAnnotationsDirectory::GetParameterAnnotationsItems(const IDexFile &dexFile,
+                                                            std::vector<const IDexParameterAnnotations*> &items)
+                                                            const {
+  const art::dex::ParameterAnnotationsItem *parameterItem =
+      GetDexFile(dexFile)->GetParameterAnnotations(GetAnnotationsDirectory(this));
+  if (parameterItem == nullptr) {
+    return;
+  }
+  for (uint32_t i = 0; i < GetAnnotationsDirectory(this)->parameters_size_; i++) {
+    items.push_back(IDexParameterAnnotations::GetInstance(parameterItem + i));
+  }
+}
+// =====IDexAnnotationsDirectory end=====
+// =====IDexClassItem start==============
+const IDexClassItem *GetDexClassInstance(const art::DexFile &dexFile, uint32_t index) {
+  return reinterpret_cast<const IDexClassItem*>(&(dexFile.GetClassDef(index)));
+}
+
+uint32_t IDexClassItem::GetClassIdx() const {
+  return GetClassDef(this)->class_idx_.index_;
+}
+
+const char *IDexClassItem::GetClassName(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->StringByTypeIdx(GetClassDef(this)->class_idx_);
+}
+
+uint32_t IDexClassItem::GetAccessFlags() const {
+  return GetClassDef(this)->access_flags_;
+}
+
+uint32_t IDexClassItem::GetSuperclassIdx() const {
+  return GetClassDef(this)->superclass_idx_.index_;
+}
+
+const char *IDexClassItem::GetSuperClassName(const IDexFile &dexFile) const {
+  if (!GetClassDef(this)->superclass_idx_.IsValid()) {
+    return nullptr;
+  }
+  return GetDexFile(dexFile)->StringByTypeIdx(GetClassDef(this)->superclass_idx_);
+}
+
+uint32_t IDexClassItem::GetInterfacesOff() const {
+  return GetClassDef(this)->interfaces_off_;
+}
+
+void IDexClassItem::GetInterfaceTypeIndexes(const IDexFile &dexFile, std::vector<uint16_t> &indexes) const {
+  const art::dex::TypeList *interfaces = GetDexFile(dexFile)->GetInterfacesList(*GetClassDef(this));
+  if (interfaces == nullptr) {
+    return;
+  }
+  for (uint32_t i = 0; i < interfaces->Size(); i++) {
+    const art::dex::TypeItem &typeItem = interfaces->GetTypeItem(i);
+    art::dex::TypeIndex artTypeIndex = typeItem.type_idx_;
+    indexes.push_back(artTypeIndex.index_);
+  }
+}
+
+void IDexClassItem::GetInterfaceNames(const IDexFile &dexFile, std::vector<const char*> &names) const {
+  const art::dex::TypeList *interfaces = GetDexFile(dexFile)->GetInterfacesList(*GetClassDef(this));
+  if (interfaces == nullptr) {
+    return;
+  }
+  for (uint32_t i = 0; i < interfaces->Size(); i++) {
+    const art::dex::TypeItem &typeItem = interfaces->GetTypeItem(i);
+    art::dex::TypeIndex artTypeIndex = typeItem.type_idx_;
+    const char *interfaceName = GetDexFile(dexFile)->StringByTypeIdx(artTypeIndex);
+    names.push_back(interfaceName);
+  }
+}
+
+uint32_t IDexClassItem::GetSourceFileIdx() const {
+  return GetClassDef(this)->source_file_idx_.index_;
+}
+
+const char *IDexClassItem::GetJavaSourceFileName(const IDexFile &dexFile) const {
+  if (GetClassDef(this)->source_file_idx_.index_ == art::dex::kDexNoIndex) {
+    return nullptr;
+  }
+  return GetDexFile(dexFile)->StringDataByIdx(GetClassDef(this)->source_file_idx_);
+}
+
+bool IDexClassItem::HasAnnotationsDirectory(const IDexFile &dexFile) const {
+  return (GetDexFile(dexFile)->GetAnnotationsDirectory(*GetClassDef(this)) != nullptr);
+}
+
+uint32_t IDexClassItem::GetAnnotationsOff() const {
+  return GetClassDef(this)->annotations_off_;
+}
+
+const IDexAnnotationsDirectory *IDexClassItem::GetAnnotationsDirectory(const IDexFile &dexFile) const {
+  const art::dex::AnnotationsDirectoryItem *artDirectoryItem =
+      GetDexFile(dexFile)->GetAnnotationsDirectory(*GetClassDef(this));
+  if (artDirectoryItem == nullptr) {
+    return nullptr;
+  } else {
+    return IDexAnnotationsDirectory::GetInstance(artDirectoryItem);
+  }
+}
+
+uint32_t IDexClassItem::GetClassDataOff() const {
+  return GetClassDef(this)->class_data_off_;
+}
+
+std::vector<std::unique_ptr<IDexFieldItem>> IDexClassItem::GetFields(const IDexFile &dexFile) const {
+  std::vector<std::unique_ptr<IDexFieldItem>> fields;
+  art::ClassAccessor accessor(*GetDexFile(dexFile), *GetClassDef(this));
+  for (const art::ClassAccessor::Field &field : accessor.GetFields()) {
+    uint32_t fieldIdx = field.GetIndex();
+    uint32_t accessFlags = field.GetAccessFlags();
+    std::unique_ptr<IDexFieldItem> dexFieldItem = std::make_unique<IDexFieldItem>(fieldIdx, accessFlags);
+    fields.push_back(std::move(dexFieldItem));
+  }
+  return fields;
+}
+
+bool IDexClassItem::HasStaticValuesList() const {
+  return (GetClassDef(this)->static_values_off_ != 0);
+}
+
+const uint8_t *IDexClassItem::GetStaticValuesList(const IDexFile &dexFile) const {
+  return GetDexFile(dexFile)->GetEncodedStaticFieldValuesArray(*GetClassDef(this));
+}
+
+bool IDexClassItem::IsInterface() const {
+  bool isInterface = ((GetAccessFlags() & art::kAccInterface) > 0) ? true : false;
+  return isInterface;
+}
+
+bool IDexClassItem::IsSuperclassValid() const {
+  const art::dex::ClassDef *artClassDef = GetClassDef(this);
+  return artClassDef->superclass_idx_.IsValid();
+}
+
+std::vector<std::pair<uint32_t, uint32_t>> IDexClassItem::GetMethodsIdxAndFlag(const IDexFile &dexFile,
+    bool isVirtual) const {
+  std::vector<std::pair<uint32_t, uint32_t>> methodsIdx;
+  art::ClassAccessor accessor(*GetDexFile(dexFile), *GetClassDef(this));
+  if (isVirtual) {
+    for (const art::ClassAccessor::Method &method : accessor.GetVirtualMethods()) {
+      methodsIdx.push_back(std::make_pair(method.GetIndex(), method.GetAccessFlags()));
+    }
+  } else {
+    for (const art::ClassAccessor::Method &method : accessor.GetDirectMethods()) {
+      methodsIdx.push_back(std::make_pair(method.GetIndex(), method.GetAccessFlags()));
+    }
+  }
+  return methodsIdx;
+}
+
+std::unique_ptr<IDexMethodItem> IDexClassItem::GetDirectMethod(const IDexFile &dexFile, uint32_t index) const {
+  art::ClassAccessor accessor(*GetDexFile(dexFile), *GetClassDef(this));
+  auto directMethodIt = accessor.GetDirectMethods().begin();
+  for (uint32_t i = 0; i < index; ++i) {
+    ++directMethodIt;
+  }
+  std::unique_ptr<IDexMethodItem> dexMethodItem = std::make_unique<IDexMethodItem>(directMethodIt->GetIndex(),
+      directMethodIt->GetAccessFlags(), directMethodIt->GetCodeItemOffset());
+  return dexMethodItem;
+}
+
+std::unique_ptr<IDexMethodItem> IDexClassItem::GetVirtualMethod(const IDexFile &dexFile, uint32_t index) const {
+  art::ClassAccessor accessor(*GetDexFile(dexFile), *GetClassDef(this));
+  auto virtualMethodIt = accessor.GetVirtualMethods().begin();
+  for (uint32_t i = 0; i < index; ++i) {
+    ++virtualMethodIt;
+  }
+  std::unique_ptr<IDexMethodItem> dexMethodItem = std::make_unique<IDexMethodItem>(virtualMethodIt->GetIndex(),
+      virtualMethodIt->GetAccessFlags(), virtualMethodIt->GetCodeItemOffset());
+  return dexMethodItem;
+}
+// =====IDexClassItem end================
+// =====Header start====================
+const art::DexFile *GetDexFile(const IDexHeader *header) {
+  return reinterpret_cast<const art::DexFile*>(header);
+}
+
+const IDexHeader *IDexHeader::GetInstance(const IDexFile &dexFile) {
+  return reinterpret_cast<const IDexHeader*>(dexFile.GetData());
+}
+
+uint8_t IDexHeader::GetMagic(uint32_t index) const {
+  return GetDexFile(this)->GetHeader().magic_[index];
+}
+
+uint32_t IDexHeader::GetChecksum() const {
+  return GetDexFile(this)->GetHeader().checksum_;
+}
+
+std::string IDexHeader::GetSignature() const {
+  static const char *const kHex = "0123456789abcdef";
+  static constexpr size_t kHexNum = 16;
+  static constexpr size_t kSignatureSize = 20;
+  const uint8_t *signature = GetDexFile(this)->GetHeader().signature_;
+  std::string result;
+  for (size_t i = 0; i < kSignatureSize; ++i) {
+    uint8_t value = signature[i];
+    result.push_back(kHex[value / kHexNum]);
+    result.push_back(kHex[value % kHexNum]);
+  }
+  return result;
+}
+
+uint32_t IDexHeader::GetFileSize() const {
+  return GetDexFile(this)->GetHeader().file_size_;
+}
+
+uint32_t IDexHeader::GetHeaderSize() const {
+  return GetDexFile(this)->GetHeader().header_size_;
+}
+
+uint32_t IDexHeader::GetEndianTag() const {
+  return GetDexFile(this)->GetHeader().endian_tag_;
+}
+
+uint32_t IDexHeader::GetLinkSize() const {
+  return GetDexFile(this)->GetHeader().link_size_;
+}
+
+uint32_t IDexHeader::GetLinkOff() const {
+  return GetDexFile(this)->GetHeader().link_off_;
+}
+
+uint32_t IDexHeader::GetMapOff() const {
+  return GetDexFile(this)->GetHeader().map_off_;
+}
+
+uint32_t IDexHeader::GetStringIdsSize() const {
+  return GetDexFile(this)->GetHeader().string_ids_size_;
+}
+
+uint32_t IDexHeader::GetStringIdsOff() const {
+  return GetDexFile(this)->GetHeader().string_ids_off_;
+}
+
+uint32_t IDexHeader::GetTypeIdsSize() const {
+  return GetDexFile(this)->GetHeader().type_ids_size_;
+}
+
+uint32_t IDexHeader::GetTypeIdsOff() const {
+  return GetDexFile(this)->GetHeader().type_ids_off_;
+}
+
+uint32_t IDexHeader::GetProtoIdsSize() const {
+  return GetDexFile(this)->GetHeader().proto_ids_size_;
+}
+
+uint32_t IDexHeader::GetProtoIdsOff() const {
+  return GetDexFile(this)->GetHeader().proto_ids_off_;
+}
+
+uint32_t IDexHeader::GetFieldIdsSize() const {
+  return GetDexFile(this)->GetHeader().field_ids_size_;
+}
+
+uint32_t IDexHeader::GetFieldIdsOff() const {
+  return GetDexFile(this)->GetHeader().field_ids_off_;
+}
+
+uint32_t IDexHeader::GetMethodIdsSize() const {
+  return GetDexFile(this)->GetHeader().method_ids_size_;
+}
+
+uint32_t IDexHeader::GetMethodIdsOff() const {
+  return GetDexFile(this)->GetHeader().method_ids_off_;
+}
+
+uint32_t IDexHeader::GetClassDefsSize() const {
+  return GetDexFile(this)->GetHeader().class_defs_size_;
+}
+
+uint32_t IDexHeader::GetClassDefsOff() const {
+  return GetDexFile(this)->GetHeader().class_defs_off_;
+}
+
+uint32_t IDexHeader::GetDataSize() const {
+  return GetDexFile(this)->GetHeader().data_size_;
+}
+
+uint32_t IDexHeader::GetDataOff() const {
+  return GetDexFile(this)->GetHeader().data_off_;
+}
+
+std::string IDexHeader::GetDexVesion() const {
+  auto magic = reinterpret_cast<const char*>(GetDexFile(this)->GetHeader().magic_);
+  std::string magicStr(magic);
+  size_t totalLength = magicStr.length();
+  size_t pos = totalLength - kDexFileVersionStringLength;
+  std::string res = magicStr.substr(pos, kDexFileVersionStringLength);
+  return res;
+}
+// =====Header end===================
+// =====MapList start================
+const art::dex::MapList *GetMapList(const IDexMapList *list) {
+  return reinterpret_cast<const art::dex::MapList*>(list);
+}
+
+const IDexMapList *IDexMapList::GetInstance(const void *data) {
+  return reinterpret_cast<const IDexMapList*>(data);
+}
+
+uint32_t IDexMapList::GetSize() const {
+  return static_cast<uint32_t>(GetMapList(this)->Size());
+}
+
+uint16_t IDexMapList::GetType(uint32_t index) const {
+  return GetMapList(this)->list_[index].type_;
+}
+
+uint32_t IDexMapList::GetTypeSize(uint32_t index) const {
+  return GetMapList(this)->list_[index].size_;
+}
+// =====MapList end==================
+// =====ResolvedMethodHandleItem start=====
+const art::dex::MethodHandleItem *GetMethodHandle(const ResolvedMethodHandleItem *item) {
+  return reinterpret_cast<const art::dex::MethodHandleItem*>(item);
+}
+
+const ResolvedMethodHandleItem *ResolvedMethodHandleItem::GetInstance(const IDexFile &dexFile, uint32_t index) {
+  return reinterpret_cast<const ResolvedMethodHandleItem*>(&(GetDexFile(dexFile)->GetMethodHandle(index)));
+}
+
+bool ResolvedMethodHandleItem::IsInstance() const {
+  art::DexFile::MethodHandleType type =
+      static_cast<art::DexFile::MethodHandleType>(GetMethodHandle(this)->method_handle_type_);
+  return (type == art::DexFile::MethodHandleType::kInvokeInstance) ||
+         (type == art::DexFile::MethodHandleType::kInvokeConstructor);
+}
+
+bool ResolvedMethodHandleItem::IsInvoke() const {
+  art::DexFile::MethodHandleType type =
+      static_cast<art::DexFile::MethodHandleType>(GetMethodHandle(this)->method_handle_type_);
+  return (type == art::DexFile::MethodHandleType::kInvokeInstance) ||
+         (type == art::DexFile::MethodHandleType::kInvokeConstructor) ||
+         (type == art::DexFile::MethodHandleType::kInvokeStatic);
+}
+
+const std::string ResolvedMethodHandleItem::GetDeclaringClass(const IDexFile &dexFile) const {
+  if (!IsInvoke()) {
+    return std::string();
+  }
+  const char *declaringClass = nullptr;
+  const art::dex::MethodId &methodId = GetDexFile(dexFile)->GetMethodId(GetMethodHandle(this)->field_or_method_idx_);
+  declaringClass = GetDexFile(dexFile)->GetMethodDeclaringClassDescriptor(methodId);
+  return namemangler::EncodeName(declaringClass);
+}
+
+const std::string ResolvedMethodHandleItem::GetMember(const IDexFile &dexFile) const {
+  if (!IsInvoke()) {
+    return std::string();
+  }
+  const char *member = nullptr;
+  const art::dex::MethodId &methodId = GetDexFile(dexFile)->GetMethodId(GetMethodHandle(this)->field_or_method_idx_);
+  member = GetDexFile(dexFile)->GetMethodName(methodId);
+  return namemangler::EncodeName(member);
+}
+
+const std::string ResolvedMethodHandleItem::GetMemeberProto(const IDexFile &dexFile) const {
+  if (!IsInvoke()) {
+    return std::string();
+  }
+  const art::dex::MethodId &methodId = GetDexFile(dexFile)->GetMethodId(GetMethodHandle(this)->field_or_method_idx_);
+  std::string memberType = GetDexFile(dexFile)->GetMethodSignature(methodId).ToString();
+  return GetDeclaringClass(dexFile) + "_7C" + GetMember(dexFile) + "_7C" + namemangler::EncodeName(memberType);
+}
+
+const ResolvedMethodType *ResolvedMethodHandleItem::GetMethodType(const IDexFile &dexFile) const {
+  return ResolvedMethodType::GetInstance(dexFile, *this);
+}
+
+const std::string ResolvedMethodHandleItem::GetInvokeKind() const {
+  art::DexFile::MethodHandleType type =
+      static_cast<art::DexFile::MethodHandleType>(GetMethodHandle(this)->method_handle_type_);
+  switch (type) {
+    case art::DexFile::MethodHandleType::kInvokeStatic:
+      return std::string("invoke-static");
+    case art::DexFile::MethodHandleType::kInvokeInstance:
+      return std::string("invoke-instance");
+    case art::DexFile::MethodHandleType::kInvokeConstructor:
+      return std::string("invoke-constructor");
+    default:
+      return std::string();
+  }
+}
+// =====ResolvedMethodHandleItem end=====
+// =====ResolvedMethodType start=====
+const art::dex::MethodId *GetMethodHandleId(const ResolvedMethodType *type) {
+  return reinterpret_cast<const art::dex::MethodId*>(type);
+}
+
+const art::dex::ProtoId *GetMethodCallSiteId(const ResolvedMethodType *type) {
+  auto value = reinterpret_cast<uintptr_t>(type);
+  return reinterpret_cast<const art::dex::ProtoId*>(value & (~1));
+}
+
+const ResolvedMethodType *ResolvedMethodType::GetInstance(const IDexFile &dexFile,
+                                                          const ResolvedMethodHandleItem &item) {
+  const art::dex::MethodId *methodId =
+      &(GetDexFile(dexFile)->GetMethodId(GetMethodHandle(&item)->field_or_method_idx_));
+  if ((reinterpret_cast<uintptr_t>(methodId) & 0x1) == 1) {
+    std::cerr << "Invalid MethodId address" << std::endl;
+    return nullptr;
+  }
+  return reinterpret_cast<const ResolvedMethodType*>(methodId);
+}
+
+const ResolvedMethodType *ResolvedMethodType::GetInstance(const IDexFile &dexFile, uint32_t callSiteId) {
+  const art::dex::ProtoId *methodId = &(GetDexFile(dexFile)->GetProtoId((art::dex::ProtoIndex)callSiteId));
+  if ((reinterpret_cast<uintptr_t>(methodId) & 0x1) == 1) {
+    std::cerr << "Invalid MethodId address" << std::endl;
+    return nullptr;
+  }
+  return reinterpret_cast<const ResolvedMethodType*>(reinterpret_cast<uintptr_t>(methodId) | 0x1);
+}
+
+const std::string ResolvedMethodType::GetReturnType(const IDexFile &dexFile) const {
+  std::string rawType = GetRawType(dexFile);
+  return SignatureReturnType(rawType);
+}
+
+const std::string ResolvedMethodType::GetRawType(const IDexFile &dexFile) const {
+  auto value = reinterpret_cast<uintptr_t>(this);
+  if ((value & 0x1) == 0) {
+    return GetDexFile(dexFile)->GetMethodSignature(*GetMethodHandleId(this)).ToString();
+  }
+  return GetDexFile(dexFile)->GetProtoSignature(*GetMethodCallSiteId(this)).ToString();
+}
+
+void ResolvedMethodType::GetArgTypes(const IDexFile &dexFile, std::list<std::string> &types) const {
+  std::string rawType = GetRawType(dexFile);
+  SignatureTypes(rawType, types);
+}
+// =====ResolvedMethodType end=======
+// =====ResolvedCallSiteIdItem start=====
+const art::dex::CallSiteIdItem *GetCallSiteId(const ResolvedCallSiteIdItem *item) {
+  return reinterpret_cast<const art::dex::CallSiteIdItem*>(item);
+}
+
+const ResolvedCallSiteIdItem *ResolvedCallSiteIdItem::GetInstance(const IDexFile &dexFile, uint32_t index) {
+  const art::dex::CallSiteIdItem &callSiteId = GetDexFile(dexFile)->GetCallSiteId(index);
+  art::CallSiteArrayValueIterator it(*GetDexFile(dexFile), callSiteId);
+  if (it.Size() < 3) {  // 3 stands for the min size of call site values.
+    std::cerr << "ERROR: Call site" << index << " has too few values." << std::endl;
+    return nullptr;
+  }
+  return reinterpret_cast<const ResolvedCallSiteIdItem*>(&callSiteId);
+}
+
+uint32_t ResolvedCallSiteIdItem::GetDataOff() const {
+  return GetCallSiteId(this)->data_off_;
+}
+
+uint32_t ResolvedCallSiteIdItem::GetMethodHandleIndex(const IDexFile &dexFile) const {
+  art::CallSiteArrayValueIterator it(*GetDexFile(dexFile), *GetCallSiteId(this));
+  return static_cast<uint32_t>(it.GetJavaValue().i);
+}
+
+const std::string ResolvedCallSiteIdItem::GetMethodName(const IDexFile &dexFile) const {
+  art::CallSiteArrayValueIterator it(*GetDexFile(dexFile), *GetCallSiteId(this));
+  it.Next();
+  art::dex::StringIndex methodNameIdx = static_cast<art::dex::StringIndex>(it.GetJavaValue().i);
+  return std::string(GetDexFile(dexFile)->StringDataByIdx(methodNameIdx));
+}
+
+const std::string ResolvedCallSiteIdItem::GetProto(const IDexFile &dexFile) const {
+  art::CallSiteArrayValueIterator it(*GetDexFile(dexFile), *GetCallSiteId(this));
+  it.Next();
+  it.Next();
+  uint32_t methodTypeIdx = static_cast<uint32_t>(it.GetJavaValue().i);
+  const art::dex::ProtoId &methodTypeId = GetDexFile(dexFile)->GetProtoId((art::dex::ProtoIndex)methodTypeIdx);
+  return GetDexFile(dexFile)->GetProtoSignature(methodTypeId).ToString();
+}
+
+const ResolvedMethodType *ResolvedCallSiteIdItem::GetMethodType(const IDexFile &dexFile) const {
+  art::CallSiteArrayValueIterator it(*GetDexFile(dexFile), *GetCallSiteId(this));
+  it.Next();
+  it.Next();
+  uint32_t methodTypeIdx = static_cast<uint32_t>(it.GetJavaValue().i);
+  return ResolvedMethodType::GetInstance(dexFile, methodTypeIdx);
+}
+
+void ResolvedCallSiteIdItem::GetLinkArgument(const IDexFile &dexFile,
+                                             std::list<std::pair<ValueType, std::string>> &args) const {
+  art::CallSiteArrayValueIterator it(*GetDexFile(dexFile), *GetCallSiteId(this));
+  it.Next();
+  it.Next();
+  it.Next();
+  while (it.HasNext()) {
+    ValueType type = ValueType::kByte;
+    std::string value;
+    switch (it.GetValueType()) {
+      case art::EncodedArrayValueIterator::ValueType::kByte: {
+        type = ValueType::kByte;
+        value = android::base::StringPrintf("%u", it.GetJavaValue().b);
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kString: {
+        // cannot define var in switch need brackets
+        type = ValueType::kString;
+        art::dex::StringIndex stringIdx = static_cast<art::dex::StringIndex>(it.GetJavaValue().i);
+        const char *str = GetDexFile(dexFile)->StringDataByIdx(stringIdx);
+        if (str == nullptr) {
+          LOG(FATAL) << "Invalid string from DexFile";
+        }
+        value = str;
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kMethodType: {
+        uint32_t protoIdx = static_cast<uint32_t>(it.GetJavaValue().i);
+        const art::dex::ProtoId &protoId = GetDexFile(dexFile)->GetProtoId((art::dex::ProtoIndex)protoIdx);
+        type = ValueType::kMethodType;
+        value = GetDexFile(dexFile)->GetProtoSignature(protoId).ToString();
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kMethodHandle: {
+        type = ValueType::kMethodHandle;
+        value = android::base::StringPrintf("%d", it.GetJavaValue().i);
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kType: {
+        art::dex::TypeIndex typeIdx = static_cast<art::dex::TypeIndex>(it.GetJavaValue().i);
+        const char *str = GetDexFile(dexFile)->StringByTypeIdx(typeIdx);
+        if (str == nullptr) {
+          LOG(FATAL) << "Invalid string from DexFile";
+        }
+        value = str;
+        type = ValueType::kType;
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kNull: {
+        type = ValueType::kNull;
+        value = "null";
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kBoolean: {
+        value = it.GetJavaValue().z ? "true" : "false";
+        type = ValueType::kBoolean;
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kShort: {
+        type = ValueType::kShort;
+        value = android::base::StringPrintf("%d", it.GetJavaValue().s);
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kChar: {
+        type = ValueType::kChar;
+        value = android::base::StringPrintf("%u", it.GetJavaValue().c);
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kInt: {
+        type = ValueType::kInt;
+        value = android::base::StringPrintf("%d", it.GetJavaValue().i);
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kLong: {
+        type = ValueType::kLong;
+        value = android::base::StringPrintf("%" PRId64 "64", it.GetJavaValue().j);
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kFloat: {
+        type = ValueType::kFloat;
+        value = android::base::StringPrintf("%g", it.GetJavaValue().f);
+        break;
+      }
+      case art::EncodedArrayValueIterator::ValueType::kDouble: {
+        type = ValueType::kDouble;
+        value = android::base::StringPrintf("%g", it.GetJavaValue().d);
+        break;
+      }
+      default: {
+        LOG(FATAL) << "Unimplemented type " << it.GetValueType();
+      }
+    }
+    args.push_back(std::make_pair(type, value));
+    it.Next();
+  }
+}
+// =====ResolvedCallSiteIdItem end===
+// =====LibDexFile start=============
+LibDexFile::LibDexFile(std::unique_ptr<const art::DexFile> artDexFile,
+                       std::unique_ptr<std::string> contentPtrIn)
+    : contentPtr(std::move(contentPtrIn)) {
+  dexFiles.push_back(std::move(artDexFile));
+  dexFile = dexFiles[0].get();
+  header = IDexHeader::GetInstance(*this);
+  mapList = IDexMapList::GetInstance(dexFile->GetMapList());
+}
+
+LibDexFile::~LibDexFile() {
+  dexFile = nullptr;
+}
+
+bool LibDexFile::Open(const std::string &fileName) {
+  const bool kVerifyChecksum = true;
+  const bool kVerify = true;
+  // If the file is not a .dex file, the function tries .zip/.jar/.apk files,
+  // all of which are Zip archives with "classes.dex" inside.
+  if (!android::base::ReadFileToString(fileName, &content)) {
+    LOG(ERROR) << "ReadFileToString failed";
+    return false;
+  }
+  // content size must > 0, otherwise previous step return false
+  if (!CheckFileSize(content.size())) {
+    return false;
+  }
+  const art::DexFileLoader dexFileLoader;
+  art::DexFileLoaderErrorCode errorCode;
+  std::string errorMsg;
+  if (!dexFileLoader.OpenAll(reinterpret_cast<const uint8_t*>(content.data()),
+                             content.size(),
+                             fileName,
+                             kVerify,
+                             kVerifyChecksum,
+                             &errorCode,
+                             &errorMsg,
+                             &dexFiles)) {
+    // Display returned error message to user. Note that this error behavior
+    // differs from the error messages shown by the original Dalvik dexdump.
+    LOG(ERROR) << errorMsg;
+    return false;
+  }
+  if (dexFiles.size() != 1) {
+    LOG(FATAL) << "Only support one dexfile now";
+  }
+  dexFile = dexFiles[0].get();
+  header = IDexHeader::GetInstance(*this);
+  mapList = IDexMapList::GetInstance(dexFile->GetMapList());
+  return true;
+}
+
+const uint8_t *LibDexFile::GetBaseAddress() const {
+  return dexFile->Begin();
+}
+
+const IDexHeader *LibDexFile::GetHeader() const {
+  return header;
+}
+
+const IDexMapList *LibDexFile::GetMapList() const {
+  return mapList;
+}
+
+uint32_t LibDexFile::GetStringDataOffset(uint32_t index) const {
+  const art::dex::StringId &artStringId = dexFile->GetStringId(art::dex::StringIndex(index));
+  return artStringId.string_data_off_;
+}
+
+uint32_t LibDexFile::GetTypeDescriptorIndex(uint32_t index) const {
+  const art::dex::TypeId &artTypeId = dexFile->GetTypeId(art::dex::TypeIndex(static_cast<uint16_t>(index)));
+  return artTypeId.descriptor_idx_.index_;
+}
+
+const char *LibDexFile::GetStringByIndex(uint32_t index) const {
+  const char *str = dexFile->StringDataByIdx(art::dex::StringIndex(index));
+  if (str == nullptr) {
+    LOG(FATAL) << "Invalid or truncated dex file";
+  }
+  return str;
+}
+
+const char *LibDexFile::GetStringByTypeIndex(uint32_t index) const {
+  return dexFile->StringByTypeIdx(art::dex::TypeIndex(index));
+}
+
+const IDexProtoIdItem *LibDexFile::GetProtoIdItem(uint32_t index) const {
+  return IDexProtoIdItem::GetInstance(*this, index);
+}
+
+const IDexFieldIdItem *LibDexFile::GetFieldIdItem(uint32_t index) const {
+  return IDexFieldIdItem::GetInstance(*this, index);
+}
+
+const IDexMethodIdItem *LibDexFile::GetMethodIdItem(uint32_t index) const {
+  return IDexMethodIdItem::GetInstance(*this, index);
+}
+
+uint32_t LibDexFile::GetClassItemsSize() const {
+  return dexFile->NumClassDefs();
+}
+
+const IDexClassItem *LibDexFile::GetClassItem(uint32_t index) const {
+  return GetDexClassInstance(*dexFile, index);
+}
+
+bool LibDexFile::IsNoIndex(uint32_t index) const {
+  uint16_t index16 = static_cast<uint16_t>(index);
+  return (index16 == art::DexFile::kDexNoIndex16);
+}
+
+uint32_t LibDexFile::GetTypeIdFromName(const std::string &className) const {
+  return dexFile->GetIndexForTypeId(*dexFile->FindTypeId(className.c_str())).index_;
+}
+
+uint32_t LibDexFile::ReadUnsignedLeb128(const uint8_t **pStream) const {
+  uint32_t result = art::DecodeUnsignedLeb128(pStream);
+  return result;
+}
+
+uint32_t LibDexFile::FindClassDefIdx(const std::string &descriptor) const {
+  const art::dex::TypeId* typeId = dexFile->FindTypeId(descriptor.c_str());
+  if (typeId != nullptr) {
+    art::dex::TypeIndex typeIdx = dexFile->GetIndexForTypeId(*typeId);
+    size_t classDefsSize = dexFile->NumClassDefs();
+    if (classDefsSize == 0) {
+      return art::dex::kDexNoIndex;
+    }
+    for (uint32_t i = 0; i < classDefsSize; ++i) {
+      const art::dex::ClassDef &class_def = dexFile->GetClassDef(i);
+      if (class_def.class_idx_ == typeIdx) {
+        return i;
+      }
+    }
+  }
+  return art::dex::kDexNoIndex;
+}
+
+std::unordered_map<std::string, uint32_t> LibDexFile::GetDefiningClassNameTypeIdMap() const {
+  std::unordered_map<std::string, uint32_t> definingClassNameTypeIdMap;
+  uint32_t classIdsSize = dexFile->NumTypeIds();
+  for (uint32_t classIdIndex = 0; classIdIndex < classIdsSize; classIdIndex++) {
+    std::string className = dexFile->StringByTypeIdx(art::dex::TypeIndex(classIdIndex));
+    definingClassNameTypeIdMap.insert(std::make_pair(namemangler::EncodeName(className), classIdIndex));
+  }
+  return definingClassNameTypeIdMap;
+}
+
+void LibDexFile::DecodeDebugLocalInfo(const IDexMethodItem &iDexMethodItem,
+                                      DebugNewLocalCallback newLocalCb) {
+  debugNewLocalCb = newLocalCb;
+  const art::dex::CodeItem *codeItem = dexFile->GetCodeItem(iDexMethodItem.GetCodeOff());
+  art::CodeItemDebugInfoAccessor accessor(*dexFile, codeItem, iDexMethodItem.GetMethodIdx());
+  (void)accessor.DecodeDebugLocalInfo(iDexMethodItem.IsStatic(), iDexMethodItem.GetMethodIdx(),
+                                      [&](const art::DexFile::LocalInfo &entry) {
+    DebugNewLocalCb(nullptr, entry);
+  });
+}
+
+void LibDexFile::DecodeDebugPositionInfo(const IDexMethodItem &iDexMethodItem,
+                                         DebugNewPositionCallback newPositionCb) {
+  debugNewPositionCb = newPositionCb;
+  const art::dex::CodeItem *codeItem = dexFile->GetCodeItem(iDexMethodItem.GetCodeOff());
+  art::CodeItemDebugInfoAccessor accessor(*dexFile, codeItem, iDexMethodItem.GetMethodIdx());
+  (void)accessor.DecodeDebugPositionInfo([&](const art::DexFile::PositionInfo &entry) {
+    return DebugNewPositionCb(nullptr, entry);
+  });
+}
+
+const ResolvedCallSiteIdItem *LibDexFile::GetCallSiteIdItem(uint32_t idx) const {
+  return ResolvedCallSiteIdItem::GetInstance(*this, idx);
+}
+
+const ResolvedMethodHandleItem *LibDexFile::GetMethodHandleItem(uint32_t idx) const {
+  return ResolvedMethodHandleItem::GetInstance(*this, idx);
+}
+
+void LibDexFile::DebugNewLocalCb(void *context, const art::DexFile::LocalInfo &entry) const {
+  debugNewLocalCb(context, entry.reg_,  entry.start_address_, entry.end_address_,
+                  entry.name_ == nullptr ? "this" : entry.name_, entry.descriptor_ == nullptr ? "" : entry.descriptor_,
+                  entry.signature_ == nullptr ? "" : entry.signature_);
+}
+
+bool LibDexFile::DebugNewPositionCb(void *context, const art::DexFile::PositionInfo &entry) const {
+  debugNewPositionCb(context, entry.address_, entry.line_);
+  return false;
+}
+
+bool LibDexFile::CheckFileSize(size_t fileSize) {
+  if (fileSize < sizeof(art::DexFile::Header)) {
+    LOG(ERROR) << "Invalid or truncated dex file";
+    return false;
+  }
+  const art::DexFile::Header *fileHeader = reinterpret_cast<const art::DexFile::Header*>(content.data());
+  if (fileSize != fileHeader->file_size_) {
+    LOG(ERROR) << "Bad file size:" << fileSize << ", " << "expected:" << fileHeader->file_size_;
+    return false;
+  }
+  return true;
+}
+// =====LibDexFile end===============
+}  // namespace maple
diff --git a/src/hir2mpl/common/include/base64.h b/src/hir2mpl/common/include/base64.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ef98385f470522bfacff13cc21417ba0034e4bc
--- /dev/null
+++ b/src/hir2mpl/common/include/base64.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_BASE64_H
+#define HIR2MPL_INCLUDE_COMMON_BASE64_H
+#include <map>
+#include <string>
+#include "types_def.h"
+
+namespace maple {
+class Base64 {
+ public:
+  static std::string Encode(const uint8 *input, size_t length);
+  static uint8 *Decode(const std::string &input, size_t &lengthRet);
+  static std::map<char, char> InitEncodeMap();
+  static std::map<char, uint8> InitDecodeMap();
+
+ private:
+  Base64() = default;
+  ~Base64() = default;
+
+  static std::map<char, char> encodeMap;
+  static std::map<char, uint8> decodeMap;
+  static size_t DecodeLength(const std::string &input);
+};
+}  // namespace maple
+#endif
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/basic_io.h b/src/hir2mpl/common/include/basic_io.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd755bd4b6724b5583fd8ebb3ae212989d76201b
--- /dev/null
+++ b/src/hir2mpl/common/include/basic_io.h
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_BASIC_IO_H
+#define HIR2MPL_INCLUDE_COMMON_BASIC_IO_H
+#include <climits>
+#include <string>
+#include <memory>
+#include "mempool_allocator.h"
+#include "types_def.h"
+#include "mpl_logging.h"
+#include "securec.h"
+
+namespace maple {
+class BasicIOEndian {
+ public:
+  static const uint32 kLengthByte = 1;
+  static const uint32 kLengthWord = 2;
+  static const uint32 kLengthDWord = 4;
+  static const uint32 kLengthQWord = 8;
+
+  static uint16 GetUInt16BigEndian(const uint8 *p) {
+    // for performance, validation of p must be done by caller
+    return static_cast<uint16>((p[kBufIndex0] << kOffset8) | p[kBufIndex1]);
+  }
+
+  static uint16 GetUInt16LittleEndian(const uint8 *p) {
+    // for performance, validation of p must be done by caller
+    return static_cast<uint16>((p[kBufIndex1] << kOffset8) | p[kBufIndex0]);
+  }
+
+  static uint32 GetUInt32BigEndian(const uint8 *p) {
+    // for performance, validation of p must be done by caller
+    uint32 value = 0;
+    for (uint32 i = 0; i < kLengthDWord; i++) {
+      value = (value << kOffset8) | p[i];
+    }
+    return value;
+  }
+
+  static uint32 GetUInt32LittleEndian(const uint8 *p) {
+    // for performance, validation of p must be done by caller
+    uint32 value = 0;
+    for (int i = static_cast<int>(kLengthDWord) - 1; i >= 0; i--) {
+      value = (value << kOffset8) | p[i];
+    }
+    return value;
+  }
+
+  static uint64 GetUInt64BigEndian(const uint8 *p) {
+    // for performance, validation of p must be done by caller
+    uint64 value = 0;
+    for (uint32 i = 0; i < kLengthQWord; i++) {
+      value = (value << kOffset8) | p[i];
+    }
+    return value;
+  }
+
+  static uint64 GetUInt64LittleEndian(const uint8 *p) {
+    // for performance, validation of p must be done by caller
+    uint64 value = 0;
+    for (int i = static_cast<int>(kLengthQWord) - 1; i >= 0; i--) {
+      value = (value << kOffset8) | p[i];
+    }
+    return value;
+  }
+
+ private:
+  static const uint32 kBufIndex0 = 0;
+  static const uint32 kBufIndex1 = 1;
+  static const uint32 kBufIndex2 = 2;
+  static const uint32 kBufIndex3 = 3;
+  static const uint32 kOffset8 = 8;
+  static const uint32 kOffset16 = 16;
+  static const uint32 kOffset24 = 24;
+
+  BasicIOEndian() = default;
+  ~BasicIOEndian() = default;
+};
+
+class BasicIOMapFile {
+ public:
+  explicit BasicIOMapFile(const std::string &name);
+  BasicIOMapFile(const std::string &name, const uint8 *ptrIn, long lengthIn);
+  virtual ~BasicIOMapFile();
+  bool OpenAndMap() {
+    return OpenAndMapImpl();
+  }
+  void Close();
+  static std::unique_ptr<BasicIOMapFile> GenFileInMemory(const std::string &name, const uint8 *buf, size_t len);
+
+  size_t GetLength() const {
+    return length;
+  }
+
+  const uint8 *GetPtr() const {
+    return ptr;
+  }
+
+  const uint8 *GetPtrOffset(size_t offset) const {
+    if (offset >= length) {
+      CHECK_FATAL(false, "offset is out of range");
+      return nullptr;
+    }
+    return ptr + offset;
+  }
+
+  const std::string &GetFileName() const {
+    return fileName;
+  }
+
+ protected:
+  virtual bool OpenAndMapImpl();
+  int fd;
+  const uint8 *ptr;
+  uint8 *ptrMemMap;
+  size_t length;
+  std::string fileName;
+};
+
+class BasicIORead {
+ public:
+  explicit BasicIORead(BasicIOMapFile &f, bool bigEndian = false);
+  virtual ~BasicIORead() = default;
+  uint8 ReadUInt8();
+  uint8 ReadUInt8(bool &success);
+  int8 ReadInt8();
+  int8 ReadInt8(bool &success);
+  char ReadChar();
+  char ReadChar(bool &success);
+  uint16 ReadUInt16();
+  uint16 ReadUInt16(bool &success);
+  int16 ReadInt16();
+  int16 ReadInt16(bool &success);
+  uint32 ReadUInt32();
+  uint32 ReadUInt32(bool &success);
+  int32 ReadInt32();
+  int32 ReadInt32(bool &success);
+  uint64 ReadUInt64();
+  uint64 ReadUInt64(bool &success);
+  int64 ReadInt64();
+  int64 ReadInt64(bool &success);
+  float ReadFloat();
+  float ReadFloat(bool &success);
+  double ReadDouble();
+  double ReadDouble(bool &success);
+  void ReadBufferUInt8(uint8 *dst, uint32 length);
+  void ReadBufferUInt8(uint8 *dst, uint32 length, bool &success);
+  void ReadBufferInt8(int8 *dst, uint32 length);
+  void ReadBufferInt8(int8 *dst, uint32 length, bool &success);
+  void ReadBufferChar(char *dst, uint32 length);
+  void ReadBufferChar(char *dst, uint32 length, bool &success);
+  std::string ReadString(uint32 length);
+  std::string ReadString(uint32 length, bool &success);
+
+  const uint8 *GetBuffer(uint32 size) const {
+    if (pos + size > file.GetLength()) {
+      ERR(kLncErr, "BasicIORead: not enough data");
+      return nullptr;
+    } else {
+      return file.GetPtrOffset(pos);
+    }
+  }
+
+  const uint8 *GetSafeBuffer(uint32 size) const {
+    CHECK_FATAL(pos + size <= file.GetLength(), "not enough data");
+    return file.GetPtrOffset(pos);
+  }
+
+  const uint8 *GetSafeBufferAt(uint32 pos0, uint32 size) const {
+    CHECK_FATAL(pos0 + size <= file.GetLength(), "not enough data");
+    return file.GetPtrOffset(pos0);
+  }
+
+  const uint8 *GetSafeDataAt(uint32 offset) const {
+    CHECK_FATAL(0 < offset && offset < file.GetLength(), "Invalid offset: 0x%x, file total size: 0x%x",
+                offset, file.GetLength());
+    return file.GetPtrOffset(offset);
+  }
+
+  uint32 GetPos() const {
+    return pos;
+  }
+
+  void SetPos(uint32 p) {
+    CHECK_FATAL(p < file.GetLength(), "invalid pos %d exceeds the length of file %ld", p, file.GetLength());
+    pos = p;
+  }
+
+  size_t GetFileLength() const {
+    return file.GetLength();
+  }
+
+ protected:
+  BasicIOMapFile &file;
+  bool isBigEndian;
+  uint32 pos;
+};
+}  // namespace maple
+#endif
diff --git a/src/hir2mpl/common/include/enhance_c_checker.h b/src/hir2mpl/common/include/enhance_c_checker.h
new file mode 100644
index 0000000000000000000000000000000000000000..a47d1f144c73b1212ec3df888f9f6a0b8cf00c9b
--- /dev/null
+++ b/src/hir2mpl/common/include/enhance_c_checker.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_ENCCHECKER_H
+#define HIR2MPL_INCLUDE_COMMON_ENCCHECKER_H
+#include "feir_var.h"
+#include "feir_stmt.h"
+#include "ast_expr.h"
+#include "ast_decl.h"
+
+namespace maple {
+constexpr int64 kUndefValue = 0xdeadbeef;
+class ENCChecker {
+ public:
+  ENCChecker() = default;
+  ~ENCChecker() = default;
+  static bool HasNonnullAttrInExpr(MIRBuilder &mirBuilder, const UniqueFEIRExpr &expr, bool isNested = false);
+  static bool HasNullExpr(const UniqueFEIRExpr &expr);
+  static void CheckNonnullGlobalVarInit(const MIRSymbol &sym, const MIRConst *cst);
+  static void CheckNullFieldInGlobalStruct(MIRType &type, MIRAggConst &cst, const MapleVector<ASTExpr*> &initExprs);
+  static void CheckNonnullLocalVarInit(const MIRSymbol &sym, const ASTExpr *initExpr);
+  static void CheckNonnullLocalVarInit(const MIRSymbol &sym, const UniqueFEIRExpr &initFEExpr,
+                                       std::list<UniqueFEIRStmt> &stmts);
+  static std::string GetNthStr(size_t index);
+  static std::string PrintParamIdx(const std::list<size_t> &idxs);
+  static void CheckNonnullArgsAndRetForFuncPtr(const MIRType &dstType, const UniqueFEIRExpr &srcExpr, const Loc &loc);
+  static bool HasNonnullFieldInStruct(const MIRType &mirType);
+  static bool HasNonnullFieldInPtrStruct(const MIRType &mirType);
+  static void CheckNonnullFieldInStruct(const MIRType &src, const MIRType &dst, const Loc &loc);
+  static bool IsSameBoundary(const AttrBoundary &arg1, const AttrBoundary &arg2);
+  static void CheckBoundaryArgsAndRetForFuncPtr(const MIRType &dstType, const UniqueFEIRExpr &srcExpr, const Loc &loc);
+  static UniqueFEIRExpr FindBaseExprInPointerOperation(const UniqueFEIRExpr &expr, bool isIncludingAddrof = false);
+  static MIRType *GetTypeFromAddrExpr(const UniqueFEIRExpr &expr);
+  static MIRType *GetArrayTypeFromExpr(const UniqueFEIRExpr &expr);
+  static MIRConst *GetMIRConstFromExpr(const UniqueFEIRExpr &expr);
+  static void AssignBoundaryVar(MIRBuilder &mirBuilder, const UniqueFEIRExpr &dstExpr, const UniqueFEIRExpr &srcExpr,
+                                const UniqueFEIRExpr &lRealLenExpr, std::list<StmtNode*> &ans);
+  static void AssignUndefVal(MIRBuilder &mirBuilder, MIRSymbol &sym);
+  static std::string GetBoundaryName(const UniqueFEIRExpr &expr);
+  static bool IsGlobalVarInExpr(const UniqueFEIRExpr &expr);
+  static std::pair<StIdx, StIdx> InsertBoundaryVar(MIRBuilder &mirBuilder, const UniqueFEIRExpr &expr);
+  static void InsertBoundaryVar(const ASTDecl &ptrDecl, std::list<UniqueFEIRStmt> &stmts);
+  static bool IsConstantIndex(const UniqueFEIRExpr &expr);
+  static void PeelNestedBoundaryChecking(std::list<UniqueFEIRStmt> &stmts, const UniqueFEIRExpr &baseExpr);
+  static void ReduceBoundaryChecking(std::list<UniqueFEIRStmt> &stmts, const UniqueFEIRExpr &expr);
+  static UniqueFEIRExpr GetRealBoundaryLenExprInFunc(const UniqueFEIRExpr &lenExpr, const ASTFunc &astFunc,
+                                                     const ASTCallExpr &astCallExpr);
+  static UniqueFEIRExpr GetRealBoundaryLenExprInFuncByIndex(const TypeAttrs &typeAttrs, const MIRType &type,
+                                                            const ASTCallExpr &astCallExpr);
+  static UniqueFEIRExpr GetRealBoundaryLenExprInField(const UniqueFEIRExpr &lenExpr, MIRStructType &baseType,
+                                                      const UniqueFEIRExpr &dstExpr);
+  static void InitBoundaryVarFromASTDecl(MapleAllocator &allocator, ASTDecl *ptrDecl,
+                                         ASTExpr *lenExpr, std::list<ASTStmt*> &stmts);
+  static void InitBoundaryVar(MIRFunction &curFunction, const ASTDecl &ptrDecl,
+                              UniqueFEIRExpr lenExpr, std::list<UniqueFEIRStmt> &stmts);
+  static void InitBoundaryVar(MIRFunction &curFunction, const std::string &ptrName, MIRType &ptrType,
+                              UniqueFEIRExpr lenExpr, std::list<UniqueFEIRStmt> &stmts);
+  static std::pair<StIdx, StIdx> InitBoundaryVar(MIRFunction &curFunction, const UniqueFEIRExpr &ptrExpr,
+                                                 UniqueFEIRExpr lenExpr, std::list<UniqueFEIRStmt> &stmts);
+  static UniqueFEIRExpr GetGlobalOrFieldLenExprInExpr(MIRBuilder &mirBuilder, const UniqueFEIRExpr &expr);
+  static void InsertBoundaryAssignChecking(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans,
+                                           const UniqueFEIRExpr &srcExpr, const Loc &loc);
+  static UniqueFEIRStmt InsertBoundaryLEChecking(UniqueFEIRExpr lenExpr, const UniqueFEIRExpr &srcExpr,
+                                                 const UniqueFEIRExpr &dstExpr);
+  static void CheckBoundaryLenFinalAssign(MIRBuilder &mirBuilder, const UniqueFEIRVar &var, FieldID fieldID,
+                                          const Loc &loc);
+  static void CheckBoundaryLenFinalAssign(MIRBuilder &mirBuilder, const UniqueFEIRType &addrType, FieldID fieldID,
+                                          const Loc &loc);
+  static void CheckBoundaryLenFinalAddr(MIRBuilder &mirBuilder, const UniqueFEIRExpr &expr, const Loc &loc);
+  static MapleVector<BaseNode*> ReplaceBoundaryChecking(MIRBuilder &mirBuilder, const FEIRStmtNary *stmt);
+  static void ReplaceBoundaryErr(const MIRBuilder &mirBuilder, const FEIRStmtNary *stmt);
+  static UniqueFEIRExpr GetBoundaryLenExprCache(uint32 hash);
+  static UniqueFEIRExpr GetBoundaryLenExprCache(const TypeAttrs &attr);
+  static UniqueFEIRExpr GetBoundaryLenExprCache(const FieldAttrs &attr);
+  static void InsertBoundaryInAtts(TypeAttrs &attr, const BoundaryInfo &boundary);
+  static void InsertBoundaryLenExprInAtts(TypeAttrs &attr, const UniqueFEIRExpr &expr);
+  static void InsertBoundaryInAtts(FieldAttrs &attr, const BoundaryInfo &boundary);
+  static void InsertBoundaryInAtts(FuncAttrs &attr, const BoundaryInfo &boundary);
+  static bool IsSafeRegion(const MIRBuilder &mirBuilder);
+  static bool IsUnsafeRegion(const MIRBuilder &mirBuilder);
+  static void CheckLenExpr(const ASTExpr &lenExpr, const std::list<UniqueFEIRStmt> &nullstmts);
+};  // class ENCChecker
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_ENCCHECKER_H
diff --git a/src/hir2mpl/common/include/fe_algorithm.h b/src/hir2mpl/common/include/fe_algorithm.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e7df74ad76b8974cec95f83cd35c931346aa046
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_algorithm.h
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_ALGORITHM_H
+#define HIR2MPL_INCLUDE_COMMON_FE_ALGORITHM_H
+#include <list>
+#include <set>
+#include <map>
+#include "types_def.h"
+#include "fe_configs.h"
+
+namespace maple {
+template <typename T>
+class CorrelativeMerge {
+ public:
+  using PtrMergeFunc = bool (T::*)(const T&);
+  using PtrMergableFunc = bool (T::*)() const;
+  CorrelativeMerge(std::map<T*, std::set<T*>> &argCorrelationMap, PtrMergeFunc argPtrMergeFunc,
+                   PtrMergableFunc argPtrMergableFunc)
+      : correlationMap(argCorrelationMap),
+        ptrMergeFunc(argPtrMergeFunc),
+        ptrMergableFunc(argPtrMergableFunc),
+        inLoop(false),
+        error(false),
+        success(false),
+        visitCount(0) {}
+
+  ~CorrelativeMerge() = default;
+  void ProcessAll() {
+    visitCount = 0;
+    // loop check
+    LoopCheckAll();
+    // process
+    CHECK_NULL_FATAL(ptrMergableFunc);
+    for (const std::pair<T*, std::set<T*>> &item : correlationMap) {
+      T *dst = item.first;
+      CHECK_NULL_FATAL(dst);
+      if ((dst->*ptrMergableFunc)()) {
+        continue;
+      }
+      ProcessOne(*dst, true);
+      if (!success) {
+        error = true;
+        break;
+      }
+    }
+  }
+
+  void LoopCheckAll() {
+    for (const std::pair<T*, std::set<T*>> &item : correlationMap) {
+      visitedSet.clear();
+      T *dst = item.first;
+      CHECK_NULL_FATAL(dst);
+      inLoop = false;
+      LoopCheck(*dst);
+      loopStatus[dst] = inLoop;
+    }
+  }
+
+  void LoopCheck(T &dst) {
+    // loop check
+    if (visitedSet.find(&dst) != visitedSet.end()) {
+      inLoop = true;
+      return;
+    }
+    // correlation check
+    CHECK_FATAL(visitedSet.insert(&dst).second, "visitedSet insert failed");
+    auto itCorr = correlationMap.find(&dst);
+    if (itCorr != correlationMap.end()) {
+      CHECK_NULL_FATAL(ptrMergableFunc);
+      for (T *src : itCorr->second) {
+        CHECK_NULL_FATAL(src);
+        if (!(src->*ptrMergableFunc)()) {
+          LoopCheck(*src);
+          if (inLoop) {
+            return;
+          }
+        }
+      }
+    }
+  }
+
+  void ProcessOne(T &dst, bool first) {
+    if (first) {
+      success = true;
+      visitedSet.clear();
+    }
+    // loop check
+    visitCount++;
+    // correlation end check
+    auto itCorr = correlationMap.find(&dst);
+    if (itCorr == correlationMap.end()) {
+      return;
+    }
+    CHECK_FATAL(visitedSet.insert(&dst).second, "visitedSet insert failed");
+    // correlation check
+    auto itLoopStatus = loopStatus.find(&dst);
+    ASSERT(itLoopStatus != loopStatus.end(), "loop status not existed");
+    bool updated = (first || !itLoopStatus->second);
+    if (ptrMergableFunc == nullptr || ptrMergeFunc == nullptr) {
+      CHECK_FATAL(false, "nullptr error.");
+    }
+    for (T *src : itCorr->second) {
+      CHECK_NULL_FATAL(src);
+      if (correlationMap.find(src) == correlationMap.end()) {
+        success = success && (dst.*ptrMergeFunc)(*src);
+      } else if ((src->*ptrMergableFunc)()) {
+        success = success && (dst.*ptrMergeFunc)(*src);
+      } else if (updatedSet.find(src) != updatedSet.end()) {
+        success = success && (dst.*ptrMergeFunc)(*src);
+      } else {
+        if (visitedSet.find(src) == visitedSet.end()) {
+          ProcessOne(*src, false);
+          success = success && (dst.*ptrMergeFunc)(*src);
+        }
+      }
+    }
+    if (!updated) {
+      return;
+    }
+    if (updatedSet.find(&dst) == updatedSet.end()) {
+      CHECK_FATAL(updatedSet.insert(&dst).second, "updatedSet insert failed");
+    }
+  }
+
+  uint32 GetVisitCount() const {
+    return visitCount;
+  }
+
+  bool GetError() const {
+    return error;
+  }
+
+ LLT_PRIVATE:
+  std::map<T*, std::set<T*>> &correlationMap;
+  PtrMergeFunc ptrMergeFunc;
+  PtrMergableFunc ptrMergableFunc;
+  std::set<T*> visitedSet;
+  std::set<T*> updatedSet;
+  std::map<T*, bool> loopStatus;
+  bool inLoop : 1;
+  bool error : 1;
+  bool success : 1;
+  uint32 visitCount;
+};  // class CorrelativeMerge
+}  // namespace maple
+#endif
diff --git a/src/hir2mpl/common/include/fe_config_parallel.h b/src/hir2mpl/common/include/fe_config_parallel.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d65a4d3aea91479480e0d3638ad7dcc06cbb1fa
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_config_parallel.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_CONFIG_PARALLEL_H
+#define HIR2MPL_INCLUDE_COMMON_FE_CONFIG_PARALLEL_H
+#include <mutex>
+#include <thread>
+#include <set>
+#include "types_def.h"
+#include "mpl_logging.h"
+
+namespace maple {
+class FEConfigParallel {
+ public:
+  FEConfigParallel();
+  ~FEConfigParallel() = default;
+  static FEConfigParallel &GetInstance() {
+    return instance;
+  }
+
+  uint32 GetNThread() const {
+    return nThread;
+  }
+
+  void EnableParallel() {
+    enableParallel = true;
+  }
+
+  void DisableParallel() {
+    enableParallel = false;
+  }
+
+  bool IsInParallelMode() const {
+    return enableParallel && (nThread > 1);
+  }
+
+  void RegisterRunThreadID(const std::thread::id &tid) {
+    mtx.lock();
+    CHECK_FATAL(runThreadIDs.insert(tid).second, "failed to register thread id");
+    mtx.unlock();
+  }
+
+  bool RunThreadParallelForbidden() {
+    if (!enableParallel) {
+      return false;
+    }
+    std::thread::id tid = std::this_thread::get_id();
+    return runThreadIDs.find(tid) != runThreadIDs.end();
+  }
+
+  void RunThreadIDCleanUp() {
+    runThreadIDs.clear();
+  }
+
+ private:
+  static FEConfigParallel instance;
+  uint32 nThread;
+  bool enableParallel;
+  std::set<std::thread::id> runThreadIDs;
+  std::mutex mtx;
+};
+
+#define HIR2MPL_PARALLEL_FORBIDDEN()                                                           \
+  do {                                                                                       \
+    if (FEConfigParallel::GetInstance().RunThreadParallelForbidden()) {                      \
+      maple::logInfo.EmitErrorMessage("HIR2MPL_PARALLEL_FORBIDDEN", __FILE__, __LINE__, "\n"); \
+      FATAL(kLncFatal, "Forbidden invocation in parallel run thread");                       \
+    }                                                                                        \
+  } while (0)
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_PARALLEL_CONFIG_H
diff --git a/src/hir2mpl/common/include/fe_configs.h b/src/hir2mpl/common/include/fe_configs.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6088219f3ffa7b4aefbbd9a109e802aa41a751f
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_configs.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_CONFIGS_H
+#define HIR2MPL_INCLUDE_COMMON_FE_CONFIGS_H
+#include "types_def.h"
+
+#if ENABLE_COV_CHECK == 1
+#define LLT_MOCK_TARGET virtual
+#define LLT_MOCK_TARGET_VIRTUAL virtual
+#define LLT_PUBLIC public
+#define LLT_PROTECTED public
+#define LLT_PRIVATE public
+#else
+#define LLT_MOCK_TARGET
+#define LLT_MOCK_TARGET_VIRTUAL virtual
+#define LLT_PUBLIC public
+#define LLT_PROTECTED protected
+#define LLT_PRIVATE private
+#endif
+
+namespace maple {
+using TypeDim = uint8;
+
+class FEConstants {
+ public:
+  const static uint8 kDimMax = UINT8_MAX;
+}; // class FEContants
+}  // namespace maple
+
+#include "fe_config_parallel.h"
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_CONFIGS_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_file_ops.h b/src/hir2mpl/common/include/fe_file_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..0102587f171292bd9f032f5461c39b2fdd2b1b4c
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_file_ops.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_FILE_OPS_H
+#define HIR2MPL_INCLUDE_COMMON_FE_FILE_OPS_H
+#include <string>
+
+namespace maple {
+class FEFileOps {
+ public:
+  static std::string GetFilePath(const std::string &pathName);
+  static std::string GetFileNameWithExt(const std::string &pathName);
+  static std::string GetFileName(const std::string &pathName);
+  static std::string GetFileExtName(const std::string &pathName);
+
+ private:
+  FEFileOps() = default;
+  ~FEFileOps() = default;
+};
+} // namespace maple
+#endif
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_file_type.h b/src/hir2mpl/common/include/fe_file_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7ce0726405cbef407b21347befef998de75395b
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_file_type.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_FILE_TYPE_H
+#define HIR2MPL_INCLUDE_COMMON_FE_FILE_TYPE_H
+#include <string>
+#include <map>
+#include "types_def.h"
+#include "basic_io.h"
+
+namespace maple {
+class FEFileType {
+ public:
+  enum FileType {
+    kUnknownType,
+    kClass,
+    kJar,
+    kDex,
+    kAST,
+    kMAST,
+  };
+
+  inline static FEFileType &GetInstance() {
+    return fileType;
+  }
+
+  FileType GetFileTypeByExtName(const std::string &extName) const;
+  FileType GetFileTypeByPathName(const std::string &pathName) const;
+  FileType GetFileTypeByMagicNumber(const std::string &pathName) const;
+  FileType GetFileTypeByMagicNumber(BasicIOMapFile &file) const;
+  FileType GetFileTypeByMagicNumber(uint32 magic) const;
+  void Reset();
+  void LoadDefault();
+  void RegisterExtName(FileType argFileType, const std::string &extName);
+  void RegisterMagicNumber(FileType argFileType, uint32 magicNumber);
+  static std::string GetPath(const std::string &pathName);
+  static std::string GetName(const std::string &pathName, bool withExt = true);
+  static std::string GetExtName(const std::string &pathName);
+
+ private:
+  static FEFileType fileType;
+  static const uint32 kMagicClass = 0xBEBAFECA;
+  static const uint32 kMagicZip = 0x04034B50;
+  static const uint32 kMagicDex = 0x0A786564;
+  static const uint32 kMagicAST = 0x48435043;
+  static const uint32 kMagicMAST = 0xAB4C504D;
+  std::map<std::string, FileType> mapExtNameType;
+  std::map<FileType, uint32> mapTypeMagic;
+  std::map<uint32, FileType> mapMagicType;
+
+  FEFileType();
+  ~FEFileType() = default;
+};
+}
+#endif
diff --git a/src/hir2mpl/common/include/fe_function.h b/src/hir2mpl/common/include/fe_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..d7c2d2c29edc38379f280802d7d66530f1b5333b
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_function.h
@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_FUNCTION_H
+#define HIR2MPL_INCLUDE_COMMON_FE_FUNCTION_H
+#include <memory>
+#include <vector>
+#include <list>
+#include "types_def.h"
+#include "mempool_allocator.h"
+#include "safe_ptr.h"
+#include "mir_function.h"
+#include "fe_utils.h"
+#include "feir_bb.h"
+#include "feir_stmt.h"
+#include "fe_timer_ns.h"
+#include "feir_lower.h"
+#include "feir_cfg.h"
+#include "fe_function_phase_result.h"
+#include "feir_type_infer.h"
+#include "feir_scope.h"
+
+namespace maple {
+#define SET_FUNC_INFO_PAIR(A, B, C, D)                                                             \
+  do {                                                                                             \
+    (A).PushbackMIRInfo(MIRInfoPair(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(B), C)); \
+    (A).PushbackIsString(D);                                                                       \
+  } while (0)                                                                                      \
+
+class FEFunction {
+ public:
+  FEFunction(MIRFunction &argMIRFunction, const std::unique_ptr<FEFunctionPhaseResult> &argPhaseResultTotal);
+  virtual ~FEFunction();
+
+  // element memory manage method
+  FEIRStmt *RegisterGeneralStmt(std::unique_ptr<FEIRStmt> stmt);
+  const std::unique_ptr<FEIRStmt> &RegisterGeneralStmtUniqueReturn(std::unique_ptr<FEIRStmt> stmt);
+  FEIRBB *RegisterFEIRBB(std::unique_ptr<FEIRBB> bb);
+  FEIRStmt *RegisterFEIRStmt(UniqueFEIRStmt stmt);
+  std::string GetDescription();
+  void OutputUseDefChain();
+  void OutputDefUseChain();
+  void PushFuncScope(const SrcPosition &startOfScope, const SrcPosition &endOfScope);
+  void PushStmtScope(const SrcPosition &startOfScope, const SrcPosition &endOfScope, bool isControllScope = false);
+  void PushStmtScope(bool isControllScope);
+  UniqueFEIRScope PopTopScope();
+  FEIRScope *GetTopFEIRScopePtr() const;
+  MIRScope *GetTopMIRScope() const;
+  virtual void AddVLACleanupStmts(std::list<UniqueFEIRStmt> &stmts);
+
+  void SetSrcFileName(const std::string &fileName) {
+    srcFileName = fileName;
+  }
+
+  const FEIRStmt *GetFEIRStmtHead() const {
+    ASSERT_NOT_NULL(feirStmtHead);
+    return feirStmtHead;
+  }
+
+  const FEIRStmt *GetFEIRStmtTail() const {
+    ASSERT_NOT_NULL(feirStmtTail);
+    return feirStmtTail;
+  }
+
+  void Init() {
+    InitImpl();
+  }
+
+  void AppendFEIRStmts(std::list<UniqueFEIRStmt> &stmts);
+  void InsertFEIRStmtsBefore(FEIRStmt &pos, std::list<UniqueFEIRStmt> &stmts);
+
+  void PreProcess() {
+    PreProcessImpl();
+  }
+
+  bool Process() {
+    return ProcessImpl();
+  }
+
+  void Finish() {
+    FinishImpl();
+  }
+
+  uint32 GetStmtCount() const {
+    return stmtCount;
+  }
+
+  std::unordered_map<uint32, std::pair<StIdx, StIdx>> &GetBoundaryMap() {
+    return boundaryMap;
+  }
+
+  const std::unordered_map<uint32, std::pair<StIdx, StIdx>> &GetBoundaryMap() const {
+    return boundaryMap;
+  }
+
+  void SetBoundaryMap(uint32 tag, const std::pair<StIdx, StIdx> &boundaryVar) {
+    boundaryMap[tag] = boundaryVar;
+  }
+
+  std::stack<bool> &GetSafeRegionFlag() {
+    return safeRegionFlag;
+  }
+
+  const std::stack<bool> &GetSafeRegionFlag() const {
+    return safeRegionFlag;
+  }
+
+  const std::deque<UniqueFEIRScope> &GetScopeStack() const {
+    return scopeStack;
+  }
+
+  void SetLabelWithScopes(std::string labelName, std::map<uint32, UniqueFEIRScope> scopes) {
+    labelWithScopes.insert(std::make_pair(labelName, std::move(scopes)));
+  }
+
+  const std::unordered_map<std::string, std::map<uint32, UniqueFEIRScope>> &GetLabelWithScopes() const {
+    return labelWithScopes;
+  }
+
+ LLT_PROTECTED:
+  // run phase routines
+  virtual bool GenerateGeneralStmt(const std::string &phaseName) = 0;
+  virtual bool LabelGeneralStmts(const std::string &phaseName);
+  virtual bool LabelFEIRBBs(const std::string &phaseName);
+  virtual bool ProcessFEIRFunction();
+
+  virtual bool GenerateArgVarList(const std::string &phaseName) = 0;
+  virtual bool GenerateAliasVars(const std::string &phaseName) = 0;
+  virtual bool EmitToFEIRStmt(const std::string &phaseName) = 0;
+  virtual bool BuildMapLabelStmt(const std::string &phaseName);
+  virtual bool SetupFEIRStmtJavaTry(const std::string &phaseName);
+  virtual bool SetupFEIRStmtBranch(const std::string &phaseName);
+  virtual bool UpdateRegNum2This(const std::string &phaseName);
+  bool LowerFunc(const std::string &phaseName);
+  bool DumpFEIRBBs(const std::string &phaseName);
+  bool DumpFEIRCFGGraph(const std::string &phaseName);
+  bool BuildFEIRDFG(const std::string &phaseName);  // process fe ir check point, build fe ir DFG
+  bool BuildFEIRUDDU(const std::string &phaseName);  // build fe ir UD DU chain
+  bool TypeInfer(const std::string &phaseName);  // feir based Type Infer
+
+  // finish phase routines
+  bool BuildGeneralStmtBBMap(const std::string &phaseName);
+  bool UpdateFormal(const std::string &phaseName);
+  virtual bool EmitToMIR(const std::string &phaseName);
+
+  // interface methods
+  virtual void InitImpl();
+  virtual void PreProcessImpl() {}
+  virtual bool ProcessImpl() {
+    return true;
+  }
+
+  virtual void FinishImpl() {}
+  virtual bool PreProcessTypeNameIdx() = 0;
+  virtual void GenerateGeneralStmtFailCallBack() = 0;
+  virtual void GenerateGeneralDebugInfo() = 0;
+  virtual bool VerifyGeneral() = 0;
+  virtual void VerifyGeneralFailCallBack() = 0;
+  virtual void DumpGeneralStmts();
+  virtual std::string GetGeneralFuncName() const;
+  void EmitToMIRStmt();
+
+  void PhaseTimerStart(FETimerNS &timer) const;
+  void PhaseTimerStopAndDump(FETimerNS &timer, const std::string &label) const;
+  virtual void DumpFEIRCFGGraphForDFGEdge(std::ofstream &file);
+  virtual bool HasThis() = 0;
+  virtual bool IsNative() = 0;
+  void BuildMapLabelIdx();
+  bool CheckPhaseResult(const std::string &phaseName);
+
+  FEIRStmt *genStmtHead;
+  FEIRStmt *genStmtTail;
+  std::list<FEIRStmt*> genStmtListRaw;
+  FEIRBB *genBBHead;
+  FEIRBB *genBBTail;
+  FEIRStmt *feirStmtHead;
+  FEIRStmt *feirStmtTail;
+  FEIRBB *feirBBHead;
+  FEIRBB *feirBBTail;
+  std::unique_ptr<FEIRLower> feirLower;
+  std::unique_ptr<FEIRCFG> feirCFG;
+  std::map<const FEIRStmt*, FEIRBB*> genStmtBBMap;
+  std::vector<std::unique_ptr<FEIRVar>> argVarList;
+  std::map<uint32, LabelIdx> mapLabelIdx;
+  std::map<uint32, FEIRStmtPesudoLabel*> mapLabelStmt;
+  FEFunctionPhaseResult phaseResult;
+  const std::unique_ptr<FEFunctionPhaseResult> &phaseResultTotal;
+  std::string srcFileName = "";
+  MIRSrcLang srcLang = kSrcLangJava;
+  MIRFunction &mirFunction;
+
+ LLT_PRIVATE:
+  void OutputStmts() const;
+  bool SetupFEIRStmtGoto(FEIRStmtGoto &stmt);
+  bool SetupFEIRStmtSwitch(FEIRStmtSwitch &stmt);
+  const FEIRStmtPesudoLOC *GetLOCForStmt(const FEIRStmt &feIRStmt) const;
+  void AddLocForStmt(const FEIRStmt &stmt, std::list<StmtNode*> &mirStmts) const;
+  void LabelFEIRStmts();  // label fe ir stmts
+  FEIRBB *NewFEIRBB(uint32 &id);
+  bool IsBBEnd(const FEIRStmt &stmt) const;
+  bool MayBeBBEnd(const FEIRStmt &stmt) const;
+  bool ShouldNewBB(const FEIRBB *currBB, const FEIRStmt &currStmt) const;
+  void LinkFallThroughBBAndItsNext(FEIRBB &bb);
+  void LinkBranchBBAndItsTargets(FEIRBB &bb);
+  void LinkGotoBBAndItsTarget(FEIRBB &bb, const FEIRStmt &stmtTail);
+  void LinkSwitchBBAndItsTargets(FEIRBB &bb, const FEIRStmt &stmtTail);
+  void LinkBB(FEIRBB &predBB, FEIRBB &succBB);
+  FEIRBB &GetFEIRBBByStmt(const FEIRStmt &stmt);
+  bool CheckBBsStmtNoAuxTail(const FEIRBB &bb) const;
+  void ProcessCheckPoints();
+  void InsertCheckPointForBBs();
+  void InsertCheckPointForTrys();
+  void InitFirstVisibleStmtForCheckPoints();
+  void InitFEIRStmtCheckPointMap();
+  void RegisterDFGNodes2CheckPoints();
+  void RegisterDFGNodesForFuncParameters();
+  void RegisterDFGNodesForStmts();
+  bool CalculateDefs4AllUses();
+  void InitTrans4AllVars();
+  void InsertRetypeStmtsAfterDef(const UniqueFEIRVar& def);
+  FEIRStmtPesudoJavaTry2 &GetJavaTryByCheckPoint(FEIRStmtCheckPoint &checkPoint);
+  FEIRStmtCheckPoint &GetCheckPointByFEIRStmt(const FEIRStmt &stmt);
+  void SetUpDefVarTypeScatterStmtMap();
+  FEIRStmt &GetStmtByDefVarTypeScatter(const FEIRVarTypeScatter &varTypeScatter);
+  void InsertRetypeStmt(const FEIRVarTypeScatter &fromVar, const FEIRType &toType);
+  void InsertCvtStmt(const FEIRVarTypeScatter &fromVar, const FEIRType &toType);
+  void InsertJavaMergeStmt(const FEIRVarTypeScatter &fromVar, const FEIRType &toType);
+  void InsertDAssignStmt4TypeCvt(const FEIRVarTypeScatter &fromVar, const FEIRType &toType, UniqueFEIRExpr expr);
+  bool WithFinalFieldsNeedBarrier(MIRClassType *classType, bool isStatic) const;
+  bool IsNeedInsertBarrier();
+
+  std::list<std::unique_ptr<FEIRStmt>> genStmtList;
+  std::list<std::unique_ptr<FEIRBB>> genBBList;
+  // FeirStmts generated by feirLower are inserted after the kStmtPesudoFuncEnd and linked,
+  // Access sequential feirStmt instructions through a doubly linked FELinkListNode from feirStmtHead
+  std::list<UniqueFEIRStmt> feirStmtList;
+  std::list<std::unique_ptr<FEIRBB>> feirBBList;
+  std::map<const FEIRStmt*, FEIRBB*> feirStmtBBMap;
+  std::map<const FEIRStmt*, FEIRStmtCheckPoint*> feirStmtCheckPointMap;
+  std::map<FEIRStmtCheckPoint*, FEIRStmtPesudoJavaTry2*> checkPointJavaTryMap;
+  std::unique_ptr<FEIRTypeInfer> typeInfer;
+  uint32 stmtCount = 0;
+  std::map<const FEIRVarTypeScatter*, FEIRStmt*> defVarTypeScatterStmtMap;
+  std::unordered_map<uint32, std::pair<StIdx, StIdx>> boundaryMap; // EnhanceC boundary var
+  std::stack<bool> safeRegionFlag; // EnhanceC saferegion(true: safe, false: unsafe)
+  std::deque<UniqueFEIRScope> scopeStack;  // an element of the stack represents the scope
+  uint32 scopeID = 0;
+  std::unordered_map<std::string, std::map<uint32, UniqueFEIRScope>> labelWithScopes;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_FUNCTION_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_function_phase_result.h b/src/hir2mpl/common/include/fe_function_phase_result.h
new file mode 100644
index 0000000000000000000000000000000000000000..192981ed3e1af05ac45b3bbbe2d36ea515c7b375
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_function_phase_result.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_FUNCTION_PHASE_RESULT_H
+#define HIR2MPL_INCLUDE_COMMON_FE_FUNCTION_PHASE_RESULT_H
+#include <map>
+#include <string>
+#include <list>
+#include "types_def.h"
+#include "fe_timer_ns.h"
+
+namespace maple {
+class FEFunctionPhaseResult {
+ public:
+  explicit FEFunctionPhaseResult(bool argRecordTime = false)
+      : recordTime(argRecordTime),
+        success(true),
+        enable(true) {}
+
+  ~FEFunctionPhaseResult() = default;
+  void Combine(const FEFunctionPhaseResult &result);
+  void Dump();
+  void DumpMS();
+  bool Finish(bool isSuccess);
+  bool Finish() {
+    return Finish(success);
+  }
+
+  void Start() {
+    if (enable && recordTime) {
+      timer.Start();
+    }
+  }
+
+  bool IsSuccess() const {
+    return success;
+  }
+
+  void Disable() {
+    enable = false;
+  }
+
+  void Enable() {
+    enable = true;
+  }
+
+  void RegisterPhaseName(const std::string &name) {
+    if (enable && recordTime) {
+      currPhaseName = name;
+      phaseNames.push_back(name);
+    }
+  }
+
+  void RegisterPhaseNameAndStart(const std::string &name) {
+    if (enable && recordTime) {
+      currPhaseName = name;
+      phaseNames.push_back(name);
+      timer.Start();
+    }
+  }
+
+ private:
+  FETimerNS timer;
+  bool recordTime : 1;
+  bool success : 1;
+  bool enable : 1;
+  std::string currPhaseName = "";
+  std::list<std::string> phaseNames;
+  std::map<std::string, int64> phaseTimes;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_FUNCTION_PHASE_RESULT_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_input.h b/src/hir2mpl/common/include/fe_input.h
new file mode 100644
index 0000000000000000000000000000000000000000..b9cdfd2d2ace67c6fce6270297a56baf618a7f53
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_input.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FE_INPUT_H
+#define HIR2MPL_INCLUDE_FE_INPUT_H
+#include "global_tables.h"
+#include "mir_module.h"
+#include "mpl_logging.h"
+
+namespace maple {
+class FEInputUnit {
+ public:
+  FEInputUnit() {}
+  virtual ~FEInputUnit() = default;
+  GStrIdx GetNameIdxOrin() {
+    return GetNameIdxOrinImpl();
+  }
+
+  GStrIdx GetNameIdxMpl() {
+    return GetNameIdxMplImpl();
+  }
+
+  std::string GetCatagoryName() {
+    return GetCatagoryNameImpl();
+  }
+
+ protected:
+  virtual GStrIdx GetNameIdxOrinImpl() = 0;
+  virtual GStrIdx GetNameIdxMplImpl() = 0;
+  virtual std::string GetCatagoryNameImpl() = 0;
+};
+
+enum FEInputSameNamePolicy {
+  kUseFirst,
+  kUseNewest,
+  kFatalOnce,
+  kFatalAll
+};
+
+template <typename T>
+class FEInputContent {
+ public:
+  explicit FEInputContent(MapleAllocator &alloc);
+  ~FEInputContent() = default;
+  void RegisterItem(T &item);
+  void CheckSameName();
+
+ private:
+  MapleAllocator &allocator;
+  MapleList<T*> items;
+  MapleUnorderedMap<GStrIdx, T*, GStrIdxHash> nameItemMap;
+  MapleList<GStrIdx> sameNames;
+  FEInputSameNamePolicy policySameName;
+
+  void EraseItem(GStrIdx nameIdxMpl);
+};
+
+class FEInputUnitExt {
+};
+
+class FEInputProgramUnit {
+};
+
+class FEInputUnitMethod : public FEInputUnit {
+ public:
+  explicit FEInputUnitMethod(MapleAllocator &alloc);
+  ~FEInputUnitMethod() = default;
+
+ protected:
+  std::string GetCatagoryNameImpl() override;
+
+  MapleAllocator &allocator;
+};
+
+class FEInputUnitVariable : public FEInputUnit {
+ public:
+  explicit FEInputUnitVariable(MapleAllocator &alloc);
+  ~FEInputUnitVariable() = default;
+
+ protected:
+  std::string GetCatagoryNameImpl() override;
+
+  MapleAllocator &allocator;
+};
+
+class FEInputUnitStruct : public FEInputUnit {
+ public:
+  explicit FEInputUnitStruct(MapleAllocator &alloc);
+  virtual ~FEInputUnitStruct() = default;
+  MIRTypeKind GetMIRTypeKind() const {
+    return typeKind;
+  }
+
+ protected:
+  std::string GetCatagoryNameImpl() override;
+
+  MapleAllocator &allocator;
+  FEInputContent<FEInputUnitMethod> methods;
+  FEInputContent<FEInputUnitMethod> methodsStatic;
+  FEInputContent<FEInputUnitVariable> fields;
+  FEInputContent<FEInputUnitVariable> fieldsStatic;
+  MIRTypeKind typeKind;
+};
+}  // namespace maple
+#endif
diff --git a/src/hir2mpl/common/include/fe_input_helper.h b/src/hir2mpl/common/include/fe_input_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..edb5a9bb71e1eecc22ef583156a2f96dfa0e20b1
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_input_helper.h
@@ -0,0 +1,461 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FE_INPUT_HELPER_H
+#define HIR2MPL_INCLUDE_FE_INPUT_HELPER_H
+#include "mempool_allocator.h"
+#include "mir_type.h"
+#include "mir_pragma.h"
+#include "mir_symbol.h"
+#include "feir_type.h"
+#include "fe_function.h"
+
+namespace maple {
+struct ExtraField {
+  std::string klass;
+  std::string field;
+  std::string type;
+  std::string attr;
+};
+
+class FEInputContainer {
+ public:
+  FEInputContainer() = default;
+  virtual ~FEInputContainer() = default;
+  MIRStructType *GetContainer() {
+    return GetContainerImpl();
+  }
+
+ protected:
+  virtual MIRStructType *GetContainerImpl() = 0;
+};
+
+class FEInputPragmaHelper {
+ public:
+  FEInputPragmaHelper() = default;
+  virtual ~FEInputPragmaHelper() = default;
+  std::vector<MIRPragma*> &GenerateMIRPragmas() {
+    return GenerateMIRPragmasImpl();
+  }
+
+ protected:
+  virtual std::vector<MIRPragma*> &GenerateMIRPragmasImpl() = 0;
+};
+
+class FEInputStructHelper;
+
+class FEInputGlobalVarHelper {
+ public:
+  explicit FEInputGlobalVarHelper(MapleAllocator &allocatorIn) : allocator(allocatorIn) {}
+  virtual ~FEInputGlobalVarHelper() = default;
+
+  bool ProcessDecl() {
+    return ProcessDecl(allocator);
+  }
+
+  bool ProcessDecl(MapleAllocator &allocatorIn) {
+    return ProcessDeclImpl(allocatorIn);
+  }
+
+ protected:
+  MapleAllocator &allocator;
+  virtual bool ProcessDeclImpl(MapleAllocator &allocator) = 0;
+};
+
+class FEInputFileScopeAsmHelper {
+ public:
+  explicit FEInputFileScopeAsmHelper(MapleAllocator &allocatorIn) : allocator(allocatorIn) {}
+  virtual ~FEInputFileScopeAsmHelper() = default;
+
+  bool ProcessDecl() {
+    return ProcessDecl(allocator);
+  }
+
+  bool ProcessDecl(MapleAllocator &allocatorIn) {
+    return ProcessDeclImpl(allocatorIn);
+  }
+
+ protected:
+  MapleAllocator &allocator;
+  virtual bool ProcessDeclImpl(MapleAllocator &allocator) = 0;
+};
+
+class FEInputEnumHelper {
+ public:
+  explicit FEInputEnumHelper(MapleAllocator &allocatorIn) : allocator(allocatorIn) {}
+  virtual ~FEInputEnumHelper() = default;
+
+  bool ProcessDecl() {
+    return ProcessDecl(allocator);
+  }
+
+  bool ProcessDecl(MapleAllocator &allocatorIn) {
+    return ProcessDeclImpl(allocatorIn);
+  }
+
+ protected:
+  MapleAllocator &allocator;
+  virtual bool ProcessDeclImpl(MapleAllocator &allocator) = 0;
+};
+
+class FEInputFieldHelper {
+ public:
+  explicit FEInputFieldHelper(MapleAllocator &allocatorIn) : allocator(allocatorIn) {}
+  virtual ~FEInputFieldHelper() = default;
+  const FieldPair &GetMIRFieldPair() const {
+    return mirFieldPair;
+  }
+
+  bool IsStatic() const {
+    return mirFieldPair.second.second.GetAttr(FLDATTR_static);
+  }
+
+  bool ProcessDecl() {
+    return ProcessDecl(allocator);
+  }
+
+  bool ProcessDecl(MapleAllocator &alloc) {
+    return ProcessDeclImpl(alloc);
+  }
+
+  bool ProcessDeclWithContainer(MapleAllocator &alloc) {
+    return ProcessDeclWithContainerImpl(alloc);
+  }
+
+  static void SetFieldAttribute(const std::string &name, FieldAttrs &attr) {
+#define FIELD_ATTR
+#define ATTR(A)                     \
+    if (!strcmp(name.c_str(), #A)) {  \
+      attr.SetAttr(FLDATTR_##A);      \
+      return;                         \
+    }
+#include "all_attributes.def"
+#undef ATTR
+#undef FIELD_ATTR
+  }
+
+ protected:
+  virtual bool ProcessDeclImpl(MapleAllocator &allocator) = 0;
+  virtual bool ProcessDeclWithContainerImpl(MapleAllocator &allocator) = 0;
+
+  MapleAllocator &allocator;
+  FieldPair mirFieldPair;
+};
+
+class FEInputMethodHelper {
+ public:
+  explicit FEInputMethodHelper(MapleAllocator &allocatorIn)
+      : allocator(allocatorIn),
+        srcLang(kSrcLangUnknown),
+        feFunc(nullptr),
+        mirFunc(nullptr),
+        retType(nullptr),
+        argTypes(allocator.Adapter()),
+        retMIRType(nullptr),
+        argMIRTypes(allocator.Adapter()),
+        methodNameIdx(GStrIdx(0)) {}
+
+  virtual ~FEInputMethodHelper() {
+    feFunc = nullptr;
+    mirFunc = nullptr;
+    retType = nullptr;
+    retMIRType = nullptr;
+  }
+
+  const MethodPair &GetMIRMethodPair() const {
+    return mirMethodPair;
+  }
+
+  const FEIRType *GetReturnType() const {
+    return retType;
+  }
+
+  const MapleVector<FEIRType*> &GetArgTypes() const {
+    return argTypes;
+  }
+
+  bool ProcessDecl() {
+    return ProcessDecl(allocator);
+  }
+
+  bool ProcessDecl(MapleAllocator &allocatorIn) {
+    return ProcessDeclImpl(allocatorIn);
+  }
+
+  void SolveReturnAndArgTypes(MapleAllocator &allocatorIn) {
+    SolveReturnAndArgTypesImpl(allocatorIn);
+  }
+
+  std::string GetMethodName(bool inMpl, bool full = true) const {
+    return GetMethodNameImpl(inMpl, full);
+  }
+
+  FuncAttrs GetAttrs() const {
+    return GetAttrsImpl();
+  }
+
+  bool IsStatic() const {
+    return IsStaticImpl();
+  }
+
+  bool IsVirtual() const {
+    return IsVirtualImpl();
+  }
+
+  bool IsNative() const {
+    return IsNativeImpl();
+  }
+
+  bool IsVarg() const {
+    return IsVargImpl();
+  }
+
+  bool HasThis() const {
+    return HasThisImpl();
+  }
+
+  MIRType *GetTypeForThis() const {
+    return GetTypeForThisImpl();
+  }
+
+  GStrIdx GetMethodNameIdx() const {
+    return methodNameIdx;
+  }
+
+  bool HasCode() const {
+    return HasCodeImpl();
+  }
+
+  void SetClassTypeInfo(const MIRStructType &structType) {
+    mirFunc->SetClassTyIdx(structType.GetTypeIndex());
+  }
+
+ protected:
+  virtual bool ProcessDeclImpl(MapleAllocator &allocatorIn);
+  virtual void SolveReturnAndArgTypesImpl(MapleAllocator &allocator) = 0;
+  virtual std::string GetMethodNameImpl(bool inMpl, bool full) const = 0;
+  virtual FuncAttrs GetAttrsImpl() const = 0;
+  virtual bool IsStaticImpl() const = 0;
+  virtual bool IsVirtualImpl() const = 0;
+  virtual bool IsNativeImpl() const = 0;
+  virtual bool IsVargImpl() const = 0;
+  virtual bool HasThisImpl() const = 0;
+  virtual MIRType *GetTypeForThisImpl() const = 0;
+  virtual bool HasCodeImpl() const = 0;
+
+  MapleAllocator &allocator;
+  MIRSrcLang srcLang;
+  FEFunction *feFunc;
+  MIRFunction *mirFunc;
+  MethodPair mirMethodPair;
+  FEIRType *retType;
+  MapleVector<FEIRType*> argTypes;
+  // Added MIRType to support C and extended to Java later.
+  MIRType *retMIRType;
+  MapleVector<MIRType*> argMIRTypes;
+  GStrIdx methodNameIdx;
+};
+
+class FEInputStructHelper : public FEInputContainer {
+ public:
+  explicit FEInputStructHelper(MapleAllocator &allocatorIn)
+      : allocator(allocatorIn),
+        mirStructType(nullptr),
+        mirSymbol(nullptr),
+        fieldHelpers(allocator.Adapter()),
+        methodHelpers(allocator.Adapter()),
+        pragmaHelper(nullptr),
+        staticFieldsConstVal(allocator.Adapter()),
+        isSkipped(false),
+        srcLang(kSrcLangJava) {}
+
+  ~FEInputStructHelper() override {
+    mirStructType = nullptr;
+    mirSymbol = nullptr;
+    pragmaHelper = nullptr;
+  }
+
+  bool IsSkipped() const {
+    return isSkipped;
+  }
+
+  const TypeAttrs GetStructAttributeFromSymbol() const {
+    if (mirSymbol != nullptr) {
+      return mirSymbol->GetAttrs();
+    }
+    return TypeAttrs();
+  }
+
+  MIRSrcLang GetSrcLang() const {
+    return srcLang;
+  }
+
+  const MapleList<FEInputMethodHelper*> &GetMethodHelpers() const {
+    return methodHelpers;
+  }
+
+  bool PreProcessDecl() {
+    return PreProcessDeclImpl();
+  }
+
+  bool ProcessDecl() {
+    return ProcessDeclImpl();
+  }
+
+  std::string GetStructNameOrin() const {
+    return GetStructNameOrinImpl();
+  }
+
+  std::string GetStructNameMpl() const {
+    return GetStructNameMplImpl();
+  }
+
+  std::list<std::string> GetSuperClassNames() const {
+    return GetSuperClassNamesImpl();
+  }
+
+  std::vector<std::string> GetInterfaceNames() const {
+    return GetInterfaceNamesImpl();
+  }
+
+  std::string GetSourceFileName() const {
+    return GetSourceFileNameImpl();
+  }
+
+  std::string GetSrcFileName() const {
+    return GetSrcFileNameImpl();
+  }
+
+  MIRStructType *CreateMIRStructType(bool &error) const {
+    return CreateMIRStructTypeImpl(error);
+  }
+
+  TypeAttrs GetStructAttributeFromInput() const {
+    return GetStructAttributeFromInputImpl();
+  }
+
+  uint64 GetRawAccessFlags() const {
+    return GetRawAccessFlagsImpl();
+  }
+
+  GStrIdx GetIRSrcFileSigIdx() const {
+    return GetIRSrcFileSigIdxImpl();
+  }
+
+  bool IsMultiDef() const {
+    return IsMultiDefImpl();
+  }
+
+  void InitFieldHelpers() {
+    InitFieldHelpersImpl();
+  }
+
+  void InitMethodHelpers() {
+    InitMethodHelpersImpl();
+  }
+
+  void SetPragmaHelper(FEInputPragmaHelper *pragmaHelperIn) {
+    pragmaHelper = pragmaHelperIn;
+  }
+
+  void SetStaticFieldsConstVal(const std::vector<MIRConst*> &val) {
+    staticFieldsConstVal.resize(val.size());
+    for (uint32 i = 0; i < val.size(); ++i) {
+      staticFieldsConstVal[i] = val[i];
+    }
+  }
+
+  void SetFinalStaticStringIDVec(const std::vector<uint32> &stringIDVec) {
+    finalStaticStringID = stringIDVec;
+  }
+
+  void SetIsOnDemandLoad(bool flag) {
+    isOnDemandLoad = flag;
+  }
+
+  void ProcessPragma();
+
+ protected:
+  MIRStructType *GetContainerImpl() override;
+  virtual bool PreProcessDeclImpl();
+  virtual bool ProcessDeclImpl();
+  virtual std::string GetStructNameOrinImpl() const = 0;
+  virtual std::string GetStructNameMplImpl() const = 0;
+  virtual std::list<std::string> GetSuperClassNamesImpl() const = 0;
+  virtual std::vector<std::string> GetInterfaceNamesImpl() const = 0;
+  virtual std::string GetSourceFileNameImpl() const = 0;
+  virtual std::string GetSrcFileNameImpl() const;
+  virtual MIRStructType *CreateMIRStructTypeImpl(bool &error) const = 0;
+  virtual TypeAttrs GetStructAttributeFromInputImpl() const = 0;
+  virtual uint64 GetRawAccessFlagsImpl() const = 0;
+  virtual GStrIdx GetIRSrcFileSigIdxImpl() const = 0;
+  virtual bool IsMultiDefImpl() const = 0;
+  virtual void InitFieldHelpersImpl() = 0;
+  virtual void InitMethodHelpersImpl() = 0;
+  void CreateSymbol();
+  void ProcessDeclSuperClass();
+  void ProcessDeclSuperClassForJava();
+  void ProcessDeclImplements();
+  void ProcessDeclDefInfo();
+  void ProcessDeclDefInfoSuperNameForJava();
+  void ProcessDeclDefInfoImplementNameForJava();
+  void ProcessFieldDef();
+  void ProcessExtraFields();
+  void ProcessMethodDef();
+  void ProcessStaticFields();
+
+  MapleAllocator &allocator;
+  MIRStructType *mirStructType;
+  MIRSymbol *mirSymbol;
+  MapleList<FEInputFieldHelper*> fieldHelpers;
+  MapleList<FEInputMethodHelper*> methodHelpers;
+  FEInputPragmaHelper *pragmaHelper;
+  MapleVector<MIRConst*> staticFieldsConstVal;
+  std::vector<uint32> finalStaticStringID;
+  bool isSkipped;
+  MIRSrcLang srcLang;
+  bool isOnDemandLoad = false;
+};
+
+class FEInputHelper {
+ public:
+  explicit FEInputHelper(MapleAllocator &allocatorIn)
+      : allocator(allocatorIn),
+        fieldHelpers(allocator.Adapter()),
+        methodHelpers(allocator.Adapter()),
+        structHelpers(allocator.Adapter()) {}
+  ~FEInputHelper() = default;
+  bool PreProcessDecl();
+  bool ProcessDecl();
+  bool ProcessImpl() const;
+  void RegisterFieldHelper(FEInputFieldHelper &helper) {
+    fieldHelpers.push_back(&helper);
+  }
+
+  void RegisterMethodHelper(FEInputMethodHelper &helper) {
+    methodHelpers.push_back(&helper);
+  }
+
+  void RegisterStructHelper(FEInputStructHelper &helper) {
+    structHelpers.push_back(&helper);
+  }
+
+ private:
+  MapleAllocator &allocator;
+  MapleList<FEInputFieldHelper*> fieldHelpers;
+  MapleList<FEInputMethodHelper*> methodHelpers;
+  MapleList<FEInputStructHelper*> structHelpers;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FE_INPUT_HELPER_H
diff --git a/src/hir2mpl/common/include/fe_java_string_manager.h b/src/hir2mpl/common/include/fe_java_string_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..870c65bdb46baa7d94b4bc699647f211c1e04054
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_java_string_manager.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_JAVA_STRING_MANAGER_H
+#define HIR2MPL_INCLUDE_COMMON_FE_JAVA_STRING_MANAGER_H
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include "mir_module.h"
+#include "mir_builder.h"
+
+namespace maple {
+class FEJavaStringManager {
+ public:
+  FEJavaStringManager(MIRModule &argModule, MIRBuilder &mirBuilderIn);
+  ~FEJavaStringManager();
+  void ClearStringMetaClassSymbolExternFlag();
+  // profiling
+  void LoadProfilingData(const std::string &profileFileName);
+  MIRSymbol *GetLiteralPtrVar(const MIRSymbol *var) const;
+  MIRSymbol *GetLiteralPtrVar(const std::string &str) const;
+  MIRSymbol *GetLiteralPtrVar(const std::u16string &strU16) const;
+  // methods for string
+  MIRSymbol *CreateLiteralVar(MIRBuilder &mirBuilderIn, const std::string &str, bool isFieldValue);
+  MIRSymbol *CreateLiteralVar(MIRBuilder &mirBuilderIn, const std::u16string &strU16, bool isFieldValue);
+  MIRSymbol *GetLiteralVar(const std::string &str) const;
+  MIRSymbol *GetLiteralVar(const std::u16string &strU16) const;
+  static std::string GetLiteralGlobalName(const std::u16string &strU16);
+  static bool IsAllASCII(const std::u16string &strU16);
+  void GenStringMetaClassVar();
+
+ private:
+  using DWBuffer = struct {
+    uint64_t data;
+    uint32_t pos;
+  };
+
+  MIRArrayType *ConstructArrayType4Str(const std::u16string &strU16, bool compressible) const;
+  MIRAggConst *CreateByteArrayConst(const std::u16string &strU16, MIRArrayType &byteArrayType, bool compressible) const;
+  static std::vector<uint8> SwapBytes(const std::u16string &strU16);
+  static uint16 ExchangeBytesPosition(uint16 input);
+  template <typename T>
+  static void AddDataIntoByteArray(MIRAggConst &newConst, MemPool &mp, DWBuffer &buf, T data, MIRType &uInt64);
+  static void FinishByteArray(MIRAggConst &newConst, MemPool &mp, DWBuffer &buf, MIRType &uInt64);
+
+  MIRModule &module;
+  MIRBuilder &mirBuilder;
+  bool useCompressedJavaString = true;
+  std::unordered_set<std::string> preloadSet;
+  std::unordered_set<MIRSymbol*> literalSet;
+  std::unordered_set<MIRSymbol*> fieldValueSet;
+  std::map<const MIRSymbol*, MIRSymbol*> literalMap;
+  MIRType *typeString = nullptr;
+  MIRSymbol *stringMetaClassSymbol = nullptr;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_JAVA_STRING_MANAGER_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_macros.h b/src/hir2mpl/common/include/fe_macros.h
new file mode 100644
index 0000000000000000000000000000000000000000..c607f79fd4ec0fabebcc2948845c4508ff833eec
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_macros.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FE_MACROS_H
+#define HIR2MPL_INCLUDE_FE_MACROS_H
+#include <cstdio>
+#include <sys/time.h>
+#include <iostream>
+#include <sstream>
+#include "fe_options.h"
+#include "mpl_logging.h"
+
+#define TIMEIT(message, stmt) do {                                                                                 \
+  if (FEOptions::GetInstance().IsDumpTime()) {                                                                     \
+    struct timeval start, end;                                                                                     \
+    (void)gettimeofday(&start, NULL);                                                                              \
+    stmt;                                                                                                          \
+    (void)gettimeofday(&end, NULL);                                                                                \
+    float t = ((end.tv_sec * 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec)) * 1.0 / 1000000.0; \
+    INFO(kLncInfo, "[TIME] %s: %.3f sec", message, t);                                                             \
+  } else {                                                                                                         \
+    stmt;                                                                                                          \
+  }                                                                                                                \
+} while (0)                                                                                                        \
+
+#define PHASE_TIMER(message, stmt) do {                                               \
+  if (FEOptions::GetInstance().IsDumpPhaseTime()) {                                   \
+    struct timespec start = {0, 0};                                                   \
+    struct timespec end = {0, 0};                                                     \
+    (void)clock_gettime(CLOCK_REALTIME, &start);                                      \
+    stmt;                                                                             \
+    (void)clock_gettime(CLOCK_REALTIME, &end);                                        \
+    constexpr int64_t nsInS = 1000000000;                                             \
+    int64_t t = (end.tv_sec - start.tv_sec) * nsInS + (end.tv_nsec - start.tv_nsec);  \
+    INFO(kLncInfo, "[PhaseTime]   %s: %lld ns", message, t);                          \
+  } else {                                                                            \
+    stmt;                                                                             \
+  }                                                                                   \
+} while (0)                                                                           \
+
+#define FE_INFO_LEVEL(level, fmt, ...) do {               \
+  if (FEOptions::GetInstance().GetDumpLevel() >= level) { \
+    INFO(kLncInfo, fmt, ##__VA_ARGS__);                   \
+  }                                                       \
+} while (0)                                               \
+
+#define BIT_XOR(v1, v2) (((v1) && (!(v2))) || ((!(v1)) && (v2)))
+
+#define TRY_DO(run) do {        \
+  CHECK_FATAL(run, "%s", #run); \
+} while (0)
+
+// for user
+#define FE_ERR(num, loc, fmt, ...) do {                                                                             \
+  if (PRINT_LEVEL_USER <= kLlErr) {                                                                                 \
+      std::ostringstream ss;                                                                                        \
+      ss << FEManager::GetModule().GetFileNameFromFileNum(loc.fileIdx) << ":" << loc.line << " error: " << fmt;     \
+      logInfo.InsertUserErrorMessage(                                                                               \
+          loc, logInfo.EmitLogToStringForUser(num, kLlErr, ss.str().c_str(), ##__VA_ARGS__));                       \
+  }                                                                                                                 \
+} while (0)
+
+#define FE_WARN(num, loc, fmt, ...) do {                                                                            \
+  if (PRINT_LEVEL_USER <= kLlWarn) {                                                                                \
+      std::ostringstream ss;                                                                                        \
+      ss << FEManager::GetModule().GetFileNameFromFileNum(loc.fileIdx) << ":" << loc.line << " warning: " << fmt;   \
+      logInfo.InsertUserWarnMessage(                                                                                \
+          loc, logInfo.EmitLogToStringForUser(num, kLlWarn, ss.str().c_str(), ##__VA_ARGS__));                      \
+  }                                                                                                                 \
+} while (0)
+#endif  // ~HIR2MPL_INCLUDE_FE_MACROS_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_manager.h b/src/hir2mpl/common/include/fe_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ca99cecc49af3490beade5533e018cf14cdc338
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_manager.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_MANAGER_H
+#define HIR2MPL_INCLUDE_COMMON_FE_MANAGER_H
+#include <memory>
+#include "mir_module.h"
+#include "mir_builder.h"
+#include "fe_type_manager.h"
+#include "fe_java_string_manager.h"
+#include "fe_function.h"
+
+namespace maple {
+class FEManager {
+ public:
+  static FEManager &GetManager() {
+    ASSERT(manager != nullptr, "manager is not initialize");
+    return *manager;
+  }
+
+  static FETypeManager &GetTypeManager() {
+    ASSERT(manager != nullptr, "manager is not initialize");
+    return manager->typeManager;
+  }
+
+  static FEJavaStringManager &GetJavaStringManager() {
+    ASSERT(manager != nullptr, "manager is not initialize");
+    return manager->javaStringManager;
+  }
+
+  static MIRBuilder &GetMIRBuilder() {
+    ASSERT(manager != nullptr, "manager is not initialize");
+    return manager->builder;
+  }
+
+  static MIRModule &GetModule() {
+    ASSERT(manager != nullptr, "manager is not initialize");
+    return manager->module;
+  }
+
+  static void SetCurrentFEFunction(FEFunction &func) {
+    ASSERT(manager != nullptr, "manager is not initialize");
+    manager->curFEFunction = &func;
+  }
+
+  static FEFunction &GetCurrentFEFunction() {
+    ASSERT(manager != nullptr, "manager is not initialize");
+    CHECK_NULL_FATAL(manager->curFEFunction);
+    return *manager->curFEFunction;
+  }
+
+  static void Init(MIRModule &moduleIn) {
+    manager = new FEManager(moduleIn);
+  }
+
+  static void Release() {
+    if (manager != nullptr) {
+      manager->typeManager.ReleaseMemPool();
+      delete manager;
+      manager = nullptr;
+    }
+  }
+
+  StructElemNameIdx *GetFieldStructElemNameIdx(uint64 index) {
+    auto it = mapFieldStructElemNameIdx.find(index);
+    if (it != mapFieldStructElemNameIdx.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+
+  void SetFieldStructElemNameIdx(uint64 index, StructElemNameIdx &structElemNameIdx) {
+    std::lock_guard<std::mutex> lk(feManagerMapStructElemNameIdxMtx);
+    mapFieldStructElemNameIdx[index] = &structElemNameIdx;
+  }
+
+  StructElemNameIdx *GetMethodStructElemNameIdx(uint64 index) {
+    auto it = mapMethodStructElemNameIdx.find(index);
+    if (it != mapMethodStructElemNameIdx.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+
+  void SetMethodStructElemNameIdx(uint64 index, StructElemNameIdx &structElemNameIdx) {
+    std::lock_guard<std::mutex> lk(feManagerMapStructElemNameIdxMtx);
+    mapMethodStructElemNameIdx[index] = &structElemNameIdx;
+  }
+
+  MemPool *GetStructElemMempool() {
+    return structElemMempool;
+  }
+
+  void ReleaseStructElemMempool() {
+    FEUtils::DeleteMempoolPtr(structElemMempool);
+  }
+
+  uint32 RegisterSourceFileIdx(const GStrIdx &strIdx) {
+    const auto it = sourceFileIdxMap.find(strIdx);
+    if (it != sourceFileIdxMap.end()) {
+      return it->second;
+    } else {
+      // make src files start from #2, #1 is mpl file
+      size_t num = sourceFileIdxMap.size() + 2;
+      (void)sourceFileIdxMap.emplace(strIdx, num);
+#ifdef DEBUG
+      idxSourceFileMap.emplace(num, strIdx);
+#endif
+      module.PushbackFileInfo(MIRInfoPair(strIdx, num));
+      return static_cast<uint32>(num);
+    }
+  }
+
+  std::string GetSourceFileNameFromIdx(uint32 idx) const {
+    auto it = idxSourceFileMap.find(idx);
+    if (it != idxSourceFileMap.end()) {
+      return GlobalTables::GetStrTable().GetStringFromStrIdx(it->second);
+    }
+    return "unknown";
+  }
+
+ private:
+  static FEManager *manager;
+  MIRModule &module;
+  FETypeManager typeManager;
+  MIRBuilder builder;
+  FEFunction *curFEFunction = nullptr;
+  FEJavaStringManager javaStringManager;
+  MemPool *structElemMempool;
+  MapleAllocator structElemAllocator;
+  std::unordered_map<uint64, StructElemNameIdx*> mapFieldStructElemNameIdx;
+  std::unordered_map<uint64, StructElemNameIdx*> mapMethodStructElemNameIdx;
+  std::map<GStrIdx, uint32> sourceFileIdxMap;
+  std::map<uint32, GStrIdx> idxSourceFileMap;
+  explicit FEManager(MIRModule &moduleIn)
+      : module(moduleIn),
+        typeManager(module),
+        builder(&module),
+        javaStringManager(moduleIn, builder),
+        structElemMempool(FEUtils::NewMempool("MemPool for StructElemNameIdx", false /* isLcalPool */)),
+        structElemAllocator(structElemMempool) {}
+  ~FEManager() {
+    structElemMempool = nullptr;
+  }
+  mutable std::mutex feManagerMapStructElemNameIdxMtx;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_MANAGER_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_options.h b/src/hir2mpl/common/include/fe_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..d115838d32ead18bc749980137f21384201710eb
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_options.h
@@ -0,0 +1,581 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_OPTIONS_H
+#define HIR2MPL_INCLUDE_COMMON_FE_OPTIONS_H
+#include <list>
+#include <vector>
+#include <string>
+#include <set>
+#include "mpl_logging.h"
+#include "types_def.h"
+
+namespace maple {
+class FEOptions {
+ public:
+  static const int kDumpLevelDisable = 0;
+  static const int kDumpLevelInfo = 1;
+  static const int kDumpLevelInfoDetail = 2;
+  static const int kDumpLevelInfoDebug = 3;
+
+  enum ModeJavaStaticFieldName {
+    kNoType = 0,      // without type
+    kAllType,         // with type
+    kSmart            // auto anti-proguard
+  };
+
+  enum ModeCollectDepTypes {
+    kAll = 0,      // collect all dependent types
+    kFunc          // collect func dependent types
+  };
+
+  enum ModeDepSameNamePolicy {
+    kSys = 0,      // load type form sys when on-demand load same name type
+    kSrc           // load type form src when on-demand load same name type
+  };
+
+  enum TypeInferKind {
+    kNo = 0,
+    kRoahAlgorithm,
+    kLinearScan
+  };
+
+  static FEOptions &GetInstance() {
+    return options;
+  }
+
+  void Init() {
+    isJBCUseImpreciseType = true;
+  }
+
+  // input control options
+  void AddInputClassFile(const std::string &fileName);
+  const std::list<std::string> &GetInputClassFiles() const {
+    return inputClassFiles;
+  }
+
+  void AddInputJarFile(const std::string &fileName);
+  const std::list<std::string> &GetInputJarFiles() const {
+    return inputJarFiles;
+  }
+
+  void AddInputDexFile(const std::string &fileName);
+  const std::vector<std::string> &GetInputDexFiles() const {
+    return inputDexFiles;
+  }
+
+  void AddInputASTFile(const std::string &fileName);
+  const std::vector<std::string> &GetInputASTFiles() const {
+    return inputASTFiles;
+  }
+
+  void AddInputMASTFile(const std::string &fileName);
+  const std::vector<std::string> &GetInputMASTFiles() const {
+    return inputMASTFiles;
+  }
+
+  void AddInputMpltFileFromSys(const std::string &fileName) {
+    inputMpltFilesFromSys.push_back(fileName);
+  }
+
+  const std::list<std::string> &GetInputMpltFilesFromSys() const {
+    return inputMpltFilesFromSys;
+  }
+
+  void AddInputMpltFileFromApk(const std::string &fileName) {
+    inputMpltFilesFromApk.push_back(fileName);
+  }
+
+  const std::list<std::string> &GetInputMpltFilesFromApk() const {
+    return inputMpltFilesFromApk;
+  }
+
+  void AddInputMpltFile(const std::string &fileName) {
+    inputMpltFiles.push_back(fileName);
+  }
+
+  const std::list<std::string> &GetInputMpltFiles() const {
+    return inputMpltFiles;
+  }
+
+  // On Demand Type Creation
+  void SetXBootClassPath(const std::string &fileName) {
+    strXBootClassPath = fileName;
+  }
+
+  const std::string &GetXBootClassPath() const {
+    return strXBootClassPath;
+  }
+
+  void SetClassLoaderContext(const std::string &fileName) {
+    strClassLoaderContext = fileName;
+  }
+
+  const std::string &GetClassLoaderContext() const {
+    return strClassLoaderContext;
+  }
+
+  void SetCompileFileName(const std::string &fileName) {
+    strCompileFileName = fileName;
+  }
+
+  const std::string &GetCompileFileName() const {
+    return strCompileFileName;
+  }
+
+  void SetModeCollectDepTypes(ModeCollectDepTypes mode) {
+    modeCollectDepTypes = mode;
+  }
+
+  ModeCollectDepTypes GetModeCollectDepTypes() const {
+    return modeCollectDepTypes;
+  }
+
+  void SetModeDepSameNamePolicy(ModeDepSameNamePolicy mode) {
+    modeDepSameNamePolicy = mode;
+  }
+
+  ModeDepSameNamePolicy GetModeDepSameNamePolicy() const {
+    return modeDepSameNamePolicy;
+  }
+
+  // output control options
+  void SetIsGenMpltOnly(bool flag) {
+    isGenMpltOnly = flag;
+  }
+
+  bool IsGenMpltOnly() const {
+    return isGenMpltOnly;
+  }
+
+  void SetIsGenAsciiMplt(bool flag) {
+    isGenAsciiMplt = flag;
+  }
+
+  bool IsGenAsciiMplt() const {
+    return isGenAsciiMplt;
+  }
+
+  void SetOutputPath(const std::string &path) {
+    outputPath = path;
+  }
+
+  const std::string &GetOutputPath() const {
+    return outputPath;
+  }
+
+  void SetOutputName(const std::string &name) {
+    outputName = name;
+  }
+
+  const std::string &GetOutputName() const {
+    return outputName;
+  }
+
+  void EnableDumpInstComment() {
+    isDumpInstComment = true;
+  }
+
+  void DisableDumpInstComment() {
+    isDumpInstComment = false;
+  }
+
+  bool IsDumpInstComment() const {
+    return isDumpInstComment;
+  }
+
+  void SetNoMplFile() {
+    isNoMplFile = true;
+  }
+
+  bool IsNoMplFile() const {
+    return isNoMplFile;
+  }
+
+  // debug info control options
+  void SetDumpLevel(int level) {
+    dumpLevel = level;
+  }
+
+  int GetDumpLevel() const {
+    return dumpLevel;
+  }
+
+  void SetIsDumpTime(bool flag) {
+    isDumpTime = flag;
+  }
+
+  bool IsDumpTime() const {
+    return isDumpTime;
+  }
+
+  void SetIsDumpComment(bool flag) {
+    isDumpComment = flag;
+  }
+
+  bool IsDumpComment() const {
+    return isDumpComment;
+  }
+
+  void SetIsDumpLOC(bool flag) {
+    isDumpLOC = flag;
+  }
+
+  bool IsDumpLOC() const {
+    return isDumpLOC;
+  }
+
+  void SetDbgFriendly(bool flag) {
+    isDbgFriendly = flag;
+    // set isDumpLOC if flag is true
+    isDumpLOC = flag ? flag : isDumpLOC;
+  }
+
+  bool IsDbgFriendly() const {
+    return isDbgFriendly;
+  }
+
+  void SetIsDumpPhaseTime(bool flag) {
+    isDumpPhaseTime = flag;
+  }
+
+  bool IsDumpPhaseTime() const {
+    return isDumpPhaseTime;
+  }
+
+  void SetIsDumpPhaseTimeDetail(bool flag) {
+    isDumpPhaseTimeDetail = flag;
+  }
+
+  bool IsDumpPhaseTimeDetail() const {
+    return isDumpPhaseTimeDetail;
+  }
+
+  // java compiler options
+  void SetModeJavaStaticFieldName(ModeJavaStaticFieldName mode) {
+    modeJavaStaticField = mode;
+  }
+
+  ModeJavaStaticFieldName GetModeJavaStaticFieldName() const {
+    return modeJavaStaticField;
+  }
+
+  void SetIsJBCUseImpreciseType(bool flag) {
+    isJBCUseImpreciseType = flag;
+  }
+
+  bool IsJBCUseImpreciseType() const {
+    return isJBCUseImpreciseType;
+  }
+
+  void SetIsJBCInfoUsePathName(bool flag) {
+    isJBCInfoUsePathName = flag;
+  }
+
+  bool IsJBCInfoUsePathName() const {
+    return isJBCInfoUsePathName;
+  }
+
+  void SetIsDumpJBCStmt(bool flag) {
+    isDumpJBCStmt = flag;
+  }
+
+  bool IsDumpJBCStmt() const {
+    return isDumpJBCStmt;
+  }
+
+  void SetIsDumpFEIRBB(bool flag) {
+    isDumpBB = flag;
+  }
+
+  bool IsDumpFEIRBB() const {
+    return isDumpBB;
+  }
+
+  void AddFuncNameForDumpCFGGraph(const std::string &funcName) {
+    funcNamesForDumpCFGGraph.insert(funcName);
+  }
+
+  bool IsDumpFEIRCFGGraph(const std::string &funcName) const {
+    return funcNamesForDumpCFGGraph.find(funcName) !=
+           funcNamesForDumpCFGGraph.end();
+  }
+
+  void SetIsDumpJBCAll(bool flag) {
+    isDumpJBCAll = flag;
+  }
+
+  bool IsDumpJBCAll() const {
+    return isDumpJBCAll;
+  }
+
+  void SetIsDumpJBCErrorOnly(bool flag) {
+    isDumpJBCErrorOnly = flag;
+  }
+
+  bool IsDumpJBCErrorOnly() const {
+    return isDumpJBCErrorOnly;
+  }
+
+  void SetIsEmitJBCLocalVarInfo(bool flag) {
+    isEmitJBCLocalVarInfo = flag;
+  }
+
+  bool IsEmitJBCLocalVarInfo() const {
+    return isEmitJBCLocalVarInfo;
+  }
+
+  // parallel
+  void SetNThreads(uint32 n) {
+    nthreads = n;
+  }
+
+  uint32 GetNThreads() const {
+    return nthreads;
+  }
+
+  void SetDumpThreadTime(bool arg) {
+    dumpThreadTime = arg;
+  }
+
+  bool IsDumpThreadTime() const {
+    return dumpThreadTime;
+  }
+
+  void AddDumpJBCFuncName(const std::string &funcName) {
+    if (!funcName.empty()) {
+      CHECK_FATAL(dumpJBCFuncNames.insert(funcName).second, "dumpJBCFuncNames insert failed");
+    }
+  }
+
+  const std::set<std::string> &GetDumpJBCFuncNames() const {
+    return dumpJBCFuncNames;
+  }
+
+  bool IsDumpJBCFuncName(const std::string &funcName) const {
+    return dumpJBCFuncNames.find(funcName) != dumpJBCFuncNames.end();
+  }
+
+  void SetTypeInferKind(TypeInferKind arg) {
+    typeInferKind = arg;
+  }
+
+  TypeInferKind GetTypeInferKind() const {
+    return typeInferKind;
+  }
+
+  bool IsRC() const {
+    return isRC;
+  }
+
+  void SetRC(bool arg) {
+    isRC = arg;
+  }
+
+  bool IsNoBarrier() const {
+    return isNoBarrier;
+  }
+
+  void SetNoBarrier(bool arg) {
+    isNoBarrier = arg;
+  }
+
+  bool HasJBC() const {
+    return ((inputClassFiles.size() != 0) || (inputJarFiles.size() != 0));
+  }
+
+  void SetIsAOT(bool flag) {
+    isAOT = flag;
+  }
+
+  bool IsAOT() const {
+    return isAOT;
+  }
+
+  void SetUseSignedChar(bool flag) {
+    useSignedChar = flag;
+  }
+
+  bool IsUseSignedChar() const {
+    return useSignedChar;
+  }
+
+  void SetBigEndian(bool flag) {
+    isBigEndian = flag;
+  }
+
+  bool IsBigEndian() const {
+    return isBigEndian;
+  }
+
+  void SetNpeCheckDynamic(bool flag) {
+    isNpeCheckDynamic = flag;
+  }
+
+  bool IsNpeCheckDynamic() const {
+    return isNpeCheckDynamic;
+  }
+
+  void SetBoundaryCheckDynamic(bool flag) {
+    isBoundaryCheckDynamic = flag;
+  }
+
+  bool IsBoundaryCheckDynamic() const {
+    return isBoundaryCheckDynamic;
+  }
+
+  void SetSafeRegion(bool flag) {
+    isEnableSafeRegion = flag;
+  }
+
+  bool IsEnableSafeRegion() const {
+    return isEnableSafeRegion;
+  }
+
+  void SetDefaultSafe(bool flag) {
+    isDefaultSafe = flag;
+  }
+
+  bool IsDefaultSafe() const {
+    if (IsEnableSafeRegion()) {
+      return isDefaultSafe;
+    }
+    return false;
+  }
+
+  void SetO2(bool flag) {
+    isO2 = flag;
+  }
+
+  bool IsO2() const {
+    return isO2;
+  }
+
+  void SetSimplifyShortCircuit(bool flag) {
+    isSimplifyShortCircuit = flag;
+  }
+
+  bool IsSimplifyShortCircuit() const {
+    return isSimplifyShortCircuit;
+  }
+
+  void SetEnableVariableArray(bool flag) {
+    isEnableVariableArray = flag;
+  }
+
+  bool IsEnableVariableArray() const {
+    return isEnableVariableArray;
+  }
+
+  void SetFuncInlineSize(uint32 size) {
+    funcInlineSize = size;
+  }
+
+  uint32 GetFuncInlineSize() const {
+    return funcInlineSize;
+  }
+
+  void SetWPAA(bool flag) {
+    wpaa = flag;
+  }
+
+  bool GetWPAA() const {
+    return wpaa;
+  }
+
+ private:
+  static FEOptions options;
+  // input control options
+  std::list<std::string> inputClassFiles;
+  std::list<std::string> inputJarFiles;
+  std::vector<std::string> inputDexFiles;
+  std::vector<std::string> inputASTFiles;
+  std::vector<std::string> inputMASTFiles;
+  std::list<std::string> inputMpltFilesFromSys;
+  std::list<std::string> inputMpltFilesFromApk;
+  std::list<std::string> inputMpltFiles;
+
+  // On Demand Type Creation
+  std::string strXBootClassPath;
+  std::string strClassLoaderContext;
+  std::string strCompileFileName;
+  ModeCollectDepTypes modeCollectDepTypes = ModeCollectDepTypes::kFunc;
+  ModeDepSameNamePolicy modeDepSameNamePolicy = ModeDepSameNamePolicy::kSys;
+
+  // output control options
+  bool isGenMpltOnly;
+  bool isGenAsciiMplt;
+  std::string outputPath;
+  std::string outputName;
+  bool isDumpInstComment = false;
+  bool isNoMplFile = false;
+
+  // debug info control options
+  int dumpLevel;
+  bool isDumpTime;
+  bool isDumpComment = false;
+  bool isDumpLOC = true;
+  bool isDbgFriendly = false;
+  bool isDumpPhaseTime = false;
+  bool isDumpPhaseTimeDetail = false;
+
+  // java compiler options
+  ModeJavaStaticFieldName modeJavaStaticField = ModeJavaStaticFieldName::kNoType;
+  bool isJBCUseImpreciseType = false;
+  bool isJBCInfoUsePathName = false;
+  bool isDumpJBCStmt = false;
+  bool isDumpJBCAll = false;
+  bool isDumpJBCErrorOnly = false;
+  std::set<std::string> dumpJBCFuncNames;
+  bool isEmitJBCLocalVarInfo = false;
+
+  // bc compiler options
+  bool isRC = false;
+  bool isNoBarrier = false;
+  bool isO2 = false;
+  bool isSimplifyShortCircuit = false;
+  bool isEnableVariableArray = false;
+
+  // ast compiler options
+  bool useSignedChar = false;
+  bool isBigEndian = false;
+
+  // general stmt/bb/cfg debug options
+  bool isDumpBB = false;
+  std::set<std::string> funcNamesForDumpCFGGraph;
+
+  // parallel
+  uint32 nthreads;
+  bool dumpThreadTime;
+
+  // type-infer
+  TypeInferKind typeInferKind = kLinearScan;
+
+  // symbol resolve
+  bool isAOT = false;
+
+  // EnhanceC
+  bool isNpeCheckDynamic = false;
+  bool isBoundaryCheckDynamic = false;
+  bool isEnableSafeRegion = false;
+  bool isDefaultSafe = false;
+
+  uint32 funcInlineSize = 0;
+  bool wpaa = false;
+
+  FEOptions();
+  ~FEOptions() = default;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_OPTIONS_H
diff --git a/src/hir2mpl/common/include/fe_struct_elem_info.h b/src/hir2mpl/common/include/fe_struct_elem_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..98130125bf7be4f71acfb1b953f26f8b5c01a008
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_struct_elem_info.h
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_STRUCT_ELEM_INFO_H
+#define HIR2MPL_INCLUDE_COMMON_FE_STRUCT_ELEM_INFO_H
+#include <memory>
+#include <unordered_set>
+#include "global_tables.h"
+#include "fe_configs.h"
+#include "feir_type.h"
+
+namespace maple {
+struct StructElemNameIdx {
+  GStrIdx klass;
+  GStrIdx elem;
+  GStrIdx type;
+  GStrIdx full;
+
+  StructElemNameIdx(const GStrIdx &argKlass, const GStrIdx &argElem, const GStrIdx &argType, const GStrIdx &argFull)
+      : klass(argKlass), elem(argElem), type(argType), full(argFull) {}
+
+  StructElemNameIdx(const std::string &klassStr, const std::string &elemStr, const std::string &typeStr) {
+    const std::string &fullName = klassStr + "|" + elemStr + "|" + typeStr;
+    klass = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(klassStr));
+    elem = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(elemStr));
+    type = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(typeStr));
+    full = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(fullName));
+  }
+
+  explicit StructElemNameIdx(const std::string &funcStr) {
+    klass = GStrIdx(0);
+    elem = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcStr);
+    type = GStrIdx(0);
+    full = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcStr);
+  }
+  ~StructElemNameIdx() = default;
+};
+
+class FEStructElemInfo {
+ public:
+  FEStructElemInfo(MapleAllocator &allocatorIn, const StructElemNameIdx &argStructElemNameIdx,
+                   MIRSrcLang argSrcLang, bool argIsStatic);
+  virtual ~FEStructElemInfo() = default;
+
+  void Prepare(MIRBuilder &mirBuilder, bool argIsStatic) {
+    PrepareImpl(mirBuilder, argIsStatic);
+  }
+
+  const std::string &GetStructName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx.klass);
+  }
+
+  const std::string &GetElemName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx.elem);
+  }
+
+  const GStrIdx &GetElemNameIdx() const {
+    return structElemNameIdx.elem;
+  }
+
+  const std::string &GetSignatureName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx.type);
+  }
+
+  bool IsStatic() const {
+    return isStatic;
+  }
+
+  bool IsMethod() const {
+    return isMethod;
+  }
+
+  bool IsDefined() const {
+    return isDefined;
+  }
+
+  void SetDefined() {
+    isDefined = true;
+  }
+
+  void SetUndefined() {
+    isDefined = false;
+  }
+
+  bool IsFromDex() const {
+    return isFromDex;
+  }
+
+  void SetFromDex() {
+    isFromDex = true;
+  }
+
+  MIRSrcLang GetSrcLang() const {
+    return srcLang;
+  }
+
+  void SetSrcLang(MIRSrcLang lang) {
+    srcLang = lang;
+  }
+
+  UniqueFEIRType GetActualContainerType() const;
+  const std::string GetActualContainerName() const {
+    return actualContainer.c_str();
+  }
+
+ LLT_PROTECTED:
+  virtual void PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) = 0;
+
+  bool isStatic : 1;
+  bool isMethod : 1;
+  bool isDefined : 1;
+  bool isFromDex : 1;
+  bool isPrepared : 1;
+  MIRSrcLang srcLang : 8;
+  MapleAllocator &allocator;
+  StructElemNameIdx structElemNameIdx;
+  MapleString actualContainer; // in maple format
+};
+
+using UniqueFEStructElemInfo = std::unique_ptr<FEStructElemInfo>;
+
+class FEStructFieldInfo : public FEStructElemInfo {
+ public:
+  FEStructFieldInfo(MapleAllocator &allocatorIn, const StructElemNameIdx &argStructElemNameIdx,
+                    MIRSrcLang argSrcLang, bool argIsStatic);
+  ~FEStructFieldInfo() override {
+    fieldType = nullptr;
+  }
+  GStrIdx GetFieldNameIdx() const {
+    return fieldNameIdx;
+  }
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(const FieldID argFieldID) {
+    fieldID = argFieldID;
+  }
+
+  const FEIRType *GetType() const {
+    return fieldType;
+  }
+
+  bool IsVolatile() const {
+    return isVolatile;
+  }
+
+ LLT_PROTECTED:
+  void PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) override;
+
+ LLT_PRIVATE:
+  void LoadFieldType();
+  void LoadFieldTypeJava();
+  void PrepareStaticField(const MIRStructType &structType);
+  void PrepareNonStaticField(MIRBuilder &mirBuilder);
+  bool SearchStructFieldJava(MIRStructType &structType, MIRBuilder &mirBuilder, bool argIsStatic,
+                             bool allowPrivate = true);
+  bool SearchStructFieldJava(const TyIdx &tyIdx, MIRBuilder &mirBuilder, bool argIsStatic, bool allowPrivate = true);
+  bool CompareFieldType(const FieldPair &fieldPair) const;
+
+  FEIRType *fieldType;
+  GStrIdx fieldNameIdx;
+  FieldID fieldID;
+  bool isVolatile;
+};
+
+class FEStructMethodInfo : public FEStructElemInfo {
+ public:
+  FEStructMethodInfo(MapleAllocator &allocatorIn, const StructElemNameIdx &argStructElemNameIdx,
+                     MIRSrcLang argSrcLang, bool argIsStatic);
+  ~FEStructMethodInfo() override;
+  PUIdx GetPuIdx() const;
+  bool IsConstructor() const {
+    return isConstructor;
+  }
+
+  bool IsReturnVoid() const {
+    return isReturnVoid;
+  }
+
+  void SetReturnVoid() {
+    isReturnVoid = true;
+  }
+
+  bool IsJavaPolymorphicCall() const {
+    return isJavaPolymorphicCall;
+  }
+
+  bool IsJavaDynamicCall() const {
+    return isJavaDynamicCall;
+  }
+
+  void SetJavaDyamicCall() {
+    isJavaDynamicCall = true;
+  }
+
+  void UnsetJavaDynamicCall() {
+    isJavaDynamicCall = false;
+  }
+
+  const FEIRType *GetReturnType() const {
+    return retType;
+  }
+
+  void SetReturnType(FEIRType *type) {
+    retType = type;
+  }
+
+  const FEIRType *GetOwnerType() const {
+    return ownerType;
+  }
+
+  const MapleVector<FEIRType*> &GetArgTypes() const {
+    return argTypes;
+  }
+
+  void SetArgTypes(const MapleVector<FEIRType*> &argTypesIn) {
+    argTypes = argTypesIn;
+  }
+
+  void SetArgsName(const std::vector<std::string> &names) {
+    argNames = names;
+  }
+
+  const std::vector<std::string> &GetArgsName() const {
+    return argNames;
+  }
+
+  void SetFuncAttrs(const FuncAttrs &attrs) {
+    funcAttrs = attrs;
+  }
+
+  const FuncAttrs &GetFuncAttrs() const {
+    return funcAttrs;
+  }
+
+  MIRFunction *GetMirFunc() const {
+    CHECK_NULL_FATAL(mirFunc);
+    return mirFunc;
+  }
+
+ LLT_PROTECTED:
+  void PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) override;
+
+ LLT_PRIVATE:
+  void LoadMethodType();
+  void LoadMethodTypeJava();
+  void PrepareMethod();
+  void PrepareMethodC();
+  void PrepareImplJava(MIRBuilder &mirBuilder, bool argIsStatic);
+  bool SearchStructMethodJava(MIRStructType &structType, MIRBuilder &mirBuilder, bool argIsStatic,
+                              bool allowPrivate = true);
+  bool SearchStructMethodJavaInParent(MIRStructType &structType, MIRBuilder &mirBuilder, bool argIsStatic);
+  bool SearchStructMethodJava(const TyIdx &tyIdx, MIRBuilder &mirBuilder, bool argIsStatic, bool allowPrivate = true);
+
+  bool isReturnVoid;
+  bool isConstructor;
+  bool isJavaPolymorphicCall;
+  bool isJavaDynamicCall;
+  GStrIdx methodNameIdx;
+  FEIRType *retType;
+  FEIRType *ownerType;
+  MIRFunction *mirFunc;
+  MapleVector<FEIRType*> argTypes;
+  std::vector<std::string> argNames;
+  FuncAttrs funcAttrs;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_STRUCT_ELEM_INFO_H
diff --git a/src/hir2mpl/common/include/fe_timer.h b/src/hir2mpl/common/include/fe_timer.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ff67103e1047e442d7fd697f83f382494242f70
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_timer.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_TIMER_H
+#define HIR2MPL_INCLUDE_COMMON_FE_TIMER_H
+#include <string>
+#include <functional>
+#include "mpl_timer.h"
+#include "mpl_logging.h"
+#include "fe_options.h"
+
+namespace maple {
+class FETimer {
+ public:
+  FETimer() = default;
+  ~FETimer() = default;
+  void Start() {
+    if (!FEOptions::GetInstance().IsDumpTime()) {
+      return;
+    }
+    timer.Start();
+  }
+
+  void StartAndDump(const std::string &message) {
+    if (!FEOptions::GetInstance().IsDumpTime()) {
+      return;
+    }
+    CHECK_FATAL(!message.empty(), "message is empty");
+    timer.Start();
+    INFO(kLncInfo, "[Time] %s: starting...", message.c_str());
+  }
+
+  void StopAndDumpTimeMS(const std::string &message) {
+    if (!FEOptions::GetInstance().IsDumpTime()) {
+      return;
+    }
+    CHECK_FATAL(!message.empty(), "message is empty");
+    timer.Stop();
+    INFO(kLncInfo, "[Time] %s: finished (%ld ms)", message.c_str(), timer.ElapsedMilliseconds());
+  }
+
+  void StopAndDumpTimeS(const std::string &message) {
+    if (!FEOptions::GetInstance().IsDumpTime()) {
+      return;
+    }
+    CHECK_FATAL(!message.empty(), "message is empty");
+    timer.Stop();
+    INFO(kLncInfo, "[Time] %s: finished (%lf s)", message.c_str(), timer.ElapsedMilliseconds() / 1000.0);
+  }
+
+ private:
+  MPLTimer timer;
+};  // class FETimer
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_TIMER_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_timer_ns.h b/src/hir2mpl/common/include/fe_timer_ns.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8a73d19888eb7ad8de097a5b79b87ee7cf6d7c8
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_timer_ns.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_TIMER_NS_H
+#define HIR2MPL_INCLUDE_COMMON_FE_TIMER_NS_H
+#include <ctime>
+#include <cstdlib>
+
+namespace maple {
+class FETimerNS {
+ public:
+  FETimerNS() = default;
+  ~FETimerNS() = default;
+  void Start();
+  void Stop();
+  int64_t GetTimeNS() const;
+
+ private:
+  struct timespec timeStart = {0, 0};
+  struct timespec timeEnd = {0, 0};
+};  // class FETimerNS
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_TIMER_NS_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_type_hierarchy.h b/src/hir2mpl/common/include/fe_type_hierarchy.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c1899fd3ede2ccf6f59279c9e48839e2c4c2144
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_type_hierarchy.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FE_TYPE_HIERARCHY_H
+#define HIR2MPL_INCLUDE_FE_TYPE_HIERARCHY_H
+#include <map>
+#include <set>
+#include "mir_type.h"
+
+namespace maple {
+class FETypeHierarchy {
+ public:
+  static FETypeHierarchy &GetInstance() {
+    return instance;
+  }
+  void InitByGlobalTable();
+  void AddMIRType(const MIRClassType &type);
+  void AddMIRType(const MIRInterfaceType &type);
+  bool IsParentOf(const GStrIdx &parentIdx, const GStrIdx &childIdx);
+
+ private:
+  static FETypeHierarchy instance;
+  std::map<GStrIdx, std::set<GStrIdx>> mapIdxChildParent;
+  std::set<std::pair<GStrIdx, GStrIdx>> cache;
+  FETypeHierarchy() = default;
+  ~FETypeHierarchy() = default;
+  void AddParentChildRelation(const GStrIdx &parentIdx, const GStrIdx &childIdx);
+};  // class FETypeHierarchy
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FE_TYPE_HIERARCHY_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/fe_type_manager.h b/src/hir2mpl/common/include/fe_type_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d68a6c089b7a761cce9c688fec9ca2ce47d9c73
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_type_manager.h
@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FE_TYPE_MANAGER_H
+#define HIR2MPL_INCLUDE_COMMON_FE_TYPE_MANAGER_H
+#include <map>
+#include <memory>
+#include <list>
+#include "mempool_allocator.h"
+#include "mir_module.h"
+#include "mir_type.h"
+#include "mir_builder.h"
+#include "feir_type.h"
+#include "fe_struct_elem_info.h"
+#include "fe_utils.h"
+#include "feir_stmt.h"
+
+namespace maple {
+enum FETypeFlag : uint16 {
+  kDefault = 0,
+  kSrcMpltSys = 1,
+  kSrcInput = 1 << 1,
+  kSrcMpltApk = 1 << 2,
+  kSrcMplt = 1 << 3,
+  kSrcExtern = 1 << 4,
+  kSrcUnknown = 1 << 5,
+  kSrcMask = 0x3F,
+};
+
+class FETypeSameNamePolicy {
+ public:
+  FETypeSameNamePolicy() : flag(0) {}
+  ~FETypeSameNamePolicy() = default;
+  bool IsUseLastest() const {
+    return (flag & kFlagUseLastest) != 0;
+  }
+
+  bool IsFatal() const {
+    return (flag & kFlagFatal) != 0;
+  }
+
+  void SetFlag(uint8 flagIn) {
+    flag = flagIn;
+  }
+
+  static constexpr uint8 kFlagUseLastest = 0x1;
+  static constexpr uint8 kFlagFatal = 0x2;
+
+ private:
+  // bitwise flag
+  // bit0: 0-use first, 1-use lastest
+  // bit1: 0-warning, 1-fatal
+  uint8 flag;
+};
+
+using FEStructTypePair = std::pair<MIRStructType*, FETypeFlag>;
+
+class FETypeManager {
+ public:
+  // ---------- prim FEIRType ----------
+  const static UniqueFEIRType kPrimFEIRTypeUnknown;
+  const static UniqueFEIRType kPrimFEIRTypeU1;
+  const static UniqueFEIRType kPrimFEIRTypeI8;
+  const static UniqueFEIRType kPrimFEIRTypeU8;
+  const static UniqueFEIRType kPrimFEIRTypeI16;
+  const static UniqueFEIRType kPrimFEIRTypeU16;
+  const static UniqueFEIRType kPrimFEIRTypeI32;
+  const static UniqueFEIRType kPrimFEIRTypeU32;
+  const static UniqueFEIRType kPrimFEIRTypeI64;
+  const static UniqueFEIRType kPrimFEIRTypeU64;
+  const static UniqueFEIRType kPrimFEIRTypeF32;
+  const static UniqueFEIRType kPrimFEIRTypeF64;
+  const static UniqueFEIRType kFEIRTypeJavaObject;
+  const static UniqueFEIRType kFEIRTypeJavaClass;
+  const static UniqueFEIRType kFEIRTypeJavaString;
+
+  explicit FETypeManager(MIRModule &moduleIn);
+  ~FETypeManager();
+  void ReleaseMemPool();
+  bool LoadMplts(const std::list<std::string> &mpltNames, FETypeFlag flag, const std::string &phaseName);
+  bool LoadMplt(const std::string &mpltName, FETypeFlag flag);
+  void CheckSameNamePolicy() const;
+  // method for Class or Interface generation
+  MIRStructType *GetClassOrInterfaceType(const GStrIdx &nameIdx) const;
+  MIRStructType *GetClassOrInterfaceType(const std::string &name) const {
+    GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+    return GetClassOrInterfaceType(nameIdx);
+  }
+
+  FETypeFlag GetClassOrInterfaceTypeFlag(const GStrIdx &nameIdx) const;
+  FETypeFlag GetClassOrInterfaceTypeFlag(const std::string &name) const {
+    GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+    return GetClassOrInterfaceTypeFlag(nameIdx);
+  }
+
+  MIRStructType *CreateClassOrInterfaceType(const GStrIdx &nameIdx, bool isInterface, FETypeFlag typeFlag);
+  MIRStructType *CreateClassOrInterfaceType(const std::string &name, bool isInterface, FETypeFlag typeFlag) {
+    GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+    return CreateClassOrInterfaceType(nameIdx, isInterface, typeFlag);
+  }
+
+  MIRStructType *GetOrCreateStructType(const std::string &name);
+  MIRStructType *CreateStructType(const std::string &name);
+  MIRTypeByName *CreateTypeByNameType(const std::string &name);
+  MIRTypeByName *GetOrCreateTypeByNameType(const std::string &name);
+  MIRTypeByName *GetTypeByNameType(const std::string &name);
+  MIRTypeByName *GetTypeByNameType(const GStrIdx &nameIdx);
+  MIRTypeByName *CreateTypedef(const std::string &name, const MIRType &type);
+  MIREnum *CreateEnum(const std::string &name, PrimType primType);
+  MIREnum *GetOrCreateEnum(const std::string &name, PrimType primType = PTY_i32);
+  size_t GetEnumIdx(const std::string &name);
+  MIRType *GetOrCreateComplexStructType(const MIRType &elemType);
+  MIRStructType *GetOrCreateClassOrInterfaceType(const GStrIdx &nameIdx, bool isInterface, FETypeFlag typeFlag,
+                                                 bool &isCreate);
+  MIRStructType *GetOrCreateClassOrInterfaceType(const std::string &name, bool isInterface, FETypeFlag typeFlag,
+                                                 bool &isCreate) {
+    GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+    return GetOrCreateClassOrInterfaceType(nameIdx, isInterface, typeFlag, isCreate);
+  }
+
+  MIRType *GetOrCreateClassOrInterfacePtrType(const GStrIdx &nameIdx, bool isInterface, FETypeFlag typeFlag,
+                                              bool &isCreate);
+  MIRType *GetOrCreateClassOrInterfacePtrType(const std::string &name, bool isInterface, FETypeFlag typeFlag,
+                                              bool &isCreate) {
+    GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+    return GetOrCreateClassOrInterfacePtrType(nameIdx, isInterface, typeFlag, isCreate);
+  }
+
+  uint32 GetTypeIDFromMplClassName(const std::string &mplClassName, int32 dexFileHashCode) const;
+  MIRStructType *GetStructTypeFromName(const std::string &name);
+  MIRStructType *GetStructTypeFromName(const GStrIdx &nameIdx);
+  MIRType *GetOrCreateTypeFromName(const std::string &name, FETypeFlag typeFlag, bool usePtr);
+  MIRType *GetOrCreatePointerType(const MIRType &type, PrimType ptyPtr = PTY_ref);
+  MIRType *GetOrCreateArrayType(MIRType &elemType, uint8 dim, PrimType ptyPtr = PTY_ref);
+  MIRType *GetOrCreateJArrayType(MIRType &elemType, uint8 dim, PrimType ptyPtr = PTY_ref);
+  void AddClassToModule(const MIRStructType &structType);
+
+  // ---------- methods for StructElemInfo ----------
+  // structIdx = 0: global field/function without owner structure
+  FEStructElemInfo *RegisterStructFieldInfo(
+      const StructElemNameIdx &argStructElemNameIdx, MIRSrcLang argSrcLang, bool isStatic);
+  FEStructElemInfo *RegisterStructMethodInfo(
+      const StructElemNameIdx &argStructElemNameIdx, MIRSrcLang argSrcLang, bool isStatic);
+  FEStructElemInfo *RegisterStructMethodInfoC(
+      const std::string &name, MIRSrcLang argSrcLang, bool isStatic);
+  FEStructElemInfo *GetStructElemInfo(const GStrIdx &fullNameIdx) const;
+
+  // ---------- methods for MIRFunction ----------
+  /**
+   * Function Name: GetMIRFunction
+   * Description: get MIRFunction by class method name
+   *   1. return if exist in mpltFuncNameSymbolMap
+   *   2. return if exist in nameFuncMap
+   *   3. return null otherwise
+   * Parallel note: Parallelable
+   */
+  MIRFunction *GetMIRFunction(const std::string &classMethodName, bool isStatic);
+  MIRFunction *GetMIRFunction(const GStrIdx &nameIdx, bool isStatic);
+
+  /*
+   * Function Name: CreateMIRFunction
+   * Description: create MIRFunction by class method name
+   *   1. call GetMIRFunction first, if exist, return
+   *   2. create MIRFunction
+   * Parallel note: Non-parallelable
+   */
+  MIRFunction *CreateFunction(const GStrIdx &nameIdx, const TyIdx &retTypeIdx, const std::vector<TyIdx> &argsTypeIdx,
+                              bool isVarg, bool isStatic);
+  MIRFunction *CreateFunction(const std::string &methodName, const std::string &returnTypeName,
+                              const std::vector<std::string> &argTypeNames, bool isVarg, bool isStatic);
+
+  // FEIRType GetOrCreate
+  const FEIRType *GetOrCreateFEIRTypeByName(const std::string &typeName, const GStrIdx &typeNameIdx,
+                                            MIRSrcLang argSrcLang = kSrcLangJava);
+  const FEIRType *GetOrCreateFEIRTypeByName(const GStrIdx &typeNameIdx, MIRSrcLang argSrcLang = kSrcLangJava);
+  const FEIRType *GetFEIRTypeByName(const std::string &typeName) const;
+  const FEIRType *GetFEIRTypeByName(const GStrIdx &typeNameIdx) const;
+
+  // MCC function
+  void InitMCCFunctions();
+  MIRFunction *GetMCCFunction(const std::string &funcName) const;
+  MIRFunction *GetMCCFunction(const GStrIdx &funcNameIdx) const;
+  PUIdx GetPuIdxForMCCGetOrInsertLiteral() const {
+    return funcMCCGetOrInsertLiteral->GetPuidx();
+  }
+
+  // anti-proguard
+  bool IsAntiProguardFieldStruct(const GStrIdx &structNameIdx);
+
+  static bool IsStructType(const MIRType &type);
+  static PrimType GetPrimType(const std::string &name);
+  static MIRType *GetMIRTypeForPrim(char c);
+  static MIRType *GetMIRTypeForPrim(const std::string &name) {
+    if (name.length() != 1) {
+      return nullptr;
+    }
+    return GetMIRTypeForPrim(name[0]);
+  }
+
+  static std::string GetBaseTypeName(const std::string &name, uint32 &dim, bool inMpl = true);
+  static std::string GetBaseTypeName(const std::string &name, bool inMpl = true) {
+    uint32 dim = 0;
+    return GetBaseTypeName(name, dim, inMpl);
+  }
+  static void SetComplete(MIRStructType &structType);
+  static std::string TypeAttrsToString(const TypeAttrs &attrs);
+
+  bool IsImportedType(const GStrIdx &typeNameIdx) const {
+    return structNameTypeMap.find(typeNameIdx) != structNameTypeMap.end();
+  }
+
+  MIRStructType *GetImportedType(const GStrIdx &typeNameIdx) const {
+    auto it = structNameTypeMap.find(typeNameIdx);
+    if (it != structNameTypeMap.end()) {
+      return it->second.first;
+    }
+    return nullptr;
+  }
+
+  const std::unordered_map<GStrIdx, FEStructTypePair, GStrIdxHash> &GetStructNameTypeMap() const {
+    return structNameTypeMap;
+  }
+  void MarkExternStructType();
+  void SetMirImportedTypes(FETypeFlag flag);
+
+  void SetSrcLang(const MIRSrcLang &argSrcLang) {
+    srcLang = argSrcLang;
+  }
+
+  void InsertBoundaryLenExprHashMap(uint32 hash, UniqueFEIRExpr expr) {
+    (void)boundaryLenExprHashMap.insert(std::make_pair(hash, std::move(expr)));
+  }
+
+  UniqueFEIRExpr GetBoundaryLenExprFromMap(uint32 hash) {
+    auto iter = boundaryLenExprHashMap.find(hash);
+    if (iter != boundaryLenExprHashMap.end()) {
+      return iter->second->Clone();
+    }
+    return nullptr;
+  }
+
+  void InsertOwnedNonnullFieldStructSet(const TyIdx &tyidx) {
+    (void)ownedNonnullFieldStructSet.insert(tyidx);
+  }
+
+  bool IsOwnedNonnullFieldStructSet(const TyIdx &tyidx) {
+    auto iter = ownedNonnullFieldStructSet.find(tyidx);
+    if (iter != ownedNonnullFieldStructSet.end()) {
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  void UpdateStructNameTypeMapFromTypeTable(const std::string &mpltName, FETypeFlag flag);
+  void UpdateNameFuncMapFromTypeTable();
+  void UpdateDupTypes(const GStrIdx &nameIdx, bool isInterface,
+                      const std::unordered_map<GStrIdx, FEStructTypePair, GStrIdxHash>::iterator &importedTypeIt);
+
+  // MCC function
+  void InitFuncMCCGetOrInsertLiteral();
+  using mirFuncPair = std::pair<char, MIRFunction*>;
+
+  MIRModule &module;
+  MemPool *mp;
+  MapleAllocator allocator;
+  MIRBuilder builder;
+  // map<structNameIdx, pair>
+  std::unordered_map<GStrIdx, FEStructTypePair, GStrIdxHash> structNameTypeMap;
+  // map<structNameIdx, mpltNameIdx>
+  std::unordered_map<GStrIdx, GStrIdx, GStrIdxHash> structNameSrcMap;
+  // list<pair<structNameIdx, mpltNameIdx>>
+  std::list<std::pair<GStrIdx, GStrIdx>> structSameNameSrcList;
+  FETypeSameNamePolicy sameNamePolicy;
+  MIRSrcLang srcLang;
+
+  // ---------- class name ---> type id map info ----------
+  using classNameTypeIDMapT = std::unordered_map<std::string, uint32>;
+  std::map<int32, classNameTypeIDMapT> classNameTypeIDMapAllDex; // dexFileHashCode className classTpyeID
+  // ---------- struct elem info ----------
+  std::map<GStrIdx, FEStructElemInfo*> mapStructElemInfo;
+
+  // ---------- function list ----------
+  std::unordered_map<GStrIdx, MIRFunction*, GStrIdxHash> nameFuncMap;
+  std::unordered_map<GStrIdx, MIRFunction*, GStrIdxHash> nameStaticFuncMap;
+  std::unordered_map<GStrIdx, MIRFunction*, GStrIdxHash> mpltNameFuncMap;
+  std::unordered_map<GStrIdx, MIRFunction*, GStrIdxHash> mpltNameStaticFuncMap;
+
+  // ---------- FEIRType list ----------
+  std::unordered_map<GStrIdx, const FEIRType*, GStrIdxHash> nameFEIRTypeMap;
+  std::list<UniqueFEIRType> nameFEIRTypeList;
+
+  // ---------- MCC function list  ----------
+  std::unordered_map<GStrIdx, MIRFunction*, GStrIdxHash> nameMCCFuncMap;
+  MIRFunction *funcMCCGetOrInsertLiteral;
+
+  // ---------- ast C  ----------
+  std::unordered_map<GStrIdx, MIRTypeByName*, GStrIdxHash> nameTypeMap;
+  std::unordered_map<GStrIdx, size_t, GStrIdxHash> enumNameMap;
+
+  // ---------- Enhance C  ----------
+  std::unordered_map<uint32, UniqueFEIRExpr> boundaryLenExprHashMap;
+  std::unordered_set<TyIdx, TyIdxHash> ownedNonnullFieldStructSet;
+
+  MIRFunction *funcMCCStaticFieldGetBool = nullptr;
+  MIRFunction *funcMCCStaticFieldGetByte = nullptr;
+  MIRFunction *funcMCCStaticFieldGetShort = nullptr;
+  MIRFunction *funcMCCStaticFieldGetChar = nullptr;
+  MIRFunction *funcMCCStaticFieldGetInt = nullptr;
+  MIRFunction *funcMCCStaticFieldGetLong = nullptr;
+  MIRFunction *funcMCCStaticFieldGetFloat = nullptr;
+  MIRFunction *funcMCCStaticFieldGetDouble = nullptr;
+  MIRFunction *funcMCCStaticFieldGetObject = nullptr;
+
+  MIRFunction *funcMCCStaticFieldSetBool = nullptr;
+  MIRFunction *funcMCCStaticFieldSetByte = nullptr;
+  MIRFunction *funcMCCStaticFieldSetShort = nullptr;
+  MIRFunction *funcMCCStaticFieldSetChar = nullptr;
+  MIRFunction *funcMCCStaticFieldSetInt = nullptr;
+  MIRFunction *funcMCCStaticFieldSetLong = nullptr;
+  MIRFunction *funcMCCStaticFieldSetFloat = nullptr;
+  MIRFunction *funcMCCStaticFieldSetDouble = nullptr;
+  MIRFunction *funcMCCStaticFieldSetObject = nullptr;
+
+  // ---------- antiproguard ----------
+  std::set<GStrIdx> setAntiProguardFieldStructIdx;
+  mutable std::mutex feTypeManagerMtx;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FE_TYPE_MANAGER_H
diff --git a/src/hir2mpl/common/include/fe_utils.h b/src/hir2mpl/common/include/fe_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d1e532183ee3cb75b1dab6a9e47e16e8a22f461
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_utils.h
@@ -0,0 +1,384 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FE_UTILS_H
+#define HIR2MPL_INCLUDE_FE_UTILS_H
+#include <vector>
+#include <string>
+#include <list>
+#include "mpl_logging.h"
+#include "prim_types.h"
+#include "mir_type.h"
+#include "global_tables.h"
+#include "mempool.h"
+#include "mir_nodes.h"
+#include "mir_scope.h"
+
+namespace maple {
+
+enum FEErrno : int {
+  kNoError = 0,
+  kCmdParseError = 1,
+  kNoValidInput = 2,
+  kFEError = 3,
+};
+
+class FEUtils {
+ public:
+  FEUtils() = default;
+  ~FEUtils() = default;
+  static std::vector<std::string> Split(const std::string &str, char delim);
+  static uint8 GetWidth(PrimType primType);
+  static bool IsInteger(PrimType primType);
+  static bool IsSignedInteger(PrimType primType);
+  static bool IsUnsignedInteger(PrimType primType);
+  static PrimType MergePrimType(PrimType primType1, PrimType primType2);
+  static uint8 GetDim(const std::string &typeName);
+  static std::string GetBaseTypeName(const std::string &typeName);
+  static PrimType GetPrimType(const GStrIdx &typeNameIdx);
+  static uint32 GetSequentialNumber();
+  static std::string GetFileNameHashStr(const std::string &fileName, uint32 seed = 211);
+  static std::string GetSequentialName0(const std::string &prefix, uint32_t num);
+  static std::string GetSequentialName(const std::string &prefix);
+  static std::string CreateLabelName();
+  static FieldID GetStructFieldID(MIRStructType *base, const std::string &fieldName);
+  static bool TraverseToNamedField(MIRStructType &structType, const GStrIdx &nameIdx, FieldID &fieldID,
+                                   bool isTopLevel = true);
+  static MIRType *GetStructFieldType(const MIRStructType *type, FieldID fieldID);
+  static const MIRFuncType *GetFuncPtrType(const MIRType &type);
+  static MIRConst *CreateImplicitConst(MIRType *type);
+  static PrimType GetVectorElementPrimType(PrimType vectorPrimType);
+  static bool EndsWith(const std::string &value, const std::string &ending);
+  static MIRConst *TraverseToMIRConst(MIRAggConst *aggConst, const MIRStructType &structType, FieldID &fieldID);
+  static Loc GetSrcLocationForMIRSymbol(const MIRSymbol &symbol);
+  static MIRAliasVars AddAlias(const GStrIdx &mplNameIdx, const MIRType *sourceType, const TypeAttrs &attrs,
+                               bool isLocal = true);
+  static void AddAliasInMIRScope(MIRScope &scope, const std::string &srcVarName, const MIRSymbol &symbol,
+                                 const MIRType *sourceType);
+  static SrcPosition CvtLoc2SrcPosition(const Loc &loc);
+
+  static const std::string kBoolean;
+  static const std::string kByte;
+  static const std::string kShort;
+  static const std::string kChar;
+  static const std::string kInt;
+  static const std::string kLong;
+  static const std::string kFloat;
+  static const std::string kDouble;
+  static const std::string kVoid;
+  static const std::string kThis;
+  static const std::string kMCCStaticFieldGetBool;
+  static const std::string kMCCStaticFieldGetByte;
+  static const std::string kMCCStaticFieldGetChar;
+  static const std::string kMCCStaticFieldGetShort;
+  static const std::string kMCCStaticFieldGetInt;
+  static const std::string kMCCStaticFieldGetLong;
+  static const std::string kMCCStaticFieldGetFloat;
+  static const std::string kMCCStaticFieldGetDouble;
+  static const std::string kMCCStaticFieldGetObject;
+
+  static const std::string kMCCStaticFieldSetBool;
+  static const std::string kMCCStaticFieldSetByte;
+  static const std::string kMCCStaticFieldSetChar;
+  static const std::string kMCCStaticFieldSetShort;
+  static const std::string kMCCStaticFieldSetInt;
+  static const std::string kMCCStaticFieldSetLong;
+  static const std::string kMCCStaticFieldSetFloat;
+  static const std::string kMCCStaticFieldSetDouble;
+  static const std::string kMCCStaticFieldSetObject;
+
+  static const std::string kCondGoToStmtLabelNamePrefix;
+
+  static inline MemPool *NewMempool(const std::string &name, bool isLocalPool) {
+    return memPoolCtrler.NewMemPool(name, isLocalPool);
+  }
+
+  static inline void DeleteMempoolPtr(MemPool *memPoolPtr) {
+    memPoolCtrler.DeleteMemPool(memPoolPtr);
+  }
+
+  static inline GStrIdx &GetBooleanIdx() {
+    static GStrIdx booleanIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kBoolean);
+    return booleanIdx;
+  }
+
+  static inline GStrIdx &GetByteIdx() {
+    static GStrIdx byteIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kByte);
+    return byteIdx;
+  }
+
+  static inline GStrIdx &GetShortIdx() {
+    static GStrIdx shortIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kShort);
+    return shortIdx;
+  }
+
+  static inline GStrIdx &GetCharIdx() {
+    static GStrIdx charIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kChar);
+    return charIdx;
+  }
+
+  static inline GStrIdx &GetIntIdx() {
+    static GStrIdx intIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kInt);
+    return intIdx;
+  }
+
+  static inline GStrIdx &GetLongIdx() {
+    static GStrIdx longIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kLong);
+    return longIdx;
+  }
+
+  static inline GStrIdx &GetFloatIdx() {
+    static GStrIdx floatIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kFloat);
+    return floatIdx;
+  }
+
+  static inline GStrIdx &GetDoubleIdx() {
+    static GStrIdx doubleIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kDouble);
+    return doubleIdx;
+  }
+
+  static inline GStrIdx &GetVoidIdx() {
+    static GStrIdx voidIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kVoid);
+    return voidIdx;
+  }
+
+  static inline GStrIdx &GetThisIdx() {
+    static GStrIdx thisIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kThis);
+    return thisIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldGetBoolIdx() {
+    static GStrIdx mccStaticFieldGetBoolIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldGetBool);
+    return mccStaticFieldGetBoolIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldGetByteIdx() {
+    static GStrIdx mccStaticFieldGetByteIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldGetByte);
+    return mccStaticFieldGetByteIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldGetShortIdx() {
+    static GStrIdx mccStaticFieldGetShortIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldGetShort);
+    return mccStaticFieldGetShortIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldGetCharIdx() {
+    static GStrIdx mccStaticFieldGetCharIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldGetChar);
+    return mccStaticFieldGetCharIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldGetIntIdx() {
+    static GStrIdx mccStaticFieldGetIntIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldGetInt);
+    return mccStaticFieldGetIntIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldGetLongIdx() {
+    static GStrIdx mccStaticFieldGetLongIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldGetLong);
+    return mccStaticFieldGetLongIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldGetFloatIdx() {
+    static GStrIdx mccStaticFieldGetFloatIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldGetFloat);
+    return mccStaticFieldGetFloatIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldGetDoubleIdx() {
+    static GStrIdx mccStaticFieldGetDoubleIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldGetDouble);
+    return mccStaticFieldGetDoubleIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldGetObjectIdx() {
+    static GStrIdx mccStaticFieldGetObjectIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldGetObject);
+    return mccStaticFieldGetObjectIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldSetBoolIdx() {
+    static GStrIdx mccStaticFieldSetBoolIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldSetBool);
+    return mccStaticFieldSetBoolIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldSetByteIdx() {
+    static GStrIdx mccStaticFieldSetByteIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldSetByte);
+    return mccStaticFieldSetByteIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldSetShortIdx() {
+    static GStrIdx mccStaticFieldSetShortIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldSetShort);
+    return mccStaticFieldSetShortIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldSetCharIdx() {
+    static GStrIdx mccStaticFieldSetCharIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldSetChar);
+    return mccStaticFieldSetCharIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldSetIntIdx() {
+    static GStrIdx mccStaticFieldSetIntIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldSetInt);
+    return mccStaticFieldSetIntIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldSetLongIdx() {
+    static GStrIdx mccStaticFieldSetLongIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldSetLong);
+    return mccStaticFieldSetLongIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldSetFloatIdx() {
+    static GStrIdx mccStaticFieldSetFloatIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldSetFloat);
+    return mccStaticFieldSetFloatIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldSetDoubleIdx() {
+    static GStrIdx mccStaticFieldSetDoubleIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldSetDouble);
+    return mccStaticFieldSetDoubleIdx;
+  }
+
+  static inline GStrIdx &GetMCCStaticFieldSetObjectIdx() {
+    static GStrIdx mccStaticFieldSetObjectIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kMCCStaticFieldSetObject);
+    return mccStaticFieldSetObjectIdx;
+  }
+
+  static void InitPrimTypeFuncNameIdxMap(std::map<PrimType, GStrIdx> &primTypeFuncNameIdxMap);
+
+ private:
+  static bool LogicXOR(bool v1, bool v2) {
+    return (v1 && !v2) || (!v1 && v2);
+  }
+};
+
+class FELinkListNode {
+ public:
+  FELinkListNode();
+  virtual ~FELinkListNode();
+  void InsertBefore(FELinkListNode *ins);
+  void InsertAfter(FELinkListNode *ins);
+  static void InsertBefore(FELinkListNode *ins, FELinkListNode *pos);
+  static void InsertAfter(FELinkListNode *ins, FELinkListNode *pos);
+  static void SpliceNodes(FELinkListNode *head, FELinkListNode *tail, FELinkListNode *newTail);
+  FELinkListNode *GetPrev() const {
+    return prev;
+  }
+
+  void SetPrev(FELinkListNode *node) {
+    CHECK_NULL_FATAL(node);
+    prev = node;
+  }
+
+  void SetPrevNull() {
+    prev = nullptr;
+  }
+
+  FELinkListNode *GetNext() const {
+    return next;
+  }
+
+  void SetNextNull() {
+    next = nullptr;
+  }
+
+  void SetNext(FELinkListNode *node) {
+    CHECK_NULL_FATAL(node);
+    next = node;
+  }
+
+ protected:
+  FELinkListNode *prev;
+  FELinkListNode *next;
+};
+
+class AstSwitchUtil {
+ public:
+  static AstSwitchUtil &Instance() {
+    static AstSwitchUtil local;
+    return local;
+  }
+  std::string CreateEndOrExitLabelName() const;
+  void MarkLabelUsed(const std::string &label);
+  void MarkLabelUnUsed(const std::string &label);
+  void PushNestedBreakLabels(const std::string &label);
+  void PopNestedBreakLabels();
+  void PushNestedCaseVectors(const std::pair<CaseVector*, LabelIdx> &caseVec);
+  void PopNestedCaseVectors();
+  bool CheckLabelUsed(const std::string &label);
+  const std::pair<CaseVector*, LabelIdx> &GetTopOfNestedCaseVectors() const;
+  const std::string &GetTopOfBreakLabels() const;
+  std::map<std::string, bool> &GetLabelUseMap() {
+    return labelUsed;
+  }
+  static uint32_t tempVarNo;
+  static const char *cleanLabel;
+  static const char *exitLabel;
+  static const char *blockLabel;
+  static const char *caseLabel;
+  static const char *catchLabel;
+  static const char *endehLabel;
+
+ private:
+  AstSwitchUtil() = default;
+  ~AstSwitchUtil() = default;
+  std::map<std::string, bool> labelUsed = std::map<std::string, bool>();
+  std::stack<std::string> nestedBreakLabels = std::stack<std::string>(); // loop and switch blocks
+  std::stack<LabelIdx> nestedContinueLabels = std::stack<LabelIdx>(); // loop blocks only
+  std::stack<std::pair<CaseVector*, LabelIdx>> nestedCaseVectors = std::stack<std::pair<CaseVector*, LabelIdx>>();
+}; // end of AstSwitchUtil
+
+class AstLoopUtil {
+ public:
+  static AstLoopUtil &Instance() {
+    static AstLoopUtil local;
+    return local;
+  }
+
+  ~AstLoopUtil() = default;
+  void PushBreak(std::string label);
+  std::string GetCurrentBreak();
+  void PopCurrentBreak();
+  bool IsBreakLabelsEmpty() const;
+  void PushContinue(std::string label);
+  std::string GetCurrentContinue();
+  bool IsContinueLabelsEmpty() const;
+  void PopCurrentContinue();
+
+  bool IsCurrentBreakLabelUsed() {
+    return breakLabels.top().second;
+  }
+
+  bool IsCurrentContinueLabelUsed() {
+    return continueLabels.top().second;
+  }
+
+ private:
+  AstLoopUtil() = default;
+  std::stack<std::pair<std::string, bool>> breakLabels = std::stack<std::pair<std::string, bool>>();
+  std::stack<std::pair<std::string, bool>> continueLabels = std::stack<std::pair<std::string, bool>>();
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FE_UTILS_H
diff --git a/src/hir2mpl/common/include/fe_utils_ast.h b/src/hir2mpl/common/include/fe_utils_ast.h
new file mode 100644
index 0000000000000000000000000000000000000000..debf40a5916dc400b678f8752e26e3276166644d
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_utils_ast.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FE_UTILS_AST_H
+#define HIR2MPL_INCLUDE_FE_UTILS_AST_H
+#include <string>
+#include "types_def.h"
+#include "cfg_primitive_types.h"
+#include "mempool.h"
+#include "opcodes.h"
+#include "mir_const.h"
+
+namespace maple {
+class FEUtilAST {
+ public:
+  static PrimType GetTypeFromASTTypeName(const std::string &typeName);
+  static const std::string Type2Label(PrimType primType);
+
+ private:
+  FEUtilAST() = default;
+  ~FEUtilAST() = default;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FE_UTILS_AST_H
diff --git a/src/hir2mpl/common/include/fe_utils_java.h b/src/hir2mpl/common/include/fe_utils_java.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a22390c4d43467bf2ec1ac6282d91261977203c
--- /dev/null
+++ b/src/hir2mpl/common/include/fe_utils_java.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FE_UTILS_JAVA_H
+#define HIR2MPL_INCLUDE_FE_UTILS_JAVA_H
+#include <string>
+#include <vector>
+#include "feir_type.h"
+#include "global_tables.h"
+#include "types_def.h"
+
+namespace maple {
+class FEUtilJava {
+ public:
+  static std::vector<std::string> SolveMethodSignature(const std::string &signature);
+  static std::string SolveParamNameInJavaFormat(const std::string &signature);
+
+  static GStrIdx &GetMultiANewArrayClassIdx() {
+    static GStrIdx multiANewArrayClassIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName("Ljava/lang/reflect/Array;"));
+    return multiANewArrayClassIdx;
+  }
+
+  static GStrIdx &GetMultiANewArrayElemIdx() {
+    static GStrIdx multiANewArrayElemIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName("newInstance"));
+    return multiANewArrayElemIdx;
+  }
+
+  static GStrIdx &GetMultiANewArrayTypeIdx() {
+    static GStrIdx multiANewArrayTypeIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName("(Ljava/lang/Class;[I)Ljava/lang/Object;"));
+    return multiANewArrayTypeIdx;
+  }
+
+  static GStrIdx &GetMultiANewArrayFullIdx() {
+    static GStrIdx multiANewArrayFullIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::EncodeName("Ljava/lang/reflect/Array;|newInstance|(Ljava/lang/Class;[I)Ljava/lang/Object;"));
+    return multiANewArrayFullIdx;
+  }
+
+  static GStrIdx &GetJavaThrowableNameMplIdx() {
+    static GStrIdx javaThrowableNameMplIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName("Ljava/lang/Throwable;"));
+    return javaThrowableNameMplIdx;
+  }
+
+ private:
+  FEUtilJava() = default;
+  ~FEUtilJava() = default;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FE_UTILS_JAVA_H
diff --git a/src/hir2mpl/common/include/feir_builder.h b/src/hir2mpl/common/include/feir_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..48feebcb33785fcc42110069458ae0c468e71649
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_builder.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FEIR_BUILDER_H
+#define HIR2MPL_INCLUDE_COMMON_FEIR_BUILDER_H
+#include <memory>
+#include "mir_function.h"
+#include "mpl_logging.h"
+#include "feir_var.h"
+#include "feir_stmt.h"
+#include "fe_function.h"
+
+namespace maple {
+class FEIRBuilder {
+ public:
+  FEIRBuilder() = default;
+  ~FEIRBuilder() = default;
+  // Type
+  static UniqueFEIRType CreateType(PrimType basePty, const GStrIdx &baseNameIdx, uint32 dim);
+  static UniqueFEIRType CreateArrayElemType(const UniqueFEIRType &arrayType);
+  static UniqueFEIRType CreateRefType(const GStrIdx &baseNameIdx, uint32 dim);
+  static UniqueFEIRType CreateTypeByJavaName(const std::string &typeName, bool inMpl);
+  // Var
+  static UniqueFEIRVar CreateVarReg(uint32 regNum, PrimType primType, bool isGlobal = false);
+  static UniqueFEIRVar CreateVarReg(uint32 regNum, UniqueFEIRType type, bool isGlobal = false);
+  static UniqueFEIRVar CreateVarName(GStrIdx nameIdx, PrimType primType, bool isGlobal = false,
+                                     bool withType = false);
+  static UniqueFEIRVar CreateVarName(const std::string &name, PrimType primType, bool isGlobal = false,
+                                     bool withType = false);
+  static UniqueFEIRVar CreateVarNameForC(GStrIdx nameIdx, MIRType &mirType, bool isGlobal = false,
+                                         bool withType = false);
+  static UniqueFEIRVar CreateVarNameForC(const std::string &name, MIRType &mirType, bool isGlobal = false,
+                                         bool withType = false);
+  static UniqueFEIRVar CreateVarNameForC(const std::string &name, UniqueFEIRType type,
+                                         bool isGlobal = false, bool withType = false);
+  // Expr
+  static UniqueFEIRExpr CreateExprSizeOfType(UniqueFEIRType ty);
+  static UniqueFEIRExpr CreateExprDRead(UniqueFEIRVar srcVar);
+  static UniqueFEIRExpr CreateExprDReadAggField(UniqueFEIRVar srcVar, FieldID fieldID, UniqueFEIRType fieldType);
+  static UniqueFEIRExpr CreateExprAddrofLabel(const std::string &lbName, UniqueFEIRType exprTy);
+  static UniqueFEIRExpr CreateExprAddrofVar(UniqueFEIRVar srcVar);
+  static UniqueFEIRExpr CreateExprAddrofFunc(const std::string &addr);
+  static UniqueFEIRExpr CreateExprAddrofArray(UniqueFEIRType argTypeNativeArray,
+                                              UniqueFEIRExpr argExprArray, std::string argArrayName,
+                                              std::list<UniqueFEIRExpr> &argExprIndexs);
+  static UniqueFEIRExpr CreateExprIRead(UniqueFEIRType returnType, UniqueFEIRType ptrType,
+                                        UniqueFEIRExpr expr, FieldID id = 0);
+  static UniqueFEIRExpr CreateExprTernary(Opcode op, UniqueFEIRType type, UniqueFEIRExpr cExpr,
+                                          UniqueFEIRExpr tExpr, UniqueFEIRExpr fExpr);
+  static UniqueFEIRExpr CreateExprConstRefNull();
+  static UniqueFEIRExpr CreateExprConstPtrNull();
+  static UniqueFEIRExpr CreateExprConstI8(int8 val);
+  static UniqueFEIRExpr CreateExprConstI16(int16 val);
+  static UniqueFEIRExpr CreateExprConstI32(int32 val);
+  static UniqueFEIRExpr CreateExprConstU32(uint32 val);
+  static UniqueFEIRExpr CreateExprConstI64(int64 val);
+  static UniqueFEIRExpr CreateExprConstU64(uint64 val);
+  static UniqueFEIRExpr CreateExprConstF32(float val);
+  static UniqueFEIRExpr CreateExprConstF64(double val);
+  static UniqueFEIRExpr CreateExprConstPtr(int64 val);
+  static UniqueFEIRExpr CreateExprConstAnyScalar(PrimType primType, int64 val);
+  static UniqueFEIRExpr CreateExprVdupAnyVector(PrimType primtype, int64 val);
+  static UniqueFEIRExpr CreateExprMathUnary(Opcode op, UniqueFEIRVar var0);
+  static UniqueFEIRExpr CreateExprMathUnary(Opcode op, UniqueFEIRExpr expr);
+  static UniqueFEIRExpr CreateExprZeroCompare(Opcode op, UniqueFEIRExpr expr);
+  static UniqueFEIRExpr CreateExprMathBinary(Opcode op, UniqueFEIRVar var0, UniqueFEIRVar var1);
+  static UniqueFEIRExpr CreateExprMathBinary(Opcode op, UniqueFEIRExpr expr0, UniqueFEIRExpr expr1);
+  static UniqueFEIRExpr CreateExprBinary(Opcode op, UniqueFEIRExpr expr0, UniqueFEIRExpr expr1);
+  static UniqueFEIRExpr CreateExprBinary(UniqueFEIRType exprType, Opcode op,
+                                         UniqueFEIRExpr expr0, UniqueFEIRExpr expr1);
+  static UniqueFEIRExpr CreateExprSExt(UniqueFEIRVar srcVar);
+  static UniqueFEIRExpr CreateExprSExt(UniqueFEIRExpr srcExpr, PrimType dstType);
+  static UniqueFEIRExpr CreateExprZExt(UniqueFEIRVar srcVar);
+  static UniqueFEIRExpr CreateExprZExt(UniqueFEIRExpr srcExpr, PrimType dstType);
+  static UniqueFEIRExpr CreateExprCvtPrim(UniqueFEIRVar srcVar, PrimType dstType);
+  static UniqueFEIRExpr CreateExprCvtPrim(UniqueFEIRExpr srcExpr, PrimType dstType);
+  static UniqueFEIRExpr CreateExprCvtPrim(UniqueFEIRExpr srcExpr, PrimType srcType, PrimType dstType);
+  static UniqueFEIRExpr CreateExprCvtPrim(Opcode argOp, UniqueFEIRExpr srcExpr, PrimType dstType);
+  static UniqueFEIRExpr CreateExprCastPrim(UniqueFEIRExpr srcExpr, PrimType dstType);
+  static UniqueFEIRExpr CreateExprJavaNewInstance(UniqueFEIRType type);
+  static UniqueFEIRExpr CreateExprJavaNewInstance(UniqueFEIRType type, uint32 argTypeID);
+  static UniqueFEIRExpr CreateExprJavaNewInstance(UniqueFEIRType type, uint32 argTypeID, bool isRcPermanent);
+  static UniqueFEIRExpr CreateExprJavaNewArray(UniqueFEIRType type, UniqueFEIRExpr exprSize);
+  static UniqueFEIRExpr CreateExprJavaNewArray(UniqueFEIRType type, UniqueFEIRExpr exprSize, uint32 typeID);
+  static UniqueFEIRExpr CreateExprJavaNewArray(UniqueFEIRType type, UniqueFEIRExpr exprSize, uint32 typeID,
+                                               bool isRcPermanent);
+  static UniqueFEIRExpr CreateExprJavaArrayLength(UniqueFEIRExpr exprArray);
+
+  // Stmt
+  static UniqueFEIRStmt CreateStmtDAssign(UniqueFEIRVar dstVar, UniqueFEIRExpr srcExpr, bool hasException = false);
+  static UniqueFEIRStmt CreateStmtDAssignAggField(UniqueFEIRVar dstVar, UniqueFEIRExpr srcExpr, FieldID fieldID);
+  static UniqueFEIRStmt CreateStmtIAssign(UniqueFEIRType dstType, UniqueFEIRExpr dstExpr,
+                                          UniqueFEIRExpr srcExpr, FieldID fieldID = 0);
+  static UniqueFEIRStmt CreateStmtGoto(uint32 targetLabelIdx);
+  static UniqueFEIRStmt CreateStmtGoto(const std::string &labelName);
+  static UniqueFEIRStmt CreateStmtIGoto(UniqueFEIRExpr targetExpr);
+  static UniqueFEIRStmt CreateStmtCondGoto(uint32 targetLabelIdx, Opcode op, UniqueFEIRExpr expr);
+  static UniqueFEIRStmt CreateStmtSwitch(UniqueFEIRExpr expr);
+  static UniqueFEIRStmt CreateStmtIfWithoutElse(UniqueFEIRExpr cond, std::list<UniqueFEIRStmt> &thenStmts);
+  static UniqueFEIRStmt CreateStmtIf(UniqueFEIRExpr cond, std::list<UniqueFEIRStmt> &thenStmts,
+                                     std::list<UniqueFEIRStmt> &elseStmts);
+  static UniqueFEIRStmt CreateStmtJavaConstClass(UniqueFEIRVar dstVar, UniqueFEIRType type);
+  static UniqueFEIRStmt CreateStmtJavaConstString(UniqueFEIRVar dstVar, const std::string &strVal);
+  static UniqueFEIRStmt CreateStmtJavaCheckCast(UniqueFEIRVar dstVar, UniqueFEIRVar srcVar, UniqueFEIRType type);
+  static UniqueFEIRStmt CreateStmtJavaCheckCast(UniqueFEIRVar dstVar, UniqueFEIRVar srcVar, UniqueFEIRType type,
+                                                                                            uint32 argTypeID);
+  static UniqueFEIRStmt CreateStmtJavaInstanceOf(UniqueFEIRVar dstVar, UniqueFEIRVar srcVar, UniqueFEIRType type);
+  static UniqueFEIRStmt CreateStmtJavaInstanceOf(UniqueFEIRVar dstVar, UniqueFEIRVar srcVar, UniqueFEIRType type,
+                                                                                             uint32 argTypeID);
+  static UniqueFEIRStmt CreateStmtJavaFillArrayData(UniqueFEIRVar srcVar, const int8 *arrayData,
+                                                    uint32 size, const std::string &arrayName);
+  static std::list<UniqueFEIRStmt> CreateStmtArrayStore(UniqueFEIRVar varElem, UniqueFEIRVar varArray,
+                                                        UniqueFEIRVar varIndex);
+  static UniqueFEIRStmt CreateStmtArrayStoreOneStmt(UniqueFEIRVar varElem, UniqueFEIRVar varArray,
+                                                    UniqueFEIRExpr exprIndex);
+  static UniqueFEIRStmt CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                        UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType);
+  static UniqueFEIRStmt CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                        UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType,
+                                                        const std::string &argArrayName);
+  static UniqueFEIRStmt CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                        std::list<UniqueFEIRExpr> exprIndexs,
+                                                        UniqueFEIRType arrayType, const std::string &argArrayName);
+  static UniqueFEIRStmt CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                        UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType,
+                                                        UniqueFEIRType elemType, const std::string &argArrayName);
+  static std::list<UniqueFEIRStmt> CreateStmtArrayLoad(UniqueFEIRVar varElem, UniqueFEIRVar varArray,
+                                                       UniqueFEIRVar varIndex);
+  static UniqueFEIRStmt CreateStmtArrayLength(UniqueFEIRVar varLength, UniqueFEIRVar varArray);
+  static UniqueFEIRStmt CreateStmtRetype(UniqueFEIRVar varDst, const UniqueFEIRVar &varSrc);
+  static UniqueFEIRStmt CreateStmtComment(const std::string &comment);
+  static UniqueFEIRExpr ReadExprField(UniqueFEIRExpr expr, FieldID fieldID, UniqueFEIRType fieldType);
+  static UniqueFEIRStmt AssginStmtField(const UniqueFEIRExpr &addrExpr, UniqueFEIRExpr srcExpr, FieldID fieldID);
+  static bool IsZeroConstExpr(const UniqueFEIRExpr &expr);
+  static UniqueFEIRStmt CreateVLAStackRestore(const UniqueFEIRVar &vlaSavedStackVar);
+  static std::string EmitVLACleanupStmts(FEFunction &feFunction, const std::string &labelName, const Loc &loc);
+  static void EmitVLACleanupStmts(const FEFunction &feFunction, std::list<UniqueFEIRStmt> &stmts);
+};  // class FEIRBuilder
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FEIR_BUILDER_H
diff --git a/src/hir2mpl/common/include/feir_node_kind.def b/src/hir2mpl/common/include/feir_node_kind.def
new file mode 100644
index 0000000000000000000000000000000000000000..42d9797447be5639f57e569b28b2a089a4b39c9b
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_node_kind.def
@@ -0,0 +1,87 @@
+// FEIR_NODE_KIND (kind, description)
+FEIR_NODE_KIND(Stmt, "Stmt")
+FEIR_NODE_KIND(StmtNary, "StmtNary")
+FEIR_NODE_KIND(StmtAssign, "StmtAssign")
+FEIR_NODE_KIND(StmtNonAssign, "StmtNonAssign")
+FEIR_NODE_KIND(StmtPesudo, "StmtPesudo")
+FEIR_NODE_KIND(StmtDAssign, "StmtDAssign")
+FEIR_NODE_KIND(StmtJavaTypeCheck, "StmtJavaTypeCheck")
+FEIR_NODE_KIND(StmtJavaConstClass, "StmtJavaConstClass")
+FEIR_NODE_KIND(StmtJavaConstString, "StmtJavaConstString")
+FEIR_NODE_KIND(StmtJavaMultiANewArray, "StmtJavaMultiANewArray")
+FEIR_NODE_KIND(StmtCallAssign, "StmtCallAssign")
+FEIR_NODE_KIND(StmtICallAssign, "StmtICallAssign")
+FEIR_NODE_KIND(StmtJavaDynamicCallAssign, "StmtJavaDynamicCallAssign")
+FEIR_NODE_KIND(StmtIntrinsicCallAssign, "StmtIntrinsicCallAssign")
+FEIR_NODE_KIND(StmtIAssign, "StmtIAssign")
+FEIR_NODE_KIND(StmtUseOnly, "StmtUseOnly")
+FEIR_NODE_KIND(StmtReturn, "StmtReturn")
+FEIR_NODE_KIND(StmtBranch, "StmtBranch")
+FEIR_NODE_KIND(StmtGoto, "StmtGoto")
+FEIR_NODE_KIND(StmtIGoto, "StmtIGoto")
+FEIR_NODE_KIND(StmtCondGoto, "StmtCondGoto")
+FEIR_NODE_KIND(StmtSwitch, "StmtSwitch")
+FEIR_NODE_KIND(StmtArrayStore, "StmtArrayStore")
+FEIR_NODE_KIND(StmtFieldStore, "StmtFieldStore")
+FEIR_NODE_KIND(StmtFieldLoad, "StmtFieldLoad")
+FEIR_NODE_KIND(StmtFieldStoreForC, "StmtFieldStoreForC")
+FEIR_NODE_KIND(ExprFieldLoadForC, "ExprFieldLoadForC")
+FEIR_NODE_KIND(Expr, "Expr")
+FEIR_NODE_KIND(ExprNestable, "ExprNestable")
+FEIR_NODE_KIND(ExprNonNestable, "ExprNonNestable")
+FEIR_NODE_KIND(ExprConst, "ExprConst")
+FEIR_NODE_KIND(ExprSizeOfType, "ExprSizeOfType")
+FEIR_NODE_KIND(ExprDRead, "ExprDRead")
+FEIR_NODE_KIND(ExprIRead, "ExprIRead")
+FEIR_NODE_KIND(ExprRegRead, "ExprRegRead")
+FEIR_NODE_KIND(ExprConvert, "ExprConvert")
+FEIR_NODE_KIND(ExprIntExt, "ExprIntExt")
+FEIR_NODE_KIND(ExprRetype, "ExprRetype")
+FEIR_NODE_KIND(ExprCompare, "ExprCompare")
+FEIR_NODE_KIND(ExprUnary, "ExprUnary")
+FEIR_NODE_KIND(ExprBinary, "ExprBinary")
+FEIR_NODE_KIND(ExprTernary, "ExprTernary")
+FEIR_NODE_KIND(ExprNary, "ExprNary")
+FEIR_NODE_KIND(ExprArray, "ExprArray")
+FEIR_NODE_KIND(ExprAddrof, "ExprAddrof")
+FEIR_NODE_KIND(ExprAddrofLabel, "ExprAddrofLabel")
+FEIR_NODE_KIND(ExprIAddrof, "ExprIAddrof")
+FEIR_NODE_KIND(ExprAddrofVar, "ExprAddrofVar")
+FEIR_NODE_KIND(ExprAddrofFunc, "ExprAddrofFunc")
+FEIR_NODE_KIND(ExprAddrofArray, "ExprAddrofArray")
+FEIR_NODE_KIND(ExprAddrofStruct, "ExprAddrofStruct")
+FEIR_NODE_KIND(ExprIntrinsicop, "ExprIntrinsicop")
+FEIR_NODE_KIND(FEIRExprJavaMerge, "FEIRExprJavaMerge")
+FEIR_NODE_KIND(ExprTypeCvt, "ExprTypeCvt")
+FEIR_NODE_KIND(ExprJavaNewInstance, "ExprJavaNewInstance")
+FEIR_NODE_KIND(ExprJavaNewArray, "ExprJavaNewArray")
+FEIR_NODE_KIND(ExprJavaArrayLength, "ExprJavaArrayLength")
+FEIR_NODE_KIND(ExprJavaInstanceOf, "ExprJavaInstanceOf")
+FEIR_NODE_KIND(ExprArrayStoreForC, "ExprArrayStoreForC")
+FEIR_NODE_KIND(ExprArrayLoad, "ExprArrayLoad")
+FEIR_NODE_KIND(ExprCStyleCast, "ExprCStyleCast")
+FEIR_NODE_KIND(ExprAtomic, "ExprAtomic")
+FEIR_NODE_KIND(StmtJavaFillArrayData, "StmtJavaFillArrayData")
+FEIR_NODE_KIND(StmtPesudoFuncStart, "StmtPesudoFuncStart")
+FEIR_NODE_KIND(StmtPesudoFuncEnd, "StmtPesudoFuncEnd")
+FEIR_NODE_KIND(StmtCheckPoint, "StmtCheckPoint")
+FEIR_NODE_KIND(StmtPesudoLOC, "StmtPesudoLOC")
+FEIR_NODE_KIND(StmtPesudoLabel, "StmtPesudoLabel")
+FEIR_NODE_KIND(StmtPesudoJavaTry, "StmtPesudoJavaTry")
+FEIR_NODE_KIND(StmtPesudoEndTry, "StmtPesudoEndTry")
+FEIR_NODE_KIND(StmtPesudoJavaCatch, "StmtPesudoJavaCatch")
+FEIR_NODE_KIND(StmtPesudoSafe, "StmtPesudoSafe")
+FEIR_NODE_KIND(StmtPesudoUnsafe, "StmtPesudoUnsafe")
+FEIR_NODE_KIND(StmtPesudoComment, "StmtPesudoComment")
+FEIR_NODE_KIND(StmtPesudoCommentForInst, "StmtPesudoCommentForInst")
+FEIR_NODE_KIND(StmtCaseForC, "StmtCaseForC")
+FEIR_NODE_KIND(StmtDefaultForC, "StmtDefaultForC")
+FEIR_NODE_KIND(StmtIf, "StmtIf")
+FEIR_NODE_KIND(StmtDoWhile, "StmtDoWhile")
+FEIR_NODE_KIND(StmtBreak, "StmtBreak")
+FEIR_NODE_KIND(StmtContinue, "StmtContinue")
+FEIR_NODE_KIND(StmtLabel, "StmtLabel")
+FEIR_NODE_KIND(StmtAtomic, "StmtAtomic")
+FEIR_NODE_KIND(StmtGCCAsm, "StmtGCCAsm")
+FEIR_NODE_KIND(StmtPesudoHead, "StmtPesudoHead")
+FEIR_NODE_KIND(StmtPesudoTail, "StmtPesudoTail")
diff --git a/src/hir2mpl/common/include/feir_scope.h b/src/hir2mpl/common/include/feir_scope.h
new file mode 100644
index 0000000000000000000000000000000000000000..cfb58540f56281132c1e6226c10b8e8f288a0ccd
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_scope.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_COMMON_INCLUDE_FEIR_SCOPE_H
+#define HIR2MPL_COMMON_INCLUDE_FEIR_SCOPE_H
+#include "mir_scope.h"
+#include "mpl_logging.h"
+#include "src_position.h"
+#include "feir_var.h"
+#include "feir_stmt.h"
+
+namespace maple {
+class FEIRScope;
+using UniqueFEIRScope = std::unique_ptr<FEIRScope>;
+
+class FEIRScope {
+ public:
+  explicit FEIRScope(uint32 currID) : id(currID) {}
+  FEIRScope(uint32 currID, MIRScope *scope) : id(currID), mirScope(scope) {}
+  FEIRScope(uint32 currID, bool isControll) : id(currID), isControllScope(isControll) {}
+  virtual ~FEIRScope() = default;
+
+  uint32 GetID() const {
+    return id;
+  }
+
+  void SetMIRScope(MIRScope *scope) {
+    mirScope = scope;
+  }
+
+  MIRScope *GetMIRScope() {
+    return mirScope;
+  }
+
+  const MIRScope *GetMIRScope() const {
+    return mirScope;
+  }
+
+  void SetVLASavedStackVar(UniqueFEIRVar var) {
+    vlaSavedStackVar = std::move(var);
+  }
+
+  const UniqueFEIRVar &GetVLASavedStackVar() const {
+    return vlaSavedStackVar;
+  }
+
+  void SetIsControllScope(bool flag) {
+    isControllScope = flag;
+  }
+
+  bool IsControllScope() const {
+    return isControllScope;
+  }
+
+  UniqueFEIRStmt GenVLAStackRestoreStmt() const;
+  UniqueFEIRScope Clone() const;
+
+ private:
+  uint32 id;
+  MIRScope *mirScope = nullptr;  // one func, compoundstmt or forstmt scope includes decls
+  UniqueFEIRVar vlaSavedStackVar = nullptr;
+  bool isControllScope = false;  // The controlling scope in a if/switch/while/for statement
+};
+} // namespace maple
+#endif // HIR2MPL_AST_INPUT_INCLUDE_AST_VAR_SCOPE_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/feir_stmt.h b/src/hir2mpl/common/include/feir_stmt.h
new file mode 100644
index 0000000000000000000000000000000000000000..dde5c575b45e44180172de48085c8c872939add4
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_stmt.h
@@ -0,0 +1,2950 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_FEIR_STMT_H
+#define HIR2MPL_INCLUDE_COMMON_FEIR_STMT_H
+#include <vector>
+#include <list>
+#include <set>
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <memory>
+#include <tuple>
+#include "types_def.h"
+#include "mempool_allocator.h"
+#include "mir_builder.h"
+#include "factory.h"
+#include "safe_ptr.h"
+#include "fe_utils.h"
+#include "feir_var.h"
+#include "fe_struct_elem_info.h"
+#include "feir_var_type_scatter.h"
+#include "fe_options.h"
+#include "feir_type_helper.h"
+#include "feir_dfg.h"
+
+namespace maple {
+class FEIRBuilder;
+
+enum FEIRNodeKind : uint8 {
+#define FEIR_NODE_KIND(kind, description) \
+  k##kind,
+#include "feir_node_kind.def"
+#undef FEIR_NODE_KIND
+};
+
+std::string GetFEIRNodeKindDescription(FEIRNodeKind kindArg);
+constexpr uint32 kOpHashShift = 24;
+constexpr uint32 kTypeHashShift = 8;
+constexpr uint32 kOtherShift = 16;
+constexpr uint32 kRandomNum = 0x9e3779b9;
+constexpr uint32 kSeedLeftShift = 6;
+constexpr uint32 kSeedRightShift = 2;
+
+// ---------- FEIRNode ----------
+class FEIRNode {
+ public:
+  explicit FEIRNode(FEIRNodeKind argKind)
+      : kind(argKind) {}
+  virtual ~FEIRNode() = default;
+
+ protected:
+  FEIRNodeKind kind;
+};  // class FEIRNode
+
+// ---------- FEIRDFGNode ----------
+class FEIRDFGNode {
+ public:
+  explicit FEIRDFGNode(const UniqueFEIRVar &argVar)
+      : var(argVar) {
+    CHECK_NULL_FATAL(argVar);
+  }
+
+  virtual ~FEIRDFGNode() = default;
+  bool operator==(const FEIRDFGNode &node) const {
+    return var->EqualsTo(node.var);
+  }
+
+  size_t Hash() const {
+    return var->Hash();
+  }
+
+  std::string GetNameRaw() const {
+    return var->GetNameRaw();
+  }
+
+ private:
+  const UniqueFEIRVar &var;
+};
+
+class FEIRDFGNodeHash {
+ public:
+  std::size_t operator()(const FEIRDFGNode &node) const {
+    return node.Hash();
+  }
+};
+
+using UniqueFEIRDFGNode = std::unique_ptr<FEIRDFGNode>;
+
+class FEIRStmtCheckPoint;
+// ---------- FEIRStmt ----------
+class FEIRStmt : public FELinkListNode {
+ public:
+  explicit FEIRStmt(FEIRNodeKind argKind)
+      : kind(argKind) {}
+
+  FEIRStmt()
+      : kind(kStmt) {} // kStmt as default
+
+  virtual ~FEIRStmt() = default;
+  void RegisterDFGNodes2CheckPoint(FEIRStmtCheckPoint &checkPoint) {
+    RegisterDFGNodes2CheckPointImpl(checkPoint);
+  }
+
+  bool CalculateDefs4AllUses(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+    return CalculateDefs4AllUsesImpl(checkPoint, udChain);
+  }
+
+  void InitTrans4AllVars() {
+    InitTrans4AllVarsImpl();
+  }
+
+  FEIRVarTypeScatter* GetTypeScatterDefVar() const {
+    return GetTypeScatterDefVarImpl();
+  }
+
+  std::list<StmtNode*> GenMIRStmts(MIRBuilder &mirBuilder) const {
+    std::list<StmtNode*> stmts = GenMIRStmtsImpl(mirBuilder);
+    SetMIRStmtSrcPos(stmts);
+    return stmts;
+  }
+
+  FEIRNodeKind GetKind() const {
+    return kind;
+  }
+
+  void SetKind(FEIRNodeKind argKind) {
+    kind = argKind;
+  }
+
+  bool IsFallThru() const {
+    return IsFallThroughImpl();
+  }
+
+  void SetFallThru(bool arg) {
+    isFallThru = arg;
+  }
+
+  bool IsBranch() const {
+    return IsBranchImpl();
+  }
+
+  bool IsStmtInst() const {
+    return IsStmtInstImpl();
+  }
+
+  bool IsTarget() const {
+    return IsTargetImpl();
+  }
+
+  bool IsThrowable() const {
+    return isThrowable;
+  }
+
+  void SetThrowable(bool argIsThrowable) {
+    isThrowable = argIsThrowable;
+  }
+
+  uint32 GetID() const {
+    return id;
+  }
+
+  void SetID(uint32 arg) {
+    id = arg;
+  }
+
+  bool IsAuxPre() const {
+    return isAuxPre;
+  }
+
+  bool IsAuxPost() const {
+    return isAuxPost;
+  }
+
+  bool IsAux() const {
+    return isAuxPre || isAuxPost;
+  }
+
+  const std::vector<FEIRStmt*> &GetExtraPreds() const {
+    return extraPreds;
+  }
+
+  const std::vector<FEIRStmt*> &GetExtraSuccs() const {
+    return extraSuccs;
+  }
+
+  void AddExtraPred(FEIRStmt &stmt) {
+    extraPreds.push_back(&stmt);
+  }
+
+  void AddExtraSucc(FEIRStmt &stmt) {
+    extraSuccs.push_back(&stmt);
+  }
+
+  bool HasDef() const {
+    return HasDefImpl();
+  }
+
+  void SetHexPC(uint32 argHexPC) {
+    return SetHexPCImpl(argHexPC);
+  }
+
+  uint32 GetHexPC(void) const {
+    return GetHexPCImpl();
+  }
+
+  bool IsStmtInstComment() const;
+  bool ShouldHaveLOC() const;
+  BaseNode *ReplaceAddrOfNode(BaseNode *node) const;
+  void SetSrcLoc(const Loc &l) {
+    loc = l;
+  }
+
+  Loc GetSrcLoc() const {
+    return loc;
+  }
+
+  uint32 GetSrcFileIdx() const {
+    return loc.fileIdx;
+  }
+
+  uint32 GetSrcFileLineNum() const {
+    return loc.line;
+  }
+
+  uint32 GetSrcFileColumn() const {
+    return loc.column;
+  }
+
+  bool HasSetLOCInfo() const {
+    return (loc.fileIdx != 0 || loc.line != 0);
+  }
+
+  bool IsDummy() const {
+    return isDummy;
+  }
+
+  void SetDummy() {
+    isDummy = true;
+  }
+
+  std::string DumpDotString() const {
+    return DumpDotStringImpl();
+  }
+
+  void Dump(const std::string &prefix = "") const {
+    return DumpImpl(prefix);
+  }
+
+ protected:
+  virtual std::string DumpDotStringImpl() const;
+  virtual void DumpImpl(const std::string &prefix) const;
+  virtual void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {}
+  virtual bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+    return true;
+  }
+
+  virtual FEIRVarTypeScatter* GetTypeScatterDefVarImpl() const {
+    return nullptr;
+  }
+
+  virtual void InitTrans4AllVarsImpl() {}
+  virtual std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const;
+  virtual bool IsStmtInstImpl() const;
+  virtual bool IsFallThroughImpl() const {
+    return isFallThru;
+  }
+
+  virtual bool IsBranchImpl() const {
+    return false;
+  }
+
+  virtual bool IsTargetImpl() const {
+    return false;
+  }
+
+  virtual bool HasDefImpl() const {
+    return false;
+  }
+
+  void SetHexPCImpl(uint32 argHexPC) {
+    hexPC = argHexPC;
+  }
+
+  uint32 GetHexPCImpl(void) const {
+    return hexPC;
+  }
+
+  void SetMIRStmtSrcPos(std::list<StmtNode*> &stmts) const {
+    if (FEOptions::GetInstance().IsDumpLOC() && !stmts.empty()) {
+      (*stmts.begin())->GetSrcPos().SetFileNum(static_cast<uint16>(loc.fileIdx));
+      (*stmts.begin())->GetSrcPos().SetLineNum(loc.line);
+      (*stmts.begin())->GetSrcPos().SetColumn(static_cast<uint16>(loc.column));
+    }
+  }
+
+  FEIRNodeKind kind;
+  uint32 id = 0;
+  Loc loc = {0, 0, 0};
+  uint32 hexPC = UINT32_MAX;
+  bool isDummy = false;
+  bool isFallThru = true;
+  bool isAuxPre = false;
+  bool isAuxPost = false;
+  bool isThrowable = false;
+  bool isEnhancedChecking = true;
+  std::vector<FEIRStmt*> extraPreds;
+  std::vector<FEIRStmt*> extraSuccs;
+};
+
+using UniqueFEIRStmt = std::unique_ptr<FEIRStmt>;
+
+// ---------- FEIRStmtCheckPoint ----------
+class FEIRStmtCheckPoint : public FEIRStmt {
+ public:
+  FEIRStmtCheckPoint()
+      : FEIRStmt(FEIRNodeKind::kStmtCheckPoint),
+        firstVisibleStmt(nullptr) {}
+  ~FEIRStmtCheckPoint() override {
+    firstVisibleStmt = nullptr;
+  }
+
+  void Reset();
+  void RegisterDFGNode(UniqueFEIRVar &var);
+  void RegisterDFGNodes(const std::list<UniqueFEIRVar*> &vars);
+  void RegisterDFGNodeFromAllVisibleStmts();
+  void AddPredCheckPoint(FEIRStmtCheckPoint &stmtCheckPoint);
+  std::set<UniqueFEIRVar*> &CalcuDef(UniqueFEIRVar &use);
+  void SetFirstVisibleStmt(FEIRStmt &stmt) {
+    CHECK_FATAL((stmt.GetKind() != FEIRNodeKind::kStmtCheckPoint), "check point should not be DFG Node.");
+    firstVisibleStmt = &stmt;
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+
+ private:
+  void CalcuDefDFS(std::set<UniqueFEIRVar*> &result, const UniqueFEIRVar &use, const FEIRStmtCheckPoint &cp,
+                   std::set<const FEIRStmtCheckPoint*> &visitSet) const;
+  std::set<FEIRStmtCheckPoint*> predCPs;
+  std::list<UniqueFEIRVar*> defs;
+  std::list<UniqueFEIRVar*> uses;
+  FEIRUseDefChain localUD;
+  std::unordered_map<FEIRDFGNode, UniqueFEIRVar*, FEIRDFGNodeHash> lastDef;
+  std::unordered_map<FEIRDFGNode, std::set<UniqueFEIRVar*>, FEIRDFGNodeHash> cacheUD;
+  FEIRStmt *firstVisibleStmt;
+};
+
+// ---------- FEIRExpr ----------
+class FEIRExpr {
+ public:
+  explicit FEIRExpr(FEIRNodeKind argKind);
+  FEIRExpr(FEIRNodeKind argKind, std::unique_ptr<FEIRType> argType);
+  virtual ~FEIRExpr() = default;
+  FEIRExpr(const FEIRExpr&) = delete;
+  FEIRExpr& operator=(const FEIRExpr&) = delete;
+  std::string DumpDotString() const;
+  std::unique_ptr<FEIRExpr> Clone();
+
+  virtual bool operator==(const FEIRExpr &expr) const {
+    return false;
+  }
+
+  virtual bool operator!=(const FEIRExpr &expr) const {
+    return true;
+  }
+
+  BaseNode *GenMIRNode(MIRBuilder &mirBuilder) const {
+    return GenMIRNodeImpl(mirBuilder);
+  }
+
+  std::vector<FEIRVar*> GetVarUses() const {
+    return GetVarUsesImpl();
+  }
+
+  bool IsNestable() const {
+    return IsNestableImpl();
+  }
+
+  bool IsAddrof() const {
+    return IsAddrofImpl();
+  }
+
+  void SetAddrof(bool flag) {
+    isAddrof = flag;
+  }
+
+  bool HasException() const {
+    return HasExceptionImpl();
+  }
+
+  void SetIsBoundaryChecking(bool flag) {
+    isBoundaryChecking = flag;
+  }
+
+  bool IsBoundaryChecking() const {
+    return isBoundaryChecking;
+  }
+
+  void SetIsEnhancedChecking(bool flag) {
+    isEnhancedChecking = flag;
+  }
+
+  bool IsEnhancedChecking() const {
+    return isEnhancedChecking;
+  }
+
+  void SetType(std::unique_ptr<FEIRType> argType) {
+    SetTypeImpl(std::move(argType));
+  }
+
+  FEIRNodeKind GetKind() const {
+    return kind;
+  }
+
+  void SetKind(FEIRNodeKind specKind) {
+    kind = specKind;
+  }
+
+  FEIRType *GetType() const {
+    return GetTypeImpl();
+  }
+
+  const FEIRType &GetTypeRef() const {
+    return GetTypeRefImpl();
+  }
+
+  PrimType GetPrimType() const {
+    return GetPrimTypeImpl();
+  }
+
+  FieldID GetFieldID() const {
+    return GetFieldIDImpl();
+  }
+
+  void SetFieldID(FieldID fieldID) {
+    return SetFieldIDImpl(fieldID);
+  }
+
+  void SetFieldType(std::unique_ptr<FEIRType> fieldType) {
+    return SetFieldTypeImpl(std::move(fieldType));
+  }
+
+  void RegisterDFGNodes2CheckPoint(FEIRStmtCheckPoint &checkPoint) {
+    RegisterDFGNodes2CheckPointImpl(checkPoint);
+  }
+
+  bool CalculateDefs4AllUses(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+    return CalculateDefs4AllUsesImpl(checkPoint, udChain);
+  }
+
+  uint32 Hash() const {
+    return HashImpl();
+  }
+
+  void SetLoc(const Loc &locIn) {
+    loc = locIn;
+  }
+
+  const Loc GetLoc() const {
+    return loc;
+  }
+
+  std::string Dump() const {
+    return GetFEIRNodeKindDescription(kind);
+  }
+
+ protected:
+  virtual std::unique_ptr<FEIRExpr> CloneImpl() const = 0;
+  virtual BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const = 0;
+  virtual std::vector<FEIRVar*> GetVarUsesImpl() const;
+  virtual void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {}
+  virtual bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+    return true;
+  }
+
+  virtual void SetTypeImpl(std::unique_ptr<FEIRType> argType) {
+    ASSERT_NOT_NULL(argType);
+    type = std::move(argType);
+  }
+
+  virtual PrimType GetPrimTypeImpl() const {
+    return type->GetPrimType();
+  }
+
+  virtual  FEIRType *GetTypeImpl() const {
+    ASSERT(type != nullptr, "type is nullptr");
+    return type.get();
+  }
+
+  virtual const FEIRType &GetTypeRefImpl() const {
+    ASSERT(GetTypeImpl() != nullptr, "type is nullptr");
+    return *GetTypeImpl();
+  }
+
+  virtual FieldID GetFieldIDImpl() const {
+    CHECK_FATAL(false, "unsupported in base class");
+  }
+
+  virtual void SetFieldIDImpl(FieldID fieldID) {
+    CHECK_FATAL(false, "unsupported in base class");
+  }
+
+  virtual void SetFieldTypeImpl(std::unique_ptr<FEIRType> fieldType) {
+    CHECK_FATAL(false, "unsupported in base class");
+  }
+
+  virtual uint32 HashImpl() const {
+    CHECK_FATAL(false, "unsupported in base class");
+    return 0;
+  }
+
+  virtual bool IsNestableImpl() const;
+  virtual bool IsAddrofImpl() const;
+  virtual bool HasExceptionImpl() const;
+
+  FEIRNodeKind kind;
+  bool isNestable : 1;
+  bool isAddrof : 1;
+  bool hasException : 1;
+  bool isBoundaryChecking : 1;
+  bool isEnhancedChecking : 1;
+  std::unique_ptr<FEIRType> type;
+  Loc loc = {0, 0, 0};
+};  // class FEIRExpr
+
+using UniqueFEIRExpr = std::unique_ptr<FEIRExpr>;
+
+// ---------- FEIRExprConst ----------
+union ConstExprValue {
+  bool b;
+  uint8 u8;
+  int8 i8;
+  uint16 u16;
+  int16 i16;
+  uint32 u32;
+  int32 i32;
+  float f32;
+  uint64 u64 = 0;
+  int64 i64;
+  double f64;
+};
+
+class FEIRExprConst : public FEIRExpr {
+ public:
+  FEIRExprConst();
+  FEIRExprConst(int64 val, PrimType argType);
+  FEIRExprConst(uint64 val, PrimType argType);
+  explicit FEIRExprConst(uint32 val);
+  explicit FEIRExprConst(float val);
+  explicit FEIRExprConst(double val);
+  ~FEIRExprConst() = default;
+  FEIRExprConst(const FEIRExprConst&) = delete;
+  FEIRExprConst& operator=(const FEIRExprConst&) = delete;
+
+  ConstExprValue GetValue() const {
+    return value;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+  uint32 HashImpl() const override;
+
+ private:
+  void CheckRawValue2SetZero();
+  ConstExprValue value;
+};
+
+// ---------- FEIRExprSizeOfType ----------
+class FEIRExprSizeOfType : public FEIRExpr {
+ public:
+  explicit FEIRExprSizeOfType(UniqueFEIRType ty);
+  ~FEIRExprSizeOfType() = default;
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) + feirType->Hash();
+  }
+
+ private:
+  UniqueFEIRType feirType;
+};
+
+// ---------- FEIRExprDRead ----------
+class FEIRExprDRead : public FEIRExpr {
+ public:
+  explicit FEIRExprDRead(std::unique_ptr<FEIRVar> argVarSrc);
+  FEIRExprDRead(std::unique_ptr<FEIRType> argType, std::unique_ptr<FEIRVar> argVarSrc);
+  ~FEIRExprDRead() = default;
+  void SetVarSrc(std::unique_ptr<FEIRVar> argVarSrc);
+  void SetTrans(UniqueFEIRVarTrans argTrans) {
+    varSrc->SetTrans(std::move(argTrans));
+  }
+
+  bool operator==(const FEIRExpr &expr) const override {
+    return expr.GetKind() == kExprDRead && *varSrc == *(expr.GetVarUses().front()) && fieldID == expr.GetFieldID();
+  }
+
+  bool operator!=(const FEIRExpr &expr) const override {
+    return expr.GetKind() != kExprDRead || *varSrc != *(expr.GetVarUses().front()) || fieldID != expr.GetFieldID();
+  }
+
+  UniqueFEIRVarTrans CreateTransDirect() {
+    UniqueFEIRVarTrans trans = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, varSrc);
+    return trans;
+  }
+
+  UniqueFEIRVarTrans CreateTransArrayDimDecr() {
+    UniqueFEIRVarTrans trans = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransArrayDimDecr, varSrc);
+    return trans;
+  }
+
+  UniqueFEIRVarTrans CreateTransArrayDimIncr() {
+    UniqueFEIRVarTrans trans = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransArrayDimIncr, varSrc);
+    return trans;
+  }
+
+  const UniqueFEIRVar &GetVar() const {
+    return varSrc;
+  }
+
+  std::unique_ptr<FEIRType> GetFieldType() const {
+    return fieldType->Clone();
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  PrimType GetPrimTypeImpl() const override;
+  void SetTypeImpl(std::unique_ptr<FEIRType> argType) override;
+  FEIRType *GetTypeImpl() const override;
+  const FEIRType &GetTypeRefImpl() const override;
+
+  FieldID GetFieldIDImpl() const override {
+    return fieldID;
+  }
+
+  void SetFieldTypeImpl(std::unique_ptr<FEIRType> type) override {
+    fieldType = std::move(type);
+  }
+
+  void SetFieldIDImpl(FieldID argFieldID) override {
+    fieldID = argFieldID;
+  }
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+           (static_cast<uint32>(fieldID) << kOtherShift) + varSrc->Hash();
+  }
+
+ private:
+  std::unique_ptr<FEIRVar> varSrc;
+  FieldID fieldID = 0;
+  std::unique_ptr<FEIRType> fieldType;
+};
+
+// ---------- FEIRExprRegRead ----------
+class FEIRExprRegRead : public FEIRExpr {
+ public:
+  FEIRExprRegRead(PrimType pty, int32 regNumIn);
+  ~FEIRExprRegRead() = default;
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  PrimType prmType;
+  int32 regNum;
+};
+
+// ---------- FEIRExprAddrofConstArray ----------
+class FEIRExprAddrofConstArray : public FEIRExpr {
+ public:
+  FEIRExprAddrofConstArray(const std::vector<uint32> &arrayIn, MIRType *typeIn, const std::string &strIn);
+  FEIRExprAddrofConstArray(const std::string &arrayNameIn, const std::vector<uint32> &arrayIn, MIRType *typeIn,
+                           const std::string &strIn)
+      : FEIRExpr(FEIRNodeKind::kExprAddrof,
+                 FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())),
+        arrayName(arrayNameIn),
+        elemType(typeIn),
+        str(strIn) {
+    std::copy(arrayIn.begin(), arrayIn.end(), std::back_inserter(array));
+  }
+
+  ~FEIRExprAddrofConstArray() = default;
+
+  uint32 GetStringLiteralSize() const {
+    return static_cast<uint32>(array.size());
+  }
+
+  const MIRType *GetElemType() const {
+    return elemType;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 HashImpl() const override {
+    uint32 hash = (static_cast<uint32>(kind) << kOpHashShift);
+    for (uint32 elem : array) {
+      hash += static_cast<uint32>(std::hash<uint32>{}(elem));
+    }
+    std::size_t seed = array.size();
+    for (uint32 elem : array) {
+      seed ^= elem + kRandomNum + (seed << kSeedLeftShift) + (seed >> kSeedRightShift);
+    }
+    hash += static_cast<uint32>(seed);
+    if (elemType != nullptr) {
+      hash += static_cast<uint32>(elemType->GetHashIndex());
+    }
+    return hash;
+  }
+
+ private:
+  std::string arrayName;
+  std::vector<uint32> array;
+  MIRType *elemType = nullptr;
+  std::string str;
+};
+
+// ---------- FEIRExprAddrOfLabel ----------
+class FEIRExprAddrOfLabel : public FEIRExpr {
+ public:
+  FEIRExprAddrOfLabel(const std::string &lbName, UniqueFEIRType exprType)
+      : FEIRExpr(FEIRNodeKind::kExprAddrofLabel, std::move(exprType)), labelName(lbName) {}
+  ~FEIRExprAddrOfLabel() = default;
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+            static_cast<uint32>(std::hash<std::string>{}(labelName));
+  }
+
+ private:
+  std::string labelName;
+};
+
+// ---------- FEIRExprAddrofVar ----------
+class FEIRExprAddrofVar : public FEIRExpr {
+ public:
+  explicit FEIRExprAddrofVar(std::unique_ptr<FEIRVar> argVarSrc)
+      : FEIRExpr(FEIRNodeKind::kExprAddrofVar,
+                 FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())),
+        varSrc(std::move(argVarSrc)) {}
+
+  FEIRExprAddrofVar(std::unique_ptr<FEIRVar> argVarSrc, FieldID id)
+      : FEIRExpr(FEIRNodeKind::kExprAddrofVar,
+                 FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())),
+        varSrc(std::move(argVarSrc)), fieldID(id) {}
+  ~FEIRExprAddrofVar() = default;
+
+  void SetVarValue(MIRConst *val) {
+    cst = val;
+  }
+
+  MIRConst *GetVarValue() const {
+    return cst;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+
+  FieldID GetFieldIDImpl() const override {
+    return fieldID;
+  }
+
+  void SetFieldIDImpl(FieldID id) override {
+    fieldID = id;
+  }
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+           (static_cast<uint32>(fieldID) << kOtherShift) + varSrc->Hash();
+  }
+
+ private:
+  std::unique_ptr<FEIRVar> varSrc;
+  FieldID fieldID = 0;
+  MIRConst *cst = nullptr;
+};
+
+// ---------- FEIRExprIAddrof ----------
+class FEIRExprIAddrof : public FEIRExpr {
+ public:
+  FEIRExprIAddrof(UniqueFEIRType pointeeType, FieldID id, UniqueFEIRExpr expr)
+      : FEIRExpr(FEIRNodeKind::kExprIAddrof,
+                 FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())),
+        ptrType(std::move(pointeeType)),
+        fieldID(id),
+        subExpr(std::move(expr)) {}
+  ~FEIRExprIAddrof() = default;
+
+  UniqueFEIRType GetClonedRetType() const {
+    return type->Clone();
+  }
+
+  UniqueFEIRExpr GetClonedOpnd() const {
+    return subExpr->Clone();
+  }
+
+  UniqueFEIRType GetClonedPtrType() const {
+    return ptrType->Clone();
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  FieldID GetFieldIDImpl() const override {
+    return fieldID;
+  }
+
+  void SetFieldIDImpl(FieldID argFieldID) override {
+    fieldID = argFieldID;
+  }
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+           (static_cast<uint32>(fieldID) << kOtherShift) + ptrType->Hash() + subExpr->Hash();
+  }
+
+ private:
+  UniqueFEIRType ptrType;
+  FieldID fieldID = 0;
+  UniqueFEIRExpr subExpr;
+};
+
+// ---------- FEIRExprAddrofFunc ----------
+class FEIRExprAddrofFunc : public FEIRExpr {
+ public:
+  explicit FEIRExprAddrofFunc(const std::string &addr)
+      : FEIRExpr(FEIRNodeKind::kExprAddrofFunc,
+                 FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())),
+        funcAddr(addr) {}
+  ~FEIRExprAddrofFunc() = default;
+
+  const std::string &GetFuncAddr() const {
+    return funcAddr;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+            static_cast<uint32>(std::hash<std::string>{}(funcAddr));
+  }
+
+ private:
+  std::string funcAddr;
+};
+
+// ---------- FEIRExprAddrofArray ----------
+class FEIRExprAddrofArray : public FEIRExpr {
+ public:
+  FEIRExprAddrofArray(UniqueFEIRType argTypeNativeArray, UniqueFEIRExpr argExprArray, const std::string &argArrayName,
+                      std::list<UniqueFEIRExpr> &argExprIndexs);
+  ~FEIRExprAddrofArray() = default;
+
+  void SetIndexsExprs(std::list<UniqueFEIRExpr> &exprs) {
+    exprIndexs.clear();
+    for (const auto &e : exprs) {
+      auto ue = e->Clone();
+      exprIndexs.push_back(std::move(ue));
+    }
+  }
+
+  const UniqueFEIRType &GetTypeArray() const {
+    return typeNativeArray;
+  }
+
+  const std::list<UniqueFEIRExpr> &GetExprIndexs() const {
+    return exprIndexs;
+  }
+
+  const UniqueFEIRExpr &GetExprArray() const {
+    return exprArray;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 HashImpl() const override {
+    uint32 hash = (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+                  (static_cast<uint32>(std::hash<std::string>{}(arrayName)) << kOtherShift);
+    if (typeNativeArray != nullptr) {
+      hash += typeNativeArray->Hash();
+    }
+    if (exprArray != nullptr) {
+      hash += exprArray->Hash();
+    }
+    std::size_t seed = exprIndexs.size();
+    for (const auto &idx : exprIndexs) {
+      if (idx != nullptr) {
+        seed ^= idx->Hash() + kRandomNum + (seed << kSeedLeftShift) + (seed >> kSeedRightShift);
+      }
+    }
+    return hash + static_cast<uint32>(seed);
+  }
+
+ private:
+  mutable std::list<UniqueFEIRExpr> exprIndexs;
+  UniqueFEIRType typeNativeArray = nullptr;
+  UniqueFEIRExpr exprArray = nullptr;
+  std::string arrayName;
+};
+
+// ---------- FEIRExprUnary ----------
+class FEIRExprUnary : public FEIRExpr {
+ public:
+  FEIRExprUnary(Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd);
+  FEIRExprUnary(std::unique_ptr<FEIRType> argType, Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd);
+  ~FEIRExprUnary() = default;
+  void SetOpnd(std::unique_ptr<FEIRExpr> argOpnd);
+  const UniqueFEIRExpr &GetOpnd() const;
+  static std::map<Opcode, bool> InitMapOpNestableForExprUnary();
+
+  Opcode GetOp() const {
+    return op;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+           (static_cast<uint32>(op) << kOtherShift) + opnd->Hash();
+  }
+
+  Opcode op;
+  std::unique_ptr<FEIRExpr> opnd;
+
+ private:
+  void SetExprTypeByOp();
+
+  static std::map<Opcode, bool> mapOpNestable;
+};  // class FEIRExprUnary
+
+// ---------- FEIRExprTypeCvt ----------
+class FEIRExprTypeCvt : public FEIRExprUnary {
+ public:
+  FEIRExprTypeCvt(Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd);
+  FEIRExprTypeCvt(std::unique_ptr<FEIRType> exprType, Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd);
+  ~FEIRExprTypeCvt() = default;
+  static std::map<Opcode, bool> InitMapOpNestableForTypeCvt();
+  static Opcode ChooseOpcodeByFromVarAndToVar(const FEIRVar &fromVar, const FEIRVar &toVar);
+
+  void SetSrcPrimType(PrimType pty) {
+    srcPrimType = pty;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 HashImpl() const override {
+    return FEIRExprUnary::HashImpl() + static_cast<uint32>(srcPrimType);
+  }
+
+ private:
+  using FuncPtrGenMIRNode = BaseNode* (FEIRExprTypeCvt::*)(MIRBuilder &mirBuilder) const;
+  static std::map<Opcode, FuncPtrGenMIRNode> InitFuncPtrMapForParseExpr();
+
+  // MIR: op <to-type> <from-type> (<opnd0>)
+  BaseNode *GenMIRNodeMode1(MIRBuilder &mirBuilder) const;
+
+  // MIR: op <prim-type> <float-type> (<opnd0>)
+  BaseNode *GenMIRNodeMode2(MIRBuilder &mirBuilder) const;
+
+  // MIR: retype <prim-type> <type> (<opnd0>)
+  BaseNode *GenMIRNodeMode3(MIRBuilder &mirBuilder) const;
+
+  static std::map<Opcode, bool> mapOpNestable;
+  static std::map<Opcode, FuncPtrGenMIRNode> funcPtrMapForParseExpr;
+  PrimType srcPrimType = PTY_unknown;
+};  // FEIRExprTypeCvt
+
+// ---------- FEIRExprExtractBits ----------
+class FEIRExprExtractBits : public FEIRExprUnary {
+ public:
+  FEIRExprExtractBits(Opcode argOp, PrimType argPrimType, uint8 argBitOffset, uint8 argBitSize,
+                      std::unique_ptr<FEIRExpr> argOpnd);
+  FEIRExprExtractBits(Opcode argOp, PrimType argPrimType, std::unique_ptr<FEIRExpr> argOpnd);
+  ~FEIRExprExtractBits() = default;
+  static std::map<Opcode, bool> InitMapOpNestableForExtractBits();
+  void SetBitOffset(uint8 offset) {
+    bitOffset = offset;
+  }
+
+  void SetBitSize(uint8 size) {
+    bitSize = size;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 HashImpl() const override {
+    return FEIRExprUnary::HashImpl() + (static_cast<uint32>(bitOffset) << kOtherShift) + static_cast<uint32>(bitSize);
+  }
+
+ private:
+  using FuncPtrGenMIRNode = BaseNode* (FEIRExprExtractBits::*)(MIRBuilder &mirBuilder) const;
+  static std::map<Opcode, FuncPtrGenMIRNode> InitFuncPtrMapForParseExpr();
+  BaseNode *GenMIRNodeForExtrabits(MIRBuilder &mirBuilder) const;
+  BaseNode *GenMIRNodeForExt(MIRBuilder &mirBuilder) const;
+
+  uint8 bitOffset;
+  uint8 bitSize;
+  static std::map<Opcode, bool> mapOpNestable;
+  static std::map<Opcode, FuncPtrGenMIRNode> funcPtrMapForParseExpr;
+};  // FEIRExprExtractBit
+
+// ---------- FEIRExprIRead ----------
+class FEIRExprIRead : public FEIRExpr {
+ public:
+  FEIRExprIRead(UniqueFEIRType returnType, UniqueFEIRType pointeeType, FieldID id, UniqueFEIRExpr expr)
+      : FEIRExpr(FEIRNodeKind::kExprIRead, std::move(returnType)),
+        ptrType(std::move(pointeeType)),
+        fieldID(id),
+        subExpr(std::move(expr)) {}
+  ~FEIRExprIRead() override = default;
+
+  UniqueFEIRType GetClonedRetType() const {
+    return type->Clone();
+  }
+
+  void SetClonedOpnd(UniqueFEIRExpr argOpnd) {
+    CHECK_FATAL(argOpnd != nullptr, "opnd is nullptr");
+    subExpr = std::move(argOpnd);
+  }
+
+  UniqueFEIRExpr GetClonedOpnd() const {
+    return subExpr->Clone();
+  }
+
+  UniqueFEIRType GetClonedPtrType() const {
+    return ptrType->Clone();
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  FieldID GetFieldIDImpl() const override {
+    return fieldID;
+  }
+
+  void SetFieldIDImpl(FieldID argFieldID) override {
+    fieldID = argFieldID;
+  }
+
+  void SetFieldTypeImpl(UniqueFEIRType argFieldType) override {
+    type = std::move(argFieldType);
+  }
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+           (static_cast<uint32>(fieldID) << kOtherShift) + ptrType->Hash() + subExpr->Hash();
+  }
+
+ private:
+  UniqueFEIRType ptrType = nullptr;
+  FieldID fieldID = 0;
+  UniqueFEIRExpr subExpr = nullptr;
+};
+
+// ---------- FEIRExprBinary ----------
+class FEIRExprBinary : public FEIRExpr {
+ public:
+  FEIRExprBinary(Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd0, std::unique_ptr<FEIRExpr> argOpnd1);
+  FEIRExprBinary(std::unique_ptr<FEIRType> exprType, Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd0,
+                 std::unique_ptr<FEIRExpr> argOpnd1);
+  ~FEIRExprBinary() = default;
+  void SetOpnd0(std::unique_ptr<FEIRExpr> argOpnd);
+  void SetOpnd1(std::unique_ptr<FEIRExpr> argOpnd);
+  const std::unique_ptr<FEIRExpr> &GetOpnd0() const;
+  const std::unique_ptr<FEIRExpr> &GetOpnd1() const;
+  bool IsComparative() const;
+
+  Opcode GetOp() const {
+    return op;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  bool IsNestableImpl() const override;
+  bool IsAddrofImpl() const override;
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+           (static_cast<uint32>(op) << kOtherShift) + (opnd0->Hash() << kTypeHashShift) + opnd1->Hash();
+  }
+
+ private:
+  using FuncPtrGenMIRNode = BaseNode* (FEIRExprBinary::*)(MIRBuilder &mirBuilder) const;
+  static std::map<Opcode, FuncPtrGenMIRNode> InitFuncPtrMapForGenMIRNode();
+  BaseNode *GenMIRNodeNormal(MIRBuilder &mirBuilder) const;
+  BaseNode *GenMIRNodeCompare(MIRBuilder &mirBuilder) const;
+  BaseNode *GenMIRNodeCompareU1(MIRBuilder &mirBuilder) const;
+  void SetExprTypeByOp();
+  void SetExprTypeByOpNormal();
+  void SetExprTypeByOpShift();
+  void SetExprTypeByOpLogic();
+  void SetExprTypeByOpCompare();
+
+  Opcode op;
+  std::unique_ptr<FEIRExpr> opnd0;
+  std::unique_ptr<FEIRExpr> opnd1;
+  static std::map<Opcode, FuncPtrGenMIRNode> funcPtrMapForGenMIRNode;
+};  // class FEIRExprUnary
+
+// ---------- FEIRExprTernary ----------
+class FEIRExprTernary : public FEIRExpr {
+ public:
+  FEIRExprTernary(Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd0, std::unique_ptr<FEIRExpr> argOpnd1,
+                  std::unique_ptr<FEIRExpr> argOpnd2);
+  FEIRExprTernary(Opcode argOp, std::unique_ptr<FEIRType> argType, std::unique_ptr<FEIRExpr> argOpnd0,
+                  std::unique_ptr<FEIRExpr> argOpnd1, std::unique_ptr<FEIRExpr> argOpnd2);
+  ~FEIRExprTernary() = default;
+  void SetOpnd(std::unique_ptr<FEIRExpr> argOpnd, uint32 idx);
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  bool IsNestableImpl() const override;
+  bool IsAddrofImpl() const override;
+
+  uint32 HashImpl() const override {
+    return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+           (static_cast<uint32>(op) << kOtherShift) +
+           (opnd0->Hash() << kTypeHashShift) + (opnd1->Hash() << kOtherShift) + opnd2->Hash();
+  }
+
+ private:
+  void SetExprTypeByOp();
+
+  Opcode op;
+  std::unique_ptr<FEIRExpr> opnd0;
+  std::unique_ptr<FEIRExpr> opnd1;
+  std::unique_ptr<FEIRExpr> opnd2;
+};
+
+// ---------- FEIRExprNary ----------
+class FEIRExprNary : public FEIRExpr {
+ public:
+  explicit FEIRExprNary(Opcode argOp);
+  virtual ~FEIRExprNary() = default;
+  void AddOpnd(std::unique_ptr<FEIRExpr> argOpnd);
+  void AddOpnds(const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds);
+  void ResetOpnd();
+  const std::vector<std::unique_ptr<FEIRExpr>> &GetOpnds() const {
+    return opnds;
+  }
+
+ protected:
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+
+  uint32 HashImpl() const override {
+    uint32 hash = (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+                  (static_cast<uint32>(op) << kOtherShift);
+    std::size_t seed = opnds.size();
+    for (auto &opnd : opnds) {
+      seed ^= opnd->Hash() + kRandomNum + (seed << kSeedLeftShift) + (seed >> kSeedRightShift);
+    }
+    hash += static_cast<uint32>(seed);
+    return hash;
+  }
+
+  Opcode op;
+  std::vector<std::unique_ptr<FEIRExpr>> opnds;
+};  // class FEIRExprNary
+
+// ---------- FEIRExprArray ----------
+class FEIRExprArray : public FEIRExprNary {
+ public:
+  FEIRExprArray(Opcode argOp, std::unique_ptr<FEIRExpr> argArray, std::unique_ptr<FEIRExpr> argIndex);
+  ~FEIRExprArray() = default;
+  void SetOpndArray(std::unique_ptr<FEIRExpr> opndArray);
+  void SetOpndIndex(std::unique_ptr<FEIRExpr> opndIndex);
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+  bool IsNestableImpl() const override;
+  bool IsAddrofImpl() const override;
+};  // class FEIRExprArray
+
+// ---------- FEIRExprIntrinsicop ----------
+class FEIRExprIntrinsicop : public FEIRExprNary {
+ public:
+  FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID);
+  FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                      std::unique_ptr<FEIRType> argParamType);
+  FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                      const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds);
+  FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                      std::unique_ptr<FEIRType> argParamType, uint32 argTypeID);
+  FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                      std::unique_ptr<FEIRType> argParamType,
+                      const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds);
+  ~FEIRExprIntrinsicop() = default;
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+  bool IsNestableImpl() const override;
+  bool IsAddrofImpl() const override;
+
+  uint32 HashImpl() const override {
+    uint32 hash = FEIRExprNary::HashImpl() + (static_cast<uint32>(intrinsicID) << 16) + typeID;
+    if (paramType != nullptr) {
+      hash += paramType->Hash();
+    }
+    return hash;
+  }
+
+ private:
+  MIRIntrinsicID intrinsicID;
+  std::unique_ptr<FEIRType> paramType;
+  uint32 typeID = UINT32_MAX;
+};  // class FEIRExprIntrinsicop
+
+class FEIRExprIntrinsicopForC : public FEIRExprNary {
+ public:
+  FEIRExprIntrinsicopForC(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                          const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds);
+  ~FEIRExprIntrinsicopForC() = default;
+
+  MIRIntrinsicID GetIntrinsicID() const {
+    return intrinsicID;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 HashImpl() const override {
+    return FEIRExprNary::HashImpl() + static_cast<uint32>(intrinsicID);
+  }
+
+ private:
+  MIRIntrinsicID intrinsicID;
+}; // class FEIRExprIntrinsicopForC
+
+class FEIRExprJavaMerge : public FEIRExprNary {
+ public:
+  FEIRExprJavaMerge(std::unique_ptr<FEIRType> mergedTypeArg, const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds);
+  ~FEIRExprJavaMerge() = default;
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+};
+
+// ---------- FEIRExprJavaNewInstance ----------
+class FEIRExprJavaNewInstance : public FEIRExpr {
+ public:
+  explicit FEIRExprJavaNewInstance(UniqueFEIRType argType);
+  FEIRExprJavaNewInstance(UniqueFEIRType argType, uint32 argTypeID);
+  FEIRExprJavaNewInstance(UniqueFEIRType argType, uint32 argTypeID, bool argIsRcPermanent);
+  ~FEIRExprJavaNewInstance() = default;
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 typeID = UINT32_MAX;
+  // isRcPermanent is true means the rc annotation @Permanent is used
+  bool isRcPermanent = false;
+};
+
+// ---------- FEIRExprJavaNewArray ----------
+class FEIRExprJavaNewArray : public FEIRExpr {
+ public:
+  FEIRExprJavaNewArray(UniqueFEIRType argArrayType, UniqueFEIRExpr argExprSize);
+  FEIRExprJavaNewArray(UniqueFEIRType argArrayType, UniqueFEIRExpr argExprSize, uint32 argTypeID);
+  FEIRExprJavaNewArray(UniqueFEIRType argArrayType, UniqueFEIRExpr argExprSize, uint32 argTypeID,
+                       bool argIsRcPermanent);
+  ~FEIRExprJavaNewArray() = default;
+  void SetArrayType(UniqueFEIRType argArrayType) {
+    CHECK_NULL_FATAL(argArrayType);
+    arrayType = std::move(argArrayType);
+  }
+
+  void SetExprSize(UniqueFEIRExpr argExprSize) {
+    CHECK_NULL_FATAL(argExprSize);
+    exprSize = std::move(argExprSize);
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  UniqueFEIRType arrayType;
+  UniqueFEIRExpr exprSize;
+  uint32 typeID = UINT32_MAX;
+  // isRcPermanent is true means the rc annotation @Permanent is used
+  bool isRcPermanent = false;
+};
+
+// ---------- FEIRExprJavaArrayLength ----------
+class FEIRExprJavaArrayLength : public FEIRExpr {
+ public:
+  explicit FEIRExprJavaArrayLength(UniqueFEIRExpr argExprArray);
+  ~FEIRExprJavaArrayLength() = default;
+  void SetExprArray(UniqueFEIRExpr argExprArray) {
+    CHECK_NULL_FATAL(argExprArray);
+    exprArray = std::move(argExprArray);
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  UniqueFEIRExpr exprArray;
+};
+
+// ---------- FEIRExprArrayLoad ----------
+class FEIRExprArrayLoad : public FEIRExpr {
+ public:
+  FEIRExprArrayLoad(UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeArray);
+  ~FEIRExprArrayLoad() = default;
+  const UniqueFEIRType GetElemType() const {
+    UniqueFEIRType typeElem = typeArray->Clone();
+    (void)typeElem->ArrayDecrDim();
+    return typeElem;
+  }
+
+  UniqueFEIRVarTrans CreateTransArrayDimDecr() {
+    FEIRExprDRead *dRead = static_cast<FEIRExprDRead*>(exprArray.get());
+    return dRead->CreateTransArrayDimDecr();
+  }
+
+  void SetTrans(UniqueFEIRVarTrans argTrans) {
+    CHECK_FATAL(argTrans->GetTransKind() == kFEIRVarTransArrayDimIncr, "ArrayLoad must hold DimIncr Transfer Function");
+    FEIRExprDRead *dRead = static_cast<FEIRExprDRead*>(exprArray.get());
+    dRead->SetTrans(std::move(argTrans));
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  UniqueFEIRExpr exprArray;
+  UniqueFEIRExpr exprIndex;
+  UniqueFEIRType typeArray;
+};
+
+class FEIRExprCStyleCast : public FEIRExpr {
+ public:
+  FEIRExprCStyleCast(MIRType *src, MIRType *dest, UniqueFEIRExpr sub, bool isArr2Pty);
+  ~FEIRExprCStyleCast() = default;
+  void SetArray2Pointer(bool isArr2Ptr) {
+    isArray2Pointer = isArr2Ptr;
+  }
+
+  void SetRefName(const std::string &name) {
+    refName = name;
+  }
+
+  const UniqueFEIRExpr &GetSubExpr() const {
+    return subExpr;
+  }
+
+  MIRType *GetMIRType() const {
+    CHECK_NULL_FATAL(destType);
+    return destType;
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  std::vector<FEIRVar*> GetVarUsesImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  MIRType *srcType = nullptr;
+  MIRType *destType = nullptr;
+  UniqueFEIRExpr subExpr;
+  bool isArray2Pointer;
+  std::string refName;
+};
+
+enum ASTAtomicOp {
+  kAtomicOpUndefined,
+  kAtomicOpLoad,
+  kAtomicOpLoadN,
+  kAtomicOpStore,
+  kAtomicOpStoreN,
+  kAtomicOpExchange,
+  kAtomicOpExchangeN,
+  kAtomicOpAddFetch,
+  kAtomicOpSubFetch,
+  kAtomicOpAndFetch,
+  kAtomicOpXorFetch,
+  kAtomicOpOrFetch,
+  kAtomicOpNandFetch,
+  kAtomicOpFetchAdd,
+  kAtomicOpFetchSub,
+  kAtomicOpFetchAnd,
+  kAtomicOpFetchXor,
+  kAtomicOpFetchOr,
+  kAtomicOpFetchNand,
+};
+
+class FEIRExprAtomic : public FEIRExpr {
+ public:
+  FEIRExprAtomic(MIRType *ty, MIRType *ref, UniqueFEIRExpr obj, ASTAtomicOp atomOp);
+  ~FEIRExprAtomic() = default;
+
+  void SetVal1Type(MIRType *ty) {
+    val1Type = ty;
+  }
+
+  void SetVal1Expr(UniqueFEIRExpr expr) {
+    valExpr1 = std::move(expr);
+  }
+
+  void SetVal2Type(MIRType *ty) {
+    val2Type = ty;
+  }
+
+  void SetVal2Expr(UniqueFEIRExpr expr) {
+    valExpr2 = std::move(expr);
+  }
+
+  void SetOrderExpr(UniqueFEIRExpr order) {
+    orderExpr = std::move(order);
+  }
+
+  void SetValVar(UniqueFEIRVar value) {
+    val = std::move(value);
+  }
+
+ protected:
+  std::unique_ptr<FEIRExpr> CloneImpl() const override;
+  BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  MIRType *mirType = nullptr;
+  MIRType *refType = nullptr;
+  MIRType *ptrType = nullptr;
+  MIRType *val1Type = nullptr;
+  MIRType *val2Type = nullptr;
+  UniqueFEIRExpr objExpr;
+  UniqueFEIRExpr valExpr1;
+  UniqueFEIRExpr valExpr2;
+  UniqueFEIRExpr orderExpr;
+  ASTAtomicOp atomicOp;
+  UniqueFEIRVar val;
+};
+
+// ---------- FEIRStmtNary ----------
+class FEIRStmtNary : public FEIRStmt {
+ public:
+  FEIRStmtNary(Opcode opIn, std::list<std::unique_ptr<FEIRExpr>> argExprsIn);
+  virtual ~FEIRStmtNary() = default;
+
+  void SetOP(Opcode opIn) {
+    op = opIn;
+  }
+
+  Opcode GetOP() const {
+    return op;
+  }
+
+  const std::list<std::unique_ptr<FEIRExpr>> &GetArgExprs() const {
+    return argExprs;
+  }
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+  Opcode op;
+  std::list<std::unique_ptr<FEIRExpr>> argExprs;
+};
+
+// ---------- FEIRStmtAssign ----------
+class FEIRStmtAssign : public FEIRStmt {
+ public:
+  FEIRStmtAssign(FEIRNodeKind argKind, std::unique_ptr<FEIRVar> argVar);
+  ~FEIRStmtAssign() = default;
+  FEIRVar *GetVar() const {
+    return var.get();
+  }
+
+  void SetVar(std::unique_ptr<FEIRVar> argVar) {
+    var = std::move(argVar);
+    var->SetDef(HasDef());
+  }
+
+  void AddExprArg(UniqueFEIRExpr exprArg) {
+    exprArgs.push_back(std::move(exprArg));
+  }
+
+  void AddExprArgReverse(UniqueFEIRExpr exprArg) {
+    exprArgs.push_front(std::move(exprArg));
+  }
+
+  bool HasException() const {
+    return hasException;
+  }
+
+  void SetHasException(bool arg) {
+    hasException = arg;
+  }
+
+ protected:
+  bool HasDefImpl() const override {
+    return ((var != nullptr) && (var.get() != nullptr));
+  }
+
+  FEIRVarTypeScatter* GetTypeScatterDefVarImpl() const override {
+    if (!HasDefImpl()) {
+      return nullptr;
+    }
+    if (var->GetKind() == kFEIRVarTypeScatter) {
+      FEIRVarTypeScatter *varTypeScatter = static_cast<FEIRVarTypeScatter*>(var.get());
+      return varTypeScatter;
+    }
+    return nullptr;
+  }
+
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool hasException;
+  std::unique_ptr<FEIRVar> var = nullptr;
+  std::list<UniqueFEIRExpr> exprArgs;
+};
+
+// ---------- FEIRStmtDAssign ----------
+class FEIRStmtDAssign : public FEIRStmtAssign {
+ public:
+  FEIRStmtDAssign(std::unique_ptr<FEIRVar> argVar, std::unique_ptr<FEIRExpr> argExpr, int32 argFieldID = 0);
+  ~FEIRStmtDAssign() = default;
+  FEIRExpr *GetExpr() const {
+    return expr.get();
+  }
+
+  void SetExpr(std::unique_ptr<FEIRExpr> argExpr) {
+    expr = std::move(argExpr);
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  void InitTrans4AllVarsImpl() override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  void InsertNonnullChecking(MIRBuilder &mirBuilder, const MIRSymbol &dstSym, std::list<StmtNode*> &ans) const;
+  void AssignBoundaryVarAndChecking(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const;
+  void CheckNonnullArgsAndRetForFuncPtr(const MIRBuilder &mirBuilder) const;
+  void CheckBoundaryArgsAndRetForFuncPtr(const MIRBuilder &mirBuilder) const;
+
+  std::unique_ptr<FEIRExpr> expr;
+  FieldID fieldID;
+};
+
+// ---------- FEIRStmtIAssign ----------
+class FEIRStmtIAssign : public FEIRStmt {
+ public:
+  FEIRStmtIAssign(UniqueFEIRType argAddrType, UniqueFEIRExpr argAddrExpr, UniqueFEIRExpr argBaseExpr, FieldID id)
+      : FEIRStmt(FEIRNodeKind::kStmtIAssign),
+        addrType(std::move(argAddrType)),
+        addrExpr(std::move(argAddrExpr)),
+        baseExpr(std::move(argBaseExpr)),
+        fieldID(id) {}
+  ~FEIRStmtIAssign() = default;
+
+ protected:
+  std::list<StmtNode *> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  void InsertNonnullChecking(MIRBuilder &mirBuilder, const MIRType &baseType, std::list<StmtNode*> &ans) const;
+  void CheckNonnullArgsAndRetForFuncPtr(const MIRBuilder &mirBuilder, const MIRType &baseType) const;
+  void CheckBoundaryArgsAndRetForFuncPtr(const MIRBuilder &mirBuilder, const MIRType &baseType) const;
+  void AssignBoundaryVarAndChecking(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const;
+
+  UniqueFEIRType addrType;
+  UniqueFEIRExpr addrExpr;
+  UniqueFEIRExpr baseExpr;
+  FieldID fieldID;
+};
+
+// ---------- FEIRStmtJavaTypeCheck ----------
+class FEIRStmtJavaTypeCheck : public FEIRStmtAssign {
+ public:
+  enum CheckKind {
+    kCheckCast,
+    kInstanceOf
+  };
+
+  FEIRStmtJavaTypeCheck(std::unique_ptr<FEIRVar> argVar, std::unique_ptr<FEIRExpr> argExpr,
+                        std::unique_ptr<FEIRType> argType, CheckKind argCheckKind);
+  FEIRStmtJavaTypeCheck(std::unique_ptr<FEIRVar> argVar, std::unique_ptr<FEIRExpr> argExpr,
+                        std::unique_ptr<FEIRType> argType, CheckKind argCheckKind, uint32 argTypeID);
+  ~FEIRStmtJavaTypeCheck() = default;
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  CheckKind checkKind;
+  std::unique_ptr<FEIRExpr> expr;
+  std::unique_ptr<FEIRType> type;
+  uint32 typeID = UINT32_MAX;
+};
+
+// ---------- FEIRStmtJavaConstClass ----------
+class FEIRStmtJavaConstClass : public FEIRStmtAssign {
+ public:
+  FEIRStmtJavaConstClass(std::unique_ptr<FEIRVar> argVar, std::unique_ptr<FEIRType> argType);
+  ~FEIRStmtJavaConstClass() = default;
+
+ protected:
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  std::unique_ptr<FEIRType> type;
+};
+
+// ---------- FEIRStmtJavaConstString ----------
+class FEIRStmtJavaConstString : public FEIRStmtAssign {
+ public:
+  FEIRStmtJavaConstString(std::unique_ptr<FEIRVar> argVar, const std::string &argStrVal,
+                          uint32 argFileIdx, uint32 argStringID);
+  ~FEIRStmtJavaConstString() = default;
+
+ protected:
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  std::string strVal;
+  uint32 fileIdx;
+  uint32 stringID = UINT32_MAX;
+};
+
+// ---------- FEIRStmtJavaFillArrayData ----------
+class FEIRStmtJavaFillArrayData : public FEIRStmtAssign {
+ public:
+  FEIRStmtJavaFillArrayData(std::unique_ptr<FEIRExpr> arrayExprIn, const int8 *arrayDataIn,
+                            uint32 sizeIn, const std::string &arrayNameIn);
+  ~FEIRStmtJavaFillArrayData() = default;
+
+ protected:
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ LLT_PRIVATE:
+  PrimType ProcessArrayElemPrimType() const;
+  MIRSymbol *ProcessArrayElemData(const MIRBuilder &mirBuilder, PrimType elemPrimType) const;
+  MIRAggConst *FillArrayElem(const MIRBuilder &mirBuilder, PrimType elemPrimType, MIRType &arrayTypeWithSize,
+                             uint32 elemSize) const;
+
+  std::unique_ptr<FEIRExpr> arrayExpr;
+  const int8 *arrayData = nullptr;
+  uint32 size = 0;
+  const std::string arrayName;
+};
+
+// ---------- FEIRStmtJavaMultiANewArray ----------
+class FEIRStmtJavaMultiANewArray : public FEIRStmtAssign {
+ public:
+  FEIRStmtJavaMultiANewArray(std::unique_ptr<FEIRVar> argVar, std::unique_ptr<FEIRType> argElemType,
+                             std::unique_ptr<FEIRType> argArrayType);
+  ~FEIRStmtJavaMultiANewArray() = default;
+  void AddVarSize(std::unique_ptr<FEIRVar> argVarSize);
+  void AddVarSizeRev(std::unique_ptr<FEIRVar> argVarSize);
+  void SetArrayType(std::unique_ptr<FEIRType> argArrayType) {
+    arrayType = std::move(argArrayType);
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  static const UniqueFEIRVar &GetVarSize();
+  static const UniqueFEIRVar &GetVarClass();
+  static const UniqueFEIRType &GetTypeAnnotation();
+  static FEStructMethodInfo &GetMethodInfoNewInstance();
+
+  std::unique_ptr<FEIRType> elemType;
+  std::unique_ptr<FEIRType> arrayType;
+  std::list<std::unique_ptr<FEIRExpr>> exprSizes;
+  static UniqueFEIRVar varSize;
+  static UniqueFEIRVar varClass;
+  static UniqueFEIRType typeAnnotation;
+  static FEStructMethodInfo *methodInfoNewInstance;
+};
+
+// ---------- FEIRStmtUseOnly ----------
+class FEIRStmtUseOnly : public FEIRStmt {
+ public:
+  FEIRStmtUseOnly(FEIRNodeKind argKind, Opcode argOp, std::unique_ptr<FEIRExpr> argExpr);
+  FEIRStmtUseOnly(Opcode argOp, std::unique_ptr<FEIRExpr> argExpr);
+  virtual ~FEIRStmtUseOnly() = default;
+
+  const std::unique_ptr<FEIRExpr> &GetExpr() const {
+    return expr;
+  }
+
+ protected:
+  bool IsFallThroughImpl() const override {
+    if ((op == OP_return) || (op == OP_throw)) {
+      return false;
+    }
+    return true;
+  }
+
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  bool SkipNonnullChecking(MIRBuilder &mirBuilder) const;
+
+  Opcode op;
+  std::unique_ptr<FEIRExpr> expr;
+};
+
+// ---------- FEIRStmtSafetyCallAssert ----------
+class FEIRStmtSafetyCallAssert {
+ public:
+  FEIRStmtSafetyCallAssert(const std::string &funcName, size_t paramIndex)
+      : funcNameIdx(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName)), paramIndex(paramIndex) {}
+
+  virtual ~FEIRStmtSafetyCallAssert() = default;
+
+  const std::string &GetFuncName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(funcNameIdx);
+  }
+
+  GStrIdx GetFuncNameIdx() const {
+    return funcNameIdx;
+  }
+
+  size_t GetParamIndex() const {
+    return paramIndex;
+  }
+
+ private:
+  GStrIdx funcNameIdx;
+  size_t paramIndex;
+};
+
+// ---------- FEIRStmtAssertNonnull ----------
+class FEIRStmtAssertNonnull : public FEIRStmtUseOnly {
+ public:
+  FEIRStmtAssertNonnull(Opcode argOp, std::unique_ptr<FEIRExpr> argExpr)
+      : FEIRStmtUseOnly(argOp, std::move(argExpr)) {}
+
+  ~FEIRStmtAssertNonnull() = default;
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+};
+
+// ---------- FEIRStmtCallAssertNonnull ----------
+class FEIRStmtCallAssertNonnull : public FEIRStmtUseOnly, public FEIRStmtSafetyCallAssert {
+ public:
+  FEIRStmtCallAssertNonnull(Opcode argOp, std::unique_ptr<FEIRExpr> argExpr, const std::string &funcName,
+                            size_t paramIndex)
+      : FEIRStmtUseOnly(argOp, std::move(argExpr)), FEIRStmtSafetyCallAssert(funcName, paramIndex) {}
+
+  ~FEIRStmtCallAssertNonnull() = default;
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+};
+
+// ---------- FEIRStmtCallAssertBoundary ----------
+class FEIRStmtCallAssertBoundary : public FEIRStmtNary, public FEIRStmtSafetyCallAssert {
+ public:
+  FEIRStmtCallAssertBoundary(Opcode opIn, std::list<std::unique_ptr<FEIRExpr>> argExprsIn, const std::string &funcName,
+                             size_t paramIndex)
+      : FEIRStmtNary(opIn, std::move(argExprsIn)), FEIRStmtSafetyCallAssert(funcName, paramIndex) {}
+
+  ~FEIRStmtCallAssertBoundary() = default;
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+};
+
+// ---------- FEIRStmtAssertBoundary ----------
+class FEIRStmtAssertBoundary : public FEIRStmtNary {
+ public:
+  FEIRStmtAssertBoundary(Opcode opIn,
+      std::list<std::unique_ptr<FEIRExpr>> argExprsIn) : FEIRStmtNary(opIn, std::move(argExprsIn)) {}
+  ~FEIRStmtAssertBoundary() = default;
+
+  void SetIsComputable(bool flag) {
+    isComputable = flag;
+  }
+
+  bool IsComputable() const {
+    return isComputable;
+  }
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  bool isComputable = false;
+};
+
+// ---------- FEIRStmtReturn ----------
+class FEIRStmtReturn : public FEIRStmtUseOnly {
+ public:
+  explicit FEIRStmtReturn(std::unique_ptr<FEIRExpr> argExpr);
+  ~FEIRStmtReturn() = default;
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  void InsertNonnullChecking(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const;
+};
+
+// ---------- FEIRStmtPesudoLabel ----------
+class FEIRStmtPesudoLabel : public FEIRStmt {
+ public:
+  explicit FEIRStmtPesudoLabel(uint32 argLabelIdx);
+  ~FEIRStmtPesudoLabel() = default;
+  void GenerateLabelIdx(const MIRBuilder &mirBuilder);
+
+  uint32 GetLabelIdx() const {
+    return labelIdx;
+  }
+
+  LabelIdx GetMIRLabelIdx() const {
+    return mirLabelIdx;
+  }
+
+ protected:
+  bool IsTargetImpl() const override {
+    return true;
+  }
+
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  uint32 labelIdx;
+  LabelIdx mirLabelIdx;
+};
+
+class FEIRStmtPesudoLabel2 : public FEIRStmt {
+ public:
+  FEIRStmtPesudoLabel2(uint32 qIdx0, uint32 qIdx1)
+      : FEIRStmt(FEIRNodeKind::kStmtPesudoLabel), labelIdxOuter(qIdx0), labelIdxInner(qIdx1) {}
+
+  ~FEIRStmtPesudoLabel2() = default;
+  static LabelIdx GenMirLabelIdx(const MIRBuilder &mirBuilder, uint32 qIdx0, uint32 qIdx1);
+  std::pair<uint32, uint32> GetLabelIdx() const;
+  uint32 GetPos() const {
+    return labelIdxInner;
+  }
+
+ protected:
+  bool IsTargetImpl() const override {
+    return true;
+  }
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 labelIdxOuter;
+  uint32 labelIdxInner;
+};
+
+// ---------- FEIRStmtGoto ----------
+class FEIRStmtGoto : public FEIRStmt {
+ public:
+  explicit FEIRStmtGoto(uint32 argLabelIdx);
+  ~FEIRStmtGoto() override;
+  void SetLabelIdx(uint32 argLabelIdx) {
+    labelIdx = argLabelIdx;
+  }
+
+  uint32 GetLabelIdx() const {
+    return labelIdx;
+  }
+
+  void SetStmtTarget(FEIRStmtPesudoLabel &argStmtTarget) {
+    stmtTarget = &argStmtTarget;
+  }
+
+  const FEIRStmtPesudoLabel &GetStmtTargetRef() const {
+    CHECK_NULL_FATAL(stmtTarget);
+    return *stmtTarget;
+  }
+
+ protected:
+  bool IsFallThroughImpl() const override {
+    return false;
+  }
+
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  uint32 labelIdx;
+  FEIRStmtPesudoLabel *stmtTarget;
+};
+
+// ---------- FEIRStmtGoto2 ----------
+class FEIRStmtGoto2 : public FEIRStmt {
+ public:
+  FEIRStmtGoto2(uint32 qIdx0, uint32 qIdx1);
+  virtual ~FEIRStmtGoto2() = default;
+  std::pair<uint32, uint32> GetLabelIdx() const;
+  uint32 GetTarget() const {
+    return labelIdxInner;
+  }
+
+  void SetStmtTarget(FEIRStmtPesudoLabel2 &argStmtTarget) {
+    stmtTarget = &argStmtTarget;
+  }
+
+  const FEIRStmtPesudoLabel2 &GetStmtTargetRef() const {
+    CHECK_NULL_FATAL(stmtTarget);
+    return *stmtTarget;
+  }
+
+ protected:
+  bool IsFallThroughImpl() const override {
+    return false;
+  }
+
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+  uint32 labelIdxOuter;
+  uint32 labelIdxInner;
+  FEIRStmtPesudoLabel2 *stmtTarget = nullptr;
+};
+
+// ---------- FEIRStmtGoto ----------
+class FEIRStmtGotoForC : public FEIRStmt {
+ public:
+  explicit FEIRStmtGotoForC(const std::string &name);
+  virtual ~FEIRStmtGotoForC() = default;
+  void SetLabelName(const std::string &name) {
+    labelName = name;
+  }
+
+  std::string GetLabelName() const {
+    return labelName;
+  }
+
+  void AddVLASvaedStackVars(uint32 scopeID, UniqueFEIRVar vlaSavedStackVar) {
+    vlaSvaedStackVars.emplace_back(std::make_pair(scopeID, std::move(vlaSavedStackVar)));
+  }
+
+ protected:
+  bool IsFallThroughImpl() const override {
+    return false;
+  }
+
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  void GenVLACleanup(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const;
+
+  std::string labelName;
+  std::vector<std::pair<uint32, UniqueFEIRVar>> vlaSvaedStackVars;
+};
+
+// ---------- FEIRStmtIGoto ----------
+class FEIRStmtIGoto : public FEIRStmt {
+ public:
+  explicit FEIRStmtIGoto(UniqueFEIRExpr expr);
+  virtual ~FEIRStmtIGoto() = default;
+
+ protected:
+  bool IsFallThroughImpl() const override {
+    return false;
+  }
+
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+  UniqueFEIRExpr targetExpr;
+};
+
+// ---------- FEIRStmtCondGotoForC ----------
+class FEIRStmtCondGotoForC : public FEIRStmt {
+ public:
+  explicit FEIRStmtCondGotoForC(UniqueFEIRExpr argExpr, Opcode op, const std::string &name)
+      : FEIRStmt(FEIRNodeKind::kStmtCondGoto), expr(std::move(argExpr)), opCode(op), labelName(name) {}
+  virtual ~FEIRStmtCondGotoForC() = default;
+  void SetLabelName(const std::string &name) {
+    labelName = name;
+  }
+
+  std::string GetLabelName() const {
+    return labelName;
+  }
+
+  const UniqueFEIRExpr &GetConditionExpr() const {
+    return expr;
+  }
+
+  void SetCondtionExpr(UniqueFEIRExpr &exprIn) {
+    expr = std::move(exprIn);
+  }
+
+ protected:
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  UniqueFEIRExpr expr;
+  Opcode opCode;
+  std::string labelName;
+};
+
+// ---------- FEIRStmtCondGoto ----------
+class FEIRStmtCondGoto : public FEIRStmtGoto {
+ public:
+  FEIRStmtCondGoto(Opcode argOp, uint32 argLabelIdx, UniqueFEIRExpr argExpr);
+  ~FEIRStmtCondGoto() = default;
+  void SetOpcode(Opcode argOp) {
+    op = argOp;
+  }
+
+  Opcode GetOpcode() const {
+    return op;
+  }
+
+  void SetExpr(UniqueFEIRExpr argExpr) {
+    CHECK_NULL_FATAL(argExpr);
+    expr = std::move(argExpr);
+  }
+
+ protected:
+  bool IsFallThroughImpl() const override {
+    return true;
+  }
+
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  Opcode op;
+  UniqueFEIRExpr expr;
+};
+
+// ---------- FEIRStmtCondGoto2 ----------
+class FEIRStmtCondGoto2 : public FEIRStmtGoto2 {
+ public:
+  FEIRStmtCondGoto2(Opcode argOp, uint32 qIdx0, uint32 qIdx1, UniqueFEIRExpr argExpr);
+  ~FEIRStmtCondGoto2() = default;
+
+ protected:
+  bool IsFallThroughImpl() const override {
+    return true;
+  }
+
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  Opcode op;
+  UniqueFEIRExpr expr;
+};
+
+// ---------- FEIRStmtSwitch ----------
+class FEIRStmtSwitch : public FEIRStmt {
+ public:
+  explicit FEIRStmtSwitch(UniqueFEIRExpr argExpr);
+  ~FEIRStmtSwitch() override;
+  void SetDefaultLabelIdx(uint32 labelIdx) {
+    defaultLabelIdx = labelIdx;
+  }
+
+  uint32 GetDefaultLabelIdx() const {
+    return defaultLabelIdx;
+  }
+
+  void SetDefaultTarget(FEIRStmtPesudoLabel &stmtTarget) {
+    defaultTarget = &stmtTarget;
+  }
+
+  const FEIRStmtPesudoLabel &GetDefaultTarget() const {
+    return *defaultTarget;
+  }
+
+  const std::map<int32, uint32> &GetMapValueLabelIdx() const {
+    return mapValueLabelIdx;
+  }
+
+  const std::map<int32, FEIRStmtPesudoLabel*> &GetMapValueTargets() const {
+    return mapValueTargets;
+  }
+
+  void AddTarget(int32 value, uint32 labelIdx) {
+    mapValueLabelIdx[value] = labelIdx;
+  }
+
+  void AddTarget(int32 value, FEIRStmtPesudoLabel &target) {
+    mapValueTargets[value] = &target;
+  }
+
+  void SetExpr(UniqueFEIRExpr argExpr) {
+    CHECK_NULL_FATAL(argExpr);
+    expr = std::move(argExpr);
+  }
+
+ protected:
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  bool IsFallThroughImpl() const override;
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  uint32 defaultLabelIdx;
+  FEIRStmtPesudoLabel *defaultTarget;
+  std::map<int32, uint32> mapValueLabelIdx;
+  std::map<int32, FEIRStmtPesudoLabel*> mapValueTargets;
+  UniqueFEIRExpr expr;
+};
+
+// ---------- FEIRStmtSwitch2 ----------
+class FEIRStmtSwitch2 : public FEIRStmt {
+ public:
+  explicit FEIRStmtSwitch2(uint32 outerIdxIn, UniqueFEIRExpr argExpr);
+  ~FEIRStmtSwitch2() override;
+  void SetDefaultLabelIdx(uint32 labelIdx) {
+    defaultLabelIdx = labelIdx;
+  }
+
+  uint32 GetDefaultLabelIdx() const {
+    return defaultLabelIdx;
+  }
+
+  void SetDefaultTarget(FEIRStmtPesudoLabel2 *stmtTarget) {
+    defaultTarget = stmtTarget;
+  }
+
+  const FEIRStmtPesudoLabel2 &GetDefaultTarget() const {
+    return *defaultTarget;
+  }
+
+  const std::map<int32, uint32> &GetMapValueLabelIdx() const {
+    return mapValueLabelIdx;
+  }
+
+  const std::map<int32, FEIRStmtPesudoLabel2*> &GetMapValueTargets() const {
+    return mapValueTargets;
+  }
+
+  void AddTarget(int32 value, uint32 labelIdx) {
+    mapValueLabelIdx[value] = labelIdx;
+  }
+
+  void AddTarget(int32 value, FEIRStmtPesudoLabel2 *target) {
+    mapValueTargets[value] = target;
+  }
+
+  void SetExpr(UniqueFEIRExpr argExpr) {
+    CHECK_NULL_FATAL(argExpr);
+    expr = std::move(argExpr);
+  }
+
+ protected:
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  bool IsFallThroughImpl() const override;
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  uint32 outerIdx;
+  uint32 defaultLabelIdx = UINT32_MAX;
+  FEIRStmtPesudoLabel2 *defaultTarget;
+  std::map<int32, uint32> mapValueLabelIdx;
+  std::map<int32, FEIRStmtPesudoLabel2*> mapValueTargets;
+  UniqueFEIRExpr expr;
+};
+
+// ---------- FEIRStmtSwitchForC ----------
+class FEIRStmtSwitchForC : public FEIRStmt {
+ public:
+  FEIRStmtSwitchForC(UniqueFEIRExpr argCondExpr, bool argHasDefault);
+  ~FEIRStmtSwitchForC() = default;
+  void AddFeirStmt(UniqueFEIRStmt stmt) {
+    subStmts.emplace_back(std::move(stmt));
+  }
+
+  void SetExpr(UniqueFEIRExpr argExpr) {
+    CHECK_NULL_FATAL(argExpr);
+    expr = std::move(argExpr);
+  }
+
+  void SetHasDefault(bool argHasDefault) {
+    hasDefault = argHasDefault;
+  }
+
+  void SetBreakLabelName(std::string name) {
+    breakLabelName = std::move(name);
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  UniqueFEIRExpr expr;
+  bool hasDefault = true;
+  std::list<UniqueFEIRStmt> subStmts;
+  std::string breakLabelName;
+};
+
+// ---------- FEIRStmtCaseForC ----------
+class FEIRStmtCaseForC : public FEIRStmt {
+ public:
+  explicit FEIRStmtCaseForC(int64 label);
+  void AddCaseTag2CaseVec(int64 lCaseTag, int64 rCaseTag);
+  ~FEIRStmtCaseForC() = default;
+  void AddFeirStmt(UniqueFEIRStmt stmt) {
+    subStmts.emplace_back(std::move(stmt));
+  }
+  const std::map<int64, std::unique_ptr<FEIRStmtPesudoLabel>> &GetPesudoLabelMap() const {
+    return pesudoLabelMap;
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  int64 lCaseLabel;
+  std::map<int64, std::unique_ptr<FEIRStmtPesudoLabel>> pesudoLabelMap =
+      std::map<int64, std::unique_ptr<FEIRStmtPesudoLabel>>();
+  std::list<UniqueFEIRStmt> subStmts;
+};
+
+// ---------- FEIRStmtDefaultForC ----------
+class FEIRStmtDefaultForC : public FEIRStmt {
+ public:
+  explicit FEIRStmtDefaultForC();
+  ~FEIRStmtDefaultForC() = default;
+  void AddFeirStmt(UniqueFEIRStmt stmt) {
+    subStmts.emplace_back(std::move(stmt));
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  std::list<UniqueFEIRStmt> subStmts;
+};
+
+// ---------- FEIRStmtArrayStore ----------
+class FEIRStmtArrayStore : public FEIRStmt {
+ public:
+  FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex,
+                     UniqueFEIRType argTypeArray);
+
+  // for C
+  FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex,
+                     UniqueFEIRType argTypeArray, const std::string &argArrayName);
+
+  // for C mul array
+  FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex,
+                     UniqueFEIRType argTypeArray, UniqueFEIRType argTypeElem, const std::string &argArrayName);
+  // for C mul array
+  FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, std::list<UniqueFEIRExpr> &argExprIndexs,
+                     UniqueFEIRType argTypeArray, const std::string &argArrayName);
+
+  // for C array in struct
+  FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, std::list<UniqueFEIRExpr> &argExprIndexs,
+                     UniqueFEIRType argTypeArray, UniqueFEIRExpr argExprStruct, UniqueFEIRType argTypeStruct,
+                     const std::string &argArrayName);
+
+  ~FEIRStmtArrayStore() = default;
+
+  void SetIndexsExprs(std::list<UniqueFEIRExpr> &exprs) {
+    exprIndexs.clear();
+    for (const auto &e : exprs) {
+      auto ue = e->Clone();
+      exprIndexs.push_back(std::move(ue));
+    }
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  void InitTrans4AllVarsImpl() override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  void GenMIRStmtsImplForCPart(MIRBuilder &mirBuilder, MIRType *ptrMIRArrayType, MIRType **mIRElemType,
+                               BaseNode **arrayExpr) const;
+
+ private:
+  UniqueFEIRExpr exprElem;
+  UniqueFEIRExpr exprArray;
+  UniqueFEIRExpr exprIndex;
+  // for C mul array
+  mutable std::list<UniqueFEIRExpr> exprIndexs;
+  UniqueFEIRType typeArray;
+  mutable UniqueFEIRType typeElem = nullptr;
+
+  // for C array in struct
+  UniqueFEIRExpr exprStruct;
+  UniqueFEIRType typeStruct;
+  std::string arrayName;
+};
+
+// ---------- FEIRStmtFieldStore ----------
+class FEIRStmtFieldStore : public FEIRStmt {
+ public:
+  FEIRStmtFieldStore(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField, FEStructFieldInfo &argFieldInfo,
+                     bool argIsStatic);
+  FEIRStmtFieldStore(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField, FEStructFieldInfo &argFieldInfo,
+                     bool argIsStatic, int32 argDexFileHashCode);
+  ~FEIRStmtFieldStore() = default;
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  void RegisterDFGNodes2CheckPointForStatic(FEIRStmtCheckPoint &checkPoint);
+  void RegisterDFGNodes2CheckPointForNonStatic(FEIRStmtCheckPoint &checkPoint);
+  bool CalculateDefs4AllUsesForStatic(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain);
+  bool CalculateDefs4AllUsesForNonStatic(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain);
+  bool NeedMCCForStatic(uint32 &typeID) const;
+  std::list<StmtNode*> GenMIRStmtsImplForStatic(MIRBuilder &mirBuilder) const;
+  std::list<StmtNode*> GenMIRStmtsImplForNonStatic(MIRBuilder &mirBuilder) const;
+
+  UniqueFEIRVar varObj;
+  UniqueFEIRVar varField;
+  FEStructFieldInfo &fieldInfo;
+  bool isStatic;
+  int32 dexFileHashCode = -1;
+};
+
+// ---------- FEIRStmtFieldLoad ----------
+class FEIRStmtFieldLoad : public FEIRStmtAssign {
+ public:
+  FEIRStmtFieldLoad(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField, FEStructFieldInfo &argFieldInfo,
+                    bool argIsStatic);
+  FEIRStmtFieldLoad(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField, FEStructFieldInfo &argFieldInfo,
+                    bool argIsStatic, int32 argDexFileHashCode);
+  ~FEIRStmtFieldLoad() = default;
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  void RegisterDFGNodes2CheckPointForStatic(FEIRStmtCheckPoint &checkPoint);
+  void RegisterDFGNodes2CheckPointForNonStatic(FEIRStmtCheckPoint &checkPoint);
+  bool CalculateDefs4AllUsesForStatic(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain);
+  bool CalculateDefs4AllUsesForNonStatic(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain);
+  bool NeedMCCForStatic(uint32 &typeID) const;
+  std::list<StmtNode*> GenMIRStmtsImplForStatic(MIRBuilder &mirBuilder) const;
+  std::list<StmtNode*> GenMIRStmtsImplForNonStatic(MIRBuilder &mirBuilder) const;
+
+  UniqueFEIRVar varObj;
+  FEStructFieldInfo &fieldInfo;
+  bool isStatic;
+  int32 dexFileHashCode = -1;
+};
+
+// ---------- FEIRStmtCallAssign ----------
+class FEIRStmtCallAssign : public FEIRStmtAssign {
+ public:
+  FEIRStmtCallAssign(FEStructMethodInfo &argMethodInfo, Opcode argMIROp, UniqueFEIRVar argVarRet, bool argIsStatic);
+  ~FEIRStmtCallAssign() = default;
+
+  static std::map<Opcode, Opcode> InitMapOpAssignToOp();
+  static std::map<Opcode, Opcode> InitMapOpToOpAssign();
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  std::list<StmtNode*> GenMIRStmtsUseZeroReturn(MIRBuilder &mirBuilder) const;
+
+ private:
+  Opcode AdjustMIROp() const;
+  void InsertNonnullInRetVar(MIRSymbol &retVarSym) const;
+  void InsertNonnullCheckingInArgs(const UniqueFEIRExpr &expr, size_t index, MIRBuilder &mirBuilder,
+                                   std::list<StmtNode*> &ans, const std::string &funcName) const;
+  FEStructMethodInfo &methodInfo;
+  Opcode mirOp;
+  bool isStatic;
+  static std::map<Opcode, Opcode> mapOpAssignToOp;
+  static std::map<Opcode, Opcode> mapOpToOpAssign;
+};
+
+// ---------- FEIRStmtICallAssign ----------
+class FEIRStmtICallAssign : public FEIRStmtAssign {
+ public:
+  FEIRStmtICallAssign();
+  ~FEIRStmtICallAssign() = default;
+
+  void SetPrototype(UniqueFEIRType type) {
+    prototype = std::move(type);
+  }
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
+
+ private:
+  void InsertNonnullCheckingInArgs(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const;
+  void InsertNonnullInRetVar(MIRSymbol &retVarSym) const;
+
+  UniqueFEIRType prototype = nullptr;
+};
+
+// ---------- FEIRStmtIntrinsicCallAssign ----------
+class FEIRStmtIntrinsicCallAssign : public FEIRStmtAssign {
+ public:
+  FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, UniqueFEIRType typeIn, UniqueFEIRVar argVarRet);
+  FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, UniqueFEIRType typeIn, UniqueFEIRVar argVarRet,
+                              std::unique_ptr<std::list<UniqueFEIRExpr>> exprListIn);
+  FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, const std::string &funcNameIn, const std::string &protoIN,
+                              std::unique_ptr<std::list<UniqueFEIRVar>> argsIn);
+  FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, const std::string &funcNameIn, const std::string &protoIN,
+                              std::unique_ptr<std::list<UniqueFEIRVar>> argsIn, uint32 callerClassTypeIDIn,
+                              bool isInStaticFuncIn);
+  FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, UniqueFEIRType typeIn, UniqueFEIRVar argVarRet,
+                              uint32 typeIDIn);
+  ~FEIRStmtIntrinsicCallAssign() = default;
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  void ConstructArgsForInvokePolyMorphic(MIRBuilder &mirBuilder, MapleVector<BaseNode*> &intrnCallargs) const;
+  std::list<StmtNode*> GenMIRStmtsForFillNewArray(MIRBuilder &mirBuilder) const;
+  std::list<StmtNode*> GenMIRStmtsForInvokePolyMorphic(MIRBuilder &mirBuilder) const;
+
+  MIRIntrinsicID intrinsicId;
+  UniqueFEIRType type;
+  std::unique_ptr<std::list<UniqueFEIRExpr>> exprList;
+  // for polymorphic
+  const std::string funcName;
+  const std::string proto;
+  std::unique_ptr<std::list<UniqueFEIRVar>> polyArgs;
+  uint32 typeID = UINT32_MAX;
+  uint32 callerClassTypeID = UINT32_MAX;
+  bool isInStaticFunc = false;
+};
+
+// ---------- FEIRStmtPesudoLOC ----------
+class FEIRStmtPesudoLOC : public FEIRStmt {
+ public:
+  FEIRStmtPesudoLOC(uint32 argSrcFileIdx, uint32 argLineNumber);
+  ~FEIRStmtPesudoLOC() = default;
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+};
+
+// ---------- FEIRStmtPesudoJavaTry ----------
+class FEIRStmtPesudoJavaTry : public FEIRStmt {
+ public:
+  FEIRStmtPesudoJavaTry();
+  ~FEIRStmtPesudoJavaTry() = default;
+  void AddCatchLabelIdx(uint32 labelIdx) {
+    catchLabelIdxVec.push_back(labelIdx);
+  }
+
+  const std::vector<uint32> GetCatchLabelIdxVec() const {
+    return catchLabelIdxVec;
+  }
+
+  void AddCatchTarget(FEIRStmtPesudoLabel &stmtLabel) {
+    catchTargets.push_back(&stmtLabel);
+  }
+
+  const std::vector<FEIRStmtPesudoLabel*> &GetCatchTargets() const {
+    return catchTargets;
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  std::vector<uint32> catchLabelIdxVec;
+  std::vector<FEIRStmtPesudoLabel*> catchTargets;
+};
+
+// ---------- FEIRStmtPesudoJavaTry2 ----------
+class FEIRStmtPesudoJavaTry2 : public FEIRStmt {
+ public:
+  explicit FEIRStmtPesudoJavaTry2(uint32 outerIdxIn);
+  ~FEIRStmtPesudoJavaTry2() = default;
+  void AddCatchLabelIdx(uint32 labelIdx) {
+    catchLabelIdxVec.push_back(labelIdx);
+  }
+
+  const std::vector<uint32> GetCatchLabelIdxVec() const {
+    return catchLabelIdxVec;
+  }
+
+  void AddCatchTarget(FEIRStmtPesudoLabel2 *stmtLabel) {
+    catchTargets.push_back(stmtLabel);
+  }
+
+  const std::vector<FEIRStmtPesudoLabel2*> &GetCatchTargets() const {
+    return catchTargets;
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  uint32 outerIdx;
+  std::vector<uint32> catchLabelIdxVec;
+  std::vector<FEIRStmtPesudoLabel2*> catchTargets;
+};
+
+// ---------- FEIRStmtPesudoEndTry ----------
+class FEIRStmtPesudoEndTry : public FEIRStmt {
+ public:
+  FEIRStmtPesudoEndTry();
+  ~FEIRStmtPesudoEndTry() = default;
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+};
+
+// ---------- FEIRStmtPesudoCatch ----------
+class FEIRStmtPesudoCatch : public FEIRStmtPesudoLabel {
+ public:
+  explicit FEIRStmtPesudoCatch(uint32 argLabelIdx);
+  ~FEIRStmtPesudoCatch() = default;
+  void AddCatchTypeNameIdx(GStrIdx typeNameIdx);
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  std::list<UniqueFEIRType> catchTypes;
+};
+
+// ---------- FEIRStmtPesudoCatch2 ----------
+class FEIRStmtPesudoCatch2 : public FEIRStmtPesudoLabel2 {
+ public:
+  explicit FEIRStmtPesudoCatch2(uint32 qIdx0, uint32 qIdx1);
+  ~FEIRStmtPesudoCatch2() = default;
+  void AddCatchTypeNameIdx(GStrIdx typeNameIdx);
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  std::list<UniqueFEIRType> catchTypes;
+};
+
+class FEIRStmtPesudoSafe : public FEIRStmt {
+ public:
+  explicit FEIRStmtPesudoSafe(bool isEnd);
+  ~FEIRStmtPesudoSafe() = default;
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  bool end = false;
+};
+
+class FEIRStmtPesudoUnsafe : public FEIRStmt {
+ public:
+  explicit FEIRStmtPesudoUnsafe(bool isEnd);
+  ~FEIRStmtPesudoUnsafe() = default;
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  bool end = false;
+};
+
+// ---------- FEIRStmtPesudoComment ----------
+class FEIRStmtPesudoComment : public FEIRStmt {
+ public:
+  explicit FEIRStmtPesudoComment(FEIRNodeKind argKind = kStmtPesudoComment);
+  explicit FEIRStmtPesudoComment(const std::string &argContent);
+  ~FEIRStmtPesudoComment() = default;
+  void SetContent(const std::string &argContent) {
+    content = argContent;
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+  std::string content = "";
+};
+
+// ---------- FEIRStmtPesudoCommentForInst ----------
+class FEIRStmtPesudoCommentForInst : public FEIRStmtPesudoComment {
+ public:
+  FEIRStmtPesudoCommentForInst();
+  ~FEIRStmtPesudoCommentForInst() = default;
+  void SetFileIdx(uint32 argFileIdx) {
+    fileIdx = argFileIdx;
+  }
+
+  void SetLineNum(uint32 argLineNum) {
+    lineNum = argLineNum;
+  }
+
+  void SetPC(uint32 argPC) {
+    pc = argPC;
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  constexpr static uint32 invalid = 0xFFFFFFFF;
+  uint32 fileIdx = invalid;
+  uint32 lineNum = invalid;
+  uint32 pc = invalid;
+};
+
+// ---------- FEIRStmtIf ----------
+class FEIRStmtIf : public FEIRStmt {
+ public:
+  FEIRStmtIf(UniqueFEIRExpr argCondExpr, std::list<UniqueFEIRStmt> &argThenStmts);
+  FEIRStmtIf(UniqueFEIRExpr argCondExpr,
+             std::list<UniqueFEIRStmt> &argThenStmts,
+             std::list<UniqueFEIRStmt> &argElseStmts);
+  ~FEIRStmtIf() = default;
+
+  void SetCondExpr(UniqueFEIRExpr argCondExpr) {
+    CHECK_NULL_FATAL(argCondExpr);
+    condExpr = std::move(argCondExpr);
+  }
+
+  const UniqueFEIRExpr &GetCondExpr() const {
+    return condExpr;
+  }
+
+  void SetHasElse(bool argHasElse) {
+    hasElse = argHasElse;
+  }
+
+  void SetThenStmts(std::list<UniqueFEIRStmt> &stmts) {
+    std::move(begin(stmts), end(stmts), std::inserter(thenStmts, end(thenStmts)));
+  }
+
+  void SetElseStmts(std::list<UniqueFEIRStmt> &stmts) {
+    std::move(begin(stmts), end(stmts), std::inserter(elseStmts, end(elseStmts)));
+  }
+
+  std::list<UniqueFEIRStmt> &GetThenStmt() {
+    return thenStmts;
+  }
+
+  std::list<UniqueFEIRStmt> &GetElseStmt() {
+    return elseStmts;
+  }
+
+ protected:
+  std::string DumpDotStringImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  bool IsFallThroughImpl() const override;
+
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+ private:
+  UniqueFEIRExpr condExpr;
+  bool hasElse = false;
+  std::list<UniqueFEIRStmt> thenStmts;
+  std::list<UniqueFEIRStmt> elseStmts;
+};
+
+class FEIRStmtDoWhile : public FEIRStmt {
+ public:
+  FEIRStmtDoWhile(Opcode argOpcode, UniqueFEIRExpr argCondExpr, std::list<UniqueFEIRStmt> argBodyStmts)
+      : FEIRStmt(FEIRNodeKind::kStmtDoWhile),
+        opcode(argOpcode),
+        condExpr(std::move(argCondExpr)),
+        bodyStmts(std::move(argBodyStmts)) {}
+  ~FEIRStmtDoWhile() = default;
+
+  const std::list<UniqueFEIRStmt> &GetBodyStmts() const {
+    return bodyStmts;
+  }
+
+  const UniqueFEIRExpr &GetCondExpr() const {
+    return condExpr;
+  }
+
+  const Opcode GetOpcode() const {
+    return opcode;
+  }
+
+ protected:
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  bool IsFallThroughImpl() const override;
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  Opcode opcode;
+  UniqueFEIRExpr condExpr;
+  std::list<UniqueFEIRStmt> bodyStmts;
+};
+
+class FEIRStmtBreak : public FEIRStmt {
+ public:
+  FEIRStmtBreak(): FEIRStmt(FEIRNodeKind::kStmtBreak) {}
+  ~FEIRStmtBreak() = default;
+
+  void SetBreakLabelName(std::string name) {
+    breakLabelName = std::move(name);
+  }
+
+ protected:
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  std::string breakLabelName;
+};
+
+class FEIRStmtContinue : public FEIRStmt {
+ public:
+  FEIRStmtContinue(): FEIRStmt(FEIRNodeKind::kStmtContinue) {}
+  ~FEIRStmtContinue() = default;
+
+  void SetLabelName(std::string name) {
+    labelName = std::move(name);
+  }
+
+ protected:
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+ private:
+  std::string labelName;
+};
+
+class FEIRStmtLabel : public FEIRStmt {
+ public:
+  explicit FEIRStmtLabel(const std::string &name) : FEIRStmt(FEIRNodeKind::kStmtLabel), labelName(name) {}
+  ~FEIRStmtLabel() = default;
+
+  const std::string &GetLabelName() const {
+    return labelName;
+  }
+
+ protected:
+  bool IsBranchImpl() const override {
+    return true;
+  }
+
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+
+ private:
+  std::string labelName;
+};
+
+class FEIRStmtAtomic : public FEIRStmt {
+ public:
+  explicit FEIRStmtAtomic(UniqueFEIRExpr expr);
+  ~FEIRStmtAtomic() = default;
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  UniqueFEIRExpr atomicExpr;
+};
+
+class FEIRStmtGCCAsm : public FEIRStmt {
+ public:
+  FEIRStmtGCCAsm(const std::string &str, bool isGotoArg, bool isVolatileArg)
+      : FEIRStmt(FEIRNodeKind::kStmtGCCAsm), asmStr(str), isGoto(isGotoArg), isVolatile(isVolatileArg) {}
+  ~FEIRStmtGCCAsm() = default;
+
+  void SetLabels(const std::vector<std::string> &labelsArg) {
+    labels = labelsArg;
+  }
+
+  void SetClobbers(const std::vector<std::string> &clobbersArg) {
+    clobbers = clobbersArg;
+  }
+
+  void SetInputs(const std::vector<std::pair<std::string, std::string>> &inputsArg) {
+    inputs = inputsArg;
+  }
+
+  void SetInputsExpr(std::vector<UniqueFEIRExpr> &expr) {
+    std::move(begin(expr), end(expr), std::inserter(inputsExprs, end(inputsExprs)));
+  }
+
+  void SetOutputs(const std::vector<std::tuple<std::string, std::string, bool>> &outputsArg) {
+    outputs = outputsArg;
+  }
+
+  void SetOutputsExpr(std::vector<UniqueFEIRExpr> &expr) {
+    std::move(begin(expr), end(expr), std::inserter(outputsExprs, end(outputsExprs)));
+  }
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  bool HandleConstraintPlusQm(MIRBuilder &mirBuilder, AsmNode *asmNode, uint32 index,
+                              std::list<StmtNode*> &stmts, std::list<StmtNode*> &initStmts) const;
+  std::pair<MIRSymbol*, UniqueFEIRVar> HandleGlobalAsmOutOperand(const UniqueFEIRVar &asmOut,
+                                                                 const FieldID fieldID,
+                                                                 std::list<StmtNode*> &stmts,
+                                                                 MIRBuilder &mirBuilder) const;
+  std::pair<MIRSymbol*, UniqueFEIRVar> HandleAsmOutOperandWithPtrType(const FEIRExprIRead *ireadExpr,
+                                                                      std::list<StmtNode*> &stmts,
+                                                                      MIRBuilder &mirBuilder) const;
+
+ private:
+  std::vector<std::tuple<std::string, std::string, bool>> outputs;
+  std::vector<UniqueFEIRExpr> outputsExprs;
+  std::vector<std::pair<std::string, std::string>> inputs;
+  std::vector<UniqueFEIRExpr> inputsExprs;
+  std::vector<std::string> clobbers;
+  std::vector<std::string> labels;
+  std::string asmStr;
+  bool isGoto = false;
+  bool isVolatile = false;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_FEIR_STMT_H
diff --git a/src/hir2mpl/common/include/feir_type.h b/src/hir2mpl/common/include/feir_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..7daf3670c114570076153c7e7068d6e128414015
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_type.h
@@ -0,0 +1,424 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FEIR_TYPE_H
+#define HIR2MPL_INCLUDE_FEIR_TYPE_H
+#include <memory>
+#include <string>
+#include <tuple>
+#include "prim_types.h"
+#include "types_def.h"
+#include "mir_type.h"
+#include "global_tables.h"
+#include "fe_configs.h"
+#include "fe_utils_ast.h"
+
+namespace maple {
+enum FEIRTypeKind {
+  kFEIRTypeDefault,
+  kFEIRTypeByName,
+  kFEIRTypePointer,
+  kFEIRTypeNative
+};
+
+class FEIRType {
+ public:
+  explicit FEIRType(FEIRTypeKind argKind);
+  virtual ~FEIRType() = default;
+  static std::unique_ptr<FEIRType> NewType(FEIRTypeKind argKind = kFEIRTypeDefault);
+  static std::map<MIRSrcLang, std::tuple<bool, PrimType>> InitLangConfig();
+  MIRType *GenerateMIRTypeAuto(MIRSrcLang argSrcLang) const;
+  MIRType *GenerateMIRTypeAuto() const {
+    return GenerateMIRTypeAutoImpl();
+  }
+
+  bool IsSameKind(const FEIRType &type) const {
+    return kind == type.kind;
+  }
+
+  FEIRTypeKind GetKind() const {
+    return kind;
+  }
+
+  PrimType GetPrimType() const {
+    return GetPrimTypeImpl();
+  }
+
+  void SetPrimType(PrimType pt) {
+    SetPrimTypeImpl(pt);
+  }
+
+  MIRSrcLang GetSrcLang() const {
+    return srcLang;
+  }
+
+  bool IsZero() const {
+    return isZero;
+  }
+
+  void SetZero(bool arg) {
+    isZero = arg;
+  }
+
+  void CopyFrom(const FEIRType &type) {
+    return CopyFromImpl(type);
+  }
+
+  std::unique_ptr<FEIRType> Clone() const {
+    return CloneImpl();
+  }
+
+  MIRType *GenerateMIRType(MIRSrcLang argSrcLang, bool usePtr) const {
+    (void)argSrcLang;
+    return GenerateMIRType(usePtr);
+  }
+
+  MIRType *GenerateMIRType() const {
+    return GenerateMIRType(false);
+  }
+
+  bool IsPreciseRefType() const {
+    return IsPrecise() && IsRef();
+  }
+
+  bool IsScalar() const {
+    return IsScalarImpl();
+  }
+
+  bool IsRef() const {
+    return IsRefImpl();
+  }
+
+  bool IsArray() const {
+    return IsArrayImpl();
+  }
+
+  bool IsPrecise() const {
+    return IsPreciseImpl();
+  }
+
+  bool IsValid() const {
+    return IsValidImpl();
+  }
+
+  MIRType *GenerateMIRType(bool usePtr, PrimType ptyPtr = PTY_ref) const {
+    return GenerateMIRTypeImpl(usePtr, ptyPtr);
+  }
+
+  TypeDim ArrayIncrDim(TypeDim delta = 1) {
+    return ArrayIncrDimImpl(delta);
+  }
+
+  TypeDim ArrayDecrDim(TypeDim delta = 1) {
+    return ArrayDecrDimImpl(delta);
+  }
+
+  bool IsEqualTo(const std::unique_ptr<FEIRType> &argType) const {
+    return IsEqualToImpl(argType);
+  }
+
+  bool IsEqualTo(const FEIRType &argType) const {
+    return IsEqualToImpl(argType);
+  }
+
+  uint32 Hash() const {
+    return HashImpl();
+  }
+
+  std::string GetTypeName() const {
+    return GetTypeNameImpl();
+  }
+
+  static std::map<MIRSrcLang, std::tuple<bool, PrimType>> langConfig;
+
+ protected:
+  virtual MIRType *GenerateMIRTypeAutoImpl() const {
+    return GenerateMIRTypeAuto(srcLang);
+  }
+  virtual MIRType *GenerateMIRTypeAutoImpl(MIRSrcLang argSrcLang) const;
+  virtual void CopyFromImpl(const FEIRType &type);
+  virtual std::unique_ptr<FEIRType> CloneImpl() const = 0;
+  virtual MIRType *GenerateMIRTypeImpl(bool usePtr, PrimType ptyPtr) const = 0;
+  virtual bool IsScalarImpl() const = 0;
+  virtual TypeDim ArrayIncrDimImpl(TypeDim delta) = 0;
+  virtual TypeDim ArrayDecrDimImpl(TypeDim delta) = 0;
+  virtual bool IsEqualToImpl(const std::unique_ptr<FEIRType> &argType) const;
+  virtual bool IsEqualToImpl(const FEIRType &argType) const;
+  virtual uint32 HashImpl() const = 0;
+  virtual PrimType GetPrimTypeImpl() const {
+    return PTY_begin;  // Means no valid primtype
+  }
+
+  virtual void SetPrimTypeImpl(PrimType pt) = 0;
+  virtual bool IsRefImpl() const = 0;
+  virtual bool IsArrayImpl() const = 0;
+  virtual bool IsPreciseImpl() const = 0;
+  virtual bool IsValidImpl() const = 0;
+  virtual std::string GetTypeNameImpl() const {
+    return "";
+  }
+
+  FEIRTypeKind kind : 7;
+  bool isZero : 1;
+  MIRSrcLang srcLang : 8;
+};  // class FEIRType
+
+using UniqueFEIRType = std::unique_ptr<FEIRType>;
+
+class FEIRTypeDefault : public FEIRType {
+ public:
+  FEIRTypeDefault();
+  explicit FEIRTypeDefault(PrimType argPrimType);
+  FEIRTypeDefault(PrimType argPrimType, const GStrIdx &argTypeNameIdx);
+  FEIRTypeDefault(PrimType argPrimType, const GStrIdx &argTypeNameIdx, TypeDim argDim);
+  ~FEIRTypeDefault() = default;
+  FEIRTypeDefault(const FEIRTypeDefault&) = delete;
+  FEIRTypeDefault &operator=(const FEIRTypeDefault&) = delete;
+  void LoadFromJavaTypeName(const std::string &typeName, bool inMpl = true);
+  void LoadFromASTTypeName(const std::string &typeName);
+  MIRType *GenerateMIRTypeForPrim() const;
+  FEIRTypeDefault &SetTypeNameIdx(const GStrIdx &argTypeNameIdx) {
+    typeNameIdx = argTypeNameIdx;
+    return *this;
+  }
+
+  FEIRTypeDefault &SetTypeName(const std::string &typeName) {
+    GStrIdx idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+    return SetTypeNameIdx(idx);
+  }
+
+  FEIRTypeDefault &SetTypeNameWithoutCreate(const std::string &typeName) {
+    GStrIdx idx = GlobalTables::GetStrTable().GetStrIdxFromName(typeName);
+    CHECK_FATAL(idx.GetIdx() != 0, "typeNameIdx should be pre-created");
+    return SetTypeNameIdx(idx);
+  }
+
+  GStrIdx GetTypeNameIdx() const {
+    return typeNameIdx;
+  }
+
+  TypeDim GetDim() const {
+    return dim;
+  }
+
+  FEIRTypeDefault &SetDim(TypeDim argDim) {
+    dim = argDim;
+    return *this;
+  }
+
+ LLT_PROTECTED:
+  void CopyFromImpl(const FEIRType &type) override;
+  std::unique_ptr<FEIRType> CloneImpl() const override;
+  MIRType *GenerateMIRTypeImpl(bool usePtr, PrimType ptyPtr) const override;
+  TypeDim ArrayIncrDimImpl(TypeDim delta) override;
+  TypeDim ArrayDecrDimImpl(TypeDim delta) override;
+  bool IsEqualToImpl(const FEIRType &argType) const override;
+  bool IsEqualToImpl(const std::unique_ptr<FEIRType> &argType) const override;
+  uint32 HashImpl() const override;
+  bool IsScalarImpl() const override;
+  PrimType GetPrimTypeImpl() const override;
+  void SetPrimTypeImpl(PrimType pt) override;
+  MIRType *GenerateMIRTypeInternal(const GStrIdx &argTypeNameIdx, bool usePtr) const;
+  MIRType *GenerateMIRTypeInternal(const GStrIdx &argTypeNameIdx, bool usePtr, PrimType ptyPtr) const;
+  std::string GetTypeNameImpl() const override;
+
+  bool IsRefImpl() const override {
+    return dim > 0 || !IsScalarPrimType(primType);
+  }
+
+  bool IsArrayImpl() const override {
+    return dim > 0;
+  }
+
+  bool IsPreciseImpl() const override {
+    return IsScalarPrimType(primType) || typeNameIdx != 0;
+  }
+
+  bool IsValidImpl() const override {
+    return !IsScalarPrimType(primType) || typeNameIdx == 0;
+  }
+
+  static bool IsScalarPrimType(PrimType pty) {
+    return pty != PTY_ref && (IsPrimitiveInteger(pty) || IsPrimitiveFloat(pty) || IsAddress(pty) || pty == PTY_void);
+  }
+
+  PrimType primType;
+  GStrIdx typeNameIdx;
+  TypeDim dim = 0;
+};
+
+// ---------- FEIRTypeByName ----------
+class FEIRTypeByName : public FEIRTypeDefault {
+ public:
+  FEIRTypeByName(PrimType argPrimType, const std::string &argTypeName, TypeDim argDim = 0);
+  ~FEIRTypeByName() = default;
+  FEIRTypeByName(const FEIRTypeByName&) = delete;
+  FEIRTypeByName &operator=(const FEIRTypeByName&) = delete;
+
+ protected:
+  std::unique_ptr<FEIRType> CloneImpl() const override;
+  MIRType *GenerateMIRTypeImpl(bool usePtr, PrimType ptyPtr) const override;
+  bool IsEqualToImpl(const FEIRType &argType) const override;
+  uint32 HashImpl() const override;
+  bool IsScalarImpl() const override;
+  bool IsPreciseImpl() const override {
+    return IsScalarPrimType(primType) || !typeName.empty();
+  }
+
+  bool IsValidImpl() const override {
+    return !IsScalarPrimType(primType) || typeName.empty();
+  }
+
+ private:
+  std::string typeName;
+};
+
+
+// ---------- FEIRTypeNative ----------
+// MIRType is enclosed directly in FEIRTypeNative.
+// Right now, FEIRTypeNative is only used for c-language.
+// Because var type is translated as MIRType directly in stage of ast parse.
+class FEIRTypeNative : public FEIRType {
+ public:
+  explicit FEIRTypeNative(MIRType &argMIRType);
+  ~FEIRTypeNative() = default;
+  FEIRTypeNative(const FEIRTypeNative&) = delete;
+  FEIRTypeNative &operator=(const FEIRTypeNative&) = delete;
+
+ protected:
+  MIRType *GenerateMIRTypeAutoImpl() const override;
+  PrimType GetPrimTypeImpl() const override;
+  void SetPrimTypeImpl(PrimType pt) override;
+  void CopyFromImpl(const FEIRType &type) override;
+  std::unique_ptr<FEIRType> CloneImpl() const override;
+  MIRType *GenerateMIRTypeImpl(bool usePtr, PrimType ptyPtr) const override;
+  bool IsEqualToImpl(const FEIRType &argType) const override;
+  uint32 HashImpl() const override;
+  std::string GetTypeNameImpl() const override;
+  bool IsScalarImpl() const override;
+  bool IsRefImpl() const override;
+  bool IsArrayImpl() const override;
+
+  bool IsPreciseImpl() const override {
+    return true;
+  }
+
+  bool IsValidImpl() const override {
+    return true;
+  }
+
+  TypeDim ArrayIncrDimImpl(TypeDim delta) override;
+  TypeDim ArrayDecrDimImpl(TypeDim delta) override;
+
+ private:
+  MIRType &mirType;
+};
+
+// ---------- FEIRTypePointer ----------
+class FEIRTypePointer : public FEIRType {
+ public:
+  explicit FEIRTypePointer(std::unique_ptr<FEIRType> argBaseType, PrimType argPrimType = PTY_ref);
+  ~FEIRTypePointer() override = default;
+  FEIRTypePointer(const FEIRTypePointer&) = delete;
+  FEIRTypePointer &operator=(const FEIRTypePointer&) = delete;
+  const UniqueFEIRType &GetBaseType() const {
+    return baseType;
+  }
+
+  void SetBaseType(UniqueFEIRType argBaseType) {
+    CHECK_NULL_FATAL(argBaseType);
+    baseType = std::move(argBaseType);
+  }
+
+ protected:
+  std::unique_ptr<FEIRType> CloneImpl() const override;
+  MIRType *GenerateMIRTypeImpl(bool usePtr, PrimType ptyPtr) const override;
+  bool IsEqualToImpl(const FEIRType &argType) const override;
+  uint32 HashImpl() const override;
+  bool IsScalarImpl() const override;
+  TypeDim ArrayIncrDimImpl(TypeDim delta) override;
+  TypeDim ArrayDecrDimImpl(TypeDim delta) override;
+  PrimType GetPrimTypeImpl() const override;
+  void SetPrimTypeImpl(PrimType pt) override;
+  bool IsRefImpl() const override {
+    return true;  // pointer type is ref
+  }
+
+  bool IsArrayImpl() const override {
+    return baseType->IsArray();
+  }
+
+  bool IsPreciseImpl() const override {
+    return baseType->IsPrecise();
+  }
+
+  bool IsValidImpl() const override {
+    return baseType->IsValid();
+  }
+
+ private:
+  PrimType primType;
+  std::unique_ptr<FEIRType> baseType;
+};
+
+// ---------- FEIRTypeKey ----------
+class FEIRTypeKey {
+ public:
+  explicit FEIRTypeKey(const UniqueFEIRType &argType) {
+    ASSERT(argType != nullptr, "nullptr check");
+    type = argType->Clone();
+  }
+
+  explicit FEIRTypeKey(const FEIRTypeKey &key) {
+    ASSERT(key.type != nullptr, "nullptr check");
+    type = key.type->Clone();
+  }
+
+  ~FEIRTypeKey() = default;
+  FEIRTypeKey &operator=(const FEIRTypeKey &key) {
+    if (&key != this) {
+      CHECK_NULL_FATAL(key.type);
+      SetType(key.type->Clone());
+    }
+    return *this;
+  }
+
+  bool operator==(const FEIRTypeKey &key) const {
+    return type->IsEqualTo(key.type);
+  }
+
+  size_t Hash() const {
+    return type->Hash();
+  }
+
+  const UniqueFEIRType &GetType() const {
+    return type;
+  }
+
+  void SetType(UniqueFEIRType argType) {
+    CHECK_NULL_FATAL(argType);
+    type = std::move(argType);
+  }
+
+ private:
+  UniqueFEIRType type;
+};
+
+struct FEIRTypeKeyHash {
+  size_t operator()(const FEIRTypeKey &key) const {
+    return key.Hash();
+  }
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FEIR_TYPE_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/feir_type_helper.h b/src/hir2mpl/common/include/feir_type_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..ded22389501e8199c883cf7a4a6336fe9250d668
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_type_helper.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FEIR_TYPE_HELPER_H
+#define HIR2MPL_INCLUDE_FEIR_TYPE_HELPER_H
+#include <string>
+#include <memory>
+#include "fe_configs.h"
+#include "feir_type.h"
+
+namespace maple {
+class FEIRTypeHelper {
+ public:
+  static UniqueFEIRType CreateTypeByPrimType(PrimType primType, TypeDim dim = 0, bool usePtr = false);
+  static UniqueFEIRType CreateTypeByJavaName(const std::string &typeName, bool inMpl, bool usePtr);
+  static UniqueFEIRType CreatePointerType(UniqueFEIRType baseType, PrimType primType = PTY_ptr);
+  static UniqueFEIRType CreateTypeByDimIncr(const UniqueFEIRType &srcType, uint8 delta, bool usePtr = false,
+                                            PrimType primType = PTY_ptr);
+  static UniqueFEIRType CreateTypeByDimDecr(const UniqueFEIRType &srcType, uint8 delta);
+  static UniqueFEIRType CreateTypeByGetAddress(const UniqueFEIRType &srcType, PrimType primType = PTY_ptr);
+  static UniqueFEIRType CreateTypeByDereferrence(const UniqueFEIRType &srcType);
+  static UniqueFEIRType CreateTypeDefault(PrimType primType, const GStrIdx &typeNameIdx, TypeDim dim);
+  static UniqueFEIRType CreateTypeNative(MIRType &mirType);
+
+ private:
+  FEIRTypeHelper() = default;
+  ~FEIRTypeHelper() = default;
+  static UniqueFEIRType CreateTypeByJavaNamePrim(char primTypeFlag, uint8 dim8);
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FEIR_TYPE_HELPER_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/feir_type_infer.h b/src/hir2mpl/common/include/feir_type_infer.h
new file mode 100644
index 0000000000000000000000000000000000000000..22333623c117bb4135d68339660f3e6329b4c47e
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_type_infer.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FEIR_TYPE_INFER_H
+#define HIR2MPL_INCLUDE_FEIR_TYPE_INFER_H
+#include "fe_configs.h"
+#include "feir_type.h"
+#include "feir_var.h"
+#include "feir_dfg.h"
+
+namespace maple {
+class FEIRTypeMergeHelper {
+ public:
+  FEIRTypeMergeHelper();
+  explicit FEIRTypeMergeHelper(const UniqueFEIRType &argTypeDefault);
+  ~FEIRTypeMergeHelper() = default;
+  void Reset();
+  void ResetTypeDefault(const UniqueFEIRType &argTypeDefault);
+  bool MergeType(const UniqueFEIRType &argType, bool parent = true);
+  UniqueFEIRType GetResult() const;
+  const std::string &GetError() const {
+    return error;
+  }
+
+  const UniqueFEIRType &GetType() const {
+    return type;
+  }
+
+  UniqueFEIRType GetTypeClone() const {
+    return type->Clone();
+  }
+
+ LLT_PRIVATE:
+  UniqueFEIRType typeDefault;
+  UniqueFEIRType type;
+  std::string error;
+  bool firstType;
+  void SetDefaultType(UniqueFEIRType &typeDst);
+  void SetType(UniqueFEIRType &typeDst, const UniqueFEIRType &typeSrc);
+  bool MergeType(UniqueFEIRType &typeDst, const UniqueFEIRType &typeSrc, bool parent = true);
+};
+
+class FEIRTypeInfer {
+ public:
+  FEIRTypeInfer(MIRSrcLang argSrcLang, const FEIRDefUseChain &argMapDefUse);
+  ~FEIRTypeInfer() = default;
+  void LoadTypeDefault();
+  void Reset();
+  UniqueFEIRType GetTypeForVarUse(const UniqueFEIRVar &varUse);
+  UniqueFEIRType GetTypeForVarDef(UniqueFEIRVar &varDef);
+  UniqueFEIRType GetTypeByTransForVarUse(const UniqueFEIRVar &varUse);
+  void ProcessVarDef(UniqueFEIRVar &varDef);
+
+ private:
+  MIRSrcLang srcLang;
+  UniqueFEIRType typeDefault;
+  FEIRTypeMergeHelper mergeHelper;
+  const FEIRDefUseChain &mapDefUse;
+  std::set<const UniqueFEIRVar*> visitVars;
+  bool withCircle = false;
+  bool first = false;
+};
+
+class FEIRTypeCvtHelper {
+ public:
+  static Opcode ChooseCvtOpcodeByFromTypeAndToType(const FEIRType &fromType, const FEIRType &toType);
+
+ private:
+  static bool IsRetypeable(const FEIRType &fromType, const FEIRType &toType);
+  static bool IsIntCvt2Ref(const FEIRType &fromType, const FEIRType &toType);
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FEIR_TYPE_INFER_H
diff --git a/src/hir2mpl/common/include/feir_var.h b/src/hir2mpl/common/include/feir_var.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bcb328e14de2a7163f61006d29aa59edafc35d8
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_var.h
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FEIR_VAR_H
+#define HIR2MPL_INCLUDE_FEIR_VAR_H
+#include <memory>
+#include "mir_type.h"
+#include "mir_symbol.h"
+#include "mir_module.h"
+#include "mir_builder.h"
+#include "feir_type.h"
+#include "fe_utils.h"
+#include "generic_attrs.h"
+
+namespace maple {
+enum FEIRVarTransKind : uint8 {
+  kFEIRVarTransDefault = 0,
+  kFEIRVarTransDirect,
+  kFEIRVarTransArrayDimIncr,
+  kFEIRVarTransArrayDimDecr,
+};
+
+class FEIRVar;
+class FEIRVarTrans {
+ public:
+  FEIRVarTrans(FEIRVarTransKind argKind, std::unique_ptr<FEIRVar> &argVar);
+  FEIRVarTrans(FEIRVarTransKind argKind, std::unique_ptr<FEIRVar> &argVar, uint8 dimDelta);
+  ~FEIRVarTrans() = default;
+  UniqueFEIRType GetType(const UniqueFEIRType &type, PrimType primType = PTY_ref, bool usePtr = true);
+  std::unique_ptr<FEIRVar> &GetVar() const {
+    return var;
+  }
+
+  void SetTransKind(FEIRVarTransKind argKind) {
+    kind = argKind;
+  }
+
+  FEIRVarTransKind GetTransKind() const {
+    return kind;
+  }
+
+ private:
+  FEIRVarTransKind kind;
+  std::unique_ptr<FEIRVar> &var;
+  union {
+    uint8 dimDelta;
+  } param;
+};
+
+using UniqueFEIRVarTrans = std::unique_ptr<FEIRVarTrans>;
+
+enum FEIRVarKind : uint8 {
+  kFEIRVarDefault = 0,
+  kFEIRVarReg,
+  kFEIRVarAccumulator,
+  kFEIRVarName,
+  kFEIRVarTypeScatter,
+};
+
+// forward declaration for smart pointers
+class FEIRExpr;
+class FEIRVar {
+ public:
+  explicit FEIRVar(FEIRVarKind argKind);
+  FEIRVar(FEIRVarKind argKind, std::unique_ptr<FEIRType> argType);
+  virtual ~FEIRVar();
+  void SetType(std::unique_ptr<FEIRType> argType);
+  FEIRVarKind GetKind() const {
+    return kind;
+  }
+
+  bool operator==(const FEIRVar &var) const {
+    return GetNameRaw() == var.GetNameRaw();
+  }
+
+  bool operator!=(const FEIRVar &var) const {
+    return GetNameRaw() != var.GetNameRaw();
+  }
+
+  const UniqueFEIRType &GetType() const {
+    return type;
+  }
+
+  const FEIRType &GetTypeRef() const {
+    ASSERT(type != nullptr, "type is nullptr");
+    return *type.get();
+  }
+
+  bool IsGlobal() const {
+    return isGlobal;
+  }
+
+  void SetGlobal(bool arg) {
+    isGlobal = arg;
+  }
+
+  bool IsDef() const {
+    return isDef;
+  }
+
+  void SetDef(bool arg) {
+    isDef = std::move(arg);
+  }
+
+  void SetTrans(UniqueFEIRVarTrans argTrans) {
+    trans = std::move(argTrans);
+  }
+
+  const UniqueFEIRVarTrans &GetTrans() const {
+    return trans;
+  }
+
+  MIRSymbol *GenerateGlobalMIRSymbol(MIRBuilder &builder) const {
+    MIRSymbol *mirSym = GenerateGlobalMIRSymbolImpl(builder);
+    if (mirSym->GetSrcPosition().LineNum() == 0) {
+      mirSym->SetSrcPosition(FEUtils::CvtLoc2SrcPosition(loc));
+    }
+    return mirSym;
+  }
+
+  MIRSymbol *GenerateLocalMIRSymbol(MIRBuilder &builder) const {
+    MIRSymbol *mirSym = GenerateLocalMIRSymbolImpl(builder);
+    if (mirSym->GetSrcPosition().LineNum() == 0) {
+      mirSym->SetSrcPosition(FEUtils::CvtLoc2SrcPosition(loc));
+    }
+    return mirSym;
+  }
+
+  MIRSymbol *GenerateMIRSymbol(MIRBuilder &builder) const {
+    return GenerateMIRSymbolImpl(builder);
+  }
+
+  std::string GetName(const MIRType &mirType) const {
+    return GetNameImpl(mirType);
+  }
+
+  std::string GetNameRaw() const {
+    return GetNameRawImpl();
+  }
+
+  bool EqualsTo(const std::unique_ptr<FEIRVar> &var) const {
+    return EqualsToImpl(var);
+  }
+
+  uint32 Hash() const {
+    return HashImpl();
+  }
+
+  void SetAttrs(const GenericAttrs &argGenericAttrs) {
+    genAttrs = argGenericAttrs;
+  }
+
+  void SetSectionAttr(const std::string &str) {
+    sectionAttr = str;
+  }
+
+  void SetSrcLoc(const Loc &l) {
+    loc = l;
+  }
+
+  Loc GetSrcLoc() const {
+    return loc;
+  }
+
+  uint32 GetSrcFileIdx() const {
+    return loc.fileIdx;
+  }
+
+  uint32 GetSrcFileLineNum() const {
+    return loc.line;
+  }
+
+  std::unique_ptr<FEIRVar> Clone() const;
+  void SetBoundaryLenExpr(std::unique_ptr<FEIRExpr> expr);
+  const std::unique_ptr<FEIRExpr> &GetBoundaryLenExpr() const;
+
+ protected:
+  virtual MIRSymbol *GenerateGlobalMIRSymbolImpl(MIRBuilder &builder) const;
+  virtual MIRSymbol *GenerateLocalMIRSymbolImpl(MIRBuilder &builder) const;
+  virtual MIRSymbol *GenerateMIRSymbolImpl(MIRBuilder &builder) const;
+  virtual std::string GetNameImpl(const MIRType &mirType) const = 0;
+  virtual std::string GetNameRawImpl() const = 0;
+  virtual std::unique_ptr<FEIRVar> CloneImpl() const = 0;
+  virtual bool EqualsToImpl(const std::unique_ptr<FEIRVar> &var) const = 0;
+  virtual uint32 HashImpl() const = 0;
+
+  FEIRVarKind kind : 6;
+  bool isGlobal : 1;
+  bool isDef : 1;
+  UniqueFEIRType type;
+  UniqueFEIRVarTrans trans;
+  GenericAttrs genAttrs;
+  Loc loc = {0, 0, 0};
+  std::string sectionAttr;
+  std::unique_ptr<FEIRExpr> boundaryLenExpr;
+};
+
+using UniqueFEIRVar = std::unique_ptr<FEIRVar>;
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FEIR_VAR_H
diff --git a/src/hir2mpl/common/include/feir_var_name.h b/src/hir2mpl/common/include/feir_var_name.h
new file mode 100644
index 0000000000000000000000000000000000000000..713ec5603470998548b51bc4611e33a2afd8f127
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_var_name.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FEIR_VAR_NAME_H
+#define HIR2MPL_INCLUDE_FEIR_VAR_NAME_H
+#include <string>
+#include "mir_symbol.h"
+#include "types_def.h"
+#include "global_tables.h"
+#include "feir_var.h"
+
+namespace maple {
+// ---------- FEIRVarName ----------
+class FEIRVarName : public FEIRVar {
+ public:
+  explicit FEIRVarName(const GStrIdx &argNameIdx, bool argWithType = false)
+      : FEIRVar(FEIRVarKind::kFEIRVarName),
+        nameIdx(argNameIdx),
+        withType(argWithType) {}
+
+  FEIRVarName(const GStrIdx &argNameIdx, std::unique_ptr<FEIRType> argType, bool argWithType = false)
+      : FEIRVar(FEIRVarKind::kFEIRVarName, std::move(argType)),
+        nameIdx(argNameIdx),
+        withType(argWithType) {}
+
+  FEIRVarName(const std::string &argName, std::unique_ptr<FEIRType> argType, bool argWithType = false)
+      : FEIRVarName(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(argName), std::move(argType), argWithType) {}
+
+  virtual ~FEIRVarName() = default;
+
+ protected:
+  std::string GetNameImpl(const MIRType &mirType) const override;
+  std::string GetNameRawImpl() const override;
+  std::unique_ptr<FEIRVar> CloneImpl() const override;
+  bool EqualsToImpl(const std::unique_ptr<FEIRVar> &var) const override;
+  uint32 HashImpl() const override;
+
+  GStrIdx nameIdx;
+  // means emit this symbol with type
+  bool withType : 1;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FEIR_VAR_REG_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/feir_var_reg.h b/src/hir2mpl/common/include/feir_var_reg.h
new file mode 100644
index 0000000000000000000000000000000000000000..a37fdfbdc78a2dfe64c840ef1fe5eb229f9f41c5
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_var_reg.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FEIR_VAR_REG_H
+#define HIR2MPL_INCLUDE_FEIR_VAR_REG_H
+#include "mir_symbol.h"
+#include "feir_var.h"
+
+namespace maple {
+class FEIRVarReg : public FEIRVar {
+ public:
+  explicit FEIRVarReg(uint32 argRegNum, FEIRVarKind kind = FEIRVarKind::kFEIRVarReg)
+      : FEIRVar(kind),
+        regNum(argRegNum) {}
+
+  FEIRVarReg(uint32 argRegNum, PrimType argPrimType)
+      : FEIRVarReg(argRegNum) {
+    type->SetPrimType(argPrimType);
+  }
+
+  FEIRVarReg(uint32 argRegNum, std::unique_ptr<FEIRType> argType, FEIRVarKind kind = FEIRVarKind::kFEIRVarReg)
+      : FEIRVar(kind, std::move(argType)),
+        regNum(argRegNum) {}
+
+  ~FEIRVarReg() = default;
+  uint32 GetRegNum() const {
+    return regNum;
+  }
+
+ protected:
+  std::string GetNameImpl(const MIRType &mirType) const override;
+  std::string GetNameRawImpl() const override;
+  MIRSymbol *GenerateLocalMIRSymbolImpl(MIRBuilder &builder) const override;
+  std::unique_ptr<FEIRVar> CloneImpl() const override;
+  bool EqualsToImpl(const std::unique_ptr<FEIRVar> &var) const override;
+  uint32 HashImpl() const override;
+  uint32 regNum;
+};
+
+class FEIRVarAccumulator : public FEIRVarReg {
+ public:
+  explicit FEIRVarAccumulator(uint32 argRegNum)
+      : FEIRVarReg(argRegNum, FEIRVarKind::kFEIRVarAccumulator) {}
+
+  FEIRVarAccumulator(uint32 argRegNum, PrimType argPrimType)
+      : FEIRVarAccumulator(argRegNum) {
+    type->SetPrimType(argPrimType);
+  }
+
+  FEIRVarAccumulator(uint32 argRegNum, std::unique_ptr<FEIRType> argType)
+      : FEIRVarReg(argRegNum, std::move(argType), FEIRVarKind::kFEIRVarAccumulator) {}
+
+  ~FEIRVarAccumulator() = default;
+
+ protected:
+  std::string GetNameImpl(const MIRType &mirType) const override;
+  std::string GetNameRawImpl() const override;
+  std::unique_ptr<FEIRVar> CloneImpl() const override;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FEIR_VAR_REG_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/feir_var_type_scatter.h b/src/hir2mpl/common/include/feir_var_type_scatter.h
new file mode 100644
index 0000000000000000000000000000000000000000..d23a717015f7da2dd553f666fd5bc2490b938a6e
--- /dev/null
+++ b/src/hir2mpl/common/include/feir_var_type_scatter.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef FEIR_VAR_TYPE_SCATTER_H
+#define FEIR_VAR_TYPE_SCATTER_H
+#include <unordered_set>
+#include "feir_var.h"
+#include "feir_type.h"
+
+namespace maple {
+class FEIRVarTypeScatter : public FEIRVar {
+ public:
+  explicit FEIRVarTypeScatter(UniqueFEIRVar argVar);
+  ~FEIRVarTypeScatter() = default;
+  void AddScatterType(const UniqueFEIRType &type);
+  const std::unordered_set<FEIRTypeKey, FEIRTypeKeyHash> &GetScatterTypes() const {
+    return scatterTypes;
+  }
+
+  const UniqueFEIRVar &GetVar() const {
+    return var;
+  }
+
+ protected:
+  MIRSymbol *GenerateGlobalMIRSymbolImpl(MIRBuilder &builder) const override;
+  MIRSymbol *GenerateLocalMIRSymbolImpl(MIRBuilder &builder) const override;
+  MIRSymbol *GenerateMIRSymbolImpl(MIRBuilder &builder) const override;
+  std::string GetNameImpl(const MIRType &mirType) const override;
+  std::string GetNameRawImpl() const override;
+  std::unique_ptr<FEIRVar> CloneImpl() const override;
+  bool EqualsToImpl(const std::unique_ptr<FEIRVar> &argVar) const override;
+  uint32 HashImpl() const override;
+
+ private:
+  UniqueFEIRVar var;
+  std::unordered_set<FEIRTypeKey, FEIRTypeKeyHash> scatterTypes;
+};  // class FEIRVarTypeScatter
+}  // namespace maple
+#endif // FEIR_VAR_TYPE_SCATTER_H
diff --git a/src/hir2mpl/common/include/generic_attrs.h b/src/hir2mpl/common/include/generic_attrs.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b7406d30dd1516e305de461292c3369d429bb86
--- /dev/null
+++ b/src/hir2mpl/common/include/generic_attrs.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef GENERIC_ATTRS_H
+#define GENERIC_ATTRS_H
+#include <bitset>
+#include <variant>
+#include "mir_type.h"
+
+namespace maple {
+using AttrContent = std::variant<int, GStrIdx>;
+// only for internal use, not emitted
+enum GenericAttrKind {
+#define FUNC_ATTR
+#define TYPE_ATTR
+#define FIELD_ATTR
+#define ATTR(STR) GENATTR_##STR,
+#include "all_attributes.def"
+#undef ATTR
+#undef FUNC_ATTR
+#undef TYPE_ATTR
+#undef FIELD_ATTR
+};
+constexpr uint32 kMaxATTRNum = 128;
+
+class GenericAttrs {
+ public:
+  GenericAttrs() = default;
+  GenericAttrs(const GenericAttrs &ta) = default;
+  GenericAttrs &operator=(const GenericAttrs &p) = default;
+  ~GenericAttrs() = default;
+
+  void SetAttr(GenericAttrKind x) {
+    attrFlag.set(x);
+  }
+
+  void ResetAttr(GenericAttrKind x) {
+    attrFlag.reset(x);
+  }
+
+  bool GetAttr(GenericAttrKind x) const {
+    return attrFlag[x];
+  }
+
+  bool operator==(const GenericAttrs &tA) const {
+    return attrFlag == tA.attrFlag;
+  }
+
+  bool operator!=(const GenericAttrs &tA) const {
+    return !(*this == tA);
+  }
+
+  void InitContentMap() {
+    contentMap.resize(kMaxATTRNum);
+    isInit = true;
+  }
+
+  bool GetContentFlag(GenericAttrKind key) const {
+    return contentFlag[key];
+  }
+
+  void InsertIntContentMap(GenericAttrKind key, int val) {
+    if (!isInit) {
+      InitContentMap();
+    }
+    if (!contentFlag[key]) {
+      contentMap[key] = val;
+      contentFlag.set(key);
+    }
+  }
+
+  void InsertStrIdxContentMap(GenericAttrKind key, GStrIdx nameIdx) {
+    if (!isInit) {
+      InitContentMap();
+    }
+    if (!contentFlag[key]) {
+      contentMap[key] = nameIdx;
+      contentFlag.set(key);
+    }
+  }
+
+  void ClearContentMap() {
+    contentMap.clear();
+    contentMap.shrink_to_fit();
+  }
+
+  FieldAttrs ConvertToFieldAttrs();
+  TypeAttrs ConvertToTypeAttrs() const;
+  FuncAttrs ConvertToFuncAttrs();
+
+ private:
+  std::bitset<kMaxATTRNum> attrFlag = 0;
+  std::bitset<kMaxATTRNum> contentFlag = 0;
+  std::vector<AttrContent> contentMap;
+  bool isInit = false;
+};
+}
+#endif // GENERIC_ATTRS_H
\ No newline at end of file
diff --git a/src/hir2mpl/common/include/hir2mpl_compiler.h b/src/hir2mpl/common/include/hir2mpl_compiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..423e67f82d95349ed2e18fb1ac23ad05f0010c1a
--- /dev/null
+++ b/src/hir2mpl/common/include/hir2mpl_compiler.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_HIR2MPL_COMPILER_NEW_H
+#define HIR2MPL_INCLUDE_COMMON_HIR2MPL_COMPILER_NEW_H
+#include <memory>
+#include <list>
+#include "fe_macros.h"
+#include "hir2mpl_compiler_component.h"
+#include "mpl_logging.h"
+#include "hir2mpl_options.h"
+#include "jbc_compiler_component.h"
+#include "fe_options.h"
+#include "bc_compiler_component.h"
+#include "ark_annotation_processor.h"
+#include "dex_reader.h"
+#include "ast_compiler_component.h"
+#include "ast_compiler_component-inl.h"
+#include "ast_parser.h"
+#ifdef ENABLE_MAST
+#include "maple_ast_parser.h"
+#endif
+#include "hir2mpl_env.h"
+#include "fe_manager.h"
+#include "fe_type_hierarchy.h"
+
+namespace maple {
+class HIR2MPLCompiler {
+ public:
+  explicit HIR2MPLCompiler(MIRModule &argModule);
+  ~HIR2MPLCompiler();
+  // common process
+  int Run();
+  void Init();
+  void Release();
+  void CheckInput();
+  void SetupOutputPathAndName();
+  bool LoadMplt();
+  void ExportMpltFile();
+  void ExportMplFile();
+
+  // component process
+  void RegisterCompilerComponent(std::unique_ptr<HIR2MPLCompilerComponent> comp);
+  void ParseInputs();
+  void LoadOnDemandTypes();
+  void PreProcessDecls();
+  void ProcessDecls();
+  void ProcessPragmas();
+  void ProcessFunctions();
+
+ private:
+  void RegisterCompilerComponent();
+  inline void InsertImportInMpl(const std::list<std::string> &mplt) const;
+  void FindMinCompileFailedFEFunctions();
+  MIRModule &module;
+  MIRSrcLang srcLang;
+  MemPool *mp;
+  MapleAllocator allocator;
+  std::string firstInputName;
+  std::string outputPath;
+  std::string outputName;
+  std::string outNameWithoutType;
+  std::list<std::unique_ptr<HIR2MPLCompilerComponent>> components;
+  std::set<FEFunction*> compileFailedFEFunctions;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_HIR2MPL_COMPILER_NEW_H
diff --git a/src/hir2mpl/common/include/hir2mpl_compiler_component.h b/src/hir2mpl/common/include/hir2mpl_compiler_component.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e9040f0995b45669455bf44dad327450090daca
--- /dev/null
+++ b/src/hir2mpl/common/include/hir2mpl_compiler_component.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_HIR2MPL_COMPILER_COMPONENT_H
+#define HIR2MPL_INCLUDE_COMMON_HIR2MPL_COMPILER_COMPONENT_H
+#include <list>
+#include <memory>
+#include "mir_module.h"
+#include "fe_function.h"
+#include "fe_input.h"
+#include "fe_input_helper.h"
+#include "mpl_scheduler.h"
+
+namespace maple {
+class FEFunctionProcessTask : public MplTask {
+ public:
+  explicit FEFunctionProcessTask(std::unique_ptr<FEFunction> argFunction);
+  virtual ~FEFunctionProcessTask() = default;
+
+ protected:
+  int RunImpl(MplTaskParam *param) override;
+  int FinishImpl(MplTaskParam *param) override;
+
+ private:
+  std::unique_ptr<FEFunction> function;
+};
+
+class FEFunctionProcessSchedular : public MplScheduler {
+ public:
+  explicit FEFunctionProcessSchedular(const std::string &name)
+      : MplScheduler(name) {}
+  virtual ~FEFunctionProcessSchedular() = default;
+  void AddFunctionProcessTask(std::unique_ptr<FEFunction> function);
+  void SetDumpTime(bool arg) {
+    dumpTime = arg;
+  }
+
+ protected:
+  void CallbackThreadMainStart() override;
+
+ private:
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+};
+
+class HIR2MPLCompilerComponent {
+ public:
+  HIR2MPLCompilerComponent(MIRModule &argModule, MIRSrcLang argSrcLang);
+  virtual ~HIR2MPLCompilerComponent() = default;
+  bool ParseInput() {
+    return ParseInputImpl();
+  }
+
+  bool LoadOnDemandType() {
+    return LoadOnDemandTypeImpl();
+  }
+
+  bool PreProcessDecl() {
+    return PreProcessDeclImpl();
+  }
+
+  bool ProcessDecl() {
+    return ProcessDeclImpl();
+  }
+
+  void ProcessPragma() {
+    ProcessPragmaImpl();
+  }
+
+  std::unique_ptr<FEFunction> CreatFEFunction(FEInputMethodHelper *methodHelper) {
+    return CreatFEFunctionImpl(methodHelper);
+  }
+
+  bool ProcessFunctionSerial() {
+    return ProcessFunctionSerialImpl();
+  }
+
+  bool ProcessFunctionParallel(uint32 nthreads) {
+    return ProcessFunctionParallelImpl(nthreads);
+  }
+
+  std::string GetComponentName() const {
+    return GetComponentNameImpl();
+  }
+
+  bool Parallelable() const {
+    return ParallelableImpl();
+  }
+
+  void DumpPhaseTimeTotal() const {
+    DumpPhaseTimeTotalImpl();
+  }
+
+  uint32 GetFunctionsSize() const {
+    return funcSize;
+  }
+
+  const std::set<FEFunction*> &GetCompileFailedFEFunctions() const {
+    return compileFailedFEFunctions;
+  }
+
+  void ReleaseMemPool() {
+    ReleaseMemPoolImpl();
+  }
+
+ protected:
+  virtual bool ParseInputImpl() = 0;
+  virtual bool LoadOnDemandTypeImpl();
+  virtual bool PreProcessDeclImpl();
+  virtual bool ProcessDeclImpl();
+  virtual void ProcessPragmaImpl() {};
+  virtual std::unique_ptr<FEFunction> CreatFEFunctionImpl(FEInputMethodHelper *methodHelper) = 0;
+  virtual bool ProcessFunctionSerialImpl();
+  virtual bool ProcessFunctionParallelImpl(uint32 nthreads);
+  virtual std::string GetComponentNameImpl() const;
+  virtual bool ParallelableImpl() const;
+  virtual void DumpPhaseTimeTotalImpl() const;
+  virtual void ReleaseMemPoolImpl() = 0;
+
+  uint32 funcSize;
+  MIRModule &module;
+  MIRSrcLang srcLang;
+  std::list<std::unique_ptr<FEInputFieldHelper>> fieldHelpers;
+  std::list<std::unique_ptr<FEInputMethodHelper>> methodHelpers;
+  std::list<FEInputStructHelper*> structHelpers;
+  std::list<FEInputMethodHelper*> globalFuncHelpers;
+  std::list<FEInputGlobalVarHelper*> globalVarHelpers;
+  std::list<FEInputFileScopeAsmHelper*> globalFileScopeAsmHelpers;
+  std::list<FEInputEnumHelper*> enumHelpers;
+  std::unique_ptr<FEFunctionPhaseResult> phaseResultTotal;
+  std::set<FEFunction*> compileFailedFEFunctions;
+};
+}  // namespace maple
+#endif
diff --git a/src/hir2mpl/common/include/hir2mpl_env.h b/src/hir2mpl/common/include/hir2mpl_env.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d5069893c32407952ad03baaa712c68c82f282e
--- /dev/null
+++ b/src/hir2mpl/common/include/hir2mpl_env.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_HIR2MPL_ENV_H
+#define HIR2MPL_INCLUDE_COMMON_HIR2MPL_ENV_H
+#include <fstream>
+#include <string>
+#include <map>
+#include "mir_module.h"
+
+namespace maple {
+class HIR2MPLEnv {
+ public:
+  void Init();
+  void Finish();
+  uint32 NewSrcFileIdx(const GStrIdx &nameIdx);
+  GStrIdx GetFileNameIdx(uint32 fileIdx) const;
+  std::string GetFileName(uint32 fileIdx) const;
+  static HIR2MPLEnv &GetInstance() {
+    return instance;
+  }
+
+  uint32 GetGlobalLabelIdx() const {
+    return globalLabelIdx;
+  }
+
+  void IncrGlobalLabelIdx() {
+    globalLabelIdx++;
+  }
+
+ private:
+  static HIR2MPLEnv instance;
+  std::map<uint32, GStrIdx> srcFileIdxNameMap;
+  uint32 globalLabelIdx = GStrIdx(0);
+  HIR2MPLEnv() = default;
+  ~HIR2MPLEnv() = default;
+};  // class HIR2MPLEnv
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_HIR2MPL_ENV_H
diff --git a/src/hir2mpl/common/include/hir2mpl_option.h b/src/hir2mpl/common/include/hir2mpl_option.h
new file mode 100644
index 0000000000000000000000000000000000000000..80d8c3995b50b6a37576ba948ed97c40b3ef96d4
--- /dev/null
+++ b/src/hir2mpl/common/include/hir2mpl_option.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef HIR2MPL_COMMON_INCLUDE_HIR2MPL_OPTION_H
+#define HIR2MPL_COMMON_INCLUDE_HIR2MPL_OPTION_H
+
+#include "driver_options.h"
+
+namespace opts::hir2mpl {
+extern maplecl::Option<bool> help;
+extern maplecl::Option<bool> version;
+extern maplecl::Option<std::string> mpltSys;
+extern maplecl::Option<std::string> mpltApk;
+extern maplecl::Option<std::string> mplt;
+extern maplecl::Option<std::string> inClass;
+extern maplecl::Option<std::string> inJar;
+extern maplecl::Option<std::string> inDex;
+extern maplecl::Option<std::string> inAst;
+extern maplecl::Option<std::string> inMast;
+extern maplecl::Option<std::string> output;
+extern maplecl::Option<std::string> outputName;
+extern maplecl::Option<bool> mpltOnly;
+extern maplecl::Option<bool> asciimplt;
+extern maplecl::Option<bool> dumpInstComment;
+extern maplecl::Option<bool> noMplFile;
+extern maplecl::Option<uint32_t> dumpLevel;
+extern maplecl::Option<bool> dumpTime;
+extern maplecl::Option<bool> dumpComment;
+extern maplecl::Option<bool> dumpLOC;
+extern maplecl::Option<bool> dbgFriendly;
+extern maplecl::Option<bool> dumpPhaseTime;
+extern maplecl::Option<bool> dumpPhaseTimeDetail;
+extern maplecl::Option<bool> rc;
+extern maplecl::Option<bool> nobarrier;
+extern maplecl::Option<bool> usesignedchar;
+extern maplecl::Option<bool> o2;
+extern maplecl::Option<bool> simplifyShortCircuit;
+extern maplecl::Option<bool> enableVariableArray;
+extern maplecl::Option<uint32_t> funcInliceSize;
+extern maplecl::Option<uint32_t> np;
+extern maplecl::Option<bool> dumpThreadTime;
+extern maplecl::Option<std::string> xbootclasspath;
+extern maplecl::Option<std::string> classloadercontext;
+extern maplecl::Option<std::string> dep;
+extern maplecl::Option<std::string> depsamename;
+extern maplecl::Option<bool> npeCheckDynamic;
+extern maplecl::Option<bool> boundaryCheckDynamic;
+extern maplecl::Option<bool> safeRegion;
+extern maplecl::Option<bool> defaultSafe;
+extern maplecl::Option<bool> dumpFEIRBB;
+extern maplecl::Option<std::string> dumpFEIRCFGGraph;
+extern maplecl::Option<bool> wpaa;
+extern maplecl::Option<bool> debug;
+
+}
+
+#endif /* HIR2MPL_COMMON_INCLUDE_HIR2MPL_OPTION_H */
diff --git a/src/hir2mpl/common/include/hir2mpl_options.h b/src/hir2mpl/common/include/hir2mpl_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..fcc4b4b78df8d68df9850464397f8da387a1647e
--- /dev/null
+++ b/src/hir2mpl/common/include/hir2mpl_options.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_COMMON_HIR2MPL_OPTIONS_H
+#define HIR2MPL_INCLUDE_COMMON_HIR2MPL_OPTIONS_H
+#include <string>
+#include <list>
+#include "factory.h"
+#include "hir2mpl_option.h"
+#include "parser_opt.h"
+#include "types_def.h"
+
+namespace maple {
+class HIR2MPLOptions {
+ public:
+  static inline HIR2MPLOptions &GetInstance() {
+    static HIR2MPLOptions options;
+    return options;
+  }
+  void Init() const;
+  static bool InitFactory();
+  bool SolveOptions(bool isDebug);
+  bool SolveArgs(int argc, char **argv);
+  void DumpUsage() const;
+  void DumpVersion() const;
+  template <typename Out>
+  static void Split(const std::string &s, char delim, Out result);
+  static std::list<std::string> SplitByComma(const std::string &s);
+
+  // non-option process
+  void ProcessInputFiles(const std::vector<std::string> &inputs) const;
+
+ private:
+  template <typename T>
+  using OptionProcessFactory = FunctionFactory<maplecl::OptionInterface *, bool, HIR2MPLOptions*, const T &>;
+  using OptionFactory = OptionProcessFactory<maplecl::OptionInterface>;
+
+  HIR2MPLOptions();
+  ~HIR2MPLOptions() = default;
+
+  // option process
+  bool ProcessHelp(const maplecl::OptionInterface &) const;
+  bool ProcessVersion(const maplecl::OptionInterface &) const;
+
+  // input control options
+  bool ProcessInClass(const maplecl::OptionInterface &mpltSys) const;
+  bool ProcessInJar(const maplecl::OptionInterface &mpltApk) const;
+  bool ProcessInDex(const maplecl::OptionInterface &inDex) const;
+  bool ProcessInAST(const maplecl::OptionInterface &inAst) const;
+  bool ProcessInMAST(const maplecl::OptionInterface &inMast) const;
+  bool ProcessInputMplt(const maplecl::OptionInterface &mplt) const;
+  bool ProcessInputMpltFromSys(const maplecl::OptionInterface &mpltSys) const;
+  bool ProcessInputMpltFromApk(const maplecl::OptionInterface &mpltApk) const;
+
+  // output control options
+  bool ProcessOutputPath(const maplecl::OptionInterface &output) const;
+  bool ProcessOutputName(const maplecl::OptionInterface &outputName) const;
+  bool ProcessGenMpltOnly(const maplecl::OptionInterface &) const;
+  bool ProcessGenAsciiMplt(const maplecl::OptionInterface &) const;
+  bool ProcessDumpInstComment(const maplecl::OptionInterface &) const;
+  bool ProcessNoMplFile(const maplecl::OptionInterface &) const;
+
+  // debug info control options
+  bool ProcessDumpLevel(const maplecl::OptionInterface &outputName) const;
+  bool ProcessDumpTime(const maplecl::OptionInterface &) const;
+  bool ProcessDumpComment(const maplecl::OptionInterface &) const;
+  bool ProcessDumpLOC(const maplecl::OptionInterface &) const;
+  bool ProcessDbgFriendly(const maplecl::OptionInterface &) const;
+  bool ProcessDumpPhaseTime(const maplecl::OptionInterface &) const;
+  bool ProcessDumpPhaseTimeDetail(const maplecl::OptionInterface &) const;
+
+  // java compiler options
+  bool ProcessModeForJavaStaticFieldName(const maplecl::OptionInterface &opt) const;
+  bool ProcessJBCInfoUsePathName(const maplecl::OptionInterface &) const;
+  bool ProcessDumpJBCStmt(const maplecl::OptionInterface &) const;
+  bool ProcessDumpJBCAll(const maplecl::OptionInterface &) const;
+  bool ProcessDumpJBCErrorOnly(const maplecl::OptionInterface &) const;
+  bool ProcessDumpJBCFuncName(const maplecl::OptionInterface &opt) const;
+  bool ProcessEmitJBCLocalVarInfo(const maplecl::OptionInterface &) const;
+
+  // bc compiler options
+  bool ProcessRC(const maplecl::OptionInterface &) const;
+  bool ProcessNoBarrier(const maplecl::OptionInterface &) const;
+  bool ProcessO2(const maplecl::OptionInterface &) const;
+  bool ProcessSimplifyShortCircuit(const maplecl::OptionInterface &) const;
+  bool ProcessEnableVariableArray(const maplecl::OptionInterface &) const;
+  bool ProcessFuncInlineSize(const maplecl::OptionInterface &funcInliceSize) const;
+  bool ProcessWPAA(const maplecl::OptionInterface &) const;
+
+  // ast compiler options
+  bool ProcessUseSignedChar(const maplecl::OptionInterface &) const;
+  bool ProcessBigEndian() const;
+
+  // general stmt/bb/cfg options
+  bool ProcessDumpFEIRBB(const maplecl::OptionInterface &) const;
+  bool ProcessDumpFEIRCFGGraph(const maplecl::OptionInterface &opt) const;
+
+  // multi-thread control options
+  bool ProcessNThreads(const maplecl::OptionInterface &numThreads) const;
+  bool ProcessDumpThreadTime(const maplecl::OptionInterface &) const;
+
+  // On Demand Type Creation
+  bool ProcessXbootclasspath(const maplecl::OptionInterface &xbootclasspath) const;
+  bool ProcessClassLoaderContext(const maplecl::OptionInterface &classloadercontext) const;
+  bool ProcessCollectDepTypes(const maplecl::OptionInterface &dep) const;
+  bool ProcessDepSameNamePolicy(const maplecl::OptionInterface &depsamename) const;
+
+  // EnhanceC
+  bool ProcessNpeCheckDynamic(const maplecl::OptionInterface &) const;
+  bool ProcessBoundaryCheckDynamic(const maplecl::OptionInterface &) const;
+  bool ProcessSafeRegion(const maplecl::OptionInterface &) const;
+  bool ProcessDefaultSafe(const maplecl::OptionInterface &) const;
+
+  // symbol resolve
+  bool ProcessAOT(const maplecl::OptionInterface &) const;
+};  // class HIR2MPLOptions
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_COMMON_HIR2MPL_OPTIONS_H
diff --git a/src/hir2mpl/common/include/simple_xml.h b/src/hir2mpl/common/include/simple_xml.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e07b9baf450d0c5c0879d9d706ce4048b3272d1
--- /dev/null
+++ b/src/hir2mpl/common/include/simple_xml.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_SIMPLE_XML_H
+#define HIR2MPL_INCLUDE_SIMPLE_XML_H
+#include <string>
+#include <ios>
+#include <iostream>
+#include "types_def.h"
+#include "mempool_allocator.h"
+#include "maple_string.h"
+
+namespace maple {
+enum SimpleXMLElemIdTag {
+  kXMLIDNone,
+  kXMLID,
+};
+
+enum SimpleXMLElemValueTag {
+  kXMLValueNone,
+  kXMLValueI8,
+  kXMLValueU8,
+  kXMLValueI16,
+  kXMLValueU16,
+  kXMLValueI32,
+  kXMLValueU32,
+  kXMLValueI64,
+  kXMLValueU64,
+  kXMLValueFloat,
+  kXMLValueDouble,
+  kXMLValueString,
+};
+
+class SimpleXMLElem {
+ public:
+  SimpleXMLElem(MapleAllocator &alloc, const std::string &cat);
+  SimpleXMLElem(MapleAllocator &alloc, const std::string &cat, uint32 argID);
+  virtual ~SimpleXMLElem() = default;
+  void AddElement(SimpleXMLElem &elem);
+  SimpleXMLElem *AddNewElement(const std::string &cat);
+  SimpleXMLElem *AddNewElement(const std::string &cat, uint32 argID);
+  void SetValue(int8 v);
+  void SetValue(uint8 v);
+  void SetValue(int16 v);
+  void SetValue(uint16 v);
+  void SetValue(int32 v);
+  void SetValue(uint32 v);
+  void SetValue(int64 v);
+  void SetValue(uint64 v);
+  void SetValue(float v);
+  void SetValue(double v);
+  void SetValue(const std::string &str);
+  void SetContent(const std::string &str);
+  static std::string XMLString(const std::string &strIn);
+  void Dump(std::ostream &os, const std::string &prefix = "") const {
+    return DumpImpl(os, prefix);
+  }
+
+ protected:
+  virtual void DumpImpl(std::ostream &os, const std::string &prefix) const;
+  void DumpHead(std::ostream &os, const std::string &prefix = "") const;
+  void DumpTail(std::ostream &os, const std::string &prefix = "") const;
+
+  SimpleXMLElemIdTag tagID;
+  SimpleXMLElemValueTag tagValue;
+  MapleAllocator &allocator;
+  std::string catalog;
+  uint32 id;
+  union {
+    int8 i8;
+    uint8 u8;
+    int16 i16;
+    uint16 u16;
+    int32 i32;
+    uint32 u32;
+    int64 i64;
+    uint64 u64;
+    float f;
+    double d;
+    uint64 raw;
+  } value;
+  std::string valueString;
+  std::string content;
+  MapleList<SimpleXMLElem*> elems;
+};
+
+class SimpleXMLElemMultiLine : public SimpleXMLElem {
+ public:
+  SimpleXMLElemMultiLine(MapleAllocator &alloc, const std::string &cat);
+  SimpleXMLElemMultiLine(MapleAllocator &alloc, const std::string &cat, uint32 argID);
+  ~SimpleXMLElemMultiLine() = default;
+  void AddLine(const std::string &line);
+
+ protected:
+  void DumpImpl(std::ostream &os, const std::string &prefix) const override;
+
+ private:
+  MapleList<MapleString> lines;
+};
+
+class SimpleXML {
+ public:
+  explicit SimpleXML(MapleAllocator &alloc);
+  ~SimpleXML() = default;
+  void AddRoot(SimpleXMLElem &elem);
+
+ protected:
+  void DumpImpl(std::ostream &os) const;
+
+ private:
+  MapleAllocator &allocator;
+  MapleList<SimpleXMLElem*> roots;
+};
+}  // namespace maple
+#endif
diff --git a/src/hir2mpl/common/include/simple_zip.h b/src/hir2mpl/common/include/simple_zip.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ad931e9189e200c68d60cc48ef18d339a4530c
--- /dev/null
+++ b/src/hir2mpl/common/include/simple_zip.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// ref: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+#ifndef HIR2MPL_INCLUDE_SIMPLE_ZIP_H
+#define HIR2MPL_INCLUDE_SIMPLE_ZIP_H
+#include <list>
+#include <memory>
+#include <string>
+#include "types_def.h"
+#include "basic_io.h"
+
+namespace maple {
+class ZipLocalFileHeader {
+ public:
+  ZipLocalFileHeader() = default;
+  ~ZipLocalFileHeader();
+  static std::unique_ptr<ZipLocalFileHeader> Parse(BasicIORead &io);
+  uint16 GetGPFlag() const {
+    return gpFlag;
+  }
+
+  std::string GetFileName() const {
+    return fileName;
+  }
+
+ private:
+  uint32 signature = 0;
+  uint16 minVersion = 0;
+  uint16 gpFlag = 0;
+  uint16 compMethod = 0;
+  uint16 rawTime = 0;
+  uint16 rawDate = 0;
+  uint32 crc32 = 0;
+  uint32 compSize = 0;
+  uint32 unCompSize = 0;
+  uint16 lengthFileName = 0;
+  uint16 lengthExtraField = 0;
+  std::string fileName = "";
+  uint8 *extraField = nullptr;
+};
+
+class ZipDataDescriptor {
+ public:
+  ZipDataDescriptor() = default;
+  ~ZipDataDescriptor() = default;
+  static std::unique_ptr<ZipDataDescriptor> Parse(BasicIORead &io);
+  uint32 GetSignature() const {
+    return signature;
+  }
+
+  uint32 GetCRC32() const {
+    return crc32;
+  }
+
+  uint32 GetCompSize() const {
+    return compSize;
+  }
+
+  uint32 GetUnCompSize() const {
+    return unCompSize;
+  }
+
+ private:
+  uint32 signature = 0;
+  uint32 crc32 = 0;
+  uint32 compSize = 0;
+  uint32 unCompSize = 0;
+};
+
+class ZipLocalFile {
+ public:
+  ZipLocalFile() = default;
+  ~ZipLocalFile();
+  static std::unique_ptr<ZipLocalFile> Parse(BasicIORead &io);
+  std::string GetFileName() const {
+    return header->GetFileName();
+  }
+
+  const uint8 *GetUnCompData() const {
+    return unCompData;
+  }
+
+  uint32 GetUnCompDataSize() const {
+    return unCompDataSize;
+  }
+
+ private:
+  uint32 GetDataEndPos(const BasicIORead &io);
+  void ProcessUncompressedFile(BasicIORead &io, uint32 start, uint32 end);
+  void ProcessCompressedFile(BasicIORead &io, uint32 start, uint32 end);
+
+  std::unique_ptr<ZipLocalFileHeader> header;
+  uint8 *compData = nullptr;
+  uint8 *unCompData = nullptr;
+  uint32 unCompDataSize = 0;
+  std::unique_ptr<ZipDataDescriptor> dataDesc;
+  bool isCompressed = false;
+};
+
+class SimpleZip : public BasicIORead {
+ public:
+  explicit SimpleZip(BasicIOMapFile &file);
+  ~SimpleZip() override;
+  void ParseFile();
+
+  const std::list<std::unique_ptr<ZipLocalFile>> &GetFiles() const {
+    return files;
+  }
+
+ private:
+  std::list<std::unique_ptr<ZipLocalFile>> files;
+};
+}  // namespace maple
+#endif
diff --git a/src/hir2mpl/common/src/base64.cpp b/src/hir2mpl/common/src/base64.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6afadbe9a2ade5e6f5fadb930eecc2415832af19
--- /dev/null
+++ b/src/hir2mpl/common/src/base64.cpp
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "base64.h"
+#include <malloc.h>
+#include <map>
+#include "types_def.h"
+#include "mpl_logging.h"
+
+namespace maple {
+namespace {
+const std::string kBase64IdxStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const uint32 kBase64IdxStrLength = 64;
+const uint8 kBase64MaskEncode = 0x3F;
+const uint8 kBase64MaskDecode = 0xFF;
+const uint32 kBase64Shift0 = 0;
+const uint32 kBase64Shift8 = 8;
+const uint32 kBase64Shift16 = 16;
+const uint32 kBase64Shift6 = 6;
+const uint32 kBase64Shift12 = 12;
+const uint32 kBase64Shift18 = 18;
+const size_t kBase64EncodeBaseLen = 3;
+const size_t kBase64DecodeBaseLen = 4;
+}
+
+std::map<char, char> Base64::encodeMap = Base64::InitEncodeMap();
+std::map<char, uint8> Base64::decodeMap = Base64::InitDecodeMap();
+
+std::map<char, char> Base64::InitEncodeMap() {
+  // init encode map
+  std::map<char, char> ans;
+  CHECK_FATAL(kBase64IdxStr.length() == kBase64IdxStrLength, "length of base64_idx_str_ must be 64");
+  for (size_t i = 0; i < kBase64IdxStr.length(); i++) {
+    CHECK_FATAL(ans.insert(std::make_pair(i, kBase64IdxStr[i])).second, "encodeMap insert failed");
+  }
+  return ans;
+}
+
+std::map<char, uint8> Base64::InitDecodeMap() {
+  // init decode map
+  std::map<char, uint8> ans;
+  CHECK_FATAL(kBase64IdxStr.length() == kBase64IdxStrLength, "length of base64_idx_str_ must be 64");
+  for (uint32 i = 0; i < kBase64IdxStr.length(); i++) {
+    CHECK_FATAL(ans.insert(std::make_pair(kBase64IdxStr[i], i)).second, "decodeMap insert failed");
+  }
+  CHECK_FATAL(ans.insert(std::make_pair('=', 0)).second, "decodeMap insert failed");
+  return ans;
+}
+
+std::string Base64::Encode(const uint8 *input, size_t length) {
+  // process input
+  std::string strEncoded;
+  uint32 temp;
+  size_t offset;
+  while (length > 0) {
+    temp = 0;
+    if (length >= 1) {
+      temp |= (input[0] << kBase64Shift16);
+    }
+    if (length >= 2) {
+      temp |= (input[1] << kBase64Shift8);
+    }
+    if (length >= 3) {
+      temp |= (input[2] << kBase64Shift0);
+    }
+
+    // encoded code 0
+    strEncoded.push_back(encodeMap[static_cast<char>((temp >> kBase64Shift18) & kBase64MaskEncode)]);
+    // encoded code 1
+    strEncoded.push_back(encodeMap[static_cast<char>((temp >> kBase64Shift12) & kBase64MaskEncode)]);
+
+    if (length < 2) {
+      strEncoded.push_back('=');
+    } else {
+      // encoded code 2
+      strEncoded.push_back(encodeMap[static_cast<char>((temp >> kBase64Shift6) & kBase64MaskEncode)]);
+    }
+
+    if (length < kBase64EncodeBaseLen) {
+      strEncoded.push_back('=');
+    } else {
+      // encoded code 3
+      strEncoded.push_back(encodeMap[static_cast<char>((temp >> kBase64Shift0) & kBase64MaskEncode)]);
+    }
+
+    offset = (length >= kBase64EncodeBaseLen) ? kBase64EncodeBaseLen : length;
+    length -= offset;
+    input += offset;
+  }
+  return strEncoded;
+}
+
+size_t Base64::DecodeLength(const std::string &input) {
+  // length calculation
+  size_t length;
+  size_t inputLength = input.length();
+  if (inputLength == 0) {
+    return 0;
+  }
+  CHECK_FATAL(inputLength % kBase64DecodeBaseLen == 0, "input.length must be factor of 4");
+  length = inputLength * kBase64EncodeBaseLen / kBase64DecodeBaseLen;
+  if (input[inputLength - 1] == '=') {
+    length--;
+  }
+  if (input[inputLength - 2] == '=') {
+    length--;
+  }
+  return length;
+}
+
+uint8 *Base64::Decode(const std::string &input, size_t &lengthRet) {
+  size_t inputLength = input.length();
+  lengthRet = DecodeLength(input);
+  if (lengthRet == 0) {
+    return nullptr;
+  }
+  size_t idx = 0;
+  const char *inputBuf = input.c_str();
+  uint8 *buf = static_cast<uint8*>(malloc(sizeof(uint8) * lengthRet));
+  CHECK_FATAL(buf != nullptr, "malloc failed");
+  uint32 temp;
+  while (inputLength > 0) {
+    auto it0 = decodeMap.find(inputBuf[0]);
+    auto it1 = decodeMap.find(inputBuf[1]);
+    auto it2 = decodeMap.find(inputBuf[2]);
+    auto it3 = decodeMap.find(inputBuf[3]);
+    if (it0 == decodeMap.end() || it1 == decodeMap.end() || it2 == decodeMap.end() || it3 == decodeMap.end()) {
+      CHECK_FATAL(false, "invalid input");
+    }
+    temp = (it0->second << kBase64Shift18) | (it1->second << kBase64Shift12) | (it2->second << kBase64Shift6) |
+           (it3->second << kBase64Shift0);
+    uint8 c0 = (temp >> kBase64Shift16) & kBase64MaskDecode;
+    uint8 c1 = (temp >> kBase64Shift8) & kBase64MaskDecode;
+    uint8 c2 = (temp >> kBase64Shift0) & kBase64MaskDecode;
+    if (inputBuf[2] == '=') {
+      CHECK_FATAL(inputLength == kBase64DecodeBaseLen, "'=' must be in last package");
+      CHECK_FATAL(inputBuf[3] == '=', "'=' must be in last package");
+      buf[idx++] = c0;
+    } else if (inputBuf[3] == '=') {
+      CHECK_FATAL(inputLength == kBase64DecodeBaseLen, "'=' must be in last package");
+      buf[idx++] = c0;
+      buf[idx++] = c1;
+    } else {
+      buf[idx++] = c0;
+      buf[idx++] = c1;
+      buf[idx++] = c2;
+    }
+    inputLength -= kBase64DecodeBaseLen;
+    inputBuf += kBase64DecodeBaseLen;
+  }
+  return buf;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/basic_io.cpp b/src/hir2mpl/common/src/basic_io.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..178142ec79e7ac710d8b1d43c0d8d8f62e5bce90
--- /dev/null
+++ b/src/hir2mpl/common/src/basic_io.cpp
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "basic_io.h"
+#include <cerrno>
+#include <dirent.h>
+#include <fcntl.h>
+#include <cstdlib>
+#include <unistd.h>
+#include <sys/mman.h>
+#include "mpl_logging.h"
+#include "file_utils.h"
+
+namespace maple {
+BasicIOMapFile::BasicIOMapFile(const std::string &name)
+    : fd(-1), ptr(nullptr), ptrMemMap(nullptr), length(0), fileName(name) {}
+
+BasicIOMapFile::BasicIOMapFile(const std::string &name, const uint8 *ptrIn, long lengthIn)
+    : fd(-1), ptr(ptrIn), ptrMemMap(nullptr), length(lengthIn), fileName(name) {}
+
+BasicIOMapFile::~BasicIOMapFile() {
+  ptr = nullptr;
+  ptrMemMap = nullptr;
+}
+
+bool BasicIOMapFile::OpenAndMapImpl() {
+  fd = -1;
+  std::string realPath = FileUtils::GetRealPath(fileName);
+  fd = open(realPath.c_str(), O_RDONLY);
+  if (fd < 0) {
+    ERR(kLncErr, "Unable to open %s.\nError %d in open()", fileName.c_str(), errno);
+    return false;
+  }
+  long start = lseek(fd, 0L, SEEK_SET);
+  long end = lseek(fd, 0L, SEEK_END);
+  if (end > start) {
+    length = static_cast<size_t>(end - start);
+    ptrMemMap = static_cast<uint8*>(mmap(NULL, length, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, start));
+    ptr = ptrMemMap;
+    return true;
+  } else {
+    length = 0;
+    ptrMemMap = nullptr;
+    ptr = nullptr;
+    if (close(fd) != 0) {
+      FATAL(kLncFatal, "close error");
+    }
+    return false;
+  }
+}
+
+void BasicIOMapFile::Close() {
+  if (fd > 0) {
+    if (munmap(ptrMemMap, length) != 0) {
+      FATAL(kLncFatal, "munmap error");
+    }
+    ptrMemMap = nullptr;
+    ptr = nullptr;
+    if (close(fd) != 0) {
+      FATAL(kLncFatal, "close error");
+    }
+  }
+  fd = -1;
+}
+
+std::unique_ptr<BasicIOMapFile> BasicIOMapFile::GenFileInMemory(const std::string &name, const uint8 *buf, size_t len) {
+  std::unique_ptr<BasicIOMapFile> file = std::make_unique<BasicIOMapFile>(name);
+  file->ptr = buf;
+  file->length = len;
+  return file;
+}
+
+BasicIORead::BasicIORead(BasicIOMapFile &f, bool bigEndian) : file(f), isBigEndian(bigEndian), pos(0) {}
+
+uint8 BasicIORead::ReadUInt8() {
+  const uint8 *p = GetSafeBuffer(BasicIOEndian::kLengthByte);
+  pos += BasicIOEndian::kLengthByte;
+  return p[0];
+}
+
+uint8 BasicIORead::ReadUInt8(bool &success) {
+  const uint8 *p = GetBuffer(BasicIOEndian::kLengthByte);
+  if (p == nullptr) {
+    success = false;
+    return 0;
+  }
+  pos += BasicIOEndian::kLengthByte;
+  success = true;
+  return p[0];
+}
+
+int8 BasicIORead::ReadInt8() {
+  return static_cast<int8>(ReadUInt8());
+}
+
+int8 BasicIORead::ReadInt8(bool &success) {
+  return static_cast<int8>(ReadUInt8(success));
+}
+
+char BasicIORead::ReadChar() {
+  return static_cast<char>(ReadUInt8());
+}
+
+char BasicIORead::ReadChar(bool &success) {
+  return static_cast<char>(ReadUInt8(success));
+}
+
+uint16 BasicIORead::ReadUInt16() {
+  const uint8 *p = GetSafeBuffer(BasicIOEndian::kLengthWord);
+  pos += BasicIOEndian::kLengthWord;
+  if (isBigEndian) {
+    return BasicIOEndian::GetUInt16BigEndian(p);
+  } else {
+    return BasicIOEndian::GetUInt16LittleEndian(p);
+  }
+}
+
+uint16 BasicIORead::ReadUInt16(bool &success) {
+  const uint8 *p = GetBuffer(BasicIOEndian::kLengthWord);
+  if (p == nullptr) {
+    success = false;
+    return 0;
+  }
+  pos += BasicIOEndian::kLengthWord;
+  success = true;
+  if (isBigEndian) {
+    return BasicIOEndian::GetUInt16BigEndian(p);
+  } else {
+    return BasicIOEndian::GetUInt16LittleEndian(p);
+  }
+}
+
+int16 BasicIORead::ReadInt16() {
+  return static_cast<int16>(ReadUInt16());
+}
+
+int16 BasicIORead::ReadInt16(bool &success) {
+  return static_cast<int16>(ReadUInt16(success));
+}
+
+uint32 BasicIORead::ReadUInt32() {
+  const uint8 *p = GetSafeBuffer(BasicIOEndian::kLengthDWord);
+  pos += BasicIOEndian::kLengthDWord;
+  if (isBigEndian) {
+    return BasicIOEndian::GetUInt32BigEndian(p);
+  } else {
+    return BasicIOEndian::GetUInt32LittleEndian(p);
+  }
+}
+
+uint32 BasicIORead::ReadUInt32(bool &success) {
+  const uint8 *p = GetBuffer(BasicIOEndian::kLengthDWord);
+  if (p == nullptr) {
+    success = false;
+    return 0;
+  }
+  pos += BasicIOEndian::kLengthDWord;
+  success = true;
+  if (isBigEndian) {
+    return BasicIOEndian::GetUInt32BigEndian(p);
+  } else {
+    return BasicIOEndian::GetUInt32LittleEndian(p);
+  }
+}
+
+int32 BasicIORead::ReadInt32() {
+  return static_cast<int32>(ReadUInt32());
+}
+
+int32 BasicIORead::ReadInt32(bool &success) {
+  return static_cast<int32>(ReadUInt32(success));
+}
+
+uint64 BasicIORead::ReadUInt64() {
+  const uint8 *p = GetSafeBuffer(BasicIOEndian::kLengthQWord);
+  pos += BasicIOEndian::kLengthQWord;
+  if (isBigEndian) {
+    return BasicIOEndian::GetUInt64BigEndian(p);
+  } else {
+    return BasicIOEndian::GetUInt64LittleEndian(p);
+  }
+}
+
+uint64 BasicIORead::ReadUInt64(bool &success) {
+  const uint8 *p = GetBuffer(BasicIOEndian::kLengthQWord);
+  if (p == nullptr) {
+    success = false;
+    return 0;
+  }
+  pos += BasicIOEndian::kLengthQWord;
+  success = true;
+  if (isBigEndian) {
+    return BasicIOEndian::GetUInt64BigEndian(p);
+  } else {
+    return BasicIOEndian::GetUInt64LittleEndian(p);
+  }
+}
+
+int64 BasicIORead::ReadInt64() {
+  return static_cast<int64>(ReadUInt64());
+}
+
+int64 BasicIORead::ReadInt64(bool &success) {
+  return static_cast<int64>(ReadUInt64(success));
+}
+
+float BasicIORead::ReadFloat() {
+  union {
+    uint32 iv;
+    float fv;
+  } v;
+  v.iv = ReadUInt32();
+  return v.fv;
+}
+
+float BasicIORead::ReadFloat(bool &success) {
+  union {
+    uint32 iv;
+    float fv;
+  } v;
+  v.iv = ReadUInt32(success);
+  return v.fv;
+}
+
+double BasicIORead::ReadDouble() {
+  union {
+    uint64 lv;
+    double dv;
+  } v;
+  v.lv = ReadUInt64();
+  return v.dv;
+}
+
+double BasicIORead::ReadDouble(bool &success) {
+  union {
+    uint64 lv;
+    double dv;
+  } v;
+  v.lv = ReadUInt64(success);
+  return v.dv;
+}
+
+void BasicIORead::ReadBufferUInt8(uint8 *dst, uint32 length) {
+  const uint8 *p = GetSafeBuffer(length);
+  pos += length;
+  errno_t err = memcpy_s(dst, length, p, length);
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
+}
+
+void BasicIORead::ReadBufferUInt8(uint8 *dst, uint32 length, bool &success) {
+  const uint8 *p = GetBuffer(length);
+  if (p == nullptr) {
+    success = false;
+    return;
+  }
+  pos += length;
+  success = true;
+  errno_t err = memcpy_s(dst, length, p, length);
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
+}
+
+void BasicIORead::ReadBufferInt8(int8 *dst, uint32 length) {
+  CHECK_NULL_FATAL(dst);
+  const uint8 *p = GetSafeBuffer(length);
+  pos += length;
+  errno_t err = memcpy_s(dst, length, p, length);
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
+}
+
+void BasicIORead::ReadBufferInt8(int8 *dst, uint32 length, bool &success) {
+  CHECK_NULL_FATAL(dst);
+  const uint8 *p = GetBuffer(length);
+  if (p == nullptr) {
+    success = false;
+    return;
+  }
+  pos += length;
+  success = true;
+  errno_t err = memcpy_s(dst, length, p, length);
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
+}
+
+void BasicIORead::ReadBufferChar(char *dst, uint32 length) {
+  const uint8 *p = GetSafeBuffer(length);
+  pos += length;
+  errno_t err = memcpy_s(dst, length, p, length);
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
+}
+
+void BasicIORead::ReadBufferChar(char *dst, uint32 length, bool &success) {
+  const uint8 *p = GetBuffer(length);
+  if (p == nullptr) {
+    success = false;
+    return;
+  }
+  pos += length;
+  success = true;
+  errno_t err = memcpy_s(dst, length, p, length);
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
+}
+
+std::string BasicIORead::ReadString(uint32 length) {
+  const void *p = GetSafeBuffer(length);
+  const char *pchar = static_cast<const char*>(p);
+  pos += length;
+  return std::string(pchar, length);
+}
+
+std::string BasicIORead::ReadString(uint32 length, bool &success) {
+  const void *p = GetBuffer(length);
+  const char *pchar = static_cast<const char*>(p);
+  if (p == nullptr) {
+    success = false;
+    return "";
+  }
+  pos += length;
+  success = true;
+  return std::string(pchar, length);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/enhance_c_checker.cpp b/src/hir2mpl/common/src/enhance_c_checker.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eaadc191191588dad972b7143d831dc92bf471c3
--- /dev/null
+++ b/src/hir2mpl/common/src/enhance_c_checker.cpp
@@ -0,0 +1,2232 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "enhance_c_checker.h"
+#include "ast_parser.h"
+#include "ast_expr.h"
+#include "ast_stmt.h"
+#include "ast_decl_builder.h"
+#include "feir_builder.h"
+#include "fe_manager.h"
+#include "fe_macros.h"
+
+namespace maple {
+const std::string kBoundsBuiltFunc = "__builtin_dynamic_bounds_cast";
+void ASTParser::ProcessNonnullFuncPtrAttrs(MapleAllocator &allocator, const clang::ValueDecl &valueDecl,
+                                           ASTDecl &astVar) {
+  const MIRFuncType *funcType = FEUtils::GetFuncPtrType(*astVar.GetTypeDesc().front());
+  if (funcType == nullptr) {
+    return;
+  }
+  std::vector<TypeAttrs> attrsVec = funcType->GetParamAttrsList();
+  TypeAttrs retAttr = funcType->GetRetAttrs();
+  // nonnull with args in function type pointers need marking nonnull arg
+  for (const auto *nonNull : valueDecl.specific_attrs<clang::NonNullAttr>()) {
+    if (nonNull->args_size() == 0) {
+      continue;
+    }
+    for (const clang::ParamIdx &paramIdx : nonNull->args()) {
+      // The clang ensures that nonnull attribute only applies to pointer parameter
+      unsigned int idx = paramIdx.getASTIndex();
+      if (idx >= attrsVec.size()) {
+        continue;
+      }
+      attrsVec[idx].SetAttr(ATTR_nonnull);
+    }
+  }
+  if (valueDecl.hasAttr<clang::ReturnsNonNullAttr>()) {
+    retAttr.SetAttr(ATTR_nonnull);
+  }
+  MIRType *newFuncType = GlobalTables::GetTypeTable().GetOrCreateFunctionType(
+      funcType->GetRetTyIdx(), funcType->GetParamTypeList(), attrsVec, funcType->IsVarargs(), retAttr);
+  astVar.SetTypeDesc(MapleVector<MIRType*>({GlobalTables::GetTypeTable().GetOrCreatePointerType(
+      *GlobalTables::GetTypeTable().GetOrCreatePointerType(*newFuncType))}, allocator.Adapter()));
+}
+
+bool ENCChecker::HasNonnullAttrInExpr(MIRBuilder &mirBuilder, const UniqueFEIRExpr &expr, bool isNested) {
+  if (expr->GetKind() == kExprDRead) {
+    if (isNested) {  // skip multi-dimensional pointer
+      return true;
+    }
+    FEIRExprDRead *dread = static_cast<FEIRExprDRead*>(expr.get());
+    MIRSymbol *symbol = dread->GetVar()->GenerateMIRSymbol(mirBuilder);
+    if (expr->GetFieldID() == 0) {
+      return symbol->GetAttr(ATTR_nonnull);
+    } else {
+      FieldID fieldID = expr->GetFieldID();
+      CHECK_FATAL(symbol->GetType()->IsStructType(), "basetype must be StructType");
+      FieldPair fieldPair = static_cast<MIRStructType*>(symbol->GetType())->TraverseToFieldRef(fieldID);
+      return fieldPair.second.second.GetAttr(FLDATTR_nonnull);
+    }
+  } else if (expr->GetKind() == kExprIRead) {
+    FEIRExprIRead *iread = static_cast<FEIRExprIRead*>(expr.get());
+    FieldID fieldID = expr->GetFieldID();
+    if (fieldID == 0) {
+      return HasNonnullAttrInExpr(mirBuilder, iread->GetClonedOpnd(), true);
+    }
+    MIRType *pointerType = iread->GetClonedPtrType()->GenerateMIRTypeAuto();
+    CHECK_FATAL(pointerType->IsMIRPtrType(), "Must be ptr type!");
+    MIRType *baseType = static_cast<MIRPtrType*>(pointerType)->GetPointedType();
+    CHECK_FATAL(baseType->IsStructType(), "basetype must be StructType");
+    FieldPair fieldPair = static_cast<MIRStructType*>(baseType)->TraverseToFieldRef(fieldID);
+    return fieldPair.second.second.GetAttr(FLDATTR_nonnull);
+  } else if (isNested && expr->GetKind() == kExprAddrofArray) {
+    return false;
+  } else {
+    return true;
+  }
+}
+
+bool ENCChecker::HasNullExpr(const UniqueFEIRExpr &expr) {
+  if (expr == nullptr || expr->GetKind() != kExprUnary || expr->GetPrimType() != PTY_ptr) {
+    return false;
+  }
+  const UniqueFEIRExpr &cstExpr = static_cast<FEIRExprUnary*>(expr.get())->GetOpnd();
+  return FEIRBuilder::IsZeroConstExpr(cstExpr);
+}
+
+void ENCChecker::CheckNonnullGlobalVarInit(const MIRSymbol &sym, const MIRConst *cst) {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic()) {
+    return;
+  }
+  if (sym.GetAttr(ATTR_nonnull)) {
+    if ((cst != nullptr && cst->IsZero()) || (cst == nullptr && sym.GetAttr(ATTR_static_init_zero))) {
+      FE_ERR(kLncErr, FEUtils::GetSrcLocationForMIRSymbol(sym), "null assignment of nonnull pointer");
+    } else if (cst == nullptr) {
+      FE_ERR(kLncErr, FEUtils::GetSrcLocationForMIRSymbol(sym), "nonnull parameter is uninitialized when defined");
+    }
+  } else if (sym.GetAttr(ATTR_static_init_zero) && HasNonnullFieldInStruct(*sym.GetType())) {
+    auto *structType = static_cast<MIRStructType*>(sym.GetType());
+    for (size_t i = 0; i < structType->GetFieldsSize(); ++i) {
+      if (!structType->GetFieldsElemt(i).second.second.GetAttr(FLDATTR_nonnull)) {
+        continue;
+      }
+      FE_ERR(kLncErr, FEUtils::GetSrcLocationForMIRSymbol(sym),
+             "null assignment of nonnull field pointer. [field name: %s]",
+             GlobalTables::GetStrTable().GetStringFromStrIdx(structType->GetFieldsElemt(i).first).c_str());
+    }
+  }
+}
+
+void ENCChecker::CheckNullFieldInGlobalStruct(MIRType &type, MIRAggConst &cst, const MapleVector<ASTExpr*> &initExprs) {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || !ENCChecker::HasNonnullFieldInStruct(type)) {
+    return;
+  }
+  auto &structType = static_cast<MIRStructType&>(type);
+  for (size_t i = 0; i < structType.GetFieldsSize(); ++i) {
+    if (!structType.GetFieldsElemt(i).second.second.GetAttr(FLDATTR_nonnull)) {
+      continue;
+    }
+    size_t idx = structType.GetKind() == kTypeUnion ? 0 : i;  // union only is one element
+    if (idx < cst.GetConstVec().size() && cst.GetConstVecItem(idx) != nullptr && cst.GetConstVecItem(idx)->IsZero()) {
+        FE_ERR(kLncErr, initExprs[idx]->GetSrcLoc(), "null assignment of nonnull field pointer. [field name: %s]",
+               GlobalTables::GetStrTable().GetStringFromStrIdx(structType.GetFieldsElemt(i).first).c_str());
+    }
+  }
+}
+
+void ENCChecker::CheckNonnullLocalVarInit(const MIRSymbol &sym, const ASTExpr *initExpr) {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || initExpr != nullptr) {
+    return;
+  }
+  if (sym.GetAttr(ATTR_nonnull)) {
+    if (sym.GetAttr(ATTR_static_init_zero)) {
+      FE_ERR(kLncErr, FEUtils::GetSrcLocationForMIRSymbol(sym), "null assignment of nonnull pointer");
+    } else {
+      FE_ERR(kLncErr, FEUtils::GetSrcLocationForMIRSymbol(sym),
+             "error: nonnull parameter is uninitialized when defined");
+    }
+  } else if (sym.GetAttr(ATTR_static_init_zero) && HasNonnullFieldInStruct(*sym.GetType())) {
+    auto *structType = static_cast<MIRStructType*>(sym.GetType());
+    for (size_t i = 0; i < structType->GetFieldsSize(); ++i) {
+      if (structType->GetFieldsElemt(i).second.second.GetAttr(FLDATTR_nonnull)) {
+        FE_ERR(kLncErr, FEUtils::GetSrcLocationForMIRSymbol(sym),
+               "null assignment of nonnull field pointer. [field name: %s]",
+               GlobalTables::GetStrTable().GetStringFromStrIdx(structType->GetFieldsElemt(i).first).c_str());}
+    }
+  }
+}
+
+void ENCChecker::CheckNonnullLocalVarInit(const MIRSymbol &sym, const UniqueFEIRExpr &initFEExpr,
+                                          std::list<UniqueFEIRStmt> &stmts) {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || !sym.GetAttr(ATTR_nonnull)) {
+    return;
+  }
+  if (HasNullExpr(initFEExpr)) {
+    FE_ERR(kLncErr, FEUtils::GetSrcLocationForMIRSymbol(sym), "null assignment of nonnull pointer");
+    return;
+  }
+  if (initFEExpr->GetPrimType() == PTY_ptr) {
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtAssertNonnull>(OP_assignassertnonnull, initFEExpr->Clone());
+    stmt->SetSrcLoc(FEUtils::GetSrcLocationForMIRSymbol(sym));
+    stmts.emplace_back(std::move(stmt));
+  }
+}
+
+std::string ENCChecker::GetNthStr(size_t index) {
+  switch (index) {
+    case 0:
+      return "1st";
+    case 1:
+      return "2nd";
+    case 2:
+      return "3rd";
+    default: {
+      std::ostringstream oss;
+      oss << index + 1 << "th";
+      return oss.str();
+    }
+  }
+}
+
+std::string ENCChecker::PrintParamIdx(const std::list<size_t> &idxs) {
+  std::ostringstream os;
+  for (auto iter = idxs.begin(); iter != idxs.end(); ++iter) {
+    if (iter != idxs.begin()) {
+      os << ", ";
+    }
+    os << GetNthStr(*iter);
+  }
+  return os.str();
+}
+
+void ENCChecker::CheckNonnullArgsAndRetForFuncPtr(const MIRType &dstType, const UniqueFEIRExpr &srcExpr,
+                                                  const Loc &loc) {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || !srcExpr->IsEnhancedChecking()) {
+    return;
+  }
+  const MIRFuncType *funcType = FEUtils::GetFuncPtrType(dstType);
+  if (funcType == nullptr) {
+    return;
+  }
+  if (srcExpr->GetKind() == kExprAddrofFunc) {  // check func ptr l-value and &func decl r-value
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        static_cast<FEIRExprAddrofFunc*>(srcExpr.get())->GetFuncAddr());
+    MIRFunction *srcFunc = FEManager::GetTypeManager().GetMIRFunction(strIdx, false);
+    CHECK_FATAL(srcFunc != nullptr, "can not get MIRFunction");
+    std::list<size_t> errIdxs;
+    for (size_t i = 0; i < srcFunc->GetParamSize() && i < funcType->GetParamAttrsList().size(); ++i) {
+      if (srcFunc->GetNthParamAttr(i).GetAttr(ATTR_nonnull) != funcType->GetNthParamAttrs(i).GetAttr(ATTR_nonnull)) {
+        errIdxs.emplace_back(i);
+      }
+    }
+    if (!errIdxs.empty()) {
+      FE_ERR(kLncErr, loc, "function pointer and assigned function %s are mismatched "
+             "for the %s argument of nonnull attributes", srcFunc->GetName().c_str(), PrintParamIdx(errIdxs).c_str());
+    }
+    if (srcFunc->GetFuncAttrs().GetAttr(FUNCATTR_nonnull) != funcType->GetRetAttrs().GetAttr(ATTR_nonnull)) {
+      FE_ERR(kLncErr, loc, "function pointer and target function's nonnull attributes are mismatched for "
+             "the return value");
+    }
+  }
+  const MIRFuncType *srcFuncType = FEUtils::GetFuncPtrType(*srcExpr->GetType()->GenerateMIRTypeAuto());
+  if (srcFuncType != nullptr) {   // check func ptr l-value and func ptr r-value
+    std::list<size_t> errIdxs;
+    for (size_t i = 0; i < srcFuncType->GetParamAttrsList().size() && i < funcType->GetParamAttrsList().size(); ++i) {
+      if (srcFuncType->GetNthParamAttrs(i).GetAttr(ATTR_nonnull) !=
+          funcType->GetNthParamAttrs(i).GetAttr(ATTR_nonnull)) {
+        errIdxs.emplace_back(i);
+      }
+    }
+    if (!errIdxs.empty()) {
+      FE_ERR(kLncErr, loc, "function pointer's nonnull attributes are mismatched for the %s argument",
+             PrintParamIdx(errIdxs).c_str());
+    }
+    if (srcFuncType->GetRetAttrs().GetAttr(ATTR_nonnull) != funcType->GetRetAttrs().GetAttr(ATTR_nonnull)) {
+      FE_ERR(kLncErr, loc, "function pointer's nonnull attributes are mismatched for the return value");
+    }
+  }
+}
+
+void FEIRStmtDAssign::CheckNonnullArgsAndRetForFuncPtr(const MIRBuilder &mirBuilder) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || ENCChecker::IsUnsafeRegion(mirBuilder)) {
+    return;
+  }
+  MIRType *baseType = var->GetType()->GenerateMIRTypeAuto();
+  if (fieldID != 0) {
+    baseType = FEUtils::GetStructFieldType(static_cast<MIRStructType*>(baseType), fieldID);
+  }
+  ENCChecker::CheckNonnullArgsAndRetForFuncPtr(*baseType, expr, loc);
+}
+
+void FEIRStmtIAssign::CheckNonnullArgsAndRetForFuncPtr(const MIRBuilder &mirBuilder, const MIRType &baseType) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || ENCChecker::IsUnsafeRegion(mirBuilder)) {
+    return;
+  }
+  MIRType *fieldType = FEUtils::GetStructFieldType(static_cast<const MIRStructType*>(&baseType), fieldID);
+  ENCChecker::CheckNonnullArgsAndRetForFuncPtr(*fieldType, baseExpr, loc);
+}
+
+bool ENCChecker::HasNonnullFieldInStruct(const MIRType &mirType) {
+  if (mirType.IsStructType() && FEManager::GetTypeManager().IsOwnedNonnullFieldStructSet(mirType.GetTypeIndex())) {
+    return true;
+  }
+  return false;
+}
+
+bool ENCChecker::HasNonnullFieldInPtrStruct(const MIRType &mirType) {
+  if (mirType.IsMIRPtrType()) {
+    MIRType *structType = static_cast<const MIRPtrType&>(mirType).GetPointedType();
+    if (structType != nullptr && HasNonnullFieldInStruct(*structType)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void ASTCallExpr::CheckNonnullFieldInStruct() const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic()) {
+    return;
+  }
+  std::list<UniqueFEIRStmt> nullStmts;
+  UniqueFEIRExpr baseExpr = nullptr;
+  if (GetFuncName() == "bzero" && args.size() == 2) {
+    baseExpr = args[0]->Emit2FEExpr(nullStmts);
+  } else if (GetFuncName() == "memset" && args.size() == 3 &&
+             FEIRBuilder::IsZeroConstExpr(args[1]->Emit2FEExpr(nullStmts))) {
+    baseExpr = args[0]->Emit2FEExpr(nullStmts);
+  }
+  if (baseExpr == nullptr) {
+    return;
+  }
+  MIRType *mirType = ENCChecker::GetTypeFromAddrExpr(baseExpr);  // check addrof or iaddrof
+  if (mirType != nullptr) {
+    mirType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType);
+  } else if ((baseExpr->GetKind() == kExprDRead || baseExpr->GetKind() == kExprIRead) &&
+              baseExpr->GetType() != nullptr) {
+    mirType = baseExpr->GetType()->GenerateMIRTypeAuto();
+  }
+  if (mirType != nullptr && ENCChecker::HasNonnullFieldInPtrStruct(*mirType)) {
+      FE_ERR(kLncErr, loc, "null assignment of nonnull structure field pointer in %s", GetFuncName().c_str());
+  }
+}
+
+void ENCChecker::CheckNonnullFieldInStruct(const MIRType &src, const MIRType &dst, const Loc &loc) {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() ||
+      !dst.IsMIRPtrType() || !src.IsMIRPtrType() ||
+      dst.GetTypeIndex() == src.GetTypeIndex()) {
+    return;
+  }
+  if (ENCChecker::HasNonnullFieldInPtrStruct(dst)) {
+    FE_ERR(kLncErr, loc, "null assignment risk of nonnull field pointer");
+  }
+}
+
+// ---------------------------
+// process boundary attr
+// ---------------------------
+void ASTParser::ProcessBoundaryFuncAttrs(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                         ASTFunc &astFunc) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return;
+  }
+  for (const auto *returnsCountAttr : funcDecl.specific_attrs<clang::ReturnsCountAttr>()) {
+    clang::Expr *expr = returnsCountAttr->getLenExpr();
+    ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+    if (lenExpr == nullptr) {
+      continue;
+    }
+    ProcessBoundaryLenExprInFunc(allocator, funcDecl, static_cast<unsigned int>(-1), astFunc, lenExpr, true);
+  }
+  for (const auto *countAttr : funcDecl.specific_attrs<clang::CountAttr>()) {
+    clang::Expr *expr = countAttr->getLenExpr();
+    ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+    if (lenExpr == nullptr) {
+      continue;
+    }
+    if (countAttr->index_size() == 0) {
+      // Lack of attribute index parameters means that only one pointer parameter is
+      // implicitly marked as boundary var in func.
+      for (unsigned int i = 0; i < astFunc.GetParamDecls().size(); ++i) {
+        if (astFunc.GetParamDecls()[i]->GetTypeDesc().front()->IsMIRPtrType()) {
+          ProcessBoundaryLenExprInFunc(allocator, funcDecl, i, astFunc, lenExpr, true);
+        }
+      }
+      break;
+    }
+    for (const clang::ParamIdx &paramIdx : countAttr->index()) {
+      // The clang ensures that the attribute only applies to pointer parameter
+      unsigned int idx = paramIdx.getASTIndex();
+      if (idx >= astFunc.GetParamDecls().size()) {
+        continue;
+      }
+      ProcessBoundaryLenExprInFunc(allocator, funcDecl, idx, astFunc, lenExpr, true);
+    }
+  }
+  ProcessByteBoundaryFuncAttrs(allocator, funcDecl, astFunc);
+  ProcessBoundaryFuncAttrsByIndex(allocator, funcDecl, astFunc);
+}
+
+void ASTParser::ProcessByteBoundaryFuncAttrs(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                             ASTFunc &astFunc) {
+  for (const auto *returnsCountAttr : funcDecl.specific_attrs<clang::ReturnsByteCountAttr>()) {
+    clang::Expr *expr = returnsCountAttr->getLenExpr();
+    ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+    if (lenExpr == nullptr) {
+      continue;
+    }
+    ProcessBoundaryLenExprInFunc(allocator, funcDecl, static_cast<unsigned int>(-1), astFunc, lenExpr, false);
+  }
+  for (const auto *countAttr : funcDecl.specific_attrs<clang::ByteCountAttr>()) {
+    clang::Expr *expr = countAttr->getLenExpr();
+    ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+    if (lenExpr == nullptr) {
+      continue;
+    }
+    if (countAttr->index_size() == 0) {
+      // Lack of attribute index parameters means that only one pointer parameter is
+      // implicitly marked as boundary var in func.
+      for (unsigned int i = 0; i < astFunc.GetParamDecls().size(); ++i) {
+        if (astFunc.GetParamDecls()[i]->GetTypeDesc().front()->IsMIRPtrType()) {
+          ProcessBoundaryLenExprInFunc(allocator, funcDecl, i, astFunc, lenExpr, false);
+        }
+      }
+      break;
+    }
+    for (const clang::ParamIdx &paramIdx : countAttr->index()) {
+      // The clang ensures that the attribute only applies to pointer parameter
+      unsigned int idx = paramIdx.getASTIndex();
+      if (idx >= astFunc.GetParamDecls().size()) {
+        continue;
+      }
+      ProcessBoundaryLenExprInFunc(allocator, funcDecl, idx, astFunc, lenExpr, false);
+    }
+  }
+}
+
+void ASTParser::ProcessBoundaryFuncAttrsByIndex(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                                ASTFunc &astFunc) {
+  for (const auto *countIndexAttr : funcDecl.specific_attrs<clang::CountIndexAttr>()) {
+    unsigned int lenIdx = countIndexAttr->getLenVarIndex().getASTIndex();
+    for (const clang::ParamIdx &paramIdx : countIndexAttr->index()) {
+      unsigned int idx = paramIdx.getASTIndex();
+      if (idx >= astFunc.GetParamDecls().size()) {
+        continue;
+      }
+      ProcessBoundaryLenExprInFunc(allocator, funcDecl, idx, astFunc, lenIdx, true);
+    }
+  }
+  for (const auto *returnsCountIndexAttr : funcDecl.specific_attrs<clang::ReturnsCountIndexAttr>()) {
+    unsigned int retLenIdx = returnsCountIndexAttr->getLenVarIndex().getASTIndex();
+    ProcessBoundaryLenExprInFunc(allocator, funcDecl, static_cast<unsigned int>(-1), astFunc, retLenIdx, true);
+  }
+  for (const auto *byteCountIndexAttr : funcDecl.specific_attrs<clang::ByteCountIndexAttr>()) {
+    unsigned int lenIdx = byteCountIndexAttr->getLenVarIndex().getASTIndex();
+    for (const clang::ParamIdx &paramIdx : byteCountIndexAttr->index()) {
+      unsigned int idx = paramIdx.getASTIndex();
+      if (idx >= astFunc.GetParamDecls().size()) {
+        continue;
+      }
+      ProcessBoundaryLenExprInFunc(allocator, funcDecl, idx, astFunc, lenIdx, false);
+    }
+  }
+  for (const auto *returnsByteCountIndexAttr : funcDecl.specific_attrs<clang::ReturnsByteCountIndexAttr>()) {
+    unsigned int retLenIdx = returnsByteCountIndexAttr->getLenVarIndex().getASTIndex();
+    ProcessBoundaryLenExprInFunc(allocator, funcDecl, static_cast<unsigned int>(-1), astFunc, retLenIdx, false);
+  }
+}
+
+void ASTParser::ProcessBoundaryParamAttrs(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                          ASTFunc &astFunc) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return;
+  }
+  for (unsigned int i = 0; i < funcDecl.getNumParams(); ++i) {
+    const clang::ParmVarDecl *parmDecl = funcDecl.getParamDecl(i);
+    if (parmDecl->getKind() == clang::Decl::Function) {
+      continue;
+    }
+    for (const auto *countAttr : parmDecl->specific_attrs<clang::CountAttr>()) {
+      clang::Expr *expr = countAttr->getLenExpr();
+      if (countAttr->index_size() > 0) {
+        continue;  // boundary attrs with index args are only marked function pointers
+      }
+      ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+      if (lenExpr == nullptr) {
+        continue;
+      }
+      ProcessBoundaryLenExprInFunc(allocator, funcDecl, i, astFunc, lenExpr, true);
+    }
+    for (const auto *byteCountAttr : parmDecl->specific_attrs<clang::ByteCountAttr>()) {
+      clang::Expr *expr = byteCountAttr->getLenExpr();
+      if (byteCountAttr->index_size() > 0) {
+        continue;  // boundary attrs with index args are only marked function pointers
+      }
+      ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+      if (lenExpr == nullptr) {
+        continue;
+      }
+      ProcessBoundaryLenExprInFunc(allocator, funcDecl, i, astFunc, lenExpr, false);
+    }
+  }
+  ProcessBoundaryParamAttrsByIndex(allocator, funcDecl, astFunc);
+}
+
+void ASTParser::ProcessBoundaryParamAttrsByIndex(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                                 ASTFunc &astFunc) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return;
+  }
+  for (unsigned int i = 0; i < funcDecl.getNumParams(); ++i) {
+    const clang::ParmVarDecl *parmDecl = funcDecl.getParamDecl(i);
+    for (const auto *countIndexAttr : parmDecl->specific_attrs<clang::CountIndexAttr>()) {
+      if (countIndexAttr->index_size() > 0) {
+        continue;  // boundary attrs with index args are only marked function pointers
+      }
+      unsigned int lenIdx = countIndexAttr->getLenVarIndex().getASTIndex();
+      ProcessBoundaryLenExprInFunc(allocator, funcDecl, i, astFunc, lenIdx, true);
+    }
+    for (const auto *byteCountIndexAttr : parmDecl->specific_attrs<clang::ByteCountIndexAttr>()) {
+      if (byteCountIndexAttr->index_size() > 0) {
+        continue;  // boundary attrs with index args are only marked function pointers
+      }
+      unsigned int lenIdx = byteCountIndexAttr->getLenVarIndex().getASTIndex();
+      ProcessBoundaryLenExprInFunc(allocator, funcDecl, i, astFunc, lenIdx, false);
+    }
+  }
+}
+
+void ASTParser::ProcessBoundaryVarAttrs(MapleAllocator &allocator, const clang::VarDecl &varDecl, ASTVar &astVar) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return;
+  }
+  for (const auto *countAttr : varDecl.specific_attrs<clang::CountAttr>()) {
+    clang::Expr *expr = countAttr->getLenExpr();
+    ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+    if (lenExpr == nullptr) {
+      continue;
+    }
+    if (countAttr->index_size() > 0) {
+      continue;  // boundary attrs with index args are only marked function pointers
+    }
+    ProcessBoundaryLenExprInVar(allocator, astVar, varDecl, lenExpr, true);
+  }
+  for (const auto *byteCountAttr : varDecl.specific_attrs<clang::ByteCountAttr>()) {
+    clang::Expr *expr = byteCountAttr->getLenExpr();
+    ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+    if (lenExpr == nullptr) {
+      continue;
+    }
+    if (byteCountAttr->index_size() > 0) {
+      continue;  // boundary attrs with index args are only marked function pointers
+    }
+    ProcessBoundaryLenExprInVar(allocator, astVar, varDecl, lenExpr, false);
+  }
+}
+
+void ASTParser::ProcessBoundaryFuncPtrAttrs(MapleAllocator &allocator, const clang::ValueDecl &valueDecl,
+                                            ASTDecl &astDecl) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return;
+  }
+  const MIRFuncType *funcType = FEUtils::GetFuncPtrType(*astDecl.GetTypeDesc().front());
+  if (funcType == nullptr || !valueDecl.getType()->isFunctionPointerType()) {
+    return;
+  }
+  clang::QualType qualType = valueDecl.getType()->getPointeeType();
+  const clang::FunctionType *clangFuncType = qualType->getAs<clang::FunctionType>();
+  if (clangFuncType == nullptr) {
+    return;
+  }
+  const clang::FunctionProtoType *proto = llvm::dyn_cast<clang::FunctionProtoType>(clangFuncType);
+  if (proto == nullptr) {
+    return;
+  }
+  std::vector<TypeAttrs> attrsVec = funcType->GetParamAttrsList();
+  TypeAttrs retAttr = funcType->GetRetAttrs();
+  bool isUpdated = false;
+  for (const auto *countAttr : valueDecl.specific_attrs<clang::CountAttr>()) {
+    if (ProcessBoundaryFuncPtrAttrsForParams(countAttr, allocator, *funcType, *proto, attrsVec)) {
+      isUpdated = true;
+    }
+  }
+  for (const auto *byteCountAttr : valueDecl.specific_attrs<clang::ByteCountAttr>()) {
+    if (ProcessBoundaryFuncPtrAttrsForParams(byteCountAttr, allocator, *funcType, *proto, attrsVec)) {
+      isUpdated = true;
+    }
+  }
+  for (const auto *returnsCountAttr : valueDecl.specific_attrs<clang::ReturnsCountAttr>()) {
+    if (ProcessBoundaryFuncPtrAttrsForRet(returnsCountAttr, allocator, *funcType, *clangFuncType, retAttr)) {
+      isUpdated = true;
+    }
+  }
+  for (const auto *returnsByteCountAttr : valueDecl.specific_attrs<clang::ReturnsByteCountAttr>()) {
+    if (ProcessBoundaryFuncPtrAttrsForRet(returnsByteCountAttr, allocator, *funcType, *clangFuncType, retAttr)) {
+      isUpdated = true;
+    }
+  }
+  if (isUpdated) {
+    MIRType *newFuncType = GlobalTables::GetTypeTable().GetOrCreateFunctionType(
+        funcType->GetRetTyIdx(), funcType->GetParamTypeList(), attrsVec, funcType->IsVarargs(), retAttr);
+    astDecl.SetTypeDesc(MapleVector<MIRType*>({GlobalTables::GetTypeTable().GetOrCreatePointerType(
+        *GlobalTables::GetTypeTable().GetOrCreatePointerType(*newFuncType))}, allocator.Adapter()));
+  }
+  ProcessBoundaryFuncPtrAttrsByIndex(allocator, valueDecl, astDecl, *funcType);
+}
+
+template <typename T>
+bool ASTParser::ProcessBoundaryFuncPtrAttrsForParams(T *attr, MapleAllocator &allocator, const MIRFuncType &funcType,
+                                                     const clang::FunctionProtoType &proto,
+                                                     std::vector<TypeAttrs> &attrsVec) {
+  bool isUpdated = false;
+  clang::Expr *expr = attr->getLenExpr();
+  ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+  if (attr->index_size() == 0 || lenExpr == nullptr) {
+    return isUpdated;
+  }
+  std::vector<TyIdx> typesVec = funcType.GetParamTypeList();
+  for (const clang::ParamIdx &paramIdx : attr->index()) {
+    unsigned int idx = paramIdx.getASTIndex();
+    if (idx >= attrsVec.size() || idx >= typesVec.size()) {
+      continue;
+    }
+    MIRType *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typesVec[idx]);
+    ASTVar *tmpDecl = ASTDeclsBuilder::ASTVarBuilder(allocator, MapleString("", allocator.GetMemPool()), "tmpVar",
+        MapleVector<MIRType*>({ptrType}, allocator.Adapter()), GenericAttrs());
+    bool isByte = std::is_same<typename std::decay<T>::type, clang::ByteCountAttr>::value;
+    ProcessBoundaryLenExprInVar(allocator, *tmpDecl, proto.getParamType(idx), lenExpr, !isByte);
+    ENCChecker::InsertBoundaryInAtts(attrsVec[idx], tmpDecl->GetBoundaryInfo());
+    isUpdated = true;
+  }
+  return isUpdated;
+}
+
+template <typename T>
+bool ASTParser::ProcessBoundaryFuncPtrAttrsForRet(T *attr, MapleAllocator &allocator, const MIRFuncType &funcType,
+                                                  const clang::FunctionType &clangFuncType, TypeAttrs &retAttr) {
+  clang::Expr *expr = attr->getLenExpr();
+  ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+  if (lenExpr == nullptr) {
+    return false;
+  }
+  MIRType *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType.GetRetTyIdx());
+  ASTVar *tmpRetDecl = ASTDeclsBuilder::ASTVarBuilder(allocator, MapleString("", allocator.GetMemPool()),
+      "tmpRetVar", MapleVector<MIRType*>({ptrType}, allocator.Adapter()), GenericAttrs());
+  bool isByte = std::is_same<typename std::decay<T>::type, clang::ReturnsByteCountAttr>::value;
+  ProcessBoundaryLenExprInVar(allocator, *tmpRetDecl, clangFuncType.getReturnType(), lenExpr, !isByte);
+  ENCChecker::InsertBoundaryInAtts(retAttr, tmpRetDecl->GetBoundaryInfo());
+  return true;
+}
+
+void ASTParser::ProcessBoundaryFuncPtrAttrsByIndex(MapleAllocator &allocator, const clang::ValueDecl &valueDecl,
+                                                   ASTDecl &astDecl, const MIRFuncType &funcType) {
+  std::vector<TypeAttrs> attrsVec = funcType.GetParamAttrsList();
+  TypeAttrs retAttr = funcType.GetRetAttrs();
+  bool isUpdated = false;
+  for (const auto *countAttr : valueDecl.specific_attrs<clang::CountIndexAttr>()) {
+    if (ProcessBoundaryFuncPtrAttrsByIndexForParams(countAttr, astDecl, funcType, attrsVec)) {
+      isUpdated = true;
+    }
+  }
+  for (const auto *byteCountAttr : valueDecl.specific_attrs<clang::ByteCountIndexAttr>()) {
+    if (ProcessBoundaryFuncPtrAttrsByIndexForParams(byteCountAttr, astDecl, funcType, attrsVec)) {
+      isUpdated = true;
+    }
+  }
+  for (const auto *returnsCountIndexAttr : valueDecl.specific_attrs<clang::ReturnsCountIndexAttr>()) {
+    unsigned int lenIdx = returnsCountIndexAttr->getLenVarIndex().getASTIndex();
+    retAttr.GetAttrBoundary().SetLenParamIdx(static_cast<int8>(lenIdx));
+    isUpdated = true;
+  }
+  for (const auto *returnsByteCountIndexAttr : valueDecl.specific_attrs<clang::ReturnsByteCountIndexAttr>()) {
+    unsigned int lenIdx = returnsByteCountIndexAttr->getLenVarIndex().getASTIndex();
+    retAttr.GetAttrBoundary().SetLenParamIdx(static_cast<int8>(lenIdx));
+    retAttr.GetAttrBoundary().SetIsBytedLen(true);
+    isUpdated = true;
+  }
+  if (isUpdated) {
+    MIRType *newFuncType = GlobalTables::GetTypeTable().GetOrCreateFunctionType(
+        funcType.GetRetTyIdx(), funcType.GetParamTypeList(), attrsVec, funcType.IsVarargs(), retAttr);
+    astDecl.SetTypeDesc(MapleVector<MIRType*>({GlobalTables::GetTypeTable().GetOrCreatePointerType(
+        *GlobalTables::GetTypeTable().GetOrCreatePointerType(*newFuncType))}, allocator.Adapter()));
+  }
+}
+
+template <typename T>
+bool ASTParser::ProcessBoundaryFuncPtrAttrsByIndexForParams(T *attr, ASTDecl &astDecl, const MIRFuncType &funcType,
+                                                            std::vector<TypeAttrs> &attrsVec) const {
+  bool isUpdated = false;
+  std::vector<TyIdx> typesVec = funcType.GetParamTypeList();
+  unsigned int lenIdx = attr->getLenVarIndex().getASTIndex();
+  if (attr->index_size() == 0 || lenIdx >= typesVec.size()) {
+    return isUpdated;
+  }
+  MIRType *lenType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typesVec[lenIdx]);
+  if (lenType == nullptr || !FEUtils::IsInteger(lenType->GetPrimType())) {
+    FE_ERR(kLncErr, astDecl.GetSrcLoc(), "The boundary length var by the %s argument is not an integer type",
+           ENCChecker::GetNthStr(lenIdx).c_str());
+    return isUpdated;
+  }
+  for (const clang::ParamIdx &paramIdx : attr->index()) {
+    unsigned int idx = paramIdx.getASTIndex();
+    if (idx >= attrsVec.size() || idx >= typesVec.size()) {
+      continue;
+    }
+    attrsVec[idx].GetAttrBoundary().SetLenParamIdx(static_cast<int8>(lenIdx));
+    if (std::is_same<typename std::decay<T>::type, clang::ByteCountIndexAttr>::value) {
+      attrsVec[idx].GetAttrBoundary().SetIsBytedLen(true);
+    }
+    isUpdated = true;
+  }
+  return isUpdated;
+}
+
+void ASTParser::ProcessBoundaryFieldAttrs(MapleAllocator &allocator, const ASTStruct &structDecl,
+                                          const clang::RecordDecl &recDecl) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return;
+  }
+  const auto *declContext = llvm::dyn_cast<clang::DeclContext>(&recDecl);
+  if (declContext == nullptr) {
+    return;
+  }
+  for (auto *loadDecl : declContext->decls()) {
+    if (loadDecl == nullptr) {
+      continue;
+    }
+    auto *fieldDecl = llvm::dyn_cast<clang::FieldDecl>(loadDecl);
+    if (fieldDecl == nullptr) {
+      continue;
+    }
+    ASTDecl *astField = ASTDeclsBuilder::GetASTDecl(fieldDecl->getID());
+    if (astField == nullptr) {
+      continue;
+    }
+    for (const auto *countAttr : fieldDecl->specific_attrs<clang::CountAttr>()) {
+      clang::Expr *expr = countAttr->getLenExpr();
+      ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+      if (lenExpr == nullptr) {
+        continue;
+      }
+      if (countAttr->index_size() == 0) {
+        ProcessBoundaryLenExprInField(allocator, *astField, structDecl, fieldDecl->getType(), lenExpr, true);
+      }
+    }
+    for (const auto *byteCountAttr : fieldDecl->specific_attrs<clang::ByteCountAttr>()) {
+      clang::Expr *expr = byteCountAttr->getLenExpr();
+      ASTExpr *lenExpr = ProcessExpr(allocator, expr);
+      if (lenExpr == nullptr) {
+        continue;
+      }
+      if (byteCountAttr->index_size() == 0) {
+        ProcessBoundaryLenExprInField(allocator, *astField, structDecl, fieldDecl->getType(), lenExpr, false);
+      }
+    }
+  }
+}
+
+// ---------------------------
+// process boundary length expr in attr
+// ---------------------------
+void ASTParser::ProcessBoundaryLenExpr(MapleAllocator &allocator, ASTDecl &ptrDecl, const clang::QualType &qualType,
+                                       const std::function<ASTExpr* ()> &getLenExprFromStringLiteral,
+                                       ASTExpr *lenExpr, bool isSize) {
+  if (!qualType->isPointerType()) {
+    FE_ERR(kLncErr, lenExpr->GetSrcLoc(), "The variable modified by the boundary attribute should be a pointer type");
+    return;
+  }
+  // Check lenExpr kind from: length stringLiteral or constant value/var expression
+  if (lenExpr->GetASTOp() == kASTStringLiteral) {
+    // boundary length stringLiteral -> real length decl expr
+    lenExpr = getLenExprFromStringLiteral();
+    if (lenExpr == nullptr) {
+      return;
+    }
+  } else if (lenExpr->GetType() == nullptr || !FEUtils::IsInteger(lenExpr->GetType()->GetPrimType())) {
+    FE_ERR(kLncErr, lenExpr->GetSrcLoc(), "The boundary length expr is not an integer type");
+    return;
+  }
+  if (isSize) {
+    // The type size can only be obtained from ClangDecl instead of ASTDecl,
+    // because the field of mir struct type has not yet been initialized at this time
+    uint32 lenSize = GetSizeFromQualType(qualType->getPointeeType());
+    MIRType *pointedType = static_cast<MIRPtrType*>(ptrDecl.GetTypeDesc().front())->GetPointedType();
+    if (pointedType->GetPrimType() == PTY_f64) {
+      lenSize = 8; // 8 is f64 byte num, because now f128 also cvt to f64
+    }
+    lenExpr = GetAddrShiftExpr(allocator, *lenExpr, lenSize);
+  }
+  ptrDecl.SetBoundaryLenExpr(lenExpr);
+  ptrDecl.SetIsBytedLen(!isSize);
+}
+
+void ENCChecker::CheckLenExpr(const ASTExpr &lenExpr, const std::list<UniqueFEIRStmt> &nullstmts) {
+  for (const auto &stmt : nullstmts) {
+    bool isAssertStmt = false;
+    if (stmt->GetKind() == kStmtNary) {
+      FEIRStmtNary *nary = static_cast<FEIRStmtNary*>(stmt.get());
+      if (kOpcodeInfo.IsAssertBoundary(nary->GetOP()) || kOpcodeInfo.IsAssertNonnull(nary->GetOP())) {
+        isAssertStmt = true;
+      }
+    }
+    if (!isAssertStmt) {
+      FE_ERR(kLncErr, lenExpr.GetSrcLoc(), "The boundary length expr containing statement is invalid");
+      break;
+    }
+  }
+}
+
+void ASTParser::ProcessBoundaryLenExprInFunc(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                             unsigned int idx, ASTFunc &astFunc, ASTExpr *lenExpr, bool isSize) {
+  ASTDecl *ptrDecl = nullptr;
+  clang::QualType qualType;
+  if (idx == static_cast<unsigned int>(-1)) {  // return boundary attr
+    ptrDecl = &astFunc;
+    qualType = funcDecl.getReturnType();
+  } else if (idx < astFunc.GetParamDecls().size()) {
+    ptrDecl = astFunc.GetParamDecls()[idx];
+    qualType = funcDecl.getParamDecl(idx)->getType();
+  } else {
+    FE_ERR(kLncErr, lenExpr->GetSrcLoc(), "The parameter annotated boundary attr [the %s argument] is not found"
+           "in the function [%s]", ENCChecker::GetNthStr(idx).c_str(), astFunc.GetName().c_str());
+    return;
+  }
+  // parameter stringLiteral -> real parameter decl
+  auto getLenExprFromStringLiteral = [&allocator, &astFunc, lenExpr, ptrDecl]() -> ASTExpr* {
+    ASTStringLiteral *strExpr = static_cast<ASTStringLiteral*>(lenExpr);
+    std::string lenName(strExpr->GetCodeUnits().begin(), strExpr->GetCodeUnits().end());
+    for (size_t i = 0; i < astFunc.GetParamDecls().size(); ++i) {
+      if (astFunc.GetParamDecls()[i]->GetName() != lenName) {
+        continue;
+      }
+      MIRType *lenType = astFunc.GetParamDecls()[i]->GetTypeDesc().front();
+      if (lenType == nullptr || !FEUtils::IsInteger(lenType->GetPrimType())) {
+        FE_ERR(kLncErr, lenExpr->GetSrcLoc(), "The parameter [%s] specified as boundary length var is not an integer "
+               "type in the function [%s]", lenName.c_str(), astFunc.GetName().c_str());
+        return nullptr;
+      }
+      ASTDeclRefExpr *lenRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+      lenRefExpr->SetASTDecl(astFunc.GetParamDecls()[i]);
+      lenRefExpr->SetType(astFunc.GetParamDecls()[i]->GetTypeDesc().front());
+      ptrDecl->SetBoundaryLenParamIdx(static_cast<int8>(i));
+      return lenRefExpr;
+    }
+    FE_ERR(kLncErr, lenExpr->GetSrcLoc(), "The parameter [%s] specified as boundary length var is not found "
+           "in the function [%s]", lenName.c_str(), astFunc.GetName().c_str());
+    return nullptr;
+  };
+  ProcessBoundaryLenExpr(allocator, *ptrDecl, qualType, getLenExprFromStringLiteral, lenExpr, isSize);
+}
+
+void ASTParser::ProcessBoundaryLenExprInFunc(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl,
+                                             unsigned int idx, ASTFunc &astFunc, unsigned int lenIdx, bool isSize) {
+  if (lenIdx > astFunc.GetParamDecls().size()) {
+    FE_ERR(kLncErr, astFunc.GetSrcLoc(), "The %s parameter specified as boundary length var is not found "
+           "in the function [%s]", ENCChecker::GetNthStr(lenIdx).c_str(), astFunc.GetName().c_str());
+    return;
+  }
+  ASTDecl *lenDecl = astFunc.GetParamDecls()[lenIdx];
+  MIRType *lenType = lenDecl->GetTypeDesc().front();
+  if (lenType == nullptr || !FEUtils::IsInteger(lenType->GetPrimType())) {
+    FE_ERR(kLncErr, astFunc.GetSrcLoc(), "The %s parameter specified as boundary length var is not an integer type "
+           "in the function [%s]", ENCChecker::GetNthStr(lenIdx).c_str(), astFunc.GetName().c_str());
+    return;
+  }
+  ASTDeclRefExpr *lenRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  lenRefExpr->SetASTDecl(lenDecl);
+  lenRefExpr->SetType(lenType);
+
+  ASTDecl *ptrDecl = nullptr;
+  if (idx == static_cast<unsigned int>(-1)) {  // return boundary attr
+    ptrDecl = &astFunc;
+  } else if (idx < astFunc.GetParamDecls().size()) {
+    ptrDecl = astFunc.GetParamDecls()[idx];
+  } else {
+    FE_ERR(kLncErr, astFunc.GetSrcLoc(), "The %s parameter annotated boundary attr is not found in the function [%s]",
+           ENCChecker::GetNthStr(idx).c_str(), astFunc.GetName().c_str());
+    return;
+  }
+  ptrDecl->SetBoundaryLenParamIdx(static_cast<int8>(lenIdx));
+  ProcessBoundaryLenExprInFunc(allocator, funcDecl, idx, astFunc, lenRefExpr, isSize);
+}
+
+void ASTParser::ProcessBoundaryLenExprInVar(MapleAllocator &allocator, ASTDecl &ptrDecl,
+                                            const clang::VarDecl &varDecl, ASTExpr *lenExpr, bool isSize) {
+  if (!varDecl.isLocalVarDeclOrParm()) {
+    ASTDecl *lenDecl = lenExpr->GetASTDecl();
+    if (lenDecl != nullptr && FEUtils::IsInteger(lenDecl->GetTypeDesc().front()->GetPrimType())) {
+      lenDecl->SetAttr(GENATTR_final_boundary_size);
+    }
+  }
+  ProcessBoundaryLenExprInVar(allocator, ptrDecl, varDecl.getType(), lenExpr, isSize);
+}
+
+void ASTParser::ProcessBoundaryLenExprInVar(MapleAllocator &allocator, ASTDecl &ptrDecl,
+                                            const clang::QualType &qualType, ASTExpr *lenExpr, bool isSize) {
+  // The StringLiteral is not allowed to use as boundary length of var
+  auto getLenExprFromStringLiteral = [lenExpr]() -> ASTExpr* {
+    FE_ERR(kLncErr, lenExpr->GetSrcLoc(), "The StringLiteral is not allowed to use as boundary length of var");
+    return nullptr;
+  };
+  ProcessBoundaryLenExpr(allocator, ptrDecl, qualType, getLenExprFromStringLiteral, lenExpr, isSize);
+}
+
+void ASTParser::ProcessBoundaryLenExprInField(MapleAllocator &allocator, ASTDecl &ptrDecl, const ASTStruct &structDecl,
+                                              const clang::QualType &qualType, ASTExpr *lenExpr, bool isSize) {
+  // boundary length stringLiteral in field -> real field decl
+  auto getLenExprFromStringLiteral = [&allocator, &structDecl, lenExpr]() -> ASTExpr* {
+    ASTStringLiteral *strExpr = static_cast<ASTStringLiteral*>(lenExpr);
+    std::string lenName(strExpr->GetCodeUnits().begin(), strExpr->GetCodeUnits().end());
+    for (ASTField *fieldDecl: structDecl.GetFields()) {
+      if (lenName != fieldDecl->GetName()) {
+        continue;
+      }
+      MIRType *lenType = fieldDecl->GetTypeDesc().front();
+      if (lenType == nullptr || !FEUtils::IsInteger(lenType->GetPrimType())) {
+        FE_ERR(kLncErr, lenExpr->GetSrcLoc(), "The field [%s] specified as boundary length var is not an integer type "
+               "in the struct [%s]", lenName.c_str(), structDecl.GetName().c_str());
+        return nullptr;
+      }
+      fieldDecl->SetAttr(GENATTR_final_boundary_size);
+      ASTDeclRefExpr *lenRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+      lenRefExpr->SetASTDecl(fieldDecl);
+      lenRefExpr->SetType(fieldDecl->GetTypeDesc().front());
+      return lenRefExpr;
+    }
+    FE_ERR(kLncErr, lenExpr->GetSrcLoc(), "The StringLiteral [%s] as boundary length var is not found "
+           "in the struct [%s]", lenName.c_str(), structDecl.GetName().c_str());
+    return nullptr;
+  };
+  ProcessBoundaryLenExpr(allocator, ptrDecl, qualType, getLenExprFromStringLiteral, lenExpr, isSize);
+}
+
+// ---------------------------
+// process boundary var
+// ---------------------------
+UniqueFEIRExpr ENCChecker::FindBaseExprInPointerOperation(const UniqueFEIRExpr &expr, bool isIncludingAddrof) {
+  if (expr == nullptr) {
+    return nullptr;
+  }
+  UniqueFEIRExpr baseExpr = nullptr;
+  if (expr->GetKind() == kExprBinary) {
+    FEIRExprBinary *binExpr = static_cast<FEIRExprBinary*>(expr.get());
+    if (binExpr->IsComparative()) {
+      return nullptr;
+    }
+    baseExpr = FindBaseExprInPointerOperation(binExpr->GetOpnd0());
+    if (baseExpr != nullptr) {
+      return baseExpr;
+    }
+    baseExpr = FindBaseExprInPointerOperation(binExpr->GetOpnd1());
+    if (baseExpr != nullptr) {
+      return baseExpr;
+    }
+  }
+  if (expr->GetKind() == kExprUnary) {
+    FEIRExprUnary *cvtExpr = static_cast<FEIRExprUnary*>(expr.get());
+    baseExpr = FindBaseExprInPointerOperation(cvtExpr->GetOpnd());
+  } else if (expr->GetKind() == kExprAddrofArray) {
+    FEIRExprAddrofArray *arrExpr = static_cast<FEIRExprAddrofArray*>(expr.get());
+    baseExpr = FindBaseExprInPointerOperation(arrExpr->GetExprArray());
+  } else if ((expr->GetKind() == kExprDRead && expr->GetPrimType() == PTY_ptr) ||
+      (expr->GetKind() == kExprIRead && expr->GetPrimType() == PTY_ptr && expr->GetFieldID() != 0) ||
+      GetArrayTypeFromExpr(expr) != nullptr) {
+    baseExpr = expr->Clone();
+  } else if (isIncludingAddrof && GetTypeFromAddrExpr(expr) != nullptr) {  // addrof as 1-sized array
+    baseExpr = expr->Clone();
+  }
+  return baseExpr;
+}
+
+MIRType *ENCChecker::GetTypeFromAddrExpr(const UniqueFEIRExpr &expr) {
+  if (expr->GetKind() == kExprAddrofVar) {
+    MIRType *type = expr->GetVarUses().front()->GetType()->GenerateMIRTypeAuto();
+    if (expr->GetFieldID() == 0) {
+      return type;
+    } else {
+      CHECK_FATAL(type->IsStructType(), "basetype must be StructType");
+      FieldID fieldID = expr->GetFieldID();
+      FieldPair fieldPair = static_cast<MIRStructType*>(type)->TraverseToFieldRef(fieldID);
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+    }
+  } else if (expr->GetKind() == kExprIAddrof) {
+    FEIRExprIAddrof *iaddrof = static_cast<FEIRExprIAddrof*>(expr.get());
+    MIRType *pointerType = iaddrof->GetClonedPtrType()->GenerateMIRTypeAuto();
+    CHECK_FATAL(pointerType->IsMIRPtrType(), "Must be ptr type!");
+    MIRType *baseType = static_cast<MIRPtrType*>(pointerType)->GetPointedType();
+    CHECK_FATAL(baseType->IsStructType(), "basetype must be StructType");
+    FieldID fieldID = iaddrof->GetFieldID();
+    FieldPair fieldPair = static_cast<MIRStructType*>(baseType)->TraverseToFieldRef(fieldID);
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+  } else {
+    return nullptr;
+  }
+}
+
+MIRType *ENCChecker::GetArrayTypeFromExpr(const UniqueFEIRExpr &expr) {
+  MIRType *arrType = GetTypeFromAddrExpr(expr);
+  if (arrType != nullptr && arrType->GetKind() == kTypeArray &&
+      !static_cast<MIRArrayType*>(arrType)->GetTypeAttrs().GetAttr(ATTR_incomplete_array)) {
+    return arrType;
+  }
+  if (expr->GetKind() == kExprAddrof) {  // local char* value size
+    auto *constArr = static_cast<FEIRExprAddrofConstArray*>(expr.get());
+    return GlobalTables::GetTypeTable().GetOrCreateArrayType(
+        *constArr->GetElemType(), constArr->GetStringLiteralSize() + 1);  // including the end character with string
+  } else if (expr->GetKind() == kExprDRead || expr->GetKind() == kExprIRead) {  // global const char* value size
+    MIRType *type = expr->GetType()->GenerateMIRTypeAuto();
+    if (type->IsMIRPtrType() && static_cast<MIRPtrType*>(type)->GetPointedType()->GetPrimType() == PTY_u8) {
+      MIRConst *cst = GetMIRConstFromExpr(expr);
+      if (cst != nullptr && cst->GetKind() == kConstStrConst) {
+        size_t size = GlobalTables::GetUStrTable().GetStringFromStrIdx(
+            static_cast<MIRStrConst*>(cst)->GetValue()).size() + 1;  // including the end character with string
+        return GlobalTables::GetTypeTable().GetOrCreateArrayType(
+            *GlobalTables::GetTypeTable().GetUInt8(), static_cast<uint32>(size));
+      }
+    }
+    return nullptr;
+  }
+  return nullptr;
+}
+
+MIRConst *ENCChecker::GetMIRConstFromExpr(const UniqueFEIRExpr &expr) {
+  if (expr == nullptr || expr->GetVarUses().size() != 1) {
+    return nullptr;
+  }
+  MIRSymbol *sym = expr->GetVarUses().front()->GenerateMIRSymbol(FEManager::GetMIRBuilder());
+  if (!sym->IsGlobal() || !sym->GetAttr(ATTR_const) || sym->GetKonst() == nullptr) {  // const global
+    return nullptr;
+  }
+  if (expr->GetKind() == kExprDRead || expr->GetKind() == kExprAddrofVar) {
+    if (expr->GetFieldID() == 0) {
+      return sym->GetKonst();
+    } else if (expr->GetFieldID() != 0 && sym->GetKonst()->GetKind() == kConstAggConst) {
+      MIRAggConst *aggConst = static_cast<MIRAggConst*>(sym->GetKonst());
+      FieldID tmpID = expr->GetFieldID();
+      MIRConst *cst = FEUtils::TraverseToMIRConst(aggConst, *static_cast<MIRStructType*>(sym->GetType()), tmpID);
+      return cst;
+    }
+    return nullptr;
+  } else if (expr->GetKind() == kExprIRead) {
+    auto *iread = static_cast<FEIRExprIRead*>(expr.get());
+    MIRConst *cst = GetMIRConstFromExpr(iread->GetClonedOpnd());
+    if (expr->GetFieldID() != 0 && cst != nullptr && sym->GetKonst()->GetKind() == kConstAggConst) {
+      MIRType *pointType = static_cast<MIRPtrType*>(iread->GetClonedPtrType()->GenerateMIRTypeAuto())->GetPointedType();
+      FieldID tmpID = expr->GetFieldID();
+      cst = FEUtils::TraverseToMIRConst(static_cast<MIRAggConst*>(cst), *static_cast<MIRStructType*>(pointType), tmpID);
+    }
+    return cst;
+  } else if (expr->GetKind() == kExprAddrofArray) {
+    FEIRExprAddrofArray *arrExpr = static_cast<FEIRExprAddrofArray*>(expr.get());
+    MIRConst *cst = GetMIRConstFromExpr(arrExpr->GetExprArray());
+    if (cst == nullptr || cst->GetKind() != kConstAggConst) {
+      return nullptr;
+    }
+    for (const auto &idxExpr : arrExpr->GetExprIndexs()) {
+      MIRAggConst *aggConst = static_cast<MIRAggConst*>(cst);
+      if (idxExpr->GetKind() != kExprConst) {
+        return nullptr;
+      }
+      uint64 idx = static_cast<FEIRExprConst*>(idxExpr.get())->GetValue().u64;
+      if (idx >= aggConst->GetConstVec().size()) {
+        return nullptr;
+      }
+      cst = aggConst->GetConstVecItem(idx);
+    }
+    return cst;
+  }
+  return nullptr;
+}
+
+void ENCChecker::AssignBoundaryVar(MIRBuilder &mirBuilder, const UniqueFEIRExpr &dstExpr, const UniqueFEIRExpr &srcExpr,
+                                   const UniqueFEIRExpr &lRealLenExpr, std::list<StmtNode*> &ans) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() ||
+      srcExpr->GetPrimType() != PTY_ptr || dstExpr->GetPrimType() != PTY_ptr) {
+    return;
+  }
+  if (lRealLenExpr == nullptr && IsGlobalVarInExpr(dstExpr)) {
+    return;  // skip boundary assignment for global var whithout boundary attr
+  }
+  // Avoid inserting redundant boundary vars
+  const std::string prefix = "_boundary.";
+  if (dstExpr->GetKind() == kExprDRead &&
+      static_cast<FEIRExprDRead*>(dstExpr.get())->GetVar()->GetNameRaw().compare(0, prefix.size(), prefix) == 0) {
+    return;
+  }
+  MIRFunction *curFunction = mirBuilder.GetCurrentFunctionNotNull();
+  FEFunction &curFEFunction = FEManager::GetCurrentFEFunction();
+  UniqueFEIRExpr baseExpr = FindBaseExprInPointerOperation(srcExpr, true);
+  if (baseExpr == nullptr) {
+    return;
+  }
+  if (dstExpr->Hash() == baseExpr->Hash()) {  // skip self-assignment, e.g. p++;
+    return;
+  }
+  // Check if the l-value has a boundary var
+  std::pair<StIdx, StIdx> lBoundaryVarStIdx = std::make_pair(StIdx(0), StIdx(0));
+  auto lIt = curFEFunction.GetBoundaryMap().find(dstExpr->Hash());
+  if (lIt != curFEFunction.GetBoundaryMap().end()) {  // The boundary var exists on the l-value
+    lBoundaryVarStIdx = lIt->second;
+  } else if (lRealLenExpr != nullptr) {  // init boundary in func body if a field/global var l-value with boundary attr
+    std::list<UniqueFEIRStmt> stmts;
+    lBoundaryVarStIdx = InitBoundaryVar(*curFunction, dstExpr, lRealLenExpr->Clone(), stmts);
+    for (const auto &stmt : stmts) {
+      std::list<StmtNode*> stmtNodes = stmt->GenMIRStmts(mirBuilder);
+      for (auto stmtNode : stmtNodes) {
+        curFunction->GetBody()->InsertFirst(stmtNode);
+      }
+    }
+  }
+  // Check if the r-value has a boundary var or an array or a global var/field with boundary attr
+  std::pair<StIdx, StIdx> rBoundaryVarStIdx = std::make_pair(StIdx(0), StIdx(0));
+  MIRType *arrType = nullptr;
+  UniqueFEIRExpr rRealLenExpr = nullptr;
+  auto rIt = curFEFunction.GetBoundaryMap().find(baseExpr->Hash());
+  if (rIt != curFEFunction.GetBoundaryMap().end()) {  // Assgin when the boundary var exists on the r-value
+    rBoundaryVarStIdx = rIt->second;
+  } else {
+    arrType = GetArrayTypeFromExpr(baseExpr);
+    if (arrType == nullptr) {
+      rRealLenExpr = GetGlobalOrFieldLenExprInExpr(mirBuilder, baseExpr);
+    }
+  }
+  // insert L-value bounary and assign boundary var
+  // when r-value with a boundary var, or with a sized array, a global var/field r-value with boundary attr
+  bool isSizedArray = (arrType != nullptr && arrType->GetSize() > 0);
+  if (lBoundaryVarStIdx.first == StIdx(0) &&
+      (rBoundaryVarStIdx.first != StIdx(0) || isSizedArray || rRealLenExpr != nullptr)) {
+    lBoundaryVarStIdx = ENCChecker::InsertBoundaryVar(mirBuilder, dstExpr);
+  }
+  if (lBoundaryVarStIdx.first != StIdx(0)) {
+    MIRSymbol *lLowerSym = curFunction->GetLocalOrGlobalSymbol(lBoundaryVarStIdx.first);
+    CHECK_NULL_FATAL(lLowerSym);
+    MIRSymbol *lUpperSym = curFunction->GetLocalOrGlobalSymbol(lBoundaryVarStIdx.second);
+    CHECK_NULL_FATAL(lUpperSym);
+    StmtNode *lowerStmt = nullptr;
+    StmtNode *upperStmt = nullptr;
+    if (rBoundaryVarStIdx.first != StIdx(0)) {
+      MIRSymbol *rLowerSym = curFunction->GetLocalOrGlobalSymbol(rBoundaryVarStIdx.first);
+      CHECK_NULL_FATAL(rLowerSym);
+      lowerStmt = mirBuilder.CreateStmtDassign(*lLowerSym, 0, mirBuilder.CreateExprDread(*rLowerSym));
+
+      MIRSymbol *rUpperSym = curFunction->GetLocalOrGlobalSymbol(rBoundaryVarStIdx.second);
+      CHECK_NULL_FATAL(rUpperSym);
+      upperStmt = mirBuilder.CreateStmtDassign(*lUpperSym, 0, mirBuilder.CreateExprDread(*rUpperSym));
+    } else if (isSizedArray) {
+      lowerStmt = mirBuilder.CreateStmtDassign(*lLowerSym, 0, baseExpr->GenMIRNode(mirBuilder));
+      UniqueFEIRExpr binExpr = FEIRBuilder::CreateExprBinary(
+          OP_add, baseExpr->Clone(), std::make_unique<FEIRExprConst>(arrType->GetSize(), PTY_ptr));
+      upperStmt = mirBuilder.CreateStmtDassign(*lUpperSym, 0, binExpr->GenMIRNode(mirBuilder));
+    } else if (rRealLenExpr != nullptr) {
+      lowerStmt = mirBuilder.CreateStmtDassign(*lLowerSym, 0, baseExpr->GenMIRNode(mirBuilder));
+      UniqueFEIRExpr binExpr = FEIRBuilder::CreateExprBinary(OP_add, baseExpr->Clone(), rRealLenExpr->Clone());
+      upperStmt = mirBuilder.CreateStmtDassign(*lUpperSym, 0, binExpr->GenMIRNode(mirBuilder));
+    } else {
+      MIRType *addrofType = GetTypeFromAddrExpr(baseExpr);
+      if (addrofType != nullptr) {  // addrof as 1-sized array, if l-value with boundary and r-value is addrof non-array
+        lowerStmt = mirBuilder.CreateStmtDassign(*lLowerSym, 0, baseExpr->GenMIRNode(mirBuilder));
+        UniqueFEIRExpr binExpr = FEIRBuilder::CreateExprBinary(
+            OP_add, baseExpr->Clone(), std::make_unique<FEIRExprConst>(addrofType->GetSize(), PTY_ptr));
+        upperStmt = mirBuilder.CreateStmtDassign(*lUpperSym, 0, binExpr->GenMIRNode(mirBuilder));
+      } else {
+        // Insert a undef boundary r-value
+        // when there is a l-value boundary var and r-value without a boundary var
+        lowerStmt = mirBuilder.CreateStmtDassign(*lLowerSym, 0, baseExpr->GenMIRNode(mirBuilder));
+        UniqueFEIRExpr undef = std::make_unique<FEIRExprConst>(kUndefValue, PTY_ptr);
+        upperStmt = mirBuilder.CreateStmtDassign(*lUpperSym, 0, undef->GenMIRNode(mirBuilder));
+      }
+    }
+    if (lowerStmt == nullptr || upperStmt == nullptr) {
+      return;
+    }
+    if (lRealLenExpr != nullptr) {  // use l-vaule own boundary(use r-base + offset) when l-value has a boundary attr
+      BaseNode *binExpr = mirBuilder.CreateExprBinary(
+          OP_add, *lLowerSym->GetType(), srcExpr->GenMIRNode(mirBuilder), lRealLenExpr->GenMIRNode(mirBuilder));
+      upperStmt = mirBuilder.CreateStmtDassign(*lUpperSym, 0, binExpr);
+    }
+    ans.emplace_back(lowerStmt);
+    ans.emplace_back(upperStmt);
+  }
+}
+
+bool ENCChecker::IsGlobalVarInExpr(const UniqueFEIRExpr &expr) {
+  bool isGlobal = false;
+  auto vars = expr->GetVarUses();
+  if (!vars.empty() && vars.front() != nullptr) {
+    isGlobal = vars.front()->IsGlobal();
+  }
+  return isGlobal;
+}
+
+std::pair<StIdx, StIdx> ENCChecker::InsertBoundaryVar(MIRBuilder &mirBuilder, const UniqueFEIRExpr &expr) {
+  std::pair<StIdx, StIdx> boundaryVarStIdx = std::make_pair(StIdx(0), StIdx(0));
+  std::string boundaryName = GetBoundaryName(expr);
+  if (boundaryName.empty()) {
+    return boundaryVarStIdx;
+  }
+  MIRType *boundaryType = expr->GetType()->GenerateMIRTypeAuto();
+  MIRSymbol *lowerSrcSym = mirBuilder.GetOrCreateLocalDecl(boundaryName + ".lower", *boundaryType);
+  MIRSymbol *upperSrcSym = mirBuilder.GetOrCreateLocalDecl(boundaryName + ".upper", *boundaryType);
+  // assign undef val to boundary var in func body head
+  AssignUndefVal(mirBuilder, *upperSrcSym);
+  AssignUndefVal(mirBuilder, *lowerSrcSym);
+  // update BoundaryMap
+  boundaryVarStIdx = std::make_pair(lowerSrcSym->GetStIdx(), upperSrcSym->GetStIdx());
+  FEManager::GetCurrentFEFunction().SetBoundaryMap(expr->Hash(), boundaryVarStIdx);
+  return boundaryVarStIdx;
+}
+
+void ENCChecker::InsertBoundaryVar(const ASTDecl &ptrDecl, std::list<UniqueFEIRStmt> &stmts) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() ||
+      ptrDecl.GetBoundaryLenExpr() == nullptr) {
+    return;
+  }
+  // GetCurrentFunction need to be optimized when parallel features
+  MIRFunction *curFunction = FEManager::GetMIRBuilder().GetCurrentFunctionNotNull();
+  UniqueFEIRExpr lenFEExpr = ptrDecl.GetBoundaryLenExpr()->Emit2FEExpr(stmts);
+  ENCChecker::InitBoundaryVar(*curFunction, ptrDecl, std::move(lenFEExpr), stmts);
+}
+
+std::string ENCChecker::GetBoundaryName(const UniqueFEIRExpr &expr) {
+  std::string boundaryName;
+  if (expr == nullptr) {
+    return boundaryName;
+  }
+  if (expr->GetKind() == kExprDRead) {
+    const FEIRExprDRead *dread = static_cast<FEIRExprDRead*>(expr.get());
+    // Naming format for var boundary: _boundary.[varname]_[fieldID].[exprHash].lower/upper
+    boundaryName = "_boundary." + dread->GetVar()->GetNameRaw() + "." + std::to_string(expr->GetFieldID()) + "." +
+                   std::to_string(expr->Hash());
+  } else if (expr->GetKind() == kExprIRead) {
+    const FEIRExprIRead *iread = static_cast<FEIRExprIRead*>(expr.get());
+    MIRType *pointerType = iread->GetClonedPtrType()->GenerateMIRTypeAuto();
+    CHECK_FATAL(pointerType->IsMIRPtrType(), "Must be ptr type!");
+    MIRType *structType = static_cast<MIRPtrType*>(pointerType)->GetPointedType();
+    std::string structName = GlobalTables::GetStrTable().GetStringFromStrIdx(structType->GetNameStrIdx());
+    FieldID fieldID = iread->GetFieldID();
+    FieldPair rFieldPair = static_cast<MIRStructType*>(structType)->TraverseToFieldRef(fieldID);
+    std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(rFieldPair.first);
+    // Naming format for field var boundary: _boundary.[sturctname]_[fieldname].[exprHash].lower/upper
+    boundaryName = "_boundary." + structName + "_" + fieldName + "." + std::to_string(iread->Hash());
+  }
+  return boundaryName;
+}
+
+void ENCChecker::AssignUndefVal(MIRBuilder &mirBuilder, MIRSymbol &sym) {
+  if (sym.IsGlobal()) {
+    MIRIntConst *cst = FEManager::GetModule().GetMemPool()->New<MIRIntConst>(
+        kUndefValue, *GlobalTables::GetTypeTable().GetPrimType(PTY_ptr));
+    sym.SetKonst(cst);
+  } else {
+    BaseNode *undef = mirBuilder.CreateIntConst(kUndefValue, PTY_ptr);
+    StmtNode *assign = mirBuilder.CreateStmtDassign(sym, 0, undef);
+    MIRFunction *curFunction = mirBuilder.GetCurrentFunctionNotNull();
+    curFunction->GetBody()->InsertFirst(assign);
+  }
+}
+
+void ENCChecker::InitBoundaryVarFromASTDecl(MapleAllocator &allocator, ASTDecl *ptrDecl, ASTExpr *lenExpr,
+                                            std::list<ASTStmt*> &stmts) {
+  MIRType *ptrType = ptrDecl->GetTypeDesc().front();
+  // insert lower boundary stmt
+  ASTDeclRefExpr *lowerRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  lowerRefExpr->SetASTDecl(ptrDecl);
+  std::string lowerVarName = "_boundary." + ptrDecl->GetName() + ".lower";
+  ASTVar *lowerDecl = ASTDeclsBuilder::ASTVarBuilder(allocator, MapleString("", allocator.GetMemPool()),
+      lowerVarName, MapleVector<MIRType*>({ptrType}, allocator.Adapter()), GenericAttrs());
+  lowerDecl->SetIsParam(true);
+  lowerDecl->SetInitExpr(lowerRefExpr);
+  ASTDeclStmt *lowerStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTDeclStmt>(allocator);
+  lowerStmt->SetSubDecl(lowerDecl);
+  // insert upper boundary stmt
+  ASTDeclRefExpr *upperRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  upperRefExpr->SetASTDecl(ptrDecl);
+  ASTBinaryOperatorExpr *upperBinExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  upperBinExpr->SetLeftExpr(upperRefExpr);
+  upperBinExpr->SetRightExpr(lenExpr);
+  upperBinExpr->SetOpcode(OP_add);
+  upperBinExpr->SetRetType(ptrType);
+  upperBinExpr->SetCvtNeeded(true);
+  std::string upperVarName = "_boundary." + ptrDecl->GetName() + ".upper";
+  ASTVar *upperDecl = ASTDeclsBuilder::ASTVarBuilder(allocator, MapleString("", allocator.GetMemPool()),
+      upperVarName, MapleVector<MIRType*>({ptrType}, allocator.Adapter()), GenericAttrs());
+  upperDecl->SetIsParam(true);
+  upperDecl->SetInitExpr(upperBinExpr);
+  ASTDeclStmt *upperStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTDeclStmt>(allocator);
+  upperStmt->SetSubDecl(upperDecl);
+  stmts.emplace_back(lowerStmt);
+  stmts.emplace_back(upperStmt);
+}
+
+void ENCChecker::InitBoundaryVar(MIRFunction &curFunction, const ASTDecl &ptrDecl,
+                                 UniqueFEIRExpr lenExpr, std::list<UniqueFEIRStmt> &stmts) {
+  std::string ptrName = ptrDecl.GenerateUniqueVarName();
+  MIRType *ptrType = ptrDecl.GetTypeDesc().front();
+  UniqueFEIRExpr ptrExpr = FEIRBuilder::CreateExprDRead(FEIRBuilder::CreateVarNameForC(ptrName, *ptrType));
+  // insert lower boundary stmt
+  std::string lowerVarName = "_boundary." + ptrName + ".lower";
+  UniqueFEIRVar lowerVar = FEIRBuilder::CreateVarNameForC(lowerVarName, *ptrType);
+  UniqueFEIRStmt lowerStmt = FEIRBuilder::CreateStmtDAssign(std::move(lowerVar), ptrExpr->Clone());
+  // insert upper boundary stmt
+  UniqueFEIRExpr binExpr = FEIRBuilder::CreateExprBinary(OP_add, ptrExpr->Clone(), std::move(lenExpr));
+  std::string upperVarName = "_boundary." + ptrName + ".upper";
+  UniqueFEIRVar upperVar = FEIRBuilder::CreateVarNameForC(upperVarName, *ptrType);
+  UniqueFEIRStmt upperStmt = FEIRBuilder::CreateStmtDAssign(std::move(upperVar), std::move(binExpr));
+  if (ptrDecl.GetSrcFileLineNum() != 0) {
+    Loc loc = {ptrDecl.GetSrcFileIdx(), ptrDecl.GetSrcFileLineNum(), ptrDecl.GetSrcFileColumn()};
+    lowerStmt->SetSrcLoc(loc);
+    upperStmt->SetSrcLoc(loc);
+  }
+  stmts.emplace_back(std::move(lowerStmt));
+  stmts.emplace_back(std::move(upperStmt));
+  // update BoundaryMap
+  MIRSymbol *lowerSym = nullptr;
+  MIRSymbol *upperSym = nullptr;
+  if (ptrDecl.IsGlobal()) {
+    lowerSym = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl(lowerVarName, *ptrType);
+    upperSym = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl(upperVarName, *ptrType);
+  } else {
+    lowerSym = FEManager::GetMIRBuilder().GetOrCreateDeclInFunc(lowerVarName, *ptrType, curFunction);
+    upperSym = FEManager::GetMIRBuilder().GetOrCreateDeclInFunc(upperVarName, *ptrType, curFunction);
+  }
+  FEManager::GetCurrentFEFunction().SetBoundaryMap(
+      ptrExpr->Hash(), std::make_pair(lowerSym->GetStIdx(), upperSym->GetStIdx()));
+}
+
+void ENCChecker::InitBoundaryVar(MIRFunction &curFunction, const std::string &ptrName, MIRType &ptrType,
+                                 UniqueFEIRExpr lenExpr, std::list<UniqueFEIRStmt> &stmts) {
+  UniqueFEIRExpr ptrExpr = FEIRBuilder::CreateExprDRead(FEIRBuilder::CreateVarNameForC(ptrName, ptrType));
+  // insert lower boundary stmt
+  std::string lowerVarName = "_boundary." + ptrName + ".lower";
+  UniqueFEIRVar lowerVar = FEIRBuilder::CreateVarNameForC(lowerVarName, ptrType);
+  UniqueFEIRStmt lowerStmt = FEIRBuilder::CreateStmtDAssign(std::move(lowerVar), ptrExpr->Clone());
+  stmts.emplace_back(std::move(lowerStmt));
+  // insert upper boundary stmt
+  UniqueFEIRExpr binExpr = FEIRBuilder::CreateExprBinary(OP_add, ptrExpr->Clone(), std::move(lenExpr));
+  std::string upperVarName = "_boundary." + ptrName + ".upper";
+  UniqueFEIRVar upperVar = FEIRBuilder::CreateVarNameForC(upperVarName, ptrType);
+  UniqueFEIRStmt upperStmt = FEIRBuilder::CreateStmtDAssign(std::move(upperVar), std::move(binExpr));
+  stmts.emplace_back(std::move(upperStmt));
+  // update BoundaryMap
+  MIRSymbol *lowerSym = FEManager::GetMIRBuilder().GetOrCreateDeclInFunc(lowerVarName, ptrType, curFunction);
+  MIRSymbol *upperSym = FEManager::GetMIRBuilder().GetOrCreateDeclInFunc(upperVarName, ptrType, curFunction);
+  FEManager::GetCurrentFEFunction().SetBoundaryMap(
+      ptrExpr->Hash(), std::make_pair(lowerSym->GetStIdx(), upperSym->GetStIdx()));
+}
+
+std::pair<StIdx, StIdx> ENCChecker::InitBoundaryVar(MIRFunction &curFunction, const UniqueFEIRExpr &ptrExpr,
+                                                    UniqueFEIRExpr lenExpr, std::list<UniqueFEIRStmt> &stmts) {
+  std::string ptrName = GetBoundaryName(ptrExpr);
+  if (ptrName.empty()) {
+    return std::make_pair(StIdx(0), StIdx(0));
+  }
+  MIRType *ptrType = ptrExpr->GetType()->GenerateMIRTypeAuto();
+  // insert lower boundary stmt
+  std::string lowerVarName = ptrName + ".lower";
+  UniqueFEIRVar lowerVar = FEIRBuilder::CreateVarNameForC(lowerVarName, *ptrType);
+  UniqueFEIRStmt lowerStmt = FEIRBuilder::CreateStmtDAssign(std::move(lowerVar), ptrExpr->Clone());
+  stmts.emplace_back(std::move(lowerStmt));
+  // insert upper boundary stmt
+  UniqueFEIRExpr binExpr = FEIRBuilder::CreateExprBinary(OP_add, ptrExpr->Clone(), std::move(lenExpr));
+  std::string upperVarName = ptrName + ".upper";
+  UniqueFEIRVar upperVar = FEIRBuilder::CreateVarNameForC(upperVarName, *ptrType);
+  UniqueFEIRStmt upperStmt = FEIRBuilder::CreateStmtDAssign(std::move(upperVar), std::move(binExpr));
+  stmts.emplace_back(std::move(upperStmt));
+  // update BoundaryMap
+  MIRSymbol *lowerSym = FEManager::GetMIRBuilder().GetOrCreateDeclInFunc(lowerVarName, *ptrType, curFunction);
+  MIRSymbol *upperSym = FEManager::GetMIRBuilder().GetOrCreateDeclInFunc(upperVarName, *ptrType, curFunction);
+  auto stIdxs = std::make_pair(lowerSym->GetStIdx(), upperSym->GetStIdx());
+  FEManager::GetCurrentFEFunction().SetBoundaryMap(ptrExpr->Hash(), stIdxs);
+  return stIdxs;
+}
+
+
+UniqueFEIRExpr ENCChecker::GetGlobalOrFieldLenExprInExpr(MIRBuilder &mirBuilder, const UniqueFEIRExpr &expr) {
+  UniqueFEIRExpr lenExpr = nullptr;
+  if (expr->GetKind() == kExprDRead && expr->GetFieldID() == 0) {
+    FEIRVar *var = expr->GetVarUses().front();
+    MIRSymbol *symbol = var->GenerateMIRSymbol(mirBuilder);
+    if (!symbol->IsGlobal()) {
+      return nullptr;
+    }
+    // Get the boundary attr(i.e. boundary length expr cache)
+    lenExpr = GetBoundaryLenExprCache(symbol->GetAttrs());
+  } else if ((expr->GetKind() == kExprDRead || expr->GetKind() == kExprIRead) && expr->GetFieldID() != 0) {
+    MIRStructType *structType = nullptr;
+    if (expr->GetKind() == kExprDRead) {
+      structType = static_cast<MIRStructType*>(expr->GetVarUses().front()->GetType()->GenerateMIRTypeAuto());
+    } else {
+      FEIRExprIRead *iread = static_cast<FEIRExprIRead*>(expr.get());
+      MIRType *baseType = static_cast<MIRPtrType*>(iread->GetClonedPtrType()->GenerateMIRTypeAuto())->GetPointedType();
+      structType = static_cast<MIRStructType*>(baseType);
+    }
+    FieldID tmpID = expr->GetFieldID();
+    FieldPair fieldPair = structType->TraverseToFieldRef(tmpID);
+    // Get the boundary attr(i.e. boundary length expr cache) of field
+    lenExpr = GetBoundaryLenExprCache(fieldPair.second.second);
+    if (lenExpr == nullptr) {
+      return nullptr;
+    }
+    UniqueFEIRExpr realExpr = ENCChecker::GetRealBoundaryLenExprInField(
+        lenExpr->Clone(), *structType, expr);  // lenExpr needs to be cloned
+    if (realExpr != nullptr) {
+      lenExpr = std::move(realExpr);
+    }
+  } else {
+    return nullptr;
+  }
+  return lenExpr;
+}
+
+bool ENCChecker::IsConstantIndex(const UniqueFEIRExpr &expr) {
+  if (expr->GetKind() != kExprAddrofArray) {
+    return false;
+  }
+  FEIRExprAddrofArray *arrExpr = static_cast<FEIRExprAddrofArray*>(expr.get());
+  // nested array
+  if (arrExpr->GetExprArray()->GetKind() == kExprAddrofArray) {
+    if (!IsConstantIndex(arrExpr->GetExprArray()->Clone())) {
+      return false;
+    }
+  }
+  for (const auto &idxExpr : arrExpr->GetExprIndexs()) {
+    if (idxExpr->GetKind() != kExprConst) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void ENCChecker::PeelNestedBoundaryChecking(std::list<UniqueFEIRStmt> &stmts, const UniqueFEIRExpr &baseExpr) {
+  std::list<UniqueFEIRStmt>::iterator i = stmts.begin();
+  while (i != stmts.end()) {
+    bool flag = ((*i)->GetKind() == kStmtNary);
+    if (flag) {
+      FEIRStmtNary *nary = static_cast<FEIRStmtNary*>((*i).get());
+      flag = kOpcodeInfo.IsAssertBoundary(nary->GetOP()) &&
+             nary->GetArgExprs().back()->Hash() == baseExpr->Hash();
+    }
+    if (flag) {
+      i = stmts.erase(i);
+    } else {
+      ++i;
+    }
+  }
+}
+
+UniqueFEIRExpr ENCChecker::GetRealBoundaryLenExprInFuncByIndex(const TypeAttrs &typeAttrs, const MIRType &type,
+                                                               const ASTCallExpr &astCallExpr) {
+  int8 idx = typeAttrs.GetAttrBoundary().GetLenParamIdx();
+  if (idx >= 0) {
+    ASTExpr *astLenExpr = astCallExpr.GetArgsExpr()[idx];
+    if (!typeAttrs.GetAttrBoundary().IsBytedLen()) {
+      CHECK_FATAL(type.IsMIRPtrType(), "Must be ptr type!");
+      size_t lenSize = static_cast<const MIRPtrType&>(type).GetPointedType()->GetSize();
+      MapleAllocator &allocator = FEManager::GetModule().GetMPAllocator();
+      astLenExpr = ASTParser::GetAddrShiftExpr(allocator, *(astCallExpr.GetArgsExpr()[idx]),
+                                               static_cast<uint32>(lenSize));
+    }
+    std::list<UniqueFEIRStmt> nullStmts;
+    return astLenExpr->Emit2FEExpr(nullStmts);
+  } else if (typeAttrs.GetAttrBoundary().GetLenExprHash() != 0) {
+    return ENCChecker::GetBoundaryLenExprCache(typeAttrs);
+  }
+  return nullptr;
+}
+
+UniqueFEIRExpr ENCChecker::GetRealBoundaryLenExprInFunc(const UniqueFEIRExpr &lenExpr, const ASTFunc &astFunc,
+                                                        const ASTCallExpr &astCallExpr) {
+  if (lenExpr == nullptr) {
+    return nullptr;
+  }
+  if (lenExpr->GetKind() == kExprBinary) {
+    FEIRExprBinary *mulExpr = static_cast<FEIRExprBinary*>(lenExpr.get());
+    UniqueFEIRExpr leftExpr = GetRealBoundaryLenExprInFunc(mulExpr->GetOpnd0(), astFunc, astCallExpr);
+    if (leftExpr != nullptr) {
+      mulExpr->SetOpnd0(std::move(leftExpr));
+    } else {
+      return nullptr;
+    }
+    UniqueFEIRExpr rightExpr = GetRealBoundaryLenExprInFunc(mulExpr->GetOpnd1(), astFunc, astCallExpr);
+    if (rightExpr != nullptr) {
+      mulExpr->SetOpnd1(std::move(rightExpr));
+    } else {
+      return nullptr;
+    }
+  }
+  if (lenExpr->GetKind() == kExprUnary) {
+    FEIRExprUnary *cvtExpr = static_cast<FEIRExprUnary*>(lenExpr.get());
+    UniqueFEIRExpr subExpr = GetRealBoundaryLenExprInFunc(cvtExpr->GetOpnd(), astFunc, astCallExpr);
+    if (subExpr != nullptr) {
+      cvtExpr->SetOpnd(std::move(subExpr));
+    } else {
+      return nullptr;
+    }
+  }
+  if (lenExpr->GetKind() == kExprIRead) {
+    FEIRExprIRead *ireadExpr = static_cast<FEIRExprIRead*>(lenExpr.get());
+    UniqueFEIRExpr subExpr = GetRealBoundaryLenExprInFunc(ireadExpr->GetClonedOpnd(), astFunc, astCallExpr);
+    if (subExpr != nullptr) {
+      ireadExpr->SetClonedOpnd(std::move(subExpr));
+    } else {
+      return nullptr;
+    }
+  }
+  // formal parameter length expr -> actual parameter expr
+  std::list<UniqueFEIRStmt> nullStmts;
+  if (lenExpr->GetKind() == kExprDRead) {
+    std::string lenName = lenExpr->GetVarUses().front()->GetNameRaw();
+    for (size_t i = 0; i < astFunc.GetParamDecls().size(); ++i) {
+      if (lenName == astFunc.GetParamDecls()[i]->GetName()) {
+        return astCallExpr.GetArgsExpr()[i]->Emit2FEExpr(nullStmts);
+      }
+    }
+    // the var may be a global var
+    FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "%s:%d EnhanceC warning: The var [%s] as boundary length var "
+        "is not found in the caller func [%s], check the caller whether the var is the actual parameter",
+        FEManager::GetModule().GetFileNameFromFileNum(astCallExpr.GetSrcFileIdx()).c_str(),
+        astCallExpr.GetSrcFileLineNum(), lenName.c_str(), astFunc.GetName().c_str());
+  }
+  return lenExpr->Clone();
+}
+
+UniqueFEIRExpr ENCChecker::GetRealBoundaryLenExprInField(const UniqueFEIRExpr &lenExpr, MIRStructType &baseType,
+                                                         const UniqueFEIRExpr &dstExpr) {
+  if (lenExpr == nullptr) {
+    return nullptr;
+  }
+  if (lenExpr->GetKind() == kExprBinary) {
+    FEIRExprBinary *mulExpr = static_cast<FEIRExprBinary*>(lenExpr.get());
+    UniqueFEIRExpr leftExpr = GetRealBoundaryLenExprInField(mulExpr->GetOpnd0(), baseType, dstExpr);
+    if (leftExpr != nullptr) {
+      mulExpr->SetOpnd0(std::move(leftExpr));
+    } else {
+      return nullptr;
+    }
+    UniqueFEIRExpr rightExpr = GetRealBoundaryLenExprInField(mulExpr->GetOpnd1(), baseType, dstExpr);
+    if (rightExpr != nullptr) {
+      mulExpr->SetOpnd1(std::move(rightExpr));
+    } else {
+      return nullptr;
+    }
+  }
+  if (lenExpr->GetKind() == kExprUnary) {
+    FEIRExprUnary *cvtExpr = static_cast<FEIRExprUnary*>(lenExpr.get());
+    UniqueFEIRExpr subExpr = GetRealBoundaryLenExprInField(cvtExpr->GetOpnd(), baseType, dstExpr);
+    if (subExpr != nullptr) {
+      cvtExpr->SetOpnd(std::move(subExpr));
+    } else {
+      return nullptr;
+    }
+  }
+  // boundary length expr -> actual dread/iread length field expr
+  if (lenExpr->GetKind() == kExprDRead) {
+    std::string lenName = lenExpr->GetVarUses().front()->GetNameRaw();
+    uint32 fieldID = 0;
+    bool flag = FEManager::GetMIRBuilder().TraverseToNamedField(
+        baseType, GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lenName), fieldID);
+    if (!flag) {
+      return nullptr;
+    }
+    MIRType *reType = FEUtils::GetStructFieldType(&baseType, static_cast<FieldID>(fieldID));
+    UniqueFEIRType reFEType = FEIRTypeHelper::CreateTypeNative(*reType);
+    if (dstExpr->GetKind() == kExprDRead) {
+      return FEIRBuilder::CreateExprDReadAggField(
+          dstExpr->GetVarUses().front()->Clone(), static_cast<FieldID>(fieldID), std::move(reFEType));
+    } else if (dstExpr->GetKind() == kExprIRead) {
+      FEIRExprIRead *iread = static_cast<FEIRExprIRead*>(dstExpr.get());
+      return FEIRBuilder::CreateExprIRead(
+          std::move(reFEType), iread->GetClonedPtrType(), iread->GetClonedOpnd(), static_cast<FieldID>(fieldID));
+    } else {
+      return nullptr;
+    }
+  }
+  return lenExpr->Clone();
+}
+
+// ---------------------------
+// process boundary var and checking for ast func arg and return
+// ---------------------------
+std::list<UniqueFEIRStmt> ASTFunc::InitArgsBoundaryVar(MIRFunction &mirFunc) const {
+  std::list<UniqueFEIRStmt> stmts;
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || compound == nullptr) {
+    return stmts;
+  }
+  for (auto paramDecl : paramDecls) {
+    ASTExpr *lenExpr = paramDecl->GetBoundaryLenExpr();
+    if (lenExpr == nullptr) {
+      continue;
+    }
+    UniqueFEIRExpr lenFEExpr = lenExpr->Emit2FEExpr(stmts);
+    ENCChecker::InitBoundaryVar(mirFunc, *paramDecl, std::move(lenFEExpr), stmts);
+  }
+  return stmts;
+}
+
+void ASTFunc::InsertBoundaryCheckingInRet(std::list<UniqueFEIRStmt> &stmts) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || boundary.lenExpr == nullptr ||
+      stmts.size() == 0 || stmts.back()->GetKind() != kStmtReturn) {
+    return;
+  }
+  std::list<UniqueFEIRStmt> nullStmts;
+  const UniqueFEIRExpr &retExpr = static_cast<FEIRStmtReturn*>(stmts.back().get())->GetExpr();
+  UniqueFEIRExpr baseExpr = ENCChecker::FindBaseExprInPointerOperation(retExpr);
+  if (baseExpr == nullptr) {
+    return;
+  }
+  std::list<UniqueFEIRExpr> exprs;
+  UniqueFEIRExpr lenExpr = boundary.lenExpr->Emit2FEExpr(nullStmts);
+  if (boundary.lenParamIdx != -1) {  // backup return boundary size in head func body
+    UniqueFEIRVar retSizeVar = FEIRBuilder::CreateVarNameForC("_boundary.return.size", lenExpr->GetType()->Clone());
+    UniqueFEIRStmt lenStmt = FEIRBuilder::CreateStmtDAssign(retSizeVar->Clone(), lenExpr->Clone());
+    stmts.emplace_front(std::move(lenStmt));
+    lenExpr = FEIRBuilder::CreateExprDRead(std::move(retSizeVar));
+  }
+  lenExpr = FEIRBuilder::CreateExprBinary(OP_add, retExpr->Clone(), std::move(lenExpr));
+  exprs.emplace_back(std::move(lenExpr));
+  exprs.emplace_back(std::move(baseExpr));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtAssertBoundary>(OP_returnassertle, std::move(exprs));
+  stmt->SetSrcLoc(stmts.back()->GetSrcLoc());
+  stmts.insert(--stmts.cend(), std::move(stmt));
+}
+
+void ENCChecker::InsertBoundaryAssignChecking(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans,
+                                              const UniqueFEIRExpr &srcExpr, const Loc &loc) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || srcExpr == nullptr || srcExpr->GetPrimType() != PTY_ptr ||
+      srcExpr->GetKind() != kExprBinary) {  // pointer computed assignment
+    return;
+  }
+  if (srcExpr->IsBoundaryChecking()) {  // skip if boundary checking has been generated
+    return;
+  }
+  UniqueFEIRExpr baseExpr = FindBaseExprInPointerOperation(srcExpr);
+  if (baseExpr == nullptr) {
+    return;
+  }
+  srcExpr->SetIsBoundaryChecking(true);
+  // insert l-value lower boundary chencking
+  std::list<UniqueFEIRExpr> lowerExprs;
+  lowerExprs.emplace_back(srcExpr->Clone());
+  lowerExprs.emplace_back(baseExpr->Clone());
+  UniqueFEIRStmt lowerStmt = std::make_unique<FEIRStmtAssertBoundary>(OP_calcassertge, std::move(lowerExprs));
+  lowerStmt->SetSrcLoc(loc);
+  std::list<StmtNode*> lowerStmts = lowerStmt->GenMIRStmts(mirBuilder);
+  ans.splice(ans.end(), lowerStmts);
+  // insert l-value upper boundary chencking
+  std::list<UniqueFEIRExpr> upperExprs;
+  upperExprs.emplace_back(srcExpr->Clone());
+  upperExprs.emplace_back(baseExpr->Clone());
+  UniqueFEIRStmt upperStmt = std::make_unique<FEIRStmtAssertBoundary>(OP_calcassertlt, std::move(upperExprs));
+  upperStmt->SetSrcLoc(loc);
+  std::list<StmtNode*> upperStmts = upperStmt->GenMIRStmts(mirBuilder);
+  ans.splice(ans.end(), upperStmts);
+}
+
+UniqueFEIRStmt ENCChecker::InsertBoundaryLEChecking(UniqueFEIRExpr lenExpr, const UniqueFEIRExpr &srcExpr,
+                                                    const UniqueFEIRExpr &dstExpr) {
+  UniqueFEIRExpr baseExpr = ENCChecker::FindBaseExprInPointerOperation(srcExpr);
+  if (baseExpr == nullptr) {
+    return nullptr;
+  }
+  if (dstExpr->Hash() == baseExpr->Hash()) {  // skip self-assignment, e.g. p++;
+    return nullptr;
+  }
+  UniqueFEIRExpr boundaryExpr = FEIRBuilder::CreateExprBinary(  // use r-value base + offset
+      OP_add, srcExpr->Clone(), std::move(lenExpr));
+  std::list<UniqueFEIRExpr> exprs;
+  exprs.emplace_back(std::move(boundaryExpr));
+  exprs.emplace_back(std::move(baseExpr));
+  return std::make_unique<FEIRStmtAssertBoundary>(OP_assignassertle, std::move(exprs));
+}
+
+UniqueFEIRExpr ENCChecker::GetBoundaryLenExprCache(uint32 hash) {
+  if (hash == 0) {
+    return nullptr;
+  } else {
+    return FEManager::GetTypeManager().GetBoundaryLenExprFromMap(hash);
+  }
+}
+
+UniqueFEIRExpr ENCChecker::GetBoundaryLenExprCache(const TypeAttrs &attr) {
+  return GetBoundaryLenExprCache(attr.GetAttrBoundary().GetLenExprHash());
+}
+
+UniqueFEIRExpr ENCChecker::GetBoundaryLenExprCache(const FieldAttrs &attr) {
+  return GetBoundaryLenExprCache(attr.GetAttrBoundary().GetLenExprHash());
+}
+
+void ENCChecker::InsertBoundaryInAtts(TypeAttrs &attr, const BoundaryInfo &boundary) {
+  attr.GetAttrBoundary().SetIsBytedLen(boundary.isBytedLen);
+  if (boundary.lenParamIdx != -1) {
+    attr.GetAttrBoundary().SetLenParamIdx(boundary.lenParamIdx);
+  }
+  if (boundary.lenExpr == nullptr) {
+    return;
+  }
+  std::list<UniqueFEIRStmt> nullStmts;
+  UniqueFEIRExpr lenExpr = boundary.lenExpr->Emit2FEExpr(nullStmts);
+  CheckLenExpr(*boundary.lenExpr, nullStmts);
+  InsertBoundaryLenExprInAtts(attr, lenExpr);
+}
+
+void ENCChecker::InsertBoundaryLenExprInAtts(TypeAttrs &attr, const UniqueFEIRExpr &expr) {
+  if (expr == nullptr) {
+    return;
+  }
+  uint32 hash = expr->Hash();
+  FEManager::GetTypeManager().InsertBoundaryLenExprHashMap(hash, expr->Clone());  // save expr cache
+  attr.GetAttrBoundary().SetLenExprHash(hash);
+}
+
+void ENCChecker::InsertBoundaryInAtts(FieldAttrs &attr, const BoundaryInfo &boundary) {
+  attr.GetAttrBoundary().SetIsBytedLen(boundary.isBytedLen);
+  if (boundary.lenParamIdx != -1) {
+    attr.GetAttrBoundary().SetLenParamIdx(boundary.lenParamIdx);
+  }
+  if (boundary.lenExpr == nullptr) {
+    return;
+  }
+  std::list<UniqueFEIRStmt> nullStmts;
+  UniqueFEIRExpr lenExpr = boundary.lenExpr->Emit2FEExpr(nullStmts);
+  uint32 hash = lenExpr->Hash();
+  FEManager::GetTypeManager().InsertBoundaryLenExprHashMap(hash, std::move(lenExpr));  // save expr cache
+  attr.GetAttrBoundary().SetLenExprHash(hash);
+}
+
+void ENCChecker::InsertBoundaryInAtts(FuncAttrs &attr, const BoundaryInfo &boundary) {
+  attr.GetAttrBoundary().SetIsBytedLen(boundary.isBytedLen);
+  if (boundary.lenParamIdx != -1) {
+    attr.GetAttrBoundary().SetLenParamIdx(boundary.lenParamIdx);
+  }
+  if (boundary.lenExpr == nullptr) {
+    return;
+  }
+  std::list<UniqueFEIRStmt> nullStmts;
+  UniqueFEIRExpr lenExpr = boundary.lenExpr->Emit2FEExpr(nullStmts);
+  uint32 hash = lenExpr->Hash();
+  FEManager::GetTypeManager().InsertBoundaryLenExprHashMap(hash, std::move(lenExpr));  // save expr cache
+  attr.GetAttrBoundary().SetLenExprHash(hash);
+}
+
+// ---------------------------
+// process boundary var and checking in stmt of ast func
+// ---------------------------
+void FEIRStmtDAssign::AssignBoundaryVarAndChecking(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || expr->GetPrimType() != PTY_ptr) {
+    return;
+  }
+  const std::string prefix = "_boundary.";
+  if (var->GetNameRaw().compare(0, prefix.size(), prefix) == 0) {
+    return;
+  }
+  // insert assign boundary checking for computed r-value
+  ENCChecker::InsertBoundaryAssignChecking(mirBuilder, ans, expr, loc);
+
+  UniqueFEIRExpr dstExpr = nullptr;
+  UniqueFEIRExpr lenExpr = nullptr;
+  if (fieldID == 0) {
+    dstExpr = FEIRBuilder::CreateExprDRead(var->Clone());
+    MIRSymbol *dstSym = var->GenerateMIRSymbol(mirBuilder);
+    // Get the boundary attr(i.e. boundary length expr cache) of var
+    lenExpr = ENCChecker::GetBoundaryLenExprCache(dstSym->GetAttrs());
+  } else {
+    FieldID tmpID = fieldID;
+    MIRStructType *structType = static_cast<MIRStructType*>(var->GetType()->GenerateMIRTypeAuto());
+    FieldPair fieldPair = structType->TraverseToFieldRef(tmpID);
+    UniqueFEIRType fieldType = FEIRTypeHelper::CreateTypeNative(
+        *GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first));
+    dstExpr = FEIRBuilder::CreateExprDReadAggField(var->Clone(), fieldID, std::move(fieldType));
+    // Get the boundary attr(i.e. boundary length expr cache) of field
+    lenExpr = ENCChecker::GetBoundaryLenExprCache(fieldPair.second.second);
+    if (lenExpr != nullptr) {
+      UniqueFEIRExpr realLenExpr = ENCChecker::GetRealBoundaryLenExprInField(
+          lenExpr->Clone(), *structType, dstExpr); // lenExpr needs to be cloned
+      if (realLenExpr != nullptr) {
+        lenExpr = std::move(realLenExpr);
+      }
+    }
+  }
+  if (lenExpr != nullptr) {
+    UniqueFEIRStmt stmt = ENCChecker::InsertBoundaryLEChecking(lenExpr->Clone(), expr, dstExpr);
+    if (stmt != nullptr) {
+      stmt->SetSrcLoc(loc);
+      std::list<StmtNode*> stmtnodes = stmt->GenMIRStmts(mirBuilder);
+      ans.insert(ans.cend(), stmtnodes.cbegin(), stmtnodes.cend());
+    }
+  }
+  ENCChecker::AssignBoundaryVar(mirBuilder, dstExpr, expr, lenExpr, ans);
+}
+
+void FEIRStmtIAssign::AssignBoundaryVarAndChecking(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || fieldID == 0 || baseExpr->GetPrimType() != PTY_ptr) {
+    return;
+  }
+  // insert assign boundary checking for computed r-value
+  ENCChecker::InsertBoundaryAssignChecking(mirBuilder, ans, baseExpr, loc);
+
+  MIRType *baseType = static_cast<MIRPtrType*>(addrType->GenerateMIRTypeAuto())->GetPointedType();
+  FieldID tmpID = fieldID;
+  FieldPair fieldPair = static_cast<MIRStructType*>(baseType)->TraverseToFieldRef(tmpID);
+  MIRType *dstType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+  UniqueFEIRExpr dstExpr = FEIRBuilder::CreateExprIRead(
+      FEIRTypeHelper::CreateTypeNative(*dstType), addrType->Clone(), addrExpr->Clone(), fieldID);
+  // Get the boundary attr (i.e. boundary length expr cache) of field
+  UniqueFEIRExpr lenExpr = ENCChecker::GetBoundaryLenExprCache(fieldPair.second.second);
+  if (lenExpr != nullptr) {
+    UniqueFEIRExpr realLenExpr = ENCChecker::GetRealBoundaryLenExprInField(
+        lenExpr->Clone(), *static_cast<MIRStructType*>(baseType), dstExpr);  // lenExpr needs to be cloned
+    if (realLenExpr != nullptr) {
+      lenExpr = std::move(realLenExpr);
+    }
+    UniqueFEIRStmt stmt = ENCChecker::InsertBoundaryLEChecking(lenExpr->Clone(), baseExpr, dstExpr);
+    if (stmt != nullptr) {
+      stmt->SetSrcLoc(loc);
+      std::list<StmtNode*> stmtnodes = stmt->GenMIRStmts(mirBuilder);
+      ans.insert(ans.cend(), stmtnodes.cbegin(), stmtnodes.cend());
+    }
+  }
+  ENCChecker::AssignBoundaryVar(mirBuilder, dstExpr, baseExpr, lenExpr, ans);
+}
+
+void ENCChecker::CheckBoundaryLenFinalAssign(MIRBuilder &mirBuilder, const UniqueFEIRVar &var, FieldID fieldID,
+                                             const Loc &loc) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || !FEOptions::GetInstance().IsEnableSafeRegion()) {
+    return;
+  }
+  bool isUnsafe = mirBuilder.GetCurrentFunctionNotNull()->GetAttr(FUNCATTR_unsafed);
+  if (!FEManager::GetCurrentFEFunction().GetSafeRegionFlag().empty()) {
+    isUnsafe = !FEManager::GetCurrentFEFunction().GetSafeRegionFlag().top();
+  }
+  if (isUnsafe) {  // not warning in unsafe region
+    return;
+  }
+  if (fieldID == 0) {
+    MIRSymbol *dstSym = var->GenerateMIRSymbol(mirBuilder);
+    if (dstSym->GetAttr(ATTR_final_boundary_size)) {
+      FE_WARN(kLncWarn, loc, "this var specified as the global or field boundary length is "
+              "assigned or token address. [Use __Unsafe__ to eliminate the warning]");
+    }
+  } else {
+    FieldID tmpID = fieldID;
+    MIRStructType *structType = static_cast<MIRStructType*>(var->GetType()->GenerateMIRTypeAuto());
+    FieldPair fieldPair = structType->TraverseToFieldRef(tmpID);
+    if (fieldPair.second.second.GetAttr(FLDATTR_final_boundary_size)) {
+      FE_WARN(kLncWarn, loc, "this field specified as the global or field boundary length is "
+              "assigned or token address. [Use __Unsafe__ to eliminate the warning]");
+    }
+  }
+}
+
+void ENCChecker::CheckBoundaryLenFinalAssign(MIRBuilder &mirBuilder, const UniqueFEIRType &addrType, FieldID fieldID,
+                                             const Loc &loc) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || !FEOptions::GetInstance().IsEnableSafeRegion() ||
+      fieldID == 0) {
+    return;
+  }
+  bool isUnsafe = mirBuilder.GetCurrentFunctionNotNull()->GetAttr(FUNCATTR_unsafed);
+  if (!FEManager::GetCurrentFEFunction().GetSafeRegionFlag().empty()) {
+    isUnsafe = !FEManager::GetCurrentFEFunction().GetSafeRegionFlag().top();
+  }
+  if (isUnsafe) {  // not warning in unsafe region
+    return;
+  }
+  MIRType *baseType = static_cast<MIRPtrType*>(addrType->GenerateMIRTypeAuto())->GetPointedType();
+  FieldID tmpID = fieldID;
+  FieldPair fieldPair = static_cast<MIRStructType*>(baseType)->TraverseToFieldRef(tmpID);
+  if (fieldPair.second.second.GetAttr(FLDATTR_final_boundary_size)) {
+    FE_WARN(kLncWarn, loc, "this field specified as the global or field boundary length is "
+            "assigned or token address. [Use __Unsafe__ to eliminate the warning]");
+  }
+}
+
+void ENCChecker::CheckBoundaryLenFinalAddr(MIRBuilder &mirBuilder, const UniqueFEIRExpr &expr, const Loc &loc) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || !FEOptions::GetInstance().IsEnableSafeRegion()) {
+    return;
+  }
+  if (expr->GetKind() == kExprAddrofVar) {
+    UniqueFEIRVar var = expr->GetVarUses().front()->Clone();
+    CheckBoundaryLenFinalAssign(mirBuilder, var, expr->GetFieldID(), loc);
+  } else if (expr->GetKind() == kExprIAddrof) {
+    auto *iaddrof = static_cast<FEIRExprIAddrof*>(expr.get());
+    CheckBoundaryLenFinalAssign(mirBuilder, iaddrof->GetClonedPtrType(), expr->GetFieldID(), loc);
+  }
+}
+
+MapleVector<BaseNode*> ENCChecker::ReplaceBoundaryChecking(MIRBuilder &mirBuilder, const FEIRStmtNary *stmt) {
+  MIRFunction *curFunction = mirBuilder.GetCurrentFunctionNotNull();
+  UniqueFEIRExpr leftExpr = stmt->GetArgExprs().front()->Clone();
+  UniqueFEIRExpr rightExpr = stmt->GetArgExprs().back()->Clone();
+  BaseNode *leftNode = nullptr;
+  BaseNode *rightNode = nullptr;
+  MIRType *arrType = ENCChecker::GetArrayTypeFromExpr(stmt->GetArgExprs().back());
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  Opcode op = stmt->GetOP();
+  if (arrType != nullptr) {  // var must be array type by the previous checking
+    if (arrType->GetSize() == 0) {  // unsized array
+      return args;
+    }
+    // Convert to the following node for array:
+    // assertge/assertlt lnode: addrofarray + index; assertle lnode: (attributed upper boundary) addrofarray + len expr
+    // assertge rnode: addrof array; assertlt/assertle rnode: addrof array + sizeof expr
+    if (kOpcodeInfo.IsAssertUpperBoundary(op)) {
+      rightExpr = FEIRBuilder::CreateExprBinary(
+          OP_add, std::move(rightExpr), std::make_unique<FEIRExprConst>(arrType->GetSize(), PTY_ptr));
+    }
+    leftNode = leftExpr->GenMIRNode(mirBuilder);
+    rightNode = rightExpr->GenMIRNode(mirBuilder);
+  } else {
+    // Convert to the following node for expr with boundary var:
+    // assertge/assertlt lnode: addrof base + index; assertle lnode: (attributed upper boundary) addrof base + len expr
+    // assertge rnode: lower boundary; assertlt/assertle rnode: upper boundary
+    auto it = FEManager::GetCurrentFEFunction().GetBoundaryMap().find(rightExpr->Hash());
+    UniqueFEIRExpr lenExpr = ENCChecker::GetGlobalOrFieldLenExprInExpr(mirBuilder, rightExpr);
+    if (it != FEManager::GetCurrentFEFunction().GetBoundaryMap().end()) {
+      if (lenExpr == nullptr && IsGlobalVarInExpr(rightExpr)) {
+        return args;  // skip boundary checking for global var whithout boundary attr,
+      }               // because the lack of global variable boundary analysis capabilities in mapleall
+      StIdx boundaryStIdx = kOpcodeInfo.IsAssertLowerBoundary(op) ? it->second.first : it->second.second;
+      MIRSymbol *boundarySym = curFunction->GetLocalOrGlobalSymbol(boundaryStIdx);
+      CHECK_NULL_FATAL(boundarySym);
+      rightNode = mirBuilder.CreateExprDread(*boundarySym);
+    } else {
+      if (lenExpr != nullptr) {  // a global var or field with boundary attr
+        if (kOpcodeInfo.IsAssertUpperBoundary(op)) {
+          rightExpr = FEIRBuilder::CreateExprBinary(OP_add, std::move(rightExpr), std::move(lenExpr));
+        }
+        rightNode = rightExpr->GenMIRNode(mirBuilder);
+      } else {
+        ReplaceBoundaryErr(mirBuilder, stmt);
+        return args;
+      }
+    }
+    leftNode = leftExpr->GenMIRNode(mirBuilder);
+  }
+  args.emplace_back(leftNode);
+  args.emplace_back(rightNode);
+  return args;
+}
+
+void ENCChecker::ReplaceBoundaryErr(const MIRBuilder &mirBuilder, const FEIRStmtNary *stmt) {
+  if (ENCChecker::IsUnsafeRegion(mirBuilder)) {
+    return;
+  }
+  Opcode op = stmt->GetOP();
+  if (op == OP_callassertle) {
+    auto callAssert = static_cast<const FEIRStmtCallAssertBoundary*>(stmt);
+    FE_ERR(kLncErr, stmt->GetSrcLoc(), "boundaryless pointer passed to %s that requires a boundary pointer for "
+           "the %s argument", callAssert->GetFuncName().c_str(),
+           ENCChecker::GetNthStr(callAssert->GetParamIndex()).c_str());
+  } else if (op == OP_returnassertle) {
+    MIRFunction *curFunction = mirBuilder.GetCurrentFunctionNotNull();
+    if (curFunction->GetName() != kBoundsBuiltFunc) {
+      FE_ERR(kLncErr, stmt->GetSrcLoc(), "boundaryless pointer returned from %s that requires a boundary pointer",
+             curFunction->GetName().c_str());
+    }
+  } else if (op == OP_assignassertle) {
+    FE_ERR(kLncErr, stmt->GetSrcLoc(), "r-value requires a boundary pointer");
+  } else if (ENCChecker::IsSafeRegion(mirBuilder) &&
+             (op == OP_calcassertge ||
+              (op == OP_assertge && static_cast<const FEIRStmtAssertBoundary*>(stmt)->IsComputable()))) {
+    FE_ERR(kLncErr, stmt->GetSrcLoc(), "calculation with pointer requires bounds in safe region");
+  }
+}
+
+bool ASTArraySubscriptExpr::InsertBoundaryChecking(std::list<UniqueFEIRStmt> &stmts,
+                                                   UniqueFEIRExpr indexExpr, UniqueFEIRExpr baseAddrFEExpr) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return false;
+  }
+  if (arrayType->GetKind() == MIRTypeKind::kTypeArray) {
+    // checking all type of indexes, including constant indexes
+    while (baseAddrFEExpr != nullptr && baseAddrFEExpr->GetKind() == kExprAddrofArray) {
+      baseAddrFEExpr = static_cast<FEIRExprAddrofArray*>(baseAddrFEExpr.get())->GetExprArray()->Clone();
+    }
+  } else {
+    baseAddrFEExpr = ENCChecker::FindBaseExprInPointerOperation(baseAddrFEExpr);
+    if (baseAddrFEExpr == nullptr) {
+      return false;
+    }
+  }
+  // peel nested boundary checking in a multi-dimensional array
+  ENCChecker::PeelNestedBoundaryChecking(stmts, baseAddrFEExpr);
+  // insert lower boundary chencking, baseExpr will be replace by lower boundary var when FEIRStmtNary GenMIRStmts
+  std::list<UniqueFEIRExpr> lowerExprs;
+  lowerExprs.emplace_back(indexExpr->Clone());
+  lowerExprs.emplace_back(baseAddrFEExpr->Clone());
+  auto lowerStmt = std::make_unique<FEIRStmtAssertBoundary>(OP_assertge, std::move(lowerExprs));
+  lowerStmt->SetIsComputable(true);
+  lowerStmt->SetSrcLoc(loc);
+  stmts.emplace_back(std::move(lowerStmt));
+  // insert upper boundary chencking, baseExpr will be replace by upper boundary var when FEIRStmtNary GenMIRStmts
+  std::list<UniqueFEIRExpr> upperExprs;
+  upperExprs.emplace_back(std::move(indexExpr));
+  upperExprs.emplace_back(std::move(baseAddrFEExpr));
+  auto upperStmt = std::make_unique<FEIRStmtAssertBoundary>(OP_assertlt, std::move(upperExprs));
+  upperStmt->SetIsComputable(true);
+  upperStmt->SetSrcLoc(loc);
+  stmts.emplace_back(std::move(upperStmt));
+  return true;
+}
+
+bool ASTUODerefExpr::InsertBoundaryChecking(std::list<UniqueFEIRStmt> &stmts, UniqueFEIRExpr expr) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return false;
+  }
+  UniqueFEIRExpr baseExpr = ENCChecker::FindBaseExprInPointerOperation(expr);
+  if (baseExpr == nullptr) {
+    return false;
+  }
+  // peel nested boundary checking in a multi-dereference
+  ENCChecker::PeelNestedBoundaryChecking(stmts, baseExpr);
+  // insert lower boundary chencking, baseExpr will be replace by lower boundary var when FEIRStmtNary GenMIRStmts
+  std::list<UniqueFEIRExpr> lowerExprs;
+  lowerExprs.emplace_back(expr->Clone());
+  lowerExprs.emplace_back(baseExpr->Clone());
+  auto lowerStmt = std::make_unique<FEIRStmtAssertBoundary>(OP_assertge, std::move(lowerExprs));
+  lowerStmt->SetIsComputable(expr->GetKind() == kExprBinary);
+  lowerStmt->SetSrcLoc(loc);
+  stmts.emplace_back(std::move(lowerStmt));
+  // insert upper boundary chencking, baseExpr will be replace by upper boundary var when FEIRStmtNary GenMIRStmts
+  std::list<UniqueFEIRExpr> upperExprs;
+  upperExprs.emplace_back(expr->Clone());
+  upperExprs.emplace_back(std::move(baseExpr));
+  auto upperStmt = std::make_unique<FEIRStmtAssertBoundary>(OP_assertlt, std::move(upperExprs));
+  upperStmt->SetIsComputable(expr->GetKind() == kExprBinary);
+  upperStmt->SetSrcLoc(loc);
+  stmts.emplace_back(std::move(upperStmt));
+  return true;
+}
+
+void ENCChecker::ReduceBoundaryChecking(std::list<UniqueFEIRStmt> &stmts, const UniqueFEIRExpr &expr) {
+  // assert* --> calcassert*, when addrof the dereference, e.g. &arr[i]
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return;
+  }
+  std::list<UniqueFEIRStmt>::iterator iter = stmts.begin();
+  for (; iter != stmts.end(); ++iter) {
+    if ((*iter)->GetKind() != kStmtNary) {
+      continue;
+    }
+    FEIRStmtNary *nary = static_cast<FEIRStmtNary*>((*iter).get());
+    if (nary->GetOP() != OP_assertge ||
+        nary->GetArgExprs().front()->Hash() != expr->Hash()) {  // addrof expr and index expr of checking are consistent
+      continue;
+    }
+    nary->SetOP(OP_calcassertge);
+    std::list<UniqueFEIRStmt>::iterator nextedIter = std::next(iter, 1);
+    if (nextedIter != stmts.end() && (*nextedIter)->GetKind() == kStmtNary) {
+      FEIRStmtNary *nextedNary = static_cast<FEIRStmtNary*>((*nextedIter).get());
+      if (nextedNary->GetOP() == OP_assertlt) {
+        nextedNary->SetOP(OP_calcassertlt);
+      }
+    }
+    break;
+  }
+}
+
+// ---------------------------
+// caller boundary inserting and checking
+// ---------------------------
+void ASTCallExpr::InsertBoundaryCheckingInArgs(std::list<UniqueFEIRStmt> &stmts) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || funcDecl == nullptr) {
+    return;
+  }
+  std::list<UniqueFEIRStmt> nullStmts;
+  for (size_t i = 0; i < funcDecl->GetParamDecls().size(); ++i) {
+    ASTDecl *paramDecl = funcDecl->GetParamDecls()[i];
+    ASSERT_NOT_NULL(paramDecl);
+    if (paramDecl->GetBoundaryLenExpr() == nullptr) {
+      continue;
+    }
+    UniqueFEIRExpr realLenExpr = ENCChecker::GetRealBoundaryLenExprInFunc(
+        paramDecl->GetBoundaryLenExpr()->Emit2FEExpr(stmts), *funcDecl, *this);
+    if (realLenExpr == nullptr) {
+      continue;
+    }
+    UniqueFEIRExpr argExpr = args[i]->Emit2FEExpr(nullStmts);
+    UniqueFEIRExpr baseExpr = ENCChecker::FindBaseExprInPointerOperation(argExpr);
+    if (baseExpr == nullptr) {
+      continue;
+    }
+    std::list<UniqueFEIRExpr> exprs;
+    realLenExpr = FEIRBuilder::CreateExprBinary(OP_add, std::move(argExpr), std::move(realLenExpr));
+    exprs.emplace_back(std::move(realLenExpr));
+    exprs.emplace_back(std::move(baseExpr));
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCallAssertBoundary>(OP_callassertle, std::move(exprs),
+                                                                       GetFuncName(), i);
+    stmt->SetSrcLoc(loc);
+    stmts.emplace_back(std::move(stmt));
+  }
+}
+
+void ASTCallExpr::InsertBoundaryCheckingInArgsForICall(std::list<UniqueFEIRStmt> &stmts,
+                                                       const UniqueFEIRExpr &calleeFEExpr) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || calleeFEExpr == nullptr) {
+    return;
+  }
+  const MIRFuncType *funcType = FEUtils::GetFuncPtrType(*calleeFEExpr->GetType()->GenerateMIRType());
+  if (funcType == nullptr) {
+    return;
+  }
+  const std::vector<TypeAttrs> &attrsVec = funcType->GetParamAttrsList();
+  const std::vector<TyIdx> typesVec = funcType->GetParamTypeList();
+  std::list<UniqueFEIRStmt> nullStmts;
+  for (size_t i = 0; i < attrsVec.size() && i < typesVec.size() && i < args.size(); ++i) {
+    MIRType *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typesVec[i]);
+    UniqueFEIRExpr lenExpr = ENCChecker::GetRealBoundaryLenExprInFuncByIndex(attrsVec[i], *ptrType, *this);
+    if (lenExpr == nullptr) {
+      continue;
+    }
+    UniqueFEIRExpr argExpr = args[i]->Emit2FEExpr(nullStmts);
+    UniqueFEIRExpr baseExpr = ENCChecker::FindBaseExprInPointerOperation(argExpr);
+    if (baseExpr == nullptr) {
+      continue;
+    }
+    std::list<UniqueFEIRExpr> exprs;
+    lenExpr = FEIRBuilder::CreateExprBinary(OP_add, std::move(argExpr), std::move(lenExpr));
+    exprs.emplace_back(std::move(lenExpr));
+    exprs.emplace_back(std::move(baseExpr));
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCallAssertBoundary>(
+        OP_callassertle, std::move(exprs), "function_pointer", i);
+    stmt->SetSrcLoc(loc);
+    stmts.emplace_back(std::move(stmt));
+  }
+}
+
+void ASTCallExpr::InsertBoundaryVarInRet(std::list<UniqueFEIRStmt> &stmts) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || !IsNeedRetExpr()) {
+    return;
+  }
+  std::list<UniqueFEIRStmt> nullStmts;
+  UniqueFEIRExpr realLenExpr = nullptr;
+  if (funcDecl != nullptr && funcDecl->GetBoundaryLenExpr() != nullptr) {  // call
+    realLenExpr = ENCChecker::GetRealBoundaryLenExprInFunc(
+        funcDecl->GetBoundaryLenExpr()->Emit2FEExpr(stmts), *funcDecl, *this);
+  } else if (isIcall && calleeExpr != nullptr) {  // icall
+    const MIRFuncType *funcType = FEUtils::GetFuncPtrType(
+        *calleeExpr->Emit2FEExpr(nullStmts)->GetType()->GenerateMIRType());
+    if (funcType != nullptr) {
+      MIRType *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx());
+      if (ptrType != nullptr) {
+        realLenExpr = ENCChecker::GetRealBoundaryLenExprInFuncByIndex(funcType->GetRetAttrs(), *ptrType, *this);
+      }
+    }
+  }
+  if (realLenExpr == nullptr) {
+    return;
+  }
+  // GetCurrentFunction need to be optimized when parallel features
+  MIRFunction *curFunction = FEManager::GetMIRBuilder().GetCurrentFunctionNotNull();
+  ENCChecker::InitBoundaryVar(*curFunction, GetRetVarName(), *mirType, std::move(realLenExpr), stmts);
+}
+
+bool ENCChecker::IsSameBoundary(const AttrBoundary &arg1, const AttrBoundary &arg2) {
+  if (arg1.IsBytedLen() != arg2.IsBytedLen()) {
+    return false;
+  }
+  if (arg1.GetLenExprHash() != 0 && arg1.GetLenExprHash() == arg2.GetLenExprHash()) {
+    return true;
+  }
+  if (arg1.GetLenParamIdx() != -1 && arg1.GetLenParamIdx() == arg2.GetLenParamIdx()) {
+    return true;
+  }
+  if (arg1.GetLenExprHash() == arg2.GetLenExprHash() && arg1.GetLenParamIdx() == arg2.GetLenParamIdx()) {
+    return true;
+  }
+  return false;
+}
+
+void ENCChecker::CheckBoundaryArgsAndRetForFuncPtr(const MIRType &dstType, const UniqueFEIRExpr &srcExpr,
+                                                   const Loc &loc) {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || !srcExpr->IsEnhancedChecking()) {
+    return;
+  }
+  const MIRFuncType *funcType = FEUtils::GetFuncPtrType(dstType);
+  if (funcType == nullptr) {
+    return;
+  }
+  if (srcExpr->GetKind() == kExprAddrofFunc) {  // check func ptr l-value and &func decl r-value
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        static_cast<FEIRExprAddrofFunc*>(srcExpr.get())->GetFuncAddr());
+    MIRFunction *srcFunc = FEManager::GetTypeManager().GetMIRFunction(strIdx, false);
+    CHECK_FATAL(srcFunc != nullptr, "can not get MIRFunction");
+    std::list<size_t> errIdxs;
+    for (size_t i = 0; i < srcFunc->GetParamSize() && i < funcType->GetParamAttrsList().size(); ++i) {
+      if (!IsSameBoundary(
+          srcFunc->GetNthParamAttr(i).GetAttrBoundary(), funcType->GetNthParamAttrs(i).GetAttrBoundary())) {
+        errIdxs.emplace_back(i);
+      }
+    }
+    if (!errIdxs.empty()) {
+      FE_ERR(kLncErr, loc, "function pointer and target function's boundary attributes are mismatched "
+             "for the %s argument", PrintParamIdx(errIdxs).c_str());
+    }
+    if (!IsSameBoundary(srcFunc->GetFuncAttrs().GetAttrBoundary(), funcType->GetRetAttrs().GetAttrBoundary())) {
+      FE_ERR(kLncErr, loc, "function pointer and target function's boundary attributes are mismatched "
+             "for the return value");
+    }
+  }
+  const MIRFuncType *srcFuncType = FEUtils::GetFuncPtrType(*srcExpr->GetType()->GenerateMIRTypeAuto());
+  if (srcFuncType != nullptr) {  // check func ptr l-value and func ptr r-value
+    std::list<size_t> errIdxs;
+    for (size_t i = 0; i < srcFuncType->GetParamAttrsList().size() && i < funcType->GetParamAttrsList().size(); ++i) {
+      if (!IsSameBoundary(
+          srcFuncType->GetNthParamAttrs(i).GetAttrBoundary(), funcType->GetNthParamAttrs(i).GetAttrBoundary())) {
+        errIdxs.emplace_back(i);
+      }
+    }
+    if (!errIdxs.empty()) {
+      FE_ERR(kLncErr, loc, "function pointer's boundary attributes are mismatched for the %s argument",
+             PrintParamIdx(errIdxs).c_str());
+    }
+    if (!IsSameBoundary(srcFuncType->GetRetAttrs().GetAttrBoundary(), funcType->GetRetAttrs().GetAttrBoundary())) {
+      FE_ERR(kLncErr, loc, "function pointer's boundary attributes are mismatched for the return value");
+    }
+  }
+}
+
+void FEIRStmtDAssign::CheckBoundaryArgsAndRetForFuncPtr(const MIRBuilder &mirBuilder) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || ENCChecker::IsUnsafeRegion(mirBuilder)) {
+    return;
+  }
+  MIRType *baseType = var->GetType()->GenerateMIRTypeAuto();
+  if (fieldID != 0) {
+    baseType = FEUtils::GetStructFieldType(static_cast<MIRStructType*>(baseType), fieldID);
+  }
+  ENCChecker::CheckBoundaryArgsAndRetForFuncPtr(*baseType, expr, loc);
+}
+
+void FEIRStmtIAssign::CheckBoundaryArgsAndRetForFuncPtr(const MIRBuilder &mirBuilder, const MIRType &baseType) const {
+  if (!FEOptions::GetInstance().IsBoundaryCheckDynamic() || ENCChecker::IsUnsafeRegion(mirBuilder)) {
+    return;
+  }
+  MIRType *fieldType = FEUtils::GetStructFieldType(static_cast<const MIRStructType*>(&baseType), fieldID);
+  ENCChecker::CheckBoundaryArgsAndRetForFuncPtr(*fieldType, baseExpr, loc);
+}
+
+// ---------------------------
+// process safe region
+// ---------------------------
+bool ENCChecker::IsSafeRegion(const MIRBuilder &mirBuilder) {
+  bool isSafe = false;
+  if (FEOptions::GetInstance().IsEnableSafeRegion()) {
+    isSafe = mirBuilder.GetCurrentFunctionNotNull()->GetAttr(FUNCATTR_safed);
+    if (!FEManager::GetCurrentFEFunction().GetSafeRegionFlag().empty()) {
+      isSafe = FEManager::GetCurrentFEFunction().GetSafeRegionFlag().top();
+    }
+  }
+  return isSafe;
+}
+
+bool ENCChecker::IsUnsafeRegion(const MIRBuilder &mirBuilder) {
+  bool isUnsafe = false;
+  if (FEOptions::GetInstance().IsEnableSafeRegion()) {
+    isUnsafe = mirBuilder.GetCurrentFunctionNotNull()->GetAttr(FUNCATTR_unsafed);
+    if (!FEManager::GetCurrentFEFunction().GetSafeRegionFlag().empty()) {
+      isUnsafe = !FEManager::GetCurrentFEFunction().GetSafeRegionFlag().top();
+    }
+  }
+  return isUnsafe;
+}
+}
diff --git a/src/hir2mpl/common/src/fe_config_parallel.cpp b/src/hir2mpl/common/src/fe_config_parallel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..980373dda4920b96f39474ce315c371d8bc3dbe1
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_config_parallel.cpp
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_config_parallel.h"
+
+namespace maple {
+FEConfigParallel FEConfigParallel::instance;
+
+FEConfigParallel::FEConfigParallel()
+    : nThread(0), enableParallel(false) {}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/fe_file_ops.cpp b/src/hir2mpl/common/src/fe_file_ops.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..067071980a47957c9928fa98b35f550dc32b4a11
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_file_ops.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_file_ops.h"
+
+namespace maple {
+std::string FEFileOps::GetFilePath(const std::string &pathName) {
+  size_t pos = pathName.find_last_of('/');
+  if (pos == std::string::npos) {
+    return "";
+  } else {
+    return pathName.substr(0, pos + 1);
+  }
+}
+
+std::string FEFileOps::GetFileNameWithExt(const std::string &pathName) {
+  size_t pos = pathName.find_last_of('/');
+  if (pos == std::string::npos) {
+    return pathName;
+  } else {
+    return pathName.substr(pos + 1);
+  }
+}
+
+std::string FEFileOps::GetFileName(const std::string &pathName) {
+  std::string nameWithExt = GetFileNameWithExt(pathName);
+  size_t pos = nameWithExt.find_last_of(".");
+  if (pos == std::string::npos) {
+    return nameWithExt;
+  } else {
+    return nameWithExt.substr(0, pos);
+  }
+}
+
+std::string FEFileOps::GetFileExtName(const std::string &pathName) {
+  std::string nameWithExt = GetFileNameWithExt(pathName);
+  size_t pos = nameWithExt.find_last_of(".");
+  if (pos == std::string::npos) {
+    return "";
+  } else {
+    return nameWithExt.substr(pos + 1);
+  }
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/fe_file_type.cpp b/src/hir2mpl/common/src/fe_file_type.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..65e4a594e8b2e06e5ca70bf547af2703a713b9c4
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_file_type.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_file_type.h"
+#include <fstream>
+#include "mpl_logging.h"
+
+namespace maple {
+FEFileType FEFileType::fileType;
+
+FEFileType::FEFileType() {
+  LoadDefault();
+}
+
+FEFileType::FileType FEFileType::GetFileTypeByExtName(const std::string &extName) const {
+  if (extName.empty()) {
+    WARN(kLncWarn, "Empty input for GetFileTypeByExtName()...skipped");
+    return kUnknownType;
+  }
+  auto itExtNameType = mapExtNameType.find(extName);
+  if (itExtNameType == mapExtNameType.end()) {
+    WARN(kLncWarn, "Unknown file extension name %s...skipped", extName.c_str());
+    return kUnknownType;
+  }
+  return itExtNameType->second;
+}
+
+FEFileType::FileType FEFileType::GetFileTypeByPathName(const std::string &pathName) const {
+  std::string extName = GetExtName(pathName);
+  return GetFileTypeByExtName(extName);
+}
+
+FEFileType::FileType FEFileType::GetFileTypeByMagicNumber(const std::string &pathName) const {
+  std::ifstream file(pathName);
+  if (!file.is_open()) {
+    ERR(kLncErr, "unable to open file %s", pathName.c_str());
+    return kUnknownType;
+  }
+  uint32 magic = 0;
+  int lenght = static_cast<int>(sizeof(uint32));
+  (void)file.read(reinterpret_cast<char*>(&magic), lenght);
+  file.close();
+  return GetFileTypeByMagicNumber(magic);
+}
+
+FEFileType::FileType FEFileType::GetFileTypeByMagicNumber(BasicIOMapFile &file) const {
+  BasicIORead fileReader(file);
+  bool success = false;
+  uint32 magic = fileReader.ReadUInt32(success);
+  if (!success) {
+    ERR(kLncErr, "unable to open file %s", file.GetFileName().c_str());
+    return kUnknownType;
+  }
+  return GetFileTypeByMagicNumber(magic);
+}
+
+FEFileType::FileType FEFileType::GetFileTypeByMagicNumber(uint32 magic) const {
+  std::map<uint32, FileType>::const_iterator it = mapMagicType.find(magic);
+  if (it != mapMagicType.end()) {
+    return it->second;
+  } else {
+    return kUnknownType;
+  }
+}
+
+void FEFileType::Reset() {
+  mapExtNameType.clear();
+  mapTypeMagic.clear();
+  mapMagicType.clear();
+}
+
+void FEFileType::LoadDefault() {
+  Reset();
+  RegisterExtName(kClass, "class");
+  RegisterMagicNumber(kClass, kMagicClass);
+  RegisterExtName(kJar, "jar");
+  RegisterMagicNumber(kJar, kMagicZip);
+  RegisterExtName(kDex, "dex");
+  RegisterMagicNumber(kDex, kMagicDex);
+  RegisterExtName(kAST, "ast");
+  RegisterMagicNumber(kAST, kMagicAST);
+  RegisterExtName(kMAST, "mast");
+  RegisterMagicNumber(kMAST, kMagicMAST);
+}
+
+void FEFileType::RegisterExtName(FileType argFileType, const std::string &extName) {
+  if (extName.empty() || argFileType == kUnknownType) {
+    WARN(kLncWarn, "Invalid input for RegisterMagicNumber()...skipped");
+    return;
+  }
+  mapExtNameType[extName] = argFileType;
+  mapTypeMagic[argFileType] = 0;
+}
+
+void FEFileType::RegisterMagicNumber(FileType argFileType, uint32 magicNumber) {
+  if (magicNumber == 0 || argFileType == kUnknownType) {
+    WARN(kLncWarn, "Invalid input for RegisterMagicNumber()...skipped");
+    return;
+  }
+  mapTypeMagic[argFileType] = magicNumber;
+  mapMagicType[magicNumber] = argFileType;
+}
+
+std::string FEFileType::GetPath(const std::string &pathName) {
+  size_t pos = pathName.find_last_of('/');
+  if (pos != std::string::npos) {
+    return pathName.substr(0, pos + 1);
+  } else {
+    return "";
+  }
+}
+
+std::string FEFileType::GetName(const std::string &pathName, bool withExt) {
+  size_t pos = pathName.find_last_of('/');
+  std::string name = "";
+  if (pos != std::string::npos) {
+    name = pathName.substr(pos + 1);
+  } else {
+    name = pathName;
+  }
+  if (withExt) {
+    return name;
+  }
+  size_t posDot = name.find_last_of('.');
+  if (posDot != std::string::npos) {
+    return name.substr(0, posDot);
+  } else {
+    return name;
+  }
+}
+
+std::string FEFileType::GetExtName(const std::string &pathName) {
+  std::string name = GetName(pathName, true);
+  size_t pos = name.find_last_of('.');
+  if (pos != std::string::npos) {
+    return name.substr(pos + 1);
+  } else {
+    return "";
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/fe_function.cpp b/src/hir2mpl/common/src/fe_function.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2e55bb4b07110de0ee7fc69a394272a4d94da0a0
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_function.cpp
@@ -0,0 +1,856 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_function.h"
+#include "feir_bb.h"
+#include "mpl_logging.h"
+#include "fe_options.h"
+#include "fe_manager.h"
+#include "feir_var_name.h"
+#include "feir_var_reg.h"
+#include "hir2mpl_env.h"
+#include "feir_builder.h"
+#include "feir_dfg.h"
+#include "feir_type_helper.h"
+#include "feir_var_type_scatter.h"
+#include "fe_options.h"
+
+namespace maple {
+FEFunction::FEFunction(MIRFunction &argMIRFunction, const std::unique_ptr<FEFunctionPhaseResult> &argPhaseResultTotal)
+    : genStmtHead(nullptr),
+      genStmtTail(nullptr),
+      genBBHead(nullptr),
+      genBBTail(nullptr),
+      feirStmtHead(nullptr),
+      feirStmtTail(nullptr),
+      feirBBHead(nullptr),
+      feirBBTail(nullptr),
+      phaseResult(FEOptions::GetInstance().IsDumpPhaseTimeDetail() || FEOptions::GetInstance().IsDumpPhaseTime()),
+      phaseResultTotal(argPhaseResultTotal),
+      mirFunction(argMIRFunction) {}
+
+FEFunction::~FEFunction() {
+  genStmtHead = nullptr;
+  genStmtTail = nullptr;
+  genBBHead = nullptr;
+  genBBTail = nullptr;
+  feirStmtHead = nullptr;
+  feirStmtTail = nullptr;
+  feirBBHead = nullptr;
+  feirBBTail = nullptr;
+}
+
+void FEFunction::InitImpl() {
+  // feir stmt/bb
+  feirStmtHead = RegisterFEIRStmt(std::make_unique<FEIRStmt>(FEIRNodeKind::kStmtPesudoFuncStart));
+  feirStmtTail = RegisterFEIRStmt(std::make_unique<FEIRStmt>(FEIRNodeKind::kStmtPesudoFuncEnd));
+  feirStmtHead->SetNext(feirStmtTail);
+  feirStmtTail->SetPrev(feirStmtHead);
+  feirBBHead = RegisterFEIRBB(std::make_unique<FEIRBB>(FEIRBBKind::kBBKindPesudoHead));
+  feirBBTail = RegisterFEIRBB(std::make_unique<FEIRBB>(FEIRBBKind::kBBKindPesudoTail));
+  feirBBHead->SetNext(feirBBTail);
+  feirBBTail->SetPrev(feirBBHead);
+}
+
+void FEFunction::AppendFEIRStmts(std::list<UniqueFEIRStmt> &stmts) {
+  ASSERT_NOT_NULL(feirStmtTail);
+  InsertFEIRStmtsBefore(*feirStmtTail, stmts);
+}
+
+void FEFunction::InsertFEIRStmtsBefore(FEIRStmt &pos, std::list<UniqueFEIRStmt> &stmts) {
+  while (stmts.size() > 0) {
+    FEIRStmt *ptrFEIRStmt = RegisterFEIRStmt(std::move(stmts.front()));
+    stmts.pop_front();
+    pos.InsertBefore(ptrFEIRStmt);
+  }
+}
+
+FEIRStmt *FEFunction::RegisterGeneralStmt(std::unique_ptr<FEIRStmt> stmt) {
+  genStmtList.push_back(std::move(stmt));
+  return genStmtList.back().get();
+}
+
+const std::unique_ptr<FEIRStmt> &FEFunction::RegisterGeneralStmtUniqueReturn(std::unique_ptr<FEIRStmt> stmt) {
+  genStmtList.push_back(std::move(stmt));
+  return genStmtList.back();
+}
+
+FEIRStmt *FEFunction::RegisterFEIRStmt(UniqueFEIRStmt stmt) {
+  feirStmtList.push_back(std::move(stmt));
+  return feirStmtList.back().get();
+}
+
+FEIRBB *FEFunction::RegisterFEIRBB(std::unique_ptr<FEIRBB> bb) {
+  feirBBList.push_back(std::move(bb));
+  return feirBBList.back().get();
+}
+
+void FEFunction::DumpGeneralStmts() {
+  FELinkListNode *nodeStmt = genStmtHead;
+  while (nodeStmt != nullptr) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    stmt->Dump();
+    nodeStmt = nodeStmt->GetNext();
+  }
+}
+
+bool FEFunction::LowerFunc(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  if (feirLower == nullptr) {
+    feirLower = std::make_unique<FEIRLower>(*this);
+    feirLower->LowerFunc();
+    feirStmtHead = feirLower->GetlowerStmtHead();
+    feirStmtTail = feirLower->GetlowerStmtTail();
+  }
+  return phaseResult.Finish();
+}
+
+bool FEFunction::DumpFEIRBBs(const std::string &phaseName) {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  if (feirCFG == nullptr) {
+    feirCFG = std::make_unique<FEIRCFG>(feirStmtHead, feirStmtTail);
+    feirCFG->GenerateCFG();
+  }
+  std::cout << "****** CFG built by FEIR for " << GetGeneralFuncName() << " *******\n";
+  feirCFG->DumpBBs();
+  std::cout << "****** END CFG built for " << GetGeneralFuncName() << " *******\n\n";
+  return phaseResult.Finish();
+}
+
+bool FEFunction::DumpFEIRCFGGraph(const std::string &phaseName) {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  std::string outName = FEManager::GetModule().GetFileName();
+  size_t lastDot = outName.find_last_of(".");
+  if (lastDot != std::string::npos) {
+    outName = outName.substr(0, lastDot);
+  }
+  CHECK_FATAL(!outName.empty(), "General CFG Graph FileName is empty");
+  std::string fileName = outName + "." + GetGeneralFuncName() + ".dot";
+  std::ofstream file(fileName);
+  CHECK_FATAL(file.is_open(), "Failed to open General CFG Graph FileName: %s", fileName.c_str());
+  if (feirCFG == nullptr) {
+    feirCFG = std::make_unique<FEIRCFG>(feirStmtHead, feirStmtTail);
+    feirCFG->GenerateCFG();
+  }
+  file << "digraph {" << std::endl;
+  file << "  label=\"" << GetGeneralFuncName() << "\"\n";
+  file << "  labelloc=t\n";
+  feirCFG->DumpCFGGraph(file);
+  file.close();
+  return phaseResult.Finish();
+}
+
+void FEFunction::DumpFEIRCFGGraphForDFGEdge(std::ofstream &file) {
+  file << "  subgraph cfg_edges {" << std::endl;
+  file << "    edge [color=\"#00FF00\",weight=0.3,len=3];" << std::endl;
+  file << "  }" << std::endl;
+}
+
+bool FEFunction::BuildGeneralStmtBBMap(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  FELinkListNode *nodeBB = genBBHead->GetNext();
+  while (nodeBB != nullptr && nodeBB != genBBTail) {
+    FEIRBB *bb = static_cast<FEIRBB*>(nodeBB);
+    const FELinkListNode *nodeStmt = bb->GetStmtHead();
+    while (nodeStmt != nullptr) {
+      const FEIRStmt *stmt = static_cast<const FEIRStmt*>(nodeStmt);
+      genStmtBBMap[stmt] = bb;
+      if (nodeStmt == bb->GetStmtTail()) {
+        break;
+      }
+      nodeStmt = nodeStmt->GetNext();
+    }
+    nodeBB = nodeBB->GetNext();
+  }
+  return phaseResult.Finish();
+}
+
+bool FEFunction::LabelGeneralStmts(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  uint32 idx = 0;
+  FELinkListNode *nodeStmt = genStmtHead;
+  while (nodeStmt != nullptr) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    stmt->SetID(idx);
+    idx++;
+    nodeStmt = nodeStmt->GetNext();
+  }
+  return phaseResult.Finish();
+}
+
+bool FEFunction::LabelFEIRBBs(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  uint32 idx = 0;
+  FELinkListNode *nodeBB = genBBHead->GetNext();
+  while (nodeBB != nullptr && nodeBB != genBBTail) {
+    FEIRBB *bb = static_cast<FEIRBB*>(nodeBB);
+    bb->SetID(idx);
+    idx++;
+    nodeBB = nodeBB->GetNext();
+  }
+  return phaseResult.Finish();
+}
+
+std::string FEFunction::GetGeneralFuncName() const {
+  return mirFunction.GetName();
+}
+
+void FEFunction::PhaseTimerStart(FETimerNS &timer) const {
+  if (!FEOptions::GetInstance().IsDumpPhaseTime()) {
+    return;
+  }
+  timer.Start();
+}
+
+void FEFunction::PhaseTimerStopAndDump(FETimerNS &timer, const std::string &label) const {
+  if (!FEOptions::GetInstance().IsDumpPhaseTime()) {
+    return;
+  }
+  timer.Stop();
+  INFO(kLncInfo, "[PhaseTime]   %s: %lld ns", label.c_str(), timer.GetTimeNS());
+}
+
+bool FEFunction::UpdateFormal(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  mirFunction.ClearFormals();
+  FEManager::GetMIRBuilder().SetCurrentFunction(mirFunction);
+  for (const std::unique_ptr<FEIRVar> &argVar : argVarList) {
+    MIRSymbol *sym = argVar->GenerateMIRSymbol(FEManager::GetMIRBuilder());
+    sym->SetStorageClass(kScFormal);
+    mirFunction.AddArgument(sym);
+  }
+  return phaseResult.Finish();
+}
+
+std::string FEFunction::GetDescription() {
+  std::stringstream ss;
+  std::string oriFuncName = GetGeneralFuncName();
+  std::string mplFuncName = namemangler::EncodeName(oriFuncName);
+  ss << "ori function name: " << oriFuncName << std::endl;
+  ss << "mpl function name: " << mplFuncName << std::endl;
+  ss << "parameter list:" << "(";
+  for (const std::unique_ptr<FEIRVar> &argVar : argVarList) {
+    ss << argVar->GetNameRaw() << ", ";
+  }
+  ss << ") {" << std::endl;
+  FELinkListNode *node = feirStmtHead->GetNext();
+  while (node != feirStmtTail) {
+    FEIRStmt *currStmt = static_cast<FEIRStmt*>(node);
+    ss << currStmt->DumpDotString() << std::endl;
+    node = node->GetNext();
+  }
+  ss << "}" << std::endl;
+  return ss.str();
+}
+
+bool FEFunction::EmitToMIR(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  mirFunction.NewBody();
+  FEManager::GetMIRBuilder().SetCurrentFunction(mirFunction);
+  FEManager::SetCurrentFEFunction(*this);
+  BuildMapLabelIdx();
+  EmitToMIRStmt();
+  return phaseResult.Finish();
+}
+
+const FEIRStmtPesudoLOC *FEFunction::GetLOCForStmt(const FEIRStmt &feIRStmt) const {
+  if (!feIRStmt.ShouldHaveLOC()) {
+    return nullptr;
+  }
+  FELinkListNode *prevNode = static_cast<FELinkListNode*>(feIRStmt.GetPrev());
+  while (prevNode != nullptr) {
+    if ((*static_cast<FEIRStmt*>(prevNode)).ShouldHaveLOC()) {
+      return nullptr;
+    }
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(prevNode);
+    if (stmt->GetKind() == kStmtPesudoLOC) {
+      FEIRStmtPesudoLOC *loc = static_cast<FEIRStmtPesudoLOC*>(stmt);
+      return loc;
+    }
+    prevNode = prevNode->GetPrev();
+  }
+  return nullptr;
+}
+
+void FEFunction::BuildMapLabelIdx() {
+  FELinkListNode *nodeStmt = feirStmtHead->GetNext();
+  while (nodeStmt != nullptr && nodeStmt != feirStmtTail) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    if (stmt->GetKind() == FEIRNodeKind::kStmtPesudoLabel) {
+      FEIRStmtPesudoLabel *stmtLabel = static_cast<FEIRStmtPesudoLabel*>(stmt);
+      stmtLabel->GenerateLabelIdx(FEManager::GetMIRBuilder());
+      mapLabelIdx[stmtLabel->GetLabelIdx()] = stmtLabel->GetMIRLabelIdx();
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+}
+
+bool FEFunction::CheckPhaseResult(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  bool success = phaseResult.IsSuccess();
+  return phaseResult.Finish(success);
+}
+
+bool FEFunction::ProcessFEIRFunction() {
+  bool success = true;
+  success = success && BuildMapLabelStmt("fe/build map label stmt");
+  success = success && SetupFEIRStmtJavaTry("fe/setup stmt javatry");
+  success = success && SetupFEIRStmtBranch("fe/setup stmt branch");
+  success = success && UpdateRegNum2This("fe/update reg num to this pointer");
+  return success;
+}
+
+bool FEFunction::BuildMapLabelStmt(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  FELinkListNode *nodeStmt = feirStmtHead->GetNext();
+  while (nodeStmt != nullptr && nodeStmt != feirStmtTail) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    FEIRNodeKind kind = stmt->GetKind();
+    switch (kind) {
+      case FEIRNodeKind::kStmtPesudoLabel:
+      case FEIRNodeKind::kStmtPesudoJavaCatch: {
+        FEIRStmtPesudoLabel *stmtLabel = static_cast<FEIRStmtPesudoLabel*>(stmt);
+        mapLabelStmt[stmtLabel->GetLabelIdx()] = stmtLabel;
+        break;
+      }
+      default:
+        break;
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+  return phaseResult.Finish();
+}
+
+bool FEFunction::SetupFEIRStmtJavaTry(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  FELinkListNode *nodeStmt = feirStmtHead->GetNext();
+  while (nodeStmt != nullptr && nodeStmt != feirStmtTail) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    if (stmt->GetKind() == FEIRNodeKind::kStmtPesudoJavaTry) {
+      FEIRStmtPesudoJavaTry *stmtJavaTry = static_cast<FEIRStmtPesudoJavaTry*>(stmt);
+      for (uint32 labelIdx : stmtJavaTry->GetCatchLabelIdxVec()) {
+        auto it = mapLabelStmt.find(labelIdx);
+        CHECK_FATAL(it != mapLabelStmt.cend(), "label is not found");
+        stmtJavaTry->AddCatchTarget(*(it->second));
+      }
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+  return phaseResult.Finish();
+}
+
+bool FEFunction::SetupFEIRStmtBranch(const std::string &phaseName) {
+  phaseResult.RegisterPhaseNameAndStart(phaseName);
+  bool success = true;
+  FELinkListNode *nodeStmt = feirStmtHead->GetNext();
+  while (nodeStmt != nullptr && nodeStmt != feirStmtTail) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    FEIRNodeKind kind = stmt->GetKind();
+    switch (kind) {
+      case FEIRNodeKind::kStmtGoto:
+      case FEIRNodeKind::kStmtCondGoto:
+        success = success && SetupFEIRStmtGoto(*(static_cast<FEIRStmtGoto*>(stmt)));
+        break;
+      case FEIRNodeKind::kStmtSwitch:
+        success = success && SetupFEIRStmtSwitch(*(static_cast<FEIRStmtSwitch*>(stmt)));
+        break;
+      default:
+        break;
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+  return phaseResult.Finish(success);
+}
+
+bool FEFunction::SetupFEIRStmtGoto(FEIRStmtGoto &stmt) {
+  auto it = mapLabelStmt.find(stmt.GetLabelIdx());
+  if (it == mapLabelStmt.cend()) {
+    ERR(kLncErr, "target not found for stmt goto");
+    return false;
+  }
+  stmt.SetStmtTarget(*(it->second));
+  return true;
+}
+
+bool FEFunction::SetupFEIRStmtSwitch(FEIRStmtSwitch &stmt) {
+  // default target
+  auto itDefault = mapLabelStmt.find(stmt.GetDefaultLabelIdx());
+  if (itDefault == mapLabelStmt.cend()) {
+    ERR(kLncErr, "target not found for stmt goto");
+    return false;
+  }
+  stmt.SetDefaultTarget(*(itDefault->second));
+
+  // value targets
+  for (const auto &itItem : stmt.GetMapValueLabelIdx()) {
+    auto itTarget = mapLabelStmt.find(itItem.second);
+    if (itTarget == mapLabelStmt.cend()) {
+      ERR(kLncErr, "target not found for stmt goto");
+      return false;
+    }
+    stmt.AddTarget(itItem.first, *(itTarget->second));
+  }
+  return true;
+}
+
+bool FEFunction::UpdateRegNum2This(const std::string &phaseName) {
+  bool success = CheckPhaseResult(phaseName);
+  if (!success) {
+    return success;
+  }
+  if (!HasThis()) {
+    return success;
+  }
+  const std::unique_ptr<FEIRVar> &firstArg = argVarList.front();
+  std::unique_ptr<FEIRVar> varReg = firstArg->Clone();
+  GStrIdx thisNameIdx = FEUtils::GetThisIdx();
+  std::unique_ptr<FEIRVar> varThisAsParam = std::make_unique<FEIRVarName>(thisNameIdx, varReg->GetType()->Clone());
+  if (!IsNative()) {
+    std::unique_ptr<FEIRVar> varThisAsLocalVar = std::make_unique<FEIRVarName>(thisNameIdx, varReg->GetType()->Clone());
+    std::unique_ptr<FEIRExpr> dReadThis = std::make_unique<FEIRExprDRead>(std::move(varThisAsLocalVar));
+    std::unique_ptr<FEIRStmt> daStmt = std::make_unique<FEIRStmtDAssign>(std::move(varReg), std::move(dReadThis));
+    FEIRStmt *stmt = RegisterFEIRStmt(std::move(daStmt));
+    FELinkListNode::InsertAfter(stmt, feirStmtHead);
+  }
+  argVarList[0].reset(varThisAsParam.release());
+  return success;
+}
+
+void FEFunction::OutputStmts() const {
+  FELinkListNode *node = feirStmtHead->GetNext();
+  while (node != feirStmtTail) {
+    FEIRStmt *currStmt = static_cast<FEIRStmt*>(node);
+    LogInfo::MapleLogger() << currStmt->DumpDotString() <<  "\n";
+    node = node->GetNext();
+  }
+}
+
+void FEFunction::LabelFEIRStmts() {
+  // stmt idx start from 1
+  FELinkListNode *node = feirStmtHead->GetNext();
+  uint32 id = 1;
+  while (node != feirStmtTail) {
+    FEIRStmt *currStmt = static_cast<FEIRStmt*>(node);
+    currStmt->SetID(id++);
+    node = node->GetNext();
+  }
+  stmtCount = --id;
+}
+
+bool FEFunction::ShouldNewBB(const FEIRBB *currBB, const FEIRStmt &currStmt) const {
+  if (currBB == nullptr) {
+    return true;
+  }
+  if (currStmt.IsTarget()) {
+    if (currBB->GetStmtNoAuxTail() != nullptr) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool FEFunction::IsBBEnd(const FEIRStmt &stmt) const {
+  bool currStmtMayBeBBEnd = MayBeBBEnd(stmt);
+  if (currStmtMayBeBBEnd) {
+    FELinkListNode *node = stmt.GetNext();
+    FEIRStmt *nextStmt = static_cast<FEIRStmt*>(node);
+    if (nextStmt->IsAuxPost()) {  // if curr stmt my be BB end, but next stmt is AuxPost
+      return false;  // curr stmt should not be BB end
+    }
+    return true;
+  }
+  if (stmt.IsAuxPost()) {
+    FELinkListNode *node = stmt.GetPrev();
+    FEIRStmt *prevStmt = static_cast<FEIRStmt*>(node);
+    bool prevStmtMayBeBBEnd = MayBeBBEnd(*prevStmt);  // if curr stmt is AuxPost, and prev stmt my be BB end
+    return prevStmtMayBeBBEnd;  // return prev stmt my be BB end as result
+  }
+  return currStmtMayBeBBEnd;
+}
+
+bool FEFunction::MayBeBBEnd(const FEIRStmt &stmt) const {
+  return (stmt.IsBranch() || !stmt.IsFallThru());
+}
+
+void FEFunction::LinkFallThroughBBAndItsNext(FEIRBB &bb) {
+  if (!CheckBBsStmtNoAuxTail(bb)) {
+    return;
+  }
+  if (!bb.IsFallThru()) {
+    return;
+  }
+  FELinkListNode *node = bb.GetNext();
+  FEIRBB *nextBB = static_cast<FEIRBB*>(node);
+  if (nextBB != feirBBTail) {
+    LinkBB(bb, *nextBB);
+  }
+}
+
+void FEFunction::LinkBranchBBAndItsTargets(FEIRBB &bb) {
+  if (!CheckBBsStmtNoAuxTail(bb)) {
+    return;
+  }
+  if (!bb.IsBranch()) {
+    return;
+  }
+  const FEIRStmt *stmtTail = bb.GetStmtNoAuxTail();
+  FEIRNodeKind nodeKind = stmtTail->GetKind();
+  switch (nodeKind) {
+    case FEIRNodeKind::kStmtCondGoto:
+    case FEIRNodeKind::kStmtGoto: {
+      LinkGotoBBAndItsTarget(bb, *stmtTail);
+      break;
+    }
+    case FEIRNodeKind::kStmtSwitch: {
+      LinkSwitchBBAndItsTargets(bb, *stmtTail);
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "nodeKind %u is not branch", nodeKind);
+      break;
+    }
+  }
+}
+
+void FEFunction::LinkGotoBBAndItsTarget(FEIRBB &bb, const FEIRStmt &stmtTail) {
+  const FEIRStmtGoto2 &gotoStmt = static_cast<const FEIRStmtGoto2&>(stmtTail);
+  const FEIRStmtPesudoLabel2 &targetStmt = gotoStmt.GetStmtTargetRef();
+  FEIRBB &targetBB = GetFEIRBBByStmt(targetStmt);
+  LinkBB(bb, targetBB);
+}
+
+void FEFunction::LinkSwitchBBAndItsTargets(FEIRBB &bb, const FEIRStmt &stmtTail) {
+  const FEIRStmtSwitch2 &switchStmt = static_cast<const FEIRStmtSwitch2&>(stmtTail);
+  const std::map<int32, FEIRStmtPesudoLabel2*> &mapValueTargets = switchStmt.GetMapValueTargets();
+  for (auto it : mapValueTargets) {
+    FEIRStmtPesudoLabel2 *pesudoLabel = it.second;
+    FEIRBB &targetBB = GetFEIRBBByStmt(*pesudoLabel);
+    LinkBB(bb, targetBB);
+  }
+  FEIRBB &targetBB = GetFEIRBBByStmt(switchStmt.GetDefaultTarget());
+  LinkBB(bb, targetBB);
+}
+
+void FEFunction::LinkBB(FEIRBB &predBB, FEIRBB &succBB) {
+  predBB.AddSuccBB(&succBB);
+  succBB.AddPredBB(&predBB);
+}
+
+FEIRBB &FEFunction::GetFEIRBBByStmt(const FEIRStmt &stmt) {
+  auto it = feirStmtBBMap.find(&stmt);
+  return *(it->second);
+}
+
+bool FEFunction::CheckBBsStmtNoAuxTail(const FEIRBB &bb) const {
+  bool bbHasStmtNoAuxTail = (bb.GetStmtNoAuxTail() != nullptr);
+  CHECK_FATAL(bbHasStmtNoAuxTail, "Error accured in BuildFEIRBB phase, bb.GetStmtNoAuxTail() should not be nullptr");
+  return true;
+}
+
+void FEFunction::InsertCheckPointForBBs() {
+  FELinkListNode *node = feirBBHead->GetNext();
+  while (node != feirBBTail) {
+    FEIRBB *currBB = static_cast<FEIRBB*>(node);  // get currBB
+    // create chekPointIn
+    std::unique_ptr<FEIRStmtCheckPoint> chekPointIn = std::make_unique<FEIRStmtCheckPoint>();
+    currBB->SetCheckPointIn(std::move(chekPointIn));  // set to currBB's checkPointIn
+    FEIRStmtCheckPoint &cpIn = currBB->GetCheckPointIn();
+    currBB->InsertAndUpdateNewHead(&cpIn);  // insert and update new head to chekPointIn
+    (void)feirStmtBBMap.insert(std::make_pair(&cpIn, currBB));  // add pair to feirStmtBBMap
+    // create chekPointOut
+    std::unique_ptr<FEIRStmtCheckPoint> chekPointOut = std::make_unique<FEIRStmtCheckPoint>();
+    currBB->SetCheckPointOut(std::move(chekPointOut));  // set to currBB's checkPointOut
+    FEIRStmtCheckPoint &cpOut = currBB->GetCheckPointOut();
+    currBB->InsertAndUpdateNewTail(&cpOut);  // insert and update new tail to chekPointOut
+    (void)feirStmtBBMap.insert(std::make_pair(&cpOut, currBB));  // add pair to feirStmtBBMap
+    // get next BB
+    node = node->GetNext();
+  }
+}
+
+void FEFunction::InsertCheckPointForTrys() {
+  FEIRStmtPesudoJavaTry2 *currTry = nullptr;
+  FEIRStmtCheckPoint *checkPointInTry = nullptr;
+  FELinkListNode *node = feirStmtHead->GetNext();
+  while (node != feirStmtTail) {
+    FEIRStmt *currStmt = static_cast<FEIRStmt*>(node);
+    if (currStmt->GetKind() == FEIRNodeKind::kStmtPesudoJavaTry) {
+      currTry = static_cast<FEIRStmtPesudoJavaTry2*>(currStmt);
+      checkPointInTry = nullptr;
+    }
+    if ((currTry != nullptr) &&
+        (currStmt->IsThrowable()) &&
+        ((checkPointInTry == nullptr) || currStmt->HasDef())) {
+      FEIRBB &currBB = GetFEIRBBByStmt(*currStmt);
+      if (currStmt == currBB.GetStmtNoAuxHead()) {
+        checkPointInTry = &(currBB.GetCheckPointIn());
+        (void)checkPointJavaTryMap.insert(std::make_pair(checkPointInTry, currTry));
+        if (currStmt == currBB.GetStmtHead()) {
+          currBB.SetStmtHead(currStmt);
+        }
+        node = node->GetNext();
+        continue;
+      }
+      std::unique_ptr<FEIRStmtCheckPoint> newCheckPoint = std::make_unique<FEIRStmtCheckPoint>();
+      currBB.AddCheckPoint(std::move(newCheckPoint));
+      checkPointInTry = currBB.GetLatestCheckPoint();
+      CHECK_NULL_FATAL(checkPointInTry);
+      FELinkListNode::InsertBefore(checkPointInTry, currStmt);
+      (void)feirStmtBBMap.insert(std::make_pair(checkPointInTry, &currBB));
+      (void)checkPointJavaTryMap.insert(std::make_pair(checkPointInTry, currTry));
+      if (currStmt == currBB.GetStmtHead()) {
+        currBB.SetStmtHead(currStmt);
+      }
+    }
+    if (currStmt->GetKind() == FEIRNodeKind::kStmtPesudoEndTry) {
+      currTry = nullptr;
+    }
+    node = node->GetNext();
+  }
+}
+
+void FEFunction::InitTrans4AllVars() {
+  FELinkListNode *node = feirStmtHead->GetNext();
+  while (node != feirStmtTail) {
+    FEIRStmt *currStmt = static_cast<FEIRStmt*>(node);
+    currStmt->InitTrans4AllVars();
+    node = node->GetNext();
+  }
+}
+
+FEIRStmtPesudoJavaTry2 &FEFunction::GetJavaTryByCheckPoint(FEIRStmtCheckPoint &checkPoint) {
+  auto it = checkPointJavaTryMap.find(&checkPoint);
+  return *(it->second);
+}
+
+FEIRStmtCheckPoint &FEFunction::GetCheckPointByFEIRStmt(const FEIRStmt &stmt) {
+  auto it = feirStmtCheckPointMap.find(&stmt);
+  return *(it->second);
+}
+
+void FEFunction::SetUpDefVarTypeScatterStmtMap() {
+  FELinkListNode *node = feirStmtHead->GetNext();
+  while (node != feirStmtTail) {
+    FEIRStmt *currStmt = static_cast<FEIRStmt*>(node);
+    FEIRVarTypeScatter *defVarTypeScatter = currStmt->GetTypeScatterDefVar();
+    if (defVarTypeScatter != nullptr) {
+      (void)defVarTypeScatterStmtMap.insert(std::make_pair(defVarTypeScatter, currStmt));
+    }
+    node = node->GetNext();
+  }
+}
+
+void FEFunction::InsertRetypeStmtsAfterDef(const UniqueFEIRVar& def) {
+  bool defIsTypeScatter = (def->GetKind() == kFEIRVarTypeScatter);
+  if (!defIsTypeScatter) {
+    return;
+  }
+  FEIRVarTypeScatter &fromVar = *(static_cast<FEIRVarTypeScatter*>(def.get()));
+  const std::unordered_set<FEIRTypeKey, FEIRTypeKeyHash> &scatterTypes = fromVar.GetScatterTypes();
+  for (auto &it : scatterTypes) {
+    const maple::FEIRTypeKey &typeKey = it;
+    FEIRType &toType = *(typeKey.GetType());
+    FEIRType &fromType = *(fromVar.GetType());
+    Opcode opcode = FEIRTypeCvtHelper::ChooseCvtOpcodeByFromTypeAndToType(fromType, toType);
+    if (opcode == OP_retype) {
+      InsertRetypeStmt(fromVar, toType);
+    } else if (opcode == OP_cvt) {
+      InsertCvtStmt(fromVar, toType);
+    } else {
+      InsertJavaMergeStmt(fromVar, toType);
+    }
+  }
+}
+
+void FEFunction::InsertRetypeStmt(const FEIRVarTypeScatter &fromVar, const FEIRType &toType) {
+  // create DRead Expr
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(fromVar.GetVar()->Clone());
+  std::unique_ptr<FEIRType> typeDst = FEIRTypeHelper::CreatePointerType(toType.Clone(), toType.GetPrimType());
+  // create expr for retype
+  std::unique_ptr<FEIRExprTypeCvt> expr = std::make_unique<FEIRExprTypeCvt>(std::move(typeDst), OP_retype,
+                                                                            std::move(exprDRead));
+  // after expr created, insert dassign stmt
+  InsertDAssignStmt4TypeCvt(fromVar, toType, std::move(expr));
+}
+
+void FEFunction::InsertCvtStmt(const FEIRVarTypeScatter &fromVar, const FEIRType &toType) {
+  // create DRead Expr
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(fromVar.GetVar()->Clone());
+  // create expr for type cvt
+  std::unique_ptr<FEIRExprTypeCvt> expr = std::make_unique<FEIRExprTypeCvt>(OP_cvt, std::move(exprDRead));
+  expr->GetType()->SetPrimType(toType.GetPrimType());
+  // after expr created, insert dassign stmt
+  InsertDAssignStmt4TypeCvt(fromVar, toType, std::move(expr));
+}
+
+void FEFunction::InsertJavaMergeStmt(const FEIRVarTypeScatter &fromVar, const FEIRType &toType) {
+  // create DRead Expr
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(fromVar.GetVar()->Clone());
+  // create expr for java merge
+  std::vector<std::unique_ptr<FEIRExpr>> argOpnds;
+  argOpnds.push_back(std::move(exprDRead));
+  std::unique_ptr<FEIRExprJavaMerge> javaMergeExpr = std::make_unique<FEIRExprJavaMerge>(toType.Clone(), argOpnds);
+  // after expr created, insert dassign stmt
+  InsertDAssignStmt4TypeCvt(fromVar, toType, std::move(javaMergeExpr));
+}
+
+void FEFunction::InsertDAssignStmt4TypeCvt(const FEIRVarTypeScatter &fromVar, const FEIRType &toType,
+                                           UniqueFEIRExpr expr) {
+  FEIRVar *var = fromVar.GetVar().get();
+  CHECK_FATAL((var->GetKind() == FEIRVarKind::kFEIRVarReg), "fromVar's inner var must be var reg kind");
+  FEIRVarReg *varReg = static_cast<FEIRVarReg*>(var);
+  uint32 regNum = varReg->GetRegNum();
+  UniqueFEIRVar toVar = FEIRBuilder::CreateVarReg(regNum, toType.Clone());
+  std::unique_ptr<FEIRStmt> daStmt = std::make_unique<FEIRStmtDAssign>(std::move(toVar), std::move(expr));
+  FEIRStmt *insertedStmt = RegisterFEIRStmt(std::move(daStmt));
+  FEIRStmt &stmt = GetStmtByDefVarTypeScatter(fromVar);
+  FELinkListNode::InsertAfter(insertedStmt, &stmt);
+}
+
+FEIRStmt &FEFunction::GetStmtByDefVarTypeScatter(const FEIRVarTypeScatter &varTypeScatter) {
+  auto it = defVarTypeScatterStmtMap.find(&varTypeScatter);
+  return *(it->second);
+}
+
+bool FEFunction::WithFinalFieldsNeedBarrier(MIRClassType *classType, bool isStatic) const {
+  // final field
+  if (isStatic) {
+    // final static fields with non-primitive types
+    // the one with primitive types are all inlined
+    for (auto it : classType->GetStaticFields()) {
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(it.second.first);
+      if (it.second.second.GetAttr(FLDATTR_final) && type->GetPrimType() == PTY_ref) {
+        return true;
+      }
+    }
+  } else {
+    for (auto it : classType->GetFields()) {
+      if (it.second.second.GetAttr(FLDATTR_final)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool FEFunction::IsNeedInsertBarrier() {
+  if (mirFunction.GetAttr(FUNCATTR_constructor) ||
+      mirFunction.GetName().find("_7Cclone_7C") != std::string::npos ||
+      mirFunction.GetName().find("_7CcopyOf_7C") != std::string::npos) {
+    const std::string &className = mirFunction.GetBaseClassName();
+    MIRType *type = FEManager::GetTypeManager().GetClassOrInterfaceType(className);
+    if (type->GetKind() == kTypeClass) {
+      MIRClassType *currClass = static_cast<MIRClassType*>(type);
+      if (!mirFunction.GetAttr(FUNCATTR_constructor) ||
+          WithFinalFieldsNeedBarrier(currClass, mirFunction.GetAttr(FUNCATTR_static))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void FEFunction::EmitToMIRStmt() {
+  MIRBuilder &builder = FEManager::GetMIRBuilder();
+  FELinkListNode *nodeStmt = feirStmtHead->GetNext();
+  while (nodeStmt != nullptr && nodeStmt != feirStmtTail) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    std::list<StmtNode*> mirStmts = stmt->GenMIRStmts(builder);
+#ifdef DEBUG
+    // LOC info has been recorded in FEIRStmt already, this could be removed later.
+    AddLocForStmt(*stmt, mirStmts);
+#endif
+    for (StmtNode *mirStmt : mirStmts) {
+      builder.AddStmtInCurrentFunctionBody(*mirStmt);
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+}
+
+void FEFunction::AddLocForStmt(const FEIRStmt &stmt, std::list<StmtNode*> &mirStmts) const {
+  const FEIRStmtPesudoLOC *pesudoLoc = GetLOCForStmt(stmt);
+  if (pesudoLoc != nullptr) {
+    mirStmts.front()->GetSrcPos().SetFileNum(static_cast<uint16>(pesudoLoc->GetSrcFileIdx()));
+    mirStmts.front()->GetSrcPos().SetLineNum(pesudoLoc->GetSrcFileLineNum());
+  }
+}
+
+void FEFunction::PushFuncScope(const SrcPosition &startOfScope, const SrcPosition &endOfScope) {
+  UniqueFEIRScope feirScope = std::make_unique<FEIRScope>(scopeID++);
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    MIRScope *mirScope = mirFunction.GetScope();
+    mirScope->SetRange(startOfScope, endOfScope);
+    feirScope->SetMIRScope(mirScope);
+  }
+  scopeStack.push_front(std::move(feirScope));
+}
+
+void FEFunction::PushStmtScope(const SrcPosition &startOfScope, const SrcPosition &endOfScope, bool isControllScope) {
+  UniqueFEIRScope feirScope = std::make_unique<FEIRScope>(scopeID++);
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    MIRScope *parentMIRScope = GetTopMIRScope();
+    CHECK_NULL_FATAL(parentMIRScope);
+    MIRScope *mirScope = mirFunction.GetModule()->GetMemPool()->New<MIRScope>(mirFunction.GetModule());
+    mirScope->SetRange(startOfScope, endOfScope);
+    (void)parentMIRScope->AddScope(mirScope);
+    feirScope->SetMIRScope(mirScope);
+  }
+  feirScope->SetIsControllScope(isControllScope);
+  scopeStack.push_front(std::move(feirScope));
+}
+
+void FEFunction::PushStmtScope(bool isControllScope) {
+  UniqueFEIRScope feirScope = std::make_unique<FEIRScope>(scopeID++, isControllScope);
+  scopeStack.push_front(std::move(feirScope));
+}
+
+FEIRScope *FEFunction::GetTopFEIRScopePtr() const {
+  if (!scopeStack.empty()) {
+    return scopeStack.front().get();
+  }
+  CHECK_FATAL(false, "scope stack is empty");
+  return nullptr;
+}
+
+MIRScope *FEFunction::GetTopMIRScope() const {
+  if (scopeStack.empty()) {
+    CHECK_FATAL(false, "scope stack is empty");
+    return nullptr;
+  }
+  for (const auto &feirScope : scopeStack) {
+    if (feirScope->GetMIRScope() != nullptr) {
+      return feirScope->GetMIRScope();
+    }
+  }
+  return nullptr;
+}
+
+UniqueFEIRScope FEFunction::PopTopScope() {
+  if (!scopeStack.empty()) {
+    UniqueFEIRScope scope = std::move(scopeStack.front());
+    scopeStack.pop_front();
+    return scope;
+  }
+  CHECK_FATAL(false, "scope stack is empty");
+  return nullptr;
+}
+
+void FEFunction::AddVLACleanupStmts(std::list<UniqueFEIRStmt> &stmts) {
+  (void)stmts;
+  CHECK_FATAL(false, "AddVLACleanupStmts only support astfunction");
+};
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/fe_function_phase_result.cpp b/src/hir2mpl/common/src/fe_function_phase_result.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..16ce9e51bbf2048c9a7733a635e0cbb49b69feee
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_function_phase_result.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_function_phase_result.h"
+#include "mpl_logging.h"
+
+namespace maple {
+void FEFunctionPhaseResult::Combine(const FEFunctionPhaseResult &result) {
+  for (const std::string &name : result.phaseNames) {
+    auto itResult = result.phaseTimes.find(name);
+    CHECK_FATAL(itResult != result.phaseTimes.end(), "invalid result: without time recorded");
+    int64 t = itResult->second;
+    auto itLocal = phaseTimes.find(name);
+    if (itLocal == phaseTimes.end()) {
+      phaseNames.push_back(name);
+      phaseTimes[name] = t;
+    } else {
+      phaseTimes[name] = itLocal->second + t;
+    }
+  }
+}
+
+void FEFunctionPhaseResult::Dump() {
+  for (const std::string &name :phaseNames) {
+    auto it = phaseTimes.find(name);
+    CHECK_FATAL(it != phaseTimes.cend(), "phase time is undefined for %s", name.c_str());
+    INFO(kLncInfo, "[PhaseTime]  %s: %lld ns", name.c_str(), it->second);
+  }
+}
+
+void FEFunctionPhaseResult::DumpMS() {
+  for (const std::string &name :phaseNames) {
+    auto it = phaseTimes.find(name);
+    CHECK_FATAL(it != phaseTimes.cend(), "phase time is undefined for %s", name.c_str());
+    INFO(kLncInfo, "[PhaseTime]  %s: %.2lf ms", name.c_str(), it->second / 1000000.0);  // 1ms = 1000000 ns
+  }
+}
+
+bool FEFunctionPhaseResult::Finish(bool isSuccess) {
+  success = isSuccess;
+  if (enable && recordTime) {
+    timer.Stop();
+    CHECK_FATAL(!currPhaseName.empty(), "Phase Name is empty");
+    int64 t = timer.GetTimeNS();
+    phaseTimes[currPhaseName] = t;
+  }
+  return success;
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/fe_input_helper.cpp b/src/hir2mpl/common/src/fe_input_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2dcefcd3a12d6aaac05b3e4ef506e7b2adc22b4a
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_input_helper.cpp
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_input_helper.h"
+#include "fe_options.h"
+#include "fe_manager.h"
+
+namespace maple {
+#define SET_CLASS_INFO_PAIR(A, B, C, D)                                                            \
+  do {                                                                                             \
+    (A)->PushbackMIRInfo(MIRInfoPair(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(B), C));  \
+    (A)->PushbackIsString(D);                                                                        \
+  } while (0);
+
+std::string FEInputStructHelper::GetSrcFileNameImpl() const {
+  return "unknown";
+}
+
+MIRStructType *FEInputStructHelper::GetContainerImpl() {
+  return mirStructType;
+}
+
+bool FEInputStructHelper::PreProcessDeclImpl() {
+  bool error = false;
+  MIRStructType *structType = CreateMIRStructType(error);
+  if (error) {
+    return false;
+  }
+  isSkipped = (structType == nullptr);
+  mirStructType = structType;
+  if (structType != nullptr) {
+    FETypeManager::SetComplete(*structType);
+    FEManager::GetTypeManager().AddClassToModule(*structType);
+  }
+  return true;
+}
+
+bool FEInputStructHelper::ProcessDeclImpl() {
+  if (isSkipped) {
+    return true;
+  }
+  if (mirStructType == nullptr) {
+    return false;
+  }
+  if (!FEOptions::GetInstance().IsGenMpltOnly() && !isOnDemandLoad) {
+    CreateSymbol();
+  }
+  ProcessDeclSuperClass();
+  ProcessDeclImplements();
+  ProcessDeclDefInfo();
+  // Process Fields
+  InitFieldHelpers();
+  ProcessFieldDef();
+  ProcessExtraFields();
+  if (!FEOptions::GetInstance().IsGenMpltOnly() && !isOnDemandLoad) {
+    ProcessStaticFields();
+  }
+  // Process Methods
+  InitMethodHelpers();
+  ProcessMethodDef();
+  return true;
+}
+
+void FEInputStructHelper::CreateSymbol() {
+  std::string structNameMpl = GetStructNameMpl();
+  mirSymbol = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl(structNameMpl.c_str(), *mirStructType);
+  switch (mirStructType->GetKind()) {
+    case kTypeClass:
+    case kTypeClassIncomplete:
+      mirSymbol->SetSKind(kStJavaClass);
+      break;
+    case kTypeInterface:
+    case kTypeInterfaceIncomplete:
+      mirSymbol->SetSKind(kStJavaInterface);
+      break;
+    default:
+      break;
+  }
+  mirSymbol->SetAttrs(GetStructAttributeFromInput());
+}
+
+void FEInputStructHelper::ProcessDeclSuperClass() {
+  ProcessDeclSuperClassForJava();
+}
+
+void FEInputStructHelper::ProcessDeclSuperClassForJava() {
+  const std::list<std::string> &superNames = GetSuperClassNames();
+  ASSERT(superNames.size() <= 1, "there must be zero or one super class for java class: %s",
+         GetStructNameOrin().c_str());
+  if (superNames.size() == 1) {
+    const std::string &superNameMpl = namemangler::EncodeName(superNames.front());
+    bool isCreate = false;
+    MIRStructType *superType = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(superNameMpl, false,
+                                                                                           FETypeFlag::kSrcExtern,
+                                                                                           isCreate);
+    if (isCreate) {
+      // Mark incomplete
+    }
+    switch (mirStructType->GetKind()) {
+      case kTypeClass:
+      case kTypeClassIncomplete: {
+        MIRClassType *thisType = static_cast<MIRClassType*>(mirStructType);
+        thisType->SetParentTyIdx(superType->GetTypeIndex());
+        break;
+      }
+      case kTypeInterface:
+      case kTypeInterfaceIncomplete: {
+        MIRInterfaceType *thisType = static_cast<MIRInterfaceType*>(mirStructType);
+        if (superType->GetKind() == kTypeInterface) {
+          thisType->GetParentsTyIdx().push_back(superType->GetTypeIndex());
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+
+void FEInputStructHelper::ProcessDeclImplements() {
+  const std::vector<std::string> &interfaceNames = GetInterfaceNames();
+  std::vector<MIRStructType*> interfaceTypes;
+  for (const std::string &name : interfaceNames) {
+    const std::string &interfaceNameMpl = namemangler::EncodeName(name);
+    bool isCreate = false;
+    MIRStructType *interfaceType = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(interfaceNameMpl, true,
+                                                                                               FETypeFlag::kSrcExtern,
+                                                                                               isCreate);
+    if (isCreate) {
+      // Mark incomplete
+    }
+    interfaceTypes.push_back(interfaceType);
+  }
+  if (interfaceTypes.size() > 0) {
+    switch (mirStructType->GetKind()) {
+      case kTypeClass:
+      case kTypeClassIncomplete: {
+        MIRClassType *thisType = static_cast<MIRClassType*>(mirStructType);
+        for (MIRStructType *type : interfaceTypes) {
+          thisType->GetInterfaceImplemented().push_back(type->GetTypeIndex());
+        }
+        break;
+      }
+      case kTypeInterface:
+      case kTypeInterfaceIncomplete: {
+        MIRInterfaceType *thisType = static_cast<MIRInterfaceType*>(mirStructType);
+        for (MIRStructType *type : interfaceTypes) {
+          thisType->GetParentsTyIdx().push_back(type->GetTypeIndex());
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+
+void FEInputStructHelper::ProcessDeclDefInfo() {
+  // INFO_srcfile
+  std::string srcFileName = GetSourceFileName();
+  if (!srcFileName.empty()) {
+    GStrIdx srcFileNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(srcFileName);
+    SET_CLASS_INFO_PAIR(mirStructType, "INFO_srcfile", srcFileNameIdx.GetIdx(), true);
+  }
+  // INFO_classname
+  std::string classNameMpl = GetStructNameMpl();
+  GStrIdx classNameMplIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(classNameMpl);
+  SET_CLASS_INFO_PAIR(mirStructType, "INFO_classname", classNameMplIdx.GetIdx(), true);
+  // INFO_classnameorig
+  std::string classNameOrig = GetStructNameOrin();
+  GStrIdx classNameOrigIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(classNameOrig);
+  SET_CLASS_INFO_PAIR(mirStructType, "INFO_classnameorig", classNameOrigIdx.GetIdx(), true);
+  if (srcLang == kSrcLangJava) {
+    // INFO_superclassname
+    ProcessDeclDefInfoSuperNameForJava();
+    // INFO_implements
+    ProcessDeclDefInfoImplementNameForJava();
+  }
+  // INFO_attribute_string
+  TypeAttrs attrs = GetStructAttributeFromInput();
+  std::string attrsName = FETypeManager::TypeAttrsToString(attrs);
+  GStrIdx attrsNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(attrsName);
+  SET_CLASS_INFO_PAIR(mirStructType, "INFO_attribute_string", attrsNameIdx.GetIdx(), true);
+  // INFO_access_flags
+  SET_CLASS_INFO_PAIR(mirStructType, "INFO_access_flags", GetRawAccessFlags(), false);
+  // INFO_ir_srcfile_signature
+  SET_CLASS_INFO_PAIR(mirStructType, "INFO_ir_srcfile_signature", GetIRSrcFileSigIdx(), true);
+}
+
+void FEInputStructHelper::ProcessDeclDefInfoSuperNameForJava() {
+  std::list<std::string> superNames = GetSuperClassNames();
+  if (superNames.size() > 1) {
+    ASSERT(false, "There is one super class at most in java");
+    return;
+  }
+  std::string superName = superNames.size() == 0 ? "unknown" : superNames.front();
+  std::string superNameMpl = namemangler::EncodeName(superName);
+  GStrIdx superNameMplIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(superNameMpl.c_str());
+  SET_CLASS_INFO_PAIR(mirStructType, "INFO_superclassname", superNameMplIdx.GetIdx(), true);
+}
+
+void FEInputStructHelper::ProcessDeclDefInfoImplementNameForJava() {
+  MIRTypeKind kind = mirStructType->GetKind();
+  if (kind == kTypeInterface || kind == kTypeInterfaceIncomplete) {
+    return;
+  }
+  std::vector<std::string> implementNames = GetInterfaceNames();
+  for (const std::string &name : implementNames) {
+    if (!name.empty()) {
+      std::string nameMpl = namemangler::EncodeName(name);
+      GStrIdx nameMplIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(nameMpl.c_str());
+      SET_CLASS_INFO_PAIR(mirStructType, "INFO_implements", nameMplIdx.GetIdx(), true);
+    }
+  }
+}
+
+void FEInputStructHelper::ProcessStaticFields() {
+  uint32 i = 0;
+  FieldVector::iterator it;
+  for (it = mirStructType->GetStaticFields().begin(); it != mirStructType->GetStaticFields().end(); ++i, ++it) {
+    StIdx stIdx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(it->first);
+    const std::string &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(it->first);
+    MIRConst *cst = nullptr;
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(it->second.first);
+    MapleAllocator &alloc = FEManager::GetModule().GetMPAllocator();
+    if (i < staticFieldsConstVal.size()) {
+      cst = staticFieldsConstVal[i];
+      if (cst != nullptr && cst->GetKind() == kConstStr16Const) {
+        std::u16string str16 =
+            GlobalTables::GetU16StrTable().GetStringFromStrIdx(static_cast<MIRStr16Const*>(cst)->GetValue());
+        MIRSymbol *literalVar =  FEManager::GetJavaStringManager().GetLiteralVar(str16);
+        if (literalVar == nullptr) {
+          literalVar = FEManager::GetJavaStringManager().CreateLiteralVar(FEManager::GetMIRBuilder(), str16, true);
+        }
+        AddrofNode *expr = FEManager::GetMIRBuilder().CreateExprAddrof(0, *literalVar,
+            FEManager::GetModule().GetMemPool());
+        MIRType *ptrType = GlobalTables::GetTypeTable().GetTypeTable()[PTY_ptr];
+        cst = alloc.GetMemPool()->New<MIRAddrofConst>(expr->GetStIdx(), expr->GetFieldID(), *ptrType);
+      }
+    }
+    MIRSymbol *fieldVar = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+    if (fieldVar == nullptr) {
+      fieldVar = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl(fieldName, *type);
+      fieldVar->SetAttrs(it->second.second.ConvertToTypeAttrs());
+    }
+    if (cst != nullptr) {
+      fieldVar->SetKonst(cst);
+    }
+  }
+}
+
+void FEInputStructHelper::ProcessFieldDef() {
+  for (FEInputFieldHelper *fieldHelper : fieldHelpers) {
+    bool success = fieldHelper->ProcessDeclWithContainer(allocator);
+    if (success) {
+      if (fieldHelper->IsStatic()) {
+        mirStructType->GetStaticFields().push_back(fieldHelper->GetMIRFieldPair());
+      } else {
+        mirStructType->GetFields().push_back(fieldHelper->GetMIRFieldPair());
+      }
+    } else {
+      ERR(kLncErr, "Error occurs in ProcessFieldDef for %s", GetStructNameOrin().c_str());
+    }
+  }
+}
+
+void FEInputStructHelper::ProcessExtraFields() {
+  // add to this set to add extrafield into a class, in this format: classname, fieldname, type, attributes
+  std::vector<ExtraField> extraFields = {
+    { "Lcom_2Fandroid_2Finternal_2Fos_2FBinderCallsStats_3B", "mCallSessionsPoolSize", "i32", "private" },
+    { "Ljava_2Flang_2FObject_3B", "shadow_24__klass__", "Ljava_2Flang_2FClass_3B", "private transient final" },
+  };
+  for (auto it = extraFields.begin(); it != extraFields.end(); ++it) {
+    bool isCreat = false;
+    MIRStructType *structType = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(it->klass,
+        false, FETypeFlag::kSrcUnknown, isCreat);
+    if (structType->IsImported()) {
+      continue;
+    }
+    GStrIdx fieldStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(it->field);
+    MIRType *fieldType = FEManager::GetTypeManager().GetOrCreateTypeFromName(it->type, FETypeFlag::kSrcUnknown, true);
+    std::vector<std::string> attrs = FEUtils::Split(it->attr, ' ');
+    FieldAttrs typeAttrs;
+    for (auto ait = attrs.begin(); ait != attrs.end(); ++ait) {
+      FEInputFieldHelper::SetFieldAttribute(*ait, typeAttrs);
+    }
+    for (auto fit = structType->GetFields().begin(); fit != structType->GetFields().end(); ++fit) {
+      if (fit->first == fieldStrIdx) {
+        (void)structType->GetFields().erase(fit);
+        break;
+      }
+    }
+    // insert at the beginning
+    structType->GetFields().insert(structType->GetFields().cbegin(),
+        FieldPair(fieldStrIdx, TyIdxFieldAttrPair(fieldType->GetTypeIndex(), typeAttrs)));
+  }
+}
+
+void FEInputStructHelper::ProcessMethodDef() {
+  for (FEInputMethodHelper *methodHelper : methodHelpers) {
+    bool success = methodHelper->ProcessDecl(allocator);
+    if (success) {
+      mirStructType->GetMethods().push_back(methodHelper->GetMIRMethodPair());
+      methodHelper->SetClassTypeInfo(*mirStructType);
+    } else {
+      ERR(kLncErr, "Error occurs in ProcessMethodDef for %s", GetStructNameOrin().c_str());
+    }
+  }
+}
+
+void FEInputStructHelper::ProcessPragma() {
+  if (isSkipped) {
+    return;
+  }
+  std::vector<MIRPragma*> pragmas = pragmaHelper->GenerateMIRPragmas();
+  std::vector<MIRPragma*> &pragmaVec = mirStructType->GetPragmaVec();
+  for (MIRPragma *pragma : pragmas) {
+    pragmaVec.push_back(pragma);
+  }
+}
+
+// ---------- FEInputMethodHelper ----------
+bool FEInputMethodHelper::ProcessDeclImpl(MapleAllocator &allocatorIn) {
+  (void)allocatorIn;
+  CHECK_FATAL(false, "NYI");
+  return true;
+}
+
+// ---------- FEInputHelper ----------
+bool FEInputHelper::PreProcessDecl() {
+  bool success = true;
+  for (FEInputStructHelper *helper : structHelpers) {
+    success = helper->PreProcessDecl() ? success : false;
+  }
+  return success;
+}
+
+bool FEInputHelper::ProcessDecl() {
+  bool success = true;
+  for (FEInputStructHelper *helper : structHelpers) {
+    success = helper->ProcessDecl() ? success : false;
+  }
+  return success;
+}
+
+bool FEInputHelper::ProcessImpl() const {
+  return true;
+}
+}
diff --git a/src/hir2mpl/common/src/fe_java_string_manager.cpp b/src/hir2mpl/common/src/fe_java_string_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..666404ce1e790ed9be4269bf50c25cba749a7146
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_java_string_manager.cpp
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_java_string_manager.h"
+#include <fstream>
+#include "global_tables.h"
+#include "namemangler.h"
+#include "muid.h"
+#include "literalstrname.h"
+#include "fe_config_parallel.h"
+#include "feir_type.h"
+#include "fe_manager.h"
+#include "fe_options.h"
+
+namespace maple {
+FEJavaStringManager::FEJavaStringManager(MIRModule &argModule, MIRBuilder &mirBuilderIn)
+    : module(argModule), mirBuilder(mirBuilderIn) {
+}
+
+FEJavaStringManager::~FEJavaStringManager() {
+  typeString = nullptr;
+}
+
+void FEJavaStringManager::LoadProfilingData(const std::string &profileFileName) {
+  std::ifstream inFile(profileFileName);
+  if (!inFile.is_open()) {
+    WARN(kLncWarn, "Cannot open literal profile data file %s", profileFileName.c_str());
+    return;
+  }
+  std::string literalName;
+  while (std::getline(inFile, literalName)) {
+    if (!literalName.empty()) {
+      (void)preloadSet.insert(literalName);
+    }
+  }
+  inFile.close();
+}
+
+MIRSymbol *FEJavaStringManager::GetLiteralPtrVar(const MIRSymbol *var) const {
+  auto it = literalMap.find(var);
+  if (it != literalMap.end()) {
+    return it->second;
+  } else {
+    return nullptr;
+  }
+}
+
+MIRSymbol *FEJavaStringManager::GetLiteralPtrVar(const std::string &str) const {
+  MIRSymbol *literalVar = GetLiteralVar(str);
+  return GetLiteralPtrVar(literalVar);
+}
+
+MIRSymbol *FEJavaStringManager::GetLiteralPtrVar(const std::u16string &strU16) const {
+  MIRSymbol *literalVar = GetLiteralVar(strU16);
+  return GetLiteralPtrVar(literalVar);
+}
+
+MIRSymbol *FEJavaStringManager::CreateLiteralVar(MIRBuilder &mirBuilderIn, const std::string &str, bool isFieldValue) {
+  std::u16string strU16;
+  (void)namemangler::UTF8ToUTF16(strU16, str);
+  return CreateLiteralVar(mirBuilderIn, strU16, isFieldValue);
+}
+
+MIRSymbol *FEJavaStringManager::CreateLiteralVar(MIRBuilder &mirBuilderIn, const std::u16string &strU16,
+                                                 bool isFieldValue) {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  if (typeString == nullptr) {
+    FEIRTypeDefault type(PTY_ref);
+    type.LoadFromJavaTypeName("Ljava/lang/String;", false);
+    typeString = type.GenerateMIRTypeAuto(kSrcLangJava);
+  }
+  MIRSymbol *literalVar = GetLiteralVar(strU16);
+  if (literalVar != nullptr) {
+    return literalVar;
+  }
+  std::string literalGlobalName = GetLiteralGlobalName(strU16);
+  bool compress = useCompressedJavaString && IsAllASCII(strU16);
+  MIRArrayType *byteArrayType = ConstructArrayType4Str(strU16, compress);
+  literalVar = mirBuilderIn.GetOrCreateGlobalDecl(literalGlobalName.c_str(), *byteArrayType);
+  MIRAggConst *strConst = CreateByteArrayConst(strU16, *byteArrayType, compress);
+  literalVar->SetKonst(strConst);
+  literalVar->SetAttr(ATTR_readonly);
+  literalVar->SetStorageClass(kScFstatic);
+  bool isHotLiteral = false;
+  if (preloadSet.find(literalGlobalName) != preloadSet.end()) {
+    isHotLiteral = true;
+    (void)literalSet.insert(literalVar);
+  }
+  if (isFieldValue) {
+    (void)fieldValueSet.insert(literalVar);
+  }
+  if ((isFieldValue || isHotLiteral) && (!FEOptions::GetInstance().IsAOT())) {
+    std::string literalGlobalPtrName = namemangler::kPtrPrefixStr + literalGlobalName;
+    MIRSymbol *literalVarPtr = mirBuilderIn.GetOrCreateGlobalDecl(literalGlobalPtrName.c_str(), *typeString);
+    literalVarPtr->SetStorageClass(literalVar->GetStorageClass());
+    AddrofNode *expr = mirBuilderIn.CreateExprAddrof(0, *literalVar, module.GetMemPool());
+    MIRConst *cst = module.GetMemPool()->New<MIRAddrofConst>(
+        expr->GetStIdx(), expr->GetFieldID(), *GlobalTables::GetTypeTable().GetPtr());
+    literalVarPtr->SetKonst(cst);
+    literalVarPtr->SetAttr(ATTR_readonly);
+    literalMap[literalVar] = literalVarPtr;
+  }
+  (void)GlobalTables::GetConstPool().GetConstU16StringPool().insert(std::make_pair(strU16, literalVar));
+  return literalVar;
+}
+
+MIRSymbol *FEJavaStringManager::GetLiteralVar(const std::string &str) const {
+  std::u16string strU16;
+  (void)namemangler::UTF8ToUTF16(strU16, str);
+  return GetLiteralVar(strU16);
+}
+
+MIRSymbol *FEJavaStringManager::GetLiteralVar(const std::u16string &strU16) const {
+  auto it = GlobalTables::GetConstPool().GetConstU16StringPool().find(strU16);
+  if (it != GlobalTables::GetConstPool().GetConstU16StringPool().end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+std::string FEJavaStringManager::GetLiteralGlobalName(const std::u16string &strU16) {
+  std::string literalGlobalName;
+  std::vector<uint8> swapped = SwapBytes(strU16);
+  if (strU16.length() == 0) {
+    literalGlobalName = LiteralStrName::GetLiteralStrName(swapped.data(), 0);
+  } else {
+    literalGlobalName = LiteralStrName::GetLiteralStrName(swapped.data(), static_cast<uint32>(strU16.length() << 1));
+  }
+  return literalGlobalName;
+}
+
+// Valid ASCII characters are in range 1..0x7f. Zero is not considered ASCII
+// because it would complicate the detection of ASCII strings in Modified-UTF8.
+bool FEJavaStringManager::IsAllASCII(const std::u16string &strU16) {
+  if (strU16.length() == 0) {
+    return false;
+  }
+  for (size_t i = 0; i < strU16.length(); ++i) {
+    uint16 val = ExchangeBytesPosition(strU16[i]);
+    if ((val - 1u) >= 0x7fu) {
+      return false;
+    }
+  }
+  return true;
+}
+
+MIRArrayType *FEJavaStringManager::ConstructArrayType4Str(const std::u16string &strU16, bool compressible) const {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  uint32 arraySize[1];
+  // use 2 bytes per char in uncompress mode
+  uint32 length = compressible ? static_cast<uint32>(strU16.length()) : static_cast<uint32>(strU16.length() * 2);
+#ifdef JAVA_OBJ_IN_MFILE
+#ifdef USE_32BIT_REF
+  uint32 sizeInBytes = 16 + length;                // shadow(4B)+monitor(4B)+count(4B)+hash(4B)+content
+#else                                              // !USE_32BIT_REF
+  uint32 sizeInBytes = 20 + length;                // shadow(8B)+monitor(4B)+count(4B)+hash(4B)+content
+#endif                                             // USE_32BIT_REF
+#else                                              // !JAVA_OBJ_IN_MFILE
+  uint32 sizeInBytes = 8 + length;                 // count(4B)+hash(4B)+content
+#endif                                             // JAVA_OBJ_IN_MFILE
+  uint32 sizeInLongs = (sizeInBytes - 1) / 8 + 1;  // round up to 8B units
+  arraySize[0] = sizeInLongs;
+  MIRArrayType *byteArrayType = static_cast<MIRArrayType*>(
+      GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetUInt64(), 1, arraySize));
+  return byteArrayType;
+}
+
+MIRAggConst *FEJavaStringManager::CreateByteArrayConst(const std::u16string &strU16, MIRArrayType &byteArrayType,
+                                                       bool compressible) const {
+  MIRAggConst *newconst = module.GetMemPool()->New<MIRAggConst>(module, byteArrayType);
+  MIRType *uInt64 = GlobalTables::GetTypeTable().GetUInt64();
+  MemPool *mp = module.GetMemPool();
+  DWBuffer currData = { 0, 0 };
+
+#ifdef JAVA_OBJ_IN_MFILE
+  // @shadow
+  // To avoid linker touch cold pages, the classinfo is not set ready in file.
+  // It will be set at runtime
+#ifdef USE_32BIT_REF
+  AddDataIntoByteArray(*newconst, *mp, currData, static_cast<uint32>(0), *uInt64);
+#else
+  AddDataIntoByteArray(*newconst, *mp, currData, static_cast<uint64>(0), *uInt64);
+#endif  // USE_32BIT_REF
+  // @monitor
+  AddDataIntoByteArray(*newconst, *mp, currData, static_cast<uint32>(0), *uInt64);
+#endif  // JAVA_OBJ_IN_MFILE
+
+  // @count
+  uint32 strCount = (strU16.length() > 0) ? static_cast<uint32>((strU16.length() * 2) | compressible) : 0;
+  AddDataIntoByteArray(*newconst, *mp, currData, strCount, *uInt64);
+
+  // @hash
+  uint32 hash = static_cast<uint32>(
+      LiteralStrName::CalculateHashSwapByte(strU16.data(), static_cast<uint32>(strU16.length())));
+  AddDataIntoByteArray(*newconst, *mp, currData, hash, *uInt64);
+
+  // @content
+  if (compressible) {
+    for (size_t i = 0; i < strU16.size(); i++) {
+      AddDataIntoByteArray(*newconst, *mp, currData, static_cast<uint8>(ExchangeBytesPosition(strU16[i])), *uInt64);
+    }
+  } else {
+    for (size_t i = 0; i < strU16.size(); i++) {
+      AddDataIntoByteArray(*newconst, *mp, currData, static_cast<uint16>(ExchangeBytesPosition(strU16[i])), *uInt64);
+    }
+  }
+  // in case there're remaining data in the buffer
+  FinishByteArray(*newconst, *mp, currData, *uInt64);
+  return newconst;
+}
+
+std::vector<uint8> FEJavaStringManager::SwapBytes(const std::u16string &strU16) {
+  std::vector<uint8> out;
+  for (size_t i = 0; i < strU16.length(); ++i) {
+    uint16 c16 = strU16[i];
+    out.push_back((c16 & 0xFF00) >> 8);
+    out.push_back(c16 & 0xFF);
+  }
+  out.push_back(0);
+  out.push_back(0);
+  return out;
+}
+
+uint16 FEJavaStringManager::ExchangeBytesPosition(uint16 input) {
+  uint16 lowerByte = input << 8;
+  uint16 higherByte = input >> 8;
+  return lowerByte | higherByte;
+}
+
+template <typename T>
+void FEJavaStringManager::AddDataIntoByteArray(MIRAggConst &newConst, MemPool &mp, DWBuffer &buf, T data,
+                                               MIRType &uInt64) {
+  if (buf.pos == 8) {  // buffer is already full
+    newConst.PushBack(mp.New<MIRIntConst>(buf.data, uInt64));
+    buf.data = 0;
+    buf.pos = 0;
+  }
+  CHECK_FATAL(((buf.pos + sizeof(T)) <= 8), "inserted data exceeds current buffer capacity");
+  buf.data |= ((static_cast<uint64>(data)) << (buf.pos * 8));
+  buf.pos += sizeof(T);
+}
+
+void FEJavaStringManager::FinishByteArray(MIRAggConst &newConst, MemPool &mp, DWBuffer &buf, MIRType &uInt64) {
+  if (buf.pos > 0) {  // there're data inside buffer
+    newConst.PushBack(mp.New<MIRIntConst>(buf.data, uInt64));
+    buf.data = 0;
+    buf.pos = 0;
+  }
+}
+
+void FEJavaStringManager::GenStringMetaClassVar() {
+  std::unique_ptr<MIRStructType> metaClassType = std::make_unique<MIRStructType>(kTypeStruct);
+
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("dummy");
+  metaClassType->GetFields().emplace_back(
+      strIdx, TyIdxFieldAttrPair(GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex(), FieldAttrs()));
+
+  GStrIdx metaStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::kClassMetadataTypeName);
+  TyIdx tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(metaClassType.get());
+  // Global?
+  module.GetTypeNameTab()->SetGStrIdxToTyIdx(metaStrIdx, tyIdx);
+  CHECK_FATAL(GlobalTables::GetTypeTable().GetTypeTable().size() > tyIdx, "empty check");
+  if (GlobalTables::GetTypeTable().GetTypeTable()[tyIdx]->GetNameStrIdx() == 0) {
+    GlobalTables::GetTypeTable().GetTypeTable()[tyIdx]->SetNameStrIdx(metaStrIdx);
+  }
+  metaClassType->SetTypeIndex(tyIdx);
+  module.AddClass(tyIdx);
+  std::string buf(CLASSINFO_PREFIX_STR);
+  (void)buf.append("Ljava_2Flang_2FString_3B");
+  stringMetaClassSymbol = mirBuilder.GetOrCreateGlobalDecl(buf.c_str(), *metaClassType);
+  GStrIdx typeNameIdxForString = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FString_3B");
+  if (FEManager::GetTypeManager().IsImportedType(typeNameIdxForString)) {
+    stringMetaClassSymbol->SetStorageClass(kScExtern);
+  }
+}
+
+void FEJavaStringManager::ClearStringMetaClassSymbolExternFlag() {
+  stringMetaClassSymbol->SetStorageClass(kScGlobal);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/fe_manager.cpp b/src/hir2mpl/common/src/fe_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dec5dc361dbcbdc89049cedbbd6ed27228549345
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_manager.cpp
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_manager.h"
+
+namespace maple {
+FEManager *FEManager::manager = nullptr;
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/fe_options.cpp b/src/hir2mpl/common/src/fe_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..848f0a03719f6121ef415d2a6a2241aa135645e2
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_options.cpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_options.h"
+#include "fe_file_type.h"
+namespace maple {
+FEOptions FEOptions::options;
+FEOptions::FEOptions()
+    : isGenMpltOnly(false),
+      isGenAsciiMplt(false),
+      outputPath(""),
+      outputName(""),
+      dumpLevel(kDumpLevelDisable),
+      isDumpTime(false),
+      nthreads(0),
+      dumpThreadTime(false) {}
+
+void FEOptions::AddInputClassFile(const std::string &fileName) {
+  FEFileType::FileType type = FEFileType::GetInstance().GetFileTypeByMagicNumber(fileName);
+  if (type == FEFileType::FileType::kClass) {
+    inputClassFiles.push_back(fileName);
+  } else {
+    WARN(kLncWarn, "invalid input class file %s...skipped", fileName.c_str());
+  }
+}
+
+void FEOptions::AddInputJarFile(const std::string &fileName) {
+  FEFileType::FileType type = FEFileType::GetInstance().GetFileTypeByMagicNumber(fileName);
+  if (type == FEFileType::FileType::kJar) {
+    inputJarFiles.push_back(fileName);
+  } else {
+    WARN(kLncWarn, "invalid input jar file %s...skipped", fileName.c_str());
+  }
+}
+
+void FEOptions::AddInputDexFile(const std::string &fileName) {
+  FEFileType::FileType type = FEFileType::GetInstance().GetFileTypeByMagicNumber(fileName);
+  if (type == FEFileType::FileType::kDex) {
+    inputDexFiles.push_back(fileName);
+  } else {
+    WARN(kLncWarn, "invalid input dex file %s...skipped", fileName.c_str());
+  }
+}
+
+void FEOptions::AddInputASTFile(const std::string &fileName) {
+  FEFileType::FileType type = FEFileType::GetInstance().GetFileTypeByMagicNumber(fileName);
+  if (type == FEFileType::FileType::kAST) {
+    inputASTFiles.push_back(fileName);
+  } else {
+    WARN(kLncWarn, "invalid input AST file %s...skipped", fileName.c_str());
+  }
+}
+
+void FEOptions::AddInputMASTFile(const std::string &fileName) {
+  FEFileType::FileType type = FEFileType::GetInstance().GetFileTypeByMagicNumber(fileName);
+  if (type == FEFileType::FileType::kMAST) {
+    inputMASTFiles.push_back(fileName);
+  } else {
+    WARN(kLncWarn, "invalid input MAST file %s...skipped", fileName.c_str());
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/fe_struct_elem_info.cpp b/src/hir2mpl/common/src/fe_struct_elem_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a20a5d6b143b65398ab6d72a45c89a14b666bcad
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_struct_elem_info.cpp
@@ -0,0 +1,449 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_struct_elem_info.h"
+#include "global_tables.h"
+#include "mpl_logging.h"
+#include "namemangler.h"
+#include "feir_builder.h"
+#include "feir_var_name.h"
+#include "fe_utils_java.h"
+#include "fe_utils.h"
+#include "fe_manager.h"
+#include "fe_options.h"
+
+
+namespace maple {
+// ---------- FEStructElemInfo ----------
+FEStructElemInfo::FEStructElemInfo(MapleAllocator &allocatorIn, const StructElemNameIdx &argStructElemNameIdx,
+                                   MIRSrcLang argSrcLang, bool argIsStatic)
+    : isStatic(argIsStatic),
+      isMethod(false),
+      isDefined(false),
+      isFromDex(false),
+      isPrepared(false),
+      srcLang(argSrcLang),
+      allocator(allocatorIn),
+      structElemNameIdx(argStructElemNameIdx),
+      actualContainer(allocator.GetMemPool()) {
+}
+
+UniqueFEIRType FEStructElemInfo::GetActualContainerType() const {
+  // Invokable after prepared
+  return FEIRBuilder::CreateTypeByJavaName(actualContainer.c_str(), true);
+}
+
+// ---------- FEStructFieldInfo ----------
+FEStructFieldInfo::FEStructFieldInfo(MapleAllocator &allocatorIn, const StructElemNameIdx &argStructElemNameIdx,
+                                     MIRSrcLang argSrcLang, bool argIsStatic)
+    : FEStructElemInfo(allocatorIn, argStructElemNameIdx, argSrcLang, argIsStatic),
+      fieldType(nullptr),
+      fieldNameIdx(0),
+      fieldID(0),
+      isVolatile(false) {
+  isMethod = false;
+  LoadFieldType();
+}
+
+void FEStructFieldInfo::PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) {
+  if (isPrepared && argIsStatic == isStatic) {
+    return;
+  }
+  // Prepare
+  actualContainer = GetStructName();
+  const std::string stdActualContainer = actualContainer.c_str();
+  std::string rawName = stdActualContainer + namemangler::kNameSplitterStr + GetElemName();
+  if (isStatic &&
+      FEOptions::GetInstance().GetModeJavaStaticFieldName() != FEOptions::ModeJavaStaticFieldName::kNoType) {
+    rawName = rawName + namemangler::kNameSplitterStr + GetSignatureName();
+  }
+  fieldNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(rawName);
+  MIRStructType *structType = FEManager::GetTypeManager().GetStructTypeFromName(stdActualContainer);
+  if (structType == nullptr) {
+    isDefined = false;
+    isPrepared = true;
+    return;
+  }
+  isDefined = SearchStructFieldJava(*structType, mirBuilder, argIsStatic);
+  if (isDefined) {
+    return;
+  }
+  WARN(kLncErr, "use undefined %s field %s", argIsStatic ? "static" : "", rawName.c_str());
+  isPrepared = true;
+  isStatic = argIsStatic;
+  return;
+}
+
+void FEStructFieldInfo::LoadFieldType() {
+  switch (srcLang) {
+    case kSrcLangJava:
+      LoadFieldTypeJava();
+      break;
+    case kSrcLangC:
+      WARN(kLncWarn, "kSrcLangC LoadFieldType NYI");
+      break;
+    default:
+      WARN(kLncWarn, "unsupported language");
+      break;
+  }
+}
+
+void FEStructFieldInfo::LoadFieldTypeJava() {
+  fieldType = allocator.GetMemPool()->New<FEIRTypeDefault>(PTY_unknown);
+  static_cast<FEIRTypeDefault*>(fieldType)->LoadFromJavaTypeName(GetSignatureName(), true);
+}
+
+void FEStructFieldInfo::PrepareStaticField(const MIRStructType &structType) {
+  std::string ownerStructName = structType.GetName();
+  const std::string &fieldName = GetElemName();
+  std::string fullName = ownerStructName + namemangler::kNameSplitterStr + fieldName;
+  if (FEOptions::GetInstance().GetModeJavaStaticFieldName() != FEOptions::ModeJavaStaticFieldName::kNoType) {
+    fullName += namemangler::kNameSplitterStr + GetSignatureName();
+  }
+  fieldNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName);
+  isPrepared = true;
+  isStatic = true;
+}
+
+void FEStructFieldInfo::PrepareNonStaticField(MIRBuilder &mirBuilder) {
+  FEIRTypeDefault feType(PTY_unknown);
+  feType.LoadFromJavaTypeName(GetSignatureName(), true);
+  MIRType *fieldMIRType = feType.GenerateMIRTypeAuto(srcLang);
+  uint32 idx = 0;
+  uint32 idx1 = 0;
+  MIRStructType *structType = FEManager::GetTypeManager().GetStructTypeFromName(GetStructName());
+  mirBuilder.TraverseToNamedFieldWithType(*structType, structElemNameIdx.elem, fieldMIRType->GetTypeIndex(), idx1, idx);
+  fieldID = static_cast<FieldID>(idx);
+  isPrepared = true;
+  isStatic = false;
+}
+
+bool FEStructFieldInfo::SearchStructFieldJava(MIRStructType &structType, MIRBuilder &mirBuilder, bool argIsStatic,
+                                              bool allowPrivate) {
+  if (structType.IsIncomplete()) {
+    return false;
+  }
+  GStrIdx nameIdx = structElemNameIdx.elem;
+  if (argIsStatic) {
+    // suppose anti-proguard is off in jbc.
+    // Turn on anti-proguard in jbc: -java-staticfield-name=smart && JBCClass2FEHelper::isStaticFieldProguard(false)
+    // Turn on anti-proguard in BC: -java-staticfield-name=smart
+    std::string fullName = structType.GetCompactMplTypeName() + namemangler::kNameSplitterStr + GetElemName();
+    if (FEOptions::GetInstance().GetModeJavaStaticFieldName() != FEOptions::ModeJavaStaticFieldName::kNoType) {
+      fullName += namemangler::kNameSplitterStr + GetSignatureName();
+    }
+    nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName);
+  }
+  actualContainer = structType.GetCompactMplTypeName();
+  const FieldVector &fields = argIsStatic ? structType.GetStaticFields() : structType.GetFields();
+  for (const FieldPair &fieldPair : fields) {
+    if (fieldPair.first != nameIdx) {
+      continue;
+    }
+    if (fieldPair.second.second.GetAttr(FLDATTR_private) && !allowPrivate) {
+      continue;
+    }
+    if (CompareFieldType(fieldPair)) {
+      if (argIsStatic) {
+        PrepareStaticField(structType);
+      } else {
+        PrepareNonStaticField(mirBuilder);
+      }
+      isVolatile = fieldPair.second.second.GetAttr(FLDATTR_volatile);
+      return true;
+    }
+  }
+  // search parent
+  bool found = false;
+  if (structType.GetKind() == kTypeClass) {
+    MIRClassType &classType = static_cast<MIRClassType&>(structType);
+    // implemented
+    for (const TyIdx &tyIdx : classType.GetInterfaceImplemented()) {
+      found = found || SearchStructFieldJava(tyIdx, mirBuilder, argIsStatic, false);
+    }
+    // parent
+    found = found || SearchStructFieldJava(classType.GetParentTyIdx(), mirBuilder, argIsStatic, false);
+  } else if (structType.GetKind() == kTypeInterface) {
+    // parent
+    MIRInterfaceType &interfaceType = static_cast<MIRInterfaceType&>(structType);
+    for (const TyIdx &tyIdx : interfaceType.GetParentsTyIdx()) {
+      found = found || SearchStructFieldJava(tyIdx, mirBuilder, argIsStatic, false);
+    }
+  } else {
+    CHECK_FATAL(false, "not supported yet");
+  }
+  return found;
+}
+
+bool FEStructFieldInfo::SearchStructFieldJava(const TyIdx &tyIdx, MIRBuilder &mirBuilder, bool argIsStatic,
+                                              bool allowPrivate) {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  if (type == nullptr) {
+    return false;
+  }
+  if (type->IsIncomplete()) {
+    return false;
+  }
+  if (type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface) {
+    MIRStructType *structType = static_cast<MIRStructType*>(type);
+    return SearchStructFieldJava(*structType, mirBuilder, argIsStatic, allowPrivate);
+  } else {
+    ERR(kLncErr, "parent type should be StructType");
+    return false;
+  }
+}
+
+bool FEStructFieldInfo::CompareFieldType(const FieldPair &fieldPair) const {
+  MIRType *fieldMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+  std::string typeName = fieldMIRType->GetCompactMplTypeName();
+  if (GetSignatureName().compare(typeName) == 0) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// ---------- FEStructMethodInfo ----------
+FEStructMethodInfo::FEStructMethodInfo(MapleAllocator &allocatorIn, const StructElemNameIdx &argStructElemNameIdx,
+                                       MIRSrcLang argSrcLang, bool argIsStatic)
+    : FEStructElemInfo(allocatorIn, argStructElemNameIdx, argSrcLang, argIsStatic),
+      isReturnVoid(false),
+      isConstructor(false),
+      isJavaPolymorphicCall(false),
+      isJavaDynamicCall(false),
+      methodNameIdx(argStructElemNameIdx.full),
+      retType(nullptr),
+      ownerType(nullptr),
+      mirFunc(nullptr),
+      argTypes(allocator.Adapter()) {
+  isMethod = true;
+  LoadMethodType();
+}
+
+FEStructMethodInfo::~FEStructMethodInfo() {
+  mirFunc = nullptr;
+  retType = nullptr;
+  ownerType = nullptr;
+}
+
+PUIdx FEStructMethodInfo::GetPuIdx() const {
+  CHECK_NULL_FATAL(mirFunc);
+  return mirFunc->GetPuidx();
+}
+
+void FEStructMethodInfo::PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) {
+  if (isPrepared && argIsStatic == isStatic) {
+    return;
+  }
+  switch (srcLang) {
+    case kSrcLangJava:
+      PrepareImplJava(mirBuilder, argIsStatic);
+      break;
+    case kSrcLangC:
+      PrepareMethodC();
+      return;
+    default:
+      CHECK_FATAL(false, "unsupported src lang");
+  }
+  PrepareMethod();
+}
+
+void FEStructMethodInfo::PrepareImplJava(MIRBuilder &mirBuilder, bool argIsStatic) {
+  // Prepare
+  actualContainer = GetStructName();
+  MIRStructType *structType = nullptr;
+  if (!actualContainer.empty() && actualContainer[0] == 'A') {
+    structType = FEManager::GetTypeManager().GetStructTypeFromName("Ljava_2Flang_2FObject_3B");
+  } else {
+    structType = FEManager::GetTypeManager().GetStructTypeFromName(actualContainer.c_str());
+  }
+  isStatic = argIsStatic;
+  isDefined = false;
+  if (structType != nullptr) {
+    isDefined = SearchStructMethodJava(*structType, mirBuilder, argIsStatic);
+    if (isDefined) {
+      return;
+    }
+  } else if (isJavaDynamicCall) {
+    methodNameIdx = structElemNameIdx.full;
+    isDefined = true;
+    PrepareMethod();
+    return;
+  }
+  std::string methodName = GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx.full);
+  WARN(kLncWarn, "undefined %s method: %s", isStatic ? "static" : "", methodName.c_str());
+}
+
+void FEStructMethodInfo::LoadMethodType() {
+  switch (srcLang) {
+    case kSrcLangJava:
+      LoadMethodTypeJava();
+      break;
+    case kSrcLangC:
+      break;
+    default:
+      WARN(kLncWarn, "unsupported language");
+      break;
+  }
+}
+
+void FEStructMethodInfo::LoadMethodTypeJava() {
+  std::string signatureJava =
+      namemangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx.full));
+  std::vector<std::string> typeNames = FEUtilJava::SolveMethodSignature(signatureJava);
+  CHECK_FATAL(typeNames.size() > 0, "invalid method signature: %s", signatureJava.c_str());
+  // constructor check
+  const std::string &funcName = GetElemName();
+  isConstructor = (funcName.find("init_28") == 0);
+  // return type
+  retType = allocator.GetMemPool()->New<FEIRTypeDefault>(PTY_unknown);
+  if (typeNames[0].compare("V") == 0) {
+    isReturnVoid = true;
+  }
+  static_cast<FEIRTypeDefault*>(retType)->LoadFromJavaTypeName(typeNames[0], false);
+  // argument types
+  argTypes.clear();
+  for (size_t i = 1; i < typeNames.size(); i++) {
+    FEIRType *argType = allocator.GetMemPool()->New<FEIRTypeDefault>(PTY_unknown);
+    static_cast<FEIRTypeDefault*>(argType)->LoadFromJavaTypeName(typeNames[i], false);
+    argTypes.push_back(argType);
+  }
+  // owner type
+  ownerType = allocator.GetMemPool()->New<FEIRTypeDefault>(PTY_unknown);
+  static_cast<FEIRTypeDefault*>(ownerType)->LoadFromJavaTypeName(GetStructName(), true);
+}
+
+void FEStructMethodInfo::PrepareMethodC() {
+  mirFunc = FEManager::GetTypeManager().GetMIRFunction(methodNameIdx, isStatic);
+  if (mirFunc == nullptr) {
+    MIRType *mirRetType = retType->GenerateMIRTypeAuto(srcLang);
+    std::vector<TyIdx> argsTypeIdx;
+    for (const FEIRType *argType : argTypes) {
+      MIRType *mirArgType = argType->GenerateMIRTypeAuto(srcLang);
+      argsTypeIdx.push_back(mirArgType->GetTypeIndex());
+    }
+    mirFunc = FEManager::GetTypeManager().CreateFunction(methodNameIdx, mirRetType->GetTypeIndex(),
+                                                         argsTypeIdx, false, isStatic);
+    mirFunc->SetFuncAttrs(funcAttrs);
+  }
+  isPrepared = true;
+}
+
+void FEStructMethodInfo::PrepareMethod() {
+  mirFunc = FEManager::GetTypeManager().GetMIRFunction(methodNameIdx, isStatic);
+  if (mirFunc == nullptr) {
+    MIRType *mirRetType = retType->GenerateMIRTypeAuto(srcLang);
+    // args type
+    std::vector<std::unique_ptr<FEIRVar>> argVarList;
+    std::vector<TyIdx> argsTypeIdx;
+    if (!isStatic) {
+      UniqueFEIRVar regVar = std::make_unique<FEIRVarName>(FEUtils::GetThisIdx(), ownerType->Clone(), false);
+      argVarList.emplace_back(std::move(regVar));
+      argsTypeIdx.emplace_back(ownerType->GenerateMIRType(srcLang, true)->GetTypeIndex());
+    }
+    uint8 regNum = 1;
+    for (const FEIRType *argType : argTypes) {
+      UniqueFEIRVar regVar = FEIRBuilder::CreateVarReg(regNum, argType->Clone(), false);
+      ++regNum;
+      argVarList.emplace_back(std::move(regVar));
+      MIRType *mirArgType = argType->GenerateMIRTypeAuto(srcLang);
+      argsTypeIdx.push_back(mirArgType->GetTypeIndex());
+    }
+    mirFunc = FEManager::GetTypeManager().CreateFunction(methodNameIdx, mirRetType->GetTypeIndex(), argsTypeIdx, false,
+                                                         isStatic);
+    // Update formals for external function,
+    // defined function will be update formals later in FEFunction::UpdateFormal
+    for (const std::unique_ptr<FEIRVar> &argVar : argVarList) {
+      MIRType *mirTy = argVar->GetType()->GenerateMIRTypeAuto();
+      std::string name = argVar->GetName(*mirTy);
+      MIRSymbol *sym = FEManager::GetMIRBuilder().GetOrCreateDeclInFunc(name, *mirTy, *mirFunc);
+      sym->SetStorageClass(kScFormal);
+      mirFunc->AddArgument(sym);
+    }
+  }
+  isPrepared = true;
+}
+
+bool FEStructMethodInfo::SearchStructMethodJava(MIRStructType &structType, MIRBuilder &mirBuilder, bool argIsStatic,
+                                                bool allowPrivate) {
+  if (structType.IsIncomplete()) {
+    return false;
+  }
+  actualContainer = structType.GetCompactMplTypeName();
+  std::string fullName = structType.GetCompactMplTypeName() + namemangler::kNameSplitterStr + GetElemName() +
+                         namemangler::kNameSplitterStr + GetSignatureName();
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName);
+  for (const MethodPair &methodPair : structType.GetMethods()) {
+    if (methodPair.second.second.GetAttr(FUNCATTR_private) && !allowPrivate) {
+      continue;
+    }
+    if (methodPair.second.second.GetAttr(FUNCATTR_static) != argIsStatic) {
+      continue;
+    }
+    const MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodPair.first.Idx(), true);
+    CHECK_NULL_FATAL(sym);
+    if (sym->GetNameStrIdx() == nameIdx) {
+      isStatic = argIsStatic;
+      if (isStatic) {
+        methodNameIdx = nameIdx;
+      }
+      PrepareMethod();
+      return true;
+    }
+  }
+  // search parent
+  return SearchStructMethodJavaInParent(structType, mirBuilder, argIsStatic);
+}
+
+bool FEStructMethodInfo::SearchStructMethodJavaInParent(MIRStructType &structType, MIRBuilder &mirBuilder,
+                                                        bool argIsStatic) {
+  bool found = false;
+  if (structType.GetKind() == kTypeClass) {
+    // parent
+    MIRClassType &classType = static_cast<MIRClassType&>(structType);
+    found = SearchStructMethodJava(classType.GetParentTyIdx(), mirBuilder, argIsStatic, false);
+    // implemented
+    for (const TyIdx &tyIdx : classType.GetInterfaceImplemented()) {
+      found = found || SearchStructMethodJava(tyIdx, mirBuilder, argIsStatic, false);
+    }
+  } else if (structType.GetKind() == kTypeInterface) {
+    // parent
+    MIRInterfaceType &interfaceType = static_cast<MIRInterfaceType&>(structType);
+    for (const TyIdx &tyIdx : interfaceType.GetParentsTyIdx()) {
+      found = found || SearchStructMethodJava(tyIdx, mirBuilder, argIsStatic, false);
+    }
+  } else {
+    CHECK_FATAL(false, "not supported yet");
+  }
+  return found;
+}
+
+bool FEStructMethodInfo::SearchStructMethodJava(const TyIdx &tyIdx, MIRBuilder &mirBuilder, bool argIsStatic,
+                                                bool allowPrivate) {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  if (type == nullptr) {
+    return false;
+  }
+  if (type->IsIncomplete()) {
+    return false;
+  }
+  if (type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface) {
+    MIRStructType *structType = static_cast<MIRStructType*>(type);
+    return SearchStructMethodJava(*structType, mirBuilder, argIsStatic, allowPrivate);
+  } else {
+    ERR(kLncErr, "parent type should be StructType");
+    return false;
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/fe_timer_ns.cpp b/src/hir2mpl/common/src/fe_timer_ns.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6efff93a79b1ea5ef48cf0b21b4f758660d119eb
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_timer_ns.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_timer_ns.h"
+#include "types_def.h"
+
+namespace maple {
+void FETimerNS::Start() {
+  (void)clock_gettime(CLOCK_REALTIME, &timeStart);
+}
+
+void FETimerNS::Stop() {
+  (void)clock_gettime(CLOCK_REALTIME, &timeEnd);
+}
+
+int64_t FETimerNS::GetTimeNS() const {
+  const int64 nsInS = 1000000000;
+  return nsInS * (timeEnd.tv_sec - timeStart.tv_sec) + (timeEnd.tv_nsec - timeStart.tv_nsec);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/fe_type_hierarchy.cpp b/src/hir2mpl/common/src/fe_type_hierarchy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c51ae341d0f19d7e8ecedeb2d838f412e0fd21d3
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_type_hierarchy.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_type_hierarchy.h"
+#include "global_tables.h"
+#include "fe_config_parallel.h"
+
+namespace maple {
+FETypeHierarchy FETypeHierarchy::instance;
+
+void FETypeHierarchy::InitByGlobalTable() {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  mapIdxChildParent.clear();
+  for (const MIRType *type : GlobalTables::GetTypeTable().GetTypeTable()) {
+    if (type == nullptr) {
+      continue;
+    }
+    switch (type->GetKind()) {
+      case kTypeClass: {
+        const MIRClassType *typeClass = static_cast<const MIRClassType*>(type);
+        AddMIRType(*typeClass);
+        break;
+      }
+      case kTypeInterface: {
+        const MIRInterfaceType *typeInterface = static_cast<const MIRInterfaceType*>(type);
+        AddMIRType(*typeInterface);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+
+void FETypeHierarchy::AddMIRType(const MIRClassType &type) {
+  MIRType *parentType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(type.GetParentTyIdx());
+  if (parentType != nullptr) {
+    CHECK_FATAL(parentType->IsStructType(), "parent must be struct type");
+    AddParentChildRelation(parentType->GetNameStrIdx(), type.GetNameStrIdx());
+  }
+  for (TyIdx tyIdx : type.GetInterfaceImplemented()) {
+    MIRType *implType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    CHECK_FATAL(implType->IsStructType(), "parent must be struct type");
+    AddParentChildRelation(implType->GetNameStrIdx(), type.GetNameStrIdx());
+  }
+}
+
+void FETypeHierarchy::AddMIRType(const MIRInterfaceType &type) {
+  for (TyIdx tyIdx : type.GetParentsTyIdx()) {
+    MIRType *parentType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    CHECK_FATAL(parentType->IsStructType(), "parent must be struct type");
+    AddParentChildRelation(parentType->GetNameStrIdx(), type.GetNameStrIdx());
+  }
+}
+
+bool FETypeHierarchy::IsParentOf(const GStrIdx &parentIdx, const GStrIdx &childIdx) {
+  if (parentIdx == childIdx) {
+    return true;
+  }
+  if (cache.find(std::make_pair(childIdx, parentIdx)) != cache.end()) {
+    return true;
+  }
+  auto it = mapIdxChildParent.find(childIdx);
+  if (it == mapIdxChildParent.end()) {
+    return false;
+  }
+  for (GStrIdx idx : it->second) {
+    if (IsParentOf(parentIdx, idx)) {
+      std::pair<GStrIdx, GStrIdx> item = std::make_pair(childIdx, parentIdx);
+      if (cache.find(item) == cache.end()) {
+        CHECK_FATAL(cache.insert(item).second, "cache insert failed");
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+void FETypeHierarchy::AddParentChildRelation(const GStrIdx &parentIdx, const GStrIdx &childIdx) {
+  if (mapIdxChildParent[childIdx].find(parentIdx) == mapIdxChildParent[childIdx].end()) {
+    CHECK_FATAL(mapIdxChildParent[childIdx].insert(parentIdx).second, "mapIdxChildParent insert failed");
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/fe_type_manager.cpp b/src/hir2mpl/common/src/fe_type_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5685715a32a04b8199183b4d9cbda9b2b70823a1
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_type_manager.cpp
@@ -0,0 +1,804 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_type_manager.h"
+#include <fstream>
+#include <sstream>
+#include "mir_parser.h"
+#include "bin_mplt.h"
+#include "global_tables.h"
+#include "fe_timer.h"
+#include "fe_config_parallel.h"
+#include "feir_type_helper.h"
+#include "fe_macros.h"
+#include "types_def.h"
+#include "fe_utils_ast.h"
+
+namespace maple {
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeUnknown = std::make_unique<FEIRTypeDefault>(PTY_unknown);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeU1 = std::make_unique<FEIRTypeDefault>(PTY_u1);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeI8 = std::make_unique<FEIRTypeDefault>(PTY_i8);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeU8 = std::make_unique<FEIRTypeDefault>(PTY_u8);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeI16 = std::make_unique<FEIRTypeDefault>(PTY_i16);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeU16 = std::make_unique<FEIRTypeDefault>(PTY_u16);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeI32 = std::make_unique<FEIRTypeDefault>(PTY_i32);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeU32 = std::make_unique<FEIRTypeDefault>(PTY_u32);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeI64 = std::make_unique<FEIRTypeDefault>(PTY_i64);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeU64 = std::make_unique<FEIRTypeDefault>(PTY_u64);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeF32 = std::make_unique<FEIRTypeDefault>(PTY_f32);
+const UniqueFEIRType FETypeManager::kPrimFEIRTypeF64 = std::make_unique<FEIRTypeDefault>(PTY_f64);
+const UniqueFEIRType FETypeManager::kFEIRTypeJavaObject = std::make_unique<FEIRTypeDefault>(PTY_ref);
+const UniqueFEIRType FETypeManager::kFEIRTypeJavaClass = std::make_unique<FEIRTypeDefault>(PTY_ref);
+const UniqueFEIRType FETypeManager::kFEIRTypeJavaString = std::make_unique<FEIRTypeDefault>(PTY_ref);
+
+FETypeManager::FETypeManager(MIRModule &moduleIn)
+    : module(moduleIn),
+      mp(FEUtils::NewMempool("mempool for FETypeManager", false /* isLcalPool */)),
+      allocator(mp),
+      builder(&module),
+      srcLang(kSrcLangJava),
+      funcMCCGetOrInsertLiteral(nullptr) {
+  static_cast<FEIRTypeDefault*>(kFEIRTypeJavaObject.get())->LoadFromJavaTypeName("Ljava/lang/Object;", false);
+  static_cast<FEIRTypeDefault*>(kFEIRTypeJavaClass.get())->LoadFromJavaTypeName("Ljava/lang/Class;", false);
+  static_cast<FEIRTypeDefault*>(kFEIRTypeJavaString.get())->LoadFromJavaTypeName("Ljava/lang/String;", false);
+  sameNamePolicy.SetFlag(FETypeSameNamePolicy::kFlagUseLastest);
+}
+
+FETypeManager::~FETypeManager() {
+  mp = nullptr;
+  funcMCCGetOrInsertLiteral = nullptr;
+
+  funcMCCStaticFieldGetBool = nullptr;
+  funcMCCStaticFieldGetByte = nullptr;
+  funcMCCStaticFieldGetShort = nullptr;
+  funcMCCStaticFieldGetChar = nullptr;
+  funcMCCStaticFieldGetInt = nullptr;
+  funcMCCStaticFieldGetLong = nullptr;
+  funcMCCStaticFieldGetFloat = nullptr;
+  funcMCCStaticFieldGetDouble = nullptr;
+  funcMCCStaticFieldGetObject = nullptr;
+
+  funcMCCStaticFieldSetBool = nullptr;
+  funcMCCStaticFieldSetByte = nullptr;
+  funcMCCStaticFieldSetShort = nullptr;
+  funcMCCStaticFieldSetChar = nullptr;
+  funcMCCStaticFieldSetInt = nullptr;
+  funcMCCStaticFieldSetLong = nullptr;
+  funcMCCStaticFieldSetFloat = nullptr;
+  funcMCCStaticFieldSetDouble = nullptr;
+  funcMCCStaticFieldSetObject = nullptr;
+}
+
+void FETypeManager::ReleaseMemPool() {
+  FEUtils::DeleteMempoolPtr(mp);
+}
+
+bool FETypeManager::LoadMplts(const std::list<std::string> &mpltNames, FETypeFlag flag, const std::string &phaseName) {
+  FETimer timer;
+  timer.StartAndDump(phaseName);
+  bool success = true;
+  for (const std::string &fileName : mpltNames) {
+    success = success && LoadMplt(fileName, flag);
+  }
+  timer.StopAndDumpTimeMS(phaseName);
+  return success;
+}
+
+bool FETypeManager::LoadMplt(const std::string &mpltName, FETypeFlag flag) {
+  BinaryMplt binMplt(module);
+  if (!binMplt.Import(mpltName)) {
+    // not a binary mplt
+    std::ifstream file(mpltName);
+    if (!file.is_open()) {
+      ERR(kLncErr, "unable to open mplt file %s", mpltName.c_str());
+      return false;
+    }
+    MIRParser parser(module);
+    if (!parser.ParseMPLTStandalone(file, mpltName)) {
+      ERR(kLncErr, "Failed to parser mplt file %s\n%s", mpltName.c_str(), parser.GetError().c_str());
+      file.close();
+      return false;
+    }
+    file.close();
+  }
+  UpdateStructNameTypeMapFromTypeTable(mpltName, flag);
+  UpdateNameFuncMapFromTypeTable();
+  return true;
+}
+
+void FETypeManager::UpdateStructNameTypeMapFromTypeTable(const std::string &mpltName, FETypeFlag flag) {
+  bool sameNameUseLastest = sameNamePolicy.IsUseLastest();
+  GStrIdx mpltNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(mpltName);
+  for (MIRType *type : GlobalTables::GetTypeTable().GetTypeTable()) {
+    if ((type == nullptr) || !IsStructType(*type)) {
+      continue;
+    }
+    MIRStructType *structType = static_cast<MIRStructType*>(type);
+    auto it = structNameTypeMap.insert(std::make_pair(structType->GetNameStrIdx(), std::make_pair(structType, flag)));
+    if (!it.second) {
+      // type is existed
+      structSameNameSrcList.push_back(std::make_pair(structType->GetNameStrIdx(),
+                                                     structNameSrcMap[structType->GetNameStrIdx()]));
+      structSameNameSrcList.push_back(std::make_pair(structType->GetNameStrIdx(), mpltNameIdx));
+      if (sameNameUseLastest) {
+        structNameTypeMap[structType->GetNameStrIdx()] = std::make_pair(structType, flag);
+        structNameSrcMap[structType->GetNameStrIdx()] = mpltNameIdx;
+      }
+    } else {
+      // type is not existed
+      structNameSrcMap[structType->GetNameStrIdx()] = mpltNameIdx;
+    }
+  }
+}
+
+void FETypeManager::SetMirImportedTypes(FETypeFlag flag) {
+  for (auto &item : structNameTypeMap) {
+    MIRStructType *type = item.second.first;
+    if ((type != nullptr) && FETypeManager::IsStructType(*type)) {
+      type->SetIsImported(true);
+      item.second.second = flag;
+    }
+  }
+}
+
+void FETypeManager::UpdateNameFuncMapFromTypeTable() {
+  for (uint32 i = 1; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); i++) {
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
+    CHECK_FATAL(symbol, "Symbol is null");
+    if (symbol->GetSKind() == kStFunc) {
+      CHECK_FATAL(symbol->GetFunction(), "Function in symbol is null");
+      MIRFunction *func = symbol->GetFunction();
+      if (func->GetAttr(FUNCATTR_static)) {
+        mpltNameStaticFuncMap[symbol->GetNameStrIdx()] = symbol->GetFunction();
+      } else {
+        mpltNameFuncMap[symbol->GetNameStrIdx()] = symbol->GetFunction();
+      }
+    }
+  }
+}
+
+void FETypeManager::CheckSameNamePolicy() const {
+  std::unordered_map<GStrIdx, std::list<GStrIdx>, GStrIdxHash> result;
+  for (const std::pair<GStrIdx, GStrIdx> &item : structSameNameSrcList) {
+    result[item.first].push_back(item.second);
+  }
+  if (result.size() > 0) {
+    WARN(kLncWarn, "========== Structs list with the same name ==========");
+  }
+  for (const std::pair<const GStrIdx, std::list<GStrIdx>> &item : result) {
+    std::string typeName = GlobalTables::GetStrTable().GetStringFromStrIdx(item.first);
+    WARN(kLncWarn, "Type: %s", typeName.c_str());
+    for (const GStrIdx &mpltNameIdx : item.second) {
+      std::string mpltName = GlobalTables::GetStrTable().GetStringFromStrIdx(mpltNameIdx);
+      WARN(kLncWarn, "  Defined in %s", mpltName.c_str());
+    }
+  }
+  if (result.size() > 0 && sameNamePolicy.IsFatal()) {
+    FATAL(kLncFatal, "Structs with the same name exsited. Exit.");
+  }
+}
+
+MIRStructType *FETypeManager::CreateStructType(const std::string &name) {
+  MIRStructType type(kTypeStruct);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  TyIdx tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&type);
+  module.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx);
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx.GetIdx())->GetNameStrIdx() == 0) {
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx.GetIdx())->SetNameStrIdx(strIdx);
+  }
+  auto *structType = static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx.GetIdx()));
+  structNameTypeMap[strIdx] = std::make_pair(structType, FETypeFlag::kSrcInput);
+  return structType;
+}
+
+MIRStructType *FETypeManager::GetOrCreateStructType(const std::string &name) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  const std::unordered_map<GStrIdx, FEStructTypePair, GStrIdxHash>::iterator &it  = structNameTypeMap.find(nameIdx);
+  if (it != structNameTypeMap.end()) {
+    return it->second.first;
+  }
+  MIRStructType *structType = CreateStructType(name);
+  module.PushbackTypeDefOrder(nameIdx);
+  CHECK_NULL_FATAL(structType);
+  return structType;
+}
+
+MIRTypeByName *FETypeManager::CreateTypeByNameType(const std::string &name) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  MIRTypeByName nameType(strIdx);
+  TyIdx tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&nameType);
+  MIRTypeByName *type = static_cast<MIRTypeByName*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx.GetIdx()));
+  nameTypeMap[strIdx] = type;
+  return type;
+}
+
+MIRTypeByName *FETypeManager::GetOrCreateTypeByNameType(const std::string &name) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  const auto &it  = nameTypeMap.find(nameIdx);
+  if (it != nameTypeMap.cend()) {
+    return it->second;
+  }
+  MIRTypeByName *nameType = CreateTypeByNameType(name);
+  return nameType;
+}
+
+MIRTypeByName *FETypeManager::GetTypeByNameType(const std::string &name) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  return GetTypeByNameType(nameIdx);
+}
+
+MIRTypeByName *FETypeManager::GetTypeByNameType(const GStrIdx &nameIdx) {
+  const auto &it = nameTypeMap.find(nameIdx);
+  if (it != nameTypeMap.cend()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+MIRTypeByName *FETypeManager::CreateTypedef(const std::string &name, const MIRType &type) {
+  MIRTypeByName *typdefType = GetOrCreateTypeByNameType(name);
+  if (!module.GetScope()->GetTypeAlias()->Exist(typdefType->GetNameStrIdx())) {
+    module.GetScope()->SetTypeAliasMap(typdefType->GetNameStrIdx(), type.GetTypeIndex());
+  }
+  return typdefType;
+}
+
+MIREnum *FETypeManager::CreateEnum(const std::string &name, PrimType primType) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  MIREnum *enumType = new MIREnum(primType, strIdx);
+  enumNameMap[strIdx] = GlobalTables::GetEnumTable().enumTable.size();
+  GlobalTables::GetEnumTable().enumTable.push_back(enumType);
+  return enumType;
+}
+
+MIREnum *FETypeManager::GetOrCreateEnum(const std::string &name, PrimType primType) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  const auto &it  = enumNameMap.find(nameIdx);
+  if (it != enumNameMap.cend()) {
+    CHECK_FATAL(it->second < GlobalTables::GetEnumTable().enumTable.size(), "enumTable out of bounds");
+    MIREnum *enumType = GlobalTables::GetEnumTable().enumTable[it->second];
+    return enumType;
+  }
+  MIREnum *enumType = CreateEnum(name, primType);
+  return enumType;
+}
+
+size_t FETypeManager::GetEnumIdx(const std::string &name) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  const auto &it  = enumNameMap.find(nameIdx);
+  if (it != enumNameMap.cend()) {
+    return it->second;
+  }
+  CHECK_FATAL(false, "The enum was not found, %s", name.c_str());
+  return 0;
+}
+
+/*
+ * create MIRStructType for complex number, e.g.
+ * type $Complex|F <struct {
+ *   @real f32,
+ *   @imag f32}>
+ */
+MIRType *FETypeManager::GetOrCreateComplexStructType(const MIRType &elemType) {
+  const std::string typeName = "Complex|" + FEUtilAST::Type2Label(elemType.GetPrimType());
+  MIRStructType *structType = GetOrCreateStructType(typeName);
+  if (structType->GetFields().size() == 0) {
+    GStrIdx realStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("real");
+    GStrIdx imagStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("imag");
+    FieldAttrs fieldAttrs;
+    TyIdxFieldAttrPair pair(elemType.GetTypeIndex(), fieldAttrs);
+    FieldPair realPair(realStrIdx, pair);
+    FieldPair imagePair(imagStrIdx, pair);
+    structType->GetFields().push_back(realPair);
+    structType->GetFields().push_back(imagePair);
+  }
+  return structType;
+}
+
+MIRStructType *FETypeManager::GetClassOrInterfaceType(const GStrIdx &nameIdx) const {
+  auto it = structNameTypeMap.find(nameIdx);
+  if (it == structNameTypeMap.end()) {
+    return nullptr;
+  } else {
+    return it->second.first;
+  }
+}
+
+FETypeFlag FETypeManager::GetClassOrInterfaceTypeFlag(const GStrIdx &nameIdx) const {
+  auto it = structNameTypeMap.find(nameIdx);
+  if (it == structNameTypeMap.end()) {
+    return FETypeFlag::kDefault;
+  } else {
+    return it->second.second;
+  }
+}
+
+MIRStructType *FETypeManager::CreateClassOrInterfaceType(const GStrIdx &nameIdx, bool isInterface,
+                                                         FETypeFlag typeFlag) {
+  MIRType *type = nullptr;
+  std::string name = GlobalTables::GetStrTable().GetStringFromStrIdx(nameIdx);
+  if (isInterface) {
+    type = GlobalTables::GetTypeTable().GetOrCreateInterfaceType(name.c_str(), module);
+  } else {
+    type = GlobalTables::GetTypeTable().GetOrCreateClassType(name.c_str(), module);
+  }
+  CHECK_NULL_FATAL(type);
+  ASSERT(IsStructType(*type), "type is not struct type");
+  MIRStructType *structType = static_cast<MIRStructType*>(type);
+  structNameTypeMap[nameIdx] = std::make_pair(structType, typeFlag);
+  return structType;
+}
+
+MIRStructType *FETypeManager::GetOrCreateClassOrInterfaceType(const GStrIdx &nameIdx, bool isInterface,
+                                                              FETypeFlag typeFlag, bool &isCreate) {
+  // same name policy: mpltSys > dex > mpltApk > mplt
+  const std::unordered_map<GStrIdx, FEStructTypePair, GStrIdxHash>::iterator &it  = structNameTypeMap.find(nameIdx);
+  if (it != structNameTypeMap.end()) {
+    uint16 flagExist = it->second.second & FETypeFlag::kSrcMask;
+    uint16 flagNew = typeFlag & FETypeFlag::kSrcMask;
+    // type is existed, use existed type
+    if (flagNew > flagExist) {
+      isCreate = false;
+      return it->second.first;
+    }
+    // type is existed when src input, replace with new type
+    if (typeFlag == FETypeFlag::kSrcInput && it->second.second != FETypeFlag::kSrcMpltApk) {
+      UpdateDupTypes(nameIdx, isInterface, it);
+    }
+  }
+  MIRStructType *structType = CreateClassOrInterfaceType(nameIdx, isInterface, typeFlag);
+  isCreate = true;
+  CHECK_NULL_FATAL(structType);
+  return structType;
+}
+
+void FETypeManager::UpdateDupTypes(const GStrIdx &nameIdx, bool isInterface,
+    const std::unordered_map<GStrIdx, FEStructTypePair, GStrIdxHash>::iterator &importedTypeIt) {
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "duplicated type %s from src",
+                GlobalTables::GetStrTable().GetStringFromStrIdx(nameIdx).c_str());
+  MIRStructType *importedType = importedTypeIt->second.first;
+  MIRStructType *newType = nullptr;
+  // If locally defined type and imported type have the same name, but one is of interface and another one
+  // is of class type, we need to update the type
+  if ((importedType->IsMIRClassType() && isInterface) ||
+      (importedType->IsMIRInterfaceType() && !isInterface)) {
+    if (isInterface) {
+      newType = new MIRInterfaceType(kTypeInterfaceIncomplete);
+    } else {
+      newType = new MIRClassType(kTypeClassIncomplete);
+    }
+    newType->SetTypeIndex(importedType->GetTypeIndex());
+    importedType->SetTypeIndex(TyIdx(-1));
+    newType->SetNameStrIdx(importedType->GetNameStrIdx());
+    importedType->SetNameStrIdxItem(0);
+    CHECK_FATAL(newType->GetTypeIndex() < GlobalTables::GetTypeTable().GetTypeTable().size(),
+                "newType->_ty_idx >= GlobalTables::GetTypeTable().type_table_.size()");
+    GlobalTables::GetTypeTable().GetTypeTable()[newType->GetTypeIndex()] = newType;
+  } else {
+    importedType->ClearContents();
+  }
+  (void)structNameTypeMap.erase(importedTypeIt);
+  auto it = structNameSrcMap.find(nameIdx);
+  if (it != structNameSrcMap.end()) {
+    (void)structNameSrcMap.erase(it);
+  }
+}
+
+MIRType *FETypeManager::GetOrCreateClassOrInterfacePtrType(const GStrIdx &nameIdx, bool isInterface,
+                                                           FETypeFlag typeFlag, bool &isCreate) {
+  MIRStructType *structType = GetOrCreateClassOrInterfaceType(nameIdx, isInterface, typeFlag, isCreate);
+  MIRType *ptrType = GetOrCreatePointerType(*structType);
+  CHECK_NULL_FATAL(ptrType);
+  return ptrType;
+}
+
+MIRStructType *FETypeManager::GetStructTypeFromName(const std::string &name) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  return GetStructTypeFromName(nameIdx);
+}
+
+MIRStructType *FETypeManager::GetStructTypeFromName(const GStrIdx &nameIdx) {
+  auto it = structNameTypeMap.find(nameIdx);
+  if (it == structNameTypeMap.end()) {
+    return nullptr;
+  } else {
+    return it->second.first;
+  }
+}
+
+uint32 FETypeManager::GetTypeIDFromMplClassName(const std::string &mplClassName, int32 dexFileHashCode) const {
+  const auto &itMap = classNameTypeIDMapAllDex.find(dexFileHashCode);
+  if (itMap != classNameTypeIDMapAllDex.end()) {
+    const auto &thisDexClassNameTypeIDMap =  itMap->second;
+    const auto &it = thisDexClassNameTypeIDMap.find(mplClassName);
+    if (it != thisDexClassNameTypeIDMap.end()) {
+      return it->second;
+    }
+    return UINT32_MAX;
+  }
+  return UINT32_MAX; // some type id not in the dex file, give UINT32_MAX
+}
+
+MIRType *FETypeManager::GetOrCreateTypeFromName(const std::string &name, FETypeFlag typeFlag, bool usePtr) {
+  CHECK_FATAL(!name.empty(), "type name is empty");
+  PrimType pty = GetPrimType(name);
+  if (pty != kPtyInvalid) {
+    return GlobalTables::GetTypeTable().GetTypeTable().at(pty);
+  }
+  switch (name[0]) {
+    case 'L': {
+      bool isCreate = false;
+      MIRStructType *structType = GetOrCreateClassOrInterfaceType(name, false, typeFlag, isCreate);
+      if (usePtr) {
+        return GetOrCreatePointerType(*structType);
+      } else {
+        return structType;
+      }
+    }
+    case 'A': {
+      uint32 dim = 0;
+      bool isCreate = false;
+      const std::string &elemTypeName = GetBaseTypeName(name, dim, true);
+      MIRType *elemType = GetMIRTypeForPrim(elemTypeName);
+      if (elemType == nullptr) {
+        elemType = GetOrCreateClassOrInterfaceType(elemTypeName, false, typeFlag, isCreate);
+        CHECK_NULL_FATAL(elemType);
+        elemType = GetOrCreatePointerType(*elemType);
+      }
+      CHECK_FATAL(dim <= UINT8_MAX, "array dimension (%u) is out of range", dim);
+      MIRType *type = GetOrCreateArrayType(*elemType, static_cast<uint8>(dim));
+      ASSERT(type != nullptr, "Array type is null");
+      if (usePtr) {
+        return GetOrCreatePointerType(*type);
+      } else {
+        return type;
+      }
+    }
+    default:
+      MIRType *type = GetMIRTypeForPrim(name[0]);
+      CHECK_FATAL(type, "Unresolved type %s", name.c_str());
+      return type;
+  }
+}
+
+MIRType *FETypeManager::GetOrCreatePointerType(const MIRType &type, PrimType ptyPtr) {
+  MIRType *retType = GlobalTables::GetTypeTable().GetOrCreatePointerType(type, ptyPtr);
+  CHECK_NULL_FATAL(retType);
+  return retType;
+}
+
+MIRType *FETypeManager::GetOrCreateArrayType(MIRType &elemType, uint8 dim, PrimType ptyPtr) {
+  switch (srcLang) {
+    case kSrcLangJava:
+    case kSrcLangC: // Need to be optimized
+      return GetOrCreateJArrayType(elemType, dim, ptyPtr);
+    default:
+      CHECK_FATAL(false, "unsupported src lang: %d", srcLang);
+      return nullptr;
+  }
+}
+
+MIRType *FETypeManager::GetOrCreateJArrayType(MIRType &elemType, uint8 dim, PrimType ptyPtr) {
+  MIRType *type = &elemType;
+  for (uint8 i = 0; i < dim; i++) {
+    type = GlobalTables::GetTypeTable().GetOrCreateJarrayType(*type);
+    CHECK_NULL_FATAL(type);
+    if (i != dim - 1) {
+      type = GetOrCreatePointerType(*type, ptyPtr);
+      CHECK_NULL_FATAL(type);
+    }
+  }
+  CHECK_NULL_FATAL(type);
+  return type;
+}
+
+void FETypeManager::AddClassToModule(const MIRStructType &structType) {
+  module.AddClass(structType.GetTypeIndex());
+}
+
+FEStructElemInfo *FETypeManager::RegisterStructFieldInfo(
+    const StructElemNameIdx &argStructElemNameIdx, MIRSrcLang argSrcLang, bool isStatic) {
+  std::lock_guard<std::mutex> lk(feTypeManagerMtx);
+  FEStructElemInfo *ptrInfo = GetStructElemInfo(argStructElemNameIdx.full);
+  if (ptrInfo != nullptr) {
+    return ptrInfo;
+  }
+  ptrInfo = allocator.GetMemPool()->New<FEStructFieldInfo>(allocator, argStructElemNameIdx, argSrcLang, isStatic);
+  CHECK_FATAL(mapStructElemInfo.insert(std::make_pair(argStructElemNameIdx.full, ptrInfo)).second,
+              "register struct elem info failed");
+  return ptrInfo;
+}
+
+FEStructElemInfo *FETypeManager::RegisterStructMethodInfo(
+    const StructElemNameIdx &argStructElemNameIdx, MIRSrcLang argSrcLang, bool isStatic) {
+  std::lock_guard<std::mutex> lk(feTypeManagerMtx);
+  FEStructElemInfo *ptrInfo = GetStructElemInfo(argStructElemNameIdx.full);
+  if (ptrInfo != nullptr) {
+    return ptrInfo;
+  }
+  ptrInfo = allocator.GetMemPool()->New<FEStructMethodInfo>(allocator, argStructElemNameIdx, argSrcLang, isStatic);
+  CHECK_FATAL(mapStructElemInfo.insert(std::make_pair(argStructElemNameIdx.full, ptrInfo)).second,
+              "register struct elem info failed");
+  return ptrInfo;
+}
+
+FEStructElemInfo *FETypeManager::GetStructElemInfo(const GStrIdx &fullNameIdx) const {
+  auto it = mapStructElemInfo.find(fullNameIdx);
+  if (it == mapStructElemInfo.end()) {
+    return nullptr;
+  }
+  return it->second;
+}
+
+MIRFunction *FETypeManager::GetMIRFunction(const std::string &classMethodName, bool isStatic) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(classMethodName);
+  return GetMIRFunction(nameIdx, isStatic);
+}
+
+MIRFunction *FETypeManager::GetMIRFunction(const GStrIdx &nameIdx, bool isStatic) {
+  const std::unordered_map<GStrIdx, MIRFunction*, GStrIdxHash> &funcMap = isStatic ? nameStaticFuncMap : nameFuncMap;
+  auto it = funcMap.find(nameIdx);
+  if (it != funcMap.end()) {
+    return it->second;
+  }
+  const std::unordered_map<GStrIdx, MIRFunction*, GStrIdxHash> &mpltFuncMap =
+      isStatic ? mpltNameStaticFuncMap : mpltNameFuncMap;
+  auto it2 = mpltFuncMap.find(nameIdx);
+  if (it2 != mpltFuncMap.end()) {
+    return it2->second;
+  }
+  return nullptr;
+}
+
+MIRFunction *FETypeManager::CreateFunction(const GStrIdx &nameIdx, const TyIdx &retTypeIdx,
+                                           const std::vector<TyIdx> &argsTypeIdx, bool isVarg, bool isStatic) {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  MIRFunction *mirFunc = GetMIRFunction(nameIdx, isStatic);
+  if (mirFunc != nullptr) {
+    return mirFunc;
+  }
+  MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  funcSymbol->SetNameStrIdx(nameIdx);
+  bool added = GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcSymbol);
+  if (!added) {
+    funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(nameIdx);
+    mirFunc = funcSymbol->GetFunction();
+    if (mirFunc != nullptr) {
+      return mirFunc;
+    }
+  }
+  funcSymbol->SetStorageClass(kScText);
+  funcSymbol->SetSKind(kStFunc);
+  MemPool *mpModule = module.GetMemPool();
+  ASSERT(mpModule, "mem pool is nullptr");
+  mirFunc = mpModule->New<MIRFunction>(&module, funcSymbol->GetStIdx());
+  mirFunc->AllocSymTab();
+  size_t idx = GlobalTables::GetFunctionTable().GetFuncTable().size();
+  CHECK_FATAL(idx < UINT32_MAX, "PUIdx is out of range");
+  mirFunc->SetPuidx(static_cast<uint32>(idx));
+  mirFunc->SetPuidxOrigin(mirFunc->GetPuidx());
+  GlobalTables::GetFunctionTable().GetFuncTable().push_back(mirFunc);
+  std::vector<TypeAttrs> argsAttr;
+  for (uint32_t i = 0; i < argsTypeIdx.size(); i++) {
+    argsAttr.emplace_back(TypeAttrs());
+  }
+  mirFunc->SetBaseClassFuncNames(nameIdx);
+  funcSymbol->SetTyIdx(GlobalTables::GetTypeTable().GetOrCreateFunctionType(retTypeIdx, argsTypeIdx, argsAttr,
+                                                                            isVarg)->GetTypeIndex());
+  funcSymbol->SetFunction(mirFunc);
+  MIRFuncType *functype = static_cast<MIRFuncType*>(funcSymbol->GetType());
+  mirFunc->SetMIRFuncType(functype);
+  mirFunc->SetReturnTyIdx(retTypeIdx);
+  if (isStatic) {
+    mirFunc->SetAttr(FUNCATTR_static);
+    CHECK_FATAL(nameStaticFuncMap.insert(std::make_pair(nameIdx, mirFunc)).second, "nameStaticFuncMap insert failed");
+  } else {
+    CHECK_FATAL(nameFuncMap.insert(std::make_pair(nameIdx, mirFunc)).second, "nameFuncMap insert failed");
+  }
+  return mirFunc;
+}
+
+MIRFunction *FETypeManager::CreateFunction(const std::string &methodName, const std::string &returnTypeName,
+                                           const std::vector<std::string> &argTypeNames, bool isVarg, bool isStatic) {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(methodName);
+  MIRFunction *mirFunc = GetMIRFunction(nameIdx, isStatic);
+  if (mirFunc != nullptr) {
+    return mirFunc;
+  }
+  MIRType *returnType = GetOrCreateTypeFromName(returnTypeName, FETypeFlag::kSrcUnknown, true);
+  std::vector<TyIdx> argsTypeIdx;
+  for (const std::string &typeName : argTypeNames) {
+    MIRType *argType = GetOrCreateTypeFromName(typeName, FETypeFlag::kSrcUnknown, true);
+    argsTypeIdx.push_back(argType->GetTypeIndex());
+  }
+  return CreateFunction(nameIdx, returnType->GetTypeIndex(), argsTypeIdx, isVarg, isStatic);
+}
+
+const FEIRType *FETypeManager::GetOrCreateFEIRTypeByName(const std::string &typeName, const GStrIdx &typeNameIdx,
+                                                         MIRSrcLang argSrcLang) {
+  const FEIRType *feirType = GetFEIRTypeByName(typeName);
+  if (feirType != nullptr) {
+    return feirType;
+  }
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  UniqueFEIRType uniType;
+  switch (argSrcLang) {
+    case kSrcLangJava:
+      uniType = FEIRTypeHelper::CreateTypeByJavaName(typeName, true, false);
+      break;
+    case kSrcLangC:
+      WARN(kLncWarn, "kSrcLangC GetOrCreateFEIRTypeByName NYI");
+      break;
+    default:
+      CHECK_FATAL(false, "unsupported language");
+      return nullptr;
+  }
+  feirType = uniType.get();
+  nameFEIRTypeList.push_back(std::move(uniType));
+  if (typeNameIdx == 0) {
+    nameFEIRTypeMap[GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName)] = feirType;
+  } else {
+    nameFEIRTypeMap[typeNameIdx] = feirType;
+  }
+  return feirType;
+}
+
+const FEIRType *FETypeManager::GetOrCreateFEIRTypeByName(const GStrIdx &typeNameIdx, MIRSrcLang argSrcLang) {
+  const std::string &typeName = GlobalTables::GetStrTable().GetStringFromStrIdx(typeNameIdx);
+  return GetOrCreateFEIRTypeByName(typeName, typeNameIdx, argSrcLang);
+}
+
+const FEIRType *FETypeManager::GetFEIRTypeByName(const std::string &typeName) const {
+  GStrIdx typeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+  return GetFEIRTypeByName(typeNameIdx);
+}
+
+const FEIRType *FETypeManager::GetFEIRTypeByName(const GStrIdx &typeNameIdx) const {
+  auto it = nameFEIRTypeMap.find(typeNameIdx);
+  if (it == nameFEIRTypeMap.end()) {
+    return nullptr;
+  } else {
+    return it->second;
+  }
+}
+
+bool FETypeManager::IsAntiProguardFieldStruct(const GStrIdx &structNameIdx) {
+  return setAntiProguardFieldStructIdx.find(structNameIdx) != setAntiProguardFieldStructIdx.end();
+}
+
+bool FETypeManager::IsStructType(const MIRType &type) {
+  MIRTypeKind kind = type.GetKind();
+  return kind == kTypeStruct || kind == kTypeStructIncomplete ||
+         kind == kTypeClass || kind == kTypeClassIncomplete ||
+         kind == kTypeInterface || kind == kTypeInterfaceIncomplete ||
+         kind == kTypeUnion;
+}
+
+PrimType FETypeManager::GetPrimType(const std::string &name) {
+#define LOAD_ALGO_PRIMARY_TYPE
+#define PRIMTYPE(P)            \
+  if (name.compare(#P) == 0) { \
+    return PTY_##P;            \
+  }
+#include "prim_types.def"
+#undef PRIMTYPE
+  return kPtyInvalid;
+}
+
+MIRType *FETypeManager::GetMIRTypeForPrim(char c) {
+  switch (c) {
+    case 'B':
+      return GlobalTables::GetTypeTable().GetInt8();
+    case 'C':
+      return GlobalTables::GetTypeTable().GetUInt16();
+    case 'S':
+      return GlobalTables::GetTypeTable().GetInt16();
+    case 'Z':
+      return GlobalTables::GetTypeTable().GetUInt1();
+    case 'I':
+      return GlobalTables::GetTypeTable().GetInt32();
+    case 'J':
+      return GlobalTables::GetTypeTable().GetInt64();
+    case 'F':
+      return GlobalTables::GetTypeTable().GetFloat();
+    case 'D':
+      return GlobalTables::GetTypeTable().GetDouble();
+    case 'V':
+      return GlobalTables::GetTypeTable().GetVoid();
+    case 'R':
+      return GlobalTables::GetTypeTable().GetRef();
+    default:
+      return nullptr;
+  }
+}
+
+std::string FETypeManager::GetBaseTypeName(const std::string &name, uint32 &dim, bool inMpl) {
+  dim = 0;
+  char prefix = inMpl ? 'A' : '[';
+  while (name[dim] == prefix) {
+    dim++;
+  }
+  return name.substr(dim);
+}
+
+void FETypeManager::SetComplete(MIRStructType &structType) {
+  switch (structType.GetKind()) {
+    case kTypeClassIncomplete:
+      structType.SetMIRTypeKind(kTypeClass);
+      break;
+    case kTypeInterfaceIncomplete:
+      structType.SetMIRTypeKind(kTypeInterface);
+      break;
+    case kTypeStructIncomplete:
+      structType.SetMIRTypeKind(kTypeStruct);
+      break;
+    default:
+      break;
+  }
+}
+
+std::string FETypeManager::TypeAttrsToString(const TypeAttrs &attrs) {
+  std::stringstream ss;
+#define TYPE_ATTR
+#define ATTR(A)                \
+  if (attrs.GetAttr(ATTR_##A)) \
+    ss << " " << #A;
+#include "all_attributes.def"
+#undef ATTR
+#undef TYPE_ATTR
+  ss << " ";
+  return ss.str();
+}
+
+void FETypeManager::MarkExternStructType() {
+  for (auto elem : structNameTypeMap) {
+    if (elem.second.second != FETypeFlag::kSrcInput &&
+        elem.second.second != FETypeFlag::kSrcMplt &&
+        elem.second.second != FETypeFlag::kSrcMpltSys &&
+        elem.second.second != FETypeFlag::kSrcMpltApk) {
+      module.AddExternStructType(elem.second.first);
+    }
+  }
+}
+
+void FETypeManager::InitMCCFunctions() {
+  if (srcLang == kSrcLangJava) {
+    InitFuncMCCGetOrInsertLiteral();
+  }
+}
+
+void FETypeManager::InitFuncMCCGetOrInsertLiteral() {
+  std::string funcName = "MCC_GetOrInsertLiteral";
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  MIRType *typeString = kFEIRTypeJavaString->GenerateMIRTypeAuto(kSrcLangJava);
+  std::vector<TyIdx> argsType;
+  funcMCCGetOrInsertLiteral = CreateFunction(nameIdx, typeString->GetTypeIndex(), argsType, false, false);
+  funcMCCGetOrInsertLiteral->SetAttr(FUNCATTR_pure);
+  funcMCCGetOrInsertLiteral->SetAttr(FUNCATTR_nosideeffect);
+  funcMCCGetOrInsertLiteral->SetAttr(FUNCATTR_noprivate_defeffect);
+  nameMCCFuncMap[nameIdx] = funcMCCGetOrInsertLiteral;
+}
+
+MIRFunction *FETypeManager::GetMCCFunction(const std::string &funcName) const {
+  GStrIdx funcNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  return GetMCCFunction(funcNameIdx);
+}
+
+MIRFunction *FETypeManager::GetMCCFunction(const GStrIdx &funcNameIdx) const {
+  auto it = nameMCCFuncMap.find(funcNameIdx);
+  CHECK_FATAL(it != nameMCCFuncMap.cend(), "The specified MCCFunc was not found");
+  return it->second;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/fe_utils.cpp b/src/hir2mpl/common/src/fe_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..abd13345eef2c16258924a45f205635407813b62
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_utils.cpp
@@ -0,0 +1,619 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_utils.h"
+#include <sstream>
+#include "mpl_logging.h"
+#include "mir_type.h"
+#include "mir_builder.h"
+#include "fe_manager.h"
+namespace maple {
+// ---------- FEUtils ----------
+const std::string FEUtils::kBoolean = "Z";
+const std::string FEUtils::kByte = "B";
+const std::string FEUtils::kShort = "S";
+const std::string FEUtils::kChar = "C";
+const std::string FEUtils::kInt = "I";
+const std::string FEUtils::kLong = "J";
+const std::string FEUtils::kFloat = "F";
+const std::string FEUtils::kDouble = "D";
+const std::string FEUtils::kVoid = "V";
+const std::string FEUtils::kThis = "_this";
+const std::string FEUtils::kMCCStaticFieldGetBool   = "MCC_StaticFieldGetBool";
+const std::string FEUtils::kMCCStaticFieldGetByte   = "MCC_StaticFieldGetByte";
+const std::string FEUtils::kMCCStaticFieldGetShort  = "MCC_StaticFieldGetShort";
+const std::string FEUtils::kMCCStaticFieldGetChar   = "MCC_StaticFieldGetChar";
+const std::string FEUtils::kMCCStaticFieldGetInt    = "MCC_StaticFieldGetInt";
+const std::string FEUtils::kMCCStaticFieldGetLong   = "MCC_StaticFieldGetLong";
+const std::string FEUtils::kMCCStaticFieldGetFloat  = "MCC_StaticFieldGetFloat";
+const std::string FEUtils::kMCCStaticFieldGetDouble = "MCC_StaticFieldGetDouble";
+const std::string FEUtils::kMCCStaticFieldGetObject = "MCC_StaticFieldGetObject";
+
+const std::string FEUtils::kMCCStaticFieldSetBool   = "MCC_StaticFieldSetBool";
+const std::string FEUtils::kMCCStaticFieldSetByte   = "MCC_StaticFieldSetByte";
+const std::string FEUtils::kMCCStaticFieldSetShort  = "MCC_StaticFieldSetShort";
+const std::string FEUtils::kMCCStaticFieldSetChar   = "MCC_StaticFieldSetChar";
+const std::string FEUtils::kMCCStaticFieldSetInt    = "MCC_StaticFieldSetInt";
+const std::string FEUtils::kMCCStaticFieldSetLong   = "MCC_StaticFieldSetLong";
+const std::string FEUtils::kMCCStaticFieldSetFloat  = "MCC_StaticFieldSetFloat";
+const std::string FEUtils::kMCCStaticFieldSetDouble = "MCC_StaticFieldSetDouble";
+const std::string FEUtils::kMCCStaticFieldSetObject = "MCC_StaticFieldSetObject";
+
+const std::string FEUtils::kCondGoToStmtLabelNamePrefix = "shortCircuit_";
+
+std::vector<std::string> FEUtils::Split(const std::string &str, char delim) {
+  std::vector<std::string> ans;
+  std::stringstream ss;
+  ss.str(str);
+  std::string item;
+  while (std::getline(ss, item, delim)) {
+    ans.push_back(item);
+  }
+  return ans;
+}
+
+uint8 FEUtils::GetWidth(PrimType primType) {
+  switch (primType) {
+    case PTY_u1:
+      return 1;
+    case PTY_i8:
+    case PTY_u8:
+      return 8;
+    case PTY_i16:
+    case PTY_u16:
+      return 16;
+    case PTY_i32:
+    case PTY_u32:
+    case PTY_f32:
+      return 32;
+    case PTY_i64:
+    case PTY_u64:
+    case PTY_f64:
+      return 64;
+    default:
+      CHECK_FATAL(false, "unsupported type %d", primType);
+      return 0;
+  }
+}
+
+bool FEUtils::IsInteger(PrimType primType) {
+  return (primType == PTY_i8) || (primType == PTY_u8) ||
+         (primType == PTY_i16) || (primType == PTY_u16) ||
+         (primType == PTY_i32) || (primType == PTY_u32) ||
+         (primType == PTY_i64) || (primType == PTY_u64);
+}
+
+bool FEUtils::IsSignedInteger(PrimType primType) {
+  return (primType == PTY_i8) || (primType == PTY_i16) || (primType == PTY_i32) || (primType == PTY_i64);
+}
+
+bool FEUtils::IsUnsignedInteger(PrimType primType) {
+  return (primType == PTY_u8) || (primType == PTY_u16) || (primType == PTY_u32) || (primType == PTY_u64);
+}
+
+PrimType FEUtils::MergePrimType(PrimType primType1, PrimType primType2) {
+  if (primType1 == primType2) {
+    return primType1;
+  }
+  // merge signed integer
+  CHECK_FATAL(!LogicXOR(IsSignedInteger(primType1), IsSignedInteger(primType2)),
+              "can not merge type %s and %s", GetPrimTypeName(primType1), GetPrimTypeName(primType2));
+  if (IsSignedInteger(primType1)) {
+    return GetPrimTypeSize(primType1) >= GetPrimTypeSize(primType2) ? primType1 : primType2;
+  }
+
+  // merge unsigned integer
+  CHECK_FATAL(!LogicXOR(IsUnsignedInteger(primType1), IsUnsignedInteger(primType2)),
+              "can not merge type %s and %s", GetPrimTypeName(primType1), GetPrimTypeName(primType2));
+  if (IsUnsignedInteger(primType1)) {
+    if (GetPrimTypeSize(primType1) == GetPrimTypeSize(primType2) && GetPrimTypeSize(primType1) == 1) {
+      return PTY_u8;
+    } else {
+      return GetPrimTypeSize(primType1) >= GetPrimTypeSize(primType2) ? primType1 : primType2;
+    }
+  }
+
+  // merge float
+  CHECK_FATAL(!LogicXOR(IsPrimitiveFloat(primType1), IsPrimitiveFloat(primType2)),
+              "can not merge type %s and %s", GetPrimTypeName(primType1), GetPrimTypeName(primType2));
+  if (IsPrimitiveFloat(primType1)) {
+    return GetPrimTypeSize(primType1) >= GetPrimTypeSize(primType2) ? primType1 : primType2;
+  }
+
+  CHECK_FATAL(false, "can not merge type %s and %s", GetPrimTypeName(primType1), GetPrimTypeName(primType2));
+  return PTY_unknown;
+}
+
+uint8 FEUtils::GetDim(const std::string &typeName) {
+  uint8 dim = 0;
+  for (size_t i = 0; i < typeName.length(); ++i) {
+    if (typeName.at(i) == 'A') {
+      dim++;
+    } else {
+      break;
+    }
+  }
+  return dim;
+}
+
+std::string FEUtils::GetBaseTypeName(const std::string &typeName) {
+  return typeName.substr(GetDim(typeName));
+}
+
+PrimType FEUtils::GetPrimType(const GStrIdx &typeNameIdx) {
+  if (typeNameIdx == GetBooleanIdx()) {
+    return PTY_u1;
+  }
+  if (typeNameIdx == GetByteIdx()) {
+    return PTY_i8;
+  }
+  if (typeNameIdx == GetShortIdx()) {
+    return PTY_i16;
+  }
+  if (typeNameIdx == GetCharIdx()) {
+    return PTY_u16;
+  }
+  if (typeNameIdx == GetIntIdx()) {
+    return PTY_i32;
+  }
+  if (typeNameIdx == GetLongIdx()) {
+    return PTY_i64;
+  }
+  if (typeNameIdx == GetFloatIdx()) {
+    return PTY_f32;
+  }
+  if (typeNameIdx == GetDoubleIdx()) {
+    return PTY_f64;
+  }
+  if (typeNameIdx == GetVoidIdx()) {
+    return PTY_void;
+  }
+  return PTY_ref;
+}
+
+std::string FEUtils::GetSequentialName0(const std::string &prefix, uint32_t num) {
+  std::stringstream ss;
+  ss << prefix << num;
+  return ss.str();
+}
+
+uint32 FEUtils::GetSequentialNumber() {
+  static uint32 unnamedSymbolIdx = 1;
+  return unnamedSymbolIdx++;
+}
+
+std::string FEUtils::GetFileNameHashStr(const std::string &fileName, uint32 seed) {
+  const char *name = fileName.c_str();
+  uint32 hash = 0;
+  while (*name) {
+    uint8_t uName = *name++;
+    hash = hash * seed + uName;
+  }
+  return kRenameKeyWord + std::to_string(hash);
+}
+
+std::string FEUtils::GetSequentialName(const std::string &prefix) {
+  std::string name = GetSequentialName0(prefix, GetSequentialNumber());
+  return name;
+}
+
+std::string FEUtils::CreateLabelName() {
+  static uint32 unnamedSymbolIdx = 1;
+  return "L." + std::to_string(unnamedSymbolIdx++);
+}
+
+bool FEUtils::TraverseToNamedField(MIRStructType &structType, const GStrIdx &nameIdx, FieldID &fieldID,
+                                   bool isTopLevel) {
+  for (uint32 fieldIdx = 0; fieldIdx < structType.GetFieldsSize(); ++fieldIdx) {
+    ++fieldID;
+    TyIdx fieldTyIdx = structType.GetFieldsElemt(fieldIdx).second.first;
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    ASSERT(fieldType != nullptr, "fieldType is null");
+    if (isTopLevel && structType.GetFieldsElemt(fieldIdx).first == nameIdx) {
+      return true;
+    }
+    // The fields of an embedded structure array are assigned fieldIDs
+    if (fieldType->GetKind() == kTypeArray) {
+      fieldType = fieldType->EmbeddedStructType();
+    }
+    if (fieldType != nullptr && fieldType->IsStructType()) {
+      auto *subStructType = static_cast<MIRStructType *>(fieldType);
+      if (TraverseToNamedField(*subStructType, nameIdx, fieldID, false)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+FieldID FEUtils::GetStructFieldID(MIRStructType *base, const std::string &fieldName) {
+  MIRStructType *type = base;
+  std::vector<std::string> fieldNames = FEUtils::Split(fieldName, '$');
+  std::reverse(fieldNames.begin(), fieldNames.end());
+  FieldID fieldID = 0;
+  for (const auto &f: fieldNames) {
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(f);
+    CHECK_FATAL(type->IsStructType(), "Must be struct type!");
+    if (TraverseToNamedField(*type, strIdx, fieldID)) {
+      type = static_cast<MIRStructType *>(base->GetFieldType(fieldID));
+    }
+  }
+  return fieldID;
+}
+
+MIRType *FEUtils::GetStructFieldType(const MIRStructType *type, FieldID fieldID) {
+  FieldID tmpID = fieldID;
+  FieldPair fieldPair = type->TraverseToFieldRef(tmpID);
+  MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+  return fieldType;
+}
+
+const MIRFuncType *FEUtils::GetFuncPtrType(const MIRType &type) {
+  const MIRType *mirType = &type;
+  if (mirType->GetKind() != kTypePointer) {
+    return nullptr;
+  }
+  mirType = static_cast<const MIRPtrType*>(mirType)->GetPointedType();
+  if (mirType->GetKind() != kTypePointer) {
+    return nullptr;
+  }
+  mirType = static_cast<const MIRPtrType*>(mirType)->GetPointedType();
+  if (mirType->GetKind() != kTypeFunction) {
+    return nullptr;
+  }
+  return static_cast<const MIRFuncType*>(mirType);
+}
+
+MIRConst *FEUtils::CreateImplicitConst(MIRType *type) {
+  switch (type->GetPrimType()) {
+    case PTY_u1: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_u1));
+    }
+    case PTY_u8: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_u8));
+    }
+    case PTY_u16: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_u16));
+    }
+    case PTY_u32: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_u32));
+    }
+    case PTY_u64: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_u64));
+    }
+    case PTY_i8: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_i8));
+    }
+    case PTY_i16: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_i16));
+    }
+    case PTY_i32: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_i32));
+    }
+    case PTY_i64: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_i64));
+    }
+    case PTY_f32: {
+      return FEManager::GetModule().GetMemPool()->New<MIRFloatConst>(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_f32));
+    }
+    case PTY_f64: {
+      return FEManager::GetModule().GetMemPool()->New<MIRDoubleConst>(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_f64));
+    }
+    case PTY_ptr: {
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          0, *GlobalTables::GetTypeTable().GetPrimType(PTY_i64));
+    }
+    case PTY_agg: {
+      auto *aggConst = FEManager::GetModule().GetMemPool()->New<MIRAggConst>(FEManager::GetModule(), *type);
+      if (type->IsStructType()) {
+        auto structType = static_cast<MIRStructType*>(type);
+        FieldID fieldID = 0;
+        for (auto &f:structType->GetFields()) {
+          fieldID++;
+          auto fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(f.second.first);
+          aggConst->AddItem(CreateImplicitConst(fieldType), fieldID);
+        }
+      } else if (type->GetKind() == kTypeArray) {
+        auto arrayType = static_cast<MIRArrayType*>(type);
+        MIRConst *elementConst;
+        if (arrayType->GetDim() > 1) {
+          uint32 subSizeArray[arrayType->GetDim()];
+          for (int dim = 1; dim < arrayType->GetDim(); ++dim) {
+            subSizeArray[dim - 1] = arrayType->GetSizeArrayItem(dim);
+          }
+          auto subArrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(
+              *arrayType->GetElemType(), static_cast<uint8>(arrayType->GetDim() - 1), subSizeArray);
+          elementConst = CreateImplicitConst(subArrayType);
+        } else {
+          elementConst = CreateImplicitConst(arrayType->GetElemType());
+        }
+        for (uint32 i = 0; i < arrayType->GetSizeArrayItem(0); ++i) {
+          aggConst->AddItem(elementConst, 0);
+        }
+      }
+      return aggConst;
+    }
+    default: {
+      CHECK_FATAL(false, "Unsupported Primitive type: %d", type->GetPrimType());
+    }
+  }
+}
+
+PrimType FEUtils::GetVectorElementPrimType(PrimType vectorPrimType) {
+  switch (vectorPrimType) {
+    case PTY_v2i64:
+      return PTY_i64;
+    case PTY_v4i32:
+    case PTY_v2i32:
+      return PTY_i32;
+    case PTY_v8i16:
+    case PTY_v4i16:
+      return PTY_i16;
+    case PTY_v16i8:
+    case PTY_v8i8:
+      return PTY_i8;
+    case PTY_v2u64:
+      return PTY_u64;
+    case PTY_v4u32:
+    case PTY_v2u32:
+      return PTY_u32;
+    case PTY_v8u16:
+    case PTY_v4u16:
+      return PTY_u16;
+    case PTY_v16u8:
+    case PTY_v8u8:
+      return PTY_u8;
+    case PTY_v2f64:
+      return PTY_f64;
+    case PTY_v4f32:
+    case PTY_v2f32:
+      return PTY_f32;
+    default:
+      return PTY_unknown;
+  }
+}
+
+bool FEUtils::EndsWith(const std::string &value, const std::string &ending) {
+  if (ending.size() > value.size()) {
+    return false;
+  }
+  return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
+}
+
+// in the search, curfieldid is being decremented until it reaches 1
+MIRConst *FEUtils::TraverseToMIRConst(MIRAggConst *aggConst, const MIRStructType &structType, FieldID &fieldID) {
+  if (aggConst == nullptr || aggConst->GetConstVec().size() == 0) {
+    return nullptr;
+  }
+  uint32 fieldIdx = 0;
+  FieldPair curPair = structType.GetFields()[0];
+  MIRConst *curConst = aggConst->GetConstVec()[0];
+  while (fieldID > 1) {
+    --fieldID;
+    MIRType *curFieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(curPair.second.first);
+    MIRStructType *subStructTy = curFieldType->EmbeddedStructType();
+    if (subStructTy != nullptr && curConst->GetKind() == kConstAggConst) {
+      curConst = TraverseToMIRConst(static_cast<MIRAggConst*>(curConst), *subStructTy, fieldID);
+        if (fieldID == 1 && curConst != nullptr) {
+          return curConst;
+        }
+    }
+    ++fieldIdx;
+    if (fieldIdx == structType.GetFields().size()) {
+      return nullptr;
+    }
+    if (structType.GetKind() == kTypeUnion) {
+      curConst = aggConst->GetConstVec()[0];  // union only is one element
+    } else {
+      curConst = aggConst->GetConstVec()[fieldIdx];
+    }
+    curPair = structType.GetFields()[fieldIdx];
+  }
+  return curConst;
+}
+
+Loc FEUtils::GetSrcLocationForMIRSymbol(const MIRSymbol &symbol) {
+  return Loc(symbol.GetSrcPosition().FileNum(), symbol.GetSrcPosition().LineNum(), symbol.GetSrcPosition().Column());
+}
+
+void FEUtils::InitPrimTypeFuncNameIdxMap(std::map<PrimType, GStrIdx> &primTypeFuncNameIdxMap) {
+  primTypeFuncNameIdxMap = {
+      { PTY_u1, GetMCCStaticFieldSetBoolIdx() },
+      { PTY_i8, GetMCCStaticFieldSetByteIdx() },
+      { PTY_i16, GetMCCStaticFieldSetShortIdx() },
+      { PTY_u16, GetMCCStaticFieldSetCharIdx() },
+      { PTY_i32, GetMCCStaticFieldSetIntIdx() },
+      { PTY_i64, GetMCCStaticFieldSetLongIdx() },
+      { PTY_f32, GetMCCStaticFieldSetFloatIdx() },
+      { PTY_f64, GetMCCStaticFieldSetDoubleIdx() },
+      { PTY_ref, GetMCCStaticFieldSetObjectIdx() },
+  };
+}
+
+MIRAliasVars FEUtils::AddAlias(const GStrIdx &mplNameIdx, const MIRType *sourceType, const TypeAttrs &attrs,
+                               bool isLocal) {
+  MIRAliasVars aliasVar;
+  aliasVar.mplStrIdx = mplNameIdx;
+  aliasVar.isLocal = isLocal;
+  aliasVar.attrs = attrs;
+  if (sourceType != nullptr) {
+    aliasVar.atk = kATKType;
+    aliasVar.index = sourceType->GetTypeIndex();
+  } else {
+    CHECK_FATAL(false, "unknown source type of %s",
+                GlobalTables::GetStrTable().GetStringFromStrIdx(mplNameIdx).c_str());
+  }
+  return aliasVar;
+};
+
+void FEUtils::AddAliasInMIRScope(MIRScope &scope, const std::string &srcVarName, const MIRSymbol &symbol,
+                                 const MIRType *sourceType) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(srcVarName);
+  MIRAliasVars aliasVar = FEUtils::AddAlias(symbol.GetNameStrIdx(), sourceType, symbol.GetAttrs(), symbol.IsLocal());
+  scope.SetAliasVarMap(nameIdx, aliasVar);
+};
+
+SrcPosition FEUtils::CvtLoc2SrcPosition(const Loc &loc) {
+  SrcPosition srcPos;
+  srcPos.SetFileNum(static_cast<uint16>(loc.fileIdx));
+  srcPos.SetLineNum(loc.line);
+  srcPos.SetColumn(static_cast<uint16>(loc.column));
+  return srcPos;
+}
+// ---------- FELinkListNode ----------
+FELinkListNode::FELinkListNode()
+    : prev(nullptr), next(nullptr) {}
+
+FELinkListNode::~FELinkListNode() {
+  prev = nullptr;
+  next = nullptr;
+}
+
+void FELinkListNode::InsertBefore(FELinkListNode *ins) {
+  InsertBefore(ins, this);
+}
+
+void FELinkListNode::InsertAfter(FELinkListNode *ins) {
+  InsertAfter(ins, this);
+}
+
+void FELinkListNode::InsertBefore(FELinkListNode *ins, FELinkListNode *pos) {
+  // pos_p -- ins -- pos
+  if (pos == nullptr || pos->prev == nullptr || ins == nullptr) {
+    CHECK_FATAL(false, "invalid input");
+  }
+  FELinkListNode *posPrev = pos->prev;
+  posPrev->next = ins;
+  pos->prev = ins;
+  ins->prev = posPrev;
+  ins->next = pos;
+}
+
+void FELinkListNode::InsertAfter(FELinkListNode *ins, FELinkListNode *pos) {
+  // pos -- ins -- pos_n
+  if (pos == nullptr || pos->next == nullptr || ins == nullptr) {
+    CHECK_FATAL(false, "invalid input");
+  }
+  FELinkListNode *posNext = pos->next;
+  pos->next = ins;
+  posNext->prev = ins;
+  ins->prev = pos;
+  ins->next = posNext;
+}
+
+void FELinkListNode::SpliceNodes(FELinkListNode *head, FELinkListNode *tail, FELinkListNode *newTail) {
+  FELinkListNode *stmt = head->GetNext();
+  FELinkListNode *nextStmt = stmt;
+  do {
+    stmt = nextStmt;
+    nextStmt = stmt->GetNext();
+    newTail->InsertBefore(stmt);
+  } while (nextStmt != nullptr && nextStmt != tail);
+}
+
+uint32_t AstSwitchUtil::tempVarNo = 0;
+const char *AstSwitchUtil::cleanLabel = "clean";
+const char *AstSwitchUtil::exitLabel = "exit";
+const char *AstSwitchUtil::blockLabel = "blklbl";
+const char *AstSwitchUtil::caseLabel = "case";
+const char *AstSwitchUtil::catchLabel = "catch";
+const char *AstSwitchUtil::endehLabel = "endeh";
+
+std::string AstSwitchUtil::CreateEndOrExitLabelName() const {
+  std::string labelName = FEUtils::GetSequentialName0(blockLabel, tempVarNo);
+  ++tempVarNo;
+  return labelName;
+}
+
+void AstSwitchUtil::MarkLabelUsed(const std::string &label) {
+  labelUsed[label] = true;
+}
+
+void AstSwitchUtil::MarkLabelUnUsed(const std::string &label) {
+  labelUsed[label] = false;
+}
+
+void AstSwitchUtil::PushNestedBreakLabels(const std::string &label) {
+  nestedBreakLabels.push(label);
+}
+
+void AstSwitchUtil::PopNestedBreakLabels() {
+  nestedBreakLabels.pop();
+}
+
+void AstSwitchUtil::PushNestedCaseVectors(const std::pair<CaseVector*, LabelIdx> &caseVec) {
+  nestedCaseVectors.push(caseVec);
+}
+
+void AstSwitchUtil::PopNestedCaseVectors() {
+  nestedCaseVectors.pop();
+}
+
+bool AstSwitchUtil::CheckLabelUsed(const std::string &label) {
+  return labelUsed[label];
+}
+
+const std::pair<CaseVector*, LabelIdx> &AstSwitchUtil::GetTopOfNestedCaseVectors() const {
+  return nestedCaseVectors.top();
+}
+
+const std::string &AstSwitchUtil::GetTopOfBreakLabels() const {
+  return nestedBreakLabels.top();
+}
+
+void AstLoopUtil::PushBreak(std::string label) {
+  breakLabels.push(std::make_pair(label, false));
+}
+
+std::string AstLoopUtil::GetCurrentBreak() {
+  breakLabels.top().second = true;
+  return breakLabels.top().first;
+}
+
+bool AstLoopUtil::IsBreakLabelsEmpty() const {
+  return breakLabels.empty();
+}
+
+void AstLoopUtil::PopCurrentBreak() {
+  breakLabels.pop();
+}
+
+void AstLoopUtil::PushContinue(std::string label) {
+  continueLabels.push(std::make_pair(label, false));
+}
+
+std::string AstLoopUtil::GetCurrentContinue() {
+  continueLabels.top().second = true;
+  return continueLabels.top().first;
+}
+
+bool AstLoopUtil::IsContinueLabelsEmpty() const {
+  return continueLabels.empty();
+}
+
+void AstLoopUtil::PopCurrentContinue() {
+  continueLabels.pop();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/fe_utils_ast.cpp b/src/hir2mpl/common/src/fe_utils_ast.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c10ca129c5da7473f6b1b288e1ec002aa43f6a9b
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_utils_ast.cpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_utils_ast.h"
+#include <map>
+#include "mpl_logging.h"
+
+namespace maple {
+PrimType FEUtilAST::GetTypeFromASTTypeName(const std::string &typeName) {
+  const static std::map<std::string, PrimType> mapASTTypeNameToType = {
+      {"bool", PTY_u1},
+      {"uint8", PTY_u8},
+      {"uint16", PTY_u16},
+      {"uint32", PTY_u32},
+      {"uint64", PTY_u64},
+      {"int8", PTY_i8},
+      {"int16", PTY_i16},
+      {"int32", PTY_i32},
+      {"int64", PTY_i64},
+      {"float", PTY_f32},
+      {"double", PTY_f64},
+      {"void", PTY_void}
+  };
+  auto it = mapASTTypeNameToType.find(typeName);
+  CHECK_FATAL(it != mapASTTypeNameToType.end(), "Can not find typeName %s", typeName.c_str());
+  return it->second;
+}
+
+const std::string FEUtilAST::Type2Label(PrimType primType) {
+  switch (primType) {
+    case PTY_u1:
+      return "B";
+    case PTY_i8:
+      return "A";
+    case PTY_u8:
+      return "C";
+    case PTY_i16:
+      return "S";
+    case PTY_u16:
+      return "T";
+    case PTY_i32:
+      return "I";
+    case PTY_u32:
+      return "M";
+    case PTY_i64:
+      return "O";
+    case PTY_u64:
+      return "Q";
+    case PTY_f32:
+      return "F";
+    case PTY_f64:
+      return "D";
+    case PTY_void:
+      return "V";
+    default:
+      return "R";
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/fe_utils_java.cpp b/src/hir2mpl/common/src/fe_utils_java.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5ac307d9701c84459fba7fb92187bffcb9838601
--- /dev/null
+++ b/src/hir2mpl/common/src/fe_utils_java.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_utils_java.h"
+#include "namemangler.h"
+
+namespace maple {
+std::vector<std::string> FEUtilJava::SolveMethodSignature(const std::string &signature) {
+  std::vector<std::string> ans;
+  size_t pos1 = signature.find('(');
+  size_t pos2 = signature.find(')');
+  if (pos1 == std::string::npos || pos2 == std::string::npos || pos1 > pos2) {
+    CHECK_FATAL(false, "invalid method signature %s", signature.c_str());
+  }
+  std::string paramTypeNames = signature.substr(pos1 + 1, (pos2 - pos1) - 1);
+  std::string retTypeName = signature.substr(pos2 + 1);
+  ans.push_back(retTypeName);
+  while (paramTypeNames.length() > 0) {
+    std::string typeName = SolveParamNameInJavaFormat(paramTypeNames);
+    ans.push_back(typeName);
+    paramTypeNames = paramTypeNames.substr(typeName.length());
+  }
+  return ans;
+}
+
+std::string FEUtilJava::SolveParamNameInJavaFormat(const std::string &signature) {
+  if (signature.empty()) {
+    return "";
+  }
+  char c = signature[0];
+  switch (c) {
+    case '[':
+      return "[" + SolveParamNameInJavaFormat(signature.substr(1));
+    case 'L': {
+      size_t pos = signature.find(';');
+      CHECK_FATAL(pos != std::string::npos, "invalid type %s", signature.c_str());
+      return signature.substr(0, pos + 1);
+    }
+    default: {
+      std::string ans = "";
+      ans.push_back(c);
+      return ans;
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/feir_builder.cpp b/src/hir2mpl/common/src/feir_builder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..23a50a5a0c66ac22b425a5554f4b588913db5689
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_builder.cpp
@@ -0,0 +1,770 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_builder.h"
+#include "mpl_logging.h"
+#include "global_tables.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "fe_type_manager.h"
+#include "feir_type_helper.h"
+
+namespace maple {
+UniqueFEIRType FEIRBuilder::CreateType(PrimType basePty, const GStrIdx &baseNameIdx, uint32 dim) {
+  UniqueFEIRType type = std::make_unique<FEIRTypeDefault>(basePty, baseNameIdx, dim);
+  CHECK_NULL_FATAL(type);
+  return type;
+}
+
+UniqueFEIRType FEIRBuilder::CreateArrayElemType(const UniqueFEIRType &arrayType) {
+  std::string typeName = arrayType->GetTypeName();
+  ASSERT(typeName.length() > 1 && typeName.at(0) == 'A', "Invalid array type: %s", typeName.c_str());
+  std::unique_ptr<FEIRTypeDefault> type = std::make_unique<FEIRTypeDefault>();
+  type->LoadFromJavaTypeName(typeName.substr(1), true);
+  return type;
+}
+
+UniqueFEIRType FEIRBuilder::CreateRefType(const GStrIdx &baseNameIdx, uint32 dim) {
+  return CreateType(PTY_ref, baseNameIdx, dim);
+}
+
+UniqueFEIRType FEIRBuilder::CreateTypeByJavaName(const std::string &typeName, bool inMpl) {
+  UniqueFEIRType type = std::make_unique<FEIRTypeDefault>(PTY_ref);
+  CHECK_NULL_FATAL(type);
+  FEIRTypeDefault *ptrType = static_cast<FEIRTypeDefault*>(type.get());
+  ptrType->LoadFromJavaTypeName(typeName, inMpl);
+  return type;
+}
+
+UniqueFEIRVar FEIRBuilder::CreateVarReg(uint32 regNum, PrimType primType, bool isGlobal) {
+  UniqueFEIRVar var = std::make_unique<FEIRVarReg>(regNum, primType);
+  CHECK_NULL_FATAL(var);
+  var->SetGlobal(isGlobal);
+  return var;
+}
+
+UniqueFEIRVar FEIRBuilder::CreateVarReg(uint32 regNum, UniqueFEIRType type, bool isGlobal) {
+  UniqueFEIRVar var = std::make_unique<FEIRVarReg>(regNum, std::move(type));
+  CHECK_NULL_FATAL(var);
+  var->SetGlobal(isGlobal);
+  return var;
+}
+
+UniqueFEIRVar FEIRBuilder::CreateVarName(GStrIdx nameIdx, PrimType primType, bool isGlobal, bool withType) {
+  UniqueFEIRVar var = std::make_unique<FEIRVarName>(nameIdx, withType);
+  CHECK_NULL_FATAL(var);
+  var->GetType()->SetPrimType(primType);
+  var->SetGlobal(isGlobal);
+  return var;
+}
+
+UniqueFEIRVar FEIRBuilder::CreateVarName(const std::string &name, PrimType primType, bool isGlobal,
+                                         bool withType) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  return CreateVarName(nameIdx, primType, isGlobal, withType);
+}
+
+UniqueFEIRVar FEIRBuilder::CreateVarNameForC(GStrIdx nameIdx, MIRType &mirType, bool isGlobal, bool withType) {
+  UniqueFEIRType type = std::make_unique<FEIRTypeNative>(mirType);
+  UniqueFEIRVar var = std::make_unique<FEIRVarName>(nameIdx, std::move(type), withType);
+  var->SetGlobal(isGlobal);
+  return var;
+}
+
+UniqueFEIRVar FEIRBuilder::CreateVarNameForC(const std::string &name, MIRType &mirType, bool isGlobal, bool withType) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  return CreateVarNameForC(nameIdx, mirType, isGlobal, withType);
+}
+
+UniqueFEIRVar FEIRBuilder::CreateVarNameForC(const std::string &name, UniqueFEIRType type,
+                                             bool isGlobal, bool withType) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  UniqueFEIRVar var = std::make_unique<FEIRVarName>(nameIdx, std::move(type), withType);
+  var->SetGlobal(isGlobal);
+  return var;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprSizeOfType(UniqueFEIRType ty) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprSizeOfType>(std::move(ty));
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprDRead(UniqueFEIRVar srcVar) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprDRead>(std::move(srcVar));
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprDReadAggField(UniqueFEIRVar srcVar, FieldID fieldID, UniqueFEIRType fieldType) {
+  CHECK_FATAL(srcVar != nullptr && srcVar->GetType()->GetPrimType() == PTY_agg,
+              "var type must be struct type, %u", srcVar->GetType()->GetPrimType());
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprDRead>(std::move(srcVar));
+  expr->SetFieldID(fieldID);
+  expr->SetFieldType(std::move(fieldType));
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprIRead(UniqueFEIRType returnType, UniqueFEIRType ptrType,
+                                            UniqueFEIRExpr expr, FieldID id /* optional parameters */) {
+  UniqueFEIRExpr feirExpr = std::make_unique<FEIRExprIRead>(std::move(returnType), std::move(ptrType),
+                                                            id, std::move(expr));
+  return feirExpr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprAddrofLabel(const std::string &lbName, UniqueFEIRType exprTy) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprAddrOfLabel>(lbName, std::move(exprTy));
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprAddrofVar(UniqueFEIRVar srcVar) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprAddrofVar>(std::move(srcVar));
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprAddrofFunc(const std::string &addr) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprAddrofFunc>(addr);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprAddrofArray(UniqueFEIRType argTypeNativeArray,
+                                                  UniqueFEIRExpr argExprArray, std::string argArrayName,
+                                                  std::list<UniqueFEIRExpr> &argExprIndexs) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprAddrofArray>(std::move(argTypeNativeArray),
+                                                              std::move(argExprArray), argArrayName, argExprIndexs);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprTernary(Opcode op, UniqueFEIRType type, UniqueFEIRExpr cExpr,
+                                              UniqueFEIRExpr tExpr, UniqueFEIRExpr fExpr) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprTernary>(op, std::move(type), std::move(cExpr),
+                                                          std::move(tExpr), std::move(fExpr));
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstRefNull() {
+  return std::make_unique<FEIRExprConst>(int64{ 0 }, PTY_ref);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstPtrNull() {
+  return std::make_unique<FEIRExprConst>(int64{ 0 }, PTY_ptr);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstI8(int8 val) {
+  return std::make_unique<FEIRExprConst>(int64{ val }, PTY_i8);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstI16(int16 val) {
+  return std::make_unique<FEIRExprConst>(int64{ val }, PTY_i16);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstI32(int32 val) {
+  return std::make_unique<FEIRExprConst>(int64{ val }, PTY_i32);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstU32(uint32 val) {
+  return std::make_unique<FEIRExprConst>(val);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstI64(int64 val) {
+  return std::make_unique<FEIRExprConst>(val, PTY_i64);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstU64(uint64 val) {
+  return std::make_unique<FEIRExprConst>(val, PTY_u64);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstF32(float val) {
+  return std::make_unique<FEIRExprConst>(val);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstF64(double val) {
+  return std::make_unique<FEIRExprConst>(val);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprConstPtr(int64 val) {
+  return std::make_unique<FEIRExprConst>(val, PTY_ptr);
+}
+
+// Create a const expr of specified prime type with fixed value.
+// Note that loss of precision, byte value is only supported.
+UniqueFEIRExpr FEIRBuilder::CreateExprConstAnyScalar(PrimType primType, int64 val) {
+  switch (primType) {
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_u16:
+    case PTY_u32:
+    case PTY_u64:
+    case PTY_i8:
+    case PTY_i16:
+    case PTY_i32:
+    case PTY_i64:
+    case PTY_ptr:
+    case PTY_a64:
+      return std::make_unique<FEIRExprConst>(val, primType);
+    case PTY_f128:
+      // Not Implemented
+      CHECK_FATAL(false, "Not Implemented");
+      return nullptr;
+    case PTY_f32:
+      return CreateExprConstF32(static_cast<float>(val));
+    case PTY_f64:
+      return CreateExprConstF64(static_cast<double>(val));
+    default:
+      if (IsPrimitiveVector(primType)) {
+        return CreateExprVdupAnyVector(primType, val);
+      }
+      CHECK_FATAL(false, "unsupported const prime type");
+      return nullptr;
+  }
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprVdupAnyVector(PrimType primtype, int64 val) {
+MIRIntrinsicID intrinsic;
+  switch (primtype) {
+#define SET_VDUP(TY)                                                          \
+    case PTY_##TY:                                                            \
+      intrinsic = INTRN_vector_from_scalar_##TY;                              \
+      break;
+
+    SET_VDUP(v2i64)
+    SET_VDUP(v4i32)
+    SET_VDUP(v8i16)
+    SET_VDUP(v16i8)
+    SET_VDUP(v2u64)
+    SET_VDUP(v4u32)
+    SET_VDUP(v8u16)
+    SET_VDUP(v16u8)
+    SET_VDUP(v2f64)
+    SET_VDUP(v4f32)
+    SET_VDUP(v2i32)
+    SET_VDUP(v4i16)
+    SET_VDUP(v8i8)
+    SET_VDUP(v2u32)
+    SET_VDUP(v4u16)
+    SET_VDUP(v8u8)
+    SET_VDUP(v2f32)
+    default:
+      CHECK_FATAL(false, "Unhandled vector type in CreateExprVdupAnyVector");
+  }
+  UniqueFEIRType feType = FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPrimType(primtype));
+  UniqueFEIRExpr valExpr = CreateExprConstAnyScalar(FEUtils::GetVectorElementPrimType(primtype), val);
+  std::vector<std::unique_ptr<FEIRExpr>> argOpnds;
+  argOpnds.push_back(std::move(valExpr));
+  return std::make_unique<FEIRExprIntrinsicopForC>(std::move(feType), intrinsic, argOpnds);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprMathUnary(Opcode op, UniqueFEIRVar var0) {
+  UniqueFEIRExpr opnd0 = CreateExprDRead(std::move(var0));
+  return std::make_unique<FEIRExprUnary>(op, std::move(opnd0));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprMathUnary(Opcode op, UniqueFEIRExpr expr) {
+  return std::make_unique<FEIRExprUnary>(op, std::move(expr));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprZeroCompare(Opcode op, UniqueFEIRExpr expr) {
+  CHECK_FATAL(op == OP_ne || op == OP_eq, "Unsupported op in CreateExprZeroCompare.");
+  if (op == OP_ne && expr->GetKind() == kExprBinary && static_cast<FEIRExprBinary*>(expr.get())->IsComparative()) {
+    return expr;
+  }
+  if (expr->GetKind() == kExprConst) {
+    FEIRExprConst *constExpr = static_cast<FEIRExprConst*>(expr.get());
+    int64 val;
+    if (op == OP_ne) {
+      val = constExpr->GetValue().u64 == 0 ? 0 : 1;
+    } else {
+      val = constExpr->GetValue().u64 == 0 ? 1 : 0;
+    }
+    return std::make_unique<FEIRExprConst>(val, PTY_u1);
+  }
+  UniqueFEIRExpr zeroExpr =
+      (expr->GetPrimType() == PTY_ptr) ? CreateExprConstPtrNull() : CreateExprConstAnyScalar(expr->GetPrimType(), 0);
+  return CreateExprMathBinary(op, std::move(expr), std::move(zeroExpr));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprMathBinary(Opcode op, UniqueFEIRVar var0, UniqueFEIRVar var1) {
+  UniqueFEIRExpr opnd0 = CreateExprDRead(std::move(var0));
+  UniqueFEIRExpr opnd1 = CreateExprDRead(std::move(var1));
+  return std::make_unique<FEIRExprBinary>(op, std::move(opnd0), std::move(opnd1));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprMathBinary(Opcode op, UniqueFEIRExpr expr0, UniqueFEIRExpr expr1) {
+  return std::make_unique<FEIRExprBinary>(op, std::move(expr0), std::move(expr1));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprBinary(UniqueFEIRType exprType, Opcode op,
+                                             UniqueFEIRExpr expr0, UniqueFEIRExpr expr1) {
+  return std::make_unique<FEIRExprBinary>(std::move(exprType), op, std::move(expr0), std::move(expr1));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprBinary(Opcode op, UniqueFEIRExpr expr0, UniqueFEIRExpr expr1) {
+  return std::make_unique<FEIRExprBinary>(op, std::move(expr0), std::move(expr1));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprSExt(UniqueFEIRVar srcVar) {
+  return std::make_unique<FEIRExprExtractBits>(OP_sext, PTY_i32,
+      std::make_unique<FEIRExprDRead>(std::move(srcVar)));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprSExt(UniqueFEIRExpr srcExpr, PrimType dstType) {
+  return std::make_unique<FEIRExprExtractBits>(OP_sext, dstType, std::move(srcExpr));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprZExt(UniqueFEIRVar srcVar) {
+  return std::make_unique<FEIRExprExtractBits>(OP_zext, PTY_i32,
+      std::make_unique<FEIRExprDRead>(std::move(srcVar)));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprZExt(UniqueFEIRExpr srcExpr, PrimType dstType) {
+  return std::make_unique<FEIRExprExtractBits>(OP_zext, dstType, std::move(srcExpr));
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprCvtPrim(UniqueFEIRVar srcVar, PrimType dstType) {
+  return CreateExprCastPrim(CreateExprDRead(std::move(srcVar)), dstType);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprCvtPrim(UniqueFEIRExpr srcExpr, PrimType dstType) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprTypeCvt>(OP_cvt, std::move(srcExpr));
+  CHECK_NULL_FATAL(expr);
+  FEIRExprTypeCvt *ptrExpr = static_cast<FEIRExprTypeCvt*>(expr.get());
+  ptrExpr->GetType()->SetPrimType(dstType);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprCvtPrim(UniqueFEIRExpr srcExpr, PrimType srcType, PrimType dstType) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprTypeCvt>(OP_cvt, std::move(srcExpr));
+  CHECK_NULL_FATAL(expr);
+  FEIRExprTypeCvt *ptrExpr = static_cast<FEIRExprTypeCvt*>(expr.get());
+  ptrExpr->SetSrcPrimType(srcType);
+  ptrExpr->GetType()->SetPrimType(dstType);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprCvtPrim(Opcode argOp, UniqueFEIRExpr srcExpr, PrimType dstType) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprTypeCvt>(argOp, std::move(srcExpr));
+  CHECK_NULL_FATAL(expr);
+  FEIRExprTypeCvt *ptrExpr = static_cast<FEIRExprTypeCvt*>(expr.get());
+  ptrExpr->GetType()->SetPrimType(dstType);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprCastPrim(UniqueFEIRExpr srcExpr, PrimType dstType) {
+  // Handle the case separately for future optimization and deletion.
+  // bool u1
+  if (srcExpr->GetPrimType() == PTY_u1) {
+    if (IsPrimitiveFloat(dstType)) {
+      return CreateExprCvtPrim(std::move(srcExpr), PTY_u32, dstType);
+    }
+    return srcExpr;
+  }
+
+  if (dstType == PTY_u1) {
+    return FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(srcExpr));
+  }
+
+  // Integer to Integer : 8, 16, 32, 64 bits Integer
+  auto createExprExt = [&srcExpr, &dstType]() {
+    if (FEUtils::IsUnsignedInteger(dstType)) {
+      return CreateExprZExt(std::move(srcExpr), dstType);
+    } else {
+      return CreateExprSExt(std::move(srcExpr), dstType);
+    }
+  };
+
+  if (FEUtils::IsInteger(srcExpr->GetPrimType()) && FEUtils::IsInteger(dstType)) {
+    // avoid using OP_cvt for integer types less than 32 bits
+    if (GetPrimTypeBitSize(dstType) < 32) {
+      return createExprExt();
+    }
+
+    if (GetPrimTypeBitSize(dstType) > GetPrimTypeBitSize(srcExpr->GetPrimType())) {
+      PrimType srcRegPty = GetRegPrimType(srcExpr->GetPrimType());
+      if (srcRegPty == dstType) {
+        // avoid using OP_cvt for integer types less than 32 bits, but need to explicit transformation
+        if (GetPrimTypeBitSize(srcExpr->GetPrimType()) < 32) {
+          return createExprExt();
+        }
+        return srcExpr;
+      }
+      return CreateExprCvtPrim(std::move(srcExpr), srcRegPty, dstType);
+    }
+  }
+
+  // others
+  return CreateExprCvtPrim(std::move(srcExpr), dstType);
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprJavaNewInstance(UniqueFEIRType type) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprJavaNewInstance>(std::move(type));
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprJavaNewInstance(UniqueFEIRType type, uint32 argTypeID) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprJavaNewInstance>(std::move(type), argTypeID);
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprJavaNewInstance(UniqueFEIRType type, uint32 argTypeID, bool isRcPermanent) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprJavaNewInstance>(std::move(type), argTypeID, isRcPermanent);
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprJavaNewArray(UniqueFEIRType type, UniqueFEIRExpr exprSize) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprJavaNewArray>(std::move(type), std::move(exprSize));
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprJavaNewArray(UniqueFEIRType type, UniqueFEIRExpr exprSize, uint32 typeID) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprJavaNewArray>(std::move(type), std::move(exprSize), typeID);
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprJavaNewArray(UniqueFEIRType type, UniqueFEIRExpr exprSize, uint32 typeID,
+                                                   bool isRcPermanent) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprJavaNewArray>(
+      std::move(type), std::move(exprSize), typeID, isRcPermanent);
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+UniqueFEIRExpr FEIRBuilder::CreateExprJavaArrayLength(UniqueFEIRExpr exprArray) {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprJavaArrayLength>(std::move(exprArray));
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtDAssign(UniqueFEIRVar dstVar, UniqueFEIRExpr srcExpr, bool hasException) {
+  std::unique_ptr<FEIRStmtDAssign> stmt = std::make_unique<FEIRStmtDAssign>(std::move(dstVar), std::move(srcExpr));
+  stmt->SetHasException(hasException);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtDAssignAggField(UniqueFEIRVar dstVar, UniqueFEIRExpr srcExpr, FieldID fieldID) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtDAssign>(std::move(dstVar), std::move(srcExpr), fieldID);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtIAssign(UniqueFEIRType dstType, UniqueFEIRExpr dstExpr,
+                                              UniqueFEIRExpr srcExpr, FieldID fieldID /* optional parameters */) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtIAssign>(
+      std::move(dstType), std::move(dstExpr), std::move(srcExpr), fieldID);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtGoto(uint32 targetLabelIdx) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtGoto>(targetLabelIdx);
+  CHECK_NULL_FATAL(stmt);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtGoto(const std::string &labelName) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtGotoForC>(labelName);
+  CHECK_NULL_FATAL(stmt);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtIGoto(UniqueFEIRExpr targetExpr) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtIGoto>(std::move(targetExpr));
+  CHECK_NULL_FATAL(stmt);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtCondGoto(uint32 targetLabelIdx, Opcode op, UniqueFEIRExpr expr) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCondGoto>(op, targetLabelIdx, std::move(expr));
+  CHECK_NULL_FATAL(stmt);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtSwitch(UniqueFEIRExpr expr) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtSwitch>(std::move(expr));
+  CHECK_NULL_FATAL(stmt);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtIfWithoutElse(UniqueFEIRExpr cond, std::list<UniqueFEIRStmt> &thenStmts) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtIf>(std::move(cond), thenStmts);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtIf(UniqueFEIRExpr cond,
+                                         std::list<UniqueFEIRStmt> &thenStmts,
+                                         std::list<UniqueFEIRStmt> &elseStmts) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtIf>(std::move(cond), thenStmts, elseStmts);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtJavaConstClass(UniqueFEIRVar dstVar, UniqueFEIRType type) {
+  UniqueFEIRType dstType = FETypeManager::kFEIRTypeJavaClass->Clone();
+  dstVar->SetType(std::move(dstType));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtJavaConstClass>(std::move(dstVar), std::move(type));
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtJavaConstString(UniqueFEIRVar dstVar, const std::string &strVal) {
+  UniqueFEIRType dstType = FETypeManager::kFEIRTypeJavaString->Clone();
+  dstVar->SetType(std::move(dstType));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtJavaConstString>(std::move(dstVar), strVal,
+      0, GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(strVal));
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtJavaCheckCast(UniqueFEIRVar dstVar, UniqueFEIRVar srcVar, UniqueFEIRType type) {
+  UniqueFEIRExpr expr = CreateExprDRead(std::move(srcVar));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtJavaTypeCheck>(std::move(dstVar), std::move(expr), std::move(type),
+                                                                FEIRStmtJavaTypeCheck::CheckKind::kCheckCast);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtJavaCheckCast(UniqueFEIRVar dstVar, UniqueFEIRVar srcVar, UniqueFEIRType type,
+                                                    uint32 argTypeID) {
+  UniqueFEIRExpr expr = CreateExprDRead(std::move(srcVar));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtJavaTypeCheck>(std::move(dstVar), std::move(expr), std::move(type),
+                                                                FEIRStmtJavaTypeCheck::CheckKind::kCheckCast,
+                                                                argTypeID);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtJavaInstanceOf(UniqueFEIRVar dstVar, UniqueFEIRVar srcVar, UniqueFEIRType type) {
+  UniqueFEIRExpr expr = CreateExprDRead(std::move(srcVar));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtJavaTypeCheck>(std::move(dstVar), std::move(expr), std::move(type),
+                                                                FEIRStmtJavaTypeCheck::CheckKind::kInstanceOf);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtJavaInstanceOf(UniqueFEIRVar dstVar, UniqueFEIRVar srcVar, UniqueFEIRType type,
+                                                     uint32 argTypeID) {
+  UniqueFEIRExpr expr = CreateExprDRead(std::move(srcVar));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtJavaTypeCheck>(std::move(dstVar), std::move(expr), std::move(type),
+                                                                FEIRStmtJavaTypeCheck::CheckKind::kInstanceOf,
+                                                                argTypeID);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtJavaFillArrayData(UniqueFEIRVar srcVar, const int8 *arrayData,
+                                                        uint32 size, const std::string &arrayName) {
+  UniqueFEIRExpr expr = CreateExprDRead(std::move(srcVar));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtJavaFillArrayData>(std::move(expr), arrayData, size, arrayName);
+  return stmt;
+}
+
+std::list<UniqueFEIRStmt> FEIRBuilder::CreateStmtArrayStore(UniqueFEIRVar varElem, UniqueFEIRVar varArray,
+                                                            UniqueFEIRVar varIndex) {
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRType arrayType = varElem->GetType()->Clone();
+  (void)arrayType->ArrayIncrDim();
+  UniqueFEIRExpr exprElem = CreateExprDRead(std::move(varElem));
+  UniqueFEIRExpr exprArray = CreateExprDRead(std::move(varArray));
+  UniqueFEIRExpr exprIndex = CreateExprDRead(std::move(varIndex));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtArrayStore>(std::move(exprElem), std::move(exprArray),
+                                                             std::move(exprIndex), std::move(arrayType));
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmt(UniqueFEIRVar varElem, UniqueFEIRVar varArray,
+                                                        UniqueFEIRExpr exprIndex) {
+  UniqueFEIRType arrayType = varElem->GetType()->Clone();
+  (void)arrayType->ArrayIncrDim();
+  UniqueFEIRExpr exprElem = CreateExprDRead(std::move(varElem));
+  UniqueFEIRExpr exprArray = CreateExprDRead(std::move(varArray));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtArrayStore>(std::move(exprElem), std::move(exprArray),
+                                                             std::move(exprIndex), std::move(arrayType));
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                            UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtArrayStore>(std::move(exprElem), std::move(exprArray),
+                                                             std::move(exprIndex), std::move(arrayType));
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                            UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType,
+                                                            const std::string &argArrayName) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtArrayStore>(std::move(exprElem), std::move(exprArray),
+                                                             std::move(exprIndex), std::move(arrayType),
+                                                             argArrayName);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                            std::list<UniqueFEIRExpr> exprIndexs,
+                                                            UniqueFEIRType arrayType, const std::string &argArrayName) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtArrayStore>(std::move(exprElem), std::move(exprArray),
+                                                             exprIndexs, std::move(arrayType),
+                                                             argArrayName);
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                            UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType,
+                                                            UniqueFEIRType elemType, const std::string &argArrayName) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtArrayStore>(std::move(exprElem), std::move(exprArray),
+                                                             std::move(exprIndex), std::move(arrayType),
+                                                             std::move(elemType), argArrayName);
+  return stmt;
+}
+
+std::list<UniqueFEIRStmt> FEIRBuilder::CreateStmtArrayLoad(UniqueFEIRVar varElem, UniqueFEIRVar varArray,
+                                                           UniqueFEIRVar varIndex) {
+  std::list<UniqueFEIRStmt> ans;
+  UniqueFEIRExpr exprArray = CreateExprDRead(std::move(varArray));
+  UniqueFEIRExpr exprIndex = CreateExprDRead(std::move(varIndex));
+  UniqueFEIRType arrayType = varElem->GetType()->Clone();
+  (void)arrayType->ArrayIncrDim();
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprArrayLoad>(std::move(exprArray), std::move(exprIndex),
+                                                            std::move(arrayType));
+  UniqueFEIRStmt stmt = CreateStmtDAssign(std::move(varElem), std::move(expr), true);
+  ans.push_back(std::move(stmt));
+  return ans;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtArrayLength(UniqueFEIRVar varLength, UniqueFEIRVar varArray) {
+  UniqueFEIRExpr exprArray = CreateExprDRead(std::move(varArray));
+  UniqueFEIRExpr exprIntriOp = CreateExprJavaArrayLength(std::move(exprArray));
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtDAssign>(std::move(varLength), std::move(exprIntriOp));
+  return stmt;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtRetype(UniqueFEIRVar varDst, const UniqueFEIRVar &varSrc) {
+  // ref -> ref    : retype
+  // primitive
+  // short -> long : cvt  GetPrimTypeSize
+  // long -> short : JAVAMERGE
+  PrimType dstType = varDst->GetType()->GetPrimType();
+  PrimType srcType = varSrc->GetType()->GetPrimType();
+  uint32 srcPrmTypeSize = GetPrimTypeSize(varSrc->GetType()->GetPrimType());
+  uint32 dstPrmTypeSize = GetPrimTypeSize(dstType);
+  UniqueFEIRExpr dreadExpr = std::make_unique<FEIRExprDRead>(varSrc->Clone());
+  if (dstType == PTY_ref && srcType == PTY_ref) {
+    std::unique_ptr<FEIRType> ptrTy = FEIRTypeHelper::CreatePointerType(varDst->GetType()->Clone(), PTY_ref);
+    UniqueFEIRExpr expr = std::make_unique<FEIRExprTypeCvt>(std::move(ptrTy), OP_retype, std::move(dreadExpr));
+    return FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(expr), false);
+  } else if (srcPrmTypeSize < dstPrmTypeSize || (IsPrimitiveFloat(srcType) && IsPrimitiveInteger(dstType)) ||
+             dstType == PTY_ref) {
+    UniqueFEIRExpr expr = std::make_unique<FEIRExprTypeCvt>(varDst->GetType()->Clone(), OP_cvt, std::move(dreadExpr));
+    return FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(expr), false);
+  } else if (((IsPrimitiveInteger(dstType) || IsPrimitiveFloat(dstType)) &&
+             (IsPrimitiveInteger(srcType) || IsPrimitiveFloat(srcType)) &&
+             IsPrimitiveInteger(srcType) && IsPrimitiveFloat(dstType) &&
+             GetPrimTypeBitSize(srcType) <= GetPrimTypeBitSize(dstType)) ||
+             (IsPrimitiveInteger(srcType) && IsPrimitiveInteger(dstType))) {
+    std::vector<std::unique_ptr<FEIRExpr>> exprs;
+    exprs.emplace_back(std::move(dreadExpr));
+    UniqueFEIRExpr javaMerge = std::make_unique<FEIRExprJavaMerge>(varDst->GetType()->Clone(), exprs);
+    return std::make_unique<FEIRStmtDAssign>(std::move(varDst), std::move(javaMerge));
+  } else {
+    WARN(kLncWarn, "Unsafe convert %s to %s", GetPrimTypeName(srcType), GetPrimTypeName(dstType));
+    UniqueFEIRExpr expr = std::make_unique<FEIRExprTypeCvt>(varDst->GetType()->Clone(), OP_cvt, std::move(dreadExpr));
+    return FEIRBuilder::CreateStmtDAssign(std::move(varDst), std::move(expr), false);
+  }
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateStmtComment(const std::string &comment) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtPesudoComment>(comment);
+  return stmt;
+}
+
+UniqueFEIRExpr FEIRBuilder::ReadExprField(UniqueFEIRExpr expr, FieldID fieldID, UniqueFEIRType fieldType) {
+  FieldID baseID = expr->GetFieldID();
+  expr->SetFieldID(baseID + fieldID);
+  expr->SetFieldType(std::move(fieldType));
+  return expr;
+}
+
+UniqueFEIRStmt FEIRBuilder::AssginStmtField(const UniqueFEIRExpr &addrExpr, UniqueFEIRExpr srcExpr, FieldID fieldID) {
+  UniqueFEIRStmt stmt;
+  FieldID baseID = addrExpr->GetFieldID();
+  if (addrExpr->GetKind() == kExprDRead) {
+    stmt = CreateStmtDAssignAggField(
+        static_cast<FEIRExprDRead*>(addrExpr.get())->GetVar()->Clone(), std::move(srcExpr), baseID + fieldID);
+  } else if (addrExpr->GetKind() == kExprIRead) {
+    auto ireadExpr = static_cast<FEIRExprIRead*>(addrExpr.get());
+    stmt = CreateStmtIAssign(ireadExpr->GetClonedPtrType(), ireadExpr->GetClonedOpnd(),
+        std::move(srcExpr), baseID + fieldID);
+  } else if (addrExpr->GetKind() == kExprIAddrof) {
+    auto iaddrofExpr = static_cast<FEIRExprIAddrof*>(addrExpr.get());
+    stmt = CreateStmtIAssign(iaddrofExpr->GetClonedPtrType(), iaddrofExpr->GetClonedOpnd(),
+        std::move(srcExpr), baseID + fieldID);
+  } else {
+    CHECK_FATAL(false, "unsupported expr in AssginStmtField");
+  }
+  return stmt;
+}
+
+bool FEIRBuilder::IsZeroConstExpr(const std::unique_ptr<FEIRExpr> &expr) {
+  if (expr != nullptr && expr->GetKind() == kExprConst &&
+      static_cast<FEIRExprConst*>(expr.get())->GetValue().u64 == 0) {
+    return true;
+  }
+  return false;
+}
+
+UniqueFEIRStmt FEIRBuilder::CreateVLAStackRestore(const UniqueFEIRVar &vlaSavedStackVar) {
+  UniqueFEIRExpr dreadVar = FEIRBuilder::CreateExprDRead(vlaSavedStackVar->Clone());
+  std::unique_ptr<std::list<UniqueFEIRExpr>> argExprList = std::make_unique<std::list<UniqueFEIRExpr>>();
+  argExprList->emplace_back(std::move(dreadVar));
+  return std::make_unique<FEIRStmtIntrinsicCallAssign>(INTRN_C_stack_restore, nullptr, nullptr,
+                                                       std::move(argExprList));
+}
+
+std::string FEIRBuilder::EmitVLACleanupStmts(FEFunction &feFunction, const std::string &labelName, const Loc &loc) {
+  std::list<UniqueFEIRStmt> stmts;
+  bool isVlaCleanup = false;
+  std::string vlaLabelName = "";
+  for (const auto &scope : feFunction.GetScopeStack()) {
+    if (scope->GetVLASavedStackVar() != nullptr) {
+      if (!isVlaCleanup) {
+        // label vla_cleanup
+        vlaLabelName = FEUtils::GetSequentialName("vla_cleanup.");
+        auto vlaLabelStmt = std::make_unique<FEIRStmtLabel>(vlaLabelName);
+        (void)stmts.emplace_back(std::move(vlaLabelStmt));
+      }
+      // vla stack restore
+      isVlaCleanup = true;
+      auto stackRestoreStmt = scope->GenVLAStackRestoreStmt();
+      (void)stmts.emplace_back(std::move(stackRestoreStmt));
+    }
+    if (scope->IsControllScope()) {
+      break;
+    }
+  }
+  if (isVlaCleanup) {
+    // goto last label name
+    auto gotoStmt = FEIRBuilder::CreateStmtGoto(labelName);
+    stmts.emplace_back(std::move(gotoStmt));
+    for (const auto &stmt : stmts) {
+      stmt->SetSrcLoc(loc);
+    }
+    feFunction.AddVLACleanupStmts(stmts);
+  }
+  return vlaLabelName;
+}
+
+void FEIRBuilder::EmitVLACleanupStmts(const FEFunction &feFunction, std::list<UniqueFEIRStmt> &stmts) {
+  for (const auto &scope : feFunction.GetScopeStack()) {
+    if (scope->GetVLASavedStackVar() != nullptr) {
+      auto stackRestoreStmt = scope->GenVLAStackRestoreStmt();
+      (void)stmts.emplace_back(std::move(stackRestoreStmt));
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/feir_scope.cpp b/src/hir2mpl/common/src/feir_scope.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f21e59e2d4c84e1521d629f6f3d812ed41a90fda
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_scope.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_scope.h"
+#include "feir_builder.h"
+
+namespace maple {
+UniqueFEIRScope FEIRScope::Clone() const {
+  UniqueFEIRScope scope = std::make_unique<FEIRScope>(id, mirScope);
+  scope->SetIsControllScope(isControllScope);
+  if (vlaSavedStackVar != nullptr) {
+    scope->SetVLASavedStackVar(vlaSavedStackVar->Clone());
+  }
+  return scope;
+}
+
+UniqueFEIRStmt FEIRScope::GenVLAStackRestoreStmt() const {
+  CHECK_NULL_FATAL(vlaSavedStackVar);
+  return FEIRBuilder::CreateVLAStackRestore(vlaSavedStackVar->Clone());
+}
+}
diff --git a/src/hir2mpl/common/src/feir_stmt.cpp b/src/hir2mpl/common/src/feir_stmt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..02f3c3dfc9cab95cfc9a829201e0e66844f66f5c
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_stmt.cpp
@@ -0,0 +1,4443 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_stmt.h"
+#include "opcode_info.h"
+#include "literalstrname.h"
+#include "mir_type.h"
+#include "feir_builder.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "fe_manager.h"
+#include "hir2mpl_env.h"
+#include "feir_var_type_scatter.h"
+#include "fe_options.h"
+#include "feir_type_helper.h"
+#include "fe_utils.h"
+#include "fe_utils_java.h"
+#include "enhance_c_checker.h"
+#include "fe_macros.h"
+#ifndef ONLY_C
+#include "rc_setter.h"
+#endif
+#include "ast_util.h"
+
+namespace maple {
+std::string GetFEIRNodeKindDescription(FEIRNodeKind kindArg) {
+  switch (kindArg) {
+#define FEIR_NODE_KIND(kind, description)                            \
+    case k##kind: {                                                  \
+      return description;                                            \
+    }
+#include "feir_node_kind.def"
+#undef FEIR_NODE_KIND
+    default: {
+      CHECK_FATAL(false, "Undefined FEIRNodeKind %u", static_cast<uint32>(kindArg));
+      return "";
+    }
+  }
+}
+
+// ---------- FEIRStmt ----------
+std::list<StmtNode*> FEIRStmt::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  return std::list<StmtNode*>();
+}
+
+bool FEIRStmt::IsStmtInstImpl() const {
+  switch (kind) {
+    case kStmtAssign:
+    case kStmtNonAssign:
+    case kStmtDAssign:
+    case kStmtJavaTypeCheck:
+    case kStmtJavaConstClass:
+    case kStmtJavaConstString:
+    case kStmtJavaMultiANewArray:
+    case kStmtCallAssign:
+    case kStmtJavaDynamicCallAssign:
+    case kStmtIAssign:
+    case kStmtUseOnly:
+    case kStmtReturn:
+    case kStmtBranch:
+    case kStmtGoto:
+    case kStmtCondGoto:
+    case kStmtSwitch:
+    case kStmtArrayStore:
+    case kStmtFieldStore:
+    case kStmtFieldLoad:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool FEIRStmt::IsStmtInstComment() const {
+  return (kind == kStmtPesudoComment);
+}
+
+bool FEIRStmt::ShouldHaveLOC() const {
+  return (IsStmtInstImpl() || IsStmtInstComment());
+}
+
+BaseNode *FEIRStmt::ReplaceAddrOfNode(BaseNode *node) const {
+  switch (node->GetOpCode()) {
+    case OP_dread:
+      node->SetOpCode(OP_addrof);
+      node->SetPrimType(PTY_ptr);
+      return node;
+    case OP_iread:
+      node->SetOpCode(OP_iaddrof);
+      node->SetPrimType(PTY_ptr);
+      return node;
+    default:
+      return node;
+  }
+}
+
+std::string FEIRStmt::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+void FEIRStmt::DumpImpl(const std::string &prefix) const {
+  std::cout << prefix << "FEIRStmt" << id << "(kind=" << GetFEIRNodeKindDescription(kind) << ")\n";
+}
+
+// ---------- FEIRStmtCheckPoint ----------
+void FEIRStmtCheckPoint::Reset() {
+  predCPs.clear();
+  localUD.clear();
+  lastDef.clear();
+  cacheUD.clear();
+  defs.clear();
+  uses.clear();
+}
+
+void FEIRStmtCheckPoint::RegisterDFGNode(UniqueFEIRVar &var) {
+  CHECK_NULL_FATAL(var);
+  if (var->IsDef()) {
+    defs.push_back(&var);
+    lastDef[FEIRDFGNode(var)] = &var;
+  } else {
+    uses.push_back(&var);
+    auto it = lastDef.find(FEIRDFGNode(var));
+    if (it != lastDef.end()) {
+      CHECK_FATAL(localUD[&var].insert(it->second).second, "localUD insert failed");
+    }
+  }
+}
+
+void FEIRStmtCheckPoint::RegisterDFGNodes(const std::list<UniqueFEIRVar*> &vars) {
+  for (UniqueFEIRVar *var : vars) {
+    CHECK_NULL_FATAL(var);
+    RegisterDFGNode(*var);
+  }
+}
+
+void FEIRStmtCheckPoint::RegisterDFGNodeFromAllVisibleStmts() {
+  if (firstVisibleStmt == nullptr) {
+    return;
+  }
+  FELinkListNode *node = static_cast<FELinkListNode*>(firstVisibleStmt);
+  while (node != this) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(node);
+    stmt->RegisterDFGNodes2CheckPoint(*this);
+    node = node->GetNext();
+  }
+}
+
+void FEIRStmtCheckPoint::AddPredCheckPoint(FEIRStmtCheckPoint &stmtCheckPoint) {
+  if (predCPs.find(&stmtCheckPoint) == predCPs.end()) {
+    CHECK_FATAL(predCPs.insert(&stmtCheckPoint).second, "pred checkpoints insert error");
+  }
+}
+
+std::set<UniqueFEIRVar*> &FEIRStmtCheckPoint::CalcuDef(UniqueFEIRVar &use) {
+  CHECK_NULL_FATAL(use);
+  auto itLocal = localUD.find(&use);
+  // search localUD
+  if (itLocal != localUD.cend()) {
+    return itLocal->second;
+  }
+  // search cacheUD
+  auto itCache = cacheUD.find(FEIRDFGNode(use));
+  if (itCache != cacheUD.cend()) {
+    return itCache->second;
+  }
+  // search by DFS
+  std::set<const FEIRStmtCheckPoint*> visitSet;
+  std::set<UniqueFEIRVar*> &result = cacheUD[FEIRDFGNode(use)];
+  CalcuDefDFS(result, use, *this, visitSet);
+  if (result.size() == 0) {
+    WARN(kLncWarn, "use var %s without def", use->GetNameRaw().c_str());
+  }
+  return result;
+}
+
+void FEIRStmtCheckPoint::CalcuDefDFS(std::set<UniqueFEIRVar*> &result, const UniqueFEIRVar &use,
+                                     const FEIRStmtCheckPoint &cp,
+                                     std::set<const FEIRStmtCheckPoint*> &visitSet) const {
+  CHECK_NULL_FATAL(use);
+  if (visitSet.find(&cp) != visitSet.end()) {
+    return;
+  }
+  CHECK_FATAL(visitSet.insert(&cp).second, "visitSet insert failed");
+  auto itLast = cp.lastDef.find(FEIRDFGNode(use));
+  if (itLast != cp.lastDef.end()) {
+    CHECK_FATAL(result.insert(itLast->second).second, "def insert failed");
+    return;
+  }
+  // optimization by cacheUD
+  auto itCache = cp.cacheUD.find(FEIRDFGNode(use));
+  if (itCache != cp.cacheUD.end()) {
+    for (UniqueFEIRVar *def : itCache->second) {
+      CHECK_FATAL(result.insert(def).second, "def insert failed");
+    }
+    if (itCache->second.size() > 0) {
+      return;
+    }
+  }
+  // optimization by cacheUD (end)
+  for (const FEIRStmtCheckPoint *pred : cp.predCPs) {
+    CHECK_NULL_FATAL(pred);
+    CalcuDefDFS(result, use, *pred, visitSet);
+  }
+}
+
+std::string FEIRStmtCheckPoint::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind) << " preds: [ ";
+  for (FEIRStmtCheckPoint *pred : predCPs) {
+    ss << pred->GetID() << ", ";
+  }
+  ss << " ]";
+  return ss.str();
+}
+
+// ---------- FEIRStmtNary ----------
+FEIRStmtNary::FEIRStmtNary(Opcode opIn, std::list<std::unique_ptr<FEIRExpr>> argExprsIn)
+    : FEIRStmt(kStmtNary), op(opIn), argExprs(std::move(argExprsIn)) {}
+
+std::list<StmtNode*> FEIRStmtNary::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  StmtNode *stmt = nullptr;
+  if (argExprs.size() > 1) {
+    MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+    for (const auto &arg : argExprs) {
+      BaseNode *node = arg->GenMIRNode(mirBuilder);
+      args.push_back(node);
+    }
+    stmt = mirBuilder.CreateStmtNary(op, std::move(args));
+  } else if (argExprs.size() == 1) {
+    // ignore invalid syntax: access content pointed by void pointer
+    if (op == OP_eval && argExprs.front()->GetKind() == FEIRNodeKind::kExprIRead) {
+      FEIRExprIRead *ireadFeExpr = static_cast<FEIRExprIRead*>(argExprs.front().get());
+      MIRType *mirType = ireadFeExpr->GetClonedPtrType()->GenerateMIRTypeAuto();
+      if (ASTUtil::IsVoidPointerType(mirType->GetTypeIndex())) {
+        return stmts;
+      }
+    }
+    BaseNode *node = argExprs.front()->GenMIRNode(mirBuilder);
+    if (op == OP_eval && argExprs.front()->IsAddrof()) {
+      node = ReplaceAddrOfNode(node);  // addrof va_list
+    }
+    stmt = mirBuilder.CreateStmtNary(op, node);
+  } else {
+    CHECK_FATAL(false, "Invalid arg size for MIR StmtNary");
+  }
+  if (stmt != nullptr) {
+    stmts.emplace_back(stmt);
+  }
+  return stmts;
+}
+
+// ---------- FEStmtAssign ----------
+FEIRStmtAssign::FEIRStmtAssign(FEIRNodeKind argKind, std::unique_ptr<FEIRVar> argVar)
+    : FEIRStmt(argKind),
+      hasException(false),
+      var(std::move(argVar)) {}
+
+void FEIRStmtAssign::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  if (var != nullptr) {
+    var->SetDef(true);
+    checkPoint.RegisterDFGNode(var);
+  }
+}
+
+std::string FEIRStmtAssign::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEStmtDAssign ----------
+FEIRStmtDAssign::FEIRStmtDAssign(std::unique_ptr<FEIRVar> argVar, std::unique_ptr<FEIRExpr> argExpr, int32 argFieldID)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtDAssign, std::move(argVar)),
+      fieldID(argFieldID) {
+  SetExpr(std::move(argExpr));
+}
+
+void FEIRStmtDAssign::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  expr->RegisterDFGNodes2CheckPoint(checkPoint);
+  var->SetDef(true);
+  checkPoint.RegisterDFGNode(var);
+}
+
+bool FEIRStmtDAssign::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return expr->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+void FEIRStmtDAssign::InitTrans4AllVarsImpl() {
+  switch (expr->GetKind()) {
+    case FEIRNodeKind::kExprDRead: {
+      FEIRExprDRead *dRead = static_cast<FEIRExprDRead*>(expr.get());
+      UniqueFEIRVarTrans trans1 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, var);
+      dRead->SetTrans(std::move(trans1));
+      var->SetTrans(dRead->CreateTransDirect());
+      break;
+    }
+    case FEIRNodeKind::kExprArrayLoad: {
+      FEIRExprArrayLoad *arrayLoad = static_cast<FEIRExprArrayLoad*>(expr.get());
+      UniqueFEIRVarTrans trans1 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransArrayDimIncr, var);
+      arrayLoad->SetTrans(std::move(trans1));
+      var->SetTrans(arrayLoad->CreateTransArrayDimDecr());
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+std::list<StmtNode*> FEIRStmtDAssign::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  ASSERT(var != nullptr, "dst var is nullptr");
+  ASSERT(expr != nullptr, "src expr is nullptr");
+  MIRSymbol *dstSym = var->GenerateMIRSymbol(mirBuilder);
+  BaseNode *srcNode = expr->GenMIRNode(mirBuilder);
+  if (fieldID != 0) {
+    MIRType *mirType = var->GetType()->GenerateMIRTypeAuto();
+    CHECK_FATAL((mirType->GetKind() == MIRTypeKind::kTypeStruct || mirType->GetKind() == MIRTypeKind::kTypeUnion),
+                "If fieldID is not 0, then the variable must be a structure");
+  }
+  InsertNonnullChecking(mirBuilder, *dstSym, ans);
+  CheckNonnullArgsAndRetForFuncPtr(mirBuilder);
+  AssignBoundaryVarAndChecking(mirBuilder, ans);
+  CheckBoundaryArgsAndRetForFuncPtr(mirBuilder);
+  StmtNode *mirStmt = mirBuilder.CreateStmtDassign(*dstSym, fieldID, srcNode);
+  ans.push_back(mirStmt);
+  ENCChecker::CheckBoundaryLenFinalAssign(mirBuilder, var, fieldID, loc);
+  ENCChecker::CheckBoundaryLenFinalAddr(mirBuilder, expr, loc);
+  return ans;
+}
+
+void FEIRStmtDAssign::InsertNonnullChecking(MIRBuilder &mirBuilder, const MIRSymbol &dstSym,
+                                            std::list<StmtNode*> &ans) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic()) {
+    return;
+  }
+  MIRType *srcType = expr->GetType()->GenerateMIRTypeAuto();
+  if (fieldID == 0) {
+    ENCChecker::CheckNonnullFieldInStruct(*srcType, *dstSym.GetType(), loc);
+    if (!dstSym.GetAttr(ATTR_nonnull)) {
+      return;
+    }
+  } else {
+    FieldID tmpID = fieldID;
+    FieldPair fieldPair = static_cast<MIRStructType*>(dstSym.GetType())->TraverseToFieldRef(tmpID);
+    MIRType *dstType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+    ENCChecker::CheckNonnullFieldInStruct(*srcType, *dstType, loc);
+    if (!fieldPair.second.second.GetAttr(FLDATTR_nonnull)) {
+      return;
+    }
+  }
+  if (ENCChecker::HasNullExpr(expr)) {
+    FE_ERR(kLncErr, loc, "null assignment of nonnull pointer");
+    return;
+  }
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtAssertNonnull>(OP_assignassertnonnull, expr->Clone());
+  std::list<StmtNode*> stmts = stmt->GenMIRStmts(mirBuilder);
+  ans.splice(ans.end(), stmts);
+}
+
+std::string FEIRStmtDAssign::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  ss << " def : " << var->GetNameRaw() << ", uses : " << expr->DumpDotString() << std::endl;
+  return ss.str();
+}
+
+// ---------- FEIRStmtJavaTypeCheck ----------
+FEIRStmtJavaTypeCheck::FEIRStmtJavaTypeCheck(std::unique_ptr<FEIRVar> argVar, std::unique_ptr<FEIRExpr> argExpr,
+                                             std::unique_ptr<FEIRType> argType,
+                                             FEIRStmtJavaTypeCheck::CheckKind argCheckKind)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtJavaTypeCheck, std::move(argVar)),
+      checkKind(argCheckKind),
+      expr(std::move(argExpr)),
+      type(std::move(argType)) {}
+
+FEIRStmtJavaTypeCheck::FEIRStmtJavaTypeCheck(std::unique_ptr<FEIRVar> argVar, std::unique_ptr<FEIRExpr> argExpr,
+                                             std::unique_ptr<FEIRType> argType,
+                                             FEIRStmtJavaTypeCheck::CheckKind argCheckKind,
+                                             uint32 argTypeID)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtJavaTypeCheck, std::move(argVar)),
+      checkKind(argCheckKind),
+      expr(std::move(argExpr)),
+      type(std::move(argType)),
+      typeID(argTypeID) {}
+
+void FEIRStmtJavaTypeCheck::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  expr->RegisterDFGNodes2CheckPoint(checkPoint);
+  var->SetDef(true);
+  checkPoint.RegisterDFGNode(var);
+}
+
+bool FEIRStmtJavaTypeCheck::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return expr->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+std::list<StmtNode*> FEIRStmtJavaTypeCheck::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  CHECK_FATAL(expr->GetKind() == FEIRNodeKind::kExprDRead, "only support expr dread");
+  BaseNode *objNode = expr->GenMIRNode(mirBuilder);
+  MIRSymbol *ret = var->GenerateLocalMIRSymbol(mirBuilder);
+  MIRType *mirType = type->GenerateMIRType();
+  MIRType *mirPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType, PTY_ref);
+  MapleVector<BaseNode*> arguments(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  arguments.push_back(objNode);
+  if (FEOptions::GetInstance().IsAOT()) {
+    arguments.push_back(mirBuilder.CreateIntConst(typeID, PTY_i32));
+  }
+  if (checkKind == kCheckCast) {
+    StmtNode *callStmt = mirBuilder.CreateStmtIntrinsicCallAssigned(INTRN_JAVA_CHECK_CAST, std::move(arguments), ret,
+                                                                    mirPtrType->GetTypeIndex());
+    ans.push_back(callStmt);
+  } else {
+    BaseNode *instanceOf = mirBuilder.CreateExprIntrinsicop(INTRN_JAVA_INSTANCE_OF, OP_intrinsicopwithtype, *mirPtrType,
+                                                            std::move(arguments));
+    instanceOf->SetPrimType(PTY_u1);
+    DassignNode *stmt = mirBuilder.CreateStmtDassign(*ret, 0, instanceOf);
+    ans.push_back(stmt);
+  }
+  return ans;
+}
+
+std::string FEIRStmtJavaTypeCheck::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  ss << "uses :" << expr->DumpDotString();
+  return ss.str();
+}
+
+// ---------- FEIRStmtJavaConstClass ----------
+FEIRStmtJavaConstClass::FEIRStmtJavaConstClass(std::unique_ptr<FEIRVar> argVar, std::unique_ptr<FEIRType> argType)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtJavaConstClass, std::move(argVar)),
+      type(std::move(argType)) {}
+
+void FEIRStmtJavaConstClass::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  var->SetDef(true);
+  checkPoint.RegisterDFGNode(var);
+}
+
+std::list<StmtNode*> FEIRStmtJavaConstClass::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MIRSymbol *varSym = var->GenerateLocalMIRSymbol(mirBuilder);
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  MIRType *ptrType = type->GenerateMIRTypeAuto(kSrcLangJava);
+  BaseNode *expr =
+      mirBuilder.CreateExprIntrinsicop(INTRN_JAVA_CONST_CLASS, OP_intrinsicopwithtype, *ptrType, std::move(args));
+  StmtNode *stmt = mirBuilder.CreateStmtDassign(*varSym, 0, expr);
+  ans.push_back(stmt);
+  return ans;
+}
+
+// ---------- FEIRStmtJavaConstString ----------
+FEIRStmtJavaConstString::FEIRStmtJavaConstString(std::unique_ptr<FEIRVar> argVar, const std::string &argStrVal,
+                                                 uint32 argFileIdx, uint32 argStringID)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtJavaConstString, std::move(argVar)),
+      strVal(argStrVal),  fileIdx(argFileIdx), stringID(argStringID) {}
+
+void FEIRStmtJavaConstString::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  var->SetDef(true);
+  checkPoint.RegisterDFGNode(var);
+}
+
+std::list<StmtNode*> FEIRStmtJavaConstString::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MIRSymbol *literalVal = FEManager::GetJavaStringManager().GetLiteralVar(strVal);
+  if (literalVal == nullptr) {
+    literalVal = FEManager::GetJavaStringManager().CreateLiteralVar(mirBuilder, strVal, false);
+  }
+  MIRSymbol *literalValPtr = FEManager::GetJavaStringManager().GetLiteralPtrVar(literalVal);
+  if (literalValPtr == nullptr) {
+    std::string localStrName = kLocalStringPrefix + std::to_string(fileIdx) + "_" + std::to_string(stringID);
+    MIRType *typeString = FETypeManager::kFEIRTypeJavaString->GenerateMIRTypeAuto(kSrcLangJava);
+    MIRSymbol *symbolLocal = mirBuilder.GetOrCreateLocalDecl(localStrName.c_str(), *typeString);
+    if (!FEOptions::GetInstance().IsAOT()) {
+      MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+      args.push_back(mirBuilder.CreateExprAddrof(0, *literalVal));
+      StmtNode *stmtCreate = mirBuilder.CreateStmtCallAssigned(
+          FEManager::GetTypeManager().GetPuIdxForMCCGetOrInsertLiteral(), std::move(args), symbolLocal,
+          OP_callassigned);
+
+      ans.push_back(stmtCreate);
+    }
+    literalValPtr = symbolLocal;
+  }
+  MIRSymbol *varDst = var->GenerateLocalMIRSymbol(mirBuilder);
+  AddrofNode *node = mirBuilder.CreateDread(*literalValPtr, PTY_ptr);
+  StmtNode *stmt = mirBuilder.CreateStmtDassign(*varDst, 0, node);
+  ans.push_back(stmt);
+  return ans;
+}
+
+// ---------- FEIRStmtJavaFillArrayData ----------
+FEIRStmtJavaFillArrayData::FEIRStmtJavaFillArrayData(std::unique_ptr<FEIRExpr> arrayExprIn, const int8 *arrayDataIn,
+                                                     uint32 sizeIn, const std::string &arrayNameIn)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtJavaFillArrayData, nullptr),
+      arrayExpr(std::move(arrayExprIn)),
+      arrayData(arrayDataIn),
+      size(sizeIn),
+      arrayName(arrayNameIn) {}
+
+void FEIRStmtJavaFillArrayData::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  arrayExpr->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRStmtJavaFillArrayData::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return arrayExpr->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+std::list<StmtNode*> FEIRStmtJavaFillArrayData::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  PrimType elemPrimType = ProcessArrayElemPrimType();
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  BaseNode *nodeArray = arrayExpr->GenMIRNode(mirBuilder);
+  args.push_back(nodeArray);
+  MIRSymbol *elemDataVar = ProcessArrayElemData(mirBuilder, elemPrimType);
+  BaseNode *nodeAddrof = mirBuilder.CreateExprAddrof(0, *elemDataVar);
+  args.push_back(nodeAddrof);
+  uint64 elemPrimTypeSize = GetPrimTypeSize(elemPrimType);
+  uint64 val = elemPrimTypeSize * size;
+  BaseNode *nodebytes = mirBuilder.CreateIntConst(val, PTY_i32);
+  args.push_back(nodebytes);
+  StmtNode *stmt = mirBuilder.CreateStmtIntrinsicCallAssigned(INTRN_JAVA_ARRAY_FILL, std::move(args), nullptr);
+  ans.push_back(stmt);
+  return ans;
+}
+
+PrimType FEIRStmtJavaFillArrayData::ProcessArrayElemPrimType() const {
+  const FEIRType &arrayType = arrayExpr->GetTypeRef();
+  CHECK_FATAL(arrayType.IsArray(), "var should be array type");
+  UniqueFEIRType elemType = arrayType.Clone();
+  (void)elemType->ArrayDecrDim();
+  PrimType elemPrimType = elemType->GetPrimType();
+  return elemPrimType;
+}
+
+MIRSymbol *FEIRStmtJavaFillArrayData::ProcessArrayElemData(const MIRBuilder &mirBuilder, PrimType elemPrimType) const {
+  // specify size for const array
+  uint32 sizeIn = size;
+  MIRType *arrayTypeWithSize = GlobalTables::GetTypeTable().GetOrCreateArrayType(
+      *GlobalTables::GetTypeTable().GetPrimType(elemPrimType), 1, &sizeIn);
+  MIRSymbol *arrayVar = mirBuilder.GetOrCreateGlobalDecl(arrayName, *arrayTypeWithSize);
+  arrayVar->SetAttr(ATTR_readonly);
+  arrayVar->SetStorageClass(kScFstatic);
+  MIRAggConst *val = FillArrayElem(mirBuilder, elemPrimType, *arrayTypeWithSize, size);
+  arrayVar->SetKonst(val);
+  return arrayVar;
+}
+
+MIRAggConst *FEIRStmtJavaFillArrayData::FillArrayElem(const MIRBuilder &mirBuilder, PrimType elemPrimType,
+                                                      MIRType &arrayTypeWithSize, uint32 elemSize) const {
+  MemPool *mp = mirBuilder.GetMirModule().GetMemPool();
+  MIRModule &module = mirBuilder.GetMirModule();
+  MIRAggConst *val = module.GetMemPool()->New<MIRAggConst>(module, arrayTypeWithSize);
+  MIRConst *cst = nullptr;
+  for (uint32 i = 0; i < elemSize; ++i) {
+    MIRType &elemType = *GlobalTables::GetTypeTable().GetPrimType(elemPrimType);
+    switch (elemPrimType) {
+      case PTY_u1:
+        cst = mp->New<MIRIntConst>((reinterpret_cast<const bool*>(arrayData))[i], elemType);
+        break;
+      case PTY_i8:
+        cst = mp->New<MIRIntConst>((reinterpret_cast<const int8*>(arrayData))[i], elemType);
+        break;
+      case PTY_u8:
+        cst = mp->New<MIRIntConst>((reinterpret_cast<const uint8*>(arrayData))[i], elemType);
+        break;
+      case PTY_i16:
+        cst = mp->New<MIRIntConst>((reinterpret_cast<const int16*>(arrayData))[i], elemType);
+        break;
+      case PTY_u16:
+        cst = mp->New<MIRIntConst>((reinterpret_cast<const uint16*>(arrayData))[i], elemType);
+        break;
+      case PTY_i32:
+        cst = mp->New<MIRIntConst>((reinterpret_cast<const int32*>(arrayData))[i], elemType);
+        break;
+      case PTY_u32:
+        cst = mp->New<MIRIntConst>((reinterpret_cast<const uint32*>(arrayData))[i], elemType);
+        break;
+      case PTY_i64:
+        cst = mp->New<MIRIntConst>((reinterpret_cast<const int64*>(arrayData))[i], elemType);
+        break;
+      case PTY_u64:
+        cst = mp->New<MIRIntConst>((reinterpret_cast<const uint64*>(arrayData))[i], elemType);
+        break;
+      case PTY_f32:
+        cst = mp->New<MIRFloatConst>((reinterpret_cast<const float*>(arrayData))[i], elemType);
+        break;
+      case PTY_f64:
+        cst = mp->New<MIRDoubleConst>((reinterpret_cast<const double*>(arrayData))[i], elemType);
+        break;
+      default:
+        CHECK_FATAL(false, "Unsupported primitive type");
+        break;
+    }
+    val->PushBack(cst);
+  }
+  return val;
+}
+
+// ---------- FEIRStmtJavaMultiANewArray ----------
+UniqueFEIRVar FEIRStmtJavaMultiANewArray::varSize = nullptr;
+UniqueFEIRVar FEIRStmtJavaMultiANewArray::varClass = nullptr;
+UniqueFEIRType FEIRStmtJavaMultiANewArray::typeAnnotation = nullptr;
+FEStructMethodInfo *FEIRStmtJavaMultiANewArray::methodInfoNewInstance = nullptr;
+
+FEIRStmtJavaMultiANewArray::FEIRStmtJavaMultiANewArray(std::unique_ptr<FEIRVar> argVar,
+                                                       std::unique_ptr<FEIRType> argElemType,
+                                                       std::unique_ptr<FEIRType> argArrayType)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtJavaMultiANewArray, std::move(argVar)),
+      elemType(std::move(argElemType)),
+      arrayType(std::move(argArrayType)) {}
+
+void FEIRStmtJavaMultiANewArray::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  for (const UniqueFEIRExpr &expr : exprSizes) {
+    expr->RegisterDFGNodes2CheckPoint(checkPoint);
+  }
+  var->SetDef(true);
+  checkPoint.RegisterDFGNode(var);
+}
+
+bool FEIRStmtJavaMultiANewArray::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  for (const UniqueFEIRExpr &expr : exprSizes) {
+    success = success && expr->CalculateDefs4AllUses(checkPoint, udChain);
+  }
+  return success;
+}
+
+void FEIRStmtJavaMultiANewArray::AddVarSize(std::unique_ptr<FEIRVar> argVarSize) {
+  argVarSize->SetType(FETypeManager::kPrimFEIRTypeI32->Clone());
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(argVarSize));
+  exprSizes.push_back(std::move(expr));
+}
+
+void FEIRStmtJavaMultiANewArray::AddVarSizeRev(std::unique_ptr<FEIRVar> argVarSize) {
+  argVarSize->SetType(FETypeManager::kPrimFEIRTypeI32->Clone());
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(argVarSize));
+  exprSizes.push_front(std::move(expr));
+}
+
+std::list<StmtNode*> FEIRStmtJavaMultiANewArray::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  // size array fill
+  MapleVector<BaseNode*> argsSizeArrayFill(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (const UniqueFEIRExpr &expr : exprSizes) {
+    BaseNode *node = expr->GenMIRNode(mirBuilder);
+    argsSizeArrayFill.push_back(node);
+  }
+  MIRSymbol *symSize = GetVarSize()->GenerateLocalMIRSymbol(mirBuilder);
+  StmtNode *stmtSizeArrayFill = mirBuilder.CreateStmtIntrinsicCallAssigned(INTRN_JAVA_FILL_NEW_ARRAY,
+      std::move(argsSizeArrayFill), symSize, TyIdx(PTY_i32));
+  ans.push_back(stmtSizeArrayFill);
+  // const class
+  FEIRStmtJavaConstClass feStmtConstClass(GetVarClass()->Clone(), elemType->Clone());
+  std::list<StmtNode*> stmtsConstClass = feStmtConstClass.GenMIRStmts(mirBuilder);
+  (void)ans.insert(ans.cend(), stmtsConstClass.cbegin(), stmtsConstClass.cend());
+  // invoke newInstance
+  UniqueFEIRVar varRetCall = var->Clone();
+  varRetCall->SetType(FETypeManager::kFEIRTypeJavaObject->Clone());
+  FEIRStmtCallAssign feStmtCall(GetMethodInfoNewInstance(), OP_callassigned, varRetCall->Clone(), true);
+  feStmtCall.AddExprArg(FEIRBuilder::CreateExprDRead(GetVarClass()->Clone()));
+  feStmtCall.AddExprArg(FEIRBuilder::CreateExprDRead(GetVarSize()->Clone()));
+  std::list<StmtNode*> stmtsCall = feStmtCall.GenMIRStmts(mirBuilder);
+  (void)ans.insert(ans.end(), stmtsCall.begin(), stmtsCall.end());
+  // check cast
+  var->SetType(arrayType->Clone());
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprDRead>(std::move(varRetCall));
+  FEIRStmtJavaTypeCheck feStmtCheck(var->Clone(), std::move(expr), arrayType->Clone(),
+                                    FEIRStmtJavaTypeCheck::kCheckCast);
+  std::list<StmtNode*> stmtsCheck = feStmtCheck.GenMIRStmts(mirBuilder);
+  (void)ans.insert(ans.cend(), stmtsCheck.cbegin(), stmtsCheck.cend());
+  return ans;
+}
+
+const UniqueFEIRVar &FEIRStmtJavaMultiANewArray::GetVarSize() {
+  if (varSize != nullptr) {
+    return varSize;
+  }
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  GStrIdx varNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("tmpsize");
+  UniqueFEIRType varSizeType = FETypeManager::kPrimFEIRTypeI32->Clone();
+  (void)varSizeType->ArrayIncrDim();
+  varSize = std::make_unique<FEIRVarName>(varNameIdx, std::move(varSizeType), true);
+  return varSize;
+}
+
+const UniqueFEIRVar &FEIRStmtJavaMultiANewArray::GetVarClass() {
+  if (varClass != nullptr) {
+    return varClass;
+  }
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  GStrIdx varNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("tmpclass");
+  varClass = std::make_unique<FEIRVarName>(varNameIdx, FETypeManager::kFEIRTypeJavaClass->Clone(), true);
+  return varClass;
+}
+
+const UniqueFEIRType &FEIRStmtJavaMultiANewArray::GetTypeAnnotation() {
+  if (typeAnnotation != nullptr) {
+    return typeAnnotation;
+  }
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  typeAnnotation = std::make_unique<FEIRTypeDefault>(PTY_ref);
+  static_cast<FEIRTypeDefault*>(typeAnnotation.get())->LoadFromJavaTypeName("Ljava/lang/annotation/Annotation;", false);
+  return typeAnnotation;
+}
+
+FEStructMethodInfo &FEIRStmtJavaMultiANewArray::GetMethodInfoNewInstance() {
+  if (methodInfoNewInstance != nullptr) {
+    return *methodInfoNewInstance;
+  }
+  StructElemNameIdx structElemNameIdx(FEUtilJava::GetMultiANewArrayClassIdx(),
+                                      FEUtilJava::GetMultiANewArrayElemIdx(),
+                                      FEUtilJava::GetMultiANewArrayTypeIdx(),
+                                      FEUtilJava::GetMultiANewArrayFullIdx());
+  methodInfoNewInstance = static_cast<FEStructMethodInfo*>(FEManager::GetTypeManager().RegisterStructMethodInfo(
+      structElemNameIdx, kSrcLangJava, true));
+  return *methodInfoNewInstance;
+}
+
+std::string FEIRStmtJavaMultiANewArray::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtUseOnly ----------
+FEIRStmtUseOnly::FEIRStmtUseOnly(FEIRNodeKind argKind, Opcode argOp, std::unique_ptr<FEIRExpr> argExpr)
+    : FEIRStmt(argKind),
+      op(argOp) {
+  if (argExpr != nullptr) {
+    expr = std::move(argExpr);
+  }
+}
+
+FEIRStmtUseOnly::FEIRStmtUseOnly(Opcode argOp, std::unique_ptr<FEIRExpr> argExpr)
+    : FEIRStmtUseOnly(FEIRNodeKind::kStmtUseOnly, argOp, std::move(argExpr)) {}
+
+void FEIRStmtUseOnly::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  if (expr != nullptr) {
+    expr->RegisterDFGNodes2CheckPoint(checkPoint);
+  }
+}
+
+bool FEIRStmtUseOnly::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  if (expr != nullptr) {
+    return expr->CalculateDefs4AllUses(checkPoint, udChain);
+  }
+  return true;
+}
+
+std::list<StmtNode*> FEIRStmtUseOnly::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  ASSERT_NOT_NULL(expr);
+  if (SkipNonnullChecking(mirBuilder)) {
+    return ans;
+  }
+  BaseNode *srcNode = expr->GenMIRNode(mirBuilder);
+  StmtNode *mirStmt = mirBuilder.CreateStmtNary(op, srcNode);
+  ans.push_back(mirStmt);
+  return ans;
+}
+
+bool FEIRStmtUseOnly::SkipNonnullChecking(MIRBuilder &mirBuilder) const {
+  if (!kOpcodeInfo.IsAssertNonnull(op)) {
+    return false;
+  }
+  return ENCChecker::HasNonnullAttrInExpr(mirBuilder, expr);
+}
+
+std::string FEIRStmtUseOnly::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  if (expr != nullptr) {
+    ss << expr->DumpDotString();
+  }
+  return ss.str();
+}
+
+std::list<StmtNode*> FEIRStmtAssertNonnull::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  ASSERT_NOT_NULL(expr);
+  if (SkipNonnullChecking(mirBuilder)) {
+    return ans;
+  }
+  BaseNode *srcNode = expr->GenMIRNode(mirBuilder);
+  StmtNode *mirStmt = mirBuilder.CreateStmtAssertNonnull(op, srcNode, mirBuilder.GetCurrentFunction()->GetNameStrIdx());
+  ans.push_back(mirStmt);
+  return ans;
+}
+
+// ---------- FEIRStmtCallAssertNonnull ----------
+std::list<StmtNode*> FEIRStmtCallAssertNonnull::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  ASSERT_NOT_NULL(expr);
+  if (SkipNonnullChecking(mirBuilder)) {
+    return ans;
+  }
+  BaseNode *srcNode = expr->GenMIRNode(mirBuilder);
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(GetFuncName());
+  StmtNode *mirStmt = mirBuilder.CreateStmtCallAssertNonnull(op, srcNode, stridx, GetParamIndex(),
+                                                             mirBuilder.GetCurrentFunction()->GetNameStrIdx());
+  ans.push_back(mirStmt);
+  return ans;
+}
+
+// ---------- FEIRStmtCallAssertBoundary ----------
+std::list<StmtNode*> FEIRStmtCallAssertBoundary::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  StmtNode *stmt = nullptr;
+  auto args = ENCChecker::ReplaceBoundaryChecking(mirBuilder, this);
+  if (args.size() > 0) {
+    GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(GetFuncName());
+    stmt = mirBuilder.CreateStmtCallAssertBoundary(op, std::move(args), stridx, GetParamIndex(),
+                                                   mirBuilder.GetCurrentFunction()->GetNameStrIdx());
+  }
+  if (stmt != nullptr) {
+    stmts.emplace_back(stmt);
+  }
+  return stmts;
+}
+
+// ---------- FEIRStmtAssertBoundary ----------
+std::list<StmtNode*> FEIRStmtAssertBoundary::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  StmtNode *stmt = nullptr;
+  auto args = ENCChecker::ReplaceBoundaryChecking(mirBuilder, this);
+  if (args.size() > 0) {
+    stmt = mirBuilder.CreateStmtAssertBoundary(op, std::move(args), mirBuilder.GetCurrentFunction()->GetNameStrIdx());
+  }
+  if (stmt != nullptr) {
+    stmts.emplace_back(stmt);
+  }
+  return stmts;
+}
+
+// ---------- FEIRStmtReturn ----------
+FEIRStmtReturn::FEIRStmtReturn(std::unique_ptr<FEIRExpr> argExpr)
+    : FEIRStmtUseOnly(FEIRNodeKind::kStmtReturn, OP_return, std::move(argExpr)) {
+      isFallThru = true;
+    }
+
+std::list<StmtNode*> FEIRStmtReturn::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *mirStmt = nullptr;
+  if (expr == nullptr) {
+    mirStmt = mirBuilder.CreateStmtReturn(nullptr);
+  } else {
+    BaseNode *srcNode = expr->GenMIRNode(mirBuilder);
+    if (mirBuilder.GetCurrentFunction()->IsFirstArgReturn()) {
+      MIRSymbol *firstArgRetSym = mirBuilder.GetCurrentFunction()->GetFormal(0);
+      BaseNode *addrNode = mirBuilder.CreateDread(*firstArgRetSym, PTY_ptr);
+      StmtNode *iNode = mirBuilder.CreateStmtIassign(*firstArgRetSym->GetType(), 0, addrNode, srcNode);
+      ans.emplace_back(iNode);
+      mirStmt = mirBuilder.CreateStmtReturn(nullptr);
+    } else {
+      InsertNonnullChecking(mirBuilder, ans);
+      ENCChecker::InsertBoundaryAssignChecking(mirBuilder, ans, expr, loc);
+      ENCChecker::CheckBoundaryLenFinalAddr(mirBuilder, expr, loc);
+      mirStmt = mirBuilder.CreateStmtReturn(srcNode);
+    }
+  }
+  ans.emplace_back(mirStmt);
+  return ans;
+}
+
+void FEIRStmtReturn::InsertNonnullChecking(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || expr == nullptr) {
+    return;
+  }
+  MIRType *srcType = expr->GetType()->GenerateMIRTypeAuto();
+  MIRType *dstType = mirBuilder.GetCurrentFunction()->GetReturnType();
+  ENCChecker::CheckNonnullFieldInStruct(*srcType, *dstType, loc);
+  if (!mirBuilder.GetCurrentFunction()->GetAttrs().GetAttr(FUNCATTR_nonnull)) {
+    return;
+  }
+  if (ENCChecker::HasNullExpr(expr)) {
+    FE_ERR(kLncErr, loc, "%s return nonnull but got null pointer", mirBuilder.GetCurrentFunction()->GetName().c_str());
+    return;
+  }
+  if (expr->GetPrimType() == PTY_ptr) {
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtAssertNonnull>(OP_returnassertnonnull, expr->Clone());
+    stmt->SetSrcLoc(expr->GetLoc());
+    std::list<StmtNode*> stmts = stmt->GenMIRStmts(mirBuilder);
+    ans.splice(ans.end(), stmts);
+  }
+}
+
+// ---------- FEIRStmtGoto ----------
+FEIRStmtGoto::FEIRStmtGoto(uint32 argLabelIdx)
+    : FEIRStmt(FEIRNodeKind::kStmtGoto),
+      labelIdx(argLabelIdx),
+      stmtTarget(nullptr) {}
+
+FEIRStmtGoto::~FEIRStmtGoto() {
+  stmtTarget = nullptr;
+}
+
+std::list<StmtNode*> FEIRStmtGoto::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  CHECK_NULL_FATAL(stmtTarget);
+  GotoNode *gotoNode = mirBuilder.CreateStmtGoto(OP_goto, stmtTarget->GetMIRLabelIdx());
+  ans.push_back(gotoNode);
+  return ans;
+}
+
+std::string FEIRStmtGoto::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtGoto2 ----------
+FEIRStmtGoto2::FEIRStmtGoto2(uint32 qIdx0, uint32 qIdx1)
+    : FEIRStmt(FEIRNodeKind::kStmtGoto), labelIdxOuter(qIdx0), labelIdxInner(qIdx1) {}
+
+std::list<StmtNode*> FEIRStmtGoto2::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  GotoNode *gotoNode = mirBuilder.CreateStmtGoto(
+      OP_goto, FEIRStmtPesudoLabel2::GenMirLabelIdx(mirBuilder, labelIdxOuter, labelIdxInner));
+  stmts.push_back(gotoNode);
+  return stmts;
+}
+
+std::pair<uint32, uint32> FEIRStmtGoto2::GetLabelIdx() const {
+  return std::make_pair(labelIdxOuter, labelIdxInner);
+}
+
+FEIRStmtGotoForC::FEIRStmtGotoForC(const std::string &name)
+    : FEIRStmt(FEIRNodeKind::kStmtGoto),
+      labelName(name) {}
+
+std::list<StmtNode*> FEIRStmtGotoForC::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  GenVLACleanup(mirBuilder, ans);
+  LabelIdx label = mirBuilder.GetOrCreateMIRLabel(labelName);
+  GotoNode *gotoNode = mirBuilder.CreateStmtGoto(OP_goto, label);
+  ans.push_back(gotoNode);
+  return ans;
+}
+
+void FEIRStmtGotoForC::GenVLACleanup(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const {
+  if (vlaSvaedStackVars.empty()) {
+    return;
+  }
+  const auto &labelWithScopes = FEManager::GetCurrentFEFunction().GetLabelWithScopes();
+  const auto &iter = labelWithScopes.find(labelName);
+  if (iter == labelWithScopes.cend()) {
+    return;
+  }
+  const std::map<uint32, UniqueFEIRScope> &scopes = iter->second;
+  for (const auto &pair : vlaSvaedStackVars) {
+    // The current scope is the same, and the parent scope is also the same between goto stmt and label stmt
+    const auto &pIter = scopes.find(pair.first);
+    if (pIter != scopes.cend()) {
+      CHECK_NULL_FATAL(pIter->second);
+      const UniqueFEIRVar &vlaStackVar = pIter->second->GetVLASavedStackVar();
+      if (vlaStackVar != nullptr) {
+        break;
+      }
+    }
+    // emit vla stack restore stmt
+    auto vlaStmt = FEIRBuilder::CreateVLAStackRestore(pair.second->Clone())->GenMIRStmts(mirBuilder);
+    (void)ans.insert(ans.cend(), vlaStmt.cbegin(), vlaStmt.cend());
+  }
+}
+
+std::string FEIRStmtGotoForC::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtIGoto ----------
+FEIRStmtIGoto::FEIRStmtIGoto(UniqueFEIRExpr expr) : FEIRStmt(kStmtIGoto), targetExpr(std::move(expr)) {}
+
+std::list<StmtNode*> FEIRStmtIGoto::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  stmts.emplace_back(mirBuilder.CreateStmtUnary(OP_igoto, targetExpr->GenMIRNode(mirBuilder)));
+  return stmts;
+}
+
+// ---------- FEIRStmtCondGotoForC ----------
+std::list<StmtNode*> FEIRStmtCondGotoForC::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  LabelIdx labelID = mirBuilder.GetOrCreateMIRLabel(labelName);
+  BaseNode *condNode = expr->GenMIRNode(mirBuilder);
+  CondGotoNode *gotoNode = mirBuilder.CreateStmtCondGoto(condNode, opCode, labelID);
+  ans.push_back(gotoNode);
+  return ans;
+}
+
+std::string FEIRStmtCondGotoForC::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtCondGoto ----------
+FEIRStmtCondGoto::FEIRStmtCondGoto(Opcode argOp, uint32 argLabelIdx, UniqueFEIRExpr argExpr)
+    : FEIRStmtGoto(argLabelIdx),
+      op(argOp) {
+  kind = FEIRNodeKind::kStmtCondGoto;
+  SetExpr(std::move(argExpr));
+}
+
+void FEIRStmtCondGoto::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  expr->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRStmtCondGoto::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return expr->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+std::list<StmtNode*> FEIRStmtCondGoto::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  BaseNode *condNode = expr->GenMIRNode(mirBuilder);
+  CHECK_NULL_FATAL(stmtTarget);
+  CondGotoNode *gotoNode = mirBuilder.CreateStmtCondGoto(condNode, op, stmtTarget->GetMIRLabelIdx());
+  ans.push_back(gotoNode);
+  return ans;
+}
+
+std::string FEIRStmtCondGoto::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtCondGoto2 ----------
+FEIRStmtCondGoto2::FEIRStmtCondGoto2(Opcode argOp, uint32 qIdx0, uint32 qIdx1, UniqueFEIRExpr argExpr)
+    : FEIRStmtGoto2(qIdx0, qIdx1), op(argOp), expr(std::move(argExpr)) {}
+
+std::list<StmtNode*> FEIRStmtCondGoto2::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  BaseNode *condNode = expr->GenMIRNode(mirBuilder);
+  CondGotoNode *gotoNode = mirBuilder.CreateStmtCondGoto(
+      condNode, op, FEIRStmtPesudoLabel2::GenMirLabelIdx(mirBuilder, labelIdxOuter, labelIdxInner));
+  stmts.push_back(gotoNode);
+  return stmts;
+}
+
+// ---------- FEIRStmtSwitch ----------
+FEIRStmtSwitch::FEIRStmtSwitch(UniqueFEIRExpr argExpr)
+    : FEIRStmt(FEIRNodeKind::kStmtSwitch),
+      defaultLabelIdx(0),
+      defaultTarget(nullptr) {
+  SetExpr(std::move(argExpr));
+}
+
+FEIRStmtSwitch::~FEIRStmtSwitch() {
+  defaultTarget = nullptr;
+}
+
+void FEIRStmtSwitch::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  expr->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRStmtSwitch::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return expr->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+bool FEIRStmtSwitch::IsFallThroughImpl() const {
+  WARN(kLncWarn, "%s:%d stmt[%s] need to be lowed when building bb",
+       FEManager::GetModule().GetFileNameFromFileNum(loc.fileIdx).c_str(), loc.line,
+       GetFEIRNodeKindDescription(kind).c_str());
+  return false;
+}
+
+std::list<StmtNode*> FEIRStmtSwitch::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  CaseVector switchTable(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (const std::pair<const int32, FEIRStmtPesudoLabel*> &targetPair : mapValueTargets) {
+    CHECK_NULL_FATAL(targetPair.second);
+    switchTable.push_back(std::make_pair(targetPair.first, targetPair.second->GetMIRLabelIdx()));
+  }
+  BaseNode *exprNode = expr->GenMIRNode(mirBuilder);
+  CHECK_NULL_FATAL(defaultTarget);
+  SwitchNode *switchNode = mirBuilder.CreateStmtSwitch(exprNode, defaultTarget->GetMIRLabelIdx(), switchTable);
+  ans.push_back(switchNode);
+  return ans;
+}
+
+std::string FEIRStmtSwitch::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtSwitch2 ----------
+FEIRStmtSwitch2::FEIRStmtSwitch2(uint32 outerIdxIn, UniqueFEIRExpr argExpr)
+    : FEIRStmt(FEIRNodeKind::kStmtSwitch),
+      outerIdx(outerIdxIn),
+      defaultLabelIdx(0),
+      defaultTarget(nullptr) {
+  SetExpr(std::move(argExpr));
+}
+
+FEIRStmtSwitch2::~FEIRStmtSwitch2() {
+  defaultTarget = nullptr;
+}
+
+bool FEIRStmtSwitch2::IsFallThroughImpl() const {
+  WARN(kLncWarn, "%s:%d stmt[%s] need to be lowed when building bb",
+       FEManager::GetModule().GetFileNameFromFileNum(loc.fileIdx).c_str(), loc.line,
+       GetFEIRNodeKindDescription(kind).c_str());
+  return false;
+}
+
+std::list<StmtNode*> FEIRStmtSwitch2::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  CaseVector switchTable(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (const std::pair<const int32, uint32> &valueLabelPair : mapValueLabelIdx) {
+    switchTable.emplace_back(valueLabelPair.first,
+                             FEIRStmtPesudoLabel2::GenMirLabelIdx(mirBuilder, outerIdx, valueLabelPair.second));
+  }
+  BaseNode *exprNode = expr->GenMIRNode(mirBuilder);
+  SwitchNode *switchNode = mirBuilder.CreateStmtSwitch(exprNode,
+      FEIRStmtPesudoLabel2::GenMirLabelIdx(mirBuilder, outerIdx, defaultLabelIdx), switchTable);
+  ans.push_back(switchNode);
+  return ans;
+}
+
+std::string FEIRStmtSwitch2::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtIf ----------
+FEIRStmtIf::FEIRStmtIf(UniqueFEIRExpr argCondExpr, std::list<UniqueFEIRStmt> &argThenStmts)
+    : FEIRStmt(FEIRNodeKind::kStmtIf) {
+  SetCondExpr(std::move(argCondExpr));
+  hasElse = false;
+  SetThenStmts(argThenStmts);
+}
+
+FEIRStmtIf::FEIRStmtIf(UniqueFEIRExpr argCondExpr,
+                       std::list<UniqueFEIRStmt> &argThenStmts,
+                       std::list<UniqueFEIRStmt> &argElseStmts)
+    : FEIRStmt(FEIRNodeKind::kStmtIf) {
+  SetCondExpr(std::move(argCondExpr));
+  SetThenStmts(argThenStmts);
+  if (argElseStmts.empty()) {
+    hasElse = false;
+  } else {
+    hasElse = true;
+    SetElseStmts(argElseStmts);
+  }
+}
+
+bool FEIRStmtIf::IsFallThroughImpl() const {
+  WARN(kLncWarn, "%s:%d stmt[%s] need to be lowed when building bb",
+       FEManager::GetModule().GetFileNameFromFileNum(loc.fileIdx).c_str(), loc.line,
+       GetFEIRNodeKindDescription(kind).c_str());
+  return false;
+}
+
+std::list<StmtNode*> FEIRStmtIf::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  BaseNode *condBase = condExpr->GenMIRNode(mirBuilder);
+  IfStmtNode *stmt = nullptr;
+  if (hasElse) {
+    stmt = mirBuilder.CreateStmtIfThenElse(condBase);
+  } else {
+    stmt = mirBuilder.CreateStmtIf(condBase);
+  }
+  for (const auto &thenStmt : thenStmts) {
+    for (auto thenNode : thenStmt->GenMIRStmts(mirBuilder)) {
+      stmt->GetThenPart()->AddStatement(thenNode);
+    }
+  }
+  if (hasElse) {
+    for (const auto &elseStmt : elseStmts) {
+      for (auto elseNode : elseStmt->GenMIRStmts(mirBuilder)) {
+        stmt->GetElsePart()->AddStatement(elseNode);
+      }
+    }
+  }
+  return std::list<StmtNode*>({ stmt });
+}
+
+std::string FEIRStmtIf::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtSwitchForC ----------
+FEIRStmtSwitchForC::FEIRStmtSwitchForC(UniqueFEIRExpr argCondExpr, bool argHasDefault)
+    : FEIRStmt(FEIRNodeKind::kStmtSwitch),
+      expr(std::move(argCondExpr)),
+      hasDefault(argHasDefault) {}
+
+void FEIRStmtSwitchForC::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  expr->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRStmtSwitchForC::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return expr->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+std::list<StmtNode*> FEIRStmtSwitchForC::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MIRModule &module = mirBuilder.GetMirModule();
+  CaseVector *caseVec = module.CurFuncCodeMemPool()->New<CaseVector>(module.CurFuncCodeMemPoolAllocator()->Adapter());
+  std::string endName = AstSwitchUtil::Instance().CreateEndOrExitLabelName();
+  LabelIdx swDefaultLabel = mirBuilder.GetOrCreateMIRLabel(endName);  // end label
+  AstSwitchUtil::Instance().PushNestedCaseVectors(std::pair<CaseVector*, LabelIdx>(caseVec, swDefaultLabel));
+  BaseNode *exprNode = expr->GenMIRNode(mirBuilder);
+  BlockNode *tempBlock = module.CurFuncCodeMemPool()->New<BlockNode>();
+  CaseVector &switchTable = *AstSwitchUtil::Instance().GetTopOfNestedCaseVectors().first;
+  for (auto &sub : subStmts) {
+    for (auto mirStmt : sub->GenMIRStmts(mirBuilder)) {
+      tempBlock->AddStatement(mirStmt);
+    }
+  }
+  SwitchNode *mirSwitchStmt = mirBuilder.CreateStmtSwitch(exprNode, swDefaultLabel, switchTable);
+  ans.push_back(mirSwitchStmt);
+  for (auto &it : tempBlock->GetStmtNodes()) {
+    ans.emplace_back(&it);
+  }
+  if (!hasDefault) {
+    LabelIdx endLab = mirBuilder.GetOrCreateMIRLabel(endName);
+    StmtNode *mirSwExitLabelStmt = mirBuilder.CreateStmtLabel(endLab);
+    ans.push_back(mirSwExitLabelStmt);
+  }
+  LabelIdx exitLab = mirBuilder.GetOrCreateMIRLabel(breakLabelName);
+  StmtNode *mirSwExitLabelStmt = mirBuilder.CreateStmtLabel(exitLab);
+  ans.push_back(mirSwExitLabelStmt);
+  AstSwitchUtil::Instance().PopNestedCaseVectors();
+  return ans;
+}
+
+std::string FEIRStmtSwitchForC::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+FEIRStmtCaseForC::FEIRStmtCaseForC(int64 label)
+    : FEIRStmt(FEIRNodeKind::kStmtCaseForC),
+      lCaseLabel(label) {}
+
+void FEIRStmtCaseForC::AddCaseTag2CaseVec(int64 lCaseTag, int64 rCaseTag) {
+  auto pLabel = std::make_unique<FEIRStmtPesudoLabel>(lCaseLabel);
+  for (int64 csTag = lCaseTag; csTag <= rCaseTag; ++csTag) {
+    pesudoLabelMap.insert(std::make_pair(csTag, std::move(pLabel)));
+  }
+}
+
+std::list<StmtNode*> FEIRStmtCaseForC::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  CaseVector &caseVec = *AstSwitchUtil::Instance().GetTopOfNestedCaseVectors().first;
+  StmtNode *mirLabelStmt = nullptr;
+  for (auto &targetPair : GetPesudoLabelMap()) {
+    targetPair.second->GenerateLabelIdx(mirBuilder);
+    caseVec.push_back(std::make_pair(targetPair.first, targetPair.second->GetMIRLabelIdx()));
+  }
+  for (auto it : caseVec) {
+    if (lCaseLabel == it.first) {
+      mirLabelStmt = mirBuilder.CreateStmtLabel(it.second);
+      ans.emplace_back(mirLabelStmt);
+    }
+  }
+  for (auto &sub : subStmts) {
+    ans.splice(ans.end(), sub.get()->GenMIRStmts(mirBuilder));
+  }
+  return ans;
+}
+
+std::string FEIRStmtCaseForC::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+FEIRStmtDefaultForC::FEIRStmtDefaultForC()
+    : FEIRStmt(FEIRNodeKind::kStmtDefaultForC) {}
+
+std::list<StmtNode*> FEIRStmtDefaultForC::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *mirLabelStmt = mirBuilder.CreateStmtLabel(AstSwitchUtil::Instance().GetTopOfNestedCaseVectors().second);
+  ans.emplace_back(mirLabelStmt);
+  for (auto &sub : subStmts) {
+    ans.splice(ans.end(), sub.get()->GenMIRStmts(mirBuilder));
+  }
+  return ans;
+}
+
+std::string FEIRStmtDefaultForC::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtArrayStore ----------
+FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray,
+                                       UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeArray)
+    : FEIRStmt(FEIRNodeKind::kStmtArrayStore),
+      exprElem(std::move(argExprElem)),
+      exprArray(std::move(argExprArray)),
+      exprIndex(std::move(argExprIndex)),
+      typeArray(std::move(argTypeArray)) {}
+
+FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray,
+                                       UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeArray,
+                                       const std::string &argArrayName)
+    : FEIRStmt(FEIRNodeKind::kStmtArrayStore),
+      exprElem(std::move(argExprElem)),
+      exprArray(std::move(argExprArray)),
+      exprIndex(std::move(argExprIndex)),
+      typeArray(std::move(argTypeArray)),
+      arrayName(argArrayName) {}
+
+FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray,
+                                       UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeArray,
+                                       UniqueFEIRType argTypeElem, const std::string &argArrayName)
+    : FEIRStmt(FEIRNodeKind::kStmtArrayStore),
+      exprElem(std::move(argExprElem)),
+      exprArray(std::move(argExprArray)),
+      exprIndex(std::move(argExprIndex)),
+      typeArray(std::move(argTypeArray)),
+      typeElem(std::move(argTypeElem)),
+      arrayName(argArrayName) {}
+
+FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray,
+                                       std::list<UniqueFEIRExpr> &argExprIndexs, UniqueFEIRType argTypeArray,
+                                       const std::string &argArrayName)
+    : FEIRStmt(FEIRNodeKind::kStmtArrayStore),
+      exprElem(std::move(argExprElem)),
+      exprArray(std::move(argExprArray)),
+      typeArray(std::move(argTypeArray)),
+      arrayName(argArrayName) {
+  SetIndexsExprs(argExprIndexs);
+}
+
+FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray,
+                                       std::list<UniqueFEIRExpr> &argExprIndexs, UniqueFEIRType argTypeArray,
+                                       UniqueFEIRExpr argExprStruct, UniqueFEIRType argTypeStruct,
+                                       const std::string &argArrayName)
+    : FEIRStmt(FEIRNodeKind::kStmtArrayStore),
+      exprElem(std::move(argExprElem)),
+      exprArray(std::move(argExprArray)),
+      typeArray(std::move(argTypeArray)),
+      exprStruct(std::move(argExprStruct)),
+      typeStruct(std::move(argTypeStruct)),
+      arrayName(argArrayName) {
+  SetIndexsExprs(argExprIndexs);
+}
+
+void FEIRStmtArrayStore::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  exprArray->RegisterDFGNodes2CheckPoint(checkPoint);
+  exprIndex->RegisterDFGNodes2CheckPoint(checkPoint);
+  exprElem->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRStmtArrayStore::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  success = success && exprArray->CalculateDefs4AllUses(checkPoint, udChain);
+  success = success && exprIndex->CalculateDefs4AllUses(checkPoint, udChain);
+  success = success && exprElem->CalculateDefs4AllUses(checkPoint, udChain);
+  return success;
+}
+
+void FEIRStmtArrayStore::InitTrans4AllVarsImpl() {
+  CHECK_FATAL(exprArray->GetKind() == kExprDRead, "only support dread expr for exprArray");
+  CHECK_FATAL(exprIndex->GetKind() == kExprDRead, "only support dread expr for exprIndex");
+  CHECK_FATAL(exprElem->GetKind() == kExprDRead, "only support dread expr for exprElem");
+  FEIRExprDRead *exprArrayDRead = static_cast<FEIRExprDRead*>(exprArray.get());
+  FEIRExprDRead *exprElemDRead = static_cast<FEIRExprDRead*>(exprElem.get());
+  exprArrayDRead->SetTrans(exprElemDRead->CreateTransArrayDimIncr());
+  exprElemDRead->SetTrans(exprArrayDRead->CreateTransArrayDimDecr());
+}
+
+std::list<StmtNode*> FEIRStmtArrayStore::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  CHECK_FATAL(((exprIndex == nullptr) && (exprIndexs.size() != 0))||
+              (exprIndex->GetKind() == kExprDRead) ||
+              (exprIndex->GetKind() == kExprConst), "only support dread/const expr for exprIndex");
+  MIRType *ptrMIRArrayType = typeArray->GenerateMIRType(false);
+  BaseNode *arrayExpr = nullptr;
+  MIRType *mIRElemType = nullptr;
+  if (FEManager::GetModule().GetSrcLang() == kSrcLangC) {
+    GenMIRStmtsImplForCPart(mirBuilder, ptrMIRArrayType, &mIRElemType, &arrayExpr);
+  } else {
+    BaseNode *addrBase = exprArray->GenMIRNode(mirBuilder);
+    BaseNode *indexBn = exprIndex->GenMIRNode(mirBuilder);
+    arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, addrBase, indexBn);
+    UniqueFEIRType typeArrayCloned = typeArray->Clone();
+    if ((exprIndex->GetKind() != kExprConst) || (!FEOptions::GetInstance().IsAOT())) {
+      (void)typeArrayCloned->ArrayDecrDim();
+    }
+    mIRElemType = typeArrayCloned->GenerateMIRType(true);
+  }
+  BaseNode *elemBn = exprElem->GenMIRNode(mirBuilder);
+  IassignNode *stmt = nullptr;
+  if ((FEManager::GetModule().GetSrcLang() == kSrcLangC) ||
+      (exprIndex->GetKind() != kExprConst) || (!FEOptions::GetInstance().IsAOT())) {
+    MIRType *ptrMIRElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mIRElemType, PTY_ptr);
+    stmt = mirBuilder.CreateStmtIassign(*ptrMIRElemType, 0, arrayExpr, elemBn);
+  } else {
+    reinterpret_cast<ArrayNode*>(arrayExpr)->SetBoundsCheck(false);
+    stmt = mirBuilder.CreateStmtIassign(*mIRElemType, 0, arrayExpr, elemBn);
+  }
+  return std::list<StmtNode*>({ stmt });
+}
+
+void FEIRStmtArrayStore::GenMIRStmtsImplForCPart(MIRBuilder &mirBuilder, MIRType *ptrMIRArrayType,
+                                                 MIRType **mIRElemType, BaseNode **arrayExpr) const {
+  if (typeElem == nullptr) {
+    typeElem = std::make_unique<FEIRTypeNative>(*static_cast<MIRArrayType*>(ptrMIRArrayType)->GetElemType());
+  }
+  FieldID fieldID = 0;
+  // array in struct
+  if (typeStruct != nullptr) {
+    fieldID = static_cast<FEIRExprDRead*>(exprArray.get())->GetFieldID();
+    MIRType *ptrMIRStructType = typeStruct->GenerateMIRType(false);
+    MIRStructType* mirStructType = static_cast<MIRStructType*>(ptrMIRStructType);
+    // for no init, create the struct symbol
+    (void)mirBuilder.GetOrCreateLocalDecl(arrayName, *mirStructType);
+  }
+
+  *mIRElemType = typeElem->GenerateMIRType(true);
+  BaseNode *arrayAddrOfExpr = nullptr;
+  MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateMIRSymbol(mirBuilder);
+  auto mirtype = mirSymbol->GetType();
+  if (mirtype->GetKind() == kTypePointer) {
+    arrayAddrOfExpr = exprArray->GenMIRNode(mirBuilder);
+  } else {
+    arrayAddrOfExpr = mirBuilder.CreateExprAddrof(fieldID, *mirSymbol);
+  }
+  if (exprIndex == nullptr) {
+    std::vector<BaseNode*> nds;
+    nds.push_back(arrayAddrOfExpr);
+    for (auto &e : exprIndexs) {
+      BaseNode *no = e->GenMIRNode(mirBuilder);
+      nds.push_back(no);
+    }
+    *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, nds);
+  } else {
+    BaseNode *indexBn = exprIndex->GenMIRNode(mirBuilder);
+    *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, arrayAddrOfExpr, indexBn);
+  }
+}
+
+std::string FEIRStmtArrayStore::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  ss << " def : {";
+  ss << " exprArray : " << exprArray->DumpDotString();
+  ss << " exprIndex : " << exprIndex->DumpDotString();
+  ss << " exprElem kind : " << GetFEIRNodeKindDescription(exprElem->GetKind()) << " " << exprElem->DumpDotString();
+  ss << " } ";
+  return ss.str();
+}
+
+// ---------- FEIRStmtFieldStore ----------
+FEIRStmtFieldStore::FEIRStmtFieldStore(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField,
+                                       FEStructFieldInfo &argFieldInfo, bool argIsStatic)
+    : FEIRStmt(FEIRNodeKind::kStmtFieldStore),
+      varObj(std::move(argVarObj)),
+      varField(std::move(argVarField)),
+      fieldInfo(argFieldInfo),
+      isStatic(argIsStatic) {}
+FEIRStmtFieldStore::FEIRStmtFieldStore(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField,
+                                       FEStructFieldInfo &argFieldInfo, bool argIsStatic, int32 argDexFileHashCode)
+    : FEIRStmt(FEIRNodeKind::kStmtFieldStore),
+      varObj(std::move(argVarObj)),
+      varField(std::move(argVarField)),
+      fieldInfo(argFieldInfo),
+      isStatic(argIsStatic),
+      dexFileHashCode(argDexFileHashCode) {}
+
+void FEIRStmtFieldStore::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  if (isStatic) {
+    RegisterDFGNodes2CheckPointForStatic(checkPoint);
+  } else {
+    RegisterDFGNodes2CheckPointForNonStatic(checkPoint);
+  }
+}
+
+void FEIRStmtFieldStore::RegisterDFGNodes2CheckPointForStatic(FEIRStmtCheckPoint &checkPoint) {
+  checkPoint.RegisterDFGNode(varField);
+}
+
+void FEIRStmtFieldStore::RegisterDFGNodes2CheckPointForNonStatic(FEIRStmtCheckPoint &checkPoint) {
+  checkPoint.RegisterDFGNode(varObj);
+  checkPoint.RegisterDFGNode(varField);
+}
+
+bool FEIRStmtFieldStore::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  if (isStatic) {
+    return CalculateDefs4AllUsesForStatic(checkPoint, udChain);
+  } else {
+    return CalculateDefs4AllUsesForNonStatic(checkPoint, udChain);
+  }
+}
+
+bool FEIRStmtFieldStore::CalculateDefs4AllUsesForStatic(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  std::set<UniqueFEIRVar*> &defs4VarField = checkPoint.CalcuDef(varField);
+  (void)udChain.insert(std::make_pair(&varField, defs4VarField));
+  return (defs4VarField.size() > 0);
+}
+
+bool FEIRStmtFieldStore::CalculateDefs4AllUsesForNonStatic(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  std::set<UniqueFEIRVar*> &defs4VarObj = checkPoint.CalcuDef(varObj);
+  (void)udChain.insert(std::make_pair(&varObj, defs4VarObj));
+  std::set<UniqueFEIRVar*> &defs4VarField = checkPoint.CalcuDef(varField);
+  (void)udChain.insert(std::make_pair(&varField, defs4VarField));
+  return ((defs4VarObj.size() > 0) && (defs4VarField.size() > 0));
+}
+
+std::list<StmtNode*> FEIRStmtFieldStore::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  // prepare and find root
+  fieldInfo.Prepare(mirBuilder, isStatic);
+  if (isStatic) {
+    return GenMIRStmtsImplForStatic(mirBuilder);
+  } else {
+    return GenMIRStmtsImplForNonStatic(mirBuilder);
+  }
+}
+
+bool FEIRStmtFieldStore::NeedMCCForStatic(uint32 &typeID) const {
+  // check type first
+  const std::string &actualContainerName = fieldInfo.GetActualContainerName();
+  typeID = FEManager::GetTypeManager().GetTypeIDFromMplClassName(actualContainerName, dexFileHashCode);
+  if (typeID == UINT32_MAX) {
+    return true;
+  }
+
+  // check type field second
+  const std::string &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldInfo.GetFieldNameIdx());
+  MIRStructType *currStructType = FEManager::GetTypeManager().GetStructTypeFromName(actualContainerName);
+  const auto &fields = currStructType->GetStaticFields();
+  for (auto f : fields) {
+    const std::string &fieldNameIt = GlobalTables::GetStrTable().GetStringFromStrIdx(f.first);
+    if (fieldName.compare(fieldNameIt) == 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+std::list<StmtNode*> FEIRStmtFieldStore::GenMIRStmtsImplForStatic(MIRBuilder &mirBuilder) const {
+  CHECK_FATAL(fieldInfo.GetFieldNameIdx() != 0, "invalid name idx");
+  std::list<StmtNode*> mirStmts;
+  UniqueFEIRVar varTarget = std::make_unique<FEIRVarName>(fieldInfo.GetFieldNameIdx(), fieldInfo.GetType()->Clone());
+  varTarget->SetGlobal(true);
+  MIRSymbol *symSrc = varTarget->GenerateGlobalMIRSymbol(mirBuilder);
+  UniqueFEIRExpr exprDRead = FEIRBuilder::CreateExprDRead(varField->Clone());
+  UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(std::move(varTarget), std::move(exprDRead));
+  mirStmts = stmtDAssign->GenMIRStmts(mirBuilder);
+  if (!FEOptions::GetInstance().IsNoBarrier() && fieldInfo.IsVolatile()) {
+    StmtNode *barrier = mirBuilder.GetMirModule().CurFuncCodeMemPool()->New<StmtNode>(OP_membarrelease);
+    mirStmts.emplace_front(barrier);
+    barrier = mirBuilder.GetMirModule().CurFuncCodeMemPool()->New<StmtNode>(OP_membarstoreload);
+    mirStmts.emplace_back(barrier);
+  }
+  TyIdx containerTyIdx = fieldInfo.GetActualContainerType()->GenerateMIRType()->GetTypeIndex();
+  if (!mirBuilder.GetCurrentFunction()->IsClinit() ||
+      mirBuilder.GetCurrentFunction()->GetClassTyIdx() != containerTyIdx) {
+    MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+    uint32 typeID = UINT32_MAX;
+    bool needMCCForStatic = false;
+    if (FEOptions::GetInstance().IsAOT()) {
+      needMCCForStatic = NeedMCCForStatic(typeID);
+      if (!needMCCForStatic) {
+        BaseNode *argNumExpr = mirBuilder.CreateIntConst(typeID, PTY_i32);
+        args.push_back(argNumExpr);
+      } else {
+        const auto &pt = fieldInfo.GetType()->GetPrimType();
+        std::map<PrimType, GStrIdx> primTypeFuncNameIdxMap;
+        FEUtils::InitPrimTypeFuncNameIdxMap(primTypeFuncNameIdxMap);
+        const auto &itorFunc = primTypeFuncNameIdxMap.find(pt);
+        CHECK_FATAL(itorFunc != primTypeFuncNameIdxMap.cend(), "java type not support %d", pt);
+        args.push_back(mirBuilder.CreateIntConst(fieldInfo.GetFieldID(), PTY_i32));
+        BaseNode *nodeSrc = mirBuilder.CreateExprDread(*symSrc);
+        args.push_back(nodeSrc);
+        MIRSymbol *retVarSym = nullptr;
+        retVarSym = varField->GenerateLocalMIRSymbol(mirBuilder);
+        StmtNode *stmtMCC = mirBuilder.CreateStmtCallAssigned(
+            FEManager::GetTypeManager().GetMCCFunction(itorFunc->second)->GetPuidx(), MapleVector<BaseNode*>(args),
+            retVarSym,
+            OP_callassigned);
+        mirStmts.clear();
+        mirStmts.emplace_front(stmtMCC);
+      }
+    }
+    if (!needMCCForStatic) {
+      StmtNode *stmtClinitCheck = mirBuilder.CreateStmtIntrinsicCall(INTRN_JAVA_CLINIT_CHECK, std::move(args),
+          containerTyIdx);
+      mirStmts.emplace_front(stmtClinitCheck);
+    }
+  }
+  return mirStmts;
+}
+
+std::list<StmtNode*> FEIRStmtFieldStore::GenMIRStmtsImplForNonStatic(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  FieldID fieldID = fieldInfo.GetFieldID();
+  ASSERT(fieldID != 0, "invalid field ID");
+  MIRStructType *structType = FEManager::GetTypeManager().GetStructTypeFromName(fieldInfo.GetStructName());
+  CHECK_NULL_FATAL(structType);
+  MIRType *ptrStructType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*structType, PTY_ref);
+  UniqueFEIRExpr exprDReadObj = FEIRBuilder::CreateExprDRead(varObj->Clone());
+  UniqueFEIRExpr exprDReadField = FEIRBuilder::CreateExprDRead(varField->Clone());
+  BaseNode *nodeObj = exprDReadObj->GenMIRNode(mirBuilder);
+  BaseNode *nodeField = exprDReadField->GenMIRNode(mirBuilder);
+  StmtNode *stmt = mirBuilder.CreateStmtIassign(*ptrStructType, fieldID, nodeObj, nodeField);
+#ifndef ONLY_C
+  if (FEOptions::GetInstance().IsRC()) {
+    bc::RCSetter::GetRCSetter().CollectInputStmtField(stmt, fieldInfo.GetElemNameIdx());
+  }
+#endif
+  ans.emplace_back(stmt);
+  if (!FEOptions::GetInstance().IsNoBarrier() && fieldInfo.IsVolatile()) {
+    StmtNode *barrier = mirBuilder.GetMirModule().CurFuncCodeMemPool()->New<StmtNode>(OP_membarrelease);
+    ans.emplace_front(barrier);
+    barrier = mirBuilder.GetMirModule().CurFuncCodeMemPool()->New<StmtNode>(OP_membarstoreload);
+    ans.emplace_back(barrier);
+  }
+  return ans;
+}
+
+std::string FEIRStmtFieldStore::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtFieldLoad ----------
+FEIRStmtFieldLoad::FEIRStmtFieldLoad(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField,
+                                     FEStructFieldInfo &argFieldInfo, bool argIsStatic)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtFieldLoad, std::move(argVarField)),
+      varObj(std::move(argVarObj)),
+      fieldInfo(argFieldInfo),
+      isStatic(argIsStatic) {}
+
+FEIRStmtFieldLoad::FEIRStmtFieldLoad(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField,
+                                     FEStructFieldInfo &argFieldInfo,
+                                     bool argIsStatic, int32 argDexFileHashCode)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtFieldLoad, std::move(argVarField)),
+      varObj(std::move(argVarObj)),
+      fieldInfo(argFieldInfo),
+      isStatic(argIsStatic),
+      dexFileHashCode(argDexFileHashCode) {}
+
+void FEIRStmtFieldLoad::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  if (isStatic) {
+    RegisterDFGNodes2CheckPointForStatic(checkPoint);
+  } else {
+    RegisterDFGNodes2CheckPointForNonStatic(checkPoint);
+  }
+}
+
+bool FEIRStmtFieldLoad::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  if (!isStatic) {
+    std::set<UniqueFEIRVar*> &defs = checkPoint.CalcuDef(varObj);
+    (void)udChain.insert(std::make_pair(&varObj, defs));
+    if (defs.size() == 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void FEIRStmtFieldLoad::RegisterDFGNodes2CheckPointForStatic(FEIRStmtCheckPoint &checkPoint) {
+  var->SetDef(true);
+  checkPoint.RegisterDFGNode(var);
+}
+
+void FEIRStmtFieldLoad::RegisterDFGNodes2CheckPointForNonStatic(FEIRStmtCheckPoint &checkPoint) {
+  checkPoint.RegisterDFGNode(varObj);
+  var->SetDef(true);
+  checkPoint.RegisterDFGNode(var);
+}
+
+std::list<StmtNode*> FEIRStmtFieldLoad::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  // prepare and find root
+  fieldInfo.Prepare(mirBuilder, isStatic);
+  if (isStatic) {
+    return GenMIRStmtsImplForStatic(mirBuilder);
+  } else {
+    return GenMIRStmtsImplForNonStatic(mirBuilder);
+  }
+}
+
+bool FEIRStmtFieldLoad::NeedMCCForStatic(uint32 &typeID) const {
+  // check type first
+  const std::string &actualContainerName = fieldInfo.GetActualContainerName();
+  typeID = FEManager::GetTypeManager().GetTypeIDFromMplClassName(actualContainerName, dexFileHashCode);
+  if (typeID == UINT32_MAX) {
+    return true;
+  }
+
+  // check type field second
+  const std::string &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldInfo.GetFieldNameIdx());
+  MIRStructType *currStructType = FEManager::GetTypeManager().GetStructTypeFromName(actualContainerName);
+  if (currStructType == nullptr) {
+    return true;
+  }
+  const auto &fields = currStructType->GetStaticFields();
+  if (fields.size() == 0) {
+    return true;
+  }
+  for (auto f : fields) {
+    const std::string &fieldNameIt = GlobalTables::GetStrTable().GetStringFromStrIdx(f.first);
+    if (fieldName.compare(fieldNameIt) == 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+std::list<StmtNode*> FEIRStmtFieldLoad::GenMIRStmtsImplForStatic(MIRBuilder &mirBuilder) const {
+  UniqueFEIRVar varTarget = std::make_unique<FEIRVarName>(fieldInfo.GetFieldNameIdx(), fieldInfo.GetType()->Clone());
+  varTarget->SetGlobal(true);
+  UniqueFEIRExpr exprDRead = FEIRBuilder::CreateExprDRead(std::move(varTarget));
+  UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(var->Clone(), std::move(exprDRead));
+  std::list<StmtNode*> mirStmts = stmtDAssign->GenMIRStmts(mirBuilder);
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+
+  bool needMCCForStatic = false;
+  if (FEOptions::GetInstance().IsAOT()) {
+    uint32 typeID = UINT32_MAX;
+    needMCCForStatic = NeedMCCForStatic(typeID);
+    if (!needMCCForStatic) {
+      BaseNode *argNumExpr = mirBuilder.CreateIntConst(typeID, PTY_i32);
+      args.push_back(argNumExpr);
+    } else {
+      auto pt = fieldInfo.GetType()->GetPrimType();
+      std::map<PrimType, GStrIdx> primTypeFuncNameIdxMap;
+      FEUtils::InitPrimTypeFuncNameIdxMap(primTypeFuncNameIdxMap);
+      auto itorFunc = primTypeFuncNameIdxMap.find(pt);
+      CHECK_FATAL(itorFunc != primTypeFuncNameIdxMap.cend(), "java type not support %d", pt);
+      args.push_back(mirBuilder.CreateIntConst(fieldInfo.GetFieldID(), PTY_i32));
+      MIRSymbol *retVarSym = nullptr;
+      retVarSym = var->GenerateLocalMIRSymbol(mirBuilder);
+      StmtNode *stmtMCC = mirBuilder.CreateStmtCallAssigned(
+          FEManager::GetTypeManager().GetMCCFunction(itorFunc->second)->GetPuidx(), MapleVector<BaseNode*>(args),
+          retVarSym, OP_callassigned);
+      mirStmts.clear();
+      mirStmts.emplace_front(stmtMCC);
+    }
+  }
+  if (!needMCCForStatic) {
+    TyIdx containerTyIdx = fieldInfo.GetActualContainerType()->GenerateMIRType()->GetTypeIndex();
+    if (!mirBuilder.GetCurrentFunction()->IsClinit() ||
+        mirBuilder.GetCurrentFunction()->GetClassTyIdx() != containerTyIdx) {
+      StmtNode *stmtClinitCheck = mirBuilder.CreateStmtIntrinsicCall(INTRN_JAVA_CLINIT_CHECK, std::move(args),
+          containerTyIdx);
+      mirStmts.emplace_front(stmtClinitCheck);
+    }
+  }
+  if (!FEOptions::GetInstance().IsNoBarrier() && fieldInfo.IsVolatile()) {
+    StmtNode *barrier = mirBuilder.GetMirModule().CurFuncCodeMemPool()->New<StmtNode>(OP_membaracquire);
+    mirStmts.emplace_back(barrier);
+  }
+  return mirStmts;
+}
+
+std::list<StmtNode*> FEIRStmtFieldLoad::GenMIRStmtsImplForNonStatic(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  FieldID fieldID = fieldInfo.GetFieldID();
+  ASSERT(fieldID != 0, "invalid field ID");
+  MIRStructType *structType = FEManager::GetTypeManager().GetStructTypeFromName(fieldInfo.GetStructName());
+  CHECK_NULL_FATAL(structType);
+  MIRType *ptrStructType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*structType, PTY_ref);
+  MIRType *fieldType = fieldInfo.GetType()->GenerateMIRTypeAuto(fieldInfo.GetSrcLang());
+  UniqueFEIRExpr exprDReadObj = FEIRBuilder::CreateExprDRead(varObj->Clone());
+  BaseNode *nodeObj = exprDReadObj->GenMIRNode(mirBuilder);
+  BaseNode *nodeVal = mirBuilder.CreateExprIread(*fieldType, *ptrStructType, fieldID, nodeObj);
+  MIRSymbol *valRet = var->GenerateLocalMIRSymbol(mirBuilder);
+  StmtNode *stmt = mirBuilder.CreateStmtDassign(*valRet, 0, nodeVal);
+  ans.emplace_back(stmt);
+  if (!FEOptions::GetInstance().IsNoBarrier() && fieldInfo.IsVolatile()) {
+    StmtNode *barrier = mirBuilder.GetMirModule().CurFuncCodeMemPool()->New<StmtNode>(OP_membaracquire);
+    ans.emplace_back(barrier);
+  }
+  return ans;
+}
+
+std::string FEIRStmtFieldLoad::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtCallAssign ----------
+std::map<Opcode, Opcode> FEIRStmtCallAssign::mapOpAssignToOp = FEIRStmtCallAssign::InitMapOpAssignToOp();
+std::map<Opcode, Opcode> FEIRStmtCallAssign::mapOpToOpAssign = FEIRStmtCallAssign::InitMapOpToOpAssign();
+
+FEIRStmtCallAssign::FEIRStmtCallAssign(FEStructMethodInfo &argMethodInfo, Opcode argMIROp, UniqueFEIRVar argVarRet,
+                                       bool argIsStatic)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtCallAssign, std::move(argVarRet)),
+      methodInfo(argMethodInfo),
+      mirOp(argMIROp),
+      isStatic(argIsStatic) {}
+
+std::map<Opcode, Opcode> FEIRStmtCallAssign::InitMapOpAssignToOp() {
+  std::map<Opcode, Opcode> ans;
+  ans[OP_callassigned] = OP_call;
+  ans[OP_virtualcallassigned] = OP_virtualcall;
+  ans[OP_superclasscallassigned] = OP_superclasscall;
+  ans[OP_interfacecallassigned] = OP_interfacecall;
+  return ans;
+}
+
+std::map<Opcode, Opcode> FEIRStmtCallAssign::InitMapOpToOpAssign() {
+  std::map<Opcode, Opcode> ans;
+  ans[OP_call] = OP_callassigned;
+  ans[OP_virtualcall] = OP_virtualcallassigned;
+  ans[OP_superclasscall] = OP_superclasscallassigned;
+  ans[OP_interfacecall] = OP_interfacecallassigned;
+  return ans;
+}
+
+void FEIRStmtCallAssign::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  for (const UniqueFEIRExpr &exprArg : exprArgs) {
+    exprArg->RegisterDFGNodes2CheckPoint(checkPoint);
+  }
+  if (!methodInfo.IsReturnVoid() && (var != nullptr)) {
+    var->SetDef(true);
+    checkPoint.RegisterDFGNode(var);
+  }
+}
+
+bool FEIRStmtCallAssign::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  for (const UniqueFEIRExpr &exprArg : exprArgs) {
+    success = success && exprArg->CalculateDefs4AllUses(checkPoint, udChain);
+  }
+  return success;
+}
+
+std::list<StmtNode*> FEIRStmtCallAssign::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  // If the struct is a class, we check it if external type directly.
+  // If the struct is a array type, we check its baseType if external type.
+  // FEUtils::GetBaseTypeName returns a class type itself or an arrayType's base type.
+  if (methodInfo.GetSrcLang() == kSrcLangJava) {
+    std::string baseStructName = FEUtils::GetBaseTypeName(methodInfo.GetStructName());
+    bool isCreate = false;
+    (void)FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(
+        baseStructName, false, FETypeFlag::kSrcExtern, isCreate);
+  }
+  std::list<StmtNode*> ans;
+  StmtNode *stmtCall = nullptr;
+  // prepare and find root
+  methodInfo.Prepare(mirBuilder, isStatic);
+  if (methodInfo.IsJavaPolymorphicCall() || methodInfo.IsJavaDynamicCall()) {
+    return GenMIRStmtsUseZeroReturn(mirBuilder);
+  }
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.reserve(exprArgs.size());
+  size_t index = 0;
+  const std::string funcName = methodInfo.GetMirFunc()->GetName();
+  for (const UniqueFEIRExpr &exprArg : exprArgs) {
+    InsertNonnullCheckingInArgs(exprArg, index++, mirBuilder, ans, funcName);
+    ENCChecker::InsertBoundaryAssignChecking(mirBuilder, ans, exprArg, loc);
+    ENCChecker::CheckBoundaryLenFinalAddr(mirBuilder, exprArg, loc);
+    BaseNode *node = exprArg->GenMIRNode(mirBuilder);
+    args.push_back(node);
+  }
+  MIRSymbol *retVarSym = nullptr;
+  if (!methodInfo.IsReturnVoid() && var != nullptr) {
+    retVarSym = var->GenerateLocalMIRSymbol(mirBuilder);
+    InsertNonnullInRetVar(*retVarSym);
+  }
+  if (retVarSym == nullptr) {
+    stmtCall = mirBuilder.CreateStmtCall(methodInfo.GetPuIdx(), std::move(args), mirOp);
+  } else {
+    stmtCall = mirBuilder.CreateStmtCallAssigned(methodInfo.GetPuIdx(), std::move(args), retVarSym, mirOp);
+  }
+  ans.push_back(stmtCall);
+  return ans;
+}
+
+
+void FEIRStmtCallAssign::InsertNonnullInRetVar(MIRSymbol &retVarSym) const {
+  if (methodInfo.GetMirFunc()->GetFuncAttrs().GetAttr(FUNCATTR_nonnull)) {
+    TypeAttrs attrs = TypeAttrs();
+    attrs.SetAttr(ATTR_nonnull);
+    retVarSym.AddAttrs(attrs);
+  }
+}
+
+void FEIRStmtCallAssign::InsertNonnullCheckingInArgs(const UniqueFEIRExpr &expr, size_t index, MIRBuilder &mirBuilder,
+                                                     std::list<StmtNode*> &ans, const std::string& funcName) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic()) {
+    return;
+  }
+  if (index >= methodInfo.GetMirFunc()->GetParamSize()) {  // Skip variable parameter
+    return;
+  }
+  MIRType *srcType = expr->GetType()->GenerateMIRTypeAuto();
+  MIRType *dstType = methodInfo.GetMirFunc()->GetNthParamType(index);
+  ENCChecker::CheckNonnullFieldInStruct(*srcType, *dstType, loc);
+  if (!methodInfo.GetMirFunc()->GetNthParamAttr(index).GetAttr(ATTR_nonnull)) {
+    return;
+  }
+  if (ENCChecker::HasNullExpr(expr)) {
+    FE_ERR(kLncErr, loc, "null passed to a callee that requires a nonnull argument[the %s argument]",
+           ENCChecker::GetNthStr(index).c_str());
+    return;
+  }
+  if (expr->GetPrimType() == PTY_ptr) {
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCallAssertNonnull>(OP_callassertnonnull, expr->Clone(),
+                                                                      funcName, index);
+    stmt->SetSrcLoc(expr->GetLoc());
+    std::list<StmtNode*> stmts = stmt->GenMIRStmts(mirBuilder);
+    ans.splice(ans.end(), stmts);
+  }
+}
+
+std::list<StmtNode*> FEIRStmtCallAssign::GenMIRStmtsUseZeroReturn(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  if (methodInfo.IsReturnVoid()) {
+    return ans;
+  }
+  const FEIRType *retType = methodInfo.GetReturnType();
+  MIRType *mirRetType = retType->GenerateMIRTypeAuto(kSrcLangJava);
+  MIRSymbol *mirRetSym = var->GenerateLocalMIRSymbol(mirBuilder);
+  BaseNode *nodeZero;
+  if (mirRetType->IsScalarType()) {
+    switch (mirRetType->GetPrimType()) {
+      case PTY_u1:
+      case PTY_i8:
+      case PTY_i16:
+      case PTY_u16:
+      case PTY_i32:
+        nodeZero = mirBuilder.CreateIntConst(0, PTY_i32);
+        break;
+      case PTY_i64:
+        nodeZero = mirBuilder.CreateIntConst(0, PTY_i64);
+        break;
+      case PTY_f32:
+        nodeZero = mirBuilder.CreateFloatConst(0.0f);
+        break;
+      case PTY_f64:
+        nodeZero = mirBuilder.CreateDoubleConst(0.0);
+        break;
+      default:
+        nodeZero = mirBuilder.CreateIntConst(0, PTY_i32);
+        break;
+    }
+  } else {
+    nodeZero = mirBuilder.CreateIntConst(0, PTY_ref);
+  }
+  StmtNode *stmt = mirBuilder.CreateStmtDassign(mirRetSym->GetStIdx(), 0, nodeZero);
+  ans.push_back(stmt);
+  return ans;
+}
+
+Opcode FEIRStmtCallAssign::AdjustMIROp() const {
+  if (methodInfo.IsReturnVoid()) {
+    auto it = mapOpAssignToOp.find(mirOp);
+    if (it != mapOpAssignToOp.cend()) {
+      return it->second;
+    }
+  } else {
+    auto it = mapOpToOpAssign.find(mirOp);
+    if (it != mapOpToOpAssign.cend()) {
+      return it->second;
+    }
+  }
+  return mirOp;
+}
+
+std::string FEIRStmtCallAssign::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  if (var != nullptr) {
+    ss << " def : " << var->GetNameRaw() << ", ";
+  }
+  if (exprArgs.size() > 0) {
+    ss << " uses : ";
+    for (const UniqueFEIRExpr &exprArg : exprArgs) {
+      ss << exprArg->DumpDotString() << ", ";
+    }
+  }
+  return ss.str();
+}
+
+// ---------- FEIRStmtICallAssign ----------
+FEIRStmtICallAssign::FEIRStmtICallAssign()
+    : FEIRStmtAssign(FEIRNodeKind::kStmtICallAssign, nullptr) {}
+
+void FEIRStmtICallAssign::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  CHECK_FATAL(false, "NYI");
+}
+
+bool FEIRStmtICallAssign::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  for (const UniqueFEIRExpr &exprArg : exprArgs) {
+    success = success && exprArg->CalculateDefs4AllUses(checkPoint, udChain);
+  }
+  return success;
+}
+
+void FEIRStmtICallAssign::InsertNonnullCheckingInArgs(MIRBuilder &mirBuilder, std::list<StmtNode*> &ans) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || exprArgs.size() <= 1) {
+    return;
+  }
+  const MIRFuncType *funcType = FEUtils::GetFuncPtrType(*exprArgs.front()->GetType()->GenerateMIRType());
+  if (funcType == nullptr) {
+    return;
+  }
+  int idx = -2; // the first arg is function pointer
+  size_t size = funcType->GetParamAttrsList().size();
+  for (const auto &expr : exprArgs) {
+    ++idx;
+    if (idx < 0 || idx >= static_cast<int>(size)) {
+      continue;
+    }
+    MIRType *srcType = expr->GetType()->GenerateMIRTypeAuto();
+    MIRType *dstType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetNthParamType(idx));
+    ENCChecker::CheckNonnullFieldInStruct(*srcType, *dstType, loc);
+    if (!funcType->GetNthParamAttrs(idx).GetAttr(ATTR_nonnull)) {
+      continue;
+    }
+    if (ENCChecker::HasNullExpr(expr)) {
+      FE_ERR(kLncErr, loc, "null passed to a callee that requires a nonnull argument[the %s argument]",
+             ENCChecker::GetNthStr(idx).c_str());
+      continue;
+    }
+    if (expr->GetPrimType() == PTY_ptr) {
+      UniqueFEIRStmt stmt = std::make_unique<FEIRStmtCallAssertNonnull>(
+          OP_callassertnonnull, expr->Clone(), "function_pointer", idx);
+      stmt->SetSrcLoc(expr->GetLoc());
+      std::list<StmtNode*> stmts = stmt->GenMIRStmts(mirBuilder);
+      ans.splice(ans.end(), stmts);
+    }
+  }
+}
+
+void FEIRStmtICallAssign::InsertNonnullInRetVar(MIRSymbol &retVarSym) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic() || exprArgs.size() < 1) {
+    return;
+  }
+  const MIRFuncType *funcType = FEUtils::GetFuncPtrType(*exprArgs.front()->GetType()->GenerateMIRType());
+  if (funcType == nullptr) {
+    return;
+  }
+  if (funcType->GetRetAttrs().GetAttr(ATTR_nonnull)) {
+    TypeAttrs attrs = TypeAttrs();
+    attrs.SetAttr(ATTR_nonnull);
+    retVarSym.AddAttrs(attrs);
+  }
+}
+
+std::list<StmtNode*> FEIRStmtICallAssign::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *stmtICall = nullptr;
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.reserve(exprArgs.size());
+  for (const UniqueFEIRExpr &exprArg : exprArgs) {
+    BaseNode *node = exprArg->GenMIRNode(mirBuilder);
+    ENCChecker::InsertBoundaryAssignChecking(mirBuilder, ans, exprArg, loc);
+    ENCChecker::CheckBoundaryLenFinalAddr(mirBuilder, exprArg, loc);
+    args.push_back(node);
+  }
+  InsertNonnullCheckingInArgs(mirBuilder, ans);
+  bool isC = FEManager::GetModule().IsCModule();
+  MIRType *pMIRType = nullptr;
+  if (isC) {
+    CHECK_FATAL(prototype != nullptr, "cannot find prototype for icall");
+    pMIRType = prototype->GenerateMIRTypeAuto();
+    CHECK_NULL_FATAL(pMIRType);
+  }
+  if (var != nullptr) {
+    MIRSymbol *retVarSym = var->GenerateLocalMIRSymbol(mirBuilder);
+    InsertNonnullInRetVar(*retVarSym);
+    stmtICall = isC ? mirBuilder.CreateStmtIcallprotoAssigned(std::move(args), *retVarSym, pMIRType->GetTypeIndex()) :
+                      mirBuilder.CreateStmtIcallAssigned(std::move(args), *retVarSym);
+  } else {
+    stmtICall = isC ? mirBuilder.CreateStmtIcallproto(std::move(args), pMIRType->GetTypeIndex()) :
+                      mirBuilder.CreateStmtIcall(std::move(args));
+  }
+  ans.push_back(stmtICall);
+  return ans;
+}
+
+std::string FEIRStmtICallAssign::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  if (var != nullptr) {
+    ss << " def : " << var->GetNameRaw() << ", ";
+  }
+  if (exprArgs.size() > 0) {
+    ss << " uses : ";
+    for (const UniqueFEIRExpr &exprArg : exprArgs) {
+      ss << exprArg->DumpDotString() << ", ";
+    }
+  }
+  return ss.str();
+}
+
+// ---------- FEIRStmtIntrinsicCallAssign ----------
+FEIRStmtIntrinsicCallAssign::FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, UniqueFEIRType typeIn,
+                                                         UniqueFEIRVar argVarRet)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtIntrinsicCallAssign, std::move(argVarRet)),
+      intrinsicId(id),
+      type(std::move(typeIn)) {}
+
+FEIRStmtIntrinsicCallAssign::FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, UniqueFEIRType typeIn,
+                                                         UniqueFEIRVar argVarRet,
+                                                         std::unique_ptr<std::list<UniqueFEIRExpr>> exprListIn)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtIntrinsicCallAssign, std::move(argVarRet)),
+      intrinsicId(id),
+      type(std::move(typeIn)),
+      exprList(std::move(exprListIn)) {}
+
+FEIRStmtIntrinsicCallAssign::FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, const std::string &funcNameIn,
+                                                         const std::string &protoIN,
+                                                         std::unique_ptr<std::list<UniqueFEIRVar>> argsIn)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtIntrinsicCallAssign, nullptr),
+      intrinsicId(id),
+      funcName(funcNameIn),
+      proto(protoIN),
+      polyArgs(std::move(argsIn)) {}
+FEIRStmtIntrinsicCallAssign::FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, const std::string &funcNameIn,
+                                                         const std::string &protoIN,
+                                                         std::unique_ptr<std::list<UniqueFEIRVar>> argsIn,
+                                                         uint32 callerClassTypeIDIn, bool isInStaticFuncIn)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtIntrinsicCallAssign, nullptr),
+      intrinsicId(id),
+      funcName(funcNameIn),
+      proto(protoIN),
+      polyArgs(std::move(argsIn)),
+      callerClassTypeID(callerClassTypeIDIn),
+      isInStaticFunc(isInStaticFuncIn) {}
+
+FEIRStmtIntrinsicCallAssign::FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, UniqueFEIRType typeIn,
+                                                         UniqueFEIRVar argVarRet, uint32 typeIDIn)
+    : FEIRStmtAssign(FEIRNodeKind::kStmtIntrinsicCallAssign, std::move(argVarRet)),
+      intrinsicId(id),
+      type(std::move(typeIn)),
+      typeID(typeIDIn) {}
+
+std::string FEIRStmtIntrinsicCallAssign::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+void FEIRStmtIntrinsicCallAssign::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  if ((var != nullptr) && (var.get() != nullptr)) {
+    var->SetDef(true);
+    checkPoint.RegisterDFGNode(var);
+  }
+}
+
+std::list<StmtNode*> FEIRStmtIntrinsicCallAssign::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *stmtCall = nullptr;
+  if (intrinsicId == INTRN_JAVA_CLINIT_CHECK) {
+    MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+    if (FEOptions::GetInstance().IsAOT()) {
+      BaseNode *argNumExpr = mirBuilder.CreateIntConst(typeID, PTY_i32);
+      args.push_back(argNumExpr);
+    }
+    stmtCall = mirBuilder.CreateStmtIntrinsicCall(INTRN_JAVA_CLINIT_CHECK, std::move(args),
+                                                  type->GenerateMIRType()->GetTypeIndex());
+  } else if (intrinsicId == INTRN_JAVA_FILL_NEW_ARRAY) {
+    return GenMIRStmtsForFillNewArray(mirBuilder);
+  } else if (intrinsicId == INTRN_JAVA_POLYMORPHIC_CALL) {
+    return GenMIRStmtsForInvokePolyMorphic(mirBuilder);
+  } else if (intrinsicId == INTRN_C_va_start || intrinsicId == INTRN_C_memcpy) {
+    MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+    if (exprList != nullptr) {
+      for (const auto &expr : *exprList) {
+        BaseNode *node = expr->GenMIRNode(mirBuilder);
+        if (expr->IsAddrof()) {
+          node = ReplaceAddrOfNode(node);  // addrof va_list
+        }
+        args.push_back(node);
+      }
+    }
+    MIRSymbol *retVarSym = nullptr;
+    if (var != nullptr) {
+      retVarSym = var->GenerateLocalMIRSymbol(mirBuilder);
+      stmtCall = mirBuilder.CreateStmtIntrinsicCallAssigned(intrinsicId, std::move(args), retVarSym);
+    } else {
+      stmtCall = mirBuilder.CreateStmtIntrinsicCall(intrinsicId, std::move(args), TyIdx(0));
+    }
+  } else {
+    MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+    if (exprList != nullptr) {
+      for (const auto &expr : *exprList) {
+        BaseNode *node = expr->GenMIRNode(mirBuilder);
+        args.push_back(node);
+      }
+    }
+    MIRSymbol *retVarSym = nullptr;
+    if ((var != nullptr) && (var.get() != nullptr)) {
+      retVarSym = var->GenerateLocalMIRSymbol(mirBuilder);
+      stmtCall = mirBuilder.CreateStmtIntrinsicCallAssigned(intrinsicId, std::move(args), retVarSym);
+    } else {
+      stmtCall = mirBuilder.CreateStmtIntrinsicCall(intrinsicId, std::move(args), TyIdx(0));
+    }
+  }
+  // other intrinsic call should be implemented
+  ans.emplace_back(stmtCall);
+  return ans;
+}
+
+std::list<StmtNode*> FEIRStmtIntrinsicCallAssign::GenMIRStmtsForFillNewArray(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  if (exprList != nullptr) {
+    for (const auto &expr : *exprList) {
+      BaseNode *node = expr->GenMIRNode(mirBuilder);
+      args.push_back(node);
+    }
+  }
+  MIRSymbol *retVarSym = nullptr;
+  if ((var != nullptr) && (var.get() != nullptr)) {
+    retVarSym = var->GenerateLocalMIRSymbol(mirBuilder);
+  }
+  auto *stmtCall = mirBuilder.CreateStmtIntrinsicCallAssigned(INTRN_JAVA_FILL_NEW_ARRAY, std::move(args), retVarSym,
+                                                              type->GenerateMIRType(true)->GetTypeIndex());
+  (void)ans.emplace_back(stmtCall);
+  return ans;
+}
+
+std::list<StmtNode*> FEIRStmtIntrinsicCallAssign::GenMIRStmtsForInvokePolyMorphic(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *stmtCall = nullptr;
+  UniqueFEIRVar tmpVar;
+  bool needRetypeRet = false;
+  MIRSymbol *retVarSym = nullptr;
+  if ((var != nullptr) && (var.get() != nullptr)) {
+    PrimType ptyRet = var->GetTypeRef().GetPrimType();
+    needRetypeRet = (ptyRet == PTY_f32 || ptyRet == PTY_f64);
+    tmpVar = var->Clone();
+    if (ptyRet == PTY_f32) {
+      tmpVar->SetType(std::make_unique<FEIRTypeDefault>(PTY_i32,
+                                                        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("I")));
+    } else if (ptyRet == PTY_f64) {
+      tmpVar->SetType(std::make_unique<FEIRTypeDefault>(PTY_i64,
+                                                        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("J")));
+    }
+    retVarSym = tmpVar->GenerateLocalMIRSymbol(mirBuilder);
+  }
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  ConstructArgsForInvokePolyMorphic(mirBuilder, args);
+  stmtCall = mirBuilder.CreateStmtIntrinsicCallAssigned(INTRN_JAVA_POLYMORPHIC_CALL, std::move(args), retVarSym);
+  ans.emplace_back(stmtCall);
+  if (needRetypeRet) {
+    UniqueFEIRStmt retypeStmt = FEIRBuilder::CreateStmtRetype(var->Clone(), std::move(tmpVar));
+    std::list<StmtNode*> retypeMirStmts = retypeStmt->GenMIRStmts(mirBuilder);
+    for (auto elem : retypeMirStmts) {
+      ans.emplace_back(elem);
+    }
+  }
+  return ans;
+}
+
+void FEIRStmtIntrinsicCallAssign::ConstructArgsForInvokePolyMorphic(MIRBuilder &mirBuilder,
+                                                                    MapleVector<BaseNode*> &intrnCallargs) const {
+  MIRSymbol *funcNameVal = FEManager::GetJavaStringManager().GetLiteralVar(funcName);
+  if (funcNameVal == nullptr) {
+    funcNameVal = FEManager::GetJavaStringManager().CreateLiteralVar(mirBuilder, funcName, false);
+  }
+  BaseNode *dreadExprFuncName = mirBuilder.CreateExprAddrof(0, *funcNameVal);
+  dreadExprFuncName->SetPrimType(PTY_ptr);
+  intrnCallargs.push_back(dreadExprFuncName);
+
+  MIRSymbol *protoNameVal = FEManager::GetJavaStringManager().GetLiteralVar(proto);
+  if (protoNameVal == nullptr) {
+    protoNameVal = FEManager::GetJavaStringManager().CreateLiteralVar(mirBuilder, proto, false);
+  }
+  BaseNode *dreadExprProtoName = mirBuilder.CreateExprAddrof(0, *protoNameVal);
+  dreadExprProtoName->SetPrimType(PTY_ptr);
+  intrnCallargs.push_back(dreadExprProtoName);
+
+  BaseNode *argNumExpr = mirBuilder.CreateIntConst(static_cast<uint64>(polyArgs->size() - 1), PTY_i32);
+  intrnCallargs.push_back(argNumExpr);
+
+  bool isAfterMethodHandle = true;
+  for (const auto &arg : *polyArgs) {
+    intrnCallargs.push_back(mirBuilder.CreateExprDread(*(arg->GenerateMIRSymbol(mirBuilder))));
+    if (FEOptions::GetInstance().IsAOT() && isAfterMethodHandle) {
+      if (isInStaticFunc) {
+        intrnCallargs.push_back(mirBuilder.CreateIntConst(callerClassTypeID, PTY_i32));
+      } else {
+        std::unique_ptr<FEIRVar> varThisAsLocalVar = std::make_unique<FEIRVarName>(FEUtils::GetThisIdx(),
+                                                                                   FEIRTypeDefault(PTY_ref).Clone());
+        intrnCallargs.push_back(mirBuilder.CreateExprDread(*(varThisAsLocalVar->GenerateMIRSymbol(mirBuilder))));
+      }
+      isAfterMethodHandle = false;
+    }
+  }
+}
+
+// ---------- FEIRExpr ----------
+FEIRExpr::FEIRExpr(FEIRNodeKind argKind)
+    : kind(argKind),
+      isNestable(true),
+      isAddrof(false),
+      hasException(false),
+      isBoundaryChecking(false),
+      isEnhancedChecking(true) {
+  type = std::make_unique<FEIRTypeDefault>();
+}
+
+FEIRExpr::FEIRExpr(FEIRNodeKind argKind, std::unique_ptr<FEIRType> argType)
+    : kind(argKind),
+      isNestable(true),
+      isAddrof(false),
+      hasException(false),
+      isBoundaryChecking(false),
+      isEnhancedChecking(true),
+      type(std::move(argType)) {}
+
+std::unique_ptr<FEIRExpr> FEIRExpr::Clone() {
+  auto expr = CloneImpl();
+  expr->isNestable = IsNestable();
+  expr->isAddrof = IsAddrof();
+  expr->hasException = HasException();
+  expr->isBoundaryChecking = IsBoundaryChecking();
+  expr->isEnhancedChecking = IsEnhancedChecking();
+  expr->SetLoc(loc);
+  return expr;
+}
+
+bool FEIRExpr::IsNestableImpl() const {
+  return isNestable;
+}
+
+bool FEIRExpr::IsAddrofImpl() const {
+  return isAddrof;
+}
+
+bool FEIRExpr::HasExceptionImpl() const {
+  return hasException;
+}
+
+std::vector<FEIRVar*> FEIRExpr::GetVarUsesImpl() const {
+  return std::vector<FEIRVar*>();
+}
+
+std::string FEIRExpr::DumpDotString() const {
+  std::stringstream ss;
+  if (kind == FEIRNodeKind::kExprArrayLoad) {
+    ss << " kExprArrayLoad: ";
+  }
+  std::vector<FEIRVar*> varUses = GetVarUses();
+  ss << "[ ";
+  for (FEIRVar *use : varUses) {
+    ss << use->GetNameRaw() << ", ";
+  }
+  ss << "] ";
+  return ss.str();
+}
+
+// ---------- FEIRExprConst ----------
+FEIRExprConst::FEIRExprConst()
+    : FEIRExpr(FEIRNodeKind::kExprConst) {
+  ASSERT(type != nullptr, "type is nullptr");
+  type->SetPrimType(PTY_i32);
+  value.u64 = 0;
+}
+
+FEIRExprConst::FEIRExprConst(int64 val, PrimType argType)
+    : FEIRExpr(FEIRNodeKind::kExprConst) {
+  ASSERT(type != nullptr, "type is nullptr");
+  type->SetPrimType(argType);
+  value.i64 = val;
+  CheckRawValue2SetZero();
+}
+
+FEIRExprConst::FEIRExprConst(uint64 val, PrimType argType)
+    : FEIRExpr(FEIRNodeKind::kExprConst) {
+  ASSERT(type != nullptr, "type is nullptr");
+  type->SetPrimType(argType);
+  value.u64 = val;
+  CheckRawValue2SetZero();
+}
+
+FEIRExprConst::FEIRExprConst(uint32 val)
+    : FEIRExpr(FEIRNodeKind::kExprConst) {
+  type->SetPrimType(PTY_u32);
+  value.u32 = val;
+  CheckRawValue2SetZero();
+}
+
+FEIRExprConst::FEIRExprConst(float val)
+    : FEIRExpr(FEIRNodeKind::kExprConst) {
+  ASSERT(type != nullptr, "type is nullptr");
+  type->SetPrimType(PTY_f32);
+  value.f32 = val;
+  CheckRawValue2SetZero();
+}
+
+FEIRExprConst::FEIRExprConst(double val)
+    : FEIRExpr(FEIRNodeKind::kExprConst) {
+  ASSERT(type != nullptr, "type is nullptr");
+  type->SetPrimType(PTY_f64);
+  value.f64 = val;
+  CheckRawValue2SetZero();
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprConst::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprConst>();
+  FEIRExprConst *exprConst = static_cast<FEIRExprConst*>(expr.get());
+  exprConst->value.u64 = value.u64;
+  ASSERT(type != nullptr, "type is nullptr");
+  exprConst->type->SetPrimType(type->GetPrimType());
+  exprConst->CheckRawValue2SetZero();
+  return expr;
+}
+
+BaseNode *FEIRExprConst::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  PrimType primType = GetPrimType();
+  switch (primType) {
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_u16:
+    case PTY_u32:
+      return mirBuilder.CreateIntConst(value.u32, primType);
+    case PTY_u64:
+    case PTY_i8:
+    case PTY_i16:
+    case PTY_i32:
+    case PTY_i64:
+    case PTY_i128:
+    case PTY_u128:
+    case PTY_ref:
+    case PTY_ptr:
+      return mirBuilder.CreateIntConst(static_cast<uint64>(value.i64), primType);
+    case PTY_f32:
+      return mirBuilder.CreateFloatConst(value.f32);
+    case PTY_f64:
+      return mirBuilder.CreateDoubleConst(value.f64);
+    default:
+      ERR(kLncErr, "unsupported const kind");
+      return nullptr;
+  }
+}
+
+uint32 FEIRExprConst::HashImpl() const {
+  return (static_cast<uint32>(kind) << kOpHashShift) + (type->Hash() << kTypeHashShift) +
+         static_cast<uint32>(std::hash<uint64>{}(value.u64));
+}
+
+void FEIRExprConst::CheckRawValue2SetZero() {
+  if (value.u64 == 0) {
+    type->SetZero(true);
+  }
+}
+
+// ---------- FEIRExprSizeOfType ----------
+FEIRExprSizeOfType::FEIRExprSizeOfType(UniqueFEIRType ty)
+    : FEIRExpr(FEIRNodeKind::kExprSizeOfType,
+               FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPrimType(PTY_u32))),
+      feirType(std::move(ty)) {}
+
+std::unique_ptr<FEIRExpr> FEIRExprSizeOfType::CloneImpl() const {
+  std::unique_ptr<FEIRExprSizeOfType> expr = std::make_unique<FEIRExprSizeOfType>(feirType->Clone());
+  return expr;
+}
+
+BaseNode *FEIRExprSizeOfType::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  return mirBuilder.CreateExprSizeoftype(*(feirType->GenerateMIRTypeAuto()));
+}
+
+// ---------- FEIRExprDRead ----------
+FEIRExprDRead::FEIRExprDRead(std::unique_ptr<FEIRVar> argVarSrc)
+    : FEIRExpr(FEIRNodeKind::kExprDRead) {
+  SetVarSrc(std::move(argVarSrc));
+}
+
+FEIRExprDRead::FEIRExprDRead(std::unique_ptr<FEIRType> argType, std::unique_ptr<FEIRVar> argVarSrc)
+    : FEIRExpr(FEIRNodeKind::kExprDRead, std::move(argType)) {
+  SetVarSrc(std::move(argVarSrc));
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprDRead::CloneImpl() const {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprDRead>(type->Clone(), varSrc->Clone());
+  if (fieldType != nullptr) {
+    expr->SetFieldType(fieldType->Clone());
+  }
+  expr->SetFieldID(fieldID);
+  return expr;
+}
+
+BaseNode *FEIRExprDRead::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MIRType *type = varSrc->GetType()->GenerateMIRTypeAuto();
+  MIRSymbol *symbol = varSrc->GenerateMIRSymbol(mirBuilder);
+  ASSERT(type != nullptr, "type is nullptr");
+  PrimType regType = GetRegPrimType(type->GetPrimType());
+  if (regType != type->GetPrimType()) {
+    type = GlobalTables::GetTypeTable().GetPrimType(regType);
+  }
+  AddrofNode *node = mirBuilder.CreateExprDread(*type, *symbol);
+  if (fieldID != 0) {
+    CHECK_FATAL((type->GetKind() == MIRTypeKind::kTypeStruct || type->GetKind() == MIRTypeKind::kTypeUnion),
+                "If fieldID is not 0, then the variable must be a structure");
+    CHECK_NULL_FATAL(fieldType);
+    MIRType *fieldMIRType = fieldType->GenerateMIRTypeAuto();
+    regType = GetRegPrimType(fieldMIRType->GetPrimType());
+    if (regType != fieldMIRType->GetPrimType()) {
+      fieldMIRType = GlobalTables::GetTypeTable().GetPrimType(regType);
+    }
+    node = mirBuilder.CreateExprDread(*fieldMIRType, fieldID, *symbol);
+  }
+  return node;
+}
+
+void FEIRExprDRead::SetVarSrc(std::unique_ptr<FEIRVar> argVarSrc) {
+  CHECK_FATAL(argVarSrc != nullptr, "input is nullptr");
+  varSrc = std::move(argVarSrc);
+  SetType(varSrc->GetType()->Clone());
+}
+
+std::vector<FEIRVar*> FEIRExprDRead::GetVarUsesImpl() const {
+  return std::vector<FEIRVar*>({ varSrc.get() });
+}
+
+PrimType FEIRExprDRead::GetPrimTypeImpl() const {
+  PrimType primType = type->GetPrimType();
+  if (primType == PTY_agg && fieldID != 0) {
+    CHECK_NULL_FATAL(fieldType);
+    return fieldType->GetPrimType();
+  }
+  return primType;
+}
+
+void FEIRExprDRead::SetTypeImpl(std::unique_ptr<FEIRType> argType) {
+  if (fieldID != 0) {
+    fieldType = std::move(argType);
+  } else {
+    type = std::move(argType);
+  }
+}
+
+FEIRType *FEIRExprDRead::GetTypeImpl() const {
+  if (fieldID != 0) {
+    CHECK_NULL_FATAL(fieldType);
+    return fieldType.get();
+  }
+  return type.get();
+}
+
+const FEIRType &FEIRExprDRead::GetTypeRefImpl() const {
+  return *GetTypeImpl();
+}
+
+// ---------- FEIRExprIRead ----------
+std::unique_ptr<FEIRExpr> FEIRExprIRead::CloneImpl() const {
+  std::unique_ptr<FEIRExprIRead> expr = std::make_unique<FEIRExprIRead>(type->Clone(), ptrType->Clone(),
+                                                                        fieldID, subExpr->Clone());
+  return expr;
+}
+
+std::vector<FEIRVar*> FEIRExprIRead::GetVarUsesImpl() const {
+  return subExpr->GetVarUses();
+}
+
+BaseNode *FEIRExprIRead::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MIRType *returnType = type->GenerateMIRTypeAuto();
+  MIRType *pointerType = ptrType->GenerateMIRTypeAuto();
+  BaseNode *node = subExpr->GenMIRNode(mirBuilder);
+  CHECK_FATAL(pointerType->IsMIRPtrType(), "Must be ptr type!");
+  MIRPtrType *mirPtrType = static_cast<MIRPtrType*>(pointerType);
+  MIRType *pointedMirType = mirPtrType->GetPointedType();
+  if (fieldID != 0) {
+    CHECK_FATAL((pointedMirType->GetKind() == MIRTypeKind::kTypeStruct ||
+                 pointedMirType->GetKind() == MIRTypeKind::kTypeUnion),
+                "If fieldID is not 0, then type must specify pointer to a structure");
+  }
+  return mirBuilder.CreateExprIread(*returnType, *mirPtrType, fieldID, node);
+}
+
+// ---------- FEIRExprAddrofConstArray ----------
+FEIRExprAddrofConstArray::FEIRExprAddrofConstArray(const std::vector<uint32> &arrayIn, MIRType *typeIn,
+                                                   const std::string &strIn)
+    : FEIRExpr(FEIRNodeKind::kExprAddrof, FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())),
+      arrayName(FEOptions::GetInstance().GetFuncInlineSize() != 0 ? FEUtils::GetSequentialName("const_array_") +
+                FEUtils::GetFileNameHashStr(FEManager::GetModule().GetFileName()) :
+                FEUtils::GetSequentialName("const_array_")),
+      elemType(typeIn),
+      str(strIn) {
+  std::copy(arrayIn.begin(), arrayIn.end(), std::back_inserter(array));
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprAddrofConstArray::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprAddrofConstArray>(arrayName, array, elemType, str);
+  return expr;
+}
+
+BaseNode *FEIRExprAddrofConstArray::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  if (!str.empty()) {
+    MIRModule &module = mirBuilder.GetMirModule();
+    UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str);
+    return module.GetMemPool()->New<ConststrNode>(PTY_ptr, strIdx);
+  }
+  MIRType *arrayTypeWithSize = GlobalTables::GetTypeTable().GetOrCreateArrayType(
+      *elemType, static_cast<uint32>(array.size()));
+  MIRSymbol *arrayVar = mirBuilder.GetOrCreateGlobalDecl(arrayName, *arrayTypeWithSize);
+  arrayVar->SetAttr(ATTR_readonly);
+  arrayVar->SetStorageClass(kScFstatic);
+  MIRModule &module = mirBuilder.GetMirModule();
+  MIRAggConst *val = module.GetMemPool()->New<MIRAggConst>(module, *arrayTypeWithSize);
+  for (uint32 i = 0; i < array.size(); ++i) {
+    MIRConst *cst = module.GetMemPool()->New<MIRIntConst>(array[i], *elemType);
+    val->PushBack(cst);
+  }
+  // This interface is only for string literal, 0 is added to the end of the string.
+  MIRConst *cst0 = module.GetMemPool()->New<MIRIntConst>(0, *elemType);
+  val->PushBack(cst0);
+  arrayVar->SetKonst(val);
+  BaseNode *nodeAddrof = mirBuilder.CreateExprAddrof(0, *arrayVar);
+  return nodeAddrof;
+}
+
+// ---------- FEIRExprAddrOfLabel ---------
+std::unique_ptr<FEIRExpr> FEIRExprAddrOfLabel::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprAddrOfLabel>(labelName, type->Clone());
+  return expr;
+}
+
+BaseNode *FEIRExprAddrOfLabel::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  LabelIdx lbIdx = mirBuilder.GetOrCreateMIRLabel(labelName);
+  BaseNode *mirNode = mirBuilder.GetCurrentFuncCodeMp()->New<AddroflabelNode>(static_cast<uint32>(lbIdx));
+  mirNode->SetPrimType(PTY_ptr);
+  return mirNode;
+}
+
+// ---------- FEIRExprIAddrof ----------
+std::unique_ptr<FEIRExpr> FEIRExprIAddrof::CloneImpl() const {
+  return std::make_unique<FEIRExprIAddrof>(ptrType->Clone(), fieldID, subExpr->Clone());
+}
+
+std::vector<FEIRVar*> FEIRExprIAddrof::GetVarUsesImpl() const {
+  return subExpr->GetVarUses();
+}
+
+BaseNode *FEIRExprIAddrof::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MIRType *returnType = GlobalTables::GetTypeTable().GetPtrType();
+  MIRType *pointerType = ptrType->GenerateMIRTypeAuto();
+  BaseNode *node = subExpr->GenMIRNode(mirBuilder);
+  CHECK_FATAL(pointerType->IsMIRPtrType(), "Must be ptr type!");
+  MIRPtrType *mirPtrType = static_cast<MIRPtrType*>(pointerType);
+  MIRType *pointedMirType = mirPtrType->GetPointedType();
+  if (fieldID != 0) {
+    CHECK_FATAL((pointedMirType->GetKind() == MIRTypeKind::kTypeStruct ||
+                 pointedMirType->GetKind() == MIRTypeKind::kTypeUnion),
+                "If fieldID is not 0, then type must specify pointer to a structure");
+  }
+  return mirBuilder.CreateExprIaddrof(*returnType, *mirPtrType, fieldID, node);
+}
+
+// ---------- FEIRExprAddrofVar ----------
+std::unique_ptr<FEIRExpr> FEIRExprAddrofVar::CloneImpl() const {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprAddrofVar>(varSrc->Clone());
+  expr->SetFieldID(fieldID);
+  return expr;
+}
+
+BaseNode *FEIRExprAddrofVar::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MIRSymbol *varSymbol = varSrc->GenerateMIRSymbol(mirBuilder);
+  if (cst != nullptr) {
+    varSymbol->SetKonst(cst);
+  }
+  MIRType *type = varSrc->GetType()->GenerateMIRTypeAuto();
+  if (fieldID != 0) {
+    CHECK_FATAL((type->IsMIRStructType() || type->GetKind() == MIRTypeKind::kTypeUnion),
+                "if fieldID is not 0, then the variable must be a structure");
+  }
+  AddrofNode *node = mirBuilder.CreateExprAddrof(fieldID, *varSymbol);
+  return node;
+}
+
+std::vector<FEIRVar*> FEIRExprAddrofVar::GetVarUsesImpl() const {
+  return std::vector<FEIRVar*>({ varSrc.get() });
+}
+
+// ---------- FEIRExprAddrofFunc ----------
+std::unique_ptr<FEIRExpr> FEIRExprAddrofFunc::CloneImpl() const {
+  auto expr = std::make_unique<FEIRExprAddrofFunc>(funcAddr);
+  return expr;
+}
+
+BaseNode *FEIRExprAddrofFunc::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(funcAddr);
+  MIRFunction *mirFunc = FEManager::GetTypeManager().GetMIRFunction(strIdx, false);
+  CHECK_FATAL(mirFunc != nullptr, "can not get MIRFunction");
+  return mirBuilder.CreateExprAddroffunc(mirFunc->GetPuidx(),
+                                         mirBuilder.GetMirModule().GetMemPool());
+}
+
+// ---------- FEIRExprAddrofArray ----------
+FEIRExprAddrofArray::FEIRExprAddrofArray(UniqueFEIRType argTypeNativeArray, UniqueFEIRExpr argExprArray,
+                                         const std::string &argArrayName, std::list<UniqueFEIRExpr> &argExprIndexs)
+    : FEIRExpr(FEIRNodeKind::kExprAddrofArray,
+               FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())),
+      typeNativeArray(std::move(argTypeNativeArray)),
+      exprArray(std::move(argExprArray)),
+      arrayName(argArrayName) {
+  SetIndexsExprs(argExprIndexs);
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprAddrofArray::CloneImpl() const {
+  UniqueFEIRType uTypeNativeArray = typeNativeArray->Clone();
+  UniqueFEIRExpr uExprArray = exprArray->Clone();
+  auto feirExprAddrofArray = std::make_unique<FEIRExprAddrofArray>(std::move(uTypeNativeArray),
+                                                                   std::move(uExprArray), arrayName,
+                                                                   exprIndexs);
+  feirExprAddrofArray->SetIndexsExprs(exprIndexs);
+  return feirExprAddrofArray;
+}
+
+std::vector<FEIRVar*> FEIRExprAddrofArray::GetVarUsesImpl() const {
+  return exprArray->GetVarUses();
+}
+
+BaseNode *FEIRExprAddrofArray::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MIRType *ptrMIRArrayType = typeNativeArray->GenerateMIRType(false);
+  BaseNode *nodeAddrof = nullptr;
+  std::vector<BaseNode*> nds;
+  if (!arrayName.empty()) {
+    std::unique_ptr<FEIRVar> arrayVar = exprArray->GetVarUses().front()->Clone();
+    MIRSymbol *mirSymbol = arrayVar->GenerateMIRSymbol(mirBuilder);
+    if (ptrMIRArrayType->GetKind() == kTypeArray) {
+      mirSymbol->SetTyIdx(ptrMIRArrayType->GetTypeIndex());
+      nodeAddrof = mirBuilder.CreateExprAddrof(0, *mirSymbol);
+    } else {
+      nodeAddrof = mirBuilder.CreateDread(*mirSymbol, PTY_ptr);
+    }
+  } else {
+    nodeAddrof = exprArray->GenMIRNode(mirBuilder);
+  }
+  nds.push_back(nodeAddrof);
+  for (auto &e : exprIndexs) {
+    BaseNode *no = e->GenMIRNode(mirBuilder);
+    nds.push_back(no);
+  }
+  BaseNode *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, nds);
+  return arrayExpr;
+}
+
+// ---------- FEIRExprRegRead ----------
+FEIRExprRegRead::FEIRExprRegRead(PrimType pty, int32 regNumIn)
+    : FEIRExpr(FEIRNodeKind::kExprRegRead), prmType(pty), regNum(regNumIn) {}
+
+std::unique_ptr<FEIRExpr> FEIRExprRegRead::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprRegRead>(prmType, regNum);
+  return expr;
+}
+
+BaseNode *FEIRExprRegRead::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  RegreadNode *node = mirBuilder.CreateExprRegread(prmType, regNum);
+  return node;
+}
+
+void FEIRExprDRead::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  checkPoint.RegisterDFGNode(varSrc);
+}
+
+bool FEIRExprDRead::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  std::set<UniqueFEIRVar*> defs = checkPoint.CalcuDef(varSrc);
+  (void)udChain.insert(std::make_pair(&varSrc, defs));
+  return (defs.size() > 0);
+}
+
+// ---------- FEIRExprUnary ----------
+std::map<Opcode, bool> FEIRExprUnary::mapOpNestable = FEIRExprUnary::InitMapOpNestableForExprUnary();
+
+FEIRExprUnary::FEIRExprUnary(Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd)
+    : FEIRExpr(kExprUnary),
+      op(argOp) {
+  SetOpnd(std::move(argOpnd));
+  SetExprTypeByOp();
+}
+
+FEIRExprUnary::FEIRExprUnary(std::unique_ptr<FEIRType> argType, Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd)
+    : FEIRExpr(kExprUnary, std::move(argType)),
+      op(argOp) {
+  SetOpnd(std::move(argOpnd));
+}
+
+std::map<Opcode, bool> FEIRExprUnary::InitMapOpNestableForExprUnary() {
+  std::map<Opcode, bool> ans;
+  ans[OP_abs] = true;
+  ans[OP_bnot] = true;
+  ans[OP_lnot] = true;
+  ans[OP_neg] = true;
+  ans[OP_recip] = true;
+  ans[OP_sqrt] = true;
+  ans[OP_gcmallocjarray] = false;
+  return ans;
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprUnary::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprUnary>(type->Clone(), op, opnd->Clone());
+  return expr;
+}
+
+BaseNode *FEIRExprUnary::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(
+      TyIdx(static_cast<uint32>(GetTypeRef().GetPrimType())));
+  ASSERT(mirType != nullptr, "mir type is nullptr");
+  BaseNode *nodeOpnd = opnd->GenMIRNode(mirBuilder);
+  BaseNode *expr = mirBuilder.CreateExprUnary(op, *mirType, nodeOpnd);
+  return expr;
+}
+
+void FEIRExprUnary::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  opnd->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRExprUnary::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return opnd->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+std::vector<FEIRVar*> FEIRExprUnary::GetVarUsesImpl() const {
+  return opnd->GetVarUses();
+}
+
+void FEIRExprUnary::SetOpnd(std::unique_ptr<FEIRExpr> argOpnd) {
+  CHECK_FATAL(argOpnd != nullptr, "opnd is nullptr");
+  opnd = std::move(argOpnd);
+}
+
+const UniqueFEIRExpr &FEIRExprUnary::GetOpnd() const {
+  return opnd;
+}
+
+void FEIRExprUnary::SetExprTypeByOp() {
+  switch (op) {
+    case OP_neg:
+    case OP_bnot:
+    case OP_lnot:
+      type->SetPrimType(opnd->GetPrimType());
+      break;
+    default:
+      break;
+  }
+}
+
+// ---------- FEIRExprTypeCvt ----------
+std::map<Opcode, bool> FEIRExprTypeCvt::mapOpNestable = FEIRExprTypeCvt::InitMapOpNestableForTypeCvt();
+std::map<Opcode, FEIRExprTypeCvt::FuncPtrGenMIRNode> FEIRExprTypeCvt::funcPtrMapForParseExpr =
+    FEIRExprTypeCvt::InitFuncPtrMapForParseExpr();
+
+FEIRExprTypeCvt::FEIRExprTypeCvt(Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd)
+    : FEIRExprUnary(argOp, std::move(argOpnd)) {}
+
+FEIRExprTypeCvt::FEIRExprTypeCvt(std::unique_ptr<FEIRType> exprType, Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd)
+    : FEIRExprUnary(std::move(exprType), argOp, std::move(argOpnd)) {}
+
+std::unique_ptr<FEIRExpr> FEIRExprTypeCvt::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprTypeCvt>(type->Clone(), op, opnd->Clone());
+  static_cast<FEIRExprTypeCvt*>(expr.get())->SetSrcPrimType(srcPrimType);
+  return expr;
+}
+
+BaseNode *FEIRExprTypeCvt::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  auto ptrFunc = funcPtrMapForParseExpr.find(op);
+  ASSERT(ptrFunc != funcPtrMapForParseExpr.cend(), "unsupported op: %s", kOpcodeInfo.GetName(op).c_str());
+  return (this->*(ptrFunc->second))(mirBuilder);
+}
+
+void FEIRExprTypeCvt::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  opnd->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRExprTypeCvt::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return opnd->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+Opcode FEIRExprTypeCvt::ChooseOpcodeByFromVarAndToVar(const FEIRVar &fromVar, const FEIRVar &toVar) {
+  if ((fromVar.GetType()->IsRef()) && (toVar.GetType()->IsRef())) {
+    return OP_retype;
+  }
+  return OP_retype;
+}
+
+BaseNode *FEIRExprTypeCvt::GenMIRNodeMode1(MIRBuilder &mirBuilder) const {
+  // MIR: op <to-type> <from-type> (<opnd0>)
+  MIRType *mirTypeDst =
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(static_cast<uint32>(GetTypeRef().GetPrimType())));
+  MIRType *mirTypeSrc = nullptr;
+  if (srcPrimType == PTY_unknown) {
+    mirTypeSrc = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(static_cast<uint32>(opnd->GetPrimType())));
+  } else {
+    mirTypeSrc = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(static_cast<uint32>(srcPrimType)));
+  }
+  BaseNode *nodeOpnd = opnd->GenMIRNode(mirBuilder);
+  BaseNode *expr = mirBuilder.CreateExprTypeCvt(op, *mirTypeDst, *mirTypeSrc, nodeOpnd);
+  return expr;
+}
+
+BaseNode *FEIRExprTypeCvt::GenMIRNodeMode2(MIRBuilder &mirBuilder) const {
+  // MIR: op <prim-type> <float-type> (<opnd0>)
+  PrimType primTypeSrc = opnd->GetPrimType();
+  CHECK_FATAL(IsPrimitiveFloat(primTypeSrc), "from type must be float type");
+  return GenMIRNodeMode1(mirBuilder);
+}
+
+BaseNode *FEIRExprTypeCvt::GenMIRNodeMode3(MIRBuilder &mirBuilder) const {
+  // MIR: retype <prim-type> <type> (<opnd0>)
+  MIRType *mirTypeDst = GetTypeRef().GenerateMIRType();
+  MIRType *mirTypeSrc = opnd->GetTypeRef().GenerateMIRTypeAuto();
+  BaseNode *nodeOpnd = opnd->GenMIRNode(mirBuilder);
+  BaseNode *expr = mirBuilder.CreateExprRetype(*mirTypeDst, *mirTypeSrc, nodeOpnd);
+  return expr;
+}
+
+std::map<Opcode, bool> FEIRExprTypeCvt::InitMapOpNestableForTypeCvt() {
+  std::map<Opcode, bool> ans;
+  ans[OP_ceil] = true;
+  ans[OP_cvt] = true;
+  ans[OP_floor] = true;
+  ans[OP_retype] = true;
+  ans[OP_round] = true;
+  ans[OP_trunc] = true;
+  return ans;
+}
+
+std::map<Opcode, FEIRExprTypeCvt::FuncPtrGenMIRNode> FEIRExprTypeCvt::InitFuncPtrMapForParseExpr() {
+  std::map<Opcode, FuncPtrGenMIRNode> ans;
+  ans[OP_ceil] = &FEIRExprTypeCvt::GenMIRNodeMode2;
+  ans[OP_cvt] = &FEIRExprTypeCvt::GenMIRNodeMode1;
+  ans[OP_floor] = &FEIRExprTypeCvt::GenMIRNodeMode2;
+  ans[OP_retype] = &FEIRExprTypeCvt::GenMIRNodeMode3;
+  ans[OP_round] = &FEIRExprTypeCvt::GenMIRNodeMode2;
+  ans[OP_trunc] = &FEIRExprTypeCvt::GenMIRNodeMode2;
+  return ans;
+}
+
+// ---------- FEIRExprExtractBits ----------
+std::map<Opcode, bool> FEIRExprExtractBits::mapOpNestable = FEIRExprExtractBits::InitMapOpNestableForExtractBits();
+std::map<Opcode, FEIRExprExtractBits::FuncPtrGenMIRNode> FEIRExprExtractBits::funcPtrMapForParseExpr =
+    FEIRExprExtractBits::InitFuncPtrMapForParseExpr();
+
+FEIRExprExtractBits::FEIRExprExtractBits(Opcode argOp, PrimType argPrimType, uint8 argBitOffset, uint8 argBitSize,
+                                         std::unique_ptr<FEIRExpr> argOpnd)
+    : FEIRExprUnary(argOp, std::move(argOpnd)),
+      bitOffset(argBitOffset),
+      bitSize(argBitSize) {
+  CHECK_FATAL(IsPrimitiveInteger(argPrimType), "only integer type is supported");
+  type->SetPrimType(argPrimType);
+}
+
+FEIRExprExtractBits::FEIRExprExtractBits(Opcode argOp, PrimType argPrimType, std::unique_ptr<FEIRExpr> argOpnd)
+    : FEIRExprExtractBits(argOp, argPrimType, 0, 0, std::move(argOpnd)) {}
+
+std::unique_ptr<FEIRExpr> FEIRExprExtractBits::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprExtractBits>(op, type->GetPrimType(), bitOffset, bitSize,
+                                                                         opnd->Clone());
+  return expr;
+}
+
+BaseNode *FEIRExprExtractBits::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  auto ptrFunc = funcPtrMapForParseExpr.find(op);
+  ASSERT(ptrFunc != funcPtrMapForParseExpr.cend(), "unsupported op: %s", kOpcodeInfo.GetName(op).c_str());
+  return (this->*(ptrFunc->second))(mirBuilder);
+}
+
+void FEIRExprExtractBits::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  opnd->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRExprExtractBits::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return opnd->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+std::map<Opcode, bool> FEIRExprExtractBits::InitMapOpNestableForExtractBits() {
+  std::map<Opcode, bool> ans;
+  ans[OP_extractbits] = true;
+  ans[OP_sext] = true;
+  ans[OP_zext] = true;
+  return ans;
+}
+
+std::map<Opcode, FEIRExprExtractBits::FuncPtrGenMIRNode> FEIRExprExtractBits::InitFuncPtrMapForParseExpr() {
+  std::map<Opcode, FuncPtrGenMIRNode> ans;
+  ans[OP_extractbits] = &FEIRExprExtractBits::GenMIRNodeForExtrabits;
+  ans[OP_sext] = &FEIRExprExtractBits::GenMIRNodeForExt;
+  ans[OP_zext] = &FEIRExprExtractBits::GenMIRNodeForExt;
+  return ans;
+}
+
+BaseNode *FEIRExprExtractBits::GenMIRNodeForExtrabits(MIRBuilder &mirBuilder) const {
+  ASSERT(opnd != nullptr, "nullptr check");
+  PrimType primTypeDst = GetTypeRef().GetPrimType();
+  PrimType primTypeSrc = opnd->GetPrimType();
+  CHECK_FATAL(FEUtils::IsInteger(primTypeDst), "dst type of extrabits must integer");
+  CHECK_FATAL(FEUtils::IsInteger(primTypeSrc), "src type of extrabits must integer");
+  uint8 widthDst = FEUtils::GetWidth(primTypeDst);
+  uint8 widthSrc = FEUtils::GetWidth(primTypeSrc);
+  CHECK_FATAL(widthDst >= bitSize, "dst width is not enough");
+  CHECK_FATAL(widthSrc >= bitOffset + bitSize, "src width is not enough");
+  MIRType *mirTypeDst = GetTypeRef().GenerateMIRTypeAuto();
+  BaseNode *nodeOpnd = opnd->GenMIRNode(mirBuilder);
+  BaseNode *expr = mirBuilder.CreateExprExtractbits(op, *mirTypeDst, bitOffset, bitSize, nodeOpnd);
+  return expr;
+}
+
+BaseNode *FEIRExprExtractBits::GenMIRNodeForExt(MIRBuilder &mirBuilder) const {
+  ASSERT(opnd != nullptr, "nullptr check");
+  PrimType primTypeDst = GetTypeRef().GetPrimType();
+  CHECK_FATAL(FEUtils::IsInteger(primTypeDst), "dst type of sext/zext must integer");
+  uint8 widthDst = FEUtils::GetWidth(primTypeDst);
+  // The bit size must be smaller than 32. This parameter is used only when the value of src or dst is smaller than 32.
+  if (widthDst >= 32) {
+    widthDst = FEUtils::GetWidth(opnd->GetPrimType());
+  }
+  BaseNode *nodeOpnd = opnd->GenMIRNode(mirBuilder);
+  PrimType extPty;
+  if (op == OP_zext) {
+    extPty = GetUnsignedPrimType(GetRegPrimType(nodeOpnd->GetPrimType()));
+  } else {
+    extPty = GetSignedPrimType(GetRegPrimType(nodeOpnd->GetPrimType()));
+  }
+  MIRType *mirTypeDst = GlobalTables::GetTypeTable().GetPrimType(extPty);
+  BaseNode *expr = mirBuilder.CreateExprExtractbits(op, *mirTypeDst, 0, widthDst, nodeOpnd);
+  return expr;
+}
+
+// ---------- FEIRExprBinary ----------
+std::map<Opcode, FEIRExprBinary::FuncPtrGenMIRNode> FEIRExprBinary::funcPtrMapForGenMIRNode =
+    FEIRExprBinary::InitFuncPtrMapForGenMIRNode();
+
+FEIRExprBinary::FEIRExprBinary(Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd0, std::unique_ptr<FEIRExpr> argOpnd1)
+    : FEIRExpr(FEIRNodeKind::kExprBinary),
+      op(argOp) {
+  SetOpnd0(std::move(argOpnd0));
+  SetOpnd1(std::move(argOpnd1));
+  SetExprTypeByOp();
+}
+
+FEIRExprBinary::FEIRExprBinary(std::unique_ptr<FEIRType> exprType, Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd0,
+                               std::unique_ptr<FEIRExpr> argOpnd1)
+    : FEIRExpr(FEIRNodeKind::kExprBinary, std::move(exprType)),
+      op(argOp) {
+  SetOpnd0(std::move(argOpnd0));
+  SetOpnd1(std::move(argOpnd1));
+  if (FEManager::GetModule().GetSrcLang() != kSrcLangC) {
+    SetExprTypeByOp();
+  }
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprBinary::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprBinary>(type->Clone(), op, opnd0->Clone(), opnd1->Clone());
+  return expr;
+}
+
+BaseNode *FEIRExprBinary::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  auto ptrFunc = funcPtrMapForGenMIRNode.find(op);
+  ASSERT(ptrFunc != funcPtrMapForGenMIRNode.cend(), "unsupported op: %s", kOpcodeInfo.GetName(op).c_str());
+  return (this->*(ptrFunc->second))(mirBuilder);
+}
+
+void FEIRExprBinary::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  opnd0->RegisterDFGNodes2CheckPoint(checkPoint);
+  opnd1->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRExprBinary::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  success = success && opnd0->CalculateDefs4AllUses(checkPoint, udChain);
+  success = success && opnd1->CalculateDefs4AllUses(checkPoint, udChain);
+  return success;
+}
+
+std::vector<FEIRVar*> FEIRExprBinary::GetVarUsesImpl() const {
+  std::vector<FEIRVar*> ans;
+  for (FEIRVar *var : opnd0->GetVarUses()) {
+    ans.push_back(var);
+  }
+  for (FEIRVar *var : opnd1->GetVarUses()) {
+    ans.push_back(var);
+  }
+  return ans;
+}
+
+bool FEIRExprBinary::IsNestableImpl() const {
+  return true;
+}
+
+bool FEIRExprBinary::IsAddrofImpl() const {
+  return false;
+}
+
+void FEIRExprBinary::SetOpnd0(std::unique_ptr<FEIRExpr> argOpnd) {
+  CHECK_FATAL(argOpnd != nullptr, "input is nullptr");
+  opnd0 = std::move(argOpnd);
+}
+
+void FEIRExprBinary::SetOpnd1(std::unique_ptr<FEIRExpr> argOpnd) {
+  CHECK_FATAL(argOpnd != nullptr, "input is nullptr");
+  opnd1 = std::move(argOpnd);
+}
+
+const std::unique_ptr<FEIRExpr> &FEIRExprBinary::GetOpnd0() const {
+  return opnd0;
+}
+
+const std::unique_ptr<FEIRExpr> &FEIRExprBinary::GetOpnd1() const {
+  return opnd1;
+}
+
+bool FEIRExprBinary::IsComparative() const {
+  switch (op) {
+    case OP_cmp:
+    case OP_cmpl:
+    case OP_cmpg:
+    case OP_eq:
+    case OP_ge:
+    case OP_gt:
+    case OP_le:
+    case OP_lt:
+    case OP_ne:
+    // Cand and cior do not need to be converted to comparison.
+    case OP_cand:
+    case OP_cior:
+      return true;
+    default:
+      return false;
+  }
+}
+
+std::map<Opcode, FEIRExprBinary::FuncPtrGenMIRNode> FEIRExprBinary::InitFuncPtrMapForGenMIRNode() {
+  std::map<Opcode, FEIRExprBinary::FuncPtrGenMIRNode> ans;
+  ans[OP_add] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_ashr] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_band] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_bior] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_bxor] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_cand] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_cior] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_cmp] = &FEIRExprBinary::GenMIRNodeCompare;
+  ans[OP_cmpg] = &FEIRExprBinary::GenMIRNodeCompare;
+  ans[OP_cmpl] = &FEIRExprBinary::GenMIRNodeCompare;
+  ans[OP_div] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_eq] = &FEIRExprBinary::GenMIRNodeCompareU1;
+  ans[OP_ge] = &FEIRExprBinary::GenMIRNodeCompareU1;
+  ans[OP_gt] = &FEIRExprBinary::GenMIRNodeCompareU1;
+  ans[OP_land] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_lior] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_le] = &FEIRExprBinary::GenMIRNodeCompareU1;
+  ans[OP_lshr] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_lt] = &FEIRExprBinary::GenMIRNodeCompareU1;
+  ans[OP_max] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_min] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_mul] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_ne] = &FEIRExprBinary::GenMIRNodeCompareU1;
+  ans[OP_rem] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_shl] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_sub] = &FEIRExprBinary::GenMIRNodeNormal;
+  ans[OP_ror] = &FEIRExprBinary::GenMIRNodeNormal;
+  return ans;
+}
+
+BaseNode *FEIRExprBinary::GenMIRNodeNormal(MIRBuilder &mirBuilder) const {
+  MIRType *mirTypeDst = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(static_cast<uint32>(type->GetPrimType())));
+  UniqueFEIRExpr opnd0FEExpr = opnd0->Clone();
+  UniqueFEIRExpr opnd1FEExpr = opnd1->Clone();
+  if (op == OP_cand || op == OP_cior) {
+    opnd0FEExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(opnd0FEExpr));
+    opnd1FEExpr = FEIRBuilder::CreateExprZeroCompare(OP_ne, std::move(opnd1FEExpr));
+  }
+  BaseNode *nodeOpnd0 = opnd0FEExpr->GenMIRNode(mirBuilder);
+  BaseNode *nodeOpnd1 = opnd1FEExpr->GenMIRNode(mirBuilder);
+  BaseNode *expr = mirBuilder.CreateExprBinary(op, *mirTypeDst, nodeOpnd0, nodeOpnd1);
+  return expr;
+}
+
+BaseNode *FEIRExprBinary::GenMIRNodeCompare(MIRBuilder &mirBuilder) const {
+  BaseNode *nodeOpnd0 = opnd0->GenMIRNode(mirBuilder);
+  BaseNode *nodeOpnd1 = opnd1->GenMIRNode(mirBuilder);
+  MIRType *mirTypeSrc = GlobalTables::GetTypeTable().GetTypeFromTyIdx(
+      TyIdx(static_cast<uint32>(nodeOpnd0->GetPrimType())));
+  MIRType *mirTypeDst = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(static_cast<uint32>(type->GetPrimType())));
+  BaseNode *expr = mirBuilder.CreateExprCompare(op, *mirTypeDst, *mirTypeSrc, nodeOpnd0, nodeOpnd1);
+  return expr;
+}
+
+BaseNode *FEIRExprBinary::GenMIRNodeCompareU1(MIRBuilder &mirBuilder) const {
+  BaseNode *nodeOpnd0 = opnd0->GenMIRNode(mirBuilder);
+  BaseNode *nodeOpnd1 = opnd1->GenMIRNode(mirBuilder);
+  PrimType srcType0 = nodeOpnd0->GetPrimType();
+  PrimType srcType1 = nodeOpnd1->GetPrimType();
+  // We take the bigger one as srcType
+  PrimType srcType = GetPrimTypeActualBitSize(srcType0) > GetPrimTypeActualBitSize(srcType1) ? srcType0 : srcType1;
+  MIRType *mirTypeSrc = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(static_cast<uint32>(srcType)));
+  // If the src type is a vector type, there is no need to use u1 to replace
+  MIRType *mirTypeDst = type->GenerateMIRTypeAuto();
+  if (!PrimitiveType(mirTypeDst->GetPrimType()).IsVector()) {
+    mirTypeDst = GlobalTables::GetTypeTable().GetUInt1();
+  }
+  BaseNode *expr = mirBuilder.CreateExprCompare(op, *mirTypeDst, *mirTypeSrc, nodeOpnd0, nodeOpnd1);
+  return expr;
+}
+
+void FEIRExprBinary::SetExprTypeByOp() {
+  switch (op) {
+    // Normal
+    case OP_add:
+    case OP_div:
+    case OP_max:
+    case OP_min:
+    case OP_mul:
+    case OP_rem:
+    case OP_sub:
+      SetExprTypeByOpNormal();
+      break;
+    // Shift
+    case OP_ashr:
+    case OP_lshr:
+    case OP_shl:
+    case OP_ror:
+      SetExprTypeByOpShift();
+      break;
+    // Logic
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_cand:
+    case OP_cior:
+    case OP_land:
+    case OP_lior:
+      SetExprTypeByOpLogic();
+      break;
+    // Compare
+    case OP_cmp:
+    case OP_cmpl:
+    case OP_cmpg:
+    case OP_eq:
+    case OP_ge:
+    case OP_gt:
+    case OP_le:
+    case OP_lt:
+    case OP_ne:
+      SetExprTypeByOpCompare();
+      break;
+    default:
+      break;
+  }
+}
+
+void FEIRExprBinary::SetExprTypeByOpNormal() {
+  PrimType primTypeOpnd0 = opnd0->GetPrimType();
+  PrimType primTypeOpnd1 = opnd1->GetPrimType();
+  // primTypeOpnd0 == PTY_void for addrof add
+  if (primTypeOpnd0 == PTY_ptr || primTypeOpnd1 == PTY_ptr || primTypeOpnd0 == PTY_void) {
+    type->SetPrimType(PTY_ptr);
+    return;
+  }
+  type->SetPrimType(primTypeOpnd0);
+}
+
+void FEIRExprBinary::SetExprTypeByOpShift() {
+  PrimType primTypeOpnd0 = opnd0->GetPrimType();
+  PrimType primTypeOpnd1 = opnd1->GetPrimType();
+  CHECK_FATAL(IsPrimitiveInteger(primTypeOpnd0), "logic's opnd0 must be integer");
+  CHECK_FATAL(IsPrimitiveInteger(primTypeOpnd1), "logic's opnd1 must be integer");
+  type->SetPrimType(primTypeOpnd0);
+}
+
+void FEIRExprBinary::SetExprTypeByOpLogic() {
+  PrimType primTypeOpnd0 = opnd0->GetPrimType();
+  CHECK_FATAL(IsPrimitiveInteger(primTypeOpnd0), "logic's opnds must be integer");
+  type->SetPrimType(primTypeOpnd0);
+}
+
+void FEIRExprBinary::SetExprTypeByOpCompare() {
+  type->SetPrimType(PTY_i32);
+}
+
+// ---------- FEIRExprTernary ----------
+FEIRExprTernary::FEIRExprTernary(Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd0, std::unique_ptr<FEIRExpr> argOpnd1,
+                                 std::unique_ptr<FEIRExpr> argOpnd2)
+    : FEIRExpr(FEIRNodeKind::kExprTernary),
+      op(argOp) {
+  SetOpnd(std::move(argOpnd0), 0);
+  SetOpnd(std::move(argOpnd1), 1);
+  SetOpnd(std::move(argOpnd2), 2);
+  SetExprTypeByOp();
+}
+
+FEIRExprTernary::FEIRExprTernary(Opcode argOp, std::unique_ptr<FEIRType> argType, std::unique_ptr<FEIRExpr> argOpnd0,
+                                 std::unique_ptr<FEIRExpr> argOpnd1, std::unique_ptr<FEIRExpr> argOpnd2)
+    : FEIRExpr(FEIRNodeKind::kExprTernary, std::move(argType)),
+      op(argOp) {
+  SetOpnd(std::move(argOpnd0), 0);
+  SetOpnd(std::move(argOpnd1), 1);
+  SetOpnd(std::move(argOpnd2), 2);
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprTernary::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprTernary>(op, type->Clone(), opnd0->Clone(), opnd1->Clone(),
+                                                                     opnd2->Clone());
+  return expr;
+}
+
+BaseNode *FEIRExprTernary::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MIRType *mirTypeDst = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(static_cast<uint32>(type->GetPrimType())));
+  BaseNode *nodeOpnd0 = opnd0->GenMIRNode(mirBuilder);
+  BaseNode *nodeOpnd1 = opnd1->GenMIRNode(mirBuilder);
+  BaseNode *nodeOpnd2 = opnd2->GenMIRNode(mirBuilder);
+  BaseNode *expr = mirBuilder.CreateExprTernary(op, *mirTypeDst, nodeOpnd0, nodeOpnd1, nodeOpnd2);
+  return expr;
+}
+
+void FEIRExprTernary::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  opnd0->RegisterDFGNodes2CheckPoint(checkPoint);
+  opnd1->RegisterDFGNodes2CheckPoint(checkPoint);
+  opnd2->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRExprTernary::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  success = success && opnd0->CalculateDefs4AllUses(checkPoint, udChain);
+  success = success && opnd1->CalculateDefs4AllUses(checkPoint, udChain);
+  success = success && opnd2->CalculateDefs4AllUses(checkPoint, udChain);
+  return success;
+}
+
+std::vector<FEIRVar*> FEIRExprTernary::GetVarUsesImpl() const {
+  std::vector<FEIRVar*> ans;
+  for (FEIRVar *var : opnd0->GetVarUses()) {
+    ans.push_back(var);
+  }
+  for (FEIRVar *var : opnd1->GetVarUses()) {
+    ans.push_back(var);
+  }
+  for (FEIRVar *var : opnd2->GetVarUses()) {
+    ans.push_back(var);
+  }
+  return ans;
+}
+
+bool FEIRExprTernary::IsNestableImpl() const {
+  return true;
+}
+
+bool FEIRExprTernary::IsAddrofImpl() const {
+  return false;
+}
+
+void FEIRExprTernary::SetOpnd(std::unique_ptr<FEIRExpr> argOpnd, uint32 idx) {
+  CHECK_FATAL(argOpnd != nullptr, "input is nullptr");
+  switch (idx) {
+    case 0:
+      opnd0 = std::move(argOpnd);
+      break;
+    case 1:
+      opnd1 = std::move(argOpnd);
+      break;
+    case 2:
+      opnd2 = std::move(argOpnd);
+      break;
+    default:
+      CHECK_FATAL(false, "index out of range");
+  }
+}
+
+void FEIRExprTernary::SetExprTypeByOp() {
+  PrimType primTypeOpnd1 = opnd1->GetPrimType();
+  type->SetPrimType(primTypeOpnd1);
+}
+
+// ---------- FEIRExprNary ----------
+FEIRExprNary::FEIRExprNary(Opcode argOp)
+    : FEIRExpr(FEIRNodeKind::kExprNary),
+      op(argOp) {}
+
+std::vector<FEIRVar*> FEIRExprNary::GetVarUsesImpl() const {
+  std::vector<FEIRVar*> ans;
+  for (const std::unique_ptr<FEIRExpr> &opnd : opnds) {
+    for (FEIRVar *var : opnd->GetVarUses()) {
+      ans.push_back(var);
+    }
+  }
+  return ans;
+}
+
+void FEIRExprNary::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  for (const std::unique_ptr<FEIRExpr> &opnd : opnds) {
+    opnd->RegisterDFGNodes2CheckPoint(checkPoint);
+  }
+}
+
+bool FEIRExprNary::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  for (const std::unique_ptr<FEIRExpr> &opnd : opnds) {
+    success = success && opnd->CalculateDefs4AllUses(checkPoint, udChain);
+  }
+  return success;
+}
+
+void FEIRExprNary::AddOpnd(std::unique_ptr<FEIRExpr> argOpnd) {
+  CHECK_FATAL(argOpnd != nullptr, "input opnd is nullptr");
+  opnds.push_back(std::move(argOpnd));
+}
+
+void FEIRExprNary::AddOpnds(const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds) {
+  for (const std::unique_ptr<FEIRExpr> &opnd : argOpnds) {
+    ASSERT_NOT_NULL(opnd);
+    AddOpnd(opnd->Clone());
+  }
+}
+
+void FEIRExprNary::ResetOpnd() {
+  opnds.clear();
+}
+
+// ---------- FEIRExprIntrinsicop ----------
+FEIRExprIntrinsicop::FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID)
+    : FEIRExprNary(OP_intrinsicop),
+      intrinsicID(argIntrinsicID) {
+  kind = FEIRNodeKind::kExprIntrinsicop;
+  SetType(std::move(exprType));
+}
+
+FEIRExprIntrinsicop::FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                                         std::unique_ptr<FEIRType> argParamType)
+    : FEIRExprNary(OP_intrinsicopwithtype),
+      intrinsicID(argIntrinsicID) {
+  kind = FEIRNodeKind::kExprIntrinsicop;
+  SetType(std::move(exprType));
+  paramType = std::move(argParamType);
+}
+
+FEIRExprIntrinsicop::FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                                         const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds)
+    : FEIRExprIntrinsicop(std::move(exprType), argIntrinsicID) {
+  AddOpnds(argOpnds);
+}
+
+FEIRExprIntrinsicop::FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                                         std::unique_ptr<FEIRType> argParamType,
+                                         const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds)
+    : FEIRExprIntrinsicop(std::move(exprType), argIntrinsicID, std::move(argParamType)) {
+  AddOpnds(argOpnds);
+}
+
+FEIRExprIntrinsicop::FEIRExprIntrinsicop(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                                         std::unique_ptr<FEIRType> argParamType, uint32 argTypeID)
+    : FEIRExprNary(OP_intrinsicopwithtype),
+      intrinsicID(argIntrinsicID),
+      typeID(argTypeID) {
+  kind = FEIRNodeKind::kExprIntrinsicop;
+  SetType(std::move(exprType));
+  paramType = std::move(argParamType);
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprIntrinsicop::CloneImpl() const {
+  if (op == OP_intrinsicop) {
+    return std::make_unique<FEIRExprIntrinsicop>(type->Clone(), intrinsicID, opnds);
+  } else {
+    CHECK_FATAL(paramType != nullptr, "error: param type is not set");
+    return std::make_unique<FEIRExprIntrinsicop>(type->Clone(), intrinsicID, paramType->Clone(), opnds);
+  }
+}
+
+BaseNode *FEIRExprIntrinsicop::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (const auto &e : opnds) {
+    BaseNode *node = e->GenMIRNode(mirBuilder);
+    args.emplace_back(node);
+  }
+  (void)typeID;
+  MIRType *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(
+      *(type->GenerateMIRType()), paramType->IsRef() ? PTY_ref : PTY_ptr);
+  BaseNode *expr = mirBuilder.CreateExprIntrinsicop(intrinsicID, op, *ptrType, std::move(args));
+  return expr;
+}
+
+void FEIRExprIntrinsicop::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  for (const std::unique_ptr<FEIRExpr> &opnd : opnds) {
+    opnd->RegisterDFGNodes2CheckPoint(checkPoint);
+  }
+}
+
+bool FEIRExprIntrinsicop::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  for (const std::unique_ptr<FEIRExpr> &opnd : opnds) {
+    success = success && opnd->CalculateDefs4AllUses(checkPoint, udChain);
+  }
+  return success;
+}
+
+bool FEIRExprIntrinsicop::IsNestableImpl() const {
+  return false;
+}
+
+bool FEIRExprIntrinsicop::IsAddrofImpl() const {
+  return false;
+}
+
+// ---------- FEIRExprIntrinsicopForC ----------
+FEIRExprIntrinsicopForC::FEIRExprIntrinsicopForC(std::unique_ptr<FEIRType> exprType, MIRIntrinsicID argIntrinsicID,
+                                                 const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds)
+    : FEIRExprNary(OP_intrinsicop),
+      intrinsicID(argIntrinsicID) {
+  kind = FEIRNodeKind::kExprIntrinsicop;
+  SetType(std::move(exprType));
+  AddOpnds(argOpnds);
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprIntrinsicopForC::CloneImpl() const {
+  return std::make_unique<FEIRExprIntrinsicopForC>(type->Clone(), intrinsicID, opnds);
+}
+
+BaseNode *FEIRExprIntrinsicopForC::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (const auto &e : opnds) {
+    BaseNode *node = e->GenMIRNode(mirBuilder);
+    args.emplace_back(node);
+  }
+  return mirBuilder.CreateExprIntrinsicop(intrinsicID, op,
+                                          *type->GenerateMIRTypeAuto(), MapleVector<BaseNode*>(args));
+}
+
+// ---------- FEIRExprJavaMerge ----------------
+FEIRExprJavaMerge::FEIRExprJavaMerge(std::unique_ptr<FEIRType> mergedTypeArg,
+                                     const std::vector<std::unique_ptr<FEIRExpr>> &argOpnds)
+    : FEIRExprNary(OP_intrinsicop) {
+  SetType(std::move(mergedTypeArg));
+  AddOpnds(argOpnds);
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprJavaMerge::CloneImpl() const {
+  return std::make_unique<FEIRExprJavaMerge>(type->Clone(), opnds);
+}
+
+void FEIRExprJavaMerge::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  for (const std::unique_ptr<FEIRExpr> &opnd : opnds) {
+    opnd->RegisterDFGNodes2CheckPoint(checkPoint);
+  }
+}
+
+bool FEIRExprJavaMerge::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  for (const std::unique_ptr<FEIRExpr> &opnd : opnds) {
+    success = success && opnd->CalculateDefs4AllUses(checkPoint, udChain);
+  }
+  return success;
+}
+
+BaseNode *FEIRExprJavaMerge::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.reserve(opnds.size());
+  for (const auto &e : opnds) {
+    BaseNode *node = e->GenMIRNode(mirBuilder);
+    args.emplace_back(node);
+  }
+  // (intrinsicop u1 JAVA_MERGE (dread i32 %Reg0_I))
+  IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[INTRN_JAVA_MERGE];
+  MIRType *retType = intrinDesc->GetReturnType();
+  BaseNode *intr = mirBuilder.CreateExprIntrinsicop(INTRN_JAVA_MERGE, op, *retType, std::move(args));
+  intr->SetPrimType(type->GetPrimType());
+  return intr;
+}
+
+// ---------- FEIRExprJavaNewInstance ----------
+FEIRExprJavaNewInstance::FEIRExprJavaNewInstance(UniqueFEIRType argType)
+    : FEIRExpr(FEIRNodeKind::kExprJavaNewInstance) {
+  SetType(std::move(argType));
+}
+
+FEIRExprJavaNewInstance::FEIRExprJavaNewInstance(UniqueFEIRType argType, uint32 argTypeID)
+    : FEIRExpr(FEIRNodeKind::kExprJavaNewInstance), typeID(argTypeID) {
+  SetType(std::move(argType));
+}
+
+FEIRExprJavaNewInstance::FEIRExprJavaNewInstance(UniqueFEIRType argType, uint32 argTypeID, bool argIsRcPermanent)
+    : FEIRExpr(FEIRNodeKind::kExprJavaNewInstance), typeID(argTypeID), isRcPermanent(argIsRcPermanent) {
+  SetType(std::move(argType));
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprJavaNewInstance::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprJavaNewInstance>(type->Clone());
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+BaseNode *FEIRExprJavaNewInstance::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MIRType *mirType = type->GenerateMIRType(kSrcLangJava, false);
+  BaseNode *expr = nullptr;
+  MIRType *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType, PTY_ref);
+  Opcode opMalloc = isRcPermanent ? OP_gcpermalloc : OP_gcmalloc;
+  expr = mirBuilder.CreateExprGCMalloc(opMalloc, *ptrType, *mirType);
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+// ---------- FEIRExprJavaNewArray ----------
+FEIRExprJavaNewArray::FEIRExprJavaNewArray(UniqueFEIRType argArrayType, UniqueFEIRExpr argExprSize)
+    : FEIRExpr(FEIRNodeKind::kExprJavaNewArray) {
+  SetArrayType(std::move(argArrayType));
+  SetExprSize(std::move(argExprSize));
+}
+
+FEIRExprJavaNewArray::FEIRExprJavaNewArray(UniqueFEIRType argArrayType, UniqueFEIRExpr argExprSize, uint32 argTypeID)
+    : FEIRExpr(FEIRNodeKind::kExprJavaNewArray), typeID(argTypeID) {
+  SetArrayType(std::move(argArrayType));
+  SetExprSize(std::move(argExprSize));
+}
+
+FEIRExprJavaNewArray::FEIRExprJavaNewArray(UniqueFEIRType argArrayType, UniqueFEIRExpr argExprSize, uint32 argTypeID,
+                                           bool argIsRcPermanent)
+    : FEIRExpr(FEIRNodeKind::kExprJavaNewArray), typeID(argTypeID), isRcPermanent(argIsRcPermanent) {
+  SetArrayType(std::move(argArrayType));
+  SetExprSize(std::move(argExprSize));
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprJavaNewArray::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprJavaNewArray>(arrayType->Clone(), exprSize->Clone());
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+std::vector<FEIRVar*> FEIRExprJavaNewArray::GetVarUsesImpl() const {
+  return exprSize->GetVarUses();
+}
+
+BaseNode *FEIRExprJavaNewArray::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  UniqueFEIRType elemType = FEIRBuilder::CreateArrayElemType(arrayType);
+  MIRType *elemMirType = elemType->GenerateMIRType(kSrcLangJava, false);
+  if (!elemMirType->IsScalarType()) {
+    elemMirType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemMirType, PTY_ptr);
+  }
+  MIRType *jarrayType = GlobalTables::GetTypeTable().GetOrCreateJarrayType(*elemMirType);
+  (void)typeID;
+  MIRType *mirType = arrayType->GenerateMIRType(kSrcLangJava, false);
+  MIRType *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType, PTY_ref);
+  BaseNode *sizeNode = exprSize->GenMIRNode(mirBuilder);
+  Opcode opMalloc = isRcPermanent ? OP_gcpermallocjarray : OP_gcmallocjarray;
+  BaseNode *expr = mirBuilder.CreateExprJarrayMalloc(opMalloc, *ptrType, *jarrayType, sizeNode);
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+void FEIRExprJavaNewArray::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  exprSize->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRExprJavaNewArray::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return exprSize->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+// ---------- FEIRExprJavaArrayLength ----------
+FEIRExprJavaArrayLength::FEIRExprJavaArrayLength(UniqueFEIRExpr argExprArray)
+    : FEIRExpr(FEIRNodeKind::kExprJavaArrayLength) {
+  SetExprArray(std::move(argExprArray));
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprJavaArrayLength::CloneImpl() const {
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprJavaArrayLength>(exprArray->Clone());
+  CHECK_NULL_FATAL(expr);
+  return expr;
+}
+
+std::vector<FEIRVar*> FEIRExprJavaArrayLength::GetVarUsesImpl() const {
+  return exprArray->GetVarUses();
+}
+
+BaseNode *FEIRExprJavaArrayLength::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  BaseNode *arrayNode = exprArray->GenMIRNode(mirBuilder);
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.push_back(arrayNode);
+  MIRType *retType = GlobalTables::GetTypeTable().GetInt32();
+  return mirBuilder.CreateExprIntrinsicop(INTRN_JAVA_ARRAY_LENGTH, OP_intrinsicop, *retType, std::move(args));
+}
+
+void FEIRExprJavaArrayLength::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  exprArray->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRExprJavaArrayLength::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  return exprArray->CalculateDefs4AllUses(checkPoint, udChain);
+}
+
+// ---------- FEIRExprArrayLoad ----------
+FEIRExprArrayLoad::FEIRExprArrayLoad(UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex,
+                                     UniqueFEIRType argTypeArray)
+    : FEIRExpr(FEIRNodeKind::kExprArrayLoad),
+      exprArray(std::move(argExprArray)),
+      exprIndex(std::move(argExprIndex)),
+      typeArray(std::move(argTypeArray)) {}
+
+std::unique_ptr<FEIRExpr> FEIRExprArrayLoad::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprArrayLoad>(exprArray->Clone(), exprIndex->Clone(),
+                                                                       typeArray->Clone());
+  return expr;
+}
+
+BaseNode *FEIRExprArrayLoad::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  CHECK_FATAL(exprArray->GetKind() == kExprDRead, "only support dread expr for exprArray");
+  CHECK_FATAL(exprIndex->GetKind() == kExprDRead, "only support dread expr for exprIndex");
+  BaseNode *addrBase = exprArray->GenMIRNode(mirBuilder);
+  BaseNode *indexBn = exprIndex->GenMIRNode(mirBuilder);
+  MIRType *ptrMIRArrayType = typeArray->GenerateMIRType(false);
+
+  BaseNode *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, addrBase, indexBn);
+  UniqueFEIRType typeElem = typeArray->Clone();
+  (void)typeElem->ArrayDecrDim();
+
+  MIRType *mirElemType = typeElem->GenerateMIRType(true);
+  MIRType *ptrMIRElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirElemType, PTY_ptr);
+  BaseNode *elemBn = mirBuilder.CreateExprIread(*mirElemType, *ptrMIRElemType, 0, arrayExpr);
+  return elemBn;
+}
+
+std::vector<FEIRVar*> FEIRExprArrayLoad::GetVarUsesImpl() const {
+  std::vector<FEIRVar*> ans;
+  for (FEIRVar *var : exprArray->GetVarUses()) {
+    ans.push_back(var);
+  }
+  for (FEIRVar *var : exprIndex->GetVarUses()) {
+    ans.push_back(var);
+  }
+  return ans;
+}
+
+void FEIRExprArrayLoad::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  exprArray->RegisterDFGNodes2CheckPoint(checkPoint);
+  exprIndex->RegisterDFGNodes2CheckPoint(checkPoint);
+}
+
+bool FEIRExprArrayLoad::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  success = success && exprArray->CalculateDefs4AllUses(checkPoint, udChain);
+  success = success && exprIndex->CalculateDefs4AllUses(checkPoint, udChain);
+  return success;
+}
+
+// ---------- FEIRExprCStyleCast ----------
+FEIRExprCStyleCast::FEIRExprCStyleCast(MIRType *src,
+                                       MIRType *dest,
+                                       UniqueFEIRExpr sub,
+                                       bool isArr2Pty)
+    : FEIRExpr(FEIRNodeKind::kExprCStyleCast),
+      srcType(src),
+      destType(dest),
+      subExpr(std::move(sub)),
+      isArray2Pointer(isArr2Pty) {
+  CHECK_NULL_FATAL(dest);
+  type = FEIRTypeHelper::CreateTypeNative(*dest);
+}
+
+std::unique_ptr<FEIRExpr> FEIRExprCStyleCast::CloneImpl() const {
+  auto expr = std::make_unique<FEIRExprCStyleCast>(srcType, destType,
+                                                   subExpr->Clone(), isArray2Pointer);
+  expr->SetRefName(refName);
+  return expr;
+}
+
+std::vector<FEIRVar*> FEIRExprCStyleCast::GetVarUsesImpl() const {
+  return subExpr->GetVarUses();
+}
+
+BaseNode *FEIRExprCStyleCast::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  BaseNode *sub = subExpr.get()->GenMIRNode(mirBuilder);
+  BaseNode *cvt = nullptr;
+  if (isArray2Pointer) {
+    auto *arrayType = static_cast<MIRArrayType*>(srcType);
+    ASSERT(arrayType != nullptr, "ERROR:null pointer!");
+    ArrayNode *arrayNode = mirBuilder.CreateExprArray(*arrayType);
+    MIRSymbol *var = subExpr->GetVarUses().front()->GenerateMIRSymbol(mirBuilder);
+    arrayNode->GetNopnd().push_back(mirBuilder.CreateExprAddrof(0, *var));
+    for (uint8 i = 0; i < arrayType->GetDim(); ++i) {
+      arrayNode->GetNopnd().push_back(mirBuilder.CreateIntConst(0, PTY_i32));
+    }
+    arrayNode->SetNumOpnds(static_cast<uint8>(arrayType->GetDim() + 1));
+    return arrayNode;
+  }
+  auto isCvtNeeded = [](const MIRType &fromNode, const MIRType &toNode) {
+    if (fromNode.EqualTo(toNode)) {
+      return false;
+    }
+    return true;
+  };
+  if (!isCvtNeeded(*srcType, *destType)) {
+    return sub;
+  }
+  if (sub != nullptr && srcType != nullptr && destType != nullptr) {
+    PrimType fromType = srcType->GetPrimType();
+    PrimType toType = destType->GetPrimType();
+    if (fromType == toType || toType == PTY_void || destType->GetKind() == kTypeUnion) {
+      return sub;
+    }
+    if (IsPrimitiveFloat(fromType) && IsPrimitiveInteger(toType)) {
+      if (toType == PTY_u1) {
+        MIRType *mirTypeU1 = GlobalTables::GetTypeTable().GetUInt1();
+        BaseNode *zeroNode = (fromType == PTY_f32) ? mirBuilder.CreateFloatConst(0) : mirBuilder.CreateDoubleConst(0);
+        return mirBuilder.CreateExprCompare(OP_ne, *mirTypeU1, *srcType, sub, zeroNode);
+      }
+      cvt = mirBuilder.CreateExprTypeCvt(OP_trunc, *destType, *srcType, sub);
+    } else {
+      cvt = mirBuilder.CreateExprTypeCvt(OP_cvt, *destType, *srcType, sub);
+    }
+  }
+  return cvt;
+}
+
+// ---------- FEIRExprAtomic ----------
+FEIRExprAtomic::FEIRExprAtomic(MIRType *ty, MIRType *ref, UniqueFEIRExpr obj, ASTAtomicOp atomOp)
+    : FEIRExpr(FEIRNodeKind::kExprAtomic),
+      mirType(ty),
+      refType(ref),
+      ptrType(GlobalTables::GetTypeTable().GetOrCreatePointerType(*refType)),
+      objExpr(std::move(obj)),
+      atomicOp(atomOp) {}
+
+std::unique_ptr<FEIRExpr> FEIRExprAtomic::CloneImpl() const {
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprAtomic>(mirType, refType, objExpr->Clone(), atomicOp);
+  static_cast<FEIRExprAtomic*>(expr.get())->SetVal1Type(val1Type);
+  if (valExpr1.get() != nullptr) {
+    static_cast<FEIRExprAtomic*>(expr.get())->SetVal1Expr(valExpr1->Clone());
+  }
+  static_cast<FEIRExprAtomic*>(expr.get())->SetVal1Type(val2Type);
+  if (valExpr2.get() != nullptr) {
+    static_cast<FEIRExprAtomic*>(expr.get())->SetVal1Expr(valExpr2->Clone());
+  }
+  return expr;
+}
+
+BaseNode *FEIRExprAtomic::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
+  MIRSymbol *retVar = nullptr;
+  if (atomicOp != kAtomicOpStore) {
+    retVar = val->GenerateMIRSymbol(mirBuilder);
+  }
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  BaseNode *objNode = objExpr.get()->GenMIRNode(mirBuilder);
+  args.emplace_back(objNode);
+  bool retVoid = false;
+  if (atomicOp != kAtomicOpLoadN) {
+    args.emplace_back(valExpr1->GenMIRNode(mirBuilder));
+    if (atomicOp == kAtomicOpExchange) {
+      args.emplace_back(valExpr2->GenMIRNode(mirBuilder));
+    }
+    retVoid = (atomicOp == kAtomicOpExchangeN ||
+        (atomicOp >= kAtomicOpAddFetch && atomicOp <= kAtomicOpFetchNand)) ? false : true;
+  }
+  static std::unordered_map<ASTAtomicOp, MIRIntrinsicID> intrinsicIDMap = {
+      {kAtomicOpLoadN, INTRN_C___atomic_load_n},
+      {kAtomicOpLoad, INTRN_C___atomic_load},
+      {kAtomicOpStoreN, INTRN_C___atomic_store_n},
+      {kAtomicOpStore, INTRN_C___atomic_store},
+      {kAtomicOpExchangeN, INTRN_C___atomic_exchange_n},
+      {kAtomicOpExchange, INTRN_C___atomic_exchange},
+      {kAtomicOpAddFetch, INTRN_C___atomic_add_fetch},
+      {kAtomicOpSubFetch, INTRN_C___atomic_sub_fetch},
+      {kAtomicOpAndFetch, INTRN_C___atomic_and_fetch},
+      {kAtomicOpXorFetch, INTRN_C___atomic_xor_fetch},
+      {kAtomicOpOrFetch, INTRN_C___atomic_or_fetch},
+      {kAtomicOpFetchAdd, INTRN_C___atomic_fetch_add},
+      {kAtomicOpFetchSub, INTRN_C___atomic_fetch_sub},
+      {kAtomicOpFetchAnd, INTRN_C___atomic_fetch_and},
+      {kAtomicOpFetchXor, INTRN_C___atomic_fetch_xor},
+      {kAtomicOpFetchOr, INTRN_C___atomic_fetch_or},
+  };
+  ASSERT(intrinsicIDMap.find(atomicOp) != intrinsicIDMap.end(), "atomic opcode not yet supported!");
+  MIRIntrinsicID intrinsicID = intrinsicIDMap[atomicOp];
+  args.emplace_back(orderExpr->GenMIRNode(mirBuilder));
+  TyIdx typeIndex(0);
+  if (atomicOp == kAtomicOpStoreN || atomicOp == kAtomicOpExchangeN) {
+    typeIndex = valExpr1->GetType()->GenerateMIRType()->GetTypeIndex();
+  }
+  if (atomicOp == kAtomicOpExchange || atomicOp == kAtomicOpLoad || atomicOp == kAtomicOpStore) {
+    UniqueFEIRVar var = static_cast<FEIRExprDRead*>(valExpr1.get())->GetVar()->Clone();
+    typeIndex = var->GenerateMIRSymbol(mirBuilder)->GetTyIdx();
+  }
+  return (!retVoid) ? mirBuilder.CreateStmtIntrinsicCallAssigned(intrinsicID, std::move(args), retVar, typeIndex)
+                    : mirBuilder.CreateStmtIntrinsicCall(intrinsicID, std::move(args), typeIndex);
+}
+
+// ---------- FEIRStmtPesudoLabel ----------
+FEIRStmtPesudoLabel::FEIRStmtPesudoLabel(uint32 argLabelIdx)
+    : FEIRStmt(kStmtPesudoLabel),
+      labelIdx(argLabelIdx),
+      mirLabelIdx(0) {}
+
+std::list<StmtNode*> FEIRStmtPesudoLabel::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *stmtLabel = mirBuilder.CreateStmtLabel(mirLabelIdx);
+  ans.push_back(stmtLabel);
+  return ans;
+}
+
+void FEIRStmtPesudoLabel::GenerateLabelIdx(const MIRBuilder &mirBuilder) {
+  std::stringstream ss;
+  ss << "label" << HIR2MPLEnv::GetInstance().GetGlobalLabelIdx();
+  HIR2MPLEnv::GetInstance().IncrGlobalLabelIdx();
+  mirLabelIdx = mirBuilder.GetOrCreateMIRLabel(ss.str());
+}
+
+std::string FEIRStmtPesudoLabel::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtPesudoLabel2 ----------
+LabelIdx FEIRStmtPesudoLabel2::GenMirLabelIdx(const MIRBuilder &mirBuilder, uint32 qIdx0, uint32 qIdx1) {
+  std::string label = "L" + std::to_string(qIdx0) + "_" + std::to_string(qIdx1);
+  return mirBuilder.GetOrCreateMIRLabel(label);
+}
+
+std::pair<uint32, uint32> FEIRStmtPesudoLabel2::GetLabelIdx() const {
+  return std::make_pair(labelIdxOuter, labelIdxInner);
+}
+
+std::list<StmtNode*> FEIRStmtPesudoLabel2::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *stmtLabel = mirBuilder.CreateStmtLabel(GenMirLabelIdx(mirBuilder, labelIdxOuter, labelIdxInner));
+  ans.push_back(stmtLabel);
+  return ans;
+}
+
+// ---------- FEIRStmtPesudoLOC ----------
+FEIRStmtPesudoLOC::FEIRStmtPesudoLOC(uint32 argSrcFileIdx, uint32 argLineNumber)
+    : FEIRStmt(kStmtPesudoLOC) {
+  isAuxPre = true;
+  Loc loc = {argSrcFileIdx, argLineNumber, 0};
+  SetSrcLoc(loc);
+}
+
+std::list<StmtNode*> FEIRStmtPesudoLOC::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  return std::list<StmtNode*>();
+}
+
+std::string FEIRStmtPesudoLOC::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtPesudoJavaTry ----------
+FEIRStmtPesudoJavaTry::FEIRStmtPesudoJavaTry()
+    : FEIRStmt(kStmtPesudoJavaTry) {}
+
+std::list<StmtNode*> FEIRStmtPesudoJavaTry::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MapleVector<LabelIdx> vec(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (FEIRStmtPesudoLabel *stmtLabel : catchTargets) {
+    vec.push_back(stmtLabel->GetMIRLabelIdx());
+  }
+  StmtNode *stmtTry = mirBuilder.CreateStmtTry(vec);
+  ans.push_back(stmtTry);
+  return ans;
+}
+
+std::string FEIRStmtPesudoJavaTry::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtPesudoJavaTry2 ----------
+FEIRStmtPesudoJavaTry2::FEIRStmtPesudoJavaTry2(uint32 outerIdxIn)
+    : FEIRStmt(kStmtPesudoJavaTry), outerIdx(outerIdxIn) {}
+
+std::list<StmtNode*> FEIRStmtPesudoJavaTry2::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MapleVector<LabelIdx> vec(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (uint32 target : catchLabelIdxVec) {
+    vec.push_back(FEIRStmtPesudoLabel2::GenMirLabelIdx(mirBuilder, outerIdx, target));
+  }
+  StmtNode *stmtTry = mirBuilder.CreateStmtTry(vec);
+  ans.push_back(stmtTry);
+  return ans;
+}
+
+std::string FEIRStmtPesudoJavaTry2::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtPesudoEndTry ----------
+FEIRStmtPesudoEndTry::FEIRStmtPesudoEndTry()
+    : FEIRStmt(kStmtPesudoEndTry) {
+  isAuxPost = true;
+}
+
+std::list<StmtNode*> FEIRStmtPesudoEndTry::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MemPool *mp = mirBuilder.GetCurrentFuncCodeMp();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  StmtNode *stmt = mp->New<StmtNode>(OP_endtry);
+  ans.push_back(stmt);
+  return ans;
+}
+
+std::string FEIRStmtPesudoEndTry::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtPesudoCatch ----------
+FEIRStmtPesudoCatch::FEIRStmtPesudoCatch(uint32 argLabelIdx)
+    : FEIRStmtPesudoLabel(argLabelIdx) {}
+
+std::list<StmtNode*> FEIRStmtPesudoCatch::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *stmtLabel = mirBuilder.CreateStmtLabel(mirLabelIdx);
+  ans.push_back(stmtLabel);
+  MapleVector<TyIdx> vec(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (const UniqueFEIRType &type : catchTypes) {
+    MIRType *mirType = type->GenerateMIRType(kSrcLangJava, true);
+    vec.push_back(mirType->GetTypeIndex());
+  }
+  StmtNode *stmtCatch = mirBuilder.CreateStmtCatch(vec);
+  ans.push_back(stmtCatch);
+  return ans;
+}
+
+void FEIRStmtPesudoCatch::AddCatchTypeNameIdx(GStrIdx typeNameIdx) {
+  UniqueFEIRType type = std::make_unique<FEIRTypeDefault>(PTY_ref, typeNameIdx);
+  catchTypes.push_back(std::move(type));
+}
+
+std::string FEIRStmtPesudoCatch::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtPesudoCatch2 ----------
+FEIRStmtPesudoCatch2::FEIRStmtPesudoCatch2(uint32 qIdx0, uint32 qIdx1)
+    : FEIRStmtPesudoLabel2(qIdx0, qIdx1) {}
+
+std::list<StmtNode*> FEIRStmtPesudoCatch2::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *stmtLabel = mirBuilder.CreateStmtLabel(
+      FEIRStmtPesudoLabel2::GenMirLabelIdx(mirBuilder, GetLabelIdx().first, GetLabelIdx().second));
+  ans.push_back(stmtLabel);
+  MapleVector<TyIdx> vec(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (const UniqueFEIRType &type : catchTypes) {
+    MIRType *mirType = type->GenerateMIRType(kSrcLangJava, true);
+    vec.push_back(mirType->GetTypeIndex());
+  }
+  StmtNode *stmtCatch = mirBuilder.CreateStmtCatch(vec);
+  ans.push_back(stmtCatch);
+  return ans;
+}
+
+void FEIRStmtPesudoCatch2::AddCatchTypeNameIdx(GStrIdx typeNameIdx) {
+  UniqueFEIRType type;
+  if (typeNameIdx == FEUtils::GetVoidIdx()) {
+    type = std::make_unique<FEIRTypeDefault>(PTY_ref, FEUtilJava::GetJavaThrowableNameMplIdx());
+  } else {
+    type = std::make_unique<FEIRTypeDefault>(PTY_ref, typeNameIdx);
+  }
+  catchTypes.push_back(std::move(type));
+}
+
+std::string FEIRStmtPesudoCatch2::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+FEIRStmtPesudoSafe::FEIRStmtPesudoSafe(bool isEnd)
+    : FEIRStmt(kStmtPesudoSafe), end(isEnd) {}
+
+std::list<StmtNode*> FEIRStmtPesudoSafe::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MemPool *mp = mirBuilder.GetCurrentFuncCodeMp();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  Opcode op = end ? OP_endsafe : OP_safe;
+  StmtNode *stmt = mp->New<StmtNode>(op);
+  ans.push_back(stmt);
+  FEFunction &curFEFunc = FEManager::GetCurrentFEFunction();
+  if (end) {
+    if (curFEFunc.GetSafeRegionFlag().empty() || !curFEFunc.GetSafeRegionFlag().top()) {
+      CHECK_FATAL(false, "pop safe region error");
+    }
+    curFEFunc.GetSafeRegionFlag().pop();
+  } else {
+    curFEFunc.GetSafeRegionFlag().push(true);
+  }
+  return ans;
+}
+
+std::string FEIRStmtPesudoSafe::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+FEIRStmtPesudoUnsafe::FEIRStmtPesudoUnsafe(bool isEnd)
+    : FEIRStmt(kStmtPesudoUnsafe), end(isEnd) {}
+
+std::list<StmtNode*> FEIRStmtPesudoUnsafe::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MemPool *mp = mirBuilder.GetCurrentFuncCodeMp();
+  ASSERT(mp != nullptr, "mempool is nullptr");
+  Opcode op = end ? OP_endunsafe : OP_unsafe;
+  StmtNode *stmt = mp->New<StmtNode>(op);
+  ans.push_back(stmt);
+  FEFunction &curFEFunc = FEManager::GetCurrentFEFunction();
+  if (end) {
+    if (curFEFunc.GetSafeRegionFlag().empty() || curFEFunc.GetSafeRegionFlag().top()) {
+      CHECK_FATAL(false, "pop unsafe region error");
+    }
+    curFEFunc.GetSafeRegionFlag().pop();
+  } else {
+    curFEFunc.GetSafeRegionFlag().push(false);
+  }
+  return ans;
+}
+
+std::string FEIRStmtPesudoUnsafe::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtPesudoComment ----------
+FEIRStmtPesudoComment::FEIRStmtPesudoComment(FEIRNodeKind argKind)
+    : FEIRStmt(argKind) {
+  isAuxPre = true;
+}
+
+FEIRStmtPesudoComment::FEIRStmtPesudoComment(const std::string &argContent)
+    : FEIRStmt(kStmtPesudoComment),
+      content(argContent) {
+  isAuxPre = true;
+}
+
+std::list<StmtNode*> FEIRStmtPesudoComment::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *stmt = mirBuilder.CreateStmtComment(content);
+  ans.push_back(stmt);
+  return ans;
+}
+
+std::string FEIRStmtPesudoComment::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtPesudoCommentForInst ----------
+FEIRStmtPesudoCommentForInst::FEIRStmtPesudoCommentForInst()
+    : FEIRStmtPesudoComment(kStmtPesudoCommentForInst) {
+  isAuxPre = true;
+}
+
+std::list<StmtNode*> FEIRStmtPesudoCommentForInst::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  return ans;
+}
+
+std::string FEIRStmtPesudoCommentForInst::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  return ss.str();
+}
+
+// ---------- FEIRStmtIAssign ----------
+std::list<StmtNode*> FEIRStmtIAssign::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  MIRType *mirType = addrType->GenerateMIRTypeAuto();
+  CHECK_FATAL(mirType->IsMIRPtrType(), "Must be ptr type");
+  BaseNode *addrNode = addrExpr->GenMIRNode(mirBuilder);
+  BaseNode *baseNode = baseExpr->GenMIRNode(mirBuilder);
+  if (fieldID != 0) {
+    MIRType * baseType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+    CHECK_FATAL((baseType->GetKind() == MIRTypeKind::kTypeStruct || baseType->GetKind() == MIRTypeKind::kTypeUnion),
+                "If fieldID is not 0, then the computed address must correspond to a structure");
+    InsertNonnullChecking(mirBuilder, *baseType, ans);
+    CheckNonnullArgsAndRetForFuncPtr(mirBuilder, *baseType);
+    CheckBoundaryArgsAndRetForFuncPtr(mirBuilder, *baseType);
+  }
+  AssignBoundaryVarAndChecking(mirBuilder, ans);
+  IassignNode *iAssignNode = mirBuilder.CreateStmtIassign(*mirType, fieldID, addrNode, baseNode);
+  ans.emplace_back(iAssignNode);
+  ENCChecker::CheckBoundaryLenFinalAssign(mirBuilder, addrType, fieldID, loc);
+  ENCChecker::CheckBoundaryLenFinalAddr(mirBuilder, addrExpr, loc);
+  return ans;
+}
+
+void FEIRStmtIAssign::InsertNonnullChecking(MIRBuilder &mirBuilder, const MIRType &baseType,
+                                            std::list<StmtNode*> &ans) const {
+  if (!FEOptions::GetInstance().IsNpeCheckDynamic()) {
+    return;
+  }
+  FieldID tmpID = fieldID;
+  FieldPair fieldPair = static_cast<const MIRStructType&>(baseType).TraverseToFieldRef(tmpID);
+  MIRType *srcType = baseExpr->GetType()->GenerateMIRTypeAuto();
+  MIRType *dstType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+  ENCChecker::CheckNonnullFieldInStruct(*srcType, *dstType, loc);
+  if (fieldPair.second.second.GetAttr(FLDATTR_nonnull)) {
+    if (ENCChecker::HasNullExpr(baseExpr)) {
+      FE_ERR(kLncErr, loc, "null assignment of nonnull pointer");
+      return;
+    }
+    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtAssertNonnull>(OP_assignassertnonnull, baseExpr->Clone());
+    std::list<StmtNode*> stmts = stmt->GenMIRStmts(mirBuilder);
+    ans.splice(ans.end(), stmts);
+  }
+}
+
+// ---------- FEIRStmtDoWhile ----------
+bool FEIRStmtDoWhile::IsFallThroughImpl() const {
+  WARN(kLncWarn, "%s:%d stmt[%s] need to be lowed when building bb",
+       FEManager::GetModule().GetFileNameFromFileNum(loc.fileIdx).c_str(), loc.line,
+       GetFEIRNodeKindDescription(kind).c_str());
+  return false;
+}
+
+std::list<StmtNode*> FEIRStmtDoWhile::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  auto *whileStmtNode = mirBuilder.GetCurrentFuncCodeMp()->New<WhileStmtNode>(opcode);
+  BaseNode *mirCond = condExpr->GenMIRNode(mirBuilder);
+  whileStmtNode->SetOpnd(mirCond, 0);
+  auto *bodyBlock = mirBuilder.GetCurrentFuncCodeMp()->New<BlockNode>();
+  for (auto &stmt : bodyStmts) {
+    for (auto mirStmt : stmt->GenMIRStmts(mirBuilder)) {
+      bodyBlock->AddStatement(mirStmt);
+    }
+  }
+  whileStmtNode->SetBody(bodyBlock);
+  stmts.emplace_back(whileStmtNode);
+  return stmts;
+}
+
+std::list<StmtNode*> FEIRStmtBreak::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  CHECK_FATAL(!breakLabelName.empty(), "labelName is null!");
+  LabelIdx labelIdx = mirBuilder.GetOrCreateMIRLabel(breakLabelName);
+  GotoNode *gotoNode = mirBuilder.CreateStmtGoto(OP_goto, labelIdx);
+  stmts.emplace_back(gotoNode);
+  return stmts;
+}
+
+std::list<StmtNode*> FEIRStmtContinue::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  CHECK_FATAL(!labelName.empty(), "labelName is null!");
+  LabelIdx labelIdx = mirBuilder.GetOrCreateMIRLabel(labelName);
+  GotoNode *gotoNode = mirBuilder.CreateStmtGoto(OP_goto, labelIdx);
+  stmts.emplace_back(gotoNode);
+  return stmts;
+}
+
+std::list<StmtNode*> FEIRStmtLabel::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  return std::list<StmtNode*>{mirBuilder.CreateStmtLabel(mirBuilder.GetOrCreateMIRLabel(labelName))};
+}
+
+FEIRStmtAtomic::FEIRStmtAtomic(UniqueFEIRExpr expr)
+    : FEIRStmt(FEIRNodeKind::kStmtAtomic),
+      atomicExpr(std::move(expr)) {}
+
+std::list<StmtNode*> FEIRStmtAtomic::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  FEIRExprAtomic *atom = static_cast<FEIRExprAtomic*>(atomicExpr.get());
+  auto stmt = static_cast<StmtNode*>(atom->GenMIRNode(mirBuilder));
+  stmts.emplace_back(stmt);
+  return stmts;
+}
+
+bool FEIRStmtGCCAsm::HandleConstraintPlusQm(MIRBuilder &mirBuilder, AsmNode *asmNode, uint32 index,
+                                            std::list<StmtNode*> &stmts, std::list<StmtNode*> &initStmts) const {
+  if (std::get<1>(outputs[index]) != "+Q" && std::get<1>(outputs[index]) != "+m") {
+    return false;
+  }
+  FieldID fieldID = outputsExprs[index]->GetFieldID();
+  MIRSymbol *sym = outputsExprs[index]->GetVarUses().front()->GenerateMIRSymbol(mirBuilder);
+  UniqueFEIRVar asmOut = outputsExprs[index]->GetVarUses().front()->Clone();
+  MIRSymbol *localSym = nullptr;
+  UniqueFEIRVar localAsmOut = nullptr;
+  BaseNode *node;
+  if (outputsExprs[index]->GetKind() == kExprDRead) {
+    if (asmOut->IsGlobal()) {
+      auto pair = HandleGlobalAsmOutOperand(asmOut, fieldID, stmts, mirBuilder);
+      localSym = pair.first;
+      localAsmOut = pair.second->Clone();
+      // '+' means that asm out operand is both read and written, copy the initial value of global var into the
+      // local temp var and then add local temp var into the input list.
+      auto stmt = FEIRBuilder::CreateStmtDAssign(localAsmOut->Clone(), outputsExprs[index]->Clone());
+      std::list<StmtNode*> nodes = stmt->GenMIRStmts(mirBuilder);
+      initStmts.splice(initStmts.end(), nodes);
+    }
+    node = static_cast<BaseNode*>(mirBuilder.CreateExprAddrof(fieldID, localSym != nullptr ? *localSym : *sym));
+  } else if (outputsExprs[index]->GetKind() == kExprIRead) {
+    FEIRExprIRead *iread = static_cast<FEIRExprIRead*>(outputsExprs[index].get());
+    if (iread->GetFieldID() == 0) {
+      node = iread->GetClonedOpnd()->GenMIRNode(mirBuilder);
+    } else {
+      auto addrOfExpr = std::make_unique<FEIRExprIAddrof>(iread->GetClonedPtrType(), iread->GetFieldID(),
+                                                          iread->GetClonedOpnd());
+      node = addrOfExpr->GenMIRNode(mirBuilder);
+    }
+    auto pair = HandleAsmOutOperandWithPtrType(iread, stmts, mirBuilder);
+    localSym = pair.first;
+    localAsmOut = pair.second->Clone();
+    fieldID = 0;
+  } else {
+    CHECK_FATAL(false, "FEIRStmtGCCAsm NYI.");
+  }
+
+  UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(std::get<1>(outputs[index]));
+  asmNode->PushOpnd(node);
+  asmNode->inputConstraints.emplace_back(strIdx);
+
+  CallReturnPair retPair(localSym != nullptr ? localSym->GetStIdx() : sym->GetStIdx(), RegFieldPair(fieldID, 0));
+  asmNode->asmOutputs.emplace_back(retPair);
+  asmNode->outputConstraints.emplace_back(strIdx);
+  return true;
+}
+
+std::pair<MIRSymbol*, UniqueFEIRVar> FEIRStmtGCCAsm::HandleAsmOutOperandWithPtrType(const FEIRExprIRead *ireadExpr,
+                                                                                    std::list<StmtNode*> &stmts,
+                                                                                    MIRBuilder &mirBuilder) const {
+  UniqueFEIRVar localAsmOut = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("asm_out_"),
+                                                             ireadExpr->GetClonedRetType());
+  MIRSymbol *localSym = localAsmOut->GenerateLocalMIRSymbol(mirBuilder);
+  UniqueFEIRExpr srcExpr = FEIRBuilder::CreateExprDRead(localAsmOut->Clone());
+  auto stmt = FEIRBuilder::CreateStmtIAssign(ireadExpr->GetClonedPtrType(), ireadExpr->GetClonedOpnd(),
+                                             std::move(srcExpr), ireadExpr->GetFieldID());
+  std::list<StmtNode*> node = stmt->GenMIRStmts(mirBuilder);
+  stmts.splice(stmts.end(), node);
+  return std::make_pair(localSym, localAsmOut->Clone());
+}
+
+std::pair<MIRSymbol*, UniqueFEIRVar> FEIRStmtGCCAsm::HandleGlobalAsmOutOperand(const UniqueFEIRVar &asmOut,
+                                                                               const FieldID fieldID,
+                                                                               std::list<StmtNode*> &stmts,
+                                                                               MIRBuilder &mirBuilder) const {
+  MIRSymbol *localSym = nullptr;
+  UniqueFEIRExpr srcExpr;
+  UniqueFEIRStmt stmt;
+  UniqueFEIRVar localAsmOut = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("asm_out_"),
+                                                             asmOut->GetType()->Clone(), false);
+  localSym = localAsmOut->GenerateLocalMIRSymbol(mirBuilder);
+  if (fieldID) {
+    MIRStructType *structType = static_cast<MIRStructType*>(asmOut->GetType()->GenerateMIRTypeAuto());
+    FieldPair fieldPair = structType->TraverseToField(fieldID);
+    UniqueFEIRType fieldType = FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable()
+        .GetTypeFromTyIdx(fieldPair.second.first));
+    srcExpr = FEIRBuilder::CreateExprDReadAggField(localAsmOut->Clone(), fieldID, fieldType->Clone());
+    stmt = FEIRBuilder::CreateStmtDAssignAggField(asmOut->Clone(), std::move(srcExpr), fieldID);
+  } else {
+    srcExpr = FEIRBuilder::CreateExprDRead(localAsmOut->Clone());
+    stmt = FEIRBuilder::CreateStmtDAssign(asmOut->Clone(), std::move(srcExpr));
+  }
+  std::list<StmtNode *> node = stmt->GenMIRStmts(mirBuilder);
+  stmts.splice(stmts.end(), node);
+  return std::make_pair(localSym, localAsmOut->Clone());
+}
+
+std::list<StmtNode*> FEIRStmtGCCAsm::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  std::list<StmtNode*> initStmts;
+  MemPool *mp = mirBuilder.GetCurrentFuncCodeMp();
+  AsmNode *asmNode = mp->New<AsmNode>(mirBuilder.GetCurrentFuncCodeMpAllocator());
+  asmNode->asmString = asmStr;
+  for (uint32 i = 0; i < inputs.size(); ++i) {
+    BaseNode *node = inputsExprs[i]->GenMIRNode(mirBuilder);
+    asmNode->PushOpnd(node);
+    UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(inputs[i].second);
+    asmNode->inputConstraints.emplace_back(strIdx);
+  }
+  for (uint32 i = 0; i < outputs.size(); ++i) {
+    if (HandleConstraintPlusQm(mirBuilder, asmNode, i, stmts, initStmts)) {
+      continue;
+    }
+    FieldID fieldID = 0;
+    MIRSymbol *sym = nullptr;
+    MIRSymbol *localSym = nullptr;
+    UniqueFEIRVar localAsmOut = nullptr;
+    UniqueFEIRVar asmOut;
+    if (outputsExprs[i]->GetKind() == kExprDRead) {
+      FEIRExprDRead *dread = static_cast<FEIRExprDRead*>(outputsExprs[i].get());
+      fieldID = dread->GetFieldID();
+      sym = dread->GetVarUses().front()->GenerateMIRSymbol(mirBuilder);
+      asmOut = dread->GetVarUses().front()->Clone();
+      if (asmOut->IsGlobal()) {
+        auto pair = HandleGlobalAsmOutOperand(asmOut, fieldID, stmts, mirBuilder);
+        localSym = pair.first;
+        localAsmOut = pair.second->Clone();
+      }
+    } else if (outputsExprs[i]->GetKind() == kExprIRead) {
+      FEIRExprIRead *iread = static_cast<FEIRExprIRead*>(outputsExprs[i].get());
+      fieldID = iread->GetFieldID();
+      auto pair = HandleAsmOutOperandWithPtrType(iread, stmts, mirBuilder);
+      localSym = pair.first;
+      localAsmOut = pair.second->Clone();
+      fieldID = 0;
+    } else {
+      CHECK_FATAL(false, "FEIRStmtGCCAsm NYI.");
+    }
+
+    CallReturnPair retPair(localSym != nullptr ? localSym->GetStIdx() : sym->GetStIdx(), RegFieldPair(fieldID, 0));
+    asmNode->asmOutputs.emplace_back(retPair);
+    UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(std::get<1>(outputs[i]));
+    asmNode->outputConstraints.emplace_back(strIdx);
+
+    // If this is a read/write, copy the initial value into the temp before and added to the input list
+    if (std::get<2>(outputs[i])) {
+      auto stmt = FEIRBuilder::CreateStmtDAssign(localAsmOut != nullptr ? localAsmOut->Clone() : asmOut->Clone(),
+                                                 outputsExprs[i]->Clone());
+      std::list<StmtNode*> node = stmt->GenMIRStmts(mirBuilder);
+      initStmts.splice(initStmts.end(), node);
+
+      AddrofNode *rNode = mirBuilder.CreateExprDread(localSym != nullptr ? *localSym : *sym);
+      asmNode->PushOpnd(static_cast<BaseNode*>(rNode));
+      asmNode->inputConstraints.emplace_back(strIdx);
+    }
+  }
+  for (uint32 i = 0; i < clobbers.size(); ++i) {
+    UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(clobbers[i]);
+    asmNode->clobberList.emplace_back(strIdx);
+  }
+  for (uint32 i = 0; i < labels.size(); ++i) {
+    LabelIdx label = mirBuilder.GetOrCreateMIRLabel(labels[i]);
+    asmNode->gotoLabels.emplace_back(label);
+  }
+  if (isVolatile) {
+    asmNode->SetQualifier(kASMvolatile);
+  }
+  if (isGoto) {
+    asmNode->SetQualifier(kASMgoto);
+  }
+  stmts.emplace_front(asmNode);
+  if (!initStmts.empty()) {
+    stmts.splice(stmts.begin(), initStmts);
+  }
+  return stmts;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/feir_type.cpp b/src/hir2mpl/common/src/feir_type.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9052fa4f9de3fbfaf32df7652b7cdafd84a2d65c
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_type.cpp
@@ -0,0 +1,518 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_type.h"
+#include <functional>
+#include "global_tables.h"
+#include "mpl_logging.h"
+#include "fe_manager.h"
+#include "fe_config_parallel.h"
+#include "fe_utils.h"
+
+namespace maple {
+// ---------- FEIRType ----------
+std::map<MIRSrcLang, std::tuple<bool, PrimType>> FEIRType::langConfig = FEIRType::InitLangConfig();
+
+FEIRType::FEIRType(FEIRTypeKind argKind)
+    : kind(argKind), isZero(false), srcLang(kSrcLangJava) {}
+
+void FEIRType::CopyFromImpl(const FEIRType &type) {
+  kind = type.kind;
+}
+
+bool FEIRType::IsEqualToImpl(const std::unique_ptr<FEIRType> &argType) const {
+  CHECK_NULL_FATAL(argType.get());
+  if (kind != argType.get()->kind) {
+    return false;
+  }
+  return IsEqualTo(*(argType.get()));
+}
+
+bool FEIRType::IsEqualToImpl(const FEIRType &argType) const {
+  if (kind == argType.kind && isZero == argType.isZero) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+std::unique_ptr<FEIRType> FEIRType::NewType(FEIRTypeKind argKind) {
+  switch (argKind) {
+    case kFEIRTypeDefault:
+      return std::make_unique<FEIRTypeDefault>();
+    default:
+      CHECK_FATAL(false, "unsupported FEIRType Kind");
+      return std::make_unique<FEIRTypeDefault>();
+  }
+}
+
+std::map<MIRSrcLang, std::tuple<bool, PrimType>> FEIRType::InitLangConfig() {
+  std::map<MIRSrcLang, std::tuple<bool, PrimType>> ans;
+  ans[kSrcLangJava] = std::make_tuple(true, PTY_ref);
+  ans[kSrcLangC] = std::make_tuple(true, PTY_ref);
+  return ans;
+}
+
+MIRType *FEIRType::GenerateMIRTypeAuto(MIRSrcLang argSrcLang) const {
+  return GenerateMIRTypeAutoImpl(argSrcLang);
+}
+
+MIRType *FEIRType::GenerateMIRTypeAutoImpl(MIRSrcLang argSrcLang) const {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  auto it = langConfig.find(argSrcLang);
+  if (it == langConfig.cend()) {
+    CHECK_FATAL(false, "unsupported language");
+    return nullptr;
+  }
+  PrimType pTy = GetPrimType();
+  return GenerateMIRType(std::get<0>(it->second), pTy == PTY_begin ? std::get<1>(it->second) : pTy);
+}
+
+// ---------- FEIRTypeDefault ----------
+FEIRTypeDefault::FEIRTypeDefault()
+    : FEIRTypeDefault(PTY_void, GStrIdx(0), 0) {}
+
+FEIRTypeDefault::FEIRTypeDefault(PrimType argPrimType)
+    : FEIRTypeDefault(argPrimType, GStrIdx(0), 0) {}
+
+FEIRTypeDefault::FEIRTypeDefault(PrimType argPrimType, const GStrIdx &argTypeNameIdx)
+    : FEIRTypeDefault(argPrimType, argTypeNameIdx, 0) {
+  std::string typeName = GlobalTables::GetStrTable().GetStringFromStrIdx(argTypeNameIdx);
+  uint8 typeDim = FEUtils::GetDim(typeName);
+  if (typeDim != 0) {
+    dim = typeDim;
+    typeName = typeName.substr(dim);
+    typeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+    primType = FEUtils::GetPrimType(typeNameIdx);
+  }
+}
+
+FEIRTypeDefault::FEIRTypeDefault(PrimType argPrimType, const GStrIdx &argTypeNameIdx, TypeDim argDim)
+    : FEIRType(kFEIRTypeDefault),
+      primType(argPrimType),
+      typeNameIdx(argTypeNameIdx),
+      dim(argDim) {}
+
+void FEIRTypeDefault::CopyFromImpl(const FEIRType &type) {
+  CHECK_FATAL(type.GetKind() == kFEIRTypeDefault, "invalid FEIRType Kind");
+  FEIRType::CopyFromImpl(type);
+  const FEIRTypeDefault &typeDefault = static_cast<const FEIRTypeDefault&>(type);
+  typeNameIdx = typeDefault.typeNameIdx;
+  dim = typeDefault.dim;
+}
+
+std::unique_ptr<FEIRType> FEIRTypeDefault::CloneImpl() const {
+  std::unique_ptr<FEIRType> type = std::make_unique<FEIRTypeDefault>(primType, typeNameIdx, dim);
+  return type;
+}
+
+MIRType *FEIRTypeDefault::GenerateMIRTypeImpl(bool usePtr, PrimType ptyPtr) const {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  return GenerateMIRTypeInternal(typeNameIdx, usePtr, ptyPtr);
+}
+
+TypeDim FEIRTypeDefault::ArrayIncrDimImpl(TypeDim delta) {
+  CHECK_FATAL(FEConstants::kDimMax - dim >= delta, "dim delta is too large");
+  dim += delta;
+  return dim;
+}
+
+TypeDim FEIRTypeDefault::ArrayDecrDimImpl(TypeDim delta) {
+  CHECK_FATAL(dim >= delta, "dim delta is too large");
+  dim -= delta;
+  return dim;
+}
+
+bool FEIRTypeDefault::IsEqualToImpl(const FEIRType &argType) const {
+  if (!FEIRType::IsEqualToImpl(argType)) {
+    return false;
+  }
+  const FEIRTypeDefault &argTypeDefault = static_cast<const FEIRTypeDefault&>(argType);
+  if (typeNameIdx == argTypeDefault.typeNameIdx && dim == argTypeDefault.dim && primType == argTypeDefault.primType) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool FEIRTypeDefault::IsEqualToImpl(const std::unique_ptr<FEIRType> &argType) const {
+  CHECK_NULL_FATAL(argType.get());
+  return IsEqualToImpl(*(argType.get()));
+}
+
+uint32 FEIRTypeDefault::HashImpl() const {
+  return static_cast<uint32>(
+      std::hash<uint32>{}(primType) + std::hash<uint32>{}(typeNameIdx) + std::hash<uint32>{}(dim));
+}
+
+bool FEIRTypeDefault::IsScalarImpl() const {
+  return (primType != PTY_ref && IsPrimitiveScalar(primType) && dim == 0);
+}
+
+PrimType FEIRTypeDefault::GetPrimTypeImpl() const {
+  if (dim == 0) {
+    return primType;
+  } else {
+    return PTY_ref;
+  }
+}
+
+void FEIRTypeDefault::SetPrimTypeImpl(PrimType pt) {
+  if (dim == 0) {
+    primType = pt;
+  } else {
+    if (pt == PTY_ref) {
+      primType = pt;
+    } else {
+      WARN(kLncWarn, "dim is set to zero");
+      dim = 0;
+    }
+  }
+}
+
+void FEIRTypeDefault::LoadFromJavaTypeName(const std::string &typeName, bool inMpl) {
+  uint32 dimLocal = 0;
+  std::string baseName = FETypeManager::GetBaseTypeName(typeName, dimLocal, inMpl);
+  CHECK_FATAL(dimLocal <= FEConstants::kDimMax, "invalid array type %s (dim is too big)", typeName.c_str());
+  dim = static_cast<TypeDim>(dimLocal);
+  if (baseName.length() == 1) {
+    typeNameIdx = GStrIdx(0);
+    switch (baseName[0]) {
+      case 'I':
+        primType = PTY_i32;
+        break;
+      case 'J':
+        primType = PTY_i64;
+        break;
+      case 'F':
+        primType = PTY_f32;
+        break;
+      case 'D':
+        primType = PTY_f64;
+        break;
+      case 'Z':
+        primType = PTY_u1;
+        break;
+      case 'B':
+        primType = PTY_i8;
+        break;
+      case 'S':
+        primType = PTY_i16;
+        break;
+      case 'C':
+        primType = PTY_u16;
+        break;
+      case 'V':
+        primType = PTY_void;
+        break;
+      default:
+        CHECK_FATAL(false, "unsupported java type %s", typeName.c_str());
+    }
+  } else if (baseName[0] == 'L') {
+    primType = PTY_ref;
+    baseName = inMpl ? baseName : namemangler::EncodeName(baseName);
+    typeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(baseName);
+  }
+}
+
+void FEIRTypeDefault::LoadFromASTTypeName(const std::string &typeName) {
+  const static std::map<std::string, PrimType> mapASTTypeNameToType = {
+      {"bool", PTY_u1},
+      {"uint8", PTY_u8},
+      {"uint16", PTY_u16},
+      {"uint32", PTY_u32},
+      {"uint64", PTY_u64},
+      {"int8", PTY_i8},
+      {"int16", PTY_i16},
+      {"int32", PTY_i32},
+      {"int64", PTY_i64},
+      {"float", PTY_f32},
+      {"double", PTY_f64},
+      {"void", PTY_void}
+  };
+  auto it = mapASTTypeNameToType.find(typeName);
+  if (it != mapASTTypeNameToType.end()) {
+    primType = it->second;
+  } else {
+    primType = PTY_ref;
+    typeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+  }
+}
+
+MIRType *FEIRTypeDefault::GenerateMIRTypeForPrim() const {
+  switch (primType) {
+    case PTY_i8:
+      return GlobalTables::GetTypeTable().GetInt8();
+    case PTY_i16:
+      return GlobalTables::GetTypeTable().GetInt16();
+    case PTY_i32:
+      return GlobalTables::GetTypeTable().GetInt32();
+    case PTY_i64:
+      return GlobalTables::GetTypeTable().GetInt64();
+    case PTY_f32:
+      return GlobalTables::GetTypeTable().GetFloat();
+    case PTY_f64:
+      return GlobalTables::GetTypeTable().GetDouble();
+    case PTY_u1:
+      return GlobalTables::GetTypeTable().GetUInt1();
+    case PTY_u8:
+      return GlobalTables::GetTypeTable().GetUInt8();
+    case PTY_u16:
+      return GlobalTables::GetTypeTable().GetUInt16();
+    case PTY_u32:
+      return GlobalTables::GetTypeTable().GetUInt32();
+    case PTY_u64:
+      return GlobalTables::GetTypeTable().GetUInt64();
+    case PTY_void:
+      return GlobalTables::GetTypeTable().GetVoid();
+    case PTY_a32:
+      return GlobalTables::GetTypeTable().GetAddr32();
+    case PTY_ref:
+      return GlobalTables::GetTypeTable().GetRef();
+    case PTY_ptr:
+      return GlobalTables::GetTypeTable().GetPtr();
+    default:
+      CHECK_FATAL(false, "unsupported prim type");
+  }
+  return GlobalTables::GetTypeTable().GetDynundef();
+}
+
+MIRType *FEIRTypeDefault::GenerateMIRTypeInternal(const GStrIdx &argTypeNameIdx, bool usePtr) const {
+  MIRType *baseType = nullptr;
+  MIRType *type = nullptr;
+  if (primType == PTY_ref) {
+    if (argTypeNameIdx.GetIdx() == 0) {
+      baseType = GlobalTables::GetTypeTable().GetRef();
+    } else {
+      bool isCreate = false;
+      baseType = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(GStrIdx(argTypeNameIdx), false,
+                                                                             FETypeFlag::kSrcUnknown, isCreate);
+    }
+    if (dim > 0) {
+      baseType = FEManager::GetTypeManager().GetOrCreatePointerType(*baseType);
+    }
+    type = FEManager::GetTypeManager().GetOrCreateArrayType(*baseType, dim);
+  } else {
+    baseType = GenerateMIRTypeForPrim();
+    type = FEManager::GetTypeManager().GetOrCreateArrayType(*baseType, dim);
+  }
+  if (IsScalar() || !IsPreciseRefType()) {
+    return type;
+  }
+  return usePtr ? FEManager::GetTypeManager().GetOrCreatePointerType(*type) : type;
+}
+
+MIRType *FEIRTypeDefault::GenerateMIRTypeInternal(const GStrIdx &argTypeNameIdx, bool usePtr, PrimType ptyPtr) const {
+  MIRType *baseType = nullptr;
+  MIRType *type = nullptr;
+  bool baseTypeUseNoPtr = (IsScalarPrimType(primType) || argTypeNameIdx == 0);
+  bool typeUseNoPtr = !IsRef() || (!IsArray() && !IsPrecise());
+  if (baseTypeUseNoPtr) {
+    baseType = GenerateMIRTypeForPrim();
+    type = FEManager::GetTypeManager().GetOrCreateArrayType(*baseType, dim, ptyPtr);
+  } else {
+    bool isCreate = false;
+    baseType = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(argTypeNameIdx, false,
+                                                                           FETypeFlag::kSrcUnknown, isCreate);
+    if (dim > 0) {
+      baseType = FEManager::GetTypeManager().GetOrCreatePointerType(*baseType, ptyPtr);
+    }
+    type = FEManager::GetTypeManager().GetOrCreateArrayType(*baseType, dim, ptyPtr);
+  }
+  if (typeUseNoPtr) {
+    return type;
+  }
+  return usePtr ? FEManager::GetTypeManager().GetOrCreatePointerType(*type, ptyPtr) : type;
+}
+
+std::string FEIRTypeDefault::GetTypeNameImpl() const {
+  if (dim == 0) {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(typeNameIdx);
+  }
+  std::string name;
+  switch (srcLang) {
+    case kSrcLangJava: {
+      for (TypeDim i = 0; i < dim; i++) {
+        (void)name.append("A");
+      }
+      (void)name.append(GlobalTables::GetStrTable().GetStringFromStrIdx(typeNameIdx));
+      return name;
+    }
+    default:
+      CHECK_FATAL(false, "undefined language");
+      return "";
+  }
+}
+
+// ---------- FEIRTypeByName ----------
+FEIRTypeByName::FEIRTypeByName(PrimType argPrimType, const std::string &argTypeName, TypeDim argDim)
+    : FEIRTypeDefault(argPrimType, GStrIdx(0), argDim),
+      typeName(argTypeName) {
+  kind = kFEIRTypeByName;
+}
+
+std::unique_ptr<FEIRType> FEIRTypeByName::CloneImpl() const {
+  std::unique_ptr<FEIRType> newType = std::make_unique<FEIRTypeByName>(primType, typeName, dim);
+  return newType;
+}
+
+MIRType *FEIRTypeByName::GenerateMIRTypeImpl(bool usePtr, PrimType ptyPtr) const {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+  return GenerateMIRTypeInternal(nameIdx, usePtr, ptyPtr);
+}
+
+bool FEIRTypeByName::IsEqualToImpl(const FEIRType &argType) const {
+  if (!FEIRTypeDefault::IsEqualToImpl(argType)) {
+    return false;
+  }
+  const FEIRTypeByName &argTypeName = static_cast<const FEIRTypeByName&>(argType);
+  if (typeName.compare(argTypeName.typeName) == 0) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+uint32 FEIRTypeByName::HashImpl() const {
+  return static_cast<uint32>(std::hash<std::string>{}(typeName));
+}
+
+bool FEIRTypeByName::IsScalarImpl() const {
+  return false;
+}
+
+// ---------- FEIRTypePointer ----------
+FEIRTypePointer::FEIRTypePointer(std::unique_ptr<FEIRType> argBaseType, PrimType argPrimType)
+    : FEIRType(kFEIRTypePointer),
+      primType(argPrimType) {
+  CHECK_FATAL(argBaseType != nullptr, "input type is nullptr");
+  baseType = std::move(argBaseType);
+}
+
+std::unique_ptr<FEIRType> FEIRTypePointer::CloneImpl() const {
+  std::unique_ptr<FEIRType> newType = std::make_unique<FEIRTypePointer>(baseType->Clone(), primType);
+  return newType;
+}
+
+MIRType *FEIRTypePointer::GenerateMIRTypeImpl(bool usePtr, PrimType ptyPtr) const {
+  MIRType *mirBaseType = baseType->GenerateMIRType(usePtr, ptyPtr);
+  return FEManager::GetTypeManager().GetOrCreatePointerType(*mirBaseType, ptyPtr);
+}
+
+bool FEIRTypePointer::IsEqualToImpl(const FEIRType &argType) const {
+  const FEIRTypePointer &argTypePointer = static_cast<const FEIRTypePointer&>(argType);
+  return baseType->IsEqualTo(argTypePointer.baseType);
+}
+
+uint32 FEIRTypePointer::HashImpl() const {
+  ASSERT(baseType != nullptr, "base type is nullptr");
+  return baseType->Hash();
+}
+
+bool FEIRTypePointer::IsScalarImpl() const {
+  return false;
+}
+
+TypeDim FEIRTypePointer::ArrayIncrDimImpl(TypeDim delta) {
+  ASSERT(baseType != nullptr, "base type is nullptr");
+  return baseType->ArrayIncrDim(delta);
+}
+
+TypeDim FEIRTypePointer::ArrayDecrDimImpl(TypeDim delta) {
+  ASSERT(baseType != nullptr, "base type is nullptr");
+  return baseType->ArrayDecrDim(delta);
+}
+
+PrimType FEIRTypePointer::GetPrimTypeImpl() const {
+  return primType;
+}
+
+void FEIRTypePointer::SetPrimTypeImpl(PrimType pt) {
+  CHECK_FATAL(false, "PrimType %d should not run here", pt);
+}
+
+// ---------- FEIRTypeNative ----------
+FEIRTypeNative::FEIRTypeNative(MIRType &argMIRType)
+    : FEIRType(kFEIRTypeNative),
+      mirType(argMIRType) {
+  kind = kFEIRTypeNative;
+  // Right now, FEIRTypeNative is only used for c-language.
+  srcLang = kSrcLangC;
+}
+
+PrimType FEIRTypeNative::GetPrimTypeImpl() const {
+  return mirType.GetPrimType();
+}
+
+void FEIRTypeNative::SetPrimTypeImpl(PrimType pt) {
+  mirType.SetPrimType(pt);
+}
+
+void FEIRTypeNative::CopyFromImpl(const FEIRType &type) {
+  CHECK_FATAL(type.GetKind() == kFEIRTypeNative, "invalid opration");
+  mirType = *(type.GenerateMIRTypeAuto());
+}
+
+MIRType *FEIRTypeNative::GenerateMIRTypeAutoImpl() const {
+  return &mirType;
+}
+
+std::unique_ptr<FEIRType> FEIRTypeNative::CloneImpl() const {
+  std::unique_ptr<FEIRType> newType = std::make_unique<FEIRTypeNative>(mirType);
+  return newType;
+}
+
+MIRType *FEIRTypeNative::GenerateMIRTypeImpl(bool usePtr, PrimType ptyPtr) const {
+  return &mirType;
+}
+
+bool FEIRTypeNative::IsEqualToImpl(const FEIRType &argType) const {
+  if (argType.GetKind() != kFEIRTypeNative) {
+    return false;
+  }
+  const FEIRTypeNative &argTypeNative = static_cast<const FEIRTypeNative&>(argType);
+  return &argTypeNative.mirType == &mirType;
+}
+
+uint32 FEIRTypeNative::HashImpl() const {
+  return static_cast<uint32>(mirType.GetHashIndex());
+}
+
+std::string FEIRTypeNative::GetTypeNameImpl() const {
+  return mirType.GetName();
+}
+
+bool FEIRTypeNative::IsScalarImpl() const {
+  return mirType.IsScalarType();
+}
+
+bool FEIRTypeNative::IsRefImpl() const {
+  return mirType.GetPrimType() == PTY_ref;
+}
+
+bool FEIRTypeNative::IsArrayImpl() const {
+  return mirType.GetKind() == kTypeArray;
+}
+
+TypeDim FEIRTypeNative::ArrayIncrDimImpl(TypeDim delta) {
+  CHECK_FATAL(false, "Should not get here");
+  return delta;
+}
+
+TypeDim FEIRTypeNative::ArrayDecrDimImpl(TypeDim delta) {
+  CHECK_FATAL(false, "Should not get here");
+  return delta;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/feir_type_helper.cpp b/src/hir2mpl/common/src/feir_type_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..00bd483ebe5c281f7413e945456643bf6270e751
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_type_helper.cpp
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_type_helper.h"
+#include "fe_type_manager.h"
+
+namespace maple {
+UniqueFEIRType FEIRTypeHelper::CreateTypeByPrimType(PrimType primType, TypeDim dim, bool usePtr) {
+  UniqueFEIRType type = std::make_unique<FEIRTypeDefault>(primType, GStrIdx(0), dim);
+  if (usePtr) {
+    return FEIRTypeHelper::CreatePointerType(std::move(type));
+  } else {
+    return type;
+  }
+}
+
+UniqueFEIRType FEIRTypeHelper::CreateTypeByJavaName(const std::string &typeName, bool inMpl, bool usePtr) {
+  uint32 dim = 0;
+  std::string baseName = FETypeManager::GetBaseTypeName(typeName, dim, inMpl);
+  CHECK_FATAL(dim <= FEConstants::kDimMax, "invalid array type %s (dim is too big)", typeName.c_str());
+  uint8 dim8 = static_cast<uint8>(dim);
+  UniqueFEIRType newType;
+  if (baseName.length() == 1) {
+    newType = CreateTypeByJavaNamePrim(baseName[0], dim8);
+    CHECK_FATAL(newType != nullptr, "unsupported java type name %s: ", typeName.c_str());
+  } else if (baseName[0] == 'L') {
+    baseName = inMpl ? baseName : namemangler::EncodeName(baseName);
+    GStrIdx typeNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(baseName);
+    if (typeNameIdx == 0) {
+      newType = std::make_unique<FEIRTypeByName>(PTY_ref, baseName, dim8);
+    } else {
+      newType = std::make_unique<FEIRTypeDefault>(PTY_ref, typeNameIdx, dim8);
+    }
+  } else {
+    CHECK_FATAL(false, "unsupported java type name %s: ", typeName.c_str());
+    return nullptr;
+  }
+  if (usePtr) {
+    return FEIRTypeHelper::CreatePointerType(std::move(newType), PTY_ref);
+  } else {
+    return newType;
+  }
+}
+
+UniqueFEIRType FEIRTypeHelper::CreatePointerType(UniqueFEIRType baseType, PrimType primType) {
+  UniqueFEIRType newType = std::make_unique<FEIRTypePointer>(std::move(baseType), primType);
+  return newType;
+}
+
+UniqueFEIRType FEIRTypeHelper::CreateTypeByJavaNamePrim(char primTypeFlag, uint8 dim8) {
+  PrimType primType = PTY_unknown;
+  switch (primTypeFlag) {
+    case 'I':
+      primType = PTY_i32;
+      break;
+    case 'J':
+      primType = PTY_i64;
+      break;
+    case 'F':
+      primType = PTY_f32;
+      break;
+    case 'D':
+      primType = PTY_f64;
+      break;
+    case 'Z':
+      primType = PTY_u1;
+      break;
+    case 'B':
+      primType = PTY_i8;
+      break;
+    case 'S':
+      primType = PTY_i16;
+      break;
+    case 'C':
+      primType = PTY_u16;
+      break;
+    case 'V':
+      primType = PTY_void;
+      break;
+    default:
+      return nullptr;
+  }
+  return std::make_unique<FEIRTypeDefault>(primType, GStrIdx(0), dim8);
+}
+
+UniqueFEIRType FEIRTypeHelper::CreateTypeByDimIncr(const UniqueFEIRType &srcType, uint8 delta, bool usePtr,
+                                                   PrimType primType) {
+  UniqueFEIRType type = srcType->Clone();
+  (void)type->ArrayIncrDim(delta);
+  if (!usePtr || type->GetKind() == FEIRTypeKind::kFEIRTypePointer) {
+    return type;
+  } else {
+    return CreatePointerType(std::move(type), primType);
+  }
+}
+
+UniqueFEIRType FEIRTypeHelper::CreateTypeByDimDecr(const UniqueFEIRType &srcType, uint8 delta) {
+  UniqueFEIRType type = srcType->Clone();
+  uint8 dim = type->ArrayDecrDim(delta);
+  if (srcType->GetKind() == FEIRTypeKind::kFEIRTypePointer && dim == 0 && IsPrimitiveScalar(type->GetPrimType())) {
+    const FEIRTypePointer *ptrType = static_cast<const FEIRTypePointer*>(type.get());
+    ASSERT(ptrType != nullptr, "nullptr check");
+    return ptrType->GetBaseType()->Clone();
+  } else {
+    return type;
+  }
+}
+
+UniqueFEIRType FEIRTypeHelper::CreateTypeByGetAddress(const UniqueFEIRType &srcType, PrimType primType) {
+  UniqueFEIRType type = std::make_unique<FEIRTypePointer>(srcType->Clone(), primType);
+  return type;
+}
+
+UniqueFEIRType FEIRTypeHelper::CreateTypeByDereferrence(const UniqueFEIRType &srcType) {
+  CHECK_FATAL(srcType->GetKind() == FEIRTypeKind::kFEIRTypePointer, "input is not pointer type");
+  const FEIRTypePointer *ptrSrcType = static_cast<const FEIRTypePointer*>(srcType.get());
+  ASSERT(ptrSrcType != nullptr, "nullptr check");
+  return ptrSrcType->GetBaseType()->Clone();
+}
+
+UniqueFEIRType FEIRTypeHelper::CreateTypeDefault(PrimType primType, const GStrIdx &typeNameIdx, TypeDim dim) {
+  UniqueFEIRType type = std::make_unique<FEIRTypeDefault>(primType, typeNameIdx, dim);
+  CHECK_FATAL(type->IsValid(), "invalid type");
+  return type;
+}
+
+UniqueFEIRType FEIRTypeHelper::CreateTypeNative(MIRType &mirType) {
+  UniqueFEIRType type = std::make_unique<FEIRTypeNative>(mirType);
+  CHECK_FATAL(type->IsValid(), "invalid type");
+  return type;
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/feir_type_infer.cpp b/src/hir2mpl/common/src/feir_type_infer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8fb89a50fccdf2d0b2ee25c6bebea344b39cc023
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_type_infer.cpp
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_type_infer.h"
+#include "fe_type_hierarchy.h"
+#include "feir_type_helper.h"
+#include "feir_var_type_scatter.h"
+#include "feir_dfg.h"
+
+namespace maple {
+// ---------- FEIRTypeMergeHelper ----------
+FEIRTypeMergeHelper::FEIRTypeMergeHelper()
+    : firstType(true) {}
+
+FEIRTypeMergeHelper::FEIRTypeMergeHelper(const UniqueFEIRType &argTypeDefault)
+    : firstType(true) {
+  CHECK_FATAL(argTypeDefault.get() != nullptr, "nullptr check");
+  ResetTypeDefault(argTypeDefault);
+}
+
+void FEIRTypeMergeHelper::Reset() {
+  firstType = true;
+  type.reset();
+  error = "";
+}
+
+void FEIRTypeMergeHelper::ResetTypeDefault(const UniqueFEIRType &argTypeDefault) {
+  typeDefault = argTypeDefault->Clone();
+}
+
+bool FEIRTypeMergeHelper::MergeType(const UniqueFEIRType &argType, bool parent) {
+  if (firstType) {
+    type = argType->Clone();
+    firstType = false;
+    return true;
+  }
+  return MergeType(type, argType, parent);
+}
+
+UniqueFEIRType FEIRTypeMergeHelper::GetResult() const {
+  return type->Clone();
+}
+
+void FEIRTypeMergeHelper::SetDefaultType(UniqueFEIRType &typeDst) {
+  SetType(typeDst, typeDefault);
+}
+
+void FEIRTypeMergeHelper::SetType(UniqueFEIRType &typeDst, const UniqueFEIRType &typeSrc) {
+  ASSERT(typeDst.get() != nullptr, "nullptr check for type dst");
+  ASSERT(typeSrc.get() != nullptr, "nullptr check for type src");
+  if (typeDst.get()->GetKind() == typeSrc.get()->GetKind()) {
+    typeDst.get()->CopyFrom(*(typeSrc.get()));
+  } else {
+    typeDst = typeSrc->Clone();
+  }
+}
+
+bool FEIRTypeMergeHelper::MergeType(UniqueFEIRType &typeDst, const UniqueFEIRType &typeSrc, bool parent) {
+  ASSERT(typeDst.get() != nullptr, "nullptr check for type dst");
+  ASSERT(typeSrc.get() != nullptr, "nullptr check for type src");
+  ASSERT(typeDefault.get() != nullptr, "nullptr check for type default");
+  FEIRTypeKind kindDst = typeDst.get()->GetKind();
+  FEIRTypeKind kindSrc = typeSrc.get()->GetKind();
+  // boundary: equal
+  if (typeDst->IsEqualTo(typeSrc)) {
+    return true;
+  }
+  // boundary: zero
+  if (typeSrc->IsZero()) {
+    return true;
+  }
+  if (typeDst->IsZero()) {
+    SetType(typeDst, typeSrc);
+    return true;
+  }
+  if (kindDst == FEIRTypeKind::kFEIRTypePointer && kindSrc == FEIRTypeKind::kFEIRTypePointer) {
+    FEIRTypePointer *ptrTypeDst = static_cast<FEIRTypePointer*>(typeDst.get());
+    FEIRTypePointer *ptrTypeSrc = static_cast<FEIRTypePointer*>(typeSrc.get());
+    UniqueFEIRType mergedType = ptrTypeDst->Clone();
+    bool success = MergeType(mergedType, ptrTypeSrc->GetBaseType(), parent);
+    if (success) {
+      ptrTypeDst->SetBaseType(std::move(mergedType));
+    }
+    return success;
+  }
+  if (kindDst == FEIRTypeKind::kFEIRTypePointer && kindSrc != FEIRTypeKind::kFEIRTypePointer) {
+    return false;
+  }
+  if (kindDst != FEIRTypeKind::kFEIRTypePointer && kindSrc == FEIRTypeKind::kFEIRTypePointer) {
+    return false;
+  }
+  // boundary: default
+  if (typeSrc->IsEqualTo(typeDefault)) {
+    if (parent) {
+      SetDefaultType(typeDst);
+    }
+    return true;
+  }
+  if (typeDst->IsEqualTo(typeDefault)) {
+    if (!parent) {
+      SetType(typeDst, typeSrc);
+    }
+    return true;
+  }
+  // hierarchy check
+  FEIRTypeDefault *ptrTypeDst = static_cast<FEIRTypeDefault*>(typeDst.get());
+  FEIRTypeDefault *ptrTypeSrc = static_cast<FEIRTypeDefault*>(typeSrc.get());
+  GStrIdx idxDst = ptrTypeDst->GetTypeNameIdx();
+  GStrIdx idxSrc = ptrTypeSrc->GetTypeNameIdx();
+  if (ptrTypeDst->GetDim() != ptrTypeSrc->GetDim()) {
+    return false;
+  }
+  if (ptrTypeDst->GetPrimType() != ptrTypeSrc->GetPrimType()) {
+    return false;
+  }
+  if (FETypeHierarchy::GetInstance().IsParentOf(idxDst, idxSrc)) {
+    // dst is parent of src
+    if (!parent) {
+      (void)ptrTypeDst->SetTypeNameIdx(idxSrc);
+    }
+  } else if (FETypeHierarchy::GetInstance().IsParentOf(idxSrc, idxDst)) {
+    // src is parent of dst
+    if (parent) {
+      (void)ptrTypeDst->SetTypeNameIdx(idxSrc);
+    }
+  } else {
+    if (parent) {
+      SetDefaultType(typeDst);
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+// ---------- FEIRTypeInfer ----------
+FEIRTypeInfer::FEIRTypeInfer(MIRSrcLang argSrcLang, const FEIRDefUseChain &argMapDefUse)
+    : srcLang(argSrcLang),
+      mapDefUse(argMapDefUse) {
+  LoadTypeDefault();
+}
+
+void FEIRTypeInfer::LoadTypeDefault() {
+  switch (srcLang) {
+    case kSrcLangJava:
+      typeDefault = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+      mergeHelper.ResetTypeDefault(typeDefault);
+      break;
+    default:
+      typeDefault.reset();
+      break;
+  }
+}
+
+void FEIRTypeInfer::Reset() {
+  visitVars.clear();
+  withCircle = false;
+  first = true;
+}
+
+UniqueFEIRType FEIRTypeInfer::GetTypeForVarUse(const UniqueFEIRVar &varUse) {
+  CHECK_NULL_FATAL(varUse);
+  if (varUse->GetType()->IsPrecise()) {
+    return varUse->GetType()->Clone();
+  }
+  if (varUse->GetTrans().get() == nullptr) {
+    return typeDefault->Clone();
+  }
+  if (visitVars.find(&varUse) != visitVars.end()) {
+    withCircle = true;
+    return UniqueFEIRType();
+  }
+  CHECK_FATAL(visitVars.insert(&varUse).second, "visitVars insert failed");
+  bool isFirst = first;
+  first = false;
+  UniqueFEIRType ans = GetTypeByTransForVarUse(varUse);
+  if ((isFirst || (!withCircle)) && ans != nullptr) {
+    varUse->SetType(ans->Clone());
+    return ans->Clone();
+  } else {
+    return UniqueFEIRType();
+  }
+}
+
+UniqueFEIRType FEIRTypeInfer::GetTypeForVarDef(UniqueFEIRVar &varDef) {
+  CHECK_NULL_FATAL(varDef);
+  if (varDef->GetType()->IsPreciseRefType()) {
+    return varDef->GetType()->Clone();
+  }
+  if (varDef->GetType()->IsZero()) {
+      return UniqueFEIRType();
+  }
+  if (visitVars.find(&varDef) != visitVars.end()) {
+    withCircle = true;
+    return UniqueFEIRType();
+  }
+  CHECK_FATAL(visitVars.insert(&varDef).second, "visitVars insert failed");
+  auto it = mapDefUse.find(&varDef);
+  CHECK_FATAL(it != mapDefUse.end(), "use not found");
+  std::unordered_set<FEIRTypeKey, FEIRTypeKeyHash> useTypes;
+  for (const UniqueFEIRVar *use : it->second) {
+    CHECK_NULL_FATAL(use);
+    UniqueFEIRType useType = GetTypeForVarUse(*use);
+    if (useType != nullptr && (!useType->IsEqualTo(varDef->GetType()))) {
+      FEIRTypeKey key(useType);
+      if (useTypes.find(key) == useTypes.end()) {
+        CHECK_FATAL(useTypes.insert(key).second, "useTypes insert failed");
+      }
+    }
+  }
+  if (useTypes.size() > 0) {
+    FEIRTypeMergeHelper mh(typeDefault);
+    for (const FEIRTypeKey &typeKey : useTypes) {
+      UniqueFEIRType defType = typeKey.GetType()->Clone();
+      bool success = mh.MergeType(defType, false);
+      CHECK_FATAL(success, "merge type error");
+    }
+    return mh.GetTypeClone();
+  } else {
+    return UniqueFEIRType();
+  }
+}
+
+void FEIRTypeInfer::ProcessVarDef(UniqueFEIRVar &varDef) {
+  CHECK_NULL_FATAL(varDef);
+  auto it = mapDefUse.find(&varDef);
+  if (it == mapDefUse.end()) {
+    return;
+  }
+  std::unordered_set<FEIRTypeKey, FEIRTypeKeyHash> useTypes;
+  for (const UniqueFEIRVar *use : it->second) {
+    CHECK_NULL_FATAL(use);
+    UniqueFEIRType useType = GetTypeForVarUse(*use);
+    if (useType != nullptr && (!useType->IsEqualTo(varDef->GetType()))) {
+      FEIRTypeKey key(useType);
+      if (useTypes.find(key) == useTypes.end()) {
+        CHECK_FATAL(useTypes.insert(key).second, "useTypes insert failed");
+      }
+    }
+  }
+  if (useTypes.size() == 1 && !(varDef->GetType()->IsPrecise())) {
+    varDef->SetType((*(useTypes.begin())).GetType()->Clone());
+    return;
+  }
+  if (useTypes.size() > 0) {
+    std::unique_ptr<FEIRVarTypeScatter> varNew =
+        std::make_unique<FEIRVarTypeScatter>(static_cast<UniqueFEIRVar>(varDef->Clone()));
+    FEIRVarTypeScatter *ptrVarNew = varNew.get();
+    ptrVarNew->SetType(varDef->GetType()->Clone());
+    for (const FEIRTypeKey &typeKey : useTypes) {
+      ptrVarNew->AddScatterType(typeKey.GetType());
+    }
+    varDef.reset(varNew.release());
+  }
+}
+
+UniqueFEIRType FEIRTypeInfer::GetTypeByTransForVarUse(const UniqueFEIRVar &varUse) {
+  CHECK_NULL_FATAL(varUse);
+  FEIRVarTrans *ptrVarUseTrans = varUse->GetTrans().get();
+  CHECK_NULL_FATAL(ptrVarUseTrans);
+  UniqueFEIRVar &varDef = ptrVarUseTrans->GetVar();
+  CHECK_NULL_FATAL(varDef);
+  UniqueFEIRType defType = GetTypeForVarDef(varDef);
+  if (defType != nullptr) {
+    return ptrVarUseTrans->GetType(defType);
+  } else {
+    return defType;
+  }
+}
+
+Opcode FEIRTypeCvtHelper::ChooseCvtOpcodeByFromTypeAndToType(const FEIRType &fromType, const FEIRType &toType) {
+  if (IsRetypeable(fromType, toType)) {
+    return OP_retype;
+  } else if (IsIntCvt2Ref(fromType, toType)) {
+    return OP_cvt;
+  } else {
+    return OP_undef;
+  }
+}
+
+bool FEIRTypeCvtHelper::IsRetypeable(const FEIRType &fromType, const FEIRType &toType) {
+  return (fromType.GetPrimType() == toType.GetPrimType());
+}
+
+bool FEIRTypeCvtHelper::IsIntCvt2Ref(const FEIRType &fromType, const FEIRType &toType) {
+  return (IsPrimitiveInteger(fromType.GetPrimType()) && toType.IsPreciseRefType());
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/feir_var.cpp b/src/hir2mpl/common/src/feir_var.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..082030b15ee2deda6beefc25efdd2c3dcc773125
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_var.cpp
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_var.h"
+#include "feir_stmt.h"
+#include "global_tables.h"
+#include "feir_type_helper.h"
+#include "fe_config_parallel.h"
+#include "enhance_c_checker.h"
+
+namespace maple {
+// ---------- FEIRVarTrans ----------
+FEIRVarTrans::FEIRVarTrans(FEIRVarTransKind argKind, std::unique_ptr<FEIRVar> &argVar)
+    : kind(argKind), var(argVar) {
+  param.dimDelta = 0;
+  switch (kind) {
+    case kFEIRVarTransArrayDimIncr:
+    case kFEIRVarTransArrayDimDecr:
+      param.dimDelta = 1;
+      break;
+    default:
+      break;
+  }
+}
+
+FEIRVarTrans::FEIRVarTrans(FEIRVarTransKind argKind, std::unique_ptr<FEIRVar> &argVar, uint8 dimDelta)
+    : kind(argKind), var(argVar) {
+  param.dimDelta = 0;
+  switch (kind) {
+    case kFEIRVarTransArrayDimIncr:
+    case kFEIRVarTransArrayDimDecr:
+      param.dimDelta = dimDelta;
+      break;
+    default:
+      break;
+  }
+}
+
+UniqueFEIRType FEIRVarTrans::GetType(const UniqueFEIRType &type, PrimType primType, bool usePtr) {
+  ASSERT(type != nullptr, "nullptr check");
+  UniqueFEIRType typeNew = type->Clone();
+  switch (kind) {
+    case kFEIRVarTransDirect:
+      break;
+    case kFEIRVarTransArrayDimIncr: {
+      (void)typeNew->ArrayIncrDim(param.dimDelta);
+      if (typeNew->GetKind() != FEIRTypeKind::kFEIRTypePointer && usePtr) {
+        return FEIRTypeHelper::CreatePointerType(typeNew->Clone(), primType);
+      } else {
+        return typeNew;
+      }
+    }
+    case kFEIRVarTransArrayDimDecr: {
+      (void)typeNew->ArrayDecrDim(param.dimDelta);
+      if (typeNew->GetKind() == FEIRTypeKind::kFEIRTypePointer) {
+        FEIRTypePointer *ptrTypeNew = static_cast<FEIRTypePointer*>(typeNew.get());
+        ASSERT(ptrTypeNew->GetBaseType() != nullptr, "nullptr check");
+        if (ptrTypeNew->GetBaseType()->IsScalar()) {
+          return ptrTypeNew->GetBaseType()->Clone();
+        }
+      } else if (usePtr && !typeNew->IsScalar()) {
+        return FEIRTypeHelper::CreatePointerType(typeNew->Clone(), primType);
+      } else {
+        return typeNew;
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "unsupported trans kind");
+  }
+  return typeNew;
+}
+
+// ---------- FEIRVar ----------
+FEIRVar::FEIRVar(FEIRVarKind argKind)
+    : kind(argKind),
+      isGlobal(false),
+      isDef(false),
+      type(std::make_unique<FEIRTypeDefault>()) {
+  boundaryLenExpr = nullptr;
+}
+
+FEIRVar::FEIRVar(FEIRVarKind argKind, std::unique_ptr<FEIRType> argType)
+    : FEIRVar(argKind) {
+  boundaryLenExpr = nullptr;
+  SetType(std::move(argType));
+}
+
+FEIRVar::~FEIRVar() {}
+
+std::unique_ptr<FEIRVar> FEIRVar::Clone() const {
+  auto var = CloneImpl();
+  var->SetGlobal(isGlobal);
+  var->SetAttrs(genAttrs);
+  var->SetSectionAttr(sectionAttr);
+  if (boundaryLenExpr != nullptr) {
+    var->SetBoundaryLenExpr(boundaryLenExpr->Clone());
+  }
+  var->SetSrcLoc(loc);
+  return var;
+}
+
+void FEIRVar::SetBoundaryLenExpr(std::unique_ptr<FEIRExpr> expr) {
+  boundaryLenExpr = std::move(expr);
+}
+
+const std::unique_ptr<FEIRExpr> &FEIRVar::GetBoundaryLenExpr() const {
+  return boundaryLenExpr;
+}
+
+MIRSymbol *FEIRVar::GenerateGlobalMIRSymbolImpl(MIRBuilder &builder) const {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  MIRType *mirType = type->GenerateMIRTypeAuto();
+  std::string name = GetName(*mirType);
+  auto attrs = genAttrs.ConvertToTypeAttrs();
+  ENCChecker::InsertBoundaryLenExprInAtts(attrs, boundaryLenExpr);
+  // do not allow extern var override global var
+  MIRSymbol *gSymbol = builder.GetGlobalDecl(name);
+  if (gSymbol != nullptr && attrs.GetAttr(ATTR_extern)) {
+    return gSymbol;
+  }
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  gSymbol = builder.GetOrCreateGlobalDecl(name, *mirType);
+  // Set global var attr once
+  std::size_t pos = name.find("_7C");
+  if (pos != std::string::npos) {
+    std::string containerName = name.substr(0, pos);
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(containerName);
+    TyIdx containerTypeIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(strIdx);
+    if (containerTypeIdx != TyIdx(0)) {
+      MIRType *containerType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(containerTypeIdx);
+      if (containerType->IsStructType()) {
+        // for external class
+        MIRStructType *mirContainer = static_cast<MIRStructType*>(containerType);
+        if (!mirContainer->IsLocal()) {
+          gSymbol->SetStorageClass(kScExtern);
+        }
+        // for not defined field use
+        if (gSymbol->GetAttrs().GetAttrFlag() == 0) {
+          auto t = TypeAttrs();
+          t.SetAttr(ATTR_static);
+          gSymbol->AddAttrs(t);
+        }
+        for (auto field : mirContainer->GetStaticFields()) {
+          if (field.first == nameIdx) {
+            gSymbol->AddAttrs(field.second.second.ConvertToTypeAttrs());
+          }
+        }
+      }
+    }
+  }
+  if (attrs.GetAttr(ATTR_extern)) {
+    gSymbol->SetStorageClass(MIRStorageClass::kScExtern);
+    attrs.ResetAttr(AttrKind::ATTR_extern);
+  } else {
+    if (gSymbol->GetStorageClass() == MIRStorageClass::kScInvalid) {
+      gSymbol->SetStorageClass(MIRStorageClass::kScGlobal);
+    }
+  }
+  return gSymbol;
+}
+
+MIRSymbol *FEIRVar::GenerateLocalMIRSymbolImpl(MIRBuilder &builder) const {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  MIRType *mirType = type->GenerateMIRTypeAuto();
+  std::string name = GetName(*mirType);
+  MIRSymbol *mirSymbol = builder.GetOrCreateLocalDecl(name, *mirType);
+  auto attrs = genAttrs.ConvertToTypeAttrs();
+  ENCChecker::InsertBoundaryLenExprInAtts(attrs, boundaryLenExpr);
+  if (attrs.GetAttr(ATTR_static)) {
+    attrs.ResetAttr(ATTR_static);
+    mirSymbol->SetStorageClass(MIRStorageClass::kScPstatic);
+  }
+  mirSymbol->AddAttrs(attrs);
+  return mirSymbol;
+}
+
+MIRSymbol *FEIRVar::GenerateMIRSymbolImpl(MIRBuilder &builder) const {
+  if (isGlobal) {
+    return GenerateGlobalMIRSymbol(builder);
+  } else {
+    return GenerateLocalMIRSymbol(builder);
+  }
+}
+
+void FEIRVar::SetType(std::unique_ptr<FEIRType> argType) {
+  CHECK_FATAL(argType != nullptr, "input type is nullptr");
+  type = std::move(argType);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/feir_var_name.cpp b/src/hir2mpl/common/src/feir_var_name.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8da2483cd47276ead9e44da78d0d2b0c8f1cb8fc
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_var_name.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_var_name.h"
+#include "feir_stmt.h"
+
+namespace maple {
+// ---------- FEIRVarName ----------
+std::string FEIRVarName::GetNameImpl(const MIRType &mirType) const {
+  std::stringstream ss;
+  ASSERT(nameIdx.GetIdx() != 0, "invalid name idx");
+  std::string name = GlobalTables::GetStrTable().GetStringFromStrIdx(nameIdx);
+  ss << name;
+  if (withType) {
+    ss << "_";
+    if (type->IsScalar()) {
+      ss << GetPrimTypeName(type->GetPrimType());
+    } else {
+      ss << "R" << mirType.GetTypeIndex().GetIdx();
+    }
+  }
+  return ss.str();
+}
+
+std::string FEIRVarName::GetNameRawImpl() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(nameIdx);
+}
+
+std::unique_ptr<FEIRVar> FEIRVarName::CloneImpl() const {
+  return std::make_unique<FEIRVarName>(nameIdx, type->Clone(), withType);
+}
+
+bool FEIRVarName::EqualsToImpl(const std::unique_ptr<FEIRVar> &var) const {
+  if (var->GetKind() != kind) {
+    return false;
+  }
+  FEIRVarName *ptrVarName = static_cast<FEIRVarName*>(var.get());
+  ASSERT(ptrVarName != nullptr, "ptr var is nullptr");
+  return ptrVarName->nameIdx == nameIdx && GetType()->IsEqualTo(ptrVarName->GetType());
+}
+
+uint32 FEIRVarName::HashImpl() const {
+  return static_cast<uint32>(std::hash<uint32>{}(nameIdx));
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/feir_var_reg.cpp b/src/hir2mpl/common/src/feir_var_reg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c21a9ce99e42b9430cab5c80abca668499ee0fe5
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_var_reg.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_var_reg.h"
+#include <sstream>
+#include <functional>
+#include "mir_type.h"
+#include "fe_options.h"
+
+namespace maple {
+std::string FEIRVarReg::GetNameImpl(const MIRType &mirType) const {
+  thread_local static std::stringstream ss("");
+  ss.str("");
+  ss << "Reg";
+  ss << regNum;
+  ss << "_";
+  if (type->IsPreciseRefType()) {
+    ss << "R" << mirType.GetTypeIndex().GetIdx();
+  } else {
+    if (type->GetSrcLang() == kSrcLangJava) {
+      ss << GetPrimTypeJavaName(type->GetPrimType());
+    } else {
+      ss << GetPrimTypeName(type->GetPrimType());
+    }
+  }
+  return ss.str();
+}
+
+std::string FEIRVarReg::GetNameRawImpl() const {
+  thread_local static std::stringstream ss("");
+  ss.str("");
+  ss << "Reg" << regNum;
+  return ss.str();
+}
+
+MIRSymbol *FEIRVarReg::GenerateLocalMIRSymbolImpl(MIRBuilder &builder) const {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  MIRType *mirType = type->GenerateMIRTypeAuto();
+  std::string name = GetName(*mirType);
+  MIRSymbol *ret = builder.GetOrCreateLocalDecl(name, *mirType);
+  return ret;
+}
+
+std::unique_ptr<FEIRVar> FEIRVarReg::CloneImpl() const {
+  std::unique_ptr<FEIRVar> var = std::make_unique<FEIRVarReg>(regNum, type->Clone());
+  return var;
+}
+
+bool FEIRVarReg::EqualsToImpl(const std::unique_ptr<FEIRVar> &var) const {
+  if (var->GetKind() != kind) {
+    return false;
+  }
+  FEIRVarReg *ptrVarReg = static_cast<FEIRVarReg*>(var.get());
+  ASSERT(ptrVarReg != nullptr, "ptr var is nullptr");
+  return ptrVarReg->regNum == regNum;
+}
+
+uint32 FEIRVarReg::HashImpl() const {
+  return static_cast<uint32>(std::hash<uint32>{}(regNum));
+}
+
+// ========== FEIRVarAccumulator ==========
+std::string FEIRVarAccumulator::GetNameImpl(const MIRType &mirType) const {
+  thread_local static std::stringstream ss("");
+  ss.str("");
+  ss << "Reg";
+  ss << "_Accumulator";
+  ss << "_";
+  if (type->IsPreciseRefType()) {
+    ss << "R" << mirType.GetTypeIndex().GetIdx();
+  } else {
+    if (type->GetSrcLang() == kSrcLangJava) {
+      ss << GetPrimTypeJavaName(type->GetPrimType());
+    } else {
+      ss << GetPrimTypeName(type->GetPrimType());
+    }
+  }
+  return ss.str();
+}
+
+std::string FEIRVarAccumulator::GetNameRawImpl() const {
+  thread_local static std::stringstream ss("");
+  ss.str("");
+  ss << "Reg_Accumulator";
+  return ss.str();
+}
+
+std::unique_ptr<FEIRVar> FEIRVarAccumulator::CloneImpl() const {
+  std::unique_ptr<FEIRVar> var = std::make_unique<FEIRVarAccumulator>(regNum, type->Clone());
+  return var;
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/feir_var_type_scatter.cpp b/src/hir2mpl/common/src/feir_var_type_scatter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad4d77ab4830033d5011624a945f62069a7619fa
--- /dev/null
+++ b/src/hir2mpl/common/src/feir_var_type_scatter.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_var_type_scatter.h"
+
+namespace maple {
+FEIRVarTypeScatter::FEIRVarTypeScatter(UniqueFEIRVar argVar)
+    : FEIRVar(FEIRVarKind::kFEIRVarTypeScatter) {
+  ASSERT(argVar != nullptr, "nullptr check");
+  ASSERT(argVar->GetKind() != FEIRVarKind::kFEIRVarTypeScatter, "invalid input var type");
+  var = std::move(argVar);
+}
+
+void FEIRVarTypeScatter::AddScatterType(const UniqueFEIRType &type) {
+  if (var->GetType()->IsEqualTo(type)) {
+    return;
+  }
+  FEIRTypeKey key(type);
+  if (scatterTypes.find(key) == scatterTypes.end()) {
+    CHECK_FATAL(scatterTypes.insert(key).second, "scatterTypes insert failed");
+  }
+}
+
+std::string FEIRVarTypeScatter::GetNameImpl(const MIRType &mirType) const {
+  return var->GetName(mirType);
+}
+
+std::string FEIRVarTypeScatter::GetNameRawImpl() const {
+  return var->GetNameRaw();
+}
+
+std::unique_ptr<FEIRVar> FEIRVarTypeScatter::CloneImpl() const {
+  std::unique_ptr<FEIRVar> ans = std::make_unique<FEIRVarTypeScatter>(var->Clone());
+  FEIRVarTypeScatter *ptrAns = static_cast<FEIRVarTypeScatter*>(ans.get());
+  ASSERT(ptrAns != nullptr, "nullptr check");
+  for (const FEIRTypeKey &key : scatterTypes) {
+    ptrAns->AddScatterType(key.GetType());
+  }
+  return std::unique_ptr<FEIRVar>(ans.release());
+}
+
+bool FEIRVarTypeScatter::EqualsToImpl(const std::unique_ptr<FEIRVar> &argVar) const {
+  return false;
+}
+
+uint32 FEIRVarTypeScatter::HashImpl() const {
+  return 0;
+}
+
+MIRSymbol *FEIRVarTypeScatter::GenerateGlobalMIRSymbolImpl(MIRBuilder &builder) const {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  MIRType *mirType = var->GetType()->GenerateMIRTypeAuto();
+  std::string name = GetName(*mirType);
+  return builder.GetOrCreateGlobalDecl(name, *mirType);
+}
+
+MIRSymbol *FEIRVarTypeScatter::GenerateLocalMIRSymbolImpl(MIRBuilder &builder) const {
+  HIR2MPL_PARALLEL_FORBIDDEN();
+  MIRType *mirType = var->GetType()->GenerateMIRTypeAuto();
+  std::string name = GetName(*mirType);
+  return builder.GetOrCreateLocalDecl(name, *mirType);
+}
+
+MIRSymbol *FEIRVarTypeScatter::GenerateMIRSymbolImpl(MIRBuilder &builder) const {
+  if (isGlobal) {
+    return GenerateGlobalMIRSymbol(builder);
+  } else {
+    return GenerateLocalMIRSymbol(builder);
+  }
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/generic_attrs.cpp b/src/hir2mpl/common/src/generic_attrs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..de7ccba767bcca2de929cc927b4fde5d1efeb615
--- /dev/null
+++ b/src/hir2mpl/common/src/generic_attrs.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "generic_attrs.h"
+#include "global_tables.h"
+
+namespace maple {
+TypeAttrs GenericAttrs::ConvertToTypeAttrs() const {
+  TypeAttrs attr;
+  for (uint32 i = 0; i < kMaxATTRNum; ++i) {
+    if (attrFlag[i] == 0) {
+      continue;
+    }
+    auto tA = static_cast<GenericAttrKind>(i);
+    switch (tA) {
+#define TYPE_ATTR
+#define ATTR(STR)               \
+    case GENATTR_##STR:         \
+      attr.SetAttr(ATTR_##STR); \
+      break;
+#include "all_attributes.def"
+#undef ATTR
+#undef TYPE_ATTR
+      default:
+        ASSERT(false, "unknown TypeAttrs");
+        break;
+    }
+  }
+  if (GetContentFlag(GENATTR_pack)) {
+    attr.SetPack(static_cast<uint32>(std::get<int>(contentMap[GENATTR_pack])));
+  }
+  return attr;
+}
+
+FuncAttrs GenericAttrs::ConvertToFuncAttrs() {
+  FuncAttrs attr;
+  for (uint32 i = 0; i < kMaxATTRNum; ++i) {
+    if (attrFlag[i] == 0) {
+      continue;
+    }
+    auto tA = static_cast<GenericAttrKind>(i);
+    switch (tA) {
+#define FUNC_ATTR
+#define ATTR(STR)                   \
+    case GENATTR_##STR:             \
+      attr.SetAttr(FUNCATTR_##STR); \
+      break;
+#include "all_attributes.def"
+#undef ATTR
+#undef FUNC_ATTR
+      default:
+        ASSERT(false, "unknown FuncAttrs");
+        break;
+    }
+  }
+  if (GetContentFlag(GENATTR_alias)) {
+    std::string name = GlobalTables::GetStrTable().GetStringFromStrIdx(std::get<GStrIdx>(contentMap[GENATTR_alias]));
+    attr.SetAliasFuncName(name);
+  }
+  if (GetContentFlag(GENATTR_constructor_priority)) {
+    attr.SetConstructorPriority(std::get<int>(contentMap[GENATTR_constructor_priority]));
+  }
+  if (GetContentFlag(GENATTR_destructor_priority)) {
+    attr.SetDestructorPriority(std::get<int>(contentMap[GENATTR_destructor_priority]));
+  }
+  return attr;
+}
+
+FieldAttrs GenericAttrs::ConvertToFieldAttrs() {
+  FieldAttrs attr;
+  constexpr uint32 maxAttrNum = 128;
+  for (uint32 i = 0; i < maxAttrNum; ++i) {
+    if (attrFlag[i] == 0) {
+      continue;
+    }
+    auto tA = static_cast<GenericAttrKind>(i);
+    switch (tA) {
+#define FIELD_ATTR
+#define ATTR(STR)                  \
+    case GENATTR_##STR:            \
+      attr.SetAttr(FLDATTR_##STR); \
+      break;
+#include "all_attributes.def"
+#undef ATTR
+#undef FIELD_ATTR
+      default:
+        ASSERT(false, "unknown FieldAttrs");
+        break;
+    }
+  }
+  return attr;
+}
+}
diff --git a/src/hir2mpl/common/src/hir2mpl.cpp b/src/hir2mpl/common/src/hir2mpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b7b2febb18e4afcb4fc061560e5563ae9dd15600
--- /dev/null
+++ b/src/hir2mpl/common/src/hir2mpl.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fe_utils.h"
+#include "hir2mpl_compiler.h"
+#include "mpl_sighandler.h"
+using namespace maple;
+
+int main(int argc, char **argv) {
+  SigHandler::EnableAll();
+
+  MPLTimer timer;
+  timer.Start();
+  HIR2MPLOptions &options = HIR2MPLOptions::GetInstance();
+  if (!options.SolveArgs(argc, argv)) {
+    return static_cast<int>(FEErrno::kCmdParseError);
+  }
+  HIR2MPLEnv::GetInstance().Init();
+  MIRModule module;
+  HIR2MPLCompiler compiler(module);
+  int res = compiler.Run();
+  timer.Stop();
+  if (FEOptions::GetInstance().IsDumpTime()) {
+    INFO(kLncInfo, "hir2mpl time: %.2lfms", timer.ElapsedMilliseconds() / 1.0);
+  }
+  return res;
+}
diff --git a/src/hir2mpl/common/src/hir2mpl_compiler.cpp b/src/hir2mpl/common/src/hir2mpl_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d447d68387eebbf9fbd3643bb3ae189938ddc002
--- /dev/null
+++ b/src/hir2mpl/common/src/hir2mpl_compiler.cpp
@@ -0,0 +1,377 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "hir2mpl_compiler.h"
+#include <sstream>
+#include "fe_manager.h"
+#include "fe_file_type.h"
+#include "fe_timer.h"
+#include "inline_mplt.h"
+#ifndef ONLY_C
+#include "rc_setter.h"
+#endif
+
+namespace maple {
+HIR2MPLCompiler::HIR2MPLCompiler(MIRModule &argModule)
+    : module(argModule),
+      srcLang(kSrcLangJava),
+      mp(FEUtils::NewMempool("MemPool for HIR2MPLCompiler", false /* isLcalPool */)),
+      allocator(mp) {}
+
+HIR2MPLCompiler::~HIR2MPLCompiler() {
+  mp = nullptr;
+}
+
+void HIR2MPLCompiler::Init() {
+  FEManager::Init(module);
+  module.SetFlavor(maple::kFeProduced);
+  module.GetImportFiles().clear();
+#ifndef ONLY_C
+  if (FEOptions::GetInstance().IsRC()) {
+    bc::RCSetter::InitRCSetter("");
+  }
+#endif
+}
+
+void HIR2MPLCompiler::Release() {
+  FEManager::Release();
+  FEUtils::DeleteMempoolPtr(mp);
+}
+
+int HIR2MPLCompiler::Run() {
+  bool success = true;
+  Init();
+  CheckInput();
+  RegisterCompilerComponent();
+  success = success && LoadMplt();
+  SetupOutputPathAndName();
+  ParseInputs();
+  if (!FEOptions::GetInstance().GetXBootClassPath().empty()) {
+    LoadOnDemandTypes();
+  }
+  PreProcessDecls();
+  ProcessDecls();
+  ProcessPragmas();
+  if (!FEOptions::GetInstance().IsGenMpltOnly()) {
+    FETypeHierarchy::GetInstance().InitByGlobalTable();
+    ProcessFunctions();
+#ifndef ONLY_C
+    if (FEOptions::GetInstance().IsRC()) {
+      bc::RCSetter::GetRCSetter().MarkRCAttributes();
+    }
+  }
+  bc::RCSetter::ReleaseRCSetter();
+#else
+  }
+#endif
+  FEManager::GetManager().ReleaseStructElemMempool();
+  CHECK_FATAL(success, "Compile Error");
+  ExportMpltFile();
+  ExportMplFile();
+  logInfo.PrintUserWarnMessages();
+  logInfo.PrintUserErrorMessages();
+  int res = logInfo.GetUserErrorsNum() > 0 ? FEErrno::kFEError : FEErrno::kNoError;
+  HIR2MPLEnv::GetInstance().Finish();
+  Release();
+  return res;
+}
+
+void HIR2MPLCompiler::CheckInput() {
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process HIR2MPLCompiler::CheckInput() =====");
+  size_t nInput = 0;
+
+  // check input class files
+  const std::list<std::string> &inputClassNames = FEOptions::GetInstance().GetInputClassFiles();
+  if (!inputClassNames.empty()) {
+    nInput += inputClassNames.size();
+    if (firstInputName.empty()) {
+      firstInputName = inputClassNames.front();
+    }
+  }
+
+  // check input jar files
+  const std::list<std::string> &inputJarNames = FEOptions::GetInstance().GetInputJarFiles();
+  if (!inputJarNames.empty()) {
+    nInput += inputJarNames.size();
+    if (firstInputName.empty()) {
+      firstInputName = inputJarNames.front();
+    }
+  }
+
+  // check input dex files
+  const std::vector<std::string> &inputDexNames = FEOptions::GetInstance().GetInputDexFiles();
+  if (!inputDexNames.empty()) {
+    nInput += inputDexNames.size();
+    if (firstInputName.empty()) {
+      firstInputName = inputDexNames[0];
+    }
+  }
+
+  // check input ast files
+  const std::vector<std::string> &inputASTNames = FEOptions::GetInstance().GetInputASTFiles();
+  if (!inputASTNames.empty()) {
+    nInput += inputASTNames.size();
+    if (firstInputName.empty()) {
+      firstInputName = inputASTNames[0];
+    }
+  }
+
+  // check input mast files
+  const std::vector<std::string> &inputMASTNames = FEOptions::GetInstance().GetInputMASTFiles();
+  if (!inputMASTNames.empty()) {
+    nInput += inputMASTNames.size();
+    if (firstInputName.empty()) {
+      firstInputName = inputMASTNames[0];
+    }
+  }
+
+  CHECK_FATAL(nInput > 0, "Error occurs: no inputs. exit.");
+}
+
+void HIR2MPLCompiler::SetupOutputPathAndName() {
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process HIR2MPLCompiler::SetupOutputPathAndName() =====");
+  // get outputName from option
+  const std::string &outputName0 = FEOptions::GetInstance().GetOutputName();
+  if (!outputName0.empty()) {
+    outputName = outputName0;
+  } else {
+    // use default
+    outputName = FEFileType::GetName(firstInputName, true);
+    outputPath = FEFileType::GetPath(firstInputName);
+  }
+  const std::string &outputPath0 = FEOptions::GetInstance().GetOutputPath();
+  if (!outputPath0.empty()) {
+    outputPath = outputPath0[outputPath0.size() - 1] == '/' ? outputPath0 : (outputPath0 + "/");
+  }
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "OutputPath: %s", outputPath.c_str());
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "OutputName: %s", outputName.c_str());
+  std::string outName = "";
+  if (outputPath.empty()) {
+    outName = outputName;
+  } else {
+    outName = outputPath + outputName;
+  }
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "OutputFullName: %s", outName.c_str());
+  module.SetFileName(outName);
+  // mapleall need outName with type, but mplt file no need
+  size_t lastDot = outName.find_last_of(".");
+  if (lastDot == std::string::npos) {
+    outNameWithoutType = outName;
+  } else {
+    outNameWithoutType = outName.substr(0, lastDot);
+  }
+  std::string mpltName = outNameWithoutType + ".mplt";
+  if (srcLang != kSrcLangC) {
+    GStrIdx strIdx = module.GetMIRBuilder()->GetOrCreateStringIndex(mpltName);
+    module.GetImportFiles().push_back(strIdx);
+  }
+}
+
+inline void HIR2MPLCompiler::InsertImportInMpl(const std::list<std::string> &mplt) const {
+  for (const std::string &fileName : mplt) {
+    GStrIdx strIdx = module.GetMIRBuilder()->GetOrCreateStringIndex(fileName);
+    module.GetImportFiles().push_back(strIdx);
+  }
+}
+
+bool HIR2MPLCompiler::LoadMplt() {
+  bool success = true;
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process HIR2MPLCompiler::LoadMplt() =====");
+  // load mplt from sys
+  const std::list<std::string> &mpltsFromSys = FEOptions::GetInstance().GetInputMpltFilesFromSys();
+  success = success && FEManager::GetTypeManager().LoadMplts(mpltsFromSys, FETypeFlag::kSrcMpltSys,
+                                                             "Load mplt from sys");
+  InsertImportInMpl(mpltsFromSys);
+  // load mplt
+  const std::list<std::string> &mplts = FEOptions::GetInstance().GetInputMpltFiles();
+  success = success && FEManager::GetTypeManager().LoadMplts(mplts, FETypeFlag::kSrcMplt, "Load mplt");
+  InsertImportInMpl(mplts);
+  // load mplt from apk
+  const std::list<std::string> &mpltsFromApk = FEOptions::GetInstance().GetInputMpltFilesFromApk();
+  success = success && FEManager::GetTypeManager().LoadMplts(mpltsFromApk, FETypeFlag::kSrcMpltApk,
+                                                             "Load mplt from apk");
+  InsertImportInMpl(mpltsFromApk);
+  return success;
+}
+
+void HIR2MPLCompiler::ExportMpltFile() {
+  if (!FEOptions::GetInstance().IsNoMplFile() && srcLang != kSrcLangC) {
+    FETimer timer;
+    timer.StartAndDump("Output mplt");
+    module.DumpToHeaderFile(!FEOptions::GetInstance().IsGenAsciiMplt());
+    timer.StopAndDumpTimeMS("Output mplt");
+  }
+}
+
+void HIR2MPLCompiler::ExportMplFile() {
+  if (!FEOptions::GetInstance().IsNoMplFile() && !FEOptions::GetInstance().IsGenMpltOnly()) {
+    FETimer timer;
+    timer.StartAndDump("Output mpl");
+    bool emitStructureType = false;
+    // Currently, struct types cannot be dumped to mplt.
+    // After mid-end interfaces are optimized, the judgment can be deleted.
+    if (srcLang == kSrcLangC) {
+      emitStructureType = true;
+    }
+    module.OutputAsciiMpl("", ".mpl", nullptr, emitStructureType, false);
+    if (FEOptions::GetInstance().GetFuncInlineSize() != 0 && !FEOptions::GetInstance().GetWPAA()) {
+      std::unique_ptr<InlineMplt> modInline = std::make_unique<InlineMplt>(module);
+      bool isInlineNeeded = modInline->CollectInlineInfo(FEOptions::GetInstance().GetFuncInlineSize());
+      if (isInlineNeeded) {
+        modInline->DumpInlineCandidateToFile(outNameWithoutType + ".mplt_inline");
+      }
+    }
+    timer.StopAndDumpTimeMS("Output mpl");
+  }
+}
+
+void HIR2MPLCompiler::RegisterCompilerComponent(std::unique_ptr<HIR2MPLCompilerComponent> comp) {
+  CHECK_FATAL(comp != nullptr, "input compiler component is nullptr");
+  components.push_back(std::move(comp));
+}
+
+void HIR2MPLCompiler::ParseInputs() {
+  FETimer timer;
+  timer.StartAndDump("HIR2MPLCompiler::ParseInputs()");
+  for (const std::unique_ptr<HIR2MPLCompilerComponent> &comp : components) {
+    CHECK_NULL_FATAL(comp);
+    bool success = comp->ParseInput();
+    CHECK_FATAL(success, "Error occurs in HIR2MPLCompiler::ParseInputs(). exit.");
+  }
+  timer.StopAndDumpTimeMS("HIR2MPLCompiler::ParseInputs()");
+}
+
+void HIR2MPLCompiler::LoadOnDemandTypes() {
+  FETimer timer;
+  timer.StartAndDump("HIR2MPLCompiler::LoadOnDemandTypes()");
+  for (const std::unique_ptr<HIR2MPLCompilerComponent> &comp : components) {
+    CHECK_NULL_FATAL(comp);
+    bool success = comp->LoadOnDemandType();
+    CHECK_FATAL(success, "Error occurs in HIR2MPLCompiler::LoadOnDemandTypes(). exit.");
+  }
+  timer.StopAndDumpTimeMS("HIR2MPLCompiler::LoadOnDemandTypes()");
+}
+
+void HIR2MPLCompiler::PreProcessDecls() {
+  FETimer timer;
+  timer.StartAndDump("HIR2MPLCompiler::PreProcessDecls()");
+  for (const std::unique_ptr<HIR2MPLCompilerComponent> &comp : components) {
+    ASSERT(comp != nullptr, "nullptr check");
+    bool success = comp->PreProcessDecl();
+    CHECK_FATAL(success, "Error occurs in HIR2MPLCompiler::PreProcessDecls(). exit.");
+  }
+  timer.StopAndDumpTimeMS("HIR2MPLCompiler::PreProcessDecl()");
+}
+
+void HIR2MPLCompiler::ProcessDecls() {
+  FETimer timer;
+  timer.StartAndDump("HIR2MPLCompiler::ProcessDecl()");
+  for (const std::unique_ptr<HIR2MPLCompilerComponent> &comp : components) {
+    ASSERT(comp != nullptr, "nullptr check");
+    bool success = comp->ProcessDecl();
+    CHECK_FATAL(success, "Error occurs in HIR2MPLCompiler::ProcessDecls(). exit.");
+  }
+  timer.StopAndDumpTimeMS("HIR2MPLCompiler::ProcessDecl()");
+}
+
+void HIR2MPLCompiler::ProcessPragmas() {
+  FETimer timer;
+  timer.StartAndDump("HIR2MPLCompiler::ProcessPragmas()");
+  for (const std::unique_ptr<HIR2MPLCompilerComponent> &comp : components) {
+    ASSERT_NOT_NULL(comp);
+    comp->ProcessPragma();
+  }
+  timer.StopAndDumpTimeMS("HIR2MPLCompiler::ProcessPragmas()");
+}
+
+void HIR2MPLCompiler::ProcessFunctions() {
+  FETimer timer;
+  bool success = true;
+  timer.StartAndDump("HIR2MPLCompiler::ProcessFunctions()");
+  uint32 funcSize = 0;
+  for (const std::unique_ptr<HIR2MPLCompilerComponent> &comp : components) {
+    ASSERT(comp != nullptr, "nullptr check");
+    success = comp->ProcessFunctionSerial() && success;
+    funcSize += comp->GetFunctionsSize();
+    if (!success) {
+      const std::set<FEFunction*> &failedFEFunctions = comp->GetCompileFailedFEFunctions();
+      compileFailedFEFunctions.insert(failedFEFunctions.cbegin(), failedFEFunctions.cend());
+    }
+    if (FEOptions::GetInstance().IsDumpPhaseTime()) {
+      comp->DumpPhaseTimeTotal();
+    }
+    comp->ReleaseMemPool();
+  }
+  FEManager::GetTypeManager().MarkExternStructType();
+  module.SetNumFuncs(funcSize);
+  FindMinCompileFailedFEFunctions();
+  timer.StopAndDumpTimeMS("HIR2MPLCompiler::ProcessFunctions()");
+  CHECK_FATAL(success, "ProcessFunction error");
+}
+
+void HIR2MPLCompiler::RegisterCompilerComponent() {
+#ifndef ONLY_C
+  if (FEOptions::GetInstance().HasJBC()) {
+    FEOptions::GetInstance().SetTypeInferKind(FEOptions::TypeInferKind::kNo);
+    std::unique_ptr<HIR2MPLCompilerComponent> jbcCompilerComp = std::make_unique<JBCCompilerComponent>(module);
+    RegisterCompilerComponent(std::move(jbcCompilerComp));
+  }
+  if (FEOptions::GetInstance().GetInputDexFiles().size() != 0) {
+    bc::ArkAnnotationProcessor::Process();
+    std::unique_ptr<HIR2MPLCompilerComponent> bcCompilerComp =
+        std::make_unique<bc::BCCompilerComponent<bc::DexReader>>(module);
+    RegisterCompilerComponent(std::move(bcCompilerComp));
+  }
+#endif
+  if (FEOptions::GetInstance().GetInputASTFiles().size() != 0) {
+    srcLang = kSrcLangC;
+    std::unique_ptr<HIR2MPLCompilerComponent> astCompilerComp =
+        std::make_unique<ASTCompilerComponent<ASTParser>>(module);
+    RegisterCompilerComponent(std::move(astCompilerComp));
+  }
+#ifdef ENABLE_MAST
+  if (FEOptions::GetInstance().GetInputMASTFiles().size() != 0) {
+    srcLang = kSrcLangC;
+    std::unique_ptr<HIR2MPLCompilerComponent> mapleAstCompilerComp =
+        std::make_unique<ASTCompilerComponent<MapleASTParser>>(module);
+    RegisterCompilerComponent(std::move(mapleAstCompilerComp));
+  }
+#endif
+  module.SetSrcLang(srcLang);
+  FEManager::GetTypeManager().SetSrcLang(srcLang);
+}
+
+void HIR2MPLCompiler::FindMinCompileFailedFEFunctions() {
+  if (compileFailedFEFunctions.size() == 0) {
+    return;
+  }
+  FEFunction *minCompileFailedFEFunction = nullptr;
+  uint32 minFailedStmtCount = 0;
+  for (FEFunction *feFunc : compileFailedFEFunctions) {
+    if (minCompileFailedFEFunction == nullptr) {
+      minCompileFailedFEFunction = feFunc;
+      minFailedStmtCount = minCompileFailedFEFunction->GetStmtCount();
+    }
+    uint32 stmtCount = feFunc->GetStmtCount();
+    if (stmtCount < minFailedStmtCount) {
+      minCompileFailedFEFunction = feFunc;
+      minFailedStmtCount = stmtCount;
+    }
+  }
+  if (minCompileFailedFEFunction != nullptr) {
+    INFO(kLncWarn, "function compile failed!!! the min function is :");
+    INFO(kLncWarn, minCompileFailedFEFunction->GetDescription().c_str());
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/hir2mpl_compiler_component.cpp b/src/hir2mpl/common/src/hir2mpl_compiler_component.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ff7abd5bb0ef6257f9a299b6296ef9c69fba5fe7
--- /dev/null
+++ b/src/hir2mpl/common/src/hir2mpl_compiler_component.cpp
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "hir2mpl_compiler_component.h"
+#include <sstream>
+#include "fe_macros.h"
+#include "fe_timer.h"
+#include "fe_config_parallel.h"
+#include "fe_manager.h"
+
+namespace maple {
+// ---------- FEFunctionProcessTask ----------
+FEFunctionProcessTask::FEFunctionProcessTask(std::unique_ptr<FEFunction> argFunction)
+    : function(std::move(argFunction)) {}
+
+int FEFunctionProcessTask::RunImpl(MplTaskParam *param) {
+  bool success = function->Process();
+  if (success) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int FEFunctionProcessTask::FinishImpl(MplTaskParam *param) {
+  function->Finish();
+  return 0;
+}
+
+// ---------- FEFunctionProcessSchedular ----------
+void FEFunctionProcessSchedular::AddFunctionProcessTask(std::unique_ptr<FEFunction> function) {
+  std::unique_ptr<FEFunctionProcessTask> task = std::make_unique<FEFunctionProcessTask>(std::move(function));
+  AddTask(*task.get());
+  tasks.push_back(std::move(task));
+}
+
+void FEFunctionProcessSchedular::CallbackThreadMainStart() {
+  std::thread::id tid = std::this_thread::get_id();
+  if (FEOptions::GetInstance().GetDumpLevel() >= FEOptions::kDumpLevelInfoDebug) {
+    INFO(kLncInfo, "Start Run Thread (tid=%lx)", tid);
+  }
+  FEConfigParallel::GetInstance().RegisterRunThreadID(tid);
+}
+
+// ---------- HIR2MPLCompilerComponent ----------
+HIR2MPLCompilerComponent::HIR2MPLCompilerComponent(MIRModule &argModule, MIRSrcLang argSrcLang)
+    : funcSize(0),
+      module(argModule),
+      srcLang(argSrcLang),
+      phaseResultTotal(std::make_unique<FEFunctionPhaseResult>(true)) {}
+
+bool HIR2MPLCompilerComponent::LoadOnDemandTypeImpl() {
+  return false;
+}
+
+bool HIR2MPLCompilerComponent::PreProcessDeclImpl() {
+  FETimer timer;
+  timer.StartAndDump("HIR2MPLCompilerComponent::PreProcessDecl()");
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process HIR2MPLCompilerComponent::PreProcessDecl() =====");
+  bool success = true;
+  FEManager::GetJavaStringManager().GenStringMetaClassVar();
+  for (FEInputStructHelper *helper : structHelpers) {
+    ASSERT_NOT_NULL(helper);
+    success = helper->PreProcessDecl() ? success : false;
+  }
+  FEManager::GetTypeManager().InitMCCFunctions();
+  timer.StopAndDumpTimeMS("HIR2MPLCompilerComponent::PreProcessDecl()");
+  return success;
+}
+
+bool HIR2MPLCompilerComponent::ProcessDeclImpl() {
+  FETimer timer;
+  timer.StartAndDump("HIR2MPLCompilerComponent::ProcessDecl()");
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process HIR2MPLCompilerComponent::ProcessDecl() =====");
+  bool success = true;
+  for (FEInputStructHelper *helper : structHelpers) {
+    ASSERT_NOT_NULL(helper);
+    success = helper->ProcessDecl() ? success : false;
+  }
+  for (FEInputMethodHelper *helper : globalFuncHelpers) {
+    ASSERT_NOT_NULL(helper);
+    success = helper->ProcessDecl() ? success : false;
+  }
+  for (FEInputGlobalVarHelper *helper : globalVarHelpers) {
+    ASSERT_NOT_NULL(helper);
+    success = helper->ProcessDecl() ? success : false;
+  }
+  for (FEInputFileScopeAsmHelper *helper : globalFileScopeAsmHelpers) {
+    ASSERT_NOT_NULL(helper);
+    success = helper->ProcessDecl() ? success : false;
+  }
+  if (FEOptions::GetInstance().IsDbgFriendly()) {
+    for (FEInputEnumHelper *helper : enumHelpers) {
+      ASSERT_NOT_NULL(helper);
+      success = helper->ProcessDecl() ? success : false;
+    }
+  }
+  timer.StopAndDumpTimeMS("HIR2MPLCompilerComponent::ProcessDecl()");
+  return success;
+}
+
+bool HIR2MPLCompilerComponent::ProcessFunctionSerialImpl() {
+  std::stringstream ss;
+  ss << GetComponentName() << "::ProcessFunctionSerial()";
+  FETimer timer;
+  timer.StartAndDump(ss.str());
+  bool success = true;
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process %s =====", ss.str().c_str());
+  for (FEInputStructHelper *structHelper : structHelpers) {
+    ASSERT_NOT_NULL(structHelper);
+    for (FEInputMethodHelper *methodHelper : structHelper->GetMethodHelpers()) {
+      ASSERT_NOT_NULL(methodHelper);
+      std::unique_ptr<FEFunction> feFunction = CreatFEFunction(methodHelper);
+      feFunction->SetSrcFileName(structHelper->GetSrcFileName());
+      bool processResult = feFunction->Process();
+      if (!processResult) {
+        (void)compileFailedFEFunctions.insert(feFunction.get());
+      }
+      success = success && processResult;
+      feFunction->Finish();
+      funcSize++;
+    }
+  }
+  timer.StopAndDumpTimeMS(ss.str());
+  return success;
+}
+
+bool HIR2MPLCompilerComponent::ProcessFunctionParallelImpl(uint32 nthreads) {
+  std::stringstream ss;
+  ss << GetComponentName() << "::ProcessFunctionParallel()";
+  FETimer timer;
+  timer.StartAndDump(ss.str());
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process %s =====", ss.str().c_str());
+  FEFunctionProcessSchedular schedular(ss.str());
+  schedular.Init();
+  for (FEInputStructHelper *structHelper : structHelpers) {
+    ASSERT_NOT_NULL(structHelper);
+    for (FEInputMethodHelper *methodHelper : structHelper->GetMethodHelpers()) {
+      ASSERT_NOT_NULL(methodHelper);
+      std::unique_ptr<FEFunction> feFunction = CreatFEFunction(methodHelper);
+      feFunction->SetSrcFileName(structHelper->GetSrcFileName());
+      schedular.AddFunctionProcessTask(std::move(feFunction));
+      funcSize++;
+    }
+  }
+  schedular.SetDumpTime(FEOptions::GetInstance().IsDumpThreadTime());
+  (void)schedular.RunTask(nthreads, true);
+  timer.StopAndDumpTimeMS(ss.str());
+  return true;
+}
+
+std::string HIR2MPLCompilerComponent::GetComponentNameImpl() const {
+  return "HIR2MPLCompilerComponent";
+}
+
+bool HIR2MPLCompilerComponent::ParallelableImpl() const {
+  return false;
+}
+
+void HIR2MPLCompilerComponent::DumpPhaseTimeTotalImpl() const {
+  CHECK_NULL_FATAL(phaseResultTotal);
+  phaseResultTotal->DumpMS();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/common/src/hir2mpl_env.cpp b/src/hir2mpl/common/src/hir2mpl_env.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..98eb5a29cf92ee1f1a6994ba7e507c649fb3c9be
--- /dev/null
+++ b/src/hir2mpl/common/src/hir2mpl_env.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "hir2mpl_env.h"
+#include "global_tables.h"
+#include "mpl_logging.h"
+#include "fe_options.h"
+
+namespace maple {
+HIR2MPLEnv HIR2MPLEnv::instance;
+
+void HIR2MPLEnv::Init() {
+  srcFileIdxNameMap.clear();
+  srcFileIdxNameMap[0] = GStrIdx(0);
+  globalLabelIdx = 1;
+}
+
+void HIR2MPLEnv::Finish() {
+  srcFileIdxNameMap.clear();
+}
+
+uint32 HIR2MPLEnv::NewSrcFileIdx(const GStrIdx &nameIdx) {
+  size_t idx = srcFileIdxNameMap.size() + 1; // 1: already occupied by VtableImpl.mpl
+  CHECK_FATAL(idx < UINT32_MAX, "idx is out of range");
+  srcFileIdxNameMap[idx] = nameIdx;
+  return static_cast<uint32>(idx);
+}
+
+GStrIdx HIR2MPLEnv::GetFileNameIdx(uint32 fileIdx) const {
+  auto it = srcFileIdxNameMap.find(fileIdx);
+  if (it == srcFileIdxNameMap.end()) {
+    return GStrIdx(0);
+  } else {
+    return it->second;
+  }
+}
+
+std::string HIR2MPLEnv::GetFileName(uint32 fileIdx) const {
+  auto it = srcFileIdxNameMap.find(fileIdx);
+  if (it == srcFileIdxNameMap.end() || it->second == 0) {
+    return "unknown";
+  } else {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(it->second);
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/hir2mpl_option.cpp b/src/hir2mpl/common/src/hir2mpl_option.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b25bdc9062c3f3171105bac41da60ff089b80424
--- /dev/null
+++ b/src/hir2mpl/common/src/hir2mpl_option.cpp
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "driver_options.h"
+
+namespace opts::hir2mpl {
+
+maplecl::Option<bool> help({"--help", "-h"},
+                      "  -h, -help              : print usage and exit",
+                      {hir2mplCategory});
+
+maplecl::Option<bool> version({"--version", "-v"},
+                         "  -v, -version           : print version and exit",
+                         {hir2mplCategory});
+
+maplecl::Option<std::string> mpltSys({"--mplt-sys", "-mplt-sys"},
+                                "  -mplt-sys sys1.mplt,sys2.mplt\n"
+                                "                         : input sys mplt files",
+                                {hir2mplCategory});
+
+maplecl::Option<std::string> mpltApk({"--mplt-apk", "-mplt-apk"},
+                                "  -mplt-apk apk1.mplt,apk2.mplt\n"
+                                "                         : input apk mplt files",
+                                {hir2mplCategory});
+
+maplecl::Option<std::string> mplt({"--mplt", "-mplt"},
+                             "  -mplt lib1.mplt,lib2.mplt\n"
+                             "                         : input mplt files",
+                             {hir2mplCategory});
+
+maplecl::Option<std::string> inClass({"--in-class", "-in-class"},
+                                "  -in-class file1.jar,file2.jar\n"
+                                "                         : input class files",
+                                {hir2mplCategory});
+
+maplecl::Option<std::string> inJar({"--in-jar", "-in-jar"},
+                              "  -in-jar file1.jar,file2.jar\n"
+                              "                         : input jar files",
+                              {hir2mplCategory});
+
+maplecl::Option<std::string> inDex({"--in-dex", "-in-dex"},
+                              "  -in-dex file1.dex,file2.dex\n"
+                              "                         : input dex files",
+                              {hir2mplCategory});
+
+maplecl::Option<std::string> inAst({"--in-ast", "-in-ast"},
+                              "  -in-ast file1.ast,file2.ast\n"
+                              "                         : input ast files",
+                              {hir2mplCategory});
+
+maplecl::Option<std::string> inMast({"--in-mast", "-in-mast"},
+                               "  -in-mast file1.mast,file2.mast\n"
+                               "                         : input mast files",
+                               {hir2mplCategory});
+
+maplecl::Option<std::string> output({"--output", "-p"},
+                               "  -p, -output            : output path",
+                               {hir2mplCategory});
+
+maplecl::Option<std::string> outputName({"--output-name", "-o"},
+                                   "  -o, -output-name       : output name",
+                                   {hir2mplCategory});
+
+maplecl::Option<bool> mpltOnly({"--t", "-t"},
+                          "  -t                     : generate mplt only",
+                          {hir2mplCategory});
+
+maplecl::Option<bool> asciimplt({"--asciimplt", "-asciimplt"},
+                           "  -asciimplt             : generate mplt in ascii format",
+                           {hir2mplCategory});
+
+maplecl::Option<bool> dumpInstComment({"--dump-inst-comment", "-dump-inst-comment"},
+                                 "  -dump-inst-comment     : dump instruction comment",
+                                 {hir2mplCategory});
+
+maplecl::Option<bool> noMplFile({"--no-mpl-file", "-no-mpl-file"},
+                           "  -no-mpl-file           : disable dump mpl file",
+                           {hir2mplCategory});
+
+maplecl::Option<uint32_t> dumpLevel({"--dump-level", "-d"},
+                               "  -d, -dump-level xx     : debug info dump level\n"
+                               "                           [0] disable\n"
+                               "                           [1] dump simple info\n"
+                               "                           [2] dump detail info\n"
+                               "                           [3] dump debug info",
+                               {hir2mplCategory});
+
+maplecl::Option<bool> dumpTime({"--dump-time", "-dump-time"},
+                          "  -dump-time             : dump time",
+                          {hir2mplCategory});
+
+maplecl::Option<bool> dumpComment({"--dump-comment", "-dump-comment"},
+                             "  -dump-comment          : gen comment stmt",
+                             {hir2mplCategory});
+
+maplecl::Option<bool> dumpLOC({"--dump-LOC", "-dump-LOC"},
+                         "  -dump-LOC              : gen LOC",
+                         {hir2mplCategory});
+
+maplecl::Option<bool> dbgFriendly({"--g", "-g"},
+                             "  -g                     : emit debug friendly mpl, including\n"
+                             "                           no variable renaming\n"
+                             "                           gen LOC",
+                             {hir2mplCategory});
+
+maplecl::Option<bool> dumpPhaseTime({"--dump-phase-time", "-dump-phase-time"},
+                               "  -dump-phase-time       : dump total phase time",
+                               {hir2mplCategory});
+
+maplecl::Option<bool> dumpPhaseTimeDetail({"-dump-phase-time-detail", "--dump-phase-time-detail"},
+                                     "  -dump-phase-time-detail\n"      \
+                                     "                         : dump phase time for each method",
+                                     {hir2mplCategory});
+
+maplecl::Option<bool> rc({"-rc", "--rc"},
+                    "  -rc                    : enable rc",
+                    {hir2mplCategory});
+
+maplecl::Option<bool> nobarrier({"-nobarrier", "--nobarrier"},
+                           "  -nobarrier             : no barrier",
+                           {hir2mplCategory});
+
+maplecl::Option<bool> usesignedchar({"-usesignedchar", "--usesignedchar"},
+                               "  -usesignedchar         : use signed char",
+                               {hir2mplCategory});
+
+maplecl::Option<bool> o2({"-O2", "--O2"},
+                    "  -O2                    : enable hir2mpl O2 optimize",
+                    {hir2mplCategory});
+
+maplecl::Option<bool> simplifyShortCircuit({"-simplify-short-circuit", "--simplify-short-circuit"},
+                                      "  -simplify-short-circuit\n"     \
+                                      "                         : enable simplify short circuit",
+                                      {hir2mplCategory});
+
+maplecl::Option<bool> enableVariableArray({"-enable-variable-array", "--enable-variable-array"},
+                                     "  -enable-variable-array\n" \
+                                     "                         : enable variable array",
+                                     {hir2mplCategory});
+
+maplecl::Option<uint32_t> funcInliceSize({"-func-inline-size", "--func-inline-size"},
+                                    "  -func-inline-size      : set func inline size",
+                                    {hir2mplCategory});
+
+maplecl::Option<uint32_t> np({"-np", "--np"},
+                        "  -np num                : number of threads",
+                        {hir2mplCategory});
+
+maplecl::Option<bool> dumpThreadTime({"-dump-thread-time", "--dump-thread-time"},
+                                "  -dump-thread-time      : dump thread time in mpl schedular",
+                                {hir2mplCategory});
+
+maplecl::Option<std::string> xbootclasspath({"-Xbootclasspath", "--Xbootclasspath"},
+                                       "  -Xbootclasspath=bootclasspath\n" \
+                                       "                         : boot class path list",
+                                       {hir2mplCategory});
+
+maplecl::Option<std::string> classloadercontext({"-classloadercontext", "--classloadercontext"},
+                                           "  -classloadercontext=pcl\n" \
+                                           "                         : class loader context \n" \
+                                           "                         : path class loader",
+                                           {hir2mplCategory});
+
+maplecl::Option<std::string> dep({"-dep", "--dep"},
+                            "  -dep=all or func\n"                      \
+                            "                         : [all]  collect all dependent types\n" \
+                            "                         : [func] collect dependent types in function",
+                            {hir2mplCategory});
+
+maplecl::Option<std::string> depsamename({"-depsamename", "--depsamename"},
+                                    "  -DepSameNamePolicy=sys or src\n" \
+                                    "               : [sys] load type from sys when on-demand load same name type\n" \
+                                    "               : [src] load type from src when on-demand load same name type",
+                                    {hir2mplCategory});
+
+maplecl::Option<bool> npeCheckDynamic({"-npe-check-dynamic", "--npe-check-dynamic"},
+                                 "  --npe-check-dynamic     : Nonnull pointr dynamic checking",
+                                 {hir2mplCategory});
+
+maplecl::Option<bool> boundaryCheckDynamic({"-boundary-check-dynamic", "--boundary-check-dynamic"},
+                                      "  --boundary-check-dynamic\n"     \
+                                      "                         : Boundary dynamic checking",
+                                      {hir2mplCategory});
+
+maplecl::Option<bool> safeRegion({"-safe-region", "--safe-region"},
+                            "  --boundary-check-dynamic\n"               \
+                            "  --safe-region           : Enable safe region",
+                            {hir2mplCategory});
+
+maplecl::Option<bool> defaultSafe({"-defaultSafe", "--defaultSafe"},
+                                  "  --defaultSafe     : treat unmarked function or blocks as safe region by default",
+                                  {hir2mplCategory});
+
+maplecl::Option<bool> dumpFEIRBB({"-dump-bb", "--dump-bb"},
+                            "  -dump-bb               : dump basic blocks info",
+                            {hir2mplCategory});
+
+maplecl::Option<std::string> dumpFEIRCFGGraph({"-dump-cfg", "--dump-cfg"},
+                                         "  -dump-cfg funcname1,funcname2\n" \
+                                         "                         : dump cfg graph to dot file",
+                                         {hir2mplCategory});
+
+maplecl::Option<bool> wpaa({"-wpaa", "--wpaa"},
+                      "  -dump-cfg funcname1,funcname2\n"               \
+                      "  -wpaa                  : enable whole program ailas analysis",
+                      {hir2mplCategory});
+
+maplecl::Option<bool> debug({"-debug", "--debug"},
+                      "  -debug                 : dump enabled options",
+                      {hir2mplCategory});
+
+}
diff --git a/src/hir2mpl/common/src/hir2mpl_options.cpp b/src/hir2mpl/common/src/hir2mpl_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed2787cdf44761c4cf47cbb7ed0b030a1e669a4e
--- /dev/null
+++ b/src/hir2mpl/common/src/hir2mpl_options.cpp
@@ -0,0 +1,623 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "hir2mpl_options.h"
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <unordered_set>
+#include "driver_options.h"
+#include "file_utils.h"
+#include "fe_options.h"
+#include "fe_macros.h"
+#include "fe_file_type.h"
+#include "hir2mpl_option.h"
+#include "parser_opt.h"
+#include "triple.h"
+#include "types_def.h"
+#include "version.h"
+
+namespace maple {
+
+HIR2MPLOptions::HIR2MPLOptions() {
+  Init();
+}
+
+void HIR2MPLOptions::Init() const {
+  FEOptions::GetInstance().Init();
+  bool success = InitFactory();
+  CHECK_FATAL(success, "InitFactory failed. Exit.");
+}
+
+bool HIR2MPLOptions::InitFactory() {
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::help,
+                                         &HIR2MPLOptions::ProcessHelp);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::version,
+                                         &HIR2MPLOptions::ProcessVersion);
+
+  // input control options
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::mpltSys,
+                                         &HIR2MPLOptions::ProcessInputMpltFromSys);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::mpltApk,
+                                         &HIR2MPLOptions::ProcessInputMpltFromApk);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::mplt,
+                                         &HIR2MPLOptions::ProcessInputMplt);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inClass,
+                                         &HIR2MPLOptions::ProcessInClass);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inJar,
+                                         &HIR2MPLOptions::ProcessInJar);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inDex,
+                                         &HIR2MPLOptions::ProcessInDex);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inAst,
+                                         &HIR2MPLOptions::ProcessInAST);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inMast,
+                                         &HIR2MPLOptions::ProcessInMAST);
+
+  // output control options
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::output,
+                                         &HIR2MPLOptions::ProcessOutputPath);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::outputName,
+                                         &HIR2MPLOptions::ProcessOutputName);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::mpltOnly,
+                                         &HIR2MPLOptions::ProcessGenMpltOnly);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::asciimplt,
+                                         &HIR2MPLOptions::ProcessGenAsciiMplt);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpInstComment,
+                                         &HIR2MPLOptions::ProcessDumpInstComment);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::noMplFile,
+                                         &HIR2MPLOptions::ProcessNoMplFile);
+
+  // debug info control options
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpLevel,
+                                         &HIR2MPLOptions::ProcessDumpLevel);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpTime,
+                                         &HIR2MPLOptions::ProcessDumpTime);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpComment,
+                                         &HIR2MPLOptions::ProcessDumpComment);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpLOC,
+                                         &HIR2MPLOptions::ProcessDumpLOC);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dbgFriendly,
+                                         &HIR2MPLOptions::ProcessDbgFriendly);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpPhaseTime,
+                                         &HIR2MPLOptions::ProcessDumpPhaseTime);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpPhaseTimeDetail,
+                                         &HIR2MPLOptions::ProcessDumpPhaseTimeDetail);
+
+  // general stmt/bb/cfg debug options
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpFEIRBB,
+                                         &HIR2MPLOptions::ProcessDumpFEIRBB);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpFEIRCFGGraph,
+                                         &HIR2MPLOptions::ProcessDumpFEIRCFGGraph);
+
+  // multi-thread control options
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::np,
+                                         &HIR2MPLOptions::ProcessNThreads);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpThreadTime,
+                                         &HIR2MPLOptions::ProcessDumpThreadTime);
+
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::rc,
+                                         &HIR2MPLOptions::ProcessRC);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::nobarrier,
+                                         &HIR2MPLOptions::ProcessNoBarrier);
+
+  // ast compiler options
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::usesignedchar,
+                                         &HIR2MPLOptions::ProcessUseSignedChar);
+
+  // On Demand Type Creation
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::xbootclasspath,
+                                         &HIR2MPLOptions::ProcessXbootclasspath);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::classloadercontext,
+                                         &HIR2MPLOptions::ProcessClassLoaderContext);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dep,
+                                         &HIR2MPLOptions::ProcessCollectDepTypes);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::depsamename,
+                                         &HIR2MPLOptions::ProcessDepSameNamePolicy);
+  // EnhanceC
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::npeCheckDynamic,
+                                         &HIR2MPLOptions::ProcessNpeCheckDynamic);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::boundaryCheckDynamic,
+                                         &HIR2MPLOptions::ProcessBoundaryCheckDynamic);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::safeRegion,
+                                         &HIR2MPLOptions::ProcessSafeRegion);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::defaultSafe,
+                                         &HIR2MPLOptions::ProcessDefaultSafe);
+
+  // O2 does not work, because it generates OP_ror instruction but this instruction is not supported in me
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::o2,
+                                         &HIR2MPLOptions::ProcessO2);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::simplifyShortCircuit,
+                                         &HIR2MPLOptions::ProcessSimplifyShortCircuit);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::enableVariableArray,
+                                         &HIR2MPLOptions::ProcessEnableVariableArray);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::funcInliceSize,
+                                         &HIR2MPLOptions::ProcessFuncInlineSize);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::wpaa,
+                                         &HIR2MPLOptions::ProcessWPAA);
+
+  return true;
+}
+
+bool HIR2MPLOptions::SolveOptions(bool isDebug) {
+  if (opts::target.IsEnabledByUser()) {
+    Triple::GetTriple().Init(opts::target.GetValue());
+  } else {
+    Triple::GetTriple().Init();
+  }
+
+  if (Triple::GetTriple().IsBigEndian()) {
+    (void)ProcessBigEndian();
+  }
+
+  for (const auto &opt : hir2mplCategory.GetEnabledOptions()) {
+    std::string printOpt;
+    if (isDebug) {
+      for (const auto &val : opt->GetRawValues()) {
+        printOpt += opt->GetName() + " " + val + " ";
+      }
+      LogInfo::MapleLogger() << "hir2mpl options: " << printOpt << '\n';
+    }
+
+    auto func = CreateProductFunction<OptionFactory>(opt);
+    if (func != nullptr) {
+      if (!func(this, *opt)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+bool HIR2MPLOptions::SolveArgs(int argc, char **argv) {
+  maplecl::CommandLine::GetCommandLine().Parse(argc, argv, hir2mplCategory);
+  bool result = SolveOptions(opts::hir2mpl::debug);
+  if (!result) {
+    return result;
+  }
+
+  std::vector<std::string> inputs;
+  for (auto &arg : maplecl::CommandLine::GetCommandLine().badCLArgs) {
+    if (FileUtils::IsFileExists(arg.first)) {
+      inputs.push_back(arg.first);
+    } else {
+      ERR(kLncErr, "Unknown Option: %s\n", arg.first.c_str());
+      DumpUsage();
+      return result;
+    }
+  }
+
+  if (inputs.size() >= 1) {
+    ProcessInputFiles(inputs);
+    return true;
+  } else {
+    ERR(kLncErr, "Input File is not specified\n");
+    DumpUsage();
+    return false;
+  }
+}
+
+void HIR2MPLOptions::DumpUsage() const {
+  std::cout << "\n====== Usage: hir2mpl [options] input1 input2 input3 ======\n";
+  maplecl::CommandLine::GetCommandLine().HelpPrinter(hir2mplCategory);
+}
+
+void HIR2MPLOptions::DumpVersion() const {
+  std::cout << "Maple FE Version : " << Version::GetVersionStr() << std::endl;
+}
+
+bool HIR2MPLOptions::ProcessHelp(const maplecl::OptionInterface &) const {
+  DumpUsage();
+  return false;
+}
+
+bool HIR2MPLOptions::ProcessVersion(const maplecl::OptionInterface &) const {
+  DumpVersion();
+  return false;
+}
+
+bool HIR2MPLOptions::ProcessInClass(const maplecl::OptionInterface &inClass) const {
+  std::string arg = inClass.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
+  for (const std::string &fileName : listFiles) {
+    FEOptions::GetInstance().AddInputClassFile(fileName);
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessInJar(const maplecl::OptionInterface &inJar) const {
+  std::string arg = inJar.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
+  for (const std::string &fileName : listFiles) {
+    FEOptions::GetInstance().AddInputJarFile(fileName);
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessInDex(const maplecl::OptionInterface &inDex) const {
+  std::string arg = inDex.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
+  for (const std::string &fileName : listFiles) {
+    FEOptions::GetInstance().AddInputDexFile(fileName);
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessInAST(const maplecl::OptionInterface &inAst) const {
+  std::string arg = inAst.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
+  for (const std::string &fileName : listFiles) {
+    FEOptions::GetInstance().AddInputASTFile(fileName);
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessInMAST(const maplecl::OptionInterface &inMast) const {
+  std::string arg = inMast.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
+  for (const std::string &fileName : listFiles) {
+    FEOptions::GetInstance().AddInputMASTFile(fileName);
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessInputMplt(const maplecl::OptionInterface &mplt) const {
+  std::string arg = mplt.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
+  for (const std::string &fileName : listFiles) {
+    FEOptions::GetInstance().AddInputMpltFile(fileName);
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessInputMpltFromSys(const maplecl::OptionInterface &mpltSys) const {
+  std::string arg = mpltSys.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
+  for (const std::string &fileName : listFiles) {
+    FEOptions::GetInstance().AddInputMpltFileFromSys(fileName);
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessInputMpltFromApk(const maplecl::OptionInterface &mpltApk) const {
+  std::string arg = mpltApk.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
+  for (const std::string &fileName : listFiles) {
+    FEOptions::GetInstance().AddInputMpltFileFromApk(fileName);
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessOutputPath(const maplecl::OptionInterface &output) const {
+  std::string arg = output.GetCommonValue();
+  FEOptions::GetInstance().SetOutputPath(arg);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessOutputName(const maplecl::OptionInterface &outputName) const {
+  std::string arg = outputName.GetCommonValue();
+  FEOptions::GetInstance().SetOutputName(arg);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessGenMpltOnly(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsGenMpltOnly(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessGenAsciiMplt(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsGenAsciiMplt(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpInstComment(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().EnableDumpInstComment();
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessNoMplFile(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetNoMplFile();
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpLevel(const maplecl::OptionInterface &outputName) const {
+  int arg = outputName.GetCommonValue();
+  FEOptions::GetInstance().SetDumpLevel(arg);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpTime(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsDumpTime(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpComment(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsDumpComment(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpLOC(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsDumpLOC(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDbgFriendly(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetDbgFriendly(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpPhaseTime(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsDumpPhaseTime(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpPhaseTimeDetail(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsDumpPhaseTimeDetail(true);
+  return true;
+}
+
+// java compiler options
+bool HIR2MPLOptions::ProcessModeForJavaStaticFieldName(const maplecl::OptionInterface &opt) const {
+  const std::string &arg = opt.GetCommonValue();
+  if (arg.compare("notype") == 0) {
+    FEOptions::GetInstance().SetModeJavaStaticFieldName(FEOptions::ModeJavaStaticFieldName::kNoType);
+  } else if (arg.compare("alltype") == 0) {
+    FEOptions::GetInstance().SetModeJavaStaticFieldName(FEOptions::ModeJavaStaticFieldName::kAllType);
+  } else if (arg.compare("smart") == 0) {
+    FEOptions::GetInstance().SetModeJavaStaticFieldName(FEOptions::ModeJavaStaticFieldName::kSmart);
+  } else {
+    ERR(kLncErr, "unsupported options: %s", arg.c_str());
+    return false;
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessJBCInfoUsePathName(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsJBCInfoUsePathName(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpJBCStmt(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsDumpJBCStmt(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpJBCAll(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsDumpJBCAll(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpJBCErrorOnly(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsDumpJBCErrorOnly(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpJBCFuncName(const maplecl::OptionInterface &opt) const {
+  std::string arg = opt.GetCommonValue();
+  while (!arg.empty()) {
+    size_t pos = arg.find(",");
+    if (pos != std::string::npos) {
+      FEOptions::GetInstance().AddDumpJBCFuncName(arg.substr(0, pos));
+      arg = arg.substr(pos + 1);
+    } else {
+      FEOptions::GetInstance().AddDumpJBCFuncName(arg);
+      arg = "";
+    }
+  }
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessEmitJBCLocalVarInfo(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsEmitJBCLocalVarInfo(true);
+  return true;
+}
+
+// bc compiler options
+bool HIR2MPLOptions::ProcessRC(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetRC(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessNoBarrier(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetNoBarrier(true);
+  return true;
+}
+
+// ast compiler options
+bool HIR2MPLOptions::ProcessUseSignedChar(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetUseSignedChar(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessBigEndian() const {
+  FEOptions::GetInstance().SetBigEndian(true);
+  return true;
+}
+
+// general stmt/bb/cfg debug options
+bool HIR2MPLOptions::ProcessDumpFEIRBB(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsDumpFEIRBB(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpFEIRCFGGraph(const maplecl::OptionInterface &opt) const {
+  std::string arg = opt.GetCommonValue();
+  std::list<std::string> funcNameList = SplitByComma(arg);
+  for (const std::string &funcName : funcNameList) {
+    FEOptions::GetInstance().AddFuncNameForDumpCFGGraph(funcName);
+  }
+  return true;
+}
+
+// multi-thread control options
+bool HIR2MPLOptions::ProcessNThreads(const maplecl::OptionInterface &numThreads) const {
+  uint32_t num = numThreads.GetCommonValue();
+  FEOptions::GetInstance().SetNThreads(num);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDumpThreadTime(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetDumpThreadTime(true);
+  return true;
+}
+
+void HIR2MPLOptions::ProcessInputFiles(const std::vector<std::string> &inputs) const {
+  FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process HIR2MPLOptions::ProcessInputFiles() =====");
+  for (const std::string &inputName : inputs) {
+    FEFileType::FileType type = FEFileType::GetInstance().GetFileTypeByPathName(inputName);
+    switch (type) {
+      case FEFileType::kClass:
+        FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "CLASS file detected: %s", inputName.c_str());
+        FEOptions::GetInstance().AddInputClassFile(inputName);
+        break;
+      case FEFileType::kJar:
+        FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "JAR file detected: %s", inputName.c_str());
+        FEOptions::GetInstance().AddInputJarFile(inputName);
+        break;
+      case FEFileType::kDex:
+        FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "DEX file detected: %s", inputName.c_str());
+        FEOptions::GetInstance().AddInputDexFile(inputName);
+        break;
+      case FEFileType::kAST:
+        FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "AST file detected: %s", inputName.c_str());
+        FEOptions::GetInstance().AddInputASTFile(inputName);
+        break;
+      case FEFileType::kMAST:
+        FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "MAST file detected: %s", inputName.c_str());
+        FEOptions::GetInstance().AddInputMASTFile(inputName);
+        break;
+      default:
+        WARN(kLncErr, "unsupported file format (%s)", inputName.c_str());
+        break;
+    }
+  }
+}
+
+// Xbootclasspath
+bool HIR2MPLOptions::ProcessXbootclasspath(const maplecl::OptionInterface &xbootclasspath) const {
+  std::string arg = xbootclasspath.GetCommonValue();
+  FEOptions::GetInstance().SetXBootClassPath(arg);
+  return true;
+}
+
+// PCL
+bool HIR2MPLOptions::ProcessClassLoaderContext(const maplecl::OptionInterface &classloadercontext) const {
+  std::string arg = classloadercontext.GetCommonValue();
+  FEOptions::GetInstance().SetClassLoaderContext(arg);
+  return true;
+}
+
+// Dep
+bool HIR2MPLOptions::ProcessCollectDepTypes(const maplecl::OptionInterface &dep) const {
+  const std::string arg = dep.GetCommonValue();
+  if (arg.compare("all") == 0) {
+    FEOptions::GetInstance().SetModeCollectDepTypes(FEOptions::ModeCollectDepTypes::kAll);
+  } else if (arg.compare("func") == 0) {
+    FEOptions::GetInstance().SetModeCollectDepTypes(FEOptions::ModeCollectDepTypes::kFunc);
+  } else {
+    ERR(kLncErr, "unsupported options: %s", arg.c_str());
+    return false;
+  }
+  return true;
+}
+
+// SameNamePolicy
+bool HIR2MPLOptions::ProcessDepSameNamePolicy(const maplecl::OptionInterface &depsamename) const {
+  const std::string arg = depsamename.GetCommonValue();
+  if (arg.compare("sys") == 0) {
+    FEOptions::GetInstance().SetModeDepSameNamePolicy(FEOptions::ModeDepSameNamePolicy::kSys);
+  } else if (arg.compare("src") == 0) {
+    FEOptions::GetInstance().SetModeDepSameNamePolicy(FEOptions::ModeDepSameNamePolicy::kSrc);
+  } else {
+    ERR(kLncErr, "unsupported options: %s", arg.c_str());
+    return false;
+  }
+  return true;
+}
+
+// EnhanceC
+bool HIR2MPLOptions::ProcessNpeCheckDynamic(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetNpeCheckDynamic(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessBoundaryCheckDynamic(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetBoundaryCheckDynamic(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessSafeRegion(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetSafeRegion(true);
+  // boundary and npe checking options will be opened, if safe region option is opened
+  FEOptions::GetInstance().SetNpeCheckDynamic(true);
+  FEOptions::GetInstance().SetBoundaryCheckDynamic(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessDefaultSafe(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetDefaultSafe(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessO2(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetO2(false);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessSimplifyShortCircuit(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetSimplifyShortCircuit(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessEnableVariableArray(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetEnableVariableArray(true);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessFuncInlineSize(const maplecl::OptionInterface &funcInliceSize) const {
+  uint32_t size = funcInliceSize.GetCommonValue();
+  FEOptions::GetInstance().SetFuncInlineSize(size);
+  return true;
+}
+
+bool HIR2MPLOptions::ProcessWPAA(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetWPAA(true);
+  FEOptions::GetInstance().SetFuncInlineSize(UINT32_MAX);
+  return true;
+}
+
+// AOT
+bool HIR2MPLOptions::ProcessAOT(const maplecl::OptionInterface &) const {
+  FEOptions::GetInstance().SetIsAOT(true);
+  return true;
+}
+
+template <typename Out>
+void HIR2MPLOptions::Split(const std::string &s, char delim, Out result) {
+  std::stringstream ss;
+  ss.str(s);
+  std::string item;
+  while (std::getline(ss, item, delim)) {
+    *(result++) = item;
+  }
+}
+
+std::list<std::string> HIR2MPLOptions::SplitByComma(const std::string &s) {
+  std::list<std::string> results;
+  HIR2MPLOptions::Split(s, ',', std::back_inserter(results));
+  return results;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/simple_xml.cpp b/src/hir2mpl/common/src/simple_xml.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ecb6bab9345b227354ed71d2f688274ea50543ec
--- /dev/null
+++ b/src/hir2mpl/common/src/simple_xml.cpp
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "simple_xml.h"
+
+namespace maple {
+SimpleXMLElem::SimpleXMLElem(MapleAllocator &alloc, const std::string &cat)
+    : tagID(kXMLIDNone),
+      tagValue(kXMLValueNone),
+      allocator(alloc),
+      catalog(cat),
+      id(0),
+      valueString(""),
+      content(""),
+      elems(allocator.Adapter()) {
+  value.raw = 0;
+  CHECK_FATAL(allocator.GetMemPool(), "mp is null");
+}
+
+SimpleXMLElem::SimpleXMLElem(MapleAllocator &alloc, const std::string &cat, uint32 argID)
+    : tagID(kXMLID),
+      tagValue(kXMLValueNone),
+      allocator(alloc),
+      catalog(cat),
+      id(argID),
+      valueString(""),
+      content(""),
+      elems(allocator.Adapter()) {
+  value.raw = 0;
+  CHECK_FATAL(allocator.GetMemPool(), "mp is null");
+}
+
+void SimpleXMLElem::DumpImpl(std::ostream &os, const std::string &prefix) const {
+  DumpHead(os, prefix);
+  if (elems.size() > 0) {
+    os << std::endl;
+    for (auto elem : elems) {
+      elem->Dump(os, prefix + "  ");
+    }
+    os << prefix;
+  } else {
+    if (content != "") {
+      os << "\"" << XMLString(content) << "\"";
+    }
+  }
+  DumpTail(os, "");
+  os << std::endl;
+}
+
+void SimpleXMLElem::DumpHead(std::ostream &os, const std::string &prefix) const {
+  os << prefix << "<" << catalog;
+  if (tagID == kXMLID) {
+    os << " id=\"" << id << "\"";
+  }
+  switch (tagValue) {
+    case kXMLValueNone:
+      break;
+    case kXMLValueI8:
+      os << " value=\"" << static_cast<int32>(value.i8) << "\"";
+      break;
+    case kXMLValueU8:
+      os << " value=\"" << static_cast<uint32>(value.u8) << "\"";
+      break;
+    case kXMLValueI16:
+      os << " value=\"" << static_cast<int32>(value.i16) << "\"";
+      break;
+    case kXMLValueU16:
+      os << " value=\"" << static_cast<uint32>(value.u16) << "\"";
+      break;
+    case kXMLValueI32:
+      os << " value=\"" << value.i32 << "\"";
+      break;
+    case kXMLValueU32:
+      os << " value=\"" << value.u32 << "\"";
+      break;
+    case kXMLValueI64:
+      os << " value=\"" << value.i64 << "\"";
+      break;
+    case kXMLValueU64:
+      os << " value=\"" << value.u64 << "\"";
+      break;
+    case kXMLValueFloat:
+      os << " value=\"" << value.f << "\"";
+      break;
+    case kXMLValueDouble:
+      os << " value=\"" << value.d << "\"";
+      break;
+    case kXMLValueString:
+      os << " value=\"" << XMLString(valueString) << "\"";
+      break;
+    default:
+      break;
+  }
+  os << ">";
+}
+
+void SimpleXMLElem::DumpTail(std::ostream &os, const std::string &prefix) const {
+  os << prefix << "</" << catalog << ">";
+}
+
+void SimpleXMLElem::AddElement(SimpleXMLElem &elem) {
+  elems.push_back(&elem);
+}
+
+SimpleXMLElem *SimpleXMLElem::AddNewElement(const std::string &cat) {
+  MemPool *mp = allocator.GetMemPool();
+  CHECK_NULL_FATAL(mp);
+  SimpleXMLElem *elem = mp->New<SimpleXMLElem>(allocator, cat);
+  AddElement(*elem);
+  return elem;
+}
+
+SimpleXMLElem *SimpleXMLElem::AddNewElement(const std::string &cat, uint32 argID) {
+  MemPool *mp = allocator.GetMemPool();
+  CHECK_NULL_FATAL(mp);
+  SimpleXMLElem *elem = mp->New<SimpleXMLElem>(allocator, cat, argID);
+  AddElement(*elem);
+  return elem;
+}
+
+void SimpleXMLElem::SetValue(int8 v) {
+  tagValue = kXMLValueI8;
+  value.i8 = v;
+}
+
+void SimpleXMLElem::SetValue(uint8 v) {
+  tagValue = kXMLValueU8;
+  value.u8 = v;
+}
+
+void SimpleXMLElem::SetValue(int16 v) {
+  tagValue = kXMLValueI16;
+  value.i16 = v;
+}
+
+void SimpleXMLElem::SetValue(uint16 v) {
+  tagValue = kXMLValueU16;
+  value.u16 = v;
+}
+
+void SimpleXMLElem::SetValue(int32 v) {
+  tagValue = kXMLValueI32;
+  value.i32 = v;
+}
+
+void SimpleXMLElem::SetValue(uint32 v) {
+  tagValue = kXMLValueU32;
+  value.u32 = v;
+}
+
+void SimpleXMLElem::SetValue(int64 v) {
+  tagValue = kXMLValueI64;
+  value.i64 = v;
+}
+
+void SimpleXMLElem::SetValue(uint64 v) {
+  tagValue = kXMLValueU64;
+  value.u64 = v;
+}
+
+void SimpleXMLElem::SetValue(float v) {
+  tagValue = kXMLValueFloat;
+  value.f = v;
+}
+
+void SimpleXMLElem::SetValue(double v) {
+  tagValue = kXMLValueDouble;
+  value.d = v;
+}
+
+void SimpleXMLElem::SetValue(const std::string &str) {
+  tagValue = kXMLValueString;
+  valueString = str;
+}
+
+void SimpleXMLElem::SetContent(const std::string &str) {
+  content = str;
+}
+
+std::string SimpleXMLElem::XMLString(const std::string &strIn) {
+  std::string str(strIn);
+  size_t npos = str.find("<");
+  while (npos != std::string::npos) {
+    (void)str.replace(npos, 1, "&lt;");
+    npos = str.find("<");
+  }
+  npos = str.find(">");
+  while (npos != std::string::npos) {
+    (void)str.replace(npos, 1, "&gt;");
+    npos = str.find(">");
+  }
+  return str;
+}
+
+SimpleXMLElemMultiLine::SimpleXMLElemMultiLine(MapleAllocator &alloc, const std::string &cat)
+    : SimpleXMLElem(alloc, cat), lines(alloc.Adapter()) {}
+
+SimpleXMLElemMultiLine::SimpleXMLElemMultiLine(MapleAllocator &alloc, const std::string &cat, uint32 argID)
+    : SimpleXMLElem(alloc, cat, argID), lines(alloc.Adapter()) {}
+
+void SimpleXMLElemMultiLine::AddLine(const std::string &line) {
+  lines.emplace_back(MapleString(line, allocator.GetMemPool()));
+}
+
+void SimpleXMLElemMultiLine::DumpImpl(std::ostream &os, const std::string &prefix) const {
+  DumpHead(os, prefix);
+  if (lines.size() > 0) {
+    os << std::endl;
+    for (const MapleString &str : lines) {
+      os << prefix << "  " << str << std::endl;
+    }
+  }
+  DumpTail(os, prefix);
+  os << std::endl;
+}
+
+SimpleXML::SimpleXML(MapleAllocator &alloc) : allocator(alloc), roots(allocator.Adapter()) {}
+
+void SimpleXML::DumpImpl(std::ostream &os) const {
+  os << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" << std::endl;
+  for (auto it : roots) {
+    it->Dump(os, "");
+  }
+}
+
+void SimpleXML::AddRoot(SimpleXMLElem &elem) {
+  roots.push_back(&elem);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/common/src/simple_zip.cpp b/src/hir2mpl/common/src/simple_zip.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c0abb9046d438f9987499f5e5d776c00d5c48af3
--- /dev/null
+++ b/src/hir2mpl/common/src/simple_zip.cpp
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "simple_zip.h"
+#include <malloc.h>
+#include <zlib.h>
+
+namespace maple {
+static const uint32 kZipSigLocalFile = 0x04034B50;
+static const uint32 kZipSigDataDescriptor = 0x08074B50;
+static const uint32 kZipSigCentralDir = 0x02014B50;
+
+ZipLocalFileHeader::~ZipLocalFileHeader() {
+  if (extraField != nullptr) {
+    free(extraField);
+    extraField = nullptr;
+  }
+}
+
+std::unique_ptr<ZipLocalFileHeader> ZipLocalFileHeader::Parse(BasicIORead &io) {
+  std::unique_ptr<ZipLocalFileHeader> header = std::make_unique<ZipLocalFileHeader>();
+  header->signature = io.ReadUInt32();
+  if (header->signature != kZipSigLocalFile) {
+    return std::unique_ptr<ZipLocalFileHeader>(nullptr);
+  }
+  header->minVersion = io.ReadUInt16();
+  header->gpFlag = io.ReadUInt16();
+  header->compMethod = io.ReadUInt16();
+  header->rawTime = io.ReadUInt16();
+  header->rawDate = io.ReadUInt16();
+  header->crc32 = io.ReadUInt32();
+  header->compSize = io.ReadUInt32();
+  header->unCompSize = io.ReadUInt32();
+  header->lengthFileName = io.ReadUInt16();
+  header->lengthExtraField = io.ReadUInt16();
+  header->fileName = io.ReadString(header->lengthFileName);
+  if (header->lengthExtraField > 0) {
+    header->extraField = static_cast<uint8*>(malloc(header->lengthExtraField));
+    CHECK_NULL_FATAL(header->extraField);
+    io.ReadBufferUInt8(header->extraField, header->lengthExtraField);
+  }
+  return header;
+}
+
+std::unique_ptr<ZipDataDescriptor> ZipDataDescriptor::Parse(BasicIORead &io) {
+  std::unique_ptr<ZipDataDescriptor> desc = std::make_unique<ZipDataDescriptor>();
+  desc->signature = io.ReadUInt32();
+  CHECK_FATAL(desc->signature == kZipSigDataDescriptor, "invalid zip file: wrong signature for data descriptor");
+  desc->crc32 = io.ReadUInt32();
+  desc->compSize = io.ReadUInt32();
+  desc->unCompSize = io.ReadUInt32();
+  return desc;
+}
+
+ZipLocalFile::~ZipLocalFile() {
+  if (compData != nullptr) {
+    free(compData);
+    compData = nullptr;
+  }
+  if (unCompData != nullptr) {
+    free(unCompData);
+    unCompData = nullptr;
+  }
+}
+
+std::unique_ptr<ZipLocalFile> ZipLocalFile::Parse(BasicIORead &io) {
+  std::unique_ptr<ZipLocalFile> zf = std::make_unique<ZipLocalFile>();
+  zf->header = ZipLocalFileHeader::Parse(io);
+  if (zf->header == nullptr) {
+    return std::unique_ptr<ZipLocalFile>(nullptr);
+  }
+  CHECK_FATAL((zf->header->GetGPFlag() & 0x1) == 0, "encrypted file is not supported");
+  uint32 posDataStart = io.GetPos();
+  uint32 posDataEnd = zf->GetDataEndPos(io);
+  if (!zf->isCompressed) {
+    zf->ProcessUncompressedFile(io, posDataStart, posDataEnd);
+  } else {
+    zf->ProcessCompressedFile(io, posDataStart, posDataEnd);
+  }
+  return zf;
+}
+
+uint32 ZipLocalFile::GetDataEndPos(const BasicIORead &io) {
+  const uint8 offsetSize = 4;
+  uint32 posDataStart = io.GetPos();
+  uint32 posDataEnd = posDataStart;
+  const uint8 *buf = io.GetSafeBuffer(offsetSize);
+  while (posDataEnd + offsetSize < io.GetFileLength()) {
+    uint32 sig = BasicIOEndian::GetUInt32LittleEndian(buf);
+    if (sig == kZipSigLocalFile) {
+      break;
+    }
+    if (sig == kZipSigCentralDir) {
+      break;
+    }
+    if (sig == kZipSigDataDescriptor) {
+      isCompressed = true;
+      break;
+    }
+    ++buf;
+    ++posDataEnd;
+  }
+  CHECK_FATAL(posDataEnd + offsetSize < io.GetFileLength(), "invalid zip file: no data descriptor");
+  return posDataEnd;
+}
+
+void ZipLocalFile::ProcessUncompressedFile(BasicIORead &io, uint32 start, uint32 end) {
+  unCompDataSize = end - start;
+  if (unCompDataSize > 0) {
+    unCompData = static_cast<uint8*>(malloc(unCompDataSize));
+    CHECK_NULL_FATAL(unCompData);
+    io.ReadBufferUInt8(unCompData, unCompDataSize);
+  }
+}
+
+void ZipLocalFile::ProcessCompressedFile(BasicIORead &io, uint32 start, uint32 end) {
+  uint32 compDataLength = static_cast<uint32>(end - start);
+  if (compDataLength == 0) {
+    return;
+  }
+  compData = static_cast<uint8*>(malloc(compDataLength));
+  CHECK_NULL_FATAL(compData);
+  io.ReadBufferUInt8(compData, compDataLength);
+  dataDesc = ZipDataDescriptor::Parse(io);
+  CHECK_FATAL(compDataLength == dataDesc->GetCompSize(), "invalid zip file: wrong compsize");
+  if (dataDesc->GetUnCompSize() > 0) {
+    unCompData = static_cast<uint8*>(malloc(dataDesc->GetUnCompSize()));
+    CHECK_NULL_FATAL(unCompData);
+    z_stream zs;
+    zs.zalloc = static_cast<alloc_func>(0);
+    zs.zfree = static_cast<free_func>(0);
+    int err = inflateInit2(&zs, -MAX_WBITS);
+    CHECK_FATAL(err == 0, "inflateInit2 error");
+    zs.next_in = compData;
+    zs.avail_in = dataDesc->GetCompSize();
+    zs.total_in = 0;
+    zs.next_out = unCompData;
+    zs.avail_out = dataDesc->GetUnCompSize();
+    zs.total_out = 0;
+    err = inflate(&zs, Z_NO_FLUSH);
+    if (err == Z_STREAM_END) {
+      err = inflateEnd(&zs);
+    }
+    unCompDataSize = dataDesc->GetUnCompSize();
+    if (err != Z_OK) {
+      free(unCompData);
+      unCompData = nullptr;
+      unCompDataSize = 0;
+      CHECK_FATAL(false, "inflate failed");
+    }
+  }
+}
+
+SimpleZip::SimpleZip(BasicIOMapFile &file) : BasicIORead(file, false) {}
+
+SimpleZip::~SimpleZip() {}
+
+void SimpleZip::ParseFile() {
+  while (true) {
+    std::unique_ptr<ZipLocalFile> zf = ZipLocalFile::Parse(*this);
+    if (zf != nullptr) {
+      files.push_back(std::move(zf));
+    } else {
+      break;
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/optimize/include/conditional_operator.h b/src/hir2mpl/optimize/include/conditional_operator.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b5eaa68981d9475f6ba08d9dbf7e072affb88ab
--- /dev/null
+++ b/src/hir2mpl/optimize/include/conditional_operator.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef CONDITIONAL_OPERATOR_H
+#define CONDITIONAL_OPERATOR_H
+#include "feir_stmt.h"
+#include "ast_expr.h"
+
+namespace maple {
+// To avoid affecting the unified abstraction processing of ast expr,
+// redundant temporary variables of conditional statements are processed separately.
+class ConditionalOptimize {
+ public:
+  static bool DeleteRedundantTmpVar(const UniqueFEIRExpr &expr, std::list<UniqueFEIRStmt> &stmts,
+                                    const UniqueFEIRVar &var, PrimType dstPty, FieldID fieldID = 0);
+  static bool DeleteRedundantTmpVar(const UniqueFEIRExpr &expr, std::list<UniqueFEIRStmt> &stmts);
+  static bool IsCompletedConditional(const UniqueFEIRExpr &expr, std::list<UniqueFEIRStmt> &stmts);
+};
+} // namespace maple
+#endif // CONDITIONAL_OPERATOR_H
diff --git a/src/hir2mpl/optimize/include/feir_bb.h b/src/hir2mpl/optimize/include/feir_bb.h
new file mode 100644
index 0000000000000000000000000000000000000000..1516bccf2fb81e3e7cc010363721f4988ad2d6a8
--- /dev/null
+++ b/src/hir2mpl/optimize/include/feir_bb.h
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_FEIR_BB_H
+#define HIR2MPL_FEIR_BB_H
+#include <vector>
+#include "types_def.h"
+#include "mempool_allocator.h"
+#include "safe_ptr.h"
+#include "fe_utils.h"
+#include "feir_stmt.h"
+
+namespace maple {
+enum FEIRBBKind : uint8 {
+  kBBKindDefault,
+  kBBKindPesudoHead,
+  kBBKindPesudoTail,
+  kBBKindExt
+};
+
+class FEIRBB : public FELinkListNode {
+ public:
+  FEIRBB();
+  explicit FEIRBB(uint8 argKind);
+  ~FEIRBB() override;
+
+  uint8 GetBBKind() const {
+    return kind;
+  }
+
+  std::string GetBBKindName() const;
+
+  uint32 GetID() const {
+    return id;
+  }
+
+  void SetID(uint32 arg) {
+    id = arg;
+  }
+
+  const FEIRStmt *GetStmtHead() const {
+    return stmtHead;
+  }
+
+  void SetStmtHead(FEIRStmt *stmtHeadIn) {
+    stmtHead = stmtHeadIn;
+  }
+
+  const FEIRStmt *GetStmtTail() const {
+    return stmtTail;
+  }
+
+  void SetStmtTail(FEIRStmt *stmtTailIn) {
+    stmtTail = stmtTailIn;
+  }
+
+  void InsertAndUpdateNewHead(FEIRStmt *newHead) {
+    stmtHead->InsertBefore(newHead);
+    stmtHead = newHead;
+  }
+
+  void InsertAndUpdateNewTail(FEIRStmt *newTail) {
+    stmtTail->InsertAfter(newTail);
+    stmtTail = newTail;
+  }
+
+  const FEIRStmt *GetStmtNoAuxHead() const {
+    return stmtNoAuxHead;
+  }
+
+  const FEIRStmt *GetStmtNoAuxTail() const {
+    return stmtNoAuxTail;
+  }
+
+  void AddPredBB(FEIRBB *bb) {
+    if (predBBs.find(bb) == predBBs.end()) {
+      predBBs.insert(bb);
+    }
+  }
+
+  void AddSuccBB(FEIRBB *bb) {
+    if (succBBs.find(bb) == succBBs.end()) {
+      succBBs.insert(bb);
+    }
+  }
+
+  const std::set<FEIRBB*> &GetPredBBs() const {
+    return predBBs;
+  }
+
+  const std::set<FEIRBB*> &GetSuccBBs() const {
+    return succBBs;
+  }
+
+  bool IsPredBB(FEIRBB *bb) const {
+    return predBBs.find(bb) != predBBs.end();
+  }
+
+  bool IsSuccBB(FEIRBB *bb) const {
+    return succBBs.find(bb) != succBBs.end();
+  }
+
+  bool IsDead() const {
+    return predBBs.empty();
+  }
+
+  bool IsFallThru() const {
+    return stmtNoAuxTail->IsFallThru();
+  }
+
+  bool IsBranch() const {
+    return stmtNoAuxTail->IsBranch();
+  }
+
+  void SetCheckPointIn(std::unique_ptr<FEIRStmtCheckPoint> argCheckPointIn) {
+    checkPointIn = std::move(argCheckPointIn);
+  }
+
+  FEIRStmtCheckPoint &GetCheckPointIn() const {
+    return *(checkPointIn.get());
+  }
+
+  void SetCheckPointOut(std::unique_ptr<FEIRStmtCheckPoint> argCheckPointOut) {
+    checkPointOut = std::move(argCheckPointOut);
+  }
+
+  FEIRStmtCheckPoint &GetCheckPointOut() const {
+    return *(checkPointOut.get());;
+  }
+
+  void AddCheckPoint(std::unique_ptr<FEIRStmtCheckPoint> checkPoint) {
+    checkPoints.emplace_back(std::move(checkPoint));
+  }
+
+  FEIRStmtCheckPoint *GetLatestCheckPoint() const {
+    if (checkPoints.empty()) {
+      return nullptr;
+    }
+    return checkPoints.back().get();
+  }
+
+  const std::vector<std::unique_ptr<FEIRStmtCheckPoint>> &GetCheckPoints() const {
+    return checkPoints;
+  }
+
+  void AppendStmt(FEIRStmt *stmt);
+  void AddStmtAuxPre(FEIRStmt *stmt);
+  void AddStmtAuxPost(FEIRStmt *stmt);
+  bool IsPredBB(uint32 bbID);
+  bool IsSuccBB(uint32 bbID);
+  virtual void Dump() const;
+
+ protected:
+  uint8 kind;
+  uint32 id;
+  FEIRStmt *stmtHead;
+  FEIRStmt *stmtTail;
+  FEIRStmt *stmtNoAuxHead;
+  FEIRStmt *stmtNoAuxTail;
+  std::set<FEIRBB*> predBBs;
+  std::set<FEIRBB*> succBBs;
+
+ private:
+  std::unique_ptr<FEIRStmtCheckPoint> checkPointIn;
+  std::vector<std::unique_ptr<FEIRStmtCheckPoint>> checkPoints;
+  std::unique_ptr<FEIRStmtCheckPoint> checkPointOut;
+  std::map<const FEIRStmt*, FEIRStmtCheckPoint*> feirStmtCheckPointMap;
+};
+}  // namespace maple
+#endif  // HIR2MPL_FEIR_BB_H
\ No newline at end of file
diff --git a/src/hir2mpl/optimize/include/feir_cfg.h b/src/hir2mpl/optimize/include/feir_cfg.h
new file mode 100644
index 0000000000000000000000000000000000000000..c103f7b36c8dec7bf305c70d22bf3162b209a9eb
--- /dev/null
+++ b/src/hir2mpl/optimize/include/feir_cfg.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_FEIR_CFG_H
+#define HIR2MPL_FEIR_CFG_H
+#include <memory>
+#include <list>
+#include "feir_bb.h"
+
+namespace maple {
+class FEIRCFG {
+ public:
+  FEIRCFG(FEIRStmt *argStmtHead, FEIRStmt *argStmtTail);
+
+  virtual ~FEIRCFG() {
+    currBBNode = nullptr;
+    stmtHead = nullptr;
+    stmtTail = nullptr;
+  }
+
+  void Init();
+  void BuildBB();
+  bool BuildCFG();
+  void GenerateCFG();
+  const FEIRBB *GetHeadBB();
+  const FEIRBB *GetNextBB();
+  void LabelStmtID() const;
+  void LabelBBID() const;
+  bool HasDeadBB() const;
+  void DumpBBs();
+  void DumpCFGGraph(std::ofstream &file);
+  void DumpCFGGraphForBB(std::ofstream &file, const FEIRBB &bb) const;
+  void DumpCFGGraphForEdge(std::ofstream &file);
+
+  FEIRBB *GetDummyHead() const {
+    return bbHead.get();
+  }
+
+  FEIRBB *GetDummyTail() const {
+    return bbTail.get();
+  }
+
+  std::unique_ptr<FEIRBB> NewFEIRBB() const {
+    return std::make_unique<FEIRBB>();
+  }
+
+  bool IsGeneratedCFG() const {
+    return isGeneratedCFG;
+  }
+
+ LLT_PRIVATE:
+  void AppendAuxStmt();
+  FEIRBB *NewBBAppend();
+
+  bool isGeneratedCFG = false;
+  FEIRStmt *stmtHead;
+  FEIRStmt *stmtTail;
+  FELinkListNode *currBBNode = nullptr;
+  std::list<std::unique_ptr<FEIRBB>> listBB;
+  std::unique_ptr<FEIRBB> bbHead;
+  std::unique_ptr<FEIRBB> bbTail;
+};
+}  // namespace maple
+#endif  // HIR2MPL_FEIR_CFG_H
\ No newline at end of file
diff --git a/src/hir2mpl/optimize/include/feir_dfg.h b/src/hir2mpl/optimize/include/feir_dfg.h
new file mode 100644
index 0000000000000000000000000000000000000000..78de62d78b667807a4d443e2d98ab9447a27f487
--- /dev/null
+++ b/src/hir2mpl/optimize/include/feir_dfg.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_FEIR_DFG_H
+#define HIR2MPL_INCLUDE_FEIR_DFG_H
+#include "feir_var.h"
+
+namespace maple {
+// FEIRUseDefChain key is use, value is def set
+using FEIRUseDefChain = std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>>;
+// FEIRUseDefChain key is def, value is use set
+using FEIRDefUseChain = std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>>;
+
+class FEIRDFG {
+ public:
+  FEIRDFG() = default;
+  ~FEIRDFG() = default;
+  void CalculateDefUseByUseDef(FEIRDefUseChain &mapDefUse, const FEIRUseDefChain &mapUseDef) const;
+  void CalculateUseDefByDefUse(FEIRUseDefChain &mapUseDef, const FEIRDefUseChain &mapDefUse) const;
+  void BuildFEIRUDDU();
+  void OutputUseDefChain();
+  void OutputDefUseChain();
+
+ private:
+  FEIRUseDefChain useDefChain;
+  FEIRDefUseChain defUseChain;
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_FEIR_DFG_H
\ No newline at end of file
diff --git a/src/hir2mpl/optimize/include/feir_lower.h b/src/hir2mpl/optimize/include/feir_lower.h
new file mode 100644
index 0000000000000000000000000000000000000000..9dc6db1bf41278dbc8c53060a860574ecb0ae54d
--- /dev/null
+++ b/src/hir2mpl/optimize/include/feir_lower.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef HIR2MPL_FEIR_LOWER_H
+#define HIR2MPL_FEIR_LOWER_H
+#include "feir_stmt.h"
+
+namespace maple {
+class FEFunction; // circular dependency exists, no other choice
+class FEIRLower {
+ public:
+  explicit FEIRLower(FEFunction &funcIn);
+  void LowerFunc();
+  void LowerStmt(FEIRStmt *stmt, FEIRStmt *ptrTail);
+  void LowerStmt(const std::list<UniqueFEIRStmt> &stmts, FEIRStmt *ptrTail);
+
+  FEIRStmt *GetlowerStmtHead() {
+    return lowerStmtHead;
+  }
+
+  FEIRStmt *GetlowerStmtTail() {
+    return lowerStmtTail;
+  }
+
+ private:
+  void Init();
+  void Clear();
+  FEIRStmt *CreateHeadAndTail();
+  FEIRStmt *RegisterAuxFEIRStmt(UniqueFEIRStmt stmt);
+  FEIRStmt *RegisterAndInsertFEIRStmt(UniqueFEIRStmt stmt, FEIRStmt *ptrTail, const Loc loc = {0, 0, 0});
+  void LowerIfStmt(FEIRStmtIf &ifStmt, FEIRStmt *ptrTail);
+  void ProcessLoopStmt(FEIRStmtDoWhile &stmt, FEIRStmt *ptrTail);
+  void LowerWhileStmt(const FEIRStmtDoWhile &whileStmt, FEIRStmt *bodyHead, FEIRStmt *bodyTail, FEIRStmt *ptrTail);
+  void LowerDoWhileStmt(const FEIRStmtDoWhile &doWhileStmt, FEIRStmt *bodyHead, FEIRStmt *bodyTail, FEIRStmt *ptrTail);
+  void CreateAndInsertCondStmt(Opcode op, const FEIRStmtIf &ifStmt, FEIRStmt *head, FEIRStmt *tail, FEIRStmt *ptrTail);
+
+  FEFunction &func;
+  FEIRStmt *lowerStmtHead;
+  FEIRStmt *lowerStmtTail;
+  std::list<UniqueFEIRStmt> auxFEIRStmtList;  // auxiliary feir stmt list
+};
+} // namespace maple
+#endif // HIR2MPL_FEIR_LOWER_H
diff --git a/src/hir2mpl/optimize/include/ror.h b/src/hir2mpl/optimize/include/ror.h
new file mode 100644
index 0000000000000000000000000000000000000000..e582c6ac9de647c74a67bd0c3ca8c30665dc8aa4
--- /dev/null
+++ b/src/hir2mpl/optimize/include/ror.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef OPTIMIZE_INCLUDE_ROR_H
+#define OPTIMIZE_INCLUDE_ROR_H
+#include "feir_stmt.h"
+#include "opcodes.h"
+
+namespace maple {
+class Ror {
+ public:
+  Ror(Opcode opIn, const UniqueFEIRExpr &left, const UniqueFEIRExpr &right)
+      : op(opIn), lExpr(left), rExpr(right) {}
+  ~Ror() = default;
+  UniqueFEIRExpr Emit2FEExpr();
+
+ private:
+  bool CheckBaseExpr() const;
+  bool GetConstVal(const UniqueFEIRExpr &expr);
+  bool IsRorShlOpnd(const UniqueFEIRExpr &expr);
+  bool IsRorLshrOpnd(const UniqueFEIRExpr &expr, bool inShl);
+
+  Opcode op;
+  const UniqueFEIRExpr &lExpr;
+  const UniqueFEIRExpr &rExpr;
+  UniqueFEIRExpr rShiftBaseExpr;
+  UniqueFEIRExpr lShiftBaseExpr;
+  uint64 constVal = 0;
+  uint32 bitWidth = 0;
+};
+} // namespace maple
+#endif // OPTIMIZE_INCLUDE_ROR_H
\ No newline at end of file
diff --git a/src/hir2mpl/optimize/src/conditional_operator.cpp b/src/hir2mpl/optimize/src/conditional_operator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0995d38fe2f853cea385d689a8e2559f6cf81652
--- /dev/null
+++ b/src/hir2mpl/optimize/src/conditional_operator.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "conditional_operator.h"
+#include "feir_builder.h"
+
+namespace maple {
+bool ConditionalOptimize::IsCompletedConditional(const UniqueFEIRExpr &expr, std::list<UniqueFEIRStmt> &stmts) {
+  if (FEOptions::GetInstance().IsNpeCheckDynamic() || FEOptions::GetInstance().IsBoundaryCheckDynamic()) {
+    return false;
+  }
+
+  if (expr == nullptr || expr->GetKind() != kExprTernary) {
+    return false;
+  }
+
+  if (stmts.empty() || stmts.back()->GetKind() != kStmtIf) {
+    return false;
+  }
+
+  FEIRStmtIf *ifStmt = static_cast<FEIRStmtIf*>(stmts.back().get());
+  if (ifStmt->GetThenStmt().empty() || ifStmt->GetElseStmt().empty()) {
+    return false;
+  }
+
+  return true;
+}
+
+bool ConditionalOptimize::DeleteRedundantTmpVar(const UniqueFEIRExpr &expr, std::list<UniqueFEIRStmt> &stmts,
+                                                const UniqueFEIRVar &var, PrimType dstPty, FieldID fieldID) {
+  if (!IsCompletedConditional(expr, stmts)) {
+    return false;
+  }
+
+  auto ReplaceBackStmt = [dstPty, fieldID, &var](std::list<UniqueFEIRStmt> &stmts, const FEIRStmt &srcStmt) {
+    auto dassignStmt = static_cast<FEIRStmtDAssign*>(stmts.back().get());
+    UniqueFEIRExpr srcExpr = dassignStmt->GetExpr()->Clone();
+    PrimType srcPty = srcExpr->GetPrimType();
+    if (srcPty != dstPty && srcPty != PTY_agg && srcPty != PTY_void) {
+      PrimType newDstPty = dstPty;
+      if (srcPty == PTY_f32 || srcPty == PTY_f64) {
+        if (dstPty == PTY_u8 || dstPty == PTY_u16) {
+          newDstPty = PTY_u32;
+        }
+        if (dstPty == PTY_i8 || dstPty == PTY_i16) {
+          newDstPty = PTY_i32;
+        }
+      }
+      srcExpr = FEIRBuilder::CreateExprCastPrim(std::move(srcExpr), newDstPty);
+    }
+
+    auto stmt = std::make_unique<FEIRStmtDAssign>(var->Clone(), srcExpr->Clone(), fieldID);
+    stmt->SetSrcLoc(srcStmt.GetSrcLoc());
+    stmts.pop_back();
+    stmts.emplace_back(std::move(stmt));
+  };
+
+  FEIRStmtIf *ifStmt = static_cast<FEIRStmtIf*>(stmts.back().get());
+  ReplaceBackStmt(ifStmt->GetThenStmt(), *ifStmt);
+  ReplaceBackStmt(ifStmt->GetElseStmt(), *ifStmt);
+  return true;
+}
+
+bool ConditionalOptimize::DeleteRedundantTmpVar(const UniqueFEIRExpr &expr, std::list<UniqueFEIRStmt> &stmts) {
+  if (!IsCompletedConditional(expr, stmts)) {
+    return false;
+  }
+
+  auto ReplaceBackStmt = [](std::list<UniqueFEIRStmt> &stmts, const FEIRStmt &srcStmt) {
+    auto dassignStmt = static_cast<FEIRStmtDAssign*>(stmts.back().get());
+    auto stmt = std::make_unique<FEIRStmtReturn>(dassignStmt->GetExpr()->Clone());
+    stmt->SetSrcLoc(srcStmt.GetSrcLoc());
+    stmts.pop_back();
+    stmts.emplace_back(std::move(stmt));
+  };
+
+  FEIRStmtIf *ifStmt = static_cast<FEIRStmtIf*>(stmts.back().get());
+  ReplaceBackStmt(ifStmt->GetThenStmt(), *ifStmt);
+  ReplaceBackStmt(ifStmt->GetElseStmt(), *ifStmt);
+  return true;
+}
+}
\ No newline at end of file
diff --git a/src/hir2mpl/optimize/src/feir_bb.cpp b/src/hir2mpl/optimize/src/feir_bb.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..42786149d5765d210bd7e546c9cf84011d1cd54e
--- /dev/null
+++ b/src/hir2mpl/optimize/src/feir_bb.cpp
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_bb.h"
+
+namespace maple {
+FEIRBB::FEIRBB(uint8 argKind)
+    : kind(argKind),
+      id(0),
+      stmtHead(nullptr),
+      stmtTail(nullptr),
+      stmtNoAuxHead(nullptr),
+      stmtNoAuxTail(nullptr) {}
+
+FEIRBB::FEIRBB()
+    : FEIRBB(FEIRBBKind::kBBKindDefault) {}
+
+FEIRBB::~FEIRBB() {
+  stmtHead = nullptr;
+  stmtTail = nullptr;
+  stmtNoAuxHead = nullptr;
+  stmtNoAuxTail = nullptr;
+}
+
+void FEIRBB::AppendStmt(FEIRStmt *stmt) {
+  if (stmtHead == nullptr) {
+    stmtHead = stmt;
+  }
+  stmtTail = stmt;
+  if (!stmt->IsAux()) {
+    if (stmtNoAuxHead == nullptr) {
+      stmtNoAuxHead = stmt;
+    }
+    stmtNoAuxTail = stmt;
+  }
+}
+
+void FEIRBB::AddStmtAuxPre(FEIRStmt *stmt) {
+  if (!stmt->IsAuxPre()) {
+    return;
+  }
+  stmtHead = stmt;
+}
+
+void FEIRBB::AddStmtAuxPost(FEIRStmt *stmt) {
+  if (!stmt->IsAuxPost()) {
+    return;
+  }
+  stmtTail = stmt;
+}
+
+bool FEIRBB::IsPredBB(uint32 bbID) {
+  for (FEIRBB *bb : predBBs) {
+    if (bb->GetID() == bbID) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool FEIRBB::IsSuccBB(uint32 bbID) {
+  for (FEIRBB *bb : succBBs) {
+    if (bb->GetID() == bbID) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void FEIRBB::Dump() const {
+  std::cout << "FEIRBB (id=" << id << ", kind=" << GetBBKindName() <<
+               ", preds={";
+  for (FEIRBB *bb : predBBs) {
+    std::cout << bb->GetID() << " ";
+  }
+  std::cout << "}, succs={";
+  for (FEIRBB *bb : succBBs) {
+    std::cout << bb->GetID() << " ";
+  }
+  std::cout << "})" << std::endl;
+  FELinkListNode *nodeStmt = stmtHead;
+  while (nodeStmt != nullptr) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    stmt->Dump("    ");
+    if (nodeStmt == stmtTail) {
+      return;
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+}
+
+std::string FEIRBB::GetBBKindName() const {
+  switch (kind) {
+    case kBBKindDefault:
+      return "Default";
+    case kBBKindPesudoHead:
+      return "PesudoHead";
+    case kBBKindPesudoTail:
+      return "PesudoTail";
+    default:
+      return "unknown";
+  }
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/optimize/src/feir_cfg.cpp b/src/hir2mpl/optimize/src/feir_cfg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3ddba5d23966a41b502ec4728a9608607fd0be76
--- /dev/null
+++ b/src/hir2mpl/optimize/src/feir_cfg.cpp
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_cfg.h"
+#include <fstream>
+#include "mpl_logging.h"
+
+namespace maple {
+FEIRCFG::FEIRCFG(FEIRStmt *argStmtHead, FEIRStmt *argStmtTail)
+    : stmtHead(argStmtHead), stmtTail(argStmtTail) {}
+
+void FEIRCFG::Init() {
+  bbHead = std::make_unique<FEIRBB>(kBBKindPesudoHead);
+  bbTail = std::make_unique<FEIRBB>(kBBKindPesudoTail);
+  bbHead->SetNext(bbTail.get());
+  bbTail->SetPrev(bbHead.get());
+}
+
+void FEIRCFG::GenerateCFG() {
+  if (isGeneratedCFG) {
+    return;
+  }
+  Init();
+  LabelStmtID();
+  BuildBB();
+  BuildCFG();
+  LabelBBID();
+}
+
+void FEIRCFG::BuildBB() {
+  FELinkListNode *nodeStmt = stmtHead->GetNext();
+  FEIRBB *currBB = nullptr;
+  while (nodeStmt != nullptr && nodeStmt != stmtTail) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    if (!stmt->IsAux()) {
+      // check start of BB
+      if (currBB == nullptr || !stmt->GetExtraPreds().empty()) {
+        currBB = NewBBAppend();
+        bbTail->InsertBefore(currBB);
+      }
+      CHECK_FATAL(currBB != nullptr, "nullptr check of currBB");
+      currBB->AppendStmt(stmt);
+      // check end of BB
+      if (!stmt->IsFallThru() || !stmt->GetExtraSuccs().empty()) {
+        currBB = nullptr;
+      }
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+
+  AppendAuxStmt();
+}
+
+void FEIRCFG::AppendAuxStmt() {
+  FELinkListNode *nodeBB = bbHead->GetNext();
+  while (nodeBB != nullptr && nodeBB != bbTail.get()) {
+    FEIRBB *bb = static_cast<FEIRBB*>(nodeBB);
+    // add pre
+    FELinkListNode *nodeStmt = bb->GetStmtHead()->GetPrev();
+    while (nodeStmt != nullptr) {
+      FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+      if (stmt->IsAuxPre()) {
+        bb->AddStmtAuxPre(stmt);
+      } else {
+        break;
+      }
+      nodeStmt = nodeStmt->GetPrev();
+    }
+    // add post
+    nodeStmt = bb->GetStmtTail()->GetNext();
+    while (nodeStmt != nullptr) {
+      FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+      if (stmt->IsAuxPost()) {
+        bb->AddStmtAuxPost(stmt);
+      } else {
+        break;
+      }
+      nodeStmt = nodeStmt->GetNext();
+    }
+    nodeBB = nodeBB->GetNext();
+  }
+}
+
+FEIRBB *FEIRCFG::NewBBAppend() {
+  std::unique_ptr<FEIRBB> bbNew = NewFEIRBB();
+  ASSERT(bbNew != nullptr, "nullptr check for bbNew");
+  listBB.push_back(std::move(bbNew));
+  return listBB.back().get();
+}
+
+bool FEIRCFG::BuildCFG() {
+  // build target map
+  std::map<const FEIRStmt*, FEIRBB*> mapTargetStmtBB;
+  FELinkListNode *nodeBB = bbHead->GetNext();
+  while (nodeBB != nullptr && nodeBB != bbTail.get()) {
+    FEIRBB *bb = static_cast<FEIRBB*>(nodeBB);
+    const FEIRStmt *locStmtHead = bb->GetStmtNoAuxHead();
+    if (locStmtHead != nullptr) { // Additional conditions need to be added
+      mapTargetStmtBB[locStmtHead] = bb;
+    }
+    nodeBB = nodeBB->GetNext();
+  }
+  // link
+  nodeBB = bbHead->GetNext();
+  bool firstBB = true;
+  while (nodeBB != nullptr && nodeBB != bbTail.get()) {
+    FEIRBB *bb = static_cast<FEIRBB*>(nodeBB);
+    if (firstBB) {
+      bb->AddPredBB(bbHead.get());
+      bbHead->AddSuccBB(bb);
+      firstBB = false;
+    }
+    const FEIRStmt *locStmtTail = bb->GetStmtNoAuxTail();
+    CHECK_FATAL(locStmtTail != nullptr, "stmt tail is nullptr");
+    if (locStmtTail->IsFallThru()) {
+      FELinkListNode *nodeBBNext = nodeBB->GetNext();
+      if (nodeBBNext == nullptr || nodeBBNext == bbTail.get()) {
+        ERR(kLncErr, "Method without return");
+        return false;
+      }
+      FEIRBB *bbNext = static_cast<FEIRBB*>(nodeBBNext);
+      bb->AddSuccBB(bbNext);
+      bbNext->AddPredBB(bb);
+    }
+    for (FEIRStmt *stmt : locStmtTail->GetExtraSuccs()) {
+      std::map<const FEIRStmt*, FEIRBB*>::const_iterator itBB = mapTargetStmtBB.find(stmt);
+      CHECK_FATAL(itBB != mapTargetStmtBB.cend(), "Target BB is not found");
+      FEIRBB *bbNext = itBB->second;
+      bb->AddSuccBB(bbNext);
+      bbNext->AddPredBB(bb);
+    }
+    nodeBB = nodeBB->GetNext();
+  }
+  isGeneratedCFG = true;
+  return isGeneratedCFG;
+}
+
+const FEIRBB *FEIRCFG::GetHeadBB() {
+  currBBNode = bbHead->GetNext();
+  if (currBBNode == bbTail.get()) {
+    return nullptr;
+  }
+  return static_cast<FEIRBB*>(currBBNode);
+}
+
+const FEIRBB *FEIRCFG::GetNextBB() {
+  currBBNode = currBBNode->GetNext();
+  if (currBBNode == bbTail.get()) {
+    return nullptr;
+  }
+  return static_cast<FEIRBB*>(currBBNode);
+}
+
+void FEIRCFG::LabelStmtID() const {
+  FELinkListNode *nodeStmt = stmtHead;
+  uint32 idx = 0;
+  while (nodeStmt != nullptr) {
+    FEIRStmt *stmt = static_cast<FEIRStmt*>(nodeStmt);
+    stmt->SetID(idx);
+    idx++;
+    nodeStmt = nodeStmt->GetNext();
+  }
+}
+
+void FEIRCFG::LabelBBID() const {
+  FELinkListNode *nodeBB = bbHead.get();
+  uint32 idx = 0;
+  while (nodeBB != nullptr) {
+    FEIRBB *bb = static_cast<FEIRBB*>(nodeBB);
+    bb->SetID(idx);
+    idx++;
+    nodeBB = nodeBB->GetNext();
+  }
+}
+
+bool FEIRCFG::HasDeadBB() const {
+  FELinkListNode *nodeBB = bbHead->GetNext();
+  while (nodeBB != nullptr && nodeBB != bbTail.get()) {
+    FEIRBB *bb = static_cast<FEIRBB*>(nodeBB);
+    if (bb->IsDead()) {
+      return true;
+    }
+    nodeBB = nodeBB->GetNext();
+  }
+  return false;
+}
+
+void FEIRCFG::DumpBBs() {
+  FELinkListNode *nodeBB = bbHead->GetNext();
+  while (nodeBB != nullptr && nodeBB != bbTail.get()) {
+    FEIRBB *bb = static_cast<FEIRBB*>(nodeBB);
+    bb->Dump();
+    nodeBB = nodeBB->GetNext();
+  }
+}
+
+void FEIRCFG::DumpCFGGraph(std::ofstream &file) {
+  FELinkListNode *nodeBB = bbHead->GetNext();
+  while (nodeBB != nullptr && nodeBB != bbTail.get()) {
+    FEIRBB *bb = static_cast<FEIRBB*>(nodeBB);
+    DumpCFGGraphForBB(file, *bb);
+    nodeBB = nodeBB->GetNext();
+  }
+  DumpCFGGraphForEdge(file);
+  file << "}" << std::endl;
+}
+
+void FEIRCFG::DumpCFGGraphForBB(std::ofstream &file, const FEIRBB &bb) const {
+  file << "  BB" << bb.GetID() << " [shape=record,label=\"{\n";
+  const FELinkListNode *nodeStmt = bb.GetStmtHead();
+  while (nodeStmt != nullptr) {
+    const FEIRStmt *stmt = static_cast<const FEIRStmt*>(nodeStmt);
+    file << "      " << stmt->DumpDotString();
+    if (nodeStmt == bb.GetStmtTail()) {
+      file << "\n";
+      break;
+    } else {
+      file << " |\n";
+    }
+    nodeStmt = nodeStmt->GetNext();
+  }
+  file << "    }\"];\n";
+}
+
+void FEIRCFG::DumpCFGGraphForEdge(std::ofstream &file) {
+  file << "  subgraph cfg_edges {\n";
+  file << "    edge [color=\"#000000\",weight=0.3,len=3];\n";
+  const FELinkListNode *nodeBB = bbHead->GetNext();
+  while (nodeBB != nullptr && nodeBB != bbTail.get()) {
+    const FEIRBB *bb = static_cast<const FEIRBB*>(nodeBB);
+    const FEIRStmt *stmtS = bb->GetStmtTail();
+    for (FEIRBB *bbNext : bb->GetSuccBBs()) {
+      const FEIRStmt *stmtE = bbNext->GetStmtHead();
+      file << "    BB" << bb->GetID() << ":stmt" << stmtS->GetID() << " -> ";
+      file << "BB" << bbNext->GetID() << ":stmt" << stmtE->GetID() << "\n";
+    }
+    nodeBB = nodeBB->GetNext();
+  }
+  file << "  }\n";
+}
+}  // namespace maple
diff --git a/src/hir2mpl/optimize/src/feir_dfg.cpp b/src/hir2mpl/optimize/src/feir_dfg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2513b15765931c08918d4d028ece0553a21d2fdb
--- /dev/null
+++ b/src/hir2mpl/optimize/src/feir_dfg.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_dfg.h"
+
+namespace maple {
+void FEIRDFG::CalculateDefUseByUseDef(FEIRDefUseChain &mapDefUse, const FEIRUseDefChain &mapUseDef) const {
+  mapDefUse.clear();
+  for (auto &it : mapUseDef) {
+    for (UniqueFEIRVar *def : it.second) {
+      if (mapDefUse[def].find(it.first) == mapDefUse[def].end()) {
+        mapDefUse[def].insert(it.first);
+      }
+    }
+  }
+}
+
+void FEIRDFG::CalculateUseDefByDefUse(FEIRUseDefChain &mapUseDef, const FEIRDefUseChain &mapDefUse) const {
+  mapUseDef.clear();
+  for (auto &it : mapDefUse) {
+    for (UniqueFEIRVar *use : it.second) {
+      if (mapUseDef[use].find(it.first) == mapUseDef[use].end()) {
+        mapUseDef[use].insert(it.first);
+      }
+    }
+  }
+}
+
+void FEIRDFG::BuildFEIRUDDU() {
+  CalculateDefUseByUseDef(defUseChain, useDefChain);  // build Def-Use Chain
+}
+
+void FEIRDFG::OutputUseDefChain() {
+  std::cout << "useDefChain : {" << std::endl;
+  FEIRUseDefChain::const_iterator it = useDefChain.cbegin();
+  while (it != useDefChain.cend()) {
+    UniqueFEIRVar *use = it->first;
+    std::cout << "  use : " << (*use)->GetNameRaw() << "_" << GetPrimTypeName((*use)->GetType()->GetPrimType());
+    std::cout << " defs : [";
+    const std::set<UniqueFEIRVar*> &defs = it->second;
+    for (UniqueFEIRVar *def : defs) {
+      std::cout << (*def)->GetNameRaw() << "_" << GetPrimTypeName((*def)->GetType()->GetPrimType()) << ", ";
+    }
+    if (defs.size() == 0) {
+      std::cout << "empty defs";
+    }
+    std::cout << " ]" << std::endl;
+    it++;
+  }
+  std::cout << "}" << std::endl;
+}
+
+void FEIRDFG::OutputDefUseChain() {
+  std::cout << "defUseChain : {" << std::endl;
+  FEIRDefUseChain::const_iterator it = defUseChain.cbegin();
+  while (it != defUseChain.cend()) {
+    UniqueFEIRVar *def = it->first;
+    std::cout << "  def : " << (*def)->GetNameRaw() << "_" << GetPrimTypeName((*def)->GetType()->GetPrimType());
+    std::cout << " uses : [";
+    const std::set<UniqueFEIRVar*> &uses = it->second;
+    for (UniqueFEIRVar *use : uses) {
+      std::cout << (*use)->GetNameRaw()  << "_" << GetPrimTypeName((*use)->GetType()->GetPrimType()) << ", ";
+    }
+    if (uses.size() == 0) {
+      std::cout << "empty uses";
+    }
+    std::cout << " ]" << std::endl;
+    it++;
+  }
+  std::cout << "}" << std::endl;
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/optimize/src/feir_lower.cpp b/src/hir2mpl/optimize/src/feir_lower.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d732b97468698c187e1cce79efd0a4bb49102810
--- /dev/null
+++ b/src/hir2mpl/optimize/src/feir_lower.cpp
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_lower.h"
+#include "fe_function.h"
+#include "feir_builder.h"
+
+namespace maple {
+FEIRLower::FEIRLower(FEFunction &funcIn) : func(funcIn) {
+  Init();
+}
+
+void FEIRLower::Init() {
+  lowerStmtHead = func.RegisterFEIRStmt(std::make_unique<FEIRStmt>(FEIRNodeKind::kStmtPesudoFuncStart));
+  lowerStmtTail = func.RegisterFEIRStmt(std::make_unique<FEIRStmt>(FEIRNodeKind::kStmtPesudoFuncEnd));
+  lowerStmtHead->SetNext(lowerStmtTail);
+  lowerStmtTail->SetPrev(lowerStmtHead);
+}
+
+void FEIRLower::Clear() {
+  auxFEIRStmtList.clear();
+}
+
+FEIRStmt *FEIRLower::RegisterAuxFEIRStmt(UniqueFEIRStmt stmt) {
+  auxFEIRStmtList.push_back(std::move(stmt));
+  return auxFEIRStmtList.back().get();
+}
+
+FEIRStmt *FEIRLower::CreateHeadAndTail() {
+  FEIRStmt *head = RegisterAuxFEIRStmt(std::make_unique<FEIRStmt>(FEIRNodeKind::kStmtPesudoHead));
+  FEIRStmt *tail = RegisterAuxFEIRStmt(std::make_unique<FEIRStmt>(FEIRNodeKind::kStmtPesudoTail));
+  head->SetNext(tail);
+  tail->SetPrev(head);
+  return head;
+}
+
+FEIRStmt *FEIRLower::RegisterAndInsertFEIRStmt(UniqueFEIRStmt stmt, FEIRStmt *ptrTail, const Loc loc) {
+  stmt->SetSrcLoc(loc);
+  FEIRStmt *prtStmt = func.RegisterFEIRStmt(std::move(stmt));
+  ptrTail->InsertBefore(prtStmt);
+  return prtStmt;
+}
+
+void FEIRLower::LowerFunc() {
+  FELinkListNode *nodeStmt = func.GetFEIRStmtHead()->GetNext();
+  if (nodeStmt != func.GetFEIRStmtTail()) {
+    LowerStmt(static_cast<FEIRStmt*>(nodeStmt), lowerStmtTail);
+  }
+  Clear();
+}
+
+void FEIRLower::LowerStmt(const std::list<UniqueFEIRStmt> &stmts, FEIRStmt *ptrTail) {
+  FEIRStmt *tmpHead = CreateHeadAndTail();
+  FEIRStmt *tmpTail = static_cast<FEIRStmt*>(tmpHead->GetNext());
+  for (auto &stmt : stmts) {
+    tmpTail->InsertBefore(stmt.get());
+  }
+  LowerStmt(static_cast<FEIRStmt*>(tmpHead->GetNext()), ptrTail);
+}
+
+void FEIRLower::LowerStmt(FEIRStmt *stmt, FEIRStmt *ptrTail) {
+  FEIRStmt *nextStmt = stmt;
+  do {
+    stmt = nextStmt;
+    nextStmt = static_cast<FEIRStmt*>(stmt->GetNext());
+    switch (stmt->GetKind()) {
+      case kStmtIf:
+        LowerIfStmt(*static_cast<FEIRStmtIf*>(stmt), ptrTail);
+        break;
+      case kStmtDoWhile:
+        ProcessLoopStmt(*static_cast<FEIRStmtDoWhile*>(stmt), ptrTail);
+        break;
+      case kStmtPesudoTail:
+      case kStmtPesudoFuncEnd:
+        return;
+      default:
+        ptrTail->InsertBefore(stmt);
+        break;
+    }
+  } while (nextStmt != nullptr);
+}
+
+void FEIRLower::LowerIfStmt(FEIRStmtIf &ifStmt, FEIRStmt *ptrTail) {
+  FEIRStmt *thenHead = nullptr;
+  FEIRStmt *thenTail = nullptr;
+  FEIRStmt *elseHead = nullptr;
+  FEIRStmt *elseTail = nullptr;
+  if (!ifStmt.GetThenStmt().empty()) {
+    thenHead = CreateHeadAndTail();
+    thenTail = static_cast<FEIRStmt*>(thenHead->GetNext());
+    LowerStmt(ifStmt.GetThenStmt(), thenTail);
+  }
+  if (!ifStmt.GetElseStmt().empty()) {
+    elseHead = CreateHeadAndTail();
+    elseTail = static_cast<FEIRStmt*>(elseHead->GetNext());
+    LowerStmt(ifStmt.GetElseStmt(), elseTail);
+  }
+  if (ifStmt.GetThenStmt().empty() && ifStmt.GetElseStmt().empty()) {
+    // eval <cond> statement
+    std::list<UniqueFEIRExpr> feExprs;
+    feExprs.emplace_back(ifStmt.GetCondExpr()->Clone());
+    (void)RegisterAndInsertFEIRStmt(
+        std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs)), ptrTail, ifStmt.GetSrcLoc());
+  } else if (ifStmt.GetElseStmt().empty()) {
+    // brfalse <cond> <endlabel>
+    // <thenPart>
+    // label <endlabel>
+    CreateAndInsertCondStmt(OP_brfalse, ifStmt, thenHead, thenTail, ptrTail);
+  } else if (ifStmt.GetThenStmt().empty()) {
+    // brtrue <cond> <endlabel>
+    // <elsePart>
+    // label <endlabel>
+    CreateAndInsertCondStmt(OP_brtrue, ifStmt, elseHead, elseTail, ptrTail);
+  } else {
+    // brfalse <cond> <elselabel>
+    // <thenPart>
+    // goto <endlabel>
+    // label <elselabel>
+    // <elsePart>
+    // label <endlabel>
+    std::string elseName = FEUtils::CreateLabelName();
+    UniqueFEIRStmt condFEStmt = std::make_unique<FEIRStmtCondGotoForC>(
+        ifStmt.GetCondExpr()->Clone(), OP_brfalse, elseName);
+    auto condStmt = RegisterAndInsertFEIRStmt(std::move(condFEStmt), ptrTail, ifStmt.GetSrcLoc());
+    // <thenPart>
+    FELinkListNode::SpliceNodes(thenHead, thenTail, ptrTail);
+    // goto <endlabel>
+    std::string endName = FEUtils::CreateLabelName();
+    auto gotoStmt = RegisterAndInsertFEIRStmt(FEIRBuilder::CreateStmtGoto(endName), ptrTail);
+    // label <elselabel>
+    auto elseLabelStmt = RegisterAndInsertFEIRStmt(std::make_unique<FEIRStmtLabel>(elseName), ptrTail);
+    // <elsePart>
+    FELinkListNode::SpliceNodes(elseHead, elseTail, ptrTail);
+    // label <endlabel>
+    auto endLabelStmt = RegisterAndInsertFEIRStmt(std::make_unique<FEIRStmtLabel>(endName), ptrTail);
+    // link bb
+    condStmt->AddExtraSucc(*elseLabelStmt);
+    elseLabelStmt->AddExtraPred(*condStmt);
+    gotoStmt->AddExtraSucc(*endLabelStmt);
+    endLabelStmt->AddExtraPred(*gotoStmt);
+  }
+}
+
+// for/dowhile/while stmts
+void FEIRLower::ProcessLoopStmt(FEIRStmtDoWhile &stmt, FEIRStmt *ptrTail) {
+  FEIRStmt *bodyHead = nullptr;
+  FEIRStmt *bodyTail = nullptr;
+  if (!stmt.GetBodyStmts().empty()) {
+    bodyHead = CreateHeadAndTail();
+    bodyTail = static_cast<FEIRStmt*>(bodyHead->GetNext());
+    LowerStmt(stmt.GetBodyStmts(), bodyTail);
+  }
+  // for/while
+  if (stmt.GetOpcode() == OP_while) {
+    return LowerWhileStmt(stmt, bodyHead, bodyTail, ptrTail);
+  }
+  // dowhile
+  if (stmt.GetOpcode() == OP_dowhile) {
+    return LowerDoWhileStmt(stmt, bodyHead, bodyTail, ptrTail);
+  }
+}
+
+/*
+ * while <cond> <body>
+ * is lowered to :
+ * label <whilelabel>
+ * brfalse <cond> <endlabel>
+ * <body>
+ * goto <whilelabel>
+ * label <endlabel>
+ */
+void FEIRLower::LowerWhileStmt(const FEIRStmtDoWhile &whileStmt, FEIRStmt *bodyHead,
+                               FEIRStmt *bodyTail, FEIRStmt *ptrTail) {
+  std::string whileLabelName = FEUtils::CreateLabelName();
+  // label <whilelabel>
+  auto whileLabelStmt = RegisterAndInsertFEIRStmt(std::make_unique<FEIRStmtLabel>(whileLabelName), ptrTail);
+  std::string endLabelName = FEUtils::CreateLabelName();
+  // brfalse <cond> <endlabel>
+  UniqueFEIRStmt condFEStmt = std::make_unique<FEIRStmtCondGotoForC>(
+      whileStmt.GetCondExpr()->Clone(), OP_brfalse, endLabelName);
+  auto condStmt = RegisterAndInsertFEIRStmt(std::move(condFEStmt), ptrTail, whileStmt.GetSrcLoc());
+  if (bodyHead != nullptr && bodyTail != nullptr) {
+    // <body>
+    FELinkListNode::SpliceNodes(bodyHead, bodyTail, ptrTail);
+  }
+  // goto <whilelabel>
+  auto gotoStmt = RegisterAndInsertFEIRStmt(FEIRBuilder::CreateStmtGoto(whileLabelName), ptrTail);
+  // label <endlabel>
+  auto endLabelStmt = RegisterAndInsertFEIRStmt(std::make_unique<FEIRStmtLabel>(endLabelName), ptrTail);
+  // link bb
+  condStmt->AddExtraSucc(*endLabelStmt);
+  endLabelStmt->AddExtraPred(*condStmt);
+  gotoStmt->AddExtraSucc(*whileLabelStmt);
+  whileLabelStmt->AddExtraPred(*gotoStmt);
+}
+
+/*
+ * dowhile <body> <cond>
+ * is lowered to:
+ * label <bodylabel>
+ * <body>
+ * brtrue <cond> <bodylabel>
+ */
+void FEIRLower::LowerDoWhileStmt(const FEIRStmtDoWhile &doWhileStmt, FEIRStmt *bodyHead,
+                                 FEIRStmt *bodyTail, FEIRStmt *ptrTail) {
+  std::string bodyLabelName = FEUtils::CreateLabelName();
+  // label <bodylabel>
+  auto bodyLabelStmt = RegisterAndInsertFEIRStmt(std::make_unique<FEIRStmtLabel>(bodyLabelName), ptrTail);
+  if (bodyHead != nullptr && bodyTail != nullptr) {
+    // <body>
+    FELinkListNode::SpliceNodes(bodyHead, bodyTail, ptrTail);
+  }
+  // brtrue <cond> <bodylabel>
+  UniqueFEIRStmt condFEStmt = std::make_unique<FEIRStmtCondGotoForC>(
+      doWhileStmt.GetCondExpr()->Clone(), OP_brtrue, bodyLabelName);
+  auto condStmt = RegisterAndInsertFEIRStmt(std::move(condFEStmt), ptrTail, doWhileStmt.GetSrcLoc());
+  // link bb
+  condStmt->AddExtraSucc(*bodyLabelStmt);
+  bodyLabelStmt->AddExtraPred(*condStmt);
+}
+
+void FEIRLower::CreateAndInsertCondStmt(Opcode op, const FEIRStmtIf &ifStmt,
+                                        FEIRStmt *head, FEIRStmt *tail, FEIRStmt *ptrTail) {
+  std::string labelName = FEUtils::CreateLabelName();
+  UniqueFEIRStmt condFEStmt = std::make_unique<FEIRStmtCondGotoForC>(ifStmt.GetCondExpr()->Clone(), op, labelName);
+  FEIRStmt *condStmt = RegisterAndInsertFEIRStmt(std::move(condFEStmt), ptrTail, ifStmt.GetSrcLoc());
+  FELinkListNode::SpliceNodes(head, tail, ptrTail);
+  FEIRStmt *labelStmt = RegisterAndInsertFEIRStmt(std::make_unique<FEIRStmtLabel>(labelName), ptrTail);
+  // link bb
+  condStmt->AddExtraSucc(*labelStmt);
+  labelStmt->AddExtraPred(*condStmt);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/optimize/src/ror.cpp b/src/hir2mpl/optimize/src/ror.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b2abd038c67d455ae195aa5892da7ab3b84f7b02
--- /dev/null
+++ b/src/hir2mpl/optimize/src/ror.cpp
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ror.h"
+#include "feir_builder.h"
+
+namespace maple {
+UniqueFEIRExpr Ror::Emit2FEExpr() {
+  if (op != OP_bior || !CheckBaseExpr()) {
+    return nullptr;
+  }
+
+  auto lBinExpr = static_cast<FEIRExprBinary*>(lExpr.get());
+  auto rBinExpr = static_cast<FEIRExprBinary*>(rExpr.get());
+  bitWidth = GetPrimTypeBitSize(lBinExpr->GetOpnd0()->GetPrimType());
+
+  if (lBinExpr->GetOp() == OP_shl && rBinExpr->GetOp() == OP_lshr) {
+    if (!IsRorLshrOpnd(rBinExpr->GetOpnd1(), false) || !IsRorShlOpnd(lBinExpr->GetOpnd1())) {
+      return nullptr;
+    }
+  } else if (lBinExpr->GetOp() == OP_lshr && rBinExpr->GetOp() == OP_shl) {
+    if (!IsRorLshrOpnd(lBinExpr->GetOpnd1(), false) || !IsRorShlOpnd(rBinExpr->GetOpnd1())) {
+      return nullptr;
+    }
+  }
+
+  if (*rShiftBaseExpr != *lShiftBaseExpr) {
+    return nullptr;
+  }
+
+  return FEIRBuilder::CreateExprBinary(OP_ror, lBinExpr->GetOpnd0()->Clone(), rShiftBaseExpr->Clone());
+}
+
+bool Ror::CheckBaseExpr() const {
+  if (lExpr->GetKind() != kExprBinary || rExpr->GetKind() != kExprBinary) {
+    return false;
+  }
+
+  auto lBinExpr = static_cast<FEIRExprBinary*>(lExpr.get());
+  auto rBinExpr = static_cast<FEIRExprBinary*>(rExpr.get());
+  if (!((lBinExpr->GetOp() == OP_shl && rBinExpr->GetOp() == OP_lshr) ||
+      (lBinExpr->GetOp() == OP_lshr && rBinExpr->GetOp() == OP_shl))) {
+    return false;
+  }
+
+  if (*(lBinExpr->GetOpnd0()) != *(rBinExpr->GetOpnd0()) ||
+      !IsUnsignedInteger(lBinExpr->GetOpnd0()->GetPrimType())) {
+    return false;
+  }
+
+  return true;
+}
+
+bool Ror::GetConstVal(const UniqueFEIRExpr &expr) {
+  if (expr->GetKind() != kExprConst && expr->GetKind() != kExprUnary) {
+    return false;
+  }
+
+  FEIRExprConst *constExpr;
+  if (expr->GetKind() == kExprUnary) {
+    UniqueFEIRExpr opndExpr = static_cast<FEIRExprUnary*>(expr.get())->GetOpnd()->Clone();
+    if (opndExpr->GetKind() != kExprConst) {
+      return false;
+    }
+    constExpr = static_cast<FEIRExprConst*>(opndExpr.get());
+  } else {
+    constExpr = static_cast<FEIRExprConst*>(expr.get());
+  }
+
+  constVal = constExpr->GetValue().u64;
+
+  return true;
+}
+
+bool Ror::IsRorShlOpnd(const UniqueFEIRExpr &expr) {
+  if (expr->GetKind() != kExprBinary) {
+    return false;
+  }
+
+  auto binExpr = static_cast<FEIRExprBinary*>(expr.get());
+  if (binExpr->GetOp() != OP_sub || !GetConstVal(binExpr->GetOpnd0()) || constVal != bitWidth) {
+    return false;
+  }
+
+  if (!IsRorLshrOpnd(binExpr->GetOpnd1(), true)) {
+    return false;
+  }
+
+  return true;
+}
+
+bool Ror::IsRorLshrOpnd(const UniqueFEIRExpr &expr, bool inShl) {
+  if (expr->GetKind() != kExprBinary) {
+    return false;
+  }
+
+  auto binExpr = static_cast<FEIRExprBinary*>(expr.get());
+  if (binExpr->GetOp() != OP_band) {
+    return false;
+  }
+
+  auto SetShiftBaseExpr = [inShl, this](const UniqueFEIRExpr &expr) {
+    if (inShl) {
+      lShiftBaseExpr = expr->Clone();
+    } else {
+      rShiftBaseExpr = expr->Clone();
+    }
+  };
+
+  if (GetConstVal(binExpr->GetOpnd0())) {
+    SetShiftBaseExpr(binExpr->GetOpnd1());
+  } else if (GetConstVal(binExpr->GetOpnd1())) {
+    SetShiftBaseExpr(binExpr->GetOpnd0());
+  } else {
+    return false;
+  }
+
+  if (constVal != bitWidth - 1) {
+    return false;
+  }
+
+  return true;
+}
+}
diff --git a/src/hir2mpl/test/BUILD.gn b/src/hir2mpl/test/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..ac663e060f93d270191ae1a3aeead4435de503cf
--- /dev/null
+++ b/src/hir2mpl/test/BUILD.gn
@@ -0,0 +1,219 @@
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+cflags += [
+  "-DMIR_FEATURE_FULL=1",
+  "-DHIR2MPL_FULL_INFO_DUMP=1",
+  "-DENABLE_COV_CHECK=1",
+]
+
+cflags_cc -= [
+  "-Werror",
+]
+
+
+include_dirs_dex = [
+  "${ANDROID_ROOT}/dalvik",
+  "${ANDROID_ROOT}/system/core/include",
+]
+include_dirs_libdexfile = [
+  #for libdexfile -start
+  "${ANDROID_ROOT}/system/core/liblog/include",
+  "${ANDROID_ROOT}/system/core/libutils/include",
+  "${ANDROID_ROOT}/system/core/libnativehelper/include_jni",
+  "${ANDROID_ROOT}/system/core/base/include",
+  "${ANDROID_ROOT}/system/core/libziparchive/include",
+  "${ANDROID_ROOT}/art/libartpalette/include",
+  "${ANDROID_ROOT}/art/libartbase",
+  "${ANDROID_ROOT}/art/libdexfile",
+  "${ANDROID_ROOT}/include",
+
+  #for libdexfile -end
+]
+
+include_directories = include_dirs_libdexfile + include_dirs_dex
+
+executable("hir2mplUT") {
+  sources = []
+
+  include_dirs = include_directories
+
+  deps = [
+    ":lib_hir2mpl_test_ast_input_clang",
+    ":lib_hir2mpl_test_bytecode_input_dex",
+    ":lib_hir2mpl_test_common",
+    ":lib_hir2mpl_test_bytecode_input_class",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
+    "${MAPLEALL_ROOT}/maple_ir:libmplir",
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/mempool:libmempool",
+    "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
+    "${HIR2MPL_ROOT}:lib_hir2mpl_ast_input_clang",
+    "${HIR2MPL_ROOT}:lib_hir2mpl_ast_input_common",
+    "${HIR2MPL_ROOT}:lib_hir2mpl_common",
+    "${HIR2MPL_ROOT}:lib_hir2mpl_optimize",
+  ]
+
+  if (ONLY_C != 1) {
+    deps += [
+      "${HIR2MPL_ROOT}:lib_hir2mpl_bytecode_input_dex",
+      "${HIR2MPL_ROOT}:lib_hir2mpl_bytecode_input_common",
+      "${HIR2MPL_ROOT}:lib_hir2mpl_bytecode_input_class",
+    ]
+  }
+
+  ldflags = [
+    "-rdynamic",
+    "-L${LLVMLIBDIR}/",
+    "-Wl,-rpath,${LLVMLIBDIR}/",
+    "-Wl,-rpath,${MAPLE_ROOT}/build/gtestlib/lib",
+  ]
+
+  libs = [
+    "${MAPLE_ROOT}/build/gtestlib/lib/libgmock.so",
+    "${MAPLE_ROOT}/build/gtestlib/lib/libgmock_main.so",
+    "${MAPLE_ROOT}/build/gtestlib/lib/libgtest.so",
+    "${MAPLE_ROOT}/build/gtestlib/lib/libgtest_main.so",
+    "z",
+    "pthread",
+  ]
+}
+
+include_ast_input_clang_directories = [
+  "${HIR2MPL_ROOT}/common/include",
+  "${HIR2MPL_ROOT}/optimize/include",
+  "${HIR2MPL_ROOT}/ast_input/clang/include",
+  "${HIR2MPL_ROOT}/ast_input/common/include",
+  "${HIR2MPL_ROOT}/test/common",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${MAPLE_ROOT}/build/gtestlib/include",
+]
+
+source_set("lib_hir2mpl_test_ast_input_clang") {
+  sources = [
+    "${HIR2MPL_ROOT}/test/ast_input/clang/ast_expr_test.cpp",
+    "${HIR2MPL_ROOT}/test/ast_input/clang/ast_var_test.cpp",
+  ]
+  include_dirs = include_ast_input_clang_directories
+  output_dir = "${root_out_dir}/ar"
+}
+
+include_bytecode_input_class_directories = [
+  "${HIR2MPL_ROOT}/common/include",
+  "${HIR2MPL_ROOT}/optimize/include",
+  "${HIR2MPL_ROOT}/bytecode_input/class/include",
+  "${HIR2MPL_ROOT}/test/common",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${MAPLE_ROOT}/build/gtestlib/include",
+]
+
+source_set("lib_hir2mpl_test_bytecode_input_class") {
+  sources = [
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_class2fe_helper_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_class_const_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_class_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_function_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_opcode_helper_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_stack2fe_helper_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_stack_helper_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_stmt_bb_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_stmt_loc_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_util_test.cpp",
+  ]
+  include_dirs = include_bytecode_input_class_directories
+  output_dir = "${root_out_dir}/ar"
+}
+
+include_common_directories = [
+  "${HIR2MPL_ROOT}/common/include",
+  "${HIR2MPL_ROOT}/optimize/include",
+  "${HIR2MPL_ROOT}/bytecode_input/class/include",  # hir2mplUT.cpp exists
+  "${HIR2MPL_ROOT}/test/common",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${MAPLE_ROOT}/build/gtestlib/include",
+]
+
+source_set("lib_hir2mpl_test_common") {
+  sources = [
+    "${HIR2MPL_ROOT}/test/common/base64_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/basic_io_test.cpp",
+
+    # "${HIR2MPL_ROOT}/test/common/fe_function_process_schedular_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/fe_algorithm_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/fe_file_ops_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/fe_file_type_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_cfg_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/fe_struct_elem_info_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/fe_type_hierarchy_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/fe_type_manager_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/fe_utils_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_builder_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_stmt_dfg_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_stmt_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_test_base.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_type_helper_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_type_infer_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_type_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_var_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/feir_lower_test.cpp",
+    "${HIR2MPL_ROOT}/test/common/hir2mplUT.cpp",
+    "${HIR2MPL_ROOT}/test/common/hir2mpl_ut_options.cpp",
+    "${HIR2MPL_ROOT}/test/common/hir2mpl_ut_regx.cpp",
+    "${HIR2MPL_ROOT}/test/common/hir2mpl_ut_regx_test.cpp",
+  ]
+  include_dirs = include_common_directories
+  output_dir = "${root_out_dir}/ar"
+}
+
+include_bytecode_input_dex_directories = [
+  "${HIR2MPL_ROOT}/common/include",
+  "${HIR2MPL_ROOT}/optimize/include",
+  "${HIR2MPL_ROOT}/bytecode_input/common/include",
+  "${HIR2MPL_ROOT}/bytecode_input/dex/include",
+  "${HIR2MPL_ROOT}/test/common",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${MAPLE_ROOT}/build/gtestlib/include",
+]
+
+source_set("lib_hir2mpl_test_bytecode_input_dex") {
+  sources = [
+    "${HIR2MPL_ROOT}/test/bytecode_input/dex/bc_load_on_demand_type_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/dex/bc_parser_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/dex/bc_util_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/dex/dex_class_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/dex/dex_file_util_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/dex/dex_op_test.cpp",
+    "${HIR2MPL_ROOT}/test/bytecode_input/dex/dex_reader_test.cpp",
+  ]
+  include_dirs = include_bytecode_input_dex_directories
+  output_dir = "${root_out_dir}/ar"
+}
+
diff --git a/src/hir2mpl/test/CMakeLists.txt b/src/hir2mpl/test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ced8cd50ddfe785a786fb31cfe3330db3819d2fd
--- /dev/null
+++ b/src/hir2mpl/test/CMakeLists.txt
@@ -0,0 +1,168 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMIR_FEATURE_FULL=1 -DHIR2MPL_FULL_INFO_DUMP=1 -DENABLE_COV_CHECK=1 -fvisibility=hidden")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DMIR_FEATURE_FULL=1 -DHIR2MPL_FULL_INFO_DUMP=1 -DENABLE_COV_CHECK=1 -fvisibility=hidden")
+
+string(REPLACE "-Werror" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+set(include_directories
+        ${ANDROID_ROOT}/dalvik
+        ${ANDROID_ROOT}/system/core/include
+        ${ANDROID_ROOT}/system/core/liblog/include
+        ${ANDROID_ROOT}/system/core/libutils/include
+        ${ANDROID_ROOT}/system/core/libnativehelper/include_jni
+        ${ANDROID_ROOT}/system/core/base/include
+        ${ANDROID_ROOT}/system/core/libziparchive/include
+        ${ANDROID_ROOT}/art/libartpalette/include
+        ${ANDROID_ROOT}/art/libartbase
+        ${ANDROID_ROOT}/art/libdexfile
+        ${ANDROID_ROOT}/include
+        ${HIR2MPL_ROOT}/ast_input/clang/include
+        ${HIR2MPL_ROOT}/ast_input/common/include
+        ${HIR2MPL_ROOT}/common/include
+        ${HIR2MPL_ROOT}/optimize/include
+        ${HIR2MPL_ROOT}/bytecode_input/class/include  # hir2mplUT.cpp exists
+        ${HIR2MPL_ROOT}/test/common
+        ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+        ${MAPLEALL_ROOT}/maple_ir/include
+        ${MAPLEALL_ROOT}/maple_util/include
+        ${MAPLEALL_ROOT}/maple_driver/include
+        ${MAPLEALL_ROOT}/mempool/include
+        ${MAPLE_ROOT}/build/gtestlib/include
+        ${HIR2MPL_ROOT}/bytecode_input/common/include
+        ${HIR2MPL_ROOT}/bytecode_input/dex/include
+        )
+
+set(deps_hir2mplUT
+        libHWSecureC
+        libdriver_option
+        libmplphase
+        libcommandline
+        libmplir
+        libmplutil
+        libmempool
+        libmpl2mpl
+        lib_hir2mpl_ast_input_clang_lib
+        lib_hir2mpl_ast_input_clang
+        lib_hir2mpl_ast_input_common
+        lib_hir2mpl_common
+        lib_hir2mpl_optimize
+        ${LLVMLIBDIR}/libclang.so
+        ${LLVMLIBDIR}/libclang-cpp.so
+        ${LLVMLIBDIR}/libclangFrontend.a
+        ${LLVMLIBDIR}/libclangDriver.a
+        ${LLVMLIBDIR}/libclangSerialization.a
+        ${LLVMLIBDIR}/libclangParse.a
+        ${LLVMLIBDIR}/libclangSema.a
+        ${LLVMLIBDIR}/libclangEdit.a
+        ${LLVMLIBDIR}/libclangLex.a
+        ${LLVMLIBDIR}/libclangAnalysis.a
+        ${LLVMLIBDIR}/libclangAST.a
+        ${LLVMLIBDIR}/libclangBasic.a
+        ${LLVMLIBDIR}/libLLVMDemangle.a
+        ${LLVMLIBDIR}/libLLVMMCParser.a
+        ${LLVMLIBDIR}/libLLVMMC.a
+        ${LLVMLIBDIR}/libLLVMBitReader.a
+        ${LLVMLIBDIR}/libLLVMCore.a
+        ${LLVMLIBDIR}/libLLVMBinaryFormat.a
+        ${LLVMLIBDIR}/libLLVMProfileData.a
+        ${LLVMLIBDIR}/libLLVMOption.a
+        ${LLVMLIBDIR}/libLLVMSupport.a
+        ${MAPLE_ROOT}/build/gtestlib/lib/libgmock.so
+        ${MAPLE_ROOT}/build/gtestlib/lib/libgmock_main.so
+        ${MAPLE_ROOT}/build/gtestlib/lib/libgtest.so
+        ${MAPLE_ROOT}/build/gtestlib/lib/libgtest_main.so
+        z
+        pthread
+        )
+
+if (NOT ${ONLY_C} STREQUAL "1")
+    list(APPEND deps_hir2mplUT
+            lib_hir2mpl_bytecode_input_dex
+            lib_hir2mpl_bytecode_input_common
+            lib_hir2mpl_bytecode_input_class
+            libdexfile
+            libziparchive
+            libbase
+            ${THIRD_PARTY_ROOT}/aosp_modified/system/core/liblog/liblog.a
+            )
+endif()
+
+set($CMAKE_EXE_LINKER_FLAGS "CMAKE_EXE_LINKER_FLAGS -rdynamic -rdynamic -L${LLVMLIBDIR} -Wl,-rpath,${LLVMLIBDIR} -Wl,-rpath,${MAPLE_ROOT}/build/gtestlib/lib")
+
+set(src_hir2mplUT "")
+list(APPEND src_hir2mplUT
+        ${HIR2MPL_ROOT}/test/ast_input/clang/ast_expr_test.cpp
+        ${HIR2MPL_ROOT}/test/ast_input/clang/ast_var_test.cpp
+        )
+
+list(APPEND src_hir2mplUT
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_class2fe_helper_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_class_const_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_class_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_function_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_opcode_helper_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_stack2fe_helper_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_stack_helper_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_stmt_bb_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_stmt_loc_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/class/jbc_util_test.cpp
+        )
+
+list(APPEND src_hir2mplUT
+        ${HIR2MPL_ROOT}/test/common/base64_test.cpp
+        ${HIR2MPL_ROOT}/test/common/basic_io_test.cpp
+        ${HIR2MPL_ROOT}/test/common/fe_algorithm_test.cpp
+        ${HIR2MPL_ROOT}/test/common/fe_file_ops_test.cpp
+        ${HIR2MPL_ROOT}/test/common/fe_file_type_test.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_cfg_test.cpp
+        ${HIR2MPL_ROOT}/test/common/fe_struct_elem_info_test.cpp
+        ${HIR2MPL_ROOT}/test/common/fe_type_hierarchy_test.cpp
+        ${HIR2MPL_ROOT}/test/common/fe_type_manager_test.cpp
+        ${HIR2MPL_ROOT}/test/common/fe_utils_test.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_builder_test.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_stmt_dfg_test.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_stmt_test.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_test_base.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_type_helper_test.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_type_infer_test.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_type_test.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_var_test.cpp
+        ${HIR2MPL_ROOT}/test/common/feir_lower_test.cpp
+        ${HIR2MPL_ROOT}/test/common/hir2mplUT.cpp
+        ${HIR2MPL_ROOT}/test/common/hir2mpl_ut_options.cpp
+        ${HIR2MPL_ROOT}/test/common/hir2mpl_ut_regx.cpp
+        ${HIR2MPL_ROOT}/test/common/hir2mpl_ut_regx_test.cpp
+        )
+
+list(APPEND src_hir2mplUT
+        ${HIR2MPL_ROOT}/test/bytecode_input/dex/bc_load_on_demand_type_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/dex/bc_parser_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/dex/bc_util_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/dex/dex_class_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/dex/dex_file_util_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/dex/dex_op_test.cpp
+        ${HIR2MPL_ROOT}/test/bytecode_input/dex/dex_reader_test.cpp
+        )
+
+#hir2mplUT
+add_executable(hir2mplUT "${src_hir2mplUT}")
+set_target_properties(hir2mplUT PROPERTIES
+        COMPILE_FLAGS ""
+        INCLUDE_DIRECTORIES "${include_directories}"
+        LINK_LIBRARIES "${deps_hir2mplUT}"
+        RUNTIME_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/bin"
+        )
diff --git a/src/hir2mpl/test/ast_input/clang/ast_expr_test.cpp b/src/hir2mpl/test/ast_input/clang/ast_expr_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e3ca47837205f4eac14d1ebb6a0b235f75370567
--- /dev/null
+++ b/src/hir2mpl/test/ast_input/clang/ast_expr_test.cpp
@@ -0,0 +1,761 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "feir_test_base.h"
+#include "fe_manager.h"
+#include "hir2mpl_ut_regx.h"
+#include "ast_expr.h"
+#include "ast_decl_builder.h"
+
+namespace maple {
+class AstExprTest : public FEIRTestBase {
+ public:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  AstExprTest() : allocator(mp) {}
+  virtual ~AstExprTest() = default;
+
+  static void SetUpTestCase() {
+    FEManager::GetManager().GetModule().SetSrcLang(kSrcLangC);
+    mp = FEUtils::NewMempool("MemPool for JBCFunctionTest", false /* isLcalPool */);
+  }
+
+  static void TearDownTestCase() {
+    FEManager::GetManager().GetModule().SetSrcLang(kSrcLangUnknown);
+    delete mp;
+    mp = nullptr;
+  }
+
+  template<typename T>
+  std::unique_ptr<T> GetConstASTExpr(PrimType primType, double val) {
+    std::unique_ptr<T> astExpr = std::make_unique<T>();
+    astExpr->SetType(primType);
+    astExpr->SetVal(val);
+    return std::move(astExpr);
+  }
+};
+MemPool *AstExprTest::mp = nullptr;
+
+TEST_F(AstExprTest, IntegerLiteral) {
+  RedirectCout();
+  std::list<UniqueFEIRStmt> stmts;
+  ASTIntegerLiteral *astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  astExpr->SetType(GlobalTables::GetTypeTable().GetInt64());
+  astExpr->SetVal(256);
+  UniqueFEIRExpr feExpr = astExpr->Emit2FEExpr(stmts);
+  ASSERT_EQ(feExpr->GetKind(), kExprConst);
+  BaseNode *exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "constval i64 256\n");
+  RestoreCout();
+}
+
+TEST_F(AstExprTest, ImaginaryLiteral) {
+  MIRType *elemType = FEManager::GetTypeManager().GetOrCreateTypeFromName("I", FETypeFlag::kSrcUnknown, false);
+  MIRType *complexType = FEManager::GetTypeManager().GetOrCreateComplexStructType(*elemType);
+  ASTImaginaryLiteral *astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTImaginaryLiteral>(allocator);
+  astExpr->SetComplexType(complexType);
+  astExpr->SetElemType(elemType);
+  // create child expr
+  ASTIntegerLiteral *childExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  childExpr->SetVal(2);
+  childExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  astExpr->SetASTExpr(childExpr);
+
+  std::list<UniqueFEIRStmt> stmts;
+  UniqueFEIRExpr feExpr = astExpr->Emit2FEExpr(stmts);
+  // check returned expr products
+  ASSERT_EQ(feExpr->GetKind(), kExprDRead);
+  BaseNode *exprConst = feExpr->GenMIRNode(mirBuilder);
+  RedirectCout();
+  exprConst->Dump();
+  std::string pattern = std::string("dread agg %Complex_[0-9]\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  // check intermediate stmt products
+  ASSERT_EQ(stmts.size(), 2);
+  std::list<StmtNode*> stmtNodeFront = stmts.front()->GenMIRStmts(mirBuilder);
+  stmtNodeFront.front()->Dump();
+  pattern = std::string("dassign %Complex_[0-9] 1 \\(constval i32 0\\)\n\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  pattern = std::string("dassign %Complex_[0-9] 1 \\(constval i32 0\\)\n\n");
+  std::list<StmtNode*> stmtNodeSecond = stmts.back()->GenMIRStmts(mirBuilder);
+  stmtNodeSecond.front()->Dump();
+  pattern = std::string("dassign %Complex_[0-9] 2 \\(constval i32 2\\)\n\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  RestoreCout();
+}
+
+// ---------- ASTUnaryOperatorExpr ----------
+TEST_F(AstExprTest, ASTUnaryOperatorExpr_1) {
+  RedirectCout();
+  std::list<UniqueFEIRStmt> stmts;
+
+  // struct/union/array and pointer need test
+  PrimType primType = PTY_i32;
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(primType);
+  PrimType ouPrimType = PTY_i32;
+  MIRType *ouType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ouPrimType);
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({subType}, allocator.Adapter()));
+  astRefExpr->SetASTDecl(astDecl);
+
+  // ASTUOMinusExpr
+  ASTUOMinusExpr *astUOMinusExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOMinusExpr>(allocator);
+  astUOMinusExpr->SetSubType(subType);
+  astUOMinusExpr->SetUOType(ouType);
+  astRefExpr->SetASTDecl(astDecl);
+  astUOMinusExpr->SetUOExpr(astRefExpr);
+  UniqueFEIRExpr feExpr = astUOMinusExpr->Emit2FEExpr(stmts);
+  BaseNode *exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "neg i32 (dread i32 %aVar_0_0)\n");
+
+  // ASTUOPlusExpr
+  ASTUOPlusExpr *astUOPlusExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOPlusExpr>(allocator);
+  astUOPlusExpr->SetSubType(subType);
+  astUOPlusExpr->SetUOType(ouType);
+  astRefExpr->SetASTDecl(astDecl);
+  astUOPlusExpr->SetUOExpr(astRefExpr);
+  feExpr = astUOPlusExpr->Emit2FEExpr(stmts);
+  exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "dread i32 %aVar_0_0\n");
+
+  // ASTUONotExpr
+  ASTUONotExpr *astUONotExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUONotExpr>(allocator);
+  astUONotExpr->SetSubType(subType);
+  astUONotExpr->SetUOExpr(astRefExpr);
+  astUONotExpr->SetUOType(ouType);
+  feExpr = astUONotExpr->Emit2FEExpr(stmts);
+  exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "bnot i32 (dread i32 %aVar_0_0)\n");
+
+  // ASTUOLNotExpr
+  ASTUOLNotExpr *astUOLNotExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOLNotExpr>(allocator);
+  astUOLNotExpr->SetSubType(subType);
+  astUOLNotExpr->SetUOExpr(astRefExpr);
+  astUOLNotExpr->SetUOType(ouType);
+  feExpr = astUOLNotExpr->Emit2FEExpr(stmts);
+  exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "eq u1 i32 (dread i32 %aVar_0_0, constval i32 0)\n");
+  RestoreCout();
+}
+
+TEST_F(AstExprTest, ASTUnaryOperatorExpr_2) {
+  RedirectCout();
+  std::list<UniqueFEIRStmt> stmts;
+
+  // struct/union/array and pointer need test
+  PrimType primType = PTY_i32;
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(primType);
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({subType}, allocator.Adapter()));
+  astRefExpr->SetASTDecl(astDecl);
+
+  // ASTUOPostIncExpr
+  ASTUOPostIncExpr *astUOPostIncExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOPostIncExpr>(allocator);
+  astUOPostIncExpr->SetSubType(subType);
+  astUOPostIncExpr->SetASTDecl(astDecl);
+  astUOPostIncExpr->SetUOExpr(astRefExpr);
+  UniqueFEIRExpr feExpr = astUOPostIncExpr->Emit2FEExpr(stmts);
+  std::list<StmtNode*> stmtNodeFront = stmts.front()->GenMIRStmts(mirBuilder);
+  stmtNodeFront.front()->Dump();
+  std::string pattern = std::string("dassign %postinc_[0-9] 0 \\(dread i32 \\%aVar_0_0\\)\n\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  std::list<StmtNode*> stmtNodeSecond = stmts.back()->GenMIRStmts(mirBuilder);
+  stmtNodeSecond.front()->Dump();
+  EXPECT_EQ(GetBufferString(), "dassign %aVar_0_0 0 (add i32 (dread i32 %aVar_0_0, constval i32 1))\n\n");
+  BaseNode *exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  pattern = std::string("dread i32 %postinc_[0-9]\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  stmts.clear();
+
+  // ASTUOPostDecExpr
+  ASTUOPostDecExpr *astUOPostDecExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOPostDecExpr>(allocator);
+  astUOPostDecExpr->SetSubType(subType);
+  astUOPostDecExpr->SetASTDecl(astDecl);
+  astUOPostDecExpr->SetUOExpr(astRefExpr);
+  feExpr = astUOPostDecExpr->Emit2FEExpr(stmts);
+  stmtNodeFront = stmts.front()->GenMIRStmts(mirBuilder);
+  stmtNodeFront.front()->Dump();
+  pattern = std::string("dassign %postdec_[0-9] 0 \\(dread i32 \\%aVar_0_0\\)\n\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  stmtNodeSecond = stmts.back()->GenMIRStmts(mirBuilder);
+  stmtNodeSecond.front()->Dump();
+  EXPECT_EQ(GetBufferString(), "dassign %aVar_0_0 0 (sub i32 (dread i32 %aVar_0_0, constval i32 1))\n\n");
+  exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  pattern = std::string("dread i32 %postdec_[0-9]\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  stmts.clear();
+
+  // ASTUOPreIncExpr
+  ASTUOPreIncExpr *astUOPreIncExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOPreIncExpr>(allocator);
+  astUOPreIncExpr->SetSubType(subType);
+  astUOPreIncExpr->SetASTDecl(astDecl);
+  astUOPreIncExpr->SetUOExpr(astRefExpr);
+  feExpr = astUOPreIncExpr->Emit2FEExpr(stmts);
+  stmtNodeFront = stmts.front()->GenMIRStmts(mirBuilder);
+  stmtNodeFront.front()->Dump();
+  EXPECT_EQ(GetBufferString(), "dassign %aVar_0_0 0 (add i32 (dread i32 %aVar_0_0, constval i32 1))\n\n");
+  exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "dread i32 %aVar_0_0\n");
+  stmts.clear();
+
+  // ASTUOPreDecExpr
+  ASTUOPreDecExpr *astUOPreDecExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOPreDecExpr>(allocator);
+  astUOPreDecExpr->SetSubType(subType);
+  astUOPreDecExpr->SetASTDecl(astDecl);
+  astUOPreDecExpr->SetUOExpr(astRefExpr);
+  feExpr = astUOPreDecExpr->Emit2FEExpr(stmts);
+  stmtNodeFront = stmts.front()->GenMIRStmts(mirBuilder);
+  stmtNodeFront.front()->Dump();
+  EXPECT_EQ(GetBufferString(), "dassign %aVar_0_0 0 (sub i32 (dread i32 %aVar_0_0, constval i32 1))\n\n");
+  exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "dread i32 %aVar_0_0\n");
+  stmts.clear();
+
+  RestoreCout();
+}
+
+TEST_F(AstExprTest, ASTUnaryOperatorExpr_3) {
+  RedirectCout();
+  std::list<UniqueFEIRStmt> stmts;
+
+  // struct/union/array and pointer need test
+  PrimType primType = PTY_i32;
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(primType);
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({subType}, allocator.Adapter()));
+  astRefExpr->SetASTDecl(astDecl);
+
+  // ASTUOAddrOfExpr
+  ASTUOAddrOfExpr *astUOAddrOfExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOAddrOfExpr>(allocator);
+  astUOAddrOfExpr->SetSubType(subType);
+  astRefExpr->SetASTDecl(astDecl);
+  astUOAddrOfExpr->SetUOExpr(astRefExpr);
+  UniqueFEIRExpr feExpr = astUOAddrOfExpr->Emit2FEExpr(stmts);
+  BaseNode *exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "addrof ptr %aVar_0_0\n");
+
+  // ASTUODerefExpr
+  ASTUODerefExpr *astUODerefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUODerefExpr>(allocator);
+  MIRType *uoType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_i32);
+  subType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*uoType, PTY_ptr);
+  astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({subType}, allocator.Adapter()));
+  astRefExpr->SetASTDecl(astDecl);
+  astUODerefExpr->SetUOType(uoType);
+  astUODerefExpr->SetSubType(subType);
+  astRefExpr->SetASTDecl(astDecl);
+  astUODerefExpr->SetUOExpr(astRefExpr);
+  feExpr = astUODerefExpr->Emit2FEExpr(stmts);
+  exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "iread i32 <* i32> 0 (dread ptr %aVar_0_0)\n");
+  RestoreCout();
+}
+
+TEST_F(AstExprTest, ASTCharacterLiteral) {
+  RedirectCout();
+  std::list<UniqueFEIRStmt> stmts;
+  ASTCharacterLiteral *astExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCharacterLiteral>(allocator);
+  astExpr->SetVal('a');
+  astExpr->SetPrimType(PTY_i32);
+  UniqueFEIRExpr feExpr = astExpr->Emit2FEExpr(stmts);
+  ASSERT_EQ(feExpr->GetKind(), kExprConst);
+  BaseNode *exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "constval i32 97\n");
+  RestoreCout();
+}
+
+TEST_F(AstExprTest, ASTParenExpr) {
+  RedirectCout();
+  std::list<UniqueFEIRStmt> stmts;
+  ASTParenExpr *astParenExpr = ASTDeclsBuilder::ASTExprBuilder<ASTParenExpr>(allocator);
+  ASTIntegerLiteral *astIntExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  astIntExpr->SetVal(2);
+  astIntExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  astParenExpr->SetASTExpr(static_cast<ASTExpr*>(astIntExpr));
+  UniqueFEIRExpr feExpr = astParenExpr->Emit2FEExpr(stmts);
+  BaseNode *exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "constval i32 2\n");
+  RestoreCout();
+}
+
+TEST_F(AstExprTest, ASTBinaryOperatorExpr_1) {
+  std::list<UniqueFEIRStmt> stmts;
+  PrimType primType = PTY_i32;
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(primType);
+  ASTDeclRefExpr *astRefExpr1 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl1 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({subType}, allocator.Adapter()));
+  astRefExpr1->SetASTDecl(astDecl1);
+  ASTDeclRefExpr *astRefExpr2 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl2 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "bVar",
+      MapleVector<MIRType*>({subType}, allocator.Adapter()));
+  astRefExpr2->SetASTDecl(astDecl2);
+
+  ASTBinaryOperatorExpr *astBinaryOperatorExpr1 = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  astBinaryOperatorExpr1->SetLeftExpr(astRefExpr1);
+  astBinaryOperatorExpr1->SetRightExpr(astRefExpr2);
+  astBinaryOperatorExpr1->SetOpcode(OP_add);
+  astBinaryOperatorExpr1->SetRetType(GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRExpr feExpr1 = astBinaryOperatorExpr1->Emit2FEExpr(stmts);
+  BaseNode *expr1 = feExpr1->GenMIRNode(mirBuilder);
+  RedirectCout();
+  expr1->Dump();
+  EXPECT_EQ(GetBufferString(), "add i32 (dread i32 %aVar_0_0, dread i32 %bVar_0_0)\n");
+
+  ASTBinaryOperatorExpr *astBinaryOperatorExpr2 = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  astBinaryOperatorExpr2->SetLeftExpr(astRefExpr1);
+  astBinaryOperatorExpr2->SetRightExpr(astRefExpr2);
+  astBinaryOperatorExpr2->SetOpcode(OP_mul);
+  astBinaryOperatorExpr2->SetRetType(GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRExpr feExpr2 = astBinaryOperatorExpr2->Emit2FEExpr(stmts);
+  BaseNode *expr2 = feExpr2->GenMIRNode(mirBuilder);
+  expr2->Dump();
+  EXPECT_EQ(GetBufferString(), "mul i32 (dread i32 %aVar_0_0, dread i32 %bVar_0_0)\n");
+  RestoreCout();
+}
+
+TEST_F(AstExprTest, ASTBinaryOperatorExpr_2) {
+  std::list<UniqueFEIRStmt> stmts;
+  PrimType primType = PTY_i32;
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(primType);
+  ASTDeclRefExpr *astRefExpr1 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl1 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({subType}, allocator.Adapter()));
+  astRefExpr1->SetASTDecl(astDecl1);
+  ASTDeclRefExpr *astRefExpr2 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl2 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "bVar",
+      MapleVector<MIRType*>({subType}, allocator.Adapter()));
+  astRefExpr2->SetASTDecl(astDecl2);
+
+  ASTAssignExpr *astAssignExpr = ASTDeclsBuilder::ASTExprBuilder<ASTAssignExpr>(allocator);
+  astAssignExpr->SetLeftExpr(astRefExpr1);
+  astAssignExpr->SetRightExpr(astRefExpr2);
+  UniqueFEIRExpr feExpr = astAssignExpr->Emit2FEExpr(stmts);
+  RedirectCout();
+  EXPECT_EQ(stmts.size(), 1);
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  EXPECT_EQ(mirStmts.size(), 1);
+  BaseNode *expr = feExpr->GenMIRNode(mirBuilder);
+  mirStmts.front()->Dump();
+  EXPECT_EQ(GetBufferString(), "dassign %aVar_0_0 0 (dread i32 %bVar_0_0)\n\n");
+  expr->Dump();
+  EXPECT_EQ(GetBufferString(), "dread i32 %aVar_0_0\n");
+  RestoreCout();
+}
+
+  // a < b ? 1 : 2
+TEST_F(AstExprTest, ConditionalOperator) {
+  std::list<UniqueFEIRStmt> stmts;
+  // create ast cond expr
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_i32);
+  ASTDeclRefExpr *astRefExpr1 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl1 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({ subType }, allocator.Adapter()));
+  astRefExpr1->SetASTDecl(astDecl1);
+  ASTDeclRefExpr *astRefExpr2 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl2 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "bVar",
+      MapleVector<MIRType*>({ subType }, allocator.Adapter()));
+  astRefExpr2->SetASTDecl(astDecl2);
+  ASTBinaryOperatorExpr *astBinaryOperatorExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  astBinaryOperatorExpr->SetLeftExpr(astRefExpr1);
+  astBinaryOperatorExpr->SetRightExpr(astRefExpr2);
+  astBinaryOperatorExpr->SetOpcode(OP_lt);
+  astBinaryOperatorExpr->SetRetType(GlobalTables::GetTypeTable().GetInt32());
+  // create true expr
+  ASTIntegerLiteral *trueAstExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  trueAstExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  trueAstExpr->SetVal(1);
+  // create false expr
+  ASTIntegerLiteral *falseAstExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  falseAstExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  falseAstExpr->SetVal(2);
+  // create ConditionalOperator expr
+  ASTConditionalOperator *conditionalOperatorExpr = ASTDeclsBuilder::ASTExprBuilder<ASTConditionalOperator>(allocator);
+  conditionalOperatorExpr->SetCondExpr(astBinaryOperatorExpr);
+  conditionalOperatorExpr->SetTrueExpr(trueAstExpr);
+  conditionalOperatorExpr->SetFalseExpr(falseAstExpr);
+  conditionalOperatorExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRExpr feExpr = conditionalOperatorExpr->Emit2FEExpr(stmts);
+  EXPECT_EQ(stmts.size(), 1);
+  RedirectCout();
+  feExpr->GenMIRNode(mirBuilder)->Dump();
+  std::string pattern = "dread i32 %levVar_7\n";
+  EXPECT_EQ(GetBufferString(), pattern);
+  RestoreCout();
+}
+
+// a < b ? 1 : a++
+TEST_F(AstExprTest, ConditionalOperator_NestedExpr) {
+  std::list<UniqueFEIRStmt> stmts;
+  // create ast cond expr
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_i32);
+  ASTDeclRefExpr *astRefExpr1 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl1 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({ subType }, allocator.Adapter()));
+  astRefExpr1->SetASTDecl(astDecl1);
+  ASTDeclRefExpr *astRefExpr2 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl2 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "bVar",
+      MapleVector<MIRType*>({ subType }, allocator.Adapter()));
+  astRefExpr2->SetASTDecl(astDecl2);
+  ASTBinaryOperatorExpr *astBinaryOperatorExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  astBinaryOperatorExpr->SetLeftExpr(astRefExpr1);
+  astBinaryOperatorExpr->SetRightExpr(astRefExpr2);
+  astBinaryOperatorExpr->SetOpcode(OP_lt);
+  astBinaryOperatorExpr->SetRetType(GlobalTables::GetTypeTable().GetInt32());
+   // create true expr
+  ASTIntegerLiteral *trueAstExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  trueAstExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  trueAstExpr->SetVal(1);
+  // create false expr
+  ASTUOPostIncExpr *falseAstExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOPostIncExpr>(allocator);
+  falseAstExpr->SetSubType(subType);
+  falseAstExpr->SetASTDecl(astDecl1);
+  falseAstExpr->SetUOExpr(astRefExpr1);
+  // create ConditionalOperator expr
+  ASTConditionalOperator *conditionalOperatorExpr = ASTDeclsBuilder::ASTExprBuilder<ASTConditionalOperator>(allocator);
+  conditionalOperatorExpr->SetCondExpr(astBinaryOperatorExpr);
+  conditionalOperatorExpr->SetTrueExpr(trueAstExpr);
+  conditionalOperatorExpr->SetFalseExpr(falseAstExpr);
+  conditionalOperatorExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRExpr feExpr = conditionalOperatorExpr->Emit2FEExpr(stmts);
+  EXPECT_EQ(stmts.size(), 1);
+  RedirectCout();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  EXPECT_EQ(mirStmts.size(), 1);
+  mirStmts.front()->GetOpCode();
+  EXPECT_EQ(mirStmts.front()->GetOpCode(), OP_if);
+  feExpr->GenMIRNode(mirBuilder)->Dump();
+  std::string pattern = std::string("dread i32 %levVar_[0-9][0-9]\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  RestoreCout();
+}
+
+// a ? 1 : a++
+TEST_F(AstExprTest, ConditionalOperator_Noncomparative) {
+  std::list<UniqueFEIRStmt> stmts;
+  // create ast cond expr
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_f64);
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({ subType }, allocator.Adapter()));
+  astRefExpr->SetASTDecl(astDecl);
+   // create true expr
+  ASTIntegerLiteral *trueAstExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  trueAstExpr->SetType(GlobalTables::GetTypeTable().GetDouble());
+  trueAstExpr->SetVal(0);
+  // create false expr
+  ASTUOPostIncExpr *falseAstExpr = ASTDeclsBuilder::ASTExprBuilder<ASTUOPostIncExpr>(allocator);
+  falseAstExpr->SetSubType(subType);
+  falseAstExpr->SetASTDecl(astDecl);
+  falseAstExpr->SetUOExpr(astRefExpr);
+  // create ConditionalOperator expr
+  ASTConditionalOperator *conditionalOperatorExpr = ASTDeclsBuilder::ASTExprBuilder<ASTConditionalOperator>(allocator);
+  conditionalOperatorExpr->SetCondExpr(astRefExpr);
+  conditionalOperatorExpr->SetTrueExpr(trueAstExpr);
+  conditionalOperatorExpr->SetFalseExpr(falseAstExpr);
+  conditionalOperatorExpr->SetType(GlobalTables::GetTypeTable().GetDouble());
+  UniqueFEIRExpr feExpr = conditionalOperatorExpr->Emit2FEExpr(stmts);
+  EXPECT_EQ(stmts.size(), 1);
+  RedirectCout();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  EXPECT_EQ(mirStmts.size(), 1);
+  mirStmts.front()->GetOpCode();
+  EXPECT_EQ(mirStmts.front()->GetOpCode(), OP_if);
+  mirStmts.front()->Dump();
+  std::string pattern =
+      std::string("if \\(ne u1 f64 \\(dread f64 %aVar_0_0, constval f64 0\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  ClearBufferString();
+  feExpr->GenMIRNode(mirBuilder)->Dump();
+  pattern = std::string("dread f64 %levVar_[0-9][0-9]\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  RestoreCout();
+}
+
+// a < b ?: 1
+TEST_F(AstExprTest, BinaryConditionalOperator) {
+  std::list<UniqueFEIRStmt> stmts;
+  // create ast cond expr
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_i32);
+  ASTDeclRefExpr *astRefExpr1 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl1 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({ subType }, allocator.Adapter()));
+  astRefExpr1->SetASTDecl(astDecl1);
+  ASTDeclRefExpr *astRefExpr2 = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl2 = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "bVar",
+      MapleVector<MIRType*>({ subType },allocator.Adapter()));
+  astRefExpr2->SetASTDecl(astDecl2);
+  ASTBinaryOperatorExpr *astBinaryOperatorExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryOperatorExpr>(allocator);
+  astBinaryOperatorExpr->SetLeftExpr(astRefExpr1);
+  astBinaryOperatorExpr->SetRightExpr(astRefExpr2);
+  astBinaryOperatorExpr->SetOpcode(OP_lt);
+  astBinaryOperatorExpr->SetRetType(GlobalTables::GetTypeTable().GetInt32());
+ // create false expr
+  ASTIntegerLiteral *falseAstExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  falseAstExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  falseAstExpr->SetVal(1);
+  // create ConditionalOperator expr
+  ASTBinaryConditionalOperator *operatorExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryConditionalOperator>(allocator);
+  operatorExpr->SetCondExpr(astBinaryOperatorExpr);
+  operatorExpr->SetFalseExpr(falseAstExpr);
+  operatorExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRExpr feExpr = operatorExpr->Emit2FEExpr(stmts);
+  EXPECT_EQ(stmts.size(), 1);
+  RedirectCout();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  EXPECT_EQ(mirStmts.size(), 1);
+  mirStmts.front()->Dump();
+  // save conditional var for true expr
+  std::string pattern =
+      "dassign %condVal_[0-9][0-9] 0 \\(lt u1 i32 \\(dread i32 %aVar_0_0, dread i32 %bVar_0_0\\)\\)\n\n";
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  ClearBufferString();
+  feExpr->GenMIRNode(mirBuilder)->Dump();
+  pattern = "select i32 \\(dread i32 %condVal_[0-9][0-9], dread i32 %condVal_[0-9][0-9], constval i32 1\\)\n";
+  EXPECT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  RestoreCout();
+}
+
+// a ?: 1
+TEST_F(AstExprTest, BinaryConditionalOperator_Noncomparative) {
+  std::list<UniqueFEIRStmt> stmts;
+  // create ast cond expr
+  MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_i32);
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "aVar",
+      MapleVector<MIRType*>({ subType }, allocator.Adapter()));
+  astRefExpr->SetASTDecl(astDecl);
+  // create false expr
+  ASTIntegerLiteral *falseAstExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  falseAstExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  falseAstExpr->SetVal(1);
+  // create ConditionalOperator expr
+  ASTBinaryConditionalOperator *operatorExpr = ASTDeclsBuilder::ASTExprBuilder<ASTBinaryConditionalOperator>(allocator);
+  operatorExpr->SetCondExpr(astRefExpr);
+  operatorExpr->SetFalseExpr(falseAstExpr);
+  operatorExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRExpr feExpr = operatorExpr->Emit2FEExpr(stmts);
+  EXPECT_EQ(stmts.size(), 0);
+  RedirectCout();
+  feExpr->GenMIRNode(mirBuilder)->Dump();
+  std::string pattern = "select i32 (\n"\
+                        "  ne u1 i32 (dread i32 %aVar_0_0, constval i32 0),\n"\
+                        "  dread i32 %aVar_0_0,\n"\
+                        "  constval i32 1)\n";
+  EXPECT_EQ(GetBufferString(), pattern);
+  RestoreCout();
+}
+
+// ASTCstyleCastExpr
+TEST_F(AstExprTest, ASTCstyleCastExpr) {
+  RedirectCout();
+  std::list<UniqueFEIRStmt> stmts;
+  PrimType srcPrimType = PTY_f32;
+  MIRType *srcType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(srcPrimType);
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  ASTDecl *astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString("", mp), "a",
+      MapleVector<MIRType*>({srcType}, allocator.Adapter()));
+  astRefExpr->SetASTDecl(astDecl);
+  ASTCastExpr *imCastExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCastExpr>(allocator);
+  imCastExpr->SetASTExpr(astRefExpr);
+  PrimType destPrimType = PTY_i32;
+  MIRType *destType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(destPrimType);
+  ASTCastExpr *cstCast = ASTDeclsBuilder::ASTExprBuilder<ASTCastExpr>(allocator);
+  cstCast->SetNeededCvt(true);
+  cstCast->SetASTExpr(imCastExpr);
+  cstCast->SetSrcType(srcType);
+  cstCast->SetDstType(destType);
+  UniqueFEIRExpr feExpr = cstCast->Emit2FEExpr(stmts);
+  BaseNode *exprConst = feExpr->GenMIRNode(mirBuilder);
+  exprConst->Dump();
+  EXPECT_EQ(GetBufferString(), "trunc i32 f32 (dread f32 %a_0_0)\n");
+  RestoreCout();
+}
+
+TEST_F(AstExprTest, ASTArraySubscriptExpr) {
+  RedirectCout();
+  std::list<UniqueFEIRStmt> stmts;
+
+  const std::string &fileName = "hello.ast";
+  const std::string &refName = "arr";
+  MIRArrayType *arrayType = static_cast<MIRArrayType*>(
+      GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetDouble(), 10));
+  ASTDecl *astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString(fileName, mp), refName,
+      MapleVector<MIRType*>({arrayType}, allocator.Adapter()));
+
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  astRefExpr->SetASTDecl(astDecl); // astDecl is var
+  astRefExpr->SetType(arrayType);
+
+  ASTCastExpr *astImplicitCastExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCastExpr>(allocator);
+  astImplicitCastExpr->SetASTExpr(astRefExpr);
+
+  // Index
+  ASTIntegerLiteral *astIntIndexExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  astIntIndexExpr->SetVal(2);
+  astIntIndexExpr->SetType(GlobalTables::GetTypeTable().GetInt32());
+
+  // Elem
+  ASTFloatingLiteral *astFloatingLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  astFloatingLiteral->SetVal(3.5);
+  astFloatingLiteral->SetKind(FloatKind::F64);
+
+  // astArraySubscriptExpr
+  ASTArraySubscriptExpr *astArraySubscriptExpr = ASTDeclsBuilder::ASTExprBuilder<ASTArraySubscriptExpr>(allocator);
+  astArraySubscriptExpr->SetBaseExpr(astImplicitCastExpr);
+  astArraySubscriptExpr->SetIdxExpr(astIntIndexExpr);
+  astArraySubscriptExpr->SetType(GlobalTables::GetTypeTable().GetPrimType(PTY_f64));
+  astArraySubscriptExpr->SetArrayType(arrayType);
+
+  ASTAssignExpr *astAssignExpr = ASTDeclsBuilder::ASTExprBuilder<ASTAssignExpr>(allocator);
+  astAssignExpr->SetLeftExpr(astArraySubscriptExpr);
+  astAssignExpr->SetRightExpr(astFloatingLiteral);
+  (void)astAssignExpr->Emit2FEExpr(stmts);
+  std::list<StmtNode*> mirList = stmts.front()->GenMIRStmts(mirBuilder);
+  mirList.front()->Dump();
+  auto dumpStr = GetBufferString();
+
+  std::string pattern = std::string("iassign \\<\\* f64\\> 0 \\(\n  array 1 ptr \\<\\* \\<\\[10\\] f64\\>\\>") +
+      std::string(" \\(addrof ptr %arr_0_0, constval i32 2\\), \n  constval f64 3.5\\)\n\n");
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(AstExprTest, InitListExpr_Array) {
+  RedirectCout();
+  std::list<UniqueFEIRStmt> stmts;
+
+  const std::string &fileName = "hello.ast";
+  const std::string &refName = "arr";
+  MIRArrayType *arrayType = static_cast<MIRArrayType*>(
+      GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetDouble(), 4));
+  ASTDecl *astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString(fileName, mp), refName,
+      MapleVector<MIRType*>({arrayType}, allocator.Adapter()));
+
+  ASTDeclRefExpr *astRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  astRefExpr->SetASTDecl(astDecl); // astDecl is var
+  astRefExpr->SetType(arrayType);
+
+  ASTCastExpr *astImplicitCastExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCastExpr>(allocator);
+  astImplicitCastExpr->SetASTExpr(astRefExpr);
+
+  // Elem 0
+  ASTFloatingLiteral *astFloatingLiteral0 = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  astFloatingLiteral0->SetVal(2.5);
+  astFloatingLiteral0->SetKind(FloatKind::F64);
+
+  // Elem 1
+  ASTFloatingLiteral *astFloatingLiteral1 = ASTDeclsBuilder::ASTExprBuilder<ASTFloatingLiteral>(allocator);
+  astFloatingLiteral1->SetVal(3.5);
+  astFloatingLiteral1->SetKind(FloatKind::F64);
+
+  // astInitListExpr
+  ASTInitListExpr *astInitListExpr = ASTDeclsBuilder::ASTExprBuilder<ASTInitListExpr>(allocator);
+  astInitListExpr->SetInitExprs(astFloatingLiteral0);
+  astInitListExpr->SetInitExprs(astFloatingLiteral1);
+  astInitListExpr->SetInitListType(arrayType);
+  astInitListExpr->SetInitListVarName("arr");
+
+  (void)astInitListExpr->Emit2FEExpr(stmts);
+  std::list<StmtNode*> mirList1 = stmts.front()->GenMIRStmts(mirBuilder);
+  mirList1.front()->Dump();
+  auto dumpStr1 = GetBufferString();
+  EXPECT_EQ(dumpStr1, "iassign <* f64> 0 (\n  array 1 ptr <* <[4] f64>> (addrof ptr %arr, constval i32 0), \n" \
+                      "  constval f64 2.5)\n\n");
+
+  stmts.pop_front();
+  std::list<StmtNode*> mirList2 = stmts.front()->GenMIRStmts(mirBuilder);
+  mirList2.front()->Dump();
+  auto dumpStr2 = GetBufferString();
+  EXPECT_EQ(dumpStr2, "iassign <* f64> 0 (\n  array 1 ptr <* <[4] f64>> (addrof ptr %arr, constval i32 1), \n" \
+                      "  constval f64 3.5)\n\n");
+
+  // mul dim array
+  uint32 arraySize[2] = {4, 10};
+  MIRArrayType *arrayMulDimType = static_cast<MIRArrayType*>(
+      GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetDouble(), 2, arraySize));
+  ASTDecl *astMulDimDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, MapleString(fileName, mp), "xxx",
+      MapleVector<MIRType*>({arrayMulDimType}, allocator.Adapter()));
+  ASTDeclRefExpr *astMulDimRefExpr = ASTDeclsBuilder::ASTExprBuilder<ASTDeclRefExpr>(allocator);
+  astMulDimRefExpr->SetASTDecl(astMulDimDecl); // astDecl is var
+  astMulDimRefExpr->SetType(arrayMulDimType);
+  ASTCastExpr *astMulDimImplicitCastExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCastExpr>(allocator);
+  astMulDimImplicitCastExpr->SetASTExpr(astMulDimRefExpr);
+  ASTInitListExpr *astMulDimInitListExpr = ASTDeclsBuilder::ASTExprBuilder<ASTInitListExpr>(allocator);
+  astMulDimInitListExpr->SetInitExprs(astInitListExpr);
+  astMulDimInitListExpr->SetInitListType(arrayMulDimType);
+  astMulDimInitListExpr->SetInitListVarName("mulDimArr");
+
+  stmts.clear();
+  (void)astMulDimInitListExpr->Emit2FEExpr(stmts);
+  ASSERT_EQ(stmts.size(), 4);
+  std::list<StmtNode*> mirMulDimList3 = stmts.front()->GenMIRStmts(mirBuilder);
+  mirMulDimList3.front()->Dump();
+  auto dumpStr3 = GetBufferString();
+  std::string pattern3 = "iassign <* f64> 0 (\n  array 1 ptr <* <[4] f64>> (\n" \
+                         "    array 1 ptr <* <[4][10] f64>> (addrof ptr %mulDimArr, constval i32 0),\n" \
+                         "    constval i32 0), \n" \
+                         "  constval f64 2.5)\n\n";
+  EXPECT_EQ(dumpStr3, pattern3);
+
+  stmts.pop_front();
+  std::list<StmtNode*> mirMulDimList4 = stmts.front()->GenMIRStmts(mirBuilder);
+  mirMulDimList4.front()->Dump();
+  auto dumpStr4 = GetBufferString();
+  std::string pattern4 = "iassign <* f64> 0 (\n  array 1 ptr <* <[4] f64>> (\n" \
+                         "    array 1 ptr <* <[4][10] f64>> (addrof ptr %mulDimArr, constval i32 0),\n" \
+                         "    constval i32 1), \n" \
+                         "  constval f64 3.5)\n\n";
+  EXPECT_EQ(dumpStr4, pattern4);
+
+  stmts.pop_front();
+  std::list<StmtNode*> mirMulDimList5 = stmts.front()->GenMIRStmts(mirBuilder);
+  mirMulDimList5.front()->Dump();
+  auto dumpStr5 = GetBufferString();
+  std::string pattern5 = "intrinsiccall C_memset (\n  add ptr (\n    array 1 ptr <* <[4][10] f64>> " \
+                         "(addrof ptr %mulDimArr, constval i32 0),\n    mul i32 (constval i32 2, constval i32 8))" \
+                         ",\n  constval i32 0,\n  mul i32 (constval i32 2, constval i32 8))\n\n";
+  EXPECT_EQ(dumpStr5, pattern5);
+
+
+  stmts.pop_front();
+  std::list<StmtNode*> mirMulDimList6 = stmts.front()->GenMIRStmts(mirBuilder);
+  mirMulDimList6.front()->Dump();
+  auto dumpStr6 = GetBufferString();
+  std::string pattern6 = "intrinsiccall C_memset (\n  add ptr (\n    addrof ptr %mulDimArr,\n    " \
+                         "mul i32 (constval i32 1, constval i32 80)),\n  constval i32 0,\n  " \
+                         "mul i32 (constval i32 3, constval i32 80))\n\n";
+  EXPECT_EQ(dumpStr6, pattern6);
+  RestoreCout();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/ast_input/clang/ast_var_test.cpp b/src/hir2mpl/test/ast_input/clang/ast_var_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1a478db53d247a6184d7ae24e590cd7193190af1
--- /dev/null
+++ b/src/hir2mpl/test/ast_input/clang/ast_var_test.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "feir_test_base.h"
+#include "feir_var.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "hir2mpl_ut_regx.h"
+#include "feir_builder.h"
+#include "ast_decl_builder.h"
+
+namespace maple {
+class FEIRVarNameTest : public FEIRTestBase {
+ public:
+  FEIRVarNameTest() = default;
+  virtual ~FEIRVarNameTest() = default;
+};
+
+TEST_F(FEIRVarNameTest, FEIRVarInAST) {
+  GenericAttrs attrs;
+  attrs.SetAttr(GENATTR_const);
+  MIRType *type = GlobalTables::GetTypeTable().GetInt32();
+  auto astVar = ASTDeclsBuilder::ASTVarBuilder(allocator, MapleString("foo.c", mp), "a",
+      MapleVector<MIRType*>({type}, allocator.Adapter()), attrs);
+  astVar->SetGlobal(false);
+  auto feirVar = astVar->Translate2FEIRVar();
+  EXPECT_EQ(feirVar->GetKind(), kFEIRVarName);
+  EXPECT_EQ(feirVar->GetType()->GetKind(), kFEIRTypeNative);
+  EXPECT_EQ(feirVar->GetType()->GenerateMIRTypeAuto(), type);
+  EXPECT_EQ(feirVar->GetName(*type).find("a") != std::string::npos, true);  // a_0_0
+  EXPECT_EQ(feirVar->GetNameRaw().find("a") != std::string::npos, true);
+  EXPECT_EQ(feirVar->GetType()->IsArray(), false);
+  MIRSymbol *symbol = feirVar->GenerateMIRSymbol(mirBuilder);
+  RedirectCout();
+  std::string symbolName = symbol->GetName();
+  EXPECT_EQ(symbolName.find("a") != std::string::npos, true);
+  EXPECT_EQ(symbol->GetAttr(ATTR_const), true);
+  symbol->Dump(false, 0);
+  std::string symbolDump = GetBufferString();
+  std::string strPattern2 = std::string("var \\$") + "a" + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(symbolDump, strPattern2), true);
+  RestoreCout();
+
+  MIRType *type1 = GlobalTables::GetTypeTable().GetInt32();
+  auto astVar1 = ASTDeclsBuilder::ASTVarBuilder(allocator, MapleString("foo.c", mp), "a",
+      MapleVector<MIRType*>({type1}, allocator.Adapter()), attrs);
+  astVar1->SetGlobal(false);
+  auto feirVar1 = astVar1->Translate2FEIRVar();
+  EXPECT_EQ(feirVar1->EqualsTo(feirVar), true);
+
+  auto feirVarClone = feirVar->Clone();
+  EXPECT_EQ(feirVarClone->EqualsTo(feirVar), true);
+
+  // array type
+  uint32 arraySize[3] = {3, 4, 5};
+  MIRType *arrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*type, 3, arraySize);
+  auto astArrVar = ASTDeclsBuilder::ASTVarBuilder(allocator, MapleString("foo.c", mp), "array",
+      MapleVector<MIRType*>({arrayType}, allocator.Adapter()), attrs);
+  astArrVar->SetGlobal(true);
+  auto feirArrVar = astArrVar->Translate2FEIRVar();
+  EXPECT_EQ(feirArrVar->GetType()->IsArray(), true);
+  MIRSymbol *symbolArr = feirArrVar->GenerateMIRSymbol(mirBuilder);
+  RedirectCout();
+  symbolName = symbolArr->GetName();
+  EXPECT_EQ(symbolName, "array");
+  symbolArr->Dump(false, 0);
+  symbolDump = GetBufferString();
+  strPattern2 = std::string("var \\$") + "array \\<\\[3\\]\\[4\\]\\[5\\] i32\\>" + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(symbolDump, strPattern2), true);
+  RestoreCout();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/bytecode_input/class/JBC0001/Test.class b/src/hir2mpl/test/bytecode_input/class/JBC0001/Test.class
new file mode 100644
index 0000000000000000000000000000000000000000..cf22eb34e438f9f941d7d250d399800556b849d5
Binary files /dev/null and b/src/hir2mpl/test/bytecode_input/class/JBC0001/Test.class differ
diff --git a/src/hir2mpl/test/bytecode_input/class/JBC0001/Test.java b/src/hir2mpl/test/bytecode_input/class/JBC0001/Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..d441a9debb157f5d81b473ab6e823419f5269b17
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/JBC0001/Test.java
@@ -0,0 +1,12 @@
+public class Test {
+    public int v1 = 0x12345678;
+    public static long v2 = 0x1234567890l;
+    public float v3 = 16.0f;
+    public static double v4 = -16.0;
+    
+    public void func1() {
+    }
+
+    public static void func2() {
+    }
+}
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_class2fe_helper_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_class2fe_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..17db7f2ce755c79a8842036ddbd93f93529355b7
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_class2fe_helper_test.cpp
@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <climits>
+#define protected public
+#define private public
+#include "jbc_class2fe_helper.h"
+#undef protected
+#undef private
+#include "redirect_buffer.h"
+#include "fe_options.h"
+
+namespace maple {
+class JBCClass2FEHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  JBCClass2FEHelperTest()
+      : allocator(mp) {}
+  ~JBCClass2FEHelperTest() = default;
+
+  static void SetUpTestCase() {
+    mp = FEUtils::NewMempool("MemPool for JBCClass2FEHelperTest", false /* isLcalPool */);
+  }
+
+  static void TearDownTestCase() {
+    delete mp;
+    mp = nullptr;
+  }
+
+ protected:
+  static MemPool *mp;
+  MapleAllocator allocator;
+};
+MemPool *JBCClass2FEHelperTest::mp = nullptr;
+
+class JBCClassField2FEHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  JBCClassField2FEHelperTest()
+      : allocator(mp) {}
+  ~JBCClassField2FEHelperTest() = default;
+
+  static void SetUpTestCase() {
+    mp = FEUtils::NewMempool("MemPool for JBCClassField2FEHelperTest", false /* isLocalPool */);
+  }
+
+  static void TearDownTestCase() {
+    delete mp;
+    mp = nullptr;
+  }
+
+ protected:
+  static MemPool *mp;
+  MapleAllocator allocator;
+};
+MemPool *JBCClassField2FEHelperTest::mp = nullptr;
+
+class MockJBCClass : public jbc::JBCClass {
+ public:
+  explicit MockJBCClass(MapleAllocator &allocator) : jbc::JBCClass(allocator) {}
+  ~MockJBCClass() = default;
+  MOCK_CONST_METHOD0(GetClassNameMpl, std::string());
+  MOCK_CONST_METHOD0(GetClassNameOrin, std::string());
+  MOCK_CONST_METHOD0(GetSuperClassName, std::string());
+  MOCK_CONST_METHOD0(GetInterfaceNames, std::vector<std::string>());
+};
+
+class MockJBCClassField : public jbc::JBCClassField {
+ public:
+  MockJBCClassField(MapleAllocator &allocator, const jbc::JBCClass &klass)
+      : jbc::JBCClassField(allocator, klass) {}
+  ~MockJBCClassField() = default;
+  MOCK_CONST_METHOD0(GetAccessFlag, uint16());
+  MOCK_CONST_METHOD0(IsStatic, bool());
+  MOCK_CONST_METHOD0(GetName, std::string());
+  MOCK_CONST_METHOD0(GetDescription, std::string());
+};
+
+class MockJBCClass2FEHelper : public JBCClass2FEHelper {
+ public:
+  MockJBCClass2FEHelper(MapleAllocator &allocator, jbc::JBCClass &klassIn)
+      : JBCClass2FEHelper(allocator, klassIn) {}
+  ~MockJBCClass2FEHelper() = default;
+  MOCK_CONST_METHOD0(IsStaticFieldProguard, bool());
+};
+
+TEST_F(JBCClass2FEHelperTest, PreProcessDecl_SameName) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("Ljava_2Flang_2FObject_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("Ljava/lang/Object;"));
+  helper.PreProcessDecl();
+  EXPECT_EQ(helper.IsSkipped(), true);
+}
+
+TEST_F(JBCClass2FEHelperTest, PreProcessDecl_NotSameName_Class) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewClass1InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewClass1InJBCClass2FEHelperTest;"));
+  helper.PreProcessDecl();
+  EXPECT_EQ(helper.IsSkipped(), false);
+}
+
+TEST_F(JBCClass2FEHelperTest, PreProcessDecl_NotSameName_Interface) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewInterface1InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewInterface1InJBCClass2FEHelperTest;"));
+  klass.header.accessFlag = jbc::kAccClassInterface;
+  helper.PreProcessDecl();
+  EXPECT_EQ(helper.IsSkipped(), false);
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDeclSuperClassForClass) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewClass2InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewClass2InJBCClass2FEHelperTest;"));
+  ON_CALL(klass, GetSuperClassName())
+      .WillByDefault(::testing::Return("Ljava/lang/Object;"));
+  helper.PreProcessDecl();
+  helper.ProcessDeclSuperClass();
+  MIRStructType *structType = helper.GetContainer();
+  EXPECT_NE(structType, nullptr);
+  EXPECT_EQ(structType->GetKind(), kTypeClass);
+  MIRClassType *classType = static_cast<MIRClassType*>(structType);
+  MIRType *superType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType->GetParentTyIdx());
+  EXPECT_EQ(superType->GetKind(), kTypeClass);
+  EXPECT_EQ(superType->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDeclImplementsForClass) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewClass3InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewClass3InJBCClass2FEHelperTest;"));
+  ON_CALL(klass, GetInterfaceNames())
+      .WillByDefault(::testing::Return(std::vector<std::string>({ "LTestInterface1;", "LTestInterface2;" })));
+  helper.PreProcessDecl();
+  helper.ProcessDeclImplements();
+  MIRStructType *structType = helper.GetContainer();
+  EXPECT_NE(structType, nullptr);
+  EXPECT_EQ(structType->GetKind(), kTypeClass);
+  MIRClassType *classType = static_cast<MIRClassType*>(structType);
+  const std::vector<TyIdx> &interfaces = classType->GetInterfaceImplemented();
+  EXPECT_EQ(interfaces.size(), 2);
+  MIRType *interfaceType0 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(interfaces[0]);
+  EXPECT_EQ(interfaceType0->GetKind(), kTypeInterfaceIncomplete);
+  EXPECT_EQ(interfaceType0->GetCompactMplTypeName(), "LTestInterface1_3B");
+  MIRType *interfaceType1 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(interfaces[1]);
+  EXPECT_EQ(interfaceType1->GetKind(), kTypeInterfaceIncomplete);
+  EXPECT_EQ(interfaceType1->GetCompactMplTypeName(), "LTestInterface2_3B");
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDeclSuperClassForInterface) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  klass.header.accessFlag = jbc::kAccClassInterface;
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewInterface2InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewInterface2InJBCClass2FEHelperTest;"));
+  ON_CALL(klass, GetSuperClassName())
+      .WillByDefault(::testing::Return("Ljava/io/Serializable;"));
+  helper.PreProcessDecl();
+  helper.ProcessDeclSuperClass();
+  MIRStructType *structType = helper.GetContainer();
+  EXPECT_NE(structType, nullptr);
+  EXPECT_EQ(structType->GetKind(), kTypeInterface);
+  MIRInterfaceType *interfaceType = static_cast<MIRInterfaceType*>(structType);
+  const std::vector<TyIdx> &parents = interfaceType->GetParentsTyIdx();
+  ASSERT_EQ(parents.size(), 1);
+  MIRType *interfaceType0 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parents[0]);
+  EXPECT_EQ(interfaceType0->GetKind(), kTypeInterface);
+  EXPECT_EQ(interfaceType0->GetCompactMplTypeName(), "Ljava_2Fio_2FSerializable_3B");
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDeclImplementsForInterface) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  klass.header.accessFlag = jbc::kAccClassInterface;
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewInterface3InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewInterface3InJBCClass2FEHelperTest;"));
+  ON_CALL(klass, GetInterfaceNames())
+      .WillByDefault(::testing::Return(std::vector<std::string>({ "LTestInterface3;", "LTestInterface4;" })));
+  helper.PreProcessDecl();
+  helper.ProcessDeclImplements();
+  MIRStructType *structType = helper.GetContainer();
+  EXPECT_NE(structType, nullptr);
+  EXPECT_EQ(structType->GetKind(), kTypeInterface);
+  MIRInterfaceType *interfaceType = static_cast<MIRInterfaceType*>(structType);
+  const std::vector<TyIdx> &parents = interfaceType->GetParentsTyIdx();
+  EXPECT_EQ(parents.size(), 2);
+  MIRType *interfaceType0 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parents[0]);
+  EXPECT_EQ(interfaceType0->GetKind(), kTypeInterfaceIncomplete);
+  EXPECT_EQ(interfaceType0->GetCompactMplTypeName(), "LTestInterface3_3B");
+  MIRType *interfaceType1 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parents[1]);
+  EXPECT_EQ(interfaceType1->GetKind(), kTypeInterfaceIncomplete);
+  EXPECT_EQ(interfaceType1->GetCompactMplTypeName(), "LTestInterface4_3B");
+}
+
+TEST_F(JBCClass2FEHelperTest, CreateSymbol_Class) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewClass4InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewClass4InJBCClass2FEHelperTest;"));
+  helper.PreProcessDecl();
+  helper.CreateSymbol();
+  EXPECT_NE(helper.mirSymbol, nullptr);
+  RedirectCout();
+  helper.mirSymbol->Dump(false, 0);
+  EXPECT_EQ(GetBufferString(),
+      "javaclass $LNewClass4InJBCClass2FEHelperTest_3B <$LNewClass4InJBCClass2FEHelperTest_3B>\n");
+  RestoreCout();
+}
+
+TEST_F(JBCClass2FEHelperTest, CreateSymbol_Interface) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewInterface4InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewInterface4InJBCClass2FEHelperTest;"));
+  klass.header.accessFlag = jbc::kAccClassInterface;
+  helper.PreProcessDecl();
+  helper.CreateSymbol();
+  EXPECT_NE(helper.mirSymbol, nullptr);
+  RedirectCout();
+  helper.mirSymbol->Dump(false, 0);
+  EXPECT_EQ(GetBufferString(),
+      "javainterface $LNewInterface4InJBCClass2FEHelperTest_3B <$LNewInterface4InJBCClass2FEHelperTest_3B>\n");
+  RestoreCout();
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDecl_Class) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  klass.header.accessFlag = jbc::kAccClassAbstract;
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewClass5InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewClass5InJBCClass2FEHelperTest;"));
+  ON_CALL(klass, GetSuperClassName())
+      .WillByDefault(::testing::Return("Ljava/lang/Object;"));
+  ON_CALL(klass, GetInterfaceNames())
+      .WillByDefault(::testing::Return(std::vector<std::string>()));
+  helper.PreProcessDecl();
+  helper.ProcessDecl();
+  EXPECT_NE(helper.mirSymbol, nullptr);
+  RedirectCout();
+  helper.mirSymbol->Dump(false, 0);
+  EXPECT_EQ(GetBufferString(),
+      "javaclass $LNewClass5InJBCClass2FEHelperTest_3B <$LNewClass5InJBCClass2FEHelperTest_3B> abstract\n");
+  RestoreCout();
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDecl_Interface) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  klass.header.accessFlag = jbc::kAccClassInterface | jbc::kAccClassPublic;
+  JBCClass2FEHelper helper(allocator, klass);
+  ON_CALL(klass, GetClassNameMpl())
+      .WillByDefault(::testing::Return("LNewInterface5InJBCClass2FEHelperTest_3B"));
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LNewInterface5InJBCClass2FEHelperTest;"));
+  ON_CALL(klass, GetSuperClassName())
+      .WillByDefault(::testing::Return("Ljava/lang/Object;"));
+  ON_CALL(klass, GetInterfaceNames())
+      .WillByDefault(::testing::Return(std::vector<std::string>()));
+  helper.PreProcessDecl();
+  helper.ProcessDecl();
+  EXPECT_NE(helper.mirSymbol, nullptr);
+  RedirectCout();
+  helper.mirSymbol->Dump(false, 0);
+  EXPECT_EQ(GetBufferString(),
+      "javainterface $LNewInterface5InJBCClass2FEHelperTest_3B <$LNewInterface5InJBCClass2FEHelperTest_3B> public\n");
+  RestoreCout();
+}
+
+TEST_F(JBCClassField2FEHelperTest, ProcessDeclWithContainer_Instance) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LTestPack/TestClass;"));
+  ::testing::NiceMock<MockJBCClassField> field(allocator, klass);
+  ON_CALL(field, GetAccessFlag()).WillByDefault(::testing::Return(jbc::kAccFieldPublic));
+  ON_CALL(field, IsStatic()).WillByDefault(::testing::Return(false));
+  ON_CALL(field, GetName()).WillByDefault(::testing::Return("field"));
+  ON_CALL(field, GetDescription()).WillByDefault(::testing::Return("Ljava/lang/Object;"));
+  JBCClassField2FEHelper fieldHelper(allocator, field);
+  ASSERT_EQ(fieldHelper.ProcessDeclWithContainer(allocator), true);
+  // check field name
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldHelper.mirFieldPair.first);
+  EXPECT_EQ(fieldName, "field");
+  // check field type
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldHelper.mirFieldPair.second.first);
+  EXPECT_EQ(type->GetKind(), kTypePointer);
+  EXPECT_EQ(type->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+  // check field attr
+  EXPECT_EQ(fieldHelper.mirFieldPair.second.second.GetAttr(FLDATTR_public), true);
+}
+
+TEST_F(JBCClassField2FEHelperTest, ProcessDeclWithContainer_Static) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LTestPack/TestClass;"));
+  ::testing::NiceMock<MockJBCClassField> field(allocator, klass);
+  ON_CALL(field, GetAccessFlag()).WillByDefault(::testing::Return(jbc::kAccFieldProtected));
+  ON_CALL(field, IsStatic()).WillByDefault(::testing::Return(true));
+  ON_CALL(field, GetName()).WillByDefault(::testing::Return("field_static"));
+  ON_CALL(field, GetDescription()).WillByDefault(::testing::Return("Ljava/lang/Object;"));
+  JBCClassField2FEHelper fieldHelper(allocator, field);
+  ASSERT_EQ(fieldHelper.ProcessDeclWithContainer(allocator), true);
+  // check field name
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldHelper.mirFieldPair.first);
+  EXPECT_EQ(fieldName, "LTestPack_2FTestClass_3B_7Cfield__static");
+  // check field type
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldHelper.mirFieldPair.second.first);
+  EXPECT_EQ(type->GetKind(), kTypePointer);
+  EXPECT_EQ(type->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+  // check field attr
+  EXPECT_EQ(fieldHelper.mirFieldPair.second.second.GetAttr(FLDATTR_protected), true);
+}
+
+TEST_F(JBCClassField2FEHelperTest, ProcessDeclWithContainer_Static_AllType) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LTestPack/TestClass;"));
+  ::testing::NiceMock<MockJBCClassField> field(allocator, klass);
+  ON_CALL(field, GetAccessFlag()).WillByDefault(::testing::Return(jbc::kAccFieldPrivate));
+  ON_CALL(field, IsStatic()).WillByDefault(::testing::Return(true));
+  ON_CALL(field, GetName()).WillByDefault(::testing::Return("field_static"));
+  ON_CALL(field, GetDescription()).WillByDefault(::testing::Return("Ljava/lang/Object;"));
+  FEOptions::GetInstance().SetModeJavaStaticFieldName(FEOptions::kAllType);
+  JBCClassField2FEHelper fieldHelper(allocator, field);
+  ASSERT_EQ(fieldHelper.ProcessDeclWithContainer(allocator), true);
+  // check field name
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldHelper.mirFieldPair.first);
+  EXPECT_EQ(fieldName, "LTestPack_2FTestClass_3B_7Cfield__static_7CLjava_2Flang_2FObject_3B");
+  // check field type
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldHelper.mirFieldPair.second.first);
+  EXPECT_EQ(type->GetKind(), kTypePointer);
+  EXPECT_EQ(type->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+  // check field attr
+  EXPECT_EQ(fieldHelper.mirFieldPair.second.second.GetAttr(FLDATTR_private), true);
+}
+
+TEST_F(JBCClassField2FEHelperTest, ProcessDeclWithContainer_Static_Smart) {
+  ::testing::NiceMock<MockJBCClass> klass(allocator);
+  ON_CALL(klass, GetClassNameOrin())
+      .WillByDefault(::testing::Return("LTestPack/TestClass;"));
+  ::testing::NiceMock<MockJBCClassField> field(allocator, klass);
+  ON_CALL(field, GetAccessFlag()).WillByDefault(::testing::Return(jbc::kAccFieldPrivate));
+  ON_CALL(field, IsStatic()).WillByDefault(::testing::Return(true));
+  ON_CALL(field, GetName()).WillByDefault(::testing::Return("field_static"));
+  ON_CALL(field, GetDescription()).WillByDefault(::testing::Return("Ljava/lang/Object;"));
+  ::testing::NiceMock<MockJBCClass2FEHelper> klassHelper(allocator, klass);
+  ON_CALL(klassHelper, IsStaticFieldProguard()).WillByDefault(::testing::Return(true));
+  FEOptions::GetInstance().SetModeJavaStaticFieldName(FEOptions::kSmart);
+  JBCClassField2FEHelper fieldHelper(allocator, field);
+  ASSERT_EQ(fieldHelper.ProcessDeclWithContainer(allocator), true);
+  // check field name
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldHelper.mirFieldPair.first);
+  EXPECT_EQ(fieldName, "LTestPack_2FTestClass_3B_7Cfield__static_7CLjava_2Flang_2FObject_3B");
+  // check field type
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldHelper.mirFieldPair.second.first);
+  EXPECT_EQ(type->GetKind(), kTypePointer);
+  EXPECT_EQ(type->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+  // check field attr
+  EXPECT_EQ(fieldHelper.mirFieldPair.second.second.GetAttr(FLDATTR_private), true);
+  FEOptions::GetInstance().SetModeJavaStaticFieldName(FEOptions::kNoType);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_class_const_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_class_const_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a71cda587c8d460c8d7f9b6f682f9b23ca83ec99
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_class_const_test.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "jbc_class_const.h"
+
+namespace maple {
+namespace jbc {
+TEST(JBCClassConst, GetTagName) {
+  EXPECT_EQ(JBCConstTagName::GetTagName(kConstUTF8), "ConstUTF8");
+}
+}  // namespace jbc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_class_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_class_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..10c3c9fd01f6a8951083f17a0699582106c6febb
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_class_test.cpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "base64.h"
+#include "jbc_class.h"
+#include "fe_utils.h"
+
+namespace maple {
+namespace jbc {
+class JBCClassTest : public testing::Test {
+ public:
+  JBCClassTest()
+      : allocator(mp),
+        fileJBC0001(nullptr),
+        ioJBC0001(nullptr) {
+    LoadFileJBC0001();
+  }
+
+  ~JBCClassTest() = default;
+
+  void LoadFileJBC0001() {
+    std::string base64Str =
+        "yv66vgAAADQAKQoADQAiAxI0VngJAAwAIwRBgAAACQAMACQFAAAAEjRWeJAJ"
+        "AAwAJQbAMAAAAAAAAAkADAAmBwAnBwAoAQACdjEBAAFJAQACdjIBAAFKAQAC"
+        "djMBAAFGAQACdjQBAAFEAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVO"
+        "dW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAAZMVGVz"
+        "dDsBAAVmdW5jMQEABWZ1bmMyAQAIPGNsaW5pdD4BAApTb3VyY2VGaWxlAQAJ"
+        "VGVzdC5qYXZhDAAWABcMAA4ADwwAEgATDAAQABEMABQAFQEABFRlc3QBABBq"
+        "YXZhL2xhbmcvT2JqZWN0ACEADAANAAAABAABAA4ADwAAAAkAEAARAAAAAQAS"
+        "ABMAAAAJABQAFQAAAAQAAQAWABcAAQAYAAAAQwACAAEAAAARKrcAASoSArUA"
+        "AyoSBLUABbEAAAACABkAAAAOAAMAAAABAAQAAgAKAAQAGgAAAAwAAQAAABEA"
+        "GwAcAAAAAQAdABcAAQAYAAAAKwAAAAEAAAABsQAAAAIAGQAAAAYAAQAAAAgA"
+        "GgAAAAwAAQAAAAEAGwAcAAAACQAeABcAAQAYAAAAGQAAAAAAAAABsQAAAAEA"
+        "GQAAAAYAAQAAAAsACAAfABcAAQAYAAAAKQACAAAAAAANFAAGswAIFAAJswAL"
+        "sQAAAAEAGQAAAAoAAgAAAAMABgAFAAEAIAAAAAIAIQ==";
+    size_t length = 0;
+    uint8 *ptr = Base64::Decode(base64Str, length);
+    fileJBC0001 = BasicIOMapFile::GenFileInMemory("JBC0001", ptr, length);
+    ioJBC0001 = mp->New<BasicIORead>(*fileJBC0001, true);
+  }
+
+  inline MapleAllocator &GetAllocator() {
+    return allocator;
+  }
+
+ protected:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  std::unique_ptr<BasicIOMapFile> fileJBC0001;
+  BasicIORead *ioJBC0001;
+
+  static void SetUpTestCase() {
+    mp = FEUtils::NewMempool("MemPool for JBCClassTest", false /* isLocalPool */);
+  }
+
+  static void TearDownTestCase() {
+    delete mp;
+    mp = nullptr;
+  }
+};
+MemPool *JBCClassTest::mp = nullptr;
+
+TEST_F(JBCClassTest, ParseFileJBC0001) {
+  JBCClass klass(allocator);
+  bool success = klass.ParseFile(*ioJBC0001);
+  EXPECT_EQ(success, true);
+  // ConstPoolCount test
+  uint16 constSize = klass.GetConstPoolCount();
+  EXPECT_EQ(constSize, 41);
+  // GetConstByIdx test
+  const JBCConst *const0 = klass.GetConstPool().GetConstByIdx(0);
+  EXPECT_EQ(const0, nullptr);
+  const JBCConst *const9 = klass.GetConstPool().GetConstByIdx(9);
+  EXPECT_NE(const9, nullptr);
+  const JBCConst *const42 = klass.GetConstPool().GetConstByIdx(42);
+  EXPECT_EQ(const42, nullptr);
+  // GetConstByIdxWithTag test
+  const JBCConst *const3 = klass.GetConstPool().GetConstByIdxWithTag(3, kConstFieldRef);
+  EXPECT_NE(const3, nullptr);
+  const JBCConst *const11 = klass.GetConstPool().GetConstByIdxWithTag(11, kConstUTF8);
+  EXPECT_EQ(const11, nullptr);
+  // GetConstValueByIdx test
+  const JBCConst *const4 = klass.GetConstPool().GetConstValueByIdx(4);
+  EXPECT_NE(const4, nullptr);
+  const JBCConst *const6 = klass.GetConstPool().GetConstValueByIdx(6);
+  EXPECT_NE(const6, nullptr);
+  const JBCConst *const8 = klass.GetConstPool().GetConstValueByIdx(8);
+  EXPECT_EQ(const8, nullptr);
+  // GetConstValue4ByteByIdx test
+  const4 = klass.GetConstPool().GetConstValue4ByteByIdx(4);
+  EXPECT_NE(const4, nullptr);
+  const6 = klass.GetConstPool().GetConstValue4ByteByIdx(6);
+  EXPECT_EQ(const6, nullptr);
+  // GetConstValue8ByteByIdx test
+  const4 = klass.GetConstPool().GetConstValue8ByteByIdx(4);
+  EXPECT_EQ(const4, nullptr);
+  const6 = klass.GetConstPool().GetConstValue8ByteByIdx(6);
+  EXPECT_NE(const6, nullptr);
+  // Field Count
+  EXPECT_EQ(klass.GetFieldCount(), 4);
+  // Method Count
+  EXPECT_EQ(klass.GetMethodCount(), 4);
+  // Attr Count
+  EXPECT_EQ(klass.GetAttrCount(), 1);
+}
+}  // namespace jbc
+}  // namespace maple
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_function_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_function_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d3f5ab958ee83c347276563e05a30a8b1051aa1e
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_function_test.cpp
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "jbc_function.h"
+#include "redirect_buffer.h"
+#include "hir2mpl_ut_environment.h"
+
+namespace maple {
+class JBCFunctionTest : public testing::Test, public RedirectBuffer {
+ public:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  jbc::JBCClass jbcClass;
+  jbc::JBCClassMethod jbcMethod;
+  JBCClassMethod2FEHelper jbcMethodHelper;
+  MIRFunction mirFunction;
+  JBCFunction jbcFunction;
+  JBCFunctionTest()
+      : allocator(mp),
+        jbcClass(allocator),
+        jbcMethod(allocator, jbcClass),
+        jbcMethodHelper(allocator, jbcMethod),
+        mirFunction(&HIR2MPLUTEnvironment::GetMIRModule(), StIdx(0, 0)),
+        jbcFunction(jbcMethodHelper, mirFunction, std::make_unique<FEFunctionPhaseResult>(true)) {}
+  ~JBCFunctionTest() = default;
+
+  static void SetUpTestCase() {
+    mp = FEUtils::NewMempool("MemPool for JBCFunctionTest", false /* isLcalPool */);
+  }
+
+  static void TearDownTestCase() {
+    delete mp;
+    mp = nullptr;
+  }
+};
+MemPool *JBCFunctionTest::mp = nullptr;
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case1) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case1
+   * S(0)--E(10)--C(20)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 20 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 20);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case2) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case2
+   * S(0)--E(10)--C(10)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 10 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 10);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case3) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case3
+   * S(0)--E(10)--C(5)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 5 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 5);
+  EXPECT_EQ(outMapStartEnd[5], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 1);
+  ASSERT_EQ(outMapStartCatch[5].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 5);
+  EXPECT_EQ(outMapStartCatch[5][0], 5);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case4) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case4
+   * S1/S2(0)--E1(10)--E2(20)--C1(25)--C2(30)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 25 });
+  rawInfo[std::make_pair(0, 20)] = std::vector<uint32>({ 30 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  EXPECT_EQ(outMapStartEnd[10], 20);
+  ASSERT_EQ(outMapStartCatch[0].size(), 2);
+  ASSERT_EQ(outMapStartCatch[10].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 25);
+  EXPECT_EQ(outMapStartCatch[0][1], 30);
+  EXPECT_EQ(outMapStartCatch[10][0], 30);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case5) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case5
+   * S(0)--E(10)--C_1(20)--C_2(30)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 20, 30 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 2);
+  EXPECT_EQ(outMapStartCatch[0][0], 20);
+  EXPECT_EQ(outMapStartCatch[0][1], 30);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case6) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case6
+   * S(0)--C_1(5)--E(10)--C_2(20)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 5, 20 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 5);
+  EXPECT_EQ(outMapStartEnd[5], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 2);
+  EXPECT_EQ(outMapStartCatch[0][0], 5);
+  EXPECT_EQ(outMapStartCatch[0][1], 20);
+  ASSERT_EQ(outMapStartCatch[5].size(), 2);
+  EXPECT_EQ(outMapStartCatch[5][0], 5);
+  EXPECT_EQ(outMapStartCatch[5][1], 20);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case7) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case7
+   * S1(0)-E1(10)-C1(20)-S2(30)-E2(40)-C2(50)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 20 });
+  rawInfo[std::make_pair(30, 40)] = std::vector<uint32>({ 50 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  EXPECT_EQ(outMapStartEnd[30], 40);
+  ASSERT_EQ(outMapStartCatch[0].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 20);
+  ASSERT_EQ(outMapStartCatch[30].size(), 1);
+  EXPECT_EQ(outMapStartCatch[30][0], 50);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_opcode_helper_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_opcode_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d0886f349bb85bda7e34ffea0139abf089098460
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_opcode_helper_test.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_configs.h"
+#include "base64.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "jbc_class.h"
+#include "jbc_opcode.h"
+#include "jbc_opcode_helper.h"
+#include "redirect_buffer.h"
+#include "fe_utils.h"
+
+namespace maple {
+class JBCOpcodeHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  JBCOpcodeHelperTest()
+      : allocator(mp),
+        klass(allocator),
+        method(allocator, klass),
+        helper(method) {}
+  ~JBCOpcodeHelperTest() = default;
+
+  static void SetUpTestCase() {
+    mp = FEUtils::NewMempool("MemPool for JBCOpcodeHelperTest", false /* isLcalPool */);
+  }
+
+  static void TearDownTestCase() {
+    delete mp;
+    mp = nullptr;
+  }
+
+ LLT_PRIVATE:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  jbc::JBCClass klass;
+  jbc::JBCClassMethod method;
+  JBCOpcodeHelper helper;
+};  // class JBCOpcodeHelperTest
+MemPool *JBCOpcodeHelperTest::mp = nullptr;
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPDefault) {
+  jbc::JBCOpGoto *op = mp->New<jbc::JBCOpGoto>(allocator, jbc::kOpGoto, jbc::kOpKindGoto, false);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPConst_Class) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "Ljava/lang/Object;");
+  jbc::JBCOpConst *op = mp->New<jbc::JBCOpConst>(allocator, jbc::kOpLdc, jbc::kOpKindConst, false);
+  op->SetIndex(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Object;");
+  op->SetIndex(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPFieldOpr) {
+  uint16 idxConstRef;
+  (void)klass.constPool.NewConstRef(idxConstRef, jbc::kConstFieldRef, "LTest;", "field", "Ljava/lang/String;");
+  jbc::JBCOpFieldOpr *op = mp->New<jbc::JBCOpFieldOpr>(allocator, jbc::kOpGetField, jbc::kOpKindFieldOpr, false);
+  op->SetFieldIdx(idxConstRef);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/String;");
+  op->SetFieldIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPInvoke) {
+  uint16 idxConstRef;
+  (void)klass.constPool.NewConstRef(idxConstRef, jbc::kConstMethodRef, "LTest;", "method",
+                                         "(Ljava/lang/String;IJ)Ljava/lang/Object;");
+  jbc::JBCOpInvoke *op = mp->New<jbc::JBCOpInvoke>(allocator, jbc::kOpInvokeVirtual, jbc::kOpKindInvoke, false);
+  op->SetMethodIdx(idxConstRef);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 4);
+  EXPECT_EQ(ans[0], "Ljava/lang/Object;");
+  EXPECT_EQ(ans[1], "Ljava/lang/String;");
+  EXPECT_EQ(ans[2], "I");
+  EXPECT_EQ(ans[3], "J");
+  op->SetMethodIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPNew) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "Ljava/lang/Integer;");
+  jbc::JBCOpNew *op = mp->New<jbc::JBCOpNew>(allocator, jbc::kOpNew, jbc::kOpKindNew, false);
+  op->SetRefTypeIdx(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Integer;");
+  op->SetRefTypeIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPNew_Array) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "[Ljava/lang/Float;");
+  jbc::JBCOpNew *op = mp->New<jbc::JBCOpNew>(allocator, jbc::kOpANewArray, jbc::kOpKindNew, false);
+  op->SetRefTypeIdx(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Float;");
+  op->SetRefTypeIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPMultiANewArray) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "[Ljava/lang/Double;");
+  jbc::JBCOpMultiANewArray *op = mp->New<jbc::JBCOpMultiANewArray>(allocator, jbc::kOpMultiANewArray,
+                                                                   jbc::kOpKindMultiANewArray, false);
+  op->SetRefTypeIdx(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Double;");
+  op->SetRefTypeIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPTypeCheck) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "Ljava/lang/Object;");
+  jbc::JBCOpTypeCheck *op = mp->New<jbc::JBCOpTypeCheck>(allocator, jbc::kOpCheckCast,
+                                                         jbc::kOpKindTypeCheck, false);
+  op->SetTypeIdx(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Object;");
+  op->SetTypeIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_stack2fe_helper_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_stack2fe_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..029eeaba81ab295c223b0e263a860216ace9646c
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_stack2fe_helper_test.cpp
@@ -0,0 +1,615 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "jbc_stack_helper.h"
+#include "jbc_stack2fe_helper.h"
+#include "feir_test_base.h"
+#include "hir2mpl_ut_regx.h"
+
+namespace maple {
+class JBCStack2FEHelperTest : public FEIRTestBase {
+ public:
+  JBCStackHelper stackHelper;
+  JBCStack2FEHelper helper;
+  JBCStack2FEHelperTest() = default;
+  ~JBCStack2FEHelperTest() = default;
+};  // class JBCStack2FEHelperTest
+
+TEST_F(JBCStack2FEHelperTest, GetRegNumForSlot) {
+  helper.SetNStacks(8);
+  helper.SetNSwaps(2);
+  helper.SetNLocals(4);
+  helper.SetNArgs(4);
+  // 0~7: stack
+  // 8~9: swap
+  // 10~13: local
+  // 14~17: arg
+  EXPECT_EQ(helper.GetRegNumForSlot(0), 14);
+  EXPECT_EQ(helper.GetRegNumForSlot(2), 16);
+  EXPECT_EQ(helper.GetRegNumForSlot(4), 10);
+  EXPECT_EQ(helper.GetRegNumForSlot(6), 12);
+}
+
+TEST_F(JBCStack2FEHelperTest, PushItem_PopItem) {
+  helper.SetNStacks(3);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "IJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWD");
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_f32), false);
+  UniqueFEIRVar var = helper.PopItem(PTY_i32);
+  EXPECT_EQ(var, nullptr);
+  var = helper.PopItem(PTY_i64);
+  EXPECT_EQ(var->GetNameRaw(), "Reg1");
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "I");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "N");
+  var = helper.PopItem(PTY_i64);
+  EXPECT_EQ(var, nullptr);
+  var = helper.PopItem(PTY_i32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg0");
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "");
+  var = helper.PopItem(PTY_i32);
+  EXPECT_EQ(var, nullptr);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  var = helper.PopItem(PTY_f32);
+  EXPECT_EQ(var, nullptr);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  var = helper.PopItem(PTY_f64);
+  EXPECT_EQ(var, nullptr);
+}
+
+TEST_F(JBCStack2FEHelperTest, GetRegNumForStack) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.GetRegNumForStack(), 0);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i64), true);
+  EXPECT_EQ(helper.GetRegNumForStack(), 2);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.GetRegNumForStack(), 0);
+}
+
+TEST_F(JBCStack2FEHelperTest, Swap) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "IF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NN");
+  EXPECT_EQ(helper.Swap(), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "FI");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NN");
+  UniqueFEIRVar var = helper.PopItem(PTY_i32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg0");
+  var = helper.PopItem(PTY_f32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg1");
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "");
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "JJDD");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "WDWD");
+  EXPECT_EQ(helper.Swap(), false);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.Swap(), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, Pop) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_f32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_ref), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "IFR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNN");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "IF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NN");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop), false);
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), false);
+  EXPECT_EQ(helper.Pop(jbc::kOpDup), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, Pop2) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "JJDD");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "WDWD");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop), false);
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "JJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "WD");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), false);
+  EXPECT_EQ(helper.Pop(jbc::kOpDup), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup_Correct) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "I");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "N");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "II");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg0");
+  UniqueFEIRVar var2 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg0");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup_Error_Empty) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.Dup(jbc::kOpDup), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup_Error_WrongType) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "JJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "WD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX1_Correct) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, ->
+  // after:  Reg0_ref, Reg2_f32, Reg1_i32, Reg2_f32, ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX1), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RFIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNN");
+  PrimType pty;
+  UniqueFEIRVar var = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var2 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg2");
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX1_Error_NotEnough) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: ->
+  // after:  Error
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX1), false);
+  // before: ->
+  // after:  Error
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX1), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX1_Error_WrongType) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64, ->
+  // after:  Error
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX1), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX2_Correct_S1) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_ref, Reg2_i32, Reg3_f32, ->
+  // after:  Reg0_ref, Reg3_f32, Reg1_ref, Reg2_i32, Reg3_f32, ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RRIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RFRIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNN");
+  PrimType pty;
+  UniqueFEIRVar var = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var3 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var4 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX2_Correct_S2) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64, Reg3_i32, ->
+  // after:  Reg0_ref, Reg3_i32, Reg1_i64, Reg3_i32, ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_i32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJI");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIJJI");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNWDN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItem(true, pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2_Correct_S1) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, ->
+  // after:  Reg0_ref, Reg1_i32, Reg2_f32, Reg1_i32, Reg2_f32, ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var2 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var4 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg1");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2_Correct_S2) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64 ->
+  // after:  Reg0_ref, Reg1_i64, Reg1_i64 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDWD");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItem(true, pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var2 = helper.PopItem(true, pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X1_Correct_S1) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, Reg3_ref ->
+  // after:  Reg0_ref, Reg2_f32, Reg3_ref, Reg1_i32, Reg2_f32, Reg3_ref ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_ref), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X1), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RFRIFR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNNN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var4 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var5 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var5->GetNameRaw(), "Reg2");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X1_Correct_S2) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_i64 ->
+  // after:  Reg0_ref, Reg2_i64, Reg1_i32, Reg2_i64 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNWD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X1), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJIJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDNWD");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg2");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X2_Correct_S1) {
+  helper.SetNStacks(8);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, Reg3_i32, Reg4_ref ->
+  // after:  Reg0_ref, Reg3_i32, Reg4_ref, Reg1_i32, Reg2_f32, Reg3_i32, Reg4_ref ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(4), PTY_ref), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFIR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIRIFIR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNNNN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg4");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var4 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var5 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var5->GetNameRaw(), "Reg4");
+  UniqueFEIRVar var6 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var6->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X2_Correct_S2) {
+  helper.SetNStacks(8);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, Reg3_i64 ->
+  // after:  Reg0_ref, Reg3_i64, Reg1_i32, Reg2_f32, Reg3_i64 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNWD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJIFJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDNNWD");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var4 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X2_Correct_S3) {
+  helper.SetNStacks(8);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64, Reg3_i32, Reg4_f32 ->
+  // after:  Reg0_ref, Reg3_i32, Reg4_f32, Reg1_i64, Reg3_i32, Reg4_f32 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(4), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFJJIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNWDNN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg4");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var4 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg4");
+  UniqueFEIRVar var5 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var5->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X2_Correct_S4) {
+  helper.SetNStacks(8);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64, Reg3_f64 ->
+  // after:  Reg0_ref, Reg3_f64, Reg1_i64, Reg3_f64 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_f64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJDD");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDWD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RDDJJDD");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDWDWD");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f64);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, GenerateSwapStmts_Test1) {
+  helper.SetNStacks(5);
+  helper.SetNSwaps(5);
+  helper.ClearStack();
+  // stack: Reg0_i32, Ref1_i64, Reg3_f64
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0, PTY_i32), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1, PTY_i64), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3, PTY_f64), PTY_f64), true);
+  std::list<UniqueFEIRStmt> stmts = helper.GenerateSwapStmts();
+  ASSERT_EQ(stmts.size(), 3);
+  std::list<UniqueFEIRStmt>::iterator it = stmts.begin();
+  std::list<StmtNode*> mirStmts0 = it->get()->GenMIRStmts(mirBuilder);
+  it++;
+  std::list<StmtNode*> mirStmts1 = it->get()->GenMIRStmts(mirBuilder);
+  it++;
+  std::list<StmtNode*> mirStmts2 = it->get()->GenMIRStmts(mirBuilder);
+
+  RedirectCout();
+  // stmt 0: dassign %Reg5_f64 0 (dread f64 %Reg3_f64)
+  ASSERT_EQ(mirStmts0.size(), 1);
+  mirStmts0.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg5_D 0 \\(dread f64 %Reg3_D\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+
+  // stmt 1: dassign %Reg7_i64 0 (dread i64 %Reg1_i64)
+  ClearBufferString();
+  ASSERT_EQ(mirStmts1.size(), 1);
+  mirStmts1.front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg7_J 0 \\(dread i64 %Reg1_J\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+
+  // stmt 2: dassign %Reg9_i32 0 (dread i32 %Reg0_i32)
+  ClearBufferString();
+  ASSERT_EQ(mirStmts2.size(), 1);
+  mirStmts2.front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg9_I 0 \\(dread i32 %Reg0_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(JBCStack2FEHelperTest, LoadSwapStack_Test1) {
+  stackHelper.Reset();
+  helper.SetNStacks(5);
+  helper.SetNSwaps(5);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeDouble);
+  bool success;
+  std::list<UniqueFEIRStmt> stmts = helper.LoadSwapStack(stackHelper, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(stmts.size(), 3);
+  std::list<UniqueFEIRStmt>::iterator it = stmts.begin();
+  std::list<StmtNode*> mirStmts0 = it->get()->GenMIRStmts(mirBuilder);
+  it++;
+  std::list<StmtNode*> mirStmts1 = it->get()->GenMIRStmts(mirBuilder);
+  it++;
+  std::list<StmtNode*> mirStmts2 = it->get()->GenMIRStmts(mirBuilder);
+
+  // swap detail
+  // swap stack: Reg9_i32, Reg7_i64, Reg5_f64
+  // jbc stack:  Reg0_i32, Reg1_i64, Reg3_f64
+
+  // stack check
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg0");
+
+  // stmts check
+  RedirectCout();
+  // stmt 0: dassign %Reg0_i32 0 (dread i32 %Reg9_i32)
+  ASSERT_EQ(mirStmts0.size(), 1);
+  mirStmts0.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_I 0 \\(dread i32 %Reg9_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+
+  // stmt 1: dassign %Reg1_i64 0 (dread i64 %Reg7_i64)
+  ClearBufferString();
+  ASSERT_EQ(mirStmts1.size(), 1);
+  mirStmts1.front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg1_J 0 \\(dread i64 %Reg7_J\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+
+  // stmt 2: dassign %Reg3_f64 0 (dread f64 %Reg5_f64)
+  ClearBufferString();
+  ASSERT_EQ(mirStmts2.size(), 1);
+  mirStmts2.front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg3_D 0 \\(dread f64 %Reg5_D\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_stack_helper_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_stack_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..68296f9c655169b2cb16404e0dc08d7e57e9e04d
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_stack_helper_test.cpp
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "jbc_stack_helper.h"
+
+namespace maple {
+TEST(JBCStackHelper, PushItem_PopItem) {
+  JBCStackHelper stackHelper;
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeInt), true);
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeFloat), false);
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeInt), false);
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeLong), true);
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeDouble);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeDouble), true);
+  stackHelper.Reset();
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeDouble), false);
+}
+
+TEST(JBCStackHelper, Dup) {
+  JBCStackHelper stackHelper;
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup), true);
+  std::vector<jbc::JBCPrimType> types({ jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeInt });
+  EXPECT_EQ(stackHelper.PopItems(types), true);
+
+  stackHelper.Reset();
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup), false);
+}
+
+TEST(JBCStackHelper, DupX1) {
+  JBCStackHelper stackHelper;
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeFloat);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), true);
+  std::vector<jbc::JBCPrimType> types({ jbc::JBCPrimType::kTypeFloat, jbc::JBCPrimType::kTypeInt,
+                                        jbc::JBCPrimType::kTypeFloat });
+  EXPECT_EQ(stackHelper.PopItems(types), true);
+
+  stackHelper.Reset();
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+}
+
+TEST(JBCStackHelper, DupX2) {
+  JBCStackHelper stackHelper;
+  // mode 1: ..., typeI, typeI, typeI ->
+  // input: ..., I, S, B ->
+  // output: ..., B, I, S, B ->
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeByteOrBoolean);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX2), true);
+  std::vector<jbc::JBCPrimType> types1({ jbc::JBCPrimType::kTypeByteOrBoolean, jbc::JBCPrimType::kTypeInt,
+                                         jbc::JBCPrimType::kTypeShort, jbc::JBCPrimType::kTypeByteOrBoolean });
+  EXPECT_EQ(stackHelper.PopItems(types1), true);
+
+  // mode2: ..., typeII, typeI ->
+  // input: ..., J, I ->
+  // output: ..., I, J, I ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX2), true);
+  std::vector<jbc::JBCPrimType> types2({ jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeLong,
+                                         jbc::JBCPrimType::kTypeInt });
+  EXPECT_EQ(stackHelper.PopItems(types2), true);
+
+  // TODO(UT): add false cases
+}
+
+TEST(JBCStackHelper, Dup2) {
+  JBCStackHelper stackHelper;
+  // mode 1: ..., typeI, typeI ->
+  // input: ..., I, S ->
+  // output: ..., I, S, I, S ->
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2), true);
+  std::vector<jbc::JBCPrimType> types1({ jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort,
+                                         jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort });
+  EXPECT_EQ(stackHelper.PopItems(types1), true);
+
+  // mode 2: ..., typeII ->
+  // input: ..., J ->
+  // output: ..., J, J ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2), true);
+  std::vector<jbc::JBCPrimType> types2({ jbc::JBCPrimType::kTypeLong, jbc::JBCPrimType::kTypeLong });
+  EXPECT_EQ(stackHelper.PopItems(types2), true);
+
+  // TODO(UT): add false cases
+}
+
+TEST(JBCStackHelper, Dup2X1) {
+  JBCStackHelper stackHelper;
+  // mode 1: ..., typeI, typeI, typeI ->
+  // input: ..., I, S, B ->
+  // output: ..., S, B, I, S, B ->
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeByteOrBoolean);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X1), true);
+  std::vector<jbc::JBCPrimType> types1({ jbc::JBCPrimType::kTypeShort, jbc::JBCPrimType::kTypeByteOrBoolean,
+                                         jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort,
+                                         jbc::JBCPrimType::kTypeByteOrBoolean });
+  EXPECT_EQ(stackHelper.PopItems(types1), true);
+
+  // mode 2: ..., typeI, typeII ->
+  // input: ..., I, J ->
+  // output: ..., J, I, J ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X1), true);
+  std::vector<jbc::JBCPrimType> types2({ jbc::JBCPrimType::kTypeLong, jbc::JBCPrimType::kTypeInt,
+                                         jbc::JBCPrimType::kTypeLong });
+  EXPECT_EQ(stackHelper.PopItems(types2), true);
+
+  // TODO(UT): add false cases
+}
+
+TEST(JBCStackHelper, Dup2X2) {
+  JBCStackHelper stackHelper;
+  // mode 1: ..., typeI, typeI, typeI, typeI ->
+  // input: ..., I, S, B, C ->
+  // output: ..., B, C, I, S, B, C ->
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeByteOrBoolean);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeChar);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X2), true);
+  std::vector<jbc::JBCPrimType> types1({ jbc::JBCPrimType::kTypeByteOrBoolean, jbc::JBCPrimType::kTypeChar,
+                                         jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort,
+                                         jbc::JBCPrimType::kTypeByteOrBoolean, jbc::JBCPrimType::kTypeChar });
+  EXPECT_EQ(stackHelper.PopItems(types1), true);
+
+  // mode 2: ..., typeI, typeI, typeII ->
+  // input: ..., I, S, J ->
+  // output: ..., J, I, S, J ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X2), true);
+  std::vector<jbc::JBCPrimType> types2({ jbc::JBCPrimType::kTypeLong, jbc::JBCPrimType::kTypeInt,
+                                         jbc::JBCPrimType::kTypeShort, jbc::JBCPrimType::kTypeLong });
+  EXPECT_EQ(stackHelper.PopItems(types2), true);
+
+  // mode 3: ..., typeII, typeI, typeI ->
+  // input: ..., J, I, S ->
+  // output: ..., I, S, J, I, S ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X2), true);
+  std::vector<jbc::JBCPrimType> types3({ jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort,
+                                         jbc::JBCPrimType::kTypeLong, jbc::JBCPrimType::kTypeInt,
+                                         jbc::JBCPrimType::kTypeShort });
+  EXPECT_EQ(stackHelper.PopItems(types3), true);
+
+  // mode 4: ..., typeII, typeII ->
+  // input: ..., J, D ->
+  // output: ..., D, J, D ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeDouble);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X2), true);
+  std::vector<jbc::JBCPrimType> types4({ jbc::JBCPrimType::kTypeDouble, jbc::JBCPrimType::kTypeLong,
+                                         jbc::JBCPrimType::kTypeDouble });
+  EXPECT_EQ(stackHelper.PopItems(types4), true);
+
+  // TODO(UT): add false cases
+}
+
+TEST(JBCStackHelper, Swap) {
+  JBCStackHelper stackHelper;
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  EXPECT_EQ(stackHelper.Swap(), true);
+  std::vector<jbc::JBCPrimType> types({ jbc::JBCPrimType::kTypeShort, jbc::JBCPrimType::kTypeInt });
+  EXPECT_EQ(stackHelper.PopItems(types), true);
+
+  // TODO(UT): add false cases
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_stmt_bb_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_stmt_bb_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3bdbbb58d00d19c21f36ae3dc96816008307bd5c
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_stmt_bb_test.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <memory>
+#include "feir_test_base.h"
+#include "feir_stmt.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "feir_bb.h"
+#include "jbc_function.h"
+#include "hir2mpl_ut_environment.h"
+
+#define protected public
+#define private public
+
+namespace maple {
+class FEIRStmtBBTest : public FEIRTestBase {
+ public:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  jbc::JBCClass jbcClass;
+  jbc::JBCClassMethod jbcMethod;
+  JBCClassMethod2FEHelper jbcMethodHelper;
+  MIRFunction mirFunction;
+  JBCFunction jbcFunction;
+  FEIRStmtBBTest()
+      : allocator(mp),
+        jbcClass(allocator),
+        jbcMethod(allocator, jbcClass),
+        jbcMethodHelper(allocator, jbcMethod),
+        mirFunction(&HIR2MPLUTEnvironment::GetMIRModule(), StIdx(0, 0)),
+        jbcFunction(jbcMethodHelper, mirFunction, std::make_unique<FEFunctionPhaseResult>(true)) {}
+  virtual ~FEIRStmtBBTest() = default;
+  static void SetUpTestCase() {
+    mp = FEUtils::NewMempool("MemPool for FEIRStmtBBTest", false /* isLcalPool */);
+  }
+
+  static void TearDownTestCase() {
+    delete mp;
+    mp = nullptr;
+  }
+};
+MemPool *FEIRStmtBBTest::mp = nullptr;
+}  // namespace maple
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_stmt_loc_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_stmt_loc_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cb3638e4ea34be591f74bf85c2d311a5a3565024
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_stmt_loc_test.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "jbc_function.h"
+#include "fe_manager.h"
+#include "redirect_buffer.h"
+#include "feir_type_helper.h"
+#include "hir2mpl_ut_regx.h"
+#include "hir2mpl_ut_environment.h"
+#include "feir_stmt.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_test_base.h"
+namespace maple {
+class FEIRStmtLOCTest : public FEIRTestBase {
+ public:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  jbc::JBCClass jbcClass;
+  jbc::JBCClassMethod jbcMethod;
+  JBCClassMethod2FEHelper jbcMethodHelper;
+  MIRFunction mirFunction;
+  JBCFunction jbcFunction;
+  FEIRStmtLOCTest()
+      : allocator(mp),
+        jbcClass(allocator),
+        jbcMethod(allocator, jbcClass),
+        jbcMethodHelper(allocator, jbcMethod),
+        mirFunction(&HIR2MPLUTEnvironment::GetMIRModule(), StIdx(0, 0)),
+        jbcFunction(jbcMethodHelper, mirFunction, std::make_unique<FEFunctionPhaseResult>(true)) {}
+  ~FEIRStmtLOCTest() = default;
+
+  static void SetUpTestCase() {
+    mp = FEUtils::NewMempool("MemPool for FEIRStmtLOCTest", false /* isLcalPool */);
+  }
+
+  static void TearDownTestCase() {
+    delete mp;
+    mp = nullptr;
+  }
+};
+MemPool *FEIRStmtLOCTest::mp = nullptr;
+
+// ---------- FEIRStmtDAssign ----------
+TEST_F(FEIRStmtLOCTest, GetLOCForStmt) {
+  std::unique_ptr<FEIRType> type = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  std::unique_ptr<FEIRVarReg> dstVar = std::make_unique<FEIRVarReg>(0, type->Clone());
+  std::unique_ptr<FEIRVarReg> srcVar = std::make_unique<FEIRVarReg>(1, type->Clone());
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(srcVar));
+  std::unique_ptr<FEIRStmtDAssign> stmtDAssign =
+      std::make_unique<FEIRStmtDAssign>(std::move(dstVar), std::move(exprDRead));
+
+  uint32 srcFileIdx = 2;
+  uint32 lineNumber = 10;
+  std::unique_ptr<FEIRStmtPesudoLOC> stmtPesudoLOC = std::make_unique<FEIRStmtPesudoLOC>(srcFileIdx, lineNumber);
+  jbcFunction.InitImpl();
+  jbcFunction.feirStmtTail->InsertBefore(static_cast<FEIRStmt*>(stmtPesudoLOC.get()));
+  jbcFunction.feirStmtTail->InsertBefore(static_cast<FEIRStmt*>(stmtDAssign.get()));
+  const FEIRStmtPesudoLOC *expectedLOC = jbcFunction.GetLOCForStmt(*static_cast<FEIRStmt *>(stmtDAssign.get()));
+  std::list<StmtNode*> mirStmts = stmtDAssign->GenMIRStmts(mirBuilder);
+  mirStmts.front()->GetSrcPos().SetFileNum(static_cast<uint16>(expectedLOC->GetSrcFileIdx()));
+  mirStmts.front()->GetSrcPos().SetLineNum(expectedLOC->GetSrcFileLineNum());
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("LOC 2 10\n") + std::string("dassign %Reg0_") +
+                        HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+                        " 0 \\(dread ref %Reg1_" + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) + "\\)" +
+                        HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/bytecode_input/class/jbc_util_test.cpp b/src/hir2mpl/test/bytecode_input/class/jbc_util_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bb50e91065b11f7ade15eb43d8738221a0ecd99f
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/class/jbc_util_test.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "jbc_util.h"
+#include "fe_utils_java.h"
+
+namespace maple {
+namespace jbc {
+TEST(JBCUtil, ClassInternalNameToFullName) {
+  EXPECT_EQ(JBCUtil::ClassInternalNameToFullName("java/lang/Object"), "Ljava/lang/Object;");
+  EXPECT_EQ(JBCUtil::ClassInternalNameToFullName("[Ljava/lang/Object;"), "[Ljava/lang/Object;");
+}
+
+TEST(JBCUtil, SolveMethodSignature) {
+  std::vector<std::string> ans;
+  ans = FEUtilJava::SolveMethodSignature("func(Ljava/lang/Object;[II)J");
+  ASSERT_EQ(ans.size(), 4);
+  EXPECT_EQ(ans[0], "J");
+  EXPECT_EQ(ans[1], "Ljava/lang/Object;");
+  EXPECT_EQ(ans[2], "[I");
+  EXPECT_EQ(ans[3], "I");
+}
+}  // namespace jbc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/bytecode_input/dex/bc_load_on_demand_type_test.cpp b/src/hir2mpl/test/bytecode_input/dex/bc_load_on_demand_type_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae76647ccd0c811b831158d194a80f60fdb95f6a
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/dex/bc_load_on_demand_type_test.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <cstdlib>
+#include "hir2mpl_ut_environment.h"
+#define private public
+#include "bc_compiler_component.h"
+#undef private
+#include "dexfile_factory.h"
+#include "dex_pragma.h"
+
+namespace maple {
+TEST(BCLoadOnDemandType, Test) {
+  std::string str(getenv("MAPLE_ROOT"));
+  std::string path = str + "/output/aarch64-clang-release/libjava-core/host-x86_64-O2/libcore-all.dex";
+  FEOptions::GetInstance().SetXBootClassPath(path);
+  bc::BCCompilerComponent<bc::DexReader> bcCompiler(HIR2MPLUTEnvironment::GetMIRModule());
+  std::unordered_set<std::string> allDepSet;
+  std::list<std::unique_ptr<bc::BCClass>> klassList;
+  allDepSet.insert("Ljava/lang/String;");
+  std::unordered_set<std::string> allClassSet;
+  bool success = bcCompiler.LoadOnDemandType2BCClass(allDepSet, allClassSet, klassList);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(klassList.size(), 5);
+  ASSERT_EQ(klassList.front()->GetClassName(false), "Ljava/lang/Object;");
+  for (const std::unique_ptr<bc::BCClass> &klass : klassList) {
+    // Dependent classes were loaded by mplt, rename class names to avoid MIRStruct types are created failed
+    klass->SetClassName("Temp/" + klass->GetClassName(false));
+    // Annotations are set nullptr instead of parsed failed,
+    // because above renamed classname is different from klass in local orinNameStrIdxMap.
+    DexFileFactory dexFileFactory;
+    std::unique_ptr<maple::IDexFile> iDexFile = dexFileFactory.NewInstance();
+    std::unique_ptr<bc::BCAnnotationsDirectory> annotationsDirectory = std::make_unique<bc::DexBCAnnotationsDirectory>(
+        HIR2MPLUTEnvironment::GetMIRModule(), *(HIR2MPLUTEnvironment::GetMIRModule().GetMemPool()), *iDexFile, "", nullptr);
+    klass->SetAnnotationsDirectory(std::move(annotationsDirectory));
+  }
+  std::list<std::unique_ptr<FEInputStructHelper>> structHelpers;
+  success = bcCompiler.LoadOnDemandBCClass2FEClass(klassList, structHelpers, false);
+  EXPECT_EQ(structHelpers.size(), 5);
+  ASSERT_EQ(structHelpers.front()->GetStructNameOrin(), "Temp/Ljava/lang/Object;");
+  ASSERT_EQ(structHelpers.front()->GetContainer()->IsImported(), true);
+  ASSERT_EQ(structHelpers.front()->GetMethodHelpers().front()->GetMethodName(false, false), "<init>");
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/bytecode_input/dex/bc_parser_test.cpp b/src/hir2mpl/test/bytecode_input/dex/bc_parser_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..85ae3ff78000f0a5057115e356af5fe2a4c7f063
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/dex/bc_parser_test.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include <list>
+#include "bc_parser.h"
+#include "dex_parser.h"
+#include "bc_class.h"
+#include "types_def.h"
+
+namespace maple {
+namespace bc {
+class BCParserTest : public testing::Test {
+ public:
+  BCParserTest() = default;
+  ~BCParserTest() = default;
+  template <typename T>
+  void Init(uint32 index, std::string fileName, const std::list<std::string> &classNamesIn) {
+    bcParser = std::make_unique<T>(index, fileName, classNamesIn);
+  }
+
+ protected:
+  std::unique_ptr<BCParserBase> bcParser;
+};
+
+TEST_F(BCParserTest, TestDexParser) {
+  std::string fileName = "";
+  std::list<std::string> classNames;
+  Init<DexParser>(0, fileName, classNames);
+  EXPECT_EQ(bcParser->OpenFile(), false);
+}
+
+TEST_F(BCParserTest, TestClassNameMplIdx) {
+  GStrIdx idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName("Ljava/lang/Object;"));
+  std::string fileName = "";
+  std::list<std::string> classNames;
+  Init<DexParser>(0, fileName, classNames);
+  BCClass *bcClass = new BCClass(0, *bcParser.get());
+  bcClass->SetClassName("Ljava/lang/Object;");
+  bool result = bcClass->GetClassNameMplIdx() == idx;
+  EXPECT_EQ(result, true);
+  delete bcClass;
+}
+
+// TODO
+// Add UT for ParseHeader(), Verify(), RetrieveClasses(klasses)
+}  // namespace jbc
+}  // namespace maple
diff --git a/src/hir2mpl/test/bytecode_input/dex/bc_util_test.cpp b/src/hir2mpl/test/bytecode_input/dex/bc_util_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f94d9326df008b1e41af6b6b2bb7e78c0813370c
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/dex/bc_util_test.cpp
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "bc_util.h"
+
+namespace maple {
+TEST(BCUtil, IsWideType) {
+  ASSERT_EQ(bc::BCUtil::IsWideType(bc::BCUtil::GetIntIdx()), false);
+  ASSERT_EQ(bc::BCUtil::IsWideType(bc::BCUtil::GetFloatIdx()), false);
+  ASSERT_EQ(bc::BCUtil::IsWideType(bc::BCUtil::GetLongIdx()), true);
+  ASSERT_EQ(bc::BCUtil::IsWideType(bc::BCUtil::GetDoubleIdx()), true);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/bytecode_input/dex/dex_class_test.cpp b/src/hir2mpl/test/bytecode_input/dex/dex_class_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..68a9ff8d592e9de5dafdc0dc95eec7d32ef77a71
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/dex/dex_class_test.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "global_tables.h"
+#include "dex_class.h"
+
+namespace maple {
+namespace bc {
+TEST(DexClass, TestTryCatch) {
+  std::unique_ptr<BCCatchInfo> catchInfo1 =
+      std::make_unique<DEXCatchInfo>(0x0023, BCUtil::GetJavaExceptionNameMplIdx(), false);
+  std::unique_ptr<BCCatchInfo> catchInfo2 = std::make_unique<DEXCatchInfo>(0x0021, BCUtil::GetVoidIdx(), true);
+  ASSERT_EQ(catchInfo1->GetHandlerAddr(), 0x0023);
+  std::cout << GlobalTables::GetStrTable().GetStringFromStrIdx(catchInfo1->GetExceptionNameIdx()) <<std::endl;
+  ASSERT_EQ(GlobalTables::GetStrTable().GetStringFromStrIdx(catchInfo1->GetExceptionNameIdx()),
+      "Ljava_2Flang_2FException_3B");
+  ASSERT_EQ(catchInfo1->GetIsCatchAll(), false);
+
+  std::unique_ptr<std::list<std::unique_ptr<BCCatchInfo>>> catches =
+      std::make_unique<std::list<std::unique_ptr<BCCatchInfo>>>();
+  catches->push_back(std::move(catchInfo1));
+  catches->push_back(std::move(catchInfo2));
+  std::unique_ptr<BCTryInfo> tryInfo = std::make_unique<DEXTryInfo>(0x0003, 0x0012, std::move(catches));
+  ASSERT_EQ(tryInfo->GetStartAddr(), 0x0003);
+  ASSERT_EQ(tryInfo->GetEndAddr(), 0x0012);
+  ASSERT_EQ(tryInfo->GetCatches()->size(), 2);
+}
+
+// Additional UT would be supplied later
+}  // bc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/bytecode_input/dex/dex_file_util_test.cpp b/src/hir2mpl/test/bytecode_input/dex/dex_file_util_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b61df26db4e52064c0590b99b438038cef91eef5
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/dex/dex_file_util_test.cpp
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "dex_file_util.h"
+
+namespace maple {
+TEST(DexFileUtil, Adler32) {
+  const uint8 data[11] = {'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd', '!'};
+  ASSERT_EQ(bc::DexFileUtil::Adler32(data, 11), 0x1974041E);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/bytecode_input/dex/dex_op_test.cpp b/src/hir2mpl/test/bytecode_input/dex/dex_op_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..17b35d7ee69b6c15a7a0c2de033a0fbc9a27de06
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/dex/dex_op_test.cpp
@@ -0,0 +1,1474 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "feir_test_base.h"
+#include "hir2mpl_ut_regx.h"
+#include "fe_utils_java.h"
+
+#define private public
+#include "dex_op.h"
+#undef private
+
+namespace maple {
+namespace bc {
+class DexOpTest : public FEIRTestBase {
+ public:
+  DexOpTest() = default;
+  virtual ~DexOpTest() = default;
+};
+
+TEST_F(DexOpTest, TestKindAndWide) {
+  MemPool *mp = FEUtils::NewMempool("MemPool for Test DexOp", true);
+  MapleAllocator allocator(mp);
+  auto dexOp = static_cast<DexOp*>(dexOpGeneratorMap[kDexOpMoveResultWide](allocator, 0));
+  ASSERT_EQ(dexOp->GetInstKind(), kFallThru);
+  ASSERT_EQ(dexOp->IsWide(), true);
+
+  dexOp = static_cast<DexOp*>(dexOpGeneratorMap[kDexOpPackedSwitch](allocator, 0));
+  ASSERT_EQ(dexOp->GetInstKind(), kFallThru | kSwitch);
+  ASSERT_EQ(dexOp->IsWide(), false);
+  ASSERT_EQ(dexOp->GetArrayElementTypeFromArrayType("ALava_2Flang_2FObject_3B").compare("Lava_2Flang_2FObject_3B"), 0);
+  ASSERT_EQ(dexOp->GetArrayElementTypeFromArrayType("AAI").compare("AI"), 0);
+  delete mp;
+}
+
+class DexOpConstClassUT : public bc::DexOpConstClass {
+ public:
+  DexOpConstClassUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpConstClass(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpConstClassUT() = default;
+  void SetRegTypeInUT(const std::string &name) {
+    const std::string &mplTypeName = namemangler::EncodeName(name);
+    mplTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(mplTypeName);
+    std::string refTypeName = bc::BCUtil::kJavaClassName;
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(refTypeName)));
+  }
+};
+
+class DexOpMoveExceptionUT : public bc::DexOpMoveException {
+ public:
+  DexOpMoveExceptionUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpMoveException(allocatorIn, pcIn, opcodeIn) {
+    instKind = bc::kCatch;
+  }
+  ~DexOpMoveExceptionUT() = default;
+  void SetRegTypeInUT(const std::string &name) {
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name)));
+  }
+};
+
+class DexOpMoveUT : public bc::DexOpMove {
+ public:
+  DexOpMoveUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpMove(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpMoveUT() = default;
+  void SetRegTypeInUT(const std::string &name) {
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name)));
+    vA.regTypeItem = vB.regTypeItem;
+  }
+};
+// ---------- FEIRStmtDAssign-DexOpMove ----------
+TEST_F(DexOpTest, FEIRStmtDAssignDexOpMove) {
+  std::unique_ptr<DexOpMoveUT> dexOp = std::make_unique<DexOpMoveUT>(allocator, 1, bc::kDexOpMove);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetRegTypeInUT(bc::BCUtil::kInt);
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_I") + " 0 \\(dread i32 %Reg1_I" + "\\)" +
+                        HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRStmtDAssign-DexOpMoveException ----------
+TEST_F(DexOpTest, FEIRStmtDAssignDexOpMoveException) {
+  std::unique_ptr<DexOpMoveExceptionUT> dexOp =
+      std::make_unique<DexOpMoveExceptionUT>(allocator, 1, bc::kDexOpMoveException);
+  dexOp->SetVA(0);
+  dexOp->SetRegTypeInUT("Ljava/lang/Exception;");
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 2);
+  ASSERT_EQ(feStmts.front()->GetKind(), kStmtPesudoLabel);
+  std::list<StmtNode*> mirNodes = feStmts.back()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+                        " 0 \\(regread ref %%thrownval" + "\\)" + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRStmtDAssign-DexOpConstClass ----------
+TEST_F(DexOpTest, FEIRStmtDAssignDexOpConstClass) {
+  std::unique_ptr<DexOpConstClassUT> dexOp = std::make_unique<DexOpConstClassUT>(allocator, 1, bc::kDexOpConstClass);
+  dexOp->SetVA(0);
+  dexOp->SetRegTypeInUT("Ljava/lang/String;");
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = "dassign %Reg0_" + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+                        " 0 \\(intrinsicopwithtype ref \\<\\* \\<\\$Ljava_2Flang_2FString_3B\\>\\> "
+                        "JAVA_CONST_CLASS \\(\\)\\)" + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRStmt-DexOpMonitor ----------
+class DexOpMonitorUT : public bc::DexOpMonitor {
+ public:
+  DexOpMonitorUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpMonitor(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpMonitorUT() = default;
+  void SetRegTypeInUT(const std::string &name) {
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name)));
+  }
+};
+TEST_F(DexOpTest, FEIRStmtDexOpMonitor) {
+  std::unique_ptr<DexOpMonitorUT> dexOp = std::make_unique<DexOpMonitorUT>(allocator, 1, bc::kDexOpMonitorEnter);
+  dexOp->SetVA(0);
+  dexOp->SetRegTypeInUT(bc::BCUtil::kInt);
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = "syncenter \\(dread i32 %Reg0_I, constval i32 2\\)" + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+  dexOp = std::make_unique<DexOpMonitorUT>(allocator, 1, bc::kDexOpMonitorExit);
+  dexOp->SetVA(0);
+  dexOp->SetRegTypeInUT(bc::BCUtil::kInt);
+  feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  dumpStr = GetBufferString();
+  EXPECT_EQ(dumpStr.find("syncexit (dread i32 %Reg0_I)"), 0);
+  RestoreCout();
+}
+
+// ---------- FEIRStmt-DexOpIfTest ----------
+class DexOpIfTestUT : public bc::DexOpIfTest {
+ public:
+  DexOpIfTestUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpIfTest(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpIfTestUT() = default;
+  void SetType(const std::string &name) {
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name)));
+    vB.regType = vA.regType;
+    vB.regTypeItem = vA.regTypeItem;
+  }
+
+  void SetFuncNameIdx(uint32 idx) {
+    funcNameIdx = idx;
+  }
+};
+
+TEST_F(DexOpTest, FEIRStmtDexOpIfTest) {
+  std::unique_ptr<DexOpIfTestUT> dexOp = std::make_unique<DexOpIfTestUT>(allocator, 1, bc::kDexOpIfLt);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetType("I");
+  dexOp->SetFuncNameIdx(111);
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  RestoreCout();
+  EXPECT_EQ(dumpStr.find("brtrue @L111_0 (lt u1 i32 (dread i32 %Reg0_I, dread i32 %Reg1_I))"), 0);
+}
+
+// ---------- FEIRStmt-DexOpIfTestZ ----------
+class DexOpIfTestZUT : public bc::DexOpIfTestZ {
+ public:
+  DexOpIfTestZUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpIfTestZ(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpIfTestZUT() = default;
+  void SetType(const std::string &name) {
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name)));
+  }
+  void SetFuncNameIdx(uint32 idx) {
+    funcNameIdx = idx;
+  }
+};
+
+TEST_F(DexOpTest, FEIRStmtDexOpIfTestZ) {
+  RedirectCout();
+  std::unique_ptr<DexOpIfTestZUT> dexOpI = std::make_unique<DexOpIfTestZUT>(allocator, 1, bc::kDexOpIfEqZ);
+  dexOpI->SetVA(0);
+  dexOpI->SetType("I");
+  dexOpI->SetFuncNameIdx(111);
+  std::list<UniqueFEIRStmt> feStmts = dexOpI->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("brtrue @L111_0 \\(eq u1 i32 \\(dread i32 %Reg0_I, constval i32 0\\)\\)") +
+                        HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  std::unique_ptr<DexOpIfTestZUT> dexOpZ = std::make_unique<DexOpIfTestZUT>(allocator, 1, bc::kDexOpIfEqZ);
+  dexOpZ->SetVA(0);
+  dexOpZ->SetType("Z");
+  dexOpZ->SetFuncNameIdx(222);
+  dexOpZ->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("brfalse @L222_0 \\(dread u32 %Reg0_Z\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRStmt-DexOpInvoke ----------
+class DexOpInvokeUT : public bc::DexOpInvoke {
+ public:
+  DexOpInvokeUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpInvoke(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpInvokeUT() = default;
+
+  void ParseImplUT(const bc::BCReader::ClassElem &elem) {
+    bc::BCReader::ClassElem methodInfo = elem;
+    retArgsTypeNames = FEUtilJava::SolveMethodSignature(methodInfo.typeName);
+    bc::DexReg reg;
+    MapleList<uint32> argRegNums = argRegs;
+    ReplaceStringFactory(methodInfo, argRegNums);
+    structElemNameIdx = allocator.GetMemPool()->New<StructElemNameIdx>(
+        methodInfo.className, methodInfo.elemName, methodInfo.typeName);
+
+    std::string typeName;
+    if (!IsStatic()) {
+      reg.regNum = argRegNums.front();
+      argRegNums.pop_front();
+      typeName = methodInfo.className;
+      typeName = namemangler::EncodeName(typeName);
+      reg.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, reg,
+          GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName));
+      argVRegs.emplace_back(reg);
+    }
+    for (size_t i = 1; i < retArgsTypeNames.size(); ++i) {
+      reg.regNum = argRegNums.front();
+      argRegNums.pop_front();
+      typeName = retArgsTypeNames[i];
+      typeName = namemangler::EncodeName(typeName);
+      reg.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, reg,
+          GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName));
+      argVRegs.emplace_back(reg);
+    }
+  }
+};
+
+TEST_F(DexOpTest, FEIRStmtDexOpInvoke) {
+  RedirectCout();
+  std::unique_ptr<DexOpInvokeUT> dexOp = std::make_unique<DexOpInvokeUT>(allocator, 1, bc::kDexOpInvokeVirtual);
+  dexOp->SetVA(3);
+  dexOp->SetVC(6);
+  MapleList<uint32> argVRegNums({6, 7, 8}, allocator.Adapter());
+  dexOp->SetArgs(argVRegNums);
+  bc::BCReader::ClassElem elem;
+  elem.className = "LTestClass;";
+  elem.elemName = "funcName";
+  elem.typeName = "(Ljava/lang/String;I)V";
+  dexOp->ParseImplUT(elem);
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  RestoreCout();
+  EXPECT_EQ(dumpStr.find(
+      "virtualcallassigned &LTestClass_3B_7CfuncName_7C_28Ljava_2Flang_2FString_3BI_29V (dread ref %Reg6_R"), 0);
+  EXPECT_EQ(dumpStr.find(", dread ref %Reg7_R", 99) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(", dread i32 %Reg8_I) {}", 99) != std::string::npos, true);
+}
+
+TEST_F(DexOpTest, FEIRStmtDexOpInvoke_StrFac) {
+  RedirectCout();
+  std::unique_ptr<DexOpInvokeUT> dexOp = std::make_unique<DexOpInvokeUT>(allocator, 1, bc::kDexOpInvokeDirect);
+  dexOp->SetVA(3);
+  dexOp->SetVC(6);
+  MapleList<uint32> argVRegNums({6, 7}, allocator.Adapter());
+  dexOp->SetArgs(argVRegNums);
+  bc::BCReader::ClassElem elem;
+  elem.className = "Ljava/lang/String;";
+  elem.elemName = "<init>";
+  elem.typeName = "(Ljava/lang/String;)V";
+  dexOp->ParseImplUT(elem);
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("callassigned &Ljava_2Flang_2FStringFactory_3B_7CnewStringFromString_7C_28Ljava_"
+                                    "2Flang_2FString_3B_29Ljava_2Flang_2FString_3B \\(dread ref %Reg7_") +
+                        HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+                        std::string("\\) \\{ dassign %Reg6_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+                        std::string(" 0 \\}") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRStmt-DexOpCheckCast ----------
+class DexOpCheckCastUT : public bc::DexOpCheckCast {
+ public:
+  DexOpCheckCastUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpCheckCast(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpCheckCastUT() = default;
+  void SetRegType(const std::string &name) {
+    targetTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name));
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA, targetTypeNameIdx);
+    vDef.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vDef, targetTypeNameIdx);
+  }
+};
+
+TEST_F(DexOpTest, FEIRStmtDexOpCheckCast) {
+  std::unique_ptr<DexOpCheckCastUT> dexOp = std::make_unique<DexOpCheckCastUT>(allocator, 1, bc::kDexOpCheckCast);
+  dexOp->SetVA(0);
+  dexOp->SetRegType("Ljava/lang/String;");
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  RestoreCout();
+  EXPECT_EQ(dumpStr.find(
+      "intrinsiccallwithtypeassigned <* <$Ljava_2Flang_2FString_3B>> JAVA_CHECK_CAST (dread ref %Reg0_R") !=
+      std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(") { dassign %Reg0_R", 96) != std::string::npos, true);
+}
+
+// ---------- FEIRStmt-DexOpInstanceOf ----------
+class DexOpInstanceOfUT : public bc::DexOpInstanceOf {
+ public:
+  DexOpInstanceOfUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpInstanceOf(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpInstanceOfUT() = default;
+  void SetVBType(const std::string &name) {
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name)));
+  }
+
+  void SetTargetType(const std::string &name) {
+    typeName = name;
+  }
+};
+
+TEST_F(DexOpTest, FEIRStmtDexOpInstanceOf) {
+  std::unique_ptr<DexOpInstanceOfUT> dexOp = std::make_unique<DexOpInstanceOfUT>(allocator, 1, bc::kDexOpInstanceOf);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVBType("Ljava/lang/Object;");
+  dexOp->SetTargetType("Ljava/lang/String;");
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  RestoreCout();
+  EXPECT_EQ(dumpStr.find("dassign %Reg0_Z 0 (intrinsicopwithtype u1 <* <$Ljava_2Flang_2FString_3B>> JAVA_INSTANCE_OF "
+                         "(dread ref %Reg1_R") != std::string::npos, true);
+}
+
+// ---------- FEIRStmt-DexOpArrayLength ----------
+class DexOpArrayLengthUT : public bc::DexOpArrayLength {
+ public:
+  DexOpArrayLengthUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpArrayLength(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpArrayLengthUT() = default;
+
+  void SetVBType(const std::string &name) {
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name)));
+  }
+
+  void SetFuncNameIdx(uint32 idx) {
+    funcNameIdx = idx;
+  }
+};
+
+TEST_F(DexOpTest, FEIRStmtDexOpArrayLength) {
+  std::unique_ptr<DexOpArrayLengthUT> dexOp = std::make_unique<DexOpArrayLengthUT>(allocator, 1, bc::kDexOpArrayLength);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVBType("[Ljava/lang/Object;");
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  RestoreCout();
+  EXPECT_EQ(dumpStr.find("dassign %Reg0_I 0 (intrinsicop i32 JAVA_ARRAY_LENGTH (dread ref %Reg1_R") == 0, true);
+}
+
+// ---------- FEIRStmt-DexOpArrayLengthWithCatch ----------
+TEST_F(DexOpTest, FEIRStmtDexOpArrayLengthWithCatch) {
+  std::unique_ptr<DexOpArrayLengthUT> dexOp = std::make_unique<DexOpArrayLengthUT>(allocator, 1, bc::kDexOpArrayLength);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVBType("[Ljava/lang/Object;");
+  dexOp->SetExceptionType(bc::BCUtil::GetJavaExceptionNameMplIdx());
+  dexOp->SetInstructionKind(bc::kCatch);
+  dexOp->SetFuncNameIdx(111);
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 2);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 2);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr1 = GetBufferString();
+  mirNodes.back()->Dump();
+  std::string dumpStr2 = GetBufferString();
+  RestoreCout();
+  EXPECT_EQ(dumpStr1.find("@L111_1") == 0, true);
+  EXPECT_EQ(dumpStr2.find("catch { <* <$Ljava_2Flang_2FException_3B>> }") == 0, true);
+}
+
+// ---------- FEIRStmtDAssign-DexOpNewInstance ----------
+class DexOpNewInstanceUT : public bc::DexOpNewInstance {
+ public:
+  DexOpNewInstanceUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpNewInstance(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpNewInstanceUT() = default;
+  void SetVAType(const std::string &name) {
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name)));
+  }
+};
+
+TEST_F(DexOpTest, DexOpNewInstance) {
+  std::unique_ptr<DexOpNewInstanceUT> dexOp = std::make_unique<DexOpNewInstanceUT>(allocator, 0, bc::kDexOpNewInstance);
+  dexOp->SetVA(0);
+  dexOp->SetVAType("Ljava/lang/String;");
+  dexOp->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string(
+      "intrinsiccallwithtype <\\$Ljava_2Flang_2FString_3B> JAVA_CLINIT_CHECK \\(\\)") +
+      HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  EXPECT_EQ(mirStmts.size(), 1);
+  RestoreCout();
+  mirStmts = stmts.back()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.back()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string(
+      "dassign %Reg0_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+      std::string(" 0 \\(gcmalloc ref <\\$Ljava_2Flang_2FString_3B>\\)") +
+      HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  EXPECT_EQ(mirStmts.size(), 1);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, DexOpNewInstance_Permanent) {
+  RedirectCout();
+  std::unique_ptr<DexOpNewInstanceUT> dexOp = std::make_unique<DexOpNewInstanceUT>(allocator, 0, bc::kDexOpNewInstance);
+  dexOp->SetVA(0);
+  dexOp->SetVAType("Ljava/lang/String;");
+  dexOp->SetVB(1);
+  dexOp->isRcPermanent = true;
+  dexOp->EmitToFEIRStmts().back()->GenMIRStmts(mirBuilder).back()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string(
+      "dassign %Reg0_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+      std::string(" 0 \\(gcpermalloc ref <\\$Ljava_2Flang_2FString_3B>\\)") +
+      HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRStmt-DexOpConst ----------
+class DexOpConstUT : public bc::DexOpConst {
+ public:
+  DexOpConstUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpConst(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpConstUT() = default;
+
+  void SetWideAndVReg(bool isWideIn) {
+    isWide = isWideIn;
+    SetVAImpl(0);                            // reg num
+    SetVBImpl(123);                          // const value
+    SetWideVBImpl(static_cast<uint64>(-1));  // wide const value
+  }
+};
+
+TEST_F(DexOpTest, DexOpConst) {
+  RedirectCout();
+  // const/4
+  std::unique_ptr<DexOpConstUT> dexOpConst4 = std::make_unique<DexOpConstUT>(allocator, 1, bc::kDexOpConst4);
+  dexOpConst4->SetWideAndVReg(false);
+  std::list<UniqueFEIRStmt> feStmts = dexOpConst4->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_I 0 \\(cvt i32 i8 \\(constval i8 123\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // const/16
+  std::unique_ptr<DexOpConstUT> dexOpConst16 = std::make_unique<DexOpConstUT>(allocator, 1, bc::kDexOpConst16);
+  dexOpConst16->SetWideAndVReg(false);
+  dexOpConst16->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_I 0 \\(cvt i32 i16 \\(constval i16 123\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // const
+  std::unique_ptr<DexOpConstUT> dexOpConst = std::make_unique<DexOpConstUT>(allocator, 1, bc::kDexOpConst);
+  dexOpConst->SetWideAndVReg(false);
+  dexOpConst->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_I 0 \\(constval i32 123\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // const/high16
+  std::unique_ptr<DexOpConstUT> dexOpConstHigh16 = std::make_unique<DexOpConstUT>(allocator, 1, bc::kDexOpConstHigh16);
+  dexOpConstHigh16->SetWideAndVReg(false);
+  dexOpConstHigh16->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  auto pos = dumpStr.find("dassign %Reg0_I 0 (shl i32 (");
+  EXPECT_EQ(pos, 0);
+  pos = dumpStr.find("    cvt i32 i16 (constval i16 123),", 28);
+  EXPECT_EQ(pos, 29);
+  pos = dumpStr.find("    constval i32 16))", 65);
+  EXPECT_EQ(pos, 65);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, DexOpConstWide) {
+  RedirectCout();
+  // const-wide/16
+  std::unique_ptr<DexOpConstUT> dexOpConstWide16 = std::make_unique<DexOpConstUT>(allocator, 1, bc::kDexOpConstWide16);
+  dexOpConstWide16->SetWideAndVReg(true);
+  std::list<UniqueFEIRStmt> feStmts = dexOpConstWide16->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_J 0 \\(cvt i64 i16 \\(constval i16 123\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // const-wide/32
+  std::unique_ptr<DexOpConstUT> dexOpConstWide32 = std::make_unique<DexOpConstUT>(allocator, 1, bc::kDexOpConstWide32);
+  dexOpConstWide32->SetWideAndVReg(true);
+  dexOpConstWide32->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_J 0 \\(cvt i64 i32 \\(constval i32 123\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // const-wide
+  std::unique_ptr<DexOpConstUT> dexOpConstWide = std::make_unique<DexOpConstUT>(allocator, 1, bc::kDexOpConstWide);
+  dexOpConstWide->SetWideAndVReg(true);
+  dexOpConstWide->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  pattern = std::string("dassign %Reg0_J 0 \\(constval i64 -1\\)") + HIR2MPLUTRegx::Any();
+  dumpStr = GetBufferString();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // const-wide/high16
+  std::unique_ptr<DexOpConstUT> dexOpConstWideHigh16 =
+      std::make_unique<DexOpConstUT>(allocator, 1, bc::kDexOpConstWideHigh16);
+  dexOpConstWideHigh16->SetWideAndVReg(true);
+  dexOpConstWideHigh16->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  auto pos = dumpStr.find("dassign %Reg0_J 0 (shl i64 (");
+  EXPECT_EQ(pos, 0);
+  pos = dumpStr.find("    cvt i64 i16 (constval i16 123),", 29);
+  EXPECT_EQ(pos, 29);
+  pos = dumpStr.find("    constval i32 48))", 65);
+  EXPECT_EQ(pos, 65);
+  RestoreCout();
+}
+
+// ---------- FEIRStmtDAssign-DexOpNewArray ----------
+class DexOpNewArrayUT : public bc::DexOpNewArray {
+ public:
+  DexOpNewArrayUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpNewArray(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpNewArrayUT() = default;
+  void SetVAType(const std::string &name) {
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name)));
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(bc::BCUtil::kInt));
+  }
+};
+
+TEST_F(DexOpTest, DexOpNewArrayUT) {
+  std::unique_ptr<DexOpNewArrayUT> dexOp = std::make_unique<DexOpNewArrayUT>(allocator, 1, bc::kDexOpNewArray);
+  dexOp->SetVA(0);
+  dexOp->SetVAType("[Ljava/lang/Object;");
+  dexOp->SetVB(1);
+  dexOp->SetVC(2);
+  std::list<UniqueFEIRStmt> feStmts = dexOp->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string(
+      "dassign %Reg0_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+      std::string(" 0 \\(gcmallocjarray ref <\\[\\] <\\* <\\$Ljava_2Flang_2FObject_3B>>> ") +
+      std::string("\\(dread i32 %Reg1_I\\)\\)") +
+      HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, DexOpNewArrayUT_Pernament) {
+  RedirectCout();
+  std::unique_ptr<DexOpNewArrayUT> dexOp = std::make_unique<DexOpNewArrayUT>(allocator, 1, bc::kDexOpNewArray);
+  dexOp->SetVA(0);
+  dexOp->SetVAType("[Ljava/lang/Object;");
+  dexOp->SetVB(1);
+  dexOp->SetVC(2);
+  dexOp->isRcPermanent = true;
+  dexOp->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string(
+      "dassign %Reg0_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+      std::string(" 0 \\(gcpermallocjarray ref <\\[\\] <\\* <\\$Ljava_2Flang_2FObject_3B>>> ") +
+      std::string("\\(dread i32 %Reg1_I\\)\\)") +
+      HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprBinary - binop/2addr ----------
+class DexOpBinaryOp2AddrUT : public bc::DexOpBinaryOp2Addr {
+ public:
+  DexOpBinaryOp2AddrUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpBinaryOp2Addr(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpBinaryOp2AddrUT() = default;
+  void SetVAImpl(uint32 num) {
+    vDef.regNum = num;
+    vDef.isDef = true;
+    vA.regNum = num;
+    defedRegs.emplace_back(&vDef);
+    usedRegs.emplace_back(&vA);
+    std::string typeName; // typeName of A, B are same
+    if (bc::kDexOpAddInt2Addr <= opcode && opcode <= bc::kDexOpUshrInt2Addr) {
+      typeName = bc::BCUtil::kInt;
+    } else if (bc::kDexOpAddLong2Addr <= opcode && opcode <= bc::kDexOpUshrLong2Addr) {
+      typeName = bc::BCUtil::kLong;
+    } else if (bc::kDexOpAddFloat2Addr <= opcode && opcode <= bc::kDexOpRemFloat2Addr) {
+      typeName = bc::BCUtil::kFloat;
+    } else if (bc::kDexOpAddDouble2Addr <= opcode && opcode <= bc::kDexOpRemDouble2Addr) {
+      typeName = bc::BCUtil::kDouble;
+    } else {
+      CHECK_FATAL(false, "Invalid opcode: 0x%x in DexOpBinaryOp2Addr", opcode);
+    }
+    GStrIdx usedTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+    vDef.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vDef, usedTypeNameIdx);
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA, usedTypeNameIdx);
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB, usedTypeNameIdx);
+  }
+};
+
+TEST_F(DexOpTest, DexOpBinaryOp2AddrIntAdd) {
+  std::unique_ptr<DexOpBinaryOp2AddrUT> dexOp =
+      std::make_unique<DexOpBinaryOp2AddrUT>(allocator, 0, bc::kDexOpAddInt2Addr);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_I 0 (add i32 (dread i32 %Reg0_I, dread i32 %Reg1_I))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, FEIRExprBinaryOf2AddrIntSub) {
+  std::unique_ptr<DexOpBinaryOp2AddrUT> dexOp =
+      std::make_unique<DexOpBinaryOp2AddrUT>(allocator, 0, bc::kDexOpSubInt2Addr);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_I 0 (sub i32 (dread i32 %Reg0_I, dread i32 %Reg1_I))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, FEIRExprBinaryOf2AddrIntShr) {
+  std::unique_ptr<bc::DexOpBinaryOp2Addr> dexOp =
+      std::make_unique<DexOpBinaryOp2AddrUT>(allocator, 0, bc::kDexOpShrInt2Addr);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_I 0 (ashr i32 (dread i32 %Reg0_I, dread i32 %Reg1_I))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, FEIRExprBinaryOf2AddrLongXor) {
+  std::unique_ptr<DexOpBinaryOp2AddrUT> dexOp =
+      std::make_unique<DexOpBinaryOp2AddrUT>(allocator, 0, bc::kDexOpXorLong2Addr);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_J 0 (bxor i64 (dread i64 %Reg0_J, dread i64 %Reg1_J))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, FEIRExprBinaryOf2AddrFloatSub) {
+  std::unique_ptr<DexOpBinaryOp2AddrUT> dexOp =
+      std::make_unique<DexOpBinaryOp2AddrUT>(allocator, 0, bc::kDexOpSubFloat2Addr);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, FEIRExprBinaryOf2AddrDoubleMul) {
+  std::unique_ptr<DexOpBinaryOp2AddrUT> dexOp =
+      std::make_unique<DexOpBinaryOp2AddrUT>(allocator, 0, bc::kDexOpMulDouble2Addr);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_D 0 (mul f64 (dread f64 %Reg0_D, dread f64 %Reg1_D))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, FEIRExprBinaryOf2AddrDoubleDiv) {
+  std::unique_ptr<DexOpBinaryOp2AddrUT> dexOp =
+      std::make_unique<DexOpBinaryOp2AddrUT>(allocator, 0, bc::kDexOpDivDouble2Addr);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_D 0 (div f64 (dread f64 %Reg0_D, dread f64 %Reg1_D))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, FEIRExprBinaryOf2AddrDoubleRem) {
+  std::unique_ptr<DexOpBinaryOp2AddrUT> dexOp =
+      std::make_unique<DexOpBinaryOp2AddrUT>(allocator, 0, bc::kDexOpRemDouble2Addr);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_D 0 (rem f64 (dread f64 %Reg0_D, dread f64 %Reg1_D))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprUnary - unop ----------
+class DexOpUnaryOpUT : public bc::DexOpUnaryOp {
+ public:
+  DexOpUnaryOpUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpUnaryOp(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpUnaryOpUT() = default;
+  void SetVAImpl(uint32 num) {
+    vA.regNum = num;
+    vA.isDef = true;
+    defedRegs.emplace_back(&vA);
+    auto it = GetOpcodeMapForUnary().find(opcode);
+    CHECK_FATAL(it != GetOpcodeMapForUnary().end(), "Invalid opcode: %u in DexOpUnaryOp", opcode);
+    mirOp = std::get<0>(it->second);
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA, std::get<1>(it->second));
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB, std::get<2>(it->second));
+  }
+};
+
+TEST_F(DexOpTest, DexOpunaryOp) {
+  RedirectCout();
+  // OP_cvt
+  std::unique_ptr<DexOpUnaryOpUT> dexOp1 = std::make_unique<DexOpUnaryOpUT>(allocator, 0, bc::kDexOpFloatToInt);
+  dexOp1->SetVA(0);
+  dexOp1->SetVB(1);
+  std::list<UniqueFEIRStmt> stmts = dexOp1->EmitToFEIRStmts();
+  ASSERT_EQ(stmts.size(), 1);
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_I 0 \\(cvt i32 f32 \\(dread f32 %Reg1_F\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // OP_sext
+  std::unique_ptr<DexOpUnaryOpUT> dexOp2 = std::make_unique<DexOpUnaryOpUT>(allocator, 0, bc::kDexOpIntToByte);
+  dexOp2->SetVA(0);
+  dexOp2->SetVB(1);
+  dexOp2->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_B 0 \\(sext i32 8 \\(dread i32 %Reg1_I\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // OP_zext
+  std::unique_ptr<DexOpUnaryOpUT> dexOp3 = std::make_unique<DexOpUnaryOpUT>(allocator, 0, bc::kDexOpIntToChar);
+  dexOp3->SetVA(0);
+  dexOp3->SetVB(1);
+  dexOp3->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_C 0 \\(zext u32 16 \\(dread i32 %Reg1_I\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // OP_neg
+  std::unique_ptr<DexOpUnaryOpUT> dexOp4 = std::make_unique<DexOpUnaryOpUT>(allocator, 0, bc::kDexOpNegInt);
+  dexOp4->SetVA(0);
+  dexOp4->SetVB(1);
+  dexOp4->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_I 0 \\(neg i32 \\(dread i32 %Reg1_I\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  // OP_bnot
+  std::unique_ptr<DexOpUnaryOpUT> dexOp5 = std::make_unique<DexOpUnaryOpUT>(allocator, 0, bc::kDexOpNotLong);
+  dexOp5->SetVA(0);
+  dexOp5->SetVB(1);
+  dexOp5->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_J 0 \\(bnot i64 \\(dread i64 %Reg1_J\\)\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprBinary - binop ----------
+class DexOpBinaryOpUT : public bc::DexOpBinaryOp {
+ public:
+  DexOpBinaryOpUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpBinaryOp(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpBinaryOpUT() = default;
+  void SetVBImpl(uint32 num) {
+    vB.regNum = num;
+    vB.regTypeItem = vA.regTypeItem;
+    vB.regType = vA.regType;
+    usedRegs.emplace_back(&vB);
+  }
+
+  void SetVCImpl(uint32 num) {
+    vC.regNum = num;
+    vC.regTypeItem = vA.regTypeItem;
+    vC.regType = vA.regType;
+    usedRegs.emplace_back(&vC);
+  }
+};
+
+TEST_F(DexOpTest, DexOpBinaryOpOfDoubleRem) {
+  std::unique_ptr<DexOpBinaryOpUT> dexOp = std::make_unique<DexOpBinaryOpUT>(allocator, 0, bc::kDexOpRemDouble);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVC(2);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_D 0 (rem f64 (dread f64 %Reg1_D, dread f64 %Reg2_D))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprBinary - binop/Lit ----------
+class DexOpBinaryOpLitUT : public bc::DexOpBinaryOpLit {
+ public:
+  DexOpBinaryOpLitUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpBinaryOpLit(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpBinaryOpLitUT() = default;
+  void SetVBImpl(uint32 num) {
+    vB.regNum = num;
+    std::string typeName = bc::BCUtil::kInt;
+    GStrIdx usedTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB, usedTypeNameIdx);
+    usedRegs.emplace_back(&vB);
+  }
+};
+
+TEST_F(DexOpTest, DexOpBinaryOpLiOfRemIntLit16) {
+  std::unique_ptr<DexOpBinaryOpLitUT> dexOp =
+      std::make_unique<DexOpBinaryOpLitUT>(allocator, 0, bc::kDexOpRemIntLit16);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVC(20);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_I 0 (rem i32 (\n    dread i32 %Reg1_I,\n    cvt i32 i16 (constval i16 20)))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, DexOpBinaryOpLiOfRemIntLit8) {
+  std::unique_ptr<DexOpBinaryOpLitUT> dexOp =
+      std::make_unique<DexOpBinaryOpLitUT>(allocator, 0, bc::kDexOpRemIntLit8);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVC(20);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_I 0 (rem i32 (\n    dread i32 %Reg1_I,\n    cvt i32 i8 (constval i8 20)))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, DexOpBinaryOpLiOfRsubIntLit8) {
+  std::unique_ptr<DexOpBinaryOpLitUT> dexOp =
+      std::make_unique<DexOpBinaryOpLitUT>(allocator, 0, bc::kDexOpRsubIntLit8);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVC(20);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expectedStr = "dassign %Reg0_I 0 (sub i32 (\n    cvt i32 i8 (constval i8 20),\n    dread i32 %Reg1_I))";
+  EXPECT_EQ(dumpStr.find(expectedStr) != std::string::npos, true);
+  RestoreCout();
+}
+
+class DexOpSgetUT : public bc::DexOpSget {
+ public:
+  DexOpSgetUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpSget(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpSgetUT() = default;
+  std::map<std::string, std::string> opcodeTypeMap = {
+      {bc::BCUtil::kChar, "C"},
+      {bc::BCUtil::kByte, "B"},
+      {bc::BCUtil::kShort, "S"},
+      {bc::BCUtil::kInt, "I"},
+      {bc::BCUtil::kFloat, "F"},
+      {bc::BCUtil::kLong, "J"},
+      {bc::BCUtil::kDouble, "D"},
+      {bc::BCUtil::kJavaObjectName, "Ljava/lang/Object;"},
+  };
+  std::map<std::string, std::string> opcodeMirMap = {
+      {bc::BCUtil::kChar, "u32"},
+      {bc::BCUtil::kByte, "i32"},
+      {bc::BCUtil::kShort, "i32"},
+      {bc::BCUtil::kInt, "i32"},
+      {bc::BCUtil::kFloat, "f32"},
+      {bc::BCUtil::kLong, "i64"},
+      {bc::BCUtil::kDouble, "f64"},
+      {bc::BCUtil::kDouble, "D"},
+      {bc::BCUtil::kJavaObjectName, "ref"},
+  };
+  void SetFieldInfoArg(std::string typeNameIn) {
+    bc::BCReader::ClassElem fieldInfo;
+    fieldInfo.className = "Landroid/icu/text/CurrencyMetaInfo;";
+    fieldInfo.elemName = "hasData";
+    fieldInfo.typeName = typeNameIn;
+    structElemNameIdx = allocator.GetMemPool()->New<StructElemNameIdx>(
+        fieldInfo.className, fieldInfo.elemName, fieldInfo.typeName);
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA, structElemNameIdx->type);
+  }
+};
+
+TEST_F(DexOpTest, DexOpSget) {
+  std::unique_ptr<DexOpSgetUT> dexOp = std::make_unique<DexOpSgetUT>(allocator, 0, bc::kDexOpSget);
+  dexOp->SetVA(3);
+  for (std::map<std::string, std::string>::iterator it = dexOp->opcodeTypeMap.begin();
+      it != dexOp->opcodeTypeMap.end(); ++it) {
+    auto mirOp = dexOp->opcodeMirMap.find(it->first);
+    CHECK_FATAL(mirOp != dexOp->opcodeMirMap.end(), "Invalid opcode");
+
+    dexOp->SetFieldInfoArg(it->second);
+    std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+    std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+    RedirectCout();
+    mirStmts.front()->Dump();
+    std::string dumpStr = GetBufferString();
+    std::string pattern = std::string(
+        "intrinsiccallwithtype <\\$Ljava_2Flang_2FObject_3B> JAVA_CLINIT_CHECK \\(\\)") +
+        HIR2MPLUTRegx::Any();
+    EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+    EXPECT_EQ(mirStmts.size(), 2);
+    RestoreCout();
+
+    mirStmts = stmts.back()->GenMIRStmts(mirBuilder);
+    RedirectCout();
+    mirStmts.back()->Dump();
+    dumpStr = GetBufferString();
+    if (it->first != bc::BCUtil::kJavaObjectName) {
+      pattern = std::string("dassign" + std::string(" %Reg3_") + it->second + " 0 \\(dread ") +
+          std::string(mirOp->second) + " \\$Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_3B_7ChasData" +
+          std::string("\\)") + HIR2MPLUTRegx::Any();
+    } else {
+      pattern = std::string("dassign " + std::string("%Reg3_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber)) +
+          " 0 \\(dread " + mirOp->second + std::string(" \\$Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_3B_7ChasData\\)") +
+          HIR2MPLUTRegx::Any();
+    }
+    EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+    EXPECT_EQ(mirStmts.size(), 2);
+    RestoreCout();
+  }
+}
+
+class DexOpSputUT : public bc::DexOpSput {
+ public:
+  DexOpSputUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpSput(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpSputUT() = default;
+  std::map<std::string, std::string> opcodeTypeMap = {
+      {bc::BCUtil::kChar, "C"},
+      {bc::BCUtil::kByte, "B"},
+      {bc::BCUtil::kShort, "S"},
+      {bc::BCUtil::kInt, "I"},
+      {bc::BCUtil::kFloat, "F"},
+      {bc::BCUtil::kLong, "J"},
+      {bc::BCUtil::kDouble, "D"},
+      {bc::BCUtil::kJavaObjectName, "Ljava/lang/Object;"},
+  };
+
+  std::map<std::string, std::string> opcodeMirMap = {
+      {bc::BCUtil::kChar, "u32"},
+      {bc::BCUtil::kByte, "i32"},
+      {bc::BCUtil::kShort, "i32"},
+      {bc::BCUtil::kInt, "i32"},
+      {bc::BCUtil::kFloat, "f32"},
+      {bc::BCUtil::kLong, "i64"},
+      {bc::BCUtil::kDouble, "f64"},
+      {bc::BCUtil::kDouble, "D"},
+      {bc::BCUtil::kJavaObjectName, "ref"},
+  };
+
+  void SetFieldInfoArg(std::string typeNameIn) {
+    bc::BCReader::ClassElem fieldInfo;
+    fieldInfo.className = "Landroid/icu/text/CurrencyMetaInfo;";
+    fieldInfo.elemName = "hasData";
+    fieldInfo.typeName = typeNameIn;
+    structElemNameIdx = allocator.GetMemPool()->New<StructElemNameIdx>(
+        fieldInfo.className, fieldInfo.elemName, fieldInfo.typeName);
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA, structElemNameIdx->type);
+  }
+};
+
+TEST_F(DexOpTest, DexOpSput) {
+  std::unique_ptr<DexOpSputUT> dexOp = std::make_unique<DexOpSputUT>(allocator, 0, bc::kDexOpSput);
+  dexOp->SetVA(3);
+  for (std::map<std::string, std::string>::iterator it = dexOp->opcodeTypeMap.begin();
+      it != dexOp->opcodeTypeMap.end(); ++it) {
+    auto mirOp = dexOp->opcodeMirMap.find(it->first);
+    CHECK_FATAL(mirOp != dexOp->opcodeMirMap.end(), "Invalid opcode");
+
+    dexOp->SetFieldInfoArg(it->second);
+    std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+    std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+    RedirectCout();
+    mirStmts.front()->Dump();
+    std::string dumpStr = GetBufferString();
+    std::string pattern = std::string(
+        "intrinsiccallwithtype <\\$Ljava_2Flang_2FObject_3B> JAVA_CLINIT_CHECK \\(\\)") +
+        HIR2MPLUTRegx::Any();
+    EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+    EXPECT_EQ(mirStmts.size(), 2);
+    RestoreCout();
+
+    mirStmts = stmts.back()->GenMIRStmts(mirBuilder);
+    RedirectCout();
+    mirStmts.back()->Dump();
+    dumpStr = GetBufferString();
+    if (it->first != bc::BCUtil::kJavaObjectName) {
+      pattern = std::string(
+          "dassign \\$Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_3B_7ChasData 0 \\(dread ") +
+          std::string(mirOp->second) + std::string(" %Reg3_") + it->second + std::string("\\)") + HIR2MPLUTRegx::Any();
+    } else {
+      pattern = std::string(
+          "dassign \\$Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_3B_7ChasData 0 \\(dread ") + std::string(mirOp->second) +
+          std::string(" %Reg3_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+          std::string("\\)") + HIR2MPLUTRegx::Any();
+    }
+    EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+    EXPECT_EQ(mirStmts.size(), 2);
+    RestoreCout();
+  }
+}
+
+class DexOpCompareUT : public bc::DexOpCompare {
+ public:
+  DexOpCompareUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpCompare(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpCompareUT() = default;
+  void SetRegNum() {
+    int mockReg0 = 0;
+    int mockReg1 = 1;
+    int mockReg2 = 2;
+    SetVA(mockReg0);
+    SetVB(mockReg1);
+    SetVC(mockReg2);
+  }
+
+  void SetVBImpl(uint32 num) {
+    vB.regNum = num;
+    std::string typeName;
+    if (opcode == bc::kDexOpCmplFloat || opcode == bc::kDexOpCmpgFloat) {
+      typeName = bc::BCUtil::kFloat;
+    } else if (opcode == bc::kDexOpCmplDouble || opcode == bc::kDexOpCmpgDouble) {
+      typeName = bc::BCUtil::kDouble;
+    } else {
+      // kDexOpCmpLong
+      typeName = bc::BCUtil::kLong;
+    }
+    GStrIdx usedTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB, usedTypeNameIdx);
+    usedRegs.emplace_back(&vB);
+  }
+
+  void SetVCImpl(uint32 num) {
+    vC = vB;
+    vC.regNum = num;
+    vC.regType = vB.regType;
+    usedRegs.emplace_back(&vC);
+  }
+};
+
+TEST_F(DexOpTest, FEIRStmtDexOpCmp) {
+  RedirectCout();
+  std::unique_ptr<DexOpCompareUT> dexOpCmpLong = std::make_unique<DexOpCompareUT>(allocator, 1, bc::kDexOpCmpLong);
+  dexOpCmpLong->SetRegNum();
+  std::list<UniqueFEIRStmt> feStmts = dexOpCmpLong->EmitToFEIRStmts();
+  ASSERT_EQ(feStmts.size(), 1);
+  std::list<StmtNode*> mirNodes = feStmts.front()->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_I 0 \\(cmp i32 i64 \\(dread i64 %Reg1_J, dread i64 %Reg2_J\\)\\)") +
+                        HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+
+  std::unique_ptr<DexOpCompareUT> dexOpCmplFloat = std::make_unique<DexOpCompareUT>(allocator, 1, bc::kDexOpCmplFloat);
+  dexOpCmplFloat->SetRegNum();
+  dexOpCmplFloat->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_I 0 \\(cmpl i32 f32 \\(dread f32 %Reg1_F, dread f32 %Reg2_F\\)\\)") +
+            HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+
+  std::unique_ptr<DexOpCompareUT> dexOpCmpgFloat = std::make_unique<DexOpCompareUT>(allocator, 1, bc::kDexOpCmpgFloat);
+  dexOpCmpgFloat->SetRegNum();
+  dexOpCmpgFloat->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_I 0 \\(cmpg i32 f32 \\(dread f32 %Reg1_F, dread f32 %Reg2_F\\)\\)") +
+            HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+
+  std::unique_ptr<DexOpCompareUT> dexOpCmplDouble =
+      std::make_unique<DexOpCompareUT>(allocator, 1, bc::kDexOpCmplDouble);
+  dexOpCmplDouble->SetRegNum();
+  dexOpCmplDouble->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_I 0 \\(cmpl i32 f64 \\(dread f64 %Reg1_D, dread f64 %Reg2_D\\)\\)") +
+            HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+
+  std::unique_ptr<DexOpCompareUT> dexOpCmpgDouble =
+      std::make_unique<DexOpCompareUT>(allocator, 1, bc::kDexOpCmpgDouble);
+  dexOpCmpgDouble->SetRegNum();
+  dexOpCmpgDouble->EmitToFEIRStmts().front()->GenMIRStmts(mirBuilder).front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg0_I 0 \\(cmpg i32 f64 \\(dread f64 %Reg1_D, dread f64 %Reg2_D\\)\\)") +
+            HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+class DexOpThrowUT : public bc::DexOpThrow {
+ public:
+  DexOpThrowUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpThrow(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpThrowUT() = default;
+
+  void SetVA(uint32 num) {
+    vA.regNum = num;
+    std::string typeName = bc::BCUtil::kAggregate;
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName));
+  }
+};
+
+// ---------- FEIRExprBinary - DexOpThrow ----------
+TEST_F(DexOpTest, DexOpThrow) {
+  std::unique_ptr<DexOpThrowUT> dexOp = std::make_unique<DexOpThrowUT>(allocator, 0, bc::kDexOpThrow);
+  dexOp->SetVA(3);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string(
+      "throw \\(dread ref %Reg3_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) + std::string("\\)") +
+      HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  EXPECT_EQ(mirStmts.size(), 1);
+  RestoreCout();
+}
+
+// ---------- FEIRExprBinary - DexOpAget ----------
+class DexOpAgetUT : public bc::DexOpAget {
+ public:
+  DexOpAgetUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpAget(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpAgetUT() = default;
+  void SetType(bc::DexOpCode opcode) {
+    std::string elemTypeName;
+    switch (opcode) {
+      case bc::kDexOpAget: {
+        elemTypeName = bc::BCUtil::kInt;
+        break;
+      }
+      case bc::kDexOpAgetWide: {
+        elemTypeName = bc::BCUtil::kWide;
+        break;
+      }
+      case bc::kDexOpAgetObject: {
+        elemTypeName = bc::BCUtil::kJavaObjectName;
+        break;
+      }
+      case bc::kDexOpAgetBoolean: {
+        elemTypeName = bc::BCUtil::kBoolean;
+        break;
+      }
+      case bc::kDexOpAgetByte: {
+        elemTypeName = bc::BCUtil::kByte;
+        break;
+      }
+      case bc::kDexOpAgetChar: {
+        elemTypeName = bc::BCUtil::kChar;
+        break;
+      }
+      case bc::kDexOpAgetShort: {
+        elemTypeName = bc::BCUtil::kShort;
+        break;
+      }
+      default: {
+        CHECK_FATAL(false, "Invalid opcode : 0x%x in DexOpAget", opcode);
+        break;
+      }
+    }
+
+    std::string arrayTypeName = "[" + elemTypeName;
+    elemTypeName = namemangler::EncodeName(elemTypeName);
+    arrayTypeName = namemangler::EncodeName(arrayTypeName);
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(elemTypeName));
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(arrayTypeName));
+
+    GStrIdx usedTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(bc::BCUtil::kInt);
+    vC.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vC, usedTypeNameIdx);
+  }
+};
+
+TEST_F(DexOpTest, DexOpAgetObject) {
+  std::unique_ptr<DexOpAgetUT> dexOp = std::make_unique<DexOpAgetUT>(allocator, 0, bc::kDexOpAgetObject);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVC(2);
+  dexOp->SetType(bc::kDexOpAgetObject);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expect1 = std::string("dassign %Reg0_");
+  std::string expect2 = std::string(" 0 (iread ref <* <* <$Ljava_2Flang_2FObject_3B>>> 0 "
+      "(array 1 ptr <* <[] <* <$Ljava_2Flang_2FObject_3B>>>> (dread ref %Reg1_");
+  std::string expect3 = std::string(", dread i32 %Reg2_I");
+  EXPECT_EQ(dumpStr.find(expect1) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect2) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect3) != std::string::npos, true);
+  EXPECT_EQ(mirStmts.size(), 1);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, DexOpAgetBoolean) {
+  std::unique_ptr<DexOpAgetUT> dexOp = std::make_unique<DexOpAgetUT>(allocator, 0, bc::kDexOpAgetBoolean);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVC(2);
+  dexOp->SetType(bc::kDexOpAgetBoolean);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+
+  std::string expect1 = std::string("dassign %Reg0_Z");
+  std::string expect2 = std::string("0 (iread u32 <* u1> 0 (array 1 ptr <* <[] u1>> (dread ref %Reg1_");
+  std::string expect3 = std::string(", dread i32 %Reg2_I");
+  EXPECT_EQ(dumpStr.find(expect1) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect2) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect3) != std::string::npos, true);
+
+  EXPECT_EQ(mirStmts.size(), 1);
+  RestoreCout();
+}
+
+// ---------- FEIRExprBinary - DexOpAput ----------
+class DexOpAputUT : public bc::DexOpAput {
+ public:
+  DexOpAputUT(MapleAllocator &allocatorIn, uint32 pcIn, bc::DexOpCode opcodeIn)
+      : bc::DexOpAput(allocatorIn, pcIn, opcodeIn) {}
+  ~DexOpAputUT() = default;
+  void SetType(bc::DexOpCode opcode) {
+    std::string elemTypeName;
+    switch (opcode) {
+      case bc::kDexOpAput: {
+        elemTypeName = bc::BCUtil::kInt;
+        break;
+      }
+      case bc::kDexOpAputWide: {
+        elemTypeName = bc::BCUtil::kWide;
+        break;
+      }
+      case bc::kDexOpAputObject: {
+        elemTypeName = bc::BCUtil::kJavaObjectName;
+        break;
+      }
+      case bc::kDexOpAputBoolean: {
+        elemTypeName = bc::BCUtil::kBoolean;
+        break;
+      }
+      case bc::kDexOpAputByte: {
+        elemTypeName = bc::BCUtil::kByte;
+        break;
+      }
+      case bc::kDexOpAputChar: {
+        elemTypeName = bc::BCUtil::kChar;
+        break;
+      }
+      case bc::kDexOpAputShort: {
+        elemTypeName = bc::BCUtil::kShort;
+        break;
+      }
+      default: {
+        CHECK_FATAL(false, "Invalid opcode : 0x%x in DexOpAget", opcode);
+        break;
+      }
+    }
+
+    std::string arrayTypeName = "[" + elemTypeName;
+    elemTypeName = namemangler::EncodeName(elemTypeName);
+    arrayTypeName = namemangler::EncodeName(arrayTypeName);
+    vA.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vA,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(elemTypeName));
+    vB.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vB,
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(arrayTypeName));
+    GStrIdx usedTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(bc::BCUtil::kInt);
+    vC.regType = allocator.GetMemPool()->New<bc::BCRegType>(allocator, vC, usedTypeNameIdx);
+  }
+};
+
+TEST_F(DexOpTest, kDexOpAputBoolean) {
+  std::unique_ptr<DexOpAputUT> dexOp = std::make_unique<DexOpAputUT>(allocator, 0, bc::kDexOpAputBoolean);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVC(2);
+  dexOp->SetType(bc::kDexOpAputBoolean);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  EXPECT_EQ(mirStmts.size(), 1);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expect1 = std::string("iassign <* u1> 0 (");
+  std::string expect2 = std::string("array 1 ptr <* <[] u1>> (dread ref %Reg1_R");
+  std::string expect3 = std::string(", dread i32 %Reg2_I), ");
+  std::string expect4 = std::string("  dread u32 %Reg0_Z)");
+  EXPECT_EQ(dumpStr.find(expect1) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect2) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect3) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect4) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(DexOpTest, DexOpAputObject) {
+  std::unique_ptr<DexOpAputUT> dexOp = std::make_unique<DexOpAputUT>(allocator, 0, bc::kDexOpAputObject);
+  dexOp->SetVA(0);
+  dexOp->SetVB(1);
+  dexOp->SetVC(2);
+  dexOp->SetType(bc::kDexOpAputObject);
+  std::list<UniqueFEIRStmt> stmts = dexOp->EmitToFEIRStmts();
+  std::list<StmtNode*> mirStmts = stmts.front()->GenMIRStmts(mirBuilder);
+  EXPECT_EQ(mirStmts.size(), 1);
+  RedirectCout();
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expect1 = std::string("iassign <* <* <$Ljava_2Flang_2FObject_3B>>> 0 (");
+  std::string expect2 = std::string("array 1 ptr <* <[] <* <$Ljava_2Flang_2FObject_3B>>>> (dread ref %Reg1_R");
+  std::string expect3 = std::string(", dread i32 %Reg2_I), ");
+  std::string expect4 = std::string("  dread ref %Reg0_R");
+  EXPECT_EQ(dumpStr.find(expect1) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect2) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect3) != std::string::npos, true);
+  EXPECT_EQ(dumpStr.find(expect4) != std::string::npos, true);
+  RestoreCout();
+}
+}  // bc
+}  // namespace maple
diff --git a/src/hir2mpl/test/bytecode_input/dex/dex_reader_test.cpp b/src/hir2mpl/test/bytecode_input/dex/dex_reader_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..abdcf1bfe3f0fb30488f3a6425282798b5df6095
--- /dev/null
+++ b/src/hir2mpl/test/bytecode_input/dex/dex_reader_test.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "dex_reader.h"
+#include "types_def.h"
+
+namespace maple {
+namespace bc {
+class DexReaderTest : public testing::Test {
+ public:
+  DexReaderTest() : reader(std::make_unique<DexReader>(0, "./hir2mplUT")) {}
+
+  ~DexReaderTest() = default;
+
+ protected:
+  std::unique_ptr<DexReader> reader;
+};
+
+TEST_F(DexReaderTest, GetRealInterger) {
+  uint32 value0 = 0x12345678;
+  uint32 value1 = 0x78563412;
+  reader->SetEndianTag(true); // big endian
+  EXPECT_EQ(reader->GetRealInteger(value0), value1);
+
+  reader->SetEndianTag(false); // little endian
+  EXPECT_EQ(reader->GetRealInteger(value0), value0);
+}
+}  // namespace jbc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/base64_test.cpp b/src/hir2mpl/test/common/base64_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae122844a2d072bf27148d295b1ba8f238e862f1
--- /dev/null
+++ b/src/hir2mpl/test/common/base64_test.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "base64.h"
+
+namespace maple {
+TEST(Base64, Encode) {
+  uint8 buf[] = { 'A', 'B', 'C', 'D' };
+  std::string base64Str = Base64::Encode(buf, 4);
+  EXPECT_EQ(base64Str, "QUJDRA==");
+}
+
+TEST(Base64, Decode) {
+  std::string base64Str = "QUJDRA==";
+  size_t length = 0;
+  uint8 *buf = Base64::Decode(base64Str, length);
+  ASSERT_EQ(length, 4);
+  EXPECT_EQ(buf[0], 'A');
+  EXPECT_EQ(buf[1], 'B');
+  EXPECT_EQ(buf[2], 'C');
+  EXPECT_EQ(buf[3], 'D');
+}
+
+TEST(Base64, Decode_Boundary1) {
+  std::string base64Str = "";
+  size_t length = 0;
+  (void)Base64::Decode(base64Str, length);
+  ASSERT_EQ(length, 0);
+}
+
+TEST(Base64, Decode_Boundary2) {
+  std::string base64Str = "QUI=";
+  size_t length = 0;
+  uint8 *buf = Base64::Decode(base64Str, length);
+  ASSERT_EQ(length, 2);
+  EXPECT_EQ(buf[0], 'A');
+  EXPECT_EQ(buf[1], 'B');
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/basic_io_test.cpp b/src/hir2mpl/test/common/basic_io_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..356825fc75ca786983402d160e2f9600be17d4ca
--- /dev/null
+++ b/src/hir2mpl/test/common/basic_io_test.cpp
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "basic_io.h"
+#include "base64.h"
+
+namespace maple {
+TEST(BasicIOMapFile, GenFileInMemory) {
+  uint8 buf[] = { 0x00, 0x01, 0x02, 0x03 };
+  std::unique_ptr<BasicIOMapFile> mapFile = BasicIOMapFile::GenFileInMemory("test", buf, sizeof(buf));
+  EXPECT_NE(mapFile.get(), nullptr);
+  EXPECT_EQ(mapFile->GetLength(), 4);
+}
+
+class BasicIOReadTest : public testing::Test {
+ public:
+  BasicIOReadTest() {
+    testFile1 = BasicIOMapFile::GenFileInMemory("test", buf1, sizeof(buf1));
+    testFile2 = BasicIOMapFile::GenFileInMemory("test", buf2, sizeof(buf2));
+    testFile3 = BasicIOMapFile::GenFileInMemory("test", buf3, sizeof(buf3));
+    testFile4 = BasicIOMapFile::GenFileInMemory("test", buf4, sizeof(buf4));
+    testFile5 = BasicIOMapFile::GenFileInMemory("test", buf5, sizeof(buf5));
+  }
+
+  ~BasicIOReadTest() = default;
+
+  BasicIOMapFile &GetTestFile1() {
+    CHECK_NULL_FATAL(testFile1.get());
+    return *testFile1;
+  }
+
+  BasicIOMapFile &GetTestFile2() {
+    CHECK_NULL_FATAL(testFile2.get());
+    return *testFile2;
+  }
+
+  BasicIOMapFile &GetTestFile3() {
+    CHECK_NULL_FATAL(testFile3.get());
+    return *testFile3;
+  }
+
+  BasicIOMapFile &GetTestFile4() {
+    CHECK_NULL_FATAL(testFile4.get());
+    return *testFile4;
+  }
+
+  BasicIOMapFile &GetTestFile5() {
+    CHECK_NULL_FATAL(testFile5.get());
+    return *testFile5;
+  }
+
+ private:
+  std::unique_ptr<BasicIOMapFile> testFile1;
+  std::unique_ptr<BasicIOMapFile> testFile2;
+  std::unique_ptr<BasicIOMapFile> testFile3;
+  std::unique_ptr<BasicIOMapFile> testFile4;
+  std::unique_ptr<BasicIOMapFile> testFile5;
+  uint8 buf1[16] = {0x01, 0xFF, 0x02, 0xFE, 0x03, 0xFD, 0x04, 0xFC, 0x05, 0xFB, 0x06, 0xFA, 0x07, 0xF8, 0x08, 0xF7};
+  uint8 buf2[12] = {0x3F, 0x80, 0x00, 0x00, 0xBF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+  uint8 buf3[12] = {0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xBF};
+  uint8 buf4[4] = {'A', 'B', 'C', 'D'};
+  uint8 buf5[1] = {0x00};
+};
+
+TEST_F(BasicIOReadTest, ReadUInt8) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadUInt8(), 0x01);
+  EXPECT_EQ(ioLittleEndian.ReadUInt8(), 0x01);
+  EXPECT_EQ(ioBigEndian.ReadUInt8(success), 0xFF);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadUInt8(success), 0xFF);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadInt8) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadInt8(), static_cast<int8>(0x01));
+  EXPECT_EQ(ioLittleEndian.ReadInt8(), static_cast<int8>(0x01));
+  EXPECT_EQ(ioBigEndian.ReadInt8(success), static_cast<int8>(0xFF));
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadInt8(success), static_cast<int8>(0xFF));
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadUInt16) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadUInt16(), 0x01FF);
+  EXPECT_EQ(ioLittleEndian.ReadUInt16(), 0xFF01);
+  EXPECT_EQ(ioBigEndian.ReadUInt16(success), 0x02FE);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadUInt16(success), 0xFE02);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadInt16) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadInt16(), static_cast<int16>(0x01FF));
+  EXPECT_EQ(ioLittleEndian.ReadInt16(), static_cast<int16>(0xFF01));
+  EXPECT_EQ(ioBigEndian.ReadInt16(success), static_cast<int16>(0x02FE));
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadInt16(success), static_cast<int16>(0xFE02));
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadUInt32) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadUInt32(), 0x01FF02FE);
+  EXPECT_EQ(ioLittleEndian.ReadUInt32(), 0xFE02FF01);
+  EXPECT_EQ(ioBigEndian.ReadUInt32(success), 0x03FD04FC);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadUInt32(success), 0xFC04FD03);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadInt32) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadInt32(), static_cast<int32>(0x01FF02FE));
+  EXPECT_EQ(ioLittleEndian.ReadInt32(), static_cast<int32>(0xFE02FF01));
+  EXPECT_EQ(ioBigEndian.ReadInt32(success), static_cast<int32>(0x03FD04FC));
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadInt32(success), static_cast<int32>(0xFC04FD03));
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadUInt64) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadUInt64(), 0x01FF02FE03FD04FC);
+  EXPECT_EQ(ioLittleEndian.ReadUInt64(), 0xFC04FD03FE02FF01);
+  EXPECT_EQ(ioBigEndian.ReadUInt64(success), 0x05FB06FA07F808F7);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadUInt64(success), 0xF708F807FA06FB05);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadInt64) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadInt64(), static_cast<int64>(0x01FF02FE03FD04FC));
+  EXPECT_EQ(ioLittleEndian.ReadInt64(), static_cast<int64>(0xFC04FD03FE02FF01));
+  EXPECT_EQ(ioBigEndian.ReadInt64(success), static_cast<int64>(0x05FB06FA07F808F7));
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadInt64(success), static_cast<int64>(0xF708F807FA06FB05));
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadFloat) {
+  BasicIORead ioBigEndian(GetTestFile2(), true);
+  BasicIORead ioLittleEndian(GetTestFile3(), false);
+  EXPECT_EQ(ioBigEndian.ReadFloat(), 1.0f);
+  EXPECT_EQ(ioLittleEndian.ReadFloat(), 1.0f);
+  EXPECT_EQ(ioBigEndian.ReadDouble(), -1.0);
+  EXPECT_EQ(ioLittleEndian.ReadDouble(), -1.0);
+}
+
+TEST_F(BasicIOReadTest, ReadFloat2) {
+  BasicIORead ioBigEndian(GetTestFile2(), true);
+  BasicIORead ioLittleEndian(GetTestFile3(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadFloat(success), 1.0f);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadFloat(success), 1.0f);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioBigEndian.ReadDouble(success), -1.0);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadDouble(success), -1.0);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadBufferUInt8) {
+  BasicIORead ioBigEndian(GetTestFile4(), true);
+  BasicIORead ioLittleEndian(GetTestFile4(), false);
+  bool success = false;
+  uint8 buf[2];
+  // big endian
+  ioBigEndian.ReadBufferUInt8(buf, 2);
+  EXPECT_EQ(buf[0], static_cast<uint8>('A'));
+  EXPECT_EQ(buf[1], static_cast<uint8>('B'));
+  ioBigEndian.ReadBufferUInt8(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], static_cast<uint8>('C'));
+  EXPECT_EQ(buf[1], static_cast<uint8>('D'));
+  ioBigEndian.ReadBufferUInt8(buf, 2, success);
+  EXPECT_EQ(success, false);
+  // little endian
+  ioLittleEndian.ReadBufferUInt8(buf, 2);
+  EXPECT_EQ(buf[0], static_cast<uint8>('A'));
+  EXPECT_EQ(buf[1], static_cast<uint8>('B'));
+  ioLittleEndian.ReadBufferUInt8(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], static_cast<uint8>('C'));
+  EXPECT_EQ(buf[1], static_cast<uint8>('D'));
+  ioLittleEndian.ReadBufferUInt8(buf, 2, success);
+  EXPECT_EQ(success, false);
+}
+
+TEST_F(BasicIOReadTest, ReadBufferInt8) {
+  BasicIORead ioBigEndian(GetTestFile4(), true);
+  BasicIORead ioLittleEndian(GetTestFile4(), false);
+  bool success = false;
+  int8 buf[2];
+  // big endian
+  ioBigEndian.ReadBufferInt8(buf, 2);
+  EXPECT_EQ(buf[0], static_cast<int8>('A'));
+  EXPECT_EQ(buf[1], static_cast<int8>('B'));
+  ioBigEndian.ReadBufferInt8(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], static_cast<int8>('C'));
+  EXPECT_EQ(buf[1], static_cast<int8>('D'));
+  ioBigEndian.ReadBufferInt8(buf, 2, success);
+  EXPECT_EQ(success, false);
+  // little endian
+  ioLittleEndian.ReadBufferInt8(buf, 2);
+  EXPECT_EQ(buf[0], static_cast<int8>('A'));
+  EXPECT_EQ(buf[1], static_cast<int8>('B'));
+  ioLittleEndian.ReadBufferInt8(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], static_cast<int8>('C'));
+  EXPECT_EQ(buf[1], static_cast<int8>('D'));
+  ioLittleEndian.ReadBufferInt8(buf, 2, success);
+  EXPECT_EQ(success, false);
+}
+
+TEST_F(BasicIOReadTest, ReadBufferChar) {
+  BasicIORead ioBigEndian(GetTestFile4(), true);
+  BasicIORead ioLittleEndian(GetTestFile4(), false);
+  bool success = false;
+  char buf[2];
+  // big endian
+  ioBigEndian.ReadBufferChar(buf, 2);
+  EXPECT_EQ(buf[0], 'A');
+  EXPECT_EQ(buf[1], 'B');
+  ioBigEndian.ReadBufferChar(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], 'C');
+  EXPECT_EQ(buf[1], 'D');
+  ioBigEndian.ReadBufferChar(buf, 2, success);
+  EXPECT_EQ(success, false);
+  // little endian
+  ioLittleEndian.ReadBufferChar(buf, 2);
+  EXPECT_EQ(buf[0], 'A');
+  EXPECT_EQ(buf[1], 'B');
+  ioLittleEndian.ReadBufferChar(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], 'C');
+  EXPECT_EQ(buf[1], 'D');
+  ioLittleEndian.ReadBufferChar(buf, 2, success);
+  EXPECT_EQ(success, false);
+}
+
+TEST_F(BasicIOReadTest, ReadString) {
+  BasicIORead ioBigEndian(GetTestFile4(), true);
+  BasicIORead ioLittleEndian(GetTestFile4(), false);
+  bool success = false;
+  // big endian
+  EXPECT_EQ(ioBigEndian.ReadString(2), "AB");
+  EXPECT_EQ(ioBigEndian.ReadString(2, success), "CD");
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioBigEndian.ReadString(2, success), "");
+  EXPECT_EQ(success, false);
+  // little endian
+  EXPECT_EQ(ioLittleEndian.ReadString(2), "AB");
+  EXPECT_EQ(ioLittleEndian.ReadString(2, success), "CD");
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadString(2, success), "");
+  EXPECT_EQ(success, false);
+}
+
+TEST_F(BasicIOReadTest, Read_BoundaryCheck) {
+  BasicIORead ioBigEndian(GetTestFile5(), true);
+  ioBigEndian.ReadUInt8();
+  bool success = false;
+  ioBigEndian.ReadUInt8(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadUInt16(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadUInt32(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadUInt64(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadFloat(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadDouble(success);
+  EXPECT_EQ(success, false);
+}
+
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/fe_algorithm_test.cpp b/src/hir2mpl/test/common/fe_algorithm_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..515814b08b4971b95ba79b5baad531b5426e1680
--- /dev/null
+++ b/src/hir2mpl/test/common/fe_algorithm_test.cpp
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <set>
+#include <memory>
+#include <iostream>
+#include "fe_options.h"
+#include "fe_algorithm.h"
+#include "mpl_logging.h"
+
+namespace maple {
+class TestNode {
+ public:
+  TestNode(int argID, std::set<int> argItems) : id(argID) {
+    for (int item : argItems) {
+      items.insert(item);
+    }
+    mergeEnd = items.size() > 0;
+  }
+  ~TestNode() = default;
+
+  bool Merge(const TestNode &src) {
+    for (int item : src.GetItems()) {
+      items.insert(item);
+    }
+    return true;
+  }
+
+  bool MergeEnd() const {
+    return mergeEnd;
+  }
+
+  bool CheckExist(int item) const {
+    return items.find(item) != items.end();
+  }
+
+  bool CheckExist(std::set<int> argItems) const {
+    for (int item : argItems) {
+      if (items.find(item) == items.end()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  const std::set<int> &GetItems() const {
+    return items;
+  }
+
+  int GetID() const {
+    return id;
+  }
+
+ private:
+  int id;
+  bool mergeEnd;
+  std::set<int> items;
+};  // class TestNode
+
+class CorrelativeMergeTest {
+ public:
+  CorrelativeMergeTest() = default;
+  ~CorrelativeMergeTest() = default;
+};
+
+// Test1
+TEST(CorrelativeMergeTest, Test1) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+}
+
+// Test2
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test2.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test2.png
+TEST(CorrelativeMergeTest, Test2) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node1.get()].insert(node2.get());
+  correlation[node2.get()].insert(node1.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+  EXPECT_EQ(node2->CheckExist(0), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test3
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test3.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test3.png
+TEST(CorrelativeMergeTest, Test3) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>({ 2 }));
+  correlation[node1.get()].insert(node0.get());
+  correlation[node1.get()].insert(node2.get());
+  correlation[node2.get()].insert(node1.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(std::set<int>({ 0, 2 })), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test4
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test4.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test4.png
+TEST(CorrelativeMergeTest, Test4) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>());
+  std::unique_ptr<TestNode> node3 = std::make_unique<TestNode>(3, std::set<int>());
+  std::unique_ptr<TestNode> node4 = std::make_unique<TestNode>(4, std::set<int>());
+  std::unique_ptr<TestNode> node5 = std::make_unique<TestNode>(5, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node2.get()].insert(node1.get());
+  correlation[node2.get()].insert(node5.get());
+  correlation[node3.get()].insert(node2.get());
+  correlation[node4.get()].insert(node3.get());
+  correlation[node5.get()].insert(node4.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+  EXPECT_EQ(node2->CheckExist(0), true);
+  EXPECT_EQ(node3->CheckExist(0), true);
+  EXPECT_EQ(node4->CheckExist(0), true);
+  EXPECT_EQ(node5->CheckExist(0), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test5
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test5.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test5.png
+TEST(CorrelativeMergeTest, Test5) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>());
+  std::unique_ptr<TestNode> node3 = std::make_unique<TestNode>(3, std::set<int>());
+  std::unique_ptr<TestNode> node4 = std::make_unique<TestNode>(4, std::set<int>({ 4 }));
+  std::unique_ptr<TestNode> node5 = std::make_unique<TestNode>(5, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node2.get()].insert(node1.get());
+  correlation[node2.get()].insert(node5.get());
+  correlation[node3.get()].insert(node2.get());
+  correlation[node4.get()].insert(node3.get());
+  correlation[node5.get()].insert(node4.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+  EXPECT_EQ(node2->CheckExist(std::set<int>({ 0, 4 })), true);
+  EXPECT_EQ(node3->CheckExist(std::set<int>({ 0, 4 })), true);
+  EXPECT_EQ(node5->CheckExist(4), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test6
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test6.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test6.png
+TEST(CorrelativeMergeTest, Test6) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>({ 2 }));
+  std::unique_ptr<TestNode> node3 = std::make_unique<TestNode>(3, std::set<int>());
+  std::unique_ptr<TestNode> node4 = std::make_unique<TestNode>(4, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node2.get()].insert(node0.get());
+  correlation[node2.get()].insert(node4.get());
+  correlation[node3.get()].insert(node1.get());
+  correlation[node3.get()].insert(node2.get());
+  correlation[node4.get()].insert(node3.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+  EXPECT_EQ(node3->CheckExist(std::set<int>({ 0, 2 })), true);
+  EXPECT_EQ(node4->CheckExist(std::set<int>({ 0, 2 })), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test7
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test7.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test7.png
+TEST(CorrelativeMergeTest, Test7) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>());
+  std::unique_ptr<TestNode> node3 = std::make_unique<TestNode>(3, std::set<int>());
+  std::unique_ptr<TestNode> node4 = std::make_unique<TestNode>(4, std::set<int>());
+  std::unique_ptr<TestNode> node5 = std::make_unique<TestNode>(5, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node1.get()].insert(node5.get());
+  correlation[node2.get()].insert(node1.get());
+  correlation[node3.get()].insert(node2.get());
+  correlation[node4.get()].insert(node2.get());
+  correlation[node5.get()].insert(node3.get());
+  correlation[node5.get()].insert(node4.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.LoopCheckAll();
+  mergeHelper.ProcessOne(*node3, true);
+  EXPECT_EQ(node3->CheckExist(std::set<int>({ 0 })), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+}  // namespace MAPLE
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/fe_file_ops_test.cpp b/src/hir2mpl/test/common/fe_file_ops_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c2d94d6f8d93b6606dfb5af76d64859b04f41d7e
--- /dev/null
+++ b/src/hir2mpl/test/common/fe_file_ops_test.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_file_ops.h"
+
+namespace maple {
+TEST(FEFileOps, GetFilePath) {
+  EXPECT_EQ(FEFileOps::GetFilePath("name"), "");
+  EXPECT_EQ(FEFileOps::GetFilePath("/name"), "/");
+  EXPECT_EQ(FEFileOps::GetFilePath("path/"), "path/");
+  EXPECT_EQ(FEFileOps::GetFilePath("path/name"), "path/");
+  EXPECT_EQ(FEFileOps::GetFilePath("/path/name"), "/path/");
+  EXPECT_EQ(FEFileOps::GetFilePath("../name"), "../");
+}
+
+TEST(FEFileOps, GetFileNameWithExt) {
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("/name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("path/"), "");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("path/name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("/path/name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("../name"), "name");
+}
+
+TEST(FEFileOps, GetFileName) {
+  EXPECT_EQ(FEFileOps::GetFileName("name.ext"), "name");
+  EXPECT_EQ(FEFileOps::GetFileName("name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileName(".ext"), "");
+  EXPECT_EQ(FEFileOps::GetFileName("/name.ext"), "name");
+  EXPECT_EQ(FEFileOps::GetFileName("path/name.ext"), "name");
+}
+
+TEST(FEFileOps, GetFileExtName) {
+  EXPECT_EQ(FEFileOps::GetFileExtName("name.ext"), "ext");
+  EXPECT_EQ(FEFileOps::GetFileExtName("name"), "");
+  EXPECT_EQ(FEFileOps::GetFileExtName(".ext"), "ext");
+  EXPECT_EQ(FEFileOps::GetFileExtName("/name.ext"), "ext");
+  EXPECT_EQ(FEFileOps::GetFileExtName("path/name.ext"), "ext");
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/fe_file_type_test.cpp b/src/hir2mpl/test/common/fe_file_type_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e31774815165a9131f80354db786cbab8d89213b
--- /dev/null
+++ b/src/hir2mpl/test/common/fe_file_type_test.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_file_type.h"
+
+namespace maple {
+TEST(FEFileType, GetFileTypeByExtName) {
+  EXPECT_EQ(FEFileType::GetInstance().GetFileTypeByExtName("jar"), FEFileType::FileType::kJar);
+  EXPECT_EQ(FEFileType::GetInstance().GetFileTypeByExtName("class"), FEFileType::FileType::kClass);
+  EXPECT_EQ(FEFileType::GetInstance().GetFileTypeByExtName("dex"), FEFileType::FileType::kDex);
+  EXPECT_EQ(FEFileType::GetInstance().GetFileTypeByExtName(""), FEFileType::FileType::kUnknownType);
+  EXPECT_EQ(FEFileType::GetInstance().GetFileTypeByExtName("txt"), FEFileType::FileType::kUnknownType);
+}
+
+TEST(FEFileType, RegisterExtName_Warn) {
+  FEFileType::GetInstance().RegisterExtName(FEFileType::FileType::kJar, "");
+  FEFileType::GetInstance().RegisterExtName(FEFileType::FileType::kUnknownType, "txt");
+}
+
+TEST(FEFileType, RegisterMagicNumber_Warn) {
+  FEFileType::GetInstance().RegisterMagicNumber(FEFileType::FileType::kJar, 0);
+  FEFileType::GetInstance().RegisterMagicNumber(FEFileType::FileType::kUnknownType, 0x12345678);
+}
+
+TEST(FEFileType, GetExtName) {
+  EXPECT_EQ(FEFileType::GetExtName("test.jar"), "jar");
+  EXPECT_EQ(FEFileType::GetExtName("../test.jar"), "jar");
+  EXPECT_EQ(FEFileType::GetExtName("../path/test.jar"), "jar");
+  EXPECT_EQ(FEFileType::GetExtName("path/test.jar"), "jar");
+  EXPECT_EQ(FEFileType::GetExtName("path/test"), "");
+}
+}
diff --git a/src/hir2mpl/test/common/fe_function_process_schedular_test.cpp b/src/hir2mpl/test/common/fe_function_process_schedular_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..07a39e7b73b86acb60a6764a1b2355526dcde32c
--- /dev/null
+++ b/src/hir2mpl/test/common/fe_function_process_schedular_test.cpp
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "hir2mpl_compiler_component.h"
+#include <list>
+#include <unistd.h>
+#include <memory>
+
+namespace maple {
+class FEFunctionChild : public FEFunction {
+ public:
+  FEFunctionChild(std::list<uint32> &argResult, uint32 argIdx)
+      : FEFunction(nullptr),
+        result(argResult),
+        idx(argIdx) {}
+  virtual ~FEFunctionChild() = default;
+  void Process() override {
+    usleep(rand() % 1000);
+  }
+  void EmitToMIR() override {
+    result.push_back(idx);
+  }
+  bool PreProcessTypeNameIdx() override {
+    return true;
+  }
+  void GenerateGeneralStmt(bool &success) override {}
+  void GenerateGeneralStmtFailCallBack() override {}
+  void GenerateGeneralDebugInfo() override {}
+  bool VerifyGeneral() override {
+    return true;
+  }
+  void VerifyGeneralFailCallBack() override {}
+  void EmitToFEIRStmt() override {}
+  void GenerateArgVarList() override {}
+  bool HasThis() override {
+    return false;
+  }
+
+ private:
+  std::list<uint32> &result;
+  uint32 idx;
+};  // class FEFunctionChild
+
+TEST(FEFunctionProcessSchedular, RunSingle) {
+  std::list<uint32> results;
+  std::unique_ptr<FEFunction> function = std::make_unique<FEFunctionChild>(results, 0);
+  std::unique_ptr<FEFunctionProcessTask> task = std::make_unique<FEFunctionProcessTask>(function.get());
+  task->Run();
+  task->Finish();
+  EXPECT_EQ(results.size(), 1);
+}
+
+TEST(FEFunctionProcessSchedular, RunDirect) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    task->Run();
+    task->Finish();
+  }
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunSerial) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(1, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel2) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(2, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel4) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(4, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel8) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(8, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel16) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(16, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel32) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(32, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel48) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(48, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel64) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(64, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel128) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  schedular.Init();
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(128, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/fe_struct_elem_info_test.cpp b/src/hir2mpl/test/common/fe_struct_elem_info_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eaa952d885dc06acf32bc11fa38da6007e868ec2
--- /dev/null
+++ b/src/hir2mpl/test/common/fe_struct_elem_info_test.cpp
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "global_tables.h"
+#include "namemangler.h"
+#include "fe_struct_elem_info.h"
+#include "fe_manager.h"
+#include "hir2mpl_ut_environment.h"
+#include "redirect_buffer.h"
+
+namespace maple {
+class FEStructFieldInfoTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEStructFieldInfoTest()
+      : mirBuilder(&HIR2MPLUTEnvironment::GetMIRModule()) {}
+
+  virtual ~FEStructFieldInfoTest() = default;
+
+  MIRBuilder mirBuilder;
+};
+
+TEST_F(FEStructFieldInfoTest, FEStructFieldInfo) {
+  StructElemNameIdx *structElemNameIdx = new StructElemNameIdx("Ljava/lang/Integer;", "MIN_VALUE", "I");
+  FEStructFieldInfo info(mirBuilder.GetMirModule().GetMPAllocator(), *structElemNameIdx, kSrcLangJava, true);
+  std::string structName = GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx->klass);
+  std::string elemName = GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx->elem);
+  std::string signatureName = GlobalTables::GetStrTable().GetStringFromStrIdx(structElemNameIdx->type);
+  delete structElemNameIdx;
+  EXPECT_EQ(structName, namemangler::EncodeName("Ljava/lang/Integer;"));
+  EXPECT_EQ(elemName, namemangler::EncodeName("MIN_VALUE"));
+  EXPECT_EQ(signatureName, namemangler::EncodeName("I"));
+  EXPECT_EQ(info.fieldType->IsScalar(), true);
+}
+
+TEST_F(FEStructFieldInfoTest, SearchStructFieldJava) {
+  StructElemNameIdx *structElemNameIdx = new StructElemNameIdx("Ljava/lang/Integer;", "MIN_VALUE", "I");
+  FEStructFieldInfo info(mirBuilder.GetMirModule().GetMPAllocator(), *structElemNameIdx, kSrcLangJava, true);
+  MIRStructType *structType =
+      FEManager::GetTypeManager().GetStructTypeFromName(namemangler::EncodeName("Ljava/lang/Integer;"));
+  delete structElemNameIdx;
+  ASSERT_NE(structType, nullptr);
+  EXPECT_EQ(info.SearchStructFieldJava(*structType, mirBuilder, true), true);
+  EXPECT_EQ(info.SearchStructFieldJava(*structType, mirBuilder, false), false);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/common/fe_type_hierarchy_test.cpp b/src/hir2mpl/test/common/fe_type_hierarchy_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4f5c017bfa13ab76fe837694518ecf68289787dc
--- /dev/null
+++ b/src/hir2mpl/test/common/fe_type_hierarchy_test.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_type_hierarchy.h"
+#include "global_tables.h"
+
+namespace maple {
+TEST(FETypeHierarchy, IsParentOf) {
+  GStrIdx idxObject = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FObject_3B");
+  GStrIdx idxString = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FString_3B");
+  GStrIdx idxInteger = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FInteger_3B");
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxObject, idxString), true);
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxObject, idxInteger), true);
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxString, idxInteger), false);
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxInteger, idxString), false);
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxString, idxString), true);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/fe_type_manager_test.cpp b/src/hir2mpl/test/common/fe_type_manager_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4817a268531aa8744e0936e473097b36ce9f7ad0
--- /dev/null
+++ b/src/hir2mpl/test/common/fe_type_manager_test.cpp
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_manager.h"
+#include "fe_type_manager.h"
+#include "redirect_buffer.h"
+
+namespace maple {
+class FETypeManagerTest : public testing::Test, public RedirectBuffer {
+ public:
+  FETypeManagerTest() = default;
+  ~FETypeManagerTest() = default;
+};
+
+TEST_F(FETypeManagerTest, GetClassOrInterfaceType) {
+  MIRStructType *structType = FEManager::GetTypeManager().GetClassOrInterfaceType("Ljava_2Flang_2FObject_3B");
+  EXPECT_NE(structType, nullptr);
+  if (structType != nullptr) {
+    std::string mplName = structType->GetCompactMplTypeName();
+    EXPECT_EQ(mplName, "Ljava_2Flang_2FObject_3B");
+  }
+  MIRStructType *structTypeUnknown = FEManager::GetTypeManager().GetClassOrInterfaceType("LUnknown");
+  EXPECT_EQ(structTypeUnknown, nullptr);
+}
+
+TEST_F(FETypeManagerTest, GetClassOrInterfaceTypeFlag) {
+  FETypeFlag flag = FEManager::GetTypeManager().GetClassOrInterfaceTypeFlag("Ljava_2Flang_2FObject_3B");
+  EXPECT_EQ(flag, FETypeFlag::kSrcMpltSys);
+  FETypeFlag flagUnknown = FEManager::GetTypeManager().GetClassOrInterfaceTypeFlag("LUnknown");
+  EXPECT_EQ(flagUnknown, FETypeFlag::kDefault);
+}
+
+TEST_F(FETypeManagerTest, CreateClassOrInterfaceType) {
+  MIRStructType *structType1 = FEManager::GetTypeManager().CreateClassOrInterfaceType("LNewClass", false,
+                                                                                      FETypeFlag::kSrcInput);
+  EXPECT_NE(structType1, nullptr);
+  if (structType1 != nullptr) {
+    std::string mplName = structType1->GetCompactMplTypeName();
+    EXPECT_EQ(mplName, "LNewClass");
+    EXPECT_EQ(structType1->GetKind(), kTypeClassIncomplete);
+  }
+  MIRStructType *structType2 = FEManager::GetTypeManager().CreateClassOrInterfaceType("LNewInterface", true,
+                                                                                      FETypeFlag::kSrcInput);
+  EXPECT_NE(structType2, nullptr);
+  if (structType2 != nullptr) {
+    std::string mplName = structType2->GetCompactMplTypeName();
+    EXPECT_EQ(mplName, "LNewInterface");
+    EXPECT_EQ(structType2->GetKind(), kTypeInterfaceIncomplete);
+  }
+}
+
+TEST_F(FETypeManagerTest, GetOrCreateClassOrInterfaceType) {
+  bool isCreate = false;
+  MIRStructType *structType1 = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType("Ljava_2Flang_2FObject_3B",
+                                                                                           false,
+                                                                                           FETypeFlag::kSrcUnknown,
+                                                                                           isCreate);
+  EXPECT_EQ(isCreate, false);
+  ASSERT_NE(structType1, nullptr);
+  std::string mplName1 = structType1->GetCompactMplTypeName();
+  EXPECT_EQ(mplName1, "Ljava_2Flang_2FObject_3B");
+  EXPECT_EQ(structType1->GetKind(), kTypeClass);
+  MIRStructType *structType2 = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType("LNewClass2",
+                                                                                           false,
+                                                                                           FETypeFlag::kSrcUnknown,
+                                                                                           isCreate);
+  EXPECT_EQ(isCreate, true);
+  ASSERT_NE(structType2, nullptr);
+  std::string mplName2 = structType2->GetCompactMplTypeName();
+  EXPECT_EQ(mplName2, "LNewClass2");
+  EXPECT_EQ(structType2->GetKind(), kTypeClassIncomplete);
+}
+
+TEST_F(FETypeManagerTest, GetOrCreateSameType_LoadInputType) {
+  // bacause flag kSrcInput > kSrcMplt in same name type, type is overridden
+  bool isCreate = false;
+  MIRStructType *structType1 = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType("LSameType1",
+                                                                                           false,
+                                                                                           FETypeFlag::kSrcMplt,
+                                                                                           isCreate);
+  EXPECT_EQ(isCreate, true);
+  ASSERT_NE(structType1, nullptr);
+  std::string mplName1 = structType1->GetCompactMplTypeName();
+  EXPECT_EQ(mplName1, "LSameType1");
+  EXPECT_EQ(structType1->GetKind(), kTypeClassIncomplete);
+
+  isCreate = false;
+  MIRStructType *structType2 = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType("LSameType1",
+                                                                                           true,
+                                                                                           FETypeFlag::kSrcInput,
+                                                                                           isCreate);
+  EXPECT_EQ(isCreate, true);
+  ASSERT_NE(structType2, nullptr);
+  std::string mplName2 = structType2->GetCompactMplTypeName();
+  EXPECT_EQ(mplName2, "LSameType1");
+  EXPECT_EQ(structType2->GetKind(), kTypeInterfaceIncomplete);
+}
+
+TEST_F(FETypeManagerTest, GetOrCreateSameType_LoadSysType) {
+  // bacause flag kSrcMpltSys > kSrcInput in same name type, type is not overridden
+  bool isCreate = false;
+  MIRStructType *structType1 = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType("LSameType2",
+                                                                                           false,
+                                                                                           FETypeFlag::kSrcMpltSys,
+                                                                                           isCreate);
+  EXPECT_EQ(isCreate, true);
+  ASSERT_NE(structType1, nullptr);
+  std::string mplName1 = structType1->GetCompactMplTypeName();
+  EXPECT_EQ(mplName1, "LSameType2");
+  EXPECT_EQ(structType1->GetKind(), kTypeClassIncomplete);
+
+  isCreate = false;
+  MIRStructType *structType2 = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType("LSameType2",
+                                                                                           true,
+                                                                                           FETypeFlag::kSrcInput,
+                                                                                           isCreate);
+  EXPECT_EQ(isCreate, false);
+  ASSERT_NE(structType2, nullptr);
+  std::string mplName2 = structType2->GetCompactMplTypeName();
+  EXPECT_EQ(mplName2, "LSameType2");
+  EXPECT_EQ(structType2->GetKind(), kTypeClassIncomplete);
+}
+
+TEST_F(FETypeManagerTest, GetOrCreateClassOrInterfacePtrType) {
+  bool isCreate = false;
+  MIRType *ptrType = FEManager::GetTypeManager().GetOrCreateClassOrInterfacePtrType("Ljava_2Flang_2FObject_3B",
+                                                                                    false, FETypeFlag::kSrcUnknown,
+                                                                                    isCreate);
+  ASSERT_NE(ptrType, nullptr);
+  RedirectCout();
+  ptrType->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  RestoreCout();
+}
+
+TEST_F(FETypeManagerTest, GetOrCreateTypeFromName) {
+  // Prim Type
+  MIRType *typePrim = FEManager::GetTypeManager().GetOrCreateTypeFromName("I",
+                                                                          FETypeFlag::kSrcUnknown, false);
+  ASSERT_NE(typePrim, nullptr);
+  EXPECT_EQ(typePrim, GlobalTables::GetTypeTable().GetInt32());
+  // Object Type
+  MIRType *typeObject = FEManager::GetTypeManager().GetOrCreateTypeFromName("Ljava_2Flang_2FObject_3B",
+                                                                            FETypeFlag::kSrcUnknown, true);
+  ASSERT_NE(typeObject, nullptr);
+  RedirectCout();
+  typeObject->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  RestoreCout();
+  // Array Type
+  MIRType *typeArray = FEManager::GetTypeManager().GetOrCreateTypeFromName("ALjava_2Flang_2FObject_3B",
+                                                                           FETypeFlag::kSrcUnknown, true);
+  ASSERT_NE(typeArray, nullptr);
+  RedirectCout();
+  typeArray->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  RestoreCout();
+  // Array Type2
+  MIRType *typeArray2 = FEManager::GetTypeManager().GetOrCreateTypeFromName("AALjava_2Flang_2FObject_3B",
+                                                                            FETypeFlag::kSrcUnknown, true);
+  ASSERT_NE(typeArray2, nullptr);
+  RedirectCout();
+  typeArray2->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <$Ljava_2Flang_2FObject_3B>>>>>>");
+  RestoreCout();
+}
+
+TEST_F(FETypeManagerTest, GetOrCreateComplexStructType) {
+  MIRType *elemType = GlobalTables::GetTypeTable().GetInt32();
+  MIRType *type = FEManager::GetTypeManager().GetOrCreateComplexStructType(*elemType);
+  ASSERT_NE(type, nullptr);
+  EXPECT_EQ(type->IsStructType(), true);
+  std::string mplName = type->GetCompactMplTypeName();
+  EXPECT_EQ(mplName, "Complex|I");
+  MIRStructType *structType = static_cast<MIRStructType*>(type);
+  ASSERT_EQ(structType->GetFields().size(), 2);
+  EXPECT_EQ(GlobalTables::GetStrTable().GetStringFromStrIdx(structType->GetFields()[0].first), "real");
+  EXPECT_EQ(structType->GetFields()[0].second.first == PTY_i32, true);
+  EXPECT_EQ(GlobalTables::GetStrTable().GetStringFromStrIdx(structType->GetFields()[1].first), "imag");
+  EXPECT_EQ(structType->GetFields()[1].second.first == PTY_i32, true);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/fe_utils_test.cpp b/src/hir2mpl/test/common/fe_utils_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b5c39e71cebdef3ecb27c1a9064b20d2bfb63b54
--- /dev/null
+++ b/src/hir2mpl/test/common/fe_utils_test.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_utils.h"
+
+namespace maple {
+TEST(FEUtils, Split) {
+  std::string str = "A,B,C";
+  std::vector<std::string> results = FEUtils::Split(str, ',');
+  ASSERT_EQ(results.size(), 3);
+  EXPECT_EQ(results[0], "A");
+  EXPECT_EQ(results[1], "B");
+  EXPECT_EQ(results[2], "C");
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/feir_builder_test.cpp b/src/hir2mpl/test/common/feir_builder_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0e0651671f9911dad9ff676c892ffa3dd871f229
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_builder_test.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include <unordered_set>
+#include <unordered_map>
+#include "feir_test_base.h"
+#include "feir_stmt.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "feir_builder.h"
+#include "hir2mpl_ut_regx.h"
+
+namespace maple {
+class FEIRBuilderTest : public FEIRTestBase {
+ public:
+  FEIRBuilderTest() = default;
+  virtual ~FEIRBuilderTest() = default;
+};
+
+// ---------- FEIRExprConst ----------
+TEST_F(FEIRBuilderTest, CreateExprConst_Any) {
+  RedirectCout();
+  UniqueFEIRExpr expr1 = FEIRBuilder::CreateExprConstAnyScalar(PTY_i8, 127);
+  expr1->GenMIRNode(mirBuilder)->Dump();
+  EXPECT_EQ(GetBufferString(), "constval i8 127\n");
+  ClearBufferString();
+  UniqueFEIRExpr expr2 = FEIRBuilder::CreateExprConstAnyScalar(PTY_i64, 127);
+  expr2->GenMIRNode(mirBuilder)->Dump();
+  EXPECT_EQ(GetBufferString(), "constval i64 127\n");
+  ClearBufferString();
+  UniqueFEIRExpr expr3 = FEIRBuilder::CreateExprConstAnyScalar(PTY_f32, 127);
+  expr3->GenMIRNode(mirBuilder)->Dump();
+  EXPECT_EQ(GetBufferString(), "constval f32 127f\n");
+  ClearBufferString();
+  UniqueFEIRExpr expr4 = FEIRBuilder::CreateExprConstAnyScalar(PTY_f64, 127);
+  expr4->GenMIRNode(mirBuilder)->Dump();
+  EXPECT_EQ(GetBufferString(), "constval f64 127\n");
+  ClearBufferString();
+  UniqueFEIRExpr expr5 = FEIRBuilder::CreateExprConstAnyScalar(PTY_u8, -1);
+  expr5->GenMIRNode(mirBuilder)->Dump();
+  EXPECT_EQ(GetBufferString(), "constval u8 255\n");
+  ClearBufferString();
+  UniqueFEIRExpr expr6 = FEIRBuilder::CreateExprConstAnyScalar(PTY_i8, -1);
+  expr6->GenMIRNode(mirBuilder)->Dump();
+  EXPECT_EQ(GetBufferString(), "constval i8 -1\n");
+  UniqueFEIRExpr expr7 = FEIRBuilder::CreateExprConstAnyScalar(PTY_v4i32, 0);
+  expr7->GenMIRNode(mirBuilder)->Dump();
+  EXPECT_EQ(GetBufferString(), "intrinsicop v4i32 vector_from_scalar_v4i32 (constval i32 0)\n");
+  RestoreCout();
+}
+
+// ---------- FEIRStmtDAssign ----------
+TEST_F(FEIRBuilderTest, CreateExprDRead) {
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(FEIRBuilder::CreateVarReg(0, PTY_i32));
+  BaseNode *mirNode = expr->GenMIRNode(mirBuilder);
+  RedirectCout();
+  mirNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dread i32 %Reg0_I") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRStmtRetype ----------
+TEST_F(FEIRBuilderTest, CreateRetypeFloat2Int) {
+  UniqueFEIRVar dstVar = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  UniqueFEIRVar srcVar = FEIRBuilder::CreateVarReg(0, PTY_f32);
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtRetype(std::move(dstVar), std::move(srcVar));
+  RedirectCout();
+  std::list<StmtNode*> mirStmts = stmt->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirStmts.size(), 1);
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_I 0 (cvt i32 f32 (dread f32 %Reg0_F))");
+  EXPECT_EQ(dumpStr.find(pattern), 0);
+  RestoreCout();
+}
+
+TEST_F(FEIRBuilderTest, CreateRetypeShort2Float) {
+  UniqueFEIRVar dstVar = FEIRBuilder::CreateVarReg(0, PTY_f32);
+  UniqueFEIRVar srcVar = FEIRBuilder::CreateVarReg(0, PTY_i16);
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtRetype(std::move(dstVar), std::move(srcVar));
+  RedirectCout();
+  std::list<StmtNode*> mirStmts = stmt->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirStmts.size(), 1);
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_F 0 (cvt f32 i16 (dread i32 %Reg0_S))");
+  EXPECT_EQ(dumpStr.find(pattern), 0);
+  RestoreCout();
+}
+
+TEST_F(FEIRBuilderTest, CreateRetypeInt2Short) {
+  UniqueFEIRVar dstVar = FEIRBuilder::CreateVarReg(0, PTY_i16);
+  UniqueFEIRVar srcVar = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtRetype(std::move(dstVar), std::move(srcVar));
+  RedirectCout();
+  std::list<StmtNode*> mirStmts = stmt->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirStmts.size(), 1);
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_S 0 (intrinsicop i16 JAVA_MERGE (dread i32 %Reg0_I))");
+  EXPECT_EQ(dumpStr.find(pattern), 0);
+  RestoreCout();
+}
+
+TEST_F(FEIRBuilderTest, CreateRetypeShort2Ref) {
+  UniqueFEIRVar dstVar = FEIRBuilder::CreateVarReg(0, PTY_ref);
+  dstVar->SetType(FEIRBuilder::CreateTypeByJavaName("Ljava/lang/String;", false));
+  UniqueFEIRVar srcVar = FEIRBuilder::CreateVarReg(0, PTY_i16);
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtRetype(std::move(dstVar), std::move(srcVar));
+  RedirectCout();
+  std::list<StmtNode*> mirStmts = stmt->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirStmts.size(), 1);
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  EXPECT_EQ(dumpStr.find("dassign %Reg0_R"), 0);
+  EXPECT_EQ(dumpStr.find(" 0 (cvt ref i16 (dread i32 %Reg0_S))", 15) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(FEIRBuilderTest, CreateRetypeRef2Ref) {
+  UniqueFEIRVar dstVar = FEIRBuilder::CreateVarReg(0, PTY_ref);
+  dstVar->SetType(FEIRBuilder::CreateTypeByJavaName("Ljava/lang/String;", false));
+  UniqueFEIRVar srcVar = FEIRBuilder::CreateVarReg(0, PTY_ref);
+  srcVar->SetType(FEIRBuilder::CreateTypeByJavaName("Ljava/lang/Object;", false));
+  UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtRetype(std::move(dstVar), std::move(srcVar));
+  RedirectCout();
+  std::list<StmtNode*> mirStmts = stmt->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirStmts.size(), 1);
+  mirStmts.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  // dassign %Reg0_R46 0 (retype ref <* <$Ljava_2Flang_2FString_3B>> (dread ref %Reg0_R40))
+  EXPECT_EQ(dumpStr.find("dassign %Reg0_R"), 0);
+  EXPECT_EQ(dumpStr.find(" 0 (retype ref <* <$Ljava_2Flang_2FString_3B>> (dread ref %Reg0_R", 15) != std::string::npos,
+            true);
+  RestoreCout();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/common/feir_cfg_test.cpp b/src/hir2mpl/test/common/feir_cfg_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d3c328b911675430f818c7321113229bf041176e
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_cfg_test.cpp
@@ -0,0 +1,576 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "feir_cfg.h"
+#include "redirect_buffer.h"
+#include "hir2mpl_ut_environment.h"
+
+namespace maple {
+class GeneralStmtHead : public FEIRStmt {
+ public:
+  GeneralStmtHead() : FEIRStmt(kStmtPesudo) {}
+  ~GeneralStmtHead() = default;
+};
+
+class GeneralStmtTail : public FEIRStmt {
+ public:
+  GeneralStmtTail() : FEIRStmt(kStmtPesudo) {}
+  ~GeneralStmtTail() = default;
+};
+
+class GeneralStmtAuxPre : public FEIRStmt {
+ public:
+  GeneralStmtAuxPre() : FEIRStmt(kStmtPesudo) {
+    isAuxPre = true;
+  }
+  ~GeneralStmtAuxPre() = default;
+};
+
+class GeneralStmtAuxPost : public FEIRStmt {
+ public:
+  GeneralStmtAuxPost() : FEIRStmt(kStmtPesudo) {
+    isAuxPost = true;
+  }
+  ~GeneralStmtAuxPost() = default;
+};
+
+class FEIRCFGDemo : public FEIRCFG {
+ public:
+  FEIRCFGDemo(MapleAllocator &argAllocator, FEIRStmt *argStmtHead, FEIRStmt *argStmtTail)
+      : FEIRCFG(argStmtHead, argStmtTail),
+        allocator(argAllocator),
+        mapIdxStmt(allocator.Adapter()) {}
+  ~FEIRCFGDemo() = default;
+
+  void LoadGenStmtDemo1();
+  void LoadGenStmtDemo2();
+  void LoadGenStmtDemo3();
+  void LoadGenStmtDemo4();
+  void LoadGenStmtDemo5();
+  void LoadGenStmtDemo6();
+  void LoadGenStmtDemo7();
+  void LoadGenStmtDemo8();
+
+  FEIRStmt *GetStmtByIdx(uint32 idx) {
+    CHECK_FATAL(mapIdxStmt.find(idx) != mapIdxStmt.end(), "invalid idx");
+    return mapIdxStmt[idx];
+  }
+
+  template <typename T>
+  T *NewTemporaryStmt(uint32 idx) {
+    FEIRStmt *ptrStmt = allocator.New<T>();
+    ptrStmt->SetFallThru(true);
+    stmtTail->InsertBefore(ptrStmt);
+    mapIdxStmt[idx] = ptrStmt;
+    return static_cast<T*>(ptrStmt);
+  }
+
+ private:
+  MapleAllocator allocator;
+  MapleMap<uint32, FEIRStmt*> mapIdxStmt;
+};
+
+class FEIRCFGTest : public testing::Test, public RedirectBuffer {
+ public:
+  static MemPool *mp;
+  static FEIRStmt *genStmtHead;
+  static FEIRStmt *genStmtTail;
+  MapleAllocator allocator;
+  FEIRCFGDemo demoCFG;
+  FEIRCFGTest()
+      : allocator(mp),
+        demoCFG(allocator, genStmtHead, genStmtTail) {}
+  ~FEIRCFGTest() = default;
+
+  static void SetUpTestCase() {
+    mp = FEUtils::NewMempool("MemPool for FEIRCFGTest", false /* isLocalPool */);
+    genStmtHead = mp->New<GeneralStmtHead>();
+    genStmtTail = mp->New<GeneralStmtTail>();
+  }
+
+  static void TearDownTestCase() {
+    delete mp;
+    mp = nullptr;
+  }
+
+  virtual void SetUp() {
+    // reset head and tail stmt
+    genStmtHead->SetNext(genStmtTail);
+    genStmtTail->SetPrev(genStmtHead);
+  }
+};
+MemPool *FEIRCFGTest::mp = nullptr;
+FEIRStmt *FEIRCFGTest::genStmtHead = nullptr;
+FEIRStmt *FEIRCFGTest::genStmtTail = nullptr;
+
+/* GenStmtDemo1:BB
+ * 0   StmtHead
+ * 1   Stmt (fallthru = true)
+ * 2   Stmt (fallthru = false)
+ * 3   StmtTail
+ */
+void FEIRCFGDemo::LoadGenStmtDemo1() {
+  mapIdxStmt.clear();
+  (void)NewTemporaryStmt<FEIRStmt>(1);
+  FEIRStmt *stmt2 = NewTemporaryStmt<FEIRStmt>(2);
+  stmt2->SetFallThru(false);
+}
+
+TEST_F(FEIRCFGTest, CFGBuildForBB) {
+  demoCFG.LoadGenStmtDemo1();
+  demoCFG.Init();
+  demoCFG.LabelStmtID();
+  demoCFG.BuildBB();
+  bool resultCFG = demoCFG.BuildCFG();
+  ASSERT_EQ(resultCFG, true);
+  demoCFG.LabelBBID();
+  FEIRBB *bb1 = static_cast<FEIRBB*>(demoCFG.GetDummyHead()->GetNext());
+  EXPECT_EQ(bb1->GetNext(), demoCFG.GetDummyTail());
+  EXPECT_EQ(bb1->GetStmtHead()->GetID(), 1);
+  EXPECT_EQ(bb1->GetStmtTail()->GetID(), 2);
+  EXPECT_EQ(demoCFG.HasDeadBB(), false);
+}
+
+/* GenStmtDemo2:BB_StmtAux
+ * 0   StmtHead
+ * 1   StmtAuxPre
+ * 2   Stmt (fallthru = true)
+ * 3   Stmt (fallthru = false)
+ * 4   StmtAuxPost
+ * 5   StmtTail
+ */
+void FEIRCFGDemo::LoadGenStmtDemo2() {
+  mapIdxStmt.clear();
+  (void)NewTemporaryStmt<GeneralStmtAuxPre>(1);
+  (void)NewTemporaryStmt<FEIRStmt>(2);
+  FEIRStmt *stmt3 = NewTemporaryStmt<FEIRStmt>(3);
+  (void)NewTemporaryStmt<GeneralStmtAuxPost>(4);
+  stmt3->SetFallThru(false);
+}
+
+TEST_F(FEIRCFGTest, CFGBuildForBB_StmtAux) {
+  demoCFG.LoadGenStmtDemo2();
+  demoCFG.Init();
+  demoCFG.LabelStmtID();
+  demoCFG.BuildBB();
+  bool resultCFG = demoCFG.BuildCFG();
+  ASSERT_EQ(resultCFG, true);
+  demoCFG.LabelBBID();
+  FEIRBB *bb1 = static_cast<FEIRBB*>(demoCFG.GetDummyHead()->GetNext());
+  EXPECT_EQ(bb1->GetNext(), demoCFG.GetDummyTail());
+  EXPECT_EQ(bb1->GetStmtHead()->GetID(), 1);
+  EXPECT_EQ(bb1->GetStmtTail()->GetID(), 4);
+  EXPECT_EQ(bb1->GetStmtNoAuxHead()->GetID(), 2);
+  EXPECT_EQ(bb1->GetStmtNoAuxTail()->GetID(), 3);
+  EXPECT_EQ(demoCFG.HasDeadBB(), false);
+}
+
+/* GenStmtDemo3:CFG
+ *     --- BB0 ---
+ * 0   StmtHead
+ *     --- BB1 ---
+ * 1   StmtAuxPre
+ * 2   StmtMultiOut (fallthru = true, out = {8})
+ * 3   StmtAuxPost
+ *     --- BB2 ---
+ * 4   StmtAuxPre
+ * 5   Stmt (fallthru = false)
+ * 6   StmtAuxPost
+ *     --- BB3 ---
+ * 7   StmtAuxPre
+ * 8   StmtMultiIn (fallthru = true, in = {2})
+ * 9   Stmt (fallthru = false)
+ * 10  StmtAuxPos
+ *     --- BB4 ---
+ * 11  StmtTail
+ *
+ * GenStmtDemo3_CFG:
+ *      BB0
+ *       |
+ *      BB1
+ *      / \
+ *   BB2   BB3
+ */
+void FEIRCFGDemo::LoadGenStmtDemo3() {
+  mapIdxStmt.clear();
+  // --- BB1 ---
+  (void)NewTemporaryStmt<GeneralStmtAuxPre>(1);
+  FEIRStmt *stmt2 = NewTemporaryStmt<FEIRStmt>(2);
+  (void)NewTemporaryStmt<GeneralStmtAuxPost>(3);
+  // --- BB2 ---
+  (void)NewTemporaryStmt<GeneralStmtAuxPre>(4);
+  FEIRStmt *stmt5 = NewTemporaryStmt<FEIRStmt>(5);
+  stmt5->SetFallThru(false);
+  (void)NewTemporaryStmt<GeneralStmtAuxPost>(6);
+  // --- BB3 ---
+  (void)NewTemporaryStmt<GeneralStmtAuxPre>(7);
+  FEIRStmt *stmt8 = NewTemporaryStmt<FEIRStmt>(8);
+  FEIRStmt *stmt9 = NewTemporaryStmt<FEIRStmt>(9);
+  stmt9->SetFallThru(false);
+  (void)NewTemporaryStmt<GeneralStmtAuxPost>(10);
+  // Link
+  stmt2->AddExtraSucc(*stmt8);
+  stmt8->AddExtraPred(*stmt2);
+}
+
+TEST_F(FEIRCFGTest, CFGBuildForCFG) {
+  demoCFG.LoadGenStmtDemo3();
+  demoCFG.LabelStmtID();
+  demoCFG.Init();
+  demoCFG.BuildBB();
+  bool resultCFG = demoCFG.BuildCFG();
+  ASSERT_EQ(resultCFG, true);
+  demoCFG.LabelBBID();
+  // Check BB
+  FEIRBB *bb1 = static_cast<FEIRBB*>(demoCFG.GetDummyHead()->GetNext());
+  ASSERT_NE(bb1, demoCFG.GetDummyTail());
+  FEIRBB *bb2 = static_cast<FEIRBB*>(bb1->GetNext());
+  ASSERT_NE(bb2, demoCFG.GetDummyTail());
+  FEIRBB *bb3 = static_cast<FEIRBB*>(bb2->GetNext());
+  ASSERT_NE(bb3, demoCFG.GetDummyTail());
+  // Check BB's detail
+  EXPECT_EQ(bb1->GetStmtHead()->GetID(), 1);
+  EXPECT_EQ(bb1->GetStmtNoAuxHead()->GetID(), 2);
+  EXPECT_EQ(bb1->GetStmtNoAuxTail()->GetID(), 2);
+  EXPECT_EQ(bb1->GetStmtTail()->GetID(), 3);
+  EXPECT_EQ(bb2->GetStmtHead()->GetID(), 4);
+  EXPECT_EQ(bb2->GetStmtNoAuxHead()->GetID(), 5);
+  EXPECT_EQ(bb2->GetStmtNoAuxTail()->GetID(), 5);
+  EXPECT_EQ(bb2->GetStmtTail()->GetID(), 6);
+  EXPECT_EQ(bb3->GetStmtHead()->GetID(), 7);
+  EXPECT_EQ(bb3->GetStmtNoAuxHead()->GetID(), 8);
+  EXPECT_EQ(bb3->GetStmtNoAuxTail()->GetID(), 9);
+  EXPECT_EQ(bb3->GetStmtTail()->GetID(), 10);
+  // Check CFG
+  EXPECT_EQ(bb1->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb1->IsPredBB(0U), true);
+  EXPECT_EQ(bb1->GetSuccBBs().size(), 2);
+  EXPECT_EQ(bb1->IsSuccBB(2), true);
+  EXPECT_EQ(bb1->IsSuccBB(3), true);
+  EXPECT_EQ(bb2->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb2->IsPredBB(1), true);
+  EXPECT_EQ(bb2->GetSuccBBs().size(), 0);
+  EXPECT_EQ(bb3->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb3->IsPredBB(1), true);
+  EXPECT_EQ(bb3->GetSuccBBs().size(), 0);
+  EXPECT_EQ(demoCFG.HasDeadBB(), false);
+}
+
+/* GenStmtDemo4:CFG_Fail
+ * 0   StmtHead
+ * 1   Stmt (fallthru = true)
+ * 2   Stmt (fallthru = true)
+ * 3   StmtTail
+ */
+void FEIRCFGDemo::LoadGenStmtDemo4() {
+  mapIdxStmt.clear();
+  (void)NewTemporaryStmt<FEIRStmt>(1);
+  (void)NewTemporaryStmt<FEIRStmt>(2);
+}
+
+TEST_F(FEIRCFGTest, CFGBuildForCFG_Fail) {
+  demoCFG.Init();
+  demoCFG.LoadGenStmtDemo4();
+  demoCFG.BuildBB();
+  bool resultCFG = demoCFG.BuildCFG();
+  ASSERT_EQ(resultCFG, false);
+}
+
+/* GenStmtDemo5:CFG_DeadBB
+ *     --- BB0 ---
+ * 0   StmtHead
+ *     --- BB1 ---
+ * 1   Stmt (fallthru = true)
+ * 2   Stmt (fallthru = false)
+ *     --- BB2 ---
+ * 3   Stmt (fallthru = false)
+ *     --- BB3 ---
+ * 4   StmtTail
+ *
+ * GenStmtDemo5_CFG:
+ *      BB0
+ *       |
+ *      BB1  BB2(DeadBB)
+ */
+void FEIRCFGDemo::LoadGenStmtDemo5() {
+  mapIdxStmt.clear();
+  (void)NewTemporaryStmt<FEIRStmt>(1);
+  FEIRStmt *stmt2 = NewTemporaryStmt<FEIRStmt>(2);
+  stmt2->SetFallThru(false);
+  FEIRStmt *stmt3 = NewTemporaryStmt<FEIRStmt>(3);
+  stmt3->SetFallThru(false);
+}
+
+TEST_F(FEIRCFGTest, CFGBuildForCFG_DeadBB) {
+  demoCFG.Init();
+  demoCFG.LoadGenStmtDemo5();
+  demoCFG.BuildBB();
+  bool resultCFG = demoCFG.BuildCFG();
+  ASSERT_EQ(resultCFG, true);
+  demoCFG.LabelStmtID();
+  demoCFG.LabelBBID();
+  // Check BB
+  FEIRBB *bb1 = static_cast<FEIRBB*>(demoCFG.GetDummyHead()->GetNext());
+  ASSERT_NE(bb1, demoCFG.GetDummyTail());
+  FEIRBB *bb2 = static_cast<FEIRBB*>(bb1->GetNext());
+  ASSERT_NE(bb2, demoCFG.GetDummyTail());
+  // Check BB's detail
+  EXPECT_EQ(bb1->GetStmtHead()->GetID(), 1);
+  EXPECT_EQ(bb1->GetStmtTail()->GetID(), 2);
+  EXPECT_EQ(bb2->GetStmtHead()->GetID(), 3);
+  EXPECT_EQ(bb2->GetStmtTail()->GetID(), 3);
+  // Check CFG
+  EXPECT_EQ(bb1->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb1->IsPredBB(0U), true);
+  EXPECT_EQ(bb2->GetSuccBBs().size(), 0);
+  EXPECT_EQ(demoCFG.HasDeadBB(), true);
+}
+
+/* GenStmtDemo6:CFG
+ *     --- BB0 ---
+ * 0   StmtHead
+ *     --- BB1 ---
+ * 1   StmtMultiOut (fallthru = true, out = {3})
+ *     --- BB2 ---
+ * 2   Stmt (fallthru = true)
+ *     --- BB3 ---
+ * 3   StmtMultiIn (fallthru = true, in = {1})
+ * 4   Stmt (fallthru = false)
+ *     --- BB4 ---
+ * 5   StmtTail
+ *
+ * GenStmtDemo6_CFG:
+ *      BB0
+ *       |
+ *      BB1
+ *      / \
+ *   BB2   |
+ *      \ /
+ *      BB3
+ */
+void FEIRCFGDemo::LoadGenStmtDemo6() {
+  mapIdxStmt.clear();
+  // --- BB1 ---
+  FEIRStmt *stmt1 = NewTemporaryStmt<FEIRStmt>(1);
+  // --- BB2 ---
+  (void)NewTemporaryStmt<FEIRStmt>(2);
+  // --- BB3 ---
+  FEIRStmt *stmt3 = NewTemporaryStmt<FEIRStmt>(3);
+  FEIRStmt *stmt4 = NewTemporaryStmt<FEIRStmt>(4);
+  stmt4->SetFallThru(false);
+  // Link
+  stmt1->AddExtraSucc(*stmt3);
+  stmt3->AddExtraPred(*stmt1);
+}
+
+TEST_F(FEIRCFGTest, CFGBuildForCFG1) {
+  demoCFG.Init();
+  demoCFG.LoadGenStmtDemo6();
+  demoCFG.LabelStmtID();
+  demoCFG.BuildBB();
+  bool resultCFG = demoCFG.BuildCFG();
+  ASSERT_EQ(resultCFG, true);
+  demoCFG.LabelBBID();
+  // Check BB
+  FEIRBB *bb1 = static_cast<FEIRBB*>(demoCFG.GetDummyHead()->GetNext());
+  ASSERT_NE(bb1, demoCFG.GetDummyTail());
+  FEIRBB *bb2 = static_cast<FEIRBB*>(bb1->GetNext());
+  ASSERT_NE(bb2, demoCFG.GetDummyTail());
+  FEIRBB *bb3 = static_cast<FEIRBB*>(bb2->GetNext());
+  ASSERT_NE(bb3, demoCFG.GetDummyTail());
+  // Check CFG
+  EXPECT_EQ(bb1->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb1->IsPredBB(0U), true);
+  EXPECT_EQ(bb1->GetSuccBBs().size(), 2);
+  EXPECT_EQ(bb1->IsSuccBB(2), true);
+  EXPECT_EQ(bb1->IsSuccBB(3), true);
+  EXPECT_EQ(bb2->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb2->IsPredBB(1), true);
+  EXPECT_EQ(bb2->GetSuccBBs().size(), 1);
+  EXPECT_EQ(bb2->IsSuccBB(3), true);
+  EXPECT_EQ(bb3->GetPredBBs().size(), 2);
+  EXPECT_EQ(bb3->IsPredBB(1), true);
+  EXPECT_EQ(bb3->IsPredBB(2), true);
+  EXPECT_EQ(demoCFG.HasDeadBB(), false);
+}
+
+/* GenStmtDemo7:CFG
+ *     --- BB0 ---
+ * 0   StmtHead
+ *     --- BB1 ---
+ * 1   StmtMultiOut (fallthru = true, out = {5})
+ *     --- BB2 ---
+ * 2   Stmt (fallthru = true)
+ *     --- BB3 ---
+ * 3   StmtMultiIn (fallthru = true, in = {6})
+ * 4   Stmt (fallthru = false)
+ *     --- BB4 ---
+ * 5   StmtMultiIn (fallthru = true, in = {1})
+ * 6   Stmt (fallthru = false, out = {3})
+ *     --- BB5 ---
+ * 7   StmtTail
+ *
+ * GenStmtDemo7_CFG:
+ *      BB0
+ *       |
+ *      BB1
+ *      / \
+ *   BB2   BB4
+ *      \ /
+ *      BB3
+ */
+void FEIRCFGDemo::LoadGenStmtDemo7() {
+  mapIdxStmt.clear();
+  // --- BB1 ---
+  FEIRStmt *stmt1 = NewTemporaryStmt<FEIRStmt>(1);
+  // --- BB2 ---
+  (void)NewTemporaryStmt<FEIRStmt>(2);
+  // --- BB3 ---
+  FEIRStmt *stmt3 = NewTemporaryStmt<FEIRStmt>(3);
+  FEIRStmt *stmt4 = NewTemporaryStmt<FEIRStmt>(4);
+  stmt4->SetFallThru(false);
+  // --- BB4 ---
+  FEIRStmt *stmt5 = NewTemporaryStmt<FEIRStmt>(5);
+  FEIRStmt *stmt6 = NewTemporaryStmt<FEIRStmt>(6);
+  stmt6->SetFallThru(false);
+  // Link
+  stmt1->AddExtraSucc(*stmt5);
+  stmt5->AddExtraPred(*stmt1);
+  stmt6->AddExtraSucc(*stmt3);
+  stmt3->AddExtraPred(*stmt6);
+}
+
+TEST_F(FEIRCFGTest, CFGBuildForCFG2) {
+  demoCFG.Init();
+  demoCFG.LoadGenStmtDemo7();
+  demoCFG.LabelStmtID();
+  demoCFG.BuildBB();
+  bool resultCFG = demoCFG.BuildCFG();
+  ASSERT_EQ(resultCFG, true);
+  demoCFG.LabelBBID();
+  // Check BB
+  FEIRBB *bb1 = static_cast<FEIRBB*>(demoCFG.GetDummyHead()->GetNext());
+  ASSERT_NE(bb1, demoCFG.GetDummyTail());
+  FEIRBB *bb2 = static_cast<FEIRBB*>(bb1->GetNext());
+  ASSERT_NE(bb2, demoCFG.GetDummyTail());
+  FEIRBB *bb3 = static_cast<FEIRBB*>(bb2->GetNext());
+  ASSERT_NE(bb3, demoCFG.GetDummyTail());
+  FEIRBB *bb4 = static_cast<FEIRBB*>(bb3->GetNext());
+  ASSERT_NE(bb4, demoCFG.GetDummyTail());
+  // Check CFG
+  EXPECT_EQ(bb2->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb2->IsPredBB(1), true);
+  EXPECT_EQ(bb2->GetSuccBBs().size(), 1);
+  EXPECT_EQ(bb2->IsSuccBB(3), true);
+  EXPECT_EQ(bb4->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb4->IsPredBB(1), true);
+  EXPECT_EQ(bb4->GetSuccBBs().size(), 1);
+  EXPECT_EQ(bb4->IsSuccBB(3), true);
+  EXPECT_EQ(bb3->GetPredBBs().size(), 2);
+  EXPECT_EQ(bb3->IsPredBB(2), true);
+  EXPECT_EQ(bb3->IsPredBB(4), true);
+  EXPECT_EQ(demoCFG.HasDeadBB(), false);
+}
+
+/* GenStmtDemo8:CFG
+ *     --- BB0 ---
+ * 0   StmtHead
+ *     --- BB1 ---
+ * 1   StmtMultiOut (fallthru = true, out = {6})
+ *     --- BB2 ---
+ * 2   StmtMultiIn (fallthru = true, in = {5})
+ * 3   Stmt (fallthru = true， out = {4})
+ *     --- BB3 ---
+ * 4   Stmt (fallthru = true, in = {3})
+ * 5   StmtMultiOut (fallthru = true, in = {2})
+ *     --- BB4 ---
+ * 6   StmtMultiIn (fallthru = true, in = {1})
+ * 7   Stmt (fallthru = false)
+ *     --- BB5 ---
+ * 8   StmtTail
+ *
+ * GenStmtDemo8_CFG_while:
+ *      BB0
+ *       |
+ *      BB1 -----
+ *       |       |
+ *      BB2 <-   |
+ *       |    |  |
+ *      BB3 --   |
+ *       |       |
+ *      BB4 <----
+ */
+void FEIRCFGDemo::LoadGenStmtDemo8() {
+  mapIdxStmt.clear();
+  // --- BB1 ---
+  FEIRStmt *stmt1 = NewTemporaryStmt<FEIRStmt>(1);
+  // --- BB2 ---
+  FEIRStmt *stmt2 = NewTemporaryStmt<FEIRStmt>(2);
+  FEIRStmt *stmt3 = NewTemporaryStmt<FEIRStmt>(3);
+  // --- BB3 ---
+  FEIRStmt *stmt4 = NewTemporaryStmt<FEIRStmt>(4);
+  FEIRStmt *stmt5 = NewTemporaryStmt<FEIRStmt>(5);
+  // --- BB4 ---
+  FEIRStmt *stmt6 = NewTemporaryStmt<FEIRStmt>(6);
+  FEIRStmt *stmt7 = NewTemporaryStmt<FEIRStmt>(7);
+  stmt7->SetFallThru(false);
+  // Link
+  stmt1->AddExtraSucc(*stmt6);
+  stmt6->AddExtraPred(*stmt1);
+  stmt5->AddExtraSucc(*stmt2);
+  stmt2->AddExtraPred(*stmt5);
+  stmt3->AddExtraSucc(*stmt4);
+  stmt4->AddExtraPred(*stmt3);
+}
+
+TEST_F(FEIRCFGTest, CFGBuildForCFG_while) {
+  demoCFG.Init();
+  demoCFG.LoadGenStmtDemo8();
+  demoCFG.LabelStmtID();
+  demoCFG.BuildBB();
+  bool resultCFG = demoCFG.BuildCFG();
+  ASSERT_EQ(resultCFG, true);
+  demoCFG.LabelBBID();
+  // Check BB
+  demoCFG.DumpBBs();
+  FEIRBB *bb1 = static_cast<FEIRBB*>(demoCFG.GetDummyHead()->GetNext());
+  ASSERT_NE(bb1, demoCFG.GetDummyTail());
+  FEIRBB *bb2 = static_cast<FEIRBB*>(bb1->GetNext());
+  ASSERT_NE(bb2, demoCFG.GetDummyTail());
+  FEIRBB *bb3 = static_cast<FEIRBB*>(bb2->GetNext());
+  ASSERT_NE(bb3, demoCFG.GetDummyTail());
+  FEIRBB *bb4 = static_cast<FEIRBB*>(bb3->GetNext());
+  ASSERT_NE(bb4, demoCFG.GetDummyTail());
+  // Check CFG
+  EXPECT_EQ(bb1->GetSuccBBs().size(), 2);
+  EXPECT_EQ(bb1->IsSuccBB(2), true);
+  EXPECT_EQ(bb1->IsSuccBB(4), true);
+  EXPECT_EQ(bb2->GetPredBBs().size(), 2);
+  EXPECT_EQ(bb2->IsPredBB(1), true);
+  EXPECT_EQ(bb2->IsPredBB(3), true);
+  EXPECT_EQ(bb2->GetSuccBBs().size(), 1);
+  EXPECT_EQ(bb2->IsSuccBB(3), true);
+  EXPECT_EQ(bb3->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb3->IsPredBB(2), true);
+  EXPECT_EQ(bb3->GetSuccBBs().size(), 2);
+  EXPECT_EQ(bb3->IsSuccBB(2), true);
+  EXPECT_EQ(bb3->IsSuccBB(4), true);
+  EXPECT_EQ(bb4->GetPredBBs().size(), 2);
+  EXPECT_EQ(bb4->IsPredBB(1), true);
+  EXPECT_EQ(bb4->IsPredBB(3), true);
+  EXPECT_EQ(demoCFG.HasDeadBB(), false);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/common/feir_lower_test.cpp b/src/hir2mpl/test/common/feir_lower_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5348b1b73b6dfd0f7806fda1095354ce5b93ed38
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_lower_test.cpp
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "feir_test_base.h"
+#include "hir2mpl_ut_environment.h"
+#include "hir2mpl_ut_regx.h"
+#include "fe_function.h"
+#include "feir_lower.h"
+#include "feir_var_reg.h"
+#include "feir_builder.h"
+
+namespace maple {
+class FEFunctionDemo : public FEFunction {
+ public:
+  FEFunctionDemo(MIRFunction &argMIRFunction)
+      : FEFunction(argMIRFunction, std::make_unique<FEFunctionPhaseResult>(true)) {}
+  ~FEFunctionDemo() = default;
+
+  bool PreProcessTypeNameIdx() override {
+    return false;
+  }
+
+  bool GenerateGeneralStmt(const std::string &phaseName) override {
+    return true;
+  }
+
+  void GenerateGeneralStmtFailCallBack() override {}
+  void GenerateGeneralDebugInfo() override {}
+  bool GenerateArgVarList(const std::string &phaseName) override {
+    return true;
+  }
+
+  bool HasThis() override {
+    return false;
+  }
+
+  bool IsNative() override {
+    return false;
+  }
+
+  bool VerifyGeneral() override {
+    return false;
+  }
+
+  void VerifyGeneralFailCallBack() override {}
+  bool EmitToFEIRStmt(const std::string &phaseName) override {
+    return true;
+  }
+
+  bool GenerateAliasVars(const std::string &phaseName) override {
+    return true;
+  }
+
+  void LoadGenStmtDemo1();
+  void LoadGenStmtDemo2();
+  void LoadGenStmtDemo3();
+};
+
+class FEIRLowerTest : public FEIRTestBase {
+ public:
+  FEFunctionDemo feFunc;
+
+  FEIRLowerTest()
+      : feFunc(*func) {
+    feFunc.Init();
+  }
+  ~FEIRLowerTest() = default;
+};
+
+// ifStmt
+void FEFunctionDemo::LoadGenStmtDemo1() {
+  UniqueFEIRVar varReg = FEIRBuilder::CreateVarReg(0, PTY_u1);
+  std::unique_ptr<FEIRExprDRead> exprDReadReg = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  // ThenStmts
+  UniqueFEIRVar dstVar = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  UniqueFEIRVar srcVar = std::make_unique<FEIRVarReg>(1, PTY_i32);
+  UniqueFEIRExpr exprDRead = std::make_unique<FEIRExprDRead>(std::move(srcVar));
+  UniqueFEIRStmt stmtDAssign = std::make_unique<FEIRStmtDAssign>(std::move(dstVar), exprDRead->Clone());
+  std::list<UniqueFEIRStmt> thenStmts;
+  thenStmts.emplace_back(std::move(stmtDAssign));
+  // ElseStmts
+  UniqueFEIRVar dstVar2 = FEIRBuilder::CreateVarReg(0, PTY_f32);
+  UniqueFEIRStmt stmtDAssign1 = std::make_unique<FEIRStmtDAssign>(std::move(dstVar2), std::move(exprDRead));
+  std::list<UniqueFEIRStmt> elseStmts;
+  elseStmts.emplace_back(std::move(stmtDAssign1));
+
+  std::list<UniqueFEIRStmt> stmts;
+  stmts.emplace_back(std::make_unique<FEIRStmtIf>(std::move(exprDReadReg), thenStmts, elseStmts));
+  AppendFEIRStmts(stmts);
+}
+
+// whileStmt/forStmt
+void FEFunctionDemo::LoadGenStmtDemo2() {
+  // conditionExpr: val > 10
+  UniqueFEIRVar varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  UniqueFEIRExpr exprDRead = FEIRBuilder::CreateExprDRead(varReg->Clone());
+  UniqueFEIRExpr exprConst = FEIRBuilder::CreateExprConstI32(10);
+  UniqueFEIRExpr conditionExpr = FEIRBuilder::CreateExprBinary(OP_gt, exprDRead->Clone(), exprConst->Clone());
+  // bodyStmts : --val
+  UniqueFEIRExpr exprConst2 = FEIRBuilder::CreateExprConstI32(1);
+  UniqueFEIRExpr subExpr = FEIRBuilder::CreateExprBinary(OP_sub, exprDRead->Clone(), exprConst2->Clone());
+  UniqueFEIRStmt bodyStmt = FEIRBuilder::CreateStmtDAssign(varReg->Clone(), subExpr->Clone());
+  std::list<UniqueFEIRStmt> bodayStmts;
+  bodayStmts.emplace_back(std::move(bodyStmt));
+  std::list<UniqueFEIRStmt> stmts;
+  stmts.emplace_back(std::make_unique<FEIRStmtDoWhile>(OP_while, std::move(conditionExpr), std::move(bodayStmts)));
+  AppendFEIRStmts(stmts);
+}
+
+// doWhileStmt
+void FEFunctionDemo::LoadGenStmtDemo3() {
+  // bodayStmts --val
+  UniqueFEIRVar varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  UniqueFEIRExpr exprDRead = FEIRBuilder::CreateExprDRead(varReg->Clone());
+  UniqueFEIRExpr exprConst = FEIRBuilder::CreateExprConstI32(1);
+  UniqueFEIRExpr subExpr = FEIRBuilder::CreateExprBinary(OP_sub, exprDRead->Clone(), exprConst->Clone());
+  UniqueFEIRStmt bodyStmt = FEIRBuilder::CreateStmtDAssign(varReg->Clone(), subExpr->Clone());
+  std::list<UniqueFEIRStmt> bodayStmts;
+  bodayStmts.emplace_back(std::move(bodyStmt));
+  // conditionExpr: val > 10
+  UniqueFEIRExpr exprConst2 = FEIRBuilder::CreateExprConstI32(10);
+  UniqueFEIRExpr conditionExpr = FEIRBuilder::CreateExprBinary(OP_gt, exprDRead->Clone(), exprConst2->Clone());
+  std::list<UniqueFEIRStmt> stmts;
+  stmts.emplace_back(std::make_unique<FEIRStmtDoWhile>(OP_dowhile, std::move(conditionExpr), std::move(bodayStmts)));
+  AppendFEIRStmts(stmts);
+}
+
+TEST_F(FEIRLowerTest, IfStmtLower) {
+  feFunc.LoadGenStmtDemo1();
+  bool res = feFunc.LowerFunc("fert lower");
+  ASSERT_EQ(res, true);
+  RedirectCout();
+  const FEIRStmt *head = feFunc.GetFEIRStmtHead();
+  FEIRStmt *stmt = static_cast<FEIRStmt*>(head->GetNext());
+  while (stmt != nullptr && stmt->GetKind() != kStmtPesudoFuncEnd) {
+    std::list<StmtNode*> baseNodes = stmt->GenMIRStmts(mirBuilder);
+    baseNodes.front()->Dump();
+    stmt = static_cast<FEIRStmt*>(stmt->GetNext());
+  }
+  std::string pattern =
+      "brfalse @.* \\(dread u32 %Reg0_Z\\)\n\n"\
+      "dassign %Reg0_I 0 \\(dread i32 %Reg1_I\\)\n\n"\
+      "goto @.*\n\n"\
+      "@.*\n"\
+      "dassign %Reg0_F 0 \\(dread i32 %Reg1_I\\)\n\n"\
+      "@.*\n";
+  ASSERT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  ASSERT_EQ(static_cast<FEIRStmtCondGotoForC*>(head->GetNext())->GetLabelName(),
+            static_cast<FEIRStmtLabel*>(feFunc.GetFEIRStmtTail()->GetPrev()->GetPrev()->GetPrev())->GetLabelName());
+  ASSERT_EQ(static_cast<FEIRStmtGotoForC*>(head->GetNext()->GetNext()->GetNext())->GetLabelName(),
+            static_cast<FEIRStmtLabel*>(feFunc.GetFEIRStmtTail()->GetPrev())->GetLabelName());
+  RestoreCout();
+}
+
+TEST_F(FEIRLowerTest, WhileAndForStmtLower) {
+  feFunc.LoadGenStmtDemo2();
+  bool res = feFunc.LowerFunc("fert lower");
+  ASSERT_EQ(res, true);
+  RedirectCout();
+  const FEIRStmt *head = feFunc.GetFEIRStmtHead();
+  FEIRStmt *stmt = static_cast<FEIRStmt*>(head->GetNext());
+  while (stmt != nullptr && stmt->GetKind() != kStmtPesudoFuncEnd) {
+    std::list<StmtNode*> baseNodes = stmt->GenMIRStmts(mirBuilder);
+    baseNodes.front()->Dump();
+    stmt = static_cast<FEIRStmt*>(stmt->GetNext());
+  }
+  std::string pattern =
+      "@.*\n"
+      "brfalse @.* \\(gt u1 i32 \\(dread i32 %Reg0_I, constval i32 10\\)\\)\n\n"\
+      "dassign %Reg0_I 0 \\(sub i32 \\(dread i32 %Reg0_I, constval i32 1\\)\\)\n\n"\
+      "goto @.*\n\n"\
+      "@.*\n";
+  ASSERT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  ASSERT_EQ(static_cast<FEIRStmtCondGotoForC*>(head->GetNext()->GetNext())->GetLabelName(),
+            static_cast<FEIRStmtLabel*>(feFunc.GetFEIRStmtTail()->GetPrev())->GetLabelName());
+  ASSERT_EQ(static_cast<FEIRStmtGotoForC*>(feFunc.GetFEIRStmtTail()->GetPrev()->GetPrev())->GetLabelName(),
+            static_cast<FEIRStmtLabel*>(head->GetNext())->GetLabelName());
+  RestoreCout();
+}
+
+TEST_F(FEIRLowerTest, DoWhileStmtLower) {
+  feFunc.LoadGenStmtDemo3();
+  bool res = feFunc.LowerFunc("fert lower");
+  ASSERT_EQ(res, true);
+  RedirectCout();
+  const FEIRStmt *head = feFunc.GetFEIRStmtHead();
+  FEIRStmt *stmt = static_cast<FEIRStmt*>(head->GetNext());
+  while (stmt != nullptr && stmt->GetKind() != kStmtPesudoFuncEnd) {
+    std::list<StmtNode*> baseNodes = stmt->GenMIRStmts(mirBuilder);
+    baseNodes.front()->Dump();
+    stmt = static_cast<FEIRStmt*>(stmt->GetNext());
+  }
+  std::string pattern =
+      "@.*\n"
+      "dassign %Reg0_I 0 \\(sub i32 \\(dread i32 %Reg0_I, constval i32 1\\)\\)\n\n"\
+      "brtrue @.* \\(gt u1 i32 \\(dread i32 %Reg0_I, constval i32 10\\)\\)\n\n";
+  ASSERT_EQ(HIR2MPLUTRegx::Match(GetBufferString(), pattern), true);
+  ASSERT_EQ(static_cast<FEIRStmtCondGotoForC*>(feFunc.GetFEIRStmtTail()->GetPrev())->GetLabelName(),
+            static_cast<FEIRStmtLabel*>(head->GetNext())->GetLabelName());
+  RestoreCout();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/common/feir_stmt_dfg_test.cpp b/src/hir2mpl/test/common/feir_stmt_dfg_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1039d3559e1be72aa16f4c3639b8bed8f723d223
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_stmt_dfg_test.cpp
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include <vector>
+#include <list>
+#include "feir_test_base.h"
+#include "feir_stmt.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "feir_builder.h"
+
+namespace maple {
+class FEIRDFGTest : public FEIRTestBase {
+ public:
+  std::vector<UniqueFEIRVar> vars;
+  std::vector<UniqueFEIRStmt> checkPoints;
+  FEIRDFGTest() = default;
+  virtual ~FEIRDFGTest() = default;
+  void Init(uint32 nVar, uint32 nCheckPoint) {
+    vars.clear();
+    checkPoints.clear();
+    vars.resize(nVar);
+    for (uint i = 0; i < nCheckPoint; i++) {
+      checkPoints.push_back(std::make_unique<FEIRStmtCheckPoint>());
+    }
+  }
+
+  void AddVar2DFGNodes(std::list<UniqueFEIRVar*> &nodes, uint32 idx, UniqueFEIRVar var, bool isDef) {
+    CHECK_FATAL(idx < vars.size(), "index out of range");
+    var->SetDef(isDef);
+    vars[idx].reset(var.release());
+    nodes.push_back(&vars[idx]);
+  }
+
+  void BuildDFG(const std::string &str) {
+    if (str.length() == 0) {
+      return;
+    }
+    std::string item;
+    std::string remainStr = str;
+    do {
+      size_t npos = remainStr.find(',');
+      item = remainStr.substr(0, npos);
+      if (item.length() > 0) {
+        size_t npos2 = item.find("->");
+        std::string strSrc = item.substr(0, npos2);
+        std::string strDst = item.substr(npos2 + 2);
+        uint32 src = std::atoi(strSrc.c_str());
+        uint32 dst = std::atoi(strDst.c_str());
+        TransformCheckPoint(checkPoints[dst])->AddPredCheckPoint(*(TransformCheckPoint(checkPoints[src])));
+      }
+      if (npos != std::string::npos) {
+        remainStr = remainStr.substr(npos + 1);
+      } else {
+        remainStr = "";
+      }
+    } while (remainStr.length() > 0);
+  }
+
+  FEIRStmtCheckPoint *TransformCheckPoint(const UniqueFEIRStmt &stmtCheckPoint) {
+    if (stmtCheckPoint == nullptr || stmtCheckPoint->GetKind() != FEIRNodeKind::kStmtCheckPoint) {
+      CHECK_FATAL(false, "invalid input");
+    }
+    return static_cast<FEIRStmtCheckPoint*>(stmtCheckPoint.get());
+  }
+};
+
+// ---------- FEIRDFGNode ----------
+TEST_F(FEIRDFGTest, FEIRDFGNode_VarReg_EqualsTo) {
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarReg(0, PTY_i64);
+  FEIRDFGNode node1(varReg1);
+  FEIRDFGNode node2(varReg2);
+  FEIRDFGNode node11(node1);
+  FEIRDFGNode node21(node2);
+  FEIRDFGNode node12 = node11;
+  FEIRDFGNode node22 = node21;
+  EXPECT_EQ(node12 == node22, true);
+}
+
+TEST_F(FEIRDFGTest, FEIRDFGNode_VarDiff_EqualsTo) {
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarName("testVar2", PTY_i32, false, false);
+  (void)GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("testVar3");
+  std::unique_ptr<FEIRVar> varReg3 = FEIRBuilder::CreateVarName("testVar3", PTY_i32, false, false);
+  FEIRDFGNode node1(varReg1);
+  FEIRDFGNode node2(varReg2);
+  FEIRDFGNode node3(varReg3);
+  EXPECT_EQ(node1 == node2, false);
+  EXPECT_EQ(node1 == node3, false);
+  EXPECT_EQ(node2 == node3, false);
+}
+
+TEST_F(FEIRDFGTest, FEIRDFGNode_VarReg_set) {
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarReg(0, PTY_i64);
+  std::unique_ptr<FEIRVar> varReg3 = FEIRBuilder::CreateVarReg(1, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg4 = FEIRBuilder::CreateVarReg(0, PTY_u1);
+  std::unordered_set<FEIRDFGNode, FEIRDFGNodeHash> set1;
+  set1.insert(FEIRDFGNode(varReg1));
+  set1.insert(FEIRDFGNode(varReg2));
+  EXPECT_EQ(set1.size(), 1);
+  set1.insert(FEIRDFGNode(varReg3));
+  EXPECT_EQ(set1.size(), 2);
+  set1.erase(FEIRDFGNode(varReg4));
+  EXPECT_EQ(set1.size(), 1);
+}
+
+// ---------- FEIRStmtCheckPoint ----------
+/*
+ * Test1
+ *   DFG: hir2mpl/doc/images/ut_cases/DFG/Test1.dot
+ *   Image: hir2mpl/doc/images/ut_cases/DFG/Test1.png
+ */
+TEST_F(FEIRDFGTest, CheckPointTest1) {
+  Init(2, 1);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt1);
+  // Build DFG
+  BuildDFG("");
+  std::set<UniqueFEIRVar*> &defs = TransformCheckPoint(checkPoints[0])->CalcuDef(vars[1]);
+  ASSERT_EQ(defs.size(), 1);
+  EXPECT_NE(defs.find(&vars[0]), defs.end());
+}
+
+/*
+ * Test2
+ *   DFG: hir2mpl/doc/images/ut_cases/DFG/Test2.dot
+ *   Image: hir2mpl/doc/images/ut_cases/DFG/Test2.png
+ */
+TEST_F(FEIRDFGTest, CheckPointTest2) {
+  Init(2, 2);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  // BB1
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[1])->RegisterDFGNodes(stmt1);
+  // Build DFG
+  BuildDFG("0->1");
+  std::set<UniqueFEIRVar*> &defs = TransformCheckPoint(checkPoints[1])->CalcuDef(vars[1]);
+  ASSERT_EQ(defs.size(), 1);
+  EXPECT_NE(defs.find(&vars[0]), defs.end());
+}
+
+/*
+ * Test3
+ *   DFG: hir2mpl/doc/images/ut_cases/DFG/Test3.dot
+ *   Image: hir2mpl/doc/images/ut_cases/DFG/Test3.png
+ */
+TEST_F(FEIRDFGTest, Test3) {
+  Init(4, 4);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  // BB1
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[1])->RegisterDFGNodes(stmt1);
+  // BB2
+  std::list<UniqueFEIRVar*> stmt2;
+  TransformCheckPoint(checkPoints[2])->RegisterDFGNodes(stmt2);
+  // BB3
+  std::list<UniqueFEIRVar*> stmt3;
+  AddVar2DFGNodes(stmt3, 3, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[3])->RegisterDFGNodes(stmt3);
+  // Build DFG
+  BuildDFG("0->1,0->2,1->3,2->3");
+  std::set<UniqueFEIRVar*> &defs = TransformCheckPoint(checkPoints[3])->CalcuDef(vars[3]);
+  ASSERT_EQ(defs.size(), 2);
+  EXPECT_NE(defs.find(&vars[0]), defs.end());
+  EXPECT_NE(defs.find(&vars[1]), defs.end());
+}
+
+/*
+ * Test4
+ *   DFG: hir2mpl/doc/images/ut_cases/DFG/Test4.dot
+ *   Image: hir2mpl/doc/images/ut_cases/DFG/Test4.png
+ */
+TEST_F(FEIRDFGTest, Test4) {
+  Init(4, 4);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  // BB1
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[1])->RegisterDFGNodes(stmt1);
+  // BB2
+  std::list<UniqueFEIRVar*> stmt2;
+  AddVar2DFGNodes(stmt2, 2, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[2])->RegisterDFGNodes(stmt2);
+  // BB3
+  std::list<UniqueFEIRVar*> stmt3;
+  AddVar2DFGNodes(stmt3, 3, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[3])->RegisterDFGNodes(stmt3);
+  // Build DFG
+  BuildDFG("0->1,0->2,1->3,2->3");
+  std::set<UniqueFEIRVar*> &defs = TransformCheckPoint(checkPoints[3])->CalcuDef(vars[3]);
+  ASSERT_EQ(defs.size(), 2);
+  EXPECT_EQ(defs.find(&vars[0]), defs.end());
+  EXPECT_NE(defs.find(&vars[1]), defs.end());
+  EXPECT_NE(defs.find(&vars[2]), defs.end());
+}
+
+/*
+ * Test5
+ *   DFG: hir2mpl/doc/images/ut_cases/DFG/Test5.dot
+ *   Image: hir2mpl/doc/images/ut_cases/DFG/Test5.png
+ */
+TEST_F(FEIRDFGTest, Test5) {
+  Init(4, 4);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  // BB1
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[1])->RegisterDFGNodes(stmt1);
+  // BB2
+  std::list<UniqueFEIRVar*> stmt2;
+  AddVar2DFGNodes(stmt2, 2, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[2])->RegisterDFGNodes(stmt2);
+  // BB3
+  std::list<UniqueFEIRVar*> stmt3;
+  AddVar2DFGNodes(stmt3, 3, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[3])->RegisterDFGNodes(stmt3);
+  // Build DFG
+  BuildDFG("0->1,1->2,2->3,2->1");
+  std::set<UniqueFEIRVar*> &defs1 = TransformCheckPoint(checkPoints[1])->CalcuDef(vars[1]);
+  ASSERT_EQ(defs1.size(), 2);
+  EXPECT_NE(defs1.find(&vars[0]), defs1.end());
+  EXPECT_NE(defs1.find(&vars[2]), defs1.end());
+  std::set<UniqueFEIRVar*> &defs3 = TransformCheckPoint(checkPoints[3])->CalcuDef(vars[3]);
+  ASSERT_EQ(defs3.size(), 1);
+  EXPECT_NE(defs3.find(&vars[2]), defs3.end());
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/feir_stmt_test.cpp b/src/hir2mpl/test/common/feir_stmt_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc26d5867791308a5673e7ae444872f8558fe535
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_stmt_test.cpp
@@ -0,0 +1,573 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include <unordered_set>
+#include <unordered_map>
+#include "feir_test_base.h"
+#include "feir_stmt.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "feir_builder.h"
+#include "hir2mpl_ut_regx.h"
+#include "fe_utils_java.h"
+#include "ror.h"
+#define private public
+#undef private
+
+namespace maple {
+class FEIRStmtTest : public FEIRTestBase {
+ public:
+  FEIRStmtTest() = default;
+  virtual ~FEIRStmtTest() = default;
+};
+
+// ---------- FEIRExprConst ----------
+TEST_F(FEIRStmtTest, FEIRExprConst_i64) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(int64{ 0x100 }, PTY_i64);
+  std::unique_ptr<FEIRExpr> exprConst2 = exprConst->Clone();
+  BaseNode *baseNode = exprConst2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  EXPECT_EQ(GetBufferString(), "constval i64 256\n");
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprConst_u64) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(uint64{ 0x100 }, PTY_u64);
+  std::unique_ptr<FEIRExpr> exprConst2 = exprConst->Clone();
+  BaseNode *baseNode = exprConst2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  EXPECT_EQ(GetBufferString(), "constval u64 256\n");
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprConst_f32) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(1.5f);
+  std::unique_ptr<FEIRExpr> exprConst2 = exprConst->Clone();
+  BaseNode *baseNode = exprConst2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  EXPECT_EQ(GetBufferString(), "constval f32 1.5f\n");
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprConst_f64) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(1.5);
+  std::unique_ptr<FEIRExpr> exprConst2 = exprConst->Clone();
+  BaseNode *baseNode = exprConst2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  EXPECT_EQ(GetBufferString(), "constval f64 1.5\n");
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprConstUnsupported) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(int64{ 0 }, PTY_unknown);
+  BaseNode *baseNode = exprConst->GenMIRNode(mirBuilder);
+  EXPECT_EQ(baseNode, nullptr);
+}
+
+// ---------- FEIRExprUnary ----------
+TEST_F(FEIRStmtTest, FEIRExprUnary) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprUnary> expr = std::make_unique<FEIRExprUnary>(OP_neg, std::move(exprDRead));
+  expr->GetType()->SetPrimType(PTY_i32);
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("neg i32 \\(dread i32 %Reg0_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+  std::vector<FEIRVar*> varUses = expr2->GetVarUses();
+  ASSERT_EQ(varUses.size(), 1);
+}
+
+// ---------- FEIRExprTypeCvt ----------
+TEST_F(FEIRStmtTest, FEIRExprTypeCvtMode1) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprUnary> expr = std::make_unique<FEIRExprTypeCvt>(OP_cvt, std::move(exprDRead));
+  expr->GetType()->SetPrimType(PTY_f32);
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("cvt f32 i32 \\(dread i32 %Reg0_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprTypeCvtMode2) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_f32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprTypeCvt> expr = std::make_unique<FEIRExprTypeCvt>(OP_round, std::move(exprDRead));
+  expr->GetType()->SetPrimType(PTY_i32);
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("round i32 f32 \\(dread f32 %Reg0_F\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprTypeCvtMode3) {
+  std::unique_ptr<FEIRType> typeVar = FEIRTypeHelper::CreateTypeByJavaName("Ltest/lang/Object;", false, true);
+  std::unique_ptr<FEIRVarReg> varReg = std::make_unique<FEIRVarReg>(0, std::move(typeVar));
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRType> typeDst = FEIRTypeHelper::CreateTypeByJavaName("Ltest/lang/String;", false, true);
+  std::unique_ptr<FEIRExprTypeCvt> expr = std::make_unique<FEIRExprTypeCvt>(std::move(typeDst), OP_retype,
+                                                                            std::move(exprDRead));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("retype ref <\\* <\\$Ltest_2Flang_2FString_3B>> \\(dread ref %Reg0_") +
+                        HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) + "\\)" + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprExtractBits ----------
+TEST_F(FEIRStmtTest, FEIRExprExtractBits) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprExtractBits> expr =
+      std::make_unique<FEIRExprExtractBits>(OP_extractbits, PTY_i32, 8, 16, std::move(exprDRead));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("extractbits i32 8 16 \\(dread i32 %Reg0_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprExtractBits_sext) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprExtractBits> expr =
+      std::make_unique<FEIRExprExtractBits>(OP_sext, PTY_i8, std::move(exprDRead));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("sext i32 8 \\(dread i32 %Reg0_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprExtractBits_zext) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprExtractBits> expr =
+      std::make_unique<FEIRExprExtractBits>(OP_zext, PTY_u16, std::move(exprDRead));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("zext u32 16 \\(dread i32 %Reg0_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprBinary ----------
+TEST_F(FEIRStmtTest, FEIRExprBinary_add) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(1, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead1 = std::make_unique<FEIRExprDRead>(std::move(varReg1));
+  std::unique_ptr<FEIRExprBinary> expr =
+      std::make_unique<FEIRExprBinary>(OP_add, std::move(exprDRead0), std::move(exprDRead1));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("add i32 \\(dread i32 %Reg0_I, dread i32 %Reg1_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+  std::vector<FEIRVar*> varUses = expr2->GetVarUses();
+  ASSERT_EQ(varUses.size(), 2);
+  EXPECT_EQ(expr2->IsNestable(), true);
+  EXPECT_EQ(expr2->IsAddrof(), false);
+}
+
+TEST_F(FEIRStmtTest, FEIRExprBinary_cmpg) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_f64);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarReg(2, PTY_f64);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead2 = std::make_unique<FEIRExprDRead>(std::move(varReg2));
+  std::unique_ptr<FEIRExprBinary> expr =
+      std::make_unique<FEIRExprBinary>(OP_cmpg, std::move(exprDRead0), std::move(exprDRead2));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("cmpg i32 f64 \\(dread f64 %Reg0_D, dread f64 %Reg2_D\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprBinary_lshr) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(1, PTY_i8);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead1 = std::make_unique<FEIRExprDRead>(std::move(varReg1));
+  std::unique_ptr<FEIRExprBinary> expr =
+      std::make_unique<FEIRExprBinary>(OP_lshr, std::move(exprDRead0), std::move(exprDRead1));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("lshr i32 \\(dread i32 %Reg0_I, dread i32 %Reg1_B\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprBinary_band) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(1, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead1 = std::make_unique<FEIRExprDRead>(std::move(varReg1));
+  std::unique_ptr<FEIRExprBinary> expr =
+      std::make_unique<FEIRExprBinary>(OP_band, std::move(exprDRead0), std::move(exprDRead1));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("band i32 \\(dread i32 %Reg0_I, dread i32 %Reg1_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprTernary ----------
+TEST_F(FEIRStmtTest, FEIRExprTernary_add) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_u1);
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(1, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarReg(2, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead1 = std::make_unique<FEIRExprDRead>(std::move(varReg1));
+  std::unique_ptr<FEIRExprDRead> exprDRead2 = std::make_unique<FEIRExprDRead>(std::move(varReg2));
+  std::unique_ptr<FEIRExprTernary> expr =
+      std::make_unique<FEIRExprTernary>(OP_select, std::move(exprDRead0), std::move(exprDRead1), std::move(exprDRead2));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern =
+      std::string("select i32 \\(dread u32 %Reg0_Z, dread i32 %Reg1_I, dread i32 %Reg2_I\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+  std::vector<FEIRVar*> varUses = expr2->GetVarUses();
+  ASSERT_EQ(varUses.size(), 3);
+  EXPECT_EQ(expr2->IsNestable(), true);
+  EXPECT_EQ(expr2->IsAddrof(), false);
+}
+
+// ---------- FEIRStmtIf ----------
+TEST_F(FEIRStmtTest, FEIRStmtIf) {
+  // CondExpr
+  UniqueFEIRVar varReg = FEIRBuilder::CreateVarReg(0, PTY_u1);
+  std::unique_ptr<FEIRExprDRead> exprDReadReg = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  // ThenStmts
+  UniqueFEIRVar dstVar = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  UniqueFEIRVar dstVar1 = dstVar->Clone();
+  UniqueFEIRVar srcVar = std::make_unique<FEIRVarReg>(1, PTY_i32);
+  UniqueFEIRExpr exprDRead = std::make_unique<FEIRExprDRead>(std::move(srcVar));
+  UniqueFEIRExpr exprDRead1 = exprDRead->Clone();
+  UniqueFEIRStmt stmtDAssign = std::make_unique<FEIRStmtDAssign>(std::move(dstVar), std::move(exprDRead));
+  std::list<UniqueFEIRStmt> thenStmts;
+  thenStmts.emplace_back(std::move(stmtDAssign));
+  // ElseStmts
+  UniqueFEIRVar dstVar2 = dstVar1->Clone();
+  UniqueFEIRExpr exprDRead2 = exprDRead1->Clone();
+  UniqueFEIRStmt stmtDAssign1 = std::make_unique<FEIRStmtDAssign>(std::move(dstVar1), std::move(exprDRead1));
+  UniqueFEIRStmt stmtDAssign2 = std::make_unique<FEIRStmtDAssign>(std::move(dstVar2), std::move(exprDRead2));
+  std::list<UniqueFEIRStmt> elseStmts;
+  elseStmts.emplace_back(std::move(stmtDAssign1));
+  elseStmts.emplace_back(std::move(stmtDAssign2));
+
+  std::unique_ptr<FEIRStmtIf> stmt =
+      std::make_unique<FEIRStmtIf>(std::move(exprDReadReg), thenStmts, elseStmts);
+  std::list<StmtNode*> baseNodes = stmt->GenMIRStmts(mirBuilder);
+  RedirectCout();
+  baseNodes.front()->Dump();
+  std::string pattern =
+      "if (dread u32 %Reg0_Z) {\n"\
+      "  dassign %Reg0_I 0 (dread i32 %Reg1_I)\n"\
+      "}\n"\
+      "else {\n"\
+      "  dassign %Reg0_I 0 (dread i32 %Reg1_I)\n"\
+      "  dassign %Reg0_I 0 (dread i32 %Reg1_I)\n"\
+      "}\n\n";
+  EXPECT_EQ(GetBufferString(), pattern);
+  RestoreCout();
+}
+
+// ---------- FEIRStmtDAssign ----------
+TEST_F(FEIRStmtTest, FEIRStmtDAssign) {
+  std::unique_ptr<FEIRType> type = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  std::unique_ptr<FEIRVarReg> dstVar = std::make_unique<FEIRVarReg>(0, type->Clone());
+  std::unique_ptr<FEIRVarReg> srcVar = std::make_unique<FEIRVarReg>(1, type->Clone());
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(srcVar));
+  std::unique_ptr<FEIRStmtDAssign> stmtDAssign =
+      std::make_unique<FEIRStmtDAssign>(std::move(dstVar), std::move(exprDRead));
+  std::list<StmtNode*> mirNodes = stmtDAssign->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_") + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+                        " 0 \\(dread ref %Reg1_" + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) + "\\)" +
+                        HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRStmtIntrinsicCallAssign ----------
+TEST_F(FEIRStmtTest, FEIRStmtIntrinsicCallAssign) {
+  std::string containerName = "Ljava/lang/String;";
+  containerName = namemangler::EncodeName(containerName);
+  GStrIdx containerNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(containerName);
+  std::unique_ptr<FEIRStmtIntrinsicCallAssign> stmtCall =
+      std::make_unique<FEIRStmtIntrinsicCallAssign>(INTRN_JAVA_CLINIT_CHECK,
+                                                    std::make_unique<FEIRTypeDefault>(PTY_ref, containerNameIdx),
+                                                    nullptr);
+  std::list<StmtNode*> mirNodes = stmtCall->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string expected = "intrinsiccallwithtype <$Ljava_2Flang_2FString_3B> JAVA_CLINIT_CHECK ()";
+  EXPECT_EQ(dumpStr.find(expected) != std::string::npos, true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRStmtIntrinsicCallAssign_FilledNewArray) {
+  RedirectCout();
+  std::string elemName = "Ljava/lang/String;";
+  UniqueFEIRType elemType = FEIRTypeHelper::CreateTypeByJavaName(elemName, false, false);
+
+  auto exprRegList = std::make_unique<std::list<UniqueFEIRExpr>>();
+  UniqueFEIRExpr exprReg = FEIRBuilder::CreateExprDRead(FEIRBuilder::CreateVarReg(0, PTY_i32));
+  exprRegList->emplace_back(std::move(exprReg));
+
+  UniqueFEIRType type = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 1, false);
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, std::move(type));
+
+  std::unique_ptr<FEIRStmtIntrinsicCallAssign> stmtCall = std::make_unique<FEIRStmtIntrinsicCallAssign>(
+      INTRN_JAVA_FILL_NEW_ARRAY, std::move(elemType), std::move(varReg), std::move(exprRegList));
+  std::list<StmtNode*> mirNodes = stmtCall->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("intrinsiccallwithtypeassigned <\\* <\\$Ljava_2Flang_2FString_3B>> ") +
+                        std::string("JAVA_FILL_NEW_ARRAY \\(dread i32 %Reg0_I\\) \\{ dassign %Reg0_") +
+                        HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) + std::string(" 0 \\}") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRStmtJavaFillArrayData) {
+  RedirectCout();
+  UniqueFEIRType type = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 1, false);
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, std::move(type));
+  int32 arr[] = { 1, 2, 3, 4 };
+  const std::string tempName = "const_array_0";
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(std::move(varReg));
+  std::unique_ptr<FEIRStmtJavaFillArrayData> stmt =
+      std::make_unique<FEIRStmtJavaFillArrayData>(std::move(expr), reinterpret_cast<int8*>(&arr), 4, tempName);
+  MIRSymbol *arrayDataVar = stmt->ProcessArrayElemData(mirBuilder, stmt->ProcessArrayElemPrimType());
+  arrayDataVar->Dump(true, 0);
+  EXPECT_EQ(GetBufferString(), "var %const_array_0 fstatic <[4] i32> readonly = [1, 2, 3, 4]\n");
+
+  std::list<StmtNode*> mirNodes = stmt->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("intrinsiccallassigned JAVA_ARRAY_FILL \\(dread ref %Reg0_") +
+                        HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+                        std::string(", addrof ptr \\$const_array_0, constval i32 16\\)") +
+                        HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExpr_hash) {
+  // FEIRExprDRead
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(1, PTY_i8);
+  UniqueFEIRExpr exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  UniqueFEIRExpr exprDRead1 = std::make_unique<FEIRExprDRead>(std::move(varReg1));
+  UniqueFEIRExpr exprDRead2 = exprDRead0->Clone();
+  EXPECT_EQ(exprDRead0->Hash() == exprDRead1->Hash(), false);
+  EXPECT_EQ(exprDRead0->Hash() == exprDRead2->Hash(), true);
+  // FEIRExprIRead
+  UniqueFEIRVar Var0 = FEIRBuilder::CreateVarNameForC("a", *GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRVar Var1 = FEIRBuilder::CreateVarNameForC("b", *GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRVar Var2 = Var0->Clone();
+  UniqueFEIRExpr exprDRead10 = std::make_unique<FEIRExprDRead>(Var0->Clone());
+  UniqueFEIRExpr exprDRead11 = std::make_unique<FEIRExprDRead>(Var1->Clone());
+  UniqueFEIRExpr exprDRead12 = exprDRead10->Clone();
+  EXPECT_EQ(exprDRead10->Hash() == exprDRead11->Hash(), false);
+  EXPECT_EQ(exprDRead10->Hash() == exprDRead12->Hash(), true);
+  UniqueFEIRType retType = FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetInt32());
+  MIRType *ptr = GlobalTables::GetTypeTable().GetOrCreatePointerType(*GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRType ptrType = FEIRTypeHelper::CreateTypeNative(*ptr);
+  UniqueFEIRExpr exprIread0 = FEIRBuilder::CreateExprIRead(retType->Clone(), ptrType->Clone(), exprDRead10->Clone());
+  UniqueFEIRExpr exprIread1 = FEIRBuilder::CreateExprIRead(retType->Clone(), ptrType->Clone(), exprDRead11->Clone());
+  UniqueFEIRExpr exprIread2 = FEIRBuilder::CreateExprIRead(retType->Clone(), ptrType->Clone(), exprDRead12->Clone());
+  UniqueFEIRExpr exprIread3 = exprIread0->Clone();
+  EXPECT_EQ(exprIread0->Hash() == exprIread1->Hash(), false);
+  EXPECT_EQ(exprIread0->Hash() == exprIread2->Hash(), true);
+  EXPECT_EQ(exprIread0->Hash() == exprIread3->Hash(), true);
+  // FEIRExprConst
+  UniqueFEIRExpr exprConst0 = std::make_unique<FEIRExprConst>(int64{ 0x100 }, PTY_i64);
+  UniqueFEIRExpr exprConst1 = std::make_unique<FEIRExprConst>(int64{ 0x100 }, PTY_u64);
+  UniqueFEIRExpr exprConst2 = std::make_unique<FEIRExprConst>(int64{ 0x101 }, PTY_u64);
+  UniqueFEIRExpr exprConst3 =  exprConst2->Clone();
+  EXPECT_EQ(exprConst0->Hash() == exprConst1->Hash(), false);
+  EXPECT_EQ(exprConst1->Hash() == exprConst2->Hash(), false);
+  EXPECT_EQ(exprConst2->Hash() == exprConst3->Hash(), true);
+  // FEIRExprUnary
+  UniqueFEIRVar varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  UniqueFEIRExpr exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  UniqueFEIRExpr exprUnary0 = std::make_unique<FEIRExprUnary>(OP_neg, exprDRead->Clone());
+  UniqueFEIRExpr exprUnary1 = std::make_unique<FEIRExprUnary>(OP_bnot, exprDRead->Clone());
+  UniqueFEIRExpr exprUnary2 = exprUnary1->Clone();
+  EXPECT_EQ(exprUnary0->Hash() == exprUnary1->Hash(), false);
+  EXPECT_EQ(exprUnary1->Hash() == exprUnary2->Hash(), true);
+  // FEIRExprTypeCvt
+  std::unique_ptr<FEIRExprTypeCvt> exprCvt0 = std::make_unique<FEIRExprTypeCvt>(OP_round, exprDRead->Clone());
+  exprCvt0->GetType()->SetPrimType(PTY_f32);
+  UniqueFEIRExpr exprCvt1 = exprCvt0->Clone();
+  exprCvt1->GetType()->SetPrimType(PTY_u32);
+  UniqueFEIRExpr exprCvt2 = exprCvt0->Clone();
+  EXPECT_EQ(exprCvt0->Hash() == exprCvt1->Hash(), false);
+  EXPECT_EQ(exprCvt0->Hash() == exprCvt2->Hash(), true);
+  // FEIRExprExtractBits
+  UniqueFEIRExpr exprExtractBits0 =
+      std::make_unique<FEIRExprExtractBits>(OP_extractbits, PTY_i32, 8, 16, exprDRead->Clone());
+  UniqueFEIRExpr exprExtractBits1 =
+      std::make_unique<FEIRExprExtractBits>(OP_extractbits, PTY_u32, 8, 16, exprDRead->Clone());
+  UniqueFEIRExpr exprExtractBits2 =
+      std::make_unique<FEIRExprExtractBits>(OP_extractbits, PTY_u32, 16, 8, exprDRead->Clone());
+  UniqueFEIRExpr exprExtractBits3 = exprExtractBits0->Clone();
+  EXPECT_EQ(exprExtractBits0->Hash() == exprConst1->Hash(), false);
+  EXPECT_EQ(exprExtractBits0->Hash() == exprExtractBits2->Hash(), false);
+  EXPECT_EQ(exprExtractBits0->Hash() == exprExtractBits3->Hash(), true);
+  // FEIRExprBinary
+  UniqueFEIRExpr exprBin0 = std::make_unique<FEIRExprBinary>(OP_add, exprDRead10->Clone(), exprDRead11->Clone());
+  UniqueFEIRExpr exprBin1 = std::make_unique<FEIRExprBinary>(OP_sub, exprDRead10->Clone(), exprDRead11->Clone());
+  UniqueFEIRExpr exprBin2 = std::make_unique<FEIRExprBinary>(OP_add, exprDRead11->Clone(), exprDRead10->Clone());
+  UniqueFEIRExpr exprBin3 = exprBin0->Clone();
+  EXPECT_EQ(exprBin0->Hash() == exprBin1->Hash(), false);
+  EXPECT_EQ(exprBin0->Hash() == exprBin2->Hash(), false);
+  EXPECT_EQ(exprBin0->Hash() == exprBin3->Hash(), true);
+  UniqueFEIRExpr exprTernary0 =
+      std::make_unique<FEIRExprTernary>(OP_select, exprDRead0->Clone(), exprDRead1->Clone(), exprDRead2->Clone());
+  UniqueFEIRExpr exprTernary1 =
+      std::make_unique<FEIRExprTernary>(OP_select, exprDRead0->Clone(), exprDRead2->Clone(), exprDRead1->Clone());
+  UniqueFEIRExpr exprTernary2 = exprTernary0->Clone();
+  EXPECT_EQ(exprTernary0->Hash() == exprTernary1->Hash(), false);
+  EXPECT_EQ(exprTernary0->Hash() == exprTernary2->Hash(), true);
+  // FEIRExprAddrofVar
+  UniqueFEIRExpr exprAddrOfVar0 = FEIRBuilder::CreateExprAddrofVar(Var0->Clone());
+  UniqueFEIRExpr exprAddrOfVar1 = FEIRBuilder::CreateExprAddrofVar(Var1->Clone());
+  UniqueFEIRExpr exprAddrOfVar2 = exprAddrOfVar0->Clone();
+  EXPECT_EQ(exprAddrOfVar0->Hash() == exprAddrOfVar1->Hash(), false);
+  EXPECT_EQ(exprAddrOfVar0->Hash() == exprAddrOfVar2->Hash(), true);
+  // FEIRExprIAddrof
+  UniqueFEIRExpr exprAddrIAddrof0 = std::make_unique<FEIRExprIAddrof>(
+      FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetAddr64()), 1, exprDRead10->Clone());
+  UniqueFEIRExpr exprAddrIAddrof1 = std::make_unique<FEIRExprIAddrof>(
+      FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetAddr64()), 2, exprDRead10->Clone());
+  UniqueFEIRExpr exprAddrIAddrof2 = std::make_unique<FEIRExprIAddrof>(
+      FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetAddr64()), 1, exprDRead11->Clone());
+  UniqueFEIRExpr exprAddrIAddrof3 = exprAddrIAddrof0->Clone();
+  EXPECT_EQ(exprAddrIAddrof0->Hash() == exprAddrIAddrof1->Hash(), false);
+  EXPECT_EQ(exprAddrIAddrof0->Hash() == exprAddrIAddrof2->Hash(), false);
+  EXPECT_EQ(exprAddrIAddrof0->Hash() == exprAddrIAddrof3->Hash(), true);
+  // FEIRExprAddrofFunc
+  UniqueFEIRExpr exprFunc0 = FEIRBuilder::CreateExprAddrofFunc("func1");
+  UniqueFEIRExpr exprFunc1 = FEIRBuilder::CreateExprAddrofFunc("func2");
+  UniqueFEIRExpr exprFunc2 = exprFunc0->Clone();
+  EXPECT_EQ(exprFunc0->Hash() == exprFunc1->Hash(), false);
+  EXPECT_EQ(exprFunc0->Hash() == exprFunc2->Hash(), true);
+  // FEIRExprAddrofArray
+  uint32_t sizeArray[2] = {3, 3};
+  MIRType *arrType = GlobalTables::GetTypeTable().GetOrCreateArrayType(
+      *GlobalTables::GetTypeTable().GetAddr64(), 2, sizeArray);
+  UniqueFEIRType arrayFEType = FEIRTypeHelper::CreateTypeNative(*arrType);
+  std::list<UniqueFEIRExpr> exprs0;
+  exprs0.emplace_back( FEIRBuilder::CreateExprConstU32(1));
+  exprs0.emplace_back( FEIRBuilder::CreateExprConstU32(2));
+  std::list<UniqueFEIRExpr> exprs1;
+  exprs1.emplace_back( FEIRBuilder::CreateExprConstU32(2));
+  exprs1.emplace_back( FEIRBuilder::CreateExprConstU32(1));
+  auto exprAddrOfArr0 = FEIRBuilder::CreateExprAddrofArray(arrayFEType->Clone(), exprAddrOfVar0->Clone(), "", exprs0);
+  auto exprAddrOfArr1 = FEIRBuilder::CreateExprAddrofArray(arrayFEType->Clone(), exprAddrOfVar1->Clone(), "", exprs0);
+  auto exprAddrOfArr2 = FEIRBuilder::CreateExprAddrofArray(arrayFEType->Clone(), exprAddrOfVar1->Clone(), "", exprs1);
+  auto exprAddrOfArr3 = exprAddrOfArr0->Clone();
+  EXPECT_EQ(exprAddrOfArr0->Hash() == exprAddrOfArr1->Hash(), false);
+  EXPECT_EQ(exprAddrOfArr0->Hash() == exprAddrOfArr2->Hash(), false);
+  EXPECT_EQ(exprAddrOfArr0->Hash() == exprAddrOfArr3->Hash(), true);
+}
+
+TEST_F(FEIRStmtTest, FEIRStmtRor) {
+  RedirectCout();
+  MIRType *type = GlobalTables::GetTypeTable().GetUInt64();
+  UniqueFEIRVar baseVar = FEIRBuilder::CreateVarNameForC("a", *type, false, false);
+  UniqueFEIRExpr baseExpr = FEIRBuilder::CreateExprDRead(std::move(baseVar));
+  UniqueFEIRVar baseShiftVar = FEIRBuilder::CreateVarNameForC("b", *type, false, false);
+  UniqueFEIRExpr baseShiftExpr = FEIRBuilder::CreateExprDRead(std::move(baseShiftVar));
+  UniqueFEIRExpr constExpr1 = FEIRBuilder::CreateExprConstI32(64);
+  UniqueFEIRExpr constExpr2 = FEIRBuilder::CreateExprConstI32(63);
+  UniqueFEIRExpr andExpr = FEIRBuilder::CreateExprBinary(OP_band, baseShiftExpr->Clone(), constExpr2->Clone());
+  UniqueFEIRExpr leftExpr = FEIRBuilder::CreateExprBinary(OP_lshr, baseExpr->Clone(), andExpr->Clone());
+  UniqueFEIRExpr subExpr = FEIRBuilder::CreateExprBinary(OP_sub, constExpr1->Clone(), andExpr->Clone());
+  UniqueFEIRExpr rightExpr = FEIRBuilder::CreateExprBinary(OP_shl, baseExpr->Clone(), subExpr->Clone());
+  UniqueFEIRExpr orExpr = FEIRBuilder::CreateExprBinary(OP_bior, leftExpr->Clone(), rightExpr->Clone());
+  // ror optimize
+  auto orExprPtr = static_cast<FEIRExprBinary*>(orExpr.get());
+  Ror ror(orExprPtr->GetOp(), orExprPtr->GetOpnd0(), orExprPtr->GetOpnd1());
+  UniqueFEIRExpr target = ror.Emit2FEExpr();
+  BaseNode *node = target->GenMIRNode(mirBuilder);
+  node->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("ror u64 \\(dread u64 %a, dread u64 %b\\)") + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/common/feir_test_base.cpp b/src/hir2mpl/test/common/feir_test_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..888d2bde82159348830d14fb8cd95c3a187b561e
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_test_base.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "feir_test_base.h"
+#include "hir2mpl_ut_environment.h"
+#include "fe_utils.h"
+#include "fe_manager.h"
+
+namespace maple {
+MemPool *FEIRTestBase::mp = nullptr;
+
+FEIRTestBase::FEIRTestBase()
+    : allocator(mp),
+      mirBuilder(&HIR2MPLUTEnvironment::GetMIRModule()) {
+  func = FEManager::GetTypeManager().GetMIRFunction("mock_func", false);
+  if (func == nullptr) {
+    func = FEManager::GetTypeManager().CreateFunction("mock_func", "void", std::vector<std::string>{}, false, false);
+  }
+  mirBuilder.SetCurrentFunction(*func);
+}
+
+void FEIRTestBase::SetUpTestCase() {
+  mp = FEUtils::NewMempool("MemPool for FEIRTestBase", false /* isLocalPool */);
+}
+
+void FEIRTestBase::TearDownTestCase() {
+  delete mp;
+  mp = nullptr;
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/common/feir_test_base.h b/src/hir2mpl/test/common/feir_test_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2cacebe195855b049af7460e74fb7a6b478e189
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_test_base.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "redirect_buffer.h"
+#include "global_tables.h"
+#include "mir_module.h"
+#include "mir_builder.h"
+
+namespace maple {
+class FEIRTestBase : public testing::Test, public RedirectBuffer {
+ public:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  MIRBuilder mirBuilder;
+  MIRFunction *func;
+  FEIRTestBase();
+  virtual ~FEIRTestBase() = default;
+
+  static void SetUpTestCase();
+  static void TearDownTestCase();
+};
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/feir_type_helper_test.cpp b/src/hir2mpl/test/common/feir_type_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..75c3151aa4b163230a1ddb0b8ac19dedda444892
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_type_helper_test.cpp
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "redirect_buffer.h"
+#include "global_tables.h"
+#include "mir_module.h"
+#include "feir_type_helper.h"
+
+namespace maple {
+class FEIRTypeHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEIRTypeHelperTest() = default;
+  ~FEIRTypeHelperTest() = default;
+};
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByPrimType_i32) {
+  std::unique_ptr<FEIRType> type1 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, false);
+  std::unique_ptr<FEIRType> type2 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* i32>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByJavaName_J) {
+  std::unique_ptr<FEIRType> type1 = FEIRTypeHelper::CreateTypeByJavaName("J", false, false);
+  std::unique_ptr<FEIRType> type2 = FEIRTypeHelper::CreateTypeByJavaName("J", false, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i64");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* i64>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByJavaName_PrimType) {
+  RedirectCout();
+  FEIRTypeHelper::CreateTypeByJavaName("I", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("J", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i64");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("F", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f32");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("D", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f64");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("Z", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u1");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("B", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i8");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("S", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i16");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("C", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u16");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("V", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByJavaName_Object) {
+  std::unique_ptr<FEIRType> type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  std::unique_ptr<FEIRType> type2 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  std::unique_ptr<FEIRType> type3 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, false);
+  std::unique_ptr<FEIRType> type4 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  ClearBufferString();
+  type3->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] <* <$Ljava_2Flang_2FObject_3B>>>");
+  ClearBufferString();
+  type4->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByJavaName_Undefined) {
+  std::unique_ptr<FEIRType> type1 = FEIRTypeHelper::CreateTypeByJavaName("LUndefine4FEIRTypeHelper;", false, false);
+  std::unique_ptr<FEIRType> type2 = FEIRTypeHelper::CreateTypeByJavaName("LUndefine4FEIRTypeHelper;", false, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$LUndefine4FEIRTypeHelper_3B>");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$LUndefine4FEIRTypeHelper_3B>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByDimIncr) {
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, false);
+  UniqueFEIRType type1A = FEIRTypeHelper::CreateTypeByDimIncr(type1, 1);
+  UniqueFEIRType type1AP = FEIRTypeHelper::CreateTypeByDimIncr(type1, 1, true);
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 1, true);
+  UniqueFEIRType type2A = FEIRTypeHelper::CreateTypeByDimIncr(type2, 2);
+  UniqueFEIRType type2AP = FEIRTypeHelper::CreateTypeByDimIncr(type2, 2, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type1A->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] i32>");
+  ClearBufferString();
+  type1AP->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type2A->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <[] i32>>>>>>");
+  ClearBufferString();
+  type2AP->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <[] i32>>>>>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByDimDecr) {
+  UniqueFEIRType type2AP = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 2, true);
+  UniqueFEIRType type1AP = FEIRTypeHelper::CreateTypeByDimDecr(type2AP, 1);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByDimDecr(type2AP, 2);
+  RedirectCout();
+  type2AP->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] i32>>>>");
+  ClearBufferString();
+  type1AP->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type0->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByGetAddress) {
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, false);
+  UniqueFEIRType type0P = FEIRTypeHelper::CreateTypeByGetAddress(type0);
+  RedirectCout();
+  type0->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type0P->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* i32>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByDereferrence) {
+  UniqueFEIRType type0P = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, true);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByDereferrence(type0P);
+  RedirectCout();
+  type0P->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* i32>");
+  ClearBufferString();
+  type0->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  RestoreCout();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/feir_type_infer_test.cpp b/src/hir2mpl/test/common/feir_type_infer_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2c523349d59269f54a6a4c900409e605e72f28b9
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_type_infer_test.cpp
@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "redirect_buffer.h"
+#include "global_tables.h"
+#include "mir_module.h"
+#define protected public
+#define private public
+#include "feir_type_helper.h"
+#include "feir_builder.h"
+#include "feir_var_type_scatter.h"
+#include "feir_dfg.h"
+#include "namemangler.h"
+#include "fe_type_hierarchy.h"
+#include "feir_type_infer.h"
+
+namespace maple {
+class FEIRTypeHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEIRTypeHelperTest() = default;
+  ~FEIRTypeHelperTest() = default;
+};
+
+class FEIRTypeInferTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEIRTypeInferTest() {};
+  ~FEIRTypeInferTest() = default;
+};
+
+class FEIRTypeCvtHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEIRTypeCvtHelperTest() {};
+  ~FEIRTypeCvtHelperTest() = default;
+};
+
+TEST_F(FEIRTypeHelperTest, MergeType_Parent) {
+  GStrIdx type0StrIdx =
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName("Ljava/lang/Integer;"));
+  GStrIdx type1StrIdx =
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName("Ljava/lang/Number;"));
+  FETypeHierarchy::GetInstance().AddParentChildRelation(type1StrIdx, type0StrIdx);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Integer;", false, false);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Number;", false, false);
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, false);
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/String;", false, false);
+  UniqueFEIRType type4 = FEIRTypeHelper::CreateTypeByJavaName("I", false, false);
+  UniqueFEIRType type5 = FEIRTypeHelper::CreateTypeByJavaName("J", false, false);
+  UniqueFEIRType type6 = FEIRTypeHelper::CreateTypeByJavaName("LFEIRTypeHelperTest", false, false);
+  UniqueFEIRType typeDefault = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType typeResult;
+  FEIRTypeMergeHelper typeMergeHelper(typeDefault);
+  // merge type0 and type1, expect Ljava/lang/Number;
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type1), true);
+  EXPECT_EQ(typeResult->IsEqualTo(type1), true);
+
+  // merge type1 and type0, expect Ljava/lang/Number;
+  typeResult.reset(type1->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type0), true);
+  EXPECT_EQ(typeResult->IsEqualTo(type1), true);
+
+  // merge type0 and type2, expect Ljava/lang/Object;
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type2), true);
+  EXPECT_EQ(typeResult->IsEqualTo(typeDefault), true);
+
+  // merge type1 and type2, expect Ljava/lang/Object;
+  typeResult.reset(type1->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type2), true);
+  EXPECT_EQ(typeResult->IsEqualTo(typeDefault), true);
+
+  // merge diff dim
+  typeResult.reset(type2->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type3), false);
+
+  // merge diff PrimType
+  typeResult.reset(type4->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type5), false);
+
+  // merge type0 and type6, expect Ljava/lang/Object;
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type6), true);
+  EXPECT_EQ(typeResult->IsEqualTo(typeDefault), true);
+
+  // merge type6 and type0, expect Ljava/lang/Object;
+  typeResult.reset(type6->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type0), true);
+  EXPECT_EQ(typeResult->IsEqualTo(typeDefault), true);
+}
+
+TEST_F(FEIRTypeHelperTest, MergeType_Child) {
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Integer;", false, false);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Number;", false, false);
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, false);
+  UniqueFEIRType typeDefault = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType typeResult;
+  FEIRTypeMergeHelper typeMergeHelper(typeDefault);
+  // merge type0 and type1, expect Ljava/lang/Integer;
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type1, false), true);
+  EXPECT_EQ(typeResult->IsEqualTo(type0), true);
+
+  // merge type1 and type0, expect Ljava/lang/Integer;
+  typeResult.reset(type1->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type0, false), true);
+  EXPECT_EQ(typeResult->IsEqualTo(type0), true);
+
+  // merge type0 and type2, expect error
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type2, false), false);
+}
+
+//
+// TypeInferTest: Test1
+//   DFG: hir2mpl/doc/images/ut_cases/TypeInfer/Test1.dot
+//   Image: hir2mpl/doc/images/ut_cases/TypeInfer/Test1.png
+//   UseDef:
+//     var1 -> var0
+//   DefUse:
+//     var0 -> var1
+//
+TEST_F(FEIRTypeInferTest, Test1) {
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapDefUse;
+  UniqueFEIRVar var0 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var1 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  var0->SetType(type0->Clone());
+  var1->SetType(type1->Clone());
+  mapDefUse[&var0].insert(&var1);
+  std::unique_ptr<FEIRTypeInfer> typeInfer = std::make_unique<FEIRTypeInfer>(kSrcLangJava, mapDefUse);
+  EXPECT_EQ(typeInfer->GetTypeForVarUse(var1)->IsEqualTo(type1), true);
+  EXPECT_EQ(typeInfer->GetTypeForVarDef(var0)->IsEqualTo(type0), true);
+  typeInfer->ProcessVarDef(var0);
+  EXPECT_EQ(var0->GetKind(), FEIRVarKind::kFEIRVarTypeScatter);
+  FEIRVarTypeScatter *ptrVar0 = static_cast<FEIRVarTypeScatter*>(var0.get());
+  EXPECT_EQ(ptrVar0->GetType()->IsEqualTo(type0), true);
+  EXPECT_EQ(ptrVar0->GetScatterTypes().size(), 1);
+  EXPECT_NE(ptrVar0->GetScatterTypes().find(FEIRTypeKey(type1)), ptrVar0->GetScatterTypes().end());
+}
+
+//
+// TypeInferTest: Test2
+//   DFG: hir2mpl/doc/images/ut_cases/TypeInfer/Test2.dot
+//   Image: hir2mpl/doc/images/ut_cases/TypeInfer/Test2.png
+//   UseDef:
+//     var1 -> var0
+//     var3 -> var2
+//   DefUse:
+//     var0 -> var1
+//     var2 -> var3
+//
+TEST_F(FEIRTypeInferTest, Test2) {
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapDefUse;
+  UniqueFEIRVar var0 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var1 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var2 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var3 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRVarTrans trans0 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, var1);
+  UniqueFEIRVarTrans trans1 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, var2);
+  var1->SetTrans(std::move(trans1));
+  var2->SetTrans(std::move(trans0));
+  var0->SetType(type0->Clone());
+  var3->SetType(type3->Clone());
+  mapDefUse[&var0].insert(&var1);
+  mapDefUse[&var2].insert(&var3);
+  std::unique_ptr<FEIRTypeInfer> typeInfer = std::make_unique<FEIRTypeInfer>(kSrcLangJava, mapDefUse);
+  EXPECT_EQ(typeInfer->GetTypeForVarUse(var1)->IsEqualTo(type3), true);
+  typeInfer->Reset();
+  EXPECT_EQ(typeInfer->GetTypeForVarUse(var3)->IsEqualTo(type3), true);
+
+  typeInfer->ProcessVarDef(var0);
+  typeInfer->ProcessVarDef(var2);
+  EXPECT_EQ(var0->GetKind(), FEIRVarKind::kFEIRVarTypeScatter);
+  EXPECT_EQ(var2->GetKind(), FEIRVarKind::kFEIRVarReg);
+}
+
+//
+// TypeInferTest: Test3
+//   DFG: hir2mpl/doc/images/ut_cases/TypeInfer/Test3.dot
+//   Image: hir2mpl/doc/images/ut_cases/TypeInfer/Test3.png
+//   UseDef:
+//     var1 -> {var0, var5}
+//     var3 -> var2
+//     var4 -> var2
+TEST_F(FEIRTypeInferTest, Test3) {
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapDefUse;
+  UniqueFEIRVar var0 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var1 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var2 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var3 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var4 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var5 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  UniqueFEIRVarTrans transFrom1To2 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, var1);
+  UniqueFEIRVarTrans transFrom2To1 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, var2);
+  UniqueFEIRVarTrans transFrom4To5 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, var4);
+  UniqueFEIRVarTrans transFrom5To4 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, var5);
+  var1->SetTrans(std::move(transFrom2To1));
+  var2->SetTrans(std::move(transFrom1To2));
+  var4->SetTrans(std::move(transFrom5To4));
+  var5->SetTrans(std::move(transFrom4To5));
+  var3->SetType(type0->Clone());
+  mapDefUse[&var0].insert(&var1);
+  mapDefUse[&var5].insert(&var1);
+  mapDefUse[&var2].insert(&var3);
+  mapDefUse[&var2].insert(&var4);
+  std::unique_ptr<FEIRTypeInfer> typeInfer = std::make_unique<FEIRTypeInfer>(kSrcLangJava, mapDefUse);
+  typeInfer->Reset();
+  EXPECT_EQ(typeInfer->GetTypeForVarUse(var1)->IsEqualTo(type0), true);
+  typeInfer->Reset();
+  EXPECT_EQ(typeInfer->GetTypeForVarUse(var3)->IsEqualTo(type0), true);
+  typeInfer->Reset();
+  EXPECT_EQ(typeInfer->GetTypeForVarUse(var4)->IsEqualTo(type0), true);
+  typeInfer->ProcessVarDef(var0);
+  typeInfer->ProcessVarDef(var2);
+  typeInfer->ProcessVarDef(var5);
+  EXPECT_EQ(var0->GetKind(), FEIRVarKind::kFEIRVarReg);
+  EXPECT_EQ(var2->GetKind(), FEIRVarKind::kFEIRVarReg);
+  EXPECT_EQ(var5->GetKind(), FEIRVarKind::kFEIRVarReg);
+  EXPECT_EQ(var0->GetType()->IsEqualTo(type0), true);
+  EXPECT_EQ(var2->GetType()->IsEqualTo(type0), true);
+  EXPECT_EQ(var5->GetType()->IsEqualTo(type0), true);
+}
+
+//
+// TypeInferTest: Test4
+//   DFG: hir2mpl/doc/images/ut_cases/TypeInfer/Test4.dot
+//   Image: hir2mpl/doc/images/ut_cases/TypeInfer/Test4.png
+//   UseDef:
+//     var1 -> var0
+//     var3 -> var2
+//
+TEST_F(FEIRTypeInferTest, Test4) {
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapDefUse;
+  UniqueFEIRVar var0 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var1 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var2 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var3 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, true);
+  UniqueFEIRVarTrans transFrom1To2 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransArrayDimDecr, var1);
+  UniqueFEIRVarTrans transFrom2To1 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransArrayDimIncr, var2);
+  var3->SetType(type0->Clone());
+  var1->SetTrans(std::move(transFrom2To1));
+  var2->SetTrans(std::move(transFrom1To2));
+  mapDefUse[&var0].insert(&var1);
+  mapDefUse[&var2].insert(&var3);
+  std::unique_ptr<FEIRTypeInfer> typeInfer = std::make_unique<FEIRTypeInfer>(kSrcLangJava, mapDefUse);
+  typeInfer->Reset();
+  EXPECT_EQ(typeInfer->GetTypeForVarUse(var1)->IsEqualTo(type1), true);
+  typeInfer->ProcessVarDef(var0);
+  typeInfer->ProcessVarDef(var2);
+  EXPECT_EQ(var0->GetType()->IsEqualTo(type1), true);
+  EXPECT_EQ(var2->GetType()->IsEqualTo(type0), true);
+}
+
+TEST_F(FEIRTypeCvtHelperTest, IsRetypeable) {
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("I", false, false);
+  bool isRetypeable = FEIRTypeCvtHelper::IsRetypeable(*type0, *type1);
+  EXPECT_EQ(isRetypeable, true);
+  isRetypeable = FEIRTypeCvtHelper::IsRetypeable(*type1, *type0);
+  EXPECT_EQ(isRetypeable, true);
+  isRetypeable = FEIRTypeCvtHelper::IsRetypeable(*type0, *type2);
+  EXPECT_EQ(isRetypeable, false);
+  isRetypeable = FEIRTypeCvtHelper::IsRetypeable(*type2, *type0);
+  EXPECT_EQ(isRetypeable, false);
+  isRetypeable = FEIRTypeCvtHelper::IsRetypeable(*type1, *type2);
+  EXPECT_EQ(isRetypeable, false);
+  isRetypeable = FEIRTypeCvtHelper::IsRetypeable(*type2, *type1);
+  EXPECT_EQ(isRetypeable, false);
+}
+
+TEST_F(FEIRTypeCvtHelperTest, IsIntCvt2Ref) {
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("I", false, false);
+  bool isIntCvt2Ref = FEIRTypeCvtHelper::IsIntCvt2Ref(*type2, *type0);
+  EXPECT_EQ(isIntCvt2Ref, true);
+  isIntCvt2Ref = FEIRTypeCvtHelper::IsIntCvt2Ref(*type2, *type1);
+  EXPECT_EQ(isIntCvt2Ref, true);
+}
+
+TEST_F(FEIRTypeCvtHelperTest, ChooseCvtOpcodeByFromTypeAndToType) {
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("I", false, false);
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("F", false, false);
+  Opcode opcode = FEIRTypeCvtHelper::ChooseCvtOpcodeByFromTypeAndToType(*type0, *type1);
+  EXPECT_EQ((opcode == OP_retype), true);
+  opcode = FEIRTypeCvtHelper::ChooseCvtOpcodeByFromTypeAndToType(*type1, *type0);
+  EXPECT_EQ((opcode == OP_retype), true);
+  opcode = FEIRTypeCvtHelper::ChooseCvtOpcodeByFromTypeAndToType(*type2, *type0);
+  EXPECT_EQ((opcode == OP_cvt), true);
+  opcode = FEIRTypeCvtHelper::ChooseCvtOpcodeByFromTypeAndToType(*type2, *type1);
+  EXPECT_EQ((opcode == OP_cvt), true);
+  opcode = FEIRTypeCvtHelper::ChooseCvtOpcodeByFromTypeAndToType(*type2, *type3);
+  EXPECT_EQ((opcode == OP_undef), true);
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/common/feir_type_test.cpp b/src/hir2mpl/test/common/feir_type_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..267bbcb835ecf668bb164435f77166d7ceb97b25
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_type_test.cpp
@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <unordered_set>
+#include "feir_type.h"
+#include "feir_type_helper.h"
+#include "redirect_buffer.h"
+#include "global_tables.h"
+#include "mir_module.h"
+
+namespace maple {
+class FEIRTypeDefaultTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEIRTypeDefaultTest() = default;
+  ~FEIRTypeDefaultTest() = default;
+};
+
+TEST(FEIRTypeDefault, IsScalarPrimType) {
+  EXPECT_EQ(FEIRTypeDefault::IsScalarPrimType(PTY_i32), true);
+  EXPECT_EQ(FEIRTypeDefault::IsScalarPrimType(PTY_ref), false);
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_Ref_Array_Precise_Valid) {
+  GStrIdx idxZero = GStrIdx(0);
+  GStrIdx idxNonZero = GStrIdx(100);
+
+  FEIRTypeDefault typeScalar(PTY_i32, idxZero, 0);
+  EXPECT_EQ(typeScalar.IsRef(), false);
+  EXPECT_EQ(typeScalar.IsArray(), false);
+  EXPECT_EQ(typeScalar.IsPrecise(), true);
+  EXPECT_EQ(typeScalar.IsValid(), true);
+
+  FEIRTypeDefault typeScalarArray(PTY_i32, idxZero, 1);
+  EXPECT_EQ(typeScalarArray.IsRef(), true);
+  EXPECT_EQ(typeScalarArray.IsArray(), true);
+  EXPECT_EQ(typeScalarArray.IsPrecise(), true);
+  EXPECT_EQ(typeScalarArray.IsValid(), true);
+
+  FEIRTypeDefault typeRefNP(PTY_ref, idxZero, 0);
+  EXPECT_EQ(typeRefNP.IsRef(), true);
+  EXPECT_EQ(typeRefNP.IsArray(), false);
+  EXPECT_EQ(typeRefNP.IsPrecise(), false);
+  EXPECT_EQ(typeRefNP.IsValid(), true);
+
+  FEIRTypeDefault typeRefNPArray(PTY_ref, idxZero, 1);
+  EXPECT_EQ(typeRefNPArray.IsRef(), true);
+  EXPECT_EQ(typeRefNPArray.IsArray(), true);
+  EXPECT_EQ(typeRefNPArray.IsPrecise(), false);
+  EXPECT_EQ(typeRefNPArray.IsValid(), true);
+
+  FEIRTypeDefault typeRef(PTY_ref, idxNonZero, 0);
+  EXPECT_EQ(typeRef.IsRef(), true);
+  EXPECT_EQ(typeRef.IsArray(), false);
+  EXPECT_EQ(typeRef.IsPrecise(), true);
+  EXPECT_EQ(typeRef.IsValid(), true);
+
+  FEIRTypeDefault typeRefArray(PTY_ref, idxNonZero, 1);
+  EXPECT_EQ(typeRefArray.IsRef(), true);
+  EXPECT_EQ(typeRefArray.IsArray(), true);
+  EXPECT_EQ(typeRefArray.IsPrecise(), true);
+  EXPECT_EQ(typeRefArray.IsValid(), true);
+
+  FEIRTypeDefault typeInvalid(PTY_i32, idxNonZero, 0);
+  EXPECT_EQ(typeInvalid.IsValid(), false);
+
+  FEIRTypeDefault typeInvalidArray(PTY_i32, idxNonZero, 1);
+  EXPECT_EQ(typeInvalidArray.IsValid(), false);
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_default) {
+  FEIRTypeDefault type;
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_void) {
+  FEIRTypeDefault type(PTY_void);
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_ref) {
+  FEIRTypeDefault type(PTY_ref);
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "ref");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "ref");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_refArray) {
+  std::string typeName = "Ljava_2Flang_2FString_3B";
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+  FEIRTypeDefault type(PTY_ref, gStrIdx, 1);
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] <* <$Ljava_2Flang_2FString_3B>>>");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FString_3B>>>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_Object) {
+  GStrIdx typeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FObject_3B");
+  FEIRTypeDefault type(PTY_ref, typeNameIdx, 0);
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_V) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("V");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_I) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("I");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_J) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("J");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i64");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i64");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_F) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("F");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f32");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f32");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_D) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("D");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f64");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f64");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_Z) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("Z");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u1");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u1");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_B) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("B");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i8");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i8");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_C) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("C");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u16");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u16");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_S) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("S");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i16");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i16");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_Object) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("Ljava_2Flang_2FObject_3B");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_AI) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("AI");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] i32>");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type.GenerateMIRTypeAuto(kSrcLangJava)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, UseFEIRTypeKey) {
+  std::unordered_set<FEIRTypeKey, FEIRTypeKeyHash> testSet;
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType type2 = type1->Clone();
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRType type4 = type3->Clone();
+  testSet.insert(FEIRTypeKey(type1));
+  testSet.insert(FEIRTypeKey(type2));
+  testSet.insert(FEIRTypeKey(type3));
+  testSet.insert(FEIRTypeKey(type4));
+  EXPECT_EQ(testSet.size(), 2);
+  EXPECT_NE(testSet.find(FEIRTypeKey(type1)), testSet.end());
+  EXPECT_NE(testSet.find(FEIRTypeKey(type2)), testSet.end());
+  EXPECT_NE(testSet.find(FEIRTypeKey(type3)), testSet.end());
+  EXPECT_NE(testSet.find(FEIRTypeKey(type4)), testSet.end());
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeNative_create) {
+  RedirectCout();
+  MIRType *mirType = GlobalTables::GetTypeTable().GetInt32();
+  FEIRTypeNative type(*mirType);
+  EXPECT_EQ(type.IsRef(), false);
+  EXPECT_EQ(type.IsArray(), false);
+  EXPECT_EQ(type.IsPrecise(), true);
+  EXPECT_EQ(type.IsValid(), true);
+  type.GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+
+  MIRType *mirType1 = GlobalTables::GetTypeTable().GetRef();
+  FEIRTypeNative type1(*mirType1);
+  EXPECT_EQ(type1.IsRef(), true);
+  EXPECT_EQ(type1.IsArray(), false);
+  EXPECT_EQ(type1.IsPrecise(), true);
+  EXPECT_EQ(type1.IsValid(), true);
+  type1.GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "ref");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeNative_equal) {
+  UniqueFEIRType type1 = std::make_unique<FEIRTypeNative>(*GlobalTables::GetTypeTable().GetInt32());
+  UniqueFEIRType type2 = std::make_unique<FEIRTypeNative>(*GlobalTables::GetTypeTable().GetInt64());
+  UniqueFEIRType type3 = std::make_unique<FEIRTypeNative>(*GlobalTables::GetTypeTable().GetRef());
+  UniqueFEIRType type4 =  type1->Clone();
+  EXPECT_EQ(type1->IsEqualTo(type2), false);
+  EXPECT_EQ(type1->IsEqualTo(type3), false);
+  EXPECT_EQ(type1->IsEqualTo(type4), true);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/feir_var_test.cpp b/src/hir2mpl/test/common/feir_var_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ea700416627f205bfa8da7a25a40439f5db2cf25
--- /dev/null
+++ b/src/hir2mpl/test/common/feir_var_test.cpp
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "feir_test_base.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "hir2mpl_ut_regx.h"
+#include "feir_builder.h"
+
+namespace maple {
+class FEIRVarTest : public FEIRTestBase {
+ public:
+  FEIRVarTest() = default;
+  virtual ~FEIRVarTest() = default;
+};
+
+TEST_F(FEIRVarTest, FEIRVarReg) {
+  std::unique_ptr<FEIRType> type = FEIRTypeHelper::CreateTypeByJavaName("Ltest/lang/Object;", false, true);
+  FEIRVarReg varReg(1, std::move(type));
+  varReg.SetGlobal(false);
+  MIRSymbol *symbol = varReg.GenerateMIRSymbol(mirBuilder);
+  RedirectCout();
+  std::string symbolName = symbol->GetName();
+  std::string strPattern = HIR2MPLUTRegx::RegName(1) + "_" + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber);
+  EXPECT_EQ(HIR2MPLUTRegx::Match(symbolName, strPattern), true);
+  symbol->Dump(true, 0);
+  std::string symbolDump = GetBufferString();
+  std::string strPattern2 = "var %" + HIR2MPLUTRegx::RegName(1) + "_" + HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber) +
+                            HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(symbolDump, strPattern2), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRVarTest, FEIRVarName) {
+  std::unique_ptr<FEIRType> type = FEIRTypeHelper::CreateTypeByJavaName("Ltest/lang/Object;", false, true);
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ltest_2Flang_2FObject_3B_7Cklass");
+  FEIRVarName varName(nameIdx, std::move(type));
+  varName.SetGlobal(true);
+  MIRSymbol *symbol = varName.GenerateMIRSymbol(mirBuilder);
+  RedirectCout();
+  std::string symbolName = symbol->GetName();
+  EXPECT_EQ(symbolName, "Ltest_2Flang_2FObject_3B_7Cklass");
+  symbol->Dump(false, 0);
+  std::string symbolDump = GetBufferString();
+  std::string strPattern2 = std::string("var \\$") + "Ltest_2Flang_2FObject_3B_7Cklass" + HIR2MPLUTRegx::Any();
+  EXPECT_EQ(HIR2MPLUTRegx::Match(symbolDump, strPattern2), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRVarTest, FEIRVarTransDirect) {
+  UniqueFEIRVar var = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  FEIRVarTrans trans(FEIRVarTransKind::kFEIRVarTransDirect, var);
+  RedirectCout();
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType type1T = trans.GetType(type1);
+  type1T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("Ltest/lang/Object;", false, true);
+  UniqueFEIRType type2T = trans.GetType(type2);
+  type2T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ltest_2Flang_2FObject_3B>>");
+  ClearBufferString();
+
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("I", false, false);
+  UniqueFEIRType type3T = trans.GetType(type3);
+  type3T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+
+  UniqueFEIRType type4 = FEIRTypeHelper::CreateTypeByJavaName("[I", false, true);
+  UniqueFEIRType type4T = trans.GetType(type4);
+  type4T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  RestoreCout();
+}
+
+TEST_F(FEIRVarTest, FEIRVarTransArrayDimIncr) {
+  UniqueFEIRVar var = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  FEIRVarTrans trans(FEIRVarTransKind::kFEIRVarTransArrayDimIncr, var);
+  RedirectCout();
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType type1T = trans.GetType(type1);
+  UniqueFEIRType type1T2 = trans.GetType(type1, PTY_ref, false);
+  type1T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  ClearBufferString();
+  type1T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] <* <$Ljava_2Flang_2FObject_3B>>>");
+  ClearBufferString();
+
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, true);
+  UniqueFEIRType type2T = trans.GetType(type2);
+  UniqueFEIRType type2T2 = trans.GetType(type2, PTY_ref, false);
+  type2T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <$Ljava_2Flang_2FObject_3B>>>>>>");
+  ClearBufferString();
+  type2T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <$Ljava_2Flang_2FObject_3B>>>>>>");
+  ClearBufferString();
+
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("I", false, false);
+  UniqueFEIRType type3T = trans.GetType(type3);
+  UniqueFEIRType type3T2 = trans.GetType(type3, PTY_ref, false);
+  type3T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type3T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] i32>");
+  ClearBufferString();
+
+  UniqueFEIRType type4 = FEIRTypeHelper::CreateTypeByJavaName("[I", false, true);
+  UniqueFEIRType type4T = trans.GetType(type4);
+  UniqueFEIRType type4T2 = trans.GetType(type4, PTY_ref, false);
+  type4T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] i32>>>>");
+  ClearBufferString();
+  type4T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] i32>>>>");
+  ClearBufferString();
+  RestoreCout();
+}
+
+TEST_F(FEIRVarTest, FEIRVarTransArrayDimDecr) {
+  UniqueFEIRVar var = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  FEIRVarTrans trans(FEIRVarTransKind::kFEIRVarTransArrayDimDecr, var);
+  RedirectCout();
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, false);
+  UniqueFEIRType type1T = trans.GetType(type1);
+  UniqueFEIRType type1T2 = trans.GetType(type1, PTY_ref, false);
+  type1T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  ClearBufferString();
+  type1T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("[[Ljava/lang/Object;", false, true);
+  UniqueFEIRType type2T = trans.GetType(type2);
+  UniqueFEIRType type2T2 = trans.GetType(type2, PTY_ref, false);
+  type2T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  ClearBufferString();
+  type2T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  ClearBufferString();
+
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("[I", false, false);
+  UniqueFEIRType type3T = trans.GetType(type3);
+  UniqueFEIRType type3T2 = trans.GetType(type3, PTY_ref, false);
+  type3T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type3T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+
+  UniqueFEIRType type4 = FEIRTypeHelper::CreateTypeByJavaName("[[I", false, false);
+  UniqueFEIRType type4T = trans.GetType(type4);
+  UniqueFEIRType type4T2 = trans.GetType(type4, PTY_ref, false);
+  type4T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type4T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] i32>");
+  ClearBufferString();
+  RestoreCout();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/hir2mplUT.cpp b/src/hir2mpl/test/common/hir2mplUT.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..63d4d71783ae549bf016efff769fe6d68a7d32e6
--- /dev/null
+++ b/src/hir2mpl/test/common/hir2mplUT.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <iostream>
+#include "mpl_logging.h"
+#include "mir_module.h"
+#include "hir2mpl_ut_options.h"
+#include "basic_io.h"
+#include "base64.h"
+#include "jbc_input.h"
+#include "fe_manager.h"
+#include "fe_file_type.h"
+#include "fe_type_hierarchy.h"
+#include "hir2mpl_ut_environment.h"
+
+using namespace maple;
+void GenBase64ForFile(const std::string &fileName) {
+  BasicIOMapFile file(fileName);
+  if (!file.OpenAndMap()) {
+    FATAL(kLncFatal, "Can not open the input file %s for base64 convert.", fileName.c_str());
+  }
+  std::string base64Str = Base64::Encode(file.GetPtr(), file.GetLength());
+  size_t length = base64Str.length();
+  size_t start = 0;
+  const size_t width = 60;
+  while (start < length) {
+    std::cout << "\"" << base64Str.substr(start, width) << "\"" << std::endl;
+    start += width;
+  }
+  file.Close();
+}
+
+int main(int argc, char **argv) {
+  ::testing::AddGlobalTestEnvironment(new HIR2MPLUTEnvironment);
+  FEManager::Init(HIR2MPLUTEnvironment::GetMIRModule());
+  HIR2MPLUTOptions options;
+  if (!options.SolveArgs(argc, argv)) {
+    return 0;
+  }
+  if (options.GetRunAll()) {
+    if (argc > 1) {
+      argc--;
+      argv++;
+    }
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+  }
+  if (options.GetRunAllWithCore()) {
+    CHECK_FATAL(argc > 2, "In RunAllWithCore mode, argc must larger than 2");
+    argc -= 2;
+    argv += 2;
+    FEManager::GetTypeManager().LoadMplt(options.GetCoreMpltName(), FETypeFlag::kSrcMpltSys);
+    FETypeHierarchy::GetInstance().InitByGlobalTable();
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+  }
+  HIR2MPLUTEnvironment::GetMIRModule().SetFlavor(maple::kFeProduced);
+  HIR2MPLUTEnvironment::GetMIRModule().SetSrcLang(maple::kSrcLangJava);
+  if (options.GetGenBase64()) {
+    GenBase64ForFile(options.GetBase64SrcFileName());
+  }
+  jbc::JBCInput jbcInput(HIR2MPLUTEnvironment::GetMIRModule());
+  if (options.GetClassFileList().size() > 0) {
+    jbcInput.ReadClassFiles(options.GetClassFileList());
+  }
+  if (options.GetJarFileList().size() > 0) {
+    jbcInput.ReadJarFiles(options.GetJarFileList());
+  }
+  if (options.GetMpltFileList().size() > 0) {
+    if (FEManager::GetTypeManager().LoadMplts(options.GetMpltFileList(), FETypeFlag::kSrcMplt, "Load mplt")) {
+      INFO(kLncInfo, "Load mplt...success");
+    } else {
+      INFO(kLncInfo, "Load mplt...failed");
+    }
+  }
+  return 0;
+}
diff --git a/src/hir2mpl/test/common/hir2mpl_ut.h b/src/hir2mpl/test/common/hir2mpl_ut.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdf9da4b4d24af8b5bb70a179debc4b725c382ee
--- /dev/null
+++ b/src/hir2mpl/test/common/hir2mpl_ut.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPLUT_INCLUDE_HIR2MPL_UT_H
+#define HIR2MPLUT_INCLUDE_HIR2MPL_UT_H
+#include "mir_module.h"
+
+extern maple::MIRModule &module;
+extern HIR2MPLUTOptions &options;
+#endif  // HIR2MPLUT_INCLUDE_HIR2MPL_UT_H
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/hir2mpl_ut_environment.h b/src/hir2mpl/test/common/hir2mpl_ut_environment.h
new file mode 100644
index 0000000000000000000000000000000000000000..46f5dae9ddd3c6436d79a52c73ea63c55ea4ad14
--- /dev/null
+++ b/src/hir2mpl/test/common/hir2mpl_ut_environment.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_TEST_HIR2MPL_UT_ENVIRONMENT_H
+#define HIR2MPL_TEST_HIR2MPL_UT_ENVIRONMENT_H
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "mir_module.h"
+#include "mir_nodes.h"
+
+namespace maple {
+class HIR2MPLUTEnvironment : public ::testing::Environment {
+ public:
+  HIR2MPLUTEnvironment() = default;
+  ~HIR2MPLUTEnvironment() = default;
+
+  static MIRModule &GetMIRModule() {
+    static MIRModule module("hir2mplUT");
+    return module;
+  }
+
+  void SetUp() override {
+    theMIRModule = &GetMIRModule();
+  }
+};
+}  // namespace maple
+#endif  // HIR2MPL_TEST_HIR2MPL_UT_ENVIRONMENT_H
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/hir2mpl_ut_options.cpp b/src/hir2mpl/test/common/hir2mpl_ut_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5d7fb3d74a05ce8c28e9928ca270df297ef44dfc
--- /dev/null
+++ b/src/hir2mpl/test/common/hir2mpl_ut_options.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cl_option.h"
+#include "driver_options.h"
+#include "hir2mpl_ut_options.h"
+#include <iostream>
+#include "mpl_logging.h"
+#include "parser_opt.h"
+#include "triple.h"
+
+namespace maple {
+
+namespace opts::hir2mplut {
+
+static maplecl::OptionCategory hir2mplUTCategory;
+
+maplecl::Option<bool> help({"--help", "-h"},
+                      "  -h, -help              : print usage and exit",
+                      {hir2mplUTCategory});
+maplecl::Option<std::string> genBase64({"--gen-base64", "-gen-base64"},
+                                  "  -gen-base64 file.xx       : generate base64 string for file.xx",
+                                  {hir2mplUTCategory});
+maplecl::Option<std::string> mplt({"--mplt", "-mplt"},
+                             "  -mplt lib1.mplt,lib2.mplt\n"
+                             "                         : input mplt files",
+                             {hir2mplUTCategory});
+
+maplecl::Option<std::string> inClass({"--in-class", "-in-class"},
+                                "  -in-class file1.jar,file2.jar\n"
+                                "                         : input class files",
+                                {hir2mplUTCategory});
+
+maplecl::Option<std::string> inJar({"--in-jar", "-in-jar"},
+                              "  -in-jar file1.jar,file2.jar\n"
+                              "                         : input jar files",
+                              {hir2mplUTCategory});
+}
+
+HIR2MPLUTOptions::HIR2MPLUTOptions()
+    : runAll(false),
+      runAllWithCore(false),
+      genBase64(false),
+      base64SrcFileName(""),
+      coreMpltName("") {}
+
+void HIR2MPLUTOptions::DumpUsage() const {
+  std::cout << "========================================\n"
+            << " Run gtest: hir2mplUT\n"
+            << " Run gtest: hir2mplUT test [ options for gtest ]\n"
+            << " Run ext mode: hir2mplUT ext [ options ]\n"
+            << "========= options for ext mode =========\n";
+  maplecl::CommandLine::GetCommandLine().HelpPrinter(opts::hir2mplut::hir2mplUTCategory);
+  exit(1);
+}
+
+bool HIR2MPLUTOptions::SolveArgs(int argc, char **argv) {
+  if (argc == 1) {
+    runAll = true;
+    return true;
+  }
+  if (std::string(argv[1]).compare("test") == 0) {
+    runAll = true;
+    return true;
+  }
+  if (std::string(argv[1]).compare("testWithMplt") == 0) {
+    runAllWithCore = true;
+    CHECK_FATAL(argc > 2, "In TestWithMplt mode, core.mplt must be specified");
+    coreMpltName = argv[2];
+    return true;
+  }
+  if (std::string(argv[1]).compare("ext") != 0) {
+    FATAL(kLncFatal, "Undefined mode");
+    return false;
+  }
+  runAll = false;
+
+  maplecl::CommandLine::GetCommandLine().Parse(argc, argv, opts::hir2mplut::hir2mplUTCategory);
+
+  if (opts::hir2mplut::help) {
+    DumpUsage();
+    return false;
+  }
+
+  if (opts::hir2mplut::genBase64.IsEnabledByUser()) {
+    base64SrcFileName = opts::hir2mplut::genBase64;
+  }
+
+  if (opts::hir2mplut::inClass.IsEnabledByUser()) {
+    Split(opts::hir2mplut::inClass, ',', std::back_inserter(classFileList));
+  }
+
+  if (opts::hir2mplut::inJar.IsEnabledByUser()) {
+    Split(opts::hir2mplut::inJar, ',', std::back_inserter(jarFileList));
+  }
+
+  if (opts::hir2mplut::mplt.IsEnabledByUser()) {
+    Split(opts::hir2mplut::mplt, ',', std::back_inserter(mpltFileList));
+  }
+
+  return true;
+}
+
+template <typename Out>
+void HIR2MPLUTOptions::Split(const std::string &s, char delim, Out result) {
+  std::stringstream ss;
+  ss.str(s);
+  std::string item;
+  while (std::getline(ss, item, delim)) {
+    *(result++) = item;
+  }
+}
+}  // namespace maple
diff --git a/src/hir2mpl/test/common/hir2mpl_ut_options.h b/src/hir2mpl/test/common/hir2mpl_ut_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..06df9793cd4f2d3d8cc6d8c7798e74ffe5f92e87
--- /dev/null
+++ b/src/hir2mpl/test/common/hir2mpl_ut_options.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_HIR2MPL_UT_OPTIONS_H
+#define HIR2MPL_INCLUDE_HIR2MPL_UT_OPTIONS_H
+#include <string>
+#include <list>
+
+namespace maple {
+class HIR2MPLUTOptions {
+ public:
+  HIR2MPLUTOptions();
+  ~HIR2MPLUTOptions() = default;
+  void DumpUsage() const;
+  bool SolveArgs(int argc, char **argv);
+  template <typename Out>
+  static void Split(const std::string &s, char delim, Out result);
+
+  static HIR2MPLUTOptions &GetInstance() {
+    static HIR2MPLUTOptions options;
+    return options;
+  }
+
+  bool GetRunAll() const {
+    return runAll;
+  }
+
+  bool GetRunAllWithCore() const {
+    return runAllWithCore;
+  }
+
+  bool GetGenBase64() const {
+    return genBase64;
+  }
+
+  std::string GetBase64SrcFileName() const {
+    return base64SrcFileName;
+  }
+
+  std::string GetCoreMpltName() const {
+    return coreMpltName;
+  }
+
+  const std::list<std::string> &GetClassFileList() const {
+    return classFileList;
+  }
+
+  const std::list<std::string> &GetJarFileList() const {
+    return jarFileList;
+  }
+
+  const std::list<std::string> &GetMpltFileList() const {
+    return mpltFileList;
+  }
+
+ private:
+  bool runAll;
+  bool runAllWithCore;
+  bool genBase64;
+  std::string base64SrcFileName;
+  std::string coreMpltName;
+  std::list<std::string> classFileList;
+  std::list<std::string> jarFileList;
+  std::list<std::string> mpltFileList;
+};
+}  // namespace maple
+
+#endif  // HIR2MPL_INCLUDE_HIR2MPL_UT_OPTIONS_H
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/hir2mpl_ut_regx.cpp b/src/hir2mpl/test/common/hir2mpl_ut_regx.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..19f9a4d79ec223ebdea9085969f51816b6452688
--- /dev/null
+++ b/src/hir2mpl/test/common/hir2mpl_ut_regx.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "hir2mpl_ut_regx.h"
+#include <sstream>
+#include <iostream>
+
+namespace maple {
+bool HIR2MPLUTRegx::Match(const std::string &str, const std::string &pattern) {
+  if (std::regex_match(str, std::regex(pattern))) {
+    return true;
+  } else {
+    std::cerr << "Pattern: " << pattern << std::endl;
+    std::cerr << "String: " << str << std::endl;
+    return false;
+  }
+}
+
+std::string HIR2MPLUTRegx::RegName(uint32 regNum) {
+  std::stringstream ss;
+  if (regNum == kAnyNumber) {
+    ss << "Reg[0-9]+";
+  } else {
+    ss << "Reg" << regNum;
+  }
+  return ss.str();
+}
+
+std::string HIR2MPLUTRegx::RefIndex(uint32 typeIdx) {
+  std::stringstream ss;
+  if (typeIdx == kAnyNumber) {
+    ss << "R[0-9]+";
+  } else {
+    ss << "R" << typeIdx;
+  }
+  return ss.str();
+}
+
+std::string HIR2MPLUTRegx::AnyNum(uint32 typeIdx) {
+  std::stringstream ss;
+  if (typeIdx == kAnyNumber) {
+    ss << "[0-9]+";
+  } else {
+    ss << "" << typeIdx;
+  }
+  return ss.str();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/hir2mpl_ut_regx.h b/src/hir2mpl/test/common/hir2mpl_ut_regx.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce67fc974112fa22897a49773929c40946c19cf1
--- /dev/null
+++ b/src/hir2mpl/test/common/hir2mpl_ut_regx.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_UT_INCLUDE_HIR2MPL_UT_REGX_H
+#define HIR2MPL_UT_INCLUDE_HIR2MPL_UT_REGX_H
+#include <string>
+#include <regex>
+#include "types_def.h"
+
+namespace maple {
+class HIR2MPLUTRegx {
+ public:
+  static const uint32 kAnyNumber = 0xFFFFFFFF;
+  HIR2MPLUTRegx() = default;
+  ~HIR2MPLUTRegx() = default;
+  static bool Match(const std::string &str, const std::string &pattern);
+  static std::string RegName(uint32 regNum);
+  static std::string RefIndex(uint32 typeIdx);
+  static std::string AnyNum(uint32 typeIdx);
+  static std::string Any() {
+    return "(.|\r|\n)*";
+  }
+};
+}  // namespace maple
+#endif  // HIR2MPL_UT_INCLUDE_HIR2MPL_UT_REGX_H
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/hir2mpl_ut_regx_test.cpp b/src/hir2mpl/test/common/hir2mpl_ut_regx_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9e438b45e5edf333b01ccf7d5210aa8dd73061d6
--- /dev/null
+++ b/src/hir2mpl/test/common/hir2mpl_ut_regx_test.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "hir2mpl_ut_regx.h"
+
+namespace maple {
+TEST(HIR2MPLUTRegx, Any) {
+  std::string pattern = HIR2MPLUTRegx::Any();
+  std::string str = "\n";
+  EXPECT_EQ(HIR2MPLUTRegx::Match(str, pattern), true);
+}
+
+TEST(HIR2MPLUTRegx, RegName) {
+  std::string patternAny = HIR2MPLUTRegx::RegName(HIR2MPLUTRegx::kAnyNumber);
+  std::string pattern100 = HIR2MPLUTRegx::RegName(100);
+  EXPECT_EQ(HIR2MPLUTRegx::Match("Reg100", patternAny), true);
+  EXPECT_EQ(HIR2MPLUTRegx::Match("Reg100", pattern100), true);
+  EXPECT_EQ(HIR2MPLUTRegx::Match("Reg1000", patternAny), true);
+  EXPECT_EQ(HIR2MPLUTRegx::Match("Reg1000", pattern100), false);
+}
+
+TEST(HIR2MPLUTRegx, RefIndex) {
+  std::string patternAny = HIR2MPLUTRegx::RefIndex(HIR2MPLUTRegx::kAnyNumber);
+  std::string pattern100 = HIR2MPLUTRegx::RefIndex(100);
+  EXPECT_EQ(HIR2MPLUTRegx::Match("R100", patternAny), true);
+  EXPECT_EQ(HIR2MPLUTRegx::Match("R100", pattern100), true);
+  EXPECT_EQ(HIR2MPLUTRegx::Match("R1000", patternAny), true);
+  EXPECT_EQ(HIR2MPLUTRegx::Match("R1000", pattern100), false);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/hir2mpl/test/common/redirect_buffer.h b/src/hir2mpl/test/common/redirect_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..ffbe80810b9d0db3296ceb87a4b8e817070d03df
--- /dev/null
+++ b/src/hir2mpl/test/common/redirect_buffer.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef HIR2MPL_INCLUDE_REDIRECT_BUFFER_H
+#define HIR2MPL_INCLUDE_REDIRECT_BUFFER_H
+#include <sstream>
+#include <iostream>
+
+namespace maple {
+class RedirectBuffer {
+ public:
+  RedirectBuffer() : sbuf(std::cout.rdbuf()), outByErr(false) {}
+  ~RedirectBuffer() = default;
+
+  void RedirectCout(bool outByErrIn = false) {
+    sbuf = RedirectCoutBuf(ss.rdbuf());
+    ss.str("");
+    outByErr = outByErrIn;
+  }
+
+  void RestoreCout() {
+    ss.str("");
+    RedirectCoutBuf(sbuf);
+  }
+
+  std::string GetBufferString() {
+    std::string str = ss.str();
+    ss.str("");
+    if (outByErr) {
+      std::cerr << str;
+    }
+    return str;
+  }
+
+  void ClearBufferString() {
+    ss.str("");
+  }
+
+  std::string RemoveLastReturnChar(const std::string &input) {
+    size_t length = input.length();
+    while (input[length - 1] == '\n') {
+      length--;
+    }
+    return input.substr(0, length);
+  }
+
+ private:
+  std::stringstream ss;
+  std::streambuf *sbuf;
+  bool outByErr;
+
+  std::streambuf *RedirectCoutBuf(std::streambuf *newBuf) {
+    std::streambuf *streamBuf = std::cout.rdbuf();
+    std::cout.rdbuf(newBuf);
+    return streamBuf;
+  }
+};
+}  // namespace maple
+#endif  // HIR2MPL_INCLUDE_REDIRECT_BUFFER_H
\ No newline at end of file
diff --git a/src/hir2mpl/test/cov_check.sh b/src/hir2mpl/test/cov_check.sh
new file mode 100644
index 0000000000000000000000000000000000000000..f1af497bfc7a40feb015bd3e5c362cf2a737c0a5
--- /dev/null
+++ b/src/hir2mpl/test/cov_check.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+CORE_OJ_JAR=${MAPLE_ROOT}/android/emui-10.0/out/target/common/obj/JAVA_LIBRARIES/core-oj_intermediates/classes.jar
+CORE_LIBART_JAR=${MAPLE_ROOT}/android/emui-10.0/out/target/common/obj/JAVA_LIBRARIES/core-libart_intermediates/classes.jar
+
+rm -rf ${MAPLE_ROOT}/report
+${MAPLE_ROOT}/out/target/product/maple_arm64/bin/hir2mplUT ext -gen-base64 xxx.file
+${MAPLE_ROOT}/out/target/product/maple_arm64/bin/hir2mplUT ext -gen-base64 ${MAPLE_ROOT}/hir2mpl/test/jbc_input/JBC0001/Test.class
+${MAPLE_ROOT}/out/target/product/maple_arm64/bin/hir2mplUT ext -in-class xxx.class
+${MAPLE_ROOT}/out/target/product/maple_arm64/bin/hir2mplUT ext -in-class ${MAPLE_ROOT}/hir2mpl/test/jbc_input/JBC0001/Test.class
+${MAPLE_ROOT}/out/target/product/maple_arm64/bin/hir2mplUT ext -in-jar xxx.jar
+${MAPLE_ROOT}/out/target/product/maple_arm64/bin/hir2mplUT ext -in-jar ${CORE_OJ_JAR},${CORE_LIBART_JAR}
+${MAPLE_ROOT}/out/target/product/maple_arm64/bin/hir2mplUT ext -mplt ${MAPLE_ROOT}/out/target/product/maple_arm64-clang-release/lib/host-x86_64-HIR2MPL_DEXO0/libcore-all.mplt
+# ${MAPLE_ROOT}/out/target/product/maple_arm64/bin/hir2mplUT test
+${MAPLE_ROOT}/out/target/product/maple_arm64/bin/hir2mplUT testWithMplt ${MAPLE_ROOT}/out/target/product/maple_arm64-clang-release/lib/host-x86_64-HIR2MPL_DEXO0/libcore-all.mplt
+bash ${MAPLE_ROOT}/zeiss/prebuilt/tools/coverage_check/coverage_check.sh hir2mpl
+
diff --git a/src/hir2mpl/test/hir2mplUT_check.sh b/src/hir2mpl/test/hir2mplUT_check.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9b9c8bdd9f5dccf76fd5d879887090999f9a6d40
--- /dev/null
+++ b/src/hir2mpl/test/hir2mplUT_check.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+set -e
+
+rm -rf ${MAPLE_ROOT}/report
+${MAPLE_ROOT}/output/aarch64-clang-release/bin/hir2mplUT ext -gen-base64 ${MAPLE_ROOT}/src/hir2mpl/test/bytecode_input/class/JBC0001/Test.class
+${MAPLE_ROOT}/output/aarch64-clang-release/bin/hir2mplUT ext -in-class ${MAPLE_ROOT}/src/hir2mpl/test/bytecode_input/class/JBC0001/Test.class
+${MAPLE_ROOT}/output/aarch64-clang-release/bin/hir2mplUT ext -mplt ${MAPLE_ROOT}/output/aarch64-clang-release/libjava-core/host-x86_64-O2/libcore-all.mplt
+${MAPLE_ROOT}/output/aarch64-clang-release/bin/hir2mplUT testWithMplt ${MAPLE_ROOT}/output/aarch64-clang-release/libjava-core/host-x86_64-O2/libcore-all.mplt
+
+
diff --git a/src/hir2mpl/test/ops_ut_check.sh b/src/hir2mpl/test/ops_ut_check.sh
new file mode 100644
index 0000000000000000000000000000000000000000..36dcf8ccc32dcea69d10edfebe5d90bf72a3ed67
--- /dev/null
+++ b/src/hir2mpl/test/ops_ut_check.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+set -e
+
+rm -rf ${MAPLE_ROOT}/report
+${MAPLE_ROOT}/out/target/product/maple_arm64-clang-release/bin/hir2mplUT ext -gen-base64 ${MAPLE_ROOT}/hir2mpl/test/jbc_input/JBC0001/Test.class
+${MAPLE_ROOT}/out/target/product/maple_arm64-clang-release/bin/hir2mplUT ext -in-class ${MAPLE_ROOT}/hir2mpl/test/jbc_input/JBC0001/Test.class
+${MAPLE_ROOT}/out/target/product/maple_arm64-clang-release/bin/hir2mplUT ext -mplt ${MAPLE_ROOT}/out/target/product/maple_arm64-clang-release/lib/host-x86_64-OPS_O2/libcore-all.mplt
+${MAPLE_ROOT}/out/target/product/maple_arm64-clang-release/bin/hir2mplUT testWithMplt ${MAPLE_ROOT}/out/target/product/maple_arm64-clang-release/lib/host-x86_64-OPS_O2/libcore-all.mplt
+
+
diff --git a/src/mapleall/BUILD.gn b/src/mapleall/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..73605d9877d2425298c4152e1e56be1145fb713c
--- /dev/null
+++ b/src/mapleall/BUILD.gn
@@ -0,0 +1,123 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+config("mapleallcompilecfg") {
+  cflags_cc = []
+  cflags_cc += [
+    "-std=c++17",
+    "-fno-common",
+  ]
+
+  if (ASAN == 1) {
+    cflags_cc += [
+      "-fsanitize=address"
+    ]
+    libs = [
+      "${LLVMLIBDIR}/libclang_rt.asan-x86_64.a"
+    ]
+  }
+
+  if (TARGET == "aarch64") {
+    cflags_cc += [
+      "-DTARGAARCH64",
+      "-DMAPLE_ROOT=\"${MAPLE_ROOT}\"",
+    ]
+  }
+
+  if (TARGET == "x86_64") {
+    cflags_cc += [
+      "-DTARGX86_64",
+      "-DMAPLE_ROOT=\"${MAPLE_ROOT}\"",
+    ]
+  }
+
+  if (TARGET == "riscv64") {
+    cflags_cc += [
+      "-DTARGRISCV64",
+      "-DMAPLE_ROOT=\"${MAPLE_ROOT}\"",
+    ]
+  }
+
+  if (TARGET == "ark") {
+    cflags_cc += [
+      "-DTARGARK",
+      "-DMAPLE_ROOT=\"${MAPLE_ROOT}\"",
+    ]
+  }
+
+  if (GN_BUILD_TYPE == "DEBUG") {
+    cflags_c += [ "-DDEBUG" ]
+    cflags_cc += [ "-DDEBUG" ]
+  }
+
+  if (HOST_ARCH == 64) {
+    ldflags = []
+    ldflags += [
+      "-fPIC",
+      "-rdynamic",
+      "-lpthread",
+      "-Wl,-z,relro",
+      "-Wl,-z,now",
+      "-Wl,-z,noexecstack",
+      "-pie",
+    ]
+  }
+
+  if (ASAN == 1) {
+    ldflags += ["-ldl"]
+  }
+  if (COV == 1) {
+    ldflags += ["--coverage"]
+    cflags_cc += [
+      "-fprofile-arcs",
+      "-ftest-coverage"
+    ]
+  }
+  if (GPROF == 1) {
+    ldflags += ["-pg"]
+    cflags_cc += ["-pg"]
+  }
+
+  if (MAJOR_VERSION != "") {
+    cflags_cc += [ "-DMAJOR_VERSION=${MAJOR_VERSION}", ]
+  }
+
+  if (MINOR_VERSION != "") {
+    cflags_cc += [ "-DMINOR_VERSION=${MINOR_VERSION}", ]
+  }
+
+  if (RELEASE_VERSION != "") {
+    cflags_cc += [ "-DRELEASE_VERSION=\"${RELEASE_VERSION}\"", ]
+  }
+
+  if (BUILD_VERSION != "") {
+    cflags_cc += [ "-DBUILD_VERSION=${BUILD_VERSION}", ]
+  }
+
+  if (GIT_REVISION != "") {
+    cflags_cc += [ "-DGIT_REVISION=\"${GIT_REVISION}\"", ]
+  }
+}
+
+group("maple") {
+  deps = [ "${MAPLEALL_ROOT}/maple_driver:maple" ]
+}
+
+group("irbuild") {
+  deps = [ "${MAPLEALL_ROOT}/maple_ir:irbuild" ]
+}
+
+group("maplegen") {
+  deps = [ "${MAPLEALL_ROOT}/maple_be:maplegen" ]
+}
diff --git a/src/mapleall/CMakeLists.txt b/src/mapleall/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a581092ca23f035569113e65834fe799ea64a822
--- /dev/null
+++ b/src/mapleall/CMakeLists.txt
@@ -0,0 +1,43 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+# Version Info
+if(NOT ${MAJOR_VERSION} STREQUAL "")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMAJOR_VERSION=${MAJOR_VERSION}")
+endif()
+if(NOT ${MINOR_VERSION} STREQUAL "")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMINOR_VERSION=${MINOR_VERSION}")
+endif()
+if(NOT ${RELEASE_VERSION} STREQUAL "")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DRELEASE_VERSION=\\\"${RELEASE_VERSION}\\\"")
+endif()
+if(NOT ${BUILD_VERSION} STREQUAL "")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DBUILD_VERSION=${BUILD_VERSION}")
+endif()
+if(NOT ${GIT_REVISION} STREQUAL "")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGIT_REVISION=\\\"${GIT_REVISION}\\\"")
+endif()
+
+
+add_subdirectory(maple_util)
+add_subdirectory(mempool)
+add_subdirectory(maple_ipa)
+add_subdirectory(maple_phase)
+add_subdirectory(mpl2mpl)
+add_subdirectory(maple_me)
+add_subdirectory(maple_be)
+add_subdirectory(maple_driver)
+add_subdirectory(maple_ir)
+add_subdirectory(maple_pgo)
diff --git a/src/mapleall/bin/dex2mpl b/src/mapleall/bin/dex2mpl
new file mode 100755
index 0000000000000000000000000000000000000000..3393eaf9df84834196ddeee3e5c6c636a7679ec5
Binary files /dev/null and b/src/mapleall/bin/dex2mpl differ
diff --git a/src/mapleall/bin/java2jar b/src/mapleall/bin/java2jar
new file mode 100755
index 0000000000000000000000000000000000000000..c8d50f6f0e8a207ff57b0eb23442f6015c6dc97d
--- /dev/null
+++ b/src/mapleall/bin/java2jar
@@ -0,0 +1,20 @@
+#!/bin/bash
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+OUTPUT=$1
+CORE_ALL_JAR=$2
+shift 2
+javac -g -d . -bootclasspath ${CORE_ALL_JAR} $@
+jar -cvf ${OUTPUT} *.class
diff --git a/src/mapleall/maple_be/BUILD.gn b/src/mapleall/maple_be/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..0abb44fdd19f8d8950c1bea101beee2943448be6
--- /dev/null
+++ b/src/mapleall/maple_be/BUILD.gn
@@ -0,0 +1,355 @@
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+include_directories = [
+  "${MAPLEALL_ROOT}/maple_be/include/cg",
+  "${MAPLEALL_ROOT}/maple_be/include/ad",
+  "${MAPLE_BUILD_OUTPUT}/common/target",
+  "${MAPLEALL_ROOT}/maple_pgo/include",
+  "${MAPLEALL_ROOT}/maple_be/include/ad/target",
+  "${MAPLEALL_ROOT}/maple_be/include/be",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_me/include",
+  "${MAPLEALL_ROOT}/mpl2mpl/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include/old",
+  "${MAPLEALL_ROOT}/maple_phase/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  "${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat",
+]
+
+deps_libcg = [ "${MAPLEALL_ROOT}/maple_pgo:libmplpgo" ]
+
+deps_libmplbe = [ ":libcglowerer" ]
+
+if (TARGET == "aarch64") {
+  include_directories += [
+    "${MAPLEALL_ROOT}/maple_be/include/cg/aarch64",
+    "${MAPLEALL_ROOT}/maple_be/include/be/aarch64",
+  ]
+  deps_libcg += [ ":libcgaarch64",
+                  ":libcgphases",
+  ]
+}
+
+if (TARGET == "x86_64") {
+  include_directories += [
+    "${MAPLEALL_ROOT}/maple_be/include/cg/x86_64",
+    "${MAPLEALL_ROOT}/maple_be/include/be/x86_64",
+  ]
+  deps_libcg += [ ":libcgx8664",
+                  ":libcgx86phases"
+ ]
+}
+
+if (TARGET == "riscv64") {
+  include_directories += [
+    "${MAPLEALL_ROOT}/maple_be/include/cg/riscv64",
+    "${MAPLEALL_ROOT}/maple_be/include/be/riscv64",
+  ]
+  deps_libcg += [ ":libcgriscv64" ]
+}
+
+if (TARGET == "ark") {
+  include_directories += [
+    "${MAPLEALL_ROOT}/maple_be/include/cg/ark",
+    "${MAPLEALL_ROOT}/maple_be/include/be/ark",
+  ]
+  deps_libcg += [ ":libcgark" ]
+}
+
+src_libmplad = [ "src/ad/mad.cpp" ]
+
+src_libcglowerer = [
+  "src/be/bbt.cpp",
+  "src/be/trycatchblockslower.cpp",
+  "src/be/lower.cpp",
+]
+
+src_libmplbe = [
+  "src/be/becommon.cpp",
+  "src/be/switch_lowerer.cpp",
+  "src/be/rt.cpp",
+]
+
+src_libcgaarch64 = [
+  "src/cg/aarch64/aarch64_abi.cpp",
+  "src/cg/aarch64/aarch64_call_conv.cpp",
+  "src/cg/aarch64/mpl_atomic.cpp",
+  "src/cg/aarch64/aarch64_cfi_generator.cpp",
+  "src/cg/aarch64/aarch64_cgfunc.cpp",
+  "src/cg/aarch64/aarch64_dependence.cpp",
+  "src/cg/aarch64/aarch64_data_dep_base.cpp",
+  "src/cg/aarch64/aarch64_ebo.cpp",
+  "src/cg/aarch64/aarch64_emitter.cpp",
+  "src/cg/aarch64/aarch64_fixshortbranch.cpp",
+  "src/cg/aarch64/aarch64_global.cpp",
+  "src/cg/aarch64/aarch64_proepilog.cpp",
+  "src/cg/aarch64/aarch64_operand.cpp",
+  "src/cg/aarch64/aarch64_color_ra.cpp",
+  "src/cg/aarch64/aarch64_reg_info.cpp",
+  "src/cg/aarch64/aarch64_ssa.cpp",
+  "src/cg/aarch64/aarch64_prop.cpp",
+  "src/cg/aarch64/aarch64_pgo_gen.cpp",
+  "src/cg/aarch64/aarch64_dce.cpp",
+  "src/cg/aarch64/aarch64_phi_elimination.cpp",
+  "src/cg/aarch64/aarch64_reg_coalesce.cpp",
+  "src/cg/aarch64/aarch64_ico.cpp",
+  "src/cg/aarch64/aarch64_insn.cpp",
+  "src/cg/aarch64/aarch64_isa.cpp",
+  "src/cg/aarch64/aarch64_memlayout.cpp",
+  "src/cg/aarch64/aarch64_args.cpp",
+  "src/cg/aarch64/aarch64_live.cpp",
+  "src/cg/aarch64/aarch64_yieldpoint.cpp",
+  "src/cg/aarch64/aarch64_offset_adjust.cpp",
+  "src/cg/aarch64/aarch64_optimize_common.cpp",
+  "src/cg/aarch64/aarch64_peep.cpp",
+  "src/cg/aarch64/aarch64_reaching.cpp",
+  "src/cg/aarch64/aarch64_schedule.cpp",
+  "src/cg/aarch64/aarch64_strldr.cpp",
+  "src/cg/aarch64/aarch64_ra_opt.cpp",
+  "src/cg/aarch64/aarch64_tailcall.cpp",
+  "src/cg/aarch64/aarch64_alignment.cpp",
+  "src/cg/aarch64/aarch64_regsaves.cpp",
+  "src/cg/aarch64/aarch64_utils.cpp",
+  "src/cg/aarch64/aarch64_cg.cpp",
+  "src/cg/aarch64/aarch64_validbit_opt.cpp",
+  "src/cg/aarch64/aarch64_rce.cpp",
+  "src/cg/aarch64/aarch64_cfgo.cpp",
+  "src/cg/aarch64/aarch64_isolate_fastpath.cpp",
+  "src/cg/aarch64/aarch64_rematerialize.cpp",
+]
+
+src_libcgx86phases = [
+  "src/cg/peep.cpp",
+  "src/cg/alignment.cpp",
+  "src/cg/reaching.cpp",
+  "src/cg/local_opt.cpp",
+  "src/cg/cfgo.cpp",
+]
+
+src_libcgx8664 = [
+  "src/cg/x86_64/x64_cg.cpp",
+  "src/cg/x86_64/x64_MPIsel.cpp",
+  "src/cg/x86_64/x64_cgfunc.cpp",
+  "src/cg/x86_64/x64_memlayout.cpp",
+  "src/cg/x86_64/x64_emitter.cpp",
+  "src/cg/x86_64/x64_abi.cpp",
+  "src/cg/x86_64/x64_call_conv.cpp",
+  "src/cg/x86_64/x64_standardize.cpp",
+  "src/cg/x86_64/x64_live.cpp",
+  "src/cg/x86_64/x64_reg_info.cpp",
+  "src/cg/x86_64/x64_proepilog.cpp",
+  "src/cg/x86_64/x64_args.cpp",
+  "src/cg/x86_64/x64_peep.cpp",
+  "src/cg/x86_64/x64_reaching.cpp",
+  "src/cg/x86_64/x64_local_opt.cpp",
+  "src/cg/x86_64/x64_cfgo.cpp",
+  "src/cg/x86_64/x64_isa.cpp",
+  "src/cg/x86_64/x64_optimize_common.cpp",
+]
+
+src_libcgriscv64 = [
+  "src/cg/riscv64/mpl_atomic.cpp",
+  "src/cg/riscv64/riscv64_abi.cpp",
+  "src/cg/riscv64/riscv64_args.cpp",
+  "src/cg/riscv64/riscv64_cg.cpp",
+  "src/cg/riscv64/riscv64_cgfunc.cpp",
+  "src/cg/riscv64/riscv64_color_ra.cpp",
+  "src/cg/riscv64/riscv64_dependence.cpp",
+  "src/cg/riscv64/riscv64_ebo.cpp",
+  "src/cg/riscv64/riscv64_emitter.cpp",
+  "src/cg/riscv64/riscv64_fixshortbranch.cpp",
+  "src/cg/riscv64/riscv64_global.cpp",
+  "src/cg/riscv64/riscv64_ico.cpp",
+  "src/cg/riscv64/riscv64_immediate.cpp",
+  "src/cg/riscv64/riscv64_insn.cpp",
+  "src/cg/riscv64/riscv64_isa.cpp",
+  "src/cg/riscv64/riscv64_live.cpp",
+  "src/cg/riscv64/riscv64_lsra.cpp",
+  "src/cg/riscv64/riscv64_memlayout.cpp",
+  "src/cg/riscv64/riscv64_offset_adjust.cpp",
+  "src/cg/riscv64/riscv64_operand.cpp",
+  "src/cg/riscv64/riscv64_optimize_common.cpp",
+  "src/cg/riscv64/riscv64_peep.cpp",
+  "src/cg/riscv64/riscv64_proepilog.cpp",
+  "src/cg/riscv64/riscv64_reaching.cpp",
+  "src/cg/riscv64/riscv64_reg_alloc.cpp",
+  "src/cg/riscv64/riscv64_schedule.cpp",
+  "src/cg/riscv64/riscv64_strldr.cpp",
+  "src/cg/riscv64/riscv64_yieldpoint.cpp",
+  "src/cg/riscv64/riscv64_ra_opt.cpp",
+]
+
+src_libcgark = [ "src/cg/ark/foo.cpp" ]
+
+src_libcgphases = [
+  "src/cg/cfi_generator.cpp",
+  "src/cg/cfgo.cpp",
+  "src/cg/local_opt.cpp",
+  "src/cg/ebo.cpp",
+  "src/cg/ra_opt.cpp",
+  "src/cg/tailcall.cpp",
+  "src/cg/cg_ssa.cpp",
+  "src/cg/cg_prop.cpp",
+  "src/cg/cg_dce.cpp",
+  "src/cg/cg_phi_elimination.cpp",
+  "src/cg/reg_coalesce.cpp",
+  "src/cg/global.cpp",
+  "src/cg/ico.cpp",
+  "src/cg/peep.cpp",
+  "src/cg/pressure.cpp",
+  "src/cg/reaching.cpp",
+  "src/cg/schedule.cpp",
+  "src/cg/strldr.cpp",
+  "src/cg/cg_dominance.cpp",
+  "src/cg/cg_pre.cpp",
+  "src/cg/cg_occur.cpp",
+  "src/cg/cg_ssu_pre.cpp",
+  "src/cg/cg_ssa_pre.cpp",
+  "src/cg/cg_pgo_gen.cpp",
+  "src/cg/cg_pgo_use.cpp",
+  "src/cg/regsaves.cpp",
+  "src/cg/cg_critical_edge.cpp",
+  "src/cg/alignment.cpp",
+  "src/cg/cg_validbit_opt.cpp",
+  "src/cg/cg_rce.cpp",
+  "src/cg/rematerialize.cpp",
+  "src/cg/control_dep_analysis.cpp",
+  "src/cg/data_dep_base.cpp",
+  "src/cg/data_dep_analysis.cpp",
+  "src/cg/global_schedule.cpp",
+]
+
+src_libcg = [
+  "src/cg/args.cpp",
+  "src/cg/cg_irbuilder.cpp",
+  "src/cg/cfi.cpp",
+  "src/cg/cgbb.cpp",
+  "src/cg/operand.cpp",
+  "src/cg/cgfunc.cpp",
+  "src/cg/cg_cfg.cpp",
+  "src/cg/cg_option.cpp",
+  "src/cg/cg_options.cpp",
+  "src/cg/dbg.cpp",
+  "src/cg/optimize_common.cpp",
+  "src/cg/eh_func.cpp",
+  "src/cg/emit.cpp",
+  "src/cg/live.cpp",
+  "src/cg/loop.cpp",
+  "src/cg/isel.cpp",
+  "src/cg/standardize.cpp",
+  "src/cg/memlayout.cpp",
+  "src/cg/yieldpoint.cpp",
+  "src/cg/label_creation.cpp",
+  "src/cg/offset_adjust.cpp",
+  "src/cg/reg_alloc.cpp",
+  "src/cg/reg_alloc_basic.cpp",
+  "src/cg/reg_alloc_lsra.cpp",
+  "src/cg/proepilog.cpp",
+  "src/cg/isolate_fastpath.cpp",
+  "src/cg/cg.cpp",
+  "src/cg/isa.cpp",
+  "src/cg/insn.cpp",
+  "src/cg/cg_phasemanager.cpp",
+]
+
+cflags_cc -= [ "-DRC_NO_MMAP" ]
+cflags_cc -= [ "-DMIR_JAVA=1" ]
+
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+
+static_library("libmplad") {
+  sources = src_libmplad
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+
+  cflags_cc += [ "-DRC_NO_MMAP" ]
+}
+
+source_set("libcglowerer") {
+  sources = src_libcglowerer
+  include_dirs = include_directories
+}
+
+static_library("libmplbe") {
+  sources = src_libmplbe
+  deps = deps_libmplbe
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
+
+source_set("libcgaarch64") {
+  sources = src_libcgaarch64
+  include_dirs = include_directories
+}
+
+source_set("libcgx8664") {
+  sources = src_libcgx8664
+  include_dirs = include_directories
+}
+
+source_set("libcgx86phases") {
+  sources = src_libcgx86phases
+  include_dirs = include_directories
+}
+
+source_set("libcgriscv64") {
+  sources = src_libcgriscv64
+  include_dirs = include_directories
+}
+
+source_set("libcgark") {
+  sources = src_libcgark
+  include_dirs = include_directories
+}
+
+source_set("libcgphases") {
+  sources = src_libcgphases
+  include_dirs = include_directories
+}
+
+static_library("libcg") {
+  sources = src_libcg
+  include_dirs = include_directories
+  deps = deps_libcg
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
+
+executable("maplegen") {
+  sources = [
+    "${MAPLEALL_ROOT}/maple_be/mdgen/src/mdgenerator.cpp",
+    "${MAPLEALL_ROOT}/maple_be/mdgen/src/mdlexer.cpp",
+    "${MAPLEALL_ROOT}/maple_be/mdgen/src/mdmain.cpp",
+    "${MAPLEALL_ROOT}/maple_be/mdgen/src/mdparser.cpp",
+    "${MAPLEALL_ROOT}/maple_be/mdgen/src/mdrecord.cpp",
+  ]
+  deps = [
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/mempool:libmempool",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
+  ]
+
+  include_dirs = [
+    "${MAPLEALL_ROOT}/maple_be/mdgen/include",
+    "${MAPLEALL_ROOT}/maple_util/include",
+    "${MAPLEALL_ROOT}/maple_ir/include",
+    "${MAPLEALL_ROOT}/mpl2mpl/include",
+    "${MAPLEALL_ROOT}/mempool/include",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  ]
+}
diff --git a/src/mapleall/maple_be/CMakeLists.txt b/src/mapleall/maple_be/CMakeLists.txt
new file mode 100755
index 0000000000000000000000000000000000000000..15909177b84f6e2cf0ffa95765f9b42cc4c6f16e
--- /dev/null
+++ b/src/mapleall/maple_be/CMakeLists.txt
@@ -0,0 +1,354 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(deps_maple
+  libcglowerer
+  libdriver_option
+  libmaple_driver
+  libmplphase
+  libcommandline
+  libmplutil
+  libmempool
+  libmaplepgo
+  libHWSecureC
+  libcg
+  libmplad
+  libmplbe
+  libmplipa
+  libmplir
+  libmplme
+  libmplmewpo
+  libmpl2mpl
+  libmaple
+)
+
+set(inc_dirs
+    ${MAPLEALL_ROOT}/maple_be/include/cg
+    ${MAPLEALL_ROOT}/maple_be/include/ad
+    ${MAPLE_BUILD_OUTPUT}/common/target
+    ${MAPLEALL_ROOT}/maple_be/include/ad/target
+    ${MAPLEALL_ROOT}/maple_be/include/be
+    ${MAPLEALL_ROOT}/maple_driver/include
+    ${MAPLEALL_ROOT}/maple_pgo/include
+    ${MAPLEALL_ROOT}/maple_util/include
+    ${MAPLEALL_ROOT}/maple_ir/include
+    ${MAPLEALL_ROOT}/maple_me/include
+    ${MAPLEALL_ROOT}/mpl2mpl/include
+    ${MAPLEALL_ROOT}/mempool/include
+    ${MAPLEALL_ROOT}/maple_ipa/include
+    ${MAPLEALL_ROOT}/maple_ipa/include/old
+    ${MAPLEALL_ROOT}/maple_phase/include
+    ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+    ${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat
+)
+
+set(src_maple "")
+set(deps_libmplbe "libcglowerer")
+
+if(${TARGET} STREQUAL "aarch64" OR ${TARGET} STREQUAL "aarch64_ilp32")
+    list(APPEND inc_dirs
+         ${MAPLEALL_ROOT}/maple_be/include/cg/aarch64
+         ${MAPLEALL_ROOT}/maple_be/include/be/aarch64
+    )
+    list(APPEND src_maple
+        src/cg/aarch64/aarch64_abi.cpp
+        src/cg/aarch64/aarch64_call_conv.cpp
+        src/cg/aarch64/mpl_atomic.cpp
+        src/cg/aarch64/aarch64_cfi_generator.cpp
+        src/cg/aarch64/aarch64_cgfunc.cpp
+        src/cg/aarch64/aarch64_dependence.cpp
+        src/cg/aarch64/aarch64_data_dep_base.cpp
+        src/cg/aarch64/aarch64_ebo.cpp
+        src/cg/aarch64/aarch64_emitter.cpp
+        src/cg/aarch64/aarch64_fixshortbranch.cpp
+        src/cg/aarch64/aarch64_global.cpp
+        src/cg/aarch64/aarch64_proepilog.cpp
+        src/cg/aarch64/aarch64_operand.cpp
+        src/cg/aarch64/aarch64_color_ra.cpp
+        src/cg/aarch64/aarch64_reg_info.cpp
+        src/cg/aarch64/aarch64_ssa.cpp
+        src/cg/aarch64/aarch64_prop.cpp
+        src/cg/aarch64/aarch64_dce.cpp
+        src/cg/aarch64/aarch64_phi_elimination.cpp
+        src/cg/aarch64/aarch64_reg_coalesce.cpp
+        src/cg/aarch64/aarch64_ico.cpp
+        src/cg/aarch64/aarch64_insn.cpp
+        src/cg/aarch64/aarch64_isa.cpp
+        src/cg/aarch64/aarch64_memlayout.cpp
+        src/cg/aarch64/aarch64_args.cpp
+        src/cg/aarch64/aarch64_live.cpp
+        src/cg/aarch64/aarch64_yieldpoint.cpp
+        src/cg/aarch64/aarch64_offset_adjust.cpp
+        src/cg/aarch64/aarch64_optimize_common.cpp
+        src/cg/aarch64/aarch64_peep.cpp
+        src/cg/aarch64/aarch64_reaching.cpp
+        src/cg/aarch64/aarch64_schedule.cpp
+        src/cg/aarch64/aarch64_strldr.cpp
+        src/cg/aarch64/aarch64_ra_opt.cpp
+        src/cg/aarch64/aarch64_tailcall.cpp
+        src/cg/aarch64/aarch64_alignment.cpp
+        src/cg/aarch64/aarch64_regsaves.cpp
+        src/cg/aarch64/aarch64_utils.cpp
+        src/cg/aarch64/aarch64_cg.cpp
+        src/cg/aarch64/aarch64_validbit_opt.cpp
+        src/cg/aarch64/aarch64_rce.cpp
+        src/cg/aarch64/aarch64_cfgo.cpp
+        src/cg/aarch64/aarch64_pgo_gen.cpp
+        src/cg/aarch64/aarch64_isolate_fastpath.cpp
+        src/cg/aarch64/aarch64_rematerialize.cpp
+        src/cg/cfi_generator.cpp
+        src/cg/cfgo.cpp
+        src/cg/local_opt.cpp
+        src/cg/ebo.cpp
+        src/cg/ra_opt.cpp
+        src/cg/tailcall.cpp
+        src/cg/cg_pgo_gen.cpp
+        src/cg/cg_pgo_use.cpp
+        src/cg/cg_ssa.cpp
+        src/cg/cg_prop.cpp
+        src/cg/cg_dce.cpp
+        src/cg/cg_phi_elimination.cpp
+        src/cg/reg_coalesce.cpp
+        src/cg/global.cpp
+        src/cg/ico.cpp
+        src/cg/peep.cpp
+        src/cg/pressure.cpp
+        src/cg/reaching.cpp
+        src/cg/schedule.cpp
+        src/cg/strldr.cpp
+        src/cg/cg_dominance.cpp
+        src/cg/cg_pre.cpp
+        src/cg/cg_occur.cpp
+        src/cg/cg_ssu_pre.cpp
+        src/cg/cg_ssa_pre.cpp
+        src/cg/regsaves.cpp
+        src/cg/cg_critical_edge.cpp
+        src/cg/alignment.cpp
+        src/cg/cg_validbit_opt.cpp
+        src/cg/cg_rce.cpp
+        src/cg/rematerialize.cpp
+        src/cg/control_dep_analysis.cpp
+        src/cg/data_dep_base.cpp
+        src/cg/data_dep_analysis.cpp
+        src/cg/global_schedule.cpp
+    )
+endif()
+
+if(${TARGET} STREQUAL "x86_64")
+    list(APPEND inc_dirs
+        ${MAPLEALL_ROOT}/maple_be/include/cg/x86_64
+        ${MAPLEALL_ROOT}/maple_be/include/be/x86_64
+    )
+    list(APPEND src_maple
+        src/cg/x86_64/x64_cg.cpp
+        src/cg/x86_64/x64_MPIsel.cpp
+        src/cg/x86_64/x64_cgfunc.cpp
+        src/cg/x86_64/x64_memlayout.cpp
+        src/cg/x86_64/x64_emitter.cpp
+        src/cg/x86_64/x64_abi.cpp
+        src/cg/x86_64/x64_call_conv.cpp
+        src/cg/x86_64/x64_standardize.cpp
+        src/cg/x86_64/x64_live.cpp
+        src/cg/x86_64/x64_reg_info.cpp
+        src/cg/x86_64/x64_proepilog.cpp
+        src/cg/x86_64/x64_args.cpp
+        src/cg/x86_64/x64_peep.cpp
+        src/cg/x86_64/x64_reaching.cpp
+        src/cg/x86_64/x64_local_opt.cpp
+        src/cg/x86_64/x64_cfgo.cpp
+        src/cg/x86_64/x64_isa.cpp
+        src/cg/x86_64/x64_optimize_common.cpp
+        src/cg/peep.cpp
+        src/cg/alignment.cpp
+        src/cg/reaching.cpp
+        src/cg/local_opt.cpp
+        src/cg/cfgo.cpp
+    )
+endif()
+
+if(${TARGET} STREQUAL "riscv64")
+    list(APPEND inc_dirs
+        ${MAPLEALL_ROOT}/maple_be/include/cg/riscv64
+        ${MAPLEALL_ROOT}/maple_be/include/be/riscv64
+    )
+    list(APPEND src_maple
+        src/cg/riscv64/mpl_atomic.cpp
+        src/cg/riscv64/riscv64_abi.cpp
+        src/cg/riscv64/riscv64_args.cpp
+        src/cg/riscv64/riscv64_cg.cpp
+        src/cg/riscv64/riscv64_cgfunc.cpp
+        src/cg/riscv64/riscv64_color_ra.cpp
+        src/cg/riscv64/riscv64_dependence.cpp
+        src/cg/riscv64/riscv64_ebo.cpp
+        src/cg/riscv64/riscv64_emitter.cpp
+        src/cg/riscv64/riscv64_fixshortbranch.cpp
+        src/cg/riscv64/riscv64_global.cpp
+        src/cg/riscv64/riscv64_ico.cpp
+        src/cg/riscv64/riscv64_immediate.cpp
+        src/cg/riscv64/riscv64_insn.cpp
+        src/cg/riscv64/riscv64_isa.cpp
+        src/cg/riscv64/riscv64_live.cpp
+        src/cg/riscv64/riscv64_lsra.cpp
+        src/cg/riscv64/riscv64_memlayout.cpp
+        src/cg/riscv64/riscv64_offset_adjust.cpp
+        src/cg/riscv64/riscv64_operand.cpp
+        src/cg/riscv64/riscv64_optimize_common.cpp
+        src/cg/riscv64/riscv64_peep.cpp
+        src/cg/riscv64/riscv64_proepilog.cpp
+        src/cg/riscv64/riscv64_reaching.cpp
+        src/cg/riscv64/riscv64_reg_alloc.cpp
+        src/cg/riscv64/riscv64_schedule.cpp
+        src/cg/riscv64/riscv64_strldr.cpp
+        src/cg/riscv64/riscv64_yieldpoint.cpp
+        src/cg/riscv64/riscv64_ra_opt.cpp
+    )
+endif()
+
+if(${TARGET} STREQUAL "ark")
+    list(APPEND inc_dirs
+        ${MAPLEALL_ROOT}/maple_be/include/cg/ark
+        ${MAPLEALL_ROOT}/maple_be/include/be/ark
+    )
+    list(APPEND src_maple
+        src/cg/ark/foo.cpp
+    )
+endif()
+
+set(src_libmplad "src/ad/mad.cpp")
+set(src_libcglowerer
+    src/be/bbt.cpp
+    src/be/trycatchblockslower.cpp
+    src/be/lower.cpp
+)
+set(src_libmplbe
+    src/be/becommon.cpp
+    src/be/switch_lowerer.cpp
+    src/be/rt.cpp
+)
+set(src_libcg
+    src/cg/args.cpp
+    src/cg/cg_irbuilder.cpp
+    src/cg/cfi.cpp
+    src/cg/cgbb.cpp
+    src/cg/operand.cpp
+    src/cg/cgfunc.cpp
+    src/cg/cg_cfg.cpp
+    src/cg/cg_option.cpp
+    src/cg/cg_options.cpp
+    src/cg/dbg.cpp
+    src/cg/optimize_common.cpp
+    src/cg/eh_func.cpp
+    src/cg/emit.cpp
+    src/cg/live.cpp
+    src/cg/loop.cpp
+    src/cg/isel.cpp
+    src/cg/standardize.cpp
+    src/cg/memlayout.cpp
+    src/cg/yieldpoint.cpp
+    src/cg/label_creation.cpp
+    src/cg/offset_adjust.cpp
+    src/cg/reg_alloc.cpp
+    src/cg/reg_alloc_basic.cpp
+    src/cg/reg_alloc_lsra.cpp
+    src/cg/proepilog.cpp
+    src/cg/isolate_fastpath.cpp
+    src/cg/cg.cpp
+    src/cg/isa.cpp
+    src/cg/insn.cpp
+    src/cg/cg_phasemanager.cpp
+)
+
+string(REPLACE "-DRC_NO_MMAP" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+string(REPLACE "-DMIR_JAVA=1" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+# libmplad
+add_library(libmplad STATIC ${src_libmplad})
+target_include_directories(libmplad PRIVATE ${inc_dirs})
+set_target_properties(libmplad PROPERTIES
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+    COMPILE_FLAGS "${CMAKE_CXX_FLAGS} -DRC_NO_MMAP"
+)
+
+# maplegen
+set(src_maplegen
+    ${MAPLEALL_ROOT}/maple_be/mdgen/src/mdgenerator.cpp
+    ${MAPLEALL_ROOT}/maple_be/mdgen/src/mdlexer.cpp
+    ${MAPLEALL_ROOT}/maple_be/mdgen/src/mdmain.cpp
+    ${MAPLEALL_ROOT}/maple_be/mdgen/src/mdparser.cpp
+    ${MAPLEALL_ROOT}/maple_be/mdgen/src/mdrecord.cpp
+)
+set(inc_maplegen
+    ${MAPLEALL_ROOT}/maple_be/mdgen/include
+    ${MAPLEALL_ROOT}/maple_util/include
+    ${MAPLEALL_ROOT}/maple_ir/include
+    ${MAPLEALL_ROOT}/mpl2mpl/include
+    ${MAPLEALL_ROOT}/mempool/include
+    ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+)
+set(deps_maplegen
+    libmplutil
+    libmempool
+    libHWSecureC
+)
+add_executable(maplegen "${src_maplegen}")
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -ldl")
+set_target_properties(maplegen PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${inc_maplegen}"
+    LINK_LIBRARIES "${deps_maplegen}"
+    RUNTIME_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/bin"
+)
+
+#libcg
+add_library(libcg STATIC ${src_libcg})
+set_target_properties(libcg PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${inc_dirs}"
+    LINK_LIBRARIES ""
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
+
+#libmplbe
+add_library(libmplbe STATIC ${src_libmplbe})
+set_target_properties(libmplbe PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${inc_dirs}"
+    LINK_LIBRARIES "${deps_libmplbe}"
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
+
+# libcglowerer
+add_library(libcglowerer STATIC ${src_libcglowerer})
+set_target_properties(libcglowerer PROPERTIES
+    INCLUDE_DIRECTORIES "${inc_dirs}"
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
+
+
+#maple
+add_executable(maple "${src_maple}")
+set_target_properties(maple PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${inc_dirs}"
+  LINK_LIBRARIES "${deps_maple}"
+  RUNTIME_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/bin"
+)
+
+message("deps_maplegen: ${deps_maplegen}")
+
+
+
+
+
diff --git a/src/mapleall/maple_be/include/ad/cortex_a55/sched_cortex_a55.td b/src/mapleall/maple_be/include/ad/cortex_a55/sched_cortex_a55.td
new file mode 100644
index 0000000000000000000000000000000000000000..bb1127d737296c7a1e95732956f677fc8495b33f
--- /dev/null
+++ b/src/mapleall/maple_be/include/ad/cortex_a55/sched_cortex_a55.td
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+DefType UnitType = Primary, And, Or;
+DefType BypassType = Accumulator, Store, AluShift;
+
+// Architecture name
+Class ArchitectureName <string>;
+// Parallelism number
+Class Parallelism  <int>;
+
+Def ArchitectureName  {cortex_a55};
+Def Parallelism  {2};
+
+// class parameters can be set as default.
+// default parameters can only be placed at the end
+// Class Unit :Name <UnitType, componentUnits>
+Class Unit :string <UnitType, Unit[]>;
+// Class Reservation :Name <Latency, dependUnits>
+Class Reservation : string <int, Unit[]>;
+// AnonClass Bypass : BypassNum, fromTypeReservation, toTypeReservation, BypassType
+Class Bypass <int, Reservation[], Reservation[], BypassType>;
+
+Def Unit : kUnitIdSlot0 {Primary};
+Def Unit : kUnitIdSlot1 {Primary};
+Def Unit : kUnitIdAgen {Primary};
+Def Unit : kUnitIdHazard {Primary};
+Def Unit : kUnitIdCrypto {Primary};
+Def Unit : kUnitIdMul {Primary};
+Def Unit : kUnitIdDiv {Primary};
+Def Unit : kUnitIdBranch {Primary};
+Def Unit : kUnitIdStAgu {Primary};
+Def Unit : kUnitIdLdAgu {Primary};
+Def Unit : kUnitIdFpAluLo {Primary};
+Def Unit : kUnitIdFpAluHi {Primary};
+Def Unit : kUnitIdFpMulLo {Primary};
+Def Unit : kUnitIdFpMulHi {Primary};
+Def Unit : kUnitIdFpDivLo {Primary};
+Def Unit : kUnitIdFpDivHi {Primary};
+
+Def Unit : kUnitIdSlotS {Or, [kUnitIdSlot0, kUnitIdSlot1]};
+Def Unit : kUnitIdFpAluS {Or, [kUnitIdFpAluLo, kUnitIdFpAluHi]};
+Def Unit : kUnitIdFpMulS {Or, [kUnitIdFpMulLo, kUnitIdFpMulHi]};
+Def Unit : kUnitIdFpDivS {Or, [kUnitIdFpDivLo, kUnitIdFpDivHi]};
+
+Def Unit : kUnitIdSlotD {And, [kUnitIdSlot0, kUnitIdSlot1]};
+Def Unit : kUnitIdFpAluD {And, [kUnitIdFpAluLo, kUnitIdFpAluHi]};
+Def Unit : kUnitIdFpMulD {And, [kUnitIdFpMulLo, kUnitIdFpMulHi]};
+Def Unit : kUnitIdFpDivD {And, [kUnitIdFpDivLo, kUnitIdFpDivHi]};
+Def Unit : kUnitIdSlotSHazard {And, [kUnitIdSlotS, kUnitIdHazard]};
+Def Unit : kUnitIdSlotSMul {And, [kUnitIdSlotS, kUnitIdMul]};
+Def Unit : kUnitIdSlotSBranch {And, [kUnitIdSlotS, kUnitIdBranch]};
+Def Unit : kUnitIdSlotSAgen {And, [kUnitIdSlotS, kUnitIdAgen]};
+Def Unit : kUnitIdSlotDAgen {And, [kUnitIdSlot0, kUnitIdSlot1, kUnitIdAgen]};
+Def Unit : kUnitIdSlot0LdAgu {And, [kUnitIdSlot0, kUnitIdLdAgu]};
+Def Unit : kUnitIdSlot0StAgu {And, [kUnitIdSlot0, kUnitIdStAgu]};
+Def Unit : nothing {};
+
+Def Reservation : kLtUndef {0};
+Def Reservation : kLtShift {2, [kUnitIdSlotS]};
+Def Reservation : kLtShiftReg {2, [ kUnitIdSlotS, kUnitIdHazard]};
+Def Reservation : kLtAlu {3, [kUnitIdSlotS]};
+Def Reservation : kLtAluShift {3, [kUnitIdSlotS]};
+Def Reservation : kLtAluShiftReg {3, [kUnitIdSlotS, kUnitIdHazard]};
+Def Reservation : kLtAluExtr {3, [kUnitIdSlot1]};
+Def Reservation : kLtMul {4, [kUnitIdSlotS, kUnitIdMul]};
+Def Reservation : kLtDiv {4, [kUnitIdSlot0, kUnitIdDiv, kUnitIdDiv]};
+Def Reservation : kLtLoad1 {4, [kUnitIdSlotSAgen, kUnitIdLdAgu]};
+Def Reservation : kLtStore1 {2, [kUnitIdSlotSAgen, kUnitIdStAgu]};
+Def Reservation : kLtLoad2 {4, [kUnitIdSlotDAgen, kUnitIdSlot0LdAgu, kUnitIdLdAgu]};
+Def Reservation : kLtStore2 {2, [ kUnitIdSlotSAgen, kUnitIdStAgu]};
+Def Reservation : kLtLoad3plus {6, [kUnitIdSlotDAgen, kUnitIdSlot0LdAgu, kUnitIdLdAgu]};
+Def Reservation : kLtStore3plus {2, [kUnitIdSlotDAgen, kUnitIdSlot0StAgu, kUnitIdStAgu]};
+Def Reservation : kLtBranch {0, [kUnitIdSlotSBranch]};
+Def Reservation : kLtFpalu {4, [kUnitIdSlotS, kUnitIdFpAluS]};
+Def Reservation : kLtFconst {2, [kUnitIdSlotS, kUnitIdFpAluS]};
+Def Reservation : kLtFpmul {4, [kUnitIdSlotS, kUnitIdFpMulS]};
+Def Reservation : kLtFpmac {8, [kUnitIdSlotS, kUnitIdFpMulS, nothing, nothing, nothing, kUnitIdFpAluS]};
+Def Reservation : kLtR2f {2, [kUnitIdSlotS, kUnitIdFpAluS]};
+Def Reservation : kLtF2r {4, [kUnitIdSlotS, kUnitIdFpAluS]};
+Def Reservation : kLtR2fCvt {4, [kUnitIdSlotS, kUnitIdFpAluS]};
+Def Reservation : kLtF2rCvt {5, [kUnitIdSlotS, kUnitIdFpAluS]};
+Def Reservation : kLtFFlags {5, [kUnitIdSlotS]};
+Def Reservation : kLtFLoad64 {3, [kUnitIdSlotSAgen, kUnitIdLdAgu]};
+Def Reservation : kLtFLoadMany {4, [kUnitIdSlotDAgen, kUnitIdSlot0LdAgu, kUnitIdLdAgu]};
+Def Reservation : kLtFStore64 {0, [kUnitIdSlotSAgen, kUnitIdStAgu]};
+Def Reservation : kLtFStoreMany {0, [kUnitIdSlotSAgen, kUnitIdSlot0StAgu, kUnitIdStAgu]};
+Def Reservation : kLtAdvsimdAlu {4, [kUnitIdSlotS, kUnitIdFpAluS]};
+Def Reservation : kLtAdvsimdAluQ {4, [kUnitIdSlot0, kUnitIdFpAluD]};
+Def Reservation : kLtAdvsimdMul {4, [kUnitIdSlotS, kUnitIdFpMulS]};
+Def Reservation : kLtAdvsimdMulQ {4, [kUnitIdSlot0, kUnitIdFpMulD]};
+Def Reservation : kLtAdvsimdDivS {14, [kUnitIdSlot0, kUnitIdFpMulS, kUnitIdFpDivS]};
+Def Reservation : kLtAdvsimdDivD {29, [kUnitIdSlot0, kUnitIdFpMulS, kUnitIdFpDivS]};
+Def Reservation : kLtAdvsimdDivSQ {14, [kUnitIdSlotD, kUnitIdFpMulD, kUnitIdFpDivD]};
+Def Reservation : kLtAdvsimdDivdQ {29, [kUnitIdSlotD, kUnitIdFpMulD, kUnitIdFpDivD]};
+Def Reservation : kLtCryptoAese {3, [kUnitIdSlot0]};
+Def Reservation : kLtCryptoAesmc {3, [kUnitIdSlotS]};
+Def Reservation : kLtClinit {14, [kUnitIdSlotS, nothing, kUnitIdSlotDAgen, kUnitIdSlot0LdAgu,
+                                     kUnitIdLdAgu, nothing, kUnitIdSlotDAgen, kUnitIdSlot0LdAgu,
+                                     kUnitIdLdAgu, nothing, kUnitIdSlotDAgen, kUnitIdSlot0LdAgu,
+                                     kUnitIdLdAgu]};
+Def Reservation : kLtAdrpLdr {6, [kUnitIdSlotS, nothing, kUnitIdSlotDAgen, kUnitIdSlot0LdAgu,
+                                     kUnitIdLdAgu]};
+Def Reservation : kLtClinitTail {8, [kUnitIdSlotDAgen, kUnitIdSlot0LdAgu, kUnitIdLdAgu, nothing,
+                                        kUnitIdSlotDAgen, kUnitIdSlot0LdAgu, kUnitIdLdAgu]};
+
+Def Bypass  {0, [kLtShift, kLtShiftReg], [kLtAlu]};
+Def Bypass  {1, [kLtShift], [kLtShift, kLtShiftReg, kLtAluShift, kLtAluShiftReg]};
+Def Bypass  {1, [kLtShiftReg], [kLtShift, kLtShiftReg, kLtAluShift, kLtAluShiftReg]};
+Def Bypass  {1, [kLtAlu, kLtAluShift, kLtAluShiftReg], [kLtAlu]};
+Def Bypass  {1, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr], [kLtAluShift], AluShift};
+Def Bypass  {1, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr], [kLtAluShiftReg], AluShift};
+Def Bypass  {2, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr], [kLtAluShift]};
+Def Bypass  {2, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr], [kLtAluShiftReg]};
+Def Bypass  {2, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr], [kLtAluExtr]};
+Def Bypass  {2, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr], [kLtShift]};
+Def Bypass  {2, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr], [kLtShiftReg]};
+Def Bypass  {2, [kLtMul], [kLtMul], Accumulator};
+Def Bypass  {2, [kLtMul], [kLtAlu]};
+Def Bypass  {3, [kLtMul], [kLtAluShift, kLtAluShiftReg, kLtAluExtr, kLtShift, kLtShiftReg]};
+Def Bypass  {2, [kLtLoad1], [kLtAlu]};
+Def Bypass  {3, [kLtLoad1], [kLtAluShift, kLtAluShiftReg, kLtAluExtr, kLtShift, kLtShiftReg]};
+Def Bypass  {3, [kLtLoad2], [kLtAlu]};
+Def Bypass  {0, [kLtAlu], [kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {0, [kLtAluShift], [kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {0, [kLtAluShiftReg], [kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {0, [kLtAluExtr], [ kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {0, [kLtShift], [kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {0, [kLtShiftReg], [kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {1, [kLtMul], [kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {1, [kLtLoad1], [kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {1, [kLtLoad2], [kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {1, [kLtLoad3plus], [kLtStore1, kLtStore2, kLtStore3plus], Store};
+Def Bypass  {0, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr, kLtShift, kLtShiftReg], [kLtR2f]};
+Def Bypass  {1, [kLtMul, kLtLoad1, kLtLoad2], [kLtR2f]};
+Def Bypass  {2, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr], [kLtR2fCvt]};
+Def Bypass  {3, [kLtMul, kLtLoad1, kLtLoad2], [kLtR2fCvt]};
+Def Bypass  {0, [kLtAlu, kLtAluShift, kLtAluShiftReg, kLtAluExtr, kLtShift, kLtShiftReg], [kLtBranch]};
+Def Bypass  {1, [kLtFpalu, kLtFpmul, kLtR2f, kLtR2fCvt, kLtFconst], [kLtFpmac], Accumulator};
+Def Bypass  {1, [kLtFLoad64, kLtFLoadMany], [kLtFpmac]};
+Def Bypass  {4, [kLtFpmac], [kLtFpmac], Accumulator};
+Def Bypass  {0, [kLtCryptoAese], [kLtCryptoAesmc]};
+Def Bypass  {1, [kLtShiftReg], [kLtClinit]};
+Def Bypass  {2, [kLtAlu, kLtAluShift, kLtAluExtr], [kLtClinit]};
+Def Bypass  {3, [kLtMul, kLtLoad1], [kLtClinit]};
+Def Bypass  {13, [kLtAlu], [kLtClinit]};
+Def Bypass  {11, [kLtClinit], [kLtStore1, kLtStore3plus], Store};
+Def Bypass  {11, [kLtClinit], [kLtR2f]};
+Def Bypass  {13, [kLtClinit], [kLtR2fCvt]};
+Def Bypass  {1, [kLtShiftReg], [kLtAdrpLdr]};
+Def Bypass  {2, [kLtAlu, kLtAluShift, kLtAluExtr], [kLtAdrpLdr]};
+Def Bypass  {3, [kLtMul, kLtLoad1], [kLtAdrpLdr]};
+Def Bypass  {5, [kLtAdrpLdr], [kLtAlu]};
+Def Bypass  {3, [kLtAdrpLdr], [kLtStore1, kLtStore3plus], Store};
+Def Bypass  {3, [kLtAdrpLdr], [kLtR2f]};
+Def Bypass  {5, [kLtAdrpLdr], [kLtR2fCvt]};
+Def Bypass  {7, [kLtClinitTail], [kLtAlu]};
+Def Bypass  {5, [kLtClinitTail], [kLtStore1, kLtStore3plus], Store};
+Def Bypass  {5, [kLtClinitTail], [kLtR2f]};
+Def Bypass  {7, [kLtClinitTail], [kLtR2fCvt]};
diff --git a/src/mapleall/maple_be/include/ad/mad.h b/src/mapleall/maple_be/include/ad/mad.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e28dc6ef0dc28fa7d8948b20773e32c395ee6f1
--- /dev/null
+++ b/src/mapleall/maple_be/include/ad/mad.h
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_AD_MAD_H
+#define MAPLEBE_INCLUDE_AD_MAD_H
+#include <vector>
+#include "types_def.h"
+#include "mpl_logging.h"
+#include "insn.h"
+
+namespace maplebe {
+enum UnitId : maple::uint32 {
+#include "mplad_unit_id.def"
+  kUnitIdLast
+};
+
+enum UnitType : maple::uint8 {
+  kUnitTypePrimart,
+  kUnitTypeOr,
+  kUnitTypeAnd,
+  KUnitTypeNone
+};
+
+enum RealUnitKind : maple::uint32 {
+  kUnitKindUndef,
+#include "mplad_unit_kind.def"
+  kUnitKindLast = 13
+};
+
+enum SlotType : maple::uint8 {
+  kSlotNone,
+  kSlot0,
+  kSlot1,
+  kSlotAny,
+  kSlots,
+};
+
+/* machine model */
+enum LatencyType : maple::uint32 {
+  /* LT: latency */
+#include "mplad_latency_type.def"
+  kLtLast,
+};
+
+class Unit {
+ public:
+  explicit Unit(enum UnitId theUnitId);
+  Unit(enum UnitType theUnitType, enum UnitId theUnitId, int numOfUnits, ...);
+  ~Unit() = default;
+
+  enum UnitType GetUnitType() const {
+    return unitType;
+  }
+
+  enum UnitId GetUnitId() const {
+    return unitId;
+  };
+
+  const std::vector<Unit*> &GetCompositeUnits() const;
+
+  std::string GetName() const;
+  bool IsFree(uint32 cycle) const;
+  void Occupy(const Insn &insn, uint32 cycle);
+  void Release();
+  void AdvanceCycle();
+  void Dump(int indent = 0) const;
+  maple::uint32 GetOccupancyTable() const;
+
+  void SetOccupancyTable(maple::uint32 table) {
+    occupancyTable = table;
+  }
+
+ private:
+  void PrintIndent(int indent) const;
+
+  enum UnitId unitId;
+  enum UnitType unitType;
+  maple::uint32 occupancyTable;
+  std::vector<Unit*> compositeUnits;
+};
+
+class Reservation {
+ public:
+  Reservation(LatencyType t, int l, int n, ...);
+  ~Reservation() = default;
+
+  bool IsEqual(maple::uint32 typ) const {
+    return typ == type;
+  }
+
+  int GetLatency() const {
+    return latency;
+  }
+
+  uint32 GetUnitNum() const {
+    return unitNum;
+  }
+
+  enum SlotType GetSlot() const {
+    return slot;
+  }
+
+  const std::string &GetSlotName() const;
+
+  Unit * const *GetUnit() const {
+    return units;
+  }
+
+ private:
+  static const int kMaxUnit = 13;
+  LatencyType type;
+  int latency;
+  uint32 unitNum;
+  Unit *units[kMaxUnit];
+  enum SlotType slot = kSlotNone;
+
+  SlotType GetSlotType(UnitId unitID) const;
+};
+
+class Bypass {
+ public:
+  Bypass(LatencyType d, LatencyType u, int l) : def(d), use(u), latency(l) {}
+  virtual ~Bypass() = default;
+
+  virtual bool CanBypass(const Insn &defInsn, const Insn &useInsn) const;
+
+  int GetLatency() const {
+    return latency;
+  }
+
+  LatencyType GetDefType() const {
+    return def;
+  }
+
+  LatencyType GetUseType() const {
+    return use;
+  }
+
+ private:
+  LatencyType def;
+  LatencyType use;
+  int latency;
+};
+
+class MAD {
+ public:
+  MAD() {
+    InitUnits();
+    InitParallelism();
+    InitReservation();
+    InitBypass();
+  }
+
+  ~MAD();
+
+  using BypassVector = std::vector<Bypass*>;
+
+  void InitUnits() const;
+  void InitParallelism() const;
+  void InitReservation() const;
+  void InitBypass() const;
+  bool IsSlot0Free() const;
+  bool IsFullIssued() const;
+  int GetLatency(const Insn &def, const Insn &use) const;
+  int DefaultLatency(const Insn &insn) const;
+  Reservation *FindReservation(const Insn &insn) const;
+  void AdvanceCycle() const;
+  void ReleaseAllUnits() const;
+  void SaveStates(std::vector<maple::uint32> &occupyTable, int size) const;
+  void RestoreStates(std::vector<maple::uint32> &occupyTable, int size) const;
+
+  int GetMaxParallelism() const {
+    return parallelism;
+  }
+
+  const Unit *GetUnitByUnitId(enum UnitId uId) const {
+    CHECK_FATAL(!allUnits.empty(), "CHECK_CONTAINER_EMPTY");
+    return allUnits[uId];
+  }
+
+  static void AddUnit(Unit &u) {
+    allUnits.emplace_back(&u);
+  }
+
+  static maple::uint32 GetAllUnitsSize() {
+    return allUnits.size();
+  }
+
+  static void AddReservation(Reservation &rev) {
+    allReservations.emplace_back(&rev);
+  }
+
+  static void AddBypass(Bypass &bp) {
+    ASSERT(bp.GetDefType() < kLtLast, "out of range");
+    ASSERT(bp.GetUseType() < kLtLast, "out of range");
+    (bypassArrays[bp.GetDefType()][bp.GetUseType()]).push_back(&bp);
+  }
+
+ protected:
+  static void SetMaxParallelism(int num) {
+    parallelism = num;
+  }
+
+  int BypassLatency(const Insn &def, const Insn &use) const;
+
+ private:
+  static int parallelism;
+  static std::vector<Unit*> allUnits;
+  static std::vector<Reservation*> allReservations;
+  static std::array<std::array<BypassVector, kLtLast>, kLtLast> bypassArrays;
+};
+
+class AluShiftBypass : public Bypass {
+ public:
+  AluShiftBypass(LatencyType d, LatencyType u, int l) : Bypass(d, u, l) {}
+  ~AluShiftBypass() override = default;
+
+  bool CanBypass(const Insn &defInsn, const Insn &useInsn) const override;
+};
+
+class AccumulatorBypass : public Bypass {
+ public:
+  AccumulatorBypass(LatencyType d, LatencyType u, int l) : Bypass(d, u, l) {}
+  ~AccumulatorBypass() override = default;
+
+  bool CanBypass(const Insn &defInsn, const Insn &useInsn) const override;
+};
+
+class StoreBypass : public Bypass {
+ public:
+  StoreBypass(LatencyType d, LatencyType u, int l) : Bypass(d, u, l) {}
+  ~StoreBypass() override = default;
+
+  bool CanBypass(const Insn &defInsn, const Insn &useInsn) const override;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_AD_MAD_H */
diff --git a/src/mapleall/maple_be/include/ad/target/mplad_unit_kind.def b/src/mapleall/maple_be/include/ad/target/mplad_unit_kind.def
new file mode 100644
index 0000000000000000000000000000000000000000..0c56044925a600296d4fbf96bbd2944e8d1d7780
--- /dev/null
+++ b/src/mapleall/maple_be/include/ad/target/mplad_unit_kind.def
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/* cortex_a55 function unit ID definition: */
+kUnitKindSlot0 = 1,
+kUnitKindAgen = 2,
+kUnitKindHazard = 4,
+kUnitKindCrypto = 8,
+kUnitKindMul = 16,
+kUnitKindDiv = 32,
+kUnitKindBranch = 64,
+kUnitKindStAgu = 128,
+kUnitKindLdAgu = 256,
+kUnitKindFpAlu = 512,
+kUnitKindFpMul = 1024,
+kUnitKindFpDiv = 2048,
+
diff --git a/src/mapleall/maple_be/include/be/array_base_name.def b/src/mapleall/maple_be/include/be/array_base_name.def
new file mode 100644
index 0000000000000000000000000000000000000000..42c8905f3c212fffdd8d3b8bc0b9582b9ceaffe6
--- /dev/null
+++ b/src/mapleall/maple_be/include/be/array_base_name.def
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+"ALjava_2Flang_2FObject_3B",
+"ALjava_2Flang_2FClass_3B",
+"ALjava_2Flang_2FString_3B"
diff --git a/src/mapleall/maple_be/include/be/array_klass_name.def b/src/mapleall/maple_be/include/be/array_klass_name.def
new file mode 100644
index 0000000000000000000000000000000000000000..3812b8c1224c82c5ea1c73995bfc9bbdeb916063
--- /dev/null
+++ b/src/mapleall/maple_be/include/be/array_klass_name.def
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+"ALjava_2Flang_2FObject_3B",
+"ALjava_2Flang_2FClass_3B",
+"ALjava_2Flang_2FString_3B",
+"ALjava_2Futil_2FFormatter_24Flags_3B",
+"ALjava_2Futil_2FHashMap_24Node_3B",
+"ALjava_2Futil_2FFormatter_24FormatString_3B",
+"ALjava_2Flang_2FCharSequence_3B",
+"ALjava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B",
+"ALjava_2Futil_2FHashtable_24HashtableEntry_3B",
+"ALlibcore_2Freflect_2FAnnotationMember_3B",
+"ALsun_2Fsecurity_2Futil_2FDerValue_3B",
+"ALsun_2Fsecurity_2Fx509_2FAVA_3B"
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/be/bbt.h b/src/mapleall/maple_be/include/be/bbt.h
new file mode 100644
index 0000000000000000000000000000000000000000..cdae745afdd06eb56d8a279ebf6aa9bb416b1a56
--- /dev/null
+++ b/src/mapleall/maple_be/include/be/bbt.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_BE_BBT_H
+#define MAPLEBE_INCLUDE_BE_BBT_H
+/* MapleIR headers. */
+#include "mir_nodes.h"
+#include "mir_lower.h"
+namespace maplebe {
+using namespace maple;
+
+class BBT {
+  /*
+   * if stmt is a switch/rangegoto, succs gets defined, and condJumpBranch == fallthruBranch == nullptr.
+   * otherwise, succs.size() ==0 &&
+   *  1. for cond br stmt, both condJumpBranch and fallthruBranch are defined.
+   *  2. if bb ends with 'throw', both fields get nullptr.
+   *  3. for the others, condJumpBranch == nullptr && only fallthruBranch is defined
+   */
+ public:
+  enum BBTType : uint8 {
+    kBBPlain,
+    kBBTry,
+    kBBEndTry,
+    kBBCatch
+  };
+
+  BBT(StmtNode *s, StmtNode *e, MemPool *memPool)
+      : alloc(memPool),
+        type(kBBPlain),
+        succs(alloc.Adapter()),
+        labelIdx(MIRLabelTable::GetDummyLabel()),
+        firstStmt(s != nullptr ? s : e),
+        lastStmt(e) {}
+
+  ~BBT() = default;
+
+  void Extend(const StmtNode *sNode, StmtNode *eNode) {
+    CHECK_FATAL(lastStmt != nullptr, "nullptr check");
+    CHECK_FATAL(sNode != nullptr ? lastStmt->GetNext() == sNode : lastStmt->GetNext() == eNode, "Extend fail");
+    lastStmt = eNode;
+  }
+
+  void SetLabelIdx(LabelIdx li) {
+    labelIdx = li;
+  }
+
+  bool IsLabeled() const {
+    return labelIdx != MIRLabelTable::GetDummyLabel();
+  }
+
+  LabelIdx GetLabelIdx() const {
+    return labelIdx;
+  }
+
+  void SetType(BBTType t, StmtNode &k) {
+    type = t;
+    keyStmt = &k;
+  }
+
+  bool IsTry() const {
+    return type == kBBTry;
+  }
+
+  bool IsEndTry() const {
+    return type == kBBEndTry;
+  }
+
+  bool IsCatch() const {
+    return type == kBBCatch;
+  }
+
+  void AddSuccs(BBT *bb) {
+    succs.emplace_back(bb);
+  }
+
+  void SetCondJumpBranch(BBT *bb) {
+    condJumpBranch = bb;
+  }
+
+  BBT *GetCondJumpBranch() {
+    return condJumpBranch;
+  }
+  void SetFallthruBranch(BBT *bb) {
+    fallthruBranch = bb;
+  }
+
+  BBT *GetFallthruBranch() {
+    return fallthruBranch;
+  }
+
+  StmtNode *GetFirstStmt() {
+    return firstStmt;
+  }
+
+  void SetFirstStmt(StmtNode &stmt) {
+    firstStmt = &stmt;
+  }
+
+  StmtNode *GetLastStmt() {
+    return lastStmt;
+  }
+
+  void SetLastStmt(StmtNode &stmt) {
+    lastStmt = &stmt;
+  }
+
+  StmtNode *GetKeyStmt() {
+    return keyStmt;
+  }
+
+#if DEBUG
+  void Dump(const MIRModule &mod) const;
+  static void ValidateStmtList(StmtNode *head, StmtNode *detached = nullptr);
+#endif
+ private:
+  MapleAllocator alloc;
+  BBTType type;
+  BBT *condJumpBranch = nullptr;
+  BBT *fallthruBranch = nullptr;
+  MapleVector<BBT*> succs;
+  LabelIdx labelIdx;
+  StmtNode *firstStmt;
+  StmtNode *lastStmt;
+  StmtNode *keyStmt = nullptr;
+};
+} /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_BE_BBT_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/be/becommon.h b/src/mapleall/maple_be/include/be/becommon.h
new file mode 100644
index 0000000000000000000000000000000000000000..17c8b24494949898ed097a13d063262123622ea5
--- /dev/null
+++ b/src/mapleall/maple_be/include/be/becommon.h
@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_BE_BECOMMON_H
+#define MAPLEBE_INCLUDE_BE_BECOMMON_H
+/* C++ headers. */
+#include <cstddef>
+#include <utility>
+/* Basic Maple-independent utility functions */
+#include "common_utils.h"
+/* MapleIR headers. */
+#include "mir_nodes.h"   /* maple_ir/include, for BaseNode */
+#include "mir_type.h"    /* maple_ir/include, for MIRType */
+#include "mir_module.h"  /* maple_ir/include, for mirModule */
+
+namespace maplebe {
+using namespace maple;
+
+enum BitsPerByte : uint8 {
+  kBitsPerByte = 8,
+  kLog2BitsPerByte = 3
+};
+
+class JClassFieldInfo {  /* common java class field info */
+ public:
+  /* constructors */
+  JClassFieldInfo() : isRef(false), isUnowned(false), isWeak(false), offset(0) {}
+
+  JClassFieldInfo(bool isRef, bool isUnowned, bool isWeak, uint32 offset)
+      : isRef(isRef), isUnowned(isUnowned), isWeak(isWeak), offset(offset) {}
+
+  ~JClassFieldInfo() = default;
+
+  bool IsRef() const {
+    return isRef;
+  }
+
+  bool IsUnowned() const {
+    return isUnowned;
+  }
+
+  bool IsWeak() const {
+    return isWeak;
+  }
+
+  uint32 GetOffset() const {
+    return offset;
+  }
+
+ private:
+  bool isRef;            /* used to generate object-map */
+  bool isUnowned;        /* used to mark unowned fields for RC */
+  bool isWeak;           /* used to mark weak fields for RC */
+  uint32 offset;         /* offset from the start of the java object */
+};
+
+using JClassLayout = MapleVector<JClassFieldInfo>;  /* java class layout info */
+
+class BECommon {
+ public:
+  explicit BECommon(MIRModule &mod);
+
+  ~BECommon() = default;
+
+  void LowerTypeAttribute(MIRType &ty);
+
+  void LowerJavaTypeAttribute(MIRType &ty);
+
+  void LowerJavaVolatileInClassType(MIRClassType &ty);
+
+  void LowerJavaVolatileForSymbol(MIRSymbol &sym) const;
+
+  void ComputeTypeSizesAligns(MIRType &ty, uint8 align = 0);
+
+  void GenFieldOffsetMap(const std::string &className);
+
+  void GenFieldOffsetMap(MIRClassType &classType, FILE &outFile);
+
+  void GenObjSize(const MIRClassType &classType, FILE &outFile) const;
+
+  std::pair<int32, int32> GetFieldOffset(MIRStructType &structType, FieldID fieldID);
+
+  bool IsRefField(MIRStructType &structType, FieldID fieldID) const;
+
+  /* some class may has incomplete type definition. provide an interface to check them. */
+  bool HasJClassLayout(MIRClassType &klass) const {
+    return (jClassLayoutTable.find(&klass) != jClassLayoutTable.end());
+  }
+
+  const JClassLayout &GetJClassLayout(MIRClassType &klass) const {
+    return *(jClassLayoutTable.at(&klass));
+  }
+
+  void AddNewTypeAfterBecommon(uint32 oldTypeTableSize, uint32 newTypeTableSize);
+
+  void AddElementToJClassLayout(MIRClassType &klass, JClassFieldInfo info);
+
+  bool HasFuncReturnType(MIRFunction &func) const {
+    return (funcReturnType.find(&func) != funcReturnType.end());
+  }
+
+  const TyIdx GetFuncReturnType(MIRFunction &func) const {
+    return (funcReturnType.at(&func));
+  }
+
+  void AddElementToFuncReturnType(MIRFunction &func, const TyIdx tyIdx);
+
+  MIRType *BeGetOrCreatePointerType(const MIRType &pointedType);
+
+  MIRType *BeGetOrCreateFunctionType(TyIdx tyIdx, const std::vector<TyIdx> &vecTy,
+                                     const std::vector<TypeAttrs> &vecAt);
+
+  BaseNode *GetAddressOfNode(const BaseNode &node);
+
+  bool CallIsOfAttr(FuncAttrKind attr, const StmtNode *narynode) const;
+
+  PrimType GetAddressPrimType() const {
+    return GetLoweredPtrType();
+  }
+
+  /* update typeSizeTable and typeAlignTable when new type is created */
+  void UpdateTypeTable(MIRType &ty) {
+    if (!TyIsInSizeAlignTable(ty)) {
+      AddAndComputeSizeAlign(ty);
+    }
+  }
+
+  /* Global type table might be updated during lowering for C/C++. */
+  void FinalizeTypeTable(const MIRType &ty);
+
+  uint32 GetFieldIdxIncrement(const MIRType &ty) const {
+    if (ty.GetKind() == kTypeClass) {
+    /* number of fields + 2 */
+      return static_cast<const MIRClassType&>(ty).GetFieldsSize() + 2;
+    } else if (ty.GetKind() == kTypeStruct) {
+    /* number of fields + 1 */
+      return static_cast<const MIRStructType&>(ty).GetFieldsSize() + 1;
+    }
+    return 1;
+  }
+
+  MIRModule &GetMIRModule() const {
+    return mirModule;
+  }
+
+  uint64 GetTypeSize(uint32 idx) const {
+    return typeSizeTable.at(idx);
+  }
+  uint32 GetSizeOfTypeSizeTable() const {
+    return typeSizeTable.size();
+  }
+  bool IsEmptyOfTypeSizeTable() const {
+    return typeSizeTable.empty();
+  }
+  void SetTypeSize(uint32 idx, uint64 value) {
+    typeSizeTable.at(idx) = value;
+  }
+  void AddTypeSize(uint64 value) {
+    typeSizeTable.emplace_back(value);
+  }
+
+  void AddTypeSizeAndAlign(const TyIdx tyIdx, uint64 value) {
+    if (typeSizeTable.size() == tyIdx) {
+      typeSizeTable.emplace_back(value);
+      typeAlignTable.emplace_back(value);
+    } else {
+      CHECK_FATAL(typeSizeTable.size() > tyIdx, "there are some types haven't set type size and align, %d");
+    }
+  }
+
+  uint8 GetTypeAlign(uint32 idx) const {
+    return typeAlignTable.at(idx);
+  }
+  size_t GetSizeOfTypeAlignTable() const {
+    return typeAlignTable.size();
+  }
+  bool IsEmptyOfTypeAlignTable() const {
+    return typeAlignTable.empty();
+  }
+  void SetTypeAlign(uint32 idx, uint8 value) {
+    typeAlignTable.at(idx) = value;
+  }
+  void AddTypeAlign(uint8 value) {
+    typeAlignTable.emplace_back(value);
+  }
+
+  bool GetHasFlexibleArray(uint32 idx) const {
+    return typeHasFlexibleArray.at(idx);
+  }
+  void SetHasFlexibleArray(uint32 idx, bool value) {
+    typeHasFlexibleArray.at(idx) = value;
+  }
+
+  FieldID GetStructFieldCount(uint32 idx) const {
+    return structFieldCountTable.at(idx);
+  }
+  uint32 GetSizeOfStructFieldCountTable() const {
+    return structFieldCountTable.size();
+  }
+  void SetStructFieldCount(uint32 idx, FieldID value) {
+    structFieldCountTable.at(idx) = value;
+  }
+  void AppendStructFieldCount(uint32 idx, FieldID value) {
+    structFieldCountTable.at(idx) += value;
+  }
+
+ private:
+  bool TyIsInSizeAlignTable(const MIRType &ty) const;
+  void AddAndComputeSizeAlign(MIRType &ty);
+  void ComputeStructTypeSizesAligns(MIRType &ty, const TyIdx &tyIdx);
+  void ComputeClassTypeSizesAligns(MIRType &ty, const TyIdx &tyIdx, uint8 align = 0);
+  void ComputeArrayTypeSizesAligns(MIRType &ty, const TyIdx &tyIdx);
+  void ComputeFArrayOrJArrayTypeSizesAligns(MIRType &ty, const TyIdx &tyIdx);
+
+  MIRModule &mirModule;
+  MapleVector<uint64> typeSizeTable;           /* index is TyIdx */
+  MapleVector<uint8> typeAlignTable;          /* index is TyIdx */
+  MapleVector<bool> typeHasFlexibleArray;     /* struct with flexible array */
+  /*
+   * gives number of fields inside
+   * each struct inclusive of nested structs, for speeding up
+   * traversal for locating the field for a given fieldID
+   */
+  MapleVector<FieldID> structFieldCountTable;
+  /*
+   * a lookup table for class layout. the vector is indexed by field-id
+   * Note: currently only for java class types.
+   */
+  MapleUnorderedMap<MIRClassType*, JClassLayout*> jClassLayoutTable;
+  MapleUnorderedMap<MIRFunction*, TyIdx> funcReturnType;
+}; /* class BECommon */
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_BE_BECOMMON_H */
diff --git a/src/mapleall/maple_be/include/be/common_utils.h b/src/mapleall/maple_be/include/be/common_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..04cec84218a8e062bd62dd8cef5890e83b47e5ee
--- /dev/null
+++ b/src/mapleall/maple_be/include/be/common_utils.h
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_BE_COMMON_UTILS_H
+#define MAPLEBE_INCLUDE_BE_COMMON_UTILS_H
+#include "types_def.h"
+#include "mpl_logging.h"
+
+namespace maplebe {
+using namespace maple;
+constexpr uint32 kOffsetAlignmentOf8Bit = 0;
+constexpr uint32 kOffsetAlignmentOf16Bit = 1;
+constexpr uint32 kOffsetAlignmentOf32Bit = 2;
+constexpr uint32 kOffsetAlignmentOf64Bit = 3;
+constexpr uint32 kOffsetAlignmentOf128Bit = 4;
+constexpr uint32 kBaseOffsetAlignment = 3;
+/*
+ * The constexpr implementations, without assertions.  Suitable for using in
+ * constants.
+ */
+constexpr uint32 k1FConst = 31;
+constexpr uint32 k0BitSize = 0;
+constexpr uint32 k1BitSize = 1;
+constexpr uint32 k2BitSize = 2;
+constexpr uint32 k3BitSize = 3;
+constexpr uint32 k4BitSize = 4;
+constexpr uint32 k5BitSize = 5;
+constexpr uint32 k6BitSize = 6;
+constexpr uint32 k7BitSize = 7;
+constexpr uint32 k8BitSize = 8;
+constexpr uint32 k16BitSize = 16;
+constexpr uint32 k24BitSize = 24;
+constexpr uint32 k32BitSize = 32;
+constexpr uint32 k48BitSize = 48;
+constexpr uint32 k56BitSize = 56;
+constexpr uint32 k64BitSize = 64;
+constexpr uint32 k128BitSize = 128;
+constexpr uint32 k256BitSize = 256;
+constexpr uint32 k512BitSize = 512;
+constexpr uint32 k1024BitSize = 1024;
+constexpr uint32 k2048BitSize = 2048;
+
+constexpr int32 k1FConstInt = 31;
+constexpr int32 k0BitSizeInt = 0;
+constexpr int32 k1BitSizeInt = 1;
+constexpr int32 k2BitSizeInt = 2;
+constexpr int32 k3BitSizeInt = 3;
+constexpr int32 k4BitSizeInt = 4;
+constexpr int32 k5BitSizeInt = 5;
+constexpr int32 k6BitSizeInt = 6;
+constexpr int32 k7BitSizeInt = 7;
+constexpr int32 k8BitSizeInt = 8;
+constexpr int32 k16BitSizeInt = 16;
+constexpr int32 k24BitSizeInt = 24;
+constexpr int32 k32BitSizeInt = 32;
+constexpr int32 k48BitSizeInt = 48;
+constexpr int32 k56BitSizeInt = 56;
+constexpr int32 k64BitSizeInt = 64;
+constexpr int32 k128BitSizeInt = 128;
+constexpr int32 k256BitSizeInt = 256;
+constexpr int32 k512BitSizeInt = 512;
+constexpr int32 k1024BitSizeInt = 1024;
+
+constexpr int32 kNegative256BitSize = -256;
+constexpr int32 kNegative512BitSize = -512;
+constexpr int32 kNegative1024BitSize = -1024;
+
+constexpr uint32 k1ByteSize = 1;
+constexpr uint32 k2ByteSize = 2;
+constexpr uint32 k3ByteSize = 3;
+constexpr uint32 k4ByteSize = 4;
+constexpr uint32 k8ByteSize = 8;
+constexpr uint32 k9ByteSize = 9;
+constexpr uint32 k12ByteSize = 12;
+constexpr uint32 k14ByteSize = 14;
+constexpr uint32 k15ByteSize = 15;
+constexpr uint32 k16ByteSize = 16;
+constexpr uint32 k32ByteSize = 32;
+
+constexpr int32 k1ByteSizeInt = 1;
+constexpr int32 k2ByteSizeInt = 2;
+constexpr int32 k3ByteSizeInt = 3;
+constexpr int32 k4ByteSizeInt = 4;
+constexpr int32 k8ByteSizeInt = 8;
+constexpr int32 k9ByteSizeInt = 9;
+constexpr int32 k12ByteSizeInt = 12;
+constexpr int32 k14ByteSizeInt = 14;
+constexpr int32 k15ByteSizeInt = 15;
+constexpr int32 k16ByteSizeInt = 16;
+constexpr int32 k32ByteSizeInt = 32;
+
+constexpr uint32 k1EightBytesSize = 8;
+constexpr uint32 k2EightBytesSize = 16;
+constexpr uint32 k3EightBytesSize = 24;
+constexpr uint32 k4EightBytesSize = 32;
+
+constexpr uint32 k4BitShift = 2; /* 4 is 1 << 2; */
+constexpr uint32 k8BitShift = 3;  /* 8 is 1 << 3; */
+constexpr uint32 k16BitShift = 4; /* 16 is 1 << 4 */
+
+constexpr uint32 kDwordSizeTwo = 2;
+
+constexpr uint32 k4ByteFloatSize = 4;
+constexpr uint32 k8ByteDoubleSize = 8;
+
+/* Storage location of operands in one insn */
+constexpr int32 kInsnFirstOpnd = 0;
+constexpr int32 kInsnSecondOpnd = 1;
+constexpr int32 kInsnThirdOpnd = 2;
+constexpr int32 kInsnFourthOpnd = 3;
+constexpr int32 kInsnFifthOpnd = 4;
+constexpr int32 kInsnSixthOpnd = 5;
+constexpr int32 kInsnSeventhOpnd = 6;
+constexpr int32 kInsnEighthOpnd = 7;
+constexpr int32 kInsnMaxOpnd = 8;
+
+/* Reg of CCLocInfo */
+constexpr uint32 kFirstReg = 0;
+constexpr uint32 kSecondReg = 1;
+constexpr uint32 kThirdReg = 2;
+constexpr uint32 kFourthReg = 3;
+
+/* inline asm operand designations */
+constexpr uint32 kAsmStringOpnd = 0;
+constexpr uint32 kAsmOutputListOpnd = 1;
+constexpr uint32 kAsmClobberListOpnd = 2;
+constexpr uint32 kAsmInputListOpnd = 3;
+constexpr uint32 kAsmOutputConstraintOpnd = 4;
+constexpr uint32 kAsmInputConstraintOpnd = 5;
+constexpr uint32 kAsmOutputRegPrefixOpnd = 6;
+constexpr uint32 kAsmInputRegPrefixOpnd = 7;
+
+/* Number of registers */
+constexpr uint32 kOneRegister = 1;
+constexpr uint32 kTwoRegister = 2;
+constexpr uint32 kThreeRegister = 3;
+constexpr uint32 kFourRegister = 4;
+
+/* Size of struct for memcpy */
+constexpr uint32 kParmMemcpySize = 40;
+
+/* const value used in cfg */
+constexpr uint32 kSuccSizeOfIfBB = 2;
+
+/* Check whether the value is an even number. */
+constexpr int32 kDivide2 = 2;
+constexpr int32 kRegNum2 = 2;
+constexpr int32 kStepNum2 = 2;
+constexpr int32 kSign4ByteSize = 4;
+
+/* alignment in bytes of uint8 */
+constexpr uint8 kAlignOfU8 = 3;
+
+/*
+ * if the number of local refvar is less than 12, use stp or str to init local refvar
+ * else call function MCC_InitializeLocalStackRef to init.
+ */
+constexpr int32 kRefNum12 = 12;
+
+/* mod function max argument size */
+constexpr uint32  kMaxModFuncArgSize = 8;
+
+/* string length of spacial name "__EARetTemp__" */
+constexpr int32 kEARetTempNameSize = 10;
+
+/*
+ * Aarch64 data processing instructions have 12 bits of space for values in their instuction word
+ * This is arranged as a four-bit rotate value and an eight-bit immediate value:
+ */
+constexpr uint32 kMaxImmVal5Bits = 5;
+constexpr uint32 kMaxImmVal6Bits = 6;
+constexpr uint32 kMaxImmVal8Bits = 8;
+constexpr uint32 kMaxImmVal12Bits = 12;
+constexpr uint32 kMaxImmVal13Bits = 13;
+constexpr uint32 kMaxImmVal16Bits = 16;
+
+constexpr int32 kMaxPimm8 = 4095;
+constexpr int32 kMaxPimm16 = 8190;
+constexpr int32 kMaxPimm32 = 16380;
+constexpr int32 kMaxPimm64 = 32760;
+constexpr int32 kMaxPimm128 = 65520;
+
+constexpr int32 kMaxPimm[k5BitSize] = {kMaxPimm8, kMaxPimm16, kMaxPimm32, kMaxPimm64, kMaxPimm128};
+constexpr int32 kMaxPairPimm[k3BitSize] = {k256BitSize, k512BitSize, k512BitSize};
+
+constexpr int32 kMaxSimm32 = 255;
+constexpr int32 kMaxSimm32Pair = 252;
+constexpr int32 kMinSimm32 = kNegative256BitSize;
+constexpr int32 kMaxSimm64Pair = 504;
+constexpr int32 kMinSimm64 = kNegative512BitSize;
+
+constexpr int32 kMax12UnsignedImm = 4096;
+constexpr int32 kMax13UnsignedImm = 8192;
+constexpr int32 kMax16UnsignedImm = 65535;
+
+/* Dedicated for Vector */
+constexpr int32 kMinImmVal = -128;
+constexpr int32 kMaxImmVal = 255;
+
+/* aarch64 assembly takes up to 24-bits */
+constexpr uint32 kMaxImmVal24Bits = 24;
+
+constexpr uint32 kDecimalMax = 10;
+
+constexpr double kMicroSecPerMilliSec = 1000.0;
+
+constexpr double kPercent = 100.0;
+
+constexpr int32 kZeroAsciiNum = 48;
+
+enum ConditionCode : uint8 {
+  CC_EQ, /* equal */
+  CC_NE, /* not equal */
+  CC_CS, /* carry set (== HS) */
+  CC_HS, /* unsigned higher or same (== CS) */
+  CC_CC, /* carry clear (== LO) */
+  CC_LO, /* Unsigned lower (== CC) */
+  CC_MI, /* Minus or negative result */
+  CC_PL, /* positive or zero result */
+  CC_VS, /* overflow */
+  CC_VC, /* no overflow */
+  CC_HI, /* unsigned higher */
+  CC_LS, /* unsigned lower or same */
+  CC_GE, /* signed greater than or equal */
+  CC_LT, /* signed less than */
+  CC_GT, /* signed greater than */
+  CC_LE, /* signed less than or equal */
+  CC_AL, /* always, this is the default. usually omitted. */
+  kCcLast
+};
+
+inline ConditionCode GetReverseCC(ConditionCode cc) {
+  switch (cc) {
+    case CC_NE:
+      return CC_EQ;
+    case CC_EQ:
+      return CC_NE;
+    case CC_HS:
+      return CC_LO;
+    case CC_LO:
+      return CC_HS;
+    case CC_MI:
+      return CC_PL;
+    case CC_PL:
+      return CC_MI;
+    case CC_VS:
+      return CC_VC;
+    case CC_VC:
+      return CC_VS;
+    case CC_HI:
+      return CC_LS;
+    case CC_LS:
+      return CC_HI;
+    case CC_LT:
+      return CC_GE;
+    case CC_GE:
+      return CC_LT;
+    case CC_GT:
+      return CC_LE;
+    case CC_LE:
+      return CC_GT;
+    default:
+      CHECK_FATAL(0, "unknown condition code");
+  }
+  return kCcLast;
+}
+
+inline bool IsPowerOf2Const(uint64 i) {
+  return (i & (i - 1)) == 0;
+}
+
+inline uint64 RoundUpConst(uint64 offset, uint64 align) {
+  return (-align) & (offset + align - 1);
+}
+
+inline bool IsPowerOf2(uint64 i) {
+  return IsPowerOf2Const(i);
+}
+
+/* align must be a power of 2 */
+inline uint64 RoundUp(uint64 offset, uint64 align) {
+  if (align == 0) {
+    return offset;
+  }
+  ASSERT(IsPowerOf2(align), "align must be power of 2!");
+  return RoundUpConst(offset, align);
+}
+
+inline uint64 RoundDownConst(uint64 offset, uint64 align) {
+  return (UINT64_MAX - align + 1) & offset;
+}
+
+// align must be a power of 2
+inline uint64 RoundDown(uint64 offset, uint64 align) {
+  if (align == 0) {
+    return offset;
+  }
+  ASSERT(IsPowerOf2(align), "align must be power of 2!");
+  return RoundDownConst(offset, align);
+}
+
+inline bool IsAlignedTo(uint64 offset, uint64 align) {
+  ASSERT(IsPowerOf2(align), "align must be power of 2!");
+  return (offset & (align - 1)) == 0;
+}
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_BE_COMMON_UTILS_H */
diff --git a/src/mapleall/maple_be/include/be/lower.h b/src/mapleall/maple_be/include/be/lower.h
new file mode 100644
index 0000000000000000000000000000000000000000..eee0bb15588677821b2a10126b8141a1b4a64284
--- /dev/null
+++ b/src/mapleall/maple_be/include/be/lower.h
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_BE_LOWERER_H
+#define MAPLEBE_INCLUDE_BE_LOWERER_H
+/* C++ headers. */
+#include <vector>
+#include <unordered_map>
+#include <utility>
+#include <cstddef>
+#include <cstdarg>
+#include <regex>
+#include "intrinsics.h"  /* For IntrinDesc. This includes 'intrinsic_op.h' as well */
+#include "becommon.h"
+#include "cg.h"
+#include "bbt.h"
+/* MapleIR headers. */
+#include "mir_nodes.h"
+#include "mir_module.h"
+#include "mir_function.h"
+#include "mir_lower.h"
+#include "simplify.h"
+
+namespace maplebe {
+class CGLowerer {
+  enum Option : uint64 {
+    kUndefined = 0,
+    kGenEh = 1ULL << 0,
+    kVerboseCG = 1ULL << 1,
+  };
+
+  using BuiltinFunctionID = uint32;
+  using OptionFlag = uint64;
+ public:
+  CGLowerer(MIRModule &mod, BECommon &common, MemPool &memPool, MIRFunction *func = nullptr)
+      : mirModule(mod),
+        beCommon(common),
+        simplifyOp(memPool) {
+    SetOptions(kGenEh);
+    mirBuilder = mod.GetMIRBuilder();
+    SetCurrentFunc(func);
+  }
+
+  CGLowerer(MIRModule &mod, BECommon &common, MemPool &memPool, bool genEh, bool verboseCG)
+      : mirModule(mod),
+        beCommon(common),
+        simplifyOp(memPool) {
+    OptionFlag option = 0;
+    if (genEh) {
+      option |= kGenEh;
+    }
+    if (verboseCG) {
+      option |= kVerboseCG;
+    }
+    SetOptions(option);
+    mirBuilder = mod.GetMIRBuilder();
+    SetCurrentFunc(nullptr);
+  }
+
+  ~CGLowerer() {
+    mirBuilder = nullptr;
+    currentBlock = nullptr;
+  }
+
+  MIRFunction *RegisterFunctionVoidStarToVoid(BuiltinFunctionID id, const std::string &name,
+                                              const std::string &paramName);
+
+  void RegisterBuiltIns();
+
+  void LowerFunc(MIRFunction &func);
+
+  BaseNode *LowerIntrinsicop(const BaseNode &parent, IntrinsicopNode &intrinNode, BlockNode &newBlk);
+
+  BaseNode *LowerIntrinsicopwithtype(const BaseNode &parent, IntrinsicopNode &intrinNode, BlockNode &blk);
+
+  StmtNode *LowerIntrinsicMplClearStack(const IntrinsiccallNode &intrinCall, BlockNode &newBlk);
+
+  StmtNode *LowerIntrinsicRCCall(const IntrinsiccallNode &intrinCall);
+
+  void LowerArrayStore(const IntrinsiccallNode &intrinCall, BlockNode &newBlk);
+
+  StmtNode *LowerDefaultIntrinsicCall(IntrinsiccallNode &intrinCall, MIRSymbol &st, MIRFunction &fn);
+
+  StmtNode *LowerIntrinsicMplCleanupLocalRefVarsSkip(IntrinsiccallNode &intrinCall);
+
+  StmtNode *LowerIntrinsiccall(IntrinsiccallNode &intrinCall, BlockNode &newBlk);
+
+  StmtNode *LowerSyncEnterSyncExit(StmtNode &stmt);
+
+  MIRFunction *GetCurrentFunc() const {
+    return mirModule.CurFunction();
+  }
+
+  BaseNode *LowerExpr(BaseNode &parent, BaseNode &expr, BlockNode &blkNode);
+
+  BaseNode *LowerDread(DreadNode &dread);
+
+  BaseNode *LowerIread(IreadNode &iread) {
+    /* use PTY_u8 for boolean type in dread/iread */
+    if (iread.GetPrimType() == PTY_u1) {
+      iread.SetPrimType(PTY_u8);
+    }
+    return (iread.GetFieldID() == 0 ? &iread : LowerIreadBitfield(iread));
+  }
+
+  BaseNode *LowerCastExpr(BaseNode &expr) const;
+
+  BaseNode *ExtractSymbolAddress(const StIdx &stIdx);
+  BaseNode *LowerDreadToThreadLocal(BaseNode &expr);
+  StmtNode *LowerDassignToThreadLocal(StmtNode &stmt);
+
+  void LowerDassign(DassignNode &dsNode, BlockNode &newBlk);
+
+  void LowerResetStmt(StmtNode &stmt, BlockNode &block);
+
+  void LowerIassign(IassignNode &iassign, BlockNode &newBlk);
+
+  void LowerRegassign(RegassignNode &regNode, BlockNode &newBlk);
+
+  void AddElemToPrintf(MapleVector<BaseNode*> &argsPrintf, int num, ...) const;
+
+  bool CheckSwitchTableContinuous(SwitchNode &stmt) const;
+
+  bool IsSwitchToRangeGoto(const BlockNode &blk) const;
+
+  std::string AssertBoundaryGetFileName(StmtNode &stmt) {
+    size_t pos = mirModule.GetFileNameFromFileNum(stmt.GetSrcPos().FileNum()).rfind('/');
+    return mirModule.GetFileNameFromFileNum(stmt.GetSrcPos().FileNum()).substr(pos + 1);
+  }
+
+  std::string GetFileNameSymbolName(const std::string &fileName) const;
+
+  void SwitchAssertBoundary(StmtNode &stmt, MapleVector<BaseNode*> &argsPrintf);
+
+  void LowerAssertBoundary(StmtNode &stmt, BlockNode &block, BlockNode &newBlk, std::vector<StmtNode *> &abortNode);
+
+  StmtNode *LowerIntrinsicopDassign(const DassignNode &dsNode, IntrinsicopNode &intrinNode, BlockNode &newBlk);
+
+  void LowerGCMalloc(const BaseNode &node, const GCMallocNode &gcmalloc, BlockNode &blkNode, bool perm = false);
+
+  std::string GetNewArrayFuncName(const uint32 elemSize, const bool perm) const;
+
+  void LowerJarrayMalloc(const StmtNode &stmt, const JarrayMallocNode &node, BlockNode &blkNode, bool perm = false);
+
+  BaseNode *LowerAddrof(AddrofNode &addrof) const {
+    return &addrof;
+  }
+
+  BaseNode *LowerIaddrof(const IreadNode &iaddrof);
+  BaseNode *SplitBinaryNodeOpnd1(BinaryNode &bNode, BlockNode &blkNode);
+  BaseNode *SplitTernaryNodeResult(TernaryNode &tNode, BaseNode &parent, BlockNode &blkNode);
+  bool IsComplexSelect(const TernaryNode &tNode) const;
+  int32 FindTheCurrentStmtFreq(const StmtNode *stmt) const;
+  BaseNode *LowerComplexSelect(const TernaryNode &tNode, BaseNode &parent, BlockNode &blkNode);
+  BaseNode *LowerFarray(ArrayNode &array);
+  BaseNode *LowerArrayDim(ArrayNode &array, int32 dim);
+  BaseNode *LowerArrayForLazyBiding(BaseNode &baseNode, BaseNode &offsetNode, const BaseNode &parent);
+  BaseNode *LowerArray(ArrayNode &array, const BaseNode &parent);
+  BaseNode *LowerCArray(ArrayNode &array);
+
+  DassignNode *SaveReturnValueInLocal(StIdx stIdx, uint16 fieldID);
+  void LowerCallStmt(StmtNode &stmt, StmtNode *&nextStmt, BlockNode &newBlk, MIRType *retty = nullptr,
+                     bool uselvar = false, bool isIntrinAssign = false);
+  BlockNode *LowerIntrinsiccallAassignedToAssignStmt(IntrinsiccallNode &intrinsicCall);
+  BlockNode *LowerCallAssignedStmt(StmtNode &stmt, bool uselvar = false);
+  bool LowerStructReturn(BlockNode &newBlk, StmtNode *stmt, StmtNode *&nextStmt, bool &lvar, BlockNode *oldBlk);
+  BlockNode *LowerMemop(StmtNode &stmt);
+
+  BaseNode *LowerRem(BaseNode &expr, BlockNode &blk);
+
+  BaseNode *LowerExtractBits(ExtractbitsNode &extr) const;
+
+  void LowerStmt(StmtNode &stmt, BlockNode &newBlk);
+
+  void LowerSwitchOpnd(StmtNode &stmt, BlockNode &newBlk);
+
+  MIRSymbol *CreateNewRetVar(const MIRType &ty, const std::string &prefix);
+
+  void RegisterExternalLibraryFunctions();
+
+  BlockNode *LowerBlock(BlockNode &block);
+
+  void SimplifyBlock(BlockNode &block) const;
+
+  void LowerTryCatchBlocks(BlockNode &body);
+
+#if TARGARM32 || TARGAARCH64 || TARGRISCV64 || TARGX86_64
+  BlockNode *LowerReturnStructUsingFakeParm(NaryStmtNode &retNode);
+#endif
+  BlockNode *LowerReturn(NaryStmtNode &retNode);
+  void LowerEntry(MIRFunction &func);
+
+  StmtNode *LowerCall(
+      CallNode &callNode, StmtNode *&nextStmt, BlockNode &newBlk, MIRType *retTy = nullptr, bool uselvar = false);
+  void SplitCallArg(CallNode &callNode, BaseNode *newOpnd, size_t i, BlockNode &newBlk);
+
+  void CleanupBranches(MIRFunction &func) const;
+
+  void LowerTypePtr(BaseNode &node) const;
+
+  BaseNode *GetBitField(int32 byteOffset, BaseNode *baseAddr, PrimType fieldPrimType);
+  StmtNode *WriteBitField(const std::pair<int32, int32> &byteBitOffsets, const MIRBitFieldType *fieldType,
+                          BaseNode *baseAddr, BaseNode *rhs, BlockNode *block);
+  BaseNode *ReadBitField(const std::pair<int32, int32> &byteBitOffsets, const MIRBitFieldType *fieldType,
+                         BaseNode *baseAddr);
+  BaseNode *LowerDreadBitfield(DreadNode &dread);
+  BaseNode *LowerIreadBitfield(IreadNode &iread);
+  StmtNode *LowerDassignBitfield(DassignNode &dassign, BlockNode &newBlk);
+  StmtNode *LowerIassignBitfield(IassignNode &iassign, BlockNode &newBlk);
+
+  void LowerAsmStmt(AsmNode *asmNode, BlockNode *newBlk);
+
+  bool ShouldOptarray() const {
+    ASSERT(mirModule.CurFunction() != nullptr, "nullptr check");
+    return MIRLower::ShouldOptArrayMrt(*mirModule.CurFunction());
+  }
+
+  BaseNode *NodeConvert(PrimType mType, BaseNode &expr);
+  /* Lower pointer/reference types if found in pseudo registers. */
+  void LowerPseudoRegs(const MIRFunction &func) const;
+
+  /* A pseudo register refers to a symbol when DreadNode is converted to RegreadNode. */
+  StIdx GetSymbolReferredToByPseudoRegister(PregIdx regNO) const {
+    (void)regNO;
+    return StIdx();
+  }
+
+  void SetOptions(OptionFlag option) {
+    options = option;
+  }
+
+  void SetCheckLoadStore(bool value) {
+    checkLoadStore = value;
+  }
+
+  /* if it defines a built-in to use for the given intrinsic, return the name. otherwise, return nullptr */
+  PUIdx GetBuiltinToUse(BuiltinFunctionID id) const;
+  void InitArrayClassCacheTableIndex();
+
+  MIRModule &mirModule;
+  BECommon &beCommon;
+  BlockNode *currentBlock = nullptr;  /* current block for lowered statements to be inserted to */
+  bool checkLoadStore = false;
+  int64 seed = 0;
+  SimplifyOp simplifyOp;
+  static const std::string kIntrnRetValPrefix;
+  static const std::string kUserRetValPrefix;
+
+  static constexpr PUIdx kFuncNotFound = PUIdx(-1);
+  static constexpr int kThreeDimArray = 3;
+  static constexpr int kNodeThirdOpnd = 2;
+  static constexpr int kMCCSyncEnterFast0 = 0;
+  static constexpr int kMCCSyncEnterFast1 = 1;
+  static constexpr int kMCCSyncEnterFast2 = 2;
+  static constexpr int kMCCSyncEnterFast3 = 3;
+
+  void BuildLabel2FreqMap();
+
+  std::unordered_map<LabelIdx, uint64> &GetLabel2Freq() {
+    return l2fMap;
+  }
+
+ protected:
+  /*
+   * true if the lower level (e.g. mplcg) can handle the intrinsic directly.
+   * For example, the INTRN_MPL_ATOMIC_EXCHANGE_PTR can be directly handled by mplcg,
+   * and generate machine code sequences not containing any function calls.
+   * Such intrinsics will bypass the lowering of "assigned",
+   * and let mplcg handle the intrinsic results which are not return values.
+   */
+  bool IsIntrinsicCallHandledAtLowerLevel(MIRIntrinsicID intrinsic) const;
+
+  bool IsIntrinsicOpHandledAtLowerLevel(MIRIntrinsicID intrinsic) const;
+
+ private:
+
+  void SetCurrentFunc(MIRFunction *func) {
+    mirModule.SetCurFunction(func);
+    simplifyOp.SetFunction(func);
+    if (func != nullptr) {
+      const std::string &dumpFunc = CGOptions::GetDumpFunc();
+      const bool debug = CGOptions::GetDumpPhases().find("cglower") != CGOptions::GetDumpPhases().end() &&
+          (dumpFunc == "*" || dumpFunc == func->GetName());
+      simplifyOp.SetDebug(debug);
+    }
+  }
+
+  bool ShouldAddAdditionalComment() const {
+    return (options & kVerboseCG) != 0;
+  }
+
+  bool GenerateExceptionHandlingCode() const {
+    return (options & kGenEh) != 0;
+  }
+
+  BaseNode *MergeToCvtType(PrimType dType, PrimType sType, BaseNode &src) const;
+  BaseNode *LowerJavascriptIntrinsicop(IntrinsicopNode &intrinNode, const IntrinDesc &desc);
+  StmtNode *CreateStmtCallWithReturnValue(const IntrinsicopNode &intrinNode, const MIRSymbol &ret, PUIdx bFunc,
+                                          BaseNode *extraInfo = nullptr) const;
+  StmtNode *CreateStmtCallWithReturnValue(const IntrinsicopNode &intrinNode, PregIdx retPregIdx, PUIdx bFunc,
+                                          BaseNode *extraInfo = nullptr) const;
+  BaseNode *LowerIntrinsicop(const BaseNode &parent, IntrinsicopNode &intrinNode);
+  BaseNode *LowerIntrinJavaMerge(const BaseNode &parent, IntrinsicopNode &intrinNode) const;
+  BaseNode *LowerIntrinJavaArrayLength(const BaseNode &parent, IntrinsicopNode &intrinNode);
+  BaseNode *LowerIntrinsicopWithType(const BaseNode &parent, IntrinsicopNode &intrinNode);
+
+  MIRType *GetArrayNodeType(BaseNode &baseNode);
+  IreadNode &GetLenNode(BaseNode &opnd0);
+  LabelIdx GetLabelIdx(MIRFunction &curFunc) const;
+  void ProcessArrayExpr(BaseNode &expr, BlockNode &blkNode);
+  void ProcessClassInfo(MIRType &classType, bool &classInfoFromRt, std::string &classInfo) const;
+  StmtNode *GenCallNode(const StmtNode &stmt, PUIdx &funcCalled, CallNode& origCall);
+  StmtNode *GenIntrinsiccallNode(const StmtNode &stmt, PUIdx &funcCalled, bool &handledAtLowerLevel,
+                                    IntrinsiccallNode &origCall);
+  StmtNode *GenIcallNode(PUIdx &funcCalled, IcallNode &origCall);
+  BlockNode *GenBlockNode(StmtNode &newCall, const CallReturnVector &p2nRets, const Opcode &opcode,
+                          const PUIdx &funcCalled, bool handledAtLowerLevel, bool uselvar);
+  BaseNode *GetClassInfoExprFromRuntime(const std::string &classInfo);
+  BaseNode *GetClassInfoExprFromArrayClassCache(const std::string &classInfo);
+  BaseNode *GetClassInfoExpr(const std::string &classInfo) const;
+  BaseNode *GetBaseNodeFromCurFunc(MIRFunction &curFunc, bool isFromJarray);
+
+  OptionFlag options = 0;
+  bool needBranchCleanup = false;
+  bool hasTry = false;
+
+  static std::vector<std::pair<BuiltinFunctionID, PUIdx>> builtinFuncIDs;
+  MIRBuilder *mirBuilder = nullptr;
+  uint32 labelIdx = 0;
+  static std::unordered_map<IntrinDesc*, PUIdx> intrinFuncIDs;
+  static std::unordered_map<std::string, size_t> arrayClassCacheIndex;
+  std::unordered_map<LabelIdx, uint64> l2fMap; // Map label to frequency on profileUse
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_BE_LOWERER_H */
diff --git a/src/mapleall/maple_be/include/be/rt.h b/src/mapleall/maple_be/include/be/rt.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0a235a2f39be74ef548c64f1296095588498304
--- /dev/null
+++ b/src/mapleall/maple_be/include/be/rt.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_BE_RT_H
+#define MAPLEBE_INCLUDE_BE_RT_H
+
+#include <cstdint>
+#include <string>
+
+namespace maplebe {
+/*
+ * This class contains constants about the ABI of the runtime, such as symbols
+ * for GC-related metadata in generated binary files.
+ */
+class RTSupport {
+ public:
+  static RTSupport &GetRTSupportInstance() {
+    static RTSupport rtSupport;
+    return rtSupport;
+  }
+  uint64_t GetObjectAlignment() const {
+    return kObjectAlignment;
+  }
+  int64_t GetArrayContentOffset() const {
+    return kArrayContentOffset;
+  }
+  int64_t GetArrayLengthOffset() const {
+    return kArrayLengthOffset;
+  }
+  uint64_t GetFieldSize() const {
+    return kRefFieldSize;
+  }
+  uint64_t GetFieldAlign() const {
+    return kRefFieldAlign;
+  }
+
+ protected:
+  uint64_t kObjectAlignment = 0;    /* Word size. Suitable for all Java types. */
+  uint64_t kObjectHeaderSize = 0;   /* java object header used by MM. */
+
+#ifdef USE_32BIT_REF
+  uint32_t kRefFieldSize = 0;       /* reference field in java object */
+  uint32_t kRefFieldAlign = 0;
+#else
+  uint32_t kRefFieldSize = 0;       /* reference field in java object */
+  uint32_t kRefFieldAlign = 0;
+#endif /* USE_32BIT_REF */
+  /* The array length offset is fixed since CONTENT_OFFSET is fixed to simplify code */
+  int64_t kArrayLengthOffset = 0;  /* shadow + monitor + [padding] */
+  /* The array content offset is aligned to 8B to alow hosting of size-8B elements */
+  int64_t kArrayContentOffset = 0; /* fixed */
+  int64_t kGcTibOffset = 0;
+  int64_t kGcTibOffsetAbs = 0;
+
+ private:
+  RTSupport() {
+    kObjectAlignment = 8;
+    kObjectHeaderSize = 8;
+#ifdef USE_32BIT_REF
+    kRefFieldSize = 4;
+    kRefFieldAlign = 4;
+#else
+    kRefFieldSize = 8;
+    kRefFieldAlign = 8;
+#endif /* USE_32BIT_REF */
+    kArrayLengthOffset = 12;
+    kArrayContentOffset = 16;
+    kGcTibOffset = -8;
+    kGcTibOffsetAbs = -kGcTibOffset;
+  }
+  static const std::string kObjectMapSectionName;
+  static const std::string kGctibLabelArrayOfObject;
+  static const std::string kGctibLabelJavaObject;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_BE_RT_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/be/switch_lowerer.h b/src/mapleall/maple_be/include/be/switch_lowerer.h
new file mode 100644
index 0000000000000000000000000000000000000000..18450a1b39e0dd1d797054c80a519f8255932cd8
--- /dev/null
+++ b/src/mapleall/maple_be/include/be/switch_lowerer.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_BE_SWITCH_LOWERER_H
+#define MAPLEBE_INCLUDE_BE_SWITCH_LOWERER_H
+#include "mir_nodes.h"
+#include "mir_module.h"
+#include "lower.h"
+
+namespace maplebe {
+using namespace maple;
+class BELowerer;
+
+class SwitchLowerer {
+ public:
+  SwitchLowerer(maple::MIRModule &mod, maple::SwitchNode &stmt,
+                CGLowerer *lower, maple::MapleAllocator &allocator)
+      : mirModule(mod),
+        stmt(&stmt),
+        cgLowerer(lower),
+        switchItems(allocator.Adapter()),
+        ownAllocator(&allocator) {}
+
+  SwitchLowerer(maple::MIRModule &mod, maple::SwitchNode &stmt,
+                maple::MapleAllocator &allocator)
+      : mirModule(mod),
+        stmt(&stmt),
+        switchItems(allocator.Adapter()),
+        ownAllocator(&allocator) {}
+
+  ~SwitchLowerer() = default;
+
+  maple::BlockNode *LowerSwitch(LabelIdx newLabelIdx = 0);
+
+ private:
+  using Cluster = std::pair<maple::int32, maple::int32>;
+  using SwitchItem = std::pair<maple::int32, maple::int32>;
+
+  maple::MIRModule &mirModule;
+  maple::SwitchNode *stmt;
+  CGLowerer *cgLowerer;
+  /*
+   * the original switch table is sorted and then each dense (in terms of the
+   * case tags) region is condensed into 1 switch item; in the switchItems
+   * table, each item either corresponds to an original entry in the original
+   * switch table (pair's second is 0), or to a dense region (pair's second
+   * gives the upper limit of the dense range)
+   */
+  maple::MapleVector<SwitchItem> switchItems;  /* uint32 is index in switchTable */
+  maple::MapleAllocator *ownAllocator;
+  const maple::int32 kClusterSwitchCutoff = 5;
+  const float kClusterSwitchDensityHigh = 0.4;
+  const float kClusterSwitchDensityLow = 0.2;
+  const maple::int32 kMaxRangeGotoTableSize = 127;
+  bool jumpToDefaultBlockGenerated = false;
+
+  void FindClusters(MapleVector<Cluster> &clusters) const;
+  void InitSwitchItems(MapleVector<Cluster> &clusters);
+  maple::RangeGotoNode *BuildRangeGotoNode(int32 startIdx, int32 endIdx, LabelIdx newLabelIdx);
+  maple::CompareNode *BuildCmpNode(Opcode opCode, uint32 idx);
+  maple::GotoNode *BuildGotoNode(int32 idx);
+  maple::CondGotoNode *BuildCondGotoNode(int32 idx, Opcode opCode, BaseNode &cond);
+  maple::BlockNode *BuildCodeForSwitchItems(int32 start, int32 end, bool lowBlockNodeChecked,
+                                            bool highBlockNodeChecked, LabelIdx newLabelIdx = 0);
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_BE_SWITCH_LOWERER_H */
diff --git a/src/mapleall/maple_be/include/be/try_catch.h b/src/mapleall/maple_be/include/be/try_catch.h
new file mode 100644
index 0000000000000000000000000000000000000000..45387aeba275a5280de6830e066d6baf6359a472
--- /dev/null
+++ b/src/mapleall/maple_be/include/be/try_catch.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_BE_TRY_CATCH_H
+#define MAPLEBE_INCLUDE_BE_TRY_CATCH_H
+#include "bbt.h"
+/* MapleIR headers. */
+#include "mir_nodes.h"
+#include "mir_lower.h"
+
+namespace maplebe {
+using namespace maple;
+class TryEndTryBlock {
+ public:
+  explicit TryEndTryBlock(MemPool &memPool)
+      : allocator(&memPool), enclosedBBs(allocator.Adapter()),
+        labeledBBsInTry(allocator.Adapter()), bbsToRelocate(allocator.Adapter()) {}
+
+  ~TryEndTryBlock() = default;
+
+  void Init() {
+    startTryBB = nullptr;
+    endTryBB = nullptr;
+    tryStmt = nullptr;
+    enclosedBBs.clear();
+    labeledBBsInTry.clear();
+    bbsToRelocate.clear();
+  }
+
+  void Reset(BBT &startBB) {
+    startTryBB = &startBB;
+    CHECK_NULL_FATAL(startTryBB->GetKeyStmt());
+    tryStmt = startTryBB->GetKeyStmt();
+    CHECK_FATAL(tryStmt->GetOpCode() == OP_try, "expect OPT_try");
+    endTryBB = nullptr;
+    enclosedBBs.clear();
+    labeledBBsInTry.clear();
+    bbsToRelocate.clear();
+  }
+
+  void SetStartTryBB(BBT *bb) {
+    startTryBB = bb;
+  }
+
+  BBT *GetStartTryBB() {
+    return startTryBB;
+  }
+
+  void SetEndTryBB(BBT *bb) {
+    endTryBB = bb;
+  }
+
+  BBT *GetEndTryBB() {
+    return endTryBB;
+  }
+
+  StmtNode *GetTryStmtNode() {
+    return tryStmt;
+  }
+
+  MapleVector<BBT*> &GetEnclosedBBs() {
+    return enclosedBBs;
+  }
+
+  size_t GetEnclosedBBsSize() const {
+    return enclosedBBs.size();
+  }
+
+  const BBT *GetEnclosedBBsElem(size_t index) const{
+    ASSERT(index < enclosedBBs.size(), "out of range");
+    return enclosedBBs[index];
+  }
+
+  void PushToEnclosedBBs(BBT &bb) {
+    enclosedBBs.emplace_back(&bb);
+  }
+
+  MapleVector<BBT*> &GetLabeledBBsInTry() {
+    return labeledBBsInTry;
+  }
+
+  MapleVector<BBT*> &GetBBsToRelocate() {
+    return bbsToRelocate;
+  }
+
+ private:
+  MapleAllocator allocator;
+  BBT *startTryBB = nullptr;
+  BBT *endTryBB = nullptr;
+  StmtNode *tryStmt = nullptr;
+  MapleVector<BBT*> enclosedBBs;
+  MapleVector<BBT*> labeledBBsInTry;
+  MapleVector<BBT*> bbsToRelocate;
+};
+
+class TryCatchBlocksLower {
+ public:
+  TryCatchBlocksLower(MemPool &memPool, BlockNode &body, MIRModule &mirModule)
+      : memPool(memPool), allocator(&memPool), body(body), mirModule(mirModule),
+        tryEndTryBlock(memPool), bbList(allocator.Adapter()), prevBBOfTry(allocator.Adapter()),
+        firstStmtToBBMap(allocator.Adapter()), catchesSeenSoFar(allocator.Adapter()) {}
+
+  ~TryCatchBlocksLower() = default;
+  void RecoverBasicBlock();
+  void TraverseBBList();
+  void CheckTryCatchPattern() const;
+
+  void SetGenerateEHCode(bool val) {
+    generateEHCode = val;
+  }
+
+ private:
+  MemPool &memPool;
+  MapleAllocator allocator;
+  BlockNode &body;
+  MIRModule &mirModule;
+  TryEndTryBlock tryEndTryBlock;
+  StmtNode *bodyFirst = nullptr;
+  bool bodyEndWithEndTry = false;
+  bool generateEHCode = false;
+  MapleVector<BBT*> bbList;
+  MapleUnorderedMap<BBT*, BBT*> prevBBOfTry;
+  MapleUnorderedMap<StmtNode*, BBT*> firstStmtToBBMap;
+  MapleVector<BBT*> catchesSeenSoFar;
+
+  void ProcessEnclosedBBBetweenTryEndTry();
+  void ConnectRemainBB();
+  BBT *FindInsertAfterBB();
+  void PlaceRelocatedBB(BBT &insertAfter);
+  void PalceCatchSeenSofar(BBT &insertAfter);
+  BBT *CreateNewBB(StmtNode *first, StmtNode *last);
+  bool CheckAndProcessCatchNodeInCurrTryBlock(BBT &origLowerBB, LabelIdx ebbLabel, uint32 index);
+  BBT *CollectCatchAndFallthruUntilNextCatchBB(BBT *&lowerBB, uint32 &nextEnclosedIdx, std::vector<BBT*> &currBBThread);
+  void WrapCatchWithTryEndTryBlock(std::vector<BBT*> &currBBThread, BBT *&nextBBThreadHead,
+                                   uint32 &nextEnclosedIdx, bool hasMoveEndTry);
+  void SwapEndTryBBAndCurrBBThread(const std::vector<BBT*> &currBBThread,
+                                   bool &hasMoveEndTry, const BBT *nextBBThreadHead);
+  void ProcessThreadTail(BBT &threadTail, BBT * const &nextBBThreadHead, bool hasMoveEndTry);
+  static StmtNode *MoveCondGotoIntoTry(BBT &jtBB, BBT &condbrBB, const MapleVector<BBT*> &labeledBBsInTry);
+  static BBT *FindTargetBBlock(LabelIdx idx, const std::vector<BBT*> &bbs);
+};
+} /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_BE_TRY_CATCH_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_MPISel.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_MPISel.h
new file mode 100644
index 0000000000000000000000000000000000000000..aac9a9bd877bf032971be7dfea369b828e65b5c2
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_MPISel.h
@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_abi.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_abi.h
new file mode 100644
index 0000000000000000000000000000000000000000..9f3118688e087c0cd4d0e3237c6b44c52294ef80
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_abi.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ABI_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ABI_H
+
+#include "aarch64_isa.h"
+#include "types_def.h"
+#include "becommon.h"
+
+namespace maplebe {
+using namespace maple;
+
+namespace AArch64Abi {
+constexpr uint32 kNumIntParmRegs = 8;
+constexpr uint32 kNumFloatParmRegs = 8;
+constexpr int32 kYieldPointReservedReg = 19;
+constexpr uint32 kNormalUseOperandNum = 3;
+constexpr uint32 kMaxInstrForCondBr = 260000; // approximately less than (2^18);
+
+constexpr AArch64reg kIntReturnRegs[kNumIntParmRegs] = { R0, R1, R2, R3, R4, R5, R6, R7 };
+constexpr AArch64reg kFloatReturnRegs[kNumFloatParmRegs] = { V0, V1, V2, V3, V4, V5, V6, V7 };
+constexpr AArch64reg kIntParmRegs[kNumIntParmRegs] = { R0, R1, R2, R3, R4, R5, R6, R7 };
+constexpr AArch64reg kFloatParmRegs[kNumFloatParmRegs] = { V0, V1, V2, V3, V4, V5, V6, V7 };
+
+/*
+ * Refer to ARM IHI 0055C_beta: Procedure Call Standard  for
+ * ARM 64-bit Architecture. Section 5.5
+ */
+bool IsAvailableReg(AArch64reg reg);
+bool IsCalleeSavedReg(AArch64reg reg);
+bool IsCallerSaveReg(AArch64reg regNO);
+bool IsParamReg(AArch64reg reg);
+bool IsSpillReg(AArch64reg reg);
+bool IsExtraSpillReg(AArch64reg reg);
+bool IsSpillRegInRA(AArch64reg regNO, bool has3RegOpnd);
+PrimType IsVectorArrayType(MIRType *ty, uint32 &arraySize);
+}  /* namespace AArch64Abi */
+
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ABI_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_alignment.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_alignment.h
new file mode 100644
index 0000000000000000000000000000000000000000..34ce4f7e0bbf8adf4ee6b1d984a19c6248221195
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_alignment.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ALIGNMENT_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ALIGNMENT_H
+
+#include "alignment.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+constexpr uint32 kAlignRegionPower = 4;
+constexpr uint32 kAlignInsnLength = 4;
+constexpr uint32 kAlignMaxNopNum = 1;
+
+struct AArch64AlignInfo {
+  /* if bb size in (16byte, 96byte) , the bb need align */
+  uint32 alignMinBBSize = 16;
+  uint32 alignMaxBBSize = 96;
+  /* default loop & jump align power, related to the target machine.  eg. 2^5 */
+  uint32 loopAlign = 4;
+  uint32 jumpAlign = 5;
+  /* record func_align_power in CGFunc */
+};
+
+class AArch64AlignAnalysis : public AlignAnalysis {
+ public:
+  AArch64AlignAnalysis(CGFunc &func, MemPool &memPool) : AlignAnalysis(func, memPool) {
+    aarFunc = static_cast<AArch64CGFunc*>(&func);
+  }
+  ~AArch64AlignAnalysis() override = default;
+
+  void FindLoopHeader() override;
+  void FindJumpTarget() override;
+  void ComputeLoopAlign() override;
+  void ComputeJumpAlign() override;
+  void ComputeCondBranchAlign() override;
+  bool MarkCondBranchAlign();
+  bool MarkShortBranchSplit();
+  void AddNopAfterMark();
+  void UpdateInsnId();
+  uint32 GetAlignRange(uint32 alignedVal, uint32 addr) const;
+
+  /* filter condition */
+  bool IsIncludeCall(BB &bb) override;
+  bool IsInSizeRange(BB &bb) override;
+  bool HasFallthruEdge(BB &bb) override;
+  bool IsInSameAlignedRegion(uint32 addr1, uint32 addr2, uint32 alignedRegionSize) const;
+
+ private:
+  AArch64CGFunc *aarFunc = nullptr;
+};
+} /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ALIGNMENT_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_args.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_args.h
new file mode 100644
index 0000000000000000000000000000000000000000..e8c10d13de4e7e7ec91b6c79ca17797ed2882c25
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_args.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ARGS_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ARGS_H
+
+#include "args.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+struct ArgInfo {
+  AArch64reg reg;
+  MIRType *mirTy;
+  uint32 symSize;
+  uint32 stkSize;
+  RegType regType;
+  MIRSymbol *sym;
+  const AArch64SymbolAlloc *symLoc;
+  uint8 memPairSecondRegSize;  /* struct arg requiring two regs, size of 2nd reg */
+  bool doMemPairOpt;
+  bool createTwoStores;
+  bool isTwoRegParm;
+};
+
+class AArch64MoveRegArgs : public MoveRegArgs {
+ public:
+  explicit AArch64MoveRegArgs(CGFunc &func) : MoveRegArgs(func) {}
+  ~AArch64MoveRegArgs() override = default;
+  void Run() override;
+
+ private:
+  RegOperand *baseReg = nullptr;
+  const MemSegment *lastSegment = nullptr;
+  void CollectRegisterArgs(std::map<uint32, AArch64reg> &argsList, std::vector<uint32> &indexList,
+                           std::map<uint32, AArch64reg> &pairReg, std::vector<uint32> &numFpRegs,
+                           std::vector<uint32> &fpSize) const;
+  ArgInfo GetArgInfo(std::map<uint32, AArch64reg> &argsList, std::vector<uint32> &numFpRegs,
+                     std::vector<uint32> &fpSize, uint32 argIndex) const;
+  bool IsInSameSegment(const ArgInfo &firstArgInfo, const ArgInfo &secondArgInfo) const;
+  void GenOneInsn(const ArgInfo &argInfo, RegOperand &baseOpnd, uint32 stBitSize, AArch64reg dest, int32 offset) const;
+  void GenerateStpInsn(const ArgInfo &firstArgInfo, const ArgInfo &secondArgInfo);
+  void GenerateStrInsn(const ArgInfo &argInfo, AArch64reg reg2, uint32 numFpRegs, uint32 fpSize);
+  void MoveRegisterArgs();
+  void MoveVRegisterArgs() const;
+  void MoveLocalRefVarToRefLocals(MIRSymbol &mirSym) const;
+  void LoadStackArgsToVReg(MIRSymbol &mirSym) const;
+  void MoveArgsToVReg(const CCLocInfo &ploc, MIRSymbol &mirSym) const;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ARGS_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_call_conv.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_call_conv.h
new file mode 100644
index 0000000000000000000000000000000000000000..d85dafee8c740eb875f9cee7d75c6897ded7c876
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_call_conv.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CALL_CONV_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CALL_CONV_H
+
+#include "types_def.h"
+#include "becommon.h"
+#include "call_conv.h"
+
+namespace maplebe {
+using namespace maple;
+
+/*
+ * We use the names used in ARM IHI 0055C_beta. $ 5.4.2.
+ * nextGeneralRegNO (= _int_parm_num)  : Next General-purpose Register number
+ * nextFloatRegNO (= _float_parm_num): Next SIMD and Floating-point Register Number
+ * nextStackArgAdress (= _last_memOffset): Next Stacked Argument Address
+ * for processing an incoming or outgoing parameter list
+ */
+class AArch64CallConvImpl {
+ public:
+  explicit AArch64CallConvImpl(BECommon &be) : beCommon(be) {}
+
+  ~AArch64CallConvImpl() = default;
+
+  /* Return size of aggregate structure copy on stack. */
+  int32 LocateNextParm(MIRType &mirType, CCLocInfo &pLoc, bool isFirst = false, MIRFunction *tFunc = nullptr);
+
+  int32 LocateRetVal(MIRType &retType, CCLocInfo &pLoc);
+
+  void InitCCLocInfo(CCLocInfo &pLoc) const;
+
+  /* for lmbc */
+  uint32 FloatParamRegRequired(MIRStructType &structType, uint32 &fpSize);
+
+  /*  return value related  */
+  void InitReturnInfo(MIRType &retTy, CCLocInfo &ccLocInfo);
+
+  void SetupSecondRetReg(const MIRType &retTy2, CCLocInfo &pLoc) const;
+
+  void SetupToReturnThroughMemory(CCLocInfo &pLoc) const {
+    pLoc.regCount = 1;
+    pLoc.reg0 = R8;
+    pLoc.primTypeOfReg0 = PTY_u64;
+  }
+
+ private:
+  BECommon &beCommon;
+  uint64 paramNum = 0;  /* number of all types of parameters processed so far */
+  uint32 nextGeneralRegNO = 0;  /* number of integer parameters processed so far */
+  uint32 nextFloatRegNO = 0;  /* number of float parameters processed so far */
+  int32 nextStackArgAdress = 0;
+
+  AArch64reg AllocateGPRegister() {
+    return (nextGeneralRegNO < AArch64Abi::kNumIntParmRegs) ? AArch64Abi::kIntParmRegs[nextGeneralRegNO++] : kRinvalid;
+  }
+
+  void AllocateTwoGPRegisters(CCLocInfo &pLoc) {
+    if ((nextGeneralRegNO + 1) < AArch64Abi::kNumIntParmRegs) {
+      pLoc.reg0 = AArch64Abi::kIntParmRegs[nextGeneralRegNO++];
+      pLoc.reg1 = AArch64Abi::kIntParmRegs[nextGeneralRegNO++];
+    } else {
+      pLoc.reg0 = kRinvalid;
+    }
+  }
+
+  AArch64reg AllocateSIMDFPRegister() {
+    return (nextFloatRegNO < AArch64Abi::kNumFloatParmRegs) ? AArch64Abi::kFloatParmRegs[nextFloatRegNO++] : kRinvalid;
+  }
+
+  void AllocateNSIMDFPRegisters(CCLocInfo &ploc, uint32 num) {
+    if ((nextFloatRegNO + num - 1) < AArch64Abi::kNumFloatParmRegs) {
+      switch (num) {
+        case kOneRegister:
+          ploc.reg0 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          break;
+        case kTwoRegister:
+          ploc.reg0 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          ploc.reg1 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          break;
+        case kThreeRegister:
+          ploc.reg0 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          ploc.reg1 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          ploc.reg2 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          break;
+        case kFourRegister:
+          ploc.reg0 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          ploc.reg1 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          ploc.reg2 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          ploc.reg3 = AArch64Abi::kFloatParmRegs[nextFloatRegNO++];
+          break;
+        default:
+          CHECK_FATAL(0, "AllocateNSIMDFPRegisters: unsupported");
+      }
+    } else {
+      ploc.reg0 = kRinvalid;
+    }
+  }
+
+  void RoundNGRNUpToNextEven() {
+    nextGeneralRegNO = (nextGeneralRegNO + 1U) & ~1U;
+  }
+
+  int32 ProcessPtyAggWhenLocateNextParm(MIRType &mirType, CCLocInfo &pLoc, uint64 &typeSize, int32 typeAlign);
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CALL_CONV_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_cfgo.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cfgo.h
new file mode 100644
index 0000000000000000000000000000000000000000..9eff8f9cd2d504753cc02bb7132a0fc17d9e7b3f
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cfgo.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CFGO_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CFGO_H
+
+#include "cfgo.h"
+
+namespace maplebe {
+class AArch64CFGOptimizer : public CFGOptimizer {
+ public:
+  AArch64CFGOptimizer(CGFunc &func, MemPool &memPool)
+      : CFGOptimizer(func, memPool) {}
+  ~AArch64CFGOptimizer() = default;
+  void InitOptimizePatterns() override;
+};
+
+class AArch64FlipBRPattern : public FlipBRPattern {
+ public:
+  explicit AArch64FlipBRPattern(CGFunc &func) : FlipBRPattern(func) {}
+  ~AArch64FlipBRPattern() = default;
+
+ private:
+  uint32 GetJumpTargetIdx(const Insn &insn) override;
+  MOperator FlipConditionOp(MOperator flippedOp) override;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CFGO_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_cfi_generator.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cfi_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbd1320d7fedae57964d169bd81e42ae5d1b8c8a
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cfi_generator.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CFI_GENERATOR_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CFI_GENERATOR_H
+
+#include "cfi_generator.h"
+
+namespace maplebe {
+class AArch64GenCfi : public GenCfi  {
+ public:
+  explicit AArch64GenCfi(CGFunc &func) : GenCfi(func) {
+    useFP = func.UseFP();
+    if (func.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc) {
+      stackBaseReg = RFP;
+    } else {
+      stackBaseReg = useFP ? R29 : RSP;
+    }
+  }
+  ~AArch64GenCfi() = default;
+
+ private:
+  void GenerateRegisterSaveDirective(BB &bb) override;
+  void GenerateRegisterRestoreDirective(BB &bb) override;
+
+  /* frame pointer(x29) is available as a general-purpose register if useFP is set as false */
+  AArch64reg stackBaseReg = RFP;
+};
+} /* namespace maplebe */
+#endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CFI_GENERATOR_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_cg.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cg.h
new file mode 100644
index 0000000000000000000000000000000000000000..6555183b509bb48768683bda9c56e1b62eb9ef53
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cg.h
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CG_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CG_H
+
+#include "cg.h"
+#include "aarch64_cgfunc.h"
+#include "aarch64_ssa.h"
+#include "aarch64_phi_elimination.h"
+#include "aarch64_prop.h"
+#include "aarch64_dce.h"
+#include "aarch64_live.h"
+#include "aarch64_reaching.h"
+#include "aarch64_args.h"
+#include "aarch64_alignment.h"
+#include "aarch64_validbit_opt.h"
+#include "aarch64_reg_coalesce.h"
+#include "aarch64_rce.h"
+#include "aarch64_tailcall.h"
+#include "aarch64_cfgo.h"
+#include "aarch64_rematerialize.h"
+#include "aarch64_pgo_gen.h"
+
+namespace maplebe {
+constexpr int64 kShortBRDistance = (8 * 1024);
+constexpr int64 kNegativeImmLowerLimit = -4096;
+constexpr int32 kIntRegTypeNum = 5;
+constexpr uint32 kAlignPseudoSize = 3;
+constexpr uint32 kInsnSize = 4;
+constexpr uint32 kAlignMovedFlag = 31;
+
+/* Supporting classes for GCTIB merging */
+class GCTIBKey {
+ public:
+  GCTIBKey(MapleAllocator &allocator, uint32 rcHeader, std::vector<uint64> &patternWords)
+      : header(rcHeader), bitMapWords(allocator.Adapter()) {
+    (void)bitMapWords.insert(bitMapWords.cbegin(), patternWords.cbegin(), patternWords.cend());
+  }
+
+  ~GCTIBKey() = default;
+
+  uint32 GetHeader() const {
+    return header;
+  }
+
+  const MapleVector<uint64> &GetBitmapWords() const {
+    return bitMapWords;
+  }
+
+ private:
+  uint32 header;
+  MapleVector<uint64> bitMapWords;
+};
+
+class Hasher {
+ public:
+  size_t operator()(const GCTIBKey *key) const {
+    CHECK_NULL_FATAL(key);
+    size_t hash = key->GetHeader();
+    return hash;
+  }
+};
+
+class EqualFn {
+ public:
+  bool operator()(const GCTIBKey *firstKey, const GCTIBKey *secondKey) const {
+    CHECK_NULL_FATAL(firstKey);
+    CHECK_NULL_FATAL(secondKey);
+    const MapleVector<uint64> &firstWords = firstKey->GetBitmapWords();
+    const MapleVector<uint64> &secondWords = secondKey->GetBitmapWords();
+
+    if ((firstKey->GetHeader() != secondKey->GetHeader()) || (firstWords.size() != secondWords.size())) {
+      return false;
+    }
+
+    for (size_t i = 0; i < firstWords.size(); ++i) {
+      if (firstWords[i] != secondWords[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+class GCTIBPattern {
+ public:
+  GCTIBPattern(GCTIBKey &patternKey, MemPool &mp) : name(&mp) {
+    key = &patternKey;
+    id = GetId();
+    name = GCTIB_PREFIX_STR + std::string("PTN_") + std::to_string(id);
+  }
+
+  ~GCTIBPattern() = default;
+
+  int GetId() const {
+    static int createNum = 0;
+    return createNum++;
+  }
+
+  std::string GetName() const {
+    ASSERT(!name.empty(), "null name check!");
+    return std::string(name.c_str());
+  }
+
+  void SetName(const std::string &ptnName) {
+    name = ptnName;
+  }
+
+ private:
+  int id = 0;
+  MapleString name;
+  GCTIBKey *key = nullptr;
+};
+
+/* sub Target info & implement */
+class AArch64CG : public CG {
+ public:
+  AArch64CG(MIRModule &mod, const CGOptions &opts, const std::vector<std::string> &nameVec,
+            const std::unordered_map<std::string, std::vector<std::string>> &patternMap)
+      : CG(mod, opts),
+        ehExclusiveNameVec(nameVec),
+        cyclePatternMap(patternMap),
+        keyPatternMap(allocator.Adapter()),
+        symbolPatternMap(allocator.Adapter()) {}
+
+  ~AArch64CG() override = default;
+
+  CGFunc *CreateCGFunc(MIRModule &mod, MIRFunction &mirFunc, BECommon &bec, MemPool &memPool,
+                       StackMemPool &stackMp, MapleAllocator &mallocator, uint32 funcId) override {
+    return memPool.New<AArch64CGFunc>(mod, *this, mirFunc, bec, memPool, stackMp, mallocator, funcId);
+  }
+
+  MemLayout *CreateMemLayout(MemPool &mp, BECommon &b, MIRFunction &f,
+                             MapleAllocator &mallocator) const override {
+    return mp.New<AArch64MemLayout>(b, f, mallocator);
+  }
+
+  RegisterInfo *CreateRegisterInfo(MemPool &mp, MapleAllocator &mallocator) const override {
+    return mp.New<AArch64RegInfo>(mallocator);
+  }
+
+  void EnrollTargetPhases(MaplePhaseManager *pm) const override;
+
+  const std::unordered_map<std::string, std::vector<std::string>> &GetCyclePatternMap() const {
+    return cyclePatternMap;
+  }
+
+  void GenerateObjectMaps(BECommon &beCommon) override;
+
+  bool IsExclusiveFunc(MIRFunction &mirFunc) override;
+
+  void FindOrCreateRepresentiveSym(std::vector<uint64> &bitmapWords, uint32 rcHeader, const std::string &name);
+
+  void CreateRefSymForGlobalPtn(GCTIBPattern &ptn) const;
+
+  Insn &BuildPhiInsn(RegOperand &defOpnd, Operand &listParam) override;
+
+  PhiOperand &CreatePhiOperand(MemPool &mp, MapleAllocator &mAllocator) override;
+
+  std::string FindGCTIBPatternName(const std::string &name) const override;
+
+  LiveAnalysis *CreateLiveAnalysis(MemPool &mp, CGFunc &f) const override {
+    return mp.New<AArch64LiveAnalysis>(f, mp);
+  }
+  ReachingDefinition *CreateReachingDefinition(MemPool &mp, CGFunc &f) const override {
+    return mp.New<AArch64ReachingDefinition>(f, mp);
+  }
+  MoveRegArgs *CreateMoveRegArgs(MemPool &mp, CGFunc &f) const override {
+    return mp.New<AArch64MoveRegArgs>(f);
+  }
+  AlignAnalysis *CreateAlignAnalysis(MemPool &mp, CGFunc &f) const override {
+    return mp.New<AArch64AlignAnalysis>(f, mp);
+  }
+  CGSSAInfo *CreateCGSSAInfo(MemPool &mp, CGFunc &f, DomAnalysis &da, MemPool &tmp) const override {
+    return mp.New<AArch64CGSSAInfo>(f, da, mp, tmp);
+  }
+  LiveIntervalAnalysis *CreateLLAnalysis(MemPool &mp, CGFunc &f) const override {
+    return mp.New<AArch64LiveIntervalAnalysis>(f, mp);
+  }
+  PhiEliminate *CreatePhiElimintor(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const override {
+    return mp.New<AArch64PhiEliminate>(f, ssaInfo, mp);
+  }
+  CGProp *CreateCGProp(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo, LiveIntervalAnalysis &ll) const override {
+    return mp.New<AArch64Prop>(mp, f, ssaInfo, ll);
+  }
+  CGDce *CreateCGDce(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const override {
+    return mp.New<AArch64Dce>(mp, f, ssaInfo);
+  }
+  ValidBitOpt *CreateValidBitOpt(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const override {
+    return mp.New<AArch64ValidBitOpt>(f, ssaInfo);
+  }
+  RedundantComputeElim *CreateRedundantCompElim(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const override {
+    return mp.New<AArch64RedundantComputeElim>(f, ssaInfo, mp);
+  }
+  TailCallOpt *CreateCGTailCallOpt(MemPool &mp, CGFunc &f) const override {
+    return mp.New<AArch64TailCallOpt>(mp, f);
+  }
+  CFGOptimizer *CreateCFGOptimizer(MemPool &mp, CGFunc &f) const override {
+    return mp.New<AArch64CFGOptimizer>(f, mp);
+  }
+  Rematerializer *CreateRematerializer(MemPool &mp) const override {
+    return mp.New<AArch64Rematerializer>();
+  }
+  /* Return the copy operand id of reg1 if it is an insn who just do copy from reg1 to reg2.
+ * i. mov reg2, reg1
+ * ii. add/sub reg2, reg1, 0/zero register
+ * iii. mul reg2, reg1, 1
+ */
+  bool IsEffectiveCopy(Insn &insn) const final;
+  bool IsTargetInsn(MOperator mOp) const final;
+  bool IsClinitInsn(MOperator mOp) const final;
+  void DumpTargetOperand(Operand &opnd, const OpndDesc &opndDesc) const final;
+  const InsnDesc &GetTargetMd(MOperator mOp) const final {
+    return kMd[mOp];
+  }
+  CGProfGen *CreateCGProfGen(MemPool &mp, CGFunc &f) const override {
+    return mp.New<AArch64ProfGen>(f, mp);
+  };
+
+  static const InsnDesc kMd[kMopLast];
+  enum : uint8 {
+    kR8List,
+    kR16List,
+    kR32List,
+    kR64List,
+    kV64List
+  };
+  static std::array<std::array<const std::string, kAllRegNum>, kIntRegTypeNum> intRegNames;
+  static std::array<const std::string, kAllRegNum> vectorRegNames;
+
+ private:
+  const std::vector<std::string> &ehExclusiveNameVec;
+  const std::unordered_map<std::string, std::vector<std::string>> &cyclePatternMap;
+  MapleUnorderedMap<GCTIBKey*, GCTIBPattern*, Hasher, EqualFn> keyPatternMap;
+  MapleUnorderedMap<std::string, GCTIBPattern*> symbolPatternMap;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CG_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_cgfunc.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cgfunc.h
new file mode 100644
index 0000000000000000000000000000000000000000..c62db13473bab7d9c01d2c0bd01a85d7b8cb64f1
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cgfunc.h
@@ -0,0 +1,969 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CGFUNC_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CGFUNC_H
+
+#include "cgfunc.h"
+#include "call_conv.h"
+#include "mpl_atomic.h"
+#include "aarch64_abi.h"
+#include "aarch64_operand.h"
+#include "aarch64_insn.h"
+#include "aarch64_memlayout.h"
+#include "aarch64_reg_info.h"
+#include "aarch64_optimize_common.h"
+#include "aarch64_call_conv.h"
+
+namespace maplebe {
+class LmbcArgInfo {
+ public:
+  explicit LmbcArgInfo(MapleAllocator &mallocator)
+      : lmbcCallArgs(mallocator.Adapter()),
+        lmbcCallArgTypes(mallocator.Adapter()),
+        lmbcCallArgOffsets(mallocator.Adapter()),
+        lmbcCallArgNumOfRegs(mallocator.Adapter()) {}
+  MapleVector<RegOperand*> lmbcCallArgs;
+  MapleVector<PrimType> lmbcCallArgTypes;
+  MapleVector<int32> lmbcCallArgOffsets;
+  MapleVector<int32> lmbcCallArgNumOfRegs; // # of regs needed to complete struct
+  int32 lmbcTotalStkUsed = -1;    // remove when explicit addr for large agg is available
+};
+
+class AArch64CGFunc : public CGFunc {
+ public:
+  AArch64CGFunc(MIRModule &mod, CG &c, MIRFunction &f, BECommon &b,
+      MemPool &memPool, StackMemPool &stackMp, MapleAllocator &mallocator, uint32 funcId)
+      : CGFunc(mod, c, f, b, memPool, stackMp, mallocator, funcId),
+        calleeSavedRegs(mallocator.Adapter()),
+        proEpilogSavedRegs(mallocator.Adapter()),
+        phyRegOperandTable(mallocator.Adapter()),
+        hashLabelOpndTable(mallocator.Adapter()),
+        hashOfstOpndTable(mallocator.Adapter()),
+        hashMemOpndTable(mallocator.Adapter()),
+        memOpndsRequiringOffsetAdjustment(mallocator.Adapter()),
+        memOpndsForStkPassedArguments(mallocator.Adapter()),
+        immOpndsRequiringOffsetAdjustment(mallocator.Adapter()),
+        immOpndsRequiringOffsetAdjustmentForRefloc(mallocator.Adapter()) {
+    uCatch.regNOCatch = 0;
+    SetUseFP(CGOptions::UseFramePointer() || HasVLAOrAlloca() || !f.GetModule()->IsCModule() ||
+             f.GetModule()->GetFlavor() == MIRFlavor::kFlavorLmbc);
+  }
+
+  ~AArch64CGFunc() override = default;
+
+  uint32 GetRefCount() const {
+    return refCount;
+  }
+
+  int32 GetBeginOffset() const {
+    return beginOffset;
+  }
+
+  MOperator PickMovBetweenRegs(PrimType destType, PrimType srcType) const;
+  MOperator PickMovInsn(const RegOperand &lhs, const RegOperand &rhs) const;
+
+  regno_t NewVRflag() override {
+    ASSERT(maxRegCount > kRFLAG, "CG internal error.");
+    constexpr uint8 size = 4;
+    if (maxRegCount <= kRFLAG) {
+      maxRegCount += (kRFLAG + kVRegisterNumber);
+      vRegTable.resize(maxRegCount);
+    }
+    new (&vRegTable[kRFLAG]) VirtualRegNode(kRegTyCc, size);
+    return kRFLAG;
+  }
+
+  MIRType *LmbcGetAggTyFromCallSite(StmtNode *stmt, std::vector<TyIdx> **parmList) const;
+  RegOperand &GetOrCreateResOperand(const BaseNode &parent, PrimType primType);
+  MIRStructType *GetLmbcStructArgType(BaseNode &stmt, size_t argNo);
+
+  void IntrinsifyGetAndAddInt(ListOperand &srcOpnds, PrimType pty);
+  void IntrinsifyGetAndSetInt(ListOperand &srcOpnds, PrimType pty);
+  void IntrinsifyCompareAndSwapInt(ListOperand &srcOpnds, PrimType pty);
+  void IntrinsifyStringIndexOf(ListOperand &srcOpnds, const MIRSymbol &funcSym);
+  void GenSaveMethodInfoCode(BB &bb) override;
+  void DetermineReturnTypeofCall() override;
+  void HandleRCCall(bool begin, const MIRSymbol *retRef = nullptr) override;
+  bool GenRetCleanup(const IntrinsiccallNode *cleanupNode, bool forEA = false);
+  void HandleRetCleanup(NaryStmtNode &retNode) override;
+  void MergeReturn() override;
+  RegOperand *ExtractNewMemBase(const MemOperand &memOpnd);
+  void SelectDassign(DassignNode &stmt, Operand &opnd0) override;
+  void SelectDassignoff(DassignoffNode &stmt, Operand &opnd0) override;
+  void SelectRegassign(RegassignNode &stmt, Operand &opnd0) override;
+  void SelectAbort() override;
+  void SelectAssertNull(UnaryStmtNode &stmt) override;
+  void SelectAsm(AsmNode &node) override;
+  MemOperand *GenLargeAggFormalMemOpnd(const MIRSymbol &sym, uint32 align, int64 offset,
+                                       bool needLow12 = false);
+  MemOperand *FixLargeMemOpnd(MemOperand &memOpnd, uint32 align);
+  MemOperand *FixLargeMemOpnd(MOperator mOp, MemOperand &memOpnd, uint32 dSize, uint32 opndIdx);
+  uint32 LmbcFindTotalStkUsed(std::vector<TyIdx> *paramList);
+  uint32 LmbcTotalRegsUsed();
+  bool LmbcSmallAggForRet(const BaseNode &bNode, Operand *src, int32 offset = 0, bool skip1 = false);
+  bool LmbcSmallAggForCall(BlkassignoffNode &bNode, const Operand *src, std::vector<TyIdx> **parmList);
+  bool GetNumReturnRegsForIassignfpoff(MIRType *rType, PrimType &primType, uint32 &numRegs);
+  void GenIassignfpoffStore(Operand &srcOpnd, int32 offset, uint32 byteSize, PrimType primType);
+  void SelectAggDassign(DassignNode &stmt) override;
+  void SelectIassign(IassignNode &stmt) override;
+  void SelectIassignoff(IassignoffNode &stmt) override;
+  void SelectIassignfpoff(IassignFPoffNode &stmt, Operand &opnd) override;
+  void SelectIassignspoff(PrimType pTy, int32 offset, Operand &opnd) override;
+  void SelectBlkassignoff(BlkassignoffNode &bNode, Operand *src) override;
+  void SelectAggIassign(IassignNode &stmt, Operand &addrOpnd) override;
+  void SelectReturnSendOfStructInRegs(BaseNode *x) override;
+  void SelectReturn(Operand *opnd0) override;
+  void SelectIgoto(Operand *opnd0) override;
+  void SelectCondGoto(CondGotoNode &stmt, Operand &opnd0, Operand &opnd1) override;
+  void SelectCondGoto(LabelOperand &targetOpnd, Opcode jmpOp, Opcode cmpOp, Operand &origOpnd0,
+                      Operand &origOpnd1, PrimType primType, bool signedCond);
+  void SelectCondSpecialCase1(CondGotoNode &stmt, BaseNode &expr) override;
+  void SelectCondSpecialCase2(const CondGotoNode &stmt, BaseNode &expr) override;
+  void SelectGoto(GotoNode &stmt) override;
+  void SelectCall(CallNode &callNode) override;
+  void SelectIcall(IcallNode &icallNode, Operand &srcOpnd) override;
+  void SelectIntrinCall(IntrinsiccallNode &intrinsicCallNode) override;
+  Operand *SelectIntrinsicOpWithOneParam(IntrinsicopNode &intrnNode, std::string name) override;
+  Operand *SelectIntrinsicOpWithNParams(IntrinsicopNode &intrnNode, PrimType retType, const std::string &name) override;
+  Operand *SelectCclz(IntrinsicopNode &intrnNode) override;
+  Operand *SelectCctz(IntrinsicopNode &intrnNode) override;
+  Operand *SelectCpopcount(IntrinsicopNode &intrnNode) override;
+  Operand *SelectCparity(IntrinsicopNode &intrnNode) override;
+  Operand *SelectCclrsb(IntrinsicopNode &intrnNode) override;
+  Operand *SelectCisaligned(IntrinsicopNode &intrnNode) override;
+  Operand *SelectCalignup(IntrinsicopNode &intrnNode) override;
+  Operand *SelectCaligndown(IntrinsicopNode &intrnNode) override;
+  Operand *SelectCSyncFetch(IntrinsicopNode &intrinopNode, Opcode op, bool fetchBefore) override;
+  Operand *SelectCSyncBoolCmpSwap(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCSyncValCmpSwap(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCSyncLockTestSet(IntrinsicopNode &intrinopNode, PrimType pty) override;
+  Operand *SelectCSyncSynchronize(IntrinsicopNode &intrinopNode) override;
+  AArch64isa::MemoryOrdering PickMemOrder(std::memory_order memOrder, bool isLdr) const;
+  Operand *SelectCAtomicLoadN(IntrinsicopNode &intrinsicopNode) override;
+  Operand *SelectCAtomicExchangeN(const IntrinsiccallNode &intrinsiccallNode) override;
+  Operand *SelectAtomicLoad(Operand &addrOpnd, PrimType primType, AArch64isa::MemoryOrdering memOrder);
+  Operand *SelectCAtomicFetch(IntrinsicopNode &intrinopNode, Opcode op, bool fetchBefore) override;
+  Operand *SelectCReturnAddress(IntrinsicopNode &intrinopNode) override;
+  void SelectCAtomicExchange(const IntrinsiccallNode &intrinsiccallNode) override;
+  void SelectMembar(StmtNode &membar) override;
+  void SelectComment(CommentNode &comment) override;
+
+  void HandleCatch() override;
+  Operand *SelectDread(const BaseNode &parent, AddrofNode &expr) override;
+  RegOperand *SelectRegread(RegreadNode &expr) override;
+
+  void SelectAddrof(Operand &result, StImmOperand &stImm, FieldID field = 0);
+  void SelectAddrof(Operand &result, MemOperand &memOpnd, FieldID field = 0);
+  Operand *SelectCSyncCmpSwap(const IntrinsicopNode &intrinopNode, bool retBool = false);
+  Operand *SelectAddrof(AddrofNode &expr, const BaseNode &parent, bool isAddrofoff) override;
+  Operand *SelectAddrofoff(AddrofoffNode &expr, const BaseNode &parent) override;
+  Operand &SelectAddrofFunc(AddroffuncNode &expr, const BaseNode &parent) override;
+  Operand &SelectAddrofLabel(AddroflabelNode &expr, const BaseNode &parent) override;
+
+  PrimType GetDestTypeFromAggSize(uint32 bitSize) const;
+
+  Operand *SelectIread(const BaseNode &parent, IreadNode &expr,
+                       int extraOffset = 0, PrimType finalBitFieldDestType = kPtyInvalid) override;
+  Operand *SelectIreadoff(const BaseNode &parent, IreadoffNode &ireadoff) override;
+  Operand *SelectIreadfpoff(const BaseNode &parent, IreadFPoffNode &ireadoff) override;
+  Operand *SelectIntConst(MIRIntConst &intConst) override;
+  Operand *HandleFmovImm(PrimType stype, int64 val, MIRConst &mirConst, const BaseNode &parent);
+  Operand *SelectFloatConst(MIRFloatConst &floatConst, const BaseNode &parent) override;
+  Operand *SelectDoubleConst(MIRDoubleConst &doubleConst, const BaseNode &parent) override;
+  Operand *SelectStrConst(MIRStrConst &strConst) override;
+  Operand *SelectStr16Const(MIRStr16Const &str16Const) override;
+
+  void SelectAdd(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectAdd(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand &SelectCGArrayElemAdd(BinaryNode &node, const BaseNode &parent) override;
+  void SelectMadd(Operand &resOpnd, Operand &opndM0, Operand &opndM1, Operand &opnd1, PrimType primType) override;
+  Operand *SelectMadd(BinaryNode &node, Operand &opndM0, Operand &opndM1, Operand &opnd1,
+                      const BaseNode &parent) override;
+  Operand *SelectRor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectShift(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectSub(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectSub(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectBand(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectBand(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectBior(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectBior(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectBxor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectBxor(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+
+  void SelectBxorShift(Operand &resOpnd, Operand *opnd0, Operand *opnd1, Operand &opnd2, PrimType primType);
+  Operand *SelectLand(BinaryNode &node, Operand &lhsOpnd, Operand &rhsOpnd, const BaseNode &parent) override;
+  Operand *SelectLor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent,
+                     bool parentIsBr = false) override;
+  Operand *SelectMin(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectMin(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectMax(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectMax(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  void SelectFMinFMax(Operand &resOpnd, Operand &opnd0, Operand &opnd1, bool is64Bits, bool isMin);
+  void SelectCmpOp(Operand &resOpnd, Operand &lhsOpnd, Operand &rhsOpnd,
+                   Opcode opcode, PrimType primType, const BaseNode &parent);
+
+  Operand *SelectCmpOp(CompareNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+
+  void SelectAArch64Cmp(Operand &o0, Operand &o1, bool isIntType, uint32 dsize);
+  void SelectTargetFPCmpQuiet(Operand &o0, Operand &o1, uint32 dsize);
+  void SelectAArch64CCmp(Operand &o, Operand &i, Operand &nzcv, CondOperand &cond, bool is64Bits);
+  void SelectAArch64CSet(Operand &res, CondOperand &cond, bool is64Bits);
+  void SelectAArch64CSINV(Operand &res, Operand &o0, Operand &o1, CondOperand &cond, bool is64Bits);
+  void SelectAArch64CSINC(Operand &res, Operand &o0, Operand &o1, CondOperand &cond, bool is64Bits);
+  void SelectShift(Operand &resOpnd, Operand &opnd0, Operand &opnd1, ShiftDirection direct, PrimType primType);
+  Operand *SelectMpy(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectMpy(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  /* method description contains method information which is metadata for reflection. */
+  MemOperand *AdjustMemOperandIfOffsetOutOfRange(MemOperand *memOpnd, regno_t vrNum, bool isDest, Insn &insn,
+                                                 AArch64reg regNum, bool &isOutOfRange);
+  void SelectAddAfterInsn(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType, bool isDest, Insn &insn);
+  bool IsImmediateOffsetOutOfRange(const MemOperand &memOpnd, uint32 bitLen);
+  bool IsOperandImmValid(MOperator mOp, Operand *o, uint32 opndIdx);
+  Operand *SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectDiv(Operand &resOpnd, Operand &origOpnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectDiv(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectAbsSub(Insn &lastInsn, const UnaryNode &node, Operand &newOpnd0);
+  Operand *SelectAbs(UnaryNode &node, Operand &opnd0) override;
+  Operand *SelectBnot(UnaryNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectBswap(IntrinsicopNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectExtractbits(ExtractbitsNode &node, Operand &srcOpnd, const BaseNode &parent) override;
+  Operand *SelectRegularBitFieldLoad(ExtractbitsNode &node, const BaseNode &parent) override;
+  Operand *SelectDepositBits(DepositbitsNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectLnot(UnaryNode &node, Operand &srcOpnd, const BaseNode &parent) override;
+  Operand *SelectNeg(UnaryNode &node, Operand &opnd0, const BaseNode &parent) override;
+  void SelectNeg(Operand &dest, Operand &srcOpnd, PrimType primType);
+  void SelectMvn(Operand &dest, Operand &src, PrimType primType);
+  Operand *SelectRecip(UnaryNode &node, Operand &src, const BaseNode &parent) override;
+  Operand *SelectSqrt(UnaryNode &node, Operand &src, const BaseNode &parent) override;
+  Operand *SelectCeil(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectFloor(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectRetype(TypeCvtNode &node, Operand &opnd0) override;
+  Operand *SelectRound(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectCvt(const BaseNode &parent, TypeCvtNode &node, Operand &opnd0) override;
+  Operand *SelectTrunc(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectSelect(TernaryNode &node, Operand &opnd0, Operand &trueOpnd, Operand &falseOpnd,
+                        const BaseNode &parent, bool hasCompare = false) override;
+  Operand *SelectMalloc(UnaryNode &node, Operand &opnd0) override;
+  Operand *SelectAlloca(UnaryNode &node, Operand &opnd0) override;
+  Operand *SelectGCMalloc(GCMallocNode &node) override;
+  Operand *SelectJarrayMalloc(JarrayMallocNode &node, Operand &opnd0) override;
+  void SelectSelect(Operand &resOpnd, Operand &condOpnd, Operand &trueOpnd, Operand &falseOpnd, PrimType dtype,
+                    PrimType ctype, bool hasCompare = false, ConditionCode cc = CC_NE);
+  void SelectAArch64Select(Operand &dest, Operand &opnd0, Operand &opnd1, CondOperand &cond, bool isIntType,
+                           uint32 is64bits);
+  void SelectRangeGoto(RangeGotoNode &rangeGotoNode, Operand &srcOpnd) override;
+  Operand *SelectLazyLoad(Operand &opnd0, PrimType primType) override;
+  Operand *SelectLazyLoadStatic(MIRSymbol &st, int64 offset, PrimType primType) override;
+  Operand *SelectLoadArrayClassCache(MIRSymbol &st, int64 offset, PrimType primType) override;
+  RegOperand &SelectCopy(Operand &src, PrimType stype, PrimType dtype) override;
+  void SelectCopy(Operand &dest, PrimType dtype, Operand &src, PrimType stype);
+  void SelectCopyImm(Operand &dest, PrimType dType, ImmOperand &src, PrimType sType);
+  void SelectCopyImm(Operand &dest, ImmOperand &src, PrimType dtype);
+  void SelectLibCall(const std::string &funcName, std::vector<Operand*> &opndVec, PrimType primType,
+                     PrimType retPrimType, bool is2ndRet = false);
+  void SelectLibCallNArg(const std::string &funcName, std::vector<Operand*> &opndVec, std::vector<PrimType> pt,
+                         PrimType retPrimType, bool is2ndRet);
+  bool IsRegRematCand(const RegOperand &reg) const;
+  void ClearRegRematInfo(const RegOperand &reg) const;
+  bool IsRegSameRematInfo(const RegOperand &regDest, const RegOperand &regSrc) const;
+  void ReplaceOpndInInsn(RegOperand &regDest, RegOperand &regSrc, Insn &insn, regno_t destNO) override;
+  void CleanupDeadMov(bool dumpInfo) override;
+  void GetRealCallerSaveRegs(const Insn &insn, std::set<regno_t> &realSaveRegs) override;
+  Operand &GetTargetRetOperand(PrimType primType, int32 sReg) override;
+  Operand &GetOrCreateRflag() override;
+  const Operand *GetRflag() const override;
+  RegOperand &GetOrCreatevaryreg();
+  RegOperand &CreateRegisterOperandOfType(PrimType primType);
+  RegOperand &CreateRegisterOperandOfType(RegType regType, uint32 byteLen);
+  RegOperand &CreateRflagOperand();
+  RegOperand &GetOrCreateSpecialRegisterOperand(PregIdx sregIdx, PrimType primType);
+  MemOperand *GetOrCreatSpillMem(regno_t vrNum) override;
+  void FreeSpillRegMem(regno_t vrNum) override;
+  RegOperand &GetOrCreatePhysicalRegisterOperand(AArch64reg regNO, uint32 size, RegType kind, uint32 flag = 0);
+  RegOperand &GetOrCreatePhysicalRegisterOperand(std::string &asmAttr);
+  RegOperand *CreateVirtualRegisterOperand(regno_t vRegNO, uint32 size, RegType kind, uint32 flg = 0) const;
+  RegOperand &CreateVirtualRegisterOperand(regno_t vRegNO) override;
+  RegOperand &GetOrCreateVirtualRegisterOperand(regno_t vRegNO) override;
+  RegOperand &GetOrCreateVirtualRegisterOperand(RegOperand &regOpnd) override;
+  const LabelOperand *GetLabelOperand(LabelIdx labIdx) const override;
+  LabelOperand &GetOrCreateLabelOperand(LabelIdx labIdx) override;
+  LabelOperand &GetOrCreateLabelOperand(BB &bb) override;
+  uint32 GetAggCopySize(uint32 offset1, uint32 offset2, uint32 alignment) const;
+
+  RegOperand *SelectVectorAddLong(PrimType rType, Operand *o1, Operand *o2, PrimType otyp, bool isLow) override;
+  RegOperand *SelectVectorAddWiden(Operand *o1, PrimType otyp1, Operand *o2, PrimType otyp2, bool isLow) override;
+  RegOperand *SelectVectorAbs(PrimType rType, Operand *o1) override;
+  RegOperand *SelectVectorBinOp(PrimType rType, Operand *o1, PrimType oty1, Operand *o2,
+                                PrimType oty2, Opcode opc) override;
+  RegOperand *SelectVectorBitwiseOp(PrimType rType, Operand *o1, PrimType oty1, Operand *o2,
+                                    PrimType oty2, Opcode opc) override;
+  RegOperand *SelectVectorCompare(Operand *o1, PrimType oty1, Operand *o2, PrimType oty2, Opcode opc) override;
+  RegOperand *SelectVectorCompareZero(Operand *o1, PrimType oty1, Operand *o2, Opcode opc) override;
+  RegOperand *SelectOneElementVectorCopy(Operand *src, PrimType sType);
+  RegOperand *SelectVectorImmMov(PrimType rType, Operand *src, PrimType sType);
+  RegOperand *SelectVectorRegMov(PrimType rType, Operand *src, PrimType sType);
+  RegOperand *SelectVectorFromScalar(PrimType rType, Operand *src, PrimType sType) override;
+  RegOperand *SelectVectorGetElement(PrimType rType, Operand *src, PrimType sType, int32 lane) override;
+  RegOperand *SelectVectorDup(PrimType rType, Operand *src, bool getLow) override;
+  RegOperand *SelectVectorAbsSubL(PrimType rType, Operand *o1, Operand *o2, PrimType oTy, bool isLow) override;
+  RegOperand *SelectVectorMadd(Operand *o1, PrimType oTyp1, Operand *o2, PrimType oTyp2,
+                               Operand *o3, PrimType oTyp3) override;
+  RegOperand *SelectVectorMerge(PrimType rType, Operand *o1, Operand *o2, int32 index) override;
+  RegOperand *SelectVectorMull(PrimType rType, Operand *o1, PrimType oTyp1,
+      Operand *o2, PrimType oTyp2, bool isLow) override;
+  RegOperand *SelectVectorNarrow(PrimType rType, Operand *o1, PrimType otyp) override;
+  RegOperand *SelectVectorNarrow2(PrimType rType, Operand *o1, PrimType oty1, Operand *o2, PrimType oty2) override;
+  RegOperand *SelectVectorNeg(PrimType rType, Operand *o1) override;
+  RegOperand *SelectVectorNot(PrimType rType, Operand *o1) override;
+  RegOperand *SelectVectorPairwiseAdalp(Operand *src1, PrimType sty1, Operand *src2, PrimType sty2) override;
+  RegOperand *SelectVectorPairwiseAdd(PrimType rType, Operand *src, PrimType sType) override;
+  RegOperand *SelectVectorReverse(PrimType rType, Operand *src, PrimType sType, uint32 size) override;
+  RegOperand *SelectVectorSetElement(Operand *eOpnd, PrimType eType, Operand *vOpnd,
+                                     PrimType vType, int32 lane) override;
+  RegOperand *SelectVectorSelect(Operand &cond, PrimType rType, Operand &o0, Operand &o1);
+  RegOperand *SelectVectorShift(PrimType rType, Operand *o1, PrimType oty1, Operand *o2,
+                                PrimType oty2, Opcode opc) override;
+  RegOperand *SelectVectorShiftImm(PrimType rType, Operand *o1, Operand *imm, int32 sVal, Opcode opc) override;
+  RegOperand *SelectVectorShiftRNarrow(PrimType rType, Operand *o1, PrimType oType, Operand *o2, bool isLow) override;
+  RegOperand *SelectVectorSubWiden(PrimType resType, Operand *o1, PrimType otyp1,
+                                   Operand *o2, PrimType otyp2, bool isLow, bool isWide) override;
+  RegOperand *SelectVectorSum(PrimType rType, Operand *o1, PrimType oType) override;
+  RegOperand *SelectVectorTableLookup(PrimType rType, Operand *o1, Operand *o2) override;
+  RegOperand *SelectVectorWiden(PrimType rType, Operand *o1, PrimType otyp, bool isLow) override;
+  RegOperand *SelectVectorMovNarrow(PrimType rType, Operand *opnd, PrimType oType) override;
+
+  void SelectVectorCvt(Operand *res, PrimType rType, Operand *o1, PrimType oType);
+  void SelectVectorZip(PrimType rType, Operand *o1, Operand *o2);
+  void SelectStackSave();
+  void SelectStackRestore(const IntrinsiccallNode &intrnNode);
+
+  void PrepareVectorOperands(Operand **o1, PrimType &oty1, Operand **o2, PrimType &oty2);
+  RegOperand *AdjustOneElementVectorOperand(PrimType oType, RegOperand *opnd);
+  bool DistanceCheck(const BB &bb, LabelIdx targLabIdx, uint32 targId) const;
+
+  PrimType FilterOneElementVectorType(PrimType origTyp) const {
+    PrimType nType = origTyp;
+    if (origTyp == PTY_i64 || origTyp == PTY_u64) {
+      nType = PTY_f64;
+    }
+    return nType;
+  }
+
+  ImmOperand &CreateImmOperand(PrimType ptyp, int64 val) override {
+    if (ptyp == PTY_f32 || ptyp == PTY_f64) {
+      ASSERT(val == 0, "val must be 0!");
+      return CreateImmOperand(Operand::kOpdFPImmediate, 0, static_cast<uint8>(GetPrimTypeBitSize(ptyp)), false);
+    }
+    return CreateImmOperand(val, GetPrimTypeBitSize(ptyp), IsSignedInteger(ptyp));
+  }
+
+
+  const Operand *GetFloatRflag() const override {
+    return nullptr;
+  }
+  /* create an integer immediate operand */
+  ImmOperand &CreateImmOperand(int64 val, uint32 size, bool isSigned, VaryType varyType = kNotVary,
+                               bool isFmov = false) const {
+    return *memPool->New<ImmOperand>(val, size, isSigned, varyType, isFmov);
+  }
+
+  ImmOperand &CreateImmOperand(Operand::OperandType type, int64 val, uint32 size, bool isSigned) {
+    return *memPool->New<ImmOperand>(type, val, size, isSigned);
+  }
+
+  ListOperand *CreateListOpnd(MapleAllocator &allocator) {
+    return memPool->New<ListOperand>(allocator);
+  }
+
+  OfstOperand &GetOrCreateOfstOpnd(uint64 offset, uint32 size);
+
+  OfstOperand &CreateOfstOpnd(uint64 offset, uint32 size) const {
+    return *memPool->New<OfstOperand>(offset, size);
+  }
+
+  OfstOperand &CreateOfstOpnd(const MIRSymbol &mirSymbol, int32 relocs) const {
+    return *memPool->New<OfstOperand>(mirSymbol, 0, relocs);
+  }
+
+  OfstOperand &CreateOfstOpnd(const MIRSymbol &mirSymbol, int64 offset, int32 relocs) const {
+    return *memPool->New<OfstOperand>(mirSymbol, 0, offset, relocs);
+  }
+
+  StImmOperand &CreateStImmOperand(const MIRSymbol &mirSymbol, int64 offset, int32 relocs) const {
+    return *memPool->New<StImmOperand>(mirSymbol, offset, relocs);
+  }
+
+  RegOperand &GetOrCreateFramePointerRegOperand() override {
+    return GetOrCreateStackBaseRegOperand();
+  }
+
+  RegOperand &GetOrCreateStackBaseRegOperand() override {
+    AArch64reg reg;
+    if (GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc) {
+      reg = RSP;
+    } else {
+      reg = RFP;
+    }
+    return GetOrCreatePhysicalRegisterOperand(reg, GetPointerSize() * kBitsPerByte, kRegTyInt);
+  }
+
+  RegOperand &GenStructParamIndex(RegOperand &base, const BaseNode &indexExpr, int shift, PrimType baseType);
+  void SelectAddrofAfterRa(Operand &result, StImmOperand &stImm, std::vector<Insn *>& rematInsns);
+  MemOperand &GetOrCreateMemOpndAfterRa(const MIRSymbol &symbol, int32 offset, uint32 size,
+      bool needLow12, RegOperand *regOp, std::vector<Insn *>& rematInsns);
+
+  MemOperand &GetOrCreateMemOpnd(const MIRSymbol &symbol, int64 offset, uint32 size, bool forLocalRef = false,
+                                 bool needLow12 = false, RegOperand *regOp = nullptr);
+
+  MemOperand &HashMemOpnd(MemOperand &tMemOpnd);
+
+  MemOperand &GetOrCreateMemOpnd(MemOperand::AArch64AddressingMode mode, uint32 size, RegOperand *base,
+                                 RegOperand *index, ImmOperand *offset, const MIRSymbol *st);
+
+  MemOperand &GetOrCreateMemOpnd(MemOperand::AArch64AddressingMode mode, uint32 size, RegOperand *base,
+                                 RegOperand *index, int32 shift, bool isSigned = false);
+
+  MemOperand &GetOrCreateMemOpnd(MemOperand &oldMem);
+
+  MemOperand &CreateMemOpnd(AArch64reg reg, int64 offset, uint32 size) {
+    RegOperand &baseOpnd = GetOrCreatePhysicalRegisterOperand(reg, GetPointerSize() * kBitsPerByte, kRegTyInt);
+    return CreateMemOpnd(baseOpnd, offset, size);
+  }
+
+  MemOperand &CreateMemOpnd(RegOperand &baseOpnd, int64 offset, uint32 size);
+
+  MemOperand &CreateMemOpnd(RegOperand &baseOpnd, int64 offset, uint32 size, const MIRSymbol &sym) const;
+
+  MemOperand &CreateMemOpnd(PrimType ptype, const BaseNode &parent, BaseNode &addrExpr, int64 offset = 0,
+                            AArch64isa::MemoryOrdering memOrd = AArch64isa::kMoNone);
+
+  MemOperand *CreateMemOpndOrNull(PrimType ptype, const BaseNode &parent, BaseNode &addrExpr, int64 offset = 0,
+                                  AArch64isa::MemoryOrdering memOrd = AArch64isa::kMoNone);
+
+  CondOperand &GetCondOperand(ConditionCode op) const {
+    return ccOperands[op];
+  }
+
+  BitShiftOperand *GetLogicalShiftLeftOperand(uint32 shiftAmount, bool is64bits) const;
+
+  BitShiftOperand &CreateBitShiftOperand(BitShiftOperand::ShiftOp op, uint32 amount, int32 bitLen) const {
+    return *memPool->New<BitShiftOperand>(op, amount, bitLen);
+  }
+
+  ExtendShiftOperand &CreateExtendShiftOperand(ExtendShiftOperand::ExtendOp op, uint32 amount, int32 bitLen) const {
+    return *memPool->New<ExtendShiftOperand>(op, amount, bitLen);
+  }
+
+  void SplitMovImmOpndInstruction(int64 immVal, RegOperand &destReg, Insn *curInsn = nullptr);
+
+  Operand &GetOrCreateFuncNameOpnd(const MIRSymbol &symbol) const;
+  void GenerateYieldpoint(BB &bb) override;
+  Operand &ProcessReturnReg(PrimType primType, int32 sReg) override;
+  void GenerateCleanupCode(BB &bb) override;
+  bool NeedCleanup() override;
+  void GenerateCleanupCodeForExtEpilog(BB &bb) override;
+  uint32 FloatParamRegRequired(MIRStructType *structType, uint32 &fpSize) override;
+  void AssignLmbcFormalParams() override;
+  void LmbcGenSaveSpForAlloca() override;
+  MemOperand *GenLmbcFpMemOperand(int32 offset, uint32 byteSize, AArch64reg baseRegno = RFP);
+  RegOperand *GenLmbcParamLoad(int32 offset, uint32 byteSize, RegType regType,
+                               PrimType primType, AArch64reg baseRegno = RFP);
+  RegOperand *LmbcStructReturnLoad(int32 offset);
+  RegOperand *GetBaseReg(const SymbolAlloc &symAlloc) override;
+  int32 GetBaseOffset(const SymbolAlloc &symbolAlloc) override;
+
+  Operand &CreateCommentOperand(const std::string &s) const {
+    return *memPool->New<CommentOperand>(s, *memPool);
+  }
+
+  Operand &CreateCommentOperand(const MapleString &s) const {
+    return *memPool->New<CommentOperand>(s.c_str(), *memPool);
+  }
+
+  Operand &CreateStringOperand(const std::string &s) const {
+    return *memPool->New<StringOperand>(s, *memPool);
+  }
+
+  Operand &CreateStringOperand(const MapleString &s) const {
+    return *memPool->New<StringOperand>(s.c_str(), *memPool);
+  }
+
+  void AddtoCalleeSaved(regno_t reg) override {
+    if (!UseFP() && reg == R29) {
+      reg = RFP;
+    }
+    if (find(calleeSavedRegs.begin(), calleeSavedRegs.end(), reg) != calleeSavedRegs.end()) {
+      return;
+    }
+    (void)calleeSavedRegs.emplace_back(static_cast<AArch64reg>(reg));
+    ASSERT((AArch64isa::IsGPRegister(static_cast<AArch64reg>(reg)) ||
+            AArch64isa::IsFPSIMDRegister(static_cast<AArch64reg>(reg))),
+            "Int or FP registers are expected");
+    if (AArch64isa::IsGPRegister(static_cast<AArch64reg>(reg))) {
+      ++numIntregToCalleeSave;
+    } else {
+      ++numFpregToCalleeSave;
+    }
+  }
+
+  uint32 SizeOfCalleeSaved() const {
+    /* npairs = num / 2 + num % 2 */
+    uint32 nPairs = (numIntregToCalleeSave >> 1) + (numIntregToCalleeSave & 0x1);
+    nPairs += (numFpregToCalleeSave >> 1) + (numFpregToCalleeSave & 0x1);
+    return (nPairs * (kIntregBytelen << 1));
+  }
+
+  void DBGFixCallFrameLocationOffsets() override;
+
+  void NoteFPLRAddedToCalleeSavedList() {
+    fplrAddedToCalleeSaved = true;
+  }
+
+  bool IsFPLRAddedToCalleeSavedList() const {
+    return fplrAddedToCalleeSaved;
+  }
+
+  bool IsIntrnCallForC() const {
+    return isIntrnCallForC;
+  }
+
+  bool UsedStpSubPairForCallFrameAllocation() const {
+    return usedStpSubPairToAllocateCallFrame;
+  }
+  void SetUsedStpSubPairForCallFrameAllocation(bool val) {
+    usedStpSubPairToAllocateCallFrame = val;
+  }
+
+  const MapleVector<AArch64reg> &GetCalleeSavedRegs() const {
+    return calleeSavedRegs;
+  }
+
+  Insn *GetYieldPointInsn() {
+    return yieldPointInsn;
+  }
+
+  const Insn *GetYieldPointInsn() const {
+    return yieldPointInsn;
+  }
+
+  IntrinsiccallNode *GetCleanEANode() {
+    return cleanEANode;
+  }
+
+  MemOperand &CreateStkTopOpnd(uint32 offset, uint32 size);
+  MemOperand *CreateStackMemOpnd(regno_t preg, int32 offset, uint32 size) const;
+  MemOperand *CreateMemOperand(MemOperand::AArch64AddressingMode mode, uint32 size,
+      RegOperand &base, RegOperand *index, ImmOperand *offset, const MIRSymbol *symbol) const;
+  MemOperand *CreateMemOperand(MemOperand::AArch64AddressingMode mode, uint32 size,
+      RegOperand &base, RegOperand &index, ImmOperand *offset, const MIRSymbol &symbol, bool noExtend) const;
+  MemOperand *CreateMemOperand(MemOperand::AArch64AddressingMode mode, uint32 dSize,
+      RegOperand &base, RegOperand &indexOpnd, uint32 shift, bool isSigned = false) const;
+  MemOperand *CreateMemOperand(MemOperand::AArch64AddressingMode mode, uint32 dSize, const MIRSymbol &sym) const;
+
+  /* if offset < 0, allocation; otherwise, deallocation */
+  MemOperand &CreateCallFrameOperand(int32 offset, uint32 size) const;
+
+  void AppendCall(const MIRSymbol &funcSymbol);
+  Insn &AppendCall(const MIRSymbol &sym, ListOperand &srcOpnds);
+
+  static constexpr uint32 kDwarfFpRegBegin = 64;
+  static constexpr int32 kBitLenOfShift64Bits = 6; /* for 64 bits register, shift amount is 0~63, use 6 bits to store */
+  static constexpr int32 kBitLenOfShift32Bits = 5; /* for 32 bits register, shift amount is 0~31, use 5 bits to store */
+  static constexpr int32 kHighestBitOf64Bits = 63; /* 63 is highest bit of a 64 bits number */
+  static constexpr int32 kHighestBitOf32Bits = 31; /* 31 is highest bit of a 32 bits number */
+  static constexpr int32 k16ValidBit = 16;
+
+  /* CFI directives related stuffs */
+  Operand &CreateCfiRegOperand(uint32 reg, uint32 size) override {
+    /*
+     * DWARF for ARM Architecture (ARM IHI 0040B) 3.1 Table 1
+     * Having kRinvalid=0 (see arm32_isa.h) means
+     * each register gets assigned an id number one greater than
+     * its physical number
+     */
+    if (reg < V0) {
+      return *memPool->New<cfi::RegOperand>((reg - R0), size);
+    } else {
+      return *memPool->New<cfi::RegOperand>((reg - V0) + kDwarfFpRegBegin, size);
+    }
+  }
+
+  void SetCatchRegno(regno_t regNO) {
+    uCatch.regNOCatch = regNO;
+  }
+
+  regno_t GetCatchRegno() const {
+    return uCatch.regNOCatch;
+  }
+
+  void SetCatchOpnd(Operand &opnd) {
+    uCatch.opndCatch = &opnd;
+  }
+
+  AArch64reg GetReturnRegisterNumber();
+
+  MOperator PickStInsn(uint32 bitSize, PrimType primType,
+                       AArch64isa::MemoryOrdering memOrd = AArch64isa::kMoNone) const;
+  MOperator PickLdInsn(uint32 bitSize, PrimType primType,
+                       AArch64isa::MemoryOrdering memOrd = AArch64isa::kMoNone) const;
+  MOperator PickExtInsn(PrimType dtype, PrimType stype) const;
+
+  bool CheckIfSplitOffsetWithAdd(const MemOperand &memOpnd, uint32 bitLen) const;
+  RegOperand *GetBaseRegForSplit(uint32 baseRegNum);
+
+  MemOperand &ConstraintOffsetToSafeRegion(uint32 bitLen, const MemOperand &memOpnd, const MIRSymbol *symbol);
+  MemOperand &SplitOffsetWithAddInstruction(const MemOperand &memOpnd, uint32 bitLen,
+                                            uint32 baseRegNum = AArch64reg::kRinvalid, bool isDest = false,
+                                            Insn *insn = nullptr, bool forPair = false);
+  ImmOperand &SplitAndGetRemained(const MemOperand &memOpnd, uint32 bitLen, int64 ofstVal, bool forPair = false);
+  MemOperand &CreateReplacementMemOperand(uint32 bitLen, RegOperand &baseReg, int64 offset);
+
+  bool OpndHasStackLoadStore(Insn &insn, Operand &opnd);
+  bool HasStackLoadStore();
+
+  MemOperand &LoadStructCopyBase(const MIRSymbol &symbol, int64 offset, int dataSize);
+
+  int32 GetSplitBaseOffset() const {
+    return splitStpldpBaseOffset;
+  }
+  void SetSplitBaseOffset(int32 val) {
+    splitStpldpBaseOffset = val;
+  }
+
+  Insn &CreateCfiRestoreInsn(uint32 reg, uint32 size) {
+    return GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_restore).AddOpndChain(CreateCfiRegOperand(reg, size));
+  }
+
+  Insn &CreateCfiOffsetInsn(uint32 reg, int64 val, uint32 size) {
+    return GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_offset).
+                                          AddOpndChain(CreateCfiRegOperand(reg, size)).
+                                          AddOpndChain(CreateCfiImmOperand(val, size));
+  }
+  Insn &CreateCfiDefCfaInsn(uint32 reg, int64 val, uint32 size) {
+    return GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_def_cfa).
+                                          AddOpndChain(CreateCfiRegOperand(reg, size)).
+                                          AddOpndChain(CreateCfiImmOperand(val, size));
+  }
+
+  InsnVisitor *NewInsnModifier() override {
+    return memPool->New<AArch64InsnVisitor>(*this);
+  }
+
+  RegType GetRegisterType(regno_t reg) const override;
+
+  uint32 MaxCondBranchDistance() override {
+    return AArch64Abi::kMaxInstrForCondBr;
+  }
+
+  void InsertJumpPad(Insn *insn) override;
+
+  MapleVector<AArch64reg> &GetProEpilogSavedRegs() {
+    return proEpilogSavedRegs;
+  }
+
+  uint32 GetDefaultAlignPow() const {
+    return alignPow;
+  }
+
+  LmbcArgInfo *GetLmbcArgInfo() {
+    return lmbcArgInfo;
+  }
+
+  void SetLmbcArgInfo(LmbcArgInfo *p) {
+    lmbcArgInfo = p;
+  }
+
+  void SetLmbcArgInfo(RegOperand *reg, PrimType pTy, int32 ofst, int32 regs) const {
+    (void)GetLmbcCallArgs().emplace_back(reg);
+    (void)GetLmbcCallArgTypes().emplace_back(pTy);
+    (void)GetLmbcCallArgOffsets().emplace_back(ofst);
+    (void)GetLmbcCallArgNumOfRegs().emplace_back(regs);
+  }
+
+  void ResetLmbcArgInfo() const {
+    GetLmbcCallArgs().clear();
+    GetLmbcCallArgTypes().clear();
+    GetLmbcCallArgOffsets().clear();
+    GetLmbcCallArgNumOfRegs().clear();
+  }
+
+  MapleVector<RegOperand*> &GetLmbcCallArgs() const {
+    return lmbcArgInfo->lmbcCallArgs;
+  }
+
+  MapleVector<PrimType> &GetLmbcCallArgTypes() const {
+    return lmbcArgInfo->lmbcCallArgTypes;
+  }
+
+  MapleVector<int32> &GetLmbcCallArgOffsets() const {
+    return lmbcArgInfo->lmbcCallArgOffsets;
+  }
+
+  MapleVector<int32> &GetLmbcCallArgNumOfRegs() const {
+    return lmbcArgInfo->lmbcCallArgNumOfRegs;
+  }
+
+  int32 GetLmbcTotalStkUsed() const {
+    return lmbcArgInfo->lmbcTotalStkUsed;
+  }
+
+  void SetLmbcTotalStkUsed(int32 offset) const {
+    lmbcArgInfo->lmbcTotalStkUsed = offset;
+  }
+
+  void SetLmbcCallReturnType(MIRType *ty) {
+    lmbcCallReturnType = ty;
+  }
+
+  MIRType *GetLmbcCallReturnType() {
+    return lmbcCallReturnType;
+  }
+
+  bool IsSPOrFP(const RegOperand &opnd) const override;
+  bool IsReturnReg(const RegOperand &opnd) const override;
+  bool IsSaveReg(const RegOperand &reg, MIRType &mirType, BECommon &cgBeCommon) const override;
+
+  RegOperand &GetZeroOpnd(uint32 bitLen) override;
+
+ private:
+  enum RelationOperator : uint8 {
+    kAND,
+    kIOR,
+    kEOR
+  };
+
+  enum RelationOperatorOpndPattern : uint8 {
+    kRegReg,
+    kRegImm
+  };
+
+  enum RoundType : uint8 {
+    kCeil,
+    kFloor,
+    kRound
+  };
+
+  static constexpr int32 kMaxMovkLslEntries = 8;
+  using MovkLslOperandArray = std::array<BitShiftOperand, kMaxMovkLslEntries>;
+
+  MapleVector<AArch64reg> calleeSavedRegs;
+  MapleVector<AArch64reg> proEpilogSavedRegs;
+  uint32 refCount = 0;  /* Ref count number. 0 if function don't have "bl MCC_InitializeLocalStackRef" */
+  int32 beginOffset = 0;        /* Begin offset based x29. */
+  Insn *yieldPointInsn = nullptr;   /* The insn of yield point at the entry of the func. */
+  IntrinsiccallNode *cleanEANode = nullptr;
+
+  MapleUnorderedMap<phyRegIdx, RegOperand*> phyRegOperandTable;  /* machine register operand table */
+  MapleUnorderedMap<LabelIdx, LabelOperand*> hashLabelOpndTable;
+  MapleUnorderedMap<OfstRegIdx, OfstOperand*> hashOfstOpndTable;
+  MapleUnorderedMap<MemOperand, MemOperand*> hashMemOpndTable;
+  /*
+   * Local variables, formal parameters that are passed via registers
+   * need offset adjustment after callee-saved registers are known.
+   */
+  MapleUnorderedMap<StIdx, MemOperand*> memOpndsRequiringOffsetAdjustment;
+  MapleUnorderedMap<StIdx, MemOperand*> memOpndsForStkPassedArguments;
+  MapleUnorderedMap<AArch64SymbolAlloc*, ImmOperand*> immOpndsRequiringOffsetAdjustment;
+  MapleUnorderedMap<AArch64SymbolAlloc*, ImmOperand*> immOpndsRequiringOffsetAdjustmentForRefloc;
+  union {
+    regno_t regNOCatch;  /* For O2. */
+    Operand *opndCatch;  /* For O0-O1. */
+  } uCatch;
+  enum FpParamState {
+    kNotFp,
+    kFp32Bit,
+    kFp64Bit,
+    kStateUnknown,
+  };
+  Operand *rcc = nullptr;
+  RegOperand *vary = nullptr;
+  RegOperand *fsp = nullptr;  /* used to point the address of local variables and formal parameters */
+
+  static CondOperand ccOperands[kCcLast];
+  static MovkLslOperandArray movkLslOperands;
+  uint32 numIntregToCalleeSave = 0;
+  uint32 numFpregToCalleeSave = 0;
+  bool fplrAddedToCalleeSaved = false;
+  bool isIntrnCallForC = false;
+  bool usedStpSubPairToAllocateCallFrame = false;
+  int32 splitStpldpBaseOffset = 0;
+  regno_t methodHandleVreg = -1;
+  uint32 alignPow = 5;  /* function align pow defaults to 5   i.e. 2^5 */
+  LmbcArgInfo *lmbcArgInfo = nullptr;
+  MIRType *lmbcCallReturnType = nullptr;
+
+  void SelectLoadAcquire(Operand &dest, PrimType dtype, Operand &src, PrimType stype,
+                         AArch64isa::MemoryOrdering memOrd, bool isDirect);
+  void SelectStoreRelease(Operand &dest, PrimType dtype, Operand &src, PrimType stype,
+                          AArch64isa::MemoryOrdering memOrd, bool isDirect);
+  MOperator PickJmpInsn(Opcode brOp, Opcode cmpOp, bool isFloat, bool isSigned) const;
+  bool IsFrameReg(const RegOperand &opnd) const override;
+
+  PrimType GetOperandTy(bool isIntty, uint32 dsize, bool isSigned) const {
+    ASSERT(!isSigned || isIntty, "");
+    return (isIntty ? ((dsize == k64BitSize) ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32))
+                    : ((dsize == k64BitSize) ? PTY_f64 : PTY_f32));
+  }
+
+  RegOperand &LoadIntoRegister(Operand &o, bool isIntty, uint32 dsize, bool asSigned = false) {
+    PrimType pTy;
+    if (o.GetKind() == Operand::kOpdRegister && static_cast<RegOperand&>(o).GetRegisterType() == kRegTyFloat) {
+      // f128 is a vector placeholder, no use for now
+      pTy = dsize == k32BitSize ? PTY_f32 : (dsize == k64BitSize ? PTY_f64 : PTY_f128);
+    } else {
+      pTy = GetOperandTy(isIntty, dsize, asSigned);
+    }
+    return LoadIntoRegister(o, pTy);
+  }
+
+  RegOperand &LoadIntoRegister(Operand &o, PrimType oty) {
+    return (o.IsRegister() ? static_cast<RegOperand&>(o) : SelectCopy(o, oty, oty));
+  }
+
+  RegOperand &LoadIntoRegister(Operand &o, PrimType dty, PrimType sty) {
+    return (o.IsRegister() ? static_cast<RegOperand&>(o) : SelectCopy(o, sty, dty));
+  }
+
+  void CreateCallStructParamPassByStack(int32 symSize, const MIRSymbol *sym, RegOperand *addrOpnd, int32 baseOffset);
+  RegOperand *SelectParmListDreadAccessField(const MIRSymbol &sym, FieldID fieldID, const CCLocInfo &ploc,
+                                             int32 offset, uint32 parmNum);
+  void CreateCallStructParamPassByReg(regno_t regno, MemOperand &memOpnd, ListOperand &srcOpnds,
+                                      FpParamState state);
+  void CreateCallStructParamMemcpy(const MIRSymbol &sym, uint32 structSize, int32 copyOffset, int32 fromOffset);
+  void CreateCallStructParamMemcpy(RegOperand &addropnd, uint32 structSize, int32 copyOffset, int32 fromOffset);
+  RegOperand *CreateCallStructParamCopyToStack(uint32 numMemOp, const MIRSymbol *sym, RegOperand *addrOpd,
+                                               int32 copyOffset, int32 fromOffset, const CCLocInfo &ploc);
+  RegOperand *LoadIreadAddrForSamllAgg(BaseNode &iread);
+  void SelectParmListDreadSmallAggregate(const MIRSymbol &sym, MIRType &structType,
+                                         ListOperand &srcOpnds,
+                                         int32 offset, AArch64CallConvImpl &parmLocator, FieldID fieldID);
+  void SelectParmListIreadSmallAggregate(BaseNode &iread, MIRType &structType, ListOperand &srcOpnds,
+                                         int32 offset, AArch64CallConvImpl &parmLocator);
+  void SelectParmListDreadLargeAggregate(const MIRSymbol &sym, MIRType &structType,
+                                         ListOperand &srcOpnds,
+                                         AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, int32 fromOffset);
+  void SelectParmListIreadLargeAggregate(const IreadNode &iread, MIRType &structType, ListOperand &srcOpnds,
+                                         AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, int32 fromOffset);
+  void CreateCallStructMemcpyToParamReg(MIRType &structType, int32 structCopyOffset, AArch64CallConvImpl &parmLocator,
+                                        ListOperand &srcOpnds);
+  void GenAggParmForDread(const BaseNode &parent, ListOperand &srcOpnds, AArch64CallConvImpl &parmLocator,
+                          int32 &structCopyOffset, size_t argNo);
+  void GenAggParmForIread(const BaseNode &parent, ListOperand &srcOpnds,
+                          AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, size_t argNo);
+  void GenAggParmForIreadoff(BaseNode &parent, ListOperand &srcOpnds,
+                             AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, size_t argNo);
+  void GenAggParmForIreadfpoff(BaseNode &parent, ListOperand &srcOpnds,
+                               AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, size_t argNo);
+  void SelectParmListForAggregate(BaseNode &parent, ListOperand &srcOpnds,
+                                  AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, size_t argNo);
+  size_t SelectParmListGetStructReturnSize(StmtNode &naryNode);
+  bool MarkParmListCall(BaseNode &expr);
+  void GenLargeStructCopyForDread(BaseNode &argExpr, int32 &structCopyOffset);
+  void GenLargeStructCopyForIread(BaseNode &argExpr, int32 &structCopyOffset);
+  void GenLargeStructCopyForIreadfpoff(BaseNode &parent, BaseNode &argExpr, int32 &structCopyOffset, size_t argNo);
+  void GenLargeStructCopyForIreadoff(BaseNode &parent, BaseNode &argExpr, int32 &structCopyOffset, size_t argNo);
+  void SelectParmListPreprocessLargeStruct(BaseNode &parent, BaseNode &argExpr, int32 &structCopyOffset, size_t argNo);
+  void SelectParmListPreprocess(StmtNode &naryNode, size_t start, std::set<size_t> &specialArgs);
+  void SelectParmList(StmtNode &naryNode, ListOperand &srcOpnds, bool isCallNative = false);
+  Operand *SelectClearStackCallParam(const AddrofNode &expr, int64 &offsetValue);
+  void SelectClearStackCallParmList(const StmtNode &naryNode, ListOperand &srcOpnds,
+                                    std::vector<int64> &stackPostion);
+  void SelectRem(Operand &resOpnd, Operand &lhsOpnd, Operand &rhsOpnd, PrimType primType, bool isSigned, bool is64Bits);
+  void SelectCvtInt2Int(const BaseNode *parent, Operand *&resOpnd, Operand *opnd0, PrimType fromType, PrimType toType);
+  void SelectCvtFloat2Float(Operand &resOpnd, Operand &srcOpnd, PrimType fromType, PrimType toType);
+  void SelectCvtFloat2Int(Operand &resOpnd, Operand &srcOpnd, PrimType itype, PrimType ftype);
+  void SelectCvtInt2Float(Operand &resOpnd, Operand &origOpnd0, PrimType toType, PrimType fromType);
+  Operand *SelectRelationOperator(RelationOperator operatorCode, const BinaryNode &node, Operand &opnd0,
+                                  Operand &opnd1, const BaseNode &parent);
+  void SelectRelationOperator(RelationOperator operatorCode, Operand &resOpnd, Operand &opnd0, Operand &opnd1,
+                              PrimType primType);
+  MOperator SelectRelationMop(RelationOperator operatorCode, RelationOperatorOpndPattern opndPattern, bool is64Bits,
+                              bool isBitmaskImmediate, bool isBitNumLessThan16) const;
+  Operand *SelectMinOrMax(bool isMin, const BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  void SelectMinOrMax(bool isMin, Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType);
+  Operand *SelectRoundLibCall(RoundType roundType, const TypeCvtNode &node, Operand &opnd0);
+  Operand *SelectRoundOperator(RoundType roundType, const TypeCvtNode &node, Operand &opnd0, const BaseNode &parent);
+  Operand *SelectAArch64ffs(Operand &argOpnd, PrimType argType);
+  Operand *SelectAArch64align(const IntrinsicopNode &intrnNode, bool isUp /* false for align down */);
+  int64 GetOrCreatSpillRegLocation(regno_t vrNum) {
+    AArch64SymbolAlloc *symLoc = static_cast<AArch64SymbolAlloc*>(GetMemlayout()->GetLocOfSpillRegister(vrNum));
+    return static_cast<int64>(GetBaseOffset(*symLoc));
+  }
+  void SelectCopyMemOpnd(Operand &dest, PrimType dtype, uint32 dsize, Operand &src, PrimType stype);
+  void SelectCopyRegOpnd(Operand &dest, PrimType dtype, Operand::OperandType opndType, uint32 dsize, Operand &src,
+                         PrimType stype);
+  bool GenerateCompareWithZeroInstruction(Opcode jmpOp, Opcode cmpOp, bool is64Bits, PrimType primType,
+                                          LabelOperand &targetOpnd, Operand &opnd0);
+  void GenCVaStartIntrin(RegOperand &opnd, uint32 stkSize);
+  void SelectCVaStart(const IntrinsiccallNode &intrnNode);
+  void SelectCAtomicStoreN(const IntrinsiccallNode &intrinsiccallNode);
+  void SelectCAtomicStore(const IntrinsiccallNode &intrinsiccall);
+  void SelectCAtomicLoad(const IntrinsiccallNode &intrinsiccall);
+  void SelectCSyncLockRelease(const IntrinsiccallNode &intrinsiccall, PrimType primType);
+  void SelectAtomicStore(Operand &srcOpnd, Operand &addrOpnd, PrimType primType, AArch64isa::MemoryOrdering memOrder);
+  void SelectAddrofThreadLocal(Operand &result, StImmOperand &stImm);
+  void SelectCTlsLocalDesc(Operand &result, StImmOperand &stImm);
+  void SelectCTlsGlobalDesc(Operand &result, StImmOperand &stImm);
+  void SelectMPLClinitCheck(const IntrinsiccallNode &intrnNode);
+  void SelectMPLProfCounterInc(const IntrinsiccallNode &intrnNode);
+  void SelectArithmeticAndLogical(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType, Opcode op);
+
+  Operand *SelectAArch64CAtomicFetch(const IntrinsicopNode &intrinopNode, Opcode op, bool fetchBefore);
+  Operand *SelectAArch64CSyncFetch(const IntrinsicopNode &intrinopNode, Opcode op, bool fetchBefore);
+  /* Helper functions for translating complex Maple IR instructions/inrinsics */
+  void SelectDassign(StIdx stIdx, FieldID fieldId, PrimType rhsPType, Operand &opnd0);
+  LabelIdx CreateLabeledBB(StmtNode &stmt);
+  void SaveReturnValueInLocal(CallReturnVector &retVals, size_t index, PrimType primType, Operand &value,
+                              StmtNode &parentStmt);
+  /* Translation for load-link store-conditional, and atomic RMW operations. */
+  MemOrd OperandToMemOrd(Operand &opnd) const;
+  MOperator PickLoadStoreExclInsn(uint32 byteP2Size, bool store, bool acqRel) const;
+  RegOperand *SelectLoadExcl(PrimType valPrimType, MemOperand &loc, bool acquire);
+  RegOperand *SelectStoreExcl(PrimType valPty, MemOperand &loc, RegOperand &newVal, bool release);
+
+  MemOperand *GetPseudoRegisterSpillMemoryOperand(PregIdx i) override;
+  void ProcessLazyBinding() override;
+  bool CanLazyBinding(const Insn &ldrInsn) const;
+  void ConvertAdrpl12LdrToLdr();
+  void ConvertAdrpLdrToIntrisic();
+  bool IsStoreMop(MOperator mOp) const;
+  bool IsImmediateValueInRange(MOperator mOp, int64 immVal, bool is64Bits,
+                               bool isIntactIndexed, bool isPostIndexed, bool isPreIndexed) const;
+  Insn &GenerateGlobalLongCallAfterInsn(const MIRSymbol &func, ListOperand &srcOpnds);
+  Insn &GenerateLocalLongCallAfterInsn(const MIRSymbol &func, ListOperand &srcOpnds);
+  bool IsDuplicateAsmList(const MIRSymbol &sym) const;
+  RegOperand *CheckStringIsCompressed(BB &bb, RegOperand &str, int32 countOffset, PrimType countPty,
+                                      LabelIdx jumpLabIdx);
+  RegOperand *CheckStringLengthLessThanEight(BB &bb, RegOperand &countOpnd, PrimType countPty, LabelIdx jumpLabIdx);
+  void GenerateIntrnInsnForStrIndexOf(BB &bb, RegOperand &srcString, RegOperand &patternString,
+                                      RegOperand &srcCountOpnd, RegOperand &patternLengthOpnd,
+                                      PrimType countPty, LabelIdx jumpLabIdx);
+  MemOperand *CheckAndCreateExtendMemOpnd(PrimType ptype, const BaseNode &addrExpr, int64 offset,
+                                          AArch64isa::MemoryOrdering memOrd);
+  MemOperand &CreateNonExtendMemOpnd(PrimType ptype, const BaseNode &parent, BaseNode &addrExpr, int64 offset);
+  std::string GenerateMemOpndVerbose(const Operand &src) const;
+  RegOperand *PrepareMemcpyParamOpnd(bool isLo12, const MIRSymbol &symbol, int64 offsetVal, RegOperand &baseReg);
+  RegOperand *PrepareMemcpyParamOpnd(int64 offset, Operand &exprOpnd);
+  RegOperand *PrepareMemcpyParamOpnd(uint64 copySize);
+  Insn *AggtStrLdrInsert(bool bothUnion, Insn *lastStrLdr, Insn &newStrLdr);
+  MemOperand &CreateMemOpndForStatic(const MIRSymbol &symbol, int64 offset, uint32 size, bool needLow12,
+                                     RegOperand *regOp);
+  LabelIdx GetLabelInInsn(Insn &insn) override {
+    return static_cast<LabelOperand&>(insn.GetOperand(AArch64isa::GetJumpTargetIdx(insn))).GetLabelIndex();
+  }
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_CGFUNC_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_color_ra.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_color_ra.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c9457547e892563e512c15b2e2cc5c8c0f83903
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_color_ra.h
@@ -0,0 +1,1447 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_COLOR_RA_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_COLOR_RA_H
+
+#include "reg_alloc.h"
+#include "operand.h"
+#include "cgfunc.h"
+#include "loop.h"
+#include "cg_dominance.h"
+#include "cg_pre.h"
+#include "rematerialize.h"
+
+namespace maplebe {
+#define RESERVED_REGS
+
+#define USE_LRA
+#define USE_SPLIT
+#undef USE_BB_FREQUENCY
+#define OPTIMIZE_FOR_PROLOG
+#define REUSE_SPILLMEM
+#undef COLOR_SPLIT
+#define MOVE_COALESCE
+
+/* for robust test */
+#undef CONSISTENT_MEMOPND
+#undef RANDOM_PRIORITY
+
+constexpr uint32 kU64 = sizeof(uint64) * CHAR_BIT;
+
+template <typename T, typename Comparator = std::less<T>>
+inline bool FindNotIn(const std::set<T, Comparator> &set, const T &item) {
+  return set.find(item) == set.end();
+}
+
+template <typename T, typename Comparator = std::less<T>>
+inline bool FindNotIn(const std::unordered_set<T, Comparator> &set, const T &item) {
+  return set.find(item) == set.end();
+}
+
+template <typename T>
+inline bool FindNotIn(const MapleSet<T> &set, const T &item) {
+  return set.find(item) == set.end();
+}
+
+template <typename T>
+inline bool FindNotIn(const MapleUnorderedSet<T> &set, const T &item) {
+  return set.find(item) == set.end();
+}
+
+template <typename T>
+inline bool FindNotIn(const MapleList<T> &list, const T &item) {
+  return std::find(list.begin(), list.end(), item) == list.end();
+}
+
+template <typename T, typename Comparator = std::less<T>>
+inline bool FindIn(const std::set<T, Comparator> &set, const T &item) {
+  return set.find(item) != set.end();
+}
+
+template <typename T, typename Comparator = std::less<T>>
+inline bool FindIn(const std::unordered_set<T, Comparator> &set, const T &item) {
+  return set.find(item) != set.end();
+}
+
+template<typename T>
+inline bool FindIn(const MapleSet<T> &set, const T &item) {
+  return set.find(item) != set.end();
+}
+
+template<typename T>
+inline bool FindIn(const MapleUnorderedSet<T> &set, const T &item) {
+  return set.find(item) != set.end();
+}
+
+template<typename T>
+inline bool FindIn(const MapleList<T> &list, const T &item) {
+  return std::find(list.begin(), list.end(), item) != list.end();
+}
+
+inline bool IsBitArrElemSet(const uint64 *vec, const uint32 num) {
+  size_t index = num / kU64;
+  uint64 bit = num % kU64;
+  return vec[index] & (1ULL << bit);
+}
+
+inline bool IsBBsetOverlap(const uint64 *vec1, const uint64 *vec2, uint32 bbBuckets) {
+  for (uint32 i = 0; i < bbBuckets; ++i) {
+    if ((vec1[i] & vec2[i]) != 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/* For each bb, record info pertain to allocation */
+/*
+ * This is per bb per LR.
+ * LU info is particular to a bb in a LR.
+ */
+class LiveUnit {
+ public:
+  LiveUnit() = default;
+  ~LiveUnit() = default;
+
+  void PrintLiveUnit() const;
+
+  uint32 GetBegin() const {
+    return begin;
+  }
+
+  void SetBegin(uint32 val) {
+    begin = val;
+  }
+
+  uint32 GetEnd() const {
+    return end;
+  }
+
+  void SetEnd(uint32 endVal) {
+    this->end = endVal;
+  }
+
+  bool HasCall() const {
+    return hasCall;
+  }
+
+  void SetHasCall(bool hasCallVal) {
+    this->hasCall = hasCallVal;
+  }
+
+  uint32 GetDefNum() const {
+    return defNum;
+  }
+
+  void SetDefNum(uint32 defNumVal) {
+    this->defNum = defNumVal;
+  }
+
+  void IncDefNum() {
+    ++defNum;
+  }
+
+  uint32 GetUseNum() const {
+    return useNum;
+  }
+
+  void SetUseNum(uint32 useNumVal) {
+    this->useNum = useNumVal;
+  }
+
+  void IncUseNum() {
+    ++useNum;
+  }
+
+  bool NeedReload() const {
+    return needReload;
+  }
+
+  void SetNeedReload(bool needReloadVal) {
+    this->needReload = needReloadVal;
+  }
+
+  bool NeedRestore() const {
+    return needRestore;
+  }
+
+  void SetNeedRestore(bool needRestoreVal) {
+    this->needRestore = needRestoreVal;
+  }
+
+ private:
+  uint32 begin = 0;      /* first encounter in bb */
+  uint32 end = 0;        /* last encounter in bb */
+  bool hasCall = false;  /* bb has a call */
+  uint32 defNum = 0;
+  uint32 useNum = 0;     /* used for priority calculation */
+  bool needReload = false;
+  bool needRestore = false;
+};
+
+struct SortedBBCmpFunc {
+  bool operator()(const BB *lhs, const BB *rhs) const {
+    return (lhs->GetLevel() < rhs->GetLevel());
+  }
+};
+
+enum RefType : uint8 {
+  kIsUse = 0x1,
+  kIsDef = 0x2,
+  kIsCall = 0x4,
+};
+
+/* LR is for each global vreg. */
+class LiveRange {
+ public:
+  explicit LiveRange(uint32 maxRegNum, MapleAllocator &allocator)
+      : lrAlloca(&allocator),
+        pregveto(maxRegNum, false, allocator.Adapter()),
+        callDef(maxRegNum, false, allocator.Adapter()),
+        forbidden(maxRegNum, false, allocator.Adapter()),
+        prefs(allocator.Adapter()),
+        refMap(allocator.Adapter()),
+        luMap(allocator.Adapter()) {}
+
+  ~LiveRange() = default;
+
+  regno_t GetRegNO() const {
+    return regNO;
+  }
+
+  void SetRegNO(regno_t val) {
+    regNO = val;
+  }
+
+  uint32 GetID() const {
+    return id;
+  }
+
+  void SetID(uint32 idVal) {
+    this->id = idVal;
+  }
+
+  regno_t GetAssignedRegNO() const {
+    return assignedRegNO;
+  }
+
+  void SetAssignedRegNO(regno_t regno) {
+    assignedRegNO = regno;
+  }
+
+  uint32 GetNumCall() const {
+    return numCall;
+  }
+
+  void SetNumCall(uint32 num) {
+    numCall = num;
+  }
+
+  void IncNumCall() {
+    ++numCall;
+  }
+
+  RegType GetRegType() const {
+    return regType;
+  }
+
+  void SetRegType(RegType regTy) {
+    this->regType = regTy;
+  }
+
+  float GetPriority() const {
+    return priority;
+  }
+
+  void SetPriority(float priorityVal) {
+    this->priority = priorityVal;
+  }
+
+  bool IsMustAssigned() const {
+    return mustAssigned;
+  }
+
+  void SetMustAssigned() {
+    mustAssigned = true;
+  }
+
+  void SetBBBuckets(uint32 bucketNum) {
+    bbBuckets = bucketNum;
+  }
+
+  void SetRegBuckets(uint32 bucketNum) {
+    regBuckets = bucketNum;
+  }
+
+  uint32 GetNumBBMembers() const {
+    return numBBMembers;
+  }
+
+  void IncNumBBMembers() {
+    ++numBBMembers;
+  }
+
+  void DecNumBBMembers() {
+    --numBBMembers;
+  }
+
+  void InitBBMember(MemPool &memPool, size_t size) {
+    bbMember = memPool.NewArray<uint64>(size);
+    errno_t ret = memset_s(bbMember, size * sizeof(uint64), 0, size * sizeof(uint64));
+    CHECK_FATAL(ret == EOK, "call memset_s failed");
+  }
+
+  uint64 *GetBBMember() {
+    return bbMember;
+  }
+
+  const uint64 *GetBBMember() const {
+    return bbMember;
+  }
+
+  uint64 GetBBMemberElem(int32 index) const {
+    return bbMember[index];
+  }
+
+  void SetBBMemberElem(int32 index, uint64 elem) const {
+    bbMember[index] = elem;
+  }
+
+  void SetMemberBitArrElem(uint32 bbID) {
+    uint32 index = bbID / kU64;
+    uint64 bit = bbID % kU64;
+    uint64 mask = 1ULL << bit;
+    if ((GetBBMemberElem(index) & mask) == 0) {
+      IncNumBBMembers();
+      SetBBMemberElem(index, GetBBMemberElem(index) | mask);
+    }
+  }
+
+  void UnsetMemberBitArrElem(uint32 bbID) {
+    uint32 index = bbID / kU64;
+    uint64 bit = bbID % kU64;
+    uint64 mask = 1ULL << bit;
+    if ((GetBBMemberElem(index) & mask) != 0) {
+      DecNumBBMembers();
+      SetBBMemberElem(index, GetBBMemberElem(index) & (~mask));
+    }
+  }
+
+  void SetConflictBitArrElem(regno_t regno) {
+    uint32 index = regno / kU64;
+    uint64 bit = regno % kU64;
+    uint64 mask = 1ULL << bit;
+    if ((GetBBConflictElem(index) & mask) == 0) {
+      IncNumBBConflicts();
+      SetBBConflictElem(index, GetBBConflictElem(index) | mask);
+    }
+  }
+
+  void UnsetConflictBitArrElem(regno_t regno) {
+    uint32 index = regno / kU64;
+    uint64 bit = regno % kU64;
+    uint64 mask = 1ULL << bit;
+    if ((GetBBConflictElem(index) & mask) != 0) {
+      DecNumBBConflicts();
+      SetBBConflictElem(index, GetBBConflictElem(index) & (~mask));
+    }
+  }
+
+  void InitPregveto() {
+    pregveto.assign(pregveto.size(), false);
+    callDef.assign(callDef.size(), false);
+  }
+
+  bool GetPregveto(regno_t regno) const {
+    return pregveto[regno];
+  }
+
+  size_t GetPregvetoSize() const {
+    return numPregveto;
+  }
+
+  void InsertElemToPregveto(regno_t regno) {
+    if (!pregveto[regno]) {
+      pregveto[regno] = true;
+      ++numPregveto;
+    }
+  }
+
+  bool GetCallDef(regno_t regno) const {
+    return callDef[regno];
+  }
+
+  void InsertElemToCallDef(regno_t regno) {
+    if (!callDef[regno]) {
+      callDef[regno] = true;
+      ++numCallDef;
+    }
+  }
+
+  void SetCrossCall() {
+    crossCall = true;
+  }
+
+  bool GetCrossCall() const {
+    return crossCall;
+  }
+
+  void InitForbidden() {
+    forbidden.assign(forbidden.size(), false);
+  }
+
+  const MapleVector<bool> &GetForbidden() const {
+    return forbidden;
+  }
+
+  bool GetForbidden(regno_t regno) const {
+    return forbidden[regno];
+  }
+
+  size_t GetForbiddenSize() const {
+    return numForbidden;
+  }
+
+  void InsertElemToForbidden(regno_t regno) {
+    if (!forbidden[regno]) {
+      forbidden[regno] = true;
+      ++numForbidden;
+    }
+  }
+
+  void EraseElemFromForbidden(regno_t regno) {
+    if (forbidden[regno]) {
+      forbidden[regno] = false;
+      --numForbidden;
+    }
+  }
+
+  void ClearForbidden() {
+    forbidden.clear();
+  }
+
+  uint32 GetNumBBConflicts() const {
+    return numBBConflicts;
+  }
+
+  void IncNumBBConflicts() {
+    ++numBBConflicts;
+  }
+
+  void DecNumBBConflicts() {
+    --numBBConflicts;
+  }
+
+  void InitBBConflict(MemPool &memPool, size_t size) {
+    bbConflict = memPool.NewArray<uint64>(size);
+    errno_t ret = memset_s(bbConflict, size * sizeof(uint64), 0, size * sizeof(uint64));
+    CHECK_FATAL(ret == EOK, "call memset_s failed");
+  }
+
+  const uint64 *GetBBConflict() const {
+    return bbConflict;
+  }
+
+  uint64 GetBBConflictElem(int32 index) const {
+    ASSERT(index < regBuckets, "out of bbConflict");
+    return bbConflict[index];
+  }
+
+  void SetBBConflictElem(int32 index, uint64 elem) const {
+    ASSERT(index < regBuckets, "out of bbConflict");
+    bbConflict[index] = elem;
+  }
+
+  void SetOldConflict(uint64 *conflict) {
+    oldConflict = conflict;
+  }
+
+  const uint64 *GetOldConflict() const {
+    return oldConflict;
+  }
+
+  const MapleSet<regno_t> &GetPrefs() const {
+    return prefs;
+  }
+
+  void InsertElemToPrefs(regno_t regno) {
+    (void)prefs.insert(regno);
+  }
+
+  const MapleMap<uint32, MapleMap<uint32, uint32>*> GetRefs() const {
+    return refMap;
+  }
+
+  const MapleMap<uint32, uint32> GetRefs(uint32 bbId) const {
+    return *(refMap.find(bbId)->second);
+  }
+
+  void AddRef(uint32 bbId, uint32 pos, uint32 mark) {
+    if (refMap.find(bbId) == refMap.end()) {
+      auto point = lrAlloca->New<MapleMap<uint32, uint32>>(lrAlloca->Adapter());
+      (void)point->emplace(std::pair<uint32, uint32>(pos, mark));
+      (void)refMap.emplace(std::pair<uint32, MapleMap<uint32, uint32>*>(bbId, point));
+    } else {
+      auto &bbPoint = (refMap.find(bbId))->second;
+      if (bbPoint->find(pos) == bbPoint->end()) {
+        (void)bbPoint->emplace(std::pair<uint32, uint32>(pos, mark));
+      } else {
+        auto posVal = bbPoint->find(pos)->second;
+        (void)bbPoint->erase(bbPoint->find(pos));
+        (void)bbPoint->emplace(std::pair<uint32, uint32>(pos, posVal | mark));
+      }
+    }
+  }
+
+  const MapleMap<uint32, LiveUnit*> &GetLuMap() const {
+    return luMap;
+  }
+
+  MapleMap<uint32, LiveUnit*>::iterator FindInLuMap(uint32 index) {
+    return luMap.find(index);
+  }
+
+  MapleMap<uint32, LiveUnit*>::iterator EndOfLuMap() {
+    return luMap.end();
+  }
+
+  MapleMap<uint32, LiveUnit*>::const_iterator EraseLuMap(MapleMap<uint32, LiveUnit*>::const_iterator it) {
+    return luMap.erase(it);
+  }
+
+  void SetElemToLuMap(uint32 key, LiveUnit &value) {
+    luMap[key] = &value;
+  }
+
+  LiveUnit *GetLiveUnitFromLuMap(uint32 key) {
+    return luMap[key];
+  }
+
+  const LiveUnit *GetLiveUnitFromLuMap(uint32 key) const {
+    auto it = luMap.find(key);
+    ASSERT(it != luMap.end(), "can't find live unit");
+    return it->second;
+  }
+
+  const LiveRange *GetSplitLr() const {
+    return splitLr;
+  }
+
+  void SetSplitLr(LiveRange &lr) {
+    splitLr = &lr;
+  }
+
+#ifdef OPTIMIZE_FOR_PROLOG
+  uint32 GetNumDefs() const {
+    return numDefs;
+  }
+
+  void IncNumDefs() {
+    ++numDefs;
+  }
+
+  void SetNumDefs(uint32 val) {
+    numDefs = val;
+  }
+
+  uint32 GetNumUses() const {
+    return numUses;
+  }
+
+  void IncNumUses() {
+    ++numUses;
+  }
+
+  void SetNumUses(uint32 val) {
+    numUses = val;
+  }
+
+  uint32 GetFrequency() const {
+    return frequency;
+  }
+
+  void SetFrequency(uint32 frequencyVal) {
+    this->frequency = frequencyVal;
+  }
+#endif  /* OPTIMIZE_FOR_PROLOG */
+
+  MemOperand *GetSpillMem() {
+    return spillMem;
+  }
+
+  const MemOperand *GetSpillMem() const {
+    return spillMem;
+  }
+
+  void SetSpillMem(MemOperand& memOpnd) {
+    spillMem = &memOpnd;
+  }
+
+  regno_t GetSpillReg() const {
+    return spillReg;
+  }
+
+  void SetSpillReg(regno_t spillRegister) {
+    this->spillReg = spillRegister;
+  }
+
+  uint32 GetSpillSize() const {
+    return spillSize;
+  }
+
+  void SetSpillSize(uint32 size) {
+    spillSize = size;
+  }
+
+  bool IsSpilled() const {
+    return spilled;
+  }
+
+  void SetSpilled(bool spill) {
+    spilled = spill;
+  }
+
+  bool HasDefUse() const {
+    return hasDefUse;
+  }
+
+  void SetDefUse() {
+    hasDefUse = true;
+  }
+
+  bool GetProcessed() const {
+    return proccessed;
+  }
+
+  void SetProcessed() {
+    proccessed = true;
+  }
+
+  bool IsNonLocal() const {
+    return isNonLocal;
+  }
+
+  void SetIsNonLocal(bool isNonLocalVal) {
+    this->isNonLocal = isNonLocalVal;
+  }
+
+  void SetRematLevel(RematLevel val) {
+    rematerializer->SetRematLevel(val);
+  }
+
+  RematLevel GetRematLevel() const {
+    return rematerializer->GetRematLevel();
+  }
+
+  Opcode GetOp() const {
+    return rematerializer->GetOp();
+  }
+
+  void SetRematerializable(const MIRConst *c) {
+    rematerializer->SetRematerializable(c);
+  }
+
+  void SetRematerializable(Opcode opcode, const MIRSymbol *symbol, FieldID fieldId, bool addrUp) {
+    rematerializer->SetRematerializable(opcode, symbol, fieldId, addrUp);
+  }
+
+  void CopyRematerialization(const LiveRange &lr) {
+    *rematerializer = *lr.GetRematerializer();
+  }
+
+  bool GetIsSpSave() const {
+    return isSpSave;
+  }
+
+  void SetIsSpSave() {
+    isSpSave = true;
+  }
+
+  bool IsRematerializable(CGFunc &cgFunc, RematLevel rematLev) const {
+    return rematerializer->IsRematerializable(cgFunc, rematLev, *this);
+  }
+  std::vector<Insn*> Rematerialize(CGFunc &cgFunc, RegOperand &regOp) {
+    return rematerializer->Rematerialize(cgFunc, regOp, *this);
+  }
+
+  void SetRematerializer(Rematerializer *remat) {
+    rematerializer = remat;
+  }
+
+  Rematerializer *GetRematerializer() const {
+    return rematerializer;
+  }
+
+ private:
+  MapleAllocator *lrAlloca;
+  regno_t regNO = 0;
+  uint32 id = 0;                      /* for priority tie breaker */
+  regno_t assignedRegNO = 0;          /* color assigned */
+  uint32 numCall = 0;
+  RegType regType = kRegTyUndef;
+  float priority = 0.0;
+  bool mustAssigned = false;
+  uint32 bbBuckets = 0;               /* size of bit array for bb (each bucket == 64 bits) */
+  uint32 regBuckets = 0;              /* size of bit array for reg (each bucket == 64 bits) */
+  uint32 numBBMembers = 0;            /* number of bits set in bbMember */
+  uint64 *bbMember = nullptr;         /* Same as smember, but use bit array */
+
+  MapleBitVector pregveto;         /* pregs cannot be assigned   -- SplitLr may clear forbidden */
+  MapleBitVector callDef;         /* pregs cannot be assigned   -- SplitLr may clear forbidden */
+  MapleBitVector forbidden;        /* pregs cannot be assigned */
+  uint32 numPregveto = 0;
+  uint32 numCallDef = 0;
+  uint32 numForbidden = 0;
+  bool crossCall = false;
+
+  uint32 numBBConflicts = 0;          /* number of bits set in bbConflict */
+  uint64 *bbConflict = nullptr;       /* vreg interference from graph neighbors (bit) */
+  uint64 *oldConflict = nullptr;
+  MapleSet<regno_t> prefs;            /* pregs that prefer */
+  MapleMap<uint32, MapleMap<uint32, uint32>*> refMap;
+  MapleMap<uint32, LiveUnit*> luMap;  /* info for each bb */
+  LiveRange *splitLr = nullptr;       /* The 1st part of the split */
+#ifdef OPTIMIZE_FOR_PROLOG
+  uint32 numDefs = 0;
+  uint32 numUses = 0;
+  uint32 frequency = 0;
+#endif                                /* OPTIMIZE_FOR_PROLOG */
+  MemOperand *spillMem = nullptr;     /* memory operand used for spill, if any */
+  regno_t spillReg = 0;               /* register operand for spill at current point */
+  uint32 spillSize = 0;               /* 32 or 64 bit spill */
+  bool spilled = false;               /* color assigned */
+  bool hasDefUse = false;               /* has regDS */
+  bool proccessed = false;
+  bool isNonLocal = false;
+  bool isSpSave = false;              /* contain SP in case of alloca */
+  Rematerializer *rematerializer = nullptr;
+};
+
+/* One per bb, to communicate local usage to global RA */
+class LocalRaInfo {
+ public:
+  explicit LocalRaInfo(MapleAllocator &allocator)
+      : defCnt(allocator.Adapter()),
+        useCnt(allocator.Adapter()) {}
+
+  ~LocalRaInfo() = default;
+
+  const MapleMap<regno_t, uint16> &GetDefCnt() const {
+    return defCnt;
+  }
+
+  uint16 GetDefCntElem(regno_t regNO) {
+    return defCnt[regNO];
+  }
+
+  void SetDefCntElem(regno_t key, uint16 value) {
+    defCnt[key] = value;
+  }
+
+  const MapleMap<regno_t, uint16> &GetUseCnt() const {
+    return useCnt;
+  }
+
+  uint16 GetUseCntElem(regno_t regNO) {
+    return useCnt[regNO];
+  }
+
+  void SetUseCntElem(regno_t key, uint16 value) {
+    useCnt[key] = value;
+  }
+
+ private:
+  MapleMap<regno_t, uint16> defCnt;
+  MapleMap<regno_t, uint16> useCnt;
+};
+
+/* For each bb, record info pertain to allocation */
+class BBAssignInfo {
+ public:
+  explicit BBAssignInfo(uint32 maxRegNum, MapleAllocator &allocator)
+      : globalsAssigned(maxRegNum, false, allocator.Adapter()),
+        regMap(allocator.Adapter()) {}
+
+  ~BBAssignInfo() = default;
+
+  uint32 GetLocalRegsNeeded() const {
+    return localRegsNeeded;
+  }
+
+  void SetLocalRegsNeeded(uint32 num) {
+    localRegsNeeded = num;
+  }
+
+  void InitGlobalAssigned() {
+    globalsAssigned.assign(globalsAssigned.size(), false);
+  }
+
+  bool GetGlobalsAssigned(regno_t regNO) const {
+    return globalsAssigned[regNO];
+  }
+
+  void InsertElemToGlobalsAssigned(regno_t regNO) {
+    globalsAssigned[regNO] = true;
+  }
+
+  void EraseElemToGlobalsAssigned(regno_t regNO) {
+    globalsAssigned[regNO] = false;
+  }
+
+  const MapleMap<regno_t, regno_t> &GetRegMap() const {
+    return regMap;
+  }
+
+  bool HasRegMap(regno_t regNOKey) const  {
+    return (regMap.find(regNOKey) != regMap.end());
+  }
+
+  regno_t GetRegMapElem(regno_t regNO) {
+    return regMap[regNO];
+  }
+
+  void SetRegMapElem(regno_t regNOKey, regno_t regNOValue) {
+    regMap[regNOKey] = regNOValue;
+  }
+
+ private:
+  uint32 localRegsNeeded = 0;         /* num local reg needs for each bb */
+  MapleBitVector globalsAssigned;     /* globals used in a bb */
+  MapleMap<regno_t, regno_t> regMap;  /* local vreg to preg mapping */
+};
+
+class FinalizeRegisterInfo {
+ public:
+  explicit FinalizeRegisterInfo(MapleAllocator &allocator)
+      : defOperands(allocator.Adapter()),
+        useOperands(allocator.Adapter()),
+        useDefOperands(allocator.Adapter()) {}
+
+  ~FinalizeRegisterInfo() = default;
+  void ClearInfo() {
+    memOperandIdx = 0;
+    baseOperand = nullptr;
+    offsetOperand = nullptr;
+    defOperands.clear();
+    useOperands.clear();
+    useDefOperands.clear();
+  }
+
+  void SetBaseOperand(Operand &opnd, uint32 idx) {
+    baseOperand = &opnd;
+    memOperandIdx = idx;
+  }
+
+  void SetOffsetOperand(Operand &opnd) {
+    offsetOperand = &opnd;
+  }
+
+  void SetDefOperand(Operand &opnd, uint32 idx) {
+    defOperands.emplace_back(idx, &opnd);
+  }
+
+  void SetUseOperand(Operand &opnd, uint32 idx) {
+    useOperands.emplace_back(idx, &opnd);
+  }
+
+  void SetUseDefOperand(Operand &opnd, uint32 idx) {
+    useDefOperands.emplace_back(idx, &opnd);
+  }
+
+  int32 GetMemOperandIdx() const {
+    return memOperandIdx;
+  }
+
+  const Operand *GetBaseOperand() const {
+    return baseOperand;
+  }
+
+  const Operand *GetOffsetOperand() const {
+    return offsetOperand;
+  }
+
+  const MapleVector<std::pair<uint32, Operand*>> &GetDefOperands() const {
+    return defOperands;
+  }
+
+  const MapleVector<std::pair<uint32, Operand*>> &GetUseOperands() const {
+    return useOperands;
+  }
+
+  const MapleVector<std::pair<uint32, Operand*>> &GetUseDefOperands() const {
+    return useDefOperands;
+  }
+ private:
+  uint32 memOperandIdx = 0;
+  Operand *baseOperand = nullptr;
+  Operand *offsetOperand = nullptr;
+  MapleVector<std::pair<uint32, Operand*>> defOperands;
+  MapleVector<std::pair<uint32, Operand*>> useOperands;
+  MapleVector<std::pair<uint32, Operand*>> useDefOperands;
+};
+
+class LocalRegAllocator {
+ public:
+  LocalRegAllocator(CGFunc &cgFunc, MapleAllocator &allocator)
+      : regInfo(cgFunc.GetTargetRegInfo()),
+        regAssigned(allocator.Adapter()),
+        regSpilled(allocator.Adapter()),
+        regAssignmentMap(allocator.Adapter()),
+        pregUsed(allocator.Adapter()),
+        pregs(allocator.Adapter()),
+        useInfo(allocator.Adapter()),
+        defInfo(allocator.Adapter()) {
+    regAssigned.resize(cgFunc.GetMaxRegNum(), false);
+    regSpilled.resize(cgFunc.GetMaxRegNum(), false);
+    pregUsed.resize(regInfo->GetAllRegNum(), false);
+    pregs.resize(regInfo->GetAllRegNum(), false);
+  }
+
+  ~LocalRegAllocator() = default;
+
+  void ClearLocalRaInfo() {
+    regSpilled.assign(regSpilled.size(), false);
+    regAssigned.assign(regAssigned.size(), false);
+    regAssignmentMap.clear();
+    pregUsed.assign(pregUsed.size(), false);
+  }
+
+  bool IsInRegAssigned(regno_t regNO) const {
+    return regAssigned[regNO];
+  }
+
+  void SetRegAssigned(regno_t regNO) {
+    regAssigned[regNO] = true;
+  }
+
+  regno_t GetRegAssignmentItem(regno_t regKey) const {
+    auto iter = regAssignmentMap.find(regKey);
+    ASSERT(iter != regAssignmentMap.end(), "error reg assignmemt");
+    return iter->second;
+  }
+
+  void SetRegAssignmentMap(regno_t regKey, regno_t regValue) {
+    regAssignmentMap[regKey] = regValue;
+  }
+
+  /* only for HandleLocalRaDebug */
+  const MapleBitVector &GetPregUsed() const {
+    return pregUsed;
+  }
+
+  void SetPregUsed(regno_t regNO) {
+    if (!pregUsed[regNO]) {
+      pregUsed[regNO] = true;
+      ++numPregUsed;
+    }
+  }
+
+  bool IsInRegSpilled(regno_t regNO) const {
+    return regSpilled[regNO];
+  }
+
+  void SetRegSpilled(regno_t regNO) {
+    regSpilled[regNO] = true;
+  }
+
+  const MapleBitVector &GetPregs() const {
+    return pregs;
+  }
+
+  void SetPregs(regno_t regNO) {
+    pregs[regNO] = true;
+  }
+
+  void ClearPregs(regno_t regNO) {
+    pregs[regNO] = false;
+  }
+
+  bool IsPregAvailable(regno_t regNO) const {
+    return pregs[regNO];
+  }
+
+  void InitPregs(bool hasYield, const MapleSet<uint32> &intSpillRegSet,
+                 const MapleSet<uint32> &fpSpillRegSet) {
+    for (regno_t regNO : regInfo->GetAllRegs()) {
+      SetPregs(regNO);
+    }
+    for (regno_t regNO : intSpillRegSet) {
+      ClearPregs(regNO);
+    }
+    for (regno_t regNO : fpSpillRegSet) {
+      ClearPregs(regNO);
+    }
+    if (hasYield) {
+      ClearPregs(regInfo->GetYieldPointReg());
+    }
+#ifdef RESERVED_REGS
+    ClearPregs(regInfo->GetReservedSpillReg());
+    ClearPregs(regInfo->GetSecondReservedSpillReg());
+#endif  /* RESERVED_REGS */
+  }
+
+  const MapleMap<regno_t, regno_t> &GetRegAssignmentMap() const {
+    return regAssignmentMap;
+  }
+
+  const MapleMap<regno_t, uint16> &GetUseInfo() const {
+    return useInfo;
+  }
+
+  void SetUseInfoElem(regno_t regNO, uint16 info) {
+    useInfo[regNO] = info;
+  }
+
+  void IncUseInfoElem(regno_t regNO) {
+    if (useInfo.find(regNO) != useInfo.end()) {
+      ++useInfo[regNO];
+    }
+  }
+
+  uint16 GetUseInfoElem(regno_t regNO) {
+    return useInfo[regNO];
+  }
+
+  void ClearUseInfo() {
+    useInfo.clear();
+  }
+
+  const MapleMap<regno_t, uint16> &GetDefInfo() const {
+    return defInfo;
+  }
+
+  void SetDefInfoElem(regno_t regNO, uint16 info) {
+    defInfo[regNO] = info;
+  }
+
+  uint16 GetDefInfoElem(regno_t regNO) {
+    return defInfo[regNO];
+  }
+
+  void IncDefInfoElem(regno_t regNO) {
+    if (defInfo.find(regNO) != defInfo.end()) {
+      ++defInfo[regNO];
+    }
+  }
+
+  void ClearDefInfo() {
+    defInfo.clear();
+  }
+
+  uint32 GetNumPregUsed() const {
+    return numPregUsed;
+  }
+
+ private:
+  RegisterInfo *regInfo = nullptr;
+  /* The following local vars keeps track of allocation information in bb. */
+  MapleBitVector regAssigned;   /* in this set if vreg is assigned */
+  MapleBitVector regSpilled;    /* on this list if vreg is spilled */
+  MapleMap<regno_t, regno_t> regAssignmentMap;  /* vreg -> preg map, which preg is the vreg assigned */
+  MapleBitVector pregUsed;      /* pregs used in bb */
+  MapleBitVector pregs;     /* available regs for assignement */
+  MapleMap<regno_t, uint16> useInfo;  /* copy of local ra info for useCnt */
+  MapleMap<regno_t, uint16> defInfo;  /* copy of local ra info for defCnt */
+
+  uint32 numPregUsed = 0;
+};
+
+class SplitBBInfo {
+ public:
+  SplitBBInfo() = default;
+
+  ~SplitBBInfo() = default;
+
+  BB *GetCandidateBB() {
+    return candidateBB;
+  }
+
+  const BB *GetCandidateBB() const {
+    return candidateBB;
+  }
+
+  const BB *GetStartBB() const {
+    return startBB;
+  }
+
+  void SetCandidateBB(BB &bb) {
+    candidateBB = &bb;
+  }
+
+  void SetStartBB(BB &bb) {
+    startBB = &bb;
+  }
+
+ private:
+  BB *candidateBB = nullptr;
+  BB *startBB = nullptr;
+};
+
+class GraphColorRegAllocator : public RegAllocator {
+ public:
+  GraphColorRegAllocator(CGFunc &cgFunc, MemPool &memPool, DomAnalysis &dom)
+      : RegAllocator(cgFunc, memPool),
+        domInfo(dom),
+        bbVec(alloc.Adapter()),
+        vregLive(alloc.Adapter()),
+        pregLive(alloc.Adapter()),
+        lrMap(alloc.Adapter()),
+        localRegVec(alloc.Adapter()),
+        bbRegInfo(alloc.Adapter()),
+        unconstrained(alloc.Adapter()),
+        unconstrainedPref(alloc.Adapter()),
+        constrained(alloc.Adapter()),
+        mustAssigned(alloc.Adapter()),
+#ifdef OPTIMIZE_FOR_PROLOG
+        intDelayed(alloc.Adapter()),
+        fpDelayed(alloc.Adapter()),
+#endif  /* OPTIMIZE_FOR_PROLOG */
+        intCallerRegSet(alloc.Adapter()),
+        intCalleeRegSet(alloc.Adapter()),
+        intSpillRegSet(alloc.Adapter()),
+        fpCallerRegSet(alloc.Adapter()),
+        fpCalleeRegSet(alloc.Adapter()),
+        fpSpillRegSet(alloc.Adapter()),
+        intCalleeUsed(alloc.Adapter()),
+        fpCalleeUsed(alloc.Adapter()) {
+    constexpr uint32 kNumInsnThreashold = 30000;
+    numVregs = cgFunc.GetMaxVReg();
+    localRegVec.resize(cgFunc.NumBBs());
+    bbRegInfo.resize(cgFunc.NumBBs());
+    if (CGOptions::DoMultiPassColorRA() && cgFunc.GetMirModule().IsCModule()) {
+      uint32 cnt = 0;
+      FOR_ALL_BB(bb, &cgFunc) {
+        FOR_BB_INSNS(insn, bb) {
+          ++cnt;
+        }
+      }
+      ASSERT(cnt <= cgFunc.GetTotalNumberOfInstructions(), "Incorrect insn count");
+      if (cnt <= kNumInsnThreashold) {
+        doMultiPass = true;
+        doLRA = false;
+        doOptProlog = false;
+      }
+    }
+  }
+
+  ~GraphColorRegAllocator() override = default;
+
+  bool AllocateRegisters() override;
+
+  enum SpillMemCheck : uint8 {
+    kSpillMemPre,
+    kSpillMemPost,
+  };
+
+  LiveRange *GetLiveRange(regno_t regNO) {
+    MapleMap<regno_t, LiveRange*>::const_iterator it = lrMap.find(regNO);
+    if (it != lrMap.cend()) {
+      return it->second;
+    } else {
+      return nullptr;
+    }
+  }
+  LiveRange *GetLiveRange(regno_t regNO) const {
+    auto it = lrMap.find(regNO);
+    if (it != lrMap.end()) {
+      return it->second;
+    } else {
+      return nullptr;
+    }
+  }
+  const MapleMap<regno_t, LiveRange*> &GetLrMap() const {
+    return lrMap;
+  }
+  Insn *SpillOperand(Insn &insn, const Operand &opnd, bool isDef, RegOperand &phyOpnd, bool forCall = false);
+ private:
+  struct SetLiveRangeCmpFunc {
+    bool operator()(const LiveRange *lhs, const LiveRange *rhs) const {
+      if (fabs(lhs->GetPriority() - rhs->GetPriority()) <= 1e-6) {
+        /*
+         * This is to ensure the ordering is consistent as the reg#
+         * differs going through VtableImpl.mpl file.
+         */
+        if (lhs->GetID() == rhs->GetID()) {
+          return lhs->GetRegNO() < rhs->GetRegNO();
+        } else {
+          return lhs->GetID() < rhs->GetID();
+        }
+      }
+      return (lhs->GetPriority() > rhs->GetPriority());
+    }
+  };
+
+  template <typename Func>
+  void ForEachBBArrElem(const uint64 *vec, Func functor) const;
+
+  template <typename Func>
+  void ForEachBBArrElemWithInterrupt(const uint64 *vec, Func functor) const;
+
+  template <typename Func>
+  void ForEachRegArrElem(const uint64 *vec, Func functor) const;
+
+  void PrintLiveUnitMap(const LiveRange &lr) const;
+  void PrintLiveRangeConflicts(const LiveRange &lr) const;
+  void PrintLiveBBBit(const LiveRange &lr) const;
+  void PrintLiveRange(const LiveRange &lr, const std::string &str) const;
+  void PrintLiveRanges() const;
+  void PrintLocalRAInfo(const std::string &str) const;
+  void PrintBBAssignInfo() const;
+  void PrintBBs() const;
+
+  void InitFreeRegPool();
+  LiveRange *NewLiveRange();
+  void CalculatePriority(LiveRange &lr) const;
+  bool CreateLiveRangeHandleLocal(regno_t regNO, const BB &bb, bool isDef);
+  LiveRange *CreateLiveRangeAllocateAndUpdate(regno_t regNO, const BB &bb, bool isDef, uint32 currId);
+  void CreateLiveRange(regno_t regNO, const BB &bb, bool isDef, uint32 currId, bool updateCount);
+  bool SetupLiveRangeByOpHandlePhysicalReg(const RegOperand &regOpnd, Insn &insn, regno_t regNO, bool isDef);
+  void SetupLiveRangeByOp(Operand &op, Insn &insn, bool isDef, uint32 &numUses);
+  void SetupLiveRangeByRegNO(regno_t liveOut, BB &bb, uint32 currPoint);
+  bool UpdateInsnCntAndSkipUseless(Insn &insn, uint32 &currPoint) const;
+  void UpdateCallInfo(uint32 bbId, uint32 currPoint, const Insn &insn);
+  void ClassifyOperand(std::unordered_set<regno_t> &pregs, std::unordered_set<regno_t> &vregs,
+      const Operand &opnd) const;
+  void SetOpndConflict(const Insn &insn, bool onlyDef);
+  void UpdateOpndConflict(const Insn &insn, bool multiDef);
+  void SetLrMustAssign(const RegOperand *regOpnd);
+  void SetupMustAssignedLiveRanges(const Insn &insn);
+  void ComputeLiveRangesForEachDefOperand(Insn &insn, bool &multiDef);
+  void ComputeLiveRangesForEachUseOperand(Insn &insn);
+  void ComputeLiveRangesUpdateIfInsnIsCall(const Insn &insn);
+  void ComputeLiveRangesUpdateLiveUnitInsnRange(BB &bb, uint32 currPoint);
+  void ComputeLiveRanges();
+  MemOperand *CreateSpillMem(uint32 spillIdx, SpillMemCheck check);
+  bool CheckOverlap(uint64 val, uint32 i, LiveRange &lr1, LiveRange &lr2) const;
+  void CheckInterference(LiveRange &lr1, LiveRange &lr2) const;
+  void BuildInterferenceGraphSeparateIntFp(std::vector<LiveRange*> &intLrVec, std::vector<LiveRange*> &fpLrVec);
+  void BuildInterferenceGraph();
+  void SetBBInfoGlobalAssigned(uint32 bbID, regno_t regNO);
+  bool HaveAvailableColor(const LiveRange &lr, uint32 num) const;
+  void Separate();
+  void SplitAndColorForEachLr(MapleVector<LiveRange*> &targetLrVec);
+  void SplitAndColor();
+  void ColorForOptPrologEpilog();
+  bool IsLocalReg(regno_t regNO) const;
+  bool IsLocalReg(const LiveRange &lr) const;
+  void HandleLocalRaDebug(regno_t regNO, const LocalRegAllocator &localRa, bool isInt) const;
+  void HandleLocalRegAssignment(regno_t regNO, LocalRegAllocator &localRa, bool isInt);
+  void UpdateLocalRegDefUseCount(regno_t regNO, LocalRegAllocator &localRa, bool isDef) const;
+  void UpdateLocalRegConflict(regno_t regNO, const LocalRegAllocator &localRa);
+  void HandleLocalReg(Operand &op, LocalRegAllocator &localRa, const BBAssignInfo *bbInfo, bool isDef, bool isInt);
+  void LocalRaRegSetEraseReg(LocalRegAllocator &localRa, regno_t regNO) const;
+  bool LocalRaInitRegSet(LocalRegAllocator &localRa, uint32 bbId);
+  void LocalRaInitAllocatableRegs(LocalRegAllocator &localRa, uint32 bbId);
+  void LocalRaForEachDefOperand(const Insn &insn, LocalRegAllocator &localRa, const BBAssignInfo *bbInfo);
+  void LocalRaForEachUseOperand(const Insn &insn, LocalRegAllocator &localRa, const BBAssignInfo *bbInfo);
+  void LocalRaPrepareBB(BB &bb, LocalRegAllocator &localRa);
+  void LocalRaFinalAssignment(const LocalRegAllocator &localRa, BBAssignInfo &bbInfo);
+  void LocalRaDebug(const BB &bb, const LocalRegAllocator &localRa) const;
+  void LocalRegisterAllocator(bool doAllocate);
+  MemOperand *GetSpillOrReuseMem(LiveRange &lr, uint32 regSize, bool &isOutOfRange, Insn &insn, bool isDef);
+  void SpillOperandForSpillPre(Insn &insn, const Operand &opnd, RegOperand &phyOpnd, uint32 spillIdx, bool needSpill);
+  void SpillOperandForSpillPost(Insn &insn, const Operand &opnd, RegOperand &phyOpnd,
+                                uint32 spillIdx, bool needSpill);
+  MemOperand *GetConsistentReuseMem(const uint64 *conflict, const std::set<MemOperand*> &usedMemOpnd, uint32 size,
+                                    RegType regType);
+  MemOperand *GetCommonReuseMem(const uint64 *conflict, const std::set<MemOperand*> &usedMemOpnd, uint32 size,
+                                RegType regType);
+  MemOperand *GetReuseMem(uint32 vregNO, uint32 size, RegType regType);
+  MemOperand *GetSpillMem(uint32 vregNO, bool isDest, Insn &insn, regno_t regNO,
+                          bool &isOutOfRange);
+  bool SetAvailableSpillReg(std::unordered_set<regno_t> &cannotUseReg, LiveRange &lr,
+                            MapleBitVector &usedRegMask);
+  void CollectCannotUseReg(std::unordered_set<regno_t> &cannotUseReg, const LiveRange &lr, Insn &insn);
+  regno_t PickRegForSpill(MapleBitVector &usedRegMask, RegType regType, uint32 spillIdx,
+                          bool &needSpillLr);
+  bool SetRegForSpill(LiveRange &lr, Insn &insn, uint32 spillIdx, MapleBitVector &usedRegMask,
+                      bool isDef);
+  bool GetSpillReg(Insn &insn, LiveRange &lr, const uint32 &spillIdx, MapleBitVector &usedRegMask,
+                   bool isDef);
+  RegOperand *GetReplaceOpndForLRA(Insn &insn, const Operand &opnd, uint32 &spillIdx,
+                                   MapleBitVector &usedRegMask, bool isDef);
+  RegOperand *GetReplaceUseDefOpndForLRA(Insn &insn, const Operand &opnd, uint32 &spillIdx,
+                                         MapleBitVector &usedRegMask);
+  bool EncountPrevRef(const BB &pred, LiveRange &lr, bool isDef, std::vector<bool>& visitedMap);
+  bool FoundPrevBeforeCall(Insn &insn, LiveRange &lr, bool isDef);
+  bool EncountNextRef(const BB &succ, LiveRange &lr, bool isDef, std::vector<bool>& visitedMap);
+  bool FoundNextBeforeCall(Insn &insn, LiveRange &lr, bool isDef);
+  bool HavePrevRefInCurBB(Insn &insn, LiveRange &lr, bool &contSearch) const;
+  bool HaveNextDefInCurBB(Insn &insn, LiveRange &lr, bool &contSearch) const;
+  bool NeedCallerSave(Insn &insn, LiveRange &lr, bool isDef);
+  RegOperand *GetReplaceOpnd(Insn &insn, const Operand &opnd, uint32 &spillIdx,
+                             MapleBitVector &usedRegMask, bool isDef);
+  RegOperand *GetReplaceUseDefOpnd(Insn &insn, const Operand &opnd, uint32 &spillIdx,
+                                   MapleBitVector &usedRegMask);
+  void MarkCalleeSaveRegs();
+  void MarkUsedRegs(Operand &opnd, MapleBitVector &usedRegMask);
+  bool FinalizeRegisterPreprocess(FinalizeRegisterInfo &fInfo, const Insn &insn,
+                                  MapleBitVector &usedRegMask);
+  void SplitVregAroundLoop(const CGFuncLoops &loop, const std::vector<LiveRange*> &lrs,
+                           BB &headerPred, BB &exitSucc, const std::set<regno_t> &cands);
+  bool LoopNeedSplit(const CGFuncLoops &loop, std::set<regno_t> &cands);
+  bool LrGetBadReg(const LiveRange &lr) const;
+  void AnalysisLoopPressureAndSplit(const CGFuncLoops &loop);
+  void AnalysisLoop(const CGFuncLoops &loop);
+  void OptCallerSave();
+  void FinalizeRegisters();
+  void GenerateSpillFillRegs(const Insn &insn);
+  RegOperand *CreateSpillFillCode(const RegOperand &opnd, Insn &insn, uint32 spillCnt, bool isdef = false);
+  bool SpillLiveRangeForSpills();
+  void FinalizeSpSaveReg();
+
+  MapleVector<LiveRange*>::iterator GetHighPriorityLr(MapleVector<LiveRange*> &lrSet) const;
+  void UpdateForbiddenForNeighbors(const LiveRange &lr) const;
+  void UpdatePregvetoForNeighbors(const LiveRange &lr) const;
+  regno_t FindColorForLr(const LiveRange &lr) const;
+  regno_t TryToAssignCallerSave(const LiveRange &lr) const;
+  bool ShouldUseCallee(LiveRange &lr, const MapleSet<regno_t> &calleeUsed,
+                       const MapleVector<LiveRange*> &delayed) const;
+  void AddCalleeUsed(regno_t regNO, RegType regType);
+  bool AssignColorToLr(LiveRange &lr, bool isDelayed = false);
+  void PruneLrForSplit(LiveRange &lr, BB &bb, bool remove, std::set<CGFuncLoops*, CGFuncLoopCmp> &candidateInLoop,
+                       std::set<CGFuncLoops*, CGFuncLoopCmp> &defInLoop);
+  bool UseIsUncovered(const BB &bb, const BB &startBB, std::vector<bool> &visitedBB);
+  void FindUseForSplit(LiveRange &lr, SplitBBInfo &bbInfo, bool &remove,
+                       std::set<CGFuncLoops*, CGFuncLoopCmp> &candidateInLoop,
+                       std::set<CGFuncLoops*, CGFuncLoopCmp> &defInLoop);
+  void FindBBSharedInSplit(LiveRange &lr,
+                           const std::set<CGFuncLoops*, CGFuncLoopCmp> &candidateInLoop,
+                           std::set<CGFuncLoops*, CGFuncLoopCmp> &defInLoop);
+  void ComputeBBForNewSplit(LiveRange &newLr, LiveRange &origLr);
+  void ClearLrBBFlags(const std::set<BB*, SortedBBCmpFunc> &member) const;
+  void ComputeBBForOldSplit(LiveRange &newLr, LiveRange &origLr);
+  bool LrCanBeColored(const LiveRange &lr, const BB &bbAdded, std::unordered_set<regno_t> &conflictRegs);
+  void MoveLrBBInfo(LiveRange &oldLr, LiveRange &newLr, BB &bb) const;
+  bool ContainsLoop(const CGFuncLoops &loop, const std::set<CGFuncLoops*, CGFuncLoopCmp> &loops) const;
+  void GetAllLrMemberLoops(LiveRange &lr, std::set<CGFuncLoops*, CGFuncLoopCmp> &loops);
+  bool SplitLrShouldSplit(LiveRange &lr);
+  bool SplitLrFindCandidateLr(LiveRange &lr, LiveRange &newLr, std::unordered_set<regno_t> &conflictRegs);
+  void SplitLrHandleLoops(LiveRange &lr, LiveRange &newLr, const std::set<CGFuncLoops*, CGFuncLoopCmp> &origLoops,
+                          const std::set<CGFuncLoops*, CGFuncLoopCmp> &newLoops);
+  void SplitLrFixNewLrCallsAndRlod(LiveRange &newLr, const std::set<CGFuncLoops*, CGFuncLoopCmp> &origLoops);
+  void SplitLrFixOrigLrCalls(LiveRange &lr) const;
+  void SplitLrUpdateInterference(LiveRange &lr);
+  void SplitLrUpdateRegInfo(const LiveRange &origLr, LiveRange &newLr,
+                            std::unordered_set<regno_t> &conflictRegs) const ;
+  void SplitLrErrorCheckAndDebug(const LiveRange &origLr) const;
+  void SplitLr(LiveRange &lr);
+
+  static constexpr uint16 kMaxUint16 = 0x7fff;
+
+  DomAnalysis &domInfo;
+  MapleVector<BB*> bbVec;
+  MapleUnorderedSet<regno_t> vregLive;
+  MapleUnorderedSet<regno_t> pregLive;
+  MapleMap<regno_t, LiveRange*> lrMap;
+  MapleVector<LocalRaInfo*> localRegVec;  /* local reg info for each bb, no local reg if null */
+  MapleVector<BBAssignInfo*> bbRegInfo;   /* register assignment info for each bb */
+  MapleVector<LiveRange*> unconstrained;
+  MapleVector<LiveRange*> unconstrainedPref;
+  MapleVector<LiveRange*> constrained;
+  MapleVector<LiveRange*> mustAssigned;
+#ifdef OPTIMIZE_FOR_PROLOG
+  MapleVector<LiveRange*> intDelayed;
+  MapleVector<LiveRange*> fpDelayed;
+#endif                               /* OPTIMIZE_FOR_PROLOG  */
+  MapleSet<uint32> intCallerRegSet;  /* integer caller saved */
+  MapleSet<uint32> intCalleeRegSet;  /*         callee       */
+  MapleSet<uint32> intSpillRegSet;   /*         spill        */
+  MapleSet<uint32> fpCallerRegSet;   /* float caller saved   */
+  MapleSet<uint32> fpCalleeRegSet;   /*       callee         */
+  MapleSet<uint32> fpSpillRegSet;    /*       spill          */
+  MapleSet<regno_t> intCalleeUsed;
+  MapleSet<regno_t> fpCalleeUsed;
+  Bfs *bfs = nullptr;
+
+  uint32 bbBuckets = 0;   /* size of bit array for bb (each bucket == 64 bits) */
+  uint32 regBuckets = 0;  /* size of bit array for reg (each bucket == 64 bits) */
+  uint32 intRegNum = 0;   /* total available int preg */
+  uint32 fpRegNum = 0;    /* total available fp preg */
+  uint32 numVregs = 0;    /* number of vregs when starting */
+  /* For spilling of spill register if there are none available
+   *   Example, all 3 operands spilled
+   *                          sp_reg1 -> [spillMemOpnds[1]]
+   *                          sp_reg2 -> [spillMemOpnds[2]]
+   *                          ld sp_reg1 <- [addr-reg2]
+   *                          ld sp_reg2 <- [addr-reg3]
+   *   reg1 <- reg2, reg3     sp_reg1 <- sp_reg1, sp_reg2
+   *                          st sp_reg1 -> [addr-reg1]
+   *                          sp_reg1 <- [spillMemOpnds[1]]
+   *                          sp_reg2 <- [spillMemOpnds[2]]
+   */
+  std::array<MemOperand*, kSpillMemOpndNum> spillMemOpnds = { nullptr };
+  bool operandSpilled[kSpillMemOpndNum];
+  bool needExtraSpillReg = false;
+#ifdef USE_LRA
+  bool doLRA = true;
+#else
+  bool doLRA = false;
+#endif
+#ifdef OPTIMIZE_FOR_PROLOG
+  bool doOptProlog = true;
+#else
+  bool doOptProlog = false;
+#endif
+  bool hasSpill = false;
+  bool doMultiPass = false;
+};
+
+class CallerSavePre : public CGPre {
+ public:
+  CallerSavePre(GraphColorRegAllocator * regAlloc, CGFunc &cgfunc, DomAnalysis &currDom,
+                MemPool &memPool, MemPool &mp2, PreKind kind, uint32 limit)
+      : CGPre(currDom, memPool, mp2, kind, limit),
+        func(&cgfunc),
+        regAllocator(regAlloc),
+        loopHeadBBs(ssaPreAllocator.Adapter()) {}
+
+  ~CallerSavePre() = default;
+
+  void ApplySSAPRE();
+  void SetDump(bool val) {
+    dump = val;
+  }
+ private:
+  void CodeMotion() ;
+  void UpdateLoadSite(CgOccur *occ);
+  void CalLoadSites();
+  void ComputeAvail();
+  void Rename1();
+  void ComputeVarAndDfPhis() override;
+  void BuildWorkList() override;
+  void DumpWorkCandAndOcc();
+
+  BB *GetBB(uint32 id) const override {
+    return func->GetBBFromID(id);
+  }
+
+  PUIdx GetPUIdx() const override {
+    return func->GetFunction().GetPuidx();
+  }
+
+  bool IsLoopHeadBB(uint32 bbId) const {
+    return loopHeadBBs.find(bbId) != loopHeadBBs.end();
+  }
+  CGFunc *func;
+  bool dump = false;
+  LiveRange *workLr = nullptr;
+  GraphColorRegAllocator *regAllocator;
+  MapleSet<uint32> loopHeadBBs;
+  bool beyondLimit = false;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_COLOR_RA_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_data_dep_base.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_data_dep_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a90a4d25e7914d9ee963dfe21b22bb0fd88baa5
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_data_dep_base.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_DATA_DEP_BASE_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_DATA_DEP_BASE_H
+
+#include "aarch64_operand.h"
+#include "cgfunc.h"
+#include "data_dep_base.h"
+
+namespace maplebe {
+class AArch64DataDepBase : public DataDepBase {
+ public:
+  AArch64DataDepBase(MemPool &mp, CGFunc &func, MAD &mad) : DataDepBase(mp, func, mad) {}
+  ~AArch64DataDepBase() override = default;
+
+  void CombineClinit(DepNode &firstNode, DepNode &secondNode, bool isAcrossSeparator) override;
+  void CombineMemoryAccessPair(DepNode &firstNode, DepNode &secondNode, bool useFirstOffset) override;
+  bool IsFrameReg(const RegOperand &opnd) const override;
+  void AnalysisAmbiInsns(BB &bb) override;
+  void BuildDepsMemBar(Insn &insn) override;
+  void BuildDepsUseMem(Insn &insn, MemOperand &aarchMemOpnd) override;
+  void BuildDepsDefMem(Insn &insn, MemOperand &aarchMemOpnd) override;
+  void BuildDepsAccessStImmMem(Insn &insn, bool isDest) override;
+  void BuildCallerSavedDeps(Insn &insn) override;
+  void BuildStackPassArgsDeps(Insn &insn) override;
+  void BuildDepsDirtyStack(Insn &insn) override;
+  void BuildDepsUseStack(Insn &insn) override;
+  void BuildDepsDirtyHeap(Insn &insn) override;
+  void BuildOpndDependency(Insn &insn) override;
+  void BuildSpecialInsnDependency(Insn &insn, const MapleVector<DepNode*> &nodes) override;
+  void UpdateRegUseAndDef(Insn &insn, const DepNode &depNode, MapleVector<DepNode*> &nodes) override;
+  DepNode *BuildSeparatorNode() override;
+  void BuildInterBlockMemDefUseDependency(DepNode &depNode, MemOperand &memOpnd,
+                                          MemOperand *nextMemOpnd, bool isMemDef) override;
+  void BuildPredPathMemDefDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                        MemOperand &memOpnd, MemOperand *nextMemOpnd) override;
+  void BuildPredPathMemUseDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                        MemOperand &memOpnd, MemOperand *nextMemOpnd) override;
+
+  void BuildAntiDepsDefStackMem(Insn &insn, MemOperand &memOpnd, const MemOperand *nextMemOpnd);
+  bool NeedBuildDepsMem(const MemOperand &memOpnd,
+                        const MemOperand *nextMemOpnd, const Insn &memInsn) const;
+
+ protected:
+  MemOperand *GetNextMemOperand(const Insn &insn, const MemOperand &aarchMemOpnd) const;
+  void BuildMemOpndDependency(Insn &insn, Operand &opnd, const OpndDesc &regProp);
+  MemOperand *BuildNextMemOperandByByteSize(const MemOperand &aarchMemOpnd, uint32 byteSize) const;
+  void ReplaceDepNodeWithNewInsn(DepNode &firstNode, DepNode &secondNode, Insn& newInsn, bool isFromClinit) const;
+  void ClearDepNodeInfo(DepNode &depNode) const;
+};
+}
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_DATA_DEP_BASE_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_dce.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_dce.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d78f79cbae3d788e8916f3c967d6158fcf81bc0
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_dce.h
@@ -0,0 +1,42 @@
+/*
+* Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+    * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef MAPLEBE_INCLUDE_AARCH64_DCE_H
+#define MAPLEBE_INCLUDE_AARCH64_DCE_H
+
+#include "cg_dce.h"
+namespace maplebe {
+class AArch64Dce : public CGDce {
+ public:
+  AArch64Dce(MemPool &mp, CGFunc &f, CGSSAInfo &sInfo) : CGDce(mp, f, sInfo) {}
+  ~AArch64Dce() override = default;
+
+ private:
+  bool RemoveUnuseDef(VRegVersion &defVersion) override;
+};
+
+class A64DeleteRegUseVisitor : public DeleteRegUseVisitor {
+ public:
+  A64DeleteRegUseVisitor(CGSSAInfo &cgSSAInfo, uint32 dInsnID) : DeleteRegUseVisitor(cgSSAInfo, dInsnID) {}
+  ~A64DeleteRegUseVisitor() override = default;
+
+ private:
+  void Visit(RegOperand *v) final;
+  void Visit(ListOperand *v) final;
+  void Visit(MemOperand *v) final;
+  void Visit(PhiOperand *v) final;
+};
+}
+#endif /* MAPLEBE_INCLUDE_AARCH64_DCE_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_dependence.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_dependence.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8626fece0583d66a6c5383e0812341b53a6aca9
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_dependence.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_DEPENDENCE_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_DEPENDENCE_H
+
+#include "aarch64_operand.h"
+#include "cgfunc.h"
+#include "dependence.h"
+
+namespace maplebe {
+class AArch64DepAnalysis : public DepAnalysis {
+ public:
+  AArch64DepAnalysis(CGFunc &func, MemPool &mp, MAD &mad, bool beforeRA);
+
+  ~AArch64DepAnalysis() override = default;
+
+  void Run(BB &bb, MapleVector<DepNode *> &nodes) override;
+  const std::string &GetDepTypeName(DepType depType) const override;
+  void DumpDepNode(DepNode &node) const override;
+  void DumpDepLink(DepLink &link, const DepNode *node) const override;
+
+ protected:
+  void Init(BB &bb, MapleVector<DepNode *> &nodes) override;
+  void ClearAllDepData() override;
+  void AnalysisAmbiInsns(BB &bb) override;
+  void AppendRegUseList(Insn &insn, regno_t regNO) override;
+  void AddDependence(DepNode &fromNode, DepNode &toNode, DepType depType) override;
+  void RemoveSelfDeps(Insn &insn) override;
+  void CombineClinit(DepNode &firstNode, DepNode &secondNode, bool isAcrossSeparator) override;
+  void CombineDependence(DepNode &firstNode, DepNode &secondNode, bool isAcrossSeparator,
+                         bool isMemCombine = false) override;
+  void CombineMemoryAccessPair(DepNode &firstNode, DepNode &secondNode, bool useFirstOffset) override;
+  void BuildDepsUseReg(Insn &insn, regno_t regNO) override;
+  void BuildDepsDefReg(Insn &insn, regno_t regNO) override;
+  void BuildDepsAmbiInsn(Insn &insn) override;
+  void BuildDepsMayThrowInsn(Insn &insn) override;
+  bool NeedBuildDepsMem(const MemOperand &memOpnd, const MemOperand *nextMemOpnd, const Insn &memInsn) const;
+  void BuildDepsUseMem(Insn &insn, MemOperand &aarchMemOpnd) override;
+  void BuildDepsDefMem(Insn &insn, MemOperand &aarchMemOpnd) override;
+  void BuildAntiDepsDefStackMem(Insn &insn, MemOperand &memOpnd, const MemOperand *nextMemOpnd);
+  void BuildOutputDepsDefStackMem(Insn &insn, MemOperand &memOpnd, const MemOperand *nextMemOpnd);
+  void BuildDepsMemBar(Insn &insn) override;
+  void BuildDepsSeparator(DepNode &newSepNode, MapleVector<DepNode *> &nodes) override;
+  void BuildDepsControlAll(DepNode &depNode, const MapleVector<DepNode *> &nodes) override;
+  void BuildDepsAccessStImmMem(Insn &insn, bool isDest) override;
+  void BuildCallerSavedDeps(Insn &insn) override;
+  void BuildDepsBetweenControlRegAndCall(Insn &insn, bool isDest) override;
+  void BuildStackPassArgsDeps(Insn &insn) override;
+  void BuildDepsDirtyStack(Insn &insn) override;
+  void BuildDepsUseStack(Insn &insn) override;
+  void BuildDepsDirtyHeap(Insn &insn) override;
+  DepNode *BuildSeparatorNode() override;
+  bool IfInAmbiRegs(regno_t regNO) const override;
+  bool IsFrameReg(const RegOperand &opnd) const override;
+
+ private:
+  MemOperand *GetNextMemOperand(const Insn &insn, const MemOperand &aarchMemOpnd) const;
+  void BuildMemOpndDependency(Insn &insn, Operand &opnd, const OpndDesc &regProp);
+  void BuildOpndDependency(Insn &insn);
+  void BuildSpecialInsnDependency(Insn &insn, DepNode &depNode, const MapleVector<DepNode *> &nodes);
+  void SeperateDependenceGraph(MapleVector<DepNode *> &nodes, uint32 &nodeSum);
+  DepNode *GenerateDepNode(Insn &insn, MapleVector<DepNode *> &nodes, int32 nodeSum,
+                           const MapleVector<Insn *> &comments);
+  void BuildAmbiInsnDependency(Insn &insn);
+  void BuildMayThrowInsnDependency(Insn &insn);
+  void UpdateRegUseAndDef(Insn &insn, const DepNode &depNode, MapleVector<DepNode *> &nodes);
+  void UpdateStackAndHeapDependency(DepNode &depNode, Insn &insn, const Insn &locInsn);
+  MemOperand *BuildNextMemOperandByByteSize(const MemOperand &aarchMemOpnd, uint32 byteSize) const;
+  void AddDependence4InsnInVectorByType(MapleVector<Insn *> &insns, Insn &insn, const DepType &type);
+  void AddDependence4InsnInVectorByTypeAndCmp(MapleVector<Insn *> &insns, Insn &insn, const DepType &type);
+  void ReplaceDepNodeWithNewInsn(DepNode &firstNode, DepNode &secondNode, Insn &newInsn, bool isFromClinit) const;
+  void ClearDepNodeInfo(DepNode &depNode) const;
+  void AddEndSeparatorNode(MapleVector<DepNode *> &nodes);
+
+  Insn **regDefs = nullptr;
+  RegList **regUses = nullptr;
+  Insn *memBarInsn = nullptr;
+  bool hasAmbiRegs = false;
+  Insn *lastCallInsn = nullptr;
+  uint32 separatorIndex = 0;
+  Insn *lastFrameDef = nullptr;
+  MapleVector<Insn *> stackUses;
+  MapleVector<Insn *> stackDefs;
+  MapleVector<Insn *> heapUses;
+  MapleVector<Insn *> heapDefs;
+  MapleVector<Insn *> mayThrows;
+  /* instructions that can not across may throw instructions. */
+  MapleVector<Insn *> ambiInsns;
+  /* register number that catch bb and cleanup bb uses. */
+  MapleSet<regno_t> ehInRegs;
+  /* the bb to be scheduling currently */
+  BB *curBB = nullptr;
+};
+}  // namespace maplebe
+
+#endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_DEPENDENCE_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_ebo.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ebo.h
new file mode 100644
index 0000000000000000000000000000000000000000..224ca456a8c15d75391930fe8f9025535fa846cf
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ebo.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_EBO_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_EBO_H
+
+#include "ebo.h"
+#include "aarch64_operand.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+
+class AArch64Ebo : public Ebo {
+ public:
+  AArch64Ebo(CGFunc &func, MemPool &memPool, LiveAnalysis *live, bool before, const std::string &phase)
+      : Ebo(func, memPool, live, before, phase),
+        callerSaveRegTable(eboAllocator.Adapter()) {
+    a64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  }
+
+  enum ExtOpTable : uint8;
+
+  ~AArch64Ebo() override = default;
+
+ protected:
+  MapleVector<RegOperand*> callerSaveRegTable;
+  AArch64CGFunc *a64CGFunc = nullptr;
+  int32 GetOffsetVal(const MemOperand &memOpnd) const override;
+  OpndInfo *OperandInfoDef(BB &currentBB, Insn &currentInsn, Operand &localOpnd) override;
+  const RegOperand &GetRegOperand(const Operand &opnd) const override;
+  bool IsGlobalNeeded(Insn &insn) const override;
+  bool IsDecoupleStaticOp(Insn &insn) const override;
+  bool OperandEqSpecial(const Operand &op1, const Operand &op2) const override;
+  bool DoConstProp(Insn &insn, uint32 idx, Operand &opnd) override;
+  bool Csel2Cset(Insn &insn, const MapleVector<Operand*> &opnds) override;
+  bool SimplifyConstOperand(Insn &insn, const MapleVector<Operand*> &opnds,
+                            const MapleVector<OpndInfo*> &opndInfo) override;
+  void BuildCallerSaveRegisters() override;
+  void DefineAsmRegisters(InsnInfo &insnInfo) override;
+  void DefineCallerSaveRegisters(InsnInfo &insnInfo) override;
+  void DefineReturnUseRegister(Insn &insn) override;
+  void DefineCallUseSpecialRegister(Insn &insn) override;
+  void DefineClinitSpecialRegisters(InsnInfo &insnInfo) override;
+  bool CombineExtensionAndLoad(Insn *insn, const MapleVector<OpndInfo*> &origInfos,
+                               ExtOpTable idx, bool is64bits) const;
+  bool SpecialSequence(Insn &insn, const MapleVector<OpndInfo*> &origInfos) override;
+  bool IsMovToSIMDVmov(Insn &insn, const Insn &replaceInsn) const override;
+  bool IsPseudoRet(Insn &insn) const override;
+  bool ChangeLdrMop(Insn &insn, const Operand &opnd) const override;
+  bool IsAdd(const Insn &insn) const override;
+  bool IsFmov(const Insn &insn) const override;
+  bool IsClinitCheck(const Insn &insn) const override;
+  bool IsLastAndBranch(BB &bb, Insn &insn) const override;
+  bool IsSameRedefine(BB &bb, Insn &insn, OpndInfo &opndInfo) const override;
+  bool ResIsNotDefAndUse(Insn &insn) const override;
+  bool LiveOutOfBB(const Operand &opnd, const BB &bb) const override;
+  bool IsInvalidReg(const RegOperand &opnd) const override;
+  bool IsZeroRegister(const Operand &opnd) const override;
+  bool IsConstantImmOrReg(const Operand &opnd) const override;
+  bool OperandLiveAfterInsn(const RegOperand &regOpnd, Insn &insn) const;
+  bool ValidPatternForCombineExtAndLoad(OpndInfo *prevOpndInfo, Insn *insn, MOperator newMop, MOperator oldMop,
+                                        const RegOperand& opnd) const;
+
+ private:
+  /* The number of elements in callerSaveRegTable must less then 45. */
+  static constexpr int32 kMaxCallerSaveReg = 45;
+  MOperator ExtLoadSwitchBitSize(MOperator lowMop) const;
+  bool CheckCondCode(const CondOperand &cond) const;
+  bool CombineMultiplyAdd(Insn *insn, const Insn *prevInsn, InsnInfo *insnInfo, Operand *addOpnd,
+                          bool is64bits, bool isFp) const;
+  bool CheckCanDoMadd(Insn *insn, OpndInfo *opndInfo, int32 pos, bool is64bits, bool isFp) const;
+  bool CombineMultiplySub(Insn *insn, OpndInfo *opndInfo, bool is64bits, bool isFp) const;
+  bool CombineMultiplyNeg(Insn *insn, OpndInfo *opndInfo, bool is64bits, bool isFp) const;
+  bool SimplifyBothConst(BB &bb, Insn &insn, const ImmOperand &immOperand0, const ImmOperand &immOperand1,
+                         uint32 opndSize) const;
+  ConditionCode GetReverseCond(const CondOperand &cond) const;
+  bool CombineLsrAnd(Insn &insn, const OpndInfo &opndInfo, bool is64bits, bool isFp) const;
+  bool CombineExtAnd(Insn &insn, const OpndInfo &opndInfo, bool isFp, int64 immVal) const;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_EBO_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_emitter.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..d34cbd4b6e3ed07f53c62ff335e2769c8bdc71b0
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_emitter.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_EMITTER_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_EMITTER_H
+
+#include "asm_emit.h"
+
+namespace maplebe {
+using namespace maple;
+
+class AArch64AsmEmitter : public AsmEmitter {
+ public:
+  AArch64AsmEmitter(CG &cg, const std::string &asmFileName) : AsmEmitter(cg, asmFileName) {}
+  ~AArch64AsmEmitter() = default;
+
+  void EmitRefToMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) override;
+  void EmitRefToMethodInfo(FuncEmitInfo &funcEmitInfo, Emitter &emitter) override;
+  void EmitMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) override;
+  void EmitFastLSDA(FuncEmitInfo &funcEmitInfo) override;
+  void EmitFullLSDA(FuncEmitInfo &funcEmitInfo) override;
+  void EmitBBHeaderLabel(FuncEmitInfo &funcEmitInfo, const std::string &name, LabelIdx labIdx) override;
+  void EmitJavaInsnAddr(FuncEmitInfo &funcEmitInfo) override;
+  void RecordRegInfo(FuncEmitInfo &funcEmitInfo) const;
+  void Run(FuncEmitInfo &funcEmitInfo) override;
+
+ private:
+  /* cfi & dbg need target info ? */
+  void EmitAArch64CfiInsn(Emitter &emitter, const Insn &insn) const;
+  void EmitAArch64DbgInsn(FuncEmitInfo &funcEmitInfo, Emitter &emitter, const Insn &insn) const;
+
+  void EmitAArch64Insn(Emitter &emitter, Insn &insn) const;
+  void EmitClinit(Emitter &emitter, const Insn &insn) const;
+  void EmitAdrpLdr(Emitter &emitter, const Insn &insn) const;
+  void EmitCounter(Emitter &emitter, const Insn &insn) const;
+  void EmitCCounter(Emitter &emitter, const Insn &insn) const;
+  void EmitInlineAsm(Emitter &emitter, const Insn &insn) const;
+  void EmitClinitTail(Emitter &emitter, const Insn &insn) const;
+  void EmitLazyLoad(Emitter &emitter, const Insn &insn) const;
+  void EmitAdrpLabel(Emitter &emitter, const Insn &insn) const;
+  void EmitLazyLoadStatic(Emitter &emitter, const Insn &insn) const;
+  void EmitArrayClassCacheLoad(Emitter &emitter, const Insn &insn) const;
+  void EmitGetAndAddInt(Emitter &emitter, const Insn &insn) const;
+  void EmitGetAndSetInt(Emitter &emitter, const Insn &insn) const;
+  void EmitCompareAndSwapInt(Emitter &emitter, const Insn &insn) const;
+  void EmitStringIndexOf(Emitter &emitter, const Insn &insn) const;
+  void EmitLazyBindingRoutine(Emitter &emitter, const Insn &insn) const;
+  void EmitCheckThrowPendingException(Emitter &emitter) const;
+  void EmitCTlsDescRel(Emitter &emitter, const Insn &insn) const;
+  void EmitCTlsDescCall(Emitter &emitter, const Insn &insn) const;
+  void EmitSyncLockTestSet(Emitter &emitter, const Insn &insn) const;
+
+  void PrepareVectorOperand(RegOperand *regOpnd, uint32 &compositeOpnds, Insn &insn) const;
+  bool CheckInsnRefField(const Insn &insn, size_t opndIndex) const;
+};
+}  /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_EMITTER_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_fixshortbranch.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_fixshortbranch.h
new file mode 100644
index 0000000000000000000000000000000000000000..8fd3b9fdaf445739fce944758f720352983ea3a3
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_fixshortbranch.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_FIXSHORTBRANCH_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_FIXSHORTBRANCH_H
+
+#include "aarch64_cg.h"
+#include "optimize_common.h"
+#include "mir_builder.h"
+
+namespace maplebe {
+class AArch64FixShortBranch {
+ public:
+  explicit AArch64FixShortBranch(CGFunc *cf) : cgFunc(cf) {}
+  ~AArch64FixShortBranch() = default;
+  void FixShortBranches() const;
+
+ private:
+  CGFunc *cgFunc = nullptr;
+  uint32 CalculateAlignRange(const BB &bb, uint32 addr) const;
+  void SetInsnId() const;
+};  /* class AArch64ShortBranch */
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgFixShortBranch, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_FIXSHORTBRANCH_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_fp_simd_regs.def b/src/mapleall/maple_be/include/cg/aarch64/aarch64_fp_simd_regs.def
new file mode 100644
index 0000000000000000000000000000000000000000..c630b95c7775a55522b66f291463b7133a0007cd
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_fp_simd_regs.def
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/*
+ * ARM Compiler armasm User Guide version 6.6.
+ * http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0473j/deb1353594352617.html
+ * (retrieved on 3/24/2017)
+ */
+/*
+ * ID, 128 bit vector prefix, followed by scalar prefixes
+ * scalar prefixes: 8-bit, 16-bit, 32-bit, 64-bit, 128-bit, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill
+ * (e.g., we use D0 when V0 contains a 64-bit scalar FP number (aka, double))
+ */
+FP_SIMD_REG(0 , "V", "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(1 , "V", "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(2 , "V", "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(3 , "V", "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(4 , "V", "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(5 , "V", "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(6 , "V", "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(7 , "V", "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(8 , "V", "B", "H", "S", "D", "Q", true, true, false, false, false)
+FP_SIMD_REG(9 , "V", "B", "H", "S", "D", "Q", true, true, false, false, false)
+FP_SIMD_REG(10, "V", "B", "H", "S", "D", "Q", true, true, false, false, false)
+FP_SIMD_REG(11, "V", "B", "H", "S", "D", "Q", true, true, false, false, false)
+FP_SIMD_REG(12, "V", "B", "H", "S", "D", "Q", true, true, false, false, false)
+FP_SIMD_REG(13, "V", "B", "H", "S", "D", "Q", true, true, false, false, false)
+FP_SIMD_REG(14, "V", "B", "H", "S", "D", "Q", true, true, false, false, false)
+FP_SIMD_REG(15, "V", "B", "H", "S", "D", "Q", true, true, false, false, false)
+FP_SIMD_REG(16, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(17, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(18, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(19, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(20, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(21, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(22, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(23, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(24, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(25, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(26, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(27, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(28, "V", "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(29, "V", "B", "H", "S", "D", "Q", true, false, false, false, true)
+FP_SIMD_REG(30, "V", "B", "H", "S", "D", "Q", true, false, false, true, false)
+FP_SIMD_REG(31, "V", "B", "H", "S", "D", "Q", true, false, false, true, false)
+
+/* Alias ID */
+FP_SIMD_REG_ALIAS(0)
+FP_SIMD_REG_ALIAS(1)
+FP_SIMD_REG_ALIAS(2)
+FP_SIMD_REG_ALIAS(3)
+FP_SIMD_REG_ALIAS(4)
+FP_SIMD_REG_ALIAS(5)
+FP_SIMD_REG_ALIAS(6)
+FP_SIMD_REG_ALIAS(7)
+
+/* FP_SIMD_REG_ALIAS_64BIT_SCALAR(0) */
+/* FP_SIMD_REG_ALIAS_64BIT_SCALAR(1) */
+/* FP_SIMD_REG_ALIAS_64BIT_SCALAR(2) */
+/* FP_SIMD_REG_ALIAS_64BIT_SCALAR(3) */
+/* FP_SIMD_REG_ALIAS_64BIT_SCALAR(4) */
+/* FP_SIMD_REG_ALIAS_64BIT_SCALAR(5) */
+/* FP_SIMD_REG_ALIAS_64BIT_SCALAR(6) */
+/* FP_SIMD_REG_ALIAS_64BIT_SCALAR(7) */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_global.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_global.h
new file mode 100644
index 0000000000000000000000000000000000000000..dea57f8a82c2d00aea5339e480f96a0cff7e86c9
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_global.h
@@ -0,0 +1,484 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_GLOBAL_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_GLOBAL_H
+
+#include "aarch64_opt_utiles.h"
+#include "global.h"
+#include "aarch64_operand.h"
+
+namespace maplebe {
+using namespace maple;
+
+class AArch64GlobalOpt : public GlobalOpt {
+ public:
+  explicit AArch64GlobalOpt(CGFunc &func) : GlobalOpt(func) {}
+  ~AArch64GlobalOpt() override = default;
+  void Run() override;
+};
+
+class OptimizeManager {
+ public:
+  explicit OptimizeManager(CGFunc &cgFunc) : cgFunc(cgFunc) {}
+  ~OptimizeManager() = default;
+  template<typename OptimizePattern>
+  void Optimize() {
+    OptimizePattern optPattern(cgFunc);
+    optPattern.Run();
+  }
+ private:
+  CGFunc &cgFunc;
+};
+
+class OptimizePattern {
+ public:
+  explicit OptimizePattern(CGFunc &cgFunc) : cgFunc(cgFunc) {}
+  virtual ~OptimizePattern() = default;
+  virtual bool CheckCondition(Insn &insn) = 0;
+  virtual void Optimize(Insn &insn) = 0;
+  virtual void Run() = 0;
+  bool OpndDefByOne(Insn &insn, int32 useIdx) const;
+  bool OpndDefByZero(Insn &insn, int32 useIdx) const;
+  bool OpndDefByOneOrZero(Insn &insn, int32 useIdx) const;
+  void ReplaceAllUsedOpndWithNewOpnd(const InsnSet &useInsnSet, uint32 regNO,
+                                     Operand &newOpnd, bool updateInfo) const;
+
+  static bool InsnDefOne(const Insn &insn);
+  static bool InsnDefZero(const Insn &insn);
+  static bool InsnDefOneOrZero(const Insn &insn);
+
+  std::string PhaseName() const {
+    return "globalopt";
+  }
+ protected:
+  virtual void Init() = 0;
+  CGFunc &cgFunc;
+};
+
+/*
+ * Do Forward prop when insn is mov
+ * mov xx, x1
+ * ... // BBs and x1 is live
+ * mOp yy, xx
+ *
+ * =>
+ * mov x1, x1
+ * ... // BBs and x1 is live
+ * mOp yy, x1
+ */
+class ForwardPropPattern : public OptimizePattern {
+ public:
+  explicit ForwardPropPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~ForwardPropPattern() override = default;
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+ private:
+  InsnSet firstRegUseInsnSet;
+  void RemoveMopUxtwToMov(Insn &insn);
+  bool IsUseInsnSetValid(Insn &insn, regno_t firstRegNO, regno_t secondRegNO);
+  std::set<BB*, BBIdCmp> modifiedBB;
+};
+
+/*
+ * Do back propagate of vreg/preg when encount following insn:
+ *
+ * mov vreg/preg1, vreg2
+ *
+ * back propagate reg1 to all vreg2's use points and def points, when all of them is in same bb
+ */
+class BackPropPattern : public OptimizePattern {
+ public:
+  explicit BackPropPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~BackPropPattern() override {
+    firstRegOpnd = nullptr;
+    secondRegOpnd = nullptr;
+    defInsnForSecondOpnd = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+
+ private:
+  bool CheckAndGetOpnd(const Insn &insn);
+  bool DestOpndHasUseInsns(Insn &insn);
+  bool DestOpndLiveOutToEHSuccs(Insn &insn) const;
+  bool CheckSrcOpndDefAndUseInsns(Insn &insn);
+  bool CheckSrcOpndDefAndUseInsnsGlobal(Insn &insn);
+  bool CheckPredefineInsn(Insn &insn);
+  bool CheckRedefineInsn(Insn &insn);
+  bool CheckReplacedUseInsn(Insn &insn);
+  RegOperand *firstRegOpnd = nullptr;
+  RegOperand *secondRegOpnd = nullptr;
+  uint32 firstRegNO = 0;
+  uint32 secondRegNO = 0;
+  InsnSet srcOpndUseInsnSet;
+  Insn *defInsnForSecondOpnd = nullptr;
+  bool globalProp = false;
+};
+
+/*
+ *  when w0 has only one valid bit, these tranformation will be done
+ *  cmp  w0, #0
+ *  cset w1, NE --> mov w1, w0
+ *
+ *  cmp  w0, #0
+ *  cset w1, EQ --> eor w1, w0, 1
+ *
+ *  cmp  w0, #1
+ *  cset w1, NE --> eor w1, w0, 1
+ *
+ *  cmp  w0, #1
+ *  cset w1, EQ --> mov w1, w0
+ *
+ *  cmp w0,  #0
+ *  cset w0, NE -->null
+ *
+ *  cmp w0, #1
+ *  cset w0, EQ -->null
+ *
+ *  condition:
+ *    1. the first operand of cmp instruction must has only one valid bit
+ *    2. the second operand of cmp instruction must be 0 or 1
+ *    3. flag register of cmp isntruction must not be used later
+ */
+class CmpCsetPattern : public OptimizePattern {
+ public:
+  explicit CmpCsetPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~CmpCsetPattern() override {
+    nextInsn = nullptr;
+    cmpFirstOpnd = nullptr;
+    cmpSecondOpnd = nullptr;
+    csetFirstOpnd = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+
+ private:
+  Insn *nextInsn = nullptr;
+  int64 cmpConstVal  = 0;
+  Operand *cmpFirstOpnd = nullptr;
+  Operand *cmpSecondOpnd = nullptr;
+  Operand *csetFirstOpnd = nullptr;
+};
+
+/*
+ * mov w5, #1
+ *  ...                   --> cset w5, NE
+ * mov w0, #0
+ * csel w5, w5, w0, NE
+ *
+ * mov w5, #0
+ *  ...                   --> cset w5,EQ
+ * mov w0, #1
+ * csel w5, w5, w0, NE
+ *
+ * condition:
+ *    1.all define points of w5 are defined by:   mov w5, #1(#0)
+ *    2.all define points of w0 are defined by:   mov w0, #0(#1)
+ *    3.w0 will not be used after: csel w5, w5, w0, NE(EQ)
+ */
+class CselPattern : public OptimizePattern {
+ public:
+  explicit CselPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~CselPattern() override = default;
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final {}
+};
+
+/*
+ * uxtb  w0, w0    -->   null
+ * uxth  w0, w0    -->   null
+ *
+ * condition:
+ * 1. validbits(w0)<=8,16,32
+ * 2. the first operand is same as the second operand
+ *
+ * uxtb  w0, w1    -->   null
+ * uxth  w0, w1    -->   null
+ *
+ * condition:
+ * 1. validbits(w1)<=8,16,32
+ * 2. the use points of w0 has only one define point, that is uxt w0, w1
+ */
+class RedundantUxtPattern : public OptimizePattern {
+ public:
+  explicit RedundantUxtPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~RedundantUxtPattern() override {
+    secondOpnd = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+
+ private:
+  uint32 GetMaximumValidBit(Insn &insn, uint8 index, InsnSet &visitedInsn) const;
+  static uint32 GetInsnValidBit(const Insn &insn);
+  InsnSet useInsnSet;
+  uint32 firstRegNO = 0;
+  Operand *secondOpnd = nullptr;
+};
+
+/*
+ *  bl  MCC_NewObj_flexible_cname                              bl  MCC_NewObj_flexible_cname
+ *  mov x21, x0   //  [R203]
+ *  str x0, [x29,#16]   // local var: Reg0_R6340 [R203]  -->   str x0, [x29,#16]   // local var: Reg0_R6340 [R203]
+ *  ... (has call)                                             ... (has call)
+ *  mov x2, x21  // use of x21                                 ldr x2, [x29, #16]
+ *  bl ***                                                     bl ***
+ */
+class LocalVarSaveInsnPattern : public OptimizePattern {
+ public:
+  explicit LocalVarSaveInsnPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~LocalVarSaveInsnPattern() override {
+    firstInsnSrcOpnd = nullptr;
+    firstInsnDestOpnd = nullptr;
+    secondInsnSrcOpnd = nullptr;
+    secondInsnDestOpnd = nullptr;
+    useInsn = nullptr;
+    secondInsn = nullptr;
+  }
+  bool CheckCondition(Insn &firstInsn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+
+ private:
+  bool CheckFirstInsn(const Insn &firstInsn);
+  bool CheckSecondInsn();
+  bool CheckAndGetUseInsn(Insn &firstInsn);
+  bool CheckLiveRange(const Insn &firstInsn);
+  Operand *firstInsnSrcOpnd = nullptr;
+  Operand *firstInsnDestOpnd = nullptr;
+  Operand *secondInsnSrcOpnd = nullptr;
+  Operand *secondInsnDestOpnd = nullptr;
+  Insn *useInsn = nullptr;
+  Insn *secondInsn = nullptr;
+};
+
+class ExtendShiftOptPattern : public OptimizePattern {
+ public:
+  explicit ExtendShiftOptPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~ExtendShiftOptPattern() override {
+    defInsn = nullptr;
+    newInsn = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+  void DoExtendShiftOpt(Insn &insn);
+
+ protected:
+  void Init() final;
+
+ private:
+  void SelectExtendOrShift(const Insn &def);
+  bool CheckDefUseInfo(Insn &use, uint32 size);
+  SuffixType CheckOpType(const Operand &lastOpnd) const;
+  void ReplaceUseInsn(Insn &use, const Insn &def, uint32 amount);
+  void SetExMOpType(const Insn &use);
+  void SetLsMOpType(const Insn &use);
+
+  MOperator replaceOp = 0;
+  uint32 replaceIdx = 0;
+  ExtendShiftOperand::ExtendOp extendOp = ExtendShiftOperand::kUndef;
+  BitShiftOperand::ShiftOp shiftOp = BitShiftOperand::kUndef;
+  Insn *defInsn = nullptr;
+  Insn *newInsn = nullptr;
+  bool optSuccess = false;
+  bool removeDefInsn = false;
+  ExMOpType exMOpType = kExUndef;
+  LsMOpType lsMOpType = kLsUndef;
+};
+
+/*
+ * This pattern do:
+ * 1)
+ * uxtw vreg:Rm validBitNum:[64], vreg:Rn validBitNum:[32]
+ * ------>
+ * mov vreg:Rm validBitNum:[64], vreg:Rn validBitNum:[32]
+ * 2)
+ * ldrh  R201, [...]
+ * and R202, R201, #65520
+ * uxth  R203, R202
+ * ------->
+ * ldrh  R201, [...]
+ * and R202, R201, #65520
+ * mov  R203, R202
+ */
+class ExtenToMovPattern : public OptimizePattern {
+ public:
+  explicit ExtenToMovPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~ExtenToMovPattern() override = default;
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+
+ private:
+  bool CheckHideUxtw(const Insn &insn, regno_t regno) const;
+  bool CheckUxtw(Insn &insn);
+  bool BitNotAffected(Insn &insn, uint32 validNum); /* check whether significant bits are affected */
+  bool CheckSrcReg(Insn &insn, regno_t srcRegNo, uint32 validNum, std::vector<Insn *> &checkedInsns);
+
+  MOperator replaceMop = MOP_undef;
+};
+
+class SameDefPattern : public OptimizePattern {
+ public:
+  explicit SameDefPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~SameDefPattern() override {
+    currInsn = nullptr;
+    sameInsn = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+
+ private:
+  bool IsSameDef();
+  bool SrcRegIsRedefined(regno_t regNo);
+  bool IsSameOperand(Operand &opnd0, Operand &opnd1);
+
+  Insn *currInsn = nullptr;
+  Insn *sameInsn = nullptr;
+};
+
+/*
+ * and r0, r0, #4        (the imm is n power of 2)
+ * ...                   (r0 is not used)
+ * cbz r0, .Label
+ * ===>  tbz r0, #2, .Label
+ *
+ * and r0, r0, #4        (the imm is n power of 2)
+ * ...                   (r0 is not used)
+ * cbnz r0, .Label
+ * ===>  tbnz r0, #2, .Label
+ */
+class AndCbzPattern : public OptimizePattern {
+ public:
+  explicit AndCbzPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~AndCbzPattern() override {
+    prevInsn = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+
+ private:
+  int64 CalculateLogValue(int64 val) const;
+  bool IsAdjacentArea(Insn &prev, Insn &curr) const;
+  Insn *prevInsn = nullptr;
+};
+
+/*
+ * [arithmetic operation]
+ * add/sub/ R202, R201, #1            add/sub/ R202, R201, #1
+ * ...                           ...
+ * add/sub/ R203, R201, #1    --->    mov R203, R202
+ *
+ * [copy operation]
+ * mov R201, #1                  mov R201, #1
+ * ...                           ...
+ * mov R202, #1          --->    mov R202, R201
+ *
+ * The pattern finds the insn with the same rvalue as the current insn,
+ * then prop its lvalue, and replaces the current insn with movrr insn.
+ * The mov can be prop in forwardprop or backprop.
+ *
+ * conditions:
+ * 1. in same BB
+ * 2. rvalue is not defined between two insns
+ * 3. lvalue is not defined between two insns
+ */
+class SameRHSPropPattern : public OptimizePattern {
+ public:
+  explicit SameRHSPropPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  ~SameRHSPropPattern() override {
+    prevInsn = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+
+ private:
+  bool IsSameOperand(Operand *opnd1, Operand *opnd2) const;
+  bool FindSameRHSInsnInBB(Insn &insn);
+  Insn *prevInsn = nullptr;
+  std::vector<MOperator> candidates;
+};
+
+/*
+ * ldr  r0, [r19, 8]
+ * ldrh r1, [r19, 16]
+ * ldrh r2, [r19, 18]      (r0,r1,r2 are call parameters)
+ * ====>
+ * ldp  x0, x1 [r19, 8]
+ * ubfx x2, x1, 16, 16
+ *
+ * we do this pattern because parameters can be passed without the unused high bit is cleared
+ */
+class ContinuousLdrPattern : public OptimizePattern {
+ public:
+  explicit ContinuousLdrPattern(CGFunc &cgFunc) : OptimizePattern(cgFunc) {}
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final {}
+
+ private:
+  static bool IsMopMatch(const Insn &insn);
+  bool IsUsedBySameCall(Insn &insn1, Insn &insn2, Insn &insn3) const;
+  static bool IsMemValid(const MemOperand &memopnd);
+  static bool IsImmValid(MOperator mop, const ImmOperand &imm);
+  static int64 GetMemOffsetValue(const Insn &insn);
+
+  std::vector<Insn *> insnList;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_GLOBAL_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_ico.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ico.h
new file mode 100755
index 0000000000000000000000000000000000000000..1d198f420c42fc59ac1cab2d0b6e343bb5d6cc17
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ico.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ICO_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ICO_H
+#include "ico.h"
+#include "aarch64_isa.h"
+#include "optimize_common.h"
+#include "live.h"
+
+namespace maplebe {
+class AArch64IfConversionOptimizer : public IfConversionOptimizer {
+ public:
+  AArch64IfConversionOptimizer(CGFunc &func, MemPool &memPool) : IfConversionOptimizer(func, memPool) {}
+
+  ~AArch64IfConversionOptimizer() override = default;
+  void InitOptimizePatterns() override;
+};
+
+class AArch64ICOPattern : public ICOPattern {
+ public:
+  explicit AArch64ICOPattern(CGFunc &func) : ICOPattern(func) {}
+  ~AArch64ICOPattern() override = default;
+ protected:
+  ConditionCode Encode(MOperator mOp, bool inverse) const;
+  Insn *BuildCmpInsn(const Insn &condBr) const;
+  Insn *BuildCcmpInsn(ConditionCode ccCode, const Insn *cmpInsn) const;
+  Insn *BuildCondSet(const Insn &branch, RegOperand &reg, bool inverse) const;
+  Insn *BuildCondSel(const Insn &branch, MOperator mOp, RegOperand &dst, RegOperand &src1, RegOperand &src2) const;
+  static uint32 GetNZCV(ConditionCode ccCode, bool inverse);
+  bool CheckMop(MOperator mOperator) const;
+};
+
+/* If-Then-Else pattern */
+class AArch64ICOIfThenElsePattern : public AArch64ICOPattern {
+ public:
+  enum DefUseKind : uint8 {
+    kUse,
+    kDef,
+    KUseOrDef
+  };
+
+  explicit AArch64ICOIfThenElsePattern(CGFunc &func) : AArch64ICOPattern(func) {}
+  ~AArch64ICOIfThenElsePattern() override = default;
+  bool Optimize(BB &curBB) override;
+ protected:
+  bool BuildCondMovInsn(const BB &bb, const std::map<Operand*, std::vector<Operand*>> &ifDestSrcMap,
+                        const std::map<Operand*, std::vector<Operand*>> &elseDestSrcMap, bool elseBBIsProcessed,
+                        std::vector<Insn*> &generateInsn);
+  bool DoOpt(BB *ifBB, BB *elseBB, BB &joinBB);
+  void GenerateInsnForImm(const Insn &branchInsn, Operand &ifDest, Operand &elseDest, RegOperand &destReg,
+                          std::vector<Insn*> &generateInsn) const;
+  Operand *GetDestReg(const std::map<Operand*, std::vector<Operand*>> &destSrcMap, const RegOperand &destReg) const;
+  void GenerateInsnForReg(const Insn &branchInsn, Operand &ifDest, Operand &elseDest, RegOperand &destReg,
+                          std::vector<Insn*> &generateInsn) const;
+  RegOperand *GenerateRegAndTempInsn(Operand &dest, const RegOperand &destReg, std::vector<Insn*> &generateInsn) const;
+  bool CheckHasSameDest(std::vector<Insn*> &lInsn, std::vector<Insn*> &rInsn) const;
+  bool CheckModifiedRegister(Insn &insn, std::map<Operand*, std::vector<Operand*>> &destSrcMap,
+      std::vector<Operand*> &src, std::map<Operand*, Insn*> &dest2InsnMap, Insn **toBeRremovedOutOfCurrBB) const;
+  bool CheckCondMoveBB(BB *bb, std::map<Operand*, std::vector<Operand*>> &destSrcMap,
+      std::vector<Operand*> &destRegs, std::vector<Insn*> &setInsn, Insn **toBeRremovedOutOfCurrBB) const;
+  bool CheckModifiedInCmpInsn(const Insn &insn) const;
+  bool DoHostBeforeDoCselOpt(BB &ifBB, BB &elseBB);
+  void UpdateTemps(std::vector<Operand*> &destRegs, std::vector<Insn*> &setInsn,
+      std::map<Operand*, std::vector<Operand*>> &destSrcMap, const Insn &oldInsn, Insn *newInsn);
+  Insn *MoveSetInsn2CmpBB(Insn &toBeRremoved2CmpBB, BB &currBB,
+      std::vector<Operand *> &anotherBranchDestRegs, std::map<Operand *, std::vector<Operand *>> &destSrcMap);
+  void RevertMoveInsns(BB *bb, Insn *prevInsnInBB, Insn *newInsnOfBB,
+      Insn *insnInBBToBeRremovedOutOfCurrBB);
+  bool IsExpansionMOperator(const Insn &insn) const;
+  bool IsMovMOperator(const Insn &insn) const;
+  bool IsEorMOperator(const Insn &insn) const;
+  bool IsShiftMOperator(const Insn &insn) const;
+  bool Has2SrcOpndSetInsn(const Insn &insn) const;
+  bool IsSetInsnMOperator(const Insn &insn) const;
+  bool IsSetInsn(const Insn &insn, Operand **dest, std::vector<Operand*> &src) const;
+
+ private:
+  BB *cmpBB = nullptr;
+  Insn *cmpInsn = nullptr;
+  Operand *flagOpnd = nullptr;
+};
+
+/* If( cmp || cmp ) then or If( cmp && cmp ) then
+ * cmp  w4, #1
+ * beq  .L.886__1(branch1)              cmp  w4, #1
+ * .L.886__2:                =>         ccmp w4, #4, #4, NE
+ * cmp  w4, #4                          beq  .L.886__1
+ * beq  .L.886__1(branch2)
+ * */
+class AArch64ICOSameCondPattern : public AArch64ICOPattern {
+ public:
+  explicit AArch64ICOSameCondPattern(CGFunc &func) : AArch64ICOPattern(func) {}
+  ~AArch64ICOSameCondPattern() override = default;
+  bool Optimize(BB &secondIfBB) override;
+ protected:
+  bool DoOpt(BB *firstIfBB, BB &secondIfBB) const;
+};
+
+/* If-Then MorePreds pattern
+ *
+ * .L.891__92:                                             .L.891__92:
+ * cmp     x4, w0, UXTW                                    cmp     x4, w0, UXTW
+ * bls     .L.891__41                                      csel    x0, x2, x0, LS
+ * .L.891__42:                                             bls     .L.891__94
+ * sub     x0, x4, w0, UXTW           =====>               .L.891__42:
+ * cmp     x0, x2                                          sub     x0, x4, w0, UXTW
+ * bls     .L.891__41                                      cmp     x0, x2
+ * ......                                                  csel    x0, x2, x0, LS
+ * .L.891__41:                                             bls     .L.891__94
+ * mov     x0, x2
+ * b       .L.891__94
+ * */
+class AArch64ICOMorePredsPattern : public AArch64ICOPattern {
+ public:
+  explicit AArch64ICOMorePredsPattern(CGFunc &func) : AArch64ICOPattern(func) {}
+  ~AArch64ICOMorePredsPattern() override = default;
+  bool Optimize(BB &curBB) override;
+ protected:
+  bool DoOpt(BB &gotoBB) const;
+  bool CheckGotoBB(BB &gotoBB, std::vector<Insn*> &movInsn) const;
+  bool MovToCsel(std::vector<Insn*> &movInsn, std::vector<Insn*> &cselInsn, const Insn &branchInsn) const;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ICO_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_insn.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_insn.h
new file mode 100644
index 0000000000000000000000000000000000000000..0fe036b2124890616b96c41421c915f9240c4c79
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_insn.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_INSN_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_INSN_H
+
+#include "aarch64_isa.h"
+#include "insn.h"
+#include "string_utils.h"
+#include "aarch64_operand.h"
+#include "common_utils.h"
+namespace maplebe {
+class A64OpndEmitVisitor : public OpndEmitVisitor {
+ public:
+  A64OpndEmitVisitor(Emitter &emitter, const OpndDesc *operandProp)
+      : OpndEmitVisitor(emitter),
+        opndProp(operandProp) {}
+  ~A64OpndEmitVisitor() override {
+    opndProp = nullptr;
+  }
+
+  void Visit(RegOperand *v) final;
+  void Visit(ImmOperand *v) final;
+  void Visit(MemOperand *v) final;
+  void Visit(CondOperand *v) final;
+  void Visit(StImmOperand *v) final;
+  void Visit(BitShiftOperand *v) final;
+  void Visit(ExtendShiftOperand *v) final;
+  void Visit(LabelOperand *v) final;
+  void Visit(FuncNameOperand *v) final;
+  void Visit(CommentOperand *v) final;
+  void Visit(OfstOperand *v) final;
+  void Visit(ListOperand *v) final;
+
+ private:
+  void EmitVectorOperand(const RegOperand &v);
+  void EmitIntReg(const RegOperand &v, int32 opndSz = kMaxSimm32);
+  void Visit(const MIRSymbol &symbol, int64 offset);
+
+  const OpndDesc *opndProp;
+};
+
+class A64OpndDumpVisitor : public OpndDumpVisitor {
+ public:
+  A64OpndDumpVisitor(const OpndDesc &operandDesc) : OpndDumpVisitor(operandDesc) {}
+  ~A64OpndDumpVisitor() override = default;
+
+  void Visit(RegOperand *v) final;
+  void Visit(ImmOperand *v) final;
+  void Visit(MemOperand *a64v) final;
+  void Visit(ListOperand *v) final;
+  void Visit(CondOperand *v) final;
+  void Visit(StImmOperand *v) final;
+  void Visit(BitShiftOperand *v) final;
+  void Visit(ExtendShiftOperand *v) final;
+  void Visit(LabelOperand *v) final;
+  void Visit(FuncNameOperand *v) final;
+  void Visit(PhiOperand *v) final;
+  void Visit(CommentOperand *v) final;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_INSN_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_int_regs.def b/src/mapleall/maple_be/include/cg/aarch64/aarch64_int_regs.def
new file mode 100644
index 0000000000000000000000000000000000000000..d4b00c71a43c654d89cc34a46e8583d7e864b8c4
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_int_regs.def
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/*
+ * ARM Compiler armasm User Guide version 6.6.
+ * http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0473j/deb1353594352617.html
+ * (retrieved on 3/24/2017)
+ *
+ * $ 4.1 Registers in AArch64 state
+ *
+ * There is no register named W31 or X31.
+ * Depending on the instruction, register 31 is either the stack
+ * pointer or the zero register. When used as the stack pointer,
+ * you refer to it as "SP". When used as the zero register, you refer
+ * to it as WZR in a 32-bit context or XZR in a 64-bit context.
+ * The zero register returns 0 when read and discards data when
+ * written (e.g., when setting the status register for testing).
+ */
+/* ID, 32-bit prefix, 64-bit prefix, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill */
+INT_REG(0 , "W", "X", true, false, true, false, false)
+INT_REG(1 , "W", "X", true, false, true, false, false)
+INT_REG(2 , "W", "X", true, false, true, false, false)
+INT_REG(3 , "W", "X", true, false, true, false, false)
+INT_REG(4 , "W", "X", true, false, true, false, false)
+INT_REG(5 , "W", "X", true, false, true, false, false)
+INT_REG(6 , "W", "X", true, false, true, false, false)
+INT_REG(7 , "W", "X", true, false, true, false, false)
+INT_REG(8 , "W", "X", true, false, false, false, false)
+INT_REG(9 , "W", "X", true, false, false, false, false)
+INT_REG(10, "W", "X", true, false, false, false, false)
+INT_REG(11, "W", "X", true, false, false, false, false)
+INT_REG(12, "W", "X", true, false, false, false, false)
+INT_REG(13, "W", "X", true, false, false, false, false)
+INT_REG(14, "W", "X", true, false, false, false, false)
+INT_REG(15, "W", "X", true, false, false, false, true)
+INT_REG(16, "W", "X", true, false, false, true, false)
+INT_REG(17, "W", "X", true, false, false, true, false)
+INT_REG(18, "W", "X", true, false, false, false, false)
+INT_REG(19, "W", "X", true, true, false, false, false)
+INT_REG(20, "W", "X", true, true, false, false, false)
+INT_REG(21, "W", "X", true, true, false, false, false)
+INT_REG(22, "W", "X", true, true, false, false, false)
+INT_REG(23, "W", "X", true, true, false, false, false)
+INT_REG(24, "W", "X", true, true, false, false, false)
+INT_REG(25, "W", "X", true, true, false, false, false)
+INT_REG(26, "W", "X", true, true, false, false, false)
+INT_REG(27, "W", "X", true, true, false, false, false)
+INT_REG(28, "W", "X", true, true, false, false, false)
+INT_REG(29, "W", "X", true, true, false, false, false)
+INT_REG(30, "W", "X", false, true, false, false, false)
+INT_REG(31, "W", "X", false, true, false, false, false)
+/*
+ * Refer to ARM Compiler armasm User Guide version 6.6. $4.5 Predeclared core register names in AArch64 state
+ * We should not use "W" prefix in 64-bit context, though!!
+ */
+INT_REG(SP, "W", "" , false, false, false, false, false)
+INT_REG(ZR, "W", "X", false, false, false, false, false)
+
+/* Alias ID, ID, 32-bit prefix, 64-bit prefix */
+INT_REG_ALIAS(FP, 31, "", "" )
+INT_REG_ALIAS(LR, 30, "", "" )
+
+/* R19 is reserved for yieldpoint */
+INT_REG_ALIAS(YP, 19, "", "" )
+
+INT_REG_ALIAS(LAST_INT_REG, 31, "", "" )
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_isa.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_isa.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae170bf012f678f12f133667f4966841c90e4bb9
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_isa.h
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ISA_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ISA_H
+
+#include "isa.h"
+
+#define DEFINE_MOP(op, ...) op,
+enum AArch64MOP_t : maple::uint32 {
+#include "abstract_mmir.def"
+#include "aarch64_md.def"
+#include "aarch64_mem_md.def"
+  kMopLast
+};
+#undef DEFINE_MOP
+
+namespace maplebe {
+/*
+ * ARM Architecture Reference Manual (for ARMv8)
+ * D1.8.2
+ */
+constexpr uint32 kAarch64StackPtrAlignment = 16;
+constexpr int32 kAarch64StackPtrAlignmentInt = 16;
+
+constexpr int32 kOffsetAlign = 8;
+constexpr uint32 kIntregBytelen = 8; /* 64-bit */
+constexpr uint32 kFpregBytelen = 8;  /* only lower 64 bits are used */
+constexpr int kSizeOfFplr = 16;
+
+enum StpLdpImmBound : int {
+  kStpLdpImm64LowerBound = -512,
+  kStpLdpImm64UpperBound = 504,
+  kStpLdpImm32LowerBound = -256,
+  kStpLdpImm32UpperBound = 252
+};
+
+enum StrLdrPerPostBound : int64 {
+  kStrLdrPerPostLowerBound = -256,
+  kStrLdrPerPostUpperBound = 255
+};
+
+constexpr int64 kStrAllLdrAllImmLowerBound = 0;
+enum StrLdrImmUpperBound : int64 {
+  kStrLdrImm32UpperBound = 16380, /* must be a multiple of 4 */
+  kStrLdrImm64UpperBound = 32760, /* must be a multiple of 8 */
+  kStrbLdrbImmUpperBound = 4095,
+  kStrhLdrhImmUpperBound = 8190
+};
+
+/*
+ * ARM Compiler armasm User Guide version 6.6.
+ * http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0473j/deb1353594352617.html
+ * (retrieved on 3/24/2017)
+ *
+ * $ 4.1 Registers in AArch64 state
+ * ...When you use the 32-bit form of an instruction, the upper
+ * 32 bits of the source registers are ignored and
+ * the upper 32 bits of the destination register are set to zero.
+ * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ *
+ * There is no register named W31 or X31.
+ * Depending on the instruction, register 31 is either the stack
+ * pointer or the zero register. When used as the stack pointer,
+ * you refer to it as "SP". When used as the zero register, you refer
+ * to it as WZR in a 32-bit context or XZR in a 64-bit context.
+ * The zero register returns 0 when read and discards data when
+ * written (e.g., when setting the status register for testing).
+ */
+enum AArch64reg : uint32 {
+  kRinvalid = kInvalidRegNO,
+/* integer registers */
+#define INT_REG(ID, PREF32, PREF64, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) R##ID,
+#define INT_REG_ALIAS(ALIAS, ID, PREF32, PREF64)
+#include "aarch64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, PV, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) V##ID,
+#define FP_SIMD_REG_ALIAS(ID)
+#include "aarch64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+#undef FP_SIMD_REG_ALIAS
+  kMaxRegNum,
+  kRFLAG,
+  kAllRegNum,
+/* alias */
+#define INT_REG(ID, PREF32, PREF64, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill)
+#define INT_REG_ALIAS(ALIAS, ID, PREF32, PREF64) R##ALIAS = R##ID,
+#include "aarch64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+#define FP_SIMD_REG(ID, PV, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill)
+#define FP_SIMD_REG_ALIAS(ID) S##ID = V##ID,
+#include "aarch64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+#undef FP_SIMD_REG_ALIAS
+#define FP_SIMD_REG(ID, PV, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill)
+#define FP_SIMD_REG_ALIAS(ID) D##ID = V##ID,
+#include "aarch64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+#undef FP_SIMD_REG_ALIAS
+};
+
+class Insn;
+
+namespace AArch64isa {
+static inline bool IsGPRegister(AArch64reg r) {
+  return R0 <= r && r <= RZR;
+}
+
+static inline bool IsFPSIMDRegister(AArch64reg r) {
+  return V0 <= r && r <= V31;
+}
+
+static inline bool IsPhysicalRegister(regno_t r) {
+  return r < kMaxRegNum;
+}
+
+static inline RegType GetRegType(AArch64reg r) {
+  if (IsGPRegister(r)) {
+    return kRegTyInt;
+  }
+  if (IsFPSIMDRegister(r)) {
+    return kRegTyFloat;
+  }
+  ASSERT(false, "No suitable register type to return?");
+  return kRegTyUndef;
+}
+
+enum MemoryOrdering : uint32 {
+  kMoNone = 0,
+  kMoAcquire = 1ULL,     /* ARMv8 */
+  kMoAcquireRcpc = (1ULL << 1), /* ARMv8.3 */
+  kMoLoacquire = (1ULL << 2),   /* ARMv8.1 */
+  kMoRelease = (1ULL << 3),     /* ARMv8 */
+  kMoLorelease = (1ULL << 4)    /* ARMv8.1 */
+};
+
+static inline bool IsPseudoInstruction(MOperator mOp) {
+  return (mOp >= MOP_pseudo_param_def_x && mOp <= MOP_pseudo_eh_def_x);
+}
+
+/*
+ * Precondition: The given insn is a jump instruction.
+ * Get the jump target label operand index from the given instruction.
+ * Note: MOP_xbr is a jump instruction, but the target is unknown at compile time,
+ * because a register instead of label. So we don't take it as a branching instruction.
+ * However for special long range branch patch, the label is installed in this case.
+ */
+uint32 GetJumpTargetIdx(const Insn &insn);
+
+MOperator FlipConditionOp(MOperator flippedOp);
+} /* namespace AArch64isa */
+
+/*
+ * We save callee-saved registers from lower stack area to upper stack area.
+ * If possible, we store a pair of registers (int/int and fp/fp) in the stack.
+ * The Stack Pointer has to be aligned at 16-byte boundary.
+ * On AArch64, kIntregBytelen == 8 (see the above)
+ */
+inline void GetNextOffsetCalleeSaved(int &offset) {
+  offset += (kIntregBytelen << 1);
+}
+
+MOperator GetMopPair(MOperator mop);
+} /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ISA_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_isolate_fastpath.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_isolate_fastpath.h
new file mode 100644
index 0000000000000000000000000000000000000000..e2248dbbbc0d485695042ae7f12e30501b3cdc5e
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_isolate_fastpath.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ISOLATE_FASTPATH_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ISOLATE_FASTPATH_H
+
+#include "isolate_fastpath.h"
+#include "aarch64_cgfunc.h"
+#include "aarch64_operand.h"
+#include "aarch64_insn.h"
+
+namespace maplebe {
+using namespace maple;
+
+class AArch64IsolateFastPath : public IsolateFastPath {
+ public:
+  explicit AArch64IsolateFastPath(CGFunc &func)
+      : IsolateFastPath(func) {}
+  ~AArch64IsolateFastPath() override = default;
+
+  void Run() override;
+
+ private:
+  bool InsertOpndRegs(Operand &op, std::set<regno_t> &vecRegs) const;
+  bool InsertInsnRegs(Insn &insn, bool insertSource, std::set<regno_t> &vecSourceRegs,
+                      bool insertTarget, std::set<regno_t> &vecTargetRegs) const;
+  bool FindRegs(Operand &op, std::set<regno_t> &vecRegs) const;
+  bool BackwardFindDependency(BB &ifbb, std::set<regno_t> &vecReturnSourceRegs, std::list<Insn*> &existingInsns,
+                              std::list<Insn*> &moveInsns) const;
+  void IsolateFastPathOpt();
+
+  void SetFastPathReturnBB(BB *bb) {
+    bb->SetFastPathReturn(true);
+    fastPathReturnBB = bb;
+  }
+  BB *GetFastPathReturnBB() {
+    return fastPathReturnBB;
+  }
+
+  BB *fastPathReturnBB = nullptr;
+};
+}  /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_ISOLATE_FASTPATH_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_live.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_live.h
new file mode 100644
index 0000000000000000000000000000000000000000..681c94831d808194784a89d6580067e241c2cbb5
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_live.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_LIVE_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_LIVE_H
+
+#include "live.h"
+
+namespace maplebe {
+class AArch64LiveAnalysis : public LiveAnalysis {
+ public:
+  AArch64LiveAnalysis(CGFunc &func, MemPool &memPool) : LiveAnalysis(func, memPool) {}
+  ~AArch64LiveAnalysis() override = default;
+  bool CleanupBBIgnoreReg(regno_t reg) override;
+  void InitEhDefine(BB &bb) override;
+  void GenerateReturnBBDefUse(BB &bb) const override;
+  void ProcessCallInsnParam(BB &bb, const Insn &insn) const override;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_LIVE_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_md.def b/src/mapleall/maple_be/include/cg/aarch64/aarch64_md.def
new file mode 100644
index 0000000000000000000000000000000000000000..4e84c643543b3d350db377827fc6d59adeada237
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_md.def
@@ -0,0 +1,1212 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/* InsnDesc format:
+ * {mop, opndMD, properties, latency, name, format, atomicNum, validFunc(nullptr)}
+ */
+
+/* AARCH64 MOVES */
+/* MOP_xmovrr */
+DEFINE_MOP(MOP_xmovrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISMOVE,kLtAlu,"mov","0,1",1)
+/* MOP_wmovrr */
+DEFINE_MOP(MOP_wmovrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},ISMOVE,kLtAlu,"mov","0,1",1)
+/* MOP_wmovri32 */
+DEFINE_MOP(MOP_wmovri32, {&OpndDesc::Reg32ID,&OpndDesc::Imm32},ISMOVE,kLtAlu,"mov","0,1",1)
+/* MOP_xmovri64 */
+DEFINE_MOP(MOP_xmovri64, {&OpndDesc::Reg64ID,&OpndDesc::Imm64},ISMOVE,kLtAlu,"mov","0,1",1)
+/* MOP_xmovrr_uxtw -- Remove Redundant uxtw -- used in globalopt:UxtwMovPattern */
+DEFINE_MOP(MOP_xmovrr_uxtw, {&OpndDesc::Reg64ID,&OpndDesc::Reg32IS},ISMOVE,kLtAlu,"mov","0,1",1)
+
+/* MOP_xvmovsr */
+DEFINE_MOP(MOP_xvmovsr, {&OpndDesc::Reg32FD,&OpndDesc::Reg32IS},ISMOVE,kLtR2f,"fmov","0,1",1)
+/* MOP_xvmovdr */
+DEFINE_MOP(MOP_xvmovdr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS},ISMOVE,kLtR2f,"fmov","0,1",1)
+/* MOP_xvmovrs */
+DEFINE_MOP(MOP_xvmovrs, {&OpndDesc::Reg32ID,&OpndDesc::Reg32FS},ISMOVE,kLtF2r,"fmov","0,1",1)
+/* MOP_xvmovrd */
+DEFINE_MOP(MOP_xvmovrd, {&OpndDesc::Reg64ID,&OpndDesc::Reg64FS},ISMOVE,kLtF2r,"fmov","0,1",1)
+/* MOP_xvmovs */
+DEFINE_MOP(MOP_xvmovs, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS},ISMOVE,kLtFpalu,"fmov","0,1",1)
+/* MOP_xvmovd */
+DEFINE_MOP(MOP_xvmovd, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS},ISMOVE,kLtFpalu,"fmov","0,1",1)
+
+/* Vector SIMD mov */
+/* MOP_xmovrv */
+DEFINE_MOP(MOP_xvmovrv, {&OpndDesc::Reg32ID,&OpndDesc::Reg32FS},ISMOVE,kLtF2r,"mov","0,1",1)
+
+/* MOP_xadrp */
+DEFINE_MOP(MOP_xadrp, {&OpndDesc::Reg64ID,&OpndDesc::LiteralSrc},ISLOADADDR,kLtShift,"adrp","0,1",1)
+/* MOP_xadr */
+DEFINE_MOP(MOP_xadri64, {&OpndDesc::Reg64ID,&OpndDesc::Imm64},ISLOADADDR,kLtShift,"adr","0,1",1)
+/* MOP_xadrpl12 */
+
+DEFINE_MOP(MOP_xadrpl12, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Literal12Src},ISLOADADDR,kLtAlu,"add","0,1,2",1)
+
+/* AARCH64 Arithmetic: add */
+/* MOP_xaddrrr */
+DEFINE_MOP(MOP_xaddrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAlu,"add","0,1,2",1)
+/* MOP_xaddrrrs */
+DEFINE_MOP(MOP_xaddrrrs, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},0,kLtAluShift,"add","0,1,2,3",1)
+/* MOP_xxwaddrrre */
+DEFINE_MOP(MOP_xxwaddrrre, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},0,kLtAluShift,"add","0,1,2,3",1)
+/* MOP_xaddrri24 */
+DEFINE_MOP(MOP_xaddrri24, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm12,&OpndDesc::Lsl12},0,kLtShift,"add","0,1,2,3",1,Imm12BitValid)
+/* MOP_xaddrri12 */
+DEFINE_MOP(MOP_xaddrri12, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm12},0,kLtAlu,"add","0,1,2",1,Imm12BitValid)
+/* MOP_waddrrr */
+DEFINE_MOP(MOP_waddrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAlu,"add","0,1,2",1)
+/* MOP_waddrrrs */
+DEFINE_MOP(MOP_waddrrrs, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Bitshift32},0,kLtAluShift,"add","0,1,2,3",1)
+/* MOP_xxwaddrrre */
+DEFINE_MOP(MOP_wwwaddrrre, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},0,kLtAluShift,"add","0,1,2,3",1)
+/* MOP_waddrri24 */
+DEFINE_MOP(MOP_waddrri24, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm12,&OpndDesc::Lsl12},0,kLtAluShift,"add","0,1,2,3",1,Imm12BitValid)
+/* MOP_waddrri12 */
+DEFINE_MOP(MOP_waddrri12, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm12},0,kLtAlu,"add","0,1,2",1,Imm12BitValid)
+/* MOP_dadd */
+DEFINE_MOP(MOP_dadd, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},0,kLtFpalu,"fadd","0,1,2",1)
+/* MOP_sadd */
+DEFINE_MOP(MOP_sadd, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS},0,kLtFpalu,"fadd","0,1,2",1)
+
+/* AARCH64 Arithmetic: sub/subs */
+/* MOP newly add to the following group should be related pairs with such order :{ sub, subs } */
+/* MOP_xsubrrr */
+DEFINE_MOP(MOP_xsubrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAlu,"sub","0,1,2",1)
+/* MOP_xsubsrrr */
+DEFINE_MOP(MOP_xsubsrrr, {&OpndDesc::CCD, &OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAlu,"subs","1,2,3",1)
+/* MOP_xsubrrrs */
+DEFINE_MOP(MOP_xsubrrrs, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},0,kLtAluShift,"sub","0,1,2,3",1)
+/* MOP_xsubsrrrs */
+DEFINE_MOP(MOP_xsubsrrrs, {&OpndDesc::CCD, &OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},0,kLtAluShift,"subs","1,2,3,4",1)
+/* MOP_xsubrri24 */
+DEFINE_MOP(MOP_xsubrri24, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm12,&OpndDesc::Lsl12},0,kLtAluShift,"sub","0,1,2,3",1,Imm12BitValid)
+/* MOP_xsubsrri24 */
+DEFINE_MOP(MOP_xsubsrri24, {&OpndDesc::CCD, &OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm12,&OpndDesc::Lsl12},0,kLtAluShift,"subs","1,2,3,4",1,Imm12BitValid)
+/* MOP_xsubrri12 */
+DEFINE_MOP(MOP_xsubrri12, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm12},0,kLtAlu,"sub","0,1,2",1,Imm12BitValid)
+/* MOP_xsubsrri12 */
+DEFINE_MOP(MOP_xsubsrri12, {&OpndDesc::CCD, &OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm12},0,kLtAlu,"subs","1,2,3",1,Imm12BitValid)
+/* MOP_wsubrrr */
+DEFINE_MOP(MOP_wsubrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAlu,"sub","0,1,2",1)
+/* MOP_wsubsrrr */
+DEFINE_MOP(MOP_wsubsrrr, {&OpndDesc::CCD,&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAlu,"subs","1,2,3",1)
+/* MOP_wsubrrrs */
+DEFINE_MOP(MOP_wsubrrrs, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Bitshift32},0,kLtAluShift,"sub","0,1,2,3",1)
+/* MOP_wsubsrrrs */
+DEFINE_MOP(MOP_wsubsrrrs, {&OpndDesc::CCD,&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Bitshift32},0,kLtAluShift,"subs","1,2,3,4",1)
+/* MOP_wsubrri24 */
+DEFINE_MOP(MOP_wsubrri24, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm12,&OpndDesc::Lsl12},0,kLtAluShift,"sub","0,1,2,3",1,Imm12BitValid)
+/* MOP_wsubsrri24 */
+DEFINE_MOP(MOP_wsubsrri24, {&OpndDesc::CCD,&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm12,&OpndDesc::Lsl12},0,kLtAluShift,"subs","1,2,3,4",1,Imm12BitValid)
+/* MOP_wsubrri12 */
+DEFINE_MOP(MOP_wsubrri12, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm12},0,kLtAlu,"sub","0,1,2",1,Imm12BitValid)
+/* MOP_wsubsrri12 */
+DEFINE_MOP(MOP_wsubsrri12, {&OpndDesc::CCD,&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm12},0,kLtAlu,"subs","1,2,3",1,Imm12BitValid)
+
+/* AARCH64 Arithmetic: sub */
+/* MOP_xxwsubrrre */
+DEFINE_MOP(MOP_xxwsubrrre, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},0,kLtAluShift,"sub","0,1,2,3",1)
+/* MOP_wwwsubrrre */
+DEFINE_MOP(MOP_wwwsubrrre, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},0,kLtAluShift,"sub","0,1,2,3",1)
+/* MOP_dsub */
+DEFINE_MOP(MOP_dsub, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},0,kLtFpalu,"fsub","0,1,2",1)
+/* MOP_ssub */
+DEFINE_MOP(MOP_ssub, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS},0,kLtFpalu,"fsub","0,1,2",1)
+
+/* AARCH64 Arithmetic: multiply */
+/* MOP_Tbxmulrrr */
+DEFINE_MOP(MOP_xmulrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtMul,"mul","0,1,2",1)
+/* MOP_wmulrrr */
+DEFINE_MOP(MOP_wmulrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtMul,"mul","0,1,2",1)
+/* MOP_Tbxvmuls */
+DEFINE_MOP(MOP_xvmuls, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS},0,kLtFpmul,"fmul","0,1,2",1)
+/* MOP_Tbxvmuld */
+DEFINE_MOP(MOP_xvmuld, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},0,kLtFpmul,"fmul","0,1,2",1)
+/*MOP_xsmullrrr */
+DEFINE_MOP(MOP_xsmullrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtMul,"smull","0,1,2",1)
+
+/* AARCH64 Arithmetic: multiply first then add */
+/* MOP_xmaddrrrr */
+DEFINE_MOP(MOP_xmaddrrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtMul,"madd","0,1,2,3",1)
+/* MOP_wmaddrrrr */
+DEFINE_MOP(MOP_wmaddrrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtMul,"madd","0,1,2,3",1)
+
+/* AARCH64 leading zeros, reverse bits (for trailing zeros) */
+/* MOP_wclz */
+DEFINE_MOP(MOP_wclz, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},0,kLtAlu,"clz","0,1", 1)
+/* MOP_xclz */
+DEFINE_MOP(MOP_xclz, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},0,kLtAlu,"clz","0,1", 1)
+/* MOP_wrbit */
+DEFINE_MOP(MOP_wrbit, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},0,kLtAlu,"rbit","0,1", 1)
+/* MOP_xrbit */
+DEFINE_MOP(MOP_xrbit, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},0,kLtAlu,"rbit","0,1", 1)
+
+/* AARCH64 Conversions */
+/* MOP_xsxtb32 */
+DEFINE_MOP(MOP_xsxtb32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},ISCONVERSION,kLtAluShift,"sxtb","0,1",1)
+/* MOP_xsxtb64 */
+DEFINE_MOP(MOP_xsxtb64, {&OpndDesc::Reg64ID,&OpndDesc::Reg32IS},ISCONVERSION,kLtAluShift,"sxtb","0,1",1)
+/* MOP_xsxth32 */
+DEFINE_MOP(MOP_xsxth32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},ISCONVERSION,kLtAluShift,"sxth","0,1",1)
+/* MOP_xsxth64 */
+DEFINE_MOP(MOP_xsxth64, {&OpndDesc::Reg64ID,&OpndDesc::Reg32IS},ISCONVERSION,kLtAluShift,"sxth","0,1",1)
+/* MOP_xsxtw64 */
+DEFINE_MOP(MOP_xsxtw64, {&OpndDesc::Reg64ID,&OpndDesc::Reg32IS},ISCONVERSION,kLtAluShift,"sxtw","0,1",1)
+
+/* MOP_xuxtb32 */
+DEFINE_MOP(MOP_xuxtb32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},ISCONVERSION,kLtAluShift,"uxtb","0,1",1)
+/* MOP_xuxth32 */
+DEFINE_MOP(MOP_xuxth32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},ISCONVERSION,kLtAluShift,"uxth","0,1",1)
+/* MOP_xuxtw64	Same as mov w0,w0 */
+DEFINE_MOP(MOP_xuxtw64, {&OpndDesc::Reg64ID,&OpndDesc::Reg32IS},ISCONVERSION,kLtAluShift,"uxtw","0,1",1)
+
+/*
+ * User-defined pseudo-instruction, which is used in validbit opt based on ssa,
+ * will recover to mov after validbit opt
+ */
+DEFINE_MOP(MOP_wuxtb_vb, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},0,kLtAluShift,"//uxtb_vb","0,1",1)
+DEFINE_MOP(MOP_wuxth_vb, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},0,kLtAluShift,"//uxth_vb","0,1",1)
+
+/* MOP_xvcvtfd */
+DEFINE_MOP(MOP_xvcvtfd, {&OpndDesc::Reg32FD,&OpndDesc::Reg64FS},ISCONVERSION,kLtFpalu,"fcvt","0,1",1)
+/* MOP_xvcvtdf */
+DEFINE_MOP(MOP_xvcvtdf, {&OpndDesc::Reg64FD,&OpndDesc::Reg32FS},ISCONVERSION,kLtFpalu,"fcvt","0,1",1)
+
+/* MOP_vcvtrf		fcvtzs w,s */
+DEFINE_MOP(MOP_vcvtrf, {&OpndDesc::Reg32ID,&OpndDesc::Reg32FS},ISCONVERSION,kLtF2rCvt,"fcvtzs","0,1",1)
+/* MOP_xvcvtrf	fcvtzs x,s */
+DEFINE_MOP(MOP_xvcvtrf, {&OpndDesc::Reg64ID,&OpndDesc::Reg32FS},ISCONVERSION,kLtF2rCvt,"fcvtzs","0,1",1)
+/* MOP_vcvturf	fcvtzu w,s */
+DEFINE_MOP(MOP_vcvturf, {&OpndDesc::Reg32ID,&OpndDesc::Reg32FS},ISCONVERSION,kLtF2rCvt,"fcvtzu","0,1",1)
+/* MOP_xvcvturf	fcvtzu x,s */
+DEFINE_MOP(MOP_xvcvturf, {&OpndDesc::Reg64ID,&OpndDesc::Reg32FS},ISCONVERSION,kLtF2rCvt,"fcvtzu","0,1",1)
+
+/* MOP_vcvtas         fcvtas w,s (for round) */
+DEFINE_MOP(MOP_vcvtas, {&OpndDesc::Reg32ID,&OpndDesc::Reg32FS},ISCONVERSION,kLtF2rCvt,"fcvtas","0,1",1)
+/* MOP_xvcvtas        fcvtas x,s */
+DEFINE_MOP(MOP_xvcvtas, {&OpndDesc::Reg64ID,&OpndDesc::Reg64FS},ISCONVERSION,kLtF2rCvt,"fcvtas","0,1",1)
+/* MOP_vcvtms         fcvtms w,s (for floor) */
+DEFINE_MOP(MOP_vcvtms, {&OpndDesc::Reg32ID,&OpndDesc::Reg32FS},ISCONVERSION,kLtF2rCvt,"fcvtms","0,1",1)
+/* MOP_xvcvtms        fcvtms x,s */
+DEFINE_MOP(MOP_xvcvtms, {&OpndDesc::Reg64ID,&OpndDesc::Reg64FS},ISCONVERSION,kLtF2rCvt,"fcvtms","0,1",1)
+/* MOP_vcvtps        fcvtps w,s (for ceil) */
+DEFINE_MOP(MOP_vcvtps, {&OpndDesc::Reg32ID,&OpndDesc::Reg32FS},ISCONVERSION,kLtF2rCvt,"fcvtps","0,1",1)
+/* MOP_xvcvtps       fcvtps x,d */
+DEFINE_MOP(MOP_xvcvtps, {&OpndDesc::Reg64ID,&OpndDesc::Reg64FS},ISCONVERSION,kLtF2rCvt,"fcvtps","0,1",1)
+
+/* MOP_vcvtrd		fcvtzs w,d */
+DEFINE_MOP(MOP_vcvtrd, {&OpndDesc::Reg32ID,&OpndDesc::Reg64FS},ISCONVERSION,kLtF2rCvt,"fcvtzs","0,1",1)
+/* MOP_xvcvtrd	fcvtzs x,d */
+DEFINE_MOP(MOP_xvcvtrd, {&OpndDesc::Reg64ID,&OpndDesc::Reg64FS},ISCONVERSION,kLtF2rCvt,"fcvtzs","0,1",1)
+/* MOP_vcvturd	fcvtzu w,d */
+DEFINE_MOP(MOP_vcvturd, {&OpndDesc::Reg32ID,&OpndDesc::Reg64FS},ISCONVERSION,kLtF2rCvt,"fcvtzu","0,1",1)
+/* MOP_xvcvturd	fcvtzu x,d */
+DEFINE_MOP(MOP_xvcvturd, {&OpndDesc::Reg64ID,&OpndDesc::Reg64FS},ISCONVERSION,kLtF2rCvt,"fcvtzu","0,1",1)
+
+/* MOP_vcvtfr		scvtf s,w */
+DEFINE_MOP(MOP_vcvtfr, {&OpndDesc::Reg32FD,&OpndDesc::Reg32IS},ISCONVERSION,kLtR2fCvt,"scvtf","0,1",1)
+/* MOP_xvcvtfr	scvtf s,x */
+DEFINE_MOP(MOP_xvcvtfr, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS},ISCONVERSION,kLtR2fCvt,"scvtf","0,1",1)
+/* MOP_vcvtufr	ucvtf s,w */
+DEFINE_MOP(MOP_vcvtufr, {&OpndDesc::Reg32FD,&OpndDesc::Reg32IS},ISCONVERSION,kLtR2fCvt,"ucvtf","0,1",1)
+/* MOP_xvcvtufr	ucvtf s,x */
+DEFINE_MOP(MOP_xvcvtufr, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS},ISCONVERSION,kLtR2fCvt,"ucvtf","0,1",1)
+
+/* MOP_vcvtdr		scvtf d,w */
+DEFINE_MOP(MOP_vcvtdr, {&OpndDesc::Reg64FD,&OpndDesc::Reg32IS},ISCONVERSION,kLtR2fCvt,"scvtf","0,1",1)
+/* MOP_xvcvtdr	scvtf d,x */
+DEFINE_MOP(MOP_xvcvtdr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS},ISCONVERSION,kLtR2fCvt,"scvtf","0,1",1)
+/* MOP_vcvtudr	ucvtf d,w */
+DEFINE_MOP(MOP_vcvtudr, {&OpndDesc::Reg64FD,&OpndDesc::Reg32IS},ISCONVERSION,kLtR2fCvt,"ucvtf","0,1",1)
+/* MOP_xvcvtudr	ucvtf d,x */
+DEFINE_MOP(MOP_xvcvtudr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS},ISCONVERSION,kLtR2fCvt,"ucvtf","0,1",1)
+
+/* MOP_xcsel */
+DEFINE_MOP(MOP_wcselrrrc, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"csel","0,1,2,3",1)
+DEFINE_MOP(MOP_xcselrrrc, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"csel","0,1,2,3",1)
+
+/* MOP_xcset -- all conditions minus AL & NV */
+DEFINE_MOP(MOP_wcsetrc, {&OpndDesc::Reg32ID,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"cset","0,1",1)
+DEFINE_MOP(MOP_xcsetrc, {&OpndDesc::Reg64ID,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"cset","0,1",1)
+
+/* MOP_xcinc */
+DEFINE_MOP(MOP_wcincrc, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"cinc","0,1,2",1)
+DEFINE_MOP(MOP_xcincrc, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"cinc","0,1,2",1)
+
+/* MOP_xcsinc */
+DEFINE_MOP(MOP_wcsincrrrc, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"csinc","0,1,2,3",1)
+DEFINE_MOP(MOP_xcsincrrrc, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"csinc","0,1,2,3",1)
+
+/* MOP_xcsinv */
+DEFINE_MOP(MOP_wcsinvrrrc, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"csinv","0,1,2,3",1)
+DEFINE_MOP(MOP_xcsinvrrrc, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"csinv","0,1,2,3",1)
+
+/* MOP_xandrrr */
+DEFINE_MOP(MOP_xandrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAlu,"and","0,1,2",1)
+/* MOP_xandrrrs */
+DEFINE_MOP(MOP_xandrrrs, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},0,kLtAluShift,"and","0,1,2,3",1)
+/* MOP_xandrri13 */
+DEFINE_MOP(MOP_xandrri13, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm13},0,kLtAlu,"and","0,1,2",1,Imm13BitMaskValid)
+/* MOP_wandrrr */
+DEFINE_MOP(MOP_wandrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAlu,"and","0,1,2",1)
+/* MOP_wandrrrs */
+DEFINE_MOP(MOP_wandrrrs, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Bitshift32},0,kLtAluShift,"and","0,1,2,3",1)
+/* MOP_wandrri12 */
+DEFINE_MOP(MOP_wandrri12, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm12},0,kLtAlu,"and","0,1,2",1,Imm12BitMaskValid)
+
+/* MOP_xbicrrr */
+DEFINE_MOP(MOP_xbicrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAlu,"bic","0,1,2",1)
+/* MOP_wbicrrr */
+DEFINE_MOP(MOP_wbicrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAlu,"bic","0,1,2",1)
+
+/* MOP_xiorrrr */
+DEFINE_MOP(MOP_xiorrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAlu,"orr","0,1,2",1)
+/* MOP_xiorrrrs */
+DEFINE_MOP(MOP_xiorrrrs, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},0,kLtAlu,"orr","0,1,2,3",1)
+/* MOP_xiorrri13 */
+DEFINE_MOP(MOP_xiorrri13, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm13},0,kLtAlu,"orr","0,1,2",1,Imm13BitMaskValid)
+/* MOP_wiorrrr */
+DEFINE_MOP(MOP_wiorrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAlu,"orr","0,1,2",1)
+/* MOP_wiorrrrs */
+DEFINE_MOP(MOP_wiorrrrs, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Bitshift32},0,kLtAlu,"orr","0,1,2,3",1)
+/* MOP_wiorrri12 */
+DEFINE_MOP(MOP_wiorrri12, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm12},0,kLtAlu,"orr","0,1,2",1,Imm12BitMaskValid)
+
+/* MOP_xeorrrr */
+DEFINE_MOP(MOP_xeorrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAlu,"eor","0,1,2",1)
+/* MOP_xeorrrrs */
+DEFINE_MOP(MOP_xeorrrrs, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},0,kLtAlu,"eor","0,1,2,3",1)
+/* MOP_xeorrri13 */
+DEFINE_MOP(MOP_xeorrri13, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm13},0,kLtAlu,"eor","0,1,2",1,Imm13BitMaskValid)
+/* MOP_weorrrr */
+DEFINE_MOP(MOP_weorrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAlu,"eor","0,1,2",1)
+/* MOP_weorrrrs */
+DEFINE_MOP(MOP_weorrrrs, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Bitshift32},0,kLtAlu,"eor","0,1,2,3",1)
+/* MOP_weorrri12 */
+DEFINE_MOP(MOP_weorrri12, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm12},0,kLtAlu,"eor","0,1,2",1,Imm12BitMaskValid)
+
+/* MOP_xnotrr */
+DEFINE_MOP(MOP_xnotrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},0,kLtAlu,"mvn","0,1",1)
+/* MOP_wnotrr */
+DEFINE_MOP(MOP_wnotrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},0,kLtAlu,"mvn","0,1",1)
+/* MOP_vnotui */
+DEFINE_MOP(MOP_vnotui,  {&OpndDesc::Reg64VD,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"mvni","0,1",1)
+/* MOP_vnotvi */
+DEFINE_MOP(MOP_vnotvi,  {&OpndDesc::Reg128VD,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"mvni","0,1",1)
+
+/* MOP_xrevrr */
+DEFINE_MOP(MOP_xrevrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},0,kLtAlu,"rev","0,1",1)
+/* MOP_wrevrr */
+DEFINE_MOP(MOP_wrevrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},0,kLtAlu,"rev","0,1",1)
+/* MOP_xrevrr */
+DEFINE_MOP(MOP_wrevrr16, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},0,kLtAlu,"rev16","0,1",1)
+
+/* MOP_wfmaxrrr */
+DEFINE_MOP(MOP_wfmaxrrr, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS},0,kLtFpalu,"fmax","0,1,2",1)
+/* MOP_xfmaxrrr */
+DEFINE_MOP(MOP_xfmaxrrr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},0,kLtFpalu,"fmax","0,1,2",1)
+/* MOP_wfminrrr */
+DEFINE_MOP(MOP_wfminrrr, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS},0,kLtFpalu,"fmin","0,1,2",1)
+/* MOP_xfminrrr */
+DEFINE_MOP(MOP_xfminrrr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},0,kLtFpalu,"fmin","0,1,2",1)
+
+/* MOP_wsdivrrr */
+DEFINE_MOP(MOP_wsdivrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},CANTHROW,kLtDiv,"sdiv","0,1,2",1)
+/* MOP_xsdivrrr */
+DEFINE_MOP(MOP_xsdivrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},CANTHROW,kLtDiv,"sdiv","0,1,2",1)
+/* MOP_wudivrrr */
+DEFINE_MOP(MOP_wudivrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},CANTHROW,kLtDiv,"udiv","0,1,2",1)
+/* MOP_xudivrrr */
+DEFINE_MOP(MOP_xudivrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},CANTHROW,kLtDiv,"udiv","0,1,2",1)
+
+/* MOP_wmsubrrrr */
+DEFINE_MOP(MOP_wmsubrrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtMul,"msub","0,1,2,3",1)
+/* MOP_xmsubrrrr */
+DEFINE_MOP(MOP_xmsubrrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtMul,"msub","0,1,2,3",1)
+
+/* MOP_wmnegrrr */
+DEFINE_MOP(MOP_wmnegrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtMul,"mneg","0,1,2",1)
+/* MOP_xmnegrrr */
+DEFINE_MOP(MOP_xmnegrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtMul,"mneg","0,1,2",1)
+
+/* MOP_wubfxrri5i5 */
+DEFINE_MOP(MOP_wubfxrri5i5, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm5,&OpndDesc::Imm5},0,kLtAluShift,"ubfx","0,1,2,3",1)
+/* MOP_xubfxrri6i6 */
+DEFINE_MOP(MOP_xubfxrri6i6, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm6,&OpndDesc::Imm6},0,kLtAluShift,"ubfx","0,1,2,3",1)
+
+/* MOP_wsbfxrri5i5 -- Signed Bitfield Extract */
+DEFINE_MOP(MOP_wsbfxrri5i5, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm5,&OpndDesc::Imm5},0,kLtAluShift,"sbfx","0,1,2,3",1)
+/* MOP_xsbfxrri6i6 */
+DEFINE_MOP(MOP_xsbfxrri6i6, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm6,&OpndDesc::Imm6},0,kLtAluShift,"sbfx","0,1,2,3",1)
+
+/* MOP_wubfizrri5i5 -- Unsigned Bitfield Insert in Zero */
+DEFINE_MOP(MOP_wubfizrri5i5, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm5,&OpndDesc::Imm5},0,kLtAluShift,"ubfiz","0,1,2,3",1)
+/* MOP_xubfizrri6i6 */
+DEFINE_MOP(MOP_xubfizrri6i6, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm6,&OpndDesc::Imm6},0,kLtAluShift,"ubfiz","0,1,2,3",1)
+
+/* MOP_xsbfizrri6i6 Signed Bitfield Insert in Zero */
+DEFINE_MOP(MOP_xsbfizrri6i6, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm6,&OpndDesc::Imm6},0,kLtAluShift,"sbfiz","0,1,2,3",1)
+
+/* MOP_wbfirri5i5 -- Bitfield Insert */
+DEFINE_MOP(MOP_wbfirri5i5, {&OpndDesc::Reg32IDS,&OpndDesc::Reg32IS,&OpndDesc::Imm5,&OpndDesc::Imm5},ISMOVE,kLtAluShift,"bfi","0,1,2,3",1)
+/* MOP_xbfirri6i6 */
+DEFINE_MOP(MOP_xbfirri6i6, {&OpndDesc::Reg64IDS,&OpndDesc::Reg64IS,&OpndDesc::Imm6,&OpndDesc::Imm6},ISMOVE,kLtAluShift,"bfi","0,1,2,3",1)
+
+/* MOP_xlslrri6,--- Logical Shift Left */
+DEFINE_MOP(MOP_xlslrri6, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm6},0,kLtAluShift,"lsl","0,1,2",1)
+/* MOP_wlslrri5 */
+DEFINE_MOP(MOP_wlslrri5, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm8},0,kLtAluShift,"lsl","0,1,2",1)
+/* MOP_xasrrri6, */
+DEFINE_MOP(MOP_xasrrri6, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm6},0,kLtAluShift,"asr","0,1,2",1)
+/* MOP_wasrrri5 */
+DEFINE_MOP(MOP_wasrrri5, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm8},0,kLtAluShift,"asr","0,1,2",1)
+/* MOP_xlsrrri6, */
+DEFINE_MOP(MOP_xlsrrri6, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm6},0,kLtAluShift,"lsr","0,1,2",1)
+/* MOP_wlsrrri5 */
+DEFINE_MOP(MOP_wlsrrri5, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Imm8},0,kLtAluShift,"lsr","0,1,2",1)
+/* MOP_xlslrrr, */
+DEFINE_MOP(MOP_xlslrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAluShiftReg,"lsl","0,1,2",1)
+/* MOP_wlslrrr */
+DEFINE_MOP(MOP_wlslrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAluShiftReg,"lsl","0,1,2",1)
+/* MOP_xasrrrr, */
+DEFINE_MOP(MOP_xasrrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAluShiftReg,"asr","0,1,2",1)
+/* MOP_wasrrrr */
+DEFINE_MOP(MOP_wasrrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAluShiftReg,"asr","0,1,2",1)
+/* MOP_xlsrrrr, */
+DEFINE_MOP(MOP_xlsrrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAluShiftReg,"lsr","0,1,2",1)
+/* MOP_wlsrrrr */
+DEFINE_MOP(MOP_wlsrrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAluShiftReg,"lsr","0,1,2",1)
+/* MOP_xrorrrr */
+DEFINE_MOP(MOP_xrorrrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAluShiftReg,"ror","0,1,2",1)
+/* MOP_wrorrrr */
+DEFINE_MOP(MOP_wrorrrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAluShiftReg,"ror","0,1,2",1)
+/* MOP_wtstri32 */
+DEFINE_MOP(MOP_wtstri32, {&OpndDesc::CCD,&OpndDesc::Reg32ID,&OpndDesc::Imm32},0,kLtAlu,"tst","1,2",1)
+/* MOP_xtstri64 */
+DEFINE_MOP(MOP_xtstri64, {&OpndDesc::CCD,&OpndDesc::Reg64ID,&OpndDesc::Imm64},0,kLtAlu,"tst","1,2",1)
+/* MOP_wtstrr */
+DEFINE_MOP(MOP_wtstrr, {&OpndDesc::CCD,&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},0,kLtAlu,"tst","1,2",1)
+/* MOP_xtstrr */
+DEFINE_MOP(MOP_xtstrr, {&OpndDesc::CCD,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},0,kLtAlu,"tst","1,2",1)
+/* MOP_wextrrrri5 -- Extracts a register from a pair of registers */
+DEFINE_MOP(MOP_wextrrrri5, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Imm5},0,kLtAluShift,"extr","0,1,2,3",1)
+/* MOP_xextrrrri6 */
+DEFINE_MOP(MOP_xextrrrri6, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Imm6},0,kLtAluShift,"extr","0,1,2,3",1)
+
+/* MOP_wsfmovri imm8->s */
+DEFINE_MOP(MOP_wsfmovri, {&OpndDesc::Reg32FD,&OpndDesc::Imm8},ISMOVE,kLtFconst,"fmov","0,1",1)
+/* MOP_xdfmovri imm8->d */
+DEFINE_MOP(MOP_xdfmovri, {&OpndDesc::Reg64FD,&OpndDesc::Imm8},ISMOVE,kLtFconst,"fmov","0,1",1)
+
+/* MOP_xcsneg -- Conditional Select Negation */
+DEFINE_MOP(MOP_wcsnegrrrc, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"csneg","0,1,2,3",1)
+DEFINE_MOP(MOP_xcsnegrrrc, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"csneg","0,1,2,3",1)
+DEFINE_MOP(MOP_wcnegrrrc, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"cneg","0,1,2",1)
+DEFINE_MOP(MOP_xcnegrrrc, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtAlu,"cneg","0,1,2",1)
+
+/* MOP_sabsrr */
+DEFINE_MOP(MOP_sabsrr, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS},0,kLtFpalu,"fabs","0,1",1)
+/* MOP_dabsrr */
+DEFINE_MOP(MOP_dabsrr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS},0,kLtFpalu,"fabs","0,1",1)
+
+/* MOP_winegrr */
+DEFINE_MOP(MOP_winegrr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},0,kLtAlu,"neg","0,1",1)
+/* MOP_winegrre */
+DEFINE_MOP(MOP_winegrrs, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Bitshift32},0,kLtAlu,"neg","0,1,2",1)
+/* neg MOP_xinegrr */
+DEFINE_MOP(MOP_xinegrr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},0,kLtAlu,"neg","0,1",1)
+/* neg MOP_xinegrrs */
+DEFINE_MOP(MOP_xinegrrs, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},0,kLtAlu,"neg","0,1,2",1)
+/* neg f32 */
+DEFINE_MOP(MOP_wfnegrr, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS},0,kLtFpalu,"fneg","0,1",1)
+/* neg f64 */
+DEFINE_MOP(MOP_xfnegrr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS},0,kLtFpalu,"fneg","0,1",1)
+
+/* MOP_sdivrrr */
+DEFINE_MOP(MOP_sdivrrr, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS},CANTHROW,kLtAdvsimdDivS,"fdiv","0,1,2",1)
+/* MOP_ddivrrr */
+DEFINE_MOP(MOP_ddivrrr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},CANTHROW,kLtAdvsimdDivD,"fdiv","0,1,2",1)
+
+/* MOP_smadd */
+DEFINE_MOP(MOP_smadd, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS},CANTHROW,kLtFpmul,"fmadd","0,1,2,3",1)
+/* MOP_dmadd */
+DEFINE_MOP(MOP_dmadd, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},CANTHROW,kLtFpmul,"fmadd","0,1,2,3",1)
+
+/* MOP_smsub */
+DEFINE_MOP(MOP_smsub, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS},CANTHROW,kLtFpmul,"fmsub","0,1,2,3",1)
+/* MOP_dmsub */
+DEFINE_MOP(MOP_dmsub, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},CANTHROW,kLtFpmul,"fmsub","0,1,2,3",1)
+
+/* MOP_snmul */
+DEFINE_MOP(MOP_snmul, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS},CANTHROW,kLtFpmul,"fnmul","0,1,2",1)
+/* MOP_dnmul */
+DEFINE_MOP(MOP_dnmul, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},CANTHROW,kLtFpmul,"fnmul","0,1,2",1)
+
+/* MOP_hcselrrrc --- Floating-point Conditional Select */
+DEFINE_MOP(MOP_hcselrrrc, {&OpndDesc::Reg16FD,&OpndDesc::Reg16FS,&OpndDesc::Reg16FS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtFpalu,"fcsel","0,1,2,3",1)
+/* MOP_scselrrrc */
+DEFINE_MOP(MOP_scselrrrc, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtFpalu,"fcsel","0,1,2,3",1)
+/* MOP_dcselrrrc */
+DEFINE_MOP(MOP_dcselrrrc, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Cond,&OpndDesc::CCS},ISCONDDEF,kLtFpalu,"fcsel","0,1,2,3",1)
+
+/* MOP_wldli -- load 32-bit literal */
+DEFINE_MOP(MOP_wldli, {&OpndDesc::Reg32ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1)
+/* MOP_xldli -- load 64-bit literal */
+DEFINE_MOP(MOP_xldli, {&OpndDesc::Reg64ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad2,"ldr","0,1",1)
+/* MOP_sldli -- load 32-bit literal */
+DEFINE_MOP(MOP_sldli, {&OpndDesc::Reg32FD,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1)
+/* MOP_dldli -- load 64-bit literal */
+DEFINE_MOP(MOP_dldli, {&OpndDesc::Reg64FD,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad2,"ldr","0,1",1)
+
+/* AArch64 branches/calls */
+/* MOP_xbl -- branch with link (call); this is a special definition */
+DEFINE_MOP(MOP_xbl,  {&OpndDesc::AddressName,&OpndDesc::ListSrc},ISCALL|CANTHROW,kLtBranch,"bl","0",1)
+/* MOP_xblr -- branch with link (call) to register; this is a special definition */
+DEFINE_MOP(MOP_xblr, {&OpndDesc::Reg64IS,&OpndDesc::ListSrc},ISCALL|CANTHROW,kLtBranch,"blr","0",1)
+
+/* Tls descriptor */
+/*
+ * add x0, #:tprel_hi12:symbol, lsl #12
+ * add x0, #:tprel_lo12_nc:symbol
+ */
+DEFINE_MOP(MOP_tls_desc_rel, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::LiteralSrc},SPINTRINSIC,kLtAlu,"tlsdescrel","0,1",2)
+
+/*
+ * adrp x0, , :tlsdesc:symbol
+ * ldr x1, [x0, #tlsdesc_lo12:symbol]]
+ * add x0, #tlsdesc_lo12:symbol
+ * .tlsdesccall symbol
+ * blr x1
+ */
+DEFINE_MOP(MOP_tls_desc_call, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::ListSrc},ISCALL|CANTHROW|SPINTRINSIC,kLtBranch,"tlsdesccall","0,1",2)
+
+/* System register access */
+/* MOP_mrs */
+DEFINE_MOP(MOP_mrs, {&OpndDesc::Reg64ID,&OpndDesc::String0S},ISMOVE,kLtAlu,"mrs","0,1",1)
+
+
+/* Inline asm */
+/* Number of instructions generated by inline asm is arbitrary.  Use a large number here. */
+/* asm string, output list, clobber list, input list, output constraint, input constraint, out reg prefix, in reg prefix */
+DEFINE_MOP(MOP_asm, {&OpndDesc::String0S,&OpndDesc::ListDest,&OpndDesc::ListDest,&OpndDesc::ListSrc,&OpndDesc::ListSrc,&OpndDesc::ListSrc,&OpndDesc::ListSrc,&OpndDesc::ListSrc},INLINEASM|CANTHROW|HASACQUIRE|HASRELEASE,kLtUndef,"asm","0,1,2,3",100)
+
+/* c sync builtins */
+/*
+ * intrinsic_sync_lock_test_setI w0, w1, x2, w3, lable1
+ * label1:
+ * ldxr     w0, [x2]
+ * stxr     w1, w3, [x2]
+ * cbnz     w1, label1
+ * dmb      ish
+ */
+DEFINE_MOP(MOP_sync_lock_test_setI, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::AddressName},HASLOOP|CANTHROW|SPINTRINSIC,kLtBranch,"intrinsic_sync_lock_test_setI","0,1,2,3,4",5)
+
+/*
+ * intrinsic_sync_lock_test_setL x0, w1, x2, x3, lable1
+ * label1:
+ * ldxr     x0, [x2]
+ * stxr     w1, x3, [x2]
+ * cbnz     w1, label1
+ * dmb      ish
+ */
+DEFINE_MOP(MOP_sync_lock_test_setL, {&OpndDesc::Reg64ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName},HASLOOP|CANTHROW|SPINTRINSIC,kLtBranch,"intrinsic_sync_lock_test_setL","0,1,2,3,4",5)
+
+/* AARCH64 LOADS */
+/* MOP_wldrsb --- Load Register Signed Byte */
+DEFINE_MOP(MOP_wldrsb, {&OpndDesc::Reg32ID,&OpndDesc::Mem8S},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+/* MOP_xldrsb --- Load Register Signed Byte */
+DEFINE_MOP(MOP_xldrsb, {&OpndDesc::Reg64ID,&OpndDesc::Mem8S},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+/* MOP_wldrb */
+DEFINE_MOP(MOP_wldrb, {&OpndDesc::Reg32ID,&OpndDesc::Mem8S},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+/* MOP_wldrsh  --- Load Register Signed Halfword */
+DEFINE_MOP(MOP_wldrsh, {&OpndDesc::Reg32ID,&OpndDesc::Mem16S},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+/* MOP_xldrsh  --- Load Register Signed Halfword */
+DEFINE_MOP(MOP_xldrsh, {&OpndDesc::Reg64ID,&OpndDesc::Mem16S},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+/* MOP_xldrsw  --- Load Register Signed Word */
+DEFINE_MOP(MOP_xldrsw, {&OpndDesc::Reg64ID,&OpndDesc::Mem32S},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+/* MOP_wldrh */
+DEFINE_MOP(MOP_wldrh, {&OpndDesc::Reg32ID, &OpndDesc::Mem16S},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+/* MOP_wldr */
+DEFINE_MOP(MOP_wldr, {&OpndDesc::Reg32ID,&OpndDesc::Mem32S},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+/* MOP_xldr */
+DEFINE_MOP(MOP_xldr, {&OpndDesc::Reg64ID,&OpndDesc::Mem64S},ISLOAD|CANTHROW,kLtLoad2,"ldr","0,1",1,StrLdr64ImmValid)
+/* MOP_bldr */
+DEFINE_MOP(MOP_bldr, {&OpndDesc::Reg8FD,&OpndDesc::Mem8S},ISLOAD|CANTHROW,kLtFLoad64,"ldr","0,1",1,StrLdr8ImmValid)
+/* MOP_hldr */
+DEFINE_MOP(MOP_hldr, {&OpndDesc::Reg16FD,&OpndDesc::Mem16S},ISLOAD|CANTHROW,kLtFLoad64,"ldr","0,1",1,StrLdr16ImmValid)
+/* MOP_sldr */
+DEFINE_MOP(MOP_sldr, {&OpndDesc::Reg32FD,&OpndDesc::Mem32S},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+/* MOP_dldr */
+DEFINE_MOP(MOP_dldr, {&OpndDesc::Reg64FD,&OpndDesc::Mem64S},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+/* MOP_qldr */
+DEFINE_MOP(MOP_qldr, {&OpndDesc::Reg128VD,&OpndDesc::Mem128S},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+
+/* AArch64 LDP/LDPSW */
+/* MOP_wldp */
+DEFINE_MOP(MOP_wldp, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Mem32S},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+/* MOP_xldp */
+DEFINE_MOP(MOP_xldp, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Mem64S},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+/* MOP_xldpsw */
+DEFINE_MOP(MOP_xldpsw, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Mem32S},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+/* MOP_sldp */
+DEFINE_MOP(MOP_sldp, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::Mem32S},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+/* MOP_dldp */
+DEFINE_MOP(MOP_dldp, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::Mem64S},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+/* MOP_qldp */
+DEFINE_MOP(MOP_qldp, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::Mem128S},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+
+/* AARCH64 Load with Acquire semantics */
+/* MOP_wldarb */
+DEFINE_MOP(MOP_wldarb, {&OpndDesc::Reg32ID,&OpndDesc::Mem8S},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldarb","0,1",1,StrLdr8ImmValid)
+/* MOP_wldarh */
+DEFINE_MOP(MOP_wldarh, {&OpndDesc::Reg32ID, &OpndDesc::Mem16S},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldarh","0,1",1,StrLdr16ImmValid)
+/* MOP_wldar */
+DEFINE_MOP(MOP_wldar, {&OpndDesc::Reg32ID,&OpndDesc::Mem32S},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldar","0,1",1,StrLdr32ImmValid)
+/* MOP_xldar */
+DEFINE_MOP(MOP_xldar, {&OpndDesc::Reg64ID,&OpndDesc::Mem64S},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldar","0,1",1,StrLdr64ImmValid)
+
+/* MOP_wmovkri16 */
+DEFINE_MOP(MOP_wmovkri16, {&OpndDesc::Reg32IDS,&OpndDesc::Imm16,&OpndDesc::Lsl4},ISMOVE,kLtShift,"movk","0,1,2",1,Imm16BitValid)
+/* MOP_xmovkri16 */
+DEFINE_MOP(MOP_xmovkri16, {&OpndDesc::Reg64IDS,&OpndDesc::Imm16,&OpndDesc::Lsl6},ISMOVE,kLtShift,"movk","0,1,2",1,Imm16BitValid)
+
+/* MOP_wmovzri16 */
+DEFINE_MOP(MOP_wmovzri16, {&OpndDesc::Reg32ID,&OpndDesc::Imm16,&OpndDesc::Lsl4},ISMOVE,kLtShift,"movz","0,1,2",1,Imm16BitValid)
+/* MOP_xmovzri16 */
+DEFINE_MOP(MOP_xmovzri16, {&OpndDesc::Reg64ID,&OpndDesc::Imm16,&OpndDesc::Lsl6},ISMOVE,kLtShift,"movz","0,1,2",1,Imm16BitValid)
+
+/* MOP_wmovnri16 */
+DEFINE_MOP(MOP_wmovnri16, {&OpndDesc::Reg32ID,&OpndDesc::Imm16,&OpndDesc::Lsl4},ISMOVE,kLtShift,"movn","0,1,2",1,Imm16BitValid)
+/* MOP_xmovnri16 */
+DEFINE_MOP(MOP_xmovnri16, {&OpndDesc::Reg64ID,&OpndDesc::Imm16,&OpndDesc::Lsl6},ISMOVE,kLtShift,"movn","0,1,2",1,Imm16BitValid)
+
+/* AARCH64 Load exclusive with/without acquire semantics */
+DEFINE_MOP(MOP_wldxrb, {&OpndDesc::Reg32ID,&OpndDesc::Mem8S},ISLOAD|ISATOMIC|CANTHROW,kLtLoad1,"ldxrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldxrh, {&OpndDesc::Reg32ID,&OpndDesc::Mem16S},ISLOAD|ISATOMIC|CANTHROW,kLtLoad1,"ldxrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldxr,  {&OpndDesc::Reg32ID,&OpndDesc::Mem32S},ISLOAD|ISATOMIC|CANTHROW,kLtLoad1,"ldxr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldxr,  {&OpndDesc::Reg64ID,&OpndDesc::Mem64S},ISLOAD|ISATOMIC|CANTHROW,kLtLoad1,"ldxr","0,1",1,StrLdr64ImmValid)
+
+DEFINE_MOP(MOP_wldaxrb,{&OpndDesc::Reg32ID,&OpndDesc::Mem8S},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldaxrh,{&OpndDesc::Reg32ID,&OpndDesc::Mem16S},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldaxr, {&OpndDesc::Reg32ID,&OpndDesc::Mem32S},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldaxr, {&OpndDesc::Reg64ID,&OpndDesc::Mem64S},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxr","0,1",1,StrLdr64ImmValid)
+
+DEFINE_MOP(MOP_wldaxp, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Mem32S},ISLOAD|ISLOADPAIR|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxp","0,1,2",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldaxp, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Mem64S},ISLOAD|ISLOADPAIR|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxp","0,1,2",1,StrLdr64ImmValid)
+
+/* MOP_vsqrts */
+DEFINE_MOP(MOP_vsqrts, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS},CANTHROW,kLtAdvsimdDivS,"fsqrt","0,1",1)
+/* MOP_vsqrtd */
+DEFINE_MOP(MOP_vsqrtd, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS},CANTHROW,kLtAdvsimdDivD,"fsqrt","0,1",1)
+
+
+/* # Non Definitions */
+/* # As far as register allocation is concerned, the instructions below are non-definitions. */
+
+/* MOP_bcs */
+DEFINE_MOP(MOP_bcs, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bcs","1",1)
+/* MOP_bcc */
+DEFINE_MOP(MOP_bcc, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bcc","1",1)
+/* MOP_beq */
+DEFINE_MOP(MOP_beq, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"beq","1",1)
+/* MOP_bne */
+DEFINE_MOP(MOP_bne, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bne","1",1)
+/* MOP_blt */
+DEFINE_MOP(MOP_blt, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"blt","1",1)
+/* MOP_ble */
+DEFINE_MOP(MOP_ble, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"ble","1",1)
+/* MOP_bgt */
+DEFINE_MOP(MOP_bgt, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bgt","1",1)
+/* MOP_bge */
+DEFINE_MOP(MOP_bge, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bge","1",1)
+/* MOP_blo equal to MOP_blt for unsigned comparison */
+DEFINE_MOP(MOP_blo, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"blo","1",1)
+/* MOP_bls equal to MOP_bls for unsigned comparison */
+DEFINE_MOP(MOP_bls, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bls","1",1)
+/* MOP_bhs equal to MOP_bge for unsigned comparison */
+DEFINE_MOP(MOP_bhs, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bhs","1",1)
+/* MOP_bhi equal to MOP_bgt for float comparison */
+DEFINE_MOP(MOP_bhi, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bhi","1",1)
+/* MOP_bpl equal to MOP_bge for float comparison */
+DEFINE_MOP(MOP_bpl, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bpl","1",1)
+DEFINE_MOP(MOP_bmi, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bmi","1",1)
+DEFINE_MOP(MOP_bvc, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bvc","1",1)
+DEFINE_MOP(MOP_bvs, {&OpndDesc::CCS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"bvs","1",1)
+
+/* MOP_xret		AARCH64 Specific */
+DEFINE_MOP(MOP_xret, {},CANTHROW,kLtBranch,"ret","",1)
+/* MOP_clrex    AARCH64 Specific */
+DEFINE_MOP(MOP_clrex, {},CANTHROW,kLtBranch,"clrex","",1)
+
+/* AARCH64 Floating-Point COMPARES signaling versions */
+/* MOP_hcmperi -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_hcmperi, {&OpndDesc::CCD, &OpndDesc::Reg16FS,&OpndDesc::FpImm8},0,kLtFpalu,"fcmpe","1,2",1)
+/* MOP_hcmperr -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_hcmperr, {&OpndDesc::CCD, &OpndDesc::Reg16FS,&OpndDesc::Reg16FS},0,kLtFpalu,"fcmpe","1,2",1)
+
+/* MOP_scmperi -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_scmperi, {&OpndDesc::CCD, &OpndDesc::Reg32FS,&OpndDesc::FpImm8},0,kLtFpalu,"fcmpe","1,2",1)
+/* MOP_scmperr */
+DEFINE_MOP(MOP_scmperr, {&OpndDesc::CCD, &OpndDesc::Reg32FS,&OpndDesc::Reg32FS},0,kLtFpalu,"fcmpe","1,2",1)
+
+/* MOP_dcmperi -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_dcmperi, {&OpndDesc::CCD, &OpndDesc::Reg64FS,&OpndDesc::FpImm8},0,kLtFpalu,"fcmpe","1,2",1)
+/* MOP_dcmperr */
+DEFINE_MOP(MOP_dcmperr, {&OpndDesc::CCD, &OpndDesc::Reg64FS,&OpndDesc::Reg64FS},0,kLtFpalu,"fcmpe","1,2",1)
+
+/* AARCH64 Floating-Point COMPARES non-signaling (quiet) versions */
+/* MOP_hcmpqri -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_hcmpqri, {&OpndDesc::CCD, &OpndDesc::Reg16FS,&OpndDesc::FpImm8},0,kLtFpalu,"fcmp","1,2",1)
+/* MOP_hcmpqrr -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_hcmpqrr, {&OpndDesc::CCD, &OpndDesc::Reg16FS,&OpndDesc::Reg16FS},0,kLtFpalu,"fcmp","1,2",1)
+
+/* MOP_scmpqri -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_scmpqri, {&OpndDesc::CCD, &OpndDesc::Reg32FS,&OpndDesc::FpImm8},0,kLtFpalu,"fcmp","1,2",1)
+/* MOP_scmpqrr */
+DEFINE_MOP(MOP_scmpqrr, {&OpndDesc::CCD, &OpndDesc::Reg32FS,&OpndDesc::Reg32FS},0,kLtFpalu,"fcmp","1,2",1)
+
+/* MOP_dcmpqri -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_dcmpqri, {&OpndDesc::CCD, &OpndDesc::Reg64FS,&OpndDesc::FpImm8},0,kLtFpalu,"fcmp","1,2",1)
+/* MOP_dcmpqrr */
+DEFINE_MOP(MOP_dcmpqrr, {&OpndDesc::CCD, &OpndDesc::Reg64FS,&OpndDesc::Reg64FS},0,kLtFpalu,"fcmp","1,2",1)
+
+/* AARCH64 Integer COMPARES */
+/* MOP_wcmpri -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wcmpri, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Imm12},0,kLtAlu,"cmp","1,2",1,Imm12BitValid)
+/* MOP_wcmprr -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wcmprr, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAlu,"cmp","1,2",1)
+/* MOP_wcmprrs -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wcmprrs, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Bitshift32},0,kLtAlu,"cmp","1,2,3",1)
+/* MOP_wwcmprre -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wwcmprre, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},0,kLtAlu,"cmp","1,2,3",1)
+/* MOP_xcmpri -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xcmpri, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Imm16},0,kLtAlu,"cmp","1,2",1,Imm16BitValid)
+/* MOP_xcmprr -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xcmprr, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAlu,"cmp","1,2",1)
+/* MOP_xcmprrs -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xcmprrs, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},0,kLtAlu,"cmp","1,2,3",1)
+/* MOP_xwcmprre -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xwcmprre, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},0,kLtAlu,"cmp","1,2,3",1)
+
+/* MOP_wccmpriic -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wccmpriic, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Imm5,&OpndDesc::Imm4,&OpndDesc::Cond,&OpndDesc::CCS},0,kLtAlu,"ccmp","1,2,3,4",1)
+/* MOP_wccmprric -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wccmprric, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Imm4,&OpndDesc::Cond,&OpndDesc::CCS},0,kLtAlu,"ccmp","1,2,3,4",1)
+/* MOP_xccmpriic -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xccmpriic, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Imm5,&OpndDesc::Imm4,&OpndDesc::Cond,&OpndDesc::CCS},0,kLtAlu,"ccmp","1,2,3,4",1)
+/* MOP_xccmprric -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xccmprric, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Imm4,&OpndDesc::Cond,&OpndDesc::CCS},0,kLtAlu,"ccmp","1,2,3,4",1)
+
+/* MOP_wcmnri -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wcmnri, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Imm12},0,kLtAlu,"cmn","1,2",1,Imm12BitValid)
+/* MOP_wcmnrr -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wcmnrr, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Reg32IS},0,kLtAlu,"cmn","1,2",1)
+/* MOP_wcmnrrs -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wcmnrrs, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Bitshift32},0,kLtAlu,"cmn","1,2,3",1)
+/* MOP_wwcmnrre -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_wwcmnrre, {&OpndDesc::CCD, &OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},0,kLtAlu,"cmn","1,2,3",1)
+/* MOP_xcmnri -- AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xcmnri, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Imm16},0,kLtAlu,"cmn","1,2",1,Imm16BitValid)
+/* MOP_xcmnrr -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xcmnrr, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Reg64IS},0,kLtAlu,"cmn","1,2",1)
+/* MOP_xcmnrrs -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xcmnrrs, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},0,kLtAlu,"cmn","1,2,3",1)
+/* MOP_xwcmnrre -- register, shifted register, AArch64 cmp has no dest operand */
+DEFINE_MOP(MOP_xwcmnrre, {&OpndDesc::CCD, &OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},0,kLtAlu,"cmn","1,2,3",1)
+
+/* AArch64 branches */
+/* MOP_xbr -- branch to register */
+DEFINE_MOP(MOP_xbr, {&OpndDesc::Reg64IS,&OpndDesc::LiteralSrc},ISUNCONDBRANCH,kLtBranch,"br","0",1)
+/* MOP_Tbbuncond */
+DEFINE_MOP(MOP_xuncond, {&OpndDesc::AddressName},ISUNCONDBRANCH,kLtBranch,"b","0",1)
+
+/* MOP_wcbnz --- Compare and Branch on Nonzero */
+DEFINE_MOP(MOP_wcbnz, {&OpndDesc::Reg32IS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"cbnz","0,1",1)
+/* MOP_xcbnz */
+DEFINE_MOP(MOP_xcbnz, {&OpndDesc::Reg64IS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"cbnz","0,1",1)
+/* MOP_wcbz --- Compare and Branch on zero */
+DEFINE_MOP(MOP_wcbz, {&OpndDesc::Reg32IS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"cbz","0,1",1)
+/* MOP_xcbz */
+DEFINE_MOP(MOP_xcbz, {&OpndDesc::Reg64IS,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"cbz","0,1",1)
+
+/* MOP_wtbnz --- Test bit and Branch if Nonzero */
+DEFINE_MOP(MOP_wtbnz, {&OpndDesc::Reg32IS,&OpndDesc::Imm8,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"tbnz","0,1,2",1)
+/* MOP_xtbnz */
+DEFINE_MOP(MOP_xtbnz, {&OpndDesc::Reg64IS,&OpndDesc::Imm8,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"tbnz","0,1,2",1)
+/* MOP_wtbz --- Test bit and Branch if Zero */
+DEFINE_MOP(MOP_wtbz, {&OpndDesc::Reg32IS,&OpndDesc::Imm8,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"tbz","0,1,2",1)
+/* MOP_xtbz */
+DEFINE_MOP(MOP_xtbz, {&OpndDesc::Reg64IS,&OpndDesc::Imm8,&OpndDesc::AddressName},ISCONDBRANCH,kLtBranch,"tbz","0,1,2",1)
+
+/* AARCH64 STORES */
+/* MOP_wstrb -- Store Register Byte */
+DEFINE_MOP(MOP_wstrb, {&OpndDesc::Reg32IS,&OpndDesc::Mem8D},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+/* MOP_wstrh -- Store Register Halfword */
+DEFINE_MOP(MOP_wstrh, {&OpndDesc::Reg32IS,&OpndDesc::Mem16D},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+/* MOP_wstr -- Store Register Word */
+DEFINE_MOP(MOP_wstr, {&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+/* MOP_xstr -- Store Register Double word */
+DEFINE_MOP(MOP_xstr, {&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+
+/* MOP_sstr -- Store Register SIMD/FP Float */
+DEFINE_MOP(MOP_sstr, {&OpndDesc::Reg32FS,&OpndDesc::Mem32D},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+/* MOP_dstr -- Store Register SIMD/FP Double */
+DEFINE_MOP(MOP_dstr, {&OpndDesc::Reg64FS,&OpndDesc::Mem64D},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+/* MOP_qstr -- Store Register SIMD/FP Double */
+DEFINE_MOP(MOP_qstr, {&OpndDesc::Reg128VS,&OpndDesc::Mem128D},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+
+/* AArch64 STP. */
+/* MOP_wstp */
+DEFINE_MOP(MOP_wstp, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+/* MOP_xstp */
+DEFINE_MOP(MOP_xstp, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr64PairImmValid)
+/* AArch64 does not define STPSW. It has no practical value. */
+/* MOP_sstp */
+DEFINE_MOP(MOP_sstp, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Mem32D},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+/* MOP_dstp */
+DEFINE_MOP(MOP_dstp, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Mem64D},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+/* MOP_qstp */
+DEFINE_MOP(MOP_qstp, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Mem128D},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+
+/* AARCH64 Store with Release semantics */
+/* MOP_wstlrb -- Store-Release Register Byte */
+DEFINE_MOP(MOP_wstlrb, {&OpndDesc::Reg32IS,&OpndDesc::Mem8D},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlrb","0,1",1,StrLdr8ImmValid)
+/* MOP_wstlrh -- Store-Release Register Halfword */
+DEFINE_MOP(MOP_wstlrh, {&OpndDesc::Reg32IS,&OpndDesc::Mem16D},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlrh","0,1",1,StrLdr16ImmValid)
+/* MOP_wstlr -- Store-Release Register Word */
+DEFINE_MOP(MOP_wstlr, {&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlr","0,1",1,StrLdr32ImmValid)
+/* MOP_xstlr -- Store-Release Register Double word */
+DEFINE_MOP(MOP_xstlr, {&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlr","0,1",1,StrLdr64ImmValid)
+
+/* AARCH64 Store exclusive with/without release semantics */
+DEFINE_MOP(MOP_wstxrb, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Mem8D},ISSTORE|ISATOMIC|CANTHROW,kLtStore1,"stxrb","0,1,2",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstxrh, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Mem16D},ISSTORE|ISATOMIC|CANTHROW,kLtStore1,"stxrh","0,1,2",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstxr,  {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISSTORE|ISATOMIC|CANTHROW,kLtStore1,"stxr","0,1,2",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xstxr,  {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISSTORE|ISATOMIC|CANTHROW,kLtStore1,"stxr","0,1,2",1,StrLdr64ImmValid)
+
+DEFINE_MOP(MOP_wstlxrb,{&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Mem8D},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlxrb","0,1,2",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstlxrh,{&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Mem16D},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlxrh","0,1,2",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstlxr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlxr","0,1,2",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xstlxr, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlxr","0,1,2",1,StrLdr64ImmValid)
+
+DEFINE_MOP(MOP_wstlxp, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Mem64D},ISSTORE|ISSTOREPAIR|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlxp","0,1,2,3",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstlxp, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISSTORE|ISSTOREPAIR|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlxp","0,1,2,3",1,StrLdr64ImmValid)
+
+/* Memory barriers */
+/* MOP_dmb_ishld */
+DEFINE_MOP(MOP_dmb_ishld, {}, HASACQUIRE|ISDMB,kLtBranch, "dmb\tishld", "",1)
+/* MOP_dmb_ishst */
+DEFINE_MOP(MOP_dmb_ishst, {}, HASRELEASE|ISDMB,kLtBranch, "dmb\tishst", "",1)
+/* MOP_dmb_ish */
+DEFINE_MOP(MOP_dmb_ish,   {}, HASACQUIRE|HASRELEASE|ISDMB,kLtBranch, "dmb\tish", "",1)
+
+/* Neon simd, r:nonvector reg, u:64b vector reg, v:128b vector reg */
+/* Following ISMOVE vector instructions must be in a group, starting with vmovui and end with vmovvv */
+DEFINE_MOP(MOP_vmovui,  {&OpndDesc::Reg64VD,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"movi","0,1",1)
+DEFINE_MOP(MOP_vmovvi,  {&OpndDesc::Reg128VD,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"movi","0,1",1)
+DEFINE_MOP(MOP_vmovuu,  {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS},ISMOVE|ISVECTOR,kLtFpalu,"mov","0,1",1)
+DEFINE_MOP(MOP_vmovvv,  {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISMOVE|ISVECTOR,kLtFpalu,"mov","0,1",1)
+DEFINE_MOP(MOP_vwmovru, {&OpndDesc::Reg32ID,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"umov","0,1",1)
+DEFINE_MOP(MOP_vwmovrv, {&OpndDesc::Reg32ID,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"umov","0,1",1)
+DEFINE_MOP(MOP_vxmovrv, {&OpndDesc::Reg64ID,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"umov","0,1",1)
+DEFINE_MOP(MOP_vwdupur, {&OpndDesc::Reg64VD,&OpndDesc::Reg32IS},ISVECTOR|SPINTRINSIC,kLtFpalu,"dup","0,1",1)
+DEFINE_MOP(MOP_vwdupvr, {&OpndDesc::Reg128VD,&OpndDesc::Reg32IS},ISVECTOR|SPINTRINSIC,kLtFpalu,"dup","0,1",1)
+DEFINE_MOP(MOP_vxdupur, {&OpndDesc::Reg64VD,&OpndDesc::Reg64IS},ISVECTOR|SPINTRINSIC,kLtFpalu,"dup","0,1",1)
+DEFINE_MOP(MOP_vxdupvr, {&OpndDesc::Reg128VD,&OpndDesc::Reg64IS},ISVECTOR|SPINTRINSIC,kLtFpalu,"dup","0,1",1)
+DEFINE_MOP(MOP_vduprv,  {&OpndDesc::Reg64FD,&OpndDesc::Reg128VS},ISVECTOR|SPINTRINSIC,kLtFpalu,"dup","0,1",1)
+DEFINE_MOP(MOP_vextuuui,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"ext","0,1,2,3",1)
+DEFINE_MOP(MOP_vextvvvi,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"ext","0,1,2,3",1)
+DEFINE_MOP(MOP_vsabdlvuu,{&OpndDesc::Reg128VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtAlu,"sabdl","0,1,2",1)
+DEFINE_MOP(MOP_vuabdlvuu,{&OpndDesc::Reg128VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtAlu,"uabdl","0,1,2",1)
+DEFINE_MOP(MOP_vsabdl2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"sabdl2","0,1,2",1)
+DEFINE_MOP(MOP_vuabdl2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"uabdl2","0,1,2",1)
+DEFINE_MOP(MOP_vspadaluu,{&OpndDesc::Reg64VDS,&OpndDesc::Reg64VS},ISVECTOR,kLtAlu,"sadalp","0,1",1)
+DEFINE_MOP(MOP_vspadalvv,{&OpndDesc::Reg128VDS,&OpndDesc::Reg128VS},ISVECTOR,kLtAlu,"sadalp","0,1",1)
+DEFINE_MOP(MOP_vupadaluu,{&OpndDesc::Reg64VDS,&OpndDesc::Reg64VS},ISVECTOR,kLtAlu,"uadalp","0,1",1)
+DEFINE_MOP(MOP_vupadalvv,{&OpndDesc::Reg128VDS,&OpndDesc::Reg128VS},ISVECTOR,kLtAlu,"uadalp","0,1",1)
+DEFINE_MOP(MOP_vspadduu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS},ISVECTOR,kLtAlu,"saddlp","0,1",1)
+DEFINE_MOP(MOP_vspaddvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtAlu,"saddlp","0,1",1)
+DEFINE_MOP(MOP_vupadduu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS},ISVECTOR,kLtAlu,"uaddlp","0,1",1)
+DEFINE_MOP(MOP_vupaddvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtAlu,"uaddlp","0,1",1)
+DEFINE_MOP(MOP_vwinsur, {&OpndDesc::Reg64VDS,&OpndDesc::Reg32IS},ISVECTOR|SPINTRINSIC,kLtFpalu,"ins","0,1",1)
+DEFINE_MOP(MOP_vxinsur, {&OpndDesc::Reg64VDS,&OpndDesc::Reg64IS},ISVECTOR|SPINTRINSIC,kLtFpalu,"ins","0,1",1)
+DEFINE_MOP(MOP_vwinsvr, {&OpndDesc::Reg128VDS,&OpndDesc::Reg32IS},ISVECTOR|SPINTRINSIC,kLtFpalu,"ins","0,1",1)
+DEFINE_MOP(MOP_vxinsvr, {&OpndDesc::Reg128VDS,&OpndDesc::Reg64IS},ISVECTOR|SPINTRINSIC,kLtFpalu,"ins","0,1",1)
+DEFINE_MOP(MOP_vrev16dd,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"rev16","0,1",1)
+DEFINE_MOP(MOP_vrev32dd,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"rev32","0,1",1)
+DEFINE_MOP(MOP_vrev64dd,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"rev64","0,1",1)
+DEFINE_MOP(MOP_vrev16qq,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"rev16","0,1",1)
+DEFINE_MOP(MOP_vrev32qq,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"rev32","0,1",1)
+DEFINE_MOP(MOP_vrev64qq,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"rev64","0,1",1)
+DEFINE_MOP(MOP_vbaddvru,{&OpndDesc::Reg8FD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"addv","0,1",1)
+DEFINE_MOP(MOP_vhaddvru,{&OpndDesc::Reg16FD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"addv","0,1",1)
+DEFINE_MOP(MOP_vsaddvru,{&OpndDesc::Reg32FD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"addv","0,1",1)
+DEFINE_MOP(MOP_vbaddvrv,{&OpndDesc::Reg8FD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"addv","0,1",1)
+DEFINE_MOP(MOP_vhaddvrv,{&OpndDesc::Reg16FD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"addv","0,1",1)
+DEFINE_MOP(MOP_vsaddvrv,{&OpndDesc::Reg32FD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"addv","0,1",1)
+DEFINE_MOP(MOP_vdaddvrv,{&OpndDesc::Reg64FD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"addp","0,1",1)
+
+DEFINE_MOP(MOP_vzcmequu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmeq","0,1,2",1)
+DEFINE_MOP(MOP_vzcmgtuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmgt","0,1,2",1)
+DEFINE_MOP(MOP_vzcmgeuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmge","0,1,2",1)
+DEFINE_MOP(MOP_vzcmltuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmlt","0,1,2",1)
+DEFINE_MOP(MOP_vzcmleuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmle","0,1,2",1)
+DEFINE_MOP(MOP_vzcmeqvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmeq","0,1,2",1)
+DEFINE_MOP(MOP_vzcmgtvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmgt","0,1,2",1)
+DEFINE_MOP(MOP_vzcmgevv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmge","0,1,2",1)
+DEFINE_MOP(MOP_vzcmltvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmlt","0,1,2",1)
+DEFINE_MOP(MOP_vzcmlevv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"cmle","0,1,2",1)
+DEFINE_MOP(MOP_vcmequuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"cmeq","0,1,2",1)
+DEFINE_MOP(MOP_vcmgeuuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"cmge","0,1,2",1)
+DEFINE_MOP(MOP_vcmgtuuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"cmgt","0,1,2",1)
+DEFINE_MOP(MOP_vcmhiuuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"cmhi","0,1,2",1)
+DEFINE_MOP(MOP_vcmhsuuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"cmhs","0,1,2",1)
+DEFINE_MOP(MOP_vcmeqvvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"cmeq","0,1,2",1)
+DEFINE_MOP(MOP_vcmgevvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"cmge","0,1,2",1)
+DEFINE_MOP(MOP_vcmgtvvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"cmgt","0,1,2",1)
+DEFINE_MOP(MOP_vcmhivvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"cmhi","0,1,2",1)
+DEFINE_MOP(MOP_vcmhsvvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"cmhs","0,1,2",1)
+DEFINE_MOP(MOP_vbsluuu,{&OpndDesc::Reg64VDS,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"bsl","0,1,2",1)
+DEFINE_MOP(MOP_vbslvvv,{&OpndDesc::Reg128VDS,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"bsl","0,1,2",1)
+
+DEFINE_MOP(MOP_vshluuu, {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"sshl","0,1,2",1)
+DEFINE_MOP(MOP_vshlvvv, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"sshl","0,1,2",1)
+DEFINE_MOP(MOP_vushluuu,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"ushl","0,1,2",1)
+DEFINE_MOP(MOP_vushlvvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"ushl","0,1,2",1)
+
+DEFINE_MOP(MOP_vushluui,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"shl","0,1,2",1)
+DEFINE_MOP(MOP_vushlvvi,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"shl","0,1,2",1)
+DEFINE_MOP(MOP_vushruui,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"ushr","0,1,2",1)
+DEFINE_MOP(MOP_vushrvvi,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"ushr","0,1,2",1)
+
+DEFINE_MOP(MOP_vshllvvi,{&OpndDesc::Reg128VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"shll","0,1,2",1)
+DEFINE_MOP(MOP_vushllvvi,{&OpndDesc::Reg128VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"ushll","0,1,2",1)
+DEFINE_MOP(MOP_vxtnuv,  {&OpndDesc::Reg64VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"xtn","0,1",1)
+DEFINE_MOP(MOP_vsxtlvu, {&OpndDesc::Reg128VD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"sxtl","0,1",1)
+DEFINE_MOP(MOP_vuxtlvu, {&OpndDesc::Reg128VD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"uxtl","0,1",1)
+DEFINE_MOP(MOP_vxtn2uv, {&OpndDesc::Reg64VDS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"xtn2","0,1",1)
+DEFINE_MOP(MOP_vsxtl2vv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"sxtl2","0,1",1)
+DEFINE_MOP(MOP_vuxtl2vv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"uxtl2","0,1",1)
+
+DEFINE_MOP(MOP_vshruui, {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"sshr","0,1,2",1)
+DEFINE_MOP(MOP_vshrvvi, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"sshr","0,1,2",1)
+DEFINE_MOP(MOP_vshrnuvi,{&OpndDesc::Reg64VD,&OpndDesc::Reg128VS,&OpndDesc::Imm8},ISVECTOR,kLtFpalu,"shrn","0,1,2",1)
+
+DEFINE_MOP(MOP_vtbl1vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"tbl","0,1,2",1)
+DEFINE_MOP(MOP_vsmaddvvv,{&OpndDesc::Reg128VDS,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"smlal","0,1,2",1)
+DEFINE_MOP(MOP_vumaddvvv,{&OpndDesc::Reg128VDS,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"umlal","0,1,2",1)
+DEFINE_MOP(MOP_vsmullvvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"smull","0,1,2",1)
+DEFINE_MOP(MOP_vumullvvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"umull","0,1,2",1)
+DEFINE_MOP(MOP_vsmull2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"smull2","0,1,2",1)
+DEFINE_MOP(MOP_vumull2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"umull2","0,1,2",1)
+DEFINE_MOP(MOP_vabsuu,  {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"abs","0,1",1)
+DEFINE_MOP(MOP_vabsvv,  {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"abs","0,1",1)
+DEFINE_MOP(MOP_vadduuu, {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"add","0,1,2",1)
+DEFINE_MOP(MOP_vsaddlvuu,{&OpndDesc::Reg128VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"saddl","0,1,2",1)
+DEFINE_MOP(MOP_vuaddlvuu,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"uaddl","0,1,2",1)
+DEFINE_MOP(MOP_vsaddl2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"saddl2","0,1,2",1)
+DEFINE_MOP(MOP_vuaddl2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"uaddl2","0,1,2",1)
+DEFINE_MOP(MOP_vsaddwvvu,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"saddw","0,1,2",1)
+DEFINE_MOP(MOP_vuaddwvvu,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"uaddw","0,1,2",1)
+DEFINE_MOP(MOP_vsaddw2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"saddw2","0,1,2",1)
+DEFINE_MOP(MOP_vuaddw2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"uaddw2","0,1,2",1)
+DEFINE_MOP(MOP_vaddvvv, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"add","0,1,2",1)
+DEFINE_MOP(MOP_vmuluuu, {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"mul","0,1,2",1)
+DEFINE_MOP(MOP_vmulvvv, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"mul","0,1,2",1)
+DEFINE_MOP(MOP_vsubuuu, {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"sub","0,1,2",1)
+DEFINE_MOP(MOP_vsubvvv, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"sub","0,1,2",1)
+DEFINE_MOP(MOP_vanduuu, {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"and","0,1,2",1)
+DEFINE_MOP(MOP_vandvvv, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"and","0,1,2",1)
+DEFINE_MOP(MOP_voruuu,  {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"orr","0,1,2",1)
+DEFINE_MOP(MOP_vorvvv,  {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"orr","0,1,2",1)
+DEFINE_MOP(MOP_vxoruuu, {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"eor","0,1,2",1)
+DEFINE_MOP(MOP_vxorvvv, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"eor","0,1,2",1)
+DEFINE_MOP(MOP_vnotuu,  {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"not","0,1",1)
+DEFINE_MOP(MOP_vnotvv,  {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"not","0,1",1)
+DEFINE_MOP(MOP_vneguu,  {&OpndDesc::Reg64VD,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"neg","0,1",1)
+DEFINE_MOP(MOP_vnegvv,  {&OpndDesc::Reg128VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"neg","0,1",1)
+DEFINE_MOP(MOP_vssublvuu,{&OpndDesc::Reg128VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"ssubl","0,1,2",1)
+DEFINE_MOP(MOP_vusublvuu,{&OpndDesc::Reg128VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"usubl","0,1,2",1)
+DEFINE_MOP(MOP_vssubl2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"ssubl2","0,1,2",1)
+DEFINE_MOP(MOP_vusubl2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"usubl2","0,1,2",1)
+DEFINE_MOP(MOP_vssubwvvu,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"ssubw","0,1,2",1)
+DEFINE_MOP(MOP_vusubwvvu,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"usubw","0,1,2",1)
+DEFINE_MOP(MOP_vssubw2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"ssubw2","0,1,2",1)
+DEFINE_MOP(MOP_vusubw2vvv,{&OpndDesc::Reg128VD,&OpndDesc::Reg128VS,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"usubw2","0,1,2",1)
+DEFINE_MOP(MOP_vzip1vvv,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"zip1","0,1,2",1)
+DEFINE_MOP(MOP_vzip2vvv,{&OpndDesc::Reg64VD,&OpndDesc::Reg64VS,&OpndDesc::Reg64VS},ISVECTOR,kLtFpalu,"zip2","0,1,2",1)
+DEFINE_MOP(MOP_vsqxtnuv,{&OpndDesc::Reg64VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"sqxtn","0,1",1)
+DEFINE_MOP(MOP_vuqxtnuv,{&OpndDesc::Reg64VD,&OpndDesc::Reg128VS},ISVECTOR,kLtFpalu,"uqxtn","0,1",1)
+
+/*
+ * MOP_clinit
+ * will be emit to four instructions in a row:
+ * adrp  xd, :got:__classinfo__Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B
+ * ldr xd, [xd,#:got_lo12:__classinfo__Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B]
+ * ldr xd, [xd,#112]
+ * ldr wzr, [xd]
+ */
+DEFINE_MOP(MOP_clinit, {&OpndDesc::Reg64ID,&OpndDesc::LiteralSrc},ISATOMIC|CANTHROW,kLtClinit,"intrinsic_clinit","0,1",4)
+
+/*
+ * MOP_counter
+ * will be emit to five instructions in a row:
+ * adrp  x1, :got:__profile_table + idx
+ * ldr w17, [x1,#:got_lo12:__profile_table]
+ * add w17, w17, #1
+ * str w17,[x1,,#:got_lo12:__profile_table]
+ */
+DEFINE_MOP(MOP_counter, {&OpndDesc::Reg64ID,&OpndDesc::LiteralSrc},ISATOMIC|CANTHROW,kLtClinit,"intrinsic_counter","0,1", 4)
+
+/*
+ * MOP_c_counter
+ * will be emit to seven instructions in a row:
+ * str x30, [sp , #-16]!
+ * adrp  x16, :got:__profile_table
+ * ldr x16, [x16,#:got_lo12:__profile_table]
+ * ldr x30, [x16 + offset]
+ * add x30, x30, #1
+ * str w30, [x16 + offset]
+ * ldr x30, [sp], #16
+ */
+DEFINE_MOP(MOP_c_counter, {&OpndDesc::LiteralSrc,&OpndDesc::Imm64},ISATOMIC|CANTHROW,kLtClinit,"intrinsic_counter","0,1", 8)
+
+/*
+ * will be emit to two instrunctions in a row:
+ * ldr wd, [xs]  // xd and xs should be differenct register
+ * ldr wd, [xd]
+ */
+DEFINE_MOP(MOP_lazy_ldr, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISATOMIC|CANTHROW|SPINTRINSIC,kLtClinitTail,"intrinsic_lazyload","0,1",2)
+
+/*
+ * will be emit to three instrunctions in a row:
+ * adrp  xd, :got:__staticDecoupleValueOffset$$xxx+offset
+ * ldr xd, [xd,#:got_lo12:__staticDecoupleValueOffset$$xx+offset]
+ * ldr xzr, [xd]
+ */
+DEFINE_MOP(MOP_lazy_ldr_static, {&OpndDesc::Reg64ID,&OpndDesc::LiteralSrc},ISATOMIC|CANTHROW,kLtAdrpLdr,"intrinsic_lazyloadstatic","0,1",3)
+
+/* A pseudo instruction followed MOP_lazy_ldr, to make sure xs and xd be allocated to different physical registers. */
+DEFINE_MOP(MOP_lazy_tail, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},0,kLtUndef,"pseudo_lazy_tail","",0)
+
+/* will be emit to two instructions in a row:
+ * adrp    xd, _PTR__cinf_Ljava_2Flang_2FSystem_3B
+ * ldr     xd, [xd, #:lo12:_PTR__cinf_Ljava_2Flang_2FSystem_3B]
+ * MOP_adrp_ldr
+ */
+DEFINE_MOP(MOP_adrp_ldr, {&OpndDesc::Reg64ID, &OpndDesc::LiteralSrc},ISATOMIC|CANTHROW,kLtAdrpLdr,"intrinsic_adrpldr","0,1",2)
+
+/* will be emit to two instructions in a row:
+ * adrp    xd, label
+ * add     xd, xd, #:lo12:label
+ */
+DEFINE_MOP(MOP_adrp_label, {&OpndDesc::Reg64ID, &OpndDesc::Imm64},0,kLtAlu,"intrinsic_adrplabel","0,1", 2)
+
+/*
+ * will be emit to three instrunctions in a row:
+ * adrp  xd, :got:__arrayClassCacheTable$$xxx+offset
+ * ldr xd, [xd,#:got_lo12:__arrayClassCacheTable$$xx+offset]
+ * ldr xzr, [xd]
+ */
+DEFINE_MOP(MOP_arrayclass_cache_ldr, {&OpndDesc::Reg64ID,&OpndDesc::LiteralSrc},ISATOMIC|CANTHROW,kLtAdrpLdr,"intrinsic_loadarrayclass","0,1",3)
+
+/*
+ * ldr x17, [xs,#112]
+ * ldr wzr, [x17]
+ */
+DEFINE_MOP(MOP_clinit_tail, {&OpndDesc::Reg64IS},ISATOMIC|CANTHROW|SPINTRINSIC,kLtClinitTail,"intrinsic_clinit_tail","0",2)
+
+/*
+ * intrinsic Unsafe.getAndAddInt
+ * intrinsic_get_add_int w0, xt, wt, ws, x1, x2, w3, label
+ * add    xt, x1, x2
+ * label:
+ * ldaxr  w0, [xt]
+ * add    wt, w0, w3
+ * stlxr  ws, wt, [xt]
+ * cbnz   ws, label
+ */
+DEFINE_MOP(MOP_get_and_addI, {&OpndDesc::Reg32ID,&OpndDesc::Reg64ID,&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::AddressName},HASLOOP|CANTHROW|SPINTRINSIC,kLtBranch,"intrinsic_get_add_int","",5)
+/*
+ * intrinsic Unsafe.getAndAddLong
+ * intrinsic_get_add_long x0, xt, xs, ws, x1, x2, x3, ws, label
+ * add    xt, x1, x2
+ * label:
+ * ldaxr  x0, [xt]
+ * add    xs, x0, x3
+ * stlxr  ws, x2, [xt]
+ * cbnz   ws, label
+ */
+DEFINE_MOP(MOP_get_and_addL, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName},HASLOOP|CANTHROW|SPINTRINSIC,kLtBranch,"intrinsic_get_add_long","",5)
+
+/*
+ * intrinsic Unsafe.getAndSetInt
+ * intrinsic_get_set_int w0, xt, x1, x2, w3, label
+ * add    xt, x1, x2
+ * label:
+ * ldaxr  w0, [xt]
+ * stlxr  w2, w3, [xt]
+ * cbnz   w2, label
+ */
+DEFINE_MOP(MOP_get_and_setI, {&OpndDesc::Reg32ID,&OpndDesc::Reg64ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::AddressName},HASLOOP|CANTHROW|SPINTRINSIC,kLtBranch,"intrinsic_get_set_int","0,1,2,3,4",4)
+/*
+ * intrinsic Unsafe.getAndSetLong
+ * intrinsic_get_set_long x0, x1, x2, x3, label
+ * add    xt, x1, x2
+ * label:
+ * ldaxr  x0, [xt]
+ * stlxr  w2, x3, [xt]
+ * cbnz   w2, label
+ */
+DEFINE_MOP(MOP_get_and_setL, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName},HASLOOP|CANTHROW|SPINTRINSIC,kLtBranch,"intrinsic_get_set_long","0,1,2,3,4",4)
+
+/*
+ * intrinsic Unsafe.compareAndSwapInt
+ * intrinsic_compare_swap_int x0, xt, ws, x1, x2, w3, w4, lable1, label2
+ * add       xt, x1, x2
+ * label1:
+ * ldaxr     ws, [xt]
+ * cmp       ws, w3
+ * b.ne      label2
+ * stlxr     ws, w4, [xt]
+ * cbnz      ws, label1
+ * label2:
+ * cset      x0, eq
+ */
+DEFINE_MOP(MOP_compare_and_swapI, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::AddressName,&OpndDesc::AddressName},HASLOOP|CANTHROW|SPINTRINSIC,kLtBranch,"intrinsic_compare_swap_int","0,1,2,3,4,5,6",7)
+/*
+ * intrinsic Unsafe.compareAndSwapLong
+ * intrinsic_compare_swap_long x0, xt, xs, x1, x2, x3, x4, lable1, label2
+ * add       xt, x1, x2
+ * label1:
+ * ldaxr     xs, [xt]
+ * cmp       xs, x3
+ * b.ne      label2
+ * stlxr     ws, x4, [xt]
+ * cbnz      ws, label1
+ * label2:
+ * cset      x0, eq
+ */
+DEFINE_MOP(MOP_compare_and_swapL, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::AddressName},HASLOOP|CANTHROW|SPINTRINSIC,kLtBranch,"intrinsic_compare_swap_long","0,1,2,3,4,5,6",7)
+
+/*
+ * intrinsic String.indexOf(Ljava/lang/String;)I
+ * intrinsic_string_indexof w0, x1, w2, x3, w4, x5, x6, x7, x8, x9, w10, Label.FIRST_LOOP, Label.STR2_NEXT, Label.STR1_LOOP, Label.STR1_NEXT, Label.LAST_WORD, Label.NOMATCH, Label.RET
+ * cmp       w4, w2
+ * b.gt      .Label.NOMATCH
+ * sub       w2, w2, w4
+ * sub       w4, w4, #8
+ * mov       w10, w2
+ * uxtw      x4, w4
+ * uxtw      x2, w2
+ * add       x3, x3, x4
+ * add       x1, x1, x2
+ * neg       x4, x4
+ * neg       x2, x2
+ * ldr       x5, [x3,x4]
+ * .Label.FIRST_LOOP:
+ * ldr       x7, [x1,x2]
+ * cmp       x5, x7
+ * b.eq      .Label.STR1_LOOP
+ * .Label.STR2_NEXT:
+ * adds      x2, x2, #1
+ * b.le      .Label.FIRST_LOOP
+ * b         .Label.NOMATCH
+ * .Label.STR1_LOOP:
+ * adds      x8, x4, #8
+ * add       x9, x2, #8
+ * b.ge      .Label.LAST_WORD
+ * .Label.STR1_NEXT:
+ * ldr       x6, [x3,x8]
+ * ldr       x7, [x1,x9]
+ * cmp       x6, x7
+ * b.ne      .Label.STR2_NEXT
+ * adds      x8, x8, #8
+ * add       x9, x9, #8
+ * b.lt      .Label.STR1_NEXT
+ * .Label.LAST_WORD:
+ * ldr       x6, [x3]
+ * sub       x9, x1, x4
+ * ldr       x7, [x9,x2]
+ * cmp       x6, x7
+ * b.ne      .Label.STR2_NEXT
+ * add       w0, w10, w2
+ * b         .Label.RET
+ * .Label.NOMATCH:
+ * mov       w0, #-1
+ * .Label.RET:
+ */
+DEFINE_MOP(MOP_string_indexof, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IDS,&OpndDesc::Reg32IDS,&OpndDesc::Reg64IDS,&OpndDesc::Reg32IDS,&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg32ID,&OpndDesc::AddressName,&OpndDesc::AddressName,&OpndDesc::AddressName,&OpndDesc::AddressName,&OpndDesc::AddressName,&OpndDesc::AddressName,&OpndDesc::AddressName},HASLOOP|CANTHROW|SPINTRINSIC,kLtBranch,"intrinsic_string_indexof","0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17",36)
+
+/* MOP_tail_call_opt_xbl -- branch without link (call); this is a special definition */
+DEFINE_MOP(MOP_tail_call_opt_xbl,  {&OpndDesc::AddressName,&OpndDesc::ListSrc},CANTHROW|ISTAILCALL,kLtBranch,"b","0", 1)
+/* MOP_tail_call_opt_xblr -- branch without link (call) to register; this is a special definition */
+DEFINE_MOP(MOP_tail_call_opt_xblr, {&OpndDesc::Reg64IS,&OpndDesc::ListSrc},CANTHROW|ISTAILCALL,kLtBranch,"br","0", 1)
+
+/* MOP_pseudo_param_def_x, */
+DEFINE_MOP(MOP_pseudo_param_def_x, {&OpndDesc::Reg64ID},0,kLtUndef,"//MOP_pseudo_param_def","0", 0)
+
+/* MOP_pseudo_param_def_w, */
+DEFINE_MOP(MOP_pseudo_param_def_w, {&OpndDesc::Reg32ID},0,kLtUndef,"//MOP_pseudo_param_def","0", 0)
+
+/* MOP_pseudo_param_def_d, */
+DEFINE_MOP(MOP_pseudo_param_def_d, {&OpndDesc::Reg64FD},0,kLtUndef,"//MOP_pseudo_param_def","0", 0)
+
+/* MOP_pseudo_param_def_s, */
+DEFINE_MOP(MOP_pseudo_param_def_s, {&OpndDesc::Reg32FD},0,kLtUndef,"//MOP_pseudo_param_def","0", 0)
+
+/* MOP_pseudo_param_store_x, */
+DEFINE_MOP(MOP_pseudo_param_store_x, {&OpndDesc::Mem64D},0,kLtUndef,"//MOP_pseudo_param_store_x","0", 0)
+
+/* MOP_pseudo_param_store_w, */
+DEFINE_MOP(MOP_pseudo_param_store_w, {&OpndDesc::Mem32D},0,kLtUndef,"//MOP_pseudo_param_store_w","0", 0)
+
+/* MOP_pseudo_ref_init_x, */
+DEFINE_MOP(MOP_pseudo_ref_init_x, {&OpndDesc::Mem64D},0,kLtUndef,"//MOP_pseudo_ref_init_x","0",  0)
+
+/* MOP_pseudo_ret_int, */
+DEFINE_MOP(MOP_pseudo_ret_int, {&OpndDesc::Reg64IS},0,kLtUndef,"//MOP_pseudo_ret_int","", 0)
+
+/* MOP_pseudo_ret_float, */
+DEFINE_MOP(MOP_pseudo_ret_float, {&OpndDesc::Reg64FS},0,kLtUndef,"//MOP_pseudo_ret_float","", 0)
+
+/* When exception occurs, R0 and R1 may be defined by runtime code. */
+/* MOP_pseudo_eh_def_x, */
+DEFINE_MOP(MOP_pseudo_eh_def_x, {&OpndDesc::Reg64ID},0,kLtUndef,"//MOP_pseudo_eh_def_x","0", 0)
+
+/*MOP_nop */
+DEFINE_MOP(MOP_nop, {},ISNOP,kLtAlu,"nop","", 1)
+
+/* phi node for SSA form */
+/* MOP_xphirr */
+DEFINE_MOP(MOP_xphirr, {&OpndDesc::Reg64ID,&OpndDesc::ListSrc},ISPHI,kLtAlu,"//phi","0,1",1)
+/* MOP_wphirr */
+DEFINE_MOP(MOP_wphirr, {&OpndDesc::Reg32ID,&OpndDesc::ListSrc},ISPHI,kLtAlu,"//phi","0,1",1)
+/* MOP_xvphis */
+DEFINE_MOP(MOP_xvphis, {&OpndDesc::Reg32FD,&OpndDesc::ListSrc},ISPHI,kLtFpalu,"//phi","0,1",1)
+/* MOP_xvphid */
+DEFINE_MOP(MOP_xvphid, {&OpndDesc::Reg64FD,&OpndDesc::ListSrc},ISPHI,kLtFpalu,"//phi","0,1",1)
+/* MOP_xvphivd */
+DEFINE_MOP(MOP_xvphivd, {&OpndDesc::Reg128VD,&OpndDesc::ListSrc},ISPHI,kLtFpalu,"movi","0,1",1)
+
+/* A pseudo instruction that used for seperating dependence graph. */
+/* MOP_pseudo_dependence_seperator, */
+DEFINE_MOP(MOP_pseudo_dependence_seperator, {},0,kLtUndef,"//MOP_pseudo_dependence_seperator","0", 0)
+
+
+/* A pseudo instruction that used for replacing MOP_clinit_tail after clinit merge in scheduling. */
+/* MOP_pseudo_none, */
+DEFINE_MOP(MOP_pseudo_none, {},0,kLtUndef,"//MOP_pseudo_none","0", 0)
+
+/* end of AArch64 instructions */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_mem_md.def b/src/mapleall/maple_be/include/cg/aarch64/aarch64_mem_md.def
new file mode 100644
index 0000000000000000000000000000000000000000..574452818de95db43195c10463c938a729ebb53e
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_mem_md.def
@@ -0,0 +1,356 @@
+/* Load Register Signed Byte */
+DEFINE_MOP(MOP_wldrsb_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrsb_ri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrsb_rr, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrsb_rex, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrsb_rls, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrsb_rlo, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrsb_pri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrsb_poi, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrsb_l, {&OpndDesc::Reg32ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+/* ldrsb */
+DEFINE_MOP(MOP_xldrsb_r, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_xldrsb_ri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_xldrsb_rr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_xldrsb_rex, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_xldrsb_rls, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_xldrsb_rlo, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_xldrsb_pri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_xldrsb_poi, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_xldrsb_l, {&OpndDesc::Reg64ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr8ImmValid)
+/* ldrb */
+DEFINE_MOP(MOP_wldrb_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrb_ri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrb_rr, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrb_rex, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrb_rls, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrb_rlo, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrb_pri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrb_poi, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldrb_l, {&OpndDesc::Reg32ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldrb","0,1",1,StrLdr8ImmValid)
+
+/* Load Register Signed Halfword */
+DEFINE_MOP(MOP_wldrsh_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrsh_ri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrsh_rr, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrsh_rex, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrsh_rls, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrsh_rlo, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrsh_pri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsb","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrsh_poi, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrsh_l, {&OpndDesc::Reg32ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldrss","0,1",1,StrLdr16ImmValid)
+/* ldrsh */
+DEFINE_MOP(MOP_xldrsh_r, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_xldrsh_ri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_xldrsh_rr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_xldrsh_rex, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_xldrsh_rls, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_xldrsh_rlo, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_xldrsh_pri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_xldrsh_poi, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_xldrsh_l, {&OpndDesc::Reg64ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldrsh","0,1",1,StrLdr16ImmValid)
+/* ldrh */
+DEFINE_MOP(MOP_wldrh_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrh_ri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrh_rr, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrh_rex, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrh_rls, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrh_rlo, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrh_pri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrh_poi, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldrh_l, {&OpndDesc::Reg32ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldrh","0,1",1,StrLdr16ImmValid)
+
+/* Load Register Signed Word */
+DEFINE_MOP(MOP_xldrsw_r, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldrsw_ri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldrsw_rr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldrsw_rex, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldrsw_rls, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldrsw_rlo, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldrsw_pri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldrsw_poi, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldrsw_l, {&OpndDesc::Reg64ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldrsw","0,1",1,StrLdr32ImmValid)
+
+/* ldr to w */
+DEFINE_MOP(MOP_wldr_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wldr_ri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wldr_rr, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wldr_rex, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wldr_rls, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wldr_rlo, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wldr_pri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wldr_poi, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wldr_l, {&OpndDesc::Reg32ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+/* ldr to x */
+DEFINE_MOP(MOP_xldr_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldr_ri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldr_rr, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldr_rex, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldr_rls, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldr_rlo, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldr_pri, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldr_poi, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldr_l, {&OpndDesc::Reg32ID,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtLoad1,"ldr","0,1",1,StrLdr32ImmValid)
+
+/* ldr to float reg */
+DEFINE_MOP(MOP_sldr_r, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sldr_ri, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sldr_rr, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sldr_rex, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sldr_rls, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sldr_rlo, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sldr_pri, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sldr_poi, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sldr_l, {&OpndDesc::Reg32FD,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr32ImmValid)
+
+DEFINE_MOP(MOP_dldr_r, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dldr_ri, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dldr_rr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dldr_rex, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dldr_rls, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dldr_rlo, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dldr_pri, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dldr_poi, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dldr_l, {&OpndDesc::Reg64FD,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr64ImmValid)
+
+DEFINE_MOP(MOP_qldr_r, {&OpndDesc::Reg128VD,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qldr_ri, {&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qldr_rr, {&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qldr_rex, {&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qldr_rls, {&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qldr_rlo, {&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qldr_pri, {&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qldr_poi, {&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qldr_l, {&OpndDesc::Reg128VD,&OpndDesc::AddressName},ISLOAD|CANTHROW,kLtFLoadMany,"ldr","0,1",1,StrLdr128ImmValid)
+
+/* ldr to pair reg */
+DEFINE_MOP(MOP_wldp_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wldp_ri, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wldp_rr, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wldp_rex, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wldp_rls, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wldp_rlo, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wldp_pri, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wldp_poi, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wldp_l, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::AddressName},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldp","0,1,2",1,StrLdr32PairImmValid)
+
+DEFINE_MOP(MOP_xldp_r, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_xldp_ri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_xldp_rr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_xldp_rex, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_xldp_rls, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_xldp_rlo, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_xldp_pri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_xldp_poi, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_xldp_l, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::AddressName},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad3plus,"ldp","0,1,2",1,StrLdr64PairImmValid)
+
+DEFINE_MOP(MOP_xldpsw_r, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xldpsw_ri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xldpsw_rr, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xldpsw_rex, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xldpsw_rls, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xldpsw_rlo, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xldpsw_pri, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xldpsw_poi, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xldpsw_l, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::AddressName},ISLOAD|ISLOADPAIR|CANTHROW,kLtLoad2,"ldpsw","0,1,2",1,StrLdr32PairImmValid)
+
+DEFINE_MOP(MOP_sldp_r, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sldp_ri, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sldp_rr, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sldp_rex, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sldp_rls, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sldp_rlo, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sldp_pri, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sldp_poi, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sldp_l, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FD,&OpndDesc::AddressName},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoad64,"ldp","0,1,2",1,StrLdr32PairImmValid)
+
+DEFINE_MOP(MOP_dldp_r, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dldp_ri, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dldp_rr, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dldp_rex, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dldp_rls, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dldp_rlo, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dldp_pri, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dldp_poi, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dldp_l, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FD,&OpndDesc::AddressName},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr64PairImmValid)
+
+DEFINE_MOP(MOP_qldp_r, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qldp_ri, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qldp_rr, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qldp_rex, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qldp_rls, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qldp_rlo, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qldp_pri, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qldp_poi, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qldp_l, {&OpndDesc::Reg128VD,&OpndDesc::Reg128VD,&OpndDesc::AddressName},ISLOAD|ISLOADPAIR|CANTHROW,kLtFLoadMany,"ldp","0,1,2",1,StrLdr128PairImmValid)
+
+/* Load with Acquire semantics */
+DEFINE_MOP(MOP_wldarb_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldarb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldarh_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldarh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldar_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldar","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldar_r, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldar","0,1",1,StrLdr64ImmValid)
+
+/* Load exclusive with/without acquire semantics */
+DEFINE_MOP(MOP_wldxrb_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|CANTHROW,kLtLoad1,"ldxrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldxrh_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|CANTHROW,kLtLoad1,"ldxrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldxr_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|CANTHROW,kLtLoad1,"ldxr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldxr_r, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|CANTHROW,kLtLoad1,"ldxr","0,1",1,StrLdr64ImmValid)
+
+DEFINE_MOP(MOP_wldaxrb_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxrb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wldaxrh_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxrh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wldaxr_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxr","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldaxr_r, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISLOAD|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad1,"ldaxr","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_wldaxp_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg32ID,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad2,"ldaxp","0,1,2",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xldaxp_r, {&OpndDesc::Reg64ID,&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISLOAD|ISLOADPAIR|ISATOMIC|HASACQUIRE|CANTHROW,kLtLoad2,"ldaxp","0,1,2",1,StrLdr64ImmValid)
+
+/* Store Register Byte */
+DEFINE_MOP(MOP_wstrb_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstrb_ri, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstrb_rr, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstrb_rex, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstrb_rls, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstrb_rlo, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstrb_pri, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstrb_poi, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstrb_l, {&OpndDesc::Reg32IS,&OpndDesc::AddressName},ISSTORE|CANTHROW,kLtStore1,"strb","0,1",1,StrLdr8ImmValid)
+
+/* Store Register Halfword */
+DEFINE_MOP(MOP_wstrh_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstrh_ri, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstrh_rr, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstrh_rex, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstrh_rls, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstrh_rlo, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstrh_pri, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstrh_poi, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstrh_l, {&OpndDesc::Reg32IS,&OpndDesc::AddressName},ISSTORE|CANTHROW,kLtStore1,"strh","0,1",1,StrLdr16ImmValid)
+
+/* Store Register Word */
+DEFINE_MOP(MOP_wstr_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wstr_ri, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wstr_rr, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wstr_rex, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wstr_rls, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wstr_rlo, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wstr_pri, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wstr_poi, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_wstr_l, {&OpndDesc::Reg32IS,&OpndDesc::AddressName},ISSTORE|CANTHROW,kLtStore1,"str","0,1",1,StrLdr32ImmValid)
+
+/* Store Register Double word */
+DEFINE_MOP(MOP_xstr_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstr_ri, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstr_rr, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstr_rex, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstr_rls, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstr_rlo, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstr_pri, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstr_poi, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstr_l, {&OpndDesc::Reg64IS,&OpndDesc::AddressName},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr64ImmValid)
+
+/* Store Register SIMD/FP Float */
+DEFINE_MOP(MOP_sstr_r, {&OpndDesc::Reg32FS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sstr_ri, {&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sstr_rr, {&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sstr_rex, {&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sstr_rls, {&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sstr_rlo, {&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sstr_pri, {&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sstr_poi, {&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_sstr_l, {&OpndDesc::Reg32FS,&OpndDesc::AddressName},ISSTORE|CANTHROW,kLtStore2,"str","0,1",1,StrLdr32ImmValid)
+
+/* Store Register SIMD/FP Double */
+DEFINE_MOP(MOP_dstr_r, {&OpndDesc::Reg64FS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dstr_ri, {&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dstr_rr, {&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dstr_rex, {&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dstr_rls, {&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dstr_rlo, {&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dstr_pri, {&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dstr_poi, {&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_dstr_l, {&OpndDesc::Reg64FS,&OpndDesc::AddressName},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr64ImmValid)
+
+/* MOP_qstr -- Store Register SIMD/FP Double */
+DEFINE_MOP(MOP_qstr_r, {&OpndDesc::Reg128VS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qstr_ri, {&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qstr_rr, {&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qstr_rex, {&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qstr_rls, {&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qstr_rlo, {&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qstr_pri, {&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qstr_poi, {&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+DEFINE_MOP(MOP_qstr_l, {&OpndDesc::Reg128VS,&OpndDesc::AddressName},ISSTORE|CANTHROW,kLtStore3plus,"str","0,1",1,StrLdr128ImmValid)
+
+/* store to pair reg */
+DEFINE_MOP(MOP_wstp_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wstp_ri, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wstp_rr, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wstp_rex, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wstp_rls, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wstp_rlo, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wstp_pri, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wstp_poi, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_wstp_l, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::AddressName},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore2,"stp","0,1,2",1,StrLdr32PairImmValid)
+
+/* MOP_xstp */
+DEFINE_MOP(MOP_xstp_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xstp_ri, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xstp_rr, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xstp_rex, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xstp_rls, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xstp_rlo, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xstp_pri, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xstp_poi, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_xstp_l, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::AddressName},ISSTORE|ISSTOREPAIR|CANTHROW,kLtStore3plus,"stp","0,1,2",1,StrLdr32PairImmValid)
+
+/* AArch64 does not define STPSW. It has no practical value. */
+/* MOP_sstp */
+DEFINE_MOP(MOP_sstp_r, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sstp_ri, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sstp_rr, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sstp_rex, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sstp_rls, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sstp_rlo, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sstp_pri, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sstp_poi, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+DEFINE_MOP(MOP_sstp_l, {&OpndDesc::Reg32FS,&OpndDesc::Reg32FS,&OpndDesc::AddressName},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr32PairImmValid)
+
+/* MOP_dstp */
+DEFINE_MOP(MOP_dstp_r, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dstp_ri, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dstp_rr, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dstp_rex, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dstp_rls, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dstp_rlo, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dstp_pri, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dstp_poi, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+DEFINE_MOP(MOP_dstp_l, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS,&OpndDesc::AddressName},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr64PairImmValid)
+
+/* MOP_qstp */
+DEFINE_MOP(MOP_qstp_r, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qstp_ri, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qstp_rr, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qstp_rex, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Reg32IS,&OpndDesc::Extendshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qstp_rls, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Bitshift64},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qstp_rlo, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::AddressName,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qstp_pri, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qstp_poi, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::Reg64IS,&OpndDesc::Imm8},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+DEFINE_MOP(MOP_qstp_l, {&OpndDesc::Reg128VS,&OpndDesc::Reg128VS,&OpndDesc::AddressName},ISSTORE|ISSTOREPAIR|CANTHROW,kLtAdvsimdMulQ,"stp","0,1,2",1,StrLdr128PairImmValid)
+
+/* AARCH64 Store with Release semantics */
+/* MOP_wstlrb -- Store-Release Register Byte */
+DEFINE_MOP(MOP_wstlrb_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlrb","0,1",1,StrLdr8ImmValid)
+/* MOP_wstlrh -- Store-Release Register Halfword */
+DEFINE_MOP(MOP_wstlrh_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlrh","0,1",1,StrLdr16ImmValid)
+/* MOP_wstlr -- Store-Release Register Word */
+DEFINE_MOP(MOP_wstlr_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlr","0,1",1,StrLdr32ImmValid)
+/* MOP_xstlr -- Store-Release Register Double word */
+DEFINE_MOP(MOP_xstlr_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlr","0,1",1,StrLdr64ImmValid)
+
+DEFINE_MOP(MOP_wstxrb_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stxrb","0,1,2",1,StrLdr8ImmValid)
+DEFINE_MOP(MOP_wstxrh_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stxrh","0,1,2",1,StrLdr16ImmValid)
+DEFINE_MOP(MOP_wstxr_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stxr","0,1,2",1,StrLdr32ImmValid)
+DEFINE_MOP(MOP_xstxr_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stxr","0,1,2",1,StrLdr64ImmValid)
+
+DEFINE_MOP(MOP_wstlxp_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS,&OpndDesc::Reg32IS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlxp","0,1,2,3",1,StrLdr64ImmValid)
+DEFINE_MOP(MOP_xstlxp_r, {&OpndDesc::Reg32ID,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS,&OpndDesc::Reg64IS},ISSTORE|ISSTOREPAIR|ISATOMIC|HASRELEASE|CANTHROW,kLtStore1,"stlxp","0,1,2,3",1,StrLdr64ImmValid)
+
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_memlayout.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_memlayout.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b3a1d7942b4a194c52bec19c6cfe0642d7660fe
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_memlayout.h
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_MEMLAYOUT_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_MEMLAYOUT_H
+
+#include "memlayout.h"
+#include "aarch64_abi.h"
+
+namespace maplebe {
+class AArch64SymbolAlloc : public SymbolAlloc {
+ public:
+  AArch64SymbolAlloc() = default;
+
+  ~AArch64SymbolAlloc() = default;
+
+  void SetRegisters(AArch64reg r0, AArch64reg r1, AArch64reg r2, AArch64reg r3) {
+    reg0 = r0;
+    reg1 = r1;
+    reg2 = r2;
+    reg3 = r3;
+  }
+
+  inline bool IsRegister() const {
+    return reg0 != kRinvalid;
+  }
+
+ private:
+  AArch64reg reg0 = kRinvalid;
+  AArch64reg reg1 = kRinvalid;
+  AArch64reg reg2 = kRinvalid;
+  AArch64reg reg3 = kRinvalid;
+};
+
+/*
+ * On AArch64, stack frames are structured as follows:
+ *
+ * The stack grows downward -- full descending (SP points
+ * to a filled slot).
+ *
+ * Any of the parts of a frame is optional, i.e., it is
+ * possible to write a caller-callee pair in such a way
+ * that the particular part is absent in the frame.
+ *
+ * Before a call is made, the frame looks like:
+ * |                            |
+ * ||----------------------------|
+ * | args passed on the stack   | (we call them up-formals)
+ * ||----------------------------|<- Stack Pointer
+ * |                            |
+ *
+ * V1.
+ * Right after a call is made
+ * |                            |
+ * ||----------------------------|
+ * | args passed on the stack   |
+ * ||----------------------------|<- Stack Pointer
+ * | PREV_FP, PREV_LR           |
+ * ||----------------------------|<- Frame Pointer
+ *
+ * After the prologue has run,
+ * |                            |
+ * ||----------------------------|
+ * | args passed on the stack   |
+ * ||----------------------------|
+ * | PREV_FP, PREV_LR           |
+ * ||----------------------------|<- Frame Pointer
+ * | callee-saved registers     |
+ * ||----------------------------|
+ * | empty space. should have   |
+ * | at least 16-byte alignment |
+ * ||----------------------------|
+ * | local variables            |
+ * ||----------------------------|
+ * | variable-sized local vars  |
+ * | (VLAs)                     |
+ * ||----------------------------|<- Stack Pointer
+ *
+ * callee-saved registers include
+ *  1. R19-R28
+ *  2. R8 if return value needs to be returned
+ *     thru memory and callee wants to use R8
+ *  3. we don't need to save R19 if it is used
+ *     as base register for PIE.
+ *  4. V8-V15
+ *
+ * V2. (this way, we may be able to save
+ *     on SP modifying instruction)
+ * Right after a call is made
+ * |                            |
+ * ||----------------------------|
+ * | args passed on the stack   |
+ * ||----------------------------|<- Stack Pointer
+ * |                            |
+ * | empty space                |
+ * |                            |
+ * ||----------------------------|
+ * | PREV_FP, PREV_LR           |
+ * ||----------------------------|<- Frame Pointer
+ *
+ * After the prologue has run,
+ * |                            |
+ * ||----------------------------|
+ * | args passed on the stack   |
+ * ||----------------------------|
+ * | callee-saved registers     |
+ * | including those used for   |
+ * | parameter passing          |
+ * ||----------------------------|
+ * | empty space. should have   |
+ * | at least 16-byte alignment |
+ * ||----------------------------|
+ * | local variables            |
+ * ||----------------------------|
+ * | PREV_FP, PREV_LR           |
+ * ||----------------------------|<- Frame Pointer
+ * | variable-sized local vars  |
+ * | (VLAs)                     |
+ * ||----------------------------|
+ * | args to pass through stack |
+ * ||----------------------------|
+ */
+class AArch64MemLayout : public MemLayout {
+ public:
+  AArch64MemLayout(BECommon &b, MIRFunction &f, MapleAllocator &mallocator)
+      : MemLayout(b, f, mallocator, kAarch64StackPtrAlignment) {}
+
+  ~AArch64MemLayout() override = default;
+
+  /*
+   * Returns stack space required for a call
+   * which is used to pass arguments that cannot be
+   * passed through registers
+   */
+  uint32 ComputeStackSpaceRequirementForCall(StmtNode &stmt, int32 &aggCopySize, bool isIcall) override;
+
+  void LayoutStackFrame(int32 &structCopySize, int32 &maxParmStackSize) override;
+
+  void AssignSpillLocationsToPseudoRegisters() override;
+
+  SymbolAlloc *AssignLocationToSpillReg(regno_t vrNum) override;
+
+  uint64 StackFrameSize() const;
+
+  uint32 RealStackFrameSize() const;
+
+  const MemSegment &Locals() const {
+    return segLocals;
+  }
+
+  uint32 GetSizeOfSpillReg() const {
+    return segSpillReg.GetSize();
+  }
+
+  uint32 GetSizeOfLocals() const {
+    return segLocals.GetSize();
+  }
+
+  void SetSizeOfGRSaveArea(uint32 sz) {
+    segGrSaveArea.SetSize(sz);
+  }
+
+  uint32 GetSizeOfGRSaveArea() const {
+    return segGrSaveArea.GetSize();
+  }
+
+  inline void SetSizeOfVRSaveArea(uint32 sz) {
+    segVrSaveArea.SetSize(sz);
+  }
+
+  uint32 GetSizeOfVRSaveArea() const {
+    return segVrSaveArea.GetSize();
+  }
+
+  uint32 GetSizeOfRefLocals() const {
+    return segRefLocals.GetSize();
+  }
+
+  int32 GetRefLocBaseLoc() const;
+  int32 GetGRSaveAreaBaseLoc() const;
+  int32 GetVRSaveAreaBaseLoc() const;
+  int32 GetCalleeSaveBaseLoc() const override;
+
+ private:
+  MemSegment segRefLocals = MemSegment(kMsRefLocals);
+  /* callee saved register R19-R28 (10) */
+  MemSegment segSpillReg = MemSegment(kMsSpillReg);
+  MemSegment segLocals = MemSegment(kMsLocals);  /* these are accessed via Frame Pointer */
+  MemSegment segGrSaveArea = MemSegment(kMsGrSaveArea);
+  MemSegment segVrSaveArea = MemSegment(kMsVrSaveArea);
+  int32 fixStackSize = 0;
+  void SetSizeAlignForTypeIdx(uint32 typeIdx, uint32 &size, uint32 &align) const;
+  void SetSegmentSize(AArch64SymbolAlloc &symbolAlloc, MemSegment &segment, uint32 typeIdx) const;
+  void LayoutVarargParams();
+  void LayoutFormalParams();
+  void LayoutActualParams();
+  void LayoutLocalVariables(std::vector<MIRSymbol*> &tempVar, std::vector<MIRSymbol*> &returnDelays);
+  void LayoutEAVariales(std::vector<MIRSymbol*> &tempVar);
+  void LayoutReturnRef(std::vector<MIRSymbol*> &returnDelays, int32 &structCopySize, int32 &maxParmStackSize);
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_MEMLAYOUT_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_offset_adjust.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_offset_adjust.h
new file mode 100644
index 0000000000000000000000000000000000000000..28aa82bdfd3cdc5d15f69e0db220cf1dc777a611
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_offset_adjust.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OFFSET_ADJUST_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OFFSET_ADJUST_H
+
+#include "offset_adjust.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+class AArch64FPLROffsetAdjustment : public FrameFinalize {
+ public:
+  explicit AArch64FPLROffsetAdjustment(CGFunc &func) : FrameFinalize(func) {}
+
+  ~AArch64FPLROffsetAdjustment() override = default;
+
+  void Run() override;
+
+ private:
+  void AdjustmentOffsetForOpnd(Insn &insn, AArch64CGFunc &aarchCGFunc) const;
+  void AdjustmentOffsetForImmOpnd(Insn &insn, uint32 index, AArch64CGFunc &aarchCGFunc) const;
+  void AdjustmentOffsetForFPLR();
+  /* frame pointer(x29) is available as a general-purpose register if useFP is set as false */
+  void AdjustmentStackPointer(Insn &insn, AArch64CGFunc &aarchCGFunc) const;
+};
+} /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OFFSET_ADJUST_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_operand.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_operand.h
new file mode 100644
index 0000000000000000000000000000000000000000..c04b3775bc1ec02cce0d4e434ff7c1ec9132f6aa
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_operand.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OPERAND_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OPERAND_H
+
+#include <limits>
+#include <string>
+#include <iomanip>
+#include "aarch64_isa.h"
+#include "operand.h"
+#include "cg.h"
+#include "emit.h"
+#include "common_utils.h"
+
+namespace std {
+template<> /* function-template-specialization */
+class std::hash<maplebe::MemOperand> {
+ public:
+  size_t operator()(const maplebe::MemOperand &x) const {
+    std::size_t seed = 0;
+    hash_combine<uint8_t>(seed, x.GetAddrMode());
+    hash_combine<uint32_t>(seed, x.GetSize());
+    maplebe::RegOperand *xb = x.GetBaseRegister();
+    maplebe::RegOperand *xi = x.GetIndexRegister();
+    if (xb != nullptr) {
+      hash_combine<uint32_t>(seed, xb->GetRegisterNumber());
+      hash_combine<uint32_t>(seed, xb->GetSize());
+    }
+    if (xi != nullptr) {
+      hash_combine<uint32_t>(seed, xi->GetRegisterNumber());
+      hash_combine<uint32_t>(seed, xi->GetSize());
+    }
+    return seed;
+  }
+};
+}
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OPERAND_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_opt_utiles.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_opt_utiles.h
new file mode 100644
index 0000000000000000000000000000000000000000..52aa468d8e5d6f178460fed68a13f90bd3a46d89
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_opt_utiles.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef OPENARKCOMPILER_AARCH64_OPT_UTILES_H
+#define OPENARKCOMPILER_AARCH64_OPT_UTILES_H
+#include "types_def.h"
+
+namespace maplebe {
+using namespace maple;
+enum ExMOpType : uint8 {
+  kExUndef,
+  kExAdd,  /* MOP_xaddrrr | MOP_xxwaddrrre | MOP_xaddrrrs */
+  kEwAdd,  /* MOP_waddrrr | MOP_wwwaddrrre | MOP_waddrrrs */
+  kExSub,  /* MOP_xsubrrr | MOP_xxwsubrrre | MOP_xsubrrrs */
+  kEwSub,  /* MOP_wsubrrr | MOP_wwwsubrrre | MOP_wsubrrrs */
+  kExCmn,  /* MOP_xcmnrr | MOP_xwcmnrre | MOP_xcmnrrs */
+  kEwCmn,  /* MOP_wcmnrr | MOP_wwcmnrre | MOP_wcmnrrs */
+  kExCmp,  /* MOP_xcmprr | MOP_xwcmprre | MOP_xcmprrs */
+  kEwCmp,  /* MOP_wcmprr | MOP_wwcmprre | MOP_wcmprrs */
+};
+
+enum LsMOpType : uint8 {
+  kLsUndef,
+  kLxAdd,  /* MOP_xaddrrr | MOP_xaddrrrs */
+  kLwAdd,  /* MOP_waddrrr | MOP_waddrrrs */
+  kLxSub,  /* MOP_xsubrrr | MOP_xsubrrrs */
+  kLwSub,  /* MOP_wsubrrr | MOP_wsubrrrs */
+  kLxCmn,  /* MOP_xcmnrr | MOP_xcmnrrs */
+  kLwCmn,  /* MOP_wcmnrr | MOP_wcmnrrs */
+  kLxCmp,  /* MOP_xcmprr | MOP_xcmprrs */
+  kLwCmp,  /* MOP_wcmprr | MOP_wcmprrs */
+  kLxEor,  /* MOP_xeorrrr | MOP_xeorrrrs */
+  kLwEor,  /* MOP_weorrrr | MOP_weorrrrs */
+  kLxNeg,  /* MOP_xinegrr | MOP_xinegrrs */
+  kLwNeg,  /* MOP_winegrr | MOP_winegrrs */
+  kLxIor,  /* MOP_xiorrrr | MOP_xiorrrrs */
+  kLwIor,  /* MOP_wiorrrr | MOP_wiorrrrs */
+};
+
+enum SuffixType : uint8 {
+  kNoSuffix, /* no suffix or do not perform the optimization. */
+  kLSL,      /* logical shift left */
+  kLSR,      /* logical shift right */
+  kASR,      /* arithmetic shift right */
+  kROR,      /* rotate shift right */
+  kExten     /* ExtendOp */
+};
+
+inline constexpr uint32 kExtenAddShiftNum = 6;
+inline SuffixType kDoOptimizeTable[kExtenAddShiftNum][kExtenAddShiftNum] = {
+    { kNoSuffix, kLSL,      kLSR,      kASR,      kROR,      kExten },    /* useType == kNoSuffix */
+    { kNoSuffix, kLSL,      kNoSuffix, kNoSuffix, kNoSuffix, kExten },    /* useType == kLSL */
+    { kNoSuffix, kNoSuffix, kLSR,      kNoSuffix, kNoSuffix, kNoSuffix }, /* useType == kLSR */
+    { kNoSuffix, kNoSuffix, kNoSuffix, kASR,      kNoSuffix, kNoSuffix }, /* useType == kASR */
+    { kNoSuffix, kNoSuffix, kNoSuffix, kNoSuffix, kROR,      kNoSuffix }, /* useType == kROR */
+    { kNoSuffix, kNoSuffix, kNoSuffix, kNoSuffix, kNoSuffix, kExten },    /* useType == kExten */
+};
+}
+
+#endif /* OPENARKCOMPILER_AARCH64_OPT_UTILES_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_optimize_common.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_optimize_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..52ab2539cefc57769d8ccfea5859f4bccd33490b
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_optimize_common.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OPTIMIZE_COMMON_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OPTIMIZE_COMMON_H
+
+#include "aarch64_isa.h"
+#include "optimize_common.h"
+
+namespace maplebe {
+using namespace maple;
+
+
+class AArch64InsnVisitor : public InsnVisitor {
+ public:
+  explicit AArch64InsnVisitor(CGFunc &func) : InsnVisitor(func) {}
+
+  ~AArch64InsnVisitor() override = default;
+
+  void ModifyJumpTarget(maple::LabelIdx targetLabel, BB &bb) override;
+  void ModifyJumpTarget(Operand &targetOperand, BB &bb) override;
+  void ModifyJumpTarget(BB &newTarget, BB &bb) override;
+  /* Check if it requires to add extra gotos when relocate bb */
+  Insn *CloneInsn(Insn &originalInsn) override;
+  LabelIdx GetJumpLabel(const Insn &insn) const override;
+  bool IsCompareInsn(const Insn &insn) const override;
+  bool IsCompareAndBranchInsn(const Insn &insn) const override;
+  bool IsAddOrSubInsn(const Insn &insn) const override;
+  RegOperand *CreateVregFromReg(const RegOperand &pReg) override;
+  void ReTargetSuccBB(BB &bb, LabelIdx newTarget) const override;
+  void FlipIfBB(BB &bb, LabelIdx ftLabel) const override;
+  BB *CreateGotoBBAfterCondBB(BB &bb, BB &fallthru, bool isTargetFallthru) const override;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OPTIMIZE_COMMON_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_peep.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_peep.h
new file mode 100644
index 0000000000000000000000000000000000000000..d55c8ab75b5a1de5a0330da98034b2bbc01c9b07
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_peep.h
@@ -0,0 +1,1641 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_PEEP_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_PEEP_H
+
+#include <vector>
+#include "peep.h"
+#include "aarch64_cg.h"
+#include "optimize_common.h"
+#include "mir_builder.h"
+
+namespace maplebe {
+class AArch64CGPeepHole : CGPeepHole {
+ public:
+  /* normal constructor */
+  AArch64CGPeepHole(CGFunc &f, MemPool *memPool) : CGPeepHole(f, memPool) {};
+  /* constructor for ssa */
+  AArch64CGPeepHole(CGFunc &f, MemPool *memPool, CGSSAInfo *cgssaInfo) : CGPeepHole(f, memPool, cgssaInfo) {};
+  ~AArch64CGPeepHole() = default;
+
+  void Run() override;
+  bool DoSSAOptimize(BB &bb, Insn &insn) override;
+  void DoNormalOptimize(BB &bb, Insn &insn) override;
+};
+
+/*
+* i.   cmp     x0, x1
+*      cset    w0, EQ     ===>   cmp x0, x1
+*      cmp     w0, #0            cset w0, EQ
+*      cset    w0, NE
+*
+* ii.  cmp     x0, x1
+*      cset    w0, EQ     ===>   cmp x0, x1
+*      cmp     w0, #0            cset w0, NE
+*      cset    w0, EQ
+*/
+class ContinuousCmpCsetPattern : public CGPeepPattern {
+ public:
+  ContinuousCmpCsetPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~ContinuousCmpCsetPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "ContinuousCmpCsetPattern";
+  }
+
+ private:
+  bool CheckCondCode(const CondOperand &condOpnd) const;
+  Insn *prevCmpInsn = nullptr;
+  Insn *prevCsetInsn1 = nullptr;
+  Insn *prevCmpInsn1 = nullptr;
+  bool reverse = false;
+};
+
+/*
+ * Example 1)
+ *  mov w5, #1
+ *   ...
+ *  mov w0, #0
+ *  csel w5, w5, w0, NE    ===> cset w5, NE
+ *
+ * Example 2)
+ *  mov w5, #0
+ *   ...
+ *  mov w0, #1
+ *  csel w5, w5, w0, NE    ===> cset w5,EQ
+ *
+ * conditions:
+ * 1. mov_imm1 value is 0(1) && mov_imm value is 1(0)
+ */
+class CselToCsetPattern : public CGPeepPattern {
+ public:
+  CselToCsetPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~CselToCsetPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "CselToCsetPattern";
+  }
+
+ private:
+  bool IsOpndDefByZero(const Insn &insn) const;
+  bool IsOpndDefByOne(const Insn &insn) const;
+  Insn *prevMovInsn1 = nullptr;
+  Insn *prevMovInsn2 = nullptr;
+};
+
+/*
+ *  cset w0, HS
+ *  add w2, w1, w0    ===> cinc w2, w1, hs
+ *
+ *  cset w0, HS
+ *  add w2, w0, w1    ===> cinc w2, w1, hs
+ */
+class CsetToCincPattern : public CGPeepPattern {
+ public:
+  CsetToCincPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~CsetToCincPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  bool CheckDefInsn(const RegOperand &opnd, Insn &insn);
+  bool CheckRegTyCc(const Insn &tempDefInsn, Insn &insn);
+  std::string GetPatternName() override {
+    return "CsetToCincPattern";
+  }
+
+ private:
+  Insn *defInsn = nullptr;
+  int32 csetOpnd1 = 0;
+};
+
+/*
+ * combine cset & cbz/cbnz ---> beq/bne
+ * Example 1)
+ *  cset    w0, EQ            or       cset    w0, NE
+ *  cbnz    w0, .label                 cbnz    w0, .label
+ *  ===> beq .label                    ===> bne .label
+ *
+ * Case: same conditon_code
+ *
+ * Example 2)
+ *  cset    w0, EQ            or       cset    w0, NE
+ *  cbz     w0, .label                 cbz    w0, .label
+ *  ===> bne .label                    ===> beq .label
+ *
+ * Case: reversed condition_code
+ */
+class CsetCbzToBeqPattern : public CGPeepPattern {
+ public:
+  CsetCbzToBeqPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~CsetCbzToBeqPattern() override = default;
+  std::string GetPatternName() override {
+    return "CsetCbzToBeqPattern";
+  }
+  bool CheckCondition(Insn &insn) override;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  MOperator SelectNewMop(ConditionCode condCode, bool inverse) const;
+  Insn *prevInsn = nullptr;
+};
+
+/*
+ * combine neg & cmp --> cmn
+ * Example 1)
+ *  neg x0, x6
+ *  cmp x2, x0                --->    (currInsn)
+ *  ===> cmn x2, x6
+ *
+ * Example 2)
+ *  neg x0, x6, LSL #5
+ *  cmp x2, x0                --->    (currInsn)
+ *  ===> cmn x2, x6, LSL #5
+ *
+ * Conditions:
+ * 1. neg_amount_val is valid in cmn amount range
+ */
+class NegCmpToCmnPattern : public CGPeepPattern {
+ public:
+  NegCmpToCmnPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~NegCmpToCmnPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "NegCmpToCmnPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+};
+
+/*
+ * case:
+ * ldr R261(32), [R197, #300]
+ * ldr R262(32), [R208, #12]
+ * cmp (CC) R261, R262
+ * bne lable175.
+ * ldr R264(32), [R197, #304]
+ * ldr R265(32), [R208, #16]
+ * cmp (CC) R264, R265
+ * bne lable175.
+ * ====>
+ * ldr R261(64), [R197, #300]
+ * ldr R262(64), [R208, #12]
+ * cmp (CC) R261, R262
+ * bne lable175.
+ */
+class LdrCmpPattern : public CGPeepPattern {
+ public:
+  LdrCmpPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn) : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~LdrCmpPattern() override {
+    prevLdr1 = nullptr;
+    prevLdr2 = nullptr;
+    ldr1 = nullptr;
+    ldr2 = nullptr;
+    prevCmp = nullptr;
+    bne1 = nullptr;
+    bne2 = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "LdrCmpPattern";
+  }
+
+ private:
+  bool IsLdr(const Insn *insn) const {
+    if (insn == nullptr) {
+      return false;
+    }
+    return insn->GetMachineOpcode() == MOP_wldr;
+  }
+
+  bool IsCmp(const Insn *insn) const {
+    if (insn == nullptr) {
+      return false;
+    }
+    return insn->GetMachineOpcode() == MOP_wcmprr;
+  }
+
+  bool IsBne(const Insn *insn) const {
+    if (insn == nullptr) {
+      return false;
+    }
+    return insn->GetMachineOpcode() == MOP_bne;
+  }
+
+  bool SetInsns();
+  bool CheckInsns() const;
+  bool MemOffet4Bit(const MemOperand &m1, const MemOperand &m2) const;
+  Insn *prevLdr1 = nullptr;
+  Insn *prevLdr2 = nullptr;
+  Insn *ldr1 = nullptr;
+  Insn *ldr2 = nullptr;
+  Insn *prevCmp = nullptr;
+  Insn *bne1 = nullptr;
+  Insn *bne2 = nullptr;
+};
+
+/*
+ * combine {sxtw / uxtw} & lsl ---> {sbfiz / ubfiz}
+ * sxtw  x1, w0
+ * lsl   x2, x1, #3    ===>   sbfiz x2, x0, #3, #32
+ *
+ * uxtw  x1, w0
+ * lsl   x2, x1, #3    ===>   ubfiz x2, x0, #3, #32
+ */
+class ExtLslToBitFieldInsertPattern : public CGPeepPattern {
+ public:
+  ExtLslToBitFieldInsertPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~ExtLslToBitFieldInsertPattern() override = default;
+  std::string GetPatternName() override {
+    return "ExtLslToBitFieldInsertPattern";
+  }
+  bool CheckCondition(Insn &insn) override;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  Insn *prevInsn = nullptr;
+};
+
+/*
+ * Optimize the following patterns:
+ * Example 1)
+ *  and  w0, w6, #1  ====> tbz  w6, #0, .label
+ *  cmp  w0, #1
+ *  bne  .label
+ *
+ *  and  w0, w6, #16  ====> tbz  w6, #4, .label
+ *  cmp  w0, #16
+ *  bne  .label
+ *
+ *  and  w0, w6, #32  ====> tbnz  w6, #5, .label
+ *  cmp  w0, #32
+ *  beq  .label
+ *
+ * Conditions:
+ * 1. cmp_imm value == and_imm value
+ * 2. (and_imm value is (1 << n)) && (cmp_imm value is (1 << n))
+ *
+ * Example 2)
+ *  and  x0, x6, #32  ====> tbz  x6, #5, .label
+ *  cmp  x0, #0
+ *  beq  .label
+ *
+ *  and  x0, x6, #32  ====> tbnz  x6, #5, .label
+ *  cmp  x0, #0
+ *  bne  .labelSimplifyMulArithmeticPattern
+ *
+ * Conditions:
+ * 1. (cmp_imm value is 0) || (cmp_imm == and_imm)
+ * 2. and_imm value is (1 << n)
+ */
+class AndCmpBranchesToTbzPattern : public CGPeepPattern {
+ public:
+  AndCmpBranchesToTbzPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~AndCmpBranchesToTbzPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "AndCmpBranchesToTbzPattern";
+  }
+
+ private:
+  bool CheckAndSelectPattern(const Insn &currInsn);
+  Insn *prevAndInsn = nullptr;
+  Insn *prevCmpInsn = nullptr;
+  MOperator newMop = MOP_undef;
+  int64 tbzImmVal = -1;
+};
+
+/*
+ * optimize the following patterns:
+ * Example 1)
+ * cmp w1, wzr
+ * bge .label        ====> tbz w1, #31, .label
+ *
+ * cmp wzr, w1
+ * ble .label        ====> tbz w1, #31, .label
+ *
+ * cmp w1,wzr
+ * blt .label        ====> tbnz w1, #31, .label
+ *
+ * cmp wzr, w1
+ * bgt .label        ====> tbnz w1, #31, .label
+ *
+ *
+ * Example 2)
+ * cmp w1, #0
+ * bge .label        ====> tbz w1, #31, .label
+ *
+ * cmp w1, #0
+ * blt .label        ====> tbnz w1, #31, .label
+ */
+class ZeroCmpBranchesToTbzPattern : public CGPeepPattern {
+ public:
+  ZeroCmpBranchesToTbzPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~ZeroCmpBranchesToTbzPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "ZeroCmpBranchesToTbzPattern";
+  }
+
+ private:
+  bool CheckAndSelectPattern(const Insn &currInsn);
+  Insn *prevInsn = nullptr;
+  MOperator newMop = MOP_undef;
+  RegOperand *regOpnd = nullptr;
+};
+
+/*
+ * mvn  w3, w3          ====> bic  w3, w5, w3
+ * and  w3, w5, w3
+ * ====>
+ * mvn  x3, x3          ====> bic  x3, x5, x3
+ * and  x3, x5, x3
+ */
+class MvnAndToBicPattern : public CGPeepPattern {
+ public:
+  MvnAndToBicPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~MvnAndToBicPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "MvnAndToBicPattern";
+  }
+
+ private:
+  Insn *prevInsn1 = nullptr;
+  Insn *prevInsn2 = nullptr;
+  bool op1IsMvnDef = false;
+  bool op2IsMvnDef = false;
+};
+
+/*
+ * and r0, r1, #4                  (the imm is n power of 2)
+ * ...
+ * cbz r0, .Label
+ * ===>  tbz r1, #2, .Label
+ *
+ * and r0, r1, #4                  (the imm is n power of 2)
+ * ...
+ * cbnz r0, .Label
+ * ===>  tbnz r1, #2, .Label
+ */
+class AndCbzToTbzPattern : public CGPeepPattern {
+ public:
+  AndCbzToTbzPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  AndCbzToTbzPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~AndCbzToTbzPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "AndCbzToTbzPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+};
+
+class CombineSameArithmeticPattern : public CGPeepPattern {
+ public:
+  CombineSameArithmeticPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~CombineSameArithmeticPattern() override {
+    prevInsn = nullptr;
+    newImmOpnd = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "CombineSameArithmeticPattern";
+  }
+
+ private:
+  std::vector<MOperator> validMops = {MOP_wlsrrri5, MOP_xlsrrri6, MOP_wasrrri5, MOP_xasrrri6, MOP_wlslrri5,
+                                      MOP_xlslrri6, MOP_waddrri12, MOP_xaddrri12, MOP_wsubrri12, MOP_xsubrri12};
+  Insn *prevInsn = nullptr;
+  ImmOperand *newImmOpnd = nullptr;
+};
+
+/*
+ * Specific Extension Elimination, includes sxt[b|h|w] & uxt[b|h|w]. There are  scenes:
+ * 1. PrevInsn is mov
+ * Example 1)
+ *  mov    w0, #imm                    or    mov    w0, #imm
+ *  sxt{}  w0, w0                            uxt{}  w0, w0
+ *  ===> mov w0, #imm                        ===> mov w0, #imm
+ *       mov w0, w0                               mov w0, w0
+ *
+ * Example 2)
+ *  mov    w0, R0
+ *  uxt{}  w0, w0
+ *  ===> mov w0, R0
+ *       mov w0, w0
+ *
+ * Conditions:
+ * 1) #imm is not out of range depend on extention valid bits.
+ * 2) [mov w0, R0] is return value of call and return size is not of range
+ * 3) mov.destOpnd.size = ext.destOpnd.size
+ *
+ *
+ * 2. PrevInsn is ldr[b|h|sb|sh]
+ * Example 1)
+ *  ldrb x1, []
+ *  and  x1, x1, #imm
+ *  ===> ldrb x1, []
+ *       mov  x1, x1
+ *
+ * Example 2)
+ *  ldrb x1, []           or   ldrb x1, []          or   ldrsb x1, []          or   ldrsb x1, []          or
+ *  sxtb x1, x1                uxtb x1, x1               sxtb  x1, x1               uxtb  x1, x1
+ *  ===> ldrsb x1, []          ===> ldrb x1, []          ===> ldrsb x1, []          ===> ldrb x1, []
+ *       mov   x1, x1               mov  x1, x1               mov   x1, x1               mov  x1, x1
+ *
+ *  ldrh x1, []           or   ldrh x1, []          or   ldrsh x1, []          or   ldrsh x1, []          or
+ *  sxth x1, x1                uxth x1, x1               sxth  x1, x1               uxth  x1, x1
+ *  ===> ldrsh x1, []          ===> ldrh x1, []          ===> ldrsh x1, []          ===> ldrb x1, []
+ *       mov   x1, x1               mov  x1, x1               mov   x1, x1               mov  x1, x1
+ *
+ *  ldrsw x1, []          or   ldrsw x1, []
+ *  sxtw  x1, x1               uxtw x1, x1
+ *  ===> ldrsw x1, []          ===> no change
+ *       mov   x1, x1
+ *
+ * Example 3)
+ *  ldrb x1, []           or   ldrb x1, []          or   ldrsb x1, []          or   ldrsb x1, []          or
+ *  sxth x1, x1                uxth x1, x1               sxth  x1, x1               uxth  x1, x1
+ *  ===> ldrb x1, []           ===> ldrb x1, []          ===> ldrsb x1, []          ===> no change
+ *       mov  x1, x1                mov  x1, x1               mov   x1, x1
+ *
+ *  ldrb x1, []           or   ldrh x1, []          or   ldrsb x1, []          or   ldrsh x1, []          or
+ *  sxtw x1, x1                sxtw x1, x1               sxtw  x1, x1               sxtw  x1, x1
+ *  ===> ldrb x1, []           ===> ldrh x1, []          ===> ldrsb x1, []          ===> ldrsh x1, []
+ *       mov  x1, x1                mov  x1, x1               mov   x1, x1               mov   x1, x1
+ *
+ *  ldr  x1, []
+ *  sxtw x1, x1
+ *  ===> ldrsw x1, []
+ *       mov   x1, x1
+ *
+ * Cases:
+ * 1) extension size == load size -> change the load type or eliminate the extension
+ * 2) extension size >  load size -> possibly eliminating the extension
+ *
+ *
+ * 3. PrevInsn is same sxt / uxt
+ * Example 1)
+ *  sxth x1, x2
+ *  sxth x3, x1
+ *  ===> sxth x1, x2
+ *       mov  x3, x1
+ *
+ * Example 2)
+ *  sxtb x1, x2          or    uxtb  w0, w0
+ *  sxth x3, x1                uxth  w0, w0
+ *  ===> sxtb x1, x2           ===> uxtb  w0, w0
+ *       mov  x3, x1                mov   x0, x0
+ *
+ * Conditions:
+ * 1) ext1.destOpnd.size == ext2.destOpnd.size
+ * 2) ext1.destOpnd.regNo == ext2.destOpnd.regNo
+ *    === prop ext1.destOpnd to ext2.srcOpnd, transfer ext2 to mov
+ *
+ * Cases:
+ * 1) ext1 type == ext2 type ((sxth32 & sxth32) || (sxth64 & sxth64) || ...)
+ * 2) ext1 type  < ext2 type ((sxtb32 & sxth32) || (sxtb64 & sxth64) || (sxtb64 & sxtw64) ||
+ *                            (sxth64 & sxtw64) || (uxtb32 & uxth32))
+ */
+class ElimSpecificExtensionPattern : public CGPeepPattern {
+ public:
+  ElimSpecificExtensionPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~ElimSpecificExtensionPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "ElimSpecificExtensionPattern";
+  }
+
+ protected:
+  enum SpecificExtType : uint8 {
+    EXTUNDEF = 0,
+    SXTB,
+    SXTH,
+    SXTW,
+    UXTB,
+    UXTH,
+    UXTW,
+    SETS    /* SETS */
+  };
+  enum OptSceneType : uint8 {
+    kSceneUndef = 0,
+    kSceneMov,
+    kSceneLoad,
+    kSceneSameExt
+  };
+  static constexpr uint8 kPrevLoadPatternNum = 6;
+  static constexpr uint8 kPrevLoadMappingNum = 2;
+  static constexpr uint8 kValueTypeNum = 2;
+  static constexpr uint64 kInvalidValue = 0;
+  static constexpr uint8 kSameExtPatternNum = 4;
+  static constexpr uint8 kSameExtMappingNum = 2;
+  uint64 extValueRangeTable[SETS][kValueTypeNum] = {
+      /* {minValue, maxValue} */
+      {kInvalidValue, kInvalidValue},          /* UNDEF */
+      {0xFFFFFFFFFFFFFF80, 0x7F},              /* SXTB */
+      {0xFFFFFFFFFFFF8000, 0x7FFF},            /* SXTH */
+      {0xFFFFFFFF80000000, kInvalidValue},     /* SXTW */
+      {0xFFFFFFFFFFFFFF00, kInvalidValue},     /* UXTB */
+      {0xFFFFFFFFFFFF0000, kInvalidValue},     /* UXTH */
+      {kInvalidValue, kInvalidValue}           /* UXTW */
+  };
+  MOperator loadMappingTable[SETS][kPrevLoadPatternNum][kPrevLoadMappingNum] = {
+      /* {prevOrigMop, prevNewMop} */
+      {{MOP_undef, MOP_undef},   {MOP_undef, MOP_undef},      {MOP_undef, MOP_undef},     {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef},   {MOP_undef, MOP_undef}},   /* UNDEF */
+      {{MOP_wldrb, MOP_wldrsb},  {MOP_wldrsb, MOP_wldrsb},    {MOP_wldr, MOP_wldrsb},     {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef},   {MOP_undef, MOP_undef}},   /* SXTB */
+      {{MOP_wldrh, MOP_wldrsh},  {MOP_wldrb, MOP_wldrb},      {MOP_wldrsb, MOP_wldrsb},   {MOP_wldrsh, MOP_wldrsh},
+       {MOP_undef, MOP_undef},   {MOP_undef, MOP_undef}},   /* SXTH */
+      {{MOP_wldrh, MOP_wldrh},   {MOP_wldrsh, MOP_wldrsh},    {MOP_wldrb, MOP_wldrb},     {MOP_wldrsb, MOP_wldrsb},
+       {MOP_wldr,  MOP_xldrsw},  {MOP_xldrsw, MOP_xldrsw}}, /* SXTW */
+      {{MOP_wldrb, MOP_wldrb},   {MOP_wldrsb, MOP_wldrb},     {MOP_undef, MOP_undef},     {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef},   {MOP_undef, MOP_undef}},   /* UXTB */
+      {{MOP_wldrh, MOP_wldrh},   {MOP_wldrb, MOP_wldrb},      {MOP_wldr, MOP_wldrh},      {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef},   {MOP_undef, MOP_undef}},   /* UXTH */
+      {{MOP_wldr,  MOP_wldr},    {MOP_wldrh, MOP_wldrh},      {MOP_wldrb, MOP_wldrb},     {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef},   {MOP_undef, MOP_undef}}    /* UXTW */
+  };
+  MOperator sameExtMappingTable[SETS][kSameExtPatternNum][kSameExtMappingNum] = {
+      /* {prevMop, currMop} */
+      {{MOP_undef, MOP_undef},     {MOP_undef, MOP_undef},     {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef}},       /* UNDEF */
+      {{MOP_xsxtb32, MOP_xsxtb32}, {MOP_xsxtb64, MOP_xsxtb64}, {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef}},       /* SXTB */
+      {{MOP_xsxtb32, MOP_xsxth32}, {MOP_xsxtb64, MOP_xsxth64}, {MOP_xsxth32, MOP_xsxth32},
+       {MOP_xsxth64, MOP_xsxth64}},   /* SXTH */
+      {{MOP_xsxtb64, MOP_xsxtw64}, {MOP_xsxth64, MOP_xsxtw64}, {MOP_xsxtw64, MOP_xsxtw64},
+       {MOP_undef, MOP_undef}},       /* SXTW */
+      {{MOP_xuxtb32, MOP_xuxtb32}, {MOP_undef, MOP_undef},     {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef}},       /* UXTB */
+      {{MOP_xuxtb32, MOP_xuxth32}, {MOP_xuxth32, MOP_xuxth32}, {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef}},       /* UXTH */
+      {{MOP_xuxtw64, MOP_xuxtw64}, {MOP_undef, MOP_undef},     {MOP_undef, MOP_undef},
+       {MOP_undef, MOP_undef}}        /* UXTW */
+  };
+
+ private:
+  void SetSpecificExtType(const Insn &currInsn);
+  void SetOptSceneType();
+  bool IsValidLoadExtPattern(MOperator oldMop, MOperator newMop) const;
+  MOperator SelectNewLoadMopByBitSize(MOperator lowBitMop) const;
+  void ElimExtensionAfterLoad(Insn &insn);
+  void ElimExtensionAfterMov(Insn &insn);
+  void ElimExtensionAfterSameExt(Insn &insn);
+  void ReplaceExtWithMov(Insn &currInsn);
+  Insn *prevInsn = nullptr;
+  SpecificExtType extTypeIdx = EXTUNDEF;
+  OptSceneType sceneType = kSceneUndef;
+  bool is64Bits = false;
+};
+
+/*
+ * We optimize the following pattern in this function:
+ * if w0's valid bits is one
+ * uxtb w0, w0
+ * eor w0, w0, #1
+ * cbz w0, .label
+ * =>
+ * tbnz w0, .label
+ * if there exists uxtb w0, w0 and w0's valid bits is
+ * less than 8, eliminate it.
+ */
+class OneHoleBranchPattern : public CGPeepPattern {
+ public:
+  explicit OneHoleBranchPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~OneHoleBranchPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "OneHoleBranchPattern";
+  }
+
+ private:
+  void FindNewMop(const BB &bb, const Insn &insn);
+  bool CheckPrePrevInsn();
+  Insn *prevInsn = nullptr;
+  Insn *prePrevInsn = nullptr;
+  MOperator newOp = MOP_undef;
+};
+
+/*
+ * Combine logical shift and orr to [extr wd, wn, wm, #lsb  /  extr xd, xn, xm, #lsb]
+ * Example 1)
+ *  lsr w5, w6, #16
+ *  lsl w4, w7, #16
+ *  orr w5, w5, w4                  --->        (currInsn)
+ *  ===> extr w5, w6, w7, #16
+ *
+ * Example 2)
+ *  lsr w5, w6, #16
+ *  orr w5, w5, w4, LSL #16         --->        (currInsn)
+ *  ===> extr w5, w6, w4, #16
+ *
+ * Example 3)
+ *  lsl w4, w7, #16
+ *  orr w5, w4, w5, LSR #16         --->        (currInsn)
+ *  ===> extr w5, w5, w7, #16
+ *
+ * Conditions:
+ *  1. (def[wn] is lsl) & (def[wm] is lsr)
+ *  2. lsl_imm + lsr_imm == curr type size (32 or 64)
+ *  3. is64bits ? (extr_imm in range [0, 63]) : (extr_imm in range [0, 31])
+ *  4. extr_imm = lsr_imm
+ */
+class LogicShiftAndOrrToExtrPattern : public CGPeepPattern {
+ public:
+  LogicShiftAndOrrToExtrPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~LogicShiftAndOrrToExtrPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "LogicShiftAndOrrToExtrPattern";
+  }
+
+ private:
+  Insn *prevLsrInsn = nullptr;
+  Insn *prevLslInsn = nullptr;
+  int64 shiftValue = 0;
+  bool is64Bits = false;
+};
+
+/*
+ * Simplify Mul and Basic Arithmetic. There are three scenes:
+ * 1. currInsn is add:
+ * Example 1)
+ *  mul   x1, x1, x2           or     mul   x0, x1, x2
+ *  add   x0, x0, x1                  add   x0, x0, x1
+ *  ===> madd x0, x1, x2, x0          ===> madd x0, x1, x2, x1
+ *
+ * Example 2)
+ *  fmul  d1, d1, d2           or     fmul  d0, d1, d2
+ *  fadd  d0, d0, d1                  fadd  d0, d0, d1
+ *  ===> fmadd d0, d1, d2, d0         ===> fmadd d0, d1, d2, d1
+ *
+ * cases: addInsn second opnd || addInsn third opnd
+ *
+ *
+ * 2. currInsn is sub:
+ * Example 1)                         Example 2)
+ *  mul   x1, x1, x2                   fmul  d1, d1, d2
+ *  sub   x0, x0, x1                   fsub  d0, d0, d1
+ *  ===> msub x0, x1, x2, x0           ===> fmsub d0, d1, d2, d0
+ *
+ * cases: subInsn third opnd
+ *
+ * 3. currInsn is neg:
+ * Example 1)                         Example 2)
+ *  mul   x1, x1, x2                   fmul     d1, d1, d2
+ *  neg   x0, x1                       fneg     d0, d1
+ *  ===> mneg x0, x1, x2               ===> fnmul d0, d1, d2
+ *
+ * cases: negInsn second opnd
+ */
+class SimplifyMulArithmeticPattern : public CGPeepPattern {
+ public:
+  SimplifyMulArithmeticPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~SimplifyMulArithmeticPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "SimplifyMulArithmeticPattern";
+  }
+
+ protected:
+  enum ArithmeticType : uint8 {
+    kUndef = 0,
+    kAdd,
+    kFAdd,
+    kSub,
+    kFSub,
+    kNeg,
+    kFNeg,
+    kArithmeticTypeSize
+  };
+  static constexpr uint8 newMopNum = 2;
+  MOperator curMop2NewMopTable[kArithmeticTypeSize][newMopNum] = {
+      /* {32bit_mop, 64bit_mop} */
+      {MOP_undef,     MOP_undef},        /* kUndef  */
+      {MOP_wmaddrrrr, MOP_xmaddrrrr},    /* kAdd    */
+      {MOP_smadd,     MOP_dmadd},        /* kFAdd   */
+      {MOP_wmsubrrrr, MOP_xmsubrrrr},    /* kSub    */
+      {MOP_smsub,     MOP_dmsub},        /* kFSub   */
+      {MOP_wmnegrrr,  MOP_xmnegrrr},     /* kNeg    */
+      {MOP_snmul,     MOP_dnmul}         /* kFNeg   */
+  };
+
+ private:
+  void SetArithType(const Insn &currInsn);
+  void DoOptimize(BB &currBB, Insn &currInsn);
+  ArithmeticType arithType = kUndef;
+  int32 validOpndIdx = -1;
+  Insn *prevInsn = nullptr;
+  bool isFloat = false;
+};
+
+/*
+ * Example 1)
+ *  lsr w0, w1, #6
+ *  and w0, w0, #1                 --->        (currInsn)
+ *  ===> ubfx w0, w1, #6, #1
+ *
+ * Conditions:
+ * 1. and_imm value is (1 << n -1)
+ * 2. is64bits ? (ubfx_imm_lsb in range [0, 63]) : (ubfx_imm_lsb in range [0, 31])
+ * 3. is64bits ? ((ubfx_imm_lsb + ubfx_imm_width) in range [1, 32]) : ((ubfx_imm_lsb + ubfx_imm_width) in range [1, 64])
+ */
+class LsrAndToUbfxPattern : public CGPeepPattern {
+ public:
+  LsrAndToUbfxPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~LsrAndToUbfxPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "LsrAndToUbfxPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+};
+
+/*
+ * lsl w1, w2, #m
+ * and w3, w1, #2^n-1    --->    if n > m : ubfiz w3, w2, #m, #n-m
+ *
+ * and w1, w2, #2^n-1    --->    ubfiz w3, w2, #m, #n
+ * lsl w3, w1, #m
+ * Exclude the scenarios that can be optimized by prop.
+ */
+class LslAndToUbfizPattern : public CGPeepPattern {
+ public:
+  LslAndToUbfizPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~LslAndToUbfizPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  Insn *BuildNewInsn(const Insn &andInsn, const Insn &lslInsn, const Insn &useInsn);
+  bool CheckUseInsnMop(const Insn &useInsn);
+  std::string GetPatternName() override {
+    return "LslAndToUbfizPattern";
+  }
+
+ private:
+  Insn *defInsn = nullptr;
+};
+
+/*
+ * Optimize the following patterns:
+ *  orr  w21, w0, #0  ====> mov  w21, w0
+ *  orr  w21, #0, w0  ====> mov  w21, w0
+ */
+class OrrToMovPattern : public CGPeepPattern {
+ public:
+  explicit OrrToMovPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~OrrToMovPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "OrrToMovPattern";
+  }
+
+ private:
+  MOperator newMop = MOP_undef;
+  RegOperand *reg2 = nullptr;
+};
+
+/*
+ * Optimize the following patterns:
+ * ubfx  x201, x202, #0, #32
+ * ====>
+ * uxtw x201, w202
+ */
+class UbfxToUxtwPattern : public CGPeepPattern {
+ public:
+  UbfxToUxtwPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn) : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~UbfxToUxtwPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "UbfxToUxtwPattern";
+  }
+};
+
+/*
+ * Optimize the following patterns:
+ * ubfx  w0, w0, #2, #1
+ * cbz   w0, .L.3434__292    ====>    tbz w0, #2, .L.3434__292
+ * -------------------------------
+ * ubfx  w0, w0, #2, #1
+ * cnbz   w0, .L.3434__292    ====>    tbnz w0, #2, .L.3434__292
+ * -------------------------------
+ * ubfx  x0, x0, #2, #1
+ * cbz   x0, .L.3434__292    ====>    tbz x0, #2, .L.3434__292
+ * -------------------------------
+ * ubfx  x0, x0, #2, #1
+ * cnbz  x0, .L.3434__292    ====>    tbnz x0, #2, .L.3434__292
+ */
+class UbfxAndCbzToTbzPattern : public CGPeepPattern {
+ public:
+  UbfxAndCbzToTbzPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn, CGSSAInfo &info)
+      : CGPeepPattern(cgFunc, currBB, currInsn, info) {}
+  ~UbfxAndCbzToTbzPattern() override {
+    useInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "UbfxAndCbzToTbzPattern";
+  }
+ private:
+  Insn *useInsn = nullptr;
+  MOperator newMop = MOP_undef;
+};
+
+/*
+ * Looking for identical mem insn to eliminate.
+ * If two back-to-back is:
+ * 1. str + str
+ * 2. str + ldr
+ * And the [MEM] is pattern of [base + offset]
+ * 1. The [MEM] operand is exactly same then first
+ *    str can be eliminate.
+ * 2. The [MEM] operand is exactly same and src opnd
+ *    of str is same as the dest opnd of ldr then
+ *    ldr can be eliminate
+ */
+class RemoveIdenticalLoadAndStorePattern : public CGPeepPattern {
+ public:
+  RemoveIdenticalLoadAndStorePattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~RemoveIdenticalLoadAndStorePattern() override {
+    nextInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "RemoveIdenticalLoadAndStorePattern";
+  }
+
+ private:
+  bool IsMemOperandsIdentical(const Insn &insn1, const Insn &insn2) const;
+  Insn *nextInsn = nullptr;
+};
+
+/* Remove redundant mov which src and dest opnd is exactly same */
+class RemoveMovingtoSameRegPattern : public CGPeepPattern {
+ public:
+  RemoveMovingtoSameRegPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~RemoveMovingtoSameRegPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "RemoveMovingtoSameRegPattern";
+  }
+};
+
+/* Remove redundant mov which src and dest opnd is exactly same */
+class RemoveMovingtoSameRegAArch64 : public PeepPattern {
+ public:
+  explicit RemoveMovingtoSameRegAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {}
+  ~RemoveMovingtoSameRegAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+};
+
+/*
+ * Combining 2 STRs into 1 stp or 2 LDRs into 1 ldp, when they are
+ * back to back and the [MEM] they access is conjointed.
+ */
+class CombineContiLoadAndStorePattern : public CGPeepPattern {
+ public:
+  CombineContiLoadAndStorePattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {
+    doAggressiveCombine = cgFunc.GetMirModule().IsCModule();
+  }
+  ~CombineContiLoadAndStorePattern() override {
+    memOpnd = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "CombineContiLoadAndStorePattern";
+  }
+
+ private:
+  std::vector<Insn*> FindPrevStrLdr(Insn &insn, regno_t destRegNO, regno_t memBaseRegNO, int64 baseOfst) const;
+  /*
+   * avoid the following situation:
+   * str x2, [x19, #8]
+   * mov x0, x19
+   * bl foo (change memory)
+   * str x21, [x19, #16]
+   */
+  bool IsRegNotSameMemUseInInsn(const Insn &insn, regno_t regNO, bool isStore, int64 baseOfst) const;
+  void RemoveInsnAndKeepComment(BB &bb, Insn &insn, Insn &prevInsn) const;
+  MOperator GetMopHigherByte(MOperator mop) const;
+  bool SplitOfstWithAddToCombine(const Insn &curInsn, Insn &combineInsn, const MemOperand &memOperand) const;
+  Insn *FindValidSplitAddInsn(Insn &combineInsn, const RegOperand &baseOpnd) const;
+  bool FindTmpRegOnlyUseAfterCombineInsn(const Insn &curInsn) const;
+  bool PlaceSplitAddInsn(const Insn &curInsn, Insn &combineInsn, const MemOperand &memOperand,
+                         RegOperand &baseOpnd, uint32 bitLen) const;
+  bool doAggressiveCombine = false;
+  MemOperand *memOpnd = nullptr;
+};
+
+/*
+ * add xt, xn, #imm               add  xt, xn, xm
+ * ldr xd, [xt]                   ldr xd, [xt]
+ * =====================>
+ * ldr xd, [xn, #imm]             ldr xd, [xn, xm]
+ *
+ * load/store can do extend shift as well
+ */
+class EnhanceStrLdrAArch64 : public PeepPattern {
+ public:
+  explicit EnhanceStrLdrAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {}
+  ~EnhanceStrLdrAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  bool IsEnhanceAddImm(MOperator prevMop) const;
+};
+
+/* Eliminate the sxt[b|h|w] w0, w0;, when w0 is satisify following:
+ * i)  mov w0, #imm (#imm is not out of range)
+ * ii) ldrs[b|h] w0, [MEM]
+ */
+class EliminateSpecifcSXTPattern : public CGPeepPattern {
+ public:
+  EliminateSpecifcSXTPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~EliminateSpecifcSXTPattern() override {
+    prevInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "EliminateSpecifcSXTPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+};
+
+/* Eliminate the uxt[b|h|w] w0, w0;when w0 is satisify following:
+ * i)  mov w0, #imm (#imm is not out of range)
+ * ii) mov w0, R0(Is return value of call and return size is not of range)
+ * iii)w0 is defined and used by special load insn and uxt[] pattern
+ */
+class EliminateSpecifcUXTAArch64 : public PeepPattern {
+ public:
+  explicit EliminateSpecifcUXTAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {}
+  ~EliminateSpecifcUXTAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+};
+
+/* fmov ireg1 <- freg1   previous insn
+ * fmov ireg2 <- freg1   current insn
+ * use  ireg2            may or may not be present
+ * =>
+ * fmov ireg1 <- freg1   previous insn
+ * mov  ireg2 <- ireg1   current insn
+ * use  ireg1            may or may not be present
+ */
+class FmovRegPattern : public CGPeepPattern {
+ public:
+  FmovRegPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn) : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~FmovRegPattern() override {
+    prevInsn = nullptr;
+    nextInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "FmovRegPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+  Insn *nextInsn = nullptr;
+};
+
+/* sbfx ireg1, ireg2, 0, 32
+ * use  ireg1.32
+ * =>
+ * sbfx ireg1, ireg2, 0, 32
+ * use  ireg2.32
+ */
+class SbfxOptPattern : public CGPeepPattern {
+ public:
+  SbfxOptPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn) : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~SbfxOptPattern() override {
+    nextInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "SbfxOptPattern";
+  }
+
+ private:
+  Insn *nextInsn = nullptr;
+  bool toRemove = false;
+  std::vector<uint32> cands;
+};
+
+/* cbnz x0, labelA
+ * mov x0, 0
+ * b  return-bb
+ * labelA:
+ * =>
+ * cbz x0, return-bb
+ * labelA:
+ */
+class CbnzToCbzPattern : public CGPeepPattern {
+ public:
+  CbnzToCbzPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn) : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~CbnzToCbzPattern() override {
+    nextBB = nullptr;
+    movInsn = nullptr;
+    brInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "CbnzToCbzPattern";
+  }
+
+ private:
+  BB *nextBB = nullptr;
+  Insn *movInsn = nullptr;
+  Insn *brInsn = nullptr;
+};
+
+/* When exist load after load or load after store, and [MEM] is
+ * totally same. Then optimize them.
+ */
+class ContiLDRorSTRToSameMEMPattern : public CGPeepPattern {
+ public:
+  ContiLDRorSTRToSameMEMPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~ContiLDRorSTRToSameMEMPattern() override {
+    prevInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "ContiLDRorSTRToSameMEMPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+  bool loadAfterStore = false;
+  bool loadAfterLoad = false;
+};
+
+/*
+ *  Remove following patterns:
+ *  mov     x1, x0
+ *  bl      MCC_IncDecRef_NaiveRCFast
+ */
+class RemoveIncDecRefPattern : public CGPeepPattern {
+ public:
+  RemoveIncDecRefPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~RemoveIncDecRefPattern() override {
+    prevInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "RemoveIncDecRefPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+};
+
+/*
+ * When GCONLY is enabled, the read barriers can be inlined.
+ * we optimize it with the following pattern:
+ * #if USE_32BIT_REF
+ *   bl MCC_LoadRefField             ->  ldr  w0, [x1]
+ *   bl MCC_LoadVolatileField        ->  ldar w0, [x1]
+ *   bl MCC_LoadRefStatic            ->  ldr  w0, [x0]
+ *   bl MCC_LoadVolatileStaticField  ->  ldar w0, [x0]
+ *   bl MCC_Dummy                    ->  omitted
+ * #else
+ *   bl MCC_LoadRefField             ->  ldr  x0, [x1]
+ *   bl MCC_LoadVolatileField        ->  ldar x0, [x1]
+ *   bl MCC_LoadRefStatic            ->  ldr  x0, [x0]
+ *   bl MCC_LoadVolatileStaticField  ->  ldar x0, [x0]
+ *   bl MCC_Dummy                    ->  omitted
+ * #endif
+ *
+ * if we encounter a tail call optimized read barrier call,
+ * such as:
+ *   b MCC_LoadRefField
+ * a return instruction will be added just after the load:
+ *   ldr w0, [x1]
+ *   ret
+ */
+class InlineReadBarriersPattern : public CGPeepPattern {
+ public:
+  InlineReadBarriersPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~InlineReadBarriersPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "InlineReadBarriersPattern";
+  }
+};
+
+/*
+ *    mov     w1, #34464
+ *    movk    w1, #1,  LSL #16
+ *    sdiv    w2, w0, w1
+ *  ========>
+ *    mov     w1, #34464         // may deleted if w1 not live anymore.
+ *    movk    w1, #1,  LSL #16   // may deleted if w1 not live anymore.
+ *    mov     w16, #0x588f
+ *    movk    w16, #0x4f8b, LSL #16
+ *    smull   x16, w0, w16
+ *    asr     x16, x16, #32
+ *    add     x16, x16, w0, SXTW
+ *    asr     x16, x16, #17
+ *    add     x2, x16, x0, LSR #31
+ */
+class ReplaceDivToMultiPattern : public CGPeepPattern {
+ public:
+  ReplaceDivToMultiPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn) : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~ReplaceDivToMultiPattern() override {
+    prevInsn = nullptr;
+    prePrevInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "ReplaceDivToMultiPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+  Insn *prePrevInsn = nullptr;
+};
+
+/*
+ * Optimize the following patterns:
+ *  and  w0, w0, #imm  ====> tst  w0, #imm
+ *  cbz/cbnz  .label         beq/bne  .label
+ */
+class AndCbzBranchesToTstAArch64 : public PeepPattern {
+ public:
+  explicit AndCbzBranchesToTstAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {}
+  ~AndCbzBranchesToTstAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+};
+
+/*
+ * Optimize the following patterns:
+ *  and  w0, w0, #1  ====> and  w0, w0, #1
+ *  cmp  w0, #1
+ *  cset w0, EQ
+ *
+ *  and  w0, w0, #1  ====> and  w0, w0, #1
+ *  cmp  w0, #0
+ *  cset w0, NE
+ *  ---------------------------------------------------
+ *  and  w0, w0, #imm  ====> ubfx  w0, w0, pos, size
+ *  cmp  w0, #imm
+ *  cset w0, EQ
+ *
+ *  and  w0, w0, #imm  ====> ubfx  w0, w0, pos, size
+ *  cmp  w0, #0
+ *  cset w0, NE
+ *  conditions:
+ *  imm is pos power of 2
+ *
+ *  ---------------------------------------------------
+ *  and  w0, w0, #1  ====> and  wn, w0, #1
+ *  cmp  w0, #1
+ *  cset wn, EQ        # wn != w0 && w0 is not live after cset
+ *
+ *  and  w0, w0, #1  ====> and  wn, w0, #1
+ *  cmp  w0, #0
+ *  cset wn, NE        # wn != w0 && w0 is not live after cset
+ *  ---------------------------------------------------
+ *  and  w0, w0, #imm  ====> ubfx  wn, w0, pos, size
+ *  cmp  w0, #imm
+ *  cset wn, EQ        # wn != w0 && w0 is not live after cset
+ *
+ *  and  w0, w0, #imm  ====> ubfx  wn, w0, pos, size
+ *  cmp  w0, #0
+ *  cset wn, NE        # wn != w0 && w0 is not live after cset
+ *  conditions:
+ *  imm is pos power of 2 and w0 is not live after cset
+ */
+class AndCmpBranchesToCsetAArch64 : public PeepPattern {
+ public:
+  explicit AndCmpBranchesToCsetAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {}
+  ~AndCmpBranchesToCsetAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  Insn *FindPreviousCmp(Insn &insn) const;
+};
+
+/*
+ * cbnz w0, @label
+ * ....
+ * mov  w0, #0 (elseBB)        -->this instruction can be deleted
+ *
+ * cbz  w0, @label
+ * ....
+ * mov  w0, #0 (ifBB)          -->this instruction can be deleted
+ *
+ * condition:
+ *  1.there is not predefine points of w0 in elseBB(ifBB)
+ *  2.the first opearnd of cbnz insn is same as the first Operand of mov insn
+ *  3.w0 is defined by move 0
+ *  4.all preds of elseBB(ifBB) end with cbnz or cbz
+ *
+ *  NOTE: if there are multiple preds and there is not define point of w0 in one pred,
+ *        (mov w0, 0) can't be deleted, avoiding use before def.
+ */
+class DeleteMovAfterCbzOrCbnzAArch64 : public PeepPattern {
+ public:
+  explicit DeleteMovAfterCbzOrCbnzAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {
+    cgcfg = cgFunc.GetTheCFG();
+    cgcfg->InitInsnVisitor(cgFunc);
+  }
+  ~DeleteMovAfterCbzOrCbnzAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  bool PredBBCheck(BB &bb, bool checkCbz, const Operand &opnd) const;
+  bool OpndDefByMovZero(const Insn &insn) const;
+  bool NoPreDefine(Insn &testInsn) const;
+  void ProcessBBHandle(BB *processBB, const BB &bb, const Insn &insn) const;
+  CGCFG *cgcfg = nullptr;
+};
+
+/*
+ * We optimize the following pattern in this function:
+ * movz x0, #11544, LSL #0
+ * movk x0, #21572, LSL #16
+ * movk x0, #8699, LSL #32
+ * movk x0, #16393, LSL #48
+ * =>
+ * ldr x0, label_of_constant_1
+ */
+class LoadFloatPointPattern : public CGPeepPattern {
+ public:
+  LoadFloatPointPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn) : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~LoadFloatPointPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "LoadFloatPointPattern";
+  }
+ private:
+  bool FindLoadFloatPoint(Insn &insn);
+  bool IsPatternMatch();
+  std::vector<Insn*> optInsn;
+};
+
+/*
+ * Optimize the following patterns:
+ *  ldr  w0, [x21,#68]        ldr  w0, [x21,#68]
+ *  mov  w1, #-1              mov  w1, #-1
+ *  cmp  w0, w1     ====>     cmn  w0, #-1
+ */
+class ReplaceCmpToCmnAArch64 : public PeepPattern {
+ public:
+  explicit ReplaceCmpToCmnAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {}
+  ~ReplaceCmpToCmnAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+};
+
+/*
+ * Remove following patterns:
+ *   mov x0, XX
+ *   mov x1, XX
+ *    bl  MCC_IncDecRef_NaiveRCFast
+ */
+class RemoveIncRefPattern : public CGPeepPattern {
+ public:
+  RemoveIncRefPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~RemoveIncRefPattern() override {
+    insnMov2 = nullptr;
+    insnMov1 = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "RemoveIncRefPattern";
+  }
+
+ private:
+  Insn *insnMov2 = nullptr;
+  Insn *insnMov1 = nullptr;
+};
+
+/*
+ * opt long int compare with 0
+ *  *cmp x0, #0
+ *  csinv w0, wzr, wzr, GE
+ *  csinc w0, w0, wzr, LE
+ *  cmp w0, #0
+ *  =>
+ *  cmp x0, #0
+ */
+class LongIntCompareWithZPattern : public CGPeepPattern {
+ public:
+  LongIntCompareWithZPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~LongIntCompareWithZPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "LongIntCompareWithZPattern";
+  }
+
+ private:
+  bool FindLondIntCmpWithZ(Insn &insn);
+  bool IsPatternMatch();
+  std::vector<Insn*> optInsn;
+};
+
+/*
+ *  add     x0, x1, #:lo12:Ljava_2Futil_2FLocale_241_3B_7C_24SwitchMap_24java_24util_24Locale_24Category
+ *  ldr     x2, [x0]
+ *  ==>
+ *  ldr     x2, [x1, #:lo12:Ljava_2Futil_2FLocale_241_3B_7C_24SwitchMap_24java_24util_24Locale_24Category]
+ */
+class ComplexMemOperandAArch64 : public PeepPattern {
+ public:
+  explicit ComplexMemOperandAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {}
+  ~ComplexMemOperandAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+};
+
+/*
+ *  add     x0, x1, x0
+ *  ldr     x2, [x0]
+ *  ==>
+ *  ldr     x2, [x1, x0]
+ */
+class ComplexMemOperandPreAddAArch64 : public PeepPattern {
+ public:
+  explicit ComplexMemOperandPreAddAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {}
+  ~ComplexMemOperandPreAddAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+};
+
+/*
+ * mov R0, vreg1 / R0         mov R0, vreg1
+ * add vreg2, vreg1, #imm1    add vreg2, vreg1, #imm1
+ * mov R1, vreg2              mov R1, vreg2
+ * mov R2, vreg3              mov R2, vreg3
+ * ...                        ...
+ * mov R0, vreg1
+ * add vreg4, vreg1, #imm2 -> str vreg5, [vreg1, #imm2]
+ * mov R1, vreg4
+ * mov R2, vreg5
+ */
+class WriteFieldCallPattern : public CGPeepPattern {
+ public:
+  struct WriteRefFieldParam {
+    Operand *objOpnd = nullptr;
+    RegOperand *fieldBaseOpnd = nullptr;
+    int64 fieldOffset = 0;
+    Operand *fieldValue = nullptr;
+  };
+  WriteFieldCallPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~WriteFieldCallPattern() override {
+    prevCallInsn = nullptr;
+    nextInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "WriteFieldCallPattern";
+  }
+
+ private:
+  bool hasWriteFieldCall = false;
+  Insn *prevCallInsn = nullptr;
+  Insn *nextInsn = nullptr;
+  WriteRefFieldParam firstCallParam;
+  WriteRefFieldParam currentCallParam;
+  std::vector<Insn*> paramDefInsns;
+  bool WriteFieldCallOptPatternMatch(const Insn &writeFieldCallInsn, WriteRefFieldParam &param);
+  bool IsWriteRefFieldCallInsn(const Insn &insn) const;
+};
+
+/*
+ * Remove following patterns:
+ *     mov     x0, xzr/#0
+ *     bl      MCC_DecRef_NaiveRCFast
+ */
+class RemoveDecRefPattern : public CGPeepPattern {
+ public:
+  RemoveDecRefPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~RemoveDecRefPattern() override {
+    prevInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "RemoveDecRefPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+};
+
+/*
+ * Replace following pattern:
+ * mov x1, xzr
+ * bl MCC_IncDecRef_NaiveRCFast
+ * =>
+ * bl MCC_IncRef_NaiveRCFast
+ */
+class ReplaceIncDecWithIncPattern : public CGPeepPattern {
+ public:
+  ReplaceIncDecWithIncPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~ReplaceIncDecWithIncPattern() override {
+    prevInsn = nullptr;
+    target = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "ReplaceIncDecWithIncPattern";
+  }
+
+ private:
+  Insn *prevInsn = nullptr;
+  FuncNameOperand *target = nullptr;
+};
+
+/*
+ * Replace following pattern:
+ * sxtw  x1, w0
+ * lsl   x2, x1, #3  ====>  sbfiz x2, x0, #3, #32
+ *
+ * uxtw  x1, w0
+ * lsl   x2, x1, #3  ====>  ubfiz x2, x0, #3, #32
+ */
+class ComplexExtendWordLslAArch64 : public PeepPattern {
+ public:
+  explicit ComplexExtendWordLslAArch64(CGFunc &cgFunc) : PeepPattern(cgFunc) {}
+  ~ComplexExtendWordLslAArch64() override = default;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  bool IsExtendWordLslPattern(const Insn &insn) const;
+};
+
+class AArch64PeepHole : public PeepPatternMatch {
+ public:
+  AArch64PeepHole(CGFunc &oneCGFunc, MemPool *memPool) : PeepPatternMatch(oneCGFunc, memPool) {}
+  ~AArch64PeepHole() override = default;
+  void InitOpts() override;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  enum PeepholeOpts : int32 {
+    kRemoveIdenticalLoadAndStoreOpt = 0,
+    kRemoveMovingtoSameRegOpt,
+    kCombineContiLoadAndStoreOpt,
+    kEliminateSpecifcSXTOpt,
+    kEliminateSpecifcUXTOpt,
+    kFmovRegOpt,
+    kCbnzToCbzOpt,
+    kCsetCbzToBeqOpt,
+    kContiLDRorSTRToSameMEMOpt,
+    kRemoveIncDecRefOpt,
+    kInlineReadBarriersOpt,
+    kReplaceDivToMultiOpt,
+    kAndCmpBranchesToCsetOpt,
+    kAndCmpBranchesToTstOpt,
+    kAndCbzBranchesToTstOpt,
+    kZeroCmpBranchesOpt,
+    kCselZeroOneToCsetOpt,
+    kPeepholeOptsNum
+  };
+};
+
+class AArch64PeepHole0 : public PeepPatternMatch {
+ public:
+  AArch64PeepHole0(CGFunc &oneCGFunc, MemPool *memPool) : PeepPatternMatch(oneCGFunc, memPool) {}
+  ~AArch64PeepHole0() override = default;
+  void InitOpts() override;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  enum PeepholeOpts : int32 {
+    kRemoveIdenticalLoadAndStoreOpt = 0,
+    kCmpCsetOpt,
+    kComplexMemOperandOptAdd,
+    kDeleteMovAfterCbzOrCbnzOpt,
+    kRemoveSxtBeforeStrOpt,
+    kRemoveMovingtoSameRegOpt,
+    kPeepholeOptsNum
+  };
+};
+
+class AArch64PrePeepHole : public PeepPatternMatch {
+ public:
+  AArch64PrePeepHole(CGFunc &oneCGFunc, MemPool *memPool) : PeepPatternMatch(oneCGFunc, memPool) {}
+  ~AArch64PrePeepHole() override = default;
+  void InitOpts() override;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  enum PeepholeOpts : int32 {
+    kOneHoleBranchesPreOpt = 0,
+    kLoadFloatPointOpt,
+    kReplaceOrrToMovOpt,
+    kReplaceCmpToCmnOpt,
+    kRemoveIncRefOpt,
+    kLongIntCompareWithZOpt,
+    kComplexMemOperandOpt,
+    kComplexMemOperandPreOptAdd,
+    kComplexMemOperandOptLSL,
+    kComplexMemOperandOptLabel,
+    kWriteFieldCallOpt,
+    kDuplicateExtensionOpt,
+    kEnhanceStrLdrAArch64Opt,
+    kUbfxToUxtw,
+    kPeepholeOptsNum
+  };
+};
+
+class AArch64PrePeepHole1 : public PeepPatternMatch {
+ public:
+  AArch64PrePeepHole1(CGFunc &oneCGFunc, MemPool *memPool) : PeepPatternMatch(oneCGFunc, memPool) {}
+  ~AArch64PrePeepHole1() override = default;
+  void InitOpts() override;
+  void Run(BB &bb, Insn &insn) override;
+
+ private:
+  enum PeepholeOpts : int32 {
+    kRemoveDecRefOpt = 0,
+    kComputationTreeOpt,
+    kOneHoleBranchesOpt,
+    kReplaceIncDecWithIncOpt,
+    kAndCmpBranchesToTbzOpt,
+    kComplexExtendWordLslOpt,
+    kPeepholeOptsNum
+  };
+};
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_PEEP_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_pgo_gen.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_pgo_gen.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f0d40722e4b9713258ca4f45f763306381c764e
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_pgo_gen.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_AARCH64_PGO_GEN_H
+#define MAPLEBE_CG_INCLUDE_AARCH64_PGO_GEN_H
+
+#include "cg_pgo_gen.h"
+namespace maplebe {
+class AArch64ProfGen : public CGProfGen {
+ public:
+  AArch64ProfGen(CGFunc &curF, MemPool &mp) : CGProfGen(curF, mp) {}
+
+  void CreateClearIcall(BB &bb, const std::string &symName) override;
+  void CreateIcallForWeakSymbol(BB &bb, const std::string &symName) override ;
+  void InstrumentBB(BB &bb, MIRSymbol &countTab, uint32 offset) override;
+};
+
+}
+#endif // MAPLEBE_CG_INCLUDE_AARCH64_PGO_GEN_H
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_phases.def b/src/mapleall/maple_be/include/cg/aarch64/aarch64_phases.def
new file mode 100644
index 0000000000000000000000000000000000000000..48e835dbb3777c4e84a5504bdf9a556bec44e49b
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_phases.def
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+ ADDTARGETPHASE("layoutstackframe", true);
+ ADDTARGETPHASE("createstartendlabel", true);
+ ADDTARGETPHASE("buildehfunc", !GetMIRModule()->IsCModule());
+ ADDTARGETPHASE("handlefunction", true);
+ ADDTARGETPHASE("moveargs", true);
+ /* SSA PHASES */
+ ADDTARGETPHASE("cgssaconstruct", CGOptions::DoCGSSA());
+ ADDTARGETPHASE("cgcopyprop", CGOptions::DoCGSSA());
+ ADDTARGETPHASE("cgpeephole", CGOptions::DoCGSSA());
+ ADDTARGETPHASE("cgvalidbitopt", CGOptions::DoCGSSA());
+ ADDTARGETPHASE("cgredundantcompelim", CGOptions::DoCGSSA());
+ ADDTARGETPHASE("cgtargetprop", CGOptions::DoCGSSA());
+ ADDTARGETPHASE("cgdeadcodeelimination", CGOptions::DoCGSSA());
+ ADDTARGETPHASE("cgsplitcriticaledge", CGOptions::DoCGSSA());
+ ADDTARGETPHASE("cgphielimination", CGOptions::DoCGSSA());
+ ADDTARGETPHASE("cgregcoalesce", CGOptions::DoCGSSA());
+ /* Normal OPT PHASES */
+ ADDTARGETPHASE("cgprepeephole", CGOptions::DoPrePeephole());
+ ADDTARGETPHASE("ebo", CGOptions::DoEBO());
+ ADDTARGETPHASE("prepeephole", CGOptions::DoPrePeephole())
+ ADDTARGETPHASE("ico", CGOptions::DoICO())
+ ADDTARGETPHASE("cfgo", !GetMIRModule()->IsCModule() && CGOptions::DoCFGO());
+
+ if (GetMIRModule()->GetFlavor() != MIRFlavor::kFlavorLmbc) {
+   ADDTARGETPHASE("storeloadopt", CGOptions::DoStoreLoadOpt() && !CGOptions::DoCGSSA());
+   ADDTARGETPHASE("globalopt", CGOptions::DoGlobalOpt());
+ }
+ ADDTARGETPHASE("clearrdinfo", (CGOptions::DoStoreLoadOpt()) || CGOptions::DoGlobalOpt());
+
+ ADDTARGETPHASE("prepeephole1", CGOptions::DoPrePeephole());
+ ADDTARGETPHASE("ebo1", CGOptions::DoEBO());
+ ADDTARGETPHASE("globalschedule", false);
+ ADDTARGETPHASE("prescheduling", !GetMIRModule()->IsJavaModule() && CGOptions::DoPreSchedule());
+ ADDTARGETPHASE("raopt", CGOptions::DoPreLSRAOpt());
+ ADDTARGETPHASE("cgsplitcriticaledge", GetMIRModule()->IsCModule());
+ ADDTARGETPHASE("regalloc", true);
+ ADDTARGETPHASE("tailcallopt", GetMIRModule()->IsCModule());
+ ADDTARGETPHASE("regsaves", GetMIRModule()->IsCModule() && CGOptions::DoRegSavesOpt());
+ if (GetMIRModule()->GetFlavor() != MIRFlavor::kFlavorLmbc) {
+   ADDTARGETPHASE("storeloadopt", GetMIRModule()->IsCModule() && CGOptions::DoStoreLoadOpt());
+   ADDTARGETPHASE("globalopt", CGOptions::DoCGSSA());
+ }
+ ADDTARGETPHASE("clearrdinfo", GetMIRModule()->IsCModule() && (CGOptions::DoStoreLoadOpt() || CGOptions::DoGlobalOpt()));
+ ADDTARGETPHASE("isolatefastpath", CGOptions::DoIsolateFastPath());
+ ADDTARGETPHASE("generateproepilog", true);
+ ADDTARGETPHASE("framefinalize", true);
+ ADDTARGETPHASE("cfgo", GetMIRModule()->IsCModule() && CGOptions::DoCFGO());
+ ADDTARGETPHASE("peephole0", CGOptions::DoPeephole())
+ ADDTARGETPHASE("postebo", CGOptions::DoEBO());
+ ADDTARGETPHASE("postcfgo", CGOptions::DoCFGO());
+ ADDTARGETPHASE("cgpostpeephole", CGOptions::DoPeephole())
+ ADDTARGETPHASE("peephole", CGOptions::DoPeephole())
+ ADDTARGETPHASE("gencfi", !GetMIRModule()->IsCModule() || CGOptions::GetInstance().IsUnwindTables() || GetMIRModule()->IsWithDbgInfo());
+ ADDTARGETPHASE("dbgfixcallframeoffsets", true);
+ ADDTARGETPHASE("yieldpoint", GetMIRModule()->IsJavaModule() && CGOptions::IsInsertYieldPoint());
+ ADDTARGETPHASE("scheduling", CGOptions::DoSchedule());
+ ADDTARGETPHASE("cgsplitcriticaledge", CGOptions::DoLiteProfGen());
+ ADDTARGETPHASE("cgpgogen", CGOptions::DoLiteProfGen());
+ ADDTARGETPHASE("cgpgouse", CGOptions::DoLiteProfUse());
+ ADDTARGETPHASE("alignanalysis", GetMIRModule()->IsCModule() && CGOptions::DoAlignAnalysis() && !CGOptions::DoLiteProfGen());
+ ADDTARGETPHASE("fixshortbranch", true);
+ ADDTARGETPHASE("cgemit", true);
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_phi_elimination.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_phi_elimination.h
new file mode 100644
index 0000000000000000000000000000000000000000..6276be4cd35272b9810b767c5168ac1cf7abdc78
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_phi_elimination.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_CG_INCLUDE_AARCH64_PHI_ELIMINATION_H
+#define MAPLEBE_CG_INCLUDE_AARCH64_PHI_ELIMINATION_H
+#include "cg_phi_elimination.h"
+namespace maplebe {
+class AArch64PhiEliminate : public PhiEliminate {
+ public:
+  AArch64PhiEliminate(CGFunc &f, CGSSAInfo &ssaAnalysisResult, MemPool &mp) : PhiEliminate(f, ssaAnalysisResult, mp) {}
+  ~AArch64PhiEliminate() override = default;
+  RegOperand &GetCGVirtualOpearnd(RegOperand &ssaOpnd, const Insn &curInsn /* for remat */);
+
+ private:
+  void ReCreateRegOperand(Insn &insn) override;
+  Insn &CreateMov(RegOperand &destOpnd, RegOperand &fromOpnd) override;
+  void MaintainRematInfo(RegOperand &destOpnd, RegOperand &fromOpnd, bool isCopy) override;
+  RegOperand &CreateTempRegForCSSA(RegOperand &oriOpnd) override;
+  void AppendMovAfterLastVregDef(BB &bb, Insn &movInsn) const override;
+};
+
+class A64OperandPhiElmVisitor : public OperandPhiElmVisitor {
+ public:
+  A64OperandPhiElmVisitor(AArch64PhiEliminate *a64PhiElm, Insn &cInsn, uint32 idx)
+      : a64PhiEliminator(a64PhiElm),
+        insn(&cInsn),
+        idx(idx) {};
+  ~A64OperandPhiElmVisitor() override = default;
+  void Visit(RegOperand *v) final;
+  void Visit(ListOperand *v) final;
+  void Visit(MemOperand *a64MemOpnd) final;
+
+ private:
+  AArch64PhiEliminate *a64PhiEliminator;
+  Insn *insn;
+  uint32 idx;
+};
+}
+#endif // MAPLEBE_CG_INCLUDE_AARCH64_PHI_ELIMINATION_H
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_proepilog.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_proepilog.h
new file mode 100644
index 0000000000000000000000000000000000000000..aef5b287716a2842c2ac5cf37e668fa01fbac347
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_proepilog.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_PROEPILOG_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_PROEPILOG_H
+
+#include "proepilog.h"
+#include "cg.h"
+#include "operand.h"
+#include "aarch64_cgfunc.h"
+#include "aarch64_operand.h"
+#include "aarch64_insn.h"
+
+namespace maplebe {
+using namespace maple;
+
+class AArch64GenProEpilog : public GenProEpilog {
+ public:
+  AArch64GenProEpilog(CGFunc &func, MemPool &memPool)
+      : GenProEpilog(func),
+        tmpAlloc(&memPool) {
+    useFP = func.UseFP();
+    if (func.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc) {
+      stackBaseReg = RFP;
+    } else {
+      stackBaseReg = useFP ? R29 : RSP;
+    }
+  }
+
+  ~AArch64GenProEpilog() override = default;
+
+  bool NeedProEpilog() override;
+  static MemOperand *SplitStpLdpOffsetForCalleeSavedWithAddInstruction(
+      CGFunc &cgFunc, const MemOperand &mo, uint32 bitLen, AArch64reg baseRegNum = AArch64reg::kRinvalid);
+  static void AppendInstructionPushPair(CGFunc &cgFunc, AArch64reg reg0, AArch64reg reg1, RegType rty, int32 offset);
+  static void AppendInstructionPushSingle(CGFunc &cgFunc, AArch64reg reg, RegType rty, int32 offset);
+  static void AppendInstructionPopSingle(CGFunc &cgFunc, AArch64reg reg, RegType rty, int32 offset);
+  static void AppendInstructionPopPair(CGFunc &cgFunc, AArch64reg reg0, AArch64reg reg1, RegType rty, int32 offset);
+  void Run() override;
+ private:
+  MemOperand *GetDownStack();
+  void GenStackGuard();
+  void AddStackGuard(BB &bb);
+  BB &GenStackGuardCheckInsn(BB &bb);
+  void AppendInstructionAllocateCallFrame(AArch64reg reg0, AArch64reg reg1, RegType rty);
+  void AppendInstructionAllocateCallFrameDebug(AArch64reg reg0, AArch64reg reg1, RegType rty);
+  void GeneratePushRegs();
+  void GeneratePushUnnamedVarargRegs();
+  void AppendInstructionStackCheck(AArch64reg reg, RegType rty, int32 offset);
+  void GenerateProlog(BB &bb);
+
+  void GenerateRet(BB &bb);
+  bool TestPredsOfRetBB(const BB &exitBB);
+  void AppendInstructionDeallocateCallFrame(AArch64reg reg0, AArch64reg reg1, RegType rty);
+  void AppendInstructionDeallocateCallFrameDebug(AArch64reg reg0, AArch64reg reg1, RegType rty);
+  void GeneratePopRegs();
+  void AppendJump(const MIRSymbol &funcSymbol);
+  void GenerateEpilog(BB &bb);
+  void GenerateEpilogForCleanup(BB &bb);
+  void AppendBBtoEpilog(BB &epilogBB, BB &newBB);
+
+  Insn &CreateAndAppendInstructionForAllocateCallFrame(int64 argsToStkPassSize, AArch64reg reg0, AArch64reg reg1,
+                                                       RegType rty);
+  Insn &AppendInstructionForAllocateOrDeallocateCallFrame(int64 argsToStkPassSize, AArch64reg reg0, AArch64reg reg1,
+                                                          RegType rty, bool isAllocate);
+  void SetFastPathReturnBB(BB *bb) {
+    bb->SetFastPathReturn(true);
+    fastPathReturnBB = bb;
+  }
+  BB *GetFastPathReturnBB() {
+    return fastPathReturnBB;
+  }
+  MapleAllocator tmpAlloc;
+  static constexpr const int32 kOffset8MemPos = 8;
+  static constexpr const int32 kOffset16MemPos = 16;
+
+  BB *fastPathReturnBB = nullptr;
+  bool useFP = true;
+  /* frame pointer(x29) is available as a general-purpose register if useFP is set as false */
+  AArch64reg stackBaseReg = RFP;
+};
+}  /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_PROEPILOG_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_prop.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_prop.h
new file mode 100644
index 0000000000000000000000000000000000000000..721a2260d59768825972a28d21d1490421efa7ad
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_prop.h
@@ -0,0 +1,495 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_AARCH64_PROP_H
+#define MAPLEBE_INCLUDE_AARCH64_PROP_H
+
+#include "aarch64_opt_utiles.h"
+#include "cg_prop.h"
+#include "aarch64_cgfunc.h"
+#include "aarch64_strldr.h"
+namespace maplebe {
+class AArch64Prop : public CGProp {
+ public:
+  AArch64Prop(MemPool &mp, CGFunc &f, CGSSAInfo &sInfo, LiveIntervalAnalysis &ll)
+      : CGProp(mp, f, sInfo, ll) {}
+  ~AArch64Prop() override = default;
+
+  /* do not extend life range */
+  static bool IsInLimitCopyRange(VRegVersion *toBeReplaced);
+ private:
+  void CopyProp() override;
+  /*
+   * for aarch64
+   * 1. extended register prop
+   * 2. shift register prop
+   * 3. add/ext/shf prop -> str/ldr
+   * 4. const prop
+   */
+  void TargetProp(Insn &insn) override;
+  void PropPatternOpt() override;
+};
+
+class A64StrLdrProp {
+ public:
+  A64StrLdrProp(MemPool &mp, CGFunc &f, CGSSAInfo &sInfo, Insn &insn, CGDce &dce)
+      : cgFunc(&f),
+        ssaInfo(&sInfo),
+        curInsn(&insn),
+        a64StrLdrAlloc(&mp),
+        replaceVersions(a64StrLdrAlloc.Adapter()),
+        cgDce(&dce) {}
+  ~A64StrLdrProp() {}
+
+  void Init() {
+    defInsn = nullptr;
+  }
+  void DoOpt();
+
+ private:
+  MemOperand *StrLdrPropPreCheck(const Insn &insn, MemPropMode prevMod = kUndef);
+  static MemPropMode SelectStrLdrPropMode(const  MemOperand &currMemOpnd);
+  bool ReplaceMemOpnd(const MemOperand &currMemOpnd);
+  MemOperand *SelectReplaceMem(const MemOperand &currMemOpnd);
+  RegOperand *GetReplaceReg(RegOperand &a64Reg);
+  MemOperand *HandleArithImmDef(RegOperand &replace, Operand *oldOffset, int64 defVal, uint32 memSize) const;
+  MemOperand *SelectReplaceExt(RegOperand &base, uint32 amount, bool isSigned, uint32 memSize);
+  bool CheckNewMemOffset(const Insn &insn, MemOperand *newMemOpnd, uint32 opndIdx) const;
+  void DoMemReplace(const RegOperand &replacedReg, MemOperand &newMem, Insn &useInsn);
+  uint32 GetMemOpndIdx(MemOperand *newMemOpnd, const Insn &insn) const;
+  Insn *GetDefInsn(const RegOperand &regOpnd, std::vector<Insn*> &allUseInsns);
+  bool IsSameOpndsOfInsn(const Insn &insn1, const Insn &insn2, uint32 opndIdx);
+  bool IsPhiInsnValid(const Insn &phiInsn);
+  bool CheckSameReplace(const RegOperand &replacedReg, const MemOperand *memOpnd) const;
+
+  CGFunc *cgFunc;
+  CGSSAInfo *ssaInfo;
+  Insn *curInsn;
+  MapleAllocator a64StrLdrAlloc;
+  MapleMap<regno_t, VRegVersion*> replaceVersions;
+  MemPropMode memPropMode = kUndef;
+  CGDce *cgDce = nullptr;
+  Insn *defInsn = nullptr;
+};
+
+enum ArithmeticType {
+  kAArch64Add,
+  kAArch64Sub,
+  kAArch64Logic,
+  kUndefArith
+};
+
+class A64ConstProp {
+ public:
+  A64ConstProp(MemPool &mp, CGFunc &f, CGSSAInfo &sInfo, Insn &insn)
+      : constPropMp(&mp),
+        cgFunc(&f),
+        ssaInfo(&sInfo),
+        curInsn(&insn) {}
+  void DoOpt();
+  /* false : default lsl #0 true: lsl #12 (only support 12 bit left shift in aarch64) */
+  static MOperator GetRegImmMOP(MOperator regregMop, bool withLeftShift);
+  static MOperator GetReversalMOP(MOperator arithMop);
+  static MOperator GetFoldMopAndVal(int64 &newVal, int64 constVal, const Insn &arithInsn);
+
+ private:
+  bool ConstProp(DUInsnInfo &useDUInfo, ImmOperand &constOpnd);
+  /* use xzr/wzr in aarch64 to shrink register live range */
+  void ZeroRegProp(DUInsnInfo &useDUInfo, RegOperand &toReplaceReg) const;
+
+  /* replace old Insn with new Insn, update ssa info automatically */
+  void ReplaceInsnAndUpdateSSA(Insn &oriInsn, Insn &newInsn) const;
+  ImmOperand *CanDoConstFold(const ImmOperand &value1, const ImmOperand &value2, ArithmeticType aT, bool is64Bit) const;
+
+  /* optimization */
+  bool MovConstReplace(DUInsnInfo &useDUInfo, ImmOperand &constOpnd) const;
+  bool ArithConstReplaceForOneOpnd(Insn &useInsn, DUInsnInfo &useDUInfo,
+                                   ImmOperand &constOpnd, ArithmeticType aT);
+  bool ArithmeticConstReplace(DUInsnInfo &useDUInfo, ImmOperand &constOpnd, ArithmeticType aT);
+  bool ArithmeticConstFold(DUInsnInfo &useDUInfo, const ImmOperand &constOpnd, ArithmeticType aT) const;
+  bool ShiftConstReplace(DUInsnInfo &useDUInfo, const ImmOperand &constOpnd);
+  bool BitInsertReplace(DUInsnInfo &useDUInfo, const ImmOperand &constOpnd) const;
+
+  MemPool *constPropMp;
+  CGFunc *cgFunc;
+  CGSSAInfo *ssaInfo;
+  Insn *curInsn;
+};
+
+class CopyRegProp : public PropOptimizePattern {
+ public:
+  CopyRegProp(CGFunc &cgFunc, CGSSAInfo *cgssaInfo, LiveIntervalAnalysis *ll)
+      : PropOptimizePattern(cgFunc, cgssaInfo, ll) {}
+  ~CopyRegProp() override {
+    destVersion = nullptr;
+    srcVersion = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final {
+    destVersion = nullptr;
+    srcVersion = nullptr;
+  }
+ private:
+  bool IsValidCopyProp(const RegOperand &dstReg, const RegOperand &srcReg) const;
+  void VaildateImplicitCvt(RegOperand &destReg, const RegOperand &srcReg, Insn &movInsn);
+  bool IsNotSpecialOptimizedInsn(const Insn &insn);
+  void ReplaceAllUseForCopyProp();
+  VRegVersion *destVersion = nullptr;
+  VRegVersion *srcVersion = nullptr;
+};
+
+class RedundantPhiProp : public PropOptimizePattern {
+ public:
+  RedundantPhiProp(CGFunc &cgFunc, CGSSAInfo *cgssaInfo) : PropOptimizePattern(cgFunc, cgssaInfo) {}
+  ~RedundantPhiProp() override {
+    destVersion = nullptr;
+    srcVersion = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final {
+    destVersion = nullptr;
+    srcVersion = nullptr;
+  }
+
+ private:
+  VRegVersion *destVersion = nullptr;
+  VRegVersion *srcVersion = nullptr;
+};
+
+class ValidBitNumberProp : public PropOptimizePattern {
+ public:
+  ValidBitNumberProp(CGFunc &cgFunc, CGSSAInfo *cgssaInfo) : PropOptimizePattern(cgFunc, cgssaInfo) {}
+  ~ValidBitNumberProp() override {
+    destVersion = nullptr;
+    srcVersion = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final {
+    destVersion = nullptr;
+    srcVersion = nullptr;
+  }
+ private:
+  bool IsImplicitUse(const RegOperand &dstOpnd, const RegOperand &srcOpnd) const;
+  VRegVersion *destVersion = nullptr;
+  VRegVersion *srcVersion = nullptr;
+};
+
+/*
+ * frame pointer and stack pointer will not be varied in function body
+ * treat them as const
+ */
+class FpSpConstProp : public PropOptimizePattern {
+ public:
+  FpSpConstProp(CGFunc &cgFunc, CGSSAInfo *cgssaInfo) : PropOptimizePattern(cgFunc, cgssaInfo) {}
+  ~FpSpConstProp() override {
+    fpSpBase = nullptr;
+    shiftOpnd = nullptr;
+    replaced = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final {
+    fpSpBase = nullptr;
+    shiftOpnd = nullptr;
+    aT = kUndefArith;
+    replaced = nullptr;
+  }
+
+ private:
+  bool GetValidSSAInfo(Operand &opnd);
+  void PropInMem(DUInsnInfo &useDUInfo, Insn &useInsn);
+  void PropInArith(DUInsnInfo &useDUInfo, Insn &useInsn, ArithmeticType curAT);
+  void PropInCopy(DUInsnInfo &useDUInfo, Insn &useInsn, MOperator oriMop);
+  int64 ArithmeticFold(int64 valInUse, ArithmeticType useAT) const;
+
+  RegOperand *fpSpBase = nullptr;
+  ImmOperand *shiftOpnd = nullptr;
+  ArithmeticType aT = kUndefArith;
+  VRegVersion *replaced = nullptr;
+};
+
+/*
+ * This pattern do:
+ * 1)
+ * uxtw vreg:Rm validBitNum:[64], vreg:Rn validBitNum:[32]
+ * ------>
+ * mov vreg:Rm validBitNum:[64], vreg:Rn validBitNum:[32]
+ * 2)
+ * ldrh  R201, [...]
+ * and R202, R201, #65520
+ * uxth  R203, R202
+ * ------->
+ * ldrh  R201, [...]
+ * and R202, R201, #65520
+ * mov  R203, R202
+ */
+class ExtendMovPattern : public PropOptimizePattern {
+ public:
+  ExtendMovPattern(CGFunc &cgFunc, CGSSAInfo *cgssaInfo) : PropOptimizePattern(cgFunc, cgssaInfo) {}
+  ~ExtendMovPattern() override = default;
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final;
+
+ private:
+  bool BitNotAffected(const Insn &insn, uint32 validNum); /* check whether significant bits are affected */
+  bool CheckSrcReg(regno_t srcRegNo, uint32 validNum);
+
+  MOperator replaceMop = MOP_undef;
+};
+
+class ExtendShiftPattern : public PropOptimizePattern {
+ public:
+  ExtendShiftPattern(CGFunc &cgFunc, CGSSAInfo *cgssaInfo) : PropOptimizePattern(cgFunc, cgssaInfo) {}
+  ~ExtendShiftPattern() override {
+    defInsn = nullptr;
+    newInsn = nullptr;
+    curInsn = nullptr;
+  }
+  bool IsSwapInsn(const Insn &insn) const;
+  void SwapOpnd(Insn &insn);
+  bool CheckAllOpndCondition(Insn &insn);
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+  void DoExtendShiftOpt(Insn &insn);
+
+ protected:
+  void Init() final;
+
+ private:
+  void SelectExtendOrShift(const Insn &def);
+  SuffixType CheckOpType(const Operand &lastOpnd) const;
+  void ReplaceUseInsn(Insn &use, const Insn &def, uint32 amount);
+  void SetExMOpType(const Insn &use);
+  void SetLsMOpType(const Insn &use);
+
+  MOperator replaceOp = 0;
+  uint32 replaceIdx = 0;
+  ExtendShiftOperand::ExtendOp extendOp = ExtendShiftOperand::kUndef;
+  BitShiftOperand::ShiftOp shiftOp = BitShiftOperand::kUndef;
+  Insn *defInsn = nullptr;
+  Insn *newInsn = nullptr;
+  Insn *curInsn = nullptr;
+  bool optSuccess = false;
+  ExMOpType exMOpType = kExUndef;
+  LsMOpType lsMOpType = kLsUndef;
+  bool is64BitSize = false;
+};
+
+/*
+ * For example:
+ *  1) lsr R102, R101, #1
+ *     lsr R103, R102, #6   ====>   lsr R103, R101, #7
+ *
+ *  2) add R102, R101, #1
+ *     sub R103, R102, #1   ====>   Replace R103 with R101
+ *
+ * Condition:
+ *   the immVal can not be negative
+ */
+class A64ConstFoldPattern : public PropOptimizePattern {
+ public:
+  A64ConstFoldPattern(CGFunc &cgFunc, CGSSAInfo *ssaInfo)
+      : PropOptimizePattern(cgFunc, ssaInfo) {}
+  ~A64ConstFoldPattern() override {
+    defInsn = nullptr;
+    dstOpnd = nullptr;
+    srcOpnd = nullptr;
+  }
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(Insn &insn) final;
+  void Run() final;
+
+ protected:
+  void Init() final {
+    defInsn = nullptr;
+    dstOpnd = nullptr;
+    srcOpnd = nullptr;
+    defDstOpnd = nullptr;
+    useFoldType = kFoldUndef;
+    defFoldType = kFoldUndef;
+    optType = kOptUndef;
+    is64Bit = false;
+  }
+
+ private:
+  enum FoldType : uint8 {
+    kAdd,
+    kSub,
+    kLsr,
+    kLsl,
+    kAsr,
+    kAnd,
+    kOrr,
+    kEor,
+    kFoldUndef
+  };
+  enum OptType : uint8 {
+    kNegativeDef,      /* negative the immVal of defInsn */
+    kNegativeUse,      /* negative the immVal of useInsn */
+    kNegativeBoth,     /* negative the immVal of both defInsn and useInsn */
+    kPositive,         /* do not change the immVal of both defInsn and useInsn */
+    kLogicalAnd,       /* for kAnd */
+    kLogicalOrr,       /* for kOrr */
+    kLogicalEor,       /* for kEor */
+    kOptUndef
+  };
+  constexpr static uint32 kFoldTypeSize = 8;
+  OptType constFoldTable[kFoldTypeSize][kFoldTypeSize] = {
+    /* defInsn: kAdd     kSub        kLsr        kLsl       kAsr     kAnd      kOrr    kEor */
+    {kPositive,    kNegativeDef,  kOptUndef, kOptUndef, kOptUndef, kOptUndef,
+     kOptUndef, kOptUndef},      /* useInsn == kAdd */
+    {kNegativeUse, kNegativeBoth, kOptUndef, kOptUndef, kOptUndef, kOptUndef,
+     kOptUndef, kOptUndef},      /* useInsn == kSub */
+    {kOptUndef,    kOptUndef,     kPositive, kOptUndef, kOptUndef, kOptUndef,
+     kOptUndef, kOptUndef},      /* useInsn == kLsr */
+    {kOptUndef,    kOptUndef,     kOptUndef, kPositive, kOptUndef, kOptUndef,
+     kOptUndef, kOptUndef},      /* useInsn == kLsl */
+    {kOptUndef,    kOptUndef,     kOptUndef, kOptUndef, kPositive, kOptUndef,
+     kOptUndef, kOptUndef},      /* useInsn == kAsr */
+    {kOptUndef,    kOptUndef,     kOptUndef, kOptUndef, kOptUndef, kLogicalAnd,
+     kOptUndef, kOptUndef},      /* useInsn == kAnd */
+    {kOptUndef,    kOptUndef,     kOptUndef, kOptUndef, kOptUndef, kOptUndef,
+     kLogicalOrr, kOptUndef},    /* useInsn == kOrr */
+    {kOptUndef,    kOptUndef,     kOptUndef, kOptUndef, kOptUndef, kOptUndef,
+     kOptUndef, kLogicalEor},    /* useInsn == kEor */
+  };
+
+  std::pair<FoldType, bool> SelectFoldTypeAndCheck64BitSize(const Insn &insn) const;
+  ImmOperand &GetNewImmOpnd(const ImmOperand &immOpnd, int64 newImmVal) const;
+  MOperator GetNewMop(bool isNegativeVal, MOperator curMop) const;
+  int64 GetNewImmVal(const Insn &insn, const ImmOperand &defImmOpnd) const;
+  void ReplaceWithNewInsn(Insn &insn, const ImmOperand &immOpnd, int64 newImmVal);
+  bool IsDefInsnValid(const Insn &curInsn, const Insn &validDefInsn);
+  bool IsPhiInsnValid(const Insn &curInsn, const Insn &phiInsn);
+  bool IsCompleteOptimization();
+  Insn *defInsn = nullptr;
+  RegOperand *dstOpnd = nullptr;
+  RegOperand *srcOpnd = nullptr;
+  RegOperand *defDstOpnd = nullptr;
+  FoldType useFoldType = kFoldUndef;
+  FoldType defFoldType = kFoldUndef;
+  OptType optType = kOptUndef;
+  bool is64Bit = false;
+  using TypeAndSize = std::pair<FoldType, bool>;
+};
+
+/*
+ * optimization for call convention
+ * example:
+ *                              [BB26]                      [BB43]
+ *                        sub R287, R101, R275        sub R279, R101, R275
+ *                                            \      /
+ *                                             \    /
+ *                                             [BB27]
+ *                                                <---- insert new phi: R403, (R275 <26>, R275 <43>)
+ *                                       old phi: R297, (R287 <26>, R279 <43>)
+ *                                               /          \
+ *                                              /            \
+ *                                           [BB28]           \
+ *                                       sub R310, R101, R309  \
+ *                                             |                \
+ *                                             |                 \
+ *            [BB17]                         [BB29]            [BB44]
+ *        sub R314, R101, R275                 |              /
+ *                                \            |             /
+ *                                 \           |            /
+ *                                  \          |           /
+ *                                   \         |          /
+ *                                           [BB18]
+ *                                               <---- insert new phi: R404, (R275 <17>, R309 <29>, R403 <44>)
+ *                                       old phi: R318, (R314 <17>, R310 <29>, R297 <44>)
+ *                                       mov R1, R318    ====>    sub R1, R101, R404
+ *                                          /                   \
+ *                                         /                     \
+ *                                        /                       \
+ *                                     [BB19]                   [BB34]
+ *                              sub R336, R101, R335           /
+ *                                               \            /
+ *                                                \          /
+ *                                                 \        /
+ *                                                   [BB20]
+ *                                                      <---- insert new phi: R405, (R335 <19>, R404<34>)
+ *                                                old phi: R340, (R336 <19>, R318 <34>)
+ *                                                mov R1, R340      ====>     sub R1, R101, R405
+ */
+class A64PregCopyPattern : public PropOptimizePattern {
+ public:
+  A64PregCopyPattern(CGFunc &cgFunc, CGSSAInfo *cgssaInfo) : PropOptimizePattern(cgFunc, cgssaInfo) {}
+  ~A64PregCopyPattern() override {
+    firstPhiInsn = nullptr;
+  }
+  bool CheckCondition(Insn &insn) override;
+  void Optimize(Insn &insn) override;
+  void Run() override;
+
+ protected:
+  void Init() override {
+    validDefInsns.clear();
+    firstPhiInsn = nullptr;
+    differIdx = -1;
+    differOrigNO = 0;
+    isCrossPhi = false;
+  }
+
+ private:
+  bool CheckUselessDefInsn(const Insn *defInsn) const;
+  bool CheckValidDefInsn(const Insn *defInsn);
+  bool CheckMultiUsePoints(const Insn *defInsn) const;
+  bool CheckPhiCaseCondition(Insn &defInsn);
+  bool DFSFindValidDefInsns(Insn *curDefInsn, std::vector<regno_t> &visitedPhiDefs,
+                            std::unordered_map<uint32, bool> &visited);
+  Insn &CreateNewPhiInsn(std::unordered_map<uint32, RegOperand*> &newPhiList, Insn *curInsn);
+  RegOperand &DFSBuildPhiInsn(Insn *curInsn, std::unordered_map<uint32, RegOperand*> &visited);
+  RegOperand *CheckAndGetExistPhiDef(Insn &phiInsn, std::vector<regno_t> &validDifferRegNOs) const;
+  std::vector<Insn*> validDefInsns;
+  Insn *firstPhiInsn = nullptr;
+  int differIdx = -1;
+  regno_t differOrigNO = 0;
+  bool isCrossPhi = false;
+};
+
+class A64ReplaceRegOpndVisitor : public ReplaceRegOpndVisitor {
+ public:
+  A64ReplaceRegOpndVisitor(CGFunc &f, Insn &cInsn, uint32 cIdx, RegOperand &oldRegister, RegOperand &newRegister)
+      : ReplaceRegOpndVisitor(f, cInsn, cIdx, oldRegister, newRegister) {}
+  ~A64ReplaceRegOpndVisitor() override = default;
+ private:
+  void Visit(RegOperand *v) final;
+  void Visit(ListOperand *v) final;
+  void Visit(MemOperand *a64memOpnd) final;
+  void Visit(PhiOperand *v) final;
+};
+}
+#endif /* MAPLEBE_INCLUDE_AARCH64_PROP_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_ra_opt.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ra_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ab20564714caf4e764a3447ec89c48227b80b6e
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ra_opt.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64RAOPT_H
+#define MAPLEBE_INCLUDE_CG_AARCH64RAOPT_H
+
+#include "cg.h"
+#include "ra_opt.h"
+#include "aarch64_cg.h"
+#include "aarch64_insn.h"
+#include "aarch64_operand.h"
+
+namespace maplebe {
+class X0OptInfo {
+ public:
+  X0OptInfo() : movSrc(nullptr), replaceReg(0), renameInsn(nullptr), renameOpnd(nullptr), renameReg(0) {}
+  ~X0OptInfo() = default;
+
+  inline RegOperand *GetMovSrc() const {
+    return movSrc;
+  }
+
+  inline regno_t GetReplaceReg() const {
+    return replaceReg;
+  }
+
+  inline Insn *GetRenameInsn() const {
+    return renameInsn;
+  }
+
+  inline Operand *GetRenameOpnd() const {
+    return renameOpnd;
+  }
+
+  inline regno_t GetRenameReg() const {
+    return renameReg;
+  }
+
+  inline void SetMovSrc(RegOperand *srcReg) {
+    movSrc = srcReg;
+  }
+
+  inline void SetReplaceReg(regno_t regno) {
+    replaceReg = regno;
+  }
+
+  inline void SetRenameInsn(Insn *insn) {
+    renameInsn = insn;
+  }
+
+  inline void ResetRenameInsn() {
+    renameInsn = nullptr;
+  }
+
+  inline void SetRenameOpnd(Operand *opnd) {
+    renameOpnd = opnd;
+  }
+
+  inline void SetRenameReg(regno_t regno) {
+    renameReg = regno;
+  }
+
+ private:
+  RegOperand *movSrc;
+  regno_t replaceReg;
+  Insn *renameInsn;
+  Operand *renameOpnd;
+  regno_t renameReg;
+};
+
+class RaX0Opt {
+ public:
+  explicit RaX0Opt(CGFunc* func) : cgFunc(func)  {}
+  ~RaX0Opt() = default;
+
+  bool PropagateX0CanReplace(Operand *opnd, regno_t replaceReg) const;
+  bool PropagateRenameReg(Insn *nInsn, const X0OptInfo &optVal) const;
+  bool PropagateX0DetectX0(const Insn *insn, X0OptInfo &optVal) const;
+  bool PropagateX0DetectRedefine(const InsnDesc *md, const Insn *ninsn, const X0OptInfo &optVal, uint32 index) const;
+  bool PropagateX0Optimize(const BB *bb, const Insn *insn, X0OptInfo &optVal) const;
+  bool PropagateX0ForCurrBb(BB *bb, const X0OptInfo &optVal) const;
+  void PropagateX0ForNextBb(BB *nextBb, const X0OptInfo &optVal) const;
+  void PropagateX0();
+
+ private:
+  CGFunc *cgFunc;
+};
+
+class ParamRegOpt {
+ public:
+  ParamRegOpt(CGFunc *func, DomAnalysis *dom) : cgFunc(func), domInfo(dom) {}
+  ~ParamRegOpt() = default;
+
+  void HandleParamReg();
+  void CollectRefBBs(RegOperand &movDest, std::set<uint32> &refBBs);
+  void TryToSplitParamReg(RegOperand &movDest, Insn &posInsn);
+  BB* GetCommondDom(std::set<uint32> &refBBs);
+  bool DominatorAll(uint32 domBB, std::set<uint32> &refBBs) const;
+  void SplitAtDomBB(RegOperand &movDest, BB &domBB, Insn &posInsn) const;
+  void SetDumpInfo(bool val) {
+    dumpInfo = val;
+  }
+
+ private:
+  CGFunc *cgFunc;
+  DomAnalysis *domInfo;
+  bool dumpInfo = false;
+};
+
+class VregRenameInfo {
+ public:
+  VregRenameInfo() = default;
+
+  ~VregRenameInfo() = default;
+
+  BB *firstBBLevelSeen = nullptr;
+  BB *lastBBLevelSeen = nullptr;
+  uint32 numDefs = 0;
+  uint32 numUses = 0;
+  uint32 numInnerDefs = 0;
+  uint32 numInnerUses = 0;
+  uint32 largestUnusedDistance = 0;
+  uint8 innerMostloopLevelSeen = 0;
+};
+
+class VregRename {
+ public:
+  VregRename(CGFunc *func, MemPool *pool) : cgFunc(func), memPool(pool), alloc(pool), renameInfo(alloc.Adapter()) {
+    renameInfo.resize(cgFunc->GetMaxRegNum());
+    ccRegno = static_cast<RegOperand *>(&cgFunc->GetOrCreateRflag())->GetRegisterNumber();
+  }
+  ~VregRename() = default;
+
+  void PrintRenameInfo(regno_t regno) const;
+  void PrintAllRenameInfo() const;
+
+  void RenameFindLoopVregs(const CGFuncLoops *loop);
+  void RenameFindVregsToRename(const CGFuncLoops *loop);
+  bool IsProfitableToRename(const VregRenameInfo *info) const;
+  void RenameProfitableVreg(RegOperand *ropnd, const CGFuncLoops *loop);
+  void RenameGetFuncVregInfo();
+  void UpdateVregInfo(regno_t vreg, BB *bb, bool isInner, bool isDef);
+  void VregLongLiveRename();
+
+  CGFunc *cgFunc = nullptr;
+  MemPool *memPool = nullptr;
+  MapleAllocator alloc;
+  Bfs *bfs = nullptr;
+  MapleVector<VregRenameInfo*> renameInfo;
+  uint32 maxRegnoSeen = 0;
+  regno_t ccRegno = 0;
+};
+
+class AArch64RaOpt : public RaOpt {
+ public:
+  AArch64RaOpt(CGFunc &func, MemPool &pool) : RaOpt(func, pool) {}
+  ~AArch64RaOpt() override = default;
+  void Run() override;
+
+ private:
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64RAOPT_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_rce.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_rce.h
new file mode 100644
index 0000000000000000000000000000000000000000..ceb6ea0b38ac900211e85f80abc38df5dbfbe60c
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_rce.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_RCE_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_RCE_H
+
+#include "cg_rce.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+static std::size_t g_hashSeed = 0;
+using InsnPtr = Insn*;
+/*
+ * Redundancy elimination with the same right value
+ * Example:
+ *   mov   R140, #31161
+ *   movk  R140(use){implicit-def: R141}, #40503, LSL #16
+ *   ...
+ *   mov   R149, #31161
+ *   movk  R149(use){implicit-def: R150}, #40503, LSL #16     ===> redundant
+ *
+ * 1) do not support vector ops & mem ops currently
+ */
+class AArch64RedundantComputeElim : public RedundantComputeElim {
+ public:
+  AArch64RedundantComputeElim(CGFunc &f, CGSSAInfo &info, MemPool &mp) :
+      RedundantComputeElim(f, info, mp), candidates(rceAlloc.Adapter()) {}
+  ~AArch64RedundantComputeElim() override {}
+
+  void Run() override;
+  void DumpHash() const;
+
+ private:
+  struct InsnRHSHash {
+    std::size_t operator()(const InsnPtr &insn) const {
+      std::string hashS = (insn->IsVectorOp() ? std::to_string(++g_hashSeed) :
+                                                std::to_string(insn->GetMachineOpcode()));
+      uint32 opndNum = insn->GetOperandSize();
+      hashS += std::to_string(opndNum);
+      for (uint i = 0; i < opndNum; ++i) {
+        Operand &opnd = insn->GetOperand(i);
+        Operand::OperandType opndKind = opnd.GetKind();
+        if (opnd.IsRegister() && !static_cast<RegOperand&>(opnd).IsPhysicalRegister() && !insn->OpndIsDef(i)) {
+          hashS += static_cast<RegOperand&>(opnd).GetHashContent();
+        } else if (opndKind == Operand::kOpdImmediate) {
+          hashS += static_cast<ImmOperand&>(opnd).GetHashContent();
+        } else if (opndKind == Operand::kOpdExtend) {
+          hashS += static_cast<ExtendShiftOperand&>(opnd).GetHashContent();
+        } else if (opndKind == Operand::kOpdShift) {
+          hashS += static_cast<BitShiftOperand&>(opnd).GetHashContent();
+        } else if (opnd.IsRegister() && insn->OpndIsDef(i) && insn->OpndIsUse(i)) {
+          hashS += static_cast<RegOperand&>(opnd).GetHashContent();
+        } else if (opnd.IsRegister() && insn->OpndIsDef(i)) {
+          continue;
+        } else {
+          hashS += std::to_string(++g_hashSeed);
+        }
+      }
+      return std::hash<std::string>{}(hashS);
+    }
+  };
+
+  struct InsnRHSEqual {
+    bool operator()(const InsnPtr &insn1, const InsnPtr &insn2) const {
+      if (insn1->GetMachineOpcode() != insn2->GetMachineOpcode()) {
+        return false;
+      }
+      if (insn1->IsVectorOp()) {
+        return false;
+      }
+      uint32 opndNum1 = insn1->GetOperandSize();
+      uint32 opndNum2 = insn2->GetOperandSize();
+      if (opndNum1 != opndNum2) {
+        return false;
+      }
+      for (uint32 i = 0; i < opndNum1; ++i) {
+        Operand &opnd1 = insn1->GetOperand(i);
+        Operand::OperandType opk1 = opnd1.GetKind();
+        Operand &opnd2 = insn2->GetOperand(i);
+        /* There are cases that the operand is both def and use */
+        if (opnd1.IsRegister() && opnd2.IsRegister() && insn1->OpndIsDef(i) && insn2->OpndIsDef(i) &&
+            !insn1->OpndIsUse(i) && !insn2->OpndIsUse(i)) {
+          continue;
+        }
+        if (!opnd1.BasicEquals(opnd2)) {
+          return false;
+        }
+        if (opk1 == Operand::kOpdRegister) {
+          if (!static_cast<RegOperand&>(opnd1).Equals(opnd2)) {
+            return false;
+          }
+          if (static_cast<RegOperand&>(opnd1).IsPhysicalRegister() ||
+              static_cast<RegOperand&>(opnd2).IsPhysicalRegister()) {
+            return false;
+          }
+        } else if (opk1 == Operand::kOpdImmediate) {
+          if (!static_cast<ImmOperand&>(opnd1).Equals(opnd2)) {
+            return false;
+          }
+        } else if (opk1 == Operand::kOpdExtend) {
+          if (!static_cast<ExtendShiftOperand&>(opnd1).Equals(opnd2)) {
+            return false;
+          }
+        } else if (opk1 == Operand::kOpdShift) {
+          if (!static_cast<BitShiftOperand&>(opnd1).Equals(opnd2)) {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      }
+      return true;
+    }
+  };
+
+  bool DoOpt(BB *bb);
+  bool IsBothDefUseCase(VRegVersion &version) const;
+  bool CheckFakeOptmization(const Insn &existInsn) const;
+  void CheckCondition(const Insn &existInsn, const Insn &curInsn);
+  void CheckBothDefAndUseChain(RegOperand *curDstOpnd, RegOperand *existDstOpnd);
+  std::size_t ComputeDefUseHash(const Insn &insn, const RegOperand *replaceOpnd) const;
+  DUInsnInfo *GetDefUseInsnInfo(VRegVersion &defVersion);
+  MOperator GetNewMop(const RegOperand &curDstOpnd, const RegOperand &existDstOpnd) const;
+  void Optimize(BB &curBB, Insn &curInsn, RegOperand &curDstOpnd, RegOperand &existDstOpnd) const;
+  MapleUnorderedSet<InsnPtr, InsnRHSHash, InsnRHSEqual> candidates;
+  bool doOpt = true;
+  bool isBothDefUse = false;
+};
+} /* namespace maplebe */
+#endif /* MAPLEBE_INCLUDE_CG_AARCH64_RCE_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_reaching.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_reaching.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f0363fdd69b9673e8c0bd41f93108c07c5cc215
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_reaching.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REACHING_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REACHING_H
+
+#include "reaching.h"
+#include "aarch64_operand.h"
+
+namespace maplebe {
+class AArch64ReachingDefinition : public ReachingDefinition {
+ public:
+  AArch64ReachingDefinition(CGFunc &func, MemPool &memPool) : ReachingDefinition(func, memPool) {}
+  ~AArch64ReachingDefinition() override = default;
+  std::vector<Insn*> FindRegDefBetweenInsnGlobal(uint32 regNO, Insn *startInsn, Insn *endInsn) const final;
+  std::vector<Insn*> FindMemDefBetweenInsn(uint32 offset, const Insn *startInsn, Insn *endInsn) const final;
+  bool FindRegUseBetweenInsn(uint32 regNO, Insn *startInsn, Insn *endInsn, InsnSet &regUseInsnSet) const final;
+  bool FindRegUseBetweenInsnGlobal(uint32 regNO, Insn *startInsn, Insn *endInsn, BB* movBB) const final;
+  bool FindMemUseBetweenInsn(uint32 offset, Insn *startInsn, const Insn *endInsn,
+                             InsnSet &memUseInsnSet) const final;
+  bool HasRegDefBetweenInsnGlobal(uint32 regNO, Insn &startInsn, Insn &endInsn) const;
+  bool DFSFindRegDefBetweenBB(const BB &startBB, const BB &endBB, uint32 regNO,
+                              std::vector<VisitStatus> &visitedBB) const;
+  InsnSet FindDefForRegOpnd(Insn &insn, uint32 indexOrRegNO, bool isRegNO = false) const final;
+  InsnSet FindDefForMemOpnd(Insn &insn, uint32 indexOrOffset, bool isOffset = false) const final;
+  InsnSet FindUseForMemOpnd(Insn &insn, uint8 index, bool secondMem = false) const final;
+  bool FindRegUsingBetweenInsn(uint32 regNO, Insn *startInsn, const Insn *endInsn) const;
+
+ protected:
+  void InitStartGen() final;
+  void InitEhDefine(BB &bb) final;
+  void InitGenUse(BB &bb, bool firstTime = true) final;
+  void GenAllAsmDefRegs(BB &bb, Insn &insn, uint32 index) final;
+  void GenAllAsmUseRegs(BB &bb, Insn &insn, uint32 index) final;
+  void GenAllCallerSavedRegs(BB &bb, Insn &insn) final;
+  bool IsRegKilledByCallInsn(const Insn &insn, regno_t regNO) const final;
+  bool KilledByCallBetweenInsnInSameBB(const Insn &startInsn, const Insn &endInsn, regno_t regNO) const final;
+  void AddRetPseudoInsn(BB &bb) final;
+  void AddRetPseudoInsns() final;
+  bool IsCallerSavedReg(uint32 regNO) const final;
+  void FindRegDefInBB(uint32 regNO, BB &bb, InsnSet &defInsnSet) const final;
+  void FindMemDefInBB(uint32 offset, BB &bb, InsnSet &defInsnSet) const final;
+  void DFSFindDefForRegOpnd(const BB &startBB, uint32 regNO, std::vector<VisitStatus> &visitedBB,
+                            InsnSet &defInsnSet) const final;
+  void DFSFindDefForMemOpnd(const BB &startBB, uint32 offset, std::vector<VisitStatus> &visitedBB,
+                            InsnSet &defInsnSet) const final;
+  int32 GetStackSize() const final;
+
+ private:
+  void InitInfoForMemOperand(Insn &insn, Operand &opnd, bool isDef);
+  void InitInfoForListOpnd(const BB &bb, const Operand &opnd);
+  void InitInfoForConditionCode(const BB &bb);
+  void InitInfoForRegOpnd(const BB &bb, Operand &opnd, bool isDef);
+  void InitMemInfoForClearStackCall(Insn &callInsn);
+  inline bool CallInsnClearDesignateStackRef(const Insn &callInsn, int64 offset) const;
+  int64 GetEachMemSizeOfPair(MOperator opCode) const;
+  bool DFSFindRegInfoBetweenBB(const BB startBB, const BB &endBB, uint32 regNO, std::vector<VisitStatus> &visitedBB,
+                               std::list<bool> &pathStatus, DumpType infoType) const;
+  bool DFSFindRegDomianBetweenBB(const BB startBB, uint32 regNO, std::vector<VisitStatus> &visitedBB) const;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REACHING_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_reg_coalesce.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_reg_coalesce.h
new file mode 100644
index 0000000000000000000000000000000000000000..4698d4b2a83c5f49bcab80a71934877f1cfd68bd
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_reg_coalesce.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REGCOALESCE_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REGCOALESCE_H
+#include "reg_coalesce.h"
+#include "aarch64_isa.h"
+#include "live.h"
+
+namespace maplebe {
+class AArch64LiveIntervalAnalysis : public LiveIntervalAnalysis {
+ public:
+  AArch64LiveIntervalAnalysis(CGFunc &func, MemPool &memPool)
+      : LiveIntervalAnalysis(func, memPool),
+        vregLive(alloc.Adapter()),
+        candidates(alloc.Adapter()) {}
+
+  ~AArch64LiveIntervalAnalysis() override = default;
+
+  void ComputeLiveIntervals() override;
+  bool IsUnconcernedReg(const RegOperand &regOpnd) const;
+  LiveInterval *GetOrCreateLiveInterval(regno_t regNO);
+  void UpdateCallInfo();
+  void SetupLiveIntervalByOp(const Operand &op, Insn &insn, bool isDef);
+  void ComputeLiveIntervalsForEachDefOperand(Insn &insn);
+  void ComputeLiveIntervalsForEachUseOperand(Insn &insn);
+  void SetupLiveIntervalInLiveOut(regno_t liveOut, const BB &bb, uint32 currPoint);
+  void CoalesceRegPair(RegOperand &regDest, RegOperand &regSrc);
+  void CoalesceRegisters() override;
+  void CollectMoveForEachBB(BB &bb, std::vector<Insn*> &movInsns) const;
+  void CoalesceMoves(std::vector<Insn*> &movInsns, bool phiOnly);
+  void CheckInterference(LiveInterval &li1, LiveInterval &li2) const;
+  void CollectCandidate();
+  std::string PhaseName() const {
+    return "regcoalesce";
+  }
+
+ private:
+  static bool IsRegistersCopy(Insn &insn);
+  MapleUnorderedSet<regno_t> vregLive;
+  MapleSet<regno_t> candidates;
+};
+
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REGCOALESCE_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_reg_info.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_reg_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..0af05c9890574241f64e282a2a2039c7e532f39e
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_reg_info.h
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REG_INFO_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REG_INFO_H
+#include "reg_info.h"
+#include "aarch64_operand.h"
+#include "aarch64_insn.h"
+#include "aarch64_abi.h"
+
+namespace maplebe {
+
+class AArch64RegInfo : public RegisterInfo {
+ public:
+  explicit AArch64RegInfo(MapleAllocator &mallocator) : RegisterInfo(mallocator) {}
+
+  ~AArch64RegInfo() override = default;
+
+  bool IsGPRegister(regno_t regNO) const override {
+    return AArch64isa::IsGPRegister(static_cast<AArch64reg>(regNO));
+  }
+  /* phys reg which can be pre-Assignment */
+  bool IsPreAssignedReg(regno_t regNO) const override {
+    return AArch64Abi::IsParamReg(static_cast<AArch64reg>(regNO));
+  }
+  regno_t GetIntRetReg(uint32 idx) override {
+    CHECK_FATAL(idx < AArch64Abi::kNumIntParmRegs, "index out of range in IntRetReg");
+    return AArch64Abi::kIntReturnRegs[idx];
+  }
+  regno_t GetFpRetReg(uint32 idx) override {
+    CHECK_FATAL(idx < AArch64Abi::kNumFloatParmRegs, "index out of range in FloatRetReg");
+    return AArch64Abi::kFloatReturnRegs[idx];
+  }
+  bool IsAvailableReg(regno_t regNO) const override {
+    return AArch64Abi::IsAvailableReg(static_cast<AArch64reg>(regNO));
+  }
+  /* Those registers can not be overwrite. */
+  bool IsUntouchableReg(regno_t regNO) const override{
+    if ((regNO == RSP) || (regNO == RFP) || regNO == RZR) {
+      return true;
+    }
+    /* when yieldpoint is enabled, the RYP(x19) can not be used. */
+    if (GetCurrFunction()->GetCG()->GenYieldPoint() && (regNO == RYP)) {
+      return true;
+    }
+    return false;
+  }
+  uint32 GetIntRegsParmsNum() override {
+    return AArch64Abi::kNumIntParmRegs;
+  }
+  uint32 GetFloatRegsParmsNum() override {
+    return AArch64Abi::kNumFloatParmRegs;
+  }
+  uint32 GetIntRetRegsNum() override {
+    return AArch64Abi::kNumIntParmRegs;
+  }
+  uint32 GetFpRetRegsNum() override {
+    return AArch64Abi::kNumFloatParmRegs;
+  }
+  uint32 GetNormalUseOperandNum() override {
+    return AArch64Abi::kNormalUseOperandNum;
+  }
+  uint32 GetIntParamRegIdx(regno_t regNO) const override {
+    return static_cast<uint32>(regNO - R0);
+  }
+  uint32 GetFpParamRegIdx(regno_t regNO) const override {
+    return static_cast<uint32>(regNO - V0);
+  }
+  regno_t GetLastParamsIntReg() override {
+    return R7;
+  }
+  regno_t GetLastParamsFpReg() override {
+    return V7;
+  }
+  uint32 GetAllRegNum() override {
+    return kAllRegNum;
+  }
+  regno_t GetInvalidReg() override {
+    return kRinvalid;
+  }
+  bool IsVirtualRegister(const RegOperand &regOpnd) override {
+    return regOpnd.GetRegisterNumber() > kAllRegNum;
+  }
+  bool IsVirtualRegister(regno_t regno) override {
+    return regno > kAllRegNum;
+  }
+  regno_t GetReservedSpillReg() override {
+    return R16;
+  }
+  regno_t GetSecondReservedSpillReg() override {
+    return R17;
+  }
+  regno_t GetYieldPointReg() const override {
+    return RYP;
+  }
+  regno_t GetStackPointReg() const override {
+    return RSP;
+  }
+
+  void Init() override;
+  void Fini() override;
+  void SaveCalleeSavedReg(MapleSet<regno_t> savedRegs) override;
+  bool IsSpecialReg(regno_t regno) const override;
+  bool IsCalleeSavedReg(regno_t regno) const override;
+  bool IsYieldPointReg(regno_t regno) const override;
+  bool IsUnconcernedReg(regno_t regNO) const override;
+  bool IsUnconcernedReg(const RegOperand &regOpnd) const override;
+  bool IsFramePointReg(regno_t regNO) const override {
+    return (regNO == RFP);
+  }
+  bool IsReservedReg(regno_t regNO, bool doMultiPass) const override;
+  bool IsSpillRegInRA(regno_t regNO, bool has3RegOpnd) override;
+  RegOperand *GetOrCreatePhyRegOperand(regno_t regNO, uint32 size, RegType kind, uint32 flag) override;
+  Insn *BuildStrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) override;
+  Insn *BuildLdrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) override;
+  MemOperand *AdjustMemOperandIfOffsetOutOfRange(MemOperand *memOpnd, regno_t vrNum,
+      bool isDest, Insn &insn, regno_t regNum, bool &isOutOfRange) override;
+
+  regno_t GetIntSpillFillReg(size_t idx) const override {
+    static regno_t intRegs[kSpillMemOpndNum] = { R10, R11, R12, R13 };
+    ASSERT(idx < kSpillMemOpndNum, "index out of range");
+    return intRegs[idx];
+  }
+  regno_t GetFpSpillFillReg(size_t idx) const override {
+    static regno_t fpRegs[kSpillMemOpndNum] = { V16, V17, V18, V19 };
+    ASSERT(idx < kSpillMemOpndNum, "index out of range");
+    return fpRegs[idx];
+  }
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REG_INFO_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_regsaves.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_regsaves.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0be8767f9ad7a78acad231d614a70324d237e6b
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_regsaves.h
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64REGSAVESOPT_H
+#define MAPLEBE_INCLUDE_CG_AARCH64REGSAVESOPT_H
+
+#include "cg.h"
+#include "regsaves.h"
+#include "aarch64_cg.h"
+#include "aarch64_insn.h"
+#include "aarch64_operand.h"
+
+namespace maplebe {
+
+#define BBID uint32
+
+/* Saved callee-save reg info */
+class SavedRegInfo {
+ public:
+  bool insertAtLastMinusOne = false;
+  explicit SavedRegInfo(MapleAllocator &alloc)
+      : saveSet(alloc.Adapter()),
+        restoreEntrySet(alloc.Adapter()),
+        restoreExitSet(alloc.Adapter()) {}
+
+  bool ContainSaveReg(regno_t r) {
+    if (saveSet.find(r) != saveSet.end()) {
+      return true;
+    }
+    return false;
+  }
+
+  bool ContainEntryReg(regno_t r) {
+    if (restoreEntrySet.find(r) != restoreEntrySet.end()) {
+      return true;
+    }
+    return false;
+  }
+
+  bool ContainExitReg(regno_t r) {
+    if (restoreExitSet.find(r) != restoreExitSet.end()) {
+      return true;
+    }
+    return false;
+  }
+
+  void InsertSaveReg(regno_t r) {
+    (void)saveSet.insert(r);
+  }
+
+  void InsertEntryReg(regno_t r) {
+    (void)restoreEntrySet.insert(r);
+  }
+
+  void InsertExitReg(regno_t r) {
+    (void)restoreExitSet.insert(r);
+  }
+
+  MapleSet<regno_t> &GetSaveSet() {
+    return saveSet;
+  }
+
+  MapleSet<regno_t> &GetEntrySet() {
+    return restoreEntrySet;
+  }
+
+  MapleSet<regno_t> &GetExitSet() {
+    return restoreExitSet;
+  }
+
+  void RemoveSaveReg(regno_t r) {
+    (void)saveSet.erase(r);
+  }
+
+ private:
+  MapleSet<regno_t> saveSet;
+  MapleSet<regno_t> restoreEntrySet;
+  MapleSet<regno_t> restoreExitSet;
+};
+
+/* BBs info for saved callee-saved reg */
+class SavedBBInfo {
+ public:
+  explicit SavedBBInfo(MapleAllocator &alloc) : bbList (alloc.Adapter()) {}
+
+  MapleSet<BB*> &GetBBList() {
+    return bbList;
+  }
+
+  void InsertBB(BB *bb) {
+    (void)bbList.insert(bb);
+  }
+
+  void RemoveBB(BB *bb) {
+    (void)bbList.erase(bb);
+  }
+
+ private:
+  MapleSet<BB *> bbList;
+};
+
+class AArch64RegSavesOpt : public RegSavesOpt {
+ public:
+  AArch64RegSavesOpt(CGFunc &func, MemPool &pool, DomAnalysis &dom, PostDomAnalysis &pdom)
+      : RegSavesOpt(func, pool),
+        domInfo(&dom),
+        pDomInfo(&pdom),
+        bbSavedRegs(alloc.Adapter()),
+        regSavedBBs(alloc.Adapter()),
+        regOffset(alloc.Adapter()),
+        visited(alloc.Adapter()),
+        id2bb(alloc.Adapter()) {
+    bbSavedRegs.resize(func.NumBBs());
+    for (size_t i = 0; i < bbSavedRegs.size(); ++i) {
+      bbSavedRegs[i] = nullptr;
+    }
+    regSavedBBs.resize(sizeof(CalleeBitsType)<<3);
+    for (size_t i = 0; i < regSavedBBs.size(); ++i) {
+      regSavedBBs[i] = nullptr;
+    }
+  }
+  ~AArch64RegSavesOpt() override = default;
+
+  using CalleeBitsType = uint64 ;
+
+  void InitData();
+  void CollectLiveInfo(const BB &bb, const Operand &opnd, bool isDef, bool isUse);
+  void GenerateReturnBBDefUse(const BB &bb);
+  void ProcessCallInsnParam(BB &bb);
+  void ProcessAsmListOpnd(const BB &bb, const Operand &opnd, uint32 idx);
+  void ProcessListOpnd(const BB &bb, const Operand &opnd);
+  void ProcessMemOpnd(const BB &bb, Operand &opnd);
+  void ProcessCondOpnd(const BB &bb);
+  void ProcessOperands(const Insn &insn, const BB &bb);
+  void GenAccDefs();
+  void GenRegDefUse();
+  bool CheckForUseBeforeDefPath();
+  void PrintBBs() const;
+  int CheckCriteria(BB *bb, regno_t reg) const;
+  void CheckCriticalEdge(BB *bb, AArch64reg reg);
+  bool AlreadySavedInDominatorList(const BB *bb, regno_t reg) const;
+  BB* FindLoopDominator(BB *bb, regno_t reg, bool *done);
+  void CheckAndRemoveBlksFromCurSavedList(SavedBBInfo *sp, BB *bbDom, regno_t reg);
+  void DetermineCalleeSaveLocationsDoms();
+  void RevertToRestoreAtEpilog(AArch64reg reg);
+  void DetermineCalleeSaveLocationsPre();
+  void DetermineCalleeRestoreLocations();
+  int32 FindCalleeBase() const;
+  void SetupRegOffsets();
+  void InsertCalleeSaveCode();
+  void InsertCalleeRestoreCode();
+  void PrintSaveLocs(AArch64reg reg);
+  void Run() override;
+
+  DomAnalysis *GetDomInfo() const {
+    return domInfo;
+  }
+
+  PostDomAnalysis *GetPostDomInfo() const {
+    return pDomInfo;
+  }
+
+  Bfs *GetBfs() const {
+    return bfs;
+  }
+
+  CalleeBitsType *GetCalleeBitsDef() {
+    return calleeBitsDef;
+  }
+
+  CalleeBitsType *GetCalleeBitsUse() {
+    return calleeBitsUse;
+  }
+
+  CalleeBitsType *GetCalleeBitsAcc() {
+    return calleeBitsAcc;
+  }
+
+  CalleeBitsType GetBBCalleeBits(CalleeBitsType *data, BBID bid) const {
+    return data[bid];
+  }
+
+  void SetCalleeBit(CalleeBitsType *dest, BBID bidD, CalleeBitsType src) {
+    dest[bidD] = src;
+  }
+
+  void SetCalleeBit(CalleeBitsType *data, BBID bid, regno_t reg) {
+    CalleeBitsType mask = 1ULL << RegBitMap(reg);
+    if ((GetBBCalleeBits(data, bid) & mask) == 0) {
+      data[bid] = GetBBCalleeBits(data, bid) | mask;
+    }
+  }
+
+  void ResetCalleeBit(CalleeBitsType * data, BBID bid, regno_t reg) {
+    CalleeBitsType mask = 1ULL << RegBitMap(reg);
+    data[bid] = GetBBCalleeBits(data, bid) & ~mask;
+  }
+
+  bool IsCalleeBitSet(CalleeBitsType * data, BBID bid, regno_t reg) const {
+    CalleeBitsType mask = 1ULL << RegBitMap(reg);
+    return GetBBCalleeBits(data, bid) & mask;
+  }
+
+  /* AArch64 specific callee-save registers bit positions
+      0       9  10                33   -- position
+     R19 ..  R28 V8 .. V15 V16 .. V31   -- regs */
+  uint32 RegBitMap(regno_t reg) const {
+    uint32 r;
+    if (reg <= R28) {
+      r = (reg - R19);
+    } else {
+      r = ((R28 - R19) + 1) + (reg - V8);
+    }
+    return r;
+  }
+
+  regno_t ReverseRegBitMap(uint32 reg) const {
+    if (reg < 10) {
+      return static_cast<AArch64reg>(R19 + reg);
+    } else {
+      return static_cast<AArch64reg>((V8 + reg) - (R28 - R19 + 1));
+    }
+  }
+
+  SavedRegInfo *GetbbSavedRegsEntry(BBID bid) {
+    if (bbSavedRegs[bid] == nullptr) {
+      bbSavedRegs[bid] = memPool->New<SavedRegInfo>(alloc);
+    }
+    return bbSavedRegs[bid];
+  }
+
+  void SetId2bb(BB *bb) {
+    id2bb[bb->GetId()] = bb;
+  }
+
+  BB *GetId2bb(BBID bid) {
+    return id2bb[bid];
+  }
+
+ private:
+  DomAnalysis *domInfo;
+  PostDomAnalysis *pDomInfo;
+  Bfs *bfs = nullptr;
+  CalleeBitsType *calleeBitsDef = nullptr;
+  CalleeBitsType *calleeBitsUse = nullptr;
+  CalleeBitsType *calleeBitsAcc = nullptr;
+  MapleVector<SavedRegInfo *> bbSavedRegs; /* set of regs to be saved in a BB */
+  MapleVector<SavedBBInfo *> regSavedBBs;  /* set of BBs to be saved for a reg */
+  MapleMap<regno_t, uint32> regOffset;     /* save offset of each register */
+  MapleSet<BBID> visited;                  /* temp */
+  MapleMap<BBID, BB*> id2bb;               /* bbid to bb* mapping */
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64REGSAVESOPT_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_rematerialize.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_rematerialize.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f35c2b9bf2240c5d7399906e37e17f26c2b2d67
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_rematerialize.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REMATERIALIZE_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REMATERIALIZE_H
+
+#include "rematerialize.h"
+
+namespace maplebe {
+class AArch64Rematerializer : public Rematerializer {
+ public:
+  AArch64Rematerializer() = default;
+  virtual ~AArch64Rematerializer() = default;
+ private:
+  bool IsRematerializableForConstval(int64 val, uint32 bitLen) const override;
+  bool IsRematerializableForDread(int32 offset) const override;
+
+  std::vector<Insn*> RematerializeForConstval(CGFunc &cgFunc, RegOperand &regOp,
+      const LiveRange &lr) override;
+
+  std::vector<Insn*> RematerializeForAddrof(CGFunc &cgFunc, RegOperand &regOp,
+      int32 offset) override;
+
+  std::vector<Insn*> RematerializeForDread(CGFunc &cgFunc, RegOperand &regOp,
+      int32 offset, PrimType type) override;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REMATERIALIZE_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_schedule.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_schedule.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc22d8b88f2d34654abc1484d5402d8c75ac73b5
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_schedule.h
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_SCHEDULE_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_SCHEDULE_H
+
+#include "schedule.h"
+#include "aarch64_operand.h"
+
+namespace maplebe {
+enum RegisterType : uint8 {
+  kRegisterUndef,
+  kRegisterInt,
+  kRegisterFloat,
+  kRegisterCc,
+  kRegisterLast,
+};
+
+class ScheduleProcessInfo {
+ public:
+  explicit ScheduleProcessInfo(uint32 size) {
+    availableReadyList.reserve(size);
+    scheduledNodes.reserve(size);
+  }
+
+  virtual ~ScheduleProcessInfo() = default;
+
+  uint32 GetLastUpdateCycle() const {
+    return lastUpdateCycle;
+  }
+
+  void SetLastUpdateCycle(uint32 updateCycle) {
+    lastUpdateCycle = updateCycle;
+  }
+
+  uint32 GetCurrCycle() const {
+    return currCycle;
+  }
+
+  void IncCurrCycle() {
+    ++currCycle;
+  }
+
+  void DecAdvanceCycle() {
+    advanceCycle--;
+  }
+
+  uint32 GetAdvanceCycle() const {
+    return advanceCycle;
+  }
+
+  void SetAdvanceCycle(uint32 cycle) {
+    advanceCycle = cycle;
+  }
+
+  void ClearAvailableReadyList() {
+    availableReadyList.clear();
+  }
+
+  void PushElemIntoAvailableReadyList(DepNode *node) {
+    availableReadyList.emplace_back(node);
+  }
+
+  size_t SizeOfAvailableReadyList() const {
+    return availableReadyList.size();
+  }
+
+  bool AvailableReadyListIsEmpty() const {
+    return availableReadyList.empty();
+  }
+
+  void SetAvailableReadyList(const std::vector<DepNode*> &tempReadyList) {
+    availableReadyList = tempReadyList;
+  }
+
+  const std::vector<DepNode*> &GetAvailableReadyList() const {
+    return availableReadyList;
+  }
+
+  const std::vector<DepNode*> &GetAvailableReadyList() {
+    return availableReadyList;
+  }
+
+  void PushElemIntoScheduledNodes(DepNode *node) {
+    node->SetState(kScheduled);
+    node->SetSchedCycle(currCycle);
+    node->OccupyUnits();
+    scheduledNodes.emplace_back(node);
+  }
+
+  bool IsFirstSeparator() const {
+    return isFirstSeparator;
+  }
+
+  void ResetIsFirstSeparator() {
+    isFirstSeparator = false;
+  }
+
+  size_t SizeOfScheduledNodes() const {
+    return scheduledNodes.size();
+  }
+
+  const std::vector<DepNode*> &GetScheduledNodes() const {
+    return scheduledNodes;
+  }
+
+ private:
+  std::vector<DepNode*> availableReadyList;
+  std::vector<DepNode*> scheduledNodes;
+  uint32 lastUpdateCycle = 0;
+  uint32 currCycle = 0;
+  uint32 advanceCycle = 0;
+  bool isFirstSeparator = true;
+};
+
+
+class AArch64ScheduleProcessInfo : public ScheduleProcessInfo {
+ public:
+  explicit AArch64ScheduleProcessInfo(uint32 size) : ScheduleProcessInfo(size) {}
+  ~AArch64ScheduleProcessInfo() override  = default;
+
+  /* recover register type which is not recorded in live analysis */
+  static RegType GetRegisterType(CGFunc &f, regno_t regNO);
+  void VaryLiveRegSet(CGFunc &f, regno_t regNO, bool isInc);
+  void VaryFreeRegSet(CGFunc &f, std::set<regno_t> regNOs, DepNode &node);
+
+  uint32 GetFreeIntRegs(DepNode &node) {
+    return (freeIntRegNodeSet.count(&node)) > 0 ? freeIntRegNodeSet.find(&node)->second : 0;
+  }
+  void IncFreeIntRegNode(DepNode &node) {
+    if (freeIntRegNodeSet.count(&node) == 0) {
+      freeIntRegNodeSet.emplace(std::pair<DepNode*, uint32>(&node, 1));
+    } else {
+      freeIntRegNodeSet.find(&node)->second++;
+    }
+  }
+  const std::map<DepNode*, uint32> &GetFreeIntRegNodeSet() const {
+    return freeIntRegNodeSet;
+  }
+  void IncFreeFpRegNode(DepNode &node) {
+    if (freeFpRegNodeSet.count(&node) == 0) {
+      freeFpRegNodeSet.emplace(std::pair<DepNode*, uint32>(&node, 1));
+    } else {
+      freeFpRegNodeSet.find(&node)->second++;
+    }
+  }
+  uint32 GetFreeFpRegs(DepNode &node) {
+    return (freeFpRegNodeSet.count(&node)) > 0 ? freeFpRegNodeSet.find(&node)->second : 0;
+  }
+  const std::map<DepNode*, uint32> &GetFreeFpRegNodeSet() const {
+    return freeFpRegNodeSet;
+  }
+
+  void ClearALLFreeRegNodeSet() {
+    freeIntRegNodeSet.clear();
+    freeFpRegNodeSet.clear();
+  }
+
+  size_t FindIntLiveReg(regno_t reg) const {
+    return intLiveRegSet.count(reg);
+  }
+  void IncIntLiveRegSet(regno_t reg) {
+    intLiveRegSet.emplace(reg);
+  }
+  void DecIntLiveRegSet(regno_t reg) {
+    intLiveRegSet.erase(reg);
+  }
+  size_t FindFpLiveReg(regno_t reg) const {
+    return fpLiveRegSet.count(reg);
+  }
+  void IncFpLiveRegSet(regno_t reg) {
+    fpLiveRegSet.emplace(reg);
+  }
+  void DecFpLiveRegSet(regno_t reg) {
+    fpLiveRegSet.erase(reg);
+  }
+
+  size_t SizeOfIntLiveRegSet() const {
+    return intLiveRegSet.size();
+  }
+
+  size_t SizeOfCalleeSaveLiveRegister(bool isInt) {
+    size_t num = 0;
+    if (isInt) {
+      for (auto regNO : intLiveRegSet) {
+        if (regNO > static_cast<regno_t>(R19)) {
+          num++;
+        }
+      }
+    } else {
+      for (auto regNO : fpLiveRegSet) {
+        if (regNO > static_cast<regno_t>(V16)) {
+          num++;
+        }
+      }
+    }
+    return num;
+  }
+
+  size_t SizeOfFpLiveRegSet() const {
+    return fpLiveRegSet.size();
+  }
+ private:
+  std::set<regno_t> intLiveRegSet;
+  std::set<regno_t> fpLiveRegSet;
+  std::map<DepNode*, uint32> freeIntRegNodeSet;
+  std::map<DepNode*, uint32> freeFpRegNodeSet;
+};
+
+class AArch64Schedule : public Schedule {
+ public:
+  AArch64Schedule(CGFunc &func, MemPool &memPool, LiveAnalysis &live, const std::string &phaseName)
+      : Schedule(func, memPool, live, phaseName) {
+    intCalleeSaveThreshold = func.UseFP() ? intCalleeSaveThresholdBase : intCalleeSaveThresholdEnhance;
+  }
+  ~AArch64Schedule() override = default;
+ protected:
+  void DumpDepGraph(const MapleVector<DepNode*> &nodes) const;
+  void DumpScheduleResult(const MapleVector<DepNode*> &nodes, SimulateType type) const;
+  void GenerateDot(const BB &bb, const MapleVector<DepNode*> &nodes) const;
+  void EraseNodeFromNodeList(const DepNode &target, MapleVector<DepNode*> &nodeList) override;
+  void FindAndCombineMemoryAccessPair(const std::vector<DepNode*> &memList) override;
+  void RegPressureScheduling(BB &bb, MapleVector<DepNode*> &nodes) override;
+
+ private:
+  enum CSRResult : uint8 {
+    kNode1,
+    kNode2,
+    kDoCSP  /* can do csp further */
+  };
+  void Init() override;
+  void MemoryAccessPairOpt() override;
+  void ClinitPairOpt() override;
+  uint32 DoSchedule() override;
+  uint32 DoBruteForceSchedule() override;
+  uint32 SimulateOnly() override;
+  void UpdateBruteForceSchedCycle() override;
+  void IterateBruteForce(DepNode &targetNode, MapleVector<DepNode*> &readyList, uint32 currCycle,
+                         MapleVector<DepNode*> &scheduledNodes, uint32 &maxCycleCount,
+                         MapleVector<DepNode*> &optimizedScheduledNodes) override;
+  bool CanCombine(const Insn &insn) const override;
+  void ListScheduling(bool beforeRA) override;
+  void BruteForceScheduling(const BB &bb);
+  void SimulateScheduling(const BB &bb);
+  void FinalizeScheduling(BB &bb, const DataDepBase &dataDepBase) override;
+  uint32 ComputeEstart(uint32 cycle) override;
+  void ComputeLstart(uint32 maxEstart) override;
+  void UpdateELStartsOnCycle(uint32 cycle) override;
+  void RandomTest() override;
+  void EraseNodeFromReadyList(const DepNode &target) override;
+  uint32 GetNextSepIndex() const override;
+  void CountUnitKind(const DepNode &depNode, uint32 array[], const uint32 arraySize) const override;
+  static bool IfUseUnitKind(const DepNode &depNode, uint32 index);
+  void UpdateReadyList(DepNode &targetNode, MapleVector<DepNode*> &readyList, bool updateEStart) override;
+  void UpdateScheduleProcessInfo(AArch64ScheduleProcessInfo &info) const;
+  void UpdateAdvanceCycle(AArch64ScheduleProcessInfo &scheduleInfo, const DepNode &targetNode) const;
+  bool CheckSchedulable(AArch64ScheduleProcessInfo &info) const;
+  void SelectNode(AArch64ScheduleProcessInfo &scheduleInfo);
+  static void DumpDebugInfo(const ScheduleProcessInfo &scheduleInfo);
+  bool CompareDepNode(DepNode &node1, DepNode &node2, AArch64ScheduleProcessInfo &scheduleInfo) const;
+  void CalculateMaxUnitKindCount(ScheduleProcessInfo &scheduleInfo) const;
+  void UpdateReleaseRegInfo(AArch64ScheduleProcessInfo &scheduleInfo);
+  std::set<regno_t> CanFreeRegister(const DepNode &node) const;
+  void UpdateLiveRegSet(AArch64ScheduleProcessInfo &scheduleInfo, const DepNode& node);
+  void InitLiveRegSet(AArch64ScheduleProcessInfo &scheduleInfo);
+  int CalSeriesCycles(const MapleVector<DepNode*> &nodes) const;
+  CSRResult DoCSR(DepNode &node1, DepNode &node2, AArch64ScheduleProcessInfo &scheduleInfo) const;
+  AArch64Schedule::CSRResult ScheduleCrossCall(const DepNode &node1, const DepNode &node2) const;
+  int intCalleeSaveThreshold = 0;
+
+  static uint32 maxUnitIndex;
+  static int intRegPressureThreshold;
+  static int fpRegPressureThreshold;
+  static int intCalleeSaveThresholdBase;
+  static int intCalleeSaveThresholdEnhance;
+  static int fpCalleeSaveThreshold;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_SCHEDULE_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_ssa.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ssa.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f04d94d96d18d446ead6e434c7b9acac3979358
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ssa.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_AARCH64_SSA_H
+#define MAPLEBE_CG_INCLUDE_AARCH64_SSA_H
+
+#include "cg_ssa.h"
+#include "aarch64_insn.h"
+
+namespace maplebe {
+class AArch64CGSSAInfo : public CGSSAInfo {
+ public:
+  AArch64CGSSAInfo(CGFunc &f, DomAnalysis &da, MemPool &mp, MemPool &tmp) : CGSSAInfo(f, da, mp, tmp) {}
+  ~AArch64CGSSAInfo() override = default;
+  void DumpInsnInSSAForm(const Insn &insn) const override;
+  RegOperand *GetRenamedOperand(RegOperand &vRegOpnd, bool isDef, Insn &curInsn, uint32 idx) override;
+  MemOperand *CreateMemOperand(MemOperand &memOpnd, bool isOnSSA) const; /* Second input parameter:false = on cgfunc */
+  void ReplaceInsn(Insn &oriInsn, Insn &newInsn) override;
+  void ReplaceAllUse(VRegVersion *toBeReplaced, VRegVersion *newVersion) override;
+  void CreateNewInsnSSAInfo(Insn &newInsn) override;
+  void CheckAsmDUbinding(Insn &insn, const VRegVersion *toBeReplaced, VRegVersion *newVersion);
+
+ private:
+  void RenameInsn(Insn &insn) override;
+  VRegVersion *RenamedOperandSpecialCase(RegOperand &vRegOpnd, Insn &curInsn, uint32 idx);
+  RegOperand *CreateSSAOperand(RegOperand &virtualOpnd) override;
+};
+
+class A64SSAOperandRenameVisitor : public SSAOperandVisitor {
+ public:
+  A64SSAOperandRenameVisitor(AArch64CGSSAInfo &cssaInfo, Insn &cInsn, const OpndDesc &cProp, uint32 idx)
+      : SSAOperandVisitor(cInsn, cProp, idx), ssaInfo(&cssaInfo) {}
+  ~A64SSAOperandRenameVisitor() override = default;
+  void Visit(RegOperand *v) final;
+  void Visit(ListOperand *v) final;
+  void Visit(MemOperand *v) final;
+
+ private:
+  AArch64CGSSAInfo *ssaInfo;
+};
+
+class A64OpndSSAUpdateVsitor : public SSAOperandVisitor,
+                               public OperandVisitor<PhiOperand> {
+ public:
+  explicit A64OpndSSAUpdateVsitor(AArch64CGSSAInfo &cssaInfo) : ssaInfo(&cssaInfo) {}
+  ~A64OpndSSAUpdateVsitor() override = default;
+  void MarkIncrease() {
+    isDecrease = false;
+  };
+  void MarkDecrease() {
+    isDecrease = true;
+  };
+  bool HasDeleteDef() const {
+    return !deletedDef.empty();
+  }
+  void Visit(RegOperand *v) final;
+  void Visit(ListOperand *v) final;
+  void Visit(MemOperand *v) final;
+  void Visit(PhiOperand *v) final;
+
+  bool IsPhi() const {
+    return isPhi;
+  }
+
+  void SetPhi(bool flag) {
+    isPhi = flag;
+  }
+
+ private:
+  void UpdateRegUse(uint32 ssaIdx);
+  void UpdateRegDef(uint32 ssaIdx);
+  AArch64CGSSAInfo *ssaInfo;
+  bool isDecrease = false;
+  std::set<regno_t> deletedDef;
+  bool isPhi = false;
+};
+
+class A64SSAOperandDumpVisitor : public SSAOperandDumpVisitor {
+ public:
+  explicit A64SSAOperandDumpVisitor(const MapleUnorderedMap<regno_t, VRegVersion*> &allssa)
+      : SSAOperandDumpVisitor(allssa) {}
+  ~A64SSAOperandDumpVisitor() override = default;
+  void Visit(RegOperand *v) final;
+  void Visit(ListOperand *v) final;
+  void Visit(MemOperand *v) final;
+  void Visit(PhiOperand *v) final;
+};
+}
+
+#endif // MAPLEBE_CG_INCLUDE_AARCH64_SSA_H
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_strldr.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_strldr.h
new file mode 100644
index 0000000000000000000000000000000000000000..f826c555c05cfd474ec084cbf0e57d0047edc4e2
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_strldr.h
@@ -0,0 +1,81 @@
+ /*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_STRLDR_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_STRLDR_H
+
+#include "strldr.h"
+#include "aarch64_reaching.h"
+#include "aarch64_operand.h"
+
+namespace maplebe {
+using namespace maple;
+enum MemPropMode : uint8 {
+  kUndef,
+  kPropBase,
+  kPropOffset,
+  kPropSignedExtend,
+  kPropUnsignedExtend,
+  kPropShift
+};
+
+class AArch64StoreLoadOpt : public StoreLoadOpt {
+ public:
+  AArch64StoreLoadOpt(CGFunc &func, MemPool &memPool)
+      : StoreLoadOpt(func, memPool), localAlloc(&memPool), str2MovMap(localAlloc.Adapter()) {}
+  ~AArch64StoreLoadOpt() override = default;
+  void Run() final;
+  void DoStoreLoadOpt();
+  void DoLoadZeroToMoveTransfer(const Insn &strInsn, short strSrcIdx,
+                                const InsnSet &memUseInsnSet) const;
+  void DoLoadToMoveTransfer(Insn &strInsn, short strSrcIdx,
+                            short memSeq, const InsnSet &memUseInsnSet);
+  bool CheckStoreOpCode(MOperator opCode) const;
+  static bool CheckNewAmount(const Insn &insn, uint32 newAmount);
+
+ private:
+  void StrLdrIndexModeOpt(Insn &currInsn);
+  bool CheckReplaceReg(Insn &defInsn, Insn &currInsn, InsnSet &replaceRegDefSet, regno_t replaceRegNo);
+  bool CheckDefInsn(Insn &defInsn, Insn &currInsn);
+  bool CheckNewMemOffset(const Insn &insn, MemOperand *newMemOpnd, uint32 opndIdx);
+  MemOperand *HandleArithImmDef(RegOperand &replace, Operand *oldOffset, int64 defVal);
+  MemOperand *SelectReplaceMem(Insn &defInsn, Insn &curInsn, RegOperand &base, Operand *offset);
+  MemOperand *SelectReplaceExt(const Insn &defInsn, RegOperand &base, bool isSigned);
+  bool CanDoMemProp(const Insn *insn);
+  bool CanDoIndexOpt(const MemOperand &currMemOpnd);
+  void MemPropInit();
+  void SelectPropMode(const MemOperand &currMemOpnd);
+  int64 GetOffsetForNewIndex(Insn &defInsn, Insn &insn, regno_t baseRegNO, uint32 memOpndSize) const;
+  MemOperand *SelectIndexOptMode(Insn &insn, const MemOperand &curMemOpnd);
+  bool ReplaceMemOpnd(Insn &insn, regno_t regNo, RegOperand &base, Operand *offset);
+  void MemProp(Insn &insn);
+  void ProcessStrPair(Insn &insn);
+  void ProcessStr(Insn &insn);
+  void GenerateMoveLiveInsn(RegOperand &resRegOpnd, RegOperand &srcRegOpnd,
+                            Insn &ldrInsn, Insn &strInsn, short memSeq);
+  void GenerateMoveDeadInsn(RegOperand &resRegOpnd, RegOperand &srcRegOpnd,
+                            Insn &ldrInsn, Insn &strInsn, short memSeq);
+  bool HasMemBarrier(const Insn &ldrInsn, const Insn &strInsn) const;
+  bool IsAdjacentBB(Insn &defInsn, Insn &curInsn) const;
+  MapleAllocator localAlloc;
+  /* the max number of mov insn to optimize. */
+  static constexpr uint8 kMaxMovNum = 2;
+  MapleMap<Insn*, Insn*[kMaxMovNum]> str2MovMap;
+  MemPropMode propMode = kUndef;
+  uint32 amount = 0;
+  bool removeDefInsn = false;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_STRLDR_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_tailcall.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_tailcall.h
new file mode 100644
index 0000000000000000000000000000000000000000..9eba2c0e42c64c8116672e41c9a4013d1b4c7a24
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_tailcall.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64TAILCALL_H
+#define MAPLEBE_INCLUDE_CG_AARCH64TAILCALL_H
+
+#include "cg.h"
+#include "tailcall.h"
+#include "aarch64_insn.h"
+#include "aarch64_operand.h"
+
+namespace maplebe {
+class AArch64TailCallOpt : public TailCallOpt {
+ public:
+  AArch64TailCallOpt(MemPool &pool, CGFunc &func) :
+      TailCallOpt(pool, func) {}
+  ~AArch64TailCallOpt() override = default;
+  bool IsFuncNeedFrame(Insn &callInsn) const override;
+  bool InsnIsCallCand(Insn &insn) const override;
+  bool InsnIsLoadPair(Insn &insn) const override;
+  bool InsnIsMove(Insn &insn) const override;
+  bool InsnIsIndirectCall(Insn &insn) const override;
+  bool InsnIsCall(Insn &insn) const override;
+  bool InsnIsUncondJump(Insn &insn) const override;
+  bool InsnIsAddWithRsp(Insn &insn) const override;
+  bool OpndIsStackRelatedReg(RegOperand &opnd) const override;
+  bool OpndIsR0Reg(RegOperand &opnd) const override;
+  bool OpndIsCalleeSaveReg(RegOperand &opnd) const override;
+  bool IsAddOrSubOp(MOperator mOp) const override;
+  void ReplaceInsnMopWithTailCall(Insn &insn) override;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64TAILCALL_H */
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_utils.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..3379b9be1d3ac2a734185c7d632bfaccdf8eb80d
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_utils.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_UTILS_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_UTILS_H
+
+#include "aarch64_cg.h"
+#include "aarch64_operand.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+
+/**
+ * Get or create new memory operand for load instruction loadIns for which
+ * machine opcode will be replaced with newLoadMop.
+ *
+ * @param loadIns load instruction
+ * @param newLoadMop new opcode for load instruction
+ * @return memory operand for new load machine opcode
+ *         or nullptr if memory operand can't be obtained
+ */
+MemOperand *GetOrCreateMemOperandForNewMOP(CGFunc &cgFunc,
+    const Insn &loadIns, MOperator newLoadMop);
+} // namespace maplebe
+
+#endif // MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_UTILS_H
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_validbit_opt.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_validbit_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e5350314c6e38c5ac4bf460a5e8614e746dd1bf
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_validbit_opt.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_VALIDBIT_OPT_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_VALIDBIT_OPT_H
+
+#include "cg_validbit_opt.h"
+#include "operand.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+class AArch64ValidBitOpt : public ValidBitOpt {
+ public:
+  AArch64ValidBitOpt(CGFunc &f, CGSSAInfo &info) : ValidBitOpt(f, info) {}
+  ~AArch64ValidBitOpt() override = default;
+
+  void DoOpt(BB &bb, Insn &insn) override;
+  void SetValidBits(Insn &insn) override;
+  bool SetPhiValidBits(Insn &insn) override;
+};
+
+/*
+ * Example 1)
+ * def w9                          def w9
+ * ...                             ...
+ * and w4, w9, #255       ===>     mov w4, w9
+ *
+ * Example 2)
+ * and w6[16], w0[16], #FF00[16]              mov  w6, w0
+ * asr w6,     w6[16], #8[4]        ===>      asr  w6, w6
+ */
+class AndValidBitPattern : public ValidBitPattern {
+ public:
+  AndValidBitPattern(CGFunc &cgFunc, CGSSAInfo &info) : ValidBitPattern(cgFunc, info) {}
+  ~AndValidBitPattern() override {
+    desReg = nullptr;
+    srcReg = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "AndValidBitPattern";
+  }
+
+ private:
+  bool CheckImmValidBit(int64 andImm, uint32 andImmVB, int64 shiftImm) const;
+  MOperator newMop = MOP_undef;
+  RegOperand *desReg = nullptr;
+  RegOperand *srcReg = nullptr;
+};
+
+/*
+ * Example 1)
+ * uxth  w1[16], w2[16]  /  uxtb  w1[8], w2[8]
+ * ===>
+ * mov   w1, w2
+ *
+ * Example 2)
+ * ubfx  w1, w2[16], #0, #16  /  sbfx  w1, w2[16], #0, #16
+ * ===>
+ * mov   w1, w2
+ */
+class ExtValidBitPattern : public ValidBitPattern {
+ public:
+  ExtValidBitPattern(CGFunc &cgFunc, CGSSAInfo &info) : ValidBitPattern(cgFunc, info) {}
+  ~ExtValidBitPattern() override {
+    newDstOpnd = nullptr;
+    newSrcOpnd = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "ExtValidBitPattern";
+  }
+
+ private:
+  RegOperand *newDstOpnd = nullptr;
+  RegOperand *newSrcOpnd = nullptr;
+  MOperator newMop = MOP_undef;
+};
+
+/*
+ *  cmp  w0, #0
+ *  cset w1, NE --> mov w1, w0
+ *
+ *  cmp  w0, #0
+ *  cset w1, EQ --> eor w1, w0, 1
+ *
+ *  cmp  w0, #1
+ *  cset w1, NE --> eor w1, w0, 1
+ *
+ *  cmp  w0, #1
+ *  cset w1, EQ --> mov w1, w0
+ *
+ *  cmp w0,  #0
+ *  cset w0, NE -->null
+ *
+ *  cmp w0, #1
+ *  cset w0, EQ -->null
+ *
+ *  condition:
+ *    1. the first operand of cmp instruction must has only one valid bit
+ *    2. the second operand of cmp instruction must be 0 or 1
+ *    3. flag register of cmp isntruction must not be used later
+ */
+class CmpCsetVBPattern : public ValidBitPattern {
+ public:
+  CmpCsetVBPattern(CGFunc &cgFunc, CGSSAInfo &info) : ValidBitPattern(cgFunc, info) {}
+  ~CmpCsetVBPattern() override {
+    cmpInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &csetInsn) override;
+  bool CheckCondition(Insn &csetInsn) override;
+  std::string GetPatternName() override {
+    return "CmpCsetPattern";
+  };
+
+ private:
+  bool IsContinuousCmpCset(const Insn &curInsn) const;
+  bool OpndDefByOneValidBit(const Insn &defInsn) const;
+  Insn *cmpInsn = nullptr;
+  int64 cmpConstVal = -1;
+};
+
+/*
+ * cmp w0[16], #32768
+ * bge label           ===>   tbnz w0, #15, label
+ *
+ * bge / blt
+ */
+class CmpBranchesPattern : public ValidBitPattern {
+ public:
+  CmpBranchesPattern(CGFunc &cgFunc, CGSSAInfo &info) : ValidBitPattern(cgFunc, info) {}
+  ~CmpBranchesPattern() override {
+    prevCmpInsn = nullptr;
+  }
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "CmpBranchesPattern";
+  };
+
+ private:
+  void SelectNewMop(MOperator mop);
+  Insn *prevCmpInsn = nullptr;
+  int64 newImmVal = -1;
+  MOperator newMop = MOP_undef;
+  bool is64Bit = false;
+};
+} /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_VALIDBIT_OPT_H */
+
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_yieldpoint.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_yieldpoint.h
new file mode 100644
index 0000000000000000000000000000000000000000..549c50a80c8abcb1717c414685a41111c4793f1f
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_yieldpoint.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_YIELDPOINT_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_YIELDPOINT_H
+
+#include "yieldpoint.h"
+
+namespace maplebe {
+using namespace maple;
+
+class AArch64YieldPointInsertion : public YieldPointInsertion {
+ public:
+  explicit AArch64YieldPointInsertion(CGFunc &func) : YieldPointInsertion(func) {}
+
+  ~AArch64YieldPointInsertion() override = default;
+
+  void Run() override;
+
+ private:
+  void InsertYieldPoint() const;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_YIELDPOINT_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/aarch64/mpl_atomic.h b/src/mapleall/maple_be/include/cg/aarch64/mpl_atomic.h
new file mode 100644
index 0000000000000000000000000000000000000000..e034f0e9f729321e8651106f0c3a7fec4fe96e51
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/aarch64/mpl_atomic.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_AARCH64_MPL_ATOMIC_H
+#define MAPLEBE_INCLUDE_CG_AARCH64_MPL_ATOMIC_H
+
+#include "types_def.h"
+
+namespace maple {
+enum class MemOrd : uint32 {
+  kNotAtomic = 0,
+#define ATTR(STR) STR,
+#include "memory_order_attrs.def"
+#undef ATTR
+};
+
+MemOrd MemOrdFromU32(uint32 val);
+
+bool MemOrdIsAcquire(MemOrd ord);
+
+bool MemOrdIsRelease(MemOrd ord);
+}  /* namespace maple */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_MPL_ATOMIC_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/abi.h b/src/mapleall/maple_be/include/cg/abi.h
new file mode 100644
index 0000000000000000000000000000000000000000..57c4ad728c7d19b09d0c3be87db131df3fb0fc3d
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/abi.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_ABI_H
+#define MAPLEBE_INCLUDE_CG_ABI_H
+
+#include <cstdint>
+#include "types_def.h"
+#include "operand.h"
+
+namespace maplebe {
+enum ArgumentClass : uint8 {
+  kNoClass,
+  kIntegerClass,
+  kFloatClass,
+  kPointerClass,
+  kVectorClass,
+  kMemoryClass,
+  kShortVectorClass,
+  kCompositeTypeHFAClass,  /* Homegeneous Floating-point Aggregates for AArch64 */
+  kCompositeTypeHVAClass,  /* Homegeneous Short-Vector Aggregates for AArch64 */
+};
+
+using regno_t = uint32_t;
+
+} /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_ABI_H */
diff --git a/src/mapleall/maple_be/include/cg/abstract_mmir.def b/src/mapleall/maple_be/include/cg/abstract_mmir.def
new file mode 100644
index 0000000000000000000000000000000000000000..c2d595600a3471bde05c1df9a8928994e121d767
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/abstract_mmir.def
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+ /* Abstract Maple Machine IR */
+ /* {mop, opnds, prop, latency, name, format, length} */
+ DEFINE_MOP(MOP_undef, {}, ISABSTRACT,0,"","",0)
+
+ /* conversion between all types and registers */
+ DEFINE_MOP(MOP_copy_ri_8, {&OpndDesc::Reg8ID,&OpndDesc::Imm32},ISABSTRACT|ISMOVE,0,"copy_ri_8","",1)
+ DEFINE_MOP(MOP_copy_rr_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS},ISABSTRACT|ISMOVE,0,"copy_rr_8","",1)
+ DEFINE_MOP(MOP_copy_ri_16, {&OpndDesc::Reg16ID,&OpndDesc::Imm32},ISABSTRACT|ISMOVE,0,"copy_ri_16","",1)
+ DEFINE_MOP(MOP_copy_rr_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS},ISABSTRACT|ISMOVE,0,"copy_rr_16","",1)
+ DEFINE_MOP(MOP_copy_ri_32, {&OpndDesc::Reg32ID,&OpndDesc::Imm32},ISABSTRACT|ISMOVE,0,"copy_ri_32","",1)
+ DEFINE_MOP(MOP_copy_rr_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},ISABSTRACT|ISMOVE,0,"copy_rr_32","",1)
+ DEFINE_MOP(MOP_copy_ri_64, {&OpndDesc::Reg64ID,&OpndDesc::Imm64},ISABSTRACT|ISMOVE,0,"copy_ri_64","",1)
+ DEFINE_MOP(MOP_copy_rr_64, {&OpndDesc::Reg64ID, &OpndDesc::Reg64IS},ISABSTRACT|ISMOVE,0,"copy_rr_64","",1)
+
+ DEFINE_MOP(MOP_copy_fi_8, {&OpndDesc::Reg8FD,&OpndDesc::Imm32},ISABSTRACT|ISMOVE,0,"copy_fi_8","",1)
+ DEFINE_MOP(MOP_copy_ff_8, {&OpndDesc::Reg8FD,&OpndDesc::Reg8FS},ISABSTRACT|ISMOVE,0,"copy_ff_8","",1)
+ DEFINE_MOP(MOP_copy_fi_16, {&OpndDesc::Reg16FD,&OpndDesc::Imm32},ISABSTRACT|ISMOVE,0,"copy_fi_16","",1)
+ DEFINE_MOP(MOP_copy_ff_16, {&OpndDesc::Reg16FD,&OpndDesc::Reg16FS},ISABSTRACT|ISMOVE,0,"copy_ff_16","",1)
+ DEFINE_MOP(MOP_copy_fi_32, {&OpndDesc::Reg32FD,&OpndDesc::Imm32},ISABSTRACT|ISMOVE,0,"copy_fi_32","",1)
+ DEFINE_MOP(MOP_copy_ff_32, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS},ISABSTRACT|ISMOVE,0,"copy_ff_32","",1)
+ DEFINE_MOP(MOP_copy_fi_64, {&OpndDesc::Reg64FD,&OpndDesc::Imm64},ISABSTRACT|ISMOVE,0,"copy_fi_64","",1)
+ DEFINE_MOP(MOP_copy_ff_64, {&OpndDesc::Reg64FD, &OpndDesc::Reg64FS},ISABSTRACT|ISMOVE,0,"copy_ff_64","",1)
+
+ /* register extend */
+ DEFINE_MOP(MOP_zext_rr_16_8,  {&OpndDesc::Reg16ID,&OpndDesc::Reg8IS},ISABSTRACT|ISCONVERSION,0,"zext_r16_r8","",1)
+ DEFINE_MOP(MOP_sext_rr_16_8,  {&OpndDesc::Reg16ID,&OpndDesc::Reg8IS},ISABSTRACT|ISCONVERSION,0,"sext_r16_r8","",1)
+ DEFINE_MOP(MOP_zext_rr_32_8,  {&OpndDesc::Reg32ID,&OpndDesc::Reg8IS},ISABSTRACT|ISCONVERSION,0,"zext_r32_r8","",1)
+ DEFINE_MOP(MOP_sext_rr_32_8,  {&OpndDesc::Reg32ID,&OpndDesc::Reg8IS},ISABSTRACT|ISCONVERSION,0,"sext_r32_r8","",1)
+ DEFINE_MOP(MOP_zext_rr_32_16,  {&OpndDesc::Reg32ID,&OpndDesc::Reg16IS},ISABSTRACT|ISCONVERSION,0,"zext_r32_r16","",1)
+ DEFINE_MOP(MOP_sext_rr_32_16,  {&OpndDesc::Reg32ID,&OpndDesc::Reg16IS},ISABSTRACT|ISCONVERSION,0,"sext_r32_r16","",1)
+
+ DEFINE_MOP(MOP_zext_rr_64_8,  {&OpndDesc::Reg64ID,&OpndDesc::Reg8IS},ISABSTRACT|ISCONVERSION,0,"zext_r64_r8","",1)
+ DEFINE_MOP(MOP_sext_rr_64_8,  {&OpndDesc::Reg64ID,&OpndDesc::Reg8IS},ISABSTRACT|ISCONVERSION,0,"sext_r64_r8","",1)
+ DEFINE_MOP(MOP_zext_rr_64_16,  {&OpndDesc::Reg64ID,&OpndDesc::Reg16IS},ISABSTRACT|ISCONVERSION,0,"zext_r64_r16","",1)
+ DEFINE_MOP(MOP_sext_rr_64_16,  {&OpndDesc::Reg64ID,&OpndDesc::Reg16IS},ISABSTRACT|ISCONVERSION,0,"sext_r64_r16","",1)
+ DEFINE_MOP(MOP_zext_rr_64_32,  {&OpndDesc::Reg64ID,&OpndDesc::Reg32IS},ISABSTRACT|ISCONVERSION,0,"zext_r64_r32","",1)
+ DEFINE_MOP(MOP_sext_rr_64_32,  {&OpndDesc::Reg64ID,&OpndDesc::Reg32IS},ISABSTRACT|ISCONVERSION,0,"sext_r64_r32","",1)
+
+/* int2float conversion */
+ DEFINE_MOP(MOP_cvt_fr_u32, {&OpndDesc::Reg32FD,&OpndDesc::Reg32IS},ISABSTRACT|ISCONVERSION,0,"cvt_fr_u32","",1)
+ DEFINE_MOP(MOP_cvt_fr_u64, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS},ISABSTRACT|ISCONVERSION,0,"cvt_fr_u64","",1)
+ DEFINE_MOP(MOP_cvt_fr_i32, {&OpndDesc::Reg32FD,&OpndDesc::Reg32IS},ISABSTRACT|ISCONVERSION,0,"cvt_fr_i32","",1)
+ DEFINE_MOP(MOP_cvt_fr_i64, {&OpndDesc::Reg64FD,&OpndDesc::Reg64IS},ISABSTRACT|ISCONVERSION,0,"cvt_fr_i64","",1)
+
+/* float2int conversion */
+ DEFINE_MOP(MOP_cvt_rf_u32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32FS},ISABSTRACT|ISCONVERSION,0,"cvt_rf_u32","",1)
+ DEFINE_MOP(MOP_cvt_rf_u64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64FS},ISABSTRACT|ISCONVERSION,0,"cvt_rf_u64","",1)
+ DEFINE_MOP(MOP_cvt_rf_i32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32FS},ISABSTRACT|ISCONVERSION,0,"cvt_rf_i32","",1)
+ DEFINE_MOP(MOP_cvt_rf_i64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64FS},ISABSTRACT|ISCONVERSION,0,"cvt_rf_i64","",1)
+
+ /* float conversion */
+ DEFINE_MOP(MOP_cvt_ff_64_32, {&OpndDesc::Reg64FD,&OpndDesc::Reg32FS},ISABSTRACT|ISCONVERSION,0,"cvt_ff_64_32","",1)
+ DEFINE_MOP(MOP_cvt_ff_32_64, {&OpndDesc::Reg32FD,&OpndDesc::Reg64IS},ISABSTRACT|ISCONVERSION,0,"cvt_ff_32_64","",1)
+
+ /* Support transformation between memory and registers */
+ DEFINE_MOP(MOP_str_8, {&OpndDesc::Reg8IS,&OpndDesc::Mem8D},ISABSTRACT|ISSTORE,0,"str_8","",1)
+ DEFINE_MOP(MOP_str_16, {&OpndDesc::Reg16IS,&OpndDesc::Mem16D},ISABSTRACT|ISSTORE,0,"str_16","",1)
+ DEFINE_MOP(MOP_str_32, {&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISABSTRACT|ISSTORE,0,"str_32","",1)
+ DEFINE_MOP(MOP_str_64, {&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISABSTRACT|ISSTORE,0,"str_64","",1)
+ DEFINE_MOP(MOP_load_8, {&OpndDesc::Reg8ID,&OpndDesc::Mem8S},ISABSTRACT|ISLOAD,0,"load_8","",1)
+ DEFINE_MOP(MOP_load_16, {&OpndDesc::Reg16ID,&OpndDesc::Mem16S},ISABSTRACT|ISLOAD,0,"load_16","",1)
+ DEFINE_MOP(MOP_load_32, {&OpndDesc::Reg32ID,&OpndDesc::Mem32S},ISABSTRACT|ISLOAD,0,"load_32","",1)
+ DEFINE_MOP(MOP_load_64, {&OpndDesc::Reg64ID,&OpndDesc::Mem64S},ISABSTRACT|ISLOAD,0,"load_64","",1)
+ DEFINE_MOP(MOP_str_f_8, {&OpndDesc::Reg8FS,&OpndDesc::Mem8D},ISABSTRACT|ISSTORE,0,"str_f_8","",1)
+ DEFINE_MOP(MOP_str_f_16, {&OpndDesc::Reg16FS,&OpndDesc::Mem16D},ISABSTRACT|ISSTORE,0,"str_f_16","",1)
+ DEFINE_MOP(MOP_str_f_32, {&OpndDesc::Reg32FS,&OpndDesc::Mem32D},ISABSTRACT|ISSTORE,0,"str_f_32","",1)
+ DEFINE_MOP(MOP_str_f_64, {&OpndDesc::Reg64FS,&OpndDesc::Mem64D},ISABSTRACT|ISSTORE,0,"str_f_64","",1)
+ DEFINE_MOP(MOP_load_f_8, {&OpndDesc::Reg8FD,&OpndDesc::Mem8S},ISABSTRACT|ISLOAD,0,"load_f_8","",1)
+ DEFINE_MOP(MOP_load_f_16, {&OpndDesc::Reg16FD,&OpndDesc::Mem16S},ISABSTRACT|ISLOAD,0,"load_f_16","",1)
+ DEFINE_MOP(MOP_load_f_32, {&OpndDesc::Reg32FD,&OpndDesc::Mem32S},ISABSTRACT|ISLOAD,0,"load_f_32","",1)
+ DEFINE_MOP(MOP_load_f_64, {&OpndDesc::Reg64FD,&OpndDesc::Mem64S},ISABSTRACT|ISLOAD,0,"load_f_64","",1)
+
+ /* Support three address basic operations */
+ DEFINE_MOP(MOP_add_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS, &OpndDesc::Reg8IS},ISABSTRACT|ISBASICOP,0,"add_8","",1)
+ DEFINE_MOP(MOP_add_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS, &OpndDesc::Reg16IS},ISABSTRACT|ISBASICOP,0,"add_16","",1)
+ DEFINE_MOP(MOP_add_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS, &OpndDesc::Reg32IS},ISABSTRACT|ISBASICOP,0,"add_32","",1)
+ DEFINE_MOP(MOP_add_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},ISABSTRACT|ISBASICOP,0,"add_64","",1)
+ DEFINE_MOP(MOP_sub_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS, &OpndDesc::Reg8IS},ISABSTRACT|ISBASICOP,0,"sub_8","",1)
+ DEFINE_MOP(MOP_sub_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS, &OpndDesc::Reg16IS},ISABSTRACT|ISBASICOP,0,"sub_16","",1)
+ DEFINE_MOP(MOP_sub_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS, &OpndDesc::Reg32IS},ISABSTRACT|ISBASICOP,0,"sub_32","",1)
+ DEFINE_MOP(MOP_sub_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},ISABSTRACT|ISBASICOP,0,"sub_64","",1)
+ DEFINE_MOP(MOP_or_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS, &OpndDesc::Reg8IS},ISABSTRACT|ISBASICOP,0,"or_8","",1)
+ DEFINE_MOP(MOP_or_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS, &OpndDesc::Reg16IS},ISABSTRACT|ISBASICOP,0,"or_16","",1)
+ DEFINE_MOP(MOP_or_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS, &OpndDesc::Reg32IS},ISABSTRACT|ISBASICOP,0,"or_32","",1)
+ DEFINE_MOP(MOP_or_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},ISABSTRACT|ISBASICOP,0,"or_64","",1)
+ DEFINE_MOP(MOP_xor_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS, &OpndDesc::Reg8IS},ISABSTRACT|ISBASICOP,0,"xor_8","",1)
+ DEFINE_MOP(MOP_xor_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS, &OpndDesc::Reg16IS},ISABSTRACT|ISBASICOP,0,"xor_16","",1)
+ DEFINE_MOP(MOP_xor_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS, &OpndDesc::Reg32IS},ISABSTRACT|ISBASICOP,0,"xor_32","",1)
+ DEFINE_MOP(MOP_xor_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},ISABSTRACT|ISBASICOP,0,"xor_64","",1)
+ DEFINE_MOP(MOP_and_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS, &OpndDesc::Reg8IS},ISABSTRACT|ISBASICOP,0,"and_8","",1)
+ DEFINE_MOP(MOP_and_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS, &OpndDesc::Reg16IS},ISABSTRACT|ISBASICOP,0,"and_16","",1)
+ DEFINE_MOP(MOP_and_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS, &OpndDesc::Reg32IS},ISABSTRACT|ISBASICOP,0,"and_32","",1)
+ DEFINE_MOP(MOP_and_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},ISABSTRACT|ISBASICOP,0,"and_64","",1)
+
+ /* Support three address basic operations (Floating point) */
+ DEFINE_MOP(MOP_add_f_8, {&OpndDesc::Reg8FD,&OpndDesc::Reg8FS, &OpndDesc::Reg8FS},ISABSTRACT|ISBASICOP,0,"add_8","",1)
+ DEFINE_MOP(MOP_add_f_16, {&OpndDesc::Reg16FD,&OpndDesc::Reg16FS, &OpndDesc::Reg16FS},ISABSTRACT|ISBASICOP,0,"add_16","",1)
+ DEFINE_MOP(MOP_add_f_32, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS, &OpndDesc::Reg32FS},ISABSTRACT|ISBASICOP,0,"add_32","",1)
+ DEFINE_MOP(MOP_add_f_64, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS, &OpndDesc::Reg64FS},ISABSTRACT|ISBASICOP,0,"add_64","",1)
+ DEFINE_MOP(MOP_sub_f_8, {&OpndDesc::Reg8FD,&OpndDesc::Reg8FS, &OpndDesc::Reg8FS},ISABSTRACT|ISBASICOP,0,"sub_8","",1)
+ DEFINE_MOP(MOP_sub_f_16, {&OpndDesc::Reg16FD,&OpndDesc::Reg16FS, &OpndDesc::Reg16FS},ISABSTRACT|ISBASICOP,0,"sub_16","",1)
+ DEFINE_MOP(MOP_sub_f_32, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS, &OpndDesc::Reg32FS},ISABSTRACT|ISBASICOP,0,"sub_32","",1)
+ DEFINE_MOP(MOP_sub_f_64, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS, &OpndDesc::Reg64FS},ISABSTRACT|ISBASICOP,0,"sub_64","",1)
+
+ /* shift -- shl/ashr/lshr */
+ DEFINE_MOP(MOP_shl_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS, &OpndDesc::Reg8IS},ISABSTRACT|ISSHIFT,0,"shl_8","",1)
+ DEFINE_MOP(MOP_shl_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS, &OpndDesc::Reg16IS},ISABSTRACT|ISSHIFT,0,"shl_16","",1)
+ DEFINE_MOP(MOP_shl_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS, &OpndDesc::Reg32IS},ISABSTRACT|ISSHIFT,0,"shl_32","",1)
+ DEFINE_MOP(MOP_shl_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},ISABSTRACT|ISSHIFT,0,"shl_64","",1)
+ DEFINE_MOP(MOP_ashr_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS, &OpndDesc::Reg8IS},ISABSTRACT|ISSHIFT,0,"ashr_8","",1)
+ DEFINE_MOP(MOP_ashr_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS, &OpndDesc::Reg16IS},ISABSTRACT|ISSHIFT,0,"ashr_16","",1)
+ DEFINE_MOP(MOP_ashr_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS, &OpndDesc::Reg32IS},ISABSTRACT|ISSHIFT,0,"ashr_32","",1)
+ DEFINE_MOP(MOP_ashr_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},ISABSTRACT|ISSHIFT,0,"ashr_64","",1)
+ DEFINE_MOP(MOP_lshr_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS, &OpndDesc::Reg8IS},ISABSTRACT|ISSHIFT,0,"lshr_8","",1)
+ DEFINE_MOP(MOP_lshr_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS, &OpndDesc::Reg16IS},ISABSTRACT|ISSHIFT,0,"lshr_16","",1)
+ DEFINE_MOP(MOP_lshr_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS, &OpndDesc::Reg32IS},ISABSTRACT|ISSHIFT,0,"lshr_32","",1)
+ DEFINE_MOP(MOP_lshr_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},ISABSTRACT|ISSHIFT,0,"lshr_64","",1)
+
+ /* Support two address basic operations */
+ DEFINE_MOP(MOP_neg_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS},ISABSTRACT|ISUNARYOP,0,"neg_8","",1)
+ DEFINE_MOP(MOP_neg_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS},ISABSTRACT|ISUNARYOP,0,"neg_16","",1)
+ DEFINE_MOP(MOP_neg_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},ISABSTRACT|ISUNARYOP,0,"neg_32","",1)
+ DEFINE_MOP(MOP_neg_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISABSTRACT|ISUNARYOP,0,"neg_64","",1)
+ DEFINE_MOP(MOP_neg_f_8, {&OpndDesc::Reg8FD,&OpndDesc::Reg8FS},ISABSTRACT|ISUNARYOP,0,"neg_f_8","",1)
+ DEFINE_MOP(MOP_neg_f_16, {&OpndDesc::Reg16FD,&OpndDesc::Reg16FS},ISABSTRACT|ISUNARYOP,0,"neg_f_16","",1)
+ DEFINE_MOP(MOP_neg_f_32, {&OpndDesc::Reg32FD,&OpndDesc::Reg32FS},ISABSTRACT|ISUNARYOP,0,"neg_f_32","",1)
+ DEFINE_MOP(MOP_neg_f_64, {&OpndDesc::Reg64FD,&OpndDesc::Reg64FS},ISABSTRACT|ISUNARYOP,0,"neg_f_64","",1)
+ DEFINE_MOP(MOP_not_8, {&OpndDesc::Reg8ID,&OpndDesc::Reg8IS},ISABSTRACT|ISUNARYOP,0,"not_8","",1)
+ DEFINE_MOP(MOP_not_16, {&OpndDesc::Reg16ID,&OpndDesc::Reg16IS},ISABSTRACT|ISUNARYOP,0,"not_16","",1)
+ DEFINE_MOP(MOP_not_32, {&OpndDesc::Reg32ID,&OpndDesc::Reg32IS},ISABSTRACT|ISUNARYOP,0,"not_32","",1)
+ DEFINE_MOP(MOP_not_64, {&OpndDesc::Reg64ID,&OpndDesc::Reg64IS},ISABSTRACT|ISUNARYOP,0,"not_64","",1)
+
+ /* MOP_comment */
+ DEFINE_MOP(MOP_comment, {&OpndDesc::String0S},ISABSTRACT,0,"//","0", 0)
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/alignment.h b/src/mapleall/maple_be/include/cg/alignment.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c588039992dbb776a8444eaf221544b96965d21
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/alignment.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_ALIGNMENT_H
+#define MAPLEBE_INCLUDE_CG_ALIGNMENT_H
+
+#include "cg_phase.h"
+#include "maple_phase.h"
+#include "cgbb.h"
+#include "loop.h"
+
+namespace maplebe {
+class AlignAnalysis {
+ public:
+  AlignAnalysis(CGFunc &func, MemPool &memP)
+      : cgFunc(&func),
+        alignAllocator(&memP),
+        loopHeaderBBs(alignAllocator.Adapter()),
+        jumpTargetBBs(alignAllocator.Adapter()),
+        alignInfos(alignAllocator.Adapter()),
+        sameTargetBranches(alignAllocator.Adapter()) {}
+
+  virtual ~AlignAnalysis() = default;
+
+  void AnalysisAlignment();
+  void Dump();
+  virtual void FindLoopHeader() = 0;
+  virtual void FindJumpTarget() = 0;
+  virtual void ComputeLoopAlign() = 0;
+  virtual void ComputeJumpAlign() = 0;
+  virtual void ComputeCondBranchAlign() = 0;
+
+  /* filter condition */
+  virtual bool IsIncludeCall(BB &bb) = 0;
+  virtual bool IsInSizeRange(BB &bb) = 0;
+  virtual bool HasFallthruEdge(BB &bb) = 0;
+
+  std::string PhaseName() const {
+    return "alignanalysis";
+  }
+  const MapleUnorderedSet<BB*> &GetLoopHeaderBBs() const {
+    return loopHeaderBBs;
+  }
+  const MapleUnorderedSet<BB*> &GetJumpTargetBBs() const {
+    return jumpTargetBBs;
+  }
+  const MapleUnorderedMap<BB*, uint32> &GetAlignInfos() const {
+    return alignInfos;
+  }
+  uint32 GetAlignPower(BB &bb) {
+    return alignInfos[&bb];
+  }
+
+  void InsertLoopHeaderBBs(BB &bb) {
+    loopHeaderBBs.insert(&bb);
+  }
+  void InsertJumpTargetBBs(BB &bb) {
+    jumpTargetBBs.insert(&bb);
+  }
+  void InsertAlignInfos(BB &bb, uint32 power) {
+    alignInfos[&bb] = power;
+  }
+
+ protected:
+  CGFunc *cgFunc;
+  MapleAllocator alignAllocator;
+  MapleUnorderedSet<BB*> loopHeaderBBs;
+  MapleUnorderedSet<BB*> jumpTargetBBs;
+  MapleUnorderedMap<BB*, uint32> alignInfos;
+  MapleUnorderedMap<LabelIdx, uint32> sameTargetBranches;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgAlignAnalysis, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+} /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_ALIGNMENT_H */
diff --git a/src/mapleall/maple_be/include/cg/args.h b/src/mapleall/maple_be/include/cg/args.h
new file mode 100644
index 0000000000000000000000000000000000000000..33e444b30e99358f3614fdd072544dd975d9185d
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/args.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_ARGS_H
+#define MAPLEBE_INCLUDE_CG_ARGS_H
+
+#include "cgfunc.h"
+#include "cg_phase.h"
+
+namespace maplebe {
+class MoveRegArgs {
+ public:
+  explicit MoveRegArgs(CGFunc &func) : cgFunc(&func) {}
+
+  virtual ~MoveRegArgs() = default;
+
+  virtual void Run() {}
+
+  std::string PhaseName() const {
+    return "moveargs";
+  }
+
+  const CGFunc *GetCGFunc() const {
+    return cgFunc;
+  }
+
+ protected:
+  CGFunc *cgFunc;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgMoveRegArgs, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_ARGS_H */
diff --git a/src/mapleall/maple_be/include/cg/asm_emit.h b/src/mapleall/maple_be/include/cg/asm_emit.h
new file mode 100644
index 0000000000000000000000000000000000000000..88236bc007af2f9de5f87e9dc1aaa61090fbe378
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/asm_emit.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_ASM_EMIT_H
+#define MAPLEBE_INCLUDE_CG_ASM_EMIT_H
+
+#include "emit.h"
+
+namespace maplebe {
+class AsmFuncEmitInfo : public FuncEmitInfo {
+ public:
+  explicit AsmFuncEmitInfo(CGFunc &func) : FuncEmitInfo(func) {}
+  virtual ~AsmFuncEmitInfo() = default;
+};
+
+class AsmEmitter : public Emitter {
+ protected:
+  AsmEmitter(CG &cg, const std::string &asmFileName) : Emitter(cg, asmFileName) {}
+  virtual ~AsmEmitter() = default;
+
+  virtual void EmitRefToMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) = 0;
+  virtual void EmitRefToMethodInfo(FuncEmitInfo &funcEmitInfo, Emitter &emitter) = 0;
+  virtual void EmitMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) = 0;
+  virtual void EmitFastLSDA(FuncEmitInfo &funcEmitInfo) = 0;
+  virtual void EmitFullLSDA(FuncEmitInfo &funcEmitInfo) = 0;
+  virtual void EmitBBHeaderLabel(FuncEmitInfo &funcEmitInfo, const std::string &name, LabelIdx labIdx) = 0;
+  virtual void EmitJavaInsnAddr(FuncEmitInfo &funcEmitInfo) = 0;
+  virtual void Run(FuncEmitInfo &funcEmitInfo) = 0;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_ASM_EMIT_H */
diff --git a/src/mapleall/maple_be/include/cg/asm_info.h b/src/mapleall/maple_be/include/cg/asm_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..f58f6c6f56314c5889872f4779154bbd3b969cc0
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/asm_info.h
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_ASM_INFO_H
+#define MAPLEBE_INCLUDE_CG_ASM_INFO_H
+
+#include "maple_string.h"
+
+namespace maplebe {
+enum AsmLabel : uint8 {
+  kAsmGlbl,
+  kAsmLocal,
+  kAsmWeak,
+  kAsmBss,
+  kAsmComm,
+  kAsmData,
+  kAsmAlign,
+  kAsmSyname,
+  kAsmZero,
+  kAsmByte,
+  kAsmShort,
+  kAsmValue,
+  kAsmLong,
+  kAsmQuad,
+  kAsmSize,
+  kAsmType,
+  kAsmText,
+  kAsmHidden
+};
+
+class AsmInfo {
+ public:
+  const MapleString &GetCmnt() const {
+    return asmCmnt;
+  }
+
+  const MapleString &GetAtobt() const {
+    return asmAtObt;
+  }
+
+  const MapleString &GetFile() const {
+    return asmFile;
+  }
+
+  const MapleString &GetSection() const {
+    return asmSection;
+  }
+
+  const MapleString &GetRodata() const {
+    return asmRodata;
+  }
+
+  const MapleString &GetGlobal() const {
+    return asmGlobal;
+  }
+
+  const MapleString &GetLocal() const {
+    return asmLocal;
+  }
+
+  const MapleString &GetWeak() const {
+    return asmWeak;
+  }
+
+  const MapleString &GetBss() const {
+    return asmBss;
+  }
+
+  const MapleString &GetComm() const {
+    return asmComm;
+  }
+
+  const MapleString &GetData() const {
+    return asmData;
+  }
+
+  const MapleString &GetAlign() const {
+    return asmAlign;
+  }
+
+  const MapleString &GetZero() const {
+    return asmZero;
+  }
+
+  const MapleString &GetByte() const {
+    return asmByte;
+  }
+
+  const MapleString &GetShort() const {
+    return asmShort;
+  }
+
+  const MapleString &GetValue() const {
+    return asmValue;
+  }
+
+  const MapleString &GetLong() const {
+    return asmLong;
+  }
+
+  const MapleString &GetQuad() const {
+    return asmQuad;
+  }
+
+  const MapleString &GetSize() const {
+    return asmSize;
+  }
+
+  const MapleString &GetType() const {
+    return asmType;
+  }
+
+  const MapleString &GetHidden() const {
+    return asmHidden;
+  }
+
+  const MapleString &GetText() const {
+    return asmText;
+  }
+
+  const MapleString &GetSet() const {
+    return asmSet;
+  }
+
+  const MapleString &GetWeakref() const {
+    return asmWeakref;
+  }
+
+  explicit AsmInfo(MemPool &memPool)
+#if TARGX86 || TARGX86_64
+      : asmCmnt("\t//\t", &memPool),
+#elif TARGARM32
+      : asmCmnt("\t@\t", &memPool),
+#else
+      : asmCmnt("\t#\t", &memPool),
+#endif
+
+        asmAtObt("\t%object\t", &memPool),
+        asmFile("\t.file\t", &memPool),
+        asmSection("\t.section\t", &memPool),
+        asmRodata(".rodata\t", &memPool),
+        asmGlobal("\t.global\t", &memPool),
+        asmLocal("\t.local\t", &memPool),
+        asmWeak("\t.weak\t", &memPool),
+        asmBss("\t.bss\t", &memPool),
+        asmComm("\t.comm\t", &memPool),
+        asmData("\t.data\t", &memPool),
+        asmAlign("\t.align\t", &memPool),
+        asmZero("\t.zero\t", &memPool),
+        asmByte("\t.byte\t", &memPool),
+        asmShort("\t.short\t", &memPool),
+#ifdef TARGARM32
+        asmValue("\t.short\t", &memPool),
+#else
+        asmValue("\t.value\t", &memPool),
+#endif
+#ifdef TARGARM32
+        asmLong("\t.word\t", &memPool),
+#else
+        asmLong("\t.long\t", &memPool),
+#endif
+        asmQuad("\t.quad\t", &memPool),
+        asmSize("\t.size\t", &memPool),
+        asmType("\t.type\t", &memPool),
+        asmHidden("\t.hidden\t", &memPool),
+        asmText("\t.text\t", &memPool),
+        asmSet("\t.set\t", &memPool),
+        asmWeakref("\t.weakref\t", &memPool) {}
+
+  ~AsmInfo() = default;
+
+ private:
+  MapleString asmCmnt;
+  MapleString asmAtObt;
+  MapleString asmFile;
+  MapleString asmSection;
+  MapleString asmRodata;
+  MapleString asmGlobal;
+  MapleString asmLocal;
+  MapleString asmWeak;
+  MapleString asmBss;
+  MapleString asmComm;
+  MapleString asmData;
+  MapleString asmAlign;
+  MapleString asmZero;
+  MapleString asmByte;
+  MapleString asmShort;
+  MapleString asmValue;
+  MapleString asmLong;
+  MapleString asmQuad;
+  MapleString asmSize;
+  MapleString asmType;
+  MapleString asmHidden;
+  MapleString asmText;
+  MapleString asmSet;
+  MapleString asmWeakref;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_ASM_INFO_H */
diff --git a/src/mapleall/maple_be/include/cg/call_conv.h b/src/mapleall/maple_be/include/cg/call_conv.h
new file mode 100644
index 0000000000000000000000000000000000000000..19661f0e3a28bdd92175c46daffad0a7d3eec1b5
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/call_conv.h
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CALL_CONV_H
+#define MAPLEBE_INCLUDE_CG_CALL_CONV_H
+
+#include "types_def.h"
+#include "becommon.h"
+
+namespace maplebe {
+using namespace maple;
+
+/* for specifying how a parameter is passed */
+struct CCLocInfo {
+  regno_t reg0 = 0;  /* 0 means parameter is stored on the stack */
+  regno_t reg1 = 0;
+  regno_t reg2 = 0;  /* can have up to 4 single precision fp registers */
+  regno_t reg3 = 0;  /* for small structure return. */
+  int32 memOffset = 0;
+  int32 memSize = 0;
+  uint32 fpSize = 0;
+  uint32 numFpPureRegs = 0;
+  uint8 regCount = 0;             /* number of registers <= 2 storing the return value */
+  PrimType primTypeOfReg0;    /* the primitive type stored in reg0 */
+  PrimType primTypeOfReg1;    /* the primitive type stored in reg1 */
+  PrimType primTypeOfReg2;
+  PrimType primTypeOfReg3;
+  uint8 GetRegCount() const {
+    return regCount;
+  }
+
+  PrimType GetPrimTypeOfReg0() const {
+    return primTypeOfReg0;
+  }
+
+  PrimType GetPrimTypeOfReg1() const {
+    return primTypeOfReg1;
+  }
+
+  PrimType GetPrimTypeOfReg2() const {
+    return primTypeOfReg2;
+  }
+
+  PrimType GetPrimTypeOfReg3() const {
+    return primTypeOfReg3;
+  }
+
+  regno_t GetReg0() const {
+    return reg0;
+  }
+
+  regno_t GetReg1() const {
+    return reg1;
+  }
+
+  regno_t GetReg2() const {
+    return reg2;
+  }
+
+  regno_t GetReg3() const {
+    return reg3;
+  }
+};
+
+class LmbcFormalParamInfo {
+ public:
+  LmbcFormalParamInfo(PrimType pType, uint32 ofst, uint32 sz)
+      : type(nullptr), primType(pType), offset(ofst), onStackOffset(0), size(sz), regNO(0), vregNO(0), numRegs(0),
+        fpSize(0), isReturn(false), isPureFloat(false), isOnStack(false), hasRegassign(false) {}
+
+  ~LmbcFormalParamInfo() = default;
+
+  MIRStructType *GetType() {
+    return type;
+  }
+  void SetType(MIRStructType *ty) {
+    type = ty;
+  }
+  PrimType GetPrimType() const {
+    return primType;
+  }
+  void SetPrimType(PrimType pType) {
+    primType = pType;
+  }
+  uint32 GetOffset() const {
+    return offset;
+  }
+  void SetOffset(uint32 ofs) {
+    offset = ofs;
+  }
+  uint32 GetOnStackOffset() const {
+    return onStackOffset;
+  }
+  void SetOnStackOffset(uint32 ofs) {
+    onStackOffset = ofs;
+  }
+  uint32 GetSize() const {
+    return size;
+  }
+  void SetSize(uint32 sz) {
+    size = sz;
+  }
+  regno_t GetRegNO() const {
+    return regNO;
+  }
+  void SetRegNO(regno_t reg) {
+    regNO = reg;
+  }
+  regno_t GetVregNO() const {
+    return vregNO;
+  }
+  void SetVregNO(regno_t reg) {
+    vregNO = reg;
+  }
+  uint32 GetNumRegs() const {
+    return numRegs;
+  }
+  void SetNumRegs(uint32 num) {
+    numRegs = num;
+  }
+  uint32 GetFpSize() const {
+    return fpSize;
+  }
+  void SetFpSize(uint32 sz) {
+    fpSize = sz;
+  }
+  bool IsReturn() const {
+    return isReturn;
+  }
+  void SetIsReturn() {
+    isReturn = true;
+  }
+  bool IsPureFloat() const {
+    return isPureFloat;
+  }
+  void SetIsPureFloat() {
+    isPureFloat = true;
+  }
+  bool IsInReg() const {
+    return !isOnStack ;
+  }
+  bool IsOnStack() const {
+    return isOnStack;
+  }
+  void SetIsOnStack() {
+    isOnStack = true;
+  }
+  bool HasRegassign() const {
+    return hasRegassign;
+  }
+  void SetHasRegassign() {
+    hasRegassign = true;
+  }
+ private:
+  MIRStructType *type;
+  PrimType primType;
+  uint32 offset;
+  uint32 onStackOffset;   /* stack location if isOnStack */
+  uint32 size;        /* size primtype or struct */
+  regno_t regNO = 0;  /* param reg num or starting reg num if numRegs > 0 */
+  regno_t vregNO = 0; /* if no explicit regassing from IR, create move from param reg */
+  uint32 numRegs = 0; /* number of regs for struct param */
+  uint32 fpSize = 0;  /* size of fp param if isPureFloat */
+  bool isReturn;
+  bool isPureFloat = false;
+  bool isOnStack; /* large struct is passed by a copy on stack */
+  bool hasRegassign;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_CALL_CONV_H */
diff --git a/src/mapleall/maple_be/include/cg/cfgo.h b/src/mapleall/maple_be/include/cg/cfgo.h
new file mode 100644
index 0000000000000000000000000000000000000000..340078e4f97469cafccab4a8652c19d71ff7c781
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cfgo.h
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CFGO_H
+#define MAPLEBE_INCLUDE_CG_CFGO_H
+#include "cg_cfg.h"
+#include "optimize_common.h"
+
+namespace maplebe {
+
+enum CfgoPhase : maple::uint8 {
+  kCfgoDefault,
+  kCfgoPreRegAlloc,
+  kCfgoPostRegAlloc,
+  kPostCfgo,
+};
+
+class ChainingPattern : public OptimizationPattern {
+ public:
+  explicit ChainingPattern(CGFunc &func) : OptimizationPattern(func) {
+    patternName = "BB Chaining";
+    dotColor = kCfgoChaining;
+  }
+
+  virtual ~ChainingPattern() = default;
+  bool Optimize(BB &curBB) override;
+
+ protected:
+  bool NoInsnBetween(const BB &from, const BB &to) const;
+  bool DoSameThing(const BB &bb1, const Insn &last1, const BB &bb2, const Insn &last2) const;
+  bool MergeFallthuBB(BB &curBB);
+  bool MergeGotoBB(BB &curBB, BB &sucBB);
+  bool MoveSuccBBAsCurBBNext(BB &curBB, BB &sucBB);
+  bool RemoveGotoInsn(BB &curBB, BB &sucBB);
+  bool ClearCurBBAndResetTargetBB(BB &curBB, BB &sucBB);
+};
+
+class SequentialJumpPattern : public OptimizationPattern {
+ public:
+  explicit SequentialJumpPattern(CGFunc &func) : OptimizationPattern(func) {
+    patternName = "Sequential Jump";
+    dotColor = kCfgoSj;
+  }
+
+  virtual ~SequentialJumpPattern() = default;
+  bool Optimize(BB &curBB) override;
+
+ protected:
+  void SkipSucBB(BB &curBB, BB &sucBB) const;
+  void UpdateSwitchSucc(BB &curBB, BB &sucBB) const;
+};
+
+class FlipBRPattern : public OptimizationPattern {
+ public:
+  explicit FlipBRPattern(CGFunc &func) : OptimizationPattern(func) {
+    patternName = "Condition Flip";
+    dotColor = kCfgoFlipCond;
+  }
+
+  virtual ~FlipBRPattern() = default;
+  bool Optimize(BB &curBB) override;
+
+  CfgoPhase GetPhase() const {
+    return phase;
+  }
+  void SetPhase(CfgoPhase val) {
+    phase = val;
+  }
+  CfgoPhase phase = kCfgoDefault;
+
+ protected:
+  void RelocateThrowBB(BB &curBB);
+ private:
+  virtual uint32 GetJumpTargetIdx(const Insn &insn) = 0;
+  virtual MOperator FlipConditionOp(MOperator flippedOp) = 0;
+};
+
+/* This class represents the scenario that the BB is unreachable. */
+class UnreachBBPattern : public OptimizationPattern {
+ public:
+  explicit UnreachBBPattern(CGFunc &func) : OptimizationPattern(func) {
+    patternName = "Unreachable BB";
+    dotColor = kCfgoUnreach;
+    func.GetTheCFG()->FindAndMarkUnreachable(*cgFunc);
+  }
+
+  virtual ~UnreachBBPattern() = default;
+  bool Optimize(BB &curBB) override;
+};
+
+/*
+ * This class represents the scenario that a common jump BB can be duplicated
+ * to one of its another predecessor.
+ */
+class DuplicateBBPattern : public OptimizationPattern {
+ public:
+  explicit DuplicateBBPattern(CGFunc &func) : OptimizationPattern(func) {
+    patternName = "Duplicate BB";
+    dotColor = kCfgoDup;
+  }
+
+  virtual ~DuplicateBBPattern() = default;
+  bool Optimize(BB &curBB) override;
+
+ private:
+  static constexpr int kThreshold = 10;
+};
+
+/*
+ * This class represents the scenario that a BB contains nothing.
+ */
+class EmptyBBPattern : public OptimizationPattern {
+ public:
+  explicit EmptyBBPattern(CGFunc &func) : OptimizationPattern(func) {
+    patternName = "Empty BB";
+    dotColor = kCfgoEmpty;
+  }
+
+  virtual ~EmptyBBPattern() = default;
+  bool Optimize(BB &curBB) override;
+};
+
+class CFGOptimizer : public Optimizer {
+ public:
+  CFGOptimizer(CGFunc &func, MemPool &memPool) : Optimizer(func, memPool) {
+    name = "CFGO";
+  }
+
+  virtual ~CFGOptimizer() = default;
+  CfgoPhase GetPhase() const {
+    return phase;
+  }
+  void SetPhase(CfgoPhase val) {
+    phase = val;
+  }
+  CfgoPhase phase = kCfgoDefault;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgCfgo, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPostCfgo, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_CFGO_H */
diff --git a/src/mapleall/maple_be/include/cg/cfi.def b/src/mapleall/maple_be/include/cg/cfi.def
new file mode 100644
index 0000000000000000000000000000000000000000..2c361aa64d2d69f53b53af4067d51cbf8d2da196
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cfi.def
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/* Binutiles 2.28 */
+/* https://sourceware.org/binutils/docs-2.28/as/CFI-directives.html#CFI-directives */
+CFI_DEFINE( sections,             , 1, List,        Undef,     Undef )
+CFI_DEFINE( startproc,            , 0, Undef,       Undef,     Undef )
+CFI_DEFINE( startproc,     _simple, 1, String,      Undef,     Undef ) /* "simple" */
+CFI_DEFINE( endproc,              , 0, Undef,       Undef,     Undef )
+CFI_DEFINE( personality,  _default, 1, Immediate,   Undef,     Undef )
+CFI_DEFINE( personality,   _symbol, 2, Immediate,   String,    Undef )
+CFI_DEFINE( personality, _constant, 2, Immediate,   Immediate, Undef )
+CFI_DEFINE( personality_id,       , 1, StImmediate, Undef,     Undef )
+CFI_DEFINE( fde_data,             , 1, List,        Undef,     Undef )
+CFI_DEFINE( lsda,         _default, 1, Immediate,   Undef,     Undef )
+CFI_DEFINE( lsda,           _label, 2, Immediate,   BBAddress, Undef )
+CFI_DEFINE( lsda,        _constant, 2, Immediate,   Immediate, Undef )
+CFI_DEFINE( inline_lsda,          , 0, Undef,       Undef,     Undef )
+CFI_DEFINE( inline_lsda,    _align, 1, Immediate,   Undef,     Undef ) /* power of 2 */
+CFI_DEFINE( def_cfa,              , 2, Register,    Immediate, Undef )
+CFI_DEFINE( def_cfa_register,     , 1, Register,    Undef,     Undef )
+CFI_DEFINE( def_cfa_offset,       , 1, Immediate,   Undef,     Undef )
+CFI_DEFINE( adjust_cfa_offset,    , 1, Immediate,   Undef,     Undef )
+CFI_DEFINE( offset,               , 2, Register,    Immediate, Undef )
+CFI_DEFINE( val_offset,           , 2, Register,    Immediate, Undef )
+CFI_DEFINE( rel_offset,           , 2, Register,    Immediate, Undef )
+CFI_DEFINE( register,             , 2, Register,    Register,  Undef )
+CFI_DEFINE( restore,              , 1, Register,    Undef,     Undef )
+CFI_DEFINE( undefined,            , 1, Register,    Undef,     Undef )
+CFI_DEFINE( same_value,           , 1, Register,    Undef,     Undef )
+CFI_DEFINE( remember_state,       , 0, Undef,       Undef,     Undef )
+CFI_DEFINE( restore_state,        , 0, Undef,       Undef,     Undef )
+CFI_DEFINE( return_column,        , 1, Register,    Undef,     Undef )
+CFI_DEFINE( signal_frame,         , 0, Undef,       Undef,     Undef )
+CFI_DEFINE( window_save,          , 0, Undef,       Undef,     Undef )
+CFI_DEFINE( escape,               , 2, StImmediate, List /*expression[, ...]*/, Undef )
+CFI_DEFINE( val_encoded_addr,     , 3, Register,    Immediate, StImmediate )
+
+ARM_DIRECTIVES_DEFINE( save,      , 1, List,        Undef,     Undef )
+ARM_DIRECTIVES_DEFINE( vsave,     , 1, List,        Undef,     Undef )
+ARM_DIRECTIVES_DEFINE( setfp,     , 3, Register,    Register, Immediate )
+ARM_DIRECTIVES_DEFINE( pad,       , 1, Immediate,   Undef,     Undef )
diff --git a/src/mapleall/maple_be/include/cg/cfi.h b/src/mapleall/maple_be/include/cg/cfi.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f90ae5d86db819aae8e08e485f9688ddd9449a3
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cfi.h
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CFI_H
+#define MAPLEBE_INCLUDE_CG_CFI_H
+
+#include "insn.h"
+#include "mempool_allocator.h"
+#include "mir_symbol.h"
+#include "operand.h"
+#include "common_utils.h"
+
+/*
+ * Reference:
+ * GNU Binutils. AS documentation
+ * https://sourceware.org/binutils/docs-2.28/as/index.html
+ *
+ * CFI blog
+ * https://www.imperialviolet.org/2017/01/18/cfi.html
+ *
+ * System V Application Binary Interface
+ * AMD64 Architecture Processor Supplement. Draft Version 0.99.7
+ * https://www.uclibc.org/docs/psABI-x86_64.pdf $ 3.7 Figure 3.36
+ * (RBP->6, RSP->7)
+ *
+ * System V Application Binary Interface
+ * Inte386 Architecture Processor Supplement. Version 1.0
+ * https://www.uclibc.org/docs/psABI-i386.pdf $ 2.5 Table 2.14
+ * (EBP->5, ESP->4)
+ *
+ * DWARF for ARM Architecture (ARM IHI 0040B)
+ * infocenter.arm.com/help/topic/com.arm.doc.ihi0040b/IHI0040B_aadwarf.pdf
+ * $ 3.1 Table 1
+ * (0-15 -> R0-R15)
+ */
+namespace cfi {
+using namespace maple;
+
+enum CfiOpcode : uint8 {
+#define CFI_DEFINE(k, sub, n, o0, o1, o2) OP_CFI_##k##sub,
+#define ARM_DIRECTIVES_DEFINE(k, sub, n, o0, o1, o2) OP_ARM_DIRECTIVES_##k##sub,
+#include "cfi.def"
+#undef CFI_DEFINE
+#undef ARM_DIRECTIVES_DEFINE
+  kOpCfiLast
+};
+
+class CfiInsn : public maplebe::Insn {
+ public:
+  CfiInsn(MemPool &memPool, maplebe::MOperator op) : Insn(memPool, op) {}
+
+  CfiInsn(MemPool &memPool, maplebe::MOperator op, maplebe::Operand &opnd0) : Insn(memPool, op, opnd0) {}
+
+  CfiInsn(MemPool &memPool, maplebe::MOperator op, maplebe::Operand &opnd0, maplebe::Operand &opnd1)
+      : Insn(memPool, op, opnd0, opnd1) {}
+
+  CfiInsn(MemPool &memPool, maplebe::MOperator op, maplebe::Operand &opnd0, maplebe::Operand &opnd1,
+      maplebe::Operand &opnd2)
+      : Insn(memPool, op, opnd0, opnd1, opnd2) {}
+
+  ~CfiInsn() = default;
+
+  bool IsMachineInstruction() const override {
+    return false;
+  }
+
+  void Dump() const override;
+
+#if DEBUG
+  void Check() const override;
+#endif
+
+  bool IsCfiInsn() const override {
+    return true;
+  }
+
+  bool IsTargetInsn() const override {
+    return false;
+  }
+
+  bool IsRegDefined(maplebe::regno_t regNO) const override {
+    CHECK_FATAL(false, "cfi do not def regs");
+    return false;
+  }
+
+  std::set<uint32> GetDefRegs() const override{
+    CHECK_FATAL(false, "cfi do not def regs");
+    return std::set<uint32>();
+  }
+
+  uint32 GetBothDefUseOpnd() const override {
+    return maplebe::kInsnMaxOpnd;
+  }
+
+ private:
+  CfiInsn &operator=(const CfiInsn&);
+};
+
+class RegOperand : public maplebe::OperandVisitable<RegOperand> {
+ public:
+  RegOperand(uint32 no, uint32 size) : OperandVisitable(kOpdRegister, size), regNO(no) {}
+
+  ~RegOperand() = default;
+  using OperandVisitable<RegOperand>::OperandVisitable;
+
+  uint32 GetRegisterNO() const {
+    return regNO;
+  }
+  Operand *Clone(MemPool &memPool) const override {
+    Operand *opnd = memPool.Clone<RegOperand>(*this);
+    return opnd;
+  }
+
+  void Dump() const override;
+
+  bool Less(const Operand &right) const override {
+    (void)right;
+    return false;
+  }
+
+ private:
+  uint32 regNO;
+};
+
+class ImmOperand : public maplebe::OperandVisitable<ImmOperand> {
+ public:
+  ImmOperand(int64 val, uint32 size) : OperandVisitable(kOpdImmediate, size), val(val) {}
+
+  ~ImmOperand() = default;
+  using OperandVisitable<ImmOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    Operand *opnd =  memPool.Clone<ImmOperand>(*this);
+    return opnd;
+  }
+  int64 GetValue() const {
+    return val;
+  }
+
+  void Dump() const override;
+
+  bool Less(const Operand &right) const override {
+    (void)right;
+    return false;
+  }
+
+ private:
+  int64 val;
+};
+
+class SymbolOperand : public maplebe::OperandVisitable<SymbolOperand> {
+ public:
+  SymbolOperand(const maple::MIRSymbol &mirSymbol, uint8 size)
+      : OperandVisitable(kOpdStImmediate, size),
+        symbol(&mirSymbol) {}
+  ~SymbolOperand() = default;
+  using OperandVisitable<SymbolOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    Operand *opnd =  memPool.Clone<SymbolOperand>(*this);
+    return opnd;
+  }
+
+  bool Less(const Operand &right) const override {
+    (void)right;
+    return false;
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "symbol is  : " << symbol->GetName();
+  }
+
+ private:
+  const maple::MIRSymbol *symbol;
+};
+
+class StrOperand : public maplebe::OperandVisitable<StrOperand> {
+ public:
+  StrOperand(const std::string &str, MemPool &memPool) : OperandVisitable(kOpdString, 0), str(str, &memPool) {}
+
+  ~StrOperand() = default;
+  using OperandVisitable<StrOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    Operand *opnd = memPool.Clone<StrOperand>(*this);
+    return opnd;
+  }
+
+  bool Less(const Operand &right) const override {
+    (void)right;
+    return false;
+  }
+
+  const MapleString &GetStr() const {
+    return str;
+  }
+
+  void Dump() const override;
+
+ private:
+  const MapleString str;
+};
+
+class LabelOperand : public maplebe::OperandVisitable<LabelOperand> {
+ public:
+  LabelOperand(const std::string &parent, LabelIdx labIdx, MemPool &memPool)
+      : OperandVisitable(kOpdBBAddress, 0), parentFunc(parent, &memPool), labelIndex(labIdx) {}
+
+  ~LabelOperand() = default;
+  using OperandVisitable<LabelOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    Operand *opnd = memPool.Clone<LabelOperand>(*this);
+    return opnd;
+  }
+
+  bool Less(const Operand &right) const override {
+    (void)right;
+    return false;
+  }
+
+  void Dump() const override;
+
+  const MapleString &GetParentFunc() const {
+    return parentFunc;
+  }
+  LabelIdx GetIabelIdx() const {
+    return labelIndex;
+  };
+
+ private:
+  const MapleString parentFunc;
+  LabelIdx labelIndex;
+};
+
+class CFIOpndEmitVisitor : public maplebe::OperandVisitorBase,
+                           public maplebe::OperandVisitors<RegOperand,
+                                                           ImmOperand,
+                                                           SymbolOperand,
+                                                           StrOperand,
+                                                           LabelOperand> {
+ public:
+  explicit CFIOpndEmitVisitor(maplebe::Emitter &asmEmitter): emitter(asmEmitter) {}
+  virtual ~CFIOpndEmitVisitor() = default;
+ protected:
+  maplebe::Emitter &emitter;
+ private:
+  void Visit(RegOperand *v) final;
+  void Visit(ImmOperand *v) final;
+  void Visit(SymbolOperand *v) final;
+  void Visit(StrOperand *v) final;
+  void Visit(LabelOperand *v) final;
+};
+}  /* namespace cfi */
+#endif  /* MAPLEBE_INCLUDE_CG_CFI_H */
diff --git a/src/mapleall/maple_be/include/cg/cfi_generator.h b/src/mapleall/maple_be/include/cg/cfi_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..1844935ae3569ed9d62d8b82b000cfec54efb2b8
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cfi_generator.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CFI_GENERATOR_H
+#define MAPLEBE_INCLUDE_CG_CFI_GENERATOR_H
+#include "cg_phase.h"
+#include "cfi.h"
+#include "cgfunc.h"
+#include "insn.h"
+#include "aarch64_insn.h"
+#include "aarch64_operand.h"
+
+namespace maplebe {
+class GenCfi {
+ public:
+  explicit GenCfi(CGFunc &func) : cg(*func.GetCG()), cgFunc(func) {}
+  virtual ~GenCfi() = default;
+
+  void Run();
+
+ protected:
+  void InsertCFIDefCfaOffset(BB &bb, Insn &insn, int32 &cfiOffset); /* cfiOffset in-out */
+  Insn &FindStackDefNextInsn(BB &bb) const;
+
+  /* CFI related routines */
+  int64 GetOffsetFromCFA() const {
+    return offsetFromCfa;
+  }
+
+  /* add increment (can be negative) and return the new value */
+  int64 AddtoOffsetFromCFA(int64 delta) {
+    offsetFromCfa += delta;
+    return offsetFromCfa;
+  }
+
+  CG &cg;
+  CGFunc &cgFunc;
+  /* SP offset from Call Frame Address */
+  int64 offsetFromCfa = 0;
+  bool useFP = true;
+
+  static constexpr const int32 kOffset8MemPos = 8;
+
+ private:
+  void GenerateStartDirective(BB &bb);
+  void GenerateEndDirective(BB &bb);
+  void GenerateRegisterStateDirective(BB &bb);
+  virtual void GenerateRegisterSaveDirective(BB &bb) {}
+  virtual void GenerateRegisterRestoreDirective(BB &bb) {}
+
+  /* It is do insert a start location information for each function in debugging mode */
+  void InsertFirstLocation(BB &bb);
+};
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_CFI_GENERATOR_H */
diff --git a/src/mapleall/maple_be/include/cg/cg.h b/src/mapleall/maple_be/include/cg/cg.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cc3b4e74ad85172c008d7f10cf07ac534bcec7a
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg.h
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CG_H
+#define MAPLEBE_INCLUDE_CG_CG_H
+
+/* C++ headers. */
+#include <string>
+/* MapleIR headers. */
+#include "operand.h"
+#include "insn.h"
+#include "cgfunc.h"
+#include "live.h"
+#include "cg_option.h"
+#include "opcode_info.h"
+#include "global_tables.h"
+#include "mir_function.h"
+#include "mad.h"
+
+namespace maplebe {
+#define ADDTARGETPHASE(PhaseName, condition)    \
+  if (!CGOptions::IsSkipPhase(PhaseName)) {     \
+    pm->AddPhase(PhaseName, condition);         \
+  }
+/* subtarget opt phase -- cyclic Dependency, use Forward declaring */
+class CGSSAInfo;
+class PhiEliminate;
+class DomAnalysis;
+class CGProp;
+class CGDce;
+class AlignAnalysis;
+class MoveRegArgs;
+class MPISel;
+class Standardize;
+class LiveIntervalAnalysis;
+class ValidBitOpt;
+class CG;
+class LocalOpt;
+class CFGOptimizer;
+class RedundantComputeElim;
+class TailCallOpt;
+class Rematerializer;
+class CGProfGen;
+
+class Globals {
+ public:
+  static Globals *GetInstance() {
+    static Globals instance;
+    return &instance;
+  }
+
+  ~Globals() = default;
+
+  void SetBECommon(BECommon &bc) {
+    beCommon = &bc;
+  }
+
+  BECommon *GetBECommon() {
+    return beCommon;
+  }
+
+  const BECommon *GetBECommon() const {
+    return beCommon;
+  }
+
+  void SetMAD(MAD &m) {
+    mad = &m;
+  }
+
+  MAD *GetMAD() {
+    return mad;
+  }
+
+  const MAD *GetMAD() const {
+    return mad;
+  }
+
+  void SetOptimLevel(int32 opLevel) {
+    optimLevel = opLevel;
+  }
+
+  int32 GetOptimLevel() const {
+    return optimLevel;
+  }
+
+  void SetTarget(CG &target);
+  const CG *GetTarget() const ;
+
+ private:
+  BECommon *beCommon = nullptr;
+  MAD *mad = nullptr;
+  int32 optimLevel = 0;
+  CG *cg = nullptr;
+  Globals() = default;
+};
+
+class CG {
+ public:
+  using GenerateFlag = uint64;
+
+ public:
+  CG(MIRModule &mod, const CGOptions &cgOptions)
+      : memPool(memPoolCtrler.NewMemPool("maplecg mempool", false /* isLocalPool */)),
+        allocator(memPool),
+        mirModule(&mod),
+        emitter(nullptr),
+        labelOrderCnt(0),
+        cgOption(cgOptions),
+        fileGP(nullptr) {
+    const std::string &internalNameLiteral = namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr);
+    GStrIdx strIdxFromName = GlobalTables::GetStrTable().GetStrIdxFromName(internalNameLiteral);
+    isLibcore = (GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdxFromName) != nullptr);
+    DefineDebugTraceFunctions();
+    isLmbc = (mirModule->GetFlavor() == MIRFlavor::kFlavorLmbc);
+  }
+
+  virtual ~CG();
+
+  /* enroll all code generator phases for target machine */
+  virtual void EnrollTargetPhases(MaplePhaseManager *pm) const = 0;
+
+  void GenExtraTypeMetadata(const std::string &classListFileName, const std::string &outputBaseName);
+  void GenPrimordialObjectList(const std::string &outputBaseName);
+  const std::string ExtractFuncName(const std::string &str) const;
+
+  virtual Insn &BuildPhiInsn(RegOperand &defOpnd, Operand &listParam) = 0;
+  virtual PhiOperand &CreatePhiOperand(MemPool &mp, MapleAllocator &mAllocator) = 0;
+
+  virtual CGFunc *CreateCGFunc(MIRModule &mod, MIRFunction&, BECommon&, MemPool&, StackMemPool&,
+                               MapleAllocator&, uint32) = 0;
+
+  bool IsExclusiveEH() const {
+    return CGOptions::IsExclusiveEH();
+  }
+
+  virtual bool IsExclusiveFunc(MIRFunction &mirFunc) = 0;
+
+  /* NOTE: Consider making be_common a field of CG. */
+  virtual void GenerateObjectMaps(BECommon &beCommon) = 0;
+
+  /* Used for GCTIB pattern merging */
+  virtual std::string FindGCTIBPatternName(const std::string &name) const = 0;
+
+  bool GenerateVerboseAsm() const {
+    return cgOption.GenerateVerboseAsm();
+  }
+
+  bool GenerateVerboseCG() const {
+    return cgOption.GenerateVerboseCG();
+  }
+
+  bool DoPrologueEpilogue() const {
+    return cgOption.DoPrologueEpilogue();
+  }
+
+  bool DoTailCall() const {
+    return cgOption.DoTailCall();
+  }
+
+  bool DoCheckSOE() const {
+    return cgOption.DoCheckSOE();
+  }
+
+  bool GenerateDebugFriendlyCode() const {
+    return cgOption.GenerateDebugFriendlyCode();
+  }
+
+  int32 GetOptimizeLevel() const {
+    return cgOption.GetOptimizeLevel();
+  }
+
+  bool UseFastUnwind() const {
+    return true;
+  }
+
+  bool IsStackProtectorStrong() const {
+    return cgOption.IsStackProtectorStrong();
+  }
+
+  bool IsStackProtectorAll() const {
+    return cgOption.IsStackProtectorAll();
+  }
+
+  bool IsUnwindTables() const {
+    return cgOption.IsUnwindTables();
+  }
+
+  bool InstrumentWithDebugTraceCall() const {
+    return cgOption.InstrumentWithDebugTraceCall();
+  }
+
+  bool DoPatchLongBranch() const {
+    return cgOption.DoPatchLongBranch();
+  }
+
+  uint8 GetRematLevel() const {
+    return CGOptions::GetRematLevel();
+  }
+
+  bool GenYieldPoint() const {
+    return cgOption.GenYieldPoint();
+  }
+
+  bool GenLocalRC() const {
+    return cgOption.GenLocalRC();
+  }
+
+  bool GenerateExceptionHandlingCode() const {
+    return cgOption.GenerateExceptionHandlingCode();
+  }
+
+  bool DoConstFold() const {
+    return cgOption.DoConstFold();
+  }
+
+  void AddStackGuardvar() const;
+  void DefineDebugTraceFunctions();
+  MIRModule *GetMIRModule() {
+    return mirModule;
+  }
+
+  void SetEmitter(Emitter &emitterVal) {
+    this->emitter = &emitterVal;
+  }
+
+  Emitter *GetEmitter() const {
+    return emitter;
+  }
+
+  void IncreaseLabelOrderCnt() {
+    labelOrderCnt++;
+  }
+
+  LabelIDOrder GetLabelOrderCnt() const {
+    return labelOrderCnt;
+  }
+
+  const CGOptions &GetCGOptions() const {
+    return cgOption;
+  }
+
+  void UpdateCGOptions(const CGOptions &newOption) {
+    cgOption.SetOptionFlag(newOption.GetOptionFlag());
+  }
+
+  bool IsLibcore() const {
+    return isLibcore;
+  }
+
+  bool IsLmbc() const {
+    return isLmbc;
+  }
+
+  MIRSymbol *GetDebugTraceEnterFunction() {
+    return dbgTraceEnter;
+  }
+
+  const MIRSymbol *GetDebugTraceEnterFunction() const {
+    return dbgTraceEnter;
+  }
+
+  MIRSymbol *GetProfileFunction() {
+    return dbgFuncProfile;
+  }
+
+  const MIRSymbol *GetProfileFunction() const {
+    return dbgFuncProfile;
+  }
+
+  const MIRSymbol *GetDebugTraceExitFunction() const {
+    return dbgTraceExit;
+  }
+
+  /* Init SubTarget Info */
+  virtual MemLayout *CreateMemLayout(MemPool &mp, BECommon &b,
+      MIRFunction &f, MapleAllocator &mallocator) const = 0;
+  virtual RegisterInfo *CreateRegisterInfo(MemPool &mp, MapleAllocator &mallocator) const = 0;
+
+  /* Init SubTarget phase */
+  virtual LiveAnalysis *CreateLiveAnalysis(MemPool &mp, CGFunc &f) const = 0;
+  virtual ReachingDefinition *CreateReachingDefinition(MemPool &mp, CGFunc &f) const {
+    return nullptr;
+  };
+  virtual MoveRegArgs *CreateMoveRegArgs(MemPool &mp, CGFunc &f) const  = 0;
+  virtual AlignAnalysis *CreateAlignAnalysis(MemPool &mp, CGFunc &f) const = 0;
+  virtual MPISel *CreateMPIsel(MemPool &mp, CGFunc &f) const {
+    return nullptr;
+  }
+  virtual Standardize *CreateStandardize(MemPool &mp, CGFunc &f) const {
+    return nullptr;
+  }
+
+  /* Init SubTarget optimization */
+  virtual CGSSAInfo *CreateCGSSAInfo(MemPool &mp, CGFunc &f, DomAnalysis &da, MemPool &tmp) const = 0;
+  virtual LiveIntervalAnalysis *CreateLLAnalysis(MemPool &mp, CGFunc &f) const = 0;
+  virtual PhiEliminate *CreatePhiElimintor(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const = 0;
+  virtual CGProp *CreateCGProp(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo, LiveIntervalAnalysis &ll) const = 0;
+  virtual CGDce *CreateCGDce(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const = 0;
+  virtual ValidBitOpt *CreateValidBitOpt(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const = 0;
+  virtual RedundantComputeElim *CreateRedundantCompElim(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const = 0;
+  virtual TailCallOpt *CreateCGTailCallOpt(MemPool &mp, CGFunc &f) const = 0;
+  virtual LocalOpt *CreateLocalOpt(MemPool &mp, CGFunc &f, ReachingDefinition&) const {
+    return nullptr;
+  };
+  virtual CFGOptimizer *CreateCFGOptimizer(MemPool &mp, CGFunc &f) const {
+    return nullptr;
+  }
+  virtual CGProfGen *CreateCGProfGen(MemPool &mp, CGFunc &f) const {
+    return nullptr;
+  }
+
+  virtual Rematerializer *CreateRematerializer(MemPool &mp) const {
+    return nullptr;
+  }
+
+  /* Object map generation helper */
+  std::vector<int64> GetReferenceOffsets64(const BECommon &beCommon, MIRStructType &structType) const;
+
+  void SetGP(MIRSymbol *sym) {
+    fileGP = sym;
+  }
+  MIRSymbol *GetGP() const {
+    return fileGP;
+  }
+
+  static bool IsInFuncWrapLabels(MIRFunction *func) {
+    return funcWrapLabels.find(func) != funcWrapLabels.end();
+  }
+
+  static void SetFuncWrapLabels(MIRFunction *func, const std::pair<LabelIdx, LabelIdx> labels) {
+    if (!IsInFuncWrapLabels(func)) {
+      funcWrapLabels[func] = labels;
+    }
+  }
+
+  static std::map<MIRFunction*, std::pair<LabelIdx, LabelIdx>> &GetFuncWrapLabels() {
+    return funcWrapLabels;
+  }
+  static void SetCurCGFunc(CGFunc &cgFunc) {
+    currentCGFunction = &cgFunc;
+  }
+
+  static const CGFunc *GetCurCGFunc() {
+    return currentCGFunction;
+  }
+
+  static CGFunc *GetCurCGFuncNoConst() {
+    return currentCGFunction;
+  }
+
+  virtual const InsnDesc &GetTargetMd(MOperator mOp) const = 0;
+  virtual bool IsEffectiveCopy(Insn &insn) const = 0;
+  virtual bool IsTargetInsn(MOperator mOp) const = 0;
+  virtual bool IsClinitInsn(MOperator mOp) const = 0;
+  virtual void DumpTargetOperand(Operand &opnd, const OpndDesc &opndDesc) const = 0;
+
+ protected:
+  MIRModule *GetMIRModule() const {
+    return mirModule;
+  }
+
+  MemPool *memPool = nullptr;
+  MapleAllocator allocator;
+
+ private:
+  MIRModule *mirModule = nullptr;
+  Emitter *emitter = nullptr;
+  LabelIDOrder labelOrderCnt;
+  static CGFunc *currentCGFunction;  /* current cg function being compiled */
+  CGOptions cgOption;
+  MIRSymbol *dbgTraceEnter = nullptr;
+  MIRSymbol *dbgTraceExit = nullptr;
+  MIRSymbol *dbgFuncProfile = nullptr;
+  MIRSymbol *fileGP;  /* for lmbc, one local %GP per file */
+  static std::map<MIRFunction *, std::pair<LabelIdx, LabelIdx>> funcWrapLabels;
+  bool isLibcore = false;
+  bool isLmbc = false;
+};  /* class CG */
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_CG_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_cdg.h b/src/mapleall/maple_be/include/cg/cg_cdg.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd2a5c48c37ad4af2c4fbc1f31ddb76cff6e76f7
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_cdg.h
@@ -0,0 +1,602 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/*
+ * The file defines the data structures of Control Dependence Graph(CDG).
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CG_CDG_H
+#define MAPLEBE_INCLUDE_CG_CG_CDG_H
+
+#include <string>
+#include "cgfunc.h"
+#include "mpl_number.h"
+#include "deps.h"
+#include "mempool_allocator.h"
+
+namespace maplebe {
+class CDGNode;
+class CDGEdge;
+class CDGRegion;
+using CDGNodeId = utils::Index<CDGNode>;
+using CDGRegionId = utils::Index<CDGRegion>;
+
+/* Encapsulation of BB */
+class CDGNode {
+ public:
+  CDGNode(CDGNodeId nId, BB &bb, MapleAllocator &alloc)
+      : id(nId), bb(&bb), outEdges(alloc.Adapter()), inEdges(alloc.Adapter()),
+        topoPreds(alloc.Adapter()), lastComments(alloc.Adapter()), predCDGNodes(alloc.Adapter()) {}
+  virtual ~CDGNode() = default;
+
+  BB *GetBB() {
+    return bb;
+  }
+
+  BB *GetBB() const {
+    return bb;
+  }
+
+  CDGNodeId GetNodeId() {
+    return id;
+  }
+
+  CDGNodeId GetNodeId() const {
+    return id;
+  }
+
+  void SetNodeId(CDGNodeId nId) {
+    id = nId;
+  }
+
+  CDGRegion *GetRegion() {
+    return region;
+  }
+
+  CDGRegion *GetRegion() const {
+    return region;
+  }
+
+  void SetRegion(CDGRegion &cdgRegion) {
+    region = &cdgRegion;
+  }
+
+  bool IsEntryNode() const {
+    return isEntryNode;
+  }
+
+  void SetEntryNode() {
+    isEntryNode = true;
+  }
+
+  bool IsExitNode() const {
+    return isExitNode;
+  }
+
+  void SetExitNode() {
+    isExitNode = true;
+  }
+
+  void AddOutEdges(CDGEdge *edge) {
+    outEdges.emplace_back(edge);
+  }
+
+  MapleVector<CDGEdge*> &GetAllOutEdges() {
+    return outEdges;
+  }
+
+  void AddInEdges(CDGEdge *edge) {
+    inEdges.emplace_back(edge);
+  }
+
+  MapleVector<CDGEdge*> &GetAllInEdges() {
+    return inEdges;
+  }
+
+  std::size_t GetOutEdgesNum() const {
+    return outEdges.size();
+  }
+
+  std::size_t GetInEdgesNum() const {
+    return inEdges.size();
+  }
+
+  bool HasAmbiRegs() {
+    return hasAmbiRegs;
+  }
+
+  void SetHasAmbiRegs(bool flag) {
+    hasAmbiRegs = flag;
+  }
+
+  Insn *GetMembarInsn() {
+    return membarInsn;
+  }
+
+  void SetMembarInsn(Insn *insn) {
+    membarInsn = insn;
+  }
+
+  Insn *GetLastCallInsn() {
+    return lastCallInsn;
+  }
+
+  void SetLastCallInsn(Insn *callInsn) {
+    lastCallInsn = callInsn;
+  }
+
+  Insn *GetLastFrameDefInsn() {
+    return lastFrameDef;
+  }
+
+  void SetLastFrameDefInsn(Insn *frameInsn) {
+    lastFrameDef = frameInsn;
+  }
+
+  MapleVector<CDGNode*> &GetTopoPreds() {
+    return topoPreds;
+  }
+
+  void AddTopoPred(CDGNode *pred) {
+    (void)topoPreds.emplace_back(pred);
+  }
+
+  void RemoveTopoPred(CDGNode *pred) {
+    auto it = std::find(topoPreds.begin(), topoPreds.end(), pred);
+    if (it != topoPreds.end()) {
+      (void)topoPreds.erase(it);
+    }
+  }
+
+  void InitDataDepInfo(MemPool &tmpMp, MapleAllocator &tmpAlloc, uint32 maxRegNum) {
+    regDefs = tmpMp.New<MapleVector<Insn*>>(tmpAlloc.Adapter());
+    regUses = tmpMp.New<MapleVector<RegList*>>(tmpAlloc.Adapter());
+    stackUses = tmpMp.New<MapleVector<Insn*>>(tmpAlloc.Adapter());
+    stackDefs = tmpMp.New<MapleVector<Insn*>>(tmpAlloc.Adapter());
+    heapUses = tmpMp.New<MapleVector<Insn*>>(tmpAlloc.Adapter());
+    heapDefs = tmpMp.New<MapleVector<Insn*>>(tmpAlloc.Adapter());
+    mayThrows = tmpMp.New<MapleVector<Insn*>>(tmpAlloc.Adapter());
+    ambiInsns = tmpMp.New<MapleVector<Insn*>>(tmpAlloc.Adapter());
+    pseudoSepNodes = tmpMp.New<MapleVector<DepNode*>>(tmpAlloc.Adapter());
+    ehInRegs = tmpMp.New<MapleSet<regno_t>>(tmpAlloc.Adapter());
+
+    regDefs->resize(maxRegNum);
+    regUses->resize(maxRegNum);
+  }
+
+  void ClearDataDepInfo() {
+    membarInsn = nullptr;
+    lastCallInsn = nullptr;
+    lastFrameDef = nullptr;
+    lastComments.clear();
+    predCDGNodes.clear();
+
+    regDefs = nullptr;
+    regUses = nullptr;
+    stackUses = nullptr;
+    stackDefs = nullptr;
+    heapUses = nullptr;
+    heapDefs = nullptr;
+    mayThrows = nullptr;
+    ambiInsns = nullptr;
+    pseudoSepNodes = nullptr;
+    ehInRegs = nullptr;
+  }
+
+  void ClearDepDataVec() {
+    membarInsn = nullptr;
+    lastCallInsn = nullptr;
+    lastFrameDef = nullptr;
+
+    for (auto &regDef : *regDefs) {
+      regDef = nullptr;
+    }
+    for (auto &regUse : *regUses) {
+      regUse = nullptr;
+    }
+
+    stackUses->clear();
+    stackDefs->clear();
+    heapUses->clear();
+    heapDefs->clear();
+    mayThrows->clear();
+    ambiInsns->clear();
+  }
+
+  Insn *GetLatestDefInsn(regno_t regNO) {
+    return (*regDefs)[regNO];
+  }
+
+  void SetLatestDefInsn(regno_t regNO, Insn *defInsn) {
+    (*regDefs)[regNO] = defInsn;
+  }
+
+  RegList *GetUseInsnChain(regno_t regNO) {
+    return (*regUses)[regNO];
+  }
+
+  void AppendUseInsnChain(regno_t regNO, Insn *useInsn, MemPool &mp, bool beforeRA) {
+    CHECK_FATAL(useInsn != nullptr, "invalid useInsn");
+    auto *newUse = mp.New<RegList>();
+    newUse->insn = useInsn;
+    newUse->next = nullptr;
+
+    RegList *headUse = (*regUses)[regNO];
+    if (headUse == nullptr) {
+      (*regUses)[regNO] = newUse;
+      if (beforeRA) {
+        Insn *defInsn = (*regDefs)[regNO];
+        if (defInsn != nullptr) {
+          DepNode *depNode = defInsn->GetDepNode();
+          depNode->SetRegDefs(regNO, newUse);
+        }
+      }
+    } else {
+      while (headUse->next != nullptr) {
+        headUse = headUse->next;
+      }
+      headUse->next = newUse;
+    }
+  }
+
+  void ClearUseInsnChain(regno_t regNO) {
+    (*regUses)[regNO] = nullptr;
+  }
+
+  MapleVector<Insn*> &GetStackUseInsns() {
+    return *stackUses;
+  }
+
+  void AddStackUseInsn(Insn *stackInsn) {
+    stackUses->emplace_back(stackInsn);
+  }
+
+  MapleVector<Insn*> &GetStackDefInsns() {
+    return *stackDefs;
+  }
+
+  void AddStackDefInsn(Insn *stackInsn) {
+    stackDefs->emplace_back(stackInsn);
+  }
+
+  MapleVector<Insn*> &GetHeapUseInsns() {
+    return *heapUses;
+  }
+
+  void AddHeapUseInsn(Insn *heapInsn) {
+    heapUses->emplace_back(heapInsn);
+  }
+
+  MapleVector<Insn*> &GetHeapDefInsns() {
+    return *heapDefs;
+  }
+
+  void AddHeapDefInsn(Insn *heapInsn) {
+    heapDefs->emplace_back(heapInsn);
+  }
+
+  MapleVector<Insn*> &GetMayThrowInsns() {
+    return *mayThrows;
+  }
+
+  void AddMayThrowInsn(Insn *throwInsn) {
+    mayThrows->emplace_back(throwInsn);
+  }
+
+  MapleVector<Insn*> &GetAmbiguousInsns() {
+    return *ambiInsns;
+  }
+
+  void AddAmbiguousInsn(Insn *ambiInsn) {
+    ambiInsns->emplace_back(ambiInsn);
+  }
+
+  MapleVector<Insn*> &GetLastComments() {
+    return lastComments;
+  }
+
+  void AddCommentInsn(Insn *commentInsn) {
+    lastComments.emplace_back(commentInsn);
+  }
+
+  void CopyAndClearComments(MapleVector<Insn*> &comments) {
+    lastComments = comments;
+    comments.clear();
+  }
+
+  void ClearLastComments() {
+    lastComments.clear();
+  }
+
+  void AddPseudoSepNodes(DepNode *node) {
+    pseudoSepNodes->emplace_back(node);
+  }
+
+  MapleSet<regno_t> &GetEhInRegs() {
+    return *ehInRegs;
+  }
+
+  bool operator!=(const CDGNode &node) {
+    if (this != &node) {
+      return true;
+    }
+    if (this->id != node.GetNodeId() || this->bb != node.GetBB() || this->region != node.GetRegion()) {
+      return true;
+    }
+    if (this->GetInEdgesNum() != node.GetInEdgesNum() || this->GetOutEdgesNum() != node.GetOutEdgesNum()) {
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  CDGNodeId id;  // same to bbId
+  BB *bb = nullptr;
+  CDGRegion *region = nullptr;
+  bool isEntryNode = false;
+  bool isExitNode = false;
+  MapleVector<CDGEdge*> outEdges;
+  MapleVector<CDGEdge*> inEdges;
+  /*
+   * The following structures are used to record data flow infos in building data dependence among insns
+   */
+  bool hasAmbiRegs = false;
+  Insn *membarInsn = nullptr;
+  Insn *lastCallInsn = nullptr;
+  Insn *lastFrameDef = nullptr;
+  MapleVector<CDGNode*> topoPreds; // For visit nodes by topological order in the region, it will change dynamically
+  MapleVector<Insn*> *regDefs = nullptr; // the index is regNO, record the latest defInsn in the curBB
+  MapleVector<RegList*> *regUses = nullptr; // the index is regNO
+  MapleVector<Insn*> *stackUses = nullptr;
+  MapleVector<Insn*> *stackDefs = nullptr;
+  MapleVector<Insn*> *heapUses = nullptr;
+  MapleVector<Insn*> *heapDefs = nullptr;
+  MapleVector<Insn*> *mayThrows = nullptr;
+  MapleVector<Insn*> *ambiInsns = nullptr;
+  MapleVector<DepNode*> *pseudoSepNodes = nullptr;
+  MapleSet<regno_t> *ehInRegs = nullptr;
+  MapleVector<Insn*> lastComments;
+  MapleVector<CDGNode*> predCDGNodes; // predecessor nodes of the curBB in CFG
+};
+
+class CDGEdge {
+ public:
+  CDGEdge(CDGNode &from, CDGNode &to, int32 cond) : fromNode(from), toNode(to), condition(cond) {}
+  virtual ~CDGEdge() = default;
+
+  CDGNode &GetFromNode() {
+    return fromNode;
+  }
+
+  CDGNode &GetFromNode() const {
+    return fromNode;
+  }
+
+  void SetFromNode(CDGNode &from) {
+    fromNode = from;
+  }
+
+  CDGNode &GetToNode() {
+    return toNode;
+  }
+
+  CDGNode &GetToNode() const {
+    return toNode;
+  }
+
+  void SetToNode(CDGNode &to) {
+    toNode = to;
+  }
+
+  int32 GetCondition() const {
+    return condition;
+  }
+
+  void SetCondition(int32 cond) {
+    condition = cond;
+  }
+
+  /* for checking same control dependence */
+  bool operator==(const CDGEdge &edge) {
+    if (this == &edge) {
+      return true;
+    }
+    if (this->fromNode != edge.GetFromNode()) {
+      return false;
+    }
+    if (this->toNode != edge.GetToNode()) {
+      return false;
+    }
+    if (this->condition != edge.GetCondition()) {
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  CDGNode &fromNode;
+  CDGNode &toNode;
+  /*
+   * allocate different COND number to different succ edges of the same fromBB
+   * default value is -1 indicated no cond.
+   */
+  int32 condition;
+};
+
+/*
+ * A region consists of nodes with the same control dependence sets
+ */
+class CDGRegion {
+ public:
+  CDGRegion(CDGRegionId rId, MapleAllocator &alloc)
+      : id(rId), memberNodes(alloc.Adapter()), cdEdges(alloc.Adapter()) {}
+  virtual ~CDGRegion() = default;
+
+  CDGRegionId GetRegionId() {
+    return id;
+  }
+
+  MapleVector<CDGNode*> &GetRegionNodes() {
+    return memberNodes;
+  }
+
+  std::size_t GetRegionNodeSize() const {
+    return memberNodes.size();
+  }
+
+  // Ensure the node is unique
+  void AddCDGNode(CDGNode *node) {
+    if (std::find(memberNodes.cbegin(), memberNodes.cend(), node) == memberNodes.cend()) {
+      memberNodes.emplace_back(node);
+    }
+  }
+
+  void RemoveCDGNode(CDGNode *node) {
+    auto it = std::find(memberNodes.begin(), memberNodes.end(), node);
+    if (it == memberNodes.end()) {
+      return;
+    }
+    (void)memberNodes.erase(it);
+  }
+
+  void ClearMemberNodes() {
+    memberNodes.clear();
+  }
+
+  MapleVector<CDGEdge*> &GetCDEdges() {
+    return cdEdges;
+  }
+
+  void AddCDEdge(CDGEdge *edge) {
+    cdEdges.emplace_back(edge);
+  }
+
+  void AddCDEdgeSet(MapleVector<CDGEdge*> &cds) {
+    for (auto &cd : cds) {
+      cdEdges.emplace_back(cd);
+    }
+  }
+
+  uint32 GetMaxBBIdInRegion() {
+    uint32 maxId = 0;
+    for (auto node : memberNodes) {
+      maxId = (node->GetNodeId() > maxId ? static_cast<uint32>(node->GetNodeId()) : maxId);
+    }
+    return maxId;
+  }
+
+ private:
+  CDGRegionId id;
+  MapleVector<CDGNode*> memberNodes;   // the nodes in CDGRegion by out-of-order
+  MapleVector<CDGEdge*> cdEdges;   // the control dependence sets of the parent node
+};
+
+/*
+ * Forward Control Dependence Graph
+ * which does not compute the control dependence on the back edges
+ */
+class FCDG {
+ public:
+  FCDG(CGFunc &f, MapleAllocator &alloc)
+      : nodes(f.GetAllBBSize(), alloc.Adapter()),
+        fcds(alloc.Adapter()), regions(f.GetAllBBSize() + 1, alloc.Adapter()) {}
+  virtual ~FCDG() = default;
+
+  MapleVector<CDGNode*> &GetAllFCDGNodes() {
+    return nodes;
+  }
+
+  std::size_t GetFCDGNodeSize() const {
+    return nodes.size();
+  }
+
+  CDGNode *GetCDGNodeFromId(CDGNodeId id) {
+    return nodes[id];
+  }
+
+  MapleVector<CDGEdge*> &GetAllFCDGEdges() {
+    return fcds;
+  }
+
+  MapleVector<CDGRegion*> &GetAllRegions() {
+    return regions;
+  }
+
+  CDGRegion *GetRegionFromId(CDGRegionId id) {
+    return regions[id];
+  }
+
+  // Ensure the node is unique
+  void AddFCDGNode(CDGNode &node) {
+    if (nodes[node.GetNodeId()] == nullptr) {
+      nodes[node.GetNodeId()] = &node;
+    }
+  }
+
+  void AddFCDGEdge(CDGEdge *edge) {
+    fcds.emplace_back(edge);
+  }
+
+  // Ensure the region is unique
+  void AddRegion(CDGRegion &region) {
+    if (regions[region.GetRegionId()] == nullptr) {
+      regions[region.GetRegionId()] = &region;
+    }
+  }
+
+  void RemoveRegionById(CDGRegionId id) {
+    regions[id] = nullptr;
+  }
+
+  /* Provide interfaces for global scheduling */
+
+ private:
+  MapleVector<CDGNode*> nodes; // all CDGNodes in FCDG that use nodeId as the index
+  MapleVector<CDGEdge*> fcds; // all forward-control-dependence in FCDG
+  MapleVector<CDGRegion*> regions;   // all regions in FCDG that use CDGRegionId as the index
+};
+
+struct CDGOutEdgeComparator {
+  bool operator()(const CDGEdge &outEdge1, const CDGEdge &outEdge2) const {
+    const CDGNode &toNode1 = outEdge1.GetToNode();
+    const CDGNode &toNode2 = outEdge2.GetToNode();
+    return toNode1.GetNodeId() < toNode2.GetNodeId();
+  }
+};
+
+struct CDGInEdgeComparator {
+  bool operator()(const CDGEdge &inEdge1, const CDGEdge &inEdge2) const {
+    const CDGNode &fromNode1 = inEdge1.GetFromNode();
+    const CDGNode &fromNode2 = inEdge2.GetToNode();
+    return fromNode1.GetNodeId() < fromNode2.GetNodeId();
+  }
+};
+} /* namespace maplebe */
+
+namespace std {
+template <>
+struct hash<maplebe::CDGNodeId> {
+  size_t operator()(const maplebe::CDGNodeId &nId) const {
+    return nId;
+  }
+};
+
+template <>
+struct hash<maplebe::CDGRegionId> {
+  size_t operator()(const maplebe::CDGRegionId &rId) const {
+    return rId;
+  }
+};
+}
+#endif /* MAPLEBE_INCLUDE_CG_CG_CDG_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_cfg.h b/src/mapleall/maple_be/include/cg/cg_cfg.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2b3398408ae77ab144a3a218541d70a8f4a4ad8
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_cfg.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CG_CFG_H
+#define MAPLEBE_INCLUDE_CG_CG_CFG_H
+#include "eh_func.h"
+#include "cgbb.h"
+
+namespace maplebe {
+class InsnVisitor {
+ public:
+  explicit InsnVisitor(CGFunc &func) : cgFunc(&func) {}
+
+  virtual ~InsnVisitor() = default;
+  CGFunc *GetCGFunc() const {
+    return cgFunc;
+  }
+
+  /*
+   * Precondition:
+   * The last instruction in bb is either conditional or unconditional jump.
+   *
+   * The jump target of bb is modified to the location specified by targetLabel.
+   */
+  virtual void ModifyJumpTarget(LabelIdx targetLabel, BB &bb) = 0;
+
+  /*
+   * Precondition:
+   * The last instruction in bb is either conditional or unconditional jump.
+   *
+   * The jump target of bb is modified to the location specified by targetOperand.
+   */
+  virtual void ModifyJumpTarget(Operand &targetOperand, BB &bb) = 0;
+
+  /*
+   * Precondition:
+   * The last instruction in bb is either a conditional or an unconditional jump.
+   * The last instruction in newTarget is an unconditional jump.
+   *
+   * The jump target of bb is modified to newTarget's jump target.
+   */
+  virtual void ModifyJumpTarget(BB &newTarget, BB &bb) = 0;
+  /* Check if it requires to add extra gotos when relocate bb */
+  virtual Insn *CloneInsn(Insn &originalInsn) = 0;
+  /* Create a new virtual register operand which has the same type and size as the given one. */
+  virtual RegOperand *CreateVregFromReg(const RegOperand &reg) = 0;
+  virtual LabelIdx GetJumpLabel(const Insn &insn) const = 0;
+  virtual bool IsCompareInsn(const Insn &insn) const = 0;
+  virtual bool IsCompareAndBranchInsn(const Insn &insn) const = 0;
+  virtual bool IsAddOrSubInsn(const Insn &insn) const = 0;
+
+  virtual void ReTargetSuccBB(BB &bb, LabelIdx newTarget) const = 0;
+  virtual void FlipIfBB(BB &bb, LabelIdx ftLabel) const = 0;
+  virtual BB *CreateGotoBBAfterCondBB(BB &bb, BB &fallthru, bool isTargetFallthru) const = 0;
+
+ private:
+  CGFunc *cgFunc;
+};  /* class InsnVisitor; */
+
+class CGCFG {
+ public:
+  explicit CGCFG(CGFunc &cgFunc) : cgFunc(&cgFunc) {}
+
+  ~CGCFG() = default;
+
+  void BuildCFG();
+  void CheckCFG();
+  void CheckCFGFreq();
+
+  void InitInsnVisitor(CGFunc &func) const;
+  InsnVisitor *GetInsnModifier() const {
+    return insnVisitor;
+  }
+
+  static bool AreCommentAllPreds(const BB &bb);
+  bool CanMerge(const BB &merger, const BB &mergee) const;
+  bool BBJudge(const BB &first, const BB &second) const;
+  /*
+   * Merge all instructions in mergee into merger, each BB's successors and
+   * predecessors should be modified accordingly.
+   */
+  static void MergeBB(BB &merger, BB &mergee, CGFunc &func);
+
+  /*
+   * Remove a BB from its position in the CFG.
+   * Prev, next, preds and sucs are all modified accordingly.
+   */
+  void RemoveBB(BB &curBB, bool isGotoIf = false) const;
+  /* Skip the successor of bb, directly jump to bb's successor'ssuccessor */
+  void RetargetJump(BB &srcBB, BB &targetBB) const;
+
+  /* Loop up if the given label is in the exception tables in LSDA */
+  static bool InLSDA(LabelIdx label, const EHFunc *ehFunc);
+  static bool InSwitchTable(LabelIdx label, const CGFunc &func);
+
+  RegOperand *CreateVregFromReg(const RegOperand &pReg) const;
+  Insn *CloneInsn(Insn &originalInsn) const;
+  static BB *GetTargetSuc(BB &curBB, bool branchOnly = false, bool isGotoIf = false);
+  bool IsCompareAndBranchInsn(const Insn &insn) const;
+  bool IsAddOrSubInsn(const Insn &insn) const;
+
+  Insn *FindLastCondBrInsn(BB &bb) const;
+  static void FindAndMarkUnreachable(CGFunc &func);
+  void FlushUnReachableStatusAndRemoveRelations(BB &bb, const CGFunc &func) const;
+  void MarkLabelTakenBB() const;
+  void UnreachCodeAnalysis() const;
+  void FindWillExitBBs(BB *bb, std::set<BB*, BBIdCmp> *visitedBBs);
+  void WontExitAnalysis();
+  BB *FindLastRetBB();
+
+  void UpdatePredsSuccsAfterSplit(BB &pred, BB &succ, BB &newBB) const;
+  BB *BreakCriticalEdge(BB &pred, BB &succ);
+  void ReverseCriticalEdge(BB &cbb);
+ /* cgcfgvisitor */
+ private:
+  CGFunc *cgFunc = nullptr;
+  static InsnVisitor *insnVisitor;
+  static void MergeBB(BB &merger, BB &mergee);
+};  /* class CGCFG */
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgHandleCFG, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_CG_CFG_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_critical_edge.h b/src/mapleall/maple_be/include/cg/cg_critical_edge.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0c7159a18539f1cf675e04f7e29b2c1a82c808e
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_critical_edge.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CRITICAL_EDGE_H
+#define MAPLEBE_INCLUDE_CG_CRITICAL_EDGE_H
+
+#include "cg.h"
+#include "cgbb.h"
+#include "insn.h"
+
+namespace maplebe {
+class CriticalEdge {
+ public:
+  CriticalEdge(CGFunc &func, MemPool &mem)
+      : cgFunc(&func),
+        alloc(&mem),
+        criticalEdges(alloc.Adapter()),
+        newBBcreated(alloc.Adapter()) {}
+
+  ~CriticalEdge() = default;
+
+  void CollectCriticalEdges();
+  void SplitCriticalEdges();
+  MapleSet<uint32> CopyNewBBInfo() {
+    return newBBcreated;
+  }
+
+ private:
+  CGFunc *cgFunc;
+  MapleAllocator alloc;
+  MapleVector<std::pair<BB*, BB*>> criticalEdges;
+  MapleSet<uint32> newBBcreated;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgCriticalEdge, maplebe::CGFunc)
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_CRITICAL_EDGE_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_dce.h b/src/mapleall/maple_be/include/cg/cg_dce.h
new file mode 100644
index 0000000000000000000000000000000000000000..af9fd918abe75023c14c80ffe86490d1e8cdab45
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_dce.h
@@ -0,0 +1,59 @@
+/*
+* Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+    * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef MAPLEBE_INCLUDE_CG_DCE_H
+#define MAPLEBE_INCLUDE_CG_DCE_H
+#include "cgfunc.h"
+#include "cg_ssa.h"
+
+namespace maplebe {
+/* dead code elimination */
+class CGDce {
+ public:
+  CGDce(MemPool &mp, CGFunc &f, CGSSAInfo &sInfo) : memPool(&mp), cgFunc(&f), ssaInfo(&sInfo) {}
+  virtual ~CGDce() = default;
+
+  void DoDce();
+  /* provide public use in ssa opt */
+  virtual bool RemoveUnuseDef(VRegVersion &defVersion) = 0;
+  CGSSAInfo *GetSSAInfo() {
+    return ssaInfo;
+  }
+
+ protected:
+  MemPool *memPool;
+  CGFunc *cgFunc;
+  CGSSAInfo *ssaInfo;
+};
+
+class DeleteRegUseVisitor : public OperandVisitorBase,
+                            public OperandVisitors<RegOperand, ListOperand, MemOperand>,
+                            public OperandVisitor<PhiOperand> {
+ public:
+  DeleteRegUseVisitor(CGSSAInfo &cgSSAInfo, uint32 dInsnID) : deleteInsnId(dInsnID), ssaInfo(&cgSSAInfo) {}
+  virtual ~DeleteRegUseVisitor() = default;
+
+ protected:
+  CGSSAInfo *GetSSAInfo() {
+    return ssaInfo;
+  }
+  uint32 deleteInsnId;
+ private:
+  CGSSAInfo *ssaInfo;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgDce, maplebe::CGFunc)
+}
+#endif /* MAPLEBE_INCLUDE_CG_DCE_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_dominance.h b/src/mapleall/maple_be/include/cg/cg_dominance.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e7c370cf083701e302368cc012bc132783ac189
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_dominance.h
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_DOM_H
+#define MAPLEBE_INCLUDE_CG_DOM_H
+
+#include "cg_phase.h"
+#include "insn.h"
+#include "cgbb.h"
+#include "datainfo.h"
+#include "maple_phase.h"
+
+namespace maplebe {
+class DominanceBase : public AnalysisResult {
+ public:
+  DominanceBase(CGFunc &func, MemPool &memPool, MemPool &tmpPool,  MapleVector<BB *> &bbVec, BB &commonEntryBB,
+                BB &commonExitBB)
+      : AnalysisResult(&memPool),
+        domAllocator(&memPool),
+        tmpAllocator(&tmpPool),
+        bbVec(bbVec),
+        cgFunc(func),
+        commonEntryBB(commonEntryBB),
+        commonExitBB(commonExitBB) {}
+
+  ~DominanceBase() override = default;
+
+  BB &GetCommonEntryBB() const {
+    return commonEntryBB;
+  }
+
+  BB &GetCommonExitBB() const {
+    return commonExitBB;
+  }
+
+ protected:
+  bool CommonEntryBBIsPred(const BB &bb) const;
+  MapleAllocator domAllocator;  // stores the analysis results
+  MapleAllocator tmpAllocator;  // can be freed after dominator computation
+  MapleVector<BB *> &bbVec;
+  CGFunc &cgFunc;
+  BB &commonEntryBB;
+  BB &commonExitBB;
+};
+
+class DomAnalysis : public DominanceBase {
+ public:
+  DomAnalysis(CGFunc &func, MemPool &memPool, MemPool &tmpPool,  MapleVector<BB *> &bbVec, BB &commonEntryBB,
+              BB &commonExitBB)
+      : DominanceBase(func, memPool, tmpPool, bbVec, commonEntryBB, commonExitBB),
+        postOrderIDVec(bbVec.size() + 1, -1, tmpAllocator.Adapter()),
+        reversePostOrder(tmpAllocator.Adapter()),
+        doms(bbVec.size() + 1, nullptr, domAllocator.Adapter()),
+        domFrontier(bbVec.size() + 1, MapleVector<uint32>(domAllocator.Adapter()), domAllocator.Adapter()),
+        domChildren(bbVec.size() + 1, MapleVector<uint32>(domAllocator.Adapter()), domAllocator.Adapter()),
+        iterDomFrontier(bbVec.size() + 1, MapleSet<uint32>(domAllocator.Adapter()), domAllocator.Adapter()),
+        dtPreOrder(bbVec.size() + 1, 0, domAllocator.Adapter()),
+        dtDfn(bbVec.size() + 1, -1, domAllocator.Adapter()),
+        dtDfnOut(bbVec.size() + 1, -1, domAllocator.Adapter()) {}
+  ~DomAnalysis() override = default;
+
+  void Compute();
+  void Dump();
+
+  void GenPostOrderID();
+  void ComputeDominance();
+  void ComputeDomFrontiers();
+  void ComputeDomChildren();
+  void GetIterDomFrontier(const BB *bb, MapleSet<uint32> *dfset, uint32 bbidMarker, std::vector<bool> &visitedMap);
+  void ComputeIterDomFrontiers();
+  uint32 ComputeDtPreorder(const BB &bb, uint32 &num);
+  bool Dominate(const BB &bb1, const BB &bb2);  // true if bb1 dominates bb2
+
+  MapleVector<BB *> &GetReversePostOrder() {
+    return reversePostOrder;
+  }
+
+  MapleVector<uint32> &GetDtPreOrder() {
+    return dtPreOrder;
+  }
+
+  uint32 GetDtPreOrderItem(size_t idx) const {
+    return dtPreOrder[idx];
+  }
+
+  size_t GetDtPreOrderSize() const {
+    return dtPreOrder.size();
+  }
+
+  uint32 GetDtDfnItem(size_t idx) const {
+    return dtDfn[idx];
+  }
+
+  size_t GetDtDfnSize() const {
+    return dtDfn.size();
+  }
+
+  BB *GetDom(uint32 id) {
+    ASSERT(id < doms.size(), "bbid out of range");
+    return doms[id];
+  }
+  void SetDom(uint32 id, BB *bb) {
+    ASSERT(id < doms.size(), "bbid out of range");
+    doms[id] = bb;
+  }
+  size_t GetDomsSize() const {
+    return doms.size();
+  }
+
+  auto &GetDomFrontier(size_t idx) {
+    return domFrontier[idx];
+  }
+  bool HasDomFrontier(uint32 id, uint32 frontier) const {
+    return std::find(domFrontier[id].begin(), domFrontier[id].end(), frontier) != domFrontier[id].end();
+  }
+
+  size_t GetDomFrontierSize() const {
+    return domFrontier.size();
+  }
+
+  auto &GetDomChildren() {
+    return domChildren;
+  }
+
+  auto &GetDomChildren(size_t idx) {
+    return domChildren[idx];
+  }
+
+  auto &GetIdomFrontier(uint32 idx) {
+    return iterDomFrontier[idx];
+  }
+
+  size_t GetDomChildrenSize() const {
+    return domChildren.size();
+  }
+
+ private:
+  void PostOrderWalk(const BB &bb, int32 &pid, MapleVector<bool> &visitedMap);
+  BB *Intersect(BB &bb1, const BB &bb2);
+
+  MapleVector<int32> postOrderIDVec;   // index is bb id
+  MapleVector<BB *> reversePostOrder;  // an ordering of the BB in reverse postorder
+  MapleVector<BB *> doms;              // index is bb id; immediate dominator for each BB
+  MapleVector<MapleVector<uint32>> domFrontier;   // index is bb id
+  MapleVector<MapleVector<uint32>> domChildren;   // index is bb id; for dom tree
+  MapleVector<MapleSet<uint32>> iterDomFrontier;
+  MapleVector<uint32> dtPreOrder;              // ordering of the BBs in a preorder traversal of the dominator tree
+  MapleVector<uint32> dtDfn;                 // gives position of each BB in dt_preorder
+  MapleVector<uint32> dtDfnOut;                 // max position of all nodes in the sub tree of each BB in dt_preorder
+};
+
+class PostDomAnalysis : public DominanceBase {
+ public:
+  PostDomAnalysis(CGFunc &func, MemPool &memPool, MemPool &tmpPool,  MapleVector<BB *> &bbVec, BB &commonEntryBB,
+                  BB &commonExitBB)
+      : DominanceBase(func, memPool, tmpPool, bbVec, commonEntryBB, commonExitBB),
+        pdomPostOrderIDVec(bbVec.size() + 1, -1, tmpAllocator.Adapter()),
+        pdomReversePostOrder(tmpAllocator.Adapter()),
+        pdoms(bbVec.size() + 1, nullptr, domAllocator.Adapter()),
+        pdomFrontier(bbVec.size() + 1, MapleVector<uint32>(domAllocator.Adapter()), domAllocator.Adapter()),
+        pdomChildren(bbVec.size() + 1, MapleVector<uint32>(domAllocator.Adapter()), domAllocator.Adapter()),
+        iterPdomFrontier(bbVec.size() + 1, MapleSet<uint32>(domAllocator.Adapter()), domAllocator.Adapter()),
+        pdtPreOrder(bbVec.size() + 1, 0, domAllocator.Adapter()),
+        pdtDfn(bbVec.size() + 1, -1, domAllocator.Adapter()),
+        pdtDfnOut(bbVec.size() + 1, -1, domAllocator.Adapter()) {}
+
+  ~PostDomAnalysis() override = default;
+  void Compute();
+  void PdomGenPostOrderID();
+  void ComputePostDominance();
+  void ComputePdomFrontiers();
+  void ComputePdomChildren();
+  void GetIterPdomFrontier(const BB *bb, MapleSet<uint32> *dfset, uint32 bbidMarker, std::vector<bool> &visitedMap);
+  void ComputeIterPdomFrontiers();
+  uint32 ComputePdtPreorder(const BB &bb, uint32 &num);
+  bool PostDominate(const BB &bb1, const BB &bb2);  // true if bb1 postdominates bb2
+  void Dump();
+  void GeneratePdomTreeDot();
+
+  auto &GetPdomFrontierItem(size_t idx) {
+    return pdomFrontier[idx];
+  }
+
+  size_t GetPdomFrontierSize() const {
+    return pdomFrontier.size();
+  }
+
+  auto &GetIpdomFrontier(uint32 idx) {
+    return iterPdomFrontier[idx];
+  }
+
+  auto &GetPdomChildrenItem(size_t idx) {
+    return pdomChildren[idx];
+  }
+
+  std::size_t GetPdomTreeVecSize() const {
+    return pdomChildren.size();
+  }
+
+  void ResizePdtPreOrder(size_t n) {
+    pdtPreOrder.resize(n);
+  }
+
+  uint32 GetPdtPreOrderItem(size_t idx) const {
+    return pdtPreOrder[idx];
+  }
+
+  size_t GetPdtPreOrderSize() const {
+    return pdtPreOrder.size();
+  }
+
+  uint32 GetPdtDfnItem(size_t idx) const {
+    return pdtDfn[idx];
+  }
+
+  int32 GetPdomPostOrderIDVec(size_t idx) const {
+    return pdomPostOrderIDVec[idx];
+  }
+
+  BB *GetPdomReversePostOrder(size_t idx) {
+    return pdomReversePostOrder[idx];
+  }
+
+  MapleVector<BB *> &GetPdomReversePostOrder() {
+    return pdomReversePostOrder;
+  }
+
+  size_t GetPdomReversePostOrderSize() const {
+    return pdomReversePostOrder.size();
+  }
+
+  bool HasPdomFrontier(uint32 id, uint32 frontier) const {
+    return std::find(pdomFrontier[id].begin(), pdomFrontier[id].end(), frontier) != pdomFrontier[id].end();
+  }
+
+  BB *GetPdom(uint32 id) {
+    ASSERT(id < pdoms.size(), "bbid out of range");
+    return pdoms[id];
+  }
+  void SetPdom(uint32 id, BB *bb) {
+    ASSERT(id < pdoms.size(), "bbid out of range");
+    pdoms[id] = bb;
+  }
+
+ private:
+  void PdomPostOrderWalk(const BB &bb, int32 &pid, MapleVector<bool> &visitedMap);
+  BB *PdomIntersect(BB &bb1, const BB &bb2);
+
+  MapleVector<int32> pdomPostOrderIDVec;     // index is bb id
+  MapleVector<BB *> pdomReversePostOrder;    // an ordering of the BB in reverse postorder
+  MapleVector<BB *> pdoms;                   // index is bb id; immediate dominator for each BB
+  MapleVector<MapleVector<uint32>> pdomFrontier;  // index is bb id
+  MapleVector<MapleVector<uint32>> pdomChildren;  // index is bb id; for pdom tree
+  MapleVector<MapleSet<uint32>> iterPdomFrontier;
+  MapleVector<uint32> pdtPreOrder;             // ordering of the BBs in a preorder traversal of the post-dominator tree
+  MapleVector<uint32> pdtDfn;                // gives position of each BB in pdt_preorder
+  MapleVector<uint32> pdtDfnOut;                 // max position of all nodes in the sub tree of each BB in pdt_preorder
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgDomAnalysis, maplebe::CGFunc);
+  DomAnalysis *GetResult() {
+    return domAnalysis;
+  }
+  DomAnalysis *domAnalysis = nullptr;
+MAPLE_FUNC_PHASE_DECLARE_END
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPostDomAnalysis, maplebe::CGFunc);
+  PostDomAnalysis *GetResult() {
+    return pdomAnalysis;
+  }
+  PostDomAnalysis *pdomAnalysis = nullptr;
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_DOM_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_irbuilder.h b/src/mapleall/maple_be/include/cg/cg_irbuilder.h
new file mode 100644
index 0000000000000000000000000000000000000000..720936143004afc0433d533dabe2f992e297e881
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_irbuilder.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_IRBUILDER_H
+#define MAPLEBE_INCLUDE_CG_IRBUILDER_H
+
+#include "insn.h"
+#include "operand.h"
+
+namespace maplebe {
+class InsnBuilder {
+ public:
+  explicit InsnBuilder(MemPool &memPool) : mp(&memPool) {}
+  virtual ~InsnBuilder() {
+    mp = nullptr;
+  }
+
+  template <class Target>
+  Insn &BuildInsn(MOperator opCode) {
+    return BuildInsn(opCode, Target::kMd[opCode]);
+  }
+  Insn &BuildInsn(MOperator opCode, const InsnDesc &idesc);
+  Insn &BuildInsn(MOperator opCode, Operand &o0);
+  Insn &BuildInsn(MOperator opCode, Operand &o0, Operand &o1);
+  Insn &BuildInsn(MOperator opCode, Operand &o0, Operand &o1, Operand &o2);
+  Insn &BuildInsn(MOperator opCode, Operand &o0, Operand &o1, Operand &o2, Operand &o3);
+  Insn &BuildInsn(MOperator opCode, Operand &o0, Operand &o1, Operand &o2, Operand &o3, Operand &o4);
+  Insn &BuildInsn(MOperator opCode, std::vector<Operand*> &opnds);
+
+  Insn &BuildCfiInsn(MOperator opCode);
+  Insn &BuildDbgInsn(MOperator opCode);
+  Insn &BuildCommentInsn(CommentOperand &comment);
+  VectorInsn &BuildVectorInsn(MOperator opCode, const InsnDesc &idesc);
+
+  uint32 GetCreatedInsnNum () const {
+    return createdInsnNum;
+  }
+ protected:
+  MemPool *mp;
+ private:
+  void IncreaseInsnNum() {
+    createdInsnNum++;
+  }
+  uint32 createdInsnNum = 0;
+};
+
+constexpr uint32 kBaseVirtualRegNO = 200; /* avoid conflicts between virtual and physical */
+class OperandBuilder {
+ public:
+  explicit OperandBuilder(MemPool &mp, uint32 mirPregNum = 0)
+      : alloc(&mp), virtualRegNum(mirPregNum) {}
+
+  /* create an operand in cgfunc when no mempool is supplied */
+  ImmOperand &CreateImm(uint32 size, int64 value, MemPool *mp = nullptr);
+  ImmOperand &CreateImm(const MIRSymbol &symbol, int64 offset, int32 relocs, MemPool *mp = nullptr);
+  MemOperand &CreateMem(uint32 size, MemPool *mp = nullptr);
+  MemOperand &CreateMem(RegOperand &baseOpnd, int64 offset, uint32 size);
+  RegOperand &CreateVReg(uint32 size, RegType type, MemPool *mp = nullptr);
+  RegOperand &CreateVReg(regno_t vRegNO, uint32 size, RegType type, MemPool *mp = nullptr);
+  RegOperand &CreatePReg(regno_t pRegNO, uint32 size, RegType type, MemPool *mp = nullptr);
+  ListOperand &CreateList(MemPool *mp = nullptr);
+  FuncNameOperand &CreateFuncNameOpnd(MIRSymbol &symbol, MemPool *mp = nullptr);
+  LabelOperand &CreateLabel(const char *parent, LabelIdx idx, MemPool *mp = nullptr);
+  CommentOperand &CreateComment(const std::string &s, MemPool *mp = nullptr);
+  CommentOperand &CreateComment(const MapleString &s, MemPool *mp = nullptr);
+
+  uint32 GetCurrentVRegNum() const {
+    return virtualRegNum;
+  }
+
+ protected:
+  MapleAllocator alloc;
+
+ private:
+  uint32 virtualRegNum = 0;
+  /* reg bank for multiple use */
+};
+}
+#endif // MAPLEBE_INCLUDE_CG_IRBUILDER_H
diff --git a/src/mapleall/maple_be/include/cg/cg_occur.h b/src/mapleall/maple_be/include/cg/cg_occur.h
new file mode 100644
index 0000000000000000000000000000000000000000..6db5e0fdd393eca1f81973d776e8b5688c8463df
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_occur.h
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_CGOCCUR_H
+#define MAPLEBE_CG_INCLUDE_CGOCCUR_H
+#include "cg_dominance.h"
+
+// the data structures that represent occurrences and work candidates for PRE
+namespace maplebe {
+enum OccType {
+  kOccUndef,
+  kOccReal,
+  kOccDef,
+  kOccStore,
+  kOccPhiocc,
+  kOccPhiopnd,
+  kOccExit,
+  kOccUse,     // for use appearances when candidate is dassign
+  kOccMembar,  // for representing occurrence of memory barriers (use CgRealOcc)
+};
+
+class CgOccur {
+ public:
+  CgOccur(OccType ty, BB *bb, Insn *insn, Operand *opnd)
+      : occTy(ty),
+        cgBB(bb),
+        insn(insn),
+        opnd(opnd) {}
+
+  CgOccur(OccType ty, int cId, BB &bb, CgOccur *df) : occTy(ty), classID(cId), cgBB(&bb), def(df) {}
+  virtual ~CgOccur() = default;
+
+  bool IsDominate(DomAnalysis &dom, CgOccur &occ);
+  const BB *GetBB() const {
+    return cgBB;
+  }
+
+  BB *GetBB() {
+    return cgBB;
+  }
+
+  void SetBB(BB &bb) {
+    cgBB = &bb;
+  }
+
+  OccType GetOccType() const {
+    return occTy;
+  }
+
+  int GetClassID() const {
+    return classID;
+  }
+
+  void SetClassID(int id) {
+    classID = id;
+  }
+
+  const CgOccur *GetDef() const {
+    return def;
+  }
+
+  CgOccur *GetDef() {
+    return def;
+  }
+
+  void SetDef(CgOccur *define) {
+    def = define;
+  }
+
+  const Insn *GetInsn() const {
+    return insn;
+  }
+
+  Insn *GetInsn() {
+    return insn;
+  }
+
+  const Operand *GetOperand() const {
+    return opnd;
+  }
+
+  Operand *GetOperand() {
+    return opnd;
+  }
+
+  bool Processed() const {
+    return processed;
+  }
+
+  void SetProcessed(bool val) {
+    processed = val;
+  }
+
+  virtual CgOccur *GetPrevVersionOccur() {
+    CHECK_FATAL(false, "has no prev version occur");
+  }
+
+  virtual void SetPrevVersionOccur(CgOccur*) {
+    CHECK_FATAL(false, "has no prev version occur");
+  }
+
+  virtual void Dump() const {
+    if (occTy == kOccExit) {
+      LogInfo::MapleLogger() << "ExitOcc at bb " << GetBB()->GetId() << std::endl;
+    }
+  };
+
+ private:
+  OccType occTy = kOccUndef;  // kinds of occ
+  int classID = 0;    // class id
+  BB *cgBB = nullptr;      // the BB it occurs in
+  Insn *insn = nullptr;
+  Operand *opnd = nullptr;
+  CgOccur *def = nullptr;
+  bool processed = false;
+};
+
+class CgUseOcc : public CgOccur {
+ public:
+  CgUseOcc(BB *bb, Insn *insn, Operand *opnd)
+      : CgOccur(kOccUse, bb, insn, opnd),
+        needReload(false) {}
+
+  ~CgUseOcc() = default;
+
+  bool Reload() const {
+    return needReload;
+  }
+
+  void SetReload(bool val) {
+    needReload = val;
+  }
+
+  CgOccur *GetPrevVersionOccur() override {
+    return prevVersion;
+  }
+
+  void SetPrevVersionOccur(CgOccur *val) override {
+    prevVersion = val;
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "UseOcc " << GetClassID() << " at bb " << GetBB()->GetId() << ": "
+        << (needReload ? "need-reload, " : "not need-reload, ")
+        << "\n";
+  }
+ private:
+  bool needReload = false;
+  CgOccur *prevVersion = nullptr;
+};
+
+class CgStoreOcc : public CgOccur {
+ public:
+  CgStoreOcc(BB *bb, Insn *insn, Operand *opnd) : CgOccur(kOccStore, bb, insn, opnd) {}
+  ~CgStoreOcc() = default;
+
+  bool Reload() const {
+    return needReload;
+  }
+
+  void SetReload(bool val) {
+    needReload = val;
+  }
+
+  CgOccur *GetPrevVersionOccur() override {
+    return prevVersion;
+  }
+
+  void SetPrevVersionOccur(CgOccur *val) override {
+    prevVersion = val;
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "StoreOcc " << GetClassID() << " at bb " << GetBB()->GetId() << ": "
+        << (needReload ? "reload, " : "not reload, ")
+        << "\n";
+  }
+ private:
+  bool needReload = false;
+  CgOccur *prevVersion = nullptr;
+};
+
+class CgDefOcc : public CgOccur {
+ public:
+  CgDefOcc(BB *bb, Insn *insn, Operand *opnd) : CgOccur(kOccDef, bb, insn, opnd) {}
+  ~CgDefOcc() = default;
+
+  bool Loaded() const {
+    return needStore;
+  }
+
+  void SetLoaded(bool val) {
+    needStore = val;
+  }
+
+  CgOccur *GetPrevVersionOccur() override {
+    return prevVersion;
+  }
+
+  void SetPrevVersionOccur(CgOccur *val) override {
+    prevVersion = val;
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "DefOcc " << GetClassID() << " at bb " << GetBB()->GetId() << ": "
+        << (needStore ? "store" : "not store")
+        << "\n";
+  }
+ private:
+  bool needStore = false;
+  CgOccur *prevVersion = nullptr;
+};
+
+
+class CgPhiOpndOcc;
+enum AvailState {
+  kFullyAvailable,
+  kPartialAvailable,
+  kNotAvailable
+};
+class CgPhiOcc : public CgOccur {
+ public:
+  CgPhiOcc(BB &bb, Operand *opnd, MapleAllocator &alloc)
+      : CgOccur(kOccPhiocc, 0, bb, nullptr),
+        regOpnd(opnd),
+        isDownSafe(!bb.IsCatch()),
+        phiOpnds(alloc.Adapter()) {}
+
+  virtual ~CgPhiOcc() = default;
+
+  bool IsDownSafe() const {
+    return isDownSafe;
+  }
+
+  void SetIsDownSafe(bool downSafe) {
+    isDownSafe = downSafe;
+  }
+
+  const MapleVector<CgPhiOpndOcc*> &GetPhiOpnds() const {
+    return phiOpnds;
+  }
+
+  MapleVector<CgPhiOpndOcc*> &GetPhiOpnds() {
+    return phiOpnds;
+  }
+
+  Operand *GetOpnd() {
+    return regOpnd;
+  }
+
+  CgPhiOpndOcc *GetPhiOpnd(size_t idx) {
+    ASSERT(idx < phiOpnds.size(), "out of range in CgPhiOcc::GetPhiOpnd");
+    return phiOpnds.at(idx);
+  }
+
+  const CgPhiOpndOcc *GetPhiOpnd(size_t idx) const {
+    ASSERT(idx < phiOpnds.size(), "out of range in CgPhiOcc::GetPhiOpnd");
+    return phiOpnds.at(idx);
+  }
+
+  void AddPhiOpnd(CgPhiOpndOcc &opnd) {
+    phiOpnds.push_back(&opnd);
+  }
+
+  CgOccur *GetPrevVersionOccur() override {
+    return prevVersion;
+  }
+
+  void SetPrevVersionOccur(CgOccur *val) override {
+    prevVersion = val;
+  }
+
+  bool IsFullyAvailable() const {
+    return availState == kFullyAvailable;
+  }
+
+  bool IsPartialAvailable() const {
+    return availState == kPartialAvailable;
+  }
+
+  bool IsNotAvailable() const {
+    return availState == kNotAvailable;
+  }
+
+  void SetAvailability(AvailState val) {
+    availState = val;
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "PhiOcc " << GetClassID() << " at bb " << GetBB()->GetId() << ": "
+        << (isDownSafe ? "downsafe, " : "not downsafe, ")
+        << (availState == kNotAvailable ? "not avail"
+                                        : (availState == kPartialAvailable ? "part avail" : "fully avail"))
+        << "\n";
+  }
+
+ private:
+  Operand *regOpnd;
+  bool isDownSafe = true;    // default is true
+  AvailState availState = kFullyAvailable;
+  MapleVector<CgPhiOpndOcc*> phiOpnds;
+  CgOccur *prevVersion = nullptr;
+};
+
+class CgPhiOpndOcc : public CgOccur {
+ public:
+  CgPhiOpndOcc(BB *bb, Operand *opnd, CgPhiOcc *defPhi)
+      : CgOccur(kOccPhiopnd, bb, nullptr, opnd),
+        hasRealUse(false),
+        phiOcc(defPhi) {}
+
+  ~CgPhiOpndOcc() = default;
+
+  bool HasRealUse() const {
+    return hasRealUse;
+  }
+
+  void SetHasRealUse(bool realUse) {
+    hasRealUse = realUse;
+  }
+
+  const CgPhiOcc *GetPhiOcc() const {
+    return phiOcc;
+  }
+
+  CgPhiOcc *GetPhiOcc() {
+    return phiOcc;
+  }
+
+  void SetPhiOcc(CgPhiOcc &occ) {
+    phiOcc = &occ;
+  }
+
+  bool Reload() const {
+    return reload;
+  }
+  void SetReload(bool val) {
+    reload = val;
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "PhiOpndOcc " << GetClassID() << " at bb " << GetBB()->GetId() << ": "
+        << (hasRealUse ? "hasRealUse, " : "not hasRealUse, ")
+        << (reload ? "reload" : "not reload") << std::endl;
+  }
+
+ private:
+  bool hasRealUse;
+  bool reload = false;
+  CgPhiOcc *phiOcc = nullptr;   // its lhs
+};
+
+// each singly linked list represents each bucket in workCandHashTable
+class PreWorkCand {
+ public:
+  PreWorkCand(MapleAllocator &alloc, Operand *curOpnd, PUIdx pIdx)
+      : next(nullptr),
+        allOccs(alloc.Adapter()),
+        realOccs(alloc.Adapter()),
+        phiOccs(alloc.Adapter()),
+        theOperand(curOpnd),
+        puIdx(pIdx),
+        redo2HandleCritEdges(false) {
+    ASSERT(pIdx != 0, "PreWorkCand: initial puIdx cannot be 0");
+  }
+
+  virtual ~PreWorkCand() = default;
+
+  void AddRealOccAsLast(CgOccur &occ, PUIdx pIdx) {
+    realOccs.push_back(&occ);  // add as last
+    ASSERT(pIdx != 0, "puIdx of realocc cannot be 0");
+    if (pIdx != puIdx) {
+      puIdx = 0;
+    }
+  }
+
+  const PreWorkCand *GetNext() const {
+    return next;
+  }
+
+  PreWorkCand *GetNext() {
+    return next;
+  }
+
+  void SetNext(PreWorkCand &workCand) {
+    next = &workCand;
+  }
+
+  int32 GetIndex() const {
+    return index;
+  }
+
+  void SetIndex(int idx) {
+    index = idx;
+  }
+
+  const MapleVector<CgOccur*> &GetRealOccs() const {
+    return realOccs;
+  }
+
+  MapleVector<CgOccur*> &GetRealOccs() {
+    return realOccs;
+  }
+
+  const CgOccur *GetRealOcc(size_t idx) const {
+    ASSERT(idx < realOccs.size(), "out of range in PreWorkCand::GetRealOccAt");
+    return realOccs.at(idx);
+  }
+
+  CgOccur *GetRealOcc(size_t idx) {
+    ASSERT(idx < realOccs.size(), "out of range in PreWorkCand::GetRealOccAt");
+    return realOccs.at(idx);
+  }
+
+  const MapleVector<CgPhiOcc *> &PhiOccs() const {
+    return phiOccs;
+  }
+
+  MapleVector<CgPhiOcc *> &PhiOccs() {
+    return phiOccs;
+  }
+
+  const Operand *GetTheOperand() const {
+    return theOperand;
+  }
+
+  Operand *GetTheOperand() {
+    return theOperand;
+  }
+
+  void SetTheOperand(Operand &expr) {
+    theOperand = &expr;
+  }
+
+  PUIdx GetPUIdx() const {
+    return puIdx;
+  }
+
+  void SetPUIdx(PUIdx idx) {
+    puIdx = idx;
+  }
+
+  bool Redo2HandleCritEdges() const {
+    return redo2HandleCritEdges;
+  }
+
+  void SetRedo2HandleCritEdges(bool redo) {
+    redo2HandleCritEdges = redo;
+  }
+
+ private:
+  PreWorkCand *next;
+  int32 index = 0;
+  MapleVector<CgOccur *> allOccs;
+  MapleVector<CgOccur *> realOccs;  // maintained in order of dt_preorder
+  MapleVector<CgPhiOcc *> phiOccs;
+  Operand *theOperand;                 // the expression of this workcand
+  PUIdx puIdx;                       // if 0, its occ span multiple PUs; initial value must
+  // puIdx cannot be 0 if hasLocalOpnd is true
+  bool redo2HandleCritEdges : 1;  // redo to make critical edges affect canbevail
+};
+
+class PreWorkCandHashTable {
+ public:
+  static const uint32 workCandHashLength = 229;
+  static uint32 ComputeWorkCandHashIndex(const Operand &opnd);
+  static uint32 ComputeStmtWorkCandHashIndex(const Insn &insn);
+
+  PreWorkCandHashTable() = default;
+  ~PreWorkCandHashTable() = default;
+
+  std::array<PreWorkCand*, workCandHashLength> &GetWorkcandHashTable() {
+    return workCandHashTable;
+  }
+
+  PreWorkCand *GetWorkcandFromIndex(size_t idx) {
+    return workCandHashTable[idx];
+  }
+
+  void SetWorkCandAt(size_t idx, PreWorkCand &workCand) {
+    workCandHashTable[idx] = &workCand;
+  }
+
+ private:
+  std::array<PreWorkCand*, workCandHashLength> workCandHashTable;
+};
+}  // namespace maple
+#endif  // MAPLEBE_CG_INCLUDE_CGOCCUR_H
diff --git a/src/mapleall/maple_be/include/cg/cg_option.h b/src/mapleall/maple_be/include/cg/cg_option.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ddc69b6366e17906d37bfdcbcee6116eeeec7eb
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_option.h
@@ -0,0 +1,1442 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CG_OPTION_H
+#define MAPLEBE_INCLUDE_CG_CG_OPTION_H
+#include <vector>
+#include <sys/stat.h>
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_module.h"
+#include "types_def.h"
+
+namespace maplebe {
+using namespace maple;
+struct Range {
+  bool enable;
+  uint64 begin;
+  uint64 end;
+};
+
+class CGOptions {
+ public:
+  enum OptionEnum : uint64 {
+    kUndefined = 0ULL,
+    kDoCg = 1ULL << 0,
+    kDoLinearScanRegAlloc = 1ULL << 1,
+    kDoColorRegAlloc = 1ULL << 2,
+    kConstFold = 1ULL << 3,
+    kGenPic = 1ULL << 4,
+    kGenPie = 1ULL << 5,
+    kVerboseAsm = 1ULL << 6,
+    kGenInsertCall = 1ULL << 7,
+    kAddDebugTrace = 1ULL << 8,
+    kGenYieldPoint = 1ULL << 9,
+    kGenLocalRc = 1ULL << 10,
+    kProEpilogueOpt = 1ULL << 11,
+    kVerboseCG = 1ULL << 12,
+    kDebugFriendly = 1ULL << 20,
+    kWithLoc = 1ULL << 21,
+    kWithDwarf = 1ULL << 22,
+    kWithMpl = 1ULL << 23,
+    kWithSrc = 1ULL << 24,
+    kWithAsm = 1ULL << 25,
+    kWithProfileCode = 1ULL << 30,
+    kUseStackProtectorStrong = 1ULL << 31,
+    kUseStackProtectorAll = 1ULL << 32,
+    kSoeCheckInsert = 1ULL << 33,
+    kAddFuncProfile = 1ULL << 34,
+    kPatchLongBranch = 1ULL << 35,
+    kTailCallOpt = 1ULL << 36,
+    kUseUnwindTables = 1ULL << 37,
+    /* undocumented */
+    kDumpCFG = 1ULL << 61,
+    kDumpCgir = 1ULL << 62,
+    kSuppressFileInfo = 1ULL << 63,
+  };
+
+  using OptionFlag = uint64;
+
+  enum GenerateEnum : uint64 {
+    kCMacroDef = 1ULL << 0,
+    kGctib = 1ULL << 1,
+    kGrootList = 1ULL << 2,
+    kPrimorList = 1ULL << 3,
+  };
+
+  using GenerateFlag = uint64;
+
+  enum OptimizeLevel : uint8 {
+    kLevel0 = 0,
+    kLevelLiteCG = 1,
+    kLevel1 = 2,
+    kLevel2 = 3,
+  };
+
+  enum ABIType : uint8 {
+    kABIHard,
+    kABISoft,
+    kABISoftFP
+  };
+
+  enum EmitFileType : uint8 {
+    kAsm,
+    kObj,
+    kEmitNone,
+  };
+  /*
+   * The default CG option values are:
+   * Don't BE_QUITE; verbose,
+   * DO CG and generate .s file as output,
+   * Generate EH,
+   * Use frame pointer,
+   * Generate CFI directives,
+   * DO peephole optimization,
+   * Generate position-independent executable,
+   * Don't insert debug comments in .s file,
+   * Don't insert a call to the named (instrumentation)
+   * function at each function entry.
+   */
+  static const OptionFlag kDefaultOptions = OptionFlag(
+#if TARGAARCH64 || TARGARM32 || TARGRISCV64
+    kDoCg | kGenPie | kDoColorRegAlloc
+#else
+    kDoCg
+#endif
+  );
+
+  /*
+   * The default metadata generation flags values are:
+   * Generate .macros.def for C preprocessors.
+   * Generate .groots.txt for GC.
+   * Generate .primordials.txt for GC.
+   * Generate yieldpoints for GC.
+   * Do not generate separate GCTIB file.
+   */
+  static const GenerateFlag kDefaultGflags = GenerateFlag(0);
+
+ public:
+  static CGOptions &GetInstance();
+  virtual ~CGOptions() = default;
+  bool SolveOptions(bool isDebug);
+  void DecideMplcgRealLevel(bool isDebug);
+
+  void DumpOptions();
+  std::vector<std::string> &GetSequence() {
+    return phaseSequence;
+  }
+
+  template <class T>
+  void SetOrClear(T &dest, uint64 flag, bool truth) const {
+    if (truth) {
+      dest |= flag;
+    } else {
+      dest &= ~flag;
+    }
+  }
+
+  void ParseExclusiveFunc(const std::string &fileName);
+  void ParseCyclePattern(const std::string &fileName) const;
+
+  void EnableO0();
+  void EnableO1();
+  void EnableO2();
+  void EnableLiteCG();
+
+  bool GenDef() const {
+    return generateFlag & kCMacroDef;
+  }
+
+  bool GenGctib() const {
+    return generateFlag & kGctib;
+  }
+
+  bool GenGrootList() const {
+    return generateFlag & kGrootList;
+  }
+
+  bool GenPrimorList() const {
+    return generateFlag & kPrimorList;
+  }
+
+  bool GenYieldPoint() const {
+    return generateFlag & kGenYieldPoint;
+  }
+
+  bool GenLocalRC() const {
+    return ((generateFlag & kGenLocalRc) != 0) && !gcOnly;
+  }
+
+  bool DoConstFold() const {
+    return options & kConstFold;
+  }
+
+  bool DoEmitCode() const {
+    return (options & kDoCg) != 0;
+  }
+
+  bool GenerateExceptionHandlingCode() const {
+    return true;
+  }
+
+  bool DoLinearScanRegisterAllocation() const {
+    return (options & kDoLinearScanRegAlloc) != 0;
+  }
+  bool DoColoringBasedRegisterAllocation() const {
+    return (options & kDoColorRegAlloc) != 0;
+  }
+
+  bool GeneratePositionIndependentExecutable() const {
+    return (options & kGenPie) != 0;
+  }
+
+  bool GenerateVerboseAsm() const {
+    return (options & kVerboseAsm) != 0;
+  }
+
+  bool GenerateVerboseCG() const {
+    return (options & kVerboseCG) != 0;
+  }
+
+  bool GenerateDebugFriendlyCode() const {
+    return true;
+  }
+
+  bool DoPrologueEpilogue() const {
+    return (options & kProEpilogueOpt) != 0;
+  }
+
+  bool IsStackProtectorStrong() const {
+    return (options & kUseStackProtectorStrong) != 0;
+  }
+
+  bool IsStackProtectorAll() const {
+    return (options & kUseStackProtectorAll) != 0;
+  }
+
+  bool IsUnwindTables() const {
+    return (options & kUseUnwindTables) != 0;
+  }
+
+  bool WithLoc() const {
+    return (options & kWithLoc) != 0;
+  }
+
+  bool WithDwarf() const {
+    return (options & kWithDwarf) != 0;
+  }
+
+  bool WithSrc() const {
+    return (options & kWithSrc) != 0;
+  }
+
+  bool WithMpl() const {
+    return (options & kWithMpl) != 0;
+  }
+
+  bool WithAsm() const {
+    return (options & kWithAsm) != 0;
+  }
+
+  bool InstrumentWithDebugTraceCall() const {
+    return (options & kAddDebugTrace) != 0;
+  }
+
+  bool DoPatchLongBranch() const {
+    return (options & kPatchLongBranch) != 0;
+  }
+
+  bool DoTailCall() const {
+    return (options & kTailCallOpt) != 0;
+  }
+
+  bool DoCheckSOE() const {
+    return (options & kSoeCheckInsert) != 0;
+  }
+
+  bool SuppressFileInfo() const {
+    return (options & kSuppressFileInfo) != 0;
+  }
+
+  bool DoDumpCFG() const {
+    return (options & kDumpCFG) != 0;
+  }
+
+  void SetDefaultOptions(const MIRModule &mod);
+  static bool DumpPhase(const std::string &phase);
+  static bool FuncFilter(const std::string &name);
+  void SplitPhases(const std::string &str, std::unordered_set<std::string> &set) const;
+  void SetRange(const std::string &str, const std::string &cmd, Range &subRange) const;
+  void SetTargetMachine(const std::string &str);
+
+  int32 GetOptimizeLevel() const {
+    return optimizeLevel;
+  }
+
+  bool IsRunCG() const {
+    return runCGFlag;
+  }
+
+  void SetRunCGFlag(bool cgFlag) {
+    runCGFlag = cgFlag;
+  }
+
+  bool IsGenerateObjectMap() const {
+    return generateObjectMap;
+  }
+
+  void SetGenerateObjectMap(bool flag) {
+    generateObjectMap = flag;
+  }
+
+  void SetParserOption(uint32 option) {
+    parserOption |= option;
+  }
+
+  uint32 GetParserOption() const {
+    return parserOption;
+  }
+
+  GenerateFlag &GetGenerateFlags() {
+    return generateFlag;
+  }
+
+  const GenerateFlag &GetGenerateFlags() const {
+    return generateFlag;
+  }
+
+  void SetGenerateFlags(GenerateFlag flag) {
+    generateFlag |= flag;
+  }
+
+  void SetOption(OptionFlag opFlag) {
+    options |= opFlag;
+  }
+
+  void ClearOption(OptionFlag opFlag) {
+    options &= ~opFlag;
+  }
+
+  const std::string &GetClassListFile() const {
+    return classListFile;
+  }
+
+  void SetClassListFile(const std::string &classList) {
+    classListFile = classList;
+  }
+
+  void SetEHExclusiveFile(const std::string &ehExclusive) {
+    ehExclusiveFile = ehExclusive;
+  }
+
+  void SetCyclePatternFile(const std::string &cyclePattern) {
+    cyclePatternFile = cyclePattern;
+  }
+
+  static bool IsQuiet() {
+    return quiet;
+  }
+
+  static void SetQuiet(bool flag) {
+    quiet = flag;
+  }
+
+  static std::unordered_set<std::string> &GetDumpPhases() {
+    return dumpPhases;
+  }
+
+  static std::unordered_set<std::string> &GetSkipPhases() {
+    return skipPhases;
+  }
+
+  static bool IsSkipPhase(const std::string &phaseName) {
+    return !(skipPhases.find(phaseName) == skipPhases.end());
+  }
+
+  const std::vector<std::string> &GetEHExclusiveFunctionNameVec() const {
+    return ehExclusiveFunctionName;
+  }
+
+  static const std::unordered_map<std::string, std::vector<std::string>> &GetCyclePatternMap() {
+    return cyclePatternMap;
+  }
+
+  static bool IsSkipFromPhase(const std::string &phaseName) {
+    return skipFrom.compare(phaseName) == 0;
+  }
+
+  static const std::string GetSkipFromPhase() {
+    return skipFrom;
+  }
+
+  static void SetSkipFrom(const std::string &phaseName) {
+    skipFrom = phaseName;
+  }
+
+  static bool IsSkipAfterPhase(const std::string &phaseName) {
+    return skipAfter.compare(phaseName) == 0;
+  }
+
+  static const std::string GetSkipAfterPhase() {
+    return skipAfter;
+  }
+
+  static void SetSkipAfter(const std::string &phaseName) {
+    skipAfter = phaseName;
+  }
+
+  static const std::string &GetDumpFunc() {
+    return dumpFunc;
+  }
+
+  static bool IsDumpFunc(const std::string &func) {
+    return ((dumpFunc.compare("*") == 0) || (func.find(CGOptions::dumpFunc.c_str()) != std::string::npos));
+  }
+
+  static void SetDumpFunc(const std::string &func) {
+    dumpFunc = func;
+  }
+  static size_t FindIndexInProfileData(char data) {
+    return profileData.find(data);
+  }
+
+  static void SetProfileData(const std::string &path) {
+    profileData = path;
+  }
+
+  static std::string &GetProfileData() {
+    return profileData;
+  }
+
+  static const std::string GetProfileDataSubStr(size_t begin, size_t end) {
+    return profileData.substr(begin, end);
+  }
+
+  static const std::string GetProfileDataSubStr(size_t position) {
+    return profileData.substr(position);
+  }
+
+  static bool IsProfileDataEmpty() {
+    return profileData.empty();
+  }
+
+  static const std::string &GetProfileFuncData() {
+    return profileFuncData;
+  }
+
+  static bool IsProfileFuncDataEmpty() {
+    return profileFuncData.empty();
+  }
+
+  static void SetProfileFuncData(const std::string &data) {
+    profileFuncData = data;
+  }
+
+  static const std::string &GetProfileClassData() {
+    return profileClassData;
+  }
+
+  static void SetProfileClassData(const std::string &data) {
+    profileClassData = data;
+  }
+
+  static const std::string &GetDuplicateAsmFile() {
+    return duplicateAsmFile;
+  }
+
+  static bool IsDuplicateAsmFileEmpty() {
+    if (duplicateAsmFile.empty()) {
+      return true;
+    }
+    struct stat buffer;
+    if (stat(duplicateAsmFile.c_str(), &buffer) != 0) {
+      return true;
+    }
+    return false;
+  }
+
+  static void SetDuplicateAsmFile(const std::string &fileName) {
+    duplicateAsmFile = fileName;
+  }
+
+  static bool UseRange() {
+    return range.enable;
+  }
+  static const std::string &GetFastFuncsAsmFile() {
+    return fastFuncsAsmFile;
+  }
+
+  static bool IsFastFuncsAsmFileEmpty() {
+    return fastFuncsAsmFile.empty();
+  }
+
+  static void SetFastFuncsAsmFile(const std::string &fileName) {
+    fastFuncsAsmFile = fileName;
+  }
+
+  static Range &GetRange() {
+    return range;
+  }
+
+  static uint64 GetRangeBegin() {
+    return range.begin;
+  }
+
+  static uint64 GetRangeEnd() {
+    return range.end;
+  }
+
+  static Range &GetSpillRanges() {
+    return spillRanges;
+  }
+
+  static uint64 GetSpillRangesBegin() {
+    return spillRanges.begin;
+  }
+
+  static uint64 GetSpillRangesEnd() {
+    return spillRanges.end;
+  }
+
+  static uint64 GetLSRABBOptSize() {
+    return lsraBBOptSize;
+  }
+
+  static void SetLSRABBOptSize(uint64 size) {
+    lsraBBOptSize = size;
+  }
+
+  static void SetLSRAInsnOptSize(uint64 size) {
+    lsraInsnOptSize = size;
+  }
+
+  static uint64 GetOverlapNum() {
+    return overlapNum;
+  }
+
+  static void SetOverlapNum(uint64 num) {
+    overlapNum = num;
+  }
+
+  static uint8 GetRematLevel() {
+    return rematLevel;
+  }
+
+  static bool OptimizeForSize() {
+    return optForSize;
+  }
+
+  static void SetRematLevel(uint8 level) {
+    rematLevel = level;
+  }
+
+  static uint8 GetFastAllocMode() {
+    return fastAllocMode;
+  }
+
+  static void SetFastAllocMode(uint8 mode) {
+    fastAllocMode = mode;
+  }
+
+  static void EnableBarriersForVolatile() {
+    useBarriersForVolatile = true;
+  }
+
+  static void DisableBarriersForVolatile() {
+    useBarriersForVolatile = false;
+  }
+
+  static bool UseBarriersForVolatile() {
+    return useBarriersForVolatile;
+  }
+  static void EnableFastAlloc() {
+    fastAlloc = true;
+  }
+
+  static bool IsFastAlloc() {
+    return fastAlloc;
+  }
+
+  static bool IsEnableTimePhases() {
+    return timePhases;
+  }
+
+  static void EnableTimePhases() {
+    timePhases = true;
+  }
+
+  static void DisableTimePhases() {
+    timePhases = false;
+  }
+
+  static void EnableInRange() {
+    inRange = true;
+  }
+
+  static void DisableInRange() {
+    inRange = false;
+  }
+
+  static bool IsInRange() {
+    return inRange;
+  }
+
+  static void EnableEBO() {
+    doEBO = true;
+  }
+
+  static void DisableEBO() {
+    doEBO = false;
+  }
+
+  static bool DoEBO() {
+    return doEBO;
+  }
+
+  static void DisableCGSSA() {
+    doCGSSA = false;
+  }
+
+  static void EnableCGSSA() {
+    doCGSSA = true;
+  }
+
+  static bool DoCGSSA() {
+    return doCGSSA && !flavorLmbc;
+  }
+
+  static void DisableIPARA() {
+    doIPARA = false;
+  }
+
+  static bool DoIPARA() {
+    return doIPARA;
+  }
+
+  static void EnableCFGO() {
+    doCFGO = true;
+  }
+
+  static void DisableCFGO() {
+    doCFGO = false;
+  }
+
+  static bool DoCFGO() {
+    return doCFGO;
+  }
+
+  static void EnableRegSavesOpt() {
+    doRegSavesOpt = true;
+  }
+
+  static void DisableRegSavesOpt() {
+    doRegSavesOpt = false;
+  }
+
+  static bool DoRegSavesOpt() {
+    return doRegSavesOpt;
+  }
+
+  static void EnableSsaPreSave() {
+    useSsaPreSave = true;
+  }
+
+  static void DisableSsaPreSave() {
+    useSsaPreSave = false;
+  }
+
+  static bool UseSsaPreSave() {
+    return useSsaPreSave;
+  }
+  static void EnableSsuPreRestore() {
+    useSsuPreRestore = true;
+  }
+
+  static void DisableSsuPreRestore() {
+    useSsuPreRestore = false;
+  }
+
+  static bool UseSsuPreRestore() {
+    return useSsuPreRestore;
+  }
+
+  static void EnableICO() {
+    doICO = true;
+  }
+
+  static void DisableICO() {
+    doICO = false;
+  }
+
+  static bool DoICO() {
+    return doICO;
+  }
+
+  static bool DoIsolateFastPath() {
+    return (CGOptions::GetInstance().DoPrologueEpilogue()) &&
+           (CGOptions::GetInstance().GetOptimizeLevel() == CGOptions::kLevel2);
+  }
+
+  static void EnableStoreLoadOpt() {
+    doStoreLoadOpt = true;
+  }
+
+  static void DisableStoreLoadOpt() {
+    doStoreLoadOpt = false;
+  }
+
+  static bool DoStoreLoadOpt() {
+    return doStoreLoadOpt;
+  }
+
+  static void EnableGlobalOpt() {
+    doGlobalOpt = true;
+  }
+
+  static void DisableGlobalOpt() {
+    doGlobalOpt = false;
+  }
+
+  static void EnableHotColdSplit() {
+    enableHotColdSplit = true;
+  }
+
+  static void DisableHotColdSplit() {
+    enableHotColdSplit = false;
+  }
+
+  static bool DoEnableHotColdSplit() {
+    return enableHotColdSplit;
+  }
+
+  static bool DoGlobalOpt() {
+    return doGlobalOpt;
+  }
+
+  static void EnableAlignAnalysis() {
+    doAlignAnalysis = true;
+  }
+
+  static void DisableAlignAnalysis() {
+    doAlignAnalysis = false;
+  }
+
+  static bool DoAlignAnalysis() {
+    return doAlignAnalysis;
+  }
+
+  static void EnableCondBrAlign() {
+    doCondBrAlign = true;
+  }
+
+  static void DisableCondBrAlign() {
+    doCondBrAlign = false;
+  }
+
+  static bool DoCondBrAlign() {
+    return doCondBrAlign;
+  }
+
+  static void EnableBigEndianInCG() {
+    cgBigEndian = true;
+  }
+
+  static void DisableBigEndianInCG() {
+    cgBigEndian = false;
+  }
+
+  static bool IsBigEndian() {
+    return cgBigEndian;
+  }
+
+  static void EnableArm64ilp32() {
+    arm64ilp32 = true;
+  }
+
+  static void DisableArm64ilp32() {
+    arm64ilp32 = false;
+  }
+
+  static bool IsArm64ilp32() {
+    return arm64ilp32;
+  }
+
+  static bool IsTargetX86_64() {
+    return targetArch == "x86_64";
+  };
+
+  static void EnableVregRename() {
+    doVregRename = true;
+  }
+
+  static void DisableVregRename() {
+    doVregRename = false;
+  }
+
+  static bool DoVregRename() {
+    return doVregRename;
+  }
+
+  static void EnableMultiPassColorRA() {
+    doMultiPassColorRA = true;
+  }
+
+  static void DisableMultiPassColorRA() {
+    doMultiPassColorRA = false;
+  }
+
+  static bool DoMultiPassColorRA() {
+    return doMultiPassColorRA;
+  }
+
+  static void EnablePreLSRAOpt() {
+    doPreLSRAOpt = true;
+  }
+
+  static void DisablePreLSRAOpt() {
+    doPreLSRAOpt = false;
+  }
+
+  static bool DoPreLSRAOpt() {
+    return doPreLSRAOpt;
+  }
+
+  static void EnableLocalRefSpill() {
+    doLocalRefSpill = true;
+  }
+
+  static void DisableLocalRefSpill() {
+    doLocalRefSpill = false;
+  }
+
+  static bool DoLocalRefSpill() {
+    return doLocalRefSpill;
+  }
+
+  static void EnableCalleeToSpill() {
+    doCalleeToSpill = true;
+  }
+
+  static void DisableCalleeToSpill() {
+    doCalleeToSpill = false;
+  }
+
+  static bool DoCalleeToSpill() {
+    return doCalleeToSpill;
+  }
+
+  static void EnablePrePeephole() {
+    doPrePeephole = true;
+  }
+
+  static void DisablePrePeephole() {
+    doPrePeephole = false;
+  }
+
+  static bool DoPrePeephole() {
+    return doPrePeephole;
+  }
+
+  static void EnablePeephole() {
+    doPeephole = true;
+  }
+
+  static void DisablePeephole() {
+    doPeephole = false;
+  }
+
+  static bool DoPeephole() {
+    return doPeephole;
+  }
+
+  static void EnableRetMerge() {
+    doRetMerge = true;
+  }
+
+  static void DisableRetMerge() {
+    doRetMerge = false;
+  }
+
+  static bool DoRetMerge() {
+    return doRetMerge;
+  }
+
+  static void EnablePreSchedule() {
+    doPreSchedule = true;
+  }
+
+  static void DisablePreSchedule() {
+    doPreSchedule = false;
+  }
+
+  static bool DoPreSchedule() {
+    return doPreSchedule;
+  }
+
+  static void EnableSchedule() {
+    doSchedule = true;
+  }
+
+  static void DisableSchedule() {
+    doSchedule = false;
+  }
+
+  static bool DoSchedule() {
+    return doSchedule;
+  }
+  static void EnableWriteRefFieldOpt() {
+    doWriteRefFieldOpt = true;
+  }
+
+  static void DisableWriteRefFieldOpt() {
+    doWriteRefFieldOpt = false;
+  }
+  static bool DoWriteRefFieldOpt() {
+    return doWriteRefFieldOpt;
+  }
+
+  static void EnableDumpOptimizeCommonLog() {
+    dumpOptimizeCommonLog = true;
+  }
+
+  static void DisableDumpOptimizeCommonLog() {
+    dumpOptimizeCommonLog = false;
+  }
+
+  static bool IsDumpOptimizeCommonLog() {
+    return dumpOptimizeCommonLog;
+  }
+
+  static void EnableCheckArrayStore() {
+    checkArrayStore = true;
+  }
+
+  static void DisableCheckArrayStore() {
+    checkArrayStore = false;
+  }
+
+  static bool IsCheckArrayStore() {
+    return checkArrayStore;
+  }
+
+  static void EnableExclusiveEH() {
+    exclusiveEH = true;
+  }
+
+  static bool IsExclusiveEH() {
+    return exclusiveEH;
+  }
+
+  static void EnablePIC() {
+    doPIC = true;
+  }
+
+  static void DisablePIC() {
+    doPIC = false;
+  }
+
+  static bool IsPIC() {
+    return doPIC;
+  }
+
+  static void EnableNoDupBB() {
+    noDupBB = true;
+  }
+
+  static void DisableNoDupBB() {
+    noDupBB = false;
+  }
+
+  static bool IsNoDupBB() {
+    return noDupBB;
+  }
+
+  static void EnableNoCalleeCFI() {
+    noCalleeCFI = true;
+  }
+
+  static void DisableNoCalleeCFI() {
+    noCalleeCFI = false;
+  }
+
+  static bool IsNoCalleeCFI() {
+    return noCalleeCFI;
+  }
+
+  static void EnableEmitCyclePattern() {
+    emitCyclePattern = true;
+  }
+
+  static bool IsInsertYieldPoint() {
+    return insertYieldPoint;
+  }
+
+  static void EnableMapleLinker() {
+    mapleLinker = true;
+  }
+
+  static void DisableMapleLinker() {
+    mapleLinker = false;
+  }
+
+  static bool IsMapleLinker() {
+    return mapleLinker;
+  }
+  static void EnableReplaceASM() {
+    replaceASM = true;
+  }
+
+  static void DisableReplaceASM() {
+    replaceASM = false;
+  }
+
+  static bool IsReplaceASM() {
+    return replaceASM;
+  }
+
+  static void EnableGeneralRegOnly() {
+    generalRegOnly = true;
+  }
+
+  static void DisableGeneralRegOnly() {
+    generalRegOnly = false;
+  }
+
+  static bool UseGeneralRegOnly() {
+    return generalRegOnly;
+  }
+
+  static void EnablePrintFunction() {
+    printFunction = true;
+  }
+
+  static void DisablePrintFunction() {
+    printFunction = false;
+  }
+
+  static bool IsPrintFunction() {
+    return printFunction;
+  }
+
+  static std::string &GetGlobalVarProFile() {
+    return globalVarProfile;
+  }
+
+  static bool IsGlobalVarProFileEmpty() {
+    return globalVarProfile.empty();
+  }
+
+  static bool IsEmitBlockMarker() {
+    return emitBlockMarker;
+  }
+
+  static void EnableNativeOpt() {
+    nativeOpt = true;
+  }
+
+  static void DisableNativeOpt() {
+    nativeOpt = false;
+  }
+
+  static bool IsNativeOpt() {
+    return nativeOpt;
+  }
+
+  static void EnableLazyBinding() {
+    lazyBinding = true;
+  }
+
+  static void DisableLazyBinding() {
+    lazyBinding = false;
+  }
+
+  static bool IsLazyBinding() {
+    return lazyBinding;
+  }
+
+  static void EnableHotFix() {
+    hotFix = true;
+  }
+
+  static void DisableHotFix() {
+    hotFix = false;
+  }
+
+  static bool IsHotFix() {
+    return hotFix;
+  }
+
+  static void EnableDebugSched() {
+    debugSched = true;
+  }
+
+  static void DisableDebugSched() {
+    debugSched = false;
+  }
+
+  static bool IsDebugSched() {
+    return debugSched;
+  }
+
+  static void EnableDruteForceSched() {
+    bruteForceSched = true;
+  }
+
+  static void DisableDruteForceSched() {
+    bruteForceSched = false;
+  }
+
+  static bool IsDruteForceSched() {
+    return bruteForceSched;
+  }
+
+  static void EnableSimulateSched() {
+    simulateSched = true;
+  }
+
+  static void DisableSimulateSched() {
+    simulateSched = false;
+  }
+
+  static bool IsSimulateSched() {
+    return simulateSched;
+  }
+
+  static void SetABIType(const std::string &type) {
+    if (type == "hard") {
+      abiType = kABIHard;
+    } else if (type == "soft") {
+      CHECK_FATAL(false, "float-abi=soft is not supported Currently.");
+    } else if (type == "softfp") {
+      abiType = kABISoftFP;
+    } else {
+      CHECK_FATAL(false, "unexpected abi-type, only hard, soft and softfp are supported");
+    }
+  }
+
+  static ABIType GetABIType() {
+    return abiType;
+  }
+
+  static void SetEmitFileType(const std::string &type) {
+    if (type == "asm") {
+      emitFileType = kAsm;
+    } else if (type == "obj") {
+      emitFileType = kObj;
+    } else if (type == "null") {
+      emitFileType = kEmitNone;
+      CHECK_FATAL(false, "null is not supported Currently.");
+    } else {
+      CHECK_FATAL(false, "unexpected file-type, only asm, obj, and null are supported");
+    }
+  }
+
+  static EmitFileType GetEmitFileType() {
+    return emitFileType;
+  }
+
+  static void EnableLongCalls() {
+    genLongCalls = true;
+  }
+
+  static void DisableLongCalls() {
+    genLongCalls = false;
+  }
+
+  static bool IsLongCalls() {
+    return genLongCalls;
+  }
+
+  static void EnableFunctionSections() {
+    functionSections = true;
+  }
+
+  static void DisableFunctionSections() {
+    functionSections = false;
+  }
+
+  static bool IsFunctionSections() {
+    return functionSections;
+  }
+
+  static void EnableFramePointer() {
+    useFramePointer = true;
+  }
+
+  static void DisableFramePointer() {
+    useFramePointer = false;
+  }
+
+  static bool UseFramePointer() {
+    return useFramePointer;
+  }
+
+  static void EnableGCOnly() {
+    gcOnly = true;
+  }
+
+  static void DisableGCOnly() {
+    gcOnly = false;
+  }
+
+  static bool IsGCOnly() {
+    return gcOnly;
+  }
+
+  const OptionFlag &GetOptionFlag() const {
+    return options;
+  }
+
+  void SetOptionFlag(const OptionFlag &flag) {
+    options = flag;
+  }
+
+  static void EnableFastMath() {
+    fastMath = true;
+  }
+
+  static void DisableFastMath() {
+    fastMath = false;
+  }
+
+  static bool IsFastMath() {
+    return fastMath;
+  }
+
+  static void EnableCommon() {
+    noCommon = false;
+  }
+
+  static void DisableCommon() {
+    noCommon = true;
+  }
+
+  static bool IsNoCommon() {
+    return noCommon;
+  }
+
+  static void EnableFlavorLmbc() {
+    flavorLmbc = true;
+  }
+
+  static void SetAlignMinBBSize(uint32 minBBSize) {
+    alignMinBBSize = minBBSize;
+  }
+
+  static uint32 GetAlignMinBBSize() {
+    return alignMinBBSize;
+  }
+
+  static void SetAlignMaxBBSize(uint32 maxBBSize) {
+    alignMaxBBSize = maxBBSize;
+  }
+
+  static uint32 GetAlignMaxBBSize() {
+    return alignMaxBBSize;
+  }
+
+  static void SetLoopAlignPow(uint32 loopPow) {
+    loopAlignPow = loopPow;
+  }
+
+  static uint32 GetLoopAlignPow() {
+    return loopAlignPow;
+  }
+
+  static void SetJumpAlignPow(uint32 jumpPow) {
+    jumpAlignPow = jumpPow;
+  }
+
+  static uint32 GetJumpAlignPow() {
+    return jumpAlignPow;
+  }
+
+  static void SetFuncAlignPow(uint32 funcPow) {
+    funcAlignPow = funcPow;
+  }
+
+  static uint32 GetFuncAlignPow() {
+    return funcAlignPow;
+  }
+
+  static bool DoLiteProfGen() {
+    return liteProfGen;
+  }
+
+  static void EnableLiteProfGen() {
+    liteProfGen = true;
+  }
+
+  static void DisableLiteProfGen() {
+    liteProfGen = false;
+  }
+
+  static bool DoLiteProfUse() {
+    return liteProfUse;
+  }
+
+  static void EnableLiteProfUse() {
+    liteProfUse = true;
+  }
+
+  static void SetLiteProfile(std::string pgofile) {
+    liteProfile = pgofile;
+  }
+
+  static std::string GetLiteProfile() {
+    return liteProfile;
+  }
+
+  static void SetLitePgoOutputFunction(std::string iofile) {
+    litePgoOutputFunction = iofile;
+  }
+
+  static std::string& GetLitePgoOutputFunction() {
+    return litePgoOutputFunction;
+  }
+
+  static void SetInstrumentationWhiteList(std::string pgoWhiteList) {
+    instrumentationWhiteList = pgoWhiteList;
+  }
+
+  static std::string& GetInstrumentationWhiteList() {
+    return instrumentationWhiteList;
+  }
+
+ private:
+  std::vector<std::string> phaseSequence;
+  bool runCGFlag = true;
+  bool generateObjectMap = true;
+  uint32 parserOption = 0;
+  int32 optimizeLevel = 0;
+
+  GenerateFlag generateFlag = 0;
+  OptionFlag options = kUndefined;
+
+  std::string classListFile;
+  std::string ehExclusiveFile;
+  std::string cyclePatternFile;
+  /* we don't do exception handling in this list */
+  std::vector<std::string> ehExclusiveFunctionName;
+
+  static bool quiet;
+  static std::string targetArch;
+  static std::unordered_set<std::string> dumpPhases;
+  static std::unordered_set<std::string> skipPhases;
+  static std::unordered_map<std::string, std::vector<std::string>> cyclePatternMap;
+  static std::string skipFrom;
+  static std::string skipAfter;
+  static std::string dumpFunc;
+  static std::string duplicateAsmFile;
+  static bool optForSize;
+  static bool enableHotColdSplit;
+  static bool useBarriersForVolatile;
+  static bool timePhases;
+  static bool cgBigEndian;
+  static bool doEBO;
+  static bool doCGSSA;
+  static bool doIPARA;
+  static bool doCFGO;
+  static bool doICO;
+  static bool doStoreLoadOpt;
+  static bool doGlobalOpt;
+  static bool doVregRename;
+  static bool doMultiPassColorRA;
+  static bool doPrePeephole;
+  static bool doPeephole;
+  static bool doRetMerge;
+  static bool doSchedule;
+  static bool doAlignAnalysis;
+  static bool doCondBrAlign;
+  static bool doWriteRefFieldOpt;
+  static bool doRegSavesOpt;
+  static bool useSsaPreSave;
+  static bool useSsuPreRestore;
+  static bool dumpOptimizeCommonLog;
+  static bool checkArrayStore;
+  static bool exclusiveEH;
+  static bool doPIC;
+  static bool noDupBB;
+  static bool noCalleeCFI;
+  static bool emitCyclePattern;
+  static bool insertYieldPoint;
+  static bool mapleLinker;
+  static bool printFunction;
+  static std::string globalVarProfile;
+  static bool nativeOpt;
+  static bool lazyBinding;
+  static bool arm64ilp32;
+  static bool hotFix;
+  /* if true dump scheduling information */
+  static bool debugSched;
+  /* if true do BruteForceSchedule */
+  static bool bruteForceSched;
+  /* if true do SimulateSched */
+  static bool simulateSched;
+  static ABIType abiType;
+  static EmitFileType emitFileType;
+  /* if true generate adrp/ldr/blr */
+  static bool genLongCalls;
+  static bool functionSections;
+  static bool useFramePointer;
+  static bool gcOnly;
+  static bool doPreSchedule;
+  static bool emitBlockMarker;
+  static Range range;
+  static bool inRange;
+  static bool doPatchLongBranch;
+  static std::string profileData;
+  static std::string profileFuncData;
+  static std::string profileClassData;
+  static std::string fastFuncsAsmFile;
+  static Range spillRanges;
+  static uint64 lsraBBOptSize;
+  static uint64 lsraInsnOptSize;
+  static uint64 overlapNum;
+  static uint8 rematLevel;
+  static uint8 fastAllocMode;
+  static bool fastAlloc;
+  static bool doPreLSRAOpt;
+  static bool doLocalRefSpill;
+  static bool doCalleeToSpill;
+  static bool replaceASM;
+  static bool generalRegOnly;
+  static bool fastMath;
+  static bool noCommon;
+  static bool flavorLmbc;
+  static uint32 alignMinBBSize;
+  static uint32 alignMaxBBSize;
+  static uint32 loopAlignPow;
+  static uint32 jumpAlignPow;
+  static uint32 funcAlignPow;
+  static bool liteProfGen;
+  static bool liteProfUse;
+  static std::string litePgoOutputFunction;
+  static std::string instrumentationWhiteList;
+  static std::string liteProfile;
+};
+}  /* namespace maplebe */
+
+#define SET_FIND(SET, NAME) ((SET).find(NAME))
+#define SET_END(SET) ((SET).end())
+#define IS_STR_IN_SET(SET, NAME) (SET_FIND(SET, NAME) != SET_END(SET))
+
+#define CG_DEBUG_FUNC(f)                                                               \
+    (!maplebe::CGOptions::GetDumpPhases().empty() && maplebe::CGOptions::IsDumpFunc((f).GetName()) &&   \
+     maplebe::CGOptions::GetDumpPhases().find(PhaseName()) != maplebe::CGOptions::GetDumpPhases().end())
+#ifndef TRACE_PHASE
+#define TRACE_PHASE (IS_STR_IN_SET(maplebe::CGOptions::GetDumpPhases(), PhaseName()))
+#endif
+
+#endif  /* MAPLEBE_INCLUDE_CG_CG_OPTION_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_options.h b/src/mapleall/maple_be/include/cg/cg_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b37bf93bd6082c1f51ee35e0431468e1eafedec
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_options.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_BE_INCLUDE_CG_OPTIONS_H
+#define MAPLE_BE_INCLUDE_CG_OPTIONS_H
+
+#include "cl_option.h"
+
+namespace opts::cg {
+
+extern maplecl::Option<bool> pie;
+extern maplecl::Option<bool> fpic;
+extern maplecl::Option<bool> verboseAsm;
+extern maplecl::Option<bool> verboseCg;
+extern maplecl::Option<bool> maplelinker;
+extern maplecl::Option<bool> quiet;
+extern maplecl::Option<bool> cg;
+extern maplecl::Option<bool> replaceAsm;
+extern maplecl::Option<bool> generalRegOnly;
+extern maplecl::Option<bool> lazyBinding;
+extern maplecl::Option<bool> hotFix;
+extern maplecl::Option<bool> ebo;
+extern maplecl::Option<bool> cfgo;
+extern maplecl::Option<bool> ico;
+extern maplecl::Option<bool> storeloadopt;
+extern maplecl::Option<bool> globalopt;
+extern maplecl::Option<bool> hotcoldsplit;
+extern maplecl::Option<bool> prelsra;
+extern maplecl::Option<bool> lsraLvarspill;
+extern maplecl::Option<bool> lsraOptcallee;
+extern maplecl::Option<bool> calleeregsPlacement;
+extern maplecl::Option<bool> ssapreSave;
+extern maplecl::Option<bool> ssupreRestore;
+extern maplecl::Option<bool> prepeep;
+extern maplecl::Option<bool> peep;
+extern maplecl::Option<bool> preschedule;
+extern maplecl::Option<bool> schedule;
+extern maplecl::Option<bool> retMerge;
+extern maplecl::Option<bool> vregRename;
+extern maplecl::Option<bool> fullcolor;
+extern maplecl::Option<bool> writefieldopt;
+extern maplecl::Option<bool> dumpOlog;
+extern maplecl::Option<bool> nativeopt;
+extern maplecl::Option<bool> objmap;
+extern maplecl::Option<bool> yieldpoint;
+extern maplecl::Option<bool> proepilogue;
+extern maplecl::Option<bool> localRc;
+extern maplecl::Option<bool> addDebugTrace;
+extern maplecl::Option<std::string> classListFile;
+extern maplecl::Option<bool> genCMacroDef;
+extern maplecl::Option<bool> genGctibFile;
+extern maplecl::Option<bool> unwindTables;
+extern maplecl::Option<bool> debug;
+extern maplecl::Option<bool> gdwarf;
+extern maplecl::Option<bool> gsrc;
+extern maplecl::Option<bool> gmixedsrc;
+extern maplecl::Option<bool> gmixedasm;
+extern maplecl::Option<bool> profile;
+extern maplecl::Option<bool> withRaLinearScan;
+extern maplecl::Option<bool> withRaGraphColor;
+extern maplecl::Option<bool> patchLongBranch;
+extern maplecl::Option<bool> constFold;
+extern maplecl::Option<std::string> ehExclusiveList;
+extern maplecl::Option<bool> o0;
+extern maplecl::Option<bool> o1;
+extern maplecl::Option<bool> o2;
+extern maplecl::Option<bool> os;
+extern maplecl::Option<bool> olitecg;
+extern maplecl::Option<uint64_t> lsraBb;
+extern maplecl::Option<uint64_t> lsraInsn;
+extern maplecl::Option<uint64_t> lsraOverlap;
+extern maplecl::Option<uint8_t> remat;
+extern maplecl::Option<bool> suppressFileinfo;
+extern maplecl::Option<bool> dumpCfg;
+extern maplecl::Option<std::string> target;
+extern maplecl::Option<std::string> dumpPhases;
+extern maplecl::Option<std::string> skipPhases;
+extern maplecl::Option<std::string> skipFrom;
+extern maplecl::Option<std::string> skipAfter;
+extern maplecl::Option<std::string> dumpFunc;
+extern maplecl::Option<bool> timePhases;
+extern maplecl::Option<bool> useBarriersForVolatile;
+extern maplecl::Option<std::string> range;
+extern maplecl::Option<uint8_t> fastAlloc;
+extern maplecl::Option<std::string> spillRange;
+extern maplecl::Option<bool> dupBb;
+extern maplecl::Option<bool> calleeCfi;
+extern maplecl::Option<bool> printFunc;
+extern maplecl::Option<std::string> cyclePatternList;
+extern maplecl::Option<std::string> duplicateAsmList;
+extern maplecl::Option<std::string> duplicateAsmList2;
+extern maplecl::Option<std::string> blockMarker;
+extern maplecl::Option<bool> soeCheck;
+extern maplecl::Option<bool> checkArraystore;
+extern maplecl::Option<bool> debugSchedule;
+extern maplecl::Option<bool> bruteforceSchedule;
+extern maplecl::Option<bool> simulateSchedule;
+extern maplecl::Option<bool> crossLoc;
+extern maplecl::Option<std::string> floatAbi;
+extern maplecl::Option<std::string> filetype;
+extern maplecl::Option<bool> longCalls;
+extern maplecl::Option<bool> functionSections;
+extern maplecl::Option<bool> omitFramePointer;
+extern maplecl::Option<bool> fastMath;
+extern maplecl::Option<bool> tailcall;
+extern maplecl::Option<bool> alignAnalysis;
+extern maplecl::Option<bool> cgSsa;
+extern maplecl::Option<bool> common;
+extern maplecl::Option<bool> condbrAlign;
+extern maplecl::Option<uint32_t> alignMinBbSize;
+extern maplecl::Option<uint32_t> alignMaxBbSize;
+extern maplecl::Option<uint32_t> loopAlignPow;
+extern maplecl::Option<uint32_t> jumpAlignPow;
+extern maplecl::Option<uint32_t> funcAlignPow;
+extern maplecl::Option<bool> litePgoGen;
+extern maplecl::Option<std::string> litePgoOutputFunc;
+extern maplecl::Option<std::string> instrumentationFile;
+extern maplecl::Option<std::string> litePgoFile;
+}
+
+#endif /* MAPLE_BE_INCLUDE_CG_OPTIONS_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_pgo_gen.h b/src/mapleall/maple_be/include/cg/cg_pgo_gen.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf8647e17198f26c817365b97b1c5a51308d0adf
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_pgo_gen.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_CG_PGO_GEN_H
+#define MAPLEBE_CG_INCLUDE_CG_PGO_GEN_H
+
+#include "cgfunc.h"
+#include "instrument.h"
+namespace maplebe {
+class CGProfGen {
+ public:
+  CGProfGen(CGFunc &curF, MemPool &mp)
+      : f(&curF),
+        instrumenter(mp) {}
+
+  void InstrumentFunction();
+  void CreateProfileCalls();
+  virtual void CreateIcallForWeakSymbol(BB &bb, const std::string &symName) = 0;
+  virtual void CreateClearIcall(BB &bb, const std::string &symName) = 0;
+  virtual void InstrumentBB(BB &bb, MIRSymbol &countTab, uint32 offset) = 0;
+ protected:
+  CGFunc *f;
+ private:
+  static uint64 counterIdx;
+  PGOInstrumentTemplate<maplebe::BB, maple::BBEdge<maplebe::BB>> instrumenter;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPgoGen, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}
+#endif // MAPLEBE_CG_INCLUDE_CG_PGO_GEN_H
diff --git a/src/mapleall/maple_be/include/cg/cg_pgo_use.h b/src/mapleall/maple_be/include/cg/cg_pgo_use.h
new file mode 100644
index 0000000000000000000000000000000000000000..97d5da631b6ea8ac2ed31d484610f45ba3e36338
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_pgo_use.h
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_CG_PGO_USE_H
+#define MAPLEBE_CG_INCLUDE_CG_PGO_USE_H
+#include "cgfunc.h"
+#include "instrument.h"
+#include "cg_dominance.h"
+namespace maplebe {
+class BBChain {
+ public:
+  using iterator = MapleVector<BB*>::iterator;
+  using const_iterator = MapleVector<BB*>::const_iterator;
+  BBChain(MapleAllocator &alloc, MapleVector<BBChain*> &bb2chain, BB &bb, uint32 inputId)
+      : id(inputId),
+        bbVec(1, &bb, alloc.Adapter()),
+        bb2chain(bb2chain) {
+    bb2chain[bb.GetId()] = this;
+  }
+
+  iterator begin() {
+    return bbVec.begin();
+  }
+  const_iterator begin() const {
+    return bbVec.begin();
+  }
+  iterator end() {
+    return bbVec.end();
+  }
+  const_iterator end() const {
+    return bbVec.end();
+  }
+
+  bool empty() const {
+    return bbVec.empty();
+  }
+
+  size_t size() const {
+    return bbVec.size();
+  }
+
+  uint32 GetId() const {
+    return id;
+  }
+
+  BB *GetHeader() {
+    CHECK_FATAL(!bbVec.empty(), "cannot get header from a empty bb chain");
+    return bbVec.front();
+  }
+  BB *GetTail() {
+    CHECK_FATAL(!bbVec.empty(), "cannot get tail from a empty bb chain");
+    return bbVec.back();
+  }
+
+  bool FindBB(BB &bb) {
+    auto fIt = std::find(bbVec.begin(), bbVec.end(), &bb);
+    return fIt != bbVec.end();
+  }
+
+  // update unlaidPredCnt if needed. The chain is ready to layout only if unlaidPredCnt == 0
+  bool IsReadyToLayout(const MapleVector<bool> *context) {
+    MayRecalculateUnlaidPredCnt(context);
+    return (unlaidPredCnt == 0);
+  }
+
+  // Merge src chain to this one
+  void MergeFrom(BBChain *srcChain);
+
+  void UpdateSuccChainBeforeMerged(const BBChain &destChain, const MapleVector<bool> *context,
+                                   MapleSet<BBChain*> &readyToLayoutChains);
+
+  void Dump() const {
+    LogInfo::MapleLogger() << "bb chain with " << bbVec.size() << " blocks: ";
+    for (BB *bb : bbVec) {
+      LogInfo::MapleLogger() << bb->GetId() << " ";
+    }
+    LogInfo::MapleLogger() << std::endl;
+  }
+
+  void DumpOneLine() const {
+    for (BB *bb : bbVec) {
+      LogInfo::MapleLogger() << bb->GetId() << " ";
+    }
+  }
+
+ private:
+  void MayRecalculateUnlaidPredCnt(const MapleVector<bool> *context);
+
+  uint32 id = 0;
+  MapleVector<BB*> bbVec;
+  MapleVector<BBChain*> &bb2chain;
+  uint32 unlaidPredCnt = 0;   // how many predecessors are not laid out
+  bool isCacheValid = false;  // whether unlaidPredCnt is trustable
+};
+
+class CGProfUse {
+ public:
+  CGProfUse(CGFunc &curF, MemPool &mp, DomAnalysis *dom, MapleSet<uint32> &newbbinsplit)
+      : f(&curF),
+        mp(&mp),
+        puAlloc(&mp),
+        domInfo(dom),
+        bbSplit(newbbinsplit),
+        instrumenter(mp),
+        bb2chain(puAlloc.Adapter()),
+        readyToLayoutChains(puAlloc.Adapter()),
+        layoutBBs(puAlloc.Adapter()),
+        laidOut(puAlloc.Adapter()) {}
+
+  bool ApplyPGOData();
+  void LayoutBBwithProfile();
+ protected:
+  CGFunc *f;
+  MemPool *mp;
+  MapleAllocator puAlloc;
+  DomAnalysis *domInfo = nullptr;
+  MapleSet<uint32> bbSplit;
+ private:
+  PGOInstrumentTemplate<maplebe::BB, maple::BBUseEdge<maplebe::BB>> instrumenter;
+  std::unordered_map<uint32, BBUseInfo<maplebe::BB>*> bbProfileInfo;
+
+  void ApplyOnBB();
+  void InitBBEdgeInfo();
+  /* compute all edge freq in the cfg without consider exception */
+  void ComputeEdgeFreq();
+  /* If all input edges or output edges determined, caculate BB freq */
+  void ComputeBBFreq(BBUseInfo<maplebe::BB> &bbInfo, bool &change);
+  uint64 SumEdgesCount(const MapleVector<BBUseEdge<maplebe::BB>*> &edges) const;
+  BBUseInfo<maplebe::BB> *GetOrCreateBBUseInfo(const maplebe::BB &bb, bool notCreate = false);
+  void SetEdgeCount(maple::BBUseEdge<maplebe::BB> &e, size_t count);
+
+  /* functions && members for PGO layout */
+  void BuildChainForFunc();
+  void BuildChainForLoops();
+  void BuildChainForLoop(CGFuncLoops &loop, MapleVector<bool> *context);
+  void InitBBChains();
+  void DoBuildChain(const BB &header, BBChain &chain, const MapleVector<bool> *context);
+  BB *GetBestSucc(BB &bb, const BBChain &chain, const MapleVector<bool> *context, bool considerBetterPred);
+  BB *FindBestStartBBForLoop(CGFuncLoops &loop, const MapleVector<bool> *context);
+
+  bool IsBBInCurrContext(const BB &bb, const MapleVector<bool> *context) const;
+  bool IsCandidateSucc(const BB &bb, const BB &succ, const MapleVector<bool> *context);
+  bool HasBetterLayoutPred(const BB &bb, const BB &succ) const;
+
+  void AddBBProf(BB &bb);
+  void AddBB(BB &bb);
+  void ReTargetSuccBB(BB &bb, BB &fallthru);
+  void ChangeToFallthruFromGoto(BB &bb);
+
+  MapleVector<BBChain*> bb2chain;
+  MapleSet<BBChain*> readyToLayoutChains;
+  bool debugChainLayout = false;
+  uint32 rpoSearchPos = 0;   // reverse post order search beginning position
+  MapleVector<BB*> layoutBBs;  // gives the determined layout order
+  MapleVector<bool> laidOut;   // indexed by bbid to tell if has been laid out
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPgoUse, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}
+#endif // MAPLEBE_CG_INCLUDE_CG_PGO_USE_H
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/cg_phase.h b/src/mapleall/maple_be/include/cg/cg_phase.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c0fe56006505489b092d98a82c7604d61b62023
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_phase.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CG_PHASE_H
+#define MAPLEBE_INCLUDE_CG_CG_PHASE_H
+
+namespace maple {}
+namespace maplebe {
+using namespace maple;
+class CGFunc;
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_CG_PHASE_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_phasemanager.h b/src/mapleall/maple_be/include/cg/cg_phasemanager.h
new file mode 100644
index 0000000000000000000000000000000000000000..411532ec236e584c5ccb06b4da4ea9bee0a48022
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_phasemanager.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CG_PHASEMANAGER_H
+#define MAPLEBE_INCLUDE_CG_CG_PHASEMANAGER_H
+#include <string>
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_module.h"
+#include "mir_lower.h"
+#include "lower.h"
+#include "constantfold.h"
+#include "cgfunc.h"
+#include "cg_phase.h"
+#include "cg_option.h"
+namespace maplebe {
+using CgFuncOptTy = MapleFunctionPhase<CGFunc>;
+
+/* =================== new phase manager ===================  */
+class CgFuncPM : public FunctionPM {
+ public:
+  explicit CgFuncPM(MemPool *mp) : FunctionPM(mp, &id) {}
+  PHASECONSTRUCTOR(CgFuncPM);
+  std::string PhaseName() const override;
+  ~CgFuncPM() override {
+    cgOptions = nullptr;
+    cg = nullptr;
+    beCommon = nullptr;
+    if (CGOptions::IsEnableTimePhases()) {
+      DumpPhaseTime();
+    }
+  }
+  bool PhaseRun(MIRModule &m) override;
+
+  void SetCGOptions(CGOptions *curCGOptions) {
+    cgOptions = curCGOptions;
+  }
+
+  CG *GetCG() {
+    return cg;
+  }
+  BECommon *GetBECommon() {
+    return beCommon;
+  }
+ private:
+  bool FuncLevelRun(CGFunc &cgFunc, AnalysisDataManager &serialADM);
+  void GenerateOutPutFile(MIRModule &m) const;
+  void CreateCGAndBeCommon(MIRModule &m);
+  void PrepareLower(MIRModule &m);
+  void PostOutPut(MIRModule &m) const;
+  void DoFuncCGLower(const MIRModule &m, MIRFunction &mirFunc) const;
+  /* Tool functions */
+  void DumpFuncCGIR(const CGFunc &f, const std::string &phaseName) const;
+  /* For Emit */
+  void InitProfile(MIRModule &m) const;
+  void EmitGlobalInfo(MIRModule &m) const;
+  void EmitDuplicatedAsmFunc(MIRModule &m) const;
+  void EmitDebugInfo(const MIRModule &m) const;
+  void EmitFastFuncs(const MIRModule &m) const;
+  bool IsFramework(MIRModule &m) const;
+  void SweepUnusedStaticSymbol(MIRModule &m) const;
+
+  CG *cg = nullptr;
+  BECommon *beCommon = nullptr;
+  MIRLower *mirLower = nullptr;
+  CGLowerer *cgLower = nullptr;
+  /* module options */
+  CGOptions *cgOptions = nullptr;
+};
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_CG_PHASEMANAGER_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_phi_elimination.h b/src/mapleall/maple_be/include/cg/cg_phi_elimination.h
new file mode 100644
index 0000000000000000000000000000000000000000..1fe8d22ab948a2e3c5d17315e6a05a646edf27da
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_phi_elimination.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_CG_PHI_ELIMINATE_H
+#define MAPLEBE_CG_INCLUDE_CG_PHI_ELIMINATE_H
+
+#include "cgfunc.h"
+#include "cg_ssa.h"
+
+namespace maplebe {
+class PhiEliminate {
+ public:
+  PhiEliminate(CGFunc &f, CGSSAInfo &ssaAnalysisResult, MemPool &mp)
+      : cgFunc(&f),
+        ssaInfo(&ssaAnalysisResult),
+        phiEliAlloc(&mp),
+        eliminatedBB(phiEliAlloc.Adapter()),
+        replaceVreg(phiEliAlloc.Adapter()),
+        remateInfoAfterSSA(phiEliAlloc.Adapter()) {
+    tempRegNO = static_cast<uint32_t>(GetSSAInfo()->GetAllSSAOperands().size()) + CGSSAInfo::ssaRegNObase;
+  }
+  virtual ~PhiEliminate() = default;
+  CGSSAInfo *GetSSAInfo() {
+    return ssaInfo;
+  }
+  void TranslateTSSAToCSSA();
+  /* move ssaRegOperand from ssaInfo to cgfunc */
+  virtual void ReCreateRegOperand(Insn &insn) = 0;
+
+ protected:
+  virtual Insn &CreateMov(RegOperand &destOpnd, RegOperand &fromOpnd) = 0;
+  virtual void MaintainRematInfo(RegOperand &destOpnd, RegOperand &fromOpnd, bool isCopy) = 0;
+  virtual void AppendMovAfterLastVregDef(BB &bb, Insn &movInsn) const = 0;
+  void UpdateRematInfo();
+  regno_t GetAndIncreaseTempRegNO();
+  regno_t RecursiveBothDU(RegOperand &ssaOpnd);
+  RegOperand *MakeRoomForNoDefVreg(RegOperand &conflictReg);
+  void RecordRematInfo(regno_t vRegNO, PregIdx pIdx);
+  PregIdx FindRematInfo(regno_t vRegNO) {
+    return (remateInfoAfterSSA.count(vRegNO)) > 0 ? remateInfoAfterSSA[vRegNO] : -1;
+  }
+  CGFunc *cgFunc;
+  CGSSAInfo *ssaInfo;
+  MapleAllocator phiEliAlloc;
+
+ private:
+  void PlaceMovInPredBB(uint32 predBBId, Insn &movInsn) const;
+  virtual RegOperand &CreateTempRegForCSSA(RegOperand &oriOpnd) = 0;
+  MapleSet<uint32> eliminatedBB;
+  /*
+   * noDef Vregs occupy the vregno_t which is used for ssa re_creating
+   * first : conflicting VReg with noDef VReg  second : new_Vreg opnd to replace occupied Vreg
+   */
+  MapleUnorderedMap<regno_t, RegOperand*> replaceVreg;
+  regno_t tempRegNO = 0; /* use for create mov insn for phi */
+  MapleMap<regno_t, PregIdx> remateInfoAfterSSA;
+};
+
+class OperandPhiElmVisitor : public OperandVisitorBase,
+                             public OperandVisitors<RegOperand, ListOperand, MemOperand> {
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgPhiElimination, maplebe::CGFunc)
+}
+
+#endif // MAPLEBE_CG_INCLUDE_CG_PHI_ELIMINATE_H
diff --git a/src/mapleall/maple_be/include/cg/cg_pre.h b/src/mapleall/maple_be/include/cg/cg_pre.h
new file mode 100644
index 0000000000000000000000000000000000000000..40e80d65fa1687860f0c12b7b427fcc236ba19e2
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_pre.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_CGPRE_H
+#define MAPLEBE_CG_INCLUDE_CGPRE_H
+#include "cg_occur.h"
+#include "cg_dominance.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+enum PreKind {
+  kExprPre,
+  kStmtPre,
+  kLoadPre,
+  kAddrPre
+};
+
+class CGPre {
+ public:
+  CGPre(DomAnalysis &currDom, MemPool &memPool, MemPool &mp2, PreKind kind, uint32 limit)
+      : dom(&currDom),
+        ssaPreMemPool(&memPool),
+        ssaPreAllocator(&memPool),
+        perCandMemPool(&mp2),
+        perCandAllocator(&mp2),
+        workList(ssaPreAllocator.Adapter()),
+        preKind(kind),
+        allOccs(ssaPreAllocator.Adapter()),
+        phiOccs(ssaPreAllocator.Adapter()),
+        exitOccs(ssaPreAllocator.Adapter()),
+        preLimit(limit),
+        dfPhiDfns(std::less<uint32>(), ssaPreAllocator.Adapter()),
+        varPhiDfns(std::less<uint32>(), ssaPreAllocator.Adapter()),
+        temp2LocalRefVarMap(ssaPreAllocator.Adapter()) {
+    preWorkCandHashTable.GetWorkcandHashTable().fill(nullptr);
+  }
+
+  virtual ~CGPre() = default;
+
+  const MapleVector<CgOccur*> &GetRealOccList() const {
+    return workCand->GetRealOccs();
+  }
+
+  virtual BB *GetBB(uint32 id) const = 0;
+  virtual PUIdx GetPUIdx() const = 0;
+  virtual void SetCurFunction(PUIdx) const {}
+
+  void GetIterDomFrontier(const BB *bb, MapleSet<uint32> *dfset) const {
+    for (uint32 bbid : dom->GetIdomFrontier(bb->GetId())) {
+      (void)dfset->insert(dom->GetDtDfnItem(bbid));
+    }
+  }
+
+  PreWorkCand* GetWorkCand() const {
+    return workCand;
+  }
+  // compute downsafety for each PHI
+  static void ResetDS(CgPhiOcc *phiOcc);
+  void ComputeDS();
+
+ protected:
+  virtual void ComputeVarAndDfPhis() = 0;
+  virtual void CreateSortedOccs();
+  CgOccur *CreateRealOcc(Insn &insn, Operand &opnd, OccType occType);
+  virtual void BuildWorkList() = 0;
+  /* for stmt pre only */
+  void CreateExitOcc(BB &bb) {
+    CgOccur *exitOcc = ssaPreMemPool->New<CgOccur>(kOccExit, 0, bb, nullptr);
+    exitOccs.push_back(exitOcc);
+  }
+
+  DomAnalysis *dom;
+  MemPool *ssaPreMemPool;
+  MapleAllocator ssaPreAllocator;
+  MemPool *perCandMemPool;
+  MapleAllocator perCandAllocator;
+  MapleList<PreWorkCand*> workList;
+  PreWorkCand *workCand = nullptr;  // the current PreWorkCand
+  PreKind preKind;
+
+  // PRE work candidates; incremented by 2 for each tree;
+  // purpose is to avoid processing a node the third time
+  // inside a tree (which is a DAG)
+  // the following 3 lists are all maintained in order of dt_preorder
+  MapleVector<CgOccur*> allOccs;     // cleared at start of each workcand
+  MapleVector<CgPhiOcc*> phiOccs;    // cleared at start of each workcand
+  MapleVector<CgOccur*> exitOccs;  // this is shared by all workcands
+  uint32 preLimit;  // set by command-line option to limit the number of candidates optimized (for debugging purpose)
+  // step 1 phi insertion data structures
+  // following are set of BBs in terms of their dfn's; index into
+  // dominance->pdt_preorder to get their bbid's
+  MapleSet<uint32> dfPhiDfns;   // phis inserted due to dominance frontiers
+  MapleSet<uint32> varPhiDfns;  // phis inserted due to the var operands
+  // step 2 renaming data structures
+  uint32 classCount = 0;            // count class created during renaming
+  // is index into workCand->realOccs
+  // step 6 codemotion data structures
+  MapleMap<Operand*, Operand*> temp2LocalRefVarMap;
+  int32 reBuiltOccIndex = -1;  // stores the size of worklist every time when try to add new worklist, update before
+  // each code motion
+  uint32 strIdxCount = 0;  // ssapre will create a lot of temp variables if using var to store redundances, start from 0
+  PreWorkCandHashTable preWorkCandHashTable;
+};
+}  // namespace maple
+#endif  // MAPLEBE_CG_INCLUDE_CGPRE_H
diff --git a/src/mapleall/maple_be/include/cg/cg_prop.h b/src/mapleall/maple_be/include/cg/cg_prop.h
new file mode 100644
index 0000000000000000000000000000000000000000..885c84273d39156366e30a9fcde8d3e603e67cf5
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_prop.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_PROP_H
+#define MAPLEBE_INCLUDE_CG_PROP_H
+
+#include "cgfunc.h"
+#include "cg_ssa.h"
+#include "cg_dce.h"
+#include "cg.h"
+#include "reg_coalesce.h"
+
+namespace maplebe {
+class CGProp {
+ public:
+  CGProp(MemPool &mp, CGFunc &f, CGSSAInfo &sInfo, LiveIntervalAnalysis &ll)
+      : memPool(&mp),
+        cgFunc(&f),
+        propAlloc(&mp),
+        ssaInfo(&sInfo),
+        regll(&ll) {
+    cgDce = f.GetCG()->CreateCGDce(mp, f, sInfo);
+  }
+  virtual ~CGProp() = default;
+
+  void DoCopyProp();
+  void DoTargetProp();
+
+ protected:
+  MemPool *memPool;
+  CGFunc *cgFunc;
+  MapleAllocator propAlloc;
+  CGSSAInfo *GetSSAInfo() {
+    return ssaInfo;
+  }
+  CGDce *GetDce() {
+    return cgDce;
+  }
+  LiveIntervalAnalysis *GetRegll() {
+    return regll;
+  }
+
+ private:
+  virtual void CopyProp() = 0;
+  virtual void TargetProp(Insn &insn) = 0;
+  virtual void PropPatternOpt() = 0;
+  CGSSAInfo *ssaInfo;
+  CGDce *cgDce = nullptr;
+  LiveIntervalAnalysis *regll;
+};
+
+class PropOptimizeManager {
+ public:
+  ~PropOptimizeManager() = default;
+  template<typename PropOptimizePattern>
+  void Optimize(CGFunc &cgFunc, CGSSAInfo *cgssaInfo, LiveIntervalAnalysis *ll) const {
+    PropOptimizePattern optPattern(cgFunc, cgssaInfo, ll);
+    optPattern.Run();
+  }
+  template<typename PropOptimizePattern>
+  void Optimize(CGFunc &cgFunc, CGSSAInfo *cgssaInfo) const {
+    PropOptimizePattern optPattern(cgFunc, cgssaInfo);
+    optPattern.Run();
+  }
+};
+
+class PropOptimizePattern {
+ public:
+  PropOptimizePattern(CGFunc &cgFunc, CGSSAInfo *cgssaInfo, LiveIntervalAnalysis *ll)
+      : cgFunc(cgFunc),
+        optSsaInfo(cgssaInfo),
+        regll(ll) {}
+
+  PropOptimizePattern(CGFunc &cgFunc, CGSSAInfo *cgssaInfo)
+      : cgFunc(cgFunc),
+        optSsaInfo(cgssaInfo) {}
+  virtual ~PropOptimizePattern() = default;
+  virtual bool CheckCondition(Insn &insn) = 0;
+  virtual void Optimize(Insn &insn) = 0;
+  virtual void Run() = 0;
+
+ protected:
+  std::string PhaseName() const {
+    return "propopt";
+  }
+  virtual void Init() = 0;
+  Insn *FindDefInsn(const VRegVersion *useVersion) const;
+
+  CGFunc &cgFunc;
+  CGSSAInfo *optSsaInfo = nullptr;
+  LiveIntervalAnalysis *regll = nullptr;
+};
+
+class ReplaceRegOpndVisitor : public OperandVisitorBase,
+                              public OperandVisitors<RegOperand, ListOperand, MemOperand>,
+                              public OperandVisitor<PhiOperand> {
+ public:
+  ReplaceRegOpndVisitor(CGFunc &f, Insn &cInsn, uint32 cIdx, RegOperand &oldR, RegOperand &newR)
+      : cgFunc(&f),
+        insn(&cInsn),
+        idx(cIdx),
+        oldReg(&oldR),
+        newReg(&newR) {}
+  virtual ~ReplaceRegOpndVisitor() = default;
+
+ protected:
+  CGFunc *cgFunc;
+  Insn *insn;
+  uint32 idx;
+  RegOperand *oldReg;
+  RegOperand *newReg;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgCopyProp, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE(CgTargetProp, maplebe::CGFunc)
+}
+#endif /* MAPLEBE_INCLUDE_CG_PROP_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_rce.h b/src/mapleall/maple_be/include/cg/cg_rce.h
new file mode 100644
index 0000000000000000000000000000000000000000..2fc3d2e11c0ede5a07756350262cbdf8476de723
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_rce.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_RCE_H
+#define MAPLEBE_INCLUDE_CG_RCE_H
+
+#include "cg.h"
+#include "cgfunc.h"
+#include "cgbb.h"
+#include "cg_ssa.h"
+
+namespace maplebe {
+#define CG_RCE_DUMP CG_DEBUG_FUNC(*cgFunc)
+using InsnSet = std::set<Insn*, InsnIdCmp>;
+static uint32 g_count = 0;
+class RedundantComputeElim {
+ public:
+  RedundantComputeElim(CGFunc &f, CGSSAInfo &info, MemPool &mp) :
+      cgFunc(&f), ssaInfo(&info), rceAlloc(&mp) {}
+  virtual ~RedundantComputeElim() = default;
+
+  std::string PhaseName() const {
+    return "cgredundantcompelim";
+  }
+
+  virtual void Run() = 0;
+  void Dump(const Insn *insn1, const Insn *insn2) const;
+
+ protected:
+  CGFunc *cgFunc;
+  CGSSAInfo *ssaInfo;
+  MapleAllocator rceAlloc;
+};
+MAPLE_FUNC_PHASE_DECLARE(CgRedundantCompElim, maplebe::CGFunc)
+} /* namespace maplebe */
+#endif /* MAPLEBE_INCLUDE_CG_RCE_H */
diff --git a/src/mapleall/maple_be/include/cg/cg_ssa.h b/src/mapleall/maple_be/include/cg/cg_ssa.h
new file mode 100644
index 0000000000000000000000000000000000000000..1853481ac4021bbd4f0bbe1604d1bc7e65f882b2
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_ssa.h
@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_CG_SSA_H
+#define MAPLEBE_CG_INCLUDE_CG_SSA_H
+
+#include "cgfunc.h"
+#include "cg_dominance.h"
+#include "live.h"
+#include "operand.h"
+#include "visitor_common.h"
+
+namespace maplebe {
+class CGSSAInfo;
+enum SSAOpndDefBy {
+  kDefByNo,
+  kDefByInsn,
+  kDefByPhi
+};
+
+/* precise def/use info in machine instrcution */
+class DUInsnInfo {
+ public:
+  DUInsnInfo(Insn *cInsn, uint32 cIdx, MapleAllocator &alloc) : insn(cInsn), defUseInfo(alloc.Adapter()) {
+    IncreaseDU(cIdx);
+  }
+  void IncreaseDU(uint32 idx) {
+    if (defUseInfo.count(idx) == 0) {
+      defUseInfo[idx] = 0;
+    }
+    defUseInfo[idx]++;
+  }
+  void DecreaseDU(uint32 idx) {
+    ASSERT(defUseInfo[idx] > 0, "no def/use any more");
+    defUseInfo[idx]--;
+  }
+  void ClearDU(uint32 idx) {
+    ASSERT(defUseInfo.count(idx), "no def/use find");
+    defUseInfo[idx] = 0;
+  }
+  bool HasNoDU() {
+    for (auto &it : std::as_const(defUseInfo)) {
+      if (it.second != 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+  Insn *GetInsn() {
+    return insn;
+  }
+  MapleMap<uint32, uint32>& GetOperands() {
+    return defUseInfo;
+  }
+ private:
+  Insn *insn;
+  /* operand idx --- count */
+  MapleMap<uint32, uint32> defUseInfo;
+};
+
+class VRegVersion {
+ public:
+  VRegVersion(const MapleAllocator &alloc, RegOperand &vReg, uint32 vIdx, regno_t vregNO)
+      : versionAlloc(alloc),
+        ssaRegOpnd(&vReg),
+        versionIdx(vIdx),
+        originalRegNO(vregNO),
+        useInsnInfos(versionAlloc.Adapter()) {}
+  void SetDefInsn(DUInsnInfo *duInfo, SSAOpndDefBy defTy) {
+    defInsnInfo = duInfo;
+    defType = defTy;
+  }
+  DUInsnInfo *GetDefInsnInfo() const {
+    return defInsnInfo;
+  }
+  SSAOpndDefBy GetDefType() const {
+    return defType;
+  }
+  RegOperand *GetSSAvRegOpnd(bool isDef = true) {
+    if (!isDef) {
+      return implicitCvtedRegOpnd;
+    }
+    return ssaRegOpnd;
+  }
+  uint32 GetVersionIdx() const {
+    return versionIdx;
+  }
+  regno_t GetOriginalRegNO() const {
+    return originalRegNO;
+  }
+  void AddUseInsn(CGSSAInfo &ssaInfo, Insn &useInsn, uint32 idx);
+  /* elimate dead use */
+  void CheckDeadUse(const Insn &useInsn);
+  void RemoveUseInsn(const Insn &useInsn, uint32 idx);
+  MapleUnorderedMap<uint32, DUInsnInfo*> &GetAllUseInsns() {
+    return useInsnInfos;
+  }
+  void MarkDeleted() {
+    deleted = true;
+  }
+  void MarkRecovery() {
+    deleted = false;
+  }
+  bool IsDeleted() const {
+    return deleted;
+  }
+  void SetImplicitCvt() {
+    hasImplicitCvt = true;
+  }
+  bool HasImplicitCvt() const {
+    return hasImplicitCvt;
+  }
+
+ private:
+  MapleAllocator versionAlloc;
+  /* if this version has implicit conversion, it refers to def reg */
+  RegOperand *ssaRegOpnd;
+  RegOperand *implicitCvtedRegOpnd = nullptr;
+  uint32 versionIdx;
+  regno_t originalRegNO;
+  DUInsnInfo *defInsnInfo = nullptr;
+  SSAOpndDefBy defType = kDefByNo;
+  /* insn ID ->  insn* & operand Idx */
+  // --> vector?
+  MapleUnorderedMap<uint32, DUInsnInfo*> useInsnInfos;
+  bool deleted = false;
+  /*
+   * def reg (size:64)  or       def reg (size:32)  -->
+   * all use reg (size:32)       all use reg (size:64)
+   * do not support single use which has implicit conversion yet
+   * support single use in defUseInfo in future
+   */
+  bool hasImplicitCvt = false;
+};
+
+class CGSSAInfo {
+ public:
+  CGSSAInfo(CGFunc &f, DomAnalysis &da, MemPool &mp, MemPool &tmp)
+      : cgFunc(&f),
+        memPool(&mp),
+        tempMp(&tmp),
+        ssaAlloc(&mp),
+        domInfo(&da),
+        renamedBBs(ssaAlloc.Adapter()),
+        vRegDefCount(ssaAlloc.Adapter()),
+        vRegStk(ssaAlloc.Adapter()),
+        allSSAOperands(ssaAlloc.Adapter()),
+        noDefVRegs(ssaAlloc.Adapter()),
+        reversePostOrder(ssaAlloc.Adapter()),
+        safePropInsns(ssaAlloc.Adapter()) {}
+  virtual ~CGSSAInfo() = default;
+  void ConstructSSA();
+  VRegVersion *FindSSAVersion(regno_t ssaRegNO); /* Get specific ssa info */
+  Insn *GetDefInsn(const RegOperand &useReg);
+  virtual void ReplaceInsn(Insn &oriInsn, Insn &newInsn) = 0; /* replace insn & update ssaInfo */
+  virtual void ReplaceAllUse(VRegVersion *toBeReplaced, VRegVersion *newVersion) = 0;
+  virtual void CreateNewInsnSSAInfo(Insn &newInsn) = 0;
+  PhiOperand &CreatePhiOperand();
+
+  DUInsnInfo *CreateDUInsnInfo(Insn *cInsn, uint32 idx) {
+    return memPool->New<DUInsnInfo>(cInsn, idx, ssaAlloc);
+  }
+  const MapleUnorderedMap<regno_t, VRegVersion*> &GetAllSSAOperands() const {
+    return allSSAOperands;
+  }
+  bool IsNoDefVReg(regno_t vRegNO) const {
+    return noDefVRegs.find(vRegNO) != noDefVRegs.end();
+  }
+  uint32 GetVersionNOOfOriginalVreg(regno_t vRegNO) {
+    if (vRegDefCount.count(vRegNO) > 0) {
+      return vRegDefCount[vRegNO];
+    }
+    ASSERT(false, " original vreg is not existed");
+    return 0;
+  }
+  MapleVector<uint32> &GetReversePostOrder() {
+    return reversePostOrder;
+  }
+  void InsertSafePropInsn(uint32 insnId) {
+    (void)safePropInsns.emplace_back(insnId);
+  }
+  MapleVector<uint32> &GetSafePropInsns() {
+    return safePropInsns;
+  }
+  void DumpFuncCGIRinSSAForm() const;
+  virtual void DumpInsnInSSAForm(const Insn &insn) const = 0;
+  static uint32 ssaRegNObase;
+
+ protected:
+  VRegVersion *CreateNewVersion(RegOperand &virtualOpnd, Insn &defInsn, uint32 idx, bool isDefByPhi = false);
+  virtual RegOperand *CreateSSAOperand(RegOperand &virtualOpnd) = 0;
+  bool IncreaseSSAOperand(regno_t vRegNO, VRegVersion *vst);
+  uint32 IncreaseVregCount(regno_t vRegNO);
+  VRegVersion *GetVersion(const RegOperand &virtualOpnd);
+  MapleUnorderedMap<regno_t, VRegVersion*> &GetPrivateAllSSAOperands() {
+    return allSSAOperands;
+  }
+  void AddNoDefVReg(regno_t noDefVregNO) {
+    ASSERT(!noDefVRegs.count(noDefVregNO), "duplicate no def Reg, please check");
+    noDefVRegs.emplace(noDefVregNO);
+  }
+  void MarkInsnsInSSA(Insn &insn);
+  CGFunc *cgFunc  = nullptr;
+  MemPool *memPool = nullptr;
+  MemPool *tempMp = nullptr;
+  MapleAllocator ssaAlloc;
+
+ private:
+  void InsertPhiInsn();
+  void RenameVariablesForBB(uint32 bbID);
+  void RenameBB(BB &bb);
+  void RenamePhi(BB &bb);
+  virtual void RenameInsn(Insn &insn) = 0;
+  /* build ssa on virtual register only */
+  virtual RegOperand *GetRenamedOperand(RegOperand &vRegOpnd, bool isDef, Insn &curInsn, uint32 idx) = 0;
+  void RenameSuccPhiUse(const BB &bb);
+  void PrunedPhiInsertion(const BB &bb, RegOperand &virtualOpnd);
+
+  void AddRenamedBB(uint32 bbID) {
+    ASSERT(!renamedBBs.count(bbID), "cgbb has been renamed already");
+    renamedBBs.emplace(bbID);
+  }
+  bool IsBBRenamed(uint32 bbID) const {
+    return renamedBBs.count(bbID);
+  }
+  void SetReversePostOrder();
+
+  DomAnalysis *domInfo = nullptr;
+  MapleSet<uint32> renamedBBs;
+  /* original regNO - number of definitions (start from 0) */
+  MapleMap<regno_t, uint32> vRegDefCount;
+  /* original regNO - ssa version stk */
+  MapleMap<regno_t, MapleStack<VRegVersion*>> vRegStk;
+  /* ssa regNO - ssa virtual operand version */
+  MapleUnorderedMap<regno_t, VRegVersion*> allSSAOperands;
+  /* For virtual registers which do not have definition */
+  MapleSet<regno_t> noDefVRegs;
+  /* only save bb_id to reduce space */
+  MapleVector<uint32> reversePostOrder;
+  /* destSize < srcSize but can be propagated */
+  MapleVector<uint32> safePropInsns;
+  int32 insnCount = 0;
+};
+
+class SSAOperandVisitor : public OperandVisitorBase,
+                          public OperandVisitors<RegOperand, ListOperand, MemOperand> {
+ public:
+  SSAOperandVisitor(Insn &cInsn, const OpndDesc &cDes, uint32 idx) : insn(&cInsn), opndDes(&cDes), idx(idx) {}
+  SSAOperandVisitor() = default;
+  virtual ~SSAOperandVisitor() = default;
+  void SetInsnOpndInfo(Insn &cInsn, const OpndDesc &cDes, uint32 index) {
+    insn = &cInsn;
+    opndDes = &cDes;
+    this->idx = index;
+  }
+
+ protected:
+  Insn *insn = nullptr;
+  const OpndDesc *opndDes = nullptr;
+  uint32 idx = 0;
+};
+
+class SSAOperandDumpVisitor : public OperandVisitorBase,
+                              public OperandVisitors<RegOperand, ListOperand, MemOperand>,
+                              public OperandVisitor<PhiOperand> {
+ public:
+  explicit SSAOperandDumpVisitor(const MapleUnorderedMap<regno_t, VRegVersion*> &allssa) : allSSAOperands(allssa) {}
+  virtual ~SSAOperandDumpVisitor() = default;
+  void SetHasDumped() {
+    hasDumped = true;
+  }
+  bool HasDumped() const {
+    return hasDumped;
+  }
+  bool hasDumped = false;
+ protected:
+  const MapleUnorderedMap<regno_t, VRegVersion*> &allSSAOperands;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgSSAConstruct, maplebe::CGFunc);
+CGSSAInfo *GetResult() {
+  return ssaInfo;
+}
+CGSSAInfo *ssaInfo = nullptr;
+ private:
+  void GetAnalysisDependence(maple::AnalysisDep &aDep) const override;
+MAPLE_FUNC_PHASE_DECLARE_END
+}
+
+#endif // MAPLEBE_CG_INCLUDE_CG_SSA_H
diff --git a/src/mapleall/maple_be/include/cg/cg_ssa_pre.h b/src/mapleall/maple_be/include/cg/cg_ssa_pre.h
new file mode 100644
index 0000000000000000000000000000000000000000..988b979456fce3f9e0f351aa06463976d2f95004
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_ssa_pre.h
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_CG_SSU_PRE_H
+#define MAPLEBE_CG_INCLUDE_CG_SSU_PRE_H
+#include <vector>
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "cg_dominance.h"
+
+// Use SSAPRE to determine where to insert saves for callee-saved registers.
+// The external interface is DoSavePlacementOpt(). Class SsaPreWorkCand is used
+// as input/output interface.
+
+namespace maplebe {
+
+using BBId = uint32;
+
+// This must have been constructed by the caller of DoSavePlacementOpt() and
+// passed to it as parameter.  The caller of DoSavePlacementOpt() describes
+// the problem via occBBs.  DoSavePlacementOpt()'s outputs are returned to the
+// caller by setting saveAtEntryBBs.
+class SsaPreWorkCand {
+ public:
+  explicit SsaPreWorkCand(MapleAllocator *alloc) : occBBs(alloc->Adapter()), saveAtEntryBBs(alloc->Adapter()) {}
+  // inputs
+  MapleSet<BBId> occBBs; // Id's of BBs with appearances of the callee-saved reg
+  // outputs
+  MapleSet<BBId> saveAtEntryBBs; // Id's of BBs to insert saves of the register at BB entry
+  bool saveAtProlog = false;    // if true, no shrinkwrapping can be done and
+                                // the other outputs can be ignored
+};
+
+extern void DoSavePlacementOpt(CGFunc *f, DomAnalysis *dom, SsaPreWorkCand *workCand);
+
+enum AOccType {
+  kAOccUndef,
+  kAOccReal,
+  kAOccPhi,
+  kAOccPhiOpnd,
+  kAOccExit,
+};
+
+class Occ {
+ public:
+  Occ(AOccType ty, BB *bb) : occTy(ty), cgbb(bb) {}
+  virtual ~Occ() = default;
+
+  virtual void Dump() const = 0;
+  bool IsDominate(DomAnalysis *dom, const Occ *occ) const {
+    return dom->Dominate(*cgbb, *occ->cgbb);
+  }
+
+  AOccType occTy;
+  uint32 classId = 0;
+  BB *cgbb;  // the BB it occurs in
+  Occ *def = nullptr;  // points to its single def
+};
+
+class RealOcc : public Occ {
+ public:
+  explicit RealOcc(BB *bb): Occ(kAOccReal, bb) {}
+  virtual ~RealOcc() = default;
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "RealOcc at bb" << cgbb->GetId();
+    LogInfo::MapleLogger() << " classId" << classId;
+  }
+
+  bool redundant = true;
+};
+
+class PhiOcc;
+
+class PhiOpndOcc : public Occ {
+ public:
+  explicit PhiOpndOcc(BB *bb): Occ(kAOccPhiOpnd, bb) {}
+  virtual ~PhiOpndOcc() = default;
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "PhiOpndOcc at bb" << cgbb->GetId() << " classId" << classId;
+  }
+
+  PhiOcc *defPhiOcc = nullptr;  // its lhs definition
+  bool hasRealUse = false;
+  bool insertHere = false;
+};
+
+class PhiOcc : public Occ {
+ public:
+  PhiOcc(BB *bb, MapleAllocator &alloc)
+      : Occ(kAOccPhi, bb), phiOpnds(alloc.Adapter()) {}
+  virtual ~PhiOcc() = default;
+
+  bool WillBeAvail() const {
+    return isCanBeAvail && !isLater;
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "PhiOcc at bb" << cgbb->GetId() << " classId" << classId << " Phi[";
+    for (size_t i = 0; i < phiOpnds.size(); i++) {
+      phiOpnds[i]->Dump();
+      if (i != phiOpnds.size() - 1) {
+        LogInfo::MapleLogger() << ", ";
+      }
+    }
+    LogInfo::MapleLogger() << "]";
+  }
+
+  bool isDownsafe = true;
+  bool speculativeDownsafe = false;  // true if set to downsafe via speculation
+  bool isCanBeAvail = true;
+  bool isLater = true;
+  MapleVector<PhiOpndOcc*> phiOpnds;
+};
+
+class ExitOcc : public Occ {
+ public:
+  explicit ExitOcc(BB *bb) : Occ(kAOccExit, bb) {}
+  virtual ~ExitOcc() = default;
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "ExitOcc at bb" << cgbb->GetId();
+  }
+};
+
+class SSAPre {
+ public:
+  SSAPre(CGFunc *cgfunc, DomAnalysis *dm, MemPool *memPool, SsaPreWorkCand *wkcand, bool aeap, bool enDebug)
+      : cgFunc(cgfunc),
+        dom(dm),
+        preMp(memPool),
+        preAllocator(memPool),
+        workCand(wkcand),
+        fullyAntBBs(cgfunc->GetAllBBs().size(), true, preAllocator.Adapter()),
+        phiDfns(std::less<uint32>(), preAllocator.Adapter()),
+        classCount(0),
+        realOccs(preAllocator.Adapter()),
+        allOccs(preAllocator.Adapter()),
+        phiOccs(preAllocator.Adapter()),
+        exitOccs(preAllocator.Adapter()),
+        asEarlyAsPossible(aeap),
+        enabledDebug(enDebug) {}
+  ~SSAPre() = default;
+
+  void ApplySSAPre();
+
+ private:
+  // step 6 methods
+  void CodeMotion();
+  // step 5 methods
+  void Finalize();
+  // step 4 methods
+  void ResetCanBeAvail(PhiOcc *phi) const;
+  void ComputeCanBeAvail() const;
+  void ResetLater(PhiOcc *phi) const;
+  void ComputeLater() const;
+  // step 3 methods
+  void ResetDownsafe(const PhiOpndOcc *phiOpnd) const;
+  void ComputeDownsafe() const;
+  // step 2 methods
+  void Rename();
+  // step 1 methods
+  void GetIterDomFrontier(const BB *bb, MapleSet<uint32> *dfset) const {
+    for (BBId bbid : dom->GetIdomFrontier(bb->GetId())) {
+      (void)dfset->insert(dom->GetDtDfnItem(bbid));
+    }
+  }
+  void FormPhis();
+  void CreateSortedOccs();
+  // step 0 methods
+  void PropagateNotAnt(BB *bb, std::set<BB*, BBIdCmp> *visitedBBs);
+  void FormRealsNExits();
+
+  CGFunc *cgFunc;
+  DomAnalysis *dom;
+  MemPool *preMp;
+  MapleAllocator preAllocator;
+  SsaPreWorkCand *workCand;
+  // step 0
+  MapleVector<bool> fullyAntBBs; // index is BBid; true if occ is fully anticipated at BB entry
+  // step 1 phi insertion data structures:
+  MapleSet<uint32> phiDfns;  // set by FormPhis(); set of BBs in terms of their
+                             // dfn's; index into dominance->dt_preorder to get
+                             // their bbid's
+  // step 2 renaming
+  uint32 classCount;  // for assigning new class id
+  // the following 4 lists are all maintained in order of dt_preorder
+  MapleVector<Occ*> realOccs;
+  MapleVector<Occ*> allOccs;
+  MapleVector<PhiOcc*> phiOccs;
+  MapleVector<ExitOcc*> exitOccs;
+  bool asEarlyAsPossible;
+  bool enabledDebug;
+};
+
+};  // namespace maplabe
+#endif  // MAPLEBE_CG_INCLUDE_CG_SSA_PRE_H
diff --git a/src/mapleall/maple_be/include/cg/cg_ssu_pre.h b/src/mapleall/maple_be/include/cg/cg_ssu_pre.h
new file mode 100644
index 0000000000000000000000000000000000000000..26252c241e7264fcf1b7f51578124ff423295352
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_ssu_pre.h
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_CG_INCLUDE_CGSSUPRE_H
+#define MAPLEBE_CG_INCLUDE_CGSSUPRE_H
+#include <vector>
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "cg_dominance.h"
+#include "cg_ssa_pre.h"
+
+// Use SSUPRE to determine where to insert restores for callee-saved registers.
+// The external interface is DoRestorePlacementOpt(). Class SPreWorkCand is used
+// as input/output interface.
+
+namespace maplebe {
+
+// This must have been constructed by the caller of DoRestorePlacementOpt() and
+// passed to it as parameter.  The caller of DoRestorePlacementOpt() describes
+// the problem via occBBs and saveBBs.  DoRestorePlacementOpt()'s outputs are
+// returned to the caller by setting restoreAtEntryBBs and restoreAtExitBBs.
+class SPreWorkCand {
+ public:
+  explicit SPreWorkCand(MapleAllocator *alloc)
+      : occBBs(alloc->Adapter()),
+        saveBBs(alloc->Adapter()),
+        restoreAtEntryBBs(alloc->Adapter()),
+        restoreAtExitBBs(alloc->Adapter()) {}
+  // inputs
+  MapleSet<BBId> occBBs; // Id's of BBs with appearances of the callee-saved reg
+  MapleSet<BBId> saveBBs;  // Id's of BBs with saves of the callee-saved reg
+  // outputs
+  MapleSet<BBId> restoreAtEntryBBs; // Id's of BBs to insert restores of the register at BB entry
+  MapleSet<BBId> restoreAtExitBBs; // Id's of BBs to insert restores of the register at BB exit
+  bool restoreAtEpilog = false;    // if true, no shrinkwrapping can be done and
+                                   // the other outputs can be ignored
+};
+
+extern void DoRestorePlacementOpt(CGFunc *f, PostDomAnalysis *pdom, SPreWorkCand *workCand);
+
+enum SOccType {
+  kSOccUndef,
+  kSOccReal,
+  kSOccLambda,
+  kSOccLambdaRes,
+  kSOccEntry,
+  kSOccKill,
+};
+
+class SOcc {
+ public:
+  SOcc(SOccType ty, BB *bb) : occTy(ty), cgbb(bb) {}
+  virtual ~SOcc() = default;
+
+  virtual void Dump() const = 0;
+  bool IsPostDominate(PostDomAnalysis *pdom, const SOcc *occ) const {
+    return pdom->PostDominate(*cgbb, *occ->cgbb);
+  }
+
+  SOccType occTy;
+  uint32 classId = 0;
+  BB *cgbb;  // the BB it occurs in
+  SOcc *use = nullptr;  // points to its single use
+};
+
+class SRealOcc : public SOcc {
+ public:
+  explicit SRealOcc(BB *bb) : SOcc(kSOccReal, bb) {}
+  virtual ~SRealOcc() = default;
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "RealOcc at bb" << cgbb->GetId();
+    LogInfo::MapleLogger() << " classId" << classId;
+  }
+
+  bool redundant = true;
+};
+
+class SLambdaOcc;
+
+class SLambdaResOcc : public SOcc {
+ public:
+  explicit SLambdaResOcc(BB *bb): SOcc(kSOccLambdaRes, bb) {}
+  virtual ~SLambdaResOcc() = default;
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "LambdaResOcc at bb" << cgbb->GetId() << " classId" << classId;
+  }
+
+
+  SLambdaOcc *useLambdaOcc = nullptr;  // its rhs use
+  bool hasRealUse = false;
+  bool insertHere = false;
+};
+
+class SLambdaOcc : public SOcc {
+ public:
+  SLambdaOcc(BB *bb, MapleAllocator &alloc)
+      : SOcc(kSOccLambda, bb), lambdaRes(alloc.Adapter()) {}
+  virtual ~SLambdaOcc() = default;
+
+  bool WillBeAnt() const {
+    return isCanBeAnt && !isEarlier;
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "LambdaOcc at bb" << cgbb->GetId() << " classId" << classId << " Lambda[";
+    for (size_t i = 0; i < lambdaRes.size(); i++) {
+      lambdaRes[i]->Dump();
+      if (i != lambdaRes.size() - 1) {
+        LogInfo::MapleLogger() << ", ";
+      }
+    }
+    LogInfo::MapleLogger() << "]";
+  }
+
+
+  bool isUpsafe = true;
+  bool isCanBeAnt = true;
+  bool isEarlier = true;
+  MapleVector<SLambdaResOcc*> lambdaRes;
+};
+
+class SEntryOcc : public SOcc {
+ public:
+  explicit SEntryOcc(BB *bb) : SOcc(kSOccEntry, bb) {}
+  virtual ~SEntryOcc() = default;
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "EntryOcc at bb" << cgbb->GetId();
+  }
+};
+
+class SKillOcc : public SOcc {
+ public:
+  explicit SKillOcc(BB *bb) : SOcc(kSOccKill, bb) {}
+  virtual ~SKillOcc() = default;
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "KillOcc at bb" << cgbb->GetId();
+  }
+};
+
+class SSUPre {
+ public:
+  SSUPre(CGFunc *cgfunc, PostDomAnalysis *pd, MemPool *memPool, SPreWorkCand *wkcand, bool alap, bool enDebug)
+      : cgFunc(cgfunc),
+        pdom(pd),
+        spreMp(memPool),
+        spreAllocator(memPool),
+        workCand(wkcand),
+        fullyAvailBBs(cgfunc->GetAllBBs().size(), true, spreAllocator.Adapter()),
+        lambdaDfns(std::less<uint32>(), spreAllocator.Adapter()),
+        classCount(0),
+        realOccs(spreAllocator.Adapter()),
+        allOccs(spreAllocator.Adapter()),
+        lambdaOccs(spreAllocator.Adapter()),
+        entryOccs(spreAllocator.Adapter()),
+        asLateAsPossible(alap),
+        enabledDebug(enDebug) {
+    CreateEntryOcc(cgfunc->GetFirstBB());
+  }
+  ~SSUPre() = default;
+
+  void ApplySSUPre();
+
+ private:
+  // step 6 methods
+  void CodeMotion();
+  // step 5 methods
+  void Finalize();
+  // step 4 methods
+  void ResetCanBeAnt(SLambdaOcc *lambda) const;
+  void ComputeCanBeAnt() const;
+  void ResetEarlier(SLambdaOcc *lambda) const;
+  void ComputeEarlier() const;
+  // step 3 methods
+  void ResetUpsafe(const SLambdaResOcc *lambdaRes) const;
+  void ComputeUpsafe() const;
+  // step 2 methods
+  void Rename();
+  // step 1 methods
+  void GetIterPdomFrontier(const BB *bb, MapleSet<uint32> *pdfset) const {
+    for (BBId bbid : pdom->GetIpdomFrontier(bb->GetId())) {
+      (void)pdfset->insert(pdom->GetPdtDfnItem(bbid));
+    }
+  }
+  void FormLambdas();
+  void CreateSortedOccs();
+  // step 0 methods
+  void CreateEntryOcc(BB *bb) {
+    SEntryOcc *entryOcc = spreMp->New<SEntryOcc>(bb);
+    entryOccs.push_back(entryOcc);
+  }
+  void PropagateNotAvail(BB *bb, std::set<BB*, BBIdCmp> *visitedBBs);
+  void FormReals();
+
+  CGFunc *cgFunc;
+  PostDomAnalysis *pdom;
+  MemPool *spreMp;
+  MapleAllocator spreAllocator;
+  SPreWorkCand *workCand;
+  // step 0
+  MapleVector<bool> fullyAvailBBs; // index is BBid; true if occ is fully available at BB exit
+  // step 1 lambda insertion data structures:
+  MapleSet<uint32> lambdaDfns;  // set by FormLambdas(); set of BBs in terms of
+                                // their dfn's; index into
+                                // dominance->pdt_preorder to get their bbid's
+  // step 2 renaming
+  uint32 classCount;  // for assigning new class id
+  // the following 4 lists are all maintained in order of pdt_preorder
+  MapleVector<SOcc*> realOccs;          // both real and kill occurrences
+  MapleVector<SOcc*> allOccs;
+  MapleVector<SLambdaOcc*> lambdaOccs;
+  MapleVector<SEntryOcc*> entryOccs;
+  bool asLateAsPossible;
+  bool enabledDebug;
+};
+
+};  // namespace maplabe
+#endif  // MAPLEBE_CG_INCLUDE_CGSSUPRE_H
diff --git a/src/mapleall/maple_be/include/cg/cg_validbit_opt.h b/src/mapleall/maple_be/include/cg/cg_validbit_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..d60abdf83300e061da7dce433c2199f436cf3bba
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_validbit_opt.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_VALIDBIT_OPT_H
+#define MAPLEBE_INCLUDE_CG_VALIDBIT_OPT_H
+
+#include "cg.h"
+#include "cgfunc.h"
+#include "bb.h"
+#include "insn.h"
+#include "cg_ssa.h"
+
+namespace maplebe {
+#define CG_VALIDBIT_OPT_DUMP CG_DEBUG_FUNC(*cgFunc)
+class ValidBitPattern {
+ public:
+  ValidBitPattern(CGFunc &f, CGSSAInfo &info) : cgFunc(&f), ssaInfo(&info) {}
+  virtual ~ValidBitPattern() {
+    cgFunc = nullptr;
+    ssaInfo = nullptr;
+  }
+  std::string PhaseName() const {
+    return "cgvalidbitopt";
+  }
+
+  virtual std::string GetPatternName() = 0;
+  virtual bool CheckCondition(Insn &insn) = 0;
+  virtual void Run(BB &bb, Insn &insn) = 0;
+  InsnSet GetAllUseInsn(const RegOperand &defReg);
+  void DumpAfterPattern(std::vector<Insn*> &prevInsns, const Insn *replacedInsn, const Insn *newInsn);
+
+ protected:
+  CGFunc *cgFunc;
+  CGSSAInfo *ssaInfo;
+};
+
+class ValidBitOpt {
+ public:
+  ValidBitOpt(CGFunc &f, CGSSAInfo &info) : cgFunc(&f), ssaInfo(&info) {}
+  virtual ~ValidBitOpt() {
+    cgFunc = nullptr;
+    ssaInfo = nullptr;
+  }
+  void Run();
+  static uint32 GetImmValidBit(int64 value, uint32 size) {
+    if (value < 0) {
+      return size;
+    } else if (value == 0) {
+      return k1BitSize;
+    }
+    uint32 pos = 0;
+    constexpr uint64 mask = 1;
+    for (uint32 i = 0; i <= k8BitSize * sizeof(int64); ++i) {
+      if ((static_cast<uint64>(value) & mask) == mask) {
+        pos = i + 1;
+      }
+      value = value / 2;
+    }
+    return pos;
+  }
+
+  static int64 GetLogValueAtBase2(int64 val) {
+    return (__builtin_popcountll(static_cast<uint64>(val)) == 1) ? (__builtin_ffsll(val) - 1) : -1;
+  }
+
+  template<typename VBOpt>
+  void Optimize(BB &bb, Insn &insn) const {
+    VBOpt opt(*cgFunc, *ssaInfo);
+    opt.Run(bb, insn);
+  }
+  virtual void DoOpt(BB &bb, Insn &insn) = 0;
+  void RectifyValidBitNum();
+  void RecoverValidBitNum();
+  virtual void SetValidBits(Insn &insn) = 0;
+  virtual bool SetPhiValidBits(Insn &insn) = 0;
+
+ protected:
+  CGFunc *cgFunc;
+  CGSSAInfo *ssaInfo;
+};
+MAPLE_FUNC_PHASE_DECLARE(CgValidBitOpt, maplebe::CGFunc)
+} /* namespace maplebe */
+#endif /* MAPLEBE_INCLUDE_CG_VALIDBIT_OPT_H */
diff --git a/src/mapleall/maple_be/include/cg/cgbb.h b/src/mapleall/maple_be/include/cg/cgbb.h
new file mode 100644
index 0000000000000000000000000000000000000000..91ac332c646d8a2c741cd536b015066135af6bf4
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cgbb.h
@@ -0,0 +1,933 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CGBB_H
+#define MAPLEBE_INCLUDE_CG_CGBB_H
+
+#if TARGAARCH64
+#include "aarch64/aarch64_isa.h"
+#elif TARGX86_64
+#include "isa.h"
+#endif
+#include "insn.h"
+#include "sparse_datainfo.h"
+
+/* Maple IR headers */
+#include "mir_nodes.h"
+#include "mir_symbol.h"
+
+/* Maple MP header */
+#include "mempool_allocator.h"
+
+namespace maplebe {
+/* For get bb */
+#define FIRST_BB_OF_FUNC(FUNC) ((FUNC)->GetFirstBB())
+#define LAST_BB_OF_FUNC(FUNC) ((FUNC)->GetLastBB())
+
+/* For iterating over basic blocks. */
+#define FOR_BB_BETWEEN(BASE, FROM, TO, DIR) for (BB * (BASE) = (FROM); (BASE) != (TO); (BASE) = (BASE)->DIR())
+#define FOR_BB_BETWEEN_CONST(BASE, FROM, TO, DIR) \
+  for (const BB * (BASE) = (FROM); (BASE) != (TO); (BASE) = (BASE)->DIR())
+
+#define FOR_ALL_BB_CONST(BASE, FUNC) FOR_BB_BETWEEN_CONST(BASE, FIRST_BB_OF_FUNC(FUNC), nullptr, GetNext)
+#define FOR_ALL_BB(BASE, FUNC) FOR_BB_BETWEEN(BASE, FIRST_BB_OF_FUNC(FUNC), nullptr, GetNext)
+#define FOR_ALL_BB_REV_CONST(BASE, FUNC) FOR_BB_BETWEEN_CONST(BASE, LAST_BB_OF_FUNC(FUNC), nullptr, GetPrev)
+#define FOR_ALL_BB_REV(BASE, FUNC) FOR_BB_BETWEEN(BASE, LAST_BB_OF_FUNC(FUNC), nullptr, GetPrev)
+
+/* For get insn */
+#define FIRST_INSN(BLOCK) (BLOCK)->GetFirstInsn()
+#define LAST_INSN(BLOCK) (BLOCK)->GetLastInsn()
+#define NEXT_INSN(INSN) (INSN)->GetNext()
+#define PREV_INSN(INSN) (INSN)->GetPrev()
+
+/* For iterating over insns in basic block. */
+#define FOR_INSN_BETWEEN(INSN, FROM, TO, DIR) \
+  for (Insn * (INSN) = (FROM); (INSN) != nullptr && (INSN) != (TO); (INSN) = (INSN)->DIR)
+
+#define FOR_BB_INSNS(INSN, BLOCK) \
+  for (Insn * (INSN) = FIRST_INSN(BLOCK); (INSN) != nullptr; (INSN) = (INSN)->GetNext())
+#define FOR_BB_INSNS_CONST(INSN, BLOCK) \
+  for (const Insn * (INSN) = FIRST_INSN(BLOCK); (INSN) != nullptr; (INSN) = (INSN)->GetNext())
+
+#define FOR_BB_INSNS_REV(INSN, BLOCK) \
+  for (Insn * (INSN) = LAST_INSN(BLOCK); (INSN) != nullptr; (INSN) = (INSN)->GetPrev())
+
+/* For iterating over insns in basic block when we might remove the current insn. */
+#define FOR_BB_INSNS_SAFE(INSN, BLOCK, NEXT)                                                               \
+  for (Insn * (INSN) = FIRST_INSN(BLOCK), *(NEXT) = (INSN) ? NEXT_INSN(INSN) : nullptr; (INSN) != nullptr; \
+       (INSN) = (NEXT), (NEXT) = (INSN) ? NEXT_INSN(INSN) : nullptr)
+
+#define FOR_BB_INSNS_REV_SAFE(INSN, BLOCK, NEXT)                                                          \
+  for (Insn * (INSN) = LAST_INSN(BLOCK), *(NEXT) = (INSN) ? PREV_INSN(INSN) : nullptr; (INSN) != nullptr; \
+       (INSN) = (NEXT), (NEXT) = (INSN) ? PREV_INSN(INSN) : nullptr)
+
+class CGFuncLoops;
+class CGFunc;
+class CDGNode;
+
+class BB {
+ public:
+  enum BBKind : uint8 {
+    kBBFallthru,  /* default */
+    kBBIf,        /* conditional branch */
+    kBBGoto,      /* unconditional branch */
+    kBBIgoto,
+    kBBReturn,
+    kBBNoReturn,
+    kBBIntrinsic,  /* BB created by inlining intrinsics; shares a lot with BB_if */
+    kBBRangeGoto,
+    kBBThrow,      /* For call __java_throw_* and call exit, which will run out of function. */
+    kBBLast
+  };
+
+  BB(uint32 bbID, MapleAllocator &mallocator)
+      : id(bbID),
+        kind(kBBFallthru), /* kBBFallthru default kind */
+        labIdx(MIRLabelTable::GetDummyLabel()),
+        preds(mallocator.Adapter()),
+        succs(mallocator.Adapter()),
+        ehPreds(mallocator.Adapter()),
+        ehSuccs(mallocator.Adapter()),
+        loopPreds(mallocator.Adapter()),
+        loopSuccs(mallocator.Adapter()),
+        succsFreq(mallocator.Adapter()),
+        liveInRegNO(mallocator.Adapter()),
+        liveOutRegNO(mallocator.Adapter()),
+        callInsns(mallocator.Adapter()),
+        rangeGotoLabelVec(mallocator.Adapter()),
+        phiInsnList(mallocator.Adapter()) {}
+
+  virtual ~BB() = default;
+
+  virtual BB *Clone(MemPool &memPool) const {
+    BB *bb = memPool.Clone<BB>(*this);
+    return bb;
+  }
+
+  void Dump() const;
+  bool IsCommentBB() const;
+  bool IsEmptyOrCommentOnly() const;
+  bool IsSoloGoto() const;
+  BB* GetValidPrev();
+
+  bool IsEmpty() const {
+    if (lastInsn == nullptr) {
+      CHECK_FATAL(firstInsn == nullptr, "firstInsn must be nullptr");
+      return true;
+    } else {
+      CHECK_FATAL(firstInsn != nullptr, "firstInsn must not be nullptr");
+      return false;
+    }
+  }
+
+  const std::string &GetKindName() const {
+    ASSERT(kind < kBBLast, "out of range in GetKindName");
+    return bbNames[kind];
+  }
+
+  void SetKind(BBKind bbKind) {
+    kind = bbKind;
+  }
+
+  BBKind GetKind() const {
+    return kind;
+  }
+
+  void AddLabel(LabelIdx idx) {
+    labIdx = idx;
+  }
+
+  void AppendBB(BB &bb) {
+    bb.prev = this;
+    bb.next = next;
+    if (next != nullptr) {
+      next->prev = &bb;
+    }
+    next = &bb;
+  }
+
+  void PrependBB(BB &bb) {
+    bb.next = this;
+    bb.prev = this->prev;
+    if (this->prev != nullptr) {
+      this->prev->next = &bb;
+    }
+    this->prev = &bb;
+  }
+
+  Insn *InsertInsnBefore(Insn &existing, Insn &newInsn);
+
+  /* returns newly inserted instruction */
+  Insn *InsertInsnAfter(Insn &existing, Insn &newInsn);
+
+  void InsertInsnBegin(Insn &insn) {
+    if (lastInsn == nullptr) {
+      firstInsn = lastInsn = &insn;
+      insn.SetNext(nullptr);
+      insn.SetPrev(nullptr);
+      insn.SetBB(this);
+    } else {
+      InsertInsnBefore(*firstInsn, insn);
+    }
+  }
+
+  void AppendInsn(Insn &insn) {
+    if (firstInsn != nullptr && lastInsn != nullptr) {
+      InsertInsnAfter(*lastInsn, insn);
+    } else {
+      firstInsn = lastInsn = &insn;
+      insn.SetNext(nullptr);
+      insn.SetPrev(nullptr);
+      insn.SetBB(this);
+    }
+    internalFlag1++;
+  }
+
+  void ReplaceInsn(Insn &insn, Insn &newInsn);
+
+  void RemoveInsn(Insn &insn);
+
+  void RemoveInsnPair(Insn &insn, const Insn &nextInsn);
+
+  void RemoveInsnSequence(Insn &insn, const Insn &nextInsn);
+
+  /* append all insns from bb into this bb */
+  void AppendBBInsns(BB &bb);
+
+  /* append all insns from bb into this bb */
+  void InsertAtBeginning(BB &bb);
+  void InsertAtEnd(BB &bb);
+  void InsertAtEndMinus1(BB &bb);
+
+  /* clear BB but don't remove insns of this */
+  void ClearInsns() {
+    firstInsn = lastInsn = nullptr;
+  }
+
+  uint32 NumPreds() const {
+    return static_cast<uint32>(preds.size());
+  }
+
+  bool IsPredecessor(const BB &predBB) {
+    for (const BB *bb : std::as_const(preds)) {
+      if (bb == &predBB) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool IsBackEdgeDest() const {
+    return !loopPreds.empty();
+  }
+
+  void RemoveFromPredecessorList(const BB &bb) {
+    for (auto i = preds.begin(); i != preds.end(); ++i) {
+      if (*i == &bb) {
+        preds.erase(i);
+        return;
+      }
+    }
+    CHECK_FATAL(false, "request to remove a non-existent element?");
+  }
+
+  void RemoveFromSuccessorList(const BB &bb) {
+    for (auto i = succs.begin(); i != succs.end(); ++i) {
+      if (*i == &bb) {
+        succs.erase(i);
+        return;
+      }
+    }
+    CHECK_FATAL(false, "request to remove a non-existent element?");
+  }
+
+  uint32 NumSuccs() const {
+    return static_cast<uint32>(succs.size());
+  }
+
+  bool HasCall() const {
+    return hasCall;
+  }
+
+  void SetHasCall() {
+    hasCall = true;
+  }
+
+  /* Number of instructions excluding DbgInsn and comments */
+  int32 NumInsn() const;
+  uint32 GetId() const {
+    return id;
+  }
+  uint32 GetLevel() const {
+    return level;
+  }
+  void SetLevel(uint32 arg) {
+    level = arg;
+  }
+  uint32 GetFrequency() const {
+    return frequency;
+  }
+  void SetFrequency(uint32 arg) {
+    frequency = arg;
+  }
+  BB *GetNext() {
+    return next;
+  }
+  const BB *GetNext() const {
+    return next;
+  }
+  BB *GetPrev() {
+    return prev;
+  }
+  const BB *GetPrev() const {
+    return prev;
+  }
+  void SetNext(BB *arg) {
+    next = arg;
+  }
+  void SetPrev(BB *arg) {
+    prev = arg;
+  }
+  LabelIdx GetLabIdx() const {
+    return labIdx;
+  }
+  void SetLabIdx(LabelIdx arg) {
+    labIdx = arg;
+  }
+  StmtNode *GetFirstStmt() {
+    return firstStmt;
+  }
+  const StmtNode *GetFirstStmt() const {
+    return firstStmt;
+  }
+  void SetFirstStmt(StmtNode &arg) {
+    firstStmt = &arg;
+  }
+  StmtNode *GetLastStmt() {
+    return lastStmt;
+  }
+  const StmtNode *GetLastStmt() const {
+    return lastStmt;
+  }
+  void SetLastStmt(StmtNode &arg) {
+    lastStmt = &arg;
+  }
+  Insn *GetFirstInsn() {
+    return firstInsn;
+  }
+  const Insn *GetFirstInsn() const {
+    return firstInsn;
+  }
+
+  void SetFirstInsn(Insn *arg) {
+    firstInsn = arg;
+  }
+  Insn *GetFirstMachineInsn() {
+    FOR_BB_INSNS(insn, this) {
+      if (insn->IsMachineInstruction()) {
+        return insn;
+      }
+    }
+    return nullptr;
+  }
+  Insn *GetLastMachineInsn() {
+    FOR_BB_INSNS_REV(insn, this) {
+#if TARGAARCH64
+      if (insn->IsMachineInstruction() && !AArch64isa::IsPseudoInstruction(insn->GetMachineOpcode())) {
+#elif TARGX86_64
+      if (insn->IsMachineInstruction()) {
+#endif
+        return insn;
+      }
+    }
+    return nullptr;
+  }
+  Insn *GetLastInsn() {
+    return lastInsn;
+  }
+  const Insn *GetLastInsn() const {
+    return lastInsn;
+  }
+  void SetLastInsn(Insn *arg) {
+    lastInsn = arg;
+  }
+  bool IsLastInsn(const Insn *insn) const{
+    return (lastInsn == insn);
+  }
+  void InsertPred(const MapleList<BB*>::iterator &it, BB &bb) {
+    preds.insert(it, &bb);
+  }
+  void InsertSucc(const MapleList<BB*>::iterator &it, BB &bb) {
+    succs.insert(it, &bb);
+  }
+  const MapleList<BB*> &GetPreds() const {
+    return preds;
+  }
+  const MapleList<BB*> &GetSuccs() const {
+    return succs;
+  }
+  const std::size_t GetSuccsSize() const {
+    return succs.size();
+  }
+  const MapleList<BB*> &GetEhPreds() const {
+    return ehPreds;
+  }
+  const MapleList<BB*> &GetEhSuccs() const {
+    return ehSuccs;
+  }
+  const MapleList<BB*> &GetLoopPreds() const {
+    return loopPreds;
+  }
+  MapleList<BB*> &GetLoopSuccs() {
+    return loopSuccs;
+  }
+  const MapleList<BB*> &GetLoopSuccs() const {
+    return loopSuccs;
+  }
+  MapleList<BB*>::iterator GetPredsBegin() {
+    return preds.begin();
+  }
+  MapleList<BB*>::iterator GetSuccsBegin() {
+    return succs.begin();
+  }
+  MapleList<BB*>::iterator GetEhPredsBegin() {
+    return ehPreds.begin();
+  }
+  MapleList<BB*>::iterator GetLoopSuccsBegin() {
+    return loopSuccs.begin();
+  }
+  MapleList<BB*>::iterator GetPredsEnd() {
+    return preds.end();
+  }
+  MapleList<BB*>::iterator GetSuccsEnd() {
+    return succs.end();
+  }
+  MapleList<BB*>::iterator GetEhPredsEnd() {
+    return ehPreds.end();
+  }
+  MapleList<BB*>::iterator GetLoopSuccsEnd() {
+    return loopSuccs.end();
+  }
+  void PushBackPreds(BB &bb) {
+    preds.push_back(&bb);
+  }
+  void PushBackSuccs(BB &bb) {
+    succs.push_back(&bb);
+  }
+  void PushBackEhPreds(BB &bb) {
+    ehPreds.push_back(&bb);
+  }
+  void PushBackEhSuccs(BB &bb) {
+    ehSuccs.push_back(&bb);
+  }
+  void PushBackLoopPreds(BB &bb) {
+    loopPreds.push_back(&bb);
+  }
+  void PushBackLoopSuccs(BB &bb) {
+    loopSuccs.push_back(&bb);
+  }
+  void PushFrontPreds(BB &bb) {
+    preds.push_front(&bb);
+  }
+  void PushFrontSuccs(BB &bb) {
+    succs.push_front(&bb);
+  }
+  void ErasePreds(MapleList<BB*>::const_iterator it) {
+    preds.erase(it);
+  }
+  void EraseSuccs(MapleList<BB*>::const_iterator it) {
+    succs.erase(it);
+  }
+  void RemovePreds(BB &bb) {
+    preds.remove(&bb);
+  }
+  void RemoveSuccs(BB &bb) {
+    succs.remove(&bb);
+  }
+  void RemoveEhPreds(BB &bb) {
+    ehPreds.remove(&bb);
+  }
+  void RemoveEhSuccs(BB &bb) {
+    ehSuccs.remove(&bb);
+  }
+  void ClearPreds() {
+    preds.clear();
+  }
+  void ClearSuccs() {
+    succs.clear();
+  }
+  void ClearEhPreds() {
+    ehPreds.clear();
+  }
+  void ClearEhSuccs() {
+    ehSuccs.clear();
+  }
+  void ClearLoopPreds() {
+    loopPreds.clear();
+  }
+  void ClearLoopSuccs() {
+    loopSuccs.clear();
+  }
+  const MapleSet<regno_t> &GetLiveInRegNO() const {
+    return liveInRegNO;
+  }
+  MapleSet<regno_t> &GetLiveInRegNO() {
+    return liveInRegNO;
+  }
+  void InsertLiveInRegNO(regno_t arg) {
+    (void)liveInRegNO.insert(arg);
+  }
+  void EraseLiveInRegNO(MapleSet<regno_t>::iterator it) {
+    liveInRegNO.erase(it);
+  }
+  void EraseLiveInRegNO(regno_t arg) {
+    liveInRegNO.erase(arg);
+  }
+  void ClearLiveInRegNO() {
+    liveInRegNO.clear();
+  }
+  const MapleSet<regno_t> &GetLiveOutRegNO() const {
+    return liveOutRegNO;
+  }
+  MapleSet<regno_t> &GetLiveOutRegNO() {
+    return liveOutRegNO;
+  }
+  void InsertLiveOutRegNO(regno_t arg) {
+    (void)liveOutRegNO.insert(arg);
+  }
+  void EraseLiveOutRegNO(MapleSet<regno_t>::iterator it) {
+    liveOutRegNO.erase(it);
+  }
+  void ClearLiveOutRegNO() {
+    liveOutRegNO.clear();
+  }
+  CGFuncLoops *GetLoop() const {
+    return loop;
+  }
+  void SetLoop(CGFuncLoops &arg) {
+    loop = &arg;
+  }
+  bool GetLiveInChange() const {
+    return liveInChange;
+  }
+  void SetLiveInChange(bool arg) {
+    liveInChange = arg;
+  }
+  bool GetCritical() const {
+    return isCritical;
+  }
+  void SetCritical(bool arg) {
+    isCritical = arg;
+  }
+  bool HasCriticalEdge();
+  bool GetInsertUse() const {
+    return insertUse;
+  }
+  void SetInsertUse(bool arg) {
+    insertUse = arg;
+  }
+  bool IsUnreachable() const {
+    return unreachable;
+  }
+  void SetUnreachable(bool arg) {
+    unreachable = arg;
+  }
+  bool IsWontExit() const {
+    return wontExit;
+  }
+  void SetWontExit(bool arg) {
+    wontExit = arg;
+  }
+  void SetFastPathReturn(bool arg) {
+    fastPathReturn = arg;
+  }
+  bool IsFastPathReturn() const {
+    return fastPathReturn;
+  }
+  bool IsCatch() const {
+    return isCatch;
+  }
+  void SetIsCatch(bool arg) {
+    isCatch = arg;
+  }
+  bool IsCleanup() const {
+    return isCleanup;
+  }
+  void SetIsCleanup(bool arg) {
+    isCleanup = arg;
+  }
+  bool IsProEpilog() const {
+    return isProEpilog;
+  }
+  void SetIsProEpilog(bool arg) {
+    isProEpilog = arg;
+  }
+  bool IsLabelTaken() const {
+    return labelTaken;
+  }
+  void SetLabelTaken() {
+    labelTaken = true;
+  }
+  bool GetHasCfi() const {
+    return hasCfi;
+  }
+  void SetHasCfi() {
+    hasCfi = true;
+  }
+  bool IsNeedRestoreCfi() const {
+    return needRestoreCfi;
+  }
+  void SetNeedRestoreCfi(bool flag) {
+    needRestoreCfi = flag;
+  }
+  long GetInternalFlag1() const {
+    return internalFlag1;
+  }
+  void SetInternalFlag1(long arg) {
+    internalFlag1 = arg;
+  }
+  long GetInternalFlag2() const {
+    return internalFlag2;
+  }
+  void SetInternalFlag2(long arg) {
+    internalFlag2 = arg;
+  }
+  long GetInternalFlag3() const {
+    return internalFlag3;
+  }
+  void SetInternalFlag3(long arg) {
+    internalFlag3 = arg;
+  }
+  bool IsAtomicBuiltInBB() const {
+    return isAtomicBuiltIn;
+  }
+  void SetAtomicBuiltIn() {
+    isAtomicBuiltIn = true;
+  }
+  const MapleList<Insn*> &GetCallInsns() const {
+    return callInsns;
+  }
+  void PushBackCallInsns(Insn &insn) {
+    callInsns.push_back(&insn);
+  }
+  void ClearCallInsns() {
+    callInsns.clear();
+  }
+  const MapleVector<LabelIdx> &GetRangeGotoLabelVec() const {
+    return rangeGotoLabelVec;
+  }
+  void SetRangeGotoLabel(uint32 index, LabelIdx labelIdx) {
+    rangeGotoLabelVec[index] = labelIdx;
+  }
+  void PushBackRangeGotoLabel(LabelIdx labelIdx) {
+    rangeGotoLabelVec.emplace_back(labelIdx);
+  }
+  void AddPhiInsn(regno_t regNO, Insn &insn) {
+    ASSERT(!phiInsnList.count(regNO), "repeat phiInsn");
+    phiInsnList.emplace(std::pair<regno_t, Insn*>(regNO, &insn));
+  }
+  void RemovePhiInsn(regno_t regNO) {
+    ASSERT(phiInsnList.count(regNO), "no such insn");
+    phiInsnList.erase(regNO);
+  }
+  bool HasPhiInsn(regno_t regNO) {
+    return phiInsnList.find(regNO) != phiInsnList.end();
+  }
+  MapleMap<regno_t, Insn*> &GetPhiInsns() {
+    return phiInsnList;
+  }
+  bool IsInPhiList(regno_t regNO);
+  bool IsInPhiDef(regno_t regNO);
+  const Insn *GetFirstLoc() const {
+    return firstLoc;
+  }
+  void SetFirstLoc(const Insn &arg) {
+    firstLoc = &arg;
+  }
+  const Insn *GetLastLoc() const {
+    return lastLoc;
+  }
+  void SetLastLoc(const Insn *arg) {
+    lastLoc = arg;
+  }
+  SparseDataInfo *GetLiveIn() {
+    return liveIn;
+  }
+  const SparseDataInfo *GetLiveIn() const {
+    return liveIn;
+  }
+  void SetLiveIn(SparseDataInfo &arg) {
+    liveIn = &arg;
+  }
+  void SetLiveInBit(uint32 arg) const {
+    liveIn->SetBit(arg);
+  }
+  void SetLiveInInfo(const SparseDataInfo &arg) const {
+    *liveIn = arg;
+  }
+  void LiveInOrBits(const SparseDataInfo &arg) const {
+    liveIn->OrBits(arg);
+  }
+  void LiveInEnlargeCapacity(uint32 arg) const {
+    liveIn->EnlargeCapacityToAdaptSize(arg);
+  }
+  void LiveInClearDataInfo() {
+    liveIn->ClearDataInfo();
+    liveIn = nullptr;
+  }
+  SparseDataInfo *GetLiveOut() {
+    return liveOut;
+  }
+  const SparseDataInfo *GetLiveOut() const {
+    return liveOut;
+  }
+  void SetLiveOut(SparseDataInfo &arg) {
+    liveOut = &arg;
+  }
+  void SetLiveOutBit(uint32 arg) const {
+    liveOut->SetBit(arg);
+  }
+  void LiveOutOrBits(const SparseDataInfo &arg) const {
+    liveOut->OrBits(arg);
+  }
+  void LiveOutEnlargeCapacity(uint32 arg) const {
+    liveOut->EnlargeCapacityToAdaptSize(arg);
+  }
+  void LiveOutClearDataInfo() {
+    liveOut->ClearDataInfo();
+    liveOut = nullptr;
+  }
+  const SparseDataInfo *GetDef() const {
+    return def;
+  }
+  void SetDef(SparseDataInfo &arg) {
+    def = &arg;
+  }
+  void SetDefBit(uint32 arg) const {
+    def->SetBit(arg);
+  }
+  void DefResetAllBit() const {
+    def->ResetAllBit();
+  }
+  void DefResetBit(uint32 arg) const {
+    def->ResetBit(arg);
+  }
+  void DefClearDataInfo() {
+    def->ClearDataInfo();
+    def = nullptr;
+  }
+  const SparseDataInfo *GetUse() const {
+    return use;
+  }
+  void SetUse(SparseDataInfo &arg) {
+    use = &arg;
+  }
+  void SetUseBit(uint32 arg) const {
+    use->SetBit(arg);
+  }
+  void UseResetAllBit() const {
+    use->ResetAllBit();
+  }
+  void UseResetBit(uint32 arg) const {
+    use->ResetBit(arg);
+  }
+  void UseClearDataInfo() {
+    use->ClearDataInfo();
+    use = nullptr;
+  }
+  void SetNeedAlign(bool flag) {
+    needAlign = flag;
+  }
+  bool IsBBNeedAlign() const {
+    return needAlign;
+  }
+  void SetAlignPower(uint32 power) {
+    alignPower = power;
+  }
+  uint32 GetAlignPower() const {
+    return alignPower;
+  }
+  void SetAlignNopNum(uint32 num) {
+    alignNopNum = num;
+  }
+  uint32 GetAlignNopNum() const {
+    return alignNopNum;
+  }
+  CDGNode *GetCDGNode() {
+    return cdgNode;
+  }
+  void SetCDGNode(CDGNode *node) {
+    cdgNode = node;
+  }
+
+  void InitEdgeFreq() {
+    succsFreq.resize(succs.size());
+  }
+
+  uint64 GetEdgeFreq(const BB &bb) const {
+    auto iter = std::find(succs.begin(), succs.end(), &bb);
+    if (iter == std::end(succs) || succs.size() > succsFreq.size()) {
+      return 0;
+    }
+    CHECK_FATAL(iter != std::end(succs), "%d is not the successor of %d", bb.GetId(), this->GetId());
+    CHECK_FATAL(succs.size() == succsFreq.size(), "succfreq size doesn't match succ size");
+    const size_t idx = static_cast<size_t>(std::distance(succs.begin(), iter));
+    return succsFreq[idx];
+  }
+
+  uint64 GetEdgeFreq(size_t idx) const {
+    if (idx >= succsFreq.size()) {
+      return 0;
+    }
+    CHECK_FATAL(idx < succsFreq.size(), "out of range in BB::GetEdgeFreq");
+    CHECK_FATAL(succs.size() == succsFreq.size(), "succfreq size doesn't match succ size");
+    return succsFreq[idx];
+  }
+
+  void SetEdgeFreq(const BB &bb, uint64 freq) {
+    auto iter = std::find(succs.begin(), succs.end(), &bb);
+    CHECK_FATAL(iter != std::end(succs), "%d is not the successor of %d", bb.GetId(), this->GetId());
+    CHECK_FATAL(succs.size() == succsFreq.size(), "succfreq size %d doesn't match succ size %d", succsFreq.size(),
+                succs.size());
+    const size_t idx = static_cast<size_t>(std::distance(succs.begin(), iter));
+    succsFreq[idx] = freq;
+  }
+
+ private:
+  static const std::string bbNames[kBBLast];
+  uint32 id;
+  uint32 level = 0;
+  uint32 frequency = 0;
+  BB *prev = nullptr;  /* Doubly linked list of BBs; */
+  BB *next = nullptr;
+  /* They represent the order in which blocks are to be emitted. */
+  BBKind kind = kBBFallthru;  /* The BB's last statement (i.e. lastStmt) determines */
+  /* what type this BB has. By default, kBbFallthru */
+  LabelIdx labIdx;
+  StmtNode *firstStmt = nullptr;
+  StmtNode *lastStmt = nullptr;
+  Insn *firstInsn = nullptr;        /* the first instruction */
+  Insn *lastInsn = nullptr;         /* the last instruction */
+  MapleList<BB*> preds;  /* preds, succs represent CFG */
+  MapleList<BB*> succs;
+  MapleList<BB*> ehPreds;
+  MapleList<BB*> ehSuccs;
+  MapleList<BB*> loopPreds;
+  MapleList<BB*> loopSuccs;
+
+  MapleVector<uint64> succsFreq;
+
+  /* this is for live in out analysis */
+  MapleSet<regno_t> liveInRegNO;
+  MapleSet<regno_t> liveOutRegNO;
+  CGFuncLoops *loop = nullptr;
+  bool liveInChange = false;
+  bool isCritical = false;
+  bool insertUse = false;
+  bool hasCall = false;
+  bool unreachable = false;
+  bool wontExit = false;
+  bool fastPathReturn = false;
+  bool isCatch = false;  /* part of the catch bb, true does might also mean it is unreachable */
+  /*
+   * Since isCatch is set early and unreachable detected later, there
+   * are some overlap here.
+   */
+  bool isCleanup = false;  /* true if the bb is cleanup bb. otherwise, false. */
+  bool isProEpilog = false;  /* Temporary tag for modifying prolog/epilog bb. */
+  bool labelTaken = false;  /* Block label is taken indirectly and can be used to jump to it. */
+  bool hasCfi = false;  /* bb contain cfi directive. */
+  bool needRestoreCfi = false;  /* add cfi insn to current bb if true */
+  /*
+   * Different meaning for each data flow analysis.
+   * For HandleFunction(), rough estimate of num of insn created.
+   * For cgbb.cpp, track insn count during code selection.
+   * For cgbb.cpp, bb is traversed during BFS ordering.
+   * For aarchregalloc.cpp, the bb is part of cleanup at end of function.
+   * For aarchcolorra.cpp, the bb is part of cleanup at end of function.
+   *                       also used for live range splitting.
+   * For live analysis, it indicates if bb is cleanupbb.
+   */
+  long internalFlag1 = 0;
+
+  /*
+   * Different meaning for each data flow analysis.
+   * For cgbb.cpp, bb is levelized to be 1 more than largest predecessor.
+   * For aarchcolorra.cpp, used for live range splitting pruning of bb.
+   */
+  long internalFlag2 = 0;
+
+  /*
+   * Different meaning for each data flow analysis.
+   * For cgfunc.cpp, it temporarily marks for catch bb discovery.
+   * For live analysis, it indicates if bb is visited.
+   * For peephole, used for live-out checking of bb.
+   */
+  long internalFlag3 = 0;
+  MapleList<Insn*> callInsns;
+  MapleVector<LabelIdx> rangeGotoLabelVec;
+
+  /* bb support for SSA analysis */
+  MapleMap<regno_t, Insn*> phiInsnList;
+
+  /* includes Built-in functions for atomic memory access */
+  bool isAtomicBuiltIn = false;
+
+  const Insn *firstLoc = nullptr;
+  const Insn *lastLoc = nullptr;
+  SparseDataInfo *liveIn = nullptr;
+  SparseDataInfo *liveOut = nullptr;
+  SparseDataInfo *def = nullptr;
+  SparseDataInfo *use = nullptr;
+
+  bool needAlign = false;
+  uint32 alignPower = 0;
+  uint32 alignNopNum = 0;
+
+  CDGNode *cdgNode = nullptr;
+};  /* class BB */
+
+struct BBIdCmp {
+  bool operator()(const BB *lhs, const BB *rhs) const {
+    CHECK_FATAL(lhs != nullptr, "null ptr check");
+    CHECK_FATAL(rhs != nullptr, "null ptr check");
+    return (lhs->GetId() < rhs->GetId());
+  }
+};
+
+class Bfs {
+ public:
+  Bfs(CGFunc &cgFunc, MemPool &memPool)
+      : cgfunc(&cgFunc),
+        memPool(&memPool),
+        alloc(&memPool),
+        visitedBBs(alloc.Adapter()),
+        sortedBBs(alloc.Adapter()) {}
+  ~Bfs() = default;
+
+  bool AllPredBBVisited(const BB &bb, long &level) const;
+  BB *MarkStraightLineBBInBFS(BB *bb);
+  BB *SearchForStraightLineBBs(BB &bb);
+  void BFS(BB &curBB);
+  void ComputeBlockOrder();
+
+  CGFunc *cgfunc;
+  MemPool *memPool;
+  MapleAllocator alloc;
+  MapleVector<bool> visitedBBs;
+  MapleVector<BB*> sortedBBs;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_CGBB_H */
diff --git a/src/mapleall/maple_be/include/cg/cgfunc.h b/src/mapleall/maple_be/include/cg/cgfunc.h
new file mode 100644
index 0000000000000000000000000000000000000000..3702303fa9408f3d56fd6ecccb60ecebd766a8e2
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cgfunc.h
@@ -0,0 +1,1461 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_CGFUNC_H
+#define MAPLEBE_INCLUDE_CG_CGFUNC_H
+
+#include "becommon.h"
+#include "operand.h"
+#include "eh_func.h"
+#include "memlayout.h"
+#include "reg_info.h"
+#include "cgbb.h"
+#include "cfi.h"
+#include "dbg.h"
+#include "reaching.h"
+#include "cg_cfg.h"
+#include "cg_irbuilder.h"
+#include "call_conv.h"
+/* MapleIR headers. */
+#include "mir_parser.h"
+#include "mir_function.h"
+#include "debug_info.h"
+#include "maple_phase_manager.h"
+
+/* Maple MP header */
+#include "mempool_allocator.h"
+
+namespace maplebe {
+constexpr int32 kBBLimit = 100000;
+constexpr int32 kFreqBase = 100000;
+struct MemOpndCmp {
+  bool operator()(const MemOperand *lhs, const MemOperand *rhs) const {
+    CHECK_FATAL(lhs != nullptr, "null ptr check");
+    CHECK_FATAL(rhs != nullptr, "null ptr check");
+    if (lhs == rhs) {
+      return false;
+    }
+    return (lhs->Less(*rhs));
+  }
+};
+
+class VirtualRegNode {
+ public:
+  VirtualRegNode() = default;
+
+  VirtualRegNode(RegType type, uint32 size)
+      : regType(type), size(size), regNO(kInvalidRegNO) {}
+
+  virtual ~VirtualRegNode() = default;
+
+  void AssignPhysicalRegister(regno_t phyRegNO) {
+    regNO = phyRegNO;
+  }
+
+  RegType GetType() const {
+    return regType;
+  }
+
+  uint32 GetSize() const {
+    return size;
+  }
+
+ private:
+  RegType regType = kRegTyUndef;
+  uint32 size     = 0;              /* size in bytes */
+  regno_t regNO   = kInvalidRegNO;  /* physical register assigned by register allocation */
+};
+
+class SpillMemOperandSet {
+ public:
+  explicit SpillMemOperandSet(MapleAllocator &mallocator) : reuseSpillLocMem(mallocator.Adapter()) {}
+
+  virtual ~SpillMemOperandSet() = default;
+
+  void Add(MemOperand &op) {
+    (void)reuseSpillLocMem.insert(&op);
+  }
+
+  void Remove(MemOperand &op) {
+    reuseSpillLocMem.erase(&op);
+  }
+
+  MemOperand *GetOne() {
+    if (!reuseSpillLocMem.empty()) {
+      MemOperand *res = *reuseSpillLocMem.begin();
+      reuseSpillLocMem.erase(res);
+      return res;
+    }
+    return nullptr;
+  }
+
+ private:
+  MapleSet<MemOperand*, MemOpndCmp> reuseSpillLocMem;
+};
+
+#if TARGARM32
+class LiveRange;
+#endif  /* TARGARM32 */
+constexpr uint32 kVRegisterNumber = 80;
+constexpr uint32 kNumBBOptReturn = 30;
+class CGFunc {
+ public:
+  enum ShiftDirection : uint8 {
+    kShiftLeft,
+    kShiftAright,
+    kShiftLright
+  };
+
+  CGFunc(MIRModule &mod, CG &cg, MIRFunction &mirFunc, BECommon &beCommon, MemPool &memPool,
+         StackMemPool &stackMp, MapleAllocator &allocator, uint32 funcId);
+  virtual ~CGFunc();
+
+  const std::string &GetName() const {
+    return func.GetName();
+  }
+
+  const MapleMap<LabelIdx, uint64> &GetLabelAndValueMap() const {
+    return labelMap;
+  }
+
+  void InsertLabelMap(LabelIdx idx, uint64 value) {
+    ASSERT(labelMap.find(idx) == labelMap.end(), "idx already exist");
+    labelMap[idx] = value;
+  }
+
+  void LayoutStackFrame() {
+    CHECK_FATAL(memLayout != nullptr, "memLayout should has been initialized in constructor");
+    memLayout->LayoutStackFrame(structCopySize, maxParamStackSize);
+  }
+
+  bool HasCall() const {
+    return func.HasCall();
+  }
+
+  bool HasVLAOrAlloca() const {
+    return hasVLAOrAlloca;
+  }
+
+  void SetHasVLAOrAlloca(bool val) {
+    hasVLAOrAlloca = val;
+  }
+
+  bool HasAlloca() const {
+    return hasAlloca;
+  }
+
+  void SetHasAlloca(bool val) {
+    hasAlloca = val;
+  }
+
+  void SetRD(ReachingDefinition *paramRd) {
+    reachingDef = paramRd;
+  }
+
+  InsnBuilder *GetInsnBuilder() {
+    return insnBuilder;
+  }
+  OperandBuilder *GetOpndBuilder() {
+    return opndBuilder;
+  }
+
+  bool GetRDStatus() const {
+    return (reachingDef != nullptr);
+  }
+
+  ReachingDefinition *GetRD() {
+    return reachingDef;
+  }
+
+  EHFunc *BuildEHFunc();
+  void NeedStackProtect();
+  virtual void GenSaveMethodInfoCode(BB &bb) = 0;
+  virtual void GenerateCleanupCode(BB &bb) = 0;
+  virtual bool NeedCleanup() = 0;
+  virtual void GenerateCleanupCodeForExtEpilog(BB &bb) = 0;
+  virtual MemOperand *GetOrCreatSpillMem(regno_t vrNum) = 0;
+  virtual void FreeSpillRegMem(regno_t vrNum) = 0;
+  void CreateLmbcFormalParamInfo();
+  virtual uint32 FloatParamRegRequired(MIRStructType *structType, uint32 &fpSize) = 0;
+  virtual void AssignLmbcFormalParams() = 0;
+  LmbcFormalParamInfo *GetLmbcFormalParamInfo(uint32 offset);
+  virtual void LmbcGenSaveSpForAlloca() = 0;
+  void RemoveUnreachableBB();
+  void GenerateLoc(StmtNode *stmt, SrcPosition &lastSrcPos, SrcPosition &lastMplPos);
+  void GenerateScopeLabel(StmtNode *stmt, SrcPosition &lastSrcPos, bool &posDone);
+  int32 GetFreqFromStmt(uint32 stmtId);
+  void GenerateInstruction();
+  bool MemBarOpt(const StmtNode &membar);
+  void UpdateCallBBFrequency();
+  void HandleFunction();
+  void MakeupScopeLabels(BB &bb);
+  void ProcessExitBBVec();
+  void AddCommonExitBB();
+  virtual void MergeReturn() = 0;
+  void TraverseAndClearCatchMark(BB &bb);
+  void MarkCatchBBs();
+  void MarkCleanupBB() const;
+  void SetCleanupLabel(BB &cleanupEntry);
+  bool ExitbbNotInCleanupArea(const BB &bb) const;
+  uint32 GetMaxRegNum() const {
+    return maxRegCount;
+  };
+  void DumpCFG() const;
+  void DumpBBInfo(const BB *bb) const;
+  void DumpCGIR() const;
+  void DumpLoop() const;
+  void ClearLoopInfo();
+  Operand *HandleExpr(const BaseNode &parent, BaseNode &expr);
+  virtual void DetermineReturnTypeofCall() = 0;
+  /* handle rc reset */
+  virtual void HandleRCCall(bool begin, const MIRSymbol *retRef = nullptr) = 0;
+  virtual void HandleRetCleanup(NaryStmtNode &retNode) = 0;
+  /* select stmt */
+  virtual void SelectDassign(DassignNode &stmt, Operand &opnd0) = 0;
+  virtual void SelectDassignoff(DassignoffNode &stmt, Operand &opnd0) = 0;
+  virtual void SelectRegassign(RegassignNode &stmt, Operand &opnd0) = 0;
+  virtual void SelectAbort() = 0;
+  virtual void SelectAssertNull(UnaryStmtNode &stmt) = 0;
+  virtual void SelectAsm(AsmNode &node) = 0;
+  virtual void SelectAggDassign(DassignNode &stmt) = 0;
+  virtual void SelectIassign(IassignNode &stmt) = 0;
+  virtual void SelectIassignoff(IassignoffNode &stmt) = 0;
+  virtual void SelectIassignfpoff(IassignFPoffNode &stmt, Operand &opnd) = 0;
+  virtual void SelectIassignspoff(PrimType pTy, int32 offset, Operand &opnd) = 0;
+  virtual void SelectBlkassignoff(BlkassignoffNode &bNode, Operand *src) = 0;
+  virtual void SelectAggIassign(IassignNode &stmt, Operand &lhsAddrOpnd) = 0;
+  virtual void SelectReturnSendOfStructInRegs(BaseNode *x) = 0;
+  virtual void SelectReturn(Operand *opnd) = 0;
+  virtual void SelectIgoto(Operand *opnd0) = 0;
+  virtual void SelectCondGoto(CondGotoNode &stmt, Operand &opnd0, Operand &opnd1) = 0;
+  virtual void SelectCondSpecialCase1(CondGotoNode &stmt, BaseNode &opnd0) = 0;
+  virtual void SelectCondSpecialCase2(const CondGotoNode &stmt, BaseNode &opnd0) = 0;
+  virtual void SelectGoto(GotoNode &stmt) = 0;
+  virtual void SelectCall(CallNode &callNode) = 0;
+  virtual void SelectIcall(IcallNode &icallNode, Operand &fptrOpnd) = 0;
+  virtual void SelectIntrinCall(IntrinsiccallNode &intrinsiccallNode) = 0;
+  virtual Operand *SelectIntrinsicOpWithOneParam(IntrinsicopNode &intrinsicopNode, std::string name) = 0;
+  virtual Operand *SelectIntrinsicOpWithNParams(IntrinsicopNode &intrinsicopNode, PrimType retType,
+                                                const std::string &name) = 0;
+  virtual Operand *SelectCclz(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCctz(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCpopcount(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCparity(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCclrsb(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCisaligned(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCalignup(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCaligndown(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCSyncFetch(IntrinsicopNode &intrinsicopNode, Opcode op, bool fetchBefore) = 0;
+  virtual Operand *SelectCSyncBoolCmpSwap(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCSyncValCmpSwap(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCSyncLockTestSet(IntrinsicopNode &intrinsicopNode, PrimType pty) = 0;
+  virtual Operand *SelectCSyncSynchronize(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCAtomicLoadN(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual Operand *SelectCAtomicExchangeN(const IntrinsiccallNode &intrinsiccallNode) = 0;
+  virtual Operand *SelectCAtomicFetch(IntrinsicopNode &intrinsicopNode, Opcode op, bool fetchBefore) = 0;
+  virtual Operand *SelectCReturnAddress(IntrinsicopNode &intrinsicopNode) = 0;
+  virtual void SelectCAtomicExchange(const IntrinsiccallNode &intrinsiccallNode) = 0;
+  virtual void SelectMembar(StmtNode &membar) = 0;
+  virtual void SelectComment(CommentNode &comment) = 0;
+  virtual void HandleCatch() = 0;
+
+  /* select expr */
+  virtual Operand *SelectDread(const BaseNode &parent, AddrofNode &expr) = 0;
+  virtual RegOperand *SelectRegread(RegreadNode &expr) = 0;
+  virtual Operand *SelectAddrof(AddrofNode &expr, const BaseNode &parent, bool isAddrofoff) = 0;
+  virtual Operand *SelectAddrofoff(AddrofoffNode &expr, const BaseNode &parent) = 0;
+  virtual Operand &SelectAddrofFunc(AddroffuncNode &expr, const BaseNode &parent) = 0;
+  virtual Operand &SelectAddrofLabel(AddroflabelNode &expr, const BaseNode &parent) = 0;
+  virtual Operand *SelectIread(const BaseNode &parent, IreadNode &expr,
+                               int extraOffset = 0, PrimType finalBitFieldDestType = kPtyInvalid) = 0;
+  virtual Operand *SelectIreadoff(const BaseNode &parent, IreadoffNode &ireadoff) = 0;
+  virtual Operand *SelectIreadfpoff(const BaseNode &parent, IreadFPoffNode &ireadoff) = 0;
+  virtual Operand *SelectIntConst(MIRIntConst &intConst) = 0;
+  virtual Operand *SelectFloatConst(MIRFloatConst &floatConst, const BaseNode &parent) = 0;
+  virtual Operand *SelectDoubleConst(MIRDoubleConst &doubleConst, const BaseNode &parent) = 0;
+  virtual Operand *SelectStrConst(MIRStrConst &strConst) = 0;
+  virtual Operand *SelectStr16Const(MIRStr16Const &strConst) = 0;
+  virtual void SelectAdd(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectAdd(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual void SelectMadd(Operand &resOpnd, Operand &opndM0, Operand &opndM1, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectMadd(BinaryNode &node, Operand &opndM0, Operand &opndM1, Operand &opnd1,
+                              const BaseNode &parent) = 0;
+  virtual Operand *SelectRor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand &SelectCGArrayElemAdd(BinaryNode &node, const BaseNode &parent) = 0;
+  virtual Operand *SelectShift(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual void SelectMpy(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectMpy(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual void SelectDiv(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectDiv(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectSub(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual void SelectSub(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectBand(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual void SelectBand(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectLand(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectLor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent,
+                             bool parentIsBr = false) = 0;
+  virtual void SelectMin(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectMin(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual void SelectMax(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectMax(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectCmpOp(CompareNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectBior(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual void SelectBior(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectBxor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual void SelectBxor(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+  virtual Operand *SelectAbs(UnaryNode &node, Operand &opnd0) = 0;
+  virtual Operand *SelectBnot(UnaryNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectBswap(IntrinsicopNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectExtractbits(ExtractbitsNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectDepositBits(DepositbitsNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectRegularBitFieldLoad(ExtractbitsNode &node, const BaseNode &parent) = 0;
+  virtual Operand *SelectLnot(UnaryNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectNeg(UnaryNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectRecip(UnaryNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectSqrt(UnaryNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectCeil(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectFloor(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectRetype(TypeCvtNode &node, Operand &opnd0) = 0;
+  virtual Operand *SelectRound(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectCvt(const BaseNode &parent, TypeCvtNode &node, Operand &opnd0) = 0;
+  virtual Operand *SelectTrunc(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual Operand *SelectSelect(TernaryNode &node, Operand &cond, Operand &opnd0, Operand &opnd1,
+                                const BaseNode &parent, bool hasCompare = false) = 0;
+  virtual Operand *SelectMalloc(UnaryNode &call, Operand &opnd0) = 0;
+  virtual RegOperand &SelectCopy(Operand &src, PrimType srcType, PrimType dstType) = 0;
+  virtual Operand *SelectAlloca(UnaryNode &call, Operand &opnd0) = 0;
+  virtual Operand *SelectGCMalloc(GCMallocNode &call) = 0;
+  virtual Operand *SelectJarrayMalloc(JarrayMallocNode &call, Operand &opnd0) = 0;
+  virtual void SelectRangeGoto(RangeGotoNode &rangeGotoNode, Operand &opnd0) = 0;
+  virtual Operand *SelectLazyLoad(Operand &opnd0, PrimType primType) = 0;
+  virtual Operand *SelectLazyLoadStatic(MIRSymbol &st, int64 offset, PrimType primType) = 0;
+  virtual Operand *SelectLoadArrayClassCache(MIRSymbol &st, int64 offset, PrimType primType) = 0;
+  virtual void GenerateYieldpoint(BB &bb) = 0;
+  virtual Operand &ProcessReturnReg(PrimType primType, int32 sReg) = 0;
+
+  virtual Operand &GetOrCreateRflag() = 0;
+  virtual const Operand *GetRflag() const = 0;
+  virtual const Operand *GetFloatRflag() const = 0;
+  virtual const LabelOperand *GetLabelOperand(LabelIdx labIdx) const = 0;
+  virtual LabelOperand &GetOrCreateLabelOperand(LabelIdx labIdx) = 0;
+  virtual LabelOperand &GetOrCreateLabelOperand(BB &bb) = 0;
+  virtual RegOperand &CreateVirtualRegisterOperand(regno_t vRegNO) = 0;
+  virtual RegOperand &GetOrCreateVirtualRegisterOperand(regno_t vRegNO) = 0;
+  virtual RegOperand &GetOrCreateVirtualRegisterOperand(RegOperand &regOpnd) = 0;
+  virtual RegOperand &GetOrCreateFramePointerRegOperand() = 0;
+  virtual RegOperand &GetOrCreateStackBaseRegOperand() = 0;
+  virtual RegOperand *GetBaseReg(const SymbolAlloc &symAlloc) = 0;
+  virtual int32 GetBaseOffset(const SymbolAlloc &symbolAlloc) = 0;
+  virtual RegOperand &GetZeroOpnd(uint32 size) = 0;
+  virtual Operand &CreateCfiRegOperand(uint32 reg, uint32 size) = 0;
+  virtual Operand &GetTargetRetOperand(PrimType primType, int32 sReg) = 0;
+  virtual Operand &CreateImmOperand(PrimType primType, int64 val) = 0;
+  virtual void ReplaceOpndInInsn(RegOperand &regDest, RegOperand &regSrc, Insn &insn, regno_t destNO) = 0;
+  virtual void CleanupDeadMov(bool dump) = 0;
+  virtual void GetRealCallerSaveRegs(const Insn &insn, std::set<regno_t> &realCallerSave) = 0;
+
+  /* ra */
+  virtual void AddtoCalleeSaved(regno_t reg) = 0;
+
+  virtual bool IsFrameReg(const RegOperand &opnd) const = 0;
+  virtual bool IsSPOrFP(const RegOperand &opnd) const = 0;
+  virtual bool IsReturnReg(const RegOperand &opnd) const = 0;
+  virtual bool IsSaveReg(const RegOperand &reg, MIRType &mirType, BECommon &cgBeCommon) const = 0;
+
+  /* For Neon intrinsics */
+  virtual RegOperand *SelectVectorAddLong(PrimType rTy, Operand *o1, Operand *o2, PrimType oty, bool isLow) = 0;
+  virtual RegOperand *SelectVectorAddWiden(Operand *o1, PrimType oty1, Operand *o2, PrimType oty2, bool isLow) = 0;
+  virtual RegOperand *SelectVectorAbs(PrimType rType, Operand *o1) = 0;
+  virtual RegOperand *SelectVectorBinOp(PrimType rType, Operand *o1, PrimType oTyp1, Operand *o2,
+                                        PrimType oTyp2, Opcode opc) = 0;
+  virtual RegOperand *SelectVectorBitwiseOp(PrimType rType, Operand *o1, PrimType oty1, Operand *o2,
+                                            PrimType oty2, Opcode opc) = 0;;
+  virtual RegOperand *SelectVectorCompareZero(Operand *o1, PrimType oty1, Operand *o2, Opcode opc) = 0;
+  virtual RegOperand *SelectVectorCompare(Operand *o1, PrimType oty1,  Operand *o2, PrimType oty2, Opcode opc) = 0;
+  virtual RegOperand *SelectVectorFromScalar(PrimType pType, Operand *opnd, PrimType sType) = 0;
+  virtual RegOperand *SelectVectorDup(PrimType rType, Operand *src, bool getLow) = 0;
+  virtual RegOperand *SelectVectorGetElement(PrimType rType, Operand *src, PrimType sType, int32 lane) = 0;
+  virtual RegOperand *SelectVectorAbsSubL(PrimType rType, Operand *o1, Operand *o2, PrimType oTy, bool isLow) = 0;
+  virtual RegOperand *SelectVectorMadd(Operand *o1, PrimType oTyp1, Operand *o2, PrimType oTyp2, Operand *o3,
+                                       PrimType oTyp3) = 0;
+  virtual RegOperand *SelectVectorMerge(PrimType rTyp, Operand *o1, Operand *o2, int32 iNum) = 0;
+  virtual RegOperand *SelectVectorMull(PrimType rType, Operand *o1, PrimType oTyp1,
+      Operand *o2, PrimType oTyp2, bool isLow) = 0;
+  virtual RegOperand *SelectVectorNarrow(PrimType rType, Operand *o1, PrimType otyp) = 0;
+  virtual RegOperand *SelectVectorNarrow2(PrimType rType, Operand *o1, PrimType oty1, Operand *o2, PrimType oty2) = 0;
+  virtual RegOperand *SelectVectorNeg(PrimType rType, Operand *o1) = 0;
+  virtual RegOperand *SelectVectorNot(PrimType rType, Operand *o1) = 0;
+
+  virtual RegOperand *SelectVectorPairwiseAdalp(Operand *src1, PrimType sty1, Operand *src2, PrimType sty2) = 0;
+  virtual RegOperand *SelectVectorPairwiseAdd(PrimType rType, Operand *src, PrimType sType) = 0;
+  virtual RegOperand *SelectVectorReverse(PrimType rtype, Operand *src, PrimType stype, uint32 size) = 0;
+  virtual RegOperand *SelectVectorSetElement(Operand *eOp, PrimType eTyp, Operand *vOpd, PrimType vTyp, int32 lane) = 0;
+  virtual RegOperand *SelectVectorShift(PrimType rType, Operand *o1,
+                                        PrimType oty1, Operand *o2, PrimType oty2, Opcode opc) = 0;
+  virtual RegOperand *SelectVectorShiftImm(PrimType rType, Operand *o1, Operand *imm, int32 sVal, Opcode opc) = 0;
+  virtual RegOperand *SelectVectorShiftRNarrow(PrimType rType, Operand *o1, PrimType oType,
+                                               Operand *o2, bool isLow) = 0;
+  virtual RegOperand *SelectVectorSubWiden(PrimType resType, Operand *o1, PrimType otyp1,
+                                           Operand *o2, PrimType otyp2, bool isLow, bool isWide) = 0;
+  virtual RegOperand *SelectVectorSum(PrimType rtype, Operand *o1, PrimType oType) = 0;
+  virtual RegOperand *SelectVectorTableLookup(PrimType rType, Operand *o1, Operand *o2) = 0;
+  virtual RegOperand *SelectVectorWiden(PrimType rType, Operand *o1, PrimType otyp, bool isLow) = 0;
+  virtual RegOperand *SelectVectorMovNarrow(PrimType rType, Operand *opnd, PrimType oType) = 0;
+
+  /* For ebo issue. */
+  virtual Operand *GetTrueOpnd() {
+    return nullptr;
+  }
+  virtual void ClearUnreachableGotInfos(BB &bb) {
+    (void)bb;
+  };
+  virtual void ClearUnreachableConstInfos(BB &bb) {
+    (void)bb;
+  };
+  LabelIdx CreateLabel();
+
+  RegOperand *GetVirtualRegisterOperand(regno_t vRegNO) {
+    auto it = vRegOperandTable.find(vRegNO);
+    return it == vRegOperandTable.end() ? nullptr : it->second;
+  }
+
+  Operand &CreateCfiImmOperand(int64 val, uint32 size) const {
+    return *memPool->New<cfi::ImmOperand>(val, size);
+  }
+
+  Operand &CreateCfiStrOperand(const std::string &str) const {
+    return *memPool->New<cfi::StrOperand>(str, *memPool);
+  }
+
+  bool IsSpecialPseudoRegister(PregIdx spr) const {
+    return spr < 0;
+  }
+
+  regno_t NewVReg(RegType regType, uint32 size) {
+    if (CGOptions::UseGeneralRegOnly()) {
+      CHECK_FATAL(regType != kRegTyFloat, "cannot use float | SIMD register with --general-reg-only");
+    }
+    /* when vRegCount reach to maxRegCount, maxRegCount limit adds 80 every time */
+    /* and vRegTable increases 80 elements. */
+    if (vRegCount >= maxRegCount) {
+      ASSERT(vRegCount < maxRegCount + 1, "MAINTIAN FAILED");
+      maxRegCount += kRegIncrStepLen;
+      vRegTable.resize(maxRegCount);
+    }
+#if TARGAARCH64 || TARGX86_64 || TARGRISCV64
+    if (size < k4ByteSize) {
+      size = k4ByteSize;
+    }
+#if TARGAARCH64
+    /* cannot handle 128 size register */
+    if (regType == kRegTyInt && size > k8ByteSize) {
+      size = k8ByteSize;
+    }
+#endif
+    ASSERT(size == k4ByteSize || size == k8ByteSize || size == k16ByteSize, "check size");
+#endif
+    new (&vRegTable[vRegCount]) VirtualRegNode(regType, size);
+    return vRegCount++;
+  }
+
+  virtual regno_t NewVRflag() {
+    return 0;
+  }
+
+  RegType GetRegTyFromPrimTy(PrimType primType) const {
+    switch (primType) {
+      case PTY_u1:
+      case PTY_i8:
+      case PTY_u8:
+      case PTY_i16:
+      case PTY_u16:
+      case PTY_i32:
+      case PTY_u32:
+      case PTY_i64:
+      case PTY_u64:
+      case PTY_a32:
+      case PTY_a64:
+      case PTY_ptr:
+      case PTY_i128:
+      case PTY_u128:
+      case PTY_agg:
+        return kRegTyInt;
+      case PTY_f32:
+      case PTY_f64:
+      case PTY_v2i32:
+      case PTY_v2u32:
+      case PTY_v2i64:
+      case PTY_v2u64:
+      case PTY_v2f32:
+      case PTY_v2f64:
+      case PTY_v4i16:
+      case PTY_v4u16:
+      case PTY_v4i32:
+      case PTY_v4u32:
+      case PTY_v4f32:
+      case PTY_v8i8:
+      case PTY_v8u8:
+      case PTY_v8i16:
+      case PTY_v8u16:
+      case PTY_v16i8:
+      case PTY_v16u8:
+        return kRegTyFloat;
+      default:
+        ASSERT(false, "Unexpected pty");
+        return kRegTyUndef;
+    }
+  }
+
+  /* return Register Type */
+  virtual RegType GetRegisterType(regno_t rNum) const {
+    CHECK(rNum < vRegTable.size(), "index out of range in GetVRegSize");
+    return vRegTable[rNum].GetType();
+  }
+
+#if TARGX86_64
+  uint32 GetMaxVReg() const {
+    return vRegCount + opndBuilder->GetCurrentVRegNum();
+  }
+#else
+  uint32 GetMaxVReg() const {
+    return vRegCount;
+  }
+#endif
+
+  uint32 GetSSAvRegCount() const {
+    return ssaVRegCount;
+  }
+
+  void SetSSAvRegCount(uint32 count) {
+    ssaVRegCount = count;
+  }
+
+  uint32 GetVRegSize(regno_t vregNum) {
+    CHECK(vregNum < vRegTable.size(), "index out of range in GetVRegSize");
+    return GetOrCreateVirtualRegisterOperand(vregNum).GetSize() / kBitsPerByte;
+  }
+
+  MIRSymbol *GetRetRefSymbol(BaseNode &expr);
+
+  void PatchLongBranch();
+
+  virtual uint32 MaxCondBranchDistance() {
+    return INT_MAX;
+  }
+
+  virtual void InsertJumpPad(Insn *) {
+    return;
+  }
+
+  virtual LabelIdx GetLabelInInsn(Insn &insn) {
+    return 0;
+  }
+
+  Operand *CreateDbgImmOperand(int64 val) const {
+    return memPool->New<mpldbg::ImmOperand>(val);
+  }
+
+  uint32 NumBBs() const {
+    return bbCnt;
+  }
+
+#if DEBUG
+  StIdx GetLocalVarReplacedByPreg(PregIdx reg) {
+    auto it = pregsToVarsMap->find(reg);
+    return it != pregsToVarsMap->end() ? it->second : StIdx();
+  }
+#endif
+
+  void IncTotalNumberOfInstructions() {
+    totalInsns++;
+  }
+
+  void DecTotalNumberOfInstructions() {
+    totalInsns--;
+  }
+
+  uint32 GetTotalNumberOfInstructions() const {
+    return totalInsns + insnBuilder->GetCreatedInsnNum();
+  }
+
+  int32 GetStructCopySize() const {
+    return structCopySize;
+  }
+
+  int32 GetMaxParamStackSize() const {
+    return maxParamStackSize;
+  }
+
+  virtual void ProcessLazyBinding() = 0;
+
+  /* Debugging support */
+  void SetDebugInfo(DebugInfo *dbgInfo) {
+    debugInfo = dbgInfo;
+  }
+
+  void AddDIESymbolLocation(const MIRSymbol *sym, SymbolAlloc *loc, bool isParam);
+
+  virtual void DBGFixCallFrameLocationOffsets() {};
+
+  /* Get And Set private members */
+  CG *GetCG() {
+    return cg;
+  }
+
+  const CG *GetCG() const {
+    return cg;
+  }
+
+  MIRModule &GetMirModule() {
+    return mirModule;
+  }
+
+  const MIRModule &GetMirModule() const {
+    return mirModule;
+  }
+
+  template <typename T>
+  MIRConst *NewMirConst(T &mirConst) {
+    MIRConst *newConst = mirModule.GetMemPool()->New<T>(mirConst.GetValue(), mirConst.GetType());
+    return newConst;
+  }
+
+  uint32 GetMIRSrcFileEndLineNum() const {
+    auto &srcFileInfo = mirModule.GetSrcFileInfo();
+    if (!srcFileInfo.empty()) {
+      return srcFileInfo.back().second;
+    } else {
+      return 0;
+    }
+  }
+
+  MIRFunction &GetFunction() {
+    return func;
+  }
+
+  const MIRFunction &GetFunction() const {
+    return func;
+  }
+
+  EHFunc *GetEHFunc() {
+    return ehFunc;
+  }
+
+  const EHFunc *GetEHFunc() const {
+    return ehFunc;
+  }
+
+  void SetEHFunc(EHFunc &ehFunction) {
+    ehFunc = &ehFunction;
+  }
+
+  uint32 GetLabelIdx() const {
+    return labelIdx;
+  }
+
+  void SetLabelIdx(uint32 idx) {
+    labelIdx = idx;
+  }
+
+  LabelNode *GetStartLabel() {
+    return startLabel;
+  }
+
+  const LabelNode *GetStartLabel() const {
+    return startLabel;
+  }
+
+  void SetStartLabel(LabelNode &label) {
+    startLabel = &label;
+  }
+
+  LabelNode *GetEndLabel() {
+    return endLabel;
+  }
+
+  const LabelNode *GetEndLabel() const {
+    return endLabel;
+  }
+
+  void SetEndLabel(LabelNode &label) {
+    endLabel = &label;
+  }
+
+  LabelNode *GetCleanupLabel() {
+    return cleanupLabel;
+  }
+
+  const LabelNode *GetCleanupLabel() const {
+    return cleanupLabel;
+  }
+
+  void SetCleanupLabel(LabelNode &node) {
+    cleanupLabel = &node;
+  }
+
+  const LabelNode *GetReturnLabel() const {
+    return returnLabel;
+  }
+
+  void SetReturnLabel(LabelNode &label) {
+    returnLabel = &label;
+  }
+
+  BB *GetFirstBB() {
+    return firstBB;
+  }
+
+  const BB *GetFirstBB() const {
+    return firstBB;
+  }
+
+  void SetFirstBB(BB &bb) {
+    firstBB = &bb;
+  }
+
+  BB *GetCleanupBB() {
+    return cleanupBB;
+  }
+
+  const BB *GetCleanupBB() const {
+    return cleanupBB;
+  }
+
+  void SetCleanupBB(BB &bb) {
+    cleanupBB = &bb;
+    cleanupBB->SetIsCleanup(true);
+  }
+
+  BB *GetLastBB() {
+    return lastBB;
+  }
+
+  const BB *GetLastBB() const {
+    return lastBB;
+  }
+
+  void SetLastBB(BB &bb) {
+    lastBB = &bb;
+  }
+
+  BB *GetReturnBB() {
+    return returnBB;
+  }
+
+  const BB *GetReturnBB() const {
+    return returnBB;
+  }
+
+  void SetPrologureBB(BB &bb) {
+    prologureBB = &bb;
+  }
+
+  BB *GetPrologureBB() {
+    return prologureBB != nullptr ? prologureBB : firstBB;
+  }
+
+  void SetReturnBB(BB &bb) {
+    returnBB = &bb;
+    returnBB->SetKind(BB::kBBReturn);
+    GetExitBBsVec().emplace_back(returnBB);
+  }
+
+  BB *GetCurBB() {
+    return curBB;
+  }
+
+  const BB *GetCurBB() const {
+    return curBB;
+  }
+
+  void SetCurBB(BB &bb) {
+    curBB = &bb;
+  }
+
+  BB *GetDummyBB() {
+    return dummyBB;
+  }
+
+  const BB *GetDummyBB() const {
+    return dummyBB;
+  }
+
+  BB *GetCommonExitBB() {
+    return commonExitBB;
+  }
+
+  LabelIdx GetFirstCGGenLabelIdx() const {
+    return firstCGGenLabelIdx;
+  }
+
+  MapleVector<BB*> &GetExitBBsVec() {
+    return exitBBVec;
+  }
+
+  const MapleVector<BB*> GetExitBBsVec() const {
+    return exitBBVec;
+  }
+
+  size_t ExitBBsVecSize() const {
+    return exitBBVec.size();
+  }
+
+  bool IsExitBBsVecEmpty() const {
+    return exitBBVec.empty();
+  }
+
+  void EraseExitBBsVec(MapleVector<BB*>::iterator it) {
+    exitBBVec.erase(it);
+  }
+
+  void PushBackExitBBsVec(BB &bb) {
+    exitBBVec.emplace_back(&bb);
+  }
+
+  void ClearExitBBsVec() {
+    exitBBVec.clear();
+  }
+
+  bool IsExtendReg(regno_t vregNum) {
+    return extendSet.find(vregNum) != extendSet.end();
+  }
+
+  void InsertExtendSet(regno_t vregNum) {
+    (void)extendSet.insert(vregNum);
+  }
+
+  void RemoveFromExtendSet(regno_t vregNum) {
+    (void)extendSet.erase(vregNum);
+  }
+
+  bool IsExitBB(const BB &currentBB) {
+    for (BB *exitBB : exitBBVec) {
+      if (exitBB == &currentBB) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  BB *GetExitBB(int32 index) {
+    return exitBBVec.at(index);
+  }
+
+  const BB *GetExitBB(int32 index) const {
+    return exitBBVec.at(index);
+  }
+
+  void PushBackNoReturnCallBBsVec(BB &bb) {
+    noReturnCallBBVec.emplace_back(&bb);
+  }
+
+  void SetLab2BBMap(int32 index, BB &bb) {
+    lab2BBMap[index] = &bb;
+  }
+
+  BB *GetBBFromLab2BBMap(uint32 index) {
+    return lab2BBMap[index];
+  }
+
+  MapleUnorderedMap<LabelIdx, BB*> &GetLab2BBMap() {
+    return lab2BBMap;
+  }
+
+  void DumpCFGToDot(const std::string &fileNamePrefix);
+
+  BECommon &GetBecommon() {
+    return beCommon;
+  }
+
+  const BECommon GetBecommon() const {
+    return beCommon;
+  }
+
+  MemLayout *GetMemlayout() {
+    return memLayout;
+  }
+
+  const MemLayout *GetMemlayout() const {
+    return memLayout;
+  }
+
+  void SetMemlayout(MemLayout &layout) {
+    memLayout = &layout;
+  }
+
+  RegisterInfo *GetTargetRegInfo() {
+    return targetRegInfo;
+  }
+
+  void SetTargetRegInfo(RegisterInfo &regInfo) {
+    targetRegInfo = &regInfo;
+  }
+
+  MemPool *GetMemoryPool() {
+    return memPool;
+  }
+
+  const MemPool *GetMemoryPool() const {
+    return memPool;
+  }
+
+  StackMemPool &GetStackMemPool() {
+    return stackMp;
+  }
+
+  MapleAllocator *GetFuncScopeAllocator() {
+    return funcScopeAllocator;
+  }
+
+  const MapleAllocator *GetFuncScopeAllocator() const {
+    return funcScopeAllocator;
+  }
+
+  const MapleMap<uint32, MIRSymbol*> GetEmitStVec() const {
+    return emitStVec;
+  }
+
+  MIRSymbol* GetEmitSt(uint32 id) {
+    return emitStVec[id];
+  }
+
+  void AddEmitSt(uint32 id, MIRSymbol &symbol) {
+    CHECK_FATAL(symbol.GetKonst()->GetKind() == kConstAggConst, "not a kConstAggConst");
+    MIRAggConst *arrayConst = safe_cast<MIRAggConst>(symbol.GetKonst());
+    for (size_t i = 0; i < arrayConst->GetConstVec().size(); ++i) {
+      CHECK_FATAL(arrayConst->GetConstVecItem(i)->GetKind() == kConstLblConst, "not a kConstLblConst");
+      MIRLblConst *lblConst = safe_cast<MIRLblConst>(arrayConst->GetConstVecItem(i));
+      ++switchLabelCnt[lblConst->GetValue()];
+    }
+    emitStVec[id] = &symbol;
+  }
+
+  void UpdateEmitSt(BB &bb, LabelIdx oldLabelIdx, LabelIdx newLabelIdx) {
+    MIRSymbol *st = GetEmitSt(bb.GetId());
+    MIRAggConst *arrayConst = safe_cast<MIRAggConst>(st->GetKonst());
+    MIRType *etype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_a64));
+    MIRConst *mirConst = GetMemoryPool()->New<MIRLblConst>(newLabelIdx,
+        GetFunction().GetPuidx(), *etype);
+    for (size_t i = 0; i < arrayConst->GetConstVec().size(); ++i) {
+      CHECK_FATAL(arrayConst->GetConstVecItem(i)->GetKind() == kConstLblConst, "not a kConstLblConst");
+      MIRLblConst *lblConst = safe_cast<MIRLblConst>(arrayConst->GetConstVecItem(i));
+      if (oldLabelIdx == lblConst->GetValue()) {
+        arrayConst->SetConstVecItem(i, *mirConst);
+        ++switchLabelCnt[newLabelIdx];
+
+        CHECK_FATAL(switchLabelCnt[oldLabelIdx] > 0, "error labelIdx");
+        --switchLabelCnt[oldLabelIdx];
+        if (switchLabelCnt[oldLabelIdx] == 0) {
+          (void)switchLabelCnt.erase(oldLabelIdx);
+        }
+      }
+    }
+  }
+
+  void DeleteEmitSt(uint32 id) {
+    MIRSymbol &symbol = *emitStVec[id];
+    CHECK_FATAL(symbol.GetKonst()->GetKind() == kConstAggConst, "not a kConstAggConst");
+    MIRAggConst *arrayConst = safe_cast<MIRAggConst>(symbol.GetKonst());
+    for (size_t i = 0; i < arrayConst->GetConstVec().size(); ++i) {
+      CHECK_FATAL(arrayConst->GetConstVecItem(i)->GetKind() == kConstLblConst, "not a kConstLblConst");
+      MIRLblConst *lblConst = safe_cast<MIRLblConst>(arrayConst->GetConstVecItem(i));
+
+      LabelIdx labelIdx = lblConst->GetValue();
+      CHECK_FATAL(switchLabelCnt[labelIdx] > 0, "error labelIdx");
+      --switchLabelCnt[labelIdx];
+      if (switchLabelCnt[labelIdx] == 0) {
+        (void)switchLabelCnt.erase(labelIdx);
+      }
+    }
+    (void)emitStVec.erase(id);
+  }
+
+  bool InSwitchTable(LabelIdx label) const {
+    if (switchLabelCnt.empty()) {
+      return false;
+    }
+    return (switchLabelCnt.find(label) != switchLabelCnt.end());
+  }
+
+  MapleVector<CGFuncLoops*> &GetLoops() {
+    return loops;
+  }
+
+  const MapleVector<CGFuncLoops*> GetLoops() const {
+    return loops;
+  }
+
+  void PushBackLoops(CGFuncLoops &loop) {
+    loops.emplace_back(&loop);
+  }
+
+  MapleVector<LmbcFormalParamInfo*> &GetLmbcParamVec() {
+    return lmbcParamVec;
+  }
+
+  void IncLmbcArgsInRegs(RegType ty) {
+    if (ty == kRegTyInt) {
+      lmbcIntArgs++;
+    } else {
+      lmbcFpArgs++;
+    }
+  }
+
+  int32 GetLmbcArgsInRegs(RegType ty) const {
+    return ty == kRegTyInt ? lmbcIntArgs : lmbcFpArgs;
+  }
+
+  void ResetLmbcArgsInRegs() {
+    lmbcIntArgs = 0;
+    lmbcFpArgs = 0;
+  }
+
+  void IncLmbcTotalArgs() {
+    lmbcTotalArgs++;
+  }
+
+  uint32 GetLmbcTotalArgs() const {
+    return lmbcTotalArgs;
+  }
+
+  void ResetLmbcTotalArgs() {
+    lmbcTotalArgs = 0;
+  }
+
+  void SetSpSaveReg(regno_t reg) {
+    spSaveReg = reg;
+  }
+
+  regno_t GetSpSaveReg() {
+    return spSaveReg;
+  }
+
+  MapleVector<BB*> &GetAllBBs() {
+    return bbVec;
+  }
+
+  std::size_t GetAllBBSize() const {
+    return bbVec.size();
+  }
+
+  BB *GetBBFromID(uint32 id) {
+    return bbVec[id];
+  }
+  void ClearBBInVec(uint32 id) {
+    bbVec[id] = nullptr;
+  }
+
+#if TARGARM32
+  MapleVector<BB*> &GetSortedBBs() {
+    return sortedBBs;
+  }
+
+  const MapleVector<BB*> &GetSortedBBs() const {
+    return sortedBBs;
+  }
+
+  void SetSortedBBs(const MapleVector<BB*> &bbVec) {
+    sortedBBs = bbVec;
+  }
+
+  MapleVector<LiveRange*> &GetLrVec() {
+    return lrVec;
+  }
+
+  const MapleVector<LiveRange*> &GetLrVec() const {
+    return lrVec;
+  }
+
+  void SetLrVec(const MapleVector<LiveRange*> &newLrVec) {
+    lrVec = newLrVec;
+  }
+#endif  /* TARGARM32 */
+
+  CGCFG *GetTheCFG() {
+    return theCFG;
+  }
+
+  void SetTheCFG(CGCFG *cfg) {
+    theCFG = cfg;
+  }
+
+  const CGCFG *GetTheCFG() const {
+    return theCFG;
+  }
+
+  regno_t GetVirtualRegNOFromPseudoRegIdx(PregIdx idx) const {
+    return regno_t(idx + firstMapleIrVRegNO);
+  }
+
+  bool GetHasProEpilogue() const {
+    return hasProEpilogue;
+  }
+
+  void SetHasProEpilogue(bool state) {
+    hasProEpilogue = state;
+  }
+
+  int32 GetDbgCallFrameOffset() const {
+    return dbgCallFrameOffset;
+  }
+
+  void SetDbgCallFrameOffset(int32 val) {
+    dbgCallFrameOffset = val;
+  }
+
+  BB *CreateNewBB() {
+    BB *bb = memPool->New<BB>(bbCnt++, *funcScopeAllocator);
+    bbVec.emplace_back(bb);
+    return bb;
+  }
+
+  BB *CreateNewBB(bool unreachable, BB::BBKind kind, uint32 frequencyVal) {
+    BB *newBB = CreateNewBB();
+    newBB->SetKind(kind);
+    newBB->SetUnreachable(unreachable);
+    newBB->SetFrequency(frequencyVal);
+    return newBB;
+  }
+
+  BB *CreateNewBB(LabelIdx label, bool unreachable, BB::BBKind kind, uint32 frequencyVal) {
+    BB *newBB = CreateNewBB(unreachable, kind, frequencyVal);
+    newBB->AddLabel(label);
+    SetLab2BBMap(label, *newBB);
+    return newBB;
+  }
+
+  void UpdateFrequency(const StmtNode &stmt) {
+    bool withFreqInfo = func.HasFreqMap() && !func.GetLastFreqMap().empty();
+    if (!withFreqInfo) {
+      return;
+    }
+    auto it = func.GetLastFreqMap().find(stmt.GetStmtID());
+    if (it != func.GetLastFreqMap().end()) {
+      frequency = it->second;
+    }
+  }
+
+  BB *StartNewBBImpl(bool stmtIsCurBBLastStmt, StmtNode &stmt) {
+    BB *newBB = CreateNewBB();
+    ASSERT(newBB != nullptr, "newBB should not be nullptr");
+    if (stmtIsCurBBLastStmt) {
+      ASSERT(curBB != nullptr, "curBB should not be nullptr");
+      curBB->SetLastStmt(stmt);
+      curBB->AppendBB(*newBB);
+      newBB->SetFirstStmt(*stmt.GetNext());
+    } else {
+      newBB->SetFirstStmt(stmt);
+      if (curBB != nullptr) {
+        if (stmt.GetPrev() != nullptr) {
+          ASSERT(stmt.GetPrev()->GetNext() == &stmt, " the next of stmt's prev should be stmt self");
+        }
+        curBB->SetLastStmt(*stmt.GetPrev());
+        curBB->AppendBB(*newBB);
+      }
+    }
+    return newBB;
+  }
+
+  BB *StartNewBB(StmtNode &stmt) {
+    BB *bb = curBB;
+    if (stmt.GetNext() != nullptr && stmt.GetNext()->GetOpCode() != OP_label) {
+      bb = StartNewBBImpl(true, stmt);
+    }
+    return bb;
+  }
+
+  void SetCurBBKind(BB::BBKind bbKind) const {
+    curBB->SetKind(bbKind);
+  }
+
+  void SetVolStore(bool val) {
+    isVolStore = val;
+  }
+
+  void SetVolReleaseInsn(Insn *insn) {
+    volReleaseInsn = insn;
+  }
+
+  bool IsAfterRegAlloc() const {
+    return isAfterRegAlloc;
+  }
+
+  void SetIsAfterRegAlloc() {
+    isAfterRegAlloc = true;
+  }
+
+  const MapleString &GetShortFuncName() const {
+    return shortFuncName;
+  }
+
+  size_t GetLSymSize() const {
+    return lSymSize;
+  }
+
+  bool HasTakenLabel() const{
+    return hasTakenLabel;
+  }
+
+  void SetHasTakenLabel() {
+    hasTakenLabel = true;
+  }
+
+  virtual InsnVisitor *NewInsnModifier() = 0;
+
+  MapleVector<DBGExprLoc*> &GetDbgCallFrameLocations(bool isParam) {
+    return isParam ? dbgParamCallFrameLocations : dbgLocalCallFrameLocations;
+  }
+
+  bool HasAsm() const {
+    return hasAsm;
+  }
+
+  uint32 GetUniqueID() const {
+    return func.GetPuidx();
+  }
+  void SetUseFP(bool canUseFP) {
+    useFP = canUseFP;
+  }
+
+  bool UseFP() const {
+    return useFP;
+  }
+
+  void SetSeenFP(bool seen) {
+    seenFP = seen;
+  }
+
+  bool SeenFP() const {
+    return seenFP;
+  }
+
+  void UpdateAllRegisterVregMapping(MapleMap<regno_t, PregIdx> &newMap);
+
+  void RegisterVregMapping(regno_t vRegNum, PregIdx pidx) {
+    vregsToPregsMap[vRegNum] = pidx;
+  }
+
+  uint32 GetFirstMapleIrVRegNO() const {
+    return firstMapleIrVRegNO;
+  }
+
+  void SetHasAsm() {
+    hasAsm = true;
+  }
+
+  void SetStackProtectInfo(StackProtectKind kind) {
+    stackProtectInfo |= kind;
+  }
+
+  uint8 GetStackProtectInfo() const {
+    return stackProtectInfo;
+  }
+
+  void SetNeedStackProtect(bool val) {
+    needStackProtect = val;
+  }
+
+  bool GetNeedStackProtect() const {
+    return needStackProtect;
+  }
+
+  MIRPreg *GetPseudoRegFromVirtualRegNO(const regno_t vRegNO, bool afterSSA = false) const {
+    PregIdx pri = afterSSA ? VRegNOToPRegIdx(vRegNO) : GetPseudoRegIdxFromVirtualRegNO(vRegNO);
+    if (pri == -1) {
+      return nullptr;
+    }
+    return GetFunction().GetPregTab()->PregFromPregIdx(pri);
+  }
+
+ protected:
+  uint32 firstMapleIrVRegNO = 200;        /* positioned after physical regs */
+  uint32 firstNonPregVRegNO;
+  uint32 vRegCount;                       /* for assigning a number for each CG virtual register */
+  uint32 ssaVRegCount = 0;                /* vreg  count in ssa */
+  uint32 maxRegCount;                     /* for the current virtual register number limit */
+  size_t lSymSize;                        /* size of local symbol table imported */
+  MapleVector<VirtualRegNode> vRegTable;  /* table of CG's virtual registers indexed by v_reg no */
+  MapleVector<BB*> bbVec;
+  MapleUnorderedMap<regno_t, RegOperand*> vRegOperandTable;
+  MapleUnorderedMap<PregIdx, MemOperand*> pRegSpillMemOperands;
+  MapleUnorderedMap<regno_t, MemOperand*> spillRegMemOperands;
+  MapleUnorderedMap<uint32, SpillMemOperandSet*> reuseSpillLocMem;
+  LabelIdx firstCGGenLabelIdx;
+  MapleMap<LabelIdx, uint64> labelMap;
+#if DEBUG
+  MapleMap<PregIdx, StIdx> *pregsToVarsMap = nullptr;
+#endif
+  MapleMap<regno_t, PregIdx> vregsToPregsMap;
+  uint32 totalInsns = 0;
+  int32 structCopySize = 0;
+  int32 maxParamStackSize = 0;
+  static constexpr int kRegIncrStepLen = 80; /* reg number increate step length */
+
+  bool hasVLAOrAlloca = false;
+  bool hasAlloca = false;
+  bool hasProEpilogue = false;
+  bool isVolLoad = false;
+  bool isVolStore = false;
+  bool isAfterRegAlloc = false;
+  bool isAggParamInReg = false;
+  bool hasTakenLabel = false;
+  uint32 frequency = 0;
+  DebugInfo *debugInfo = nullptr;  /* debugging info */
+  MapleVector<DBGExprLoc*> dbgParamCallFrameLocations;
+  MapleVector<DBGExprLoc*> dbgLocalCallFrameLocations;
+  RegOperand *aggParamReg = nullptr;
+  ReachingDefinition *reachingDef = nullptr;
+
+  int32 dbgCallFrameOffset = 0;
+  CG *cg;
+  MIRModule &mirModule;
+  MemPool *memPool;
+  StackMemPool &stackMp;
+
+  PregIdx GetPseudoRegIdxFromVirtualRegNO(const regno_t vRegNO) const {
+    if (IsVRegNOForPseudoRegister(vRegNO)) {
+      return PregIdx(vRegNO - firstMapleIrVRegNO);
+    }
+    return VRegNOToPRegIdx(vRegNO);
+  }
+
+  bool IsVRegNOForPseudoRegister(regno_t vRegNum) const {
+    /* 0 is not allowed for preg index */
+    uint32 n = static_cast<uint32>(vRegNum);
+    return (firstMapleIrVRegNO < n && n < firstNonPregVRegNO);
+  }
+
+  PregIdx VRegNOToPRegIdx(regno_t vRegNum) const {
+    auto it = vregsToPregsMap.find(vRegNum);
+    if (it == vregsToPregsMap.end()) {
+      return PregIdx(-1);
+    }
+    return it->second;
+  }
+
+  VirtualRegNode &GetVirtualRegNodeFromPseudoRegIdx(PregIdx idx) {
+    return vRegTable.at(GetVirtualRegNOFromPseudoRegIdx(idx));
+  }
+
+  PrimType GetTypeFromPseudoRegIdx(PregIdx idx) {
+    VirtualRegNode &vRegNode = GetVirtualRegNodeFromPseudoRegIdx(idx);
+    RegType regType = vRegNode.GetType();
+    ASSERT(regType == kRegTyInt || regType == kRegTyFloat, "");
+    uint32 size = vRegNode.GetSize();  /* in bytes */
+    ASSERT(size == sizeof(int32) || size == sizeof(int64), "");
+    return (regType == kRegTyInt ? (size == sizeof(int32) ? PTY_i32 : PTY_i64)
+                                 : (size == sizeof(float) ? PTY_f32 : PTY_f64));
+  }
+
+  int64 GetPseudoRegisterSpillLocation(PregIdx idx) {
+    const SymbolAlloc *symLoc = memLayout->GetSpillLocOfPseduoRegister(idx);
+    return static_cast<int64>(GetBaseOffset(*symLoc));
+  }
+
+  virtual MemOperand *GetPseudoRegisterSpillMemoryOperand(PregIdx idx) = 0;
+
+  uint32 GetSpillLocation(uint32 size) {
+    uint32 offset = RoundUp(nextSpillLocation, static_cast<uint64>(size));
+    nextSpillLocation = offset + size;
+    return offset;
+  }
+
+  /* See if the symbol is a structure parameter that requires a copy. */
+  bool IsParamStructCopy(const MIRSymbol &symbol) {
+    if (symbol.GetStorageClass() == kScFormal &&
+        GetBecommon().GetTypeSize(symbol.GetTyIdx().GetIdx()) > k16ByteSize) {
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  CGFunc &operator=(const CGFunc &cgFunc);
+  CGFunc(const CGFunc&);
+  StmtNode *HandleFirstStmt();
+  bool CheckSkipMembarOp(const StmtNode &stmt);
+  MIRFunction &func;
+  EHFunc *ehFunc = nullptr;
+
+  InsnBuilder *insnBuilder = nullptr;
+  OperandBuilder *opndBuilder = nullptr;
+
+  uint32 bbCnt = 0;
+  uint32 labelIdx = 0;          /* local label index number */
+  LabelNode *startLabel = nullptr;    /* start label of the function */
+  LabelNode *returnLabel = nullptr;   /* return label of the function */
+  LabelNode *cleanupLabel = nullptr;  /* label to indicate the entry of cleanup code. */
+  LabelNode *endLabel = nullptr;      /* end label of the function */
+
+  BB *firstBB = nullptr;
+  BB *prologureBB = nullptr;  /* the BB to placing prologure's instructions(callee save/cfi) */
+  BB *returnBB = nullptr;
+  BB *cleanupBB = nullptr;
+  BB *lastBB = nullptr;
+  BB *curBB = nullptr;
+  BB *dummyBB;   /* use this bb for add some instructions to bb that is no curBB. */
+  BB *commonExitBB = nullptr;  /* this post-dominate all BBs */
+
+  Insn *volReleaseInsn = nullptr;  /* use to record the release insn for volatile strore */
+  MapleVector<BB*> exitBBVec;
+  MapleVector<BB*> noReturnCallBBVec;
+  MapleSet<regno_t> extendSet;  /* use to mark regs which spilled 32 bits but loaded 64 bits. */
+  MapleUnorderedMap<LabelIdx, BB*> lab2BBMap;
+  BECommon &beCommon;
+  MemLayout *memLayout = nullptr;
+  RegisterInfo *targetRegInfo = nullptr;
+  MapleAllocator *funcScopeAllocator;
+  MapleMap<uint32, MIRSymbol*> emitStVec;  /* symbol that needs to be emit as a local symbol. i.e, switch table */
+  MapleUnorderedMap<LabelIdx, int32> switchLabelCnt;  /* label in switch table */
+#if TARGARM32
+  MapleVector<BB*> sortedBBs;
+  MapleVector<LiveRange*> lrVec;
+#endif  /* TARGARM32 */
+  MapleVector<CGFuncLoops*> loops;
+  MapleVector<LmbcFormalParamInfo*> lmbcParamVec;
+  CGCFG *theCFG = nullptr;
+  MapleSet<uint32> scpIdSet;
+  const MapleString shortFuncName;
+  int32 lmbcIntArgs = 0;
+  int32 lmbcFpArgs = 0;
+  uint32 lmbcTotalArgs = 0;
+  uint32 nextSpillLocation = 0;
+  regno_t spSaveReg = 0;
+
+  bool hasAsm = false;
+  bool useFP = true;
+  bool seenFP = true;
+
+  /* save stack protect kinds which can trigger stack protect */
+  uint8 stackProtectInfo = 0;
+  bool needStackProtect = false;
+};  /* class CGFunc */
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgLayoutFrame, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgHandleFunction, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgFixCFLocOsft, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgGenCfi, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgEmission, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgGenProEpiLog, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgIsolateFastPath, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_CGFUNC_H */
diff --git a/src/mapleall/maple_be/include/cg/control_dep_analysis.h b/src/mapleall/maple_be/include/cg/control_dep_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..bc572bfee46f5ca4920a6e02b6a022167b9edd2b
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/control_dep_analysis.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_PDG_ANALYSIS_H
+#define MAPLEBE_INCLUDE_CG_PDG_ANALYSIS_H
+
+#include "cfg_mst.h"
+#include "instrument.h"
+#include "cg_cdg.h"
+#include "cg_dominance.h"
+#include "data_dep_base.h"
+#include "loop.h"
+
+namespace maplebe {
+/* Analyze Control Dependence */
+class ControlDepAnalysis {
+ public:
+  ControlDepAnalysis(CGFunc &func, MemPool &memPool, MemPool &tmpPool, PostDomAnalysis &pd,
+                     CFGMST<BBEdge<maplebe::BB>, maplebe::BB> &cfgmst)
+      : cgFunc(func), pdom(&pd), cfgMST(&cfgmst), cdgMemPool(memPool), tmpMemPool(&tmpPool), cdgAlloc(&memPool),
+        tmpAlloc(&tmpPool), nonPdomEdges(tmpAlloc.Adapter()), curCondNumOfBB(tmpAlloc.Adapter()) {}
+  ControlDepAnalysis(CGFunc &func, MemPool &memPool)
+      : cgFunc(func), cdgMemPool(memPool), cdgAlloc(&memPool), tmpAlloc(&memPool),
+        nonPdomEdges(cdgAlloc.Adapter()), curCondNumOfBB(cdgAlloc.Adapter()) {}
+  virtual ~ControlDepAnalysis() = default;
+
+  /* The entry of analysis */
+  void Run();
+
+  /* Interface for obtaining PDGAnalysis infos */
+  FCDG *GetFCDG() {
+    return fcdg;
+  }
+
+  /* Print forward-control-dependence-graph in dot syntax */
+  void GenerateFCDGDot() const;
+  /* Print control-flow-graph with condition at edges in dot syntax */
+  void GenerateCFGDot() const;
+  void CreateAllCDGNodes();
+
+ protected:
+  void BuildCFGInfo();
+  void ConstructFCDG();
+  void ComputeRegions();
+  void ComputeRegionForCurNode(uint32 curBBId, std::vector<bool> &visited);
+  void CreateAndDivideRegion(uint32 pBBId);
+  void ComputeRegionForNonDepNodes();
+  CDGRegion *FindExistRegion(CDGNode &node);
+  bool IsISEqualToCDs(CDGNode &parent, CDGNode &child);
+  void MergeRegions(CDGNode &mergeNode, CDGNode &candiNode);
+
+  CDGEdge *BuildControlDependence(const BB &fromBB, const BB &toBB, int32 condition);
+  CDGRegion *CreateFCDGRegion(CDGNode &curNode);
+
+  void AddNonPdomEdges(BBEdge<maplebe::BB> *bbEdge) {
+    nonPdomEdges.emplace_back(bbEdge);
+  }
+
+  uint32 GetAndAccSuccedCondNum(uint32 bbId) {
+    auto pair = curCondNumOfBB.try_emplace(bbId, 0);
+    if (pair.second) {
+      return 0;
+    } else {
+      uint32 curNum = pair.first->second;
+      pair.first->second = curNum + 1;
+      return curNum;
+    }
+  }
+
+  static bool IsSameControlDependence(const CDGEdge &edge1, const CDGEdge &edge2) {
+    CDGNode &fromNode1 = edge1.GetFromNode();
+    CDGNode &fromNode2 = edge2.GetFromNode();
+    if (fromNode1.GetNodeId() != fromNode2.GetNodeId()) {
+      return false;
+    }
+    if (edge1.GetCondition() != edge2.GetCondition()) {
+      return false;
+    }
+    return true;
+  }
+
+  CGFunc &cgFunc;
+  PostDomAnalysis *pdom = nullptr;
+  CFGMST<BBEdge<maplebe::BB>, maplebe::BB> *cfgMST = nullptr;
+  MemPool &cdgMemPool;
+  MemPool *tmpMemPool = nullptr;
+  MapleAllocator cdgAlloc;
+  MapleAllocator tmpAlloc;
+  MapleVector<BBEdge<maplebe::BB>*> nonPdomEdges;
+  MapleUnorderedMap<uint32, uint32> curCondNumOfBB; // <BBId, assigned condNum>
+  FCDG *fcdg = nullptr;
+  uint32 lastRegionId = 0;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgControlDepAnalysis, maplebe::CGFunc);
+ControlDepAnalysis *GetResult() {
+  return cda;
+}
+ControlDepAnalysis *cda = nullptr;
+ private:
+  void GetAnalysisDependence(maple::AnalysisDep &aDep) const override;
+MAPLE_FUNC_PHASE_DECLARE_END
+} /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_PDG_ANALYSIS_H */
diff --git a/src/mapleall/maple_be/include/cg/data_dep_analysis.h b/src/mapleall/maple_be/include/cg/data_dep_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8902784808b9d00433c044b805baea9db29dceb
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/data_dep_analysis.h
@@ -0,0 +1,96 @@
+/*
+* Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/*
+ * Build intra/inter block data dependence graph.
+ * 1: Build data dependence nodes
+ * 2: Build edges between dependence nodes. Edges are:
+ *   2.1) True dependence
+ *   2.2) Anti dependence
+ *   2.3) Output dependence
+ *   2.4) Barrier dependence
+ */
+#ifndef MAPLEBE_INCLUDE_CG_DATA_DEP_ANALYSIS_H
+#define MAPLEBE_INCLUDE_CG_DATA_DEP_ANALYSIS_H
+
+#include "data_dep_base.h"
+#include "mempool.h"
+#include "cg_cdg.h"
+
+namespace maplebe {
+/* Analyze IntraBlock Data Dependence */
+class IntraDataDepAnalysis {
+ public:
+  IntraDataDepAnalysis(MemPool &mp, CGFunc &f, DataDepBase &dataDepBase)
+      : intraMp(mp), intraAlloc(&mp), cgFunc(f), ddb(dataDepBase) {}
+  virtual ~IntraDataDepAnalysis() = default;
+
+  void Run(BB &bb, MapleVector<DepNode*> &dataNodes);
+  void InitCurNodeInfo(MemPool &tmpMp, MapleAllocator &tmpAlloc, BB &bb, MapleVector<DepNode*> &dataNodes);
+  void ClearCurNodeInfo(MemPool *tmpMp, MapleAllocator *tmpAlloc);
+  void AddEndSeparatorNode(BB &bb, MapleVector<DepNode*> &nodes);
+
+ private:
+  MemPool &intraMp;
+  MapleAllocator intraAlloc;
+  CGFunc &cgFunc;
+  DataDepBase &ddb;
+};
+
+/* Analyze InterBlock Data Dependence */
+class InterDataDepAnalysis {
+ public:
+  InterDataDepAnalysis(CGFunc &f, MemPool &memPool, DataDepBase &dataDepBase)
+      : cgFunc(f), interAlloc(&memPool), ddb(dataDepBase),
+        readyNodes(interAlloc.Adapter()), restNodes(interAlloc.Adapter()) {}
+  virtual ~InterDataDepAnalysis() = default;
+
+  void AddReadyNode(CDGNode *node) {
+    (void)readyNodes.emplace_back(node);
+  }
+  void RemoveReadyNode(CDGNode *node) {
+    auto it = std::find(readyNodes.begin(), readyNodes.end(), node);
+    if (it != readyNodes.end()) {
+      (void)readyNodes.erase(it);
+    }
+  }
+  void InitRestNodes(MapleVector<CDGNode*> &nodes) {
+    restNodes = nodes;
+  }
+  void RemoveRestNode(CDGNode *node) {
+    auto it = std::find(restNodes.begin(), restNodes.end(), node);
+    if (it != restNodes.end()) {
+      (void)restNodes.erase(it);
+    }
+  }
+
+  void Run(CDGRegion &region, MapleVector<DepNode*> &dataNodes);
+  void GlobalInit(MapleVector<DepNode*> &dataNodes);
+  void LocalInit(BB &bb, CDGNode &cdgNode, MapleVector<DepNode*> &dataNodes, std::size_t idx);
+  void GenerateInterDDGDot(MapleVector<DepNode*> &dataNodes);
+
+ protected:
+  void ComputeTopologicalOrderInRegion(CDGRegion &region);
+
+ private:
+  CGFunc &cgFunc;
+  MapleAllocator interAlloc;
+  DataDepBase &ddb;
+  MapleVector<CDGNode*> readyNodes;
+  MapleVector<CDGNode*> restNodes;
+};
+} /* namespace maplebe */
+
+#endif  // MAPLEBE_INCLUDE_CG_DATA_DEP_ANALYSIS_H
diff --git a/src/mapleall/maple_be/include/cg/data_dep_base.h b/src/mapleall/maple_be/include/cg/data_dep_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1d41a3dc46263028e5017d06c4ca0e166d41a91
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/data_dep_base.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_DATA_DEP_BASE_H
+#define MAPLEBE_INCLUDE_CG_DATA_DEP_BASE_H
+
+#include "deps.h"
+#include "cgbb.h"
+#include "cg_cdg.h"
+
+namespace maplebe {
+using namespace maple;
+constexpr maple::uint32 kMaxDependenceNum = 200;
+
+class DataDepBase {
+ public:
+  DataDepBase(MemPool &memPool, CGFunc &func, MAD &mad)
+      : memPool(memPool), alloc(&memPool), cgFunc(func), mad(mad), beforeRA(!cgFunc.IsAfterRegAlloc()) {}
+  virtual ~DataDepBase() = default;
+
+  enum DataFlowInfoType : uint8 {
+    kDataFlowUndef,
+    kMembar,
+    kLastCall,
+    kLastFrameDef,
+    kStackUses,
+    kStackDefs,
+    kHeapUses,
+    kHeapDefs,
+    kMayThrows,
+    kAmbiguous,
+  };
+
+  uint32 GetSeparatorIndex() const {
+    return separatorIndex;
+  }
+  void SetSeparatorIndex(uint32 index) {
+    separatorIndex = index;
+  }
+  void SetCDGNode(CDGNode *cdgNode) {
+    curCDGNode = cdgNode;
+  }
+  CDGNode *GetCDGNode() {
+    return curCDGNode;
+  }
+  void SetLastFrameDefInsn(Insn *insn) {
+    curCDGNode->SetLastFrameDefInsn(insn);
+  }
+  void CopyAndClearComments(MapleVector<Insn*> &comments) {
+    curCDGNode->CopyAndClearComments(comments);
+  }
+  MapleVector<Insn*> &GetLastComments() const {
+    return curCDGNode->GetLastComments();
+  }
+  void ClearLastComments() const {
+    curCDGNode->ClearLastComments();
+  }
+
+  void ProcessNonMachineInsn(Insn &insn, MapleVector<Insn*> &comments, MapleVector<DepNode*> &dataNodes,
+                             const Insn *&locInsn);
+
+  void AddDependence4InsnInVectorByType(MapleVector<Insn*> &insns, Insn &insn, const DepType &type);
+  void AddDependence4InsnInVectorByTypeAndCmp(MapleVector<Insn*> &insns, Insn &insn, const DepType &type);
+
+  void DumpDepNode(const DepNode &node) const;
+  void DumpDepLink(const DepLink &link, const DepNode *node) const;
+  const std::string &GetDepTypeName(DepType depType) const;
+  void CombineDependence(DepNode &firstNode, const DepNode &secondNode, bool isAcrossSeparator,
+                         bool isMemCombine = false);
+
+  bool IsIntraBlockAnalysis() const;
+  bool IfInAmbiRegs(regno_t regNO) const;
+  void AddDependence(DepNode &fromNode, DepNode &toNode, DepType depType);
+  void RemoveSelfDeps(Insn &insn);
+  void BuildDepsUseReg(Insn &insn, regno_t regNO);
+  void BuildDepsDefReg(Insn &insn, regno_t regNO);
+  void BuildDepsAmbiInsn(Insn &insn);
+  void BuildAmbiInsnDependency(Insn &insn);
+  void BuildDepsMayThrowInsn(Insn &insn);
+  void BuildMayThrowInsnDependency(Insn &insn);
+  void BuildDepsSeparator(DepNode &newSepNode, MapleVector<DepNode*> &nodes);
+  void BuildDepsControlAll(Insn &insn, const MapleVector<DepNode*> &nodes);
+  void BuildDepsBetweenControlRegAndCall(Insn &insn, bool isDest);
+  void BuildDepsLastCallInsn(Insn &insn);
+  void SeparateDependenceGraph(MapleVector<DepNode*> &nodes, uint32 &nodeSum);
+  DepNode *GenerateDepNode(Insn &insn, MapleVector<DepNode*> &nodes, uint32 &nodeSum, MapleVector<Insn*> &comments);
+  void UpdateStackAndHeapDependency(DepNode &depNode, Insn &insn, const Insn &locInsn);
+  void BuildSeparatorNodeDependency(MapleVector<DepNode*> &dataNodes, Insn &insn);
+  void BuildInterBlockDefUseDependency(DepNode &curDepNode, regno_t regNO, DepType depType, bool isDef);
+  void BuildPredPathDefDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                     regno_t regNO, DepType depType);
+  void BuildPredPathUseDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                     regno_t regNO, DepType depType);
+  void BuildInterBlockSpecialDataInfoDependency(DepNode &curDepNode, bool needCmp, DepType depType,
+                                                DataDepBase::DataFlowInfoType infoType);
+  void BuildPredPathSpecialDataInfoDependencyDFS(BB &curBB, std::vector<bool> &visited, bool needCmp, DepNode &depNode,
+                                                 DepType depType, DataDepBase::DataFlowInfoType infoType);
+
+  virtual void CombineClinit(DepNode &firstNode, DepNode &secondNode, bool isAcrossSeparator) = 0;
+  virtual void CombineMemoryAccessPair(DepNode &firstNode, DepNode &secondNode, bool useFirstOffset) = 0;
+  virtual bool IsFrameReg(const RegOperand&) const = 0;
+  virtual void AnalysisAmbiInsns(BB &bb) = 0;
+  virtual void BuildDepsMemBar(Insn &insn) = 0;
+  virtual void BuildDepsUseMem(Insn &insn, MemOperand &memOpnd) = 0;
+  virtual void BuildDepsDefMem(Insn &insn, MemOperand &memOpnd) = 0;
+  virtual void BuildDepsAccessStImmMem(Insn &insn, bool isDest) = 0;
+  virtual void BuildCallerSavedDeps(Insn &insn) = 0;
+  virtual void BuildStackPassArgsDeps(Insn &insn) = 0;
+  virtual void BuildDepsDirtyStack(Insn &insn) = 0;
+  virtual void BuildDepsUseStack(Insn &insn) = 0;
+  virtual void BuildDepsDirtyHeap(Insn &insn) = 0;
+  virtual void BuildOpndDependency(Insn &insn) = 0;
+  virtual void BuildSpecialInsnDependency(Insn &insn, const MapleVector<DepNode*> &nodes) = 0;
+  virtual void UpdateRegUseAndDef(Insn &insn, const DepNode &depNode, MapleVector<DepNode*> &nodes) = 0;
+  virtual DepNode *BuildSeparatorNode() = 0;
+  virtual void BuildInterBlockMemDefUseDependency(DepNode &depNode, MemOperand &memOpnd,
+                                                  MemOperand *nextMemOpnd, bool isMemDef) = 0;
+  virtual void BuildPredPathMemDefDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                                MemOperand &memOpnd, MemOperand *nextMemOpnd) = 0;
+  virtual void BuildPredPathMemUseDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                                MemOperand &memOpnd, MemOperand *nextMemOpnd) = 0;
+
+ protected:
+  MemPool &memPool;
+  MapleAllocator alloc;
+  CGFunc &cgFunc;
+  MAD &mad;
+  CDGNode *curCDGNode = nullptr;
+  bool beforeRA;
+  uint32 separatorIndex = 0;
+};
+}
+
+#endif  /* MAPLEBE_INCLUDE_CG_DATA_DEP_BASE_H */
diff --git a/src/mapleall/maple_be/include/cg/datainfo.h b/src/mapleall/maple_be/include/cg/datainfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..108a19be5e53c167ae6d9c02b1b5d238bd6e74a9
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/datainfo.h
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_DATAINFO_H
+#define MAPLEBE_INCLUDE_CG_DATAINFO_H
+#include "maple_string.h"
+#include "common_utils.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+
+namespace maplebe {
+class DataInfo {
+ public:
+  DataInfo(uint32 bitNum, MapleAllocator &alloc)
+      : info((bitNum / kWordSize + 1), 0, alloc.Adapter()) {}
+  DataInfo(const DataInfo &other, MapleAllocator &alloc) : info(other.info, alloc.Adapter()) {}
+  DataInfo &Clone(MapleAllocator &alloc) {
+    auto *dataInfo = alloc.New<DataInfo>(*this, alloc);
+    return *dataInfo;
+  }
+
+  ~DataInfo() = default;
+
+  void SetBit(int64 bitNO) {
+    ASSERT(bitNO < info.size() * kWordSize, "Out of Range");
+    info[static_cast<size_t>(bitNO / kWordSize)] |= (1ULL << static_cast<uint64>((bitNO % kWordSize)));
+  }
+
+  void ResetBit(uint32 bitNO) {
+    info[bitNO / kWordSize] &= (~(1ULL << (bitNO % kWordSize)));
+  }
+
+  bool TestBit(uint32 bitNO) const {
+    return (info[bitNO / kWordSize] & (1ULL << (bitNO % kWordSize))) != 0ULL;
+  }
+
+  const uint64 &GetElem(uint32 index) const {
+    ASSERT(index < info.size(), "out of range");
+    return info[index];
+  }
+
+  void SetElem(uint32 index, uint64 val) {
+    ASSERT(index < info.size(), "out of range");
+    info[index] = val;
+  }
+
+  bool NoneBit() const {
+    for (auto &data : info) {
+      if (data != 0ULL) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  size_t Size() const {
+    return info.size() * kWordSize;
+  }
+
+  const MapleVector<uint64> &GetInfo() const {
+    return info;
+  }
+
+  bool IsEqual(const DataInfo &secondInfo) const {
+    auto infoSize = static_cast<const uint32>(info.size());
+    ASSERT(infoSize == secondInfo.GetInfo().size(), "two dataInfo's size different");
+    for (uint32 i = 0; i != infoSize; ++i) {
+      if (info[i] != secondInfo.GetElem(i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool IsEqual(const MapleVector<uint64> &liveInfoBak) const {
+    size_t infoSize = info.size();
+    ASSERT(infoSize == liveInfoBak.size(), "two dataInfo's size different");
+    for (size_t i = 0; i != infoSize; ++i) {
+      if (info[i] != liveInfoBak[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  void AndBits(const DataInfo &secondInfo) {
+    auto infoSize = static_cast<const uint32>(info.size());
+    ASSERT(infoSize == secondInfo.GetInfo().size(), "two dataInfo's size different");
+    for (uint32 i = 0; i != infoSize; ++i) {
+      info[i] &= secondInfo.GetElem(i);
+    }
+  }
+
+  void OrBits(const DataInfo &secondInfo) {
+    auto infoSize = static_cast<const uint32>(info.size());
+    ASSERT(infoSize == secondInfo.GetInfo().size(), "two dataInfo's size different");
+    for (uint32 i = 0; i != infoSize; i++) {
+      info[i] |= secondInfo.GetElem(i);
+    }
+  }
+
+  bool OrBitsCheck(const DataInfo &secondInfo) {
+    auto infoSize = static_cast<const uint32>(info.size());
+    ASSERT(infoSize == secondInfo.GetInfo().size(), "two dataInfo's size different");
+    bool changed = false;
+    for (uint32 i = 0; i != infoSize; i++) {
+      if (info[i] != secondInfo.GetElem(i)) {
+        changed = true;
+        info[i] |= secondInfo.GetElem(i);
+      }
+    }
+    return changed;
+  }
+
+  void OrDesignateBits(const DataInfo &secondInfo, uint32 infoIndex) {
+    ASSERT(infoIndex < secondInfo.GetInfo().size(), "out of secondInfo's range");
+    ASSERT(infoIndex < info.size(), "out of secondInfo's range");
+    info[infoIndex] |= secondInfo.GetElem(infoIndex);
+  }
+
+  void EorBits(const DataInfo &secondInfo) {
+    auto infoSize = static_cast<const uint32>(info.size());
+    ASSERT(infoSize == secondInfo.GetInfo().size(), "two dataInfo's size different");
+    for (uint32 i = 0; i != infoSize; i++) {
+      info[i] ^= secondInfo.GetElem(i);
+    }
+  }
+
+  /* if bit in secondElem is 1, bit in current DataInfo is set 0 */
+  void Difference(const DataInfo &secondInfo) {
+    auto infoSize = static_cast<const uint32>(info.size());
+    ASSERT(infoSize == secondInfo.GetInfo().size(), "two dataInfo's size different");
+    for (uint32 i = 0; i != infoSize; i++) {
+      info[i] &= (~(secondInfo.GetElem(i)));
+    }
+  }
+
+  void ResetAllBit() {
+    for (auto &data : info) {
+      data = 0ULL;
+    }
+  }
+
+  void EnlargeCapacityToAdaptSize(uint32 bitNO) {
+    /* add one more size for each enlarge action */
+    auto sizeToEnlarge = static_cast<int32>((bitNO / kWordSize + 1) - info.size());
+    for (int32 i = 0; i < sizeToEnlarge; i++) {
+      info.emplace_back(0ULL);
+    }
+  }
+
+  void GetNonZeroElemsIndex(std::set<uint32> &index) {
+    auto infoSize = static_cast<const int32>(info.size());
+    for (int32 i = 0; i < infoSize; i++) {
+      if (info[i] != 0ULL) {
+        (void)index.insert(i);
+      }
+    }
+  }
+
+  template<typename T>
+  void GetBitsOfInfo(T &wordRes) const {
+    wordRes.clear();
+    for (size_t i = 0; i != info.size(); ++i) {
+      uint32 result = 0;
+      uint64 word = info[i];
+      uint32 offset = 0;
+      uint32 baseWord = 0;
+      bool firstTime = true;
+      while (word > 0) {
+        int32 index = __builtin_ffsll(static_cast<int64>(word));
+        if (index == 0) {
+          continue;
+        }
+        if (index == k64BitSize) {
+          /* when the highest bit is 1, the shift operation will cause error, need special treatment. */
+          result = i * kWordSize + (index - 1);
+          (void)wordRes.insert(result);
+          break;
+        }
+        if (firstTime) {
+          offset = static_cast<uint32>(index - 1);
+          baseWord = i * kWordSize;
+          firstTime = false;
+        } else {
+          offset = static_cast<uint32>(index);
+          baseWord = 0;
+        }
+        result += baseWord + offset;
+        (void)wordRes.insert(result);
+        word = word >> static_cast<uint64>(index);
+      }
+    }
+  }
+
+  void ClearDataInfo() {
+    info.clear();
+  }
+
+ private:
+  /* long type has 8 bytes, 64 bits */
+  static constexpr int32 kWordSize = 64;
+  MapleVector<uint64> info;
+};
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_INSN_H */
diff --git a/src/mapleall/maple_be/include/cg/dbg.def b/src/mapleall/maple_be/include/cg/dbg.def
new file mode 100644
index 0000000000000000000000000000000000000000..e3f6760b783b4d2299d90a6850867f541172f1ca
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/dbg.def
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/* .loc fileNum lineNum */
+DBG_DEFINE(loc,     , 3, Immediate, Immediate, Immediate)
+DBG_DEFINE(scope,   , 2, Immediate, Immediate, Undef)
diff --git a/src/mapleall/maple_be/include/cg/dbg.h b/src/mapleall/maple_be/include/cg/dbg.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ef3cb45615957be9f466c698b0833db5b14d05b
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/dbg.h
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_DBG_H
+#define MAPLEBE_INCLUDE_CG_DBG_H
+
+#include "insn.h"
+#include "mempool_allocator.h"
+#include "mir_symbol.h"
+#include "debug_info.h"
+
+namespace mpldbg {
+using namespace maple;
+
+/* https://sourceware.org/binutils/docs-2.28/as/Loc.html */
+enum LocOpt { kBB, kProEnd, kEpiBeg, kIsStmt, kIsa, kDisc };
+
+enum DbgOpcode : uint8 {
+#define DBG_DEFINE(k, sub, n, o0, o1, o2) OP_DBG_##k##sub,
+#define ARM_DIRECTIVES_DEFINE(k, sub, n, o0, o1, o2) OP_ARM_DIRECTIVES_##k##sub,
+#include "dbg.def"
+#undef DBG_DEFINE
+#undef ARM_DIRECTIVES_DEFINE
+  kOpDbgLast
+};
+
+class DbgInsn : public maplebe::Insn {
+ public:
+  DbgInsn(MemPool &memPool, maplebe::MOperator op) : Insn(memPool, op) {}
+
+  DbgInsn(MemPool &memPool, maplebe::MOperator op, maplebe::Operand &opnd0) : Insn(memPool, op, opnd0) {}
+
+  DbgInsn(MemPool &memPool, maplebe::MOperator op, maplebe::Operand &opnd0, maplebe::Operand &opnd1)
+      : Insn(memPool, op, opnd0, opnd1) {}
+
+  DbgInsn(MemPool &memPool, maplebe::MOperator op, maplebe::Operand &opnd0, maplebe::Operand &opnd1,
+      maplebe::Operand &opnd2)
+      : Insn(memPool, op, opnd0, opnd1, opnd2) {}
+
+  ~DbgInsn() = default;
+
+  bool IsMachineInstruction() const override {
+    return false;
+  }
+
+  void Dump() const override;
+
+#if DEBUG
+  void Check() const override;
+#endif
+
+  bool IsTargetInsn() const override{
+    return false;
+  }
+
+  bool IsDbgInsn() const override {
+    return true;
+  }
+
+  bool IsRegDefined(maplebe::regno_t regNO) const override {
+    CHECK_FATAL(false, "dbg insn do not def regs");
+    return false;
+  }
+
+  std::set<uint32> GetDefRegs() const override{
+    CHECK_FATAL(false, "dbg insn do not def regs");
+    return std::set<uint32>();
+  }
+
+  uint32 GetBothDefUseOpnd() const override {
+    return maplebe::kInsnMaxOpnd;
+  }
+
+  uint32 GetLoc() const;
+
+ private:
+  DbgInsn &operator=(const DbgInsn&);
+};
+
+class ImmOperand : public maplebe::OperandVisitable<ImmOperand> {
+ public:
+  explicit ImmOperand(int64 val) : OperandVisitable(kOpdImmediate, 32), val(val) {}
+
+  ~ImmOperand() = default;
+  using OperandVisitable<ImmOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    Operand *opnd =  memPool.Clone<ImmOperand>(*this);
+    return opnd;
+  }
+
+  void Dump() const override;
+
+  bool Less(const Operand &right) const override {
+    (void)right;
+    return false;
+  }
+
+  int64 GetVal() const {
+    return val;
+  }
+
+ private:
+  int64 val;
+};
+
+class DBGOpndEmitVisitor : public maplebe::OperandVisitorBase,
+                           public maplebe::OperandVisitor<ImmOperand> {
+ public:
+  explicit DBGOpndEmitVisitor(maplebe::Emitter &asmEmitter): emitter(asmEmitter) {}
+  virtual ~DBGOpndEmitVisitor() = default;
+ protected:
+  maplebe::Emitter &emitter;
+ private:
+  void Visit(ImmOperand *v) final;
+};
+
+}  /* namespace mpldbg */
+
+#endif  /* MAPLEBE_INCLUDE_CG_DBG_H */
diff --git a/src/mapleall/maple_be/include/cg/dependence.h b/src/mapleall/maple_be/include/cg/dependence.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba92b5651d2906e0978b8fb50e7f5891b9ab64d2
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/dependence.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_DEPENDENCE_H
+#define MAPLEBE_INCLUDE_CG_DEPENDENCE_H
+
+#include "cgbb.h"
+#include "deps.h"
+
+namespace maplebe {
+using namespace maple;
+namespace {
+constexpr maple::uint32 kMaxDependenceNum = 200;
+};
+
+class DepAnalysis {
+ public:
+  DepAnalysis(CGFunc &func, MemPool &memPool, MAD &mad, bool beforeRA)
+      : cgFunc(func), memPool(memPool), alloc(&memPool), beforeRA(beforeRA), mad(mad), lastComments(alloc.Adapter()) {}
+
+  virtual ~DepAnalysis() = default;
+
+  virtual void Run(BB &bb, MapleVector<DepNode *> &nodes) = 0;
+
+  const MapleVector<Insn *> &GetLastComments() const {
+    return lastComments;
+  }
+  virtual void CombineClinit(DepNode &firstNode, DepNode &secondNode, bool isAcrossSeparator) = 0;
+  virtual void CombineDependence(DepNode &firstNode, DepNode &secondNode, bool isAcrossSeparator,
+                                 bool isMemCombine = false) = 0;
+  virtual void CombineMemoryAccessPair(DepNode &firstNode, DepNode &secondNode, bool useFirstOffset) = 0;
+
+  virtual const std::string &GetDepTypeName(DepType depType) const = 0;
+  virtual void DumpDepNode(DepNode &node) const = 0;
+  virtual void DumpDepLink(DepLink &link, const DepNode *node) const = 0;
+
+ protected:
+  CGFunc &cgFunc;
+  MemPool &memPool;
+  MapleAllocator alloc;
+  bool beforeRA;
+  MAD &mad;
+  MapleVector<Insn *> lastComments;
+
+  virtual void Init(BB &bb, MapleVector<DepNode *> &nodes) = 0;
+  virtual void ClearAllDepData() = 0;
+  virtual void AnalysisAmbiInsns(BB &bb) = 0;
+  virtual void AppendRegUseList(Insn &insn, regno_t regNO) = 0;
+  virtual void AddDependence(DepNode &fromNode, DepNode &toNode, DepType depType) = 0;
+  virtual void RemoveSelfDeps(Insn &insn) = 0;
+  virtual void BuildDepsUseReg(Insn &insn, regno_t regNO) = 0;
+  virtual void BuildDepsDefReg(Insn &insn, regno_t regNO) = 0;
+  virtual void BuildDepsAmbiInsn(Insn &insn) = 0;
+  virtual void BuildDepsMayThrowInsn(Insn &insn) = 0;
+  virtual void BuildDepsUseMem(Insn &insn, MemOperand &memOpnd) = 0;
+  virtual void BuildDepsDefMem(Insn &insn, MemOperand &memOpnd) = 0;
+  virtual void BuildDepsMemBar(Insn &insn) = 0;
+  virtual void BuildDepsSeparator(DepNode &newSepNode, MapleVector<DepNode *> &nodes) = 0;
+  virtual void BuildDepsControlAll(DepNode &depNode, const MapleVector<DepNode *> &nodes) = 0;
+  virtual void BuildDepsAccessStImmMem(Insn &insn, bool isDest) = 0;
+  virtual void BuildCallerSavedDeps(Insn &insn) = 0;
+  virtual void BuildDepsBetweenControlRegAndCall(Insn &insn, bool isDest) = 0;
+  virtual void BuildStackPassArgsDeps(Insn &insn) = 0;
+  virtual void BuildDepsDirtyStack(Insn &insn) = 0;
+  virtual void BuildDepsUseStack(Insn &insn) = 0;
+  virtual void BuildDepsDirtyHeap(Insn &insn) = 0;
+  virtual DepNode *BuildSeparatorNode() = 0;
+  virtual bool IfInAmbiRegs(regno_t regNO) const = 0;
+  virtual bool IsFrameReg(const RegOperand &) const = 0;
+};
+}  // namespace maplebe
+
+#endif /* MAPLEBE_INCLUDE_CG_DEPENDENCE_H */
diff --git a/src/mapleall/maple_be/include/cg/deps.h b/src/mapleall/maple_be/include/cg/deps.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a71c17c0600fe1806cc583556c6b6f964c5400d
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/deps.h
@@ -0,0 +1,465 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_DEPS_H
+#define MAPLEBE_INCLUDE_CG_DEPS_H
+
+#include <array>
+#include "mad.h"
+#include "pressure.h"
+namespace maplebe {
+#define PRINT_STR_VAL(STR, VAL) \
+  LogInfo::MapleLogger() << std::left << std::setw(12) << STR << VAL << " | ";
+#define PRINT_VAL(VAL) \
+  LogInfo::MapleLogger() << std::left << std::setw(12) << VAL << " | ";
+
+enum DepType : uint8 {
+  kDependenceTypeTrue,
+  kDependenceTypeOutput,
+  kDependenceTypeAnti,
+  kDependenceTypeControl,
+  kDependenceTypeMembar,
+  kDependenceTypeThrow,
+  kDependenceTypeSeparator,
+  kDependenceTypeNone
+};
+
+inline const std::array<std::string, kDependenceTypeNone + 1> kDepTypeName = {
+  "true-dep",
+  "output-dep",
+  "anti-dep",
+  "control-dep",
+  "membar-dep",
+  "throw-dep",
+  "separator-dep",
+  "none-dep",
+};
+
+enum NodeType : uint8 {
+  kNodeTypeNormal,
+  kNodeTypeSeparator,
+  kNodeTypeEmpty
+};
+
+enum ScheduleState : uint8 {
+  kNormal,
+  kReady,
+  kScheduled,
+};
+
+class DepNode;
+
+class DepLink {
+ public:
+  DepLink(DepNode &fromNode, DepNode &toNode, DepType typ) : from(fromNode), to(toNode), depType(typ), latency(0) {}
+  virtual ~DepLink() = default;
+
+  DepNode &GetFrom() const {
+    return from;
+  }
+  DepNode &GetTo() const {
+    return to;
+  }
+  void SetDepType(DepType dType) {
+    depType = dType;
+  }
+  DepType GetDepType() const {
+    return depType;
+  }
+  void SetLatency(uint32 lat) {
+    latency = lat;
+  }
+  uint32 GetLatency() const {
+    return latency;
+  }
+
+ private:
+  DepNode &from;
+  DepNode &to;
+  DepType depType;
+  uint32 latency;
+};
+
+class DepNode {
+ public:
+  bool CanBeScheduled() const;
+  void OccupyUnits();
+  uint32 GetUnitKind() const;
+
+  DepNode(Insn &insn, MapleAllocator &alloc)
+      : insn(&insn), units(nullptr), reservation(nullptr), unitNum(0),
+        eStart(0), lStart(0), visit(0), type(kNodeTypeNormal), state(kNormal), index(0), simulateCycle(0),
+        schedCycle(0), bruteForceSchedCycle(0), validPredsSize(0), validSuccsSize(0),
+        preds(alloc.Adapter()), succs(alloc.Adapter()), comments(alloc.Adapter()),
+        cfiInsns(alloc.Adapter()), clinitInsns(alloc.Adapter()), locInsn(nullptr), useRegnos(alloc.Adapter()),
+        defRegnos(alloc.Adapter()), regPressure(nullptr) {}
+
+  DepNode(Insn &insn, MapleAllocator &alloc, Unit * const *unit, uint32 num, Reservation &rev)
+      : insn(&insn), units(unit),
+        reservation(&rev), unitNum(num), eStart(0), lStart(0), visit(0), type(kNodeTypeNormal), state(kNormal),
+        index(0), simulateCycle(0), schedCycle(0), bruteForceSchedCycle(0), validPredsSize(0), validSuccsSize(0),
+        preds(alloc.Adapter()), succs(alloc.Adapter()), comments(alloc.Adapter()), cfiInsns(alloc.Adapter()),
+        clinitInsns(alloc.Adapter()), locInsn(nullptr), useRegnos(alloc.Adapter()), defRegnos(alloc.Adapter()),
+        regPressure(nullptr) {}
+
+  virtual ~DepNode() = default;
+
+  Insn *GetInsn() const {
+    return insn;
+  }
+  void SetInsn(Insn &rvInsn) {
+    insn = &rvInsn;
+  }
+  void SetUnits(Unit * const *unit) {
+    units = unit;
+  }
+  const Unit *GetUnitByIndex(uint32 idx) const {
+    ASSERT(index < unitNum, "out of units");
+    return units[idx];
+  }
+  Reservation *GetReservation() const {
+    return reservation;
+  }
+  void SetReservation(Reservation &rev) {
+    reservation = &rev;
+  }
+  uint32 GetUnitNum() const {
+    return unitNum;
+  }
+  void SetUnitNum(uint32 num) {
+    unitNum = num;
+  }
+  uint32 GetEStart() const {
+    return eStart;
+  }
+  void SetEStart(uint32 start) {
+    eStart = start;
+  }
+  uint32 GetLStart() const {
+    return lStart;
+  }
+  void SetLStart(uint32 start) {
+    lStart = start;
+  }
+  uint32 GetVisit() const {
+    return visit;
+  }
+  void SetVisit(uint32 visitVal) {
+    visit = visitVal;
+  }
+  void IncreaseVisit() {
+    ++visit;
+  }
+  NodeType GetType() const {
+    return type;
+  }
+  void SetType(NodeType nodeType) {
+    type = nodeType;
+  }
+  ScheduleState GetState() const {
+    return state;
+  }
+  void SetState(ScheduleState scheduleState) {
+    state = scheduleState;
+  }
+  uint32 GetIndex() const {
+    return index;
+  }
+  void SetIndex(uint32 idx) {
+    index = idx;
+  }
+  void SetSchedCycle(uint32 cycle) {
+    schedCycle = cycle;
+  }
+  uint32 GetSchedCycle() const {
+    return schedCycle;
+  }
+  void SetSimulateCycle(uint32 cycle) {
+    simulateCycle = cycle;
+  }
+  uint32 GetSimulateCycle() const {
+    return simulateCycle;
+  }
+  void SetBruteForceSchedCycle(uint32 cycle) {
+    bruteForceSchedCycle = cycle;
+  }
+  uint32 GetBruteForceSchedCycle() const {
+    return bruteForceSchedCycle;
+  }
+  void SetValidPredsSize(uint32 validSize) {
+    validPredsSize = validSize;
+  }
+  uint32 GetValidPredsSize() const {
+    return validPredsSize;
+  }
+  void DescreaseValidPredsSize() {
+    --validPredsSize;
+  }
+  void IncreaseValidPredsSize() {
+    ++validPredsSize;
+  }
+  uint32 GetValidSuccsSize() const {
+    return validSuccsSize;
+  }
+  void SetValidSuccsSize(uint32 size) {
+    validSuccsSize = size;
+  }
+  const MapleVector<DepLink*> &GetPreds() const {
+    return preds;
+  }
+  void ReservePreds(size_t size) {
+    preds.reserve(size);
+  }
+  void AddPred(DepLink &depLink) {
+    preds.emplace_back(&depLink);
+  }
+  void RemovePred() {
+    preds.pop_back();
+  }
+  const MapleVector<DepLink*> &GetSuccs() const{
+    return succs;
+  }
+  void ReserveSuccs(size_t size) {
+    succs.reserve(size);
+  }
+  void AddSucc(DepLink &depLink) {
+    succs.emplace_back(&depLink);
+  }
+  void RemoveSucc() {
+    succs.pop_back();
+  }
+  const MapleVector<Insn*> &GetComments() const {
+    return comments;
+  }
+  void SetComments(MapleVector<Insn*> com) {
+    comments = com;
+  }
+  void AddComments(Insn &addInsn) {
+    (void)comments.emplace_back(&addInsn);
+  }
+  void ClearComments() {
+    comments.clear();
+  }
+  const MapleVector<Insn*> &GetCfiInsns() const {
+    return cfiInsns;
+  }
+  void SetCfiInsns(MapleVector<Insn*> insns) {
+    cfiInsns = insns;
+  }
+  void AddCfiInsn(Insn &curInsn) {
+    (void)cfiInsns.emplace_back(&curInsn);
+  }
+  void ClearCfiInsns() {
+    cfiInsns.clear();
+  }
+  const MapleVector<Insn*> &GetClinitInsns() const {
+    return clinitInsns;
+  }
+  void SetClinitInsns(MapleVector<Insn*> insns) {
+    clinitInsns = insns;
+  }
+  void AddClinitInsn(Insn &addInsn) {
+    (void)clinitInsns.emplace_back(&addInsn);
+  }
+  const RegPressure *GetRegPressure() const {
+    return regPressure;
+  }
+  void SetRegPressure(RegPressure &pressure) {
+    regPressure = &pressure;
+  }
+  void DumpRegPressure() const {
+    if (regPressure) {
+      regPressure->DumpRegPressure();
+    }
+  }
+  void InitPressure() const {
+    regPressure->InitPressure();
+  }
+  const MapleVector<int32> &GetPressure() const {
+    return regPressure->GetPressure();
+  }
+
+  void IncPressureByIndex(int32 idx) const {
+    regPressure->IncPressureByIndex(static_cast<uint32>(idx));
+  }
+  void DecPressureByIndex(int32 idx) const {
+    regPressure->DecPressureByIndex(static_cast<uint32>(idx));
+  }
+
+  const MapleVector<int32> &GetDeadDefNum() const {
+    return regPressure->GetDeadDefNum();
+  }
+  void IncDeadDefByIndex(int32 idx) const {
+    regPressure->IncDeadDefByIndex(static_cast<uint32>(idx));
+  }
+
+  void SetRegUses(RegList &regList) const {
+    regPressure->SetRegUses(&regList);
+  }
+  void SetRegDefs(size_t idx, RegList *regList) const {
+    regPressure->SetRegDefs(idx, regList);
+  }
+
+  int32 GetIncPressure() const {
+    return regPressure->GetIncPressure();
+  }
+  void SetIncPressure(bool value) const {
+    regPressure->SetIncPressure(value);
+  }
+  int32 GetMaxDepth() const {
+    return regPressure->GetMaxDepth();
+  }
+  void SetMaxDepth(int32 value) const {
+    regPressure->SetMaxDepth(value);
+  }
+  int32 GetNear() const {
+    return regPressure->GetNear();
+  }
+  void SetNear(int32 value) const {
+    regPressure->SetNear(value);
+  }
+  int32 GetPriority() const {
+    return regPressure->GetPriority();
+  }
+  void SetPriority(int32 value) const {
+    regPressure->SetPriority(value);
+  }
+  RegList *GetRegUses(size_t idx) const {
+    return regPressure->GetRegUses(idx);
+  }
+  void InitRegUsesSize(size_t size) const {
+    regPressure->InitRegUsesSize(size);
+  }
+  RegList *GetRegDefs(size_t idx) const {
+    return regPressure->GetRegDefs(idx);
+  }
+  void InitRegDefsSize(size_t size) const {
+    regPressure->InitRegDefsSize(size);
+  }
+
+  void SetNumCall(int32 value) const {
+    regPressure->SetNumCall(value);
+  }
+
+  int32 GetNumCall() const {
+    return regPressure->GetNumCall();
+  }
+
+  void SetHasNativeCallRegister(bool value) const {
+    regPressure->SetHasNativeCallRegister(value);
+  }
+
+  bool GetHasNativeCallRegister() const {
+    return regPressure->GetHasNativeCallRegister();
+  }
+
+  const Insn *GetLocInsn() const {
+    return locInsn;
+  }
+  void SetLocInsn(const Insn &locationInsn) {
+    locInsn = &locationInsn;
+  }
+
+  /* printf dep-node's information of scheduling */
+  void DumpSchedInfo() const {
+    PRINT_STR_VAL("estart: ", eStart);
+    PRINT_STR_VAL("lstart: ", lStart);
+    PRINT_STR_VAL("visit: ", visit);
+    PRINT_STR_VAL("state: ", state);
+    PRINT_STR_VAL("index: ", index);
+    PRINT_STR_VAL("validPredsSize: ", validPredsSize);
+    PRINT_STR_VAL("validSuccsSize: ", validSuccsSize);
+    LogInfo::MapleLogger() << '\n';
+
+    constexpr int32 width = 12;
+    LogInfo::MapleLogger() << std::left << std::setw(width) << "usereg: ";
+    for (const auto &useReg : useRegnos) {
+      LogInfo::MapleLogger() << "R" << useReg << " ";
+    }
+    LogInfo::MapleLogger() << "\n";
+    LogInfo::MapleLogger() << std::left << std::setw(width) << "defreg: ";
+    for (const auto &defReg : defRegnos) {
+      LogInfo::MapleLogger() << "R" << defReg << " ";
+    }
+    LogInfo::MapleLogger() << "\n";
+  }
+
+  void SetHasPreg(bool value) const {
+    regPressure->SetHasPreg(value);
+  }
+
+  bool GetHasPreg() const {
+    return regPressure->GetHasPreg();
+  }
+
+  void AddUseReg(regno_t reg) {
+    useRegnos.emplace_back(reg);
+  }
+
+  const MapleVector<regno_t> &GetUseRegnos() const {
+    return useRegnos;
+  }
+
+  void AddDefReg(regno_t reg) {
+    defRegnos.emplace_back(reg);
+  }
+
+  const MapleVector<regno_t> &GetDefRegnos() const {
+    return defRegnos;
+  }
+
+ private:
+  Insn *insn;
+  Unit * const *units;
+  Reservation *reservation;
+  uint32 unitNum;
+  uint32 eStart;
+  uint32 lStart;
+  uint32 visit;
+  NodeType type;
+  ScheduleState state;
+  uint32 index;
+  uint32 simulateCycle;
+  uint32 schedCycle;
+  uint32 bruteForceSchedCycle;
+
+  /* For scheduling, denotes unscheduled preds/succs number. */
+  uint32 validPredsSize;
+  uint32 validSuccsSize;
+
+  /* Dependence links. */
+  MapleVector<DepLink*> preds;
+  MapleVector<DepLink*> succs;
+
+  /* Non-machine instructions prior to insn, such as comments. */
+  MapleVector<Insn*> comments;
+
+  /* Non-machine instructions which follows insn, such as cfi instructions. */
+  MapleVector<Insn*> cfiInsns;
+
+  /* Special instructions which follows insn, such as clinit instructions. */
+  MapleVector<Insn*> clinitInsns;
+
+  /* loc insn which indicate insn location in source file */
+  const Insn *locInsn;
+
+  MapleVector<regno_t> useRegnos;
+  MapleVector<regno_t> defRegnos;
+
+  /* For register pressure analysis */
+  RegPressure *regPressure;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_DEPS_H */
diff --git a/src/mapleall/maple_be/include/cg/ebo.h b/src/mapleall/maple_be/include/cg/ebo.h
new file mode 100644
index 0000000000000000000000000000000000000000..d30cc91e7daeaf18690b1d9df1f75586526fd089
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/ebo.h
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_EBO_H
+#define MAPLEBE_INCLUDE_CG_EBO_H
+
+#include "cg_phase.h"
+#include "cgbb.h"
+#include "live.h"
+#include "loop.h"
+
+namespace maplebe {
+namespace {
+constexpr uint32 kEboDefaultMemHash = 0;
+constexpr uint32 kEboNoAliasMemHash = 1;
+constexpr uint32 kEboSpillMemHash = 2;
+constexpr uint32 kEboCopyInsnHash = 3;
+constexpr uint32 kEboReservedInsnHash = 4;
+constexpr uint32 kEboMaxExpInsnHash = 1024;
+constexpr uint32 kEboMaxOpndHash = 521;
+constexpr uint32 kEboMaxInsnHash = kEboReservedInsnHash + kEboMaxExpInsnHash;
+};
+
+#define EBO_EXP_INSN_HASH(val) ((kEboMaxExpInsnHash - 1ULL) & (static_cast<uint64>(val) >> 6))
+
+/* forward decls */
+class InsnInfo;
+
+struct OpndInfo {
+  explicit OpndInfo(Operand &opnd) : opnd(&opnd) {}
+
+  virtual ~OpndInfo() = default;
+
+  int32 hashVal = 0;  /* Mem operand is placed in hash table, this is the hashVal of it, and otherwise -1. */
+  Operand *opnd;  /* Operand */
+  Operand *replacementOpnd = nullptr;  /* Rename opnd with this new name. */
+  OpndInfo *replacementInfo = nullptr;  /* Rename opnd with this info. */
+  BB *bb = nullptr;  /* The Definining bb. */
+  Insn *insn = nullptr;  /* The Defining insn. */
+  InsnInfo *insnInfo = nullptr;
+  bool redefinedInBB = false;  /* A following definition exisit in bb. */
+  bool redefined = false;  /* A following definition exisit. */
+  Insn *redefinedInsn = nullptr; /* Next defined insn if redefinedInBB is true */
+#if TARGARM32
+  bool mayReDef = false;
+#endif
+  OpndInfo *same = nullptr;  /* Other definitions of the same operand. */
+  OpndInfo *prev = nullptr;
+  OpndInfo *next = nullptr;
+  OpndInfo *hashNext = nullptr;
+  int32 refCount = 0;  /* Number of references to the operand. */
+};
+
+struct MemOpndInfo : public OpndInfo {
+  explicit MemOpndInfo(Operand &opnd) : OpndInfo(opnd) {}
+
+  ~MemOpndInfo() override = default;
+
+  OpndInfo *GetBaseInfo() const {
+    return base;
+  }
+
+  OpndInfo *GetOffsetInfo() const{
+    return offset;
+  }
+
+  void SetBaseInfo(OpndInfo &baseInfo) {
+    base = &baseInfo;
+  }
+
+  void SetOffsetInfo(OpndInfo &offInfo) {
+    offset = &offInfo;
+  }
+
+ private:
+  OpndInfo *base = nullptr;
+  OpndInfo *offset = nullptr;
+};
+
+class InsnInfo {
+ public:
+  InsnInfo(MemPool &memPool, Insn &insn)
+      : alloc(&memPool), bb(insn.GetBB()), insn(&insn), result(alloc.Adapter()),
+        origOpnd(alloc.Adapter()), optimalOpnd(alloc.Adapter()) {}
+
+  virtual ~InsnInfo() = default;
+  MapleAllocator alloc;
+  uint32 hashIndex = 0;
+  bool mustNotBeRemoved = false;  /* Some condition requires this insn. */
+  BB *bb;  /* The defining bb. */
+  Insn *insn;  /* The defining insn. */
+  InsnInfo *same = nullptr;  /* Other insns with the same hash value. */
+  InsnInfo *prev = nullptr;
+  InsnInfo *next = nullptr;
+  MapleVector<OpndInfo*> result;  /* Result array. */
+  MapleVector<OpndInfo*> origOpnd;
+  MapleVector<OpndInfo*> optimalOpnd;
+};
+
+class Ebo {
+ public:
+  Ebo(CGFunc &func, MemPool &memPool, LiveAnalysis *live, bool before, const std::string &phase)
+      : cgFunc(&func),
+        beforeRegAlloc(before),
+        phaseName(phase),
+        live(live),
+        eboMp(&memPool),
+        eboAllocator(&memPool),
+        visitedBBs(eboAllocator.Adapter()),
+        vRegInfo(eboAllocator.Adapter()),
+        exprInfoTable(eboAllocator.Adapter()),
+        insnInfoTable(eboAllocator.Adapter()) {}
+
+  virtual ~Ebo() = default;
+
+  MemOpndInfo *GetMemInfo(InsnInfo &insnInfo) const;
+  void SetInsnInfo(uint32 hashVal, InsnInfo &info) {
+    ASSERT(hashVal < insnInfoTable.size(), "hashVal out of insnInfoTable range");
+    insnInfoTable.at(hashVal) = &info;
+  }
+
+  void IncRef(OpndInfo &info) const {
+    ++info.refCount;
+  }
+
+  void DecRef(OpndInfo &info) const {
+    --info.refCount;
+  }
+
+  void EnlargeSpaceForLA(Insn &csetInsn) const;
+  bool IsSaveReg(const Operand &opnd) const;
+  bool IsFrameReg(Operand &opnd) const;
+  bool OperandEqual(const Operand &op1, const Operand &op2) const;
+  Operand *GetZeroOpnd(uint32 size) const;
+  bool IsPhysicalReg(const Operand &opnd) const;
+  bool HasAssignedReg(const Operand &opnd) const;
+  bool IsOfSameClass(const Operand &op0, const Operand &op1) const;
+  bool OpndAvailableInBB(const BB &bb, OpndInfo *info) const;
+  bool ForwardPropCheck(const Operand *opndReplace, const OpndInfo &opndInfo, const Operand &opnd, Insn &insn);
+  bool RegForwardCheck(Insn &insn, const Operand &opnd, const Operand *opndReplace, Operand &oldOpnd,
+                       const OpndInfo *tmpInfo) const;
+  bool IsNotVisited(const BB &bb) {
+    return !visitedBBs.at(bb.GetId());
+  };
+
+  void SetBBVisited(const BB &bb) {
+    visitedBBs.at(bb.GetId()) = true;
+  };
+
+  void UpdateOpndInfo(const Operand &opnd, OpndInfo &opndInfo, OpndInfo *newInfo, int32 hashVal);
+  void SetOpndInfo(const Operand &opnd, OpndInfo *opndInfo, int32 hashVal);
+  bool RegistersIdentical(const Operand &op0, const Operand &op1) const;
+  OpndInfo *GetOpndInfo(const Operand &opnd, int32 hashVal) const;
+  OpndInfo *GetNewOpndInfo(BB &bb, Insn *insn, Operand &opnd, int32 hashVal);
+  OpndInfo *OperandInfoUse(BB &currentBB, Operand &localOpnd);
+  InsnInfo *GetNewInsnInfo(Insn &insn);
+  int32 ComputeOpndHash(const Operand &opnd) const;
+  uint32 ComputeHashVal( Insn &insn, const MapleVector<OpndInfo*> &opndInfos) const;
+  void MarkOpndLiveIntoBB(const Operand &opnd, BB &into, BB &def) const;
+  void RemoveInsn(InsnInfo &info) const;
+  void RemoveUses(uint32 opndNum, const MapleVector<OpndInfo*> &origInfo) const;
+  void HashInsn(Insn &insn, const MapleVector<OpndInfo*> &origInfo, const MapleVector<OpndInfo*> &opndInfos);
+  void BuildAllInfo(BB &bb);
+  InsnInfo *LocateInsnInfo(const OpndInfo &info) const;
+  void RemoveUnusedInsns(BB &bb, bool normal);
+  void UpdateNextInfo(const OpndInfo &opndInfo);
+  void BackupOpndInfoList(OpndInfo *saveLast);
+  void BackupInsnInfoList(InsnInfo *saveLast);
+  void AddBB2EB(BB &bb);
+  void EboInit();
+  void EboProcessSingleBB();
+  void EboProcess();
+  void Run();
+  std::string PhaseName() const {
+    return phaseName;
+  }
+
+ protected:
+  CGFunc *cgFunc;
+  bool beforeRegAlloc;  /* True if perform Ebo before register allocation. */
+  virtual OpndInfo *OperandInfoDef(BB &currentBB, Insn &currentInsn, Operand &localOpnd) = 0;
+  virtual const RegOperand &GetRegOperand(const Operand &opnd) const = 0;
+  virtual bool IsGlobalNeeded(Insn &insn) const = 0;
+  virtual bool IsDecoupleStaticOp(Insn &insn) const = 0;
+  virtual bool IsFmov(const Insn &insn) const = 0;
+  virtual bool SpecialSequence(Insn &insn, const MapleVector<OpndInfo*> &origInfos) = 0;
+  virtual bool DoConstProp(Insn &insn, uint32 i, Operand &opnd) = 0;
+  virtual bool Csel2Cset(Insn &insn, const MapleVector<Operand*> &opnds) = 0;
+  virtual bool SimplifyConstOperand(Insn &insn, const MapleVector<Operand*> &opnds,
+                                    const MapleVector<OpndInfo*> &opndInfo) = 0;
+  virtual int32 GetOffsetVal(const MemOperand &mem) const = 0;
+  virtual bool OperandEqSpecial(const Operand &op1, const Operand &op2) const = 0;
+  virtual void BuildCallerSaveRegisters() = 0;
+  virtual void DefineAsmRegisters(InsnInfo &insnInfo) = 0;
+  virtual void DefineCallerSaveRegisters(InsnInfo &insnInfo) = 0;
+  virtual void DefineReturnUseRegister(Insn &insn) = 0;
+  virtual void DefineCallUseSpecialRegister(Insn &insn) = 0;
+  virtual void DefineClinitSpecialRegisters(InsnInfo &insnInfo) = 0;
+  virtual bool IsMovToSIMDVmov(Insn &insn, const Insn &replaceInsn) const = 0;
+  virtual bool IsPseudoRet(Insn &insn) const = 0;
+  virtual bool ChangeLdrMop(Insn &insn, const Operand &opnd) const = 0;
+  virtual bool IsAdd(const Insn &insn) const = 0;
+  virtual bool IsClinitCheck(const Insn &insn) const = 0;
+  virtual bool IsLastAndBranch(BB &bb, Insn &insn) const = 0;
+  virtual bool IsSameRedefine(BB &bb, Insn &insn, OpndInfo &opndInfo) const = 0;
+  virtual bool ResIsNotDefAndUse(Insn &insn) const = 0;
+  virtual bool LiveOutOfBB(const Operand &opnd, const BB &bb) const = 0;
+  virtual bool IsInvalidReg(const RegOperand &opnd) const = 0;
+  virtual bool IsZeroRegister(const Operand &opnd) const = 0;
+  virtual bool IsConstantImmOrReg(const Operand &opnd) const = 0;
+  OpndInfo *BuildMemOpndInfo(BB &bb, Insn &insn, Operand &opnd, uint32 opndIndex);
+  OpndInfo *BuildOperandInfo(BB &bb, Insn &insn, Operand &opnd, uint32 opndIndex, MapleVector<OpndInfo*> &origInfos);
+  bool ForwardPropagateOpnd(Insn &insn, Operand *&opnd, uint32 opndIndex, OpndInfo *&opndInfo,
+                            MapleVector<OpndInfo*> &origInfos);
+  void SimplifyInsn(Insn &insn, bool &insnReplaced, bool opndsConstant, const MapleVector<Operand*> &opnds,
+                    const MapleVector<OpndInfo*> &opndInfos, const MapleVector<OpndInfo*> &origInfos);
+  void FindRedundantInsns(BB &bb, Insn *&insn, const Insn *prev, bool insnReplaced,
+                          MapleVector<Operand*> &opnds, MapleVector<OpndInfo*> &opndInfos,
+                          const MapleVector<OpndInfo*> &origInfos);
+  void PreProcessSpecialInsn(Insn &insn);
+
+  std::string phaseName;
+  LiveAnalysis *live;
+  uint32 bbNum = 0;  /* bb numbers for an extend block. */
+  MemPool *eboMp;
+  MapleAllocator eboAllocator;
+  MapleVector<bool> visitedBBs;
+  OpndInfo *firstOpndInfo = nullptr;
+  OpndInfo *lastOpndInfo = nullptr;
+  InsnInfo *firstInsnInfo = nullptr;
+  InsnInfo *lastInsnInfo = nullptr;
+  MapleUnorderedMap<uint32, OpndInfo*> vRegInfo;
+  MapleVector<OpndInfo*> exprInfoTable;
+  MapleVector<InsnInfo*> insnInfoTable;
+  bool optSuccess = false;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgEbo0, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE(CgEbo1, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE(CgPostEbo, maplebe::CGFunc)
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_EBO_H */
diff --git a/src/mapleall/maple_be/include/cg/eh_func.h b/src/mapleall/maple_be/include/cg/eh_func.h
new file mode 100644
index 0000000000000000000000000000000000000000..c997b73ef0191d00879c2d7f8d9e03c9ef29f9f5
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/eh_func.h
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_EH_EH_FUNC_H
+#define MAPLEBE_INCLUDE_EH_EH_FUNC_H
+#include "mir_parser.h"
+#include "mir_function.h"
+#include "lsda.h"
+#include "cg_phase.h"
+#include "maple_phase.h"
+
+namespace maplebe {
+class EHTry {
+ public:
+  EHTry(MapleAllocator &alloc, TryNode &tryNode)
+      : tryNode(&tryNode),
+        catchVec(alloc.Adapter()) {}
+  ~EHTry() = default;
+
+  TryNode *GetTryNode() const {
+    return tryNode;
+  }
+
+  void SetEndtryNode(StmtNode &endtryNode) {
+    this->endTryNode = &endtryNode;
+  }
+
+  StmtNode *GetEndtryNode() {
+    return endTryNode;
+  }
+
+  void SetFallthruGoto(StmtNode *fallthruGoto) {
+    this->fallThroughGoto = fallthruGoto;
+  }
+
+  StmtNode *GetFallthruGoto() {
+    return fallThroughGoto;
+  }
+
+  size_t GetCatchVecSize() const {
+    return catchVec.size();
+  }
+
+  void PushBackCatchVec(CatchNode &catchNode) {
+    catchVec.emplace_back(&catchNode);
+  }
+
+  CatchNode *GetCatchNodeAt(size_t pos) const {
+    CHECK_FATAL(pos < GetCatchVecSize(), "pos is out of range.");
+    return catchVec.at(pos);
+  }
+
+  void SetLSDACallSite(LSDACallSite &lsdaCallSiteVal) {
+    this->lsdaCallSite = &lsdaCallSiteVal;
+  }
+
+  void SetCSAction(uint32 action) const {
+    lsdaCallSite->csAction = action;
+  }
+
+  void DumpEHTry(const MIRModule &mirModule);
+
+ private:
+  TryNode *tryNode;
+  StmtNode *endTryNode = nullptr;
+  StmtNode *fallThroughGoto = nullptr;  /* no throw in the try block, the goto stmt to the fall through */
+  MapleVector<CatchNode*> catchVec;
+  LSDACallSite *lsdaCallSite = nullptr;  /* one try has a callsite */
+};
+
+class EHThrow {
+ public:
+  explicit EHThrow(UnaryStmtNode &rtNode)
+      : rethrow(&rtNode) {}
+  ~EHThrow() = default;
+
+  bool IsUnderTry() const {
+    return javaTry != nullptr;
+  }
+
+  bool HasLSDA() const {
+    return startLabel != nullptr;
+  }
+
+  const UnaryStmtNode *GetRethrow() const {
+    return rethrow;
+  }
+
+  void SetJavaTry(EHTry *javaTryVal) {
+    this->javaTry = javaTryVal;
+  }
+
+  LabelNode *GetStartLabel() {
+    return startLabel;
+  }
+
+  LabelNode *GetEndLabel() {
+    return endLabel;
+  }
+
+  void Lower(CGFunc &cgFunc);
+  void ConvertThrowToRethrow(CGFunc &cgFunc) const;
+  void ConvertThrowToRuntime(CGFunc &cgFunc, BaseNode &arg) const;
+
+ private:
+  UnaryStmtNode *rethrow;            /* must be a throw stmt */
+  EHTry *javaTry = nullptr;          /* the try statement wrapping this throw */
+  LabelNode *startLabel = nullptr;   /* the label that "MCC_RethrowException" or "MCC_ThrowException" begin */
+  LabelNode *endLabel = nullptr;     /* the label that "MCC_RethrowException" or "MCC_ThrowException" end */
+};
+
+class EHFunc {
+ public:
+  static constexpr uint8 kTypeEncoding = 0x9b;  /* same thing as LSDAHeader.kTypeEncoding */
+  explicit EHFunc(CGFunc &func);
+  ~EHFunc() = default;
+
+  void CollectEHInformation(std::vector<std::pair<LabelIdx, CatchNode*>> &catchVec);
+  void InsertEHSwitchTable();
+  void CreateLSDA();
+  bool NeedFullLSDA() const;
+  bool NeedFastLSDA() const;
+  void InsertCxaAfterEachCatch(const std::vector<std::pair<LabelIdx, CatchNode*>> &catchVec) const;
+  void GenerateCleanupLabel();
+  void MergeCatchToTry(const std::vector<std::pair<LabelIdx, CatchNode*>> &catchVec);
+  void BuildEHTypeTable(const std::vector<std::pair<LabelIdx, CatchNode*>> &catchVec);
+  void LowerThrow();  /* for non-personality function */
+  void CreateTypeInfoSt() const;
+  void DumpEHFunc() const;
+
+  bool HasThrow() const {
+    return !rethrowVec.empty();
+  }
+
+  void AddTry(EHTry &ehTry) {
+    tryVec.emplace_back(&ehTry);
+  }
+
+  size_t GetEHTyTableSize() const {
+    return ehTyTable.size();
+  }
+
+  TyIdx &GetEHTyTableMember(size_t index) {
+    CHECK_FATAL(index < ehTyTable.size(), "out of ehTyTable");
+    return ehTyTable[index];
+  }
+
+  LSDAHeader *GetLSDAHeader() {
+    return lsdaHeader;
+  }
+
+  LSDACallSiteTable *GetLSDACallSiteTable() {
+    return lsdaCallSiteTable;
+  }
+
+  const LSDACallSiteTable *GetLSDACallSiteTable() const {
+    return lsdaCallSiteTable;
+  }
+
+  const LSDAActionTable *GetLSDAActionTable() const {
+    return lsdaActionTable;
+  }
+
+  void AddRethrow(EHThrow &rethrow) {
+    rethrowVec.emplace_back(&rethrow);
+  }
+
+ private:
+  void CreateLSDAAction();
+  void InsertDefaultLabelAndAbortFunc(BlockNode &blkNode, SwitchNode &switchNode,
+                                      const StmtNode &beforeEndLabel) const;
+  void FillSwitchTable(SwitchNode &switchNode, const EHTry &ehTry);
+  void CreateLSDAHeader();
+  void FillLSDACallSiteTable();
+  LabelIdx CreateLabel(const std::string &cstr);
+  bool HasTry() const;
+
+  CGFunc *cgFunc;
+  LabelIdx labelIdx = 0;
+  MapleVector<EHTry*> tryVec;             /* try stmt node */
+  MapleVector<TyIdx> ehTyTable;           /* the type that would emit in LSDA */
+  MapleMap<TyIdx, uint32> ty2IndexTable;  /* use the TyIdx to get the index of ehTyTable; */
+  LSDAHeader *lsdaHeader = nullptr;
+  LSDACallSiteTable *lsdaCallSiteTable = nullptr;
+  LSDAActionTable *lsdaActionTable = nullptr;
+  MapleVector<EHThrow*> rethrowVec;       /* EHRethrow */
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgBuildEHFunc, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_EH_EH_FUNC_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/emit.h b/src/mapleall/maple_be/include/cg/emit.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ae714f7b36c1f5cc59f100718c702aea93381c2
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/emit.h
@@ -0,0 +1,404 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_EMIT_H
+#define MAPLEBE_INCLUDE_CG_EMIT_H
+
+/* C++ headers */
+#include <fstream>
+#include <functional>
+#include <map>
+#include <array>
+#include "isa.h"
+#include "lsda.h"
+#include "asm_info.h"
+#include "cg.h"
+
+/* Maple IR headers */
+#include "mir_module.h"
+#include "mir_const.h"
+#include "mempool_allocator.h"
+#include "muid_replacement.h"
+#include "namemangler.h"
+#include "debug_info.h"
+#include "alignment.h"
+
+namespace maple {
+const char *GetDwTagName(unsigned n);
+const char *GetDwFormName(unsigned n);
+const char *GetDwAtName(unsigned n);
+const char *GetDwOpName(unsigned n);
+}  /* namespace maple */
+
+#if TARGRISCV64
+#define CMNT "\t# "
+#else
+#define CMNT "\t// "
+#endif
+#define TEXT_BEGIN text0
+#define TEXT_END etext0
+#define DEBUG_INFO_0 debug_info0
+#define DEBUG_ABBREV_0 debug_abbrev0
+#define DEBUG_LINE_0 debug_line0
+#define DEBUG_STR_LABEL ASF
+
+namespace maplebe {
+constexpr int32 kSizeOfDecoupleStaticStruct = 4;
+constexpr uint32 kHugeSoInsnCountThreshold = 0x1f00000; /* 124M (4bytes per Insn), leave 4M rooms for 128M */
+constexpr char kHugeSoPostFix[] = "$$hugeso_";
+constexpr char kDebugMapleThis[] = "_this";
+constexpr uint32 kDwarfVersion = 4;
+constexpr uint32 kSizeOfPTR = 8;
+class StructEmitInfo {
+ public:
+  /* default ctor */
+  StructEmitInfo() = default;
+
+  ~StructEmitInfo() = default;
+
+  uint16 GetNextFieldOffset() const {
+    return nextFieldOffset;
+  }
+
+  void SetNextFieldOffset(uint16 offset) {
+    nextFieldOffset = offset;
+  }
+
+  void IncreaseNextFieldOffset(uint16 value) {
+    nextFieldOffset += value;
+  }
+
+  uint8 GetCombineBitFieldWidth() const {
+    return combineBitFieldWidth;
+  }
+
+  void SetCombineBitFieldWidth(uint8 offset) {
+    combineBitFieldWidth = offset;
+  }
+
+  void IncreaseCombineBitFieldWidth(uint8 value) {
+    combineBitFieldWidth += value;
+  }
+
+  void DecreaseCombineBitFieldWidth(uint8 value) {
+    combineBitFieldWidth -= value;
+  }
+
+  uint64 GetCombineBitFieldValue() const {
+    return combineBitFieldValue;
+  }
+
+  void SetCombineBitFieldValue(uint64 value) {
+    combineBitFieldValue = value;
+  }
+
+  uint64 GetTotalSize() const {
+    return totalSize;
+  }
+
+  void SetTotalSize(uint64 value) {
+    totalSize = value;
+  }
+
+  void IncreaseTotalSize(uint64 value) {
+    totalSize += value;
+  }
+
+ private:
+  /* Next field offset in struct. */
+  uint16 nextFieldOffset = 0;
+  uint8 combineBitFieldWidth = 0;
+  uint64 combineBitFieldValue = 0;
+  /* Total size emitted in current struct. */
+  uint64 totalSize = 0;
+};
+
+class FuncEmitInfo {
+ public:
+  CGFunc &GetCGFunc() {
+    return cgFunc;
+  }
+
+  const CGFunc &GetCGFunc() const {
+    return cgFunc;
+  }
+
+ protected:
+  explicit FuncEmitInfo(CGFunc &func) : cgFunc(func) {}
+  ~FuncEmitInfo() = default;
+
+ private:
+  CGFunc &cgFunc;
+};
+
+class Emitter {
+ public:
+  void CloseOutput() {
+    if (outStream.is_open()) {
+      outStream.close();
+    }
+    rangeIdx2PrefixStr.clear();
+    hugeSoTargets.clear();
+    labdie2labidxTable.clear();
+    fileMap.clear();
+  }
+
+  MOperator GetCurrentMOP() const {
+    return currentMop;
+  }
+
+  void SetCurrentMOP(const MOperator &mOp) {
+    currentMop = mOp;
+  }
+
+  void EmitAsmLabel(AsmLabel label);
+  void EmitAsmLabel(const MIRSymbol &mirSymbol, AsmLabel label);
+  void EmitFileInfo(const std::string &fileName);
+  /* a symbol start/end a block */
+  void EmitBlockMarker(const std::string &markerName, const std::string &sectionName,
+                       bool withAddr, const std::string &addrName = "");
+  void EmitNullConstant(uint64 size);
+  void EmitCombineBfldValue(StructEmitInfo &structEmitInfo);
+  void EmitBitFieldConstant(StructEmitInfo &structEmitInfo, MIRConst &mirConst, const MIRType *nextType,
+                            uint64 fieldOffset);
+  void EmitScalarConstant(MIRConst &mirConst, bool newLine = true, bool flag32 = false, bool isIndirect = false);
+  void EmitStr(const std::string& mplStr, bool emitAscii = false, bool emitNewline = false);
+  void EmitStrConstant(const MIRStrConst &mirStrConst, bool isIndirect = false);
+  void EmitStr16Constant(const MIRStr16Const &mirStr16Const);
+  void EmitIntConst(const MIRSymbol &mirSymbol, MIRAggConst &aggConst, uint32 itabConflictIndex,
+                    const std::map<GStrIdx, MIRType*> &strIdx2Type, size_t idx);
+  void EmitAddrofFuncConst(const MIRSymbol &mirSymbol, MIRConst &elemConst, size_t idx);
+  void EmitAddrofSymbolConst(const MIRSymbol &mirSymbol, MIRConst &elemConst, size_t idx);
+  void EmitConstantTable(const MIRSymbol &mirSymbol, MIRConst &mirConst,
+                         const std::map<GStrIdx, MIRType*> &strIdx2Type);
+  void EmitClassInfoSequential(const MIRSymbol &mirSymbol, const std::map<GStrIdx, MIRType*> &strIdx2Type,
+                               const std::string &sectionName);
+  void EmitMethodFieldSequential(const MIRSymbol &mirSymbol, const std::map<GStrIdx, MIRType*> &strIdx2Type,
+                                 const std::string &sectionName);
+  void EmitLiterals(std::vector<std::pair<MIRSymbol*, bool>> &literals,
+                    const std::map<GStrIdx, MIRType*> &strIdx2Type);
+  void EmitFuncLayoutInfo(const MIRSymbol &layout);
+  void EmitGlobalVars(std::vector<std::pair<MIRSymbol*, bool>> &globalVars);
+  void EmitGlobalVar(const MIRSymbol &globalVar);
+  void EmitStaticFields(const std::vector<MIRSymbol*> &fields);
+  void EmitLiteral(const MIRSymbol &literal, const std::map<GStrIdx, MIRType*> &strIdx2Type);
+  void EmitStringPointers();
+  void GetHotAndColdMetaSymbolInfo(const std::vector<MIRSymbol*> &mirSymbolVec,
+                                   std::vector<MIRSymbol*> &hotFieldInfoSymbolVec,
+                                   std::vector<MIRSymbol*> &coldFieldInfoSymbolVec, const std::string &prefixStr,
+                                   bool forceCold = false) const;
+  void EmitMetaDataSymbolWithMarkFlag(const std::vector<MIRSymbol*> &mirSymbolVec,
+                                      const std::map<GStrIdx, MIRType*> &strIdx2Type,
+                                      const std::string &prefixStr, const std::string &sectionName,
+                                      bool isHotFlag);
+  void EmitMethodDeclaringClass(const MIRSymbol &mirSymbol, const std::string &sectionName);
+  void MarkVtabOrItabEndFlag(const std::vector<MIRSymbol*> &mirSymbolVec) const;
+  void EmitArrayConstant(MIRConst &mirConst);
+  void EmitStructConstant(MIRConst &mirConst);
+  void EmitStructConstant(MIRConst &mirConst, uint32 &subStructFieldCounts);
+  void EmitVectorConstant(MIRConst &mirConst);
+  void EmitLocalVariable(const CGFunc &cgFunc);
+  void EmitUninitializedSymbolsWithPrefixSection(const MIRSymbol &symbol, const std::string &sectionName);
+  void EmitUninitializedSymbol(const MIRSymbol &mirSymbol);
+  void EmitGlobalVariable();
+  void EmitGlobalRootList(const MIRSymbol &mirSymbol);
+  void EmitMuidTable(const std::vector<MIRSymbol*> &vec, const std::map<GStrIdx, MIRType*> &strIdx2Type,
+                     const std::string &sectionName);
+  MIRAddroffuncConst *GetAddroffuncConst(const MIRSymbol &mirSymbol, MIRAggConst &aggConst) const;
+  int64 GetFieldOffsetValue(const std::string &className, const MIRIntConst &intConst,
+                            const std::map<GStrIdx, MIRType*> &strIdx2Type) const;
+
+  Emitter &Emit(int64 val) {
+    outStream << val;
+    return *this;
+  }
+
+  Emitter &Emit(const IntVal& val) {
+    outStream << val.GetExtValue();
+    return *this;
+  }
+
+  Emitter &Emit(const MapleString &str) {
+    ASSERT(str.c_str() != nullptr, "nullptr check");
+    outStream << str;
+    return *this;
+  }
+
+  Emitter &Emit(const std::string &str) {
+    outStream << str;
+    return *this;
+  }
+
+  void EmitLabelRef(LabelIdx labIdx);
+  void EmitStmtLabel(LabelIdx labIdx);
+  void EmitLabelPair(const LabelPair &pairLabel);
+  void EmitLabelForFunc(const MIRFunction *func, LabelIdx labIdx);
+
+  /* Emit signed/unsigned integer literals in decimal or hexadecimal */
+  void EmitDecSigned(int64 num);
+  void EmitDecUnsigned(uint64 num);
+  void EmitHexUnsigned(uint64 num);
+
+  /* Dwarf debug info */
+  void FillInClassByteSize(DBGDie *die, DBGDieAttr *byteSizeAttr) const;
+  void SetupDBGInfo(DebugInfo *mirdi);
+  void ApplyInPrefixOrder(DBGDie *die, const std::function<void(DBGDie*)> &func);
+  void AddLabelDieToLabelIdxMapping(DBGDie *lblDie, LabelIdx lblIdx);
+  LabelIdx GetLabelIdxForLabelDie(DBGDie *lblDie);
+  void EmitDIHeader();
+  void EmitDIFooter();
+  void EmitDIHeaderFileInfo();
+  void EmitDIDebugInfoSection(DebugInfo *mirdi);
+  void EmitDIDebugAbbrevSection(DebugInfo *mirdi);
+  void EmitDIDebugARangesSection();
+  void EmitDIDebugRangesSection();
+  void EmitDIDebugLineSection();
+  void EmitDIDebugStrSection();
+  void EmitDIAttrValue(DBGDie *die, DBGDieAttr *attr, DwAt attrName, DwTag tagName, DebugInfo *di);
+  void EmitDIFormSpecification(unsigned int dwform);
+  void EmitDIFormSpecification(const DBGDieAttr *attr) {
+    EmitDIFormSpecification(attr->GetDwForm());
+  }
+
+#if 1 /* REQUIRE TO SEPERATE TARGAARCH64 TARGARM32 */
+/* Following code is under TARGAARCH64 condition */
+  void EmitHugeSoRoutines(bool lastRoutine = false);
+  void EmitInlineAsmSection();
+
+  uint64 GetJavaInsnCount() const {
+    return javaInsnCount;
+  }
+
+  uint64 GetFuncInsnCount() const {
+    return funcInsnCount;
+  }
+
+  MapleMap<uint32_t, std::string> &GetFileMap() {
+    return fileMap;
+  }
+
+  void SetFileMapValue(uint32_t n, const std::string &file) {
+    fileMap[n] = file;
+  }
+
+  CG *GetCG() const {
+    return cg;
+  }
+
+  void ClearFuncInsnCount() {
+    funcInsnCount = 0;
+  }
+
+  void IncreaseJavaInsnCount(uint64 n = 1, bool alignToQuad = false) {
+    if (alignToQuad) {
+      javaInsnCount = (javaInsnCount + 1) & (~0x1UL);
+      funcInsnCount = (funcInsnCount + 1) & (~0x1UL);
+    }
+    javaInsnCount += n;
+    funcInsnCount += n;
+#ifdef EMIT_INSN_COUNT
+    Emit(" /* InsnCount: ");
+    Emit(javaInsnCount *);
+    Emit("*/ ");
+#endif
+  }
+
+  bool NeedToDealWithHugeSo() const {
+    return javaInsnCount > kHugeSoInsnCountThreshold;
+  }
+
+  std::string HugeSoPostFix() const {
+    return std::string(kHugeSoPostFix) + std::to_string(hugeSoSeqence);
+  }
+
+  void InsertHugeSoTarget(const std::string &target) {
+    (void)hugeSoTargets.insert(target);
+  }
+#endif
+
+  void InsertLabdie2labidxTable(DBGDie *lbldie, LabelIdx lab) {
+    if (labdie2labidxTable.find(lbldie) == labdie2labidxTable.end()) {
+      labdie2labidxTable[lbldie] = lab;
+    }
+  }
+
+ protected:
+  Emitter(CG &cg, const std::string &fileName)
+      : cg(&cg),
+        rangeIdx2PrefixStr(cg.GetMIRModule()->GetMPAllocator().Adapter()),
+        arraySize(0),
+        isFlexibleArray(false),
+        stringPtr(cg.GetMIRModule()->GetMPAllocator().Adapter()),
+        localStrPtr(cg.GetMIRModule()->GetMPAllocator().Adapter()),
+        hugeSoTargets(cg.GetMIRModule()->GetMPAllocator().Adapter()),
+        labdie2labidxTable(std::less<DBGDie*>(), cg.GetMIRModule()->GetMPAllocator().Adapter()),
+        fileMap(std::less<uint32_t>(), cg.GetMIRModule()->GetMPAllocator().Adapter()) {
+    outStream.open(fileName, std::ios::trunc);
+    MIRModule &mirModule = *cg.GetMIRModule();
+    memPool = mirModule.GetMemPool();
+    asmInfo = memPool->New<AsmInfo>(*memPool);
+  }
+
+  ~Emitter() = default;
+
+ private:
+  AsmLabel GetTypeAsmInfoName(PrimType primType) const;
+  void EmitDWRef(const std::string &name);
+  void InitRangeIdx2PerfixStr();
+  void EmitAddressString(const std::string &address);
+  void EmitAliasAndRef(const MIRSymbol &sym); /* handle function symbol which has alias and weak ref */
+
+  CG *cg;
+  MOperator currentMop = UINT_MAX;
+  MapleUnorderedMap<int, std::string> rangeIdx2PrefixStr;
+  const AsmInfo *asmInfo = nullptr;
+  std::ofstream outStream;
+  MemPool *memPool = nullptr;
+  uint32 arraySize;
+  bool isFlexibleArray;
+  MapleSet<UStrIdx> stringPtr;
+  MapleVector<UStrIdx> localStrPtr;
+#if 1 /* REQUIRE TO SEPERATE TARGAARCH64 TARGARM32 */
+/* Following code is under TARGAARCH64 condition */
+  uint64 javaInsnCount = 0;
+  uint64 funcInsnCount = 0;
+  MapleSet<std::string> hugeSoTargets;
+  uint32 hugeSoSeqence = 2;
+#endif
+  MapleMap<DBGDie*, LabelIdx> labdie2labidxTable;
+  MapleMap<uint32_t, std::string> fileMap;
+};
+
+class OpndEmitVisitor : public OperandVisitorBase,
+                        public OperandVisitors<RegOperand,
+                                               ImmOperand,
+                                               MemOperand,
+                                               OfstOperand,
+                                               ListOperand,
+                                               LabelOperand,
+                                               FuncNameOperand,
+                                               StImmOperand,
+                                               CondOperand,
+                                               BitShiftOperand,
+                                               ExtendShiftOperand,
+                                               CommentOperand> {
+ public:
+  explicit OpndEmitVisitor(Emitter &asmEmitter): emitter(asmEmitter) {}
+  virtual ~OpndEmitVisitor() = default;
+ protected:
+  Emitter &emitter;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_EMIT_H */
diff --git a/src/mapleall/maple_be/include/cg/framewhitelist.def b/src/mapleall/maple_be/include/cg/framewhitelist.def
new file mode 100644
index 0000000000000000000000000000000000000000..59b30fc3b36a9c5db47ae22f21ead7d381560f45
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/framewhitelist.def
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+"Ldalvik_2Fsystem_2FVMStack_3B_7CgetStackClass1_7C_28_29Ljava_2Flang_2FClass_3B",
+"Ldalvik_2Fsystem_2FVMStack_3B_7CgetStackClass2_7C_28_29Ljava_2Flang_2FClass_3B",
+"Ljava_2Flang_2FClass_3B_7CnewInstance_7C_28_29Ljava_2Flang_2FObject_3B",
+"Ljava_2Flang_2Freflect_2FConstructor_3B_7CnewInstance_7C_28ALjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+"Ljava_2Flang_2Freflect_2FField_3B_7CgetShort_7C_28Ljava_2Flang_2FObject_3B_29S",
+"Ljava_2Flang_2Freflect_2FField_3B_7CgetInt_7C_28Ljava_2Flang_2FObject_3B_29I",
+"Ljava_2Flang_2Freflect_2FField_3B_7CgetFloat_7C_28Ljava_2Flang_2FObject_3B_29F",
+"Ljava_2Flang_2Freflect_2FField_3B_7CgetDouble_7C_28Ljava_2Flang_2FObject_3B_29D",
+"Ljava_2Flang_2Freflect_2FField_3B_7CgetChar_7C_28Ljava_2Flang_2FObject_3B_29C",
+"Ljava_2Flang_2Freflect_2FField_3B_7CgetByte_7C_28Ljava_2Flang_2FObject_3B_29B",
+"Ljava_2Flang_2Freflect_2FField_3B_7CgetBoolean_7C_28Ljava_2Flang_2FObject_3B_29Z",
+"Ljava_2Flang_2Freflect_2FField_3B_7CgetLong_7C_28Ljava_2Flang_2FObject_3B_29J",
+"Ljava_2Flang_2Freflect_2FField_3B_7Cget_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+"Ljava_2Flang_2Freflect_2FField_3B_7CsetBoolean_7C_28Ljava_2Flang_2FObject_3BZ_29V",
+"Ljava_2Flang_2Freflect_2FField_3B_7Cset_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29V",
+"Ljava_2Flang_2Freflect_2FField_3B_7CsetShort_7C_28Ljava_2Flang_2FObject_3BS_29V",
+"Ljava_2Flang_2Freflect_2FField_3B_7CsetLong_7C_28Ljava_2Flang_2FObject_3BJ_29V",
+"Ljava_2Flang_2Freflect_2FField_3B_7CsetInt_7C_28Ljava_2Flang_2FObject_3BI_29V",
+"Ljava_2Flang_2Freflect_2FField_3B_7CsetFloat_7C_28Ljava_2Flang_2FObject_3BF_29V",
+"Ljava_2Flang_2Freflect_2FField_3B_7CsetDouble_7C_28Ljava_2Flang_2FObject_3BD_29V",
+"Ljava_2Flang_2Freflect_2FField_3B_7CsetChar_7C_28Ljava_2Flang_2FObject_3BC_29V",
+"Ljava_2Flang_2Freflect_2FField_3B_7CsetByte_7C_28Ljava_2Flang_2FObject_3BB_29V",
+"LThrowableNativeUncover_3B_7Cmain_7C_28ALjava_2Flang_2FString_3B_29V",
+"Llibcore_2Fjava_2Flang_2Freflect_2FMethodTest_24InterfaceWithDefault_3B_7CdefaultMethod_7C_28_29Ljava_2Flang_2FString_3B",
+"Llibcore_2Fjava_2Flang_2Freflect_2FMethodTest_247_3B_7CdefaultMethod_7C_28_29Ljava_2Flang_2FString_3B",
+"Llibcore_2Fjava_2Flang_2Freflect_2FMethodTest_249_3B_7CdefaultMethod_7C_28_29Ljava_2Flang_2FString_3B",
+"Llibcore_2Fjava_2Flang_2Freflect_2FMethodTest_2410_3B_7CdefaultMethod_7C_28_29Ljava_2Flang_2FString_3B",
+"Llibcore_2Fjava_2Flang_2Freflect_2FMethodTest_24InterfaceWithRedefinedMethods_3B_7CdefaultMethod_7C_28_29Ljava_2Flang_2FString_3B",
+"Llibcore_2Fjava_2Flang_2Freflect_2FMethodTest_2413_3B_7CdefaultMethod_7C_28_29Ljava_2Flang_2FString_3B",
+"Llibcore_2Fjava_2Flang_2Freflect_2FMethodTest_241ImplementationSuperUser_3B_7CdefaultMethod_7C_28_29Ljava_2Flang_2FString_3B",
+"Llibcore_2Fjava_2Flang_2Freflect_2FMethodTest_24InterfaceWithStatic_3B_7CstaticMethod_7C_28_29Ljava_2Flang_2FString_3B",
+"Ljava_2Flang_2Freflect_2FMethod_3B_7Cinvoke_7C_28Ljava_2Flang_2FObject_3BALjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+"Llibcore_2Fjava_2Flang_2Freflect_2FMethodTest_24OtherInterfaceWithDefault_3B_7CdefaultMethod_7C_28_29Ljava_2Flang_2FString_3B",
+"LStackoverflow_3B_7CstackOverflow_7C_28_29V",
+"Llibcore_2Fsun_2Fmisc_2FUnsafeTest_241_3B_7Crun_7C_28_29V",
+"__sigsetjmp",
+"_setjmp"
diff --git a/src/mapleall/maple_be/include/cg/global.h b/src/mapleall/maple_be/include/cg/global.h
new file mode 100644
index 0000000000000000000000000000000000000000..80ad3f08de55de6be98331b10f65024ac4e5b5f1
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/global.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_GLOBAL_H
+#define MAPLEBE_INCLUDE_CG_GLOBAL_H
+
+#include "cg_phase.h"
+#include "maple_phase.h"
+
+namespace maplebe {
+class GlobalOpt {
+ public:
+  explicit GlobalOpt(CGFunc &func) : cgFunc(func) {}
+  virtual ~GlobalOpt() = default;
+  virtual void Run() {}
+  std::string PhaseName() const {
+    return "globalopt";
+  }
+
+ protected:
+  /* if the number of bbs is more than 500 or the number of insns is more than 9000, don't optimize. */
+  static constexpr uint32 kMaxBBNum = 500;
+  static constexpr uint32 kMaxInsnNum = 9000;
+  CGFunc &cgFunc;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgGlobalOpt, maplebe::CGFunc)
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_GLOBAL_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/global_schedule.h b/src/mapleall/maple_be/include/cg/global_schedule.h
new file mode 100644
index 0000000000000000000000000000000000000000..29a45c5f7ee5e721ae4ea1fe39613dc2e8e7c85c
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/global_schedule.h
@@ -0,0 +1,44 @@
+/*
+* Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+#ifndef MAPLEBE_INCLUDE_CG_GLOBAL_SCHEDULE_H
+#define MAPLEBE_INCLUDE_CG_GLOBAL_SCHEDULE_H
+
+#include "cgfunc.h"
+#include "control_dep_analysis.h"
+#include "data_dep_analysis.h"
+
+namespace maplebe {
+class GlobalSchedule {
+ public:
+  GlobalSchedule(MemPool &mp, CGFunc &f, ControlDepAnalysis &cdAna, InterDataDepAnalysis &interDDA)
+      : gsMempool(mp), gsAlloc(&mp), cgFunc(f), cda(cdAna), idda(interDDA),
+        dataNodes(gsAlloc.Adapter()) {}
+  virtual ~GlobalSchedule() = default;
+
+  void Run();
+
+ protected:
+  MemPool &gsMempool;
+  MapleAllocator gsAlloc;
+  CGFunc &cgFunc;
+  ControlDepAnalysis &cda;
+  InterDataDepAnalysis &idda;
+  MapleVector<DepNode*> dataNodes;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgGlobalSchedule, maplebe::CGFunc)
+} /* namespace maplebe */
+
+#endif  // MAPLEBE_INCLUDE_CG_GLOBAL_SCHEDULE_H
diff --git a/src/mapleall/maple_be/include/cg/ico.h b/src/mapleall/maple_be/include/cg/ico.h
new file mode 100644
index 0000000000000000000000000000000000000000..9155fd3a9c2580e4e7e726d7752acdfc2b4a1860
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/ico.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_ICO_H
+#define MAPLEBE_INCLUDE_CG_ICO_H
+#include "optimize_common.h"
+#include "live.h"
+
+namespace maplebe {
+class IfConversionOptimizer : public Optimizer {
+ public:
+  IfConversionOptimizer(CGFunc &func, MemPool &memPool) : Optimizer(func, memPool) {
+    name = "ICO";
+  }
+
+  ~IfConversionOptimizer() override = default;
+};
+
+/* If-Then-Else pattern */
+class ICOPattern : public OptimizationPattern {
+ public:
+  explicit ICOPattern(CGFunc &func) : OptimizationPattern(func) {
+    dotColor = kIcoIte;
+    patternName = "If-Then-Else";
+  }
+  ~ICOPattern() override = default;
+  static constexpr int kThreshold = 2;
+
+ protected:
+  Insn *FindLastCmpInsn(BB &bb) const;
+  std::vector<LabelOperand*> GetLabelOpnds(Insn &insn) const;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgIco, maplebe::CGFunc)
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_ICO_H */
diff --git a/src/mapleall/maple_be/include/cg/immvalid.def b/src/mapleall/maple_be/include/cg/immvalid.def
new file mode 100644
index 0000000000000000000000000000000000000000..5b38d448c22804f89c0ad8a6c161e5bb18cd8285
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/immvalid.def
@@ -0,0 +1,176 @@
+static std::set<uint64> ValidBitmaskImmSet = {
+#include "valid_bitmask_imm.txt"
+};
+constexpr uint32 kMaxBitTableSize = 5;
+constexpr std::array<uint64, kMaxBitTableSize> kBitmaskImmMultTable = {
+    0x0000000100000001UL, 0x0001000100010001UL, 0x0101010101010101UL, 0x1111111111111111UL, 0x5555555555555555UL,
+};
+
+bool IsBitSizeImmediate(uint64 val, uint32 bitLen, uint32 nLowerZeroBits) {
+    /* mask1 is a 64bits number that is all 1 shifts left size bits */
+    const uint64 mask1 = 0xffffffffffffffffUL << bitLen;
+    /* mask2 is a 64 bits number that nlowerZeroBits are all 1, higher bits aro all 0 */
+    uint64 mask2 = (1UL << static_cast<uint64>(nLowerZeroBits)) - 1UL;
+    return (mask2 & val) == 0UL && (mask1 & ((static_cast<uint64>(val)) >> nLowerZeroBits)) == 0UL;
+};
+
+bool IsBitmaskImmediate(uint64 val, uint32 bitLen) {
+  ASSERT(val != 0, "IsBitmaskImmediate() don's accept 0 or -1");
+  ASSERT(static_cast<int64>(val) != -1, "IsBitmaskImmediate() don's accept 0 or -1");
+  if ((bitLen == k32BitSize) && (static_cast<int32>(val) == -1)) {
+    return false;
+  }
+  uint64 val2 = val;
+  if (bitLen == k32BitSize) {
+    val2 = (val2 << k32BitSize) | (val2 & ((1ULL << k32BitSize) - 1));
+  }
+  bool expectedOutcome = (ValidBitmaskImmSet.find(val2) != ValidBitmaskImmSet.end());
+
+  if ((val & 0x1) != 0) {
+    /*
+     * we want to work with
+     * 0000000000000000000000000000000000000000000001100000000000000000
+     * instead of
+     * 1111111111111111111111111111111111111111111110011111111111111111
+     */
+    val = ~val;
+  }
+
+  if (bitLen == k32BitSize) {
+    val = (val << k32BitSize) | (val & ((1ULL << k32BitSize) - 1));
+  }
+
+  /* get the least significant bit set and add it to 'val' */
+  uint64 tmpVal = val + (val & static_cast<uint64>(UINT64_MAX - val + 1));
+
+  /* now check if tmp is a power of 2 or tmpVal==0. */
+  tmpVal = tmpVal & (tmpVal - 1);
+  if (tmpVal == 0) {
+    if (!expectedOutcome) {
+      LogInfo::MapleLogger() << "0x" << std::hex << std::setw(static_cast<int>(k16ByteSize)) <<
+          std::setfill('0') << static_cast<uint64>(val) << "\n";
+      return false;
+    }
+    ASSERT(expectedOutcome, "incorrect implementation: not valid value but returning true");
+    /* power of two or zero ; return true */
+    return true;
+  }
+
+  int32 p0 = __builtin_ctzll(val);
+  int32 p1 = __builtin_ctzll(tmpVal);
+  int64 diff = p1 - p0;
+
+  /* check if diff is a power of two; return false if not. */
+  if ((static_cast<uint64>(diff) & (static_cast<uint64>(diff) - 1)) != 0) {
+    ASSERT(!expectedOutcome, "incorrect implementation: valid value but returning false");
+    return false;
+  }
+
+  uint32 logDiff = static_cast<uint32>(__builtin_ctzll(static_cast<uint64>(diff)));
+  uint64 pattern = val & ((1ULL << static_cast<uint64>(diff)) - 1);
+#if DEBUG
+  bool ret = (val == pattern * kBitmaskImmMultTable[kMaxBitTableSize - logDiff]);
+  ASSERT(expectedOutcome == ret, "incorrect implementation: return value does not match expected outcome");
+  return ret;
+#else
+  return val == pattern * kBitmaskImmMultTable[kMaxBitTableSize - logDiff];
+#endif
+}
+
+bool Imm12BitValid(int64 value) {
+  bool result = IsBitSizeImmediate(static_cast<uint64>(value), kMaxImmVal12Bits, 0);
+  // for target linux-aarch64-gnu
+  result = result || IsBitSizeImmediate(static_cast<uint64>(value), kMaxImmVal12Bits, kMaxImmVal12Bits);
+  return result;
+}
+
+bool Imm12BitMaskValid(int64 value) {
+  if (value == 0 || static_cast<int64>(value) == -1) {
+    return false;
+  }
+  return IsBitmaskImmediate(static_cast<uint64>(value), k32BitSize);
+}
+
+bool Imm13BitValid(int64 value) {
+  bool result = IsBitSizeImmediate(static_cast<uint64>(value), kMaxImmVal13Bits, 0);
+  // for target linux-aarch64-gnu
+  result = result || IsBitSizeImmediate(static_cast<uint64>(value), kMaxImmVal13Bits, kMaxImmVal13Bits);
+  return result;
+}
+
+bool Imm13BitMaskValid(int64 value) {
+  if (value == 0 || static_cast<int64>(value) == -1) {
+    return false;
+  }
+  return IsBitmaskImmediate(static_cast<uint64>(value), k64BitSize);
+}
+
+bool Imm16BitValid(int64 value) {
+  bool result = IsBitSizeImmediate(static_cast<uint64>(value), kMaxImmVal16Bits, 0);
+   /*
+    * for target linux-aarch64-gnu
+    * aarch64 assembly takes up to 24-bits immediate, generating
+    * either cmp or cmp with shift 12 encoding
+    */
+  result = result || IsBitSizeImmediate(static_cast<uint64>(value), kMaxImmVal12Bits, kMaxImmVal12Bits);
+  return result;
+}
+
+/*
+ * 8bit         : 0
+ * halfword     : 1
+ * 32bit - word : 2
+ * 64bit - word : 3
+ * 128bit- word : 4
+ */
+bool StrLdrSignedOfstValid(int64 value, uint wordSize) {
+  if (value <= k256BitSize && value >= kNegative256BitSize) {
+    return true;
+  } else if ((value > k256BitSize) && (value <= kMaxPimm[wordSize])) {
+    uint64 mask = (1U << wordSize) - 1U;
+    return (static_cast<uint64>(value) & mask) > 0 ? false : true;
+  }
+  return false;
+}
+
+
+bool StrLdr8ImmValid(int64 value) {
+  return StrLdrSignedOfstValid(value, 0);
+}
+
+bool StrLdr16ImmValid(int64 value) {
+  return StrLdrSignedOfstValid(value, k1ByteSize);
+}
+
+bool StrLdr32ImmValid(int64 value) {
+  return StrLdrSignedOfstValid(value, k2ByteSize);
+}
+
+bool StrLdr32PairImmValid(int64 value) {
+  if ((value <= kMaxSimm32Pair)  && (value >= kMinSimm32)) {
+    return (static_cast<uint64>(value) & 3) > 0 ? false : true;
+  }
+  return false;
+}
+
+bool StrLdr64ImmValid(int64 value) {
+ return StrLdrSignedOfstValid(value, k3ByteSize);
+}
+
+bool StrLdr64PairImmValid(int64 value) {
+  if (value <= kMaxSimm64Pair && (value >= kMinSimm64)) {
+    return (static_cast<uint64>(value) & 7) > 0 ? false : true;
+  }
+  return false;
+}
+
+bool StrLdr128ImmValid(int64 value) {
+  return StrLdrSignedOfstValid(value, k4ByteSize);
+}
+
+bool StrLdr128PairImmValid(int64 value) {
+  if (value < k1024BitSize && (value >= kNegative1024BitSize)) {
+    return (static_cast<uint64>(value) & 0xf) > 0 ? false : true;
+  }
+  return false;
+}
diff --git a/src/mapleall/maple_be/include/cg/insn.h b/src/mapleall/maple_be/include/cg/insn.h
new file mode 100644
index 0000000000000000000000000000000000000000..806446a713676be8e8be10149c0b0ff91c3d214a
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/insn.h
@@ -0,0 +1,678 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_INSN_H
+#define MAPLEBE_INCLUDE_CG_INSN_H
+/* C++ headers */
+#include <cstddef>  /* for nullptr */
+#include <string>
+#include <vector>
+#include <list>
+#include "operand.h"
+#include "mpl_logging.h"
+#include "isa.h"
+
+/* Maple IR header */
+#include "types_def.h"  /* for uint32 */
+#include "common_utils.h"
+
+namespace maplebe {
+/* forward declaration */
+class BB;
+class CG;
+class Emitter;
+class DepNode;
+class Insn {
+ public:
+  enum RetType : uint8 {
+    kRegNull,   /* no return type */
+    kRegFloat,  /* return register is V0 */
+    kRegInt     /* return register is R0 */
+  };
+  /* MCC_DecRefResetPair clear 2 stack position, MCC_ClearLocalStackRef clear 1 stack position */
+  static constexpr uint8 kMaxStackOffsetSize = 2;
+
+  Insn(MemPool &memPool, MOperator opc)
+      : mOp(opc),
+        localAlloc(&memPool),
+        opnds(localAlloc.Adapter()),
+        registerBinding(localAlloc.Adapter()),
+        comment(&memPool) {}
+  Insn(MemPool &memPool, MOperator opc, Operand &opnd0) : Insn(memPool, opc) { opnds.emplace_back(&opnd0); }
+  Insn(MemPool &memPool, MOperator opc, Operand &opnd0, Operand &opnd1) : Insn(memPool, opc) {
+    opnds.emplace_back(&opnd0);
+    opnds.emplace_back(&opnd1);
+  }
+  Insn(MemPool &memPool, MOperator opc, Operand &opnd0, Operand &opnd1, Operand &opnd2) : Insn(memPool, opc) {
+    opnds.emplace_back(&opnd0);
+    opnds.emplace_back(&opnd1);
+    opnds.emplace_back(&opnd2);
+  }
+  Insn(MemPool &memPool, MOperator opc, Operand &opnd0, Operand &opnd1, Operand &opnd2, Operand &opnd3)
+      : Insn(memPool, opc) {
+    opnds.emplace_back(&opnd0);
+    opnds.emplace_back(&opnd1);
+    opnds.emplace_back(&opnd2);
+    opnds.emplace_back(&opnd3);
+  }
+  Insn(MemPool &memPool, MOperator opc, Operand &opnd0, Operand &opnd1, Operand &opnd2, Operand &opnd3, Operand &opnd4)
+      : Insn(memPool, opc) {
+    opnds.emplace_back(&opnd0);
+    opnds.emplace_back(&opnd1);
+    opnds.emplace_back(&opnd2);
+    opnds.emplace_back(&opnd3);
+    opnds.emplace_back(&opnd4);
+  }
+  virtual ~Insn() = default;
+
+  MOperator GetMachineOpcode() const {
+    return mOp;
+  }
+
+  void SetMOP(const InsnDesc &idesc);
+
+  void AddOperand(Operand &opnd) {
+    opnds.emplace_back(&opnd);
+  }
+
+  Insn &AddOpndChain(Operand &opnd) {
+    AddOperand(opnd);
+    return *this;
+  }
+  /* use carefully which might cause insn to illegal */
+  void CommuteOperands(uint32 dIndex, uint32 sIndex);
+  void CleanAllOperand() {
+    opnds.clear();
+  }
+
+  void PopBackOperand() {
+    opnds.pop_back();
+  }
+
+  Operand &GetOperand(uint32 index) const {
+    ASSERT(index < opnds.size(), "index out of range");
+    return *opnds[index];
+  }
+
+  void ResizeOpnds(uint32 newSize) {
+    opnds.resize(static_cast<std::size_t>(newSize));
+  }
+
+  uint32 GetOperandSize() const {
+    return static_cast<uint32>(opnds.size());
+  }
+
+  void SetOperand(uint32 index, Operand &opnd) {
+    ASSERT(index <= opnds.size(), "index out of range");
+    opnds[index] = &opnd;
+  }
+
+  void SetRetSize(uint32 size) {
+    ASSERT(IsCall(), "Insn should be a call.");
+    retSize = size;
+  }
+
+  uint32 GetRetSize() const {
+    ASSERT(IsCall(), "Insn should be a call.");
+    return retSize;
+  }
+
+  virtual bool IsMachineInstruction() const;
+
+  bool OpndIsDef(uint32 id) const;
+
+  bool OpndIsUse(uint32 id) const;
+
+  virtual bool IsPCLoad() const {
+    return false;
+  }
+
+  Operand *GetMemOpnd() const;
+
+  void SetMemOpnd(MemOperand *memOpnd);
+
+  bool IsCall() const;
+  bool IsTailCall() const;
+  bool IsAsmInsn() const;
+  bool IsClinit() const;
+  bool CanThrow() const;
+  bool MayThrow() const;
+  bool IsBranch() const;
+  bool IsCondBranch() const;
+  bool IsUnCondBranch() const;
+  bool IsMove() const;
+  bool IsBasicOp() const;
+  bool IsUnaryOp() const;
+  bool IsShift() const;
+  bool IsPhi() const;
+  bool IsLoad() const;
+  bool IsStore() const;
+  bool IsConversion() const;
+  bool IsAtomic() const;
+
+  bool IsLoadPair() const;
+  bool IsStorePair() const;
+  bool IsLoadStorePair() const;
+  bool IsLoadLabel() const;
+
+  virtual bool NoAlias() const {
+    return false;
+  }
+
+  bool IsVolatile() const;
+
+  bool IsMemAccessBar() const;
+
+  bool IsMemAccess() const;
+
+  virtual bool HasSideEffects() const {
+    return false;
+  }
+
+  bool HasLoop() const;
+
+  virtual bool IsSpecialIntrinsic() const;
+
+  bool IsComment() const;
+  bool IsImmaterialInsn() const;
+
+  virtual bool IsTargetInsn() const {
+    return true;
+  }
+
+  virtual bool IsCfiInsn() const {
+    return false;
+  }
+
+  virtual bool IsDbgInsn() const {
+    return false;
+  }
+
+  bool IsDMBInsn() const;
+
+  bool IsVectorOp() const;
+
+  virtual Operand *GetCallTargetOperand() const;
+
+  uint32 GetAtomicNum() const;
+  /*
+   * returns a ListOperand
+   * Note that we don't really need this for Emit
+   * Rather, we need it for register allocation, to
+   * correctly state the live ranges for operands
+   * use for passing call arguments
+   */
+  virtual ListOperand *GetCallArgumentOperand();
+  bool IsAtomicStore() const {
+    return IsStore() && IsAtomic();
+  }
+
+  void SetCondDef() {
+    flags |= kOpCondDef;
+  }
+
+  bool IsCondDef() const {
+    return flags & kOpCondDef;
+  }
+
+  bool AccessMem() const {
+    return IsLoad() || IsStore();
+  }
+
+  bool IsFrameDef() const {
+    return isFrameDef;
+  }
+
+  void SetFrameDef(bool b) {
+    isFrameDef = b;
+  }
+
+  bool IsStackDef() const {
+    return isStackDef;
+  }
+
+  void SetStackDef(bool flag) {
+    isStackDef = flag;
+  }
+
+  bool IsAsmDefCondCode() const {
+    return asmDefCondCode;
+  }
+
+  void SetAsmDefCondCode() {
+    asmDefCondCode = true;
+  }
+
+  bool IsAsmModMem() const {
+    return asmModMem;
+  }
+
+  void SetAsmModMem() {
+    asmModMem = true;
+  }
+
+  virtual uint32 GetUnitType() {
+    return 0;
+  }
+
+  virtual void Dump() const;
+
+#if DEBUG
+  virtual void Check() const;
+#endif
+
+  void SetComment(const std::string &str) {
+    comment = str;
+  }
+
+  void SetComment(const MapleString &str) {
+    comment = str;
+  }
+
+  const MapleString &GetComment() const {
+    return comment;
+  }
+
+  void AppendComment(const std::string &str) {
+    comment += str;
+  }
+
+  void MarkAsSaveRetValToLocal() {
+    flags |= kOpDassignToSaveRetValToLocal;
+  }
+
+  bool IsSaveRetValToLocal() const {
+    return ((flags & kOpDassignToSaveRetValToLocal) != 0);
+  }
+
+  void MarkAsAccessRefField(bool cond) {
+    if (cond) {
+      flags |= kOpAccessRefField;
+    }
+  }
+
+  bool IsAccessRefField() const {
+    return ((flags & kOpAccessRefField) != 0);
+  }
+
+  bool IsIntRegisterMov() const {
+    if (md == nullptr || !md->IsPhysicalInsn() || !md->IsMove() ||
+        md->opndMD.size() != kOperandNumBinary) {
+      return false;
+    }
+    auto firstMD = md->GetOpndDes(kFirstOpnd);
+    auto secondMD = md->GetOpndDes(kSecondOpnd);
+    if (!firstMD->IsRegister() || !secondMD->IsRegister() ||
+        !firstMD->IsIntOperand() || !secondMD->IsIntOperand() ||
+        firstMD->GetSize() != secondMD->GetSize()) {
+      return false;
+    }
+    return true;
+  }
+
+  Insn *GetPreviousMachineInsn() const {
+    for (Insn *returnInsn = prev; returnInsn != nullptr; returnInsn = returnInsn->prev) {
+      ASSERT(returnInsn->bb == bb, "insn and it's prev insn must have same bb");
+      if (returnInsn->IsMachineInstruction()) {
+        return returnInsn;
+      }
+    }
+    return nullptr;
+  }
+
+  Insn *GetNextMachineInsn() const {
+    for (Insn *returnInsn = next; returnInsn != nullptr; returnInsn = returnInsn->next) {
+      CHECK_FATAL(returnInsn->bb == bb, "insn and it's next insn must have same bb");
+      if (returnInsn->IsMachineInstruction()) {
+        return returnInsn;
+      }
+    }
+    return nullptr;
+  }
+
+  uint32 GetLatencyType() const;
+
+  void SetPrev(Insn *prevInsn) {
+    this->prev = prevInsn;
+  }
+
+  Insn *GetPrev() {
+    return prev;
+  }
+
+  const Insn *GetPrev() const {
+    return prev;
+  }
+
+  void SetNext(Insn *nextInsn) {
+    this->next = nextInsn;
+  }
+
+  Insn *GetNext() const {
+    return next;
+  }
+
+  void SetBB(BB *newBB) {
+    this->bb = newBB;
+  }
+
+  BB *GetBB() {
+    return bb;
+  }
+
+  const BB *GetBB() const {
+    return bb;
+  }
+
+  void SetId(uint32 idVal) {
+    this->id = idVal;
+  }
+
+  uint32 GetId() const {
+    return id;
+  }
+
+  void SetAddress(uint32 addr) {
+    address = addr;
+  }
+
+  uint32 GetAddress() const {
+    return address;
+  }
+
+  void SetNopNum(uint32 num) {
+    nopNum = num;
+  }
+
+  uint32 GetNopNum() const {
+    return nopNum;
+  }
+
+  void SetNeedSplit(bool flag) {
+    needSplit = flag;
+  }
+
+  bool IsNeedSplit() const {
+    return needSplit;
+  }
+
+  void SetIsThrow(bool isThrowVal) {
+    this->isThrow = isThrowVal;
+  }
+
+  bool GetIsThrow() const {
+    return isThrow;
+  }
+
+  void SetDoNotRemove(bool doNotRemoveVal) {
+    this->doNotRemove = doNotRemoveVal;
+  }
+
+  bool GetDoNotRemove() const {
+    return doNotRemove;
+  }
+
+  void SetIsSpill() {
+    this->isSpill = true;
+  }
+
+  bool GetIsSpill() const {
+    return isSpill;
+  }
+
+  void SetIsReload() {
+    this->isReload = true;
+  }
+
+  bool GetIsReload() const {
+    return isReload;
+  }
+
+  bool IsSpillInsn() const {
+    return (isSpill || isReload);
+  }
+
+  void SetIsCallReturnUnsigned(bool unSigned) {
+    ASSERT(IsCall(), "Insn should be a call.");
+    this->isCallReturnUnsigned = unSigned;
+  }
+
+  bool GetIsCallReturnUnsigned() const {
+    ASSERT(IsCall(), "Insn should be a call.");
+    return isCallReturnUnsigned;
+  }
+
+  bool GetIsCallReturnSigned() const {
+    ASSERT(IsCall(), "Insn should be a call.");
+    return !isCallReturnUnsigned;
+  }
+
+  void SetRetType(RetType retTy) {
+    this->retType = retTy;
+  }
+
+  RetType GetRetType() const {
+    return retType;
+  }
+
+  void SetClearStackOffset(short index, int64 offset) {
+    CHECK_FATAL(index < kMaxStackOffsetSize, "out of clearStackOffset's range");
+    clearStackOffset[index] = offset;
+  }
+
+  int64 GetClearStackOffset(short index) const {
+    CHECK_FATAL(index < kMaxStackOffsetSize, "out of clearStackOffset's range");
+    return clearStackOffset[index];
+  }
+
+  /* if function name is MCC_ClearLocalStackRef or MCC_DecRefResetPair, will clear designate stack slot */
+  bool IsClearDesignateStackCall() const {
+    return clearStackOffset[0] != -1 || clearStackOffset[1] != -1;
+  }
+
+  void SetDepNode(DepNode &depNodeVal) {
+    this->depNode = &depNodeVal;
+  }
+
+  DepNode *GetDepNode() {
+    return depNode;
+  }
+
+  const DepNode *GetDepNode() const {
+    return depNode;
+  }
+
+  void SetIsPhiMovInsn(bool val) {
+    isPhiMovInsn = val;
+  }
+
+  bool IsPhiMovInsn() const {
+    return isPhiMovInsn;
+  }
+
+  Insn *Clone(MemPool &memPool) const;
+
+  void SetInsnDescrption(const InsnDesc &newMD) {
+    md = &newMD;
+  }
+
+  const InsnDesc *GetDesc() const {
+    return md;
+  }
+
+  void AddRegBinding(uint32 regA, uint32 regB) {
+    (void)registerBinding.emplace(regA, regB);
+  }
+
+  const MapleMap<uint32, uint32>& GetRegBinding() const {
+    return registerBinding;
+  }
+
+  void SetRefSkipIdx(int32 index) {
+    refSkipIdx = index;
+  }
+
+  /* Get Size of memory write/read by insn */
+  uint32 GetMemoryByteSize() const;
+
+  /* return ture if register appears */
+  virtual bool ScanReg(regno_t regNO) const;
+
+  virtual bool IsRegDefined(regno_t regNO) const;
+
+  virtual std::set<uint32> GetDefRegs() const;
+
+  virtual uint32 GetBothDefUseOpnd() const;
+
+  RegOperand *GetSSAImpDefOpnd() {
+    return ssaImplicitDefOpnd;
+  }
+
+  void SetSSAImpDefOpnd(RegOperand *ssaDef) {
+    ssaImplicitDefOpnd = ssaDef;
+  }
+
+  void SetProcessRHS() {
+    processRHS = true;
+  }
+
+  bool HasProcessedRHS() const {
+    return processRHS;
+  }
+
+ protected:
+  MOperator mOp;
+  MapleAllocator localAlloc;
+  MapleVector<Operand*> opnds;
+  RegOperand *ssaImplicitDefOpnd = nullptr;   /* for the opnd is both def and use is ssa */
+  Insn *prev = nullptr;
+  Insn *next = nullptr;
+  BB *bb = nullptr;        /* BB to which this insn belongs */
+  uint32 flags = 0;
+  bool isPhiMovInsn = false;
+
+ private:
+  MapleMap<uint32, uint32> registerBinding; /* used for inline asm only */
+  enum OpKind : uint32 {
+    kOpUnknown = 0,
+    kOpCondDef = 0x1,
+    kOpAccessRefField = (1ULL << 30),  /* load-from/store-into a ref flag-fieldGetMachineOpcode() */
+    kOpDassignToSaveRetValToLocal = (1ULL << 31) /* save return value to local flag */
+  };
+
+  uint32 id = 0;
+  uint32 address = 0;
+  uint32 nopNum = 0;
+  RetType retType = kRegNull;    /* if this insn is call, it represent the return register type R0/V0 */
+  uint32 retSize = 0;  /* Byte size of the return value if insn is a call. */
+  /* record the stack cleared by MCC_ClearLocalStackRef or MCC_DecRefResetPair */
+  int64 clearStackOffset[kMaxStackOffsetSize] = { -1, -1 };
+  DepNode *depNode = nullptr; /* For dependence analysis, pointing to a dependence node. */
+  MapleString comment;
+  bool isThrow = false;
+  bool doNotRemove = false;  /* caller reg cross call */
+  bool isCallReturnUnsigned = false;   /* for call insn only. false: signed, true: unsigned */
+  bool isSpill = false;   /* used as hint for optimization */
+  bool isReload = false;  /* used as hint for optimization */
+  bool isFrameDef = false;
+  bool isStackDef = false;
+  bool asmDefCondCode = false;
+  bool asmModMem = false;
+  bool needSplit = false;
+
+  /* for dynamic language to mark reference counting */
+  int32 refSkipIdx = -1;
+
+  /* for multiple architecture */
+  const InsnDesc *md = nullptr;
+  /*
+   * for redundant compute elimination phase,
+   * indicate whether the version has been processed.
+   */
+  bool processRHS = false;
+};
+
+struct VectorRegSpec {
+  VectorRegSpec() : vecLane(-1), vecLaneMax(0), vecElementSize(0), compositeOpnds(0) {}
+
+  VectorRegSpec(PrimType type, int16 lane = -1, uint16 compositeOpnds = 0) :
+      vecLane(lane),
+      vecLaneMax(GetVecLanes(type)),
+      vecElementSize(GetVecEleSize(type)),
+      compositeOpnds(compositeOpnds) {}
+
+  VectorRegSpec(uint16 laneNum, uint16 eleSize, int16 lane = -1, uint16 compositeOpnds = 0) :
+      vecLane(lane),
+      vecLaneMax(laneNum),
+      vecElementSize(eleSize),
+      compositeOpnds(compositeOpnds) {}
+
+  int16 vecLane;         /* -1 for whole reg, 0 to 15 to specify individual lane */
+  uint16 vecLaneMax;     /* Maximum number of lanes for this vregister */
+  uint16 vecElementSize; /* element size in each Lane */
+  uint16 compositeOpnds; /* Number of enclosed operands within this composite operand */
+};
+
+class VectorInsn : public Insn {
+ public:
+  VectorInsn(MemPool &memPool, MOperator opc)
+      : Insn(memPool, opc),
+        regSpecList(localAlloc.Adapter()) {
+    regSpecList.clear();
+  }
+
+  ~VectorInsn() override = default;
+
+  void ClearRegSpecList() {
+    regSpecList.clear();
+  }
+
+  VectorRegSpec *GetAndRemoveRegSpecFromList();
+
+  size_t GetNumOfRegSpec() const {
+    if (IsVectorOp() && !regSpecList.empty()) {
+      return regSpecList.size();
+    }
+    return 0;
+  }
+
+  MapleVector<VectorRegSpec*> &GetRegSpecList() {
+    return regSpecList;
+  }
+
+  void SetRegSpecList(const MapleVector<VectorRegSpec*> &vec) {
+    regSpecList = vec;
+  }
+
+  VectorInsn &PushRegSpecEntry(VectorRegSpec *v) {
+    (void)regSpecList.emplace(regSpecList.begin(), v);
+    return *this;
+  }
+
+ private:
+  MapleVector<VectorRegSpec*> regSpecList;
+};
+
+struct InsnIdCmp {
+  bool operator()(const Insn *lhs, const Insn *rhs) const {
+    CHECK_FATAL(lhs != nullptr, "lhs is nullptr in InsnIdCmp");
+    CHECK_FATAL(rhs != nullptr, "rhs is nullptr in InsnIdCmp");
+    return lhs->GetId() < rhs->GetId();
+  }
+};
+using InsnSet = std::set<Insn*, InsnIdCmp>;
+using InsnMapleSet = MapleSet<Insn*, InsnIdCmp>;
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_INSN_H */
diff --git a/src/mapleall/maple_be/include/cg/instruction_selection.h b/src/mapleall/maple_be/include/cg/instruction_selection.h
new file mode 100644
index 0000000000000000000000000000000000000000..00568de66be166b2a8b088aeb24758cb805abcf3
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/instruction_selection.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_INSTRUCTION_SELECTION_H
+#define MAPLEBE_INCLUDE_INSTRUCTION_SELECTION_H
+
+#include "maple_phase_manager.h"
+
+namespace maplebe {
+
+class InsnSel {
+ public:
+  explicit InsnSel(CGFunc &tempCGFunc) : cgFunc(&tempCGFunc) {}
+
+  virtual ~InsnSel() = default;
+
+  virtual bool InsnSel() = 0;
+
+ protected:
+  CGFunc *cgFunc;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgIsel, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+
+} /* namespace maplebe */
+
+
+#endif /* MAPLEBE_INCLUDE_INSTRUCTION_SELECTION_H */
diff --git a/src/mapleall/maple_be/include/cg/isa.h b/src/mapleall/maple_be/include/cg/isa.h
new file mode 100644
index 0000000000000000000000000000000000000000..5948612f8194033a3321b1c768d440052b3df923
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/isa.h
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_ISA_H
+#define MAPLEBE_INCLUDE_CG_ISA_H
+
+#include <cstdint>
+#include "types_def.h"
+#include "operand.h"
+
+namespace maplebe {
+enum MopProperty : maple::uint8 {
+  kInsnIsAbstract,
+  kInsnIsMove,
+  kInsnIsLoad,
+  kInsnIsLoadPair,
+  kInsnIsStore,
+  kInsnIsStorePair,
+  kInsnIsLoadAddress,
+  kInsnIsAtomic,
+  kInsnIsCall,
+  kInsnIsTailCall,
+  kInsnIsConversion,
+  kInsnIsCondDef,
+  kInsnHasAcqure,
+  kInsnHasAcqureRCpc,
+  kInsnHasLOAcqure,
+  kInsnHasRelease,
+  kInsnHasLORelease,
+  kInsnCanThrow,
+  kInsnIsDMB,
+  kInsnIsUnCondBr,
+  kInsnIsCondBr,
+  kInsnHasLoop,
+  kInsnIsVectorOp,
+  kInsnIsBinaryOp,
+  kInsnIsPhi,
+  kInsnIsUnaryOp,
+  kInsnIsShift,
+  kInsnInlineAsm,
+  kInsnSpecialIntrisic,
+  kInsnIsNop,
+};
+using regno_t = uint32_t;
+#define ISABSTRACT 1ULL
+#define ISMOVE (1ULL << kInsnIsMove)
+#define ISLOAD (1ULL << kInsnIsLoad)
+#define ISLOADPAIR (1ULL << kInsnIsLoadPair)
+#define ISSTORE (1ULL << kInsnIsStore)
+#define ISSTOREPAIR (1ULL << kInsnIsStorePair)
+#define ISLOADADDR (1ULL << kInsnIsLoadAddress)
+#define ISATOMIC (1ULL << kInsnIsAtomic)
+#define ISCALL (1ULL << kInsnIsCall)
+#define ISTAILCALL (1ULL << kInsnIsTailCall)
+#define ISCONVERSION (1ULL << kInsnIsConversion)
+#define ISCONDDEF (1ULL << kInsnIsCondDef)
+#define HASACQUIRE (1ULL << kInsnHasAcqure)
+#define HASACQUIRERCPC (1ULL << kInsnHasAcqureRCpc)
+#define HASLOACQUIRE (1ULL << kInsnHasLOAcqure)
+#define HASRELEASE (1ULL << kInsnHasRelease)
+#define HASLORELEASE (1ULL << kInsnHasLORelease)
+#define CANTHROW (1ULL << kInsnCanThrow)
+#define ISDMB (1ULL << kInsnIsDMB)
+#define ISUNCONDBRANCH (1ULL << kInsnIsUnCondBr)
+#define ISCONDBRANCH (1ULL << kInsnIsCondBr)
+#define HASLOOP (1ULL << kInsnHasLoop)
+#define ISVECTOR (1ULL << kInsnIsVectorOp)
+#define ISBASICOP (1ULL << kInsnIsBinaryOp)
+#define ISPHI (1ULL << kInsnIsPhi)
+#define ISUNARYOP (1ULL << kInsnIsUnaryOp)
+#define ISSHIFT (1ULL << kInsnIsShift)
+#define INLINEASM (1ULL << kInsnInlineAsm)
+#define SPINTRINSIC (1ULL << kInsnSpecialIntrisic)
+#define ISNOP (1ULL << kInsnIsNop)
+constexpr maplebe::regno_t kInvalidRegNO = 0;
+
+/*
+ * ARM64 has 32 int registes and 32 FP registers.
+ * AMD64/X86_64 has 16 int registes, and 16 FP registers.
+ * In either case, the corresponding calling conventions use
+ * the smaller number of caller-saved registers.
+ * 64 bit is not large enough?
+ */
+using CsrBitset = uint64_t;
+
+template <typename ParaType>
+class ConstraintFunction {
+ public:
+  using CfPointer = bool (*) (ParaType);
+  bool CheckConstraint(CfPointer ccfunc, ParaType a) const {
+    return (*ccfunc)(a);
+  }
+};
+
+/*
+ * abstract machine instruction
+ * a lower-level maple IR which is aimed to represent general machine instruction for extreme cpus
+ * 1. Support conversion between all types and registers
+ * 2. Support conversion between memory and registers
+ * 3. Support three address basic operations
+ *
+ */
+namespace abstract {
+#define DEFINE_MOP(op, ...) op,
+enum AbstractMOP_t : maple::uint32 {
+#include "abstract_mmir.def"
+  kMopLast
+};
+#undef DEFINE_MOP
+}
+
+struct InsnDesc {
+  MOperator opc;
+  std::vector<const OpndDesc*> opndMD;
+  uint64 properties;
+  uint32 latencyType;
+  const std::string &name;
+  const std::string &format;
+  uint32 atomicNum; /* indicate how many asm instructions it will emit. */
+  std::function<bool(int64)> validFunc = nullptr; /* If insn has immOperand, this function needs to be implemented. */
+
+  bool IsSame(const InsnDesc &left,
+      std::function<bool (const InsnDesc &left, const InsnDesc &right)> cmp) const;
+
+  bool IsCall() const {
+    return (properties & ISCALL) != 0;
+  }
+  bool IsTailCall() const {
+    return properties & ISTAILCALL;
+  }
+  bool IsPhi() const {
+    return (properties & ISPHI) != 0;
+  }
+  bool IsPhysicalInsn() const {
+    return (properties & ISABSTRACT) == 0;
+  }
+  bool IsStore() const {
+    return (properties & ISSTORE) != 0;
+  }
+  bool IsLoad() const {
+    return (properties & ISLOAD) != 0;
+  }
+  bool IsConversion() const {
+    return (properties & ISCONVERSION) != 0;
+  }
+  bool IsLoadPair() const {
+    return (properties & (ISLOADPAIR)) != 0;
+  }
+  bool IsStorePair() const {
+    return (properties & (ISSTOREPAIR)) != 0;
+  }
+  bool IsLoadStorePair() const {
+    return (properties & (ISLOADPAIR | ISSTOREPAIR)) != 0;
+  }
+  bool IsMove() const {
+    return (properties & ISMOVE) != 0;
+  }
+  bool IsDMB() const {
+    return (properties & (ISDMB)) != 0;
+  }
+  bool IsBasicOp() const {
+    return (properties & ISBASICOP) != 0;
+  }
+  bool IsCondBranch() const {
+    return (properties & (ISCONDBRANCH)) != 0;
+  }
+  bool IsUnCondBranch() const {
+    return (properties & (ISUNCONDBRANCH)) != 0;
+  }
+  bool IsLoadAddress() const {
+    return (properties & (ISLOADADDR)) != 0;
+  }
+  bool IsAtomic() const {
+    return (properties & ISATOMIC) != 0;
+  }
+  bool IsCondDef() const {
+    return (properties & ISCONDDEF) != 0;
+  }
+  bool IsVectorOp() const {
+    return (properties & ISVECTOR) != 0;
+  }
+  bool IsVolatile() const {
+    return ((properties & HASRELEASE) != 0) || ((properties & HASACQUIRE) != 0);
+  }
+  bool IsMemAccessBar() const {
+    return (properties & (HASRELEASE | HASACQUIRE | HASACQUIRERCPC | HASLOACQUIRE | HASLORELEASE)) != 0;
+  }
+  bool IsMemAccess() const {
+    return (properties & (ISLOAD | ISSTORE | ISLOADPAIR | ISSTOREPAIR)) != 0;
+  }
+  bool IsBranch() const {
+    return (properties & (ISCONDBRANCH | ISUNCONDBRANCH)) != 0;
+  }
+  bool HasLoop() const {
+    return (properties & HASLOOP) != 0;
+  }
+  bool CanThrow() const {
+    return (properties & CANTHROW) != 0;
+  }
+  bool IsInlineAsm() const {
+    return properties & INLINEASM;
+  }
+  bool IsSpecialIntrinsic() const {
+    return properties & SPINTRINSIC;
+  }
+  MOperator GetOpc() const {
+    return opc;
+  }
+  const OpndDesc *GetOpndDes(size_t index) const {
+    return opndMD[index];
+  }
+  uint32 GetOperandSize() const {
+    if (properties & (ISLOAD | ISSTORE)) {
+      /* use memory operand */
+      return GetOpndDes(1)->GetSize();
+    }
+    /* use dest operand */
+    return GetOpndDes(0)->GetSize();
+  }
+  bool Is64Bit() const {
+    return GetOperandSize() == k64BitSize;
+  }
+  bool IsValidImmOpnd(int64 val) const {
+    if (!validFunc) {
+      return true;
+    }
+    return validFunc(val);
+  }
+  uint32 GetLatencyType() const {
+    return latencyType;
+  }
+  bool IsUnaryOp() const {
+    return (properties & ISUNARYOP) != 0;
+  }
+  bool IsShift() const {
+    return (properties & ISSHIFT) != 0;
+  }
+  const std::string &GetName() const {
+    return name;
+  }
+  const std::string &GetFormat() const {
+    return format;
+  }
+  uint32 GetAtomicNum() const {
+    return atomicNum;
+  }
+  static const InsnDesc &GetAbstractId(MOperator mOperator) {
+    ASSERT(mOperator < abstract::kMopLast, "op must be lower than kMopLast");
+    return abstractId[mOperator];
+  }
+  static const InsnDesc abstractId[abstract::kMopLast];
+};
+
+enum RegAddress : uint32 {
+  kRegHigh = 0x4,
+  kRegLow = 0x8
+};
+constexpr uint32 kMemLow12 = 0x10;
+constexpr uint32 kLiteralLow12 = kMemLow12;
+constexpr uint32 kPreInc = 0x20;
+constexpr uint32 kPostInc = 0x40;
+constexpr uint32 kLoadLiteral = 0x80;
+
+enum BitIndex : maple::uint8 {
+  k8BitIndex = 0,
+  k16BitIndex,
+  k32BitIndex,
+  k64BitIndex,
+  kBitIndexEnd,
+};
+
+static inline BitIndex GetBitIndex(uint32 bitSize) {
+  switch (bitSize) {
+    case k8BitSize:
+      return k8BitIndex;
+    case k16BitSize:
+      return k16BitIndex;
+    case k32BitSize:
+      return k32BitIndex;
+    case k64BitSize:
+      return k64BitIndex;
+    default:
+      CHECK_FATAL(false, "NIY, Not support size");
+  }
+}
+} /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_ISA_H */
diff --git a/src/mapleall/maple_be/include/cg/isel.h b/src/mapleall/maple_be/include/cg/isel.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe28a9c9bb7d71e8ce7bdba7cc95f35c56fbd178
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/isel.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_ISEL_H
+#define MAPLEBE_INCLUDE_CG_ISEL_H
+
+#include "cgfunc.h"
+
+namespace maplebe {
+struct MirTypeInfo {
+  PrimType primType;
+  int32 offset = 0;
+  uint32 size = 0;  /* for aggType */
+};
+/* macro expansion instruction selection */
+class MPISel {
+ public:
+  MPISel(MemPool &mp, CGFunc &f) : isMp(&mp), cgFunc(&f) {}
+
+  virtual ~MPISel() {
+    isMp = nullptr;
+    cgFunc = nullptr;
+  }
+
+  void DoMPIS();
+
+  CGFunc *GetCurFunc() const {
+    return cgFunc;
+  }
+
+  Operand *HandleExpr(const BaseNode &parent, BaseNode &expr);
+
+  void SelectDassign(const DassignNode &stmt, Operand &opndRhs);
+  void SelectDassignoff(DassignoffNode &stmt, Operand &opnd0);
+  void SelectIassign(const IassignNode &stmt, Operand &opndAddr, Operand &opndRhs);
+  void SelectIassignoff(const IassignoffNode &stmt);
+  RegOperand *SelectRegread(RegreadNode &expr);
+  void SelectRegassign(RegassignNode &stmt, Operand &opnd0);
+  Operand* SelectDread(const BaseNode &parent, const AddrofNode &expr);
+  Operand* SelectBand(const BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  Operand* SelectAdd(const BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  Operand* SelectSub(const BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  Operand* SelectNeg(const UnaryNode &node, Operand &opnd0, const BaseNode &parent);
+  Operand* SelectCvt(const BaseNode &parent, const TypeCvtNode &node, Operand &opnd0);
+  Operand* SelectExtractbits(const BaseNode &parent, const ExtractbitsNode &node, Operand &opnd0);
+  Operand *SelectDepositBits(const DepositbitsNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  Operand *SelectAbs(UnaryNode &node, Operand &opnd0);
+  Operand *SelectAlloca(UnaryNode &node, Operand &opnd0);
+  Operand *SelectCGArrayElemAdd(BinaryNode &node, const BaseNode &parent);
+  ImmOperand *SelectIntConst(MIRIntConst &intConst, PrimType primType) const;
+  Operand *SelectLiteral(MIRDoubleConst &c, MIRFunction &func, uint32 labelIdx) const;
+  void SelectCallCommon(StmtNode &stmt, const MPISel &iSel);
+  void SelectAdd(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType);
+  void SelectSub(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType);
+  Operand *SelectShift(const BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  void SelectShift(Operand &resOpnd, Operand &opnd0, Operand &opnd1, Opcode shiftDirect,
+                   PrimType opnd0Type, PrimType opnd1Type);
+  void SelectBand(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType);
+  virtual void SelectReturn(NaryStmtNode &retNode, Operand &opnd) = 0;
+  virtual void SelectReturn() = 0;
+  virtual void SelectIntAggCopyReturn(MemOperand &symbolMem, uint64 aggSize) = 0;
+  virtual void SelectAggIassign(IassignNode &stmt, Operand &AddrOpnd, Operand &opndRhs) = 0;
+  virtual void SelectAggCopy(MemOperand &lhs, MemOperand &rhs, uint32 copySize) = 0;
+  virtual void SelectGoto(GotoNode &stmt) = 0;
+  virtual void SelectRangeGoto(RangeGotoNode &rangeGotoNode, Operand &srcOpnd) = 0;
+  virtual void SelectIgoto(Operand &opnd0) = 0;
+  virtual void SelectCall(CallNode &callNode) = 0;
+  virtual void SelectIcall(IcallNode &icallNode, Operand &opnd0) = 0;
+  virtual void SelectIntrinCall(IntrinsiccallNode &intrinsiccallNode) = 0;
+  virtual Operand *SelectDoubleConst(MIRDoubleConst &intConst, PrimType primType) const = 0;
+  virtual Operand *SelectAddrof(AddrofNode &expr, const BaseNode &parent) = 0;
+  virtual Operand *SelectAddrofFunc(AddroffuncNode &expr, const BaseNode &parent) = 0;
+  virtual Operand *SelectAddrofLabel(AddroflabelNode &expr, const BaseNode &parent) = 0;
+  virtual Operand &ProcessReturnReg(PrimType primType, int32 sReg) = 0 ;
+  virtual void SelectCondGoto(CondGotoNode &stmt, BaseNode &condNode, Operand &opnd0) = 0;
+  Operand *SelectBior(const BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  Operand *SelectBxor(const BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  Operand *SelectIread(const BaseNode &parent, const IreadNode &expr, int extraOffset = 0);
+  Operand *SelectIreadoff(const BaseNode &parent, const IreadoffNode &ireadoff);
+  virtual Operand *SelectMpy(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectDiv(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectCmpOp(CompareNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) = 0;
+  virtual Operand *SelectSelect(TernaryNode &expr, Operand &cond, Operand &trueOpnd, Operand &falseOpnd,
+                                const BaseNode &parent) = 0;
+  virtual Operand *SelectStrLiteral(ConststrNode &constStr) = 0;
+  virtual Operand *SelectBswap(IntrinsicopNode &node, Operand &opnd0, const BaseNode &parent) = 0;
+  virtual void SelectAsm(AsmNode &node) = 0;
+  virtual void SelectAggDassign(MirTypeInfo &lhsInfo, MemOperand &symbolMem, Operand &opndRhs) = 0;
+  Operand *SelectBnot(const UnaryNode &node, Operand &opnd0, const BaseNode &parent);
+  Operand *SelectMin(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  Operand *SelectMax(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent);
+  Operand *SelectRetype(TypeCvtNode &node, Operand &opnd0);
+ protected:
+  MemPool *isMp;
+  CGFunc *cgFunc;
+  void SelectCopy(Operand &dest, Operand &src, PrimType toType, PrimType fromType);
+  void SelectCopy(Operand &dest, Operand &src, PrimType toType);
+  RegOperand &SelectCopy2Reg(Operand &src, PrimType toType, PrimType fromType);
+  RegOperand &SelectCopy2Reg(Operand &src, PrimType toType);
+  void SelectIntCvt(RegOperand &resOpnd, Operand &opnd0, PrimType toType, PrimType fromType);
+  void SelectCvtInt2Float(RegOperand &resOpnd, Operand &origOpnd0, PrimType toType, PrimType fromType);
+  void SelectFloatCvt(RegOperand &resOpnd, Operand &opnd0, PrimType toType, PrimType fromType);
+  void SelectCvtFloat2Int(RegOperand &resOpnd, Operand &origOpnd0, PrimType toType, PrimType fromType);
+  PrimType GetIntegerPrimTypeFromSize(bool isSigned, uint32 bitSize) const;
+  std::pair<FieldID, MIRType*> GetFieldIdAndMirTypeFromMirNode(const BaseNode &node);
+  MirTypeInfo GetMirTypeInfoFormFieldIdAndMirType(FieldID fieldId, MIRType *mirType);
+  MirTypeInfo GetMirTypeInfoFromMirNode(const BaseNode &node);
+  MemOperand *GetOrCreateMemOpndFromIreadNode(const IreadNode &expr, PrimType primType, int offset);
+ private:
+  StmtNode *HandleFuncEntry();
+  void HandleFuncExit() const;
+  void SelectDassign(StIdx stIdx, FieldID fieldId, PrimType rhsPType, Operand &opndRhs);
+  void SelectDassignStruct(MIRSymbol &symbol, MemOperand &symbolMem, Operand &opndRhs);
+  virtual MemOperand &GetOrCreateMemOpndFromSymbol(const MIRSymbol &symbol, FieldID fieldId = 0) const = 0;
+  virtual MemOperand &GetOrCreateMemOpndFromSymbol(const MIRSymbol &symbol, uint32 opndSize, int64 offset) const = 0;
+  virtual Operand &GetTargetRetOperand(PrimType primType, int32 sReg) = 0;
+  void SelectBasicOp(Operand &resOpnd, Operand &opnd0, Operand &opnd1, MOperator mOp, PrimType primType);
+  /*
+   * Support conversion between all types and registers
+   * only Support conversion between registers and memory
+   * alltypes -> reg -> mem
+   */
+  void SelectCopyInsn(Operand &dest, Operand &src, PrimType type);
+  void SelectNeg(Operand &resOpnd, Operand &opnd0, PrimType primType) const;
+  void SelectBnot(Operand &resOpnd, Operand &opnd0, PrimType primType);
+  void SelectBior(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType);
+  void SelectExtractbits(RegOperand &resOpnd, RegOperand &opnd0, uint8 bitOffset, uint8 bitSize, PrimType primType);
+  void SelectBxor(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType);
+  virtual RegOperand &GetTargetBasicPointer(PrimType primType) = 0;
+  virtual RegOperand &GetTargetStackPointer(PrimType primType) = 0;
+  void SelectMin(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType);
+  void SelectMax(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType);
+  virtual void SelectMinOrMax(bool isMin, Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) = 0;
+};
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(InstructionSelector, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}
+#endif  /* MAPLEBE_INCLUDE_CG_ISEL_H */
diff --git a/src/mapleall/maple_be/include/cg/isolate_fastpath.h b/src/mapleall/maple_be/include/cg/isolate_fastpath.h
new file mode 100644
index 0000000000000000000000000000000000000000..9bdb58cae8daed8a2f6f34a6aac6ad61c76aac17
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/isolate_fastpath.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_ISOLATE_FASTPATH_H
+#define MAPLEBE_INCLUDE_CG_ISOLATE_FASTPATH_H
+#include "cgfunc.h"
+
+namespace maplebe {
+class IsolateFastPath {
+ public:
+  explicit IsolateFastPath(CGFunc &func)
+      : cgFunc(func) {}
+
+  virtual ~IsolateFastPath() = default;
+
+  virtual void Run() {}
+
+  std::string PhaseName() const {
+    return "isolate_fastpath";
+  }
+
+ protected:
+  CGFunc &cgFunc;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_ISOLATE_FASTPATH_H */
diff --git a/src/mapleall/maple_be/include/cg/label_creation.h b/src/mapleall/maple_be/include/cg/label_creation.h
new file mode 100644
index 0000000000000000000000000000000000000000..765fb3dc347b52e765b8f2b1ba553fc09adf5aee
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/label_creation.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_LABEL_CREATION_H
+#define MAPLEBE_INCLUDE_CG_LABEL_CREATION_H
+
+#include "cgfunc.h"
+#include "cg_phase.h"
+#include "mir_builder.h"
+
+namespace maplebe {
+class LabelCreation {
+ public:
+  explicit LabelCreation(CGFunc &func) : cgFunc(&func) {}
+
+  ~LabelCreation() = default;
+
+  void Run();
+
+  std::string PhaseName() const {
+    return "createlabel";
+  }
+
+ private:
+  CGFunc *cgFunc;
+  void CreateStartEndLabel() const;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgCreateLabel, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_LABEL_CREATION_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/live.h b/src/mapleall/maple_be/include/cg/live.h
new file mode 100644
index 0000000000000000000000000000000000000000..8286afc657dda5210e5e0b881fba408d1fc78604
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/live.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_LIVE_H
+#define MAPLEBE_INCLUDE_CG_LIVE_H
+
+#include "cg_phase.h"
+#include "insn.h"
+#include "cgbb.h"
+#include "sparse_datainfo.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+class LiveAnalysis : public AnalysisResult {
+ public:
+  LiveAnalysis(CGFunc &func, MemPool &memPool)
+      : AnalysisResult(&memPool), cgFunc(&func), memPool(&memPool), alloc(&memPool), stackMp(func.GetStackMemPool()) {}
+  ~LiveAnalysis() override = default;
+
+  void AnalysisLive();
+  void Dump() const;
+  void DumpInfo(const SparseDataInfo &info) const;
+  void InitBB(BB &bb);
+  void InitAndGetDefUse();
+  bool GenerateLiveOut(BB &bb) const;
+  bool GenerateLiveIn(BB &bb);
+  void BuildInOutforFunc();
+  void DealWithInOutOfCleanupBB();
+  void InsertInOutOfCleanupBB();
+  void ResetLiveSet();
+  void ClearInOutDataInfo();
+  void EnlargeSpaceForLiveAnalysis(BB &currBB);
+  void GetBBDefUse(BB &bb);
+  void ProcessAsmListOpnd(BB &bb, Operand &opnd, uint32 idx) const;
+  void ProcessListOpnd(BB &bb, Operand &opnd, bool isDef) const;
+  void ProcessMemOpnd(BB &bb, Operand &opnd) const;
+  void ProcessCondOpnd(BB &bb) const;
+  void CollectLiveInfo(BB &bb, const Operand &opnd, bool isDef, bool isUse) const;
+
+  SparseDataInfo *NewLiveIn(uint32 maxRegCount) {
+    return memPool->New<SparseDataInfo>(maxRegCount, alloc);
+  }
+
+  SparseDataInfo *NewLiveOut(uint32 maxRegCount) {
+    return memPool->New<SparseDataInfo>(maxRegCount, alloc);
+  }
+
+  SparseDataInfo *NewDef(uint32 maxRegCount) {
+    return memPool->New<SparseDataInfo>(maxRegCount, alloc);
+  }
+
+  SparseDataInfo *NewUse(uint32 maxRegCount) {
+    return memPool->New<SparseDataInfo>(maxRegCount, alloc);
+  }
+
+  virtual void GenerateReturnBBDefUse(BB &bb) const = 0;
+  virtual void ProcessCallInsnParam(BB &bb, const Insn &insn) const = 0;
+  virtual bool CleanupBBIgnoreReg(regno_t reg) = 0;
+  virtual void InitEhDefine(BB &bb) = 0;
+
+ protected:
+  int iteration = 0;
+  CGFunc *cgFunc;
+  MemPool *memPool;
+  MapleAllocator alloc;
+  StackMemPool &stackMp;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgLiveAnalysis, maplebe::CGFunc)
+  LiveAnalysis *GetResult() {
+    return live;
+  }
+  LiveAnalysis *live = nullptr;
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_LIVE_H */
diff --git a/src/mapleall/maple_be/include/cg/local_opt.h b/src/mapleall/maple_be/include/cg/local_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b3d1246481a9aea7d10c2efc0ce50e4b2071b88
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/local_opt.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_LOCALO_H
+#define MAPLEBE_INCLUDE_CG_LOCALO_H
+
+#include "cg_phase.h"
+#include "cgbb.h"
+#include "live.h"
+#include "loop.h"
+#include "cg.h"
+
+namespace maplebe {
+class LocalOpt {
+ public:
+  LocalOpt(MemPool &memPool, CGFunc &func, ReachingDefinition &rd)
+      : localoMp(&memPool),
+        cgFunc(&func),
+        reachindDef(&rd) {}
+
+  virtual ~LocalOpt() = default;
+
+  void DoLocalCopyPropOptmize();
+
+ protected:
+  ReachingDefinition *GetRDInfo() {
+    return reachindDef;
+  }
+  MemPool *localoMp;
+  CGFunc *cgFunc;
+  ReachingDefinition *reachindDef;
+
+ private:
+  virtual void DoLocalCopyProp() = 0;
+};
+
+class LocalOptimizeManager {
+ public:
+  LocalOptimizeManager(CGFunc &cgFunc, ReachingDefinition &rd)
+      : cgFunc(cgFunc),
+        reachingDef(&rd) {}
+  ~LocalOptimizeManager() = default;
+  template<typename LocalPropOptimizePattern>
+  void Optimize() {
+    LocalPropOptimizePattern optPattern(cgFunc, *reachingDef);
+    optPattern.Run();
+  }
+ private:
+  CGFunc &cgFunc;
+  ReachingDefinition *reachingDef;
+};
+
+class LocalPropOptimizePattern {
+ public:
+  LocalPropOptimizePattern(CGFunc &cgFunc, ReachingDefinition &rd)
+      : cgFunc(cgFunc),
+        reachingDef(&rd) {}
+  virtual ~LocalPropOptimizePattern() = default;
+  virtual bool CheckCondition(Insn &insn) = 0;
+  virtual void Optimize(BB &bb, Insn &insn) = 0;
+  void Run();
+ protected:
+  std::string PhaseName() const {
+    return "localopt";
+  }
+  CGFunc &cgFunc;
+  ReachingDefinition *reachingDef;
+};
+
+class RedundantDefRemove : public LocalPropOptimizePattern {
+ public:
+  RedundantDefRemove(CGFunc &cgFunc, ReachingDefinition &rd) : LocalPropOptimizePattern(cgFunc, rd) {}
+  ~RedundantDefRemove() override = default;
+  bool CheckCondition(Insn &insn) final;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(LocalCopyProp, maplebe::CGFunc)
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_LOCALO_H */
diff --git a/src/mapleall/maple_be/include/cg/loop.h b/src/mapleall/maple_be/include/cg/loop.h
new file mode 100644
index 0000000000000000000000000000000000000000..379f11159e47b71ffbcdd846ead10dd594e6d7db
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/loop.h
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_LOOP_H
+#define MAPLEBE_INCLUDE_CG_LOOP_H
+
+#include "cg_phase.h"
+#include "cgbb.h"
+#include "insn.h"
+#include "maple_phase.h"
+
+namespace maplebe {
+class LoopHierarchy {
+ public:
+  struct HeadIDCmp {
+    bool operator()(const LoopHierarchy *loopHierarchy1, const LoopHierarchy *loopHierarchy2) const {
+      CHECK_NULL_FATAL(loopHierarchy1);
+      CHECK_NULL_FATAL(loopHierarchy2);
+      return (loopHierarchy1->GetHeader()->GetId() < loopHierarchy2->GetHeader()->GetId());
+    }
+  };
+
+  explicit LoopHierarchy(MemPool &memPool)
+      : loopMp(memPool),
+        loopAlloc(&memPool),
+        otherLoopEntries(loopAlloc.Adapter()),
+        loopMembers(loopAlloc.Adapter()),
+        backedge(loopAlloc.Adapter()),
+        backBBEdges(loopAlloc.Adapter()),
+        exits(loopAlloc.Adapter()),
+        innerLoops(loopAlloc.Adapter()) {}
+
+  virtual ~LoopHierarchy() = default;
+
+  BB *GetHeader() const {
+    return header;
+  }
+  const MapleSet<BB*, BBIdCmp> &GetLoopMembers() const {
+    return loopMembers;
+  }
+  const MapleSet<BB*, BBIdCmp> &GetBackedge() const {
+    return backedge;
+  }
+  const MapleUnorderedMap<BB*, MapleSet<BB*>*> &GetBackBBEdges() const {
+    return backBBEdges;
+  }
+  MapleSet<BB*, BBIdCmp> &GetBackedgeNonConst() {
+    return backedge;
+  }
+  const MapleSet<BB*, BBIdCmp> &GetExits() const {
+    return exits;
+  }
+  const MapleSet<LoopHierarchy*, HeadIDCmp> &GetInnerLoops() const {
+    return innerLoops;
+  }
+  const LoopHierarchy *GetOuterLoop() const {
+    return outerLoop;
+  }
+  LoopHierarchy *GetPrev() {
+    return prev;
+  }
+  LoopHierarchy *GetNext() {
+    return next;
+  }
+
+  MapleSet<BB*, BBIdCmp>::iterator EraseLoopMembers(MapleSet<BB*, BBIdCmp>::iterator it) {
+    return loopMembers.erase(it);
+  }
+  void InsertLoopMembers(BB &bb) {
+    (void)loopMembers.insert(&bb);
+  }
+  void InsertBackedge(BB &bb) {
+    (void)backedge.insert(&bb);
+  }
+  void InsertBackBBEdge(BB &backBB, BB &headerBB) {
+    auto backIt = backBBEdges.find(&backBB);
+    if (backIt == backBBEdges.end()) {
+      auto *headBBSPtr = loopMp.New<MapleSet<BB*>>(loopAlloc.Adapter());
+      headBBSPtr->insert(&headerBB);
+      backBBEdges.emplace(&backBB, headBBSPtr);
+    } else {
+      backIt->second->insert(&headerBB);
+    }
+  }
+  void InsertExit(BB &bb) {
+    (void)exits.insert(&bb);
+  }
+  void InsertInnerLoops(LoopHierarchy &loop) {
+    (void)innerLoops.insert(&loop);
+  }
+  void SetHeader(BB &bb) {
+    header = &bb;
+  }
+  void SetOuterLoop(LoopHierarchy &loop) {
+    outerLoop = &loop;
+  }
+  void SetPrev(LoopHierarchy *loop) {
+    prev = loop;
+  }
+  void SetNext(LoopHierarchy *loop) {
+    next = loop;
+  }
+  void PrintLoops(const std::string &name) const;
+  MapleSet<BB*, BBIdCmp> GetOtherLoopEntries() const {
+    return otherLoopEntries;
+  }
+
+  void InsertBBToOtherLoopEntries(BB * const &insertBB) {
+    (void)otherLoopEntries.insert(insertBB);
+  }
+  void EraseBBFromOtherLoopEntries(BB * const &eraseBB) {
+    (void)otherLoopEntries.erase(eraseBB);
+  }
+
+ protected:
+  LoopHierarchy *prev = nullptr;
+  LoopHierarchy *next = nullptr;
+
+ private:
+  MemPool &loopMp;
+  MapleAllocator loopAlloc;
+  BB *header = nullptr;
+  MapleSet<BB*, BBIdCmp> otherLoopEntries;
+  MapleSet<BB*, BBIdCmp> loopMembers;
+  MapleSet<BB*, BBIdCmp> backedge;
+  MapleUnorderedMap<BB*, MapleSet<BB*>*> backBBEdges; // <backBB, headerBBs>
+  MapleSet<BB*, BBIdCmp> exits;
+  MapleSet<LoopHierarchy*, HeadIDCmp> innerLoops;
+  LoopHierarchy *outerLoop = nullptr;
+};
+
+class LoopFinder : public AnalysisResult {
+ public:
+  LoopFinder(CGFunc &func, MemPool &mem)
+      : AnalysisResult(&mem),
+        cgFunc(&func),
+        memPool(&mem),
+        loopMemPool(memPool),
+        visitedBBs(loopMemPool.Adapter()),
+        sortedBBs(loopMemPool.Adapter()),
+        dfsBBs(loopMemPool.Adapter()),
+        onPathBBs(loopMemPool.Adapter()),
+        recurseVisited(loopMemPool.Adapter())
+        {}
+
+  ~LoopFinder() override = default;
+
+  void FormLoop(BB* headBB, BB* backBB);
+  void SeekBackEdge(BB* bb, MapleList<BB*> succs);
+  void SeekCycles();
+  void MarkExtraEntryAndEncl();
+  bool HasSameHeader(const LoopHierarchy *lp1, const LoopHierarchy *lp2) const;
+  void MergeLoops();
+  void SortLoops();
+  void UpdateOuterForInnerLoop(BB *bb, LoopHierarchy *outer);
+  void UpdateOuterLoop(const LoopHierarchy *loop);
+  void CreateInnerLoop(LoopHierarchy &inner, LoopHierarchy &outer);
+  void DetectInnerLoop();
+  void UpdateCGFunc() const;
+  void FormLoopHierarchy();
+
+ private:
+  CGFunc *cgFunc;
+  MemPool *memPool;
+  MapleAllocator loopMemPool;
+  MapleVector<bool> visitedBBs;
+  MapleVector<BB*> sortedBBs;
+  MapleStack<BB*> dfsBBs;
+  MapleVector<bool> onPathBBs;
+  MapleVector<bool> recurseVisited;
+  LoopHierarchy *loops = nullptr;
+};
+
+class CGFuncLoops {
+ public:
+  explicit CGFuncLoops(MemPool &memPool)
+      : loopMemPool(&memPool),
+        multiEntries(loopMemPool.Adapter()),
+        loopMembers(loopMemPool.Adapter()),
+        backedge(loopMemPool.Adapter()),
+        backBBEdges(loopMemPool.Adapter()),
+        exits(loopMemPool.Adapter()),
+        innerLoops(loopMemPool.Adapter()) {}
+
+  ~CGFuncLoops() = default;
+
+  void CheckOverlappingInnerLoops(const MapleVector<CGFuncLoops*> &iLoops,
+                                  const MapleVector<BB*> &loopMem) const;
+  void CheckLoops() const;
+  void PrintLoops(const CGFuncLoops &loops) const;
+  bool IsBBLoopMember(const BB *bb) const;
+  bool IsBackEdge(const BB &fromBB, const BB &toBB) const {
+    auto backIt = backBBEdges.find(fromBB.GetId());
+    if (backIt == backBBEdges.end()) {
+      return false;
+    }
+    for (auto headId : backIt->second) {
+      if (toBB.GetId() == headId) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const BB *GetHeader() const {
+    return header;
+  }
+  BB *GetHeader() {
+    return header;
+  }
+  const MapleVector<BB*> &GetMultiEntries() const {
+    return multiEntries;
+  }
+  const MapleVector<BB*> &GetLoopMembers() const {
+    return loopMembers;
+  }
+  const MapleVector<BB*> &GetBackedge() const {
+    return backedge;
+  }
+  const MapleUnorderedMap<uint32, MapleSet<uint32>> &GetBackBBEdges() const {
+    return backBBEdges;
+  }
+  const MapleVector<BB*> &GetExits() const {
+    return exits;
+  }
+  const MapleVector<CGFuncLoops*> &GetInnerLoops() const {
+    return innerLoops;
+  }
+  const CGFuncLoops *GetOuterLoop() const {
+    return outerLoop;
+  }
+  uint32 GetLoopLevel() const {
+    return loopLevel;
+  }
+  void AddMultiEntries(BB &bb) {
+    multiEntries.emplace_back(&bb);
+  }
+  void AddLoopMembers(BB &bb) {
+    loopMembers.emplace_back(&bb);
+  }
+  void AddBackedge(BB &bb) {
+    backedge.emplace_back(&bb);
+  }
+  void AddBackBBEdge(BB &backBB, BB &headerBB) {
+    auto backIt = backBBEdges.find(backBB.GetId());
+    if (backIt == backBBEdges.end()) {
+      MapleSet<uint32> toBBs(loopMemPool.Adapter());
+      toBBs.insert(headerBB.GetId());
+      backBBEdges.emplace(backBB.GetId(), toBBs);
+    } else {
+      backIt->second.insert(headerBB.GetId());
+    }
+  }
+  void AddExit(BB &bb) {
+    exits.emplace_back(&bb);
+  }
+  void AddInnerLoops(CGFuncLoops &loop) {
+    innerLoops.emplace_back(&loop);
+  }
+  void SetHeader(BB &bb) {
+    header = &bb;
+  }
+  void SetOuterLoop(CGFuncLoops &loop) {
+    outerLoop = &loop;
+  }
+  void SetLoopLevel(uint32 val) {
+    loopLevel = val;
+  }
+
+ private:
+  MapleAllocator loopMemPool;
+  BB *header = nullptr;
+  MapleVector<BB*> multiEntries;
+  MapleVector<BB*> loopMembers;
+  MapleVector<BB*> backedge;
+  MapleUnorderedMap<uint32, MapleSet<uint32>> backBBEdges; // <backBBId, headerBBIds> (<fromBBId, toBBIds>)
+  MapleVector<BB*> exits;
+  MapleVector<CGFuncLoops*> innerLoops;
+  CGFuncLoops *outerLoop = nullptr;
+  uint32 loopLevel = 0;
+};
+
+struct CGFuncLoopCmp {
+  bool operator()(const CGFuncLoops *lhs, const CGFuncLoops *rhs) const {
+    CHECK_NULL_FATAL(lhs);
+    CHECK_NULL_FATAL(rhs);
+    return lhs->GetHeader()->GetId() < rhs->GetHeader()->GetId();
+  }
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgLoopAnalysis, maplebe::CGFunc);
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_LOOP_H */
diff --git a/src/mapleall/maple_be/include/cg/lsda.h b/src/mapleall/maple_be/include/cg/lsda.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd11e092936b4e8f33f8c638d285e230a8a04ea6
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/lsda.h
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_LSDA_H
+#define MAPLEBE_INCLUDE_CG_LSDA_H
+#include "types_def.h"
+#include "mir_nodes.h"
+#include "cgbb.h"
+
+namespace maplebe {
+using namespace maple;
+
+class LabelPair {
+ public:
+  LabelPair() = default;
+  LabelPair(LabelNode *startOffsetLbl, LabelNode *endOffsetLbl) {
+    startOffset = startOffsetLbl;
+    endOffset = endOffsetLbl;
+  }
+  ~LabelPair() = default;
+
+  const LabelNode *GetStartOffset() const {
+    return startOffset;
+  }
+
+  void SetStartOffset(LabelNode *lableNode) {
+    startOffset = lableNode;
+  }
+
+  const LabelNode *GetEndOffset() const {
+    return endOffset;
+  }
+
+  void SetEndOffsetLabelIdx(LabelIdx index) const {
+    endOffset->SetLabelIdx(index);
+  }
+
+  void SetEndOffset(LabelNode *labelNode) {
+    endOffset = labelNode;
+  }
+
+ private:
+  LabelNode *startOffset = nullptr;
+  LabelNode *endOffset = nullptr;
+};
+
+class LSDAHeader {
+ public:
+  const LabelNode *GetLSDALabel() const {
+    return lsdaLabel;
+  }
+
+  void SetLSDALabel(LabelNode &labelNode) {
+    lsdaLabel = &labelNode;
+  }
+
+  uint8 GetLPStartEncoding() const {
+    return lpStartEncoding;
+  }
+
+  void SetLPStartEncoding(uint8 encoding) {
+    lpStartEncoding = encoding;
+  }
+
+  uint8 GetTTypeEncoding() const {
+    return tTypeEncoding;
+  }
+
+  void SetTTypeEncoding(uint8 encoding) {
+    tTypeEncoding = encoding;
+  }
+
+  const LabelPair &GetTTypeOffset() const {
+    return tTypeOffset;
+  }
+
+  void SetTTypeOffset(LabelNode *start, LabelNode *end) {
+    tTypeOffset.SetStartOffset(start);
+    tTypeOffset.SetEndOffset(end);
+  }
+
+  uint8 GetCallSiteEncoding() const {
+    return callSiteEncoding;
+  }
+
+  void SetCallSiteEncoding(uint8 encoding) {
+    callSiteEncoding = encoding;
+  }
+
+ private:
+  LabelNode *lsdaLabel;
+  uint8 lpStartEncoding;
+  uint8 tTypeEncoding;
+  LabelPair tTypeOffset;
+  uint8 callSiteEncoding;
+};
+
+struct LSDACallSite {
+  LabelPair csStart;
+  LabelPair csLength;
+  LabelPair csLandingPad;
+  uint32 csAction;
+
+ public:
+  void Init(const LabelPair &start, const LabelPair &length, const LabelPair &landingPad, uint32 action) {
+    csStart = start;
+    csLength = length;
+    csLandingPad = landingPad;
+    csAction = action;
+  }
+};
+
+class LSDAAction {
+ public:
+  LSDAAction(uint8 idx, uint8 filter) : actionIndex(idx), actionFilter(filter) {}
+  ~LSDAAction() = default;
+
+  uint8 GetActionIndex() const {
+    return actionIndex;
+  }
+
+  uint8 GetActionFilter() const {
+    return actionFilter;
+  }
+
+ private:
+  uint8 actionIndex;
+  uint8 actionFilter;
+};
+
+class LSDACallSiteTable {
+ public:
+  explicit LSDACallSiteTable(MapleAllocator &alloc) : callSiteTable(alloc.Adapter()) {
+    csTable.SetStartOffset(nullptr);
+    csTable.SetEndOffset(nullptr);
+  }
+  ~LSDACallSiteTable() = default;
+
+  const MapleVector<LSDACallSite*> &GetCallSiteTable() const {
+    return callSiteTable;
+  }
+
+  void PushBack(LSDACallSite &lsdaCallSite) {
+    callSiteTable.emplace_back(&lsdaCallSite);
+  }
+
+  const LabelPair &GetCSTable() const {
+    return csTable;
+  }
+
+  void SetCSTable(LabelNode *start, LabelNode *end) {
+    csTable.SetStartOffset(start);
+    csTable.SetEndOffset(end);
+  }
+
+  void UpdateCallSite(const BB &oldBB, const BB &newBB) {
+    for (auto *callSite : callSiteTable) {
+      if (callSite->csStart.GetEndOffset() != nullptr) {
+        if (callSite->csStart.GetEndOffset()->GetLabelIdx() == oldBB.GetLabIdx()) {
+          callSite->csStart.SetEndOffsetLabelIdx(newBB.GetLabIdx());
+        }
+      }
+
+      CHECK_NULL_FATAL(callSite->csLength.GetEndOffset());
+      if (callSite->csLength.GetEndOffset()->GetLabelIdx() == oldBB.GetLabIdx()) {
+        callSite->csLength.SetEndOffsetLabelIdx(newBB.GetLabIdx());
+      }
+
+      if (callSite->csLandingPad.GetEndOffset() != nullptr) {
+        if (callSite->csLandingPad.GetEndOffset()->GetLabelIdx() == oldBB.GetLabIdx()) {
+          callSite->csLandingPad.SetEndOffsetLabelIdx(newBB.GetLabIdx());
+        }
+      }
+    }
+  }
+
+  void RemoveCallSite(const BB &bb) {
+    for (int32 i = static_cast<int32>(callSiteTable.size()) - 1; i > -1; --i) {
+      if (callSiteTable[i]->csStart.GetEndOffset() != nullptr) {
+        if (callSiteTable[i]->csStart.GetEndOffset()->GetLabelIdx() == bb.GetLabIdx()) {
+          (void)callSiteTable.erase(callSiteTable.cbegin() + i);
+          continue;
+        }
+      }
+      if (callSiteTable[i]->csLandingPad.GetEndOffset() != nullptr) {
+        if (callSiteTable[i]->csLandingPad.GetEndOffset()->GetLabelIdx() == bb.GetLabIdx()) {
+          (void)callSiteTable.erase(callSiteTable.cbegin() + i);
+          continue;
+        }
+      }
+    }
+  }
+
+  /* return true if label is in callSiteTable */
+  bool InCallSiteTable(LabelIdx label) const {
+    for (auto *callSite : callSiteTable) {
+      if (label == callSite->csStart.GetEndOffset()->GetLabelIdx() ||
+          label == callSite->csStart.GetStartOffset()->GetLabelIdx()) {
+        return true;
+      }
+      if (label == callSite->csLength.GetEndOffset()->GetLabelIdx() ||
+          label == callSite->csLength.GetStartOffset()->GetLabelIdx()) {
+        return true;
+      }
+      if (callSite->csLandingPad.GetStartOffset()) {
+        if (label == callSite->csLandingPad.GetEndOffset()->GetLabelIdx() ||
+            label == callSite->csLandingPad.GetStartOffset()->GetLabelIdx()) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  bool IsTryBlock(const BB &bb) const {
+    for (auto *callSite : callSiteTable) {
+      if (callSite->csLength.GetStartOffset()->GetLabelIdx() == bb.GetLabIdx()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  void SortCallSiteTable(std::function<bool(LSDACallSite *site1, LSDACallSite *site2)> const &func) {
+    std::sort(callSiteTable.begin(), callSiteTable.end(), func);
+  }
+
+ private:
+  MapleVector<LSDACallSite*> callSiteTable;
+  LabelPair csTable;
+};
+
+class LSDAActionTable {
+ public:
+  explicit LSDAActionTable(MapleAllocator &alloc) : actionTable(alloc.Adapter()) {}
+  virtual ~LSDAActionTable() = default;
+
+  const MapleVector<LSDAAction*> &GetActionTable() const{
+    return actionTable;
+  }
+
+  void PushBack(LSDAAction &lsdaAction) {
+    actionTable.emplace_back(&lsdaAction);
+  }
+
+  size_t Size() const {
+    return actionTable.size();
+  }
+
+ private:
+  MapleVector<LSDAAction*> actionTable;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_LSDA_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/memlayout.h b/src/mapleall/maple_be/include/cg/memlayout.h
new file mode 100644
index 0000000000000000000000000000000000000000..17980e0d2378854c5babdcbe74ad2d08f66a7acd
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/memlayout.h
@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_MEMLAYOUT_H
+#define MAPLEBE_INCLUDE_CG_MEMLAYOUT_H
+
+/* C++ headers. */
+#include <utility>
+#include "becommon.h"
+#include "mir_function.h"
+#include "mir_nodes.h"  /* StmtNode */
+
+namespace maplebe {
+using regno_t = uint32;
+enum MemSegmentKind : uint8 {
+  kMsUnknown,
+  /*
+   * Function arguments that are not passed through registers
+   * are passed to the callee through stack.
+   */
+  kMsArgsStkPassed,
+  /*
+   * In between MS_args_stackpassed and kMsArgsRegpassed,
+   * we store call-saved registers if any.
+   */
+  /*
+   * Args passed via registers according to the architecture-specific ABI
+   * may need be stored in stack.
+   * 1) In the unoptimized version, we implement a model (similar to GCC -O0)
+   *    where all the values are initially stored in the memory and
+   *    loaded into registers when needed, and stored back to the memory when
+   *    their uses are done.
+   * 2) In an optimized version, some register-passed values may need to be
+   *    spilled into memory. We allocate the space in this Memory segment.
+   *    (or we may allocate them in caller-saved; may be this is better...)
+   */
+  kMsArgsRegPassed,
+  /*
+   * GR/VR Save areas for unnamed arguments under vararg functions
+   */
+  kMsGrSaveArea,
+  kMsVrSaveArea,
+  /* local (auto) variables */
+  kMsRefLocals,
+  kMsLocals,
+  kMsSpillReg,
+  /*
+   * In between kMsLocals and MS_args_to_stackpass, we allocate
+   * a register-spill area and space for caller-saved registers
+   */
+  /*
+   * When a function calls another which takes some arguments
+   * that cannot be passed through registers, it is the caller's
+   * responsibility to allocate space for those arguments in memory.
+   */
+  kMsArgsToStkPass,
+  /* The red zone stack area will not be modified by the exception signal. */
+  kMsRedZone,
+};
+
+enum StackProtectKind : uint8 {
+  kNone = 0,
+  kAddrofStack = 0x1,
+  /* if a callee has return agg type which size over 16bytes */
+  kRetureStackSlot = 0x2,
+};
+
+class CGFunc;
+
+/* keeps track of the allocation of a memory segment */
+class MemSegment {
+ public:
+  explicit MemSegment(MemSegmentKind memSegKind) : kind(memSegKind), size(0) {}
+
+  ~MemSegment() = default;
+
+  uint32 GetSize() const {
+    return size;
+  }
+
+  void SetSize(uint32 memSize) {
+    size = memSize;
+  }
+
+  MemSegmentKind GetMemSegmentKind() const {
+    return kind;
+  }
+
+ private:
+  MemSegmentKind kind;
+  uint32 size;  /* size is negative if allocated offsets are negative */
+};  /* class MemSegment */
+
+/* describes where a symbol is allocated */
+class SymbolAlloc {
+ public:
+  SymbolAlloc() = default;
+
+  ~SymbolAlloc() = default;
+
+  const MemSegment *GetMemSegment() const {
+    return memSegment;
+  }
+
+  void SetMemSegment(const MemSegment &memSeg) {
+    memSegment = &memSeg;
+  }
+
+  int64 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(int64 off) {
+    offset = off;
+  }
+
+ protected:
+  const MemSegment *memSegment = nullptr;
+  int64 offset = 0;
+};  /* class SymbolAlloc */
+
+class MemLayout {
+ public:
+  MemLayout(BECommon &beCommon, MIRFunction &mirFunc, MapleAllocator &mallocator, uint32 kStackPtrAlignment)
+      : be(beCommon),
+        mirFunction(&mirFunc),
+        segArgsStkPassed(kMsArgsStkPassed),
+        segArgsRegPassed(kMsArgsRegPassed),
+        segArgsToStkPass(kMsArgsToStkPass),
+        symAllocTable(mallocator.Adapter()),
+        spillLocTable(mallocator.Adapter()),
+        spillRegLocMap(mallocator.Adapter()),
+        localRefLocMap(std::less<StIdx>(), mallocator.Adapter()),
+        memAllocator(&mallocator),
+        stackPtrAlignment(kStackPtrAlignment) {
+    symAllocTable.resize(mirFunc.GetSymTab()->GetSymbolTableSize());
+  }
+
+  virtual ~MemLayout() = default;
+
+  void SetCurrFunction(CGFunc &func) {
+    cgFunc = &func;
+  }
+
+  /*
+   * Returns stack space required for a call
+   * which is used to pass arguments that cannot be
+   * passed through registers
+   */
+  virtual uint32 ComputeStackSpaceRequirementForCall(StmtNode &stmtNode, int32 &aggCopySize, bool isIcall) = 0;
+
+  /*
+   * Go over all outgoing calls in the function body and get the maximum space
+   * needed for storing the actuals based on the actual parameters and the ABI.
+   * These are usually those arguments that cannot be passed
+   * through registers because a call passes more than 8 arguments, or
+   * they cannot be fit in a pair of registers.
+   */
+  uint32 FindLargestActualArea(int32 &aggCopySize);
+
+  virtual void LayoutStackFrame(int32 &structCopySize, int32 &maxParmStackSize) = 0;
+
+  /*
+   * "Pseudo-registers can be regarded as local variables of a
+   * primitive type whose addresses are never taken"
+   */
+  virtual void AssignSpillLocationsToPseudoRegisters() = 0;
+
+  virtual SymbolAlloc *AssignLocationToSpillReg(regno_t vrNum) = 0;
+
+  virtual int32 GetCalleeSaveBaseLoc() const {
+    return 0;
+  }
+
+  SymbolAlloc *GetSymAllocInfo(uint32 stIdx) {
+    ASSERT(stIdx < symAllocTable.size(), "out of symAllocTable's range");
+    return symAllocTable[stIdx];
+  }
+
+  void SetSymAllocInfo(uint32 stIdx, SymbolAlloc &symAlloc) {
+    ASSERT(stIdx < symAllocTable.size(), "out of symAllocTable's range");
+    symAllocTable[stIdx] = &symAlloc;
+  }
+
+  const SymbolAlloc *GetSpillLocOfPseduoRegister(PregIdx index) const {
+    return spillLocTable.at(index);
+  }
+
+  SymbolAlloc *GetLocOfSpillRegister(regno_t vrNum) {
+    SymbolAlloc *loc = nullptr;
+    auto pos = spillRegLocMap.find(vrNum);
+    if (pos == spillRegLocMap.end()) {
+      loc = AssignLocationToSpillReg(vrNum);
+    } else {
+      loc = pos->second;
+    }
+    return loc;
+  }
+
+  uint32 SizeOfArgsToStackPass() const {
+    return segArgsToStkPass.GetSize();
+  }
+
+  uint32 SizeOfArgsRegisterPassed() const {
+    return segArgsRegPassed.GetSize();
+  }
+
+  BECommon &GetBECommon() {
+    return be;
+  }
+
+  MIRFunction *GetMIRFunction() {
+    return mirFunction;
+  }
+
+  const MemSegment &GetSegArgsStkPassed() const {
+    return segArgsStkPassed;
+  }
+
+  const MemSegment &GetSegArgsRegPassed() const {
+    return segArgsRegPassed;
+  }
+
+  const MemSegment &GetSegArgsToStkPass() const {
+    return segArgsToStkPass;
+  }
+
+  const MapleVector<SymbolAlloc*> &GetSymAllocTable() const {
+    return symAllocTable;
+  }
+
+  void SetSpillRegLocInfo(regno_t regNum, SymbolAlloc &symAlloc) {
+    spillRegLocMap[regNum] = &symAlloc;
+  }
+
+  const MapleMap<StIdx, SymbolAlloc*> &GetLocalRefLocMap() const {
+    return localRefLocMap;
+  }
+
+  void SetLocalRegLocInfo(StIdx idx, SymbolAlloc &symAlloc) {
+    localRefLocMap[idx] = &symAlloc;
+  }
+
+  bool IsLocalRefLoc(const MIRSymbol &symbol) const {
+    return localRefLocMap.find(symbol.GetStIdx()) != localRefLocMap.end();
+  }
+
+  uint32 GetStackPtrAlignment() const {
+    return stackPtrAlignment;
+  }
+ protected:
+  BECommon &be;
+  MIRFunction *mirFunction;
+  MemSegment segArgsStkPassed;
+  MemSegment segArgsRegPassed;
+  MemSegment segArgsToStkPass;
+  MapleVector<SymbolAlloc*> symAllocTable;  /* index is stindex from StIdx */
+  MapleVector<SymbolAlloc*> spillLocTable;  /* index is preg idx */
+  MapleUnorderedMap<regno_t, SymbolAlloc*> spillRegLocMap;
+  MapleMap<StIdx, SymbolAlloc*> localRefLocMap;  /* localrefvar formals. real address passed in stack. */
+  MapleAllocator *memAllocator;
+  CGFunc *cgFunc = nullptr;
+  const uint32 stackPtrAlignment;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_MEMLAYOUT_H */
diff --git a/src/mapleall/maple_be/include/cg/offset_adjust.h b/src/mapleall/maple_be/include/cg/offset_adjust.h
new file mode 100644
index 0000000000000000000000000000000000000000..774e4fc6d8bec1950c2b8e1ee52f27837eed2d8c
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/offset_adjust.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_OFFSET_ADJUST_H
+#define MAPLEBE_INCLUDE_CG_OFFSET_ADJUST_H
+
+#include "cgfunc.h"
+#include "cg_phase.h"
+
+namespace maplebe {
+class FrameFinalize {
+ public:
+  explicit FrameFinalize(CGFunc &func) : cgFunc(&func) {}
+
+  virtual ~FrameFinalize() {
+    cgFunc = nullptr;
+  }
+
+  virtual void Run() {}
+
+  std::string PhaseName() const {
+    return "framefinalize";
+  }
+
+ protected:
+  CGFunc *cgFunc;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgFrameFinalize, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_OFFSET_ADJUST_H */
diff --git a/src/mapleall/maple_be/include/cg/operand.def b/src/mapleall/maple_be/include/cg/operand.def
new file mode 100644
index 0000000000000000000000000000000000000000..249f048046382c302518f830f1250c9b6570fdc4
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/operand.def
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+DEFINE_MOP(Mem8S, {Operand::kOpdMem, operand::kIsUse, 8})
+DEFINE_MOP(Mem8D, {Operand::kOpdMem, operand::kIsDef, 8})
+DEFINE_MOP(Mem16S, {Operand::kOpdMem, operand::kIsUse, 16})
+DEFINE_MOP(Mem16D, {Operand::kOpdMem, operand::kIsDef, 16})
+DEFINE_MOP(Mem32D, {Operand::kOpdMem, operand::kIsDef, 32})
+DEFINE_MOP(Mem32S, {Operand::kOpdMem, operand::kIsUse, 32})
+DEFINE_MOP(Mem64D, {Operand::kOpdMem, operand::kIsDef, 64})
+DEFINE_MOP(Mem64S, {Operand::kOpdMem, operand::kIsUse, 64})
+DEFINE_MOP(Mem128D, {Operand::kOpdMem, operand::kIsDef, 128})
+DEFINE_MOP(Mem128S, {Operand::kOpdMem, operand::kIsUse, 128})
+
+DEFINE_MOP(Reg8IS, {Operand::kOpdRegister, operand::kIsUse | operand::kInt, 8})
+DEFINE_MOP(Reg8ID, {Operand::kOpdRegister, operand::kIsDef | operand::kInt, 8})
+DEFINE_MOP(Reg8IDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kInt, 8})
+DEFINE_MOP(Reg16ID, {Operand::kOpdRegister, operand::kIsDef | operand::kInt, 16})
+DEFINE_MOP(Reg16IS, {Operand::kOpdRegister, operand::kIsUse | operand::kInt, 16})
+DEFINE_MOP(Reg16IDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kInt, 16})
+DEFINE_MOP(Reg32ID, {Operand::kOpdRegister, operand::kIsDef | operand::kInt, 32})
+DEFINE_MOP(Reg32IS, {Operand::kOpdRegister, operand::kIsUse | operand::kInt, 32})
+DEFINE_MOP(Reg32IDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kInt, 32})
+DEFINE_MOP(Reg64ID, {Operand::kOpdRegister, operand::kIsDef | operand::kInt, 64})
+DEFINE_MOP(Reg64IS, {Operand::kOpdRegister, operand::kIsUse | operand::kInt, 64})
+DEFINE_MOP(Reg64IDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kInt, 64})
+
+DEFINE_MOP(Reg8FS, {Operand::kOpdRegister, operand::kIsUse | operand::kFloat, 8})
+DEFINE_MOP(Reg8FD, {Operand::kOpdRegister, operand::kIsDef | operand::kFloat, 8})
+DEFINE_MOP(Reg16FD, {Operand::kOpdRegister, operand::kIsDef | operand::kFloat, 16})
+DEFINE_MOP(Reg16FS, {Operand::kOpdRegister, operand::kIsUse | operand::kFloat, 16})
+DEFINE_MOP(Reg16FDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kFloat, 16})
+DEFINE_MOP(Reg32FD, {Operand::kOpdRegister, operand::kIsDef | operand::kFloat, 32})
+DEFINE_MOP(Reg32FS, {Operand::kOpdRegister, operand::kIsUse | operand::kFloat, 32})
+DEFINE_MOP(Reg32FDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kFloat, 32})
+DEFINE_MOP(Reg64FD, {Operand::kOpdRegister, operand::kIsDef | operand::kFloat, 64})
+DEFINE_MOP(Reg64FS, {Operand::kOpdRegister, operand::kIsUse | operand::kFloat, 64})
+DEFINE_MOP(Reg64FDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kFloat, 64})
+DEFINE_MOP(Reg128FD, {Operand::kOpdRegister, operand::kIsDef | operand::kFloat, 128})
+DEFINE_MOP(Reg128FS, {Operand::kOpdRegister, operand::kIsUse | operand::kFloat, 128})
+DEFINE_MOP(Reg128FDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kFloat, 128})
+
+DEFINE_MOP(Reg64VD, {Operand::kOpdRegister, operand::kIsDef | operand::kFloat | operand::kIsVector, 64})
+DEFINE_MOP(Reg64VS, {Operand::kOpdRegister, operand::kIsUse | operand::kFloat | operand::kIsVector, 64})
+DEFINE_MOP(Reg64VDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kFloat | operand::kIsVector, 64})
+DEFINE_MOP(Reg128VD, {Operand::kOpdRegister, operand::kIsDef | operand::kFloat | operand::kIsVector, 128})
+DEFINE_MOP(Reg128VS, {Operand::kOpdRegister, operand::kIsUse | operand::kFloat | operand::kIsVector, 128})
+DEFINE_MOP(Reg128VDS, {Operand::kOpdRegister, operand::kIsDef | operand::kIsUse | operand::kFloat | operand::kIsVector, 128})
+
+DEFINE_MOP(CCD, {Operand::kOpdRegister, operand::kRegTyCc | operand::kIsDef, 1})
+DEFINE_MOP(CCS, {Operand::kOpdRegister, operand::kRegTyCc | operand::kIsUse, 1})
+DEFINE_MOP(Cond, {Operand::kOpdCond, operand::kRegTyCc | operand::kIsUse, 4})
+
+DEFINE_MOP(Imm4, {Operand::kOpdImmediate, operand::kIsUse, 4})
+DEFINE_MOP(Imm5, {Operand::kOpdImmediate, operand::kIsUse, 5})
+DEFINE_MOP(Imm6, {Operand::kOpdImmediate, operand::kIsUse, 6})
+DEFINE_MOP(Imm8, {Operand::kOpdImmediate, operand::kIsUse, 8})
+DEFINE_MOP(Imm12, {Operand::kOpdImmediate, operand::kIsUse, 12})
+DEFINE_MOP(Imm13, {Operand::kOpdImmediate, operand::kIsUse, 13})
+DEFINE_MOP(Imm16, {Operand::kOpdImmediate, operand::kIsUse, 16})
+DEFINE_MOP(Imm32, {Operand::kOpdImmediate, operand::kIsUse, 32})
+DEFINE_MOP(Imm64, {Operand::kOpdImmediate, operand::kIsUse, 64})
+DEFINE_MOP(StImm32, {Operand::kOpdStImmediate, operand::kIsUse, 32})
+DEFINE_MOP(StImm64, {Operand::kOpdStImmediate, operand::kIsUse, 64})
+DEFINE_MOP(FpImm8, {Operand::kOpdFPImmediate, operand::kIsUse, 8})
+DEFINE_MOP(LiteralSrc, {Operand::kOpdStImmediate, operand::kIsUse, 64})
+DEFINE_MOP(Literal12Src, {Operand::kOpdStImmediate, operand::kLiteralLow12, 12})
+
+/* for movk */
+DEFINE_MOP(Lsl4, {Operand::kOpdShift, operand::kIsUse, 4})
+DEFINE_MOP(Lsl6, {Operand::kOpdShift, operand::kIsUse, 6})
+DEFINE_MOP(Lsl12, {Operand::kOpdShift, operand::kIsUse, 12})
+/* for shift */
+DEFINE_MOP(Bitshift32, {Operand::kOpdShift, operand::kIsUse, 5})
+DEFINE_MOP(Bitshift64, {Operand::kOpdShift, operand::kIsUse, 6})
+DEFINE_MOP(Extendshift64, {Operand::kOpdExtend, operand::kIsUse, 3})
+
+DEFINE_MOP(ListSrc, {Operand::kOpdList, operand::kIsUse, 1})
+DEFINE_MOP(ListDest, {Operand::kOpdList, operand::kIsDef, 1})
+DEFINE_MOP(String0S, {Operand::kOpdString, operand::kIsUse, 0})
+DEFINE_MOP(AddressName, {Operand::kOpdBBAddress, operand::kIsUse, 64})
+
+DEFINE_MOP(Lbl64, {Operand::kOpdBBAddress, operand::kIsUse, 64})
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/operand.h b/src/mapleall/maple_be/include/cg/operand.h
new file mode 100644
index 0000000000000000000000000000000000000000..8833ae79c8bae3f57a5e892741d645592ca195fb
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/operand.h
@@ -0,0 +1,1908 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_OPERAND_H
+#define MAPLEBE_INCLUDE_CG_OPERAND_H
+
+#include "becommon.h"
+#include "cg_option.h"
+#include "visitor_common.h"
+
+/* maple_ir */
+#include "types_def.h"  /* need uint8 etc */
+#include "prim_types.h" /* for PrimType */
+#include "mir_symbol.h"
+
+/* Mempool */
+#include "mempool_allocator.h" /* MapleList */
+#include "memlayout.h"
+
+namespace maplebe {
+class OpndDesc;
+class Emitter;
+
+bool IsBitSizeImmediate(uint64 val, uint32 bitLen, uint32 nLowerZeroBits);
+bool IsBitmaskImmediate(uint64 val, uint32 bitLen);
+bool IsMoveWidableImmediate(uint64 val, uint32 bitLen);
+bool BetterUseMOVZ(uint64 val);
+
+
+using MOperator = uint32;
+enum RegType : maple::uint8 {
+  kRegTyUndef,
+  kRegTyInt,
+  kRegTyFloat,
+  kRegTyCc,
+  kRegTyX87,
+  kRegTyVary,
+  kRegTyFpsc,
+  kRegTyIndex,
+  kRegTyLast,
+};
+
+class Operand {
+ public:
+  enum OperandType : uint8 {
+    kOpdRegister,
+    kOpdImmediate,
+    kOpdMem,
+    kOpdCond,     /*  for condition code */
+    kOpdPhi,      /*  for phi operand */
+    kOpdFPImmediate,
+    kOpdStImmediate, /* use the symbol name as the offset */
+    kOpdOffset,      /* for the offset operand in MemOperand */
+    kOpdBBAddress,
+    kOpdList,     /*  for list operand */
+    kOpdShift,    /*  for imm shift operand */
+    kOpdRegShift, /*  for reg shift operand */
+    kOpdExtend,   /*  for extend operand */
+    kOpdString,   /*  for comments */
+    kOpdUndef
+  };
+
+  Operand(OperandType type, uint32 size) : opndKind(type), size(size) {}
+  virtual ~Operand() = default;
+
+  uint32 GetSize() const {
+    return size;
+  }
+
+  void SetSize(uint32 sz) {
+    size = sz;
+  }
+
+  OperandType GetKind() const {
+    return opndKind;
+  }
+
+  bool IsIntImmediate() const {
+    return opndKind == kOpdImmediate || opndKind == kOpdOffset;
+  }
+
+  bool IsConstImmediate() const {
+    return opndKind == kOpdImmediate || opndKind == kOpdOffset || opndKind == kOpdFPImmediate;
+  }
+
+  bool IsOfstImmediate() const {
+    return opndKind == kOpdOffset;
+  }
+
+  bool IsStImmediate() const {
+    return opndKind == kOpdStImmediate;
+  }
+
+  bool IsImmediate() const {
+    return (kOpdFPImmediate <= opndKind && opndKind <= kOpdOffset) || opndKind == kOpdImmediate;
+  }
+
+  bool IsRegister() const {
+    return opndKind == kOpdRegister;
+  }
+
+  bool IsList() const {
+    return opndKind == kOpdList;
+  }
+
+  bool IsPhi() const {
+    return opndKind == kOpdPhi;
+  }
+
+  bool IsMemoryAccessOperand() const {
+    return opndKind == kOpdMem;
+  }
+
+  bool IsLabel() const {
+    return opndKind == kOpdBBAddress;
+  }
+
+  bool IsConditionCode() const {
+    return opndKind == kOpdCond;
+  }
+
+  bool IsOpdShift() const {
+    return opndKind == kOpdShift;
+  }
+
+  bool IsRegShift() const {
+    return opndKind == kOpdRegShift;
+  }
+
+  bool IsOpdExtend() const {
+    return opndKind == kOpdExtend;
+  }
+
+  virtual bool IsLabelOpnd() const {
+    return false;
+  }
+
+  virtual bool IsFuncNameOpnd() const {
+    return false;
+  }
+
+  virtual bool IsCommentOpnd() const {
+    return false;
+  }
+
+  virtual bool IsLogicLSLOpnd() const {
+    return false;
+  }
+
+  virtual Operand *Clone(MemPool &memPool) const = 0;
+
+  /*
+   * A simple implementation here.
+   * Each subclass can elaborate on demand.
+   */
+  virtual bool Equals(Operand &op) const {
+    return BasicEquals(op) && (&op == this);
+  }
+
+  bool BasicEquals(const Operand &op) const {
+    return opndKind == op.GetKind() && size == op.GetSize();
+  }
+
+  /*
+   *  Operand hash content, ensuring uniqueness
+   */
+  virtual std::string GetHashContent() const {
+    return std::to_string(opndKind) + std::to_string(size);
+  }
+
+  virtual void Dump() const = 0;
+
+  virtual bool Less(const Operand &right) const = 0;
+
+  virtual void Accept(OperandVisitorBase &v) = 0;
+
+ protected:
+  OperandType opndKind; /* operand type */
+  uint32 size;          /* size in bits */
+  uint64 flag = 0;      /* operand property */
+};
+
+/* RegOperand */
+enum RegOperandState : uint32 {
+  kRegOpndNone = 0,
+  kRegOpndSetLow32 = 0x1,
+  kRegOpndSetHigh32 = 0x2
+};
+
+template<typename VisitableTy>
+class OperandVisitable : public Operand {
+ public:
+  using Operand::Operand;
+  void Accept(OperandVisitorBase &v) override {
+    if (OperandVisitor<VisitableTy>* typeV = dynamic_cast<OperandVisitor<VisitableTy>*>(&v)) {
+      typeV->Visit(static_cast<VisitableTy*>(this));
+    } else {
+      /* the type which has no implements */
+    }
+  }
+};
+
+class RegOperand : public OperandVisitable<RegOperand> {
+ public:
+  RegOperand(regno_t regNum, uint32 size, RegType type, uint32 flg = 0)
+      : OperandVisitable(kOpdRegister, size),
+        regNO(regNum),
+        regType(type),
+        validBitsNum(size),
+        regFlag(flg) {}
+
+  ~RegOperand() override = default;
+  using OperandVisitable<RegOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<RegOperand>(*this);
+  }
+
+  void SetValidBitsNum(uint32 validNum) {
+    validBitsNum = validNum;
+  }
+
+  uint32 GetValidBitsNum() const {
+    return validBitsNum;
+  }
+
+  bool IsOfIntClass() const {
+    return regType == kRegTyInt;
+  }
+
+  bool IsOfFloatOrSIMDClass() const {
+    return regType == kRegTyFloat;
+  }
+
+  bool IsOfCC() const {
+    return regType == kRegTyCc;
+  }
+
+  bool IsOfVary() const {
+    return regType == kRegTyVary;
+  }
+
+  RegType GetRegisterType() const {
+    return regType;
+  }
+
+  void SetRegisterType(RegType newTy) {
+    regType = newTy;
+  }
+
+  virtual bool IsBBLocalReg() const {
+    return isBBLocal;
+  }
+
+  void SetRegNotBBLocal() {
+    isBBLocal = false;
+  }
+
+  regno_t GetRegisterNumber() const {
+    return regNO;
+  }
+
+  void SetRegisterNumber(regno_t regNum) {
+    regNO = regNum;
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "reg ";
+    LogInfo::MapleLogger() << "size : " << GetSize();
+    LogInfo::MapleLogger() << " NO_" << GetRegisterNumber();
+  };
+
+  bool Less(const Operand &right) const override {
+    if (&right == this) {
+      return false;
+    }
+
+    /* For different type. */
+    if (opndKind != right.GetKind()) {
+      return opndKind < right.GetKind();
+    }
+
+    auto *rightOpnd = static_cast<const RegOperand*>(&right);
+
+    /* The same type. */
+    return regNO < rightOpnd->regNO;
+  }
+
+  bool Less(const RegOperand &right) const {
+    return regNO < right.regNO;
+  }
+
+  bool RegNumEqual(const RegOperand &right) const {
+    return regNO == right.GetRegisterNumber();
+  }
+
+  int32 RegCompare(const RegOperand &right) const {
+    return (regNO - right.GetRegisterNumber());
+  }
+
+  bool Equals(Operand &operand) const override {
+    if (!operand.IsRegister()) {
+      return false;
+    }
+    auto &op = static_cast<RegOperand&>(operand);
+    if (&op == this) {
+      return true;
+    }
+    return (BasicEquals(op) && regNO == op.GetRegisterNumber() && regType == op.GetRegisterType() &&
+            IsBBLocalReg() == op.IsBBLocalReg());
+  }
+
+  std::string GetHashContent() const override {
+    return Operand::GetHashContent() + std::to_string(regNO) + std::to_string(regType);
+  }
+
+  static bool IsSameRegNO(const Operand &firstOpnd, const Operand &secondOpnd) {
+    if (!firstOpnd.IsRegister() || !secondOpnd.IsRegister()) {
+      return false;
+    }
+    auto &firstReg = static_cast<const RegOperand&>(firstOpnd);
+    auto &secondReg = static_cast<const RegOperand&>(secondOpnd);
+    return firstReg.RegNumEqual(secondReg);
+  }
+
+  static bool IsSameReg(const Operand &firstOpnd, const Operand &secondOpnd) {
+    if (firstOpnd.GetSize() != secondOpnd.GetSize()) {
+      return false;
+    }
+    return IsSameRegNO(firstOpnd, secondOpnd);
+  }
+
+  void SetOpndSSAForm() {
+    isSSAForm = true;
+  }
+
+  void SetOpndOutOfSSAForm() {
+    isSSAForm = false;
+  }
+
+  bool IsSSAForm() const {
+    return isSSAForm;
+  }
+
+  void SetRefField(bool newIsRefField) {
+    isRefField = newIsRefField;
+  }
+
+  bool IsPhysicalRegister() const {
+    return GetRegisterNumber() < 100 && !IsOfCC();
+  }
+
+  bool IsVirtualRegister() const {
+    return !IsPhysicalRegister();
+  }
+
+  bool IsBBLocalVReg() const {
+    return IsVirtualRegister() && IsBBLocalReg();
+  }
+
+  void SetIF64Vec() {
+    if64Vec = true;
+  }
+
+  bool GetIF64Vec() const {
+    return if64Vec;
+  }
+
+  void SetVecLanePosition(int32 pos) {
+    vecLane = static_cast<int16>(pos);
+  }
+
+  int32 GetVecLanePosition() const {
+    return vecLane;
+  }
+
+  void SetVecLaneSize(uint32 size) {
+    vecLaneSize = static_cast<uint16>(size);
+  }
+
+  uint32 GetVecLaneSize() const {
+    return vecLaneSize;
+  }
+
+  void SetVecElementSize(uint32 size) {
+    vecElementSize = size;
+  }
+
+  uint64 GetVecElementSize() const {
+    return vecElementSize;
+  }
+
+  void SetHigh8Bit() {
+    isHigh8Bit = true;
+  }
+
+  bool IsHigh8Bit() {
+    return isHigh8Bit;
+  }
+
+  bool operator==(const RegOperand &o) const;
+
+  bool operator<(const RegOperand &o) const;
+
+ protected:
+  regno_t regNO;
+  RegType regType;
+
+  /*
+   * used for EBO(-O1), it can recognize the registers whose use and def are in different BB. It is
+   * true by default. Sometime it should be false such as when handle intrinsiccall for target
+   * aarch64(AArch64CGFunc::SelectIntrinCall).
+   */
+  bool isBBLocal = true;
+  uint32 validBitsNum;
+  /* use for SSA analysis */
+  bool isSSAForm = false;
+  bool isRefField = false;
+  uint32 regFlag = 0;
+  int16 vecLane = -1;     /* -1 for whole reg, 0 to 15 to specify each lane one at a time */
+  uint16 vecLaneSize = 0; /* Number of lanes */
+  uint64 vecElementSize = 0;  /* size of vector element in each lane */
+  bool if64Vec = false;   /* operand returning 64x1's int value in FP/Simd register */
+  bool isHigh8Bit = false;
+}; /* class RegOperand */
+
+enum VaryType : uint8 {
+  kNotVary = 0,
+  kUnAdjustVary,
+  kAdjustVary,
+};
+
+class ImmOperand : public OperandVisitable<ImmOperand> {
+ public:
+  ImmOperand(int64 val, uint32 size, bool isSigned, VaryType isVar = kNotVary, bool isFloat = false)
+      : OperandVisitable(kOpdImmediate, size), value(val), isSigned(isSigned), isVary(isVar), isFmov(isFloat) {}
+  ImmOperand(OperandType type, int64 val, uint32 size, bool isSigned, VaryType isVar = kNotVary, bool isFloat = false)
+      : OperandVisitable(type, size), value(val), isSigned(isSigned), isVary(isVar), isFmov(isFloat) {}
+  ImmOperand(const MIRSymbol &symbol, int64 val, int32 relocs, bool isSigned, VaryType isVar = kNotVary,
+      bool isFloat = false) : OperandVisitable(kOpdStImmediate, 0), value(val), isSigned(isSigned), isVary(isVar),
+      isFmov(isFloat), symbol(&symbol), relocs(relocs) {}
+  ~ImmOperand() override = default;
+  using OperandVisitable<ImmOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<ImmOperand>(*this);
+  }
+
+  const MIRSymbol *GetSymbol() const {
+    return symbol;
+  }
+
+  const std::string &GetName() const {
+    return symbol->GetName();
+  }
+
+  int32 GetRelocs() const {
+    return relocs;
+  }
+
+  bool IsInBitSize(uint8 size, uint8 nLowerZeroBits) const {
+    return maplebe::IsBitSizeImmediate(static_cast<uint64>(value), size, nLowerZeroBits);
+  }
+
+  bool IsBitmaskImmediate() const {
+    ASSERT(!IsZero(), " 0 is reserved for bitmask immediate");
+    ASSERT(!IsAllOnes(), " -1 is reserved for bitmask immediate");
+    return maplebe::IsBitmaskImmediate(static_cast<uint64>(value), static_cast<uint32>(size));
+  }
+
+  bool IsBitmaskImmediate(uint32 destSize) const {
+    ASSERT(!IsZero(), " 0 is reserved for bitmask immediate");
+    ASSERT(!IsAllOnes(), " -1 is reserved for bitmask immediate");
+    return maplebe::IsBitmaskImmediate(static_cast<uint64>(value), static_cast<uint32>(destSize));
+  }
+
+  bool IsSingleInstructionMovable() const {
+    return (IsMoveWidableImmediate(static_cast<uint64>(value), static_cast<uint32>(size)) ||
+            IsMoveWidableImmediate(~static_cast<uint64>(value), static_cast<uint32>(size)) ||
+            IsBitmaskImmediate());
+  }
+
+  bool IsSingleInstructionMovable(uint32 destSize) const {
+    return (IsMoveWidableImmediate(static_cast<uint64>(value), static_cast<uint32>(destSize)) ||
+            IsMoveWidableImmediate(~static_cast<uint64>(value), static_cast<uint32>(destSize)) ||
+            IsBitmaskImmediate(destSize));
+  }
+
+  int64 GetValue() const {
+    return value;
+  }
+
+  void SetValue(int64 val) {
+    value = val;
+  }
+
+  void SetVary(VaryType flag) {
+    isVary = flag;
+  }
+
+  bool IsZero() const {
+    return value == 0;
+  }
+
+  VaryType GetVary() const {
+    return isVary;
+  }
+
+  bool IsOne() const {
+    return value == 1;
+  }
+
+  bool IsSignedValue() const {
+    return isSigned;
+  }
+
+  void SetSigned() {
+    isSigned = true;
+  }
+
+  void SetSigned(bool flag) {
+    isSigned = flag;
+  }
+
+  bool IsInBitSizeRot(uint8 size) const {
+    return IsInBitSizeRot(size, value);
+  }
+
+  static bool IsInBitSizeRot(uint8 size, int64 val) {
+    /* to tell if the val is in a rotate window of size */
+#if __GNU_C__ || __clang__
+    if (val == 0) {
+      return true;
+    }
+    int32 start = __builtin_ctzll(static_cast<uint64>(val));
+    int32 end = static_cast<int32>(sizeof(val) * kBitsPerByte - __builtin_clzll(static_cast<uint64>(val)) - 1);
+    return (size >= end - start + 1);
+#else
+    uint8 start = 0;
+    uint8 end = 0;
+    bool isFound = false;
+    CHECK_FATAL(val > 0, "do not perform bit operator operations on signed integers");
+    for (uint8 i = 0; i < k64BitSize; ++i) {
+      /* check whether the ith bit of val is 1 or not */
+      if (((static_cast<uint64>(val) >> i) & 0x1) == 0x1) {
+        if (!isFound) {
+          start = i;
+          end = i;
+          isFound = true;
+        } else {
+          end = i;
+        }
+      }
+    }
+    return !isFound || (size >= (end - start) + 1);
+#endif
+  }
+
+  static bool IsInValueRange(int32 lowVal, int32 highVal, int32 val) {
+    return val >= lowVal && val <= highVal;
+  }
+
+  bool IsNegative() const {
+    return isSigned && value < 0;
+  }
+
+  void Add(int64 delta) {
+    value += delta;
+  }
+
+  void Negate() {
+    value = -value;
+  }
+
+  void BitwiseNegate() {
+    value = ~(static_cast<uint64>(value)) & ((1ULL << size) - 1UL);
+  }
+
+  void DivideByPow2(uint32 shift) {
+    value = (static_cast<uint64>(value)) >> shift;
+  }
+
+  void ModuloByPow2(uint32 shift) {
+    value = (static_cast<uint64>(value)) & ((1ULL << shift) - 1UL);
+  }
+
+  bool IsAllOnes() const {
+    return value == -1;
+  }
+
+  bool IsAllOnes32bit() const {
+    return value == 0x0ffffffffLL;
+  }
+
+  bool operator<(const ImmOperand &iOpnd) const {
+    return value < iOpnd.value || (value == iOpnd.value && iOpnd.isSigned) ||
+        (value == iOpnd.value && isSigned == iOpnd.isSigned && size < iOpnd.GetSize());
+  }
+
+  bool operator==(const ImmOperand &iOpnd) const {
+    return (value == iOpnd.value && isSigned == iOpnd.isSigned && size == iOpnd.GetSize());
+  }
+
+  void Dump() const override;
+
+  bool Less(const Operand &right) const override {
+    if (&right == this) {
+      return false;
+    }
+
+    /* For different type. */
+    if (opndKind != right.GetKind()) {
+      return opndKind < right.GetKind();
+    }
+
+    auto *rightOpnd = static_cast<const ImmOperand*>(&right);
+
+    /* The same type. */
+    if (isSigned != rightOpnd->isSigned) {
+      return isSigned;
+    }
+
+    if (isVary != rightOpnd->isVary) {
+      return isVary;
+    }
+
+    return value < rightOpnd->value;
+  }
+
+  bool Equals(Operand &operand) const override {
+    if (!operand.IsImmediate()) {
+      return false;
+    }
+    auto &op = static_cast<ImmOperand&>(operand);
+    if (&op == this) {
+      return true;
+    }
+    return (BasicEquals(op) && value == op.GetValue() && isSigned == op.IsSignedValue());
+  }
+
+  std::string GetHashContent() const override {
+    return std::to_string(opndKind) + std::to_string(value) + std::to_string(static_cast<int>(isSigned)) +
+        std::to_string(static_cast<int>(isVary)) + std::to_string(static_cast<int>(isFmov));
+  }
+
+  bool ValueEquals(const ImmOperand &op) const {
+    if (&op == this) {
+      return true;
+    }
+    return (value == op.GetValue() && isSigned == op.IsSignedValue());
+  }
+  bool IsFmov() const {
+    return isFmov;
+  }
+
+ protected:
+  int64 value;
+  bool isSigned;
+  VaryType isVary;
+  bool isFmov = false;
+  const MIRSymbol *symbol; /* for Immediate in symbol form */
+  int32 relocs;
+};
+
+class OfstOperand : public ImmOperand {
+ public:
+  enum OfstType : uint8 {
+    kSymbolOffset,
+    kImmediateOffset,
+    kSymbolImmediateOffset,
+  };
+
+  /* only for symbol offset */
+  OfstOperand(const MIRSymbol &mirSymbol, uint32 size, int32 relocs)
+      : ImmOperand(kOpdOffset, 0, size, true, kNotVary, false),
+        offsetType(kSymbolOffset), symbol(&mirSymbol), relocs(relocs) {}
+  /* only for Immediate offset */
+  OfstOperand(int64 val, uint32 size, VaryType isVar = kNotVary)
+      : ImmOperand(kOpdOffset, static_cast<int64>(val), size, true, isVar, false),
+        offsetType(kImmediateOffset), symbol(nullptr), relocs(0) {}
+  /* for symbol and Immediate offset */
+  OfstOperand(const MIRSymbol &mirSymbol, int64 val, uint32 size, int32 relocs, VaryType isVar = kNotVary)
+      : ImmOperand(kOpdOffset, val, size, true, isVar, false),
+        offsetType(kSymbolImmediateOffset),
+        symbol(&mirSymbol),
+        relocs(relocs) {}
+
+  ~OfstOperand() override {
+    symbol = nullptr;
+  }
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<OfstOperand>(*this);
+  }
+
+  bool IsSymOffset() const {
+    return offsetType == kSymbolOffset;
+  }
+  bool IsImmOffset() const {
+    return offsetType == kImmediateOffset;
+  }
+  bool IsSymAndImmOffset() const {
+    return offsetType == kSymbolImmediateOffset;
+  }
+
+  const MIRSymbol *GetSymbol() const {
+    return symbol;
+  }
+
+  const std::string &GetSymbolName() const {
+    return symbol->GetName();
+  }
+
+  int64 GetOffsetValue() const {
+    return GetValue();
+  }
+
+  void SetOffsetValue(int32 offVal) {
+    SetValue(static_cast<int64>(offVal));
+  }
+
+  void AdjustOffset(int32 delta) {
+    Add(static_cast<int64>(delta));
+  }
+
+  bool operator==(const OfstOperand &opnd) const {
+    return (offsetType == opnd.offsetType && symbol == opnd.symbol &&
+            ImmOperand::operator==(opnd) && relocs == opnd.relocs);
+  }
+
+  bool operator<(const OfstOperand &opnd) const {
+    return (offsetType < opnd.offsetType ||
+            (offsetType == opnd.offsetType && symbol < opnd.symbol) ||
+            (offsetType == opnd.offsetType && symbol == opnd.symbol && GetValue() < opnd.GetValue()));
+  }
+
+  void Dump() const override {
+    if (IsImmOffset()) {
+      LogInfo::MapleLogger() << "ofst:" << GetValue();
+    } else {
+      LogInfo::MapleLogger() << GetSymbolName();
+      LogInfo::MapleLogger() << "+offset:" << GetValue();
+    }
+  }
+
+  std::string GetHashContent() const override {
+    return ImmOperand::GetHashContent() + std::to_string(offsetType) + std::to_string(relocs);
+  }
+
+ private:
+  OfstType offsetType;
+  const MIRSymbol *symbol;
+  int32 relocs;
+};
+
+/*
+ * Table C1-6 A64 Load/Store addressing modes
+ * |         Offset
+ * Addressing Mode    | Immediate     | Register             | Extended Register
+ *
+ * Base register only | [base{,#0}]   | -                    | -
+ * (no offset)        | B_OI_NONE     |                      |
+ *                   imm=0
+ *
+ * Base plus offset   | [base{,#imm}] | [base,Xm{,LSL #imm}] | [base,Wm,(S|U)XTW {#imm}]
+ *                  B_OI_NONE     | B_OR_X               | B_OR_X
+ *                                   imm=0,1 (0,3)        | imm=00,01,10,11 (0/2,s/u)
+ *
+ * Pre-indexed        | [base, #imm]! | -                    | -
+ *
+ * Post-indexed       | [base], #imm  | [base], Xm(a)        | -
+ *
+ * Literal            | label         | -                    | -
+ * (PC-relative)
+ *
+ * a) The post-indexed by register offset mode can be used with the SIMD Load/Store
+ * structure instructions described in Load/Store Vector on page C3-154. Otherwise
+ * the post-indexed by register offset mode is not available.
+ */
+class MemOperand : public OperandVisitable<MemOperand> {
+ public:
+  enum AArch64AddressingMode : uint8 {
+    kAddrModeUndef,
+    /* AddrMode_BO, base, offset. EA = [base] + offset; */
+    kAddrModeBOi,  /* INTACT: EA = [base]+immediate */
+    /*
+     * PRE: base += immediate, EA = [base]
+     * POST: EA = [base], base += immediate
+     */
+    kAddrModeBOrX,  /* EA = [base]+Extend([offreg/idxreg]), OR=Wn/Xn */
+    kAddrModeLiteral,  /* AArch64 insruction LDR takes literal and */
+    /*
+     * "calculates an address from the PC value and an immediate offset,
+     * loads a word from memory, and writes it to a register."
+     */
+    kAddrModeLo12Li  // EA = [base] + #:lo12:Label+immediate. (Example: [x0, #:lo12:__Label300+456]
+  };
+  /*
+   * ARMv8-A A64 ISA Overview by Matteo Franchin @ ARM
+   * (presented at 64-bit Android on ARM. Sep. 2015) p.14
+   * o Address to load from/store to is a 64-bit base register + an optional offset
+   *   LDR X0, [X1] ; Load from address held in X1
+   *   STR X0, [X1] ; Store to address held in X1
+   *
+   * o Offset can be an immediate or a register
+   *   LDR X0, [X1, #8]  ; Load from address [X1 + 8 bytes]
+   *   LDR X0, [X1, #-8] ; Load with negative offset
+   *   LDR X0, [X1, X2]  ; Load from address [X1 + X2]
+   *
+   * o A Wn register offset needs to be extended to 64 bits
+   *  LDR X0, [X1, W2, SXTW] ; Sign-extend offset in W2
+   *   LDR X0, [X1, W2, UXTW] ; Zero-extend offset in W2
+   *
+   * o Both Xn and Wn register offsets can include an optional left-shift
+   *   LDR X0, [X1, W2, UXTW #2] ; Zero-extend offset in W2 & left-shift by 2
+   *   LDR X0, [X1, X2, LSL #2]  ; Left-shift offset in X2 by 2
+   *
+   * p.15
+   * Addressing Modes                       Analogous C Code
+   *                                       int *intptr = ... // X1
+   *                                       int out; // W0
+   * o Simple: X1 is not changed
+   *   LDR W0, [X1]                        out = *intptr;
+   * o Offset: X1 is not changed
+   *   LDR W0, [X1, #4]                    out = intptr[1];
+   * o Pre-indexed: X1 changed before load
+   *   LDR W0, [X1, #4]! =|ADD X1,X1,#4    out = *(++intptr);
+   * |LDR W0,[X1]
+   * o Post-indexed: X1 changed after load
+   *   LDR W0, [X1], #4  =|LDR W0,[X1]     out = *(intptr++);
+   * |ADD X1,X1,#4
+   */
+  enum ExtendInfo : uint8 {
+    kShiftZero = 0x1,
+    kShiftOne = 0x2,
+    kShiftTwo = 0x4,
+    kShiftThree = 0x8,
+    kUnsignedExtend = 0x10,
+    kSignExtend = 0x20
+  };
+
+  enum IndexingOption : uint8 {
+    kIntact,     /* base register stays the same */
+    kPreIndex,   /* base register gets changed before load */
+    kPostIndex,  /* base register gets changed after load */
+  };
+
+  MemOperand(uint32 size) :
+      OperandVisitable(Operand::kOpdMem, size) {}
+  MemOperand(uint32 size, const MIRSymbol &mirSymbol) : OperandVisitable(Operand::kOpdMem, size), symbol(&mirSymbol) {}
+
+  MemOperand(uint32 size, RegOperand *baseOp, RegOperand *indexOp, ImmOperand *ofstOp, const MIRSymbol *mirSymbol,
+             ImmOperand *scaleOp = nullptr)
+      : OperandVisitable(Operand::kOpdMem, size),
+        baseOpnd(baseOp),
+        indexOpnd(indexOp),
+        offsetOpnd(ofstOp),
+        scaleOpnd(scaleOp),
+        symbol(mirSymbol) {}
+
+  MemOperand(RegOperand *base, OfstOperand *offset, uint32 size, IndexingOption idxOpt = kIntact)
+      : OperandVisitable(Operand::kOpdMem, size),
+        baseOpnd(base),
+        indexOpnd(nullptr),
+        offsetOpnd(offset),
+        symbol(nullptr),
+        addrMode(kAddrModeBOi),
+        extend(0),
+        idxOpt(idxOpt),
+        noExtend(false),
+        isStackMem(false) {}
+
+  MemOperand(AArch64AddressingMode mode, uint32 size, RegOperand &base, RegOperand *index,
+             ImmOperand *offset, const MIRSymbol *sym)
+      : OperandVisitable(Operand::kOpdMem, size),
+        baseOpnd(&base),
+        indexOpnd(index),
+        offsetOpnd(offset),
+        symbol(sym),
+        addrMode(mode),
+        extend(0),
+        idxOpt(kIntact),
+        noExtend(false),
+        isStackMem(false) {}
+
+  MemOperand(AArch64AddressingMode mode, uint32 size, RegOperand &base, RegOperand &index,
+             ImmOperand *offset, const MIRSymbol &sym, bool noExtend)
+      : OperandVisitable(Operand::kOpdMem, size),
+        baseOpnd(&base),
+        indexOpnd(&index),
+        offsetOpnd(offset),
+        symbol(&sym),
+        addrMode(mode),
+        extend(0),
+        idxOpt(kIntact),
+        noExtend(noExtend),
+        isStackMem(false) {}
+
+  MemOperand(AArch64AddressingMode mode, uint32 dSize, RegOperand &baseOpnd, RegOperand &indexOpnd,
+             uint32 shift, bool isSigned = false)
+      : OperandVisitable(Operand::kOpdMem, dSize),
+        baseOpnd(&baseOpnd),
+        indexOpnd(&indexOpnd),
+        offsetOpnd(nullptr),
+        symbol(nullptr),
+        addrMode(mode),
+        extend((isSigned ? kSignExtend : kUnsignedExtend) | (1U << shift)),
+        idxOpt(kIntact),
+        noExtend(false),
+        isStackMem(false) {}
+
+  MemOperand(AArch64AddressingMode mode, uint32 dSize, const MIRSymbol &sym)
+      : OperandVisitable(Operand::kOpdMem, dSize),
+        baseOpnd(nullptr),
+        indexOpnd(nullptr),
+        offsetOpnd(nullptr),
+        symbol(&sym),
+        addrMode(mode),
+        extend(0),
+        idxOpt(kIntact),
+        noExtend(false),
+        isStackMem(false) {
+    ASSERT(mode == kAddrModeLiteral, "This constructor version is supposed to be used with AddrMode_Literal only");
+  }
+
+  /* Copy constructor */
+  explicit MemOperand(const MemOperand &memOpnd)
+      : OperandVisitable(Operand::kOpdMem, memOpnd.GetSize()),
+        baseOpnd(memOpnd.baseOpnd),
+        indexOpnd(memOpnd.indexOpnd),
+        offsetOpnd(memOpnd.offsetOpnd),
+        scaleOpnd(memOpnd.scaleOpnd),
+        symbol(memOpnd.symbol),
+        memoryOrder(memOpnd.memoryOrder),
+        addrMode(memOpnd.addrMode),
+        extend(memOpnd.extend),
+        idxOpt(memOpnd.idxOpt),
+        noExtend(memOpnd.noExtend),
+        isStackMem(memOpnd.isStackMem),
+        isStackArgMem(memOpnd.isStackArgMem) {}
+
+  MemOperand &operator=(const MemOperand &memOpnd) = default;
+
+  ~MemOperand() override = default;
+  using OperandVisitable<MemOperand>::OperandVisitable;
+
+  MemOperand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<MemOperand>(*this);
+  }
+
+  void Dump() const override {};
+
+  RegOperand *GetBaseRegister() const {
+    return baseOpnd;
+  }
+
+  void SetBaseRegister(RegOperand &regOpnd) {
+    baseOpnd = &regOpnd;
+  }
+
+  RegOperand *GetIndexRegister() const {
+    return indexOpnd;
+  }
+
+  void SetIndexRegister(RegOperand &regOpnd) {
+    indexOpnd = &regOpnd;
+  }
+
+  ImmOperand *GetOffsetOperand() const {
+    return offsetOpnd;
+  }
+
+  void SetOffsetOperand(ImmOperand &oftOpnd) {
+    offsetOpnd = &oftOpnd;
+  }
+
+  const ImmOperand *GetScaleOperand() const {
+    return scaleOpnd;
+  }
+
+  void SetScaleOperand(ImmOperand &scaOpnd) {
+    scaleOpnd = &scaOpnd;
+  }
+
+  const MIRSymbol *GetSymbol() const {
+    return symbol;
+  }
+
+  void SetMemoryOrdering(uint32 memOrder) {
+    memoryOrder |= memOrder;
+  }
+
+  bool HasMemoryOrdering(uint32 memOrder) const {
+    return (memoryOrder & memOrder) != 0;
+  }
+
+  void SetAccessSize(uint32 size) {
+    accessSize = size;
+  }
+
+  uint8 GetAccessSize() const {
+    return accessSize;
+  }
+
+  AArch64AddressingMode GetAddrMode() const {
+    return addrMode;
+  }
+
+  const std::string &GetSymbolName() const {
+    return GetSymbol()->GetName();
+  }
+
+  bool IsStackMem() const {
+    return isStackMem;
+  }
+
+  void SetStackMem(bool isStack) {
+    isStackMem = isStack;
+  }
+
+  bool IsStackArgMem() const {
+    return isStackArgMem;
+  }
+
+  void SetStackArgMem(bool isStackArg) {
+    isStackArgMem = isStackArg;
+  }
+
+  Operand *GetOffset() const;
+
+  OfstOperand *GetOffsetImmediate() const {
+    return static_cast<OfstOperand*>(GetOffsetOperand());
+  }
+
+  /* Returns N where alignment == 2^N */
+  static int32 GetImmediateOffsetAlignment(uint32 dSize) {
+    ASSERT(dSize >= k8BitSize, "error val:dSize");
+    ASSERT(dSize <= k128BitSize, "error val:dSize");
+    ASSERT((dSize & (dSize - 1)) == 0, "error val:dSize");
+    /* dSize==8: 0, dSize==16 : 1, dSize==32: 2, dSize==64: 3 */
+    return __builtin_ctz(dSize) - static_cast<int32>(kBaseOffsetAlignment);
+  }
+
+  static int32 GetMaxPIMM(uint32 dSize) {
+    dSize = dSize > k64BitSize ? k64BitSize : dSize;
+    ASSERT(dSize >= k8BitSize, "error val:dSize");
+    ASSERT(dSize <= k128BitSize, "error val:dSize");
+    ASSERT((dSize & (dSize - 1)) == 0, "error val:dSize");
+    int32 alignment = GetImmediateOffsetAlignment(dSize);
+    /* alignment is between kAlignmentOf8Bit and kAlignmentOf64Bit */
+    ASSERT(alignment >= kOffsetAlignmentOf8Bit, "error val:alignment");
+    ASSERT(alignment <= kOffsetAlignmentOf128Bit, "error val:alignment");
+    return (kMaxPimm[alignment]);
+  }
+
+  static int32 GetMaxPairPIMM(uint32 dSize) {
+    ASSERT(dSize >= k32BitSize, "error val:dSize");
+    ASSERT(dSize <= k128BitSize, "error val:dSize");
+    ASSERT((dSize & (dSize - 1)) == 0, "error val:dSize");
+    int32 alignment = GetImmediateOffsetAlignment(dSize);
+    /* alignment is between kAlignmentOf8Bit and kAlignmentOf64Bit */
+    ASSERT(alignment >= kOffsetAlignmentOf32Bit, "error val:alignment");
+    ASSERT(alignment <= kOffsetAlignmentOf128Bit, "error val:alignment");
+    return (kMaxPairPimm[static_cast<uint32>(alignment) - k2BitSize]);
+  }
+
+  bool IsOffsetMisaligned(uint32 dSize) const {
+    ASSERT(dSize >= k8BitSize, "error val:dSize");
+    ASSERT(dSize <= k128BitSize, "error val:dSize");
+    ASSERT((dSize & (dSize - 1)) == 0, "error val:dSize");
+    if (dSize == k8BitSize) {
+      return false;
+    }
+    OfstOperand *ofstOpnd = GetOffsetImmediate();
+    if (!ofstOpnd) {
+      return false;
+    }
+    int64 ofstVal = ofstOpnd->GetOffsetValue();
+    if (addrMode == kAddrModeBOi) {
+      if (ofstVal >= kMinSimm32 && ofstVal <= kMaxSimm32) {
+        return false;
+      }
+      return ((static_cast<uint32>(ofstOpnd->GetOffsetValue()) &
+              static_cast<uint32>((1U << static_cast<uint32>(GetImmediateOffsetAlignment(dSize))) - 1)) != 0);
+    } else if (addrMode == kAddrModeLo12Li) {
+      uint32 alignByte = (dSize / k8BitSize);
+      return ((ofstVal % alignByte) != k0BitSize);
+    }
+    return false;
+  }
+
+  static bool IsSIMMOffsetOutOfRange(int64 offset, bool is64bit, bool isLDSTPair) {
+    if (!isLDSTPair) {
+      return (offset < kMinSimm32 || offset > kMaxSimm32);
+    }
+    if (is64bit) {
+      return (offset < kMinSimm64 || offset > kMaxSimm64Pair) || ((static_cast<uint64>(offset) & k7BitSize) != 0);
+    }
+    return (offset < kMinSimm32 || offset > kMaxSimm32Pair) || ((static_cast<uint64>(offset) & k3BitSize) != 0);
+  }
+
+  static bool IsPIMMOffsetOutOfRange(int32 offset, uint32 dSize) {
+    ASSERT(dSize >= k8BitSize, "error val:dSize");
+    ASSERT(dSize <= k128BitSize, "error val:dSize");
+    ASSERT((dSize & (dSize - 1)) == 0, "error val:dSize");
+    return (offset < 0 || offset > GetMaxPIMM(dSize));
+  }
+
+  bool operator<(const MemOperand &opnd) const {
+    return addrMode < opnd.addrMode ||
+           (addrMode == opnd.addrMode && GetBaseRegister() < opnd.GetBaseRegister()) ||
+           (addrMode == opnd.addrMode && GetBaseRegister() == opnd.GetBaseRegister() &&
+            GetIndexRegister() < opnd.GetIndexRegister()) ||
+           (addrMode == opnd.addrMode && GetBaseRegister() == opnd.GetBaseRegister() &&
+            GetIndexRegister() == opnd.GetIndexRegister() && GetOffsetOperand() < opnd.GetOffsetOperand()) ||
+           (addrMode == opnd.addrMode && GetBaseRegister() == opnd.GetBaseRegister() &&
+            GetIndexRegister() == opnd.GetIndexRegister() && GetOffsetOperand() == opnd.GetOffsetOperand() &&
+            GetSymbol() < opnd.GetSymbol()) ||
+           (addrMode == opnd.addrMode && GetBaseRegister() == opnd.GetBaseRegister() &&
+            GetIndexRegister() == opnd.GetIndexRegister() && GetOffsetOperand() == opnd.GetOffsetOperand() &&
+            GetSymbol() == opnd.GetSymbol() && GetSize() < opnd.GetSize()) ||
+           (addrMode == opnd.addrMode && GetBaseRegister() == opnd.GetBaseRegister() &&
+            GetIndexRegister() == opnd.GetIndexRegister() && GetOffsetOperand() == opnd.GetOffsetOperand() &&
+            GetSymbol() == opnd.GetSymbol() && GetSize() == opnd.GetSize() && extend < opnd.extend);
+  }
+
+  bool operator==(const MemOperand &opnd) const {
+    return  (GetSize() == opnd.GetSize()) && (addrMode == opnd.addrMode) && (extend == opnd.extend) &&
+            (GetBaseRegister() == opnd.GetBaseRegister()) &&
+            (GetIndexRegister() == opnd.GetIndexRegister()) &&
+            (GetSymbol() == opnd.GetSymbol()) &&
+            (GetOffsetOperand() == opnd.GetOffsetOperand()) ;
+  }
+
+  VaryType GetMemVaryType() const {
+    Operand *ofstOpnd = GetOffsetOperand();
+    if (ofstOpnd != nullptr) {
+      auto *opnd = static_cast<OfstOperand*>(ofstOpnd);
+      return opnd->GetVary();
+    }
+    return kNotVary;
+  }
+
+  void SetAddrMode(AArch64AddressingMode val) {
+    addrMode = val;
+  }
+
+  bool IsExtendedRegisterMode() const {
+    return addrMode == kAddrModeBOrX;
+  }
+
+  void UpdateExtend(ExtendInfo flag) {
+    extend = flag | (1U << ShiftAmount());
+  }
+
+  bool SignedExtend() const {
+    return IsExtendedRegisterMode() && ((extend & kSignExtend) != 0);
+  }
+
+  bool UnsignedExtend() const {
+    return IsExtendedRegisterMode() && !SignedExtend();
+  }
+
+  uint32 ShiftAmount() const {
+    uint32 scale = extend & 0xF;
+    /* 8 is 1 << 3, 4 is 1 << 2, 2 is 1 << 1, 1 is 1 << 0; */
+    return (scale == 8) ? 3 : ((scale == 4) ? 2 : ((scale == 2) ? 1 : 0));
+  }
+
+  bool ShouldEmitExtend() const {
+    return !noExtend && ((extend & 0x3F) != 0);
+  }
+
+  IndexingOption GetIndexOpt() const {
+    return idxOpt;
+  }
+
+  void SetIndexOpt(IndexingOption newidxOpt) {
+    idxOpt = newidxOpt;
+  }
+
+  bool GetNoExtend() const {
+    return noExtend;
+  }
+
+  void SetNoExtend(bool val) {
+    noExtend = val;
+  }
+
+  uint32 GetExtend() const {
+    return extend;
+  }
+
+  void SetExtend(uint32 val) {
+    extend = val;
+  }
+
+  bool IsIntactIndexed() const {
+    return idxOpt == kIntact;
+  }
+
+  bool IsPostIndexed() const {
+    return idxOpt == kPostIndex;
+  }
+
+  bool IsPreIndexed() const {
+    return idxOpt == kPreIndex;
+  }
+
+  std::string GetExtendAsString() const {
+    if (GetIndexRegister()->GetSize() == k64BitSize) {
+      return std::string("LSL");
+    }
+    return ((extend & kSignExtend) != 0) ? std::string("SXTW") : std::string("UXTW");
+  }
+
+  /* Return true if given operand has the same base reg and offset with this. */
+  bool Equals(Operand &op) const override;
+  bool Equals(const MemOperand &op) const;
+  bool Less(const Operand &right) const override;
+
+ private:
+  RegOperand *baseOpnd = nullptr;    /* base register */
+  RegOperand *indexOpnd = nullptr;   /* index register */
+  ImmOperand *offsetOpnd = nullptr; /* offset immediate */
+  ImmOperand *scaleOpnd = nullptr;
+  const MIRSymbol *symbol; /* AddrMode_Literal */
+  uint32 memoryOrder = 0;
+  uint8 accessSize = 0; /* temp, must be set right before use everytime. */
+  AArch64AddressingMode addrMode = kAddrModeBOi;
+  uint32 extend = false;        /* used with offset register ; AddrMode_B_OR_X */
+  IndexingOption idxOpt = kIntact;  /* used with offset immediate ; AddrMode_B_OI */
+  bool noExtend = false;
+  bool isStackMem = false;
+  bool isStackArgMem = false;
+};
+
+class LabelOperand : public OperandVisitable<LabelOperand> {
+ public:
+  LabelOperand(const char *parent, LabelIdx labIdx, MemPool &mp)
+      : OperandVisitable(kOpdBBAddress, 0), labelIndex(labIdx), parentFunc(parent, &mp), orderID(-1u) {}
+
+  ~LabelOperand() override = default;
+  using OperandVisitable<LabelOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<LabelOperand>(*this);
+  }
+
+  bool IsLabelOpnd() const override {
+    return true;
+  }
+
+  LabelIdx GetLabelIndex() const {
+    return labelIndex;
+  }
+
+  const MapleString &GetParentFunc() const {
+    return parentFunc;
+  }
+
+  LabelIDOrder GetLabelOrder() const {
+    return orderID;
+  }
+
+  void SetLabelOrder(LabelIDOrder idx) {
+    orderID = idx;
+  }
+
+  void Dump() const override;
+
+  bool Less(const Operand &right) const override {
+    if (&right == this) {
+      return false;
+    }
+
+    /* For different type. */
+    if (opndKind != right.GetKind()) {
+      return opndKind < right.GetKind();
+    }
+
+    auto *rightOpnd = static_cast<const LabelOperand*>(&right);
+
+    int32 nRes = strcmp(parentFunc.c_str(), rightOpnd->parentFunc.c_str());
+    if (nRes == 0) {
+      return labelIndex < rightOpnd->labelIndex;
+    } else {
+      return nRes < 0;
+    }
+  }
+
+  bool Equals(Operand &operand) const override {
+    if (!operand.IsLabel()) {
+      return false;
+    }
+    auto &op = static_cast<LabelOperand&>(operand);
+    return ((&op == this) || (op.GetLabelIndex() == labelIndex));
+  }
+
+ protected:
+  LabelIdx labelIndex;
+  const MapleString parentFunc;
+
+ private:
+  /* this index records the order this label is defined during code emit. */
+  LabelIDOrder orderID = -1u;
+};
+
+class ListOperand : public OperandVisitable<ListOperand> {
+ public:
+  explicit ListOperand(MapleAllocator &allocator)
+      : OperandVisitable(Operand::kOpdList, 0),
+        opndList(allocator.Adapter()) {}
+
+  ~ListOperand() override = default;
+
+  using OperandVisitable<ListOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<ListOperand>(*this);
+  }
+
+  void PushOpnd(RegOperand &opnd) {
+    opndList.push_back(&opnd);
+  }
+
+  MapleList<RegOperand*> &GetOperands() {
+    return opndList;
+  }
+
+  const MapleList<RegOperand*> &GetOperands() const {
+    return opndList;
+  }
+
+  void Dump() const override {
+    for (auto it = opndList.begin(); it != opndList.end();) {
+      (*it)->Dump();
+      LogInfo::MapleLogger() << (++it == opndList.end() ? "" : " ,");
+    }
+  }
+
+  bool Less(const Operand &right) const override {
+    /* For different type. */
+    if (opndKind != right.GetKind()) {
+      return opndKind < right.GetKind();
+    }
+
+    ASSERT(false, "We don't need to compare list operand.");
+    return false;
+  }
+
+  bool Equals(Operand &operand) const override {
+    if (!operand.IsList()) {
+      return false;
+    }
+    auto &op = static_cast<ListOperand&>(operand);
+    return (&op == this);
+  }
+
+ protected:
+  MapleList<RegOperand*> opndList;
+};
+
+/* representing for global variables address */
+class StImmOperand : public OperandVisitable<StImmOperand> {
+ public:
+  StImmOperand(const MIRSymbol &symbol, int64 offset, int32 relocs)
+      : OperandVisitable(kOpdStImmediate, 0), symbol(&symbol), offset(offset), relocs(relocs) {}
+
+  ~StImmOperand() override = default;
+  using OperandVisitable<StImmOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<StImmOperand>(*this);
+  }
+
+  const MIRSymbol *GetSymbol() const {
+    return symbol;
+  }
+
+  const std::string &GetName() const {
+    return symbol->GetName();
+  }
+
+  int64 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(int64 newOffset) {
+    offset = newOffset;
+  }
+
+  int32 GetRelocs() const {
+    return relocs;
+  }
+
+  bool operator==(const StImmOperand &opnd) const {
+    return (symbol == opnd.symbol && offset == opnd.offset && relocs == opnd.relocs);
+  }
+
+  bool operator<(const StImmOperand &opnd) const {
+    return (symbol < opnd.symbol || (symbol == opnd.symbol && offset < opnd.offset) ||
+            (symbol == opnd.symbol && offset == opnd.offset && relocs < opnd.relocs));
+  }
+
+  bool Less(const Operand &right) const override;
+
+  void Dump() const override {
+    CHECK_FATAL(false, "dont run here");
+  }
+
+ private:
+  const MIRSymbol *symbol;
+  int64 offset;
+  int32 relocs;
+};
+
+class ExtendShiftOperand : public OperandVisitable<ExtendShiftOperand> {
+ public:
+  /* if and only if at least one register is WSP, ARM Recommends use of the LSL operator name rathe than UXTW */
+  enum ExtendOp : uint8 {
+    kUndef,
+    kUXTB,
+    kUXTH,
+    kUXTW, /* equal to lsl in 32bits */
+    kUXTX, /* equal to lsl in 64bits */
+    kSXTB,
+    kSXTH,
+    kSXTW,
+    kSXTX,
+  };
+
+  ExtendShiftOperand(ExtendOp op, uint32 amt, int32 bitLen)
+      : OperandVisitable(Operand::kOpdExtend, bitLen), extendOp(op), shiftAmount(amt) {}
+
+  ~ExtendShiftOperand() override = default;
+  using OperandVisitable<ExtendShiftOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<ExtendShiftOperand>(*this);
+  }
+
+  uint32 GetShiftAmount() const {
+    return shiftAmount;
+  }
+
+  ExtendOp GetExtendOp() const {
+    return extendOp;
+  }
+
+  bool Less(const Operand &right) const override;
+
+  void Dump() const override {
+    CHECK_FATAL(false, "dont run here");
+  }
+
+  bool Equals(Operand &operand) const override {
+    if (!operand.IsOpdExtend()) {
+      return false;
+    }
+    auto &op = static_cast<ExtendShiftOperand&>(operand);
+    return ((&op == this) || (op.GetExtendOp() == extendOp && op.GetShiftAmount() == shiftAmount));
+  }
+
+  std::string GetHashContent() const override {
+    return std::to_string(opndKind) + std::to_string(extendOp) + std::to_string(shiftAmount);
+  }
+
+ private:
+  ExtendOp extendOp;
+  uint32 shiftAmount;
+};
+
+class BitShiftOperand : public OperandVisitable<BitShiftOperand> {
+ public:
+  enum ShiftOp : uint8 {
+    kUndef,
+    kLSL, /* logical shift left */
+    kLSR, /* logical shift right */
+    kASR, /* arithmetic shift right */
+    kROR, /* rotate shift right */
+  };
+
+  /* bitlength is equal to 5 or 6 */
+  BitShiftOperand(ShiftOp op, uint32 amt, int32 bitLen)
+      : OperandVisitable(Operand::kOpdShift, bitLen), shiftOp(op), shiftAmount(amt) {}
+
+  ~BitShiftOperand() override = default;
+  using OperandVisitable<BitShiftOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<BitShiftOperand>(*this);
+  }
+
+  bool Less(const Operand &right) const override {
+    if (&right == this) {
+      return false;
+    }
+
+    /* For different type. */
+    if (GetKind() != right.GetKind()) {
+      return GetKind() < right.GetKind();
+    }
+
+    const BitShiftOperand *rightOpnd = static_cast<const BitShiftOperand*>(&right);
+
+    /* The same type. */
+    if (shiftOp != rightOpnd->shiftOp) {
+      return shiftOp < rightOpnd->shiftOp;
+    }
+    return shiftAmount < rightOpnd->shiftAmount;
+  }
+
+  uint32 GetShiftAmount() const {
+    return shiftAmount;
+  }
+
+  ShiftOp GetShiftOp() const {
+    return shiftOp;
+  }
+
+  void Dump() const override {
+    CHECK_FATAL(false, "dont run here");
+  }
+
+  bool Equals(Operand &operand) const override {
+    if (!operand.IsOpdShift()) {
+      return false;
+    }
+    auto &op = static_cast<BitShiftOperand&>(operand);
+    return ((&op == this) || (op.GetShiftOp() == shiftOp && op.GetShiftAmount() == shiftAmount));
+  }
+
+  std::string GetHashContent() const override {
+    return std::to_string(opndKind) + std::to_string(shiftOp) + std::to_string(shiftAmount);
+  }
+
+ private:
+  ShiftOp shiftOp;
+  uint32 shiftAmount;
+};
+
+class CommentOperand : public OperandVisitable<CommentOperand> {
+ public:
+  CommentOperand(const char *str, MemPool &memPool)
+      : OperandVisitable(Operand::kOpdString, 0), comment(str, &memPool) {}
+
+  CommentOperand(const std::string &str, MemPool &memPool)
+      : OperandVisitable(Operand::kOpdString, 0), comment(str, &memPool) {}
+
+  ~CommentOperand() override = default;
+  using OperandVisitable<CommentOperand>::OperandVisitable;
+
+  const MapleString &GetComment() const {
+    return comment;
+  }
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<CommentOperand>(*this);
+  }
+
+  bool IsCommentOpnd() const override {
+    return true;
+  }
+
+  bool Less(const Operand &right) const override {
+    /* For different type. */
+    return GetKind() < right.GetKind();
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << "# ";
+    if (!comment.empty()) {
+      LogInfo::MapleLogger() << comment;
+    }
+  }
+
+ private:
+  const MapleString comment;
+};
+
+using StringOperand = CommentOperand;
+
+class ListConstraintOperand : public OperandVisitable<ListConstraintOperand> {
+ public:
+  explicit ListConstraintOperand(MapleAllocator &allocator)
+      : OperandVisitable(Operand::kOpdString, 0),
+        stringList(allocator.Adapter()) {};
+
+  ~ListConstraintOperand() override = default;
+  using OperandVisitable<ListConstraintOperand>::OperandVisitable;
+
+  void Dump() const override {
+    for (auto *str : stringList) {
+      LogInfo::MapleLogger() << "(" << str->GetComment().c_str() << ")";
+    }
+  }
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<ListConstraintOperand>(*this);
+  }
+
+  bool Less(const Operand &right) const override {
+    /* For different type. */
+    if (opndKind != right.GetKind()) {
+      return opndKind < right.GetKind();
+    }
+
+    ASSERT(false, "We don't need to compare list operand.");
+    return false;
+  }
+
+  MapleVector<StringOperand*> stringList;
+};
+
+/* for cg ssa analysis */
+class PhiOperand : public OperandVisitable<PhiOperand> {
+ public:
+  explicit PhiOperand(MapleAllocator &allocator)
+      : OperandVisitable(Operand::kOpdPhi, 0),
+        phiList(allocator.Adapter()) {}
+
+  ~PhiOperand() override = default;
+  using OperandVisitable<PhiOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.Clone<PhiOperand>(*this);
+  }
+
+  void Dump() const override {
+    CHECK_FATAL(false, "NIY");
+  }
+
+  void InsertOpnd(uint32 bbId, RegOperand &phiParam) {
+    ASSERT(!phiList.count(bbId), "cannot insert duplicate operand");
+    (void)phiList.emplace(std::pair(bbId, &phiParam));
+  }
+
+  void UpdateOpnd(uint32 bbId, uint32 newId, RegOperand &phiParam) {
+    (void)phiList.emplace(std::pair(newId, &phiParam));
+    phiList.erase(bbId);
+  }
+
+  MapleMap<uint32, RegOperand*> &GetOperands() {
+    return phiList;
+  }
+
+  const MapleMap<uint32, RegOperand*> &GetOperands() const {
+    return phiList;
+  }
+
+  uint32 GetLeastCommonValidBit() const;
+
+  bool IsRedundancy() const;
+
+  bool Less(const Operand &right) const override {
+    /* For different type. */
+    if (opndKind != right.GetKind()) {
+      return opndKind < right.GetKind();
+    }
+    ASSERT(false, "We don't need to compare list operand.");
+    return false;
+  }
+
+  bool Equals(Operand &operand) const override {
+    if (!operand.IsPhi()) {
+      return false;
+    }
+    auto &op = static_cast<PhiOperand&>(operand);
+    return (&op == this);
+  }
+
+ protected:
+  MapleMap<uint32, RegOperand*> phiList; /* ssa-operand && BBId */
+};
+
+/* Use StImmOperand instead? */
+class FuncNameOperand : public OperandVisitable<FuncNameOperand> {
+ public:
+  explicit FuncNameOperand(const MIRSymbol &fsym) : OperandVisitable(kOpdBBAddress, 0),
+      symbol(&fsym) {}
+
+  ~FuncNameOperand() override {
+    symbol = nullptr;
+  }
+  using OperandVisitable<FuncNameOperand>::OperandVisitable;
+
+  const std::string &GetName() const {
+    return symbol->GetName();
+  }
+
+  bool IsFuncNameOpnd() const override {
+    return true;
+  }
+
+  const MIRSymbol *GetFunctionSymbol() const {
+    return symbol;
+  }
+
+  void SetFunctionSymbol(const MIRSymbol &fsym) {
+    symbol = &fsym;
+  }
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.New<FuncNameOperand>(*this);
+  }
+
+  bool Less(const Operand &right) const override {
+    if (&right == this) {
+      return false;
+    }
+    /* For different type. */
+    if (GetKind() != right.GetKind()) {
+      return GetKind() < right.GetKind();
+    }
+
+    auto *rightOpnd = static_cast<const FuncNameOperand*>(&right);
+
+    return static_cast<const void*>(symbol) < static_cast<const void*>(rightOpnd->symbol);
+  }
+
+  void Dump() const override {
+    LogInfo::MapleLogger() << GetName();
+  }
+
+ private:
+  const MIRSymbol *symbol;
+};
+
+namespace operand {
+/* bit 0-7 for common */
+enum CommOpndDescProp : maple::uint64 {
+  kIsDef = 1ULL,
+  kIsUse = (1ULL << 1),
+  kIsVector = (1ULL << 2)
+
+};
+
+/* bit 8-15 for reg */
+enum RegOpndDescProp : maple::uint64 {
+  kInt = (1ULL << 8),
+  kFloat = (1ULL << 9),
+  kRegTyCc = (1ULL << 10),
+  kRegTyVary = (1ULL << 11),
+};
+
+/* bit 16-23 for imm */
+enum ImmOpndDescProp : maple::uint64 {
+
+};
+
+/* bit 24-31 for mem */
+enum MemOpndDescProp : maple::uint64 {
+  kMemLow12 = (1ULL << 24),
+  kLiteralLow12 = kMemLow12,
+  kIsLoadLiteral = (1ULL << 25)
+
+};
+}
+
+class OpndDesc {
+ public:
+  OpndDesc(Operand::OperandType t, maple::uint64 p, maple::uint32 s) : opndType(t), property(p), size(s) {}
+  virtual ~OpndDesc() = default;
+
+  Operand::OperandType GetOperandType() const {
+    return opndType;
+  }
+
+  maple::uint32 GetSize() const {
+    return size;
+  }
+
+  bool IsImm() const {
+    return opndType == Operand::kOpdImmediate;
+  }
+
+  bool IsRegister() const {
+    return opndType == Operand::kOpdRegister;
+  }
+
+  bool IsMem() const {
+    return opndType == Operand::kOpdMem;
+  }
+
+  bool IsRegDef() const {
+    return opndType == Operand::kOpdRegister && ((property & operand::kIsDef) != 0);
+  }
+
+  bool IsRegUse() const {
+    return opndType == Operand::kOpdRegister && ((property & operand::kIsUse) != 0);
+  }
+
+  bool IsDef() const {
+    return (property & operand::kIsDef) != 0;
+  }
+
+  bool IsUse() const {
+    return (property & operand::kIsUse) != 0;
+  }
+
+  bool IsMemLow12() const {
+    return IsMem() && ((property & operand::kMemLow12) != 0);
+  }
+
+  bool IsLiteralLow12() const {
+    return opndType == Operand::kOpdStImmediate && ((property & operand::kLiteralLow12) != 0);
+  }
+
+  bool IsLoadLiteral() const {
+    return (property & operand::kIsLoadLiteral) != 0;
+  }
+
+  bool IsVectorOperand() const {
+    return (property & operand::kIsVector);
+  }
+
+  bool IsIntOperand() const {
+    return (property & operand::kInt);
+  }
+
+#define DEFINE_MOP(op, ...) static const OpndDesc op;
+#include "operand.def"
+#undef DEFINE_MOP
+
+ private:
+  Operand::OperandType opndType;
+  maple::uint64 property;
+  maple::uint32 size;
+};
+
+class CondOperand : public OperandVisitable<CondOperand> {
+ public:
+  explicit CondOperand(maplebe::ConditionCode cc) : OperandVisitable(Operand::kOpdCond, k4ByteSize), cc(cc) {}
+
+  ~CondOperand() override = default;
+  using OperandVisitable<CondOperand>::OperandVisitable;
+
+  Operand *Clone(MemPool &memPool) const override {
+    return memPool.New<CondOperand>(cc);
+  }
+
+  ConditionCode GetCode() const {
+    return cc;
+  }
+
+  bool Less(const Operand &right) const override;
+
+  void Dump() const override {
+    CHECK_FATAL(false, "dont run here");
+  }
+
+  static const char *ccStrs[kCcLast];
+
+ private:
+  ConditionCode cc;
+};
+
+class OpndDumpVisitor : public OperandVisitorBase,
+                        public OperandVisitors<RegOperand,
+                                               ImmOperand,
+                                               MemOperand,
+                                               LabelOperand,
+                                               FuncNameOperand,
+                                               ListOperand,
+                                               StImmOperand,
+                                               CondOperand,
+                                               CommentOperand,
+                                               BitShiftOperand,
+                                               ExtendShiftOperand,
+                                               PhiOperand> {
+ public:
+  explicit OpndDumpVisitor(const OpndDesc &operandDesc) : opndDesc(&operandDesc) {}
+  ~OpndDumpVisitor() override {
+    opndDesc = nullptr;
+  }
+
+ protected:
+  virtual void DumpOpndPrefix() {
+    LogInfo::MapleLogger() << " (opnd:";
+  }
+  virtual void DumpOpndSuffix() {
+    LogInfo::MapleLogger() << " )";
+  }
+  void DumpSize(const Operand &opnd) const {
+    LogInfo::MapleLogger() << " [size:" << opnd.GetSize() << "]";
+  }
+  const OpndDesc *GetOpndDesc() const {
+    return opndDesc;
+  }
+
+ private:
+  const OpndDesc *opndDesc;
+};
+} /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_OPERAND_H */
diff --git a/src/mapleall/maple_be/include/cg/optimize_common.h b/src/mapleall/maple_be/include/cg/optimize_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..b65252979b563d7eca25843f2550788b3ca023c4
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/optimize_common.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_OPTIMIZE_COMMON_H
+#define MAPLEBE_INCLUDE_CG_OPTIMIZE_COMMON_H
+#include "cgfunc.h"
+
+namespace maplebe {
+inline const std::string kCfgoChaining = "red";
+inline const std::string kCfgoSj = "burlywood1";
+inline const std::string kCfgoFlipCond = "cadetblue1";
+inline const std::string kCfgoAlways = "green";
+inline const std::string kCfgoUnreach = "yellow";
+inline const std::string kCfgoDup = "orange";
+inline const std::string kCfgoEmpty = "purple";
+inline const std::string kIcoIte = "blue"; /* if conversion optimization, if-then-else */
+inline const std::string kIcoIt = "grey";  /* if conversion optimization, if-then-else */
+
+class OptimizationPattern {
+ public:
+  explicit OptimizationPattern(CGFunc &func)
+      : patternName(func.GetMemoryPool()),
+        cgFunc(&func),
+        dotColor(func.GetMemoryPool()) {}
+  virtual ~OptimizationPattern() = default;
+
+  bool IsKeepPosition() const {
+    return keepPosition;
+  }
+
+  void SetKeepPosition(bool flag) {
+    keepPosition = flag;
+  }
+
+  bool IsLabelInLSDAOrSwitchTable(LabelIdx label) const {
+    EHFunc *ehFunc = cgFunc->GetEHFunc();
+    return (ehFunc != nullptr && cgFunc->GetTheCFG()->InLSDA(label, ehFunc)) ||
+            cgFunc->GetTheCFG()->InSwitchTable(label, *cgFunc);
+  }
+
+  void Search2Op(bool noOptimize);
+  virtual bool Optimize(BB &curBB) = 0;
+
+ protected:
+  void Log(uint32 bbID);
+
+  bool keepPosition = false;
+  MapleString patternName;
+  CGFunc *cgFunc;
+  MapleString dotColor;
+  bool checkOnly = false;
+};
+
+class Optimizer {
+ public:
+  Optimizer(CGFunc &func, MemPool &memPool)
+      : cgFunc(&func),
+        name(nullptr),
+        memPool(&memPool),
+        alloc(&memPool),
+        diffPassPatterns(alloc.Adapter()),
+        singlePassPatterns(alloc.Adapter()) {
+    func.GetTheCFG()->InitInsnVisitor(func);
+  }
+
+  virtual ~Optimizer() = default;
+  void Run(const std::string &funcName, bool checkOnly = false);
+  virtual void InitOptimizePatterns() = 0;
+
+ protected:
+  CGFunc *cgFunc;
+  const char *name;
+  MemPool *memPool;
+  MapleAllocator alloc;
+  /* patterns need to run in different passes of cgFunc */
+  MapleVector<OptimizationPattern*> diffPassPatterns;
+  /* patterns can run in a single pass of cgFunc */
+  MapleVector<OptimizationPattern*> singlePassPatterns;
+};
+
+class OptimizeLogger {
+ public:
+  static OptimizeLogger &GetLogger() {
+    static OptimizeLogger instance;
+    return instance;
+  }
+
+  void Log(const std::string &patternName);
+  void ClearLocal();
+  void Print(const std::string &funcName);
+
+ private:
+  OptimizeLogger() = default;
+
+  ~OptimizeLogger() = default;
+
+  OptimizeLogger(const OptimizeLogger&);
+  OptimizeLogger &operator=(const OptimizeLogger&);
+
+  std::map<const std::string, int> globalStat;
+  std::map<const std::string, int> localStat;
+};
+
+class DotGenerator {
+ public:
+  static void SetColor(uint32 bbID, const std::string &color);
+  static void GenerateDot(const std::string &preFix, const CGFunc &cgFunc, const MIRModule &mod,
+                          bool includeEH = false, const std::string fname = "", regno_t vReg = 0);
+ private:
+  static std::map<uint32, std::string> coloringMap;
+  static std::string GetFileName(const MIRModule &mirModule, const std::string &filePreFix);
+  static bool IsBackEdge(const CGFunc &cgFunction, const BB &from, const BB &to);
+  static void DumpEdge(const CGFunc &cgFunction, std::ofstream &cfgFileOfStream, bool isIncludeEH);
+  static void DumpBBInstructions(const CGFunc &cgFunction, regno_t vReg, std::ofstream &cfgFile);
+  static bool FoundListOpndRegNum(ListOperand &listOpnd, const Insn &insnObj, regno_t vReg);
+  static bool FoundMemAccessOpndRegNum(const MemOperand &memOperand, const Insn &insnObj, regno_t vReg);
+  static bool FoundNormalOpndRegNum(const RegOperand &regOpnd, const Insn &insnObj, regno_t vReg);
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_OPTIMIZE_COMMON_H */
diff --git a/src/mapleall/maple_be/include/cg/peep.h b/src/mapleall/maple_be/include/cg/peep.h
new file mode 100644
index 0000000000000000000000000000000000000000..549c0ea9751341cb18b600b81efcb976841e3bac
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/peep.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_PEEP_H
+#define MAPLEBE_INCLUDE_CG_PEEP_H
+
+#include "cg.h"
+#include "optimize_common.h"
+
+namespace maplebe {
+enum ReturnType : uint8 {
+  kResUseFirst,
+  kResDefFirst,
+  kResNotFind
+};
+
+class PeepOptimizeManager {
+ public:
+  /* normal constructor */
+  PeepOptimizeManager(CGFunc &f, BB &bb, Insn &insn)
+      : cgFunc(&f),
+        currBB(&bb),
+        currInsn(&insn),
+        ssaInfo(nullptr) {}
+  /* constructor for ssa */
+  PeepOptimizeManager(CGFunc &f, BB &bb, Insn &insn, CGSSAInfo &info)
+      : cgFunc(&f),
+        currBB(&bb),
+        currInsn(&insn),
+        ssaInfo(&info) {}
+  ~PeepOptimizeManager() = default;
+  template<typename OptimizePattern>
+  void Optimize(bool patternEnable = false) {
+    if (!patternEnable) {
+      return;
+    }
+    OptimizePattern optPattern(*cgFunc, *currBB, *currInsn, *ssaInfo);
+    optPattern.Run(*currBB, *currInsn);
+    optSuccess |= optPattern.GetPatternRes();
+    if (optSuccess && optPattern.GetCurrInsn() != nullptr) {
+      currInsn = optPattern.GetCurrInsn();
+    }
+  }
+  template<typename OptimizePattern>
+  void NormalPatternOpt(bool patternEnable = false) {
+    if (!patternEnable) {
+      return;
+    }
+    OptimizePattern optPattern(*cgFunc, *currBB, *currInsn);
+    optPattern.Run(*currBB, *currInsn);
+  }
+  void SetOptSuccess(bool optRes) {
+    optSuccess = optRes;
+  }
+  bool OptSuccess() const {
+    return optSuccess;
+  }
+ private:
+  CGFunc *cgFunc;
+  BB *currBB;
+  Insn *currInsn;
+  CGSSAInfo *ssaInfo;
+  bool optSuccess = false;
+};
+
+class CGPeepHole {
+ public:
+  /* normal constructor */
+  CGPeepHole(CGFunc &f, MemPool *memPool)
+      : cgFunc(&f),
+        peepMemPool(memPool),
+        ssaInfo(nullptr) {}
+  /* constructor for ssa */
+  CGPeepHole(CGFunc &f, MemPool *memPool, CGSSAInfo *cgssaInfo)
+      : cgFunc(&f),
+        peepMemPool(memPool),
+        ssaInfo(cgssaInfo) {}
+  ~CGPeepHole() = default;
+
+  virtual void Run() = 0;
+  virtual bool DoSSAOptimize(BB &bb, Insn &insn) = 0;
+  virtual void DoNormalOptimize(BB &bb, Insn &insn) = 0;
+
+ protected:
+  CGFunc *cgFunc;
+  MemPool *peepMemPool;
+  CGSSAInfo *ssaInfo;
+  PeepOptimizeManager *manager = nullptr;
+};
+
+class PeepPattern {
+ public:
+  explicit PeepPattern(CGFunc &oneCGFunc) : cgFunc(oneCGFunc) {}
+  virtual ~PeepPattern() = default;
+  virtual void Run(BB &bb, Insn &insn) = 0;
+  /* optimization support function */
+  bool IfOperandIsLiveAfterInsn(const RegOperand &regOpnd, Insn &insn);
+  bool FindRegLiveOut(const RegOperand &regOpnd, const BB &bb);
+  bool CheckOpndLiveinSuccs(const RegOperand &regOpnd, const BB &bb) const;
+  bool CheckRegLiveinReturnBB(const RegOperand &regOpnd, const BB &bb) const;
+  ReturnType IsOpndLiveinBB(const RegOperand &regOpnd, const BB &bb) const;
+  int LogValueAtBase2(int64 val) const;
+  bool IsMemOperandOptPattern(const Insn &insn, Insn &nextInsn);
+
+ protected:
+  CGFunc &cgFunc;
+};
+
+class CGPeepPattern {
+ public:
+  /* normal constructor */
+  CGPeepPattern(CGFunc &f, BB &bb, Insn &insn)
+      : cgFunc(&f),
+        currBB(&bb),
+        currInsn(&insn),
+        ssaInfo(nullptr) {}
+  /* constructor for ssa */
+  CGPeepPattern(CGFunc &f, BB &bb, Insn &insn, CGSSAInfo &info)
+      : cgFunc(&f),
+        currBB(&bb),
+        currInsn(&insn),
+        ssaInfo(&info) {}
+  virtual ~CGPeepPattern() = default;
+
+  std::string PhaseName() const {
+    return "cgpeephole";
+  }
+
+  virtual std::string GetPatternName() = 0;
+  void DumpAfterPattern(std::vector<Insn*> &prevInsns, const Insn *replacedInsn, const Insn *newInsn);
+  InsnSet GetAllUseInsn(const RegOperand &defReg) const;
+  int64 GetLogValueAtBase2(int64 val) const;
+  /* The CC reg is unique and cannot cross-version props. */
+  bool IsCCRegCrossVersion(Insn &startInsn, Insn &endInsn, const RegOperand &ccReg) const;
+  /* optimization support function */
+  bool IfOperandIsLiveAfterInsn(const RegOperand &regOpnd, Insn &insn);
+  bool FindRegLiveOut(const RegOperand &regOpnd, const BB &bb);
+  bool CheckOpndLiveinSuccs(const RegOperand &regOpnd, const BB &bb) const;
+  bool CheckRegLiveinReturnBB(const RegOperand &regOpnd, const BB &bb) const;
+  ReturnType IsOpndLiveinBB(const RegOperand &regOpnd, const BB &bb) const;
+  bool GetPatternRes() const {
+    return optSuccess;
+  }
+  Insn *GetCurrInsn() {
+    return currInsn;
+  }
+  void SetCurrInsn(Insn *updateInsn) {
+    currInsn = updateInsn;
+  }
+  virtual void Run(BB &bb, Insn &insn) = 0;
+  virtual bool CheckCondition(Insn &insn) = 0;
+
+ protected:
+  CGFunc *cgFunc;
+  BB *currBB;
+  Insn *currInsn;
+  CGSSAInfo *ssaInfo;
+  bool optSuccess = false;
+};
+
+class PeepHoleOptimizer {
+ public:
+  explicit PeepHoleOptimizer(CGFunc *cf) : cgFunc(cf) {
+    cg = cgFunc->GetCG();
+  }
+  ~PeepHoleOptimizer() = default;
+  void Peephole0();
+  void PeepholeOpt();
+  void PrePeepholeOpt();
+  void PrePeepholeOpt1();
+
+ private:
+  CGFunc *cgFunc;
+  CG *cg = nullptr;
+};  /* class PeepHoleOptimizer */
+
+class PeepPatternMatch {
+ public:
+  PeepPatternMatch(CGFunc &oneCGFunc, MemPool *memPool)
+      : optOwnMemPool(memPool),
+        peepAllocator(memPool),
+        optimizations(peepAllocator.Adapter()),
+        cgFunc(oneCGFunc) {}
+  virtual ~PeepPatternMatch() = default;
+  virtual void Run(BB &bb, Insn &insn) = 0;
+  virtual void InitOpts() = 0;
+ protected:
+  MemPool *optOwnMemPool;
+  MapleAllocator peepAllocator;
+  MapleVector<PeepPattern*> optimizations;
+  CGFunc &cgFunc;
+};
+
+class PeepOptimizer {
+ public:
+  PeepOptimizer(CGFunc &oneCGFunc, MemPool *memPool)
+      : cgFunc(oneCGFunc),
+        peepOptMemPool(memPool) {
+    index = 0;
+  }
+  ~PeepOptimizer() = default;
+  template<typename T>
+  void Run();
+  static int32 index;
+
+ private:
+  CGFunc &cgFunc;
+  MemPool *peepOptMemPool;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgPeepHole, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPrePeepHole, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPostPeepHole, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPrePeepHole0, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPrePeepHole1, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPeepHole0, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgPeepHole1, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_PEEP_H */
diff --git a/src/mapleall/maple_be/include/cg/pressure.h b/src/mapleall/maple_be/include/cg/pressure.h
new file mode 100644
index 0000000000000000000000000000000000000000..c4b69df73f1424b27971c8c2da373080b6fc163a
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/pressure.h
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_PRESSURE_H
+#define MAPLEBE_INCLUDE_CG_PRESSURE_H
+
+#include "cgbb.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+struct RegList {
+  Insn *insn;
+  RegList *next;
+};
+
+#define FOR_ALL_REGCLASS(i) \
+  for (uint32 i = 0; i < static_cast<uint32>(RegPressure::GetMaxRegClassNum()); ++i)
+
+class RegPressure {
+ public:
+  explicit RegPressure(MapleAllocator &alloc)
+      : regUses(alloc.Adapter()), regDefs(alloc.Adapter()),
+        pressure(alloc.Adapter()), deadDefNum(alloc.Adapter()) {}
+
+  virtual ~RegPressure() = default;
+
+  void DumpRegPressure() const;
+
+  void SetRegUses(RegList *regList) {
+    regUses.emplace_back(regList);
+  }
+
+  void SetRegDefs(size_t idx, RegList *regList) {
+    if (idx < regDefs.size()) {
+      regDefs[idx] = regList;
+    } else {
+      regDefs.emplace_back(regList);
+    }
+  }
+
+  static void SetMaxRegClassNum(int32 maxClassNum) {
+    maxRegClassNum = maxClassNum;
+  }
+
+  static int32 GetMaxRegClassNum() {
+    return maxRegClassNum;
+  }
+
+  int32 GetPriority() const {
+    return priority;
+  }
+
+  void SetPriority(int32 value) {
+    priority = value;
+  }
+
+  int32 GetMaxDepth() const {
+    return maxDepth;
+  }
+
+  void SetMaxDepth(int32 value) {
+    maxDepth = value;
+  }
+
+  int32 GetNear() const {
+    return near;
+  }
+
+  void SetNear(int32 value) {
+    near = value;
+  }
+
+  int32 GetIncPressure() const {
+    return incPressure;
+  }
+
+  void SetIncPressure(bool value) {
+    incPressure = value;
+  }
+  const MapleVector<int32> &GetPressure() const {
+    return pressure;
+  }
+
+  void IncPressureByIndex(uint32 index) {
+    ASSERT(index < pressure.size(), "index out of range");
+    ++pressure[index];
+  }
+
+  void DecPressureByIndex(uint32 index) {
+    ASSERT(index < pressure.size(), "index out of range");
+    --pressure[index];
+  }
+
+  void InitPressure() {
+    pressure.resize(static_cast<uint64>(maxRegClassNum), 0);
+    deadDefNum.resize(static_cast<uint64>(maxRegClassNum), 0);
+    incPressure = false;
+  }
+
+  const MapleVector<int32> &GetDeadDefNum() const {
+    return deadDefNum;
+  }
+
+  void IncDeadDefByIndex(uint32 index) {
+    ASSERT(index < deadDefNum.size(), "index out of range");
+    ++deadDefNum[index];
+  }
+
+  RegList *GetRegUses(size_t idx) const {
+    return idx < regUses.size() ? regUses[idx] : nullptr;
+  }
+
+  void InitRegUsesSize(size_t size) {
+    regUses.reserve(size);
+  }
+
+  RegList *GetRegDefs(size_t idx) const {
+    return idx < regDefs.size() ? regDefs[idx] : nullptr;
+  }
+
+  void InitRegDefsSize(size_t size) {
+    regDefs.reserve(size);
+  }
+
+  void SetHasPreg(bool value) {
+    hasPreg = value;
+  }
+
+  bool GetHasPreg() const {
+    return hasPreg;
+  }
+
+  void SetNumCall(int32 value) {
+    callNum = value;
+  }
+
+  int32 GetNumCall() const {
+    return callNum;
+  }
+
+  void SetHasNativeCallRegister(bool value) {
+    hasNativeCallRegister = value;
+  }
+
+  bool GetHasNativeCallRegister() const {
+    return hasNativeCallRegister;
+  }
+
+ private:
+  /* save reglist of every uses'register */
+  MapleVector<RegList*> regUses;
+  /* save reglist of every defs'register */
+  MapleVector<RegList*> regDefs;
+
+  /* the number of the node needs registers */
+  MapleVector<int32> pressure;
+  /* the count of dead define registers */
+  MapleVector<int32> deadDefNum;
+  /* max number of reg's class */
+  static int32 maxRegClassNum;
+  int32 priority = 0;
+  int32 maxDepth = 0;
+  int32 near = 0;
+  /* the number of successor call */
+  int32 callNum = 0;
+  /* if a type register increase then set incPressure as true. */
+  bool incPressure = false;
+  /* if define physical register, set hasPreg as true */
+  bool hasPreg = false;
+  /* it is call native special register */
+  bool hasNativeCallRegister = false;
+};
+} /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_PRESSURE_H */
diff --git a/src/mapleall/maple_be/include/cg/proepilog.h b/src/mapleall/maple_be/include/cg/proepilog.h
new file mode 100644
index 0000000000000000000000000000000000000000..9fffbbeff947d2be15b4d6e7317ec6d3b41bb497
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/proepilog.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_PROEPILOG_H
+#define MAPLEBE_INCLUDE_CG_PROEPILOG_H
+#include "cg_phase.h"
+#include "cgfunc.h"
+#include "insn.h"
+
+namespace maplebe {
+class GenProEpilog {
+ public:
+  explicit GenProEpilog(CGFunc &func) : cgFunc(func) {}
+
+  virtual ~GenProEpilog() = default;
+
+  virtual void Run() {}
+
+  std::string PhaseName() const {
+    return "generateproepilog";
+  }
+
+  virtual bool NeedProEpilog() {
+    return true;
+  }
+
+  /* CFI related routines */
+  int64 GetOffsetFromCFA() const {
+    return offsetFromCfa;
+  }
+
+  /* add increment (can be negative) and return the new value */
+  int64 AddtoOffsetFromCFA(int64 delta) {
+    offsetFromCfa += delta;
+    return offsetFromCfa;
+  }
+
+ protected:
+
+  CGFunc &cgFunc;
+  int64 offsetFromCfa = 0; /* SP offset from Call Frame Address */
+  bool stackProtect = false;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_PROEPILOG_H */
diff --git a/src/mapleall/maple_be/include/cg/ra_opt.h b/src/mapleall/maple_be/include/cg/ra_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..93c4944e0fb15e89128767f4e02f85ca0dc2c4b5
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/ra_opt.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_RAOPT_H
+#define MAPLEBE_INCLUDE_CG_RAOPT_H
+
+#include "cgfunc.h"
+#include "cg_phase.h"
+#include "cg_dominance.h"
+
+namespace maplebe {
+class RaOpt {
+ public:
+  RaOpt(CGFunc &func, MemPool &pool) : cgFunc(&func), memPool(&pool) {}
+
+  virtual ~RaOpt() = default;
+
+  virtual void Run() {}
+
+  std::string PhaseName() const {
+    return "raopt";
+  }
+
+  const CGFunc *GetCGFunc() const {
+    return cgFunc;
+  }
+  const MemPool *GetMemPool() const {
+    return memPool;
+  }
+
+  void SetDomInfo(DomAnalysis *curDom) {
+    domInfo = curDom;
+  }
+
+ protected:
+  CGFunc *cgFunc;
+  MemPool *memPool;
+  DomAnalysis *domInfo = nullptr;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgRaOpt, maplebe::CGFunc)
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_RAOPT_H */
diff --git a/src/mapleall/maple_be/include/cg/reaching.h b/src/mapleall/maple_be/include/cg/reaching.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a4692521a2058454d3356b4cdcf1ee0f8b583c5
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/reaching.h
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_REACHING_H
+#define MAPLEBE_INCLUDE_CG_REACHING_H
+
+#include "cg_phase.h"
+#include "cgbb.h"
+#include "datainfo.h"
+#include "maple_phase.h"
+
+namespace maplebe {
+enum VisitStatus : uint8 {
+  kNotVisited,
+  kNormalVisited,
+  kEHVisited
+};
+
+enum AnalysisType : uint8 {
+  kRDRegAnalysis = 1,
+  kRDMemAnalysis = 2,
+  kRDAllAnalysis = 3
+};
+
+enum DumpType : uint32 {
+  kDumpAll = 0xFFF,
+  kDumpRegGen = 0x001,
+  kDumpRegUse = 0x002,
+  kDumpRegIn = 0x004,
+  kDumpRegOut = 0x008,
+  kDumpMemGen = 0x010,
+  kDumpMemIn = 0x020,
+  kDumpMemOut = 0x040,
+  kDumpMemUse = 0x080,
+  kDumpBBCGIR = 0x100
+};
+
+class ReachingDefinition : public AnalysisResult {
+ public:
+  ReachingDefinition(CGFunc &func, MemPool &memPool);
+  ~ReachingDefinition() override = default;
+  void AnalysisStart();
+  void Dump(uint32 flag) const;
+  void DumpInfo(const BB &bb, DumpType flag) const;
+  void DumpBBCGIR(const BB &bb) const;
+  void ClearDefUseInfo();
+  void UpdateInOut(BB &changedBB);
+  void UpdateInOut(BB &changedBB, bool isReg);
+  void SetAnalysisMode(AnalysisType analysisMode) {
+    mode = analysisMode;
+  }
+
+  bool OnlyAnalysisReg() const {
+    return mode == kRDRegAnalysis;
+  }
+
+  uint32 GetMaxInsnNO() const {
+    return maxInsnNO;
+  }
+
+  size_t GetRegSize(const BB &bb) const {
+    return regUse[bb.GetId()]->Size();
+  }
+
+  bool CheckRegGen(const BB &bb, uint32 regNO) const {
+    return regGen[bb.GetId()]->TestBit(regNO);
+  }
+
+  void EnlargeRegCapacity(uint32 size);
+  bool IsFrameReg(const Operand &opnd) const;
+  InsnSet FindUseForRegOpnd(Insn &insn, uint32 indexOrRegNO, bool isRegNO) const;
+  bool RegIsUsedIncaller(uint32 regNO, Insn &startInsn, Insn &endInsn) const;
+  bool CheckRegLiveinReturnBB(uint32 regNO, const BB &bb) const;
+  bool RegIsLiveBetweenInsn(uint32 regNO, Insn &startInsn, Insn &endInsn, bool isBack = false,
+                            bool isFirstNo = false) const;
+  bool RegIsUsedOrDefBetweenInsn(uint32 regNO, Insn &startInsn, Insn &endInsn) const;
+  bool IsLiveInAllPathBB(uint32 regNO, const BB &startBB, const BB &endBB, std::vector<bool> &visitedBB,
+                         bool isFirstNo = false) const;
+  bool IsUseOrDefInAllPathBB(uint32 regNO, const BB &startBB, const BB &endBB, std::vector<bool> &visitedBB) const;
+  bool IsUseOrDefBetweenInsn(uint32 regNO, const BB &curBB, const Insn &startInsn, Insn &endInsn) const;
+  bool HasCallBetweenDefUse(const Insn &defInsn, const Insn &useInsn) const;
+  std::vector<Insn*> FindRegDefBetweenInsn (
+      uint32 regNO, Insn *startInsn, Insn *endInsn, bool findAll = false, bool analysisDone = true) const;
+  virtual void InitGenUse(BB &bb, bool firstTime = true) = 0;
+  virtual InsnSet FindDefForMemOpnd(Insn &insn, uint32 indexOrOffset, bool isOffset = false) const = 0;
+  virtual InsnSet FindUseForMemOpnd(Insn &insn, uint8 index, bool secondMem = false) const = 0;
+  virtual std::vector<Insn*> FindMemDefBetweenInsn(uint32 offset, const Insn *startInsn, Insn *endInsn) const = 0;
+  virtual std::vector<Insn*> FindRegDefBetweenInsnGlobal(uint32 regNO, Insn *startInsn, Insn *endInsn) const = 0;
+  virtual bool FindRegUseBetweenInsn(uint32 regNO, Insn *startInsn, Insn *endInsn, InsnSet &useInsnSet) const = 0;
+  virtual bool FindRegUseBetweenInsnGlobal(uint32 regNO, Insn *startInsn, Insn *endInsn, BB* movBB) const = 0;
+  virtual bool FindMemUseBetweenInsn(uint32 offset, Insn *startInsn, const Insn *endInsn,
+                                     InsnSet &useInsnSet) const = 0;
+  virtual InsnSet FindDefForRegOpnd(Insn &insn, uint32 indexOrRegNO, bool isRegNO = false) const = 0;
+
+  static constexpr int32 kWordByteNum = 4;
+  static constexpr int32 kDoubleWordByteNum = 8;
+  /* to save storage space, the offset of stack memory is devided by 4 and then saved in DataInfo */
+  static constexpr int32 kMemZoomSize = 4;
+  /* number the insn interval 3. make sure no repeated insn number when new insn inserted */
+  static constexpr uint32 kInsnNoInterval = 3;
+  bool HasCallBetweenInsnInSameBB(const Insn &startInsn, const Insn &endInsn) const;
+  virtual bool KilledByCallBetweenInsnInSameBB(const Insn &startInsn, const Insn &endInsn, regno_t regNO) const = 0;
+ protected:
+  virtual void InitStartGen() = 0;
+  virtual void InitEhDefine(BB &bb) = 0;
+  virtual void GenAllAsmDefRegs(BB &bb, Insn &insn, uint32 index) = 0;
+  virtual void GenAllAsmUseRegs(BB &bb, Insn &insn, uint32 index) = 0;
+  virtual void GenAllCallerSavedRegs(BB &bb, Insn &insn) = 0;
+  virtual void AddRetPseudoInsn(BB &bb) = 0;
+  virtual void AddRetPseudoInsns() = 0;
+  virtual int32 GetStackSize() const = 0;
+  virtual bool IsCallerSavedReg(uint32 regNO) const = 0;
+  virtual void FindRegDefInBB(uint32 regNO, BB &bb, InsnSet &defInsnSet) const = 0;
+  virtual void FindMemDefInBB(uint32 offset, BB &bb, InsnSet &defInsnSet) const = 0;
+  virtual bool IsRegKilledByCallInsn(const Insn &insn, regno_t regNO) const = 0;
+  virtual void DFSFindDefForRegOpnd(const BB &startBB, uint32 regNO, std::vector<VisitStatus> &visitedBB,
+                                    InsnSet &defInsnSet) const = 0;
+  virtual void DFSFindDefForMemOpnd(const BB &startBB, uint32 offset, std::vector<VisitStatus> &visitedBB,
+                                    InsnSet &defInsnSet) const = 0;
+  void DFSFindUseForMemOpnd(const BB &startBB, uint32 offset, std::vector<bool> &visitedBB,
+                            InsnSet &useInsnSet, bool onlyFindForEhSucc) const;
+
+  CGFunc *cgFunc;
+  MapleAllocator rdAlloc;
+  StackMemPool &stackMp;
+  MapleVector<Insn*> pseudoInsns;
+  AnalysisType mode = kRDRegAnalysis;
+  BB *firstCleanUpBB = nullptr;
+  std::vector<DataInfo*> regGen;
+  std::vector<DataInfo*> regUse;
+  std::vector<DataInfo*> regIn;
+  std::vector<DataInfo*> regOut;
+  std::vector<DataInfo*> memGen;
+  std::vector<DataInfo*> memUse;
+  std::vector<DataInfo*> memIn;
+  std::vector<DataInfo*> memOut;
+  const uint32 kMaxBBNum;
+  uint32 stackSize = 0;
+ private:
+  void Initialize();
+  void InitDataSize();
+  void BuildInOutForFuncBody();
+  void BuildInOutForCleanUpBB();
+  void BuildInOutForCleanUpBB(bool isReg, const std::set<uint32> &index);
+  void InitRegAndMemInfo(const BB &bb);
+  void InitOut(const BB &bb);
+  bool GenerateIn(const BB &bb);
+  bool GenerateIn(const BB &bb, const std::set<uint32> &infoIndex, const bool isReg);
+  bool GenerateOut(const BB &bb);
+  bool GenerateOut(const BB &bb, const std::set<uint32> &infoIndex, const bool isReg);
+  bool GenerateInForFirstCleanUpBB();
+  bool GenerateInForFirstCleanUpBB(bool isReg, const std::set<uint32> &infoIndex);
+  void DFSFindUseForRegOpnd(const BB &startBB, uint32 regNO, std::vector<bool> &visitedBB,
+                            InsnSet &useInsnSet, bool onlyFindForEhSucc) const;
+  bool RegIsUsedInOtherBB(const BB &startBB, uint32 regNO, std::vector<bool> &visitedBB) const;
+  bool RegHasUsePoint(uint32 regNO, Insn &regDefInsn) const;
+  bool CanReachEndBBFromCurrentBB(const BB &currentBB, const BB &endBB, std::vector<bool> &traversedBBSet) const;
+
+  bool HasCallInPath(const BB &startBB, const BB &endBB, std::vector<bool> &visitedBB) const;
+  bool RegIsUsedInCleanUpBB(uint32 regNO) const;
+  void BuildInOutForFuncBodyBFS();
+  void GenerateIn(const BB &bb, std::queue<BB*> &worklist, std::vector<bool> &inQueued);
+
+  MapleSet<BB*, BBIdCmp> normalBBSet;
+  MapleSet<BB*, BBIdCmp> cleanUpBBSet;
+  uint32 maxInsnNO = 0;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgReachingDefinition, maplebe::CGFunc)
+  ReachingDefinition *GetResult() {
+    return reachingDef;
+  }
+  ReachingDefinition *reachingDef = nullptr;
+MAPLE_FUNC_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgClearRDInfo, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_REACHING_H */
diff --git a/src/mapleall/maple_be/include/cg/reg_alloc.h b/src/mapleall/maple_be/include/cg/reg_alloc.h
new file mode 100644
index 0000000000000000000000000000000000000000..312f266dd5e029093365dc1aba57f24ff97534f9
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/reg_alloc.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_REG_ALLOC_H
+#define MAPLEBE_INCLUDE_CG_REG_ALLOC_H
+
+#include "cgfunc.h"
+#include "maple_phase_manager.h"
+
+namespace maplebe {
+class RegAllocator {
+ public:
+  RegAllocator(CGFunc &tempCGFunc, MemPool &memPool)
+      : cgFunc(&tempCGFunc),
+        memPool(&memPool),
+        alloc(&memPool),
+        regInfo(tempCGFunc.GetTargetRegInfo()) {
+  regInfo->Init();
+}
+
+  virtual ~RegAllocator() = default;
+
+  virtual bool AllocateRegisters() = 0;
+
+  bool IsYieldPointReg(regno_t regNO) const;
+  bool IsUntouchableReg(regno_t regNO) const;
+
+  virtual std::string PhaseName() const {
+    return "regalloc";
+  }
+
+ protected:
+  CGFunc *cgFunc = nullptr;
+  MemPool *memPool = nullptr;
+  MapleAllocator alloc;
+  RegisterInfo *regInfo = nullptr;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgRegAlloc, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_REG_ALLOC_H */
diff --git a/src/mapleall/maple_be/include/cg/reg_alloc_basic.h b/src/mapleall/maple_be/include/cg/reg_alloc_basic.h
new file mode 100644
index 0000000000000000000000000000000000000000..74c8e6d84c3b6a240e12372903b4c442db2c42d8
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/reg_alloc_basic.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_REG_ALLOC_BASIC_H
+#define MAPLEBE_INCLUDE_CG_REG_ALLOC_BASIC_H
+
+#include "reg_alloc.h"
+#include "operand.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+class DefaultO0RegAllocator : public RegAllocator {
+ public:
+  DefaultO0RegAllocator(CGFunc &cgFunc, MemPool &memPool)
+      : RegAllocator(cgFunc, memPool),
+        calleeSaveUsed(alloc.Adapter()),
+        availRegSet(alloc.Adapter()),
+        regMap(std::less<uint32>(), alloc.Adapter()),
+        liveReg(std::less<uint8>(), alloc.Adapter()),
+        allocatedSet(std::less<Operand*>(), alloc.Adapter()),
+        regLiveness(alloc.Adapter()),
+        rememberRegs(alloc.Adapter()) {
+    availRegSet.resize(regInfo->GetAllRegNum());
+  }
+
+  ~DefaultO0RegAllocator() override {
+    regInfo = nullptr;
+  }
+
+  bool AllocateRegisters() override;
+
+  void InitAvailReg();
+
+  bool AllocatePhysicalRegister(const RegOperand &opnd);
+  void ReleaseReg(regno_t reg);
+  void ReleaseReg(const RegOperand &regOpnd);
+  void AllocHandleDestList(Insn &insn, Operand &opnd, uint32 idx);
+  void AllocHandleDest(Insn &insn, Operand &opnd, uint32 idx);
+  void AllocHandleSrcList(Insn &insn, Operand &opnd, uint32 idx);
+  void AllocHandleSrc(Insn &insn, Operand &opnd, uint32 idx);
+  void SaveCalleeSavedReg(const RegOperand &opnd);
+
+ protected:
+  Operand *HandleRegOpnd(Operand &opnd);
+  Operand *HandleMemOpnd(Operand &opnd);
+  Operand *AllocSrcOpnd(Operand &opnd);
+  Operand *AllocDestOpnd(Operand &opnd, const Insn &insn);
+  uint32 GetRegLivenessId(regno_t regNo);
+  bool CheckRangesOverlap(const std::pair<uint32, uint32> &range1,
+                          const MapleVector<std::pair<uint32, uint32>> &ranges2) const;
+  void SetupRegLiveness(BB *bb);
+  void SetupRegLiveness(MemOperand &opnd, uint32 insnId);
+  void SetupRegLiveness(ListOperand &opnd, uint32 insnId, bool isDef);
+  void SetupRegLiveness(RegOperand &opnd, uint32 insnId, bool isDef);
+
+  MapleSet<regno_t> calleeSaveUsed;
+  MapleVector<bool> availRegSet;
+  MapleMap<uint32, regno_t> regMap;     /* virtual-register-to-physical-register map */
+  MapleSet<uint8> liveReg;              /* a set of currently live physical registers */
+  MapleSet<Operand*> allocatedSet;      /* already allocated */
+  MapleMap<regno_t, MapleVector<std::pair<uint32, uint32>>> regLiveness;
+  MapleVector<regno_t> rememberRegs;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_REG_ALLOC_BASIC_H */
diff --git a/src/mapleall/maple_be/include/cg/reg_alloc_lsra.h b/src/mapleall/maple_be/include/cg/reg_alloc_lsra.h
new file mode 100644
index 0000000000000000000000000000000000000000..7759ac1b5ac76d984a404282054c04b155465f72
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/reg_alloc_lsra.h
@@ -0,0 +1,552 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_REG_ALLOC_LSRA_H
+#define MAPLEBE_INCLUDE_CG_REG_ALLOC_LSRA_H
+#include "reg_alloc.h"
+#include "cgfunc.h"
+#include "optimize_common.h"
+
+namespace maplebe {
+class LSRALinearScanRegAllocator : public RegAllocator {
+  enum RegInCatch : uint8 {
+    /*
+     * RA do not want to allocate certain registers if a live interval is
+     * only inside of catch blocks.
+     */
+    kRegCatchNotInit = 0,  /* unitialized state */
+    kRegNOtInCatch = 1,    /* interval is part or all outside of catch */
+    kRegAllInCatch = 2,    /* inteval is completely inside catch */
+  };
+
+  enum RegInCleanup : uint8 {
+    /* Similar to reg_in_catch_t */
+    kRegCleanupNotInit = 0,        /* unitialized state */
+    kRegAllInFirstbb = 1,          /* interval is all in the first bb */
+    kRegAllOutCleanup = 2,         /* interval is all outside of cleanup, must in normal bb, may in first bb. */
+    kRegInCleanupAndFirstbb = 3,   /* inteval is in cleanup and first bb. */
+    kRegInCleanupAndNormalbb = 4,  /* inteval is in cleanup and non-first bb. */
+    kRegAllInCleanup = 5           /* inteval is inside cleanup, except for bb 1 */
+  };
+
+  class LiveInterval {
+   public:
+    explicit LiveInterval(MapleAllocator &mallocator)
+        : ranges(mallocator.Adapter()),
+          holes(mallocator.Adapter()),
+          usePositions(mallocator.Adapter()),
+          overlapPhyRegSet(mallocator.Adapter()) {}
+
+    virtual ~LiveInterval() = default;
+
+    void AddRange(uint32 from, uint32 to);
+    void AddUsePos(uint32 pos);
+
+    const Insn *GetIsCall() const {
+      return isCall;
+    }
+
+    void SetIsCall(Insn &newIsCall) {
+      isCall = &newIsCall;
+    }
+
+    uint32 GetPhysUse() const {
+      return physUse;
+    }
+
+    void SetPhysUse(uint32 newPhysUse) {
+      physUse = newPhysUse;
+    }
+
+    uint32 GetLastUse() const {
+      return lastUse;
+    }
+
+    void SetLastUse(uint32 newLastUse) {
+      lastUse = newLastUse;
+    }
+
+    uint32 GetRegNO() const {
+      return regNO;
+    }
+
+    void SetRegNO(uint32 newRegNO) {
+      regNO = newRegNO;
+    }
+
+    uint32 GetAssignedReg() const {
+      return assignedReg;
+    }
+
+    void SetAssignedReg(uint32 newAssignedReg) {
+      assignedReg = newAssignedReg;
+    }
+
+    uint32 GetFirstDef() const {
+      return firstDef;
+    }
+
+    void SetFirstDef(uint32 newFirstDef) {
+      firstDef = newFirstDef;
+    }
+
+    uint32 GetStackSlot() const {
+      return stackSlot;
+    }
+
+    void SetStackSlot(uint32 newStkSlot) {
+      stackSlot = newStkSlot;
+    }
+
+    RegType GetRegType() const {
+      return regType;
+    }
+
+    void SetRegType(RegType newRegType) {
+      regType = newRegType;
+    }
+
+    uint32 GetFirstAcrossedCall() const {
+      return firstAcrossedCall;
+    }
+
+    void SetFirstAcrossedCall(uint32 newFirstAcrossedCall) {
+      firstAcrossedCall = newFirstAcrossedCall;
+    }
+
+    bool IsEndByCall() const {
+      return endByCall;
+    }
+
+    bool IsUseBeforeDef() const {
+      return useBeforeDef;
+    }
+
+    void SetUseBeforeDef(bool newUseBeforeDef) {
+      useBeforeDef = newUseBeforeDef;
+    }
+
+    bool IsShouldSave() const {
+      return shouldSave;
+    }
+
+    void SetShouldSave(bool newShouldSave) {
+      shouldSave = newShouldSave;
+    }
+
+    bool IsMultiUseInBB() const {
+      return multiUseInBB;
+    }
+
+    void SetMultiUseInBB(bool newMultiUseInBB) {
+      multiUseInBB = newMultiUseInBB;
+    }
+
+    bool IsThrowVal() const {
+      return isThrowVal;
+    }
+
+    bool IsCallerSpilled() const {
+      return isCallerSpilled;
+    }
+
+    void SetIsCallerSpilled(bool newIsCallerSpilled) {
+      isCallerSpilled = newIsCallerSpilled;
+    }
+
+    bool IsMustAllocate() const {
+      return mustAllocate;
+    }
+
+    void SetMustAllocate(bool newMustAllocate) {
+      mustAllocate = newMustAllocate;
+    }
+
+    uint32 GetRefCount() const{
+      return refCount;
+    }
+
+    void SetRefCount(uint32 newRefCount) {
+      refCount = newRefCount;
+    }
+
+    float GetPriority() const {
+      return priority;
+    }
+
+    void SetPriority(float newPriority) {
+      priority = newPriority;
+    }
+
+    const MapleVector<std::pair<uint32, uint32>> &GetRanges() const {
+      return ranges;
+    }
+
+    MapleVector<std::pair<uint32, uint32>> &GetRanges() {
+      return ranges;
+    }
+
+    size_t GetRangesSize() const {
+      return ranges.size();
+    }
+
+    const MapleVector<std::pair<uint32, uint32>> &GetHoles() const {
+      return holes;
+    }
+
+    void HolesPushBack(uint32 pair1, uint32 pair2) {
+      holes.push_back(std::pair<uint32, uint32>(pair1, pair2));
+    }
+
+    void UsePositionsInsert(uint32 insertId) {
+      (void)usePositions.insert(insertId);
+    }
+
+    const LiveInterval *GetLiParent() const {
+      return liveParent;
+    }
+
+    void SetLiParent(LiveInterval *newLiParent) {
+      liveParent = newLiParent;
+    }
+
+    void SetLiParentChild(LiveInterval *child) const {
+      liveParent->SetLiChild(child);
+    }
+
+    const LiveInterval *GetLiChild() const {
+      return liveChild;
+    }
+
+    void SetLiChild(LiveInterval *newLiChild) {
+      liveChild = newLiChild;
+    }
+
+    void SetOverlapPhyRegSet(regno_t regNo) {
+      overlapPhyRegSet.insert(regNo);
+    }
+    bool IsOverlapPhyReg(regno_t regNo) {
+      return overlapPhyRegSet.find(regNo) != overlapPhyRegSet.end();
+    }
+
+    uint32 GetResultCount() const {
+      return resultCount;
+    }
+
+    void SetResultCount(uint32 newResultCount) {
+      resultCount = newResultCount;
+    }
+
+    void SetInCatchState() {
+      /*
+       * Once in REG_NOT_IN_CATCH, it is irreversible since once an interval
+       * is not in a catch, it is not completely in a catch.
+       */
+      if (inCatchState == kRegNOtInCatch) {
+        return;
+      }
+      inCatchState = kRegAllInCatch;
+    }
+
+    void SetNotInCatchState() {
+      inCatchState = kRegNOtInCatch;
+    }
+
+    bool IsInCatch() const {
+      return (inCatchState == kRegAllInCatch);
+    }
+
+    void SetInCleanupState() {
+      switch (inCleanUpState) {
+        case kRegCleanupNotInit:
+          inCleanUpState = kRegAllInCleanup;
+          break;
+        case kRegAllInFirstbb:
+          inCleanUpState = kRegInCleanupAndFirstbb;
+          break;
+        case kRegAllOutCleanup:
+          inCleanUpState = kRegInCleanupAndNormalbb;
+          break;
+        case kRegInCleanupAndFirstbb:
+          break;
+        case kRegInCleanupAndNormalbb:
+          break;
+        case kRegAllInCleanup:
+          break;
+        default:
+          ASSERT(false, "CG Internal error.");
+          break;
+      }
+    }
+
+    void SetNotInCleanupState(bool isFirstBB) {
+      switch (inCleanUpState) {
+        case kRegCleanupNotInit: {
+          if (isFirstBB) {
+            inCleanUpState = kRegAllInFirstbb;
+          } else {
+            inCleanUpState = kRegAllOutCleanup;
+          }
+          break;
+        }
+        case kRegAllInFirstbb: {
+          if (!isFirstBB) {
+            inCleanUpState = kRegAllOutCleanup;
+          }
+          break;
+        }
+        case kRegAllOutCleanup:
+          break;
+        case kRegInCleanupAndFirstbb: {
+          if (!isFirstBB) {
+            inCleanUpState = kRegInCleanupAndNormalbb;
+          }
+          break;
+        }
+        case kRegInCleanupAndNormalbb:
+          break;
+        case kRegAllInCleanup: {
+          if (isFirstBB) {
+            inCleanUpState = kRegInCleanupAndFirstbb;
+          } else {
+            inCleanUpState = kRegInCleanupAndNormalbb;
+          }
+          break;
+        }
+        default:
+          ASSERT(false, "CG Internal error.");
+          break;
+      }
+    }
+
+    bool IsAllInCleanupOrFirstBB() const {
+      return (inCleanUpState == kRegAllInCleanup) || (inCleanUpState == kRegInCleanupAndFirstbb);
+    }
+
+    bool IsAllOutCleanup() const {
+      return (inCleanUpState == kRegAllInFirstbb) || (inCleanUpState == kRegAllOutCleanup);
+    }
+
+   private:
+    Insn *isCall = nullptr;
+    uint32 firstDef = 0;
+    uint32 lastUse = 0;
+    uint32 physUse = 0;
+    uint32 regNO = 0;
+    /* physical register, using cg defined reg based on R0/V0. */
+    uint32 assignedReg = 0;
+    uint32 stackSlot = -1;
+    RegType regType = kRegTyUndef;
+    uint32 firstAcrossedCall = 0;
+    bool endByCall = false;
+    bool useBeforeDef = false;
+    bool shouldSave = false;
+    bool multiUseInBB = false;    /* vreg has more than 1 use in bb */
+    bool isThrowVal = false;
+    bool isCallerSpilled = false; /* only for R0(R1?) which are used for explicit incoming value of throwval; */
+    bool mustAllocate = false;    /* The register cannot be spilled (clinit pair) */
+    uint32 refCount = 0;
+    float priority = 0.0;
+    MapleVector<std::pair<uint32, uint32>> ranges;
+    MapleVector<std::pair<uint32, uint32>> holes;
+    MapleSet<uint32> usePositions;
+    MapleSet<regno_t> overlapPhyRegSet;
+    LiveInterval *liveParent = nullptr;  /* Current li is in aother li's hole. */
+    LiveInterval *liveChild = nullptr;   /* Another li is in current li's hole. */
+    uint32 resultCount = 0;              /* number of times this vreg has been written */
+    uint8 inCatchState = kRegCatchNotInit;         /* part or all of live interval is outside of catch blocks */
+    uint8 inCleanUpState = kRegCleanupNotInit;     /* part or all of live interval is outside of cleanup blocks */
+  };
+
+  struct ActiveCmp {
+    bool operator()(const LiveInterval *lhs, const LiveInterval *rhs) const {
+      CHECK_NULL_FATAL(lhs);
+      CHECK_NULL_FATAL(rhs);
+      /* elements considered equal if return false */
+      if (lhs == rhs) {
+        return false;
+      }
+      if (lhs->GetFirstDef() == rhs->GetFirstDef() && lhs->GetLastUse() == rhs->GetLastUse() &&
+          lhs->GetRegNO() == rhs->GetRegNO() && lhs->GetRegType() == rhs->GetRegType() &&
+          lhs->GetAssignedReg() == rhs->GetAssignedReg()) {
+        return false;
+      }
+      if (lhs->GetFirstDef() == rhs->GetFirstDef() && lhs->GetLastUse() == rhs->GetLastUse() &&
+          lhs->GetPhysUse() == rhs->GetPhysUse() && lhs->GetRegType() == rhs->GetRegType()) {
+        return lhs->GetRegNO() < rhs->GetRegNO();
+      }
+      if (lhs->GetPhysUse() != 0 && rhs->GetPhysUse() != 0) {
+        if (lhs->GetFirstDef() == rhs->GetFirstDef()) {
+          return lhs->GetPhysUse() < rhs->GetPhysUse();
+        } else {
+          return lhs->GetFirstDef() < rhs->GetFirstDef();
+        }
+      }
+      /* At this point, lhs != rhs */
+      if (lhs->GetLastUse() == rhs->GetLastUse()) {
+        return lhs->GetFirstDef() <= rhs->GetFirstDef();
+      }
+      return lhs->GetLastUse() < rhs->GetLastUse();
+    }
+  };
+
+ public:
+  LSRALinearScanRegAllocator(CGFunc &cgFunc, MemPool &memPool)
+      : RegAllocator(cgFunc, memPool),
+        liveIntervalsArray(alloc.Adapter()),
+        lastIntParamLi(alloc.Adapter()),
+        lastFpParamLi(alloc.Adapter()),
+        initialQue(alloc.Adapter()),
+        intParamQueue(alloc.Adapter()),
+        fpParamQueue(alloc.Adapter()),
+        callList(alloc.Adapter()),
+        active(alloc.Adapter()),
+        intCallerRegSet(alloc.Adapter()),
+        intCalleeRegSet(alloc.Adapter()),
+        intParamRegSet(alloc.Adapter()),
+        intSpillRegSet(alloc.Adapter()),
+        fpCallerRegSet(alloc.Adapter()),
+        fpCalleeRegSet(alloc.Adapter()),
+        fpParamRegSet(alloc.Adapter()),
+        fpSpillRegSet(alloc.Adapter()),
+        calleeUseCnt(alloc.Adapter()) {
+    for (uint32 i = 0; i < regInfo->GetIntRegsParmsNum(); ++i) {
+      intParamQueue.push_back(initialQue);
+    }
+    for (int32 i = 0; i < regInfo->GetFloatRegsParmsNum(); ++i) {
+      fpParamQueue.push_back(initialQue);
+    }
+    firstIntReg = *regInfo->GetRegsFromType(kRegTyInt).begin();
+    firstFpReg = *regInfo->GetRegsFromType(kRegTyFloat).begin();
+  }
+  ~LSRALinearScanRegAllocator() override = default;
+
+  bool AllocateRegisters() override;
+  void PreWork();
+  bool CheckForReg(Operand &opnd, const Insn &insn, const LiveInterval &li, regno_t regNO, bool isDef) const;
+  void PrintRegSet(const MapleSet<uint32> &set, const std::string &str) const;
+  void PrintLiveInterval(const LiveInterval &li, const std::string &str) const;
+  void PrintLiveRanges() const;
+  void PrintParamQueue(const std::string &str);
+  void PrintCallQueue(const std::string &str) const;
+  void PrintActiveList(const std::string &str, uint32 len = 0) const;
+  void PrintActiveListSimple() const;
+  void PrintLiveIntervals() const;
+  void DebugCheckActiveList() const;
+  void InitFreeRegPool();
+  void RecordCall(Insn &insn);
+  void RecordPhysRegs(const RegOperand &regOpnd, uint32 insnNum, bool isDef);
+  void UpdateLiveIntervalState(const BB &bb, LiveInterval &li) const;
+  void SetupLiveInterval(Operand &opnd, Insn &insn, bool isDef, uint32 &nUses);
+  void UpdateLiveIntervalByLiveIn(const BB &bb, uint32 insnNum);
+  void UpdateParamLiveIntervalByLiveIn(const BB &bb, uint32 insnNum);
+  void ComputeLiveIn(BB &bb, uint32 insnNum);
+  void ComputeLiveOut(BB &bb, uint32 insnNum);
+  void ComputeLiveIntervalForEachOperand(Insn &insn);
+  void ComputeLiveInterval();
+  void FindLowestPrioInActive(LiveInterval *&targetLi, RegType regType = kRegTyInt, bool startRa = false);
+  void LiveIntervalAnalysis();
+  bool OpndNeedAllocation(const Insn &insn, Operand &opnd, bool isDef, uint32 insnNum);
+  void InsertParamToActive(Operand &opnd);
+  void InsertToActive(Operand &opnd, uint32 insnNum);
+  void ReturnPregToSet(const LiveInterval &li, uint32 preg);
+  void ReleasePregToSet(const LiveInterval &li, uint32 preg);
+  void UpdateActiveAtRetirement(uint32 insnID);
+  void RetireFromActive(const Insn &insn);
+  void AssignPhysRegsForInsn(Insn &insn);
+  RegOperand *GetReplaceOpnd(Insn &insn, Operand &opnd, uint32 &spillIdx, bool isDef);
+  RegOperand *GetReplaceUdOpnd(Insn &insn, Operand &opnd, uint32 &spillIdx);
+
+  void SetAllocMode();
+  void CheckSpillCallee();
+  void LinearScanRegAllocator();
+  void FinalizeRegisters();
+  void SpillOperand(Insn &insn, Operand &opnd, bool isDef, uint32 spillIdx);
+  void SetOperandSpill(Operand &opnd);
+  RegOperand *HandleSpillForInsn(const Insn &insn, Operand &opnd);
+  MemOperand *GetSpillMem(uint32 vRegNO, bool isDest, Insn &insn, regno_t regNO,
+                          bool &isOutOfRange) const;
+  void InsertCallerSave(Insn &insn, Operand &opnd, bool isDef);
+  uint32 GetRegFromSet(MapleSet<uint32> &set, regno_t offset, LiveInterval &li, regno_t forcedReg = 0) const;
+  uint32 AssignSpecialPhysRegPattern(const Insn &insn, LiveInterval &li);
+  uint32 FindAvailablePhyReg(LiveInterval &li, const Insn &insn);
+  RegOperand *AssignPhysRegs(Operand &opnd, const Insn &insn);
+  void SetupIntervalRangesByOperand(Operand &opnd, const Insn &insn, uint32 blockFrom, bool isDef, bool isUse);
+  void BuildIntervalRangesForEachOperand(const Insn &insn, uint32 blockFrom);
+  void BuildIntervalRanges();
+  uint32 FillInHole(LiveInterval &li);
+
+ private:
+  uint32 FindAvailablePhyRegByFastAlloc(LiveInterval &li);
+  bool NeedSaveAcrossCall(LiveInterval &li);
+  uint32 FindAvailablePhyReg(LiveInterval &li, const Insn &insn, bool isIntReg);
+
+  regno_t firstIntReg = 0;
+  regno_t firstFpReg = 0;
+
+  /* Comparison function for LiveInterval */
+  static constexpr uint32 kMaxSpillRegNum = 3;
+  static constexpr uint32 kMaxFpSpill = 2;
+  MapleVector<LiveInterval*> liveIntervalsArray;
+  MapleVector<LiveInterval*> lastIntParamLi;
+  MapleVector<LiveInterval*> lastFpParamLi;
+  MapleQueue<LiveInterval*> initialQue;
+  using SingleQue = MapleQueue<LiveInterval*>;
+  MapleVector<SingleQue> intParamQueue;
+  MapleVector<SingleQue> fpParamQueue;
+  MapleList<LiveInterval*> callList;
+  MapleSet<LiveInterval*, ActiveCmp> active;
+  MapleSet<LiveInterval*, ActiveCmp>::iterator itFinded;
+
+  /* Change these into vectors so it can be added and deleted easily. */
+  MapleSet<regno_t> intCallerRegSet;   /* integer caller saved */
+  MapleSet<regno_t> intCalleeRegSet;   /*         callee       */
+  MapleSet<regno_t> intParamRegSet;    /*         parameters    */
+  MapleVector<regno_t> intSpillRegSet; /* integer regs put aside for spills */
+
+  /* and register */
+  uint32 intCallerMask = 0;           /* bit mask for all possible caller int */
+  uint32 intCalleeMask = 0;           /*                           callee     */
+  uint32 intParamMask = 0;            /*     (physical-register)   parameter  */
+  MapleSet<uint32> fpCallerRegSet;    /* float caller saved */
+  MapleSet<uint32> fpCalleeRegSet;    /*       callee       */
+  MapleSet<uint32> fpParamRegSet;     /*       parameter    */
+  MapleVector<uint32> fpSpillRegSet;  /* float regs put aside for spills */
+  MapleVector<uint32> calleeUseCnt;   /* Number of time callee reg is seen */
+  Bfs *bfs = nullptr;
+  uint32 fpCallerMask = 0;            /* bit mask for all possible caller fp */
+  uint32 fpCalleeMask = 0;            /*                           callee    */
+  uint32 fpParamMask = 0;             /*      (physical-register)  parameter */
+  uint32 intBBDefMask = 0;            /* locally which physical reg is defined */
+  uint32 fpBBDefMask = 0;
+  uint32 debugSpillCnt = 0;
+  uint32 regUsedInBBSz = 0;
+  uint64 *regUsedInBB = nullptr;
+  uint32 maxInsnNum = 0;
+  regno_t minVregNum = 0;
+  regno_t maxVregNum = 0xFFFFFFFF;
+  bool fastAlloc = false;
+  bool spillAll = false;
+  bool needExtraSpillReg = false;
+  bool isSpillZero = false;
+  bool shouldOptIntCallee = false;
+  bool shouldOptFpCallee = false;
+  uint64 spillCount = 0;
+  uint64 reloadCount = 0;
+  uint64 callerSaveSpillCount = 0;
+  uint64 callerSaveReloadCount = 0;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_REG_ALLOC_LSRA_H */
diff --git a/src/mapleall/maple_be/include/cg/reg_coalesce.h b/src/mapleall/maple_be/include/cg/reg_coalesce.h
new file mode 100644
index 0000000000000000000000000000000000000000..d905f08a7591e9a17967d975e650864389670fac
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/reg_coalesce.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_REGCOALESCE_H
+#define MAPLEBE_INCLUDE_CG_REGCOALESCE_H
+#include "live.h"
+
+namespace maplebe {
+
+using PosPair = std::pair<uint32, uint32>;
+class LiveInterval {
+ public:
+  explicit LiveInterval(MapleAllocator &allocator)
+      : ranges(allocator.Adapter()),
+        conflict(allocator.Adapter()),
+        defPoints(allocator.Adapter()),
+        usePoints(allocator.Adapter()),
+        alloc(allocator) {}
+
+  void IncNumCall() {
+    ++numCall;
+  }
+
+  MapleMap<uint32, MapleVector<PosPair>> &GetRanges() {
+    return ranges;
+  }
+
+  const MapleMap<uint32, MapleVector<PosPair>> &GetRanges() const {
+    return ranges;
+  }
+
+  void AddRange(uint32 bbid, uint32 end, bool alreadLive) {
+    auto it = ranges.find(bbid);
+    if (it == ranges.end()) {
+      MapleVector<PosPair> posVec(alloc.Adapter());
+      posVec.emplace_back(std::pair(end, end));
+      ranges.emplace(bbid, posVec);
+    } else {
+      MapleVector<PosPair> &posVec = it->second;
+      if (alreadLive) {
+        PosPair lastPos = posVec[posVec.size() - 1];
+        posVec[posVec.size() - 1] = std::pair(end, lastPos.second);
+      } else {
+        posVec.emplace_back(std::pair(end, end));
+      }
+    }
+  }
+
+  void MergeRanges(LiveInterval &lr) {
+    const MapleMap<uint32, MapleVector<PosPair>> lrDestRanges = lr.GetRanges();
+    for (auto &destRange : lrDestRanges) {
+      uint32 bbid = destRange.first;
+      auto &destPosVec = destRange.second;
+      auto it = ranges.find(bbid);
+      if (it == ranges.end()) {
+        /* directly add it */
+        MapleVector<PosPair> posVec(alloc.Adapter());
+        for (auto pos: destPosVec) {
+          posVec.emplace_back(std::pair(pos.first, pos.second));
+        }
+        ranges.emplace(bbid, posVec);
+      } else {
+        /* merge it simply, so that subpos may overlap. */
+        auto &srcPosVec = it->second;
+        for (auto pos1 : destPosVec) {
+          bool merged = false;
+          for (auto &pos2 : srcPosVec) {
+            if (!((pos1.first < pos2.first && pos1.second < pos2.first) ||
+                (pos2.first < pos1.second && pos2.second < pos1.first))) {
+              uint32 bgn = pos1.first < pos2.first ? pos1.first : pos2.first;
+              uint32 end = pos1.second > pos2.second ? pos1.second : pos2.second;
+              pos2 = std::pair(bgn, end);
+              merged = true;
+            }
+          }
+          /* add it directly when no overlap */
+          if (!merged) {
+            srcPosVec.emplace_back(std::pair(pos1.first, pos1.second));
+          }
+        }
+      }
+    }
+  }
+
+  void MergeConflict(LiveInterval &lr) {
+    for (auto reg : lr.conflict) {
+      conflict.insert(reg);
+    }
+  }
+
+  void MergeRefPoints(LiveInterval &lr) {
+    if (lr.GetDefPoint().size() != k1ByteSize) {
+      for (auto insn : lr.defPoints) {
+        defPoints.insert(insn);
+      }
+    }
+    for (auto insn : lr.usePoints) {
+      usePoints.insert(insn);
+    }
+  }
+
+  void AddConflict(regno_t val) {
+    conflict.insert(val);
+  }
+
+  MapleSet<uint32> GetConflict() {
+    return conflict;
+  }
+
+  void AddRefPoint(Insn *val, bool isDef) {
+    if (isDef) {
+      defPoints.insert(val);
+    } else {
+      usePoints.insert(val);
+    }
+  }
+
+  InsnMapleSet &GetDefPoint() {
+    return defPoints;
+  }
+
+  InsnMapleSet &GetUsePoint() {
+    return usePoints;
+  }
+
+  bool IsConflictWith(regno_t val) {
+    return conflict.find(val) != conflict.end();
+  }
+
+  RegType GetRegType() const {
+    return regType;
+  }
+
+  void SetRegType(RegType val) {
+    this->regType = val;
+  }
+
+  regno_t GetRegNO() const {
+    return regno;
+  }
+
+  void SetRegNO(regno_t val) {
+    this->regno = val;
+  }
+
+  void Dump() const {
+    std::cout << "R" << regno << ": ";
+    for (auto &range : GetRanges()) {
+      uint32 bbid = range.first;
+      std::cout << "BB" << bbid <<  ": < " ;
+      for (auto pos : range.second) {
+        std::cout << "[" <<  pos.first << ", " << pos.second << ") ";
+      }
+      std::cout <<  " > " ;
+    }
+    std::cout << "\n";
+  }
+  void DumpDefs() {
+    std::cout << "R" << regno << ": ";
+    for (auto def : defPoints) {
+      def->Dump();
+    }
+    std::cout << "\n";
+  }
+  void DumpUses() {
+    std::cout << "R" << regno << ": ";
+    for (auto def : usePoints) {
+      def->Dump();
+    }
+    std::cout << "\n";
+  }
+
+ private:
+  MapleMap<uint32, MapleVector<PosPair>> ranges;
+  MapleSet<uint32> conflict;
+  InsnMapleSet defPoints;
+  InsnMapleSet usePoints;
+  uint32 numCall = 0;
+  RegType regType = kRegTyUndef;
+  regno_t regno = 0;
+  MapleAllocator &alloc;
+};
+
+class LiveIntervalAnalysis {
+ public:
+  LiveIntervalAnalysis(CGFunc &func, MemPool &memPool)
+      : cgFunc(&func),
+        memPool(&memPool),
+        alloc(&memPool),
+        vregIntervals(alloc.Adapter()) {}
+
+  virtual ~LiveIntervalAnalysis() {
+    cgFunc = nullptr;
+    memPool = nullptr;
+    bfs = nullptr;
+  }
+
+  virtual void ComputeLiveIntervals() = 0;
+  virtual void CoalesceRegisters() = 0;
+  void Run();
+  void Analysis();
+  void DoAnalysis();
+  void ClearBFS();
+  void Dump();
+  void CoalesceLiveIntervals(LiveInterval &lrDest, LiveInterval &lrSrc);
+  LiveInterval *GetLiveInterval(regno_t regno) {
+    MapleMap<regno_t, LiveInterval*>::const_iterator it = vregIntervals.find(regno);
+    if (it == vregIntervals.cend()) {
+      return nullptr;
+    } else {
+      return it->second;
+    }
+  }
+
+ protected:
+  CGFunc *cgFunc;
+  MemPool *memPool;
+  MapleAllocator alloc;
+  MapleMap<regno_t, LiveInterval*> vregIntervals;
+  Bfs *bfs = nullptr;
+  bool runAnalysis = false;
+};
+
+
+MAPLE_FUNC_PHASE_DECLARE(CgRegCoalesce, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CGliveIntervalAnalysis, maplebe::CGFunc)
+  LiveIntervalAnalysis *GetResult() {
+    return liveInterval;
+  }
+  LiveIntervalAnalysis *liveInterval = nullptr;
+  OVERRIDE_DEPENDENCE
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_REGCOALESCE_H */
diff --git a/src/mapleall/maple_be/include/cg/reg_info.h b/src/mapleall/maple_be/include/cg/reg_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a1100c12d0f2f2ea8b9a2b3432484f7f853ca16
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/reg_info.h
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_REG_INFO_H
+#define MAPLEBE_INCLUDE_CG_REG_INFO_H
+
+#include "isa.h"
+#include "insn.h"
+
+namespace maplebe {
+constexpr size_t kSpillMemOpndNum = 4;
+
+class RegisterInfo {
+ public:
+  explicit RegisterInfo(MapleAllocator &mallocator)
+      : allIntRegs(mallocator.Adapter()),
+        allFpRegs(mallocator.Adapter()),
+        allregs(mallocator.Adapter()) {}
+
+  virtual ~RegisterInfo() {
+    cgFunc = nullptr;
+  }
+
+  virtual void Init() = 0;
+  virtual void Fini() = 0;
+  const MapleSet<regno_t> &GetAllRegs() const {
+    return allregs;
+  }
+  const MapleSet<regno_t> &GetRegsFromType(RegType regTy) const {
+    if (regTy == kRegTyInt) {
+      return allIntRegs;
+    } else if (regTy == kRegTyFloat) {
+      return allFpRegs;
+    } else {
+      CHECK_FATAL(false, "NIY, unsupported reg type");
+    }
+  }
+  void AddToAllRegs(regno_t regNo) {
+    (void)allregs.insert(regNo);
+  }
+  void AddToIntRegs(regno_t regNo) {
+    (void)allIntRegs.insert(regNo);
+  }
+  void AddToFpRegs(regno_t regNo) {
+    (void)allFpRegs.insert(regNo);
+  }
+  void SetCurrFunction(CGFunc &func) {
+    cgFunc = &func;
+  }
+  CGFunc *GetCurrFunction() const {
+    return cgFunc;
+  }
+  virtual RegOperand *GetOrCreatePhyRegOperand(regno_t regNO, uint32 size, RegType kind, uint32 flag = 0) = 0;
+  virtual bool IsGPRegister(regno_t regNO) const = 0;
+  virtual bool IsPreAssignedReg(regno_t regNO) const = 0;
+  virtual uint32 GetIntParamRegIdx(regno_t regNO) const = 0;
+  virtual uint32 GetFpParamRegIdx(regno_t regNO) const = 0;
+  virtual bool IsSpecialReg(regno_t regno) const = 0;
+  virtual bool IsAvailableReg(regno_t regNO) const = 0;
+  virtual bool IsCalleeSavedReg(regno_t regno) const = 0;
+  virtual bool IsYieldPointReg(regno_t regNO) const = 0;
+  virtual bool IsUntouchableReg(uint32 regNO) const = 0;
+  virtual bool IsUnconcernedReg(regno_t regNO) const = 0;
+  virtual bool IsUnconcernedReg(const RegOperand &regOpnd) const = 0;
+  virtual bool IsVirtualRegister(const RegOperand &regOpnd) = 0;
+  virtual bool IsVirtualRegister(regno_t regno) = 0;
+  virtual bool IsFramePointReg(regno_t regNO) const = 0;
+  virtual bool IsReservedReg(regno_t regNO, bool doMultiPass) const = 0;
+  virtual void SaveCalleeSavedReg(MapleSet<regno_t> savedRegs) = 0;
+  virtual uint32 GetIntRegsParmsNum() = 0;
+  virtual uint32 GetIntRetRegsNum() = 0;
+  virtual uint32 GetFpRetRegsNum() = 0;
+  virtual uint32 GetFloatRegsParmsNum() = 0;
+  virtual regno_t GetLastParamsIntReg() = 0;
+  virtual regno_t GetLastParamsFpReg() = 0;
+  virtual regno_t GetIntRetReg(uint32 idx)  = 0;
+  virtual regno_t GetFpRetReg(uint32 idx)  = 0;
+  virtual regno_t GetReservedSpillReg() = 0;
+  virtual regno_t GetSecondReservedSpillReg() = 0;
+  virtual regno_t GetYieldPointReg() const = 0;
+  virtual regno_t GetStackPointReg() const = 0;
+  virtual uint32 GetAllRegNum() = 0;
+  virtual uint32 GetNormalUseOperandNum() = 0;
+  virtual regno_t GetInvalidReg() = 0;
+  virtual bool IsSpillRegInRA(regno_t regNO, bool has3RegOpnd) = 0;
+  virtual Insn *BuildStrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) = 0;
+  virtual Insn *BuildLdrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) = 0;
+  virtual MemOperand *AdjustMemOperandIfOffsetOutOfRange(MemOperand *memOpnd, regno_t vrNum,
+      bool isDest, Insn &insn, regno_t regNum, bool &isOutOfRange) = 0;
+
+  // used in color ra
+  virtual regno_t GetIntSpillFillReg(size_t idx) const = 0;
+  virtual regno_t GetFpSpillFillReg(size_t idx) const = 0;
+ private:
+  MapleSet<regno_t> allIntRegs;
+  MapleSet<regno_t> allFpRegs;
+  MapleSet<regno_t> allregs;
+  CGFunc *cgFunc = nullptr;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_REG_INFO_H */
diff --git a/src/mapleall/maple_be/include/cg/regsaves.h b/src/mapleall/maple_be/include/cg/regsaves.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f20313a9ec66c01957725e113a60512bcf47f45
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/regsaves.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_REGSAVES_OPT_H
+#define MAPLEBE_INCLUDE_CG_REGSAVES_OPT_H
+
+#include "cgfunc.h"
+#include "cg_phase.h"
+
+namespace maplebe {
+class RegSavesOpt {
+ public:
+  RegSavesOpt(CGFunc &func, MemPool &pool)
+      : cgFunc(&func),
+        memPool(&pool),
+        alloc(&pool) {}
+
+  virtual ~RegSavesOpt() = default;
+
+  virtual void Run() {}
+
+  std::string PhaseName() const {
+    return "regsavesopt";
+  }
+
+  CGFunc *GetCGFunc() const {
+    return cgFunc;
+  }
+
+  MemPool *GetMemPool() const {
+    return memPool;
+  }
+
+  bool GetEnabledDebug() const {
+    return enabledDebug;
+  }
+
+  void SetEnabledDebug(bool d) {
+    enabledDebug = d;
+  }
+
+ protected:
+  CGFunc *cgFunc;
+  MemPool *memPool;
+  MapleAllocator alloc;
+  bool enabledDebug = false;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgRegSavesOpt, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_REGSAVES_OPT_H */
diff --git a/src/mapleall/maple_be/include/cg/rematerialize.h b/src/mapleall/maple_be/include/cg/rematerialize.h
new file mode 100644
index 0000000000000000000000000000000000000000..80c677e85ce9fe830fbbce4bee99fc24c87b081b
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/rematerialize.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_REMATERIALIZE_H
+#define MAPLEBE_INCLUDE_CG_REMATERIALIZE_H
+
+#include "cgfunc.h"
+
+namespace maplebe {
+enum RematLevel {
+  kRematOff = 0,
+  kRematConst = 1,
+  kRematAddr = 2,
+  kRematDreadLocal = 3,
+  kRematDreadGlobal = 4
+};
+
+class LiveRange;
+
+class Rematerializer {
+ public:
+  Rematerializer() = default;
+  virtual ~Rematerializer() = default;
+
+  void SetRematerializable(const MIRConst *c) {
+    op = OP_constval;
+    rematInfo.mirConst = c;
+  }
+
+  void SetRematerializable(Opcode opcode, const MIRSymbol *symbol, FieldID fieldId, bool addrUp) {
+    op = opcode;
+    rematInfo.sym = symbol;
+    fieldID = fieldId;
+    addrUpper = addrUp;
+  }
+
+  void SetRematLevel(RematLevel val) {
+    rematLevel = val;
+  }
+  RematLevel GetRematLevel() const {
+    return rematLevel;
+  }
+
+  Opcode GetOp() const {
+    return op;
+  }
+
+  bool IsRematerializable(CGFunc &cgFunc, RematLevel rematLev, const LiveRange &lr) const;
+  std::vector<Insn*> Rematerialize(CGFunc &cgFunc, RegOperand &regOp, const LiveRange &lr);
+
+ protected:
+  RematLevel rematLevel = kRematOff;
+  Opcode op = OP_undef;               /* OP_constval, OP_addrof or OP_dread if rematerializable */
+  union RematInfo {
+    const MIRConst *mirConst;
+    const MIRSymbol *sym;
+  } rematInfo;                        /* info for rematerializing value */
+  FieldID fieldID = 0;                /* used only when op is OP_addrof or OP_dread */
+  bool addrUpper = false;             /* indicates the upper bits of an addrof */
+
+ private:
+  bool IsRematerializableForAddrof(CGFunc &cgFunc, const LiveRange &lr) const;
+  bool IsRematerializableForDread(CGFunc &cgFunc, RematLevel rematLev) const;
+
+  virtual bool IsRematerializableForConstval(int64 val, uint32 bitLen) const = 0;
+  virtual bool IsRematerializableForDread(int32 offset) const = 0;
+
+  virtual std::vector<Insn*> RematerializeForConstval(CGFunc &cgFunc, RegOperand &regOp,
+      const LiveRange &lr) = 0;
+
+  virtual std::vector<Insn*> RematerializeForAddrof(CGFunc &cgFunc, RegOperand &regOp,
+      int32 offset) = 0;
+
+  virtual std::vector<Insn*> RematerializeForDread(CGFunc &cgFunc, RegOperand &regOp,
+      int32 offset, PrimType type) = 0;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_REMATERIALIZE_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/schedule.h b/src/mapleall/maple_be/include/cg/schedule.h
new file mode 100644
index 0000000000000000000000000000000000000000..647b2501f12f67619e7e20cae27ddd815a08c8d0
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/schedule.h
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_SCHEDULE_H
+#define MAPLEBE_INCLUDE_CG_SCHEDULE_H
+
+#include "data_dep_base.h"
+#include "data_dep_analysis.h"
+#include "insn.h"
+#include "live.h"
+#include "mad.h"
+
+namespace maplebe {
+#define LIST_SCHED_DUMP_NEWPM CG_DEBUG_FUNC(f)
+#define LIST_SCHED_DUMP_REF CG_DEBUG_FUNC(cgFunc)
+
+class RegPressureSchedule {
+ public:
+  RegPressureSchedule(CGFunc &func, MapleAllocator &alloc)
+      : cgFunc(func), liveReg(alloc.Adapter()), scheduledNode(alloc.Adapter()),
+        originalNodeSeries(alloc.Adapter()), readyList(alloc.Adapter()),
+        partialList(alloc.Adapter()), partialSet(alloc.Adapter()),
+        partialScheduledNode(alloc.Adapter()), optimisticScheduledNodes(alloc.Adapter()),
+        splitterIndexes(alloc.Adapter()), liveInRegNO(alloc.Adapter()), liveOutRegNO(alloc.Adapter()) {}
+  virtual ~RegPressureSchedule() = default;
+
+  void InitBBInfo(BB &b, MemPool &memPool, const MapleVector<DepNode*> &nodes);
+  void BuildPhyRegInfo(const std::vector<int32> &regNumVec);
+  void InitPartialSplitters(const MapleVector<DepNode*> &nodes);
+  void Init(const MapleVector<DepNode*> &nodes);
+  void UpdateBBPressure(const DepNode &node);
+  void CalculatePressure(DepNode &node, regno_t reg, bool def) const;
+  void SortReadyList();
+  static bool IsLastUse(const DepNode &node, regno_t regNO) ;
+  void ReCalculateDepNodePressure(DepNode &node) const;
+  void UpdateLiveReg(const DepNode &node, regno_t reg, bool def);
+  bool CanSchedule(const DepNode &node) const;
+  void UpdateReadyList(const DepNode &node);
+  void BruteUpdateReadyList(const DepNode &node, std::vector<bool> &changedToReady);
+  void RestoreReadyList(DepNode &node, std::vector<bool> &changedToReady);
+  void UpdatePriority(DepNode &node);
+  void CalculateMaxDepth(const MapleVector<DepNode*> &nodes) const;
+  void CalculateNear(const DepNode &node);
+  static bool DepNodePriorityCmp(const DepNode *node1, const DepNode *node2);
+  DepNode *ChooseNode();
+  void DoScheduling(MapleVector<DepNode*> &nodes);
+  void HeuristicScheduling(MapleVector<DepNode*> &nodes);
+  int CalculateRegisterPressure(MapleVector<DepNode*> &nodes);
+  void PartialScheduling(MapleVector<DepNode*> &nodes);
+  void BruteForceScheduling();
+  void CalculatePredSize(DepNode &node);
+  void InitBruteForceScheduling(MapleVector<DepNode*> &nodes);
+  void EmitSchedulingSeries(MapleVector<DepNode*> &nodes);
+ private:
+  void DumpBBPressureInfo() const;
+  void DumpBBLiveInfo() const;
+  void DumpReadyList() const;
+  void DumpSelectInfo(const DepNode &node) const;
+  static void DumpDependencyInfo(const MapleVector<DepNode*> &nodes);
+  void ReportScheduleError() const;
+  void ReportScheduleOutput() const;
+  RegType GetRegisterType(regno_t reg) const;
+
+  CGFunc &cgFunc;
+  BB *bb = nullptr;
+  int32 *maxPressure = nullptr;
+  int32 *curPressure = nullptr;
+  MapleUnorderedSet<regno_t> liveReg;
+  /* save node that has been scheduled. */
+  MapleVector<DepNode*> scheduledNode;
+  MapleVector<DepNode*> originalNodeSeries;
+  MapleVector<DepNode*> readyList;
+  /* save partial nodes to be scheduled */
+  MapleVector<DepNode*> partialList;
+  MapleSet<DepNode*> partialSet;
+  /* save partial nodes which have been scheduled. */
+  MapleVector<DepNode*> partialScheduledNode;
+  /* optimistic schedule series with minimum register pressure */
+  MapleVector<DepNode*> optimisticScheduledNodes;
+  /* save split points */
+  MapleVector<int> splitterIndexes;
+  /* save integer register pressure */
+  std::vector<int> integerRegisterPressureList;
+  /* save the amount of every type register. */
+  int32 *physicalRegNum = nullptr;
+  int32 maxPriority = 0;
+  int32 scheduleSeriesCount = 0;
+  /* live in register set */
+  MapleSet<regno_t> liveInRegNO;
+  /* live out register set */
+  MapleSet<regno_t> liveOutRegNO;
+  /* register pressure without pre-scheduling */
+  int originalPressure = 0;
+  /* register pressure after pre-scheduling */
+  int scheduledPressure = 0;
+  /* minimum pressure ever met */
+  int minPressure = -1;
+};
+
+enum SimulateType : uint8 {
+  kListSchedule,
+  kBruteForce,
+  kSimulateOnly
+};
+
+class Schedule {
+ public:
+  Schedule(CGFunc &func, MemPool &memPool, LiveAnalysis &liveAnalysis, const std::string &phase)
+      : phaseName(phase),
+        cgFunc(func),
+        memPool(memPool),
+        alloc(&memPool),
+        live(liveAnalysis),
+        considerRegPressure(false),
+        nodes(alloc.Adapter()),
+        readyList(alloc.Adapter()),
+        liveInRegNo(alloc.Adapter()),
+        liveOutRegNo(alloc.Adapter()) {}
+
+  virtual ~Schedule() = default;
+  virtual void MemoryAccessPairOpt() = 0;
+  virtual void ClinitPairOpt() = 0;
+  virtual uint32 DoSchedule() = 0;
+  virtual uint32 DoBruteForceSchedule() = 0;
+  virtual uint32 SimulateOnly() = 0;
+  virtual void UpdateBruteForceSchedCycle() = 0;
+  virtual void IterateBruteForce(DepNode &targetNode, MapleVector<DepNode*> &readyList, uint32 currCycle,
+                                 MapleVector<DepNode*> &scheduledNodes, uint32 &maxCycleCount,
+                                 MapleVector<DepNode*> &optimizedScheduledNodes) = 0;
+  virtual void UpdateReadyList(DepNode &targetNode, MapleVector<DepNode*> &readyList, bool updateEStart) = 0;
+  virtual void ListScheduling(bool beforeRA) = 0;
+  virtual void FinalizeScheduling(BB &bb, const DataDepBase &dataDepBase) = 0;
+
+ protected:
+  virtual void Init() = 0;
+  virtual uint32 ComputeEstart(uint32 cycle) = 0;
+  virtual void ComputeLstart(uint32 maxEstart) = 0;
+  virtual void UpdateELStartsOnCycle(uint32 cycle) = 0;
+  virtual void RandomTest() = 0;
+  virtual void EraseNodeFromReadyList(const DepNode &target) = 0;
+  virtual void EraseNodeFromNodeList(const DepNode &target, MapleVector<DepNode*> &nodeList) = 0;
+  virtual uint32 GetNextSepIndex() const = 0;
+  virtual void CountUnitKind(const DepNode &depNode, uint32 array[], const uint32 arraySize) const = 0;
+  virtual void FindAndCombineMemoryAccessPair(const std::vector<DepNode*> &memList) = 0;
+  virtual void RegPressureScheduling(BB &bb, MapleVector<DepNode*> &nodes) = 0;
+  virtual bool CanCombine(const Insn &insn) const = 0;
+  void SetConsiderRegPressure() {
+    considerRegPressure = true;
+  }
+  bool GetConsiderRegPressure() const {
+    return considerRegPressure;
+  }
+  void InitIDAndLoc();
+  void RestoreFirstLoc();
+  std::string PhaseName() const {
+    return phaseName;
+  }
+
+  const std::string phaseName;
+  CGFunc &cgFunc;
+  MemPool &memPool;
+  MapleAllocator alloc;
+  LiveAnalysis &live;
+  DataDepBase *ddb = nullptr;
+  IntraDataDepAnalysis *intraDDA = nullptr;
+  MAD *mad = nullptr;
+  uint32 lastSeparatorIndex = 0;
+  uint32 nodeSize = 0;
+  bool considerRegPressure  = false;
+  MapleVector<DepNode*> nodes;      /* Dependence graph */
+  MapleVector<DepNode*> readyList;  /* Ready list. */
+  MapleSet<regno_t> liveInRegNo;
+  MapleSet<regno_t> liveOutRegNo;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgPreScheduling, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE(CgScheduling, maplebe::CGFunc)
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_SCHEDULE_H */
diff --git a/src/mapleall/maple_be/include/cg/sparse_datainfo.h b/src/mapleall/maple_be/include/cg/sparse_datainfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..ccac2aebb6926be68614434e1f3009ce83310856
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/sparse_datainfo.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_SPARSE_DATAINFO_H
+#define MAPLEBE_INCLUDE_CG_SPARSE_DATAINFO_H
+#include "maple_string.h"
+#include "common_utils.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "maple_sparse_bitvector.h"
+
+namespace maplebe {
+class SparseDataInfo {
+ /*
+  * SparseDataInfo has the same imterface like DataInfo
+  * it can be used when the data member is small while the data
+  * range is big.like in live analysis, in some extreme case the
+  * vreg num range is 10k while in each bb, the max num of is 30+
+  */
+ public:
+  SparseDataInfo(uint32 bitNum, MapleAllocator &alloc)
+      : allocator(alloc),
+        info(allocator),
+        maxRegNum(bitNum) {}
+
+  SparseDataInfo(const SparseDataInfo &other, MapleAllocator &alloc)
+      : allocator(alloc),
+        info(other.info, allocator),
+        maxRegNum(other.maxRegNum) {}
+
+  SparseDataInfo(const SparseDataInfo &other)
+    : allocator(other.allocator),
+      info(other.info, allocator),
+      maxRegNum(other.maxRegNum) {}
+
+  SparseDataInfo &Clone(MapleAllocator &alloc) const {
+    auto *dataInfo = alloc.New<SparseDataInfo>(*this, alloc);
+    return *dataInfo;
+  }
+
+  ~SparseDataInfo() = default;
+
+  SparseDataInfo &operator=(const SparseDataInfo &other) {
+    if (this == &other) {
+      return *this;
+    }
+    allocator = other.GetAllocator();
+    info = other.GetInfo();
+    maxRegNum = other.GetMaxRegNum();
+    return *this;
+  }
+
+  void SetBit(uint32 bitNO) {
+    info.Set(bitNO);
+  }
+
+  void ResetBit(uint32 bitNO) {
+    info.Reset(bitNO);
+  }
+
+  bool TestBit(uint32 bitNO) const {
+    return info.Test(bitNO);
+  }
+
+  bool NoneBit() const {
+    return info.Empty();
+  }
+
+  size_t Size() const {
+    return maxRegNum;
+  }
+
+  const MapleAllocator &GetAllocator() const {
+    return allocator;
+  }
+
+  const MapleSparseBitVector<> &GetInfo() const {
+    return info;
+  }
+
+  uint32 GetMaxRegNum() const {
+    return maxRegNum;
+  }
+
+  bool IsEqual(const SparseDataInfo &secondInfo) const {
+    return info == secondInfo.GetInfo();
+  }
+
+  bool IsEqual(const MapleSparseBitVector<> &liveInfoBak) const {
+    return info == liveInfoBak;
+  }
+
+  void AndBits(const SparseDataInfo &secondInfo) {
+    info &= secondInfo.info;
+  }
+
+  void OrBits(const SparseDataInfo &secondInfo) {
+    info |= secondInfo.info;
+  }
+
+  /* if bit in secondElem is 1, bit in current DataInfo is set 0 */
+  void Difference(const SparseDataInfo &secondInfo) {
+    info.Diff(secondInfo.info);
+  }
+
+  void ResetAllBit() {
+    info.Clear();
+  }
+
+  void EnlargeCapacityToAdaptSize(uint32 bitNO) {
+    /* add one more size for each enlarge action */
+  }
+
+  void ClearDataInfo() {
+    info.Clear();
+  }
+
+  template<typename T>
+  void GetBitsOfInfo(T &wordRes) const {
+    info.ConvertToSet(wordRes);
+  }
+
+ private:
+  MapleAllocator allocator;
+  MapleSparseBitVector<> info;
+  uint32 maxRegNum;
+};
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_SPARSE_DATAINFO_H */
diff --git a/src/mapleall/maple_be/include/cg/standardize.h b/src/mapleall/maple_be/include/cg/standardize.h
new file mode 100644
index 0000000000000000000000000000000000000000..dac0e2870202861d6e81b987474de902d89a296e
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/standardize.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_STANDARDIZE_H
+#define MAPLEBE_INCLUDE_STANDARDIZE_H
+
+#include "cgfunc.h"
+namespace maplebe {
+class Standardize {
+ public:
+  explicit Standardize(CGFunc &f) : cgFunc(&f) {}
+
+  virtual ~Standardize() {
+    cgFunc = nullptr;
+  }
+
+  /*
+   * for cpu instruction contains different operands
+   * maple provide a default implement from three address to two address
+   * convertion rule is:
+   * mop(dest, src1, src2) -> mov(dest, src1)
+   *                          mop(dest, src2)
+   * maple provide a default implement from two address to one address for unary op
+   * convertion rule is:
+   * mop(dest, src) -> mov(dest, src1)
+   *                   mop(dest)
+   */
+  void AddressMapping(Insn &insn) const;
+
+  void DoStandardize();
+
+ protected:
+  void SetAddressMapping(bool needMapping) {
+    needAddrMapping = needMapping;
+  }
+  bool NeedAddressMapping(const Insn &insn) {
+    /* Operand number for two addressing mode is 2 */
+    /* and 3 for three addressing mode */
+    needAddrMapping = (insn.GetOperandSize() > 2) || (insn.IsUnaryOp());
+    return needAddrMapping;
+  }
+ private:
+  virtual void StdzMov(Insn &insn) = 0;
+  virtual void StdzStrLdr(Insn &insn) = 0;
+  virtual void StdzBasicOp(Insn &insn) = 0;
+  virtual void StdzUnaryOp(Insn &insn, CGFunc &cgFunc) = 0;
+  virtual void StdzCvtOp(Insn &insn, CGFunc &cgFunc) = 0;
+  virtual void StdzShiftOp(Insn &insn, CGFunc &cgFunc) = 0;
+  CGFunc *cgFunc;
+  bool needAddrMapping = false;
+};
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(InstructionStandardize, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}
+#endif  /* MAPLEBE_INCLUDE_STANDARDIZE_H */
diff --git a/src/mapleall/maple_be/include/cg/strldr.h b/src/mapleall/maple_be/include/cg/strldr.h
new file mode 100644
index 0000000000000000000000000000000000000000..c36e5772923e79c0c686674fe5c7ccf89be502ae
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/strldr.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_STRLDR_H
+#define MAPLEBE_INCLUDE_CG_STRLDR_H
+#include "cg_phase.h"
+#include "maple_phase.h"
+
+namespace maplebe {
+class StoreLoadOpt {
+ public:
+  StoreLoadOpt(CGFunc &func, MemPool &memPool) : cgFunc(func), memPool(memPool) {}
+  virtual ~StoreLoadOpt() = default;
+  virtual void Run() = 0;
+  std::string PhaseName() const {
+    return "storeloadopt";
+  }
+
+ protected:
+  CGFunc &cgFunc;
+  MemPool &memPool;
+  /* if the number of bbs is more than 500 or the number of insns is more than 9000, don't optimize. */
+  static constexpr uint32 kMaxBBNum = 500;
+  static constexpr uint32 kMaxInsnNum = 9000;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(CgStoreLoadOpt, maplebe::CGFunc)
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_STRLDR_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/tailcall.h b/src/mapleall/maple_be/include/cg/tailcall.h
new file mode 100644
index 0000000000000000000000000000000000000000..74eee52b4048724a2128a1c5a6248ca00a432aec
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/tailcall.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_TAILCALL_H
+#define MAPLEBE_INCLUDE_CG_TAILCALL_H
+
+#include "cgfunc.h"
+#include "cg_phase.h"
+#include "cg_dominance.h"
+#include "cg.h"
+#include "cg_ssa.h"
+#include "reg_coalesce.h"
+
+namespace maplebe {
+
+class TailCallOpt {
+ public:
+  TailCallOpt(MemPool &pool, CGFunc &func)
+      : cgFunc(func),
+        memPool(&pool),
+        tmpAlloc(&pool),
+        exitBB2CallSitesMap(tmpAlloc.Adapter()) {
+    exitBB2CallSitesMap.clear();
+  }
+
+  virtual ~TailCallOpt() = default;
+
+  void Run();
+  bool DoTailCallOpt();
+  void TideExitBB();
+  bool OptimizeTailBB(BB &bb, MapleSet<Insn*> &callInsns, const BB &exitBB) const;
+  void TailCallBBOpt(BB &bb, MapleSet<Insn*> &callInsns, BB &exitBB);
+  void ConvertToTailCalls(MapleSet<Insn*> &callInsnsMap);
+  MapleMap<BB*, MapleSet<Insn*>> &GetExitBB2CallSitesMap() {
+    return exitBB2CallSitesMap;
+  }
+  void SetCurTailcallExitBB(BB *bb) {
+    curTailcallExitBB = bb;
+  }
+  BB *GetCurTailcallExitBB() {
+    return curTailcallExitBB;
+  }
+
+  const MemPool *GetMemPool() const {
+    return memPool;
+  }
+
+  virtual bool IsFuncNeedFrame(Insn &callInsn) const = 0;
+  virtual bool InsnIsCallCand(Insn &insn) const = 0;
+  virtual bool InsnIsLoadPair(Insn &insn) const = 0;
+  virtual bool InsnIsMove(Insn &insn) const = 0;
+  virtual bool InsnIsIndirectCall(Insn &insn) const = 0;
+  virtual bool InsnIsCall(Insn &insn) const = 0;
+  virtual bool InsnIsUncondJump(Insn &insn) const = 0;
+  virtual bool InsnIsAddWithRsp(Insn &insn) const = 0;
+  virtual bool OpndIsStackRelatedReg(RegOperand &opnd) const = 0;
+  virtual bool OpndIsR0Reg(RegOperand &opnd) const = 0;
+  virtual bool OpndIsCalleeSaveReg(RegOperand &opnd) const = 0;
+  virtual bool IsAddOrSubOp(MOperator mOp) const = 0;
+  virtual void ReplaceInsnMopWithTailCall(Insn &insn) = 0;
+  bool IsStackAddrTaken();
+
+ protected:
+  CGFunc &cgFunc;
+  MemPool *memPool;
+  MapleAllocator tmpAlloc;
+  bool stackProtect = false;
+  MapleMap<BB*, MapleSet<Insn*>> exitBB2CallSitesMap;
+  BB *curTailcallExitBB = nullptr;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgTailCallOpt, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_TAILCALL_H */
diff --git a/src/mapleall/maple_be/include/cg/valid_bitmask_imm.txt b/src/mapleall/maple_be/include/cg/valid_bitmask_imm.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53a6135b6ebd4f570d728df66a9b2584a3a677ef
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/valid_bitmask_imm.txt
@@ -0,0 +1,5372 @@
+0x5555555555555555,
+0xaaaaaaaaaaaaaaaa,
+0x1111111111111111,
+0x2222222222222222,
+0x4444444444444444,
+0x8888888888888888,
+0x3333333333333333,
+0x6666666666666666,
+0xcccccccccccccccc,
+0x9999999999999999,
+0x7777777777777777,
+0xeeeeeeeeeeeeeeee,
+0xdddddddddddddddd,
+0xbbbbbbbbbbbbbbbb,
+0x0101010101010101,
+0x0202020202020202,
+0x0404040404040404,
+0x0808080808080808,
+0x1010101010101010,
+0x2020202020202020,
+0x4040404040404040,
+0x8080808080808080,
+0x0303030303030303,
+0x0606060606060606,
+0x0c0c0c0c0c0c0c0c,
+0x1818181818181818,
+0x3030303030303030,
+0x6060606060606060,
+0xc0c0c0c0c0c0c0c0,
+0x8181818181818181,
+0x0707070707070707,
+0x0e0e0e0e0e0e0e0e,
+0x1c1c1c1c1c1c1c1c,
+0x3838383838383838,
+0x7070707070707070,
+0xe0e0e0e0e0e0e0e0,
+0xc1c1c1c1c1c1c1c1,
+0x8383838383838383,
+0x0f0f0f0f0f0f0f0f,
+0x1e1e1e1e1e1e1e1e,
+0x3c3c3c3c3c3c3c3c,
+0x7878787878787878,
+0xf0f0f0f0f0f0f0f0,
+0xe1e1e1e1e1e1e1e1,
+0xc3c3c3c3c3c3c3c3,
+0x8787878787878787,
+0x1f1f1f1f1f1f1f1f,
+0x3e3e3e3e3e3e3e3e,
+0x7c7c7c7c7c7c7c7c,
+0xf8f8f8f8f8f8f8f8,
+0xf1f1f1f1f1f1f1f1,
+0xe3e3e3e3e3e3e3e3,
+0xc7c7c7c7c7c7c7c7,
+0x8f8f8f8f8f8f8f8f,
+0x3f3f3f3f3f3f3f3f,
+0x7e7e7e7e7e7e7e7e,
+0xfcfcfcfcfcfcfcfc,
+0xf9f9f9f9f9f9f9f9,
+0xf3f3f3f3f3f3f3f3,
+0xe7e7e7e7e7e7e7e7,
+0xcfcfcfcfcfcfcfcf,
+0x9f9f9f9f9f9f9f9f,
+0x7f7f7f7f7f7f7f7f,
+0xfefefefefefefefe,
+0xfdfdfdfdfdfdfdfd,
+0xfbfbfbfbfbfbfbfb,
+0xf7f7f7f7f7f7f7f7,
+0xefefefefefefefef,
+0xdfdfdfdfdfdfdfdf,
+0xbfbfbfbfbfbfbfbf,
+0x0001000100010001,
+0x0002000200020002,
+0x0004000400040004,
+0x0008000800080008,
+0x0010001000100010,
+0x0020002000200020,
+0x0040004000400040,
+0x0080008000800080,
+0x0100010001000100,
+0x0200020002000200,
+0x0400040004000400,
+0x0800080008000800,
+0x1000100010001000,
+0x2000200020002000,
+0x4000400040004000,
+0x8000800080008000,
+0x0003000300030003,
+0x0006000600060006,
+0x000c000c000c000c,
+0x0018001800180018,
+0x0030003000300030,
+0x0060006000600060,
+0x00c000c000c000c0,
+0x0180018001800180,
+0x0300030003000300,
+0x0600060006000600,
+0x0c000c000c000c00,
+0x1800180018001800,
+0x3000300030003000,
+0x6000600060006000,
+0xc000c000c000c000,
+0x8001800180018001,
+0x0007000700070007,
+0x000e000e000e000e,
+0x001c001c001c001c,
+0x0038003800380038,
+0x0070007000700070,
+0x00e000e000e000e0,
+0x01c001c001c001c0,
+0x0380038003800380,
+0x0700070007000700,
+0x0e000e000e000e00,
+0x1c001c001c001c00,
+0x3800380038003800,
+0x7000700070007000,
+0xe000e000e000e000,
+0xc001c001c001c001,
+0x8003800380038003,
+0x000f000f000f000f,
+0x001e001e001e001e,
+0x003c003c003c003c,
+0x0078007800780078,
+0x00f000f000f000f0,
+0x01e001e001e001e0,
+0x03c003c003c003c0,
+0x0780078007800780,
+0x0f000f000f000f00,
+0x1e001e001e001e00,
+0x3c003c003c003c00,
+0x7800780078007800,
+0xf000f000f000f000,
+0xe001e001e001e001,
+0xc003c003c003c003,
+0x8007800780078007,
+0x001f001f001f001f,
+0x003e003e003e003e,
+0x007c007c007c007c,
+0x00f800f800f800f8,
+0x01f001f001f001f0,
+0x03e003e003e003e0,
+0x07c007c007c007c0,
+0x0f800f800f800f80,
+0x1f001f001f001f00,
+0x3e003e003e003e00,
+0x7c007c007c007c00,
+0xf800f800f800f800,
+0xf001f001f001f001,
+0xe003e003e003e003,
+0xc007c007c007c007,
+0x800f800f800f800f,
+0x003f003f003f003f,
+0x007e007e007e007e,
+0x00fc00fc00fc00fc,
+0x01f801f801f801f8,
+0x03f003f003f003f0,
+0x07e007e007e007e0,
+0x0fc00fc00fc00fc0,
+0x1f801f801f801f80,
+0x3f003f003f003f00,
+0x7e007e007e007e00,
+0xfc00fc00fc00fc00,
+0xf801f801f801f801,
+0xf003f003f003f003,
+0xe007e007e007e007,
+0xc00fc00fc00fc00f,
+0x801f801f801f801f,
+0x007f007f007f007f,
+0x00fe00fe00fe00fe,
+0x01fc01fc01fc01fc,
+0x03f803f803f803f8,
+0x07f007f007f007f0,
+0x0fe00fe00fe00fe0,
+0x1fc01fc01fc01fc0,
+0x3f803f803f803f80,
+0x7f007f007f007f00,
+0xfe00fe00fe00fe00,
+0xfc01fc01fc01fc01,
+0xf803f803f803f803,
+0xf007f007f007f007,
+0xe00fe00fe00fe00f,
+0xc01fc01fc01fc01f,
+0x803f803f803f803f,
+0x00ff00ff00ff00ff,
+0x01fe01fe01fe01fe,
+0x03fc03fc03fc03fc,
+0x07f807f807f807f8,
+0x0ff00ff00ff00ff0,
+0x1fe01fe01fe01fe0,
+0x3fc03fc03fc03fc0,
+0x7f807f807f807f80,
+0xff00ff00ff00ff00,
+0xfe01fe01fe01fe01,
+0xfc03fc03fc03fc03,
+0xf807f807f807f807,
+0xf00ff00ff00ff00f,
+0xe01fe01fe01fe01f,
+0xc03fc03fc03fc03f,
+0x807f807f807f807f,
+0x01ff01ff01ff01ff,
+0x03fe03fe03fe03fe,
+0x07fc07fc07fc07fc,
+0x0ff80ff80ff80ff8,
+0x1ff01ff01ff01ff0,
+0x3fe03fe03fe03fe0,
+0x7fc07fc07fc07fc0,
+0xff80ff80ff80ff80,
+0xff01ff01ff01ff01,
+0xfe03fe03fe03fe03,
+0xfc07fc07fc07fc07,
+0xf80ff80ff80ff80f,
+0xf01ff01ff01ff01f,
+0xe03fe03fe03fe03f,
+0xc07fc07fc07fc07f,
+0x80ff80ff80ff80ff,
+0x03ff03ff03ff03ff,
+0x07fe07fe07fe07fe,
+0x0ffc0ffc0ffc0ffc,
+0x1ff81ff81ff81ff8,
+0x3ff03ff03ff03ff0,
+0x7fe07fe07fe07fe0,
+0xffc0ffc0ffc0ffc0,
+0xff81ff81ff81ff81,
+0xff03ff03ff03ff03,
+0xfe07fe07fe07fe07,
+0xfc0ffc0ffc0ffc0f,
+0xf81ff81ff81ff81f,
+0xf03ff03ff03ff03f,
+0xe07fe07fe07fe07f,
+0xc0ffc0ffc0ffc0ff,
+0x81ff81ff81ff81ff,
+0x07ff07ff07ff07ff,
+0x0ffe0ffe0ffe0ffe,
+0x1ffc1ffc1ffc1ffc,
+0x3ff83ff83ff83ff8,
+0x7ff07ff07ff07ff0,
+0xffe0ffe0ffe0ffe0,
+0xffc1ffc1ffc1ffc1,
+0xff83ff83ff83ff83,
+0xff07ff07ff07ff07,
+0xfe0ffe0ffe0ffe0f,
+0xfc1ffc1ffc1ffc1f,
+0xf83ff83ff83ff83f,
+0xf07ff07ff07ff07f,
+0xe0ffe0ffe0ffe0ff,
+0xc1ffc1ffc1ffc1ff,
+0x83ff83ff83ff83ff,
+0x0fff0fff0fff0fff,
+0x1ffe1ffe1ffe1ffe,
+0x3ffc3ffc3ffc3ffc,
+0x7ff87ff87ff87ff8,
+0xfff0fff0fff0fff0,
+0xffe1ffe1ffe1ffe1,
+0xffc3ffc3ffc3ffc3,
+0xff87ff87ff87ff87,
+0xff0fff0fff0fff0f,
+0xfe1ffe1ffe1ffe1f,
+0xfc3ffc3ffc3ffc3f,
+0xf87ff87ff87ff87f,
+0xf0fff0fff0fff0ff,
+0xe1ffe1ffe1ffe1ff,
+0xc3ffc3ffc3ffc3ff,
+0x87ff87ff87ff87ff,
+0x1fff1fff1fff1fff,
+0x3ffe3ffe3ffe3ffe,
+0x7ffc7ffc7ffc7ffc,
+0xfff8fff8fff8fff8,
+0xfff1fff1fff1fff1,
+0xffe3ffe3ffe3ffe3,
+0xffc7ffc7ffc7ffc7,
+0xff8fff8fff8fff8f,
+0xff1fff1fff1fff1f,
+0xfe3ffe3ffe3ffe3f,
+0xfc7ffc7ffc7ffc7f,
+0xf8fff8fff8fff8ff,
+0xf1fff1fff1fff1ff,
+0xe3ffe3ffe3ffe3ff,
+0xc7ffc7ffc7ffc7ff,
+0x8fff8fff8fff8fff,
+0x3fff3fff3fff3fff,
+0x7ffe7ffe7ffe7ffe,
+0xfffcfffcfffcfffc,
+0xfff9fff9fff9fff9,
+0xfff3fff3fff3fff3,
+0xffe7ffe7ffe7ffe7,
+0xffcfffcfffcfffcf,
+0xff9fff9fff9fff9f,
+0xff3fff3fff3fff3f,
+0xfe7ffe7ffe7ffe7f,
+0xfcfffcfffcfffcff,
+0xf9fff9fff9fff9ff,
+0xf3fff3fff3fff3ff,
+0xe7ffe7ffe7ffe7ff,
+0xcfffcfffcfffcfff,
+0x9fff9fff9fff9fff,
+0x7fff7fff7fff7fff,
+0xfffefffefffefffe,
+0xfffdfffdfffdfffd,
+0xfffbfffbfffbfffb,
+0xfff7fff7fff7fff7,
+0xffefffefffefffef,
+0xffdfffdfffdfffdf,
+0xffbfffbfffbfffbf,
+0xff7fff7fff7fff7f,
+0xfefffefffefffeff,
+0xfdfffdfffdfffdff,
+0xfbfffbfffbfffbff,
+0xf7fff7fff7fff7ff,
+0xefffefffefffefff,
+0xdfffdfffdfffdfff,
+0xbfffbfffbfffbfff,
+0x0000000100000001,
+0x0000000200000002,
+0x0000000400000004,
+0x0000000800000008,
+0x0000001000000010,
+0x0000002000000020,
+0x0000004000000040,
+0x0000008000000080,
+0x0000010000000100,
+0x0000020000000200,
+0x0000040000000400,
+0x0000080000000800,
+0x0000100000001000,
+0x0000200000002000,
+0x0000400000004000,
+0x0000800000008000,
+0x0001000000010000,
+0x0002000000020000,
+0x0004000000040000,
+0x0008000000080000,
+0x0010000000100000,
+0x0020000000200000,
+0x0040000000400000,
+0x0080000000800000,
+0x0100000001000000,
+0x0200000002000000,
+0x0400000004000000,
+0x0800000008000000,
+0x1000000010000000,
+0x2000000020000000,
+0x4000000040000000,
+0x8000000080000000,
+0x0000000300000003,
+0x0000000600000006,
+0x0000000c0000000c,
+0x0000001800000018,
+0x0000003000000030,
+0x0000006000000060,
+0x000000c0000000c0,
+0x0000018000000180,
+0x0000030000000300,
+0x0000060000000600,
+0x00000c0000000c00,
+0x0000180000001800,
+0x0000300000003000,
+0x0000600000006000,
+0x0000c0000000c000,
+0x0001800000018000,
+0x0003000000030000,
+0x0006000000060000,
+0x000c0000000c0000,
+0x0018000000180000,
+0x0030000000300000,
+0x0060000000600000,
+0x00c0000000c00000,
+0x0180000001800000,
+0x0300000003000000,
+0x0600000006000000,
+0x0c0000000c000000,
+0x1800000018000000,
+0x3000000030000000,
+0x6000000060000000,
+0xc0000000c0000000,
+0x8000000180000001,
+0x0000000700000007,
+0x0000000e0000000e,
+0x0000001c0000001c,
+0x0000003800000038,
+0x0000007000000070,
+0x000000e0000000e0,
+0x000001c0000001c0,
+0x0000038000000380,
+0x0000070000000700,
+0x00000e0000000e00,
+0x00001c0000001c00,
+0x0000380000003800,
+0x0000700000007000,
+0x0000e0000000e000,
+0x0001c0000001c000,
+0x0003800000038000,
+0x0007000000070000,
+0x000e0000000e0000,
+0x001c0000001c0000,
+0x0038000000380000,
+0x0070000000700000,
+0x00e0000000e00000,
+0x01c0000001c00000,
+0x0380000003800000,
+0x0700000007000000,
+0x0e0000000e000000,
+0x1c0000001c000000,
+0x3800000038000000,
+0x7000000070000000,
+0xe0000000e0000000,
+0xc0000001c0000001,
+0x8000000380000003,
+0x0000000f0000000f,
+0x0000001e0000001e,
+0x0000003c0000003c,
+0x0000007800000078,
+0x000000f0000000f0,
+0x000001e0000001e0,
+0x000003c0000003c0,
+0x0000078000000780,
+0x00000f0000000f00,
+0x00001e0000001e00,
+0x00003c0000003c00,
+0x0000780000007800,
+0x0000f0000000f000,
+0x0001e0000001e000,
+0x0003c0000003c000,
+0x0007800000078000,
+0x000f0000000f0000,
+0x001e0000001e0000,
+0x003c0000003c0000,
+0x0078000000780000,
+0x00f0000000f00000,
+0x01e0000001e00000,
+0x03c0000003c00000,
+0x0780000007800000,
+0x0f0000000f000000,
+0x1e0000001e000000,
+0x3c0000003c000000,
+0x7800000078000000,
+0xf0000000f0000000,
+0xe0000001e0000001,
+0xc0000003c0000003,
+0x8000000780000007,
+0x0000001f0000001f,
+0x0000003e0000003e,
+0x0000007c0000007c,
+0x000000f8000000f8,
+0x000001f0000001f0,
+0x000003e0000003e0,
+0x000007c0000007c0,
+0x00000f8000000f80,
+0x00001f0000001f00,
+0x00003e0000003e00,
+0x00007c0000007c00,
+0x0000f8000000f800,
+0x0001f0000001f000,
+0x0003e0000003e000,
+0x0007c0000007c000,
+0x000f8000000f8000,
+0x001f0000001f0000,
+0x003e0000003e0000,
+0x007c0000007c0000,
+0x00f8000000f80000,
+0x01f0000001f00000,
+0x03e0000003e00000,
+0x07c0000007c00000,
+0x0f8000000f800000,
+0x1f0000001f000000,
+0x3e0000003e000000,
+0x7c0000007c000000,
+0xf8000000f8000000,
+0xf0000001f0000001,
+0xe0000003e0000003,
+0xc0000007c0000007,
+0x8000000f8000000f,
+0x0000003f0000003f,
+0x0000007e0000007e,
+0x000000fc000000fc,
+0x000001f8000001f8,
+0x000003f0000003f0,
+0x000007e0000007e0,
+0x00000fc000000fc0,
+0x00001f8000001f80,
+0x00003f0000003f00,
+0x00007e0000007e00,
+0x0000fc000000fc00,
+0x0001f8000001f800,
+0x0003f0000003f000,
+0x0007e0000007e000,
+0x000fc000000fc000,
+0x001f8000001f8000,
+0x003f0000003f0000,
+0x007e0000007e0000,
+0x00fc000000fc0000,
+0x01f8000001f80000,
+0x03f0000003f00000,
+0x07e0000007e00000,
+0x0fc000000fc00000,
+0x1f8000001f800000,
+0x3f0000003f000000,
+0x7e0000007e000000,
+0xfc000000fc000000,
+0xf8000001f8000001,
+0xf0000003f0000003,
+0xe0000007e0000007,
+0xc000000fc000000f,
+0x8000001f8000001f,
+0x0000007f0000007f,
+0x000000fe000000fe,
+0x000001fc000001fc,
+0x000003f8000003f8,
+0x000007f0000007f0,
+0x00000fe000000fe0,
+0x00001fc000001fc0,
+0x00003f8000003f80,
+0x00007f0000007f00,
+0x0000fe000000fe00,
+0x0001fc000001fc00,
+0x0003f8000003f800,
+0x0007f0000007f000,
+0x000fe000000fe000,
+0x001fc000001fc000,
+0x003f8000003f8000,
+0x007f0000007f0000,
+0x00fe000000fe0000,
+0x01fc000001fc0000,
+0x03f8000003f80000,
+0x07f0000007f00000,
+0x0fe000000fe00000,
+0x1fc000001fc00000,
+0x3f8000003f800000,
+0x7f0000007f000000,
+0xfe000000fe000000,
+0xfc000001fc000001,
+0xf8000003f8000003,
+0xf0000007f0000007,
+0xe000000fe000000f,
+0xc000001fc000001f,
+0x8000003f8000003f,
+0x000000ff000000ff,
+0x000001fe000001fe,
+0x000003fc000003fc,
+0x000007f8000007f8,
+0x00000ff000000ff0,
+0x00001fe000001fe0,
+0x00003fc000003fc0,
+0x00007f8000007f80,
+0x0000ff000000ff00,
+0x0001fe000001fe00,
+0x0003fc000003fc00,
+0x0007f8000007f800,
+0x000ff000000ff000,
+0x001fe000001fe000,
+0x003fc000003fc000,
+0x007f8000007f8000,
+0x00ff000000ff0000,
+0x01fe000001fe0000,
+0x03fc000003fc0000,
+0x07f8000007f80000,
+0x0ff000000ff00000,
+0x1fe000001fe00000,
+0x3fc000003fc00000,
+0x7f8000007f800000,
+0xff000000ff000000,
+0xfe000001fe000001,
+0xfc000003fc000003,
+0xf8000007f8000007,
+0xf000000ff000000f,
+0xe000001fe000001f,
+0xc000003fc000003f,
+0x8000007f8000007f,
+0x000001ff000001ff,
+0x000003fe000003fe,
+0x000007fc000007fc,
+0x00000ff800000ff8,
+0x00001ff000001ff0,
+0x00003fe000003fe0,
+0x00007fc000007fc0,
+0x0000ff800000ff80,
+0x0001ff000001ff00,
+0x0003fe000003fe00,
+0x0007fc000007fc00,
+0x000ff800000ff800,
+0x001ff000001ff000,
+0x003fe000003fe000,
+0x007fc000007fc000,
+0x00ff800000ff8000,
+0x01ff000001ff0000,
+0x03fe000003fe0000,
+0x07fc000007fc0000,
+0x0ff800000ff80000,
+0x1ff000001ff00000,
+0x3fe000003fe00000,
+0x7fc000007fc00000,
+0xff800000ff800000,
+0xff000001ff000001,
+0xfe000003fe000003,
+0xfc000007fc000007,
+0xf800000ff800000f,
+0xf000001ff000001f,
+0xe000003fe000003f,
+0xc000007fc000007f,
+0x800000ff800000ff,
+0x000003ff000003ff,
+0x000007fe000007fe,
+0x00000ffc00000ffc,
+0x00001ff800001ff8,
+0x00003ff000003ff0,
+0x00007fe000007fe0,
+0x0000ffc00000ffc0,
+0x0001ff800001ff80,
+0x0003ff000003ff00,
+0x0007fe000007fe00,
+0x000ffc00000ffc00,
+0x001ff800001ff800,
+0x003ff000003ff000,
+0x007fe000007fe000,
+0x00ffc00000ffc000,
+0x01ff800001ff8000,
+0x03ff000003ff0000,
+0x07fe000007fe0000,
+0x0ffc00000ffc0000,
+0x1ff800001ff80000,
+0x3ff000003ff00000,
+0x7fe000007fe00000,
+0xffc00000ffc00000,
+0xff800001ff800001,
+0xff000003ff000003,
+0xfe000007fe000007,
+0xfc00000ffc00000f,
+0xf800001ff800001f,
+0xf000003ff000003f,
+0xe000007fe000007f,
+0xc00000ffc00000ff,
+0x800001ff800001ff,
+0x000007ff000007ff,
+0x00000ffe00000ffe,
+0x00001ffc00001ffc,
+0x00003ff800003ff8,
+0x00007ff000007ff0,
+0x0000ffe00000ffe0,
+0x0001ffc00001ffc0,
+0x0003ff800003ff80,
+0x0007ff000007ff00,
+0x000ffe00000ffe00,
+0x001ffc00001ffc00,
+0x003ff800003ff800,
+0x007ff000007ff000,
+0x00ffe00000ffe000,
+0x01ffc00001ffc000,
+0x03ff800003ff8000,
+0x07ff000007ff0000,
+0x0ffe00000ffe0000,
+0x1ffc00001ffc0000,
+0x3ff800003ff80000,
+0x7ff000007ff00000,
+0xffe00000ffe00000,
+0xffc00001ffc00001,
+0xff800003ff800003,
+0xff000007ff000007,
+0xfe00000ffe00000f,
+0xfc00001ffc00001f,
+0xf800003ff800003f,
+0xf000007ff000007f,
+0xe00000ffe00000ff,
+0xc00001ffc00001ff,
+0x800003ff800003ff,
+0x00000fff00000fff,
+0x00001ffe00001ffe,
+0x00003ffc00003ffc,
+0x00007ff800007ff8,
+0x0000fff00000fff0,
+0x0001ffe00001ffe0,
+0x0003ffc00003ffc0,
+0x0007ff800007ff80,
+0x000fff00000fff00,
+0x001ffe00001ffe00,
+0x003ffc00003ffc00,
+0x007ff800007ff800,
+0x00fff00000fff000,
+0x01ffe00001ffe000,
+0x03ffc00003ffc000,
+0x07ff800007ff8000,
+0x0fff00000fff0000,
+0x1ffe00001ffe0000,
+0x3ffc00003ffc0000,
+0x7ff800007ff80000,
+0xfff00000fff00000,
+0xffe00001ffe00001,
+0xffc00003ffc00003,
+0xff800007ff800007,
+0xff00000fff00000f,
+0xfe00001ffe00001f,
+0xfc00003ffc00003f,
+0xf800007ff800007f,
+0xf00000fff00000ff,
+0xe00001ffe00001ff,
+0xc00003ffc00003ff,
+0x800007ff800007ff,
+0x00001fff00001fff,
+0x00003ffe00003ffe,
+0x00007ffc00007ffc,
+0x0000fff80000fff8,
+0x0001fff00001fff0,
+0x0003ffe00003ffe0,
+0x0007ffc00007ffc0,
+0x000fff80000fff80,
+0x001fff00001fff00,
+0x003ffe00003ffe00,
+0x007ffc00007ffc00,
+0x00fff80000fff800,
+0x01fff00001fff000,
+0x03ffe00003ffe000,
+0x07ffc00007ffc000,
+0x0fff80000fff8000,
+0x1fff00001fff0000,
+0x3ffe00003ffe0000,
+0x7ffc00007ffc0000,
+0xfff80000fff80000,
+0xfff00001fff00001,
+0xffe00003ffe00003,
+0xffc00007ffc00007,
+0xff80000fff80000f,
+0xff00001fff00001f,
+0xfe00003ffe00003f,
+0xfc00007ffc00007f,
+0xf80000fff80000ff,
+0xf00001fff00001ff,
+0xe00003ffe00003ff,
+0xc00007ffc00007ff,
+0x80000fff80000fff,
+0x00003fff00003fff,
+0x00007ffe00007ffe,
+0x0000fffc0000fffc,
+0x0001fff80001fff8,
+0x0003fff00003fff0,
+0x0007ffe00007ffe0,
+0x000fffc0000fffc0,
+0x001fff80001fff80,
+0x003fff00003fff00,
+0x007ffe00007ffe00,
+0x00fffc0000fffc00,
+0x01fff80001fff800,
+0x03fff00003fff000,
+0x07ffe00007ffe000,
+0x0fffc0000fffc000,
+0x1fff80001fff8000,
+0x3fff00003fff0000,
+0x7ffe00007ffe0000,
+0xfffc0000fffc0000,
+0xfff80001fff80001,
+0xfff00003fff00003,
+0xffe00007ffe00007,
+0xffc0000fffc0000f,
+0xff80001fff80001f,
+0xff00003fff00003f,
+0xfe00007ffe00007f,
+0xfc0000fffc0000ff,
+0xf80001fff80001ff,
+0xf00003fff00003ff,
+0xe00007ffe00007ff,
+0xc0000fffc0000fff,
+0x80001fff80001fff,
+0x00007fff00007fff,
+0x0000fffe0000fffe,
+0x0001fffc0001fffc,
+0x0003fff80003fff8,
+0x0007fff00007fff0,
+0x000fffe0000fffe0,
+0x001fffc0001fffc0,
+0x003fff80003fff80,
+0x007fff00007fff00,
+0x00fffe0000fffe00,
+0x01fffc0001fffc00,
+0x03fff80003fff800,
+0x07fff00007fff000,
+0x0fffe0000fffe000,
+0x1fffc0001fffc000,
+0x3fff80003fff8000,
+0x7fff00007fff0000,
+0xfffe0000fffe0000,
+0xfffc0001fffc0001,
+0xfff80003fff80003,
+0xfff00007fff00007,
+0xffe0000fffe0000f,
+0xffc0001fffc0001f,
+0xff80003fff80003f,
+0xff00007fff00007f,
+0xfe0000fffe0000ff,
+0xfc0001fffc0001ff,
+0xf80003fff80003ff,
+0xf00007fff00007ff,
+0xe0000fffe0000fff,
+0xc0001fffc0001fff,
+0x80003fff80003fff,
+0x0000ffff0000ffff,
+0x0001fffe0001fffe,
+0x0003fffc0003fffc,
+0x0007fff80007fff8,
+0x000ffff0000ffff0,
+0x001fffe0001fffe0,
+0x003fffc0003fffc0,
+0x007fff80007fff80,
+0x00ffff0000ffff00,
+0x01fffe0001fffe00,
+0x03fffc0003fffc00,
+0x07fff80007fff800,
+0x0ffff0000ffff000,
+0x1fffe0001fffe000,
+0x3fffc0003fffc000,
+0x7fff80007fff8000,
+0xffff0000ffff0000,
+0xfffe0001fffe0001,
+0xfffc0003fffc0003,
+0xfff80007fff80007,
+0xfff0000ffff0000f,
+0xffe0001fffe0001f,
+0xffc0003fffc0003f,
+0xff80007fff80007f,
+0xff0000ffff0000ff,
+0xfe0001fffe0001ff,
+0xfc0003fffc0003ff,
+0xf80007fff80007ff,
+0xf0000ffff0000fff,
+0xe0001fffe0001fff,
+0xc0003fffc0003fff,
+0x80007fff80007fff,
+0x0001ffff0001ffff,
+0x0003fffe0003fffe,
+0x0007fffc0007fffc,
+0x000ffff8000ffff8,
+0x001ffff0001ffff0,
+0x003fffe0003fffe0,
+0x007fffc0007fffc0,
+0x00ffff8000ffff80,
+0x01ffff0001ffff00,
+0x03fffe0003fffe00,
+0x07fffc0007fffc00,
+0x0ffff8000ffff800,
+0x1ffff0001ffff000,
+0x3fffe0003fffe000,
+0x7fffc0007fffc000,
+0xffff8000ffff8000,
+0xffff0001ffff0001,
+0xfffe0003fffe0003,
+0xfffc0007fffc0007,
+0xfff8000ffff8000f,
+0xfff0001ffff0001f,
+0xffe0003fffe0003f,
+0xffc0007fffc0007f,
+0xff8000ffff8000ff,
+0xff0001ffff0001ff,
+0xfe0003fffe0003ff,
+0xfc0007fffc0007ff,
+0xf8000ffff8000fff,
+0xf0001ffff0001fff,
+0xe0003fffe0003fff,
+0xc0007fffc0007fff,
+0x8000ffff8000ffff,
+0x0003ffff0003ffff,
+0x0007fffe0007fffe,
+0x000ffffc000ffffc,
+0x001ffff8001ffff8,
+0x003ffff0003ffff0,
+0x007fffe0007fffe0,
+0x00ffffc000ffffc0,
+0x01ffff8001ffff80,
+0x03ffff0003ffff00,
+0x07fffe0007fffe00,
+0x0ffffc000ffffc00,
+0x1ffff8001ffff800,
+0x3ffff0003ffff000,
+0x7fffe0007fffe000,
+0xffffc000ffffc000,
+0xffff8001ffff8001,
+0xffff0003ffff0003,
+0xfffe0007fffe0007,
+0xfffc000ffffc000f,
+0xfff8001ffff8001f,
+0xfff0003ffff0003f,
+0xffe0007fffe0007f,
+0xffc000ffffc000ff,
+0xff8001ffff8001ff,
+0xff0003ffff0003ff,
+0xfe0007fffe0007ff,
+0xfc000ffffc000fff,
+0xf8001ffff8001fff,
+0xf0003ffff0003fff,
+0xe0007fffe0007fff,
+0xc000ffffc000ffff,
+0x8001ffff8001ffff,
+0x0007ffff0007ffff,
+0x000ffffe000ffffe,
+0x001ffffc001ffffc,
+0x003ffff8003ffff8,
+0x007ffff0007ffff0,
+0x00ffffe000ffffe0,
+0x01ffffc001ffffc0,
+0x03ffff8003ffff80,
+0x07ffff0007ffff00,
+0x0ffffe000ffffe00,
+0x1ffffc001ffffc00,
+0x3ffff8003ffff800,
+0x7ffff0007ffff000,
+0xffffe000ffffe000,
+0xffffc001ffffc001,
+0xffff8003ffff8003,
+0xffff0007ffff0007,
+0xfffe000ffffe000f,
+0xfffc001ffffc001f,
+0xfff8003ffff8003f,
+0xfff0007ffff0007f,
+0xffe000ffffe000ff,
+0xffc001ffffc001ff,
+0xff8003ffff8003ff,
+0xff0007ffff0007ff,
+0xfe000ffffe000fff,
+0xfc001ffffc001fff,
+0xf8003ffff8003fff,
+0xf0007ffff0007fff,
+0xe000ffffe000ffff,
+0xc001ffffc001ffff,
+0x8003ffff8003ffff,
+0x000fffff000fffff,
+0x001ffffe001ffffe,
+0x003ffffc003ffffc,
+0x007ffff8007ffff8,
+0x00fffff000fffff0,
+0x01ffffe001ffffe0,
+0x03ffffc003ffffc0,
+0x07ffff8007ffff80,
+0x0fffff000fffff00,
+0x1ffffe001ffffe00,
+0x3ffffc003ffffc00,
+0x7ffff8007ffff800,
+0xfffff000fffff000,
+0xffffe001ffffe001,
+0xffffc003ffffc003,
+0xffff8007ffff8007,
+0xffff000fffff000f,
+0xfffe001ffffe001f,
+0xfffc003ffffc003f,
+0xfff8007ffff8007f,
+0xfff000fffff000ff,
+0xffe001ffffe001ff,
+0xffc003ffffc003ff,
+0xff8007ffff8007ff,
+0xff000fffff000fff,
+0xfe001ffffe001fff,
+0xfc003ffffc003fff,
+0xf8007ffff8007fff,
+0xf000fffff000ffff,
+0xe001ffffe001ffff,
+0xc003ffffc003ffff,
+0x8007ffff8007ffff,
+0x001fffff001fffff,
+0x003ffffe003ffffe,
+0x007ffffc007ffffc,
+0x00fffff800fffff8,
+0x01fffff001fffff0,
+0x03ffffe003ffffe0,
+0x07ffffc007ffffc0,
+0x0fffff800fffff80,
+0x1fffff001fffff00,
+0x3ffffe003ffffe00,
+0x7ffffc007ffffc00,
+0xfffff800fffff800,
+0xfffff001fffff001,
+0xffffe003ffffe003,
+0xffffc007ffffc007,
+0xffff800fffff800f,
+0xffff001fffff001f,
+0xfffe003ffffe003f,
+0xfffc007ffffc007f,
+0xfff800fffff800ff,
+0xfff001fffff001ff,
+0xffe003ffffe003ff,
+0xffc007ffffc007ff,
+0xff800fffff800fff,
+0xff001fffff001fff,
+0xfe003ffffe003fff,
+0xfc007ffffc007fff,
+0xf800fffff800ffff,
+0xf001fffff001ffff,
+0xe003ffffe003ffff,
+0xc007ffffc007ffff,
+0x800fffff800fffff,
+0x003fffff003fffff,
+0x007ffffe007ffffe,
+0x00fffffc00fffffc,
+0x01fffff801fffff8,
+0x03fffff003fffff0,
+0x07ffffe007ffffe0,
+0x0fffffc00fffffc0,
+0x1fffff801fffff80,
+0x3fffff003fffff00,
+0x7ffffe007ffffe00,
+0xfffffc00fffffc00,
+0xfffff801fffff801,
+0xfffff003fffff003,
+0xffffe007ffffe007,
+0xffffc00fffffc00f,
+0xffff801fffff801f,
+0xffff003fffff003f,
+0xfffe007ffffe007f,
+0xfffc00fffffc00ff,
+0xfff801fffff801ff,
+0xfff003fffff003ff,
+0xffe007ffffe007ff,
+0xffc00fffffc00fff,
+0xff801fffff801fff,
+0xff003fffff003fff,
+0xfe007ffffe007fff,
+0xfc00fffffc00ffff,
+0xf801fffff801ffff,
+0xf003fffff003ffff,
+0xe007ffffe007ffff,
+0xc00fffffc00fffff,
+0x801fffff801fffff,
+0x007fffff007fffff,
+0x00fffffe00fffffe,
+0x01fffffc01fffffc,
+0x03fffff803fffff8,
+0x07fffff007fffff0,
+0x0fffffe00fffffe0,
+0x1fffffc01fffffc0,
+0x3fffff803fffff80,
+0x7fffff007fffff00,
+0xfffffe00fffffe00,
+0xfffffc01fffffc01,
+0xfffff803fffff803,
+0xfffff007fffff007,
+0xffffe00fffffe00f,
+0xffffc01fffffc01f,
+0xffff803fffff803f,
+0xffff007fffff007f,
+0xfffe00fffffe00ff,
+0xfffc01fffffc01ff,
+0xfff803fffff803ff,
+0xfff007fffff007ff,
+0xffe00fffffe00fff,
+0xffc01fffffc01fff,
+0xff803fffff803fff,
+0xff007fffff007fff,
+0xfe00fffffe00ffff,
+0xfc01fffffc01ffff,
+0xf803fffff803ffff,
+0xf007fffff007ffff,
+0xe00fffffe00fffff,
+0xc01fffffc01fffff,
+0x803fffff803fffff,
+0x00ffffff00ffffff,
+0x01fffffe01fffffe,
+0x03fffffc03fffffc,
+0x07fffff807fffff8,
+0x0ffffff00ffffff0,
+0x1fffffe01fffffe0,
+0x3fffffc03fffffc0,
+0x7fffff807fffff80,
+0xffffff00ffffff00,
+0xfffffe01fffffe01,
+0xfffffc03fffffc03,
+0xfffff807fffff807,
+0xfffff00ffffff00f,
+0xffffe01fffffe01f,
+0xffffc03fffffc03f,
+0xffff807fffff807f,
+0xffff00ffffff00ff,
+0xfffe01fffffe01ff,
+0xfffc03fffffc03ff,
+0xfff807fffff807ff,
+0xfff00ffffff00fff,
+0xffe01fffffe01fff,
+0xffc03fffffc03fff,
+0xff807fffff807fff,
+0xff00ffffff00ffff,
+0xfe01fffffe01ffff,
+0xfc03fffffc03ffff,
+0xf807fffff807ffff,
+0xf00ffffff00fffff,
+0xe01fffffe01fffff,
+0xc03fffffc03fffff,
+0x807fffff807fffff,
+0x01ffffff01ffffff,
+0x03fffffe03fffffe,
+0x07fffffc07fffffc,
+0x0ffffff80ffffff8,
+0x1ffffff01ffffff0,
+0x3fffffe03fffffe0,
+0x7fffffc07fffffc0,
+0xffffff80ffffff80,
+0xffffff01ffffff01,
+0xfffffe03fffffe03,
+0xfffffc07fffffc07,
+0xfffff80ffffff80f,
+0xfffff01ffffff01f,
+0xffffe03fffffe03f,
+0xffffc07fffffc07f,
+0xffff80ffffff80ff,
+0xffff01ffffff01ff,
+0xfffe03fffffe03ff,
+0xfffc07fffffc07ff,
+0xfff80ffffff80fff,
+0xfff01ffffff01fff,
+0xffe03fffffe03fff,
+0xffc07fffffc07fff,
+0xff80ffffff80ffff,
+0xff01ffffff01ffff,
+0xfe03fffffe03ffff,
+0xfc07fffffc07ffff,
+0xf80ffffff80fffff,
+0xf01ffffff01fffff,
+0xe03fffffe03fffff,
+0xc07fffffc07fffff,
+0x80ffffff80ffffff,
+0x03ffffff03ffffff,
+0x07fffffe07fffffe,
+0x0ffffffc0ffffffc,
+0x1ffffff81ffffff8,
+0x3ffffff03ffffff0,
+0x7fffffe07fffffe0,
+0xffffffc0ffffffc0,
+0xffffff81ffffff81,
+0xffffff03ffffff03,
+0xfffffe07fffffe07,
+0xfffffc0ffffffc0f,
+0xfffff81ffffff81f,
+0xfffff03ffffff03f,
+0xffffe07fffffe07f,
+0xffffc0ffffffc0ff,
+0xffff81ffffff81ff,
+0xffff03ffffff03ff,
+0xfffe07fffffe07ff,
+0xfffc0ffffffc0fff,
+0xfff81ffffff81fff,
+0xfff03ffffff03fff,
+0xffe07fffffe07fff,
+0xffc0ffffffc0ffff,
+0xff81ffffff81ffff,
+0xff03ffffff03ffff,
+0xfe07fffffe07ffff,
+0xfc0ffffffc0fffff,
+0xf81ffffff81fffff,
+0xf03ffffff03fffff,
+0xe07fffffe07fffff,
+0xc0ffffffc0ffffff,
+0x81ffffff81ffffff,
+0x07ffffff07ffffff,
+0x0ffffffe0ffffffe,
+0x1ffffffc1ffffffc,
+0x3ffffff83ffffff8,
+0x7ffffff07ffffff0,
+0xffffffe0ffffffe0,
+0xffffffc1ffffffc1,
+0xffffff83ffffff83,
+0xffffff07ffffff07,
+0xfffffe0ffffffe0f,
+0xfffffc1ffffffc1f,
+0xfffff83ffffff83f,
+0xfffff07ffffff07f,
+0xffffe0ffffffe0ff,
+0xffffc1ffffffc1ff,
+0xffff83ffffff83ff,
+0xffff07ffffff07ff,
+0xfffe0ffffffe0fff,
+0xfffc1ffffffc1fff,
+0xfff83ffffff83fff,
+0xfff07ffffff07fff,
+0xffe0ffffffe0ffff,
+0xffc1ffffffc1ffff,
+0xff83ffffff83ffff,
+0xff07ffffff07ffff,
+0xfe0ffffffe0fffff,
+0xfc1ffffffc1fffff,
+0xf83ffffff83fffff,
+0xf07ffffff07fffff,
+0xe0ffffffe0ffffff,
+0xc1ffffffc1ffffff,
+0x83ffffff83ffffff,
+0x0fffffff0fffffff,
+0x1ffffffe1ffffffe,
+0x3ffffffc3ffffffc,
+0x7ffffff87ffffff8,
+0xfffffff0fffffff0,
+0xffffffe1ffffffe1,
+0xffffffc3ffffffc3,
+0xffffff87ffffff87,
+0xffffff0fffffff0f,
+0xfffffe1ffffffe1f,
+0xfffffc3ffffffc3f,
+0xfffff87ffffff87f,
+0xfffff0fffffff0ff,
+0xffffe1ffffffe1ff,
+0xffffc3ffffffc3ff,
+0xffff87ffffff87ff,
+0xffff0fffffff0fff,
+0xfffe1ffffffe1fff,
+0xfffc3ffffffc3fff,
+0xfff87ffffff87fff,
+0xfff0fffffff0ffff,
+0xffe1ffffffe1ffff,
+0xffc3ffffffc3ffff,
+0xff87ffffff87ffff,
+0xff0fffffff0fffff,
+0xfe1ffffffe1fffff,
+0xfc3ffffffc3fffff,
+0xf87ffffff87fffff,
+0xf0fffffff0ffffff,
+0xe1ffffffe1ffffff,
+0xc3ffffffc3ffffff,
+0x87ffffff87ffffff,
+0x1fffffff1fffffff,
+0x3ffffffe3ffffffe,
+0x7ffffffc7ffffffc,
+0xfffffff8fffffff8,
+0xfffffff1fffffff1,
+0xffffffe3ffffffe3,
+0xffffffc7ffffffc7,
+0xffffff8fffffff8f,
+0xffffff1fffffff1f,
+0xfffffe3ffffffe3f,
+0xfffffc7ffffffc7f,
+0xfffff8fffffff8ff,
+0xfffff1fffffff1ff,
+0xffffe3ffffffe3ff,
+0xffffc7ffffffc7ff,
+0xffff8fffffff8fff,
+0xffff1fffffff1fff,
+0xfffe3ffffffe3fff,
+0xfffc7ffffffc7fff,
+0xfff8fffffff8ffff,
+0xfff1fffffff1ffff,
+0xffe3ffffffe3ffff,
+0xffc7ffffffc7ffff,
+0xff8fffffff8fffff,
+0xff1fffffff1fffff,
+0xfe3ffffffe3fffff,
+0xfc7ffffffc7fffff,
+0xf8fffffff8ffffff,
+0xf1fffffff1ffffff,
+0xe3ffffffe3ffffff,
+0xc7ffffffc7ffffff,
+0x8fffffff8fffffff,
+0x3fffffff3fffffff,
+0x7ffffffe7ffffffe,
+0xfffffffcfffffffc,
+0xfffffff9fffffff9,
+0xfffffff3fffffff3,
+0xffffffe7ffffffe7,
+0xffffffcfffffffcf,
+0xffffff9fffffff9f,
+0xffffff3fffffff3f,
+0xfffffe7ffffffe7f,
+0xfffffcfffffffcff,
+0xfffff9fffffff9ff,
+0xfffff3fffffff3ff,
+0xffffe7ffffffe7ff,
+0xffffcfffffffcfff,
+0xffff9fffffff9fff,
+0xffff3fffffff3fff,
+0xfffe7ffffffe7fff,
+0xfffcfffffffcffff,
+0xfff9fffffff9ffff,
+0xfff3fffffff3ffff,
+0xffe7ffffffe7ffff,
+0xffcfffffffcfffff,
+0xff9fffffff9fffff,
+0xff3fffffff3fffff,
+0xfe7ffffffe7fffff,
+0xfcfffffffcffffff,
+0xf9fffffff9ffffff,
+0xf3fffffff3ffffff,
+0xe7ffffffe7ffffff,
+0xcfffffffcfffffff,
+0x9fffffff9fffffff,
+0x7fffffff7fffffff,
+0xfffffffefffffffe,
+0xfffffffdfffffffd,
+0xfffffffbfffffffb,
+0xfffffff7fffffff7,
+0xffffffefffffffef,
+0xffffffdfffffffdf,
+0xffffffbfffffffbf,
+0xffffff7fffffff7f,
+0xfffffefffffffeff,
+0xfffffdfffffffdff,
+0xfffffbfffffffbff,
+0xfffff7fffffff7ff,
+0xffffefffffffefff,
+0xffffdfffffffdfff,
+0xffffbfffffffbfff,
+0xffff7fffffff7fff,
+0xfffefffffffeffff,
+0xfffdfffffffdffff,
+0xfffbfffffffbffff,
+0xfff7fffffff7ffff,
+0xffefffffffefffff,
+0xffdfffffffdfffff,
+0xffbfffffffbfffff,
+0xff7fffffff7fffff,
+0xfefffffffeffffff,
+0xfdfffffffdffffff,
+0xfbfffffffbffffff,
+0xf7fffffff7ffffff,
+0xefffffffefffffff,
+0xdfffffffdfffffff,
+0xbfffffffbfffffff,
+0x0000000000000001,
+0x0000000000000002,
+0x0000000000000004,
+0x0000000000000008,
+0x0000000000000010,
+0x0000000000000020,
+0x0000000000000040,
+0x0000000000000080,
+0x0000000000000100,
+0x0000000000000200,
+0x0000000000000400,
+0x0000000000000800,
+0x0000000000001000,
+0x0000000000002000,
+0x0000000000004000,
+0x0000000000008000,
+0x0000000000010000,
+0x0000000000020000,
+0x0000000000040000,
+0x0000000000080000,
+0x0000000000100000,
+0x0000000000200000,
+0x0000000000400000,
+0x0000000000800000,
+0x0000000001000000,
+0x0000000002000000,
+0x0000000004000000,
+0x0000000008000000,
+0x0000000010000000,
+0x0000000020000000,
+0x0000000040000000,
+0x0000000080000000,
+0x0000000100000000,
+0x0000000200000000,
+0x0000000400000000,
+0x0000000800000000,
+0x0000001000000000,
+0x0000002000000000,
+0x0000004000000000,
+0x0000008000000000,
+0x0000010000000000,
+0x0000020000000000,
+0x0000040000000000,
+0x0000080000000000,
+0x0000100000000000,
+0x0000200000000000,
+0x0000400000000000,
+0x0000800000000000,
+0x0001000000000000,
+0x0002000000000000,
+0x0004000000000000,
+0x0008000000000000,
+0x0010000000000000,
+0x0020000000000000,
+0x0040000000000000,
+0x0080000000000000,
+0x0100000000000000,
+0x0200000000000000,
+0x0400000000000000,
+0x0800000000000000,
+0x1000000000000000,
+0x2000000000000000,
+0x4000000000000000,
+0x8000000000000000,
+0x0000000000000003,
+0x0000000000000006,
+0x000000000000000c,
+0x0000000000000018,
+0x0000000000000030,
+0x0000000000000060,
+0x00000000000000c0,
+0x0000000000000180,
+0x0000000000000300,
+0x0000000000000600,
+0x0000000000000c00,
+0x0000000000001800,
+0x0000000000003000,
+0x0000000000006000,
+0x000000000000c000,
+0x0000000000018000,
+0x0000000000030000,
+0x0000000000060000,
+0x00000000000c0000,
+0x0000000000180000,
+0x0000000000300000,
+0x0000000000600000,
+0x0000000000c00000,
+0x0000000001800000,
+0x0000000003000000,
+0x0000000006000000,
+0x000000000c000000,
+0x0000000018000000,
+0x0000000030000000,
+0x0000000060000000,
+0x00000000c0000000,
+0x0000000180000000,
+0x0000000300000000,
+0x0000000600000000,
+0x0000000c00000000,
+0x0000001800000000,
+0x0000003000000000,
+0x0000006000000000,
+0x000000c000000000,
+0x0000018000000000,
+0x0000030000000000,
+0x0000060000000000,
+0x00000c0000000000,
+0x0000180000000000,
+0x0000300000000000,
+0x0000600000000000,
+0x0000c00000000000,
+0x0001800000000000,
+0x0003000000000000,
+0x0006000000000000,
+0x000c000000000000,
+0x0018000000000000,
+0x0030000000000000,
+0x0060000000000000,
+0x00c0000000000000,
+0x0180000000000000,
+0x0300000000000000,
+0x0600000000000000,
+0x0c00000000000000,
+0x1800000000000000,
+0x3000000000000000,
+0x6000000000000000,
+0xc000000000000000,
+0x8000000000000001,
+0x0000000000000007,
+0x000000000000000e,
+0x000000000000001c,
+0x0000000000000038,
+0x0000000000000070,
+0x00000000000000e0,
+0x00000000000001c0,
+0x0000000000000380,
+0x0000000000000700,
+0x0000000000000e00,
+0x0000000000001c00,
+0x0000000000003800,
+0x0000000000007000,
+0x000000000000e000,
+0x000000000001c000,
+0x0000000000038000,
+0x0000000000070000,
+0x00000000000e0000,
+0x00000000001c0000,
+0x0000000000380000,
+0x0000000000700000,
+0x0000000000e00000,
+0x0000000001c00000,
+0x0000000003800000,
+0x0000000007000000,
+0x000000000e000000,
+0x000000001c000000,
+0x0000000038000000,
+0x0000000070000000,
+0x00000000e0000000,
+0x00000001c0000000,
+0x0000000380000000,
+0x0000000700000000,
+0x0000000e00000000,
+0x0000001c00000000,
+0x0000003800000000,
+0x0000007000000000,
+0x000000e000000000,
+0x000001c000000000,
+0x0000038000000000,
+0x0000070000000000,
+0x00000e0000000000,
+0x00001c0000000000,
+0x0000380000000000,
+0x0000700000000000,
+0x0000e00000000000,
+0x0001c00000000000,
+0x0003800000000000,
+0x0007000000000000,
+0x000e000000000000,
+0x001c000000000000,
+0x0038000000000000,
+0x0070000000000000,
+0x00e0000000000000,
+0x01c0000000000000,
+0x0380000000000000,
+0x0700000000000000,
+0x0e00000000000000,
+0x1c00000000000000,
+0x3800000000000000,
+0x7000000000000000,
+0xe000000000000000,
+0xc000000000000001,
+0x8000000000000003,
+0x000000000000000f,
+0x000000000000001e,
+0x000000000000003c,
+0x0000000000000078,
+0x00000000000000f0,
+0x00000000000001e0,
+0x00000000000003c0,
+0x0000000000000780,
+0x0000000000000f00,
+0x0000000000001e00,
+0x0000000000003c00,
+0x0000000000007800,
+0x000000000000f000,
+0x000000000001e000,
+0x000000000003c000,
+0x0000000000078000,
+0x00000000000f0000,
+0x00000000001e0000,
+0x00000000003c0000,
+0x0000000000780000,
+0x0000000000f00000,
+0x0000000001e00000,
+0x0000000003c00000,
+0x0000000007800000,
+0x000000000f000000,
+0x000000001e000000,
+0x000000003c000000,
+0x0000000078000000,
+0x00000000f0000000,
+0x00000001e0000000,
+0x00000003c0000000,
+0x0000000780000000,
+0x0000000f00000000,
+0x0000001e00000000,
+0x0000003c00000000,
+0x0000007800000000,
+0x000000f000000000,
+0x000001e000000000,
+0x000003c000000000,
+0x0000078000000000,
+0x00000f0000000000,
+0x00001e0000000000,
+0x00003c0000000000,
+0x0000780000000000,
+0x0000f00000000000,
+0x0001e00000000000,
+0x0003c00000000000,
+0x0007800000000000,
+0x000f000000000000,
+0x001e000000000000,
+0x003c000000000000,
+0x0078000000000000,
+0x00f0000000000000,
+0x01e0000000000000,
+0x03c0000000000000,
+0x0780000000000000,
+0x0f00000000000000,
+0x1e00000000000000,
+0x3c00000000000000,
+0x7800000000000000,
+0xf000000000000000,
+0xe000000000000001,
+0xc000000000000003,
+0x8000000000000007,
+0x000000000000001f,
+0x000000000000003e,
+0x000000000000007c,
+0x00000000000000f8,
+0x00000000000001f0,
+0x00000000000003e0,
+0x00000000000007c0,
+0x0000000000000f80,
+0x0000000000001f00,
+0x0000000000003e00,
+0x0000000000007c00,
+0x000000000000f800,
+0x000000000001f000,
+0x000000000003e000,
+0x000000000007c000,
+0x00000000000f8000,
+0x00000000001f0000,
+0x00000000003e0000,
+0x00000000007c0000,
+0x0000000000f80000,
+0x0000000001f00000,
+0x0000000003e00000,
+0x0000000007c00000,
+0x000000000f800000,
+0x000000001f000000,
+0x000000003e000000,
+0x000000007c000000,
+0x00000000f8000000,
+0x00000001f0000000,
+0x00000003e0000000,
+0x00000007c0000000,
+0x0000000f80000000,
+0x0000001f00000000,
+0x0000003e00000000,
+0x0000007c00000000,
+0x000000f800000000,
+0x000001f000000000,
+0x000003e000000000,
+0x000007c000000000,
+0x00000f8000000000,
+0x00001f0000000000,
+0x00003e0000000000,
+0x00007c0000000000,
+0x0000f80000000000,
+0x0001f00000000000,
+0x0003e00000000000,
+0x0007c00000000000,
+0x000f800000000000,
+0x001f000000000000,
+0x003e000000000000,
+0x007c000000000000,
+0x00f8000000000000,
+0x01f0000000000000,
+0x03e0000000000000,
+0x07c0000000000000,
+0x0f80000000000000,
+0x1f00000000000000,
+0x3e00000000000000,
+0x7c00000000000000,
+0xf800000000000000,
+0xf000000000000001,
+0xe000000000000003,
+0xc000000000000007,
+0x800000000000000f,
+0x000000000000003f,
+0x000000000000007e,
+0x00000000000000fc,
+0x00000000000001f8,
+0x00000000000003f0,
+0x00000000000007e0,
+0x0000000000000fc0,
+0x0000000000001f80,
+0x0000000000003f00,
+0x0000000000007e00,
+0x000000000000fc00,
+0x000000000001f800,
+0x000000000003f000,
+0x000000000007e000,
+0x00000000000fc000,
+0x00000000001f8000,
+0x00000000003f0000,
+0x00000000007e0000,
+0x0000000000fc0000,
+0x0000000001f80000,
+0x0000000003f00000,
+0x0000000007e00000,
+0x000000000fc00000,
+0x000000001f800000,
+0x000000003f000000,
+0x000000007e000000,
+0x00000000fc000000,
+0x00000001f8000000,
+0x00000003f0000000,
+0x00000007e0000000,
+0x0000000fc0000000,
+0x0000001f80000000,
+0x0000003f00000000,
+0x0000007e00000000,
+0x000000fc00000000,
+0x000001f800000000,
+0x000003f000000000,
+0x000007e000000000,
+0x00000fc000000000,
+0x00001f8000000000,
+0x00003f0000000000,
+0x00007e0000000000,
+0x0000fc0000000000,
+0x0001f80000000000,
+0x0003f00000000000,
+0x0007e00000000000,
+0x000fc00000000000,
+0x001f800000000000,
+0x003f000000000000,
+0x007e000000000000,
+0x00fc000000000000,
+0x01f8000000000000,
+0x03f0000000000000,
+0x07e0000000000000,
+0x0fc0000000000000,
+0x1f80000000000000,
+0x3f00000000000000,
+0x7e00000000000000,
+0xfc00000000000000,
+0xf800000000000001,
+0xf000000000000003,
+0xe000000000000007,
+0xc00000000000000f,
+0x800000000000001f,
+0x000000000000007f,
+0x00000000000000fe,
+0x00000000000001fc,
+0x00000000000003f8,
+0x00000000000007f0,
+0x0000000000000fe0,
+0x0000000000001fc0,
+0x0000000000003f80,
+0x0000000000007f00,
+0x000000000000fe00,
+0x000000000001fc00,
+0x000000000003f800,
+0x000000000007f000,
+0x00000000000fe000,
+0x00000000001fc000,
+0x00000000003f8000,
+0x00000000007f0000,
+0x0000000000fe0000,
+0x0000000001fc0000,
+0x0000000003f80000,
+0x0000000007f00000,
+0x000000000fe00000,
+0x000000001fc00000,
+0x000000003f800000,
+0x000000007f000000,
+0x00000000fe000000,
+0x00000001fc000000,
+0x00000003f8000000,
+0x00000007f0000000,
+0x0000000fe0000000,
+0x0000001fc0000000,
+0x0000003f80000000,
+0x0000007f00000000,
+0x000000fe00000000,
+0x000001fc00000000,
+0x000003f800000000,
+0x000007f000000000,
+0x00000fe000000000,
+0x00001fc000000000,
+0x00003f8000000000,
+0x00007f0000000000,
+0x0000fe0000000000,
+0x0001fc0000000000,
+0x0003f80000000000,
+0x0007f00000000000,
+0x000fe00000000000,
+0x001fc00000000000,
+0x003f800000000000,
+0x007f000000000000,
+0x00fe000000000000,
+0x01fc000000000000,
+0x03f8000000000000,
+0x07f0000000000000,
+0x0fe0000000000000,
+0x1fc0000000000000,
+0x3f80000000000000,
+0x7f00000000000000,
+0xfe00000000000000,
+0xfc00000000000001,
+0xf800000000000003,
+0xf000000000000007,
+0xe00000000000000f,
+0xc00000000000001f,
+0x800000000000003f,
+0x00000000000000ff,
+0x00000000000001fe,
+0x00000000000003fc,
+0x00000000000007f8,
+0x0000000000000ff0,
+0x0000000000001fe0,
+0x0000000000003fc0,
+0x0000000000007f80,
+0x000000000000ff00,
+0x000000000001fe00,
+0x000000000003fc00,
+0x000000000007f800,
+0x00000000000ff000,
+0x00000000001fe000,
+0x00000000003fc000,
+0x00000000007f8000,
+0x0000000000ff0000,
+0x0000000001fe0000,
+0x0000000003fc0000,
+0x0000000007f80000,
+0x000000000ff00000,
+0x000000001fe00000,
+0x000000003fc00000,
+0x000000007f800000,
+0x00000000ff000000,
+0x00000001fe000000,
+0x00000003fc000000,
+0x00000007f8000000,
+0x0000000ff0000000,
+0x0000001fe0000000,
+0x0000003fc0000000,
+0x0000007f80000000,
+0x000000ff00000000,
+0x000001fe00000000,
+0x000003fc00000000,
+0x000007f800000000,
+0x00000ff000000000,
+0x00001fe000000000,
+0x00003fc000000000,
+0x00007f8000000000,
+0x0000ff0000000000,
+0x0001fe0000000000,
+0x0003fc0000000000,
+0x0007f80000000000,
+0x000ff00000000000,
+0x001fe00000000000,
+0x003fc00000000000,
+0x007f800000000000,
+0x00ff000000000000,
+0x01fe000000000000,
+0x03fc000000000000,
+0x07f8000000000000,
+0x0ff0000000000000,
+0x1fe0000000000000,
+0x3fc0000000000000,
+0x7f80000000000000,
+0xff00000000000000,
+0xfe00000000000001,
+0xfc00000000000003,
+0xf800000000000007,
+0xf00000000000000f,
+0xe00000000000001f,
+0xc00000000000003f,
+0x800000000000007f,
+0x00000000000001ff,
+0x00000000000003fe,
+0x00000000000007fc,
+0x0000000000000ff8,
+0x0000000000001ff0,
+0x0000000000003fe0,
+0x0000000000007fc0,
+0x000000000000ff80,
+0x000000000001ff00,
+0x000000000003fe00,
+0x000000000007fc00,
+0x00000000000ff800,
+0x00000000001ff000,
+0x00000000003fe000,
+0x00000000007fc000,
+0x0000000000ff8000,
+0x0000000001ff0000,
+0x0000000003fe0000,
+0x0000000007fc0000,
+0x000000000ff80000,
+0x000000001ff00000,
+0x000000003fe00000,
+0x000000007fc00000,
+0x00000000ff800000,
+0x00000001ff000000,
+0x00000003fe000000,
+0x00000007fc000000,
+0x0000000ff8000000,
+0x0000001ff0000000,
+0x0000003fe0000000,
+0x0000007fc0000000,
+0x000000ff80000000,
+0x000001ff00000000,
+0x000003fe00000000,
+0x000007fc00000000,
+0x00000ff800000000,
+0x00001ff000000000,
+0x00003fe000000000,
+0x00007fc000000000,
+0x0000ff8000000000,
+0x0001ff0000000000,
+0x0003fe0000000000,
+0x0007fc0000000000,
+0x000ff80000000000,
+0x001ff00000000000,
+0x003fe00000000000,
+0x007fc00000000000,
+0x00ff800000000000,
+0x01ff000000000000,
+0x03fe000000000000,
+0x07fc000000000000,
+0x0ff8000000000000,
+0x1ff0000000000000,
+0x3fe0000000000000,
+0x7fc0000000000000,
+0xff80000000000000,
+0xff00000000000001,
+0xfe00000000000003,
+0xfc00000000000007,
+0xf80000000000000f,
+0xf00000000000001f,
+0xe00000000000003f,
+0xc00000000000007f,
+0x80000000000000ff,
+0x00000000000003ff,
+0x00000000000007fe,
+0x0000000000000ffc,
+0x0000000000001ff8,
+0x0000000000003ff0,
+0x0000000000007fe0,
+0x000000000000ffc0,
+0x000000000001ff80,
+0x000000000003ff00,
+0x000000000007fe00,
+0x00000000000ffc00,
+0x00000000001ff800,
+0x00000000003ff000,
+0x00000000007fe000,
+0x0000000000ffc000,
+0x0000000001ff8000,
+0x0000000003ff0000,
+0x0000000007fe0000,
+0x000000000ffc0000,
+0x000000001ff80000,
+0x000000003ff00000,
+0x000000007fe00000,
+0x00000000ffc00000,
+0x00000001ff800000,
+0x00000003ff000000,
+0x00000007fe000000,
+0x0000000ffc000000,
+0x0000001ff8000000,
+0x0000003ff0000000,
+0x0000007fe0000000,
+0x000000ffc0000000,
+0x000001ff80000000,
+0x000003ff00000000,
+0x000007fe00000000,
+0x00000ffc00000000,
+0x00001ff800000000,
+0x00003ff000000000,
+0x00007fe000000000,
+0x0000ffc000000000,
+0x0001ff8000000000,
+0x0003ff0000000000,
+0x0007fe0000000000,
+0x000ffc0000000000,
+0x001ff80000000000,
+0x003ff00000000000,
+0x007fe00000000000,
+0x00ffc00000000000,
+0x01ff800000000000,
+0x03ff000000000000,
+0x07fe000000000000,
+0x0ffc000000000000,
+0x1ff8000000000000,
+0x3ff0000000000000,
+0x7fe0000000000000,
+0xffc0000000000000,
+0xff80000000000001,
+0xff00000000000003,
+0xfe00000000000007,
+0xfc0000000000000f,
+0xf80000000000001f,
+0xf00000000000003f,
+0xe00000000000007f,
+0xc0000000000000ff,
+0x80000000000001ff,
+0x00000000000007ff,
+0x0000000000000ffe,
+0x0000000000001ffc,
+0x0000000000003ff8,
+0x0000000000007ff0,
+0x000000000000ffe0,
+0x000000000001ffc0,
+0x000000000003ff80,
+0x000000000007ff00,
+0x00000000000ffe00,
+0x00000000001ffc00,
+0x00000000003ff800,
+0x00000000007ff000,
+0x0000000000ffe000,
+0x0000000001ffc000,
+0x0000000003ff8000,
+0x0000000007ff0000,
+0x000000000ffe0000,
+0x000000001ffc0000,
+0x000000003ff80000,
+0x000000007ff00000,
+0x00000000ffe00000,
+0x00000001ffc00000,
+0x00000003ff800000,
+0x00000007ff000000,
+0x0000000ffe000000,
+0x0000001ffc000000,
+0x0000003ff8000000,
+0x0000007ff0000000,
+0x000000ffe0000000,
+0x000001ffc0000000,
+0x000003ff80000000,
+0x000007ff00000000,
+0x00000ffe00000000,
+0x00001ffc00000000,
+0x00003ff800000000,
+0x00007ff000000000,
+0x0000ffe000000000,
+0x0001ffc000000000,
+0x0003ff8000000000,
+0x0007ff0000000000,
+0x000ffe0000000000,
+0x001ffc0000000000,
+0x003ff80000000000,
+0x007ff00000000000,
+0x00ffe00000000000,
+0x01ffc00000000000,
+0x03ff800000000000,
+0x07ff000000000000,
+0x0ffe000000000000,
+0x1ffc000000000000,
+0x3ff8000000000000,
+0x7ff0000000000000,
+0xffe0000000000000,
+0xffc0000000000001,
+0xff80000000000003,
+0xff00000000000007,
+0xfe0000000000000f,
+0xfc0000000000001f,
+0xf80000000000003f,
+0xf00000000000007f,
+0xe0000000000000ff,
+0xc0000000000001ff,
+0x80000000000003ff,
+0x0000000000000fff,
+0x0000000000001ffe,
+0x0000000000003ffc,
+0x0000000000007ff8,
+0x000000000000fff0,
+0x000000000001ffe0,
+0x000000000003ffc0,
+0x000000000007ff80,
+0x00000000000fff00,
+0x00000000001ffe00,
+0x00000000003ffc00,
+0x00000000007ff800,
+0x0000000000fff000,
+0x0000000001ffe000,
+0x0000000003ffc000,
+0x0000000007ff8000,
+0x000000000fff0000,
+0x000000001ffe0000,
+0x000000003ffc0000,
+0x000000007ff80000,
+0x00000000fff00000,
+0x00000001ffe00000,
+0x00000003ffc00000,
+0x00000007ff800000,
+0x0000000fff000000,
+0x0000001ffe000000,
+0x0000003ffc000000,
+0x0000007ff8000000,
+0x000000fff0000000,
+0x000001ffe0000000,
+0x000003ffc0000000,
+0x000007ff80000000,
+0x00000fff00000000,
+0x00001ffe00000000,
+0x00003ffc00000000,
+0x00007ff800000000,
+0x0000fff000000000,
+0x0001ffe000000000,
+0x0003ffc000000000,
+0x0007ff8000000000,
+0x000fff0000000000,
+0x001ffe0000000000,
+0x003ffc0000000000,
+0x007ff80000000000,
+0x00fff00000000000,
+0x01ffe00000000000,
+0x03ffc00000000000,
+0x07ff800000000000,
+0x0fff000000000000,
+0x1ffe000000000000,
+0x3ffc000000000000,
+0x7ff8000000000000,
+0xfff0000000000000,
+0xffe0000000000001,
+0xffc0000000000003,
+0xff80000000000007,
+0xff0000000000000f,
+0xfe0000000000001f,
+0xfc0000000000003f,
+0xf80000000000007f,
+0xf0000000000000ff,
+0xe0000000000001ff,
+0xc0000000000003ff,
+0x80000000000007ff,
+0x0000000000001fff,
+0x0000000000003ffe,
+0x0000000000007ffc,
+0x000000000000fff8,
+0x000000000001fff0,
+0x000000000003ffe0,
+0x000000000007ffc0,
+0x00000000000fff80,
+0x00000000001fff00,
+0x00000000003ffe00,
+0x00000000007ffc00,
+0x0000000000fff800,
+0x0000000001fff000,
+0x0000000003ffe000,
+0x0000000007ffc000,
+0x000000000fff8000,
+0x000000001fff0000,
+0x000000003ffe0000,
+0x000000007ffc0000,
+0x00000000fff80000,
+0x00000001fff00000,
+0x00000003ffe00000,
+0x00000007ffc00000,
+0x0000000fff800000,
+0x0000001fff000000,
+0x0000003ffe000000,
+0x0000007ffc000000,
+0x000000fff8000000,
+0x000001fff0000000,
+0x000003ffe0000000,
+0x000007ffc0000000,
+0x00000fff80000000,
+0x00001fff00000000,
+0x00003ffe00000000,
+0x00007ffc00000000,
+0x0000fff800000000,
+0x0001fff000000000,
+0x0003ffe000000000,
+0x0007ffc000000000,
+0x000fff8000000000,
+0x001fff0000000000,
+0x003ffe0000000000,
+0x007ffc0000000000,
+0x00fff80000000000,
+0x01fff00000000000,
+0x03ffe00000000000,
+0x07ffc00000000000,
+0x0fff800000000000,
+0x1fff000000000000,
+0x3ffe000000000000,
+0x7ffc000000000000,
+0xfff8000000000000,
+0xfff0000000000001,
+0xffe0000000000003,
+0xffc0000000000007,
+0xff8000000000000f,
+0xff0000000000001f,
+0xfe0000000000003f,
+0xfc0000000000007f,
+0xf8000000000000ff,
+0xf0000000000001ff,
+0xe0000000000003ff,
+0xc0000000000007ff,
+0x8000000000000fff,
+0x0000000000003fff,
+0x0000000000007ffe,
+0x000000000000fffc,
+0x000000000001fff8,
+0x000000000003fff0,
+0x000000000007ffe0,
+0x00000000000fffc0,
+0x00000000001fff80,
+0x00000000003fff00,
+0x00000000007ffe00,
+0x0000000000fffc00,
+0x0000000001fff800,
+0x0000000003fff000,
+0x0000000007ffe000,
+0x000000000fffc000,
+0x000000001fff8000,
+0x000000003fff0000,
+0x000000007ffe0000,
+0x00000000fffc0000,
+0x00000001fff80000,
+0x00000003fff00000,
+0x00000007ffe00000,
+0x0000000fffc00000,
+0x0000001fff800000,
+0x0000003fff000000,
+0x0000007ffe000000,
+0x000000fffc000000,
+0x000001fff8000000,
+0x000003fff0000000,
+0x000007ffe0000000,
+0x00000fffc0000000,
+0x00001fff80000000,
+0x00003fff00000000,
+0x00007ffe00000000,
+0x0000fffc00000000,
+0x0001fff800000000,
+0x0003fff000000000,
+0x0007ffe000000000,
+0x000fffc000000000,
+0x001fff8000000000,
+0x003fff0000000000,
+0x007ffe0000000000,
+0x00fffc0000000000,
+0x01fff80000000000,
+0x03fff00000000000,
+0x07ffe00000000000,
+0x0fffc00000000000,
+0x1fff800000000000,
+0x3fff000000000000,
+0x7ffe000000000000,
+0xfffc000000000000,
+0xfff8000000000001,
+0xfff0000000000003,
+0xffe0000000000007,
+0xffc000000000000f,
+0xff8000000000001f,
+0xff0000000000003f,
+0xfe0000000000007f,
+0xfc000000000000ff,
+0xf8000000000001ff,
+0xf0000000000003ff,
+0xe0000000000007ff,
+0xc000000000000fff,
+0x8000000000001fff,
+0x0000000000007fff,
+0x000000000000fffe,
+0x000000000001fffc,
+0x000000000003fff8,
+0x000000000007fff0,
+0x00000000000fffe0,
+0x00000000001fffc0,
+0x00000000003fff80,
+0x00000000007fff00,
+0x0000000000fffe00,
+0x0000000001fffc00,
+0x0000000003fff800,
+0x0000000007fff000,
+0x000000000fffe000,
+0x000000001fffc000,
+0x000000003fff8000,
+0x000000007fff0000,
+0x00000000fffe0000,
+0x00000001fffc0000,
+0x00000003fff80000,
+0x00000007fff00000,
+0x0000000fffe00000,
+0x0000001fffc00000,
+0x0000003fff800000,
+0x0000007fff000000,
+0x000000fffe000000,
+0x000001fffc000000,
+0x000003fff8000000,
+0x000007fff0000000,
+0x00000fffe0000000,
+0x00001fffc0000000,
+0x00003fff80000000,
+0x00007fff00000000,
+0x0000fffe00000000,
+0x0001fffc00000000,
+0x0003fff800000000,
+0x0007fff000000000,
+0x000fffe000000000,
+0x001fffc000000000,
+0x003fff8000000000,
+0x007fff0000000000,
+0x00fffe0000000000,
+0x01fffc0000000000,
+0x03fff80000000000,
+0x07fff00000000000,
+0x0fffe00000000000,
+0x1fffc00000000000,
+0x3fff800000000000,
+0x7fff000000000000,
+0xfffe000000000000,
+0xfffc000000000001,
+0xfff8000000000003,
+0xfff0000000000007,
+0xffe000000000000f,
+0xffc000000000001f,
+0xff8000000000003f,
+0xff0000000000007f,
+0xfe000000000000ff,
+0xfc000000000001ff,
+0xf8000000000003ff,
+0xf0000000000007ff,
+0xe000000000000fff,
+0xc000000000001fff,
+0x8000000000003fff,
+0x000000000000ffff,
+0x000000000001fffe,
+0x000000000003fffc,
+0x000000000007fff8,
+0x00000000000ffff0,
+0x00000000001fffe0,
+0x00000000003fffc0,
+0x00000000007fff80,
+0x0000000000ffff00,
+0x0000000001fffe00,
+0x0000000003fffc00,
+0x0000000007fff800,
+0x000000000ffff000,
+0x000000001fffe000,
+0x000000003fffc000,
+0x000000007fff8000,
+0x00000000ffff0000,
+0x00000001fffe0000,
+0x00000003fffc0000,
+0x00000007fff80000,
+0x0000000ffff00000,
+0x0000001fffe00000,
+0x0000003fffc00000,
+0x0000007fff800000,
+0x000000ffff000000,
+0x000001fffe000000,
+0x000003fffc000000,
+0x000007fff8000000,
+0x00000ffff0000000,
+0x00001fffe0000000,
+0x00003fffc0000000,
+0x00007fff80000000,
+0x0000ffff00000000,
+0x0001fffe00000000,
+0x0003fffc00000000,
+0x0007fff800000000,
+0x000ffff000000000,
+0x001fffe000000000,
+0x003fffc000000000,
+0x007fff8000000000,
+0x00ffff0000000000,
+0x01fffe0000000000,
+0x03fffc0000000000,
+0x07fff80000000000,
+0x0ffff00000000000,
+0x1fffe00000000000,
+0x3fffc00000000000,
+0x7fff800000000000,
+0xffff000000000000,
+0xfffe000000000001,
+0xfffc000000000003,
+0xfff8000000000007,
+0xfff000000000000f,
+0xffe000000000001f,
+0xffc000000000003f,
+0xff8000000000007f,
+0xff000000000000ff,
+0xfe000000000001ff,
+0xfc000000000003ff,
+0xf8000000000007ff,
+0xf000000000000fff,
+0xe000000000001fff,
+0xc000000000003fff,
+0x8000000000007fff,
+0x000000000001ffff,
+0x000000000003fffe,
+0x000000000007fffc,
+0x00000000000ffff8,
+0x00000000001ffff0,
+0x00000000003fffe0,
+0x00000000007fffc0,
+0x0000000000ffff80,
+0x0000000001ffff00,
+0x0000000003fffe00,
+0x0000000007fffc00,
+0x000000000ffff800,
+0x000000001ffff000,
+0x000000003fffe000,
+0x000000007fffc000,
+0x00000000ffff8000,
+0x00000001ffff0000,
+0x00000003fffe0000,
+0x00000007fffc0000,
+0x0000000ffff80000,
+0x0000001ffff00000,
+0x0000003fffe00000,
+0x0000007fffc00000,
+0x000000ffff800000,
+0x000001ffff000000,
+0x000003fffe000000,
+0x000007fffc000000,
+0x00000ffff8000000,
+0x00001ffff0000000,
+0x00003fffe0000000,
+0x00007fffc0000000,
+0x0000ffff80000000,
+0x0001ffff00000000,
+0x0003fffe00000000,
+0x0007fffc00000000,
+0x000ffff800000000,
+0x001ffff000000000,
+0x003fffe000000000,
+0x007fffc000000000,
+0x00ffff8000000000,
+0x01ffff0000000000,
+0x03fffe0000000000,
+0x07fffc0000000000,
+0x0ffff80000000000,
+0x1ffff00000000000,
+0x3fffe00000000000,
+0x7fffc00000000000,
+0xffff800000000000,
+0xffff000000000001,
+0xfffe000000000003,
+0xfffc000000000007,
+0xfff800000000000f,
+0xfff000000000001f,
+0xffe000000000003f,
+0xffc000000000007f,
+0xff800000000000ff,
+0xff000000000001ff,
+0xfe000000000003ff,
+0xfc000000000007ff,
+0xf800000000000fff,
+0xf000000000001fff,
+0xe000000000003fff,
+0xc000000000007fff,
+0x800000000000ffff,
+0x000000000003ffff,
+0x000000000007fffe,
+0x00000000000ffffc,
+0x00000000001ffff8,
+0x00000000003ffff0,
+0x00000000007fffe0,
+0x0000000000ffffc0,
+0x0000000001ffff80,
+0x0000000003ffff00,
+0x0000000007fffe00,
+0x000000000ffffc00,
+0x000000001ffff800,
+0x000000003ffff000,
+0x000000007fffe000,
+0x00000000ffffc000,
+0x00000001ffff8000,
+0x00000003ffff0000,
+0x00000007fffe0000,
+0x0000000ffffc0000,
+0x0000001ffff80000,
+0x0000003ffff00000,
+0x0000007fffe00000,
+0x000000ffffc00000,
+0x000001ffff800000,
+0x000003ffff000000,
+0x000007fffe000000,
+0x00000ffffc000000,
+0x00001ffff8000000,
+0x00003ffff0000000,
+0x00007fffe0000000,
+0x0000ffffc0000000,
+0x0001ffff80000000,
+0x0003ffff00000000,
+0x0007fffe00000000,
+0x000ffffc00000000,
+0x001ffff800000000,
+0x003ffff000000000,
+0x007fffe000000000,
+0x00ffffc000000000,
+0x01ffff8000000000,
+0x03ffff0000000000,
+0x07fffe0000000000,
+0x0ffffc0000000000,
+0x1ffff80000000000,
+0x3ffff00000000000,
+0x7fffe00000000000,
+0xffffc00000000000,
+0xffff800000000001,
+0xffff000000000003,
+0xfffe000000000007,
+0xfffc00000000000f,
+0xfff800000000001f,
+0xfff000000000003f,
+0xffe000000000007f,
+0xffc00000000000ff,
+0xff800000000001ff,
+0xff000000000003ff,
+0xfe000000000007ff,
+0xfc00000000000fff,
+0xf800000000001fff,
+0xf000000000003fff,
+0xe000000000007fff,
+0xc00000000000ffff,
+0x800000000001ffff,
+0x000000000007ffff,
+0x00000000000ffffe,
+0x00000000001ffffc,
+0x00000000003ffff8,
+0x00000000007ffff0,
+0x0000000000ffffe0,
+0x0000000001ffffc0,
+0x0000000003ffff80,
+0x0000000007ffff00,
+0x000000000ffffe00,
+0x000000001ffffc00,
+0x000000003ffff800,
+0x000000007ffff000,
+0x00000000ffffe000,
+0x00000001ffffc000,
+0x00000003ffff8000,
+0x00000007ffff0000,
+0x0000000ffffe0000,
+0x0000001ffffc0000,
+0x0000003ffff80000,
+0x0000007ffff00000,
+0x000000ffffe00000,
+0x000001ffffc00000,
+0x000003ffff800000,
+0x000007ffff000000,
+0x00000ffffe000000,
+0x00001ffffc000000,
+0x00003ffff8000000,
+0x00007ffff0000000,
+0x0000ffffe0000000,
+0x0001ffffc0000000,
+0x0003ffff80000000,
+0x0007ffff00000000,
+0x000ffffe00000000,
+0x001ffffc00000000,
+0x003ffff800000000,
+0x007ffff000000000,
+0x00ffffe000000000,
+0x01ffffc000000000,
+0x03ffff8000000000,
+0x07ffff0000000000,
+0x0ffffe0000000000,
+0x1ffffc0000000000,
+0x3ffff80000000000,
+0x7ffff00000000000,
+0xffffe00000000000,
+0xffffc00000000001,
+0xffff800000000003,
+0xffff000000000007,
+0xfffe00000000000f,
+0xfffc00000000001f,
+0xfff800000000003f,
+0xfff000000000007f,
+0xffe00000000000ff,
+0xffc00000000001ff,
+0xff800000000003ff,
+0xff000000000007ff,
+0xfe00000000000fff,
+0xfc00000000001fff,
+0xf800000000003fff,
+0xf000000000007fff,
+0xe00000000000ffff,
+0xc00000000001ffff,
+0x800000000003ffff,
+0x00000000000fffff,
+0x00000000001ffffe,
+0x00000000003ffffc,
+0x00000000007ffff8,
+0x0000000000fffff0,
+0x0000000001ffffe0,
+0x0000000003ffffc0,
+0x0000000007ffff80,
+0x000000000fffff00,
+0x000000001ffffe00,
+0x000000003ffffc00,
+0x000000007ffff800,
+0x00000000fffff000,
+0x00000001ffffe000,
+0x00000003ffffc000,
+0x00000007ffff8000,
+0x0000000fffff0000,
+0x0000001ffffe0000,
+0x0000003ffffc0000,
+0x0000007ffff80000,
+0x000000fffff00000,
+0x000001ffffe00000,
+0x000003ffffc00000,
+0x000007ffff800000,
+0x00000fffff000000,
+0x00001ffffe000000,
+0x00003ffffc000000,
+0x00007ffff8000000,
+0x0000fffff0000000,
+0x0001ffffe0000000,
+0x0003ffffc0000000,
+0x0007ffff80000000,
+0x000fffff00000000,
+0x001ffffe00000000,
+0x003ffffc00000000,
+0x007ffff800000000,
+0x00fffff000000000,
+0x01ffffe000000000,
+0x03ffffc000000000,
+0x07ffff8000000000,
+0x0fffff0000000000,
+0x1ffffe0000000000,
+0x3ffffc0000000000,
+0x7ffff80000000000,
+0xfffff00000000000,
+0xffffe00000000001,
+0xffffc00000000003,
+0xffff800000000007,
+0xffff00000000000f,
+0xfffe00000000001f,
+0xfffc00000000003f,
+0xfff800000000007f,
+0xfff00000000000ff,
+0xffe00000000001ff,
+0xffc00000000003ff,
+0xff800000000007ff,
+0xff00000000000fff,
+0xfe00000000001fff,
+0xfc00000000003fff,
+0xf800000000007fff,
+0xf00000000000ffff,
+0xe00000000001ffff,
+0xc00000000003ffff,
+0x800000000007ffff,
+0x00000000001fffff,
+0x00000000003ffffe,
+0x00000000007ffffc,
+0x0000000000fffff8,
+0x0000000001fffff0,
+0x0000000003ffffe0,
+0x0000000007ffffc0,
+0x000000000fffff80,
+0x000000001fffff00,
+0x000000003ffffe00,
+0x000000007ffffc00,
+0x00000000fffff800,
+0x00000001fffff000,
+0x00000003ffffe000,
+0x00000007ffffc000,
+0x0000000fffff8000,
+0x0000001fffff0000,
+0x0000003ffffe0000,
+0x0000007ffffc0000,
+0x000000fffff80000,
+0x000001fffff00000,
+0x000003ffffe00000,
+0x000007ffffc00000,
+0x00000fffff800000,
+0x00001fffff000000,
+0x00003ffffe000000,
+0x00007ffffc000000,
+0x0000fffff8000000,
+0x0001fffff0000000,
+0x0003ffffe0000000,
+0x0007ffffc0000000,
+0x000fffff80000000,
+0x001fffff00000000,
+0x003ffffe00000000,
+0x007ffffc00000000,
+0x00fffff800000000,
+0x01fffff000000000,
+0x03ffffe000000000,
+0x07ffffc000000000,
+0x0fffff8000000000,
+0x1fffff0000000000,
+0x3ffffe0000000000,
+0x7ffffc0000000000,
+0xfffff80000000000,
+0xfffff00000000001,
+0xffffe00000000003,
+0xffffc00000000007,
+0xffff80000000000f,
+0xffff00000000001f,
+0xfffe00000000003f,
+0xfffc00000000007f,
+0xfff80000000000ff,
+0xfff00000000001ff,
+0xffe00000000003ff,
+0xffc00000000007ff,
+0xff80000000000fff,
+0xff00000000001fff,
+0xfe00000000003fff,
+0xfc00000000007fff,
+0xf80000000000ffff,
+0xf00000000001ffff,
+0xe00000000003ffff,
+0xc00000000007ffff,
+0x80000000000fffff,
+0x00000000003fffff,
+0x00000000007ffffe,
+0x0000000000fffffc,
+0x0000000001fffff8,
+0x0000000003fffff0,
+0x0000000007ffffe0,
+0x000000000fffffc0,
+0x000000001fffff80,
+0x000000003fffff00,
+0x000000007ffffe00,
+0x00000000fffffc00,
+0x00000001fffff800,
+0x00000003fffff000,
+0x00000007ffffe000,
+0x0000000fffffc000,
+0x0000001fffff8000,
+0x0000003fffff0000,
+0x0000007ffffe0000,
+0x000000fffffc0000,
+0x000001fffff80000,
+0x000003fffff00000,
+0x000007ffffe00000,
+0x00000fffffc00000,
+0x00001fffff800000,
+0x00003fffff000000,
+0x00007ffffe000000,
+0x0000fffffc000000,
+0x0001fffff8000000,
+0x0003fffff0000000,
+0x0007ffffe0000000,
+0x000fffffc0000000,
+0x001fffff80000000,
+0x003fffff00000000,
+0x007ffffe00000000,
+0x00fffffc00000000,
+0x01fffff800000000,
+0x03fffff000000000,
+0x07ffffe000000000,
+0x0fffffc000000000,
+0x1fffff8000000000,
+0x3fffff0000000000,
+0x7ffffe0000000000,
+0xfffffc0000000000,
+0xfffff80000000001,
+0xfffff00000000003,
+0xffffe00000000007,
+0xffffc0000000000f,
+0xffff80000000001f,
+0xffff00000000003f,
+0xfffe00000000007f,
+0xfffc0000000000ff,
+0xfff80000000001ff,
+0xfff00000000003ff,
+0xffe00000000007ff,
+0xffc0000000000fff,
+0xff80000000001fff,
+0xff00000000003fff,
+0xfe00000000007fff,
+0xfc0000000000ffff,
+0xf80000000001ffff,
+0xf00000000003ffff,
+0xe00000000007ffff,
+0xc0000000000fffff,
+0x80000000001fffff,
+0x00000000007fffff,
+0x0000000000fffffe,
+0x0000000001fffffc,
+0x0000000003fffff8,
+0x0000000007fffff0,
+0x000000000fffffe0,
+0x000000001fffffc0,
+0x000000003fffff80,
+0x000000007fffff00,
+0x00000000fffffe00,
+0x00000001fffffc00,
+0x00000003fffff800,
+0x00000007fffff000,
+0x0000000fffffe000,
+0x0000001fffffc000,
+0x0000003fffff8000,
+0x0000007fffff0000,
+0x000000fffffe0000,
+0x000001fffffc0000,
+0x000003fffff80000,
+0x000007fffff00000,
+0x00000fffffe00000,
+0x00001fffffc00000,
+0x00003fffff800000,
+0x00007fffff000000,
+0x0000fffffe000000,
+0x0001fffffc000000,
+0x0003fffff8000000,
+0x0007fffff0000000,
+0x000fffffe0000000,
+0x001fffffc0000000,
+0x003fffff80000000,
+0x007fffff00000000,
+0x00fffffe00000000,
+0x01fffffc00000000,
+0x03fffff800000000,
+0x07fffff000000000,
+0x0fffffe000000000,
+0x1fffffc000000000,
+0x3fffff8000000000,
+0x7fffff0000000000,
+0xfffffe0000000000,
+0xfffffc0000000001,
+0xfffff80000000003,
+0xfffff00000000007,
+0xffffe0000000000f,
+0xffffc0000000001f,
+0xffff80000000003f,
+0xffff00000000007f,
+0xfffe0000000000ff,
+0xfffc0000000001ff,
+0xfff80000000003ff,
+0xfff00000000007ff,
+0xffe0000000000fff,
+0xffc0000000001fff,
+0xff80000000003fff,
+0xff00000000007fff,
+0xfe0000000000ffff,
+0xfc0000000001ffff,
+0xf80000000003ffff,
+0xf00000000007ffff,
+0xe0000000000fffff,
+0xc0000000001fffff,
+0x80000000003fffff,
+0x0000000000ffffff,
+0x0000000001fffffe,
+0x0000000003fffffc,
+0x0000000007fffff8,
+0x000000000ffffff0,
+0x000000001fffffe0,
+0x000000003fffffc0,
+0x000000007fffff80,
+0x00000000ffffff00,
+0x00000001fffffe00,
+0x00000003fffffc00,
+0x00000007fffff800,
+0x0000000ffffff000,
+0x0000001fffffe000,
+0x0000003fffffc000,
+0x0000007fffff8000,
+0x000000ffffff0000,
+0x000001fffffe0000,
+0x000003fffffc0000,
+0x000007fffff80000,
+0x00000ffffff00000,
+0x00001fffffe00000,
+0x00003fffffc00000,
+0x00007fffff800000,
+0x0000ffffff000000,
+0x0001fffffe000000,
+0x0003fffffc000000,
+0x0007fffff8000000,
+0x000ffffff0000000,
+0x001fffffe0000000,
+0x003fffffc0000000,
+0x007fffff80000000,
+0x00ffffff00000000,
+0x01fffffe00000000,
+0x03fffffc00000000,
+0x07fffff800000000,
+0x0ffffff000000000,
+0x1fffffe000000000,
+0x3fffffc000000000,
+0x7fffff8000000000,
+0xffffff0000000000,
+0xfffffe0000000001,
+0xfffffc0000000003,
+0xfffff80000000007,
+0xfffff0000000000f,
+0xffffe0000000001f,
+0xffffc0000000003f,
+0xffff80000000007f,
+0xffff0000000000ff,
+0xfffe0000000001ff,
+0xfffc0000000003ff,
+0xfff80000000007ff,
+0xfff0000000000fff,
+0xffe0000000001fff,
+0xffc0000000003fff,
+0xff80000000007fff,
+0xff0000000000ffff,
+0xfe0000000001ffff,
+0xfc0000000003ffff,
+0xf80000000007ffff,
+0xf0000000000fffff,
+0xe0000000001fffff,
+0xc0000000003fffff,
+0x80000000007fffff,
+0x0000000001ffffff,
+0x0000000003fffffe,
+0x0000000007fffffc,
+0x000000000ffffff8,
+0x000000001ffffff0,
+0x000000003fffffe0,
+0x000000007fffffc0,
+0x00000000ffffff80,
+0x00000001ffffff00,
+0x00000003fffffe00,
+0x00000007fffffc00,
+0x0000000ffffff800,
+0x0000001ffffff000,
+0x0000003fffffe000,
+0x0000007fffffc000,
+0x000000ffffff8000,
+0x000001ffffff0000,
+0x000003fffffe0000,
+0x000007fffffc0000,
+0x00000ffffff80000,
+0x00001ffffff00000,
+0x00003fffffe00000,
+0x00007fffffc00000,
+0x0000ffffff800000,
+0x0001ffffff000000,
+0x0003fffffe000000,
+0x0007fffffc000000,
+0x000ffffff8000000,
+0x001ffffff0000000,
+0x003fffffe0000000,
+0x007fffffc0000000,
+0x00ffffff80000000,
+0x01ffffff00000000,
+0x03fffffe00000000,
+0x07fffffc00000000,
+0x0ffffff800000000,
+0x1ffffff000000000,
+0x3fffffe000000000,
+0x7fffffc000000000,
+0xffffff8000000000,
+0xffffff0000000001,
+0xfffffe0000000003,
+0xfffffc0000000007,
+0xfffff8000000000f,
+0xfffff0000000001f,
+0xffffe0000000003f,
+0xffffc0000000007f,
+0xffff8000000000ff,
+0xffff0000000001ff,
+0xfffe0000000003ff,
+0xfffc0000000007ff,
+0xfff8000000000fff,
+0xfff0000000001fff,
+0xffe0000000003fff,
+0xffc0000000007fff,
+0xff8000000000ffff,
+0xff0000000001ffff,
+0xfe0000000003ffff,
+0xfc0000000007ffff,
+0xf8000000000fffff,
+0xf0000000001fffff,
+0xe0000000003fffff,
+0xc0000000007fffff,
+0x8000000000ffffff,
+0x0000000003ffffff,
+0x0000000007fffffe,
+0x000000000ffffffc,
+0x000000001ffffff8,
+0x000000003ffffff0,
+0x000000007fffffe0,
+0x00000000ffffffc0,
+0x00000001ffffff80,
+0x00000003ffffff00,
+0x00000007fffffe00,
+0x0000000ffffffc00,
+0x0000001ffffff800,
+0x0000003ffffff000,
+0x0000007fffffe000,
+0x000000ffffffc000,
+0x000001ffffff8000,
+0x000003ffffff0000,
+0x000007fffffe0000,
+0x00000ffffffc0000,
+0x00001ffffff80000,
+0x00003ffffff00000,
+0x00007fffffe00000,
+0x0000ffffffc00000,
+0x0001ffffff800000,
+0x0003ffffff000000,
+0x0007fffffe000000,
+0x000ffffffc000000,
+0x001ffffff8000000,
+0x003ffffff0000000,
+0x007fffffe0000000,
+0x00ffffffc0000000,
+0x01ffffff80000000,
+0x03ffffff00000000,
+0x07fffffe00000000,
+0x0ffffffc00000000,
+0x1ffffff800000000,
+0x3ffffff000000000,
+0x7fffffe000000000,
+0xffffffc000000000,
+0xffffff8000000001,
+0xffffff0000000003,
+0xfffffe0000000007,
+0xfffffc000000000f,
+0xfffff8000000001f,
+0xfffff0000000003f,
+0xffffe0000000007f,
+0xffffc000000000ff,
+0xffff8000000001ff,
+0xffff0000000003ff,
+0xfffe0000000007ff,
+0xfffc000000000fff,
+0xfff8000000001fff,
+0xfff0000000003fff,
+0xffe0000000007fff,
+0xffc000000000ffff,
+0xff8000000001ffff,
+0xff0000000003ffff,
+0xfe0000000007ffff,
+0xfc000000000fffff,
+0xf8000000001fffff,
+0xf0000000003fffff,
+0xe0000000007fffff,
+0xc000000000ffffff,
+0x8000000001ffffff,
+0x0000000007ffffff,
+0x000000000ffffffe,
+0x000000001ffffffc,
+0x000000003ffffff8,
+0x000000007ffffff0,
+0x00000000ffffffe0,
+0x00000001ffffffc0,
+0x00000003ffffff80,
+0x00000007ffffff00,
+0x0000000ffffffe00,
+0x0000001ffffffc00,
+0x0000003ffffff800,
+0x0000007ffffff000,
+0x000000ffffffe000,
+0x000001ffffffc000,
+0x000003ffffff8000,
+0x000007ffffff0000,
+0x00000ffffffe0000,
+0x00001ffffffc0000,
+0x00003ffffff80000,
+0x00007ffffff00000,
+0x0000ffffffe00000,
+0x0001ffffffc00000,
+0x0003ffffff800000,
+0x0007ffffff000000,
+0x000ffffffe000000,
+0x001ffffffc000000,
+0x003ffffff8000000,
+0x007ffffff0000000,
+0x00ffffffe0000000,
+0x01ffffffc0000000,
+0x03ffffff80000000,
+0x07ffffff00000000,
+0x0ffffffe00000000,
+0x1ffffffc00000000,
+0x3ffffff800000000,
+0x7ffffff000000000,
+0xffffffe000000000,
+0xffffffc000000001,
+0xffffff8000000003,
+0xffffff0000000007,
+0xfffffe000000000f,
+0xfffffc000000001f,
+0xfffff8000000003f,
+0xfffff0000000007f,
+0xffffe000000000ff,
+0xffffc000000001ff,
+0xffff8000000003ff,
+0xffff0000000007ff,
+0xfffe000000000fff,
+0xfffc000000001fff,
+0xfff8000000003fff,
+0xfff0000000007fff,
+0xffe000000000ffff,
+0xffc000000001ffff,
+0xff8000000003ffff,
+0xff0000000007ffff,
+0xfe000000000fffff,
+0xfc000000001fffff,
+0xf8000000003fffff,
+0xf0000000007fffff,
+0xe000000000ffffff,
+0xc000000001ffffff,
+0x8000000003ffffff,
+0x000000000fffffff,
+0x000000001ffffffe,
+0x000000003ffffffc,
+0x000000007ffffff8,
+0x00000000fffffff0,
+0x00000001ffffffe0,
+0x00000003ffffffc0,
+0x00000007ffffff80,
+0x0000000fffffff00,
+0x0000001ffffffe00,
+0x0000003ffffffc00,
+0x0000007ffffff800,
+0x000000fffffff000,
+0x000001ffffffe000,
+0x000003ffffffc000,
+0x000007ffffff8000,
+0x00000fffffff0000,
+0x00001ffffffe0000,
+0x00003ffffffc0000,
+0x00007ffffff80000,
+0x0000fffffff00000,
+0x0001ffffffe00000,
+0x0003ffffffc00000,
+0x0007ffffff800000,
+0x000fffffff000000,
+0x001ffffffe000000,
+0x003ffffffc000000,
+0x007ffffff8000000,
+0x00fffffff0000000,
+0x01ffffffe0000000,
+0x03ffffffc0000000,
+0x07ffffff80000000,
+0x0fffffff00000000,
+0x1ffffffe00000000,
+0x3ffffffc00000000,
+0x7ffffff800000000,
+0xfffffff000000000,
+0xffffffe000000001,
+0xffffffc000000003,
+0xffffff8000000007,
+0xffffff000000000f,
+0xfffffe000000001f,
+0xfffffc000000003f,
+0xfffff8000000007f,
+0xfffff000000000ff,
+0xffffe000000001ff,
+0xffffc000000003ff,
+0xffff8000000007ff,
+0xffff000000000fff,
+0xfffe000000001fff,
+0xfffc000000003fff,
+0xfff8000000007fff,
+0xfff000000000ffff,
+0xffe000000001ffff,
+0xffc000000003ffff,
+0xff8000000007ffff,
+0xff000000000fffff,
+0xfe000000001fffff,
+0xfc000000003fffff,
+0xf8000000007fffff,
+0xf000000000ffffff,
+0xe000000001ffffff,
+0xc000000003ffffff,
+0x8000000007ffffff,
+0x000000001fffffff,
+0x000000003ffffffe,
+0x000000007ffffffc,
+0x00000000fffffff8,
+0x00000001fffffff0,
+0x00000003ffffffe0,
+0x00000007ffffffc0,
+0x0000000fffffff80,
+0x0000001fffffff00,
+0x0000003ffffffe00,
+0x0000007ffffffc00,
+0x000000fffffff800,
+0x000001fffffff000,
+0x000003ffffffe000,
+0x000007ffffffc000,
+0x00000fffffff8000,
+0x00001fffffff0000,
+0x00003ffffffe0000,
+0x00007ffffffc0000,
+0x0000fffffff80000,
+0x0001fffffff00000,
+0x0003ffffffe00000,
+0x0007ffffffc00000,
+0x000fffffff800000,
+0x001fffffff000000,
+0x003ffffffe000000,
+0x007ffffffc000000,
+0x00fffffff8000000,
+0x01fffffff0000000,
+0x03ffffffe0000000,
+0x07ffffffc0000000,
+0x0fffffff80000000,
+0x1fffffff00000000,
+0x3ffffffe00000000,
+0x7ffffffc00000000,
+0xfffffff800000000,
+0xfffffff000000001,
+0xffffffe000000003,
+0xffffffc000000007,
+0xffffff800000000f,
+0xffffff000000001f,
+0xfffffe000000003f,
+0xfffffc000000007f,
+0xfffff800000000ff,
+0xfffff000000001ff,
+0xffffe000000003ff,
+0xffffc000000007ff,
+0xffff800000000fff,
+0xffff000000001fff,
+0xfffe000000003fff,
+0xfffc000000007fff,
+0xfff800000000ffff,
+0xfff000000001ffff,
+0xffe000000003ffff,
+0xffc000000007ffff,
+0xff800000000fffff,
+0xff000000001fffff,
+0xfe000000003fffff,
+0xfc000000007fffff,
+0xf800000000ffffff,
+0xf000000001ffffff,
+0xe000000003ffffff,
+0xc000000007ffffff,
+0x800000000fffffff,
+0x000000003fffffff,
+0x000000007ffffffe,
+0x00000000fffffffc,
+0x00000001fffffff8,
+0x00000003fffffff0,
+0x00000007ffffffe0,
+0x0000000fffffffc0,
+0x0000001fffffff80,
+0x0000003fffffff00,
+0x0000007ffffffe00,
+0x000000fffffffc00,
+0x000001fffffff800,
+0x000003fffffff000,
+0x000007ffffffe000,
+0x00000fffffffc000,
+0x00001fffffff8000,
+0x00003fffffff0000,
+0x00007ffffffe0000,
+0x0000fffffffc0000,
+0x0001fffffff80000,
+0x0003fffffff00000,
+0x0007ffffffe00000,
+0x000fffffffc00000,
+0x001fffffff800000,
+0x003fffffff000000,
+0x007ffffffe000000,
+0x00fffffffc000000,
+0x01fffffff8000000,
+0x03fffffff0000000,
+0x07ffffffe0000000,
+0x0fffffffc0000000,
+0x1fffffff80000000,
+0x3fffffff00000000,
+0x7ffffffe00000000,
+0xfffffffc00000000,
+0xfffffff800000001,
+0xfffffff000000003,
+0xffffffe000000007,
+0xffffffc00000000f,
+0xffffff800000001f,
+0xffffff000000003f,
+0xfffffe000000007f,
+0xfffffc00000000ff,
+0xfffff800000001ff,
+0xfffff000000003ff,
+0xffffe000000007ff,
+0xffffc00000000fff,
+0xffff800000001fff,
+0xffff000000003fff,
+0xfffe000000007fff,
+0xfffc00000000ffff,
+0xfff800000001ffff,
+0xfff000000003ffff,
+0xffe000000007ffff,
+0xffc00000000fffff,
+0xff800000001fffff,
+0xff000000003fffff,
+0xfe000000007fffff,
+0xfc00000000ffffff,
+0xf800000001ffffff,
+0xf000000003ffffff,
+0xe000000007ffffff,
+0xc00000000fffffff,
+0x800000001fffffff,
+0x000000007fffffff,
+0x00000000fffffffe,
+0x00000001fffffffc,
+0x00000003fffffff8,
+0x00000007fffffff0,
+0x0000000fffffffe0,
+0x0000001fffffffc0,
+0x0000003fffffff80,
+0x0000007fffffff00,
+0x000000fffffffe00,
+0x000001fffffffc00,
+0x000003fffffff800,
+0x000007fffffff000,
+0x00000fffffffe000,
+0x00001fffffffc000,
+0x00003fffffff8000,
+0x00007fffffff0000,
+0x0000fffffffe0000,
+0x0001fffffffc0000,
+0x0003fffffff80000,
+0x0007fffffff00000,
+0x000fffffffe00000,
+0x001fffffffc00000,
+0x003fffffff800000,
+0x007fffffff000000,
+0x00fffffffe000000,
+0x01fffffffc000000,
+0x03fffffff8000000,
+0x07fffffff0000000,
+0x0fffffffe0000000,
+0x1fffffffc0000000,
+0x3fffffff80000000,
+0x7fffffff00000000,
+0xfffffffe00000000,
+0xfffffffc00000001,
+0xfffffff800000003,
+0xfffffff000000007,
+0xffffffe00000000f,
+0xffffffc00000001f,
+0xffffff800000003f,
+0xffffff000000007f,
+0xfffffe00000000ff,
+0xfffffc00000001ff,
+0xfffff800000003ff,
+0xfffff000000007ff,
+0xffffe00000000fff,
+0xffffc00000001fff,
+0xffff800000003fff,
+0xffff000000007fff,
+0xfffe00000000ffff,
+0xfffc00000001ffff,
+0xfff800000003ffff,
+0xfff000000007ffff,
+0xffe00000000fffff,
+0xffc00000001fffff,
+0xff800000003fffff,
+0xff000000007fffff,
+0xfe00000000ffffff,
+0xfc00000001ffffff,
+0xf800000003ffffff,
+0xf000000007ffffff,
+0xe00000000fffffff,
+0xc00000001fffffff,
+0x800000003fffffff,
+0x00000000ffffffff,
+0x00000001fffffffe,
+0x00000003fffffffc,
+0x00000007fffffff8,
+0x0000000ffffffff0,
+0x0000001fffffffe0,
+0x0000003fffffffc0,
+0x0000007fffffff80,
+0x000000ffffffff00,
+0x000001fffffffe00,
+0x000003fffffffc00,
+0x000007fffffff800,
+0x00000ffffffff000,
+0x00001fffffffe000,
+0x00003fffffffc000,
+0x00007fffffff8000,
+0x0000ffffffff0000,
+0x0001fffffffe0000,
+0x0003fffffffc0000,
+0x0007fffffff80000,
+0x000ffffffff00000,
+0x001fffffffe00000,
+0x003fffffffc00000,
+0x007fffffff800000,
+0x00ffffffff000000,
+0x01fffffffe000000,
+0x03fffffffc000000,
+0x07fffffff8000000,
+0x0ffffffff0000000,
+0x1fffffffe0000000,
+0x3fffffffc0000000,
+0x7fffffff80000000,
+0xffffffff00000000,
+0xfffffffe00000001,
+0xfffffffc00000003,
+0xfffffff800000007,
+0xfffffff00000000f,
+0xffffffe00000001f,
+0xffffffc00000003f,
+0xffffff800000007f,
+0xffffff00000000ff,
+0xfffffe00000001ff,
+0xfffffc00000003ff,
+0xfffff800000007ff,
+0xfffff00000000fff,
+0xffffe00000001fff,
+0xffffc00000003fff,
+0xffff800000007fff,
+0xffff00000000ffff,
+0xfffe00000001ffff,
+0xfffc00000003ffff,
+0xfff800000007ffff,
+0xfff00000000fffff,
+0xffe00000001fffff,
+0xffc00000003fffff,
+0xff800000007fffff,
+0xff00000000ffffff,
+0xfe00000001ffffff,
+0xfc00000003ffffff,
+0xf800000007ffffff,
+0xf00000000fffffff,
+0xe00000001fffffff,
+0xc00000003fffffff,
+0x800000007fffffff,
+0x00000001ffffffff,
+0x00000003fffffffe,
+0x00000007fffffffc,
+0x0000000ffffffff8,
+0x0000001ffffffff0,
+0x0000003fffffffe0,
+0x0000007fffffffc0,
+0x000000ffffffff80,
+0x000001ffffffff00,
+0x000003fffffffe00,
+0x000007fffffffc00,
+0x00000ffffffff800,
+0x00001ffffffff000,
+0x00003fffffffe000,
+0x00007fffffffc000,
+0x0000ffffffff8000,
+0x0001ffffffff0000,
+0x0003fffffffe0000,
+0x0007fffffffc0000,
+0x000ffffffff80000,
+0x001ffffffff00000,
+0x003fffffffe00000,
+0x007fffffffc00000,
+0x00ffffffff800000,
+0x01ffffffff000000,
+0x03fffffffe000000,
+0x07fffffffc000000,
+0x0ffffffff8000000,
+0x1ffffffff0000000,
+0x3fffffffe0000000,
+0x7fffffffc0000000,
+0xffffffff80000000,
+0xffffffff00000001,
+0xfffffffe00000003,
+0xfffffffc00000007,
+0xfffffff80000000f,
+0xfffffff00000001f,
+0xffffffe00000003f,
+0xffffffc00000007f,
+0xffffff80000000ff,
+0xffffff00000001ff,
+0xfffffe00000003ff,
+0xfffffc00000007ff,
+0xfffff80000000fff,
+0xfffff00000001fff,
+0xffffe00000003fff,
+0xffffc00000007fff,
+0xffff80000000ffff,
+0xffff00000001ffff,
+0xfffe00000003ffff,
+0xfffc00000007ffff,
+0xfff80000000fffff,
+0xfff00000001fffff,
+0xffe00000003fffff,
+0xffc00000007fffff,
+0xff80000000ffffff,
+0xff00000001ffffff,
+0xfe00000003ffffff,
+0xfc00000007ffffff,
+0xf80000000fffffff,
+0xf00000001fffffff,
+0xe00000003fffffff,
+0xc00000007fffffff,
+0x80000000ffffffff,
+0x00000003ffffffff,
+0x00000007fffffffe,
+0x0000000ffffffffc,
+0x0000001ffffffff8,
+0x0000003ffffffff0,
+0x0000007fffffffe0,
+0x000000ffffffffc0,
+0x000001ffffffff80,
+0x000003ffffffff00,
+0x000007fffffffe00,
+0x00000ffffffffc00,
+0x00001ffffffff800,
+0x00003ffffffff000,
+0x00007fffffffe000,
+0x0000ffffffffc000,
+0x0001ffffffff8000,
+0x0003ffffffff0000,
+0x0007fffffffe0000,
+0x000ffffffffc0000,
+0x001ffffffff80000,
+0x003ffffffff00000,
+0x007fffffffe00000,
+0x00ffffffffc00000,
+0x01ffffffff800000,
+0x03ffffffff000000,
+0x07fffffffe000000,
+0x0ffffffffc000000,
+0x1ffffffff8000000,
+0x3ffffffff0000000,
+0x7fffffffe0000000,
+0xffffffffc0000000,
+0xffffffff80000001,
+0xffffffff00000003,
+0xfffffffe00000007,
+0xfffffffc0000000f,
+0xfffffff80000001f,
+0xfffffff00000003f,
+0xffffffe00000007f,
+0xffffffc0000000ff,
+0xffffff80000001ff,
+0xffffff00000003ff,
+0xfffffe00000007ff,
+0xfffffc0000000fff,
+0xfffff80000001fff,
+0xfffff00000003fff,
+0xffffe00000007fff,
+0xffffc0000000ffff,
+0xffff80000001ffff,
+0xffff00000003ffff,
+0xfffe00000007ffff,
+0xfffc0000000fffff,
+0xfff80000001fffff,
+0xfff00000003fffff,
+0xffe00000007fffff,
+0xffc0000000ffffff,
+0xff80000001ffffff,
+0xff00000003ffffff,
+0xfe00000007ffffff,
+0xfc0000000fffffff,
+0xf80000001fffffff,
+0xf00000003fffffff,
+0xe00000007fffffff,
+0xc0000000ffffffff,
+0x80000001ffffffff,
+0x00000007ffffffff,
+0x0000000ffffffffe,
+0x0000001ffffffffc,
+0x0000003ffffffff8,
+0x0000007ffffffff0,
+0x000000ffffffffe0,
+0x000001ffffffffc0,
+0x000003ffffffff80,
+0x000007ffffffff00,
+0x00000ffffffffe00,
+0x00001ffffffffc00,
+0x00003ffffffff800,
+0x00007ffffffff000,
+0x0000ffffffffe000,
+0x0001ffffffffc000,
+0x0003ffffffff8000,
+0x0007ffffffff0000,
+0x000ffffffffe0000,
+0x001ffffffffc0000,
+0x003ffffffff80000,
+0x007ffffffff00000,
+0x00ffffffffe00000,
+0x01ffffffffc00000,
+0x03ffffffff800000,
+0x07ffffffff000000,
+0x0ffffffffe000000,
+0x1ffffffffc000000,
+0x3ffffffff8000000,
+0x7ffffffff0000000,
+0xffffffffe0000000,
+0xffffffffc0000001,
+0xffffffff80000003,
+0xffffffff00000007,
+0xfffffffe0000000f,
+0xfffffffc0000001f,
+0xfffffff80000003f,
+0xfffffff00000007f,
+0xffffffe0000000ff,
+0xffffffc0000001ff,
+0xffffff80000003ff,
+0xffffff00000007ff,
+0xfffffe0000000fff,
+0xfffffc0000001fff,
+0xfffff80000003fff,
+0xfffff00000007fff,
+0xffffe0000000ffff,
+0xffffc0000001ffff,
+0xffff80000003ffff,
+0xffff00000007ffff,
+0xfffe0000000fffff,
+0xfffc0000001fffff,
+0xfff80000003fffff,
+0xfff00000007fffff,
+0xffe0000000ffffff,
+0xffc0000001ffffff,
+0xff80000003ffffff,
+0xff00000007ffffff,
+0xfe0000000fffffff,
+0xfc0000001fffffff,
+0xf80000003fffffff,
+0xf00000007fffffff,
+0xe0000000ffffffff,
+0xc0000001ffffffff,
+0x80000003ffffffff,
+0x0000000fffffffff,
+0x0000001ffffffffe,
+0x0000003ffffffffc,
+0x0000007ffffffff8,
+0x000000fffffffff0,
+0x000001ffffffffe0,
+0x000003ffffffffc0,
+0x000007ffffffff80,
+0x00000fffffffff00,
+0x00001ffffffffe00,
+0x00003ffffffffc00,
+0x00007ffffffff800,
+0x0000fffffffff000,
+0x0001ffffffffe000,
+0x0003ffffffffc000,
+0x0007ffffffff8000,
+0x000fffffffff0000,
+0x001ffffffffe0000,
+0x003ffffffffc0000,
+0x007ffffffff80000,
+0x00fffffffff00000,
+0x01ffffffffe00000,
+0x03ffffffffc00000,
+0x07ffffffff800000,
+0x0fffffffff000000,
+0x1ffffffffe000000,
+0x3ffffffffc000000,
+0x7ffffffff8000000,
+0xfffffffff0000000,
+0xffffffffe0000001,
+0xffffffffc0000003,
+0xffffffff80000007,
+0xffffffff0000000f,
+0xfffffffe0000001f,
+0xfffffffc0000003f,
+0xfffffff80000007f,
+0xfffffff0000000ff,
+0xffffffe0000001ff,
+0xffffffc0000003ff,
+0xffffff80000007ff,
+0xffffff0000000fff,
+0xfffffe0000001fff,
+0xfffffc0000003fff,
+0xfffff80000007fff,
+0xfffff0000000ffff,
+0xffffe0000001ffff,
+0xffffc0000003ffff,
+0xffff80000007ffff,
+0xffff0000000fffff,
+0xfffe0000001fffff,
+0xfffc0000003fffff,
+0xfff80000007fffff,
+0xfff0000000ffffff,
+0xffe0000001ffffff,
+0xffc0000003ffffff,
+0xff80000007ffffff,
+0xff0000000fffffff,
+0xfe0000001fffffff,
+0xfc0000003fffffff,
+0xf80000007fffffff,
+0xf0000000ffffffff,
+0xe0000001ffffffff,
+0xc0000003ffffffff,
+0x80000007ffffffff,
+0x0000001fffffffff,
+0x0000003ffffffffe,
+0x0000007ffffffffc,
+0x000000fffffffff8,
+0x000001fffffffff0,
+0x000003ffffffffe0,
+0x000007ffffffffc0,
+0x00000fffffffff80,
+0x00001fffffffff00,
+0x00003ffffffffe00,
+0x00007ffffffffc00,
+0x0000fffffffff800,
+0x0001fffffffff000,
+0x0003ffffffffe000,
+0x0007ffffffffc000,
+0x000fffffffff8000,
+0x001fffffffff0000,
+0x003ffffffffe0000,
+0x007ffffffffc0000,
+0x00fffffffff80000,
+0x01fffffffff00000,
+0x03ffffffffe00000,
+0x07ffffffffc00000,
+0x0fffffffff800000,
+0x1fffffffff000000,
+0x3ffffffffe000000,
+0x7ffffffffc000000,
+0xfffffffff8000000,
+0xfffffffff0000001,
+0xffffffffe0000003,
+0xffffffffc0000007,
+0xffffffff8000000f,
+0xffffffff0000001f,
+0xfffffffe0000003f,
+0xfffffffc0000007f,
+0xfffffff8000000ff,
+0xfffffff0000001ff,
+0xffffffe0000003ff,
+0xffffffc0000007ff,
+0xffffff8000000fff,
+0xffffff0000001fff,
+0xfffffe0000003fff,
+0xfffffc0000007fff,
+0xfffff8000000ffff,
+0xfffff0000001ffff,
+0xffffe0000003ffff,
+0xffffc0000007ffff,
+0xffff8000000fffff,
+0xffff0000001fffff,
+0xfffe0000003fffff,
+0xfffc0000007fffff,
+0xfff8000000ffffff,
+0xfff0000001ffffff,
+0xffe0000003ffffff,
+0xffc0000007ffffff,
+0xff8000000fffffff,
+0xff0000001fffffff,
+0xfe0000003fffffff,
+0xfc0000007fffffff,
+0xf8000000ffffffff,
+0xf0000001ffffffff,
+0xe0000003ffffffff,
+0xc0000007ffffffff,
+0x8000000fffffffff,
+0x0000003fffffffff,
+0x0000007ffffffffe,
+0x000000fffffffffc,
+0x000001fffffffff8,
+0x000003fffffffff0,
+0x000007ffffffffe0,
+0x00000fffffffffc0,
+0x00001fffffffff80,
+0x00003fffffffff00,
+0x00007ffffffffe00,
+0x0000fffffffffc00,
+0x0001fffffffff800,
+0x0003fffffffff000,
+0x0007ffffffffe000,
+0x000fffffffffc000,
+0x001fffffffff8000,
+0x003fffffffff0000,
+0x007ffffffffe0000,
+0x00fffffffffc0000,
+0x01fffffffff80000,
+0x03fffffffff00000,
+0x07ffffffffe00000,
+0x0fffffffffc00000,
+0x1fffffffff800000,
+0x3fffffffff000000,
+0x7ffffffffe000000,
+0xfffffffffc000000,
+0xfffffffff8000001,
+0xfffffffff0000003,
+0xffffffffe0000007,
+0xffffffffc000000f,
+0xffffffff8000001f,
+0xffffffff0000003f,
+0xfffffffe0000007f,
+0xfffffffc000000ff,
+0xfffffff8000001ff,
+0xfffffff0000003ff,
+0xffffffe0000007ff,
+0xffffffc000000fff,
+0xffffff8000001fff,
+0xffffff0000003fff,
+0xfffffe0000007fff,
+0xfffffc000000ffff,
+0xfffff8000001ffff,
+0xfffff0000003ffff,
+0xffffe0000007ffff,
+0xffffc000000fffff,
+0xffff8000001fffff,
+0xffff0000003fffff,
+0xfffe0000007fffff,
+0xfffc000000ffffff,
+0xfff8000001ffffff,
+0xfff0000003ffffff,
+0xffe0000007ffffff,
+0xffc000000fffffff,
+0xff8000001fffffff,
+0xff0000003fffffff,
+0xfe0000007fffffff,
+0xfc000000ffffffff,
+0xf8000001ffffffff,
+0xf0000003ffffffff,
+0xe0000007ffffffff,
+0xc000000fffffffff,
+0x8000001fffffffff,
+0x0000007fffffffff,
+0x000000fffffffffe,
+0x000001fffffffffc,
+0x000003fffffffff8,
+0x000007fffffffff0,
+0x00000fffffffffe0,
+0x00001fffffffffc0,
+0x00003fffffffff80,
+0x00007fffffffff00,
+0x0000fffffffffe00,
+0x0001fffffffffc00,
+0x0003fffffffff800,
+0x0007fffffffff000,
+0x000fffffffffe000,
+0x001fffffffffc000,
+0x003fffffffff8000,
+0x007fffffffff0000,
+0x00fffffffffe0000,
+0x01fffffffffc0000,
+0x03fffffffff80000,
+0x07fffffffff00000,
+0x0fffffffffe00000,
+0x1fffffffffc00000,
+0x3fffffffff800000,
+0x7fffffffff000000,
+0xfffffffffe000000,
+0xfffffffffc000001,
+0xfffffffff8000003,
+0xfffffffff0000007,
+0xffffffffe000000f,
+0xffffffffc000001f,
+0xffffffff8000003f,
+0xffffffff0000007f,
+0xfffffffe000000ff,
+0xfffffffc000001ff,
+0xfffffff8000003ff,
+0xfffffff0000007ff,
+0xffffffe000000fff,
+0xffffffc000001fff,
+0xffffff8000003fff,
+0xffffff0000007fff,
+0xfffffe000000ffff,
+0xfffffc000001ffff,
+0xfffff8000003ffff,
+0xfffff0000007ffff,
+0xffffe000000fffff,
+0xffffc000001fffff,
+0xffff8000003fffff,
+0xffff0000007fffff,
+0xfffe000000ffffff,
+0xfffc000001ffffff,
+0xfff8000003ffffff,
+0xfff0000007ffffff,
+0xffe000000fffffff,
+0xffc000001fffffff,
+0xff8000003fffffff,
+0xff0000007fffffff,
+0xfe000000ffffffff,
+0xfc000001ffffffff,
+0xf8000003ffffffff,
+0xf0000007ffffffff,
+0xe000000fffffffff,
+0xc000001fffffffff,
+0x8000003fffffffff,
+0x000000ffffffffff,
+0x000001fffffffffe,
+0x000003fffffffffc,
+0x000007fffffffff8,
+0x00000ffffffffff0,
+0x00001fffffffffe0,
+0x00003fffffffffc0,
+0x00007fffffffff80,
+0x0000ffffffffff00,
+0x0001fffffffffe00,
+0x0003fffffffffc00,
+0x0007fffffffff800,
+0x000ffffffffff000,
+0x001fffffffffe000,
+0x003fffffffffc000,
+0x007fffffffff8000,
+0x00ffffffffff0000,
+0x01fffffffffe0000,
+0x03fffffffffc0000,
+0x07fffffffff80000,
+0x0ffffffffff00000,
+0x1fffffffffe00000,
+0x3fffffffffc00000,
+0x7fffffffff800000,
+0xffffffffff000000,
+0xfffffffffe000001,
+0xfffffffffc000003,
+0xfffffffff8000007,
+0xfffffffff000000f,
+0xffffffffe000001f,
+0xffffffffc000003f,
+0xffffffff8000007f,
+0xffffffff000000ff,
+0xfffffffe000001ff,
+0xfffffffc000003ff,
+0xfffffff8000007ff,
+0xfffffff000000fff,
+0xffffffe000001fff,
+0xffffffc000003fff,
+0xffffff8000007fff,
+0xffffff000000ffff,
+0xfffffe000001ffff,
+0xfffffc000003ffff,
+0xfffff8000007ffff,
+0xfffff000000fffff,
+0xffffe000001fffff,
+0xffffc000003fffff,
+0xffff8000007fffff,
+0xffff000000ffffff,
+0xfffe000001ffffff,
+0xfffc000003ffffff,
+0xfff8000007ffffff,
+0xfff000000fffffff,
+0xffe000001fffffff,
+0xffc000003fffffff,
+0xff8000007fffffff,
+0xff000000ffffffff,
+0xfe000001ffffffff,
+0xfc000003ffffffff,
+0xf8000007ffffffff,
+0xf000000fffffffff,
+0xe000001fffffffff,
+0xc000003fffffffff,
+0x8000007fffffffff,
+0x000001ffffffffff,
+0x000003fffffffffe,
+0x000007fffffffffc,
+0x00000ffffffffff8,
+0x00001ffffffffff0,
+0x00003fffffffffe0,
+0x00007fffffffffc0,
+0x0000ffffffffff80,
+0x0001ffffffffff00,
+0x0003fffffffffe00,
+0x0007fffffffffc00,
+0x000ffffffffff800,
+0x001ffffffffff000,
+0x003fffffffffe000,
+0x007fffffffffc000,
+0x00ffffffffff8000,
+0x01ffffffffff0000,
+0x03fffffffffe0000,
+0x07fffffffffc0000,
+0x0ffffffffff80000,
+0x1ffffffffff00000,
+0x3fffffffffe00000,
+0x7fffffffffc00000,
+0xffffffffff800000,
+0xffffffffff000001,
+0xfffffffffe000003,
+0xfffffffffc000007,
+0xfffffffff800000f,
+0xfffffffff000001f,
+0xffffffffe000003f,
+0xffffffffc000007f,
+0xffffffff800000ff,
+0xffffffff000001ff,
+0xfffffffe000003ff,
+0xfffffffc000007ff,
+0xfffffff800000fff,
+0xfffffff000001fff,
+0xffffffe000003fff,
+0xffffffc000007fff,
+0xffffff800000ffff,
+0xffffff000001ffff,
+0xfffffe000003ffff,
+0xfffffc000007ffff,
+0xfffff800000fffff,
+0xfffff000001fffff,
+0xffffe000003fffff,
+0xffffc000007fffff,
+0xffff800000ffffff,
+0xffff000001ffffff,
+0xfffe000003ffffff,
+0xfffc000007ffffff,
+0xfff800000fffffff,
+0xfff000001fffffff,
+0xffe000003fffffff,
+0xffc000007fffffff,
+0xff800000ffffffff,
+0xff000001ffffffff,
+0xfe000003ffffffff,
+0xfc000007ffffffff,
+0xf800000fffffffff,
+0xf000001fffffffff,
+0xe000003fffffffff,
+0xc000007fffffffff,
+0x800000ffffffffff,
+0x000003ffffffffff,
+0x000007fffffffffe,
+0x00000ffffffffffc,
+0x00001ffffffffff8,
+0x00003ffffffffff0,
+0x00007fffffffffe0,
+0x0000ffffffffffc0,
+0x0001ffffffffff80,
+0x0003ffffffffff00,
+0x0007fffffffffe00,
+0x000ffffffffffc00,
+0x001ffffffffff800,
+0x003ffffffffff000,
+0x007fffffffffe000,
+0x00ffffffffffc000,
+0x01ffffffffff8000,
+0x03ffffffffff0000,
+0x07fffffffffe0000,
+0x0ffffffffffc0000,
+0x1ffffffffff80000,
+0x3ffffffffff00000,
+0x7fffffffffe00000,
+0xffffffffffc00000,
+0xffffffffff800001,
+0xffffffffff000003,
+0xfffffffffe000007,
+0xfffffffffc00000f,
+0xfffffffff800001f,
+0xfffffffff000003f,
+0xffffffffe000007f,
+0xffffffffc00000ff,
+0xffffffff800001ff,
+0xffffffff000003ff,
+0xfffffffe000007ff,
+0xfffffffc00000fff,
+0xfffffff800001fff,
+0xfffffff000003fff,
+0xffffffe000007fff,
+0xffffffc00000ffff,
+0xffffff800001ffff,
+0xffffff000003ffff,
+0xfffffe000007ffff,
+0xfffffc00000fffff,
+0xfffff800001fffff,
+0xfffff000003fffff,
+0xffffe000007fffff,
+0xffffc00000ffffff,
+0xffff800001ffffff,
+0xffff000003ffffff,
+0xfffe000007ffffff,
+0xfffc00000fffffff,
+0xfff800001fffffff,
+0xfff000003fffffff,
+0xffe000007fffffff,
+0xffc00000ffffffff,
+0xff800001ffffffff,
+0xff000003ffffffff,
+0xfe000007ffffffff,
+0xfc00000fffffffff,
+0xf800001fffffffff,
+0xf000003fffffffff,
+0xe000007fffffffff,
+0xc00000ffffffffff,
+0x800001ffffffffff,
+0x000007ffffffffff,
+0x00000ffffffffffe,
+0x00001ffffffffffc,
+0x00003ffffffffff8,
+0x00007ffffffffff0,
+0x0000ffffffffffe0,
+0x0001ffffffffffc0,
+0x0003ffffffffff80,
+0x0007ffffffffff00,
+0x000ffffffffffe00,
+0x001ffffffffffc00,
+0x003ffffffffff800,
+0x007ffffffffff000,
+0x00ffffffffffe000,
+0x01ffffffffffc000,
+0x03ffffffffff8000,
+0x07ffffffffff0000,
+0x0ffffffffffe0000,
+0x1ffffffffffc0000,
+0x3ffffffffff80000,
+0x7ffffffffff00000,
+0xffffffffffe00000,
+0xffffffffffc00001,
+0xffffffffff800003,
+0xffffffffff000007,
+0xfffffffffe00000f,
+0xfffffffffc00001f,
+0xfffffffff800003f,
+0xfffffffff000007f,
+0xffffffffe00000ff,
+0xffffffffc00001ff,
+0xffffffff800003ff,
+0xffffffff000007ff,
+0xfffffffe00000fff,
+0xfffffffc00001fff,
+0xfffffff800003fff,
+0xfffffff000007fff,
+0xffffffe00000ffff,
+0xffffffc00001ffff,
+0xffffff800003ffff,
+0xffffff000007ffff,
+0xfffffe00000fffff,
+0xfffffc00001fffff,
+0xfffff800003fffff,
+0xfffff000007fffff,
+0xffffe00000ffffff,
+0xffffc00001ffffff,
+0xffff800003ffffff,
+0xffff000007ffffff,
+0xfffe00000fffffff,
+0xfffc00001fffffff,
+0xfff800003fffffff,
+0xfff000007fffffff,
+0xffe00000ffffffff,
+0xffc00001ffffffff,
+0xff800003ffffffff,
+0xff000007ffffffff,
+0xfe00000fffffffff,
+0xfc00001fffffffff,
+0xf800003fffffffff,
+0xf000007fffffffff,
+0xe00000ffffffffff,
+0xc00001ffffffffff,
+0x800003ffffffffff,
+0x00000fffffffffff,
+0x00001ffffffffffe,
+0x00003ffffffffffc,
+0x00007ffffffffff8,
+0x0000fffffffffff0,
+0x0001ffffffffffe0,
+0x0003ffffffffffc0,
+0x0007ffffffffff80,
+0x000fffffffffff00,
+0x001ffffffffffe00,
+0x003ffffffffffc00,
+0x007ffffffffff800,
+0x00fffffffffff000,
+0x01ffffffffffe000,
+0x03ffffffffffc000,
+0x07ffffffffff8000,
+0x0fffffffffff0000,
+0x1ffffffffffe0000,
+0x3ffffffffffc0000,
+0x7ffffffffff80000,
+0xfffffffffff00000,
+0xffffffffffe00001,
+0xffffffffffc00003,
+0xffffffffff800007,
+0xffffffffff00000f,
+0xfffffffffe00001f,
+0xfffffffffc00003f,
+0xfffffffff800007f,
+0xfffffffff00000ff,
+0xffffffffe00001ff,
+0xffffffffc00003ff,
+0xffffffff800007ff,
+0xffffffff00000fff,
+0xfffffffe00001fff,
+0xfffffffc00003fff,
+0xfffffff800007fff,
+0xfffffff00000ffff,
+0xffffffe00001ffff,
+0xffffffc00003ffff,
+0xffffff800007ffff,
+0xffffff00000fffff,
+0xfffffe00001fffff,
+0xfffffc00003fffff,
+0xfffff800007fffff,
+0xfffff00000ffffff,
+0xffffe00001ffffff,
+0xffffc00003ffffff,
+0xffff800007ffffff,
+0xffff00000fffffff,
+0xfffe00001fffffff,
+0xfffc00003fffffff,
+0xfff800007fffffff,
+0xfff00000ffffffff,
+0xffe00001ffffffff,
+0xffc00003ffffffff,
+0xff800007ffffffff,
+0xff00000fffffffff,
+0xfe00001fffffffff,
+0xfc00003fffffffff,
+0xf800007fffffffff,
+0xf00000ffffffffff,
+0xe00001ffffffffff,
+0xc00003ffffffffff,
+0x800007ffffffffff,
+0x00001fffffffffff,
+0x00003ffffffffffe,
+0x00007ffffffffffc,
+0x0000fffffffffff8,
+0x0001fffffffffff0,
+0x0003ffffffffffe0,
+0x0007ffffffffffc0,
+0x000fffffffffff80,
+0x001fffffffffff00,
+0x003ffffffffffe00,
+0x007ffffffffffc00,
+0x00fffffffffff800,
+0x01fffffffffff000,
+0x03ffffffffffe000,
+0x07ffffffffffc000,
+0x0fffffffffff8000,
+0x1fffffffffff0000,
+0x3ffffffffffe0000,
+0x7ffffffffffc0000,
+0xfffffffffff80000,
+0xfffffffffff00001,
+0xffffffffffe00003,
+0xffffffffffc00007,
+0xffffffffff80000f,
+0xffffffffff00001f,
+0xfffffffffe00003f,
+0xfffffffffc00007f,
+0xfffffffff80000ff,
+0xfffffffff00001ff,
+0xffffffffe00003ff,
+0xffffffffc00007ff,
+0xffffffff80000fff,
+0xffffffff00001fff,
+0xfffffffe00003fff,
+0xfffffffc00007fff,
+0xfffffff80000ffff,
+0xfffffff00001ffff,
+0xffffffe00003ffff,
+0xffffffc00007ffff,
+0xffffff80000fffff,
+0xffffff00001fffff,
+0xfffffe00003fffff,
+0xfffffc00007fffff,
+0xfffff80000ffffff,
+0xfffff00001ffffff,
+0xffffe00003ffffff,
+0xffffc00007ffffff,
+0xffff80000fffffff,
+0xffff00001fffffff,
+0xfffe00003fffffff,
+0xfffc00007fffffff,
+0xfff80000ffffffff,
+0xfff00001ffffffff,
+0xffe00003ffffffff,
+0xffc00007ffffffff,
+0xff80000fffffffff,
+0xff00001fffffffff,
+0xfe00003fffffffff,
+0xfc00007fffffffff,
+0xf80000ffffffffff,
+0xf00001ffffffffff,
+0xe00003ffffffffff,
+0xc00007ffffffffff,
+0x80000fffffffffff,
+0x00003fffffffffff,
+0x00007ffffffffffe,
+0x0000fffffffffffc,
+0x0001fffffffffff8,
+0x0003fffffffffff0,
+0x0007ffffffffffe0,
+0x000fffffffffffc0,
+0x001fffffffffff80,
+0x003fffffffffff00,
+0x007ffffffffffe00,
+0x00fffffffffffc00,
+0x01fffffffffff800,
+0x03fffffffffff000,
+0x07ffffffffffe000,
+0x0fffffffffffc000,
+0x1fffffffffff8000,
+0x3fffffffffff0000,
+0x7ffffffffffe0000,
+0xfffffffffffc0000,
+0xfffffffffff80001,
+0xfffffffffff00003,
+0xffffffffffe00007,
+0xffffffffffc0000f,
+0xffffffffff80001f,
+0xffffffffff00003f,
+0xfffffffffe00007f,
+0xfffffffffc0000ff,
+0xfffffffff80001ff,
+0xfffffffff00003ff,
+0xffffffffe00007ff,
+0xffffffffc0000fff,
+0xffffffff80001fff,
+0xffffffff00003fff,
+0xfffffffe00007fff,
+0xfffffffc0000ffff,
+0xfffffff80001ffff,
+0xfffffff00003ffff,
+0xffffffe00007ffff,
+0xffffffc0000fffff,
+0xffffff80001fffff,
+0xffffff00003fffff,
+0xfffffe00007fffff,
+0xfffffc0000ffffff,
+0xfffff80001ffffff,
+0xfffff00003ffffff,
+0xffffe00007ffffff,
+0xffffc0000fffffff,
+0xffff80001fffffff,
+0xffff00003fffffff,
+0xfffe00007fffffff,
+0xfffc0000ffffffff,
+0xfff80001ffffffff,
+0xfff00003ffffffff,
+0xffe00007ffffffff,
+0xffc0000fffffffff,
+0xff80001fffffffff,
+0xff00003fffffffff,
+0xfe00007fffffffff,
+0xfc0000ffffffffff,
+0xf80001ffffffffff,
+0xf00003ffffffffff,
+0xe00007ffffffffff,
+0xc0000fffffffffff,
+0x80001fffffffffff,
+0x00007fffffffffff,
+0x0000fffffffffffe,
+0x0001fffffffffffc,
+0x0003fffffffffff8,
+0x0007fffffffffff0,
+0x000fffffffffffe0,
+0x001fffffffffffc0,
+0x003fffffffffff80,
+0x007fffffffffff00,
+0x00fffffffffffe00,
+0x01fffffffffffc00,
+0x03fffffffffff800,
+0x07fffffffffff000,
+0x0fffffffffffe000,
+0x1fffffffffffc000,
+0x3fffffffffff8000,
+0x7fffffffffff0000,
+0xfffffffffffe0000,
+0xfffffffffffc0001,
+0xfffffffffff80003,
+0xfffffffffff00007,
+0xffffffffffe0000f,
+0xffffffffffc0001f,
+0xffffffffff80003f,
+0xffffffffff00007f,
+0xfffffffffe0000ff,
+0xfffffffffc0001ff,
+0xfffffffff80003ff,
+0xfffffffff00007ff,
+0xffffffffe0000fff,
+0xffffffffc0001fff,
+0xffffffff80003fff,
+0xffffffff00007fff,
+0xfffffffe0000ffff,
+0xfffffffc0001ffff,
+0xfffffff80003ffff,
+0xfffffff00007ffff,
+0xffffffe0000fffff,
+0xffffffc0001fffff,
+0xffffff80003fffff,
+0xffffff00007fffff,
+0xfffffe0000ffffff,
+0xfffffc0001ffffff,
+0xfffff80003ffffff,
+0xfffff00007ffffff,
+0xffffe0000fffffff,
+0xffffc0001fffffff,
+0xffff80003fffffff,
+0xffff00007fffffff,
+0xfffe0000ffffffff,
+0xfffc0001ffffffff,
+0xfff80003ffffffff,
+0xfff00007ffffffff,
+0xffe0000fffffffff,
+0xffc0001fffffffff,
+0xff80003fffffffff,
+0xff00007fffffffff,
+0xfe0000ffffffffff,
+0xfc0001ffffffffff,
+0xf80003ffffffffff,
+0xf00007ffffffffff,
+0xe0000fffffffffff,
+0xc0001fffffffffff,
+0x80003fffffffffff,
+0x0000ffffffffffff,
+0x0001fffffffffffe,
+0x0003fffffffffffc,
+0x0007fffffffffff8,
+0x000ffffffffffff0,
+0x001fffffffffffe0,
+0x003fffffffffffc0,
+0x007fffffffffff80,
+0x00ffffffffffff00,
+0x01fffffffffffe00,
+0x03fffffffffffc00,
+0x07fffffffffff800,
+0x0ffffffffffff000,
+0x1fffffffffffe000,
+0x3fffffffffffc000,
+0x7fffffffffff8000,
+0xffffffffffff0000,
+0xfffffffffffe0001,
+0xfffffffffffc0003,
+0xfffffffffff80007,
+0xfffffffffff0000f,
+0xffffffffffe0001f,
+0xffffffffffc0003f,
+0xffffffffff80007f,
+0xffffffffff0000ff,
+0xfffffffffe0001ff,
+0xfffffffffc0003ff,
+0xfffffffff80007ff,
+0xfffffffff0000fff,
+0xffffffffe0001fff,
+0xffffffffc0003fff,
+0xffffffff80007fff,
+0xffffffff0000ffff,
+0xfffffffe0001ffff,
+0xfffffffc0003ffff,
+0xfffffff80007ffff,
+0xfffffff0000fffff,
+0xffffffe0001fffff,
+0xffffffc0003fffff,
+0xffffff80007fffff,
+0xffffff0000ffffff,
+0xfffffe0001ffffff,
+0xfffffc0003ffffff,
+0xfffff80007ffffff,
+0xfffff0000fffffff,
+0xffffe0001fffffff,
+0xffffc0003fffffff,
+0xffff80007fffffff,
+0xffff0000ffffffff,
+0xfffe0001ffffffff,
+0xfffc0003ffffffff,
+0xfff80007ffffffff,
+0xfff0000fffffffff,
+0xffe0001fffffffff,
+0xffc0003fffffffff,
+0xff80007fffffffff,
+0xff0000ffffffffff,
+0xfe0001ffffffffff,
+0xfc0003ffffffffff,
+0xf80007ffffffffff,
+0xf0000fffffffffff,
+0xe0001fffffffffff,
+0xc0003fffffffffff,
+0x80007fffffffffff,
+0x0001ffffffffffff,
+0x0003fffffffffffe,
+0x0007fffffffffffc,
+0x000ffffffffffff8,
+0x001ffffffffffff0,
+0x003fffffffffffe0,
+0x007fffffffffffc0,
+0x00ffffffffffff80,
+0x01ffffffffffff00,
+0x03fffffffffffe00,
+0x07fffffffffffc00,
+0x0ffffffffffff800,
+0x1ffffffffffff000,
+0x3fffffffffffe000,
+0x7fffffffffffc000,
+0xffffffffffff8000,
+0xffffffffffff0001,
+0xfffffffffffe0003,
+0xfffffffffffc0007,
+0xfffffffffff8000f,
+0xfffffffffff0001f,
+0xffffffffffe0003f,
+0xffffffffffc0007f,
+0xffffffffff8000ff,
+0xffffffffff0001ff,
+0xfffffffffe0003ff,
+0xfffffffffc0007ff,
+0xfffffffff8000fff,
+0xfffffffff0001fff,
+0xffffffffe0003fff,
+0xffffffffc0007fff,
+0xffffffff8000ffff,
+0xffffffff0001ffff,
+0xfffffffe0003ffff,
+0xfffffffc0007ffff,
+0xfffffff8000fffff,
+0xfffffff0001fffff,
+0xffffffe0003fffff,
+0xffffffc0007fffff,
+0xffffff8000ffffff,
+0xffffff0001ffffff,
+0xfffffe0003ffffff,
+0xfffffc0007ffffff,
+0xfffff8000fffffff,
+0xfffff0001fffffff,
+0xffffe0003fffffff,
+0xffffc0007fffffff,
+0xffff8000ffffffff,
+0xffff0001ffffffff,
+0xfffe0003ffffffff,
+0xfffc0007ffffffff,
+0xfff8000fffffffff,
+0xfff0001fffffffff,
+0xffe0003fffffffff,
+0xffc0007fffffffff,
+0xff8000ffffffffff,
+0xff0001ffffffffff,
+0xfe0003ffffffffff,
+0xfc0007ffffffffff,
+0xf8000fffffffffff,
+0xf0001fffffffffff,
+0xe0003fffffffffff,
+0xc0007fffffffffff,
+0x8000ffffffffffff,
+0x0003ffffffffffff,
+0x0007fffffffffffe,
+0x000ffffffffffffc,
+0x001ffffffffffff8,
+0x003ffffffffffff0,
+0x007fffffffffffe0,
+0x00ffffffffffffc0,
+0x01ffffffffffff80,
+0x03ffffffffffff00,
+0x07fffffffffffe00,
+0x0ffffffffffffc00,
+0x1ffffffffffff800,
+0x3ffffffffffff000,
+0x7fffffffffffe000,
+0xffffffffffffc000,
+0xffffffffffff8001,
+0xffffffffffff0003,
+0xfffffffffffe0007,
+0xfffffffffffc000f,
+0xfffffffffff8001f,
+0xfffffffffff0003f,
+0xffffffffffe0007f,
+0xffffffffffc000ff,
+0xffffffffff8001ff,
+0xffffffffff0003ff,
+0xfffffffffe0007ff,
+0xfffffffffc000fff,
+0xfffffffff8001fff,
+0xfffffffff0003fff,
+0xffffffffe0007fff,
+0xffffffffc000ffff,
+0xffffffff8001ffff,
+0xffffffff0003ffff,
+0xfffffffe0007ffff,
+0xfffffffc000fffff,
+0xfffffff8001fffff,
+0xfffffff0003fffff,
+0xffffffe0007fffff,
+0xffffffc000ffffff,
+0xffffff8001ffffff,
+0xffffff0003ffffff,
+0xfffffe0007ffffff,
+0xfffffc000fffffff,
+0xfffff8001fffffff,
+0xfffff0003fffffff,
+0xffffe0007fffffff,
+0xffffc000ffffffff,
+0xffff8001ffffffff,
+0xffff0003ffffffff,
+0xfffe0007ffffffff,
+0xfffc000fffffffff,
+0xfff8001fffffffff,
+0xfff0003fffffffff,
+0xffe0007fffffffff,
+0xffc000ffffffffff,
+0xff8001ffffffffff,
+0xff0003ffffffffff,
+0xfe0007ffffffffff,
+0xfc000fffffffffff,
+0xf8001fffffffffff,
+0xf0003fffffffffff,
+0xe0007fffffffffff,
+0xc000ffffffffffff,
+0x8001ffffffffffff,
+0x0007ffffffffffff,
+0x000ffffffffffffe,
+0x001ffffffffffffc,
+0x003ffffffffffff8,
+0x007ffffffffffff0,
+0x00ffffffffffffe0,
+0x01ffffffffffffc0,
+0x03ffffffffffff80,
+0x07ffffffffffff00,
+0x0ffffffffffffe00,
+0x1ffffffffffffc00,
+0x3ffffffffffff800,
+0x7ffffffffffff000,
+0xffffffffffffe000,
+0xffffffffffffc001,
+0xffffffffffff8003,
+0xffffffffffff0007,
+0xfffffffffffe000f,
+0xfffffffffffc001f,
+0xfffffffffff8003f,
+0xfffffffffff0007f,
+0xffffffffffe000ff,
+0xffffffffffc001ff,
+0xffffffffff8003ff,
+0xffffffffff0007ff,
+0xfffffffffe000fff,
+0xfffffffffc001fff,
+0xfffffffff8003fff,
+0xfffffffff0007fff,
+0xffffffffe000ffff,
+0xffffffffc001ffff,
+0xffffffff8003ffff,
+0xffffffff0007ffff,
+0xfffffffe000fffff,
+0xfffffffc001fffff,
+0xfffffff8003fffff,
+0xfffffff0007fffff,
+0xffffffe000ffffff,
+0xffffffc001ffffff,
+0xffffff8003ffffff,
+0xffffff0007ffffff,
+0xfffffe000fffffff,
+0xfffffc001fffffff,
+0xfffff8003fffffff,
+0xfffff0007fffffff,
+0xffffe000ffffffff,
+0xffffc001ffffffff,
+0xffff8003ffffffff,
+0xffff0007ffffffff,
+0xfffe000fffffffff,
+0xfffc001fffffffff,
+0xfff8003fffffffff,
+0xfff0007fffffffff,
+0xffe000ffffffffff,
+0xffc001ffffffffff,
+0xff8003ffffffffff,
+0xff0007ffffffffff,
+0xfe000fffffffffff,
+0xfc001fffffffffff,
+0xf8003fffffffffff,
+0xf0007fffffffffff,
+0xe000ffffffffffff,
+0xc001ffffffffffff,
+0x8003ffffffffffff,
+0x000fffffffffffff,
+0x001ffffffffffffe,
+0x003ffffffffffffc,
+0x007ffffffffffff8,
+0x00fffffffffffff0,
+0x01ffffffffffffe0,
+0x03ffffffffffffc0,
+0x07ffffffffffff80,
+0x0fffffffffffff00,
+0x1ffffffffffffe00,
+0x3ffffffffffffc00,
+0x7ffffffffffff800,
+0xfffffffffffff000,
+0xffffffffffffe001,
+0xffffffffffffc003,
+0xffffffffffff8007,
+0xffffffffffff000f,
+0xfffffffffffe001f,
+0xfffffffffffc003f,
+0xfffffffffff8007f,
+0xfffffffffff000ff,
+0xffffffffffe001ff,
+0xffffffffffc003ff,
+0xffffffffff8007ff,
+0xffffffffff000fff,
+0xfffffffffe001fff,
+0xfffffffffc003fff,
+0xfffffffff8007fff,
+0xfffffffff000ffff,
+0xffffffffe001ffff,
+0xffffffffc003ffff,
+0xffffffff8007ffff,
+0xffffffff000fffff,
+0xfffffffe001fffff,
+0xfffffffc003fffff,
+0xfffffff8007fffff,
+0xfffffff000ffffff,
+0xffffffe001ffffff,
+0xffffffc003ffffff,
+0xffffff8007ffffff,
+0xffffff000fffffff,
+0xfffffe001fffffff,
+0xfffffc003fffffff,
+0xfffff8007fffffff,
+0xfffff000ffffffff,
+0xffffe001ffffffff,
+0xffffc003ffffffff,
+0xffff8007ffffffff,
+0xffff000fffffffff,
+0xfffe001fffffffff,
+0xfffc003fffffffff,
+0xfff8007fffffffff,
+0xfff000ffffffffff,
+0xffe001ffffffffff,
+0xffc003ffffffffff,
+0xff8007ffffffffff,
+0xff000fffffffffff,
+0xfe001fffffffffff,
+0xfc003fffffffffff,
+0xf8007fffffffffff,
+0xf000ffffffffffff,
+0xe001ffffffffffff,
+0xc003ffffffffffff,
+0x8007ffffffffffff,
+0x001fffffffffffff,
+0x003ffffffffffffe,
+0x007ffffffffffffc,
+0x00fffffffffffff8,
+0x01fffffffffffff0,
+0x03ffffffffffffe0,
+0x07ffffffffffffc0,
+0x0fffffffffffff80,
+0x1fffffffffffff00,
+0x3ffffffffffffe00,
+0x7ffffffffffffc00,
+0xfffffffffffff800,
+0xfffffffffffff001,
+0xffffffffffffe003,
+0xffffffffffffc007,
+0xffffffffffff800f,
+0xffffffffffff001f,
+0xfffffffffffe003f,
+0xfffffffffffc007f,
+0xfffffffffff800ff,
+0xfffffffffff001ff,
+0xffffffffffe003ff,
+0xffffffffffc007ff,
+0xffffffffff800fff,
+0xffffffffff001fff,
+0xfffffffffe003fff,
+0xfffffffffc007fff,
+0xfffffffff800ffff,
+0xfffffffff001ffff,
+0xffffffffe003ffff,
+0xffffffffc007ffff,
+0xffffffff800fffff,
+0xffffffff001fffff,
+0xfffffffe003fffff,
+0xfffffffc007fffff,
+0xfffffff800ffffff,
+0xfffffff001ffffff,
+0xffffffe003ffffff,
+0xffffffc007ffffff,
+0xffffff800fffffff,
+0xffffff001fffffff,
+0xfffffe003fffffff,
+0xfffffc007fffffff,
+0xfffff800ffffffff,
+0xfffff001ffffffff,
+0xffffe003ffffffff,
+0xffffc007ffffffff,
+0xffff800fffffffff,
+0xffff001fffffffff,
+0xfffe003fffffffff,
+0xfffc007fffffffff,
+0xfff800ffffffffff,
+0xfff001ffffffffff,
+0xffe003ffffffffff,
+0xffc007ffffffffff,
+0xff800fffffffffff,
+0xff001fffffffffff,
+0xfe003fffffffffff,
+0xfc007fffffffffff,
+0xf800ffffffffffff,
+0xf001ffffffffffff,
+0xe003ffffffffffff,
+0xc007ffffffffffff,
+0x800fffffffffffff,
+0x003fffffffffffff,
+0x007ffffffffffffe,
+0x00fffffffffffffc,
+0x01fffffffffffff8,
+0x03fffffffffffff0,
+0x07ffffffffffffe0,
+0x0fffffffffffffc0,
+0x1fffffffffffff80,
+0x3fffffffffffff00,
+0x7ffffffffffffe00,
+0xfffffffffffffc00,
+0xfffffffffffff801,
+0xfffffffffffff003,
+0xffffffffffffe007,
+0xffffffffffffc00f,
+0xffffffffffff801f,
+0xffffffffffff003f,
+0xfffffffffffe007f,
+0xfffffffffffc00ff,
+0xfffffffffff801ff,
+0xfffffffffff003ff,
+0xffffffffffe007ff,
+0xffffffffffc00fff,
+0xffffffffff801fff,
+0xffffffffff003fff,
+0xfffffffffe007fff,
+0xfffffffffc00ffff,
+0xfffffffff801ffff,
+0xfffffffff003ffff,
+0xffffffffe007ffff,
+0xffffffffc00fffff,
+0xffffffff801fffff,
+0xffffffff003fffff,
+0xfffffffe007fffff,
+0xfffffffc00ffffff,
+0xfffffff801ffffff,
+0xfffffff003ffffff,
+0xffffffe007ffffff,
+0xffffffc00fffffff,
+0xffffff801fffffff,
+0xffffff003fffffff,
+0xfffffe007fffffff,
+0xfffffc00ffffffff,
+0xfffff801ffffffff,
+0xfffff003ffffffff,
+0xffffe007ffffffff,
+0xffffc00fffffffff,
+0xffff801fffffffff,
+0xffff003fffffffff,
+0xfffe007fffffffff,
+0xfffc00ffffffffff,
+0xfff801ffffffffff,
+0xfff003ffffffffff,
+0xffe007ffffffffff,
+0xffc00fffffffffff,
+0xff801fffffffffff,
+0xff003fffffffffff,
+0xfe007fffffffffff,
+0xfc00ffffffffffff,
+0xf801ffffffffffff,
+0xf003ffffffffffff,
+0xe007ffffffffffff,
+0xc00fffffffffffff,
+0x801fffffffffffff,
+0x007fffffffffffff,
+0x00fffffffffffffe,
+0x01fffffffffffffc,
+0x03fffffffffffff8,
+0x07fffffffffffff0,
+0x0fffffffffffffe0,
+0x1fffffffffffffc0,
+0x3fffffffffffff80,
+0x7fffffffffffff00,
+0xfffffffffffffe00,
+0xfffffffffffffc01,
+0xfffffffffffff803,
+0xfffffffffffff007,
+0xffffffffffffe00f,
+0xffffffffffffc01f,
+0xffffffffffff803f,
+0xffffffffffff007f,
+0xfffffffffffe00ff,
+0xfffffffffffc01ff,
+0xfffffffffff803ff,
+0xfffffffffff007ff,
+0xffffffffffe00fff,
+0xffffffffffc01fff,
+0xffffffffff803fff,
+0xffffffffff007fff,
+0xfffffffffe00ffff,
+0xfffffffffc01ffff,
+0xfffffffff803ffff,
+0xfffffffff007ffff,
+0xffffffffe00fffff,
+0xffffffffc01fffff,
+0xffffffff803fffff,
+0xffffffff007fffff,
+0xfffffffe00ffffff,
+0xfffffffc01ffffff,
+0xfffffff803ffffff,
+0xfffffff007ffffff,
+0xffffffe00fffffff,
+0xffffffc01fffffff,
+0xffffff803fffffff,
+0xffffff007fffffff,
+0xfffffe00ffffffff,
+0xfffffc01ffffffff,
+0xfffff803ffffffff,
+0xfffff007ffffffff,
+0xffffe00fffffffff,
+0xffffc01fffffffff,
+0xffff803fffffffff,
+0xffff007fffffffff,
+0xfffe00ffffffffff,
+0xfffc01ffffffffff,
+0xfff803ffffffffff,
+0xfff007ffffffffff,
+0xffe00fffffffffff,
+0xffc01fffffffffff,
+0xff803fffffffffff,
+0xff007fffffffffff,
+0xfe00ffffffffffff,
+0xfc01ffffffffffff,
+0xf803ffffffffffff,
+0xf007ffffffffffff,
+0xe00fffffffffffff,
+0xc01fffffffffffff,
+0x803fffffffffffff,
+0x00ffffffffffffff,
+0x01fffffffffffffe,
+0x03fffffffffffffc,
+0x07fffffffffffff8,
+0x0ffffffffffffff0,
+0x1fffffffffffffe0,
+0x3fffffffffffffc0,
+0x7fffffffffffff80,
+0xffffffffffffff00,
+0xfffffffffffffe01,
+0xfffffffffffffc03,
+0xfffffffffffff807,
+0xfffffffffffff00f,
+0xffffffffffffe01f,
+0xffffffffffffc03f,
+0xffffffffffff807f,
+0xffffffffffff00ff,
+0xfffffffffffe01ff,
+0xfffffffffffc03ff,
+0xfffffffffff807ff,
+0xfffffffffff00fff,
+0xffffffffffe01fff,
+0xffffffffffc03fff,
+0xffffffffff807fff,
+0xffffffffff00ffff,
+0xfffffffffe01ffff,
+0xfffffffffc03ffff,
+0xfffffffff807ffff,
+0xfffffffff00fffff,
+0xffffffffe01fffff,
+0xffffffffc03fffff,
+0xffffffff807fffff,
+0xffffffff00ffffff,
+0xfffffffe01ffffff,
+0xfffffffc03ffffff,
+0xfffffff807ffffff,
+0xfffffff00fffffff,
+0xffffffe01fffffff,
+0xffffffc03fffffff,
+0xffffff807fffffff,
+0xffffff00ffffffff,
+0xfffffe01ffffffff,
+0xfffffc03ffffffff,
+0xfffff807ffffffff,
+0xfffff00fffffffff,
+0xffffe01fffffffff,
+0xffffc03fffffffff,
+0xffff807fffffffff,
+0xffff00ffffffffff,
+0xfffe01ffffffffff,
+0xfffc03ffffffffff,
+0xfff807ffffffffff,
+0xfff00fffffffffff,
+0xffe01fffffffffff,
+0xffc03fffffffffff,
+0xff807fffffffffff,
+0xff00ffffffffffff,
+0xfe01ffffffffffff,
+0xfc03ffffffffffff,
+0xf807ffffffffffff,
+0xf00fffffffffffff,
+0xe01fffffffffffff,
+0xc03fffffffffffff,
+0x807fffffffffffff,
+0x01ffffffffffffff,
+0x03fffffffffffffe,
+0x07fffffffffffffc,
+0x0ffffffffffffff8,
+0x1ffffffffffffff0,
+0x3fffffffffffffe0,
+0x7fffffffffffffc0,
+0xffffffffffffff80,
+0xffffffffffffff01,
+0xfffffffffffffe03,
+0xfffffffffffffc07,
+0xfffffffffffff80f,
+0xfffffffffffff01f,
+0xffffffffffffe03f,
+0xffffffffffffc07f,
+0xffffffffffff80ff,
+0xffffffffffff01ff,
+0xfffffffffffe03ff,
+0xfffffffffffc07ff,
+0xfffffffffff80fff,
+0xfffffffffff01fff,
+0xffffffffffe03fff,
+0xffffffffffc07fff,
+0xffffffffff80ffff,
+0xffffffffff01ffff,
+0xfffffffffe03ffff,
+0xfffffffffc07ffff,
+0xfffffffff80fffff,
+0xfffffffff01fffff,
+0xffffffffe03fffff,
+0xffffffffc07fffff,
+0xffffffff80ffffff,
+0xffffffff01ffffff,
+0xfffffffe03ffffff,
+0xfffffffc07ffffff,
+0xfffffff80fffffff,
+0xfffffff01fffffff,
+0xffffffe03fffffff,
+0xffffffc07fffffff,
+0xffffff80ffffffff,
+0xffffff01ffffffff,
+0xfffffe03ffffffff,
+0xfffffc07ffffffff,
+0xfffff80fffffffff,
+0xfffff01fffffffff,
+0xffffe03fffffffff,
+0xffffc07fffffffff,
+0xffff80ffffffffff,
+0xffff01ffffffffff,
+0xfffe03ffffffffff,
+0xfffc07ffffffffff,
+0xfff80fffffffffff,
+0xfff01fffffffffff,
+0xffe03fffffffffff,
+0xffc07fffffffffff,
+0xff80ffffffffffff,
+0xff01ffffffffffff,
+0xfe03ffffffffffff,
+0xfc07ffffffffffff,
+0xf80fffffffffffff,
+0xf01fffffffffffff,
+0xe03fffffffffffff,
+0xc07fffffffffffff,
+0x80ffffffffffffff,
+0x03ffffffffffffff,
+0x07fffffffffffffe,
+0x0ffffffffffffffc,
+0x1ffffffffffffff8,
+0x3ffffffffffffff0,
+0x7fffffffffffffe0,
+0xffffffffffffffc0,
+0xffffffffffffff81,
+0xffffffffffffff03,
+0xfffffffffffffe07,
+0xfffffffffffffc0f,
+0xfffffffffffff81f,
+0xfffffffffffff03f,
+0xffffffffffffe07f,
+0xffffffffffffc0ff,
+0xffffffffffff81ff,
+0xffffffffffff03ff,
+0xfffffffffffe07ff,
+0xfffffffffffc0fff,
+0xfffffffffff81fff,
+0xfffffffffff03fff,
+0xffffffffffe07fff,
+0xffffffffffc0ffff,
+0xffffffffff81ffff,
+0xffffffffff03ffff,
+0xfffffffffe07ffff,
+0xfffffffffc0fffff,
+0xfffffffff81fffff,
+0xfffffffff03fffff,
+0xffffffffe07fffff,
+0xffffffffc0ffffff,
+0xffffffff81ffffff,
+0xffffffff03ffffff,
+0xfffffffe07ffffff,
+0xfffffffc0fffffff,
+0xfffffff81fffffff,
+0xfffffff03fffffff,
+0xffffffe07fffffff,
+0xffffffc0ffffffff,
+0xffffff81ffffffff,
+0xffffff03ffffffff,
+0xfffffe07ffffffff,
+0xfffffc0fffffffff,
+0xfffff81fffffffff,
+0xfffff03fffffffff,
+0xffffe07fffffffff,
+0xffffc0ffffffffff,
+0xffff81ffffffffff,
+0xffff03ffffffffff,
+0xfffe07ffffffffff,
+0xfffc0fffffffffff,
+0xfff81fffffffffff,
+0xfff03fffffffffff,
+0xffe07fffffffffff,
+0xffc0ffffffffffff,
+0xff81ffffffffffff,
+0xff03ffffffffffff,
+0xfe07ffffffffffff,
+0xfc0fffffffffffff,
+0xf81fffffffffffff,
+0xf03fffffffffffff,
+0xe07fffffffffffff,
+0xc0ffffffffffffff,
+0x81ffffffffffffff,
+0x07ffffffffffffff,
+0x0ffffffffffffffe,
+0x1ffffffffffffffc,
+0x3ffffffffffffff8,
+0x7ffffffffffffff0,
+0xffffffffffffffe0,
+0xffffffffffffffc1,
+0xffffffffffffff83,
+0xffffffffffffff07,
+0xfffffffffffffe0f,
+0xfffffffffffffc1f,
+0xfffffffffffff83f,
+0xfffffffffffff07f,
+0xffffffffffffe0ff,
+0xffffffffffffc1ff,
+0xffffffffffff83ff,
+0xffffffffffff07ff,
+0xfffffffffffe0fff,
+0xfffffffffffc1fff,
+0xfffffffffff83fff,
+0xfffffffffff07fff,
+0xffffffffffe0ffff,
+0xffffffffffc1ffff,
+0xffffffffff83ffff,
+0xffffffffff07ffff,
+0xfffffffffe0fffff,
+0xfffffffffc1fffff,
+0xfffffffff83fffff,
+0xfffffffff07fffff,
+0xffffffffe0ffffff,
+0xffffffffc1ffffff,
+0xffffffff83ffffff,
+0xffffffff07ffffff,
+0xfffffffe0fffffff,
+0xfffffffc1fffffff,
+0xfffffff83fffffff,
+0xfffffff07fffffff,
+0xffffffe0ffffffff,
+0xffffffc1ffffffff,
+0xffffff83ffffffff,
+0xffffff07ffffffff,
+0xfffffe0fffffffff,
+0xfffffc1fffffffff,
+0xfffff83fffffffff,
+0xfffff07fffffffff,
+0xffffe0ffffffffff,
+0xffffc1ffffffffff,
+0xffff83ffffffffff,
+0xffff07ffffffffff,
+0xfffe0fffffffffff,
+0xfffc1fffffffffff,
+0xfff83fffffffffff,
+0xfff07fffffffffff,
+0xffe0ffffffffffff,
+0xffc1ffffffffffff,
+0xff83ffffffffffff,
+0xff07ffffffffffff,
+0xfe0fffffffffffff,
+0xfc1fffffffffffff,
+0xf83fffffffffffff,
+0xf07fffffffffffff,
+0xe0ffffffffffffff,
+0xc1ffffffffffffff,
+0x83ffffffffffffff,
+0x0fffffffffffffff,
+0x1ffffffffffffffe,
+0x3ffffffffffffffc,
+0x7ffffffffffffff8,
+0xfffffffffffffff0,
+0xffffffffffffffe1,
+0xffffffffffffffc3,
+0xffffffffffffff87,
+0xffffffffffffff0f,
+0xfffffffffffffe1f,
+0xfffffffffffffc3f,
+0xfffffffffffff87f,
+0xfffffffffffff0ff,
+0xffffffffffffe1ff,
+0xffffffffffffc3ff,
+0xffffffffffff87ff,
+0xffffffffffff0fff,
+0xfffffffffffe1fff,
+0xfffffffffffc3fff,
+0xfffffffffff87fff,
+0xfffffffffff0ffff,
+0xffffffffffe1ffff,
+0xffffffffffc3ffff,
+0xffffffffff87ffff,
+0xffffffffff0fffff,
+0xfffffffffe1fffff,
+0xfffffffffc3fffff,
+0xfffffffff87fffff,
+0xfffffffff0ffffff,
+0xffffffffe1ffffff,
+0xffffffffc3ffffff,
+0xffffffff87ffffff,
+0xffffffff0fffffff,
+0xfffffffe1fffffff,
+0xfffffffc3fffffff,
+0xfffffff87fffffff,
+0xfffffff0ffffffff,
+0xffffffe1ffffffff,
+0xffffffc3ffffffff,
+0xffffff87ffffffff,
+0xffffff0fffffffff,
+0xfffffe1fffffffff,
+0xfffffc3fffffffff,
+0xfffff87fffffffff,
+0xfffff0ffffffffff,
+0xffffe1ffffffffff,
+0xffffc3ffffffffff,
+0xffff87ffffffffff,
+0xffff0fffffffffff,
+0xfffe1fffffffffff,
+0xfffc3fffffffffff,
+0xfff87fffffffffff,
+0xfff0ffffffffffff,
+0xffe1ffffffffffff,
+0xffc3ffffffffffff,
+0xff87ffffffffffff,
+0xff0fffffffffffff,
+0xfe1fffffffffffff,
+0xfc3fffffffffffff,
+0xf87fffffffffffff,
+0xf0ffffffffffffff,
+0xe1ffffffffffffff,
+0xc3ffffffffffffff,
+0x87ffffffffffffff,
+0x1fffffffffffffff,
+0x3ffffffffffffffe,
+0x7ffffffffffffffc,
+0xfffffffffffffff8,
+0xfffffffffffffff1,
+0xffffffffffffffe3,
+0xffffffffffffffc7,
+0xffffffffffffff8f,
+0xffffffffffffff1f,
+0xfffffffffffffe3f,
+0xfffffffffffffc7f,
+0xfffffffffffff8ff,
+0xfffffffffffff1ff,
+0xffffffffffffe3ff,
+0xffffffffffffc7ff,
+0xffffffffffff8fff,
+0xffffffffffff1fff,
+0xfffffffffffe3fff,
+0xfffffffffffc7fff,
+0xfffffffffff8ffff,
+0xfffffffffff1ffff,
+0xffffffffffe3ffff,
+0xffffffffffc7ffff,
+0xffffffffff8fffff,
+0xffffffffff1fffff,
+0xfffffffffe3fffff,
+0xfffffffffc7fffff,
+0xfffffffff8ffffff,
+0xfffffffff1ffffff,
+0xffffffffe3ffffff,
+0xffffffffc7ffffff,
+0xffffffff8fffffff,
+0xffffffff1fffffff,
+0xfffffffe3fffffff,
+0xfffffffc7fffffff,
+0xfffffff8ffffffff,
+0xfffffff1ffffffff,
+0xffffffe3ffffffff,
+0xffffffc7ffffffff,
+0xffffff8fffffffff,
+0xffffff1fffffffff,
+0xfffffe3fffffffff,
+0xfffffc7fffffffff,
+0xfffff8ffffffffff,
+0xfffff1ffffffffff,
+0xffffe3ffffffffff,
+0xffffc7ffffffffff,
+0xffff8fffffffffff,
+0xffff1fffffffffff,
+0xfffe3fffffffffff,
+0xfffc7fffffffffff,
+0xfff8ffffffffffff,
+0xfff1ffffffffffff,
+0xffe3ffffffffffff,
+0xffc7ffffffffffff,
+0xff8fffffffffffff,
+0xff1fffffffffffff,
+0xfe3fffffffffffff,
+0xfc7fffffffffffff,
+0xf8ffffffffffffff,
+0xf1ffffffffffffff,
+0xe3ffffffffffffff,
+0xc7ffffffffffffff,
+0x8fffffffffffffff,
+0x3fffffffffffffff,
+0x7ffffffffffffffe,
+0xfffffffffffffffc,
+0xfffffffffffffff9,
+0xfffffffffffffff3,
+0xffffffffffffffe7,
+0xffffffffffffffcf,
+0xffffffffffffff9f,
+0xffffffffffffff3f,
+0xfffffffffffffe7f,
+0xfffffffffffffcff,
+0xfffffffffffff9ff,
+0xfffffffffffff3ff,
+0xffffffffffffe7ff,
+0xffffffffffffcfff,
+0xffffffffffff9fff,
+0xffffffffffff3fff,
+0xfffffffffffe7fff,
+0xfffffffffffcffff,
+0xfffffffffff9ffff,
+0xfffffffffff3ffff,
+0xffffffffffe7ffff,
+0xffffffffffcfffff,
+0xffffffffff9fffff,
+0xffffffffff3fffff,
+0xfffffffffe7fffff,
+0xfffffffffcffffff,
+0xfffffffff9ffffff,
+0xfffffffff3ffffff,
+0xffffffffe7ffffff,
+0xffffffffcfffffff,
+0xffffffff9fffffff,
+0xffffffff3fffffff,
+0xfffffffe7fffffff,
+0xfffffffcffffffff,
+0xfffffff9ffffffff,
+0xfffffff3ffffffff,
+0xffffffe7ffffffff,
+0xffffffcfffffffff,
+0xffffff9fffffffff,
+0xffffff3fffffffff,
+0xfffffe7fffffffff,
+0xfffffcffffffffff,
+0xfffff9ffffffffff,
+0xfffff3ffffffffff,
+0xffffe7ffffffffff,
+0xffffcfffffffffff,
+0xffff9fffffffffff,
+0xffff3fffffffffff,
+0xfffe7fffffffffff,
+0xfffcffffffffffff,
+0xfff9ffffffffffff,
+0xfff3ffffffffffff,
+0xffe7ffffffffffff,
+0xffcfffffffffffff,
+0xff9fffffffffffff,
+0xff3fffffffffffff,
+0xfe7fffffffffffff,
+0xfcffffffffffffff,
+0xf9ffffffffffffff,
+0xf3ffffffffffffff,
+0xe7ffffffffffffff,
+0xcfffffffffffffff,
+0x9fffffffffffffff,
+0x7fffffffffffffff,
+0xfffffffffffffffe,
+0xfffffffffffffffd,
+0xfffffffffffffffb,
+0xfffffffffffffff7,
+0xffffffffffffffef,
+0xffffffffffffffdf,
+0xffffffffffffffbf,
+0xffffffffffffff7f,
+0xfffffffffffffeff,
+0xfffffffffffffdff,
+0xfffffffffffffbff,
+0xfffffffffffff7ff,
+0xffffffffffffefff,
+0xffffffffffffdfff,
+0xffffffffffffbfff,
+0xffffffffffff7fff,
+0xfffffffffffeffff,
+0xfffffffffffdffff,
+0xfffffffffffbffff,
+0xfffffffffff7ffff,
+0xffffffffffefffff,
+0xffffffffffdfffff,
+0xffffffffffbfffff,
+0xffffffffff7fffff,
+0xfffffffffeffffff,
+0xfffffffffdffffff,
+0xfffffffffbffffff,
+0xfffffffff7ffffff,
+0xffffffffefffffff,
+0xffffffffdfffffff,
+0xffffffffbfffffff,
+0xffffffff7fffffff,
+0xfffffffeffffffff,
+0xfffffffdffffffff,
+0xfffffffbffffffff,
+0xfffffff7ffffffff,
+0xffffffefffffffff,
+0xffffffdfffffffff,
+0xffffffbfffffffff,
+0xffffff7fffffffff,
+0xfffffeffffffffff,
+0xfffffdffffffffff,
+0xfffffbffffffffff,
+0xfffff7ffffffffff,
+0xffffefffffffffff,
+0xffffdfffffffffff,
+0xffffbfffffffffff,
+0xffff7fffffffffff,
+0xfffeffffffffffff,
+0xfffdffffffffffff,
+0xfffbffffffffffff,
+0xfff7ffffffffffff,
+0xffefffffffffffff,
+0xffdfffffffffffff,
+0xffbfffffffffffff,
+0xff7fffffffffffff,
+0xfeffffffffffffff,
+0xfdffffffffffffff,
+0xfbffffffffffffff,
+0xf7ffffffffffffff,
+0xefffffffffffffff,
+0xdfffffffffffffff,
+0xbfffffffffffffff,
+/*
+#include <stdio.h>
+#include <stdint.h>
+
+// Dumps all legal bitmask immediates for ARM64
+// Total number of unique 64-bit patterns:
+//   1*2 + 3*4 + 7*8 + 15*16 + 31*32 + 63*64 = 5334
+
+const char *uint64_to_binary(uint64_t x) {
+  static char b[65];
+  unsigned i;
+  for (i = 0; i < 64; i++, x <<= 1)
+    b[i] = (0x8000000000000000ULL & x)? '1' : '0';
+  b[64] = '\0';
+  return b;
+}
+
+int main() {
+  uint64_t result;
+  unsigned size, length, rotation, e;
+  for (size = 2; size <= 64; size *= 2)
+    for (length = 1; length < size; ++length) {
+      result = 0xffffffffffffffffULL >> (64 - length);
+      for (e = size; e < 64; e *= 2)
+        result |= result << e;
+      for (rotation = 0; rotation < size; ++rotation) {
+#if 0
+        printf("0x%016llx %s (size=%u, length=%u, rotation=%u)\n",
+            (unsigned long long)result, uint64_to_binary(result),
+            size, length, rotation);
+#endif
+        printf("0x%016llx\n", (unsigned long long)result );
+        result = (result >> 63) | (result << 1);
+      }
+    }
+  return 0;
+}
+*/
diff --git a/src/mapleall/maple_be/include/cg/visitor_common.h b/src/mapleall/maple_be/include/cg/visitor_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd5be7080e282d6cea0553bab8cfc3cf9446db29
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/visitor_common.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_VISITOR_COMMON_H
+#define MAPLEBE_INCLUDE_CG_VISITOR_COMMON_H
+namespace maplebe {
+class OperandVisitorBase {
+ public:
+  virtual ~OperandVisitorBase() = default;
+};
+
+template<typename Visitable>
+class OperandVisitor {
+ public:
+  virtual ~OperandVisitor() = default;
+  virtual void Visit(Visitable *v) = 0;
+};
+
+template<typename ... V>
+class OperandVisitors {
+ public:
+  virtual ~OperandVisitors() = default;
+};
+
+template<typename OpV1, typename OpV2, typename ... OpV3>
+class OperandVisitors<OpV1, OpV2, OpV3 ...> :
+    public OperandVisitor<OpV1>,
+    public OperandVisitor<OpV2>,
+    public OperandVisitor<OpV3> ... {};
+}  /* namespace maplebe */
+#endif /* MAPLEBE_INCLUDE_CG_VISITOR_COMMON_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_MPISel.h b/src/mapleall/maple_be/include/cg/x86_64/x64_MPISel.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a26100ccba27f2a3b5f5166a244a1ade310d8b3
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_MPISel.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_X64_MPISEL_H
+#define MAPLEBE_INCLUDE_X64_MPISEL_H
+
+#include "isel.h"
+#include "x64_call_conv.h"
+
+namespace maplebe {
+class X64MPIsel : public MPISel {
+ public:
+  X64MPIsel(MemPool &mp, CGFunc &f) : MPISel(mp, f) {}
+  ~X64MPIsel() override = default;
+  void SelectReturn(NaryStmtNode &retNode, Operand &opnd) override;
+  void SelectReturn() override;
+  void SelectCall(CallNode &callNode) override;
+  void SelectIcall(IcallNode &icallNode, Operand &opnd0) override;
+  Operand &ProcessReturnReg(PrimType primType, int32 sReg) override;
+  Operand &GetTargetRetOperand(PrimType primType, int32 sReg) override;
+  Operand *SelectAddrof(AddrofNode &expr, const BaseNode &parent) override;
+  Operand *SelectAddrofFunc(AddroffuncNode &expr, const BaseNode &parent) override;
+  Operand *SelectAddrofLabel(AddroflabelNode &expr, const BaseNode &parent) override;
+  Operand *SelectDoubleConst(MIRDoubleConst &intConst, PrimType primType) const override;
+  void SelectGoto(GotoNode &stmt) override;
+  void SelectIntrinCall(IntrinsiccallNode &intrinsiccallNode) override;
+  void SelectAggIassign(IassignNode &stmt, Operand &AddrOpnd, Operand &opndRhs) override;
+  void SelectAggDassign(maplebe::MirTypeInfo &lhsInfo, MemOperand &symbolMem, Operand &opndRhs) override;
+  void SelectAggCopy(MemOperand &lhs, MemOperand &rhs, uint32 copySize) override;
+  void SelectRangeGoto(RangeGotoNode &rangeGotoNode, Operand &srcOpnd) override;
+  void SelectCondGoto(CondGotoNode &stmt, BaseNode &condNode, Operand &opnd0) override;
+  void SelectIgoto(Operand &opnd0) override;
+  Operand *SelectDiv(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectMpy(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectCmpOp(CompareNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectSelect(TernaryNode &expr, Operand &cond, Operand &trueOpnd, Operand &falseOpnd,
+                        const BaseNode &parent) override;
+  Operand *SelectStrLiteral(ConststrNode &constStr) override;
+  void SelectIntAggCopyReturn(MemOperand &symbolMem, uint64 aggSize) override;
+  /* Create the operand interface directly */
+  MemOperand &CreateMemOpndOrNull(PrimType ptype, const BaseNode &parent, BaseNode &addrExpr, int64 offset = 0);
+  Operand *SelectBswap(IntrinsicopNode &node, Operand &opnd0, const BaseNode &parent) override;
+  void SelectAsm(AsmNode &node) override;
+ private:
+  MemOperand &GetOrCreateMemOpndFromSymbol(const MIRSymbol &symbol, FieldID fieldId = 0) const override;
+  MemOperand &GetOrCreateMemOpndFromSymbol(const MIRSymbol &symbol, uint32 opndSize, int64 offset) const override;
+  Insn &AppendCall(x64::X64MOP_t mOp, Operand &targetOpnd,
+      ListOperand &paramOpnds, ListOperand &retOpnds);
+  void SelectCalleeReturn(MIRType *retType, ListOperand &retOpnds);
+
+  /* Inline function implementation of va_start */
+  void GenCVaStartIntrin(RegOperand &opnd, uint32 stkSize);
+
+  /* Subclass private instruction selector function */
+  void SelectCVaStart(const IntrinsiccallNode &intrnNode);
+  void SelectParmList(StmtNode &naryNode, ListOperand &srcOpnds, uint32 &fpNum);
+  void SelectMpy(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType);
+  void SelectCmp(Operand &opnd0, Operand &opnd1, PrimType primType);
+  void SelectCmpResult(RegOperand &resOpnd, Opcode opCode, PrimType primType, PrimType primOpndType);
+  Operand *SelectDivRem(RegOperand &opnd0, RegOperand &opnd1, PrimType primType, Opcode opcode);
+  void SelectSelect(Operand &resOpnd, Operand &trueOpnd, Operand &falseOpnd, PrimType primType,
+                    Opcode cmpOpcode, PrimType cmpPrimType);
+  RegOperand &GetTargetStackPointer(PrimType primType) override;
+  RegOperand &GetTargetBasicPointer(PrimType primType) override;
+  std::tuple<Operand*, size_t, MIRType*> GetMemOpndInfoFromAggregateNode(BaseNode &argExpr);
+  void SelectParmListForAggregate(BaseNode &argExpr, X64CallConvImpl &parmLocator, bool isArgUnused);
+  void CreateCallStructParamPassByReg(MemOperand &memOpnd, regno_t regNo, uint32 parmNum);
+  void CreateCallStructParamPassByStack(MemOperand &addrOpnd, int32 symSize, int32 baseOffset);
+  void SelectAggCopyReturn(const MIRSymbol &symbol, MIRType &symbolType, uint64 symbolSize);
+  uint32 GetAggCopySize(uint32 offset1, uint32 offset2, uint32 alignment) const;
+  bool IsParamStructCopy(const MIRSymbol &symbol);
+  void SelectMinOrMax(bool isMin, Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  void SelectLibCallNoReturn(const std::string &funcName, std::vector<Operand*> &opndVec, PrimType primType);
+  void SelectLibCallNArg(const std::string &funcName, std::vector<Operand*> &opndVec,
+                         std::vector<PrimType> pt);
+  void SelectPseduoForReturn(std::vector<RegOperand*> &retRegs);
+  RegOperand *PrepareMemcpyParm(MemOperand &memOperand,  MOperator mOp);
+  RegOperand *PrepareMemcpyParm(uint64 copySize);
+
+  /* save param pass by reg */
+  std::vector<std::tuple<RegOperand*, Operand*, PrimType>> paramPassByReg;
+};
+}
+
+#endif  /* MAPLEBE_INCLUDE_X64_MPISEL_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_abi.h b/src/mapleall/maple_be/include/cg/x86_64/x64_abi.h
new file mode 100644
index 0000000000000000000000000000000000000000..252576216896bbabada6bd094b898619c07de156
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_abi.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_ABI_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_ABI_H
+
+#include "x64_isa.h"
+#include "types_def.h"
+#include "becommon.h"
+
+namespace maplebe {
+using namespace maple;
+
+namespace x64 {
+constexpr int32 kNumIntParmRegs = 6;
+constexpr int32 kNumIntReturnRegs = 2;
+constexpr int32 kNumFloatParmRegs = 8;
+constexpr int32 kNumFloatReturnRegs = 2;
+
+constexpr uint32 kNormalUseOperandNum = 2;
+constexpr uint32 kMaxInstrForCondBr = 260000;
+
+constexpr X64reg kIntParmRegs[kNumIntParmRegs] = { R7, R6, R3, R2, R8, R9 };
+constexpr X64reg kIntReturnRegs[kNumIntReturnRegs] = { R0, R3 };
+constexpr X64reg kFloatParmRegs[kNumFloatParmRegs] = { V0, V1, V2, V3, V4, V5, V6, V7 };
+constexpr X64reg kFloatReturnRegs[kNumFloatReturnRegs] = { V0, V1 };
+
+/*
+ * Refer to：
+ * x64-bit Architecture.
+ */
+bool IsAvailableReg(X64reg reg);
+bool IsCalleeSavedReg(X64reg reg);
+bool IsCallerSaveReg(X64reg reg);
+bool IsParamReg(X64reg reg);
+bool IsSpillReg(X64reg reg);
+bool IsExtraSpillReg(X64reg reg);
+bool IsSpillRegInRA(X64reg regNO, bool has3RegOpnd);
+PrimType IsVectorArrayType(MIRType *ty, uint32 &arraySize);
+}  /* namespace x64 */
+
+/*
+ * X64-bit Architecture.
+ * After the argument values have been computed, they are placed either in registers
+ * or pushed on the stack. The way how values are passed is described in the
+ * following sections.
+ *   - INTEGER This class consists of integral types that fit into one of the general
+       purpose registers.
+     - SSE The class consists of types that fit into a vector register.
+     - SSEUP The class consists of types that fit into a vector register and can be passed
+       and returned in the upper bytes of it.
+     - X87, X87UP These classes consists of types that will be returned via the x87 FPU.
+     - COMPLEX_X87 This class consists of types that will be returned via the x87 FPU.
+     - NO_CLASS This class is used as initializer in the algorithms. It will be used for
+       padding and empty structures and unions.
+     - MEMORY This class consists of types that will be passed and returned in memory via the stack.
+ *
+ */
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_X64_X64_ABI_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_abstract_mapping.def b/src/mapleall/maple_be/include/cg/x86_64/x64_abstract_mapping.def
new file mode 100644
index 0000000000000000000000000000000000000000..9aedec04365da76977bd80c9170dcd124b27667c
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_abstract_mapping.def
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+/* Mapping between abstract maple machine IR and machine operation code of X86_64*/
+/* {mmir, mop} */
+DEFINE_MAPPING(abstract::MOP_undef, x64::MOP_begin)
+
+/* Mov */
+DEFINE_MAPPING(abstract::MOP_copy_ri_8,   x64::MOP_movb_i_r)
+DEFINE_MAPPING(abstract::MOP_copy_ri_16,  x64::MOP_movw_i_r)
+DEFINE_MAPPING(abstract::MOP_copy_ri_32,  x64::MOP_movl_i_r)
+DEFINE_MAPPING(abstract::MOP_copy_ri_64,  x64::MOP_movq_i_r)
+DEFINE_MAPPING(abstract::MOP_copy_rr_8,   x64::MOP_movb_r_r)
+DEFINE_MAPPING(abstract::MOP_copy_rr_16,  x64::MOP_movw_r_r)
+DEFINE_MAPPING(abstract::MOP_copy_rr_32,  x64::MOP_movl_r_r)
+DEFINE_MAPPING(abstract::MOP_copy_rr_64,  x64::MOP_movq_r_r)
+DEFINE_MAPPING(abstract::MOP_copy_ff_32,  x64::MOP_movl_r_r)
+DEFINE_MAPPING(abstract::MOP_copy_ff_64, x64::MOP_movq_r_r)
+
+/* str/load */
+DEFINE_MAPPING(abstract::MOP_str_8,       x64::MOP_movb_r_m)
+DEFINE_MAPPING(abstract::MOP_str_16,      x64::MOP_movw_r_m)
+DEFINE_MAPPING(abstract::MOP_str_32,      x64::MOP_movl_r_m)
+DEFINE_MAPPING(abstract::MOP_str_64,      x64::MOP_movq_r_m)
+DEFINE_MAPPING(abstract::MOP_load_8,      x64::MOP_movb_m_r)
+DEFINE_MAPPING(abstract::MOP_load_16,     x64::MOP_movw_m_r)
+DEFINE_MAPPING(abstract::MOP_load_32,     x64::MOP_movl_m_r)
+DEFINE_MAPPING(abstract::MOP_load_64,     x64::MOP_movq_m_r)
+
+/* str/load floating point */
+DEFINE_MAPPING(abstract::MOP_str_f_64,    x64::MOP_movfd_r_m)
+DEFINE_MAPPING(abstract::MOP_load_f_64,   x64::MOP_movfd_m_r)
+DEFINE_MAPPING(abstract::MOP_str_f_32,    x64::MOP_movfs_r_m)
+DEFINE_MAPPING(abstract::MOP_load_f_32,   x64::MOP_movfs_m_r)
+
+/* shift -- shl/ashr/lshr */
+DEFINE_MAPPING(abstract::MOP_shl_8,       x64::MOP_shlb_r_r)
+DEFINE_MAPPING(abstract::MOP_shl_16,      x64::MOP_shlw_r_r)
+DEFINE_MAPPING(abstract::MOP_shl_32,      x64::MOP_shll_r_r)
+DEFINE_MAPPING(abstract::MOP_shl_64,      x64::MOP_shlq_r_r)
+DEFINE_MAPPING(abstract::MOP_ashr_8,      x64::MOP_sarb_r_r)
+DEFINE_MAPPING(abstract::MOP_ashr_16,     x64::MOP_sarw_r_r)
+DEFINE_MAPPING(abstract::MOP_ashr_32,     x64::MOP_sarl_r_r)
+DEFINE_MAPPING(abstract::MOP_ashr_64,     x64::MOP_sarq_r_r)
+DEFINE_MAPPING(abstract::MOP_lshr_8,      x64::MOP_shrb_r_r)
+DEFINE_MAPPING(abstract::MOP_lshr_16,     x64::MOP_shrw_r_r)
+DEFINE_MAPPING(abstract::MOP_lshr_32,     x64::MOP_shrl_r_r)
+DEFINE_MAPPING(abstract::MOP_lshr_64,     x64::MOP_shrq_r_r)
+
+/* BasicOp */
+DEFINE_MAPPING(abstract::MOP_and_8,       x64::MOP_andb_r_r)
+DEFINE_MAPPING(abstract::MOP_and_16,      x64::MOP_andw_r_r)
+DEFINE_MAPPING(abstract::MOP_and_32,      x64::MOP_andl_r_r)
+DEFINE_MAPPING(abstract::MOP_and_64,      x64::MOP_andq_r_r)
+DEFINE_MAPPING(abstract::MOP_or_8,        x64::MOP_orb_r_r)
+DEFINE_MAPPING(abstract::MOP_or_16,       x64::MOP_orw_r_r)
+DEFINE_MAPPING(abstract::MOP_or_32,       x64::MOP_orl_r_r)
+DEFINE_MAPPING(abstract::MOP_or_64,       x64::MOP_orq_r_r)
+DEFINE_MAPPING(abstract::MOP_xor_8,       x64::MOP_xorb_r_r)
+DEFINE_MAPPING(abstract::MOP_xor_16,      x64::MOP_xorw_r_r)
+DEFINE_MAPPING(abstract::MOP_xor_32,      x64::MOP_xorl_r_r)
+DEFINE_MAPPING(abstract::MOP_xor_64,      x64::MOP_xorq_r_r)
+DEFINE_MAPPING(abstract::MOP_add_8,       x64::MOP_addb_r_r)
+DEFINE_MAPPING(abstract::MOP_add_16,      x64::MOP_addw_r_r)
+DEFINE_MAPPING(abstract::MOP_add_32,      x64::MOP_addl_r_r)
+DEFINE_MAPPING(abstract::MOP_add_64,      x64::MOP_addq_r_r)
+DEFINE_MAPPING(abstract::MOP_sub_8,       x64::MOP_subb_r_r)
+DEFINE_MAPPING(abstract::MOP_sub_16,      x64::MOP_subw_r_r)
+DEFINE_MAPPING(abstract::MOP_sub_32,      x64::MOP_subl_r_r)
+DEFINE_MAPPING(abstract::MOP_sub_64,      x64::MOP_subq_r_r)
+DEFINE_MAPPING(abstract::MOP_add_f_32,    x64::MOP_adds_r_r)
+DEFINE_MAPPING(abstract::MOP_add_f_64,    x64::MOP_addd_r_r)
+DEFINE_MAPPING(abstract::MOP_sub_f_32,    x64::MOP_subs_r_r)
+DEFINE_MAPPING(abstract::MOP_sub_f_64,    x64::MOP_subd_r_r)
+/* UnaryOp */
+DEFINE_MAPPING(abstract::MOP_not_8,       x64::MOP_notb_r)
+DEFINE_MAPPING(abstract::MOP_not_16,      x64::MOP_notw_r)
+DEFINE_MAPPING(abstract::MOP_not_32,      x64::MOP_notl_r)
+DEFINE_MAPPING(abstract::MOP_not_64,      x64::MOP_notq_r)
+DEFINE_MAPPING(abstract::MOP_neg_8,       x64::MOP_negb_r)
+DEFINE_MAPPING(abstract::MOP_neg_16,      x64::MOP_negw_r)
+DEFINE_MAPPING(abstract::MOP_neg_32,      x64::MOP_negl_r)
+DEFINE_MAPPING(abstract::MOP_neg_64,      x64::MOP_negq_r)
+
+/* CvtOp */
+DEFINE_MAPPING(abstract::MOP_zext_rr_16_8,      x64::MOP_movzbw_r_r)
+DEFINE_MAPPING(abstract::MOP_sext_rr_16_8,      x64::MOP_movsbw_r_r)
+DEFINE_MAPPING(abstract::MOP_zext_rr_32_8,      x64::MOP_movzbl_r_r)
+DEFINE_MAPPING(abstract::MOP_sext_rr_32_8,      x64::MOP_movsbl_r_r)
+DEFINE_MAPPING(abstract::MOP_zext_rr_32_16,     x64::MOP_movzwl_r_r)
+DEFINE_MAPPING(abstract::MOP_sext_rr_32_16,     x64::MOP_movswl_r_r)
+DEFINE_MAPPING(abstract::MOP_zext_rr_64_8,      x64::MOP_movzbl_r_r)
+DEFINE_MAPPING(abstract::MOP_sext_rr_64_8,      x64::MOP_movsbq_r_r)
+DEFINE_MAPPING(abstract::MOP_zext_rr_64_16,     x64::MOP_movzwl_r_r)
+DEFINE_MAPPING(abstract::MOP_sext_rr_64_16,     x64::MOP_movswq_r_r)
+DEFINE_MAPPING(abstract::MOP_zext_rr_64_32,     x64::MOP_movl_r_r)
+DEFINE_MAPPING(abstract::MOP_sext_rr_64_32,     x64::MOP_movslq_r_r)
+DEFINE_MAPPING(abstract::MOP_sext_rr_64_32,     x64::MOP_movslq_r_r)
+
+/* Floating CvtOp int2float */
+DEFINE_MAPPING(abstract::MOP_cvt_fr_u64,    x64::MOP_cvtsi2sdq_r)
+DEFINE_MAPPING(abstract::MOP_cvt_fr_u32,    x64::MOP_cvtsi2ssq_r)
+DEFINE_MAPPING(abstract::MOP_cvt_fr_i32,    x64::MOP_cvtsi2ssl_r)
+DEFINE_MAPPING(abstract::MOP_cvt_fr_i64,    x64::MOP_cvtsi2sdq_r)
+
+/* Floating CvtOp float2int */
+DEFINE_MAPPING(abstract::MOP_cvt_rf_u32,    x64::MOP_cvttss2siq_r)
+DEFINE_MAPPING(abstract::MOP_cvt_rf_u64,    x64::MOP_cvttsd2siq_r)
+DEFINE_MAPPING(abstract::MOP_cvt_rf_i32,    x64::MOP_cvttss2sil_r)
+DEFINE_MAPPING(abstract::MOP_cvt_rf_i64,    x64::MOP_cvttsd2siq_r)
+
+/* Floating CvtOp float2float */
+DEFINE_MAPPING(abstract::MOP_cvt_ff_64_32,   x64::MOP_cvtss2sd_r)
+DEFINE_MAPPING(abstract::MOP_cvt_ff_32_64,   x64::MOP_cvtsd2ss_r)
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_args.h b/src/mapleall/maple_be/include/cg/x86_64/x64_args.h
new file mode 100644
index 0000000000000000000000000000000000000000..773750d08e6100a1d00895508c32aa88aaf1535b
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_args.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_ARGS_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_ARGS_H
+
+#include "args.h"
+#include "x64_isa.h"
+#include "x64_cgfunc.h"
+#include "x64_call_conv.h"
+
+namespace maplebe {
+using namespace maple;
+using namespace x64;
+
+struct ArgInfo {
+  X64reg reg;
+  MIRType *mirTy;
+  uint32 symSize;
+  uint32 stkSize;
+  RegType regType;
+  MIRSymbol *sym;
+  const X64SymbolAlloc *symLoc;
+  uint8 memPairSecondRegSize;  /* struct arg requiring two regs, size of 2nd reg */
+  bool doMemPairOpt;
+  bool createTwoStores;
+  bool isTwoRegParm;
+};
+
+class X64MoveRegArgs : public MoveRegArgs {
+ public:
+  explicit X64MoveRegArgs(CGFunc &func) : MoveRegArgs(func) {}
+  ~X64MoveRegArgs() override = default;
+  void Run() override;
+
+ private:
+  void CollectRegisterArgs(std::map<uint32, X64reg> &argsList, std::vector<uint32> &indexList,
+                           std::map<uint32, X64reg> &pairReg, std::vector<uint32> &numFpRegs,
+                           std::vector<uint32> &fpSize) const;
+  ArgInfo GetArgInfo(std::map<uint32, X64reg> &argsList, uint32 argIndex,
+      std::vector<uint32> &numFpRegs, std::vector<uint32> &fpSize) const;
+  void GenerateMovInsn(ArgInfo &argInfo, X64reg reg2);
+  void MoveRegisterArgs();
+  void MoveVRegisterArgs();
+  void LoadStackArgsToVReg(MIRSymbol &mirSym);
+  void MoveArgsToVReg(const CCLocInfo &ploc, MIRSymbol &mirSym);
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_X64_X64_ARGS_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_call_conv.h b/src/mapleall/maple_be/include/cg/x86_64/x64_call_conv.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f6c8049e461efd93f47e7aa806a7c0d0fc6a7e9
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_call_conv.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_CALL_CONV_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_CALL_CONV_H
+
+#include "types_def.h"
+#include "becommon.h"
+#include "call_conv.h"
+#include "abi.h"
+#include "x64_abi.h"
+
+namespace maplebe {
+using namespace maple;
+using namespace x64;
+
+constexpr const uint32 kMaxStructParamByReg = 4;
+
+class X64CallConvImpl {
+ public:
+  explicit X64CallConvImpl(BECommon &be) : beCommon(be) {}
+
+  ~X64CallConvImpl() = default;
+
+  void InitCCLocInfo(CCLocInfo &pLoc) const;
+
+  /* Passing  value related */
+  int32 LocateNextParm(MIRType &mirType, CCLocInfo &pLoc, bool isFirst = false, MIRFunction *func = nullptr);
+
+  /*  return value related  */
+  int32 LocateRetVal(MIRType &retType, CCLocInfo &ploc);
+
+ private:
+  X64reg AllocateGPParmRegister() {
+    return (nextGeneralParmRegNO < kNumIntParmRegs) ?
+        kIntParmRegs[nextGeneralParmRegNO++] : kRinvalid;
+  }
+
+  void AllocateTwoGPParmRegisters(CCLocInfo &pLoc) {
+    if ((nextGeneralParmRegNO + 1) < kNumIntParmRegs) {
+      pLoc.reg0 = kIntParmRegs[nextGeneralParmRegNO++];
+      pLoc.reg1 = kIntParmRegs[nextGeneralParmRegNO++];
+    } else {
+      pLoc.reg0 = kRinvalid;
+    }
+  }
+
+  X64reg AllocateSIMDFPRegister() {
+    return (nextFloatRegNO < kNumFloatParmRegs) ?
+        kFloatParmRegs[nextFloatRegNO++] : kRinvalid;
+  }
+
+  X64reg AllocateGPReturnRegister() {
+    return (nextGeneralReturnRegNO < kNumIntReturnRegs) ?
+        kIntReturnRegs[nextGeneralReturnRegNO++] : kRinvalid;
+  }
+
+  void AllocateTwoGPReturnRegisters(CCLocInfo &pLoc) {
+    if ((nextGeneralReturnRegNO + 1) < kNumIntReturnRegs) {
+      pLoc.reg0 = kIntReturnRegs[nextGeneralReturnRegNO++];
+      pLoc.reg1 = kIntReturnRegs[nextGeneralReturnRegNO++];
+    } else {
+      pLoc.reg0 = kRinvalid;
+    }
+  }
+
+  BECommon &beCommon;
+  uint64 paramNum = 0;  /* number of all types of parameters processed so far */
+  int32 nextGeneralParmRegNO = 0;  /* number of integer parameters processed so far */
+  int32 nextGeneralReturnRegNO = 0;  /* number of integer return processed so far */
+  int32 nextStackArgAdress = 0;
+  uint32 nextFloatRegNO = 0;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_X64_X64_CALL_CONV_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_cfgo.h b/src/mapleall/maple_be/include/cg/x86_64/x64_cfgo.h
new file mode 100644
index 0000000000000000000000000000000000000000..78aba629f8db858f2edb25944a475b82266a716e
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_cfgo.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_CFGO_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_CFGO_H
+
+#include "cfgo.h"
+
+namespace maplebe {
+class X64CFGOptimizer : public CFGOptimizer {
+ public:
+  X64CFGOptimizer(CGFunc &func, MemPool &memPool) : CFGOptimizer(func, memPool) {}
+  ~X64CFGOptimizer() = default;
+  void InitOptimizePatterns() override;
+};
+
+class X64FlipBRPattern : public FlipBRPattern {
+ public:
+  explicit X64FlipBRPattern(CGFunc &func) : FlipBRPattern(func) {}
+  ~X64FlipBRPattern() = default;
+
+ private:
+  uint32 GetJumpTargetIdx(const Insn &insn) override;
+  MOperator FlipConditionOp(MOperator flippedOp) override;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_X64_X64_CFGO_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_cg.h b/src/mapleall/maple_be/include/cg/x86_64/x64_cg.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e49c9a12db8504bf3497296e41b9a57c91aa95b
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_cg.h
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/* sub Target info & implement */
+#ifndef MAPLEBE_INCLUDE_CG_X86_64_CG_H
+#define MAPLEBE_INCLUDE_CG_X86_64_CG_H
+
+#include "cg.h"
+#include "x64_reg_info.h"
+#include "x64_live.h"
+#include "x64_reaching.h"
+#include "x64_MPISel.h"
+#include "x64_standardize.h"
+#include "x64_args.h"
+#include "x64_local_opt.h"
+#include "x64_cfgo.h"
+
+namespace maplebe {
+constexpr int32 kIntRegTypeNum = 5;
+
+class X64CG : public CG {
+ public:
+  X64CG(MIRModule &mod, const CGOptions &opts) : CG(mod, opts) {}
+
+  static const InsnDesc kMd[x64::kMopLast];
+  void EnrollTargetPhases(MaplePhaseManager *pm) const override;
+
+  MemLayout *CreateMemLayout(MemPool &mp, BECommon &b,
+      MIRFunction &f, MapleAllocator &mallocator) const override {
+    return mp.New<X64MemLayout>(b, f, mallocator);
+  };
+
+  RegisterInfo *CreateRegisterInfo(MemPool &mp, MapleAllocator &mallocator) const override {
+    return mp.New<X64RegInfo>(mallocator);
+  }
+
+  LiveAnalysis *CreateLiveAnalysis(MemPool &mp, CGFunc &f) const override {
+    return mp.New<X64LiveAnalysis>(f, mp);
+  }
+  ReachingDefinition *CreateReachingDefinition(MemPool &mp, CGFunc &f) const override {
+    return mp.New<X64ReachingDefinition>(f, mp);
+  }
+  LocalOpt *CreateLocalOpt(MemPool &mp, CGFunc &f, ReachingDefinition& rd) const override {
+    return mp.New<X64LocalOpt>(mp, f, rd);
+  }
+  MoveRegArgs *CreateMoveRegArgs(MemPool &mp, CGFunc &f) const override {
+    return mp.New<X64MoveRegArgs>(f);
+  }
+
+  MPISel *CreateMPIsel(MemPool &mp, CGFunc &f) const override {
+    return mp.New<X64MPIsel>(mp, f);
+  }
+
+  Standardize *CreateStandardize(MemPool &mp, CGFunc &f) const override {
+    return mp.New<X64Standardize>(f);
+  }
+
+  CFGOptimizer *CreateCFGOptimizer(MemPool &mp, CGFunc &f) const override {
+    return mp.New<X64CFGOptimizer>(f, mp);
+  }
+
+  /* Init SubTarget optimization */
+
+  Insn &BuildPhiInsn(RegOperand &defOpnd, Operand &listParam) override;
+
+  PhiOperand &CreatePhiOperand(MemPool &mp, MapleAllocator &mAllocator) override;
+
+  CGFunc *CreateCGFunc(MIRModule &mod, MIRFunction &mirFunc, BECommon &bec, MemPool &memPool,
+      StackMemPool &stackMp, MapleAllocator &mallocator, uint32 funcId) override;
+
+  bool IsExclusiveFunc(MIRFunction &mirFunc) override;
+
+  /* NOTE: Consider making be_common a field of CG. */
+  void GenerateObjectMaps(BECommon &beCommon) override;
+
+  AlignAnalysis *CreateAlignAnalysis(MemPool &mp, CGFunc &f) const override {
+    (void)mp;
+    (void)f;
+    return nullptr;
+  }
+  /* Init SubTarget optimization */
+  CGSSAInfo *CreateCGSSAInfo(MemPool &mp, CGFunc &f, DomAnalysis &da, MemPool &tmp) const override {
+    (void)mp;
+    (void)f;
+    (void)da;
+    (void)tmp;
+    return nullptr;
+  }
+  LiveIntervalAnalysis *CreateLLAnalysis(MemPool &mp, CGFunc &f) const override {
+    (void)mp;
+    (void)f;
+    return nullptr;
+  };
+  PhiEliminate *CreatePhiElimintor(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const override {
+    (void)mp;
+    (void)f;
+    (void)ssaInfo;
+    return nullptr;
+  };
+  CGProp *CreateCGProp(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo, LiveIntervalAnalysis &ll) const override {
+    (void)mp;
+    (void)f;
+    (void)ssaInfo;
+    (void)ll;
+    return nullptr;
+  }
+  CGDce *CreateCGDce(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const override {
+    (void)mp;
+    (void)f;
+    (void)ssaInfo;
+    return nullptr;
+  }
+  ValidBitOpt *CreateValidBitOpt(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const override {
+    (void)mp;
+    (void)f;
+    (void)ssaInfo;
+    return nullptr;
+  }
+  RedundantComputeElim *CreateRedundantCompElim(MemPool &mp, CGFunc &f, CGSSAInfo &ssaInfo) const override {
+    (void)mp;
+    (void)f;
+    (void)ssaInfo;
+    return nullptr;
+  }
+  TailCallOpt *CreateCGTailCallOpt(MemPool &mp, CGFunc &f) const override {
+    (void)mp;
+    (void)f;
+    return nullptr;
+  }
+
+  /* Used for GCTIB pattern merging */
+  std::string FindGCTIBPatternName(const std::string &name) const override;
+  static std::array<std::array<const std::string, x64::kAllRegNum>, kIntRegTypeNum> intRegNames;
+  enum : uint8 {
+    kR8LowList,
+    kR8HighList,
+    kR16List,
+    kR32List,
+    kR64List
+  };
+  bool IsEffectiveCopy(Insn &insn) const final;
+  bool IsTargetInsn(MOperator mOp) const final;
+  bool IsClinitInsn(MOperator mOp) const final;
+  void DumpTargetOperand(Operand &opnd, const OpndDesc &opndDesc) const final;
+  const InsnDesc &GetTargetMd(MOperator mOp) const final {
+    return kMd[mOp];
+  }
+};
+}  // namespace maplebe
+#endif /* MAPLEBE_INCLUDE_CG_X86_64_CG_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_cgfunc.h b/src/mapleall/maple_be/include/cg/x86_64/x64_cgfunc.h
new file mode 100644
index 0000000000000000000000000000000000000000..7bc55508ab51a93baf1623cefd7b44db852201c9
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_cgfunc.h
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X86_64_CGFUNC_H
+#define MAPLEBE_INCLUDE_CG_X86_64_CGFUNC_H
+
+#include "cgfunc.h"
+#include "x64_memlayout.h"
+#include "x64_isa.h"
+#include "x64_reg_info.h"
+#include "x64_optimize_common.h"
+
+namespace maplebe {
+class X64CGFunc : public CGFunc {
+ public:
+  X64CGFunc(MIRModule &mod, CG &c, MIRFunction &f, BECommon &b,
+      MemPool &memPool, StackMemPool &stackMp, MapleAllocator &mallocator, uint32 funcId)
+      : CGFunc(mod, c, f, b, memPool, stackMp, mallocator, funcId),
+        calleeSavedRegs(mallocator.Adapter()) { }
+  /* null implementation yet */
+  InsnVisitor *NewInsnModifier() override {
+    return memPool->New<X64InsnVisitor>(*this);
+  }
+  void GenSaveMethodInfoCode(BB &bb) override;
+  void GenerateCleanupCode(BB &bb) override;
+  bool NeedCleanup() override;
+  void GenerateCleanupCodeForExtEpilog(BB &bb) override;
+  uint32 FloatParamRegRequired(MIRStructType *structType, uint32 &fpSize) override;
+  void AssignLmbcFormalParams() override;
+  void LmbcGenSaveSpForAlloca() override;
+  void MergeReturn() override;
+  void DetermineReturnTypeofCall() override;
+  void HandleRCCall(bool begin, const MIRSymbol *retRef = nullptr) override;
+  void HandleRetCleanup(NaryStmtNode &retNode) override;
+  void SelectDassign(DassignNode &stmt, Operand &opnd0) override;
+  void SelectDassignoff(DassignoffNode &stmt, Operand &opnd0) override;
+  void SelectRegassign(RegassignNode &stmt, Operand &opnd0) override;
+  void SelectAbort() override;
+  void SelectAssertNull(UnaryStmtNode &stmt) override;
+  void SelectAsm(AsmNode &node) override;
+  void SelectAggDassign(DassignNode &stmt) override;
+  void SelectIassign(IassignNode &stmt) override;
+  void SelectIassignoff(IassignoffNode &stmt) override;
+  void SelectIassignfpoff(IassignFPoffNode &stmt, Operand &opnd) override;
+  void SelectIassignspoff(PrimType pTy, int32 offset, Operand &opnd) override;
+  void SelectBlkassignoff(BlkassignoffNode &bNode, Operand *src) override;
+  void SelectAggIassign(IassignNode &stmt, Operand &lhsAddrOpnd) override;
+  void SelectReturnSendOfStructInRegs(BaseNode *x) override;
+  void SelectReturn(Operand *opnd) override;
+  void SelectIgoto(Operand *opnd0) override;
+  void SelectCondGoto(CondGotoNode &stmt, Operand &opnd0, Operand &opnd1) override;
+  void SelectCondSpecialCase1(CondGotoNode &stmt, BaseNode &opnd0) override;
+  void SelectCondSpecialCase2(const CondGotoNode &stmt, BaseNode &opnd0) override;
+  void SelectGoto(GotoNode &stmt) override;
+  void SelectCall(CallNode &callNode) override;
+  void SelectIcall(IcallNode &icallNode, Operand &fptrOpnd) override;
+  void SelectIntrinCall(IntrinsiccallNode &intrinsiccallNode) override;
+  Operand *SelectIntrinsicOpWithOneParam(IntrinsicopNode &intrinopNode, std::string name) override;
+  Operand *SelectCclz(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCctz(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCpopcount(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCparity(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCclrsb(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCisaligned(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCalignup(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCaligndown(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCSyncFetch(IntrinsicopNode &intrinsicopNode, Opcode op, bool fetchBefore) override;
+  Operand *SelectCSyncSynchronize(IntrinsicopNode &intrinsicopNode) override;
+  Operand *SelectCAtomicLoadN(IntrinsicopNode &intrinsicopNode) override;
+  Operand *SelectCAtomicExchangeN(const IntrinsiccallNode &intrinsiccallNode) override;
+  Operand *SelectCAtomicFetch(IntrinsicopNode &intrinsicopNode, Opcode op, bool fetchBefore) override;
+  Operand *SelectCSyncBoolCmpSwap(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCSyncValCmpSwap(IntrinsicopNode &intrinopNode) override;
+  Operand *SelectCSyncLockTestSet(IntrinsicopNode &intrinopNode, PrimType pty) override;
+  Operand *SelectCReturnAddress(IntrinsicopNode &intrinopNode) override;
+  void SelectCAtomicExchange(const IntrinsiccallNode &intrinsiccallNode) override;
+  void SelectMembar(StmtNode &membar) override;
+  void SelectComment(CommentNode &comment) override;
+  void HandleCatch() override;
+  Operand *SelectDread(const BaseNode &parent, AddrofNode &expr) override;
+  RegOperand *SelectRegread(RegreadNode &expr) override;
+  Operand *SelectAddrof(AddrofNode &expr, const BaseNode &parent, bool isAddrofoff) override;
+  Operand *SelectAddrofoff(AddrofoffNode &expr, const BaseNode &parent) override;
+  Operand &SelectAddrofFunc(AddroffuncNode &expr, const BaseNode &parent) override;
+  Operand &SelectAddrofLabel(AddroflabelNode &expr, const BaseNode &parent) override;
+  Operand *SelectIread(const BaseNode &parent, IreadNode &expr, int extraOffset = 0,
+      PrimType finalBitFieldDestType = kPtyInvalid) override;
+  Operand *SelectIreadoff(const BaseNode &parent, IreadoffNode &ireadoff) override;
+  Operand *SelectIreadfpoff(const BaseNode &parent, IreadFPoffNode &ireadoff) override;
+  Operand *SelectIntConst(MIRIntConst &intConst) override;
+  Operand *SelectFloatConst(MIRFloatConst &floatConst, const BaseNode &parent) override;
+  Operand *SelectDoubleConst(MIRDoubleConst &doubleConst, const BaseNode &parent) override;
+  Operand *SelectStrConst(MIRStrConst &strConst) override;
+  Operand *SelectStr16Const(MIRStr16Const &strConst) override;
+  void SelectAdd(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectAdd(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectMadd(Operand &resOpnd, Operand &opndM0, Operand &opndM1, Operand &opnd1, PrimType primType) override;
+  Operand *SelectMadd(BinaryNode &node, Operand &opndM0, Operand &opndM1, Operand &opnd1,
+      const BaseNode &parent) override;
+  Operand *SelectRor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand &SelectCGArrayElemAdd(BinaryNode &node, const BaseNode &parent) override;
+  Operand *SelectShift(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectMpy(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectMpy(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectDiv(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectDiv(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectSub(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectSub(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectBand(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectBand(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectLand(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectLor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent,
+      bool parentIsBr = false) override;
+  void SelectMin(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectMin(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectMax(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectMax(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectCmpOp(CompareNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectBior(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectBior(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectBxor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  void SelectBxor(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
+  Operand *SelectAbs(UnaryNode &node, Operand &opnd0) override;
+  Operand *SelectBnot(UnaryNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectExtractbits(ExtractbitsNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectDepositBits(DepositbitsNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) override;
+  Operand *SelectRegularBitFieldLoad(ExtractbitsNode &node, const BaseNode &parent) override;
+  Operand *SelectLnot(UnaryNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectNeg(UnaryNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectRecip(UnaryNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectSqrt(UnaryNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectCeil(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectFloor(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectRetype(TypeCvtNode &node, Operand &opnd0) override;
+  Operand *SelectRound(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectCvt(const BaseNode &parent, TypeCvtNode &node, Operand &opnd0) override;
+  Operand *SelectBswap(IntrinsicopNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectTrunc(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) override;
+  Operand *SelectSelect(TernaryNode &node, Operand &cond, Operand &opnd0, Operand &opnd1,
+      const BaseNode &parent, bool hasCompare = false) override;
+  Operand *SelectMalloc(UnaryNode &call, Operand &opnd0) override;
+  RegOperand &SelectCopy(Operand &src, PrimType srcType, PrimType dstType) override;
+  Operand *SelectAlloca(UnaryNode &call, Operand &opnd0) override;
+  Operand *SelectGCMalloc(GCMallocNode &call) override;
+  Operand *SelectJarrayMalloc(JarrayMallocNode &call, Operand &opnd0) override;
+  void SelectRangeGoto(RangeGotoNode &rangeGotoNode, Operand &opnd0) override;
+  Operand *SelectLazyLoad(Operand &opnd0, PrimType primType) override;
+  Operand *SelectLazyLoadStatic(MIRSymbol &st, int64 offset, PrimType primType) override;
+  Operand *SelectLoadArrayClassCache(MIRSymbol &st, int64 offset, PrimType primType) override;
+  void GenerateYieldpoint(BB &bb) override;
+  Operand &ProcessReturnReg(PrimType primType, int32 sReg) override;
+  Operand &GetOrCreateRflag() override;
+  const Operand *GetRflag() const override;
+  const Operand *GetFloatRflag() const override;
+  const LabelOperand *GetLabelOperand(LabelIdx labIdx) const override;
+  LabelOperand &GetOrCreateLabelOperand(LabelIdx labIdx) override;
+  LabelOperand &GetOrCreateLabelOperand(BB &bb) override;
+  RegOperand &CreateVirtualRegisterOperand(regno_t vRegNO) override;
+  RegOperand &GetOrCreateVirtualRegisterOperand(regno_t vRegNO) override;
+  RegOperand &GetOrCreateVirtualRegisterOperand(RegOperand &regOpnd) override;
+  RegOperand &GetOrCreateFramePointerRegOperand() override;
+  RegOperand &GetOrCreateStackBaseRegOperand() override;
+  RegOperand &GetZeroOpnd(uint32 size) override;
+  Operand &CreateCfiRegOperand(uint32 reg, uint32 size) override;
+  Operand &GetTargetRetOperand(PrimType primType, int32 sReg) override;
+  Operand &CreateImmOperand(PrimType primType, int64 val) override;
+  void ReplaceOpndInInsn(RegOperand &regDest, RegOperand &regSrc, Insn &insn, regno_t regno) override;
+  void CleanupDeadMov(bool dump = false) override;
+  void GetRealCallerSaveRegs(const Insn &insn, std::set<regno_t> &realCallerSave) override;
+  bool IsFrameReg(const RegOperand &opnd) const override;
+  RegOperand *SelectVectorAddLong(PrimType rTy, Operand *o1, Operand *o2, PrimType oty, bool isLow) override;
+  RegOperand *SelectVectorAddWiden(Operand *o1, PrimType oty1, Operand *o2, PrimType oty2, bool isLow) override;
+  RegOperand *SelectVectorAbs(PrimType rType, Operand *o1) override;
+  RegOperand *SelectVectorBinOp(PrimType rType, Operand *o1, PrimType oTyp1, Operand *o2,
+      PrimType oTyp2, Opcode opc) override;
+  RegOperand *SelectVectorBitwiseOp(PrimType rType, Operand *o1, PrimType oty1, Operand *o2,
+      PrimType oty2, Opcode opc) override;;
+  RegOperand *SelectVectorCompareZero(Operand *o1, PrimType oty1, Operand *o2, Opcode opc) override;
+  RegOperand *SelectVectorCompare(Operand *o1, PrimType oty1,  Operand *o2, PrimType oty2, Opcode opc) override;
+  RegOperand *SelectVectorFromScalar(PrimType pType, Operand *opnd, PrimType sType) override;
+  RegOperand *SelectVectorDup(PrimType rType, Operand *src, bool getLow) override;
+  RegOperand *SelectVectorGetElement(PrimType rType, Operand *src, PrimType sType, int32 lane) override;
+  RegOperand *SelectVectorAbsSubL(PrimType rType, Operand *o1, Operand *o2, PrimType oTy, bool isLow) override;
+  RegOperand *SelectVectorMadd(Operand *o1, PrimType oTyp1, Operand *o2, PrimType oTyp2, Operand *o3,
+      PrimType oTyp3) override;
+  RegOperand *SelectVectorMerge(PrimType rTyp, Operand *o1, Operand *o2, int32 iNum) override;
+  RegOperand *SelectVectorMull(PrimType rType, Operand *o1, PrimType oTyp1, Operand *o2, PrimType oTyp2,
+      bool isLow) override;
+  RegOperand *SelectVectorNarrow(PrimType rType, Operand *o1, PrimType otyp) override;
+  RegOperand *SelectVectorNarrow2(PrimType rType, Operand *o1, PrimType oty1, Operand *o2, PrimType oty2) override;
+  RegOperand *SelectVectorNeg(PrimType rType, Operand *o1) override;
+  RegOperand *SelectVectorNot(PrimType rType, Operand *o1) override;
+  RegOperand *SelectVectorPairwiseAdalp(Operand *src1, PrimType sty1, Operand *src2, PrimType sty2) override;
+  RegOperand *SelectVectorPairwiseAdd(PrimType rType, Operand *src, PrimType sType) override;
+  RegOperand *SelectVectorReverse(PrimType rtype, Operand *src, PrimType stype, uint32 size) override;
+  RegOperand *SelectVectorSetElement(Operand *eOp, PrimType eTyp, Operand *vOpd, PrimType vTyp,
+      int32 lane) override;
+  RegOperand *SelectVectorShift(PrimType rType, Operand *o1, PrimType oty1, Operand *o2, PrimType oty2,
+      Opcode opc) override;
+  RegOperand *SelectVectorShiftImm(PrimType rType, Operand *o1, Operand *imm, int32 sVal, Opcode opc) override;
+  RegOperand *SelectVectorShiftRNarrow(PrimType rType, Operand *o1, PrimType oType, Operand *o2, bool isLow) override;
+  RegOperand *SelectVectorSubWiden(PrimType resType, Operand *o1, PrimType otyp1, Operand *o2, PrimType otyp2,
+      bool isLow, bool isWide) override;
+  RegOperand *SelectVectorSum(PrimType rtype, Operand *o1, PrimType oType) override;
+  RegOperand *SelectVectorTableLookup(PrimType rType, Operand *o1, Operand *o2) override;
+  RegOperand *SelectVectorWiden(PrimType rType, Operand *o1, PrimType otyp, bool isLow) override;
+  RegOperand *SelectVectorMovNarrow(PrimType rType, Operand *opnd, PrimType oType) override;
+  Operand *SelectIntrinsicOpWithNParams(IntrinsicopNode &intrinopNode, PrimType retType,
+                                        const std::string &name) override;
+  void ProcessLazyBinding() override;
+  void DBGFixCallFrameLocationOffsets() override;
+  MemOperand *GetPseudoRegisterSpillMemoryOperand(PregIdx idx) override;
+
+  RegOperand *GetBaseReg(const SymbolAlloc &symAlloc) override;
+  int32 GetBaseOffset(const SymbolAlloc &symbolAlloc) override;
+
+  void AddtoCalleeSaved(regno_t reg) override {
+    const auto &[_, flag] = calleeSavedRegs.insert(static_cast<x64::X64reg>(reg));
+    ASSERT((IsGPRegister(static_cast<x64::X64reg>(reg)) ||
+        IsFPSIMDRegister(static_cast<x64::X64reg>(reg))), "Int or FP registers are expected");
+    if (flag) {
+      if (IsGPRegister(static_cast<x64::X64reg>(reg))) {
+        ++numIntregToCalleeSave;
+      } else {
+        ++numFpregToCalleeSave;
+      }
+    }
+  }
+
+  const MapleSet<x64::X64reg> &GetCalleeSavedRegs() const {
+    return calleeSavedRegs;
+  }
+
+  uint32 SizeOfCalleeSaved() const {
+    uint32 size = numIntregToCalleeSave * kIntregBytelen + numFpregToCalleeSave * kFpregBytelen;
+    return RoundUp(size, GetMemlayout()->GetStackPtrAlignment());
+  }
+
+  bool IsSPOrFP(const RegOperand &opnd) const override {
+    (void)opnd;
+    return false;
+  };
+  bool IsReturnReg(const RegOperand &opnd) const override {
+    (void)opnd;
+    return false;
+  }
+  bool IsSaveReg(const RegOperand &reg, MIRType &mirType, BECommon &cgBeCommon) const override {
+    (void)reg;
+    (void)mirType;
+    (void)cgBeCommon;
+    return false;
+  };
+
+  MemOperand *GetOrCreatSpillMem(regno_t vrNum) override;
+  void FreeSpillRegMem(regno_t vrNum) override;
+  int64 GetOrCreatSpillRegLocation(regno_t vrNum) {
+    auto symLoc = GetMemlayout()->GetLocOfSpillRegister(vrNum);
+    return static_cast<int64>(GetBaseOffset(*symLoc));
+  }
+ private:
+  MapleSet<x64::X64reg> calleeSavedRegs;
+  uint32 numIntregToCalleeSave = 0;
+  uint32 numFpregToCalleeSave = 0;
+};
+
+class X64OpndDumpVisitor : public OpndDumpVisitor {
+ public:
+  explicit X64OpndDumpVisitor(const OpndDesc &operandDesc) : OpndDumpVisitor(operandDesc) {};
+  ~X64OpndDumpVisitor() override = default;
+
+ private:
+  void Visit(RegOperand *v) final;
+  void Visit(ImmOperand *v) final;
+  void Visit(MemOperand *v) final;
+  void Visit(ListOperand *v) final;
+  void Visit(CondOperand *v) final;
+  void Visit(CommentOperand *v) final;
+  void Visit(StImmOperand *v) final;
+  void Visit(BitShiftOperand *v) final;
+  void Visit(ExtendShiftOperand *v) final;
+  void Visit(LabelOperand *v) final;
+  void Visit(FuncNameOperand *v) final;
+  void Visit(PhiOperand *v) final;
+  void DumpRegInfo(RegOperand &v);
+};
+} /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_X86_64_CGFUNC_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_emitter.h b/src/mapleall/maple_be/include/cg/x86_64/x64_emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..4970611d8f8fa893847d0106ac2c6d0771319510
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_emitter.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X86_64_EMITTER_H
+#define MAPLEBE_INCLUDE_CG_X86_64_EMITTER_H
+
+#include "asm_emit.h"
+#include "visitor_common.h"
+#include "operand.h"
+
+namespace maplebe {
+
+class X64Emitter : public AsmEmitter {
+ public:
+  X64Emitter(CG &cg, const std::string &asmFileName) : AsmEmitter(cg, asmFileName) {}
+  ~X64Emitter() = default;
+
+  void EmitRefToMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) override;
+  void EmitRefToMethodInfo(FuncEmitInfo &funcEmitInfo, Emitter &emitter) override;
+  void EmitMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) override;
+  void EmitFastLSDA(FuncEmitInfo &funcEmitInfo) override;
+  void EmitFullLSDA(FuncEmitInfo &funcEmitInfo) override;
+  void EmitBBHeaderLabel(FuncEmitInfo &funcEmitInfo, const std::string &name, LabelIdx labIdx) override;
+  void EmitJavaInsnAddr(FuncEmitInfo &funcEmitInfo) override;
+  void Run(FuncEmitInfo &funcEmitInfo) override;
+};
+
+class X64OpndEmitVisitor : public OpndEmitVisitor {
+ public:
+  X64OpndEmitVisitor(Emitter &emitter) : OpndEmitVisitor(emitter) {}
+  ~X64OpndEmitVisitor() override = default;
+
+  void Visit(RegOperand *v) final;
+  void Visit(ImmOperand *v) final;
+  void Visit(MemOperand *v) final;
+  void Visit(FuncNameOperand *v) final;
+  void Visit(LabelOperand *v) final;
+  void Visit(ListOperand *v) final;
+  void Visit(StImmOperand *v) final;
+  void Visit(CondOperand *v) final;
+  void Visit(BitShiftOperand *v) final;
+  void Visit(ExtendShiftOperand *v) final;
+  void Visit(CommentOperand *v) final;
+  void Visit(OfstOperand *v) final;
+};
+
+}  /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_X86_64_EMITTER_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_fp_simd_regs.def b/src/mapleall/maple_be/include/cg/x86_64/x64_fp_simd_regs.def
new file mode 100644
index 0000000000000000000000000000000000000000..7c4dafda4ac80fec5f9967d03eae1ab7256ebeec
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_fp_simd_regs.def
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/*
+ * - %xmm0–%xmm1 used to pass and return floating point arguments
+   - %xmm2–%xmm7 used to pass floating point arguments
+ *
+ */
+
+/*
+ * ID, prefixes: 8-bit, 16-bit, 32-bit, 64-bit, 128-bit, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill
+ */
+/*XMM0 ~ XMM15*/
+FP_SIMD_REG(0 , "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(1 , "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(2 , "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(3 , "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(4 , "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(5 , "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(6 , "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(7 , "B", "H", "S", "D", "Q", true, false, true, false, false)
+FP_SIMD_REG(8 , "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(9 , "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(10, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(11, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(12, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(13, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(14, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(15, "B", "H", "S", "D", "Q", true, false, false, false, false)
+/*ST0 ~ ST7*/
+FP_SIMD_REG(16, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(17, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(18, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(19, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(20, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(21, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(22, "B", "H", "S", "D", "Q", true, false, false, false, false)
+FP_SIMD_REG(23, "B", "H", "S", "D", "Q", true, false, false, false, false)
\ No newline at end of file
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_int_regs.def b/src/mapleall/maple_be/include/cg/x86_64/x64_int_regs.def
new file mode 100644
index 0000000000000000000000000000000000000000..10426073d7c4daf8338c6b0e21bb56f118fde866
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_int_regs.def
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/*
+ * Registers in x86-64
+ *
+ * - caller-save registers: %rax, %rcx, %rdx, %rdi, %rsi, %rsp, and %r8-r11
+ * - callee-saved registers: %r12, %r13, %r14, %r15, %rbx, %rsp, %rbp.
+ * - In contrast to the Intel386 ABI, %rdi, and %rsi in x86-64 belong to the called function, not
+ *   the caller. So, It's caller-save registers
+ * - User-level applications use as integer registers for passing the sequence %rdi, %rsi, %rdx, %rcx,
+ *   %r8 and %r9. The kernel interface uses %rdi, %rsi, %rdx, %r10, %r8 and %r9.
+ * - the sequence %rax, %rdx is used to return INTEGER,
+ * - rdx is used to pass 3rd argument to functions; 2nd return register
+ * - %r11 is neither required to be preserved, nor is it used to pass arguments
+ */
+/* ID, 8-bit prefix, 8-16 bit prefix, 16-bit prefix, 32-bit prefix, 64-bit prefix, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill */
+INT_REG(0 , "BL", "BH", "W", "L", "Q", true, false, false, false, false)
+INT_REG(1 , "BL", "BH", "W", "L", "Q", true, true, false, false, false)
+INT_REG(2 , "BL", "BH", "W", "L", "Q", true, false, true, false, false)
+INT_REG(3 , "BL", "BH", "W", "L", "Q", true, false, true, false, false)
+INT_REG(4 , "B",   "",  "W", "L", "Q", false, false, false, false, false)
+INT_REG(5 , "B",   "",  "W", "L", "Q", false, true, false, false, false)
+INT_REG(6 , "B",   "",  "W", "L", "Q", true, false, true, false, false)
+INT_REG(7 , "B",   "",  "W", "L", "Q", true, false, true, false, false)
+INT_REG(8 , "B",   "",  "W", "L", "Q", true, false, true, false, false)
+INT_REG(9 , "B",   "",  "W", "L", "Q", true, false, true, false, false)
+INT_REG(10, "B",   "",  "W", "L", "Q", true, false, false, true, false)
+INT_REG(11, "B",   "",  "W", "L", "Q", true, false, false, true, false)
+INT_REG(12, "B",   "",  "W", "L", "Q", true, true, false, false, false)
+INT_REG(13, "B",   "",  "W", "L", "Q", true, true, false, false, false)
+INT_REG(14, "B",   "",  "W", "L", "Q", true, true, false, false, false)
+INT_REG(15, "B",   "",  "W", "L", "Q", true, true, false, false, false)
+/* instruction pointer */
+INT_REG(16, "B",   "",  "W", "L", "Q", false, false, false, false, false)
+
+/* Alias */
+INT_REG_ALIAS(AX, 0)
+INT_REG_ALIAS(BX, 1)
+INT_REG_ALIAS(CX, 2)
+INT_REG_ALIAS(DX, 3)
+INT_REG_ALIAS(SP, 4)
+INT_REG_ALIAS(BP, 5)
+INT_REG_ALIAS(SI, 6)
+INT_REG_ALIAS(DI, 7)
+
+INT_REG_ALIAS(FP, 5)
+INT_REG_ALIAS(YP, 12)
+INT_REG_ALIAS(IP, 16)
+INT_REG_ALIAS(LAST_GP_REG, 16)
+
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_isa.h b/src/mapleall/maple_be/include/cg/x86_64/x64_isa.h
new file mode 100644
index 0000000000000000000000000000000000000000..505a717837c5a837a750dd1da07b92446f4493e3
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_isa.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_ISA_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_ISA_H
+
+#include "operand.h"
+#include "mad.h"
+#include "isa.h"
+
+namespace maplebe {
+/*
+ * X64 Architecture Reference Manual
+ */
+constexpr int kX64StackPtrAlignment = 16;
+
+constexpr int32 kOffsetAlign = 8;
+constexpr uint32 kIntregBytelen = 8;   /* 64-bit */
+constexpr uint32 kFpregBytelen = 8;    /* only lower 64 bits are used */
+constexpr int kSizeOfFplr = 16;
+
+class Insn;
+
+namespace x64 {
+/* machine instruction description */
+#define DEFINE_MOP(op, ...) op,
+enum X64MOP_t : maple::uint32 {
+#include "abstract_mmir.def"
+#include "x64_md.def"
+  kMopLast
+};
+#undef DEFINE_MOP
+
+/* Registers in x64 state */
+enum X64reg : uint32 {
+  kRinvalid = kInvalidRegNO,
+/* integer registers */
+#define INT_REG(ID, PREF8, PREF8_16, PREF16, PREF32, PREF64, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) R##ID,
+#define INT_REG_ALIAS(ALIAS, ID)
+#include "x64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) V##ID,
+#include "x64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+  kMaxRegNum,
+  kRFLAG,
+  kAllRegNum,
+/* integer registers alias */
+#define INT_REG(ID, PREF8, PREF8_16, PREF16, PREF32, PREF64, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill)
+#define INT_REG_ALIAS(ALIAS, ID) R##ALIAS = R##ID,
+#include "x64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+};
+
+static inline bool IsGPRegister(X64reg r) {
+  return R0 <= r && r <= RLAST_GP_REG;
+}
+
+static inline bool IsFPSIMDRegister(X64reg r) {
+  return V0 <= r && r <= V23;
+}
+
+static inline bool IsFPRegister(X64reg r) {
+  return V0 <= r && r <= V7;
+}
+
+static inline bool IsSIMDRegister(X64reg r) {
+  return V8 <= r && r <= V23;
+}
+
+static inline bool IsPhysicalRegister(regno_t r) {
+  return r < kMaxRegNum;
+}
+
+static inline RegType GetRegType(X64reg r) {
+  if (IsGPRegister(r)) {
+    return kRegTyInt;
+  }
+  if (IsFPSIMDRegister(r)) {
+    return kRegTyFloat;
+  }
+  ASSERT(false, "No suitable register type to return?");
+  return kRegTyUndef;
+}
+/*
+ * Precondition: The given insn is a jump instruction.
+ * Get the jump target label operand index from the given instruction.
+ * Note: MOP_jmp_m, MOP_jmp_r is a jump instruction, but the target is unknown at compile time.
+ */
+uint32 GetJumpTargetIdx(const Insn &insn);
+
+MOperator FlipConditionOp(MOperator flippedOp);
+}  /* namespace x64 */
+
+/*
+ * We save callee-saved registers from lower stack area to upper stack area.
+ * If possible, we store a pair of registers (int/int and fp/fp) in the stack.
+ * The Stack Pointer has to be aligned at 16-byte boundary.
+ * On X64, kIntregBytelen == 8 (see the above)
+ */
+inline void GetNextOffsetCalleeSaved(int &offset) {
+  offset += (kIntregBytelen << 1);
+}
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_X64_X64_ISA_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_isa_tbl.h b/src/mapleall/maple_be/include/cg/x86_64/x64_isa_tbl.h
new file mode 100644
index 0000000000000000000000000000000000000000..59708ac59fb3e7795e09a6e3426d33a19f6911cd
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_isa_tbl.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_ISA_TBL_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_ISA_TBL_H
+
+#include "x64_isa.h"
+#include "operand.h"
+
+namespace maplebe {
+
+namespace x64 {
+ /* register,                  imm ,              memory,                   cond */
+#define DEF_X64_CMP_MAPPING_INT(SIZE)                                                                   \
+static const X64MOP_t cmpIselMap##SIZE[Operand::OperandType::kOpdPhi][Operand::OperandType::kOpdPhi] = {\
+    {MOP_cmp##SIZE##_r_r,      MOP_begin,       MOP_cmp##SIZE##_r_m,      MOP_begin},                   \
+    {MOP_cmp##SIZE##_i_r,      MOP_begin,       MOP_cmp##SIZE##_i_m,      MOP_begin},                   \
+    {MOP_cmp##SIZE##_m_r,      MOP_begin,       MOP_begin,                MOP_begin},                   \
+    {MOP_begin,                MOP_begin,       MOP_begin,                MOP_begin},                   \
+};
+DEF_X64_CMP_MAPPING_INT(b)
+DEF_X64_CMP_MAPPING_INT(w)
+DEF_X64_CMP_MAPPING_INT(l)
+DEF_X64_CMP_MAPPING_INT(q)
+
+static inline X64MOP_t GetCmpMop(Operand::OperandType dTy, Operand::OperandType sTy, PrimType primType) {
+  X64MOP_t cmpOp = MOP_begin;
+  switch (GetPrimTypeBitSize(primType)) {
+    case k8BitSize:
+      cmpOp = cmpIselMapb[sTy][dTy];
+      break;
+    case k16BitSize:
+      cmpOp = cmpIselMapw[sTy][dTy];
+      break;
+    case k32BitSize:
+      cmpOp = cmpIselMapl[sTy][dTy];
+      break;
+    case k64BitSize:
+      cmpOp = cmpIselMapq[sTy][dTy];
+      break;
+    default:
+      cmpOp= MOP_begin;
+      break;
+  }
+  return cmpOp;
+}
+
+ /* {OPCODE, {register,             imm ,              memory,                   cond}} */
+#define DEF_X64_SET_MAPPING_INT(OPCODE, TYPE)                                                   \
+{OPCODE, {x64::MOP_##TYPE##_r,      x64::MOP_begin,    x64::MOP_##TYPE##_m,      x64::MOP_begin}}
+
+using SetIselMappingType = std::unordered_map<maple::Opcode, std::array<X64MOP_t, Operand::OperandType::kOpdPhi>>;
+static const SetIselMappingType setUnsignedIselMapping = {
+    DEF_X64_SET_MAPPING_INT(OP_le, setbe),
+    DEF_X64_SET_MAPPING_INT(OP_ge, setae),
+    DEF_X64_SET_MAPPING_INT(OP_gt, seta),
+    DEF_X64_SET_MAPPING_INT(OP_lt, setb),
+    DEF_X64_SET_MAPPING_INT(OP_ne, setne),
+    DEF_X64_SET_MAPPING_INT(OP_eq, sete),
+};
+static const SetIselMappingType setSignedIselMapping = {
+    DEF_X64_SET_MAPPING_INT(OP_le, setle),
+    DEF_X64_SET_MAPPING_INT(OP_ge, setge),
+    DEF_X64_SET_MAPPING_INT(OP_gt, setg),
+    DEF_X64_SET_MAPPING_INT(OP_lt, setl),
+    DEF_X64_SET_MAPPING_INT(OP_ne, setne),
+    DEF_X64_SET_MAPPING_INT(OP_eq, sete),
+};
+#undef DEF_X64_SET_MAPPING_INT
+
+static inline X64MOP_t GetSetCCMop(maple::Opcode opcode, Operand::OperandType dTy, bool isSigned) {
+  ASSERT(dTy < Operand::OperandType::kOpdPhi, "illegal operand type");
+  const SetIselMappingType& setIselMapping = isSigned ? setSignedIselMapping :
+                                                        setUnsignedIselMapping;
+  auto iter = setIselMapping.find(opcode);
+  if (iter == setIselMapping.end()) {
+    return x64::MOP_begin;
+  }
+  return iter->second[dTy];
+}
+
+#define DEF_X64_CMOV_MAPPING_INT(OPCODE, TYPE)                                                          \
+{OPCODE, {x64::MOP_begin,   x64::MOP_##TYPE##w_r_r,   x64::MOP_##TYPE##l_r_r,   x64::MOP_##TYPE##q_r_r}}
+using CMovIselMappingType = std::unordered_map<maple::Opcode, std::array<X64MOP_t, kBitIndexEnd>>;
+static const CMovIselMappingType cmovUnsignedIselMapping = {
+    DEF_X64_CMOV_MAPPING_INT(OP_le, cmovbe),
+    DEF_X64_CMOV_MAPPING_INT(OP_ge, cmovae),
+    DEF_X64_CMOV_MAPPING_INT(OP_gt, cmova),
+    DEF_X64_CMOV_MAPPING_INT(OP_lt, cmovb),
+    DEF_X64_CMOV_MAPPING_INT(OP_ne, cmovne),
+    DEF_X64_CMOV_MAPPING_INT(OP_eq, cmove),
+};
+static const CMovIselMappingType cmovSignedIselMapping = {
+    DEF_X64_CMOV_MAPPING_INT(OP_le, cmovle),
+    DEF_X64_CMOV_MAPPING_INT(OP_ge, cmovge),
+    DEF_X64_CMOV_MAPPING_INT(OP_gt, cmovg),
+    DEF_X64_CMOV_MAPPING_INT(OP_lt, cmovl),
+    DEF_X64_CMOV_MAPPING_INT(OP_ne, cmovne),
+    DEF_X64_CMOV_MAPPING_INT(OP_eq, cmove),
+};
+#undef DEF_X64_CMOV_MAPPING_INT
+
+static inline X64MOP_t GetCMovCCMop(maple::Opcode opcode, int32 bitSize, bool isSigned) {
+  const auto &cmovIselMapping = isSigned ? cmovSignedIselMapping : cmovUnsignedIselMapping;
+  auto iter = cmovIselMapping.find(opcode);
+  if (iter == cmovIselMapping.end()) {
+    return x64::MOP_begin;
+  }
+  return iter->second[GetBitIndex(bitSize)];
+}
+}
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_X64_X64_ISA_TBL_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_live.h b/src/mapleall/maple_be/include/cg/x86_64/x64_live.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ccdb9c1c89d9feb70a4f10ad471145b519ce33f
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_live.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_LIVE_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_LIVE_H
+
+#include "live.h"
+
+namespace maplebe {
+class X64LiveAnalysis : public LiveAnalysis {
+ public:
+  X64LiveAnalysis(CGFunc &func, MemPool &memPool) : LiveAnalysis(func, memPool) {}
+  ~X64LiveAnalysis() override = default;
+  bool CleanupBBIgnoreReg(regno_t reg) override;
+  void InitEhDefine(BB &bb) override {};
+  void GenerateReturnBBDefUse(BB &bb) const override {};
+  void ProcessCallInsnParam(BB &bb, const Insn &insn) const override {};
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_X64_X64_LIVE_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_local_opt.h b/src/mapleall/maple_be/include/cg/x86_64/x64_local_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..af7df9c4c72d13f4295eada723f4ea470a8e534e
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_local_opt.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_X64_LOCALO_H
+#define MAPLEBE_INCLUDE_X64_LOCALO_H
+
+#include "local_opt.h"
+namespace maplebe{
+class X64LocalOpt : public LocalOpt {
+ public:
+  X64LocalOpt(MemPool &memPool, CGFunc &func, ReachingDefinition& rd)
+      : LocalOpt(memPool, func, rd){}
+  ~X64LocalOpt() = default;
+ private:
+  void DoLocalCopyProp() override;
+};
+
+class CopyRegProp : public LocalPropOptimizePattern {
+ public:
+  CopyRegProp(CGFunc &cgFunc, ReachingDefinition &rd) : LocalPropOptimizePattern(cgFunc, rd) {}
+  ~CopyRegProp() override = default;
+  bool CheckCondition(Insn &insn) final;
+  void Optimize(BB &bb, Insn &insn) final;
+ private:
+  bool propagateOperand(Insn &insn, RegOperand& oldOpnd, RegOperand& replaceOpnd);
+};
+
+class X64RedundantDefRemove : public RedundantDefRemove {
+ public:
+  X64RedundantDefRemove(CGFunc &cgFunc, ReachingDefinition &rd) : RedundantDefRemove(cgFunc, rd) {}
+  ~X64RedundantDefRemove() override = default;
+  void Optimize(BB &bb, Insn &insn) final;
+};
+
+}
+
+#endif /* MAPLEBE_INCLUDE_X64_LOCALO_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_md.def b/src/mapleall/maple_be/include/cg/x86_64/x64_md.def
new file mode 100644
index 0000000000000000000000000000000000000000..1b778335947749974631f1f7d3af08ae8b7302f6
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_md.def
@@ -0,0 +1,522 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/* {mop, opnds, prop, latency, name, format, length} */
+/* begin machine operation code of X86_64 instruction , */
+DEFINE_MOP(MOP_begin, {},0,0,"","",0)
+
+/* # Definitions
+ * use x64 style b/w/l/q for 8b/16b/32b/64b operation
+ * and using AT&T style assembly
+ */
+
+/* X64 MOVES */
+// TODO: fix intruction opnds, prop, latency, format and length
+// TODO: the encoding and enumeration seems too verbose
+// TODO: understand how other system represent these MOPs (especially for x86-64)
+// TODO: this is still an experiment
+// TODO: should make sure the convention is consistent with (AT&T style?)
+// TODO: how the general Machine instruction is designed?
+
+/* mov */
+DEFINE_MOP(MOP_movb_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg8ID},ISMOVE,kLtAlu,"movb","0,1",1)
+DEFINE_MOP(MOP_movb_i_r, {&OpndDesc::Imm8,&OpndDesc::Reg8ID},ISMOVE,kLtAlu,"movb","0,1",1)
+DEFINE_MOP(MOP_movb_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg8ID},ISLOAD,kLtAlu,"movb","0,1",1)
+DEFINE_MOP(MOP_movb_r_m, {&OpndDesc::Reg8IS,&OpndDesc::Mem8D},ISSTORE,kLtAlu,"movb","0,1",1)
+DEFINE_MOP(MOP_movb_i_m, {&OpndDesc::Imm8,&OpndDesc::Mem8D},ISSTORE,kLtAlu,"movb","0,1",1)
+
+DEFINE_MOP(MOP_movw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16ID},ISMOVE,kLtAlu,"movw","0,1",1)
+DEFINE_MOP(MOP_movw_i_r, {&OpndDesc::Imm16,&OpndDesc::Reg16ID},ISMOVE,kLtAlu,"movw","0,1",1)
+DEFINE_MOP(MOP_movw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16ID},ISLOAD,kLtAlu,"movw","0,1",1)
+DEFINE_MOP(MOP_movw_r_m, {&OpndDesc::Reg16IS,&OpndDesc::Mem16D},ISSTORE,kLtAlu,"movw","0,1",1)
+DEFINE_MOP(MOP_movw_i_m, {&OpndDesc::Imm16,&OpndDesc::Mem16D},ISSTORE,kLtAlu,"movw","0,1",1)
+
+DEFINE_MOP(MOP_movl_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32ID},ISMOVE,kLtAlu,"movl","0,1",1)
+DEFINE_MOP(MOP_movl_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg32ID},ISMOVE,kLtAlu,"movl","0,1",1)
+DEFINE_MOP(MOP_movl_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32ID},ISLOAD,kLtAlu,"movl","0,1",1)
+DEFINE_MOP(MOP_movl_r_m, {&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISSTORE,kLtAlu,"movl","0,1",1)
+DEFINE_MOP(MOP_movl_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem32D},ISSTORE,kLtAlu,"movl","0,1",1)
+
+DEFINE_MOP(MOP_movq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64ID},ISMOVE,kLtAlu,"movq","0,1",1)
+DEFINE_MOP(MOP_movq_i_r, {&OpndDesc::Imm64,&OpndDesc::Reg64ID},ISMOVE,kLtAlu,"movq","0,1",1)
+DEFINE_MOP(MOP_movq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64ID},ISLOAD,kLtAlu,"movq","0,1",1)
+DEFINE_MOP(MOP_movq_r_m, {&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISSTORE,kLtAlu,"movq","0,1",1)
+
+/* floating point mov */
+DEFINE_MOP(MOP_movd_fr_r, {&OpndDesc::Reg128FS,&OpndDesc::Reg32ID},ISSTORE,kLtAlu,"movd","0,1",1)
+DEFINE_MOP(MOP_movq_fr_r, {&OpndDesc::Reg128FS,&OpndDesc::Reg64ID},ISSTORE,kLtAlu,"movq","0,1",1)
+DEFINE_MOP(MOP_movq_r_fr, {&OpndDesc::Reg64IS,&OpndDesc::Reg128FD},ISSTORE,kLtAlu,"movq","0,1",1)
+DEFINE_MOP(MOP_movfs_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg128FD},ISLOAD,kLtAlu,"movss","0,1",1)
+DEFINE_MOP(MOP_movfs_r_m, {&OpndDesc::Reg32FS,&OpndDesc::Mem128D},ISSTORE,kLtAlu,"movss","0,1",1)
+DEFINE_MOP(MOP_movfd_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg128FD},ISLOAD,kLtAlu,"movsd","0,1",1)
+DEFINE_MOP(MOP_movfd_r_m, {&OpndDesc::Reg64IS,&OpndDesc::Mem128D},ISSTORE,kLtAlu,"movsd","0,1",1)
+
+/* movabs */
+//The movabs instruction to load arbitrary 64-bit constant into register and to load/store integer register from/to arbitrary constant 64-bit address is available
+DEFINE_MOP(MOP_movabs_i_r, {&OpndDesc::Imm64,&OpndDesc::Reg64ID},ISMOVE,kLtAlu,"movabs","0,1",1)
+DEFINE_MOP(MOP_movabs_s_r, {&OpndDesc::StImm64,&OpndDesc::Reg64ID},ISMOVE,kLtAlu,"movabs","0,1",1)
+DEFINE_MOP(MOP_movabs_l_r, {&OpndDesc::Lbl64,&OpndDesc::Reg64ID},ISMOVE,kLtAlu,"movabs","0,1",1)
+
+/* push & pop & lea */
+DEFINE_MOP(MOP_pushq_r, {&OpndDesc::Reg64IS},0,kLtAlu,"pushq","0",1)
+DEFINE_MOP(MOP_popq_r, {&OpndDesc::Reg32IS},0,kLtAlu,"popq","0",1)
+
+DEFINE_MOP(MOP_leaq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64ID},0,kLtAlu,"leaq","0,1",1)
+DEFINE_MOP(MOP_leal_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg64ID},0,kLtAlu,"leaq","0,1",1)
+DEFINE_MOP(MOP_leaw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg64ID},0,kLtAlu,"leaq","0,1",1)
+
+/* Moving from a smaller data size to 32 bits */
+/* zero extension */
+DEFINE_MOP(MOP_movzbw_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg16ID},ISCONVERSION,kLtAlu,"movzbw","0,1",1)
+DEFINE_MOP(MOP_movzbw_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg16ID},ISCONVERSION,kLtAlu,"movzbw","0,1",1)
+DEFINE_MOP(MOP_movzbl_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg32ID},ISCONVERSION,kLtAlu,"movzbl","0,1",1)
+DEFINE_MOP(MOP_movzbl_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg32ID},ISCONVERSION,kLtAlu,"movzbl","0,1",1)
+DEFINE_MOP(MOP_movzwl_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg32ID},ISCONVERSION,kLtAlu,"movzwl","0,1",1)
+DEFINE_MOP(MOP_movzwl_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg32ID},ISCONVERSION,kLtAlu,"movzwl","0,1",1)
+/* sign extension */
+DEFINE_MOP(MOP_movsbw_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg16ID},ISCONVERSION,kLtAlu,"movsbw","0,1",1)
+DEFINE_MOP(MOP_movsbw_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg16ID},ISCONVERSION,kLtAlu,"movsbw","0,1",1)
+DEFINE_MOP(MOP_movsbl_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg32ID},ISCONVERSION,kLtAlu,"movsbl","0,1",1)
+DEFINE_MOP(MOP_movsbl_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg32ID},ISCONVERSION,kLtAlu,"movsbl","0,1",1)
+DEFINE_MOP(MOP_movswl_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg32ID},ISCONVERSION,kLtAlu,"movswl","0,1",1)
+DEFINE_MOP(MOP_movswl_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg32ID},ISCONVERSION,kLtAlu,"movswl","0,1",1)
+
+/* Moving from a smaller data size to 64 bits */
+/* zero extension */
+/*
+ * Perhaps unexpectedly, instructions that move or generate 32-bit register values also set the upper 32 bits of the register to zero.
+ * Consequently, there is no need for an instruction movzlq.
+ */
+DEFINE_MOP(MOP_movzbq_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movzbq","0,1",1)
+DEFINE_MOP(MOP_movzbq_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movzbq","0,1",1)
+DEFINE_MOP(MOP_movzwq_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movzwq","0,1",1)
+DEFINE_MOP(MOP_movzwq_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movzwq","0,1",1)
+/* sign extension */
+DEFINE_MOP(MOP_movsbq_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movsbq","0,1",1)
+DEFINE_MOP(MOP_movsbq_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movsbq","0,1",1)
+DEFINE_MOP(MOP_movswq_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movswq","0,1",1)
+DEFINE_MOP(MOP_movswq_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movswq","0,1",1)
+DEFINE_MOP(MOP_movslq_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movslq","0,1",1)
+DEFINE_MOP(MOP_movslq_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg64ID},ISCONVERSION,kLtAlu,"movslq","0,1",1)
+
+/* BasicOp */
+/* add */
+DEFINE_MOP(MOP_addb_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"addb","0,1",1)
+DEFINE_MOP(MOP_addw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"addw","0,1",1)
+DEFINE_MOP(MOP_addl_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"addl","0,1",1)
+DEFINE_MOP(MOP_addq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"addq","0,1",1)
+DEFINE_MOP(MOP_addb_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"addb","0,1",1)
+DEFINE_MOP(MOP_addw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"addw","0,1",1)
+DEFINE_MOP(MOP_addl_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"addl","0,1",1)
+DEFINE_MOP(MOP_addq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"addq","0,1",1)
+DEFINE_MOP(MOP_addb_i_r, {&OpndDesc::Imm8,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"addb","0,1",1)
+DEFINE_MOP(MOP_addw_i_r, {&OpndDesc::Imm16,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"addw","0,1",1)
+DEFINE_MOP(MOP_addl_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"addl","0,1",1)
+DEFINE_MOP(MOP_addq_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"addq","0,1",1)
+DEFINE_MOP(MOP_addb_r_m, {&OpndDesc::Reg8IS,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"addb","0,1",1)
+DEFINE_MOP(MOP_addw_r_m, {&OpndDesc::Reg16IS,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"addw","0,1",1)
+DEFINE_MOP(MOP_addl_r_m, {&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"addl","0,1",1)
+DEFINE_MOP(MOP_addq_r_m, {&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"addq","0,1",1)
+DEFINE_MOP(MOP_addb_i_m, {&OpndDesc::Imm8,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"addb","0,1",1)
+DEFINE_MOP(MOP_addw_i_m, {&OpndDesc::Imm16,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"addw","0,1",1)
+DEFINE_MOP(MOP_addl_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"addl","0,1",1)
+DEFINE_MOP(MOP_addq_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"addq","0,1",1)
+/* add floating point */
+DEFINE_MOP(MOP_adds_r_r, {&OpndDesc::Reg128FS,&OpndDesc::Reg128FDS},ISBASICOP,kLtAlu,"addss","0,1",1)
+DEFINE_MOP(MOP_adds_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg128FDS},ISBASICOP,kLtAlu,"addss","0,1",1)
+DEFINE_MOP(MOP_addd_r_r, {&OpndDesc::Reg128FS,&OpndDesc::Reg128FDS},ISBASICOP,kLtAlu,"addsd","0,1",1)
+DEFINE_MOP(MOP_addd_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg128FDS},ISBASICOP,kLtAlu,"addsd","0,1",1)
+/* sub */
+DEFINE_MOP(MOP_subb_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"subb","0,1",1)
+DEFINE_MOP(MOP_subw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"subw","0,1",1)
+DEFINE_MOP(MOP_subl_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"subl","0,1",1)
+DEFINE_MOP(MOP_subq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"subq","0,1",1)
+DEFINE_MOP(MOP_subb_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"subb","0,1",1)
+DEFINE_MOP(MOP_subw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"subw","0,1",1)
+DEFINE_MOP(MOP_subl_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"subl","0,1",1)
+DEFINE_MOP(MOP_subq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"subq","0,1",1)
+DEFINE_MOP(MOP_subb_i_r, {&OpndDesc::Imm8,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"subb","0,1",1)
+DEFINE_MOP(MOP_subw_i_r, {&OpndDesc::Imm16,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"subw","0,1",1)
+DEFINE_MOP(MOP_subl_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"subl","0,1",1)
+DEFINE_MOP(MOP_subq_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"subq","0,1",1)
+DEFINE_MOP(MOP_subb_r_m, {&OpndDesc::Reg8IS,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"subb","0,1",1)
+DEFINE_MOP(MOP_subw_r_m, {&OpndDesc::Reg16IS,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"subw","0,1",1)
+DEFINE_MOP(MOP_subl_r_m, {&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"subl","0,1",1)
+DEFINE_MOP(MOP_subq_r_m, {&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"subq","0,1",1)
+DEFINE_MOP(MOP_subb_i_m, {&OpndDesc::Imm8,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"subb","0,1",1)
+DEFINE_MOP(MOP_subw_i_m, {&OpndDesc::Imm16,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"subw","0,1",1)
+DEFINE_MOP(MOP_subl_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"subl","0,1",1)
+DEFINE_MOP(MOP_subq_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"subq","0,1",1)
+/* sub floating point */
+DEFINE_MOP(MOP_subs_r_r, {&OpndDesc::Reg128FS,&OpndDesc::Reg128FDS},ISBASICOP,kLtAlu,"subss","0,1",1)
+DEFINE_MOP(MOP_subs_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg128FDS},ISBASICOP,kLtAlu,"subss","0,1",1)
+DEFINE_MOP(MOP_subd_r_r, {&OpndDesc::Reg128FS,&OpndDesc::Reg128FDS},ISBASICOP,kLtAlu,"subsd","0,1",1)
+DEFINE_MOP(MOP_subd_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg128FDS},ISBASICOP,kLtAlu,"subsd","0,1",1)
+/* and */
+DEFINE_MOP(MOP_andb_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"andb","0,1",1)
+DEFINE_MOP(MOP_andw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"andw","0,1",1)
+DEFINE_MOP(MOP_andl_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"andl","0,1",1)
+DEFINE_MOP(MOP_andq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"andq","0,1",1)
+DEFINE_MOP(MOP_andb_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"andb","0,1",1)
+DEFINE_MOP(MOP_andw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"andw","0,1",1)
+DEFINE_MOP(MOP_andl_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"andl","0,1",1)
+DEFINE_MOP(MOP_andq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"andq","0,1",1)
+DEFINE_MOP(MOP_andb_i_r, {&OpndDesc::Imm8,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"andb","0,1",1)
+DEFINE_MOP(MOP_andw_i_r, {&OpndDesc::Imm16,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"andw","0,1",1)
+DEFINE_MOP(MOP_andl_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"andl","0,1",1)
+DEFINE_MOP(MOP_andq_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"andq","0,1",1)
+DEFINE_MOP(MOP_andb_r_m, {&OpndDesc::Reg8IS,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"andb","0,1",1)
+DEFINE_MOP(MOP_andw_r_m, {&OpndDesc::Reg16IS,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"andw","0,1",1)
+DEFINE_MOP(MOP_andl_r_m, {&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"andl","0,1",1)
+DEFINE_MOP(MOP_andq_r_m, {&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"andq","0,1",1)
+DEFINE_MOP(MOP_andb_i_m, {&OpndDesc::Imm8,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"andb","0,1",1)
+DEFINE_MOP(MOP_andw_i_m, {&OpndDesc::Imm16,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"andw","0,1",1)
+DEFINE_MOP(MOP_andl_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"andl","0,1",1)
+DEFINE_MOP(MOP_andq_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"andq","0,1",1)
+/* or */
+DEFINE_MOP(MOP_orb_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"orb","0,1",1)
+DEFINE_MOP(MOP_orw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"orw","0,1",1)
+DEFINE_MOP(MOP_orl_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"orl","0,1",1)
+DEFINE_MOP(MOP_orq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"orq","0,1",1)
+DEFINE_MOP(MOP_orb_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"orb","0,1",1)
+DEFINE_MOP(MOP_orw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"orw","0,1",1)
+DEFINE_MOP(MOP_orl_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"orl","0,1",1)
+DEFINE_MOP(MOP_orq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"orq","0,1",1)
+DEFINE_MOP(MOP_orb_i_r, {&OpndDesc::Imm8,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"orb","0,1",1)
+DEFINE_MOP(MOP_orw_i_r, {&OpndDesc::Imm16,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"orw","0,1",1)
+DEFINE_MOP(MOP_orl_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"orl","0,1",1)
+DEFINE_MOP(MOP_orq_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"orq","0,1",1)
+DEFINE_MOP(MOP_orb_r_m, {&OpndDesc::Reg8IS,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"orb","0,1",1)
+DEFINE_MOP(MOP_orw_r_m, {&OpndDesc::Reg16IS,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"orw","0,1",1)
+DEFINE_MOP(MOP_orl_r_m, {&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"orl","0,1",1)
+DEFINE_MOP(MOP_orq_r_m, {&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"orq","0,1",1)
+DEFINE_MOP(MOP_orb_i_m, {&OpndDesc::Imm8,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"orb","0,1",1)
+DEFINE_MOP(MOP_orw_i_m, {&OpndDesc::Imm16,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"orw","0,1",1)
+DEFINE_MOP(MOP_orl_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"orl","0,1",1)
+DEFINE_MOP(MOP_orq_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"orq","0,1",1)
+/* xor */
+DEFINE_MOP(MOP_xorb_r_r, {&OpndDesc::Reg8IS,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"xorb","0,1",1)
+DEFINE_MOP(MOP_xorw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"xorw","0,1",1)
+DEFINE_MOP(MOP_xorl_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"xorl","0,1",1)
+DEFINE_MOP(MOP_xorq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"xorq","0,1",1)
+DEFINE_MOP(MOP_xorb_m_r, {&OpndDesc::Mem8S,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"xorb","0,1",1)
+DEFINE_MOP(MOP_xorw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"xorw","0,1",1)
+DEFINE_MOP(MOP_xorl_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"xorl","0,1",1)
+DEFINE_MOP(MOP_xorq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"xorq","0,1",1)
+DEFINE_MOP(MOP_xorb_i_r, {&OpndDesc::Imm8,&OpndDesc::Reg8IDS},ISBASICOP,kLtAlu,"xorb","0,1",1)
+DEFINE_MOP(MOP_xorw_i_r, {&OpndDesc::Imm16,&OpndDesc::Reg16IDS},ISBASICOP,kLtAlu,"xorw","0,1",1)
+DEFINE_MOP(MOP_xorl_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg32IDS},ISBASICOP,kLtAlu,"xorl","0,1",1)
+DEFINE_MOP(MOP_xorq_i_r, {&OpndDesc::Imm32,&OpndDesc::Reg64IDS},ISBASICOP,kLtAlu,"xorq","0,1",1)
+DEFINE_MOP(MOP_xorb_r_m, {&OpndDesc::Reg8IS,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"xorb","0,1",1)
+DEFINE_MOP(MOP_xorw_r_m, {&OpndDesc::Reg16IS,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"xorw","0,1",1)
+DEFINE_MOP(MOP_xorl_r_m, {&OpndDesc::Reg32IS,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"xorl","0,1",1)
+DEFINE_MOP(MOP_xorq_r_m, {&OpndDesc::Reg64IS,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"xorq","0,1",1)
+DEFINE_MOP(MOP_xorb_i_m, {&OpndDesc::Imm8,&OpndDesc::Mem8D},ISBASICOP,kLtAlu,"xorb","0,1",1)
+DEFINE_MOP(MOP_xorw_i_m, {&OpndDesc::Imm16,&OpndDesc::Mem16D},ISBASICOP,kLtAlu,"xorw","0,1",1)
+DEFINE_MOP(MOP_xorl_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem32D},ISBASICOP,kLtAlu,"xorl","0,1",1)
+DEFINE_MOP(MOP_xorq_i_m, {&OpndDesc::Imm32,&OpndDesc::Mem64D},ISBASICOP,kLtAlu,"xorq","0,1",1)
+
+/* UnaryOp */
+/* neg */
+DEFINE_MOP(MOP_negb_r, {&OpndDesc::Reg8IDS},ISUNARYOP,kLtAlu,"negb","0",1)
+DEFINE_MOP(MOP_negw_r, {&OpndDesc::Reg16IDS},ISUNARYOP,kLtAlu,"negw","0",1)
+DEFINE_MOP(MOP_negl_r, {&OpndDesc::Reg32IDS},ISUNARYOP,kLtAlu,"negl","0",1)
+DEFINE_MOP(MOP_negq_r, {&OpndDesc::Reg64IDS},ISUNARYOP,kLtAlu,"negq","0",1)
+DEFINE_MOP(MOP_negb_m, {&OpndDesc::Mem8S},ISUNARYOP,kLtAlu,"negb","0",1)
+DEFINE_MOP(MOP_negw_m, {&OpndDesc::Mem16S},ISUNARYOP,kLtAlu,"negw","0",1)
+DEFINE_MOP(MOP_negl_m, {&OpndDesc::Mem32S},ISUNARYOP,kLtAlu,"negl","0",1)
+DEFINE_MOP(MOP_negq_m, {&OpndDesc::Mem64S},ISUNARYOP,kLtAlu,"negq","0",1)
+/* not */
+DEFINE_MOP(MOP_notb_r, {&OpndDesc::Reg8IDS},ISUNARYOP,kLtAlu,"notb","0",1)
+DEFINE_MOP(MOP_notw_r, {&OpndDesc::Reg16IDS},ISUNARYOP,kLtAlu,"notw","0",1)
+DEFINE_MOP(MOP_notl_r, {&OpndDesc::Reg32IDS},ISUNARYOP,kLtAlu,"notl","0",1)
+DEFINE_MOP(MOP_notq_r, {&OpndDesc::Reg64IDS},ISUNARYOP,kLtAlu,"notq","0",1)
+DEFINE_MOP(MOP_notb_m, {&OpndDesc::Mem8S},ISUNARYOP,kLtAlu,"notb","0",1)
+DEFINE_MOP(MOP_notw_m, {&OpndDesc::Mem16S},ISUNARYOP,kLtAlu,"notw","0",1)
+DEFINE_MOP(MOP_notl_m, {&OpndDesc::Mem32S},ISUNARYOP,kLtAlu,"notl","0",1)
+DEFINE_MOP(MOP_notq_m, {&OpndDesc::Mem64S},ISUNARYOP,kLtAlu,"notq","0",1)
+
+/* shift -- shl/sar/shr reg8, use cl */
+/* shl */
+DEFINE_MOP(MOP_shlb_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg8IDS},ISSHIFT,kLtAlu,"shlb","0,1",1)
+DEFINE_MOP(MOP_shlw_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg16IDS},ISSHIFT,kLtAlu,"shlw","0,1",1)
+DEFINE_MOP(MOP_shll_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg32IDS},ISSHIFT,kLtAlu,"shll","0,1",1)
+DEFINE_MOP(MOP_shlq_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg64IDS},ISSHIFT,kLtAlu,"shlq","0,1",1)
+DEFINE_MOP(MOP_shlb_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg8IDS},ISSHIFT,kLtAlu,"shlb","0,1",1)
+DEFINE_MOP(MOP_shlw_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg16IDS},ISSHIFT,kLtAlu,"shlw","0,1",1)
+DEFINE_MOP(MOP_shll_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg32IDS},ISSHIFT,kLtAlu,"shll","0,1",1)
+DEFINE_MOP(MOP_shlq_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg64IDS},ISSHIFT,kLtAlu,"shlq","0,1",1)
+DEFINE_MOP(MOP_shlb_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem8D},ISSHIFT,kLtAlu,"shlb","0,1",1)
+DEFINE_MOP(MOP_shlw_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem16D},ISSHIFT,kLtAlu,"shlw","0,1",1)
+DEFINE_MOP(MOP_shll_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem32D},ISSHIFT,kLtAlu,"shll","0,1",1)
+DEFINE_MOP(MOP_shlq_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem64D},ISSHIFT,kLtAlu,"shlq","0,1",1)
+DEFINE_MOP(MOP_shlb_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem8D},ISSHIFT,kLtAlu,"shlb","0,1",1)
+DEFINE_MOP(MOP_shlw_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem16D},ISSHIFT,kLtAlu,"shlw","0,1",1)
+DEFINE_MOP(MOP_shll_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem32D},ISSHIFT,kLtAlu,"shll","0,1",1)
+DEFINE_MOP(MOP_shlq_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem64D},ISSHIFT,kLtAlu,"shlq","0,1",1)
+/* sar */
+DEFINE_MOP(MOP_sarb_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg8IDS},ISSHIFT,kLtAlu,"sarb","0,1",1)
+DEFINE_MOP(MOP_sarw_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg16IDS},ISSHIFT,kLtAlu,"sarw","0,1",1)
+DEFINE_MOP(MOP_sarl_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg32IDS},ISSHIFT,kLtAlu,"sarl","0,1",1)
+DEFINE_MOP(MOP_sarq_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg64IDS},ISSHIFT,kLtAlu,"sarq","0,1",1)
+DEFINE_MOP(MOP_sarb_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg8IDS},ISSHIFT,kLtAlu,"sarb","0,1",1)
+DEFINE_MOP(MOP_sarw_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg16IDS},ISSHIFT,kLtAlu,"sarw","0,1",1)
+DEFINE_MOP(MOP_sarl_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg32IDS},ISSHIFT,kLtAlu,"sarl","0,1",1)
+DEFINE_MOP(MOP_sarq_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg64IDS},ISSHIFT,kLtAlu,"sarq","0,1",1)
+DEFINE_MOP(MOP_sarb_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem8D},ISSHIFT,kLtAlu,"sarb","0,1",1)
+DEFINE_MOP(MOP_sarw_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem16D},ISSHIFT,kLtAlu,"sarw","0,1",1)
+DEFINE_MOP(MOP_sarl_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem32D},ISSHIFT,kLtAlu,"sarl","0,1",1)
+DEFINE_MOP(MOP_sarq_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem64D},ISSHIFT,kLtAlu,"sarq","0,1",1)
+DEFINE_MOP(MOP_sarb_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem8D},ISSHIFT,kLtAlu,"sarb","0,1",1)
+DEFINE_MOP(MOP_sarw_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem16D},ISSHIFT,kLtAlu,"sarw","0,1",1)
+DEFINE_MOP(MOP_sarl_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem32D},ISSHIFT,kLtAlu,"sarl","0,1",1)
+DEFINE_MOP(MOP_sarq_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem64D},ISSHIFT,kLtAlu,"sarq","0,1",1)
+/* shr */
+DEFINE_MOP(MOP_shrb_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg8IDS},ISSHIFT,kLtAlu,"shrb","0,1",1)
+DEFINE_MOP(MOP_shrw_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg16IDS},ISSHIFT,kLtAlu,"shrw","0,1",1)
+DEFINE_MOP(MOP_shrl_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg32IDS},ISSHIFT,kLtAlu,"shrl","0,1",1)
+DEFINE_MOP(MOP_shrq_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg64IDS},ISSHIFT,kLtAlu,"shrq","0,1",1)
+DEFINE_MOP(MOP_shrb_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg8IDS},ISSHIFT,kLtAlu,"shrb","0,1",1)
+DEFINE_MOP(MOP_shrw_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg16IDS},ISSHIFT,kLtAlu,"shrw","0,1",1)
+DEFINE_MOP(MOP_shrl_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg32IDS},ISSHIFT,kLtAlu,"shrl","0,1",1)
+DEFINE_MOP(MOP_shrq_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg64IDS},ISSHIFT,kLtAlu,"shrq","0,1",1)
+DEFINE_MOP(MOP_shrb_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem8D},ISSHIFT,kLtAlu,"shrb","0,1",1)
+DEFINE_MOP(MOP_shrw_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem16D},ISSHIFT,kLtAlu,"shrw","0,1",1)
+DEFINE_MOP(MOP_shrl_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem32D},ISSHIFT,kLtAlu,"shrl","0,1",1)
+DEFINE_MOP(MOP_shrq_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem64D},ISSHIFT,kLtAlu,"shrq","0,1",1)
+DEFINE_MOP(MOP_shrb_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem8D},ISSHIFT,kLtAlu,"shrb","0,1",1)
+DEFINE_MOP(MOP_shrw_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem16D},ISSHIFT,kLtAlu,"shrw","0,1",1)
+DEFINE_MOP(MOP_shrl_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem32D},ISSHIFT,kLtAlu,"shrl","0,1",1)
+DEFINE_MOP(MOP_shrq_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem64D},ISSHIFT,kLtAlu,"shrq","0,1",1)
+
+/* idiv, div  -- opnd(use), rax(def,use), rdx(def,use) */
+DEFINE_MOP(MOP_idivw_r, {&OpndDesc::Reg16IS, &OpndDesc::Reg16IDS, &OpndDesc::Reg16IDS},0,kLtAlu,"idivw","0",1)
+DEFINE_MOP(MOP_idivl_r, {&OpndDesc::Reg32IS, &OpndDesc::Reg32IDS, &OpndDesc::Reg32IDS},0,kLtAlu,"idivl","0",1)
+DEFINE_MOP(MOP_idivq_r, {&OpndDesc::Reg64IS, &OpndDesc::Reg64IDS, &OpndDesc::Reg64IDS},0,kLtAlu,"idivq","0",1)
+DEFINE_MOP(MOP_idivw_m, {&OpndDesc::Mem16S, &OpndDesc::Reg16IDS, &OpndDesc::Reg16IDS},0,kLtAlu,"idivw","0",1)
+DEFINE_MOP(MOP_idivl_m, {&OpndDesc::Mem32S, &OpndDesc::Reg32IDS, &OpndDesc::Reg32IDS},0,kLtAlu,"idivl","0",1)
+DEFINE_MOP(MOP_idivq_m, {&OpndDesc::Mem64S, &OpndDesc::Reg64IDS, &OpndDesc::Reg64IDS},0,kLtAlu,"idivq","0",1)
+DEFINE_MOP(MOP_divw_r, {&OpndDesc::Reg16IS, &OpndDesc::Reg16IDS, &OpndDesc::Reg16IDS},0,kLtAlu,"divw","0",1)
+DEFINE_MOP(MOP_divl_r, {&OpndDesc::Reg32IS, &OpndDesc::Reg32IDS, &OpndDesc::Reg32IDS},0,kLtAlu,"divl","0",1)
+DEFINE_MOP(MOP_divq_r, {&OpndDesc::Reg64IS, &OpndDesc::Reg64IDS, &OpndDesc::Reg64IDS},0,kLtAlu,"divq","0",1)
+DEFINE_MOP(MOP_divw_m, {&OpndDesc::Mem16S, &OpndDesc::Reg16IDS, &OpndDesc::Reg16IDS},0,kLtAlu,"divw","0",1)
+DEFINE_MOP(MOP_divl_m, {&OpndDesc::Mem32S, &OpndDesc::Reg32IDS, &OpndDesc::Reg32IDS},0,kLtAlu,"divl","0",1)
+DEFINE_MOP(MOP_divq_m, {&OpndDesc::Mem64S, &OpndDesc::Reg64IDS, &OpndDesc::Reg64IDS},0,kLtAlu,"divq","0",1)
+/* cwd, cdq, cqo  -- rax(def use), rdx(def) */
+DEFINE_MOP(MOP_cwd, {&OpndDesc::Reg16IDS, &OpndDesc::Reg16ID},0,kLtAlu,"cwd","",1)
+DEFINE_MOP(MOP_cdq, {&OpndDesc::Reg32IDS, &OpndDesc::Reg32ID},0,kLtAlu,"cdq","",1)
+DEFINE_MOP(MOP_cqo, {&OpndDesc::Reg64IDS, &OpndDesc::Reg64ID},0,kLtAlu,"cqo","",1)
+
+/* jmp, je, jne */
+DEFINE_MOP(MOP_jmpq_r, {&OpndDesc::Reg64IS},ISUNCONDBRANCH,kLtAlu,"jmp","0",1)
+DEFINE_MOP(MOP_jmpq_m, {&OpndDesc::Mem64S},ISUNCONDBRANCH,kLtAlu,"jmp","0",1)
+DEFINE_MOP(MOP_jmpq_l, {&OpndDesc::Lbl64},ISUNCONDBRANCH,kLtAlu,"jmp","0",1) // ip relative
+
+DEFINE_MOP(MOP_je_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"je","0",1)
+DEFINE_MOP(MOP_ja_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"ja","0",1)  // unsigned >
+DEFINE_MOP(MOP_jae_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"jae","0",1) // unsigned >=
+DEFINE_MOP(MOP_jne_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"jne","0",1)
+DEFINE_MOP(MOP_jb_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"jb","0",1)  // unsigned <
+DEFINE_MOP(MOP_jbe_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"jbe","0",1) // unsigned <=
+DEFINE_MOP(MOP_jg_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"jg","0",1)  // signed >
+DEFINE_MOP(MOP_jge_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"jge","0",1) // signed >=
+DEFINE_MOP(MOP_jl_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"jl","0",1)  // signed <
+DEFINE_MOP(MOP_jle_l, {&OpndDesc::Lbl64},ISCONDBRANCH,kLtAlu,"jle","0",1) // signed <=
+
+/* cmp */
+DEFINE_MOP(MOP_cmpb_r_r, {&OpndDesc::Reg8IS, &OpndDesc::Reg8IS},0,kLtAlu,"cmpb","0,1",1)
+DEFINE_MOP(MOP_cmpb_m_r, {&OpndDesc::Mem8S, &OpndDesc::Reg8IS},0,kLtAlu,"cmpb","0,1",1)
+DEFINE_MOP(MOP_cmpb_i_r, {&OpndDesc::Imm8, &OpndDesc::Reg8IS},0,kLtAlu,"cmpb","0,1",1)
+DEFINE_MOP(MOP_cmpb_r_m, {&OpndDesc::Reg8IS, &OpndDesc::Mem8S},0,kLtAlu,"cmpb","0,1",1)
+DEFINE_MOP(MOP_cmpb_i_m, {&OpndDesc::Imm8, &OpndDesc::Mem8S},0,kLtAlu,"cmpb","0,1",1)
+DEFINE_MOP(MOP_cmpw_r_r, {&OpndDesc::Reg16IS, &OpndDesc::Reg16IS},0,kLtAlu,"cmpw","0,1",1)
+DEFINE_MOP(MOP_cmpw_m_r, {&OpndDesc::Mem16S, &OpndDesc::Reg16IS},0,kLtAlu,"cmpw","0,1",1)
+DEFINE_MOP(MOP_cmpw_i_r, {&OpndDesc::Imm16, &OpndDesc::Reg16IS},0,kLtAlu,"cmpw","0,1",1)
+DEFINE_MOP(MOP_cmpw_r_m, {&OpndDesc::Reg16IS, &OpndDesc::Mem16S},0,kLtAlu,"cmpw","0,1",1)
+DEFINE_MOP(MOP_cmpw_i_m, {&OpndDesc::Imm16, &OpndDesc::Mem16S},0,kLtAlu,"cmpw","0,1",1)
+DEFINE_MOP(MOP_cmpl_r_r, {&OpndDesc::Reg32IS, &OpndDesc::Reg32IS},0,kLtAlu,"cmpl","0,1",1)
+DEFINE_MOP(MOP_cmpl_m_r, {&OpndDesc::Mem32S, &OpndDesc::Reg32IS},0,kLtAlu,"cmpl","0,1",1)
+DEFINE_MOP(MOP_cmpl_i_r, {&OpndDesc::Imm32, &OpndDesc::Reg32IS},0,kLtAlu,"cmpl","0,1",1)
+DEFINE_MOP(MOP_cmpl_r_m, {&OpndDesc::Reg32IS, &OpndDesc::Mem32S},0,kLtAlu,"cmpl","0,1",1)
+DEFINE_MOP(MOP_cmpl_i_m, {&OpndDesc::Imm32, &OpndDesc::Mem32S},0,kLtAlu,"cmpl","0,1",1)
+DEFINE_MOP(MOP_cmpq_r_r, {&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},0,kLtAlu,"cmpq","0,1",1)
+DEFINE_MOP(MOP_cmpq_m_r, {&OpndDesc::Mem64S, &OpndDesc::Reg64IS},0,kLtAlu,"cmpq","0,1",1)
+DEFINE_MOP(MOP_cmpq_i_r, {&OpndDesc::Imm32, &OpndDesc::Reg64IS},0,kLtAlu,"cmpq","0,1",1)
+DEFINE_MOP(MOP_cmpq_r_m, {&OpndDesc::Reg64IS, &OpndDesc::Mem64S},0,kLtAlu,"cmpq","0,1",1)
+DEFINE_MOP(MOP_cmpq_i_m, {&OpndDesc::Imm32, &OpndDesc::Mem64S},0,kLtAlu,"cmpq","0,1",1)
+
+/* test */
+DEFINE_MOP(MOP_testq_r_r, {&OpndDesc::Reg64IS, &OpndDesc::Reg64IS},0,kLtAlu,"testq","0,1",1)
+
+/* setcc -- use ccreg(CF/ZF/SF/OF) */
+DEFINE_MOP(MOP_setbe_r, {&OpndDesc::Reg8ID},0,kLtAlu,"setbe","0",1)
+DEFINE_MOP(MOP_setle_r, {&OpndDesc::Reg8ID},0,kLtAlu,"setle","0",1)
+DEFINE_MOP(MOP_setae_r, {&OpndDesc::Reg8ID},0,kLtAlu,"setae","0",1)
+DEFINE_MOP(MOP_setge_r, {&OpndDesc::Reg8ID},0,kLtAlu,"setge","0",1)
+DEFINE_MOP(MOP_setne_r, {&OpndDesc::Reg8ID},0,kLtAlu,"setne","0",1)
+DEFINE_MOP(MOP_setb_r, {&OpndDesc::Reg8ID},0,kLtAlu,"setb","0",1)
+DEFINE_MOP(MOP_setl_r, {&OpndDesc::Reg8ID},0,kLtAlu,"setl","0",1)
+DEFINE_MOP(MOP_seta_r, {&OpndDesc::Reg8ID},0,kLtAlu,"seta","0",1)
+DEFINE_MOP(MOP_setg_r, {&OpndDesc::Reg8ID},0,kLtAlu,"setg","0",1)
+DEFINE_MOP(MOP_sete_r, {&OpndDesc::Reg8ID},0,kLtAlu,"sete","0",1)
+DEFINE_MOP(MOP_setbe_m, {&OpndDesc::Mem8D},0,kLtAlu,"setbe","0",1)
+DEFINE_MOP(MOP_setle_m, {&OpndDesc::Mem8D},0,kLtAlu,"setle","0",1)
+DEFINE_MOP(MOP_setae_m, {&OpndDesc::Mem8D},0,kLtAlu,"setae","0",1)
+DEFINE_MOP(MOP_setge_m, {&OpndDesc::Mem8D},0,kLtAlu,"setge","0",1)
+DEFINE_MOP(MOP_setne_m, {&OpndDesc::Mem8D},0,kLtAlu,"setne","0",1)
+DEFINE_MOP(MOP_setb_m, {&OpndDesc::Mem8D},0,kLtAlu,"setb","0",1)
+DEFINE_MOP(MOP_setl_m, {&OpndDesc::Mem8D},0,kLtAlu,"setl","0",1)
+DEFINE_MOP(MOP_seta_m, {&OpndDesc::Mem8D},0,kLtAlu,"seta","0",1)
+DEFINE_MOP(MOP_setg_m, {&OpndDesc::Mem8D},0,kLtAlu,"setg","0",1)
+DEFINE_MOP(MOP_sete_m, {&OpndDesc::Mem8D},0,kLtAlu,"sete","0",1)
+
+/* cmov */
+/* condition move if below or equal */
+DEFINE_MOP(MOP_cmovbew_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovbew","0,1",1)
+DEFINE_MOP(MOP_cmovbel_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovbel","0,1",1)
+DEFINE_MOP(MOP_cmovbeq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovbeq","0,1",1)
+DEFINE_MOP(MOP_cmovbew_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovbew","0,1",1)
+DEFINE_MOP(MOP_cmovbel_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovbel","0,1",1)
+DEFINE_MOP(MOP_cmovbeq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovbeq","0,1",1)
+/* condition move if less or equal */
+DEFINE_MOP(MOP_cmovlew_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovlew","0,1",1)
+DEFINE_MOP(MOP_cmovlel_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovlel","0,1",1)
+DEFINE_MOP(MOP_cmovleq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovleq","0,1",1)
+DEFINE_MOP(MOP_cmovlew_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovlew","0,1",1)
+DEFINE_MOP(MOP_cmovlel_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovlel","0,1",1)
+DEFINE_MOP(MOP_cmovleq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovleq","0,1",1)
+/* condition move if above or equal */
+DEFINE_MOP(MOP_cmovaew_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovaew","0,1",1)
+DEFINE_MOP(MOP_cmovael_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovael","0,1",1)
+DEFINE_MOP(MOP_cmovaeq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovaeq","0,1",1)
+DEFINE_MOP(MOP_cmovaew_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovaew","0,1",1)
+DEFINE_MOP(MOP_cmovael_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovael","0,1",1)
+DEFINE_MOP(MOP_cmovaeq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovaeq","0,1",1)
+/* condition move if greater or equal */
+DEFINE_MOP(MOP_cmovgew_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovgew","0,1",1)
+DEFINE_MOP(MOP_cmovgel_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovgel","0,1",1)
+DEFINE_MOP(MOP_cmovgeq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovgeq","0,1",1)
+DEFINE_MOP(MOP_cmovgew_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovgew","0,1",1)
+DEFINE_MOP(MOP_cmovgel_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovgel","0,1",1)
+DEFINE_MOP(MOP_cmovgeq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovgeq","0,1",1)
+/* condition move if not equal */
+DEFINE_MOP(MOP_cmovnew_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovnew","0,1",1)
+DEFINE_MOP(MOP_cmovnel_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovnel","0,1",1)
+DEFINE_MOP(MOP_cmovneq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovneq","0,1",1)
+DEFINE_MOP(MOP_cmovnew_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovnew","0,1",1)
+DEFINE_MOP(MOP_cmovnel_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovnel","0,1",1)
+DEFINE_MOP(MOP_cmovneq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovneq","0,1",1)
+/* condition move if below */
+DEFINE_MOP(MOP_cmovbw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovbw","0,1",1)
+DEFINE_MOP(MOP_cmovbl_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovbl","0,1",1)
+DEFINE_MOP(MOP_cmovbq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovbq","0,1",1)
+DEFINE_MOP(MOP_cmovbw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovbw","0,1",1)
+DEFINE_MOP(MOP_cmovbl_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovbl","0,1",1)
+DEFINE_MOP(MOP_cmovbq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovbq","0,1",1)
+/* condition move if less */
+DEFINE_MOP(MOP_cmovlw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovlw","0,1",1)
+DEFINE_MOP(MOP_cmovll_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovll","0,1",1)
+DEFINE_MOP(MOP_cmovlq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovlq","0,1",1)
+DEFINE_MOP(MOP_cmovlw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovlw","0,1",1)
+DEFINE_MOP(MOP_cmovll_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovll","0,1",1)
+DEFINE_MOP(MOP_cmovlq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovlq","0,1",1)
+/* condition move if above */
+DEFINE_MOP(MOP_cmovaw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovaw","0,1",1)
+DEFINE_MOP(MOP_cmoval_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmoval","0,1",1)
+DEFINE_MOP(MOP_cmovaq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovaq","0,1",1)
+DEFINE_MOP(MOP_cmovaw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovaw","0,1",1)
+DEFINE_MOP(MOP_cmoval_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmoval","0,1",1)
+DEFINE_MOP(MOP_cmovaq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovaq","0,1",1)
+/* condition move if greater */
+DEFINE_MOP(MOP_cmovgw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovgw","0,1",1)
+DEFINE_MOP(MOP_cmovgl_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovgl","0,1",1)
+DEFINE_MOP(MOP_cmovgq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovgq","0,1",1)
+DEFINE_MOP(MOP_cmovgw_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovgw","0,1",1)
+DEFINE_MOP(MOP_cmovgl_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovgl","0,1",1)
+DEFINE_MOP(MOP_cmovgq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmovgq","0,1",1)
+/* condition move if equal */
+DEFINE_MOP(MOP_cmovew_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovew","0,1",1)
+DEFINE_MOP(MOP_cmovel_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovel","0,1",1)
+DEFINE_MOP(MOP_cmoveq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"cmoveq","0,1",1)
+DEFINE_MOP(MOP_cmovew_m_r, {&OpndDesc::Mem16S,&OpndDesc::Reg16IDS},0,kLtAlu,"cmovew","0,1",1)
+DEFINE_MOP(MOP_cmovel_m_r, {&OpndDesc::Mem32S,&OpndDesc::Reg32IDS},0,kLtAlu,"cmovel","0,1",1)
+DEFINE_MOP(MOP_cmoveq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64IDS},0,kLtAlu,"cmoveq","0,1",1)
+
+/* call, ret, leave */
+DEFINE_MOP(MOP_callq_l, {&OpndDesc::Lbl64,&OpndDesc::ListSrc,&OpndDesc::ListDest},ISCALL,kLtAlu,"callq","0",1)
+DEFINE_MOP(MOP_callq_m, {&OpndDesc::Mem64S,&OpndDesc::ListSrc,&OpndDesc::ListDest},ISCALL,kLtAlu,"callq","0",1)
+DEFINE_MOP(MOP_callq_r, {&OpndDesc::Reg64IS,&OpndDesc::ListSrc,&OpndDesc::ListDest},ISCALL,kLtAlu,"callq","0",1)
+
+DEFINE_MOP(MOP_retq, {},CANTHROW,kLtBranch,"ret","",1)
+
+DEFINE_MOP(MOP_leaveq, {},CANTHROW,kLtBranch,"leave","",1)
+
+/* imul */
+DEFINE_MOP(MOP_imulw_r_r, {&OpndDesc::Reg16IS,&OpndDesc::Reg16IDS},0,kLtAlu,"imulw","0,1",1)
+DEFINE_MOP(MOP_imull_r_r, {&OpndDesc::Reg32IS,&OpndDesc::Reg32IDS},0,kLtAlu,"imull","0,1",1)
+DEFINE_MOP(MOP_imulq_r_r, {&OpndDesc::Reg64IS,&OpndDesc::Reg64IDS},0,kLtAlu,"imulq","0,1",1)
+
+/* mul float */
+DEFINE_MOP(MOP_mulfs_r_r, {&OpndDesc::Reg128FS,&OpndDesc::Reg128FDS},0,kLtAlu,"mulss","0,1",1)
+DEFINE_MOP(MOP_mulfd_r_r, {&OpndDesc::Reg128FS,&OpndDesc::Reg128FDS},0,kLtAlu,"mulsd","0,1",1)
+
+/* nop */
+// TODO: still not clear why we need so many forms of nop (except for patch)
+DEFINE_MOP(MOP_nopb, {&OpndDesc::Mem8S},0,kLtAlu,"nopb","",1)
+DEFINE_MOP(MOP_nopw, {&OpndDesc::Mem16S},0,kLtAlu,"nopw","",1)
+DEFINE_MOP(MOP_nopl, {&OpndDesc::Mem32S},0,kLtAlu,"nopl","",1)
+DEFINE_MOP(MOP_nop, {},0,0,"nop","",1)
+
+/* Byte Swap */
+DEFINE_MOP(MOP_bswapl_r, {&OpndDesc::Reg32IDS},0,kLtAlu,"bswapl","0",1)
+DEFINE_MOP(MOP_bswapq_r, {&OpndDesc::Reg64IDS},0,kLtAlu,"bswapq","0",1)
+
+/* xchg */
+DEFINE_MOP(MOP_xchgb_r_r, {&OpndDesc::Reg8IDS,&OpndDesc::Reg8IDS},0,kLtAlu,"xchgb","0,1",1)
+
+/* end of X64 instructions */
+
+/* invalid operation */
+DEFINE_MOP(MOP_movq_i_m, {&OpndDesc::Imm64,&OpndDesc::Mem64D},0,kLtAlu,"invalid","0,1",1)
+
+
+/* floating point */
+DEFINE_MOP(MOP_movfq_m_r, {&OpndDesc::Mem64S,&OpndDesc::Reg64FD},ISLOAD,kLtAlu,"movsd","0,1",1)
+DEFINE_MOP(MOP_movfq_r_m, {&OpndDesc::Reg64FS,&OpndDesc::Mem64D},ISSTORE,kLtAlu,"movsd","0,1",1)
+DEFINE_MOP(MOP_movfq_r_r, {&OpndDesc::Reg64FS,&OpndDesc::Reg64FS},ISSTORE,kLtAlu,"movsd","0,1",1)
+
+/* floating div */
+DEFINE_MOP(MOP_divsd_r, {&OpndDesc::Reg64FS, &OpndDesc::Reg64FDS},0,kLtAlu,"divsd","0,1",1)
+DEFINE_MOP(MOP_divsd_m, {&OpndDesc::Mem64S, &OpndDesc::Reg64FDS},0,kLtAlu,"divsd","0,1",1)
+
+/* convert int2float */
+DEFINE_MOP(MOP_cvtsi2ssq_r, {&OpndDesc::Reg64IS, &OpndDesc::Reg128FD},0,kLtAlu,"cvtsi2ssq","0,1",1)
+DEFINE_MOP(MOP_cvtsi2ssl_r, {&OpndDesc::Reg32IS, &OpndDesc::Reg128FD},0,kLtAlu,"cvtsi2ssl","0,1",1)
+DEFINE_MOP(MOP_cvtsi2sdq_r, {&OpndDesc::Reg64IS, &OpndDesc::Reg128FD},0,kLtAlu,"cvtsi2sdq","0,1",1)
+DEFINE_MOP(MOP_cvtsi2sdl_r, {&OpndDesc::Reg32IS, &OpndDesc::Reg128FD},0,kLtAlu,"cvtsi2sdl","0,1",1)
+
+/*convert float2int */
+DEFINE_MOP(MOP_cvttsd2siq_r, {&OpndDesc::Reg128FS, &OpndDesc::Reg64ID},0,kLtAlu,"cvttsd2siq","0,1",1)
+DEFINE_MOP(MOP_cvttsd2sil_r, {&OpndDesc::Reg128FS, &OpndDesc::Reg32ID},0,kLtAlu,"cvttsd2sil","0,1",1)
+DEFINE_MOP(MOP_cvttss2siq_r, {&OpndDesc::Reg128FS, &OpndDesc::Reg64ID},0,kLtAlu,"cvttss2siq","0,1",1)
+DEFINE_MOP(MOP_cvttss2sil_r, {&OpndDesc::Reg128FS, &OpndDesc::Reg32ID},0,kLtAlu,"cvttss2sil","0,1",1)
+
+/* convert float2float */
+DEFINE_MOP(MOP_cvtss2sd_r, {&OpndDesc::Reg128FS, &OpndDesc::Reg128FD},0,kLtAlu,"cvtss2sd","0,1",1)
+DEFINE_MOP(MOP_cvtsd2ss_r, {&OpndDesc::Reg128FS, &OpndDesc::Reg128FD},0,kLtAlu,"cvtsd2ss","0,1",1)
+
+DEFINE_MOP(MOP_ucomisd_r_r, {&OpndDesc::Reg128FS,&OpndDesc::Reg128FS},0,kLtAlu,"ucomisd","0,1",1)
+
+/* pseudo operation */
+DEFINE_MOP(MOP_pseudo_ret_int, {&OpndDesc::Reg64IS},0,kLtUndef,"//MOP_pseudo_ret_int","", 0)
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_memlayout.h b/src/mapleall/maple_be/include/cg/x86_64/x64_memlayout.h
new file mode 100644
index 0000000000000000000000000000000000000000..a46a8ba5622246011e3e346755e6f78012a345b3
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_memlayout.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_CG_X86_64_MEMLAYOUT_H
+#define MAPLEBE_INCLUDE_CG_X86_64_MEMLAYOUT_H
+
+#include "memlayout.h"
+#include "x64_abi.h"
+
+namespace maplebe {
+class X64SymbolAlloc : public SymbolAlloc {
+ public:
+  X64SymbolAlloc() = default;
+
+  ~X64SymbolAlloc() = default;
+
+  void SetRegisters(bool isR) {
+    isRegister = isR;
+  }
+
+  inline bool IsRegister() const {
+    return isRegister;
+  }
+
+ private:
+  bool isRegister = false;
+};
+/*
+ * On X64, stack frames are structured as follows:
+ *
+ * The stack grows downward -- full descending (SP points
+ * to a filled slot).
+ *
+ * Any of the parts of a frame is optional, i.e., it is
+ * possible to write a caller-callee pair in such a way
+ * that the particular part is absent in the frame.
+ *
+ * Before a call is made, the frame looks like:
+ * |                            |
+ * ||----------------------------|
+ * | args passed on the stack   | (we call them up-formals)
+ * ||----------------------------|<- Stack Pointer
+ * |                            |
+ *
+ * Right after a call is made
+ * |                            |
+ * ||----------------------------|
+ * | args passed on the stack   |
+ * ||----------------------------|<- Stack Pointer
+ * | PREV_FP, PREV_LR           |
+ * ||----------------------------|<- Frame Pointer
+ *
+ * After the prologue has run,
+ * |                            |
+ * ||----------------------------|
+ * | args passed on the stack   |
+ * ||----------------------------|
+ * | PREV_FP, PREV_LR           |
+ * ||----------------------------|<- Frame Pointer
+ * | GR Arg Save Area           |
+ * ||----------------------------|
+ * | VR Arg Save Area           |
+ * ||----------------------------|
+ * | callee-saved registers     |
+ * ||----------------------------|
+ * | empty space. should have   |
+ * | at least 16-byte alignment |
+ * ||----------------------------|
+ * | local variables            |
+ * ||----------------------------|<- Stack Pointer
+ * | red zone                   |
+ *
+ * callee-saved registers include
+ *  1. rbx rbp r12 r14 r14 r15
+ *  2. XMM0-XMM7
+ */
+
+class X64MemLayout : public MemLayout {
+ public:
+  X64MemLayout(BECommon &b, MIRFunction &f, MapleAllocator &mallocator)
+      : MemLayout(b, f, mallocator, kX64StackPtrAlignment) {}
+
+  ~X64MemLayout() override = default;
+
+  uint32 ComputeStackSpaceRequirementForCall(StmtNode &stmtNode, int32 &aggCopySize, bool isIcall) override;
+  void LayoutStackFrame(int32 &structCopySize, int32 &maxParmStackSize) override;
+
+  uint64 StackFrameSize() const;
+
+  const MemSegment &Locals() const {
+    return segLocals;
+  }
+  /*
+   * "Pseudo-registers can be regarded as local variables of a
+   * primitive type whose addresses are never taken"
+   */
+  virtual void AssignSpillLocationsToPseudoRegisters() override;
+
+  virtual SymbolAlloc *AssignLocationToSpillReg(regno_t vrNum) override;
+
+  uint32 GetSizeOfSpillReg() const {
+    return segSpillReg.GetSize();
+  }
+
+  uint32 GetSizeOfLocals() const {
+    return segLocals.GetSize();
+  }
+
+  void SetSizeOfGRSaveArea(uint32 sz) {
+    segGrSaveArea.SetSize(sz);
+  }
+
+  uint32 GetSizeOfGRSaveArea() const {
+    return segGrSaveArea.GetSize();
+  }
+
+  inline void SetSizeOfVRSaveArea(uint32 sz) {
+    segVrSaveArea.SetSize(sz);
+  }
+
+  uint32 GetSizeOfVRSaveArea() const {
+    return segVrSaveArea.GetSize();
+  }
+
+  int32 GetGRSaveAreaBaseLoc();
+  int32 GetVRSaveAreaBaseLoc();
+ private:
+  /* Layout function */
+  void LayoutFormalParams();
+  void LayoutLocalVariables();
+  void LayoutVarargParams();
+
+  /* util function */
+  void SetSizeAlignForTypeIdx(uint32 typeIdx, uint32 &size, uint32 &align) const;
+  void LayoutReturnRef(int32 &structCopySize, int32 &maxParmStackSize);
+
+  MemSegment segLocals = MemSegment(kMsLocals);  /* these are accessed via Frame Pointer */
+  MemSegment segGrSaveArea = MemSegment(kMsGrSaveArea);
+  MemSegment segVrSaveArea = MemSegment(kMsVrSaveArea);
+  MemSegment segSpillReg = MemSegment(kMsSpillReg);
+};
+}
+#endif // MAPLEBE_INCLUDE_CG_X86_64_MEMLAYOUT_H
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_optimize_common.h b/src/mapleall/maple_be/include/cg/x86_64/x64_optimize_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..055658b0a5bc152b0033b6b494b2abe427626655
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_optimize_common.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_OPTIMIZE_COMMON_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_OPTIMIZE_COMMON_H
+
+#include "x64_isa.h"
+#include "optimize_common.h"
+
+namespace maplebe {
+using namespace maple;
+
+class X64InsnVisitor : public InsnVisitor {
+ public:
+  explicit X64InsnVisitor(CGFunc &func) : InsnVisitor(func) {}
+
+  ~X64InsnVisitor() = default;
+
+  void ModifyJumpTarget(LabelIdx targetLabel, BB &bb) override;
+  void ModifyJumpTarget(Operand &targetOperand, BB &bb) override;
+  void ModifyJumpTarget(BB &newTarget, BB &bb) override;
+  /* Check if it requires to add extra gotos when relocate bb */
+  Insn *CloneInsn(Insn &originalInsn) override;
+  LabelIdx GetJumpLabel(const Insn &insn) const override;
+  bool IsCompareInsn(const Insn &insn) const override;
+  bool IsCompareAndBranchInsn(const Insn &insn) const override;
+  bool IsAddOrSubInsn(const Insn &insn) const override;
+  RegOperand *CreateVregFromReg(const RegOperand &pReg) override;
+  void ReTargetSuccBB(BB &bb, LabelIdx newTarget) const override;
+  void FlipIfBB(BB &bb, LabelIdx ftLabel) const override;
+  BB *CreateGotoBBAfterCondBB(BB &bb, BB &fallthru, bool isTargetFallthru) const override;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_X64_X64_OPTIMIZE_COMMON_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_peep.h b/src/mapleall/maple_be/include/cg/x86_64/x64_peep.h
new file mode 100644
index 0000000000000000000000000000000000000000..488c82ad455d5816d2d563b96026aa7598c25e7c
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_peep.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_PEEP_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_PEEP_H
+
+#include <vector>
+#include "peep.h"
+
+namespace maplebe {
+class X64CGPeepHole : CGPeepHole {
+ public:
+    /* normal constructor */
+  X64CGPeepHole(CGFunc &f, MemPool *memPool) : CGPeepHole(f, memPool) {};
+  /* constructor for ssa */
+  X64CGPeepHole(CGFunc &f, MemPool *memPool, CGSSAInfo *cgssaInfo) : CGPeepHole(f, memPool, cgssaInfo) {};
+  ~X64CGPeepHole() = default;
+  void Run() override;
+  bool DoSSAOptimize(BB &bb, Insn &insn) override;
+  void DoNormalOptimize(BB &bb, Insn &insn) override;
+};
+
+class RemoveMovingtoSameRegPattern : public CGPeepPattern {
+ public:
+  RemoveMovingtoSameRegPattern(CGFunc &cgFunc, BB &currBB, Insn &currInsn)
+      : CGPeepPattern(cgFunc, currBB, currInsn) {}
+  ~RemoveMovingtoSameRegPattern() override = default;
+  void Run(BB &bb, Insn &insn) override;
+  bool CheckCondition(Insn &insn) override;
+  std::string GetPatternName() override {
+    return "RemoveMovingtoSameRegPattern";
+  }
+};
+
+}  /* namespace maplebe */
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_PEEP_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_phases.def b/src/mapleall/maple_be/include/cg/x86_64/x64_phases.def
new file mode 100644
index 0000000000000000000000000000000000000000..0d7b66e6b7698a6e06a4364ae7744bf781800ac9
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_phases.def
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+ ADDTARGETPHASE("layoutstackframe", true);
+ ADDTARGETPHASE("createstartendlabel", true);
+ ADDTARGETPHASE("buildehfunc", GetMIRModule()->GetSrcLang() != kSrcLangC);
+ ADDTARGETPHASE("instructionselector", true);
+ ADDTARGETPHASE("instructionstandardize", true);
+ ADDTARGETPHASE("handlecfg", true);
+ ADDTARGETPHASE("moveargs", true);
+ ADDTARGETPHASE("cfgo", true);
+ ADDTARGETPHASE("localcopyprop", true);
+ ADDTARGETPHASE("regalloc", true);
+ ADDTARGETPHASE("postcfgo", true);
+ ADDTARGETPHASE("cgpostpeephole", true);
+ ADDTARGETPHASE("generateproepilog", true);
+ /* ASM EMIT */
+ ADDTARGETPHASE("cgemit", true);
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_proepilog.h b/src/mapleall/maple_be/include/cg/x86_64/x64_proepilog.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f0ba354f5feb408cfcc9bb973d5df56033d2320
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_proepilog.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_PROEPILOG_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_PROEPILOG_H
+
+#include "proepilog.h"
+#include "x64_cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+class X64GenProEpilog : public GenProEpilog {
+ public:
+  explicit X64GenProEpilog(CGFunc &func) : GenProEpilog(func) {}
+  ~X64GenProEpilog() override = default;
+
+  bool NeedProEpilog() override;
+  void Run() override;
+ private:
+  void GenerateProlog(BB &bb);
+  void GenerateEpilog(BB &bb);
+  void GenerateCalleeSavedRegs(bool isPush);
+  void GeneratePushCalleeSavedRegs(RegOperand &regOpnd, MemOperand &memOpnd, uint32 regSize);
+  void GeneratePopCalleeSavedRegs(RegOperand &regOpnd, MemOperand &memOpnd, uint32 regSize);
+  void GeneratePushUnnamedVarargRegs();
+  void GeneratePushRbpInsn();
+  void GenerateMovRspToRbpInsn();
+  void GenerateSubFrameSizeFromRspInsn();
+  void GenerateAddFrameSizeToRspInsn();
+  void GeneratePopInsn();
+  void GenerateRetInsn();
+};
+}  /* namespace maplebe */
+
+#endif /* MAPLEBE_INCLUDE_CG_X64_X64_PROEPILOG_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_reaching.h b/src/mapleall/maple_be/include/cg/x86_64/x64_reaching.h
new file mode 100644
index 0000000000000000000000000000000000000000..f53023c23e64aa73aa29a813b3da60c7fae34dc1
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_reaching.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_REACHING_H
+#define MAPLEBE_INCLUDE_CG_X64_REACHING_H
+
+#include "reaching.h"
+
+namespace maplebe {
+class X64ReachingDefinition : public ReachingDefinition {
+ public:
+  X64ReachingDefinition(CGFunc &func, MemPool &memPool) : ReachingDefinition(func, memPool) {}
+  ~X64ReachingDefinition() override = default;
+  bool FindRegUseBetweenInsn(uint32 regNO, Insn *startInsn, Insn *endInsn, InsnSet &useInsnSet) const final;
+  std::vector<Insn*> FindRegDefBetweenInsnGlobal(uint32 regNO, Insn *startInsn, Insn *endInsn) const final;
+  std::vector<Insn*> FindMemDefBetweenInsn(uint32 offset, const Insn *startInsn, Insn *endInsn) const final;
+  bool FindRegUseBetweenInsnGlobal(uint32 regNO, Insn *startInsn, Insn *endInsn, BB* movBB) const final;
+  bool FindMemUseBetweenInsn(uint32 offset, Insn *startInsn, const Insn *endInsn,
+                             InsnSet &useInsnSet) const final;
+  bool HasRegDefBetweenInsnGlobal(uint32 regNO, Insn &startInsn, Insn &endInsn);
+  bool DFSFindRegDefBetweenBB(const BB &startBB, const BB &endBB, uint32 regNO,
+                              std::vector<VisitStatus> &visitedBB) const;
+  InsnSet FindDefForRegOpnd(Insn &insn, uint32 indexOrRegNO, bool isRegNO = false) const final;
+  InsnSet FindDefForMemOpnd(Insn &insn, uint32 indexOrOffset, bool isOffset = false) const final;
+  InsnSet FindUseForMemOpnd(Insn &insn, uint8 index, bool secondMem = false) const final;
+  bool FindRegUsingBetweenInsn(uint32 regNO, Insn *startInsn, const Insn *endInsn) const;
+ protected:
+  void InitStartGen() final;
+  void InitEhDefine(BB &bb) final;
+  void InitGenUse(BB &bb, bool firstTime = true) final;
+  void GenAllAsmDefRegs(BB &bb, Insn &insn, uint32 index) final;
+  void GenAllAsmUseRegs(BB &bb, Insn &insn, uint32 index) final;
+  void GenAllCallerSavedRegs(BB &bb, Insn &insn) final;
+  bool IsRegKilledByCallInsn(const Insn &insn, regno_t regNO) const final;
+  bool KilledByCallBetweenInsnInSameBB(const Insn &startInsn, const Insn &endInsn, regno_t regNO) const final;
+  void AddRetPseudoInsn(BB &bb) final;
+
+   void AddRetPseudoInsns() final; bool IsCallerSavedReg(uint32 regNO) const final;
+  void FindRegDefInBB(uint32 regNO, BB &bb, InsnSet &defInsnSet) const final;
+  void FindMemDefInBB(uint32 offset, BB &bb, InsnSet &defInsnSet) const final;
+  void DFSFindDefForRegOpnd(const BB &startBB, uint32 regNO, std::vector<VisitStatus> &visitedBB,
+                            InsnSet &defInsnSet) const final;
+  void DFSFindDefForMemOpnd(const BB &startBB, uint32 offset, std::vector<VisitStatus> &visitedBB,
+                            InsnSet &defInsnSet) const final;
+  int32 GetStackSize() const final;
+ private:
+  bool IsDiv(const Insn &insn) const;
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_REACHING_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_reg_info.h b/src/mapleall/maple_be/include/cg/x86_64/x64_reg_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..7eba47a583907935c2f8e0425e70429bd70b11b7
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_reg_info.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_X64_X64_REG_INFO_H
+#define MAPLEBE_INCLUDE_CG_X64_X64_REG_INFO_H
+
+#include "reg_info.h"
+#include "x64_isa.h"
+#include "x64_abi.h"
+
+namespace maplebe {
+static const std::map<regno_t, uint32> x64IntParamsRegIdx =
+    {{x64::RAX, 0}, {x64::RDI, 1}, {x64::RSI, 2}, {x64::RDX, 3}, {x64::RCX, 4}, {x64::R8, 5}, {x64::R9, 6}};
+
+class X64RegInfo : public RegisterInfo {
+ public:
+  X64RegInfo(MapleAllocator &mallocator): RegisterInfo(mallocator) {}
+
+  ~X64RegInfo() override = default;
+
+  void Init() override;
+  void Fini() override;
+  void SaveCalleeSavedReg(MapleSet<regno_t> savedRegs) override;
+  bool IsSpecialReg(regno_t regno) const override;
+  bool IsCalleeSavedReg(regno_t regno) const override;
+  bool IsYieldPointReg(regno_t regNO) const override;
+  bool IsUnconcernedReg(regno_t regNO) const override;
+  bool IsUnconcernedReg(const RegOperand &regOpnd) const override;
+  bool IsFramePointReg(regno_t regNO) const override {
+    return (regNO == x64::RBP);
+  }
+  bool IsReservedReg(regno_t regNO, bool doMultiPass) const override {
+    return false;
+  }
+  RegOperand *GetOrCreatePhyRegOperand(regno_t regNO, uint32 size, RegType kind, uint32 flag) override;
+  Insn *BuildStrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) override;
+  Insn *BuildLdrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) override;
+  MemOperand *AdjustMemOperandIfOffsetOutOfRange(MemOperand *memOpnd, regno_t vrNum,
+      bool isDest, Insn &insn, regno_t regNum, bool &isOutOfRange) override;
+  bool IsGPRegister(regno_t regNO) const override {
+    return x64::IsGPRegister(static_cast<x64::X64reg>(regNO));
+  }
+  /* Those registers can not be overwrite. */
+  bool IsUntouchableReg(regno_t regNO) const override{
+    return false;
+  }
+  /* Refactor later: Integrate parameters and return Reg */
+  uint32 GetIntRegsParmsNum() override {
+    /*Parms: rdi, rsi, rdx, rcx, r8, r9; Ret: rax, rdx */
+    return x64::kNumIntParmRegs + 1;
+  }
+  uint32 GetIntRetRegsNum() override {
+    return x64::kNumIntReturnRegs;
+  }
+  uint32 GetFpRetRegsNum() override {
+    return x64::kNumFloatReturnRegs;
+  }
+  regno_t GetLastParamsIntReg() override {
+    return x64::R9;
+  }
+  uint32 GetNormalUseOperandNum() override {
+    return 0;
+  }
+  regno_t GetIntRetReg(uint32 idx) override {
+    CHECK_FATAL(idx < x64::kNumIntReturnRegs, "index out of range in IntRetReg");
+    return static_cast<regno_t>(x64::kIntReturnRegs[idx]);
+  }
+  regno_t GetFpRetReg(uint32 idx) override {
+    CHECK_FATAL(idx < x64::kNumFloatReturnRegs, "index out of range in FloatRetReg");
+    return static_cast<regno_t>(x64::kFloatReturnRegs[idx]);
+  }
+  /* phys reg which can be pre-Assignment:
+   * INT param regs -- rdi, rsi, rdx, rcx, r8, r9
+   * INT return regs -- rdx, rax
+   * FP param regs -- xmm0 ~ xmm7
+   * FP return regs -- xmm0 ~ xmm1
+   */
+  bool IsPreAssignedReg(regno_t regNO) const override {
+    return x64::IsParamReg(static_cast<x64::X64reg>(regNO)) ||
+           regNO == x64::RAX || regNO == x64::RDX;
+  }
+  uint32 GetIntParamRegIdx(regno_t regNO) const override {
+    const std::map<regno_t, uint32>::const_iterator iter = x64IntParamsRegIdx.find(regNO);
+    CHECK_FATAL(iter != x64IntParamsRegIdx.end(), "index out of range in IntParamsRegs");
+    return iter->second;
+  }
+  uint32 GetFpParamRegIdx(regno_t regNO) const override {
+    return static_cast<uint32>(regNO - x64::V0);
+  }
+  regno_t GetLastParamsFpReg() override {
+    return x64::kRinvalid;
+  }
+  uint32 GetFloatRegsParmsNum() override {
+    return x64::kNumFloatParmRegs;
+  }
+  uint32 GetFloatRegsRetsNum() {
+    return x64::kNumFloatReturnRegs;
+  }
+  uint32 GetAllRegNum() override {
+    return x64::kAllRegNum;
+  }
+  regno_t GetInvalidReg() override {
+    return x64::kRinvalid;
+  }
+  bool IsAvailableReg(regno_t regNO) const override {
+    return x64::IsAvailableReg(static_cast<x64::X64reg>(regNO));
+  }
+  bool IsVirtualRegister(const RegOperand &regOpnd) override {
+    return regOpnd.GetRegisterNumber() > x64::kAllRegNum;
+  }
+  bool IsVirtualRegister(regno_t regno) override {
+    return regno > x64::kAllRegNum;
+  }
+  regno_t GetReservedSpillReg() override {
+    return x64::kRinvalid;
+  }
+  regno_t GetSecondReservedSpillReg() override {
+    return x64::kRinvalid;
+  }
+  regno_t GetYieldPointReg() const override {
+    return x64::kRinvalid;
+  }
+  regno_t GetStackPointReg() const override {
+    return x64::RSP;
+  }
+  bool IsSpillRegInRA(regno_t regNO, bool has3RegOpnd) override {
+    return x64::IsSpillRegInRA(static_cast<x64::X64reg>(regNO), has3RegOpnd);
+  }
+
+  regno_t GetIntSpillFillReg(size_t idx) const override {
+    static regno_t intRegs[kSpillMemOpndNum] = { 0 };
+    ASSERT(idx < kSpillMemOpndNum, "index out of range");
+    return intRegs[idx];
+  }
+  regno_t GetFpSpillFillReg(size_t idx) const override {
+    static regno_t fpRegs[kSpillMemOpndNum] = { 0 };
+    ASSERT(idx < kSpillMemOpndNum, "index out of range");
+    return fpRegs[idx];
+  }
+};
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_X64_X64_REG_INFO_H */
diff --git a/src/mapleall/maple_be/include/cg/x86_64/x64_standardize.h b/src/mapleall/maple_be/include/cg/x86_64/x64_standardize.h
new file mode 100644
index 0000000000000000000000000000000000000000..46353bc7e0885b5df86ecf156a23a7f3f78b1eaf
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/x86_64/x64_standardize.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEBE_INCLUDE_X64_STANDARDIZE_H
+#define MAPLEBE_INCLUDE_X64_STANDARDIZE_H
+
+#include "standardize.h"
+
+namespace maplebe {
+class X64Standardize : public Standardize {
+ public:
+  explicit X64Standardize(CGFunc &f) : Standardize(f) {
+    SetAddressMapping(true);
+  }
+
+  ~X64Standardize() override = default;
+
+ private:
+  void StdzMov(Insn &insn) override;
+  void StdzStrLdr(Insn &insn) override;
+  void StdzBasicOp(Insn &insn) override;
+  void StdzUnaryOp(Insn &insn, CGFunc &cgFunc) override;
+  void StdzCvtOp(Insn &insn, CGFunc &cgFunc) override;
+  void StdzShiftOp(Insn &insn, CGFunc &cgFunc) override;
+  void StdzFloatingNeg(Insn &insn, CGFunc &cgFunc);
+};
+}
+#endif  /* MAPLEBE_INCLUDEX_64_STANDARDIZE_H */
diff --git a/src/mapleall/maple_be/include/cg/yieldpoint.h b/src/mapleall/maple_be/include/cg/yieldpoint.h
new file mode 100644
index 0000000000000000000000000000000000000000..d66103c59e93c1f4d0192098ccf64d7550235917
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/yieldpoint.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_INCLUDE_CG_YIELDPOINT_H
+#define MAPLEBE_INCLUDE_CG_YIELDPOINT_H
+
+#include "cgfunc.h"
+#include "cg_phase.h"
+
+namespace maplebe {
+class YieldPointInsertion {
+ public:
+  explicit YieldPointInsertion(CGFunc &func) : cgFunc(&func) {}
+
+  virtual ~YieldPointInsertion() = default;
+
+  virtual void Run() {}
+
+  std::string PhaseName() const {
+    return "yieldpoint";
+  }
+
+ protected:
+  CGFunc *cgFunc;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(CgYieldPointInsertion, maplebe::CGFunc)
+MAPLE_FUNC_PHASE_DECLARE_END
+}  /* namespace maplebe */
+
+#endif  /* MAPLEBE_INCLUDE_CG_YIELDPOINT_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/mdgen/gendef.py b/src/mapleall/maple_be/mdgen/gendef.py
new file mode 100755
index 0000000000000000000000000000000000000000..a49862a0b8de538f732651ca65edf3d8c8c8d7fb
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/gendef.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+# coding=utf-8
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+import os, sys, subprocess, shlex, re, argparse
+def Gendef(execTool, mdFiles, outputDir, asanLib=None):
+  tdList = []
+  for mdFile in mdFiles:
+    if mdFile.find('sched') >= 0:
+      schedInfo = mdFile
+      mdCmd = "%s --genSchdInfo %s -o %s" %(execTool, schedInfo , outputDir)
+      isMatch = re.search(r'[;\\|\\&\\$\\>\\<`]', mdCmd, re.M|re.I)
+      if (isMatch):
+        print("Command Injection !")
+        return
+      print("[*] %s" % (mdCmd))
+      localEnv = os.environ
+      if asanLib is not None:
+        asanEnv = asanLib.split("=")
+        localEnv[asanEnv[0]] = asanEnv[1]
+        print("env :" + str(asanEnv))
+      subprocess.check_call(shlex.split(mdCmd), shell = False, env = localEnv)
+    else:
+      tdList.append(i)
+  return
+
+def Process(execTool, mdFileDir, outputDir, asanLib=None):
+  if not (os.path.exists(execTool)):
+    print("maplegen is required before generating def files automatically")
+    return
+  if not (os.path.exists(mdFileDir)):
+    print("td/md files is required as input!!!")
+    print("Generate def files FAILED!!!")
+    return
+
+  mdFiles = []
+  for root,dirs,allfiles in os.walk(mdFileDir):
+    for mdFile in allfiles:
+      mdFiles.append("%s/%s"%(mdFileDir, mdFile))
+
+  if not (os.path.exists(outputDir)):
+    print("Create the " + outputDir)
+    os.makedirs(outputDir)
+    Gendef(execTool, mdFiles, outputDir, asanLib)
+
+  defFile = "%s/mplad_arch_define.def" % (outputDir)
+  if not (os.path.exists(defFile)):
+    Gendef(execTool, mdFiles, outputDir, asanLib)
+  for mdfile in mdFiles:
+    if (os.stat(mdfile).st_mtime > os.stat(defFile).st_mtime):
+      Gendef(execTool, mdFiles, outputDir, asanLib)
+  if (os.stat(execTool).st_mtime > os.stat(defFile).st_mtime):
+    Gendef(execTool, mdFiles, outputDir, asanLib)
+
+def get_arg_parser():
+  parser = argparse.ArgumentParser(
+      description="maplegen")
+  parser.add_argument('-e', '--exe',
+                      help='maplegen_exe_directory')
+  parser.add_argument('-m', '--md',
+                      help='mdfiles_directory')
+  parser.add_argument('-o', '--out',
+                      help='output_defiless_directory')
+  parser.add_argument('-a', '--asan',
+                      help='enabled asan and followed env LD_PRELOAD=xxxx')
+  return parser
+
+def main():
+  parser = get_arg_parser()
+  args = parser.parse_args()
+  if (args.exe is None or args.md is None or args.out is None):
+    print(str(args))
+    parser.print_help()
+    exit(-1)
+
+  Process(args.exe, args.md, args.out, args.asan)
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mapleall/maple_be/mdgen/include/mdgenerator.h b/src/mapleall/maple_be/mdgen/include/mdgenerator.h
new file mode 100644
index 0000000000000000000000000000000000000000..714b19fc45235dbc0c6019fa99eff9bbfb26bfb3
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/include/mdgenerator.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_MDGEN_INCLUDE_MDGENERATOR_H
+#define MAPLEBE_MDGEN_INCLUDE_MDGENERATOR_H
+#include <fstream>
+#include "mdrecord.h"
+#include "mpl_logging.h"
+
+namespace MDGen {
+class MDCodeGen {
+ public:
+  MDCodeGen(const MDClassRange &inputRange, const std::string &oFileDirArg)
+      : curKeeper (inputRange),
+        outputFileDir(oFileDirArg) {}
+  virtual ~MDCodeGen() = default;
+
+  const std::string &GetOFileDir() const {
+    return outputFileDir;
+  }
+  void SetTargetArchName(const std::string &archName) const {
+    targetArchName = archName;
+  }
+
+  void EmitCheckPtr(std::ofstream &outputFile, const std::string &emitName, const std::string &name,
+                    const std::string &ptrType) const;
+  void EmitFileHead(std::ofstream &outputFile, const std::string &headInfo) const;
+  MDClass GetSpecificClass(const std::string &className);
+
+ protected:
+  MDClassRange curKeeper;
+
+ private:
+  static std::string targetArchName;
+  std::string outputFileDir;
+};
+
+class SchedInfoGen : public MDCodeGen {
+ public:
+  SchedInfoGen(const MDClassRange &inputRange, const std::string &oFileDirArg)
+      : MDCodeGen(inputRange, oFileDirArg) {}
+  ~SchedInfoGen() override {
+    if (outFile.is_open()) {
+      outFile.close();
+    }
+  }
+
+  void EmitArchDef();
+  const std::string &GetArchName();
+  void EmitUnitIdDef();
+  void EmitUnitDef();
+  void EmitUnitNameDef();
+  void EmitLatencyDef();
+  void EmitResvDef();
+  void EmitBypassDef();
+  void Run();
+
+ private:
+  std::ofstream outFile;
+};
+} /* namespace MDGen */
+
+#endif /* MAPLEBE_MDGEN_INCLUDE_MDGENERATOR_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/mdgen/include/mdlexer.h b/src/mapleall/maple_be/mdgen/include/mdlexer.h
new file mode 100644
index 0000000000000000000000000000000000000000..020ef877b7af58fef29fbf83a38e05edce4ebc17
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/include/mdlexer.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_MDGEN_INCLUDE_MDLEXER_H
+#define MAPLEBE_MDGEN_INCLUDE_MDLEXER_H
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <unordered_map>
+#include <cstdio>
+#include "mdtokens.h"
+#include "mpl_logging.h"
+#include "types_def.h"
+
+namespace MDGen {
+using namespace maple;
+class MDLexer {
+ public:
+  MDLexer() {
+    keywords.clear();
+    /* input can be improved */
+    (void)keywords.insert(std::make_pair("Def", kMDDef));
+    (void)keywords.insert(std::make_pair("Class", kMDClass));
+    (void)keywords.insert(std::make_pair("DefType", kMDDefType));
+  };
+  ~MDLexer() {
+    if (mdFileInternal.is_open()) {
+      mdFileInternal.close();
+    }
+  };
+
+  MDTokenKind ReturnError() const;
+  MDTokenKind NextToken();
+  MDTokenKind LexToken();
+  MDTokenKind GetTokenIdentifier();
+  MDTokenKind GetTokenConstVal();
+  int ReadOneLine();
+  bool SkipCComment();
+  void SkipALineComment();
+
+  void PrepareFile(const std::string &mdfileName);
+  const std::string &GetStrToken() const {
+    return strToken;
+  }
+  int64_t GetIntVal() const {
+    return intVal;
+  }
+  const std::string &GetStrLine() const {
+    return strLine;
+  }
+  size_t GetStrLineSize() const {
+    return strLine.size();
+  }
+  void RemoveInValidAtBack() {
+    if (strLine.length() == 0) {
+      return;
+    }
+    if (strLine.back() == '\n') {
+      strLine.pop_back();
+    }
+    if (strLine.back() == '\r') {
+      strLine.pop_back();
+    }
+  }
+  MDTokenKind GetCurKind() const {
+    return curKind;
+  }
+  char GetCurChar() {
+    return curPos < GetStrLineSize() ? strLine[curPos] : 0;
+  }
+  char GetNextChar() {
+    ++curPos;
+    return curPos < GetStrLineSize() ? strLine[curPos] : 0;
+  }
+  char ViewNextChar() const {
+    return curPos < GetStrLineSize() ? strLine[curPos] : 0;
+  }
+  char GetCharAt(uint32 pos) {
+    if (pos >=  GetStrLineSize()) {
+      return 0;
+    }
+    return strLine[pos];
+  }
+  int GetLineNumber() const {
+    return lineNumber;
+  }
+
+  MDTokenKind GetHexConst(uint32 digitStartPos, bool isNegative);
+  MDTokenKind GetIntConst(uint32 digitStartPos, bool isNegative);
+  MDTokenKind GetFloatConst();
+
+ private:
+  static constexpr int maxNumLength = 10;
+  std::ifstream *mdFile = nullptr;
+  std::ifstream mdFileInternal;
+  uint32 lineNumber = 0;                                 /* current Processing Line */
+  uint32 curPos = 0;                                         /* Position in a line */
+  std::string strLine = "";                              /* current token line */
+  std::string strToken = "";                             /* store ID,keywords ... */
+  int32 intVal = 0;                                          /* store integer when token */
+  float floatVal = 0;                                    /* store float value when token */
+  MDTokenKind curKind = kMDInvalid;                      /* current token kind */
+  std::unordered_map<std::string, MDTokenKind> keywords; /* store keywords defined for md files */
+};
+} /* namespace MDGen */
+
+#endif /* MAPLEBE_MDGEN_INCLUDE_MDLEXER_H */
diff --git a/src/mapleall/maple_be/mdgen/include/mdparser.h b/src/mapleall/maple_be/mdgen/include/mdparser.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4e449fcaeb0f4ca00b1a30ad7b83a0784c4afa9
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/include/mdparser.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_MDGEN_INCLUDE_MDPARSER_H
+#define MAPLEBE_MDGEN_INCLUDE_MDPARSER_H
+
+#include "mdlexer.h"
+#include "mdrecord.h"
+#include "mempool.h"
+
+namespace MDGen {
+class MDParser {
+ public:
+  MDParser(MDClassRange &newKeeper, maple::MemPool *memPool) : dataKeeper(newKeeper), mdMemPool(memPool) {}
+  ~MDParser() = default;
+
+  bool ParseFile(const std::string &inputFile);
+  bool ParseObjectStart();
+  bool ParseObject();
+  bool IsObjectStart(MDTokenKind k) const;
+  bool ParseDefType();
+  bool ParseMDClass();
+  bool ParseMDClassBody(MDClass &oneClass);
+  bool ParseMDObject();
+  bool ParseMDObjBody(MDObject &curObj);
+  bool ParseIntElement(MDObject &curObj, bool isVec);
+  bool ParseStrElement(MDObject &curObj, bool isVec);
+  bool ParseDefTyElement(MDObject &curObj, bool isVec, const std::set<unsigned int> &childSet);
+  bool ParseDefObjElement(MDObject &curObj, bool isVec, const MDClass &pClass);
+
+  /* error process */
+  bool EmitError(const std::string &errMsg);
+
+ private:
+  MDLexer lexer;
+  MDClassRange &dataKeeper;
+  maple::MemPool *mdMemPool;
+};
+} /* namespace MDGen */
+
+#endif /* MAPLEBE_MDGEN_INCLUDE_MDPARSER_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/mdgen/include/mdrecord.h b/src/mapleall/maple_be/mdgen/include/mdrecord.h
new file mode 100644
index 0000000000000000000000000000000000000000..3f9755ed31963f90118bd0f92408d81cd7cf66d6
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/include/mdrecord.h
@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_MDGEN_INCLUDE_MDREORD_H
+#define MAPLEBE_MDGEN_INCLUDE_MDREORD_H
+
+#include <vector>
+#include <unordered_map>
+#include <map>
+#include <set>
+#include <climits>
+#include "mempool_allocator.h"
+#include "mempool.h"
+#include "mpl_logging.h"
+#include "types_def.h"
+
+/* Define base data structure which is used to store information in  .md files */
+namespace MDGen {
+class MDClass; /* circular dependency */
+
+enum RecordType : maple::uint32 {
+  kClassName,
+  kAnonClassName,
+  kObjectName,
+  kElementName,
+  kIntType,
+  kStringType,
+  kTypeName,
+  kTypeMemberName,
+  kUndefinedStr
+};
+
+struct StrInfo {
+  unsigned int idx;
+  RecordType sType;
+  StrInfo(unsigned int curIdx, RecordType curTy) : idx(curIdx), sType(curTy) {}
+};
+
+class MDElement {
+ public:
+  MDElement() = default;
+  virtual ~MDElement() = default;
+  enum ElementTy : maple::uint32 {
+    kEleIntTy,
+    kEleStrTy,
+    kEleDefTyTy,
+    kEleDefObjTy,
+    kEleVecTy,
+    kEleDefaultTy,
+    kEleInValidTy
+  };
+
+  unsigned int GetContent() const {
+    return DoGetContent();
+  }
+
+  ElementTy GetRecDataTy() const {
+    return eleType;
+  }
+
+ protected:
+  ElementTy eleType = kEleInValidTy;
+
+ private:
+  virtual unsigned int DoGetContent() const = 0;
+};
+
+class DefaultElement : public MDElement {
+ public:
+  DefaultElement() {
+    eleType = kEleDefaultTy;
+  }
+
+  ~DefaultElement() override = default;
+
+ private:
+  unsigned int DoGetContent() const override {
+    CHECK_FATAL(false, "Cannnot load default element's content");
+    return UINT_MAX;
+  }
+};
+
+class IntElement : public MDElement {
+ public:
+  explicit IntElement(unsigned int curVal) : intEleVal(curVal) {
+    eleType = kEleIntTy;
+  }
+
+  ~IntElement() override = default;
+
+ private:
+  unsigned int intEleVal;
+  unsigned int DoGetContent() const override {
+    return intEleVal;
+  }
+};
+
+class StringElement : public MDElement {
+ public:
+  explicit StringElement(unsigned int curIdx) : strElemntIdx(curIdx) {
+    eleType = kEleStrTy;
+  }
+
+  ~StringElement() override = default;
+
+ private:
+  unsigned int strElemntIdx;
+  unsigned int DoGetContent() const override {
+    return strElemntIdx;
+  }
+};
+
+class DefTyElement : public MDElement {
+ public:
+  DefTyElement() {
+    eleType = kEleDefTyTy;
+  }
+
+  ~DefTyElement() override = default;
+
+  bool SetContent(const StrInfo curInfo, const std::set<unsigned int> &childTySet);
+
+ private:
+  unsigned int elementIdx = UINT_MAX;
+  unsigned int DoGetContent() const override {
+    return elementIdx;
+  }
+};
+
+class DefObjElement : public MDElement {
+ public:
+  DefObjElement() {
+    eleType = kEleDefObjTy;
+  }
+
+  ~DefObjElement() override = default;
+
+  bool SetContent(const StrInfo curInfo, const MDClass &parentClass);
+
+ private:
+  unsigned int elementIdx = UINT_MAX;
+  unsigned int DoGetContent() const override {
+    return elementIdx;
+  }
+};
+
+class VecElement : public MDElement {
+ public:
+  explicit VecElement(maple::MemPool &mem) : alloc(&mem), vecData(alloc.Adapter()) {
+    eleType = kEleVecTy;
+  }
+
+  ~VecElement() override = default;
+
+  void appendElement(MDElement *curElement) {
+    vecData.emplace_back(curElement);
+  }
+
+  const maple::MapleVector<MDElement*> GetVecData() const {
+    return vecData;
+  }
+
+  size_t GetVecDataSize() const {
+    return vecData.size();
+  }
+
+ private:
+  maple::MapleAllocator alloc;
+  maple::MapleVector<MDElement*> vecData;
+
+  unsigned int DoGetContent() const override {
+    CHECK_FATAL(false, "Vector element does not have a single content");
+    return UINT_MAX;
+  }
+};
+
+class MDObject {
+ public:
+  MDObject(unsigned int curIdx, MDClass &pClass, maple::MemPool &memPool)
+      : objectIdx(curIdx), parentClass(&pClass), alloc(&memPool), mdElements(alloc.Adapter()) {}
+
+  ~MDObject() = default;
+
+  const MDElement *GetOneMDElement(size_t index) const;
+
+  void AddMDElements(MDElement* curElement) {
+    mdElements.emplace_back(curElement);
+  }
+
+  unsigned int GetIdx() const {
+    return objectIdx;
+  }
+
+  const MDClass *GetParentClass() const {
+    return parentClass;
+  }
+
+ private:
+  unsigned int objectIdx;
+  MDClass *parentClass;
+  maple::MapleAllocator alloc;
+  maple::MapleVector<MDElement*> mdElements;
+};
+
+class MDClass {
+ public:
+  MDClass(unsigned int classIdx, bool isAnonymous) {
+    this->classIdx = classIdx;
+    this->isAnonymous = isAnonymous;
+  }
+  ~MDClass() = default;
+
+  const MDObject &GetOneMDObject(size_t index) const;
+  void AddClassMember(MDObject inputObj);
+  bool IsClassMember(unsigned int curIdx) const;
+  bool IsValidStructEle(RecordType curTy) const;
+  unsigned int GetClassIdx() const {
+    return classIdx;
+  }
+  bool IsAnonymousClass() const {
+    return isAnonymous;
+  }
+  const std::vector<std::pair<uint, bool>> GetFormalTypes() const {
+    return formalTypes;
+  }
+  const std::set<unsigned int> GetchildObjNames() const {
+    return childObjNames;
+  }
+  size_t GetFormalTypeSize() const {
+    return formalTypes.size();
+  }
+  size_t GetMDObjectSize() const {
+    return mdObjects.size();
+  }
+  void BuildFormalTypes(unsigned int memberIdx, bool isVec);
+
+ private:
+  unsigned int classIdx = 0;
+  bool isAnonymous = false;
+  std::vector<MDObject> mdObjects;
+  std::vector<std::pair<uint, bool>> formalTypes;
+  std::set<unsigned int> childObjNames;
+};
+
+class MDClassRange {
+ public:
+  explicit MDClassRange(std::string module) : moduleName(module) {
+    stringTable.clear();
+    stringHashTable.clear();
+    /* init common types such as unsigned int ,string , float */
+    std::set<unsigned int> initTypes;
+    AddDefinedType(CreateStrInTable("int", kIntType), initTypes);
+    AddDefinedType(CreateStrInTable("string", kStringType), initTypes);
+  }
+  ~MDClassRange() = default;
+
+  StrInfo GetStrInTable(const std::string &inStr);
+  RecordType GetStrTyByIdx(size_t curIdx);
+  const std::string &GetStrByIdx(size_t curIdx);
+  void AddMDClass(MDClass curClass);
+  MDClass GetOneMDClass(unsigned int givenIdx);
+  std::set<unsigned int> GetOneSpcType(unsigned int givenTyIdx);
+  size_t GetStringTableSize() const {
+    return stringTable.size();
+  }
+  unsigned int CreateStrInTable(const std::string &inStr, RecordType curTy);
+  void ModifyStrTyInTable(const std::string &inStr, RecordType newTy);
+  void AddDefinedType(unsigned int typesName, std::set<unsigned int> typesSet);
+  void FillMDClass(unsigned int givenIdx, const MDObject &insertObj);
+
+ private:
+  std::string moduleName;
+  std::unordered_map<std::string, StrInfo> stringHashTable;
+  std::vector<std::string> stringTable;
+  unsigned int totalStr = 0;
+  std::unordered_map<uint, std::set<unsigned int>> definedTypes;
+  std::unordered_map<uint, MDClass> allClasses;
+};
+} /* namespace MDGen */
+
+#endif /* MAPLEBE_MDGEN_INCLUDE_MDREORD_H */
diff --git a/src/mapleall/maple_be/mdgen/include/mdtokens.h b/src/mapleall/maple_be/mdgen/include/mdtokens.h
new file mode 100644
index 0000000000000000000000000000000000000000..41a703feead3d2add9f6ee522d429112860e3dfd
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/include/mdtokens.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEBE_MDGEN_INCLUDE_MDTOKENS_H
+#define MAPLEBE_MDGEN_INCLUDE_MDTOKENS_H
+enum MDTokenKind {
+  /* special symbols */
+  kMDError,
+  kMDEOF,
+  kMDInvalid,
+
+  /* normal symbols */
+  kMDOpenParen,           /* ( */
+  kMDCloseParen,          /* ) */
+  kMDOpenBrace,           /* { */
+  kMDCloseBrace,          /* } */
+  kMDOpenSquare,          /* [ */
+  kMDCloseSquare,         /* ] */
+  kMDEqual,               /* = */
+  kMDSemi,                /* ; */
+  kMDComma,               /* , */
+  kMDColon,               /* : */
+  kMDLess,                /* < */
+  kMDGreater,             /* > */
+  kMDLgAnd,               /* & */
+  kMDLgOr,                /* | */
+
+  kMDIdentifier,
+  /* const values */
+  kMDIntVal,
+  kMDFloatVal,
+  kMDDoubleVal,
+
+  /* keywords */
+  kMDDef,
+  kMDClass,
+  kMDAnonClass,
+  kMDDefType,
+};
+
+#endif /* MAPLEBE_MDGEN_INCLUDE_MDTOKENS_H */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/mdgen/src/mdgenerator.cpp b/src/mapleall/maple_be/mdgen/src/mdgenerator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..649072f934643556d71bc0ec2a6be0eebe1d5c11
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/src/mdgenerator.cpp
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <cstdio>
+#include <unistd.h>
+#include <iomanip>
+#include <algorithm>
+#include "mdgenerator.h"
+
+namespace MDGen {
+std::string MDCodeGen::targetArchName = "";
+
+void MDCodeGen::EmitCheckPtr(std::ofstream &outputFile, const std::string &emitName, const std::string &name,
+                             const std::string &ptrType) const {
+  outputFile << "if(" << emitName << " == nullptr) {\n" <<
+                "  maple::LogInfo::MapleLogger(maple::kLlErr) << \"" << ptrType << " allocation for " << name <<
+                " failed.\" << std::endl;\n" << "}\n" <<
+                "ASSERT(" << emitName << ", \"" << ptrType << " allocation for " << name <<
+                " failed.\");\n" << "\n";
+}
+
+void MDCodeGen::EmitFileHead(std::ofstream &outputFile, const std::string &headInfo) const {
+  outputFile << "/* " << targetArchName << " " << headInfo << " definition : */\n";
+}
+
+MDClass MDCodeGen::GetSpecificClass(const std::string &className) {
+  unsigned int classIdx = curKeeper.GetStrInTable(className).idx;
+  CHECK_FATAL(classIdx != UINT_MAX, "Load Class Failed!");
+  return curKeeper.GetOneMDClass(classIdx);
+}
+
+const std::string &SchedInfoGen::GetArchName() {
+  MDClass archClass = GetSpecificClass("ArchitectureName");
+  const MDObject &archObj = archClass.GetOneMDObject(0);
+  auto *archStrEle = static_cast<const StringElement*>(archObj.GetOneMDElement(0));
+  return curKeeper.GetStrByIdx(archStrEle->GetContent());
+}
+
+void SchedInfoGen::EmitArchDef() {
+  MDClass parallelClass = GetSpecificClass("Parallelism");
+  CHECK_FATAL(parallelClass.GetMDObjectSize() > 0, "specific class failed, maybe illegal input");
+  const MDObject &paralleObj = parallelClass.GetOneMDObject(0);
+  auto *parallelEle = static_cast<const IntElement*>(paralleObj.GetOneMDElement(0));
+  outFile.open(GetOFileDir() + "/mplad_arch_define.def", std::ios::out);
+  EmitFileHead(outFile, "Architecture");
+  outFile << "SetMaxParallelism(" << parallelEle->GetContent() << ");\n";
+  outFile.close();
+}
+
+void SchedInfoGen::EmitUnitIdDef() {
+  MDClass unitClass = GetSpecificClass("Unit");
+  outFile.open(GetOFileDir() + "/mplad_unit_id.def", std::ios::out);
+  CHECK_FATAL(outFile.is_open(), "Failed to open output file: %s/mplad_unit_id.def", GetOFileDir().c_str());
+  EmitFileHead(outFile, "function unit ID");
+  for (auto unitIdx : unitClass.GetchildObjNames()) {
+    outFile << "  " << curKeeper.GetStrByIdx(unitIdx) << ",\n";
+  }
+  outFile.close();
+}
+
+void SchedInfoGen::EmitUnitNameDef() {
+  MDClass unitClass = GetSpecificClass("Unit");
+  outFile.open(GetOFileDir() + "/mplad_unit_name.def", std::ios::out);
+  CHECK_FATAL(outFile.is_open(), "Failed to open output file: %s/mplad_unit_name.def", GetOFileDir().c_str());
+  EmitFileHead(outFile, "function unit name");
+  for (auto unitIdx : unitClass.GetchildObjNames()) {
+    std::string unitPureName = curKeeper.GetStrByIdx(unitIdx);
+    std::string unitPrefix = "kUnitId";
+    if (unitPrefix.length() < unitPureName.length()) {
+      unitPureName = unitPureName.substr(unitPrefix.length());
+      outFile << "\"" << unitPureName << "\",\n";
+    }
+  }
+  outFile.close();
+}
+
+void SchedInfoGen::EmitUnitDef() {
+  MDClass unitClass = GetSpecificClass("Unit");
+  outFile.open(GetOFileDir() + "/mplad_unit_define.def", std::ios::out);
+  CHECK_FATAL(outFile.is_open(), "Failed to open output file: %s/mplad_unit_define.def", GetOFileDir().c_str());
+  EmitFileHead(outFile, "function units ");
+  bool isUnitNumDef = false;
+  for (size_t i = 0; i < unitClass.GetMDObjectSize(); ++i) {
+    const MDObject &singleUnit = unitClass.GetOneMDObject(i);
+    if (singleUnit.GetOneMDElement(0)->GetRecDataTy() == MDElement::kEleDefaultTy) {
+      continue;
+    }
+    auto *curUnitTy = static_cast<const DefTyElement*>(singleUnit.GetOneMDElement(0));
+    std::string curUnitName = curKeeper.GetStrByIdx(singleUnit.GetIdx());
+    std::string emitUnitName = "instance" + curUnitName;
+    std::string unitPrefix = "Unit *" + emitUnitName + " = new Unit(";
+    if (!isUnitNumDef) {
+      outFile << "\n";
+      outFile << "const unsigned int kunitNum = 2;\n";
+      isUnitNumDef = true;
+    }
+    outFile << unitPrefix;
+    if (curUnitTy->GetContent() == curKeeper.GetStrInTable("Primary").idx) {
+      outFile << curUnitName << ");\n";
+    } else {
+      std::string unitTypeStr = "";
+      if (curUnitTy->GetContent() == curKeeper.GetStrInTable("And").idx) {
+        unitTypeStr = "kUnitTypeAnd";
+      } else if (curUnitTy->GetContent() == curKeeper.GetStrInTable("Or").idx) {
+        unitTypeStr = "kUnitTypeOr";
+      }
+      CHECK_FATAL(unitTypeStr.size() != 0, "Haven't support this kind of Unit yet");
+      outFile << unitTypeStr << ", " << curUnitName << ", kunitNum,\n";
+      outFile << std::setiosflags(std::ios::right) << std::setw(unitPrefix.length()) << std::setfill(' ') << " ";
+      unsigned int dependUnitsIndex = 1;
+      auto *dependUnitEle = static_cast<const VecElement*>(singleUnit.GetOneMDElement(dependUnitsIndex));
+      for (size_t k = 0; k < dependUnitEle->GetVecDataSize(); ++k) {
+        auto *dependUnit = static_cast<DefObjElement*>(dependUnitEle->GetVecData()[k]);
+        outFile << "instance" <<  curKeeper.GetStrByIdx(dependUnit->GetContent());
+        if (k != dependUnitEle->GetVecDataSize() - 1) {
+          outFile << ", ";
+        }
+      }
+      outFile << ");\n";
+    }
+    EmitCheckPtr(outFile, emitUnitName, curUnitName, "Unit");
+  }
+  outFile.close();
+}
+
+void SchedInfoGen::EmitLatencyDef() {
+  MDClass resvClass = GetSpecificClass("Reservation");
+  outFile.open(GetOFileDir() + "/mplad_latency_type.def", std::ios::out);
+  CHECK_FATAL(outFile.is_open(), "Failed to open output file: %s/mplad_latency_type.def", GetOFileDir().c_str());
+  EmitFileHead(outFile, " latency type definition ");
+  for (auto resvIdx : resvClass.GetchildObjNames()) {
+    outFile << "  " << curKeeper.GetStrByIdx(resvIdx) << ",\n";
+  }
+  outFile.close();
+}
+
+void SchedInfoGen::EmitResvDef() {
+  MDClass resvClass = GetSpecificClass("Reservation");
+  outFile.open(GetOFileDir() + "/mplad_reservation_define.def", std::ios::out);
+  CHECK_FATAL(outFile.is_open(), "Failed to open output file: %s/mplad_reservation_define.def",
+              GetOFileDir().c_str());
+  EmitFileHead(outFile, "reservations");
+  for (size_t i = 0; i < resvClass.GetMDObjectSize(); ++i) {
+    const MDObject &singleResv = resvClass.GetOneMDObject(i);
+    if (singleResv.GetOneMDElement(0)->GetRecDataTy() == MDElement::kEleDefaultTy) {
+      continue;
+    }
+    auto *curResvLatency = static_cast<const IntElement*>(singleResv.GetOneMDElement(0));
+    std::string curResvName = curKeeper.GetStrByIdx(singleResv.GetIdx());
+    std::string emitResvName = "resvInst" + curResvName;
+    std::string resvPrefix = "Reservation *" + emitResvName + " = new Reservation(";
+    outFile << resvPrefix << curResvName << ", " << curResvLatency->GetContent() << ", ";
+    if (singleResv.GetOneMDElement(1)->GetRecDataTy() == MDElement::kEleDefaultTy) {
+      outFile << "0);\n";
+    } else {
+      size_t dependUnitsIndex = 1;
+      auto *dependUnitEle = static_cast<const VecElement*>(singleResv.GetOneMDElement(dependUnitsIndex));
+      outFile << dependUnitEle->GetVecDataSize() << ",\n";
+      for (size_t k = 0; k < dependUnitEle->GetVecDataSize(); ++k) {
+        auto *dependUnit = static_cast<DefObjElement*>(dependUnitEle->GetVecData()[k]);
+        if (curKeeper.GetStrByIdx(dependUnit->GetContent()) != "nothing") {
+          outFile << std::setiosflags(std::ios::right) << std::setw(resvPrefix.length()) << std::setfill(' ')
+                  << "GetUnitByUnitId(" << curKeeper.GetStrByIdx(dependUnit->GetContent()) << ")";
+        } else {
+          outFile << std::setiosflags(std::ios::right) << std::setw(resvPrefix.length()) << std::setfill(' ')
+                  << "nullptr";
+        }
+        if (k < dependUnitEle->GetVecDataSize() - 1) {
+          outFile << ",\n";
+        }
+      }
+      outFile << ");\n";
+    }
+    EmitCheckPtr(outFile, emitResvName, curResvName, "Reservation");
+  }
+  outFile.close();
+}
+
+void SchedInfoGen::EmitBypassDef() {
+  MDClass bypassClass = GetSpecificClass("Bypass");
+  outFile.open(GetOFileDir() + "/mplad_bypass_define.def", std::ios::out);
+  for (size_t i = 0; i < bypassClass.GetMDObjectSize(); ++i) {
+    const MDObject &singleBypass = bypassClass.GetOneMDObject(i);
+    if (singleBypass.GetOneMDElement(0)->GetRecDataTy() == MDElement::kEleDefaultTy) {
+      continue;
+    }
+    constexpr size_t fromVecIndex = 1;
+    constexpr size_t toVecIndex = 2;
+    constexpr size_t curBpTyIndex = 3;
+    auto *bpTyEle = singleBypass.GetOneMDElement(curBpTyIndex);
+    std::string curBypassTy = (bpTyEle->GetRecDataTy() == MDElement::kEleDefaultTy) ?
+        "" :  curKeeper.GetStrByIdx(bpTyEle->GetContent());
+    transform(curBypassTy.begin(), curBypassTy.end(), curBypassTy.begin(), ::toupper);
+
+    CHECK_FATAL(singleBypass.GetOneMDElement(0)->GetRecDataTy() == MDElement::ElementTy::kEleIntTy, "Bypass illegal");
+    CHECK_FATAL(singleBypass.GetOneMDElement(fromVecIndex)->GetRecDataTy() == MDElement::ElementTy::kEleVecTy,
+        "Bypass illegal");
+    CHECK_FATAL(singleBypass.GetOneMDElement(toVecIndex)->GetRecDataTy() == MDElement::ElementTy::kEleVecTy,
+        "Bypass illegal");
+
+    unsigned int bypassNum = static_cast<const IntElement*>(singleBypass.GetOneMDElement(0))->GetContent();
+    auto *fromVec = static_cast<const VecElement*>(singleBypass.GetOneMDElement(fromVecIndex));
+    auto *toVec = static_cast<const VecElement*>(singleBypass.GetOneMDElement(toVecIndex));
+    for (auto itTo : toVec->GetVecData()) {
+      for (auto itFrom : fromVec->GetVecData()) {
+        auto *fromResv = static_cast<DefObjElement*>(itFrom);
+        auto *toResv = static_cast<DefObjElement*>(itTo);
+        outFile << "ADD" << curBypassTy << "BYPASS(" << curKeeper.GetStrByIdx(fromResv->GetContent()) << ", "
+                << curKeeper.GetStrByIdx(toResv->GetContent()) << ", " << bypassNum <<");\n";
+      }
+    }
+  }
+  outFile.close();
+}
+
+void SchedInfoGen::Run() {
+  SetTargetArchName(GetArchName());
+  EmitArchDef();
+  EmitResvDef();
+  EmitBypassDef();
+  EmitUnitDef();
+  EmitUnitNameDef();
+  EmitLatencyDef();
+  EmitUnitIdDef();
+}
+} /* namespace MDGen */
diff --git a/src/mapleall/maple_be/mdgen/src/mdlexer.cpp b/src/mapleall/maple_be/mdgen/src/mdlexer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1b1db44aa0fe407fe91993cde89526a88c63a48e
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/src/mdlexer.cpp
@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <cerrno>
+#include "mdlexer.h"
+
+namespace MDGen {
+void MDLexer::PrepareFile(const std::string &mdfileName) {
+  mdFileInternal.open(mdfileName);
+  if (!mdFileInternal.is_open()) {
+    CHECK_FATAL(false, "Open target file failed");
+  }
+  mdFile = &mdFileInternal;
+}
+
+MDTokenKind MDLexer::ReturnError() const {
+  maple::LogInfo::MapleLogger() << "Unexpect character at Line" << lineNumber << "\n";
+  return kMDError;
+}
+
+int MDLexer::ReadOneLine() {
+  if (mdFile == nullptr) {
+    strLine = "";
+    return -1;
+  }
+  curPos = 0;
+  if (!std::getline(*mdFile, strLine)) { /* EOF */
+    strLine = "";
+    mdFile = nullptr;
+    return -1;
+  }
+  RemoveInValidAtBack();
+  return GetStrLineSize();
+}
+
+MDTokenKind MDLexer::NextToken() {
+  curKind = LexToken();
+  return curKind;
+}
+
+MDTokenKind MDLexer::LexToken() {
+  char c = GetCurChar();
+  while (c == ' ' || c == '\t') { /* skip space && tab */
+    c = GetNextChar();
+  }
+  while (c == 0) {
+    if (ReadOneLine() < 0) {
+      return kMDEOF;
+    }
+    lineNumber++;
+    c = GetCurChar();
+    while (c == ' ' || c == '\t') {
+      c = GetNextChar();
+    }
+  }
+  curPos++;
+  switch (c) {
+    case '(':
+      return kMDOpenParen;
+    case ')':
+      return kMDCloseParen;
+    case '{':
+      return kMDOpenBrace;
+    case '}':
+      return kMDCloseBrace;
+    case '[':
+      return kMDOpenSquare;
+    case ']':
+      return kMDCloseSquare;
+    case '<':
+      return kMDLess;
+    case '>':
+      return kMDGreater;
+    case ';':
+      return kMDSemi;
+    case ',':
+      return kMDComma;
+    case ':':
+      return kMDColon;
+    case '=':
+      return kMDEqual;
+    case '&':
+      return kMDLgAnd;
+    case '|':
+      return kMDLgOr;
+    case '0': /* start handling number */
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '-':
+      curPos--; /* support HEX AND INTERGER at present */
+      return GetTokenConstVal();
+    case '/': { /* handle comment; */
+      char cn = GetCurChar();
+      if (cn == '/') {
+        SkipALineComment();
+      } else if (cn == '*') {
+        if (!SkipCComment()) {
+          return kMDError;
+        }
+      } else {
+        return ReturnError();
+      }
+      return LexToken();
+    }
+    default:
+      if (isalpha(c) || c == '_') {
+        return GetTokenIdentifier(); /* identifier need to be modify */
+      }
+      return ReturnError();
+  }
+}
+
+MDTokenKind MDLexer::GetTokenConstVal() {
+  bool negative = false;
+  char curC = GetCurChar();
+  if (curC == '-') {
+    curC = GetNextChar();
+    /* have Special Float const? */
+    negative = true;
+  }
+  const uint32 hexPrefixLength = 2;
+  if (strLine.compare(curPos, hexPrefixLength, "0x") == 0) {
+    curPos += hexPrefixLength;
+    return GetHexConst(curPos, negative);
+  }
+  uint32 digitStartPos = curPos;
+  char digitStartC = GetCurChar();
+  while (isdigit(curC)) {
+    curC = GetNextChar();
+  }
+  if (!isdigit(digitStartC) && curC != '.') {
+    return kMDInvalid;
+  }
+  if (curC != '.' && curC != 'e' && curC != 'E') {
+    return  GetIntConst(digitStartPos, negative);
+  }
+  return GetFloatConst();
+}
+
+MDTokenKind MDLexer::GetHexConst(uint32 digitStartPos, bool isNegative) {
+  if (digitStartPos >= strLine.length()) {
+    return ReturnError();
+  }
+  char c = GetCurChar();
+  if (!isxdigit(c)) {
+    return kMDInvalid;
+  }
+  int loopDepth = 0;
+  while (isxdigit(c)) {
+    c = GetNextChar();
+    ++loopDepth;
+    if (loopDepth > maxNumLength) {
+      return ReturnError();
+    }
+  }
+  std::string hexStr = strLine.substr(digitStartPos, curPos - digitStartPos);
+  const char *hexStrPtr = hexStr.c_str();
+  errno = 0;
+  constexpr int hexInDec = 16;
+  intVal = static_cast<int32>(std::strtoll(hexStrPtr, nullptr, hexInDec));
+  if (errno == EINVAL) {  /* Invalid hexadecimal number */
+    return ReturnError();
+  }
+  if (errno == ERANGE) {
+    errno = 0;
+    intVal = static_cast<uint32>(std::strtoll(hexStrPtr, nullptr, hexInDec));
+    if (errno == EINVAL) { /* Invalid hexadecimal number */
+      return ReturnError();
+    }
+    if (errno == ERANGE) {  /* input number is out of range */
+      return ReturnError();
+    }
+  }
+  if (isNegative) {
+    intVal = -intVal;
+  }
+  return kMDIntVal;
+}
+
+MDTokenKind MDLexer::GetIntConst(uint32 digitStartPos, bool isNegative) {
+  char c = GetCharAt(digitStartPos);
+  /* no ULL LL suffix at present */
+  int loopDepth = 0;
+  while (isdigit(c)) {
+    c = GetNextChar();
+    ++loopDepth;
+    if (loopDepth > maxNumLength) {
+      return ReturnError();
+    }
+  }
+  curPos--;
+  if (digitStartPos >= strLine.length() || digitStartPos > curPos) {
+    return ReturnError();
+  }
+  std::string intStr = strLine.substr(digitStartPos, curPos - digitStartPos);
+  const char *intStrPtr = intStr.c_str();
+  errno = 0;
+  constexpr int decInDec = 10;
+  intVal = static_cast<int32>(std::strtoll(intStrPtr, nullptr, decInDec));
+  if (errno == ERANGE) {
+    return ReturnError();
+  }
+  if (isNegative) {
+    intVal = -intVal;
+  }
+  return kMDIntVal;
+}
+
+MDTokenKind MDLexer::GetFloatConst() {
+  floatVal = 0;
+  return kMDInvalid;
+}
+
+MDTokenKind MDLexer::GetTokenIdentifier() {
+  --curPos;
+  uint32 startPos = curPos;
+  char curC = GetCurChar();
+
+  while (isalnum(curC) || curC == '_' || curC == '-' || curC < 0) {
+    curC = GetNextChar();
+  }
+  if (startPos >= strLine.length()) {
+    return ReturnError();
+  }
+  strToken = strLine.substr(startPos, curPos - startPos);
+  auto it = keywords.find(strToken);
+  if (it != keywords.end()) {
+    return it->second;
+  }
+  return kMDIdentifier;
+}
+
+void MDLexer::SkipALineComment() {
+  while (curPos < GetStrLineSize()) {
+    curPos++;
+  }
+  /* if comment is required to be stored. it can be done here */
+}
+
+bool MDLexer::SkipCComment() {
+  bool startAnewLine = false;
+  char commentNext;
+  while (true) {
+    if (!startAnewLine) {
+      commentNext = GetNextChar();
+    } else {
+      commentNext = GetCurChar();
+      startAnewLine = false;
+    }
+    switch (commentNext) {
+      case 0:
+        if (ReadOneLine() < 0) {
+          ASSERT(false, "Untermianted comment");
+          return false;
+        }
+        ++lineNumber;
+        startAnewLine = true;
+        break;
+      case '*':
+        commentNext = GetNextChar();
+        if (commentNext == '/') {
+          ++curPos;
+          return true;
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  return false;
+}
+}
diff --git a/src/mapleall/maple_be/mdgen/src/mdmain.cpp b/src/mapleall/maple_be/mdgen/src/mdmain.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..36e27efbf271bc62dbbdf8a9a8c0eedf38f8d715
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/src/mdmain.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <getopt.h>
+
+#include "mdgenerator.h"
+#include "mdparser.h"
+#include "mpl_sighandler.h"
+
+using namespace MDGen;
+namespace {
+  bool isGenSched = false;
+  std::string schedSrcPath = "";
+  std::string oFileDir = "";
+}
+
+static int PrintHelpAndExit() {
+  maple::LogInfo::MapleLogger() << "Maplegen is usd to process md files and " <<
+                            "generate architecture specific information in def files\n" <<
+                            "usage: ./mplgen xxx.md outputdirectroy\n";
+  return 1;
+}
+
+void ParseCommandLine(int argc, char **argv) {
+  int opt;
+  int gOptionIndex = 0;
+  std::string optStr = "s:o:";
+  static struct option longOptions[] = {
+      {"genSchdInfo", required_argument, nullptr, 's'},
+      {"outDirectory", required_argument, nullptr, 'o'},
+      {nullptr, 0, nullptr, 0}
+  };
+  while ((opt = getopt_long(argc, argv, optStr.c_str(), longOptions, &gOptionIndex)) != -1) {
+    switch (opt) {
+      case 's':
+        isGenSched = true;
+        schedSrcPath = optarg;
+        break;
+      case 'o':
+        oFileDir = optarg;
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+bool GenSchedFiles(const std::string &fileName, const std::string &fileDir) {
+  maple::MemPool *schedInfoMemPool = memPoolCtrler.NewMemPool("schedInfoMp", false /* isLcalPool */);
+  MDClassRange moduleData("Schedule");
+  MDParser parser(moduleData, schedInfoMemPool);
+  if (!parser.ParseFile(fileName)) {
+    delete schedInfoMemPool;
+    return false;
+  }
+  SchedInfoGen schedEmiiter(moduleData, fileDir);
+  schedEmiiter.Run();
+  delete schedInfoMemPool;
+  return true;
+}
+
+int main(int argc, char **argv) {
+  SigHandler::EnableAll();
+
+  constexpr int minimumArgNum = 2;
+  if (argc <= minimumArgNum) {
+    return PrintHelpAndExit();
+  }
+  ParseCommandLine(argc, argv);
+  if (isGenSched) {
+    if (!GenSchedFiles(schedSrcPath, oFileDir)) {
+      return 1;
+    }
+  }
+  return 0;
+}
diff --git a/src/mapleall/maple_be/mdgen/src/mdparser.cpp b/src/mapleall/maple_be/mdgen/src/mdparser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c1bd058c6d93388c2d0b49ef1f6253f65c8ea364
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/src/mdparser.cpp
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mdparser.h"
+
+namespace MDGen {
+bool MDParser::ParseFile(const std::string &inputFile) {
+  lexer.PrepareFile(inputFile);
+  if (!ParseObjectStart()) {
+    return false;
+  }
+  if (lexer.GetCurKind() == kMDEOF) {
+    return true;
+  }
+  return EmitError("Unexpected input at begin");
+}
+
+bool MDParser::IsObjectStart(MDTokenKind k) const {
+  return (k == kMDDef || k == kMDClass || k == kMDDefType);
+}
+
+bool MDParser::ParseObjectStart() {
+  while (IsObjectStart(lexer.NextToken())) {
+    if (!ParseObject()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MDParser::ParseObject() {
+  switch (lexer.GetCurKind()) {
+    case kMDDefType:
+      return ParseDefType();
+    case kMDClass:
+      return ParseMDClass();
+    case kMDDef:
+      return ParseMDObject();
+    default:
+      return EmitError("Unexpected key word at start");
+  }
+}
+
+bool MDParser::ParseDefType() {
+  if (lexer.NextToken() != kMDIdentifier) {
+    return EmitError("Expect a name after a specific type defined");
+  }
+  unsigned int defTypeIdx = dataKeeper.CreateStrInTable(lexer.GetStrToken(), kTypeName);
+  if (defTypeIdx == UINT_MAX) {
+    return EmitError("InValid defType is defined");
+  }
+  if (lexer.NextToken() != kMDEqual) {
+    return EmitError("Expect a equal when a specific type is going to be instantiated");
+  }
+  std::set<unsigned int> defTypeMembers;
+  while (lexer.NextToken() != kMDSemi) {
+    switch (lexer.GetCurKind()) {
+      case kMDIdentifier: {
+        unsigned int defTypeMemberIdx = dataKeeper.CreateStrInTable(lexer.GetStrToken(), kTypeMemberName);
+        if (defTypeMemberIdx == UINT_MAX || !defTypeMembers.insert(defTypeMemberIdx).second) {
+          return EmitError("InValid defType member is defined");
+        }
+        break;
+      }
+      case kMDComma:
+        break;
+      default:
+        return  EmitError("Unexpected token kind");
+    }
+  }
+  dataKeeper.AddDefinedType(defTypeIdx, defTypeMembers);
+  return (lexer.GetCurKind() == kMDSemi) ? true : EmitError("Expected an ending with a semicolon");
+}
+
+bool MDParser::ParseMDClass() {
+  if (lexer.NextToken() != kMDIdentifier) {
+    return EmitError("Expect a name after a specific class defined");
+  }
+  unsigned int classIdx = dataKeeper.CreateStrInTable(lexer.GetStrToken(), kClassName);
+  if (classIdx == UINT_MAX) {
+    return EmitError("InValid class name. Please change a class name");
+  }
+  bool isAnon = true;
+  if (lexer.NextToken() == kMDColon) {
+    isAnon = false;
+    if (lexer.NextToken() != kMDIdentifier) {
+      return EmitError("Expect a name after a specific class defined");
+    }
+    if (lexer.GetStrToken() != "string") {
+      return EmitError("Only Support string as a class name type at current stage");
+    }
+    static_cast<void>(lexer.NextToken());
+  }
+  if (isAnon) {
+    dataKeeper.ModifyStrTyInTable(lexer.GetStrToken(), kAnonClassName);
+  }
+  MDClass oneMDclass(classIdx, isAnon);
+  if (lexer.GetCurKind() != kMDLess) {
+    return EmitError("Expect a 'less' before class structure being defined");
+  }
+
+  while (lexer.NextToken() != kMDGreater) {
+    if (!ParseMDClassBody(oneMDclass)) {
+      return false;
+    }
+  }
+  dataKeeper.AddMDClass(oneMDclass);
+  return (lexer.NextToken() == kMDSemi) ? true : EmitError("Expected an ending with a semicolon");
+}
+
+bool MDParser::ParseMDClassBody(MDClass &oneClass) {
+  switch (lexer.GetCurKind()) {
+    case kMDIdentifier: {
+      StrInfo defTypeInfo = dataKeeper.GetStrInTable(lexer.GetStrToken());
+      if (defTypeInfo.idx == UINT_MAX || !oneClass.IsValidStructEle(defTypeInfo.sType)) {
+        return EmitError("Expect a defined Type to be a memeber of a class");
+      }
+      bool isVec = false;
+      if (lexer.ViewNextChar() == '[') {
+        if (lexer.NextToken() != kMDOpenSquare || lexer.NextToken() != kMDCloseSquare) {
+          return EmitError("Expect a \"[]\" to represent a list element");
+        }
+        isVec = true;
+      }
+      oneClass.BuildFormalTypes(defTypeInfo.idx, isVec);
+      break;
+    }
+    case kMDComma:
+      break;
+    default:
+      return EmitError("Unexpected token kind");
+  }
+  return true;
+}
+
+bool MDParser::ParseMDObject() {
+  if (lexer.NextToken() != kMDIdentifier) {
+    return EmitError("Expect a name after a specific object defined");
+  }
+  StrInfo parentInfo = dataKeeper.GetStrInTable(lexer.GetStrToken());
+  if (parentInfo.idx == UINT_MAX || (parentInfo.sType != kClassName && parentInfo.sType != kAnonClassName)) {
+    return EmitError("A new object should be belong to a defined class");
+  }
+  MDClass parentClass = dataKeeper.GetOneMDClass(parentInfo.idx);
+  unsigned int objectIdx = UINT_MAX;
+  if (!parentClass.IsAnonymousClass()) {
+    if (lexer.NextToken() != kMDColon) {
+      return EmitError("Expect a colon when a object name is going to be defined");
+    }
+    if (lexer.NextToken() != kMDIdentifier) {
+      return EmitError("Expect a name for a specific object");
+    }
+    objectIdx = dataKeeper.CreateStrInTable(lexer.GetStrToken(), kObjectName);
+    if (objectIdx == UINT_MAX) {
+      return EmitError("InValid ObjectName!");
+    }
+  }
+  MDObject *curObj = mdMemPool->New<MDObject>(objectIdx, parentClass, *mdMemPool);
+  if (lexer.NextToken() != kMDOpenBrace) {
+    return EmitError("Expect a OpenBrace before a object body is defined");
+  }
+  if (!ParseMDObjBody(*curObj)) {
+    return false;
+  }
+  dataKeeper.FillMDClass(parentInfo.idx, *curObj);
+  return (lexer.NextToken() == kMDSemi) ? true : EmitError("Expected an ending with a semicolon");
+}
+
+bool MDParser::ParseMDObjBody(MDObject &curObj) {
+  bool hasDefault = false;
+  for (size_t i = 0; i < curObj.GetParentClass()->GetFormalTypeSize(); ++i) {
+    if (hasDefault) {
+      DefaultElement *defaultEle = mdMemPool->New<DefaultElement>();
+      curObj.AddMDElements(defaultEle);
+      continue;
+    }
+    MDTokenKind curKind = lexer.NextToken();
+    if (i != 0 && (curKind != kMDComma && curKind != kMDCloseBrace)) {
+      return EmitError("Unexpected Gramma when define a object");
+    }
+    if (curKind == kMDComma) {
+      curKind = lexer.NextToken();
+    }
+    if (curKind == kMDCloseBrace) {
+      hasDefault = true;
+      DefaultElement *defaultEle = mdMemPool->New<DefaultElement>();
+      curObj.AddMDElements(defaultEle);
+      continue;
+    }
+    unsigned int typeIdx = curObj.GetParentClass()->GetFormalTypes().at(i).first;
+    bool isVec = curObj.GetParentClass()->GetFormalTypes().at(i).second;
+    if (dataKeeper.GetStrTyByIdx(typeIdx) == kIntType) {
+      if (!ParseIntElement(curObj, isVec)) {
+        return false;
+      }
+    } else if (dataKeeper.GetStrTyByIdx(typeIdx) == kStringType) {
+      if (!ParseStrElement(curObj, isVec)) {
+        return false;
+      }
+    } else if (dataKeeper.GetStrTyByIdx(typeIdx) == kTypeName) {
+      std::set<unsigned int> childSet = dataKeeper.GetOneSpcType(typeIdx);
+      if (!ParseDefTyElement(curObj, isVec, childSet)) {
+        return false;
+      }
+    } else if (dataKeeper.GetStrTyByIdx(typeIdx) == kClassName) {
+      MDClass pClass = dataKeeper.GetOneMDClass(typeIdx);
+      if (!ParseDefObjElement(curObj, isVec, pClass)) {
+        return false;
+      }
+    }
+  }
+  if (lexer.GetCurKind() == kMDCloseBrace) {
+    return true;
+  }
+  return (lexer.NextToken() != kMDCloseBrace) ? EmitError("Expect a CloseBrace as end of object definition") : true;
+}
+
+bool MDParser::ParseIntElement(MDObject &curObj, bool isVec) {
+  if (isVec) {
+    if (lexer.GetCurKind() != kMDOpenSquare) {
+      return EmitError("Expect a OpenSquare before a list element defined");
+    }
+
+    VecElement *curEle = mdMemPool->New<VecElement>(*mdMemPool);
+    while (lexer.NextToken() != kMDCloseSquare) {
+      switch (lexer.GetCurKind()) {
+        case kMDIntVal: {
+          IntElement *singleEle = mdMemPool->New<IntElement>(lexer.GetIntVal());
+          curEle->appendElement(singleEle);
+          break;
+        }
+        case kMDComma:
+          break;
+        default:
+          return EmitError("Unexpected token kind");
+      }
+    }
+    curObj.AddMDElements(curEle);
+  } else {
+    if (lexer.GetCurKind() != kMDIntVal) {
+      return EmitError("Expect a integer elemet as defined");
+    }
+    IntElement *curEle = mdMemPool->New<IntElement>(lexer.GetIntVal());
+    curObj.AddMDElements(curEle);
+  }
+  return true;
+}
+
+bool MDParser::ParseStrElement(MDObject &curObj, bool isVec) {
+  if (isVec) {
+    if (lexer.GetCurKind() != kMDOpenSquare) {
+      return EmitError("Expect a OpenSquare before a list element defined");
+    }
+    VecElement *curEle = mdMemPool->New<VecElement>(*mdMemPool);
+    while (lexer.NextToken() != kMDCloseSquare) {
+      switch (lexer.GetCurKind()) {
+        case kMDIdentifier: {
+          unsigned int elementIdx = dataKeeper.CreateStrInTable(lexer.GetStrToken(), kElementName);
+          if (elementIdx == UINT_MAX) {
+            return EmitError("Duplicate string name has already been defined");
+          }
+          StringElement *singleEle = mdMemPool->New<StringElement>(elementIdx);
+          curEle->appendElement(singleEle);
+          break;
+        }
+        case kMDComma:
+          break;
+        default:
+          return EmitError("Unexpected token kind");
+      }
+    }
+    curObj.AddMDElements(curEle);
+  } else {
+    if (lexer.GetCurKind() != kMDIdentifier) {
+      return EmitError("Expect a string elemet as defined");
+    }
+    unsigned int elementIdx = dataKeeper.CreateStrInTable(lexer.GetStrToken(), kElementName);
+    if (elementIdx == UINT_MAX) {
+      return EmitError("Duplicate string name has already been defined");
+    }
+    StringElement *curEle = mdMemPool->New<StringElement>(elementIdx);
+    curObj.AddMDElements(curEle);
+  }
+  return true;
+}
+
+bool MDParser::ParseDefTyElement(MDObject &curObj, bool isVec, const std::set<unsigned int> &childSet) {
+  if (isVec) {
+    if (lexer.GetCurKind() != kMDOpenSquare) {
+      return EmitError("Expect a OpenSquare before a list element defined");
+    }
+    VecElement *curEle = mdMemPool->New<VecElement>(*mdMemPool);
+    while (lexer.NextToken() != kMDCloseSquare) {
+      switch (lexer.GetCurKind()) {
+        case kMDIdentifier: {
+          StrInfo defTypeInfo = dataKeeper.GetStrInTable(lexer.GetStrToken());
+          DefTyElement *singleEle = mdMemPool->New<DefTyElement>();
+          if (!singleEle->SetContent(defTypeInfo, childSet)) {
+            return EmitError("Expect a input element which has been defined as a type");
+          }
+          curEle->appendElement(singleEle);
+          break;
+        }
+        case kMDComma:
+          break;
+        default:
+          return EmitError("Unexpected token kind");
+      }
+    }
+    curObj.AddMDElements(curEle);
+  } else {
+    if (lexer.GetCurKind() != kMDIdentifier) {
+      return EmitError("Expect a string elemet as defined");
+    }
+    StrInfo defTypeInfo = dataKeeper.GetStrInTable(lexer.GetStrToken());
+    DefTyElement *curEle = mdMemPool->New<DefTyElement>();
+    if (!curEle->SetContent(defTypeInfo, childSet)) {
+      return EmitError("Expect a input element which has been defined as a type");
+    }
+    curObj.AddMDElements(curEle);
+  }
+  return true;
+}
+
+bool MDParser::ParseDefObjElement(MDObject &curObj, bool isVec, const MDClass &pClass) {
+  if (isVec) {
+    if (lexer.GetCurKind() != kMDOpenSquare) {
+      return EmitError("Expect a OpenSquare before a list element defined");
+    }
+    VecElement *curEle = mdMemPool->New<VecElement>(*mdMemPool);
+    while (lexer.NextToken() != kMDCloseSquare) {
+      switch (lexer.GetCurKind()) {
+        case kMDIdentifier: {
+          StrInfo defObjInfo = dataKeeper.GetStrInTable(lexer.GetStrToken());
+          DefObjElement *singleEle = mdMemPool->New<DefObjElement>();
+          if (!singleEle->SetContent(defObjInfo, pClass)) {
+            return EmitError("Expect a input element which has been defined as a object");
+          }
+          curEle->appendElement(singleEle);
+          break;
+        }
+        case kMDComma:
+          break;
+        default:
+          return EmitError("Unexpected token kind");
+      }
+    }
+    curObj.AddMDElements(curEle);
+  } else {
+    if (lexer.GetCurKind() != kMDIdentifier) {
+      return EmitError("Expect a integer elemet as defined");
+    }
+    StrInfo defObjInfo = dataKeeper.GetStrInTable(lexer.GetStrToken());
+    DefObjElement *curEle = mdMemPool->New<DefObjElement>();
+    if (!curEle->SetContent(defObjInfo, pClass)) {
+      return EmitError("Expect a input element which has been defined as a object");
+    }
+    curObj.AddMDElements(curEle);
+  }
+  return true;
+}
+
+bool MDParser::EmitError(const std::string &errMsg) {
+  maple::LogInfo::MapleLogger() << errMsg <<  "\n";
+  maple::LogInfo::MapleLogger() << "A Error Appear At Line " << lexer.GetLineNumber() << "\n";
+  maple::LogInfo::MapleLogger() << "Source code : " << lexer.GetStrLine() << "\n";
+  return false;
+}
+} /* namespace MDGen */
diff --git a/src/mapleall/maple_be/mdgen/src/mdrecord.cpp b/src/mapleall/maple_be/mdgen/src/mdrecord.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c89a504c9e8d21ddb61b735a723b0174ecc5d59
--- /dev/null
+++ b/src/mapleall/maple_be/mdgen/src/mdrecord.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mdrecord.h"
+
+namespace MDGen {
+constexpr unsigned int kInValidStrIdx = UINT_MAX;
+
+bool DefTyElement::SetContent(const StrInfo curInfo, const std::set<unsigned int> &childTySet) {
+  if (childTySet.count(curInfo.idx) == 0) {
+    return false;
+  }
+  elementIdx = curInfo.idx;
+  return true;
+}
+
+bool DefObjElement::SetContent(const StrInfo curInfo, const MDClass &parentClass) {
+  if (!parentClass.IsClassMember(curInfo.idx)) {
+    return false;
+  }
+  elementIdx = curInfo.idx;
+  return true;
+}
+
+const MDElement *MDObject::GetOneMDElement(size_t index) const {
+  CHECK_FATAL(index < mdElements.size(), "Array boundary check failed");
+  return mdElements[index];
+}
+
+const MDObject &MDClass::GetOneMDObject(size_t index) const {
+  CHECK_FATAL(index < mdObjects.size(), "Array boundary check failed");
+  return mdObjects[index];
+}
+
+void MDClass::AddClassMember(MDObject inputObj) {
+  mdObjects.emplace_back(inputObj);
+  (void)childObjNames.insert(inputObj.GetIdx());
+}
+
+bool MDClass::IsClassMember(unsigned int curIdx) const {
+  return childObjNames.count(curIdx);
+}
+
+void MDClass::BuildFormalTypes(unsigned int memberIdx, bool isVec) {
+  formalTypes.emplace_back(std::make_pair(memberIdx, isVec));
+}
+
+bool MDClass::IsValidStructEle(RecordType curTy) const {
+  return (curTy == kTypeName || curTy == kClassName || curTy == kIntType || curTy == kStringType);
+}
+
+unsigned int MDClassRange::CreateStrInTable(const std::string &inStr, RecordType curTy) {
+  unsigned int result = kInValidStrIdx;
+  StrInfo curInfo (totalStr, curTy);
+  auto ret = stringHashTable.insert(std::make_pair(inStr, curInfo));
+  if (ret.second) {
+    unsigned int temp = totalStr;
+    stringTable.emplace_back(inStr);
+    ++totalStr;
+    return temp;
+  }
+  return result;
+}
+
+StrInfo MDClassRange::GetStrInTable(const std::string &inStr) {
+  auto ret = stringHashTable.find(inStr);
+  StrInfo inValidInfo (UINT_MAX, kUndefinedStr);
+  return (ret != stringHashTable.end()) ? ret->second : inValidInfo;
+}
+
+RecordType MDClassRange::GetStrTyByIdx(size_t curIdx) {
+  CHECK_FATAL(curIdx < stringTable.size(), "Array boundary check failed");
+  return GetStrInTable(stringTable[curIdx]).sType;
+}
+
+const std::string &MDClassRange::GetStrByIdx(size_t curIdx) {
+  CHECK_FATAL(curIdx < stringTable.size(), "Array boundary check failed");
+  return stringTable[curIdx];
+}
+
+void MDClassRange::ModifyStrTyInTable(const std::string &inStr, RecordType newTy) {
+  auto ret = stringHashTable.find(inStr);
+  CHECK_FATAL(ret != stringHashTable.end(), "find string failed!");
+  ret->second.sType = newTy;
+}
+
+void MDClassRange::AddDefinedType(unsigned int typesName, std::set<unsigned int> typesSet) {
+  (void)definedTypes.insert(std::make_pair(typesName, typesSet));
+}
+
+void MDClassRange::AddMDClass(MDClass curClass) {
+  (void)allClasses.insert(std::make_pair(curClass.GetClassIdx(), curClass));
+}
+
+void MDClassRange::FillMDClass(unsigned int givenIdx, const MDObject &insertObj) {
+  auto ret = allClasses.find(givenIdx);
+  CHECK_FATAL(ret != allClasses.end(), "Cannot achieve target MD Class");
+  ret->second.AddClassMember(insertObj);
+}
+
+MDClass MDClassRange::GetOneMDClass(unsigned int givenIdx) {
+  auto ret = allClasses.find(givenIdx);
+  CHECK_FATAL(ret != allClasses.end(), "Cannot achieve target MD Class");
+  return ret->second;
+}
+
+std::set<unsigned int> MDClassRange::GetOneSpcType(unsigned int givenTyIdx) {
+  auto ret = definedTypes.find(givenTyIdx);
+  CHECK_FATAL(ret != definedTypes.end(), "Cannot achieve a defined type");
+  return ret->second;
+}
+} /* namespace MDGen */
diff --git a/src/mapleall/maple_be/src/ad/mad.cpp b/src/mapleall/maple_be/src/ad/mad.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..367c25f67831a461f309867c63d49c921d38d7aa
--- /dev/null
+++ b/src/mapleall/maple_be/src/ad/mad.cpp
@@ -0,0 +1,389 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mad.h"
+#include <string>
+#if TARGAARCH64
+#include "aarch64_operand.h"
+#elif TARGRISCV64
+#include "riscv64_operand.h"
+#endif
+#include "schedule.h"
+#include "insn.h"
+
+namespace maplebe {
+const std::string kUnitName[] = {
+#include "mplad_unit_name.def"
+  "None",
+};
+/* Unit */
+Unit::Unit(enum UnitId theUnitId)
+    : unitId(theUnitId), unitType(kUnitTypePrimart), occupancyTable(0), compositeUnits() {
+  MAD::AddUnit(*this);
+}
+
+Unit::Unit(enum UnitType theUnitType, enum UnitId theUnitId, int numOfUnits, ...)
+    : unitId(theUnitId), unitType(theUnitType), occupancyTable(0) {
+  ASSERT(numOfUnits > 1, "CG internal error, composite unit with less than 2 unit elements.");
+  va_list ap;
+  va_start(ap, numOfUnits);
+
+  for (int i = 0; i < numOfUnits; ++i) {
+    compositeUnits.emplace_back(static_cast<Unit*>(va_arg(ap, Unit*)));
+  }
+  va_end(ap);
+
+  MAD::AddUnit(*this);
+}
+
+/* return name of unit */
+std::string Unit::GetName() const {
+  ASSERT(GetUnitId() <= kUnitIdLast, "Unexpected UnitID");
+  return kUnitName[GetUnitId()];
+}
+
+/* Check if unit is free at next "cycle" cycle. */
+bool Unit::IsFree(uint32 cycle) const {
+  if (GetUnitType() == kUnitTypeOr) {
+    for (auto unit : compositeUnits) {
+      if (unit->IsFree(cycle)) {
+        return true;
+      }
+    }
+    return false;
+  } else if (GetUnitType() == kUnitTypeAnd) {
+    for (auto unit : compositeUnits) {
+      if (!unit->IsFree(cycle)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if ((occupancyTable & (1u << cycle)) != 0) {
+    return false;
+  }
+  return true;
+}
+
+/* Occupy unit at next "cycle" cycle. */
+void Unit::Occupy(const Insn &insn, uint32 cycle) {
+  if (GetUnitType() == kUnitTypeOr) {
+    for (auto unit : GetCompositeUnits()) {
+      if (unit->IsFree(cycle)) {
+        unit->Occupy(insn, cycle);
+        return;
+      }
+    }
+
+    ASSERT(false, "CG internal error, should not be reach here.");
+    return;
+  } else if (GetUnitType() == kUnitTypeAnd) {
+    for (auto unit : GetCompositeUnits()) {
+      unit->Occupy(insn, cycle);
+    }
+    return;
+  }
+  occupancyTable |= (1u << cycle);
+}
+
+/* Advance all units one cycle */
+void Unit::AdvanceCycle() {
+  if (GetUnitType() != kUnitTypePrimart) {
+    return;
+  }
+  occupancyTable = (occupancyTable >> 1);
+}
+
+/* Release all units. */
+void Unit::Release() {
+  if (GetUnitType() != kUnitTypePrimart) {
+    return;
+  }
+  occupancyTable = 0;
+}
+
+const std::vector<Unit*> &Unit::GetCompositeUnits() const {
+  return compositeUnits;
+}
+
+void Unit::PrintIndent(int indent) const {
+  for (int i = 0; i < indent; ++i) {
+    LogInfo::MapleLogger() << " ";
+  }
+}
+
+void Unit::Dump(int indent) const {
+  PrintIndent(indent);
+  LogInfo::MapleLogger() << "Unit " << GetName() << " (ID " << GetUnitId() << "): ";
+  LogInfo::MapleLogger() << "occupancyTable = " << occupancyTable << '\n';
+}
+
+uint32 Unit::GetOccupancyTable() const {
+  return occupancyTable;
+}
+
+/* MAD */
+int MAD::parallelism;
+std::vector<Unit*> MAD::allUnits;
+std::vector<Reservation*> MAD::allReservations;
+std::array<std::array<MAD::BypassVector, kLtLast>, kLtLast> MAD::bypassArrays;
+
+MAD::~MAD() {
+  for (auto unit : allUnits) {
+    delete unit;
+  }
+  for (auto rev : allReservations) {
+    delete rev;
+  }
+  for (auto &bypassArray : bypassArrays) {
+    for (auto &bypassVector : bypassArray) {
+      for (auto *bypass : bypassVector) {
+        delete bypass;
+      }
+    }
+  }
+  allUnits.clear();
+  allReservations.clear();
+}
+
+void MAD::InitUnits() const {
+#include "mplad_unit_define.def"
+}
+
+void MAD::InitReservation() const {
+#include "mplad_reservation_define.def"
+}
+
+void MAD::InitParallelism() const {
+#include "mplad_arch_define.def"
+}
+
+/* according insn's insnType to get a reservation */
+Reservation *MAD::FindReservation(const Insn &insn) const {
+  uint32 insnType = insn.GetLatencyType();
+  for (auto reservation : allReservations) {
+    if (reservation->IsEqual(insnType)) {
+      return reservation;
+    }
+  }
+  return nullptr;
+}
+
+/* Get latency that is def insn to use insn */
+int MAD::GetLatency(const Insn &def, const Insn &use) const {
+  int latency = BypassLatency(def, use);
+  if (latency < 0) {
+    latency = DefaultLatency(def);
+  }
+  return latency;
+}
+
+/* Get bypass latency that is  def insn to use insn */
+int MAD::BypassLatency(const Insn &def, const Insn &use) const {
+  int latency = -1;
+  ASSERT(def.GetLatencyType() < kLtLast, "out of range");
+  ASSERT(use.GetLatencyType() < kLtLast, "out of range");
+  BypassVector &bypassVec = bypassArrays[def.GetLatencyType()][use.GetLatencyType()];
+  for (auto bypass : bypassVec) {
+    if (bypass->CanBypass(def, use)) {
+      latency = bypass->GetLatency();
+      break;
+    }
+  }
+  return latency;
+}
+
+/* Get insn's default latency */
+int MAD::DefaultLatency(const Insn &insn) const {
+  Reservation *res = insn.GetDepNode()->GetReservation();
+  return res != nullptr ? res->GetLatency() : 0;
+}
+
+void MAD::AdvanceCycle() const {
+  for (auto unit : allUnits) {
+    unit->AdvanceCycle();
+  }
+}
+
+void MAD::ReleaseAllUnits() const {
+  for (auto unit : allUnits) {
+    unit->Release();
+  }
+}
+
+void MAD::SaveStates(std::vector<uint32> &occupyTable, int size) const {
+  int i = 0;
+  for (auto unit : allUnits) {
+    CHECK_FATAL(i < size, "unit number error");
+    occupyTable[i] = unit->GetOccupancyTable();
+    ++i;
+  }
+}
+
+#define ADDBYPASS(DEFLTTY, USELTTY, LT) AddBypass(*(new Bypass(DEFLTTY, USELTTY, LT)))
+#define ADDALUSHIFTBYPASS(DEFLTTY, USELTTY, LT) AddBypass(*(new AluShiftBypass(DEFLTTY, USELTTY, LT)))
+#define ADDACCUMULATORBYPASS(DEFLTTY, USELTTY, LT) AddBypass(*(new AccumulatorBypass(DEFLTTY, USELTTY, LT)))
+#define ADDSTOREBYPASS(DEFLTTY, USELTTY, LT) AddBypass(*(new StoreBypass(DEFLTTY, USELTTY, LT)))
+
+void MAD::InitBypass() const {
+#include "mplad_bypass_define.def"
+}
+
+bool MAD::IsSlot0Free() const {
+  if (GetUnitByUnitId(kUnitIdSlot0)->IsFree(0)) {
+    return false;
+  }
+  return true;
+}
+
+bool MAD::IsFullIssued() const {
+  if (GetUnitByUnitId(kUnitIdSlot0)->IsFree(0) || GetUnitByUnitId(kUnitIdSlot1)->IsFree(0)) {
+    return false;
+  }
+  return true;
+}
+
+void MAD::RestoreStates(std::vector<uint32> &occupyTable, int size) const {
+  int i = 0;
+  for (auto unit : allUnits) {
+    CHECK_FATAL(i < size, "unit number error");
+    unit->SetOccupancyTable(occupyTable[i]);
+    ++i;
+  }
+}
+
+bool Bypass::CanBypass(const Insn &defInsn, const Insn &useInsn) const {
+  (void)defInsn;
+  (void)useInsn;
+  return true;
+}
+
+bool AluShiftBypass::CanBypass(const Insn &defInsn, const Insn &useInsn) const {
+  /*
+   * hook condition
+   * true: r1=r2+x1 -> r3=r2<<0x2+r1
+   * false:r1=r2+x1 -> r3=r1<<0x2+r2
+   */
+  return &(defInsn.GetOperand(kInsnFirstOpnd)) != &(useInsn.GetOperand(kInsnSecondOpnd));
+}
+
+bool AccumulatorBypass::CanBypass(const Insn &defInsn, const Insn &useInsn) const {
+  /*
+   * hook condition
+   * true: r98=x0*x1 -> x0=x2*x3+r98
+   * false:r98=x0*x1 -> x0=x2*r98+x3
+   */
+  return (&(defInsn.GetOperand(kInsnFirstOpnd)) != &(useInsn.GetOperand(kInsnSecondOpnd)) &&
+          &(defInsn.GetOperand(kInsnFirstOpnd)) != &(useInsn.GetOperand(kInsnThirdOpnd)));
+}
+
+bool StoreBypass::CanBypass(const Insn &defInsn, const Insn &useInsn) const {
+  /*
+   * hook condition
+   * true: r96=r92+x2 -> str r96, [r92]
+   * false:r96=r92+x2 -> str r92, [r96]
+   * false:r96=r92+x2 -> str r92, [r94, r96]
+   */
+#if TARGAARCH64
+  switch (useInsn.GetMachineOpcode()) {
+    case MOP_wstrb:
+    case MOP_wstrh:
+    case MOP_wstr:
+    case MOP_xstr:
+    case MOP_sstr:
+    case MOP_dstr: {
+      auto &useMemOpnd = static_cast<MemOperand&>(useInsn.GetOperand(kInsnSecondOpnd));
+      return (&(defInsn.GetOperand(kInsnFirstOpnd)) != useMemOpnd.GetOffset() &&
+              &(defInsn.GetOperand(kInsnFirstOpnd)) != useMemOpnd.GetBaseRegister());
+    }
+    case MOP_wstp:
+    case MOP_xstp: {
+      auto &useMemOpnd = static_cast<MemOperand&>(useInsn.GetOperand(kInsnThirdOpnd));
+      return (&(defInsn.GetOperand(kInsnFirstOpnd)) != useMemOpnd.GetOffset() &&
+              &(defInsn.GetOperand(kInsnFirstOpnd)) != useMemOpnd.GetBaseRegister());
+    }
+
+    default:
+      return false;
+  }
+#endif
+  return false;
+}
+
+/* Reservation */
+Reservation::Reservation(LatencyType t, int l, int n, ...) : type(t), latency(l), unitNum(n) {
+  ASSERT(l >= 0, "CG internal error, latency and unitNum should not be less than 0.");
+  ASSERT(n >= 0, "CG internal error, latency and unitNum should not be less than 0.");
+
+  errno_t ret = memset_s(units, sizeof(Unit*) * kMaxUnit, 0, sizeof(Unit*) * kMaxUnit);
+  CHECK_FATAL(ret == EOK, "call memset_s failed in Reservation");
+
+  va_list ap;
+  va_start(ap, n);
+  for (uint32 i = 0; i < unitNum; ++i) {
+    units[i] = static_cast<Unit*>(va_arg(ap, Unit*));
+  }
+  va_end(ap);
+
+  MAD::AddReservation(*this);
+  /* init slot */
+  if (n > 0) {
+    /* if there are units, init slot by units[0] */
+    slot = GetSlotType(units[0]->GetUnitId());
+  } else {
+    slot = kSlotNone;
+  }
+}
+
+const std::string kSlotName[] = {
+  "SlotNone",
+  "Slot0",
+  "Slot1",
+  "SlotAny",
+  "Slots",
+};
+
+const std::string &Reservation::GetSlotName() const {
+  ASSERT(GetSlot() <= kSlots, "Unexpected slot");
+  return kUnitName[GetSlot()];
+}
+
+/* Get slot type by unit id */
+SlotType Reservation::GetSlotType(UnitId unitID) const {
+  switch (unitID) {
+    case kUnitIdSlot0:
+    case kUnitIdSlot0LdAgu:
+    case kUnitIdSlot0StAgu:
+      return kSlot0;
+
+    case kUnitIdSlot1:
+      return kSlot1;
+
+    case kUnitIdSlotS:
+    case kUnitIdSlotSHazard:
+    case kUnitIdSlotSMul:
+    case kUnitIdSlotSBranch:
+    case kUnitIdSlotSAgen:
+      return kSlotAny;
+
+    case kUnitIdSlotD:
+    case kUnitIdSlotDAgen:
+      return kSlots;
+
+    default:
+      ASSERT(false, "unknown slot type!");
+      return kSlotNone;
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/be/bbt.cpp b/src/mapleall/maple_be/src/be/bbt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc00a8b515ecc5d0059a4de275bb7ce1eefdb897
--- /dev/null
+++ b/src/mapleall/maple_be/src/be/bbt.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bbt.h"
+namespace maplebe {
+#if DEBUG
+void BBT::Dump(const MIRModule &mod) const {
+  if (IsTry()) {
+    LogInfo::MapleLogger() << "Try" << '\n';
+  } else if (IsEndTry()) {
+    LogInfo::MapleLogger() << "EndTry" << '\n';
+  } else if (IsCatch()) {
+    LogInfo::MapleLogger() << "Catch" << '\n';
+  } else {
+    LogInfo::MapleLogger() << "Plain" << '\n';
+  }
+  if (firstStmt != nullptr) {
+    firstStmt->Dump(0);
+    LogInfo::MapleLogger() << '\n';
+    if (keyStmt != nullptr) {
+      keyStmt->Dump(0);
+      LogInfo::MapleLogger() << '\n';
+    } else {
+      LogInfo::MapleLogger() << "<<No-Key-Stmt>>" << '\n';
+    }
+    if (lastStmt != nullptr) {
+      lastStmt->Dump(0);
+    }
+    LogInfo::MapleLogger() << '\n';
+  } else {
+    LogInfo::MapleLogger() << "<<Empty>>" << '\n';
+  }
+}
+
+void BBT::ValidateStmtList(StmtNode *head, StmtNode *detached) {
+  static int nStmts = 0;
+  int n = 0;
+  int m = 0;
+  if (head == nullptr && detached == nullptr) {
+    nStmts = 0;
+    return;
+  }
+  for (StmtNode *s = head; s != nullptr; s = s->GetNext()) {
+    if (s->GetNext() != nullptr) {
+      CHECK_FATAL(s->GetNext()->GetPrev() == s, "make sure the prev node of s' next is s");
+    }
+    if (s->GetPrev() != nullptr) {
+      CHECK_FATAL(s->GetPrev()->GetNext() == s, "make sure the next node of s' prev is s");
+    }
+    ++n;
+  }
+  for (StmtNode *s = detached; s != nullptr; s = s->GetNext()) {
+    if (s->GetNext() != nullptr) {
+      CHECK_FATAL(s->GetNext()->GetPrev() == s, "make sure the prev node of s' next is s");
+    }
+    if (s->GetPrev() != nullptr) {
+      CHECK_FATAL(s->GetPrev()->GetNext() == s, "make sure the next node of s' prev is s");
+    }
+    ++m;
+  }
+  CHECK_FATAL(nStmts <= n + m, "make sure nStmts <= n + m");
+  nStmts = n + m;
+}
+#endif
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/be/becommon.cpp b/src/mapleall/maple_be/src/be/becommon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2d593f5aa3aec12fc62124955112d1bf1b8681e3
--- /dev/null
+++ b/src/mapleall/maple_be/src/be/becommon.cpp
@@ -0,0 +1,846 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <cinttypes>
+#include <list>
+#include "rt.h"
+#include "cg_option.h"
+#include "mir_builder.h"
+#include "mpl_logging.h"
+#include "becommon.h"
+
+namespace maplebe {
+using namespace maple;
+
+BECommon::BECommon(MIRModule &mod)
+    : mirModule(mod),
+      typeSizeTable(GlobalTables::GetTypeTable().GetTypeTable().size(), 0, mirModule.GetMPAllocator().Adapter()),
+      typeAlignTable(GlobalTables::GetTypeTable().GetTypeTable().size(), static_cast<uint8>(mirModule.IsCModule()),
+          mirModule.GetMPAllocator().Adapter()),
+      typeHasFlexibleArray(GlobalTables::GetTypeTable().GetTypeTable().size(), 0, mirModule.GetMPAllocator().Adapter()),
+      structFieldCountTable(GlobalTables::GetTypeTable().GetTypeTable().size(),
+                            0, mirModule.GetMPAllocator().Adapter()),
+      jClassLayoutTable(mirModule.GetMPAllocator().Adapter()),
+      funcReturnType(mirModule.GetMPAllocator().Adapter()) {
+    for (uint32 i = 1; i < GlobalTables::GetTypeTable().GetTypeTable().size(); ++i) {
+      MIRType *ty = GlobalTables::GetTypeTable().GetTypeTable()[i];
+      ComputeTypeSizesAligns(*ty);
+      LowerTypeAttribute(*ty);
+    }
+
+  if (mirModule.IsJavaModule()) {
+    for (uint32 i = 0; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
+      MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbol(i);
+      if (sym == nullptr) {
+        continue;
+      }
+      LowerJavaVolatileForSymbol(*sym);
+    }
+  }
+}
+
+/*
+ * try to find an available padding slot, and allocate the given field in it.
+ * return the offset of the allocated memory. 0 if not available
+ * Note: this will update lists in paddingSlots
+ * Note: padding slots is a list of un-occupied (small size) slots
+ *       available to allocate new fields. so far, just for 1, 2, 4 bytes
+ *       types (map to array index 0, 1, 2)
+ */
+static uint32 TryAllocInPaddingSlots(std::list<uint32> paddingSlots[],
+                                     uint32 fieldSize,
+                                     uint32 fieldAlign,
+                                     size_t paddingSlotsLength) {
+  CHECK_FATAL(paddingSlotsLength > 0, "expect paddingSlotsLength > 0");
+  if (fieldSize > 4) {
+    return 0;  /* padding slots are for size 1/2/4 bytes */
+  }
+
+  uint32 fieldOffset = 0;
+  /* here is a greedy search */
+  for (size_t freeSlot = static_cast<size_t>(fieldSize >> 1); freeSlot < paddingSlotsLength; ++freeSlot) {
+    if (!paddingSlots[freeSlot].empty()) {
+      uint32 paddingOffset = paddingSlots[freeSlot].front();
+      if (IsAlignedTo(paddingOffset, fieldAlign)) {
+        /* reuse one padding slot */
+        paddingSlots[freeSlot].pop_front();
+        fieldOffset = paddingOffset;
+        /* check whether there're still space left in this slot */
+        uint32 leftSize = (1u << freeSlot) - fieldSize;
+        if (leftSize != 0) {
+          uint32 leftOffset = paddingOffset + fieldSize;
+          if ((leftSize & 0x1) > 0) {  /* check whether the last bit is 1 */
+            paddingSlots[0].push_front(leftOffset);
+            leftOffset += 1;
+          }
+          if ((leftSize & 0x2) > 0) {  /* check whether the penultimate bit is 1 */
+            paddingSlots[1].push_front(leftOffset);
+          }
+        }
+        break;
+      }
+    }
+  }
+  return fieldOffset;
+}
+
+static void AddPaddingSlot(std::list<uint32> paddingSlots[], uint32 offset, uint32 size, size_t paddingSlotsLength) {
+  CHECK_FATAL(paddingSlotsLength > 0, "expect paddingSlotsLength > 0");
+  /*
+   * decompose the padding into 1/2/4 bytes slots.
+   * to satisfy alignment constraints.
+   */
+  for (size_t i = 0; i < paddingSlotsLength; ++i) {
+    if ((size & (1u << i)) > 0) {
+      paddingSlots[i].push_front(offset);
+      offset += (1u << i);
+    }
+  }
+}
+
+void BECommon::AddNewTypeAfterBecommon(uint32 oldTypeTableSize, uint32 newTypeTableSize) {
+  for (auto i = oldTypeTableSize; i < newTypeTableSize; ++i) {
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(i);
+    CHECK_NULL_FATAL(ty);
+    typeSizeTable.emplace_back(0);
+    typeAlignTable.emplace_back(static_cast<uint8>(mirModule.IsCModule()));
+    typeHasFlexibleArray.emplace_back(0);
+    structFieldCountTable.emplace_back(0);
+    ComputeTypeSizesAligns(*ty);
+    LowerTypeAttribute(*ty);
+  }
+}
+
+void BECommon::ComputeStructTypeSizesAligns(MIRType &ty, const TyIdx &tyIdx) {
+  auto &structType = static_cast<MIRStructType&>(ty);
+  const FieldVector &fields = structType.GetFields();
+  uint64 allocedSize = 0;
+  uint64 allocedSizeInBits = 0;
+  SetStructFieldCount(structType.GetTypeIndex(), fields.size());
+  if (fields.size() == 0) {
+    if (structType.IsCPlusPlus()) {
+      SetTypeSize(tyIdx.GetIdx(), 1); /* empty struct in C++ has size 1 */
+      SetTypeAlign(tyIdx.GetIdx(), 1);
+    } else {
+      SetTypeSize(tyIdx.GetIdx(), 0);
+      SetTypeAlign(tyIdx.GetIdx(), 1);
+    }
+    return;
+  }
+  auto structAttr = structType.GetTypeAttrs();
+  auto structPack = static_cast<uint8>(structAttr.GetPack());
+  for (uint32 j = 0; j < fields.size(); ++j) {
+    TyIdx fieldTyIdx = fields[j].second.first;
+    auto fieldAttr = fields[j].second.second;
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    uint32 fieldTypeSize = GetTypeSize(fieldTyIdx);
+    if (fieldTypeSize == 0) {
+      ComputeTypeSizesAligns(*fieldType);
+      fieldTypeSize = GetTypeSize(fieldTyIdx);
+    }
+    uint64 fieldSizeBits = fieldTypeSize * kBitsPerByte;
+    auto attrAlign = static_cast<uint8>(fieldAttr.GetAlign());
+    auto originAlign = std::max(attrAlign, GetTypeAlign(fieldTyIdx));
+    uint8 fieldAlign = fieldAttr.IsPacked() ? static_cast<uint8>(1U) : std::min(originAlign, structPack);
+    uint64 fieldAlignBits = fieldAlign * kBitsPerByte;
+    CHECK_FATAL(fieldAlign != 0, "expect fieldAlign not equal 0");
+    MIRStructType *subStructType = fieldType->EmbeddedStructType();
+    if (subStructType != nullptr) {
+      AppendStructFieldCount(structType.GetTypeIndex(), GetStructFieldCount(subStructType->GetTypeIndex()));
+    }
+    if (structType.GetKind() != kTypeUnion) {
+      if (fieldType->GetKind() == kTypeBitField) {
+        uint32 fieldSize = static_cast<MIRBitFieldType*>(fieldType)->GetFieldSize();
+        /* is this field is crossing the align boundary of its base type? */
+        if ((!structAttr.IsPacked() &&
+            ((allocedSizeInBits / fieldSizeBits) != ((allocedSizeInBits + fieldSize - 1u) / fieldSizeBits))) ||
+            fieldSize == 0) {
+          allocedSizeInBits = RoundUp(allocedSizeInBits, fieldSizeBits);
+        }
+        /* allocate the bitfield */
+        allocedSizeInBits += fieldSize;
+        allocedSize = std::max(allocedSize, RoundUp(allocedSizeInBits, fieldAlignBits) / kBitsPerByte);
+      } else {
+        bool leftoverbits = false;
+
+        if (allocedSizeInBits == allocedSize * kBitsPerByte) {
+          allocedSize = RoundUp(allocedSize, fieldAlign);
+        } else {
+          /* still some leftover bits on allocated words, we calculate things based on bits then. */
+          if (allocedSizeInBits / fieldAlignBits != (allocedSizeInBits + fieldSizeBits - 1) / fieldAlignBits) {
+            /* the field is crossing the align boundary of its base type */
+            allocedSizeInBits = RoundUp(allocedSizeInBits, fieldAlignBits);
+          }
+          leftoverbits =  true;
+        }
+        if (leftoverbits) {
+          allocedSizeInBits += fieldSizeBits;
+          allocedSize = std::max(allocedSize, RoundUp(allocedSizeInBits, fieldAlignBits) / kBitsPerByte);
+        } else {
+          /* pad alloced_size according to the field alignment */
+          allocedSize = RoundUp(allocedSize, fieldAlign);
+          allocedSize += fieldTypeSize;
+          allocedSizeInBits = allocedSize * kBitsPerByte;
+        }
+      }
+    } else {  /* for unions, bitfields are treated as non-bitfields */
+      allocedSize = std::max(allocedSize, static_cast<uint64>(fieldTypeSize));
+    }
+    SetTypeAlign(tyIdx, std::max(GetTypeAlign(tyIdx), fieldAlign));
+    /* C99
+     * Last struct element of a struct with more than one member
+     * is a flexible array if it is an array of size 0.
+     */
+    if ((j != 0) && ((j + 1) == fields.size()) &&
+        (fieldType->GetKind() == kTypeArray) &&
+        (GetTypeSize(fieldTyIdx.GetIdx()) == 0)) {
+      SetHasFlexibleArray(tyIdx.GetIdx(), true);
+    }
+  }
+  SetTypeSize(tyIdx, RoundUp(allocedSize, GetTypeAlign(tyIdx.GetIdx())));
+}
+
+void BECommon::ComputeClassTypeSizesAligns(MIRType &ty, const TyIdx &tyIdx, uint8 align) {
+  uint64 allocedSize = 0;
+  const FieldVector &fields = static_cast<MIRStructType&>(ty).GetFields();
+
+  auto &classType = static_cast<MIRClassType&>(ty);
+  TyIdx prntTyIdx = classType.GetParentTyIdx();
+  /* process parent class */
+  if (prntTyIdx != 0u) {
+    MIRClassType *parentType =
+        static_cast<MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(prntTyIdx));
+    uint32 prntSize = GetTypeSize(prntTyIdx);
+    if (prntSize == 0) {
+      ComputeTypeSizesAligns(*parentType);
+      prntSize = GetTypeSize(prntTyIdx);
+    }
+    uint8 prntAlign = GetTypeAlign(prntTyIdx);
+    AppendStructFieldCount(tyIdx, GetStructFieldCount(prntTyIdx) + 1);
+    /* pad alloced_size according to the field alignment */
+    allocedSize = RoundUp(allocedSize, prntAlign);
+
+    JClassLayout *layout = mirModule.GetMemPool()->New<JClassLayout>(mirModule.GetMPAllocator().Adapter());
+    /* add parent's record to the front */
+    layout->emplace_back(JClassFieldInfo(false, false, false, allocedSize));
+    /* copy parent's layout plan into my plan */
+    if (HasJClassLayout(*parentType)) {  /* parent may have incomplete type definition. */
+      const JClassLayout &parentLayout = GetJClassLayout(*parentType);
+      (void)layout->insert(layout->cend(), parentLayout.cbegin(), parentLayout.cend());
+      allocedSize += prntSize;
+      SetTypeAlign(tyIdx, std::max(GetTypeAlign(tyIdx), prntAlign));
+    } else {
+      LogInfo::MapleLogger() << "Warning:try to layout class with incomplete type:" << parentType->GetName() << "\n";
+    }
+    jClassLayoutTable[&classType] = layout;
+  } else {
+    /* This is the root class, say, The Object */
+    jClassLayoutTable[&classType] = mirModule.GetMemPool()->New<JClassLayout>(mirModule.GetMPAllocator().Adapter());
+  }
+
+  /*
+   * a list of un-occupied (small size) slots available for insertion
+   * so far, just for 1, 2, 4 bytes types (map to array index 0, 1, 2)
+   */
+  std::list<uint32> paddingSlots[3];
+  /* process fields */
+  AppendStructFieldCount(tyIdx, fields.size());
+  if (fields.size() == 0 && mirModule.IsCModule()) {
+    SetTypeAlign(tyIdx.GetIdx(), 1);
+    SetTypeSize(tyIdx.GetIdx(), 1);
+    return;
+  }
+  for (uint32 j = 0; j < fields.size(); ++j) {
+    TyIdx fieldTyIdx = fields[j].second.first;
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    FieldAttrs fieldAttr = fields[j].second.second;
+    uint32 fieldSize = GetTypeSize(fieldTyIdx);
+    if (fieldSize == 0) {
+      ComputeTypeSizesAligns(*fieldType);
+      fieldSize = GetTypeSize(fieldTyIdx);
+    }
+    uint8 fieldAlign = GetTypeAlign(fieldTyIdx);
+
+    if ((fieldType->GetKind() == kTypePointer) && (fieldType->GetPrimType() == PTY_a64)) {
+      /* handle class reference field */
+      fieldSize = static_cast<uint32>(RTSupport::GetRTSupportInstance().GetFieldSize());
+      fieldAlign = static_cast<uint8>(RTSupport::GetRTSupportInstance().GetFieldAlign());
+    }
+
+    /* try to alloc the field in one of previously created padding slots */
+    uint32 currentFieldOffset = TryAllocInPaddingSlots(paddingSlots, fieldSize, fieldAlign,
+                                                       sizeof(paddingSlots) / sizeof(paddingSlots[0]));
+    /* cannot reuse one padding slot. layout to current end */
+    if (currentFieldOffset == 0) {
+      /* pad alloced_size according to the field alignment */
+      currentFieldOffset = RoundUp(allocedSize, fieldAlign);
+      if (currentFieldOffset != allocedSize) {
+        /* rounded up, create one padding-slot */
+        uint32 paddingSize = currentFieldOffset - allocedSize;
+        AddPaddingSlot(paddingSlots, allocedSize, paddingSize,
+                       sizeof(paddingSlots) / sizeof(paddingSlots[0]));
+        allocedSize = currentFieldOffset;
+      }
+      /* need new memory for this field */
+      allocedSize += fieldSize;
+    }
+    AddElementToJClassLayout(classType, JClassFieldInfo(fieldType->GetKind() == kTypePointer,
+                                                        fieldAttr.GetAttr(FLDATTR_rcunowned),
+                                                        fieldAttr.GetAttr(FLDATTR_rcweak),
+                                                        currentFieldOffset));
+    SetTypeAlign(tyIdx, std::max(GetTypeAlign(tyIdx), fieldAlign));
+  }
+  SetTypeSize(tyIdx, RoundUp(allocedSize, align));
+}
+
+void BECommon::ComputeArrayTypeSizesAligns(MIRType &ty, const TyIdx &tyIdx) {
+  MIRArrayType &arrayType = static_cast<MIRArrayType&>(ty);
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrayType.GetElemTyIdx());
+  uint32 elemSize = GetTypeSize(elemType->GetTypeIndex());
+  if (elemSize == 0) {
+    ComputeTypeSizesAligns(*elemType);
+    elemSize = GetTypeSize(elemType->GetTypeIndex());
+  }
+  if (!mirModule.IsCModule()) {
+    CHECK_FATAL(elemSize != 0, "elemSize should not equal 0");
+    CHECK_FATAL(elemType->GetTypeIndex() != 0u, "elemType's idx should not equal 0");
+  }
+  uint32 arrayAlign = arrayType.GetTypeAttrs().GetAlign();
+  elemSize = std::max(elemSize, static_cast<uint32>(GetTypeAlign(elemType->GetTypeIndex())));
+  elemSize = std::max(elemSize, arrayAlign);
+  /* compute total number of elements from the multipel dimensions */
+  uint64 numElems = 1;
+  for (int d = 0; d < arrayType.GetDim(); ++d) {
+    numElems *= arrayType.GetSizeArrayItem(d);
+  }
+  auto typeSize = elemSize * numElems;
+  SetTypeSize(tyIdx, typeSize);
+  if (typeSize == 0) {
+    SetTypeAlign(tyIdx, static_cast<uint8>(arrayAlign));
+  } else {
+    auto maxAlign = std::max(static_cast<uint32>(GetTypeAlign(elemType->GetTypeIndex())), arrayAlign);
+    SetTypeAlign(tyIdx, static_cast<uint8>(maxAlign));
+  }
+}
+
+void BECommon::ComputeFArrayOrJArrayTypeSizesAligns(MIRType &ty, const TyIdx &tyIdx) {
+  MIRFarrayType &arrayType = static_cast<MIRFarrayType&>(ty);
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrayType.GetElemTyIdx());
+  uint32 elemSize = GetTypeSize(elemType->GetTypeIndex());
+  if (elemSize == 0) {
+    ComputeTypeSizesAligns(*elemType);
+    elemSize = GetTypeSize(elemType->GetTypeIndex());
+  }
+  CHECK_FATAL(elemSize != 0, "elemSize should not equal 0");
+  CHECK_FATAL(GetTypeAlign(elemType->GetTypeIndex()) != 0u, "GetTypeAlign return 0 is not expected");
+  elemSize = std::max(elemSize, static_cast<uint32>(GetTypeAlign(elemType->GetTypeIndex())));
+  SetTypeSize(tyIdx, 0);
+  SetTypeAlign(tyIdx, GetTypeAlign(elemType->GetTypeIndex()));
+}
+
+/* Note: also do java class layout */
+void BECommon::ComputeTypeSizesAligns(MIRType &ty, uint8 align) {
+  TyIdx tyIdx = ty.GetTypeIndex();
+  if ((structFieldCountTable.size() > tyIdx) && (GetStructFieldCount(tyIdx) != 0)) {
+    return;  /* processed before */
+  }
+
+  if ((ty.GetPrimType() == PTY_ptr) || (ty.GetPrimType() == PTY_ref)) {
+    ty.SetPrimType(GetLoweredPtrType());
+  }
+
+  switch (ty.GetKind()) {
+    case kTypeScalar:
+    case kTypePointer:
+    case kTypeBitField:
+    case kTypeFunction:
+      SetTypeSize(tyIdx, GetPrimTypeSize(ty.GetPrimType()));
+      SetTypeAlign(tyIdx, GetTypeSize(tyIdx));
+      break;
+    case kTypeArray: {
+      ComputeArrayTypeSizesAligns(ty, tyIdx);
+      break;
+    }
+    case kTypeFArray:
+    case kTypeJArray: {
+      ComputeFArrayOrJArrayTypeSizesAligns(ty, tyIdx);
+      break;
+    }
+    case kTypeUnion:
+    case kTypeStruct: {
+      ComputeStructTypeSizesAligns(ty, tyIdx);
+      break;
+    }
+    case kTypeInterface: {  /* interface shouldn't have instance fields */
+      SetTypeAlign(tyIdx, 0);
+      SetTypeSize(tyIdx, 0);
+      SetStructFieldCount(tyIdx, 0);
+      break;
+    }
+    case kTypeClass: {  /* cannot have union or bitfields */
+      ComputeClassTypeSizesAligns(ty, tyIdx, align);
+      break;
+    }
+    case kTypeByName:
+    case kTypeVoid:
+    default:
+      SetTypeSize(tyIdx, 0);
+      break;
+  }
+  /* there may be passed-in align attribute declared with the symbol */
+  SetTypeAlign(tyIdx, std::max(GetTypeAlign(tyIdx), align));
+}
+
+void BECommon::LowerTypeAttribute(MIRType &ty) {
+  if (mirModule.IsJavaModule()) {
+    LowerJavaTypeAttribute(ty);
+  }
+}
+
+void BECommon::LowerJavaTypeAttribute(MIRType &ty) {
+  /* we process volatile only for now */
+  switch (ty.GetKind()) {
+    case kTypeClass:  /* cannot have union or bitfields */
+      LowerJavaVolatileInClassType(static_cast<MIRClassType&>(ty));
+      break;
+
+    default:
+      break;
+  }
+}
+
+void BECommon::LowerJavaVolatileInClassType(MIRClassType &ty) {
+  for (auto &field : ty.GetFields()) {
+    if (field.second.second.GetAttr(FLDATTR_volatile)) {
+      field.second.second.SetAttr(FLDATTR_memory_order_acquire);
+      field.second.second.SetAttr(FLDATTR_memory_order_release);
+    } else {
+      MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(field.second.first);
+      if (fieldType->GetKind() == kTypeClass) {
+        LowerJavaVolatileInClassType(static_cast<MIRClassType&>(*fieldType));
+      }
+    }
+  }
+}
+
+bool BECommon::IsRefField(MIRStructType &structType, FieldID fieldID) const {
+  if (structType.GetKind() == kTypeClass) {
+    CHECK_FATAL(HasJClassLayout(static_cast<MIRClassType&>(structType)), "Cannot found java class layout information");
+    const JClassLayout &layout = GetJClassLayout(static_cast<MIRClassType&>(structType));
+    if (layout.empty()) {
+      ERR(kLncErr, "layout is null in BECommon::IsRefField");
+      return false;
+    }
+    return layout[fieldID - 1].IsRef();
+  }
+  return false;
+}
+
+void BECommon::LowerJavaVolatileForSymbol(MIRSymbol &sym) const {
+  /* type attr is associated with symbol */
+  if (sym.GetAttr(ATTR_volatile)) {
+    sym.SetAttr(ATTR_memory_order_acquire);
+    sym.SetAttr(ATTR_memory_order_release);
+  }
+}
+
+void BECommon::GenFieldOffsetMap(const std::string &className) {
+  MIRType *type = GlobalTables::GetTypeTable().GetOrCreateClassType(className, mirModule);
+  CHECK_FATAL(type != nullptr, "unknown class, type should not be nullptr");
+  MIRClassType *classType = static_cast<MIRClassType*>(type);
+  for (FieldID i = 1; i <= GetStructFieldCount(classType->GetTypeIndex()); ++i) {
+    FieldID fieldID = i;
+    FieldPair fp = classType->TraverseToFieldRef(fieldID);
+    GStrIdx strIdx = fp.first;
+    if (strIdx == 0u) {
+      continue;
+    }
+
+    const std::string &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+
+    TyIdx fieldTyIdx = fp.second.first;
+    uint64 fieldSize = GetTypeSize(fieldTyIdx);
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+
+    if ((fieldType->GetKind() == kTypePointer) && (fieldType->GetPrimType() == PTY_a64)) {
+      /* handle class reference field */
+      fieldSize = RTSupport::GetRTSupportInstance().GetFieldSize();
+    }
+
+    std::pair<int32, int32> p = GetFieldOffset(*classType, i);
+    CHECK_FATAL(p.second == 0, "expect p.second equals 0");
+    LogInfo::MapleLogger() << "CLASS_FIELD_OFFSET_MAP(" << className.c_str() << "," << fieldName.c_str() << ","
+                           << p.first << "," << fieldSize << ")\n";
+  }
+}
+
+void BECommon::GenFieldOffsetMap(MIRClassType &classType, FILE &outFile) {
+  const std::string &className = classType.GetName();
+
+  /*
+   * We only enumerate fields defined in the current class.  There are cases
+   * where a parent classes may define private fields that have the same name as
+   * a field in the current class.This table is generated for the convenience of
+   * C programmers.  If the C programmer wants to access parent class fields,
+   * the programmer should access them as `Parent.field`.
+   */
+  FieldID myEnd = structFieldCountTable.at(classType.GetTypeIndex());
+  FieldID myBegin = (myEnd - static_cast<FieldID>(classType.GetFieldsSize())) + 1;
+
+  for (FieldID i = myBegin; i <= myEnd; ++i) {
+    FieldID fieldID = i;
+    FieldPair fp = classType.TraverseToFieldRef(fieldID);
+    GStrIdx strIdx = fp.first;
+    if (strIdx == 0u) {
+      continue;
+    }
+    FieldAttrs attrs = fp.second.second;
+    if (attrs.GetAttr(FLDATTR_static)) {
+      continue;
+    }
+
+    const std::string &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+
+    TyIdx fieldTyIdx = fp.second.first;
+    uint64 fieldSize = GetTypeSize(fieldTyIdx);
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+
+    if ((fieldType->GetKind() == kTypePointer) && (fieldType->GetPrimType() == PTY_a64)) {
+      /* handle class reference field */
+      fieldSize = RTSupport::GetRTSupportInstance().GetFieldSize();
+    }
+
+    std::pair<int32, int32> p = GetFieldOffset(classType, i);
+    CHECK_FATAL(p.second == 0, "expect p.second equals 0");
+    (void)fprintf(&outFile, "__MRT_CLASS_FIELD(%s, %s, %d, %lu)\n", className.c_str(), fieldName.c_str(),
+        p.first, fieldSize);
+  }
+}
+
+void BECommon::GenObjSize(const MIRClassType &classType, FILE &outFile) const {
+  const std::string &className = classType.GetName();
+  uint64_t objSize = GetTypeSize(classType.GetTypeIndex());
+  if (objSize == 0) {
+    return;
+  }
+
+  TyIdx parentTypeIdx = classType.GetParentTyIdx();
+  MIRType *parentType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTypeIdx);
+  const char *parentName = nullptr;
+  if (parentType != nullptr) {
+    MIRClassType *parentClass = static_cast<MIRClassType*>(parentType);
+    parentName = parentClass->GetName().c_str();
+  } else {
+    parentName = "THIS_IS_ROOT";
+  }
+  fprintf(&outFile, "__MRT_CLASS(%s, %" PRIu64 ", %s)\n", className.c_str(), objSize, parentName);
+}
+
+/*
+ * compute the offset of the field given by fieldID within the structure type
+ * structy; it returns the answer in the pair (byteoffset, bitoffset) such that
+ * if it is a bitfield, byteoffset gives the offset of the container for
+ * extracting the bitfield and bitoffset is with respect to the container
+ */
+std::pair<int32, int32> BECommon::GetFieldOffset(MIRStructType &structType, FieldID fieldID) {
+  CHECK_FATAL(fieldID <= GetStructFieldCount(structType.GetTypeIndex()), "GetFieldOFfset: fieldID too large");
+  uint64 allocedSize = 0;
+  uint64 allocedSizeInBits = 0;
+  FieldID curFieldID = 1;
+  if (fieldID == 0) {
+    return std::pair<int32, int32>(0, 0);
+  }
+
+  if (structType.GetKind() == kTypeClass) {
+    CHECK_FATAL(HasJClassLayout(static_cast<MIRClassType&>(structType)), "Cannot found java class layout information");
+    const JClassLayout &layout = GetJClassLayout(static_cast<MIRClassType&>(structType));
+    CHECK_FATAL(static_cast<uint32>(fieldID) - 1 < layout.size(), "subscript out of range");
+    return std::pair<int32, int32>(static_cast<int32>(layout[fieldID - 1].GetOffset()), 0);
+  }
+
+  /* process the struct fields */
+  FieldVector fields = structType.GetFields();
+  auto structPack = static_cast<uint8>(structType.GetTypeAttrs().GetPack());
+  for (uint32 j = 0; j < fields.size(); ++j) {
+    TyIdx fieldTyIdx = fields[j].second.first;
+    auto fieldAttr = fields[j].second.second;
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    uint32 fieldTypeSize = GetTypeSize(fieldTyIdx);
+    uint64 fieldSizeBits = fieldTypeSize * kBitsPerByte;
+    auto originAlign = GetTypeAlign(fieldTyIdx);
+    uint64 fieldAlign = static_cast<uint64>(
+        static_cast<int64>(fieldAttr.IsPacked() ? 1 : std::min(originAlign, structPack)));
+    uint64 fieldAlignBits = static_cast<uint64>(static_cast<int64>(fieldAlign * kBitsPerByte));
+    CHECK_FATAL(fieldAlign != 0, "fieldAlign should not equal 0");
+    if (structType.GetKind() != kTypeUnion) {
+      if (fieldType->GetKind() == kTypeBitField) {
+        uint32 fieldSize = static_cast<MIRBitFieldType*>(fieldType)->GetFieldSize();
+        /*
+         * Is this field is crossing the align boundary of its base type? Or,
+         * is field a zero-with bit field?
+         * Refer to C99 standard (§6.7.2.1) :
+         * > As a special case, a bit-field structure member with a width of 0 indicates that no further
+         * > bit-field is to be packed into the unit in which the previous bit-field, if any, was placed.
+         *
+         * We know that A zero-width bit field can cause the next field to be aligned on the next container
+         * boundary where the container is the same size as the underlying type of the bit field.
+         */
+        if ((!structType.GetTypeAttrs().IsPacked() &&
+            ((allocedSizeInBits / fieldSizeBits) != ((allocedSizeInBits + fieldSize - 1u) / fieldSizeBits))) ||
+            fieldSize == 0) {
+          /*
+           * the field is crossing the align boundary of its base type;
+           * align alloced_size_in_bits to fieldAlign
+           */
+          allocedSizeInBits = RoundUp(allocedSizeInBits, fieldSizeBits);
+        }
+        /* allocate the bitfield */
+        if (curFieldID == fieldID) {
+          return std::pair<int32, int32>(
+              static_cast<int32>(static_cast<int64>((allocedSizeInBits / fieldAlignBits) * fieldAlign)),
+              static_cast<int32>(static_cast<int64>(allocedSizeInBits % fieldAlignBits)));
+        } else {
+          ++curFieldID;
+        }
+        allocedSizeInBits += fieldSize;
+        allocedSize = std::max(allocedSize, RoundUp(allocedSizeInBits, fieldAlignBits) / kBitsPerByte);
+      } else {
+        bool leftOverBits = false;
+        uint64 offset = 0;
+
+        if (allocedSizeInBits == allocedSize * k8BitSize) {
+          allocedSize = RoundUp(allocedSize, fieldAlign);
+          offset = allocedSize;
+        } else {
+          /* still some leftover bits on allocated words, we calculate things based on bits then. */
+          if (allocedSizeInBits / fieldAlignBits != (allocedSizeInBits + fieldSizeBits - k1BitSize) / fieldAlignBits) {
+            /* the field is crossing the align boundary of its base type */
+            allocedSizeInBits = RoundUp(allocedSizeInBits, fieldAlignBits);
+          }
+          allocedSize = RoundUp(allocedSize, fieldAlign);
+          offset = (allocedSizeInBits / fieldAlignBits) * fieldAlign;
+          leftOverBits =  true;
+        }
+
+        if (curFieldID == fieldID) {
+          return std::pair<int32, int32>(static_cast<int32>(static_cast<int64>(offset)), 0);
+        } else {
+          MIRStructType *subStructType = fieldType->EmbeddedStructType();
+          if (subStructType == nullptr) {
+            ++curFieldID;
+          } else {
+            if ((curFieldID + GetStructFieldCount(subStructType->GetTypeIndex())) < fieldID) {
+              curFieldID += GetStructFieldCount(subStructType->GetTypeIndex()) + 1;
+            } else {
+              std::pair<int32, int32> result = GetFieldOffset(*subStructType, fieldID - curFieldID);
+              return std::pair<int32, int32>(result.first + allocedSize, result.second);
+            }
+          }
+        }
+
+        if (leftOverBits) {
+          allocedSizeInBits += fieldSizeBits;
+          allocedSize = std::max(allocedSize, RoundUp(allocedSizeInBits, fieldAlignBits) / kBitsPerByte);
+        } else {
+          allocedSize += fieldTypeSize;
+          allocedSizeInBits = allocedSize * kBitsPerByte;
+        }
+      }
+    } else {  /* for unions, bitfields are treated as non-bitfields */
+      if (curFieldID == fieldID) {
+        return std::pair<int32, int32>(0, 0);
+      } else {
+        MIRStructType *subStructType = fieldType->EmbeddedStructType();
+        if (subStructType == nullptr) {
+          curFieldID++;
+        } else {
+          if ((curFieldID + GetStructFieldCount(subStructType->GetTypeIndex())) < fieldID) {
+            curFieldID += GetStructFieldCount(subStructType->GetTypeIndex()) + 1;
+          } else {
+            return GetFieldOffset(*subStructType, fieldID - curFieldID);
+          }
+        }
+      }
+    }
+  }
+  CHECK_FATAL(false, "GetFieldOffset() fails to find field");
+  return std::pair<int32, int32>(0, 0);
+}
+
+bool BECommon::TyIsInSizeAlignTable(const MIRType &ty) const {
+  if (typeSizeTable.size() != typeAlignTable.size()) {
+    return false;
+  }
+  return ty.GetTypeIndex() < typeSizeTable.size();
+}
+
+void BECommon::AddAndComputeSizeAlign(MIRType &ty) {
+  FinalizeTypeTable(ty);
+  typeAlignTable.emplace_back(mirModule.IsCModule());
+  typeSizeTable.emplace_back(0);
+  ComputeTypeSizesAligns(ty);
+}
+
+void BECommon::AddElementToJClassLayout(MIRClassType &klass, JClassFieldInfo info) {
+  JClassLayout &layout = *(jClassLayoutTable.at(&klass));
+  layout.emplace_back(info);
+}
+
+void BECommon::AddElementToFuncReturnType(MIRFunction &func, const TyIdx tyIdx) {
+  funcReturnType[&func] = tyIdx;
+}
+
+MIRType *BECommon::BeGetOrCreatePointerType(const MIRType &pointedType) {
+  MIRType *newType = GlobalTables::GetTypeTable().GetOrCreatePointerType(pointedType, GetLoweredPtrType());
+  if (TyIsInSizeAlignTable(*newType)) {
+    return newType;
+  }
+  AddAndComputeSizeAlign(*newType);
+  return newType;
+}
+
+MIRType *BECommon::BeGetOrCreateFunctionType(TyIdx tyIdx, const std::vector<TyIdx> &vecTy,
+                                             const std::vector<TypeAttrs> &vecAt) {
+  MIRType *newType = GlobalTables::GetTypeTable().GetOrCreateFunctionType(tyIdx, vecTy, vecAt);
+  if (TyIsInSizeAlignTable(*newType)) {
+    return newType;
+  }
+  AddAndComputeSizeAlign(*newType);
+  return newType;
+}
+
+void BECommon::FinalizeTypeTable(const MIRType &ty) {
+  if (ty.GetTypeIndex() > GetSizeOfTypeSizeTable()) {
+    if (mirModule.GetSrcLang() == kSrcLangC) {
+      for (uint32 i = GetSizeOfTypeSizeTable(); i < ty.GetTypeIndex(); ++i) {
+        MIRType *tyTmp = GlobalTables::GetTypeTable().GetTypeFromTyIdx(i);
+        AddAndComputeSizeAlign(*tyTmp);
+      }
+    } else {
+      CHECK_FATAL(ty.GetTypeIndex() == typeSizeTable.size(), "make sure the ty idx is exactly the table size");
+    }
+  }
+}
+
+BaseNode *BECommon::GetAddressOfNode(const BaseNode &node) {
+  switch (node.GetOpCode()) {
+    case OP_dread: {
+      const DreadNode &dNode = static_cast<const DreadNode&>(node);
+      const StIdx &index = dNode.GetStIdx();
+      return mirModule.GetMIRBuilder()->CreateAddrof(*mirModule.CurFunction()->GetLocalOrGlobalSymbol(index));
+    }
+    case OP_iread: {
+      const IreadNode &iNode = static_cast<const IreadNode&>(node);
+      if (iNode.GetFieldID() == 0) {
+        return iNode.Opnd(0);
+      }
+
+      uint32 index = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeTable().at(
+          iNode.GetTyIdx()))->GetPointedTyIdx();
+      MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeTable().at(index);
+      std::pair<int32, int32> byteBitOffset =
+          GetFieldOffset(static_cast<MIRStructType&>(*pointedType), iNode.GetFieldID());
+#if TARGAARCH64 || TARGRISCV64
+      ASSERT(GetAddressPrimType() == GetLoweredPtrType(), "incorrect address type, expect a GetLoweredPtrType()");
+#endif
+      return mirModule.GetMIRBuilder()->CreateExprBinary(
+          OP_add, *GlobalTables::GetTypeTable().GetPrimType(GetAddressPrimType()),
+          static_cast<BaseNode*>(iNode.Opnd(0)),
+          mirModule.GetMIRBuilder()->CreateIntConst(static_cast<uint64>(static_cast<int64>(byteBitOffset.first)),
+                                                    PTY_u32));
+    }
+    default:
+      return nullptr;
+  }
+}
+
+bool BECommon::CallIsOfAttr(FuncAttrKind attr, const StmtNode *narynode) const {
+  (void) attr;
+  (void) narynode;
+  return false;
+
+  /* For now, all 64x1_t types object are not propagated to become pregs by mplme, so the following
+     is not needed for now. We need to revisit this later when types are enhanced with attributes */
+#if TO_BE_RESURRECTED
+  bool attrFunc = false;
+  if (narynode->GetOpCode() == OP_call) {
+    CallNode *callNode = static_cast<CallNode *>(narynode);
+    MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+    attrFunc = (mirModule.GetSrcLang() == kSrcLangC && func->GetAttr(attr)) ? true : false;
+  } else if (narynode->GetOpCode() == OP_icall) {
+    IcallNode *icallNode = static_cast<IcallNode *>(narynode);
+    BaseNode *fNode = icallNode->Opnd(0);
+    MIRFuncType *fType = nullptr;
+    MIRPtrType *pType = nullptr;
+    if (fNode->GetOpCode() == OP_dread) {
+      DreadNode *dNode = static_cast<DreadNode *>(fNode);
+      MIRSymbol *symbol = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dNode->GetStIdx());
+      pType = static_cast<MIRPtrType *>(symbol->GetType());
+      MIRType *ty = pType;
+      if (dNode->GetFieldID() != 0) {
+        ASSERT(ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeClass, "");
+        FieldPair thepair;
+        if (ty->GetKind() == kTypeStruct) {
+          thepair = static_cast<MIRStructType *>(ty)->TraverseToField(dNode->GetFieldID());
+        } else {
+          thepair = static_cast<MIRClassType *>(ty)->TraverseToField(dNode->GetFieldID());
+        }
+        pType = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(thepair.second.first));
+      }
+      fType = static_cast<MIRFuncType *>(pType->GetPointedType());
+    } else if (fNode->GetOpCode() == OP_iread) {
+      IreadNode *iNode = static_cast<IreadNode *>(fNode);
+      MIRPtrType *pointerty = static_cast<MIRPtrType *>(GlobalTables::
+          GetTypeTable().GetTypeFromTyIdx(iNode->GetTyIdx()));
+      MIRType *pointedType = pointerty->GetPointedType();
+      if (iNode->GetFieldID() != 0) {
+        pointedType = static_cast<MIRStructType *>(pointedType)->GetFieldType(iNode->GetFieldID());
+      }
+      if (pointedType->GetKind() == kTypeFunction) {
+        fType = static_cast<MIRFuncType *>(pointedType);
+      } else if (pointedType->GetKind() == kTypePointer) {
+        return false;     /* assert? */
+      }
+    } else if (fNode->GetOpCode() == OP_select) {
+      TernaryNode *sNode = static_cast<TernaryNode *>(fNode);
+      BaseNode *expr = sNode->Opnd(1);
+      // both function ptrs under select should have the same signature, chk op1 only
+      AddroffuncNode *afNode = static_cast<AddroffuncNode *>(expr);
+      MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(afNode->GetPUIdx());
+      attrFunc = mirModule.GetSrcLang() == kSrcLangC && func->GetAttr(attr);
+    } else if (fNode->GetOpCode() == OP_regread) {
+      RegreadNode *rNode = static_cast<RegreadNode *>(fNode);
+      PregIdx pregidx = rNode->GetRegIdx();
+      MIRPreg *preg = mirModule.CurFunction()->GetPregTab()->PregFromPregIdx(pregidx);
+      MIRType *type = preg->GetMIRType();
+      if (type == nullptr) {
+        return false;
+      }
+      MIRPtrType *pType = static_cast<MIRPtrType *>(type);
+      type = pType->GetPointedType();
+      if (type == nullptr) {
+        return false;
+      }
+    } else if (fNode->GetOpCode() == OP_retype) {
+      RetypeNode *rNode = static_cast<RetypeNode *>(fNode);
+      pType = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(rNode->GetTyIdx()));
+      fType = static_cast<MIRFuncType *>(pType->GetPointedType());
+    } else {
+      return false;     /* assert? */
+    }
+  }
+  return attrFunc;
+#endif
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/be/lower.cpp b/src/mapleall/maple_be/src/be/lower.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..83850176ef5d8399db35a8762dee00c422135020
--- /dev/null
+++ b/src/mapleall/maple_be/src/be/lower.cpp
@@ -0,0 +1,4164 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "lower.h"
+#include <string>
+#include <cinttypes>
+#include <vector>
+#include "mir_symbol.h"
+#include "mir_function.h"
+#include "cg_option.h"
+#include "switch_lowerer.h"
+#include "try_catch.h"
+#include "intrinsic_op.h"
+#include "mir_builder.h"
+#include "opcode_info.h"
+#include "rt.h"
+#include "securec.h"
+#include "string_utils.h"
+#include "cast_opt.h"
+#include "simplify.h"
+#include "me_safety_warning.h"
+
+namespace maplebe {
+namespace arrayNameForLower {
+const std::set<std::string> kArrayKlassName{
+#include "array_klass_name.def"
+};
+
+const std::set<std::string> kArrayBaseName{
+#include "array_base_name.def"
+};
+}
+
+using namespace maple;
+
+#define JAVALANG (mirModule.IsJavaModule())
+#define TARGARM32 0
+
+enum ExtFuncT : uint8 { kFmodDouble, kFmodFloat };
+
+struct ExtFuncDescrT {
+  ExtFuncT fid;
+  const char *name;
+  PrimType retType;
+  PrimType argTypes[kMaxModFuncArgSize];
+};
+
+namespace {
+std::pair<MIRIntrinsicID, const std::string> cgBuiltins[] = {
+  { INTRN_JAVA_ARRAY_LENGTH, "MCC_DexArrayLength" },
+  { INTRN_JAVA_ARRAY_FILL, "MCC_DexArrayFill" },
+  { INTRN_JAVA_CHECK_CAST, "MCC_DexCheckCast" },
+  { INTRN_JAVA_INSTANCE_OF, "MCC_DexInstanceOf" },
+  { INTRN_JAVA_INTERFACE_CALL, "MCC_DexInterfaceCall" },
+  { INTRN_JAVA_POLYMORPHIC_CALL, "MCC_DexPolymorphicCall" },
+  { INTRN_MCC_DeferredFillNewArray, "MCC_DeferredFillNewArray" },
+  { INTRN_MCC_DeferredInvoke, "MCC_DeferredInvoke" },
+  { INTRN_JAVA_CONST_CLASS, "MCC_GetReferenceToClass" },
+  { INTRN_JAVA_GET_CLASS, "MCC_GetClass" },
+  { INTRN_MPL_SET_CLASS, "MCC_SetJavaClass" },
+  { INTRN_MPL_MEMSET_LOCALVAR, "memset_s" },
+};
+
+ExtFuncDescrT extFnDescrs[] = {
+  { kFmodDouble, "fmod", PTY_f64, { PTY_f64, PTY_f64, kPtyInvalid } },
+  { kFmodFloat, "fmodf", PTY_f32, { PTY_f32, PTY_f32, kPtyInvalid } },
+};
+
+std::vector<std::pair<ExtFuncT, PUIdx>> extFuncs;
+const std::string kOpAssertge = "OP_assertge";
+const std::string kOpAssertlt = "OP_assertlt";
+const std::string kOpCallAssertle = "OP_callassertle";
+const std::string kOpReturnAssertle = "OP_returnassertle";
+const std::string kOpAssignAssertle = "OP_assignassertle";
+const std::string kFileSymbolNamePrefix = "symname";
+}
+
+const std::string CGLowerer::kIntrnRetValPrefix = "__iret";
+const std::string CGLowerer::kUserRetValPrefix = "__uret";
+
+static bool CasePairKeyLessThan(const CasePair &left, const CasePair &right) {
+  return left.first < right.first;
+}
+
+std::string CGLowerer::GetFileNameSymbolName(const std::string &fileName) const {
+  return kFileSymbolNamePrefix + std::regex_replace(fileName, std::regex("-"), "_");
+}
+
+MIRSymbol *CGLowerer::CreateNewRetVar(const MIRType &ty, const std::string &prefix) {
+  const uint32 bufSize = 257;
+  char buf[bufSize] = {'\0'};
+  MIRFunction *func = GetCurrentFunc();
+  MIRSymbol *var = func->GetSymTab()->CreateSymbol(kScopeLocal);
+  int eNum = sprintf_s(buf, bufSize - 1, "%s%" PRId64, prefix.c_str(), ++seed);
+  if (eNum == -1) {
+    FATAL(kLncFatal, "sprintf_s failed");
+  }
+  std::string strBuf(buf);
+  var->SetNameStrIdx(mirModule.GetMIRBuilder()->GetOrCreateStringIndex(strBuf));
+  var->SetTyIdx(ty.GetTypeIndex());
+  var->SetStorageClass(kScAuto);
+  var->SetSKind(kStVar);
+  func->GetSymTab()->AddToStringSymbolMap(*var);
+  return var;
+}
+
+void CGLowerer::RegisterExternalLibraryFunctions() {
+  for (uint32 i = 0; i < sizeof(extFnDescrs) / sizeof(extFnDescrs[0]); ++i) {
+    ExtFuncT id = extFnDescrs[i].fid;
+    CHECK_FATAL(id == i, "make sure id equal i");
+
+    MIRFunction *func = mirModule.GetMIRBuilder()->GetOrCreateFunction(extFnDescrs[i].name,
+                                                                       TyIdx(extFnDescrs[i].retType));
+    beCommon.UpdateTypeTable(*func->GetMIRFuncType());
+    func->AllocSymTab();
+    MIRSymbol *funcSym = func->GetFuncSymbol();
+    funcSym->SetStorageClass(kScExtern);
+    funcSym->SetAppearsInCode(true);
+    /* return type */
+    MIRType *retTy = GlobalTables::GetTypeTable().GetPrimType(extFnDescrs[i].retType);
+
+    /* use void* for PTY_dynany */
+    if (retTy->GetPrimType() == PTY_dynany) {
+      retTy = GlobalTables::GetTypeTable().GetPtr();
+    }
+
+    std::vector<MIRSymbol*> formals;
+    for (uint32 j = 0; extFnDescrs[i].argTypes[j] != kPtyInvalid; ++j) {
+      PrimType primTy = extFnDescrs[i].argTypes[j];
+      MIRType *argTy = GlobalTables::GetTypeTable().GetPrimType(primTy);
+      /* use void* for PTY_dynany */
+      if (argTy->GetPrimType() == PTY_dynany) {
+        argTy = GlobalTables::GetTypeTable().GetPtr();
+      }
+      MIRSymbol *argSt = func->GetSymTab()->CreateSymbol(kScopeLocal);
+      const uint32 bufSize = 18;
+      char buf[bufSize] = {'\0'};
+      int eNum = sprintf_s(buf, bufSize - 1, "p%u", j);
+      if (eNum == -1) {
+        FATAL(kLncFatal, "sprintf_s failed");
+      }
+      std::string strBuf(buf);
+      argSt->SetNameStrIdx(mirModule.GetMIRBuilder()->GetOrCreateStringIndex(strBuf));
+      argSt->SetTyIdx(argTy->GetTypeIndex());
+      argSt->SetStorageClass(kScFormal);
+      argSt->SetSKind(kStVar);
+      func->GetSymTab()->AddToStringSymbolMap(*argSt);
+      formals.emplace_back(argSt);
+    }
+    func->UpdateFuncTypeAndFormalsAndReturnType(formals, retTy->GetTypeIndex(), false);
+    auto *funcType = func->GetMIRFuncType();
+    ASSERT(funcType != nullptr, "null ptr check");
+    beCommon.AddTypeSizeAndAlign(funcType->GetTypeIndex(), GetPrimTypeSize(funcType->GetPrimType()));
+    extFuncs.emplace_back(std::pair<ExtFuncT, PUIdx>(id, func->GetPuidx()));
+  }
+}
+
+BaseNode *CGLowerer::NodeConvert(PrimType mType, BaseNode &expr) {
+  PrimType srcType = expr.GetPrimType();
+  if (GetPrimTypeSize(mType) == GetPrimTypeSize(srcType)) {
+    return &expr;
+  }
+  TypeCvtNode *cvtNode = mirModule.CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt);
+  cvtNode->SetFromType(srcType);
+  cvtNode->SetPrimType(mType);
+  cvtNode->SetOpnd(&expr, 0);
+  return cvtNode;
+}
+
+BaseNode *CGLowerer::LowerIaddrof(const IreadNode &iaddrof) {
+  if (iaddrof.GetFieldID() == 0) {
+    return iaddrof.Opnd(0);
+  }
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iaddrof.GetTyIdx());
+  MIRPtrType *pointerTy = static_cast<MIRPtrType*>(type);
+  CHECK_FATAL(pointerTy != nullptr, "LowerIaddrof: expect a pointer type at iaddrof node");
+  MIRStructType *structTy = static_cast<MIRStructType*>(
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerTy->GetPointedTyIdx()));
+  CHECK_FATAL(structTy != nullptr, "LowerIaddrof: non-zero fieldID for non-structure");
+  int32 offset = beCommon.GetFieldOffset(*structTy, iaddrof.GetFieldID()).first;
+  if (offset == 0) {
+    return iaddrof.Opnd(0);
+  }
+  uint32 loweredPtrType = static_cast<uint32>(GetLoweredPtrType());
+  MIRIntConst *offsetConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+      static_cast<uint64>(static_cast<int64>(offset)), *GlobalTables::GetTypeTable().GetTypeTable().at(loweredPtrType));
+  BaseNode *offsetNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(offsetConst);
+  offsetNode->SetPrimType(GetLoweredPtrType());
+
+  BinaryNode *addNode = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add);
+  addNode->SetPrimType(GetLoweredPtrType());
+  addNode->SetBOpnd(iaddrof.Opnd(0), 0);
+  addNode->SetBOpnd(offsetNode, 1);
+  return addNode;
+}
+
+BaseNode *CGLowerer::SplitBinaryNodeOpnd1(BinaryNode &bNode, BlockNode &blkNode) {
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel1) {
+    return &bNode;
+  }
+  MIRBuilder *mirbuilder = mirModule.GetMIRBuilder();
+  static uint32 val = 0;
+  std::string name("bnaryTmp");
+  name.append(std::to_string(val++));
+
+  BaseNode *opnd1 = bNode.Opnd(1);
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(opnd1->GetPrimType()));
+  MIRSymbol *dnodeSt = mirbuilder->GetOrCreateLocalDecl(const_cast<const std::string&>(name), *ty);
+  DassignNode *dnode = mirbuilder->CreateStmtDassign(const_cast<MIRSymbol&>(*dnodeSt), 0, opnd1);
+  blkNode.InsertAfter(blkNode.GetLast(), dnode);
+
+  BaseNode *dreadNode = mirbuilder->CreateExprDread(*dnodeSt);
+  bNode.SetOpnd(dreadNode, 1);
+
+  return &bNode;
+}
+
+BaseNode *CGLowerer::SplitTernaryNodeResult(TernaryNode &tNode, BaseNode &parent, BlockNode &blkNode) {
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel1) {
+    return &tNode;
+  }
+  MIRBuilder *mirbuilder = mirModule.GetMIRBuilder();
+  static uint32 val = 0;
+  std::string name("tnaryTmp");
+  name.append(std::to_string(val++));
+
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(tNode.GetPrimType()));
+  MIRSymbol *dassignNodeSym = mirbuilder->GetOrCreateLocalDecl(const_cast<const std::string&>(name), *ty);
+  DassignNode *dassignNode = mirbuilder->CreateStmtDassign(const_cast<MIRSymbol&>(*dassignNodeSym), 0, &tNode);
+  blkNode.InsertAfter(blkNode.GetLast(), dassignNode);
+
+  BaseNode *dreadNode = mirbuilder->CreateExprDread(*dassignNodeSym);
+  for (size_t i = 0; i < parent.NumOpnds(); i++) {
+    if (parent.Opnd(i) == &tNode) {
+      parent.SetOpnd(dreadNode, i);
+      break;
+    }
+  }
+
+  return dreadNode;
+}
+
+/* Check if the operand of the select node is complex enough for either
+ * functionality or performance reason so we need to lower it to if-then-else.
+ */
+bool CGLowerer::IsComplexSelect(const TernaryNode &tNode) const {
+  if (tNode.GetPrimType() == PTY_agg) {
+    return true;
+  }
+  /* Iread may have side effect which may cause correctness issue. */
+  if (HasIreadExpr(tNode.Opnd(1)) || HasIreadExpr(tNode.Opnd(2))) {
+    return true;
+  }
+  // it will be generated many insn for complex expr, leading to
+  // worse performance than punishment of branch prediction error
+  constexpr size_t maxDepth = 3;
+  if (MaxDepth(tNode.Opnd(1)) > maxDepth || MaxDepth(tNode.Opnd(1)) > maxDepth) {
+    return true;
+  }
+  return false;
+}
+
+int32 CGLowerer::FindTheCurrentStmtFreq(const StmtNode *stmt) const {
+  while (stmt != nullptr) {
+    int32 freq = mirModule.CurFunction()->GetFreqFromLastStmt(stmt->GetStmtID());
+    if (freq != -1) {
+      return freq;
+    }
+    stmt = stmt->GetPrev();
+  }
+  return -1;
+}
+
+/* Lower agg select node back to if-then-else stmt. */
+/*
+  0(brfalse)
+  |  \
+  1   2
+   \  |
+    \ |
+     3
+*/
+BaseNode *CGLowerer::LowerComplexSelect(const TernaryNode &tNode, BaseNode &parent, BlockNode &blkNode) {
+  MIRBuilder *mirbuilder = mirModule.GetMIRBuilder();
+
+  MIRType *resultTy = nullptr;
+  MIRFunction *func = mirModule.CurFunction();
+  if (tNode.GetPrimType() == PTY_agg) {
+    if (tNode.Opnd(1)->op == OP_dread) {
+      DreadNode *trueNode = static_cast<DreadNode *>(tNode.Opnd(1));
+      resultTy = mirModule.CurFunction()->GetLocalOrGlobalSymbol(trueNode->GetStIdx())->GetType();
+    } else if (tNode.Opnd(1)->op == OP_iread) {
+      IreadNode *trueNode = static_cast<IreadNode *>(tNode.Opnd(1));
+      MIRPtrType *ptrty =
+          static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(trueNode->GetTyIdx()));
+      resultTy = static_cast<MIRStructType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrty->GetPointedTyIdx()));
+      if (trueNode->GetFieldID() != 0) {
+        MIRStructType *structty = static_cast<MIRStructType *>(resultTy);
+        resultTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(structty->GetFieldTyIdx(trueNode->GetFieldID()));
+      }
+    } else {
+      CHECK_FATAL(false, "NYI: LowerComplexSelect");
+    }
+  } else {
+    resultTy =  GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(tNode.GetPrimType()));
+  }
+
+  CondGotoNode *brTargetStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brfalse);
+  brTargetStmt->SetOpnd(tNode.Opnd(0), 0);
+  LabelIdx targetIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(targetIdx);
+  brTargetStmt->SetOffset(targetIdx);
+  // Update the current stmt frequence
+  int32 currentStmtFreq = 0;
+  if (kOpcodeInfo.IsStmt(parent.GetOpCode())) {
+    currentStmtFreq = FindTheCurrentStmtFreq(static_cast<StmtNode*>(&parent));
+  }
+  currentStmtFreq = currentStmtFreq == -1 ? 0 : currentStmtFreq;
+  func->SetLastFreqMap(brTargetStmt->GetStmtID(), static_cast<uint32>(currentStmtFreq));
+  blkNode.InsertAfter(blkNode.GetLast(), brTargetStmt);
+  union {
+    MIRSymbol *resSym;
+    PregIdx resPreg;
+  } cplxSelRes; // complex select result
+  uint32 fallthruStmtFreq = static_cast<uint32>((currentStmtFreq + 1) / 2);
+  if (tNode.GetPrimType() == PTY_agg) {
+    static uint32 val = 0;
+    std::string name("ComplexSelectTmp");
+    name.append(std::to_string(val++));
+    cplxSelRes.resSym = mirbuilder->GetOrCreateLocalDecl(const_cast<std::string&>(name), *resultTy);
+    DassignNode *dassignTrue = mirbuilder->CreateStmtDassign(*cplxSelRes.resSym, 0, tNode.Opnd(1));
+    // Fallthru: update the frequence 1
+    func->SetFirstFreqMap(dassignTrue->GetStmtID(), fallthruStmtFreq);
+    blkNode.InsertAfter(blkNode.GetLast(), dassignTrue);
+  } else {
+    cplxSelRes.resPreg = mirbuilder->GetCurrentFunction()->GetPregTab()->CreatePreg(tNode.GetPrimType());
+    RegassignNode *regassignTrue =
+        mirbuilder->CreateStmtRegassign(tNode.GetPrimType(), cplxSelRes.resPreg, tNode.Opnd(1));
+    // Update the frequence first opnd
+    func->SetFirstFreqMap(regassignTrue->GetStmtID(), fallthruStmtFreq);
+    blkNode.InsertAfter(blkNode.GetLast(), regassignTrue);
+  }
+
+  GotoNode *gotoStmt = mirModule.CurFuncCodeMemPool()->New<GotoNode>(OP_goto);
+  LabelIdx endIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(endIdx);
+  gotoStmt->SetOffset(endIdx);
+  // Update the frequence first opnd
+  func->SetLastFreqMap(gotoStmt->GetStmtID(), fallthruStmtFreq);
+  blkNode.InsertAfter(blkNode.GetLast(), gotoStmt);
+
+  uint32 targetStmtFreq = static_cast<uint32>(currentStmtFreq / 2);
+  LabelNode *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  lableStmt->SetLabelIdx(targetIdx);
+  func->SetFirstFreqMap(lableStmt->GetStmtID(), targetStmtFreq);
+  blkNode.InsertAfter(blkNode.GetLast(), lableStmt);
+
+  if (tNode.GetPrimType() == PTY_agg) {
+    DassignNode *dassignFalse = mirbuilder->CreateStmtDassign(*cplxSelRes.resSym, 0, tNode.Opnd(2));
+    // Update the frequence second opnd
+    func->SetLastFreqMap(dassignFalse->GetStmtID(), targetStmtFreq);
+    blkNode.InsertAfter(blkNode.GetLast(), dassignFalse);
+  } else {
+    RegassignNode *regassignFalse =
+        mirbuilder->CreateStmtRegassign(tNode.GetPrimType(), cplxSelRes.resPreg, tNode.Opnd(2));
+    // Update the frequence 2
+    func->SetLastFreqMap(regassignFalse->GetStmtID(), targetStmtFreq);
+    blkNode.InsertAfter(blkNode.GetLast(), regassignFalse);
+  }
+
+  lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  lableStmt->SetLabelIdx(endIdx);
+  // Update the frequence third opnd
+  func->SetFirstFreqMap(lableStmt->GetStmtID(), static_cast<uint32>(currentStmtFreq));
+  blkNode.InsertAfter(blkNode.GetLast(), lableStmt);
+
+  BaseNode *exprNode = (tNode.GetPrimType() == PTY_agg) ?
+      static_cast<BaseNode*>(mirbuilder->CreateExprDread(*cplxSelRes.resSym)) :
+      static_cast<BaseNode*>(mirbuilder->CreateExprRegread(tNode.GetPrimType(), cplxSelRes.resPreg));
+  for (size_t i = 0; i < parent.NumOpnds(); i++) {
+    if (parent.Opnd(i) == &tNode) {
+      parent.SetOpnd(exprNode, i);
+      break;
+    }
+  }
+
+  return exprNode;
+}
+
+BaseNode *CGLowerer::LowerFarray(ArrayNode &array) {
+  auto *farrayType = static_cast<MIRFarrayType*>(array.GetArrayType(GlobalTables::GetTypeTable()));
+  size_t eSize = GlobalTables::GetTypeTable().GetTypeFromTyIdx(farrayType->GetElemTyIdx())->GetSize();
+  if (farrayType->GetKind() == kTypeJArray) {
+    if (farrayType->GetElemType()->GetKind() != kTypeScalar) {
+      /* not the last dimension of primitive array */
+      eSize = RTSupport::GetRTSupportInstance().GetObjectAlignment();
+    }
+  }
+
+  MIRType &arrayType = *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array.GetPrimType()));
+  /* how about multi-dimension array? */
+  if (array.GetIndex(0)->GetOpCode() == OP_constval) {
+    const ConstvalNode *constvalNode = static_cast<const ConstvalNode*>(array.GetIndex(0));
+    if (constvalNode->GetConstVal()->GetKind() == kConstInt) {
+      const MIRIntConst *pIntConst = static_cast<const MIRIntConst*>(constvalNode->GetConstVal());
+      CHECK_FATAL(JAVALANG || !pIntConst->IsNegative(), "Array index should >= 0.");
+      uint64 eleOffset = static_cast<uint64>(pIntConst->GetExtValue()) * eSize;
+
+      if (farrayType->GetKind() == kTypeJArray) {
+        eleOffset += static_cast<uint64>(RTSupport::GetRTSupportInstance().GetArrayContentOffset());
+      }
+
+      BaseNode *baseNode = NodeConvert(array.GetPrimType(), *array.GetBase());
+      if (eleOffset == 0) {
+        return baseNode;
+      }
+
+      MIRIntConst *eleConst =
+          GlobalTables::GetIntConstTable().GetOrCreateIntConst(eleOffset, arrayType);
+      BaseNode *offsetNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(eleConst);
+      offsetNode->SetPrimType(array.GetPrimType());
+
+      BaseNode *rAdd = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add);
+      rAdd->SetPrimType(array.GetPrimType());
+      rAdd->SetOpnd(baseNode, 0);
+      rAdd->SetOpnd(offsetNode, 1);
+      return rAdd;
+    }
+  }
+
+  BaseNode *resNode = NodeConvert(array.GetPrimType(), *array.GetIndex(0));
+  BaseNode *rMul = nullptr;
+
+  if ((farrayType->GetKind() == kTypeJArray) && (resNode->GetOpCode() == OP_constval)) {
+    ConstvalNode *idxNode = static_cast<ConstvalNode*>(resNode);
+    uint64 idx = static_cast<uint64>(safe_cast<MIRIntConst>(idxNode->GetConstVal())->GetExtValue());
+    MIRIntConst *eConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(idx * eSize, arrayType);
+    rMul = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(eConst);
+    rMul->SetPrimType(array.GetPrimType());
+  } else {
+    MIRIntConst *eConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(eSize, arrayType);
+    BaseNode *eSizeNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(eConst);
+    eSizeNode->SetPrimType(array.GetPrimType());
+    rMul = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_mul);
+    rMul->SetPrimType(array.GetPrimType());
+    rMul->SetOpnd(resNode, 0);
+    rMul->SetOpnd(eSizeNode, 1);
+  }
+
+  BaseNode *baseNode = NodeConvert(array.GetPrimType(), *array.GetBase());
+
+  if (farrayType->GetKind() == kTypeJArray) {
+    BaseNode *jarrayBaseNode = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add);
+    MIRIntConst *arrayHeaderNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        static_cast<uint64>(RTSupport::GetRTSupportInstance().GetArrayContentOffset()), arrayType);
+    BaseNode *arrayHeaderCstNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(arrayHeaderNode);
+    arrayHeaderCstNode->SetPrimType(array.GetPrimType());
+    jarrayBaseNode->SetPrimType(array.GetPrimType());
+    jarrayBaseNode->SetOpnd(baseNode, 0);
+    jarrayBaseNode->SetOpnd(arrayHeaderCstNode, 1);
+    baseNode = jarrayBaseNode;
+  }
+
+  BaseNode *rAdd = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add);
+  rAdd->SetPrimType(array.GetPrimType());
+  rAdd->SetOpnd(baseNode, 0);
+  rAdd->SetOpnd(rMul, 1);
+  return rAdd;
+}
+
+BaseNode *CGLowerer::LowerArrayDim(ArrayNode &array, int32 dim) {
+  BaseNode *resNode = NodeConvert(array.GetPrimType(), *array.GetIndex(dim - 1));
+  /* process left dimension index, resNode express the last dim, so dim need sub 2 */
+  CHECK_FATAL(dim > (std::numeric_limits<int>::min)() + 1, "out of range");
+  int leftDim = dim - 2;
+  MIRType *aType = array.GetArrayType(GlobalTables::GetTypeTable());
+  MIRArrayType *arrayType = static_cast<MIRArrayType*>(aType);
+  for (int i = leftDim; i >= 0; --i) {
+    BaseNode *mpyNode = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_mul);
+    BaseNode *item = NodeConvert(array.GetPrimType(), *array.GetDim(mirModule, GlobalTables::GetTypeTable(), dim - 1));
+    if (mirModule.IsCModule()) {
+      item = NodeConvert(array.GetPrimType(), *array.GetIndex(static_cast<size_t>(static_cast<uint>(i))));
+      int64 offsetSize = 1;
+      for (int32 j = i + 1; j < dim; ++j) {
+        offsetSize *= static_cast<int32>(arrayType->GetSizeArrayItem(static_cast<uint32>(j)));
+      }
+      MIRIntConst *offsetCst = mirModule.CurFuncCodeMemPool()->New<MIRIntConst>(
+          offsetSize, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(array.GetPrimType()));
+      BaseNode *eleOffset = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(offsetCst);
+      eleOffset->SetPrimType(array.GetPrimType());
+      mpyNode->SetPrimType(array.GetPrimType());
+      mpyNode->SetOpnd(eleOffset, 0);
+      mpyNode->SetOpnd(item, 1);
+    } else {
+      for (int j = leftDim; j > i; --j) {
+        BaseNode *mpyNodes = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_mul);
+        mpyNodes->SetPrimType(array.GetPrimType());
+        mpyNodes->SetOpnd(item, 0);
+        mpyNodes->SetOpnd(
+            NodeConvert(array.GetPrimType(), *array.GetDim(mirModule, GlobalTables::GetTypeTable(), j)), 1);
+        item = mpyNodes;
+      }
+      mpyNode->SetPrimType(array.GetPrimType());
+      mpyNode->SetOpnd(NodeConvert(array.GetPrimType(), *array.GetIndex(i)), 0);
+      mpyNode->SetOpnd(item, 1);
+    }
+
+    BaseNode *newResNode = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add);
+    newResNode->SetPrimType(array.GetPrimType());
+    newResNode->SetOpnd(resNode, 0);
+    newResNode->SetOpnd(mpyNode, 1);
+    resNode = newResNode;
+  }
+  return resNode;
+}
+
+BaseNode *CGLowerer::LowerArrayForLazyBiding(BaseNode &baseNode, BaseNode &offsetNode, const BaseNode &parent) {
+  if (parent.GetOpCode() == OP_iread && (baseNode.GetOpCode() == maple::OP_addrof)) {
+    const MIRSymbol *st =
+        mirModule.CurFunction()->GetLocalOrGlobalSymbol(static_cast<AddrofNode&>(baseNode).GetStIdx());
+    if (StringUtils::StartsWith(st->GetName(), namemangler::kDecoupleStaticValueStr) ||
+        ((StringUtils::StartsWith(st->GetName(), namemangler::kMuidFuncUndefTabPrefixStr) ||
+          StringUtils::StartsWith(st->GetName(), namemangler::kMuidFuncDefTabPrefixStr) ||
+          StringUtils::StartsWith(st->GetName(), namemangler::kMuidDataDefTabPrefixStr) ||
+          StringUtils::StartsWith(st->GetName(), namemangler::kMuidDataUndefTabPrefixStr)) &&
+         CGOptions::IsLazyBinding())) {
+      /* for decouple static or lazybinding def/undef tables, replace it with intrinsic */
+      MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+      args.emplace_back(&baseNode);
+      args.emplace_back(&offsetNode);
+      return mirBuilder->CreateExprIntrinsicop(INTRN_MPL_READ_STATIC_OFFSET_TAB, OP_intrinsicop,
+                                               *GlobalTables::GetTypeTable().GetPrimType(parent.GetPrimType()), args);
+    }
+  }
+  return nullptr;
+}
+
+BaseNode *CGLowerer::LowerArray(ArrayNode &array, const BaseNode &parent) {
+  MIRType *aType = array.GetArrayType(GlobalTables::GetTypeTable());
+  if (aType->GetKind() == kTypeFArray || aType->GetKind() == kTypeJArray) {
+    return LowerFarray(array);
+  }
+  MIRArrayType *arrayType = static_cast<MIRArrayType*>(aType);
+  int32 dim = arrayType->GetDim();
+  BaseNode *resNode = LowerArrayDim(array, dim);
+  BaseNode *rMul = nullptr;
+  size_t eSize = beCommon.GetTypeSize(arrayType->GetElemTyIdx().GetIdx());
+  Opcode opAdd = OP_add;
+  MIRType &arrayTypes = *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array.GetPrimType()));
+  if (resNode->GetOpCode() == OP_constval) {
+    /* index is a constant, we can calculate the offset now */
+    ConstvalNode *idxNode = static_cast<ConstvalNode*>(resNode);
+    uint64 idx = static_cast<uint64>(safe_cast<MIRIntConst>(idxNode->GetConstVal())->GetExtValue());
+    MIRIntConst *eConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(idx * eSize, arrayTypes);
+    rMul = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(eConst);
+    rMul->SetPrimType(array.GetPrimType());
+    if (dim == 1) {
+      opAdd = OP_CG_array_elem_add;
+    }
+  } else {
+    MIRIntConst *eConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(eSize, arrayTypes);
+    BaseNode *tmpNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(eConst);
+    tmpNode->SetPrimType(array.GetPrimType());
+    rMul = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_mul);
+    rMul->SetPrimType(array.GetPrimType());
+    rMul->SetOpnd(resNode, 0);
+    rMul->SetOpnd(tmpNode, 1);
+  }
+  BaseNode *baseNode = NodeConvert(array.GetPrimType(), *array.GetBase());
+  if (rMul->GetOpCode() == OP_constval) {
+    BaseNode *intrnNode = LowerArrayForLazyBiding(*baseNode, *rMul, parent);
+    if (intrnNode != nullptr) {
+      return intrnNode;
+    }
+  }
+  BaseNode *rAdd = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(opAdd);
+  rAdd->SetPrimType(array.GetPrimType());
+  rAdd->SetOpnd(baseNode, 0);
+  rAdd->SetOpnd(rMul, 1);
+  return rAdd;
+}
+
+BaseNode *CGLowerer::LowerCArray(ArrayNode &array) {
+  MIRType *aType = array.GetArrayType(GlobalTables::GetTypeTable());
+  if (aType->GetKind() == kTypeFArray || aType->GetKind() == kTypeJArray) {
+    return LowerFarray(array);
+  }
+
+  MIRArrayType *arrayType = static_cast<MIRArrayType *>(aType);
+  /* There are two cases where dimension > 1.
+   * 1) arrayType->dim > 1.  Process the current arrayType. (nestedArray = false)
+   * 2) arrayType->dim == 1, but arraytype->eTyIdx is another array. (nestedArray = true)
+   * Assume at this time 1) and 2) cannot mix.
+   * Along with the array dimension, there is the array indexing.
+   * It is allowed to index arrays less than the dimension.
+   * This is dictated by the number of indexes.
+   */
+  bool nestedArray = false;
+  int dim = arrayType->GetDim();
+  MIRType *innerType = nullptr;
+  MIRArrayType *innerArrayType = nullptr;
+  uint64 elemSize = 0;
+  if (dim == 1) {
+    innerType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrayType->GetElemTyIdx());
+    if (innerType->GetKind() == kTypeArray) {
+      nestedArray = true;
+      do {
+        innerArrayType = static_cast<MIRArrayType *>(innerType);
+        elemSize = RoundUp(beCommon.GetTypeSize(innerArrayType->GetElemTyIdx().GetIdx()),
+                           beCommon.GetTypeAlign(arrayType->GetElemTyIdx().GetIdx()));
+        dim++;
+        innerType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(innerArrayType->GetElemTyIdx());
+      } while (innerType->GetKind() == kTypeArray);
+    }
+  }
+
+  int32 numIndex = static_cast<int>(array.NumOpnds()) - 1;
+  MIRArrayType *curArrayType = arrayType;
+  BaseNode *resNode = NodeConvert(array.GetPrimType(), *array.GetIndex(0));
+  if (dim > 1) {
+    BaseNode *prevNode = nullptr;
+    for (int i = 0; (i < dim) && (i < numIndex); i++) {
+      uint32 mpyDim = 1;
+      if (nestedArray) {
+        CHECK_FATAL(arrayType->GetSizeArrayItem(0) > 0, "Zero size array dimension");
+        innerType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(curArrayType->GetElemTyIdx());
+        curArrayType = static_cast<MIRArrayType *>(innerType);
+        while (innerType->GetKind() == kTypeArray) {
+          innerArrayType = static_cast<MIRArrayType *>(innerType);
+          mpyDim *= innerArrayType->GetSizeArrayItem(0);
+          innerType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(innerArrayType->GetElemTyIdx());
+        }
+      } else {
+        CHECK_FATAL(arrayType->GetSizeArrayItem(static_cast<uint32>(i)) > 0, "Zero size array dimension");
+        for (int j = i + 1; j < dim; j++) {
+          mpyDim *= arrayType->GetSizeArrayItem(static_cast<uint32>(j));
+        }
+      }
+
+      BaseNode *index = static_cast<ConstvalNode *>(array.GetIndex(static_cast<size_t>(i)));
+      bool isConst = false;
+      uint64 indexVal = 0;
+      if (index->op == OP_constval) {
+        ConstvalNode *constNode = static_cast<ConstvalNode *>(index);
+        indexVal = static_cast<uint64>((static_cast<MIRIntConst *>(constNode->GetConstVal()))->GetExtValue());
+        isConst = true;
+        MIRIntConst *newConstNode = mirModule.GetMemPool()->New<MIRIntConst>(
+            indexVal * mpyDim, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array.GetPrimType())));
+        BaseNode *newValNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(newConstNode);
+        newValNode->SetPrimType(array.GetPrimType());
+        if (i == 0) {
+          prevNode = newValNode;
+          continue;
+        } else {
+          resNode = newValNode;
+        }
+      }
+      if (i > 0 && !isConst) {
+        resNode = NodeConvert(array.GetPrimType(), *array.GetIndex(static_cast<size_t>(i)));
+      }
+
+      BaseNode *mpyNode;
+      if (isConst) {
+        MIRIntConst *mulConst = mirModule.GetMemPool()->New<MIRIntConst>(
+            mpyDim * indexVal, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array.GetPrimType())));
+        BaseNode *mulSize = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(mulConst);
+        mulSize->SetPrimType(array.GetPrimType());
+        mpyNode = mulSize;
+      } else if (mpyDim == 1 && prevNode) {
+        mpyNode = prevNode;
+        prevNode = resNode;
+      } else {
+        mpyNode = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_mul);
+        mpyNode->SetPrimType(array.GetPrimType());
+        MIRIntConst *mulConst = mirModule.GetMemPool()->New<MIRIntConst>(
+            mpyDim, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array.GetPrimType())));
+        BaseNode *mulSize = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(mulConst);
+        mulSize->SetPrimType(array.GetPrimType());
+        mpyNode->SetOpnd(NodeConvert(array.GetPrimType(), *mulSize), 0);
+        mpyNode->SetOpnd(resNode, 1);
+      }
+      if (i == 0) {
+        prevNode = mpyNode;
+        continue;
+      }
+      BaseNode *newResNode = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add);
+      newResNode->SetPrimType(array.GetPrimType());
+      newResNode->SetOpnd(mpyNode, 0);
+      newResNode->SetOpnd(prevNode, 1);
+      prevNode = newResNode;
+    }
+    resNode = prevNode;
+  }
+
+  BaseNode *rMul = nullptr;
+  // esize is the size of the array element (eg. int = 4 long = 8)
+  uint64 esize;
+  if (nestedArray) {
+    esize = elemSize;
+  } else {
+    esize = beCommon.GetTypeSize(arrayType->GetElemTyIdx().GetIdx());
+  }
+  Opcode opadd = OP_add;
+  if (resNode->op == OP_constval) {
+    // index is a constant, we can calculate the offset now
+    ConstvalNode *idxNode = static_cast<ConstvalNode *>(resNode);
+    uint64 idx = static_cast<uint64>(static_cast<MIRIntConst *>(idxNode->GetConstVal())->GetExtValue());
+    MIRIntConst *econst = mirModule.GetMemPool()->New<MIRIntConst>(
+        idx * esize, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array.GetPrimType())));
+    rMul = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(econst);
+    rMul->SetPrimType(array.GetPrimType());
+    if (dim == 1 && array.GetBase()->op == OP_addrof && static_cast<AddrofNode *>(array.GetBase())->GetFieldID() == 0) {
+      opadd = OP_CG_array_elem_add;
+    }
+  } else {
+    MIRIntConst *econst = mirModule.GetMemPool()->New<MIRIntConst>(esize,
+        *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array.GetPrimType())));
+    BaseNode *eSize = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(econst);
+    eSize->SetPrimType(array.GetPrimType());
+    rMul = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_mul);
+    rMul->SetPrimType(array.GetPrimType());
+    rMul->SetOpnd(resNode, 0);
+    rMul->SetOpnd(eSize, 1);
+  }
+  BaseNode *baseNode = NodeConvert(array.GetPrimType(), *array.GetBase());
+  BaseNode *rAdd = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(opadd);
+  rAdd->SetPrimType(array.GetPrimType());
+  rAdd->SetOpnd(baseNode, 0);
+  rAdd->SetOpnd(rMul, 1);
+  return rAdd;
+}
+
+StmtNode *CGLowerer::WriteBitField(const std::pair<int32, int32> &byteBitOffsets, const MIRBitFieldType *fieldType,
+    BaseNode *baseAddr, BaseNode *rhs, BlockNode *block) {
+  auto bitSize = fieldType->GetFieldSize();
+  auto primType = fieldType->GetPrimType();
+  auto byteOffset = byteBitOffsets.first;
+  auto bitOffset = byteBitOffsets.second;
+  auto *builder = mirModule.GetMIRBuilder();
+  auto *bitField = builder->CreateExprIreadoff(primType, byteOffset, baseAddr);
+  auto primTypeBitSize = GetPrimTypeBitSize(primType);
+  if ((static_cast<uint32>(bitOffset) + bitSize) <= primTypeBitSize) {
+    if (CGOptions::IsBigEndian()) {
+      bitOffset = static_cast<int32>(static_cast<int64>(beCommon.GetTypeSize(fieldType->GetTypeIndex()) *
+          kBitsPerByte) - bitOffset) - bitSize;
+    }
+    auto depositBits = builder->CreateExprDepositbits(OP_depositbits, primType, static_cast<uint32>(bitOffset),
+        bitSize, bitField, rhs);
+    return builder->CreateStmtIassignoff(primType, byteOffset, baseAddr, depositBits);
+  }
+  // if space not enough in the unit with size of primType, we would make an extra assignment from next bound
+  auto bitsRemained = (static_cast<uint32>(bitOffset) + bitSize) - primTypeBitSize;
+  auto bitsExtracted = primTypeBitSize - static_cast<uint32>(bitOffset);
+  if (CGOptions::IsBigEndian()) {
+    bitOffset = 0;
+  }
+  auto *depositedLowerBits = builder->CreateExprDepositbits(OP_depositbits, primType,
+      static_cast<uint32>(bitOffset), bitsExtracted, bitField, rhs);
+  auto *assignedLowerBits = builder->CreateStmtIassignoff(primType, byteOffset, baseAddr, depositedLowerBits);
+  block->AddStatement(assignedLowerBits);
+  auto *extractedHigherBits =
+      builder->CreateExprExtractbits(OP_extractbits, primType, bitsExtracted, bitsRemained, rhs);
+  auto *bitFieldRemained = builder->CreateExprIreadoff(primType,
+      byteOffset + static_cast<int32>(GetPrimTypeSize(primType)), baseAddr);
+  auto *depositedHigherBits =
+      builder->CreateExprDepositbits(OP_depositbits, primType, 0, bitsRemained, bitFieldRemained, extractedHigherBits);
+  auto *assignedHigherBits = builder->CreateStmtIassignoff(primType,
+      byteOffset + static_cast<int32>(GetPrimTypeSize(primType)), baseAddr, depositedHigherBits);
+  return assignedHigherBits;
+}
+
+BaseNode *CGLowerer::ReadBitField(const std::pair<int32, int32> &byteBitOffsets, const MIRBitFieldType *fieldType,
+    BaseNode *baseAddr) {
+  auto bitSize = fieldType->GetFieldSize();
+  auto primType = fieldType->GetPrimType();
+  auto byteOffset = byteBitOffsets.first;
+  auto bitOffset = byteBitOffsets.second;
+  auto *builder = mirModule.GetMIRBuilder();
+  auto *bitField = builder->CreateExprIreadoff(primType, byteOffset, baseAddr);
+  auto primTypeBitSize = GetPrimTypeBitSize(primType);
+  if ((static_cast<uint32>(bitOffset) + bitSize) <= primTypeBitSize) {
+    if (CGOptions::IsBigEndian()) {
+      bitOffset = static_cast<int32>(static_cast<int64>(beCommon.GetTypeSize(fieldType->GetTypeIndex()) *
+          kBitsPerByte) - bitOffset) - bitSize;
+    }
+    return builder->CreateExprExtractbits(OP_extractbits, primType, static_cast<uint32>(bitOffset), bitSize, bitField);
+  }
+  // if space not enough in the unit with size of primType, the result would be binding of two exprs of load
+  auto bitsRemained = (static_cast<uint32>(bitOffset) + bitSize) - primTypeBitSize;
+  if (CGOptions::IsBigEndian()) {
+    bitOffset = 0;
+  }
+  auto *extractedLowerBits = builder->CreateExprExtractbits(OP_extractbits, primType,
+      static_cast<uint32>(bitOffset), bitSize - bitsRemained, bitField);
+  auto *bitFieldRemained = builder->CreateExprIreadoff(primType,
+      byteOffset + static_cast<int32>(GetPrimTypeSize(primType)), baseAddr);
+  auto *result = builder->CreateExprDepositbits(OP_depositbits, primType, bitSize - bitsRemained, bitsRemained,
+      extractedLowerBits, bitFieldRemained);
+  return result;
+}
+
+BaseNode *CGLowerer::LowerDreadBitfield(DreadNode &dread) {
+  auto *symbol = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dread.GetStIdx());
+  auto *structTy = static_cast<MIRStructType*>(symbol->GetType());
+  auto fTyIdx = structTy->GetFieldTyIdx(dread.GetFieldID());
+  auto *fType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(fTyIdx));
+  if (fType->GetKind() != kTypeBitField) {
+    return &dread;
+  }
+  auto *builder = mirModule.GetMIRBuilder();
+  auto *baseAddr = builder->CreateExprAddrof(0, dread.GetStIdx());
+  auto byteBitOffsets = beCommon.GetFieldOffset(*structTy, dread.GetFieldID());
+  return ReadBitField(byteBitOffsets, static_cast<MIRBitFieldType*>(fType), baseAddr);
+}
+
+BaseNode *CGLowerer::LowerIreadBitfield(IreadNode &iread) {
+  uint32 index = iread.GetTyIdx();
+  MIRPtrType *pointerTy = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(index));
+  MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerTy->GetPointedTyIdx());
+  /* Here pointed type can be Struct or JArray */
+  MIRStructType *structTy = nullptr;
+  if (pointedTy->GetKind() != kTypeJArray) {
+    structTy = static_cast<MIRStructType*>(pointedTy);
+  } else {
+    /* it's a Jarray type. using it's parent's field info: java.lang.Object */
+    structTy = static_cast<MIRJarrayType*>(pointedTy)->GetParentType();
+  }
+  TyIdx fTyIdx = structTy->GetFieldTyIdx(iread.GetFieldID());
+  MIRType *fType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(fTyIdx));
+  if (fType->GetKind() != kTypeBitField) {
+    return &iread;
+  }
+  auto byteBitOffsets = beCommon.GetFieldOffset(*structTy, iread.GetFieldID());
+  return ReadBitField(byteBitOffsets, static_cast<MIRBitFieldType*>(fType), iread.Opnd(0));
+}
+
+// input node must be cvt, retype, zext or sext
+BaseNode *CGLowerer::LowerCastExpr(BaseNode &expr) const {
+  if (CGOptions::GetInstance().GetOptimizeLevel() >= CGOptions::kLevel2) {
+    BaseNode *simplified = MapleCastOpt::SimplifyCast(*mirBuilder, &expr);
+    return simplified != nullptr ? simplified : &expr;
+  }
+  return &expr;
+}
+
+void CGLowerer::LowerTypePtr(BaseNode &node) const {
+  if ((node.GetPrimType() == PTY_ptr) || (node.GetPrimType() == PTY_ref)) {
+    node.SetPrimType(GetLoweredPtrType());
+  }
+
+  if (kOpcodeInfo.IsTypeCvt(node.GetOpCode())) {
+    auto &cvt = static_cast<TypeCvtNode&>(node);
+    if ((cvt.FromType() == PTY_ptr) || (cvt.FromType() == PTY_ref)) {
+      cvt.SetFromType(GetLoweredPtrType());
+    }
+  } else if (kOpcodeInfo.IsCompare(node.GetOpCode())) {
+    auto &cmp = static_cast<CompareNode&>(node);
+    if ((cmp.GetOpndType() == PTY_ptr) || (cmp.GetOpndType() == PTY_ref)) {
+      cmp.SetOpndType(GetLoweredPtrType());
+    }
+  }
+}
+
+
+#if TARGARM32 || TARGAARCH64 || TARGRISCV64 || TARGX86_64
+BlockNode *CGLowerer::LowerReturnStructUsingFakeParm(NaryStmtNode &retNode) {
+  BlockNode *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  for (size_t i = 0; i < retNode.GetNopndSize(); ++i) {
+    retNode.SetOpnd(LowerExpr(retNode, *retNode.GetNopndAt(i), *blk), i);
+  }
+  BaseNode *opnd0 = retNode.Opnd(0);
+  if (!(opnd0 && opnd0->GetPrimType() == PTY_agg)) {
+    /* It is possible function never returns and have a dummy return const instead of a struct. */
+    maple::LogInfo::MapleLogger(kLlWarn) << "return struct should have a kid" << std::endl;
+  }
+
+  MIRFunction *curFunc = GetCurrentFunc();
+  MIRSymbol *retSt = curFunc->GetFormal(0);
+  MIRPtrType *retTy = static_cast<MIRPtrType*>(retSt->GetType());
+  IassignNode *iassign = mirModule.CurFuncCodeMemPool()->New<IassignNode>();
+  iassign->SetTyIdx(retTy->GetTypeIndex());
+  ASSERT(opnd0 != nullptr, "opnd0 should not be nullptr");
+  if ((beCommon.GetTypeSize(retTy->GetPointedTyIdx().GetIdx()) <= k16ByteSize) && (opnd0->GetPrimType() == PTY_agg)) {
+    /* struct goes into register. */
+    curFunc->SetStructReturnedInRegs();
+  }
+  iassign->SetFieldID(0);
+  iassign->SetRHS(opnd0);
+  if (retSt->IsPreg()) {
+    RegreadNode *regNode = mirModule.GetMIRBuilder()->CreateExprRegread(
+        GetLoweredPtrType(),
+        curFunc->GetPregTab()->GetPregIdxFromPregno(static_cast<uint32>(retSt->GetPreg()->GetPregNo())));
+    iassign->SetOpnd(regNode, 0);
+  } else {
+    AddrofNode *dreadNode = mirModule.CurFuncCodeMemPool()->New<AddrofNode>(OP_dread);
+    dreadNode->SetPrimType(GetLoweredPtrType());
+    dreadNode->SetStIdx(retSt->GetStIdx());
+    iassign->SetOpnd(dreadNode, 0);
+  }
+  blk->AddStatement(iassign);
+  retNode.GetNopnd().clear();
+  retNode.SetNumOpnds(0);
+  blk->AddStatement(&retNode);
+  return blk;
+}
+
+#endif /* TARGARM32 || TARGAARCH64 || TARGX86_64 */
+
+BlockNode *CGLowerer::LowerReturn(NaryStmtNode &retNode) {
+  BlockNode *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  if (retNode.NumOpnds() != 0) {
+    BaseNode *expr = retNode.Opnd(0);
+    Opcode opr = expr->GetOpCode();
+    if (opr == OP_dread) {
+      AddrofNode *retExpr = static_cast<AddrofNode*>(expr);
+      MIRFunction *mirFunc = mirModule.CurFunction();
+      MIRSymbol *sym = mirFunc->GetLocalOrGlobalSymbol(retExpr->GetStIdx());
+      if (sym->GetAttr(ATTR_localrefvar)) {
+        mirFunc->InsertMIRSymbol(sym);
+      }
+    }
+  }
+  for (size_t i = 0; i < retNode.GetNopndSize(); ++i) {
+    retNode.SetOpnd(LowerExpr(retNode, *retNode.GetNopndAt(i), *blk), i);
+  }
+  blk->AddStatement(&retNode);
+  return blk;
+}
+
+StmtNode *CGLowerer::LowerDassignBitfield(DassignNode &dassign, BlockNode &newBlk) {
+  dassign.SetRHS(LowerExpr(dassign, *dassign.GetRHS(), newBlk));
+  MIRSymbol *symbol = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dassign.GetStIdx());
+  MIRStructType *structTy = static_cast<MIRStructType*>(symbol->GetType());
+  CHECK_FATAL(structTy != nullptr, "LowerDassignBitfield: non-zero fieldID for non-structure");
+  TyIdx fTyIdx = structTy->GetFieldTyIdx(dassign.GetFieldID());
+  CHECK_FATAL(fTyIdx != 0u, "LowerDassignBitField: field id out of range for the structure");
+  MIRType *fType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(fTyIdx));
+  if (fType->GetKind() != kTypeBitField) {
+    return &dassign;
+  }
+  auto *builder = mirModule.GetMIRBuilder();
+  auto *baseAddr = builder->CreateExprAddrof(0, dassign.GetStIdx());
+  auto byteBitOffsets = beCommon.GetFieldOffset(*structTy, dassign.GetFieldID());
+  return WriteBitField(byteBitOffsets, static_cast<MIRBitFieldType*>(fType), baseAddr, dassign.GetRHS(), &newBlk);
+}
+
+StmtNode *CGLowerer::LowerIassignBitfield(IassignNode &iassign, BlockNode &newBlk) {
+  ASSERT(iassign.Opnd(0) != nullptr, "iassign.Opnd(0) should not be nullptr");
+  iassign.SetOpnd(LowerExpr(iassign, *iassign.Opnd(0), newBlk), 0);
+  iassign.SetRHS(LowerExpr(iassign, *iassign.GetRHS(), newBlk));
+
+  CHECK_FATAL(iassign.GetTyIdx() < GlobalTables::GetTypeTable().GetTypeTable().size(),
+              "LowerIassignBitField: subscript out of range");
+  uint32 index = iassign.GetTyIdx();
+  MIRPtrType *pointerTy = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(index));
+  CHECK_FATAL(pointerTy != nullptr, "LowerIassignBitField: type in iassign should be pointer type");
+  MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerTy->GetPointedTyIdx());
+  /*
+   * Here pointed type can be Struct or JArray
+   * We should seriously consider make JArray also a Struct type
+   */
+  MIRStructType *structTy = nullptr;
+  if (pointedTy->GetKind() != kTypeJArray) {
+    structTy = static_cast<MIRStructType*>(pointedTy);
+  } else {
+    /* it's a Jarray type. using it's parent's field info: java.lang.Object */
+    structTy = static_cast<MIRJarrayType*>(pointedTy)->GetParentType();
+  }
+
+  TyIdx fTyIdx = structTy->GetFieldTyIdx(iassign.GetFieldID());
+  MIRType *fType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(fTyIdx));
+  if (fType->GetKind() != kTypeBitField) {
+    return &iassign;
+  }
+  auto byteBitOffsets = beCommon.GetFieldOffset(*structTy, iassign.GetFieldID());
+  auto *bitFieldType = static_cast<MIRBitFieldType*>(fType);
+  return WriteBitField(byteBitOffsets, bitFieldType, iassign.Opnd(0), iassign.GetRHS(), &newBlk);
+}
+
+void CGLowerer::LowerIassign(IassignNode &iassign, BlockNode &newBlk) {
+  StmtNode *newStmt = nullptr;
+  if (iassign.GetFieldID() != 0) {
+    newStmt = LowerIassignBitfield(iassign, newBlk);
+  } else {
+    CHECK_FATAL(iassign.GetPrimType() != PTY_ptr, "should have been lowered already");
+    CHECK_FATAL(iassign.GetPrimType() != PTY_ref, "should have been lowered already");
+    LowerStmt(iassign, newBlk);
+    newStmt = &iassign;
+  }
+  newBlk.AddStatement(newStmt);
+}
+
+static GStrIdx NewAsmTempStrIdx() {
+  static uint32 strIdxCount = 0;  // to create unique temporary symbol names
+  std::string asmTempStr("asm_tempvar");
+  (void)asmTempStr.append(std::to_string(++strIdxCount));
+  return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(asmTempStr);
+}
+
+void CGLowerer::LowerAsmStmt(AsmNode *asmNode, BlockNode *newBlk) {
+  for (size_t i = 0; i < asmNode->NumOpnds(); i++) {
+    BaseNode *opnd = LowerExpr(*asmNode, *asmNode->Opnd(i), *newBlk);
+    if (opnd->NumOpnds() == 0) {
+      asmNode->SetOpnd(opnd, i);
+      continue;
+    }
+    // introduce a temporary to store the expression tree operand
+    TyIdx tyIdxUsed = static_cast<TyIdx>(opnd->GetPrimType());
+    if (opnd->op == OP_iread) {
+      IreadNode *ireadNode = static_cast<IreadNode *>(opnd);
+      tyIdxUsed = ireadNode->GetType()->GetTypeIndex();
+    }
+    StmtNode *assignNode = nullptr;
+    BaseNode *readOpnd = nullptr;
+    PrimType type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdxUsed)->GetPrimType();
+    if ((type != PTY_agg) && CGOptions::GetInstance().GetOptimizeLevel() >= CGOptions::kLevel2) {
+      PregIdx pregIdx = mirModule.CurFunction()->GetPregTab()->CreatePreg(type);
+      assignNode = mirBuilder->CreateStmtRegassign(type, pregIdx, opnd);
+      readOpnd = mirBuilder->CreateExprRegread(type, pregIdx);
+    } else {
+      MIRSymbol *st = mirModule.GetMIRBuilder()->CreateSymbol(tyIdxUsed, NewAsmTempStrIdx(),
+          kStVar, kScAuto, mirModule.CurFunction(), kScopeLocal);
+      assignNode = mirModule.GetMIRBuilder()->CreateStmtDassign(*st, 0, opnd);
+      readOpnd = mirBuilder->CreateExprDread(*st);
+    }
+    newBlk->AddStatement(assignNode);
+    asmNode->SetOpnd(readOpnd, i);
+  }
+  newBlk->AddStatement(asmNode);
+}
+
+DassignNode *CGLowerer::SaveReturnValueInLocal(StIdx stIdx, uint16 fieldID) {
+  MIRSymbol *var;
+  if (stIdx.IsGlobal()) {
+    var = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+  } else {
+    var = GetCurrentFunc()->GetSymbolTabItem(stIdx.Idx());
+  }
+  CHECK_FATAL(var != nullptr, "var should not be nullptr");
+  PrimType pType;
+  if (var->GetAttr(ATTR_oneelem_simd)) {
+    pType = PTY_f64;
+  } else {
+    pType = GlobalTables::GetTypeTable().GetTypeTable().at(var->GetTyIdx())->GetPrimType();
+  }
+  RegreadNode *regRead = mirModule.GetMIRBuilder()->CreateExprRegread(pType, -kSregRetval0);
+  return mirModule.GetMIRBuilder()->CreateStmtDassign(*var, fieldID, regRead);
+}
+
+BaseNode *CGLowerer::LowerExtractBits(ExtractbitsNode &extr) const {
+  PrimType nodeType = extr.GetPrimType();
+  PrimType opndType = extr.Opnd(0)->GetPrimType();
+  if (!IsPrimitiveInteger(nodeType) || !IsPrimitiveInteger(opndType) ||
+      GetPrimTypeSize(GetRegPrimType(nodeType)) == GetPrimTypeSize(GetRegPrimType(opndType))) {
+    return &extr;
+  }
+  // instructions hope the reg-sizes of src and dst are same
+  if (GetPrimTypeSize(nodeType) > GetPrimTypeSize(opndType)) {
+    auto *newOpnd = mirBuilder->CreateExprTypeCvt(OP_cvt, GetRegPrimType(nodeType), opndType, *extr.Opnd(0));
+    extr.SetOpnd(newOpnd, 0);
+    return &extr;
+  } else {
+    PrimType newType = IsSignedInteger(nodeType) ? GetSignedPrimType(GetRegPrimType(opndType))
+                                                 : GetUnsignedPrimType(GetRegPrimType(opndType));
+    extr.SetPrimType(newType);
+    return mirBuilder->CreateExprTypeCvt(OP_cvt, nodeType, newType, extr);
+  }
+}
+
+BaseNode *CGLowerer::LowerRem(BaseNode &expr, BlockNode &blk) {
+  auto &remExpr = static_cast<BinaryNode&>(expr);
+  if (!IsPrimitiveFloat(remExpr.GetPrimType())) {
+    return &expr;
+  }
+  ExtFuncT fmodFunc = remExpr.GetPrimType() == PTY_f32 ? kFmodFloat : kFmodDouble;
+  uint32 i = 0;
+  for (; i < extFuncs.size(); ++i) {
+    if (extFuncs[i].first == fmodFunc) {
+      break;
+    }
+  }
+  CHECK_FATAL(i < extFuncs.size(), "rem expression primtype is not PTY_f32 nor PTY_f64.");
+  MIRSymbol *ret = CreateNewRetVar(*GlobalTables::GetTypeTable().GetPrimType(remExpr.GetPrimType()),
+                                   kIntrnRetValPrefix);
+  MapleVector<BaseNode*> args(mirModule.GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.emplace_back(remExpr.Opnd(0));
+  args.emplace_back(remExpr.Opnd(1));
+  CallNode *callStmt = mirModule.GetMIRBuilder()->CreateStmtCallAssigned(extFuncs[i].second, args, ret);
+  blk.AppendStatementsFromBlock(*LowerCallAssignedStmt(*callStmt));
+  MIRType *type = GlobalTables::GetTypeTable().GetPrimType(extFnDescrs[fmodFunc].retType);
+  return mirModule.GetMIRBuilder()->CreateExprDread(*type, 0, *ret);
+}
+
+/* to lower call (including icall) and intrinsicall statements */
+void CGLowerer::LowerCallStmt(StmtNode &stmt, StmtNode *&nextStmt, BlockNode &newBlk, MIRType *retty, bool uselvar,
+                              bool isIntrinAssign) {
+  StmtNode *newStmt = nullptr;
+  if (stmt.GetOpCode() == OP_intrinsiccall) {
+    auto &intrnNode = static_cast<IntrinsiccallNode&>(stmt);
+    newStmt = LowerIntrinsiccall(intrnNode, newBlk);
+  } else {
+    /* We note the function has a user-defined (i.e., not an intrinsic) call. */
+    GetCurrentFunc()->SetHasCall();
+    newStmt = &stmt;
+  }
+
+  if (newStmt == nullptr) {
+    return;
+  }
+
+  if (newStmt->GetOpCode() == OP_call || newStmt->GetOpCode() == OP_icall || newStmt->GetOpCode() == OP_icallproto) {
+    newStmt = LowerCall(static_cast<CallNode&>(*newStmt), nextStmt, newBlk, retty, uselvar);
+  }
+  newStmt->SetSrcPos(stmt.GetSrcPos());
+  newBlk.AddStatement(newStmt);
+  if (CGOptions::GetInstance().GetOptimizeLevel() >= CGOptions::kLevel2 && stmt.GetOpCode() == OP_intrinsiccall) {
+    /* Try to expand memset and memcpy call lowered from intrinsiccall */
+    /* Skip expansion if call returns a value that is used later. */
+    BlockNode *blkLowered = isIntrinAssign ? nullptr : LowerMemop(*newStmt);
+    if (blkLowered != nullptr) {
+      newBlk.RemoveStmt(newStmt);
+      newBlk.AppendStatementsFromBlock(*blkLowered);
+    }
+  }
+}
+
+StmtNode *CGLowerer::GenCallNode(const StmtNode &stmt, PUIdx &funcCalled, CallNode& origCall) {
+  StmtNode *newCall = nullptr;
+  if (stmt.GetOpCode() == OP_callassigned) {
+    newCall = mirModule.GetMIRBuilder()->CreateStmtCall(origCall.GetPUIdx(), origCall.GetNopnd());
+  } else if (stmt.GetOpCode() == OP_virtualcallassigned) {
+    newCall = mirModule.GetMIRBuilder()->CreateStmtVirtualCall(origCall.GetPUIdx(), origCall.GetNopnd());
+  } else if (stmt.GetOpCode() == OP_superclasscallassigned) {
+    newCall = mirModule.GetMIRBuilder()->CreateStmtSuperclassCall(origCall.GetPUIdx(), origCall.GetNopnd());
+  } else if (stmt.GetOpCode() == OP_interfacecallassigned) {
+    newCall = mirModule.GetMIRBuilder()->CreateStmtInterfaceCall(origCall.GetPUIdx(), origCall.GetNopnd());
+  }
+  CHECK_FATAL(newCall != nullptr, "nullptr is not expected");
+  newCall->SetSrcPos(stmt.GetSrcPos());
+  funcCalled = origCall.GetPUIdx();
+  CHECK_FATAL((newCall->GetOpCode() == OP_call || newCall->GetOpCode() == OP_interfacecall),
+              "virtual call or super class call are not expected");
+  if (newCall->GetOpCode() == OP_interfacecall) {
+    std::cerr << "interfacecall found\n";
+  }
+  return newCall;
+}
+
+StmtNode *CGLowerer::GenIntrinsiccallNode(const StmtNode &stmt, PUIdx &funcCalled, bool &handledAtLowerLevel,
+                                          IntrinsiccallNode &origCall) {
+  StmtNode *newCall = nullptr;
+  handledAtLowerLevel = IsIntrinsicCallHandledAtLowerLevel(origCall.GetIntrinsic());
+  if (handledAtLowerLevel) {
+    /* If the lower level can handle the intrinsic, just let it pass through. */
+    newCall = &origCall;
+  } else {
+    PUIdx bFunc = GetBuiltinToUse(origCall.GetIntrinsic());
+    if (bFunc != kFuncNotFound) {
+      newCall = mirModule.GetMIRBuilder()->CreateStmtCall(bFunc, origCall.GetNopnd());
+      CHECK_FATAL(newCall->GetOpCode() == OP_call, "intrinsicnode except intrinsiccall is not expected");
+    } else {
+      if (stmt.GetOpCode() == OP_intrinsiccallassigned) {
+        newCall = mirModule.GetMIRBuilder()->CreateStmtIntrinsicCall(origCall.GetIntrinsic(), origCall.GetNopnd());
+        CHECK_FATAL(newCall->GetOpCode() == OP_intrinsiccall, "intrinsicnode except intrinsiccall is not expected");
+      } else if (stmt.GetOpCode() == OP_xintrinsiccallassigned) {
+        newCall = mirModule.GetMIRBuilder()->CreateStmtXintrinsicCall(origCall.GetIntrinsic(), origCall.GetNopnd());
+        CHECK_FATAL(newCall->GetOpCode() == OP_intrinsiccall, "intrinsicnode except intrinsiccall is not expected");
+      } else {
+        newCall = mirModule.GetMIRBuilder()->CreateStmtIntrinsicCall(origCall.GetIntrinsic(), origCall.GetNopnd(),
+            origCall.GetTyIdx());
+        CHECK_FATAL(newCall->GetOpCode() == OP_intrinsiccallwithtype,
+            "intrinsicnode except OP_intrinsiccallwithtype is not expected");
+      }
+    }
+    newCall->SetSrcPos(stmt.GetSrcPos());
+    funcCalled = bFunc;
+  }
+  return newCall;
+}
+
+StmtNode *CGLowerer::GenIcallNode(PUIdx &funcCalled, IcallNode &origCall) {
+  StmtNode *newCall = nullptr;
+  if (origCall.GetOpCode() == OP_icallassigned) {
+    newCall = mirModule.GetMIRBuilder()->CreateStmtIcall(origCall.GetNopnd());
+  } else {
+    newCall = mirModule.GetMIRBuilder()->CreateStmtIcallproto(origCall.GetNopnd(), origCall.GetRetTyIdx());
+  }
+  newCall->SetSrcPos(origCall.GetSrcPos());
+  CHECK_FATAL(newCall != nullptr, "nullptr is not expected");
+  funcCalled = kFuncNotFound;
+  return newCall;
+}
+
+BlockNode *CGLowerer::GenBlockNode(StmtNode &newCall, const CallReturnVector &p2nRets, const Opcode &opcode,
+                                   const PUIdx &funcCalled, bool handledAtLowerLevel, bool uselvar) {
+  BlockNode *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  blk->AddStatement(&newCall);
+  if (!handledAtLowerLevel) {
+    CHECK_FATAL(p2nRets.size() <= 1, "make sure p2nRets size <= 1");
+    /* Create DassignStmt to save kSregRetval0. */
+    StmtNode *dStmt = nullptr;
+    MIRType *retType = nullptr;
+    if (p2nRets.size() == 1) {
+      MIRSymbol *sym = nullptr;
+      StIdx stIdx = p2nRets[0].first;
+      if (stIdx.IsGlobal()) {
+        sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+      } else {
+        sym = GetCurrentFunc()->GetSymbolTabItem(stIdx.Idx());
+      }
+      bool sizeIs0 = false;
+      if (sym != nullptr) {
+        retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx());
+        if (beCommon.GetTypeSize(retType->GetTypeIndex().GetIdx()) == 0) {
+          sizeIs0 = true;
+        }
+      }
+      if (!sizeIs0) {
+        RegFieldPair regFieldPair = p2nRets[0].second;
+        if (!regFieldPair.IsReg()) {
+          uint16 fieldID = static_cast<uint16>(regFieldPair.GetFieldID());
+          DassignNode *dn = SaveReturnValueInLocal(stIdx, fieldID);
+          CHECK_FATAL(dn->GetFieldID() == 0, "make sure dn's fieldID return 0");
+          LowerDassign(*dn, *blk);
+          CHECK_FATAL(&newCall == blk->GetLast() || newCall.GetNext() == blk->GetLast(), "");
+          dStmt = (&newCall == blk->GetLast()) ? nullptr : blk->GetLast();
+          CHECK_FATAL(newCall.GetNext() == dStmt, "make sure newCall's next equal dStmt");
+        } else {
+          PregIdx pregIdx = static_cast<PregIdx>(regFieldPair.GetPregIdx());
+          MIRPreg *mirPreg = GetCurrentFunc()->GetPregTab()->PregFromPregIdx(pregIdx);
+          bool is64x1vec = beCommon.CallIsOfAttr(FUNCATTR_oneelem_simd, &newCall);
+          PrimType pType = is64x1vec ? PTY_f64 : mirPreg->GetPrimType();
+          RegreadNode *regNode = mirModule.GetMIRBuilder()->CreateExprRegread(pType, -kSregRetval0);
+          RegassignNode *regAssign;
+          if (is64x1vec && IsPrimitiveInteger(mirPreg->GetPrimType())) {  // not f64
+            MIRType *to;
+            if (IsUnsignedInteger(mirPreg->GetPrimType())) {
+              to = GlobalTables::GetTypeTable().GetUInt64();
+            } else {
+              to = GlobalTables::GetTypeTable().GetInt64();
+            }
+            MIRType *from = GlobalTables::GetTypeTable().GetDouble();
+            BaseNode *rNode = mirModule.GetMIRBuilder()->CreateExprRetype(*to, *from, regNode);
+            regAssign = mirModule.GetMIRBuilder()->CreateStmtRegassign(mirPreg->GetPrimType(),
+                regFieldPair.GetPregIdx(), rNode);
+          } else {
+            regAssign = mirModule.GetMIRBuilder()->CreateStmtRegassign(mirPreg->GetPrimType(),
+                regFieldPair.GetPregIdx(), regNode);
+          }
+          blk->AddStatement(regAssign);
+          dStmt = regAssign;
+        }
+      }
+    }
+    blk->ResetBlock();
+    /* if VerboseCG, insert a comment */
+    if (ShouldAddAdditionalComment()) {
+      CommentNode *cmnt = mirModule.CurFuncCodeMemPool()->New<CommentNode>(mirModule);
+      cmnt->SetComment(kOpcodeInfo.GetName(opcode).c_str());
+      if (funcCalled == kFuncNotFound) {
+        cmnt->Append(" : unknown");
+      } else {
+        cmnt->Append(" : ");
+        cmnt->Append(GlobalTables::GetFunctionTable().GetFunctionFromPuidx(funcCalled)->GetName());
+      }
+      blk->AddStatement(cmnt);
+    }
+    CHECK_FATAL(dStmt == nullptr || dStmt->GetNext() == nullptr, "make sure dStmt or dStmt's next is nullptr");
+    LowerCallStmt(newCall, dStmt, *blk, retType, uselvar ? true : false, opcode == OP_intrinsiccallassigned);
+    if (!uselvar && dStmt != nullptr) {
+      dStmt->SetSrcPos(newCall.GetSrcPos());
+      blk->AddStatement(dStmt);
+    }
+  }
+  return blk;
+}
+
+// try to expand memset and memcpy
+BlockNode *CGLowerer::LowerMemop(StmtNode &stmt) {
+  auto memOpKind = SimplifyOp::ComputeOpKind(stmt);
+  if (memOpKind == MEM_OP_unknown) {
+    return nullptr;
+  }
+  auto *prev = stmt.GetPrev();
+  auto *next = stmt.GetNext();
+  auto *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  blk->AddStatement(&stmt);
+  uint32 oldTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  bool success = simplifyOp.AutoSimplify(stmt, *blk, true);
+  uint32 newTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  if (newTypeTableSize != oldTypeTableSize) {
+    beCommon.AddNewTypeAfterBecommon(oldTypeTableSize, newTypeTableSize);
+  }
+  stmt.SetPrev(prev);
+  stmt.SetNext(next);  // recover callStmt's position
+  if (!success) {
+    return nullptr;
+  }
+  // lower new generated stmts
+  auto *currStmt = blk->GetFirst();
+  while (currStmt != nullptr) {
+    auto *nextStmt = currStmt->GetNext();
+    for (uint32 i = 0; i < currStmt->NumOpnds(); ++i) {
+      currStmt->SetOpnd(LowerExpr(*currStmt, *currStmt->Opnd(i), *blk), i);
+    }
+    currStmt = nextStmt;
+  }
+  return blk;
+}
+
+BlockNode *CGLowerer::LowerIntrinsiccallAassignedToAssignStmt(IntrinsiccallNode &intrinsicCall) {
+  auto *builder = mirModule.GetMIRBuilder();
+  auto *block = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  auto intrinsicID = intrinsicCall.GetIntrinsic();
+  auto &opndVector = intrinsicCall.GetNopnd();
+  auto returnPair = intrinsicCall.GetReturnVec().begin();
+  auto regFieldPair = returnPair->second;
+  if (regFieldPair.IsReg()) {
+    auto regIdx = regFieldPair.GetPregIdx();
+    auto primType = mirModule.CurFunction()->GetPregItem(static_cast<PregIdx>(regIdx))->GetPrimType();
+    auto intrinsicOp = builder->CreateExprIntrinsicop(intrinsicID, OP_intrinsicop, primType, TyIdx(0), opndVector);
+    auto regAssign = builder->CreateStmtRegassign(primType, regIdx, intrinsicOp);
+    block->AddStatement(regAssign);
+  } else {
+    auto fieldID = regFieldPair.GetFieldID();
+    auto stIdx = returnPair->first;
+    auto *type = mirModule.CurFunction()->GetLocalOrGlobalSymbol(stIdx)->GetType();
+    auto intrinsicOp = builder->CreateExprIntrinsicop(intrinsicID, OP_intrinsicop, *type, opndVector);
+    auto dAssign = builder->CreateStmtDassign(stIdx, fieldID, intrinsicOp);
+    block->AddStatement(dAssign);
+  }
+  return LowerBlock(*block);
+}
+
+BlockNode *CGLowerer::LowerCallAssignedStmt(StmtNode &stmt, bool uselvar) {
+  StmtNode *newCall = nullptr;
+  CallReturnVector *p2nRets = nullptr;
+  PUIdx funcCalled = kFuncNotFound;
+  bool handledAtLowerLevel = false;
+  switch (stmt.GetOpCode()) {
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned: {
+      if (CGOptions::GetInstance().GetOptimizeLevel() >= CGOptions::kLevel2) {
+        BlockNode *blkLowered = LowerMemop(stmt);
+        if (blkLowered != nullptr) {
+          return blkLowered;
+        }
+      }
+      auto &origCall = static_cast<CallNode&>(stmt);
+      newCall = GenCallNode(stmt, funcCalled, origCall);
+      p2nRets = &origCall.GetReturnVec();
+      static_cast<CallNode *>(newCall)->SetReturnVec(*p2nRets);
+      MIRFunction *curFunc = mirModule.CurFunction();
+      curFunc->SetLastFreqMap(newCall->GetStmtID(),
+          static_cast<uint32>(curFunc->GetFreqFromLastStmt(stmt.GetStmtID())));
+      break;
+    }
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned: {
+      IntrinsiccallNode &intrinCall = static_cast<IntrinsiccallNode&>(stmt);
+      auto intrinsicID = intrinCall.GetIntrinsic();
+      if (IntrinDesc::intrinTable[intrinsicID].IsAtomic()) {
+        return LowerIntrinsiccallAassignedToAssignStmt(intrinCall);
+      }
+      if (intrinsicID == INTRN_JAVA_POLYMORPHIC_CALL) {
+        BaseNode *contextClassArg = GetBaseNodeFromCurFunc(*mirModule.CurFunction(), false);
+        constexpr int kContextIdx = 4; /* stable index in MCC_DexPolymorphicCall, never out of range */
+        intrinCall.InsertOpnd(contextClassArg, kContextIdx);
+
+        BaseNode *firstArg = intrinCall.GetNopndAt(0);
+        BaseNode *baseVal = mirBuilder->CreateExprBinary(OP_add, *GlobalTables::GetTypeTable().GetPtr(), firstArg,
+                                                         mirBuilder->CreateIntConst(1, PTY_ref));
+        intrinCall.SetNOpndAt(0, baseVal);
+      }
+      newCall = GenIntrinsiccallNode(stmt, funcCalled, handledAtLowerLevel, intrinCall);
+      p2nRets = &intrinCall.GetReturnVec();
+      static_cast<IntrinsiccallNode *>(newCall)->SetReturnVec(*p2nRets);
+      break;
+    }
+    case OP_intrinsiccallwithtypeassigned: {
+      auto &origCall = static_cast<IntrinsiccallNode&>(stmt);
+      newCall = GenIntrinsiccallNode(stmt, funcCalled, handledAtLowerLevel, origCall);
+      p2nRets = &origCall.GetReturnVec();
+      static_cast<IntrinsiccallNode *>(newCall)->SetReturnVec(*p2nRets);
+      break;
+    }
+    case OP_icallprotoassigned:
+    case OP_icallassigned: {
+      auto &origCall = static_cast<IcallNode&>(stmt);
+      newCall = GenIcallNode(funcCalled, origCall);
+      p2nRets = &origCall.GetReturnVec();
+      static_cast<IcallNode*>(newCall)->SetReturnVec(*p2nRets);
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "NIY");
+      return nullptr;
+  }
+
+  /* transfer srcPosition location info */
+  newCall->SetSrcPos(stmt.GetSrcPos());
+  return GenBlockNode(*newCall, *p2nRets, stmt.GetOpCode(), funcCalled, handledAtLowerLevel, uselvar);
+}
+
+#if TARGAARCH64
+static PrimType IsStructElementSame(MIRType *ty) {
+  if (ty->GetKind() == kTypeArray) {
+    MIRArrayType *arrtype = static_cast<MIRArrayType *>(ty);
+    MIRType *pty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrtype->GetElemTyIdx());
+    if (pty->GetKind() == kTypeArray || pty->GetKind() == kTypeStruct) {
+      return IsStructElementSame(pty);
+    }
+    return pty->GetPrimType();
+  } else if (ty->GetKind() == kTypeStruct) {
+    MIRStructType *sttype = static_cast<MIRStructType *>(ty);
+    FieldVector fields = sttype->GetFields();
+    PrimType oldtype = PTY_void;
+    for (uint32 fcnt = 0; fcnt < fields.size(); ++fcnt) {
+      TyIdx fieldtyidx = fields[fcnt].second.first;
+      MIRType *fieldty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldtyidx);
+      PrimType ptype = IsStructElementSame(fieldty);
+      if (oldtype != PTY_void && oldtype != ptype) {
+        return PTY_void;
+      } else {
+        oldtype = ptype;
+      }
+    }
+    return oldtype;
+  } else {
+    return ty->GetPrimType();
+  }
+}
+#endif
+
+// return true if successfully lowered; nextStmt is in/out, and is made to point
+// to its following statement if lowering of the struct return is successful
+bool CGLowerer::LowerStructReturn(BlockNode &newBlk, StmtNode *stmt,
+                                  StmtNode *&nextStmt, bool &lvar, BlockNode *oldBlk) {
+  if (!nextStmt) {
+    return false;
+  }
+  CallReturnVector *p2nrets = stmt->GetCallReturnVector();
+  if (p2nrets->size() == 0) {
+    return false;
+  }
+  CallReturnPair retPair = (*p2nrets)[0];
+  if (retPair.second.IsReg()) {
+    return false;
+  }
+  MIRSymbol *retSym = mirModule.CurFunction()->GetLocalOrGlobalSymbol(retPair.first);
+  if (retSym->GetType()->GetPrimType() != PTY_agg) {
+    return false;
+  }
+  if (nextStmt->op != OP_dassign) {
+    // introduce a temporary and insert a dassign whose rhs is this temporary
+    // and whose lhs is retSym
+    MIRSymbol *temp = CreateNewRetVar(*retSym->GetType(), kUserRetValPrefix);
+    BaseNode *rhs = mirModule.GetMIRBuilder()->CreateExprDread(*temp->GetType(), 0, *temp);
+    DassignNode *dass = mirModule.GetMIRBuilder()->CreateStmtDassign(
+        retPair.first, retPair.second.GetFieldID(), rhs);
+    oldBlk->InsertBefore(nextStmt, dass);
+    nextStmt = dass;
+    // update CallReturnVector to the new temporary
+    (*p2nrets)[0].first = temp->GetStIdx();
+    (*p2nrets)[0].second.SetFieldID(0);
+  }
+  // now, it is certain that nextStmt is a dassign
+  BaseNode *bnode = static_cast<DassignNode*>(nextStmt)->GetRHS();
+  if (bnode->GetOpCode() != OP_dread) {
+    return false;
+  }
+  DreadNode *dnode = static_cast<DreadNode*>(bnode);
+  MIRType *dtype = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dnode->GetStIdx())->GetType();
+#if TARGAARCH64
+  PrimType ty = IsStructElementSame(dtype);
+  if (ty == PTY_f32 || ty == PTY_f64 || IsPrimitiveVector(ty)) {
+    return false;
+  }
+#endif
+  if (dnode->GetPrimType() != PTY_agg) {
+    return false;
+  }
+  CallReturnPair pair = (*p2nrets)[0];
+  if (pair.first != dnode->GetStIdx() || pair.second.GetFieldID() != dnode->GetFieldID()) {
+    return false;
+  }
+  auto *dnodeStmt = static_cast<DassignNode*>(nextStmt);
+  if (dnodeStmt->GetFieldID() != 0) {
+    return false;
+  }
+  if (dtype->GetSize() > k16ByteSize) {
+    (*p2nrets)[0].first = dnodeStmt->GetStIdx();
+    (*p2nrets)[0].second.SetFieldID(dnodeStmt->GetFieldID());
+    lvar = true;
+    // set ATTR_firstarg_return for callee
+    if (stmt->GetOpCode() == OP_callassigned) {
+      CallNode *callNode = static_cast<CallNode*>(stmt);
+      MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+      f->SetFirstArgReturn();
+      f->GetMIRFuncType()->SetFirstArgReturn();
+    } else {
+      // for icall, front-end already set ATTR_firstarg_return
+    }
+  } else { /* struct <= 16 passed in regs lowered into
+                          call &foo
+                          regassign u64 %1 (regread u64 %%retval0)
+                          regassign ptr %2 (addrof ptr $s)
+                          iassign <* u64> 0 (regread ptr %2, regread u64 %1) */
+    MIRSymbol *symbol = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dnodeStmt->GetStIdx());
+    auto *structType = static_cast<MIRStructType*>(symbol->GetType());
+    auto size = static_cast<uint32>(structType->GetSize());
+    if (stmt->GetOpCode() == OP_callassigned) {
+      auto *callNode = static_cast<CallNode*>(stmt);
+      for (size_t i = 0; i < callNode->GetNopndSize(); ++i) {
+        BaseNode *newOpnd = LowerExpr(*callNode, *callNode->GetNopndAt(i), newBlk);
+        callNode->SetOpnd(newOpnd, i);
+      }
+      CallNode *callStmt = mirModule.GetMIRBuilder()->CreateStmtCall(callNode->GetPUIdx(), callNode->GetNopnd());
+      callStmt->SetSrcPos(callNode->GetSrcPos());
+      newBlk.AddStatement(callStmt);
+    } else if (stmt->GetOpCode() == OP_icallassigned || stmt->GetOpCode() == OP_icallprotoassigned) {
+      auto *icallNode = static_cast<IcallNode*>(stmt);
+      for (size_t i = 0; i < icallNode->GetNopndSize(); ++i) {
+        BaseNode *newOpnd = LowerExpr(*icallNode, *icallNode->GetNopndAt(i), newBlk);
+        icallNode->SetOpnd(newOpnd, i);
+      }
+      IcallNode *icallStmt = nullptr;
+      if (stmt->GetOpCode() == OP_icallassigned) {
+        icallStmt = mirModule.GetMIRBuilder()->CreateStmtIcall(icallNode->GetNopnd());
+      } else {
+        icallStmt = mirModule.GetMIRBuilder()->CreateStmtIcallproto(icallNode->GetNopnd(), icallNode->GetRetTyIdx());
+      }
+      icallStmt->SetSrcPos(icallNode->GetSrcPos());
+      newBlk.AddStatement(icallStmt);
+    } else {
+      return false;
+    }
+
+    uint32 origSize = size;
+    PregIdx pIdxR, pIdx1R, pIdx2R;
+    StmtNode *aStmt = nullptr;
+    RegreadNode *reg = nullptr;
+
+    /* save x0 */
+    reg = mirBuilder->CreateExprRegread(PTY_u64, -kSregRetval0);
+    pIdx1R = GetCurrentFunc()->GetPregTab()->CreatePreg(PTY_u64);
+    aStmt = mirBuilder->CreateStmtRegassign(PTY_u64, pIdx1R, reg);
+    newBlk.AddStatement(aStmt);
+
+    /* save x1 */
+    if (origSize > k8ByteSize) {
+      reg = mirBuilder->CreateExprRegread(PTY_u64, -kSregRetval1);
+      pIdx2R = GetCurrentFunc()->GetPregTab()->CreatePreg(PTY_u64);
+      aStmt = mirBuilder->CreateStmtRegassign(PTY_u64, pIdx2R, reg);
+      newBlk.AddStatement(aStmt);
+    }
+
+    /* save &s */
+    BaseNode *regAddr = mirBuilder->CreateExprAddrof(0, *symbol);
+    LowerTypePtr(*regAddr);
+    PregIdx pIdxL = GetCurrentFunc()->GetPregTab()->CreatePreg(GetLoweredPtrType());
+    aStmt = mirBuilder->CreateStmtRegassign(PTY_a64, pIdxL, regAddr);
+    newBlk.AddStatement(aStmt);
+
+    uint32 curSize = 0;
+    PregIdx pIdxS;
+    while (size > 0) {
+      pIdxR = pIdx1R;
+      if (curSize >= k8ByteSize) {
+        pIdxR = pIdx2R;
+      }
+      BaseNode *addr;
+      BaseNode *shift;
+      BaseNode *regreadExp;
+      if (origSize != size) {
+        MIRType *addrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetLoweredPtrType());
+        addr = mirBuilder->CreateExprBinary(OP_add, *addrType,
+                                            mirBuilder->CreateExprRegread(GetLoweredPtrType(), pIdxL),
+                                            mirBuilder->CreateIntConst(origSize - size, PTY_i32));
+      } else {
+        addr = mirBuilder->CreateExprRegread(GetLoweredPtrType(), pIdxL);
+      }
+      if (size >= k8ByteSize) {
+        aStmt = mirBuilder->CreateStmtIassign(
+            *beCommon.BeGetOrCreatePointerType(*GlobalTables::GetTypeTable().GetUInt64()),
+            0, addr, mirBuilder->CreateExprRegread(PTY_u64, pIdxR));
+        size -= k8ByteSize;
+        curSize += k8ByteSize;
+      } else if (size >= k4ByteSize) {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_u64);
+
+        if (CGOptions::IsBigEndian()) {
+          regreadExp = mirBuilder->CreateExprBinary(
+              OP_lshr, *type, mirBuilder->CreateExprRegread(PTY_u64, pIdxR),
+              mirBuilder->CreateIntConst(k64BitSize - k32BitSize, PTY_i32));
+        } else {
+          regreadExp = mirBuilder->CreateExprRegread(PTY_u32, pIdxR);
+        }
+
+        aStmt = mirBuilder->CreateStmtIassign(
+            *beCommon.BeGetOrCreatePointerType(*GlobalTables::GetTypeTable().GetUInt32()),
+            0, addr, regreadExp);
+
+        if (CGOptions::IsBigEndian()) {
+          shift = mirBuilder->CreateExprBinary(OP_shl, *type, mirBuilder->CreateExprRegread(PTY_u64, pIdxR),
+                                               mirBuilder->CreateIntConst(k32BitSize, PTY_i32));
+        } else {
+          shift = mirBuilder->CreateExprBinary(OP_lshr, *type, mirBuilder->CreateExprRegread(PTY_u64, pIdxR),
+                                               mirBuilder->CreateIntConst(k32BitSize, PTY_i32));
+        }
+
+        pIdxS = GetCurrentFunc()->GetPregTab()->CreatePreg(PTY_u64);
+        StmtNode *sStmp = mirBuilder->CreateStmtRegassign(PTY_u64, pIdxS, shift);
+
+        pIdx1R = pIdx2R = pIdxS;
+        newBlk.AddStatement(sStmp);
+        size -= k4ByteSize;
+        curSize += k4ByteSize;
+      } else if (size >= k2ByteSize) {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_u64);
+
+        if (CGOptions::IsBigEndian()) {
+          regreadExp = mirBuilder->CreateExprBinary(OP_lshr, *type, mirBuilder->CreateExprRegread(PTY_u64, pIdxR),
+                                                    mirBuilder->CreateIntConst(k64BitSize - k16BitSize, PTY_i32));
+        } else {
+          regreadExp = mirBuilder->CreateExprRegread(PTY_u16, pIdxR);
+        }
+
+        aStmt = mirBuilder->CreateStmtIassign(
+            *beCommon.BeGetOrCreatePointerType(*GlobalTables::GetTypeTable().GetUInt16()),
+            0, addr, regreadExp);
+
+        if (CGOptions::IsBigEndian()) {
+          shift = mirBuilder->CreateExprBinary(OP_shl, *type,
+                                               mirBuilder->CreateExprRegread(PTY_u64, pIdxR),
+                                               mirBuilder->CreateIntConst(k64BitSize - k16BitSize, PTY_i32));
+        } else {
+          shift = mirBuilder->CreateExprBinary(OP_lshr, *type,
+                                               mirBuilder->CreateExprRegread(PTY_u64, pIdxR),
+                                               mirBuilder->CreateIntConst(k16BitSize, PTY_i32));
+        }
+
+        pIdxS = GetCurrentFunc()->GetPregTab()->CreatePreg(PTY_u64);
+        StmtNode *sStmp = mirBuilder->CreateStmtRegassign(PTY_u64, pIdxS, shift);
+
+        pIdx1R = pIdx2R = pIdxS;
+        newBlk.AddStatement(sStmp);
+        size -= k2ByteSize;
+        curSize += k2ByteSize;
+      } else {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_u64);
+
+        if (CGOptions::IsBigEndian()) {
+          regreadExp = mirBuilder->CreateExprBinary(OP_lshr, *type, mirBuilder->CreateExprRegread(PTY_u64, pIdxR),
+                                                    mirBuilder->CreateIntConst(k64BitSize - k8BitSize, PTY_i32));
+        } else {
+          regreadExp = mirBuilder->CreateExprRegread(PTY_u8, pIdxR);
+        }
+
+        aStmt = mirBuilder->CreateStmtIassign(
+            *beCommon.BeGetOrCreatePointerType(*GlobalTables::GetTypeTable().GetUInt8()),
+            0, addr, regreadExp);
+
+        if (CGOptions::IsBigEndian()) {
+          shift = mirBuilder->CreateExprBinary(OP_shl, *type, mirBuilder->CreateExprRegread(PTY_u64, pIdxR),
+                                               mirBuilder->CreateIntConst(k64BitSize - k8BitSize, PTY_i32));
+        } else {
+          shift = mirBuilder->CreateExprBinary(OP_lshr, *type, mirBuilder->CreateExprRegread(PTY_u64, pIdxR),
+                                               mirBuilder->CreateIntConst(k8BitSize, PTY_i32));
+        }
+
+        pIdxS = GetCurrentFunc()->GetPregTab()->CreatePreg(PTY_u64);
+        StmtNode *sStmp = mirBuilder->CreateStmtRegassign(PTY_u64, pIdxS, shift);
+
+        pIdx1R = pIdx2R = pIdxS;
+        newBlk.AddStatement(sStmp);
+        size -= k1ByteSize;
+        curSize += k1ByteSize;
+      }
+      newBlk.AddStatement(aStmt);
+    }
+  }
+  nextStmt = nextStmt->GetNext();  // skip the dassign
+  return true;
+}
+
+void CGLowerer::LowerStmt(StmtNode &stmt, BlockNode &newBlk) {
+  CHECK_FATAL(stmt.GetPrimType() != PTY_ptr, "should have been lowered already");
+  CHECK_FATAL(stmt.GetPrimType() != PTY_ref, "should have been lowered already");
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+    stmt.SetOpnd(LowerExpr(stmt, *stmt.Opnd(i), newBlk), i);
+  }
+}
+
+void CGLowerer::LowerSwitchOpnd(StmtNode &stmt, BlockNode &newBlk) {
+  BaseNode *opnd = LowerExpr(stmt, *stmt.Opnd(0), newBlk);
+  if (CGOptions::GetInstance().GetOptimizeLevel() >= CGOptions::kLevel2 && opnd->GetOpCode() != OP_regread) {
+    PrimType ptyp = stmt.Opnd(0)->GetPrimType();
+    PregIdx pIdx = GetCurrentFunc()->GetPregTab()->CreatePreg(ptyp);
+    RegassignNode *regAss = mirBuilder->CreateStmtRegassign(ptyp, pIdx, opnd);
+    newBlk.AddStatement(regAss);
+    GetCurrentFunc()->SetLastFreqMap(regAss->GetStmtID(),
+        static_cast<uint32>(GetCurrentFunc()->GetFreqFromLastStmt(stmt.GetStmtID())));
+    stmt.SetOpnd(mirBuilder->CreateExprRegread(ptyp, pIdx), 0);
+  } else {
+    stmt.SetOpnd(LowerExpr(stmt, *stmt.Opnd(0), newBlk), 0);
+  }
+}
+
+void CGLowerer::AddElemToPrintf(MapleVector<BaseNode*> &argsPrintf, int num, ...) const {
+  va_list argPtr;
+  va_start(argPtr, num);
+  for (int i = 0; i < num; ++i) {
+    argsPrintf.push_back(va_arg(argPtr, BaseNode*));
+  }
+  va_end(argPtr);
+}
+
+bool CGLowerer::CheckSwitchTableContinuous(SwitchNode &stmt) const {
+  if (!stmt.GetSwitchTable().empty()) {
+    stmt.SortCasePair(CasePairKeyLessThan);
+    if (static_cast<uint64>(((stmt.GetSwitchTable().end() - 1)->first - stmt.GetSwitchTable().begin()->first) + 1) >
+        stmt.GetSwitchTable().size()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool CGLowerer::IsSwitchToRangeGoto(const BlockNode &blk) const {
+  for (const StmtNode *stmt = blk.GetFirst(); stmt != nullptr; stmt = stmt->GetNext()) {
+    if (stmt->GetOpCode() == OP_rangegoto) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void CGLowerer::SwitchAssertBoundary(StmtNode &stmt, MapleVector<BaseNode *> &argsPrintf) {
+  MIRSymbol *errMsg;
+  MIRSymbol *fileNameSym;
+  ConstvalNode *lineNum;
+  const int callElemNum = 5;
+  const int returnElemNum = 4;
+  const int otherElemNum = 3;
+  fileNameSym = mirBuilder->CreateConstStringSymbol(GetFileNameSymbolName(AssertBoundaryGetFileName(stmt)),
+      AssertBoundaryGetFileName(stmt));
+  lineNum = mirBuilder->CreateIntConst(stmt.GetSrcPos().LineNum(), PTY_u32);
+  if (kOpcodeInfo.IsAssertLowerBoundary(stmt.GetOpCode())) {
+    errMsg = mirBuilder->CreateConstStringSymbol(kOpAssertge,
+        "%s:%d error: the pointer < the lower bounds when accessing the memory!\n");
+    AddElemToPrintf(argsPrintf, otherElemNum, mirBuilder->CreateAddrof(*errMsg, PTY_a64),
+                    mirBuilder->CreateAddrof(*fileNameSym, PTY_a64), lineNum);
+  } else {
+    if (kOpcodeInfo.IsAssertLeBoundary(stmt.GetOpCode())) {
+      if (stmt.GetOpCode() == OP_callassertle) {
+        auto &callStmt = static_cast<CallAssertBoundaryStmtNode&>(stmt);
+        std::string param;
+        MIRSymbol *funcName;
+        MIRSymbol *paramNum;
+        param = maple::GetNthStr(callStmt.GetParamIndex());
+        errMsg = mirBuilder->CreateConstStringSymbol(kOpCallAssertle,
+            "%s:%d error: the pointer's bounds does not match the function %s declaration for the %s argument!\n");
+        funcName = mirBuilder->CreateConstStringSymbol(callStmt.GetFuncName() + kOpCallAssertle,
+                                                       callStmt.GetFuncName());
+        paramNum = mirBuilder->CreateConstStringSymbol(kOpCallAssertle + param, param);
+        AddElemToPrintf(argsPrintf, callElemNum, mirBuilder->CreateAddrof(*errMsg, PTY_a64),
+                        mirBuilder->CreateAddrof(*fileNameSym, PTY_a64), lineNum,
+                        mirBuilder->CreateAddrof(*funcName, PTY_a64),
+                        mirBuilder->CreateAddrof(*paramNum, PTY_a64));
+      } else if (stmt.GetOpCode() == OP_returnassertle) {
+        auto &callStmt = static_cast<CallAssertBoundaryStmtNode&>(stmt);
+        MIRSymbol *funcName;
+        errMsg = mirBuilder->CreateConstStringSymbol(kOpReturnAssertle,
+            "%s:%d error: return value's bounds does not match the function declaration for %s\n");
+        funcName = mirBuilder->CreateConstStringSymbol(callStmt.GetFuncName() + kOpReturnAssertle,
+                                                       callStmt.GetFuncName());
+        AddElemToPrintf(argsPrintf, returnElemNum, mirBuilder->CreateAddrof(*errMsg, PTY_a64),
+                        mirBuilder->CreateAddrof(*fileNameSym, PTY_a64), lineNum,
+                        mirBuilder->CreateAddrof(*funcName, PTY_a64));
+      } else {
+        errMsg = mirBuilder->CreateConstStringSymbol(kOpAssignAssertle,
+            "%s:%d error: l-value boundary should not be larger than r-value boundary!\n");
+        AddElemToPrintf(argsPrintf, otherElemNum, mirBuilder->CreateAddrof(*errMsg, PTY_a64),
+                        mirBuilder->CreateAddrof(*fileNameSym, PTY_a64), lineNum);
+      }
+    } else {
+      errMsg = mirBuilder->CreateConstStringSymbol(kOpAssertlt,
+          "%s:%d error: the pointer >= the upper bounds when accessing the memory!\n");
+      AddElemToPrintf(argsPrintf, otherElemNum, mirBuilder->CreateAddrof(*errMsg, PTY_a64),
+                      mirBuilder->CreateAddrof(*fileNameSym, PTY_a64), lineNum);
+    }
+  }
+}
+
+void CGLowerer::LowerAssertBoundary(StmtNode &stmt, BlockNode &block, BlockNode &newBlk,
+                                    std::vector<StmtNode *> &abortNode) {
+  MIRFunction *curFunc = mirModule.CurFunction();
+  BaseNode *op0 = LowerExpr(stmt, *stmt.Opnd(0), block);
+  BaseNode *op1 = LowerExpr(stmt, *stmt.Opnd(1), block);
+  LabelIdx labIdx = GetLabelIdx(*curFunc);
+  LabelNode *labelBC = mirBuilder->CreateStmtLabel(labIdx);
+  Opcode op = OP_ge;
+  if (kOpcodeInfo.IsAssertUpperBoundary(stmt.GetOpCode())) {
+    op = (kOpcodeInfo.IsAssertLeBoundary(stmt.GetOpCode())) ? OP_le : OP_lt;
+  }
+  BaseNode *cond = mirBuilder->CreateExprCompare(op, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                 *GlobalTables::GetTypeTable().GetPrimType(op0->GetPrimType()),
+                                                 op0, op1);
+  CondGotoNode *brFalseNode = mirBuilder->CreateStmtCondGoto(cond, OP_brfalse, labIdx);
+
+  MIRFunction *printf = mirBuilder->GetOrCreateFunction("printf", TyIdx(PTY_i32));
+  printf->GetFuncSymbol()->SetAppearsInCode(true);
+  beCommon.UpdateTypeTable(*printf->GetMIRFuncType());
+  MapleVector<BaseNode*> argsPrintf(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  uint32 oldTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  SwitchAssertBoundary(stmt, argsPrintf);
+  uint32 newTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  if (newTypeTableSize != oldTypeTableSize) {
+    beCommon.AddNewTypeAfterBecommon(oldTypeTableSize, newTypeTableSize);
+  }
+  StmtNode *callPrintf = mirBuilder->CreateStmtCall(printf->GetPuidx(), argsPrintf);
+  UnaryStmtNode *abortModeNode = mirBuilder->CreateStmtUnary(OP_abort, nullptr);
+
+  brFalseNode->SetSrcPos(stmt.GetSrcPos());
+  labelBC->SetSrcPos(stmt.GetSrcPos());
+  callPrintf->SetSrcPos(stmt.GetSrcPos());
+  abortModeNode->SetSrcPos(stmt.GetSrcPos());
+
+  newBlk.AddStatement(brFalseNode);
+  abortNode.emplace_back(labelBC);
+  abortNode.emplace_back(callPrintf);
+  abortNode.emplace_back(abortModeNode);
+}
+
+BlockNode *CGLowerer::LowerBlock(BlockNode &block) {
+  BlockNode *newBlk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  BlockNode *tmpBlockNode = nullptr;
+  std::vector<StmtNode *> abortNode;
+  if (block.GetFirst() == nullptr) {
+    return newBlk;
+  }
+
+  StmtNode *nextStmt = block.GetFirst();
+  do {
+    StmtNode *stmt = nextStmt;
+    nextStmt = stmt->GetNext();
+    stmt->SetNext(nullptr);
+    currentBlock = newBlk;
+    auto lastStmt = newBlk->GetStmtNodes().rbegin();
+
+    LowerTypePtr(*stmt);
+
+    switch (stmt->GetOpCode()) {
+      case OP_switch: {
+        LowerSwitchOpnd(*stmt, *newBlk);
+        auto switchMp = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "switchlowere");
+        MapleAllocator switchAllocator(switchMp.get());
+        LabelNode *defaultLabel = nullptr;
+        LabelIdx newLabelIdx = 0;
+        if (!CheckSwitchTableContinuous(static_cast<SwitchNode&>(*stmt)) &&
+            static_cast<SwitchNode*>(stmt)->GetDefaultLabel() == 0) {
+          newLabelIdx = GetLabelIdx(*mirModule.CurFunction());
+          defaultLabel = mirBuilder->CreateStmtLabel(newLabelIdx);
+        }
+        SwitchLowerer switchLowerer(mirModule, static_cast<SwitchNode&>(*stmt), switchAllocator);
+        BlockNode *blk = switchLowerer.LowerSwitch(newLabelIdx);
+        if (blk->GetFirst() != nullptr && defaultLabel != nullptr && IsSwitchToRangeGoto(*blk)) {
+          blk->AddStatement(defaultLabel);
+        }
+        if (blk->GetFirst() != nullptr) {
+          newBlk->AppendStatementsFromBlock(*blk);
+        }
+        needBranchCleanup = true;
+        break;
+      }
+      case OP_block:
+        tmpBlockNode = LowerBlock(static_cast<BlockNode&>(*stmt));
+        CHECK_FATAL(tmpBlockNode != nullptr, "nullptr is not expected");
+        newBlk->AppendStatementsFromBlock(*tmpBlockNode);
+        break;
+      case OP_dassign: {
+        LowerDassign(static_cast<DassignNode&>(*stmt), *newBlk);
+        break;
+      }
+      case OP_regassign: {
+        LowerRegassign(static_cast<RegassignNode&>(*stmt), *newBlk);
+        break;
+      }
+      CASE_OP_ASSERT_BOUNDARY {
+        LowerAssertBoundary(*stmt, block, *newBlk, abortNode);
+        break;
+      }
+      case OP_iassign: {
+        LowerIassign(static_cast<IassignNode&>(*stmt), *newBlk);
+        break;
+      }
+      case OP_callassigned:
+      case OP_icallassigned:
+      case OP_icallprotoassigned: {
+        // pass the addr of lvar if this is a struct call assignment
+        bool lvar = false;
+        // nextStmt could be changed by the call to LowerStructReturn
+        if (!LowerStructReturn(*newBlk, stmt, nextStmt, lvar, &block)) {
+          newBlk->AppendStatementsFromBlock(*LowerCallAssignedStmt(*stmt, lvar));
+        }
+        break;
+      }
+      case OP_virtualcallassigned:
+      case OP_superclasscallassigned:
+      case OP_interfacecallassigned:
+      case OP_intrinsiccallassigned:
+      case OP_xintrinsiccallassigned:
+      case OP_intrinsiccallwithtypeassigned:
+        newBlk->AppendStatementsFromBlock(*LowerCallAssignedStmt(*stmt));
+        break;
+      case OP_intrinsiccall:
+      case OP_call:
+      case OP_icall:
+      case OP_icallproto:
+#if TARGARM32 || TARGAARCH64 || TARGRISCV64 || TARGX86_64
+        // nextStmt could be changed by the call to LowerStructReturn
+        LowerCallStmt(*stmt, nextStmt, *newBlk);
+#else
+        LowerStmt(*stmt, *newBlk);
+#endif
+        break;
+      case OP_return: {
+#if TARGARM32 || TARGAARCH64 || TARGRISCV64 || TARGX86_64
+        if (GetCurrentFunc()->IsFirstArgReturn() && stmt->NumOpnds() > 0) {
+          newBlk->AppendStatementsFromBlock(*LowerReturnStructUsingFakeParm(static_cast<NaryStmtNode&>(*stmt)));
+        } else {
+#endif
+        NaryStmtNode *retNode = static_cast<NaryStmtNode*>(stmt);
+        if (retNode->GetNopndSize() == 0) {
+          newBlk->AddStatement(stmt);
+        } else {
+          tmpBlockNode = LowerReturn(*retNode);
+          CHECK_FATAL(tmpBlockNode != nullptr, "nullptr is not expected");
+          newBlk->AppendStatementsFromBlock(*tmpBlockNode);
+        }
+#if TARGARM32 || TARGAARCH64 || TARGRISCV64 || TARGX86_64
+        }
+#endif
+        break;
+      }
+      case OP_comment:
+        newBlk->AddStatement(stmt);
+        break;
+      case OP_try:
+        LowerStmt(*stmt, *newBlk);
+        newBlk->AddStatement(stmt);
+        hasTry = true;
+        break;
+      case OP_endtry:
+        LowerStmt(*stmt, *newBlk);
+        newBlk->AddStatement(stmt);
+        break;
+      case OP_catch:
+        LowerStmt(*stmt, *newBlk);
+        newBlk->AddStatement(stmt);
+        break;
+      case OP_throw:
+        if (mirModule.IsJavaModule()) {
+          if (GenerateExceptionHandlingCode()) {
+            LowerStmt(*stmt, *newBlk);
+            newBlk->AddStatement(stmt);
+          }
+        } else {
+          LowerStmt(*stmt, *newBlk);
+          newBlk->AddStatement(stmt);
+        }
+        break;
+      case OP_syncenter:
+      case OP_syncexit: {
+        LowerStmt(*stmt, *newBlk);
+        StmtNode *tmp = LowerSyncEnterSyncExit(*stmt);
+        CHECK_FATAL(tmp != nullptr, "nullptr is not expected");
+        newBlk->AddStatement(tmp);
+        break;
+      }
+      case OP_decrefreset: {
+        /*
+         * only gconly can reach here
+         * lower stmt (decrefreset (addrof ptr %RegX_RXXXX)) to (dassign %RegX_RXXXX 0 (constval ref 0))
+         */
+        CHECK_FATAL(CGOptions::IsGCOnly(), "OP_decrefreset is expected only in gconly.");
+        LowerResetStmt(*stmt, *newBlk);
+        break;
+      }
+      case OP_asm: {
+        LowerAsmStmt(static_cast<AsmNode *>(stmt), newBlk);
+        break;
+      }
+      default:
+        LowerStmt(*stmt, *newBlk);
+        newBlk->AddStatement(stmt);
+        break;
+    }
+    CHECK_FATAL(beCommon.GetSizeOfTypeSizeTable() == GlobalTables::GetTypeTable().GetTypeTableSize(), "Error!");
+
+    for (auto itStmt = newBlk->GetStmtNodes().rbegin(); itStmt != lastStmt; ++itStmt) {
+      if (stmt->GetSrcPos().IsValid()) {
+        itStmt->SetSrcPos(stmt->GetSrcPos());
+      }
+    }
+    lastStmt = newBlk->GetStmtNodes().rbegin();
+  } while (nextStmt != nullptr);
+  for (auto node : abortNode) {
+      newBlk->AddStatement(node);
+  }
+  return newBlk;
+}
+
+void CGLowerer::SimplifyBlock(BlockNode &block) const {
+  if (block.GetFirst() == nullptr) {
+    return;
+  }
+  StmtNode *nextStmt = block.GetFirst();
+  do {
+    StmtNode *stmt = nextStmt;
+    nextStmt = stmt->GetNext();
+    Opcode op = stmt->GetOpCode();
+    switch (op) {
+      case OP_call: {
+        auto *callStmt = static_cast<CallNode*>(stmt);
+        if (CGOptions::IsDuplicateAsmFileEmpty()) {
+          break;
+        }
+        auto *oldFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt->GetPUIdx());
+        if (asmMap.find(oldFunc->GetName()) == asmMap.end()) {
+          break;
+        }
+        auto *newFunc = theMIRModule->GetMIRBuilder()->GetOrCreateFunction(asmMap.at(oldFunc->GetName()),
+                                                                           callStmt->GetTyIdx());
+        MIRSymbol *funcSym = newFunc->GetFuncSymbol();
+        funcSym->SetStorageClass(kScExtern);
+        funcSym->SetAppearsInCode(true);
+        callStmt->SetPUIdx(newFunc->GetPuidx());
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  } while (nextStmt != nullptr);
+  return;
+}
+
+MIRType *CGLowerer::GetArrayNodeType(BaseNode &baseNode) {
+  MIRType *baseType = nullptr;
+  auto curFunc = mirModule.CurFunction();
+  if (baseNode.GetOpCode() == OP_regread) {
+      RegreadNode *rrNode = static_cast<RegreadNode*>(&baseNode);
+      MIRPreg *pReg = curFunc->GetPregTab()->PregFromPregIdx(rrNode->GetRegIdx());
+      if (pReg->IsRef()) {
+        baseType = pReg->GetMIRType();
+      }
+  }
+  if (baseNode.GetOpCode() == OP_dread) {
+    DreadNode *dreadNode = static_cast<DreadNode*>(&baseNode);
+    MIRSymbol *symbol = curFunc->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+    baseType = symbol->GetType();
+  }
+  MIRType *arrayElemType = nullptr;
+  if (baseType != nullptr) {
+    MIRType *stType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(
+        static_cast<MIRPtrType*>(baseType)->GetPointedTyIdx());
+    while (stType->GetKind() == kTypeJArray) {
+      MIRJarrayType *baseType1 = static_cast<MIRJarrayType*>(stType);
+      MIRType *elemType = baseType1->GetElemType();
+      if (elemType->GetKind() == kTypePointer) {
+        const TyIdx &index = static_cast<MIRPtrType*>(elemType)->GetPointedTyIdx();
+        stType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(index);
+      } else {
+        stType = elemType;
+      }
+    }
+
+    arrayElemType = stType;
+  }
+  return arrayElemType;
+}
+
+void CGLowerer::SplitCallArg(CallNode &callNode, BaseNode *newOpnd, size_t i, BlockNode &newBlk) {
+  if (newOpnd->GetOpCode() != OP_regread && newOpnd->GetOpCode() != OP_constval &&
+      newOpnd->GetOpCode() != OP_dread && newOpnd->GetOpCode() != OP_addrof &&
+      newOpnd->GetOpCode() != OP_iaddrof && newOpnd->GetOpCode() != OP_constval &&
+      newOpnd->GetOpCode() != OP_conststr && newOpnd->GetOpCode() != OP_conststr16) {
+    if (CGOptions::GetInstance().GetOptimizeLevel() == CGOptions::kLevel0) {
+      MIRType *type = GlobalTables::GetTypeTable().GetPrimType(newOpnd->GetPrimType());
+      MIRSymbol *ret = CreateNewRetVar(*type, kIntrnRetValPrefix);
+      DassignNode *dassignNode = mirBuilder->CreateStmtDassign(*ret, 0, newOpnd);
+      newBlk.AddStatement(dassignNode);
+      callNode.SetOpnd(mirBuilder->CreateExprDread(*type, 0, *ret), i);
+    } else {
+      PregIdx pregIdx = mirModule.CurFunction()->GetPregTab()->CreatePreg(newOpnd->GetPrimType());
+      RegassignNode *temp = mirBuilder->CreateStmtRegassign(newOpnd->GetPrimType(), pregIdx, newOpnd);
+      newBlk.AddStatement(temp);
+      callNode.SetOpnd(mirBuilder->CreateExprRegread(newOpnd->GetPrimType(), pregIdx), i);
+    }
+  } else {
+    callNode.SetOpnd(newOpnd, i);
+  }
+}
+
+StmtNode *CGLowerer::LowerCall(
+    CallNode &callNode, StmtNode *&nextStmt, BlockNode &newBlk, MIRType *retTy, bool uselvar) {
+  /*
+   * nextStmt in-out
+   * call $foo(constval u32 128)
+   * dassign %jlt (dread agg %%retval)
+   */
+  bool isArrayStore = false;
+
+  if (callNode.GetOpCode() == OP_call) {
+    MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode.GetPUIdx());
+    if ((calleeFunc->GetName() == "MCC_WriteRefField") && (callNode.Opnd(1)->GetOpCode() == OP_iaddrof)) {
+      IreadNode *addrExpr = static_cast<IreadNode*>(callNode.Opnd(1));
+      if (addrExpr->Opnd(0)->GetOpCode() == OP_array) {
+        isArrayStore = true;
+      }
+    }
+  }
+
+  for (size_t i = 0; i < callNode.GetNopndSize(); ++i) {
+    BaseNode *newOpnd = LowerExpr(callNode, *callNode.GetNopndAt(i), newBlk);
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    callNode.SetOpnd(newOpnd, i);
+#else
+    SplitCallArg(callNode, newOpnd, i, newBlk);
+#endif
+  }
+
+  if (isArrayStore && checkLoadStore) {
+    bool needCheckStore = true;
+    MIRType *arrayElemType = GetArrayNodeType(*callNode.Opnd(0));
+    MIRType *valueRealType = GetArrayNodeType(*callNode.Opnd(kNodeThirdOpnd));
+    if ((arrayElemType != nullptr) && (valueRealType != nullptr) && (arrayElemType->GetKind() == kTypeClass) &&
+        static_cast<MIRClassType*>(arrayElemType)->IsFinal() && (valueRealType->GetKind() == kTypeClass) &&
+        static_cast<MIRClassType*>(valueRealType)->IsFinal() &&
+        valueRealType->GetTypeIndex() == arrayElemType->GetTypeIndex()) {
+      needCheckStore = false;
+    }
+
+    if (needCheckStore) {
+      MIRFunction *fn = mirModule.GetMIRBuilder()->GetOrCreateFunction("MCC_Reflect_Check_Arraystore", TyIdx(PTY_void));
+      fn->GetFuncSymbol()->SetAppearsInCode(true);
+      beCommon.UpdateTypeTable(*fn->GetMIRFuncType());
+      fn->AllocSymTab();
+      MapleVector<BaseNode*> args(mirModule.GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
+      args.emplace_back(callNode.Opnd(0));
+      args.emplace_back(callNode.Opnd(kNodeThirdOpnd));
+      StmtNode *checkStoreStmt = mirModule.GetMIRBuilder()->CreateStmtCall(fn->GetPuidx(), args);
+      newBlk.AddStatement(checkStoreStmt);
+    }
+  }
+
+  DassignNode *dassignNode = nullptr;
+  if ((nextStmt != nullptr) && (nextStmt->GetOpCode() == OP_dassign)) {
+    dassignNode = static_cast<DassignNode*>(nextStmt);
+  }
+
+  /* if nextStmt is not a dassign stmt, return */
+  if (dassignNode == nullptr) {
+    return &callNode;
+  }
+
+  if (!uselvar && retTy && beCommon.GetTypeSize(retTy->GetTypeIndex().GetIdx()) <= k16ByteSize) {
+    /* return structure fitting in one or two regs. */
+    return &callNode;
+  }
+
+  MIRType *retType = nullptr;
+  if (callNode.op == OP_icall || callNode.op == OP_icallproto) {
+    if (retTy == nullptr) {
+      return &callNode;
+    } else {
+      retType = retTy;
+    }
+  }
+
+  if (retType == nullptr) {
+    MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode.GetPUIdx());
+    retType = calleeFunc->GetReturnType();
+    if (calleeFunc->IsReturnStruct() && (retType->GetPrimType() == PTY_void)) {
+      MIRPtrType *pretType = static_cast<MIRPtrType*>((calleeFunc->GetNthParamType(0)));
+      CHECK_FATAL(pretType != nullptr, "nullptr is not expected");
+      retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pretType->GetPointedTyIdx());
+      CHECK_FATAL((retType->GetKind() == kTypeStruct) || (retType->GetKind() == kTypeUnion),
+          "make sure retType is a struct type");
+    }
+  }
+
+  /* if return type is not of a struct, return */
+  if ((retType->GetKind() != kTypeStruct) && (retType->GetKind() != kTypeUnion)) {
+    return &callNode;
+  }
+
+  MIRSymbol *dsgnSt = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dassignNode->GetStIdx());
+  CHECK_FATAL(dsgnSt->GetType()->IsStructType(), "expects a struct type");
+  MIRStructType *structTy = static_cast<MIRStructType*>(dsgnSt->GetType());
+  if (structTy == nullptr) {
+    return &callNode;
+  }
+
+  RegreadNode *regReadNode = nullptr;
+  if (dassignNode->Opnd(0)->GetOpCode() == OP_regread) {
+    regReadNode = static_cast<RegreadNode*>(dassignNode->Opnd(0));
+  }
+  if (regReadNode == nullptr || (regReadNode->GetRegIdx() != -kSregRetval0)) {
+    return &callNode;
+  }
+
+  MapleVector<BaseNode*> newNopnd(mirModule.CurFuncCodeMemPoolAllocator()->Adapter());
+  AddrofNode *addrofNode = mirModule.CurFuncCodeMemPool()->New<AddrofNode>(OP_addrof);
+  addrofNode->SetPrimType(GetLoweredPtrType());
+  addrofNode->SetStIdx(dsgnSt->GetStIdx());
+  addrofNode->SetFieldID(0);
+
+  if (callNode.op == OP_icall || callNode.op == OP_icallproto) {
+    auto ond = callNode.GetNopnd().begin();
+    newNopnd.emplace_back(*ond);
+    newNopnd.emplace_back(addrofNode);
+    for (++ond; ond != callNode.GetNopnd().end(); ++ond) {
+      newNopnd.emplace_back(*ond);
+    }
+  } else {
+    newNopnd.emplace_back(addrofNode);
+    for (auto *opnd : callNode.GetNopnd()) {
+      newNopnd.emplace_back(opnd);
+    }
+  }
+
+  callNode.SetNOpnd(newNopnd);
+  callNode.SetNumOpnds(static_cast<uint8>(newNopnd.size()));
+  CHECK_FATAL(nextStmt != nullptr, "nullptr is not expected");
+  nextStmt = nextStmt->GetNext();
+  return &callNode;
+}
+
+void CGLowerer::LowerEntry(MIRFunction &func) {
+  // determine if needed to insert fake parameter to return struct for current function
+  if (func.IsReturnStruct()) {
+    MIRType *retType = func.GetReturnType();
+#if TARGAARCH64
+    PrimType pty = IsStructElementSame(retType);
+    if (pty == PTY_f32 || pty == PTY_f64 || IsPrimitiveVector(pty)) {
+      func.SetStructReturnedInRegs();
+      return;
+    }
+#endif
+    if (retType->GetPrimType() != PTY_agg) {
+      return;
+    }
+    if (retType->GetSize() > k16ByteSize) {
+      func.SetFirstArgReturn();
+      func.GetMIRFuncType()->SetFirstArgReturn();
+    } else {
+      func.SetStructReturnedInRegs();
+    }
+  }
+  if (func.IsFirstArgReturn() && func.GetReturnType()->GetPrimType() != PTY_void) {
+    MIRSymbol *retSt = func.GetSymTab()->CreateSymbol(kScopeLocal);
+    retSt->SetStorageClass(kScFormal);
+    retSt->SetSKind(kStVar);
+    std::string retName(".return.");
+    MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(func.GetStIdx().Idx());
+    retName.append(funcSt->GetName());
+    retSt->SetNameStrIdx(retName);
+    MIRType *pointType = beCommon.BeGetOrCreatePointerType(*func.GetReturnType());
+
+    retSt->SetTyIdx(pointType->GetTypeIndex());
+    std::vector<MIRSymbol*> formals;
+    formals.emplace_back(retSt);
+    for (uint32 i = 0; i < func.GetFormalCount(); ++i) {
+      auto formal = func.GetFormal(i);
+      formals.emplace_back(formal);
+    }
+    func.SetFirstArgReturn();
+
+    beCommon.AddElementToFuncReturnType(func, func.GetReturnTyIdx());
+
+    func.UpdateFuncTypeAndFormalsAndReturnType(formals, TyIdx(PTY_void), true);
+    auto *funcType = func.GetMIRFuncType();
+    ASSERT(funcType != nullptr, "null ptr check");
+    funcType->SetFirstArgReturn();
+    beCommon.AddTypeSizeAndAlign(funcType->GetTypeIndex(), GetPrimTypeSize(funcType->GetPrimType()));
+  }
+}
+
+void CGLowerer::LowerPseudoRegs(const MIRFunction &func) const {
+  for (uint32 i = 1; i < func.GetPregTab()->Size(); ++i) {
+    MIRPreg *ipr = func.GetPregTab()->PregFromPregIdx(i);
+    PrimType primType = ipr->GetPrimType();
+    if ((primType == PTY_ptr) || (primType == PTY_ref)) {
+      ipr->SetPrimType(GetLoweredPtrType());
+    } else if (primType == PTY_u1) {
+      ipr->SetPrimType(PTY_u32);
+    }
+  }
+}
+
+void CGLowerer::CleanupBranches(MIRFunction &func) const {
+  BlockNode *block = func.GetBody();
+  StmtNode *prev = nullptr;
+  StmtNode *next = nullptr;
+  for (StmtNode *curr = block->GetFirst(); curr != nullptr; curr = next) {
+    next = curr->GetNext();
+    if (next != nullptr) {
+      CHECK_FATAL(curr == next->GetPrev(), "unexpected node");
+    }
+    if ((next != nullptr) && (prev != nullptr) && (curr->GetOpCode() == OP_goto)) {
+      /*
+       * Skip until find a label.
+       * Note that the CURRent 'goto' statement may be the last statement
+       * when discounting comment statements.
+       * Make sure we don't lose any comments.
+       */
+      StmtNode *cmtB = nullptr;
+      StmtNode *cmtE = nullptr;
+      bool isCleanable = true;
+      while ((next != nullptr) && (next->GetOpCode() != OP_label)) {
+        if ((next->GetOpCode() == OP_try) || (next->GetOpCode() == OP_endtry) || (next->GetOpCode() == OP_catch)) {
+          isCleanable = false;
+          break;
+        }
+        next = next->GetNext();
+      }
+      if ((next != nullptr) && (!isCleanable)) {
+        prev = next->GetPrev();
+        continue;
+      }
+
+      next = curr->GetNext();
+
+      while ((next != nullptr) && (next->GetOpCode() != OP_label)) {
+        if (next->GetOpCode() == OP_comment) {
+          if (cmtB == nullptr) {
+            cmtB = next;
+            cmtE = next;
+          } else {
+            CHECK_FATAL(cmtE != nullptr, "cmt_e is null in CGLowerer::CleanupBranches");
+            cmtE->SetNext(next);
+            next->SetPrev(cmtE);
+            cmtE = next;
+          }
+        }
+        next = next->GetNext();
+      }
+
+      curr->SetNext(next);
+
+      if (next != nullptr) {
+        next->SetPrev(curr);
+      }
+
+      StmtNode *insertAfter = nullptr;
+
+      if ((next != nullptr) &&
+          ((static_cast<GotoNode*>(curr))->GetOffset() == (static_cast<LabelNode*>(next))->GetLabelIdx())) {
+        insertAfter = prev;
+        prev->SetNext(next);  /* skip goto statement (which is pointed by curr) */
+        next->SetPrev(prev);
+        curr = next;        /* make curr point to the label statement */
+        next = next->GetNext();  /* advance next to the next statement of the label statement */
+      } else {
+        insertAfter = curr;
+      }
+
+      /* insert comments before 'curr' */
+      if (cmtB != nullptr) {
+        CHECK_FATAL(cmtE != nullptr, "nullptr is not expected");
+        StmtNode *iaNext = insertAfter->GetNext();
+        if (iaNext != nullptr) {
+          iaNext->SetPrev(cmtE);
+        }
+        cmtE->SetNext(iaNext);
+
+        insertAfter->SetNext(cmtB);
+        cmtB->SetPrev(insertAfter);
+
+        if (insertAfter == curr) {
+          curr = cmtE;
+        }
+      }
+      if (next == nullptr) {
+        func.GetBody()->SetLast(curr);
+      }
+    }
+    prev = curr;
+  }
+  CHECK_FATAL(func.GetBody()->GetLast() == prev, "make sure the return value of GetLast equal prev");
+}
+
+/*
+ * We want to place catch blocks so that they don't come before any of java trys that refer to them.
+ * In order to do that, we take advantage of the fact that the mpl. source we get is already flattened and
+ * no java-try-end-try block is enclosed in any other java-try-end-try block. they appear in the mpl file.
+ * We process each bb in bbList from the front to the end, and while doing so, we maintain a list of catch blocks
+ * we have seen. When we get to an end-try block, we examine each catch block label it has (offsets),
+ * and if we find any catch block in the "seen" list, we move the block after the end-try block.
+ * Note that we need to find a basic block which does not have 'fallthruBranch' control path.
+ * (Appending the catch block to any basic block that has the 'fallthruBranch' control path
+ * will alter the program semantics)
+ */
+void CGLowerer::LowerTryCatchBlocks(BlockNode &body) {
+  if (!hasTry) {
+    return;
+  }
+
+#if DEBUG
+  BBT::ValidateStmtList(nullptr, nullptr);
+#endif
+  auto memPool = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "CreateNewBB mempool");
+  TryCatchBlocksLower tryCatchLower(*memPool, body, mirModule);
+  tryCatchLower.RecoverBasicBlock();
+  bool generateEHCode = GenerateExceptionHandlingCode();
+  tryCatchLower.SetGenerateEHCode(generateEHCode);
+  tryCatchLower.TraverseBBList();
+#if DEBUG
+  tryCatchLower.CheckTryCatchPattern();
+#endif
+}
+
+inline bool IsAccessingTheSameMemoryLocation(const DassignNode &dassign,
+                                             const RegreadNode &rRead, const CGLowerer &cgLowerer) {
+  StIdx stIdx = cgLowerer.GetSymbolReferredToByPseudoRegister(rRead.GetRegIdx());
+  return ((dassign.GetStIdx() == stIdx) && (dassign.GetFieldID() == 0));
+}
+
+inline bool IsAccessingTheSameMemoryLocation(const DassignNode &dassign, const DreadNode &dread) {
+  return ((dassign.GetStIdx() == dread.GetStIdx()) && (dassign.GetFieldID() == dread.GetFieldID()));
+}
+
+inline bool IsDassignNOP(const DassignNode &dassign) {
+  if (dassign.GetRHS()->GetOpCode() == OP_dread) {
+    return IsAccessingTheSameMemoryLocation(dassign, static_cast<DreadNode&>(*dassign.GetRHS()));
+  }
+  return false;
+}
+
+inline bool IsConstvalZero(const BaseNode &n) {
+  return ((n.GetOpCode() == OP_constval) && static_cast<const ConstvalNode&>(n).GetConstVal()->IsZero());
+}
+
+#define NEXT_ID(x) ((x) + 1)
+#define INTRN_FIRST_SYNC_ENTER NEXT_ID(INTRN_LAST)
+#define INTRN_SECOND_SYNC_ENTER NEXT_ID(INTRN_FIRST_SYNC_ENTER)
+#define INTRN_THIRD_SYNC_ENTER NEXT_ID(INTRN_SECOND_SYNC_ENTER)
+#define INTRN_FOURTH_SYNC_ENTER NEXT_ID(INTRN_THIRD_SYNC_ENTER)
+#define INTRN_YNC_EXIT NEXT_ID(INTRN_FOURTH_SYNC_ENTER)
+
+std::vector<std::pair<CGLowerer::BuiltinFunctionID, PUIdx>> CGLowerer::builtinFuncIDs;
+std::unordered_map<IntrinDesc*, PUIdx> CGLowerer::intrinFuncIDs;
+std::unordered_map<std::string, size_t> CGLowerer::arrayClassCacheIndex;
+
+MIRFunction *CGLowerer::RegisterFunctionVoidStarToVoid(BuiltinFunctionID id, const std::string &name,
+                                                       const std::string &paramName) {
+  MIRFunction *func = mirBuilder->GetOrCreateFunction(name, GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex());
+  beCommon.UpdateTypeTable(*func->GetMIRFuncType());
+  func->AllocSymTab();
+  MIRSymbol *funcSym = func->GetFuncSymbol();
+  funcSym->SetStorageClass(kScExtern);
+  funcSym->SetAppearsInCode(true);
+  MIRType *argTy = GlobalTables::GetTypeTable().GetPtr();
+  MIRSymbol *argSt = func->GetSymTab()->CreateSymbol(kScopeLocal);
+  argSt->SetNameStrIdx(mirBuilder->GetOrCreateStringIndex(paramName));
+  argSt->SetTyIdx(argTy->GetTypeIndex());
+  argSt->SetStorageClass(kScFormal);
+  argSt->SetSKind(kStVar);
+  func->GetSymTab()->AddToStringSymbolMap(*argSt);
+  std::vector<MIRSymbol*> formals;
+  formals.emplace_back(argSt);
+  if ((name == "MCC_SyncEnterFast0") || (name == "MCC_SyncEnterFast1") ||
+      (name == "MCC_SyncEnterFast2") || (name == "MCC_SyncEnterFast3") ||
+      (name == "MCC_SyncExitFast")) {
+    MIRSymbol *argStMatch = func->GetSymTab()->CreateSymbol(kScopeLocal);
+    argStMatch->SetNameStrIdx(mirBuilder->GetOrCreateStringIndex("monitor_slot"));
+    argStMatch->SetTyIdx(argTy->GetTypeIndex());
+    argStMatch->SetStorageClass(kScFormal);
+    argStMatch->SetSKind(kStVar);
+    func->GetSymTab()->AddToStringSymbolMap(*argStMatch);
+    formals.emplace_back(argStMatch);
+  }
+  func->UpdateFuncTypeAndFormalsAndReturnType(formals, GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex(),
+                                              false);
+  auto *funcType = func->GetMIRFuncType();
+  ASSERT(funcType != nullptr, "null ptr check");
+  beCommon.AddTypeSizeAndAlign(funcType->GetTypeIndex(), GetPrimTypeSize(funcType->GetPrimType()));
+
+  builtinFuncIDs.emplace_back(std::pair<BuiltinFunctionID, PUIdx>(id, func->GetPuidx()));
+  return func;
+}
+
+void CGLowerer::RegisterBuiltIns() {
+  for (uint32 i = 0; i < sizeof(cgBuiltins) / sizeof(cgBuiltins[0]); ++i) {
+    BuiltinFunctionID id = cgBuiltins[i].first;
+    IntrinDesc &desc = IntrinDesc::intrinTable[id];
+
+    MIRFunction *func = mirBuilder->GetOrCreateFunction(cgBuiltins[i].second,
+                                                        GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex());
+    beCommon.UpdateTypeTable(*func->GetMIRFuncType());
+    func->AllocSymTab();
+    MIRSymbol *funcSym = func->GetFuncSymbol();
+    funcSym->SetStorageClass(kScExtern);
+    funcSym->SetAppearsInCode(true);
+    /* return type */
+    MIRType *retTy = desc.GetReturnType();
+    CHECK_FATAL(retTy != nullptr, "retTy should not be nullptr");
+    /* use void* for PTY_dynany */
+    if (retTy->GetPrimType() == PTY_dynany) {
+      retTy = GlobalTables::GetTypeTable().GetPtr();
+    }
+
+    std::vector<MIRSymbol*> formals;
+    const std::string params[IntrinDesc::kMaxArgsNum] = { "p0", "p1", "p2", "p3", "p4", "p5" };
+    for (uint32 j = 0; j < IntrinDesc::kMaxArgsNum; ++j) {
+      MIRType *argTy = desc.GetArgType(j);
+      if (argTy == nullptr) {
+        break;
+      }
+      /* use void* for PTY_dynany */
+      if (argTy->GetPrimType() == PTY_dynany) {
+        argTy = GlobalTables::GetTypeTable().GetPtr();
+      }
+      MIRSymbol *argSt = func->GetSymTab()->CreateSymbol(kScopeLocal);
+      argSt->SetNameStrIdx(mirBuilder->GetOrCreateStringIndex(params[j]));
+      argSt->SetTyIdx(argTy->GetTypeIndex());
+      argSt->SetStorageClass(kScFormal);
+      argSt->SetSKind(kStVar);
+      func->GetSymTab()->AddToStringSymbolMap(*argSt);
+      formals.emplace_back(argSt);
+    }
+    func->UpdateFuncTypeAndFormalsAndReturnType(formals, retTy->GetTypeIndex(), false);
+    auto *funcType = func->GetMIRFuncType();
+    ASSERT(funcType != nullptr, "null ptr check");
+    beCommon.AddTypeSizeAndAlign(funcType->GetTypeIndex(), GetPrimTypeSize(funcType->GetPrimType()));
+
+    builtinFuncIDs.emplace_back(std::pair<BuiltinFunctionID, PUIdx>(id, func->GetPuidx()));
+  }
+
+  /* register __builtin_sync_enter */
+  static_cast<void>(RegisterFunctionVoidStarToVoid(INTRN_FIRST_SYNC_ENTER, "MCC_SyncEnterFast0", "obj"));
+  static_cast<void>(RegisterFunctionVoidStarToVoid(INTRN_SECOND_SYNC_ENTER, "MCC_SyncEnterFast1", "obj"));
+  static_cast<void>(RegisterFunctionVoidStarToVoid(INTRN_THIRD_SYNC_ENTER, "MCC_SyncEnterFast2", "obj"));
+  static_cast<void>(RegisterFunctionVoidStarToVoid(INTRN_FOURTH_SYNC_ENTER, "MCC_SyncEnterFast3", "obj"));
+  /* register __builtin_sync_exit */
+  static_cast<void>(RegisterFunctionVoidStarToVoid(INTRN_YNC_EXIT, "MCC_SyncExitFast", "obj"));
+}
+
+/*
+ * From Maple IR Document as of Apr 14, 2017
+ * Type Conversion Expression Opcodes
+ * Conversions between integer types of different sizes require the cvt opcode.
+ * Conversion between signed and unsigned integers of the same size does not
+ * require any operation, not even retype.
+ * cvt :
+ * Convert the operand's value from <from-type> to <to-type>.
+ * If the sizes of the two types are the same, the conversion must involve
+ * altering the bits.
+ * retype:
+ * <opnd0> is converted to <prim-type> which has derived type <type> without
+ * changing any bits.  The size of <opnd0> and <prim-type> must be the same.
+ * <opnd0> may be of aggregate type.
+ */
+BaseNode *CGLowerer::MergeToCvtType(PrimType dType, PrimType sType, BaseNode &src) const {
+  CHECK_FATAL(IsPrimitiveInteger(dType) || IsPrimitiveFloat(dType),
+              "dtype should be primitiveInteger or primitiveFloat");
+  CHECK_FATAL(IsPrimitiveInteger(sType) || IsPrimitiveFloat(sType),
+              "sType should be primitiveInteger or primitiveFloat");
+  /* src i32, dest f32; src i64, dest f64 */
+  CHECK_FATAL(
+      (IsPrimitiveInteger(sType) && IsPrimitiveFloat(dType) &&
+       (GetPrimTypeBitSize(sType) == GetPrimTypeBitSize(dType))) ||
+      (IsPrimitiveInteger(sType) && IsPrimitiveInteger(dType)),
+      "when sType is primitiveInteger and dType is primitiveFloat, sType's primTypeBitSize must equal dType's,"
+      " or both sType and dType should primitiveInteger");
+
+  /* src & dest are both of float type */
+  MIRType *toType = GlobalTables::GetTypeTable().GetPrimType(dType);
+  MIRType *fromType = GlobalTables::GetTypeTable().GetPrimType(sType);
+  if (IsPrimitiveInteger(sType) && IsPrimitiveFloat(dType) &&
+      (GetPrimTypeBitSize(sType) == GetPrimTypeBitSize(dType))) {
+    return mirBuilder->CreateExprRetype(*toType, *fromType, &src);
+  } else if (IsPrimitiveInteger(sType) && IsPrimitiveInteger(dType)) {
+    if (GetPrimTypeBitSize(sType) >= GetPrimTypeBitSize(dType)) {
+      if (dType == PTY_u1) {  /* e.g., type _Bool */
+        toType = GlobalTables::GetTypeTable().GetPrimType(PTY_u8);
+        return mirBuilder->CreateExprCompare(OP_ne, *toType, *fromType, &src, mirBuilder->CreateIntConst(0, sType));
+      } else if (GetPrimTypeBitSize(sType) > GetPrimTypeBitSize(dType)) {
+        return mirBuilder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, &src);
+      } else if (IsSignedInteger(sType) != IsSignedInteger(dType)) {
+        return mirBuilder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, &src);
+      }
+      src.SetPrimType(dType);
+      return &src;
+      /*
+       * Force type cvt here because we currently do not run constant folding
+       * or contanst propagation before CG. We may revisit this decision later.
+       */
+    } else if (GetPrimTypeBitSize(sType) < GetPrimTypeBitSize(dType)) {
+      return mirBuilder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, &src);
+    } else if (IsConstvalZero(src)) {
+      return mirBuilder->CreateIntConst(0, dType);
+    }
+    CHECK_FATAL(false, "should not run here");
+  }
+  CHECK_FATAL(false, "should not run here");
+}
+
+IreadNode &CGLowerer::GetLenNode(BaseNode &opnd0) {
+  MIRIntConst *arrayHeaderNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+      static_cast<uint64>(RTSupport::GetRTSupportInstance().GetArrayLengthOffset()),
+      *GlobalTables::GetTypeTable().GetTypeFromTyIdx(opnd0.GetPrimType()));
+  BaseNode *arrayHeaderCstNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(arrayHeaderNode);
+  arrayHeaderCstNode->SetPrimType(opnd0.GetPrimType());
+  MIRType *addrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(opnd0.GetPrimType());
+  BaseNode *refLenAddr = mirBuilder->CreateExprBinary(OP_add, *addrType, &opnd0, arrayHeaderCstNode);
+  MIRType *infoLenType = GlobalTables::GetTypeTable().GetInt32();
+  MIRType *ptrType = beCommon.BeGetOrCreatePointerType(*infoLenType);
+  IreadNode *lenNode = mirBuilder->CreateExprIread(*infoLenType, *ptrType, 0, refLenAddr);
+  return (*lenNode);
+}
+
+LabelIdx CGLowerer::GetLabelIdx(MIRFunction &curFunc) const {
+  std::string suffix = std::to_string(curFunc.GetLabelTab()->GetLabelTableSize());
+  GStrIdx labelStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("__label_BC_" + suffix);
+  LabelIdx labIdx = curFunc.GetLabelTab()->AddLabel(labelStrIdx);
+  return labIdx;
+}
+
+void CGLowerer::ProcessArrayExpr(BaseNode &expr, BlockNode &blkNode) {
+  bool needProcessArrayExpr = !ShouldOptarray() && mirModule.IsJavaModule();
+  if (!needProcessArrayExpr) {
+    return;
+  }
+  /* Array boundary check */
+  MIRFunction *curFunc = mirModule.CurFunction();
+  auto &arrayNode = static_cast<ArrayNode&>(expr);
+  StmtNode *boundaryCheckStmt = nullptr;
+  if (arrayNode.GetBoundsCheck()) {
+    CHECK_FATAL(arrayNode.GetNopndSize() == kOperandNumBinary, "unexpected nOpnd size");
+    BaseNode *opnd0 = arrayNode.GetNopndAt(0);
+    if (opnd0->GetOpCode() == OP_iread) {
+      PregIdx pregIdx = curFunc->GetPregTab()->CreatePreg(opnd0->GetPrimType());
+      RegassignNode *temp = mirBuilder->CreateStmtRegassign(opnd0->GetPrimType(), pregIdx, opnd0);
+      blkNode.InsertAfter(blkNode.GetLast(), temp);
+      arrayNode.SetNOpndAt(0, mirBuilder->CreateExprRegread(opnd0->GetPrimType(), pregIdx));
+    }
+    IreadNode &lenNode = GetLenNode(*opnd0);
+    PregIdx lenPregIdx = curFunc->GetPregTab()->CreatePreg(lenNode.GetPrimType());
+    RegassignNode *lenRegassignNode = mirBuilder->CreateStmtRegassign(lenNode.GetPrimType(), lenPregIdx, &lenNode);
+    BaseNode *lenRegreadNode = mirBuilder->CreateExprRegread(PTY_u32, lenPregIdx);
+
+    LabelIdx labIdx = GetLabelIdx(*curFunc);
+    LabelNode *labelBC = mirBuilder->CreateStmtLabel(labIdx);
+    BaseNode *cond = mirBuilder->CreateExprCompare(OP_ge, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                   *GlobalTables::GetTypeTable().GetUInt32(),
+                                                   arrayNode.GetNopndAt(1), lenRegreadNode);
+    CondGotoNode *brFalseNode = mirBuilder->CreateStmtCondGoto(cond, OP_brfalse, labIdx);
+    MIRFunction *fn = mirBuilder->GetOrCreateFunction("MCC_Array_Boundary_Check", TyIdx(PTY_void));
+    fn->GetFuncSymbol()->SetAppearsInCode(true);
+    beCommon.UpdateTypeTable(*fn->GetMIRFuncType());
+    fn->AllocSymTab();
+    MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    args.emplace_back(arrayNode.GetNopndAt(0));
+    args.emplace_back(arrayNode.GetNopndAt(1));
+    boundaryCheckStmt = mirBuilder->CreateStmtCall(fn->GetPuidx(), args);
+    blkNode.InsertAfter(blkNode.GetLast(), lenRegassignNode);
+    blkNode.InsertAfter(blkNode.GetLast(), brFalseNode);
+    blkNode.InsertAfter(blkNode.GetLast(), boundaryCheckStmt);
+    blkNode.InsertAfter(blkNode.GetLast(), labelBC);
+  }
+}
+
+BaseNode *CGLowerer::LowerExpr(BaseNode &parent, BaseNode &expr, BlockNode &blkNode) {
+  bool isCvtU1Expr = (expr.GetOpCode() == OP_cvt && expr.GetPrimType() == PTY_u1 &&
+      static_cast<TypeCvtNode&>(expr).FromType() != PTY_u1);
+  if (expr.GetPrimType() == PTY_u1) {
+#if TARGAARCH64
+    expr.SetPrimType(PTY_i32);
+#elif TARGX86_64
+    expr.SetPrimType(PTY_u8);
+#else
+    CHECK_FATAL(false, "target not supported");
+#endif
+  }
+  if (expr.GetOpCode() == OP_intrinsicopwithtype) {
+    return LowerIntrinsicopwithtype(parent, static_cast<IntrinsicopNode&>(expr), blkNode);
+  }
+
+  LowerTypePtr(expr);
+
+  if (expr.GetOpCode() == OP_iread && expr.Opnd(0)->GetOpCode() == OP_array) {
+    /* iread ptr <* <$MUIDDataDefTabEntry>> 1 (
+     *     array 0 ptr <* <[5] <$MUIDDataDefTabEntry>>> (addrof ...
+     * ==>
+     * intrinsicop a64 MPL_READ_STATIC_OFFSET_TAB (addrof ..
+     */
+    BaseNode *node = LowerExpr(expr, *expr.Opnd(0), blkNode);
+    if (node->GetOpCode() == OP_intrinsicop) {
+      auto *binNode = static_cast<IntrinsicopNode*>(node);
+      CHECK_FATAL(binNode->GetIntrinsic() == INTRN_MPL_READ_STATIC_OFFSET_TAB, "Something wrong here");
+      return binNode;
+    } else {
+      expr.SetOpnd(node, 0);
+    }
+  } else {
+    for (size_t i = 0; i < expr.NumOpnds(); ++i) {
+      expr.SetOpnd(LowerExpr(expr, *expr.Opnd(i), blkNode), i);
+    }
+  }
+  // Convert `cvt u1 xx <expr>` to `ne u8 xx (<expr>, constval xx 0)`
+  // No need to convert `cvt u1 u1 <expr>`
+  if (isCvtU1Expr) {
+    auto &cvtExpr = static_cast<TypeCvtNode&>(expr);
+    PrimType fromType = cvtExpr.FromType();
+    auto *fromMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(fromType));
+    // We use u8 instead of u1 because codegen can't recognize u1
+    auto *toMIRType = GlobalTables::GetTypeTable().GetUInt8();
+    auto *zero = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *fromMIRType);
+    auto *converted = mirBuilder->CreateExprCompare(OP_ne, *toMIRType, *fromMIRType, cvtExpr.Opnd(0),
+                                                    mirBuilder->CreateConstval(zero));
+    return converted;
+  }
+  switch (expr.GetOpCode()) {
+    case OP_array: {
+      ProcessArrayExpr(expr, blkNode);
+      if (!mirModule.IsCModule()) {
+        return LowerArray(static_cast<ArrayNode&>(expr), parent);
+      } else {
+        return LowerCArray(static_cast<ArrayNode&>(expr));
+      }
+    }
+
+    case OP_dread:
+      return LowerDread(static_cast<DreadNode&>(expr));
+
+    case OP_addrof:
+      return LowerAddrof(static_cast<AddrofNode&>(expr));
+
+    case OP_iread:
+      return LowerIread(static_cast<IreadNode&>(expr));
+
+    case OP_iaddrof:
+      return LowerIaddrof(static_cast<IreadNode&>(expr));
+
+    case OP_select:
+      if (IsComplexSelect(static_cast<TernaryNode&>(expr))) {
+        return LowerComplexSelect(static_cast<TernaryNode&>(expr), parent, blkNode);
+      } else if (mirModule.GetFlavor() != kFlavorLmbc) {
+        return SplitTernaryNodeResult(static_cast<TernaryNode&>(expr), parent, blkNode);
+      } else {
+        return &expr;
+      }
+
+    case OP_sizeoftype: {
+      CHECK(static_cast<SizeoftypeNode&>(expr).GetTyIdx() < beCommon.GetSizeOfTypeSizeTable(),
+            "index out of range in CGLowerer::LowerExpr");
+      int64 typeSize = beCommon.GetTypeSize(static_cast<SizeoftypeNode&>(expr).GetTyIdx());
+      return mirModule.GetMIRBuilder()->CreateIntConst(static_cast<uint64>(typeSize), PTY_u32);
+    }
+
+    case OP_fieldsdist: {
+      auto &fdNode = static_cast<FieldsDistNode&>(expr);
+      CHECK(fdNode.GetTyIdx() < beCommon.GetSizeOfTypeSizeTable(),
+            "index out of range in CGLowerer::LowerExpr");
+      MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fdNode.GetTyIdx());
+      CHECK(ty->GetKind() == kTypeClass, "wrong type for FieldsDistNode");
+      MIRClassType *classType = static_cast<MIRClassType*>(ty);
+      const JClassLayout &layout = beCommon.GetJClassLayout(*classType);
+      ASSERT(!layout.empty(), "container should not be empty");
+      int32 i1 = fdNode.GetFiledID1() > 0 ? fdNode.GetFiledID1() - 1 : 0;
+      int32 i2 = fdNode.GetFiledID2() > 0 ? fdNode.GetFiledID2() - 1 : 0;
+      int64 offset = layout[i2].GetOffset() - layout[i1].GetOffset();
+      return mirModule.GetMIRBuilder()->CreateIntConst(static_cast<uint64>(offset), PTY_u32);
+    }
+
+    case OP_intrinsicop:
+      if (IsIntrinsicOpHandledAtLowerLevel(static_cast<IntrinsicopNode&>(expr).GetIntrinsic())) {
+        return &expr;
+      }
+      return LowerIntrinsicop(parent, static_cast<IntrinsicopNode&>(expr), blkNode);
+
+    case OP_alloca: {
+      GetCurrentFunc()->SetVlaOrAlloca(true);
+      return &expr;
+    }
+    case OP_rem:
+      return LowerRem(expr, blkNode);
+
+    case OP_cand:
+      expr.SetOpCode(OP_land);
+      return SplitBinaryNodeOpnd1(static_cast<BinaryNode&>(expr), blkNode);
+    case OP_cior:
+      expr.SetOpCode(OP_lior);
+      return SplitBinaryNodeOpnd1(static_cast<BinaryNode&>(expr), blkNode);
+    case OP_cvt:
+    case OP_retype:
+    case OP_zext:
+    case OP_sext:
+      return LowerCastExpr(expr);
+    case OP_extractbits:
+      return LowerExtractBits(static_cast<ExtractbitsNode&>(expr));
+    default:
+      return &expr;
+  }
+}
+
+BaseNode *CGLowerer::LowerDread(DreadNode &dread) {
+  /* use PTY_u8 for boolean type in dread/iread */
+  if (dread.GetPrimType() == PTY_u1) {
+    dread.SetPrimType(PTY_u8);
+  }
+  auto *result = LowerDreadToThreadLocal(dread);
+  if (result->GetOpCode() == OP_iread) {
+    return LowerIread(static_cast<IreadNode &>(*result));
+  } else if (dread.GetFieldID() != 0) {
+    return LowerDreadBitfield(static_cast<DreadNode &>(*result));
+  }
+  return result;
+}
+
+void CGLowerer::LowerRegassign(RegassignNode &regNode, BlockNode &newBlk) {
+  CHECK_FATAL(regNode.GetPrimType() != PTY_ptr, "should have been lowered already");
+  CHECK_FATAL(regNode.GetPrimType() != PTY_ref, "should have been lowered already");
+  BaseNode *rhsOpnd = regNode.Opnd(0);
+  Opcode op = rhsOpnd->GetOpCode();
+  if ((op == OP_gcmalloc) || (op == OP_gcpermalloc)) {
+    LowerGCMalloc(regNode, static_cast<GCMallocNode&>(*rhsOpnd), newBlk, op == OP_gcpermalloc);
+    return;
+  } else if ((op == OP_gcmallocjarray) || (op == OP_gcpermallocjarray)) {
+    LowerJarrayMalloc(regNode, static_cast<JarrayMallocNode&>(*rhsOpnd), newBlk, op == OP_gcpermallocjarray);
+    return;
+  } else {
+    regNode.SetOpnd(LowerExpr(regNode, *rhsOpnd, newBlk), 0);
+    newBlk.AddStatement(&regNode);
+  }
+}
+
+BaseNode *CGLowerer::ExtractSymbolAddress(const StIdx &stIdx) {
+  auto builder = mirModule.GetMIRBuilder();
+  return builder->CreateExprAddrof(0, stIdx);
+}
+
+BaseNode *CGLowerer::LowerDreadToThreadLocal(BaseNode &expr) {
+  auto *result = &expr;
+  if (expr.GetOpCode() != maple::OP_dread) {
+    return result;
+  }
+  uint32 oldTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  auto dread = static_cast<DreadNode&>(expr);
+  StIdx stIdx = dread.GetStIdx();
+  MIRSymbol *symbol = stIdx.IsGlobal() ?
+      GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx()) :
+      GetCurrentFunc()->GetSymbolTabItem(stIdx.Idx());
+  ASSERT(symbol != nullptr, "symbol should not be nullptr");
+  if (symbol->IsThreadLocal()) {
+    //  iread <* u32> 0 (regread u64 %addr)
+    auto addr = ExtractSymbolAddress(stIdx);
+    auto fieldId = dread.GetFieldID();
+    auto symbolType = symbol->GetType();
+    auto readType = fieldId == 0 ? symbolType : static_cast<MIRStructType *>(symbolType)->GetFieldType(fieldId);
+    auto ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*symbolType);
+    auto iread = mirModule.GetMIRBuilder()->CreateExprIread(*readType, *ptrType, fieldId, addr);
+    result = iread;
+  }
+  uint32 newTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  if (newTypeTableSize != oldTypeTableSize) {
+    beCommon.AddNewTypeAfterBecommon(oldTypeTableSize, newTypeTableSize);
+  }
+  return result;
+}
+
+StmtNode *CGLowerer::LowerDassignToThreadLocal(StmtNode &stmt) {
+  StmtNode *result = &stmt;
+  if (stmt.GetOpCode() != maple::OP_dassign) {
+    return result;
+  }
+  uint32 oldTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  auto dAssign = static_cast<DassignNode&>(stmt);
+  StIdx stIdx = dAssign.GetStIdx();
+  if (!stIdx.IsGlobal()) {
+    return result;
+  }
+  MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+  ASSERT(symbol != nullptr, "symbol should not be nullptr");
+  if (symbol->IsThreadLocal()) {
+    //  iassign <* u32> 0 (regread u64 %addr, dread u32 $x)
+    auto addr = ExtractSymbolAddress(stIdx);
+    auto ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*symbol->GetType());
+    auto iassign = mirModule.GetMIRBuilder()->CreateStmtIassign(*ptrType, dAssign.GetFieldID(), addr, dAssign.GetRHS());
+    result = iassign;
+  }
+  uint32 newTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  if (newTypeTableSize != oldTypeTableSize) {
+    beCommon.AddNewTypeAfterBecommon(oldTypeTableSize, newTypeTableSize);
+  }
+  return result;
+}
+
+void CGLowerer::LowerDassign(DassignNode &dsNode, BlockNode &newBlk) {
+  StmtNode *newStmt = nullptr;
+  BaseNode *rhs = nullptr;
+  Opcode op = dsNode.GetRHS()->GetOpCode();
+  if (dsNode.GetFieldID() != 0) {
+    newStmt = LowerDassignBitfield(dsNode, newBlk);
+  } else if (op == OP_intrinsicop) {
+    IntrinsicopNode *intrinNode = static_cast<IntrinsicopNode*>(dsNode.GetRHS());
+    MIRType *retType = IntrinDesc::intrinTable[intrinNode->GetIntrinsic()].GetReturnType();
+    CHECK_FATAL(retType != nullptr, "retType should not be nullptr");
+    if (retType->GetKind() == kTypeStruct) {
+      newStmt = LowerIntrinsicopDassign(dsNode, *intrinNode, newBlk);
+    } else {
+      rhs = LowerExpr(dsNode, *intrinNode, newBlk);
+      dsNode.SetRHS(rhs);
+      CHECK_FATAL(dsNode.GetRHS() != nullptr, "dsNode->rhs is null in CGLowerer::LowerDassign");
+      if (!IsDassignNOP(dsNode)) {
+        newStmt = &dsNode;
+      }
+    }
+  } else if ((op == OP_gcmalloc) || (op == OP_gcpermalloc)) {
+    LowerGCMalloc(dsNode, static_cast<GCMallocNode&>(*dsNode.GetRHS()), newBlk, op == OP_gcpermalloc);
+    return;
+  } else if ((op == OP_gcmallocjarray) || (op == OP_gcpermallocjarray)) {
+    LowerJarrayMalloc(dsNode, static_cast<JarrayMallocNode&>(*dsNode.GetRHS()), newBlk, op == OP_gcpermallocjarray);
+    return;
+  } else {
+    rhs = LowerExpr(dsNode, *dsNode.GetRHS(), newBlk);
+    dsNode.SetRHS(rhs);
+    newStmt = &dsNode;
+  }
+
+  if (newStmt != nullptr) {
+    newBlk.AddStatement(LowerDassignToThreadLocal(*newStmt));
+  }
+}
+
+// Lower stmt Form
+// Initial form: decrefreset (addrof ptr %RegX_RXXXX)
+// Convert to form: dassign %RegX_RXXXX 0 (constval ref 0)
+// Final form: str xzr, [x29,#XX]
+void CGLowerer::LowerResetStmt(StmtNode &stmt, BlockNode &block) {
+  UnaryStmtNode &unaryStmtNode = static_cast<UnaryStmtNode&>(stmt);
+  AddrofNode *addrofNode = static_cast<AddrofNode*>(unaryStmtNode.GetRHS());
+  MIRType &type = *GlobalTables::GetTypeTable().GetPrimType(PTY_ref);
+  MIRConst *constVal = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, type);
+  ConstvalNode *exprConst = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>();
+  exprConst->SetPrimType(type.GetPrimType());
+  exprConst->SetConstVal(constVal);
+  DassignNode *dassignNode = mirModule.CurFuncCodeMemPool()->New<DassignNode>();
+  dassignNode->SetStIdx(addrofNode->GetStIdx());
+  dassignNode->SetRHS(exprConst);
+  dassignNode->SetFieldID(addrofNode->GetFieldID());
+  block.AddStatement(dassignNode);
+}
+
+StmtNode *CGLowerer::LowerIntrinsicopDassign(const DassignNode &dsNode,
+                                             IntrinsicopNode &intrinNode, BlockNode &newBlk) {
+  for (size_t i = 0; i < intrinNode.GetNumOpnds(); ++i) {
+    ASSERT(intrinNode.Opnd(i) != nullptr, "intrinNode.Opnd(i) should not be nullptr");
+    intrinNode.SetOpnd(LowerExpr(intrinNode, *intrinNode.Opnd(i), newBlk), i);
+  }
+  MIRIntrinsicID intrnID = intrinNode.GetIntrinsic();
+  IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrnID];
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  const std::string name = intrinDesc->name;
+  CHECK_FATAL(intrinDesc->name != nullptr, "intrinDesc's name should not be nullptr");
+  st->SetNameStrIdx(name);
+  st->SetStorageClass(kScText);
+  st->SetSKind(kStFunc);
+  MIRFunction *fn = mirModule.GetMemPool()->New<MIRFunction>(&mirModule, st->GetStIdx());
+  MapleVector<BaseNode*> &nOpnds = intrinNode.GetNopnd();
+  st->SetFunction(fn);
+  std::vector<TyIdx> fnTyVec;
+  std::vector<TypeAttrs> fnTaVec;
+  CHECK_FATAL(intrinDesc->IsJsOp(), "intrinDesc should be JsOp");
+  /* setup parameters */
+  for (uint32 i = 0; i < nOpnds.size(); ++i) {
+    fnTyVec.emplace_back(GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_a32)->GetTypeIndex());
+    fnTaVec.emplace_back(TypeAttrs());
+    BaseNode *addrNode = beCommon.GetAddressOfNode(*nOpnds[i]);
+    CHECK_FATAL(addrNode != nullptr, "addrNode should not be nullptr");
+    nOpnds[i] = addrNode;
+  }
+  MIRSymbol *dst = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dsNode.GetStIdx());
+  MIRType *ty = dst->GetType();
+  MIRType *fnType = beCommon.BeGetOrCreateFunctionType(ty->GetTypeIndex(), fnTyVec, fnTaVec);
+  st->SetTyIdx(fnType->GetTypeIndex());
+  fn->SetMIRFuncType(static_cast<MIRFuncType*>(fnType));
+  fn->SetReturnTyIdx(ty->GetTypeIndex());
+  CHECK_FATAL(ty->GetKind() == kTypeStruct, "ty's kind should be struct type");
+  CHECK_FATAL(dsNode.GetFieldID() == 0, "dsNode's filedId should equal");
+  AddrofNode *addrofNode = mirBuilder->CreateAddrof(*dst, PTY_a32);
+  MapleVector<BaseNode*> newOpnd(mirModule.CurFuncCodeMemPoolAllocator()->Adapter());
+  newOpnd.emplace_back(addrofNode);
+  (void)newOpnd.insert(newOpnd.cend(), nOpnds.cbegin(), nOpnds.cend());
+  CallNode *callStmt = mirModule.CurFuncCodeMemPool()->New<CallNode>(mirModule, OP_call);
+  callStmt->SetPUIdx(st->GetFunction()->GetPuidx());
+  callStmt->SetNOpnd(newOpnd);
+  return callStmt;
+}
+
+/*   From maple_ir/include/dex2mpl/dexintrinsic.def
+ *   JAVA_ARRAY_LENGTH
+ *   JAVA_ARRAY_FILL
+ *   JAVA_FILL_NEW_ARRAY
+ *   JAVA_CHECK_CAST
+ *   JAVA_CONST_CLASS
+ *   JAVA_INSTANCE_OF
+ *   JAVA_MERGE
+ *   JAVA_RANDOM
+ *   #if DEXHACK
+ *   JAVA_PRINTLN
+ *   #endif
+ *   INTRN_<<name>>
+ *   intrinsic
+ */
+BaseNode *CGLowerer::LowerJavascriptIntrinsicop(IntrinsicopNode &intrinNode, const IntrinDesc &desc) {
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  CHECK_FATAL(desc.name != nullptr, "desc's name should not be nullptr");
+  const std::string name = desc.name;
+  st->SetNameStrIdx(name);
+  st->SetStorageClass(kScText);
+  st->SetSKind(kStFunc);
+  MIRFunction *fn = mirModule.GetMemPool()->New<MIRFunction>(&mirModule, st->GetStIdx());
+  MapleVector<BaseNode*> &nOpnds = intrinNode.GetNopnd();
+  st->SetFunction(fn);
+  std::vector<TyIdx> fnTyVec;
+  std::vector<TypeAttrs> fnTaVec;
+  CHECK_FATAL(desc.IsJsOp(), "desc should be jsOp");
+  /* setup parameters */
+  for (uint32 i = 0; i < nOpnds.size(); ++i) {
+    fnTyVec.emplace_back(GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_a32)->GetTypeIndex());
+    fnTaVec.emplace_back(TypeAttrs());
+    BaseNode *addrNode = beCommon.GetAddressOfNode(*nOpnds[i]);
+    CHECK_FATAL(addrNode != nullptr, "can not get address");
+    nOpnds[i] = addrNode;
+  }
+
+  MIRType *retType = desc.GetReturnType();
+  CHECK_FATAL(retType != nullptr, "retType should not be nullptr");
+  if (retType->GetKind() == kTypeStruct) {
+    /* create a local symbol and dread it; */
+    std::string tmpstr("__ret_struct_tmp_st");
+    static uint32 tmpIdx = 0;
+    tmpstr.append(std::to_string(tmpIdx++));
+    MIRSymbol *tmpSt = mirBuilder->GetOrCreateDeclInFunc(tmpstr, *retType, *mirModule.CurFunction());
+    MIRType *fnType = beCommon.BeGetOrCreateFunctionType(retType->GetTypeIndex(), fnTyVec, fnTaVec);
+    st->SetTyIdx(fnType->GetTypeIndex());
+    fn->SetMIRFuncType(static_cast<MIRFuncType*>(fnType));
+    AddrofNode *addrofNode = mirBuilder->CreateAddrof(*tmpSt, PTY_a32);
+    MapleVector<BaseNode*> newOpnd(mirModule.CurFuncCodeMemPoolAllocator()->Adapter());
+    newOpnd.emplace_back(addrofNode);
+    (void)newOpnd.insert(newOpnd.cend(), nOpnds.cbegin(), nOpnds.cend());
+    CallNode *callStmt = mirModule.CurFuncCodeMemPool()->New<CallNode>(mirModule, OP_call);
+    callStmt->SetPUIdx(st->GetFunction()->GetPuidx());
+    callStmt->SetNOpnd(newOpnd);
+    currentBlock->AddStatement(callStmt);
+    /* return the dread */
+    AddrofNode *drRetSt = mirBuilder->CreateDread(*tmpSt, PTY_agg);
+    return drRetSt;
+  }
+  CHECK_FATAL(st->GetStIdx().FullIdx() != 0, "the fullIdx of st's stIdx should not equal 0");
+  CallNode *callStmt = static_cast<CallNode*>(mirBuilder->CreateStmtCall(st->GetStIdx().FullIdx(), nOpnds));
+  currentBlock->AddStatement(callStmt);
+  PrimType promotedPrimType = intrinNode.GetPrimType() == PTY_u1 ? PTY_u32 : intrinNode.GetPrimType();
+  BaseNode *drRetSt = mirBuilder->CreateExprRegread(promotedPrimType, -kSregRetval0);
+  /*
+    * for safty dassign the return value to a register and return the dread to that register
+    * to avoid such code:
+    * call $__js_int32 (addrof ptr %temp_var_8 0)
+    * call $__jsop_getelem (addrof a32 %temp_var_9 0, addrof a32 $arr 0, dread i32 %%retval 0)
+    * for many target, the first actual parameter and return value would use R0, which would cause the above
+    * case fail
+    */
+  PregIdx tmpRegIdx = GetCurrentFunc()->GetPregTab()->CreatePreg(promotedPrimType);
+  RegassignNode *dstoReg = mirBuilder->CreateStmtRegassign(promotedPrimType, tmpRegIdx, drRetSt);
+  currentBlock->AddStatement(dstoReg);
+  RegreadNode *outDsNode = mirBuilder->CreateExprRegread(promotedPrimType, tmpRegIdx);
+  return outDsNode;
+}
+
+StmtNode *CGLowerer::CreateStmtCallWithReturnValue(const IntrinsicopNode &intrinNode, const MIRSymbol &ret,
+                                                   PUIdx bFunc, BaseNode *extraInfo) const {
+  MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (size_t i = 0; i < intrinNode.NumOpnds(); ++i) {
+    args.emplace_back(intrinNode.Opnd(i));
+  }
+  if (extraInfo != nullptr) {
+    args.emplace_back(extraInfo);
+  }
+  return mirBuilder->CreateStmtCallAssigned(bFunc, args, &ret, OP_callassigned);
+}
+
+StmtNode *CGLowerer::CreateStmtCallWithReturnValue(const IntrinsicopNode &intrinNode, PregIdx retPregIdx, PUIdx bFunc,
+                                                   BaseNode *extraInfo) const {
+  MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  for (size_t i = 0; i < intrinNode.NumOpnds(); ++i) {
+    args.emplace_back(intrinNode.Opnd(i));
+  }
+  if (extraInfo != nullptr) {
+    args.emplace_back(extraInfo);
+  }
+  return mirBuilder->CreateStmtCallRegassigned(bFunc, args, retPregIdx, OP_callassigned);
+}
+
+BaseNode *CGLowerer::LowerIntrinJavaMerge(const BaseNode &parent, IntrinsicopNode &intrinNode) const {
+  BaseNode *resNode = &intrinNode;
+  CHECK_FATAL(intrinNode.GetNumOpnds() > 0, "invalid JAVA_MERGE intrinsic node");
+  BaseNode *candidate = intrinNode.Opnd(0);
+  ASSERT(candidate != nullptr, "candidate should not be nullptr");
+  resNode = candidate;
+  if (parent.GetOpCode() == OP_regassign) {
+    PrimType sTyp = resNode->GetPrimType();
+    auto &regAssign = static_cast<const RegassignNode&>(parent);
+    PrimType pType = GetCurrentFunc()->GetPregTab()->PregFromPregIdx(regAssign.GetRegIdx())->GetPrimType();
+    if (sTyp != pType) {
+      resNode = MergeToCvtType(pType, sTyp, *resNode);
+    }
+    return resNode;
+  }
+  if (parent.GetOpCode() == OP_dassign) {
+    auto &dassign = static_cast<const DassignNode&>(parent);
+    if (candidate->GetOpCode() == OP_constval) {
+      MIRSymbol *dest = GetCurrentFunc()->GetLocalOrGlobalSymbol(dassign.GetStIdx());
+      MIRType *toType = dest->GetType();
+      PrimType dTyp = toType->GetPrimType();
+      PrimType sTyp = resNode->GetPrimType();
+      if (dTyp != sTyp) {
+        resNode = MergeToCvtType(dTyp, sTyp, *resNode);
+      }
+      return resNode;
+    }
+    CHECK_FATAL((candidate->GetOpCode() == OP_dread) || (candidate->GetOpCode() == OP_regread),
+                "candidate's opcode should be OP_dread or OP_regread");
+    bool differentLocation =
+        (candidate->GetOpCode() == OP_dread)
+        ? !IsAccessingTheSameMemoryLocation(dassign, static_cast<DreadNode&>(*candidate))
+        : !IsAccessingTheSameMemoryLocation(dassign, static_cast<RegreadNode&>(*candidate), *this);
+    if (differentLocation) {
+      bool simpleMove = false;
+      /* res_node already contains the 0-th operand. */
+      for (size_t i = 1; i < intrinNode.GetNumOpnds(); ++i) {
+        candidate = intrinNode.Opnd(i);
+        ASSERT(candidate != nullptr, "candidate should not be nullptr");
+        bool sameLocation =
+            (candidate->GetOpCode() == OP_dread)
+            ? IsAccessingTheSameMemoryLocation(dassign, static_cast<DreadNode&>(*candidate))
+            : IsAccessingTheSameMemoryLocation(dassign, static_cast<RegreadNode&>(*candidate), *this);
+        if (sameLocation) {
+          simpleMove = true;
+          resNode = candidate;
+          break;
+        }
+      }
+      if (!simpleMove) {
+        /* if source and destination types don't match, insert 'retype' */
+        MIRSymbol *dest = GetCurrentFunc()->GetLocalOrGlobalSymbol(dassign.GetStIdx());
+        MIRType *toType = dest->GetType();
+        PrimType dTyp = toType->GetPrimType();
+        CHECK_FATAL((dTyp != PTY_agg) && (dassign.GetFieldID() <= 0),
+                    "dType should not be PTY_agg and dassign's filedId <= 0");
+        PrimType sType = resNode->GetPrimType();
+        if (dTyp != sType) {
+          resNode = MergeToCvtType(dTyp, sType, *resNode);
+        }
+      }
+    }
+    return resNode;
+  }
+  CHECK_FATAL(false, "should not run here");
+  return resNode;
+}
+
+BaseNode *CGLowerer::LowerIntrinJavaArrayLength(const BaseNode &parent, IntrinsicopNode &intrinNode) {
+  BaseNode *resNode = &intrinNode;
+  PUIdx bFunc = GetBuiltinToUse(intrinNode.GetIntrinsic());
+  CHECK_FATAL(bFunc != kFuncNotFound, "bFunc should not be kFuncNotFound");
+  MIRFunction *biFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(bFunc);
+
+  BaseNode *arrAddr = intrinNode.Opnd(0);
+  ASSERT(arrAddr != nullptr, "arrAddr should not be nullptr");
+  if (((arrAddr->GetPrimType() == PTY_a64) || (arrAddr->GetPrimType() == PTY_ref)) &&
+      ((parent.GetOpCode() == OP_regassign) || (parent.GetOpCode() == OP_dassign) || (parent.GetOpCode() == OP_ge))) {
+    MIRType *addrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(arrAddr->GetPrimType()));
+    MIRIntConst *arrayHeaderNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        static_cast<uint64>(RTSupport::GetRTSupportInstance().GetArrayLengthOffset()), *addrType);
+    BaseNode *arrayHeaderCstNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(arrayHeaderNode);
+    arrayHeaderCstNode->SetPrimType(arrAddr->GetPrimType());
+
+    BaseNode *refLenAddr = mirBuilder->CreateExprBinary(OP_add, *addrType, arrAddr, arrayHeaderCstNode);
+    MIRType *infoLenType = GlobalTables::GetTypeTable().GetInt32();
+    MIRType *ptrType = beCommon.BeGetOrCreatePointerType(*infoLenType);
+    resNode = mirBuilder->CreateExprIread(*infoLenType, *ptrType, 0, refLenAddr);
+    auto curFunc = mirModule.CurFunction();
+    std::string suffix = std::to_string(curFunc->GetLabelTab()->GetLabelTableSize());
+    GStrIdx labelStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("__label_nonnull_" + suffix);
+    LabelIdx labIdx = curFunc->GetLabelTab()->AddLabel(labelStrIdx);
+    LabelNode *labelNonNull = mirBuilder->CreateStmtLabel(labIdx);
+
+    BaseNode *cond = mirBuilder->CreateExprCompare(OP_ne,
+                                                   *GlobalTables::GetTypeTable().GetUInt1(),
+                                                   *GlobalTables::GetTypeTable().GetRef(), arrAddr,
+                                                   mirBuilder->CreateIntConst(0, PTY_ref));
+    CondGotoNode *brtureNode = mirBuilder->CreateStmtCondGoto(cond, OP_brtrue, labIdx);
+
+    MIRFunction *newFunc =
+        mirBuilder->GetOrCreateFunction("MCC_ThrowNullArrayNullPointerException",
+                                        GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex());
+    newFunc->GetFuncSymbol()->SetAppearsInCode(true);
+    beCommon.UpdateTypeTable(*newFunc->GetMIRFuncType());
+    newFunc->AllocSymTab();
+    MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    StmtNode *call = mirBuilder->CreateStmtCallAssigned(newFunc->GetPuidx(), args, nullptr, OP_callassigned);
+
+    currentBlock->AddStatement(brtureNode);
+    currentBlock->AppendStatementsFromBlock(*LowerCallAssignedStmt(*call));
+    currentBlock->AddStatement(labelNonNull);
+    return resNode;
+  }
+
+  if (parent.GetOpCode() == OP_regassign) {
+    auto &regAssign = static_cast<const RegassignNode&>(parent);
+    StmtNode *biCall = CreateStmtCallWithReturnValue(intrinNode, regAssign.GetRegIdx(), bFunc);
+    currentBlock->AppendStatementsFromBlock(*LowerCallAssignedStmt(*biCall));
+    PrimType pType = GetCurrentFunc()->GetPregTab()->PregFromPregIdx(regAssign.GetRegIdx())->GetPrimType();
+    resNode = mirBuilder->CreateExprRegread(pType, regAssign.GetRegIdx());
+    return resNode;
+  }
+
+  if (parent.GetOpCode() == OP_dassign) {
+    auto &dassign = static_cast<const DassignNode&>(parent);
+    MIRSymbol *ret = GetCurrentFunc()->GetLocalOrGlobalSymbol(dassign.GetStIdx());
+    StmtNode *biCall = CreateStmtCallWithReturnValue(intrinNode, *ret, bFunc);
+    currentBlock->AppendStatementsFromBlock(*LowerCallAssignedStmt(*biCall));
+    resNode = mirBuilder->CreateExprDread(*biFunc->GetReturnType(), 0, *ret);
+    return resNode;
+  }
+  CHECK_FATAL(false, "should not run here");
+  return resNode;
+}
+
+BaseNode *CGLowerer::LowerIntrinsicop(const BaseNode &parent, IntrinsicopNode &intrinNode) {
+  BaseNode *resNode = &intrinNode;
+  if (intrinNode.GetIntrinsic() == INTRN_JAVA_MERGE) {
+    resNode = LowerIntrinJavaMerge(parent, intrinNode);
+  } else if (intrinNode.GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH) {
+    resNode = LowerIntrinJavaArrayLength(parent, intrinNode);
+  }
+
+  return resNode;
+}
+
+void CGLowerer::ProcessClassInfo(MIRType &classType, bool &classInfoFromRt, std::string &classInfo) const {
+  MIRPtrType &ptrType = static_cast<MIRPtrType&>(classType);
+  MIRType *pType = ptrType.GetPointedType();
+  CHECK_FATAL(pType != nullptr, "Class type not found for INTRN_JAVA_CONST_CLASS");
+  MIRType *typeScalar = nullptr;
+
+  if (pType->GetKind() == kTypeScalar) {
+    typeScalar = pType;
+  } else if (classType.GetKind() == kTypeScalar) {
+    typeScalar = &classType;
+  }
+  if (typeScalar != nullptr) {
+    std::string eName(GetPrimTypeJavaName(typeScalar->GetPrimType()));
+    classInfo = PRIMITIVECLASSINFO_PREFIX_STR + eName;
+  }
+  if ((pType->GetKind() == kTypeByName) || (pType->GetKind() == kTypeClass) || (pType->GetKind() == kTypeInterface)) {
+    MIRStructType *classTypeSecond = static_cast<MIRStructType*>(pType);
+    classInfo = CLASSINFO_PREFIX_STR + classTypeSecond->GetName();
+  } else if ((pType->GetKind() == kTypeArray) || (pType->GetKind() == kTypeJArray)) {
+    MIRJarrayType *jarrayType = static_cast<MIRJarrayType*>(pType);
+    CHECK_FATAL(jarrayType != nullptr, "jarrayType is null in CGLowerer::LowerIntrinsicopWithType");
+    std::string baseName = jarrayType->GetJavaName();
+    if (jarrayType->IsPrimitiveArray() && (jarrayType->GetDim() <= kThreeDimArray)) {
+      classInfo = PRIMITIVECLASSINFO_PREFIX_STR + baseName;
+    } else if (arrayNameForLower::kArrayBaseName.find(baseName) != arrayNameForLower::kArrayBaseName.end()) {
+      classInfo = CLASSINFO_PREFIX_STR + baseName;
+    } else {
+      classInfoFromRt = true;
+      classInfo = baseName;
+    }
+  }
+}
+
+BaseNode *CGLowerer::GetBaseNodeFromCurFunc(MIRFunction &curFunc, bool isFromJarray) {
+  BaseNode *baseNode = nullptr;
+  if (curFunc.IsStatic()) {
+    /*
+     * it's a static function.
+     * pass caller functions's classinfo directly
+     */
+    std::string callerName = CLASSINFO_PREFIX_STR;
+    callerName += mirModule.CurFunction()->GetBaseClassName();
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(callerName);
+    MIRSymbol *callerClassInfoSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+    if (callerClassInfoSym == nullptr) {
+      if (isFromJarray) {
+        MIRType *mType = GlobalTables::GetTypeTable().GetVoidPtr();
+        CHECK_FATAL(mType != nullptr, "type is null in CGLowerer::LowerJarrayMalloc");
+        callerClassInfoSym = mirBuilder->CreateGlobalDecl(callerName.c_str(), *mType);
+        callerClassInfoSym->SetStorageClass(kScExtern);
+      } else {
+        callerClassInfoSym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+        callerClassInfoSym->SetNameStrIdx(strIdx);
+        callerClassInfoSym->SetStorageClass(kScGlobal);
+        callerClassInfoSym->SetSKind(kStVar);
+        /* it must be a local symbol */
+        GlobalTables::GetGsymTable().AddToStringSymbolMap(*callerClassInfoSym);
+        callerClassInfoSym->SetTyIdx(static_cast<TyIdx>(PTY_ptr));
+      }
+    }
+
+    baseNode = mirBuilder->CreateExprAddrof(0, *callerClassInfoSym);
+  } else {
+    /*
+     * it's an instance function.
+     * pass caller function's this pointer
+     */
+    CHECK_FATAL(curFunc.GetFormalCount() != 0, "index out of range in CGLowerer::GetBaseNodeFromCurFunc");
+    MIRSymbol *formalSt = curFunc.GetFormal(0);
+    if (formalSt->IsPreg()) {
+      if (isFromJarray) {
+        baseNode = mirBuilder->CreateExprRegread(formalSt->GetType()->GetPrimType(),
+            curFunc.GetPregTab()->GetPregIdxFromPregno(formalSt->GetPreg()->GetPregNo()));
+      } else {
+        CHECK_FATAL(curFunc.GetParamSize() != 0, "index out of range in CGLowerer::GetBaseNodeFromCurFunc");
+        baseNode = mirBuilder->CreateExprRegread((curFunc.GetNthParamType(0))->GetPrimType(),
+            curFunc.GetPregTab()->GetPregIdxFromPregno(formalSt->GetPreg()->GetPregNo()));
+      }
+    } else {
+      baseNode = mirBuilder->CreateExprDread(*formalSt);
+    }
+  }
+  return baseNode;
+}
+
+BaseNode *CGLowerer::GetClassInfoExprFromRuntime(const std::string &classInfo) {
+  /*
+   * generate runtime call to get class information
+   * jclass __mrt_getclass(jobject caller, const char *name)
+   * if the calling function is an instance function, it's the calling obj
+   * if the calling function is a static function, it's the calling class
+   */
+  BaseNode *classInfoExpr = nullptr;
+  PUIdx getClassFunc = GetBuiltinToUse(INTRN_JAVA_GET_CLASS);
+  CHECK_FATAL(getClassFunc != kFuncNotFound, "classfunc is not found");
+  /* return jclass */
+  MIRType *voidPtrType = GlobalTables::GetTypeTable().GetPtr();
+  MIRSymbol *ret0 = CreateNewRetVar(*voidPtrType, kIntrnRetValPrefix);
+
+  BaseNode *arg0 = GetBaseNodeFromCurFunc(*mirModule.CurFunction(), false);
+  BaseNode *arg1 = nullptr;
+  /* classname */
+  std::string klassJavaDescriptor;
+  namemangler::DecodeMapleNameToJavaDescriptor(classInfo, klassJavaDescriptor);
+  UStrIdx classNameStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(klassJavaDescriptor);
+  arg1 = mirModule.GetMemPool()->New<ConststrNode>(classNameStrIdx);
+  arg1->SetPrimType(PTY_ptr);
+
+  MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.emplace_back(arg0);
+  args.emplace_back(arg1);
+  StmtNode *getClassCall = mirBuilder->CreateStmtCallAssigned(getClassFunc, args, ret0, OP_callassigned);
+  currentBlock->AppendStatementsFromBlock(*LowerCallAssignedStmt(*getClassCall));
+  classInfoExpr = mirBuilder->CreateExprDread(*voidPtrType, 0, *ret0);
+  return classInfoExpr;
+}
+
+BaseNode *CGLowerer::GetClassInfoExprFromArrayClassCache(const std::string &classInfo) {
+  std::string klassJavaDescriptor;
+  namemangler::DecodeMapleNameToJavaDescriptor(classInfo, klassJavaDescriptor);
+  if (arrayClassCacheIndex.find(klassJavaDescriptor) == arrayClassCacheIndex.end()) {
+    return nullptr;
+  }
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(
+      namemangler::kArrayClassCacheTable + mirModule.GetFileNameAsPostfix());
+  MIRSymbol *arrayClassSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+  if (arrayClassSt == nullptr) {
+    return nullptr;
+  }
+  auto index = arrayClassCacheIndex[klassJavaDescriptor];
+#ifdef USE_32BIT_REF
+  const int32 width = 4;
+#else
+  const int32 width = 8;
+#endif  /* USE_32BIT_REF */
+  int64 offset = static_cast<int64>(index) * width;
+  ConstvalNode *offsetExpr = mirBuilder->CreateIntConst(static_cast<uint64>(offset), PTY_u32);
+  AddrofNode *baseExpr = mirBuilder->CreateExprAddrof(0, *arrayClassSt, mirModule.GetMemPool());
+  MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.emplace_back(baseExpr);
+  args.emplace_back(offsetExpr);
+  return mirBuilder->CreateExprIntrinsicop(INTRN_MPL_READ_ARRAYCLASS_CACHE_ENTRY, OP_intrinsicop,
+                                           *GlobalTables::GetTypeTable().GetPrimType(PTY_ref), args);
+}
+
+BaseNode *CGLowerer::GetClassInfoExpr(const std::string &classInfo) const {
+  BaseNode *classInfoExpr = nullptr;
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(classInfo);
+  MIRSymbol *classInfoSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+  if (classInfoSym != nullptr) {
+    classInfoExpr = mirBuilder->CreateExprAddrof(0, *classInfoSym);
+  } else {
+    classInfoSym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+    classInfoSym->SetNameStrIdx(strIdx);
+    classInfoSym->SetStorageClass(kScGlobal);
+    classInfoSym->SetSKind(kStVar);
+    if (CGOptions::IsPIC()) {
+      classInfoSym->SetStorageClass(kScExtern);
+    } else {
+      classInfoSym->SetAttr(ATTR_weak);
+    }
+    GlobalTables::GetGsymTable().AddToStringSymbolMap(*classInfoSym);
+    classInfoSym->SetTyIdx(static_cast<TyIdx>(PTY_ptr));
+
+    classInfoExpr = mirBuilder->CreateExprAddrof(0, *classInfoSym);
+  }
+  return classInfoExpr;
+}
+
+BaseNode *CGLowerer::LowerIntrinsicopWithType(const BaseNode &parent, IntrinsicopNode &intrinNode) {
+  BaseNode *resNode = &intrinNode;
+  if ((intrinNode.GetIntrinsic() == INTRN_JAVA_CONST_CLASS) || (intrinNode.GetIntrinsic() == INTRN_JAVA_INSTANCE_OF)) {
+    PUIdx bFunc = GetBuiltinToUse(intrinNode.GetIntrinsic());
+    CHECK_FATAL(bFunc != kFuncNotFound, "bFunc not founded");
+    MIRFunction *biFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(bFunc);
+    MIRType *classType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(intrinNode.GetTyIdx());
+    std::string classInfo;
+    BaseNode *classInfoExpr = nullptr;
+    bool classInfoFromRt = false;  /* whether the classinfo is generated by RT */
+    ProcessClassInfo(*classType, classInfoFromRt, classInfo);
+    if (classInfoFromRt) {
+      classInfoExpr = GetClassInfoExprFromArrayClassCache(classInfo);
+      if (classInfoExpr == nullptr) {
+        classInfoExpr = GetClassInfoExprFromRuntime(classInfo);
+      }
+    } else {
+      classInfoExpr = GetClassInfoExpr(classInfo);
+      LowerTypePtr(*classInfoExpr);
+    }
+
+    if (intrinNode.GetIntrinsic() == INTRN_JAVA_CONST_CLASS) {
+        CHECK_FATAL(classInfoExpr != nullptr, "classInfoExpr should not be nullptr");
+        if ((classInfoExpr->GetPrimType() == PTY_ptr) || (classInfoExpr->GetPrimType() == PTY_ref)) {
+          classInfoExpr->SetPrimType(GetLoweredPtrType());
+        }
+        resNode = classInfoExpr;
+        return resNode;
+      }
+
+    if (parent.GetOpCode() == OP_regassign) {
+      auto &regAssign = static_cast<const RegassignNode&>(parent);
+      StmtNode *biCall = CreateStmtCallWithReturnValue(intrinNode, regAssign.GetRegIdx(), bFunc, classInfoExpr);
+      currentBlock->AppendStatementsFromBlock(*LowerCallAssignedStmt(*biCall));
+      PrimType pTyp = GetCurrentFunc()->GetPregTab()->PregFromPregIdx(regAssign.GetRegIdx())->GetPrimType();
+      resNode = mirBuilder->CreateExprRegread(pTyp, regAssign.GetRegIdx());
+      return resNode;
+    }
+
+    if (parent.GetOpCode() == OP_dassign) {
+      auto &dassign = static_cast<const DassignNode&>(parent);
+      MIRSymbol *ret = GetCurrentFunc()->GetLocalOrGlobalSymbol(dassign.GetStIdx());
+      StmtNode *biCall = CreateStmtCallWithReturnValue(intrinNode, *ret, bFunc, classInfoExpr);
+      currentBlock->AppendStatementsFromBlock(*LowerCallAssignedStmt(*biCall));
+      resNode = mirBuilder->CreateExprDread(*biFunc->GetReturnType(), 0, *ret);
+      return resNode;
+    }
+    CHECK_FATAL(false, "should not run here");
+  }
+  CHECK_FATAL(false, "should not run here");
+  return resNode;
+}
+
+BaseNode *CGLowerer::LowerIntrinsicop(const BaseNode &parent, IntrinsicopNode &intrinNode, BlockNode &newBlk) {
+  for (size_t i = 0; i < intrinNode.GetNumOpnds(); ++i) {
+    intrinNode.SetOpnd(LowerExpr(intrinNode, *intrinNode.Opnd(i), newBlk), i);
+  }
+
+  MIRIntrinsicID intrnID = intrinNode.GetIntrinsic();
+  IntrinDesc &intrinDesc = IntrinDesc::intrinTable[intrnID];
+  if (intrinDesc.IsJS()) {
+    return LowerJavascriptIntrinsicop(intrinNode, intrinDesc);
+  }
+  if (intrinDesc.IsJava()) {
+    return LowerIntrinsicop(parent, intrinNode);
+  }
+  if (intrinNode.GetIntrinsic() == INTRN_MPL_READ_OVTABLE_ENTRY_LAZY) {
+    return &intrinNode;
+  }
+  if (intrinNode.GetIntrinsic() == INTRN_MPL_READ_ARRAYCLASS_CACHE_ENTRY) {
+    return &intrinNode;
+  }
+  if (intrnID == INTRN_C_constant_p) {
+    BaseNode *opnd = intrinNode.Opnd(0);
+    int64 val = (opnd->op == OP_constval || opnd->op == OP_sizeoftype ||
+                 opnd->op == OP_conststr || opnd->op == OP_conststr16) ? 1 : 0;
+    return mirModule.GetMIRBuilder()->CreateIntConst(static_cast<uint64>(val), PTY_i32);
+  }
+  if (intrnID == INTRN_C___builtin_expect) {
+    return intrinNode.Opnd(0);
+  }
+  if (intrinDesc.IsVectorOp() || intrinDesc.IsAtomic()) {
+    return &intrinNode;
+  }
+  CHECK_FATAL(false, "unexpected intrinsic type in CGLowerer::LowerIntrinsicop");
+  return &intrinNode;
+}
+
+BaseNode *CGLowerer::LowerIntrinsicopwithtype(const BaseNode &parent, IntrinsicopNode &intrinNode, BlockNode &blk) {
+  for (size_t i = 0; i < intrinNode.GetNumOpnds(); ++i) {
+    intrinNode.SetOpnd(LowerExpr(intrinNode, *intrinNode.Opnd(i), blk), i);
+  }
+  MIRIntrinsicID intrnID = intrinNode.GetIntrinsic();
+  IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrnID];
+  CHECK_FATAL(!intrinDesc->IsJS(), "intrinDesc should not be js");
+  if (intrinDesc->IsJava()) {
+    return LowerIntrinsicopWithType(parent, intrinNode);
+  }
+  CHECK_FATAL(false, "should not run here");
+  return &intrinNode;
+}
+
+StmtNode *CGLowerer::LowerIntrinsicMplClearStack(const IntrinsiccallNode &intrinCall, BlockNode &newBlk) {
+  StmtNode *newStmt = mirBuilder->CreateStmtIassign(
+      *beCommon.BeGetOrCreatePointerType(*GlobalTables::GetTypeTable().GetUInt8()), 0,
+      intrinCall.Opnd(0), mirBuilder->GetConstUInt8(0));
+  newBlk.AddStatement(newStmt);
+
+  BaseNode *length = intrinCall.Opnd(1);
+  PrimType pType = PTY_i64;
+  PregIdx pIdx = GetCurrentFunc()->GetPregTab()->CreatePreg(pType);
+  newStmt = mirBuilder->CreateStmtRegassign(pType, pIdx, mirBuilder->CreateIntConst(1, pType));
+  newBlk.AddStatement(newStmt);
+  MIRFunction *func = GetCurrentFunc();
+
+  const std::string &name = func->GetName() + std::string("_Lalloca_");
+  LabelIdx label1 = GetCurrentFunc()->GetOrCreateLableIdxFromName(name + std::to_string(labelIdx++));
+  LabelIdx label2 = GetCurrentFunc()->GetOrCreateLableIdxFromName(name + std::to_string(labelIdx++));
+
+  newStmt = mirBuilder->CreateStmtGoto(OP_goto, label2);
+  newBlk.AddStatement(newStmt);
+  LabelNode *ln = mirBuilder->CreateStmtLabel(label1);
+  newBlk.AddStatement(ln);
+
+  RegreadNode *regLen = mirBuilder->CreateExprRegread(pType, pIdx);
+
+  BinaryNode *addr = mirBuilder->CreateExprBinary(OP_add,
+                                                  *GlobalTables::GetTypeTable().GetAddr64(),
+                                                  intrinCall.Opnd(0), regLen);
+
+  newStmt = mirBuilder->CreateStmtIassign(*beCommon.BeGetOrCreatePointerType(*GlobalTables::GetTypeTable().GetUInt8()),
+                                          0, addr, mirBuilder->GetConstUInt8(0));
+  newBlk.AddStatement(newStmt);
+
+  BinaryNode *subLen = mirBuilder->CreateExprBinary(
+      OP_add, *GlobalTables::GetTypeTable().GetPrimType(pType), regLen, mirBuilder->CreateIntConst(1, pType));
+  newStmt = mirBuilder->CreateStmtRegassign(pType, pIdx, subLen);
+  newBlk.AddStatement(newStmt);
+
+  ln = mirBuilder->CreateStmtLabel(label2);
+  newBlk.AddStatement(ln);
+
+  CompareNode *cmpExp =
+      mirBuilder->CreateExprCompare(OP_lt, *GlobalTables::GetTypeTable().GetUInt32(),
+                                    *GlobalTables::GetTypeTable().GetPrimType(pType), regLen, length);
+  newStmt = mirBuilder->CreateStmtCondGoto(cmpExp, OP_brtrue, label1);
+
+  return newStmt;
+}
+
+StmtNode *CGLowerer::LowerIntrinsicRCCall(const IntrinsiccallNode &intrinCall) {
+  /* If GCONLY enabled, lowering RC intrinsics in another way. */
+  MIRIntrinsicID intrnID = intrinCall.GetIntrinsic();
+  IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrnID];
+
+  /* convert intrinsic call into function call. */
+  if (intrinFuncIDs.find(intrinDesc) == intrinFuncIDs.end()) {
+    /* add funcid into map */
+    MIRFunction *fn = mirBuilder->GetOrCreateFunction(intrinDesc->name, TyIdx(PTY_void));
+    fn->GetFuncSymbol()->SetAppearsInCode(true);
+    beCommon.UpdateTypeTable(*fn->GetMIRFuncType());
+    fn->AllocSymTab();
+    intrinFuncIDs[intrinDesc] = fn->GetPuidx();
+  }
+  CallNode *callStmt = mirModule.CurFuncCodeMemPool()->New<CallNode>(mirModule, OP_call);
+  callStmt->SetPUIdx(intrinFuncIDs.at(intrinDesc));
+  for (size_t i = 0; i < intrinCall.GetNopndSize(); ++i) {
+    (void)callStmt->GetNopnd().emplace_back(intrinCall.GetNopndAt(i));
+    callStmt->SetNumOpnds(callStmt->GetNumOpnds() + 1);
+  }
+  return callStmt;
+}
+
+void CGLowerer::LowerArrayStore(const IntrinsiccallNode &intrinCall, BlockNode &newBlk) {
+  bool needCheckStore = true;
+  BaseNode *arrayNode = intrinCall.Opnd(0);
+  MIRType *arrayElemType = GetArrayNodeType(*arrayNode);
+  BaseNode *valueNode = intrinCall.Opnd(kNodeThirdOpnd);
+  MIRType *valueRealType = GetArrayNodeType(*valueNode);
+  if ((arrayElemType != nullptr) && (valueRealType != nullptr) && (arrayElemType->GetKind() == kTypeClass) &&
+      static_cast<MIRClassType*>(arrayElemType)->IsFinal() && (valueRealType->GetKind() == kTypeClass) &&
+      static_cast<MIRClassType*>(valueRealType)->IsFinal() &&
+      (valueRealType->GetTypeIndex() == arrayElemType->GetTypeIndex())) {
+    needCheckStore = false;
+  }
+
+  if (needCheckStore) {
+    MIRFunction *fn = mirBuilder->GetOrCreateFunction("MCC_Reflect_Check_Arraystore", TyIdx(PTY_void));
+    fn->GetFuncSymbol()->SetAppearsInCode(true);
+    beCommon.UpdateTypeTable(*fn->GetMIRFuncType());
+    fn->AllocSymTab();
+    MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    (void)args.emplace_back(intrinCall.Opnd(0));
+    (void)args.emplace_back(intrinCall.Opnd(kNodeThirdOpnd));
+    StmtNode *checkStoreStmt = mirBuilder->CreateStmtCall(fn->GetPuidx(), args);
+    newBlk.AddStatement(checkStoreStmt);
+  }
+}
+
+StmtNode *CGLowerer::LowerDefaultIntrinsicCall(IntrinsiccallNode &intrinCall, MIRSymbol &st, MIRFunction &fn) {
+  MIRIntrinsicID intrnID = intrinCall.GetIntrinsic();
+  IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrnID];
+  std::vector<TyIdx> funcTyVec;
+  std::vector<TypeAttrs> fnTaVec;
+  MapleVector<BaseNode*> &nOpnds = intrinCall.GetNopnd();
+  MIRType *retTy = intrinDesc->GetReturnType();
+  CHECK_FATAL(retTy != nullptr, "retTy should not be nullptr");
+  if (retTy->GetKind() == kTypeStruct) {
+    funcTyVec.emplace_back(beCommon.BeGetOrCreatePointerType(*retTy)->GetTypeIndex());
+    fnTaVec.emplace_back(TypeAttrs());
+    fn.SetReturnStruct();
+  }
+  for (uint32 i = 0; i < nOpnds.size(); ++i) {
+    MIRType *argTy = intrinDesc->GetArgType(i);
+    CHECK_FATAL(argTy != nullptr, "argTy should not be nullptr");
+    if (argTy->GetKind() == kTypeStruct) {
+      funcTyVec.emplace_back(GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_a32)->GetTypeIndex());
+      fnTaVec.emplace_back(TypeAttrs());
+      BaseNode *addrNode = beCommon.GetAddressOfNode(*nOpnds[i]);
+      CHECK_FATAL(addrNode != nullptr, "can not get address");
+      nOpnds[i] = addrNode;
+    } else {
+      funcTyVec.emplace_back(argTy->GetTypeIndex());
+      fnTaVec.emplace_back(TypeAttrs());
+    }
+  }
+  MIRType *funcType = beCommon.BeGetOrCreateFunctionType(retTy->GetTypeIndex(), funcTyVec, fnTaVec);
+  st.SetTyIdx(funcType->GetTypeIndex());
+  fn.SetMIRFuncType(static_cast<MIRFuncType*>(funcType));
+  if (retTy->GetKind() == kTypeStruct) {
+    fn.SetReturnTyIdx(static_cast<TyIdx>(PTY_void));
+  } else {
+    fn.SetReturnTyIdx(retTy->GetTypeIndex());
+  }
+  return static_cast<CallNode*>(mirBuilder->CreateStmtCall(fn.GetPuidx(), nOpnds));
+}
+
+StmtNode *CGLowerer::LowerIntrinsicMplCleanupLocalRefVarsSkip(IntrinsiccallNode &intrinCall) {
+  MIRFunction *mirFunc = mirModule.CurFunction();
+  BaseNode *skipExpr = intrinCall.Opnd(intrinCall.NumOpnds() - 1);
+
+  CHECK_FATAL(skipExpr != nullptr, "should be dread");
+  CHECK_FATAL(skipExpr->GetOpCode() == OP_dread, "should be dread");
+  DreadNode *refNode = static_cast<DreadNode*>(skipExpr);
+  MIRSymbol *skipSym = mirFunc->GetLocalOrGlobalSymbol(refNode->GetStIdx());
+  if (skipSym->GetAttr(ATTR_localrefvar)) {
+    mirFunc->InsertMIRSymbol(skipSym);
+  }
+  return &intrinCall;
+}
+
+StmtNode *CGLowerer::LowerIntrinsiccall(IntrinsiccallNode &intrinCall, BlockNode &newBlk) {
+  MIRIntrinsicID intrnID = intrinCall.GetIntrinsic();
+  for (size_t i = 0; i < intrinCall.GetNumOpnds(); ++i) {
+    intrinCall.SetOpnd(LowerExpr(intrinCall, *intrinCall.Opnd(i), newBlk), i);
+  }
+  if (intrnID == INTRN_MPL_CLEAR_STACK) {
+    return LowerIntrinsicMplClearStack(intrinCall, newBlk);
+  }
+  if (intrnID == INTRN_C_va_start) {
+    return &intrinCall;
+  }
+  IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrnID];
+  if (intrinDesc->IsSpecial() || intrinDesc->IsAtomic()) {
+    /* For special intrinsics we leave them to CGFunc::SelectintrinCall() */
+    return &intrinCall;
+  }
+  /* default lowers intrinsic call to real function call. */
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  CHECK_FATAL(intrinDesc->name != nullptr, "intrinsic's name should not be nullptr");
+  const std::string name = intrinDesc->name;
+  st->SetNameStrIdx(name);
+  st->SetStorageClass(kScText);
+  st->SetSKind(kStFunc);
+  MIRFunction *fn = mirBuilder->GetOrCreateFunction(intrinDesc->name, TyIdx(0));
+  beCommon.UpdateTypeTable(*fn->GetMIRFuncType());
+  fn->AllocSymTab();
+  st->SetFunction(fn);
+  st->SetAppearsInCode(true);
+  return LowerDefaultIntrinsicCall(intrinCall, *st, *fn);
+}
+
+StmtNode *CGLowerer::LowerSyncEnterSyncExit(StmtNode &stmt) {
+  CHECK_FATAL(stmt.GetOpCode() == OP_syncenter || stmt.GetOpCode() == OP_syncexit,
+              "stmt's opcode should be OP_syncenter or OP_syncexit");
+
+  auto &nStmt = static_cast<NaryStmtNode&>(stmt);
+  BuiltinFunctionID id;
+  if (nStmt.GetOpCode() == OP_syncenter) {
+    if (nStmt.NumOpnds() == 1) {
+      /* Just as ParseNaryStmt do for syncenter */
+      MIRType &intType = *GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_i32));
+      /* default 2 for __sync_enter_fast() */
+      MIRIntConst *intConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(2, intType);
+      ConstvalNode *exprConst = mirModule.GetMemPool()->New<ConstvalNode>();
+      exprConst->SetPrimType(PTY_i32);
+      exprConst->SetConstVal(intConst);
+      nStmt.GetNopnd().emplace_back(exprConst);
+      nStmt.SetNumOpnds(nStmt.GetNopndSize());
+    }
+    CHECK_FATAL(nStmt.NumOpnds() == kOperandNumBinary, "wrong args for syncenter");
+    CHECK_FATAL(nStmt.Opnd(1)->GetOpCode() == OP_constval, "wrong 2nd arg type for syncenter");
+    ConstvalNode *cst = static_cast<ConstvalNode*>(nStmt.GetNopndAt(1));
+    MIRIntConst *intConst = safe_cast<MIRIntConst>(cst->GetConstVal());
+    switch (intConst->GetExtValue()) {
+      case kMCCSyncEnterFast0:
+        id = INTRN_FIRST_SYNC_ENTER;
+        break;
+      case kMCCSyncEnterFast1:
+        id = INTRN_SECOND_SYNC_ENTER;
+        break;
+      case kMCCSyncEnterFast2:
+        id = INTRN_THIRD_SYNC_ENTER;
+        break;
+      case kMCCSyncEnterFast3:
+        id = INTRN_FOURTH_SYNC_ENTER;
+        break;
+      default:
+        CHECK_FATAL(false, "wrong kind for syncenter");
+        break;
+    }
+  } else {
+    CHECK_FATAL(nStmt.NumOpnds() == 1, "wrong args for syncexit");
+    id = INTRN_YNC_EXIT;
+  }
+  PUIdx bFunc = GetBuiltinToUse(id);
+  CHECK_FATAL(bFunc != kFuncNotFound, "bFunc should be found");
+
+  MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.emplace_back(nStmt.Opnd(0));
+  return mirBuilder->CreateStmtCall(bFunc, args);
+}
+
+PUIdx CGLowerer::GetBuiltinToUse(BuiltinFunctionID id) const {
+  /*
+   * use std::vector & linear search as the number of entries is small.
+   * we may revisit it if the number of entries gets larger.
+   */
+  for (const auto &funcID : builtinFuncIDs) {
+    if (funcID.first == id) {
+      return funcID.second;
+    }
+  }
+  return kFuncNotFound;
+}
+
+void CGLowerer::LowerGCMalloc(const BaseNode &node, const GCMallocNode &gcmalloc, BlockNode &blkNode, bool perm) {
+  MIRFunction *func = mirBuilder->GetOrCreateFunction((perm ? "MCC_NewPermanentObject" : "MCC_NewObj_fixed_class"),
+                                                      static_cast<TyIdx>(GetLoweredPtrType()));
+  func->GetFuncSymbol()->SetAppearsInCode(true);
+  beCommon.UpdateTypeTable(*func->GetMIRFuncType());
+  func->AllocSymTab();
+  /* Get the classinfo */
+  MIRStructType *classType = static_cast<MIRStructType*>(
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(gcmalloc.GetTyIdx()));
+  std::string classInfoName = CLASSINFO_PREFIX_STR + classType->GetName();
+  MIRSymbol *classSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetStrIdxFromName(classInfoName));
+  if (classSym == nullptr) {
+    MIRType *pointerType = beCommon.BeGetOrCreatePointerType(*GlobalTables::GetTypeTable().GetVoid());
+    classSym = mirBuilder->CreateGlobalDecl(classInfoName, *pointerType);
+    classSym->SetStorageClass(kScExtern);
+  }
+  CallNode *callAssign = nullptr;
+  auto *curFunc = mirModule.CurFunction();
+  if (classSym->GetAttr(ATTR_abstract) || classSym->GetAttr(ATTR_interface)) {
+    MIRFunction *funcSecond = mirBuilder->GetOrCreateFunction("MCC_Reflect_ThrowInstantiationError",
+                                                              static_cast<TyIdx>(GetLoweredPtrType()));
+    funcSecond->GetFuncSymbol()->SetAppearsInCode(true);
+    beCommon.UpdateTypeTable(*funcSecond->GetMIRFuncType());
+    funcSecond->AllocSymTab();
+    BaseNode *arg = mirBuilder->CreateExprAddrof(0, *classSym);
+    if (node.GetOpCode() == OP_dassign) {
+      auto &dsNode = static_cast<const DassignNode&>(node);
+      MIRSymbol *ret = curFunc->GetLocalOrGlobalSymbol(dsNode.GetStIdx());
+      MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+      args.emplace_back(arg);
+      callAssign = mirBuilder->CreateStmtCallAssigned(funcSecond->GetPuidx(), args, ret, OP_callassigned);
+    } else {
+      CHECK_FATAL(node.GetOpCode() == OP_regassign, "regassign expected");
+      callAssign = mirBuilder->CreateStmtCallRegassigned(
+          funcSecond->GetPuidx(), static_cast<const RegassignNode&>(node).GetRegIdx(), OP_callassigned, arg);
+    }
+    blkNode.AppendStatementsFromBlock(*LowerCallAssignedStmt(*callAssign));
+    return;
+  }
+  BaseNode *arg = mirBuilder->CreateExprAddrof(0, *classSym);
+
+  if (node.GetOpCode() == OP_dassign) {
+    MIRSymbol *ret = curFunc->GetLocalOrGlobalSymbol(static_cast<const DassignNode&>(node).GetStIdx());
+    MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    args.emplace_back(arg);
+    callAssign = mirBuilder->CreateStmtCallAssigned(func->GetPuidx(), args, ret, OP_callassigned);
+  } else {
+    CHECK_FATAL(node.GetOpCode() == OP_regassign, "regassign expected");
+    callAssign = mirBuilder->CreateStmtCallRegassigned(
+        func->GetPuidx(), static_cast<const RegassignNode&>(node).GetRegIdx(), OP_callassigned, arg);
+  }
+  blkNode.AppendStatementsFromBlock(*LowerCallAssignedStmt(*callAssign));
+}
+
+std::string CGLowerer::GetNewArrayFuncName(const uint32 elemSize, const bool perm) const {
+  if (elemSize == 1) {
+    return perm ? "MCC_NewPermArray8" : "MCC_NewArray8";
+  }
+  if (elemSize == 2) {
+    return perm ? "MCC_NewPermArray16" : "MCC_NewArray16";
+  }
+  if (elemSize == 4) {
+    return perm ? "MCC_NewPermArray32" : "MCC_NewArray32";
+  }
+  CHECK_FATAL((elemSize == 8), "Invalid elemSize.");
+  return perm ? "MCC_NewPermArray64" : "MCC_NewArray64";
+}
+
+void CGLowerer::LowerJarrayMalloc(const StmtNode &stmt, const JarrayMallocNode &node, BlockNode &blkNode, bool perm) {
+  /* Extract jarray type */
+  TyIdx tyIdx = node.GetTyIdx();
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  CHECK_FATAL(type->GetKind() == kTypeJArray, "Type param of gcmallocjarray is not a MIRJarrayType");
+  auto jaryType = static_cast<MIRJarrayType*>(type);
+  CHECK_FATAL(jaryType != nullptr, "Type param of gcmallocjarray is not a MIRJarrayType");
+
+  /* Inspect element type */
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(jaryType->GetElemTyIdx());
+  PrimType elemPrimType = elemType->GetPrimType();
+  uint32 elemSize = GetPrimTypeSize(elemPrimType);
+  if (elemType->GetKind() != kTypeScalar) {  /* element is reference */
+    elemSize = static_cast<uint32>(RTSupport::GetRTSupportInstance().GetFieldSize());
+  }
+
+  std::string klassName = jaryType->GetJavaName();
+  std::string arrayClassInfoName;
+  bool isPredefinedArrayClass = false;
+  BaseNode *arrayCacheNode = nullptr;
+  if (jaryType->IsPrimitiveArray() && (jaryType->GetDim() <= kThreeDimArray)) {
+    arrayClassInfoName = PRIMITIVECLASSINFO_PREFIX_STR + klassName;
+    isPredefinedArrayClass = true;
+  } else if (arrayNameForLower::kArrayKlassName.find(klassName) != arrayNameForLower::kArrayKlassName.end()) {
+    arrayClassInfoName = CLASSINFO_PREFIX_STR + klassName;
+    isPredefinedArrayClass = true;
+  } else {
+    arrayCacheNode = GetClassInfoExprFromArrayClassCache(klassName);
+  }
+
+  std::string funcName;
+  MapleVector<BaseNode*> args(mirModule.GetMPAllocator().Adapter());
+  auto *curFunc = mirModule.CurFunction();
+  if (isPredefinedArrayClass || (arrayCacheNode != nullptr)) {
+    funcName = GetNewArrayFuncName(elemSize, perm);
+    args.emplace_back(node.Opnd(0));                                   /* n_elems */
+    if (isPredefinedArrayClass) {
+      GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(arrayClassInfoName);
+      MIRSymbol *arrayClassSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+          GlobalTables::GetStrTable().GetStrIdxFromName(arrayClassInfoName));
+      if (arrayClassSym == nullptr) {
+        arrayClassSym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+        arrayClassSym->SetNameStrIdx(strIdx);
+        arrayClassSym->SetStorageClass(kScGlobal);
+        arrayClassSym->SetSKind(kStVar);
+        if (CGOptions::IsPIC()) {
+          arrayClassSym->SetStorageClass(kScExtern);
+        } else {
+          arrayClassSym->SetAttr(ATTR_weak);
+        }
+        GlobalTables::GetGsymTable().AddToStringSymbolMap(*arrayClassSym);
+        arrayClassSym->SetTyIdx(static_cast<TyIdx>(PTY_ptr));
+      }
+      args.emplace_back(mirBuilder->CreateExprAddrof(0, *arrayClassSym));
+    } else {
+      args.emplace_back(arrayCacheNode);
+    }
+  } else {
+    funcName = perm ? "MCC_NewPermanentArray" : "MCC_NewObj_flexible_cname";
+    args.emplace_back(mirBuilder->CreateIntConst(elemSize, PTY_u32));  /* elem_size */
+    args.emplace_back(node.Opnd(0));                                   /* n_elems */
+    std::string klassJavaDescriptor;
+    namemangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
+    UStrIdx classNameStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(klassJavaDescriptor);
+    ConststrNode *classNameExpr = mirModule.GetMemPool()->New<ConststrNode>(classNameStrIdx);
+    classNameExpr->SetPrimType(PTY_ptr);
+    args.emplace_back(classNameExpr);  /* class_name */
+    args.emplace_back(GetBaseNodeFromCurFunc(*curFunc, true));
+    /* set class flag 0 */
+    args.emplace_back(mirBuilder->CreateIntConst(0, PTY_u32));
+  }
+  MIRFunction *func = mirBuilder->GetOrCreateFunction(funcName, static_cast<TyIdx>(GetLoweredPtrType()));
+  func->GetFuncSymbol()->SetAppearsInCode(true);
+  beCommon.UpdateTypeTable(*func->GetMIRFuncType());
+  func->AllocSymTab();
+  CallNode *callAssign = nullptr;
+  if (stmt.GetOpCode() == OP_dassign) {
+    auto &dsNode = static_cast<const DassignNode&>(stmt);
+    MIRSymbol *ret = curFunc->GetLocalOrGlobalSymbol(dsNode.GetStIdx());
+
+    callAssign = mirBuilder->CreateStmtCallAssigned(func->GetPuidx(), args, ret, OP_callassigned);
+  } else {
+    auto &regNode = static_cast<const RegassignNode&>(stmt);
+    callAssign = mirBuilder->CreateStmtCallRegassigned(func->GetPuidx(), args, regNode.GetRegIdx(), OP_callassigned);
+  }
+  blkNode.AppendStatementsFromBlock(*LowerCallAssignedStmt(*callAssign));
+}
+
+bool CGLowerer::IsIntrinsicCallHandledAtLowerLevel(MIRIntrinsicID intrinsic) const {
+  /* only INTRN_MPL_ATOMIC_EXCHANGE_PTR now. */
+  return intrinsic == INTRN_MPL_ATOMIC_EXCHANGE_PTR;
+}
+
+bool CGLowerer::IsIntrinsicOpHandledAtLowerLevel(MIRIntrinsicID intrinsic) const {
+  switch (intrinsic) {
+#if TARGAARCH64 || TARGX86_64
+    case INTRN_C_bswap64:
+    case INTRN_C_bswap32:
+    case INTRN_C_bswap16:
+    case INTRN_C_cos:
+    case INTRN_C_cosf:
+    case INTRN_C_cosh:
+    case INTRN_C_coshf:
+    case INTRN_C_acos:
+    case INTRN_C_acosf:
+    case INTRN_C_sin:
+    case INTRN_C_sinf:
+    case INTRN_C_sinh:
+    case INTRN_C_sinhf:
+    case INTRN_C_asin:
+    case INTRN_C_asinf:
+    case INTRN_C_atan:
+    case INTRN_C_atanf:
+    case INTRN_C_exp:
+    case INTRN_C_expf:
+    case INTRN_C_ffs:
+    case INTRN_C_log:
+    case INTRN_C_logf:
+    case INTRN_C_log10:
+    case INTRN_C_log10f:
+    case INTRN_C_clz32:
+    case INTRN_C_clz64:
+    case INTRN_C_ctz32:
+    case INTRN_C_ctz64:
+    case INTRN_C_popcount32:
+    case INTRN_C_popcount64:
+    case INTRN_C_parity32:
+    case INTRN_C_parity64:
+    case INTRN_C_clrsb32:
+    case INTRN_C_clrsb64:
+    case INTRN_C_isaligned:
+    case INTRN_C_alignup:
+    case INTRN_C_aligndown:
+    case INTRN_C___sync_add_and_fetch_1:
+    case INTRN_C___sync_add_and_fetch_2:
+    case INTRN_C___sync_add_and_fetch_4:
+    case INTRN_C___sync_add_and_fetch_8:
+    case INTRN_C___sync_sub_and_fetch_1:
+    case INTRN_C___sync_sub_and_fetch_2:
+    case INTRN_C___sync_sub_and_fetch_4:
+    case INTRN_C___sync_sub_and_fetch_8:
+    case INTRN_C___sync_fetch_and_add_1:
+    case INTRN_C___sync_fetch_and_add_2:
+    case INTRN_C___sync_fetch_and_add_4:
+    case INTRN_C___sync_fetch_and_add_8:
+    case INTRN_C___sync_fetch_and_sub_1:
+    case INTRN_C___sync_fetch_and_sub_2:
+    case INTRN_C___sync_fetch_and_sub_4:
+    case INTRN_C___sync_fetch_and_sub_8:
+    case INTRN_C___sync_bool_compare_and_swap_1:
+    case INTRN_C___sync_bool_compare_and_swap_2:
+    case INTRN_C___sync_bool_compare_and_swap_4:
+    case INTRN_C___sync_bool_compare_and_swap_8:
+    case INTRN_C___sync_val_compare_and_swap_1:
+    case INTRN_C___sync_val_compare_and_swap_2:
+    case INTRN_C___sync_val_compare_and_swap_4:
+    case INTRN_C___sync_val_compare_and_swap_8:
+    case INTRN_C___sync_lock_test_and_set_1:
+    case INTRN_C___sync_lock_test_and_set_2:
+    case INTRN_C___sync_lock_test_and_set_4:
+    case INTRN_C___sync_lock_test_and_set_8:
+    case INTRN_C___sync_lock_release_8:
+    case INTRN_C___sync_lock_release_4:
+    case INTRN_C___sync_lock_release_2:
+    case INTRN_C___sync_lock_release_1:
+    case INTRN_C___sync_fetch_and_and_1:
+    case INTRN_C___sync_fetch_and_and_2:
+    case INTRN_C___sync_fetch_and_and_4:
+    case INTRN_C___sync_fetch_and_and_8:
+    case INTRN_C___sync_fetch_and_or_1:
+    case INTRN_C___sync_fetch_and_or_2:
+    case INTRN_C___sync_fetch_and_or_4:
+    case INTRN_C___sync_fetch_and_or_8:
+    case INTRN_C___sync_fetch_and_xor_1:
+    case INTRN_C___sync_fetch_and_xor_2:
+    case INTRN_C___sync_fetch_and_xor_4:
+    case INTRN_C___sync_fetch_and_xor_8:
+    case INTRN_C___sync_fetch_and_nand_1:
+    case INTRN_C___sync_fetch_and_nand_2:
+    case INTRN_C___sync_fetch_and_nand_4:
+    case INTRN_C___sync_fetch_and_nand_8:
+    case INTRN_C___sync_and_and_fetch_1:
+    case INTRN_C___sync_and_and_fetch_2:
+    case INTRN_C___sync_and_and_fetch_4:
+    case INTRN_C___sync_and_and_fetch_8:
+    case INTRN_C___sync_or_and_fetch_1:
+    case INTRN_C___sync_or_and_fetch_2:
+    case INTRN_C___sync_or_and_fetch_4:
+    case INTRN_C___sync_or_and_fetch_8:
+    case INTRN_C___sync_xor_and_fetch_1:
+    case INTRN_C___sync_xor_and_fetch_2:
+    case INTRN_C___sync_xor_and_fetch_4:
+    case INTRN_C___sync_xor_and_fetch_8:
+    case INTRN_C___sync_nand_and_fetch_1:
+    case INTRN_C___sync_nand_and_fetch_2:
+    case INTRN_C___sync_nand_and_fetch_4:
+    case INTRN_C___sync_nand_and_fetch_8:
+    case INTRN_C___sync_synchronize:
+    case INTRN_C__builtin_return_address:
+    case INTRN_C__builtin_extract_return_addr:
+    case INTRN_C_memcmp:
+    case INTRN_C_strlen:
+    case INTRN_C_strcmp:
+    case INTRN_C_strncmp:
+    case INTRN_C_strchr:
+    case INTRN_C_strrchr:
+    case INTRN_C_rev16_2:
+    case INTRN_C_rev_4:
+    case INTRN_C_rev_8:
+    case INTRN_C_stack_save:
+    case INTRN_C_stack_restore:
+      return true;
+#endif
+    default:
+      return false;
+  }
+}
+
+void CGLowerer::InitArrayClassCacheTableIndex() {
+  MIRSymbol *reflectStrtabSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::kReflectionStrtabPrefixStr + mirModule.GetFileNameAsPostfix()));
+  MIRSymbol *reflectStartHotStrtabSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::kReflectionStartHotStrtabPrefixStr + mirModule.GetFileNameAsPostfix()));
+  MIRSymbol *reflectBothHotStrtabSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::kReflectionBothHotStrTabPrefixStr + mirModule.GetFileNameAsPostfix()));
+  MIRSymbol *reflectRunHotStrtabSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::kReflectionRunHotStrtabPrefixStr + mirModule.GetFileNameAsPostfix()));
+  MIRSymbol *arrayCacheNameTableSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::kArrayClassCacheNameTable + mirModule.GetFileNameAsPostfix()));
+  if (arrayCacheNameTableSym == nullptr) {
+    return;
+  }
+  MIRAggConst &aggConst = static_cast<MIRAggConst&>(*(arrayCacheNameTableSym->GetKonst()));
+  MIRSymbol *strTab = nullptr;
+  for (size_t i = 0; i < aggConst.GetConstVec().size(); ++i) {
+    MIRConst *elemConst = aggConst.GetConstVecItem(i);
+    uint32 intValue = static_cast<uint32>(
+        static_cast<uint64>((safe_cast<MIRIntConst>(elemConst))->GetExtValue()) & 0xFFFFFFFF);
+    bool isHotReflectStr = (intValue & 0x00000003) != 0;     /* use the last two bits of intValue in this expression */
+    if (isHotReflectStr) {
+      uint32 tag = (intValue & 0x00000003) - kCStringShift;  /* use the last two bits of intValue in this expression */
+      if (tag == kLayoutBootHot) {
+        strTab = reflectStartHotStrtabSym;
+      } else if (tag == kLayoutBothHot) {
+        strTab = reflectBothHotStrtabSym;
+      } else {
+        strTab = reflectRunHotStrtabSym;
+      }
+    } else {
+      strTab = reflectStrtabSym;
+    }
+    ASSERT(strTab != nullptr, "strTab is nullptr");
+    std::string arrayClassName;
+    MIRAggConst *strAgg = static_cast<MIRAggConst*>(strTab->GetKonst());
+    for (auto start = (intValue >> 2); start < strAgg->GetConstVec().size(); ++start) { /* the last two bits is flag */
+      MIRIntConst *oneChar = static_cast<MIRIntConst*>(strAgg->GetConstVecItem(start));
+      if ((oneChar != nullptr) && !oneChar->IsZero()) {
+        arrayClassName += static_cast<char>(oneChar->GetExtValue());
+      } else {
+        break;
+      }
+    }
+    arrayClassCacheIndex[arrayClassName] = i;
+  }
+}
+
+void CGLowerer::BuildLabel2FreqMap() {
+  StmtNodes stmtNodes = GetCurrentFunc()->GetBody()->GetStmtNodes();
+  FuncProfInfo* funcProfile = mirModule.CurFunction()->GetFuncProfData();
+  if (Options::profileUse && (funcProfile != nullptr)) {
+    for (StmtNode& stmt : stmtNodes) {
+      if (stmt.GetOpCode() == OP_label) {
+        l2fMap[static_cast<LabelNode&>(stmt).GetLabelIdx()] = funcProfile->GetStmtFreq(stmt.GetStmtID());
+      }
+    }
+  }
+}
+
+void CGLowerer::LowerFunc(MIRFunction &func) {
+  labelIdx = 0;
+  SetCurrentFunc(&func);
+  hasTry = false;
+  LowerEntry(func);
+  LowerPseudoRegs(func);
+  BuildLabel2FreqMap();
+  BlockNode *origBody = func.GetBody();
+  CHECK_FATAL(origBody != nullptr, "origBody should not be nullptr");
+
+  BlockNode *newBody = LowerBlock(*origBody);
+  func.SetBody(newBody);
+  if (needBranchCleanup) {
+    CleanupBranches(func);
+  }
+
+  if (mirModule.IsJavaModule() && func.GetBody()->GetFirst() && GenerateExceptionHandlingCode()) {
+    LowerTryCatchBlocks(*func.GetBody());
+  }
+  uint32 oldTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  // We do the simplify work here because now all the intrinsic calls and potential expansion work of memcpy or other
+  // functions are handled well. So we can concentrate to do the replacement work.
+  SimplifyBlock(*newBody);
+  uint32 newTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  if (newTypeTableSize != oldTypeTableSize) {
+    beCommon.AddNewTypeAfterBecommon(oldTypeTableSize, newTypeTableSize);
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/be/rt.cpp b/src/mapleall/maple_be/src/be/rt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5a14d9cf52f0f503d90320fb332e62b9bd62bc8a
--- /dev/null
+++ b/src/mapleall/maple_be/src/be/rt.cpp
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "rt.h"
+
+namespace maplebe {
+const std::string RTSupport::kObjectMapSectionName = ".maple.objectmap";
+const std::string RTSupport::kGctibLabelArrayOfObject = "MCC_GCTIB___ArrayOfObject";
+const std::string RTSupport::kGctibLabelJavaObject = "MCC_GCTIB__Ljava_2Flang_2FObject_3B";
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/be/switch_lowerer.cpp b/src/mapleall/maple_be/src/be/switch_lowerer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d361660d445046a1715626d0b0096906183d57a1
--- /dev/null
+++ b/src/mapleall/maple_be/src/be/switch_lowerer.cpp
@@ -0,0 +1,404 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+/*
+ * This module analyzes the tag distribution in a switch statement and decides
+ * the best strategy in terms of runtime performance to generate code for it.
+ * The generated code makes use of 3 code generation techniques:
+ *
+ * 1. cascade of if-then-else based on equality test
+ * 2. rangegoto
+ * 3. binary search
+ *
+ * 1 is applied only if the number of possibilities is <= 6.
+ * 2 corresponds to indexed jump, but it requires allocating an array
+ * initialized with the jump targets.  Since it causes memory usage overhead,
+ * rangegoto is used only if the density is higher than 0.7.
+ * If neither 1 nor 2 is applicable, 3 is applied in the form of a decision
+ * tree.  In this case, each test would split the tags into 2 halves.  For
+ * each half, the above algorithm is then applied recursively until the
+ * algorithm terminates.
+ *
+ * But we don't want to apply 3 right from the beginning if both 1 and 2 do not
+ * apply, because there may be regions that have density > 0.7.  Thus, the
+ * switch lowerer begins by finding clusters.  A cluster is defined to be a
+ * maximal range of tags whose density is > 0.7.
+ *
+ * In finding clusters, the original switch table is sorted and then each dense
+ * region is condensed into 1 switch item; in the switch_items table, each item // either corresponds to an original
+ * entry in the original switch table (pair's // second is 0), or to a dense region (pair's second gives the upper limit
+ * of the dense range).  The output code is generated based on the switch_items. See BuildCodeForSwitchItems() which is
+ * recursive.
+*/
+#include "switch_lowerer.h"
+#include "mir_nodes.h"
+#include "mir_builder.h"
+#include "mir_lower.h"  /* "../../../maple_ir/include/mir_lower.h" */
+
+namespace maplebe {
+static bool CasePairKeyLessThan(const CasePair &left, const CasePair &right) {
+  return left.first < right.first;
+}
+
+void SwitchLowerer::FindClusters(MapleVector<Cluster> &clusters) const {
+  int32 length = static_cast<int>(stmt->GetSwitchTable().size());
+  int32 i = 0;
+  while (i < length - kClusterSwitchCutoff) {
+    for (int32 j = length - 1; j > i; --j) {
+      float tmp1 = static_cast<float>(j - i);
+      float tmp2 = static_cast<float>(stmt->GetCasePair(static_cast<size_t>(static_cast<uint>(j))).first) -
+                   static_cast<float>(stmt->GetCasePair(static_cast<size_t>(static_cast<uint>(i))).first);
+      float currDensity = tmp1 / tmp2;
+      if (((j - i) >= kClusterSwitchCutoff) &&
+          ((currDensity >= kClusterSwitchDensityHigh) ||
+           ((currDensity >= kClusterSwitchDensityLow) && (tmp2 < kMaxRangeGotoTableSize)))) {
+        clusters.emplace_back(Cluster(i, j));
+        i = j;
+        break;
+      }
+    }
+    ++i;
+  }
+}
+
+void SwitchLowerer::InitSwitchItems(MapleVector<Cluster> &clusters) {
+  if (clusters.empty()) {
+    for (int32 i = 0; i < static_cast<int>(stmt->GetSwitchTable().size()); ++i) {
+      switchItems.emplace_back(SwitchItem(i, 0));
+    }
+  } else {
+    int32 j = 0;
+    Cluster front = clusters[j];
+    for (int32 i = 0; i < static_cast<int>(stmt->GetSwitchTable().size()); ++i) {
+      if (i == front.first) {
+        switchItems.emplace_back(SwitchItem(i, front.second));
+        i = front.second;
+        ++j;
+        if (static_cast<int>(clusters.size()) > j) {
+          front = clusters[j];
+        }
+      } else {
+        switchItems.emplace_back(SwitchItem(i, 0));
+      }
+    }
+  }
+}
+
+RangeGotoNode *SwitchLowerer::BuildRangeGotoNode(int32 startIdx, int32 endIdx, LabelIdx newLabelIdx) {
+  RangeGotoNode *node = mirModule.CurFuncCodeMemPool()->New<RangeGotoNode>(mirModule);
+  node->SetOpnd(stmt->GetSwitchOpnd(), 0);
+
+  node->SetRangeGotoTable(SmallCaseVector(mirModule.CurFuncCodeMemPoolAllocator()->Adapter()));
+  node->SetTagOffset(static_cast<int32>(stmt->GetCasePair(static_cast<size_t>(startIdx)).first));
+  uint32 curTag = 0;
+  node->AddRangeGoto(curTag, stmt->GetCasePair(startIdx).second);
+  int64 lastCaseTag = stmt->GetSwitchTable().at(startIdx).first;
+  for (int32 i = startIdx + 1; i <= endIdx; ++i) {
+    /*
+     * The second condition is to solve the problem that compilation falls into a dead loop,
+     * because in some cases the two will fall into a dead loop if they are equal.
+     */
+    while ((stmt->GetCasePair(i).first != (lastCaseTag + 1)) && (stmt->GetCasePair(i).first != lastCaseTag)) {
+      /* fill in a gap in the case tags */
+      curTag = static_cast<uint32>(static_cast<int32>(++lastCaseTag) - node->GetTagOffset());
+      if (stmt->GetDefaultLabel() != 0) {
+        node->AddRangeGoto(curTag, stmt->GetDefaultLabel());
+      } else if (newLabelIdx != 0) {
+        node->AddRangeGoto(curTag, newLabelIdx);
+      }
+    }
+    curTag = static_cast<uint32>(stmt->GetCasePair(static_cast<size_t>(i)).first - node->GetTagOffset());
+    node->AddRangeGoto(curTag, stmt->GetCasePair(i).second);
+    lastCaseTag = stmt->GetCasePair(i).first;
+  }
+  /* If the density is high enough, the range is allowed to be large */
+  // ASSERT(static_cast<int32>(node->GetRangeGotoTable().size()) <= kMaxRangeGotoTableSize,
+  //       "rangegoto table exceeds allowed number of entries");
+  ASSERT(node->GetNumOpnds() == 1, "RangeGotoNode is a UnaryOpnd and numOpnds must be 1");
+  return node;
+}
+
+CompareNode *SwitchLowerer::BuildCmpNode(Opcode opCode, uint32 idx) {
+  CompareNode *binaryExpr = mirModule.CurFuncCodeMemPool()->New<CompareNode>(opCode);
+  binaryExpr->SetPrimType(PTY_u32);
+  binaryExpr->SetOpndType(stmt->GetSwitchOpnd()->GetPrimType());
+
+  MIRType &type = *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(stmt->GetSwitchOpnd()->GetPrimType()));
+  MIRConst *constVal =
+      GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<uint64>(stmt->GetCasePair(idx).first), type);
+  ConstvalNode *exprConst = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>();
+  exprConst->SetPrimType(stmt->GetSwitchOpnd()->GetPrimType());
+  exprConst->SetConstVal(constVal);
+
+  binaryExpr->SetBOpnd(stmt->GetSwitchOpnd(), 0);
+  binaryExpr->SetBOpnd(exprConst, 1);
+  return binaryExpr;
+}
+
+GotoNode *SwitchLowerer::BuildGotoNode(int32 idx) {
+  if (idx == -1 && stmt->GetDefaultLabel() == 0) {
+    return nullptr;
+  }
+  GotoNode *gotoStmt = mirModule.CurFuncCodeMemPool()->New<GotoNode>(OP_goto);
+  if (idx == -1) {
+    gotoStmt->SetOffset(stmt->GetDefaultLabel());
+  } else {
+    gotoStmt->SetOffset(stmt->GetCasePair(idx).second);
+  }
+  return gotoStmt;
+}
+
+CondGotoNode *SwitchLowerer::BuildCondGotoNode(int32 idx, Opcode opCode, BaseNode &cond) {
+  if (idx == -1 && stmt->GetDefaultLabel() == 0) {
+    return nullptr;
+  }
+  CondGotoNode *cGotoStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(opCode);
+  cGotoStmt->SetOpnd(&cond, 0);
+  if (idx == -1) {
+    cGotoStmt->SetOffset(stmt->GetDefaultLabel());
+  } else {
+    cGotoStmt->SetOffset(stmt->GetCasePair(idx).second);
+  }
+  return cGotoStmt;
+}
+
+/* start and end is with respect to switchItems */
+BlockNode *SwitchLowerer::BuildCodeForSwitchItems(int32 start, int32 end, bool lowBlockNodeChecked,
+                                                  bool highBlockNodeChecked, LabelIdx newLabelIdx) {
+  ASSERT(start >= 0, "invalid args start");
+  ASSERT(end >= 0, "invalid args end");
+  BlockNode *localBlk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  if (start > end) {
+    return localBlk;
+  }
+  CondGotoNode *cGoto = nullptr;
+  RangeGotoNode *rangeGoto = nullptr;
+  IfStmtNode *ifStmt = nullptr;
+  CompareNode *cmpNode = nullptr;
+  MIRLower mirLowerer(mirModule, mirModule.CurFunction());
+  mirLowerer.Init();
+  /* if low side starts with a dense item, handle it first */
+  while ((start <= end) && (switchItems[start].second != 0)) {
+    if (!lowBlockNodeChecked) {
+      lowBlockNodeChecked = true;
+      if (!(IsUnsignedInteger(stmt->GetSwitchOpnd()->GetPrimType()) &&
+          (stmt->GetCasePair(static_cast<size_t>(switchItems[static_cast<uint64>(start)].first)).first == 0))) {
+        cGoto = BuildCondGotoNode(-1, OP_brtrue, *BuildCmpNode(OP_lt, switchItems[start].first));
+        if (cGoto != nullptr) {
+          localBlk->AddStatement(cGoto);
+        }
+      }
+    }
+    rangeGoto = BuildRangeGotoNode(switchItems[start].first, switchItems[start].second, newLabelIdx);
+    if (stmt->GetDefaultLabel() == 0) {
+      localBlk->AddStatement(rangeGoto);
+    } else {
+      cmpNode = BuildCmpNode(OP_le, switchItems[start].second);
+      ifStmt = static_cast<IfStmtNode*>(mirModule.GetMIRBuilder()->CreateStmtIf(cmpNode));
+      ifStmt->GetThenPart()->AddStatement(rangeGoto);
+      localBlk->AppendStatementsFromBlock(*mirLowerer.LowerIfStmt(*ifStmt, false));
+    }
+    if (start < end) {
+      lowBlockNodeChecked = (stmt->GetCasePair(switchItems[start].second).first + 1 ==
+                       stmt->GetCasePair(switchItems[start + 1].first).first);
+    }
+    ++start;
+  }
+  /* if high side starts with a dense item, handle it also */
+  while ((start <= end) && (switchItems[end].second != 0)) {
+    if (!highBlockNodeChecked) {
+      cGoto = BuildCondGotoNode(-1, OP_brtrue, *BuildCmpNode(OP_gt, switchItems[end].second));
+      if (cGoto != nullptr) {
+        localBlk->AddStatement(cGoto);
+      }
+      highBlockNodeChecked = true;
+    }
+    rangeGoto = BuildRangeGotoNode(switchItems[end].first, switchItems[end].second, newLabelIdx);
+    if (stmt->GetDefaultLabel() == 0) {
+      localBlk->AddStatement(rangeGoto);
+    } else {
+      cmpNode = BuildCmpNode(OP_ge, switchItems[end].first);
+      ifStmt = static_cast<IfStmtNode*>(mirModule.GetMIRBuilder()->CreateStmtIf(cmpNode));
+      ifStmt->GetThenPart()->AddStatement(rangeGoto);
+      localBlk->AppendStatementsFromBlock(*mirLowerer.LowerIfStmt(*ifStmt, false));
+    }
+    if (start < end) {
+      highBlockNodeChecked =
+          (stmt->GetCasePair(switchItems[end].first).first - 1 ==
+           stmt->GetCasePair(switchItems[end - 1].first).first) ||
+          (stmt->GetCasePair(switchItems[end].first).first - 1 ==
+           stmt->GetCasePair(switchItems[end - 1].second).first);
+    }
+    --end;
+  }
+  if (start > end) {
+    if (!lowBlockNodeChecked || !highBlockNodeChecked) {
+      GotoNode *gotoDft = BuildGotoNode(-1);
+      if (gotoDft != nullptr) {
+        localBlk->AddStatement(gotoDft);
+        jumpToDefaultBlockGenerated = true;
+      }
+    }
+    return localBlk;
+  }
+  if ((start == end) && lowBlockNodeChecked && highBlockNodeChecked) {
+    /* only 1 case with 1 tag remains */
+    auto *gotoStmt = BuildGotoNode(switchItems[static_cast<size_t>(start)].first);
+    if (gotoStmt != nullptr) {
+      localBlk->AddStatement(gotoStmt);
+    }
+    return localBlk;
+  }
+  if (end < (start + kClusterSwitchCutoff)) {
+    /* generate equality checks for what remains */
+    std::vector <std::pair<uint64, int32>> freq2case;
+    int32 lastIdx = -1;
+    bool freqPriority = false;
+    // The setting of kClusterSwitchDensityLow to such a lower value (0.2) makes other strategies less useful
+    if (Options::profileUse && cgLowerer->GetLabel2Freq().size()) {
+      for (int32 idx = start; idx <= end; idx++) {
+        if (switchItems[static_cast<uint32>(idx)].second == 0) {
+          freq2case.push_back(std::make_pair(cgLowerer->GetLabel2Freq()[stmt->GetCasePair(static_cast<uint32>(
+              switchItems[static_cast<uint32>(idx)].first)).second], switchItems[static_cast<uint32>(idx)].first));
+          lastIdx = idx;
+        } else {
+          break;
+        }
+      }
+
+      std::sort(freq2case.rbegin(), freq2case.rend());
+      if (freq2case.size() > 0 && freq2case[0].first != freq2case[freq2case.size() - 1].first) {
+        freqPriority = true;
+      }
+    }
+
+    if (Options::profileUse && freqPriority) {
+      for (std::pair<uint64, int32> f2c : freq2case) {
+        uint32 idx = static_cast<uint32>(f2c.second);
+        cGoto = BuildCondGotoNode(switchItems[idx].first, OP_brtrue, *BuildCmpNode(OP_eq, switchItems[idx].first));
+        if (cGoto != nullptr) {
+          localBlk->AddStatement(cGoto);
+        }
+      }
+
+      if (lastIdx != -1) {
+        if (lowBlockNodeChecked && (lastIdx < end)) {
+          lowBlockNodeChecked = (
+              stmt->GetCasePair(static_cast<uint32>(switchItems[static_cast<uint32>(lastIdx)].first)).first + 1 ==
+              stmt->GetCasePair(static_cast<uint32>(switchItems[static_cast<uint32>(lastIdx + 1)].first)).first);
+        }
+        start = lastIdx + 1;
+      }
+    } else {
+      while ((start <= end) && (switchItems[static_cast<uint32>(start)].second == 0)) {
+        if ((start == end) && lowBlockNodeChecked && highBlockNodeChecked) {
+          /* can omit the condition */
+          cGoto = reinterpret_cast<CondGotoNode*>(BuildGotoNode(switchItems[static_cast<uint32>(start)].first));
+        } else {
+          cGoto = BuildCondGotoNode(switchItems[static_cast<uint32>(start)].first, OP_brtrue,
+                                    *BuildCmpNode(OP_eq, switchItems[static_cast<uint32>(start)].first));
+        }
+        if (cGoto != nullptr) {
+          localBlk->AddStatement(cGoto);
+        }
+        if (lowBlockNodeChecked && (start < end)) {
+          lowBlockNodeChecked = (stmt->GetCasePair(switchItems[static_cast<uint32>(start)].first).first + 1 ==
+                           stmt->GetCasePair(switchItems[static_cast<uint32>(start + 1)].first).first);
+        }
+        ++start;
+      }
+    }
+    if (start <= end) {  /* recursive call */
+      BlockNode *tmp = BuildCodeForSwitchItems(start, end, lowBlockNodeChecked, highBlockNodeChecked);
+      CHECK_FATAL(tmp != nullptr, "tmp should not be nullptr");
+      localBlk->AppendStatementsFromBlock(*tmp);
+    } else if (!lowBlockNodeChecked || !highBlockNodeChecked) {
+      GotoNode *gotoDft = BuildGotoNode(-1);
+      if (gotoDft != nullptr) {
+        localBlk->AddStatement(gotoDft);
+        jumpToDefaultBlockGenerated = true;
+      }
+    }
+    return localBlk;
+  }
+
+  int64 lowestTag = stmt->GetCasePair(switchItems[static_cast<uint32>(start)].first).first;
+  int64 highestTag = stmt->GetCasePair(switchItems[static_cast<uint32>(end)].first).first;
+
+  /*
+   * if lowestTag and higesttag have the same sign, use difference
+   * if lowestTag and higesttag have the diefferent sign, use sum
+   * 1LL << 63 judge lowestTag ^ highestTag operate result highest
+   * bit is 1 or not, the result highest bit is 1 express lowestTag
+   * and highestTag have same sign , otherwise diefferent sign.highestTag
+   * add or subtract lowestTag divide 2 to get middle tag.
+   */
+  int64 middleTag = ((((static_cast<uint64>(lowestTag)) ^ (static_cast<uint64>(highestTag))) & (1ULL << 63)) == 0)
+                      ? (highestTag - lowestTag) / 2 + lowestTag
+                      : (highestTag + lowestTag) / 2;
+  /* find the mid-point in switch_items between start and end */
+  int32 mid = start;
+  while (stmt->GetCasePair(switchItems[mid].first).first < middleTag) {
+    ++mid;
+  }
+  ASSERT(mid >= start, "switch lowering logic mid should greater than or equal start");
+  ASSERT(mid <= end, "switch lowering logic mid should less than or equal end");
+  /* generate test for binary search */
+  if (stmt->GetDefaultLabel() != 0) {
+    cmpNode = BuildCmpNode(OP_lt, static_cast<uint32>(switchItems[static_cast<uint64>(mid)].first));
+    ifStmt = static_cast<IfStmtNode*>(mirModule.GetMIRBuilder()->CreateStmtIf(cmpNode));
+    bool leftHighBNdChecked = (stmt->GetCasePair(switchItems.at(mid - 1).first).first + 1 ==
+                               stmt->GetCasePair(switchItems.at(mid).first).first) ||
+                              (stmt->GetCasePair(switchItems.at(mid - 1).second).first + 1 ==
+                               stmt->GetCasePair(switchItems.at(mid).first).first);
+    ifStmt->SetThenPart(BuildCodeForSwitchItems(start, mid - 1, lowBlockNodeChecked, leftHighBNdChecked));
+    ifStmt->SetElsePart(BuildCodeForSwitchItems(mid, end, true, highBlockNodeChecked));
+    if (ifStmt->GetElsePart()) {
+      ifStmt->SetNumOpnds(kOperandNumTernary);
+    }
+    localBlk->AppendStatementsFromBlock(*mirLowerer.LowerIfStmt(*ifStmt, false));
+  }
+  return localBlk;
+}
+
+BlockNode *SwitchLowerer::LowerSwitch(LabelIdx newLabelIdx) {
+  if (stmt->GetSwitchTable().empty()) {  /* change to goto */
+    BlockNode *localBlk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+    GotoNode *gotoDft = BuildGotoNode(-1);
+    if (gotoDft != nullptr) {
+      localBlk->AddStatement(gotoDft);
+    }
+    return localBlk;
+  }
+
+  // add case labels to label table's caseLabelSet
+  MIRLabelTable *labelTab = mirModule.CurFunction()->GetLabelTab();
+  for (CasePair &casePair : stmt->GetSwitchTable()) {
+    labelTab->caseLabelSet.insert(casePair.second);
+  }
+
+  MapleVector<Cluster> clusters(ownAllocator->Adapter());
+  stmt->SortCasePair(CasePairKeyLessThan);
+  FindClusters(clusters);
+  InitSwitchItems(clusters);
+  BlockNode *blkNode = BuildCodeForSwitchItems(0, static_cast<int>(switchItems.size()) - 1, false, false, newLabelIdx);
+  if (!jumpToDefaultBlockGenerated) {
+    GotoNode *gotoDft = BuildGotoNode(-1);
+    if (gotoDft != nullptr) {
+      blkNode->AddStatement(gotoDft);
+    }
+  }
+  return blkNode;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/be/trycatchblockslower.cpp b/src/mapleall/maple_be/src/be/trycatchblockslower.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8dc8a37f072fe0e98a1888eb1dec12db50d919c2
--- /dev/null
+++ b/src/mapleall/maple_be/src/be/trycatchblockslower.cpp
@@ -0,0 +1,897 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "try_catch.h"
+namespace maplebe {
+BBT *TryCatchBlocksLower::CreateNewBB(StmtNode *first, StmtNode *last) {
+  BBT *newBB = memPool.New<BBT>(first, last, &memPool);
+  bbList.emplace_back(newBB);
+  return newBB;
+}
+
+BBT *TryCatchBlocksLower::FindTargetBBlock(LabelIdx idx, const std::vector<BBT*> &bbs) {
+  for (auto &target : bbs) {
+    if (target->GetLabelIdx() == idx) {
+      return target;
+    }
+  }
+  return nullptr;
+}
+
+/* returns the first statement that is moved in into the try block. If none is moved in, nullptr is returned */
+StmtNode *TryCatchBlocksLower::MoveCondGotoIntoTry(BBT &jtBB, BBT &condbrBB, const MapleVector<BBT*> &labeledBBsInTry) {
+  StmtNode *firstStmtMovedIn = nullptr;
+  const MapleVector<BBT*> &bbs = labeledBBsInTry;
+  StmtNode *jtStmt = jtBB.GetKeyStmt();
+#if DEBUG
+  StmtNode *js = jtBB.GetFirstStmt();
+  while (js->GetOpCode() != OP_try) {
+    js = js->GetNext();
+  }
+  CHECK_FATAL(js == jtStmt, "make sure js equal jtStmt");
+#endif
+  StmtNode *ts = jtBB.GetFirstStmt()->GetPrev();
+  while ((ts != nullptr) && (ts->GetOpCode() == OP_comment)) {
+    ts = ts->GetPrev();
+  }
+
+  if (ts != nullptr && ts->IsCondBr()) {
+    CHECK_FATAL(ts->GetNext() == jtBB.GetFirstStmt(), "make sure ts's next equal jtBB's firstStmt");
+    StmtNode *firstStmtNode = jtBB.GetFirstStmt();
+    /* [ jtbb_b..jtstmt ]; either jtbb_b is a comment or jtbb_b == jtstmt */
+    LabelIdx id = static_cast<CondGotoNode*>(ts)->GetOffset();
+    for (auto &lbb : bbs) {
+      if (lbb->GetLabelIdx() == id) {
+        /*
+         * this cond goto jumps into the try block; let the try block enclose it
+         * first find the preceding comment statements if any
+         */
+        StmtNode *brS = ts;
+        while ((ts->GetPrev() != nullptr) && (ts->GetPrev()->GetOpCode() == OP_comment)) {
+          ts = ts->GetPrev();
+        }
+        StmtNode *secondStmtNode = ts;  /* beginning statement of branch block */
+        /* [ brbb_b..br_s ]; either brbb_b is a comment or brbb_b == br_s */
+        firstStmtNode->SetPrev(secondStmtNode->GetPrev());
+        if (secondStmtNode->GetPrev()) {
+          secondStmtNode->GetPrev()->SetNext(firstStmtNode);
+        }
+        jtStmt->GetNext()->SetPrev(brS);
+        brS->SetNext(jtStmt->GetNext());
+        secondStmtNode->SetPrev(jtStmt);
+        jtStmt->SetNext(secondStmtNode);
+        condbrBB.SetLastStmt(*firstStmtNode->GetPrev());
+        CHECK_FATAL(condbrBB.GetFallthruBranch() == &jtBB, "make sure condbrBB's fallthruBranch equal &jtBB");
+        condbrBB.SetFallthruBranch(&jtBB);
+        condbrBB.SetCondJumpBranch(nullptr);
+        firstStmtMovedIn = secondStmtNode;
+        break;
+      }
+    }
+  }
+  return firstStmtMovedIn;
+}
+
+void TryCatchBlocksLower::RecoverBasicBlock() {
+  std::vector<BBT*> condbrBBs;
+  std::vector<BBT*> switchBBs;
+  std::vector<BBT*> labeledBBs;
+  using BBTPair = std::pair<BBT*, BBT*>;
+  std::vector<BBTPair> tryBBs;
+  std::vector<BBT*> catchBBs;
+
+  CHECK_FATAL(body.GetFirst() != nullptr, "body should not be NULL");
+  bodyFirst = body.GetFirst();
+  StmtNode *next = bodyFirst;
+  /*
+   * comment block [ begin, end ], We treat comment statements as if they are parts
+   * of the immediately following non-comment statement
+   */
+  StmtNode *commentB = nullptr;
+  StmtNode *commentE = nullptr;
+
+  BBT *curBB = nullptr;
+  BBT *lastBB = nullptr;
+  BBT *openTry = nullptr;
+
+  /* recover basic blocks */
+  for (StmtNode *stmt = next; stmt != nullptr; stmt = next) {
+    next = stmt->GetNext();
+
+    if (stmt->GetOpCode() == OP_comment) {
+      if (commentB == nullptr) {
+        commentB = stmt;
+        commentE = stmt;
+      } else {
+        CHECK_FATAL(commentE != nullptr, "nullptr is not expected");
+        CHECK_FATAL(commentE->GetNext() == stmt, "make sure commentE's next is stmt");
+        commentE = stmt;
+      }
+      continue;
+    }
+
+    CHECK_FATAL(stmt->GetOpCode() != OP_comment, "make sure stmt's opcde not equal OP_comment");
+    CHECK_FATAL(commentB == nullptr || (commentE != nullptr && commentE->GetNext() == stmt),
+                "make sure commentB is nullptr or commentE's next is stmt");
+
+    if (curBB != nullptr) {
+      if (stmt->GetOpCode() != OP_label && stmt->GetOpCode() != OP_try && stmt->GetOpCode() != OP_endtry) {
+        curBB->Extend(commentB, stmt);
+      } else {
+        /* java catch blockes always start with a label (i.e., OP_catch) */
+        CHECK_FATAL(curBB->GetCondJumpBranch() == nullptr, "expect curBB's condJumpBranch is nullptr");
+        CHECK_FATAL(curBB->GetFallthruBranch() == nullptr, "expect curBB's fallthruBranch is nullptr");
+        /* a 'label' statement starts a new basic block */
+        BBT *newBB = CreateNewBB(commentB, stmt);
+        /*
+         * if the immediately preceding statement (discounting comments) was throw, goto or return,
+         * curBB is to be reset to nullptr, so the control  won't come here.
+         */
+        curBB->SetFallthruBranch(newBB);
+        curBB = newBB;
+      }
+    } else {
+      /* start a new basic block with 'comment_b -- stmt' */
+      curBB = CreateNewBB(commentB, stmt);
+      if (lastBB != nullptr) {
+        Opcode lastBBLastStmtOp = lastBB->GetLastStmt()->GetOpCode();
+        if (lastBB->GetLastStmt()->IsCondBr() || lastBBLastStmtOp == OP_endtry) {
+          lastBB->SetFallthruBranch(curBB);
+        }
+        /* else don't connect curBB to last_bb */
+      }
+    }
+    commentB = nullptr;
+    commentE = nullptr;
+
+    switch (stmt->GetOpCode()) {
+      case OP_throw:
+      case OP_return:
+      case OP_goto:
+        /* start a new bb at the next stmt */
+        lastBB = curBB;
+        curBB = nullptr;
+        break;
+      case OP_label: {
+        LabelNode *labelStmt = static_cast<LabelNode*>(stmt);
+        labeledBBs.emplace_back(curBB);
+        curBB->SetLabelIdx(static_cast<LabelIdx>(labelStmt->GetLabelIdx()));
+      } break;
+      case OP_brtrue:
+      case OP_brfalse:
+        condbrBBs.emplace_back(curBB);
+        lastBB = curBB;
+        curBB = nullptr;
+        break;
+      case OP_switch:
+        switchBBs.emplace_back(curBB);
+        lastBB = curBB;
+        curBB = nullptr;
+        break;
+      /*
+       * We deal try and endtry slightly differently.
+       * 1. try begins a basic block which includes the try statement and the subsequent statements up to one that
+       *    results in non-sequential control transfer such as unconditional/conditional branches.
+       * 2. endtry will create its own basic block which contains the endtry statement and nothing else.
+       */
+      case OP_try:
+      case OP_endtry: {
+        /* because a label statement is inserted at the function entry */
+        CHECK_FATAL(curBB != nullptr, "expect curBB is not nullptr");
+        CHECK_FATAL(curBB->GetCondJumpBranch() == nullptr, "expect curBB's condJumpBranch is nullptr");
+        CHECK_FATAL(curBB->GetFallthruBranch() == nullptr, "expect curBB's fallthruBranch is nullptr");
+        CHECK_FATAL(curBB->GetLastStmt()->GetOpCode() == stmt->GetOpCode(),
+                    "the opcode of curBB's lastStmt should equal stmt's opcocde");
+        if (stmt->GetOpCode() == OP_try) {
+          CHECK_FATAL(openTry == nullptr, "trys are not expected to be nested");
+          curBB->SetType(BBT::kBBTry, *stmt);
+          openTry = curBB;
+          prevBBOfTry[openTry] = lastBB;
+        } else {
+          tryBBs.emplace_back(BBTPair(openTry, curBB));
+          openTry = nullptr;
+          curBB->SetType(BBT::kBBEndTry, *stmt);
+          lastBB = curBB;
+          curBB = nullptr;
+        }
+        break;
+      }
+      case OP_catch: {
+#if DEBUG
+        StmtNode *ss = stmt->GetPrev();
+        while ((ss != nullptr) && (ss->GetOpCode() == OP_comment)) {
+          ss = ss->GetPrev();
+        }
+        CHECK_FATAL(ss != nullptr, "expect ss is not nullptr");
+        CHECK_FATAL(ss->GetOpCode() == OP_label, "expect op equal OP_label");
+        for (auto &tb : catchBBs) {
+          CHECK_FATAL(tb != curBB, "tb should not equal curBB");
+        }
+#endif
+        catchBBs.emplace_back(curBB);
+        curBB->SetType(BBT::kBBCatch, *stmt);
+        break;
+      }
+      case OP_block:
+        CHECK_FATAL(false, "should not run here");
+      default:
+        break;
+    }
+  }
+
+  for (auto &cbBB : condbrBBs) {
+    CHECK_FATAL(cbBB->GetLastStmt()->IsCondBr(), "cbBB's lastStmt is not condBr");
+    CondGotoNode *cbBBLastStmt = static_cast<CondGotoNode*>(cbBB->GetLastStmt());
+    cbBB->SetCondJumpBranch(FindTargetBBlock(static_cast<LabelIdx>(cbBBLastStmt->GetOffset()), labeledBBs));
+  }
+
+  for (auto &swBB : switchBBs) {
+    CHECK_FATAL(swBB->GetLastStmt()->GetOpCode() == OP_switch, "the opcode of sw's lastStmt should equal OP_switch");
+    SwitchNode *ss = static_cast<SwitchNode*>(swBB->GetLastStmt());
+
+    swBB->AddSuccs(FindTargetBBlock(ss->GetDefaultLabel(), labeledBBs));
+    for (auto &cp : ss->GetSwitchTable()) {
+      swBB->AddSuccs(FindTargetBBlock(cp.second, labeledBBs));
+    }
+  }
+
+  for (auto &bb : bbList) {
+    firstStmtToBBMap[bb->GetFirstStmt()] = bb;
+  }
+  CHECK_FATAL(openTry == nullptr, "trys are not expected to be nested");
+}
+
+/* if catchBB is in try-endtry block and catch is own to current try-endtry, process it and return true */
+bool TryCatchBlocksLower::CheckAndProcessCatchNodeInCurrTryBlock(BBT &origLowerBB, LabelIdx ebbLabel,
+                                                                 uint32 index) {
+  MapleVector<BBT*> &enclosedBBs = tryEndTryBlock.GetEnclosedBBs();
+  MapleVector<BBT*> &bbsToRelocate = tryEndTryBlock.GetBBsToRelocate();
+  BBT *endTryBB = tryEndTryBlock.GetEndTryBB();
+  StmtNode *tryStmt = tryEndTryBlock.GetTryStmtNode();
+  bool found = false;
+  for (size_t tempIndex = 0; tempIndex < static_cast<TryNode*>(tryStmt)->GetOffsetsCount(); ++tempIndex) {
+    auto id = static_cast<TryNode*>(tryStmt)->GetOffset(tempIndex);
+    /*
+     * if this labeled bb is a catch block,
+     * remove it from the list of blocks enclosed in this try-block'
+     */
+    if (ebbLabel == id) {
+      found = true;
+      enclosedBBs[index] = nullptr;
+      std::vector<BBT*> currBBThread;
+      BBT *lowerBB = &origLowerBB;
+      /* append it to the list of blocks placed after the end try block */
+      currBBThread.emplace_back(lowerBB);
+      while (lowerBB->GetFallthruBranch() != nullptr) {
+        lowerBB = lowerBB->GetFallthruBranch();
+        CHECK_FATAL(!lowerBB->IsTry(), "ebb must not be tryBB");
+        if (lowerBB->IsEndTry()) {
+          CHECK_FATAL(lowerBB == endTryBB, "lowerBB should equal endTryBB");
+          break;
+        }
+        for (uint32 j = 0; j < enclosedBBs.size(); ++j) {
+          if (enclosedBBs[j] == lowerBB) {
+            enclosedBBs[j] = nullptr;
+            break;
+          }
+        }
+        currBBThread.emplace_back(lowerBB);
+      }
+
+      if (!lowerBB->IsEndTry()) {
+        for (auto &e : currBBThread) {
+          bbsToRelocate.emplace_back(e);
+        }
+      } else {
+        /*
+         * We have the following case.
+         * bb_head -> bb_1 -> .. bb_n -> endtry_bb -> succ
+         * For this particular case, we swap endtry bb and curr_bb_thread because the bblock that
+         * contains the endtry statement does not contain any other statements!!
+         */
+        CHECK_FATAL(endTryBB->GetFirstStmt()->GetOpCode() == OP_comment ||
+                    endTryBB->GetFirstStmt()->GetOpCode() == OP_endtry,
+                    "the opcode of endTryBB's firstStmt should be OP_comment or OP_endtry");
+        CHECK_FATAL(endTryBB->GetLastStmt()->GetOpCode() == OP_endtry,
+                    "the opcode of endTryBB's lastStmt should be OP_endtry");
+
+        /* we move endtry_bb before thread_head */
+        BBT *threadHead = currBBThread.front();
+        CHECK_FATAL(threadHead->GetFirstStmt()->GetPrev() != nullptr,
+                    "the prev node of threadHead's firstStmt should be not nullptr");
+        CHECK_FATAL(threadHead->GetFirstStmt()->GetOpCode() == OP_comment ||
+                    threadHead->GetFirstStmt()->GetOpCode() == OP_label,
+                    "the opcode of threadHead's firstStmt should be OP_comment or OP_label");
+        CHECK_FATAL(threadHead->GetFirstStmt()->GetPrev()->GetNext() == threadHead->GetFirstStmt(),
+                    "the next of the prev of threadHead's firstStmt should equal threadHead's firstStmt");
+        threadHead->GetFirstStmt()->GetPrev()->SetNext(endTryBB->GetFirstStmt());
+        endTryBB->GetFirstStmt()->SetPrev(threadHead->GetFirstStmt()->GetPrev());
+        BBT *threadTail = currBBThread.back();
+        threadTail->GetLastStmt()->SetNext(endTryBB->GetLastStmt()->GetNext());
+        if (endTryBB->GetLastStmt()->GetNext() != nullptr) {
+          endTryBB->GetLastStmt()->GetNext()->SetPrev(threadTail->GetLastStmt());
+        }
+        endTryBB->GetLastStmt()->SetNext(threadHead->GetFirstStmt());
+
+        CHECK_FATAL(endTryBB->GetCondJumpBranch() == nullptr, "endTryBB's condJumpBranch must be nullptr");
+        if (threadTail->GetFallthruBranch() != nullptr) {
+          threadTail->SetFallthruBranch(firstStmtToBBMap[threadTail->GetLastStmt()->GetNext()]);
+        }
+        endTryBB->SetFallthruBranch(nullptr);
+        if (bodyEndWithEndTry) {
+          body.SetLast(threadTail->GetLastStmt());
+        }
+      }
+      break;
+    }
+  }
+  return found;
+}
+
+/* collect catchbb->fallthru(0-n) into currBBThread, when encounter a new catch, return it, else return nullptr */
+BBT *TryCatchBlocksLower::CollectCatchAndFallthruUntilNextCatchBB(BBT *&lowerBB, uint32 &nextEnclosedIdx,
+                                                                  std::vector<BBT*> &currBBThread) {
+  MapleVector<BBT*> &enclosedBBs = tryEndTryBlock.GetEnclosedBBs();
+  BBT *endTryBB = tryEndTryBlock.GetEndTryBB();
+
+  BBT *nextBBThreadHead = nullptr;
+  while (lowerBB->GetFallthruBranch() != nullptr) {
+    lowerBB = lowerBB->GetFallthruBranch();
+    ++nextEnclosedIdx;
+    if (lowerBB->IsEndTry()) {
+      CHECK_FATAL(lowerBB == endTryBB, "lowerBB should equal endTryBB");
+      break;
+    }
+
+    for (uint32 j = 0; j < enclosedBBs.size(); ++j) {
+      if (enclosedBBs[j] == lowerBB) {
+        enclosedBBs[j] = nullptr;
+        break;
+      }
+    }
+    if (lowerBB->IsCatch()) {
+      nextBBThreadHead = lowerBB;
+      break;
+    }
+    currBBThread.emplace_back(lowerBB);
+  }
+
+  if (nextBBThreadHead == nullptr && lowerBB->GetFallthruBranch() == nullptr && lowerBB != endTryBB &&
+      nextEnclosedIdx < enclosedBBs.size() && enclosedBBs[nextEnclosedIdx]) {
+    /*
+     * Using a loop to find the next_bb_thread_head when it's a catch_BB or a normal_BB which
+     * is after a catch_BB. Other condition, push_back into the curr_bb_thread.
+     */
+    do {
+      lowerBB = enclosedBBs[nextEnclosedIdx];
+      enclosedBBs[nextEnclosedIdx++] = nullptr;
+      BBT *head = currBBThread.front();
+      if (head->IsCatch() || lowerBB->IsCatch()) {
+        nextBBThreadHead = lowerBB;
+        break;
+      }
+      currBBThread.emplace_back(lowerBB);
+    } while (nextEnclosedIdx < enclosedBBs.size());
+  }
+
+  return nextBBThreadHead;
+}
+
+void TryCatchBlocksLower::ProcessThreadTail(BBT &threadTail, BBT * const &nextBBThreadHead, bool hasMoveEndTry) {
+  BBT *endTryBB = tryEndTryBlock.GetEndTryBB();
+  StmtNode *newEndTry = endTryBB->GetKeyStmt()->CloneTree(mirModule.GetCurFuncCodeMPAllocator());
+  newEndTry->SetPrev(threadTail.GetLastStmt());
+  newEndTry->SetNext(threadTail.GetLastStmt()->GetNext());
+  if (bodyEndWithEndTry && hasMoveEndTry) {
+    if (threadTail.GetLastStmt()->GetNext()) {
+      threadTail.GetLastStmt()->GetNext()->SetPrev(newEndTry);
+    }
+  } else {
+    CHECK_FATAL(threadTail.GetLastStmt()->GetNext() != nullptr,
+                "the next of threadTail's lastStmt should not be nullptr");
+    threadTail.GetLastStmt()->GetNext()->SetPrev(newEndTry);
+  }
+  threadTail.GetLastStmt()->SetNext(newEndTry);
+
+  threadTail.SetLastStmt(*newEndTry);
+  if (hasMoveEndTry && nextBBThreadHead == nullptr) {
+    body.SetLast(threadTail.GetLastStmt());
+  }
+}
+
+/* Wrap this catch block with try-endtry block */
+void TryCatchBlocksLower::WrapCatchWithTryEndTryBlock(std::vector<BBT*> &currBBThread, BBT *&nextBBThreadHead,
+                                                      uint32 &nextEnclosedIdx, bool hasMoveEndTry) {
+  BBT *endTryBB = tryEndTryBlock.GetEndTryBB();
+  StmtNode *tryStmt = tryEndTryBlock.GetTryStmtNode();
+  MapleVector<BBT*> &enclosedBBs = tryEndTryBlock.GetEnclosedBBs();
+  for (auto &e : currBBThread) {
+    CHECK_FATAL(!e->IsTry(), "expect e is not try");
+  }
+  BBT *threadHead = currBBThread.front();
+  if (threadHead->IsCatch()) {
+    StmtNode *jcStmt = threadHead->GetKeyStmt();
+    CHECK_FATAL(jcStmt->GetNext() != nullptr, "jcStmt's next should not be nullptr");
+    TryNode *jtCopy = static_cast<TryNode*>(tryStmt)->CloneTree(mirModule.GetCurFuncCodeMPAllocator());
+    jtCopy->SetNext(jcStmt->GetNext());
+    jtCopy->SetPrev(jcStmt);
+    jcStmt->GetNext()->SetPrev(jtCopy);
+    jcStmt->SetNext(jtCopy);
+
+    BBT *threadTail = currBBThread.back();
+
+    /* for this endtry stmt, we don't need to create a basic block */
+    ProcessThreadTail(*threadTail, static_cast<BBT * const &>(nextBBThreadHead), hasMoveEndTry);
+  } else {
+    /* For cases try->catch->normal_bb->normal_bb->endtry, Combine normal bb first. */
+    while (nextEnclosedIdx < enclosedBBs.size()) {
+      if (nextBBThreadHead != nullptr) {
+        if (nextBBThreadHead->IsCatch()) {
+          break;
+        }
+      }
+      BBT *ebbSecond = enclosedBBs[nextEnclosedIdx];
+      enclosedBBs[nextEnclosedIdx++] = nullptr;
+      CHECK_FATAL(ebbSecond != endTryBB, "ebbSecond should not equal endTryBB");
+      if (ebbSecond->IsCatch()) {
+        nextBBThreadHead = ebbSecond;
+        break;
+      }
+      currBBThread.emplace_back(ebbSecond);
+    }
+    /* normal bb. */
+    StmtNode *stmt = threadHead->GetFirstStmt();
+
+    TryNode *jtCopy = static_cast<TryNode*>(tryStmt)->CloneTree(mirModule.GetCurFuncCodeMPAllocator());
+    jtCopy->SetNext(stmt);
+    jtCopy->SetPrev(stmt->GetPrev());
+    stmt->GetPrev()->SetNext(jtCopy);
+    stmt->SetPrev(jtCopy);
+    threadHead->SetFirstStmt(*jtCopy);
+
+    BBT *threadTail = currBBThread.back();
+
+    /* for this endtry stmt, we don't need to create a basic block */
+    ProcessThreadTail(*threadTail, static_cast<BBT * const &>(nextBBThreadHead), hasMoveEndTry);
+  }
+}
+
+/*
+ * We have the following case.
+ * bb_head -> bb_1 -> .. bb_n -> endtry_bb -> succ
+ * For this particular case, we swap EndTry bb and curr_bb_thread, because the bblock that contains the endtry
+ * statement does not contain any other statements!!
+ */
+void TryCatchBlocksLower::SwapEndTryBBAndCurrBBThread(const std::vector<BBT*> &currBBThread, bool &hasMoveEndTry,
+                                                      const BBT *nextBBThreadHead) {
+  BBT *endTryBB = tryEndTryBlock.GetEndTryBB();
+  CHECK_FATAL(endTryBB->GetFirstStmt()->GetOpCode() == OP_comment ||
+              endTryBB->GetFirstStmt()->GetOpCode() == OP_endtry,
+              "the opcode of endTryBB's firstStmt should be OP_comment or OP_endtry");
+  CHECK_FATAL(endTryBB->GetLastStmt()->GetOpCode() == OP_endtry,
+              "the opcode of endTryBB's lastStmt should be OP_endtry");
+
+  /* we move endtry_bb before bb_head */
+  BBT *threadHead = currBBThread.front();
+  CHECK_FATAL(threadHead->GetFirstStmt()->GetPrev() != nullptr,
+              "the prev of threadHead's firstStmt should not nullptr");
+  CHECK_FATAL(threadHead->GetFirstStmt()->GetOpCode() == OP_comment ||
+              threadHead->GetFirstStmt()->GetOpCode() == OP_label,
+              "the opcode of threadHead's firstStmt should be OP_comment or OP_label");
+  CHECK_FATAL(threadHead->GetFirstStmt()->GetPrev()->GetNext() == threadHead->GetFirstStmt(),
+              "the next of the prev of threadHead's firstStmt should equal threadHead's firstStmt");
+
+  endTryBB->GetFirstStmt()->GetPrev()->SetNext(endTryBB->GetLastStmt()->GetNext());
+  if (endTryBB->GetLastStmt()->GetNext() != nullptr) {
+    endTryBB->GetLastStmt()->GetNext()->SetPrev(endTryBB->GetFirstStmt()->GetPrev());
+  }
+
+  threadHead->GetFirstStmt()->GetPrev()->SetNext(endTryBB->GetFirstStmt());
+  endTryBB->GetFirstStmt()->SetPrev(threadHead->GetFirstStmt()->GetPrev());
+
+  endTryBB->GetLastStmt()->SetNext(threadHead->GetFirstStmt());
+  threadHead->GetFirstStmt()->SetPrev(endTryBB->GetLastStmt());
+
+  CHECK_FATAL(endTryBB->GetCondJumpBranch() == nullptr, "endTryBB's condJumpBranch must be nullptr");
+  endTryBB->SetFallthruBranch(nullptr);
+  if (bodyEndWithEndTry) {
+    hasMoveEndTry = true;
+    if (nextBBThreadHead == nullptr) {
+      body.SetLast(currBBThread.back()->GetLastStmt());
+    }
+  }
+}
+
+void TryCatchBlocksLower::ProcessEnclosedBBBetweenTryEndTry() {
+  MapleVector<BBT*> &enclosedBBs = tryEndTryBlock.GetEnclosedBBs();
+  MapleVector<BBT*> &labeledBBsInTry = tryEndTryBlock.GetLabeledBBsInTry();
+
+  for (uint32 i = 0; i < enclosedBBs.size(); ++i) {
+    BBT *lowerBB = enclosedBBs[i];
+    uint32 nextEnclosedIdx = i + 1;
+    if (lowerBB == nullptr) {
+      continue;  /* we may have removed the element */
+    }
+    if (!lowerBB->IsLabeled()) {
+      continue;
+    }
+    labeledBBsInTry.emplace_back(lowerBB);
+
+    /*
+     * It seems the way a finally is associated with its try is to put the catch block inside
+     * the java-try-end-try block. So, keep the 'catch(void*)' in it.
+     */
+    LabelIdx ebbLabel = lowerBB->GetLabelIdx();
+    bool found = CheckAndProcessCatchNodeInCurrTryBlock(*lowerBB, ebbLabel, i);
+    /* fill cur_bb_thread until meet the next catch */
+    if (!found && lowerBB->IsCatch()) {
+      enclosedBBs[i] = nullptr;
+      std::vector<BBT*> currBBThread;
+      BBT *nextBBThreadHead = nullptr;
+      bool isFirstTime = true;
+      bool hasMoveEndTry = false;
+      do {
+        if (nextBBThreadHead != nullptr) {
+          isFirstTime = false;
+        }
+        nextBBThreadHead = nullptr;
+        currBBThread.clear();
+        currBBThread.emplace_back(lowerBB);
+        nextBBThreadHead = CollectCatchAndFallthruUntilNextCatchBB(lowerBB, nextEnclosedIdx, currBBThread);
+        WrapCatchWithTryEndTryBlock(currBBThread, nextBBThreadHead, nextEnclosedIdx, hasMoveEndTry);
+        if (isFirstTime) {
+          SwapEndTryBBAndCurrBBThread(currBBThread, hasMoveEndTry, nextBBThreadHead);
+        }
+      } while (nextBBThreadHead != nullptr);
+    }
+  }
+}
+
+void TryCatchBlocksLower::ConnectRemainBB() {
+  MapleVector<BBT*> &enclosedBBs = tryEndTryBlock.GetEnclosedBBs();
+  BBT *startTryBB = tryEndTryBlock.GetStartTryBB();
+  BBT *endTryBB = tryEndTryBlock.GetEndTryBB();
+  size_t nEnclosedBBs = enclosedBBs.size();
+  size_t k = 0;
+  while ((k < nEnclosedBBs) && (enclosedBBs[k] == nullptr)) {
+    ++k;
+  }
+
+  if (k < nEnclosedBBs) {
+    BBT *prevBB = enclosedBBs[k];
+
+    startTryBB->GetLastStmt()->SetNext(prevBB->GetFirstStmt());
+    prevBB->GetFirstStmt()->SetPrev(startTryBB->GetLastStmt());
+
+    for (++k; k < nEnclosedBBs; ++k) {
+      BBT *lowerBB = enclosedBBs[k];
+      if (lowerBB == nullptr) {
+        continue;
+      }
+      prevBB->GetLastStmt()->SetNext(lowerBB->GetFirstStmt());
+      lowerBB->GetFirstStmt()->SetPrev(prevBB->GetLastStmt());
+      prevBB = lowerBB;
+    }
+
+    prevBB->GetLastStmt()->SetNext(endTryBB->GetFirstStmt());
+    endTryBB->GetFirstStmt()->SetPrev(prevBB->GetLastStmt());
+  } else {
+    startTryBB->GetLastStmt()->SetNext(endTryBB->GetFirstStmt());
+    endTryBB->GetFirstStmt()->SetPrev(startTryBB->GetLastStmt());
+  }
+}
+
+BBT *TryCatchBlocksLower::FindInsertAfterBB() {
+  BBT *insertAfter = tryEndTryBlock.GetEndTryBB();
+  CHECK_FATAL(tryEndTryBlock.GetEndTryBB()->GetLastStmt()->GetOpCode() == OP_endtry, "LowerBB type check");
+  BBT *iaOpenTry = nullptr;
+  while (insertAfter->GetFallthruBranch() != nullptr || iaOpenTry != nullptr) {
+    if (insertAfter->GetFallthruBranch() != nullptr) {
+      insertAfter = insertAfter->GetFallthruBranch();
+    } else {
+      CHECK_FATAL(iaOpenTry != nullptr, "iaOpenTry should not be nullptr");
+      insertAfter = firstStmtToBBMap[insertAfter->GetLastStmt()->GetNext()];
+      CHECK_FATAL(!insertAfter->IsTry(), "insertAfter should not be try");
+    }
+
+    if (insertAfter->IsTry()) {
+      iaOpenTry = insertAfter;
+    } else if (insertAfter->IsEndTry()) {
+      iaOpenTry = nullptr;
+    }
+  }
+  return insertAfter;
+}
+
+void TryCatchBlocksLower::PlaceRelocatedBB(BBT &insertAfter) {
+  StmtNode *iaLast = insertAfter.GetLastStmt();
+  CHECK_FATAL(iaLast != nullptr, "iaLast should not nullptr");
+
+  StmtNode *iaNext = iaLast->GetNext();
+  if (iaNext == nullptr) {
+    CHECK_FATAL(body.GetLast() == iaLast, "body's last should equal iaLast");
+  }
+  BBT *prevBB = &insertAfter;
+  MapleVector<BBT*> &bbsToRelocate = tryEndTryBlock.GetBBsToRelocate();
+  for (auto &rbb : bbsToRelocate) {
+    prevBB->GetLastStmt()->SetNext(rbb->GetFirstStmt());
+    rbb->GetFirstStmt()->SetPrev(prevBB->GetLastStmt());
+    prevBB = rbb;
+  }
+  prevBB->GetLastStmt()->SetNext(iaNext);
+  if (iaNext != nullptr) {
+    iaNext->SetPrev(prevBB->GetLastStmt());
+  } else {
+    /* !ia_next means we started with insert_after that was the last bblock Refer to the above CHECK_FATAL. */
+    body.SetLast(prevBB->GetLastStmt());
+    body.GetLast()->SetNext(nullptr);
+  }
+}
+
+void TryCatchBlocksLower::PalceCatchSeenSofar(BBT &insertAfter) {
+  TryNode *tryNode = static_cast<TryNode*>(tryEndTryBlock.GetTryStmtNode());
+  ASSERT(tryNode != nullptr, "tryNode should not be nullptr");
+  MapleVector<BBT*> &bbsToRelocate = tryEndTryBlock.GetBBsToRelocate();
+
+  for (size_t offsetIndex = 0; offsetIndex < tryNode->GetOffsetsCount(); ++offsetIndex) {
+    auto id = tryNode->GetOffset(offsetIndex);
+    bool myCatchBlock = false;
+    for (auto &jcb : bbsToRelocate) {
+      if (!jcb->IsLabeled()) {
+        continue;
+      }
+      myCatchBlock = (id == jcb->GetLabelIdx());
+      if (myCatchBlock) {
+        break;
+      }
+    }
+    /*
+     * If the catch block is the one enclosed in this try-endtry block,
+     * we just relocated it above, so we don't need to consider it again
+     */
+    if (myCatchBlock) {
+      continue;
+    }
+
+    CHECK_FATAL(body.GetLast()->GetNext() == nullptr, "the next of body's last should be nullptr");
+    for (auto &jcb : catchesSeenSoFar) {
+      CHECK_FATAL(jcb->IsLabeled(), "jcb should be labeled");
+      if (id == jcb->GetLabelIdx()) {
+        /*
+         * Remove jcb and all of the blocks that are reachable by following fallthruBranch.
+         * If we hit a try block, cut there, append an unconditional jump to it to the preceding bblock,
+         * and relocate them. We may need to insert a label in the try block
+         */
+        BBT *lastBB = jcb;
+        while (lastBB->GetFallthruBranch() != nullptr && !lastBB->GetFallthruBranch()->IsTry()) {
+          lastBB = lastBB->GetFallthruBranch();
+        }
+
+#if DEBUG
+        BBT::ValidateStmtList(bodyFirst);
+#endif
+        if (lastBB->GetFallthruBranch() != nullptr) {
+          BBT *jtBB = lastBB->GetFallthruBranch();
+          CHECK_FATAL(jtBB->IsTry(), "jtBB should be try");
+          if (!jtBB->IsLabeled()) {
+            LabelIdx jtLabIdx = mirModule.GetMIRBuilder()->CreateLabIdx(*mirModule.CurFunction());
+            jtBB->SetLabelIdx(jtLabIdx);
+            StmtNode *labelStmt = mirModule.GetMIRBuilder()->CreateStmtLabel(jtLabIdx);
+            bool adjustBBFirstStmt = (jtBB->GetKeyStmt() == jtBB->GetFirstStmt());
+            labelStmt->SetNext(jtBB->GetKeyStmt());
+            labelStmt->SetPrev(jtBB->GetKeyStmt()->GetPrev());
+            CHECK_FATAL(jtBB->GetKeyStmt()->GetPrev() != nullptr, "the prev of jtBB's ketStmt shpould not be nullptr");
+            jtBB->GetKeyStmt()->GetPrev()->SetNext(labelStmt);
+            CHECK_FATAL(jtBB->GetKeyStmt()->GetNext() != nullptr, "the next of jtBB's ketStmt shpould not be nullptr");
+            jtBB->GetKeyStmt()->SetPrev(labelStmt);
+            if (adjustBBFirstStmt) {
+              firstStmtToBBMap.erase(jtBB->GetFirstStmt());
+              jtBB->SetFirstStmt(*labelStmt);
+              firstStmtToBBMap[jtBB->GetFirstStmt()] = jtBB;
+            }
+          }
+          CHECK_FATAL(jtBB->IsLabeled(), "jtBB should be labeled");
+          CHECK_FATAL(lastBB->GetLastStmt()->GetOpCode() != OP_goto,
+                      "the opcode of lastBB's lastStmt should not be OP_goto");
+          StmtNode *gotoStmt = mirModule.GetMIRBuilder()->CreateStmtGoto(OP_goto, jtBB->GetLabelIdx());
+
+          StmtNode *lastBBLastStmt = lastBB->GetLastStmt();
+          gotoStmt->SetNext(lastBBLastStmt->GetNext());
+          gotoStmt->SetPrev(lastBBLastStmt);
+          if (lastBBLastStmt->GetNext()) {
+            lastBBLastStmt->GetNext()->SetPrev(gotoStmt);
+          }
+          lastBBLastStmt->SetNext(gotoStmt);
+
+          lastBB->SetLastStmt(*gotoStmt);
+          lastBB->SetFallthruBranch(nullptr);
+
+#if DEBUG
+          CHECK_FATAL(body.GetLast()->GetNext() == nullptr, "the next of body's last should be nullptr");
+          BBT::ValidateStmtList(bodyFirst);
+#endif
+        }
+
+        /* we want to remove [jcb .. last_bb], inclusively. */
+        if (jcb->GetFirstStmt() == body.GetFirst()) {
+          body.SetFirst(lastBB->GetLastStmt()->GetNext());
+          body.GetFirst()->SetPrev(nullptr);
+          lastBB->GetLastStmt()->GetNext()->SetPrev(nullptr);
+          bodyFirst = body.GetFirst();
+        } else {
+          CHECK_FATAL(jcb->GetFirstStmt()->GetPrev() != nullptr, "the prev of jcb's firstStmt should not be nullptr");
+          CHECK_FATAL(jcb->GetFirstStmt()->GetPrev()->GetNext() == jcb->GetFirstStmt(),
+                      "the next of the prev of jcb's firstStmt should equal jcb's firstStmt");
+          if (lastBB->GetLastStmt()->GetNext() != nullptr) {
+            jcb->GetFirstStmt()->GetPrev()->SetNext(lastBB->GetLastStmt()->GetNext());
+            lastBB->GetLastStmt()->GetNext()->SetPrev(jcb->GetFirstStmt()->GetPrev());
+          } else {
+            CHECK_FATAL(lastBB->GetLastStmt() == body.GetLast(), "lastBB's lastStmt should equal body's last");
+            body.SetLast(jcb->GetFirstStmt()->GetPrev());
+            body.GetLast()->SetNext(nullptr);
+            jcb->GetFirstStmt()->GetPrev()->SetNext(nullptr);
+          }
+        }
+        jcb->GetFirstStmt()->SetPrev(nullptr);
+        lastBB->GetLastStmt()->SetNext(nullptr);
+
+#if DEBUG
+        CHECK_FATAL(body.GetLast()->GetNext() == nullptr, "the next of body's last should be nullptr");
+        BBT::ValidateStmtList(body.GetFirst(), jcb->GetFirstStmt());
+#endif
+
+        /* append it (i.e., [jcb->firstStmt .. last_bb->lastStmt]) after insert_after */
+        CHECK_FATAL(insertAfter.GetFallthruBranch() == nullptr, "insertAfter's fallthruBranch should be nullptr");
+        if (insertAfter.GetLastStmt() == body.GetLast()) {
+          CHECK_FATAL(insertAfter.GetLastStmt()->GetNext() == nullptr,
+                      "the next of insertAfter's lastStmt should not be nullptr");
+        }
+
+        jcb->GetFirstStmt()->SetPrev(insertAfter.GetLastStmt());
+        lastBB->GetLastStmt()->SetNext(insertAfter.GetLastStmt()->GetNext());
+
+        CHECK_FATAL(body.GetLast()->GetNext() == nullptr, "the next of body's last should be nullptr");
+
+        if (insertAfter.GetLastStmt()->GetNext() != nullptr) {
+          insertAfter.GetLastStmt()->GetNext()->SetPrev(lastBB->GetLastStmt());
+          CHECK_FATAL(body.GetLast()->GetNext() == nullptr, "the next of body's last should be nullptr");
+        } else {
+          /*
+           * note that we have a single BlockNode that contains  all the instructions of a method.
+           * What that means is each instruction's next is not nullptr except for the very last instruction.
+           * insert_after->lastStmt->next == nullptr, means insert_after->lastStmt is indeed the last instruction,
+           * and we are moving instructions of 'last_bb' after it. Thus, we need to fix the BlockNode's last field.
+           */
+          body.SetLast(lastBB->GetLastStmt());
+          CHECK_FATAL(body.GetLast()->GetNext() == nullptr, "the next of body's last should be nullptr");
+        }
+        insertAfter.GetLastStmt()->SetNext(jcb->GetFirstStmt());
+        if (jcb->GetFirstStmt()->GetPrev() != nullptr) {
+          CHECK_FATAL(jcb->GetFirstStmt()->GetPrev()->GetNext() == jcb->GetFirstStmt(),
+                      "the next of the prev of jcb's firstStmt should equal jcb's firstStmt");
+        }
+        if (lastBB->GetLastStmt()->GetNext() != nullptr) {
+          CHECK_FATAL(lastBB->GetLastStmt()->GetNext()->GetPrev() == lastBB->GetLastStmt(),
+                      "thr prev of the next of lastBB's lastStmt should equal lastBB's lastStmt");
+        }
+
+        CHECK_FATAL(body.GetLast()->GetNext() == nullptr, "the next of body's last should be nullptr");
+      }
+    }
+  }
+}
+
+void TryCatchBlocksLower::TraverseBBList() {
+  tryEndTryBlock.Init();
+  for (auto &bb : bbList) {
+    if (bb->IsCatch() && tryEndTryBlock.GetStartTryBB() == nullptr) {
+      /* Add to the list of catch blocks seen so far. */
+      catchesSeenSoFar.emplace_back(bb);
+    }
+    bodyEndWithEndTry = false;
+
+    if (tryEndTryBlock.GetStartTryBB() == nullptr) {
+      if (bb->IsTry()) {
+        StmtNode *firstNonCommentStmt = bb->GetFirstStmt();
+        while (firstNonCommentStmt != nullptr && firstNonCommentStmt->GetOpCode() == OP_comment) {
+          firstNonCommentStmt = firstNonCommentStmt->GetNext();
+        }
+        CHECK_FATAL(bb->GetLastStmt()->GetOpCode() != OP_try || bb->GetLastStmt() == firstNonCommentStmt ||
+                    !generateEHCode, "make sure the opcode of bb's lastStmt is not OP_try"
+                    "or the opcode of bb's lastStmt is OP_try but bb's lastStmt equals firstNonCommentStmt"
+                    "or not generate EHCode");
+        /* prepare for processing a java try block */
+        tryEndTryBlock.Reset(*bb);
+      }
+      continue;
+    }
+
+    /* We should have not a try block enclosed in another java try block!! */
+    CHECK_FATAL(!bb->IsTry(), "bb should not be try");
+    if (!bb->IsEndTry()) {
+      tryEndTryBlock.PushToEnclosedBBs(*bb);
+    } else {
+      tryEndTryBlock.SetEndTryBB(bb);
+      if (tryEndTryBlock.GetEndTryBB()->GetLastStmt() == body.GetLast()) {
+        bodyEndWithEndTry = true;
+      }
+#if DEBUG
+      for (size_t i = 0; i < tryEndTryBlock.GetEnclosedBBsSize(); ++i) {
+        CHECK_FATAL(tryEndTryBlock.GetEnclosedBBsElem(i), "there should not be nullptr in enclosedBBs");
+      }
+#endif
+      ProcessEnclosedBBBetweenTryEndTry();
+      /* Now, connect the remaining ones again n_enclosed_bbs includes 'nullptr's (i.e., deleted entries) */
+      ConnectRemainBB();
+      BBT *insertAfter = FindInsertAfterBB();
+      PlaceRelocatedBB(*insertAfter);
+
+#if DEBUG
+      CHECK_FATAL(body.GetLast()->GetNext() == nullptr, "the next of body's last should be nullptr");
+      BBT::ValidateStmtList(bodyFirst);
+#endif
+      if (prevBBOfTry[tryEndTryBlock.GetStartTryBB()]) {
+        StmtNode *firstStmtMovedIn = MoveCondGotoIntoTry(*tryEndTryBlock.GetStartTryBB(),
+                                                         *prevBBOfTry[tryEndTryBlock.GetStartTryBB()],
+                                                         tryEndTryBlock.GetLabeledBBsInTry());
+        if (firstStmtMovedIn == bodyFirst) {
+          bodyFirst = tryEndTryBlock.GetStartTryBB()->GetFirstStmt();
+          prevBBOfTry[tryEndTryBlock.GetStartTryBB()] = nullptr;
+        }
+      }
+      /*
+       * Now, examine each offset attached to this try and move any catch block
+       * that is not in 'bbs_to_relocate' but in 'catches_seen_so_far'
+       */
+      PalceCatchSeenSofar(*insertAfter);
+
+      /* close the try that is open */
+      tryEndTryBlock.SetStartTryBB(nullptr);
+    }
+#if DEBUG
+    CHECK_FATAL(body.GetLast()->GetNext() == nullptr, "the next of body's last should be nullptr");
+    BBT::ValidateStmtList(bodyFirst);
+#endif
+  }
+
+  body.SetFirst(bodyFirst);
+}
+
+void TryCatchBlocksLower::CheckTryCatchPattern() const {
+  StmtNode *openJt = nullptr;
+  for (StmtNode *stmt = body.GetFirst(); stmt; stmt = stmt->GetNext()) {
+    switch (stmt->GetOpCode()) {
+      case OP_try:
+        openJt = stmt;
+        break;
+      case OP_endtry:
+        openJt = nullptr;
+        break;
+      case OP_catch:
+        if (openJt != nullptr) {
+          CatchNode *jcn = static_cast<CatchNode*>(stmt);
+          for (uint32 i = 0; i < jcn->Size(); ++i) {
+            MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(jcn->GetExceptionTyIdxVecElement(i));
+            MIRPtrType *ptr = static_cast<MIRPtrType*>(type);
+            type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptr->GetPointedTyIdx());
+            CHECK_FATAL(type->GetPrimType() == PTY_void, "type's primType should be PTY_void");
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}
+} /* namespace maplebe */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_MPISel.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_MPISel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..72ba534f1b21bbd023375a8f6b493d9338cbcc20
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_MPISel.cpp
@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_abi.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_abi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2cc831cb4d682446dd5fc3d1ce1c88277312ace0
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_abi.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_cgfunc.h"
+#include "becommon.h"
+
+namespace maplebe {
+using namespace maple;
+
+namespace AArch64Abi {
+bool IsAvailableReg(AArch64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF32, PREF64, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                                  \
+      return canBeAssigned;
+#define INT_REG_ALIAS(ALIAS, ID, PREF32, PREF64)
+#include "aarch64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, PV, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                                                   \
+      return canBeAssigned;
+#define FP_SIMD_REG_ALIAS(ID)
+#include "aarch64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+#undef FP_SIMD_REG_ALIAS
+    default:
+      return false;
+  }
+}
+
+bool IsCallerSaveReg(AArch64reg regNO) {
+  return (R0 <= regNO && regNO <= R18) || (V0 <= regNO && regNO <= V7) ||
+      (V16 <= regNO && regNO <= V31) || (regNO == kRFLAG);
+}
+
+bool IsCalleeSavedReg(AArch64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF32, PREF64, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                                  \
+      return isCalleeSave;
+#define INT_REG_ALIAS(ALIAS, ID, PREF32, PREF64)
+#include "aarch64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, PV, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                                                   \
+      return isCalleeSave;
+#define FP_SIMD_REG_ALIAS(ID)
+#include "aarch64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+#undef FP_SIMD_REG_ALIAS
+    default:
+      return false;
+  }
+}
+
+bool IsParamReg(AArch64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF32, PREF64, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                                  \
+      return isParam;
+#define INT_REG_ALIAS(ALIAS, ID, PREF32, PREF64)
+#include "aarch64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, PV, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                                                   \
+      return isParam;
+#define FP_SIMD_REG_ALIAS(ID)
+#include "aarch64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+#undef FP_SIMD_REG_ALIAS
+    default:
+      return false;
+  }
+}
+
+bool IsSpillReg(AArch64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF32, PREF64, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                                  \
+      return isSpill;
+#define INT_REG_ALIAS(ALIAS, ID, PREF32, PREF64)
+#include "aarch64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, PV, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                                                   \
+      return isSpill;
+#define FP_SIMD_REG_ALIAS(ID)
+#include "aarch64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+#undef FP_SIMD_REG_ALIAS
+    default:
+      return false;
+  }
+}
+
+bool IsExtraSpillReg(AArch64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF32, PREF64, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                                  \
+      return isExtraSpill;
+#define INT_REG_ALIAS(ALIAS, ID, PREF32, PREF64)
+#include "aarch64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, PV, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                                                   \
+      return isExtraSpill;
+#define FP_SIMD_REG_ALIAS(ID)
+#include "aarch64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+#undef FP_SIMD_REG_ALIAS
+    default:
+      return false;
+  }
+}
+
+bool IsSpillRegInRA(AArch64reg regNO, bool has3RegOpnd) {
+  /* if has 3 RegOpnd, previous reg used to spill. */
+  if (has3RegOpnd) {
+    return AArch64Abi::IsSpillReg(regNO) || AArch64Abi::IsExtraSpillReg(regNO);
+  }
+  return AArch64Abi::IsSpillReg(regNO);
+}
+
+PrimType IsVectorArrayType(MIRType *ty, uint32 &arraySize) {
+  if (ty->GetKind() == kTypeStruct) {
+    MIRStructType *structTy = static_cast<MIRStructType *>(ty);
+    if (structTy->GetFields().size() == 1) {
+      auto fieldPair = structTy->GetFields()[0];
+      MIRType *fieldTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+      if (fieldTy->GetKind() == kTypeArray) {
+        MIRArrayType *arrayTy = static_cast<MIRArrayType *>(fieldTy);
+        MIRType *arrayElemTy = arrayTy->GetElemType();
+        arraySize = arrayTy->GetSizeArrayItem(0);
+        if (arrayTy->GetDim() == k1BitSize && arraySize <= k4BitSize &&
+            IsPrimitiveVector(arrayElemTy->GetPrimType())) {
+          return arrayElemTy->GetPrimType();
+        }
+      }
+    }
+  }
+  return PTY_void;
+}
+}  /* namespace AArch64Abi */
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_alignment.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_alignment.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..213ea3f33944364467ce17887f3299a7bd23195a
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_alignment.cpp
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <unordered_map>
+#include "insn.h"
+#include "loop.h"
+#include "aarch64_cg.h"
+#include "cg_option.h"
+#include "aarch64_alignment.h"
+
+namespace maplebe {
+void AArch64AlignAnalysis::FindLoopHeader() {
+  MapleVector<CGFuncLoops*> loops = aarFunc->GetLoops();
+  if (loops.empty()) {
+    return;
+  }
+  for (const auto *loop : loops) {
+    const BB *header = loop->GetHeader();
+    if (header != nullptr) {
+      InsertLoopHeaderBBs(const_cast<BB &>(*header));
+    }
+  }
+}
+
+void AArch64AlignAnalysis::FindJumpTarget() {
+  MapleUnorderedMap<LabelIdx, BB*> label2BBMap = aarFunc->GetLab2BBMap();
+  if (label2BBMap.empty()) {
+    return;
+  }
+  for (auto &iter : label2BBMap) {
+    BB *jumpBB = iter.second;
+    if (jumpBB != nullptr) {
+      InsertJumpTargetBBs(*jumpBB);
+    }
+  }
+}
+
+bool AArch64AlignAnalysis::IsIncludeCall(BB &bb) {
+  return bb.HasCall();
+}
+
+bool AArch64AlignAnalysis::IsInSizeRange(BB &bb) {
+  uint64 size = 0;
+  FOR_BB_INSNS_CONST(insn, &bb) {
+    if (!insn->IsMachineInstruction() || insn->GetMachineOpcode() == MOP_pseudo_ret_int ||
+        insn->GetMachineOpcode() == MOP_pseudo_ret_float) {
+      continue;
+    }
+    size += kAlignInsnLength;
+  }
+  BB *curBB = &bb;
+  while (curBB->GetNext() != nullptr && curBB->GetNext()->GetLabIdx() == 0) {
+    FOR_BB_INSNS_CONST(insn, curBB->GetNext()) {
+      if (!insn->IsMachineInstruction() || insn->GetMachineOpcode() == MOP_pseudo_ret_int ||
+          insn->GetMachineOpcode() == MOP_pseudo_ret_float) {
+        continue;
+      }
+      size += kAlignInsnLength;
+    }
+    curBB = curBB->GetNext();
+  }
+  AArch64AlignInfo targetInfo;
+  if (CGOptions::GetAlignMinBBSize() == 0 || CGOptions::GetAlignMaxBBSize() == 0) {
+    return false;
+  }
+  targetInfo.alignMinBBSize = (CGOptions::OptimizeForSize()) ? 16 : CGOptions::GetAlignMinBBSize();
+  targetInfo.alignMaxBBSize = (CGOptions::OptimizeForSize()) ? 44 : CGOptions::GetAlignMaxBBSize();
+  if (size <= targetInfo.alignMinBBSize || size >= targetInfo.alignMaxBBSize) {
+    return false;
+  }
+  return true;
+}
+
+bool AArch64AlignAnalysis::HasFallthruEdge(BB &bb) {
+  for (auto *iter : bb.GetPreds()) {
+    if (iter == bb.GetPrev()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void AArch64AlignAnalysis::ComputeLoopAlign() {
+  if (loopHeaderBBs.empty()) {
+    return;
+  }
+  for (BB *bb : loopHeaderBBs) {
+    if (bb == cgFunc->GetFirstBB() || IsIncludeCall(*bb) || !IsInSizeRange(*bb)) {
+      continue;
+    }
+    bb->SetNeedAlign(true);
+    if (CGOptions::GetLoopAlignPow() == 0) {
+      return;
+    }
+    AArch64AlignInfo targetInfo;
+    targetInfo.loopAlign = CGOptions::GetLoopAlignPow();
+    if (alignInfos.find(bb) == alignInfos.end()) {
+      alignInfos[bb] = targetInfo.loopAlign;
+    } else {
+      uint32 curPower = alignInfos[bb];
+      alignInfos[bb] = (targetInfo.loopAlign < curPower) ? targetInfo.loopAlign : curPower;
+    }
+    bb->SetAlignPower(alignInfos[bb]);
+  }
+}
+
+void AArch64AlignAnalysis::ComputeJumpAlign() {
+  if (jumpTargetBBs.empty()) {
+    return;
+  }
+  for (BB *bb : jumpTargetBBs) {
+    if (bb == cgFunc->GetFirstBB() || !IsInSizeRange(*bb) || HasFallthruEdge(*bb)) {
+      continue;
+    }
+    bb->SetNeedAlign(true);
+    if (CGOptions::GetJumpAlignPow() == 0) {
+      return;
+    }
+    AArch64AlignInfo targetInfo;
+    targetInfo.jumpAlign = (CGOptions::OptimizeForSize()) ? 3 : CGOptions::GetJumpAlignPow();
+    if (alignInfos.find(bb) == alignInfos.end()) {
+      alignInfos[bb] = targetInfo.jumpAlign;
+    } else {
+      uint32 curPower = alignInfos[bb];
+      alignInfos[bb] = (targetInfo.jumpAlign < curPower) ? targetInfo.jumpAlign : curPower;
+    }
+    bb->SetAlignPower(alignInfos[bb]);
+  }
+}
+
+uint32 AArch64AlignAnalysis::GetAlignRange(uint32 alignedVal, uint32 addr) const {
+  if (addr == 0) {
+    return addr;
+  }
+  uint32 range = (alignedVal - (((addr - 1) * kInsnSize) & (alignedVal - 1))) / kInsnSize - 1;
+  return range;
+}
+
+bool AArch64AlignAnalysis::IsInSameAlignedRegion(uint32 addr1, uint32 addr2, uint32 alignedRegionSize) const {
+  return (((addr1 - 1) * kInsnSize) / alignedRegionSize) == (((addr2 - 1) * kInsnSize) / alignedRegionSize);
+}
+
+bool AArch64AlignAnalysis::MarkCondBranchAlign() {
+  sameTargetBranches.clear();
+  uint32 addr = 0;
+  bool change = false;
+  FOR_ALL_BB(bb, aarFunc) {
+    if (bb != nullptr && bb->IsBBNeedAlign()) {
+      uint32 alignedVal = (1U << bb->GetAlignPower());
+      uint32 alignNopNum = GetAlignRange(alignedVal, addr);
+      addr += alignNopNum;
+      bb->SetAlignNopNum(alignNopNum);
+    }
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      addr += insn->GetAtomicNum();
+      MOperator mOp = insn->GetMachineOpcode();
+      if ((mOp == MOP_wtbz || mOp == MOP_wtbnz || mOp == MOP_xtbz || mOp == MOP_xtbnz) && insn->IsNeedSplit()) {
+        ++addr;
+      }
+      if (!insn->IsCondBranch() || insn->GetOperandSize() == 0) {
+        insn->SetAddress(addr);
+        continue;
+      }
+      Operand &opnd = insn->GetOperand(insn->GetOperandSize() - 1);
+      if (!opnd.IsLabelOpnd()) {
+        insn->SetAddress(addr);
+        continue;
+      }
+      LabelIdx targetIdx = static_cast<LabelOperand&>(opnd).GetLabelIndex();
+      if (sameTargetBranches.find(targetIdx) == sameTargetBranches.end()) {
+        sameTargetBranches[targetIdx] = addr;
+        insn->SetAddress(addr);
+        continue;
+      }
+      uint32 sameTargetAddr = sameTargetBranches[targetIdx];
+      uint32 alignedRegionSize = 1 << kAlignRegionPower;
+      /**
+       * if two branches jump to the same target and their addresses are within an 16byte aligned region,
+       * add a certain number of [nop] to move them out of the region.
+       */
+      if (IsInSameAlignedRegion(sameTargetAddr, addr, alignedRegionSize)) {
+        uint32 nopNum = GetAlignRange(alignedRegionSize, addr) + 1;
+        nopNum = nopNum > kAlignMaxNopNum ? 0 : nopNum;
+        if (nopNum == 0) {
+          break;
+        }
+        change = true;
+        insn->SetNopNum(nopNum);
+        for (uint32 i = 0; i < nopNum; i++) {
+          addr += insn->GetAtomicNum();
+        }
+      } else {
+        insn->SetNopNum(0);
+      }
+      sameTargetBranches[targetIdx] = addr;
+      insn->SetAddress(addr);
+    }
+  }
+  return change;
+}
+
+void AArch64AlignAnalysis::UpdateInsnId() {
+  uint32 id = 0;
+  FOR_ALL_BB(bb, aarFunc) {
+    if (bb != nullptr && bb->IsBBNeedAlign()) {
+      uint32 alignedVal = 1U << (bb->GetAlignPower());
+      uint32 range = GetAlignRange(alignedVal, id);
+      id = id + (range > kAlignPseudoSize ? range : kAlignPseudoSize);
+    }
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      id += insn->GetAtomicNum();
+      if (insn->IsCondBranch() && insn->GetNopNum() != 0) {
+        id += insn->GetNopNum();
+      }
+      MOperator mOp = insn->GetMachineOpcode();
+      if ((mOp == MOP_wtbz || mOp == MOP_wtbnz || mOp == MOP_xtbz || mOp == MOP_xtbnz) && insn->IsNeedSplit()) {
+        ++id;
+      }
+      insn->SetId(id);
+      if (insn->GetMachineOpcode() == MOP_adrp_ldr && CGOptions::IsLazyBinding() && !aarFunc->GetCG()->IsLibcore()) {
+        ++id;
+      }
+    }
+  }
+}
+
+bool AArch64AlignAnalysis::MarkShortBranchSplit() {
+  bool change = false;
+  bool split;
+  do {
+    split = false;
+    UpdateInsnId();
+    for (auto *bb = aarFunc->GetFirstBB(); bb != nullptr && !split; bb = bb->GetNext()) {
+      for (auto *insn = bb->GetLastInsn(); insn != nullptr && !split; insn = insn->GetPrev()) {
+        if (!insn->IsMachineInstruction()) {
+          continue;
+        }
+        MOperator mOp = insn->GetMachineOpcode();
+        if (mOp != MOP_wtbz && mOp != MOP_wtbnz && mOp != MOP_xtbz && mOp != MOP_xtbnz) {
+          continue;
+        }
+        if (insn->IsNeedSplit()) {
+          continue;
+        }
+        auto &labelOpnd = static_cast<LabelOperand&>(insn->GetOperand(kInsnThirdOpnd));
+        if (aarFunc->DistanceCheck(*bb, labelOpnd.GetLabelIndex(), insn->GetId())) {
+          continue;
+        }
+        split = true;
+        change = true;
+        insn->SetNeedSplit(split);
+      }
+    }
+  } while (split);
+  return change;
+}
+
+void AArch64AlignAnalysis::AddNopAfterMark() {
+  FOR_ALL_BB(bb, aarFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction() || !insn->IsCondBranch() || insn->GetNopNum() == 0) {
+        continue;
+      }
+      /**
+       * To minimize the performance loss of nop, we decided to place nop on an island before the current addr.
+       * The island here is after [b, ret, br, blr].
+       * To ensure correct insertion of the nop, the nop is inserted in the original position in the following cases:
+       * 1. A branch with the same target exists before it.
+       * 2. A branch whose nopNum value is not 0 exists before it.
+       * 3. no BBs need to be aligned between the original location and the island.
+       */
+      std::unordered_map<LabelIdx, Insn*> targetCondBrs;
+      bool findIsland = false;
+      Insn *detect = insn->GetPrev();
+      BB *region = bb;
+      while (detect != nullptr || region != aarFunc->GetFirstBB()) {
+        while (detect == nullptr) {
+          ASSERT(region->GetPrev() != nullptr, "get region prev failed");
+          region = region->GetPrev();
+          detect = region->GetLastInsn();
+        }
+        if (detect->GetMachineOpcode() == MOP_xuncond || detect->GetMachineOpcode() == MOP_xret ||
+            detect->GetMachineOpcode() == MOP_xbr) {
+          findIsland = true;
+          break;
+        }
+        if (region->IsBBNeedAlign()) {
+          break;
+        }
+        if (!detect->IsMachineInstruction() || !detect->IsCondBranch() || detect->GetOperandSize() == 0) {
+          detect = detect->GetPrev();
+          continue;
+        }
+        if (detect->GetNopNum() != 0) {
+          break;
+        }
+        Operand &opnd = detect->GetOperand(detect->GetOperandSize() - 1);
+        if (!opnd.IsLabelOpnd()) {
+          detect = detect->GetPrev();
+          continue;
+        }
+        LabelIdx targetIdx = static_cast<LabelOperand&>(opnd).GetLabelIndex();
+        if (targetCondBrs.find(targetIdx) != targetCondBrs.end()) {
+          break;
+        }
+        targetCondBrs[targetIdx] = detect;
+        detect = detect->GetPrev();
+      }
+      uint32 nopNum = insn->GetNopNum();
+      if (findIsland) {
+        for (uint32 i = 0; i < nopNum; i++) {
+          (void)bb->InsertInsnAfter(*detect, aarFunc->GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_nop));
+        }
+      } else {
+        for (uint32 i = 0; i < nopNum; i++) {
+          (void)bb->InsertInsnBefore(*insn, aarFunc->GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_nop));
+        }
+      }
+    }
+  }
+}
+
+/**
+ * The insertion of nop affects the judgement of the addressing range of short branches,
+ * and the splitting of short branches affects the calculation of the location and number of nop insertions.
+ * In the iteration process of both, we only make some marks, wait for the fixed points, and fill in nop finally.
+ */
+void AArch64AlignAnalysis::ComputeCondBranchAlign() {
+  bool condBrChange = false;
+  bool shortBrChange = false;
+  while (true) {
+    condBrChange = MarkCondBranchAlign();
+    if (!condBrChange) {
+      break;
+    }
+    shortBrChange = MarkShortBranchSplit();
+    if (!shortBrChange) {
+      break;
+    }
+  }
+  AddNopAfterMark();
+}
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_args.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_args.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e9ace62f7001060a5ca8379d9704ae584192a9ca
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_args.cpp
@@ -0,0 +1,484 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_args.h"
+#include <fstream>
+#include "aarch64_cgfunc.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+using namespace maple;
+
+void AArch64MoveRegArgs::Run() {
+  MoveVRegisterArgs();
+  MoveRegisterArgs();
+}
+
+void AArch64MoveRegArgs::CollectRegisterArgs(std::map<uint32, AArch64reg> &argsList,
+                                             std::vector<uint32> &indexList,
+                                             std::map<uint32, AArch64reg> &pairReg,
+                                             std::vector<uint32> &numFpRegs,
+                                             std::vector<uint32> &fpSize) const {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  uint32 numFormal = static_cast<uint32>(aarchCGFunc->GetFunction().GetFormalCount());
+  numFpRegs.resize(numFormal);
+  fpSize.resize(numFormal);
+  AArch64CallConvImpl parmlocator(aarchCGFunc->GetBecommon());
+  CCLocInfo ploc;
+  uint32 start = 0;
+  if (numFormal > 0) {
+    MIRFunction *func = const_cast<MIRFunction *>(aarchCGFunc->GetBecommon().GetMIRModule().CurFunction());
+    if (func->IsReturnStruct() && func->IsFirstArgReturn()) {
+      TyIdx tyIdx = func->GetFuncRetStructTyIdx();
+      if (aarchCGFunc->GetBecommon().GetTypeSize(tyIdx) <= k16ByteSize) {
+        start = 1;
+      }
+    }
+  }
+  for (uint32 i = start; i < numFormal; ++i) {
+    MIRType *ty = aarchCGFunc->GetFunction().GetNthParamType(i);
+    parmlocator.LocateNextParm(*ty, ploc, i == 0, &aarchCGFunc->GetFunction());
+    if (ploc.reg0 == kRinvalid) {
+      continue;
+    }
+    AArch64reg reg0 = static_cast<AArch64reg>(ploc.reg0);
+    MIRSymbol *sym = aarchCGFunc->GetFunction().GetFormal(i);
+    if (sym->IsPreg()) {
+      continue;
+    }
+    argsList[i] = reg0;
+    indexList.emplace_back(i);
+    if (ploc.reg1 == kRinvalid) {
+      continue;
+    }
+    if (ploc.numFpPureRegs > 0) {
+      uint32 index = i;
+      numFpRegs[index] = ploc.numFpPureRegs;
+      fpSize[index] = ploc.fpSize;
+      continue;
+    }
+    pairReg[i] = static_cast<AArch64reg>(ploc.reg1);
+  }
+}
+
+ArgInfo AArch64MoveRegArgs::GetArgInfo(std::map<uint32, AArch64reg> &argsList, std::vector<uint32> &numFpRegs,
+                                       std::vector<uint32> &fpSize, uint32 argIndex) const {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  ArgInfo argInfo;
+  argInfo.reg = argsList[argIndex];
+  argInfo.mirTy = aarchCGFunc->GetFunction().GetNthParamType(argIndex);
+  argInfo.symSize = aarchCGFunc->GetBecommon().GetTypeSize(argInfo.mirTy->GetTypeIndex());
+  argInfo.memPairSecondRegSize = 0;
+  argInfo.doMemPairOpt = false;
+  argInfo.createTwoStores  = false;
+  argInfo.isTwoRegParm = false;
+
+  if (GetVecLanes(argInfo.mirTy->GetPrimType()) > 0) {
+    /* vector type */
+    argInfo.stkSize = argInfo.symSize;
+  } else if ((argInfo.symSize > k8ByteSize) && (argInfo.symSize <= k16ByteSize)) {
+    argInfo.isTwoRegParm = true;
+    if (numFpRegs[argIndex] > kOneRegister) {
+      argInfo.symSize = argInfo.stkSize = fpSize[argIndex];
+    } else {
+      if (argInfo.symSize > k12ByteSize) {
+        argInfo.memPairSecondRegSize = k8ByteSize;
+      } else {
+        /* Round to 4 the stack space required for storing the struct */
+        argInfo.memPairSecondRegSize = k4ByteSize;
+      }
+      argInfo.doMemPairOpt = true;
+      if (CGOptions::IsArm64ilp32()) {
+        argInfo.symSize = argInfo.stkSize = k8ByteSize;
+      } else {
+        argInfo.symSize = argInfo.stkSize = GetPointerSize();
+      }
+    }
+  } else if (argInfo.symSize > k16ByteSize) {
+    /* For large struct passing, a pointer to the copy is used. */
+    if (CGOptions::IsArm64ilp32()) {
+      argInfo.symSize = argInfo.stkSize = k8ByteSize;
+    } else {
+      argInfo.symSize = argInfo.stkSize = GetPointerSize();
+    }
+  } else if ((argInfo.mirTy->GetPrimType() == PTY_agg) && (argInfo.symSize < k8ByteSize)) {
+    /*
+     * For small aggregate parameter, set to minimum of 8 bytes.
+     * B.5:If the argument type is a Composite Type then the size of the argument is rounded up to the
+     * nearest multiple of 8 bytes.
+     */
+    argInfo.symSize = argInfo.stkSize = k8ByteSize;
+  } else if (numFpRegs[argIndex] > kOneRegister) {
+    argInfo.isTwoRegParm = true;
+    argInfo.symSize = argInfo.stkSize = fpSize[argIndex];
+  } else {
+    argInfo.stkSize = (argInfo.symSize < k4ByteSize) ? k4ByteSize : argInfo.symSize;
+    if (argInfo.symSize > k4ByteSize) {
+      argInfo.symSize = k8ByteSize;
+    }
+  }
+  argInfo.regType = (argInfo.reg < V0) ? kRegTyInt : kRegTyFloat;
+  argInfo.sym = aarchCGFunc->GetFunction().GetFormal(argIndex);
+  CHECK_NULL_FATAL(argInfo.sym);
+  argInfo.symLoc =
+      static_cast<const AArch64SymbolAlloc*>(aarchCGFunc->GetMemlayout()->GetSymAllocInfo(argInfo.sym->GetStIndex()));
+  CHECK_NULL_FATAL(argInfo.symLoc);
+  if (argInfo.doMemPairOpt && (static_cast<uint32>(aarchCGFunc->GetBaseOffset(*(argInfo.symLoc))) & 0x7)) {
+    /* Do not optimize for struct reg pair for unaligned access.
+     * However, this symbol requires two parameter registers, separate stores must be generated.
+     */
+    argInfo.symSize = GetPointerSize();
+    argInfo.doMemPairOpt = false;
+    argInfo.createTwoStores = true;
+  }
+  return argInfo;
+}
+
+bool AArch64MoveRegArgs::IsInSameSegment(const ArgInfo &firstArgInfo, const ArgInfo &secondArgInfo) const {
+  if (firstArgInfo.symLoc->GetMemSegment() != secondArgInfo.symLoc->GetMemSegment()) {
+    return false;
+  }
+  if (firstArgInfo.symSize != secondArgInfo.symSize) {
+    return false;
+  }
+  if (firstArgInfo.symSize != k4ByteSize && firstArgInfo.symSize != k8ByteSize) {
+    return false;
+  }
+  if (firstArgInfo.regType != secondArgInfo.regType) {
+    return false;
+  }
+  return firstArgInfo.symLoc->GetOffset() + firstArgInfo.stkSize == secondArgInfo.symLoc->GetOffset();
+}
+
+void AArch64MoveRegArgs::GenerateStpInsn(const ArgInfo &firstArgInfo, const ArgInfo &secondArgInfo) {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  RegOperand *baseOpnd = static_cast<RegOperand*>(aarchCGFunc->GetBaseReg(*firstArgInfo.symLoc));
+  RegOperand &regOpnd = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(firstArgInfo.reg,
+                                                                        firstArgInfo.stkSize * kBitsPerByte,
+                                                                        firstArgInfo.regType);
+  MOperator mOp = firstArgInfo.regType == kRegTyInt ? ((firstArgInfo.stkSize > k4ByteSize) ? MOP_xstp : MOP_wstp)
+                                                    : ((firstArgInfo.stkSize > k4ByteSize) ? MOP_dstp : MOP_sstp);
+  RegOperand *regOpnd2 = &aarchCGFunc->GetOrCreatePhysicalRegisterOperand(secondArgInfo.reg,
+                                                                          firstArgInfo.stkSize * kBitsPerByte,
+                                                                          firstArgInfo.regType);
+  if (firstArgInfo.doMemPairOpt && firstArgInfo.isTwoRegParm) {
+    AArch64reg regFp2 = static_cast<AArch64reg>(firstArgInfo.reg + kOneRegister);
+    regOpnd2 = &aarchCGFunc->GetOrCreatePhysicalRegisterOperand(regFp2,
+                                                                firstArgInfo.stkSize * kBitsPerByte,
+                                                                firstArgInfo.regType);
+  }
+
+  int32 limit = (secondArgInfo.stkSize > k4ByteSize) ? kStpLdpImm64UpperBound : kStpLdpImm32UpperBound;
+  int32 stOffset = aarchCGFunc->GetBaseOffset(*firstArgInfo.symLoc);
+  MemOperand *memOpnd = nullptr;
+  if (stOffset > limit || baseReg != nullptr) {
+    if (baseReg == nullptr || lastSegment != firstArgInfo.symLoc->GetMemSegment()) {
+      ImmOperand &immOpnd =
+          aarchCGFunc->CreateImmOperand(stOffset - firstArgInfo.symLoc->GetOffset(), k64BitSize, false);
+      baseReg = &aarchCGFunc->CreateRegisterOperandOfType(kRegTyInt, k8ByteSize);
+      lastSegment = firstArgInfo.symLoc->GetMemSegment();
+      aarchCGFunc->SelectAdd(*baseReg, *baseOpnd, immOpnd, GetLoweredPtrType());
+    }
+    OfstOperand &offsetOpnd = aarchCGFunc->CreateOfstOpnd(static_cast<uint64>(firstArgInfo.symLoc->GetOffset()),
+        k32BitSize);
+    if (firstArgInfo.symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed) {
+      offsetOpnd.SetVary(kUnAdjustVary);
+    }
+    memOpnd = aarchCGFunc->CreateMemOperand(MemOperand::kAddrModeBOi,
+                                            firstArgInfo.stkSize * kBitsPerByte,
+                                            *baseReg, nullptr, &offsetOpnd, firstArgInfo.sym);
+  } else {
+    OfstOperand &offsetOpnd = aarchCGFunc->CreateOfstOpnd(static_cast<uint64>(static_cast<int64>(stOffset)),
+        k32BitSize);
+    if (firstArgInfo.symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed) {
+      offsetOpnd.SetVary(kUnAdjustVary);
+    }
+    memOpnd = aarchCGFunc->CreateMemOperand(MemOperand::kAddrModeBOi,
+                                            firstArgInfo.stkSize * kBitsPerByte,
+                                            *baseOpnd, nullptr, &offsetOpnd, firstArgInfo.sym);
+  }
+  Insn &pushInsn = aarchCGFunc->GetInsnBuilder()->BuildInsn(mOp, regOpnd, *regOpnd2, *memOpnd);
+  if (aarchCGFunc->GetCG()->GenerateVerboseCG()) {
+    std::string argName = firstArgInfo.sym->GetName() + " " + secondArgInfo.sym->GetName();
+    pushInsn.SetComment(std::string("store param: ").append(argName));
+  }
+  aarchCGFunc->GetCurBB()->AppendInsn(pushInsn);
+}
+
+void AArch64MoveRegArgs::GenOneInsn(const ArgInfo &argInfo, RegOperand &baseOpnd, uint32 stBitSize, AArch64reg dest,
+                                    int32 offset) const {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  MOperator mOp = aarchCGFunc->PickStInsn(stBitSize, argInfo.mirTy->GetPrimType());
+  RegOperand &regOpnd = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(dest, stBitSize, argInfo.regType);
+
+  OfstOperand &offsetOpnd = aarchCGFunc->CreateOfstOpnd(static_cast<uint64>(static_cast<int64>(offset)), k32BitSize);
+  if (argInfo.symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed) {
+    offsetOpnd.SetVary(kUnAdjustVary);
+  }
+  MemOperand *memOpnd = aarchCGFunc->CreateMemOperand(MemOperand::kAddrModeBOi,
+                        stBitSize, baseOpnd, nullptr, &offsetOpnd, argInfo.sym);
+  Insn &insn = aarchCGFunc->GetInsnBuilder()->BuildInsn(mOp, regOpnd, *memOpnd);
+  if (aarchCGFunc->GetCG()->GenerateVerboseCG()) {
+    insn.SetComment(std::string("store param: ").append(argInfo.sym->GetName()));
+  }
+  aarchCGFunc->GetCurBB()->AppendInsn(insn);
+}
+
+void AArch64MoveRegArgs::GenerateStrInsn(const ArgInfo &argInfo, AArch64reg reg2, uint32 numFpRegs, uint32 fpSize) {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  int32 stOffset = aarchCGFunc->GetBaseOffset(*argInfo.symLoc);
+  RegOperand *baseOpnd = static_cast<RegOperand*>(aarchCGFunc->GetBaseReg(*argInfo.symLoc));
+  RegOperand &regOpnd =
+      aarchCGFunc->GetOrCreatePhysicalRegisterOperand(argInfo.reg, argInfo.stkSize * kBitsPerByte, argInfo.regType);
+  MemOperand *memOpnd = nullptr;
+  if (MemOperand::IsPIMMOffsetOutOfRange(stOffset, argInfo.symSize * kBitsPerByte) ||
+      (baseReg != nullptr && (lastSegment == argInfo.symLoc->GetMemSegment()))) {
+    if (baseReg == nullptr || lastSegment != argInfo.symLoc->GetMemSegment()) {
+      ImmOperand &immOpnd = aarchCGFunc->CreateImmOperand(stOffset - argInfo.symLoc->GetOffset(), k64BitSize,
+                                                          false);
+      baseReg = &aarchCGFunc->CreateRegisterOperandOfType(kRegTyInt, k8ByteSize);
+      lastSegment = argInfo.symLoc->GetMemSegment();
+      aarchCGFunc->SelectAdd(*baseReg, *baseOpnd, immOpnd, PTY_a64);
+    }
+    OfstOperand &offsetOpnd = aarchCGFunc->CreateOfstOpnd(static_cast<uint64>(argInfo.symLoc->GetOffset()), k32BitSize);
+    if (argInfo.symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed) {
+      offsetOpnd.SetVary(kUnAdjustVary);
+    }
+    memOpnd = aarchCGFunc->CreateMemOperand(MemOperand::kAddrModeBOi,
+                                            argInfo.symSize * kBitsPerByte, *baseReg,
+                                            nullptr, &offsetOpnd, argInfo.sym);
+  } else {
+    OfstOperand &offsetOpnd = aarchCGFunc->CreateOfstOpnd(static_cast<uint64>(static_cast<int64>(stOffset)),
+        k32BitSize);
+    if (argInfo.symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed) {
+      offsetOpnd.SetVary(kUnAdjustVary);
+    }
+    memOpnd = aarchCGFunc->CreateMemOperand(MemOperand::kAddrModeBOi,
+                                            argInfo.symSize * kBitsPerByte, *baseOpnd,
+                                            nullptr, &offsetOpnd, argInfo.sym);
+  }
+
+  MOperator mOp = aarchCGFunc->PickStInsn(argInfo.symSize * kBitsPerByte, argInfo.mirTy->GetPrimType());
+  Insn &insn = aarchCGFunc->GetInsnBuilder()->BuildInsn(mOp, regOpnd, *memOpnd);
+  if (aarchCGFunc->GetCG()->GenerateVerboseCG()) {
+    insn.SetComment(std::string("store param: ").append(argInfo.sym->GetName()));
+  }
+  aarchCGFunc->GetCurBB()->AppendInsn(insn);
+
+  if (argInfo.createTwoStores || argInfo.doMemPairOpt) {
+    /* second half of the struct passing by registers. */
+    uint32 part2BitSize = argInfo.memPairSecondRegSize * kBitsPerByte;
+    GenOneInsn(argInfo, *baseOpnd, part2BitSize, reg2, (stOffset + GetPointerSize()));
+  } else if (numFpRegs > kOneRegister) {
+    uint32 fpSizeBits = fpSize * kBitsPerByte;
+    AArch64reg regFp2 = static_cast<AArch64reg>(argInfo.reg + kOneRegister);
+    GenOneInsn(argInfo, *baseOpnd, fpSizeBits, regFp2, (stOffset + static_cast<int>(fpSize)));
+    if (numFpRegs > kTwoRegister) {
+      AArch64reg regFp3 = static_cast<AArch64reg>(argInfo.reg + kTwoRegister);
+      GenOneInsn(argInfo, *baseOpnd, fpSizeBits, regFp3, (stOffset + static_cast<int>(fpSize * k4BitShift)));
+    }
+    if (numFpRegs > kThreeRegister) {
+      AArch64reg regFp3 = static_cast<AArch64reg>(argInfo.reg + kThreeRegister);
+      GenOneInsn(argInfo, *baseOpnd, fpSizeBits, regFp3, (stOffset + static_cast<int>(fpSize * k8BitShift)));
+    }
+  }
+}
+
+void AArch64MoveRegArgs::MoveRegisterArgs() {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  BB *formerCurBB = aarchCGFunc->GetCurBB();
+  aarchCGFunc->GetDummyBB()->ClearInsns();
+  aarchCGFunc->SetCurBB(*aarchCGFunc->GetDummyBB());
+
+  std::map<uint32, AArch64reg> movePara;
+  std::vector<uint32> moveParaIndex;
+  std::map<uint32, AArch64reg> pairReg;
+  std::vector<uint32> numFpRegs;
+  std::vector<uint32> fpSize;
+  CollectRegisterArgs(movePara, moveParaIndex, pairReg, numFpRegs, fpSize);
+
+  std::vector<uint32>::iterator it;
+  std::vector<uint32>::iterator next;
+  for (it = moveParaIndex.begin(); it != moveParaIndex.end(); ++it) {
+    uint32 firstIndex = *it;
+    ArgInfo firstArgInfo = GetArgInfo(movePara, numFpRegs, fpSize, firstIndex);
+    next = it;
+    ++next;
+    if ((next != moveParaIndex.end()) || (firstArgInfo.doMemPairOpt)) {
+      uint32 secondIndex = (firstArgInfo.doMemPairOpt) ? firstIndex : *next;
+      ArgInfo secondArgInfo = GetArgInfo(movePara, numFpRegs, fpSize, secondIndex);
+      secondArgInfo.reg = (firstArgInfo.doMemPairOpt) ? pairReg[firstIndex] : movePara[secondIndex];
+      secondArgInfo.symSize = (firstArgInfo.doMemPairOpt) ? firstArgInfo.memPairSecondRegSize : secondArgInfo.symSize;
+      secondArgInfo.symLoc = (firstArgInfo.doMemPairOpt) ? secondArgInfo.symLoc :
+          static_cast<AArch64SymbolAlloc *>(aarchCGFunc->GetMemlayout()->GetSymAllocInfo(
+              secondArgInfo.sym->GetStIndex()));
+      /* Make sure they are in same segment if want to use stp */
+      if (((firstArgInfo.isTwoRegParm && secondArgInfo.isTwoRegParm) ||
+          (!firstArgInfo.isTwoRegParm && !secondArgInfo.isTwoRegParm)) &&
+          (firstArgInfo.doMemPairOpt || IsInSameSegment(firstArgInfo, secondArgInfo))) {
+        GenerateStpInsn(firstArgInfo, secondArgInfo);
+        if (!firstArgInfo.doMemPairOpt) {
+          it = next;
+        }
+        continue;
+      }
+    }
+    GenerateStrInsn(firstArgInfo, pairReg[firstIndex], numFpRegs[firstIndex], fpSize[firstIndex]);
+  }
+
+  if (cgFunc->GetCG()->IsLmbc() && cgFunc->GetSpSaveReg()) {
+    /* lmbc uses vreg act as SP when alloca is present due to usage of FP for - offset */
+    aarchCGFunc->GetFirstBB()->InsertAtEnd(*aarchCGFunc->GetDummyBB());
+  } else {
+    /* Java requires insertion at begining as it has fast unwind and other features */
+    aarchCGFunc->GetFirstBB()->InsertAtBeginning(*aarchCGFunc->GetDummyBB());
+  }
+  aarchCGFunc->SetCurBB(*formerCurBB);
+}
+
+void AArch64MoveRegArgs::MoveLocalRefVarToRefLocals(MIRSymbol &mirSym) const {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  PrimType stype = mirSym.GetType()->GetPrimType();
+  uint32 byteSize = GetPrimTypeSize(stype);
+  uint32 bitSize = byteSize * kBitsPerByte;
+  MemOperand &memOpnd = aarchCGFunc->GetOrCreateMemOpnd(mirSym, 0, bitSize, true);
+  RegOperand *regOpnd = nullptr;
+  if (mirSym.IsPreg()) {
+    PregIdx pregIdx = aarchCGFunc->GetFunction().GetPregTab()->GetPregIdxFromPregno(mirSym.GetPreg()->GetPregNo());
+    regOpnd = &aarchCGFunc->GetOrCreateVirtualRegisterOperand(aarchCGFunc->GetVirtualRegNOFromPseudoRegIdx(pregIdx));
+  } else {
+    regOpnd = &aarchCGFunc->GetOrCreateVirtualRegisterOperand(aarchCGFunc->NewVReg(kRegTyInt, k8ByteSize));
+  }
+  Insn &insn = aarchCGFunc->GetInsnBuilder()->BuildInsn(
+      aarchCGFunc->PickLdInsn(GetPrimTypeBitSize(stype), stype), *regOpnd, memOpnd);
+  MemOperand &memOpnd1 = aarchCGFunc->GetOrCreateMemOpnd(mirSym, 0, bitSize, false);
+  Insn &insn1 = aarchCGFunc->GetInsnBuilder()->BuildInsn(
+      aarchCGFunc->PickStInsn(GetPrimTypeBitSize(stype), stype), *regOpnd, memOpnd1);
+  aarchCGFunc->GetCurBB()->InsertInsnBegin(insn1);
+  aarchCGFunc->GetCurBB()->InsertInsnBegin(insn);
+}
+
+void AArch64MoveRegArgs::LoadStackArgsToVReg(MIRSymbol &mirSym) const {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  PrimType stype = mirSym.GetType()->GetPrimType();
+  uint32 byteSize = GetPrimTypeSize(stype);
+  uint32 bitSize = byteSize * kBitsPerByte;
+  MemOperand &memOpnd = aarchCGFunc->GetOrCreateMemOpnd(mirSym, 0, bitSize);
+  PregIdx pregIdx = aarchCGFunc->GetFunction().GetPregTab()->GetPregIdxFromPregno(mirSym.GetPreg()->GetPregNo());
+  RegOperand &dstRegOpnd = aarchCGFunc->GetOrCreateVirtualRegisterOperand(
+      aarchCGFunc->GetVirtualRegNOFromPseudoRegIdx(pregIdx));
+  Insn &insn = aarchCGFunc->GetInsnBuilder()->BuildInsn(
+      aarchCGFunc->PickLdInsn(GetPrimTypeBitSize(stype), stype), dstRegOpnd, memOpnd);
+
+  if (aarchCGFunc->GetCG()->GenerateVerboseCG()) {
+    std::string str = "param: %%";
+    str += std::to_string(mirSym.GetPreg()->GetPregNo());
+    ASSERT(mirSym.GetStorageClass() == kScFormal, "vreg parameters should be kScFormal type.");
+    insn.SetComment(str);
+  }
+
+  aarchCGFunc->GetCurBB()->InsertInsnBegin(insn);
+}
+
+void AArch64MoveRegArgs::MoveArgsToVReg(const CCLocInfo &ploc, MIRSymbol &mirSym) const {
+  auto *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  RegType regType = (ploc.reg0 < V0) ? kRegTyInt : kRegTyFloat;
+  PrimType stype = mirSym.GetType()->GetPrimType();
+  uint32 byteSize = GetPrimTypeSize(stype);
+  uint32 srcBitSize = ((byteSize < k4ByteSize) ? k4ByteSize : byteSize) * kBitsPerByte;
+  PregIdx pregIdx = aarchCGFunc->GetFunction().GetPregTab()->GetPregIdxFromPregno(mirSym.GetPreg()->GetPregNo());
+  RegOperand &dstRegOpnd =
+      aarchCGFunc->GetOrCreateVirtualRegisterOperand(aarchCGFunc->GetVirtualRegNOFromPseudoRegIdx(pregIdx));
+  dstRegOpnd.SetSize(srcBitSize);
+  RegOperand &srcRegOpnd = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(
+      static_cast<AArch64reg>(ploc.reg0), srcBitSize, regType);
+  ASSERT(mirSym.GetStorageClass() == kScFormal, "should be args");
+  MOperator mOp = aarchCGFunc->PickMovBetweenRegs(stype, stype);
+  if (mOp == MOP_vmovvv || mOp == MOP_vmovuu) {
+    VectorInsn &vInsn = aarchCGFunc->GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+    (void)vInsn.AddOpndChain(dstRegOpnd).AddOpndChain(srcRegOpnd);
+    auto *vecSpec1 = aarchCGFunc->GetMemoryPool()->New<VectorRegSpec>(srcBitSize >> k3ByteSize, k8BitSize);
+    auto *vecSpec2 = aarchCGFunc->GetMemoryPool()->New<VectorRegSpec>(srcBitSize >> k3ByteSize, k8BitSize);
+    (void)vInsn.PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2);
+    aarchCGFunc->GetCurBB()->InsertInsnBegin(vInsn);
+    return;
+  }
+  if (CGOptions::DoCGSSA() && (mOp == MOP_wmovrr || mOp == MOP_xmovrr)) {
+    uint32 validBit = byteSize * kBitsPerByte;
+    if (validBit == k8BitSize) {
+      mOp = MOP_wuxtb_vb;
+    } else if (validBit == k16BitSize) {
+      mOp = MOP_wuxth_vb;
+    }
+  }
+  Insn &insn = aarchCGFunc->GetInsnBuilder()->BuildInsn(mOp, dstRegOpnd, srcRegOpnd);
+  if (aarchCGFunc->GetCG()->GenerateVerboseCG()) {
+    std::string str = "param: %%";
+    str += std::to_string(mirSym.GetPreg()->GetPregNo());
+    insn.SetComment(str);
+  }
+  aarchCGFunc->GetCurBB()->InsertInsnBegin(insn);
+}
+
+void AArch64MoveRegArgs::MoveVRegisterArgs() const {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  BB *formerCurBB = aarchCGFunc->GetCurBB();
+  aarchCGFunc->GetDummyBB()->ClearInsns();
+  aarchCGFunc->SetCurBB(*aarchCGFunc->GetDummyBB());
+  AArch64CallConvImpl parmlocator(aarchCGFunc->GetBecommon());
+  CCLocInfo ploc;
+
+  uint32 formalCount = static_cast<uint32>(aarchCGFunc->GetFunction().GetFormalCount());
+  uint32 start = 0;
+  if (formalCount > 0) {
+    MIRFunction *func = const_cast<MIRFunction*>(aarchCGFunc->GetBecommon().GetMIRModule().CurFunction());
+    if (func->IsReturnStruct() && func->IsFirstArgReturn()) {
+      TyIdx tyIdx = func->GetFuncRetStructTyIdx();
+      if (aarchCGFunc->GetBecommon().GetTypeSize(tyIdx) <= k16BitSize) {
+        start = 1;
+      }
+    }
+  }
+  for (uint32 i = start; i < formalCount; ++i) {
+    MIRType *ty = aarchCGFunc->GetFunction().GetNthParamType(i);
+    parmlocator.LocateNextParm(*ty, ploc, i == 0, &aarchCGFunc->GetFunction());
+    MIRSymbol *sym = aarchCGFunc->GetFunction().GetFormal(i);
+
+    /* load locarefvar formals to store in the reflocals. */
+    if (aarchCGFunc->GetFunction().GetNthParamAttr(i).GetAttr(ATTR_localrefvar) && ploc.reg0 == kRinvalid) {
+      MoveLocalRefVarToRefLocals(*sym);
+    }
+
+    if (!sym->IsPreg()) {
+      continue;
+    }
+
+    if (ploc.reg0 == kRinvalid) {
+      /* load stack parameters to the vreg. */
+      LoadStackArgsToVReg(*sym);
+    } else {
+      MoveArgsToVReg(ploc, *sym);
+    }
+  }
+
+  if (cgFunc->GetCG()->IsLmbc() && cgFunc->GetSpSaveReg()) {
+    /* lmbc uses vreg act as SP when alloca is present due to usage of FP for - offset */
+    aarchCGFunc->GetFirstBB()->InsertAtEnd(*aarchCGFunc->GetDummyBB());
+  } else {
+    /* Java requires insertion at begining as it has fast unwind and other features */
+    aarchCGFunc->GetFirstBB()->InsertAtBeginning(*aarchCGFunc->GetDummyBB());
+  }
+  aarchCGFunc->SetCurBB(*formerCurBB);
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_call_conv.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_call_conv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..596af4c9bc179a0a60f5b0a1fd53330f3eedb86b
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_call_conv.cpp
@@ -0,0 +1,744 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_cgfunc.h"
+#include "becommon.h"
+#include "aarch64_call_conv.h"
+
+namespace maplebe {
+using namespace maple;
+
+namespace {
+constexpr int kMaxRegCount = 4;
+
+/*
+ * Refer to ARM IHI 0055C_beta: Procedure Call Standard for
+ * ARM 64-bit Architecture. Table 1.
+ */
+enum AArch64ArgumentClass : uint8 {
+  kAArch64NoClass,
+  kAArch64IntegerClass,
+  kAArch64FloatClass,
+  kAArch64MemoryClass
+};
+
+int32 ProcessNonStructAndNonArrayWhenClassifyAggregate(const MIRType &mirType,
+                                                       AArch64ArgumentClass classes[kMaxRegCount],
+                                                       size_t classesLength) {
+  CHECK_FATAL(classesLength > 0, "classLength must > 0");
+  /* scalar type */
+  switch (mirType.GetPrimType()) {
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_i8:
+    case PTY_u16:
+    case PTY_i16:
+    case PTY_a32:
+    case PTY_u32:
+    case PTY_i32:
+    case PTY_a64:
+    case PTY_ptr:
+    case PTY_ref:
+    case PTY_u64:
+    case PTY_i64:
+      classes[0] = kAArch64IntegerClass;
+      return 1;
+    case PTY_f32:
+    case PTY_f64:
+    case PTY_c64:
+    case PTY_c128:
+      classes[0] = kAArch64FloatClass;
+      return 1;
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+
+  /* should not reach to this point */
+  return 0;
+}
+
+PrimType TraverseStructFieldsForFp(MIRType *ty, uint32 &numRegs) {
+  if (ty->GetKind() == kTypeArray) {
+    MIRArrayType *arrtype = static_cast<MIRArrayType *>(ty);
+    MIRType *pty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrtype->GetElemTyIdx());
+    if (pty->GetKind() == kTypeArray || pty->GetKind() == kTypeStruct) {
+      return TraverseStructFieldsForFp(pty, numRegs);
+    }
+    for (uint32 i = 0; i < arrtype->GetDim(); ++i) {
+      numRegs += arrtype->GetSizeArrayItem(i);
+    }
+    return pty->GetPrimType();
+  } else if (ty->GetKind() == kTypeStruct) {
+    MIRStructType *sttype = static_cast<MIRStructType *>(ty);
+    FieldVector fields = sttype->GetFields();
+    PrimType oldtype = PTY_void;
+    for (uint32 fcnt = 0; fcnt < fields.size(); ++fcnt) {
+      TyIdx fieldtyidx = fields[fcnt].second.first;
+      MIRType *fieldty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldtyidx);
+      PrimType ptype = TraverseStructFieldsForFp(fieldty, numRegs);
+      if (oldtype != PTY_void && oldtype != ptype) {
+        return PTY_void;
+      } else {
+        oldtype = ptype;
+      }
+    }
+    return oldtype;
+  } else {
+    numRegs++;
+    return ty->GetPrimType();
+  }
+}
+
+int32 ClassifyAggregate(const BECommon &be, MIRType &mirType, AArch64ArgumentClass classes[kMaxRegCount],
+                        size_t classesLength, uint32 &fpSize);
+
+uint32 ProcessStructAndUnionWhenClassifyAggregate(const BECommon &be, MIRStructType &structType,
+                                                  AArch64ArgumentClass classes[kMaxRegCount],
+                                                  size_t classesLength, uint32 &fpSize) {
+  CHECK_FATAL(classesLength > 0, "classLength must > 0");
+  uint32 sizeOfTyInDwords = static_cast<uint32>(
+      RoundUp(be.GetTypeSize(structType.GetTypeIndex()), k8ByteSize) >> k8BitShift);
+  bool isF32 = false;
+  bool isF64 = false;
+  uint32 numRegs = 0;
+  for (uint32 f = 0; f < structType.GetFieldsSize(); ++f) {
+    TyIdx fieldTyIdx = structType.GetFieldsElemt(f).second.first;
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    PrimType pType = TraverseStructFieldsForFp(fieldType, numRegs);
+    if (pType == PTY_f32) {
+      if (isF64) {
+        isF64 = false;
+        break;
+      }
+      isF32 = true;
+    } else if (pType == PTY_f64) {
+      if (isF32) {
+        isF32 = false;
+        break;
+      }
+      isF64 = true;
+    } else if (IsPrimitiveVector(pType)) {
+      isF64 = true;
+      break;
+    } else {
+      isF32 = isF64 = false;
+      break;
+    }
+  }
+  if (isF32 || isF64) {
+    CHECK_FATAL(numRegs <= classesLength, "ClassifyAggregate: num regs exceed limit");
+    for (uint32 i = 0; i < numRegs; ++i) {
+      classes[i] = kAArch64FloatClass;
+    }
+
+    fpSize = isF32 ? k4ByteSize : k8ByteSize;
+    if (structType.GetKind() == kTypeUnion) {
+      /* For Union, numRegs is calculated for the maximum size element in this Union */
+      return sizeOfTyInDwords;
+    }
+    return numRegs;
+  }
+
+  classes[0] = kAArch64IntegerClass;
+  if (sizeOfTyInDwords == kDwordSizeTwo) {
+    classes[1] = kAArch64IntegerClass;
+  }
+  ASSERT(sizeOfTyInDwords <= classesLength, "sizeOfTyInDwords exceed limit");
+  return sizeOfTyInDwords;
+}
+
+/*
+ * Analyze the given aggregate using the rules given by the ARM 64-bit ABI and
+ * return the number of doublewords to be passed in registers; the classes of
+ * the doublewords are returned in parameter "classes"; if 0 is returned, it
+ * means the whole aggregate is passed in memory.
+ */
+int32 ClassifyAggregate(const BECommon &be, MIRType &mirType, AArch64ArgumentClass classes[kMaxRegCount],
+                        size_t classesLength, uint32 &fpSize) {
+  CHECK_FATAL(classesLength > 0, "invalid index");
+  uint64 sizeOfTy = be.GetTypeSize(mirType.GetTypeIndex());
+  /* Rule B.3.
+   * If the argument type is a Composite Type that is larger than 16 bytes
+   * then the argument is copied to memory allocated by the caller and
+   * the argument is replaced by a pointer to the copy.
+   */
+  if ((sizeOfTy > k16ByteSize) || (sizeOfTy == 0)) {
+    return 0;
+  }
+
+  /*
+   * An argument of any Integer class takes up an integer register
+   * which is a single double-word.
+   * Rule B.4. The size of an argument of composite type is rounded up to the nearest
+   * multiple of 8 bytes.
+   */
+  int64 sizeOfTyInDwords = static_cast<int64>(RoundUp(sizeOfTy, k8ByteSize) >> k8BitShift);
+  ASSERT(sizeOfTyInDwords > 0, "sizeOfTyInDwords should be sizeOfTyInDwords > 0");
+  ASSERT(sizeOfTyInDwords <= kTwoRegister, "sizeOfTyInDwords should be <= 2");
+  int64 i;
+  for (i = 0; i < sizeOfTyInDwords; ++i) {
+    classes[i] = kAArch64NoClass;
+  }
+  if ((mirType.GetKind() != kTypeStruct) && (mirType.GetKind() != kTypeArray) && (mirType.GetKind() != kTypeUnion)) {
+    return ProcessNonStructAndNonArrayWhenClassifyAggregate(mirType, classes, classesLength);
+  }
+  if (mirType.GetKind() == kTypeStruct || mirType.GetKind() == kTypeUnion) {
+    MIRStructType &structType = static_cast<MIRStructType&>(mirType);
+    return static_cast<int32>(ProcessStructAndUnionWhenClassifyAggregate(be, structType, classes,
+                                                                         classesLength, fpSize));
+  }
+  /* post merger clean-up */
+  for (i = 0; i < sizeOfTyInDwords; ++i) {
+    if (classes[i] == kAArch64MemoryClass) {
+      return 0;
+    }
+  }
+  return static_cast<int32>(sizeOfTyInDwords);
+}
+}
+
+/* external interface to look for pure float struct */
+uint32 AArch64CallConvImpl::FloatParamRegRequired(MIRStructType &structType, uint32 &fpSize) {
+  if (structType.GetSize() > k32ByteSize) {
+    return 0;
+  }
+  AArch64ArgumentClass classes[kMaxRegCount];
+  uint32 numRegs = ProcessStructAndUnionWhenClassifyAggregate(beCommon, structType, classes, kMaxRegCount, fpSize);
+  if (numRegs == 0) {
+    return 0;
+  }
+
+  bool isPure = true;
+  for (uint i = 0; i < numRegs; ++i) {
+    ASSERT(i < kMaxRegCount, "i should be lower than kMaxRegCount");
+    if (classes[i] != kAArch64FloatClass) {
+      isPure = false;
+      break;
+    }
+  }
+  if (isPure) {
+    return numRegs;
+  }
+  return 0;
+}
+
+void AArch64CallConvImpl::InitCCLocInfo(CCLocInfo &pLoc) const {
+  pLoc.reg0 = kRinvalid;
+  pLoc.reg1 = kRinvalid;
+  pLoc.reg2 = kRinvalid;
+  pLoc.reg3 = kRinvalid;
+  pLoc.memOffset = nextStackArgAdress;
+  pLoc.fpSize = 0;
+  pLoc.numFpPureRegs = 0;
+}
+
+int32 AArch64CallConvImpl::LocateRetVal(MIRType &retType, CCLocInfo &pLoc) {
+  InitCCLocInfo(pLoc);
+  uint32 retSize = beCommon.GetTypeSize(retType.GetTypeIndex().GetIdx());
+  if (retSize == 0) {
+    return 0;    /* size 0 ret val */
+  }
+  if (retSize <= k16ByteSize) {
+    /* For return struct size less or equal to 16 bytes, the values */
+    /* are returned in register pairs. */
+    AArch64ArgumentClass classes[kMaxRegCount] = { kAArch64NoClass }; /* Max of four floats. */
+    uint32 fpSize;
+    uint32 numRegs = static_cast<uint32>(ClassifyAggregate(beCommon, retType, classes, sizeof(classes), fpSize));
+    if (classes[0] == kAArch64FloatClass) {
+      CHECK_FATAL(numRegs <= kMaxRegCount, "LocateNextParm: illegal number of regs");
+      AllocateNSIMDFPRegisters(pLoc, numRegs);
+      pLoc.numFpPureRegs = numRegs;
+      pLoc.fpSize = fpSize;
+      return 0;
+    } else {
+      CHECK_FATAL(numRegs <= kTwoRegister, "LocateNextParm: illegal number of regs");
+      if (numRegs == kOneRegister) {
+        pLoc.reg0 = AllocateGPRegister();
+      } else {
+        AllocateTwoGPRegisters(pLoc);
+      }
+      return 0;
+    }
+  } else {
+    /* For return struct size > 16 bytes the pointer returns in x8. */
+    pLoc.reg0 = R8;
+    return GetPointerSize();
+  }
+}
+
+/*
+ * Refer to ARM IHI 0055C_beta: Procedure Call Standard for
+ * the ARM 64-bit Architecture. $5.4.2
+ *
+ * For internal only functions, we may want to implement
+ * our own rules as Apple IOS has done. Maybe we want to
+ * generate two versions for each of externally visible functions,
+ * one conforming to the ARM standard ABI, and the other for
+ * internal only use.
+ *
+ * LocateNextParm should be called with each parameter in the parameter list
+ * starting from the beginning, one call per parameter in sequence; it returns
+ * the information on how each parameter is passed in pLoc
+ *
+ * *** CAUTION OF USE: ***
+ * If LocateNextParm is called for function formals, third argument isFirst is true.
+ * LocateNextParm is then checked against a function parameter list.  All other calls
+ * of LocateNextParm are against caller's argument list must not have isFirst set,
+ * or it will be checking the caller's enclosing function.
+ */
+int32 AArch64CallConvImpl::LocateNextParm(MIRType &mirType, CCLocInfo &pLoc, bool isFirst, MIRFunction *tFunc) {
+  InitCCLocInfo(pLoc);
+
+  bool is64x1vec = false;
+  if (tFunc != nullptr && tFunc->GetParamSize() > 0) {
+    is64x1vec = tFunc->GetNthParamAttr(paramNum).GetAttr(ATTR_oneelem_simd) != 0;
+  }
+
+  if (isFirst) {
+    MIRFunction *func = tFunc != nullptr ? tFunc : const_cast<MIRFunction *>(beCommon.GetMIRModule().CurFunction());
+    if (func->IsFirstArgReturn()) {
+      TyIdx tyIdx = func->GetFuncRetStructTyIdx();
+      size_t size = beCommon.GetTypeSize(tyIdx);
+      if (size == 0) {
+        /* For return struct size 0 there is no return value. */
+        return 0;
+      }
+      /* For return struct size > 16 bytes the pointer returns in x8. */
+      pLoc.reg0 = R8;
+      return GetPointerSize();
+    }
+  }
+  uint64 typeSize = beCommon.GetTypeSize(mirType.GetTypeIndex());
+  if (typeSize == 0) {
+    return 0;
+  }
+  int32 typeAlign = beCommon.GetTypeAlign(mirType.GetTypeIndex());
+  /*
+   * Rule C.12 states that we do round nextStackArgAdress up before we use its value
+   * according to the alignment requirement of the argument being processed.
+   * We do the rounding up at the end of LocateNextParm(),
+   * so we want to make sure our rounding up is correct.
+   */
+  ASSERT((nextStackArgAdress & (std::max(typeAlign, static_cast<int32>(k8ByteSize)) - 1)) == 0,
+         "C.12 alignment requirement is violated");
+  pLoc.memSize = static_cast<int32>(typeSize);
+  ++paramNum;
+
+  int32 aggCopySize = 0;
+  switch (mirType.GetPrimType()) {
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_i8:
+    case PTY_u16:
+    case PTY_i16:
+    case PTY_a32:
+    case PTY_u32:
+    case PTY_i32:
+    case PTY_ptr:
+    case PTY_ref:
+    case PTY_a64:
+    case PTY_u64:
+    case PTY_i64:
+    case PTY_i128:
+    case PTY_u128:
+      /* Rule C.7 */
+      typeSize = k8ByteSize;
+      pLoc.reg0 = is64x1vec ? AllocateSIMDFPRegister() : AllocateGPRegister();
+      ASSERT(nextGeneralRegNO <= AArch64Abi::kNumIntParmRegs, "RegNo should be pramRegNO");
+      break;
+    /*
+     * for c64 complex numbers, we assume
+     * - callers marshall the two f32 numbers into one f64 register
+     * - callees de-marshall one f64 value into the real and the imaginery part
+     */
+    case PTY_f32:
+    case PTY_f64:
+    case PTY_c64:
+    case PTY_v2i32:
+    case PTY_v4i16:
+    case PTY_v8i8:
+    case PTY_v2u32:
+    case PTY_v4u16:
+    case PTY_v8u8:
+    case PTY_v2f32:
+      /* Rule C.1 */
+      ASSERT(GetPrimTypeSize(PTY_f64) == k8ByteSize, "unexpected type size");
+      typeSize = k8ByteSize;
+      pLoc.reg0 = AllocateSIMDFPRegister();
+      break;
+    /*
+     * for c128 complex numbers, we assume
+     * - callers marshall the two f64 numbers into one f128 register
+     * - callees de-marshall one f128 value into the real and the imaginery part
+     */
+    case PTY_c128:
+    case PTY_v2i64:
+    case PTY_v4i32:
+    case PTY_v8i16:
+    case PTY_v16i8:
+    case PTY_v2u64:
+    case PTY_v4u32:
+    case PTY_v8u16:
+    case PTY_v16u8:
+    case PTY_v2f64:
+    case PTY_v4f32:
+      /* SIMD-FP registers have 128-bits. */
+      pLoc.reg0 = AllocateSIMDFPRegister();
+      ASSERT(nextFloatRegNO <= AArch64Abi::kNumFloatParmRegs, "regNO should not be greater than kNumFloatParmRegs");
+      ASSERT(typeSize == k16ByteSize, "unexpected type size");
+      break;
+    /*
+     * case of quad-word integer:
+     * we don't support java yet.
+     * if (has-16-byte-alignment-requirement)
+     * nextGeneralRegNO = (nextGeneralRegNO+1) & ~1; // C.8 round it up to the next even number
+     * try allocate two consecutive registers at once.
+     */
+    /* case PTY_agg */
+    case PTY_agg: {
+      aggCopySize = ProcessPtyAggWhenLocateNextParm(mirType, pLoc, typeSize, typeAlign);
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+
+  /* Rule C.12 */
+  if (pLoc.reg0 == kRinvalid) {
+    /* being passed in memory */
+    nextStackArgAdress = pLoc.memOffset + static_cast<int32>(static_cast<int64>(typeSize));
+  }
+  return aggCopySize;
+}
+
+int32 AArch64CallConvImpl::ProcessPtyAggWhenLocateNextParm(MIRType &mirType, CCLocInfo &pLoc, uint64 &typeSize,
+                                                           int32 typeAlign) {
+  /*
+   * In AArch64, integer-float or float-integer
+   * argument passing is not allowed. All should go through
+   * integer-integer.
+   * In the case where a struct is homogeneous composed of one of the fp types,
+   * either all single fp or all double fp, then it can be passed by float-float.
+   */
+  AArch64ArgumentClass classes[kMaxRegCount] = { kAArch64NoClass };
+  typeSize = beCommon.GetTypeSize(mirType.GetTypeIndex().GetIdx());
+  int32 aggCopySize = 0;
+  if (typeSize > k16ByteSize) {
+    aggCopySize = static_cast<int32>(RoundUp(typeSize, GetPointerSize()));
+  }
+  /*
+   * alignment requirement
+   * Note. This is one of a few things iOS diverges from
+   * the ARM 64-bit standard. They don't observe the round-up requirement.
+   */
+  if (typeAlign == k16ByteSizeInt) {
+    RoundNGRNUpToNextEven();
+  }
+
+  uint32 fpSize;
+  uint32 numRegs = static_cast<uint32>(
+      ClassifyAggregate(beCommon, mirType, classes, sizeof(classes) / sizeof(AArch64ArgumentClass), fpSize));
+  if (classes[0] == kAArch64FloatClass) {
+    CHECK_FATAL(numRegs <= kMaxRegCount, "LocateNextParm: illegal number of regs");
+    typeSize = k8ByteSize;
+    AllocateNSIMDFPRegisters(pLoc, numRegs);
+    pLoc.numFpPureRegs = numRegs;
+    pLoc.fpSize = fpSize;
+  } else if (numRegs == 1) {
+    /* passing in registers */
+    typeSize = k8ByteSize;
+    if (classes[0] == kAArch64FloatClass) {
+      CHECK_FATAL(false, "param passing in FP reg not allowed here");
+    } else {
+      pLoc.reg0 = AllocateGPRegister();
+      /* Rule C.11 */
+      ASSERT((pLoc.reg0 != kRinvalid) || (nextGeneralRegNO == AArch64Abi::kNumIntParmRegs),
+             "reg0 should not be kRinvalid or nextGeneralRegNO should equal kNumIntParmRegs");
+    }
+  } else if (numRegs == kTwoRegister) {
+    /* Other aggregates with 8 < size <= 16 bytes can be allocated in reg pair */
+    ASSERT(classes[0] == kAArch64IntegerClass || classes[0] == kAArch64NoClass,
+           "classes[0] must be either integer class or no class");
+    ASSERT(classes[1] == kAArch64IntegerClass || classes[1] == kAArch64NoClass,
+           "classes[1] must be either integer class or no class");
+    AllocateTwoGPRegisters(pLoc);
+    /* Rule C.11 */
+    if (pLoc.reg0 == kRinvalid) {
+      nextGeneralRegNO = AArch64Abi::kNumIntParmRegs;
+    }
+  } else {
+    /*
+     * 0 returned from ClassifyAggregate(). This means the whole data
+     * is passed thru memory.
+     * Rule B.3.
+     *  If the argument type is a Composite Type that is larger than 16
+     *  bytes then the argument is copied to memory allocated by the
+     *  caller and the argument is replaced by a pointer to the copy.
+     *
+     * Try to allocate an integer register
+     */
+    typeSize = k8ByteSize;
+    pLoc.reg0 = AllocateGPRegister();
+    pLoc.memSize = k8ByteSizeInt;  /* byte size of a pointer in AArch64 */
+    if (pLoc.reg0 != kRinvalid) {
+      numRegs = 1;
+    }
+  }
+  /* compute rightpad */
+  if ((numRegs == 0) || (pLoc.reg0 == kRinvalid)) {
+    /* passed in memory */
+    typeSize = RoundUp(static_cast<uint64>(static_cast<int64>(pLoc.memSize)), k8ByteSize);
+  }
+  return aggCopySize;
+}
+
+/*
+ * instantiated with the type of the function return value, it describes how
+ * the return value is to be passed back to the caller
+ *
+ *  Refer to ARM IHI 0055C_beta: Procedure Call Standard for
+ *  the ARM 64-bit Architecture. $5.5
+ *  "If the type, T, of the result of a function is such that
+ *     void func(T arg)
+ *   would require that 'arg' be passed as a value in a register
+ *   (or set of registers) according to the rules in $5.4 Parameter
+ *   Passing, then the result is returned in the same registers
+ *   as would be used for such an argument.
+ */
+void AArch64CallConvImpl::InitReturnInfo(MIRType &retTy, CCLocInfo &ccLocInfo) {
+  PrimType pType = retTy.GetPrimType();
+  switch (pType) {
+    case PTY_void:
+      break;
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_i8:
+    case PTY_u16:
+    case PTY_i16:
+    case PTY_a32:
+    case PTY_u32:
+    case PTY_i32:
+      ccLocInfo.regCount = 1;
+      ccLocInfo.reg0 = AArch64Abi::kIntReturnRegs[0];
+      ccLocInfo.primTypeOfReg0 = IsSignedInteger(pType) ? PTY_i32 : PTY_u32;  /* promote the type */
+      return;
+
+    case PTY_ptr:
+    case PTY_ref:
+      CHECK_FATAL(false, "PTY_ptr should have been lowered");
+      return;
+
+    case PTY_a64:
+    case PTY_u64:
+    case PTY_i64:
+    case PTY_i128:
+    case PTY_u128:
+      ccLocInfo.regCount = 1;
+      ccLocInfo.reg0 = AArch64Abi::kIntReturnRegs[0];
+      ccLocInfo.primTypeOfReg0 = IsSignedInteger(pType) ? PTY_i64 : PTY_u64;  /* promote the type */
+      return;
+
+    /*
+     * for c64 complex numbers, we assume
+     * - callers marshall the two f32 numbers into one f64 register
+     * - callees de-marshall one f64 value into the real and the imaginery part
+     */
+    case PTY_f32:
+    case PTY_f64:
+    case PTY_c64:
+    case PTY_v2i32:
+    case PTY_v4i16:
+    case PTY_v8i8:
+    case PTY_v2u32:
+    case PTY_v4u16:
+    case PTY_v8u8:
+    case PTY_v2f32:
+
+    /*
+     * for c128 complex numbers, we assume
+     * - callers marshall the two f64 numbers into one f128 register
+     * - callees de-marshall one f128 value into the real and the imaginery part
+     */
+    case PTY_c128:
+    case PTY_v2i64:
+    case PTY_v4i32:
+    case PTY_v8i16:
+    case PTY_v16i8:
+    case PTY_v2u64:
+    case PTY_v4u32:
+    case PTY_v8u16:
+    case PTY_v16u8:
+    case PTY_v2f64:
+    case PTY_v4f32:
+      ccLocInfo.regCount = 1;
+      ccLocInfo.reg0 = AArch64Abi::kFloatReturnRegs[0];
+      ccLocInfo.primTypeOfReg0 = pType;
+      return;
+
+    /*
+     * Refer to ARM IHI 0055C_beta: Procedure Call Standard for
+     * the ARM 64-bit Architecture. $5.5
+     * "Otherwise, the caller shall reserve a block of memory of
+     * sufficient size and alignment to hold the result. The
+     * address of the memory block shall be passed as an additional
+     * argument to the function in x8. The callee may modify the
+     * result memory block at any point during the execution of the
+     * subroutine (there is no requirement for the callee to preserve
+     * the value stored in x8)."
+     */
+    case PTY_agg: {
+      uint64 size = beCommon.GetTypeSize(retTy.GetTypeIndex());
+      if ((size > k16ByteSize) || (size == 0)) {
+        /*
+         * The return value is returned via memory.
+         * The address is in X8 and passed by the caller.
+         */
+        SetupToReturnThroughMemory(ccLocInfo);
+        return;
+      }
+      uint32 fpSize;
+      AArch64ArgumentClass classes[kMaxRegCount] = { kAArch64NoClass };
+      ccLocInfo.regCount = static_cast<uint8>(ClassifyAggregate(beCommon, retTy, classes,
+          sizeof(classes) / sizeof(AArch64ArgumentClass), fpSize));
+      if (classes[0] == kAArch64FloatClass) {
+        switch (ccLocInfo.regCount) {
+          case kFourRegister:
+            ccLocInfo.reg3 = AArch64Abi::kFloatReturnRegs[3];
+            break;
+          case kThreeRegister:
+            ccLocInfo.reg2 = AArch64Abi::kFloatReturnRegs[2];
+            break;
+          case kTwoRegister:
+            ccLocInfo.reg1 = AArch64Abi::kFloatReturnRegs[1];
+            break;
+          case kOneRegister:
+            ccLocInfo.reg0 = AArch64Abi::kFloatReturnRegs[0];
+            break;
+          default:
+            CHECK_FATAL(0, "AArch64CallConvImpl: unsupported");
+        }
+        if (fpSize == k4ByteSize) {
+          ccLocInfo.primTypeOfReg0 = ccLocInfo.primTypeOfReg1 = PTY_f32;
+        } else {
+          ccLocInfo.primTypeOfReg0 = ccLocInfo.primTypeOfReg1 = PTY_f64;
+        }
+        return;
+      } else if (ccLocInfo.regCount == 0) {
+        SetupToReturnThroughMemory(ccLocInfo);
+        return;
+      } else {
+        if (ccLocInfo.regCount == 1) {
+          /* passing in registers */
+          if (classes[0] == kAArch64FloatClass) {
+            ccLocInfo.reg0 = AArch64Abi::kFloatReturnRegs[0];
+            ccLocInfo.primTypeOfReg0 = PTY_f64;
+          } else {
+            ccLocInfo.reg0 = AArch64Abi::kIntReturnRegs[0];
+            ccLocInfo.primTypeOfReg0 = PTY_i64;
+          }
+        } else {
+          ASSERT(ccLocInfo.regCount <= k2ByteSize, "reg count from ClassifyAggregate() should be 0, 1, or 2");
+          ASSERT(classes[0] == kAArch64IntegerClass, "error val :classes[0]");
+          ASSERT(classes[1] == kAArch64IntegerClass, "error val :classes[1]");
+          ccLocInfo.reg0 = AArch64Abi::kIntReturnRegs[0];
+          ccLocInfo.primTypeOfReg0 = PTY_i64;
+          ccLocInfo.reg1 = AArch64Abi::kIntReturnRegs[1];
+          ccLocInfo.primTypeOfReg1 = PTY_i64;
+        }
+        return;
+      }
+    }
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+}
+
+void AArch64CallConvImpl::SetupSecondRetReg(const MIRType &retTy2, CCLocInfo &pLoc) const {
+  ASSERT(pLoc.reg1 == kRinvalid, "make sure reg1 equal kRinvalid");
+  PrimType pType = retTy2.GetPrimType();
+  switch (pType) {
+    case PTY_void:
+      break;
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_i8:
+    case PTY_u16:
+    case PTY_i16:
+    case PTY_a32:
+    case PTY_u32:
+    case PTY_i32:
+    case PTY_ptr:
+    case PTY_ref:
+    case PTY_a64:
+    case PTY_u64:
+    case PTY_i64:
+      pLoc.reg1 = AArch64Abi::kIntReturnRegs[1];
+      pLoc.primTypeOfReg1 = IsSignedInteger(pType) ? PTY_i64 : PTY_u64;  /* promote the type */
+      break;
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+}
+
+/*
+ * From "ARM Procedure Call Standard for ARM 64-bit Architecture"
+ *     ARM IHI 0055C_beta, 6th November 2013
+ * $ 5.1 machine Registers
+ * $ 5.1.1 General-Purpose Registers
+ *  <Table 2>                Note
+ *  SP       Stack Pointer
+ *  R30/LR   Link register   Stores the return address.
+ *                           We push it into stack along with FP on function
+ *                           entry using STP and restore it on function exit
+ *                           using LDP even if the function is a leaf (i.e.,
+ *                           it does not call any other function) because it
+ *                           is free (we have to store FP anyway).  So, if a
+ *                           function is a leaf, we may use it as a temporary
+ *                           register.
+ *  R29/FP   Frame Pointer
+ *  R19-R28  Callee-saved
+ *           registers
+ *  R18      Platform reg    Can we use it as a temporary register?
+ *  R16,R17  IP0,IP1         Maybe used as temporary registers. Should be
+ *                           given lower priorities. (i.e., we push them
+ *                           into the free register stack before the others)
+ *  R9-R15                   Temporary registers, caller-saved
+ *  Note:
+ *  R16 and R17 may be used by a linker as a scratch register between
+ *  a routine and any subroutine it calls. They can also be used within a
+ *  routine to hold intermediate values between subroutine calls.
+ *
+ *  The role of R18 is platform specific. If a platform ABI has need of
+ *  a dedicated general purpose register to carry inter-procedural state
+ *  (for example, the thread context) then it should use this register for
+ *  that purpose. If the platform ABI has no such requirements, then it should
+ *  use R18 as an additional temporary register. The platform ABI specification
+ *  must document the usage for this register.
+ *
+ *  A subroutine invocation must preserve the contents of the registers R19-R29
+ *  and SP. All 64 bits of each value stored in R19-R29 must be preserved, even
+ *  when using the ILP32 data model.
+ *
+ *  $ 5.1.2 SIMD and Floating-Point Registers
+ *
+ *  The first eight registers, V0-V7, are used to pass argument values into
+ *  a subroutine and to return result values from a function. They may also
+ *  be used to hold intermediate values within a routine.
+ *
+ *  V8-V15 must be preserved by a callee across subroutine calls; the
+ *  remaining registers do not need to be preserved( or caller-saved).
+ *  Additionally, only the bottom 64 bits of each value stored in V8-
+ *  V15 need to be preserved.
+ */
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cfgo.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cfgo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1048dc54911647dc82221e97aa52cedd69400183
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cfgo.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "aarch64_cfgo.h"
+#include "aarch64_isa.h"
+
+namespace maplebe {
+/* Initialize cfg optimization patterns */
+void AArch64CFGOptimizer::InitOptimizePatterns() {
+  (void)diffPassPatterns.emplace_back(memPool->New<ChainingPattern>(*cgFunc));
+  (void)diffPassPatterns.emplace_back(memPool->New<SequentialJumpPattern>(*cgFunc));
+  AArch64FlipBRPattern *brOpt = memPool->New<AArch64FlipBRPattern>(*cgFunc);
+  if (GetPhase() == kCfgoPostRegAlloc) {
+    brOpt->SetPhase(kCfgoPostRegAlloc);
+  }
+  (void)diffPassPatterns.emplace_back(brOpt);
+  (void)diffPassPatterns.emplace_back(memPool->New<DuplicateBBPattern>(*cgFunc));
+  (void)diffPassPatterns.emplace_back(memPool->New<UnreachBBPattern>(*cgFunc));
+  (void)diffPassPatterns.emplace_back(memPool->New<EmptyBBPattern>(*cgFunc));
+}
+
+uint32 AArch64FlipBRPattern::GetJumpTargetIdx(const Insn &insn) {
+  return AArch64isa::GetJumpTargetIdx(insn);
+}
+MOperator AArch64FlipBRPattern::FlipConditionOp(MOperator flippedOp) {
+  return AArch64isa::FlipConditionOp(flippedOp);
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cfi_generator.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cfi_generator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..052d274c1566ef3af1cfa490c356293019ca03f3
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cfi_generator.cpp
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_cfi_generator.h"
+#include "aarch64_memlayout.h"
+#include "aarch64_cgfunc.h"
+namespace maplebe {
+void AArch64GenCfi::GenerateRegisterSaveDirective(BB &bb) {
+  int32 stackFrameSize = static_cast<int32>(
+      static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize());
+  int32 argsToStkPassSize = static_cast<int32>(cgFunc.GetMemlayout()->SizeOfArgsToStackPass());
+  int32 cfiOffset = stackFrameSize;
+  Insn &stackDefNextInsn = FindStackDefNextInsn(bb);
+  InsertCFIDefCfaOffset(bb, stackDefNextInsn, cfiOffset);
+  cfiOffset = GetOffsetFromCFA() - argsToStkPassSize;
+  AArch64CGFunc &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+
+  if (useFP) {
+    (void)bb.InsertInsnBefore(stackDefNextInsn, aarchCGFunc.CreateCfiOffsetInsn(stackBaseReg, -cfiOffset, k64BitSize));
+  }
+  (void)bb.InsertInsnBefore(stackDefNextInsn, aarchCGFunc.CreateCfiOffsetInsn(RLR, -cfiOffset + kOffset8MemPos, k64BitSize));
+
+  /* change CFA register and offset */
+  if (useFP) {
+    bool isLmbc = cgFunc.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc;
+    if ((argsToStkPassSize > 0) || isLmbc) {
+      (void)bb.InsertInsnBefore(stackDefNextInsn, aarchCGFunc.CreateCfiDefCfaInsn(stackBaseReg,
+          static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize() - argsToStkPassSize,
+          k64BitSize));
+    } else {
+      (void)bb.InsertInsnBefore(
+          stackDefNextInsn, cgFunc.GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_def_cfa_register).AddOpndChain(
+              cgFunc.CreateCfiRegOperand(stackBaseReg, k64BitSize)));
+    }
+  }
+
+  if (CGOptions::IsNoCalleeCFI()) {
+    return;
+  }
+
+  /* callee save register cfi offset */
+  auto &regsToSave = (aarchCGFunc.GetProEpilogSavedRegs().empty()) ?
+      aarchCGFunc.GetCalleeSavedRegs() : aarchCGFunc.GetProEpilogSavedRegs();
+  if (regsToSave.empty()) {
+    return;
+  }
+
+  auto it = regsToSave.begin();
+  /* skip the first two registers */
+  CHECK_FATAL(*it == RFP, "The first callee saved reg is expected to be RFP");
+  ++it;
+  CHECK_FATAL(*it == RLR, "The second callee saved reg is expected to be RLR");
+  ++it;
+  int32 offset = cgFunc.GetMemlayout()->GetCalleeSaveBaseLoc();
+  for (; it != regsToSave.end(); ++it) {
+    AArch64reg reg = *it;
+    stackFrameSize -= static_cast<int32>(cgFunc.GetMemlayout()->SizeOfArgsToStackPass());
+    cfiOffset = stackFrameSize - offset;
+    (void)bb.InsertInsnBefore(stackDefNextInsn, aarchCGFunc.CreateCfiOffsetInsn(reg, -cfiOffset, k64BitSize));
+    /* On AArch64, kIntregBytelen == 8 */
+    offset += kIntregBytelen;
+  }
+}
+
+void AArch64GenCfi::GenerateRegisterRestoreDirective(BB &bb) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  auto &regsToSave = (aarchCGFunc.GetProEpilogSavedRegs().empty()) ?
+      aarchCGFunc.GetCalleeSavedRegs() : aarchCGFunc.GetProEpilogSavedRegs();
+
+  Insn *returnInsn = bb.GetLastMachineInsn();
+  CHECK_NULL_FATAL(returnInsn);
+  if (!regsToSave.empty()) {
+    auto it = regsToSave.begin();
+    CHECK_FATAL(*it == RFP, "The first callee saved reg is expected to be RFP");
+    ++it;
+    CHECK_FATAL(*it == RLR, "The second callee saved reg is expected to be RLR");
+    ++it;
+
+    if (!CGOptions::IsNoCalleeCFI()) {
+      for (; it != regsToSave.end(); ++it) {
+        AArch64reg reg = *it;
+        (void)bb.InsertInsnBefore(*returnInsn, aarchCGFunc.CreateCfiRestoreInsn(reg, k64BitSize));
+      }
+    }
+
+    if (useFP) {
+      (void)bb.InsertInsnBefore(*returnInsn, aarchCGFunc.CreateCfiRestoreInsn(stackBaseReg, k64BitSize));
+    }
+    (void)bb.InsertInsnBefore(*returnInsn, aarchCGFunc.CreateCfiRestoreInsn(RLR, k64BitSize));
+  }
+  /* in aarch64 R31 is sp */
+  (void)bb.InsertInsnBefore(*returnInsn, aarchCGFunc.CreateCfiDefCfaInsn(R31, 0, k64BitSize));
+}
+} /* maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cg.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aead8709591e217329050cb97d1af280b9524a75
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cg.cpp
@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_cg.h"
+#include "mir_builder.h"
+#include "becommon.h"
+#include "label_creation.h"
+#include "alignment.h"
+
+namespace maplebe {
+#include "immvalid.def"
+#define DEFINE_MOP(...) {__VA_ARGS__},
+const InsnDesc AArch64CG::kMd[kMopLast] = {
+#include "abstract_mmir.def"
+#include "aarch64_md.def"
+#include "aarch64_mem_md.def"
+};
+#undef DEFINE_MOP
+
+std::array<std::array<const std::string, kAllRegNum>, kIntRegTypeNum> AArch64CG::intRegNames = {
+  std::array<const std::string, kAllRegNum> {
+      "err",   "err0",  "err1",  "err2",  "err3",  "err4",  "err5",  "err6",  "err7",  "err8",  "err9",  "err10",
+      "err11", "err12", "err13", "err14", "err15", "err16", "err17", "err18", "err19", "err20", "err21", "err22",
+      "err23", "err24", "err25", "err26", "err27", "err28", "err",   "err",   "err",   "errsp", "errzr", /* x29 is fp */
+      "b0",    "b1",    "b2",    "b3",    "b4",    "b5",    "b6",    "b7",    "b8",    "b9",    "b10",   "b11",
+      "b12",   "b13",   "b14",   "b15",   "b16",   "b17",   "b18",   "b19",   "b20",   "b21",   "b22",   "b23",
+      "b24",   "b25",   "b26",   "b27",   "b28",   "b29",   "b30",   "b31",   "errMaxRegNum",   "rflag" },
+  std::array<const std::string, kAllRegNum> {
+      "err",   "err0",  "err1",  "err2",  "err3",  "err4",  "err5",  "err6",  "err7",  "err8",  "err9",  "err10",
+      "err11", "err12", "err13", "err14", "err15", "err16", "err17", "err18", "err19", "err20", "err21", "err22",
+      "err23", "err24", "err25", "err26", "err27", "err28", "err29", "err30", "err31", "errsp", "errzr", /* x29 is fp */
+      "h0",    "h1",    "h2",    "h3",    "h4",    "h5",    "h6",    "h7",    "h8",    "h9",    "h10",   "h11",
+      "h12",   "h13",   "h14",   "h15",   "h16",   "h17",   "h18",   "h19",   "h20",   "h21",   "h22",   "h23",
+      "h24",   "h25",   "h26",   "h27",   "h28",   "h29",   "h30",   "h31",   "errMaxRegNum",   "rflag" },
+  std::array<const std::string, kAllRegNum> {
+      "err", "w0",  "w1",  "w2",  "w3",  "w4",  "w5",  "w6",  "w7",  "w8",  "w9",  "w10", "w11", "w12", "w13", "w14",
+      "w15", "w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23", "w24", "w25", "w26", "w27", "w28",
+      "w29", "err", "err", "wsp", "wzr", /* x29 is fp */
+      "s0",  "s1",  "s2",  "s3",  "s4",  "s5",  "s6",  "s7",  "s8",  "s9",  "s10", "s11", "s12", "s13", "s14", "s15",
+      "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
+      "errMaxRegNum", "rflag" },
+  std::array<const std::string, kAllRegNum> {
+      "err", "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",  "x8",  "x9",  "x10", "x11", "x12", "x13", "x14",
+      "x15", "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x29", "x30",
+      "x29" /* use X40 when debug */, "sp",  "xzr", /* x29 is fp */
+      "d0",  "d1",  "d2",  "d3",  "d4",  "d5",  "d6",  "d7",  "d8",  "d9",  "d10", "d11", "d12", "d13", "d14", "d15",
+      "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
+      "errMaxRegNum", "rflag" },
+  std::array<const std::string, kAllRegNum> {
+      "err", "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",  "x8",  "x9",  "x10", "x11", "x12", "x13", "x14",
+      "x15", "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x29", "x30",
+      "x29" /* use X40 when debug */, "sp",  "xzr", /* x29 is fp */
+      "q0",  "q1",  "q2",  "q3",  "q4",  "q5",  "q6",  "q7",  "q8",  "q9",  "q10", "q11", "q12", "q13", "q14", "q15",
+      "q16", "q17", "q18", "q19", "q20", "q21", "q22", "q23", "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31",
+      "errMaxRegNum", "rflag" }
+};
+
+std::array<const std::string, kAllRegNum> AArch64CG::vectorRegNames = {
+    "err",   "err0",  "err1",  "err2",  "err3",  "err4",  "err5",  "err6",  "err7",  "err8",  "err9",  "err10",
+    "err11", "err12", "err13", "err14", "err15", "err16", "err17", "err18", "err19", "err20", "err21", "err22",
+    /* x29 is fp, err40 is fp before RA */
+    "err23", "err24", "err25", "err26", "err27", "err28", "err29", "err30", "errsp", "errzr", "err40",
+    "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",  "v8",  "v9",  "v10", "v11", "v12", "v13", "v14", "v15",
+    "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
+    "errMaxRegNum", "rflag" };
+
+bool AArch64CG::IsExclusiveFunc(MIRFunction &mirFunc) {
+  const std::string &funcName = mirFunc.GetName();
+  for (const auto &it : ehExclusiveNameVec) {
+    if (it.compare(funcName) == 0) {
+      return true;
+    }
+  }
+  return false;
+}
+namespace wordsMap {
+  /*
+   * Generate object maps.
+   *
+   * 1. each class record its GCTIB in method meta (not read only meta)
+   * 2. GCTIB include: header protoType; n bitmap word; bitmap word
+   * 3. each reference word(4 or 8 bytes) is represented by 2 bits
+   *    00: not ref
+   *    01: normal ref
+   *    10: weak ref
+   *    11: unowned ref
+   *
+   * For example, if a scalar object has five ptr fields at offsets 24, 40(weak),
+   * 64(unowned), the generated code will be like:
+   *
+   * MCC_GCTIB__xxx:
+   * .long 0x40      // object has child reference
+   * .long 1         // one word in the bitmap
+   * .quad 0b110000100001000000
+   * ...
+   */
+  const uint32 kRefWordsPerMapWord = 32;    /* contains bitmap for 32 ref words in 64 bits */
+  const uint32 kLogRefWordsPerMapWord = 5;
+#ifdef USE_32BIT_REF
+  const uint32 kReferenceWordSize = 4;
+  const uint32 kLog2ReferenceWordSize = 2;
+#else
+  const uint32 kReferenceWordSize = 8;
+  const uint32 kLog2ReferenceWordSize = 3;
+#endif
+  const uint32 kInMapWordOffsetMask = ((kReferenceWordSize * kRefWordsPerMapWord) - 1);
+  const uint32 kInMapWordIndexShift = (kLog2ReferenceWordSize - 1);
+  const uint32 kMapWordIndexShift = (kLog2ReferenceWordSize + kLogRefWordsPerMapWord);
+
+  const uint64 kRefBits = 1;
+  const uint64 kWeakRefBits = 2;
+  const uint64 kUnownedRefBits = 3;
+
+  /*
+   * Give a structrue type, calculate its bitmap_vector
+   */
+  static void GetGCTIBBitMapWords(const BECommon &beCommon, MIRStructType &stType, std::vector<uint64> &bitmapWords) {
+    bitmapWords.clear();
+    if (stType.GetKind() == kTypeClass) {
+      uint64 curBitmap = 0;
+      uint32 curBitmapIndex = 0;
+      uint32 prevOffset = 0;
+      for (const auto &fieldInfo : beCommon.GetJClassLayout(static_cast<MIRClassType&>(stType))) {
+        if (fieldInfo.IsRef()) {
+          uint32 curOffset = fieldInfo.GetOffset();
+          /* skip meta field */
+          if (curOffset == 0) {
+            continue;
+          }
+          CHECK_FATAL((curOffset > prevOffset) || (prevOffset == 0), "not ascending offset");
+          uint32 wordIndex = curOffset >> kMapWordIndexShift;
+          if (wordIndex > curBitmapIndex) {
+            bitmapWords.emplace_back(curBitmap);
+            for (uint32 i = curBitmapIndex + 1; i < wordIndex; i++) {
+              bitmapWords.emplace_back(0);
+            }
+            curBitmap = 0;
+            curBitmapIndex = wordIndex;
+          }
+          uint32 bitOffset = (curOffset & kInMapWordOffsetMask) >> kInMapWordIndexShift;
+          if (CGOptions::IsGCOnly()) {
+            /* ignore unowned/weak when GCONLY is enabled. */
+            curBitmap |= (kRefBits << bitOffset);
+          } else if (fieldInfo.IsUnowned()) {
+            curBitmap |= (kUnownedRefBits << bitOffset);
+          } else if (fieldInfo.IsWeak()) {
+            curBitmap |= (kWeakRefBits << bitOffset);
+          } else {
+            /* ref */
+            curBitmap |= (kRefBits << bitOffset);
+          }
+          prevOffset = curOffset;
+        }
+      }
+      if (curBitmap != 0) {
+        bitmapWords.emplace_back(curBitmap);
+      }
+    } else if (stType.GetKind() != kTypeInterface) {
+      /* interface doesn't have reference fields */
+      CHECK_FATAL(false, "GetGCTIBBitMapWords unexpected type");
+    }
+  }
+}
+
+bool AArch64CG::IsTargetInsn(MOperator mOp) const {
+  return (mOp > MOP_undef && mOp <= MOP_nop);
+}
+bool AArch64CG::IsClinitInsn(MOperator mOp) const {
+  return (mOp == MOP_clinit || mOp == MOP_clinit_tail || mOp == MOP_adrp_ldr);
+}
+
+bool AArch64CG::IsEffectiveCopy(Insn &insn) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  if (mOp >= MOP_xmovrr  && mOp <= MOP_xvmovrv) {
+    return true;
+  }
+  if (mOp == MOP_vmovuu || mOp == MOP_vmovvv) {
+    return true;
+  }
+  if ((mOp >= MOP_xaddrrr && mOp <= MOP_ssub) || (mOp >= MOP_xlslrri6 && mOp <= MOP_wlsrrrr)) {
+    Operand &opnd2 = insn.GetOperand(kInsnThirdOpnd);
+    if (opnd2.IsIntImmediate()) {
+      auto &immOpnd = static_cast<ImmOperand&>(opnd2);
+      if (immOpnd.IsZero()) {
+        return true;
+      }
+    }
+  }
+  if (mOp > MOP_xmulrrr && mOp <= MOP_xvmuld) {
+    Operand &opnd2 = insn.GetOperand(kInsnThirdOpnd);
+    if (opnd2.IsIntImmediate()) {
+      auto &immOpnd = static_cast<ImmOperand&>(opnd2);
+      if (immOpnd.GetValue() == 1) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void AArch64CG::DumpTargetOperand(Operand &opnd, const OpndDesc &opndDesc) const {
+  A64OpndDumpVisitor visitor(opndDesc);
+  opnd.Accept(visitor);
+}
+
+/*
+ * Find if there exist same GCTIB (both rcheader and bitmap are same)
+ * for different class. If ture reuse, if not emit and record new GCTIB.
+ */
+void AArch64CG::FindOrCreateRepresentiveSym(std::vector<uint64> &bitmapWords, uint32 rcHeader,
+                                            const std::string &name) {
+  GCTIBKey *key = memPool->New<GCTIBKey>(allocator, rcHeader, bitmapWords);
+  const std::string &gcTIBName = GCTIB_PREFIX_STR + name;
+  MapleUnorderedMap<GCTIBKey*, GCTIBPattern*, Hasher, EqualFn>::const_iterator iter = keyPatternMap.find(key);
+  if (iter == keyPatternMap.end() || gcTIBName.compare("MCC_GCTIB__Ljava_2Flang_2FObject_3B") == 0) {
+    /* Emit the GCTIB label for the class */
+    GCTIBPattern *ptn = memPool->New<GCTIBPattern>(*key, *memPool);
+
+    if (gcTIBName.compare("MCC_GCTIB__Ljava_2Flang_2FObject_3B") == 0) {
+      ptn->SetName("MCC_GCTIB__Ljava_2Flang_2FObject_3B");
+    }
+    (void)keyPatternMap.insert(std::make_pair(key, ptn));
+    (void)symbolPatternMap.insert(std::make_pair(gcTIBName, ptn));
+
+    /* Emit GCTIB pattern */
+    std::string ptnString = "\t.type " + ptn->GetName() + ", %object\n" + "\t.data\n" + "\t.align 3\n";
+
+    MIRSymbol *gcTIBSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+        GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::GetInternalNameLiteral(gcTIBName)));
+    if (gcTIBSymbol != nullptr && gcTIBSymbol->GetStorageClass() == kScFstatic) {
+      ptnString += "\t.local ";
+    } else {
+      ptnString += "\t.global ";
+    }
+
+    Emitter *emitter = GetEmitter();
+    emitter->Emit(ptnString);
+    emitter->Emit(ptn->GetName());
+    emitter->Emit("\n");
+
+    /* Emit the GCTIB pattern label for the class */
+    emitter->Emit(ptn->GetName());
+    emitter->Emit(":\n");
+
+    emitter->Emit("\t.long ");
+    emitter->EmitHexUnsigned(rcHeader);
+    emitter->Emit("\n");
+
+    /* generate n_bitmap word */
+    emitter->Emit("\t.long ");   /* AArch64-specific. Generate a 64-bit value. */
+    emitter->EmitDecUnsigned(bitmapWords.size());
+    emitter->Emit("\n");
+
+    /* Emit each bitmap word */
+    for (const auto &bitmapWord : bitmapWords) {
+      if (!CGOptions::IsQuiet()) {
+        LogInfo::MapleLogger() << "  bitmap_word: 0x"<< bitmapWord << " " << PRIx64 << "\n";
+      }
+      emitter->Emit("\t.quad ");  /* AArch64-specific. Generate a 64-bit value. */
+      emitter->EmitHexUnsigned(bitmapWord);
+      emitter->Emit("\n");
+    }
+    if (gcTIBSymbol != nullptr && gcTIBSymbol->GetStorageClass() != kScFstatic) {
+      /* add local symbol REF_XXX to every global GCTIB symbol */
+      CreateRefSymForGlobalPtn(*ptn);
+      keyPatternMap[key] = ptn;
+    }
+  } else {
+    (void)symbolPatternMap.insert(make_pair(gcTIBName, iter->second));
+  }
+}
+
+/*
+ * Add local symbol REF_XXX to global GCTIB symbol,
+ * and replace the global GCTIBPattern in keyPatternMap.
+ */
+void AArch64CG::CreateRefSymForGlobalPtn(GCTIBPattern &ptn) const {
+  const std::string &refPtnString = REF_PREFIX_STR + ptn.GetName();
+  const std::string &ptnString = "\t.type " + refPtnString + ", %object\n" +
+                                 "\t.data\n"  +
+                                 "\t.align 3\n" +
+                                 "\t.local " + refPtnString + "\n" +
+                                 refPtnString + ":\n" +
+                                 "\t.quad " + ptn.GetName() + "\n";
+  Emitter *emitter = GetEmitter();
+  emitter->Emit(ptnString);
+  ptn.SetName(refPtnString);
+}
+
+std::string AArch64CG::FindGCTIBPatternName(const std::string &name) const {
+  auto iter = symbolPatternMap.find(name);
+  if (iter == symbolPatternMap.end()) {
+    CHECK_FATAL(false, "No GCTIB pattern found for symbol: %s", name.c_str());
+  }
+  return iter->second->GetName();
+}
+
+void AArch64CG::GenerateObjectMaps(BECommon &beCommon) {
+  if (!CGOptions::IsQuiet()) {
+    LogInfo::MapleLogger() << "DEBUG: Generating object maps...\n";
+  }
+
+  for (auto &tyId : GetMIRModule()->GetClassList()) {
+    if (!CGOptions::IsQuiet()) {
+      LogInfo::MapleLogger() << "Class tyIdx: " << tyId << "\n";
+    }
+    TyIdx tyIdx(tyId);
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    ASSERT(ty != nullptr, "ty nullptr check");
+    /* Only emit GCTIB for classes owned by this module */
+    ASSERT(ty->IsStructType(), "ty isn't MIRStructType* in AArch64CG::GenerateObjectMaps");
+    MIRStructType *strTy = static_cast<MIRStructType*>(ty);
+    if (!strTy->IsLocal()) {
+      continue;
+    }
+
+    GStrIdx nameIdx = ty->GetNameStrIdx();
+
+    const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(nameIdx);
+
+    /* Emit for a class */
+    if (!CGOptions::IsQuiet()) {
+      LogInfo::MapleLogger() << "  name: " << name << "\n";
+    }
+
+    std::vector<uint64> bitmapWords;
+    wordsMap::GetGCTIBBitMapWords(beCommon, *strTy, bitmapWords);
+    /* fill specific header according to the size of bitmapWords */
+    uint32 rcHeader = (!bitmapWords.empty()) ? 0x40 : 0;
+    FindOrCreateRepresentiveSym(bitmapWords, rcHeader, name);
+  }
+}
+
+void AArch64CG::EnrollTargetPhases(MaplePhaseManager *pm) const {
+  if (!GetMIRModule()->IsCModule()) {
+    CGOptions::DisableCGSSA();
+  }
+#include "aarch64_phases.def"
+}
+
+Insn &AArch64CG::BuildPhiInsn(RegOperand &defOpnd, Operand &listParam) {
+  ASSERT(defOpnd.IsRegister(), "build SSA on register operand");
+  CHECK_FATAL(defOpnd.IsOfIntClass() || defOpnd.IsOfFloatOrSIMDClass(), " unknown operand type ");
+  bool is64bit = defOpnd.GetSize() == k64BitSize;
+  MOperator mop = MOP_nop;
+  if (defOpnd.GetSize() == k128BitSize) {
+    ASSERT(defOpnd.IsOfFloatOrSIMDClass(), "unexpect 128bit int operand in aarch64");
+    mop = MOP_xvphivd;
+  } else {
+    mop = defOpnd.IsOfIntClass() ? is64bit ? MOP_xphirr : MOP_wphirr : is64bit ? MOP_xvphid : MOP_xvphis;
+  }
+  ASSERT(mop != MOP_nop, "unexpect 128bit int operand in aarch64");
+  return GetCurCGFuncNoConst()->GetInsnBuilder()->BuildInsn(mop, defOpnd, listParam);
+}
+
+PhiOperand &AArch64CG::CreatePhiOperand(MemPool &mp, MapleAllocator &mAllocator) {
+  return *mp.New<PhiOperand>(mAllocator);
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1bb68ac8257e89596b3f5d7da8d0901cc2592c19
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
@@ -0,0 +1,12420 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <vector>
+#include <cstdint>
+#include <atomic>
+#include <algorithm>
+#include "aarch64_cg.h"
+#include "cfi.h"
+#include "mpl_logging.h"
+#include "rt.h"
+#include "opcode_info.h"
+#include "mir_builder.h"
+#include "mir_symbol_builder.h"
+#include "mpl_atomic.h"
+#include "metadata_layout.h"
+#include "emit.h"
+#include "simplify.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+CondOperand AArch64CGFunc::ccOperands[kCcLast] = {
+    CondOperand(CC_EQ),
+    CondOperand(CC_NE),
+    CondOperand(CC_CS),
+    CondOperand(CC_HS),
+    CondOperand(CC_CC),
+    CondOperand(CC_LO),
+    CondOperand(CC_MI),
+    CondOperand(CC_PL),
+    CondOperand(CC_VS),
+    CondOperand(CC_VC),
+    CondOperand(CC_HI),
+    CondOperand(CC_LS),
+    CondOperand(CC_GE),
+    CondOperand(CC_LT),
+    CondOperand(CC_GT),
+    CondOperand(CC_LE),
+    CondOperand(CC_AL),
+};
+
+namespace {
+constexpr int32 kSignedDimension = 2;        /* signed and unsigned */
+constexpr int32 kIntByteSizeDimension = 4;   /* 1 byte, 2 byte, 4 bytes, 8 bytes */
+constexpr int32 kFloatByteSizeDimension = 3; /* 4 bytes, 8 bytes, 16 bytes(vector) */
+constexpr int32 kShiftAmount12 = 12;         /* for instruction that can use shift, shift amount must be 0 or 12 */
+
+MOperator ldIs[kSignedDimension][kIntByteSizeDimension] = {
+  /* unsigned == 0 */
+  { MOP_wldrb, MOP_wldrh, MOP_wldr, MOP_xldr },
+  /* signed == 1 */
+  { MOP_wldrsb, MOP_wldrsh, MOP_wldr, MOP_xldr }
+};
+
+MOperator stIs[kSignedDimension][kIntByteSizeDimension] = {
+  /* unsigned == 0 */
+  { MOP_wstrb, MOP_wstrh, MOP_wstr, MOP_xstr },
+  /* signed == 1 */
+  { MOP_wstrb, MOP_wstrh, MOP_wstr, MOP_xstr }
+};
+
+MOperator ldIsAcq[kSignedDimension][kIntByteSizeDimension] = {
+  /* unsigned == 0 */
+  { MOP_wldarb, MOP_wldarh, MOP_wldar, MOP_xldar },
+  /* signed == 1 */
+  { MOP_wldarb, MOP_wldarh, MOP_wldar, MOP_xldar }
+};
+
+MOperator stIsRel[kSignedDimension][kIntByteSizeDimension] = {
+  /* unsigned == 0 */
+  { MOP_wstlrb, MOP_wstlrh, MOP_wstlr, MOP_xstlr },
+  /* signed == 1 */
+  { MOP_wstlrb, MOP_wstlrh, MOP_wstlr, MOP_xstlr }
+};
+
+MOperator ldFs[kFloatByteSizeDimension] = { MOP_sldr, MOP_dldr, MOP_qldr };
+MOperator stFs[kFloatByteSizeDimension] = { MOP_sstr, MOP_dstr, MOP_qstr };
+
+MOperator ldFsAcq[kFloatByteSizeDimension] = { MOP_undef, MOP_undef, MOP_undef };
+MOperator stFsRel[kFloatByteSizeDimension] = { MOP_undef, MOP_undef, MOP_undef };
+
+/* extended to unsigned ints */
+MOperator uextIs[kIntByteSizeDimension][kIntByteSizeDimension] = {
+  /*  u8         u16          u32          u64      */
+  { MOP_undef, MOP_xuxtb32, MOP_xuxtb32, MOP_xuxtb32},  /* u8/i8   */
+  { MOP_undef, MOP_undef,   MOP_xuxth32, MOP_xuxth32},  /* u16/i16 */
+  { MOP_undef, MOP_undef,   MOP_xuxtw64, MOP_xuxtw64},  /* u32/i32 */
+  { MOP_undef, MOP_undef,   MOP_undef,   MOP_undef}     /* u64/u64 */
+};
+
+/* extended to signed ints */
+MOperator extIs[kIntByteSizeDimension][kIntByteSizeDimension] = {
+  /*  i8         i16          i32          i64      */
+  { MOP_undef, MOP_xsxtb32, MOP_xsxtb32, MOP_xsxtb64},  /* u8/i8   */
+  { MOP_undef, MOP_undef,   MOP_xsxth32, MOP_xsxth64},  /* u16/i16 */
+  { MOP_undef, MOP_undef,   MOP_undef,   MOP_xsxtw64},  /* u32/i32 */
+  { MOP_undef, MOP_undef,   MOP_undef,   MOP_undef}     /* u64/u64 */
+};
+
+MOperator PickLdStInsn(bool isLoad, uint32 bitSize, PrimType primType, AArch64isa::MemoryOrdering memOrd) {
+  ASSERT(__builtin_popcount(static_cast<uint32>(memOrd)) <= 1, "must be kMoNone or kMoAcquire");
+  ASSERT(primType != PTY_ptr, "should have been lowered");
+  ASSERT(primType != PTY_ref, "should have been lowered");
+  ASSERT(bitSize >= k8BitSize, "PTY_u1 should have been lowered?");
+  ASSERT(__builtin_popcount(bitSize) == 1, "PTY_u1 should have been lowered?");
+  if (isLoad) {
+    ASSERT((memOrd == AArch64isa::kMoNone) || (memOrd == AArch64isa::kMoAcquire) ||
+           (memOrd == AArch64isa::kMoAcquireRcpc) || (memOrd == AArch64isa::kMoLoacquire), "unknown Memory Order");
+  } else {
+    ASSERT((memOrd == AArch64isa::kMoNone) || (memOrd == AArch64isa::kMoRelease) ||
+           (memOrd == AArch64isa::kMoLorelease), "unknown Memory Order");
+  }
+
+  /* __builtin_ffs(x) returns: 0 -> 0, 1 -> 1, 2 -> 2, 4 -> 3, 8 -> 4 */
+  if ((IsPrimitiveInteger(primType) || primType == PTY_agg) && !IsPrimitiveVector(primType))  {
+    MOperator(*table)[kIntByteSizeDimension];
+    if (isLoad) {
+      table = (memOrd == AArch64isa::kMoAcquire) ? ldIsAcq : ldIs;
+    } else {
+      table = (memOrd == AArch64isa::kMoRelease) ? stIsRel : stIs;
+    }
+
+    int32 signedUnsigned = IsUnsignedInteger(primType) ? 0 : 1;
+    if (primType == PTY_agg) {
+      CHECK_FATAL(bitSize >= k8BitSize, " unexpect agg size");
+      bitSize = static_cast<uint32>(RoundUp(bitSize, k8BitSize));
+      ASSERT((bitSize & (bitSize - 1)) == 0, "bitlen error");
+    }
+
+    /* __builtin_ffs(x) returns: 8 -> 4, 16 -> 5, 32 -> 6, 64 -> 7 */
+    if (primType == PTY_i128 || primType == PTY_u128) {
+      bitSize = k64BitSize;
+    }
+    uint32 size = static_cast<uint32>(__builtin_ffs(static_cast<int32>(bitSize))) - 4;
+    ASSERT(size <= 3, "wrong bitSize");
+    return table[signedUnsigned][size];
+  } else {
+    MOperator *table = nullptr;
+    if (isLoad) {
+      table = (memOrd == AArch64isa::kMoAcquire) ? ldFsAcq : ldFs;
+    } else {
+      table = (memOrd == AArch64isa::kMoRelease) ? stFsRel : stFs;
+    }
+
+    /* __builtin_ffs(x) returns: 32 -> 6, 64 -> 7, 128 -> 8 */
+    uint32 size = static_cast<uint32>(__builtin_ffs(static_cast<int32>(bitSize))) - 6;
+    ASSERT(size <= 2, "size must be 0 to 2");
+    return table[size];
+  }
+}
+}
+
+bool IsBlkassignForPush(const BlkassignoffNode &bNode) {
+  BaseNode *dest = bNode.Opnd(0);
+  bool spBased = false;
+  if (dest->GetOpCode() == OP_regread) {
+    RegreadNode &node = static_cast<RegreadNode&>(*dest);
+    if (-node.GetRegIdx() == kSregSp) {
+      spBased = true;
+    }
+  }
+  return spBased;
+}
+
+MIRStructType *AArch64CGFunc::GetLmbcStructArgType(BaseNode &stmt, size_t argNo) {
+  MIRType *ty = nullptr;
+  if (stmt.GetOpCode() == OP_call) {
+    CallNode &callNode = static_cast<CallNode&>(stmt);
+    MIRFunction *callFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode.GetPUIdx());
+    if (callFunc->GetFormalCount() < (argNo + 1UL)) {
+      return nullptr;   /* formals less than actuals */
+    }
+    ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(callFunc->GetFormalDefVec()[argNo].formalTyIdx);
+  } else if (stmt.GetOpCode() == OP_icallproto) {
+    argNo--;   /* 1st opnd of icallproto is funcname, skip it relative to param list */
+    IcallNode &icallproto = static_cast<IcallNode&>(stmt);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(icallproto.GetRetTyIdx());
+    MIRFuncType *fType = nullptr;
+    if (type->IsMIRPtrType()) {
+      fType = static_cast<MIRPtrType*>(type)->GetPointedFuncType();
+    } else {
+      fType = static_cast<MIRFuncType*>(type);
+    }
+    if (fType->GetParamTypeList().size() < (argNo + 1UL)) {
+      return nullptr;
+    }
+    ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fType->GetNthParamType(argNo));
+  }
+  CHECK_FATAL(ty && ty->IsStructType(), "lmbc agg arg error");
+  return static_cast<MIRStructType*>(ty);
+}
+
+RegOperand &AArch64CGFunc::GetOrCreateResOperand(const BaseNode &parent, PrimType primType) {
+  RegOperand *resOpnd = nullptr;
+  if (parent.GetOpCode() == OP_regassign) {
+    auto &regAssignNode = static_cast<const RegassignNode&>(parent);
+    PregIdx pregIdx = regAssignNode.GetRegIdx();
+    if (IsSpecialPseudoRegister(pregIdx)) {
+      /* if it is one of special registers */
+      resOpnd = &GetOrCreateSpecialRegisterOperand(-pregIdx, primType);
+    } else {
+      resOpnd = &GetOrCreateVirtualRegisterOperand(GetVirtualRegNOFromPseudoRegIdx(pregIdx));
+    }
+  } else {
+    resOpnd = &CreateRegisterOperandOfType(primType);
+  }
+  return *resOpnd;
+}
+
+MOperator AArch64CGFunc::PickLdInsn(uint32 bitSize, PrimType primType,
+                                    AArch64isa::MemoryOrdering memOrd) const {
+  return PickLdStInsn(true, bitSize, primType, memOrd);
+}
+
+MOperator AArch64CGFunc::PickStInsn(uint32 bitSize, PrimType primType,
+                                    AArch64isa::MemoryOrdering memOrd) const {
+  return PickLdStInsn(false, bitSize, primType, memOrd);
+}
+
+MOperator AArch64CGFunc::PickExtInsn(PrimType dtype, PrimType stype) const {
+  int32 sBitSize = static_cast<int32>(GetPrimTypeBitSize(stype));
+  int32 dBitSize = static_cast<int32>(GetPrimTypeBitSize(dtype));
+  /* __builtin_ffs(x) returns: 0 -> 0, 1 -> 1, 2 -> 2, 4 -> 3, 8 -> 4 */
+  if (IsPrimitiveInteger(stype) && IsPrimitiveInteger(dtype)) {
+    MOperator(*table)[kIntByteSizeDimension];
+    table = IsUnsignedInteger(stype) ? uextIs : extIs;
+    if (stype == PTY_i128 || stype == PTY_u128) {
+      sBitSize = static_cast<int32>(k64BitSize);
+    }
+    /* __builtin_ffs(x) returns: 8 -> 4, 16 -> 5, 32 -> 6, 64 -> 7 */
+    uint32 row = static_cast<uint32>(__builtin_ffs(sBitSize)) - k4BitSize;
+    ASSERT(row <= 3, "wrong bitSize");
+    if (dtype == PTY_i128 || dtype == PTY_u128) {
+      dBitSize = static_cast<int32>(k64BitSize);
+    }
+    uint32 col = static_cast<uint32>(__builtin_ffs(dBitSize)) - k4BitSize;
+    ASSERT(col <= 3, "wrong bitSize");
+    return table[row][col];
+  }
+  CHECK_FATAL(false, "extend not primitive integer");
+  return MOP_undef;
+}
+
+MOperator AArch64CGFunc::PickMovBetweenRegs(PrimType destType, PrimType srcType) const {
+  if (IsPrimitiveVector(destType) && IsPrimitiveVector(srcType)) {
+    return GetPrimTypeSize(srcType) == k8ByteSize ? MOP_vmovuu : MOP_vmovvv;
+  }
+  if (IsPrimitiveInteger(destType) && IsPrimitiveInteger(srcType)) {
+    return GetPrimTypeSize(srcType) <= k4ByteSize ? MOP_wmovrr : MOP_xmovrr;
+  }
+  if (IsPrimitiveFloat(destType) && IsPrimitiveFloat(srcType)) {
+    return GetPrimTypeSize(srcType) <= k4ByteSize ? MOP_xvmovs : MOP_xvmovd;
+  }
+  if (IsPrimitiveInteger(destType) && IsPrimitiveFloat(srcType)) {
+    return GetPrimTypeSize(srcType) <= k4ByteSize ? MOP_xvmovrs : MOP_xvmovrd;
+  }
+  if (IsPrimitiveFloat(destType) && IsPrimitiveInteger(srcType)) {
+    return GetPrimTypeSize(srcType) <= k4ByteSize ? MOP_xvmovsr : MOP_xvmovdr;
+  }
+  if (IsPrimitiveInteger(destType) && IsPrimitiveVector(srcType)) {
+    return GetPrimTypeSize(srcType) == k8ByteSize ? MOP_vwmovru :
+        GetPrimTypeSize(destType) <= k4ByteSize ? MOP_vwmovrv : MOP_vxmovrv;
+  }
+  CHECK_FATAL(false, "unexpected operand primtype for mov");
+  return MOP_undef;
+}
+
+MOperator AArch64CGFunc::PickMovInsn(const RegOperand &lhs, const RegOperand &rhs) const {
+  CHECK_FATAL(lhs.GetRegisterType() == rhs.GetRegisterType(), "PickMovInsn: unequal kind NYI");
+  CHECK_FATAL(lhs.GetSize() == rhs.GetSize(), "PickMovInsn: unequal size NYI");
+  ASSERT(((lhs.GetSize() < k64BitSize) || (lhs.GetRegisterType() == kRegTyFloat)),
+         "should split the 64 bits or more mov");
+  if (lhs.GetRegisterType() == kRegTyInt) {
+    return MOP_wmovrr;
+  }
+  if (lhs.GetRegisterType() == kRegTyFloat) {
+    return (lhs.GetSize() <= k32BitSize) ? MOP_xvmovs : MOP_xvmovd;
+  }
+  ASSERT(false, "PickMovInsn: kind NYI");
+  return MOP_undef;
+}
+
+void AArch64CGFunc::SelectLoadAcquire(Operand &dest, PrimType dtype, Operand &src, PrimType stype,
+                                      AArch64isa::MemoryOrdering memOrd, bool isDirect) {
+  ASSERT(src.GetKind() == Operand::kOpdMem, "Just checking");
+  ASSERT(memOrd != AArch64isa::kMoNone, "Just checking");
+
+  uint32 ssize = isDirect ? src.GetSize() : GetPrimTypeBitSize(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  MOperator mOp = PickLdInsn(ssize, stype, memOrd);
+
+  Operand *newSrc = &src;
+  auto &memOpnd = static_cast<MemOperand&>(src);
+  OfstOperand *immOpnd = memOpnd.GetOffsetImmediate();
+  int32 offset = static_cast<int32>(immOpnd->GetOffsetValue());
+  RegOperand *origBaseReg = memOpnd.GetBaseRegister();
+  if (offset != 0) {
+    RegOperand &resOpnd = CreateRegisterOperandOfType(PTY_i64);
+    ASSERT(origBaseReg != nullptr, "nullptr check");
+    SelectAdd(resOpnd, *origBaseReg, *immOpnd, PTY_i64);
+    newSrc = &CreateReplacementMemOperand(ssize, resOpnd, 0);
+  }
+
+  std::string key;
+  if (isDirect && GetCG()->GenerateVerboseCG()) {
+    key = GenerateMemOpndVerbose(src);
+  }
+
+  /* Check if the right load-acquire instruction is available. */
+  if (mOp != MOP_undef) {
+    Insn &insn = GetInsnBuilder()->BuildInsn(mOp, dest, *newSrc);
+    if (isDirect && GetCG()->GenerateVerboseCG()) {
+      insn.SetComment(key);
+    }
+    GetCurBB()->AppendInsn(insn);
+  } else {
+    if (IsPrimitiveFloat(stype)) {
+      /* Uses signed integer version ldar followed by a floating-point move(fmov).  */
+      ASSERT(stype == dtype, "Just checking");
+      PrimType itype = (stype == PTY_f32) ? PTY_i32 : PTY_i64;
+      RegOperand &regOpnd = CreateRegisterOperandOfType(itype);
+      Insn &insn = GetInsnBuilder()->BuildInsn(PickLdInsn(ssize, itype, memOrd), regOpnd, *newSrc);
+      if (isDirect && GetCG()->GenerateVerboseCG()) {
+        insn.SetComment(key);
+      }
+      GetCurBB()->AppendInsn(insn);
+      mOp = (stype == PTY_f32) ? MOP_xvmovsr : MOP_xvmovdr;
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, dest, regOpnd));
+    } else {
+      /* Use unsigned version ldarb/ldarh followed by a sign-extension instruction(sxtb/sxth).  */
+      ASSERT((ssize == k8BitSize) || (ssize == k16BitSize), "Just checking");
+      PrimType utype = (ssize == k8BitSize) ? PTY_u8 : PTY_u16;
+      Insn &insn = GetInsnBuilder()->BuildInsn(PickLdInsn(ssize, utype, memOrd), dest, *newSrc);
+      if (isDirect && GetCG()->GenerateVerboseCG()) {
+        insn.SetComment(key);
+      }
+      GetCurBB()->AppendInsn(insn);
+      mOp = ((dsize == k32BitSize) ? ((ssize == k8BitSize) ? MOP_xsxtb32 : MOP_xsxth32)
+                                   : ((ssize == k8BitSize) ? MOP_xsxtb64 : MOP_xsxth64));
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, dest, dest));
+    }
+  }
+}
+
+void AArch64CGFunc::SelectStoreRelease(Operand &dest, PrimType dtype, Operand &src, PrimType stype,
+                                       AArch64isa::MemoryOrdering memOrd, bool isDirect) {
+  ASSERT(dest.GetKind() == Operand::kOpdMem, "Just checking");
+
+  uint32 dsize = isDirect ? dest.GetSize() : GetPrimTypeBitSize(stype);
+  MOperator mOp = PickStInsn(dsize, stype, memOrd);
+
+  Operand *newDest = &dest;
+  MemOperand *memOpnd = static_cast<MemOperand*>(&dest);
+  OfstOperand *immOpnd = memOpnd->GetOffsetImmediate();
+  int32 offset = static_cast<int32>(immOpnd->GetOffsetValue());
+  RegOperand *origBaseReg = memOpnd->GetBaseRegister();
+  if (offset != 0) {
+    RegOperand &resOpnd = CreateRegisterOperandOfType(PTY_i64);
+    ASSERT(origBaseReg != nullptr, "nullptr check");
+    SelectAdd(resOpnd, *origBaseReg, *immOpnd, PTY_i64);
+    newDest = &CreateReplacementMemOperand(dsize, resOpnd, 0);
+  }
+
+  std::string key;
+  if (isDirect && GetCG()->GenerateVerboseCG()) {
+    key = GenerateMemOpndVerbose(dest);
+  }
+
+  /* Check if the right store-release instruction is available. */
+  if (mOp != MOP_undef) {
+    Insn &insn = GetInsnBuilder()->BuildInsn(mOp, src, *newDest);
+    if (isDirect && GetCG()->GenerateVerboseCG()) {
+      insn.SetComment(key);
+    }
+    GetCurBB()->AppendInsn(insn);
+  } else {
+    /* Use a floating-point move(fmov) followed by a stlr.  */
+    ASSERT(IsPrimitiveFloat(stype), "must be float type");
+    CHECK_FATAL(stype == dtype, "Just checking");
+    PrimType itype = (stype == PTY_f32) ? PTY_i32 : PTY_i64;
+    RegOperand &regOpnd = CreateRegisterOperandOfType(itype);
+    mOp = (stype == PTY_f32) ? MOP_xvmovrs : MOP_xvmovrd;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, regOpnd, src));
+    Insn &insn = GetInsnBuilder()->BuildInsn(PickStInsn(dsize, itype, memOrd), regOpnd, *newDest);
+    if (isDirect && GetCG()->GenerateVerboseCG()) {
+      insn.SetComment(key);
+    }
+    GetCurBB()->AppendInsn(insn);
+  }
+}
+
+void AArch64CGFunc::SelectCopyImm(Operand &dest, PrimType dType, ImmOperand &src, PrimType sType) {
+  if (IsPrimitiveInteger(dType) != IsPrimitiveInteger(sType)) {
+    RegOperand &tempReg = CreateRegisterOperandOfType(sType);
+    SelectCopyImm(tempReg, src, sType);
+    SelectCopy(dest, dType, tempReg, sType);
+  } else {
+    SelectCopyImm(dest, src, sType);
+  }
+}
+
+void AArch64CGFunc::SelectCopyImm(Operand &dest, ImmOperand &src, PrimType dtype) {
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  ASSERT(IsPrimitiveInteger(dtype), "The type of destination operand must be Integer");
+  ASSERT(((dsize == k8BitSize) || (dsize == k16BitSize) || (dsize == k32BitSize) || (dsize == k64BitSize)),
+         "The destination operand must be >= 8-bit");
+  if (src.GetSize() == k32BitSize && dsize == k64BitSize && src.IsSingleInstructionMovable()) {
+    auto tempReg = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, dsize), dsize, kRegTyInt);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wmovri32, *tempReg, src));
+    SelectCopy(dest, dtype, *tempReg, PTY_u32);
+    return;
+  }
+  if (src.IsSingleInstructionMovable()) {
+    MOperator mOp = (dsize == k32BitSize) ? MOP_wmovri32 : MOP_xmovri64;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, dest, src));
+    return;
+  }
+  uint64 srcVal = static_cast<uint64>(src.GetValue());
+  /* using mov/movk to load the immediate value */
+  if (dsize == k8BitSize) {
+    /* compute lower 8 bits value */
+    if (dtype == PTY_u8) {
+      /* zero extend */
+      srcVal = (srcVal << 56) >> 56;
+      dtype = PTY_u16;
+    } else {
+      /* sign extend */
+      srcVal = ((static_cast<int64>(srcVal)) << 56) >> 56;
+      dtype = PTY_i16;
+    }
+    dsize = k16BitSize;
+  }
+  if (dsize == k16BitSize) {
+    if (dtype == PTY_u16) {
+      /* check lower 16 bits and higher 16 bits respectively */
+      ASSERT((srcVal & 0x0000FFFFULL) != 0, "unexpected value");
+      ASSERT(((srcVal >> k16BitSize) & 0x0000FFFFULL) == 0, "unexpected value");
+      ASSERT((srcVal & 0x0000FFFFULL) != 0xFFFFULL, "unexpected value");
+      /* create an imm opereand which represents lower 16 bits of the immediate */
+      ImmOperand &srcLower = CreateImmOperand(static_cast<int64>(srcVal & 0x0000FFFFULL), k16BitSize, false);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wmovri32, dest, srcLower));
+      return;
+    } else {
+      /* sign extend and let `dsize == 32` case take care of it */
+      srcVal = ((static_cast<int64>(srcVal)) << 48) >> 48;
+      dsize = k32BitSize;
+    }
+  }
+  if (dsize == k32BitSize) {
+    /* check lower 16 bits and higher 16 bits respectively */
+    ASSERT((srcVal & 0x0000FFFFULL) != 0, "unexpected val");
+    ASSERT(((srcVal >> k16BitSize) & 0x0000FFFFULL) != 0, "unexpected val");
+    ASSERT((srcVal & 0x0000FFFFULL) != 0xFFFFULL, "unexpected val");
+    ASSERT(((srcVal >> k16BitSize) & 0x0000FFFFULL) != 0xFFFFULL, "unexpected val");
+    /* create an imm opereand which represents lower 16 bits of the immediate */
+    ImmOperand &srcLower = CreateImmOperand(static_cast<int64>(srcVal & 0x0000FFFFULL), k16BitSize, false);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wmovri32, dest, srcLower));
+    /* create an imm opereand which represents upper 16 bits of the immediate */
+    ImmOperand &srcUpper = CreateImmOperand(static_cast<int64>((srcVal >> k16BitSize) & 0x0000FFFFULL),
+        k16BitSize, false);
+    BitShiftOperand *lslOpnd = GetLogicalShiftLeftOperand(k16BitSize, false);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wmovkri16, dest, srcUpper, *lslOpnd));
+  } else {
+    /*
+     * partition it into 4 16-bit chunks
+     * if more 0's than 0xFFFF's, use movz as the initial instruction.
+     * otherwise, movn.
+     */
+    bool useMovz = BetterUseMOVZ(srcVal);
+    bool useMovk = false;
+    /* get lower 32 bits of the immediate */
+    uint64 chunkLval = srcVal & 0xFFFFFFFFULL;
+    /* get upper 32 bits of the immediate */
+    uint64 chunkHval = (srcVal >> k32BitSize) & 0xFFFFFFFFULL;
+    int32 maxLoopTime = 4;
+
+    if (chunkLval == chunkHval) {
+      /* compute lower 32 bits, and then copy to higher 32 bits, so only 2 chunks need be processed */
+      maxLoopTime = 2;
+    }
+
+    uint64 sa = 0;
+
+    for (int64 i = 0; i < maxLoopTime; ++i, sa += k16BitSize) {
+      /* create an imm opereand which represents the i-th 16-bit chunk of the immediate */
+      uint64 chunkVal = (srcVal >> (static_cast<uint64>(sa))) & 0x0000FFFFULL;
+      if (useMovz ? (chunkVal == 0) : (chunkVal == 0x0000FFFFULL)) {
+        continue;
+      }
+      ImmOperand &src16 = CreateImmOperand(static_cast<int64>(chunkVal), k16BitSize, false);
+      BitShiftOperand *lslOpnd = GetLogicalShiftLeftOperand(sa, true);
+      if (!useMovk) {
+        /* use movz or movn */
+        if (!useMovz) {
+          src16.BitwiseNegate();
+        }
+        GetCurBB()->AppendInsn(
+            GetInsnBuilder()->BuildInsn(useMovz ? MOP_xmovzri16 : MOP_xmovnri16, dest, src16, *lslOpnd));
+        useMovk = true;
+      } else {
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xmovkri16, dest, src16, *lslOpnd));
+      }
+    }
+
+    if (maxLoopTime == 2) {
+      /* copy lower 32 bits to higher 32 bits */
+      ImmOperand &immOpnd = CreateImmOperand(k32BitSize, k8BitSize, false);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xbfirri6i6, dest, dest, immOpnd, immOpnd));
+    }
+  }
+}
+
+std::string AArch64CGFunc::GenerateMemOpndVerbose(const Operand &src) const {
+  ASSERT(src.GetKind() == Operand::kOpdMem, "Just checking");
+  const MIRSymbol *symSecond = static_cast<const MemOperand*>(&src)->GetSymbol();
+  if (symSecond != nullptr) {
+    std::string str;
+    MIRStorageClass sc = symSecond->GetStorageClass();
+    if (sc == kScFormal) {
+      str = "param: ";
+    } else if (sc == kScAuto) {
+      str = "local var: ";
+    } else {
+      str = "global: ";
+    }
+    return str.append(symSecond->GetName());
+  }
+  return "";
+}
+
+void AArch64CGFunc::SelectCopyMemOpnd(Operand &dest, PrimType dtype, uint32 dsize,
+                                      Operand &src, PrimType stype) {
+  AArch64isa::MemoryOrdering memOrd = AArch64isa::kMoNone;
+  const MIRSymbol *sym = static_cast<MemOperand*>(&src)->GetSymbol();
+  if ((sym != nullptr) && (sym->GetStorageClass() == kScGlobal) && sym->GetAttr(ATTR_memory_order_acquire)) {
+    memOrd = AArch64isa::kMoAcquire;
+  }
+
+  if (memOrd != AArch64isa::kMoNone) {
+    AArch64CGFunc::SelectLoadAcquire(dest, dtype, src, stype, memOrd, true);
+    return;
+  }
+  Insn *insn = nullptr;
+  uint32 ssize = src.GetSize();
+  PrimType regTy = PTY_void;
+  RegOperand *loadReg = nullptr;
+  MOperator mop = MOP_undef;
+  if (IsPrimitiveFloat(stype) || IsPrimitiveVector(stype)) {
+    CHECK_FATAL(dsize == ssize, "dsize %u expect equals ssize %u", dtype, ssize);
+    insn = &GetInsnBuilder()->BuildInsn(PickLdInsn(ssize, stype), dest, src);
+  } else {
+    if (stype == PTY_agg && dtype == PTY_agg) {
+      mop = MOP_undef;
+    } else {
+      mop = PickExtInsn(dtype, stype);
+    }
+    if (ssize == (GetPrimTypeSize(dtype) * kBitsPerByte) || mop == MOP_undef) {
+      insn = &GetInsnBuilder()->BuildInsn(PickLdInsn(ssize, stype), dest, src);
+    } else {
+      regTy = dsize == k64BitSize ? dtype : PTY_i32;
+      loadReg = &CreateRegisterOperandOfType(regTy);
+      insn = &GetInsnBuilder()->BuildInsn(PickLdInsn(ssize, stype), *loadReg, src);
+    }
+  }
+
+  if (GetCG()->GenerateVerboseCG()) {
+    insn->SetComment(GenerateMemOpndVerbose(src));
+  }
+
+  GetCurBB()->AppendInsn(*insn);
+  if (regTy != PTY_void && mop != MOP_undef) {
+    ASSERT(loadReg != nullptr, "loadReg should not be nullptr");
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mop, dest, *loadReg));
+  }
+}
+
+bool AArch64CGFunc::IsImmediateValueInRange(MOperator mOp, int64 immVal, bool is64Bits,
+                                            bool isIntactIndexed, bool isPostIndexed, bool isPreIndexed) const {
+  bool isInRange = false;
+  switch (mOp) {
+    case MOP_xstr:
+    case MOP_wstr:
+      isInRange =
+          (isIntactIndexed &&
+           ((!is64Bits && (immVal >= kStrAllLdrAllImmLowerBound) && (immVal <= kStrLdrImm32UpperBound)) ||
+            (is64Bits && (immVal >= kStrAllLdrAllImmLowerBound) && (immVal <= kStrLdrImm64UpperBound)))) ||
+          ((isPostIndexed || isPreIndexed) && (immVal >= kStrLdrPerPostLowerBound) &&
+           (immVal <= kStrLdrPerPostUpperBound));
+      break;
+    case MOP_wstrb:
+      isInRange =
+          (isIntactIndexed && (immVal >= kStrAllLdrAllImmLowerBound) && (immVal <= kStrbLdrbImmUpperBound)) ||
+          ((isPostIndexed || isPreIndexed) && (immVal >= kStrLdrPerPostLowerBound) &&
+           (immVal <= kStrLdrPerPostUpperBound));
+      break;
+    case MOP_wstrh:
+      isInRange =
+          (isIntactIndexed && (immVal >= kStrAllLdrAllImmLowerBound) && (immVal <= kStrhLdrhImmUpperBound)) ||
+          ((isPostIndexed || isPreIndexed) && (immVal >= kStrLdrPerPostLowerBound) &&
+           (immVal <= kStrLdrPerPostUpperBound));
+      break;
+    default:
+      break;
+  }
+  return isInRange;
+}
+
+bool AArch64CGFunc::IsStoreMop(MOperator mOp) const {
+  switch (mOp) {
+    case MOP_sstr:
+    case MOP_dstr:
+    case MOP_qstr:
+    case MOP_xstr:
+    case MOP_wstr:
+    case MOP_wstrb:
+    case MOP_wstrh:
+      return true;
+    default:
+      return false;
+  }
+}
+
+void AArch64CGFunc::SplitMovImmOpndInstruction(int64 immVal, RegOperand &destReg, Insn *curInsn) {
+  bool useMovz = BetterUseMOVZ(immVal);
+  bool useMovk = false;
+  /* get lower 32 bits of the immediate */
+  uint64 chunkLval = static_cast<uint64>(immVal) & 0xFFFFFFFFULL;
+  /* get upper 32 bits of the immediate */
+  uint64 chunkHval = (static_cast<uint64>(immVal) >> k32BitSize) & 0xFFFFFFFFULL;
+  int32 maxLoopTime = 4;
+
+  if (chunkLval == chunkHval) {
+    /* compute lower 32 bits, and then copy to higher 32 bits, so only 2 chunks need be processed */
+    maxLoopTime = 2;
+  }
+
+  uint64 sa = 0;
+  auto *bb = (curInsn != nullptr) ? curInsn->GetBB() : GetCurBB();
+  for (int64 i = 0 ; i < maxLoopTime; ++i, sa += k16BitSize) {
+    /* create an imm opereand which represents the i-th 16-bit chunk of the immediate */
+    uint64 chunkVal = (static_cast<uint64>(immVal) >> sa) & 0x0000FFFFULL;
+    if (useMovz ? (chunkVal == 0) : (chunkVal == 0x0000FFFFULL)) {
+      continue;
+    }
+    ImmOperand &src16 = CreateImmOperand(static_cast<int64>(chunkVal), k16BitSize, false);
+    BitShiftOperand *lslOpnd = GetLogicalShiftLeftOperand(sa, true);
+    Insn *newInsn = nullptr;
+    if (!useMovk) {
+      /* use movz or movn */
+      if (!useMovz) {
+        src16.BitwiseNegate();
+      }
+      MOperator mOpCode = useMovz ? MOP_xmovzri16 : MOP_xmovnri16;
+      newInsn = &GetInsnBuilder()->BuildInsn(mOpCode, destReg, src16, *lslOpnd);
+      useMovk = true;
+    } else {
+      newInsn = &GetInsnBuilder()->BuildInsn(MOP_xmovkri16, destReg, src16, *lslOpnd);
+    }
+    if (curInsn != nullptr) {
+      bb->InsertInsnBefore(*curInsn, *newInsn);
+    } else {
+      bb->AppendInsn(*newInsn);
+    }
+  }
+
+  if (maxLoopTime == 2) {
+    /* copy lower 32 bits to higher 32 bits */
+    ImmOperand &immOpnd = CreateImmOperand(k32BitSize, k8BitSize, false);
+    Insn &insn = GetInsnBuilder()->BuildInsn(MOP_xbfirri6i6, destReg, destReg, immOpnd, immOpnd);
+    if (curInsn != nullptr) {
+      bb->InsertInsnBefore(*curInsn, insn);
+    } else {
+      bb->AppendInsn(insn);
+    }
+  }
+}
+
+void AArch64CGFunc::SelectCopyRegOpnd(Operand &dest, PrimType dtype, Operand::OperandType opndType,
+                                      uint32 dsize, Operand &src, PrimType stype) {
+  if (opndType != Operand::kOpdMem) {
+    if (!CGOptions::IsArm64ilp32()) {
+      ASSERT(stype != PTY_a32, "");
+    }
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickMovBetweenRegs(dtype, stype), dest, src));
+    return;
+  }
+  AArch64isa::MemoryOrdering memOrd = AArch64isa::kMoNone;
+  const MIRSymbol *sym = static_cast<MemOperand*>(&dest)->GetSymbol();
+  if ((sym != nullptr) && (sym->GetStorageClass() == kScGlobal) && sym->GetAttr(ATTR_memory_order_release)) {
+    memOrd = AArch64isa::kMoRelease;
+  }
+
+  if (memOrd != AArch64isa::kMoNone) {
+    AArch64CGFunc::SelectStoreRelease(dest, dtype, src, stype, memOrd, true);
+    return;
+  }
+
+  bool is64Bits = (dest.GetSize() == k64BitSize) ? true : false;
+  MOperator strMop = PickStInsn(dsize, stype);
+  if (!dest.IsMemoryAccessOperand()) {
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(strMop, src, dest));
+    return;
+  }
+
+  MemOperand *memOpnd = static_cast<MemOperand*>(&dest);
+  ASSERT(memOpnd != nullptr, "memOpnd should not be nullptr");
+  if (memOpnd->GetAddrMode() == MemOperand::kAddrModeLo12Li) {
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(strMop, src, dest));
+    return;
+  }
+  if (memOpnd->GetOffsetOperand() == nullptr) {
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(strMop, src, dest));
+    return;
+  }
+  ImmOperand *immOpnd = static_cast<ImmOperand*>(memOpnd->GetOffsetOperand());
+  ASSERT(immOpnd != nullptr, "immOpnd should not be nullptr");
+  int64 immVal = immOpnd->GetValue();
+  bool isIntactIndexed = memOpnd->IsIntactIndexed();
+  bool isPostIndexed = memOpnd->IsPostIndexed();
+  bool isPreIndexed = memOpnd->IsPreIndexed();
+  ASSERT(!isPostIndexed, "memOpnd should not be post-index type");
+  ASSERT(!isPreIndexed, "memOpnd should not be pre-index type");
+  bool isInRange = false;
+  if (!GetMirModule().IsCModule()) {
+    isInRange = IsImmediateValueInRange(strMop, immVal, is64Bits, isIntactIndexed, isPostIndexed, isPreIndexed);
+  } else {
+    isInRange = IsOperandImmValid(strMop, memOpnd, kInsnSecondOpnd);
+  }
+  bool isMopStr = IsStoreMop(strMop);
+  if (isInRange || !isMopStr) {
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(strMop, src, dest));
+    return;
+  }
+  ASSERT(memOpnd->GetBaseRegister() != nullptr, "nullptr check");
+  if (isIntactIndexed) {
+    memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, dsize);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(strMop, src, *memOpnd));
+  } else if (isPostIndexed || isPreIndexed) {
+    RegOperand &reg = CreateRegisterOperandOfType(PTY_i64);
+    MOperator mopMov = MOP_xmovri64;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopMov, reg, *immOpnd));
+    MOperator mopAdd = MOP_xaddrrr;
+    MemOperand &newDest =
+        GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, GetPrimTypeBitSize(dtype), memOpnd->GetBaseRegister(),
+                           nullptr, &GetOrCreateOfstOpnd(0, k32BitSize), nullptr);
+    Insn &insn1 = GetInsnBuilder()->BuildInsn(strMop, src, newDest);
+    Insn &insn2 = GetInsnBuilder()->BuildInsn(mopAdd, *newDest.GetBaseRegister(), *newDest.GetBaseRegister(), reg);
+    if (isPostIndexed) {
+      GetCurBB()->AppendInsn(insn1);
+      GetCurBB()->AppendInsn(insn2);
+    } else {
+      /* isPreIndexed */
+      GetCurBB()->AppendInsn(insn2);
+      GetCurBB()->AppendInsn(insn1);
+    }
+  }
+}
+
+void AArch64CGFunc::SelectCopy(Operand &dest, PrimType dtype, Operand &src, PrimType stype) {
+  ASSERT(dest.IsRegister() || dest.IsMemoryAccessOperand(), "");
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  if (dest.IsRegister()) {
+    dsize = dest.GetSize();
+  }
+  Operand::OperandType opnd0Type = dest.GetKind();
+  Operand::OperandType opnd1Type = src.GetKind();
+  ASSERT(((dsize >= src.GetSize()) || (opnd0Type == Operand::kOpdRegister) || (opnd0Type == Operand::kOpdMem)), "NYI");
+  ASSERT(((opnd0Type == Operand::kOpdRegister) || (src.GetKind() == Operand::kOpdRegister)),
+         "either src or dest should be register");
+
+  switch (opnd1Type) {
+    case Operand::kOpdMem:
+      SelectCopyMemOpnd(dest, dtype, dsize, src, stype);
+      break;
+    case Operand::kOpdOffset:
+    case Operand::kOpdImmediate:
+      SelectCopyImm(dest, dtype, static_cast<ImmOperand&>(src), stype);
+      break;
+    case Operand::kOpdFPImmediate:
+      CHECK_FATAL(static_cast<ImmOperand&>(src).GetValue() == 0, "NIY");
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn((dsize == k32BitSize) ? MOP_xvmovsr : MOP_xvmovdr,
+          dest, GetZeroOpnd(dsize)));
+      break;
+    case Operand::kOpdRegister: {
+      if (opnd0Type == Operand::kOpdRegister && IsPrimitiveVector(stype)) {
+        /* check vector reg to vector reg move */
+        CHECK_FATAL(IsPrimitiveVector(dtype), "invalid vectreg to vectreg move");
+        MOperator mop = (dsize <= k64BitSize) ? MOP_vmovuu : MOP_vmovvv;
+        VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mop, AArch64CG::kMd[mop]);
+        (void)vInsn.AddOpndChain(dest).AddOpndChain(src);
+        auto *vecSpecSrc = GetMemoryPool()->New<VectorRegSpec>(dsize >> k3ByteSize, k8BitSize);
+        auto *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(dsize >> k3ByteSize, k8BitSize);
+        (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpecSrc);
+        GetCurBB()->AppendInsn(vInsn);
+        break;
+      }
+      RegOperand &desReg = static_cast<RegOperand&>(dest);
+      RegOperand &srcReg = static_cast<RegOperand&>(src);
+      if (desReg.GetRegisterNumber() == srcReg.GetRegisterNumber()) {
+        break;
+      }
+      SelectCopyRegOpnd(dest, dtype, opnd0Type, dsize, src, stype);
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+}
+
+/* This function copies src to a register, the src can be an imm, mem or a label */
+RegOperand &AArch64CGFunc::SelectCopy(Operand &src, PrimType stype, PrimType dtype) {
+  RegOperand &dest = CreateRegisterOperandOfType(dtype);
+  SelectCopy(dest, dtype, src, stype);
+  return dest;
+}
+
+/*
+ * We need to adjust the offset of a stack allocated local variable
+ * if we store FP/SP before any other local variables to save an instruction.
+ * See AArch64CGFunc::OffsetAdjustmentForFPLR() in aarch64_cgfunc.cpp
+ *
+ * That is when we !UsedStpSubPairForCallFrameAllocation().
+ *
+ * Because we need to use the STP/SUB instruction pair to store FP/SP 'after'
+ * local variables when the call frame size is greater that the max offset
+ * value allowed for the STP instruction (we cannot use STP w/ prefix, LDP w/
+ * postfix), if UsedStpSubPairForCallFrameAllocation(), we don't need to
+ * adjust the offsets.
+ */
+bool AArch64CGFunc::IsImmediateOffsetOutOfRange(const MemOperand &memOpnd, uint32 bitLen) {
+  ASSERT(bitLen >= k8BitSize, "bitlen error");
+  ASSERT(bitLen <= k128BitSize, "bitlen error");
+
+  if (bitLen >= k8BitSize) {
+    bitLen = static_cast<uint32>(RoundUp(bitLen, k8BitSize));
+  }
+  ASSERT((bitLen & (bitLen - 1)) == 0, "bitlen error");
+
+  MemOperand::AArch64AddressingMode mode = memOpnd.GetAddrMode();
+  if ((mode == MemOperand::kAddrModeBOi) && memOpnd.IsIntactIndexed()) {
+    OfstOperand *ofstOpnd = memOpnd.GetOffsetImmediate();
+    int32 offsetValue = ofstOpnd ? static_cast<int32>(ofstOpnd->GetOffsetValue()) : 0;
+    if (ofstOpnd && ofstOpnd->GetVary() == kUnAdjustVary) {
+      offsetValue += static_cast<int32>(static_cast<AArch64MemLayout*>(GetMemlayout())->RealStackFrameSize() + 0xff);
+    }
+    offsetValue += 2 * kIntregBytelen;  /* Refer to the above comment */
+    return MemOperand::IsPIMMOffsetOutOfRange(offsetValue, bitLen);
+  } else {
+    return false;
+  }
+}
+
+bool AArch64CGFunc::IsOperandImmValid(MOperator mOp, Operand *o, uint32 opndIdx) {
+  const InsnDesc *md = &AArch64CG::kMd[mOp];
+  auto *opndProp = md->opndMD[opndIdx];
+
+  Operand::OperandType opndTy = opndProp->GetOperandType();
+  if (opndTy == Operand::kOpdMem) {
+    auto *memOpnd = static_cast<MemOperand*>(o);
+    if (memOpnd->GetAddrMode() == MemOperand::kAddrModeBOrX) {
+      return true;
+    }
+    OfstOperand *ofStOpnd = memOpnd->GetOffsetImmediate();
+    int64 offsetValue = ofStOpnd ? ofStOpnd->GetOffsetValue() : 0LL;
+    if (md->IsLoadStorePair() ||
+        (memOpnd->GetAddrMode() == MemOperand::kAddrModeBOi && memOpnd->IsIntactIndexed())) {
+      if (ofStOpnd && ofStOpnd->GetVary() == kUnAdjustVary) {
+        offsetValue += static_cast<AArch64MemLayout*>(GetMemlayout())->RealStackFrameSize() + 0xffL;
+      }
+      return md->IsValidImmOpnd(offsetValue);
+    } else if (memOpnd->GetAddrMode() == MemOperand::kAddrModeLo12Li) {
+      return offsetValue == 0LL;
+    } else {
+      CHECK_FATAL(!memOpnd->IsIntactIndexed(), "CHECK WHAT?");
+      return (offsetValue <= static_cast<int64>(k256BitSizeInt) && offsetValue >= kNegative256BitSize);
+    }
+  } else if (opndTy == Operand::kOpdImmediate) {
+    return md->IsValidImmOpnd(static_cast<ImmOperand*>(o)->GetValue());
+  }
+  return true;
+}
+
+MemOperand &AArch64CGFunc::CreateReplacementMemOperand(uint32 bitLen,
+                                                       RegOperand &baseReg, int64 offset) {
+  return CreateMemOpnd(baseReg, offset, bitLen);
+}
+
+bool AArch64CGFunc::CheckIfSplitOffsetWithAdd(const MemOperand &memOpnd, uint32 bitLen) const {
+  if (memOpnd.GetAddrMode() != MemOperand::kAddrModeBOi || !memOpnd.IsIntactIndexed()) {
+    return false;
+  }
+  OfstOperand *ofstOpnd = memOpnd.GetOffsetImmediate();
+  int32 opndVal = static_cast<int32>(ofstOpnd->GetOffsetValue());
+  int32 maxPimm = memOpnd.GetMaxPIMM(bitLen);
+  int32 q0 = opndVal / maxPimm;
+  int32 addend = q0 * maxPimm;
+  int32 r0 = opndVal - addend;
+  int32 alignment = memOpnd.GetImmediateOffsetAlignment(bitLen);
+  int32 r1 = static_cast<uint32>(r0) & ((1u << static_cast<uint32>(alignment)) - 1);
+  addend = addend + r1;
+  return (addend > 0);
+}
+
+RegOperand *AArch64CGFunc::GetBaseRegForSplit(uint32 baseRegNum) {
+  RegOperand *resOpnd = nullptr;
+  if (baseRegNum == AArch64reg::kRinvalid) {
+    resOpnd = &CreateRegisterOperandOfType(PTY_i64);
+  } else if (AArch64isa::IsPhysicalRegister(baseRegNum)) {
+    resOpnd = &GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(baseRegNum),
+        GetPointerSize() * kBitsPerByte, kRegTyInt);
+  } else  {
+    resOpnd = &GetOrCreateVirtualRegisterOperand(baseRegNum);
+  }
+  return resOpnd;
+}
+
+/*
+ * When immediate of str/ldr is over 256bits, it should be aligned according to the reg byte size.
+ * Here we split the offset into (512 * n) and +/-(new Offset) when misaligned, to make sure that
+ * the new offet is always under 256 bits.
+ */
+MemOperand &AArch64CGFunc::ConstraintOffsetToSafeRegion(uint32 bitLen, const MemOperand &memOpnd,
+                                                        const MIRSymbol *symbol) {
+  auto it = hashMemOpndTable.find(memOpnd);
+  if (it != hashMemOpndTable.end()) {
+    hashMemOpndTable.erase(memOpnd);
+  }
+  MemOperand::AArch64AddressingMode addrMode = memOpnd.GetAddrMode();
+  int32 offsetValue = static_cast<int32>(memOpnd.GetOffsetImmediate()->GetOffsetValue());
+  RegOperand *baseReg = memOpnd.GetBaseRegister();
+  RegOperand *resOpnd = GetBaseRegForSplit(kRinvalid);
+  MemOperand *newMemOpnd = nullptr;
+  if (addrMode == MemOperand::kAddrModeBOi) {
+    int32 val256 = k256BitSizeInt; /* const val is unsigned */
+    int32 val512 = k512BitSizeInt;
+    int32 multiplier = (offsetValue / val512) + static_cast<int32>(offsetValue % val512 > val256);
+    int32 addMount = multiplier * val512;
+    int32 newOffset = offsetValue - addMount;
+    ImmOperand &immAddMount = CreateImmOperand(addMount, k64BitSize, true);
+    if (memOpnd.GetOffsetImmediate()->GetVary() == kUnAdjustVary) {
+      immAddMount.SetVary(kUnAdjustVary);
+    }
+    SelectAdd(*resOpnd, *baseReg, immAddMount, PTY_i64);
+    newMemOpnd = &CreateReplacementMemOperand(bitLen, *resOpnd, newOffset);
+  } else if (addrMode == MemOperand::kAddrModeLo12Li) {
+    CHECK_FATAL(symbol != nullptr, "must have symbol");
+    StImmOperand &stImmOpnd = CreateStImmOperand(*symbol, offsetValue, 0);
+    SelectAdd(*resOpnd, *baseReg, stImmOpnd, PTY_i64);
+    newMemOpnd = &CreateReplacementMemOperand(bitLen, *resOpnd, 0);
+  }
+  CHECK_FATAL(newMemOpnd != nullptr, "create memOpnd failed");
+  newMemOpnd->SetStackMem(memOpnd.IsStackMem());
+  return *newMemOpnd;
+}
+
+ImmOperand &AArch64CGFunc::SplitAndGetRemained(const MemOperand &memOpnd, uint32 bitLen, int64 ofstVal, bool forPair) {
+  auto it = hashMemOpndTable.find(memOpnd);
+  if (it != hashMemOpndTable.end()) {
+    (void)hashMemOpndTable.erase(memOpnd);
+  }
+  /*
+   * opndVal == Q0 * 32760(16380) + R0
+   * R0 == Q1 * 8(4) + R1
+   * ADDEND == Q0 * 32760(16380) + R1
+   * NEW_OFFSET = Q1 * 8(4)
+   * we want to generate two instructions:
+   * ADD TEMP_REG, X29, ADDEND
+   * LDR/STR TEMP_REG, [ TEMP_REG, #NEW_OFFSET ]
+   */
+  int32 maxPimm = 0;
+  if (!forPair) {
+    maxPimm = MemOperand::GetMaxPIMM(bitLen);
+  } else {
+    maxPimm = MemOperand::GetMaxPairPIMM(bitLen);
+  }
+  ASSERT(maxPimm != 0, "get max pimm failed");
+
+  int64 q0 = ofstVal / maxPimm + (ofstVal < 0 ? -1 : 0);
+  int64 addend = q0 * maxPimm;
+  uint64 r0 = static_cast<uint64>(ofstVal - addend);
+  uint64 alignment = static_cast<uint64>(static_cast<int64>(MemOperand::GetImmediateOffsetAlignment(bitLen)));
+  auto q1 = r0 >> alignment;
+  auto r1 = static_cast<int64>(r0 & ((1u << alignment) - 1));
+  auto remained = static_cast<int64>(q1 << alignment);
+  addend = addend + r1;
+  if (addend > 0) {
+    uint64 suffixClear = 0xfff;
+    if (forPair) {
+      suffixClear = 0xff;
+    }
+    int64 remainedTmp = remained + static_cast<int64>(static_cast<uint64>(addend) & suffixClear);
+    if (!MemOperand::IsPIMMOffsetOutOfRange(static_cast<int32>(remainedTmp), bitLen) &&
+        ((static_cast<uint64>(remainedTmp) & ((1u << alignment) - 1)) == 0)) {
+      addend = static_cast<int64>(static_cast<uint64>(addend) & ~suffixClear);
+    }
+  }
+  ImmOperand &immAddend = CreateImmOperand(addend, k64BitSize, true);
+  if (memOpnd.GetOffsetImmediate()->GetVary() == kUnAdjustVary) {
+    immAddend.SetVary(kUnAdjustVary);
+  }
+  return immAddend;
+}
+
+MemOperand &AArch64CGFunc::SplitOffsetWithAddInstruction(const MemOperand &memOpnd, uint32 bitLen,
+                                                         uint32 baseRegNum, bool isDest,
+                                                         Insn *insn, bool forPair) {
+  ASSERT((memOpnd.GetAddrMode() == MemOperand::kAddrModeBOi), "expect kAddrModeBOi memOpnd");
+  ASSERT(memOpnd.IsIntactIndexed(), "expect intactIndexed memOpnd");
+  OfstOperand *ofstOpnd = memOpnd.GetOffsetImmediate();
+  int64 ofstVal = ofstOpnd->GetOffsetValue();
+  RegOperand *resOpnd = GetBaseRegForSplit(baseRegNum);
+  ImmOperand &immAddend = SplitAndGetRemained(memOpnd, bitLen, ofstVal, forPair);
+  int64 remained = (ofstVal - immAddend.GetValue());
+  RegOperand *origBaseReg = memOpnd.GetBaseRegister();
+  ASSERT(origBaseReg != nullptr, "nullptr check");
+  if (insn == nullptr) {
+    SelectAdd(*resOpnd, *origBaseReg, immAddend, PTY_i64);
+  } else {
+    SelectAddAfterInsn(*resOpnd, *origBaseReg, immAddend, PTY_i64, isDest, *insn);
+  }
+  MemOperand &newMemOpnd = CreateReplacementMemOperand(bitLen, *resOpnd, remained);
+  newMemOpnd.SetStackMem(memOpnd.IsStackMem());
+  return newMemOpnd;
+}
+
+void AArch64CGFunc::SelectDassign(DassignNode &stmt, Operand &opnd0) {
+  SelectDassign(stmt.GetStIdx(), stmt.GetFieldID(), stmt.GetRHS()->GetPrimType(), opnd0);
+}
+
+/*
+ * Used for SelectDassign when do optimization for volatile store, because the stlr instruction only allow
+ * store to the memory addrress with the register base offset 0.
+ * STLR <Wt>, [<Xn|SP>{,#0}], 32-bit variant (size = 10)
+ * STLR <Xt>, [<Xn|SP>{,#0}], 64-bit variant (size = 11)
+ * So the function do the prehandle of the memory operand to satisify the Store-Release..
+ */
+RegOperand *AArch64CGFunc::ExtractNewMemBase(const MemOperand &memOpnd) {
+  const MIRSymbol *sym = memOpnd.GetSymbol();
+  MemOperand::AArch64AddressingMode mode = memOpnd.GetAddrMode();
+  if (mode == MemOperand::kAddrModeLiteral) {
+    return nullptr;
+  }
+  RegOperand *baseOpnd = memOpnd.GetBaseRegister();
+  ASSERT(baseOpnd != nullptr, "nullptr check");
+  RegOperand &resultOpnd = CreateRegisterOperandOfType(baseOpnd->GetRegisterType(), baseOpnd->GetSize() / kBitsPerByte);
+  bool is64Bits = (baseOpnd->GetSize() == k64BitSize);
+  if (mode == MemOperand::kAddrModeLo12Li) {
+    StImmOperand &stImm = CreateStImmOperand(*sym, 0, 0);
+    Insn &addInsn = GetInsnBuilder()->BuildInsn(MOP_xadrpl12, resultOpnd, *baseOpnd, stImm);
+    addInsn.SetComment("new add insn");
+    GetCurBB()->AppendInsn(addInsn);
+  } else if (mode == MemOperand::kAddrModeBOi) {
+    OfstOperand *offsetOpnd = memOpnd.GetOffsetImmediate();
+    if (offsetOpnd->GetOffsetValue() != 0) {
+      MOperator mOp = is64Bits ? MOP_xaddrri12 : MOP_waddrri12;
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resultOpnd, *baseOpnd, *offsetOpnd));
+    } else {
+      return baseOpnd;
+    }
+  } else {
+    CHECK_FATAL(mode == MemOperand::kAddrModeBOrX, "unexpect addressing mode.");
+    RegOperand *regOpnd = static_cast<const MemOperand*>(&memOpnd)->GetIndexRegister();
+    MOperator mOp = is64Bits ? MOP_xaddrrr : MOP_waddrrr;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resultOpnd, *baseOpnd, *regOpnd));
+  }
+  return &resultOpnd;
+}
+
+/*
+ * NOTE: I divided SelectDassign so that we can create "virtual" assignments
+ * when selecting other complex Maple IR instructions. For example, the atomic
+ * exchange and other intrinsics will need to assign its results to local
+ * variables. Such Maple IR instructions are pltform-specific (e.g.
+ * atomic_exchange can be implemented as one single machine intruction on x86_64
+ * and ARMv8.1, but ARMv8.0 needs an LL/SC loop), therefore they cannot (in
+ * principle) be lowered at BELowerer or CGLowerer.
+ */
+void AArch64CGFunc::SelectDassign(StIdx stIdx, FieldID fieldId, PrimType rhsPType, Operand &opnd0) {
+  MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(stIdx);
+  int32 offset = 0;
+  bool parmCopy = false;
+  if (fieldId != 0) {
+    MIRStructType *structType = static_cast<MIRStructType*>(symbol->GetType());
+    ASSERT(structType != nullptr, "SelectDassign: non-zero fieldID for non-structure");
+    offset = GetBecommon().GetFieldOffset(*structType, fieldId).first;
+    parmCopy = IsParamStructCopy(*symbol);
+  }
+  uint32 regSize = GetPrimTypeBitSize(rhsPType);
+  MIRType *type = symbol->GetType();
+  Operand &stOpnd = LoadIntoRegister(opnd0, IsPrimitiveInteger(rhsPType) ||
+                                     IsPrimitiveVectorInteger(rhsPType), regSize,
+                                     IsSignedInteger(type->GetPrimType()));
+  MOperator mOp = MOP_undef;
+  if ((type->GetKind() == kTypeStruct) || (type->GetKind() == kTypeUnion)) {
+    MIRStructType *structType = static_cast<MIRStructType*>(type);
+    type = structType->GetFieldType(fieldId);
+  } else if (type->GetKind() == kTypeClass) {
+    MIRClassType *classType = static_cast<MIRClassType*>(type);
+    type = classType->GetFieldType(fieldId);
+  }
+
+  uint32 dataSize = GetPrimTypeBitSize(type->GetPrimType());
+  if (type->GetPrimType() == PTY_agg) {
+    dataSize = GetPrimTypeBitSize(PTY_a64);
+  }
+  MemOperand *memOpnd = nullptr;
+  if (parmCopy) {
+    memOpnd = &LoadStructCopyBase(*symbol, offset, static_cast<int>(dataSize));
+  } else {
+    memOpnd = &GetOrCreateMemOpnd(*symbol, offset, dataSize);
+  }
+  if ((memOpnd->GetMemVaryType() == kNotVary) && IsImmediateOffsetOutOfRange(*memOpnd, dataSize)) {
+    memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, dataSize);
+  }
+
+  /* In bpl mode, a func symbol's type is represented as a MIRFuncType instead of a MIRPtrType (pointing to
+   * MIRFuncType), so we allow `kTypeFunction` to appear here */
+  ASSERT(((type->GetKind() == kTypeScalar) || (type->GetKind() == kTypePointer) || (type->GetKind() == kTypeFunction) ||
+          (type->GetKind() == kTypeStruct) || (type->GetKind() == kTypeUnion)|| (type->GetKind() == kTypeArray)),
+         "NYI dassign type");
+  PrimType ptyp = type->GetPrimType();
+  if (ptyp == PTY_agg) {
+    ptyp = PTY_a64;
+  }
+
+  AArch64isa::MemoryOrdering memOrd = AArch64isa::kMoNone;
+  if (isVolStore) {
+    RegOperand *baseOpnd = ExtractNewMemBase(*memOpnd);
+    if (baseOpnd != nullptr) {
+      memOpnd = &CreateMemOpnd(*baseOpnd, 0, dataSize);
+      memOrd = AArch64isa::kMoRelease;
+      isVolStore = false;
+    }
+  }
+
+  memOpnd = memOpnd->IsOffsetMisaligned(dataSize) ?
+            &ConstraintOffsetToSafeRegion(dataSize, *memOpnd, symbol) : memOpnd;
+  if (symbol->GetAsmAttr() != UStrIdx(0) &&
+      symbol->GetStorageClass() != kScPstatic && symbol->GetStorageClass() != kScFstatic) {
+    std::string regDesp = GlobalTables::GetUStrTable().GetStringFromStrIdx(symbol->GetAsmAttr());
+    RegOperand &specifiedOpnd = GetOrCreatePhysicalRegisterOperand(regDesp);
+    SelectCopy(specifiedOpnd, type->GetPrimType(), opnd0, rhsPType);
+  } else if (memOrd == AArch64isa::kMoNone) {
+    mOp = PickStInsn(GetPrimTypeBitSize(ptyp), ptyp);
+    Insn &insn = GetInsnBuilder()->BuildInsn(mOp, stOpnd, *memOpnd);
+    if (GetCG()->GenerateVerboseCG()) {
+      insn.SetComment(GenerateMemOpndVerbose(*memOpnd));
+    }
+    GetCurBB()->AppendInsn(insn);
+  } else {
+    AArch64CGFunc::SelectStoreRelease(*memOpnd, ptyp, stOpnd, ptyp, memOrd, true);
+  }
+}
+
+void AArch64CGFunc::SelectDassignoff(DassignoffNode &stmt, Operand &opnd0) {
+  MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(stmt.stIdx);
+  int64 offset = stmt.offset;
+  uint32 size = GetPrimTypeSize(stmt.GetPrimType()) * k8ByteSize;
+  MOperator mOp = (size == k16BitSize) ? MOP_wstrh :
+                      ((size == k32BitSize) ? MOP_wstr :
+                          ((size == k64BitSize) ? MOP_xstr : MOP_undef));
+  CHECK_FATAL(mOp != MOP_undef, "illegal size for dassignoff");
+  MemOperand *memOpnd = &GetOrCreateMemOpnd(*symbol, offset, size);
+  if ((memOpnd->GetMemVaryType() == kNotVary) &&
+      (IsImmediateOffsetOutOfRange(*memOpnd, size) || (offset % 8 != 0))) {
+    memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, size);
+  }
+  Operand &stOpnd = LoadIntoRegister(opnd0, true, size, false);
+  memOpnd = memOpnd->IsOffsetMisaligned(size) ?
+            &ConstraintOffsetToSafeRegion(size, *memOpnd, symbol) : memOpnd;
+  Insn &insn = GetInsnBuilder()->BuildInsn(mOp, stOpnd, *memOpnd);
+  GetCurBB()->AppendInsn(insn);
+}
+
+void AArch64CGFunc::SelectAssertNull(UnaryStmtNode &stmt) {
+  Operand *opnd0 = HandleExpr(stmt, *stmt.Opnd(0));
+  RegOperand &baseReg = LoadIntoRegister(*opnd0, PTY_a64);
+  auto &zwr = GetZeroOpnd(k32BitSize);
+  auto &mem = CreateMemOpnd(baseReg, 0, k32BitSize);
+  Insn &loadRef = GetInsnBuilder()->BuildInsn(MOP_wldr, zwr, mem);
+  loadRef.SetDoNotRemove(true);
+  if (GetCG()->GenerateVerboseCG()) {
+    loadRef.SetComment("null pointer check");
+  }
+  GetCurBB()->AppendInsn(loadRef);
+}
+
+void AArch64CGFunc::SelectAbort() {
+  RegOperand &inOpnd = GetOrCreatePhysicalRegisterOperand(R16, k64BitSize, kRegTyInt);
+  auto &mem = CreateMemOpnd(inOpnd, 0, k64BitSize);
+  Insn &movXzr = GetInsnBuilder()->BuildInsn(MOP_xmovri64, inOpnd, CreateImmOperand(0, k64BitSize, false));
+  Insn &loadRef = GetInsnBuilder()->BuildInsn(MOP_wldr, GetZeroOpnd(k64BitSize), mem);
+  loadRef.SetDoNotRemove(true);
+  movXzr.SetDoNotRemove(true);
+  GetCurBB()->AppendInsn(movXzr);
+  GetCurBB()->AppendInsn(loadRef);
+  SetCurBBKind(BB::kBBGoto);
+  LabelOperand &targetOpnd = GetOrCreateLabelOperand(GetReturnLabel()->GetLabelIdx());
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xuncond, targetOpnd));
+}
+
+static std::string GetRegPrefixFromPrimType(PrimType pType, uint32 size, const std::string &constraint) {
+  std::string regPrefix = "";
+  /* memory access check */
+  if (constraint.find("m") != std::string::npos || constraint.find("Q") != std::string::npos) {
+    regPrefix += "[";
+  }
+  if (IsPrimitiveVector(pType)) {
+    regPrefix += "v";
+  } else if (IsPrimitiveInteger(pType)) {
+    if (size == k32BitSize) {
+      regPrefix += "w";
+    } else {
+      regPrefix += "x";
+    }
+  } else {
+    if (size == k32BitSize) {
+      regPrefix += "s";
+    } else {
+      regPrefix += "d";
+    }
+  }
+  return regPrefix;
+}
+
+void AArch64CGFunc::SelectAsm(AsmNode &node) {
+  SetHasAsm();
+  if (Globals::GetInstance()->GetOptimLevel() > CGOptions::kLevel0) {
+    if (GetCG()->GetCGOptions().DoLinearScanRegisterAllocation()) {
+      LogInfo::MapleLogger() << "Using coloring RA\n";
+      const_cast<CGOptions &>(GetCG()->GetCGOptions()).SetOption(CGOptions::kDoColorRegAlloc);
+      const_cast<CGOptions &>(GetCG()->GetCGOptions()).ClearOption(CGOptions::kDoLinearScanRegAlloc);
+    }
+  }
+  Operand *asmString = &CreateStringOperand(node.asmString);
+  ListOperand *listInputOpnd = CreateListOpnd(*GetFuncScopeAllocator());
+  ListOperand *listOutputOpnd = CreateListOpnd(*GetFuncScopeAllocator());
+  ListOperand *listClobber = CreateListOpnd(*GetFuncScopeAllocator());
+  ListConstraintOperand *listInConstraint = memPool->New<ListConstraintOperand>(*GetFuncScopeAllocator());
+  ListConstraintOperand *listOutConstraint = memPool->New<ListConstraintOperand>(*GetFuncScopeAllocator());
+  ListConstraintOperand *listInRegPrefix = memPool->New<ListConstraintOperand>(*GetFuncScopeAllocator());
+  ListConstraintOperand *listOutRegPrefix = memPool->New<ListConstraintOperand>(*GetFuncScopeAllocator());
+  std::list<std::pair<Operand*, PrimType>> rPlusOpnd;
+  bool noReplacement = false;
+  if (node.asmString.find('$') == std::string::npos) {
+    /* no replacements */
+    noReplacement = true;
+  }
+  /* input constraints should be processed before OP_asm instruction */
+  for (size_t i = 0; i < node.numOpnds; ++i) {
+    /* process input constraint */
+    std::string str = GlobalTables::GetUStrTable().GetStringFromStrIdx(node.inputConstraints[i]);
+    bool isOutputTempNode = false;
+    if (str[0] == '+') {
+      isOutputTempNode = true;
+    }
+    listInConstraint->stringList.push_back(static_cast<StringOperand*>(&CreateStringOperand(str)));
+    /* process input operands */
+    switch (node.Opnd(i)->op) {
+      case OP_dread: {
+        DreadNode &dread = static_cast<DreadNode&>(*node.Opnd(i));
+        Operand *inOpnd = SelectDread(node, dread);
+        PrimType pType = dread.GetPrimType();
+        listInputOpnd->PushOpnd(static_cast<RegOperand&>(*inOpnd));
+        listInRegPrefix->stringList.push_back(
+            static_cast<StringOperand*>(&CreateStringOperand(GetRegPrefixFromPrimType(pType, inOpnd->GetSize(), str))));
+        if (isOutputTempNode) {
+          rPlusOpnd.emplace_back(std::make_pair(inOpnd, pType));
+        }
+        break;
+      }
+      case OP_addrof: {
+        auto &addrofNode = static_cast<AddrofNode&>(*node.Opnd(i));
+        Operand *inOpnd = SelectAddrof(addrofNode, node, false);
+        listInputOpnd->PushOpnd(static_cast<RegOperand&>(*inOpnd));
+        PrimType pType = addrofNode.GetPrimType();
+        listInRegPrefix->stringList.push_back(
+            static_cast<StringOperand*>(&CreateStringOperand(GetRegPrefixFromPrimType(pType, inOpnd->GetSize(), str))));
+        if (isOutputTempNode) {
+          rPlusOpnd.emplace_back(std::make_pair(inOpnd, pType));
+        }
+        break;
+      }
+      case OP_addrofoff: {
+        auto &addrofoffNode = static_cast<AddrofoffNode&>(*node.Opnd(i));
+        Operand *inOpnd = SelectAddrofoff(addrofoffNode, node);
+        listInputOpnd->PushOpnd(static_cast<RegOperand&>(*inOpnd));
+        PrimType pType = addrofoffNode.GetPrimType();
+        listInRegPrefix->stringList.push_back(
+            static_cast<StringOperand*>(&CreateStringOperand(GetRegPrefixFromPrimType(pType, inOpnd->GetSize(), str))));
+        if (isOutputTempNode) {
+          rPlusOpnd.emplace_back(std::make_pair(inOpnd, pType));
+        }
+        break;
+      }
+      case OP_ireadoff: {
+        IreadoffNode *ireadoff = static_cast<IreadoffNode*>(node.Opnd(i));
+        Operand *inOpnd = SelectIreadoff(node, *ireadoff);
+        listInputOpnd->PushOpnd(static_cast<RegOperand&>(*inOpnd));
+        PrimType pType = ireadoff->GetPrimType();
+        listInRegPrefix->stringList.push_back(
+            static_cast<StringOperand*>(&CreateStringOperand(GetRegPrefixFromPrimType(pType, inOpnd->GetSize(), str))));
+        if (isOutputTempNode) {
+          rPlusOpnd.emplace_back(std::make_pair(inOpnd, pType));
+        }
+        break;
+      }
+      case OP_ireadfpoff: {
+        IreadFPoffNode *ireadfpoff = static_cast<IreadFPoffNode*>(node.Opnd(i));
+        Operand *inOpnd = SelectIreadfpoff(node, *ireadfpoff);
+        listInputOpnd->PushOpnd(static_cast<RegOperand&>(*inOpnd));
+        PrimType pType = ireadfpoff->GetPrimType();
+        listInRegPrefix->stringList.push_back(
+            static_cast<StringOperand*>(&CreateStringOperand(GetRegPrefixFromPrimType(pType, inOpnd->GetSize(), str))));
+        if (isOutputTempNode) {
+          rPlusOpnd.emplace_back(std::make_pair(inOpnd, pType));
+        }
+        break;
+      }
+      case OP_iread: {
+        IreadNode *iread = static_cast<IreadNode*>(node.Opnd(i));
+        Operand *inOpnd = SelectIread(node, *iread);
+        listInputOpnd->PushOpnd(static_cast<RegOperand&>(*inOpnd));
+        PrimType pType = iread->GetPrimType();
+        listInRegPrefix->stringList.push_back(
+            static_cast<StringOperand*>(&CreateStringOperand(GetRegPrefixFromPrimType(pType, inOpnd->GetSize(), str))));
+        if (isOutputTempNode) {
+          rPlusOpnd.emplace_back(std::make_pair(inOpnd, pType));
+        }
+        break;
+      }
+      case OP_add: {
+        BinaryNode *addNode = static_cast<BinaryNode*>(node.Opnd(i));
+        Operand *inOpnd = SelectAdd(*addNode, *HandleExpr(*addNode, *addNode->Opnd(0)),
+                                    *HandleExpr(*addNode, *addNode->Opnd(1)), node);
+        listInputOpnd->PushOpnd(static_cast<RegOperand&>(*inOpnd));
+        PrimType pType = addNode->GetPrimType();
+        listInRegPrefix->stringList.push_back(static_cast<StringOperand*>(&CreateStringOperand(
+            GetRegPrefixFromPrimType(pType, inOpnd->GetSize(), str))));
+        if (isOutputTempNode) {
+          rPlusOpnd.emplace_back(std::make_pair(inOpnd, pType));
+        }
+        break;
+      }
+      case OP_constval: {
+        CHECK_FATAL(!isOutputTempNode, "Unexpect");
+        auto &constNode = static_cast<ConstvalNode&>(*node.Opnd(i));
+        CHECK_FATAL(constNode.GetConstVal()->GetKind() == kConstInt, "expect MIRIntConst does not support float yet");
+        MIRIntConst *mirIntConst = safe_cast<MIRIntConst>(constNode.GetConstVal());
+        CHECK_FATAL(mirIntConst != nullptr, "just checking");
+        int64 scale = mirIntConst->GetExtValue();
+        if (str.find("r") != std::string::npos) {
+          bool isSigned = scale < 0;
+          ImmOperand &immOpnd = CreateImmOperand(scale, k64BitSize, isSigned);
+          /* set default type as a 64 bit reg */
+          PrimType pty = isSigned ? PTY_i64 : PTY_u64;
+          auto &tempReg = static_cast<Operand&>(CreateRegisterOperandOfType(pty));
+          SelectCopy(tempReg, pty, immOpnd, isSigned ? PTY_i64 : PTY_u64);
+          listInputOpnd->PushOpnd(static_cast<RegOperand&>(tempReg));
+          listInRegPrefix->stringList.push_back(
+              static_cast<StringOperand*>(&CreateStringOperand(GetRegPrefixFromPrimType(pty, tempReg.GetSize(), str))));
+        } else {
+          RegOperand &inOpnd = GetOrCreatePhysicalRegisterOperand(RZR, k64BitSize, kRegTyInt);
+          listInputOpnd->PushOpnd(static_cast<RegOperand&>(inOpnd));
+
+          listInRegPrefix->stringList.push_back(
+              static_cast<StringOperand*>(&CreateStringOperand("i" + std::to_string(scale))));
+        }
+        break;
+      }
+      case OP_regread: {
+        auto &regreadNode = static_cast<RegreadNode&>(*node.Opnd(i));
+        PregIdx pregIdx = regreadNode.GetRegIdx();
+        MIRPreg *preg = GetFunction().GetPregTab()->PregFromPregIdx(pregIdx);
+        PrimType pType = preg->GetPrimType();
+        RegOperand *inOpnd;
+        if (IsSpecialPseudoRegister(pregIdx)) {
+          inOpnd = &GetOrCreateSpecialRegisterOperand(-pregIdx, pType);
+        } else {
+          inOpnd = &GetOrCreateVirtualRegisterOperand(GetVirtualRegNOFromPseudoRegIdx(pregIdx));
+        }
+        listInputOpnd->PushOpnd(static_cast<RegOperand&>(*inOpnd));
+        listInRegPrefix->stringList.push_back(static_cast<StringOperand *>(&CreateStringOperand(
+            GetRegPrefixFromPrimType(pType, inOpnd->GetSize(), str))));
+        if (isOutputTempNode) {
+          (void)rPlusOpnd.emplace_back(std::make_pair(&static_cast<Operand&>(*inOpnd), pType));
+        }
+        break;
+      }
+      default:
+        CHECK_FATAL(false, "Inline asm input expression not handled");
+    }
+  }
+  std::vector<Operand*> intrnOpnds;
+  intrnOpnds.emplace_back(asmString);
+  intrnOpnds.emplace_back(listOutputOpnd);
+  intrnOpnds.emplace_back(listClobber);
+  intrnOpnds.emplace_back(listInputOpnd);
+  intrnOpnds.emplace_back(listOutConstraint);
+  intrnOpnds.emplace_back(listInConstraint);
+  intrnOpnds.emplace_back(listOutRegPrefix);
+  intrnOpnds.emplace_back(listInRegPrefix);
+  Insn *asmInsn = &GetInsnBuilder()->BuildInsn(MOP_asm, intrnOpnds);
+  GetCurBB()->AppendInsn(*asmInsn);
+
+  /* process listOutputOpnd */
+  for (size_t i = 0; i < node.asmOutputs.size(); ++i) {
+    bool isOutputTempNode = false;
+    RegOperand *rPOpnd = nullptr;
+    /* process output constraint */
+    std::string str = GlobalTables::GetUStrTable().GetStringFromStrIdx(node.outputConstraints[i]);
+
+    listOutConstraint->stringList.push_back(static_cast<StringOperand*>(&CreateStringOperand(str)));
+    if (str[0] == '+') {
+      CHECK_FATAL(!rPlusOpnd.empty(), "Need r+ operand");
+      rPOpnd = static_cast<RegOperand*>((rPlusOpnd.begin()->first));
+      listOutputOpnd->PushOpnd(*rPOpnd);
+      listOutRegPrefix->stringList.push_back(static_cast<StringOperand*>(
+          &CreateStringOperand(GetRegPrefixFromPrimType(rPlusOpnd.begin()->second, rPOpnd->GetSize(), str))));
+      if (!rPlusOpnd.empty()) {
+        rPlusOpnd.pop_front();
+      }
+      isOutputTempNode = true;
+    }
+    if (str.find("Q") != std::string::npos || str.find("m") != std::string::npos) {
+      continue;
+    }
+    /* process output operands */
+    StIdx stIdx = node.asmOutputs[i].first;
+    RegFieldPair regFieldPair = node.asmOutputs[i].second;
+    if (regFieldPair.IsReg()) {
+      PregIdx pregIdx = static_cast<PregIdx>(regFieldPair.GetPregIdx());
+      MIRPreg *mirPreg = mirModule.CurFunction()->GetPregTab()->PregFromPregIdx(pregIdx);
+      RegOperand *outOpnd =
+          isOutputTempNode ? rPOpnd : &GetOrCreateVirtualRegisterOperand(GetVirtualRegNOFromPseudoRegIdx(pregIdx));
+      PrimType srcType = mirPreg->GetPrimType();
+      PrimType destType = srcType;
+      if (GetPrimTypeBitSize(destType) < k32BitSize) {
+        destType = IsSignedInteger(destType) ? PTY_i32 : PTY_u32;
+      }
+      RegType rtype = GetRegTyFromPrimTy(srcType);
+      RegOperand &opnd0 = isOutputTempNode ?
+                          GetOrCreateVirtualRegisterOperand(GetVirtualRegNOFromPseudoRegIdx(pregIdx)) :
+                          CreateVirtualRegisterOperand(NewVReg(rtype, GetPrimTypeSize(srcType)));
+      SelectCopy(opnd0, destType, *outOpnd, srcType);
+      if (!isOutputTempNode) {
+        listOutputOpnd->PushOpnd(static_cast<RegOperand&>(*outOpnd));
+        listOutRegPrefix->stringList.push_back(static_cast<StringOperand*>(
+            &CreateStringOperand(GetRegPrefixFromPrimType(srcType, outOpnd->GetSize(), str))));
+      }
+    } else {
+      MIRSymbol *var;
+      if (stIdx.IsGlobal()) {
+        var = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+      } else {
+        var = mirModule.CurFunction()->GetSymbolTabItem(stIdx.Idx());
+      }
+      CHECK_FATAL(var != nullptr, "var should not be nullptr");
+      if (!noReplacement || var->GetAsmAttr() != UStrIdx(0)) {
+        RegOperand *outOpnd = nullptr;
+        PrimType pty = GlobalTables::GetTypeTable().GetTypeTable().at(var->GetTyIdx())->GetPrimType();
+        if (var->GetAsmAttr() != UStrIdx(0)) {
+          std::string regDesp = GlobalTables::GetUStrTable().GetStringFromStrIdx(var->GetAsmAttr());
+          outOpnd = &GetOrCreatePhysicalRegisterOperand(regDesp);
+        } else  {
+          RegType rtype = GetRegTyFromPrimTy(pty);
+          outOpnd = isOutputTempNode ? rPOpnd : &CreateVirtualRegisterOperand(NewVReg(rtype, GetPrimTypeSize(pty)));
+        }
+        SaveReturnValueInLocal(node.asmOutputs, i, PTY_a64, *outOpnd, node);
+        if (!isOutputTempNode) {
+          listOutputOpnd->PushOpnd(static_cast<RegOperand&>(*outOpnd));
+          listOutRegPrefix->stringList.push_back(
+              static_cast<StringOperand*>(&CreateStringOperand(
+                  GetRegPrefixFromPrimType(pty, outOpnd->GetSize(), str))));
+        }
+      }
+    }
+  }
+  if (noReplacement) {
+    return;
+  }
+
+  /* process listClobber */
+  for (size_t i = 0; i < node.clobberList.size(); ++i) {
+    std::string str = GlobalTables::GetUStrTable().GetStringFromStrIdx(node.clobberList[i]);
+    auto regno = static_cast<regno_t>(static_cast<int32>(str[1]) - kZeroAsciiNum);
+    if (str[2] >= '0' && str[2] <= '9') {
+      regno = regno * kDecimalMax + static_cast<uint32>((static_cast<int32>(str[2]) - kZeroAsciiNum));
+    }
+    RegOperand *reg;
+    switch (str[0]) {
+      case 'w': {
+        reg = &GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(regno + R0), k32BitSize, kRegTyInt);
+        listClobber->PushOpnd(*reg);
+        break;
+      }
+      case 'x': {
+        reg = &GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(regno + R0), k64BitSize, kRegTyInt);
+        listClobber->PushOpnd(*reg);
+        break;
+      }
+      case 's': {
+        reg = &GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(regno + V0), k32BitSize, kRegTyFloat);
+        listClobber->PushOpnd(*reg);
+        break;
+      }
+      case 'd': {
+        reg = &GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(regno + V0), k64BitSize, kRegTyFloat);
+        listClobber->PushOpnd(*reg);
+        break;
+      }
+      case 'v': {
+        reg = &GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(regno + V0), k64BitSize, kRegTyFloat);
+        listClobber->PushOpnd(*reg);
+        break;
+      }
+      case 'c': {
+        asmInsn->SetAsmDefCondCode();
+        break;
+      }
+      case 'm': {
+        asmInsn->SetAsmModMem();
+        break;
+      }
+      default:
+        CHECK_FATAL(false, "Inline asm clobber list not handled");
+    }
+  }
+}
+
+void AArch64CGFunc::SelectRegassign(RegassignNode &stmt, Operand &opnd0) {
+  if (GetCG()->IsLmbc()) {
+    PrimType lhsSize = stmt.GetPrimType();
+    PrimType rhsSize = stmt.Opnd(0)->GetPrimType();
+    if (lhsSize != rhsSize && stmt.Opnd(0)->GetOpCode() == OP_ireadoff) {
+      Insn *prev = GetCurBB()->GetLastInsn();
+      if (prev->GetMachineOpcode() == MOP_wldrsb || prev->GetMachineOpcode() == MOP_wldrsh) {
+        opnd0.SetSize(GetPrimTypeBitSize(stmt.GetPrimType()));
+        prev->SetMOP(AArch64CG::kMd[prev->GetMachineOpcode() == MOP_wldrsb ? MOP_xldrsb : MOP_xldrsh]);
+      } else if (prev->GetMachineOpcode() == MOP_wldr && stmt.GetPrimType() == PTY_i64) {
+        opnd0.SetSize(GetPrimTypeBitSize(stmt.GetPrimType()));
+        prev->SetMOP(AArch64CG::kMd[MOP_xldrsw]);
+      }
+    }
+  }
+  RegOperand *regOpnd = nullptr;
+  PregIdx pregIdx = stmt.GetRegIdx();
+  if (IsSpecialPseudoRegister(pregIdx)) {
+    if (GetCG()->IsLmbc() && stmt.GetPrimType() == PTY_agg) {
+      if (static_cast<RegOperand&>(opnd0).IsOfIntClass()) {
+        regOpnd = &GetOrCreateSpecialRegisterOperand(-pregIdx, PTY_i64);
+      } else if (opnd0.GetSize() <= k4ByteSize) {
+        regOpnd = &GetOrCreateSpecialRegisterOperand(-pregIdx, PTY_f32);
+      } else {
+        regOpnd = &GetOrCreateSpecialRegisterOperand(-pregIdx, PTY_f64);
+      }
+    } else {
+      regOpnd = &GetOrCreateSpecialRegisterOperand(-pregIdx, stmt.GetPrimType());
+    }
+  } else {
+    regOpnd = &GetOrCreateVirtualRegisterOperand(GetVirtualRegNOFromPseudoRegIdx(pregIdx));
+  }
+  /* look at rhs */
+  PrimType rhsType = stmt.Opnd(0)->GetPrimType();
+  if (GetCG()->IsLmbc() && rhsType == PTY_agg) {
+    /* This occurs when a call returns a small struct */
+    /* The subtree should already taken care of the agg type that is in excess of 8 bytes */
+    rhsType = PTY_i64;
+  }
+  PrimType dtype = rhsType;
+  if (GetPrimTypeBitSize(dtype) < k32BitSize) {
+    ASSERT(IsPrimitiveInteger(dtype), "");
+    dtype = IsSignedInteger(dtype) ? PTY_i32 : PTY_u32;
+  }
+  ASSERT(regOpnd != nullptr, "null ptr check!");
+  SelectCopy(*regOpnd, dtype, opnd0, rhsType);
+  if (GetCG()->GenerateVerboseCG()) {
+    if (GetCurBB()->GetLastInsn()) {
+      GetCurBB()->GetLastInsn()->AppendComment(" regassign %" + std::to_string(pregIdx) + "; ");
+    } else if (GetCurBB()->GetPrev()->GetLastInsn()) {
+      GetCurBB()->GetPrev()->GetLastInsn()->AppendComment(" regassign %" + std::to_string(pregIdx) + "; ");
+    }
+  }
+
+  if ((Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) && (pregIdx >= 0)) {
+    MemOperand *dest = GetPseudoRegisterSpillMemoryOperand(pregIdx);
+    PrimType stype = GetTypeFromPseudoRegIdx(pregIdx);
+    MIRPreg *preg = GetFunction().GetPregTab()->PregFromPregIdx(pregIdx);
+    uint32 srcBitLength = GetPrimTypeSize(preg->GetPrimType()) * kBitsPerByte;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickStInsn(srcBitLength, stype), *regOpnd, *dest));
+  } else if (regOpnd->GetRegisterNumber() == R0 || regOpnd->GetRegisterNumber() == R1) {
+    Insn &pseudo = GetInsnBuilder()->BuildInsn(MOP_pseudo_ret_int, *regOpnd);
+    GetCurBB()->AppendInsn(pseudo);
+  } else if (regOpnd->GetRegisterNumber() >= V0 && regOpnd->GetRegisterNumber() <= V3) {
+    Insn &pseudo = GetInsnBuilder()->BuildInsn(MOP_pseudo_ret_float, *regOpnd);
+    GetCurBB()->AppendInsn(pseudo);
+  }
+}
+
+MemOperand *AArch64CGFunc::FixLargeMemOpnd(MemOperand &memOpnd, uint32 align) {
+  MemOperand *lhsMemOpnd = &memOpnd;
+  if ((lhsMemOpnd->GetMemVaryType() == kNotVary) &&
+      IsImmediateOffsetOutOfRange(*lhsMemOpnd, align * kBitsPerByte)) {
+    RegOperand *addReg = &CreateRegisterOperandOfType(PTY_i64);
+    lhsMemOpnd = &SplitOffsetWithAddInstruction(*lhsMemOpnd, align * k8BitSize, addReg->GetRegisterNumber());
+  }
+  return lhsMemOpnd;
+}
+
+MemOperand *AArch64CGFunc::FixLargeMemOpnd(MOperator mOp, MemOperand &memOpnd, uint32 dSize, uint32 opndIdx) {
+  auto *a64MemOpnd = &memOpnd;
+  if ((a64MemOpnd->GetMemVaryType() == kNotVary) && !IsOperandImmValid(mOp, &memOpnd, opndIdx)) {
+    if (opndIdx == kInsnSecondOpnd) {
+      a64MemOpnd = &SplitOffsetWithAddInstruction(*a64MemOpnd, dSize);
+    } else if (opndIdx == kInsnThirdOpnd)  {
+      a64MemOpnd = &SplitOffsetWithAddInstruction(
+          *a64MemOpnd, dSize, AArch64reg::kRinvalid, false, nullptr, true);
+    } else {
+      CHECK_FATAL(false, "NYI");
+    }
+  }
+  return a64MemOpnd;
+}
+
+MemOperand *AArch64CGFunc::GenLargeAggFormalMemOpnd(const MIRSymbol &sym, uint32 align, int64 offset,
+                                                    bool needLow12) {
+  MemOperand *memOpnd;
+  if (sym.GetStorageClass() == kScFormal && GetBecommon().GetTypeSize(sym.GetTyIdx()) > k16ByteSize) {
+    /* formal of size of greater than 16 is copied by the caller and the pointer to it is passed. */
+    /* otherwise it is passed in register and is accessed directly. */
+    memOpnd = &GetOrCreateMemOpnd(sym, 0, align * kBitsPerByte);
+    RegOperand *vreg = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+    Insn &ldInsn = GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_i64), *vreg, *memOpnd);
+    GetCurBB()->AppendInsn(ldInsn);
+    memOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, vreg, nullptr,
+                                  &GetOrCreateOfstOpnd(static_cast<uint64>(offset), k32BitSize), nullptr);
+  } else {
+    memOpnd = &GetOrCreateMemOpnd(sym, offset, align * kBitsPerByte, false, needLow12);
+  }
+  return FixLargeMemOpnd(*memOpnd, align);
+}
+
+RegOperand *AArch64CGFunc::PrepareMemcpyParamOpnd(bool isLo12, const MIRSymbol &symbol, int64 offsetVal,
+                                                  RegOperand &baseReg) {
+  RegOperand *tgtAddr = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+  if (isLo12) {
+    StImmOperand &stImm = CreateStImmOperand(symbol, 0, 0);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrpl12, *tgtAddr, baseReg, stImm));
+  } else {
+    ImmOperand &imm = CreateImmOperand(offsetVal, k64BitSize, false);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, *tgtAddr, baseReg, imm));
+  }
+  return tgtAddr;
+}
+
+RegOperand *AArch64CGFunc::PrepareMemcpyParamOpnd(int64 offset, Operand &exprOpnd) {
+  RegOperand *tgtAddr = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+  OfstOperand *ofstOpnd = &GetOrCreateOfstOpnd(static_cast<uint64>(offset), k32BitSize);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, *tgtAddr, exprOpnd, *ofstOpnd));
+  return tgtAddr;
+}
+
+RegOperand *AArch64CGFunc::PrepareMemcpyParamOpnd(uint64 copySize) {
+  RegOperand *vregMemcpySize = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+  ImmOperand *sizeOpnd = &CreateImmOperand(static_cast<int64>(copySize), k64BitSize, false);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wmovri32, *vregMemcpySize, *sizeOpnd));
+  return vregMemcpySize;
+}
+
+Insn *AArch64CGFunc::AggtStrLdrInsert(bool bothUnion, Insn *lastStrLdr, Insn &newStrLdr) {
+  if (bothUnion) {
+    if (lastStrLdr == nullptr) {
+      GetCurBB()->AppendInsn(newStrLdr);
+    } else  {
+      GetCurBB()->InsertInsnAfter(*lastStrLdr, newStrLdr);
+    }
+  } else {
+    GetCurBB()->AppendInsn(newStrLdr);
+  }
+  return &newStrLdr;
+}
+
+void AArch64CGFunc::SelectAggDassign(DassignNode &stmt) {
+  MIRSymbol *lhsSymbol = GetFunction().GetLocalOrGlobalSymbol(stmt.GetStIdx());
+  uint32 lhsOffset = 0;
+  MIRType *lhsType = lhsSymbol->GetType();
+  bool bothUnion = false;
+  if (stmt.GetFieldID() != 0) {
+    MIRStructType *structType = static_cast<MIRStructType*>(lhsSymbol->GetType());
+    ASSERT(structType != nullptr, "SelectAggDassign: non-zero fieldID for non-structure");
+    lhsType = structType->GetFieldType(stmt.GetFieldID());
+    lhsOffset = static_cast<uint32>(GetBecommon().GetFieldOffset(*structType, stmt.GetFieldID()).first);
+    bothUnion = bothUnion || (structType->GetKind() == kTypeUnion);
+  }
+  uint32 lhsAlign = GetBecommon().GetTypeAlign(lhsType->GetTypeIndex());
+  uint64 lhsSize = GetBecommon().GetTypeSize(lhsType->GetTypeIndex());
+
+  uint32 rhsAlign;
+  uint32 alignUsed;
+  uint32 rhsOffset = 0;
+  if (stmt.GetRHS()->GetOpCode() == OP_dread) {
+    AddrofNode *rhsDread = static_cast<AddrofNode*>(stmt.GetRHS());
+    MIRSymbol *rhsSymbol = GetFunction().GetLocalOrGlobalSymbol(rhsDread->GetStIdx());
+    MIRType *rhsType = rhsSymbol->GetType();
+    if (rhsDread->GetFieldID() != 0) {
+      MIRStructType *structType = static_cast<MIRStructType*>(rhsSymbol->GetType());
+      ASSERT(structType != nullptr, "SelectAggDassign: non-zero fieldID for non-structure");
+      rhsType = structType->GetFieldType(rhsDread->GetFieldID());
+      rhsOffset = static_cast<uint32>(GetBecommon().GetFieldOffset(*structType, rhsDread->GetFieldID()).first);
+      bothUnion &= (structType->GetKind() == kTypeUnion);
+    }
+    bothUnion &= (rhsSymbol == lhsSymbol);
+    rhsAlign = GetBecommon().GetTypeAlign(rhsType->GetTypeIndex());
+    alignUsed = std::min(lhsAlign, rhsAlign);
+    ASSERT(alignUsed != 0, "expect non-zero");
+    uint32 copySize = GetAggCopySize(lhsOffset, rhsOffset, alignUsed);
+    MemOperand *rhsBaseMemOpnd;
+    if (IsParamStructCopy(*rhsSymbol)) {
+      rhsBaseMemOpnd = &LoadStructCopyBase(*rhsSymbol,
+          rhsOffset, static_cast<int>(copySize * k8BitSize));
+    } else {
+      rhsBaseMemOpnd = &GetOrCreateMemOpnd(*rhsSymbol,
+          rhsOffset, copySize * k8BitSize, false, true);
+      rhsBaseMemOpnd = FixLargeMemOpnd(*rhsBaseMemOpnd, copySize);
+    }
+    RegOperand *rhsBaseReg = rhsBaseMemOpnd->GetBaseRegister();
+    int64 rhsOffsetVal = rhsBaseMemOpnd->GetOffsetOperand()->GetValue();
+    MemOperand *lhsBaseMemOpnd = GenLargeAggFormalMemOpnd(*lhsSymbol, copySize, lhsOffset, true);
+    RegOperand *lhsBaseReg = lhsBaseMemOpnd->GetBaseRegister();
+    int64 lhsOffsetVal = lhsBaseMemOpnd->GetOffsetOperand()->GetValue();
+    bool rhsIsLo12 = (rhsBaseMemOpnd->GetAddrMode() == MemOperand::kAddrModeLo12Li);
+    bool lhsIsLo12 = (lhsBaseMemOpnd->GetAddrMode() == MemOperand::kAddrModeLo12Li);
+    if (lhsSize > kParmMemcpySize) {
+      std::vector<Operand*> opndVec;
+      RegOperand *regResult = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      opndVec.push_back(regResult);  /* result */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(lhsIsLo12, *lhsSymbol, lhsOffsetVal, *lhsBaseReg));  /* param 0 */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(rhsIsLo12, *rhsSymbol, rhsOffsetVal, *rhsBaseReg));  /* param 1 */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(lhsSize));  /* param 2 */
+
+      SelectLibCall("memcpy", opndVec, PTY_a64, PTY_a64);
+
+      return;
+    }
+    Insn *lastLdr = nullptr;
+    Insn *lastStr = nullptr;
+    for (uint32 i = 0; i < (lhsSize / copySize); i++) {
+      uint64 rhsBaseOffset = i * copySize + static_cast<uint64>(rhsOffsetVal);
+      uint64 lhsBaseOffset = i * copySize + static_cast<uint64>(lhsOffsetVal);
+      MemOperand::AArch64AddressingMode addrMode =
+          rhsIsLo12 ? MemOperand::kAddrModeLo12Li : MemOperand::kAddrModeBOi;
+      MIRSymbol *sym = rhsIsLo12 ? rhsSymbol : nullptr;
+      OfstOperand &rhsOfstOpnd = GetOrCreateOfstOpnd(rhsBaseOffset, k32BitSize);
+      /* generate the load */
+      MemOperand *rhsMemOpnd =
+          &GetOrCreateMemOpnd(addrMode, copySize * k8BitSize, rhsBaseReg, nullptr, &rhsOfstOpnd, sym);
+      /* generate the load */
+      RegOperand &result = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, std::max(4u, copySize)));
+      bool doPair = (!rhsIsLo12 && !lhsIsLo12 && (copySize >= k4BitSize) && ((i + 1) < (lhsSize / copySize)));
+      RegOperand *result1 = nullptr;
+      Insn *newLoadInsn = nullptr;
+      if (doPair) {
+        MOperator mOpLDP = (copySize == k4BitSize) ? MOP_wldp : MOP_xldp;
+        result1 = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, std::max(4u, copySize)));
+        rhsMemOpnd = FixLargeMemOpnd(mOpLDP, *rhsMemOpnd, copySize * k8BitSize, kInsnThirdOpnd);
+        newLoadInsn = &GetInsnBuilder()->BuildInsn(mOpLDP, result, *result1, *rhsMemOpnd);
+      } else {
+        MOperator mOp = PickLdInsn(copySize * k8BitSize, PTY_u32);
+        rhsMemOpnd = FixLargeMemOpnd(mOp, *rhsMemOpnd, copySize * k8BitSize, kInsnSecondOpnd);
+        newLoadInsn = &GetInsnBuilder()->BuildInsn(mOp, result, *rhsMemOpnd);
+      }
+      ASSERT(newLoadInsn != nullptr, "build load instruction failed in SelectAggDassign");
+      lastLdr = AggtStrLdrInsert(bothUnion, lastLdr, *newLoadInsn);
+      /* generate the store */
+      OfstOperand &lhsOfstOpnd = GetOrCreateOfstOpnd(lhsBaseOffset, k32BitSize);
+      addrMode = lhsIsLo12 ? MemOperand::kAddrModeLo12Li : MemOperand::kAddrModeBOi;
+      sym = lhsIsLo12 ? lhsSymbol : nullptr;
+      Insn *newStoreInsn = nullptr;
+      MemOperand *lhsMemOpnd =
+          &GetOrCreateMemOpnd(addrMode, copySize * k8BitSize, lhsBaseReg, nullptr, &lhsOfstOpnd, sym);
+      if (doPair) {
+        MOperator mOpSTP = (copySize == k4BitSize) ? MOP_wstp : MOP_xstp;
+        lhsMemOpnd = FixLargeMemOpnd(mOpSTP, *lhsMemOpnd, copySize * k8BitSize, kInsnThirdOpnd);
+        ASSERT(result1 != nullptr, "result1 should not be nullptr");
+        newStoreInsn = &GetInsnBuilder()->BuildInsn(mOpSTP, result, *result1, *lhsMemOpnd);
+        i++;
+      } else {
+        MOperator mOp = PickStInsn(copySize * k8BitSize, PTY_u32);
+        lhsMemOpnd = FixLargeMemOpnd(mOp, *lhsMemOpnd, copySize * k8BitSize, kInsnSecondOpnd);
+        newStoreInsn = &GetInsnBuilder()->BuildInsn(mOp, result, *lhsMemOpnd);
+      }
+      ASSERT(newStoreInsn != nullptr, "build store instruction failed in SelectAggDassign");
+      lastStr = AggtStrLdrInsert(bothUnion, lastStr, *newStoreInsn);
+    }
+    /* take care of extra content at the end less than the unit */
+    uint64 lhsSizeCovered = (lhsSize / copySize) * copySize;
+    uint32 newAlignUsed = copySize;
+    while (lhsSizeCovered < lhsSize) {
+      newAlignUsed = newAlignUsed >> 1;
+      CHECK_FATAL(newAlignUsed != 0, "expect non-zero");
+      if ((lhsSizeCovered + newAlignUsed) > lhsSize) {
+        continue;
+      }
+      /* generate the load */
+      MemOperand *rhsMemOpnd;
+      MemOperand::AArch64AddressingMode addrMode =
+          rhsIsLo12 ? MemOperand::kAddrModeLo12Li : MemOperand::kAddrModeBOi;
+      MIRSymbol *sym = rhsIsLo12 ? rhsSymbol : nullptr;
+      OfstOperand &rhsOfstOpnd = GetOrCreateOfstOpnd(lhsSizeCovered + static_cast<uint64>(rhsOffsetVal), k32BitSize);
+      rhsMemOpnd = &GetOrCreateMemOpnd(addrMode, newAlignUsed * k8BitSize, rhsBaseReg, nullptr, &rhsOfstOpnd, sym);
+      rhsMemOpnd = FixLargeMemOpnd(*rhsMemOpnd, newAlignUsed);
+      regno_t vRegNO = NewVReg(kRegTyInt, std::max(4u, newAlignUsed));
+      RegOperand &result = CreateVirtualRegisterOperand(vRegNO);
+      MOperator mOp = PickLdInsn(newAlignUsed * k8BitSize, PTY_u32);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, *rhsMemOpnd));
+      /* generate the store */
+      addrMode = lhsIsLo12 ? MemOperand::kAddrModeLo12Li : MemOperand::kAddrModeBOi;
+      sym = lhsIsLo12 ? lhsSymbol : nullptr;
+      OfstOperand &lhsOfstOpnd = GetOrCreateOfstOpnd(lhsSizeCovered + static_cast<uint64>(lhsOffsetVal), k32BitSize);
+      MemOperand *lhsMemOpnd = &GetOrCreateMemOpnd(addrMode, newAlignUsed * k8BitSize,
+                                                   lhsBaseReg, nullptr, &lhsOfstOpnd, sym);
+      lhsMemOpnd = FixLargeMemOpnd(*lhsMemOpnd, newAlignUsed);
+      mOp = PickStInsn(newAlignUsed * k8BitSize, PTY_u32);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, *lhsMemOpnd));
+      lhsSizeCovered += newAlignUsed;
+    }
+  } else if (stmt.GetRHS()->GetOpCode() == OP_iread) {
+    IreadNode *rhsIread = static_cast<IreadNode*>(stmt.GetRHS());
+    RegOperand *addrOpnd = static_cast<RegOperand*>(HandleExpr(*rhsIread, *rhsIread->Opnd(0)));
+    addrOpnd = &LoadIntoRegister(*addrOpnd, rhsIread->Opnd(0)->GetPrimType());
+    MIRPtrType *rhsPointerType = static_cast<MIRPtrType*>(
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(rhsIread->GetTyIdx()));
+    MIRType *rhsType = static_cast<MIRStructType*>(
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(rhsPointerType->GetPointedTyIdx()));
+    bool isRefField = false;
+    if (rhsIread->GetFieldID() != 0) {
+      MIRStructType *rhsStructType = static_cast<MIRStructType*>(rhsType);
+      ASSERT(rhsStructType != nullptr, "SelectAggDassign: non-zero fieldID for non-structure");
+      rhsType = rhsStructType->GetFieldType(rhsIread->GetFieldID());
+      rhsOffset = static_cast<uint32>(GetBecommon().GetFieldOffset(*rhsStructType, rhsIread->GetFieldID()).first);
+      isRefField = GetBecommon().IsRefField(*rhsStructType, rhsIread->GetFieldID());
+    }
+    rhsAlign = GetBecommon().GetTypeAlign(rhsType->GetTypeIndex());
+    alignUsed = std::min(lhsAlign, rhsAlign);
+    ASSERT(alignUsed != 0, "expect non-zero");
+    uint32 copySize = GetAggCopySize(rhsOffset, lhsOffset, alignUsed);
+    MemOperand *lhsBaseMemOpnd = GenLargeAggFormalMemOpnd(*lhsSymbol, copySize, lhsOffset, true);
+    RegOperand *lhsBaseReg = lhsBaseMemOpnd->GetBaseRegister();
+    int64 lhsOffsetVal = lhsBaseMemOpnd->GetOffsetOperand()->GetValue();
+    bool lhsIsLo12 = (lhsBaseMemOpnd->GetAddrMode() == MemOperand::kAddrModeLo12Li);
+    if (lhsSize > kParmMemcpySize) {
+      std::vector<Operand*> opndVec;
+      RegOperand *regResult = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      opndVec.push_back(regResult);  /* result */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(lhsIsLo12, *lhsSymbol, lhsOffsetVal, *lhsBaseReg));  /* param 0 */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(rhsOffset, *addrOpnd));  /* param 1 */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(lhsSize));  /* param 2 */
+
+      SelectLibCall("memcpy", opndVec, PTY_a64, PTY_a64);
+
+      return;
+    }
+    for (uint32 i = 0; i < (lhsSize / copySize); i++) {
+      uint64 rhsBaseOffset = rhsOffset + i * copySize;
+      uint64 lhsBaseOffset = static_cast<uint64>(lhsOffsetVal) + i * copySize;
+      /* generate the load */
+      OfstOperand &ofstOpnd = GetOrCreateOfstOpnd(rhsBaseOffset, k32BitSize);
+      MemOperand *rhsMemOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, copySize * k8BitSize,
+                                                   addrOpnd, nullptr, &ofstOpnd, nullptr);
+      regno_t vRegNO = NewVReg(kRegTyInt, std::max(4u, copySize));
+      RegOperand &result = CreateVirtualRegisterOperand(vRegNO);
+      bool doPair = (!lhsIsLo12 && copySize >= k4BitSize) && ((i + 1) < (lhsSize / copySize));
+      Insn *insn = nullptr;
+      RegOperand *result1 = nullptr;
+      if (doPair) {
+        MOperator mOpLDP = (copySize == k4BitSize) ? MOP_wldp : MOP_xldp;
+        regno_t vRegNO1 = NewVReg(kRegTyInt, std::max(4u, copySize));
+        result1 = &CreateVirtualRegisterOperand(vRegNO1);
+        rhsMemOpnd = FixLargeMemOpnd(mOpLDP, *rhsMemOpnd, copySize * k8BitSize, kInsnThirdOpnd);
+        insn = &GetInsnBuilder()->BuildInsn(mOpLDP, result, *result1, *rhsMemOpnd);
+      } else {
+        MOperator mOp = PickLdInsn(copySize * k8BitSize, PTY_u32);
+        rhsMemOpnd = FixLargeMemOpnd(mOp, *rhsMemOpnd, copySize * k8BitSize, kInsnSecondOpnd);
+        insn = &GetInsnBuilder()->BuildInsn(mOp, result, *rhsMemOpnd);
+      }
+      insn->MarkAsAccessRefField(isRefField);
+      GetCurBB()->AppendInsn(*insn);
+      /* generate the store */
+      MemOperand::AArch64AddressingMode addrMode =
+          lhsIsLo12 ? MemOperand::kAddrModeLo12Li : MemOperand::kAddrModeBOi;
+      MIRSymbol *sym = lhsIsLo12 ? lhsSymbol : nullptr;
+      OfstOperand &lhsOfstOpnd = GetOrCreateOfstOpnd(lhsBaseOffset, k32BitSize);
+      MemOperand *lhsMemOpnd =
+          &GetOrCreateMemOpnd(addrMode, copySize * k8BitSize, lhsBaseReg, nullptr, &lhsOfstOpnd, sym);
+      if (doPair) {
+        MOperator mOpSTP = (copySize == k4BitSize) ? MOP_wstp : MOP_xstp;
+        lhsMemOpnd = FixLargeMemOpnd(mOpSTP, *lhsMemOpnd, copySize * k8BitSize, kInsnThirdOpnd);
+        ASSERT(result1 != nullptr, "result1 should not be nullptr");
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpSTP, result, *result1, *lhsMemOpnd));
+        i++;
+      } else {
+        MOperator mOp = PickStInsn(copySize * k8BitSize, PTY_u32);
+        lhsMemOpnd = FixLargeMemOpnd(mOp, *lhsMemOpnd, copySize * k8BitSize, kInsnSecondOpnd);
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, *lhsMemOpnd));
+      }
+    }
+    /* take care of extra content at the end less than the unit of alignUsed */
+    uint64 lhsSizeCovered = (lhsSize / copySize) * copySize;
+    uint32 newAlignUsed = copySize;
+    while (lhsSizeCovered < lhsSize) {
+      newAlignUsed = newAlignUsed >> 1;
+      CHECK_FATAL(newAlignUsed != 0, "expect non-zero");
+      if ((lhsSizeCovered + newAlignUsed) > lhsSize) {
+        continue;
+      }
+      /* generate the load */
+      OfstOperand &ofstOpnd = GetOrCreateOfstOpnd(rhsOffset + lhsSizeCovered, k32BitSize);
+      MemOperand *rhsMemOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, newAlignUsed * k8BitSize,
+                                                   addrOpnd, nullptr, &ofstOpnd, nullptr);
+      rhsMemOpnd = FixLargeMemOpnd(*rhsMemOpnd, newAlignUsed);
+      RegOperand &result = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, std::max(4u, newAlignUsed)));
+      MOperator mOp = PickLdInsn(newAlignUsed * k8BitSize, PTY_u32);
+      Insn &insn = GetInsnBuilder()->BuildInsn(mOp, result, *rhsMemOpnd);
+      insn.MarkAsAccessRefField(isRefField);
+      GetCurBB()->AppendInsn(insn);
+      /* generate the store */
+      MemOperand::AArch64AddressingMode addrMode =
+          lhsIsLo12 ? MemOperand::kAddrModeLo12Li : MemOperand::kAddrModeBOi;
+      MIRSymbol *sym = lhsIsLo12 ? lhsSymbol : nullptr;
+      OfstOperand &lhsOfstOpnd = GetOrCreateOfstOpnd(lhsSizeCovered + static_cast<uint64>(lhsOffsetVal), k32BitSize);
+      MemOperand *lhsMemOpnd =
+          &GetOrCreateMemOpnd(addrMode, newAlignUsed * k8BitSize, lhsBaseReg, nullptr, &lhsOfstOpnd, sym);
+      lhsMemOpnd = FixLargeMemOpnd(*lhsMemOpnd, newAlignUsed);
+      mOp = PickStInsn(newAlignUsed * k8BitSize, PTY_u32);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, *lhsMemOpnd));
+      lhsSizeCovered += newAlignUsed;
+    }
+  } else {
+    ASSERT(stmt.GetRHS()->op == OP_regread, "SelectAggDassign: NYI");
+    bool isRet = false;
+    if (lhsType->GetKind() == kTypeStruct || lhsType->GetKind() == kTypeUnion) {
+      RegreadNode *rhsregread = static_cast<RegreadNode*>(stmt.GetRHS());
+      PregIdx pregIdx = rhsregread->GetRegIdx();
+      if (IsSpecialPseudoRegister(pregIdx)) {
+        if ((-pregIdx) == kSregRetval0) {
+          AArch64CallConvImpl parmlocator(GetBecommon());
+          CCLocInfo pLoc;
+          PrimType retPtype;
+          RegType regType;
+          uint32 memSize;
+          uint32 regSize;
+          parmlocator.LocateRetVal(*lhsType, pLoc);
+          AArch64reg r[kFourRegister];
+          r[0] = static_cast<AArch64reg>(pLoc.reg0);
+          r[1] = static_cast<AArch64reg>(pLoc.reg1);
+          r[2] = static_cast<AArch64reg>(pLoc.reg2);
+          r[3] = static_cast<AArch64reg>(pLoc.reg3);
+          if (pLoc.numFpPureRegs > 0) {
+            regSize = (pLoc.fpSize == k4ByteSize) ? k32BitSize : k64BitSize;
+            memSize = pLoc.fpSize;
+            retPtype = (pLoc.fpSize == k4ByteSize) ? PTY_f32 : PTY_f64;
+            regType = kRegTyFloat;
+          } else {
+            regSize = k64BitSize;
+            memSize = k8BitSize;
+            retPtype = PTY_u64;
+            regType = kRegTyInt;
+          }
+          for (uint32 i = 0; i < kFourRegister; ++i) {
+            if (r[i] == kRinvalid) {
+              break;
+            }
+            RegOperand &parm = GetOrCreatePhysicalRegisterOperand(r[i], regSize, regType);
+            Operand &mOpnd = GetOrCreateMemOpnd(*lhsSymbol, memSize * i, regSize);
+            GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickStInsn(regSize, retPtype), parm, mOpnd));
+          }
+          isRet = true;
+        }
+      }
+    }
+    CHECK_FATAL(isRet, "SelectAggDassign: NYI");
+  }
+}
+
+static MIRType *GetPointedToType(const MIRPtrType &pointerType) {
+  MIRType *aType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerType.GetPointedTyIdx());
+  if (aType->GetKind() == kTypeArray) {
+    MIRArrayType *arrayType = static_cast<MIRArrayType*>(aType);
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrayType->GetElemTyIdx());
+  }
+  if (aType->GetKind() == kTypeFArray || aType->GetKind() == kTypeJArray) {
+    MIRFarrayType *farrayType = static_cast<MIRFarrayType*>(aType);
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(farrayType->GetElemTyIdx());
+  }
+  return aType;
+}
+
+void AArch64CGFunc::SelectIassign(IassignNode &stmt) {
+  int32 offset = 0;
+  MIRPtrType *pointerType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(stmt.GetTyIdx()));
+  ASSERT(pointerType != nullptr, "expect a pointer type at iassign node");
+  MIRType *pointedType = nullptr;
+  bool isRefField = false;
+  AArch64isa::MemoryOrdering memOrd = AArch64isa::kMoNone;
+
+  if (stmt.GetFieldID() != 0) {
+    MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerType->GetPointedTyIdx());
+    MIRStructType *structType = nullptr;
+    if (pointedTy->GetKind() != kTypeJArray) {
+      structType = static_cast<MIRStructType*>(pointedTy);
+    } else {
+      /* it's a Jarray type. using it's parent's field info: java.lang.Object */
+      structType = static_cast<MIRJarrayType*>(pointedTy)->GetParentType();
+    }
+    ASSERT(structType != nullptr, "SelectIassign: non-zero fieldID for non-structure");
+    pointedType = structType->GetFieldType(stmt.GetFieldID());
+    offset = GetBecommon().GetFieldOffset(*structType, stmt.GetFieldID()).first;
+    isRefField = GetBecommon().IsRefField(*structType, stmt.GetFieldID());
+  } else {
+    pointedType = GetPointedToType(*pointerType);
+    if (GetFunction().IsJava() && (pointedType->GetKind() == kTypePointer)) {
+      MIRType *nextPointedType =
+          GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<MIRPtrType*>(pointedType)->GetPointedTyIdx());
+      if (nextPointedType->GetKind() != kTypeScalar) {
+        isRefField = true;  /* write into an object array or a high-dimensional array */
+      }
+    }
+  }
+
+  PrimType styp = stmt.GetRHS()->GetPrimType();
+  Operand *valOpnd = HandleExpr(stmt, *stmt.GetRHS());
+  Operand &srcOpnd =
+      LoadIntoRegister(*valOpnd,
+                       (IsPrimitiveInteger(styp) || IsPrimitiveVectorInteger(styp)), GetPrimTypeBitSize(styp));
+
+  PrimType destType = pointedType->GetPrimType();
+  if (destType == PTY_agg) {
+    destType = PTY_a64;
+  }
+  if (IsPrimitiveVector(styp)) {  /* a vector type */
+    destType = styp;
+  }
+  ASSERT(stmt.Opnd(0) != nullptr, "null ptr check");
+  MemOperand &memOpnd = CreateMemOpnd(destType, stmt, *stmt.Opnd(0), offset);
+  auto dataSize = GetPrimTypeBitSize(destType);
+  memOpnd = memOpnd.IsOffsetMisaligned(dataSize) ?
+            ConstraintOffsetToSafeRegion(dataSize, memOpnd, nullptr) : memOpnd;
+  if (isVolStore && memOpnd.GetAddrMode() == MemOperand::kAddrModeBOi) {
+    memOrd = AArch64isa::kMoRelease;
+    isVolStore = false;
+  }
+
+  if (memOrd == AArch64isa::kMoNone) {
+    SelectCopy(memOpnd, destType, srcOpnd, destType);
+  } else {
+    AArch64CGFunc::SelectStoreRelease(memOpnd, destType, srcOpnd, destType, memOrd, false);
+  }
+  GetCurBB()->GetLastInsn()->MarkAsAccessRefField(isRefField);
+}
+
+void AArch64CGFunc::SelectIassignoff(IassignoffNode &stmt) {
+  int32 offset = stmt.GetOffset();
+  PrimType destType = stmt.GetPrimType();
+
+  MemOperand &memOpnd = CreateMemOpnd(destType, stmt, *stmt.GetBOpnd(0), offset);
+  auto dataSize = GetPrimTypeBitSize(destType);
+  memOpnd = memOpnd.IsOffsetMisaligned(dataSize) ?
+            ConstraintOffsetToSafeRegion(dataSize, memOpnd, nullptr) : memOpnd;
+  Operand *valOpnd = HandleExpr(stmt, *stmt.GetBOpnd(1));
+  Operand &srcOpnd = LoadIntoRegister(*valOpnd, true, GetPrimTypeBitSize(destType));
+  SelectCopy(memOpnd, destType, srcOpnd, destType);
+}
+
+MemOperand *AArch64CGFunc::GenLmbcFpMemOperand(int32 offset, uint32 byteSize, AArch64reg baseRegno) {
+  MemOperand *memOpnd;
+  RegOperand *rfp = &GetOrCreatePhysicalRegisterOperand(baseRegno, k64BitSize, kRegTyInt);
+  uint32 bitlen = byteSize * kBitsPerByte;
+  if (offset < kMinSimm32) {
+    RegOperand *baseOpnd = &CreateRegisterOperandOfType(PTY_a64);
+    ImmOperand &immOpnd = CreateImmOperand(offset, k32BitSize, true);
+    if (immOpnd.IsSingleInstructionMovable()) {
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, *baseOpnd, *rfp, immOpnd));
+    } else {
+      SelectCopyImm(*baseOpnd, immOpnd, PTY_i64);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrrr, *baseOpnd, *rfp, *baseOpnd));
+    }
+    OfstOperand *offsetOpnd = &CreateOfstOpnd(0, k32BitSize);
+    memOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, bitlen, baseOpnd, nullptr, offsetOpnd, nullptr);
+  } else {
+    OfstOperand *offsetOpnd = &CreateOfstOpnd(static_cast<uint64>(static_cast<int64>(offset)), k32BitSize);
+    memOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, bitlen, rfp, nullptr, offsetOpnd, nullptr);
+  }
+  memOpnd->SetStackMem(true);
+  return memOpnd;
+}
+
+bool AArch64CGFunc::GetNumReturnRegsForIassignfpoff(MIRType *rType, PrimType &primType, uint32 &numRegs) {
+  bool isPureFp = false;
+  uint32 rSize = static_cast<uint32>(rType->GetSize());
+  CHECK_FATAL(rSize <= k16ByteSize, "SelectIassignfpoff invalid agg size");
+  uint32 fpSize;
+  numRegs = FloatParamRegRequired(static_cast<MIRStructType*>(rType), fpSize);
+  if (numRegs > 0) {
+    primType = (fpSize == k4ByteSize) ? PTY_f32 : PTY_f64;
+    isPureFp = true;
+  } else if (rSize > k8ByteSize) {
+    primType = PTY_u64;
+    numRegs = kTwoRegister;
+  } else {
+    primType = PTY_u64;
+    numRegs = kOneRegister;
+  }
+  return isPureFp;
+}
+
+void AArch64CGFunc::GenIassignfpoffStore(Operand &srcOpnd, int32 offset, uint32 byteSize, PrimType primType) {
+  MemOperand *memOpnd = GenLmbcFpMemOperand(offset, byteSize);
+  MOperator mOp = PickStInsn(byteSize * kBitsPerByte, primType);
+  Insn &store = GetInsnBuilder()->BuildInsn(mOp, srcOpnd, *memOpnd);
+  GetCurBB()->AppendInsn(store);
+}
+
+void AArch64CGFunc::SelectIassignfpoff(IassignFPoffNode &stmt, Operand &opnd) {
+  int32 offset = stmt.GetOffset();
+  PrimType primType = stmt.GetPrimType();
+  MIRType *rType = GetLmbcCallReturnType();
+  bool isPureFpStruct = false;
+  uint32 numRegs = 0;
+  if (rType && rType->GetPrimType() == PTY_agg && opnd.IsRegister() &&
+      static_cast<RegOperand&>(opnd).IsPhysicalRegister()) {
+    isPureFpStruct = GetNumReturnRegsForIassignfpoff(rType, primType, numRegs);
+  }
+  uint32 byteSize = GetPrimTypeSize(primType);
+  if (isPureFpStruct) {
+    for (uint32 i = 0 ; i < numRegs; ++i) {
+      RegOperand &srcOpnd = GetOrCreatePhysicalRegisterOperand(AArch64reg(V0 + i),
+          byteSize * kBitsPerByte, kRegTyFloat);
+      GenIassignfpoffStore(srcOpnd, offset + static_cast<int32>(i * byteSize), byteSize, primType);
+    }
+  } else if (numRegs) {
+    for (uint32 i = 0 ; i < numRegs; ++i) {
+      RegOperand &srcOpnd = GetOrCreatePhysicalRegisterOperand(AArch64reg(R0 + i), byteSize * kBitsPerByte, kRegTyInt);
+      GenIassignfpoffStore(srcOpnd, offset + static_cast<int32>(i * byteSize), byteSize, primType);
+    }
+  } else {
+    Operand &srcOpnd = LoadIntoRegister(opnd, primType);
+    GenIassignfpoffStore(srcOpnd, offset, byteSize, primType);
+  }
+}
+
+/* Load and assign to a new register. To be moved to the correct call register OR stack
+   location in LmbcSelectParmList */
+void AArch64CGFunc::SelectIassignspoff(PrimType pTy, int32 offset, Operand &opnd) {
+  if (GetLmbcArgInfo() == nullptr) {
+    LmbcArgInfo *p = memPool->New<LmbcArgInfo>(*GetFuncScopeAllocator());
+    SetLmbcArgInfo(p);
+  }
+  uint32 byteLen = GetPrimTypeSize(pTy);
+  uint32 bitLen = byteLen * kBitsPerByte;
+  RegType regTy = GetRegTyFromPrimTy(pTy);
+  int32 curRegArgs = GetLmbcArgsInRegs(regTy);
+  if (curRegArgs < static_cast<int32>(k8ByteSize)) {
+    RegOperand *res = &CreateVirtualRegisterOperand(NewVReg(regTy, byteLen));
+    SelectCopy(*res, pTy, opnd, pTy);
+    SetLmbcArgInfo(res, pTy, offset, 1);
+  }
+  else {
+    /* Move into allocated space */
+    Operand &memOpd = CreateMemOpnd(RSP, offset, byteLen);
+    Operand &reg = LoadIntoRegister(opnd, pTy);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickStInsn(bitLen, pTy), reg, memOpd));
+  }
+  IncLmbcArgsInRegs(regTy);  /* num of args in registers */
+  IncLmbcTotalArgs();        /* num of args */
+}
+
+/* Search for CALL/ICALL/ICALLPROTO node, must be called from a blkassignoff node */
+MIRType *AArch64CGFunc::LmbcGetAggTyFromCallSite(StmtNode *stmt, std::vector<TyIdx> **parmList) const {
+  for (; stmt != nullptr; stmt = stmt->GetNext()) {
+    if (stmt->GetOpCode() == OP_call || stmt->GetOpCode() == OP_icallproto) {
+      break;
+    }
+  }
+  CHECK_FATAL(stmt && (stmt->GetOpCode() == OP_call || stmt->GetOpCode() == OP_icallproto),
+              "blkassign sp not followed by call");
+  uint32 nargs = GetLmbcTotalArgs();
+  MIRType *ty = nullptr;
+  if (stmt->GetOpCode() == OP_call) {
+    CallNode *callNode = static_cast<CallNode*>(stmt);
+    MIRFunction *fn = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+    if (fn->GetFormalCount() > 0) {
+      ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fn->GetFormalDefVec()[nargs].formalTyIdx);
+    }
+    *parmList = &fn->GetParamTypes();
+    // would return null if the actual parameter is bogus
+  } else if (stmt->GetOpCode() == OP_icallproto) {
+    IcallNode *icallproto = static_cast<IcallNode*>(stmt);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(icallproto->GetRetTyIdx());
+    MIRFuncType *fType = static_cast<MIRFuncType*>(type);
+    ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fType->GetNthParamType(nargs));
+    *parmList = &fType->GetParamTypeList();
+  } else {
+    CHECK_FATAL(stmt->GetOpCode() == OP_icallproto,
+                "LmbcGetAggTyFromCallSite:: unexpected call operator");
+  }
+  return ty;
+}
+
+/* return true if blkassignoff for return, false otherwise */
+bool AArch64CGFunc::LmbcSmallAggForRet(const BaseNode &bNode, Operand *src, int32 offset, bool skip1) {
+  PrimType pTy;
+  uint32 size = 0;
+  AArch64reg regno = static_cast<AArch64reg>(static_cast<const RegOperand*>(src)->GetRegisterNumber());
+  MIRFunction *func = &GetFunction();
+
+  if (!func->IsReturnStruct()) {
+    return false;
+  }
+  /* This blkassignoff is for struct return? */
+  uint32 loadSize;
+  uint32 numRegs = 0;
+  if (static_cast<const StmtNode&>(bNode).GetNext()->GetOpCode() == OP_return) {
+    MIRStructType *ty = static_cast<MIRStructType*>(func->GetReturnType());
+    uint32 tySize = GetBecommon().GetTypeSize(ty->GetTypeIndex());
+    uint32 fpregs = FloatParamRegRequired(ty, size);
+    if (fpregs > 0) {
+      /* pure floating point in agg */
+      numRegs = fpregs;
+      pTy = (size == k4ByteSize) ? PTY_f32 : PTY_f64;
+      loadSize = GetPrimTypeSize(pTy) * kBitsPerByte;
+      for (uint32 i = 0; i < fpregs; i++) {
+        int32 s = (i == 0) ? 0 : static_cast<int32>(i * size);
+        int64 newOffset = static_cast<int64>(s) + static_cast<int64>(offset);
+        MemOperand &mem = CreateMemOpnd(regno, newOffset, size * kBitsPerByte);
+        AArch64reg reg = static_cast<AArch64reg>(V0 + i);
+        RegOperand *res = &GetOrCreatePhysicalRegisterOperand(reg, loadSize, kRegTyFloat);
+        SelectCopy(*res, pTy, mem, pTy);
+      }
+    } else {
+      /* int/float mixed */
+      numRegs = 2;
+      pTy = PTY_i64;
+      size = k4ByteSize;
+      switch (tySize) {
+        case 1:
+          pTy = PTY_i8;
+          break;
+        case 2:
+          pTy = PTY_i16;
+          break;
+        case 4:
+          pTy = PTY_i32;
+          break;
+        default:
+          size = k8ByteSize; /* pTy remains i64 */
+          break;
+      }
+      loadSize = GetPrimTypeSize(pTy) * kBitsPerByte;
+      if (!skip1) {
+        MemOperand &mem = CreateMemOpnd(regno, offset, size * kBitsPerByte);
+        RegOperand &res1 = GetOrCreatePhysicalRegisterOperand(R0, loadSize, kRegTyInt);
+        SelectCopy(res1, pTy, mem, pTy);
+      }
+      if (tySize > static_cast<int32>(k8ByteSize)) {
+        int32 newOffset = offset + static_cast<int32>(k8ByteSize);
+        MemOperand &newMem = CreateMemOpnd(regno, newOffset, size * kBitsPerByte);
+        RegOperand &res2 = GetOrCreatePhysicalRegisterOperand(R1, loadSize, kRegTyInt);
+        SelectCopy(res2, pTy, newMem, pTy);
+      }
+    }
+    bool intReg = fpregs == 0;
+    for (uint32 i = 0; i < numRegs; i++) {
+      AArch64reg preg = static_cast<AArch64reg>((intReg ? R0 : V0) + i);
+      MOperator mop = intReg ? MOP_pseudo_ret_int : MOP_pseudo_ret_float;
+      RegOperand &dest = GetOrCreatePhysicalRegisterOperand(preg, loadSize, intReg ? kRegTyInt : kRegTyFloat);
+      Insn &pseudo = GetInsnBuilder()->BuildInsn(mop, dest);
+      GetCurBB()->AppendInsn(pseudo);
+    }
+    return true;
+  }
+  return false;
+}
+
+/* return true if blkassignoff for return, false otherwise */
+bool AArch64CGFunc::LmbcSmallAggForCall(BlkassignoffNode &bNode, const Operand *src, std::vector<TyIdx> **parmList) {
+  AArch64reg regno = static_cast<AArch64reg>(static_cast<const RegOperand*>(src)->GetRegisterNumber());
+  if (IsBlkassignForPush(bNode)) {
+    PrimType pTy = PTY_i64;
+    MIRStructType *ty = static_cast<MIRStructType*>(LmbcGetAggTyFromCallSite(&bNode, parmList));
+    uint32 size = 0;
+    uint32 fpregs = ty ? FloatParamRegRequired(ty, size) : 0;  /* fp size determined */
+    if (fpregs > 0) {
+      /* pure floating point in agg */
+      pTy = (size == k4ByteSize) ? PTY_f32 : PTY_f64;
+      for (uint32 i = 0; i < fpregs; i++) {
+        int32 s = (i == 0) ? 0 : static_cast<int32>(i * size);
+        MemOperand &mem = CreateMemOpnd(regno, s, size * kBitsPerByte);
+        RegOperand *res = &CreateVirtualRegisterOperand(NewVReg(kRegTyFloat, size));
+        SelectCopy(*res, pTy, mem, pTy);
+        SetLmbcArgInfo(res, pTy, 0, static_cast<int32>(fpregs));
+        IncLmbcArgsInRegs(kRegTyFloat);
+      }
+      IncLmbcTotalArgs();
+      return true;
+    } else if (bNode.blockSize <= static_cast<int32>(k16ByteSize)) {
+      /* integer/mixed types in register/s */
+      size = k4ByteSize;
+      switch (bNode.blockSize) {
+        case 1:
+          pTy = PTY_i8;
+          break;
+        case 2:
+          pTy = PTY_i16;
+          break;
+        case 4:
+          pTy = PTY_i32;
+          break;
+        default:
+          size = k8ByteSize; /* pTy remains i64 */
+          break;
+      }
+      MemOperand &mem = CreateMemOpnd(regno, 0, size * kBitsPerByte);
+      RegOperand *res = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, size));
+      SelectCopy(*res, pTy, mem, pTy);
+      SetLmbcArgInfo(res, pTy, bNode.offset, bNode.blockSize > static_cast<int32>(k8ByteSize) ? 2 : 1);
+      IncLmbcArgsInRegs(kRegTyInt);
+      if (bNode.blockSize > static_cast<int32>(k8ByteSize)) {
+        MemOperand &newMem = CreateMemOpnd(regno, k8ByteSize, size * kBitsPerByte);
+        RegOperand *newRes = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, size));
+        SelectCopy(*newRes, pTy, newMem, pTy);
+        SetLmbcArgInfo(newRes, pTy, bNode.offset + k8ByteSizeInt, 2);
+        IncLmbcArgsInRegs(kRegTyInt);
+      }
+      IncLmbcTotalArgs();
+      return true;
+    }
+  }
+  return false;
+}
+
+/* This function is incomplete and may be removed when Lmbc IR is changed
+   to have the lowerer figures out the address of the large agg to reside */
+uint32 AArch64CGFunc::LmbcFindTotalStkUsed(std::vector<TyIdx> *paramList) {
+  AArch64CallConvImpl parmlocator(GetBecommon());
+  CCLocInfo pLoc;
+  for (TyIdx tyIdx : *paramList) {
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    (void)parmlocator.LocateNextParm(*ty, pLoc);
+  }
+  return 0;
+}
+
+/* All arguments passed as registers */
+uint32 AArch64CGFunc::LmbcTotalRegsUsed() {
+  if (GetLmbcArgInfo() == nullptr) {
+    return 0;   /* no arg */
+  }
+  MapleVector<int32> &regs = GetLmbcCallArgNumOfRegs();
+  MapleVector<PrimType> &types = GetLmbcCallArgTypes();
+  uint32 iCnt = 0;
+  uint32 fCnt = 0;
+  for (uint32 i = 0; i < regs.size(); i++) {
+    if (IsPrimitiveInteger(types[i])) {
+      if ((iCnt + static_cast<uint32>(regs[i])) <= k8ByteSize) {
+        iCnt += static_cast<uint32>(regs[i]);
+      };
+    } else {
+      if ((fCnt + static_cast<uint32>(regs[i])) <= k8ByteSize) {
+        fCnt += static_cast<uint32>(regs[i]);
+      };
+    }
+  }
+  return iCnt + fCnt;
+}
+
+/* If blkassignoff for argument, this function loads the agg arguments into
+   virtual registers, disregard if there is sufficient physicall call
+   registers. Argument > 16-bytes are copied to preset space and ptr
+   result is loaded into virtual register.
+   If blassign is not for argument, this function simply memcpy */
+void AArch64CGFunc::SelectBlkassignoff(BlkassignoffNode &bNode, Operand *src) {
+  CHECK_FATAL(src->GetKind() == Operand::kOpdRegister, "blkassign src type not in register");
+  std::vector<TyIdx> *parmList;
+  if (GetLmbcArgInfo() == nullptr) {
+    LmbcArgInfo *p = memPool->New<LmbcArgInfo>(*GetFuncScopeAllocator());
+    SetLmbcArgInfo(p);
+  }
+  if (LmbcSmallAggForRet(bNode, src)) {
+    return;
+  } else if (LmbcSmallAggForCall(bNode, src, &parmList)) {
+    return;
+  }
+  Operand *dest = HandleExpr(bNode, *bNode.Opnd(0));
+  RegOperand *regResult = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+  /* memcpy for agg assign OR large agg for arg/ret */
+  int32 offset = bNode.offset;
+  if (IsBlkassignForPush(bNode)) {
+    /* large agg for call, addr to be pushed in SelectCall */
+    offset = GetLmbcTotalStkUsed();
+    if (offset < 0) {
+      /* length of ALL stack based args for this call, this location is where the
+         next large agg resides, its addr will then be passed */
+      offset = static_cast<int32>(LmbcFindTotalStkUsed(parmList) + LmbcTotalRegsUsed());
+    }
+    SetLmbcTotalStkUsed(offset + bNode.blockSize);  /* next use */
+    SetLmbcArgInfo(regResult, PTY_i64, 0, 1); /* 1 reg for ptr */
+    IncLmbcArgsInRegs(kRegTyInt);
+    IncLmbcTotalArgs();
+    /* copy large agg arg to offset below */
+  }
+  RegOperand *param0 = PrepareMemcpyParamOpnd(offset, *dest);
+  RegOperand *param1 = static_cast<RegOperand *>(src);
+  RegOperand *param2 = PrepareMemcpyParamOpnd(static_cast<uint64>(static_cast<int64>(bNode.blockSize)));
+  if (bNode.blockSize > static_cast<int32>(kParmMemcpySize)) {
+    std::vector<Operand*> opndVec;
+    opndVec.push_back(regResult); /* result */
+    opndVec.push_back(param0);    /* param 0 */
+    opndVec.push_back(src);       /* param 1 */
+    opndVec.push_back(param2);    /* param 2 */
+    SelectLibCall("memcpy", opndVec, PTY_a64, PTY_a64);
+  } else {
+    int32 copyOffset = 0;
+    uint32 inc = 0;
+    bool isPair;
+    for (uint32 sz = static_cast<uint32>(bNode.blockSize); sz > 0;) {
+      isPair = false;
+      MOperator ldOp, stOp;
+      if (sz >= k16ByteSize) {
+        sz -= k16ByteSize;
+        inc = k16ByteSize;
+        ldOp = MOP_xldp;
+        stOp = MOP_xstp;
+        isPair = true;
+      } else if (sz >= k8ByteSize) {
+        sz -= k8ByteSize;
+        inc = k8ByteSize;
+        ldOp = MOP_xldr;
+        stOp = MOP_xstr;
+      } else if (sz >= k4ByteSize) {
+        sz -= k4ByteSize;
+        inc = k4ByteSize;
+        ldOp = MOP_wldr;
+        stOp = MOP_wstr;
+      } else if (sz >= k2ByteSize) {
+        sz -= k2ByteSize;
+        inc = k2ByteSize;
+        ldOp = MOP_wldrh;
+        stOp = MOP_wstrh;
+      } else {
+        sz -= k1ByteSize;
+        inc = k1ByteSize;
+        ldOp = MOP_wldrb;
+        stOp = MOP_wstrb;
+      }
+      AArch64reg ldBaseReg = static_cast<AArch64reg>(param1->GetRegisterNumber());
+      MemOperand &ldMem = CreateMemOpnd(ldBaseReg, copyOffset, k8ByteSize);
+
+      AArch64reg stBaseReg = static_cast<AArch64reg>(param0->GetRegisterNumber());
+      MemOperand &stMem = CreateMemOpnd(stBaseReg, copyOffset, k8ByteSize);
+      if (isPair) {
+        RegOperand &ldResult = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+        RegOperand &ldResult2 = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(ldOp, ldResult, ldResult2, ldMem));
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(stOp, ldResult, ldResult2, stMem));
+      } else {
+        RegOperand &ldResult = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(ldOp, ldResult, ldMem));
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(stOp, ldResult, stMem));
+      }
+      copyOffset += static_cast<int32>(inc);
+    }
+  }
+}
+
+void AArch64CGFunc::SelectAggIassign(IassignNode &stmt, Operand &addrOpnd) {
+  ASSERT(stmt.Opnd(0) != nullptr, "null ptr check");
+  Operand &lhsAddrOpnd = LoadIntoRegister(addrOpnd, stmt.Opnd(0)->GetPrimType());
+  uint32 lhsOffset = 0;
+  MIRType *stmtType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(stmt.GetTyIdx());
+  MIRPtrType *lhsPointerType = static_cast<MIRPtrType*>(stmtType);
+  MIRType *lhsType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsPointerType->GetPointedTyIdx());
+  if (stmt.GetFieldID() != 0) {
+    MIRStructType *structType = static_cast<MIRStructType*>(lhsType);
+    ASSERT(structType != nullptr, "SelectAggIassign: non-zero fieldID for non-structure");
+    lhsType = structType->GetFieldType(stmt.GetFieldID());
+    lhsOffset = static_cast<uint32>(GetBecommon().GetFieldOffset(*structType, stmt.GetFieldID()).first);
+  } else if (lhsType->GetKind() == kTypeArray) {
+#if DEBUG
+    MIRArrayType *arrayLhsType = static_cast<MIRArrayType*>(lhsType);
+    /* access an array element */
+    MIRType *lhsType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrayLhsType->GetElemTyIdx());
+    MIRTypeKind typeKind = lhsType->GetKind();
+    ASSERT(((typeKind == kTypeScalar) || (typeKind == kTypeStruct) || (typeKind == kTypeClass) ||
+            (typeKind == kTypePointer)),
+           "unexpected array element type in iassign");
+#endif
+  } else if (lhsType->GetKind() == kTypeFArray) {
+#if DEBUG
+    MIRFarrayType *farrayLhsType = static_cast<MIRFarrayType*>(lhsType);
+    /* access an array element */
+    MIRType *lhsElemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(farrayLhsType->GetElemTyIdx());
+    MIRTypeKind typeKind = lhsElemType->GetKind();
+    ASSERT(((typeKind == kTypeScalar) || (typeKind == kTypeStruct) || (typeKind == kTypeClass) ||
+            (typeKind == kTypePointer)),
+           "unexpected array element type in iassign");
+#endif
+  }
+  uint32 lhsAlign = GetBecommon().GetTypeAlign(lhsType->GetTypeIndex());
+  uint64 lhsSize = GetBecommon().GetTypeSize(lhsType->GetTypeIndex());
+
+  uint32 rhsAlign;
+  uint32 alignUsed;
+  uint32 rhsOffset = 0;
+  if (stmt.GetRHS()->GetOpCode() == OP_dread) {
+    AddrofNode *rhsDread = static_cast<AddrofNode*>(stmt.GetRHS());
+    MIRSymbol *rhsSymbol = GetFunction().GetLocalOrGlobalSymbol(rhsDread->GetStIdx());
+    MIRType *rhsType = rhsSymbol->GetType();
+    if (rhsDread->GetFieldID() != 0) {
+      MIRStructType *structType = static_cast<MIRStructType *>(rhsSymbol->GetType());
+      ASSERT(structType != nullptr, "SelectAggIassign: non-zero fieldID for non-structure");
+      rhsType = structType->GetFieldType(rhsDread->GetFieldID());
+      rhsOffset = static_cast<uint32>(GetBecommon().GetFieldOffset(*structType, rhsDread->GetFieldID()).first);
+    }
+    rhsAlign = GetBecommon().GetTypeAlign(rhsType->GetTypeIndex());
+    alignUsed = std::min(lhsAlign, rhsAlign);
+    ASSERT(alignUsed != 0, "expect non-zero");
+    uint32 copySize = GetAggCopySize(rhsOffset, lhsOffset, alignUsed);
+    MemOperand *rhsBaseMemOpnd;
+    if (IsParamStructCopy(*rhsSymbol)) {
+      rhsBaseMemOpnd = &LoadStructCopyBase(*rhsSymbol, rhsOffset,
+                                           static_cast<int>(copySize * k8BitSize));
+    } else {
+      rhsBaseMemOpnd = GenLargeAggFormalMemOpnd(*rhsSymbol, copySize, rhsOffset, true);
+    }
+    RegOperand *rhsBaseReg = rhsBaseMemOpnd->GetBaseRegister();
+    int64 rhsOffsetVal = rhsBaseMemOpnd->GetOffsetOperand()->GetValue();
+    bool rhsIsLo12 = (rhsBaseMemOpnd->GetAddrMode() == MemOperand::kAddrModeLo12Li);
+    if (lhsSize > kParmMemcpySize) {
+      std::vector<Operand*> opndVec;
+      RegOperand *regResult = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      opndVec.push_back(regResult);  /* result */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(static_cast<int64>(lhsOffset), lhsAddrOpnd));  /* param 0 */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(rhsOffsetVal, *rhsBaseReg));  /* param 1 */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(lhsSize));  /* param 2 */
+
+      SelectLibCall("memcpy", opndVec, PTY_a64, PTY_a64);
+
+      return;
+    }
+    for (uint32 i = 0; i < (lhsSize / copySize); ++i) {
+      uint32 rhsBaseOffset = static_cast<uint32>(rhsOffsetVal + i * copySize);
+      uint32 lhsBaseOffset = lhsOffset + i * copySize;
+      MemOperand::AArch64AddressingMode addrMode =
+          rhsIsLo12 ? MemOperand::kAddrModeLo12Li : MemOperand::kAddrModeBOi;
+      MIRSymbol *sym = rhsIsLo12 ? rhsSymbol : nullptr;
+      OfstOperand &rhsOfstOpnd = GetOrCreateOfstOpnd(rhsBaseOffset, k32BitSize);
+      MemOperand *rhsMemOpnd =
+          &GetOrCreateMemOpnd(addrMode, copySize * k8BitSize, rhsBaseReg, nullptr, &rhsOfstOpnd, sym);
+      rhsMemOpnd = FixLargeMemOpnd(*rhsMemOpnd, copySize);
+      /* generate the load */
+      RegOperand &result = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, std::max(4u, copySize)));
+      MOperator mOpLDP = (copySize == k4BitSize) ? MOP_wldp : MOP_xldp;
+      bool doPair = (!rhsIsLo12 && (copySize >= k4BitSize) && ((i + 1) < (lhsSize / copySize)));
+      RegOperand *result1 = nullptr;
+      if (doPair) {
+        regno_t vRegNO1 = NewVReg(kRegTyInt, std::max(4u, copySize));
+        result1 = &CreateVirtualRegisterOperand(vRegNO1);
+        rhsMemOpnd = FixLargeMemOpnd(mOpLDP, *static_cast<MemOperand*>(rhsMemOpnd), result.GetSize(), kInsnThirdOpnd);
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpLDP, result, *result1, *rhsMemOpnd));
+      } else {
+        MOperator mOp = PickLdInsn(copySize * k8BitSize, PTY_u32);
+        rhsMemOpnd = FixLargeMemOpnd(mOp,  *static_cast<MemOperand*>(rhsMemOpnd), result.GetSize(), kInsnSecondOpnd);
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, *rhsMemOpnd));
+      }
+      /* generate the store */
+      OfstOperand &ofstOpnd = GetOrCreateOfstOpnd(lhsBaseOffset, k32BitSize);
+      MemOperand *lhsMemOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, copySize * k8BitSize,
+          static_cast<RegOperand*>(&lhsAddrOpnd), nullptr, &ofstOpnd, nullptr);
+      if (doPair) {
+        MOperator mOpSTP = (copySize == k4BitSize) ? MOP_wstp : MOP_xstp;
+        lhsMemOpnd = FixLargeMemOpnd(mOpSTP, *lhsMemOpnd, result.GetSize(), kInsnThirdOpnd);
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpSTP, result, *result1, *lhsMemOpnd));
+        i++;
+      } else {
+        MOperator mOp = PickStInsn(copySize * k8BitSize, PTY_u32);
+        lhsMemOpnd = FixLargeMemOpnd(mOp, *lhsMemOpnd, copySize * k8BitSize, kInsnSecondOpnd);
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, *lhsMemOpnd));
+      }
+    }
+    /* take care of extra content at the end less than the unit of alignUsed */
+    uint64 lhsSizeCovered = (lhsSize / copySize) * copySize;
+    uint32 newAlignUsed = copySize;
+    while (lhsSizeCovered < lhsSize) {
+      newAlignUsed = newAlignUsed >> 1;
+      CHECK_FATAL(newAlignUsed != 0, "expect non-zero");
+      if ((lhsSizeCovered + newAlignUsed) > lhsSize) {
+        continue;
+      }
+      MemOperand::AArch64AddressingMode addrMode =
+          rhsIsLo12 ? MemOperand::kAddrModeLo12Li : MemOperand::kAddrModeBOi;
+      MIRSymbol *sym = rhsIsLo12 ? rhsSymbol : nullptr;
+      OfstOperand &rhsOfstOpnd = GetOrCreateOfstOpnd(lhsSizeCovered + static_cast<uint64>(rhsOffsetVal), k32BitSize);
+      MemOperand *rhsMemOpnd =
+          &GetOrCreateMemOpnd(addrMode, newAlignUsed * k8BitSize, rhsBaseReg, nullptr, &rhsOfstOpnd, sym);
+      /* generate the load */
+      Operand &result = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, std::max(4u, newAlignUsed)));
+      MOperator mOp = PickLdInsn(newAlignUsed * k8BitSize, PTY_u32);
+      rhsMemOpnd = FixLargeMemOpnd(mOp, *rhsMemOpnd, newAlignUsed * k8BitSize, kInsnSecondOpnd);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, *rhsMemOpnd));
+      /* generate the store */
+      OfstOperand &ofstOpnd = GetOrCreateOfstOpnd(lhsOffset + lhsSizeCovered, k32BitSize);
+      MemOperand &lhsMemOpnd = GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, newAlignUsed * k8BitSize,
+          static_cast<RegOperand*>(&lhsAddrOpnd), nullptr, &ofstOpnd, static_cast<MIRSymbol*>(nullptr));
+      mOp = PickStInsn(newAlignUsed * k8BitSize, PTY_u32);
+      lhsMemOpnd = *FixLargeMemOpnd(mOp, lhsMemOpnd, newAlignUsed * k8BitSize, kInsnSecondOpnd);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, lhsMemOpnd));
+      lhsSizeCovered += newAlignUsed;
+    }
+  } else {  /* rhs is iread */
+    ASSERT(stmt.GetRHS()->GetOpCode() == OP_iread, "SelectAggDassign: NYI");
+    IreadNode *rhsIread = static_cast<IreadNode*>(stmt.GetRHS());
+    RegOperand *rhsAddrOpnd = static_cast<RegOperand*>(HandleExpr(*rhsIread, *rhsIread->Opnd(0)));
+    rhsAddrOpnd = &LoadIntoRegister(*rhsAddrOpnd, rhsIread->Opnd(0)->GetPrimType());
+    MIRPtrType *rhsPointerType =
+        static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(rhsIread->GetTyIdx()));
+    MIRType *rhsType = static_cast<MIRStructType*>(
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(rhsPointerType->GetPointedTyIdx()));
+    bool isRefField = false;
+    if (rhsIread->GetFieldID() != 0) {
+      MIRStructType *rhsStructType = static_cast<MIRStructType*>(rhsType);
+      ASSERT(rhsStructType, "SelectAggDassign: non-zero fieldID for non-structure");
+      rhsType = rhsStructType->GetFieldType(rhsIread->GetFieldID());
+      rhsOffset = static_cast<uint32>(GetBecommon().GetFieldOffset(*rhsStructType, rhsIread->GetFieldID()).first);
+      isRefField = GetBecommon().IsRefField(*rhsStructType, rhsIread->GetFieldID());
+    }
+    rhsAlign = GetBecommon().GetTypeAlign(rhsType->GetTypeIndex());
+    alignUsed = std::min(lhsAlign, rhsAlign);
+    ASSERT(alignUsed != 0, "expect non-zero");
+    uint32 copySize = GetAggCopySize(rhsOffset, lhsOffset, alignUsed);
+    if (lhsSize > kParmMemcpySize) {
+      std::vector<Operand*> opndVec;
+      RegOperand *regResult = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      opndVec.push_back(regResult);  /* result */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(static_cast<int64>(lhsOffset), lhsAddrOpnd));  /* param 0 */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(static_cast<int64>(rhsOffset), *rhsAddrOpnd));  /* param 1 */
+
+      opndVec.push_back(PrepareMemcpyParamOpnd(lhsSize));  /* param 2 */
+
+      SelectLibCall("memcpy", opndVec, PTY_a64, PTY_a64);
+
+      return;
+    }
+    ASSERT(copySize != 0, "expect non-zero");
+    for (uint32 i = 0; i < (lhsSize / copySize); i++) {
+      /* generate the load */
+      uint32 operandSize = copySize * k8BitSize;
+      OfstOperand &rhsOfstOpnd = GetOrCreateOfstOpnd(rhsOffset + i * copySize, k32BitSize);
+      MemOperand *rhsMemOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, operandSize,
+          static_cast<RegOperand*>(rhsAddrOpnd), nullptr, &rhsOfstOpnd, nullptr);
+      RegOperand &result = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, std::max(4u, copySize)));
+      bool doPair = ((copySize >= k4BitSize) && ((i + 1) < (lhsSize / copySize)));
+      Insn *insn = nullptr;
+      RegOperand *result1 = nullptr;
+      if (doPair) {
+        MOperator mOpLDP = (copySize == k4BitSize) ? MOP_wldp : MOP_xldp;
+        rhsMemOpnd = FixLargeMemOpnd(mOpLDP, *static_cast<MemOperand*>(rhsMemOpnd), operandSize, kInsnThirdOpnd);
+        result1 = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, std::max(4u, copySize)));
+        insn = &GetInsnBuilder()->BuildInsn(mOpLDP, result, *result1, *rhsMemOpnd);
+      } else {
+        MOperator mOp = PickLdInsn(operandSize, PTY_u32);
+        rhsMemOpnd = FixLargeMemOpnd(mOp, *static_cast<MemOperand*>(rhsMemOpnd), operandSize, kInsnSecondOpnd);
+        insn = &GetInsnBuilder()->BuildInsn(mOp, result, *rhsMemOpnd);
+      }
+      insn->MarkAsAccessRefField(isRefField);
+      GetCurBB()->AppendInsn(*insn);
+      /* generate the store */
+      OfstOperand &lhsOfstOpnd = GetOrCreateOfstOpnd(lhsOffset + i * copySize, k32BitSize);
+      MemOperand *lhsMemOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, operandSize,
+          static_cast<RegOperand*>(&lhsAddrOpnd), nullptr, &lhsOfstOpnd, nullptr);
+      if (doPair) {
+        MOperator mOpSTP = (copySize == k4BitSize) ? MOP_wstp : MOP_xstp;
+        lhsMemOpnd = FixLargeMemOpnd(mOpSTP, *static_cast<MemOperand*>(lhsMemOpnd), operandSize, kInsnThirdOpnd);
+        ASSERT(result1 != nullptr, "result1 should not be nullptr");
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpSTP, result, *result1, *lhsMemOpnd));
+        i++;
+      } else {
+        MOperator mOp = PickStInsn(operandSize, PTY_u32);
+        lhsMemOpnd = FixLargeMemOpnd(mOp, *static_cast<MemOperand*>(lhsMemOpnd), operandSize, kInsnSecondOpnd);
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, *lhsMemOpnd));
+      }
+    }
+    /* take care of extra content at the end less than the unit */
+    uint64 lhsSizeCovered = (lhsSize / copySize) * copySize;
+    uint32 newAlignUsed = copySize;
+    while (lhsSizeCovered < lhsSize) {
+      newAlignUsed = newAlignUsed >> 1;
+      CHECK_FATAL(newAlignUsed != 0, "expect non-zero");
+      if ((lhsSizeCovered + newAlignUsed) > lhsSize) {
+        continue;
+      }
+      /* generate the load */
+      OfstOperand &rhsOfstOpnd = GetOrCreateOfstOpnd(rhsOffset + lhsSizeCovered, k32BitSize);
+      uint32 memOpndSize = newAlignUsed * k8BitSize;
+      MemOperand *rhsMemOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, memOpndSize,
+          static_cast<RegOperand*>(rhsAddrOpnd), nullptr, &rhsOfstOpnd, nullptr);
+      regno_t vRegNO = NewVReg(kRegTyInt, std::max(4u, newAlignUsed));
+      RegOperand &result = CreateVirtualRegisterOperand(vRegNO);
+      MOperator mOpLD = PickLdInsn(memOpndSize, PTY_u32);
+      rhsMemOpnd = FixLargeMemOpnd(mOpLD, *rhsMemOpnd, memOpndSize, static_cast<uint32>(kInsnSecondOpnd));
+      Insn &insn = GetInsnBuilder()->BuildInsn(mOpLD, result, *rhsMemOpnd);
+      insn.MarkAsAccessRefField(isRefField);
+      GetCurBB()->AppendInsn(insn);
+      /* generate the store */
+      OfstOperand &lhsOfstOpnd = GetOrCreateOfstOpnd(lhsOffset + lhsSizeCovered, k32BitSize);
+      MemOperand *lhsMemOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, memOpndSize,
+          static_cast<RegOperand*>(&lhsAddrOpnd), nullptr, &lhsOfstOpnd, nullptr);
+      MOperator mOpST = PickStInsn(memOpndSize, PTY_u32);
+      lhsMemOpnd = FixLargeMemOpnd(mOpST, *lhsMemOpnd, memOpndSize, static_cast<uint32>(kInsnSecondOpnd));
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpST, result, *lhsMemOpnd));
+      lhsSizeCovered += newAlignUsed;
+    }
+  }
+}
+
+void AArch64CGFunc::SelectReturnSendOfStructInRegs(BaseNode *x) {
+  uint32 offset = 0;
+  if (x->GetOpCode() == OP_dread) {
+    DreadNode *dread = static_cast<DreadNode *>(x);
+    MIRSymbol *sym = GetFunction().GetLocalOrGlobalSymbol(dread->GetStIdx());
+    MIRType *mirType = sym->GetType();
+    if (dread->GetFieldID() != 0) {
+      MIRStructType *structType = static_cast<MIRStructType *>(mirType);
+      mirType = structType->GetFieldType(dread->GetFieldID());
+      offset = static_cast<uint32>(GetBecommon().GetFieldOffset(*structType, dread->GetFieldID()).first);
+    }
+    uint32 typeSize = GetBecommon().GetTypeSize(mirType->GetTypeIndex());
+    /* generate move to regs for agg return */
+    AArch64CallConvImpl parmlocator(GetBecommon());
+    CCLocInfo pLoc;
+    (void)parmlocator.LocateNextParm(*mirType, pLoc, true, GetBecommon().GetMIRModule().CurFunction());
+    /* aggregates are 8 byte aligned. */
+    Operand *rhsmemopnd = nullptr;
+    RegOperand *result[kFourRegister]; /* up to 2 int or 4 fp */
+    uint32 loadSize;
+    uint32 numRegs;
+    RegType regType;
+    PrimType retPty;
+    bool fpParm = false;
+    if (pLoc.numFpPureRegs > 0) {
+      loadSize = pLoc.fpSize;
+      numRegs = pLoc.numFpPureRegs;
+      fpParm = true;
+      regType = kRegTyFloat;
+      retPty = (pLoc.fpSize == k4ByteSize) ? PTY_f32 : PTY_f64;
+    } else {
+      if (CGOptions::IsBigEndian()) {
+        loadSize = k8ByteSize;
+        numRegs = (typeSize <= k8ByteSize) ? kOneRegister : kTwoRegister;
+        regType = kRegTyInt;
+        retPty = PTY_u64;
+      } else {
+        loadSize = (typeSize <= k4ByteSize) ? k4ByteSize : k8ByteSize;
+        numRegs = (typeSize <= k8ByteSize) ? kOneRegister : kTwoRegister;
+        regType = kRegTyInt;
+        retPty = PTY_u32;
+      }
+    }
+    bool parmCopy = IsParamStructCopy(*sym);
+    for (uint32 i = 0; i < numRegs; i++) {
+      if (parmCopy) {
+        rhsmemopnd = &LoadStructCopyBase(*sym,
+                                         (offset + static_cast<int64>(i * (fpParm ? loadSize : k8ByteSize))),
+                                         static_cast<int>(loadSize * kBitsPerByte));
+      } else {
+        rhsmemopnd = &GetOrCreateMemOpnd(*sym,
+                                         (offset + static_cast<int64>(i * (fpParm ? loadSize : k8ByteSize))),
+                                         (loadSize * kBitsPerByte));
+      }
+      result[i] = &CreateVirtualRegisterOperand(NewVReg(regType, loadSize));
+      MOperator mop1 = PickLdInsn(loadSize * kBitsPerByte, retPty);
+      Insn &ld = GetInsnBuilder()->BuildInsn(mop1, *(result[i]), *rhsmemopnd);
+      GetCurBB()->AppendInsn(ld);
+    }
+    AArch64reg regs[kFourRegister];
+    regs[0] = static_cast<AArch64reg>(pLoc.reg0);
+    regs[1] = static_cast<AArch64reg>(pLoc.reg1);
+    regs[2] = static_cast<AArch64reg>(pLoc.reg2);
+    regs[3] = static_cast<AArch64reg>(pLoc.reg3);
+    RegOperand *dest;
+    for (uint32 i = 0; i < numRegs; i++) {
+      AArch64reg preg;
+      MOperator mop2;
+      if (fpParm) {
+        preg = regs[i];
+        mop2 = (loadSize == k4ByteSize) ? MOP_xvmovs : MOP_xvmovd;
+      } else {
+        preg = (i == 0 ? R0 : R1);
+        mop2 = (loadSize == k4ByteSize) ? MOP_wmovrr : MOP_xmovrr;
+      }
+      dest = &GetOrCreatePhysicalRegisterOperand(preg, (loadSize * kBitsPerByte), regType);
+      Insn &mov = GetInsnBuilder()->BuildInsn(mop2, *dest, *(result[i]));
+      GetCurBB()->AppendInsn(mov);
+    }
+    /* Create artificial dependency to extend the live range */
+    for (uint32 i = 0; i < numRegs; i++) {
+      AArch64reg preg;
+      MOperator mop3;
+      if (fpParm) {
+        preg = regs[i];
+        mop3 = MOP_pseudo_ret_float;
+      } else {
+        preg = (i == 0 ? R0 : R1);
+        mop3 = MOP_pseudo_ret_int;
+      }
+      dest = &GetOrCreatePhysicalRegisterOperand(preg, loadSize * kBitsPerByte, regType);
+      Insn &pseudo = GetInsnBuilder()->BuildInsn(mop3, *dest);
+      GetCurBB()->AppendInsn(pseudo);
+    }
+    return;
+  } else if (x->GetOpCode() == OP_iread) {
+    IreadNode *iread = static_cast<IreadNode*>(x);
+    RegOperand *rhsAddrOpnd = static_cast<RegOperand*>(HandleExpr(*iread, *iread->Opnd(0)));
+    rhsAddrOpnd = &LoadIntoRegister(*rhsAddrOpnd, iread->Opnd(0)->GetPrimType());
+    MIRPtrType *ptrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx()));
+    MIRType *mirType = static_cast<MIRStructType*>(ptrType->GetPointedType());
+    bool isRefField = false;
+    if (iread->GetFieldID() != 0) {
+      MIRStructType *structType = static_cast<MIRStructType*>(mirType);
+      mirType = structType->GetFieldType(iread->GetFieldID());
+      offset = static_cast<uint32>(GetBecommon().GetFieldOffset(*structType, iread->GetFieldID()).first);
+      isRefField = GetBecommon().IsRefField(*structType, iread->GetFieldID());
+    }
+    uint32 typeSize = static_cast<uint32>(GetBecommon().GetTypeSize(mirType->GetTypeIndex()));
+    /* generate move to regs. */
+    RegOperand *result[kTwoRegister]; /* maximum 16 bytes, 2 registers */
+    uint32 loadSize;
+    if (CGOptions::IsBigEndian()) {
+      loadSize = k8ByteSize;
+    } else {
+      loadSize = (typeSize <= k4ByteSize) ? k4ByteSize : k8ByteSize;
+    }
+    uint32 numRegs = (typeSize <= k8ByteSize) ? kOneRegister : kTwoRegister;
+    for (uint32 i = 0; i < numRegs; i++) {
+      OfstOperand *rhsOffOpnd = &GetOrCreateOfstOpnd(offset + i * loadSize, loadSize * kBitsPerByte);
+      Operand &rhsmemopnd = GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, loadSize * kBitsPerByte,
+          rhsAddrOpnd, nullptr, rhsOffOpnd, nullptr);
+      result[i] = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, loadSize));
+      MOperator mop1 = PickLdInsn(loadSize * kBitsPerByte, PTY_u32);
+      Insn &ld = GetInsnBuilder()->BuildInsn(mop1, *(result[i]), rhsmemopnd);
+      ld.MarkAsAccessRefField(isRefField);
+      GetCurBB()->AppendInsn(ld);
+    }
+    RegOperand *dest;
+    for (uint32 i = 0; i < numRegs; i++) {
+      AArch64reg preg = (i == 0 ? R0 : R1);
+      dest = &GetOrCreatePhysicalRegisterOperand(preg, loadSize * kBitsPerByte, kRegTyInt);
+      Insn &mov = GetInsnBuilder()->BuildInsn(MOP_xmovrr, *dest, *(result[i]));
+      GetCurBB()->AppendInsn(mov);
+    }
+    /* Create artificial dependency to extend the live range */
+    for (uint32 i = 0; i < numRegs; i++) {
+      AArch64reg preg = (i == 0 ? R0 : R1);
+      dest = &GetOrCreatePhysicalRegisterOperand(preg, loadSize * kBitsPerByte, kRegTyInt);
+      Insn &pseudo = GetInsnBuilder()->BuildInsn(MOP_pseudo_ret_int, *dest);
+      GetCurBB()->AppendInsn(pseudo);
+    }
+    return;
+  } else {  // dummy return of 0 inserted by front-end at absence of return
+    ASSERT(x->GetOpCode() == OP_constval, "SelectReturnSendOfStructInRegs: unexpected return operand");
+    uint32 typeSize = GetPrimTypeSize(x->GetPrimType());
+    RegOperand &dest = GetOrCreatePhysicalRegisterOperand(R0, typeSize * kBitsPerByte, kRegTyInt);
+    ImmOperand &src = CreateImmOperand(0, k16BitSize, false);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wmovri32, dest, src));
+    return;
+  }
+}
+
+Operand *AArch64CGFunc::SelectDread(const BaseNode &parent, DreadNode &expr) {
+  MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(expr.GetStIdx());
+  if (symbol->IsEhIndex()) {
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_i32));
+    /* use the second register return by __builtin_eh_return(). */
+    AArch64CallConvImpl retLocator(GetBecommon());
+    CCLocInfo retMech;
+    retLocator.InitReturnInfo(*type, retMech);
+    retLocator.SetupSecondRetReg(*type, retMech);
+    return &GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(retMech.GetReg1()), k64BitSize, kRegTyInt);
+  }
+
+  PrimType symType = symbol->GetType()->GetPrimType();
+  uint32 offset = 0;
+  bool parmCopy = false;
+  if (expr.GetFieldID() != 0) {
+    MIRStructType *structType = static_cast<MIRStructType*>(symbol->GetType());
+    ASSERT(structType != nullptr, "SelectDread: non-zero fieldID for non-structure");
+    symType = structType->GetFieldType(expr.GetFieldID())->GetPrimType();
+    offset = static_cast<uint32>(GetBecommon().GetFieldOffset(*structType, expr.GetFieldID()).first);
+    parmCopy = IsParamStructCopy(*symbol);
+  }
+
+  uint32 dataSize = GetPrimTypeBitSize(symType);
+  uint32 aggSize = 0;
+  PrimType resultType = expr.GetPrimType();
+  if (symType == PTY_agg) {
+    if (expr.GetPrimType() == PTY_agg) {
+      aggSize = static_cast<uint32>(GetBecommon().GetTypeSize(symbol->GetType()->GetTypeIndex().GetIdx()));
+      dataSize = ((expr.GetFieldID() == 0) ? GetPointerSize() : aggSize) << 3;
+      resultType = PTY_u64;
+      symType = resultType;
+    } else {
+      dataSize = GetPrimTypeBitSize(expr.GetPrimType());
+    }
+  }
+  MemOperand *memOpnd = nullptr;
+  if (aggSize > k8ByteSize) {
+    if (parent.op == OP_eval) {
+      if (symbol->GetAttr(ATTR_volatile)) {
+        /* Need to generate loads for the upper parts of the struct. */
+        Operand &dest = GetZeroOpnd(k64BitSize);
+        uint32 numLoads = static_cast<uint32>(RoundUp(aggSize, k64BitSize) / k64BitSize);
+        for (uint32 o = 0; o < numLoads; ++o) {
+          if (parmCopy) {
+            memOpnd = &LoadStructCopyBase(*symbol, offset + o * GetPointerSize(), GetPointerSize());
+          } else {
+            memOpnd = &GetOrCreateMemOpnd(*symbol, offset + o * GetPointerSize(), GetPointerSize());
+          }
+          if (IsImmediateOffsetOutOfRange(*memOpnd, GetPointerSize())) {
+            memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, GetPointerSize());
+          }
+          SelectCopy(dest, PTY_u64, *memOpnd, PTY_u64);
+        }
+      } else {
+        /* No side-effects.  No need to generate anything for eval. */
+      }
+    } else {
+      if (expr.GetFieldID() != 0) {
+        CHECK_FATAL(false, "SelectDread: Illegal agg size");
+      }
+    }
+  }
+  if (parmCopy) {
+    memOpnd = &LoadStructCopyBase(*symbol, offset, static_cast<int>(dataSize));
+  } else {
+    memOpnd = &GetOrCreateMemOpnd(*symbol, offset, dataSize);
+  }
+  if ((memOpnd->GetMemVaryType() == kNotVary) &&
+      IsImmediateOffsetOutOfRange(*memOpnd, dataSize)) {
+    memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, dataSize);
+  }
+
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, symType);
+  /* a local register variable defined with a specified register */
+  if (symbol->GetAsmAttr() != UStrIdx(0) &&
+      symbol->GetStorageClass() != kScPstatic && symbol->GetStorageClass() != kScFstatic) {
+    std::string regDesp = GlobalTables::GetUStrTable().GetStringFromStrIdx(symbol->GetAsmAttr());
+    RegOperand &specifiedOpnd = GetOrCreatePhysicalRegisterOperand(regDesp);
+    return &specifiedOpnd;
+  }
+  memOpnd = memOpnd->IsOffsetMisaligned(dataSize) ?
+            &ConstraintOffsetToSafeRegion(dataSize, *memOpnd, symbol) : memOpnd;
+  SelectCopy(resOpnd, resultType, *memOpnd, symType);
+  return &resOpnd;
+}
+
+RegOperand *AArch64CGFunc::SelectRegread(RegreadNode &expr) {
+  PregIdx pregIdx = expr.GetRegIdx();
+  if (IsSpecialPseudoRegister(pregIdx)) {
+    /* if it is one of special registers */
+    return &GetOrCreateSpecialRegisterOperand(-pregIdx, expr.GetPrimType());
+  }
+  RegOperand &reg = GetOrCreateVirtualRegisterOperand(GetVirtualRegNOFromPseudoRegIdx(pregIdx));
+  if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+    MemOperand *src = GetPseudoRegisterSpillMemoryOperand(pregIdx);
+    MIRPreg *preg = GetFunction().GetPregTab()->PregFromPregIdx(pregIdx);
+    PrimType stype = preg->GetPrimType();
+    uint32 srcBitLength = GetPrimTypeSize(stype) * kBitsPerByte;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickLdInsn(srcBitLength, stype), reg, *src));
+  }
+  return &reg;
+}
+
+void AArch64CGFunc::SelectAddrof(Operand &result, StImmOperand &stImm, FieldID field) {
+  const MIRSymbol *symbol = stImm.GetSymbol();
+  if (!GetFunction().IsMayWriteToAddrofStackChecked() && symbol->GetStorageClass() == kScAuto) {
+    SetStackProtectInfo(kAddrofStack);
+  }
+  if ((symbol->GetStorageClass() == kScAuto) || (symbol->GetStorageClass() == kScFormal)) {
+    if (!CGOptions::IsQuiet()) {
+      maple::LogInfo::MapleLogger(kLlErr) <<
+          "Warning: we expect AddrOf with StImmOperand is not used for local variables";
+    }
+    AArch64SymbolAlloc *symLoc =
+        static_cast<AArch64SymbolAlloc*>(GetMemlayout()->GetSymAllocInfo(symbol->GetStIndex()));
+    ImmOperand *offset = nullptr;
+    if (symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed) {
+      offset = &CreateImmOperand(GetBaseOffset(*symLoc) + stImm.GetOffset(), k64BitSize, false, kUnAdjustVary);
+    } else if (symLoc->GetMemSegment()->GetMemSegmentKind() == kMsRefLocals) {
+      auto it = immOpndsRequiringOffsetAdjustmentForRefloc.find(symLoc);
+      if (it != immOpndsRequiringOffsetAdjustmentForRefloc.end()) {
+        offset = (*it).second;
+      } else {
+        offset = &CreateImmOperand(GetBaseOffset(*symLoc) + stImm.GetOffset(), k64BitSize, false);
+        immOpndsRequiringOffsetAdjustmentForRefloc[symLoc] = offset;
+      }
+    } else if (mirModule.IsJavaModule()) {
+      auto it = immOpndsRequiringOffsetAdjustment.find(symLoc);
+      if ((it != immOpndsRequiringOffsetAdjustment.end()) && (symbol->GetType()->GetPrimType() != PTY_agg)) {
+        offset = (*it).second;
+      } else {
+        offset = &CreateImmOperand(GetBaseOffset(*symLoc) + stImm.GetOffset(), k64BitSize, false);
+        if (symbol->GetType()->GetKind() != kTypeClass) {
+          immOpndsRequiringOffsetAdjustment[symLoc] = offset;
+        }
+      }
+    } else {
+      /* Do not cache modified symbol location */
+      offset = &CreateImmOperand(GetBaseOffset(*symLoc) + stImm.GetOffset(), k64BitSize, false);
+    }
+
+    SelectAdd(result, *GetBaseReg(*symLoc), *offset, PTY_u64);
+    if (GetCG()->GenerateVerboseCG()) {
+      /* Add a comment */
+      Insn *insn = GetCurBB()->GetLastInsn();
+      std::string comm = "local/formal var: ";
+      comm.append(symbol->GetName());
+      insn->SetComment(comm);
+    }
+  } else if (symbol->IsThreadLocal()) {
+    SelectAddrofThreadLocal(result, stImm);
+    return;
+  } else {
+    Operand *srcOpnd = &result;
+    if (!IsAfterRegAlloc()) {
+      // Create a new vreg/preg for the upper bits of the address
+      PregIdx pregIdx = GetFunction().GetPregTab()->CreatePreg(PTY_a64);
+      MIRPreg *tmpPreg = GetFunction().GetPregTab()->PregFromPregIdx(pregIdx);
+      regno_t vRegNO = NewVReg(kRegTyInt, GetPrimTypeSize(PTY_a64));
+      RegOperand &tmpreg = GetOrCreateVirtualRegisterOperand(vRegNO);
+
+      // Register this vreg mapping
+      RegisterVregMapping(vRegNO, pregIdx);
+
+      // Store rematerialization info in the preg
+      tmpPreg->SetOp(OP_addrof);
+      tmpPreg->rematInfo.sym = symbol;
+      tmpPreg->fieldID = field;
+      tmpPreg->addrUpper = true;
+
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrp, tmpreg, stImm));
+      srcOpnd = &tmpreg;
+    } else {
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrp, result, stImm));
+    }
+    if (CGOptions::IsPIC() && symbol->NeedPIC()) {
+      /* ldr     x0, [x0, #:got_lo12:Ljava_2Flang_2FSystem_3B_7Cout] */
+      OfstOperand &offset = CreateOfstOpnd(*stImm.GetSymbol(), stImm.GetOffset(), stImm.GetRelocs());
+
+      auto size = GetPointerSize() * kBitsPerByte;
+      MemOperand &memOpnd = GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, size, static_cast<RegOperand *>(srcOpnd),
+                                               nullptr, &offset, nullptr);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(size == k64BitSize ? MOP_xldr : MOP_wldr,
+                                                 result, memOpnd));
+
+      if (stImm.GetOffset() > 0) {
+        ImmOperand &immOpnd = CreateImmOperand(stImm.GetOffset(), result.GetSize(), false);
+        SelectAdd(result, result, immOpnd, PTY_u64);
+      }
+    } else {
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrpl12, result, *srcOpnd, stImm));
+    }
+  }
+}
+
+void AArch64CGFunc::SelectAddrof(Operand &result, MemOperand &memOpnd, FieldID field) {
+  const MIRSymbol *symbol = memOpnd.GetSymbol();
+  if (symbol->GetStorageClass() == kScAuto) {
+    auto *offsetOpnd = static_cast<OfstOperand*>(memOpnd.GetOffsetImmediate());
+    Operand &immOpnd = CreateImmOperand(offsetOpnd->GetOffsetValue(), PTY_u32, false);
+    ASSERT(memOpnd.GetBaseRegister() != nullptr, "nullptr check");
+    SelectAdd(result, *memOpnd.GetBaseRegister(), immOpnd, PTY_u32);
+    if (!GetFunction().IsMayWriteToAddrofStackChecked()) {
+      SetStackProtectInfo(kAddrofStack);
+    }
+  } else if (!IsAfterRegAlloc()) {
+    // Create a new vreg/preg for the upper bits of the address
+    PregIdx pregIdx = GetFunction().GetPregTab()->CreatePreg(PTY_a64);
+    MIRPreg *tmpPreg = GetFunction().GetPregTab()->PregFromPregIdx(pregIdx);
+    regno_t vRegNO = NewVReg(kRegTyInt, GetPrimTypeSize(PTY_a64));
+    RegOperand &tmpreg = GetOrCreateVirtualRegisterOperand(vRegNO);
+
+    // Register this vreg mapping
+    RegisterVregMapping(vRegNO, pregIdx);
+
+    // Store rematerialization info in the preg
+    tmpPreg->SetOp(OP_addrof);
+    tmpPreg->rematInfo.sym = symbol;
+    tmpPreg->fieldID = field;
+    tmpPreg->addrUpper = true;
+
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrp, tmpreg, memOpnd));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrpl12, result, tmpreg, memOpnd));
+  } else {
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrp, result, memOpnd));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrpl12, result, result, memOpnd));
+  }
+}
+
+Operand *AArch64CGFunc::SelectAddrof(AddrofNode &expr, const BaseNode &parent, bool isAddrofoff) {
+  MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(expr.GetStIdx());
+  int32 offset = 0;
+  AddrofoffNode &addrofoffExpr = static_cast<AddrofoffNode&>(static_cast<BaseNode&>(expr));
+  if (isAddrofoff) {
+    offset = addrofoffExpr.offset;
+  } else {
+    if (expr.GetFieldID() != 0) {
+      MIRStructType *structType = static_cast<MIRStructType*>(symbol->GetType());
+      /* with array of structs, it is possible to have nullptr */
+      if (structType != nullptr) {
+        offset = GetBecommon().GetFieldOffset(*structType, expr.GetFieldID()).first;
+      }
+    }
+  }
+  if ((symbol->GetStorageClass() == kScFormal) && (symbol->GetSKind() == kStVar) &&
+      ((!isAddrofoff && expr.GetFieldID() != 0) ||
+       (GetBecommon().GetTypeSize(symbol->GetType()->GetTypeIndex().GetIdx()) > k16ByteSize))) {
+    /*
+     * Struct param is copied on the stack by caller if struct size > 16.
+     * Else if size < 16 then struct param is copied into one or two registers.
+     */
+    RegOperand *stackAddr = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+    /* load the base address of the struct copy from stack. */
+    SelectAddrof(*stackAddr, CreateStImmOperand(*symbol, 0, 0));
+    Operand *structAddr;
+    if (GetBecommon().GetTypeSize(symbol->GetType()->GetTypeIndex().GetIdx()) <= k16ByteSize) {
+      isAggParamInReg = true;
+      structAddr = stackAddr;
+    } else {
+      OfstOperand *offopnd = &CreateOfstOpnd(0, k32BitSize);
+      MemOperand *mo = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, GetPointerSize() * kBitsPerByte,
+          stackAddr, nullptr, offopnd, nullptr);
+      structAddr = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xldr, *structAddr, *mo));
+    }
+    if (offset == 0) {
+      return structAddr;
+    } else {
+      /* add the struct offset to the base address */
+      Operand *result = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      ImmOperand *imm = &CreateImmOperand(PTY_a64, offset);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, *result, *structAddr, *imm));
+      return result;
+    }
+  }
+  PrimType ptype = expr.GetPrimType();
+  Operand &result = GetOrCreateResOperand(parent, ptype);
+  if (symbol->IsReflectionClassInfo() && !symbol->IsReflectionArrayClassInfo() && !GetCG()->IsLibcore()) {
+    /*
+     * Turn addrof __cinf_X  into a load of _PTR__cinf_X
+     * adrp    x1, _PTR__cinf_Ljava_2Flang_2FSystem_3B
+     * ldr     x1, [x1, #:lo12:_PTR__cinf_Ljava_2Flang_2FSystem_3B]
+     */
+    std::string ptrName = namemangler::kPtrPrefixStr + symbol->GetName();
+    MIRType *ptrType = GlobalTables::GetTypeTable().GetPtr();
+    symbol = GetMirModule().GetMIRBuilder()->GetOrCreateGlobalDecl(ptrName, *ptrType);
+    symbol->SetStorageClass(kScFstatic);
+
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_adrp_ldr, result, CreateStImmOperand(*symbol, 0, 0)));
+    /* make it un rematerializable. */
+    MIRPreg *preg = GetPseudoRegFromVirtualRegNO(static_cast<RegOperand&>(result).GetRegisterNumber());
+    if (preg) {
+      preg->SetOp(OP_undef);
+    }
+    return &result;
+  }
+
+  SelectAddrof(result, CreateStImmOperand(*symbol, offset, 0), isAddrofoff ? 0 : expr.GetFieldID());
+  return &result;
+}
+
+Operand *AArch64CGFunc::SelectAddrofoff(AddrofoffNode &expr, const BaseNode &parent) {
+  return SelectAddrof(static_cast<AddrofNode&>(static_cast<BaseNode&>(expr)), parent, true);
+}
+
+Operand &AArch64CGFunc::SelectAddrofFunc(AddroffuncNode &expr, const BaseNode &parent) {
+  uint32 instrSize = static_cast<uint32>(expr.SizeOfInstr());
+  PrimType primType = (instrSize == k8ByteSize) ? PTY_u64 :
+                      (instrSize == k4ByteSize) ? PTY_u32 :
+                      (instrSize == k2ByteSize) ? PTY_u16 : PTY_u8;
+  Operand &operand = GetOrCreateResOperand(parent, primType);
+  MIRFunction *mirFunction = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(expr.GetPUIdx());
+  SelectAddrof(operand, CreateStImmOperand(*mirFunction->GetFuncSymbol(), 0, 0));
+  return operand;
+}
+
+/* For an entire aggregate that can fit inside a single 8 byte register.  */
+PrimType AArch64CGFunc::GetDestTypeFromAggSize(uint32 bitSize) const {
+  PrimType primType;
+  switch (bitSize) {
+    case k8BitSize: {
+      primType = PTY_u8;
+      break;
+    }
+    case k16BitSize: {
+      primType = PTY_u16;
+      break;
+    }
+    case k32BitSize: {
+      primType = PTY_u32;
+      break;
+    }
+    case k64BitSize: {
+      primType = PTY_u64;
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "aggregate of unhandled size");
+  }
+  return primType;
+}
+
+Operand &AArch64CGFunc::SelectAddrofLabel(AddroflabelNode &expr, const BaseNode &parent) {
+  /* adrp reg, label-id */
+  uint32 instrSize = static_cast<uint32>(expr.SizeOfInstr());
+  PrimType primType = (instrSize == k8ByteSize) ? PTY_u64 :
+                      (instrSize == k4ByteSize) ? PTY_u32 :
+                      (instrSize == k2ByteSize) ? PTY_u16 : PTY_u8;
+  Operand &dst = GetOrCreateResOperand(parent, primType);
+  Operand &immOpnd = CreateImmOperand(expr.GetOffset(), k64BitSize, false);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_adrp_label, dst, immOpnd));
+  return dst;
+}
+
+Operand *AArch64CGFunc::SelectIreadoff(const BaseNode &parent, IreadoffNode &ireadoff) {
+  auto offset = ireadoff.GetOffset();
+  auto primType = ireadoff.GetPrimType();
+  auto bitSize = GetPrimTypeBitSize(primType);
+  auto *baseAddr = ireadoff.Opnd(0);
+  auto *result = &CreateRegisterOperandOfType(primType);
+  auto *addrOpnd = HandleExpr(ireadoff, *baseAddr);
+  if (primType == PTY_agg && parent.GetOpCode() == OP_regassign) {
+    auto &memOpnd = CreateMemOpnd(LoadIntoRegister(*addrOpnd, PTY_a64), offset, bitSize);
+    auto mop = PickLdInsn(64, PTY_a64);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mop, *result, memOpnd));
+    auto &regAssignNode = static_cast<const RegassignNode&>(parent);
+    PregIdx pIdx = regAssignNode.GetRegIdx();
+    CHECK_FATAL(IsSpecialPseudoRegister(pIdx), "SelectIreadfpoff of agg");
+    (void)LmbcSmallAggForRet(parent, addrOpnd, offset, true);
+    // result not used
+  } else {
+    auto &memOpnd = CreateMemOpnd(LoadIntoRegister(*addrOpnd, PTY_a64), offset, bitSize);
+    auto mop = PickLdInsn(bitSize, primType);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mop, *result, memOpnd));
+  }
+  return result;
+}
+
+RegOperand *AArch64CGFunc::GenLmbcParamLoad(int32 offset, uint32 byteSize, RegType regType, PrimType primType,
+                                            AArch64reg baseRegno) {
+  MemOperand *memOpnd = GenLmbcFpMemOperand(offset, byteSize, baseRegno);
+  RegOperand *result = &GetOrCreateVirtualRegisterOperand(NewVReg(regType, byteSize));
+  MOperator mOp = PickLdInsn(byteSize * kBitsPerByte, primType);
+  Insn &load = GetInsnBuilder()->BuildInsn(mOp, *result, *memOpnd);
+  GetCurBB()->AppendInsn(load);
+  return result;
+}
+
+RegOperand *AArch64CGFunc::LmbcStructReturnLoad(int32 offset) {
+  RegOperand *result = nullptr;
+  MIRFunction &func = GetFunction();
+  CHECK_FATAL(func.IsReturnStruct(), "LmbcStructReturnLoad: not struct return");
+  MIRType *ty = func.GetReturnType();
+  uint32 sz = static_cast<uint32>(GetBecommon().GetTypeSize(ty->GetTypeIndex()));
+  uint32 fpSize;
+  uint32 numFpRegs = FloatParamRegRequired(static_cast<MIRStructType*>(ty), fpSize);
+  if (numFpRegs > 0) {
+    PrimType pType = (fpSize <= k4ByteSize) ? PTY_f32 : PTY_f64;
+    for (int32 i = static_cast<int32>(numFpRegs - kOneRegister); i > 0; --i) {
+      result = GenLmbcParamLoad(offset + (i * static_cast<int32>(fpSize)), fpSize, kRegTyFloat, pType);
+      AArch64reg regNo = static_cast<AArch64reg>(V0 + static_cast<uint32>(i));
+      RegOperand *reg = &GetOrCreatePhysicalRegisterOperand(regNo, fpSize * kBitsPerByte, kRegTyFloat);
+      SelectCopy(*reg, pType, *result, pType);
+      Insn &pseudo = GetInsnBuilder()->BuildInsn(MOP_pseudo_ret_float, *reg);
+      GetCurBB()->AppendInsn(pseudo);
+    }
+    result = GenLmbcParamLoad(offset, fpSize, kRegTyFloat, pType);
+  } else if (sz <= k4ByteSize) {
+    result = GenLmbcParamLoad(offset, k4ByteSize, kRegTyInt, PTY_u32);
+  } else if (sz <= k8ByteSize) {
+    result = GenLmbcParamLoad(offset, k8ByteSize, kRegTyInt, PTY_i64);
+  } else if (sz <= k16ByteSize) {
+    result = GenLmbcParamLoad(offset + k8ByteSizeInt, k8ByteSize, kRegTyInt, PTY_i64);
+    RegOperand *r1 = &GetOrCreatePhysicalRegisterOperand(R1, k8ByteSize * kBitsPerByte, kRegTyInt);
+    SelectCopy(*r1, PTY_i64, *result, PTY_i64);
+    Insn &pseudo = GetInsnBuilder()->BuildInsn(MOP_pseudo_ret_int, *r1);
+    GetCurBB()->AppendInsn(pseudo);
+    result = GenLmbcParamLoad(offset, k8ByteSize, kRegTyInt, PTY_i64);
+  }
+  return result;
+}
+
+Operand *AArch64CGFunc::SelectIreadfpoff(const BaseNode &parent, IreadFPoffNode &ireadoff) {
+  int32 offset = ireadoff.GetOffset();
+  PrimType primType = ireadoff.GetPrimType();
+  uint32 bytelen = GetPrimTypeSize(primType);
+  RegType regty = GetRegTyFromPrimTy(primType);
+  RegOperand *result = nullptr;
+  if (offset > 0) {
+    CHECK_FATAL(false, "Invalid ireadfpoff offset");
+  } else {
+    if (primType == PTY_agg) {
+      /* agg return */
+      CHECK_FATAL(parent.GetOpCode() == OP_regassign, "SelectIreadfpoff of agg");
+      result = LmbcStructReturnLoad(offset);
+    } else {
+      result = GenLmbcParamLoad(offset, bytelen, regty, primType);
+    }
+  }
+  return result;
+}
+
+Operand *AArch64CGFunc::SelectIread(const BaseNode &parent, IreadNode &expr,
+                                    int extraOffset, PrimType finalBitFieldDestType) {
+  int32 offset = 0;
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(expr.GetTyIdx());
+  MIRPtrType *pointerType = static_cast<MIRPtrType*>(type);
+  ASSERT(pointerType != nullptr, "expect a pointer type at iread node");
+  MIRType *pointedType = nullptr;
+  bool isRefField = false;
+  AArch64isa::MemoryOrdering memOrd = AArch64isa::kMoNone;
+
+  if (expr.GetFieldID() != 0) {
+    MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerType->GetPointedTyIdx());
+    MIRStructType *structType = nullptr;
+    if (pointedTy->GetKind() != kTypeJArray) {
+      structType = static_cast<MIRStructType*>(pointedTy);
+    } else {
+      /* it's a Jarray type. using it's parent's field info: java.lang.Object */
+      structType = static_cast<MIRJarrayType*>(pointedTy)->GetParentType();
+    }
+
+    ASSERT(structType != nullptr, "SelectIread: non-zero fieldID for non-structure");
+    pointedType = structType->GetFieldType(expr.GetFieldID());
+    offset = GetBecommon().GetFieldOffset(*structType, expr.GetFieldID()).first;
+    isRefField = GetBecommon().IsRefField(*structType, expr.GetFieldID());
+  } else {
+    pointedType = GetPointedToType(*pointerType);
+    if (GetFunction().IsJava() && (pointedType->GetKind() == kTypePointer)) {
+      MIRType *nextPointedType =
+          GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<MIRPtrType*>(pointedType)->GetPointedTyIdx());
+      if (nextPointedType->GetKind() != kTypeScalar) {
+        isRefField = true;  /* read from an object array, or an high-dimentional array */
+      }
+    }
+  }
+
+  RegType regType = GetRegTyFromPrimTy(expr.GetPrimType());
+  uint32 regSize = GetPrimTypeSize(expr.GetPrimType());
+  if (expr.GetFieldID() == 0 && pointedType->GetPrimType() == PTY_agg) {
+    /* Maple IR can passing small struct to be loaded into a single register. */
+    if (regType == kRegTyFloat) {
+      /* regsize is correct */
+    } else {
+      uint32 sz = GetBecommon().GetTypeSize(pointedType->GetTypeIndex().GetIdx());
+      regSize = (sz <= k4ByteSize) ? k4ByteSize : k8ByteSize;
+    }
+  } else if (regSize < k4ByteSize) {
+    regSize = k4ByteSize;  /* 32-bit */
+  }
+  Operand *result = nullptr;
+  if (parent.GetOpCode() == OP_eval) {
+    /* regSize << 3, that is regSize * 8, change bytes to bits */
+    result = &GetZeroOpnd(regSize << 3);
+  } else {
+    result = &GetOrCreateResOperand(parent, expr.GetPrimType());
+  }
+
+  PrimType destType = pointedType->GetPrimType();
+
+  uint32 bitSize = 0;
+  if ((pointedType->GetKind() == kTypeStructIncomplete) || (pointedType->GetKind() == kTypeClassIncomplete) ||
+      (pointedType->GetKind() == kTypeInterfaceIncomplete)) {
+    bitSize = GetPrimTypeBitSize(expr.GetPrimType());
+    maple::LogInfo::MapleLogger(kLlErr) << "Warning: objsize is zero! \n";
+  } else {
+    if (pointedType->IsStructType()) {
+      MIRStructType *structType = static_cast<MIRStructType*>(pointedType);
+      /* size << 3, that is size * 8, change bytes to bits */
+      bitSize = static_cast<uint32>(std::min(structType->GetSize(), static_cast<size_t>(GetPointerSize())) << 3);
+    } else {
+      bitSize = GetPrimTypeBitSize(destType);
+    }
+    if (regType == kRegTyFloat) {
+      destType = expr.GetPrimType();
+      bitSize = GetPrimTypeBitSize(destType);
+    } else if (destType == PTY_agg) {
+      switch (bitSize) {
+        case k8BitSize:
+          destType = PTY_u8;
+          break;
+        case k16BitSize:
+          destType = PTY_u16;
+          break;
+        case k32BitSize:
+          destType = PTY_u32;
+          break;
+        case k64BitSize:
+          destType = PTY_u64;
+          break;
+        default:
+          destType = PTY_u64; // when eval agg . a way to round up
+          ASSERT(bitSize == 0, " round up empty agg ");
+          bitSize = k64BitSize;
+          break;
+      }
+    }
+  }
+
+  MemOperand *memOpnd =
+      CreateMemOpndOrNull(destType, expr, *expr.Opnd(0), static_cast<int64>(offset) + extraOffset, memOrd);
+  if (aggParamReg != nullptr) {
+    isAggParamInReg = false;
+    return aggParamReg;
+  }
+  ASSERT(memOpnd != nullptr, "memOpnd should not be nullptr");
+  if (isVolLoad && (memOpnd->GetAddrMode() == MemOperand::kAddrModeBOi)) {
+    memOrd = AArch64isa::kMoAcquire;
+    isVolLoad = false;
+  }
+
+  memOpnd = memOpnd->IsOffsetMisaligned(bitSize) ?
+            &ConstraintOffsetToSafeRegion(bitSize, *memOpnd, nullptr) : memOpnd;
+  if (memOrd == AArch64isa::kMoNone) {
+    MOperator mOp = 0;
+    if (finalBitFieldDestType == kPtyInvalid) {
+      mOp = PickLdInsn(bitSize, destType);
+    } else {
+      mOp = PickLdInsn(GetPrimTypeBitSize(finalBitFieldDestType), finalBitFieldDestType);
+    }
+    if ((memOpnd->GetMemVaryType() == kNotVary) && !IsOperandImmValid(mOp, memOpnd, 1)) {
+      memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, bitSize);
+    }
+    Insn &insn = GetInsnBuilder()->BuildInsn(mOp, *result, *memOpnd);
+    if (parent.GetOpCode() == OP_eval && result->IsRegister() &&
+        static_cast<RegOperand*>(result)->GetRegisterNumber() == RZR) {
+      insn.SetComment("null-check");
+    }
+    GetCurBB()->AppendInsn(insn);
+
+    if (parent.op != OP_eval) {
+      const InsnDesc *md = &AArch64CG::kMd[insn.GetMachineOpcode()];
+      auto *prop = md->GetOpndDes(0);
+      if ((prop->GetSize()) < insn.GetOperand(0).GetSize()) {
+        switch (destType) {
+          case PTY_i8:
+            mOp = MOP_xsxtb64;
+            break;
+          case PTY_i16:
+            mOp = MOP_xsxth64;
+            break;
+          case PTY_i32:
+            mOp = MOP_xsxtw64;
+            break;
+          case PTY_u8:
+            mOp = MOP_xuxtb32;
+            break;
+          case PTY_u16:
+            mOp = MOP_xuxth32;
+            break;
+          case PTY_u32:
+            mOp = MOP_xuxtw64;
+            break;
+          default:
+            break;
+        }
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+            mOp, insn.GetOperand(0), insn.GetOperand(0)));
+      }
+    }
+  } else {
+    if ((memOpnd->GetMemVaryType() == kNotVary) && IsImmediateOffsetOutOfRange(*memOpnd, bitSize)) {
+      memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, bitSize);
+    }
+    AArch64CGFunc::SelectLoadAcquire(*result, destType, *memOpnd, destType, memOrd, false);
+  }
+  GetCurBB()->GetLastInsn()->MarkAsAccessRefField(isRefField);
+  return result;
+}
+
+Operand *AArch64CGFunc::SelectIntConst(MIRIntConst &intConst) {
+  return &CreateImmOperand(intConst.GetExtValue(), GetPrimTypeSize(intConst.GetType().GetPrimType()) * kBitsPerByte,
+                           false);
+}
+
+template <typename T>
+Operand *SelectLiteral(T *c, MIRFunction *func, uint32 labelIdx, AArch64CGFunc *cgFunc) {
+  MIRSymbol *st = func->GetSymTab()->CreateSymbol(kScopeLocal);
+  std::string lblStr(".LB_");
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
+  std::string funcName = funcSt->GetName();
+  lblStr.append(funcName).append(std::to_string(labelIdx));
+  st->SetNameStrIdx(lblStr);
+  st->SetStorageClass(kScPstatic);
+  st->SetSKind(kStConst);
+  st->SetKonst(c);
+  PrimType primType = c->GetType().GetPrimType();
+  st->SetTyIdx(TyIdx(primType));
+  uint32 typeBitSize = GetPrimTypeBitSize(primType);
+
+  if (cgFunc->GetMirModule().IsCModule() && (T::GetPrimType() == PTY_f32 || T::GetPrimType() == PTY_f64)) {
+    return static_cast<Operand *>(&cgFunc->GetOrCreateMemOpnd(*st, 0, typeBitSize));
+  }
+  if (T::GetPrimType() == PTY_f32) {
+    return (fabs(c->GetValue()) < std::numeric_limits<float>::denorm_min()) ?
+        static_cast<Operand*>(&cgFunc->CreateImmOperand(
+            Operand::kOpdFPImmediate, 0, static_cast<uint8>(typeBitSize), false)) :
+        static_cast<Operand*>(&cgFunc->GetOrCreateMemOpnd(*st, 0, typeBitSize));
+  } else if (T::GetPrimType() == PTY_f64) {
+    return (fabs(c->GetValue()) < std::numeric_limits<double>::denorm_min()) ?
+        static_cast<Operand*>(&cgFunc->CreateImmOperand(
+        Operand::kOpdFPImmediate, 0, static_cast<uint8>(typeBitSize), false)) :
+        static_cast<Operand*>(&cgFunc->GetOrCreateMemOpnd(*st, 0, typeBitSize));
+  } else {
+    CHECK_FATAL(false, "Unsupported const type");
+  }
+  return nullptr;
+}
+
+Operand *AArch64CGFunc::HandleFmovImm(PrimType stype, int64 val, MIRConst &mirConst, const BaseNode &parent) {
+  Operand *result;
+  bool is64Bits = (GetPrimTypeBitSize(stype) == k64BitSize);
+  uint64 canRepreset = is64Bits ? (val & 0xffffffffffff) : (val & 0x7ffff);
+  uint32 val1 = is64Bits ? (val >> 61) & 0x3 : (val >> 29) & 0x3;
+  uint32 val2 = is64Bits ? (val >> 54) & 0xff : (val >> 25) & 0x1f;
+  bool isSame = is64Bits ? ((val2 == 0) || (val2 == 0xff)) : ((val2 == 0) || (val2 == 0x1f));
+  canRepreset = (canRepreset == 0) && ((val1 & 0x1) ^ ((val1 & 0x2) >> 1)) && isSame;
+  if (canRepreset > 0) {
+    uint64 temp1 = is64Bits ? (val >> 63) << 7 : (val >> 31) << 7;
+    uint64 temp2 = is64Bits ? val >> 48 : val >> 19;
+    int64 imm8 = (temp2 & 0x7f) | temp1;
+    Operand *newOpnd0 = &CreateImmOperand(imm8, k8BitSize, true, kNotVary, true);
+    result = &GetOrCreateResOperand(parent, stype);
+    MOperator mopFmov = (is64Bits ? MOP_xdfmovri : MOP_wsfmovri);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopFmov, *result, *newOpnd0));
+  } else {
+    if (is64Bits) { // For DoubleConst, use ldr .literal
+      uint32 labelIdxTmp = GetLabelIdx();
+      result = SelectLiteral(static_cast<MIRDoubleConst*>(&mirConst), &GetFunction(), labelIdxTmp++, this);
+      SetLabelIdx(labelIdxTmp);
+      return result;
+    }
+    Operand *newOpnd0 = &CreateImmOperand(val, GetPrimTypeSize(stype) * kBitsPerByte, false);
+    PrimType itype = (stype == PTY_f32) ? PTY_i32 : PTY_i64;
+    RegOperand &regOpnd = LoadIntoRegister(*newOpnd0, itype);
+
+    result = &GetOrCreateResOperand(parent, stype);
+    MOperator mopFmov = (is64Bits ? MOP_xvmovdr : MOP_xvmovsr);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopFmov, *result, regOpnd));
+  }
+  return result;
+}
+
+Operand *AArch64CGFunc::SelectFloatConst(MIRFloatConst &floatConst, const BaseNode &parent) {
+  /* according to aarch64 encoding format, convert int to float expression */
+  return HandleFmovImm(floatConst.GetType().GetPrimType(), floatConst.GetIntValue(), floatConst, parent);
+}
+
+Operand *AArch64CGFunc::SelectDoubleConst(MIRDoubleConst &doubleConst, const BaseNode &parent) {
+  /* according to aarch64 encoding format, convert int to float expression */
+  return HandleFmovImm(doubleConst.GetType().GetPrimType(), doubleConst.GetIntValue(), doubleConst, parent);
+}
+
+template <typename T>
+Operand *SelectStrLiteral(T &c, AArch64CGFunc &cgFunc) {
+  std::string labelStr;
+  if (c.GetKind() == kConstStrConst) {
+    labelStr.append(".LUstr_");
+  } else if (c.GetKind() == kConstStr16Const) {
+    labelStr.append(".LUstr16_");
+  } else {
+    CHECK_FATAL(false, "Unsupported literal type");
+  }
+  labelStr.append(std::to_string(c.GetValue()));
+
+  MIRSymbol *labelSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetStrIdxFromName(labelStr));
+  if (labelSym == nullptr) {
+    labelSym = cgFunc.GetMirModule().GetMIRBuilder()->CreateGlobalDecl(labelStr, c.GetType());
+    labelSym->SetStorageClass(kScFstatic);
+    labelSym->SetSKind(kStConst);
+    /* c may be local, we need a global node here */
+    labelSym->SetKonst(cgFunc.NewMirConst(c));
+  }
+
+  if (c.GetPrimType() == PTY_ptr) {
+    StImmOperand &stOpnd = cgFunc.CreateStImmOperand(*labelSym, 0, 0);
+    RegOperand &addrOpnd = cgFunc.CreateRegisterOperandOfType(PTY_a64);
+    cgFunc.SelectAddrof(addrOpnd, stOpnd);
+    return &addrOpnd;
+  }
+  CHECK_FATAL(false, "Unsupported const string type");
+  return nullptr;
+}
+
+Operand *AArch64CGFunc::SelectStrConst(MIRStrConst &strConst) {
+  return SelectStrLiteral(strConst, *this);
+}
+
+Operand *AArch64CGFunc::SelectStr16Const(MIRStr16Const &str16Const) {
+  return SelectStrLiteral(str16Const, *this);
+}
+
+static inline void AppendInstructionTo(Insn &i, CGFunc &f) {
+  f.GetCurBB()->AppendInsn(i);
+}
+
+/*
+ * Returns the number of leading 0-bits in x, starting at the most significant bit position.
+ * If x is 0, the result is -1.
+ */
+static int32 GetHead0BitNum(int64 val) {
+  uint32 bitNum = 0;
+  for (; bitNum < k64BitSize; bitNum++) {
+    if ((0x8000000000000000ULL >> static_cast<uint32>(bitNum)) & static_cast<uint64>(val)) {
+      break;
+    }
+  }
+  if (bitNum == k64BitSize) {
+    return -1;
+  }
+  return bitNum;
+}
+
+/*
+ * Returns the number of trailing 0-bits in x, starting at the least significant bit position.
+ * If x is 0, the result is -1.
+ */
+static int32 GetTail0BitNum(int64 val) {
+  uint32 bitNum = 0;
+  for (; bitNum < k64BitSize; bitNum++) {
+    if ((static_cast<uint64>(1) << static_cast<uint32>(bitNum)) & static_cast<uint64>(val)) {
+      break;
+    }
+  }
+  if (bitNum == k64BitSize) {
+    return -1;
+  }
+  return bitNum;
+}
+
+/*
+ * If the input integer is power of 2, return log2(input)
+ * else return -1
+ */
+static inline int32 GetLog2(uint64 val) {
+  if (__builtin_popcountll(val) == 1) {
+    return __builtin_ffsll(static_cast<int64>(val)) - 1;
+  }
+  return -1;
+}
+
+MOperator AArch64CGFunc::PickJmpInsn(Opcode brOp, Opcode cmpOp, bool isFloat, bool isSigned) const {
+  switch (cmpOp) {
+    case OP_ne:
+      return (brOp == OP_brtrue) ? MOP_bne : MOP_beq;
+    case OP_eq:
+      return (brOp == OP_brtrue) ? MOP_beq : MOP_bne;
+    case OP_lt:
+      return (brOp == OP_brtrue) ? (isSigned ? MOP_blt : MOP_blo)
+                                 : (isFloat ? MOP_bpl : (isSigned ? MOP_bge : MOP_bhs));
+    case OP_le:
+      return (brOp == OP_brtrue) ? (isSigned ? MOP_ble : MOP_bls)
+                                 : (isFloat ? MOP_bhi : (isSigned ? MOP_bgt : MOP_bhi));
+    case OP_gt:
+      return (brOp == OP_brtrue) ? (isFloat ? MOP_bgt : (isSigned ? MOP_bgt : MOP_bhi))
+                                 : (isSigned ? MOP_ble : MOP_bls);
+    case OP_ge:
+      return (brOp == OP_brtrue) ? (isFloat ? MOP_bpl : (isSigned ? MOP_bge : MOP_bhs))
+                                 : (isSigned ? MOP_blt : MOP_blo);
+    default:
+      CHECK_FATAL(false, "PickJmpInsn error");
+  }
+}
+
+bool AArch64CGFunc::GenerateCompareWithZeroInstruction(Opcode jmpOp, Opcode cmpOp, bool is64Bits,
+                                                       PrimType primType,
+                                                       LabelOperand &targetOpnd, Operand &opnd0) {
+  bool finish = true;
+  MOperator mOpCode = MOP_undef;
+  switch (cmpOp) {
+    case OP_ne: {
+      if (jmpOp == OP_brtrue) {
+        mOpCode = is64Bits ? MOP_xcbnz : MOP_wcbnz;
+      } else {
+        mOpCode = is64Bits ? MOP_xcbz : MOP_wcbz;
+      }
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, opnd0, targetOpnd));
+      break;
+    }
+    case OP_eq: {
+      if (jmpOp == OP_brtrue) {
+        mOpCode = is64Bits ? MOP_xcbz : MOP_wcbz;
+      } else {
+        mOpCode = is64Bits ? MOP_xcbnz : MOP_wcbnz;
+      }
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, opnd0, targetOpnd));
+      break;
+    }
+    /*
+     * TBZ/TBNZ instruction have a range of +/-32KB, need to check if the jump target is reachable in a later
+     * phase. If the branch target is not reachable, then we change tbz/tbnz into combination of ubfx and
+     * cbz/cbnz, which will clobber one extra register. With LSRA under O2, we can use of the reserved registers
+     * for that purpose.
+     */
+    case OP_lt: {
+      if (primType == PTY_u64 || primType == PTY_u32) {
+        return false;
+      }
+      ImmOperand &signBit = CreateImmOperand(is64Bits ? kHighestBitOf64Bits : kHighestBitOf32Bits, k8BitSize, false);
+      if (jmpOp == OP_brtrue) {
+        mOpCode = is64Bits ? MOP_xtbnz : MOP_wtbnz;
+      } else {
+        mOpCode = is64Bits ? MOP_xtbz : MOP_wtbz;
+      }
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, opnd0, signBit, targetOpnd));
+      break;
+    }
+    case OP_ge: {
+      if (primType == PTY_u64 || primType == PTY_u32) {
+        return false;
+      }
+      ImmOperand &signBit = CreateImmOperand(is64Bits ? kHighestBitOf64Bits : kHighestBitOf32Bits, k8BitSize, false);
+      if (jmpOp == OP_brtrue) {
+        mOpCode = is64Bits ? MOP_xtbz : MOP_wtbz;
+      } else {
+        mOpCode = is64Bits ? MOP_xtbnz : MOP_wtbnz;
+      }
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, opnd0, signBit, targetOpnd));
+      break;
+    }
+    default:
+      finish = false;
+      break;
+  }
+  return finish;
+}
+
+void AArch64CGFunc::SelectIgoto(Operand *opnd0) {
+  Operand *srcOpnd = opnd0;
+  if (opnd0->GetKind() == Operand::kOpdMem) {
+    Operand *dst = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xldr, *dst, *opnd0));
+    srcOpnd = dst;
+  }
+  GetCurBB()->SetKind(BB::kBBIgoto);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xbr, *srcOpnd));
+}
+
+void AArch64CGFunc::SelectCondGoto(LabelOperand &targetOpnd, Opcode jmpOp, Opcode cmpOp, Operand &origOpnd0,
+                                   Operand &origOpnd1, PrimType primType, bool signedCond) {
+  Operand *opnd0 = &origOpnd0;
+  Operand *opnd1 = &origOpnd1;
+  opnd0 = &LoadIntoRegister(origOpnd0, primType);
+
+  bool is64Bits = GetPrimTypeBitSize(primType) == k64BitSize;
+  bool isFloat = IsPrimitiveFloat(primType);
+  Operand &rflag = GetOrCreateRflag();
+  if (isFloat) {
+    opnd1 = &LoadIntoRegister(origOpnd1, primType);
+    MOperator mOp = is64Bits ? MOP_dcmperr : ((GetPrimTypeBitSize(primType) == k32BitSize) ? MOP_scmperr : MOP_hcmperr);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, rflag, *opnd0, *opnd1));
+  } else {
+    bool isImm = ((origOpnd1.GetKind() == Operand::kOpdImmediate) || (origOpnd1.GetKind() == Operand::kOpdOffset));
+    if ((origOpnd1.GetKind() != Operand::kOpdRegister) && !isImm) {
+      opnd1 = &SelectCopy(origOpnd1, primType, primType);
+    }
+    MOperator mOp = is64Bits ? MOP_xcmprr : MOP_wcmprr;
+
+    if (isImm) {
+      /* Special cases, i.e., comparing with zero
+       * Do not perform optimization for C, unlike Java which has no unsigned int.
+       */
+      if (static_cast<ImmOperand*>(opnd1)->IsZero() &&
+          (Globals::GetInstance()->GetOptimLevel() > CGOptions::kLevel0)) {
+        bool finish = GenerateCompareWithZeroInstruction(jmpOp, cmpOp, is64Bits, primType, targetOpnd, *opnd0);
+        if (finish) {
+          return;
+        }
+      }
+
+      /*
+       * aarch64 assembly takes up to 24-bits immediate, generating
+       * either cmp or cmp with shift 12 encoding
+       */
+      ImmOperand *immOpnd = static_cast<ImmOperand*>(opnd1);
+      if (immOpnd->IsInBitSize(kMaxImmVal12Bits, 0) ||
+          immOpnd->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits)) {
+        mOp = is64Bits ? MOP_xcmpri : MOP_wcmpri;
+      } else {
+        opnd1 = &SelectCopy(*opnd1, primType, primType);
+      }
+    }
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, rflag, *opnd0, *opnd1));
+  }
+
+  bool isSigned = IsPrimitiveInteger(primType) ? IsSignedInteger(primType) : (signedCond ? true : false);
+  MOperator jmpOperator = PickJmpInsn(jmpOp, cmpOp, isFloat, isSigned);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(jmpOperator, rflag, targetOpnd));
+}
+
+/*
+ *   brtrue @label0 (ge u8 i32 (
+ *   cmp i32 i64 (dread i64 %Reg2_J, dread i64 %Reg4_J),
+ *   constval i32 0))
+ *  ===>
+ *   cmp r1, r2
+ *   bge Cond, label0
+ */
+void AArch64CGFunc::SelectCondSpecialCase1(CondGotoNode &stmt, BaseNode &expr) {
+  ASSERT(expr.GetOpCode() == OP_cmp, "unexpect opcode");
+  Operand *opnd0 = HandleExpr(expr, *expr.Opnd(0));
+  Operand *opnd1 = HandleExpr(expr, *expr.Opnd(1));
+  CompareNode *node = static_cast<CompareNode*>(&expr);
+  bool isFloat = IsPrimitiveFloat(node->GetOpndType());
+  opnd0 = &LoadIntoRegister(*opnd0, node->GetOpndType());
+  /*
+   * most of FP constants are passed as MemOperand
+   * except 0.0 which is passed as kOpdFPImmediate
+   */
+  Operand::OperandType opnd1Type = opnd1->GetKind();
+  if ((opnd1Type != Operand::kOpdImmediate) && (opnd1Type != Operand::kOpdFPImmediate) &&
+      (opnd1Type != Operand::kOpdOffset)) {
+    opnd1 = &LoadIntoRegister(*opnd1, node->GetOpndType());
+  }
+  SelectAArch64Cmp(*opnd0, *opnd1, !isFloat, GetPrimTypeBitSize(node->GetOpndType()));
+  /* handle condgoto now. */
+  LabelIdx labelIdx = stmt.GetOffset();
+  BaseNode *condNode = stmt.Opnd(0);
+  LabelOperand &targetOpnd = GetOrCreateLabelOperand(labelIdx);
+  Opcode cmpOp = condNode->GetOpCode();
+  PrimType pType = static_cast<CompareNode*>(condNode)->GetOpndType();
+  isFloat = IsPrimitiveFloat(pType);
+  Operand &rflag = GetOrCreateRflag();
+  bool isSigned = IsPrimitiveInteger(pType) ? IsSignedInteger(pType) :
+                                              (IsSignedInteger(condNode->GetPrimType()) ? true : false);
+  MOperator jmpOp = PickJmpInsn(stmt.GetOpCode(), cmpOp, isFloat, isSigned);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(jmpOp, rflag, targetOpnd));
+}
+
+/*
+ * Special case:
+ * brfalse(ge (cmpg (op0, op1), 0) ==>
+ * fcmp op1, op2
+ * blo
+ */
+void AArch64CGFunc::SelectCondSpecialCase2(const CondGotoNode &stmt, BaseNode &expr) {
+  auto &cmpNode = static_cast<CompareNode&>(expr);
+  Operand *opnd0 = HandleExpr(cmpNode, *cmpNode.Opnd(0));
+  Operand *opnd1 = HandleExpr(cmpNode, *cmpNode.Opnd(1));
+  PrimType operandType = cmpNode.GetOpndType();
+  opnd0 = opnd0->IsRegister() ? static_cast<RegOperand*>(opnd0)
+                              : &SelectCopy(*opnd0, operandType, operandType);
+  Operand::OperandType opnd1Type = opnd1->GetKind();
+  if ((opnd1Type != Operand::kOpdImmediate) && (opnd1Type != Operand::kOpdFPImmediate) &&
+      (opnd1Type != Operand::kOpdOffset)) {
+    opnd1 = opnd1->IsRegister() ? static_cast<RegOperand*>(opnd1)
+                                : &SelectCopy(*opnd1, operandType, operandType);
+  }
+#ifdef DEBUG
+  bool isFloat = IsPrimitiveFloat(operandType);
+  if (!isFloat) {
+    ASSERT(false, "incorrect operand types");
+  }
+#endif
+  SelectTargetFPCmpQuiet(*opnd0, *opnd1, GetPrimTypeBitSize(operandType));
+  Operand &rFlag = GetOrCreateRflag();
+  LabelIdx tempLabelIdx = stmt.GetOffset();
+  LabelOperand &targetOpnd = GetOrCreateLabelOperand(tempLabelIdx);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_blo, rFlag, targetOpnd));
+}
+
+void AArch64CGFunc::SelectCondGoto(CondGotoNode &stmt, Operand &opnd0, Operand &opnd1) {
+  /*
+   * handle brfalse/brtrue op, opnd0 can be a compare node or non-compare node
+   * such as a dread for example
+   */
+  LabelIdx labelIdx = stmt.GetOffset();
+  BaseNode *condNode = stmt.Opnd(0);
+  LabelOperand &targetOpnd = GetOrCreateLabelOperand(labelIdx);
+  Opcode cmpOp;
+
+  if (opnd0.IsRegister() && (static_cast<RegOperand*>(&opnd0)->GetValidBitsNum() == 1) &&
+      (condNode->GetOpCode() == OP_lior)) {
+    ImmOperand &condBit = CreateImmOperand(0, k8BitSize, false);
+    if (stmt.GetOpCode() == OP_brtrue) {
+      GetCurBB()->AppendInsn(
+          GetInsnBuilder()->BuildInsn(MOP_wtbnz, static_cast<RegOperand&>(opnd0), condBit, targetOpnd));
+    } else {
+      GetCurBB()->AppendInsn(
+          GetInsnBuilder()->BuildInsn(MOP_wtbz, static_cast<RegOperand&>(opnd0), condBit, targetOpnd));
+    }
+    return;
+  }
+
+  PrimType pType;
+  if (kOpcodeInfo.IsCompare(condNode->GetOpCode())) {
+    cmpOp = condNode->GetOpCode();
+    pType = static_cast<CompareNode*>(condNode)->GetOpndType();
+  } else {
+    /* not a compare node; dread for example, take its pType */
+    cmpOp = OP_ne;
+    pType = condNode->GetPrimType();
+  }
+  bool signedCond = IsSignedInteger(pType) || IsPrimitiveFloat(pType);
+  SelectCondGoto(targetOpnd, stmt.GetOpCode(), cmpOp, opnd0, opnd1, pType, signedCond);
+}
+
+void AArch64CGFunc::SelectGoto(GotoNode &stmt) {
+  Operand &targetOpnd = GetOrCreateLabelOperand(stmt.GetOffset());
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xuncond, targetOpnd));
+  GetCurBB()->SetKind(BB::kBBGoto);
+}
+
+Operand *AArch64CGFunc::SelectAdd(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool isSigned = IsSignedInteger(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  bool is64Bits = (dsize == k64BitSize);
+  bool isFloat = IsPrimitiveFloat(dtype);
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(dtype)) {
+    /* promoted type */
+    PrimType primType =
+        isFloat ? dtype : ((is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32)));
+    if (parent.GetOpCode() == OP_regassign) {
+      auto &regAssignNode = static_cast<const RegassignNode&>(parent);
+      PregIdx pregIdx = regAssignNode.GetRegIdx();
+      if (IsSpecialPseudoRegister(pregIdx)) {
+        resOpnd = &GetOrCreateSpecialRegisterOperand(-pregIdx, dtype);
+      } else {
+        resOpnd = &GetOrCreateVirtualRegisterOperand(GetVirtualRegNOFromPseudoRegIdx(pregIdx));
+      }
+    } else {
+      resOpnd = &CreateRegisterOperandOfType(primType);
+    }
+    SelectAdd(*resOpnd, opnd0, opnd1, primType);
+  } else {
+    /* vector operands */
+    resOpnd = SelectVectorBinOp(dtype, &opnd0, node.Opnd(0)->GetPrimType(), &opnd1,
+                                node.Opnd(1)->GetPrimType(), OP_add);
+  }
+  return resOpnd;
+}
+
+void AArch64CGFunc::SelectAdd(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  Operand::OperandType opnd0Type = opnd0.GetKind();
+  Operand::OperandType opnd1Type = opnd1.GetKind();
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+  if (opnd0Type != Operand::kOpdRegister) {
+    /* add #imm, #imm */
+    if (opnd1Type != Operand::kOpdRegister) {
+      SelectAdd(resOpnd, SelectCopy(opnd0, primType, primType), opnd1, primType);
+      return;
+    }
+    /* add #imm, reg */
+    SelectAdd(resOpnd, opnd1, opnd0, primType);  /* commutative */
+    return;
+  }
+  /* add reg, reg */
+  if (opnd1Type == Operand::kOpdRegister) {
+    ASSERT(IsPrimitiveFloat(primType) || IsPrimitiveInteger(primType), "NYI add");
+    MOperator mOp = IsPrimitiveFloat(primType) ?
+        (is64Bits ? MOP_dadd : MOP_sadd) : (is64Bits ? MOP_xaddrrr : MOP_waddrrr);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0, opnd1));
+    return;
+  } else if (opnd1Type == Operand::kOpdStImmediate) {
+    CHECK_FATAL(is64Bits, "baseReg of mem in aarch64 must be 64bit size");
+    /* add reg, reg, #:lo12:sym+offset */
+    StImmOperand &stImmOpnd = static_cast<StImmOperand&>(opnd1);
+    Insn &newInsn = GetInsnBuilder()->BuildInsn(MOP_xadrpl12, resOpnd, opnd0, stImmOpnd);
+    GetCurBB()->AppendInsn(newInsn);
+    return;
+  } else if (!((opnd1Type == Operand::kOpdImmediate) || (opnd1Type == Operand::kOpdOffset))) {
+    /* add reg, otheregType */
+    SelectAdd(resOpnd, opnd0, SelectCopy(opnd1, primType, primType), primType);
+    return;
+  } else {
+    /* add reg, #imm */
+    ImmOperand *immOpnd = static_cast<ImmOperand*>(&opnd1);
+    if (immOpnd->IsNegative()) {
+      immOpnd->Negate();
+      SelectSub(resOpnd, opnd0, *immOpnd, primType);
+      return;
+    }
+    if (immOpnd->IsInBitSize(kMaxImmVal24Bits, 0)) {
+      /*
+       * ADD Wd|WSP, Wn|WSP, #imm{, shift} ; 32-bit general registers
+       * ADD Xd|SP,  Xn|SP,  #imm{, shift} ; 64-bit general registers
+       * imm : 0 ~ 4095, shift: none, LSL #0, or LSL #12
+       * aarch64 assembly takes up to 24-bits, if the lower 12 bits is all 0
+       */
+      MOperator mOpCode = MOP_undef;
+      Operand *newOpnd0 = &opnd0;
+      if (!(immOpnd->IsInBitSize(kMaxImmVal12Bits, 0) ||
+            immOpnd->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits))) {
+        /* process higher 12 bits */
+        ImmOperand &immOpnd2 =
+            CreateImmOperand(static_cast<int64>(static_cast<uint64>(immOpnd->GetValue()) >> kMaxImmVal12Bits),
+                             immOpnd->GetSize(), immOpnd->IsSignedValue());
+        mOpCode = is64Bits ? MOP_xaddrri24 : MOP_waddrri24;
+        Operand *tmpRes = IsAfterRegAlloc() ? &resOpnd : &CreateRegisterOperandOfType(primType);
+        BitShiftOperand &shiftopnd = CreateBitShiftOperand(BitShiftOperand::kLSL, kShiftAmount12, k64BitSize);
+        Insn &newInsn = GetInsnBuilder()->BuildInsn(mOpCode, *tmpRes, opnd0, immOpnd2, shiftopnd);
+        GetCurBB()->AppendInsn(newInsn);
+        immOpnd->ModuloByPow2(kMaxImmVal12Bits);
+        newOpnd0 = tmpRes;
+      }
+      /* process lower 12  bits */
+      mOpCode = is64Bits ? MOP_xaddrri12 : MOP_waddrri12;
+      Insn &newInsn = GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, *newOpnd0, *immOpnd);
+      GetCurBB()->AppendInsn(newInsn);
+      return;
+    }
+    /* load into register */
+    int64 immVal = immOpnd->GetValue();
+    int32 tail0bitNum = GetTail0BitNum(immVal);
+    int32 head0bitNum = GetHead0BitNum(immVal);
+    const int32 bitNum = (k64BitSizeInt - head0bitNum) - tail0bitNum;
+    RegOperand &regOpnd = CreateRegisterOperandOfType(primType);
+    if (isAfterRegAlloc) {
+      RegType regty = GetRegTyFromPrimTy(primType);
+      uint32 bytelen = GetPrimTypeSize(primType);
+      regOpnd = GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(R16), bytelen, regty);
+    }
+    regno_t regNO0 = static_cast<RegOperand&>(opnd0).GetRegisterNumber();
+    /* addrrrs do not support sp */
+    if (bitNum <= k16ValidBit && regNO0 != RSP) {
+      int64 newImm = (static_cast<uint64>(immVal) >> static_cast<uint32>(tail0bitNum)) & 0xFFFF;
+      ImmOperand &immOpnd1 = CreateImmOperand(newImm, k16BitSize, false);
+      SelectCopyImm(regOpnd, immOpnd1, primType);
+      uint32 mopBadd = is64Bits ? MOP_xaddrrrs : MOP_waddrrrs;
+      int32 bitLen = is64Bits ? kBitLenOfShift64Bits : kBitLenOfShift32Bits;
+      BitShiftOperand &bitShiftOpnd =
+          CreateBitShiftOperand(BitShiftOperand::kLSL, static_cast<uint32>(tail0bitNum), bitLen);
+      Insn &newInsn = GetInsnBuilder()->BuildInsn(mopBadd, resOpnd, opnd0, regOpnd, bitShiftOpnd);
+      GetCurBB()->AppendInsn(newInsn);
+      return;
+    }
+
+    SelectCopyImm(regOpnd, *immOpnd, primType);
+    MOperator mOpCode = is64Bits ? MOP_xaddrrr : MOP_waddrrr;
+    Insn &newInsn = GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, opnd0, regOpnd);
+    GetCurBB()->AppendInsn(newInsn);
+  }
+}
+
+Operand *AArch64CGFunc::SelectMadd(BinaryNode &node, Operand &opndM0, Operand &opndM1, Operand &opnd1,
+                                   const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool isSigned = IsSignedInteger(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  bool is64Bits = (dsize == k64BitSize);
+  /* promoted type */
+  PrimType primType = is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32);
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, primType);
+  SelectMadd(resOpnd, opndM0, opndM1, opnd1, primType);
+  return &resOpnd;
+}
+
+void AArch64CGFunc::SelectMadd(Operand &resOpnd, Operand &opndM0, Operand &opndM1, Operand &opnd1, PrimType primType) {
+  Operand::OperandType opndM0Type = opndM0.GetKind();
+  Operand::OperandType opndM1Type = opndM1.GetKind();
+  Operand::OperandType opnd1Type = opnd1.GetKind();
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+
+  if (opndM0Type != Operand::kOpdRegister) {
+    SelectMadd(resOpnd, SelectCopy(opndM0, primType, primType), opndM1, opnd1, primType);
+    return;
+  } else if (opndM1Type != Operand::kOpdRegister) {
+    SelectMadd(resOpnd, opndM0, SelectCopy(opndM1, primType, primType), opnd1, primType);
+    return;
+  } else if (opnd1Type != Operand::kOpdRegister) {
+    SelectMadd(resOpnd, opndM0, opndM1, SelectCopy(opnd1, primType, primType), primType);
+    return;
+  }
+
+  ASSERT(IsPrimitiveInteger(primType), "NYI MAdd");
+  MOperator mOp = is64Bits ? MOP_xmaddrrrr : MOP_wmaddrrrr;
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opndM0, opndM1, opnd1));
+}
+
+Operand &AArch64CGFunc::SelectCGArrayElemAdd(BinaryNode &node, const BaseNode &parent) {
+  BaseNode *opnd0 = node.Opnd(0);
+  BaseNode *opnd1 = node.Opnd(1);
+  ASSERT(opnd1->GetOpCode() == OP_constval, "Internal error, opnd1->op should be OP_constval.");
+
+  switch (opnd0->op) {
+    case OP_regread: {
+      RegreadNode *regreadNode = static_cast<RegreadNode *>(opnd0);
+      return *SelectRegread(*regreadNode);
+    }
+    case OP_addrof: {
+      AddrofNode *addrofNode = static_cast<AddrofNode *>(opnd0);
+      MIRSymbol &symbol = *mirModule.CurFunction()->GetLocalOrGlobalSymbol(addrofNode->GetStIdx());
+      ASSERT(addrofNode->GetFieldID() == 0, "For debug SelectCGArrayElemAdd.");
+
+      Operand &result = GetOrCreateResOperand(parent, PTY_a64);
+
+      /* OP_constval */
+      ConstvalNode *constvalNode = static_cast<ConstvalNode *>(opnd1);
+      MIRConst *mirConst = constvalNode->GetConstVal();
+      MIRIntConst *mirIntConst = static_cast<MIRIntConst *>(mirConst);
+      SelectAddrof(result, CreateStImmOperand(symbol, mirIntConst->GetExtValue(), 0));
+
+      return result;
+    }
+    default:
+      CHECK_FATAL(false, "Internal error, cannot handle opnd0.");
+  }
+}
+
+void AArch64CGFunc::SelectSub(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  Operand::OperandType opnd1Type = opnd1.GetKind();
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+  bool isFloat = IsPrimitiveFloat(primType);
+  Operand *opnd0Bak = &LoadIntoRegister(opnd0, primType);
+  if (opnd1Type == Operand::kOpdRegister) {
+    MOperator mOp = isFloat ? (is64Bits ? MOP_dsub : MOP_ssub) : (is64Bits ? MOP_xsubrrr : MOP_wsubrrr);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, *opnd0Bak, opnd1));
+    return;
+  }
+
+  if ((opnd1Type != Operand::kOpdImmediate) && (opnd1Type != Operand::kOpdOffset)) {
+    SelectSub(resOpnd, *opnd0Bak, SelectCopy(opnd1, primType, primType), primType);
+    return;
+  }
+
+  ImmOperand *immOpnd = static_cast<ImmOperand*>(&opnd1);
+  if (immOpnd->IsNegative()) {
+    immOpnd->Negate();
+    SelectAdd(resOpnd, *opnd0Bak, *immOpnd, primType);
+    return;
+  }
+
+  int64 higher12BitVal = static_cast<int64>(static_cast<uint64>(immOpnd->GetValue()) >> kMaxImmVal12Bits);
+  if (immOpnd->IsInBitSize(kMaxImmVal24Bits, 0) && higher12BitVal + 1 <= kMaxPimm8) {
+    /*
+     * SUB Wd|WSP, Wn|WSP, #imm{, shift} ; 32-bit general registers
+     * SUB Xd|SP,  Xn|SP,  #imm{, shift} ; 64-bit general registers
+     * imm : 0 ~ 4095, shift: none, LSL #0, or LSL #12
+     * aarch64 assembly takes up to 24-bits, if the lower 12 bits is all 0
+     * large offset is treated as sub (higher 12 bits + 4096) + add
+     * it gives opportunities for combining add + ldr due to the characteristics of aarch64's load/store
+     */
+    MOperator mOpCode = MOP_undef;
+    bool isSplitSub = false;
+    if (!(immOpnd->IsInBitSize(kMaxImmVal12Bits, 0) ||
+          immOpnd->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits))) {
+      isSplitSub = true;
+      /* process higher 12 bits */
+      ImmOperand &immOpnd2 =
+          CreateImmOperand(higher12BitVal + 1, immOpnd->GetSize(), immOpnd->IsSignedValue());
+
+      mOpCode = is64Bits ? MOP_xsubrri24 : MOP_wsubrri24;
+      BitShiftOperand &shiftopnd = CreateBitShiftOperand(BitShiftOperand::kLSL, kShiftAmount12, k64BitSize);
+      Insn &newInsn = GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, *opnd0Bak, immOpnd2, shiftopnd);
+      GetCurBB()->AppendInsn(newInsn);
+      immOpnd->ModuloByPow2(kMaxImmVal12Bits);
+      immOpnd->SetValue(static_cast<int64>(kMax12UnsignedImm) - immOpnd->GetValue());
+      opnd0Bak = &resOpnd;
+    }
+    /* process lower 12 bits */
+    mOpCode = isSplitSub ? (is64Bits ? MOP_xaddrri12 : MOP_waddrri12) : (is64Bits ? MOP_xsubrri12 : MOP_wsubrri12);
+    Insn &newInsn = GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, *opnd0Bak, *immOpnd);
+    GetCurBB()->AppendInsn(newInsn);
+    return;
+  }
+
+  /* load into register */
+  int64 immVal = immOpnd->GetValue();
+  int32 tail0bitNum = GetTail0BitNum(immVal);
+  int32 head0bitNum = GetHead0BitNum(immVal);
+  const int32 bitNum = (k64BitSizeInt - head0bitNum) - tail0bitNum;
+  RegOperand &regOpnd = CreateRegisterOperandOfType(primType);
+  if (isAfterRegAlloc) {
+    RegType regty = GetRegTyFromPrimTy(primType);
+    uint32 bytelen = GetPrimTypeSize(primType);
+    regOpnd = GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(R16), bytelen, regty);
+  }
+
+  if (bitNum <= k16ValidBit) {
+    int64 newImm = (static_cast<uint64>(immVal) >> static_cast<uint32>(tail0bitNum)) & 0xFFFF;
+    ImmOperand &immOpnd1 = CreateImmOperand(newImm, k16BitSize, false);
+    SelectCopyImm(regOpnd, immOpnd1, primType);
+    uint32 mopBsub = is64Bits ? MOP_xsubrrrs : MOP_wsubrrrs;
+    int32 bitLen = is64Bits ? kBitLenOfShift64Bits : kBitLenOfShift32Bits;
+    BitShiftOperand &bitShiftOpnd =
+        CreateBitShiftOperand(BitShiftOperand::kLSL, static_cast<uint32>(tail0bitNum), bitLen);
+    GetCurBB()->AppendInsn(
+        GetInsnBuilder()->BuildInsn(mopBsub, resOpnd, *opnd0Bak, regOpnd, bitShiftOpnd));
+    return;
+  }
+
+  SelectCopyImm(regOpnd, *immOpnd, primType);
+  MOperator mOpCode = is64Bits ? MOP_xsubrrr : MOP_wsubrrr;
+  Insn &newInsn = GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, *opnd0Bak, regOpnd);
+  GetCurBB()->AppendInsn(newInsn);
+}
+
+Operand *AArch64CGFunc::SelectSub(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool isSigned = IsSignedInteger(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  bool is64Bits = (dsize == k64BitSize);
+  bool isFloat = IsPrimitiveFloat(dtype);
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(dtype)) {
+    /* promoted type */
+    PrimType primType =
+        isFloat ? dtype : ((is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32)));
+    resOpnd = &GetOrCreateResOperand(parent, primType);
+    SelectSub(*resOpnd, opnd0, opnd1, primType);
+  } else {
+    /* vector operands */
+    resOpnd = SelectVectorBinOp(dtype, &opnd0, node.Opnd(0)->GetPrimType(), &opnd1,
+                                node.Opnd(1)->GetPrimType(), OP_sub);
+  }
+  return resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectMpy(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool isSigned = IsSignedInteger(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  bool is64Bits = (dsize == k64BitSize);
+  bool isFloat = IsPrimitiveFloat(dtype);
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(dtype)) {
+    /* promoted type */
+    PrimType primType =
+        isFloat ? dtype : ((is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32)));
+    resOpnd = &GetOrCreateResOperand(parent, primType);
+    SelectMpy(*resOpnd, opnd0, opnd1, primType);
+  } else {
+    resOpnd = SelectVectorBinOp(dtype, &opnd0, node.Opnd(0)->GetPrimType(), &opnd1,
+                                node.Opnd(1)->GetPrimType(), OP_mul);
+  }
+  return resOpnd;
+}
+
+void AArch64CGFunc::SelectMpy(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  Operand::OperandType opnd0Type = opnd0.GetKind();
+  Operand::OperandType opnd1Type = opnd1.GetKind();
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+
+  if (((opnd0Type == Operand::kOpdImmediate) || (opnd0Type == Operand::kOpdOffset) ||
+       (opnd1Type == Operand::kOpdImmediate) || (opnd1Type == Operand::kOpdOffset)) &&
+      IsPrimitiveInteger(primType)) {
+    ImmOperand *imm =
+        ((opnd0Type == Operand::kOpdImmediate) || (opnd0Type == Operand::kOpdOffset)) ? static_cast<ImmOperand*>(&opnd0)
+                                                                                  : static_cast<ImmOperand*>(&opnd1);
+    Operand *otherOp = ((opnd0Type == Operand::kOpdImmediate) || (opnd0Type == Operand::kOpdOffset)) ? &opnd1 : &opnd0;
+    int64 immValue = llabs(imm->GetValue());
+    if (immValue != 0 && (static_cast<uint64>(immValue) & (static_cast<uint64>(immValue) - 1)) == 0) {
+      /* immValue is 1 << n */
+      if (otherOp->GetKind() != Operand::kOpdRegister) {
+        otherOp = &SelectCopy(*otherOp, primType, primType);
+      }
+      int64 shiftVal = __builtin_ffsll(immValue);
+      ImmOperand &shiftNum = CreateImmOperand(shiftVal - 1, dsize, false);
+      SelectShift(resOpnd, *otherOp, shiftNum, kShiftLeft, primType);
+      bool reachSignBit = (is64Bits && (shiftVal == k64BitSize)) || (!is64Bits && (shiftVal == k32BitSize));
+      if (imm->GetValue() < 0 && !reachSignBit) {
+        SelectNeg(resOpnd, resOpnd, primType);
+      }
+
+      return;
+    } else if (immValue > 2) {
+      uint32 zeroNum = __builtin_ffsll(immValue) - 1;
+      int64 headVal = static_cast<uint64>(immValue) >> zeroNum;
+      /*
+       * if (headVal - 1) & (headVal - 2) == 0, that is (immVal >> zeroNum) - 1 == 1 << n
+       * otherOp * immVal = (otherOp * (immVal >> zeroNum) * (1 << zeroNum)
+       * = (otherOp * ((immVal >> zeroNum) - 1) + otherOp) * (1 << zeroNum)
+       */
+      if (((static_cast<uint64>(headVal) - 1) & (static_cast<uint64>(headVal) - 2)) == 0) {
+        if (otherOp->GetKind() != Operand::kOpdRegister) {
+          otherOp = &SelectCopy(*otherOp, primType, primType);
+        }
+        ImmOperand &shiftNum1 = CreateImmOperand(__builtin_ffsll(headVal - 1) - 1, dsize, false);
+        RegOperand &tmpOpnd = CreateRegisterOperandOfType(primType);
+        SelectShift(tmpOpnd, *otherOp, shiftNum1, kShiftLeft, primType);
+        SelectAdd(resOpnd, *otherOp, tmpOpnd, primType);
+        ImmOperand &shiftNum2 = CreateImmOperand(zeroNum, dsize, false);
+        SelectShift(resOpnd, resOpnd, shiftNum2, kShiftLeft, primType);
+        if (imm->GetValue() < 0) {
+          SelectNeg(resOpnd, resOpnd, primType);
+        }
+
+        return;
+      }
+    }
+  }
+
+  if ((opnd0Type != Operand::kOpdRegister) && (opnd1Type != Operand::kOpdRegister)) {
+    SelectMpy(resOpnd, SelectCopy(opnd0, primType, primType), opnd1, primType);
+  } else if ((opnd0Type == Operand::kOpdRegister) && (opnd1Type != Operand::kOpdRegister)) {
+    SelectMpy(resOpnd, opnd0, SelectCopy(opnd1, primType, primType), primType);
+  } else if ((opnd0Type != Operand::kOpdRegister) && (opnd1Type == Operand::kOpdRegister)) {
+    SelectMpy(resOpnd, opnd1, opnd0, primType);
+  } else {
+    ASSERT(IsPrimitiveFloat(primType) || IsPrimitiveInteger(primType), "NYI Mpy");
+    MOperator mOp = IsPrimitiveFloat(primType) ? (is64Bits ? MOP_xvmuld : MOP_xvmuls)
+                                               : (is64Bits ? MOP_xmulrrr : MOP_wmulrrr);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0, opnd1));
+  }
+}
+
+void AArch64CGFunc::SelectDiv(Operand &resOpnd, Operand &origOpnd0, Operand &opnd1, PrimType primType) {
+  Operand &opnd0 = LoadIntoRegister(origOpnd0, primType);
+  Operand::OperandType opnd0Type = opnd0.GetKind();
+  Operand::OperandType opnd1Type = opnd1.GetKind();
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+
+  if (Globals::GetInstance()->GetOptimLevel() > CGOptions::kLevel0) {
+    if (((opnd1Type == Operand::kOpdImmediate) || (opnd1Type == Operand::kOpdOffset)) && IsSignedInteger(primType)) {
+      ImmOperand *imm = static_cast<ImmOperand*>(&opnd1);
+      int64 immValue = llabs(imm->GetValue());
+      if ((immValue != 0) && (static_cast<uint64>(immValue) & (static_cast<uint64>(immValue) - 1)) == 0) {
+        if (immValue == 1) {
+          if (imm->GetValue() > 0) {
+            uint32 mOp = is64Bits ? MOP_xmovrr : MOP_wmovrr;
+            GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0));
+          } else {
+            SelectNeg(resOpnd, opnd0, primType);
+          }
+
+          return;
+        }
+        int32 shiftNumber = __builtin_ffsll(immValue) - 1;
+        ImmOperand &shiftNum = CreateImmOperand(shiftNumber, dsize, false);
+        Operand &tmpOpnd = CreateRegisterOperandOfType(primType);
+        SelectShift(tmpOpnd, opnd0, CreateImmOperand(dsize - 1, dsize, false), kShiftAright, primType);
+        uint32 mopBadd = is64Bits ? MOP_xaddrrrs : MOP_waddrrrs;
+        int32 bitLen = is64Bits ? kBitLenOfShift64Bits : kBitLenOfShift32Bits;
+        BitShiftOperand &shiftOpnd = CreateBitShiftOperand(BitShiftOperand::kLSR,
+            dsize - static_cast<uint32>(shiftNumber), bitLen);
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopBadd, tmpOpnd, opnd0, tmpOpnd, shiftOpnd));
+        SelectShift(resOpnd, tmpOpnd, shiftNum, kShiftAright, primType);
+        if (imm->GetValue() < 0) {
+          SelectNeg(resOpnd, resOpnd, primType);
+        }
+
+        return;
+      }
+    } else if (((opnd1Type == Operand::kOpdImmediate) || (opnd1Type == Operand::kOpdOffset)) &&
+               IsUnsignedInteger(primType)) {
+      ImmOperand *imm = static_cast<ImmOperand*>(&opnd1);
+      if (imm->GetValue() != 0) {
+        if ((imm->GetValue() > 0) &&
+            ((static_cast<uint64>(imm->GetValue()) & (static_cast<uint64>(imm->GetValue()) - 1)) == 0)) {
+          ImmOperand &shiftNum = CreateImmOperand(__builtin_ffsll(imm->GetValue()) - 1, dsize, false);
+          SelectShift(resOpnd, opnd0, shiftNum, kShiftLright, primType);
+
+          return;
+        } else if (imm->GetValue() < 0) {
+          SelectAArch64Cmp(opnd0, *imm, true, dsize);
+          SelectAArch64CSet(resOpnd, GetCondOperand(CC_CS), is64Bits);
+
+          return;
+        }
+      }
+    }
+  }
+
+  if (opnd0Type != Operand::kOpdRegister) {
+    SelectDiv(resOpnd, SelectCopy(opnd0, primType, primType), opnd1, primType);
+  } else if (opnd1Type != Operand::kOpdRegister) {
+    SelectDiv(resOpnd, opnd0, SelectCopy(opnd1, primType, primType), primType);
+  } else {
+    ASSERT(IsPrimitiveFloat(primType) || IsPrimitiveInteger(primType), "NYI Div");
+    MOperator mOp = IsPrimitiveFloat(primType) ? (is64Bits ? MOP_ddivrrr : MOP_sdivrrr)
+                                               : (IsSignedInteger(primType) ? (is64Bits ? MOP_xsdivrrr : MOP_wsdivrrr)
+                                                                            : (is64Bits ? MOP_xudivrrr : MOP_wudivrrr));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0, opnd1));
+  }
+}
+
+Operand *AArch64CGFunc::SelectDiv(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool isSigned = IsSignedInteger(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  bool is64Bits = (dsize == k64BitSize);
+  bool isFloat = IsPrimitiveFloat(dtype);
+  CHECK_FATAL(!IsPrimitiveVector(dtype), "NYI DIV vector operands");
+  /* promoted type */
+  PrimType primType =
+      isFloat ? dtype : ((is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32)));
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, primType);
+  SelectDiv(resOpnd, opnd0, opnd1, primType);
+  return &resOpnd;
+}
+
+void AArch64CGFunc::SelectRem(Operand &resOpnd, Operand &lhsOpnd, Operand &rhsOpnd, PrimType primType, bool isSigned,
+                              bool is64Bits) {
+  Operand &opnd0 = LoadIntoRegister(lhsOpnd, primType);
+  Operand &opnd1 = LoadIntoRegister(rhsOpnd, primType);
+
+  ASSERT(IsPrimitiveInteger(primType), "Wrong type for REM");
+ /*
+  * printf("%d \n", 29 % 7 );
+  * -> 1
+  * printf("%u %d \n", (unsigned)-7, (unsigned)(-7) % 7 );
+  * -> 4294967289 4
+  * printf("%d \n", (-7) % 7 );
+  * -> 0
+  * printf("%d \n", 237 % -7 );
+  * 6->
+  * printf("implicit i->u conversion %d \n", ((unsigned)237) % -7 );
+  * implicit conversion 237
+
+  * http://stackoverflow.com/questions/35351470/obtaining-remainder-using-single-aarch64-instruction
+  * input: x0=dividend, x1=divisor
+  * udiv|sdiv x2, x0, x1
+  * msub x3, x2, x1, x0  -- multply-sub : x3 <- x0 - x2*x1
+  * result: x2=quotient, x3=remainder
+  *
+  * allocate temporary register
+  */
+  RegOperand &temp = CreateRegisterOperandOfType(primType);
+  /*
+   * mov     w1, #2
+   * sdiv    wTemp, w0, w1
+   * msub    wRespond, wTemp, w1, w0
+   * ========>
+   * asr     wTemp, w0, #31
+   * lsr     wTemp, wTemp, #31  (#30 for 4, #29 for 8, ...)
+   * add     wRespond, w0, wTemp
+   * and     wRespond, wRespond, #1   (#3 for 4, #7 for 8, ...)
+   * sub     wRespond, wRespond, w2
+   *
+   * if divde by 2
+   * ========>
+   * lsr     wTemp, w0, #31
+   * add     wRespond, w0, wTemp
+   * and     wRespond, wRespond, #1
+   * sub     wRespond, wRespond, w2
+   *
+   * for unsigned rem op, just use and
+   */
+  if ((Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel2)) {
+    ImmOperand *imm = nullptr;
+    Insn *movImmInsn = GetCurBB()->GetLastInsn();
+    if (movImmInsn &&
+        ((movImmInsn->GetMachineOpcode() == MOP_wmovri32) || (movImmInsn->GetMachineOpcode() == MOP_xmovri64)) &&
+        movImmInsn->GetOperand(0).Equals(opnd1)) {
+      /*
+       * mov w1, #2
+       * rem res, w0, w1
+       */
+      imm = static_cast<ImmOperand*>(&movImmInsn->GetOperand(kInsnSecondOpnd));
+    } else if (opnd1.IsImmediate()) {
+      /*
+       * rem res, w0, #2
+       */
+      imm = static_cast<ImmOperand*>(&opnd1);
+    }
+    /* positive or negative do not have effect on the result */
+    int64 dividor = 0;
+    if (imm && (imm->GetValue() != LONG_MIN)) {
+      dividor = abs(imm->GetValue());
+    }
+    const int64 log2OfDividor = GetLog2(static_cast<uint64>(dividor));
+    if ((dividor != 0) && (log2OfDividor > 0)) {
+      if (is64Bits) {
+        CHECK_FATAL(log2OfDividor < k64BitSize, "imm out of bound");
+        if (isSigned) {
+          ImmOperand &rightShiftValue = CreateImmOperand(k64BitSize - log2OfDividor, k64BitSize, isSigned);
+          if (log2OfDividor != 1) {
+            /* 63->shift ALL , 32 ->32bit register */
+            ImmOperand &rightShiftAll = CreateImmOperand(63, k64BitSize, isSigned);
+            GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xasrrri6, temp, opnd0, rightShiftAll));
+
+            GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xlsrrri6, temp, temp, rightShiftValue));
+          } else {
+            GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xlsrrri6, temp, opnd0, rightShiftValue));
+          }
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrrr, resOpnd, opnd0, temp));
+          ImmOperand &remBits = CreateImmOperand(dividor - 1, k64BitSize, isSigned);
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xandrri13, resOpnd, resOpnd, remBits));
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xsubrrr, resOpnd, resOpnd, temp));
+          return;
+        } else if (imm && imm->GetValue() > 0) {
+          ImmOperand &remBits = CreateImmOperand(dividor - 1, k64BitSize, isSigned);
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xandrri13, resOpnd, opnd0, remBits));
+          return;
+        }
+      } else {
+        CHECK_FATAL(log2OfDividor < k32BitSize, "imm out of bound");
+        if (isSigned) {
+          ImmOperand &rightShiftValue = CreateImmOperand(k32BitSize - log2OfDividor, k32BitSize, isSigned);
+          if (log2OfDividor != 1) {
+            /* 31->shift ALL , 32 ->32bit register */
+            ImmOperand &rightShiftAll = CreateImmOperand(31, k32BitSize, isSigned);
+            GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wasrrri5, temp, opnd0, rightShiftAll));
+
+            GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wlsrrri5, temp, temp, rightShiftValue));
+          } else {
+            GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wlsrrri5, temp, opnd0, rightShiftValue));
+          }
+
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_waddrrr, resOpnd, opnd0, temp));
+          ImmOperand &remBits = CreateImmOperand(dividor - 1, k32BitSize, isSigned);
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wandrri12, resOpnd, resOpnd, remBits));
+
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wsubrrr, resOpnd, resOpnd, temp));
+          return;
+        } else if (imm && imm->GetValue() > 0) {
+          ImmOperand &remBits = CreateImmOperand(dividor - 1, k32BitSize, isSigned);
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wandrri12, resOpnd, opnd0, remBits));
+          return;
+        }
+      }
+    }
+  }
+
+  uint32 mopDiv = is64Bits ? (isSigned ? MOP_xsdivrrr : MOP_xudivrrr) : (isSigned ? MOP_wsdivrrr : MOP_wudivrrr);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopDiv, temp, opnd0, opnd1));
+
+  uint32 mopSub = is64Bits ? MOP_xmsubrrrr : MOP_wmsubrrrr;
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopSub, resOpnd, temp, opnd1, opnd0));
+}
+
+Operand *AArch64CGFunc::SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  ASSERT(IsPrimitiveInteger(dtype), "wrong type for rem");
+  bool isSigned = IsSignedInteger(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  bool is64Bits = (dsize == k64BitSize);
+  CHECK_FATAL(!IsPrimitiveVector(dtype), "NYI DIV vector operands");
+
+  /* promoted type */
+  PrimType primType = ((is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32)));
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, primType);
+  SelectRem(resOpnd, opnd0, opnd1, primType, isSigned, is64Bits);
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectLand(BinaryNode &node, Operand &lhsOpnd, Operand &rhsOpnd, const BaseNode &parent) {
+  PrimType primType = node.GetPrimType();
+  ASSERT(IsPrimitiveInteger(primType), "Land should be integer type");
+  bool is64Bits = (GetPrimTypeBitSize(primType) == k64BitSize);
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, is64Bits ? PTY_u64 : PTY_u32);
+  /*
+   * OP0 band Op1
+   * cmp  OP0, 0     # compare X0 with 0, sets Z bit
+   * ccmp OP1, 0, 4 //==0100b, ne     # if(OP0!=0) cmp Op1 and 0, else NZCV <- 0100 makes OP0==0
+   * cset RES, ne     # if Z==1(i.e., OP0==0||OP1==0) RES<-0, RES<-1
+   */
+  Operand &opnd0 = LoadIntoRegister(lhsOpnd, primType);
+  SelectAArch64Cmp(opnd0, CreateImmOperand(0, primType, false), true, GetPrimTypeBitSize(primType));
+  Operand &opnd1 = LoadIntoRegister(rhsOpnd, primType);
+  SelectAArch64CCmp(opnd1, CreateImmOperand(0, primType, false), CreateImmOperand(4, PTY_u8, false),
+                    GetCondOperand(CC_NE), is64Bits);
+  SelectAArch64CSet(resOpnd, GetCondOperand(CC_NE), is64Bits);
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectLor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent,
+                                  bool parentIsBr) {
+  PrimType primType = node.GetPrimType();
+  ASSERT(IsPrimitiveInteger(primType), "Lior should be integer type");
+  bool is64Bits = (GetPrimTypeBitSize(primType) == k64BitSize);
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, is64Bits ? PTY_u64 : PTY_u32);
+  /*
+   * OP0 band Op1
+   * cmp  OP0, 0     # compare X0 with 0, sets Z bit
+   * ccmp OP1, 0, 0 //==0100b, eq     # if(OP0==0,eq) cmp Op1 and 0, else NZCV <- 0000 makes OP0!=0
+   * cset RES, ne     # if Z==1(i.e., OP0==0&&OP1==0) RES<-0, RES<-1
+   */
+  if (parentIsBr && !is64Bits && opnd0.IsRegister() && (static_cast<RegOperand*>(&opnd0)->GetValidBitsNum() == 1) &&
+      opnd1.IsRegister() && (static_cast<RegOperand*>(&opnd1)->GetValidBitsNum() == 1)) {
+    uint32 mOp = MOP_wiorrrr;
+    static_cast<RegOperand&>(resOpnd).SetValidBitsNum(1);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0, opnd1));
+  } else {
+    SelectBior(resOpnd, opnd0, opnd1, primType);
+    SelectAArch64Cmp(resOpnd, CreateImmOperand(0, primType, false), true, GetPrimTypeBitSize(primType));
+    SelectAArch64CSet(resOpnd, GetCondOperand(CC_NE), is64Bits);
+  }
+  return &resOpnd;
+}
+
+void AArch64CGFunc::SelectCmpOp(Operand &resOpnd, Operand &lhsOpnd, Operand &rhsOpnd,
+                                Opcode opcode, PrimType primType, const BaseNode &parent) {
+  uint32 dsize = resOpnd.GetSize();
+  bool isFloat = IsPrimitiveFloat(primType);
+  Operand &opnd0 = LoadIntoRegister(lhsOpnd, primType);
+
+  /*
+   * most of FP constants are passed as MemOperand
+   * except 0.0 which is passed as kOpdFPImmediate
+   */
+  Operand::OperandType opnd1Type = rhsOpnd.GetKind();
+  Operand *opnd1 = &rhsOpnd;
+  if ((opnd1Type != Operand::kOpdImmediate) && (opnd1Type != Operand::kOpdFPImmediate) &&
+      (opnd1Type != Operand::kOpdOffset)) {
+    opnd1 = &LoadIntoRegister(rhsOpnd, primType);
+  }
+
+  bool unsignedIntegerComparison = !isFloat && !IsSignedInteger(primType);
+  /*
+   * OP_cmp, OP_cmpl, OP_cmpg
+   * <cmp> OP0, OP1  ; fcmp for OP_cmpl/OP_cmpg, cmp/fcmpe for OP_cmp
+   * CSINV RES, WZR, WZR, GE
+   * CSINC RES, RES, WZR, LE
+   * if OP_cmpl, CSINV RES, RES, WZR, VC (no overflow)
+   * if OP_cmpg, CSINC RES, RES, WZR, VC (no overflow)
+   */
+  RegOperand &xzr = GetZeroOpnd(dsize);
+  if ((opcode == OP_cmpl) || (opcode == OP_cmpg)) {
+    ASSERT(isFloat, "incorrect operand types");
+    SelectTargetFPCmpQuiet(opnd0, *opnd1, GetPrimTypeBitSize(primType));
+    SelectAArch64CSINV(resOpnd, xzr, xzr, GetCondOperand(CC_GE), (dsize == k64BitSize));
+    SelectAArch64CSINC(resOpnd, resOpnd, xzr, GetCondOperand(CC_LE), (dsize == k64BitSize));
+    if (opcode == OP_cmpl) {
+      SelectAArch64CSINV(resOpnd, resOpnd, xzr, GetCondOperand(CC_VC), (dsize == k64BitSize));
+    } else {
+      SelectAArch64CSINC(resOpnd, resOpnd, xzr, GetCondOperand(CC_VC), (dsize == k64BitSize));
+    }
+    return;
+  }
+
+  if (opcode == OP_cmp) {
+    SelectAArch64Cmp(opnd0, *opnd1, !isFloat, GetPrimTypeBitSize(primType));
+    if (unsignedIntegerComparison) {
+      SelectAArch64CSINV(resOpnd, xzr, xzr, GetCondOperand(CC_HS), (dsize == k64BitSize));
+      SelectAArch64CSINC(resOpnd, resOpnd, xzr, GetCondOperand(CC_LS), (dsize == k64BitSize));
+    } else {
+      SelectAArch64CSINV(resOpnd, xzr, xzr, GetCondOperand(CC_GE), (dsize == k64BitSize));
+      SelectAArch64CSINC(resOpnd, resOpnd, xzr, GetCondOperand(CC_LE), (dsize == k64BitSize));
+    }
+    return;
+  }
+
+  // lt u8 i32 ( xxx, 0 ) => get sign bit
+  if ((opcode == OP_lt) && opnd0.IsRegister() && opnd1->IsImmediate() &&
+      (static_cast<ImmOperand*>(opnd1)->GetValue() == 0) && parent.GetOpCode() != OP_select) {
+    bool is64Bits = (opnd0.GetSize() == k64BitSize);
+    if (!unsignedIntegerComparison) {
+      int32 bitLen = is64Bits ? kBitLenOfShift64Bits : kBitLenOfShift32Bits;
+      ImmOperand &shiftNum =
+          CreateImmOperand(is64Bits ? kHighestBitOf64Bits : kHighestBitOf32Bits, static_cast<uint32>(bitLen), false);
+      MOperator mOpCode = is64Bits ? MOP_xlsrrri6 : MOP_wlsrrri5;
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, opnd0, shiftNum));
+      return;
+    }
+    ImmOperand &constNum = CreateImmOperand(0, is64Bits ? k64BitSize : k32BitSize, false);
+    GetCurBB()->AppendInsn(
+        GetInsnBuilder()->BuildInsn(is64Bits ? MOP_xmovri64 : MOP_wmovri32, resOpnd, constNum));
+    return;
+  }
+  SelectAArch64Cmp(opnd0, *opnd1, !isFloat, GetPrimTypeBitSize(primType));
+
+  ConditionCode cc = CC_EQ;
+  switch (opcode) {
+    case OP_eq:
+      cc = CC_EQ;
+      break;
+    case OP_ne:
+      cc = CC_NE;
+      break;
+    case OP_le:
+      cc = unsignedIntegerComparison ? CC_LS : CC_LE;
+      break;
+    case OP_ge:
+      cc = unsignedIntegerComparison ? CC_HS : CC_GE;
+      break;
+    case OP_gt:
+      cc = unsignedIntegerComparison ? CC_HI : CC_GT;
+      break;
+    case OP_lt:
+      cc = unsignedIntegerComparison ? CC_LO : CC_LT;
+      break;
+    default:
+      CHECK_FATAL(false, "illegal logical operator");
+  }
+  SelectAArch64CSet(resOpnd, GetCondOperand(cc), (dsize == k64BitSize));
+}
+
+Operand *AArch64CGFunc::SelectCmpOp(CompareNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(node.GetPrimType())) {
+    resOpnd = &GetOrCreateResOperand(parent, node.GetPrimType());
+    SelectCmpOp(*resOpnd, opnd0, opnd1, node.GetOpCode(), node.GetOpndType(), parent);
+  } else {
+    resOpnd = SelectVectorCompare(&opnd0, node.Opnd(0)->GetPrimType(), &opnd1,
+                                  node.Opnd(1)->GetPrimType(), node.GetOpCode());
+  }
+  return resOpnd;
+}
+
+void AArch64CGFunc::SelectTargetFPCmpQuiet(Operand &o0, Operand &o1, uint32 dsize) {
+  MOperator mOpCode = 0;
+  if (o1.GetKind() == Operand::kOpdFPImmediate) {
+    CHECK_FATAL(static_cast<ImmOperand&>(o0).GetValue() == 0, "NIY");
+    mOpCode = (dsize == k64BitSize) ? MOP_dcmpqri : (dsize == k32BitSize) ? MOP_scmpqri : MOP_hcmpqri;
+  } else if (o1.GetKind() == Operand::kOpdRegister) {
+    mOpCode = (dsize == k64BitSize) ? MOP_dcmpqrr : (dsize == k32BitSize) ? MOP_scmpqrr : MOP_hcmpqrr;
+  } else {
+    CHECK_FATAL(false, "unsupported operand type");
+  }
+  Operand &rflag = GetOrCreateRflag();
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, rflag, o0, o1));
+}
+
+void AArch64CGFunc::SelectAArch64Cmp(Operand &o0, Operand &o1, bool isIntType, uint32 dsize) {
+  MOperator mOpCode = 0;
+  Operand *newO1 = &o1;
+  if (isIntType) {
+    if ((o1.GetKind() == Operand::kOpdImmediate) || (o1.GetKind() == Operand::kOpdOffset)) {
+      ImmOperand *immOpnd = static_cast<ImmOperand*>(&o1);
+      /*
+       * imm : 0 ~ 4095, shift: none, LSL #0, or LSL #12
+       * aarch64 assembly takes up to 24-bits, if the lower 12 bits is all 0
+       */
+      if (immOpnd->IsInBitSize(kMaxImmVal12Bits, 0) || immOpnd->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits)) {
+        mOpCode = (dsize == k64BitSize) ? MOP_xcmpri : MOP_wcmpri;
+      } else {
+        /* load into register */
+        PrimType ptype = (dsize == k64BitSize) ? PTY_i64 : PTY_i32;
+        newO1 = &SelectCopy(o1, ptype, ptype);
+        mOpCode = (dsize == k64BitSize) ? MOP_xcmprr : MOP_wcmprr;
+      }
+    } else if (o1.GetKind() == Operand::kOpdRegister) {
+      mOpCode = (dsize == k64BitSize) ? MOP_xcmprr : MOP_wcmprr;
+    } else {
+      CHECK_FATAL(false, "unsupported operand type");
+    }
+  } else { /* float */
+    if (o1.GetKind() == Operand::kOpdFPImmediate) {
+      CHECK_FATAL(static_cast<ImmOperand&>(o1).GetValue() == 0, "NIY");
+      mOpCode = (dsize == k64BitSize) ? MOP_dcmperi : ((dsize == k32BitSize) ? MOP_scmperi : MOP_hcmperi);
+    } else if (o1.GetKind() == Operand::kOpdRegister) {
+      mOpCode = (dsize == k64BitSize) ? MOP_dcmperr : ((dsize == k32BitSize) ? MOP_scmperr : MOP_hcmperr);
+    } else {
+      CHECK_FATAL(false, "unsupported operand type");
+    }
+  }
+  ASSERT(mOpCode != 0, "mOpCode undefined");
+  Operand &rflag = GetOrCreateRflag();
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, rflag, o0, *newO1));
+}
+
+void AArch64CGFunc::SelectAArch64CCmp(Operand &o, Operand &i, Operand &nzcv, CondOperand &cond, bool is64Bits) {
+  uint32 mOpCode = is64Bits ? MOP_xccmpriic : MOP_wccmpriic;
+  Operand &rflag = GetOrCreateRflag();
+  std::vector<Operand*> opndVec;
+  opndVec.push_back(&rflag);
+  opndVec.push_back(&o);
+  opndVec.push_back(&i);
+  opndVec.push_back(&nzcv);
+  opndVec.push_back(&cond);
+  opndVec.push_back(&rflag);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, opndVec));
+}
+
+void AArch64CGFunc::SelectAArch64CSet(Operand &res, CondOperand &cond, bool is64Bits) {
+  MOperator mOpCode = is64Bits ? MOP_xcsetrc : MOP_wcsetrc;
+  Operand &rflag = GetOrCreateRflag();
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, res, cond, rflag));
+}
+
+void AArch64CGFunc::SelectAArch64CSINV(Operand &res, Operand &o0, Operand &o1, CondOperand &cond, bool is64Bits) {
+  MOperator mOpCode = is64Bits ? MOP_xcsinvrrrc : MOP_wcsinvrrrc;
+  Operand &rflag = GetOrCreateRflag();
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, res, o0, o1, cond, rflag));
+}
+
+void AArch64CGFunc::SelectAArch64CSINC(Operand &res, Operand &o0, Operand &o1, CondOperand &cond, bool is64Bits) {
+  MOperator mOpCode = is64Bits ? MOP_xcsincrrrc : MOP_wcsincrrrc;
+  Operand &rflag = GetOrCreateRflag();
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, res, o0, o1, cond, rflag));
+}
+
+Operand *AArch64CGFunc::SelectBand(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  return SelectRelationOperator(kAND, node, opnd0, opnd1, parent);
+}
+
+void AArch64CGFunc::SelectBand(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  SelectRelationOperator(kAND, resOpnd, opnd0, opnd1, primType);
+}
+
+Operand *AArch64CGFunc::SelectRelationOperator(RelationOperator operatorCode, const BinaryNode &node, Operand &opnd0,
+                                               Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool isSigned = IsSignedInteger(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  bool is64Bits = (dsize == k64BitSize);
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(dtype)) {
+    PrimType primType = is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32);  /* promoted type */
+    resOpnd = &GetOrCreateResOperand(parent, primType);
+    SelectRelationOperator(operatorCode, *resOpnd, opnd0, opnd1, primType);
+  } else {
+    /* vector operations */
+    resOpnd = SelectVectorBitwiseOp(dtype, &opnd0, node.Opnd(0)->GetPrimType(), &opnd1, node.Opnd(1)->GetPrimType(),
+                                    (operatorCode == kAND) ? OP_band : (operatorCode == kIOR ? OP_bior : OP_bxor));
+  }
+  return resOpnd;
+}
+
+MOperator AArch64CGFunc::SelectRelationMop(RelationOperator operatorCode,
+                                           RelationOperatorOpndPattern opndPattern, bool is64Bits,
+                                           bool isBitmaskImmediate, bool isBitNumLessThan16) const {
+  MOperator mOp = MOP_undef;
+  if (opndPattern == kRegReg) {
+    switch (operatorCode) {
+      case kAND:
+        mOp = is64Bits ? MOP_xandrrr : MOP_wandrrr;
+        break;
+      case kIOR:
+        mOp = is64Bits ? MOP_xiorrrr : MOP_wiorrrr;
+        break;
+      case kEOR:
+        mOp = is64Bits ? MOP_xeorrrr : MOP_weorrrr;
+        break;
+      default:
+        break;
+    }
+    return mOp;
+  }
+  /* opndPattern == KRegImm */
+  if (isBitmaskImmediate) {
+    switch (operatorCode) {
+      case kAND:
+        mOp = is64Bits ? MOP_xandrri13 : MOP_wandrri12;
+        break;
+      case kIOR:
+        mOp = is64Bits ? MOP_xiorrri13 : MOP_wiorrri12;
+        break;
+      case kEOR:
+        mOp = is64Bits ? MOP_xeorrri13 : MOP_weorrri12;
+        break;
+      default:
+        break;
+    }
+    return mOp;
+  }
+  /* normal imm value */
+  if (isBitNumLessThan16) {
+    switch (operatorCode) {
+      case kAND:
+        mOp = is64Bits ? MOP_xandrrrs : MOP_wandrrrs;
+        break;
+      case kIOR:
+        mOp = is64Bits ? MOP_xiorrrrs : MOP_wiorrrrs;
+        break;
+      case kEOR:
+        mOp = is64Bits ? MOP_xeorrrrs : MOP_weorrrrs;
+        break;
+      default:
+        break;
+    }
+    return mOp;
+  }
+  return mOp;
+}
+
+void AArch64CGFunc::SelectRelationOperator(RelationOperator operatorCode, Operand &resOpnd, Operand &opnd0,
+                                           Operand &opnd1, PrimType primType) {
+  Operand::OperandType opnd0Type = opnd0.GetKind();
+  Operand::OperandType opnd1Type = opnd1.GetKind();
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+  /* op #imm. #imm */
+  if ((opnd0Type != Operand::kOpdRegister) && (opnd1Type != Operand::kOpdRegister)) {
+    SelectRelationOperator(operatorCode, resOpnd, SelectCopy(opnd0, primType, primType), opnd1, primType);
+    return;
+  }
+  /* op #imm, reg -> op reg, #imm */
+  if ((opnd0Type != Operand::kOpdRegister) && (opnd1Type == Operand::kOpdRegister)) {
+    SelectRelationOperator(operatorCode, resOpnd, opnd1, opnd0, primType);
+    return;
+  }
+  /* op reg, reg */
+  if ((opnd0Type == Operand::kOpdRegister) && (opnd1Type == Operand::kOpdRegister)) {
+    ASSERT(IsPrimitiveInteger(primType), "NYI band");
+    MOperator mOp = SelectRelationMop(operatorCode, kRegReg, is64Bits, false, false);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0, opnd1));
+    return;
+  }
+  /* op reg, #imm */
+  if ((opnd0Type == Operand::kOpdRegister) && (opnd1Type != Operand::kOpdRegister)) {
+    if (!((opnd1Type == Operand::kOpdImmediate) || (opnd1Type == Operand::kOpdOffset))) {
+      SelectRelationOperator(operatorCode, resOpnd, opnd0, SelectCopy(opnd1, primType, primType), primType);
+      return;
+    }
+
+    ImmOperand *immOpnd = static_cast<ImmOperand*>(&opnd1);
+    if (immOpnd->IsZero()) {
+      if (operatorCode == kAND) {
+        uint32 mopMv = is64Bits ? MOP_xmovrr : MOP_wmovrr;
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopMv, resOpnd,
+                                                                      GetZeroOpnd(dsize)));
+      } else if ((operatorCode == kIOR) || (operatorCode == kEOR)) {
+        SelectCopy(resOpnd, primType, opnd0, primType);
+      }
+    } else if ((immOpnd->IsAllOnes()) || (!is64Bits && immOpnd->IsAllOnes32bit())) {
+      if (operatorCode == kAND) {
+        SelectCopy(resOpnd, primType, opnd0, primType);
+      } else if (operatorCode == kIOR) {
+        uint32 mopMovn = is64Bits ? MOP_xmovnri16 : MOP_wmovnri16;
+        ImmOperand &src16 = CreateImmOperand(0, k16BitSize, false);
+        BitShiftOperand *lslOpnd = GetLogicalShiftLeftOperand(0, is64Bits);
+        GetCurBB()->AppendInsn(
+            GetInsnBuilder()->BuildInsn(mopMovn, resOpnd, src16, *lslOpnd));
+      } else if (operatorCode == kEOR) {
+        SelectMvn(resOpnd, opnd0, primType);
+      }
+    } else if (immOpnd->IsBitmaskImmediate()) {
+      MOperator mOp = SelectRelationMop(operatorCode, kRegImm, is64Bits, true, false);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0, opnd1));
+    } else {
+      int64 immVal = immOpnd->GetValue();
+      int32 tail0BitNum = GetTail0BitNum(immVal);
+      int32 head0BitNum = GetHead0BitNum(immVal);
+      const int32 bitNum = (k64BitSizeInt - head0BitNum) - tail0BitNum;
+      RegOperand &regOpnd = CreateRegisterOperandOfType(primType);
+
+      if (bitNum <= k16ValidBit && tail0BitNum != 0) {
+        int64 newImm = (static_cast<uint64>(immVal) >> static_cast<uint32>(tail0BitNum)) & 0xFFFF;
+        ImmOperand &immOpnd1 = CreateImmOperand(newImm, k32BitSize, false);
+        SelectCopyImm(regOpnd, immOpnd1, primType);
+        MOperator mOp = SelectRelationMop(operatorCode, kRegImm, is64Bits, false, true);
+        int32 bitLen = is64Bits ? kBitLenOfShift64Bits : kBitLenOfShift32Bits;
+        BitShiftOperand &shiftOpnd =
+            CreateBitShiftOperand(BitShiftOperand::kLSL, static_cast<uint32>(tail0BitNum), bitLen);
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0, regOpnd, shiftOpnd));
+      } else {
+        SelectCopyImm(regOpnd, *immOpnd, primType);
+        MOperator mOp = SelectRelationMop(operatorCode, kRegReg, is64Bits, false, false);
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0, regOpnd));
+      }
+    }
+  }
+}
+
+Operand *AArch64CGFunc::SelectBior(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  return SelectRelationOperator(kIOR, node, opnd0, opnd1, parent);
+}
+
+void AArch64CGFunc::SelectBior(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  SelectRelationOperator(kIOR, resOpnd, opnd0, opnd1, primType);
+}
+
+Operand *AArch64CGFunc::SelectMinOrMax(bool isMin, const BinaryNode &node, Operand &opnd0, Operand &opnd1,
+                                       const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool isSigned = IsSignedInteger(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  bool is64Bits = (dsize == k64BitSize);
+  bool isFloat = IsPrimitiveFloat(dtype);
+  /* promoted type */
+  PrimType primType = isFloat ? dtype : (is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32));
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, primType);
+  SelectMinOrMax(isMin, resOpnd, opnd0, opnd1, primType);
+  return &resOpnd;
+}
+
+void AArch64CGFunc::SelectMinOrMax(bool isMin, Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+  if (IsPrimitiveInteger(primType)) {
+    RegOperand &regOpnd0 = LoadIntoRegister(opnd0, primType);
+    Operand &regOpnd1 = LoadIntoRegister(opnd1, primType);
+    SelectAArch64Cmp(regOpnd0, regOpnd1, true, dsize);
+    Operand &newResOpnd = LoadIntoRegister(resOpnd, primType);
+    if (isMin) {
+      CondOperand &cc = IsSignedInteger(primType) ? GetCondOperand(CC_LT) : GetCondOperand(CC_LO);
+      SelectAArch64Select(newResOpnd, regOpnd0, regOpnd1, cc, true, dsize);
+    } else {
+      CondOperand &cc = IsSignedInteger(primType) ? GetCondOperand(CC_GT) : GetCondOperand(CC_HI);
+      SelectAArch64Select(newResOpnd, regOpnd0, regOpnd1, cc, true, dsize);
+    }
+  } else if (IsPrimitiveFloat(primType)) {
+    RegOperand &regOpnd0 = LoadIntoRegister(opnd0, primType);
+    RegOperand &regOpnd1 = LoadIntoRegister(opnd1, primType);
+    SelectFMinFMax(resOpnd, regOpnd0, regOpnd1, is64Bits, isMin);
+  } else {
+    CHECK_FATAL(false, "NIY type max or min");
+  }
+}
+
+Operand *AArch64CGFunc::SelectMin(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  return SelectMinOrMax(true, node, opnd0, opnd1, parent);
+}
+
+void AArch64CGFunc::SelectMin(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  SelectMinOrMax(true, resOpnd, opnd0, opnd1, primType);
+}
+
+Operand *AArch64CGFunc::SelectMax(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  return SelectMinOrMax(false, node, opnd0, opnd1, parent);
+}
+
+void AArch64CGFunc::SelectMax(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  SelectMinOrMax(false, resOpnd, opnd0, opnd1, primType);
+}
+
+void AArch64CGFunc::SelectFMinFMax(Operand &resOpnd, Operand &opnd0, Operand &opnd1, bool is64Bits, bool isMin) {
+  uint32 mOpCode = isMin ? (is64Bits ? MOP_xfminrrr : MOP_wfminrrr) : (is64Bits ? MOP_xfmaxrrr : MOP_wfmaxrrr);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, opnd0, opnd1));
+}
+
+Operand *AArch64CGFunc::SelectBxor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  return SelectRelationOperator(kEOR, node, opnd0, opnd1, parent);
+}
+
+void AArch64CGFunc::SelectBxor(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  SelectRelationOperator(kEOR, resOpnd, opnd0, opnd1, primType);
+}
+
+Operand *AArch64CGFunc::SelectShift(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool isSigned = IsSignedInteger(dtype);
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  bool is64Bits = (dsize == k64BitSize);
+  bool isFloat = IsPrimitiveFloat(dtype);
+  RegOperand *resOpnd = nullptr;
+  Opcode opcode = node.GetOpCode();
+
+  bool isOneElemVector = false;
+  BaseNode *expr = node.Opnd(0);
+  if (expr->GetOpCode() == OP_dread) {
+    MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(static_cast<DreadNode*>(expr)->GetStIdx());
+    isOneElemVector = symbol->GetAttr(ATTR_oneelem_simd);
+  }
+
+  Operand *opd0 = &opnd0;
+  PrimType otyp0 = expr->GetPrimType();
+  if (IsPrimitiveVector(dtype) && opnd0.IsConstImmediate()) {
+    opd0 = SelectVectorFromScalar(dtype, opd0, node.Opnd(0)->GetPrimType());
+    otyp0 = dtype;
+  }
+
+  if (IsPrimitiveVector(dtype) && opnd1.IsConstImmediate()) {
+    int64 sConst = static_cast<ImmOperand&>(opnd1).GetValue();
+    resOpnd = SelectVectorShiftImm(dtype, opd0, &opnd1, static_cast<int32>(sConst), opcode);
+  } else if ((IsPrimitiveVector(dtype) || isOneElemVector) && !opnd1.IsConstImmediate()) {
+    resOpnd = SelectVectorShift(dtype, opd0, otyp0, &opnd1, node.Opnd(1)->GetPrimType(), opcode);
+  } else {
+    PrimType primType = isFloat ? dtype : (is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32));
+    resOpnd = &GetOrCreateResOperand(parent, primType);
+    ShiftDirection direct = (opcode == OP_lshr) ? kShiftLright : ((opcode == OP_ashr) ? kShiftAright : kShiftLeft);
+    SelectShift(*resOpnd, opnd0, opnd1, direct, primType);
+  }
+
+  if (dtype == PTY_i16) {
+    MOperator exOp = is64Bits ? MOP_xsxth64 : MOP_xsxth32;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(exOp, *resOpnd, *resOpnd));
+  } else if (dtype == PTY_i8) {
+    MOperator exOp = is64Bits ? MOP_xsxtb64 : MOP_xsxtb32;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(exOp, *resOpnd, *resOpnd));
+  }
+  return resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectRor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  uint32 dsize = GetPrimTypeBitSize(dtype);
+  PrimType primType = (dsize == k64BitSize) ? PTY_u64 : PTY_u32;
+  RegOperand *resOpnd = &GetOrCreateResOperand(parent, primType);
+  Operand *firstOpnd = &LoadIntoRegister(opnd0, primType);
+  MOperator mopRor = (dsize == k64BitSize) ? MOP_xrorrrr : MOP_wrorrrr;
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopRor, *resOpnd, *firstOpnd, opnd1));
+  return resOpnd;
+}
+
+void AArch64CGFunc::SelectBxorShift(Operand &resOpnd, Operand *opnd0, Operand *opnd1, Operand &opnd2,
+                                    PrimType primType) {
+  opnd0 = &LoadIntoRegister(*opnd0, primType);
+  opnd1 = &LoadIntoRegister(*opnd1, primType);
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+  MOperator mopBxor = is64Bits ? MOP_xeorrrrs : MOP_weorrrrs;
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopBxor, resOpnd, *opnd0, *opnd1, opnd2));
+}
+
+void AArch64CGFunc::SelectShift(Operand &resOpnd, Operand &opnd0, Operand &opnd1, ShiftDirection direct,
+                                PrimType primType) {
+  Operand::OperandType opnd1Type = opnd1.GetKind();
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+  Operand *firstOpnd = &LoadIntoRegister(opnd0, primType);
+
+  MOperator mopShift;
+  if ((opnd1Type == Operand::kOpdImmediate) || (opnd1Type == Operand::kOpdOffset)) {
+    ImmOperand *immOpnd1 = static_cast<ImmOperand*>(&opnd1);
+    const int64 kVal = immOpnd1->GetValue();
+    const uint32 kShiftamt = is64Bits ? kHighestBitOf64Bits : kHighestBitOf32Bits;
+    if (kVal == 0) {
+      SelectCopy(resOpnd, primType, *firstOpnd, primType);
+      return;
+    }
+    /* e.g. a >> -1 */
+    if ((kVal < 0) || (kVal > kShiftamt)) {
+      SelectShift(resOpnd, *firstOpnd, SelectCopy(opnd1, primType, primType), direct, primType);
+      return;
+    }
+    switch (direct) {
+      case kShiftLeft:
+        mopShift = is64Bits ? MOP_xlslrri6 : MOP_wlslrri5;
+        break;
+      case kShiftAright:
+        mopShift = is64Bits ? MOP_xasrrri6 : MOP_wasrrri5;
+        break;
+      case kShiftLright:
+        mopShift = is64Bits ? MOP_xlsrrri6 : MOP_wlsrrri5;
+        break;
+    }
+  } else if (opnd1Type != Operand::kOpdRegister) {
+    SelectShift(resOpnd, *firstOpnd, SelectCopy(opnd1, primType, primType), direct, primType);
+    return;
+  } else {
+    switch (direct) {
+      case kShiftLeft:
+        mopShift = is64Bits ? MOP_xlslrrr : MOP_wlslrrr;
+        break;
+      case kShiftAright:
+        mopShift = is64Bits ? MOP_xasrrrr : MOP_wasrrrr;
+        break;
+      case kShiftLright:
+        mopShift = is64Bits ? MOP_xlsrrrr : MOP_wlsrrrr;
+        break;
+    }
+  }
+
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopShift, resOpnd, *firstOpnd, opnd1));
+}
+
+Operand *AArch64CGFunc::SelectAbsSub(Insn &lastInsn, const UnaryNode &node, Operand &newOpnd0) {
+  PrimType dtyp = node.GetPrimType();
+  bool is64Bits = (GetPrimTypeBitSize(dtyp) == k64BitSize);
+  /* promoted type */
+  PrimType primType = is64Bits ? (PTY_i64) : (PTY_i32);
+  RegOperand &resOpnd = CreateRegisterOperandOfType(primType);
+  uint32 mopCsneg = is64Bits ? MOP_xcnegrrrc : MOP_wcnegrrrc;
+  /* ABS requires the operand be interpreted as a signed integer */
+  CondOperand &condOpnd = GetCondOperand(CC_MI);
+  MOperator newMop = lastInsn.GetMachineOpcode() + 1;
+  Operand &rflag = GetOrCreateRflag();
+  std::vector<Operand *> opndVec;
+  opndVec.push_back(&rflag);
+  for (uint32 i = 0; i < lastInsn.GetOperandSize(); i++) {
+    opndVec.push_back(&lastInsn.GetOperand(i));
+  }
+  Insn *subsInsn = &GetInsnBuilder()->BuildInsn(newMop, opndVec);
+  GetCurBB()->ReplaceInsn(lastInsn, *subsInsn);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopCsneg, resOpnd, newOpnd0, condOpnd, rflag));
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectAbs(UnaryNode &node, Operand &opnd0) {
+  PrimType dtyp = node.GetPrimType();
+  if (IsPrimitiveVector(dtyp)) {
+    return SelectVectorAbs(dtyp, &opnd0);
+  } else if (IsPrimitiveFloat(dtyp)) {
+    CHECK_FATAL(GetPrimTypeBitSize(dtyp) >= k32BitSize, "We don't support hanf-word FP operands yet");
+    bool is64Bits = (GetPrimTypeBitSize(dtyp) == k64BitSize);
+    Operand &newOpnd0 = LoadIntoRegister(opnd0, dtyp);
+    RegOperand &resOpnd = CreateRegisterOperandOfType(dtyp);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(is64Bits ? MOP_dabsrr : MOP_sabsrr,
+                                                                  resOpnd, newOpnd0));
+    return &resOpnd;
+  } else {
+    bool is64Bits = (GetPrimTypeBitSize(dtyp) == k64BitSize);
+    /* promoted type */
+    PrimType primType = is64Bits ? (PTY_i64) : (PTY_i32);
+    Operand &newOpnd0 = LoadIntoRegister(opnd0, primType);
+    Insn *lastInsn = GetCurBB()->GetLastInsn();
+    if (lastInsn != nullptr && lastInsn->GetMachineOpcode() >= MOP_xsubrrr &&
+      lastInsn->GetMachineOpcode() <= MOP_wsubrri12) {
+      return SelectAbsSub(*lastInsn, node, newOpnd0);
+    }
+    RegOperand &resOpnd = CreateRegisterOperandOfType(primType);
+    SelectAArch64Cmp(newOpnd0, CreateImmOperand(0, is64Bits ? PTY_u64 : PTY_u32, false),
+                     true, GetPrimTypeBitSize(dtyp));
+    uint32 mopCsneg = is64Bits ? MOP_xcsnegrrrc : MOP_wcsnegrrrc;
+    /* ABS requires the operand be interpreted as a signed integer */
+    CondOperand &condOpnd = GetCondOperand(CC_GE);
+    Operand &rflag = GetOrCreateRflag();
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopCsneg, resOpnd, newOpnd0, newOpnd0,
+                                                                  condOpnd, rflag));
+    return &resOpnd;
+  }
+}
+
+Operand *AArch64CGFunc::SelectBnot(UnaryNode &node, Operand &opnd0, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  ASSERT(IsPrimitiveInteger(dtype) || IsPrimitiveVectorInteger(dtype), "bnot expect integer or NYI");
+  bool is64Bits = (GetPrimTypeBitSize(dtype) == k64BitSize);
+  bool isSigned = IsSignedInteger(dtype);
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(dtype)) {
+    /* promoted type */
+    PrimType primType = is64Bits ? (isSigned ? PTY_i64 : PTY_u64) : (isSigned ? PTY_i32 : PTY_u32);
+    resOpnd = &GetOrCreateResOperand(parent, primType);
+
+    Operand &newOpnd0 = LoadIntoRegister(opnd0, primType);
+
+    uint32 mopBnot = is64Bits ? MOP_xnotrr : MOP_wnotrr;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopBnot, *resOpnd, newOpnd0));
+  } else {
+    /* vector operand */
+    resOpnd = SelectVectorNot(dtype, &opnd0);
+  }
+  return resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectBswap(IntrinsicopNode &node, Operand &opnd0, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  auto bitWidth = (GetPrimTypeBitSize(dtype));
+  RegOperand *resOpnd = nullptr;
+  resOpnd = &GetOrCreateResOperand(parent, dtype);
+  Operand &newOpnd0 = LoadIntoRegister(opnd0, dtype);
+  uint32 mopBswap = bitWidth == 64 ? MOP_xrevrr : (bitWidth == 32 ? MOP_wrevrr : MOP_wrevrr16);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopBswap, *resOpnd, newOpnd0));
+  return resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectRegularBitFieldLoad(ExtractbitsNode &node, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool isSigned = IsSignedInteger(dtype);
+  uint8 bitOffset = node.GetBitsOffset();
+  uint8 bitSize = node.GetBitsSize();
+  bool is64Bits = (GetPrimTypeBitSize(dtype) == k64BitSize);
+  CHECK_FATAL(!is64Bits, "dest opnd should not be 64bit");
+  PrimType destType = GetIntegerPrimTypeBySizeAndSign(bitSize, isSigned);
+  Operand *result = SelectIread(parent, *static_cast<IreadNode*>(node.Opnd(0)),
+      static_cast<int>(bitOffset / k8BitSize), destType);
+  return result;
+}
+
+Operand *AArch64CGFunc::SelectExtractbits(ExtractbitsNode &node, Operand &srcOpnd, const BaseNode &parent) {
+  uint8 bitOffset = node.GetBitsOffset();
+  uint8 bitSize = node.GetBitsSize();
+  RegOperand *srcVecRegOperand = static_cast<RegOperand*>(&srcOpnd);
+  if (srcVecRegOperand && srcVecRegOperand->IsRegister() && (srcVecRegOperand->GetSize() == k128BitSize)) {
+    if ((bitSize == k8BitSize || bitSize == k16BitSize || bitSize == k32BitSize || bitSize == k64BitSize) &&
+        (bitOffset % bitSize) == k0BitSize) {
+      uint32 lane = bitOffset / bitSize;
+      PrimType srcVecPtype;
+      if (bitSize == k64BitSize) {
+        srcVecPtype = PTY_v2u64;
+      } else if (bitSize == k32BitSize) {
+        srcVecPtype = PTY_v4u32;
+      } else if (bitSize == k16BitSize) {
+        srcVecPtype = PTY_v8u16;
+      } else {
+        srcVecPtype = PTY_v16u8;
+      }
+      RegOperand *resRegOperand = SelectVectorGetElement(node.GetPrimType(),
+          &srcOpnd, srcVecPtype, static_cast<int32>(lane));
+      return resRegOperand;
+    } else {
+      CHECK_FATAL(false, "NYI");
+    }
+  }
+  PrimType dtype = node.GetPrimType();
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, dtype);
+  bool isSigned = (node.GetOpCode() == OP_sext) ? true : (node.GetOpCode() == OP_zext) ? false : IsSignedInteger(dtype);
+  bool is64Bits = (GetPrimTypeBitSize(dtype) == k64BitSize);
+  uint32 immWidth = is64Bits ? kMaxImmVal13Bits : kMaxImmVal12Bits;
+  Operand &opnd0 = LoadIntoRegister(srcOpnd, dtype);
+  if (bitOffset == 0) {
+    if (!isSigned && (bitSize < immWidth)) {
+      SelectBand(resOpnd, opnd0, CreateImmOperand(static_cast<int64>((static_cast<uint64>(1) << bitSize) - 1),
+          immWidth, false), dtype);
+      return &resOpnd;
+    } else {
+      MOperator mOp = MOP_undef;
+      if (bitSize == k8BitSize) {
+        mOp = is64Bits ? (isSigned ? MOP_xsxtb64 : MOP_undef) :
+            (isSigned ? MOP_xsxtb32 : (opnd0.GetSize() == k32BitSize ? MOP_xuxtb32 : MOP_undef));
+      } else if (bitSize == k16BitSize) {
+        mOp = is64Bits ? (isSigned ? MOP_xsxth64 : MOP_undef) :
+            (isSigned ? MOP_xsxth32 : (opnd0.GetSize() == k32BitSize ? MOP_xuxth32 : MOP_undef));
+      } else if (bitSize == k32BitSize) {
+        mOp = is64Bits ? (isSigned ? MOP_xsxtw64 : MOP_xuxtw64) : MOP_wmovrr;
+      }
+      if (mOp != MOP_undef) {
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0));
+        return &resOpnd;
+      }
+    }
+  }
+  uint32 mopBfx =
+      is64Bits ? (isSigned ? MOP_xsbfxrri6i6 : MOP_xubfxrri6i6) : (isSigned ? MOP_wsbfxrri5i5 : MOP_wubfxrri5i5);
+  ImmOperand &immOpnd1 = CreateImmOperand(bitOffset, k8BitSize, false);
+  ImmOperand &immOpnd2 = CreateImmOperand(bitSize, k8BitSize, false);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopBfx, resOpnd, opnd0, immOpnd1, immOpnd2));
+  return &resOpnd;
+}
+
+/*
+ *  operand fits in MOVK if
+ *     is64Bits && boffst == 0, 16, 32, 48 && bSize == 16, so boffset / 16 == 0, 1, 2, 3; (boffset / 16 ) & (~3) == 0
+ *  or is32Bits && boffset == 0, 16 && bSize == 16, so boffset / 16 == 0, 1; (boffset / 16) & (~1) == 0
+ *  imm range of aarch64-movk [0 - 65536] imm16
+ */
+inline bool IsMoveWideKeepable(int64 offsetVal, uint32 bitOffset, uint32 bitSize, bool is64Bits) {
+  ASSERT(is64Bits || (bitOffset < k32BitSize), "");
+  bool isOutOfRange = offsetVal < 0;
+  if (!isOutOfRange) {
+    isOutOfRange = (static_cast<unsigned long int>(offsetVal) >> k16BitSize) > 0;
+  }
+  return (!isOutOfRange) &&
+      bitSize == k16BitSize &&
+      ((bitOffset >> k16BitShift) & ~static_cast<uint32>(is64Bits ? 0x3 : 0x1)) == 0;
+}
+
+/* we use the fact that A ^ B ^ A == B, A ^ 0 = A */
+Operand *AArch64CGFunc::SelectDepositBits(DepositbitsNode &node, Operand &opnd0, Operand &opnd1,
+                                          const BaseNode &parent) {
+  uint32 bitOffset = node.GetBitsOffset();
+  uint32 bitSize = node.GetBitsSize();
+  PrimType regType = node.GetPrimType();
+  bool is64Bits = GetPrimTypeBitSize(regType) == k64BitSize;
+  // deposit does not define opnd0 but bfi does, so we need an extra copy to keep opnd0 wont de defined
+  Operand *result = &GetOrCreateResOperand(parent, regType);
+  SelectCopy(*result, regType, opnd0, regType);
+  /*
+   * if operand 1 is immediate and fits in MOVK, use it
+   * MOVK Wd, #imm{, LSL #shift} ; 32-bit general registers
+   * MOVK Xd, #imm{, LSL #shift} ; 64-bit general registers
+   */
+  if (opnd1.IsIntImmediate() &&
+      IsMoveWideKeepable(static_cast<ImmOperand&>(opnd1).GetValue(), bitOffset, bitSize, is64Bits)) {
+    RegOperand &resOpnd = GetOrCreateResOperand(parent, regType);
+    SelectCopy(resOpnd, regType, *result, regType);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn((is64Bits ? MOP_xmovkri16 : MOP_wmovkri16),
+                                                                  resOpnd, opnd1,
+                                                                  *GetLogicalShiftLeftOperand(bitOffset, is64Bits)));
+    return &resOpnd;
+  } else {
+    Operand &movOpnd = LoadIntoRegister(opnd1, regType);
+    uint32 mopBfi = is64Bits ? MOP_xbfirri6i6 : MOP_wbfirri5i5;
+    ImmOperand &immOpnd1 = CreateImmOperand(bitOffset, k8BitSize, false);
+    ImmOperand &immOpnd2 = CreateImmOperand(bitSize, k8BitSize, false);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopBfi, *result, movOpnd, immOpnd1, immOpnd2));
+    return result;
+  }
+}
+
+Operand *AArch64CGFunc::SelectLnot(UnaryNode &node, Operand &srcOpnd, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, dtype);
+  bool is64Bits = (GetPrimTypeBitSize(dtype) == k64BitSize);
+  Operand &opnd0 = LoadIntoRegister(srcOpnd, dtype);
+  SelectAArch64Cmp(opnd0, CreateImmOperand(0, is64Bits ? PTY_u64 : PTY_u32, false), true, GetPrimTypeBitSize(dtype));
+  SelectAArch64CSet(resOpnd, GetCondOperand(CC_EQ), is64Bits);
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectNeg(UnaryNode &node, Operand &opnd0, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  bool is64Bits = (GetPrimTypeBitSize(dtype) == k64BitSize);
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(dtype)) {
+    PrimType primType;
+    if (IsPrimitiveFloat(dtype)) {
+      primType = dtype;
+    } else {
+      primType = is64Bits ? (PTY_i64) : (PTY_i32);  /* promoted type */
+    }
+    resOpnd = &GetOrCreateResOperand(parent, primType);
+    SelectNeg(*resOpnd, opnd0, primType);
+  } else {
+    /* vector operand */
+    resOpnd = SelectVectorNeg(dtype, &opnd0);
+  }
+  return resOpnd;
+}
+
+void AArch64CGFunc::SelectNeg(Operand &dest, Operand &srcOpnd, PrimType primType) {
+  Operand &opnd0 = LoadIntoRegister(srcOpnd, primType);
+  bool is64Bits = (GetPrimTypeBitSize(primType) == k64BitSize);
+  MOperator mOp;
+  if (IsPrimitiveFloat(primType)) {
+    mOp = is64Bits ? MOP_xfnegrr : MOP_wfnegrr;
+  } else {
+    mOp = is64Bits ? MOP_xinegrr : MOP_winegrr;
+  }
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, dest, opnd0));
+}
+
+void AArch64CGFunc::SelectMvn(Operand &dest, Operand &src, PrimType primType) {
+  Operand &opnd0 = LoadIntoRegister(src, primType);
+  bool is64Bits = (GetPrimTypeBitSize(primType) == k64BitSize);
+  MOperator mOp;
+  ASSERT(!IsPrimitiveFloat(primType), "Instruction 'mvn' do not have float version.");
+  mOp = is64Bits ? MOP_xnotrr : MOP_wnotrr;
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, dest, opnd0));
+}
+
+Operand *AArch64CGFunc::SelectRecip(UnaryNode &node, Operand &src, const BaseNode &parent) {
+  /*
+   * fconsts s15, #112
+   * fdivs s0, s15, s0
+   */
+  PrimType dtype = node.GetPrimType();
+  if (!IsPrimitiveFloat(dtype)) {
+    ASSERT(false, "should be float type");
+    return nullptr;
+  }
+  Operand &opnd0 = LoadIntoRegister(src, dtype);
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, dtype);
+  Operand *one = nullptr;
+  if (GetPrimTypeBitSize(dtype) == k64BitSize) {
+    MIRDoubleConst *c = memPool->New<MIRDoubleConst>(1.0, *GlobalTables::GetTypeTable().GetTypeTable().at(PTY_f64));
+    one = SelectDoubleConst(*c, node);
+  } else if (GetPrimTypeBitSize(dtype) == k32BitSize) {
+    MIRFloatConst *c = memPool->New<MIRFloatConst>(1.0f, *GlobalTables::GetTypeTable().GetTypeTable().at(PTY_f32));
+    one = SelectFloatConst(*c, node);
+  } else {
+    CHECK_FATAL(false, "we don't support half-precision fp operations yet");
+  }
+  SelectDiv(resOpnd, *one, opnd0, dtype);
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectSqrt(UnaryNode &node, Operand &src, const BaseNode &parent) {
+  /*
+   * gcc generates code like below for better accurate
+   * fsqrts  s15, s0
+   * fcmps s15, s15
+   * fmstat
+   * beq .L4
+   * push  {r3, lr}
+   * bl  sqrtf
+   * pop {r3, pc}
+   * .L4:
+   * fcpys s0, s15
+   * bx  lr
+   */
+  PrimType dtype = node.GetPrimType();
+  if (!IsPrimitiveFloat(dtype)) {
+    ASSERT(false, "should be float type");
+    return nullptr;
+  }
+  bool is64Bits = (GetPrimTypeBitSize(dtype) == k64BitSize);
+  Operand &opnd0 = LoadIntoRegister(src, dtype);
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, dtype);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(is64Bits ? MOP_vsqrtd : MOP_vsqrts, resOpnd, opnd0));
+  return &resOpnd;
+}
+
+void AArch64CGFunc::SelectCvtFloat2Int(Operand &resOpnd, Operand &srcOpnd, PrimType itype, PrimType ftype) {
+  bool is64BitsFloat = (ftype == PTY_f64);
+  MOperator mOp = 0;
+
+  ASSERT(((ftype == PTY_f64) || (ftype == PTY_f32)), "wrong from type");
+  Operand &opnd0 = LoadIntoRegister(srcOpnd, ftype);
+  switch (itype) {
+    case PTY_i32:
+      mOp = !is64BitsFloat ? MOP_vcvtrf : MOP_vcvtrd;
+      break;
+    case PTY_u32:
+    case PTY_a32:
+      mOp = !is64BitsFloat ? MOP_vcvturf : MOP_vcvturd;
+      break;
+    case PTY_i64:
+      mOp = !is64BitsFloat ? MOP_xvcvtrf : MOP_xvcvtrd;
+      break;
+    case PTY_u64:
+    case PTY_a64:
+      mOp = !is64BitsFloat ? MOP_xvcvturf : MOP_xvcvturd;
+      break;
+    default:
+      CHECK_FATAL(false, "unexpected type");
+  }
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0));
+}
+
+void AArch64CGFunc::SelectCvtInt2Float(Operand &resOpnd, Operand &origOpnd0, PrimType toType, PrimType fromType) {
+  ASSERT((toType == PTY_f32) || (toType == PTY_f64), "unexpected type");
+  bool is64BitsFloat = (toType == PTY_f64);
+  MOperator mOp = 0;
+  uint32 fsize = GetPrimTypeBitSize(fromType);
+
+  PrimType itype = (GetPrimTypeBitSize(fromType) == k64BitSize) ? (IsSignedInteger(fromType) ? PTY_i64 : PTY_u64)
+                                                                : (IsSignedInteger(fromType) ? PTY_i32 : PTY_u32);
+
+  Operand *opnd0 = &LoadIntoRegister(origOpnd0, itype);
+
+  /* need extension before cvt */
+  ASSERT(opnd0->IsRegister(), "opnd should be a register operand");
+  Operand *srcOpnd = opnd0;
+  if (IsSignedInteger(fromType) && (fsize < k32BitSize)) {
+    srcOpnd = &CreateRegisterOperandOfType(itype);
+    mOp = (fsize == k8BitSize) ? MOP_xsxtb32 : MOP_xsxth32;
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, *srcOpnd, *opnd0));
+  }
+
+  switch (itype) {
+    case PTY_i32:
+      mOp = !is64BitsFloat ? MOP_vcvtfr : MOP_vcvtdr;
+      break;
+    case PTY_u32:
+      mOp = !is64BitsFloat ? MOP_vcvtufr : MOP_vcvtudr;
+      break;
+    case PTY_i64:
+      mOp = !is64BitsFloat ? MOP_xvcvtfr : MOP_xvcvtdr;
+      break;
+    case PTY_u64:
+      mOp = !is64BitsFloat ? MOP_xvcvtufr : MOP_xvcvtudr;
+      break;
+    default:
+      CHECK_FATAL(false, "unexpected type");
+  }
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, *srcOpnd));
+}
+
+Operand *AArch64CGFunc::SelectIntrinsicOpWithOneParam(IntrinsicopNode &intrnNode, std::string name) {
+  BaseNode *argexpr = intrnNode.Opnd(0);
+  PrimType ptype = argexpr->GetPrimType();
+  Operand *opnd = HandleExpr(intrnNode, *argexpr);
+  if (intrnNode.GetIntrinsic() == INTRN_C_ffs) {
+    ASSERT(intrnNode.GetPrimType() == PTY_i32, "Unexpect Size");
+    return SelectAArch64ffs(*opnd, ptype);
+  }
+  if (opnd->IsMemoryAccessOperand()) {
+    RegOperand &ldDest = CreateRegisterOperandOfType(ptype);
+    Insn &insn = GetInsnBuilder()->BuildInsn(PickLdInsn(GetPrimTypeBitSize(ptype), ptype), ldDest, *opnd);
+    GetCurBB()->AppendInsn(insn);
+    opnd = &ldDest;
+  }
+  std::vector<Operand *> opndVec;
+  RegOperand *dst = &CreateRegisterOperandOfType(ptype);
+  opndVec.push_back(dst);  /* result */
+  opndVec.push_back(opnd); /* param 0 */
+  SelectLibCall(name, opndVec, ptype, ptype);
+
+  return dst;
+}
+
+Operand *AArch64CGFunc::SelectIntrinsicOpWithNParams(IntrinsicopNode &intrnNode, PrimType retType,
+                                                     const std::string &name) {
+  MapleVector<BaseNode*> argNodes = intrnNode.GetNopnd();
+  std::vector<Operand*> opndVec;
+  std::vector<PrimType> opndTypes;
+  RegOperand *retOpnd = &CreateRegisterOperandOfType(retType);
+  opndVec.push_back(retOpnd);
+  opndTypes.push_back(retType);
+
+  for (BaseNode *argexpr : argNodes) {
+    PrimType ptype = argexpr->GetPrimType();
+    Operand *opnd = HandleExpr(intrnNode, *argexpr);
+    if (opnd->IsMemoryAccessOperand()) {
+      RegOperand &ldDest = CreateRegisterOperandOfType(ptype);
+      Insn &insn = GetInsnBuilder()->BuildInsn(PickLdInsn(GetPrimTypeBitSize(ptype), ptype), ldDest, *opnd);
+      GetCurBB()->AppendInsn(insn);
+      opnd = &ldDest;
+    }
+    opndVec.push_back(opnd);
+    opndTypes.push_back(ptype);
+  }
+  SelectLibCallNArg(name, opndVec, opndTypes, retType, false);
+
+  return retOpnd;
+}
+
+/* According to  gcc.target/aarch64/ffs.c */
+Operand *AArch64CGFunc::SelectAArch64ffs(Operand &argOpnd, PrimType argType) {
+  RegOperand &destOpnd = LoadIntoRegister(argOpnd, argType);
+  uint32 argSize = GetPrimTypeBitSize(argType);
+  ASSERT((argSize == k64BitSize || argSize == k32BitSize), "Unexpect arg type");
+  /* cmp */
+  ImmOperand &zeroOpnd = CreateImmOperand(0, argSize, false);
+  Operand &rflag = GetOrCreateRflag();
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+      argSize == k64BitSize ? MOP_xcmpri : MOP_wcmpri, rflag, destOpnd, zeroOpnd));
+  /* rbit */
+  RegOperand *tempResReg = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, GetPrimTypeSize(argType)));
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+      argSize == k64BitSize ? MOP_xrbit : MOP_wrbit, *tempResReg, destOpnd));
+  /* clz */
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+      argSize == k64BitSize ? MOP_xclz : MOP_wclz, *tempResReg, *tempResReg));
+  /* csincc */
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+      argSize == k64BitSize ? MOP_xcsincrrrc : MOP_wcsincrrrc,
+      *tempResReg, GetZeroOpnd(k32BitSize), *tempResReg, GetCondOperand(CC_EQ), rflag));
+  return tempResReg;
+}
+
+Operand *AArch64CGFunc::SelectRoundLibCall(RoundType roundType, const TypeCvtNode &node, Operand &opnd0) {
+  PrimType ftype = node.FromType();
+  PrimType rtype = node.GetPrimType();
+  bool is64Bits = (ftype == PTY_f64);
+  std::vector<Operand *> opndVec;
+  RegOperand *resOpnd;
+  if (is64Bits) {
+    resOpnd = &GetOrCreatePhysicalRegisterOperand(D0, k64BitSize, kRegTyFloat);
+  } else {
+    resOpnd = &GetOrCreatePhysicalRegisterOperand(S0, k32BitSize, kRegTyFloat);
+  }
+  opndVec.push_back(resOpnd);
+  RegOperand &regOpnd0 = LoadIntoRegister(opnd0, ftype);
+  opndVec.push_back(&regOpnd0);
+  std::string libName;
+  if (roundType == kCeil) {
+    libName.assign(is64Bits ? "ceil" : "ceilf");
+  } else if (roundType == kFloor) {
+    libName.assign(is64Bits ? "floor" : "floorf");
+  } else {
+    libName.assign(is64Bits ? "round" : "roundf");
+  }
+  SelectLibCall(libName, opndVec, ftype, rtype);
+
+  return resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectRoundOperator(RoundType roundType, const TypeCvtNode &node, Operand &opnd0,
+                                            const BaseNode &parent) {
+  PrimType itype = node.GetPrimType();
+  if ((mirModule.GetSrcLang() == kSrcLangC) && ((itype == PTY_f64) || (itype == PTY_f32))) {
+    SelectRoundLibCall(roundType, node, opnd0);
+  }
+  PrimType ftype = node.FromType();
+  ASSERT(((ftype == PTY_f64) || (ftype == PTY_f32)), "wrong float type");
+  bool is64Bits = (ftype == PTY_f64);
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, itype);
+  RegOperand &regOpnd0 = LoadIntoRegister(opnd0, ftype);
+  MOperator mop = MOP_undef;
+  if (roundType == kCeil) {
+    mop = is64Bits ? MOP_xvcvtps : MOP_vcvtps;
+  } else if (roundType == kFloor) {
+    mop = is64Bits ? MOP_xvcvtms : MOP_vcvtms;
+  } else {
+    mop = is64Bits ? MOP_xvcvtas : MOP_vcvtas;
+  }
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mop, resOpnd, regOpnd0));
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectCeil(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) {
+  return SelectRoundOperator(kCeil, node, opnd0, parent);
+}
+
+/* float to int floor */
+Operand *AArch64CGFunc::SelectFloor(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) {
+  return SelectRoundOperator(kFloor, node, opnd0, parent);
+}
+
+Operand *AArch64CGFunc::SelectRound(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) {
+  return SelectRoundOperator(kRound, node, opnd0, parent);
+}
+
+static bool LIsPrimitivePointer(PrimType ptype) {
+  return ((ptype >= PTY_ptr) && (ptype <= PTY_a64));
+}
+
+Operand *AArch64CGFunc::SelectRetype(TypeCvtNode &node, Operand &opnd0) {
+  PrimType fromType = node.Opnd(0)->GetPrimType();
+  PrimType toType = node.GetPrimType();
+  ASSERT(GetPrimTypeSize(fromType) == GetPrimTypeSize(toType), "retype bit widith doesn' match");
+  if (LIsPrimitivePointer(fromType) && LIsPrimitivePointer(toType)) {
+    return &LoadIntoRegister(opnd0, toType);
+  }
+  if (IsPrimitiveVector(fromType) || IsPrimitiveVector(toType)) {
+    return &LoadIntoRegister(opnd0, toType);
+  }
+  Operand::OperandType opnd0Type = opnd0.GetKind();
+  RegOperand *resOpnd = &CreateRegisterOperandOfType(toType);
+  if (IsPrimitiveInteger(fromType) || IsPrimitiveFloat(fromType)) {
+    bool isFromInt = IsPrimitiveInteger(fromType);
+    bool is64Bits = GetPrimTypeBitSize(fromType) == k64BitSize;
+    PrimType itype =
+        isFromInt ? ((GetPrimTypeBitSize(fromType) == k64BitSize) ? (IsSignedInteger(fromType) ? PTY_i64 : PTY_u64)
+                                                                  : (IsSignedInteger(fromType) ? PTY_i32 : PTY_u32))
+                  : (is64Bits ? PTY_f64 : PTY_f32);
+
+    /*
+     * if source operand is in memory,
+     * simply read it as a value of 'toType 'into the dest operand
+     * and return
+     */
+    if (opnd0Type == Operand::kOpdMem) {
+      resOpnd = &SelectCopy(opnd0, toType, toType);
+      return resOpnd;
+    }
+    /* according to aarch64 encoding format, convert int to float expression */
+    bool isImm = false;
+    ImmOperand *imm = static_cast<ImmOperand*>(&opnd0);
+    uint64 val = static_cast<uint64>(imm->GetValue());
+    uint64 canRepreset = is64Bits ? (val & 0xffffffffffff) : (val & 0x7ffff);
+    uint32 val1 = is64Bits ? (val >> 61) & 0x3 : (val >> 29) & 0x3;
+    uint32 val2 = is64Bits ? (val >> 54) & 0xff : (val >> 25) & 0x1f;
+    bool isSame = is64Bits ? ((val2 == 0) || (val2 == 0xff)) : ((val2 == 0) || (val2 == 0x1f));
+    canRepreset = (canRepreset == 0) && ((val1 & 0x1) ^ ((val1 & 0x2) >> 1)) && isSame;
+    Operand *newOpnd0 = &opnd0;
+    if (IsPrimitiveInteger(fromType) && IsPrimitiveFloat(toType) && canRepreset) {
+      uint64 temp1 = is64Bits ? (val >> 63) << 7 : (val >> 31) << 7;
+      uint64 temp2 = is64Bits ? val >> 48 : val >> 19;
+      int64 imm8 = (temp2 & 0x7f) | temp1;
+      newOpnd0 = &CreateImmOperand(imm8, k8BitSize, false, kNotVary, true);
+      isImm = true;
+    } else {
+      newOpnd0 = &LoadIntoRegister(opnd0, itype);
+    }
+    if ((IsPrimitiveFloat(fromType) && IsPrimitiveInteger(toType)) ||
+        (IsPrimitiveFloat(toType) && IsPrimitiveInteger(fromType))) {
+      MOperator mopFmov = (isImm ? static_cast<bool>(is64Bits ? MOP_xdfmovri : MOP_wsfmovri) : isFromInt) ?
+          (is64Bits ? MOP_xvmovdr : MOP_xvmovsr) : (is64Bits ? MOP_xvmovrd : MOP_xvmovrs);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mopFmov, *resOpnd, *newOpnd0));
+      return resOpnd;
+    } else {
+      return newOpnd0;
+    }
+  } else {
+    CHECK_FATAL(false, "NYI retype");
+  }
+  return nullptr;
+}
+
+void AArch64CGFunc::SelectCvtFloat2Float(Operand &resOpnd, Operand &srcOpnd, PrimType fromType, PrimType toType) {
+  Operand &opnd0 = LoadIntoRegister(srcOpnd, fromType);
+  MOperator mOp = 0;
+  switch (toType) {
+    case PTY_f32: {
+      CHECK_FATAL(fromType == PTY_f64, "unexpected cvt from type");
+      mOp = MOP_xvcvtfd;
+      break;
+    }
+    case PTY_f64: {
+      CHECK_FATAL(fromType == PTY_f32, "unexpected cvt from type");
+      mOp = MOP_xvcvtdf;
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "unexpected cvt to type");
+  }
+
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, resOpnd, opnd0));
+}
+
+/*
+ * This should be regarded only as a reference.
+ *
+ * C11 specification.
+ * 6.3.1.3 Signed and unsigned integers
+ * 1 When a value with integer type is converted to another integer
+ *  type other than _Bool, if the value can be represented by the
+ *  new type, it is unchanged.
+ * 2 Otherwise, if the new type is unsigned, the value is converted
+ *  by repeatedly adding or subtracting one more than the maximum
+ *  value that can be represented in the new type until the value
+ *  is in the range of the new type.60)
+ * 3 Otherwise, the new type is signed and the value cannot be
+ *  represented in it; either the result is implementation-defined
+ *  or an implementation-defined signal is raised.
+ */
+void AArch64CGFunc::SelectCvtInt2Int(const BaseNode *parent, Operand *&resOpnd, Operand *opnd0, PrimType fromType,
+                                     PrimType toType) {
+  uint32 fsize = GetPrimTypeBitSize(fromType);
+  if (fromType == PTY_i128 || fromType == PTY_u128) {
+    fsize = k64BitSize;
+  }
+  uint32 tsize = GetPrimTypeBitSize(toType);
+  if (toType == PTY_i128 || toType == PTY_u128) {
+    tsize = k64BitSize;
+  }
+  bool isExpand = tsize > fsize;
+  bool is64Bit = (tsize == k64BitSize);
+  if ((parent != nullptr) && opnd0->IsIntImmediate() &&
+      ((parent->GetOpCode() == OP_band) || (parent->GetOpCode() == OP_bior) || (parent->GetOpCode() == OP_bxor) ||
+       (parent->GetOpCode() == OP_ashr) || (parent->GetOpCode() == OP_lshr) || (parent->GetOpCode() == OP_shl))) {
+    ImmOperand *simm = static_cast<ImmOperand*>(opnd0);
+    ASSERT(simm != nullptr, "simm is nullptr in AArch64CGFunc::SelectCvtInt2Int");
+    bool isSign = false;
+    int64 origValue = simm->GetValue();
+    int64 newValue = origValue;
+    int64 signValue = 0;
+    if (!isExpand) {
+      /* 64--->32 */
+      if (fsize > tsize) {
+        if (IsSignedInteger(toType)) {
+          if (origValue < 0) {
+            signValue = static_cast<int64>(0xFFFFFFFFFFFFFFFFLL & (1ULL << static_cast<uint32>(tsize)));
+          }
+          newValue = static_cast<int64>((static_cast<uint64>(origValue) & ((1ULL << static_cast<uint32>(tsize)) - 1u)) |
+                     static_cast<uint64>(signValue));
+        } else {
+          newValue = static_cast<uint64>(origValue) & ((1ULL << static_cast<uint32>(tsize)) - 1u);
+        }
+      }
+    }
+    if (IsSignedInteger(toType)) {
+      isSign = true;
+    }
+    resOpnd = &static_cast<Operand&>(CreateImmOperand(newValue, GetPrimTypeSize(toType) * kBitsPerByte, isSign));
+    return;
+  }
+  if (isExpand) {  /* Expansion */
+    /* if cvt expr's parent is add,and,xor and some other,we can use the imm version */
+    PrimType primType =
+      ((fsize == k64BitSize) ? (IsSignedInteger(fromType) ? PTY_i64 : PTY_u64) : (IsSignedInteger(fromType) ?
+                                                                                PTY_i32 : PTY_u32));
+    opnd0 = &LoadIntoRegister(*opnd0, primType);
+
+    if (IsSignedInteger(fromType)) {
+      ASSERT((is64Bit || (fsize == k8BitSize || fsize == k16BitSize)), "incorrect from size");
+
+      MOperator mOp =
+          (is64Bit ? ((fsize == k8BitSize) ? MOP_xsxtb64 : ((fsize == k16BitSize) ? MOP_xsxth64 : MOP_xsxtw64))
+                   : ((fsize == k8BitSize) ? MOP_xsxtb32 : MOP_xsxth32));
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, *resOpnd, *opnd0));
+    } else {
+      /* Unsigned */
+      if (is64Bit) {
+        if (fsize == k8BitSize) {
+          ImmOperand &immOpnd = CreateImmOperand(0xff, k64BitSize, false);
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xandrri13, *resOpnd, *opnd0, immOpnd));
+        } else if (fsize == k16BitSize) {
+          ImmOperand &immOpnd = CreateImmOperand(0xffff, k64BitSize, false);
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xandrri13, *resOpnd, *opnd0, immOpnd));
+        } else {
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xuxtw64, *resOpnd, *opnd0));
+        }
+      } else {
+        ASSERT(((fsize == k8BitSize) || (fsize == k16BitSize)), "incorrect from size");
+        if (fsize == k8BitSize) {
+          static_cast<RegOperand*>(opnd0)->SetValidBitsNum(k8BitSize);
+          static_cast<RegOperand*>(resOpnd)->SetValidBitsNum(k8BitSize);
+        }
+        if (fromType == PTY_u1) {
+          static_cast<RegOperand*>(opnd0)->SetValidBitsNum(1);
+          static_cast<RegOperand*>(resOpnd)->SetValidBitsNum(1);
+        }
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+            (fsize == k8BitSize) ? MOP_xuxtb32 : MOP_xuxth32, *resOpnd, *opnd0));
+      }
+    }
+  } else {  /* Same size or truncate */
+#ifdef CNV_OPTIMIZE
+    /*
+     * No code needed for aarch64 with same reg.
+     * Just update regno.
+     */
+    RegOperand *reg = static_cast<RegOperand*>(resOpnd);
+    reg->regNo = static_cast<RegOperand*>(opnd0)->regNo;
+#else
+    /*
+     *  This is not really needed if opnd0 is result from a load.
+     * Hopefully the FE will get rid of the redundant conversions for loads.
+     */
+    PrimType primType = ((fsize == k64BitSize) ? (IsSignedInteger(fromType) ? PTY_i64 : PTY_u64)
+                                               : (IsSignedInteger(fromType) ? PTY_i32 : PTY_u32));
+    opnd0 = &LoadIntoRegister(*opnd0, primType);
+
+    if (fsize > tsize) {
+      if (tsize == k8BitSize) {
+        MOperator mOp = IsSignedInteger(toType) ? MOP_xsxtb32 : MOP_xuxtb32;
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, *resOpnd, *opnd0));
+      } else if (tsize == k16BitSize) {
+        MOperator mOp = IsSignedInteger(toType) ? MOP_xsxth32 : MOP_xuxth32;
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, *resOpnd, *opnd0));
+      } else {
+        MOperator mOp = IsSignedInteger(toType) ? MOP_xsbfxrri6i6 : MOP_xubfxrri6i6;
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, *resOpnd, *opnd0,
+                                                                      CreateImmOperand(0, k8BitSize, false),
+                                                                      CreateImmOperand(tsize, k8BitSize, false)));
+      }
+    } else {
+      /* same size, so resOpnd can be set */
+      if ((mirModule.IsJavaModule()) || (IsSignedInteger(fromType) == IsSignedInteger(toType)) ||
+          (GetPrimTypeSize(toType) >= k4BitSize)) {
+        resOpnd = opnd0;
+      } else if (IsUnsignedInteger(toType)) {
+        MOperator mop;
+        switch (toType) {
+          case PTY_u8:
+            mop = MOP_xuxtb32;
+            break;
+          case PTY_u16:
+            mop = MOP_xuxth32;
+            break;
+          default:
+            CHECK_FATAL(false, "Unhandled unsigned convert");
+        }
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mop, *resOpnd, *opnd0));
+      } else {
+        /* signed target */
+        uint32 size = GetPrimTypeSize(toType);
+        MOperator mop;
+        switch (toType) {
+          case PTY_i8:
+            mop = (size > k4BitSize) ? MOP_xsxtb64 : MOP_xsxtb32;
+            break;
+          case PTY_i16:
+            mop = (size > k4BitSize) ? MOP_xsxth64 : MOP_xsxth32;
+            break;
+          default:
+            CHECK_FATAL(0, "Unhandled unsigned convert");
+        }
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mop, *resOpnd, *opnd0));
+      }
+    }
+#endif
+  }
+}
+
+Operand *AArch64CGFunc::SelectCvt(const BaseNode &parent, TypeCvtNode &node, Operand &opnd0) {
+  PrimType fromType = node.FromType();
+  PrimType toType = node.GetPrimType();
+  if (fromType == toType) {
+    return &opnd0;  /* noop */
+  }
+  Operand *resOpnd = &GetOrCreateResOperand(parent, toType);
+  if (IsPrimitiveFloat(toType) && IsPrimitiveInteger(fromType)) {
+    SelectCvtInt2Float(*resOpnd, opnd0, toType, fromType);
+  } else if (IsPrimitiveFloat(fromType) && IsPrimitiveInteger(toType)) {
+    SelectCvtFloat2Int(*resOpnd, opnd0, toType, fromType);
+  } else if (IsPrimitiveInteger(fromType) && IsPrimitiveInteger(toType)) {
+    SelectCvtInt2Int(&parent, resOpnd, &opnd0, fromType, toType);
+  } else if (IsPrimitiveVector(toType) || IsPrimitiveVector(fromType)) {
+    CHECK_FATAL(IsPrimitiveVector(toType) && IsPrimitiveVector(fromType), "Invalid vector cvt operands");
+    SelectVectorCvt(resOpnd, toType, &opnd0, fromType);
+  } else {  /* both are float type */
+    SelectCvtFloat2Float(*resOpnd, opnd0, fromType, toType);
+  }
+  return resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectTrunc(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) {
+  PrimType ftype = node.FromType();
+  bool is64Bits = (GetPrimTypeBitSize(node.GetPrimType()) == k64BitSize);
+  PrimType itype = (is64Bits) ? (IsSignedInteger(node.GetPrimType()) ? PTY_i64 : PTY_u64)
+                              : (IsSignedInteger(node.GetPrimType()) ? PTY_i32 : PTY_u32);  /* promoted type */
+  RegOperand &resOpnd = GetOrCreateResOperand(parent, itype);
+  SelectCvtFloat2Int(resOpnd, opnd0, itype, ftype);
+  return &resOpnd;
+}
+
+void AArch64CGFunc::SelectSelect(Operand &resOpnd, Operand &condOpnd, Operand &trueOpnd, Operand &falseOpnd,
+                                 PrimType dtype, PrimType ctype, bool hasCompare, ConditionCode cc) {
+  ASSERT(&resOpnd != &condOpnd, "resOpnd cannot be the same as condOpnd");
+  bool isIntType = IsPrimitiveInteger(dtype);
+  ASSERT((IsPrimitiveInteger(dtype) || IsPrimitiveFloat(dtype)), "unknown type for select");
+  // making condOpnd and cmpInsn closer will provide more opportunity for opt
+  Operand &newTrueOpnd = LoadIntoRegister(trueOpnd, dtype);
+  Operand &newFalseOpnd = LoadIntoRegister(falseOpnd, dtype);
+  Operand &newCondOpnd = LoadIntoRegister(condOpnd, ctype);
+  if (hasCompare) {
+    SelectAArch64Cmp(newCondOpnd, CreateImmOperand(0, ctype, false), true, GetPrimTypeBitSize(ctype));
+    cc = CC_NE;
+  }
+  Operand &newResOpnd = LoadIntoRegister(resOpnd, dtype);
+  SelectAArch64Select(newResOpnd, newTrueOpnd, newFalseOpnd,
+                      GetCondOperand(cc), isIntType, GetPrimTypeBitSize(dtype));
+}
+
+Operand *AArch64CGFunc::SelectSelect(TernaryNode &node, Operand &opnd0, Operand &trueOpnd, Operand &falseOpnd,
+                                     const BaseNode &parent, bool hasCompare) {
+  PrimType dtype = node.GetPrimType();
+  PrimType ctype = node.Opnd(0)->GetPrimType();
+
+  ConditionCode cc = CC_NE;
+  Opcode opcode = node.Opnd(0)->GetOpCode();
+  PrimType cmpType = static_cast<CompareNode *>(node.Opnd(0))->GetOpndType();
+  bool isFloat = false;
+  bool unsignedIntegerComparison = false;
+  if (!IsPrimitiveVector(cmpType)) {
+    isFloat = IsPrimitiveFloat(cmpType);
+    unsignedIntegerComparison = !isFloat && !IsSignedInteger(cmpType);
+  } else {
+    isFloat = IsPrimitiveVectorFloat(cmpType);
+    unsignedIntegerComparison = !isFloat && IsPrimitiveUnSignedVector(cmpType);
+  }
+  switch (opcode) {
+    case OP_eq:
+      cc = CC_EQ;
+      break;
+    case OP_ne:
+      cc = CC_NE;
+      break;
+    case OP_le:
+      cc = unsignedIntegerComparison ? CC_LS : CC_LE;
+      break;
+    case OP_ge:
+      cc = unsignedIntegerComparison ? CC_HS : CC_GE;
+      break;
+    case OP_gt:
+      cc = unsignedIntegerComparison ? CC_HI : CC_GT;
+      break;
+    case OP_lt:
+      cc = unsignedIntegerComparison ? CC_LO : CC_LT;
+      break;
+    default:
+      hasCompare = true;
+      break;
+  }
+  if (!IsPrimitiveVector(dtype)) {
+    RegOperand &resOpnd = GetOrCreateResOperand(parent, dtype);
+    SelectSelect(resOpnd, opnd0, trueOpnd, falseOpnd, dtype, ctype, hasCompare, cc);
+    return &resOpnd;
+  } else {
+    return SelectVectorSelect(opnd0, dtype, trueOpnd, falseOpnd);
+  }
+}
+
+/*
+ * syntax: select <prim-type> (<opnd0>, <opnd1>, <opnd2>)
+ * <opnd0> must be of integer type.
+ * <opnd1> and <opnd2> must be of the type given by <prim-type>.
+ * If <opnd0> is not 0, return <opnd1>.  Otherwise, return <opnd2>.
+ */
+void AArch64CGFunc::SelectAArch64Select(Operand &dest, Operand &opnd0, Operand &opnd1, CondOperand &cond,
+                                        bool isIntType, uint32 is64bits) {
+  uint32 mOpCode = isIntType ? ((is64bits == k64BitSize) ? MOP_xcselrrrc : MOP_wcselrrrc)
+                             : ((is64bits == k64BitSize) ? MOP_dcselrrrc
+                                                      : ((is64bits == k32BitSize) ? MOP_scselrrrc : MOP_hcselrrrc));
+  Operand &rflag = GetOrCreateRflag();
+  if (opnd1.IsImmediate()) {
+    uint32 movOp = (is64bits == k64BitSize ? MOP_xmovri64 : MOP_wmovri32);
+    RegOperand &movDest = CreateVirtualRegisterOperand(
+        NewVReg(kRegTyInt, (is64bits == k64BitSize) ? k8ByteSize : k4ByteSize));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(movOp, movDest, opnd1));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, dest, opnd0, movDest, cond, rflag));
+    return;
+  }
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOpCode, dest, opnd0, opnd1, cond, rflag));
+}
+
+void AArch64CGFunc::SelectRangeGoto(RangeGotoNode &rangeGotoNode, Operand &srcOpnd) {
+  const SmallCaseVector &switchTable = rangeGotoNode.GetRangeGotoTable();
+  MIRType *etype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_a64));
+  /*
+   * we store 8-byte displacement ( jump_label - offset_table_address )
+   * in the table. Refer to AArch64Emit::Emit() in aarch64emit.cpp
+   */
+  std::vector<uint32> sizeArray;
+  sizeArray.emplace_back(switchTable.size());
+  MIRArrayType *arrayType = memPool->New<MIRArrayType>(etype->GetTypeIndex(), sizeArray);
+  MIRAggConst *arrayConst = memPool->New<MIRAggConst>(mirModule, *arrayType);
+  for (const auto &itPair : switchTable) {
+    LabelIdx labelIdx = itPair.second;
+    GetCurBB()->PushBackRangeGotoLabel(labelIdx);
+    MIRConst *mirConst = memPool->New<MIRLblConst>(labelIdx, GetFunction().GetPuidx(), *etype);
+    arrayConst->AddItem(mirConst, 0);
+  }
+
+  MIRSymbol *lblSt = GetFunction().GetSymTab()->CreateSymbol(kScopeLocal);
+  lblSt->SetStorageClass(kScFstatic);
+  lblSt->SetSKind(kStConst);
+  lblSt->SetTyIdx(arrayType->GetTypeIndex());
+  lblSt->SetKonst(arrayConst);
+  std::string lblStr(".LB_");
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(GetFunction().GetStIdx().Idx());
+  uint32 labelIdxTmp = GetLabelIdx();
+  lblStr.append(funcSt->GetName()).append(std::to_string(labelIdxTmp++));
+  SetLabelIdx(labelIdxTmp);
+  lblSt->SetNameStrIdx(lblStr);
+  AddEmitSt(GetCurBB()->GetId(), *lblSt);
+
+  PrimType itype = rangeGotoNode.Opnd(0)->GetPrimType();
+  Operand &opnd0 = LoadIntoRegister(srcOpnd, itype);
+
+  regno_t vRegNO = NewVReg(kRegTyInt, 8u);
+  RegOperand *addOpnd = &CreateVirtualRegisterOperand(vRegNO);
+
+  int32 minIdx = switchTable[0].first;
+  SelectAdd(*addOpnd, opnd0,
+            CreateImmOperand(-static_cast<int64>(minIdx) - static_cast<int64>(rangeGotoNode.GetTagOffset()),
+                             GetPrimTypeBitSize(itype), true),
+            itype);
+
+  /* contains the index */
+  if (addOpnd->GetSize() != GetPrimTypeBitSize(PTY_u64)) {
+    addOpnd = static_cast<RegOperand*>(&SelectCopy(*addOpnd, PTY_u64, PTY_u64));
+  }
+
+  RegOperand &baseOpnd = CreateRegisterOperandOfType(PTY_u64);
+  StImmOperand &stOpnd = CreateStImmOperand(*lblSt, 0, 0);
+
+  /* load the address of the switch table */
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrp, baseOpnd, stOpnd));
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrpl12, baseOpnd, baseOpnd, stOpnd));
+
+  /* load the displacement into a register by accessing memory at base + index*8 */
+  Operand *disp =
+      CreateMemOperand(MemOperand::kAddrModeBOrX, k64BitSize, baseOpnd, *addOpnd, k8BitShift);
+  RegOperand &tgt = CreateRegisterOperandOfType(PTY_a64);
+  SelectAdd(tgt, baseOpnd, *disp, PTY_u64);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xbr, tgt));
+}
+
+Operand *AArch64CGFunc::SelectLazyLoad(Operand &opnd0, PrimType primType) {
+  ASSERT(opnd0.IsRegister(), "wrong type.");
+  RegOperand &resOpnd = CreateRegisterOperandOfType(primType);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_lazy_ldr, resOpnd, opnd0));
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectLazyLoadStatic(MIRSymbol &st, int64 offset, PrimType primType) {
+  StImmOperand &srcOpnd = CreateStImmOperand(st, offset, 0);
+  RegOperand &resOpnd = CreateRegisterOperandOfType(primType);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_lazy_ldr_static, resOpnd, srcOpnd));
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectLoadArrayClassCache(MIRSymbol &st, int64 offset, PrimType primType) {
+  StImmOperand &srcOpnd = CreateStImmOperand(st, offset, 0);
+  RegOperand &resOpnd = CreateRegisterOperandOfType(primType);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_arrayclass_cache_ldr, resOpnd, srcOpnd));
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectAlloca(UnaryNode &node, Operand &opnd0) {
+  if (!CGOptions::IsArm64ilp32()) {
+    ASSERT((node.GetPrimType() == PTY_a64), "wrong type");
+  }
+  if (GetCG()->IsLmbc()) {
+    SetHasVLAOrAlloca(true);
+  }
+  PrimType stype = node.Opnd(0)->GetPrimType();
+  Operand *resOpnd = &opnd0;
+  if (GetPrimTypeBitSize(stype) < GetPrimTypeBitSize(PTY_u64)) {
+    resOpnd = &CreateRegisterOperandOfType(PTY_u64);
+    SelectCvtInt2Int(nullptr, resOpnd, &opnd0, stype, PTY_u64);
+  }
+
+  RegOperand &aliOp = CreateRegisterOperandOfType(PTY_u64);
+
+  SelectAdd(aliOp, *resOpnd, CreateImmOperand(kAarch64StackPtrAlignment - 1, k64BitSize, true), PTY_u64);
+  Operand &shifOpnd = CreateImmOperand(__builtin_ctz(kAarch64StackPtrAlignment), k64BitSize, true);
+  SelectShift(aliOp, aliOp, shifOpnd, kShiftLright, PTY_u64);
+  SelectShift(aliOp, aliOp, shifOpnd, kShiftLeft, PTY_u64);
+  Operand &spOpnd = GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+  SelectSub(spOpnd, spOpnd, aliOp, PTY_u64);
+  int64 allocaOffset = GetMemlayout()->SizeOfArgsToStackPass();
+  if (GetCG()->IsLmbc()) {
+    allocaOffset -= kDivide2 * k8ByteSize;
+  }
+  if (allocaOffset > 0) {
+    RegOperand &resallo = CreateRegisterOperandOfType(PTY_u64);
+    SelectAdd(resallo, spOpnd, CreateImmOperand(allocaOffset, k64BitSize, true), PTY_u64);
+    return &resallo;
+  } else {
+    return &SelectCopy(spOpnd, PTY_u64, PTY_u64);
+  }
+}
+
+Operand *AArch64CGFunc::SelectMalloc(UnaryNode &node, Operand &opnd0) {
+  PrimType retType = node.GetPrimType();
+  ASSERT((retType == PTY_a64), "wrong type");
+
+  std::vector<Operand*> opndVec;
+  RegOperand &resOpnd = CreateRegisterOperandOfType(retType);
+  opndVec.emplace_back(&resOpnd);
+  opndVec.emplace_back(&opnd0);
+  /* Use calloc to make sure allocated memory is zero-initialized */
+  const std::string &funcName = "calloc";
+  PrimType srcPty = PTY_u64;
+  if (opnd0.GetSize() <= k32BitSize) {
+    srcPty = PTY_u32;
+  }
+  Operand &opnd1 = CreateImmOperand(1, srcPty, false);
+  opndVec.emplace_back(&opnd1);
+  SelectLibCall(funcName, opndVec, srcPty, retType);
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectGCMalloc(GCMallocNode &node) {
+  PrimType retType = node.GetPrimType();
+  ASSERT((retType == PTY_a64), "wrong type");
+
+  /* Get the size and alignment of the type. */
+  TyIdx tyIdx = node.GetTyIdx();
+  uint64 size = GetBecommon().GetTypeSize(tyIdx);
+  int64 align = static_cast<int64>(RTSupport::GetRTSupportInstance().GetObjectAlignment());
+
+  /* Generate the call to MCC_NewObj */
+  Operand &opndSize = CreateImmOperand(static_cast<int64>(size), k64BitSize, false);
+  Operand &opndAlign = CreateImmOperand(align, k64BitSize, false);
+
+  RegOperand &resOpnd = CreateRegisterOperandOfType(retType);
+
+  std::vector<Operand*> opndVec{ &resOpnd, &opndSize, &opndAlign };
+
+  const std::string &funcName = "MCC_NewObj";
+  SelectLibCall(funcName, opndVec, PTY_u64, retType);
+
+  return &resOpnd;
+}
+
+Operand *AArch64CGFunc::SelectJarrayMalloc(JarrayMallocNode &node, Operand &opnd0) {
+  PrimType retType = node.GetPrimType();
+  ASSERT((retType == PTY_a64), "wrong type");
+
+  /* Extract jarray type */
+  TyIdx tyIdx = node.GetTyIdx();
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  ASSERT(type != nullptr, "nullptr check");
+  CHECK_FATAL(type->GetKind() == kTypeJArray, "expect MIRJarrayType");
+  auto jaryType = static_cast<MIRJarrayType*>(type);
+  uint64 fixedSize = static_cast<uint64>(RTSupport::GetRTSupportInstance().GetArrayContentOffset());
+
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(jaryType->GetElemTyIdx());
+  PrimType elemPrimType = elemType->GetPrimType();
+  uint64 elemSize = GetPrimTypeSize(elemPrimType);
+
+  /* Generate the cal to MCC_NewObj_flexible */
+  Operand &opndFixedSize = CreateImmOperand(PTY_u64, static_cast<int64>(fixedSize));
+  Operand &opndElemSize = CreateImmOperand(PTY_u64, static_cast<int64>(elemSize));
+
+  Operand *opndNElems = &opnd0;
+
+  Operand *opndNElems64 = &static_cast<Operand&>(CreateRegisterOperandOfType(PTY_u64));
+  SelectCvtInt2Int(nullptr, opndNElems64, opndNElems, PTY_u32, PTY_u64);
+
+  Operand &opndAlign = CreateImmOperand(PTY_u64,
+      static_cast<int64>(RTSupport::GetRTSupportInstance().GetObjectAlignment()));
+
+  RegOperand &resOpnd = CreateRegisterOperandOfType(retType);
+
+  std::vector<Operand*> opndVec{ &resOpnd, &opndFixedSize, &opndElemSize, opndNElems64, &opndAlign };
+
+  const std::string &funcName = "MCC_NewObj_flexible";
+  SelectLibCall(funcName, opndVec, PTY_u64, retType);
+
+  /* Generate the store of the object length field */
+  MemOperand &opndArrayLengthField = CreateMemOpnd(resOpnd,
+      static_cast<int64>(RTSupport::GetRTSupportInstance().GetArrayLengthOffset()), k4BitSize);
+  RegOperand *regOpndNElems = &SelectCopy(*opndNElems, PTY_u32, PTY_u32);
+  ASSERT(regOpndNElems != nullptr, "null ptr check!");
+  SelectCopy(opndArrayLengthField, PTY_u32, *regOpndNElems, PTY_u32);
+
+  return &resOpnd;
+}
+
+bool AArch64CGFunc::IsRegRematCand(const RegOperand &reg) const {
+  MIRPreg *preg = GetPseudoRegFromVirtualRegNO(reg.GetRegisterNumber(), CGOptions::DoCGSSA());
+  if (preg != nullptr && preg->GetOp() != OP_undef) {
+    if (preg->GetOp() == OP_constval && cg->GetRematLevel() >= 1) {
+      return true;
+    } else if (preg->GetOp() == OP_addrof && cg->GetRematLevel() >= 2) {
+      return true;
+    } else if (preg->GetOp() == OP_iread && cg->GetRematLevel() >= 4) {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+
+void AArch64CGFunc::ClearRegRematInfo(const RegOperand &reg) const {
+  MIRPreg *preg = GetPseudoRegFromVirtualRegNO(reg.GetRegisterNumber(), CGOptions::DoCGSSA());
+  if (preg != nullptr && preg->GetOp() != OP_undef) {
+    preg->SetOp(OP_undef);
+  }
+}
+
+bool AArch64CGFunc::IsRegSameRematInfo(const RegOperand &regDest, const RegOperand &regSrc) const {
+  MIRPreg *pregDest = GetPseudoRegFromVirtualRegNO(regDest.GetRegisterNumber(), CGOptions::DoCGSSA());
+  MIRPreg *pregSrc = GetPseudoRegFromVirtualRegNO(regSrc.GetRegisterNumber(), CGOptions::DoCGSSA());
+  if (pregDest != nullptr && pregDest == pregSrc) {
+    if (pregDest->GetOp() == OP_constval && cg->GetRematLevel() >= 1) {
+      return true;
+    } else if (pregDest->GetOp() == OP_addrof && cg->GetRematLevel() >= 2) {
+      return true;
+    } else if (pregDest->GetOp() == OP_iread && cg->GetRematLevel() >= 4) {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+
+void AArch64CGFunc::ReplaceOpndInInsn(RegOperand &regDest, RegOperand &regSrc, Insn &insn, regno_t destNO) {
+  auto opndNum = static_cast<int32>(insn.GetOperandSize());
+  for (int i = opndNum - 1; i >= 0; --i) {
+    Operand &opnd = insn.GetOperand(static_cast<uint32>(i));
+    if (opnd.IsList()) {
+      std::list<RegOperand*> tempRegStore;
+      auto& opndList = static_cast<ListOperand&>(opnd).GetOperands();
+      bool needReplace = false;
+      for (auto it = opndList.cbegin(), end = opndList.cend(); it != end; ++it) {
+        auto *regOpnd = *it;
+        if (regOpnd->GetRegisterNumber() == destNO) {
+          needReplace = true;
+          if (regDest.GetSize() != regSrc.GetSize()) {
+            regDest.SetRegisterNumber(regSrc.GetRegisterNumber());
+            tempRegStore.push_back(&regDest);
+          } else {
+            tempRegStore.push_back(&regSrc);
+          }
+        } else {
+          tempRegStore.push_back(regOpnd);
+        }
+      }
+      if (needReplace) {
+        opndList.clear();
+        for (auto &newOpnd : std::as_const(tempRegStore)) {
+          static_cast<ListOperand &>(opnd).PushOpnd(*newOpnd);
+        }
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      RegOperand *baseRegOpnd = memOpnd.GetBaseRegister();
+      RegOperand *indexRegOpnd = memOpnd.GetIndexRegister();
+      MemOperand *newMem = static_cast<MemOperand*>(memOpnd.Clone(*GetMemoryPool()));
+      if ((baseRegOpnd != nullptr && baseRegOpnd->GetRegisterNumber() == destNO) ||
+          (indexRegOpnd != nullptr && indexRegOpnd->GetRegisterNumber() == destNO)) {
+        if (baseRegOpnd != nullptr && baseRegOpnd->GetRegisterNumber() == destNO) {
+          if (regDest.GetSize() != regSrc.GetSize()) {
+            regDest.SetRegisterNumber(regSrc.GetRegisterNumber());
+            newMem->SetBaseRegister(regDest);
+          } else {
+            newMem->SetBaseRegister(regSrc);
+          }
+        }
+        if (indexRegOpnd != nullptr && indexRegOpnd->GetRegisterNumber() == destNO) {
+          if (regDest.GetSize() != regSrc.GetSize()) {
+            regDest.SetRegisterNumber(regSrc.GetRegisterNumber());
+            newMem->SetIndexRegister(regDest);
+          } else {
+            newMem->SetIndexRegister(regSrc);
+          }
+        }
+        insn.SetMemOpnd(&GetOrCreateMemOpnd(*newMem));
+      }
+    } else if (opnd.IsRegister()) {
+      auto &regOpnd = static_cast<RegOperand&>(opnd);
+      if (regOpnd.GetRegisterNumber() == destNO) {
+        ASSERT(regOpnd.GetRegisterNumber() != kRFLAG, "both condi and reg");
+        if (regDest.GetSize() != regSrc.GetSize()) {
+          regOpnd.SetRegisterNumber(regSrc.GetRegisterNumber());
+        } else {
+          insn.SetOperand(static_cast<uint32>(i), regSrc);
+        }
+      }
+    }
+  }
+}
+
+void AArch64CGFunc::CleanupDeadMov(bool dumpInfo) {
+  /* clean dead mov. */
+  FOR_ALL_BB(bb, this) {
+    FOR_BB_INSNS_SAFE(insn, bb, ninsn) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (insn->GetMachineOpcode() == MOP_xmovrr || insn->GetMachineOpcode() == MOP_wmovrr ||
+          insn->GetMachineOpcode() == MOP_xvmovs || insn->GetMachineOpcode() == MOP_xvmovd) {
+        RegOperand &regDest = static_cast<RegOperand &>(insn->GetOperand(kInsnFirstOpnd));
+        RegOperand &regSrc = static_cast<RegOperand &>(insn->GetOperand(kInsnSecondOpnd));
+        if (!regSrc.IsVirtualRegister() || !regDest.IsVirtualRegister()) {
+          continue;
+        }
+
+        if (regSrc.GetRegisterNumber() == regDest.GetRegisterNumber()) {
+          bb->RemoveInsn(*insn);
+        } else if (insn->IsPhiMovInsn() && dumpInfo) {
+          LogInfo::MapleLogger() << "fail to remove mov: " << regDest.GetRegisterNumber() << " <- "
+              << regSrc.GetRegisterNumber() << std::endl;
+        }
+      }
+    }
+  }
+}
+
+void AArch64CGFunc::GetRealCallerSaveRegs(const Insn &insn, std::set<regno_t> &realSaveRegs) {
+  auto *targetOpnd = insn.GetCallTargetOperand();
+  CHECK_FATAL(targetOpnd != nullptr, "target is null in AArch64Insn::IsCallToFunctionThatNeverReturns");
+  if (CGOptions::DoIPARA() && targetOpnd->IsFuncNameOpnd()) {
+    FuncNameOperand *target = static_cast<FuncNameOperand*>(targetOpnd);
+    const MIRSymbol *funcSt = target->GetFunctionSymbol();
+    ASSERT(funcSt->GetSKind() == kStFunc, "funcst must be a function name symbol");
+    MIRFunction *func = funcSt->GetFunction();
+    if (func != nullptr && func->IsReferedRegsValid()) {
+      for (auto preg : func->GetReferedRegs()) {
+        if (AArch64Abi::IsCallerSaveReg(static_cast<AArch64reg>(preg))) {
+          realSaveRegs.insert(preg);
+        }
+      }
+      return;
+    }
+  }
+  for (uint32 i = R0; i <= kMaxRegNum; ++i) {
+    if (AArch64Abi::IsCallerSaveReg(static_cast<AArch64reg>(i))) {
+      realSaveRegs.insert(i);
+    }
+  }
+}
+
+RegOperand &AArch64CGFunc::GetZeroOpnd(uint32 bitLen) {
+  /*
+   * It is possible to have a bitLen < 32, eg stb.
+   * Set it to 32 if it is less than 32.
+  */
+  if (bitLen < k32BitSize) {
+    bitLen = k32BitSize;
+  }
+  ASSERT((bitLen == k32BitSize || bitLen == k64BitSize), "illegal bit length = %d", bitLen);
+  return (bitLen == k32BitSize) ? GetOrCreatePhysicalRegisterOperand(RZR, k32BitSize, kRegTyInt) :
+      GetOrCreatePhysicalRegisterOperand(RZR, k64BitSize, kRegTyInt);
+}
+
+bool AArch64CGFunc::IsFrameReg(const RegOperand &opnd) const {
+  if (opnd.GetRegisterNumber() == RFP) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool AArch64CGFunc::IsSaveReg(const RegOperand &reg, MIRType &mirType, BECommon &cgBeCommon) const {
+  AArch64CallConvImpl retLocator(cgBeCommon);
+  CCLocInfo retMechanism;
+  retLocator.InitReturnInfo(mirType, retMechanism);
+  if (retMechanism.GetRegCount() > 0) {
+    return reg.GetRegisterNumber() == retMechanism.GetReg0() || reg.GetRegisterNumber() == retMechanism.GetReg1() ||
+        reg.GetRegisterNumber() == retMechanism.GetReg2() || reg.GetRegisterNumber() == retMechanism.GetReg3();
+  }
+  return false;
+}
+
+bool AArch64CGFunc::IsSPOrFP(const RegOperand &opnd) const {
+  const RegOperand &regOpnd = static_cast<const RegOperand&>(opnd);
+  regno_t regNO = opnd.GetRegisterNumber();
+  return (regOpnd.IsPhysicalRegister() &&
+    (regNO == RSP || regNO == RFP || (regNO == R29 && CGOptions::UseFramePointer())));
+}
+
+bool AArch64CGFunc::IsReturnReg(const RegOperand &opnd) const {
+  regno_t regNO = opnd.GetRegisterNumber();
+  return (regNO == R0) || (regNO == V0);
+}
+
+/*
+ * This function returns true to indicate that the clean up code needs to be generated,
+ * otherwise it does not need. In GCOnly mode, it always returns false.
+ */
+bool AArch64CGFunc::NeedCleanup() {
+  if (CGOptions::IsGCOnly()) {
+    return false;
+  }
+  AArch64MemLayout *layout = static_cast<AArch64MemLayout*>(GetMemlayout());
+  if (layout->GetSizeOfRefLocals() > 0) {
+    return true;
+  }
+  for (uint32 i = 0; i < GetFunction().GetFormalCount(); i++) {
+    TypeAttrs ta = GetFunction().GetNthParamAttr(i);
+    if (ta.GetAttr(ATTR_localrefvar)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/*
+ * bb must be the cleanup bb.
+ * this function must be invoked before register allocation.
+ * extended epilogue is specific for fast exception handling and is made up of
+ * clean up code and epilogue.
+ * clean up code is generated here while epilogue is generated in GeneratePrologEpilog()
+ */
+void AArch64CGFunc::GenerateCleanupCodeForExtEpilog(BB &bb) {
+  ASSERT(GetLastBB()->GetPrev()->GetFirstStmt() == GetCleanupLabel(), "must be");
+
+  if (!NeedCleanup()) {
+    return;
+  }
+  /* this is necessary for code insertion. */
+  SetCurBB(bb);
+
+  RegOperand &regOpnd0 =
+    GetOrCreatePhysicalRegisterOperand(R0, GetPointerSize() * kBitsPerByte, GetRegTyFromPrimTy(PTY_a64));
+  RegOperand &regOpnd1 =
+    GetOrCreatePhysicalRegisterOperand(R1, GetPointerSize() * kBitsPerByte, GetRegTyFromPrimTy(PTY_a64));
+  /* allocate 16 bytes to store reg0 and reg1 (each reg has 8 bytes) */
+  MemOperand &frameAlloc = CreateCallFrameOperand(-16, GetPointerSize() * kBitsPerByte);
+  Insn &allocInsn = GetInsnBuilder()->BuildInsn(MOP_xstp, regOpnd0, regOpnd1, frameAlloc);
+  allocInsn.SetDoNotRemove(true);
+  AppendInstructionTo(allocInsn, *this);
+
+  /* invoke MCC_CleanupLocalStackRef(). */
+  HandleRCCall(false);
+  /* deallocate 16 bytes which used to store reg0 and reg1 */
+  MemOperand &frameDealloc = CreateCallFrameOperand(16, GetPointerSize() * kBitsPerByte);
+  GenRetCleanup(cleanEANode, true);
+  Insn &deallocInsn = GetInsnBuilder()->BuildInsn(MOP_xldp, regOpnd0, regOpnd1, frameDealloc);
+  deallocInsn.SetDoNotRemove(true);
+  AppendInstructionTo(deallocInsn, *this);
+
+  CHECK_FATAL(GetCurBB() == &bb, "cleanup BB can't be splitted, it is only one cleanup BB");
+}
+
+/*
+ * bb must be the cleanup bb.
+ * this function must be invoked before register allocation.
+ */
+void AArch64CGFunc::GenerateCleanupCode(BB &bb) {
+  ASSERT(GetLastBB()->GetPrev()->GetFirstStmt() == GetCleanupLabel(), "must be");
+  if (!NeedCleanup()) {
+    return;
+  }
+
+  /* this is necessary for code insertion. */
+  SetCurBB(bb);
+
+  /* R0 is lived-in for clean-up code, save R0 before invocation */
+  RegOperand &livein = GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+
+  if (!GetCG()->GenLocalRC()) {
+    /* by pass local RC operations. */
+  } else if (Globals::GetInstance()->GetOptimLevel() > CGOptions::kLevel0) {
+    regno_t vreg = NewVReg(GetRegTyFromPrimTy(PTY_a64), GetPrimTypeSize(PTY_a64));
+    RegOperand &backupRegOp = CreateVirtualRegisterOperand(vreg);
+    backupRegOp.SetRegNotBBLocal();
+    SelectCopy(backupRegOp, PTY_a64, livein, PTY_a64);
+
+    /* invoke MCC_CleanupLocalStackRef(). */
+    HandleRCCall(false);
+    SelectCopy(livein, PTY_a64, backupRegOp, PTY_a64);
+  } else {
+    /*
+     * Register Allocation for O0 can not handle this case, so use a callee saved register directly.
+     * If yieldpoint is enabled, we use R20 instead R19.
+     */
+    AArch64reg backupRegNO = GetCG()->GenYieldPoint() ? R20 : R19;
+    RegOperand &backupRegOp = GetOrCreatePhysicalRegisterOperand(backupRegNO, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+    SelectCopy(backupRegOp, PTY_a64, livein, PTY_a64);
+    /* invoke MCC_CleanupLocalStackRef(). */
+    HandleRCCall(false);
+    SelectCopy(livein, PTY_a64, backupRegOp, PTY_a64);
+  }
+
+  /* invoke _Unwind_Resume */
+  std::string funcName("_Unwind_Resume");
+  MIRSymbol *sym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  sym->SetNameStrIdx(funcName);
+  sym->SetStorageClass(kScText);
+  sym->SetSKind(kStFunc);
+  ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+  srcOpnds->PushOpnd(livein);
+  AppendCall(*sym, *srcOpnds);
+  /*
+   * this instruction is unreachable, but we need it as the return address of previous
+   * "bl _Unwind_Resume" for stack unwinding.
+   */
+  Insn &nop = GetInsnBuilder()->BuildInsn(MOP_xblr, livein, *srcOpnds);
+  GetCurBB()->AppendInsn(nop);
+  GetCurBB()->SetHasCall();
+
+  CHECK_FATAL(GetCurBB() == &bb, "cleanup BB can't be splitted, it is only one cleanup BB");
+}
+
+uint32 AArch64CGFunc::FloatParamRegRequired(MIRStructType *structType, uint32 &fpSize) {
+  AArch64CallConvImpl parmlocator(GetBecommon());
+  return parmlocator.FloatParamRegRequired(*structType, fpSize);
+}
+
+/*
+ * Map param registers to formals.  For small structs passed in param registers,
+ * create a move to vreg since lmbc IR does not create a regassign for them.
+ */
+void AArch64CGFunc::AssignLmbcFormalParams() {
+  PrimType primType;
+  uint32 offset;
+  regno_t intReg = R0;
+  regno_t fpReg = V0;
+  for (auto param : GetLmbcParamVec()) {
+    primType = param->GetPrimType();
+    offset = param->GetOffset();
+    if (param->IsReturn()) {
+      param->SetRegNO(R8);
+    } else if (IsPrimitiveInteger(primType)) {
+      if (intReg > R7) {
+        param->SetRegNO(0);
+      } else {
+        param->SetRegNO(intReg);
+        if (!param->HasRegassign()) {
+          uint32 bytelen = GetPrimTypeSize(primType);
+          uint32 bitlen = bytelen * kBitsPerByte;
+          MemOperand *mOpnd = GenLmbcFpMemOperand(static_cast<int32>(offset), bytelen);
+          RegOperand &src = GetOrCreatePhysicalRegisterOperand(AArch64reg(intReg), bitlen, kRegTyInt);
+          MOperator mOp = PickStInsn(bitlen, primType);
+          Insn &store = GetInsnBuilder()->BuildInsn(mOp, src, *mOpnd);
+          GetCurBB()->AppendInsn(store);
+        }
+        intReg++;
+      }
+    } else if (IsPrimitiveFloat(primType)) {
+      if (fpReg > V7) {
+        param->SetRegNO(0);
+      } else {
+        param->SetRegNO(fpReg);
+        if (!param->HasRegassign()) {
+          uint32 bytelen = GetPrimTypeSize(primType);
+          uint32 bitlen = bytelen * kBitsPerByte;
+          MemOperand *mOpnd = GenLmbcFpMemOperand(static_cast<int32>(offset), bytelen);
+          RegOperand &src = GetOrCreatePhysicalRegisterOperand(AArch64reg(fpReg), bitlen, kRegTyFloat);
+          MOperator mOp = PickStInsn(bitlen, primType);
+          Insn &store = GetInsnBuilder()->BuildInsn(mOp, src, *mOpnd);
+          GetCurBB()->AppendInsn(store);
+        }
+        fpReg++;
+      }
+    } else if (primType == PTY_agg) {
+      if (param->IsPureFloat()) {
+        uint32 numFpRegs = param->GetNumRegs();
+        if ((fpReg + numFpRegs - kOneRegister) > V7) {
+          param->SetRegNO(0);
+        } else {
+          param->SetRegNO(fpReg);
+          param->SetNumRegs(numFpRegs);
+          fpReg += numFpRegs;
+        }
+      } else if (param->GetSize() > k16ByteSize) {
+        if (intReg > R7) {
+          param->SetRegNO(0);
+        } else {
+          param->SetRegNO(intReg);
+          param->SetIsOnStack();
+          param->SetOnStackOffset(((intReg - R0 + fpReg) - V0) * k8ByteSize);
+          uint32 bytelen = GetPrimTypeSize(PTY_a64);
+          uint32 bitlen = bytelen * kBitsPerByte;
+          MemOperand *mOpnd = GenLmbcFpMemOperand(static_cast<int32>(param->GetOnStackOffset()), bytelen);
+          RegOperand &src = GetOrCreatePhysicalRegisterOperand(AArch64reg(intReg), bitlen, kRegTyInt);
+          MOperator mOp = PickStInsn(bitlen, PTY_a64);
+          Insn &store = GetInsnBuilder()->BuildInsn(mOp, src, *mOpnd);
+          GetCurBB()->AppendInsn(store);
+          intReg++;
+        }
+      } else if (param->GetSize() <= k8ByteSize) {
+        if (intReg > R7) {
+          param->SetRegNO(0);
+        } else {
+          param->SetRegNO(intReg);
+          param->SetNumRegs(kOneRegister);
+          intReg++;
+        }
+      } else {
+        /* size > 8 && size <= 16 */
+        if ((intReg + kOneRegister) > R7) {
+          param->SetRegNO(0);
+        } else {
+          param->SetRegNO(intReg);
+          param->SetNumRegs(kTwoRegister);
+          intReg += kTwoRegister;
+        }
+      }
+      if (param->GetRegNO() != 0) {
+        for (uint32 i = 0; i < param->GetNumRegs(); ++i) {
+          PrimType pType = PTY_i64;
+          RegType rType = kRegTyInt;
+          uint32 rSize = k8ByteSize;
+          if (param->IsPureFloat()) {
+            rType = kRegTyFloat;
+            if (param->GetFpSize() <= k4ByteSize) {
+              pType = PTY_f32;
+              rSize = k4ByteSize;
+            } else {
+              pType = PTY_f64;
+            }
+          }
+          regno_t vreg = NewVReg(rType, rSize);
+          RegOperand &dest = GetOrCreateVirtualRegisterOperand(vreg);
+          RegOperand &src = GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(param->GetRegNO() + i),
+                                                               rSize * kBitsPerByte, rType);
+          SelectCopy(dest, pType, src, pType);
+          if (param->GetVregNO() == 0) {
+            param->SetVregNO(vreg);
+          }
+          Operand *memOpd = &CreateMemOpnd(RFP, offset + (i * rSize), rSize);
+          GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+              PickStInsn(rSize * kBitsPerByte, pType), dest, *memOpd));
+        }
+      }
+    } else {
+      CHECK_FATAL(false, "lmbc formal primtype not handled");
+    }
+  }
+}
+
+void AArch64CGFunc::LmbcGenSaveSpForAlloca() {
+  if (GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc || !HasVLAOrAlloca()) {
+    return;
+  }
+  Operand &spOpnd = GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+  regno_t regno = NewVReg(kRegTyInt, GetPointerSize());
+  RegOperand &spSaveOpnd = CreateVirtualRegisterOperand(regno);
+  SetSpSaveReg(regno);
+  Insn &save = GetInsnBuilder()->BuildInsn(MOP_xmovrr, spSaveOpnd, spOpnd);
+  GetFirstBB()->AppendInsn(save);
+  for (auto *retBB : GetExitBBsVec()) {
+    Insn &restore = GetInsnBuilder()->BuildInsn(MOP_xmovrr, spOpnd, spSaveOpnd);
+    retBB->AppendInsn(restore);
+    restore.SetFrameDef(true);
+  }
+}
+
+/* if offset < 0, allocation; otherwise, deallocation */
+MemOperand &AArch64CGFunc::CreateCallFrameOperand(int32 offset, uint32 size) const {
+  MemOperand *memOpnd = CreateStackMemOpnd(RSP, offset, size);
+  memOpnd->SetIndexOpt((offset < 0) ? MemOperand::kPreIndex : MemOperand::kPostIndex);
+  return *memOpnd;
+}
+
+BitShiftOperand *AArch64CGFunc::GetLogicalShiftLeftOperand(uint32 shiftAmount, bool is64bits) const {
+  /* num(0, 16, 32, 48) >> 4 is num1(0, 1, 2, 3), num1 & (~3) == 0 */
+  ASSERT((!shiftAmount || ((shiftAmount >> 4) & ~static_cast<uint32>(3)) == 0),
+         "shift amount should be one of 0, 16, 32, 48");
+  /* movkLslOperands[4]~movkLslOperands[7] is for 64 bits */
+  return &movkLslOperands[(shiftAmount >> 4) + (is64bits ? 4 : 0)];
+}
+
+AArch64CGFunc::MovkLslOperandArray AArch64CGFunc::movkLslOperands = {
+    BitShiftOperand(BitShiftOperand::kLSL, 0, 4),          BitShiftOperand(BitShiftOperand::kLSL, 16, 4),
+    BitShiftOperand(BitShiftOperand::kLSL, static_cast<uint32>(-1), 0),  /* invalid entry */
+    BitShiftOperand(BitShiftOperand::kLSL, static_cast<uint32>(-1), 0),  /* invalid entry */
+    BitShiftOperand(BitShiftOperand::kLSL, 0, 6),          BitShiftOperand(BitShiftOperand::kLSL, 16, 6),
+    BitShiftOperand(BitShiftOperand::kLSL, 32, 6),         BitShiftOperand(BitShiftOperand::kLSL, 48, 6),
+};
+
+MemOperand &AArch64CGFunc::CreateStkTopOpnd(uint32 offset, uint32 size) {
+  AArch64reg reg;
+  if (GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc) {
+    reg = RSP;
+  } else {
+    reg = RFP;
+  }
+  MemOperand *memOp = CreateStackMemOpnd(reg, static_cast<int32>(offset), size);
+  return *memOp;
+}
+
+MemOperand *AArch64CGFunc::CreateStackMemOpnd(regno_t preg, int32 offset, uint32 size) const {
+  auto *memOp = memPool->New<MemOperand>(
+      memPool->New<RegOperand>(preg, k64BitSize, kRegTyInt),
+      &CreateOfstOpnd(static_cast<uint64>(static_cast<int64>(offset)), k32BitSize),
+      size);
+  if (preg == RFP || preg == RSP) {
+    memOp->SetStackMem(true);
+  }
+  return memOp;
+}
+
+MemOperand *AArch64CGFunc::CreateMemOperand(MemOperand::AArch64AddressingMode mode, uint32 size,
+                                            RegOperand &base, RegOperand *index,
+                                            ImmOperand *offset, const MIRSymbol *symbol) const {
+  auto *memOp = memPool->New<MemOperand>(
+      mode, size, base, index, offset, symbol);
+  if (base.GetRegisterNumber() == RFP || base.GetRegisterNumber() == RSP) {
+    memOp->SetStackMem(true);
+  }
+  return memOp;
+}
+
+MemOperand *AArch64CGFunc::CreateMemOperand(MemOperand::AArch64AddressingMode mode, uint32 size,
+                                            RegOperand &base, RegOperand &index,
+                                            ImmOperand *offset, const MIRSymbol &symbol, bool noExtend) const {
+  auto *memOp = memPool->New<MemOperand>(
+      mode, size, base, index, offset, symbol, noExtend);
+  if (base.GetRegisterNumber() == RFP || base.GetRegisterNumber() == RSP) {
+    memOp->SetStackMem(true);
+  }
+  return memOp;
+}
+
+MemOperand *AArch64CGFunc::CreateMemOperand(MemOperand::AArch64AddressingMode mode, uint32 dSize,
+                                            RegOperand &base, RegOperand &indexOpnd,
+                                            uint32 shift, bool isSigned) const {
+  auto *memOp = memPool->New<MemOperand>(
+      mode, dSize, base, indexOpnd, shift, isSigned);
+  if (base.GetRegisterNumber() == RFP || base.GetRegisterNumber() == RSP) {
+    memOp->SetStackMem(true);
+  }
+  return memOp;
+}
+
+MemOperand *AArch64CGFunc::CreateMemOperand(MemOperand::AArch64AddressingMode mode, uint32 dSize,
+                                            const MIRSymbol &sym) const {
+  auto *memOp = memPool->New<MemOperand>(mode, dSize, sym);
+  return memOp;
+}
+
+void AArch64CGFunc::GenSaveMethodInfoCode(BB &bb) {
+  if (GetCG()->UseFastUnwind()) {
+    BB *formerCurBB = GetCurBB();
+    GetDummyBB()->ClearInsns();
+    SetCurBB(*GetDummyBB());
+    /*
+     * FUNCATTR_bridge for function: Ljava_2Flang_2FString_3B_7CcompareTo_7C_28Ljava_2Flang_2FObject_3B_29I, to
+     * exclude this funciton this function is a bridge function generated for Java Genetic
+     */
+    if ((GetFunction().GetAttr(FUNCATTR_native) || GetFunction().GetAttr(FUNCATTR_fast_native)) &&
+        !GetFunction().GetAttr(FUNCATTR_critical_native) && !GetFunction().GetAttr(FUNCATTR_bridge)) {
+      RegOperand &fpReg = GetOrCreatePhysicalRegisterOperand(RFP, GetPointerSize() * kBitsPerByte, kRegTyInt);
+
+      ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+      RegOperand &parmRegOpnd1 = GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, kRegTyInt);
+      srcOpnds->PushOpnd(parmRegOpnd1);
+      Operand &immOpnd = CreateImmOperand(0, k64BitSize, false);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadri64, parmRegOpnd1, immOpnd));
+      RegOperand &parmRegOpnd2 = GetOrCreatePhysicalRegisterOperand(R1, k64BitSize, kRegTyInt);
+      srcOpnds->PushOpnd(parmRegOpnd2);
+      SelectCopy(parmRegOpnd2, PTY_a64, fpReg, PTY_a64);
+
+      MIRSymbol *sym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+      std::string funcName("MCC_SetRiskyUnwindContext");
+      sym->SetNameStrIdx(funcName);
+
+      sym->SetStorageClass(kScText);
+      sym->SetSKind(kStFunc);
+      AppendCall(*sym, *srcOpnds);
+      bb.SetHasCall();
+    }
+
+    bb.InsertAtBeginning(*GetDummyBB());
+    SetCurBB(*formerCurBB);
+  }
+}
+
+bool AArch64CGFunc::OpndHasStackLoadStore(Insn &insn, Operand &opnd) {
+  if (!opnd.IsMemoryAccessOperand()) {
+    return false;
+  }
+  auto &memOpnd = static_cast<MemOperand&>(opnd);
+  Operand *base = memOpnd.GetBaseRegister();
+  if ((base != nullptr) && base->IsRegister()) {
+    RegOperand *regOpnd = static_cast<RegOperand*>(base);
+    RegType regType = regOpnd->GetRegisterType();
+    uint32 regNO = regOpnd->GetRegisterNumber();
+    if (((regType != kRegTyCc) && ((regNO == RFP) || (regNO == RSP))) || (regType == kRegTyVary)) {
+      return true;
+    }
+    if (GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+      return false;
+    }
+    /* lmbc uses ireadoff, not dread. Need to check for previous insn */
+    Insn *prevInsn = insn.GetPrev();
+    if (prevInsn && prevInsn->GetMachineOpcode() == MOP_xaddrri12) {
+      RegOperand *pOpnd = static_cast<RegOperand*>(&prevInsn->GetOperand(1));
+      if (pOpnd->GetRegisterType() == kRegTyVary) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool AArch64CGFunc::HasStackLoadStore() {
+  FOR_ALL_BB(bb, this) {
+    FOR_BB_INSNS(insn, bb) {
+      uint32 opndNum = insn->GetOperandSize();
+      for (uint32 i = 0; i < opndNum; ++i) {
+        Operand &opnd = insn->GetOperand(i);
+        if (OpndHasStackLoadStore(*insn, opnd)) {
+            return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+void AArch64CGFunc::GenerateYieldpoint(BB &bb) {
+  /* ldr wzr, [RYP]  # RYP hold address of the polling page. */
+  auto &wzr = GetZeroOpnd(k32BitSize);
+  auto &pollingPage = CreateMemOpnd(RYP, 0, k32BitSize);
+  auto &yieldPoint = GetInsnBuilder()->BuildInsn(MOP_wldr, wzr, pollingPage);
+  if (GetCG()->GenerateVerboseCG()) {
+    yieldPoint.SetComment("yieldpoint");
+  }
+  bb.AppendInsn(yieldPoint);
+}
+
+Operand &AArch64CGFunc::ProcessReturnReg(PrimType primType, int32 sReg) {
+  return GetTargetRetOperand(primType, sReg);
+}
+
+Operand &AArch64CGFunc::GetTargetRetOperand(PrimType primType, int32 sReg) {
+  uint32 bitSize = GetPrimTypeBitSize(primType) < k32BitSize ? k32BitSize : GetPrimTypeBitSize(primType);
+  AArch64reg pReg;
+  if (sReg < 0) {
+    return GetOrCreatePhysicalRegisterOperand(
+        IsPrimitiveFloat(primType) || (IsPrimitiveVector(primType)) ? S0 : R0,
+        bitSize, GetRegTyFromPrimTy(primType));
+  } else {
+    switch (sReg) {
+      case kSregRetval0:
+        pReg = IsPrimitiveFloat(primType) || (IsPrimitiveVector(primType)) ? S0 : R0;
+        break;
+      case kSregRetval1:
+        pReg = R1;
+        break;
+      default:
+        pReg = RLAST_INT_REG;
+        ASSERT(0, "GetTargetRetOperand: NYI");
+    }
+    return GetOrCreatePhysicalRegisterOperand(pReg, bitSize, GetRegTyFromPrimTy(primType));
+  }
+}
+
+RegOperand &AArch64CGFunc::CreateRegisterOperandOfType(PrimType primType) {
+  RegType regType = GetRegTyFromPrimTy(primType);
+  uint32 byteLength = GetPrimTypeSize(primType);
+  return CreateRegisterOperandOfType(regType, byteLength);
+}
+
+RegOperand &AArch64CGFunc::CreateRegisterOperandOfType(RegType regType, uint32 byteLen) {
+  /* BUG: if half-precision floating point operations are supported? */
+  /* AArch64 has 32-bit and 64-bit registers only */
+  if (byteLen < k4ByteSize) {
+    byteLen = k4ByteSize;
+  }
+  regno_t vRegNO = NewVReg(regType, byteLen);
+  return CreateVirtualRegisterOperand(vRegNO);
+}
+
+RegOperand &AArch64CGFunc::CreateRflagOperand() {
+  /* AArch64 has Status register that is 32-bit wide. */
+  regno_t vRegNO = NewVRflag();
+  return CreateVirtualRegisterOperand(vRegNO);
+}
+
+void AArch64CGFunc::MergeReturn() {
+  uint32 exitBBSize = GetExitBBsVec().size();
+  CHECK_FATAL(exitBBSize == 1, "allow one returnBB only");
+}
+
+void AArch64CGFunc::HandleRetCleanup(NaryStmtNode &retNode) {
+  if (!GetCG()->GenLocalRC()) {
+    /* handle local rc is disabled. */
+    return;
+  }
+
+  Opcode ops[11] = { OP_label, OP_goto,      OP_brfalse,   OP_brtrue,  OP_return, OP_call,
+                     OP_icall, OP_rangegoto, OP_catch, OP_try, OP_endtry };
+  std::set<Opcode> branchOp(ops, ops + 11);
+
+  /* get cleanup intrinsic */
+  bool found = false;
+  StmtNode *cleanupNode = retNode.GetPrev();
+  cleanEANode = nullptr;
+  while (cleanupNode != nullptr) {
+    if (branchOp.find(cleanupNode->GetOpCode()) != branchOp.end()) {
+      if (cleanupNode->GetOpCode() == OP_call) {
+        CallNode *callNode = static_cast<CallNode*>(cleanupNode);
+        MIRFunction *fn = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+        MIRSymbol *fsym = GetFunction().GetLocalOrGlobalSymbol(fn->GetStIdx(), false);
+        if ((fsym->GetName() == "MCC_DecRef_NaiveRCFast") || (fsym->GetName() == "MCC_IncRef_NaiveRCFast") ||
+            (fsym->GetName() == "MCC_IncDecRef_NaiveRCFast") || (fsym->GetName() == "MCC_LoadRefStatic") ||
+            (fsym->GetName() == "MCC_LoadRefField") || (fsym->GetName() == "MCC_LoadReferentField") ||
+            (fsym->GetName() == "MCC_LoadRefField_NaiveRCFast") || (fsym->GetName() == "MCC_LoadVolatileField") ||
+            (fsym->GetName() == "MCC_LoadVolatileStaticField") || (fsym->GetName() == "MCC_LoadWeakField") ||
+            (fsym->GetName() == "MCC_CheckObjMem")) {
+          cleanupNode = cleanupNode->GetPrev();
+          continue;
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+
+    if (cleanupNode->GetOpCode() == OP_intrinsiccall) {
+      IntrinsiccallNode *tempNode = static_cast<IntrinsiccallNode*>(cleanupNode);
+      if ((tempNode->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS) ||
+          (tempNode->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP)) {
+        GenRetCleanup(tempNode);
+        if (cleanEANode != nullptr) {
+          GenRetCleanup(cleanEANode, true);
+        }
+        found = true;
+        break;
+      }
+      if (tempNode->GetIntrinsic() == INTRN_MPL_CLEANUP_NORETESCOBJS) {
+        cleanEANode = tempNode;
+      }
+    }
+    cleanupNode = cleanupNode->GetPrev();
+  }
+
+  if (!found) {
+    MIRSymbol *retRef = nullptr;
+    if (retNode.NumOpnds() != 0) {
+      retRef = GetRetRefSymbol(*static_cast<NaryStmtNode&>(retNode).Opnd(0));
+    }
+    HandleRCCall(false, retRef);
+  }
+}
+
+bool AArch64CGFunc::GenRetCleanup(const IntrinsiccallNode *cleanupNode, bool forEA) {
+#undef CC_DEBUG_INFO
+
+#ifdef CC_DEBUG_INFO
+  LogInfo::MapleLogger() << "==============" << GetFunction().GetName() << "==============" << '\n';
+#endif
+
+  if (cleanupNode == nullptr) {
+    return false;
+  }
+
+  int32 minByteOffset = INT_MAX;
+  int32 maxByteOffset = 0;
+
+  int32 skipIndex = -1;
+  MIRSymbol *skipSym = nullptr;
+  size_t refSymNum = 0;
+  if (cleanupNode->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS) {
+    refSymNum = cleanupNode->GetNopndSize();
+    if (refSymNum < 1) {
+      return true;
+    }
+  } else if (cleanupNode->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP) {
+    refSymNum = cleanupNode->GetNopndSize();
+    /* refSymNum == 0, no local refvars; refSymNum == 1 and cleanup skip, so nothing to do */
+    if (refSymNum < 2) {
+      return true;
+    }
+    BaseNode *skipExpr = cleanupNode->Opnd(refSymNum - 1);
+
+    CHECK_FATAL(skipExpr->GetOpCode() == OP_dread, "should be dread");
+    DreadNode *refNode = static_cast<DreadNode*>(skipExpr);
+    skipSym = GetFunction().GetLocalOrGlobalSymbol(refNode->GetStIdx());
+
+    refSymNum -= 1;
+  } else if (cleanupNode->GetIntrinsic() == INTRN_MPL_CLEANUP_NORETESCOBJS) {
+    refSymNum = cleanupNode->GetNopndSize();
+    /* the number of operands of intrinsic call INTRN_MPL_CLEANUP_NORETESCOBJS must be more than 1 */
+    if (refSymNum < 2) {
+      return true;
+    }
+    BaseNode *skipexpr = cleanupNode->Opnd(0);
+    CHECK_FATAL(skipexpr->GetOpCode() == OP_dread, "should be dread");
+    DreadNode *refnode = static_cast<DreadNode*>(skipexpr);
+    skipSym = GetFunction().GetLocalOrGlobalSymbol(refnode->GetStIdx());
+  }
+
+  /* now compute the offset range */
+  std::vector<int32> offsets;
+  AArch64MemLayout *memLayout = static_cast<AArch64MemLayout*>(this->GetMemlayout());
+  for (size_t i = 0; i < refSymNum; ++i) {
+    BaseNode *argExpr = cleanupNode->Opnd(i);
+    CHECK_FATAL(argExpr->GetOpCode() == OP_dread, "should be dread");
+    DreadNode *refNode = static_cast<DreadNode*>(argExpr);
+    MIRSymbol *refSymbol = GetFunction().GetLocalOrGlobalSymbol(refNode->GetStIdx());
+    if (memLayout->GetSymAllocTable().size() <= refSymbol->GetStIndex()) {
+      ERR(kLncErr, "access memLayout->GetSymAllocTable() failed");
+      return false;
+    }
+    AArch64SymbolAlloc *symLoc =
+          static_cast<AArch64SymbolAlloc*>(memLayout->GetSymAllocInfo(refSymbol->GetStIndex()));
+    int32 tempOffset = GetBaseOffset(*symLoc);
+    offsets.emplace_back(tempOffset);
+#ifdef CC_DEBUG_INFO
+    LogInfo::MapleLogger() << "refsym " << refSymbol->GetName() << " offset " << tempOffset << '\n';
+#endif
+    minByteOffset = (minByteOffset > tempOffset) ? tempOffset : minByteOffset;
+    maxByteOffset = (maxByteOffset < tempOffset) ? tempOffset : maxByteOffset;
+  }
+
+  /* get the skip offset */
+  int32 skipOffset = -1;
+  if (skipSym != nullptr) {
+    AArch64SymbolAlloc *symLoc = static_cast<AArch64SymbolAlloc*>(memLayout->GetSymAllocInfo(skipSym->GetStIndex()));
+    CHECK_FATAL(GetBaseOffset(*symLoc) < std::numeric_limits<int32>::max(), "out of range");
+    skipOffset = GetBaseOffset(*symLoc);
+    offsets.emplace_back(skipOffset);
+
+#ifdef CC_DEBUG_INFO
+    LogInfo::MapleLogger() << "skip " << skipSym->GetName() << " offset " << skipOffset << '\n';
+#endif
+
+    skipIndex = symLoc->GetOffset() / kOffsetAlign;
+  }
+
+  /* call runtime cleanup */
+  if (minByteOffset < INT_MAX) {
+    int32 refLocBase = memLayout->GetRefLocBaseLoc();
+    uint32 refNum = memLayout->GetSizeOfRefLocals() / kOffsetAlign;
+    CHECK_FATAL((refLocBase + (refNum - 1) * kIntregBytelen) < std::numeric_limits<int32>::max(), "out of range");
+    int32 refLocEnd = refLocBase + static_cast<int32>((refNum - 1) * kIntregBytelen);
+    int32 realMin = minByteOffset < refLocBase ? refLocBase : minByteOffset;
+    int32 realMax = maxByteOffset > refLocEnd ? refLocEnd : maxByteOffset;
+    if (forEA) {
+      std::sort(offsets.begin(), offsets.end());
+      int32 prev = offsets[0];
+      for (size_t i = 1; i < offsets.size(); i++) {
+        CHECK_FATAL((offsets[i] == prev) || ((offsets[i] - prev) == kIntregBytelen), "must be");
+        prev = offsets[i];
+      }
+      CHECK_FATAL((refLocBase - prev) == kIntregBytelen, "must be");
+      realMin = minByteOffset;
+      realMax = maxByteOffset;
+    }
+#ifdef CC_DEBUG_INFO
+    LogInfo::MapleLogger() << " realMin " << realMin << " realMax " << realMax << '\n';
+#endif
+    if (realMax < realMin) {
+      /* maybe there is a cleanup intrinsic bug, use CHECK_FATAL instead? */
+      CHECK_FATAL(false, "must be");
+    }
+
+    /* optimization for little slot cleanup */
+    if (realMax == realMin && !forEA) {
+      RegOperand &phyOpnd = GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+      Operand &stackLoc = CreateStkTopOpnd(static_cast<uint32>(realMin), GetPointerSize() * kBitsPerByte);
+      Insn &ldrInsn = GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_a64), phyOpnd, stackLoc);
+      GetCurBB()->AppendInsn(ldrInsn);
+
+      ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+      srcOpnds->PushOpnd(phyOpnd);
+      MIRSymbol *callSym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+      std::string funcName("MCC_DecRef_NaiveRCFast");
+      callSym->SetNameStrIdx(funcName);
+      callSym->SetStorageClass(kScText);
+      callSym->SetSKind(kStFunc);
+      Insn &callInsn = AppendCall(*callSym, *srcOpnds);
+      callInsn.SetRefSkipIdx(skipIndex);
+      GetCurBB()->SetHasCall();
+      /* because of return stmt is often the last stmt */
+      GetCurBB()->SetFrequency(frequency);
+
+      return true;
+    }
+    ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+
+    ImmOperand &beginOpnd = CreateImmOperand(realMin, k64BitSize, true);
+    regno_t vRegNO0 = NewVReg(GetRegTyFromPrimTy(PTY_a64), GetPrimTypeSize(PTY_a64));
+    RegOperand &vReg0 = CreateVirtualRegisterOperand(vRegNO0);
+    RegOperand &fpOpnd = GetOrCreateStackBaseRegOperand();
+    SelectAdd(vReg0, fpOpnd, beginOpnd, PTY_i64);
+
+    RegOperand &parmRegOpnd1 = GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+    srcOpnds->PushOpnd(parmRegOpnd1);
+    SelectCopy(parmRegOpnd1, PTY_a64, vReg0, PTY_a64);
+
+    uint32 realRefNum = static_cast<uint32>((realMax - realMin) / kOffsetAlign + 1);
+
+    ImmOperand &countOpnd = CreateImmOperand(realRefNum, k64BitSize, true);
+
+    RegOperand &parmRegOpnd2 = GetOrCreatePhysicalRegisterOperand(R1, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+    srcOpnds->PushOpnd(parmRegOpnd2);
+    SelectCopyImm(parmRegOpnd2, countOpnd, PTY_i64);
+
+    MIRSymbol *funcSym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+    if ((skipSym != nullptr) && (skipOffset >= realMin) && (skipOffset <= realMax)) {
+      /* call cleanupskip */
+      uint32 stOffset = (skipOffset - realMin) / kOffsetAlign;
+      ImmOperand &retLoc = CreateImmOperand(stOffset, k64BitSize, true);
+
+      RegOperand &parmRegOpnd3 = GetOrCreatePhysicalRegisterOperand(R2, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+      srcOpnds->PushOpnd(parmRegOpnd3);
+      SelectCopyImm(parmRegOpnd3, retLoc, PTY_i64);
+
+      std::string funcName;
+      if (forEA) {
+        funcName = "MCC_CleanupNonRetEscObj";
+      } else {
+        funcName = "MCC_CleanupLocalStackRefSkip_NaiveRCFast";
+      }
+      funcSym->SetNameStrIdx(funcName);
+#ifdef CC_DEBUG_INFO
+      LogInfo::MapleLogger() << "num " << real_ref_num << " skip loc " << stOffset << '\n';
+#endif
+    } else {
+      /* call cleanup */
+      CHECK_FATAL(!forEA, "must be");
+      std::string funcName("MCC_CleanupLocalStackRef_NaiveRCFast");
+      funcSym->SetNameStrIdx(funcName);
+#ifdef CC_DEBUG_INFO
+      LogInfo::MapleLogger() << "num " << real_ref_num << '\n';
+#endif
+    }
+
+    funcSym->SetStorageClass(kScText);
+    funcSym->SetSKind(kStFunc);
+    Insn &callInsn = AppendCall(*funcSym, *srcOpnds);
+    callInsn.SetRefSkipIdx(skipIndex);
+    GetCurBB()->SetHasCall();
+    GetCurBB()->SetFrequency(frequency);
+  }
+  return true;
+}
+
+RegOperand *AArch64CGFunc::CreateVirtualRegisterOperand(regno_t vRegNO, uint32 size, RegType kind, uint32 flg) const {
+  RegOperand *res = memPool->New<RegOperand>(vRegNO, size, kind, flg);
+  return res;
+}
+
+RegOperand &AArch64CGFunc::CreateVirtualRegisterOperand(regno_t vRegNO) {
+  ASSERT((vRegOperandTable.find(vRegNO) == vRegOperandTable.end()), "already exist");
+  ASSERT(vRegNO < vRegTable.size(), "index out of range");
+  uint8 bitSize = static_cast<uint8>((static_cast<uint32>(vRegTable[vRegNO].GetSize())) * kBitsPerByte);
+  RegOperand *res = CreateVirtualRegisterOperand(vRegNO, bitSize, vRegTable.at(vRegNO).GetType());
+  vRegOperandTable[vRegNO] = res;
+  return *res;
+}
+
+RegOperand &AArch64CGFunc::GetOrCreateVirtualRegisterOperand(regno_t vRegNO) {
+  auto it = vRegOperandTable.find(vRegNO);
+  return (it != vRegOperandTable.end()) ? *(it->second) : CreateVirtualRegisterOperand(vRegNO);
+}
+
+RegOperand &AArch64CGFunc::GetOrCreateVirtualRegisterOperand(RegOperand &regOpnd) {
+  regno_t regNO = regOpnd.GetRegisterNumber();
+  auto it = vRegOperandTable.find(regNO);
+  if (it != vRegOperandTable.end()) {
+    it->second->SetSize(regOpnd.GetSize());
+    it->second->SetRegisterNumber(regNO);
+    it->second->SetRegisterType(regOpnd.GetRegisterType());
+    it->second->SetValidBitsNum(regOpnd.GetValidBitsNum());
+    return *it->second;
+  } else {
+    auto *newRegOpnd = static_cast<RegOperand*>(regOpnd.Clone(*memPool));
+    regno_t newRegNO = newRegOpnd->GetRegisterNumber();
+    if (newRegNO >= maxRegCount) {
+      maxRegCount = newRegNO + kRegIncrStepLen;
+      vRegTable.resize(maxRegCount);
+    }
+    vRegOperandTable[newRegNO] = newRegOpnd;
+    VirtualRegNode *vregNode = memPool->New<VirtualRegNode>(newRegOpnd->GetRegisterType(), newRegOpnd->GetSize());
+    vRegTable[newRegNO] = *vregNode;
+    vRegCount = maxRegCount;
+    return *newRegOpnd;
+  }
+}
+
+/*
+ * Traverse all call insn to determine return type of it
+ * If the following insn is mov/str/blr and use R0/V0, it means the call insn have reture value
+ */
+void AArch64CGFunc::DetermineReturnTypeofCall() {
+  FOR_ALL_BB(bb, this) {
+    if (bb->IsUnreachable() || !bb->HasCall()) {
+      continue;
+    }
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsTargetInsn()) {
+        continue;
+      }
+      if (!insn->IsCall() || insn->GetMachineOpcode() == MOP_asm) {
+        continue;
+      }
+      Insn *nextInsn = insn->GetNextMachineInsn();
+      if (nextInsn == nullptr) {
+        continue;
+      }
+      if ((nextInsn->GetMachineOpcode() != MOP_asm) &&
+          ((nextInsn->IsMove() && nextInsn->GetOperand(kInsnSecondOpnd).IsRegister()) ||
+           nextInsn->IsStore() ||
+           (nextInsn->IsCall() && nextInsn->GetOperand(kInsnFirstOpnd).IsRegister()))) {
+        auto *srcOpnd = static_cast<RegOperand*>(&nextInsn->GetOperand(kInsnFirstOpnd));
+        CHECK_FATAL(srcOpnd != nullptr, "nullptr");
+        if (!srcOpnd->IsPhysicalRegister()) {
+          continue;
+        }
+        if (srcOpnd->GetRegisterNumber() == R0) {
+          insn->SetRetType(Insn::kRegInt);
+          continue;
+        }
+        if (srcOpnd->GetRegisterNumber() == V0) {
+          insn->SetRetType(Insn::kRegFloat);
+        }
+      }
+    }
+  }
+}
+
+void AArch64CGFunc::HandleRCCall(bool begin, const MIRSymbol *retRef) {
+  if (!GetCG()->GenLocalRC() && !begin) {
+    /* handle local rc is disabled. */
+    return;
+  }
+
+  AArch64MemLayout *memLayout = static_cast<AArch64MemLayout*>(this->GetMemlayout());
+  int32 refNum = static_cast<int32>(memLayout->GetSizeOfRefLocals() / kOffsetAlign);
+  if (!refNum) {
+    if (begin) {
+      GenerateYieldpoint(*GetCurBB());
+      yieldPointInsn = GetCurBB()->GetLastInsn();
+    }
+    return;
+  }
+
+  /* no MCC_CleanupLocalStackRefSkip when ret_ref is the only ref symbol */
+  if ((refNum == 1) && (retRef != nullptr)) {
+    if (begin) {
+      GenerateYieldpoint(*GetCurBB());
+      yieldPointInsn = GetCurBB()->GetLastInsn();
+    }
+    return;
+  }
+  CHECK_FATAL(refNum < 0xFFFF, "not enough room for size.");
+  int32 refLocBase = memLayout->GetRefLocBaseLoc();
+  CHECK_FATAL((refLocBase >= 0) && (refLocBase < 0xFFFF), "not enough room for offset.");
+  int32 formalRef = 0;
+  /* avoid store zero to formal localrefvars. */
+  if (begin) {
+    for (uint32 i = 0; i < GetFunction().GetFormalCount(); ++i) {
+      if (GetFunction().GetNthParamAttr(i).GetAttr(ATTR_localrefvar)) {
+        refNum--;
+        formalRef++;
+      }
+    }
+  }
+  /*
+   * if the number of local refvar is less than 12, use stp or str to init local refvar
+   * else call function MCC_InitializeLocalStackRef to init.
+   */
+  if (begin && (refNum <= kRefNum12) && ((refLocBase + kIntregBytelen * (refNum - 1)) < kStpLdpImm64UpperBound)) {
+    int32 pairNum = refNum / kDivide2;
+    int32 singleNum = refNum % kDivide2;
+    const int32 pairRefBytes = 16; /* the size of each pair of ref is 16 bytes */
+    int32 ind = 0;
+    while (ind < pairNum) {
+      int32 offset = memLayout->GetRefLocBaseLoc() + kIntregBytelen * formalRef + pairRefBytes * ind;
+      Operand &zeroOp = GetZeroOpnd(k64BitSize);
+      Operand &stackLoc = CreateStkTopOpnd(static_cast<uint32>(offset), GetPointerSize() * kBitsPerByte);
+      Insn &setInc = GetInsnBuilder()->BuildInsn(MOP_xstp, zeroOp, zeroOp, stackLoc);
+      GetCurBB()->AppendInsn(setInc);
+      ind++;
+    }
+    if (singleNum > 0) {
+      int32 offset = memLayout->GetRefLocBaseLoc() + kIntregBytelen * formalRef + kIntregBytelen * (refNum - 1);
+      Operand &zeroOp = GetZeroOpnd(k64BitSize);
+      Operand &stackLoc = CreateStkTopOpnd(static_cast<uint32>(offset), GetPointerSize() * kBitsPerByte);
+      Insn &setInc = GetInsnBuilder()->BuildInsn(MOP_xstr, zeroOp, stackLoc);
+      GetCurBB()->AppendInsn(setInc);
+    }
+    /* Insert Yield Point just after localrefvar are initialized. */
+    GenerateYieldpoint(*GetCurBB());
+    yieldPointInsn = GetCurBB()->GetLastInsn();
+    return;
+  }
+
+  /* refNum is 1 and refvar is not returned, this refvar need to call MCC_DecRef_NaiveRCFast. */
+  if ((refNum == 1) && !begin && (retRef == nullptr)) {
+    RegOperand &phyOpnd = GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+    Operand &stackLoc = CreateStkTopOpnd(static_cast<uint32>(memLayout->GetRefLocBaseLoc()),
+                                         GetPointerSize() * kBitsPerByte);
+    Insn &ldrInsn = GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_a64), phyOpnd, stackLoc);
+    GetCurBB()->AppendInsn(ldrInsn);
+
+    ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+    srcOpnds->PushOpnd(phyOpnd);
+    MIRSymbol *callSym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+    std::string funcName("MCC_DecRef_NaiveRCFast");
+    callSym->SetNameStrIdx(funcName);
+    callSym->SetStorageClass(kScText);
+    callSym->SetSKind(kStFunc);
+
+    AppendCall(*callSym, *srcOpnds);
+    GetCurBB()->SetHasCall();
+    if (frequency != 0) {
+      GetCurBB()->SetFrequency(frequency);
+    }
+    return;
+  }
+
+  /* refNum is 2 and one of refvar is returned, only another one is needed to call MCC_DecRef_NaiveRCFast. */
+  if ((refNum == 2) && !begin && retRef != nullptr) {
+    AArch64SymbolAlloc *symLoc =
+        static_cast<AArch64SymbolAlloc*>(memLayout->GetSymAllocInfo(retRef->GetStIndex()));
+    int32 stOffset = symLoc->GetOffset() / kOffsetAlign;
+    RegOperand &phyOpnd = GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+    Operand *stackLoc = nullptr;
+    if (stOffset == 0) {
+      /* just have to Dec the next one. */
+      stackLoc = &CreateStkTopOpnd(static_cast<uint32>(memLayout->GetRefLocBaseLoc()) + kIntregBytelen,
+                                   GetPointerSize() * kBitsPerByte);
+    } else {
+      /* just have to Dec the current one. */
+      stackLoc = &CreateStkTopOpnd(static_cast<uint32>(memLayout->GetRefLocBaseLoc()), GetPointerSize() * kBitsPerByte);
+    }
+    Insn &ldrInsn = GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_a64), phyOpnd, *stackLoc);
+    GetCurBB()->AppendInsn(ldrInsn);
+
+    ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+    srcOpnds->PushOpnd(phyOpnd);
+    MIRSymbol *callSym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+    std::string funcName("MCC_DecRef_NaiveRCFast");
+    callSym->SetNameStrIdx(funcName);
+    callSym->SetStorageClass(kScText);
+    callSym->SetSKind(kStFunc);
+    Insn &callInsn = AppendCall(*callSym, *srcOpnds);
+    callInsn.SetRefSkipIdx(stOffset);
+    GetCurBB()->SetHasCall();
+    if (frequency != 0) {
+      GetCurBB()->SetFrequency(frequency);
+    }
+    return;
+  }
+
+  bool needSkip = false;
+  ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+
+  ImmOperand *beginOpnd =
+      &CreateImmOperand(memLayout->GetRefLocBaseLoc() + kIntregBytelen * formalRef, k64BitSize, true);
+  ImmOperand *countOpnd = &CreateImmOperand(refNum, k64BitSize, true);
+  int32 refSkipIndex = -1;
+  if (!begin && retRef != nullptr) {
+    AArch64SymbolAlloc *symLoc =
+        static_cast<AArch64SymbolAlloc*>(memLayout->GetSymAllocInfo(retRef->GetStIndex()));
+    int32 stOffset = symLoc->GetOffset() / kOffsetAlign;
+    refSkipIndex = stOffset;
+    if (stOffset == 0) {
+      /* ret_ref at begin. */
+      beginOpnd = &CreateImmOperand(memLayout->GetRefLocBaseLoc() + kIntregBytelen, k64BitSize, true);
+      countOpnd = &CreateImmOperand(refNum - 1, k64BitSize, true);
+    } else if (stOffset == (refNum - 1)) {
+      /* ret_ref at end. */
+      countOpnd = &CreateImmOperand(refNum - 1, k64BitSize, true);
+    } else {
+      needSkip = true;
+    }
+  }
+
+  regno_t vRegNO0 = NewVReg(GetRegTyFromPrimTy(PTY_a64), GetPrimTypeSize(PTY_a64));
+  RegOperand &vReg0 = CreateVirtualRegisterOperand(vRegNO0);
+  RegOperand &fpOpnd = GetOrCreateStackBaseRegOperand();
+  SelectAdd(vReg0, fpOpnd, *beginOpnd, PTY_i64);
+
+  RegOperand &parmRegOpnd1 = GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+  srcOpnds->PushOpnd(parmRegOpnd1);
+  SelectCopy(parmRegOpnd1, PTY_a64, vReg0, PTY_a64);
+
+  regno_t vRegNO1 = NewVReg(GetRegTyFromPrimTy(PTY_a64), GetPrimTypeSize(PTY_a64));
+  RegOperand &vReg1 = CreateVirtualRegisterOperand(vRegNO1);
+  SelectCopyImm(vReg1, *countOpnd, PTY_i64);
+
+  RegOperand &parmRegOpnd2 = GetOrCreatePhysicalRegisterOperand(R1, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+  srcOpnds->PushOpnd(parmRegOpnd2);
+  SelectCopy(parmRegOpnd2, PTY_a64, vReg1, PTY_a64);
+
+  MIRSymbol *sym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  if (begin) {
+    std::string funcName("MCC_InitializeLocalStackRef");
+    sym->SetNameStrIdx(funcName);
+    CHECK_FATAL(countOpnd->GetValue() > 0, "refCount should be greater than 0.");
+    refCount = static_cast<uint32>(countOpnd->GetValue());
+    beginOffset = beginOpnd->GetValue();
+  } else if (!needSkip) {
+    std::string funcName("MCC_CleanupLocalStackRef_NaiveRCFast");
+    sym->SetNameStrIdx(funcName);
+  } else {
+    CHECK_NULL_FATAL(retRef);
+    if (retRef->GetStIndex() >= memLayout->GetSymAllocTable().size()) {
+      CHECK_FATAL(false, "index out of range in AArch64CGFunc::HandleRCCall");
+    }
+    AArch64SymbolAlloc *symLoc = static_cast<AArch64SymbolAlloc*>(memLayout->GetSymAllocInfo(retRef->GetStIndex()));
+    int32 stOffset = symLoc->GetOffset() / kOffsetAlign;
+    ImmOperand &retLoc = CreateImmOperand(stOffset, k64BitSize, true);
+
+    regno_t vRegNO2 = NewVReg(GetRegTyFromPrimTy(PTY_a64), GetPrimTypeSize(PTY_a64));
+    RegOperand &vReg2 = CreateVirtualRegisterOperand(vRegNO2);
+    SelectCopyImm(vReg2, retLoc, PTY_i64);
+
+    RegOperand &parmRegOpnd3 = GetOrCreatePhysicalRegisterOperand(R2, k64BitSize, GetRegTyFromPrimTy(PTY_a64));
+    srcOpnds->PushOpnd(parmRegOpnd3);
+    SelectCopy(parmRegOpnd3, PTY_a64, vReg2, PTY_a64);
+
+    std::string funcName("MCC_CleanupLocalStackRefSkip_NaiveRCFast");
+    sym->SetNameStrIdx(funcName);
+  }
+  sym->SetStorageClass(kScText);
+  sym->SetSKind(kStFunc);
+
+  Insn &callInsn = AppendCall(*sym, *srcOpnds);
+  callInsn.SetRefSkipIdx(refSkipIndex);
+  if (frequency != 0) {
+    GetCurBB()->SetFrequency(frequency);
+  }
+  GetCurBB()->SetHasCall();
+  if (begin) {
+    /* Insert Yield Point just after localrefvar are initialized. */
+    GenerateYieldpoint(*GetCurBB());
+    yieldPointInsn = GetCurBB()->GetLastInsn();
+  }
+}
+
+void AArch64CGFunc::SelectParmListDreadSmallAggregate(const MIRSymbol &sym, MIRType &structType,
+                                                      ListOperand &srcOpnds,
+                                                      int32 offset, AArch64CallConvImpl &parmLocator, FieldID fieldID) {
+  /*
+   * in two param regs if possible
+   * If struct is <= 8 bytes, then it fits into one param reg.
+   * If struct is <= 16 bytes, then it fits into two param regs.
+   * Otherwise, it goes onto the stack.
+   * If the number of available param reg is less than what is
+   * needed to fit the entire struct into them, then the param
+   * reg is skipped and the struct goes onto the stack.
+   * Example 1.
+   *  struct size == 8 bytes.
+   *  param regs x0 to x6 are used.
+   *  struct is passed in x7.
+   * Example 2.
+   *  struct is 16 bytes.
+   *  param regs x0 to x5 are used.
+   *  struct is passed in x6 and x7.
+   * Example 3.
+   *  struct is 16 bytes.
+   *  param regs x0 to x6 are used.  x7 alone is not enough to pass the struct.
+   *  struct is passed on the stack.
+   *  x7 is not used, as the following param will go onto the stack also.
+   */
+  int32 symSize = GetBecommon().GetTypeSize(structType.GetTypeIndex().GetIdx());
+  CCLocInfo ploc;
+  parmLocator.LocateNextParm(structType, ploc);
+  if (ploc.reg0 == 0) {
+    /* No param regs available, pass on stack. */
+    /* If symSize is <= 8 bytes then use 1 reg, else 2 */
+    CreateCallStructParamPassByStack(symSize, &sym, nullptr, ploc.memOffset);
+  } else {
+    /* pass by param regs. */
+    RegOperand *parmOpnd0 = SelectParmListDreadAccessField(sym, fieldID, ploc, offset, 0);
+    srcOpnds.PushOpnd(*parmOpnd0);
+    if (ploc.reg1 > 0) {
+      RegOperand *parmOpnd1 = SelectParmListDreadAccessField(sym, fieldID, ploc, offset, 1);
+      srcOpnds.PushOpnd(*parmOpnd1);
+    }
+    if (ploc.reg2 > 0) {
+      RegOperand *parmOpnd2 = SelectParmListDreadAccessField(sym, fieldID, ploc, offset, 2);
+      srcOpnds.PushOpnd(*parmOpnd2);
+    }
+    if (ploc.reg3 > 0) {
+      RegOperand *parmOpnd3 = SelectParmListDreadAccessField(sym, fieldID, ploc, offset, 3);
+      srcOpnds.PushOpnd(*parmOpnd3);
+    }
+  }
+}
+
+RegOperand *AArch64CGFunc::LoadIreadAddrForSamllAgg(BaseNode &iread) {
+  RegOperand *addrOpnd1 = nullptr;
+  if (iread.GetOpCode() == OP_iread) {
+    RegOperand *addrOpnd0 = static_cast<RegOperand*>(HandleExpr(iread, *(iread.Opnd(0))));
+    addrOpnd1 = &LoadIntoRegister(*addrOpnd0, iread.Opnd(0)->GetPrimType());
+  } else if (iread.GetOpCode() == OP_ireadfpoff) {
+    IreadFPoffNode &ireadoff = static_cast<IreadFPoffNode&>(iread);
+    RegOperand *rfp = &GetOrCreatePhysicalRegisterOperand(RFP, k64BitSize, kRegTyInt);
+    RegOperand *addrOpnd0 = &CreateRegisterOperandOfType(PTY_a64);
+    ImmOperand &immOpnd = CreateImmOperand(ireadoff.GetOffset(), k32BitSize, true);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, *addrOpnd0, *rfp, immOpnd));
+    addrOpnd1 = &LoadIntoRegister(*addrOpnd0, PTY_i64);
+  } else if (iread.GetOpCode() == OP_ireadoff) {
+    IreadoffNode &ireadoff = static_cast<IreadoffNode&>(iread);
+    RegOperand *addrOpnd0 = static_cast<RegOperand*>(HandleExpr(ireadoff, *(ireadoff.Opnd(0))));
+    addrOpnd1 = &LoadIntoRegister(*addrOpnd0, PTY_i64);
+  }
+  CHECK_FATAL(addrOpnd1 != nullptr, "addrOpnd for iread cannot be null");
+  return addrOpnd1;
+}
+
+void AArch64CGFunc::SelectParmListIreadSmallAggregate(BaseNode &iread, MIRType &structType,
+                                                      ListOperand &srcOpnds, int32 offset,
+                                                      AArch64CallConvImpl &parmLocator) {
+  int32 symSize = GetBecommon().GetTypeSize(structType.GetTypeIndex().GetIdx());
+  RegOperand *addrOpnd1 = LoadIreadAddrForSamllAgg(iread);
+  CCLocInfo ploc;
+  parmLocator.LocateNextParm(structType, ploc);
+  if (ploc.reg0 == 0) {
+    /* No param regs available, pass on stack. */
+    CreateCallStructParamPassByStack(symSize, nullptr, addrOpnd1, ploc.memOffset);
+  } else {
+    /* pass by param regs. */
+    FpParamState state = kStateUnknown;
+    uint32 memSize = 0;
+    switch (ploc.fpSize) {
+      case k0BitSize:
+        state = kNotFp;
+        memSize = k64BitSize;
+        break;
+      case k4BitSize:
+        state = kFp32Bit;
+        memSize = k32BitSize;
+        break;
+      case k8BitSize:
+        state = kFp64Bit;
+        memSize = k64BitSize;
+        break;
+      default:
+        break;
+    }
+    OfstOperand *offOpnd0 = &GetOrCreateOfstOpnd(static_cast<uint64>(static_cast<int64>(offset)), k32BitSize);
+    MemOperand *mopnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, memSize, addrOpnd1, nullptr, offOpnd0, nullptr);
+    CreateCallStructParamPassByReg(ploc.reg0, *mopnd, srcOpnds, state);
+    if (ploc.reg1 > 0) {
+      OfstOperand *offOpnd1 = &GetOrCreateOfstOpnd((((ploc.fpSize > 0) ? ploc.fpSize : GetPointerSize()) +
+          static_cast<uint32>(offset)), k32BitSize);
+      mopnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, memSize, addrOpnd1, nullptr, offOpnd1, nullptr);
+      CreateCallStructParamPassByReg(ploc.reg1, *mopnd, srcOpnds, state);
+    }
+    if (ploc.reg2 > 0) {
+      OfstOperand *offOpnd2 =
+          &GetOrCreateOfstOpnd(((ploc.fpSize ? (ploc.fpSize * k4BitShift) : GetPointerSize()) + static_cast<uint32>(offset)),
+                               k32BitSize);
+      mopnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, memSize, addrOpnd1, nullptr, offOpnd2, nullptr);
+      CreateCallStructParamPassByReg(ploc.reg2, *mopnd, srcOpnds, state);
+    }
+    if (ploc.reg3 > 0) {
+      OfstOperand *offOpnd3 = &GetOrCreateOfstOpnd((((ploc.fpSize > 0) ? (ploc.fpSize * k8BitShift) : GetPointerSize()) +
+          static_cast<uint32>(offset)), k32BitSize);
+      mopnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, memSize, addrOpnd1, nullptr, offOpnd3, nullptr);
+      CreateCallStructParamPassByReg(ploc.reg3, *mopnd, srcOpnds, state);
+    }
+  }
+}
+
+void AArch64CGFunc::SelectParmListDreadLargeAggregate(const MIRSymbol &sym, MIRType &structType,
+                                                      ListOperand &srcOpnds,
+                                                      AArch64CallConvImpl &parmLocator, int32 &structCopyOffset,
+                                                      int32 fromOffset) {
+  /*
+   * Pass larger sized struct on stack.
+   * Need to copy the entire structure onto the stack.
+   * The pointer to the starting address of the copied struct is then
+   * used as the parameter for the struct.
+   * This pointer is passed as the next parameter.
+   * Example 1:
+   * struct is 23 bytes.
+   * param regs x0 to x5 are used.
+   * First around up 23 to 24, so 3 of 8-byte slots.
+   * Copy struct to a created space on the stack.
+   * Pointer of copied struct is passed in x6.
+   * Example 2:
+   * struct is 25 bytes.
+   * param regs x0 to x7 are used.
+   * First around up 25 to 32, so 4 of 8-byte slots.
+   * Copy struct to a created space on the stack.
+   * Pointer of copied struct is passed on stack as the 9th parameter.
+   */
+  uint64 symSize = GetBecommon().GetTypeSize(structType.GetTypeIndex().GetIdx());
+  CCLocInfo ploc;
+  parmLocator.LocateNextParm(structType, ploc);
+  uint32 numMemOp = static_cast<uint32>(RoundUp(symSize, GetPointerSize()) / GetPointerSize()); /* round up */
+  /* Create the struct copies. */
+  RegOperand *parmOpnd = CreateCallStructParamCopyToStack(numMemOp, &sym, nullptr, structCopyOffset,
+                                                          fromOffset, ploc);
+  if (parmOpnd) {
+    srcOpnds.PushOpnd(*parmOpnd);
+  }
+  structCopyOffset += static_cast<int32>(numMemOp * GetPointerSize());
+}
+
+void AArch64CGFunc::SelectParmListIreadLargeAggregate(const IreadNode &iread, MIRType &structType,
+                                                      ListOperand &srcOpnds, AArch64CallConvImpl &parmLocator,
+                                                      int32 &structCopyOffset, int32 fromOffset) {
+  uint64 symSize = GetBecommon().GetTypeSize(structType.GetTypeIndex().GetIdx());
+  RegOperand *addrOpnd0 = static_cast<RegOperand*>(HandleExpr(iread, *(iread.Opnd(0))));
+  RegOperand *addrOpnd1 = &LoadIntoRegister(*addrOpnd0, iread.Opnd(0)->GetPrimType());
+  CCLocInfo ploc;
+  parmLocator.LocateNextParm(structType, ploc);
+  uint32 numMemOp = static_cast<uint32>(RoundUp(symSize, GetPointerSize()) / GetPointerSize()); /* round up */
+  RegOperand *parmOpnd =
+      CreateCallStructParamCopyToStack(numMemOp, nullptr, addrOpnd1, structCopyOffset, fromOffset, ploc);
+  structCopyOffset += static_cast<int32>(numMemOp * GetPointerSize());
+  if (parmOpnd) {
+    srcOpnds.PushOpnd(*parmOpnd);
+  }
+}
+
+void AArch64CGFunc::CreateCallStructParamPassByStack(int32 symSize, const MIRSymbol *sym,
+                                                     RegOperand *addrOpnd, int32 baseOffset) {
+  if (symSize == 0) {
+    return;
+  }
+  MemOperand *ldMopnd = nullptr;
+  MemOperand *stMopnd = nullptr;
+  uint32 numRegNeeded = (static_cast<uint32>(symSize) <= k8ByteSize) ? kOneRegister : kTwoRegister;
+  for (int j = 0; j < static_cast<int>(numRegNeeded); j++) {
+    if (sym) {
+      if (CGOptions::IsArm64ilp32()) {
+        ldMopnd = &GetOrCreateMemOpnd(*sym, (j * static_cast<int>(k8ByteSize)), k64BitSize);
+      } else {
+        ldMopnd = &GetOrCreateMemOpnd(*sym, (j * static_cast<int>(GetPointerSize())), k64BitSize);
+      }
+    } else {
+      if (CGOptions::IsArm64ilp32()) {
+        ldMopnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, addrOpnd, nullptr,
+            &GetOrCreateOfstOpnd(static_cast<uint32>(j) * k8ByteSize, k32BitSize), nullptr);
+      } else {
+        ldMopnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, addrOpnd, nullptr,
+            &GetOrCreateOfstOpnd(static_cast<uint32>(j) * GetPointerSize(), k32BitSize), nullptr);
+      }
+    }
+    RegOperand *vreg = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_i64), *vreg, *ldMopnd));
+    if (CGOptions::IsArm64ilp32()) {
+      stMopnd = &CreateMemOpnd(RSP, (static_cast<int64>(baseOffset) + (j * static_cast<int>(k8ByteSize))), k64BitSize);
+    } else {
+      stMopnd = &CreateMemOpnd(RSP, (static_cast<int64>(baseOffset) + (j * GetPointerSize())), k64BitSize);
+    }
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickStInsn(k64BitSize, PTY_i64), *vreg, *stMopnd));
+  }
+}
+
+RegOperand *AArch64CGFunc::SelectParmListDreadAccessField(const MIRSymbol &sym, FieldID fieldID,
+                                                          const CCLocInfo &ploc, int32 offset, uint32 parmNum) {
+  uint32 memSize;
+  PrimType primType;
+  RegOperand *parmOpnd;
+  uint32 dataSizeBits;
+  AArch64reg reg;
+  switch (parmNum) {
+    case 0:
+      reg = static_cast<AArch64reg>(ploc.reg0);
+      break;
+    case 1:
+      reg = static_cast<AArch64reg>(ploc.reg1);
+      break;
+    case 2:
+      reg = static_cast<AArch64reg>(ploc.reg2);
+      break;
+    case 3:
+      reg = static_cast<AArch64reg>(ploc.reg3);
+      break;
+    default:
+      CHECK_FATAL(false, "Exceeded maximum allowed fp parameter registers for struct passing");
+  }
+  if (ploc.fpSize == 0) {
+    memSize = k64BitSize;
+    primType = PTY_i64;
+    dataSizeBits = GetPrimTypeSize(PTY_i64) * kBitsPerByte;
+    parmOpnd = &GetOrCreatePhysicalRegisterOperand(reg, k64BitSize, kRegTyInt);
+  } else if (ploc.fpSize == k4ByteSize) {
+    memSize = k32BitSize;
+    primType = PTY_f32;
+    dataSizeBits = GetPrimTypeSize(PTY_f32) * kBitsPerByte;
+    parmOpnd = &GetOrCreatePhysicalRegisterOperand(reg, k32BitSize, kRegTyFloat);
+  } else if (ploc.fpSize == k8ByteSize) {
+    memSize = k64BitSize;
+    primType = PTY_f64;
+    dataSizeBits = GetPrimTypeSize(PTY_i64) * kBitsPerByte;
+    parmOpnd = &GetOrCreatePhysicalRegisterOperand(reg, k64BitSize, kRegTyFloat);
+  } else {
+    CHECK_FATAL(false, "Unknown call parameter state");
+  }
+  MemOperand *memOpnd;
+  if (sym.GetStorageClass() == kScFormal && fieldID > 0) {
+    MemOperand &baseOpnd = GetOrCreateMemOpnd(sym, 0, memSize);
+    RegOperand &base = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_i64), base, baseOpnd));
+    memOpnd = &CreateMemOpnd(base, (static_cast<int64>(offset) + parmNum * GetPointerSize()), memSize);
+  } else if (ploc.fpSize > 0) {
+    memOpnd = &GetOrCreateMemOpnd(sym, (ploc.fpSize * parmNum + static_cast<int64>(offset)), memSize);
+  } else {
+    if (CGOptions::IsArm64ilp32()) {
+      memOpnd = &GetOrCreateMemOpnd(sym, (k8ByteSize * parmNum + static_cast<int64>(offset)), memSize);
+    } else {
+      memOpnd = &GetOrCreateMemOpnd(sym, (GetPointerSize() * parmNum + static_cast<int64>(offset)), memSize);
+    }
+  }
+  MOperator selectedMop = PickLdInsn(dataSizeBits, primType);
+  if ((memOpnd->GetAddrMode() == MemOperand::kAddrModeBOi) &&
+      !IsOperandImmValid(selectedMop, memOpnd, kInsnSecondOpnd)) {
+    memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, dataSizeBits);
+  }
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(selectedMop, *parmOpnd, *memOpnd));
+
+  return parmOpnd;
+}
+
+void AArch64CGFunc::CreateCallStructParamPassByReg(regno_t regno, MemOperand &memOpnd, ListOperand &srcOpnds,
+                                                   FpParamState state) {
+  RegOperand *parmOpnd;
+  uint32 dataSizeBits = 0;
+  PrimType pType = PTY_void;
+  parmOpnd = nullptr;
+  AArch64reg reg = static_cast<AArch64reg>(regno);
+  if (state == kNotFp) {
+    parmOpnd = &GetOrCreatePhysicalRegisterOperand(reg, k64BitSize, kRegTyInt);
+    dataSizeBits = GetPrimTypeSize(PTY_i64) * kBitsPerByte;
+    pType = PTY_i64;
+  } else if (state == kFp32Bit) {
+    parmOpnd = &GetOrCreatePhysicalRegisterOperand(reg, k32BitSize, kRegTyFloat);
+    dataSizeBits = GetPrimTypeSize(PTY_f32) * kBitsPerByte;
+    pType = PTY_f32;
+  } else if (state == kFp64Bit) {
+    parmOpnd = &GetOrCreatePhysicalRegisterOperand(reg, k64BitSize, kRegTyFloat);
+    dataSizeBits = GetPrimTypeSize(PTY_f64) * kBitsPerByte;
+    pType = PTY_f64;
+  } else {
+    ASSERT(0, "CreateCallStructParamPassByReg: Unknown state");
+  }
+
+  MOperator selectedMop = PickLdInsn(dataSizeBits, pType);
+  if (!IsOperandImmValid(selectedMop, &memOpnd, kInsnSecondOpnd)) {
+    memOpnd = SplitOffsetWithAddInstruction(memOpnd, dataSizeBits);
+  }
+  ASSERT(parmOpnd != nullptr, "parmOpnd should not be nullptr");
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(selectedMop, *parmOpnd, memOpnd));
+  srcOpnds.PushOpnd(*parmOpnd);
+}
+
+void AArch64CGFunc::CreateCallStructParamMemcpy(const MIRSymbol &sym, uint32 structSize,
+                                                int32 copyOffset, int32 fromOffset) {
+  std::vector<Operand*> opndVec;
+
+  RegOperand *vreg1 = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8BitSize));
+  opndVec.push_back(vreg1);  /* result */
+
+  RegOperand *parmOpnd = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8BitSize));
+  RegOperand *spReg = &GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+  ImmOperand *offsetOpnd0 = &CreateImmOperand(copyOffset, k64BitSize, false);
+  SelectAdd(*parmOpnd, *spReg, *offsetOpnd0, PTY_a64);
+  opndVec.push_back(parmOpnd);  /* param 0 */
+
+  if (sym.GetStorageClass() == kScGlobal || sym.GetStorageClass() == kScExtern) {
+    StImmOperand &stopnd = CreateStImmOperand(sym, fromOffset, 0);
+    RegOperand &staddropnd = static_cast<RegOperand &>(CreateRegisterOperandOfType(PTY_u64));
+    SelectAddrof(staddropnd, stopnd);
+    opndVec.push_back(&staddropnd);  /* param 1 */
+  } else if (sym.GetStorageClass() == kScAuto || sym.GetStorageClass() == kScFormal) {
+    RegOperand *parm1Reg = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+    AArch64SymbolAlloc *symloc = static_cast<AArch64SymbolAlloc*>(GetMemlayout()->GetSymAllocInfo(sym.GetStIndex()));
+    RegOperand *baseOpnd = static_cast<RegOperand*>(GetBaseReg(*symloc));
+    int32 stoffset = GetBaseOffset(*symloc);
+    ImmOperand *offsetOpnd1 = &CreateImmOperand(static_cast<int64>(stoffset), k64BitSize, false);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, *parm1Reg, *baseOpnd, *offsetOpnd1));
+    if (sym.GetStorageClass() == kScFormal) {
+      MemOperand *ldmopnd =
+          &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, parm1Reg, nullptr,
+                              &GetOrCreateOfstOpnd(0, k32BitSize), static_cast<MIRSymbol*>(nullptr));
+      RegOperand *tmpreg = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      RegOperand *vreg2 = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_a64),
+                                                                    *tmpreg, *ldmopnd));
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, *vreg2, *tmpreg,
+                                                                    CreateImmOperand(fromOffset, k64BitSize, false)));
+      parm1Reg = vreg2;
+    }
+    opndVec.push_back(parm1Reg);  /* param 1 */
+  } else if (sym.GetStorageClass() == kScPstatic || sym.GetStorageClass() == kScFstatic) {
+    CHECK_FATAL(sym.GetSKind() != kStConst, "Unsupported sym const for struct param");
+    StImmOperand *stopnd = &CreateStImmOperand(sym, 0, 0);
+    RegOperand &staddropnd = static_cast<RegOperand &>(CreateRegisterOperandOfType(PTY_u64));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrp, staddropnd, *stopnd));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrpl12, staddropnd, staddropnd, *stopnd));
+    opndVec.push_back(&staddropnd);  /* param 1 */
+  } else {
+    CHECK_FATAL(false, "Unsupported sym for struct param");
+  }
+
+  RegOperand &vreg3 = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8BitSize));
+  ImmOperand &sizeOpnd = CreateImmOperand(structSize, k64BitSize, false);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wmovri32, vreg3, sizeOpnd));
+  opndVec.push_back(&vreg3);  /* param 2 */
+
+  SelectLibCall("memcpy", opndVec, PTY_a64, PTY_a64);
+}
+
+void AArch64CGFunc::CreateCallStructParamMemcpy(RegOperand &addrOpnd, uint32 structSize,
+                                                int32 copyOffset, int32 fromOffset) {
+  std::vector<Operand*> opndVec;
+
+  RegOperand *vreg1 = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8BitSize));
+  opndVec.push_back(vreg1);  /* result */
+
+  RegOperand *parmOpnd = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8BitSize));
+  RegOperand *spReg = &GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+  ImmOperand *offsetOpnd0 = &CreateImmOperand(copyOffset, k64BitSize, false);
+  SelectAdd(*parmOpnd, *spReg, *offsetOpnd0, PTY_a64);
+  opndVec.push_back(parmOpnd);  /* param 0 */
+
+  if (fromOffset) {
+    RegOperand &p1vreg = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+    ImmOperand &fromImm = CreateImmOperand(fromOffset, k64BitSize, true);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, p1vreg, addrOpnd, fromImm));
+    opndVec.push_back(&p1vreg);  /* param 1 */
+  } else {
+    opndVec.push_back(&addrOpnd);  /* param 1 */
+  }
+
+  RegOperand &vreg3 = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8BitSize));
+  ImmOperand &sizeOpnd = CreateImmOperand(structSize, k64BitSize, false);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wmovri32, vreg3, sizeOpnd));
+  opndVec.push_back(&vreg3);  /* param 2 */
+
+  SelectLibCall("memcpy", opndVec, PTY_a64, PTY_a64);
+}
+
+RegOperand *AArch64CGFunc::CreateCallStructParamCopyToStack(uint32 numMemOp, const MIRSymbol *sym,
+                                                            RegOperand *addrOpd, int32 copyOffset,
+                                                            int32 fromOffset, const CCLocInfo &ploc) {
+  /* Create the struct copies. */
+  MemOperand *ldMopnd = nullptr;
+  MemOperand *stMopnd = nullptr;
+  for (uint32 j = 0; j < numMemOp; j++) {
+    if (sym != nullptr) {
+      if (sym->GetStorageClass() == kScFormal) {
+        MemOperand &base = GetOrCreateMemOpnd(*sym, 0, k64BitSize);
+        RegOperand &vreg = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+        Insn &ldInsn = GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_i64), vreg, base);
+        GetCurBB()->AppendInsn(ldInsn);
+        ldMopnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, &vreg, nullptr,
+            &GetOrCreateOfstOpnd((j * GetPointerSize() + static_cast<uint64>(fromOffset)), k32BitSize), nullptr);
+      } else {
+        if (CGOptions::IsArm64ilp32()) {
+          ldMopnd = &GetOrCreateMemOpnd(*sym, (j * GetPointerSize() + static_cast<int64>(fromOffset)), k32BitSize);
+        } else {
+          ldMopnd = &GetOrCreateMemOpnd(*sym, (j * GetPointerSize() + static_cast<int64>(fromOffset)), k64BitSize);
+        }
+      }
+    } else {
+      ldMopnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, addrOpd, nullptr,
+          &GetOrCreateOfstOpnd((j * GetPointerSize() + static_cast<uint64>(fromOffset)), k32BitSize), nullptr);
+    }
+    if (CGOptions::IsArm64ilp32()) {
+      RegOperand *vreg = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k4ByteSize));
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickLdInsn(k32BitSize, PTY_i32), *vreg, *ldMopnd));
+
+      stMopnd = &CreateMemOpnd(RSP, (static_cast<int64>(copyOffset) + (j * GetPointerSize())), k32BitSize);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickStInsn(k32BitSize, PTY_i32), *vreg, *stMopnd));
+    } else {
+      RegOperand *vreg = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_i64), *vreg, *ldMopnd));
+
+      stMopnd = &CreateMemOpnd(RSP, (static_cast<int64>(copyOffset) + (j * GetPointerSize())), k64BitSize);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickStInsn(k64BitSize, PTY_i64), *vreg, *stMopnd));
+    }
+  }
+  /* Create the copy address parameter for the struct */
+  RegOperand *fpopnd = &GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+  ImmOperand *offset = &CreateImmOperand(copyOffset, k64BitSize, false);
+  if (ploc.reg0 == kRinvalid) {
+    RegOperand &res = CreateRegisterOperandOfType(PTY_u64);
+    SelectAdd(res, *fpopnd, *offset, PTY_u64);
+    MemOperand &stMopnd2 = CreateMemOpnd(RSP, ploc.memOffset, k64BitSize);
+    GetCurBB()->AppendInsn(
+        GetInsnBuilder()->BuildInsn(PickStInsn(k64BitSize, PTY_i64), res, stMopnd2));
+    return nullptr;
+  } else {
+    RegOperand *parmOpnd = &GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(ploc.reg0),
+                                                               k64BitSize, kRegTyInt);
+    SelectAdd(*parmOpnd, *fpopnd, *offset, PTY_a64);
+    return parmOpnd;
+  }
+}
+
+void AArch64CGFunc::CreateCallStructMemcpyToParamReg(MIRType &structType, int32 structCopyOffset,
+                                                     AArch64CallConvImpl &parmLocator, ListOperand &srcOpnds) {
+  RegOperand &spReg = GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+  ImmOperand &offsetOpnd = CreateImmOperand(structCopyOffset, k64BitSize, false);
+
+  CCLocInfo ploc;
+  parmLocator.LocateNextParm(structType, ploc);
+  if (ploc.reg0 != 0) {
+    RegOperand &res = GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(ploc.reg0), k64BitSize, kRegTyInt);
+    SelectAdd(res, spReg, offsetOpnd, PTY_a64);
+    srcOpnds.PushOpnd(res);
+  } else {
+    RegOperand &parmOpnd = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+    SelectAdd(parmOpnd, spReg, offsetOpnd, PTY_a64);
+    MemOperand &stmopnd = CreateMemOpnd(RSP, ploc.memOffset, k64BitSize);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickStInsn(k64BitSize, PTY_i64), parmOpnd, stmopnd));
+  }
+}
+
+void AArch64CGFunc::GenAggParmForDread(const BaseNode &parent, ListOperand &srcOpnds,
+                                       AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, size_t argNo) {
+  int32 rhsOffset = 0;
+  BaseNode &argExpr = *parent.Opnd(argNo);
+  DreadNode &dread = static_cast<DreadNode &>(argExpr);
+  MIRSymbol *sym = GetBecommon().GetMIRModule().CurFunction()->GetLocalOrGlobalSymbol(dread.GetStIdx());
+  MIRType *ty = sym->GetType();
+  if (dread.GetFieldID() != 0) {
+    MIRStructType *structty = static_cast<MIRStructType *>(ty);
+    ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(structty->GetFieldTyIdx(dread.GetFieldID()));
+    rhsOffset = GetBecommon().GetFieldOffset(*structty, dread.GetFieldID()).first;
+  }
+  uint64 symSize = GetBecommon().GetTypeSize(ty->GetTypeIndex().GetIdx());
+  if (symSize <= k16ByteSize) {
+    SelectParmListDreadSmallAggregate(*sym, *ty, srcOpnds, rhsOffset, parmLocator, dread.GetFieldID());
+  } else if (symSize > kParmMemcpySize) {
+    CreateCallStructMemcpyToParamReg(*ty, structCopyOffset, parmLocator, srcOpnds);
+    structCopyOffset += static_cast<int32>(RoundUp(symSize, GetPointerSize()));
+  } else {
+    SelectParmListDreadLargeAggregate(*sym, *ty, srcOpnds, parmLocator, structCopyOffset, rhsOffset);
+  }
+}
+
+void AArch64CGFunc::GenAggParmForIread(const BaseNode &parent, ListOperand &srcOpnds,
+                                       AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, size_t argNo) {
+  int32 rhsOffset = 0;
+  BaseNode &argExpr = *parent.Opnd(argNo);
+  IreadNode &iread = static_cast<IreadNode &>(argExpr);
+  MIRPtrType *pointerty = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread.GetTyIdx()));
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerty->GetPointedTyIdx());
+  if (iread.GetFieldID() != 0) {
+    MIRStructType *structty = static_cast<MIRStructType *>(ty);
+    ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(structty->GetFieldTyIdx(iread.GetFieldID()));
+    rhsOffset = GetBecommon().GetFieldOffset(*structty, iread.GetFieldID()).first;
+  }
+  uint64 symSize = GetBecommon().GetTypeSize(ty->GetTypeIndex().GetIdx());
+  if (symSize <= k16ByteSize) {
+    SelectParmListIreadSmallAggregate(iread, *ty, srcOpnds, rhsOffset, parmLocator);
+  } else if (symSize > kParmMemcpySize) {
+    RegOperand *ireadOpnd = static_cast<RegOperand*>(HandleExpr(iread, *(iread.Opnd(0))));
+    if (rhsOffset > 0) {
+      RegOperand *addrOpnd = &LoadIntoRegister(*ireadOpnd, iread.Opnd(0)->GetPrimType());
+      regno_t vRegNO = NewVReg(kRegTyInt, k8ByteSize);
+      RegOperand *result = &CreateVirtualRegisterOperand(vRegNO);
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, *result, *addrOpnd,
+                                                                    CreateImmOperand(rhsOffset, k64BitSize, false)));
+    }
+    CreateCallStructMemcpyToParamReg(*ty, structCopyOffset, parmLocator, srcOpnds);
+    structCopyOffset += static_cast<int32>(RoundUp(symSize, GetPointerSize()));
+  } else {
+    SelectParmListIreadLargeAggregate(iread, *ty, srcOpnds, parmLocator, structCopyOffset, rhsOffset);
+  }
+}
+
+void AArch64CGFunc::GenAggParmForIreadoff(BaseNode &parent, ListOperand &srcOpnds,
+                                          AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, size_t argNo) {
+  int32 rhsOffset = 0;
+  BaseNode &argExpr = *parent.Opnd(argNo);
+  IreadoffNode &iread = static_cast<IreadoffNode &>(argExpr);
+  MIRStructType *ty = GetLmbcStructArgType(parent, argNo);
+  if (ty == nullptr) {
+    return;
+  }
+  uint64 symSize = GetBecommon().GetTypeSize(ty->GetTypeIndex().GetIdx());
+  if (symSize <= k16ByteSize) {
+    rhsOffset = iread.GetOffset();
+    SelectParmListIreadSmallAggregate(iread, *ty, srcOpnds, rhsOffset, parmLocator);
+  } else {
+    CreateCallStructMemcpyToParamReg(*ty, structCopyOffset, parmLocator, srcOpnds);
+    structCopyOffset += static_cast<int32>(RoundUp(symSize, GetPointerSize()));
+  }
+}
+
+void AArch64CGFunc::GenAggParmForIreadfpoff(BaseNode &parent, ListOperand &srcOpnds,
+                                            AArch64CallConvImpl &parmLocator, int32 &structCopyOffset, size_t argNo) {
+  int32 rhsOffset = 0;
+  BaseNode &argExpr = *parent.Opnd(argNo);
+  IreadFPoffNode &iread = static_cast<IreadFPoffNode &>(argExpr);
+  MIRStructType *ty = GetLmbcStructArgType(parent, argNo);
+  if (ty == nullptr) {  /* param < arg */
+    return;
+  }
+  uint64 symSize = GetBecommon().GetTypeSize(ty->GetTypeIndex().GetIdx());
+  if (symSize <= k16ByteSize) {
+    SelectParmListIreadSmallAggregate(iread, *ty, srcOpnds, rhsOffset, parmLocator);
+  } else {
+    CreateCallStructMemcpyToParamReg(*ty, structCopyOffset, parmLocator, srcOpnds);
+    structCopyOffset += static_cast<int32>(RoundUp(symSize, GetPointerSize()));
+  }
+}
+
+void AArch64CGFunc::SelectParmListForAggregate(BaseNode &parent, ListOperand &srcOpnds,
+                                               AArch64CallConvImpl &parmLocator, int32 &structCopyOffset,
+                                               size_t argNo) {
+  BaseNode &argExpr = *parent.Opnd(argNo);
+  if (argExpr.GetOpCode() == OP_dread) {
+    GenAggParmForDread(parent, srcOpnds, parmLocator, structCopyOffset, argNo);
+  } else if (argExpr.GetOpCode() == OP_iread) {
+    GenAggParmForIread(parent, srcOpnds, parmLocator, structCopyOffset, argNo);
+  } else if (argExpr.GetOpCode() == OP_ireadfpoff) {
+    GenAggParmForIreadfpoff(parent, srcOpnds, parmLocator, structCopyOffset, argNo);
+  } else if (argExpr.GetOpCode() == OP_ireadoff) {
+    GenAggParmForIreadoff(parent, srcOpnds, parmLocator, structCopyOffset, argNo);
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+}
+
+size_t AArch64CGFunc::SelectParmListGetStructReturnSize(StmtNode &naryNode) {
+  if (naryNode.GetOpCode() == OP_call) {
+    CallNode &callNode = static_cast<CallNode&>(naryNode);
+    MIRFunction *callFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode.GetPUIdx());
+    TyIdx retIdx = callFunc->GetReturnTyIdx();
+    if (callFunc->IsFirstArgReturn()) {
+      MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(callFunc->GetFormalDefVec()[0].formalTyIdx);
+      return GetBecommon().GetTypeSize(static_cast<MIRPtrType*>(ty)->GetPointedTyIdx());
+    }
+    size_t retSize = GetBecommon().GetTypeSize(retIdx.GetIdx());
+    if ((retSize == 0) && callFunc->IsReturnStruct()) {
+      TyIdx tyIdx = callFunc->GetFuncRetStructTyIdx();
+      return GetBecommon().GetTypeSize(tyIdx);
+    }
+    return retSize;
+  } else if (naryNode.GetOpCode() == OP_icall) {
+    IcallNode &icallNode = static_cast<IcallNode&>(naryNode);
+    CallReturnVector *p2nrets = &icallNode.GetReturnVec();
+    if (p2nrets->size() == k1ByteSize) {
+      StIdx stIdx = (*p2nrets)[0].first;
+      MIRSymbol *sym = GetBecommon().GetMIRModule().CurFunction()->GetSymTab()->GetSymbolFromStIdx(stIdx.Idx());
+      if (sym != nullptr) {
+        return GetBecommon().GetTypeSize(sym->GetTyIdx().GetIdx());
+      }
+    }
+  } else if (naryNode.GetOpCode() == OP_icallproto) {
+    IcallNode &icallProto = static_cast<IcallNode&>(naryNode);
+    MIRFuncType *funcTy = static_cast<MIRFuncType*>(
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(icallProto.GetRetTyIdx()));
+    if (funcTy->FirstArgReturn()) {
+      MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcTy->GetNthParamType(0));
+      return GetBecommon().GetTypeSize(static_cast<MIRPtrType*>(ty)->GetPointedTyIdx());
+    }
+    return GetBecommon().GetTypeSize(funcTy->GetRetTyIdx());
+  }
+  return 0;
+}
+
+void AArch64CGFunc::GenLargeStructCopyForDread(BaseNode &argExpr, int32 &structCopyOffset) {
+  int32 rhsOffset = 0;
+  DreadNode &dread = static_cast<DreadNode &>(argExpr);
+  MIRSymbol *sym = GetBecommon().GetMIRModule().CurFunction()->GetLocalOrGlobalSymbol(dread.GetStIdx());
+  MIRType *ty = sym->GetType();
+  if (dread.GetFieldID() != 0) {
+    MIRStructType *structty = static_cast<MIRStructType *>(ty);
+    ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(structty->GetFieldTyIdx(dread.GetFieldID()));
+    rhsOffset = GetBecommon().GetFieldOffset(*structty, dread.GetFieldID()).first;
+  }
+  uint64 symSize = GetBecommon().GetTypeSize(ty->GetTypeIndex().GetIdx());
+  if (symSize > kParmMemcpySize) {
+    CreateCallStructParamMemcpy(*sym, static_cast<uint32>(symSize), structCopyOffset, rhsOffset);
+    structCopyOffset += static_cast<int32>(RoundUp(symSize, GetPointerSize()));
+  } else if (symSize > k16ByteSize) {
+    uint32 numMemOp = static_cast<uint32>(RoundUp(symSize, GetPointerSize()) / GetPointerSize());
+    structCopyOffset += static_cast<int32>(numMemOp * GetPointerSize());
+  }
+}
+
+void AArch64CGFunc::GenLargeStructCopyForIread(BaseNode &argExpr, int32 &structCopyOffset) {
+  int32 rhsOffset = 0;
+  IreadNode &iread = static_cast<IreadNode &>(argExpr);
+  MIRPtrType *pointerty = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread.GetTyIdx()));
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerty->GetPointedTyIdx());
+  if (iread.GetFieldID() != 0) {
+    MIRStructType *structty = static_cast<MIRStructType *>(ty);
+    ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(structty->GetFieldTyIdx(iread.GetFieldID()));
+    rhsOffset = GetBecommon().GetFieldOffset(*structty, iread.GetFieldID()).first;
+  }
+  uint64 symSize = GetBecommon().GetTypeSize(ty->GetTypeIndex().GetIdx());
+  if (symSize > kParmMemcpySize) {
+    RegOperand *ireadOpnd = static_cast<RegOperand*>(HandleExpr(iread, *(iread.Opnd(0))));
+    RegOperand &addrOpnd = LoadIntoRegister(*ireadOpnd, iread.Opnd(0)->GetPrimType());
+    CreateCallStructParamMemcpy(addrOpnd, static_cast<uint32>(symSize), structCopyOffset, rhsOffset);
+    structCopyOffset += static_cast<int32>(RoundUp(symSize, GetPointerSize()));
+  } else if (symSize > k16ByteSize) {
+    uint32 numMemOp = static_cast<uint32>(RoundUp(symSize, GetPointerSize()) / GetPointerSize());
+    structCopyOffset += static_cast<int32>(numMemOp * GetPointerSize());
+  }
+}
+
+void AArch64CGFunc::GenLargeStructCopyForIreadfpoff(BaseNode &parent, BaseNode &argExpr,
+                                                    int32 &structCopyOffset, size_t argNo) {
+  IreadFPoffNode &ireadoff = static_cast<IreadFPoffNode &>(argExpr);
+  MIRStructType *ty = GetLmbcStructArgType(parent, argNo);
+  uint64 symSize = GetBecommon().GetTypeSize(ty->GetTypeIndex());
+  if (symSize > k16ByteSize) { /* kParmMemcpySize */
+    RegOperand *rfp = &GetOrCreatePhysicalRegisterOperand(RFP, k64BitSize, kRegTyInt);
+    RegOperand &addrOpnd = CreateRegisterOperandOfType(PTY_a64);
+    ImmOperand &immOpnd = CreateImmOperand(ireadoff.GetOffset(), k32BitSize, true);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xaddrri12, addrOpnd, *rfp, immOpnd));
+    CreateCallStructParamMemcpy(addrOpnd, static_cast<uint32>(symSize), structCopyOffset, 0);
+    structCopyOffset += static_cast<int32>(RoundUp(symSize, GetPointerSize()));
+  }
+}
+
+void AArch64CGFunc::GenLargeStructCopyForIreadoff(BaseNode &parent, BaseNode &argExpr,
+                                                  int32 &structCopyOffset, size_t argNo) {
+  IreadoffNode &ireadoff = static_cast<IreadoffNode &>(argExpr);
+  MIRStructType *ty = GetLmbcStructArgType(parent, argNo);
+  uint64 symSize = GetBecommon().GetTypeSize(ty->GetTypeIndex());
+  if (symSize > k16ByteSize) { /* kParmMemcpySize */
+    RegOperand *addrOpnd = static_cast<RegOperand*>(
+                           HandleExpr(ireadoff, *(ireadoff.Opnd(0))));
+    int32 fromOffset = ireadoff.GetOffset();
+    CreateCallStructParamMemcpy(*addrOpnd, static_cast<uint32>(symSize), structCopyOffset, fromOffset);
+    structCopyOffset += static_cast<int32>(RoundUp(symSize, GetPointerSize()));
+  }
+}
+
+void AArch64CGFunc::SelectParmListPreprocessLargeStruct(BaseNode &parent, BaseNode &argExpr,
+                                                        int32 &structCopyOffset, size_t argNo) {
+  if (argExpr.GetOpCode() == OP_dread) {
+    GenLargeStructCopyForDread(argExpr, structCopyOffset);
+  } else if (argExpr.GetOpCode() == OP_iread) {
+    GenLargeStructCopyForIread(argExpr, structCopyOffset);
+  } else if (argExpr.GetOpCode() == OP_ireadfpoff) {
+    GenLargeStructCopyForIreadfpoff(parent, argExpr, structCopyOffset, argNo);
+  } else if (argExpr.GetOpCode() == OP_ireadoff) {
+    GenLargeStructCopyForIreadoff(parent, argExpr, structCopyOffset, argNo);
+  }
+}
+
+/* preprocess call in parmlist */
+bool AArch64CGFunc::MarkParmListCall(BaseNode &expr) {
+  if (!CGOptions::IsPIC()) {
+    return false;
+  }
+  switch (expr.GetOpCode()) {
+    case OP_addrof: {
+      auto &addrNode = static_cast<AddrofNode&>(expr);
+      MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(addrNode.GetStIdx());
+      if (symbol->IsThreadLocal()) {
+        return true;
+      }
+      break;
+    }
+    default: {
+      for (size_t i = 0; i < expr.GetNumOpnds(); i++) {
+        if (expr.Opnd(i)) {
+          if (MarkParmListCall(*expr.Opnd(i))) {
+            return true;
+          }
+        }
+      }
+      break;
+    }
+  }
+  return false;
+}
+
+void AArch64CGFunc::SelectParmListPreprocess(StmtNode &naryNode, size_t start, std::set<size_t> &specialArgs) {
+  size_t i = start;
+  int32 structCopyOffset = GetMaxParamStackSize() - GetStructCopySize();
+  for (; i < naryNode.NumOpnds(); ++i) {
+    BaseNode *argExpr = naryNode.Opnd(i);
+    PrimType primType = argExpr->GetPrimType();
+    if (MarkParmListCall(*argExpr)) {
+      (void)specialArgs.emplace(i);
+    }
+    ASSERT(primType != PTY_void, "primType should not be void");
+    if (primType != PTY_agg) {
+      continue;
+    }
+    SelectParmListPreprocessLargeStruct(naryNode, *argExpr, structCopyOffset, i);
+  }
+}
+
+/*
+   SelectParmList generates an instrunction for each of the parameters
+   to load the parameter value into the corresponding register.
+   We return a list of registers to the call instruction because
+   they may be needed in the register allocation phase.
+ */
+void AArch64CGFunc::SelectParmList(StmtNode &naryNode, ListOperand &srcOpnds, bool isCallNative) {
+  size_t i = 0;
+  if (naryNode.GetOpCode() == OP_icall || naryNode.GetOpCode() == OP_icallproto || isCallNative) {
+    i++;
+  }
+  std::set<size_t> specialArgs;
+  SelectParmListPreprocess(naryNode, i, specialArgs);
+  bool specialArg = false;
+  bool firstArgReturn = false;
+  MIRFunction *callee = nullptr;
+  if (dynamic_cast<CallNode*>(&naryNode) != nullptr) {
+    auto calleePuIdx = static_cast<CallNode&>(naryNode).GetPUIdx();
+    callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleePuIdx);
+    firstArgReturn = callee->IsFirstArgReturn();
+  } else if (naryNode.GetOpCode() == OP_icallproto) {
+    IcallNode *icallnode = &static_cast<IcallNode&>(naryNode);
+    MIRType *protoType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(icallnode->GetRetTyIdx());
+    MIRFuncType *funcType = nullptr;
+    if (protoType->IsMIRPtrType()) {
+      funcType = static_cast<MIRPtrType*>(protoType)->GetPointedFuncType();
+    } else if (protoType->IsMIRFuncType()) {
+      funcType = static_cast<MIRFuncType*>(protoType);
+    }
+    CHECK_FATAL(funcType != nullptr, "cannot find prototype for icall");
+    firstArgReturn = funcType->FirstArgReturn();
+  }
+  BB *curBBrecord = GetCurBB();
+  BB *tmpBB = nullptr;
+  if (!specialArgs.empty()) {
+    tmpBB = CreateNewBB();
+    specialArg = true;
+  }
+  AArch64CallConvImpl parmLocator(GetBecommon());
+  CCLocInfo ploc;
+  int32 structCopyOffset = GetMaxParamStackSize() - GetStructCopySize();
+  std::vector<Insn*> insnForStackArgs;
+  uint32 stackArgsCount = 0;
+  for (uint32 pnum = 0; i < naryNode.NumOpnds(); ++i, ++pnum) {
+    if (specialArg) {
+      ASSERT(tmpBB, "need temp bb for lower priority args");
+      SetCurBB((specialArgs.count(i) > 0) ? *curBBrecord : *tmpBB);
+    }
+    bool is64x1vec = false;
+    MIRType *ty = nullptr;
+    BaseNode *argExpr = naryNode.Opnd(i);
+    PrimType primType = argExpr->GetPrimType();
+    ASSERT(primType != PTY_void, "primType should not be void");
+    if (callee != nullptr && pnum < callee->GetFormalCount() && callee->GetFormal(pnum) != nullptr) {
+      is64x1vec = callee->GetFormal(pnum)->GetAttr(ATTR_oneelem_simd);
+    }
+    switch (argExpr->op) {
+      case OP_dread: {
+        DreadNode *dNode = static_cast<DreadNode *>(argExpr);
+        MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(dNode->GetStIdx());
+        if (dNode->GetFieldID() != 0) {
+          MIRStructType *structType = static_cast<MIRStructType*>(symbol->GetType());
+          ASSERT(structType != nullptr, "SelectParmList: non-zero fieldID for non-structure");
+          FieldAttrs fa = structType->GetFieldAttrs(dNode->GetFieldID());
+          is64x1vec = fa.GetAttr(FLDATTR_oneelem_simd);
+        } else {
+          is64x1vec = symbol->GetAttr(ATTR_oneelem_simd);
+        }
+        break;
+      }
+      case OP_iread: {
+        IreadNode *iNode = static_cast<IreadNode *>(argExpr);
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iNode->GetTyIdx());
+        MIRPtrType *ptrTyp = static_cast<MIRPtrType *>(type);
+        ASSERT(ptrTyp != nullptr, "expect a pointer type at iread node");
+        MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTyp->GetPointedTyIdx());
+        if (iNode->GetFieldID() != 0) {
+          MIRStructType *structType = static_cast<MIRStructType *>(pointedTy);
+          FieldAttrs fa = structType->GetFieldAttrs(iNode->GetFieldID());
+          is64x1vec = fa.GetAttr(FLDATTR_oneelem_simd);
+        } else {
+          TypeAttrs ta = static_cast<MIRPtrType *>(ptrTyp)->GetTypeAttrs();
+          is64x1vec = ta.GetAttr(ATTR_oneelem_simd);
+        }
+        break;
+      }
+      case OP_constval: {
+        CallNode *call = safe_cast<CallNode>(&naryNode);
+        if (call == nullptr) {
+          break;
+        }
+        MIRFunction *fn = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(call->GetPUIdx());
+        if (fn == nullptr || fn->GetFormalCount() == 0 || fn->GetFormalCount() <= pnum) {
+          break;
+        }
+        is64x1vec = fn->GetFormalDefAt(pnum).formalAttrs.GetAttr(ATTR_oneelem_simd);
+        break;
+      }
+      default:
+        break;
+    }
+    /* use alloca  */
+    if (primType == PTY_agg) {
+      SelectParmListForAggregate(naryNode, srcOpnds, parmLocator, structCopyOffset, i);
+      continue;
+    }
+    ty = GlobalTables::GetTypeTable().GetTypeTable()[static_cast<uint32>(primType)];
+    RegOperand *expRegOpnd = nullptr;
+    Operand *opnd = HandleExpr(naryNode, *argExpr);
+    if (opnd->GetKind() == Operand::kOpdRegister && static_cast<RegOperand *>(opnd)->GetIF64Vec()) {
+      is64x1vec = true;
+    }
+    if (!opnd->IsRegister()) {
+      opnd = &LoadIntoRegister(*opnd, primType);
+    }
+    expRegOpnd = static_cast<RegOperand*>(opnd);
+
+    if ((pnum == 0) && firstArgReturn) {
+      parmLocator.InitCCLocInfo(ploc);
+      ploc.reg0 = R8;
+    } else {
+      parmLocator.LocateNextParm(*ty, ploc);
+    }
+    /* is64x1vec should be an int64 value in an FP/simd reg for ABI compliance,
+       convert R-reg to equivalent V-reg */
+    PrimType destPrimType = primType;
+    if (is64x1vec && ploc.reg0 != kRinvalid && ploc.reg0 < R7) {
+      ploc.reg0 = AArch64Abi::kFloatParmRegs[static_cast<int>(ploc.reg0) - 1];
+      destPrimType = PTY_f64;
+    }
+
+    /* skip unused args */
+    if (callee != nullptr && callee->GetFuncDesc().IsArgUnused(pnum)) {
+      continue;
+    }
+
+    if (ploc.reg0 != kRinvalid) {  /* load to the register. */
+      CHECK_FATAL(expRegOpnd != nullptr, "null ptr check");
+      RegOperand &parmRegOpnd = GetOrCreatePhysicalRegisterOperand(
+          static_cast<AArch64reg>(ploc.reg0), expRegOpnd->GetSize(), GetRegTyFromPrimTy(destPrimType));
+      SelectCopy(parmRegOpnd, destPrimType, *expRegOpnd, primType);
+      srcOpnds.PushOpnd(parmRegOpnd);
+    } else {  /* store to the memory segment for stack-passsed arguments. */
+      if (CGOptions::IsBigEndian()) {
+        if (GetPrimTypeBitSize(primType) < k64BitSize) {
+          ploc.memOffset = ploc.memOffset + static_cast<int32>(k4BitSize);
+        }
+      }
+      MemOperand &actMemOpnd = CreateMemOpnd(RSP, ploc.memOffset, GetPrimTypeBitSize(primType));
+      Insn &strInsn = GetInsnBuilder()->BuildInsn(PickStInsn(GetPrimTypeBitSize(primType), primType), *expRegOpnd,
+                                                  actMemOpnd);
+      actMemOpnd.SetStackArgMem(true);
+      if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel2 && stackArgsCount < kShiftAmount12) {
+        (void)insnForStackArgs.emplace_back(&strInsn);
+        stackArgsCount++;
+      } else {
+        GetCurBB()->AppendInsn(strInsn);
+      }
+    }
+    ASSERT(ploc.reg1 == 0, "SelectCall NYI");
+  }
+  if (specialArg) {
+    ASSERT(tmpBB, "need temp bb for lower priority args");
+    curBBrecord->InsertAtEnd(*tmpBB);
+    SetCurBB(*curBBrecord);
+  }
+  for (auto &strInsn : insnForStackArgs) {
+    GetCurBB()->AppendInsn(*strInsn);
+  }
+}
+
+/*
+ * for MCC_DecRefResetPair(addrof ptr %Reg17_R5592, addrof ptr %Reg16_R6202) or
+ * MCC_ClearLocalStackRef(addrof ptr %Reg17_R5592), the parameter (addrof ptr xxx) is converted to asm as follow:
+ * add vreg, x29, #imm
+ * mov R0/R1, vreg
+ * this function is used to prepare parameters, the generated vreg is returned, and #imm is saved in offsetValue.
+ */
+Operand *AArch64CGFunc::SelectClearStackCallParam(const AddrofNode &expr, int64 &offsetValue) {
+  MIRSymbol *symbol = GetMirModule().CurFunction()->GetLocalOrGlobalSymbol(expr.GetStIdx());
+  PrimType ptype = expr.GetPrimType();
+  regno_t vRegNO = NewVReg(kRegTyInt, GetPrimTypeSize(ptype));
+  Operand &result = CreateVirtualRegisterOperand(vRegNO);
+  CHECK_FATAL(expr.GetFieldID() == 0, "the fieldID of parameter in clear stack reference call must be 0");
+  if (!CGOptions::IsQuiet()) {
+    maple::LogInfo::MapleLogger(kLlErr) <<
+        "Warning: we expect AddrOf with StImmOperand is not used for local variables";
+  }
+  auto *symLoc = static_cast<AArch64SymbolAlloc*>(GetMemlayout()->GetSymAllocInfo(symbol->GetStIndex()));
+  ImmOperand *offset = nullptr;
+  if (symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed) {
+    offset = &CreateImmOperand(GetBaseOffset(*symLoc), k64BitSize, false, kUnAdjustVary);
+  } else if (symLoc->GetMemSegment()->GetMemSegmentKind() == kMsRefLocals) {
+    auto it = immOpndsRequiringOffsetAdjustmentForRefloc.find(symLoc);
+    if (it != immOpndsRequiringOffsetAdjustmentForRefloc.end()) {
+      offset = (*it).second;
+    } else {
+      offset = &CreateImmOperand(GetBaseOffset(*symLoc), k64BitSize, false);
+      immOpndsRequiringOffsetAdjustmentForRefloc[symLoc] = offset;
+    }
+  } else {
+    CHECK_FATAL(false, "the symLoc of parameter in clear stack reference call is unreasonable");
+  }
+  ASSERT(offset != nullptr, "offset should not be nullptr");
+  offsetValue = offset->GetValue();
+  SelectAdd(result, *GetBaseReg(*symLoc), *offset, PTY_u64);
+  if (GetCG()->GenerateVerboseCG()) {
+    /* Add a comment */
+    Insn *insn = GetCurBB()->GetLastInsn();
+    std::string comm = "local/formal var: ";
+    comm.append(symbol->GetName());
+    insn->SetComment(comm);
+  }
+  return &result;
+}
+
+/* select paramters for MCC_DecRefResetPair and MCC_ClearLocalStackRef function */
+void AArch64CGFunc::SelectClearStackCallParmList(const StmtNode &naryNode, ListOperand &srcOpnds,
+                                                 std::vector<int64> &stackPostion) {
+  AArch64CallConvImpl parmLocator(GetBecommon());
+  CCLocInfo ploc;
+  for (size_t i = 0; i < naryNode.NumOpnds(); ++i) {
+    MIRType *ty = nullptr;
+    BaseNode *argExpr = naryNode.Opnd(i);
+    PrimType primType = argExpr->GetPrimType();
+    ASSERT(primType != PTY_void, "primType check");
+    /* use alloc */
+    CHECK_FATAL(primType != PTY_agg, "the type of argument is unreasonable");
+    ty = GlobalTables::GetTypeTable().GetTypeTable()[static_cast<uint32>(primType)];
+    CHECK_FATAL(argExpr->GetOpCode() == OP_addrof, "the argument of clear stack call is unreasonable");
+    auto *expr = static_cast<AddrofNode*>(argExpr);
+    int64 offsetValue = 0;
+    Operand *opnd = SelectClearStackCallParam(*expr, offsetValue);
+    stackPostion.emplace_back(offsetValue);
+    auto *expRegOpnd = static_cast<RegOperand*>(opnd);
+    parmLocator.LocateNextParm(*ty, ploc);
+    CHECK_FATAL(ploc.reg0 != 0, "the parameter of ClearStackCall must be passed by register");
+    CHECK_FATAL(expRegOpnd != nullptr, "null ptr check");
+    RegOperand &parmRegOpnd = GetOrCreatePhysicalRegisterOperand(
+        static_cast<AArch64reg>(ploc.reg0), expRegOpnd->GetSize(), GetRegTyFromPrimTy(primType));
+    SelectCopy(parmRegOpnd, primType, *expRegOpnd, primType);
+    srcOpnds.PushOpnd(parmRegOpnd);
+    ASSERT(ploc.reg1 == 0, "SelectCall NYI");
+  }
+}
+
+/*
+ * intrinsify Unsafe.getAndAddInt and Unsafe.getAndAddLong
+ * generate an intrinsic instruction instead of a function call
+ * intrinsic_get_add_int w0, xt, ws, ws, x1, x2, w3, label
+ */
+void AArch64CGFunc::IntrinsifyGetAndAddInt(ListOperand &srcOpnds, PrimType pty) {
+  MapleList<RegOperand*> &opnds = srcOpnds.GetOperands();
+  /* Unsafe.getAndAddInt has more than 4 parameters */
+  ASSERT(opnds.size() >= 4, "ensure the operands number");
+  auto iter = opnds.cbegin();
+  RegOperand *objOpnd = *(++iter);
+  RegOperand *offOpnd = *(++iter);
+  RegOperand *deltaOpnd = *(++iter);
+  auto &retVal = static_cast<RegOperand&>(GetTargetRetOperand(pty, -1));
+  LabelIdx labIdx = CreateLabel();
+  LabelOperand &targetOpnd = GetOrCreateLabelOperand(labIdx);
+  RegOperand &tempOpnd0 = CreateRegisterOperandOfType(PTY_i64);
+  RegOperand &tempOpnd1 = CreateRegisterOperandOfType(pty);
+  RegOperand &tempOpnd2 = CreateRegisterOperandOfType(PTY_i32);
+  MOperator mOp = (pty == PTY_i64) ? MOP_get_and_addL : MOP_get_and_addI;
+  std::vector<Operand*> intrnOpnds;
+  intrnOpnds.emplace_back(&retVal);
+  intrnOpnds.emplace_back(&tempOpnd0);
+  intrnOpnds.emplace_back(&tempOpnd1);
+  intrnOpnds.emplace_back(&tempOpnd2);
+  intrnOpnds.emplace_back(objOpnd);
+  intrnOpnds.emplace_back(offOpnd);
+  intrnOpnds.emplace_back(deltaOpnd);
+  intrnOpnds.emplace_back(&targetOpnd);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, intrnOpnds));
+}
+
+/*
+ * intrinsify Unsafe.getAndSetInt and Unsafe.getAndSetLong
+ * generate an intrinsic instruction instead of a function call
+ */
+void AArch64CGFunc::IntrinsifyGetAndSetInt(ListOperand &srcOpnds, PrimType pty) {
+  MapleList<RegOperand*> &opnds = srcOpnds.GetOperands();
+  /* Unsafe.getAndSetInt has 4 parameters */
+  ASSERT(opnds.size() == 4, "ensure the operands number");
+  auto iter = opnds.cbegin();
+  RegOperand *objOpnd = *(++iter);
+  RegOperand *offOpnd = *(++iter);
+  RegOperand *newValueOpnd = *(++iter);
+  auto &retVal = static_cast<RegOperand&>(GetTargetRetOperand(pty, -1));
+  LabelIdx labIdx = CreateLabel();
+  LabelOperand &targetOpnd = GetOrCreateLabelOperand(labIdx);
+  RegOperand &tempOpnd0 = CreateRegisterOperandOfType(PTY_i64);
+  RegOperand &tempOpnd1 = CreateRegisterOperandOfType(PTY_i32);
+
+  MOperator mOp = (pty == PTY_i64) ? MOP_get_and_setL : MOP_get_and_setI;
+  std::vector<Operand*> intrnOpnds;
+  intrnOpnds.emplace_back(&retVal);
+  intrnOpnds.emplace_back(&tempOpnd0);
+  intrnOpnds.emplace_back(&tempOpnd1);
+  intrnOpnds.emplace_back(objOpnd);
+  intrnOpnds.emplace_back(offOpnd);
+  intrnOpnds.emplace_back(newValueOpnd);
+  intrnOpnds.emplace_back(&targetOpnd);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, intrnOpnds));
+}
+
+/*
+ * intrinsify Unsafe.compareAndSwapInt and Unsafe.compareAndSwapLong
+ * generate an intrinsic instruction instead of a function call
+ */
+void AArch64CGFunc::IntrinsifyCompareAndSwapInt(ListOperand &srcOpnds, PrimType pty) {
+  MapleList<RegOperand*> &opnds = srcOpnds.GetOperands();
+  /* Unsafe.compareAndSwapInt has more than 5 parameters */
+  ASSERT(opnds.size() >= 5, "ensure the operands number");
+  auto iter = opnds.cbegin();
+  RegOperand *objOpnd = *(++iter);
+  RegOperand *offOpnd = *(++iter);
+  RegOperand *expectedValueOpnd = *(++iter);
+  RegOperand *newValueOpnd = *(++iter);
+  auto &retVal = static_cast<RegOperand&>(GetTargetRetOperand(PTY_i64, -1));
+  RegOperand &tempOpnd0 = CreateRegisterOperandOfType(PTY_i64);
+  RegOperand &tempOpnd1 = CreateRegisterOperandOfType(pty);
+  LabelIdx labIdx1 = CreateLabel();
+  LabelOperand &label1Opnd = GetOrCreateLabelOperand(labIdx1);
+  LabelIdx labIdx2 = CreateLabel();
+  LabelOperand &label2Opnd = GetOrCreateLabelOperand(labIdx2);
+  MOperator mOp = (pty == PTY_i32) ? MOP_compare_and_swapI : MOP_compare_and_swapL;
+  std::vector<Operand*> intrnOpnds;
+  intrnOpnds.emplace_back(&retVal);
+  intrnOpnds.emplace_back(&tempOpnd0);
+  intrnOpnds.emplace_back(&tempOpnd1);
+  intrnOpnds.emplace_back(objOpnd);
+  intrnOpnds.emplace_back(offOpnd);
+  intrnOpnds.emplace_back(expectedValueOpnd);
+  intrnOpnds.emplace_back(newValueOpnd);
+  intrnOpnds.emplace_back(&label1Opnd);
+  intrnOpnds.emplace_back(&label2Opnd);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, intrnOpnds));
+}
+
+/*
+ * the lowest bit of count field is used to indicate whether or not the string is compressed
+ * if the string is not compressed, jump to jumpLabIdx
+ */
+RegOperand *AArch64CGFunc::CheckStringIsCompressed(BB &bb, RegOperand &str, int32 countOffset, PrimType countPty,
+                                                   LabelIdx jumpLabIdx) {
+  MemOperand &memOpnd = CreateMemOpnd(str, countOffset, str.GetSize());
+  uint32 bitSize = GetPrimTypeBitSize(countPty);
+  MOperator loadOp = PickLdInsn(bitSize, countPty);
+  RegOperand &countOpnd = CreateRegisterOperandOfType(countPty);
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(loadOp, countOpnd, memOpnd));
+  ImmOperand &immValueOne = CreateImmOperand(countPty, 1);
+  RegOperand &countLowestBitOpnd = CreateRegisterOperandOfType(countPty);
+  MOperator andOp = bitSize == k64BitSize ? MOP_xandrri13 : MOP_wandrri12;
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(andOp, countLowestBitOpnd, countOpnd, immValueOne));
+  RegOperand &wzr = GetZeroOpnd(bitSize);
+  MOperator cmpOp = (bitSize == k64BitSize) ? MOP_xcmprr : MOP_wcmprr;
+  Operand &rflag = GetOrCreateRflag();
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(cmpOp, rflag, wzr, countLowestBitOpnd));
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(MOP_beq, rflag, GetOrCreateLabelOperand(jumpLabIdx)));
+  bb.SetKind(BB::kBBIf);
+  return &countOpnd;
+}
+
+/*
+ * count field stores the length shifted one bit to the left
+ * if the length is less than eight, jump to jumpLabIdx
+ */
+RegOperand *AArch64CGFunc::CheckStringLengthLessThanEight(BB &bb, RegOperand &countOpnd, PrimType countPty,
+                                                          LabelIdx jumpLabIdx) {
+  RegOperand &lengthOpnd = CreateRegisterOperandOfType(countPty);
+  uint32 bitSize = GetPrimTypeBitSize(countPty);
+  MOperator lsrOp = (bitSize == k64BitSize) ? MOP_xlsrrri6 : MOP_wlsrrri5;
+  ImmOperand &immValueOne = CreateImmOperand(countPty, 1);
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(lsrOp, lengthOpnd, countOpnd, immValueOne));
+  constexpr int kConstIntEight = 8;
+  ImmOperand &immValueEight = CreateImmOperand(countPty, kConstIntEight);
+  MOperator cmpImmOp = (bitSize == k64BitSize) ? MOP_xcmpri : MOP_wcmpri;
+  Operand &rflag = GetOrCreateRflag();
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(cmpImmOp, rflag, lengthOpnd, immValueEight));
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(MOP_blt, rflag, GetOrCreateLabelOperand(jumpLabIdx)));
+  bb.SetKind(BB::kBBIf);
+  return &lengthOpnd;
+}
+
+void AArch64CGFunc::GenerateIntrnInsnForStrIndexOf(BB &bb, RegOperand &srcString, RegOperand &patternString,
+                                                   RegOperand &srcCountOpnd, RegOperand &patternLengthOpnd,
+                                                   PrimType countPty, LabelIdx jumpLabIdx) {
+  RegOperand &srcLengthOpnd = CreateRegisterOperandOfType(countPty);
+  ImmOperand &immValueOne = CreateImmOperand(countPty, 1);
+  uint32 bitSize = GetPrimTypeBitSize(countPty);
+  MOperator lsrOp = (bitSize == k64BitSize) ? MOP_xlsrrri6 : MOP_wlsrrri5;
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(lsrOp, srcLengthOpnd, srcCountOpnd, immValueOne));
+#ifdef USE_32BIT_REF
+  const int64 stringBaseObjSize = 16;  /* shadow(4)+monitor(4)+count(4)+hash(4) */
+#else
+  const int64 stringBaseObjSize = 20;  /* shadow(8)+monitor(4)+count(4)+hash(4) */
+#endif  /* USE_32BIT_REF */
+  PrimType pty = (srcString.GetSize() == k64BitSize) ? PTY_i64 : PTY_i32;
+  ImmOperand &immStringBaseOffset = CreateImmOperand(pty, stringBaseObjSize);
+  MOperator addOp = (pty == PTY_i64) ? MOP_xaddrri12 : MOP_waddrri12;
+  RegOperand &srcStringBaseOpnd = CreateRegisterOperandOfType(pty);
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(addOp, srcStringBaseOpnd, srcString, immStringBaseOffset));
+  RegOperand &patternStringBaseOpnd = CreateRegisterOperandOfType(pty);
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(addOp, patternStringBaseOpnd, patternString, immStringBaseOffset));
+  auto &retVal = static_cast<RegOperand&>(GetTargetRetOperand(PTY_i32, -1));
+  std::vector<Operand*> intrnOpnds;
+  intrnOpnds.emplace_back(&retVal);
+  intrnOpnds.emplace_back(&srcStringBaseOpnd);
+  intrnOpnds.emplace_back(&srcLengthOpnd);
+  intrnOpnds.emplace_back(&patternStringBaseOpnd);
+  intrnOpnds.emplace_back(&patternLengthOpnd);
+  const uint32 tmpRegOperandNum = 6;
+  for (uint32 i = 0; i < tmpRegOperandNum - 1; ++i) {
+    RegOperand &tmpOpnd = CreateRegisterOperandOfType(PTY_i64);
+    intrnOpnds.emplace_back(&tmpOpnd);
+  }
+  intrnOpnds.emplace_back(&CreateRegisterOperandOfType(PTY_i32));
+  const uint32 labelNum = 7;
+  for (uint32 i = 0; i < labelNum; ++i) {
+    LabelIdx labIdx = CreateLabel();
+    LabelOperand &labelOpnd = GetOrCreateLabelOperand(labIdx);
+    intrnOpnds.emplace_back(&labelOpnd);
+  }
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(MOP_string_indexof, intrnOpnds));
+  bb.AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xuncond, GetOrCreateLabelOperand(jumpLabIdx)));
+  bb.SetKind(BB::kBBGoto);
+}
+
+/*
+ * intrinsify String.indexOf
+ * generate an intrinsic instruction instead of a function call if both the source string and the specified substring
+ * are compressed and the length of the substring is not less than 8, i.e.
+ * bl  String.indexOf, srcString, patternString ===>>
+ *
+ * ldr srcCountOpnd, [srcString, offset]
+ * and srcCountLowestBitOpnd, srcCountOpnd, #1
+ * cmp wzr, srcCountLowestBitOpnd
+ * beq Label.call
+ * ldr patternCountOpnd, [patternString, offset]
+ * and patternCountLowestBitOpnd, patternCountOpnd, #1
+ * cmp wzr, patternCountLowestBitOpnd
+ * beq Label.call
+ * lsr patternLengthOpnd, patternCountOpnd, #1
+ * cmp patternLengthOpnd, #8
+ * blt Label.call
+ * lsr srcLengthOpnd, srcCountOpnd, #1
+ * add srcStringBaseOpnd, srcString, immStringBaseOffset
+ * add patternStringBaseOpnd, patternString, immStringBaseOffset
+ * intrinsic_string_indexof retVal, srcStringBaseOpnd, srcLengthOpnd, patternStringBaseOpnd, patternLengthOpnd,
+ *                          tmpOpnd1, tmpOpnd2, tmpOpnd3, tmpOpnd4, tmpOpnd5, tmpOpnd6,
+ *                          label1, label2, label3, lable3, label4, label5, label6, label7
+ * b   Label.joint
+ * Label.call:
+ * bl  String.indexOf, srcString, patternString
+ * Label.joint:
+ */
+void AArch64CGFunc::IntrinsifyStringIndexOf(ListOperand &srcOpnds, const MIRSymbol &funcSym) {
+  MapleList<RegOperand*> &opnds = srcOpnds.GetOperands();
+  /* String.indexOf opnd size must be more than 2 */
+  ASSERT(opnds.size() >= 2, "ensure the operands number");
+  auto iter = opnds.cbegin();
+  RegOperand *srcString = *iter;
+  RegOperand *patternString = *(++iter);
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kJavaLangStringStr);
+  MIRType *type =
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(gStrIdx));
+  auto stringType = static_cast<MIRStructType*>(type);
+  CHECK_FATAL(stringType != nullptr, "Ljava_2Flang_2FString_3B type can not be null");
+  FieldID fieldID = GetMirModule().GetMIRBuilder()->GetStructFieldIDFromFieldNameParentFirst(stringType, "count");
+  MIRType *fieldType = stringType->GetFieldType(fieldID);
+  PrimType countPty = fieldType->GetPrimType();
+  int32 offset = GetBecommon().GetFieldOffset(*stringType, fieldID).first;
+  LabelIdx callBBLabIdx = CreateLabel();
+  RegOperand *srcCountOpnd = CheckStringIsCompressed(*GetCurBB(), *srcString, offset, countPty, callBBLabIdx);
+
+  BB *srcCompressedBB = CreateNewBB();
+  GetCurBB()->AppendBB(*srcCompressedBB);
+  RegOperand *patternCountOpnd = CheckStringIsCompressed(*srcCompressedBB, *patternString, offset, countPty,
+      callBBLabIdx);
+
+  BB *patternCompressedBB = CreateNewBB();
+  RegOperand *patternLengthOpnd = CheckStringLengthLessThanEight(*patternCompressedBB, *patternCountOpnd, countPty,
+      callBBLabIdx);
+
+  BB *intrinsicBB = CreateNewBB();
+  LabelIdx jointLabIdx = CreateLabel();
+  GenerateIntrnInsnForStrIndexOf(*intrinsicBB, *srcString, *patternString, *srcCountOpnd, *patternLengthOpnd,
+      countPty, jointLabIdx);
+
+  BB *callBB = CreateNewBB();
+  callBB->AddLabel(callBBLabIdx);
+  SetLab2BBMap(callBBLabIdx, *callBB);
+  SetCurBB(*callBB);
+  Insn &callInsn = AppendCall(funcSym, srcOpnds);
+  MIRType *retType = funcSym.GetFunction()->GetReturnType();
+  if (retType != nullptr) {
+    callInsn.SetRetSize(static_cast<uint32>(retType->GetSize()));
+  }
+  GetFunction().SetHasCall();
+
+  BB *jointBB = CreateNewBB();
+  jointBB->AddLabel(jointLabIdx);
+  SetLab2BBMap(jointLabIdx, *jointBB);
+  srcCompressedBB->AppendBB(*patternCompressedBB);
+  patternCompressedBB->AppendBB(*intrinsicBB);
+  intrinsicBB->AppendBB(*callBB);
+  callBB->AppendBB(*jointBB);
+  SetCurBB(*jointBB);
+}
+
+void AArch64CGFunc::SelectCall(CallNode &callNode) {
+  MIRFunction *fn = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode.GetPUIdx());
+  MIRSymbol *fsym = GetFunction().GetLocalOrGlobalSymbol(fn->GetStIdx(), false);
+  MIRType *retType = fn->GetReturnType();
+
+  if (GetCG()->GenerateVerboseCG()) {
+    auto &comment = GetOpndBuilder()->CreateComment(fsym->GetName());
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildCommentInsn(comment));
+  }
+
+  ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+  if (GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc) {
+    SetLmbcCallReturnType(nullptr);
+    if (fn->IsFirstArgReturn()) {
+      MIRPtrType *ptrTy = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(
+          fn->GetFormalDefVec()[0].formalTyIdx));
+      MIRType *sTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTy->GetPointedTyIdx());
+      SetLmbcCallReturnType(sTy);
+    } else {
+      MIRType *ty = fn->GetReturnType();
+      SetLmbcCallReturnType(ty);
+    }
+  }
+  bool callNative = false;
+  if ((fsym->GetName() == "MCC_CallFastNative") || (fsym->GetName() == "MCC_CallFastNativeExt") ||
+      (fsym->GetName() == "MCC_CallSlowNative0") || (fsym->GetName() == "MCC_CallSlowNative1") ||
+      (fsym->GetName() == "MCC_CallSlowNative2") || (fsym->GetName() == "MCC_CallSlowNative3") ||
+      (fsym->GetName() == "MCC_CallSlowNative4") || (fsym->GetName() == "MCC_CallSlowNative5") ||
+      (fsym->GetName() == "MCC_CallSlowNative6") || (fsym->GetName() == "MCC_CallSlowNative7") ||
+      (fsym->GetName() == "MCC_CallSlowNative8") || (fsym->GetName() == "MCC_CallSlowNativeExt")) {
+    callNative = true;
+  }
+
+  std::vector<int64> stackPosition;
+  if ((fsym->GetName() == "MCC_DecRefResetPair") || (fsym->GetName() == "MCC_ClearLocalStackRef")) {
+    SelectClearStackCallParmList(callNode, *srcOpnds, stackPosition);
+  } else {
+    SelectParmList(callNode, *srcOpnds, callNative);
+  }
+  if (callNative) {
+    auto &comment = GetOpndBuilder()->CreateComment("call native func");
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildCommentInsn(comment));
+
+    BaseNode *funcArgExpr = callNode.Opnd(0);
+    PrimType ptype = funcArgExpr->GetPrimType();
+    Operand *funcOpnd = HandleExpr(callNode, *funcArgExpr);
+    RegOperand &livein = GetOrCreatePhysicalRegisterOperand(R9, GetPointerSize() * kBitsPerByte,
+                                                            GetRegTyFromPrimTy(PTY_a64));
+    SelectCopy(livein, ptype, *funcOpnd, ptype);
+
+    RegOperand &extraOpnd = GetOrCreatePhysicalRegisterOperand(R9, GetPointerSize() * kBitsPerByte, kRegTyInt);
+    srcOpnds->PushOpnd(extraOpnd);
+  }
+  const std::string &funcName = fsym->GetName();
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel2 &&
+      funcName == "Ljava_2Flang_2FString_3B_7CindexOf_7C_28Ljava_2Flang_2FString_3B_29I") {
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(funcName);
+    MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx, true);
+    IntrinsifyStringIndexOf(*srcOpnds, *st);
+    return;
+  }
+  Insn &callInsn = AppendCall(*fsym, *srcOpnds);
+  GetCurBB()->SetHasCall();
+  if (retType != nullptr) {
+    callInsn.SetRetSize(static_cast<uint32>(retType->GetSize()));
+    callInsn.SetIsCallReturnUnsigned(IsUnsignedInteger(retType->GetPrimType()));
+  }
+
+  /* check if this call use stack slot to return */
+  if (fn->IsFirstArgReturn()) {
+    SetStackProtectInfo(kRetureStackSlot);
+  }
+
+  GetFunction().SetHasCall();
+  if (GetMirModule().IsCModule()) { /* do not mark abort BB in C at present */
+    if (fsym->GetName() == "__builtin_unreachable") {
+      GetCurBB()->ClearInsns();
+      GetCurBB()->SetUnreachable(true);
+    }
+    if (fn->GetAttr(FUNCATTR_noreturn)) {
+      GetCurBB()->SetKind(BB::kBBNoReturn);
+      PushBackNoReturnCallBBsVec(*GetCurBB());
+    }
+    return;
+  }
+  if ((fsym->GetName() == "MCC_ThrowException") || (fsym->GetName() == "MCC_RethrowException") ||
+      (fsym->GetName() == "MCC_ThrowArithmeticException") ||
+      (fsym->GetName() == "MCC_ThrowArrayIndexOutOfBoundsException") ||
+      (fsym->GetName() == "MCC_ThrowNullPointerException") ||
+      (fsym->GetName() == "MCC_ThrowStringIndexOutOfBoundsException") || (fsym->GetName() == "abort") ||
+      (fsym->GetName() == "exit") || (fsym->GetName() == "MCC_Array_Boundary_Check")) {
+    callInsn.SetIsThrow(true);
+    GetCurBB()->SetKind(BB::kBBThrow);
+  } else if ((fsym->GetName() == "MCC_DecRefResetPair") || (fsym->GetName() == "MCC_ClearLocalStackRef")) {
+    for (size_t i = 0; i < stackPosition.size(); ++i) {
+      callInsn.SetClearStackOffset(i, stackPosition[i]);
+    }
+  }
+}
+
+void AArch64CGFunc::SelectIcall(IcallNode &icallNode, Operand &srcOpnd) {
+  ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+  SelectParmList(icallNode, *srcOpnds);
+
+  Operand *fptrOpnd = &srcOpnd;
+  if (fptrOpnd->GetKind() != Operand::kOpdRegister) {
+    PrimType ty = icallNode.Opnd(0)->GetPrimType();
+    fptrOpnd = &SelectCopy(srcOpnd, ty, ty);
+  }
+  ASSERT(fptrOpnd->IsRegister(), "SelectIcall: function pointer not RegOperand");
+  RegOperand *regOpnd = static_cast<RegOperand*>(fptrOpnd);
+  Insn &callInsn = GetInsnBuilder()->BuildInsn(MOP_xblr, *regOpnd, *srcOpnds);
+
+  MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(icallNode.GetRetTyIdx());
+  if (retType != nullptr) {
+    callInsn.SetRetSize(static_cast<uint32>(retType->GetSize()));
+    callInsn.SetIsCallReturnUnsigned(IsUnsignedInteger(retType->GetPrimType()));
+  }
+
+  /* check if this icall use stack slot to return */
+  CallReturnVector *p2nrets = &icallNode.GetReturnVec();
+  if (p2nrets->size() == k1ByteSize) {
+    StIdx stIdx = (*p2nrets)[0].first;
+    MIRSymbol *sym = GetBecommon().GetMIRModule().CurFunction()->GetSymTab()->GetSymbolFromStIdx(stIdx.Idx());
+    if (sym != nullptr && (GetBecommon().GetTypeSize(sym->GetTyIdx().GetIdx()) > k16ByteSize)) {
+      SetStackProtectInfo(kRetureStackSlot);
+    }
+  }
+
+  GetCurBB()->AppendInsn(callInsn);
+  GetCurBB()->SetHasCall();
+  ASSERT(GetCurBB()->GetLastInsn()->IsCall(), "lastInsn should be a call");
+  GetFunction().SetHasCall();
+}
+
+void AArch64CGFunc::HandleCatch() {
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel1) {
+    regno_t regNO = uCatch.regNOCatch;
+    RegOperand &vregOpnd = GetOrCreateVirtualRegisterOperand(regNO);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xmovrr, vregOpnd,
+        GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, kRegTyInt)));
+  } else {
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickStInsn(uCatch.opndCatch->GetSize(), PTY_a64),
+        GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, kRegTyInt), *uCatch.opndCatch));
+  }
+}
+
+void AArch64CGFunc::SelectMembar(StmtNode &membar) {
+  switch (membar.GetOpCode()) {
+    case OP_membaracquire:
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_dmb_ishld, AArch64CG::kMd[MOP_dmb_ishld]));
+      break;
+    case OP_membarrelease:
+    case OP_membarstoreload:
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_dmb_ish, AArch64CG::kMd[MOP_dmb_ish]));
+      break;
+    case OP_membarstorestore:
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_dmb_ishst, AArch64CG::kMd[MOP_dmb_ishst]));
+      break;
+    default:
+      ASSERT(false, "NYI");
+      break;
+  }
+}
+
+void AArch64CGFunc::SelectComment(CommentNode &comment) {
+  auto &commentOpnd = GetOpndBuilder()->CreateComment(comment.GetComment());
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildCommentInsn(commentOpnd));
+}
+
+void AArch64CGFunc::SelectReturn(Operand *opnd0) {
+  bool is64x1vec = GetFunction().GetAttr(FUNCATTR_oneelem_simd) ? true : false;
+  MIRType *floatType = GlobalTables::GetTypeTable().GetDouble();
+  MIRType *retTyp = is64x1vec ? floatType : GetFunction().GetReturnType();
+  AArch64CallConvImpl retLocator(GetBecommon());
+  CCLocInfo retMech;
+  retLocator.InitReturnInfo(*retTyp, retMech);
+  if ((retMech.GetRegCount() > 0) && (opnd0 != nullptr)) {
+    RegType regTyp = is64x1vec ? kRegTyFloat : GetRegTyFromPrimTy(retMech.GetPrimTypeOfReg0());
+    PrimType oriPrimType = is64x1vec ? GetFunction().GetReturnType()->GetPrimType() : retMech.GetPrimTypeOfReg0();
+    AArch64reg retReg = static_cast<AArch64reg>(retMech.GetReg0());
+    if (opnd0->IsRegister()) {
+      RegOperand *regOpnd = static_cast<RegOperand*>(opnd0);
+      if (regOpnd->GetRegisterNumber() != retMech.GetReg0()) {
+        RegOperand &retOpnd =
+            GetOrCreatePhysicalRegisterOperand(retReg, regOpnd->GetSize(), regTyp);
+        SelectCopy(retOpnd, retMech.GetPrimTypeOfReg0(), *regOpnd, oriPrimType);
+      }
+    } else if (opnd0->IsMemoryAccessOperand()) {
+      auto *memopnd = static_cast<MemOperand*>(opnd0);
+      RegOperand &retOpnd = GetOrCreatePhysicalRegisterOperand(retReg,
+          GetPrimTypeBitSize(retMech.GetPrimTypeOfReg0()), regTyp);
+      MOperator mOp = PickLdInsn(memopnd->GetSize(), retMech.GetPrimTypeOfReg0());
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, retOpnd, *memopnd));
+    } else if (opnd0->IsConstImmediate()) {
+      ImmOperand *immOpnd = static_cast<ImmOperand*>(opnd0);
+      if (!is64x1vec) {
+        RegOperand &retOpnd = GetOrCreatePhysicalRegisterOperand(retReg,
+            GetPrimTypeBitSize(retMech.GetPrimTypeOfReg0()), GetRegTyFromPrimTy(retMech.GetPrimTypeOfReg0()));
+        SelectCopy(retOpnd, retMech.GetPrimTypeOfReg0(), *immOpnd, retMech.GetPrimTypeOfReg0());
+      } else {
+        PrimType rType = GetFunction().GetReturnType()->GetPrimType();
+        RegOperand *reg = &CreateRegisterOperandOfType(rType);
+        SelectCopy(*reg, rType, *immOpnd, rType);
+        RegOperand &retOpnd = GetOrCreatePhysicalRegisterOperand(retReg,
+            GetPrimTypeBitSize(PTY_f64), GetRegTyFromPrimTy(PTY_f64));
+        Insn &insn = GetInsnBuilder()->BuildInsn(MOP_xvmovdr, retOpnd, *reg);
+        GetCurBB()->AppendInsn(insn);
+      }
+    } else {
+      CHECK_FATAL(false, "nyi");
+    }
+  }
+
+  LabelOperand &targetOpnd = GetOrCreateLabelOperand(GetReturnLabel()->GetLabelIdx());
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xuncond, targetOpnd));
+}
+
+RegOperand &AArch64CGFunc::GetOrCreateSpecialRegisterOperand(PregIdx sregIdx, PrimType primType) {
+  AArch64reg reg = R0;
+  switch (sregIdx) {
+    case kSregSp:
+      reg = RSP;
+      break;
+    case kSregFp:
+      reg = RFP;
+      break;
+    case kSregGp: {
+      MIRSymbol *sym = GetCG()->GetGP();
+      if (sym == nullptr) {
+        sym = GetFunction().GetSymTab()->CreateSymbol(kScopeLocal);
+        std::string strBuf("__file__local__GP");
+        sym->SetNameStrIdx(GetMirModule().GetMIRBuilder()->GetOrCreateStringIndex(strBuf));
+        GetCG()->SetGP(sym);
+      }
+      RegOperand &result = GetOrCreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+      SelectAddrof(result, CreateStImmOperand(*sym, 0, 0));
+      return result;
+    }
+    case kSregThrownval: { /* uses x0 == R0 */
+      ASSERT(uCatch.regNOCatch > 0, "regNOCatch should greater than 0.");
+      if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+        RegOperand &regOpnd = GetOrCreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8BitSize));
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+            PickLdInsn(uCatch.opndCatch->GetSize(), PTY_a64), regOpnd, *uCatch.opndCatch));
+        return regOpnd;
+      } else {
+        return GetOrCreateVirtualRegisterOperand(uCatch.regNOCatch);
+      }
+    }
+    case kSregRetval0:
+      if (!IsPrimitiveInteger(primType) || IsPrimitiveVectorFloat(primType)) {
+        reg = V0;
+      }
+      break;
+    case kSregMethodhdl:
+      if (methodHandleVreg == regno_t(-1)) {
+        methodHandleVreg = NewVReg(kRegTyInt, k8BitSize);
+      }
+      return GetOrCreateVirtualRegisterOperand(methodHandleVreg);
+    default:
+      ASSERT(false, "Special pseudo registers NYI");
+      break;
+  }
+  return GetOrCreatePhysicalRegisterOperand(reg, k64BitSize, kRegTyInt);
+}
+
+RegOperand &AArch64CGFunc::GetOrCreatePhysicalRegisterOperand(std::string &asmAttr) {
+  ASSERT(!asmAttr.empty(), "Get inline asm string failed in GetOrCreatePhysicalRegisterOperand");
+  RegType rKind = kRegTyUndef;
+  uint32 rSize = 0;
+  /* Get Register Type and Size */
+  switch (asmAttr[0]) {
+    case 'x': {
+      rKind = kRegTyInt;
+      rSize = k64BitSize;
+      break;
+    }
+    case 'w': {
+      rKind = kRegTyInt;
+      rSize = k32BitSize;
+      break;
+    }
+    default: {
+      LogInfo::MapleLogger() << "Unsupport asm string : " << asmAttr << "\n";
+      CHECK_FATAL(false, "Have not support this kind of register ");
+    }
+  }
+  AArch64reg rNO = kRinvalid;
+  /* Get Register Number */
+  uint32 regNumPos = 1;
+  char numberChar = asmAttr[regNumPos++];
+  if (numberChar >= '0' && numberChar <= '9') {
+    uint32 val = static_cast<uint32>(static_cast<int32>(numberChar) - kZeroAsciiNum);
+    if (regNumPos < asmAttr.length()) {
+      char numberCharSecond = asmAttr[regNumPos++];
+      ASSERT(regNumPos == asmAttr.length(), "Invalid asm attribute");
+      if (numberCharSecond >= '0' && numberCharSecond <= '9') {
+        val = val * kDecimalMax + static_cast<uint32>((static_cast<int32>(numberCharSecond) - kZeroAsciiNum));
+      }
+    }
+    rNO = static_cast<AArch64reg>(static_cast<uint32>(R0) + val);
+    if (val > (kAsmInputRegPrefixOpnd + 1)) {
+      LogInfo::MapleLogger() << "Unsupport asm string : " << asmAttr << "\n";
+      CHECK_FATAL(false, "have not support this kind of register ");
+    }
+  } else if (numberChar == 0) {
+    return CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+  } else {
+    CHECK_FATAL(false, "Unexpect input in GetOrCreatePhysicalRegisterOperand");
+  }
+  return GetOrCreatePhysicalRegisterOperand(rNO, rSize, rKind);
+}
+
+RegOperand &AArch64CGFunc::GetOrCreatePhysicalRegisterOperand(AArch64reg regNO, uint32 size,
+                                                              RegType kind, uint32 flag) {
+  uint64 aarch64PhyRegIdx = regNO;
+  ASSERT(flag == 0, "Do not expect flag here");
+  if (size <= k32BitSize) {
+    size = k32BitSize;
+    aarch64PhyRegIdx = aarch64PhyRegIdx << 1;
+  } else if (size <= k64BitSize) {
+    size = k64BitSize;
+    aarch64PhyRegIdx = (aarch64PhyRegIdx << 1) + 1;
+  } else {
+    size = (size == k128BitSize) ? k128BitSize : k64BitSize;
+    aarch64PhyRegIdx = aarch64PhyRegIdx << 2;
+  }
+  RegOperand *phyRegOpnd = nullptr;
+  auto phyRegIt = phyRegOperandTable.find(aarch64PhyRegIdx);
+  if (phyRegIt != phyRegOperandTable.end()) {
+    phyRegOpnd = phyRegOperandTable[aarch64PhyRegIdx];
+  } else {
+    phyRegOpnd = memPool->New<RegOperand>(regNO, size, kind, flag);
+    phyRegOperandTable.emplace(aarch64PhyRegIdx, phyRegOpnd);
+  }
+  return *phyRegOpnd;
+}
+
+const LabelOperand *AArch64CGFunc::GetLabelOperand(LabelIdx labIdx) const {
+  const MapleUnorderedMap<LabelIdx, LabelOperand*>::const_iterator it = hashLabelOpndTable.find(labIdx);
+  if (it != hashLabelOpndTable.end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+LabelOperand &AArch64CGFunc::GetOrCreateLabelOperand(LabelIdx labIdx) {
+  MapleUnorderedMap<LabelIdx, LabelOperand*>::iterator it = hashLabelOpndTable.find(labIdx);
+  if (it != hashLabelOpndTable.end()) {
+    return *(it->second);
+  }
+  LabelOperand *res = memPool->New<LabelOperand>(GetShortFuncName().c_str(), labIdx, *memPool);
+  hashLabelOpndTable[labIdx] = res;
+  return *res;
+}
+
+LabelOperand &AArch64CGFunc::GetOrCreateLabelOperand(BB &bb) {
+  LabelIdx labelIdx = bb.GetLabIdx();
+  if (labelIdx == MIRLabelTable::GetDummyLabel()) {
+    labelIdx = CreateLabel();
+    bb.AddLabel(labelIdx);
+  }
+  return GetOrCreateLabelOperand(labelIdx);
+}
+
+uint32 AArch64CGFunc::GetAggCopySize(uint32 offset1, uint32 offset2, uint32 alignment) const {
+  /* Generating a larger sized mem op than alignment if allowed by aggregate starting address */
+  uint32 offsetAlign1 = (offset1 == 0) ? k8ByteSize : offset1;
+  uint32 offsetAlign2 = (offset2 == 0) ? k8ByteSize : offset2;
+  uint32 alignOffset = 1U << (std::min(__builtin_ffs(static_cast<int>(offsetAlign1)),
+                                       __builtin_ffs(static_cast<int>(offsetAlign2))) - 1);
+  if (alignOffset == k8ByteSize || alignOffset == k4ByteSize || alignOffset == k2ByteSize) {
+    return alignOffset;
+  } else if (alignOffset > k8ByteSize) {
+    return k8ByteSize;
+  } else {
+    return alignment;
+  }
+}
+
+OfstOperand &AArch64CGFunc::GetOrCreateOfstOpnd(uint64 offset, uint32 size) {
+  uint64 aarch64OfstRegIdx = offset;
+  aarch64OfstRegIdx = (aarch64OfstRegIdx << 1);
+  if (size == k64BitSize) {
+    ++aarch64OfstRegIdx;
+  }
+  ASSERT(size == k32BitSize || size == k64BitSize, "ofStOpnd size check");
+  auto it = hashOfstOpndTable.find(aarch64OfstRegIdx);
+  if (it != hashOfstOpndTable.end()) {
+    return *it->second;
+  }
+  OfstOperand *res = &CreateOfstOpnd(offset, size);
+  hashOfstOpndTable[aarch64OfstRegIdx] = res;
+  return *res;
+}
+
+void AArch64CGFunc::SelectAddrofAfterRa(Operand &result, StImmOperand &stImm, std::vector<Insn *>& rematInsns) {
+  const MIRSymbol *symbol = stImm.GetSymbol();
+  ASSERT ((symbol->GetStorageClass() != kScAuto) || (symbol->GetStorageClass() != kScFormal), "");
+  Operand *srcOpnd = &result;
+  (void)rematInsns.emplace_back(&GetInsnBuilder()->BuildInsn(MOP_xadrp, result, stImm));
+  if (CGOptions::IsPIC() && symbol->NeedPIC()) {
+    /* ldr     x0, [x0, #:got_lo12:Ljava_2Flang_2FSystem_3B_7Cout] */
+    OfstOperand &offset = CreateOfstOpnd(*stImm.GetSymbol(), stImm.GetOffset(), stImm.GetRelocs());
+    MemOperand &memOpnd = GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, GetPointerSize() * kBitsPerByte,
+        static_cast<RegOperand*>(srcOpnd), nullptr, &offset, nullptr);
+    (void)rematInsns.emplace_back(&GetInsnBuilder()->BuildInsn(
+        memOpnd.GetSize() == k64BitSize ? MOP_xldr : MOP_wldr, result, memOpnd));
+
+    if (stImm.GetOffset() > 0) {
+      ImmOperand &immOpnd = CreateImmOperand(stImm.GetOffset(), result.GetSize(), false);
+      (void)rematInsns.emplace_back(&GetInsnBuilder()->BuildInsn(MOP_xaddrri12, result, result, immOpnd));
+      return;
+    }
+  } else {
+    (void)rematInsns.emplace_back(&GetInsnBuilder()->BuildInsn(MOP_xadrpl12, result, *srcOpnd, stImm));
+  }
+}
+
+MemOperand &AArch64CGFunc::GetOrCreateMemOpndAfterRa(const MIRSymbol &symbol, int32 offset, uint32 size,
+                                                     bool needLow12, RegOperand *regOp,
+                                                     std::vector<Insn *>& rematInsns) {
+  MIRStorageClass storageClass = symbol.GetStorageClass();
+  if ((storageClass == kScGlobal) || (storageClass == kScExtern)) {
+    StImmOperand &stOpnd = CreateStImmOperand(symbol, offset, 0);
+    RegOperand &stAddrOpnd = *regOp;
+    SelectAddrofAfterRa(stAddrOpnd, stOpnd, rematInsns);
+    /* MemOperand::AddrMode_B_OI */
+    return *CreateMemOperand(MemOperand::kAddrModeBOi, size, stAddrOpnd,
+                             nullptr, &GetOrCreateOfstOpnd(0, k32BitSize), &symbol);
+  } else if ((storageClass == kScPstatic) || (storageClass == kScFstatic)) {
+    if (symbol.GetSKind() == kStConst) {
+      ASSERT(offset == 0, "offset should be 0 for constant literals");
+      return *CreateMemOperand(MemOperand::kAddrModeLiteral, size, symbol);
+    } else {
+      if (needLow12) {
+        StImmOperand &stOpnd = CreateStImmOperand(symbol, offset, 0);
+        RegOperand &stAddrOpnd = *regOp;
+        SelectAddrofAfterRa(stAddrOpnd, stOpnd, rematInsns);
+        return *CreateMemOperand(MemOperand::kAddrModeBOi, size, stAddrOpnd,
+                                 nullptr, &GetOrCreateOfstOpnd(0, k32BitSize), &symbol);
+      } else {
+        StImmOperand &stOpnd = CreateStImmOperand(symbol, offset, 0);
+        RegOperand &stAddrOpnd = *regOp;
+        /* adrp    x1, _PTR__cinf_Ljava_2Flang_2FSystem_3B */
+        Insn &insn = GetInsnBuilder()->BuildInsn(MOP_xadrp, stAddrOpnd, stOpnd);
+        rematInsns.emplace_back(&insn);
+        /* ldr     x1, [x1, #:lo12:_PTR__cinf_Ljava_2Flang_2FSystem_3B] */
+        return *CreateMemOperand(MemOperand::kAddrModeLo12Li, size, stAddrOpnd, nullptr,
+                                 &GetOrCreateOfstOpnd(static_cast<uint64>(offset), k32BitSize), &symbol);
+      }
+    }
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+}
+
+MemOperand &AArch64CGFunc::GetOrCreateMemOpnd(const MIRSymbol &symbol, int64 offset, uint32 size, bool forLocalRef,
+                                              bool needLow12, RegOperand *regOp) {
+  MIRStorageClass storageClass = symbol.GetStorageClass();
+  if ((storageClass == kScAuto) || (storageClass == kScFormal)) {
+    AArch64SymbolAlloc *symLoc =
+      static_cast<AArch64SymbolAlloc*>(GetMemlayout()->GetSymAllocInfo(symbol.GetStIndex()));
+    if (forLocalRef) {
+      auto p = GetMemlayout()->GetLocalRefLocMap().find(symbol.GetStIdx());
+      CHECK_FATAL(p != GetMemlayout()->GetLocalRefLocMap().end(), "sym loc should have been defined");
+      symLoc = static_cast<AArch64SymbolAlloc*>(p->second);
+    }
+    ASSERT(symLoc != nullptr, "sym loc should have been defined");
+    /* At this point, we don't know which registers the callee needs to save. */
+    ASSERT((IsFPLRAddedToCalleeSavedList() || (SizeOfCalleeSaved() == 0)),
+           "CalleeSaved won't be known until after Register Allocation");
+    StIdx idx = symbol.GetStIdx();
+    auto it = memOpndsRequiringOffsetAdjustment.find(idx);
+    ASSERT((!IsFPLRAddedToCalleeSavedList() ||
+            ((it != memOpndsRequiringOffsetAdjustment.end()) || (storageClass == kScFormal))),
+           "Memory operand of this symbol should have been added to the hash table");
+    int32 stOffset = GetBaseOffset(*symLoc);
+    if (it != memOpndsRequiringOffsetAdjustment.end()) {
+      if (GetMemlayout()->IsLocalRefLoc(symbol)) {
+        if (!forLocalRef) {
+          return *(it->second);
+        }
+      } else if (mirModule.IsJavaModule()) {
+        return *(it->second);
+      } else {
+        Operand* offOpnd = (it->second)->GetOffset();
+        ASSERT(offOpnd != nullptr, "offOpnd should not be nullptr");
+        if (((static_cast<OfstOperand*>(offOpnd))->GetOffsetValue() == (stOffset + offset)) &&
+            (it->second->GetSize() == size)) {
+          return *(it->second);
+        }
+      }
+    }
+    it = memOpndsForStkPassedArguments.find(idx);
+    if (it != memOpndsForStkPassedArguments.end()) {
+      if (GetMemlayout()->IsLocalRefLoc(symbol)) {
+        if (!forLocalRef) {
+          return *(it->second);
+        }
+      } else {
+        return *(it->second);
+      }
+    }
+
+    RegOperand *baseOpnd = static_cast<RegOperand*>(GetBaseReg(*symLoc));
+    int32 totalOffset = stOffset + static_cast<int32>(offset);
+    /* needs a fresh copy of ImmOperand as we may adjust its offset at a later stage. */
+    OfstOperand *offsetOpnd = nullptr;
+    if (CGOptions::IsBigEndian()) {
+      if (symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed && size < k64BitSize) {
+        offsetOpnd = &CreateOfstOpnd(k4BitSize + static_cast<uint32>(totalOffset), k64BitSize);
+      } else {
+        offsetOpnd = &CreateOfstOpnd(static_cast<uint64>(static_cast<int64>(totalOffset)), k64BitSize);
+      }
+    } else {
+      offsetOpnd = &CreateOfstOpnd(static_cast<uint64>(static_cast<int64>(totalOffset)), k64BitSize);
+    }
+    if (symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed &&
+        MemOperand::IsPIMMOffsetOutOfRange(totalOffset, size)) {
+      ImmOperand *offsetOprand = &CreateImmOperand(totalOffset, k64BitSize, true, kUnAdjustVary);
+      Operand *resImmOpnd = &SelectCopy(*offsetOprand, PTY_i64, PTY_i64);
+      return *CreateMemOperand(MemOperand::kAddrModeBOrX, size, *baseOpnd,
+                               static_cast<RegOperand&>(*resImmOpnd), nullptr, symbol, true);
+    } else {
+      if (symLoc->GetMemSegment()->GetMemSegmentKind() == kMsArgsStkPassed) {
+        offsetOpnd->SetVary(kUnAdjustVary);
+      }
+      MemOperand *res = CreateMemOperand(MemOperand::kAddrModeBOi, size, *baseOpnd,
+          nullptr, offsetOpnd, &symbol);
+      if ((symbol.GetType()->GetKind() != kTypeClass) && !forLocalRef) {
+        memOpndsRequiringOffsetAdjustment[idx] = res;
+      }
+      return *res;
+    }
+  } else if ((storageClass == kScGlobal) || (storageClass == kScExtern)) {
+    StImmOperand &stOpnd = CreateStImmOperand(symbol, offset, 0);
+    if (!regOp) {
+      regOp = static_cast<RegOperand *>(&CreateRegisterOperandOfType(PTY_u64));
+    }
+    RegOperand &stAddrOpnd = *regOp;
+    SelectAddrof(stAddrOpnd, stOpnd);
+    /* MemOperand::AddrMode_B_OI */
+    return *CreateMemOperand(MemOperand::kAddrModeBOi, size, stAddrOpnd,
+                             nullptr, &GetOrCreateOfstOpnd(0, k32BitSize), &symbol);
+  } else if ((storageClass == kScPstatic) || (storageClass == kScFstatic)) {
+    return CreateMemOpndForStatic(symbol, offset, size, needLow12, regOp);
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+}
+
+MemOperand &AArch64CGFunc::CreateMemOpndForStatic(const MIRSymbol &symbol, int64 offset, uint32 size,
+                                                  bool needLow12, RegOperand *regOp) {
+  if (symbol.GetSKind() == kStConst) {
+    ASSERT(offset == 0, "offset should be 0 for constant literals");
+    return *CreateMemOperand(MemOperand::kAddrModeLiteral, size, symbol);
+  } else {
+    /* not guaranteed align for uninitialized symbol */
+    if (needLow12 || (!symbol.IsConst() && CGOptions::IsPIC())) {
+      StImmOperand &stOpnd = CreateStImmOperand(symbol, offset, 0);
+      if (!regOp) {
+        regOp = static_cast<RegOperand *>(&CreateRegisterOperandOfType(PTY_u64));
+      }
+      RegOperand &stAddrOpnd = *regOp;
+      SelectAddrof(stAddrOpnd, stOpnd);
+      return *CreateMemOperand(MemOperand::kAddrModeBOi, size, stAddrOpnd,
+                               nullptr, &GetOrCreateOfstOpnd(0, k32BitSize), &symbol);
+    } else {
+      StImmOperand &stOpnd = CreateStImmOperand(symbol, offset, 0);
+      if (!regOp) {
+        regOp = static_cast<RegOperand *>(&CreateRegisterOperandOfType(PTY_u64));
+      }
+      RegOperand &stAddrOpnd = *regOp;
+      /* adrp    x1, _PTR__cinf_Ljava_2Flang_2FSystem_3B */
+      Insn &insn = GetInsnBuilder()->BuildInsn(MOP_xadrp, stAddrOpnd, stOpnd);
+      GetCurBB()->AppendInsn(insn);
+      if (GetCG()->GetOptimizeLevel() == CGOptions::kLevel0) {
+        GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xadrpl12, stAddrOpnd, stAddrOpnd, stOpnd));
+        return *CreateMemOperand(MemOperand::kAddrModeBOi, size, stAddrOpnd, nullptr,
+                                 &GetOrCreateOfstOpnd(static_cast<uint64>(0), k32BitSize), nullptr);
+      }
+      /* ldr     x1, [x1, #:lo12:_PTR__cinf_Ljava_2Flang_2FSystem_3B] */
+      return *CreateMemOperand(MemOperand::kAddrModeLo12Li, size, stAddrOpnd, nullptr,
+                               &GetOrCreateOfstOpnd(static_cast<uint64>(offset), k32BitSize), &symbol);
+    }
+  }
+}
+
+MemOperand &AArch64CGFunc::HashMemOpnd(MemOperand &tMemOpnd) {
+  auto it = hashMemOpndTable.find(tMemOpnd);
+  if (it != hashMemOpndTable.end()) {
+    return *(it->second);
+  }
+  auto *res = memPool->New<MemOperand>(tMemOpnd);
+  hashMemOpndTable[tMemOpnd] = res;
+  return *res;
+}
+
+MemOperand &AArch64CGFunc::GetOrCreateMemOpnd(MemOperand::AArch64AddressingMode mode, uint32 size,
+                                              RegOperand *base, RegOperand *index, ImmOperand *offset,
+                                              const MIRSymbol *st) {
+  ASSERT(base != nullptr, "nullptr check");
+  MemOperand tMemOpnd(mode, size, *base, index, offset, st);
+  if (base->GetRegisterNumber() == RFP || base->GetRegisterNumber() == RSP) {
+    tMemOpnd.SetStackMem(true);
+  }
+  return HashMemOpnd(tMemOpnd);
+}
+
+MemOperand &AArch64CGFunc::GetOrCreateMemOpnd(MemOperand::AArch64AddressingMode mode, uint32 size,
+                                              RegOperand *base, RegOperand *index, int32 shift,
+                                              bool isSigned) {
+  ASSERT(base != nullptr, "nullptr check");
+  MemOperand tMemOpnd(mode, size, *base, *index, shift, isSigned);
+  if (base->GetRegisterNumber() == RFP || base->GetRegisterNumber() == RSP) {
+    tMemOpnd.SetStackMem(true);
+  }
+  return HashMemOpnd(tMemOpnd);
+}
+
+MemOperand &AArch64CGFunc::GetOrCreateMemOpnd(MemOperand &oldMem) {
+  return HashMemOpnd(oldMem);
+}
+
+/* offset: base offset from FP or SP */
+MemOperand &AArch64CGFunc::CreateMemOpnd(RegOperand &baseOpnd, int64 offset, uint32 size) {
+  OfstOperand &offsetOpnd = CreateOfstOpnd(static_cast<uint64>(offset), k32BitSize);
+  /* do not need to check bit size rotate of sign immediate */
+  bool checkSimm = (offset > kMinSimm64 && offset < kMaxSimm64Pair);
+  if (!checkSimm && !ImmOperand::IsInBitSizeRot(kMaxImmVal12Bits, offset)) {
+    Operand *resImmOpnd = &SelectCopy(CreateImmOperand(offset, k32BitSize, true), PTY_i32, PTY_i32);
+    return *CreateMemOperand(MemOperand::kAddrModeBOrX, size, baseOpnd,
+        static_cast<RegOperand*>(resImmOpnd), nullptr, nullptr);
+  } else {
+    return *CreateMemOperand(MemOperand::kAddrModeBOi, size, baseOpnd,
+                             nullptr, &offsetOpnd, nullptr);
+  }
+}
+
+/* offset: base offset + #:lo12:Label+immediate */
+MemOperand &AArch64CGFunc::CreateMemOpnd(RegOperand &baseOpnd, int64 offset, uint32 size, const MIRSymbol &sym) const {
+  OfstOperand &offsetOpnd = CreateOfstOpnd(static_cast<uint64>(offset), k32BitSize);
+  ASSERT(ImmOperand::IsInBitSizeRot(kMaxImmVal12Bits, offset), "");
+  return *CreateMemOperand(MemOperand::kAddrModeBOi, size, baseOpnd, nullptr, &offsetOpnd, &sym);
+}
+
+RegOperand &AArch64CGFunc::GenStructParamIndex(RegOperand &base, const BaseNode &indexExpr, int shift,
+                                               PrimType baseType) {
+  RegOperand *index = &LoadIntoRegister(*HandleExpr(indexExpr, *(indexExpr.Opnd(0))), PTY_a64);
+  RegOperand *srcOpnd = &CreateRegisterOperandOfType(PTY_a64);
+  ImmOperand *imm = &CreateImmOperand(PTY_a64, shift);
+  SelectShift(*srcOpnd, *index, *imm, kShiftLeft, PTY_a64);
+  RegOperand *result = &CreateRegisterOperandOfType(PTY_a64);
+  SelectAdd(*result, base, *srcOpnd, PTY_a64);
+
+  OfstOperand *offopnd = &CreateOfstOpnd(0, k32BitSize);
+  MemOperand &mo =
+      GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, result, nullptr, offopnd, nullptr);
+  RegOperand &structAddr = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+  GetCurBB()->AppendInsn(
+      GetInsnBuilder()->BuildInsn(PickLdInsn(GetPrimTypeBitSize(baseType), baseType), structAddr, mo));
+  return structAddr;
+}
+
+/*
+ *  case 1: iread a64 <* <* void>> 0 (add a64 (
+ *  addrof a64 $__reg_jni_func_tab$$libcore_all_dex,
+ *  mul a64 (
+ *    cvt a64 i32 (constval i32 21),
+ *    constval a64 8)))
+ *
+ * case 2 : iread u32 <* u8> 0 (add a64 (regread a64 %61, constval a64 3))
+ * case 3 : iread u32 <* u8> 0 (add a64 (regread a64 %61, regread a64 %65))
+ * case 4 : iread u32 <* u8> 0 (add a64 (cvt a64 i32(regread  %n)))
+ */
+MemOperand *AArch64CGFunc::CheckAndCreateExtendMemOpnd(PrimType ptype, const BaseNode &addrExpr, int64 offset,
+                                                       AArch64isa::MemoryOrdering memOrd) {
+  aggParamReg = nullptr;
+  if (memOrd != AArch64isa::kMoNone || addrExpr.GetOpCode() != OP_add || offset != 0) {
+    return nullptr;
+  }
+  BaseNode *baseExpr = addrExpr.Opnd(0);
+  BaseNode *addendExpr = addrExpr.Opnd(1);
+
+  if (baseExpr->GetOpCode() == OP_regread) {
+    /* case 2 */
+    if (addendExpr->GetOpCode() == OP_constval) {
+      ASSERT(addrExpr.GetNumOpnds() == 2, "Unepect expr operand in CheckAndCreateExtendMemOpnd");
+      ConstvalNode *constOfstNode = static_cast<ConstvalNode*>(addendExpr);
+      ASSERT(constOfstNode->GetConstVal()->GetKind() == kConstInt, "expect MIRIntConst");
+      MIRIntConst *intOfst = safe_cast<MIRIntConst>(constOfstNode->GetConstVal());
+      CHECK_FATAL(intOfst != nullptr, "just checking");
+      /* discard large offset and negative offset */
+      if (intOfst->GetExtValue() > INT32_MAX || intOfst->IsNegative()) {
+        return nullptr;
+      }
+      uint32 scale = static_cast<uint32>(intOfst->GetExtValue());
+      OfstOperand &ofstOpnd = GetOrCreateOfstOpnd(scale, k32BitSize);
+      uint32 dsize = GetPrimTypeBitSize(ptype);
+      MemOperand *memOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, GetPrimTypeBitSize(ptype),
+          SelectRegread(*static_cast<RegreadNode*>(baseExpr)), nullptr, &ofstOpnd, nullptr);
+      return IsOperandImmValid(PickLdInsn(dsize, ptype), memOpnd, kInsnSecondOpnd) ? memOpnd : nullptr;
+      /* case 3 */
+    } else if (addendExpr->GetOpCode() == OP_regread) {
+      CHECK_FATAL(addrExpr.GetNumOpnds() == 2, "Unepect expr operand in CheckAndCreateExtendMemOpnd");
+      if (GetPrimTypeSize(baseExpr->GetPrimType()) != GetPrimTypeSize(addendExpr->GetPrimType())) {
+        return nullptr;
+      }
+
+      auto *baseReg = SelectRegread(*static_cast<RegreadNode *>(baseExpr));
+      auto *indexReg = SelectRegread(*static_cast<RegreadNode *>(addendExpr));
+      MemOperand *memOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOrX, GetPrimTypeBitSize(ptype), baseReg, indexReg,
+                                                nullptr, nullptr);
+      if (CGOptions::IsArm64ilp32() && IsSignedInteger(addendExpr->GetPrimType())) {
+        memOpnd->SetExtend(memOpnd->GetExtend() | MemOperand::ExtendInfo::kSignExtend);
+      }
+      return memOpnd;
+      /* case 4 */
+    } else if (addendExpr->GetOpCode() == OP_cvt && addendExpr->GetNumOpnds() == 1) {
+      int shiftAmount = 0;
+      BaseNode *cvtRegreadNode = addendExpr->Opnd(kInsnFirstOpnd);
+      if (cvtRegreadNode->GetOpCode() == OP_regread && cvtRegreadNode->IsLeaf()) {
+        uint32 fromSize = GetPrimTypeBitSize(cvtRegreadNode->GetPrimType());
+        uint32 toSize = GetPrimTypeBitSize(addendExpr->GetPrimType());
+
+        if (toSize < fromSize) {
+          return nullptr;
+        }
+
+        MemOperand *memOpnd = &GetOrCreateMemOpnd(
+            MemOperand::kAddrModeBOrX, GetPrimTypeBitSize(ptype),
+            SelectRegread(*static_cast<RegreadNode*>(baseExpr)),
+            SelectRegread(*static_cast<RegreadNode*>(cvtRegreadNode)), shiftAmount, toSize != fromSize);
+        return memOpnd;
+      }
+    }
+  }
+  if (addendExpr->GetOpCode() != OP_mul || !IsPrimitiveInteger(ptype)) {
+    return nullptr;
+  }
+  BaseNode *indexExpr, *scaleExpr;
+  indexExpr = addendExpr->Opnd(0);
+  scaleExpr = addendExpr->Opnd(1);
+  if (scaleExpr->GetOpCode() != OP_constval) {
+    return nullptr;
+  }
+  ConstvalNode *constValNode = static_cast<ConstvalNode*>(scaleExpr);
+  CHECK_FATAL(constValNode->GetConstVal()->GetKind() == kConstInt, "expect MIRIntConst");
+  MIRIntConst *mirIntConst = safe_cast<MIRIntConst>(constValNode->GetConstVal());
+  CHECK_FATAL(mirIntConst != nullptr, "just checking");
+  int32 scale = static_cast<int32>(mirIntConst->GetExtValue());
+  if (scale < 0) {
+    return nullptr;
+  }
+  uint32 unsignedScale = static_cast<uint32>(scale);
+  if (unsignedScale != GetPrimTypeSize(ptype) || indexExpr->GetOpCode() != OP_cvt) {
+    return nullptr;
+  }
+  /* 8 is 1 << 3; 4 is 1 << 2; 2 is 1 << 1; 1 is 1 << 0 */
+  int32 shift = (unsignedScale == 8) ? 3 : ((unsignedScale == 4) ? 2 : ((unsignedScale == 2) ? 1 : 0));
+  RegOperand &base = static_cast<RegOperand&>(LoadIntoRegister(*HandleExpr(addrExpr, *baseExpr), PTY_a64));
+  TypeCvtNode *typeCvtNode = static_cast<TypeCvtNode*>(indexExpr);
+  PrimType fromType = typeCvtNode->FromType();
+  PrimType toType = typeCvtNode->GetPrimType();
+  if (isAggParamInReg) {
+    aggParamReg = &GenStructParamIndex(base, *indexExpr, shift, ptype);
+    return nullptr;
+  }
+  MemOperand *memOpnd = nullptr;
+  if ((fromType == PTY_i32) && (toType == PTY_a64)) {
+    RegOperand &index =
+        static_cast<RegOperand&>(LoadIntoRegister(*HandleExpr(*indexExpr, *indexExpr->Opnd(0)), PTY_i32));
+    memOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOrX, GetPrimTypeBitSize(ptype), &base, &index,
+                                  shift, true);
+  } else if ((fromType == PTY_u32) && (toType == PTY_a64)) {
+    RegOperand &index =
+        static_cast<RegOperand&>(LoadIntoRegister(*HandleExpr(*indexExpr, *indexExpr->Opnd(0)), PTY_u32));
+    memOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOrX, GetPrimTypeBitSize(ptype), &base, &index,
+                                  shift, false);
+  }
+  return memOpnd;
+}
+
+MemOperand &AArch64CGFunc::CreateNonExtendMemOpnd(PrimType ptype, const BaseNode &parent, BaseNode &addrExpr,
+                                                  int64 offset) {
+  Operand *addrOpnd = nullptr;
+  if ((addrExpr.GetOpCode() == OP_add || addrExpr.GetOpCode() == OP_sub) &&
+      addrExpr.Opnd(1)->GetOpCode() == OP_constval) {
+    addrOpnd = HandleExpr(addrExpr, *addrExpr.Opnd(0));
+    ConstvalNode *constOfstNode = static_cast<ConstvalNode*>(addrExpr.Opnd(1));
+    ASSERT(constOfstNode->GetConstVal()->GetKind() == kConstInt, "expect MIRIntConst");
+    MIRIntConst *intOfst = safe_cast<MIRIntConst>(constOfstNode->GetConstVal());
+    CHECK_FATAL(intOfst != nullptr, "just checking");
+    offset = (addrExpr.GetOpCode() == OP_add) ? offset + intOfst->GetSXTValue() : offset - intOfst->GetSXTValue();
+  } else {
+    addrOpnd = HandleExpr(parent, addrExpr);
+  }
+  addrOpnd = static_cast<RegOperand*>(&LoadIntoRegister(*addrOpnd, PTY_a64));
+  Insn *lastInsn = GetCurBB() == nullptr ? nullptr : GetCurBB()->GetLastInsn();
+  if ((addrExpr.GetOpCode() == OP_CG_array_elem_add) && (offset == 0) && lastInsn &&
+      (lastInsn->GetMachineOpcode() == MOP_xadrpl12) &&
+      (&lastInsn->GetOperand(kInsnFirstOpnd) == &lastInsn->GetOperand(kInsnSecondOpnd))) {
+    Operand &opnd = lastInsn->GetOperand(kInsnThirdOpnd);
+    StImmOperand &stOpnd = static_cast<StImmOperand&>(opnd);
+
+    OfstOperand &ofstOpnd = GetOrCreateOfstOpnd(static_cast<uint64>(stOpnd.GetOffset()), k32BitSize);
+    MemOperand &tmpMemOpnd = GetOrCreateMemOpnd(MemOperand::kAddrModeLo12Li, GetPrimTypeBitSize(ptype),
+        static_cast<RegOperand*>(addrOpnd), nullptr, &ofstOpnd, stOpnd.GetSymbol());
+    GetCurBB()->RemoveInsn(*GetCurBB()->GetLastInsn());
+    return tmpMemOpnd;
+  } else {
+    OfstOperand &ofstOpnd = GetOrCreateOfstOpnd(static_cast<uint64>(offset), k64BitSize);
+    return GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, GetPrimTypeBitSize(ptype),
+                              static_cast<RegOperand*>(addrOpnd), nullptr, &ofstOpnd, nullptr);
+  }
+}
+
+/*
+ * Create a memory operand with specified data type and memory ordering, making
+ * use of aarch64 extend register addressing mode when possible.
+ */
+MemOperand &AArch64CGFunc::CreateMemOpnd(PrimType ptype, const BaseNode &parent, BaseNode &addrExpr, int64 offset,
+                                         AArch64isa::MemoryOrdering memOrd) {
+  MemOperand *memOpnd = CheckAndCreateExtendMemOpnd(ptype, addrExpr, offset, memOrd);
+  if (memOpnd != nullptr) {
+    return *memOpnd;
+  }
+  return CreateNonExtendMemOpnd(ptype, parent, addrExpr, offset);
+}
+
+MemOperand *AArch64CGFunc::CreateMemOpndOrNull(PrimType ptype, const BaseNode &parent, BaseNode &addrExpr, int64 offset,
+                                               AArch64isa::MemoryOrdering memOrd) {
+  MemOperand *memOpnd = CheckAndCreateExtendMemOpnd(ptype, addrExpr, offset, memOrd);
+  if (memOpnd != nullptr) {
+    return memOpnd;
+  } else if (aggParamReg != nullptr) {
+    return nullptr;
+  }
+  return &CreateNonExtendMemOpnd(ptype, parent, addrExpr, offset);
+}
+
+Operand &AArch64CGFunc::GetOrCreateFuncNameOpnd(const MIRSymbol &symbol) const {
+  return *memPool->New<FuncNameOperand>(symbol);
+}
+
+Operand &AArch64CGFunc::GetOrCreateRflag() {
+  if (rcc == nullptr) {
+    rcc = &CreateRflagOperand();
+  }
+  return *rcc;
+}
+
+const Operand *AArch64CGFunc::GetRflag() const {
+  return rcc;
+}
+
+RegOperand &AArch64CGFunc::GetOrCreatevaryreg() {
+  if (vary == nullptr) {
+    regno_t vRegNO = NewVReg(kRegTyVary, k8ByteSize);
+    vary = &CreateVirtualRegisterOperand(vRegNO);
+  }
+  return *vary;
+}
+
+/* the first operand in opndvec is return opnd */
+void AArch64CGFunc::SelectLibCall(const std::string &funcName, std::vector<Operand*> &opndVec, PrimType primType,
+                                  PrimType retPrimType, bool is2ndRet) {
+  std::vector <PrimType> pt;
+  pt.push_back(retPrimType);
+  for (size_t i = 0; i < opndVec.size(); ++i) {
+    pt.push_back(primType);
+  }
+  SelectLibCallNArg(funcName, opndVec, pt, retPrimType, is2ndRet);
+  return;
+}
+
+void AArch64CGFunc::SelectLibCallNArg(const std::string &funcName, std::vector<Operand*> &opndVec,
+                                      std::vector<PrimType> pt, PrimType retPrimType, bool is2ndRet) {
+  std::string newName = funcName;
+  // Check whether we have a maple version of libcall and we want to use it instead.
+  if (!CGOptions::IsDuplicateAsmFileEmpty() && asmMap.find(funcName) != asmMap.end()) {
+    newName = asmMap.at(funcName);
+  }
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  st->SetNameStrIdx(newName);
+  st->SetStorageClass(kScExtern);
+  st->SetSKind(kStFunc);
+  /* setup the type of the callee function */
+  std::vector<TyIdx> vec;
+  std::vector<TypeAttrs> vecAt;
+  for (size_t i = 1; i < opndVec.size(); ++i) {
+    (void)vec.emplace_back(GlobalTables::GetTypeTable().GetTypeTable()[static_cast<size_t>(pt[i])]->GetTypeIndex());
+    vecAt.emplace_back(TypeAttrs());
+  }
+
+  MIRType *retType = GlobalTables::GetTypeTable().GetTypeTable().at(static_cast<size_t>(retPrimType));
+  st->SetTyIdx(GetBecommon().BeGetOrCreateFunctionType(retType->GetTypeIndex(), vec, vecAt)->GetTypeIndex());
+
+  if (GetCG()->GenerateVerboseCG()) {
+    auto &comment = GetOpndBuilder()->CreateComment("lib call : " + newName);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildCommentInsn(comment));
+  }
+
+  AArch64CallConvImpl parmLocator(GetBecommon());
+  CCLocInfo ploc;
+  /* setup actual parameters */
+  ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+  for (size_t i = 1; i < opndVec.size(); ++i) {
+    ASSERT(pt[i] != PTY_void, "primType check");
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeTable()[static_cast<size_t>(pt[i])];
+    Operand *stOpnd = opndVec[i];
+    if (stOpnd->GetKind() != Operand::kOpdRegister) {
+      stOpnd = &SelectCopy(*stOpnd, pt[i], pt[i]);
+    }
+    RegOperand *expRegOpnd = static_cast<RegOperand*>(stOpnd);
+    parmLocator.LocateNextParm(*ty, ploc);
+    if (ploc.reg0 != 0) {  /* load to the register */
+      RegOperand &parmRegOpnd = GetOrCreatePhysicalRegisterOperand(
+          static_cast<AArch64reg>(ploc.reg0), expRegOpnd->GetSize(), GetRegTyFromPrimTy(pt[i]));
+      SelectCopy(parmRegOpnd, pt[i], *expRegOpnd, pt[i]);
+      srcOpnds->PushOpnd(parmRegOpnd);
+    }
+    ASSERT(ploc.reg1 == 0, "SelectCall NYI");
+  }
+
+  MIRSymbol *sym = GetFunction().GetLocalOrGlobalSymbol(st->GetStIdx(), false);
+  Insn &callInsn = AppendCall(*sym, *srcOpnds);
+  MIRType *callRetType = GlobalTables::GetTypeTable().GetTypeTable().at(static_cast<int32>(retPrimType));
+  if (callRetType != nullptr) {
+    callInsn.SetRetSize(static_cast<uint32>(callRetType->GetSize()));
+    callInsn.SetIsCallReturnUnsigned(IsUnsignedInteger(callRetType->GetPrimType()));
+  }
+  GetFunction().SetHasCall();
+  /* get return value */
+  Operand *opnd0 = opndVec[0];
+  CCLocInfo retMech;
+  parmLocator.InitReturnInfo(*(GlobalTables::GetTypeTable().GetTypeTable().at(retPrimType)), retMech);
+  if (retMech.GetRegCount() <= 0) {
+    CHECK_FATAL(false, "should return from register");
+  }
+  if (!opnd0->IsRegister()) {
+    CHECK_FATAL(false, "nyi");
+  }
+  RegOperand *regOpnd = static_cast<RegOperand*>(opnd0);
+  AArch64reg regNum = static_cast<AArch64reg>(is2ndRet ? retMech.GetReg1() : retMech.GetReg0());
+  if (regOpnd->GetRegisterNumber() != regNum) {
+    RegOperand &retOpnd = GetOrCreatePhysicalRegisterOperand(regNum, regOpnd->GetSize(),
+                                                             GetRegTyFromPrimTy(retPrimType));
+    SelectCopy(*opnd0, retPrimType, retOpnd, retPrimType);
+  }
+}
+
+RegOperand *AArch64CGFunc::GetBaseReg(const SymbolAlloc &symAlloc) {
+  MemSegmentKind sgKind = symAlloc.GetMemSegment()->GetMemSegmentKind();
+  ASSERT(((sgKind == kMsArgsRegPassed) || (sgKind == kMsLocals) || (sgKind == kMsRefLocals) ||
+      (sgKind == kMsArgsToStkPass) || (sgKind == kMsArgsStkPassed)), "NYI");
+
+  if (sgKind == kMsArgsStkPassed) {
+    return &GetOrCreatevaryreg();
+  }
+
+  if (fsp == nullptr) {
+    if (GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc) {
+      fsp = &GetOrCreatePhysicalRegisterOperand(RSP, GetPointerSize() * kBitsPerByte, kRegTyInt);
+    } else {
+      fsp = &GetOrCreatePhysicalRegisterOperand(RFP, GetPointerSize() * kBitsPerByte, kRegTyInt);
+    }
+  }
+  return fsp;
+}
+
+int32 AArch64CGFunc::GetBaseOffset(const SymbolAlloc &symbolAlloc) {
+  const AArch64SymbolAlloc *symAlloc = static_cast<const AArch64SymbolAlloc*>(&symbolAlloc);
+  /* Call Frame layout of AArch64
+   * Refer to V2 in aarch64_memlayout.h.
+   * Do Not change this unless you know what you do
+   */
+  const int32 sizeofFplr = static_cast<int32>(2 * kIntregBytelen);
+  MemSegmentKind sgKind = symAlloc->GetMemSegment()->GetMemSegmentKind();
+  AArch64MemLayout *memLayout = static_cast<AArch64MemLayout*>(this->GetMemlayout());
+  if (sgKind == kMsArgsStkPassed) {  /* for callees */
+    int32 offset = static_cast<int32>(symAlloc->GetOffset());
+    return offset;
+  } else if (sgKind == kMsArgsRegPassed) {
+    int32 baseOffset;
+    if (GetCG()->IsLmbc()) {
+      baseOffset = static_cast<int32>(symAlloc->GetOffset() + memLayout->GetSizeOfRefLocals() +
+                   memLayout->SizeOfArgsToStackPass());   /* SP relative */
+    } else {
+      baseOffset = static_cast<int32>(memLayout->GetSizeOfLocals() + symAlloc->GetOffset() +
+                   memLayout->GetSizeOfRefLocals());
+    }
+    return baseOffset + sizeofFplr;
+  } else if (sgKind == kMsRefLocals) {
+    int32 baseOffset = static_cast<int32>(symAlloc->GetOffset()) + static_cast<int32>(memLayout->GetSizeOfLocals());
+    return baseOffset + sizeofFplr;
+  } else if (sgKind == kMsLocals) {
+    if (GetCG()->IsLmbc()) {
+      CHECK_FATAL(false, "invalid lmbc's locals");
+    }
+    int32 baseOffset = symAlloc->GetOffset();
+    return baseOffset + sizeofFplr;
+  } else if (sgKind == kMsSpillReg) {
+    int32 baseOffset;
+    if (GetCG()->IsLmbc()) {
+      baseOffset = static_cast<int32>(symAlloc->GetOffset() +
+                   memLayout->SizeOfArgsRegisterPassed() + memLayout->GetSizeOfRefLocals() +
+                   memLayout->SizeOfArgsToStackPass());
+    } else {
+      baseOffset = static_cast<int32>(symAlloc->GetOffset() +
+                   memLayout->SizeOfArgsRegisterPassed() + memLayout->GetSizeOfLocals() +
+                   memLayout->GetSizeOfRefLocals());
+    }
+    return baseOffset + sizeofFplr;
+  } else if (sgKind == kMsArgsToStkPass) {  /* this is for callers */
+    return static_cast<int32>(symAlloc->GetOffset());
+  } else {
+    CHECK_FATAL(false, "sgKind check");
+  }
+  return 0;
+}
+
+void AArch64CGFunc::AppendCall(const MIRSymbol &funcSymbol) {
+  ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+  AppendCall(funcSymbol, *srcOpnds);
+}
+
+void AArch64CGFunc::DBGFixCallFrameLocationOffsets() {
+  unsigned idx = 0;
+  for (DBGExprLoc *el : GetDbgCallFrameLocations(true)) {
+    if (el && el->GetSimpLoc() && el->GetSimpLoc()->GetDwOp() == DW_OP_fbreg) {
+      SymbolAlloc *symloc = static_cast<SymbolAlloc*>(el->GetSymLoc());
+      int32 offset = GetBaseOffset(*symloc) - ((idx < AArch64Abi::kNumIntParmRegs) ? GetDbgCallFrameOffset() : 0);
+      el->SetFboffset(offset);
+    }
+    idx++;
+  }
+  for (DBGExprLoc *el : GetDbgCallFrameLocations(false)) {
+    if (el->GetSimpLoc()->GetDwOp() == DW_OP_fbreg) {
+      SymbolAlloc *symloc = static_cast<SymbolAlloc*>(el->GetSymLoc());
+      int32 offset = GetBaseOffset(*symloc) - GetDbgCallFrameOffset();
+      el->SetFboffset(offset);
+    }
+  }
+}
+
+void AArch64CGFunc::SelectAddAfterInsn(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType,
+                                       bool isDest, Insn &insn) {
+  uint32 dsize = GetPrimTypeBitSize(primType);
+  bool is64Bits = (dsize == k64BitSize);
+  ASSERT(opnd0.GetKind() == Operand::kOpdRegister, "Spill memory operand should based on register");
+  ASSERT((opnd1.GetKind() == Operand::kOpdImmediate || opnd1.GetKind() == Operand::kOpdOffset),
+         "Spill memory operand should be with a immediate offset.");
+
+  ImmOperand *immOpnd = static_cast<ImmOperand*>(&opnd1);
+
+  MOperator mOpCode = MOP_undef;
+  Insn *curInsn = &insn;
+  /* lower 24 bits has 1, higher bits are all 0 */
+  if (immOpnd->IsInBitSize(kMaxImmVal24Bits, 0)) {
+    /* lower 12 bits and higher 12 bits both has 1 */
+    Operand *newOpnd0 = &opnd0;
+    if (!(immOpnd->IsInBitSize(kMaxImmVal12Bits, 0) ||
+          immOpnd->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits))) {
+      /* process higher 12 bits */
+      ImmOperand &immOpnd2 =
+          CreateImmOperand(static_cast<int64>(static_cast<uint64>(immOpnd->GetValue()) >> kMaxImmVal12Bits),
+                           immOpnd->GetSize(), immOpnd->IsSignedValue());
+      mOpCode = is64Bits ? MOP_xaddrri24 : MOP_waddrri24;
+      BitShiftOperand &shiftopnd = CreateBitShiftOperand(BitShiftOperand::kLSL, kShiftAmount12, k64BitSize);
+      Insn &newInsn = GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, opnd0, immOpnd2, shiftopnd);
+      ASSERT(IsOperandImmValid(mOpCode, &immOpnd2, kInsnThirdOpnd), "immOpnd2 appears invalid");
+      if (isDest) {
+        insn.GetBB()->InsertInsnAfter(insn, newInsn);
+      } else {
+        insn.GetBB()->InsertInsnBefore(insn, newInsn);
+      }
+      /* get lower 12 bits value */
+      immOpnd->ModuloByPow2(kMaxImmVal12Bits);
+      newOpnd0 = &resOpnd;
+      curInsn = &newInsn;
+    }
+    /* process lower 12 bits value */
+    mOpCode = is64Bits ? MOP_xaddrri12 : MOP_waddrri12;
+    Insn &newInsn = GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, *newOpnd0, *immOpnd);
+    ASSERT(IsOperandImmValid(mOpCode, immOpnd, kInsnThirdOpnd), "immOpnd appears invalid");
+    if (isDest) {
+      insn.GetBB()->InsertInsnAfter(*curInsn, newInsn);
+    } else {
+      insn.GetBB()->InsertInsnBefore(insn, newInsn);
+    }
+  } else {
+    /* load into register */
+    RegOperand &movOpnd = GetOrCreatePhysicalRegisterOperand(R16, dsize, kRegTyInt);
+    mOpCode = is64Bits ? MOP_xmovri64 : MOP_wmovri32;
+    Insn &movInsn = GetInsnBuilder()->BuildInsn(mOpCode, movOpnd, *immOpnd);
+    mOpCode = is64Bits ? MOP_xaddrrr : MOP_waddrrr;
+    Insn &newInsn = GetInsnBuilder()->BuildInsn(mOpCode, resOpnd, opnd0, movOpnd);
+    if (isDest) {
+      (void)insn.GetBB()->InsertInsnAfter(insn, newInsn);
+      (void)insn.GetBB()->InsertInsnAfter(insn, movInsn);
+    } else {
+      (void)insn.GetBB()->InsertInsnBefore(insn, movInsn);
+      (void)insn.GetBB()->InsertInsnBefore(insn, newInsn);
+    }
+  }
+}
+
+MemOperand *AArch64CGFunc::AdjustMemOperandIfOffsetOutOfRange(
+    MemOperand *memOpnd, regno_t vrNum, bool isDest, Insn &insn, AArch64reg regNum, bool &isOutOfRange) {
+  if (vrNum >= vRegTable.size()) {
+    CHECK_FATAL(false, "index out of range in AArch64CGFunc::AdjustMemOperandIfOffsetOutOfRange");
+  }
+  uint32 dataSize = GetOrCreateVirtualRegisterOperand(vrNum).GetSize();
+  if (IsImmediateOffsetOutOfRange(*memOpnd, dataSize)) {
+    if (CheckIfSplitOffsetWithAdd(*memOpnd, dataSize)) {
+      isOutOfRange = true;
+    }
+    memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, dataSize, regNum, isDest, &insn);
+  } else {
+    isOutOfRange = false;
+  }
+  return memOpnd;
+}
+
+void AArch64CGFunc::FreeSpillRegMem(regno_t vrNum) {
+  MemOperand *memOpnd = nullptr;
+
+  auto p = spillRegMemOperands.find(vrNum);
+  if (p != spillRegMemOperands.end()) {
+    memOpnd = p->second;
+  }
+
+  if ((memOpnd == nullptr) && IsVRegNOForPseudoRegister(vrNum)) {
+    auto pSecond = pRegSpillMemOperands.find(GetPseudoRegIdxFromVirtualRegNO(vrNum));
+    if (pSecond != pRegSpillMemOperands.end()) {
+      memOpnd = pSecond->second;
+    }
+  }
+
+  if (memOpnd == nullptr) {
+    ASSERT(false, "free spillreg have no mem");
+    return;
+  }
+
+  uint32 size = memOpnd->GetSize();
+  MapleUnorderedMap<uint32, SpillMemOperandSet*>::iterator iter;
+  if ((iter = reuseSpillLocMem.find(size)) != reuseSpillLocMem.end()) {
+    iter->second->Add(*memOpnd);
+  } else {
+    reuseSpillLocMem[size] = memPool->New<SpillMemOperandSet>(*GetFuncScopeAllocator());
+    reuseSpillLocMem[size]->Add(*memOpnd);
+  }
+}
+
+MemOperand *AArch64CGFunc::GetOrCreatSpillMem(regno_t vrNum) {
+  /* NOTES: must used in RA, not used in other place. */
+  if (IsVRegNOForPseudoRegister(vrNum)) {
+    auto p = pRegSpillMemOperands.find(GetPseudoRegIdxFromVirtualRegNO(vrNum));
+    if (p != pRegSpillMemOperands.end()) {
+      return p->second;
+    }
+  }
+
+  auto p = spillRegMemOperands.find(vrNum);
+  if (p == spillRegMemOperands.end()) {
+    if (vrNum >= vRegTable.size()) {
+      CHECK_FATAL(false, "index out of range in AArch64CGFunc::FreeSpillRegMem");
+    }
+    uint32 memBitSize = k64BitSize;
+    auto it = reuseSpillLocMem.find(memBitSize);
+    if (it != reuseSpillLocMem.end()) {
+      MemOperand *memOpnd = it->second->GetOne();
+      if (memOpnd != nullptr) {
+        (void)spillRegMemOperands.emplace(std::pair<regno_t, MemOperand*>(vrNum, memOpnd));
+        return memOpnd;
+      }
+    }
+
+    RegOperand &baseOpnd = GetOrCreateStackBaseRegOperand();
+    int64 offset = GetOrCreatSpillRegLocation(vrNum);
+    OfstOperand *offsetOpnd = &CreateOfstOpnd(static_cast<uint64>(offset), k64BitSize);
+    MemOperand *memOpnd = CreateMemOperand(MemOperand::kAddrModeBOi, memBitSize, baseOpnd,
+                                           nullptr, offsetOpnd, nullptr);
+    (void)spillRegMemOperands.emplace(std::pair<regno_t, MemOperand*>(vrNum, memOpnd));
+    return memOpnd;
+  } else {
+    return p->second;
+  }
+}
+
+MemOperand *AArch64CGFunc::GetPseudoRegisterSpillMemoryOperand(PregIdx i) {
+  MapleUnorderedMap<PregIdx, MemOperand *>::iterator p;
+  if (GetCG()->GetOptimizeLevel() == CGOptions::kLevel0) {
+    p = pRegSpillMemOperands.end();
+  } else {
+    p = pRegSpillMemOperands.find(i);
+  }
+  if (p != pRegSpillMemOperands.end()) {
+    return p->second;
+  }
+  int64 offset = GetPseudoRegisterSpillLocation(i);
+  MIRPreg *preg = GetFunction().GetPregTab()->PregFromPregIdx(i);
+  uint32 bitLen = GetPrimTypeSize(preg->GetPrimType()) * kBitsPerByte;
+  RegOperand &base = GetOrCreateFramePointerRegOperand();
+
+  OfstOperand &ofstOpnd = GetOrCreateOfstOpnd(static_cast<uint64>(offset), k32BitSize);
+  MemOperand &memOpnd = GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, bitLen, &base, nullptr, &ofstOpnd, nullptr);
+  if (IsImmediateOffsetOutOfRange(memOpnd, bitLen)) {
+    MemOperand &newMemOpnd = SplitOffsetWithAddInstruction(memOpnd, bitLen);
+    (void)pRegSpillMemOperands.emplace(std::pair<PregIdx, MemOperand*>(i, &newMemOpnd));
+    return &newMemOpnd;
+  }
+  (void)pRegSpillMemOperands.emplace(std::pair<PregIdx, MemOperand*>(i, &memOpnd));
+  return &memOpnd;
+}
+
+/* Get the number of return register of current function. */
+AArch64reg AArch64CGFunc::GetReturnRegisterNumber() {
+  AArch64CallConvImpl retLocator(GetBecommon());
+  CCLocInfo retMech;
+  retLocator.InitReturnInfo(*(GetFunction().GetReturnType()), retMech);
+  if (retMech.GetRegCount() > 0) {
+    return static_cast<AArch64reg>(retMech.GetReg0());
+  }
+  return kRinvalid;
+}
+
+bool AArch64CGFunc::CanLazyBinding(const Insn &ldrInsn) const {
+  Operand &memOpnd = ldrInsn.GetOperand(1);
+  auto &aarchMemOpnd = static_cast<MemOperand&>(memOpnd);
+  if (aarchMemOpnd.GetAddrMode() != MemOperand::kAddrModeLo12Li) {
+    return false;
+  }
+
+  const MIRSymbol *sym = aarchMemOpnd.GetSymbol();
+  CHECK_FATAL(sym != nullptr, "sym can't be nullptr");
+  if (sym->IsMuidFuncDefTab() || sym->IsMuidFuncUndefTab() ||
+      sym->IsMuidDataDefTab() || sym->IsMuidDataUndefTab() ||
+      (sym->IsReflectionClassInfo() && !sym->IsReflectionArrayClassInfo())) {
+    return true;
+  }
+
+  return false;
+}
+
+/*
+ *  add reg, reg, __PTR_C_STR_...
+ *  ldr reg1, [reg]
+ *  =>
+ *  ldr reg1, [reg, #:lo12:__Ptr_C_STR_...]
+ */
+void AArch64CGFunc::ConvertAdrpl12LdrToLdr() {
+  FOR_ALL_BB(bb, this) {
+    FOR_BB_INSNS_SAFE(insn, bb, nextInsn) {
+      nextInsn = insn->GetNextMachineInsn();
+      if (nextInsn == nullptr) {
+        break;
+      }
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      /* check first insn */
+      MOperator thisMop = insn->GetMachineOpcode();
+      if (thisMop != MOP_xadrpl12) {
+        continue;
+      }
+      /* check second insn */
+      MOperator nextMop = nextInsn->GetMachineOpcode();
+      if (!(((nextMop >= MOP_wldrsb) && (nextMop <= MOP_dldp)) || ((nextMop >= MOP_wstrb) && (nextMop <= MOP_dstp)))) {
+        continue;
+      }
+
+      /* Check if base register of nextInsn and the dest operand of insn are identical. */
+      MemOperand *memOpnd = static_cast<MemOperand*>(nextInsn->GetMemOpnd());
+      CHECK_FATAL(memOpnd != nullptr, "memOpnd can't be nullptr");
+
+      /* Only for AddrMode_B_OI addressing mode. */
+      if (memOpnd->GetAddrMode() != MemOperand::kAddrModeBOi) {
+        continue;
+      }
+
+      /* Only for intact memory addressing. */
+      if (!memOpnd->IsIntactIndexed()) {
+        continue;
+      }
+
+      auto &regOpnd = static_cast<RegOperand&>(insn->GetOperand(0));
+
+      /* Check if dest operand of insn is idential with base register of nextInsn. */
+      RegOperand *baseReg = memOpnd->GetBaseRegister();
+      CHECK_FATAL(baseReg != nullptr, "baseReg can't be nullptr");
+      if (baseReg->GetRegisterNumber() != regOpnd.GetRegisterNumber()) {
+        continue;
+      }
+
+      StImmOperand &stImmOpnd = static_cast<StImmOperand&>(insn->GetOperand(kInsnThirdOpnd));
+      OfstOperand &ofstOpnd = GetOrCreateOfstOpnd(
+          static_cast<uint64>(stImmOpnd.GetOffset() + memOpnd->GetOffsetImmediate()->GetOffsetValue()), k32BitSize);
+      RegOperand &newBaseOpnd = static_cast<RegOperand&>(insn->GetOperand(kInsnSecondOpnd));
+      MemOperand &newMemOpnd = GetOrCreateMemOpnd(MemOperand::kAddrModeLo12Li, memOpnd->GetSize(),
+                                                  &newBaseOpnd, nullptr, &ofstOpnd, stImmOpnd.GetSymbol());
+      nextInsn->SetOperand(1, newMemOpnd);
+      bb->RemoveInsn(*insn);
+    }
+  }
+}
+
+/*
+ * adrp reg1, __muid_func_undef_tab..
+ * ldr reg2, [reg1, #:lo12:__muid_func_undef_tab..]
+ * =>
+ * intrinsic_adrp_ldr reg2, __muid_func_undef_tab...
+ */
+void AArch64CGFunc::ConvertAdrpLdrToIntrisic() {
+  FOR_ALL_BB(bb, this) {
+    FOR_BB_INSNS_SAFE(insn, bb, nextInsn) {
+      nextInsn = insn->GetNextMachineInsn();
+      if (nextInsn == nullptr) {
+        break;
+      }
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+
+      MOperator firstMop = insn->GetMachineOpcode();
+      MOperator secondMop = nextInsn->GetMachineOpcode();
+      if (!((firstMop == MOP_xadrp) && ((secondMop == MOP_wldr) || (secondMop == MOP_xldr)))) {
+        continue;
+      }
+
+      if (CanLazyBinding(*nextInsn)) {
+        bb->ReplaceInsn(*insn, GetInsnBuilder()->BuildInsn(MOP_adrp_ldr, nextInsn->GetOperand(0), insn->GetOperand(1)));
+        bb->RemoveInsn(*nextInsn);
+      }
+    }
+  }
+}
+
+void AArch64CGFunc::ProcessLazyBinding() {
+  ConvertAdrpl12LdrToLdr();
+  ConvertAdrpLdrToIntrisic();
+}
+
+/*
+ * Generate global long call
+ *  adrp  VRx, symbol
+ *  ldr VRx, [VRx, #:lo12:symbol]
+ *  blr VRx
+ *
+ * Input:
+ *  insn       : insert new instruction after the 'insn'
+ *  func       : the symbol of the function need to be called
+ *  srcOpnds   : list operand of the function need to be called
+ *  isCleanCall: when generate clean call insn, set isCleanCall as true
+ * Return: the 'blr' instruction
+ */
+Insn &AArch64CGFunc::GenerateGlobalLongCallAfterInsn(const MIRSymbol &func, ListOperand &srcOpnds) {
+  MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(func.GetStIdx());
+  symbol->SetStorageClass(kScGlobal);
+  RegOperand &tmpReg = CreateRegisterOperandOfType(PTY_u64);
+  StImmOperand &stOpnd = CreateStImmOperand(*symbol, 0, 0);
+  OfstOperand &offsetOpnd = CreateOfstOpnd(*symbol, 0);
+  Insn &adrpInsn = GetInsnBuilder()->BuildInsn(MOP_xadrp, tmpReg, stOpnd);
+  GetCurBB()->AppendInsn(adrpInsn);
+  MemOperand &memOrd = GetOrCreateMemOpnd(MemOperand::kAddrModeLo12Li, GetPointerSize() * kBitsPerByte,
+                                          static_cast<RegOperand*>(&tmpReg),
+                                          nullptr, &offsetOpnd, symbol);
+  Insn &ldrInsn = GetInsnBuilder()->BuildInsn(memOrd.GetSize() == k64BitSize ? MOP_xldr : MOP_wldr, tmpReg, memOrd);
+  GetCurBB()->AppendInsn(ldrInsn);
+
+  Insn &callInsn = GetInsnBuilder()->BuildInsn(MOP_xblr, tmpReg, srcOpnds);
+  GetCurBB()->AppendInsn(callInsn);
+  GetCurBB()->SetHasCall();
+  return callInsn;
+}
+
+/*
+ * Generate local long call
+ *  adrp  VRx, symbol
+ *  add VRx, VRx, #:lo12:symbol
+ *  blr VRx
+ *
+ * Input:
+ *  insn       : insert new instruction after the 'insn'
+ *  func       : the symbol of the function need to be called
+ *  srcOpnds   : list operand of the function need to be called
+ *  isCleanCall: when generate clean call insn, set isCleanCall as true
+ * Return: the 'blr' instruction
+ */
+Insn &AArch64CGFunc::GenerateLocalLongCallAfterInsn(const MIRSymbol &func, ListOperand &srcOpnds) {
+  RegOperand &tmpReg = CreateRegisterOperandOfType(PTY_u64);
+  StImmOperand &stOpnd = CreateStImmOperand(func, 0, 0);
+  Insn &adrpInsn = GetInsnBuilder()->BuildInsn(MOP_xadrp, tmpReg, stOpnd);
+  GetCurBB()->AppendInsn(adrpInsn);
+  Insn &addInsn = GetInsnBuilder()->BuildInsn(MOP_xadrpl12, tmpReg, tmpReg, stOpnd);
+  GetCurBB()->AppendInsn(addInsn);
+  Insn *callInsn = &GetInsnBuilder()->BuildInsn(MOP_xblr, tmpReg, srcOpnds);
+  GetCurBB()->AppendInsn(*callInsn);
+  GetCurBB()->SetHasCall();
+  return *callInsn;
+}
+
+Insn &AArch64CGFunc::AppendCall(const MIRSymbol &sym, ListOperand &srcOpnds) {
+  Insn *callInsn = nullptr;
+  if (CGOptions::IsLongCalls()) {
+    MIRFunction *mirFunc = sym.GetFunction();
+    if (IsDuplicateAsmList(sym) || (mirFunc && mirFunc->GetAttr(FUNCATTR_local))) {
+      callInsn = &GenerateLocalLongCallAfterInsn(sym, srcOpnds);
+    } else {
+      callInsn = &GenerateGlobalLongCallAfterInsn(sym, srcOpnds);
+    }
+  } else {
+    Operand &targetOpnd = GetOrCreateFuncNameOpnd(sym);
+    callInsn = &GetInsnBuilder()->BuildInsn(MOP_xbl, targetOpnd, srcOpnds);
+    GetCurBB()->AppendInsn(*callInsn);
+    GetCurBB()->SetHasCall();
+  }
+  return *callInsn;
+}
+
+bool AArch64CGFunc::IsDuplicateAsmList(const MIRSymbol &sym) const {
+  if (CGOptions::IsDuplicateAsmFileEmpty()) {
+    return false;
+  }
+
+  const std::string &name = sym.GetName();
+  if ((name == "strlen") ||
+      (name == "strncmp") ||
+      (name == "memcpy") ||
+      (name == "memmove") ||
+      (name == "strcmp") ||
+      (name == "memcmp") ||
+      (name == "memcmpMpl")) {
+    return true;
+  }
+  return false;
+}
+
+void AArch64CGFunc::SelectMPLProfCounterInc(const IntrinsiccallNode &intrnNode) {
+  if (Options::profileGen) {
+    ASSERT(intrnNode.NumOpnds() == 1, "must be 1 operand");
+    BaseNode *arg1 = intrnNode.Opnd(0);
+    ASSERT(arg1 != nullptr, "nullptr check");
+    regno_t vRegNO1 = NewVReg(GetRegTyFromPrimTy(PTY_a64), GetPrimTypeSize(PTY_a64));
+    RegOperand &vReg1 = CreateVirtualRegisterOperand(vRegNO1);
+    vReg1.SetRegNotBBLocal();
+    static const MIRSymbol *bbProfileTab = nullptr;
+
+    // Ref: MeProfGen::InstrumentFunc on ctrTbl namiLogicalShiftLeftOperandng
+    std::string ctrTblName = namemangler::kprefixProfCtrTbl +
+                             GetMirModule().GetFileName() + "_" + GetName();
+    std::replace(ctrTblName.begin(), ctrTblName.end(), '.', '_');
+    std::replace(ctrTblName.begin(), ctrTblName.end(), '-', '_');
+    std::replace(ctrTblName.begin(), ctrTblName.end(), '/', '_');
+
+    if (!bbProfileTab || bbProfileTab->GetName() != ctrTblName) {
+      bbProfileTab = GetMirModule().GetMIRBuilder()->GetGlobalDecl(ctrTblName);
+      CHECK_FATAL(bbProfileTab != nullptr, "expect counter table");
+    }
+
+    ConstvalNode *constvalNode = static_cast<ConstvalNode*>(arg1);
+    MIRConst *mirConst = constvalNode->GetConstVal();
+    ASSERT(mirConst != nullptr, "nullptr check");
+    CHECK_FATAL(mirConst->GetKind() == kConstInt, "expect MIRIntConst type");
+    MIRIntConst *mirIntConst = safe_cast<MIRIntConst>(mirConst);
+    int64 offset = GetPrimTypeSize(PTY_u64) * mirIntConst->GetExtValue();
+
+    if (!CGOptions::IsQuiet()) {
+      maple::LogInfo::MapleLogger(kLlInfo) << "At counter table offset: " << offset << std::endl;
+    }
+    MemOperand *memOpnd = &GetOrCreateMemOpnd(*bbProfileTab, offset, k64BitSize);
+    if (IsImmediateOffsetOutOfRange(*memOpnd, k64BitSize)) {
+      memOpnd = &SplitOffsetWithAddInstruction(*memOpnd, k64BitSize);
+    }
+    Operand *reg = &SelectCopy(*memOpnd, PTY_u64, PTY_u64);
+    ImmOperand &one = CreateImmOperand(1, k64BitSize, false);
+    SelectAdd(*reg, *reg, one, PTY_u64);
+    SelectCopy(*memOpnd, PTY_u64, *reg, PTY_u64);
+    return;
+  }
+
+  ASSERT(intrnNode.NumOpnds() == 1, "must be 1 operand");
+  BaseNode *arg1 = intrnNode.Opnd(0);
+  ASSERT(arg1 != nullptr, "nullptr check");
+  regno_t vRegNO1 = NewVReg(GetRegTyFromPrimTy(PTY_a64), GetPrimTypeSize(PTY_a64));
+  RegOperand &vReg1 = CreateVirtualRegisterOperand(vRegNO1);
+  vReg1.SetRegNotBBLocal();
+  static const MIRSymbol *bbProfileTab = nullptr;
+  if (!bbProfileTab) {
+    std::string bbProfileName = namemangler::kBBProfileTabPrefixStr + GetMirModule().GetFileNameAsPostfix();
+    bbProfileTab = GetMirModule().GetMIRBuilder()->GetGlobalDecl(bbProfileName);
+    CHECK_FATAL(bbProfileTab != nullptr, "expect bb profile tab");
+  }
+  ConstvalNode *constvalNode = static_cast<ConstvalNode*>(arg1);
+  MIRConst *mirConst = constvalNode->GetConstVal();
+  ASSERT(mirConst != nullptr, "nullptr check");
+  CHECK_FATAL(mirConst->GetKind() == kConstInt, "expect MIRIntConst type");
+  MIRIntConst *mirIntConst = safe_cast<MIRIntConst>(mirConst);
+  int64 idx = GetPrimTypeSize(PTY_u32) * mirIntConst->GetExtValue();
+  if (!CGOptions::IsQuiet()) {
+    maple::LogInfo::MapleLogger(kLlErr) << "Id index " << idx << std::endl;
+  }
+  StImmOperand &stOpnd = CreateStImmOperand(*bbProfileTab, idx, 0);
+  Insn &newInsn = GetInsnBuilder()->BuildInsn(MOP_counter, vReg1, stOpnd);
+  newInsn.SetDoNotRemove(true);
+  GetCurBB()->AppendInsn(newInsn);
+}
+
+void AArch64CGFunc::SelectMPLClinitCheck(const IntrinsiccallNode &intrnNode) {
+  ASSERT(intrnNode.NumOpnds() == 1, "must be 1 operand");
+  BaseNode *arg = intrnNode.Opnd(0);
+  Operand *stOpnd = nullptr;
+  bool bClinitSeperate = false;
+  ASSERT(CGOptions::IsPIC(), "must be doPIC");
+  if (arg->GetOpCode() == OP_addrof) {
+    AddrofNode *addrof = static_cast<AddrofNode*>(arg);
+    MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(addrof->GetStIdx());
+    ASSERT(symbol->GetName().find(CLASSINFO_PREFIX_STR) == 0, "must be a symbol with __classinfo__");
+
+    if (!symbol->IsMuidDataUndefTab()) {
+      std::string ptrName = namemangler::kPtrPrefixStr + symbol->GetName();
+      MIRType *ptrType = GlobalTables::GetTypeTable().GetPtr();
+      symbol = GetMirModule().GetMIRBuilder()->GetOrCreateGlobalDecl(ptrName, *ptrType);
+      bClinitSeperate = true;
+      symbol->SetStorageClass(kScFstatic);
+    }
+    stOpnd = &CreateStImmOperand(*symbol, 0, 0);
+  } else {
+    arg = arg->Opnd(0);
+    BaseNode *arg0 = arg->Opnd(0);
+    BaseNode *arg1 = arg->Opnd(1);
+    ASSERT(arg0 != nullptr, "nullptr check");
+    ASSERT(arg1 != nullptr, "nullptr check");
+    ASSERT(arg0->GetOpCode() == OP_addrof, "expect the operand to be addrof");
+    AddrofNode *addrof = static_cast<AddrofNode*>(arg0);
+    MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(addrof->GetStIdx());
+    ASSERT(addrof->GetFieldID() == 0, "For debug SelectMPLClinitCheck.");
+    ConstvalNode *constvalNode = static_cast<ConstvalNode*>(arg1);
+    MIRConst *mirConst = constvalNode->GetConstVal();
+    ASSERT(mirConst != nullptr, "nullptr check");
+    CHECK_FATAL(mirConst->GetKind() == kConstInt, "expect MIRIntConst type");
+    MIRIntConst *mirIntConst = safe_cast<MIRIntConst>(mirConst);
+    stOpnd = &CreateStImmOperand(*symbol, mirIntConst->GetExtValue(), 0);
+  }
+
+  regno_t vRegNO2 = NewVReg(GetRegTyFromPrimTy(PTY_a64), GetPrimTypeSize(PTY_a64));
+  RegOperand &vReg2 = CreateVirtualRegisterOperand(vRegNO2);
+  vReg2.SetRegNotBBLocal();
+  if (bClinitSeperate) {
+    /* Seperate MOP_clinit to MOP_adrp_ldr + MOP_clinit_tail. */
+    Insn &newInsn = GetInsnBuilder()->BuildInsn(MOP_adrp_ldr, vReg2, *stOpnd);
+    GetCurBB()->AppendInsn(newInsn);
+    newInsn.SetDoNotRemove(true);
+    Insn &insn = GetInsnBuilder()->BuildInsn(MOP_clinit_tail, vReg2);
+    insn.SetDoNotRemove(true);
+    GetCurBB()->AppendInsn(insn);
+  } else {
+    Insn &newInsn = GetInsnBuilder()->BuildInsn(MOP_clinit, vReg2, *stOpnd);
+    GetCurBB()->AppendInsn(newInsn);
+  }
+}
+void AArch64CGFunc::GenCVaStartIntrin(RegOperand &opnd, uint32 stkSize) {
+  /* FPLR only pushed in regalloc() after intrin function */
+  Operand &stkOpnd = GetOrCreatePhysicalRegisterOperand(RFP, k64BitSize, kRegTyInt);
+
+  /* __stack */
+  ImmOperand *offsOpnd;
+  if (GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+    offsOpnd = &CreateImmOperand(0, k64BitSize, true, kUnAdjustVary); /* isvary reset StackFrameSize */
+  } else {
+    offsOpnd = &CreateImmOperand(0, k64BitSize, true);
+  }
+  ImmOperand *offsOpnd2 = &CreateImmOperand(stkSize, k64BitSize, false);
+  RegOperand &vReg = CreateVirtualRegisterOperand(NewVReg(kRegTyInt, GetPrimTypeSize(GetLoweredPtrType())));
+  if (stkSize > 0) {
+    SelectAdd(vReg, *offsOpnd, *offsOpnd2, GetLoweredPtrType());
+    SelectAdd(vReg, stkOpnd, vReg, GetLoweredPtrType());
+  } else {
+    SelectAdd(vReg, stkOpnd, *offsOpnd, GetLoweredPtrType());    /* stack pointer */
+  }
+  OfstOperand *offOpnd = &GetOrCreateOfstOpnd(0, k64BitSize); /* va_list ptr */
+  /* mem operand in va_list struct (lhs) */
+  MemOperand *strOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, &opnd, nullptr,
+                                            offOpnd, static_cast<MIRSymbol*>(nullptr));
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+      vReg.GetSize() == k64BitSize ? MOP_xstr : MOP_wstr, vReg, *strOpnd));
+
+  /* __gr_top   ; it's the same as __stack before the 1st va_arg */
+  if (CGOptions::IsArm64ilp32()) {
+    offOpnd = &GetOrCreateOfstOpnd(GetPointerSize(), k64BitSize);
+  } else {
+    offOpnd = &GetOrCreateOfstOpnd(k8BitSize, k64BitSize);
+  }
+  strOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, &opnd, nullptr,
+                                offOpnd, static_cast<MIRSymbol*>(nullptr));
+  SelectAdd(vReg, stkOpnd, *offsOpnd, GetLoweredPtrType());
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+      vReg.GetSize() == k64BitSize ? MOP_xstr : MOP_wstr, vReg, *strOpnd));
+
+  /* __vr_top */
+  int32 grAreaSize = static_cast<int32>(static_cast<AArch64MemLayout*>(GetMemlayout())->GetSizeOfGRSaveArea());
+  if (CGOptions::IsArm64ilp32()) {
+    offsOpnd2 = &CreateImmOperand(static_cast<int64>(RoundUp(static_cast<uint64>(grAreaSize), k8ByteSize * 2)),
+                                  k64BitSize, false);
+  } else {
+    offsOpnd2 = &CreateImmOperand(static_cast<int64>(RoundUp(static_cast<uint64>(grAreaSize), GetPointerSize() * 2)),
+                                  k64BitSize, false);
+  }
+  SelectSub(vReg, *offsOpnd, *offsOpnd2, GetLoweredPtrType());  /* if 1st opnd is register => sub */
+  SelectAdd(vReg, stkOpnd, vReg, GetLoweredPtrType());
+  offOpnd = &GetOrCreateOfstOpnd(GetPointerSize() * 2, k64BitSize);
+  strOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k64BitSize, &opnd, nullptr,
+                                offOpnd, static_cast<MIRSymbol*>(nullptr));
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(
+      vReg.GetSize() == k64BitSize ? MOP_xstr : MOP_wstr, vReg, *strOpnd));
+
+  /* __gr_offs */
+  int32 offs = 0 - grAreaSize;
+  offsOpnd = &CreateImmOperand(offs, k32BitSize, false);
+  RegOperand *tmpReg = &CreateRegisterOperandOfType(PTY_i32); /* offs value to be assigned (rhs) */
+  SelectCopyImm(*tmpReg, *offsOpnd, PTY_i32);
+  offOpnd = &GetOrCreateOfstOpnd(GetPointerSize() * 3, k32BitSize);
+  strOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k32BitSize, &opnd, nullptr,
+                                offOpnd, static_cast<MIRSymbol*>(nullptr));
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wstr, *tmpReg, *strOpnd));
+
+  /* __vr_offs */
+  offs = static_cast<int32>(UINT32_MAX - (static_cast<AArch64MemLayout*>(GetMemlayout())->GetSizeOfVRSaveArea() - 1UL));
+  offsOpnd = &CreateImmOperand(offs, k32BitSize, false);
+  tmpReg = &CreateRegisterOperandOfType(PTY_i32);
+  SelectCopyImm(*tmpReg, *offsOpnd, PTY_i32);
+  offOpnd = &GetOrCreateOfstOpnd((GetPointerSize() * 3 + sizeof(int32)), k32BitSize);
+  strOpnd = &GetOrCreateMemOpnd(MemOperand::kAddrModeBOi, k32BitSize, &opnd, nullptr,
+                                offOpnd, static_cast<MIRSymbol*>(nullptr));
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wstr, *tmpReg, *strOpnd));
+}
+
+void AArch64CGFunc::SelectCVaStart(const IntrinsiccallNode &intrnNode) {
+  ASSERT(intrnNode.NumOpnds() == 2, "must be 2 operands");
+  /* 2 operands, but only 1 needed. Don't need to emit code for second operand
+   *
+   * va_list is a passed struct with an address, load its address
+   */
+  isIntrnCallForC = true;
+  BaseNode *argExpr = intrnNode.Opnd(0);
+  Operand *opnd = HandleExpr(intrnNode, *argExpr);
+  RegOperand &opnd0 = LoadIntoRegister(*opnd, GetLoweredPtrType());  /* first argument of intrinsic */
+
+  /* Find beginning of unnamed arg on stack.
+   * Ex. void foo(int i1, int i2, ... int i8, struct S r, struct S s, ...)
+   *     where struct S has size 32, address of r and s are on stack but they are named.
+   */
+  AArch64CallConvImpl parmLocator(GetBecommon());
+  CCLocInfo pLoc;
+  uint32 stkSize = 0;
+  for (uint32 i = 0; i < GetFunction().GetFormalCount(); i++) {
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetFunction().GetNthParamTyIdx(i));
+    parmLocator.LocateNextParm(*ty, pLoc);
+    if (pLoc.reg0 == kRinvalid) {  /* on stack */
+      stkSize = static_cast<uint32_t>(pLoc.memOffset + pLoc.memSize);
+    }
+  }
+  if (CGOptions::IsArm64ilp32()) {
+    stkSize = static_cast<uint32>(RoundUp(stkSize, k8ByteSize));
+  } else {
+    stkSize = static_cast<uint32>(RoundUp(stkSize, GetPointerSize()));
+  }
+
+  GenCVaStartIntrin(opnd0, stkSize);
+
+  return;
+}
+
+/*
+ * intrinsiccall C___Atomic_store_N(ptr, val, memorder))
+ * ====> *ptr = val
+ * let ptr -> x0
+ * let val -> x1
+ * implement to asm: str/stlr x1, [x0]
+ * a store-release would replace str if memorder is not 0
+ */
+void AArch64CGFunc::SelectCAtomicStoreN(const IntrinsiccallNode &intrinsiccallNode) {
+  auto primType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(intrinsiccallNode.GetTyIdx())->GetPrimType();
+  auto *addr = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(0));
+  auto *value = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(1));
+  auto *memOrderOpnd = intrinsiccallNode.Opnd(kInsnThirdOpnd);
+  std::memory_order memOrder = std::memory_order_seq_cst;
+  if (memOrderOpnd->IsConstval()) {
+    auto *memOrderConst = static_cast<MIRIntConst*>(static_cast<ConstvalNode*>(memOrderOpnd)->GetConstVal());
+    memOrder = static_cast<std::memory_order>(memOrderConst->GetExtValue());
+  }
+  SelectAtomicStore(*value, *addr, primType, PickMemOrder(memOrder, false));
+}
+
+/*
+ * intrinsiccall C___atomic_store(ptr, val, memorder)
+ * ====> *ptr = *val
+ * let ptr -> x0
+ * let val -> x1
+ * implement to asm:
+ * ldr/ldar xn, [x1]
+ * str/stlr xn, [x0]
+ * a load-acquire would replace ldr if acquire needed
+ * a store-relase would replace str if release needed
+ */
+void AArch64CGFunc::SelectCAtomicStore(const IntrinsiccallNode &intrinsiccallNode) {
+  auto primType = GlobalTables::GetTypeTable().
+      GetTypeFromTyIdx(intrinsiccallNode.GetTyIdx())->GetPrimType();
+  auto *addrOpnd = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(kInsnFirstOpnd));
+  auto *valueOpnd = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(kInsnSecondOpnd));
+  auto *memOrderOpnd = intrinsiccallNode.Opnd(kInsnThirdOpnd);
+  std::memory_order memOrder = std::memory_order_seq_cst;
+  if (memOrderOpnd->IsConstval()) {
+    auto *memOrderConst = static_cast<MIRIntConst*>(
+        static_cast<ConstvalNode*>(memOrderOpnd)->GetConstVal());
+    memOrder = static_cast<std::memory_order>(memOrderConst->GetExtValue());
+  }
+  auto *value = SelectAtomicLoad(*valueOpnd, primType, PickMemOrder(memOrder, true));
+  SelectAtomicStore(*value, *addrOpnd, primType, PickMemOrder(memOrder, false));
+}
+
+void AArch64CGFunc::SelectAtomicStore(
+    Operand &srcOpnd, Operand &addrOpnd, PrimType primType, AArch64isa::MemoryOrdering memOrder) {
+  auto &memOpnd = CreateMemOpnd(LoadIntoRegister(addrOpnd, PTY_a64), 0, k64BitSize);
+  auto mOp = PickStInsn(GetPrimTypeBitSize(primType), primType, memOrder);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, LoadIntoRegister(srcOpnd, primType), memOpnd));
+}
+
+void AArch64CGFunc::SelectAddrofThreadLocal(Operand &result, StImmOperand &stImm) {
+  if (CGOptions::IsPIC()) {
+    SelectCTlsGlobalDesc(result, stImm);
+  } else {
+    SelectCTlsLocalDesc(result, stImm);
+  }
+  if (stImm.GetOffset() > 0) {
+    auto &immOpnd = CreateImmOperand(stImm.GetOffset(), result.GetSize(), false);
+    SelectAdd(result, result, immOpnd, PTY_u64);
+  }
+}
+
+void AArch64CGFunc::SelectCTlsLocalDesc(Operand &result, StImmOperand &stImm) {
+  auto tpidr = &CreateCommentOperand("tpidr_el0");
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_mrs, result, *tpidr));
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_tls_desc_rel, result, result, stImm));
+}
+
+void AArch64CGFunc::SelectCTlsGlobalDesc(Operand &result, StImmOperand &stImm) {
+  /* according to AArch64 Machine Directives */
+  auto &r0opnd = GetOrCreatePhysicalRegisterOperand (R0, k64BitSize, GetRegTyFromPrimTy(PTY_u64));
+  RegOperand *tlsAddr = &CreateRegisterOperandOfType(PTY_u64);
+  RegOperand *specialFunc = &CreateRegisterOperandOfType(PTY_u64);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_tls_desc_call, r0opnd, *tlsAddr, stImm));
+  //  mrs xn, tpidr_el0
+  //  add x0, x0, xn
+  auto tpidr = &CreateCommentOperand("tpidr_el0");
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_mrs, *specialFunc, *tpidr));
+  SelectAdd(result, r0opnd, *specialFunc, PTY_u64);
+}
+
+void AArch64CGFunc::SelectIntrinCall(IntrinsiccallNode &intrinsicCallNode) {
+  MIRIntrinsicID intrinsic = intrinsicCallNode.GetIntrinsic();
+
+  if (GetCG()->GenerateVerboseCG()) {
+    auto &comment = GetOpndBuilder()->CreateComment(GetIntrinsicName(intrinsic));
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildCommentInsn(comment));
+  }
+
+  /*
+   * At this moment, we eagerly evaluates all argument expressions.  In theory,
+   * there could be intrinsics that extract meta-information of variables, such as
+   * their locations, rather than computing their values.  Applications
+   * include building stack maps that help runtime libraries to find the values
+   * of local variables (See @stackmap in LLVM), in which case knowing their
+   * locations will suffice.
+   */
+  if (intrinsic == INTRN_MPL_CLINIT_CHECK) {  /* special case */
+    SelectMPLClinitCheck(intrinsicCallNode);
+    return;
+  }
+  if (intrinsic == INTRN_MPL_PROF_COUNTER_INC) {  /* special case */
+    SelectMPLProfCounterInc(intrinsicCallNode);
+    return;
+  }
+  if ((intrinsic == INTRN_MPL_CLEANUP_LOCALREFVARS) || (intrinsic == INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP) ||
+      (intrinsic == INTRN_MPL_CLEANUP_NORETESCOBJS)) {
+    return;
+  }
+  switch (intrinsic) {
+    case INTRN_C_va_start:
+      SelectCVaStart(intrinsicCallNode);
+      return;
+    case INTRN_C___sync_lock_release_1:
+      SelectCSyncLockRelease(intrinsicCallNode, PTY_u8);
+      return;
+    case INTRN_C___sync_lock_release_2:
+      SelectCSyncLockRelease(intrinsicCallNode, PTY_u16);
+      return;
+    case INTRN_C___sync_lock_release_4:
+      SelectCSyncLockRelease(intrinsicCallNode, PTY_u32);
+      return;
+    case INTRN_C___sync_lock_release_8:
+      SelectCSyncLockRelease(intrinsicCallNode, PTY_u64);
+      return;
+    case INTRN_C___atomic_store_n:
+      SelectCAtomicStoreN(intrinsicCallNode);
+      return;
+    case INTRN_C___atomic_store:
+      SelectCAtomicStore(intrinsicCallNode);
+      return;
+    case INTRN_C___atomic_load:
+      SelectCAtomicLoad(intrinsicCallNode);
+      return;
+    case INTRN_vector_zip_v8u8: case INTRN_vector_zip_v8i8:
+    case INTRN_vector_zip_v4u16: case INTRN_vector_zip_v4i16:
+    case INTRN_vector_zip_v2u32: case INTRN_vector_zip_v2i32:
+      SelectVectorZip(intrinsicCallNode.Opnd(0)->GetPrimType(),
+                      HandleExpr(intrinsicCallNode, *intrinsicCallNode.Opnd(0)),
+                      HandleExpr(intrinsicCallNode, *intrinsicCallNode.Opnd(1)));
+      return;
+    case INTRN_C_stack_save:
+      SelectStackSave();
+      return;
+    case INTRN_C_stack_restore:
+      SelectStackRestore(intrinsicCallNode);
+      return;
+    default:
+      break;
+  }
+  std::vector<Operand*> operands;  /* Temporary.  Deallocated on return. */
+  ListOperand *srcOpnds = CreateListOpnd(*GetFuncScopeAllocator());
+  for (size_t i = 0; i < intrinsicCallNode.NumOpnds(); i++) {
+    BaseNode *argExpr = intrinsicCallNode.Opnd(i);
+    Operand *opnd = HandleExpr(intrinsicCallNode, *argExpr);
+    operands.emplace_back(opnd);
+    if (!opnd->IsRegister()) {
+      opnd = &LoadIntoRegister(*opnd, argExpr->GetPrimType());
+    }
+    RegOperand *expRegOpnd = static_cast<RegOperand*>(opnd);
+    srcOpnds->PushOpnd(*expRegOpnd);
+  }
+  CallReturnVector *retVals = &intrinsicCallNode.GetReturnVec();
+
+  switch (intrinsic) {
+    case INTRN_MPL_ATOMIC_EXCHANGE_PTR: {
+      BB *origFtBB = GetCurBB()->GetNext();
+      Operand *loc = operands[kInsnFirstOpnd];
+      Operand *newVal = operands[kInsnSecondOpnd];
+      Operand *memOrd = operands[kInsnThirdOpnd];
+
+      MemOrd ord = OperandToMemOrd(*memOrd);
+      bool isAcquire = MemOrdIsAcquire(ord);
+      bool isRelease = MemOrdIsRelease(ord);
+
+      const PrimType kValPrimType = PTY_a64;
+
+      RegOperand &locReg = LoadIntoRegister(*loc, PTY_a64);
+      /* Because there is no live analysis when -O1 */
+      if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+        locReg.SetRegNotBBLocal();
+      }
+      MemOperand &locMem = GetOrCreateMemOpnd(MemOperand::kAddrModeBOi,
+          k64BitSize, &locReg, nullptr, &GetOrCreateOfstOpnd(0, k32BitSize), nullptr);
+      RegOperand &newValReg = LoadIntoRegister(*newVal, PTY_a64);
+      if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+        newValReg.SetRegNotBBLocal();
+      }
+      GetCurBB()->SetKind(BB::kBBFallthru);
+
+      LabelIdx retryLabIdx = CreateLabeledBB(intrinsicCallNode);
+
+      RegOperand *oldVal = SelectLoadExcl(kValPrimType, locMem, isAcquire);
+      if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+        oldVal->SetRegNotBBLocal();
+      }
+      RegOperand *succ = SelectStoreExcl(kValPrimType, locMem, newValReg, isRelease);
+      if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+        succ->SetRegNotBBLocal();
+      }
+
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wcbnz, *succ, GetOrCreateLabelOperand(retryLabIdx)));
+      GetCurBB()->SetKind(BB::kBBIntrinsic);
+      GetCurBB()->SetNext(origFtBB);
+
+      SaveReturnValueInLocal(*retVals, 0, kValPrimType, *oldVal, intrinsicCallNode);
+      break;
+    }
+    case INTRN_GET_AND_ADDI: {
+      IntrinsifyGetAndAddInt(*srcOpnds, PTY_i32);
+      break;
+    }
+    case INTRN_GET_AND_ADDL: {
+      IntrinsifyGetAndAddInt(*srcOpnds, PTY_i64);
+      break;
+    }
+    case INTRN_GET_AND_SETI: {
+      IntrinsifyGetAndSetInt(*srcOpnds, PTY_i32);
+      break;
+    }
+    case INTRN_GET_AND_SETL: {
+      IntrinsifyGetAndSetInt(*srcOpnds, PTY_i64);
+      break;
+    }
+    case INTRN_COMP_AND_SWAPI: {
+      IntrinsifyCompareAndSwapInt(*srcOpnds, PTY_i32);
+      break;
+    }
+    case INTRN_COMP_AND_SWAPL: {
+      IntrinsifyCompareAndSwapInt(*srcOpnds, PTY_i64);
+      break;
+    }
+    case INTRN_C___atomic_exchange_n: {
+      Operand *oldVal = SelectCAtomicExchangeN(intrinsicCallNode);
+      auto primType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(intrinsicCallNode.GetTyIdx())->GetPrimType();
+      uint32 regSize = GetPrimTypeBitSize(primType);
+      SelectCopy(GetOrCreatePhysicalRegisterOperand(R0, regSize, kRegTyInt), primType, *oldVal, primType);
+      break;
+    }
+    case INTRN_C___atomic_exchange : {
+      SelectCAtomicExchange(intrinsicCallNode);
+      break;
+    }
+    case INTRN_C___sync_synchronize: {
+      GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_dmb_ish));
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "Intrinsic %d: %s not implemented by the AArch64 CG.", intrinsic, GetIntrinsicName(intrinsic));
+      break;
+    }
+  }
+}
+
+Operand *AArch64CGFunc::SelectCclz(IntrinsicopNode &intrnNode) {
+  BaseNode *argexpr = intrnNode.Opnd(0);
+  PrimType ptype = argexpr->GetPrimType();
+  Operand *opnd = HandleExpr(intrnNode, *argexpr);
+  MOperator mop;
+
+  RegOperand &ldDest = CreateRegisterOperandOfType(ptype);
+  if (opnd->IsMemoryAccessOperand()) {
+    Insn &insn = GetInsnBuilder()->BuildInsn(PickLdInsn(GetPrimTypeBitSize(ptype), ptype), ldDest, *opnd);
+    GetCurBB()->AppendInsn(insn);
+    opnd = &ldDest;
+  } else if (opnd->IsImmediate()) {
+    SelectCopyImm(ldDest, *static_cast<ImmOperand *>(opnd), ptype);
+    opnd = &ldDest;
+  }
+
+  if (GetPrimTypeSize(ptype) == k4ByteSize) {
+    mop = MOP_wclz;
+  } else {
+    mop = MOP_xclz;
+  }
+  RegOperand &dst = CreateRegisterOperandOfType(ptype);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mop, dst, *opnd));
+  return &dst;
+}
+
+Operand *AArch64CGFunc::SelectCctz(IntrinsicopNode &intrnNode) {
+  BaseNode *argexpr = intrnNode.Opnd(0);
+  PrimType ptype = argexpr->GetPrimType();
+  Operand *opnd = HandleExpr(intrnNode, *argexpr);
+
+  RegOperand &ldDest = CreateRegisterOperandOfType(ptype);
+  if (opnd->IsMemoryAccessOperand()) {
+    Insn &insn = GetInsnBuilder()->BuildInsn(PickLdInsn(GetPrimTypeBitSize(ptype), ptype), ldDest, *opnd);
+    GetCurBB()->AppendInsn(insn);
+    opnd = &ldDest;
+  } else if (opnd->IsImmediate()) {
+    SelectCopyImm(ldDest, *static_cast<ImmOperand *>(opnd), ptype);
+    opnd = &ldDest;
+  }
+
+  MOperator clzmop;
+  MOperator rbitmop;
+  if (GetPrimTypeSize(ptype) == k4ByteSize) {
+    clzmop = MOP_wclz;
+    rbitmop = MOP_wrbit;
+  } else {
+    clzmop = MOP_xclz;
+    rbitmop = MOP_xrbit;
+  }
+  RegOperand &dst1 = CreateRegisterOperandOfType(ptype);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(rbitmop, dst1, *opnd));
+  RegOperand &dst2 = CreateRegisterOperandOfType(ptype);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(clzmop, dst2, dst1));
+  return &dst2;
+}
+
+Operand *AArch64CGFunc::SelectCpopcount(IntrinsicopNode &intrnNode) {
+  CHECK_FATAL(false, "%s NIY", intrnNode.GetIntrinDesc().name);
+  return nullptr;
+}
+
+Operand *AArch64CGFunc::SelectCparity(IntrinsicopNode &intrnNode) {
+  CHECK_FATAL(false, "%s NIY", intrnNode.GetIntrinDesc().name);
+  return nullptr;
+}
+
+Operand *AArch64CGFunc::SelectCclrsb(IntrinsicopNode &intrnNode) {
+  BaseNode *argexpr = intrnNode.Opnd(0);
+  PrimType ptype = argexpr->GetPrimType();
+  Operand *opnd = HandleExpr(intrnNode, *argexpr);
+
+  RegOperand &ldDest = CreateRegisterOperandOfType(ptype);
+  if (opnd->IsMemoryAccessOperand()) {
+    Insn &insn = GetInsnBuilder()->BuildInsn(PickLdInsn(GetPrimTypeBitSize(ptype), ptype), ldDest, *opnd);
+    GetCurBB()->AppendInsn(insn);
+    opnd = &ldDest;
+  } else if (opnd->IsImmediate()) {
+    SelectCopyImm(ldDest, *static_cast<ImmOperand *>(opnd), ptype);
+    opnd = &ldDest;
+  }
+
+  bool is32Bit = (GetPrimTypeSize(ptype) == k4ByteSize);
+  RegOperand &res = CreateRegisterOperandOfType(ptype);
+  SelectMvn(res, *opnd, ptype);
+  SelectAArch64Cmp(*opnd, GetZeroOpnd(is32Bit ? k32BitSize : k64BitSize), true, is32Bit ? k32BitSize : k64BitSize);
+  SelectAArch64Select(*opnd, res, *opnd, GetCondOperand(CC_LT), true, is32Bit ? k32BitSize : k64BitSize);
+  MOperator clzmop = (is32Bit ? MOP_wclz : MOP_xclz);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(clzmop, *opnd, *opnd));
+  SelectSub(*opnd, *opnd, CreateImmOperand(1, is32Bit ? k32BitSize : k64BitSize, true), ptype);
+  return opnd;
+}
+
+Operand *AArch64CGFunc::SelectCisaligned(IntrinsicopNode &intrnNode) {
+  BaseNode *argexpr0 = intrnNode.Opnd(0);
+  PrimType ptype0 = argexpr0->GetPrimType();
+  Operand *opnd0 = HandleExpr(intrnNode, *argexpr0);
+
+  RegOperand &ldDest0 = CreateRegisterOperandOfType(ptype0);
+  if (opnd0->IsMemoryAccessOperand()) {
+    GetCurBB()->AppendInsn(
+        GetInsnBuilder()->BuildInsn(PickLdInsn(GetPrimTypeBitSize(ptype0), ptype0), ldDest0, *opnd0));
+    opnd0 = &ldDest0;
+  } else if (opnd0->IsImmediate()) {
+    SelectCopyImm(ldDest0, *static_cast<ImmOperand *>(opnd0), ptype0);
+    opnd0 = &ldDest0;
+  }
+
+  BaseNode *argexpr1 = intrnNode.Opnd(1);
+  PrimType ptype1 = argexpr1->GetPrimType();
+  Operand *opnd1 = HandleExpr(intrnNode, *argexpr1);
+
+  RegOperand &ldDest1 = CreateRegisterOperandOfType(ptype1);
+  if (opnd1->IsMemoryAccessOperand()) {
+    GetCurBB()->AppendInsn(
+        GetInsnBuilder()->BuildInsn(PickLdInsn(GetPrimTypeBitSize(ptype1), ptype1), ldDest1, *opnd1));
+    opnd1 = &ldDest1;
+  } else if (opnd1->IsImmediate()) {
+    SelectCopyImm(ldDest1, *static_cast<ImmOperand *>(opnd1), ptype1);
+    opnd1 = &ldDest1;
+  }
+  // mov w4, #1
+  RegOperand &reg0 = CreateRegisterOperandOfType(PTY_i32);
+  SelectCopyImm(reg0, CreateImmOperand(1, k32BitSize, true), PTY_i32);
+  // sxtw x4, w4
+  MOperator mOp = MOP_xsxtw64;
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, reg0, reg0));
+  // sub x3, x3, x4
+  SelectSub(*opnd1, *opnd1, reg0, ptype1);
+  // and x2, x2, x3
+  SelectBand(*opnd0, *opnd0, *opnd1, ptype1);
+  // mov w3, #0
+  // sxtw x3, w3
+  // cmp x2, x3
+  SelectAArch64Cmp(*opnd0, GetZeroOpnd(k64BitSize), true, k64BitSize);
+  // cset w2, EQ
+  SelectAArch64CSet(*opnd0, GetCondOperand(CC_EQ), false);
+  return opnd0;
+}
+
+void AArch64CGFunc::SelectArithmeticAndLogical(Operand &resOpnd, Operand &opnd0, Operand &opnd1,
+                                               PrimType primType, Opcode op) {
+  switch (op) {
+    case OP_add:
+      SelectAdd(resOpnd, opnd0, opnd1, primType);
+      break;
+    case OP_sub:
+      SelectSub(resOpnd, opnd0, opnd1, primType);
+      break;
+    case OP_band:
+      SelectBand(resOpnd, opnd0, opnd1, primType);
+      break;
+    case OP_bior:
+      SelectBior(resOpnd, opnd0, opnd1, primType);
+      break;
+    case OP_bxor:
+      SelectBxor(resOpnd, opnd0, opnd1, primType);
+      break;
+    default:
+      CHECK_FATAL(false, "unconcerned opcode for arithmetical and logical insns");
+      break;
+  }
+}
+
+Operand *AArch64CGFunc::SelectAArch64CAtomicFetch(const IntrinsicopNode &intrinopNode, Opcode op, bool fetchBefore) {
+  auto primType = intrinopNode.GetPrimType();
+  /* Create BB which includes atomic built_in function */
+  LabelIdx atomicBBLabIdx = CreateLabel();
+  BB *atomicBB = CreateNewBB();
+  atomicBB->SetKind(BB::kBBIf);
+  atomicBB->SetAtomicBuiltIn();
+  atomicBB->AddLabel(atomicBBLabIdx);
+  SetLab2BBMap(static_cast<int32>(atomicBBLabIdx), *atomicBB);
+  GetCurBB()->AppendBB(*atomicBB);
+  /* keep variables inside same BB */
+  if (GetCG()->GetOptimizeLevel() == CGOptions::kLevel0) {
+    SetCurBB(*atomicBB);
+  }
+  /* handle built_in args */
+  Operand *addrOpnd = HandleExpr(intrinopNode, *intrinopNode.GetNopndAt(kInsnFirstOpnd));
+  Operand *valueOpnd = HandleExpr(intrinopNode, *intrinopNode.GetNopndAt(kInsnSecondOpnd));
+  addrOpnd = &LoadIntoRegister(*addrOpnd, intrinopNode.GetNopndAt(kInsnFirstOpnd)->GetPrimType());
+  valueOpnd = &LoadIntoRegister(*valueOpnd, intrinopNode.GetNopndAt(kInsnSecondOpnd)->GetPrimType());
+  if (GetCG()->GetOptimizeLevel() != CGOptions::kLevel0) {
+    SetCurBB(*atomicBB);
+  }
+  /* load from pointed address */
+  auto primTypeP2Size = GetPrimTypeP2Size(primType);
+  auto *regLoaded = &CreateRegisterOperandOfType(primType);
+  auto &memOpnd = CreateMemOpnd(*static_cast<RegOperand*>(addrOpnd), 0, GetPrimTypeBitSize(primType));
+  auto mOpLoad = PickLoadStoreExclInsn(primTypeP2Size, false, false);
+  atomicBB->AppendInsn(GetInsnBuilder()->BuildInsn(mOpLoad, *regLoaded, memOpnd));
+  /* update loaded value */
+  auto *regOperated = &CreateRegisterOperandOfType(primType);
+  SelectArithmeticAndLogical(*regOperated, *regLoaded, *valueOpnd, primType, op);
+  /* store to pointed address */
+  auto *accessStatus = &CreateRegisterOperandOfType(PTY_u32);
+  auto mOpStore = PickLoadStoreExclInsn(primTypeP2Size, true, true);
+  atomicBB->AppendInsn(GetInsnBuilder()->BuildInsn(mOpStore, *accessStatus, *regOperated, memOpnd));
+  /* check the exclusive accsess status */
+  auto &atomicBBOpnd = GetOrCreateLabelOperand(*atomicBB);
+  atomicBB->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wcbnz, *accessStatus, atomicBBOpnd));
+
+  BB *nextBB = CreateNewBB();
+  GetCurBB()->AppendBB(*nextBB);
+  SetCurBB(*nextBB);
+  return fetchBefore ? regLoaded : regOperated;
+}
+
+Operand *AArch64CGFunc::SelectAArch64CSyncFetch(const IntrinsicopNode &intrinopNode, Opcode op, bool fetchBefore) {
+  auto *result = SelectAArch64CAtomicFetch(intrinopNode, op, fetchBefore);
+  /* Data Memory Barrier */
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_dmb_ish));
+  return result;
+}
+
+Operand *AArch64CGFunc::SelectCSyncCmpSwap(const IntrinsicopNode &intrinopNode, bool retBool) {
+  PrimType primType = intrinopNode.GetNopndAt(kInsnSecondOpnd)->GetPrimType();
+  ASSERT(primType == intrinopNode.GetNopndAt(kInsnThirdOpnd)->GetPrimType(), "gcc built_in rule");
+  LabelIdx atomicBBLabIdx = CreateLabel();
+  BB *atomicBB = CreateNewBB();
+  atomicBB->SetKind(BB::kBBIf);
+  atomicBB->SetAtomicBuiltIn();
+  atomicBB->AddLabel(atomicBBLabIdx);
+  SetLab2BBMap(static_cast<int32>(atomicBBLabIdx), *atomicBB);
+  GetCurBB()->AppendBB(*atomicBB);
+  if (GetCG()->GetOptimizeLevel() == CGOptions::kLevel0) {
+    SetCurBB(*atomicBB);
+  }
+  /* handle built_in args */
+  Operand *addrOpnd = HandleExpr(intrinopNode, *intrinopNode.GetNopndAt(kInsnFirstOpnd));
+  Operand *oldVal = HandleExpr(intrinopNode, *intrinopNode.GetNopndAt(kInsnSecondOpnd));
+  Operand *newVal = HandleExpr(intrinopNode, *intrinopNode.GetNopndAt(kInsnThirdOpnd));
+  if (GetCG()->GetOptimizeLevel() != CGOptions::kLevel0) {
+    SetCurBB(*atomicBB);
+  }
+
+  uint32 primTypeP2Size = GetPrimTypeP2Size(primType);
+  /* ldxr */
+  auto *regLoaded = &CreateRegisterOperandOfType(primType);
+  auto &memOpnd = CreateMemOpnd(LoadIntoRegister(*addrOpnd, primType), 0, GetPrimTypeBitSize(primType));
+  auto mOpLoad = PickLoadStoreExclInsn(primTypeP2Size, false, false);
+  atomicBB->AppendInsn(GetInsnBuilder()->BuildInsn(mOpLoad, *regLoaded, memOpnd));
+  Operand *regExtend = &CreateRegisterOperandOfType(primType);
+  PrimType targetType = (oldVal->GetSize() <= k32BitSize) ?
+      (IsSignedInteger(primType) ? PTY_i32 : PTY_u32) : (IsSignedInteger(primType) ? PTY_i64 : PTY_u64);
+  SelectCvtInt2Int(nullptr, regExtend, regLoaded, primType, targetType);
+  /* cmp */
+  SelectAArch64Cmp(*regExtend, *oldVal, true, oldVal->GetSize());
+  /* bne */
+  Operand &rflag = GetOrCreateRflag();
+  LabelIdx nextBBLableIdx = CreateLabel();
+  LabelOperand &targetOpnd = GetOrCreateLabelOperand(nextBBLableIdx);
+  atomicBB->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_bne, rflag, targetOpnd));
+  /* stlxr */
+  BB *stlxrBB = CreateNewBB();
+  stlxrBB->SetKind(BB::kBBIf);
+  atomicBB->AppendBB(*stlxrBB);
+  SetCurBB(*stlxrBB);
+  auto *accessStatus = &CreateRegisterOperandOfType(PTY_u32);
+  auto &newRegVal = LoadIntoRegister(*newVal, primType);
+  auto mOpStore = PickLoadStoreExclInsn(primTypeP2Size, true, true);
+  stlxrBB->AppendInsn(GetInsnBuilder()->BuildInsn(mOpStore, *accessStatus, newRegVal, memOpnd));
+  /* cbnz ==> check the exclusive accsess status */
+  auto &atomicBBOpnd = GetOrCreateLabelOperand(*atomicBB);
+  stlxrBB->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wcbnz, *accessStatus, atomicBBOpnd));
+  /* Data Memory Barrier */
+  BB *nextBB = CreateNewBB();
+  nextBB->AddLabel(nextBBLableIdx);
+  nextBB->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_dmb_ish, AArch64CG::kMd[MOP_dmb_ish]));
+  SetLab2BBMap(static_cast<int32>(nextBBLableIdx), *nextBB);
+  stlxrBB->AppendBB(*nextBB);
+  SetCurBB(*nextBB);
+  /* bool version return true if the comparison is successful and newval is written */
+  if (retBool) {
+    auto *retOpnd = &CreateRegisterOperandOfType(PTY_u32);
+    SelectAArch64CSet(*retOpnd, GetCondOperand(CC_EQ), false);
+    return retOpnd;
+  }
+  /* type version return the contents of *addrOpnd before the operation */
+  return regLoaded;
+}
+
+Operand *AArch64CGFunc::SelectCAtomicFetch(IntrinsicopNode &intrinopNode, Opcode op, bool fetchBefore) {
+  return SelectAArch64CAtomicFetch(intrinopNode, op, fetchBefore);
+}
+
+Operand *AArch64CGFunc::SelectCSyncFetch(IntrinsicopNode &intrinopNode, Opcode op, bool fetchBefore) {
+  return SelectAArch64CSyncFetch(intrinopNode, op, fetchBefore);
+}
+
+Operand *AArch64CGFunc::SelectCSyncBoolCmpSwap(IntrinsicopNode &intrinopNode) {
+  return SelectCSyncCmpSwap(intrinopNode, true);
+}
+
+Operand *AArch64CGFunc::SelectCSyncValCmpSwap(IntrinsicopNode &intrinopNode) {
+  return SelectCSyncCmpSwap(intrinopNode);
+}
+
+Operand *AArch64CGFunc::SelectCSyncLockTestSet(IntrinsicopNode &intrinopNode, PrimType pty) {
+  auto primType = intrinopNode.GetPrimType();
+  Operand *addrOpnd = HandleExpr(intrinopNode, *intrinopNode.GetNopndAt(kInsnFirstOpnd));
+  Operand *valueOpnd = HandleExpr(intrinopNode, *intrinopNode.GetNopndAt(kInsnSecondOpnd));
+  addrOpnd = &LoadIntoRegister(*addrOpnd, intrinopNode.GetNopndAt(kInsnFirstOpnd)->GetPrimType());
+  valueOpnd = &LoadIntoRegister(*valueOpnd, intrinopNode.GetNopndAt(kInsnSecondOpnd)->GetPrimType());
+
+  /* Create BB which includes atomic built_in function */
+  LabelIdx atomicBBLabIdx = CreateLabel();
+  BB *atomicBB = CreateNewBB();
+  atomicBB->SetKind(BB::kBBIf);
+  atomicBB->SetAtomicBuiltIn();
+  atomicBB->AddLabel(atomicBBLabIdx);
+  SetLab2BBMap(static_cast<int32>(atomicBBLabIdx), *atomicBB);
+  GetCurBB()->AppendBB(*atomicBB);
+  SetCurBB(*atomicBB);
+  /* load from pointed address */
+  auto primTypeP2Size = GetPrimTypeP2Size(primType);
+  auto *regLoaded = &CreateRegisterOperandOfType(primType);
+  auto &memOpnd = CreateMemOpnd(*static_cast<RegOperand*>(addrOpnd), 0, GetPrimTypeBitSize(primType));
+  auto mOpLoad = PickLoadStoreExclInsn(primTypeP2Size, false, false);
+  atomicBB->AppendInsn(GetInsnBuilder()->BuildInsn(mOpLoad, *regLoaded, memOpnd));
+  /* store to pointed address */
+  auto *accessStatus = &CreateRegisterOperandOfType(PTY_u32);
+  auto mOpStore = PickLoadStoreExclInsn(primTypeP2Size, true, false);
+  atomicBB->AppendInsn(GetInsnBuilder()->BuildInsn(mOpStore, *accessStatus, *valueOpnd, memOpnd));
+  /* check the exclusive accsess status */
+  auto &atomicBBOpnd = GetOrCreateLabelOperand(*atomicBB);
+  atomicBB->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_wcbnz, *accessStatus, atomicBBOpnd));
+
+  /* Data Memory Barrier */
+  BB *nextBB = CreateNewBB();
+  atomicBB->AppendBB(*nextBB);
+  SetCurBB(*nextBB);
+  nextBB->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_dmb_ish, AArch64CG::kMd[MOP_dmb_ish]));
+  return regLoaded;
+}
+
+void AArch64CGFunc::SelectCSyncLockRelease(const IntrinsiccallNode &intrinsiccall, PrimType primType) {
+  auto *addrOpnd = HandleExpr(intrinsiccall, *intrinsiccall.GetNopndAt(kInsnFirstOpnd));
+  auto primTypeBitSize = GetPrimTypeBitSize(primType);
+  auto mOp = PickStInsn(primTypeBitSize, primType, AArch64isa::kMoRelease);
+  auto &zero = GetZeroOpnd(primTypeBitSize);
+  auto &memOpnd = CreateMemOpnd(LoadIntoRegister(*addrOpnd, primType), 0, primTypeBitSize);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, zero, memOpnd));
+}
+
+Operand *AArch64CGFunc::SelectCSyncSynchronize(IntrinsicopNode &intrinopNode) {
+  (void)intrinopNode;
+  CHECK_FATAL(false, "have not implement SelectCSyncSynchronize yet");
+  return nullptr;
+}
+
+AArch64isa::MemoryOrdering AArch64CGFunc::PickMemOrder(std::memory_order memOrder, bool isLdr) const {
+  switch (memOrder) {
+    case std::memory_order_relaxed:
+      return AArch64isa::kMoNone;
+    case std::memory_order_consume:
+    case std::memory_order_acquire:
+      return isLdr ? AArch64isa::kMoAcquire : AArch64isa::kMoNone;
+    case std::memory_order_release:
+      return isLdr ? AArch64isa::kMoNone : AArch64isa::kMoRelease;
+    case std::memory_order_acq_rel:
+    case std::memory_order_seq_cst:
+      return isLdr ? AArch64isa::kMoAcquire : AArch64isa::kMoRelease;
+    default:
+      CHECK_FATAL(false, "unexpected memorder");
+      return AArch64isa::kMoNone;
+  }
+}
+
+/*
+ * regassign %1 (intrinsicop C___Atomic_Load_N(ptr, memorder))
+ * ====> %1 = *ptr
+ * let %1 -> x0
+ * let ptr -> x1
+ * implement to asm: ldr/ldar x0, [x1]
+ * a load-acquire would replace ldr if memorder is not 0
+ */
+Operand *AArch64CGFunc::SelectCAtomicLoadN(IntrinsicopNode &intrinsicopNode) {
+  auto *addrOpnd = HandleExpr(intrinsicopNode, *intrinsicopNode.Opnd(0));
+  auto *memOrderOpnd = intrinsicopNode.Opnd(1);
+  auto primType = intrinsicopNode.GetPrimType();
+  std::memory_order memOrder = std::memory_order_seq_cst;
+  if (memOrderOpnd->IsConstval()) {
+    auto *memOrderConst = static_cast<MIRIntConst*>(static_cast<ConstvalNode*>(memOrderOpnd)->GetConstVal());
+    memOrder = static_cast<std::memory_order>(memOrderConst->GetExtValue());
+  }
+  return SelectAtomicLoad(*addrOpnd, primType, PickMemOrder(memOrder, true));
+}
+
+/*
+ * intrinsiccall C___atomic_load (ptr, ret, memorder)
+ * ====> *ret = *ptr
+ * let ret -> x0
+ * let ptr -> x1
+ * implement to asm:
+ * ldr/ldar xn, [x1]
+ * str/stlr xn, [x0]
+ * a load-acquire would replace ldr if acquire needed
+ * a store-relase would replace str if release needed
+ */
+void AArch64CGFunc::SelectCAtomicLoad(const IntrinsiccallNode &intrinsiccallNode) {
+  auto primType = GlobalTables::GetTypeTable().
+      GetTypeFromTyIdx(intrinsiccallNode.GetTyIdx())->GetPrimType();
+  auto *addrOpnd = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(kInsnFirstOpnd));
+  auto *retOpnd = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(kInsnSecondOpnd));
+  auto *memOrderOpnd = intrinsiccallNode.Opnd(kInsnThirdOpnd);
+  std::memory_order memOrder = std::memory_order_seq_cst;
+  if (memOrderOpnd->IsConstval()) {
+    auto *memOrderConst = static_cast<MIRIntConst*>(
+        static_cast<ConstvalNode*>(memOrderOpnd)->GetConstVal());
+    memOrder = static_cast<std::memory_order>(memOrderConst->GetExtValue());
+  }
+  auto *value = SelectAtomicLoad(*addrOpnd, primType, PickMemOrder(memOrder, true));
+  SelectAtomicStore(*value, *retOpnd, primType, PickMemOrder(memOrder, false));
+}
+
+/*
+ * regassign %1 (intrinsicop C___Atomic_exchange_n(ptr, val, memorder))
+ * ====> %1 = *ptr; *ptr = val;
+ * let %1 -> x0
+ * let ptr -> x1
+ * let val -> x2
+ * implement to asm:
+ * ldr/ldar x0, [x1]
+ * str/stlr x2, [x1]
+ * a load-acquire would replace ldr if acquire needed
+ * a store-relase would replace str if release needed
+ */
+Operand *AArch64CGFunc::SelectCAtomicExchangeN(const IntrinsiccallNode &intrinsiccallNode) {
+  auto primType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(intrinsiccallNode.GetTyIdx())->GetPrimType();
+  auto *addrOpnd = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(0));
+  auto *valueOpnd = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(1));
+  auto *memOrderOpnd = intrinsiccallNode.Opnd(kInsnThirdOpnd);
+  std::memory_order memOrder = std::memory_order_seq_cst;
+  if (memOrderOpnd->IsConstval()) {
+    auto *memOrderConst = static_cast<MIRIntConst*>(static_cast<ConstvalNode*>(memOrderOpnd)->GetConstVal());
+    memOrder = static_cast<std::memory_order>(memOrderConst->GetExtValue());
+  }
+
+  auto *result = SelectAtomicLoad(*addrOpnd, primType, PickMemOrder(memOrder, true));
+  SelectAtomicStore(*valueOpnd, *addrOpnd, primType, PickMemOrder(memOrder, false));
+  return result;
+}
+
+/*
+ * intrinsiccall C___atomic_exchange (ptr, val, ret, memorder)
+ * ====> *ret = *ptr; *ptr = *val
+ * let ptr -> x0
+ * let val -> x1
+ * let ret -> x2
+ * implement to asm:
+ * ldr/ldar xn1, [x0]
+ * ldr/ldar xn2, [x1]
+ * str/stlr xn2, [x0]
+ * str/stlr xn1, [x2]
+ * a load-acquire would replace ldr if acquire needed
+ * a store-relase would replace str if release needed
+ */
+void AArch64CGFunc::SelectCAtomicExchange(const IntrinsiccallNode &intrinsiccallNode) {
+  auto primType = GlobalTables::GetTypeTable().
+      GetTypeFromTyIdx(intrinsiccallNode.GetTyIdx())->GetPrimType();
+  auto *addrOpnd = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(kInsnFirstOpnd));
+  auto *valueOpnd = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(kInsnSecondOpnd));
+  auto *retOpnd = HandleExpr(intrinsiccallNode, *intrinsiccallNode.Opnd(kInsnThirdOpnd));
+  auto *memOrderOpnd = intrinsiccallNode.Opnd(kInsnFourthOpnd);
+  std::memory_order memOrder = std::memory_order_seq_cst;
+  if (memOrderOpnd->IsConstval()) {
+    auto *memOrderConst = static_cast<MIRIntConst*>(
+        static_cast<ConstvalNode*>(memOrderOpnd)->GetConstVal());
+    memOrder = static_cast<std::memory_order>(memOrderConst->GetExtValue());
+  }
+
+  auto *result = SelectAtomicLoad(*addrOpnd, primType, PickMemOrder(memOrder, true));
+  auto *val = SelectAtomicLoad(*valueOpnd, primType, PickMemOrder(memOrder, true));
+  SelectAtomicStore(*val, *addrOpnd, primType, PickMemOrder(memOrder, false));
+  SelectAtomicStore(*result, *retOpnd, primType, PickMemOrder(memOrder, false));
+}
+
+Operand *AArch64CGFunc::SelectAtomicLoad(Operand &addrOpnd, PrimType primType, AArch64isa::MemoryOrdering memOrder) {
+  auto mOp = PickLdInsn(GetPrimTypeBitSize(primType), primType, memOrder);
+  auto &memOpnd = CreateMemOpnd(LoadIntoRegister(addrOpnd, PTY_a64), 0, k64BitSize);
+  auto *resultOpnd = &CreateRegisterOperandOfType(primType);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, *resultOpnd, memOpnd));
+  return resultOpnd;
+}
+
+Operand *AArch64CGFunc::SelectCReturnAddress(IntrinsicopNode &intrinopNode) {
+  if (intrinopNode.GetIntrinsic() == INTRN_C__builtin_extract_return_addr) {
+    ASSERT(intrinopNode.GetNumOpnds() == 1, "expect one parameter");
+    Operand *addrOpnd = HandleExpr(intrinopNode, *intrinopNode.GetNopndAt(kInsnFirstOpnd));
+    return &LoadIntoRegister(*addrOpnd, PTY_a64);
+  } else if (intrinopNode.GetIntrinsic() == INTRN_C__builtin_return_address) {
+    BaseNode *argexpr0 = intrinopNode.Opnd(0);
+    while (!argexpr0->IsLeaf()) {
+      argexpr0 = argexpr0->Opnd(0);
+    }
+    CHECK_FATAL(argexpr0->IsConstval(), "Invalid argument of __builtin_return_address");
+    auto &constNode = static_cast<ConstvalNode&>(*argexpr0);
+    ASSERT(constNode.GetConstVal()->GetKind() == kConstInt, "expect MIRIntConst does not support float yet");
+    MIRIntConst *mirIntConst = safe_cast<MIRIntConst>(constNode.GetConstVal());
+    ASSERT(mirIntConst != nullptr, "nullptr checking");
+    int64 scale = mirIntConst->GetExtValue();
+    /*
+     * Do not support getting return address with a nonzero argument
+     * inline / tail call opt will destory this behavior
+     */
+    CHECK_FATAL(scale == 0, "Do not support recursion");
+    Operand *resReg = &static_cast<Operand&>(CreateRegisterOperandOfType(PTY_i64));
+    SelectCopy(*resReg, PTY_i64, GetOrCreatePhysicalRegisterOperand(RLR, k64BitSize, kRegTyInt), PTY_i64);
+    return resReg;
+  }
+  return nullptr;
+}
+
+Operand *AArch64CGFunc::SelectCalignup(IntrinsicopNode &intrnNode) {
+  return SelectAArch64align(intrnNode, true);
+}
+
+Operand *AArch64CGFunc::SelectCaligndown(IntrinsicopNode &intrnNode) {
+  return SelectAArch64align(intrnNode, false);
+}
+
+Operand *AArch64CGFunc::SelectAArch64align(const IntrinsicopNode &intrnNode, bool isUp) {
+  /* Handle Two args */
+  BaseNode *argexpr0 = intrnNode.Opnd(0);
+  PrimType ptype0 = argexpr0->GetPrimType();
+  Operand *opnd0 = HandleExpr(intrnNode, *argexpr0);
+  PrimType resultPtype = intrnNode.GetPrimType();
+  RegOperand &ldDest0 = LoadIntoRegister(*opnd0, ptype0);
+
+  BaseNode *argexpr1 = intrnNode.Opnd(1);
+  PrimType ptype1 = argexpr1->GetPrimType();
+  Operand *opnd1 = HandleExpr(intrnNode, *argexpr1);
+  RegOperand &arg1 = LoadIntoRegister(*opnd1, ptype1);
+  ASSERT(IsPrimitiveInteger(ptype0) && IsPrimitiveInteger(ptype1), "align integer type only");
+  Operand *ldDest1 = &static_cast<Operand&>(CreateRegisterOperandOfType(ptype0));
+  SelectCvtInt2Int(nullptr, ldDest1, &arg1, ptype1, ptype0);
+
+  Operand *resultReg = &static_cast<Operand&>(CreateRegisterOperandOfType(ptype0));
+  Operand &immReg = CreateImmOperand(1, GetPrimTypeBitSize(ptype0), true);
+  /* Do alignment  x0 -- value to be aligned   x1 -- alignment */
+  if (isUp) {
+    /* add res, x0, x1 */
+    SelectAdd(*resultReg, ldDest0, *ldDest1, ptype0);
+    /* sub res, res, 1 */
+    SelectSub(*resultReg, *resultReg, immReg, ptype0);
+  }
+  Operand *tempReg = &static_cast<Operand&>(CreateRegisterOperandOfType(ptype0));
+  /* sub temp, x1, 1 */
+  SelectSub(*tempReg, *ldDest1, immReg, ptype0);
+  /* mvn temp, temp */
+  SelectMvn(*tempReg, *tempReg, ptype0);
+  /* and res, res, temp */
+  if (isUp) {
+    SelectBand(*resultReg, *resultReg, *tempReg, ptype0);
+  } else {
+    SelectBand(*resultReg, ldDest0, *tempReg, ptype0);
+  }
+  if (resultPtype != ptype0) {
+    SelectCvtInt2Int(&intrnNode, resultReg, resultReg, ptype0, resultPtype);
+  }
+  return resultReg;
+}
+
+void AArch64CGFunc::SelectStackSave() {
+  Operand &spOpnd = GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+  Operand &r0Opnd = GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, kRegTyInt);
+  Insn &saveInsn = GetInsnBuilder()->BuildInsn(MOP_xmovrr, r0Opnd, spOpnd);
+  GetCurBB()->AppendInsn(saveInsn);
+}
+
+void AArch64CGFunc::SelectStackRestore(const IntrinsiccallNode &intrnNode) {
+  BaseNode *argexpr0 = intrnNode.Opnd(0);
+  Operand *opnd0 = HandleExpr(intrnNode, *argexpr0);
+  Operand &spOpnd = GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+  Insn &restoreInsn = GetInsnBuilder()->BuildInsn(MOP_xmovrr, spOpnd, *opnd0);
+  GetCurBB()->AppendInsn(restoreInsn);
+}
+
+/*
+ * NOTE: consider moving the following things into aarch64_cg.cpp  They may
+ * serve not only inrinsics, but other MapleIR instructions as well.
+ * Do it as if we are adding a label in straight-line assembly code.
+ */
+LabelIdx AArch64CGFunc::CreateLabeledBB(StmtNode &stmt) {
+  LabelIdx labIdx = CreateLabel();
+  BB *newBB = StartNewBBImpl(false, stmt);
+  newBB->AddLabel(labIdx);
+  SetLab2BBMap(labIdx, *newBB);
+  SetCurBB(*newBB);
+  return labIdx;
+}
+
+/* Save value into the local variable for the index-th return value; */
+void AArch64CGFunc::SaveReturnValueInLocal(CallReturnVector &retVals, size_t index, PrimType primType, Operand &value,
+                                           StmtNode &parentStmt) {
+  CallReturnPair &pair = retVals.at(index);
+  BB tempBB(static_cast<uint32>(-1), *GetFuncScopeAllocator());
+  BB *realCurBB = GetCurBB();
+  CHECK_FATAL(!pair.second.IsReg(), "NYI");
+  Operand* destOpnd = &value;
+  /* for O0 ,corss-BB var is not support, do extra store/load but why new BB */
+  if (GetCG()->GetOptimizeLevel() == CGOptions::kLevel0) {
+    MIRSymbol *symbol = GetFunction().GetLocalOrGlobalSymbol(pair.first);
+    MIRType *sPty = symbol->GetType();
+    PrimType ty = symbol->GetType()->GetPrimType();
+    if (sPty->GetKind() == kTypeStruct || sPty->GetKind() == kTypeUnion) {
+      MIRStructType *structType = static_cast<MIRStructType*>(sPty);
+      ty = structType->GetFieldType(pair.second.GetFieldID())->GetPrimType();
+    } else if (sPty->GetKind() == kTypeClass) {
+      CHECK_FATAL(false, "unsuppotr type for inlineasm / intrinsic");
+    }
+    RegOperand &tempReg = CreateVirtualRegisterOperand(NewVReg(GetRegTyFromPrimTy(ty), GetPrimTypeSize(ty)));
+    SelectCopy(tempReg, ty, value, ty);
+    destOpnd = &tempReg;
+  }
+  SetCurBB(tempBB);
+  SelectDassign(pair.first, pair.second.GetFieldID(), primType, *destOpnd);
+
+  CHECK_FATAL(realCurBB->GetNext() == nullptr, "current BB must has not nextBB");
+  realCurBB->SetLastStmt(parentStmt);
+  realCurBB->SetNext(StartNewBBImpl(true, parentStmt));
+  realCurBB->GetNext()->SetKind(BB::kBBFallthru);
+  realCurBB->GetNext()->SetPrev(realCurBB);
+
+  realCurBB->GetNext()->InsertAtBeginning(*GetCurBB());
+  /* restore it */
+  SetCurBB(*realCurBB->GetNext());
+}
+
+/* The following are translation of LL/SC and atomic RMW operations */
+MemOrd AArch64CGFunc::OperandToMemOrd(Operand &opnd) const {
+  CHECK_FATAL(opnd.IsImmediate(), "Memory order must be an int constant.");
+  auto immOpnd = static_cast<ImmOperand*>(&opnd);
+  int32 val = immOpnd->GetValue();
+  CHECK_FATAL(val >= 0, "val must be non-negtive");
+  return MemOrdFromU32(static_cast<uint32>(val));
+}
+
+/*
+ * Generate ldxr or ldaxr instruction.
+ * byte_p2x: power-of-2 size of operand in bytes (0: 1B, 1: 2B, 2: 4B, 3: 8B).
+ */
+MOperator AArch64CGFunc::PickLoadStoreExclInsn(uint32 byteP2Size, bool store, bool acqRel) const {
+  CHECK_FATAL(byteP2Size < kIntByteSizeDimension, "Illegal argument p2size: %d", byteP2Size);
+
+  static MOperator operators[4][2][2] = { { { MOP_wldxrb, MOP_wldaxrb }, { MOP_wstxrb, MOP_wstlxrb } },
+                                          { { MOP_wldxrh, MOP_wldaxrh }, { MOP_wstxrh, MOP_wstlxrh } },
+                                          { { MOP_wldxr, MOP_wldaxr }, { MOP_wstxr, MOP_wstlxr } },
+                                          { { MOP_xldxr, MOP_xldaxr }, { MOP_xstxr, MOP_xstlxr } } };
+
+  MOperator optr = operators[byteP2Size][static_cast<uint32>(store)][static_cast<uint32>(acqRel)];
+  CHECK_FATAL(optr != MOP_undef, "Unsupported type p2size: %d", byteP2Size);
+
+  return optr;
+}
+
+RegOperand *AArch64CGFunc::SelectLoadExcl(PrimType valPrimType, MemOperand &loc, bool acquire) {
+  uint32 p2size = GetPrimTypeP2Size(valPrimType);
+
+  RegOperand &result = CreateRegisterOperandOfType(valPrimType);
+  MOperator mOp = PickLoadStoreExclInsn(p2size, false, acquire);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, loc));
+
+  return &result;
+}
+
+RegOperand *AArch64CGFunc::SelectStoreExcl(PrimType valPty, MemOperand &loc, RegOperand &newVal, bool release) {
+  uint32 p2size = GetPrimTypeP2Size(valPty);
+
+  /* the result (success/fail) is to be stored in a 32-bit register */
+  RegOperand &result = CreateRegisterOperandOfType(PTY_u32);
+
+  MOperator mOp = PickLoadStoreExclInsn(p2size, true, release);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(mOp, result, newVal, loc));
+
+  return &result;
+}
+
+RegType AArch64CGFunc::GetRegisterType(regno_t reg) const {
+  if (AArch64isa::IsPhysicalRegister(reg)) {
+    return AArch64isa::GetRegType(static_cast<AArch64reg>(reg));
+  } else if (reg == kRFLAG) {
+    return kRegTyCc;
+  } else {
+    return CGFunc::GetRegisterType(reg);
+  }
+}
+
+MemOperand &AArch64CGFunc::LoadStructCopyBase(const MIRSymbol &symbol, int64 offset, int dataSize) {
+  /* For struct formals > 16 bytes, this is the pointer to the struct copy. */
+  /* Load the base pointer first. */
+  RegOperand *vreg = &CreateVirtualRegisterOperand(NewVReg(kRegTyInt, k8ByteSize));
+  MemOperand *baseMemOpnd = &GetOrCreateMemOpnd(symbol, 0, k64BitSize);
+  GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(PickLdInsn(k64BitSize, PTY_i64), *vreg, *baseMemOpnd));
+  /* Create the indirect load mem opnd from the base pointer. */
+  return CreateMemOpnd(*vreg, offset, static_cast<uint32>(dataSize));
+}
+
+ /* For long branch, insert an unconditional branch.
+  * From                      To
+  *   cond_br targe_label       reverse_cond_br fallthru_label
+  *   fallthruBB                unconditional br target_label
+  *                             fallthru_label:
+  *                             fallthruBB
+  */
+void AArch64CGFunc::InsertJumpPad(Insn *insn) {
+  BB *bb = insn->GetBB();
+  ASSERT(bb, "instruction has no bb");
+  ASSERT(bb->GetKind() == BB::kBBIf || bb->GetKind() == BB::kBBGoto,
+         "instruction is in neither if bb nor goto bb");
+  if (bb->GetKind() == BB::kBBGoto) {
+    return;
+  }
+  ASSERT(bb->NumSuccs() == k2ByteSize, "if bb should have 2 successors");
+
+  BB *longBrBB = CreateNewBB();
+
+  BB *fallthruBB = bb->GetNext();
+  LabelIdx fallthruLBL = fallthruBB->GetLabIdx();
+  if (fallthruLBL == 0) {
+    fallthruLBL = CreateLabel();
+    SetLab2BBMap(static_cast<int32>(fallthruLBL), *fallthruBB);
+    fallthruBB->AddLabel(fallthruLBL);
+  }
+
+  BB *targetBB;
+  if (bb->GetSuccs().front() == fallthruBB) {
+    targetBB = bb->GetSuccs().back();
+  } else {
+    targetBB = bb->GetSuccs().front();
+  }
+  LabelIdx targetLBL = targetBB->GetLabIdx();
+  if (targetLBL == 0) {
+    targetLBL = CreateLabel();
+    SetLab2BBMap(static_cast<int32>(targetLBL), *targetBB);
+    targetBB->AddLabel(targetLBL);
+  }
+
+  // Adjustment on br and CFG
+  bb->RemoveSuccs(*targetBB);
+  bb->PushBackSuccs(*longBrBB);
+  bb->SetNext(longBrBB);
+  // reverse cond br targeting fallthruBB
+  uint32 targetIdx = AArch64isa::GetJumpTargetIdx(*insn);
+  MOperator mOp = AArch64isa::FlipConditionOp(insn->GetMachineOpcode());
+  insn->SetMOP( AArch64CG::kMd[mOp]);
+  LabelOperand &fallthruBBLBLOpnd = GetOrCreateLabelOperand(fallthruLBL);
+  insn->SetOperand(targetIdx, fallthruBBLBLOpnd);
+
+  longBrBB->PushBackPreds(*bb);
+  longBrBB->PushBackSuccs(*targetBB);
+  LabelOperand &targetLBLOpnd = GetOrCreateLabelOperand(targetLBL);
+  longBrBB->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xuncond, targetLBLOpnd));
+  longBrBB->SetPrev(bb);
+  longBrBB->SetNext(fallthruBB);
+  longBrBB->SetKind(BB::kBBGoto);
+
+  fallthruBB->SetPrev(longBrBB);
+
+  targetBB->RemovePreds(*bb);
+  targetBB->PushBackPreds(*longBrBB);
+}
+
+RegOperand *AArch64CGFunc::AdjustOneElementVectorOperand(PrimType oType, RegOperand *opnd) {
+  RegOperand *resCvt = &CreateRegisterOperandOfType(oType);
+  Insn *insnCvt = &GetInsnBuilder()->BuildInsn(MOP_xvmovrd, *resCvt, *opnd);
+  GetCurBB()->AppendInsn(*insnCvt);
+  return resCvt;
+}
+
+RegOperand *AArch64CGFunc::SelectOneElementVectorCopy(Operand *src, PrimType sType) {
+  RegOperand *res = &CreateRegisterOperandOfType(PTY_f64);
+  SelectCopy(*res, PTY_f64, *src, sType);
+  static_cast<RegOperand *>(res)->SetIF64Vec();
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorAbs(PrimType rType, Operand *o1) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(rType);     /* vector operand 1 */
+
+  MOperator mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vabsvv : MOP_vabsuu;
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorAddLong(PrimType rType, Operand *o1, Operand *o2,
+    PrimType otyp, bool isLow) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                     /* result type */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(otyp);       /* vector operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(otyp);       /* vector operand 2 */
+  MOperator mOp;
+  if (isLow) {
+    mOp = IsUnsignedInteger(rType) ? MOP_vuaddlvuu : MOP_vsaddlvuu;
+  } else {
+    mOp = IsUnsignedInteger(rType) ? MOP_vuaddl2vvv : MOP_vsaddl2vvv;
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorAddWiden(Operand *o1, PrimType otyp1, Operand *o2, PrimType otyp2, bool isLow) {
+  RegOperand *res = &CreateRegisterOperandOfType(otyp1);                     /* restype is same as o1 */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(otyp1);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(otyp1);      /* vector operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(otyp2);      /* vector operand 2 */
+
+  MOperator mOp;
+  if (isLow) {
+    mOp = IsUnsignedInteger(otyp1) ? MOP_vuaddwvvu : MOP_vsaddwvvu;
+  } else {
+    mOp = IsUnsignedInteger(otyp1) ? MOP_vuaddw2vvv : MOP_vsaddw2vvv;
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorImmMov(PrimType rType, Operand *src, PrimType sType) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                 /* result operand */
+  VectorRegSpec *vecSpec = GetMemoryPool()->New<VectorRegSpec>(rType);
+  int64 val = static_cast<ImmOperand*>(src)->GetValue();
+  /* copy the src imm operand to a reg if out of range */
+  if ((GetVecEleSize(rType) >= k64BitSize) ||
+      (GetPrimTypeSize(sType) > k4ByteSize && val != 0) ||
+      (val < kMinImmVal || val > kMaxImmVal)) {
+    Operand *reg = &CreateRegisterOperandOfType(sType);
+    SelectCopy(*reg, sType, *src, sType);
+    return SelectVectorRegMov(rType, reg, sType);
+  }
+
+  MOperator mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vmovvi : MOP_vmovui;
+  if (GetVecEleSize(rType) == k8BitSize && val < 0) {
+    src = &CreateImmOperand(static_cast<uint8>(val), k8BitSize, true);
+  } else if (val < 0) {
+    src = &CreateImmOperand(-(val + 1), k8BitSize, true);
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vnotvi : MOP_vnotui;
+  }
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*src);
+  (void)vInsn.PushRegSpecEntry(vecSpec);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorRegMov(PrimType rType, Operand *src, PrimType sType) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                 /* result operand */
+  VectorRegSpec *vecSpec = GetMemoryPool()->New<VectorRegSpec>(rType);
+
+  MOperator mOp;
+  if (GetPrimTypeSize(sType) > k4ByteSize) {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vxdupvr : MOP_vxdupur;
+  } else {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vwdupvr : MOP_vwdupur;
+  }
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*src);
+  (void)vInsn.PushRegSpecEntry(vecSpec);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorFromScalar(PrimType rType, Operand *src, PrimType sType) {
+  if (!IsPrimitiveVector(rType)) {
+    return SelectOneElementVectorCopy(src, sType);
+  } else if (src->IsConstImmediate()) {
+    return SelectVectorImmMov(rType, src, sType);
+  } else {
+    return SelectVectorRegMov(rType, src, sType);
+  }
+}
+
+RegOperand *AArch64CGFunc::SelectVectorDup(PrimType rType, Operand *src, bool getLow) {
+  PrimType oType = rType;
+  rType = FilterOneElementVectorType(oType);
+  RegOperand *res = &CreateRegisterOperandOfType(rType);
+  VectorRegSpec *vecSpecSrc = GetMemoryPool()->New<VectorRegSpec>(k2ByteSize, k64BitSize, getLow ? 0 : 1);
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(MOP_vduprv, AArch64CG::kMd[MOP_vduprv]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*src);
+  (void)vInsn.PushRegSpecEntry(vecSpecSrc);
+  GetCurBB()->AppendInsn(vInsn);
+  if (oType != rType) {
+    res = AdjustOneElementVectorOperand(oType, res);
+    static_cast<RegOperand *>(res)->SetIF64Vec();
+  }
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorGetElement(PrimType rType, Operand *src, PrimType sType, int32 lane) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                   /* result operand */
+  VectorRegSpec *vecSpecSrc = GetMemoryPool()->New<VectorRegSpec>(sType, lane);       /* vector operand */
+
+  MOperator mop;
+  if (!IsPrimitiveVector(sType)) {
+    mop = MOP_xmovrr;
+  } else if (GetPrimTypeBitSize(rType) >= k64BitSize) {
+    mop = MOP_vxmovrv;
+  } else {
+    mop = (GetPrimTypeBitSize(sType) > k64BitSize) ? MOP_vwmovrv : MOP_vwmovru;
+  }
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mop, AArch64CG::kMd[mop]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*src);
+  (void)vInsn.PushRegSpecEntry(vecSpecSrc);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+/* adalp o1, o2 instruction accumulates into o1, overwriting the original operand.
+   Hence we perform c = vadalp(a,b) as
+       T tmp = a;
+       return tmp+b;
+   The return value of vadalp is then assigned to c, leaving value of a intact.
+ */
+RegOperand *AArch64CGFunc::SelectVectorPairwiseAdalp(Operand *src1, PrimType sty1,
+    Operand *src2, PrimType sty2) {
+  VectorRegSpec *vecSpecDest;
+  RegOperand *res;
+
+  if (!IsPrimitiveVector(sty1)) {
+    RegOperand *resF = SelectOneElementVectorCopy(src1, sty1);
+    res = &CreateRegisterOperandOfType(PTY_f64);
+    SelectCopy(*res, PTY_f64, *resF, PTY_f64);
+    vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(k1ByteSize, k64BitSize);
+  } else {
+    res = &CreateRegisterOperandOfType(sty1);                            /* result type same as sty1 */
+    SelectCopy(*res, sty1, *src1, sty1);
+    vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(sty1);
+  }
+  VectorRegSpec *vecSpecSrc = GetMemoryPool()->New<VectorRegSpec>(sty2);
+
+  MOperator mop;
+  if (IsUnsignedInteger(sty1)) {
+    mop = GetPrimTypeSize(sty1) > k8ByteSize ? MOP_vupadalvv : MOP_vupadaluu;
+  } else {
+    mop = GetPrimTypeSize(sty1) > k8ByteSize ? MOP_vspadalvv : MOP_vspadaluu;
+  }
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mop, AArch64CG::kMd[mop]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*src2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpecSrc);
+  GetCurBB()->AppendInsn(vInsn);
+  if (!IsPrimitiveVector(sty1)) {
+    res = AdjustOneElementVectorOperand(sty1, res);
+  }
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorPairwiseAdd(PrimType rType, Operand *src, PrimType sType) {
+  PrimType oType = rType;
+  rType = FilterOneElementVectorType(oType);
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                   /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpecSrc = GetMemoryPool()->New<VectorRegSpec>(sType);       /* source operand */
+
+  if (rType == PTY_f64) {
+    vecSpecDest->vecLaneMax = 1;
+  }
+
+  MOperator mop;
+  if (IsUnsignedInteger(sType)) {
+    mop = GetPrimTypeSize(sType) > k8ByteSize ? MOP_vupaddvv : MOP_vupadduu;
+  } else {
+    mop = GetPrimTypeSize(sType) > k8ByteSize ? MOP_vspaddvv : MOP_vspadduu;
+  }
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mop, AArch64CG::kMd[mop]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*src);
+  /* dest pushed first, popped first */
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpecSrc);
+  GetCurBB()->AppendInsn(vInsn);
+  if (oType != rType) {
+    res = AdjustOneElementVectorOperand(oType, res);
+  }
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorSetElement(Operand *eOpnd, PrimType eType, Operand *vOpnd,
+                                                  PrimType vType, int32 lane) {
+  if (!IsPrimitiveVector(vType)) {
+    return SelectOneElementVectorCopy(eOpnd, eType);
+  }
+  RegOperand *reg = &CreateRegisterOperandOfType(eType);                   /* vector element type */
+  SelectCopy(*reg, eType, *eOpnd, eType);
+  VectorRegSpec *vecSpecSrc = GetMemoryPool()->New<VectorRegSpec>(vType, lane);       /* vector operand == result */
+
+  MOperator mOp;
+  if (GetPrimTypeSize(eType) > k4ByteSize) {
+    mOp = GetPrimTypeSize(vType) > k8ByteSize ? MOP_vxinsvr : MOP_vxinsur;
+  } else {
+    mOp = GetPrimTypeSize(vType) > k8ByteSize ? MOP_vwinsvr : MOP_vwinsur;
+  }
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*vOpnd).AddOpndChain(*reg);
+  (void)vInsn.PushRegSpecEntry(vecSpecSrc);
+  GetCurBB()->AppendInsn(vInsn);
+  return static_cast<RegOperand*>(vOpnd);
+}
+
+RegOperand *AArch64CGFunc::SelectVectorAbsSubL(PrimType rType, Operand *o1, Operand *o2,
+    PrimType oTy, bool isLow) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpecOpd1 = GetMemoryPool()->New<VectorRegSpec>(oTy);
+  VectorRegSpec *vecSpecOpd2 = GetMemoryPool()->New<VectorRegSpec>(oTy);    /* same opnd types */
+
+  MOperator mop;
+  if (isLow) {
+    mop = IsPrimitiveUnSignedVector(rType) ? MOP_vuabdlvuu : MOP_vsabdlvuu;
+  } else {
+    mop = IsPrimitiveUnSignedVector(rType) ? MOP_vuabdl2vvv : MOP_vsabdl2vvv;
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mop, AArch64CG::kMd[mop]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpecOpd1).PushRegSpecEntry(vecSpecOpd2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorMerge(PrimType rType, Operand *o1, Operand *o2, int32 index) {
+  if (!IsPrimitiveVector(rType)) {
+    static_cast<RegOperand *>(o1)->SetIF64Vec();
+    return static_cast<RegOperand *>(o1);                                   /* 64x1_t, index equals 0 */
+  }
+  RegOperand *res = &CreateRegisterOperandOfType(rType);
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpecOpd1 = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpecOpd2 = GetMemoryPool()->New<VectorRegSpec>(rType);
+
+  ImmOperand *imm = &CreateImmOperand(index, k8BitSize, true);
+
+  MOperator mOp = (GetPrimTypeSize(rType) > k8ByteSize) ? MOP_vextvvvi : MOP_vextuuui;
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2).AddOpndChain(*imm);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpecOpd1).PushRegSpecEntry(vecSpecOpd2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorReverse(PrimType rType, Operand *src, PrimType sType, uint32 size) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                   /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpecSrc = GetMemoryPool()->New<VectorRegSpec>(sType);       /* vector operand */
+
+  MOperator mOp;
+  if (GetPrimTypeBitSize(rType) == k128BitSize) {
+    mOp = size >= k64BitSize ? MOP_vrev64qq : (size >= k32BitSize ? MOP_vrev32qq : MOP_vrev16qq);
+  } else if (GetPrimTypeBitSize(rType) == k64BitSize) {
+    mOp = size >= k64BitSize ? MOP_vrev64dd : (size >= k32BitSize ? MOP_vrev32dd : MOP_vrev16dd);
+  } else {
+    CHECK_FATAL(false, "should not be here");
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*src);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpecSrc);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorSum(PrimType rType, Operand *o1, PrimType oType) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* uint32_t result */
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(oType);
+  RegOperand *iOpnd = &CreateRegisterOperandOfType(oType);                  /* float intermediate result */
+  uint32 eSize = GetVecEleSize(oType);                                      /* vector opd in bits */
+  bool is16ByteVec = GetPrimTypeSize(oType) >= k16ByteSize;
+  MOperator mOp;
+  if (is16ByteVec) {
+    mOp = eSize <= k8BitSize ? MOP_vbaddvrv : (eSize <= k16BitSize ? MOP_vhaddvrv :
+          (eSize <= k32BitSize ? MOP_vsaddvrv : MOP_vdaddvrv));
+  } else {
+    mOp = eSize <= k8BitSize ? MOP_vbaddvru : (eSize <= k16BitSize ? MOP_vhaddvru : MOP_vsaddvru);
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*iOpnd).AddOpndChain(*o1);
+  (void)vInsn.PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(vInsn);
+
+  mOp = eSize > k32BitSize ? MOP_vxmovrv : MOP_vwmovrv;
+  VectorInsn &vInsn2 = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  auto *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(oType);
+  (void)vInsn2.AddOpndChain(*res).AddOpndChain(*iOpnd);
+  vecSpec2->vecLane = 0;
+  (void)vInsn2.PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn2);
+  return res;
+}
+
+void AArch64CGFunc::PrepareVectorOperands(Operand **o1, PrimType &oty1, Operand **o2, PrimType &oty2) {
+  /* Only 1 operand can be non vector, otherwise it's a scalar operation, wouldn't come here */
+  if (IsPrimitiveVector(oty1) == IsPrimitiveVector(oty2)) {
+    return;
+  }
+  PrimType origTyp = !IsPrimitiveVector(oty2) ? oty2 : oty1;
+  Operand *opd = !IsPrimitiveVector(oty2) ? *o2 : *o1;
+  PrimType rType = !IsPrimitiveVector(oty2) ? oty1 : oty2;                  /* Type to dup into */
+  RegOperand *res = &CreateRegisterOperandOfType(rType);
+  VectorRegSpec *vecSpec = GetMemoryPool()->New<VectorRegSpec>(rType);
+
+  bool immOpnd = false;
+  if (opd->IsConstImmediate()) {
+    int64 val = static_cast<ImmOperand*>(opd)->GetValue();
+    if (val >= kMinImmVal && val <= kMaxImmVal && GetVecEleSize(rType) < k64BitSize) {
+      immOpnd = true;
+    } else {
+      RegOperand *regOpd = &CreateRegisterOperandOfType(origTyp);
+      SelectCopyImm(*regOpd, origTyp, static_cast<ImmOperand&>(*opd), origTyp);
+      opd = static_cast<Operand*>(regOpd);
+    }
+  }
+
+  /* need dup to vector operand */
+  MOperator mOp;
+  if (immOpnd) {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vmovvi : MOP_vmovui;    /* a const */
+  } else {
+    if (GetPrimTypeSize(origTyp) > k4ByteSize) {
+      mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vxdupvr : MOP_vxdupur;
+    } else {
+      mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vwdupvr : MOP_vwdupur; /* a scalar var */
+    }
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*opd);
+  (void)vInsn.PushRegSpecEntry(vecSpec);
+  GetCurBB()->AppendInsn(vInsn);
+  if (!IsPrimitiveVector(oty2)) {
+    *o2 = static_cast<Operand*>(res);
+    oty2 = rType;
+  } else {
+    *o1 = static_cast<Operand*>(res);
+    oty1 = rType;
+  }
+}
+
+void AArch64CGFunc::SelectVectorCvt(Operand *res, PrimType rType, Operand *o1, PrimType oType) {
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(oType);           /* vector operand 1 */
+
+  MOperator mOp;
+  VectorInsn *insn;
+  if (GetPrimTypeSize(rType) > GetPrimTypeSize(oType)) {
+    /* expand, similar to vmov_XX() intrinsics */
+    mOp = IsUnsignedInteger(rType) ? MOP_vushllvvi : MOP_vshllvvi;
+    ImmOperand *imm = &CreateImmOperand(0, k8BitSize, true);
+    insn = &GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+    (void)insn->AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*imm);
+  } else if (GetPrimTypeSize(rType) < GetPrimTypeSize(oType)) {
+    /* extract, similar to vqmovn_XX() intrinsics */
+    insn = &GetInsnBuilder()->BuildVectorInsn(MOP_vxtnuv, AArch64CG::kMd[MOP_vxtnuv]);
+    (void)insn->AddOpndChain(*res).AddOpndChain(*o1);
+  } else {
+    CHECK_FATAL(false, "Invalid cvt between 2 operands of the same size");
+  }
+  (void)insn->PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(*insn);
+}
+
+RegOperand *AArch64CGFunc::SelectVectorCompareZero(Operand *o1, PrimType oty1, Operand *o2, Opcode opc) {
+  if (IsUnsignedInteger(oty1) && (opc != OP_eq && opc != OP_ne)) {
+    return nullptr;                                                         /* no unsigned instr for zero */
+  }
+  RegOperand *res = &CreateRegisterOperandOfType(oty1);                     /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(oty1);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(oty1);          /* vector operand 1 */
+
+  MOperator mOp;
+  switch (opc) {
+    case OP_eq:
+    case OP_ne:
+      mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vzcmeqvv : MOP_vzcmequu;
+      break;
+    case OP_gt:
+      mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vzcmgtvv : MOP_vzcmgtuu;
+      break;
+    case OP_ge:
+      mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vzcmgevv : MOP_vzcmgeuu;
+      break;
+    case OP_lt:
+      mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vzcmltvv : MOP_vzcmltuu;
+      break;
+    case OP_le:
+      mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vzcmlevv : MOP_vzcmleuu;
+      break;
+    default:
+      CHECK_FATAL(false, "Invalid cc in vector compare");
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(vInsn);
+  if (opc == OP_ne) {
+    res = SelectVectorNot(oty1, res);
+  }
+  return res;
+}
+
+/* Neon compare intrinsics always return unsigned vector, MapleIR for comparison always return
+   signed.  Using type of 1st operand for operation here */
+RegOperand *AArch64CGFunc::SelectVectorCompare(Operand *o1, PrimType oty1, Operand *o2, PrimType oty2, Opcode opc) {
+  if (o2->IsConstImmediate() && static_cast<ImmOperand*>(o2)->GetValue() == 0) {
+    RegOperand *zeroCmp = SelectVectorCompareZero(o1, oty1, o2, opc);
+    if (zeroCmp != nullptr) {
+      return zeroCmp;
+    }
+  }
+  PrepareVectorOperands(&o1, oty1, &o2, oty2);
+  ASSERT(oty1 == oty2, "vector operand type mismatch");
+
+  RegOperand *res = &CreateRegisterOperandOfType(oty1);                     /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(oty1);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(oty1);          /* vector operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(oty2);          /* vector operand 2 */
+
+  MOperator mOp;
+  switch (opc) {
+    case OP_eq:
+    case OP_ne:
+      mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vcmeqvvv : MOP_vcmequuu;
+      break;
+    case OP_lt:
+    case OP_gt:
+      if (IsUnsignedInteger(oty1)) {
+        mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vcmhivvv : MOP_vcmhiuuu;
+      } else {
+        mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vcmgtvvv : MOP_vcmgtuuu;
+      }
+      break;
+    case OP_le:
+    case OP_ge:
+      if (IsUnsignedInteger(oty1)) {
+        mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vcmhsvvv : MOP_vcmhsuuu;
+      } else {
+        mOp = GetPrimTypeSize(oty1) > k8ByteSize ? MOP_vcmgevvv : MOP_vcmgeuuu;
+      }
+      break;
+    default:
+      CHECK_FATAL(false, "Invalid cc in vector compare");
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  if (opc == OP_lt || opc == OP_le) {
+    (void)vInsn.AddOpndChain(*res).AddOpndChain(*o2).AddOpndChain(*o1);
+  } else {
+    (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  }
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  if (opc == OP_ne) {
+    res = SelectVectorNot(oty1, res);
+  }
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorShift(PrimType rType, Operand *o1, PrimType oty1,
+                                             Operand *o2, PrimType oty2, Opcode opc) {
+  PrepareVectorOperands(&o1, oty1, &o2, oty2);
+  PrimType resultType = rType;
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(rType);          /* vector operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(rType);          /* vector operand 2 */
+
+  if (!IsPrimitiveVector(rType)) {
+    o1 = &SelectCopy(*o1, rType, PTY_f64);
+    o2 = &SelectCopy(*o2, rType, PTY_f64);
+    resultType = PTY_f64;
+  }
+  RegOperand *res = &CreateRegisterOperandOfType(resultType);                    /* result operand */
+
+  /* signed and unsigned shl(v,v) both use sshl or ushl, they are the same */
+  MOperator mOp;
+  if (IsPrimitiveUnsigned(rType)) {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vushlvvv : MOP_vushluuu;
+  } else {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vshlvvv : MOP_vshluuu;
+  }
+
+  if (opc != OP_shl) {
+    o2 = SelectVectorNeg(rType, o2);
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+uint32 ValidShiftConst(PrimType rType) {
+  switch (rType) {
+    case PTY_v8u8:
+    case PTY_v8i8:
+    case PTY_v16u8:
+    case PTY_v16i8:
+      return k8BitSize;
+    case PTY_v4u16:
+    case PTY_v4i16:
+    case PTY_v8u16:
+    case PTY_v8i16:
+      return k16BitSize;
+    case PTY_v2u32:
+    case PTY_v2i32:
+    case PTY_v4u32:
+    case PTY_v4i32:
+      return k32BitSize;
+    case PTY_v2u64:
+    case PTY_v2i64:
+      return k64BitSize;
+    default:
+      CHECK_FATAL(false, "Invalid Shift operand type");
+  }
+  return 0;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorShiftImm(PrimType rType, Operand *o1, Operand *imm, int32 sVal, Opcode opc) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(rType);          /* vector operand 1 */
+
+  if (!imm->IsConstImmediate()) {
+    CHECK_FATAL(false, "VectorUShiftImm has invalid shift const");
+  }
+  uint32 shift = static_cast<uint32>(ValidShiftConst(rType));
+  bool needDup = false;
+  if (opc == OP_shl) {
+    if ((shift == k8BitSize && (sVal < 0 || static_cast<uint32>(sVal) >= shift)) ||
+        (shift == k16BitSize && (sVal < 0 || static_cast<uint32>(sVal) >= shift)) ||
+        (shift == k32BitSize && (sVal < 0 || static_cast<uint32>(sVal) >= shift)) ||
+        (shift == k64BitSize && (sVal < 0 || static_cast<uint32>(sVal) >= shift))) {
+      needDup = true;
+    }
+  } else {
+    if ((shift == k8BitSize && (sVal < 1 || static_cast<uint32>(sVal) > shift)) ||
+        (shift == k16BitSize && (sVal < 1 || static_cast<uint32>(sVal) > shift)) ||
+        (shift == k32BitSize && (sVal < 1 || static_cast<uint32>(sVal) > shift)) ||
+        (shift == k64BitSize && (sVal < 1 || static_cast<uint32>(sVal) > shift))) {
+      needDup = true;
+    }
+  }
+  if (needDup) {
+    /* Dup constant to vector reg */
+    MOperator mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vmovvi : MOP_vmovui;
+    VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+    (void)vInsn.AddOpndChain(*res).AddOpndChain(*imm);
+    (void)vInsn.PushRegSpecEntry(vecSpecDest);
+    GetCurBB()->AppendInsn(vInsn);
+    res = SelectVectorShift(rType, o1, rType, res, rType, opc);
+    return res;
+  }
+  MOperator mOp;
+  if (GetPrimTypeSize(rType) > k8ByteSize) {
+    if (IsUnsignedInteger(rType)) {
+      mOp = opc == OP_shl ? MOP_vushlvvi : MOP_vushrvvi;
+    } else {
+      mOp = opc == OP_shl ? MOP_vushlvvi : MOP_vshrvvi;
+    }
+  } else {
+    if (IsUnsignedInteger(rType)) {
+      mOp = opc == OP_shl ? MOP_vushluui : MOP_vushruui;
+    } else {
+      mOp = opc == OP_shl ? MOP_vushluui : MOP_vshruui;
+    }
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*imm);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorTableLookup(PrimType rType, Operand *o1, Operand *o2) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);  /* 8B or 16B */
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(rType);     /* vector operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(rType);     /* vector operand 2 */
+  vecSpec1->compositeOpnds = 1;                                             /* composite operand */
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(MOP_vtbl1vvv, AArch64CG::kMd[MOP_vtbl1vvv]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorMadd(Operand *o1, PrimType oTyp1, Operand *o2,
+                                            PrimType oTyp2, Operand *o3, PrimType oTyp3) {
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(oTyp1);          /* operand 1 and result */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(oTyp2);          /* vector operand 2 */
+  VectorRegSpec *vecSpec3 = GetMemoryPool()->New<VectorRegSpec>(oTyp3);          /* vector operand 2 */
+
+  MOperator mop = IsPrimitiveUnSignedVector(oTyp1) ? MOP_vumaddvvv : MOP_vsmaddvvv;
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mop, AArch64CG::kMd[mop]);
+  (void)vInsn.AddOpndChain(*o1).AddOpndChain(*o2).AddOpndChain(*o3);
+  (void)vInsn.PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2).PushRegSpecEntry(vecSpec3);
+  GetCurBB()->AppendInsn(vInsn);
+  return static_cast<RegOperand*>(o1);
+}
+
+RegOperand *AArch64CGFunc::SelectVectorMull(PrimType rType, Operand *o1, PrimType oTyp1,
+                                            Operand *o2, PrimType oTyp2, bool isLow) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(oTyp1);          /* vector operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(oTyp2);          /* vector operand 1 */
+
+  MOperator mop;
+  if (isLow) {
+    mop = IsPrimitiveUnSignedVector(rType) ? MOP_vumullvvv : MOP_vsmullvvv;
+  } else {
+    mop = IsPrimitiveUnSignedVector(rType) ? MOP_vumull2vvv : MOP_vsmull2vvv;
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mop, AArch64CG::kMd[mop]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorBinOp(PrimType rType, Operand *o1, PrimType oty1, Operand *o2,
+                                             PrimType oty2, Opcode opc) {
+  PrepareVectorOperands(&o1, oty1, &o2, oty2);
+  ASSERT(oty1 == oty2, "vector operand type mismatch");
+
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                   /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(oty1);         /* source operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(oty2);         /* source operand 2 */
+
+  MOperator mOp;
+  if (opc == OP_add) {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vaddvvv : MOP_vadduuu;
+  } else if (opc == OP_sub) {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vsubvvv : MOP_vsubuuu;
+  } else if (opc == OP_mul) {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vmulvvv : MOP_vmuluuu;
+  } else {
+    CHECK_FATAL(false, "Invalid opcode for SelectVectorBinOp");
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  /* dest pushed first, popped first */
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorBitwiseOp(PrimType rType, Operand *o1, PrimType oty1, Operand *o2,
+                                                 PrimType oty2, Opcode opc) {
+  PrepareVectorOperands(&o1, oty1, &o2, oty2);
+  ASSERT(oty1 == oty2, "vector operand type mismatch");
+
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(rType);          /* vector operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(rType);          /* vector operand 1 */
+
+  MOperator mOp;
+  if (opc == OP_band) {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vandvvv : MOP_vanduuu;
+  } else if (opc == OP_bior) {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vorvvv : MOP_voruuu;
+  } else if (opc == OP_bxor) {
+    mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vxorvvv : MOP_vxoruuu;
+  } else {
+    CHECK_FATAL(false, "Invalid opcode for SelectVectorBitwiseOp");
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1).PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorNarrow(PrimType rType, Operand *o1, PrimType otyp) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(otyp);      /* vector operand */
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(MOP_vxtnuv, AArch64CG::kMd[MOP_vxtnuv]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorNarrow2(PrimType rType, Operand *o1, PrimType oty1, Operand *o2, PrimType oty2) {
+  (void)oty1;             /* 1st opnd was loaded already, type no longer needed */
+  RegOperand *res = static_cast<RegOperand *>(o1);   /* o1 is also the result */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(oty2);      /* vector opnd2 */
+
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(MOP_vxtn2uv, AArch64CG::kMd[MOP_vxtn2uv]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorNot(PrimType rType, Operand *o1) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(rType);          /* vector operand 1 */
+
+  MOperator mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vnotvv : MOP_vnotuu;
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorNeg(PrimType rType, Operand *o1) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(rType);          /* vector operand 1 */
+
+  MOperator mOp = GetPrimTypeSize(rType) > k8ByteSize ? MOP_vnegvv : MOP_vneguu;
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest);
+  (void)vInsn.PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+/*
+ * Called internally for auto-vec, no intrinsics for now
+ */
+RegOperand *AArch64CGFunc::SelectVectorSelect(Operand &cond, PrimType rType, Operand &o0, Operand &o1) {
+  rType = GetPrimTypeSize(rType) > k8ByteSize ? PTY_v16u8 : PTY_v8u8;
+  RegOperand *res = &CreateRegisterOperandOfType(rType);
+  SelectCopy(*res, rType, cond, rType);
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(rType);
+
+  uint32 mOp = GetPrimTypeBitSize(rType) > k64BitSize ? MOP_vbslvvv : MOP_vbsluuu;
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(o0).AddOpndChain(o1);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest);
+  (void)vInsn.PushRegSpecEntry(vecSpec1);
+  (void)vInsn.PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorShiftRNarrow(PrimType rType, Operand *o1, PrimType oType,
+                                                    Operand *o2, bool isLow) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(oType);          /* vector operand 1 */
+
+  ImmOperand *imm = static_cast<ImmOperand*>(o2);
+  MOperator mOp;
+  if (isLow) {
+    mOp = MOP_vshrnuvi;
+  } else {
+    CHECK_FATAL(false, "NYI: vshrn_high_");
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*imm);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest);
+  (void)vInsn.PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorSubWiden(PrimType resType, Operand *o1, PrimType otyp1,
+                                                Operand *o2, PrimType otyp2, bool isLow, bool isWide) {
+  RegOperand *res = &CreateRegisterOperandOfType(resType);                   /* result reg */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(resType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(otyp1);      /* vector operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(otyp2);      /* vector operand 2 */
+
+  MOperator mOp;
+  if (!isWide) {
+    if (isLow) {
+      mOp = IsUnsignedInteger(otyp1) ? MOP_vusublvuu : MOP_vssublvuu;
+    } else {
+      mOp = IsUnsignedInteger(otyp1) ? MOP_vusubl2vvv : MOP_vssubl2vvv;
+    }
+  } else {
+    if (isLow) {
+      mOp = IsUnsignedInteger(otyp1) ? MOP_vusubwvvu : MOP_vssubwvvu;
+    } else {
+      mOp = IsUnsignedInteger(otyp1) ? MOP_vusubw2vvv : MOP_vssubw2vvv;
+    }
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest);
+  (void)vInsn.PushRegSpecEntry(vecSpec1);
+  (void)vInsn.PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+void AArch64CGFunc::SelectVectorZip(PrimType rType, Operand *o1, Operand *o2) {
+  RegOperand *res1 = &CreateRegisterOperandOfType(rType);                   /* result operand 1 */
+  RegOperand *res2 = &CreateRegisterOperandOfType(rType);                   /* result operand 2 */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(rType);          /* vector operand 1 */
+  VectorRegSpec *vecSpec2 = GetMemoryPool()->New<VectorRegSpec>(rType);          /* vector operand 2 */
+
+  VectorInsn &vInsn1 = GetInsnBuilder()->BuildVectorInsn(MOP_vzip1vvv, AArch64CG::kMd[MOP_vzip1vvv]);
+  (void)vInsn1.AddOpndChain(*res1).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn1.PushRegSpecEntry(vecSpecDest);
+  (void)vInsn1.PushRegSpecEntry(vecSpec1);
+  (void)vInsn1.PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn1);
+
+  VectorInsn &vInsn2 = GetInsnBuilder()->BuildVectorInsn(MOP_vzip2vvv, AArch64CG::kMd[MOP_vzip2vvv]);
+  (void)vInsn2.AddOpndChain(*res2).AddOpndChain(*o1).AddOpndChain(*o2);
+  (void)vInsn2.PushRegSpecEntry(vecSpecDest);
+  (void)vInsn2.PushRegSpecEntry(vecSpec1);
+  (void)vInsn2.PushRegSpecEntry(vecSpec2);
+  GetCurBB()->AppendInsn(vInsn2);
+
+  if (GetPrimTypeSize(rType) <= k16ByteSize) {
+    Operand *preg1 = &GetOrCreatePhysicalRegisterOperand(V0, k64BitSize, kRegTyFloat);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xvmovd, *preg1, *res1));
+    Operand *preg2 = &GetOrCreatePhysicalRegisterOperand(V1, k64BitSize, kRegTyFloat);
+    GetCurBB()->AppendInsn(GetInsnBuilder()->BuildInsn(MOP_xvmovd, *preg2, *res2));
+  }
+}
+
+RegOperand *AArch64CGFunc::SelectVectorWiden(PrimType rType, Operand *o1, PrimType otyp, bool isLow) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(otyp);      /* vector operand */
+
+  MOperator mOp;
+  if (isLow) {
+    mOp = IsPrimitiveUnSignedVector(rType) ? MOP_vuxtlvu : MOP_vsxtlvu;
+  } else {
+    mOp = IsPrimitiveUnSignedVector(rType) ? MOP_vuxtl2vv : MOP_vsxtl2vv;
+  }
+  VectorInsn &vInsn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)vInsn.AddOpndChain(*res).AddOpndChain(*o1);
+  (void)vInsn.PushRegSpecEntry(vecSpecDest);
+  (void)vInsn.PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(vInsn);
+  return res;
+}
+
+RegOperand *AArch64CGFunc::SelectVectorMovNarrow(PrimType rType, Operand *opnd, PrimType oType) {
+  RegOperand *res = &CreateRegisterOperandOfType(rType);                    /* result operand */
+  VectorRegSpec *vecSpecDest = GetMemoryPool()->New<VectorRegSpec>(rType);
+  VectorRegSpec *vecSpec1 = GetMemoryPool()->New<VectorRegSpec>(oType);      /* vector operand */
+
+  MOperator mOp = IsPrimitiveUnSignedVector(rType) ? MOP_vuqxtnuv : MOP_vsqxtnuv;
+  VectorInsn &insn = GetInsnBuilder()->BuildVectorInsn(mOp, AArch64CG::kMd[mOp]);
+  (void)insn.AddOpndChain(*res).AddOpndChain(*opnd);
+  (void)insn.PushRegSpecEntry(vecSpecDest);
+  (void)insn.PushRegSpecEntry(vecSpec1);
+  GetCurBB()->AppendInsn(insn);
+  return res;
+}
+
+/*
+ * Check the distance between the first insn of BB with the lable(targ_labidx)
+ * and the insn with targ_id. If the distance greater than kShortBRDistance
+ * return false.
+ */
+bool AArch64CGFunc::DistanceCheck(const BB &bb, LabelIdx targLabIdx, uint32 targId) const {
+  for (auto *tBB : bb.GetSuccs()) {
+    if (tBB->GetLabIdx() != targLabIdx) {
+      continue;
+    }
+    Insn *tInsn = tBB->GetFirstInsn();
+    while (tInsn == nullptr || !tInsn->IsMachineInstruction()) {
+      if (tInsn == nullptr) {
+        tBB = tBB->GetNext();
+        if (tBB == nullptr) { /* tailcallopt may make the target block empty */
+          return true;
+        }
+        tInsn = tBB->GetFirstInsn();
+      } else {
+        tInsn = tInsn->GetNext();
+      }
+    }
+    uint32 tmp = (tInsn->GetId() > targId) ? (tInsn->GetId() - targId) : (targId - tInsn->GetId());
+    return (tmp < kShortBRDistance);
+  }
+  CHECK_FATAL(false, "CFG error");
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c1ef39d578128be369a2668d66b9570438be6dfc
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
@@ -0,0 +1,4888 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_color_ra.h"
+#include "cg.h"
+#include "mir_lower.h"
+#include "securec.h"
+/*
+ * Based on concepts from Chow and Hennessey.
+ * Phases are as follows:
+ *   Prepass to collect local BB information.
+ *     Compute local register allocation demands for global RA.
+ *   Compute live ranges.
+ *     Live ranges LR represented by a vector of size #BBs.
+ *     for each cross bb vreg, a bit is set in the vector.
+ *   Build interference graph with basic block as granularity.
+ *     When intersection of two LRs is not null, they interfere.
+ *   Separate unconstrained and constrained LRs.
+ *     unconstrained - LR with connect edges less than available colors.
+ *                     These LR can always be colored.
+ *     constrained - not uncontrained.
+ *   Split LR based on priority cost
+ *     Repetitive adding BB from original LR to new LR until constrained.
+ *     Update all LR the new LR interferes with.
+ *   Color the new LR
+ *     Each LR has a forbidden list, the registers cannot be assigned
+ *     Coalesce move using preferred color first.
+ *   Mark the remaining uncolorable LR after split as spill.
+ *   Local register allocate.
+ *   Emit and insert spills.
+ */
+namespace maplebe {
+#define JAVALANG (cgFunc->GetMirModule().IsJavaModule())
+#define CLANG (cgFunc->GetMirModule().IsCModule())
+
+constexpr uint32 kLoopWeight = 20;
+constexpr uint32 kAdjustWeight = 2;
+constexpr uint32 kInsnStep = 2;
+constexpr uint32 kMaxSplitCount = 3;
+constexpr uint32 kRematWeight = 3;
+constexpr uint32 kPriorityDefThreashold = 1;
+constexpr uint32 kPriorityUseThreashold = 5;
+constexpr uint32 kPriorityBBThreashold = 1000;
+constexpr float  kPriorityRatioThreashold = 0.9;
+
+#define GCRA_DUMP CG_DEBUG_FUNC(*cgFunc)
+
+void LiveUnit::PrintLiveUnit() const {
+  LogInfo::MapleLogger() << "[" << begin << "," << end << "]"
+                         << "<D" << defNum << "U" << useNum << ">";
+  if (!hasCall) {
+    /* Too many calls, so only print when there is no call. */
+    LogInfo::MapleLogger() << " nc";
+  }
+  if (needReload) {
+    LogInfo::MapleLogger() << " rlod";
+  }
+  if (needRestore) {
+    LogInfo::MapleLogger() << " rstr";
+  }
+}
+
+template <typename Func>
+void GraphColorRegAllocator::ForEachBBArrElem(const uint64 *vec, Func functor) const {
+  for (uint32 iBBArrElem = 0; iBBArrElem < bbBuckets; ++iBBArrElem) {
+    for (uint32 bBBArrElem = 0; bBBArrElem < kU64; ++bBBArrElem) {
+      if ((vec[iBBArrElem] & (1ULL << bBBArrElem)) != 0) {
+        functor(iBBArrElem * kU64 + bBBArrElem);
+      }
+    }
+  }
+}
+
+template <typename Func>
+void GraphColorRegAllocator::ForEachBBArrElemWithInterrupt(const uint64 *vec, Func functor) const {
+  for (uint32 iBBArrElem = 0; iBBArrElem < bbBuckets; ++iBBArrElem) {
+    for (uint32 bBBArrElem = 0; bBBArrElem < kU64; ++bBBArrElem) {
+      if ((vec[iBBArrElem] & (1ULL << bBBArrElem)) != 0) {
+        if (functor(iBBArrElem * kU64 + bBBArrElem)) {
+          return;
+        }
+      }
+    }
+  }
+}
+
+template <typename Func>
+void GraphColorRegAllocator::ForEachRegArrElem(const uint64 *vec, Func functor) const {
+  for (uint32 iBBArrElem = 0; iBBArrElem < regBuckets; ++iBBArrElem) {
+    for (uint32 bBBArrElem = 0; bBBArrElem < kU64; ++bBBArrElem) {
+      if ((vec[iBBArrElem] & (1ULL << bBBArrElem)) != 0) {
+        functor(iBBArrElem * kU64 + bBBArrElem);
+      }
+    }
+  }
+}
+
+void GraphColorRegAllocator::PrintLiveUnitMap(const LiveRange &lr) const {
+  LogInfo::MapleLogger() << "\n\tlu:";
+  for (uint32 i = 0; i < cgFunc->NumBBs(); ++i) {
+    if (!IsBitArrElemSet(lr.GetBBMember(), i)) {
+      continue;
+    }
+    auto lu = lr.GetLuMap().find(i);
+    if (lu != lr.GetLuMap().end() && ((lu->second->GetDefNum() > 0) || (lu->second->GetUseNum() > 0))) {
+      LogInfo::MapleLogger() << "(" << i << " ";
+      lu->second->PrintLiveUnit();
+      LogInfo::MapleLogger() << ")";
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void GraphColorRegAllocator::PrintLiveRangeConflicts(const LiveRange &lr) const {
+  LogInfo::MapleLogger() << "\n\tinterfere(" << lr.GetNumBBConflicts() << "): ";
+  for (uint32 i = 0; i < regBuckets; ++i) {
+    uint64 chunk = lr.GetBBConflictElem(i);
+    for (uint64 bit = 0; bit < kU64; ++bit) {
+      if ((chunk & (1ULL << bit)) > 0) {
+        regno_t newNO = i * kU64 + bit;
+        LogInfo::MapleLogger() << newNO << ",";
+      }
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void GraphColorRegAllocator::PrintLiveBBBit(const LiveRange &lr) const {
+  LogInfo::MapleLogger() << "live_bb(" << lr.GetNumBBMembers() << "): ";
+  for (uint32 i = 0; i < cgFunc->NumBBs(); ++i) {
+    if (IsBitArrElemSet(lr.GetBBMember(), i)) {
+      LogInfo::MapleLogger() << i << " ";
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void GraphColorRegAllocator::PrintLiveRange(const LiveRange &lr, const std::string &str) const {
+  LogInfo::MapleLogger() << str << "\n";
+
+  LogInfo::MapleLogger() << "R" << lr.GetRegNO();
+  if (lr.GetRegType() == kRegTyInt) {
+    LogInfo::MapleLogger() << "(I)";
+  } else if (lr.GetRegType() == kRegTyFloat) {
+    LogInfo::MapleLogger() << "(F)";
+  } else {
+    LogInfo::MapleLogger() << "(U)";
+  }
+  if (lr.GetSpillSize() == k32BitSize) {
+    LogInfo::MapleLogger() << "S32";
+  } else if (lr.GetSpillSize() == k64BitSize) {
+    LogInfo::MapleLogger() << "S64";
+  } else {
+    LogInfo::MapleLogger() << "S0(nodef)";
+  }
+  LogInfo::MapleLogger() << "\tnumCall " << lr.GetNumCall();
+  if (lr.GetCrossCall()) {
+    LogInfo::MapleLogger() << "\tcrossCall ";
+  }
+  LogInfo::MapleLogger() << "\tpriority " << lr.GetPriority();
+  LogInfo::MapleLogger() << "\tforbidden: ";
+  for (regno_t preg = regInfo->GetInvalidReg(); preg < regInfo->GetAllRegNum(); preg++) {
+    if (lr.GetForbidden(preg)) {
+      LogInfo::MapleLogger() << preg << ",";
+    }
+  }
+  LogInfo::MapleLogger() << "\tcalldef: ";
+  for (regno_t preg = regInfo->GetInvalidReg(); preg < regInfo->GetAllRegNum(); preg++) {
+    if (lr.GetCallDef(preg)) {
+      LogInfo::MapleLogger() << preg << ",";
+    }
+  }
+  LogInfo::MapleLogger() << "\tpregveto: ";
+  for (regno_t preg = regInfo->GetInvalidReg(); preg < regInfo->GetAllRegNum(); preg++) {
+    if (lr.GetPregveto(preg)) {
+      LogInfo::MapleLogger() << preg << ",";
+    }
+  }
+  if (lr.IsSpilled()) {
+    LogInfo::MapleLogger() << " spilled";
+  }
+  if (lr.GetSplitLr()) {
+    LogInfo::MapleLogger() << " split";
+  }
+  LogInfo::MapleLogger() << "\top: " << kOpcodeInfo.GetName(lr.GetOp());
+  LogInfo::MapleLogger() << "\n";
+  PrintLiveBBBit(lr);
+  PrintLiveRangeConflicts(lr);
+  PrintLiveUnitMap(lr);
+  if (lr.GetSplitLr()) {
+    PrintLiveRange(*lr.GetSplitLr(), "===>Split LR");
+  }
+}
+
+void GraphColorRegAllocator::PrintLiveRanges() const {
+  LogInfo::MapleLogger() << "PrintLiveRanges: size = " << lrMap.size() << "\n";
+  for (auto it : lrMap) {
+    PrintLiveRange(*it.second, "");
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void GraphColorRegAllocator::PrintLocalRAInfo(const std::string &str) const {
+  LogInfo::MapleLogger() << str << "\n";
+  for (uint32 id = 0; id < cgFunc->NumBBs(); ++id) {
+    LocalRaInfo *lraInfo = localRegVec[id];
+    if (lraInfo == nullptr) {
+      continue;
+    }
+    LogInfo::MapleLogger() << "bb " << id << " def ";
+    for (const auto &defCntPair : lraInfo->GetDefCnt()) {
+      LogInfo::MapleLogger() << "[" << defCntPair.first << ":" << defCntPair.second << "],";
+    }
+    LogInfo::MapleLogger() << "\n";
+    LogInfo::MapleLogger() << "use ";
+    for (const auto &useCntPair : lraInfo->GetUseCnt()) {
+      LogInfo::MapleLogger() << "[" << useCntPair.first << ":" << useCntPair.second << "],";
+    }
+    LogInfo::MapleLogger() << "\n";
+  }
+}
+
+void GraphColorRegAllocator::PrintBBAssignInfo() const {
+  for (size_t id = 0; id < bfs->sortedBBs.size(); ++id) {
+    uint32 bbID = bfs->sortedBBs[id]->GetId();
+    BBAssignInfo *bbInfo = bbRegInfo[bbID];
+    if (bbInfo == nullptr) {
+      continue;
+    }
+    LogInfo::MapleLogger() << "BBinfo(" << id << ")";
+    LogInfo::MapleLogger() << " lra-needed " << bbInfo->GetLocalRegsNeeded();
+    LogInfo::MapleLogger() << " greg-used ";
+    for (regno_t regNO = regInfo->GetInvalidReg(); regNO < regInfo->GetAllRegNum(); ++regNO) {
+      if (bbInfo->GetGlobalsAssigned(regNO)) {
+        LogInfo::MapleLogger() << regNO << ",";
+      }
+    }
+    LogInfo::MapleLogger() << "\n";
+  }
+}
+
+void GraphColorRegAllocator::CalculatePriority(LiveRange &lr) const {
+#ifdef RANDOM_PRIORITY
+  unsigned long seed = 0;
+  size_t size = sizeof(seed);
+  std::ifstream randomNum("/dev/random", std::ios::in | std::ios::binary);
+  if (randomNum) {
+    randomNum.read(reinterpret_cast<char*>(&seed), size);
+    if (randomNum) {
+      lr.SetPriority(1 / (seed + 1));
+    }
+    randomNum.close();
+  } else {
+    std::cerr << "Failed to open /dev/urandom" << '\n';
+  }
+  return;
+#endif  /* RANDOM_PRIORITY */
+  float pri = 0.0;
+  uint32 bbNum = 0;
+  uint32 numDefs = 0;
+  uint32 numUses = 0;
+  CG *cg = cgFunc->GetCG();
+  bool isSpSave = false;
+
+  if (cgFunc->GetCG()->IsLmbc()) {
+    lr.SetRematLevel(kRematOff);
+    regno_t spSaveReg = cgFunc->GetSpSaveReg();
+    if (spSaveReg && lr.GetRegNO() == spSaveReg) {
+      /*  For lmbc, %fp and %sp are frame pointer and stack pointer respectively, unlike
+       *  non-lmbc where %fp and %sp can be of the same.
+       *  With alloca() potentially changing %sp, lmbc creates another register to act
+       *  as %sp before alloca().  This register cannot be spilled as it is used to
+       *  generate spill/fill instructions.
+       */
+      isSpSave = true;
+    }
+  } else {
+    if (cg->GetRematLevel() >= kRematConst && lr.IsRematerializable(*cgFunc, kRematConst)) {
+      lr.SetRematLevel(kRematConst);
+    } else if (cg->GetRematLevel() >= kRematAddr && lr.IsRematerializable(*cgFunc, kRematAddr)) {
+      lr.SetRematLevel(kRematAddr);
+    } else if (cg->GetRematLevel() >= kRematDreadLocal &&
+        lr.IsRematerializable(*cgFunc, kRematDreadLocal)) {
+      lr.SetRematLevel(kRematDreadLocal);
+    } else if (cg->GetRematLevel() >= kRematDreadGlobal &&
+        lr.IsRematerializable(*cgFunc, kRematDreadGlobal)) {
+      lr.SetRematLevel(kRematDreadGlobal);
+    }
+  }
+
+  auto calculatePriorityFunc = [&lr, &bbNum, &numDefs, &numUses, &pri, this] (uint32 bbID) {
+    auto lu = lr.FindInLuMap(bbID);
+    ASSERT(lu != lr.EndOfLuMap(), "can not find live unit");
+    BB *bb = bbVec[bbID];
+    if (bb->GetFirstInsn() != nullptr && !bb->IsSoloGoto()) {
+      ++bbNum;
+      numDefs += lu->second->GetDefNum();
+      numUses += lu->second->GetUseNum();
+      uint32 useCnt = lu->second->GetDefNum() + lu->second->GetUseNum();
+      uint32 mult;
+#ifdef USE_BB_FREQUENCY
+      mult = bb->GetFrequency();
+#else   /* USE_BB_FREQUENCY */
+      if (bb->GetLoop() != nullptr) {
+        uint32 loopFactor;
+        if (lr.GetNumCall() > 0 && lr.GetRematLevel() == kRematOff) {
+          loopFactor = bb->GetLoop()->GetLoopLevel() * kAdjustWeight;
+        } else {
+          loopFactor = bb->GetLoop()->GetLoopLevel() / kAdjustWeight;
+        }
+        mult = static_cast<uint32>(pow(kLoopWeight, loopFactor));
+      } else {
+        mult = 1;
+      }
+#endif  /* USE_BB_FREQUENCY */
+      pri += useCnt * mult;
+    }
+  };
+  ForEachBBArrElem(lr.GetBBMember(), calculatePriorityFunc);
+
+  if (lr.GetRematLevel() == kRematAddr || lr.GetRematLevel() == kRematConst) {
+    if (numDefs <= 1 && numUses <= 1) {
+      pri = -0xFFFF;
+    } else {
+      pri /= kRematWeight;
+    }
+  } else if (lr.GetRematLevel() == kRematDreadLocal) {
+    pri /= 4;
+  } else if (lr.GetRematLevel() == kRematDreadGlobal) {
+    pri /= 2;
+  }
+
+  lr.SetPriority(pri);
+  lr.SetNumDefs(numDefs);
+  lr.SetNumUses(numUses);
+  if (isSpSave) {
+    lr.SetPriority(MAXFLOAT);
+    lr.SetIsSpSave();
+    return;
+  }
+  if (lr.GetPriority() > 0 && numDefs <= kPriorityDefThreashold && numUses <= kPriorityUseThreashold &&
+      cgFunc->NumBBs() > kPriorityBBThreashold &&
+      (static_cast<float>(lr.GetNumBBMembers()) / cgFunc->NumBBs()) > kPriorityRatioThreashold) {
+    /* for large functions, delay allocating long LR with few defs and uses */
+    lr.SetPriority(0.0);
+  }
+}
+
+void GraphColorRegAllocator::PrintBBs() const {
+  for (auto *bb : bfs->sortedBBs) {
+    LogInfo::MapleLogger() << "\n< === > ";
+    LogInfo::MapleLogger() << bb->GetId();
+    LogInfo::MapleLogger() << " succs:";
+    for (auto *succBB : bb->GetSuccs()) {
+      LogInfo::MapleLogger() << " " << succBB->GetId();
+    }
+    LogInfo::MapleLogger() << " eh_succs:";
+    for (auto *succBB : bb->GetEhSuccs()) {
+      LogInfo::MapleLogger() << " " << succBB->GetId();
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void GraphColorRegAllocator::InitFreeRegPool() {
+  /*
+   *  ==== int regs ====
+   *  FP 29, LR 30, SP 31, 0 to 7 parameters
+
+   *  MapleCG defines 32 as ZR (zero register)
+   *  use 8 if callee does not return large struct ? No
+   *  16 and 17 are intra-procedure call temp, can be caller saved
+   *  18 is platform reg, still use it
+   */
+  uint32 intNum = 0;
+  uint32 fpNum = 0;
+  for (regno_t regNO : regInfo->GetAllRegs()) {
+    if (!regInfo->IsAvailableReg(regNO)) {
+      continue;
+    }
+
+    /*
+     * Because of the try-catch scenario in JAVALANG,
+     * we should use specialized spill register to prevent register changes when exceptions occur.
+     */
+    if (JAVALANG && regInfo->IsSpillRegInRA(regNO, needExtraSpillReg)) {
+      if (regInfo->IsGPRegister(regNO)) {
+        /* Preset int spill registers */
+        (void)intSpillRegSet.insert(regNO);
+      } else {
+        /* Preset float spill registers */
+        (void)fpSpillRegSet.insert(regNO);
+      }
+      continue;
+    }
+
+#ifdef RESERVED_REGS
+    if (regInfo->IsReservedReg(regNO, doMultiPass)) {
+      continue;
+    }
+#endif  /* RESERVED_REGS */
+
+    if (regInfo->IsGPRegister(regNO)) {
+      /* when yieldpoint is enabled, x19 is reserved. */
+      if (regInfo->IsYieldPointReg(regNO)) {
+        continue;
+      }
+      if (regInfo->IsCalleeSavedReg(regNO)) {
+        (void)intCalleeRegSet.insert(regNO);
+      } else {
+        (void)intCallerRegSet.insert(regNO);
+      }
+      ++intNum;
+    } else {
+      if (regInfo->IsCalleeSavedReg(regNO)) {
+        (void)fpCalleeRegSet.insert(regNO);
+      } else {
+        (void)fpCallerRegSet.insert(regNO);
+      }
+      ++fpNum;
+    }
+  }
+  intRegNum = intNum;
+  fpRegNum = fpNum;
+}
+
+/*
+ *  Based on live analysis, the live-in and live-out set determines
+ *  the bit to be set in the LR vector, which is of size #BBs.
+ *  If a vreg is in the live-in and live-out set, it is live in the BB.
+ *
+ *  Also keep track if a LR crosses a call.  If a LR crosses a call, it
+ *  interferes with all caller saved registers.  Add all caller registers
+ *  to the LR's forbidden list.
+ *
+ *  Return created LiveRange object
+ *
+ *  maybe need extra info:
+ *  Add info for setjmp.
+ *  Add info for defBB, useBB, index in BB for def and use
+ *  Add info for startingBB and endingBB
+ */
+LiveRange *GraphColorRegAllocator::NewLiveRange() {
+  LiveRange *lr = memPool->New<LiveRange>(regInfo->GetAllRegNum(), alloc);
+
+  if (bbBuckets == 0) {
+    bbBuckets = (cgFunc->NumBBs() / kU64) + 1;
+  }
+  lr->SetBBBuckets(bbBuckets);
+  lr->InitBBMember(*memPool, bbBuckets);
+  if (regBuckets == 0) {
+    regBuckets = (cgFunc->GetMaxRegNum() / kU64) + 1;
+  }
+  lr->SetRegBuckets(regBuckets);
+  lr->InitBBConflict(*memPool, regBuckets);
+  lr->InitPregveto();
+  lr->InitForbidden();
+  lr->SetRematerializer(cgFunc->GetCG()->CreateRematerializer(*memPool));
+  return lr;
+}
+
+/* Create local info for LR.  return true if reg is not local. */
+bool GraphColorRegAllocator::CreateLiveRangeHandleLocal(regno_t regNO, const BB &bb, bool isDef) {
+  if (FindIn(bb.GetLiveInRegNO(), regNO) || FindIn(bb.GetLiveOutRegNO(), regNO)) {
+    return true;
+  }
+  /*
+   *  register not in globals for the bb, so it is local.
+   *  Compute local RA info.
+   */
+  LocalRaInfo *lraInfo = localRegVec[bb.GetId()];
+  if (lraInfo == nullptr) {
+    lraInfo = memPool->New<LocalRaInfo>(alloc);
+    localRegVec[bb.GetId()] = lraInfo;
+  }
+  if (isDef) {
+    /* movk is handled by different id for use/def in the same insn. */
+    lraInfo->SetDefCntElem(regNO, lraInfo->GetDefCntElem(regNO) + 1);
+  } else {
+    lraInfo->SetUseCntElem(regNO, lraInfo->GetUseCntElem(regNO) + 1);
+  }
+  /* lr info is useful for lra, so continue lr info */
+  return false;
+}
+
+LiveRange *GraphColorRegAllocator::CreateLiveRangeAllocateAndUpdate(regno_t regNO, const BB &bb, bool isDef,
+                                                                    uint32 currId) {
+  LiveRange *lr = GetLiveRange(regNO);
+  if (lr == nullptr) {
+    lr = NewLiveRange();
+    lr->SetID(currId);
+
+    LiveUnit *lu = memPool->New<LiveUnit>();
+    lr->SetElemToLuMap(bb.GetId(), *lu);
+    lu->SetBegin(currId);
+    lu->SetEnd(currId);
+    if (isDef) {
+      /* means no use after def for reg, chances for ebo opt */
+      for (const auto &pregNO : pregLive) {
+        lr->InsertElemToPregveto(pregNO);
+      }
+    }
+  } else {
+    LiveUnit *lu = lr->GetLiveUnitFromLuMap(bb.GetId());
+    if (lu == nullptr) {
+      lu = memPool->New<LiveUnit>();
+      lr->SetElemToLuMap(bb.GetId(), *lu);
+      lu->SetBegin(currId);
+      lu->SetEnd(currId);
+    }
+    if (lu->GetBegin() > currId) {
+      lu->SetBegin(currId);
+    }
+  }
+
+  if (CLANG) {
+    MIRPreg *preg = cgFunc->GetPseudoRegFromVirtualRegNO(regNO, CGOptions::DoCGSSA());
+    if (preg) {
+      switch (preg->GetOp()) {
+        case OP_constval:
+          lr->SetRematerializable(preg->rematInfo.mirConst);
+          break;
+        case OP_addrof:
+        case OP_dread:
+          lr->SetRematerializable(preg->GetOp(), preg->rematInfo.sym,
+                                  preg->fieldID, preg->addrUpper);
+          break;
+        case OP_undef:
+          break;
+        default:
+          ASSERT(false, "Unexpected op in Preg");
+      }
+    }
+  }
+
+  return lr;
+}
+
+void GraphColorRegAllocator::CreateLiveRange(regno_t regNO, const BB &bb, bool isDef, uint32 currId, bool updateCount) {
+  bool isNonLocal = CreateLiveRangeHandleLocal(regNO, bb, isDef);
+
+  if (!isDef) {
+    --currId;
+  }
+
+  LiveRange *lr = CreateLiveRangeAllocateAndUpdate(regNO, bb, isDef, currId);
+  lr->SetRegNO(regNO);
+  lr->SetIsNonLocal(isNonLocal);
+  if (isDef) {
+    (void)vregLive.erase(regNO);
+#ifdef OPTIMIZE_FOR_PROLOG
+    if (doOptProlog && updateCount) {
+      if (lr->GetNumDefs() == 0) {
+        lr->SetFrequency(lr->GetFrequency() + bb.GetFrequency());
+      }
+      lr->IncNumDefs();
+    }
+#endif  /* OPTIMIZE_FOR_PROLOG */
+  } else {
+    (void)vregLive.insert(regNO);
+#ifdef OPTIMIZE_FOR_PROLOG
+    if (doOptProlog && updateCount) {
+      if (lr->GetNumUses() == 0) {
+        lr->SetFrequency(lr->GetFrequency() + bb.GetFrequency());
+      }
+      lr->IncNumUses();
+    }
+#endif  /* OPTIMIZE_FOR_PROLOG */
+  }
+  for (const auto &pregNO : pregLive) {
+    lr->InsertElemToPregveto(pregNO);
+  }
+
+  /* only handle it in live_in and def point? */
+  uint32 bbID = bb.GetId();
+  lr->SetMemberBitArrElem(bbID);
+
+  lrMap[regNO] = lr;
+}
+
+bool GraphColorRegAllocator::SetupLiveRangeByOpHandlePhysicalReg(const RegOperand &regOpnd, Insn &insn,
+                                                                 regno_t regNO, bool isDef) {
+  if (!regOpnd.IsPhysicalRegister()) {
+    return false;
+  }
+  LocalRaInfo *lraInfo = localRegVec[insn.GetBB()->GetId()];
+  if (lraInfo == nullptr) {
+    lraInfo = memPool->New<LocalRaInfo>(alloc);
+    localRegVec[insn.GetBB()->GetId()] = lraInfo;
+  }
+
+  if (isDef) {
+    if (FindNotIn(pregLive, regNO)) {
+      for (const auto &vRegNO : vregLive) {
+        if (regInfo->IsUnconcernedReg(vRegNO)) {
+          continue;
+        }
+        lrMap[vRegNO]->InsertElemToPregveto(regNO);
+      }
+    }
+    pregLive.erase(regNO);
+    if (lraInfo != nullptr) {
+      lraInfo->SetDefCntElem(regNO, lraInfo->GetDefCntElem(regNO) + 1);
+    }
+  } else {
+    (void)pregLive.insert(regNO);
+    for (const auto &vregNO : vregLive) {
+      if (regInfo->IsUnconcernedReg(vregNO)) {
+        continue;
+      }
+      LiveRange *lr = lrMap[vregNO];
+      lr->InsertElemToPregveto(regNO);
+    }
+
+    if (lraInfo != nullptr) {
+      lraInfo->SetUseCntElem(regNO, lraInfo->GetUseCntElem(regNO) + 1);
+    }
+  }
+  return true;
+}
+
+/*
+ *  add pregs to forbidden list of lr. If preg is in
+ *  the live list, then it is forbidden for other vreg on the list.
+ */
+void GraphColorRegAllocator::SetupLiveRangeByOp(Operand &op, Insn &insn, bool isDef, uint32 &numUses) {
+  if (!op.IsRegister()) {
+    return;
+  }
+  auto &regOpnd = static_cast<RegOperand&>(op);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  if (regInfo->IsUnconcernedReg(regOpnd)) {
+    if (GetLiveRange(regNO) != nullptr) {
+      ASSERT(false, "Unconcerned reg");
+      lrMap.erase(regNO);
+    }
+    return;
+  }
+  if (SetupLiveRangeByOpHandlePhysicalReg(regOpnd, insn, regNO, isDef)) {
+    return;
+  }
+
+  CreateLiveRange(regNO, *insn.GetBB(), isDef, insn.GetId(), true);
+
+  LiveRange *lr = GetLiveRange(regNO);
+  ASSERT(lr != nullptr, "lr should not be nullptr");
+  if (isDef) {
+    lr->SetSpillSize((regOpnd.GetSize() <= k32BitSize) ? k32BitSize : k64BitSize);
+  }
+  if (lr->GetRegType() == kRegTyUndef) {
+    lr->SetRegType(regOpnd.GetRegisterType());
+  }
+  if (isDef) {
+    lr->GetLiveUnitFromLuMap(insn.GetBB()->GetId())->IncDefNum();
+    lr->AddRef(insn.GetBB()->GetId(), insn.GetId(), kIsDef);
+  } else {
+    lr->GetLiveUnitFromLuMap(insn.GetBB()->GetId())->IncUseNum();
+    lr->AddRef(insn.GetBB()->GetId(), insn.GetId(), kIsUse);
+    ++numUses;
+  }
+#ifdef MOVE_COALESCE
+  if (insn.IsIntRegisterMov()) {
+    RegOperand &opnd1 = static_cast<RegOperand&>(insn.GetOperand(1));
+    if (!regInfo->IsVirtualRegister(opnd1.GetRegisterNumber()) &&
+        !regInfo->IsUnconcernedReg(opnd1)) {
+      lr->InsertElemToPrefs(opnd1.GetRegisterNumber());
+    }
+    RegOperand &opnd0 = static_cast<RegOperand&>(insn.GetOperand(0));
+    if (!regInfo->IsVirtualRegister(opnd0.GetRegisterNumber())) {
+      lr->InsertElemToPrefs(opnd0.GetRegisterNumber());
+    }
+  }
+#endif  /*  MOVE_COALESCE */
+  if (!insn.IsSpecialIntrinsic() && insn.GetBothDefUseOpnd() != kInsnMaxOpnd) {
+    lr->SetDefUse();
+  }
+}
+
+/* handle live range for bb->live_out */
+void GraphColorRegAllocator::SetupLiveRangeByRegNO(regno_t liveOut, BB &bb, uint32 currPoint) {
+  if (regInfo->IsUnconcernedReg(liveOut)) {
+    return;
+  }
+  if (regInfo->IsVirtualRegister(liveOut)) {
+    (void)vregLive.insert(liveOut);
+    CreateLiveRange(liveOut, bb, false, currPoint, false);
+    return;
+  }
+
+  (void)pregLive.insert(liveOut);
+  for (const auto &vregNO : vregLive) {
+    LiveRange *lr = lrMap[vregNO];
+    lr->InsertElemToPregveto(liveOut);
+  }
+
+  /* See if phys reg is livein also. Then assume it span the entire bb. */
+  if (!FindIn(bb.GetLiveInRegNO(), liveOut)) {
+    return;
+  }
+  LocalRaInfo *lraInfo = localRegVec[bb.GetId()];
+  if (lraInfo == nullptr) {
+    lraInfo = memPool->New<LocalRaInfo>(alloc);
+    localRegVec[bb.GetId()] = lraInfo;
+  }
+  /* Make it a large enough so no locals can be allocated. */
+  lraInfo->SetUseCntElem(liveOut, kMaxUint16);
+}
+
+void GraphColorRegAllocator::ClassifyOperand(std::unordered_set<regno_t> &pregs, std::unordered_set<regno_t> &vregs,
+                                             const Operand &opnd) const {
+  if (!opnd.IsRegister()) {
+    return;
+  }
+  auto &regOpnd = static_cast<const RegOperand&>(opnd);
+  regno_t regNO = regOpnd.GetRegisterNumber();
+  if (regInfo->IsUnconcernedReg(regNO)) {
+    return;
+  }
+  if (regOpnd.IsPhysicalRegister()) {
+    (void)pregs.insert(regNO);
+  } else {
+    (void)vregs.insert(regNO);
+  }
+}
+
+void GraphColorRegAllocator::SetOpndConflict(const Insn &insn, bool onlyDef) {
+  uint32 opndNum = insn.GetOperandSize();
+  if (opndNum <= 1) {
+    return;
+  }
+  const InsnDesc *md = insn.GetDesc();
+  std::unordered_set<regno_t> pregs;
+  std::unordered_set<regno_t> vregs;
+
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    if (!onlyDef) {
+      if (opnd.IsList()) {
+        auto &listOpnd = static_cast<const ListOperand&>(opnd);
+        for (auto &op : listOpnd.GetOperands()) {
+          ClassifyOperand(pregs, vregs, *op);
+        }
+      } else if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        Operand *base = memOpnd.GetBaseRegister();
+        Operand *offset = memOpnd.GetIndexRegister();
+        if (base != nullptr) {
+          ClassifyOperand(pregs, vregs, *base);
+        }
+        if (offset != nullptr) {
+          ClassifyOperand(pregs, vregs, *offset);
+        }
+      } else if (opnd.IsRegister()) {
+        ClassifyOperand(pregs, vregs, opnd);
+      }
+    } else {
+      if (md->GetOpndDes(i)->IsRegDef()) {
+        ClassifyOperand(pregs, vregs, opnd);
+      }
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        Operand *base = memOpnd.GetBaseRegister();
+        if (base != nullptr && !memOpnd.IsIntactIndexed()) {
+          ClassifyOperand(pregs, vregs, *base);
+        }
+      }
+    }
+  }
+
+  if (vregs.empty()) {
+    return;
+  }
+  /* Set BBConflict and Pregveto */
+  for (regno_t vregNO : vregs) {
+    for (regno_t conflictVregNO : vregs) {
+      if (conflictVregNO != vregNO) {
+        lrMap[vregNO]->SetConflictBitArrElem(conflictVregNO);
+      }
+    }
+    for (regno_t conflictPregNO : pregs) {
+      lrMap[vregNO]->InsertElemToPregveto(conflictPregNO);
+    }
+  }
+}
+
+void GraphColorRegAllocator::UpdateOpndConflict(const Insn &insn, bool multiDef) {
+  /* if IsSpecialIntrinsic or IsAtomicStore, set conflicts for all opnds */
+  if (insn.IsAtomicStore() || insn.IsSpecialIntrinsic()) {
+    SetOpndConflict(insn, false);
+    return;
+  }
+  if (multiDef) {
+    SetOpndConflict(insn, true);
+  }
+}
+
+void GraphColorRegAllocator::ComputeLiveRangesForEachDefOperand(Insn &insn, bool &multiDef) {
+  uint32 numDefs = 0;
+  uint32 numUses = 0;
+  const InsnDesc *md = insn.GetDesc();
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    if (insn.IsAsmInsn() && (i == kAsmOutputListOpnd || i == kAsmClobberListOpnd)) {
+      for (auto &opnd : static_cast<const ListOperand&>(insn.GetOperand(i)).GetOperands()) {
+        SetupLiveRangeByOp(*opnd, insn, true, numUses);
+        ++numDefs;
+      }
+      continue;
+    }
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      if (!memOpnd.IsIntactIndexed()) {
+        SetupLiveRangeByOp(opnd, insn, true, numUses);
+        ++numDefs;
+      }
+    }
+    if (!md->GetOpndDes(i)->IsRegDef()) {
+      continue;
+    }
+    SetupLiveRangeByOp(opnd, insn, true, numUses);
+    ++numDefs;
+  }
+  ASSERT(numUses == 0, "should only be def opnd");
+  if (numDefs > 1) {
+    multiDef = true;
+    needExtraSpillReg = true;
+  }
+}
+
+void GraphColorRegAllocator::ComputeLiveRangesForEachUseOperand(Insn &insn) {
+  uint32 numUses = 0;
+  const InsnDesc *md = insn.GetDesc();
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    if (insn.IsAsmInsn() && i == kAsmInputListOpnd) {
+      for (auto &opnd : static_cast<const ListOperand&>(insn.GetOperand(i)).GetOperands()) {
+        SetupLiveRangeByOp(*opnd, insn, false, numUses);
+      }
+      continue;
+    }
+    if (md->GetOpndDes(i)->IsRegDef() && !md->GetOpndDes(i)->IsRegUse()) {
+      continue;
+    }
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsList()) {
+      auto &listOpnd = static_cast<ListOperand&>(opnd);
+      for (auto &op : listOpnd.GetOperands()) {
+        SetupLiveRangeByOp(*op, insn, false, numUses);
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      Operand *base = memOpnd.GetBaseRegister();
+      Operand *offset = memOpnd.GetIndexRegister();
+      if (base != nullptr) {
+        SetupLiveRangeByOp(*base, insn, false, numUses);
+      }
+      if (offset != nullptr) {
+        SetupLiveRangeByOp(*offset, insn, false, numUses);
+      }
+    } else {
+      SetupLiveRangeByOp(opnd, insn, false, numUses);
+    }
+  }
+  if (numUses >= regInfo->GetNormalUseOperandNum()) {
+    needExtraSpillReg = true;
+  }
+}
+
+void GraphColorRegAllocator::ComputeLiveRangesUpdateIfInsnIsCall(const Insn &insn) {
+  if (!insn.IsCall()) {
+    return;
+  }
+  /* def the return value */
+  for (uint32 i = 0; i < regInfo->GetIntRetRegsNum(); ++i) {
+    pregLive.erase(regInfo->GetIntRetReg(i));
+  }
+  for (uint32 i = 0; i < regInfo->GetFloatRegsParmsNum(); ++i) {
+    pregLive.erase(regInfo->GetFpRetReg(i));
+  }
+
+  /* active the parametes */
+  Operand &opnd1 = insn.GetOperand(1);
+  if (opnd1.IsList()) {
+    auto &srcOpnds = static_cast<const ListOperand&>(opnd1);
+    for (auto &regOpnd : srcOpnds.GetOperands()) {
+      ASSERT(!regOpnd->IsVirtualRegister(), "not be a virtual register");
+      auto physicalReg = regOpnd->GetRegisterNumber();
+      (void)pregLive.insert(physicalReg);
+    }
+  }
+}
+
+void GraphColorRegAllocator::ComputeLiveRangesUpdateLiveUnitInsnRange(BB &bb, uint32 currPoint) {
+  for (auto lin : bb.GetLiveInRegNO()) {
+    if (!regInfo->IsVirtualRegister(lin)) {
+      continue;
+    }
+    LiveRange *lr = GetLiveRange(lin);
+    if (lr == nullptr) {
+      continue;
+    }
+    auto lu = lr->FindInLuMap(bb.GetId());
+    ASSERT(lu != lr->EndOfLuMap(), "container empty check");
+    if (bb.GetFirstInsn()) {
+      lu->second->SetBegin(bb.GetFirstInsn()->GetId());
+    } else {
+      /* since bb is empty, then use pointer as is */
+      lu->second->SetBegin(currPoint);
+    }
+    lu->second->SetBegin(lu->second->GetBegin() - 1);
+  }
+}
+
+bool GraphColorRegAllocator::UpdateInsnCntAndSkipUseless(Insn &insn, uint32 &currPoint) const {
+  insn.SetId(currPoint);
+  if (insn.IsImmaterialInsn() || !insn.IsMachineInstruction()) {
+    --currPoint;
+    return true;
+  }
+  return false;
+}
+
+void GraphColorRegAllocator::UpdateCallInfo(uint32 bbId, uint32 currPoint, const Insn &insn) {
+  auto *targetOpnd = insn.GetCallTargetOperand();
+  CHECK_FATAL(targetOpnd != nullptr, "target is null in Insn::IsCallToFunctionThatNeverReturns");
+  if (CGOptions::DoIPARA() && targetOpnd->IsFuncNameOpnd()) {
+    FuncNameOperand *target = static_cast<FuncNameOperand*>(targetOpnd);
+    const MIRSymbol *funcSt = target->GetFunctionSymbol();
+    ASSERT(funcSt->GetSKind() == kStFunc, "funcst must be a function name symbol");
+    MIRFunction *func = funcSt->GetFunction();
+    if (func != nullptr && func->IsReferedRegsValid()) {
+      for (auto preg : func->GetReferedRegs()) {
+        if (!regInfo->IsCalleeSavedReg(preg)) {
+          for (auto vregNO : vregLive) {
+            LiveRange *lr = lrMap[vregNO];
+            lr->InsertElemToCallDef(preg);
+          }
+        }
+      }
+    } else {
+      for (auto vregNO : vregLive) {
+        LiveRange *lr = lrMap[vregNO];
+        lr->SetCrossCall();
+      }
+    }
+  } else {
+    for (auto vregNO : vregLive) {
+      LiveRange *lr = lrMap[vregNO];
+      lr->SetCrossCall();
+    }
+  }
+  for (auto vregNO : vregLive) {
+    LiveRange *lr = lrMap[vregNO];
+    lr->IncNumCall();
+    lr->AddRef(bbId, currPoint, kIsCall);
+
+    MapleMap<uint32, LiveUnit*>::const_iterator lu = lr->FindInLuMap(bbId);
+    if (lu != lr->EndOfLuMap()) {
+      lu->second->SetHasCall(true);
+    }
+  }
+}
+
+void GraphColorRegAllocator::SetLrMustAssign(const RegOperand *regOpnd) {
+  regno_t regNO = regOpnd->GetRegisterNumber();
+  LiveRange *lr = GetLiveRange(regNO);
+  if (lr != nullptr) {
+    lr->SetMustAssigned();
+    lr->SetIsNonLocal(true);
+  }
+}
+
+void GraphColorRegAllocator::SetupMustAssignedLiveRanges(const Insn &insn) {
+  if (!insn.IsSpecialIntrinsic()) {
+    return;
+  }
+  if (insn.IsAsmInsn()) {
+    for (auto &regOpnd : static_cast<const ListOperand &>(insn.GetOperand(kAsmOutputListOpnd)).GetOperands()) {
+      SetLrMustAssign(regOpnd);
+    }
+    for (auto &regOpnd : static_cast<const ListOperand &>(insn.GetOperand(kAsmInputListOpnd)).GetOperands()) {
+      SetLrMustAssign(regOpnd);
+    }
+    return;
+  }
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand *opnd = &insn.GetOperand(i);
+    if (!opnd->IsRegister()) {
+      continue;
+    }
+    auto regOpnd = static_cast<RegOperand *>(opnd);
+    SetLrMustAssign(regOpnd);
+  }
+}
+
+/*
+ *  For each succ bb->GetSuccs(), if bb->liveout - succ->livein is not empty, the vreg(s) is
+ *  dead on this path (but alive on the other path as there is some use of it on the
+ *  other path).  This might be useful for optimization of reload placement later for
+ *  splits (lr split into lr1 & lr2 and lr2 will need to reload.)
+ *  Not for now though.
+ */
+void GraphColorRegAllocator::ComputeLiveRanges() {
+  bbVec.clear();
+  bbVec.resize(cgFunc->NumBBs());
+
+  auto currPoint =
+      static_cast<uint32>(cgFunc->GetTotalNumberOfInstructions() + bfs->sortedBBs.size());
+  /* distinguish use/def */
+  CHECK_FATAL(currPoint < (INT_MAX >> 2), "integer overflow check");
+  currPoint = currPoint << 2;
+  for (size_t bbIdx = bfs->sortedBBs.size(); bbIdx > 0; --bbIdx) {
+    BB *bb = bfs->sortedBBs[bbIdx - 1];
+    bbVec[bb->GetId()] = bb;
+    bb->SetLevel(bbIdx - 1);
+
+    pregLive.clear();
+    vregLive.clear();
+    for (auto liveOut : bb->GetLiveOutRegNO()) {
+      SetupLiveRangeByRegNO(liveOut, *bb, currPoint);
+    }
+    --currPoint;
+
+    if (bb->GetLastInsn() != nullptr && bb->GetLastInsn()->IsMachineInstruction() && bb->GetLastInsn()->IsCall()) {
+      UpdateCallInfo(bb->GetId(), currPoint, *bb->GetLastInsn());
+    }
+
+    FOR_BB_INSNS_REV_SAFE(insn, bb, ninsn) {
+#ifdef MOVE_COALESCE
+      if (insn->IsIntRegisterMov() &&
+          (regInfo->IsVirtualRegister(static_cast<RegOperand&>(
+              insn->GetOperand(0)).GetRegisterNumber())) &&
+          (static_cast<RegOperand&>(insn->GetOperand(0)).GetRegisterNumber() ==
+              static_cast<RegOperand&>(insn->GetOperand(1)).GetRegisterNumber())) {
+        bb->RemoveInsn(*insn);
+        continue;
+      }
+#endif
+      if (UpdateInsnCntAndSkipUseless(*insn, currPoint)) {
+        if (ninsn && ninsn->IsMachineInstruction() && ninsn->IsCall()) {
+          UpdateCallInfo(bb->GetId(), currPoint, *ninsn);
+        }
+        continue;
+      }
+
+      bool multiDef = false;
+      ComputeLiveRangesForEachDefOperand(*insn, multiDef);
+      ComputeLiveRangesForEachUseOperand(*insn);
+
+      UpdateOpndConflict(*insn, multiDef);
+      SetupMustAssignedLiveRanges(*insn);
+
+      if (ninsn  && ninsn->IsMachineInstruction() && ninsn->IsCall()) {
+        UpdateCallInfo(bb->GetId(), currPoint - kInsnStep, *ninsn);
+      }
+
+      ComputeLiveRangesUpdateIfInsnIsCall(*insn);
+      /* distinguish use/def */
+      currPoint -= 2;
+    }
+    ComputeLiveRangesUpdateLiveUnitInsnRange(*bb, currPoint);
+    /* move one more step for each BB */
+    --currPoint;
+  }
+
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << "After ComputeLiveRanges\n";
+    PrintLiveRanges();
+#ifdef USE_LRA
+    if (doLRA) {
+      PrintLocalRAInfo("After ComputeLiveRanges");
+    }
+#endif  /* USE_LRA */
+  }
+}
+
+/* Create a common stack space for spilling with need_spill */
+MemOperand *GraphColorRegAllocator::CreateSpillMem(uint32 spillIdx, SpillMemCheck check) {
+  if (spillIdx >= spillMemOpnds.size()) {
+    return nullptr;
+  }
+
+  if (operandSpilled[spillIdx]) {
+    /* For this insn, spill slot already used, need to find next available slot. */
+    uint32 i;
+    for (i = spillIdx + 1; i < kSpillMemOpndNum; ++i) {
+      if (!operandSpilled[i]) {
+        break;
+      }
+    }
+    CHECK_FATAL(i < kSpillMemOpndNum, "no more available spill mem slot");
+    spillIdx = i;
+  }
+  if (check == kSpillMemPost) {
+    operandSpilled[spillIdx] = true;
+  }
+
+  if (spillMemOpnds[spillIdx] == nullptr) {
+    regno_t reg = cgFunc->NewVReg(kRegTyInt, sizeof(int64));
+    spillMemOpnds[spillIdx] = cgFunc->GetOrCreatSpillMem(reg);
+  }
+  return spillMemOpnds[spillIdx];
+}
+
+bool GraphColorRegAllocator::IsLocalReg(regno_t regNO) const {
+  LiveRange *lr = GetLiveRange(regNO);
+  if (lr == nullptr) {
+    LogInfo::MapleLogger() << "unexpected regNO" << regNO;
+    return true;
+  }
+  return IsLocalReg(*lr);
+}
+
+bool GraphColorRegAllocator::IsLocalReg(const LiveRange &lr) const {
+  return !lr.GetSplitLr() && (lr.GetNumBBMembers() == 1) && !lr.IsNonLocal();
+}
+
+bool GraphColorRegAllocator::CheckOverlap(uint64 val, uint32 i, LiveRange &lr1, LiveRange &lr2) const {
+  regno_t lr1RegNO = lr1.GetRegNO();
+  regno_t lr2RegNO = lr2.GetRegNO();
+  for (uint32 x = 0; x < kU64; ++x) {
+    if ((val & (1ULL << x)) != 0) {
+      uint32 lastBitSet = i * kU64 + x;
+      /*
+       * begin and end should be in the bb info (LU)
+       * Need to rethink this if.
+       * Under some circumstance, lr->begin can occur after lr->end.
+       */
+      auto lu1 = lr1.FindInLuMap(lastBitSet);
+      auto lu2 = lr2.FindInLuMap(lastBitSet);
+      if (lu1 != lr1.EndOfLuMap() && lu2 != lr2.EndOfLuMap() &&
+          !((lu1->second->GetBegin() < lu2->second->GetBegin() && lu1->second->GetEnd() < lu2->second->GetBegin()) ||
+            (lu2->second->GetBegin() < lu1->second->GetEnd() && lu2->second->GetEnd() < lu1->second->GetBegin()))) {
+        lr1.SetConflictBitArrElem(lr2RegNO);
+        lr2.SetConflictBitArrElem(lr1RegNO);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void GraphColorRegAllocator::CheckInterference(LiveRange &lr1, LiveRange &lr2) const {
+  uint64 bitArr[bbBuckets];
+  for (uint32 i = 0; i < bbBuckets; ++i) {
+    bitArr[i] = lr1.GetBBMember()[i] & lr2.GetBBMember()[i];
+  }
+
+  for (uint32 i = 0; i < bbBuckets; ++i) {
+    uint64 val = bitArr[i];
+    if (val == 0) {
+      continue;
+    }
+    if (CheckOverlap(val, i, lr1, lr2)) {
+      break;
+    }
+  }
+}
+
+void GraphColorRegAllocator::BuildInterferenceGraphSeparateIntFp(std::vector<LiveRange*> &intLrVec,
+                                                                 std::vector<LiveRange*> &fpLrVec) {
+  for (auto &it : std::as_const(lrMap)) {
+    LiveRange *lr = it.second;
+    if (lr->GetRegNO() == 0) {
+      continue;
+    }
+#ifdef USE_LRA
+    if (doLRA && IsLocalReg(*lr)) {
+      continue;
+    }
+#endif  /* USE_LRA */
+    if (lr->GetRegType() == kRegTyInt) {
+      intLrVec.emplace_back(lr);
+    } else if (lr->GetRegType() == kRegTyFloat) {
+      fpLrVec.emplace_back(lr);
+    } else {
+      ASSERT(false, "Illegal regType in BuildInterferenceGraph");
+      LogInfo::MapleLogger() << "error: Illegal regType in BuildInterferenceGraph\n";
+    }
+  }
+}
+
+/*
+ *  Based on intersection of LRs.  When two LRs interfere, add to each other's
+ *  interference list.
+ */
+void GraphColorRegAllocator::BuildInterferenceGraph() {
+  std::vector<LiveRange*> intLrVec;
+  std::vector<LiveRange*> fpLrVec;
+  BuildInterferenceGraphSeparateIntFp(intLrVec, fpLrVec);
+
+  /*
+   * Once number of BB becomes larger for big functions, the checking for interferences
+   * takes significant long time. Taking advantage of unique bucket is one of strategies
+   * to avoid unnecessary computation
+   */
+  auto lrSize = intLrVec.size();
+  std::vector<int32> uniqueBucketIdx(lrSize);
+  for (uint32 i = 0; i < lrSize; i++) {
+    uint32 count = 0;
+    uint32 uniqueIdx;
+    LiveRange *lr =  intLrVec[i];
+    for (uint32 j = 0; j < bbBuckets; ++j) {
+      if (lr->GetBBMember()[j] > 0) {
+        count++;
+        uniqueIdx = j;
+      }
+    }
+    if (count == 1) {
+      uniqueBucketIdx[i] = static_cast<int32>(uniqueIdx);
+    } else {
+      /* LR spans multiple buckets */
+      ASSERT(count >= 1, "A live range can not be empty");
+      uniqueBucketIdx[i] = -1;
+    }
+  }
+
+  for (auto it1 = intLrVec.begin(); it1 != intLrVec.end(); ++it1) {
+    LiveRange *lr1 = *it1;
+    CalculatePriority(*lr1);
+    int32 lr1UniqueBucketIdx = uniqueBucketIdx[static_cast<uint64>(std::distance(intLrVec.begin(), it1))];
+    for (auto it2 = it1 + 1; it2 != intLrVec.end(); ++it2) {
+      LiveRange *lr2 = *it2;
+      if (lr1->GetRegNO() < lr2->GetRegNO()) {
+        int32 lr2UniqueBucketIdx = uniqueBucketIdx[static_cast<uint64>(std::distance(intLrVec.begin(), it2))];
+        if (lr1UniqueBucketIdx == -1 && lr2UniqueBucketIdx == -1) {
+          CheckInterference(*lr1, *lr2);
+        } else if (((lr1UniqueBucketIdx >= 0) && ((lr1->GetBBMember()[lr1UniqueBucketIdx] &
+            lr2->GetBBMember()[lr1UniqueBucketIdx])) > 0) || ((lr2UniqueBucketIdx >= 0) &&
+            ((lr1->GetBBMember()[lr2UniqueBucketIdx] & lr2->GetBBMember()[lr2UniqueBucketIdx]) > 0))) {
+          CheckInterference(*lr1, *lr2);
+        }
+      }
+    }
+  }
+
+  // Might need to do same as to intLrVec
+  for (auto it1 = fpLrVec.begin(); it1 != fpLrVec.end(); ++it1) {
+    LiveRange *lr1 = *it1;
+    CalculatePriority(*lr1);
+    for (auto it2 = it1 + 1; it2 != fpLrVec.end(); ++it2) {
+      LiveRange *lr2 = *it2;
+      if (lr1->GetRegNO() < lr2->GetRegNO()) {
+        CheckInterference(*lr1, *lr2);
+      }
+    }
+  }
+
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << "After BuildInterferenceGraph\n";
+    PrintLiveRanges();
+  }
+}
+
+void GraphColorRegAllocator::SetBBInfoGlobalAssigned(uint32 bbID, regno_t regNO) {
+  ASSERT(bbID < bbRegInfo.size(), "index out of range in GraphColorRegAllocator::SetBBInfoGlobalAssigned");
+  BBAssignInfo *bbInfo = bbRegInfo[bbID];
+  if (bbInfo == nullptr) {
+    bbInfo = memPool->New<BBAssignInfo>(regInfo->GetAllRegNum(), alloc);
+    bbRegInfo[bbID] = bbInfo;
+    bbInfo->InitGlobalAssigned();
+  }
+  bbInfo->InsertElemToGlobalsAssigned(regNO);
+}
+
+bool GraphColorRegAllocator::HaveAvailableColor(const LiveRange &lr, uint32 num) const {
+  return ((lr.GetRegType() == kRegTyInt && num < intRegNum) || (lr.GetRegType() == kRegTyFloat && num < fpRegNum));
+}
+
+/*
+ * If the members on the interference list is less than #colors, then
+ * it can be trivially assigned a register.  Otherwise it is constrained.
+ * Separate the LR based on if it is contrained or not.
+ *
+ * The unconstrained LRs are colored last.
+ *
+ * Compute a sorted list of constrained LRs based on priority cost.
+ */
+void GraphColorRegAllocator::Separate() {
+  for (auto &it : std::as_const(lrMap)) {
+    LiveRange *lr = it.second;
+#ifdef USE_LRA
+    if (doLRA && IsLocalReg(*lr)) {
+      continue;
+    }
+#endif  /* USE_LRA */
+#ifdef OPTIMIZE_FOR_PROLOG
+    if (doOptProlog && ((lr->GetNumDefs() <= 1) && (lr->GetNumUses() <= 1) && (lr->GetNumCall() > 0)) &&
+        (lr->GetFrequency() <= (cgFunc->GetFirstBB()->GetFrequency() << 1))) {
+      if (lr->GetRegType() == kRegTyInt) {
+        intDelayed.emplace_back(lr);
+      } else {
+        fpDelayed.emplace_back(lr);
+      }
+      continue;
+    }
+#endif  /* OPTIMIZE_FOR_PROLOG */
+    if (lr->GetRematLevel() != kRematOff) {
+      unconstrained.emplace_back(lr);
+    } else if (HaveAvailableColor(*lr, lr->GetNumBBConflicts() + static_cast<uint32>(lr->GetPregvetoSize()) +
+        static_cast<uint32>(lr->GetForbiddenSize()))) {
+      if (lr->GetPrefs().size() > 0) {
+        unconstrainedPref.emplace_back(lr);
+      } else {
+        unconstrained.emplace_back(lr);
+      }
+    } else if (lr->IsMustAssigned()) {
+      mustAssigned.emplace_back(lr);
+    } else {
+      if ((lr->GetPrefs().size() > 0) && lr->GetNumCall() == 0) {
+        unconstrainedPref.emplace_back(lr);
+      } else {
+        constrained.emplace_back(lr);
+      }
+    }
+  }
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << "Unconstrained : ";
+    for (auto lr : unconstrainedPref) {
+      LogInfo::MapleLogger() << lr->GetRegNO() << " ";
+    }
+    for (auto lr : unconstrained) {
+      LogInfo::MapleLogger() << lr->GetRegNO() << " ";
+    }
+    LogInfo::MapleLogger() << "\n";
+    LogInfo::MapleLogger() << "Constrained : ";
+    for (auto lr : constrained) {
+      LogInfo::MapleLogger() << lr->GetRegNO() << " ";
+    }
+    LogInfo::MapleLogger() << "\n";
+    LogInfo::MapleLogger() << "mustAssigned : ";
+    for (auto lr : mustAssigned) {
+      LogInfo::MapleLogger() << lr->GetRegNO() << " ";
+    }
+    LogInfo::MapleLogger() << "\n";
+  }
+}
+
+MapleVector<LiveRange*>::iterator GraphColorRegAllocator::GetHighPriorityLr(MapleVector<LiveRange*> &lrSet) const {
+  auto it = lrSet.begin();
+  auto highestIt = it;
+  LiveRange *startLr = *it;
+  float maxPrio = startLr->GetPriority();
+  ++it;
+  for (; it != lrSet.end(); ++it) {
+    LiveRange *lr = *it;
+    if (lr->GetPriority() > maxPrio) {
+      maxPrio = lr->GetPriority();
+      highestIt = it;
+    }
+  }
+  return highestIt;
+}
+
+void GraphColorRegAllocator::UpdateForbiddenForNeighbors(const LiveRange &lr) const {
+  auto updateForbidden = [&lr, this] (regno_t regNO) {
+    LiveRange *newLr = GetLiveRange(regNO);
+    ASSERT(newLr != nullptr, "newLr should not be nullptr");
+    if (!newLr->GetPregveto(lr.GetAssignedRegNO())) {
+      newLr->InsertElemToForbidden(lr.GetAssignedRegNO());
+    }
+  };
+  ForEachRegArrElem(lr.GetBBConflict(), updateForbidden);
+}
+
+void GraphColorRegAllocator::UpdatePregvetoForNeighbors(const LiveRange &lr) const {
+  auto updatePregveto = [&lr, this] (regno_t regNO) {
+    LiveRange *newLr = GetLiveRange(regNO);
+    ASSERT(newLr != nullptr, "newLr should not be nullptr");
+    newLr->InsertElemToPregveto(lr.GetAssignedRegNO());
+    newLr->EraseElemFromForbidden(lr.GetAssignedRegNO());
+  };
+  ForEachRegArrElem(lr.GetBBConflict(), updatePregveto);
+}
+
+/*
+ *  For cases with only one def/use and crosses a call.
+ *  It might be more beneficial to spill vs save/restore in prolog/epilog.
+ *  But if the callee register is already used, then it is ok to reuse it again.
+ *  Or in certain cases, just use the callee.
+ */
+bool GraphColorRegAllocator::ShouldUseCallee(LiveRange &lr, const MapleSet<regno_t> &calleeUsed,
+                                             const MapleVector<LiveRange*> &delayed) const {
+  if (FindIn(calleeUsed, lr.GetAssignedRegNO())) {
+    return true;
+  }
+  if (regInfo->IsCalleeSavedReg(lr.GetAssignedRegNO()) &&
+      (calleeUsed.size() % kDivide2) != 0) {
+    return true;
+  }
+  if (delayed.size() > 1 && calleeUsed.empty()) {
+    /* If there are more than 1 vreg that can benefit from callee, use callee */
+    return true;
+  }
+  lr.SetAssignedRegNO(0);
+  return false;
+}
+
+void GraphColorRegAllocator::AddCalleeUsed(regno_t regNO, RegType regType) {
+  ASSERT(!regInfo->IsVirtualRegister(regNO), "regNO should be physical register");
+  bool isCalleeReg = regInfo->IsCalleeSavedReg(regNO);
+  if (isCalleeReg) {
+    if (regType == kRegTyInt) {
+      (void)intCalleeUsed.insert(regNO);
+    } else {
+      (void)fpCalleeUsed.insert(regNO);
+    }
+  }
+}
+
+regno_t GraphColorRegAllocator::FindColorForLr(const LiveRange &lr) const {
+  RegType regType = lr.GetRegType();
+  const MapleSet<uint32> *currRegSet = nullptr;
+  const MapleSet<uint32> *nextRegSet = nullptr;
+  if (regType == kRegTyInt) {
+    if (lr.GetNumCall() != 0) {
+      currRegSet = &intCalleeRegSet;
+      nextRegSet = &intCallerRegSet;
+    } else {
+      currRegSet = &intCallerRegSet;
+      nextRegSet = &intCalleeRegSet;
+    }
+  } else {
+    if (lr.GetNumCall() != 0) {
+      currRegSet = &fpCalleeRegSet;
+      nextRegSet = &fpCallerRegSet;
+    } else {
+      currRegSet = &fpCallerRegSet;
+      nextRegSet = &fpCalleeRegSet;
+    }
+  }
+
+#ifdef MOVE_COALESCE
+  if (lr.GetNumCall() == 0 || (lr.GetNumDefs() + lr.GetNumUses() <= 2)) {
+    for (const auto reg : lr.GetPrefs()) {
+      if ((FindIn(*currRegSet, reg) || FindIn(*nextRegSet, reg)) && !lr.GetForbidden(reg) && !lr.GetPregveto(reg)) {
+        return reg;
+      }
+    }
+  }
+#endif  /*  MOVE_COALESCE */
+  for (const auto reg : *currRegSet) {
+    if (!lr.GetForbidden(reg) && !lr.GetPregveto(reg)) {
+      return reg;
+    }
+  }
+  /* Failed to allocate in first choice. Try 2nd choice. */
+  for (const auto reg : *nextRegSet) {
+    if (!lr.GetForbidden(reg) && !lr.GetPregveto(reg)) {
+      return reg;
+    }
+  }
+  ASSERT(false, "Failed to find a register");
+  return 0;
+}
+
+regno_t GraphColorRegAllocator::TryToAssignCallerSave(const LiveRange &lr) const {
+  RegType regType = lr.GetRegType();
+  const MapleSet<uint32> *currRegSet = nullptr;
+  if (regType == kRegTyInt) {
+    currRegSet = &intCallerRegSet;
+  } else {
+    currRegSet = &fpCallerRegSet;
+  }
+
+#ifdef MOVE_COALESCE
+  if (lr.GetNumCall() == 0 || (lr.GetNumDefs() + lr.GetNumUses() <= 2)) {
+    for (const auto reg : lr.GetPrefs()) {
+      if ((FindIn(*currRegSet, reg)) && !lr.GetForbidden(reg) && !lr.GetPregveto(reg) && !lr.GetCallDef(reg)) {
+        return reg;
+      }
+    }
+  }
+#endif  /*  MOVE_COALESCE */
+  for (const auto reg : *currRegSet) {
+    if (!lr.GetForbidden(reg) && !lr.GetPregveto(reg) && !lr.GetCallDef(reg)) {
+      return reg;
+    }
+  }
+  return 0;
+}
+
+/*
+ * If forbidden list has more registers than max of all BB's local reg
+ *  requirement, then LR can be colored.
+ *  Update LR's color if success, return true, else return false.
+ */
+bool GraphColorRegAllocator::AssignColorToLr(LiveRange &lr, bool isDelayed) {
+  if (lr.GetAssignedRegNO() > 0) {
+    /* Already assigned. */
+    return true;
+  }
+  if (!HaveAvailableColor(lr, lr.GetForbiddenSize() + lr.GetPregvetoSize())) {
+    if (GCRA_DUMP) {
+      LogInfo::MapleLogger() << "assigned fail to R" << lr.GetRegNO() << "\n";
+    }
+    return false;
+  }
+  regno_t callerSaveReg = 0;
+  regno_t reg = FindColorForLr(lr);
+  if (lr.GetNumCall() != 0 && !lr.GetCrossCall()) {
+    callerSaveReg = TryToAssignCallerSave(lr);
+    bool prefCaller = regInfo->IsCalleeSavedReg(reg) &&
+                      intCalleeUsed.find(reg) == intCalleeUsed.end() &&
+                      fpCalleeUsed.find(reg) == fpCalleeUsed.end();
+    if (callerSaveReg != 0 && (prefCaller || !regInfo->IsCalleeSavedReg(reg))) {
+      reg = callerSaveReg;
+      lr.SetNumCall(0);
+    }
+  }
+  lr.SetAssignedRegNO(reg);
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << "assigned " << lr.GetAssignedRegNO() << " to R" << lr.GetRegNO() << "\n";
+  }
+  if (lr.GetAssignedRegNO() == 0) {
+    return false;
+  }
+#ifdef OPTIMIZE_FOR_PROLOG
+  if (doOptProlog && isDelayed) {
+    if ((lr.GetRegType() == kRegTyInt && !ShouldUseCallee(lr, intCalleeUsed, intDelayed)) ||
+        (lr.GetRegType() == kRegTyFloat && !ShouldUseCallee(lr, fpCalleeUsed, fpDelayed))) {
+      return false;
+    }
+  }
+#endif  /* OPTIMIZE_FOR_PROLOG */
+
+  AddCalleeUsed(lr.GetAssignedRegNO(), lr.GetRegType());
+
+  UpdateForbiddenForNeighbors(lr);
+  ForEachBBArrElem(lr.GetBBMember(),
+                   [&lr, this](uint32 bbID) { SetBBInfoGlobalAssigned(bbID, lr.GetAssignedRegNO()); });
+  return true;
+}
+
+void GraphColorRegAllocator::PruneLrForSplit(LiveRange &lr, BB &bb, bool remove,
+                                             std::set<CGFuncLoops*, CGFuncLoopCmp> &candidateInLoop,
+                                             std::set<CGFuncLoops*, CGFuncLoopCmp> &defInLoop) {
+  if (bb.GetInternalFlag1() != 0) {
+    /* already visited */
+    return;
+  }
+
+  bb.SetInternalFlag1(true);
+  MapleMap<uint32, LiveUnit*>::const_iterator lu = lr.FindInLuMap(bb.GetId());
+  uint32 defNum = 0;
+  uint32 useNum = 0;
+  if (lu != lr.EndOfLuMap()) {
+    defNum = lu->second->GetDefNum();
+    useNum = lu->second->GetUseNum();
+  }
+
+  if (remove) {
+    /* In removal mode, has not encountered a ref yet. */
+    if (defNum == 0 && useNum == 0) {
+      if (bb.GetLoop() != nullptr && FindIn(candidateInLoop, bb.GetLoop())) {
+        /*
+         * Upward search has found a loop.  Regardless of def/use
+         *  The loop members must be included in the new LR.
+         */
+        remove = false;
+      } else {
+        /* No ref in this bb. mark as potential remove. */
+        bb.SetInternalFlag2(true);
+        return;
+      }
+    } else {
+      /* found a ref, no more removal of bb and preds. */
+      remove = false;
+    }
+  }
+
+  if (bb.GetLoop() != nullptr) {
+    /* With a def in loop, cannot prune that loop */
+    if (defNum > 0) {
+      (void)defInLoop.insert(bb.GetLoop());
+    }
+    /* bb in loop, need to make sure of loop carried dependency */
+    (void)candidateInLoop.insert(bb.GetLoop());
+  }
+  for (auto pred : bb.GetPreds()) {
+    if (FindNotIn(bb.GetLoopPreds(), pred)) {
+      PruneLrForSplit(lr, *pred, remove, candidateInLoop, defInLoop);
+    }
+  }
+  for (auto pred : bb.GetEhPreds()) {
+    if (FindNotIn(bb.GetLoopPreds(), pred)) {
+      PruneLrForSplit(lr, *pred, remove, candidateInLoop, defInLoop);
+    }
+  }
+}
+
+void GraphColorRegAllocator::FindBBSharedInSplit(LiveRange &lr,
+                                                 const std::set<CGFuncLoops*, CGFuncLoopCmp> &candidateInLoop,
+                                                 std::set<CGFuncLoops*, CGFuncLoopCmp> &defInLoop) {
+  /* A loop might be split into two.  Need to see over the entire LR if there is a def in the loop. */
+  auto findBBSharedFunc = [&lr, &candidateInLoop, &defInLoop, this](uint32 bbID) {
+    BB *bb = bbVec[bbID];
+    if (bb->GetLoop() != nullptr && FindIn(candidateInLoop, bb->GetLoop())) {
+      auto lu = lr.FindInLuMap(bb->GetId());
+      if (lu != lr.EndOfLuMap() && lu->second->GetDefNum() > 0) {
+        (void)defInLoop.insert(bb->GetLoop());
+      }
+    }
+  };
+  ForEachBBArrElem(lr.GetBBMember(), findBBSharedFunc);
+}
+
+/*
+ *  Backward traversal of the top part of the split LR.
+ *  Prune the part of the LR that has no downward exposing references.
+ *  Take into account of loops and loop carried dependencies.
+ *  The candidate bb to be removed, if in a loop, store that info.
+ *  If a LR crosses a loop, even if the loop has no def/use, it must
+ *  be included in the new LR.
+ */
+void GraphColorRegAllocator::ComputeBBForNewSplit(LiveRange &newLr, LiveRange &origLr) {
+  /*
+   *  The candidate bb to be removed, if in a loop, store that info.
+   *  If a LR crosses a loop, even if the loop has no def/use, it must
+   *  be included in the new LR.
+   */
+  std::set<CGFuncLoops*, CGFuncLoopCmp> candidateInLoop;
+  /* If a bb has a def and is in a loop, store that info. */
+  std::set<CGFuncLoops*, CGFuncLoopCmp> defInLoop;
+  std::set<BB*, SortedBBCmpFunc> smember;
+  ForEachBBArrElem(newLr.GetBBMember(), [this, &smember](uint32 bbID) { (void)smember.insert(bbVec[bbID]); });
+  for (auto bbIt = smember.crbegin(); bbIt != smember.crend(); ++bbIt) {
+    BB *bb = *bbIt;
+    if (bb->GetInternalFlag1() != 0) {
+      continue;
+    }
+    PruneLrForSplit(newLr, *bb, true, candidateInLoop, defInLoop);
+  }
+  FindBBSharedInSplit(origLr, candidateInLoop, defInLoop);
+  auto pruneTopLr = [this, &newLr, &candidateInLoop, &defInLoop] (uint32 bbID) {
+    BB *bb = bbVec[bbID];
+    if (bb->GetInternalFlag2() != 0) {
+      if (bb->GetLoop() != nullptr && FindIn(candidateInLoop, bb->GetLoop())) {
+        return;
+      }
+      if (bb->GetLoop() != nullptr || FindNotIn(defInLoop, bb->GetLoop())) {
+        /* defInLoop should be a subset of candidateInLoop.  remove. */
+        newLr.UnsetMemberBitArrElem(bbID);
+      }
+    }
+  };
+  ForEachBBArrElem(newLr.GetBBMember(), pruneTopLr); /* prune the top LR. */
+}
+
+bool GraphColorRegAllocator::UseIsUncovered(const BB &bb, const BB &startBB, std::vector<bool> &visitedBB) {
+  CHECK_FATAL(bb.GetId() < visitedBB.size(), "index out of range");
+  visitedBB[bb.GetId()] = true;
+  for (auto pred : bb.GetPreds()) {
+    if (visitedBB[pred->GetId()]) {
+      continue;
+    }
+    if (pred->GetLevel() <= startBB.GetLevel()) {
+      return true;
+    }
+    if (UseIsUncovered(*pred, startBB, visitedBB)) {
+      return true;
+    }
+  }
+  for (auto pred : bb.GetEhPreds()) {
+    if (visitedBB[pred->GetId()]) {
+      continue;
+    }
+    if (pred->GetLevel() <= startBB.GetLevel()) {
+      return true;
+    }
+    if (UseIsUncovered(*pred, startBB, visitedBB)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void GraphColorRegAllocator::FindUseForSplit(LiveRange &lr, SplitBBInfo &bbInfo, bool &remove,
+                                             std::set<CGFuncLoops*, CGFuncLoopCmp> &candidateInLoop,
+                                             std::set<CGFuncLoops*, CGFuncLoopCmp> &defInLoop) {
+  BB *bb = bbInfo.GetCandidateBB();
+  const BB *startBB = bbInfo.GetStartBB();
+  if (bb->GetInternalFlag1() != 0) {
+    /* already visited */
+    return;
+  }
+  for (auto pred : bb->GetPreds()) {
+    if (pred->GetInternalFlag1() == 0) {
+      return;
+    }
+  }
+  for (auto pred : bb->GetEhPreds()) {
+    if (pred->GetInternalFlag1() == 0) {
+      return;
+    }
+  }
+
+  bb->SetInternalFlag1(true);
+  MapleMap<uint32, LiveUnit*>::const_iterator lu = lr.FindInLuMap(bb->GetId());
+  uint32 defNum = 0;
+  uint32 useNum = 0;
+  if (lu != lr.EndOfLuMap()) {
+    defNum = lu->second->GetDefNum();
+    useNum = lu->second->GetUseNum();
+  }
+
+  std::vector<bool> visitedBB(cgFunc->GetAllBBs().size(), false);
+  if (remove) {
+    /* In removal mode, has not encountered a ref yet. */
+    if (defNum == 0 && useNum == 0) {
+      /* No ref in this bb. mark as potential remove. */
+      bb->SetInternalFlag2(true);
+      if (bb->GetLoop() != nullptr) {
+        /* bb in loop, need to make sure of loop carried dependency */
+        (void)candidateInLoop.insert(bb->GetLoop());
+      }
+    } else {
+      /* found a ref, no more removal of bb and preds. */
+      remove = false;
+      /* A potential point for a upward exposing use. (might be a def). */
+      lu->second->SetNeedReload(true);
+    }
+  } else if ((defNum > 0 || useNum > 0) && UseIsUncovered(*bb, *startBB, visitedBB)) {
+    lu->second->SetNeedReload(true);
+  }
+
+  /* With a def in loop, cannot prune that loop */
+  if (bb->GetLoop() != nullptr && defNum > 0) {
+    (void)defInLoop.insert(bb->GetLoop());
+  }
+
+  for (auto succ : bb->GetSuccs()) {
+    if (FindNotIn(bb->GetLoopSuccs(), succ)) {
+      bbInfo.SetCandidateBB(*succ);
+      FindUseForSplit(lr, bbInfo, remove, candidateInLoop, defInLoop);
+    }
+  }
+  for (auto succ : bb->GetEhSuccs()) {
+    if (FindNotIn(bb->GetLoopSuccs(), succ)) {
+      bbInfo.SetCandidateBB(*succ);
+      FindUseForSplit(lr, bbInfo, remove, candidateInLoop, defInLoop);
+    }
+  }
+}
+
+void GraphColorRegAllocator::ClearLrBBFlags(const std::set<BB*, SortedBBCmpFunc> &member) const {
+  for (auto bb : member) {
+    bb->SetInternalFlag1(0);
+    bb->SetInternalFlag2(0);
+    for (auto pred : bb->GetPreds()) {
+      pred->SetInternalFlag1(0);
+      pred->SetInternalFlag2(0);
+    }
+    for (auto pred : bb->GetEhPreds()) {
+      pred->SetInternalFlag1(0);
+      pred->SetInternalFlag2(0);
+    }
+  }
+}
+
+/*
+ *  Downward traversal of the bottom part of the split LR.
+ *  Prune the part of the LR that has no upward exposing references.
+ *  Take into account of loops and loop carried dependencies.
+ */
+void GraphColorRegAllocator::ComputeBBForOldSplit(LiveRange &newLr, LiveRange &origLr) {
+  /* The candidate bb to be removed, if in a loop, store that info. */
+  std::set<CGFuncLoops*, CGFuncLoopCmp> candidateInLoop;
+  /* If a bb has a def and is in a loop, store that info. */
+  std::set<CGFuncLoops*, CGFuncLoopCmp> defInLoop;
+  SplitBBInfo bbInfo;
+  bool remove = true;
+
+  std::set<BB*, SortedBBCmpFunc> smember;
+  ForEachBBArrElem(origLr.GetBBMember(), [this, &smember](uint32 bbID) { (void)smember.insert(bbVec[bbID]); });
+  ClearLrBBFlags(smember);
+  for (auto bb : smember) {
+    if (bb->GetInternalFlag1() != 0) {
+      continue;
+    }
+    for (auto pred : bb->GetPreds()) {
+      pred->SetInternalFlag1(true);
+    }
+    for (auto pred : bb->GetEhPreds()) {
+      pred->SetInternalFlag1(true);
+    }
+    bbInfo.SetCandidateBB(*bb);
+    bbInfo.SetStartBB(*bb);
+    FindUseForSplit(origLr, bbInfo, remove, candidateInLoop, defInLoop);
+  }
+  FindBBSharedInSplit(newLr, candidateInLoop, defInLoop);
+  auto pruneLrFunc = [&origLr, &defInLoop, this](uint32 bbID) {
+    BB *bb = bbVec[bbID];
+    if (bb->GetInternalFlag2() != 0) {
+      if (bb->GetLoop() != nullptr && FindNotIn(defInLoop, bb->GetLoop())) {
+        origLr.UnsetMemberBitArrElem(bbID);
+      }
+    }
+  };
+  ForEachBBArrElem(origLr.GetBBMember(), pruneLrFunc);
+}
+
+/*
+ *  There is at least one available color for this BB from the neighbors
+ *  minus the ones reserved for local allocation.
+ *  bbAdded : The new BB to be added into the split LR if color is available.
+ *  conflictRegs : Reprent the LR before adding the bbAdded.  These are the
+ *                 forbidden regs before adding the new BBs.
+ *  Side effect : Adding the new forbidden regs from bbAdded into
+ *                conflictRegs if the LR can still be colored.
+ */
+bool GraphColorRegAllocator::LrCanBeColored(const LiveRange &lr, const BB &bbAdded,
+                                            std::unordered_set<regno_t> &conflictRegs) {
+  RegType type = lr.GetRegType();
+
+  std::unordered_set<regno_t> newConflict;
+  auto updateConflictFunc = [&bbAdded, &conflictRegs, &newConflict, &lr, this](regno_t regNO) {
+    /* check the real conflict in current bb */
+    LiveRange *conflictLr = lrMap[regNO];
+    /*
+     *  If the bb to be added to the new LR has an actual
+     *  conflict with another LR, and if that LR has already
+     *  assigned a color that is not in the conflictRegs,
+     *  then add it as a newConflict.
+     */
+    if (IsBitArrElemSet(conflictLr->GetBBMember(), bbAdded.GetId())) {
+      regno_t confReg = conflictLr->GetAssignedRegNO();
+      if ((confReg > 0) && FindNotIn(conflictRegs, confReg) && !lr.GetPregveto(confReg)) {
+        (void)newConflict.insert(confReg);
+      }
+    } else if (conflictLr->GetSplitLr() != nullptr &&
+               IsBitArrElemSet(conflictLr->GetSplitLr()->GetBBMember(), bbAdded.GetId())) {
+      /*
+       * The after split LR is split into pieces, and this ensures
+       * the after split color is taken into consideration.
+       */
+      regno_t confReg = conflictLr->GetSplitLr()->GetAssignedRegNO();
+      if ((confReg > 0) && FindNotIn(conflictRegs, confReg) && !lr.GetPregveto(confReg)) {
+        (void)newConflict.insert(confReg);
+      }
+    }
+  };
+  ForEachRegArrElem(lr.GetBBConflict(), updateConflictFunc);
+
+  size_t numRegs = newConflict.size() + lr.GetPregvetoSize() + conflictRegs.size();
+
+  bool canColor = false;
+  if (type == kRegTyInt) {
+    if (numRegs < intRegNum) {
+      canColor = true;
+    }
+  } else if (numRegs < fpRegNum) {
+    canColor = true;
+  }
+
+  if (canColor) {
+    for (auto regNO : newConflict) {
+      (void)conflictRegs.insert(regNO);
+    }
+  }
+
+  /* Update all the registers conflicting when adding thew new bb. */
+  return canColor;
+}
+
+/* Support function for LR split.  Move one BB from LR1 to LR2. */
+void GraphColorRegAllocator::MoveLrBBInfo(LiveRange &oldLr, LiveRange &newLr, BB &bb) const {
+  /* initialize backward traversal flag for the bb pruning phase */
+  bb.SetInternalFlag1(false);
+  /* initialize bb removal marker */
+  bb.SetInternalFlag2(false);
+  /* Insert BB into new LR */
+  uint32 bbID = bb.GetId();
+  newLr.SetMemberBitArrElem(bbID);
+
+  /* Move LU from old LR to new LR */
+  MapleMap<uint32, LiveUnit*>::const_iterator luIt = oldLr.FindInLuMap(bb.GetId());
+  if (luIt != oldLr.EndOfLuMap()) {
+    newLr.SetElemToLuMap(luIt->first, *(luIt->second));
+    oldLr.EraseLuMap(luIt);
+  }
+
+  /* Remove BB from old LR */
+  oldLr.UnsetMemberBitArrElem(bbID);
+}
+
+/* Is the set of loops inside the loop? */
+bool GraphColorRegAllocator::ContainsLoop(const CGFuncLoops &loop,
+                                          const std::set<CGFuncLoops*, CGFuncLoopCmp> &loops) const {
+  for (const CGFuncLoops *lp : loops) {
+    while (lp != nullptr) {
+      if (lp == &loop) {
+        return true;
+      }
+      lp = lp->GetOuterLoop();
+    }
+  }
+  return false;
+}
+
+void GraphColorRegAllocator::GetAllLrMemberLoops(LiveRange &lr, std::set<CGFuncLoops*, CGFuncLoopCmp> &loops) {
+  auto getLrMemberFunc = [&loops, this](uint32 bbID) {
+    BB *bb = bbVec[bbID];
+    CGFuncLoops *loop = bb->GetLoop();
+    if (loop != nullptr) {
+      (void)loops.insert(loop);
+    }
+  };
+  ForEachBBArrElem(lr.GetBBMember(), getLrMemberFunc);
+}
+
+bool GraphColorRegAllocator::SplitLrShouldSplit(LiveRange &lr) {
+  if (lr.GetSplitLr() != nullptr || lr.GetNumBBMembers() == 1) {
+    return false;
+  }
+  /* Need to split within the same hierarchy */
+  uint32 loopID = 0xFFFFFFFF; /* loopID is initialized the maximum value，and then be assigned in function */
+  bool needSplit = true;
+  auto setNeedSplit = [&needSplit, &loopID, this](uint32 bbID) -> bool {
+    BB *bb = bbVec[bbID];
+    if (loopID == 0xFFFFFFFF) {
+      if (bb->GetLoop() != nullptr) {
+        loopID = bb->GetLoop()->GetHeader()->GetId();
+      } else {
+        loopID = 0;
+      }
+    } else if ((bb->GetLoop() != nullptr && bb->GetLoop()->GetHeader()->GetId() != loopID) ||
+        (bb->GetLoop() == nullptr && loopID != 0)) {
+      needSplit = false;
+      return true;
+    }
+    return false;
+  };
+  ForEachBBArrElemWithInterrupt(lr.GetBBMember(), setNeedSplit);
+  return needSplit;
+}
+
+/*
+ * When a BB in the LR has no def or use in it, then potentially
+ * there is no conflict within these BB for the new LR, since
+ * the new LR will need to spill the defs which terminates the
+ * new LR unless there is a use later which extends the new LR.
+ * There is no need to compute conflicting register set unless
+ * there is a def or use.
+ * It is assumed that the new LR is extended to the def or use.
+ * Initially newLr is empty, then add bb if can be colored.
+ * Return true if there is a split.
+ */
+bool GraphColorRegAllocator::SplitLrFindCandidateLr(LiveRange &lr, LiveRange &newLr,
+                                                    std::unordered_set<regno_t> &conflictRegs) {
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << "start split lr for vreg " << lr.GetRegNO() << "\n";
+  }
+  std::set<BB*, SortedBBCmpFunc> smember;
+  ForEachBBArrElem(lr.GetBBMember(), [&smember, this](uint32 bbID) { (void)smember.insert(bbVec[bbID]); });
+  for (auto bb : smember) {
+    if (!LrCanBeColored(lr, *bb, conflictRegs)) {
+      break;
+    }
+    MoveLrBBInfo(lr, newLr, *bb);
+  }
+
+  /* return ture if split is successful */
+  return newLr.GetNumBBMembers() != 0;
+}
+
+void GraphColorRegAllocator::SplitLrHandleLoops(LiveRange &lr, LiveRange &newLr,
+                                                const std::set<CGFuncLoops*, CGFuncLoopCmp> &origLoops,
+                                                const std::set<CGFuncLoops*, CGFuncLoopCmp> &newLoops) {
+  /*
+   * bb in loops might need a reload due to loop carried dependency.
+   * Compute this before pruning the LRs.
+   * if there is no re-definition, then reload is not necessary.
+   * Part of the new LR region after the last reference is
+   * no longer in the LR.  Remove those bb.
+   */
+  ComputeBBForNewSplit(newLr, lr);
+
+  /* With new LR, recompute conflict. */
+  auto recomputeConflict = [&lr, &newLr, this](uint32 bbID) {
+    auto lrFunc = [&newLr, &bbID, this](regno_t regNO) {
+      LiveRange *confLrVec = lrMap[regNO];
+      if (IsBitArrElemSet(confLrVec->GetBBMember(), bbID) ||
+          (confLrVec->GetSplitLr() != nullptr && IsBitArrElemSet(confLrVec->GetSplitLr()->GetBBMember(), bbID))) {
+        /*
+        * New LR getting the interference does not mean the
+        * old LR can remove the interference.
+        * Old LR's interference will be handled at the end of split.
+        */
+        newLr.SetConflictBitArrElem(regNO);
+      }
+    };
+    ForEachRegArrElem(lr.GetBBConflict(), lrFunc);
+  };
+  ForEachBBArrElem(newLr.GetBBMember(), recomputeConflict);
+
+  /* update bb/loop same as for new LR. */
+  ComputeBBForOldSplit(newLr, lr);
+  /* Update the conflict interference for the original LR later. */
+  for (auto loop : newLoops) {
+    if (!ContainsLoop(*loop, origLoops)) {
+      continue;
+    }
+    for (auto bb : loop->GetLoopMembers()) {
+      if (!IsBitArrElemSet(newLr.GetBBMember(), bb->GetId())) {
+        continue;
+      }
+      LiveUnit *lu = newLr.GetLiveUnitFromLuMap(bb->GetId());
+      if (lu->GetUseNum() != 0) {
+        lu->SetNeedReload(true);
+      }
+    }
+  }
+}
+
+void GraphColorRegAllocator::SplitLrFixNewLrCallsAndRlod(LiveRange &newLr,
+                                                         const std::set<CGFuncLoops*, CGFuncLoopCmp> &origLoops) {
+  /* If a 2nd split loop is before the bb in 1st split bb. */
+  newLr.SetNumCall(0);
+  auto fixCallsAndRlod = [&newLr, &origLoops, this](uint32 bbID) {
+    BB *bb = bbVec[bbID];
+    for (auto loop : origLoops) {
+      if (loop->GetHeader()->GetLevel() >= bb->GetLevel()) {
+        continue;
+      }
+      LiveUnit *lu = newLr.GetLiveUnitFromLuMap(bbID);
+      if (lu->GetUseNum() != 0) {
+        lu->SetNeedReload(true);
+      }
+    }
+    LiveUnit *lu = newLr.GetLiveUnitFromLuMap(bbID);
+    if (lu->HasCall()) {
+      newLr.IncNumCall();
+    }
+  };
+  ForEachBBArrElem(newLr.GetBBMember(), fixCallsAndRlod);
+}
+
+void GraphColorRegAllocator::SplitLrFixOrigLrCalls(LiveRange &lr) const {
+  lr.SetNumCall(0);
+  auto fixOrigCalls = [&lr](uint32 bbID) {
+    LiveUnit *lu = lr.GetLiveUnitFromLuMap(bbID);
+    if (lu->HasCall()) {
+      lr.IncNumCall();
+    }
+  };
+  ForEachBBArrElem(lr.GetBBMember(), fixOrigCalls);
+}
+
+void GraphColorRegAllocator::SplitLrUpdateInterference(LiveRange &lr) {
+  /*
+   * newLr is now a separate LR from the original lr.
+   * Update the interference info.
+   * Also recompute the forbidden info
+   */
+  lr.ClearForbidden();
+  auto updateInterfrence = [&lr, this](regno_t regNO) {
+    LiveRange *confLrVec = lrMap[regNO];
+    if (IsBBsetOverlap(lr.GetBBMember(), confLrVec->GetBBMember(), bbBuckets)) {
+      /* interfere */
+      if ((confLrVec->GetAssignedRegNO() > 0) && !lr.GetPregveto(confLrVec->GetAssignedRegNO())) {
+        lr.InsertElemToForbidden(confLrVec->GetAssignedRegNO());
+      }
+    } else {
+      /* no interference */
+      lr.UnsetConflictBitArrElem(regNO);
+    }
+  };
+  ForEachRegArrElem(lr.GetBBConflict(), updateInterfrence);
+}
+
+void GraphColorRegAllocator::SplitLrUpdateRegInfo(const LiveRange &origLr, LiveRange &newLr,
+                                                  std::unordered_set<regno_t> &conflictRegs) const {
+  for (regno_t regNO = regInfo->GetInvalidReg(); regNO < regInfo->GetAllRegNum(); ++regNO) {
+    if (origLr.GetPregveto(regNO)) {
+      newLr.InsertElemToPregveto(regNO);
+    }
+  }
+  for (auto regNO : conflictRegs) {
+    if (!newLr.GetPregveto(regNO)) {
+      newLr.InsertElemToForbidden(regNO);
+    }
+  }
+}
+
+void GraphColorRegAllocator::SplitLrErrorCheckAndDebug(const LiveRange &origLr) const {
+  if (origLr.GetNumBBMembers() == 0) {
+    ASSERT(origLr.GetNumBBConflicts() == 0, "Error: member and conflict not match");
+  }
+}
+
+/*
+ * Pick a starting BB, then expand to maximize the new LR.
+ * Return the new LR.
+ */
+void GraphColorRegAllocator::SplitLr(LiveRange &lr) {
+  if (!SplitLrShouldSplit(lr)) {
+    return;
+  }
+  LiveRange *newLr = NewLiveRange();
+  /*
+   * For the new LR, whenever a BB with either a def or
+   * use is added, then add the registers that the neighbor
+   * is using to the conflict register set indicating that these
+   * registers cannot be used for the new LR's color.
+   */
+  std::unordered_set<regno_t> conflictRegs;
+  if (!SplitLrFindCandidateLr(lr, *newLr, conflictRegs)) {
+    return;
+  }
+#ifdef REUSE_SPILLMEM
+  /* Copy the original conflict vector for spill reuse optimization */
+  lr.SetOldConflict(memPool->NewArray<uint64>(regBuckets));
+  for (uint32 i = 0; i < regBuckets; ++i) {
+    lr.SetBBConflictElem(static_cast<int32>(i), lr.GetBBConflictElem(static_cast<int32>(i)));
+  }
+#endif  /* REUSE_SPILLMEM */
+
+  std::set<CGFuncLoops*, CGFuncLoopCmp> newLoops;
+  std::set<CGFuncLoops*, CGFuncLoopCmp> origLoops;
+  GetAllLrMemberLoops(*newLr, newLoops);
+  GetAllLrMemberLoops(lr, origLoops);
+  SplitLrHandleLoops(lr, *newLr, origLoops, newLoops);
+  SplitLrFixNewLrCallsAndRlod(*newLr, origLoops);
+  SplitLrFixOrigLrCalls(lr);
+
+  SplitLrUpdateRegInfo(lr, *newLr, conflictRegs);
+
+  CalculatePriority(lr);
+  /* At this point, newLr should be unconstrained. */
+  lr.SetSplitLr(*newLr);
+
+  newLr->SetRegNO(lr.GetRegNO());
+  newLr->SetRegType(lr.GetRegType());
+  newLr->SetID(lr.GetID());
+  newLr->CopyRematerialization(lr);
+  CalculatePriority(*newLr);
+  SplitLrUpdateInterference(lr);
+  newLr->SetAssignedRegNO(FindColorForLr(*newLr));
+
+  AddCalleeUsed(newLr->GetAssignedRegNO(), newLr->GetRegType());
+
+  /* For the new LR, update assignment for local RA */
+  ForEachBBArrElem(newLr->GetBBMember(),
+                   [&newLr, this](uint32 bbID) { SetBBInfoGlobalAssigned(bbID, newLr->GetAssignedRegNO()); });
+
+  UpdatePregvetoForNeighbors(*newLr);
+
+  SplitLrErrorCheckAndDebug(lr);
+}
+
+void GraphColorRegAllocator::ColorForOptPrologEpilog() {
+#ifdef OPTIMIZE_FOR_PROLOG
+  if (!doOptProlog) {
+    return;
+  }
+  for (auto lr : intDelayed) {
+    if (!AssignColorToLr(*lr, true)) {
+      lr->SetSpilled(true);
+    }
+  }
+  for (auto lr : fpDelayed) {
+    if (!AssignColorToLr(*lr, true)) {
+      lr->SetSpilled(true);
+    }
+  }
+#endif
+}
+
+/*
+ *  From the sorted list of constrained LRs, pick the most profitable LR.
+ *  Split the LR into LRnew1 LRnew2 where LRnew1 has the maximum number of
+ *  BB and is colorable.
+ *  The starting BB for traversal must have a color available.
+ *
+ *  Assign a color, update neighbor's forbidden list.
+ *
+ *  Update the conflict graph by change the interference list.
+ *  In the case of both LRnew1 and LRnew2 conflicts with a BB, this BB's
+ *  #neightbors increased.  If this BB was unconstrained, must check if
+ *  it is still unconstrained.  Move to constrained if necessary.
+ *
+ *  Color the unconstrained LRs.
+ */
+void GraphColorRegAllocator::SplitAndColorForEachLr(MapleVector<LiveRange*> &targetLrVec) {
+  while (!targetLrVec.empty()) {
+    auto highestIt = GetHighPriorityLr(targetLrVec);
+    LiveRange *lr = *highestIt;
+    /* check those lrs in lr->sconflict which is in unconstrained whether it turns to constrined */
+    if (highestIt != targetLrVec.end()) {
+      targetLrVec.erase(highestIt);
+    } else {
+      ASSERT(false, "Error: not in targetLrVec");
+    }
+    if (AssignColorToLr(*lr)) {
+      continue;
+    }
+#ifdef USE_SPLIT
+    SplitLr(*lr);
+#endif  /* USE_SPLIT */
+    /*
+     * When LR is spilled, it potentially has no conflicts as
+     * each def/use is spilled/reloaded.
+     */
+#ifdef COLOR_SPLIT
+    if (!AssignColorToLr(*lr)) {
+#endif  /* COLOR_SPLIT */
+      lr->SetSpilled(true);
+      hasSpill = true;
+#ifdef COLOR_SPLIT
+    }
+#endif  /* COLOR_SPLIT */
+  }
+}
+
+void GraphColorRegAllocator::SplitAndColor() {
+  /* handle mustAssigned */
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << " starting mustAssigned : \n";
+  }
+  SplitAndColorForEachLr(mustAssigned);
+
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << " starting unconstrainedPref : \n";
+  }
+  /* assign color for unconstained */
+  SplitAndColorForEachLr(unconstrainedPref);
+
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << " starting constrained : \n";
+  }
+  /* handle constrained */
+  SplitAndColorForEachLr(constrained);
+
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << " starting unconstrained : \n";
+  }
+  /* assign color for unconstained */
+  SplitAndColorForEachLr(unconstrained);
+
+#ifdef OPTIMIZE_FOR_PROLOG
+  if (doOptProlog) {
+    ColorForOptPrologEpilog();
+  }
+#endif  /* OPTIMIZE_FOR_PROLOG */
+}
+
+void GraphColorRegAllocator::HandleLocalRegAssignment(regno_t regNO, LocalRegAllocator &localRa, bool isInt) {
+  /* vreg, get a reg for it if not assigned already. */
+  if (!localRa.IsInRegAssigned(regNO) && !localRa.IsInRegSpilled(regNO)) {
+    /* find an available phys reg */
+    bool founded = false;
+    LiveRange *lr = lrMap[regNO];
+    auto &regsSet = regInfo->GetRegsFromType(isInt ? kRegTyInt : kRegTyFloat);
+    regno_t startReg = *regsSet.begin();
+    regno_t endReg = *regsSet.rbegin();
+    for (uint32 preg = startReg; preg <= endReg; ++preg) {
+      if (!localRa.IsPregAvailable(preg)) {
+        continue;
+      }
+      if (lr->GetNumCall() != 0 && !regInfo->IsCalleeSavedReg(preg)) {
+        continue;
+      }
+      if (lr->GetPregveto(preg)) {
+        continue;
+      }
+      regno_t assignedReg = preg;
+      localRa.ClearPregs(assignedReg);
+      localRa.SetPregUsed(assignedReg);
+      localRa.SetRegAssigned(regNO);
+      localRa.SetRegAssignmentMap(regNO, assignedReg);
+      lr->SetAssignedRegNO(assignedReg);
+      founded = true;
+      break;
+    }
+    if (!founded) {
+      localRa.SetRegSpilled(regNO);
+      lr->SetSpilled(true);
+    }
+  }
+}
+
+void GraphColorRegAllocator::UpdateLocalRegDefUseCount(regno_t regNO, LocalRegAllocator &localRa,
+    bool isDef) const {
+  auto usedIt = localRa.GetUseInfo().find(regNO);
+  if (usedIt != localRa.GetUseInfo().end() && !isDef) {
+    /* reg use, decrement count */
+    ASSERT(usedIt->second > 0, "Incorrect local ra info");
+    localRa.SetUseInfoElem(regNO, usedIt->second - 1);
+    if (regInfo->IsVirtualRegister(regNO) && localRa.IsInRegAssigned(regNO)) {
+      localRa.IncUseInfoElem(localRa.GetRegAssignmentItem(regNO));
+    }
+    if (GCRA_DUMP) {
+      LogInfo::MapleLogger() << "\t\treg " << regNO << " update #use to " << localRa.GetUseInfoElem(regNO) << "\n";
+    }
+  }
+
+  auto defIt = localRa.GetDefInfo().find(regNO);
+  if (defIt != localRa.GetDefInfo().end() && isDef) {
+    /* reg def, decrement count */
+    ASSERT(defIt->second > 0, "Incorrect local ra info");
+    localRa.SetDefInfoElem(regNO, defIt->second - 1);
+    if (regInfo->IsVirtualRegister(regNO) && localRa.IsInRegAssigned(regNO)) {
+      localRa.IncDefInfoElem(localRa.GetRegAssignmentItem(regNO));
+    }
+    if (GCRA_DUMP) {
+      LogInfo::MapleLogger() << "\t\treg " << regNO << " update #def to " << localRa.GetDefInfoElem(regNO) << "\n";
+    }
+  }
+}
+
+void GraphColorRegAllocator::UpdateLocalRegConflict(regno_t regNO,
+    const LocalRegAllocator &localRa) {
+  LiveRange *lr = lrMap[regNO];
+  if (lr->GetNumBBConflicts() == 0) {
+    return;
+  }
+  if (!localRa.IsInRegAssigned(regNO)) {
+    return;
+  }
+  regno_t preg = localRa.GetRegAssignmentItem(regNO);
+  ForEachRegArrElem(lr->GetBBConflict(),
+                    [&preg, this](regno_t regNO) { lrMap[regNO]->InsertElemToPregveto(preg); });
+}
+
+void GraphColorRegAllocator::HandleLocalRaDebug(regno_t regNO, const LocalRegAllocator &localRa, bool isInt) const {
+  LogInfo::MapleLogger() << "HandleLocalReg " << regNO << "\n";
+  LogInfo::MapleLogger() << "\tregUsed:";
+  const auto &regUsed = localRa.GetPregUsed();
+
+  auto &regsSet = regInfo->GetRegsFromType(isInt ? kRegTyInt : kRegTyFloat);
+  regno_t regStart = *regsSet.begin();
+  regno_t regEnd = *regsSet.rbegin();
+
+  for (uint32 i = regStart; i <= regEnd; ++i) {
+    if (regUsed[i]) {
+      LogInfo::MapleLogger() << " " << i;
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+  LogInfo::MapleLogger() << "\tregs:";
+  const auto &regs = localRa.GetPregs();
+  for (uint32 regnoInLoop = regStart; regnoInLoop <= regEnd; ++regnoInLoop) {
+    if (regs[regnoInLoop]) {
+      LogInfo::MapleLogger() << " " << regnoInLoop;
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void GraphColorRegAllocator::HandleLocalReg(Operand &op, LocalRegAllocator &localRa, const BBAssignInfo *bbInfo,
+                                            bool isDef, bool isInt) {
+  if (!op.IsRegister()) {
+    return;
+  }
+  auto &regOpnd = static_cast<RegOperand&>(op);
+  regno_t regNO = regOpnd.GetRegisterNumber();
+
+  if (regInfo->IsUnconcernedReg(regOpnd)) {
+    return;
+  }
+
+  /* is this a local register ? */
+  if (regInfo->IsVirtualRegister(regNO) && !IsLocalReg(regNO)) {
+    return;
+  }
+
+  if (GCRA_DUMP) {
+    HandleLocalRaDebug(regNO, localRa, isInt);
+  }
+
+  if (regOpnd.IsPhysicalRegister()) {
+    /* conflict with preg is record in lr->pregveto and BBAssignInfo->globalsAssigned */
+    UpdateLocalRegDefUseCount(regNO, localRa, isDef);
+    /* See if it is needed by global RA */
+    if (localRa.GetUseInfoElem(regNO) == 0 && localRa.GetDefInfoElem(regNO) == 0) {
+      if (bbInfo && !bbInfo->GetGlobalsAssigned(regNO)) {
+        /* This phys reg is now available for assignment for a vreg */
+        localRa.SetPregs(regNO);
+        if (GCRA_DUMP) {
+          LogInfo::MapleLogger() << "\t\tlast ref, phys-reg " << regNO << " now available\n";
+        }
+      }
+    }
+  } else {
+    HandleLocalRegAssignment(regNO, localRa, isInt);
+    UpdateLocalRegDefUseCount(regNO, localRa, isDef);
+    UpdateLocalRegConflict(regNO, localRa);
+    if (localRa.GetUseInfoElem(regNO) == 0 && localRa.GetDefInfoElem(regNO) == 0 &&
+        localRa.IsInRegAssigned(regNO)) {
+      /* last ref of vreg, release assignment */
+      localRa.SetPregs(localRa.GetRegAssignmentItem(regNO));
+      if (GCRA_DUMP) {
+        LogInfo::MapleLogger() << "\t\tlast ref, release reg " <<
+            localRa.GetRegAssignmentItem(regNO) << " for " << regNO << "\n";
+      }
+    }
+  }
+}
+
+void GraphColorRegAllocator::LocalRaRegSetEraseReg(LocalRegAllocator &localRa, regno_t regNO) const {
+  CHECK_FATAL(regInfo->IsAvailableReg(regNO), "regNO should be available");
+  if (localRa.IsPregAvailable(regNO)) {
+    localRa.ClearPregs(regNO);
+  }
+}
+
+bool GraphColorRegAllocator::LocalRaInitRegSet(LocalRegAllocator &localRa, uint32 bbId) {
+  bool needLocalRa = false;
+  localRa.InitPregs(cgFunc->GetCG()->GenYieldPoint(), intSpillRegSet, fpSpillRegSet);
+
+  localRa.ClearUseInfo();
+  localRa.ClearDefInfo();
+  LocalRaInfo *lraInfo = localRegVec[bbId];
+  ASSERT(lraInfo != nullptr, "lraInfo not be nullptr");
+  for (const auto &useCntPair : lraInfo->GetUseCnt()) {
+    regno_t regNO = useCntPair.first;
+    if (regInfo->IsVirtualRegister(regNO)) {
+      needLocalRa = true;
+    }
+    localRa.SetUseInfoElem(useCntPair.first, useCntPair.second);
+  }
+  for (const auto &defCntPair : lraInfo->GetDefCnt()) {
+    regno_t regNO = defCntPair.first;
+    if (regInfo->IsVirtualRegister(regNO)) {
+      needLocalRa = true;
+    }
+    localRa.SetDefInfoElem(defCntPair.first, defCntPair.second);
+  }
+  return needLocalRa;
+}
+
+void GraphColorRegAllocator::LocalRaInitAllocatableRegs(LocalRegAllocator &localRa, uint32 bbId) {
+  BBAssignInfo *bbInfo = bbRegInfo[bbId];
+  if (bbInfo != nullptr) {
+    for (regno_t regNO = regInfo->GetInvalidReg(); regNO < regInfo->GetAllRegNum(); ++regNO) {
+      if (bbInfo->GetGlobalsAssigned(regNO)) {
+        LocalRaRegSetEraseReg(localRa, regNO);
+      }
+    }
+  }
+}
+
+void GraphColorRegAllocator::LocalRaForEachDefOperand(const Insn &insn, LocalRegAllocator &localRa,
+                                                      const BBAssignInfo *bbInfo) {
+  const InsnDesc *md = insn.GetDesc();
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    /* handle def opnd */
+    if (!md->GetOpndDes(i)->IsRegDef()) {
+      continue;
+    }
+    auto &regOpnd = static_cast<RegOperand&>(opnd);
+    bool isInt = (regOpnd.GetRegisterType() == kRegTyInt);
+    HandleLocalReg(opnd, localRa, bbInfo, true, isInt);
+  }
+}
+
+void GraphColorRegAllocator::LocalRaForEachUseOperand(const Insn &insn, LocalRegAllocator &localRa,
+                                                      const BBAssignInfo *bbInfo) {
+  const InsnDesc *md = insn.GetDesc();
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsList()) {
+      continue;
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      Operand *base = memOpnd.GetBaseRegister();
+      Operand *offset = memOpnd.GetIndexRegister();
+      if (base != nullptr) {
+        HandleLocalReg(*base, localRa, bbInfo, false, true);
+      }
+      if (!memOpnd.IsIntactIndexed()) {
+        HandleLocalReg(*base, localRa, bbInfo, true, true);
+      }
+      if (offset != nullptr) {
+        HandleLocalReg(*offset, localRa, bbInfo, false, true);
+      }
+    } else if (md->GetOpndDes(i)->IsRegUse()) {
+      auto &regOpnd = static_cast<RegOperand&>(opnd);
+      bool isInt = (regOpnd.GetRegisterType() == kRegTyInt);
+      HandleLocalReg(opnd, localRa, bbInfo, false, isInt);
+    }
+  }
+}
+
+void GraphColorRegAllocator::LocalRaPrepareBB(BB &bb, LocalRegAllocator &localRa) {
+  BBAssignInfo *bbInfo = bbRegInfo[bb.GetId()];
+  FOR_BB_INSNS(insn, &bb) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+
+    /*
+     * Use reverse operand order, assuming use first then def for allocation.
+     * need to free the use resource so it can be reused for def.
+     */
+    LocalRaForEachUseOperand(*insn, localRa, bbInfo);
+    LocalRaForEachDefOperand(*insn, localRa, bbInfo);
+  }
+}
+
+void GraphColorRegAllocator::LocalRaFinalAssignment(const LocalRegAllocator &localRa,
+                                                    BBAssignInfo &bbInfo) {
+  for (const auto &regAssignmentMapPair : localRa.GetRegAssignmentMap()) {
+    regno_t regNO = regAssignmentMapPair.second;
+    if (GCRA_DUMP) {
+      LogInfo::MapleLogger() << "[" << regAssignmentMapPair.first << "," << regNO << "],";
+    }
+    /* Might need to get rid of this copy. */
+    bbInfo.SetRegMapElem(regAssignmentMapPair.first, regNO);
+    AddCalleeUsed(regNO, regInfo->IsGPRegister(regNO) ? kRegTyInt : kRegTyFloat);
+  }
+}
+
+void GraphColorRegAllocator::LocalRaDebug(const BB &bb, const LocalRegAllocator &localRa) const {
+  LogInfo::MapleLogger() << "bb " << bb.GetId() << " local ra need " <<
+      localRa.GetNumPregUsed() << " regs\n";
+  LogInfo::MapleLogger() << "\tpotential assignments:";
+  for (auto it : localRa.GetRegAssignmentMap()) {
+    LogInfo::MapleLogger() << "[" << it.first << "," << it.second << "],";
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+/*
+ * When do_allocate is false, it is prepass:
+ * Traverse each BB, keep track of the number of registers required
+ * for local registers in the BB.  Communicate this to global RA.
+ *
+ * When do_allocate is true:
+ * Allocate local registers for each BB based on unused registers
+ * from global RA.  Spill if no register available.
+ */
+void GraphColorRegAllocator::LocalRegisterAllocator(bool doAllocate) {
+  if (GCRA_DUMP) {
+    if (doAllocate) {
+      LogInfo::MapleLogger() << "LRA allocation start\n";
+      PrintBBAssignInfo();
+    } else {
+      LogInfo::MapleLogger() << "LRA preprocessing start\n";
+    }
+  }
+  LocalRegAllocator *localRa = memPool->New<LocalRegAllocator>(*cgFunc, alloc);
+  for (auto *bb : bfs->sortedBBs) {
+    uint32 bbID = bb->GetId();
+
+    LocalRaInfo *lraInfo = localRegVec[bb->GetId()];
+    if (lraInfo == nullptr) {
+      /* No locals to allocate */
+      continue;
+    }
+
+    localRa->ClearLocalRaInfo();
+    bool needLocalRa = LocalRaInitRegSet(*localRa, bbID);
+    if (!needLocalRa) {
+      /* Only physical regs in bb, no local ra needed. */
+      continue;
+    }
+
+    if (doAllocate) {
+      LocalRaInitAllocatableRegs(*localRa, bbID);
+    }
+
+    LocalRaPrepareBB(*bb, *localRa);
+
+    BBAssignInfo *bbInfo = bbRegInfo[bb->GetId()];
+    if (bbInfo == nullptr) {
+      bbInfo = memPool->New<BBAssignInfo>(regInfo->GetAllRegNum(), alloc);
+      bbRegInfo[bbID] = bbInfo;
+      bbInfo->InitGlobalAssigned();
+    }
+    bbInfo->SetLocalRegsNeeded(localRa->GetNumPregUsed());
+
+    if (doAllocate) {
+      if (GCRA_DUMP) {
+        LogInfo::MapleLogger() << "\tbb(" << bb->GetId() << ")final local ra assignments:";
+      }
+      LocalRaFinalAssignment(*localRa, *bbInfo);
+      if (GCRA_DUMP) {
+        LogInfo::MapleLogger() << "\n";
+      }
+    } else if (GCRA_DUMP) {
+      LocalRaDebug(*bb, *localRa);
+    }
+  }
+}
+
+MemOperand *GraphColorRegAllocator::GetConsistentReuseMem(const uint64 *conflict,
+                                                          const std::set<MemOperand*> &usedMemOpnd,
+                                                          uint32 size, RegType regType) {
+  std::set<LiveRange*, SetLiveRangeCmpFunc> sconflict;
+  regno_t regNO;
+  for (uint32 i = 0; i < regBuckets; ++i) {
+    for (uint32 b = 0; b < kU64; ++b) {
+      if ((conflict[i] & (1ULL << b)) != 0) {
+        continue;
+      }
+      regNO = i * kU64 + b;
+      if (regNO >= numVregs) {
+        break;
+      }
+      if (GetLiveRange(regNO) != nullptr) {
+        (void)sconflict.insert(lrMap[regNO]);
+      }
+    }
+  }
+
+  for (auto *noConflictLr : sconflict) {
+    if (noConflictLr == nullptr || noConflictLr->GetRegType() != regType || noConflictLr->GetSpillSize() != size) {
+      continue;
+    }
+    if (usedMemOpnd.find(noConflictLr->GetSpillMem()) == usedMemOpnd.end()) {
+      return noConflictLr->GetSpillMem();
+    }
+  }
+  return nullptr;
+}
+
+MemOperand *GraphColorRegAllocator::GetCommonReuseMem(const uint64 *conflict, const std::set<MemOperand*> &usedMemOpnd,
+                                                      uint32 size, RegType regType) {
+  regno_t regNO;
+  for (uint32 i = 0; i < regBuckets; ++i) {
+    for (uint32 b = 0; b < kU64; ++b) {
+      if ((conflict[i] & (1ULL << b)) != 0) {
+        continue;
+      }
+      regNO = i * kU64 + b;
+      if (regNO >= numVregs) {
+        break;
+      }
+      LiveRange *noConflictLr = GetLiveRange(regNO);
+      if (noConflictLr == nullptr || noConflictLr->GetRegType() != regType || noConflictLr->GetSpillSize() != size) {
+        continue;
+      }
+      if (usedMemOpnd.find(noConflictLr->GetSpillMem()) == usedMemOpnd.end()) {
+        return noConflictLr->GetSpillMem();
+      }
+    }
+  }
+  return nullptr;
+}
+
+/* See if any of the non-conflict LR is spilled and use its memOpnd. */
+MemOperand *GraphColorRegAllocator::GetReuseMem(uint32 vregNO, uint32 size, RegType regType) {
+  if (cgFunc->GetMirModule().GetSrcLang() != kSrcLangC) {
+    return nullptr;
+  }
+  if (IsLocalReg(vregNO)) {
+    return nullptr;
+  }
+
+  LiveRange *lr = lrMap[vregNO];
+  const uint64 *conflict;
+  if (lr->GetSplitLr() != nullptr) {
+    /*
+     * For split LR, the vreg liveness is optimized, but for spill location
+     * the stack location needs to be maintained for the entire LR.
+     */
+    return nullptr;
+  } else {
+    conflict = lr->GetBBConflict();
+  }
+
+  std::set<MemOperand*> usedMemOpnd;
+  auto updateMemOpnd = [&usedMemOpnd, this](regno_t regNO) {
+    if (regNO >= numVregs) {
+      return;
+    }
+    LiveRange *lrInner = GetLiveRange(regNO);
+    if (lrInner && lrInner->GetSpillMem() != nullptr) {
+      (void)usedMemOpnd.insert(lrInner->GetSpillMem());
+    }
+  };
+  ForEachRegArrElem(conflict, updateMemOpnd);
+  uint32 regSize = (size <= k32BitSize) ? k32BitSize : k64BitSize;
+  /*
+   * This is to order the search so memOpnd given out is consistent.
+   * When vreg#s do not change going through VtableImpl.mpl file
+   * then this can be simplified.
+   */
+#ifdef CONSISTENT_MEMOPND
+  return GetConsistentReuseMem(conflict, usedMemOpnd, regSize, regType);
+#else   /* CONSISTENT_MEMOPND */
+  return GetCommonReuseMem(conflict, usedMemOpnd, regSize, regType);
+#endif  /* CONSISTENT_MEMOPNDi */
+}
+
+MemOperand *GraphColorRegAllocator::GetSpillMem(uint32 vregNO, bool isDest, Insn &insn,
+    regno_t regNO, bool &isOutOfRange) {
+  MemOperand *memOpnd = cgFunc->GetOrCreatSpillMem(vregNO);
+  if (cgFunc->GetCG()->IsLmbc() && cgFunc->GetSpSaveReg()) {
+    LiveRange *lr = lrMap[cgFunc->GetSpSaveReg()];
+    RegOperand *baseReg = nullptr;
+    if (lr == nullptr) {
+      BB *firstBB = cgFunc->GetFirstBB();
+      FOR_BB_INSNS(bbInsn, firstBB) {
+        if (bbInsn->IsIntRegisterMov() && bbInsn->GetOperand(kInsnSecondOpnd).IsRegister() &&
+            static_cast<RegOperand&>(bbInsn->GetOperand(kInsnSecondOpnd)).GetRegisterNumber() ==
+                regInfo->GetStackPointReg()) {
+          baseReg = static_cast<RegOperand *>(&bbInsn->GetOperand(kInsnFirstOpnd));
+          CHECK_FATAL(baseReg->IsPhysicalRegister(), "Incorrect dest register for SP move");
+          break;
+        }
+      }
+      CHECK_FATAL(baseReg, "Cannot find dest register for SP move");
+    } else {
+      baseReg = &cgFunc->GetOpndBuilder()->CreatePReg(lr->GetAssignedRegNO(),
+          k64BitSize, kRegTyInt);
+    }
+    MemOperand *newmemOpnd = (static_cast<MemOperand*>(memOpnd)->Clone(*cgFunc->GetMemoryPool()));
+    newmemOpnd->SetBaseRegister(*baseReg);
+    return regInfo->AdjustMemOperandIfOffsetOutOfRange(newmemOpnd, vregNO, isDest, insn, regNO,
+        isOutOfRange);
+  }
+  return regInfo->AdjustMemOperandIfOffsetOutOfRange(memOpnd, vregNO, isDest, insn, regNO,
+      isOutOfRange);
+}
+
+void GraphColorRegAllocator::SpillOperandForSpillPre(Insn &insn, const Operand &opnd, RegOperand &phyOpnd,
+                                                     uint32 spillIdx, bool needSpill) {
+  if (!needSpill) {
+    return;
+  }
+  auto &regOpnd = static_cast<const RegOperand&>(opnd);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  LiveRange *lr = lrMap[regNO];
+
+  MemOperand *spillMem = CreateSpillMem(spillIdx, kSpillMemPre);
+  ASSERT(spillMem != nullptr, "spillMem nullptr check");
+
+  uint32 regSize = regOpnd.GetSize();
+  PrimType stype;
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType == kRegTyInt) {
+    stype = (regSize <= k32BitSize) ? PTY_i32 : PTY_i64;
+  } else {
+    stype = (regSize <= k32BitSize) ? PTY_f32 : PTY_f64;
+  }
+  bool isOutOfRange = false;
+  spillMem = regInfo->AdjustMemOperandIfOffsetOutOfRange(spillMem, regOpnd.GetRegisterNumber(),
+      false, insn, regInfo->GetReservedSpillReg(), isOutOfRange);
+  Insn &stInsn = *regInfo->BuildStrInsn(spillMem->GetSize(), stype, phyOpnd, *spillMem);
+  std::string comment = " SPILL for spill vreg: " + std::to_string(regNO) + " op:" +
+                        kOpcodeInfo.GetName(lr->GetOp());
+  stInsn.SetComment(comment);
+  insn.GetBB()->InsertInsnBefore(insn, stInsn);
+}
+
+void GraphColorRegAllocator::SpillOperandForSpillPost(Insn &insn, const Operand &opnd, RegOperand &phyOpnd,
+                                                      uint32 spillIdx, bool needSpill) {
+  if (!needSpill) {
+    return;
+  }
+
+  auto &regOpnd = static_cast<const RegOperand&>(opnd);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  LiveRange *lr = lrMap[regNO];
+  bool isLastInsn = false;
+  if (insn.GetBB()->GetKind() == BB::kBBIf && insn.GetBB()->IsLastInsn(&insn)) {
+    isLastInsn = true;
+  }
+
+  if (lr->GetRematLevel() != kRematOff) {
+    std::string comment = " REMATERIALIZE for spill vreg: " +
+                          std::to_string(regNO);
+    if (isLastInsn) {
+      for (auto tgtBB : insn.GetBB()->GetSuccs()) {
+        std::vector<Insn *> rematInsns = lr->Rematerialize(*cgFunc, phyOpnd);
+        for (auto &&remat : rematInsns) {
+          remat->SetComment(comment);
+          tgtBB->InsertInsnBegin(*remat);
+        }
+      }
+    } else {
+      std::vector<Insn *> rematInsns = lr->Rematerialize(*cgFunc, phyOpnd);
+      for (auto &&remat : rematInsns) {
+        remat->SetComment(comment);
+        insn.GetBB()->InsertInsnAfter(insn, *remat);
+      }
+    }
+    return;
+  }
+
+  MemOperand *spillMem = CreateSpillMem(spillIdx, kSpillMemPost);
+  ASSERT(spillMem != nullptr, "spillMem nullptr check");
+
+  uint32 regSize = regOpnd.GetSize();
+  PrimType stype;
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType == kRegTyInt) {
+    stype = (regSize <= k32BitSize) ? PTY_i32 : PTY_i64;
+  } else {
+    stype = (regSize <= k32BitSize) ? PTY_f32 : PTY_f64;
+  }
+
+  bool isOutOfRange = false;
+  Insn *nextInsn = insn.GetNextMachineInsn();
+  spillMem = regInfo->AdjustMemOperandIfOffsetOutOfRange(spillMem, regOpnd.GetRegisterNumber(),
+      true, insn, regInfo->GetReservedSpillReg(), isOutOfRange);
+  std::string comment = " RELOAD for spill vreg: " + std::to_string(regNO) +
+                        " op:" + kOpcodeInfo.GetName(lr->GetOp());
+  if (isLastInsn) {
+    for (auto tgtBB : insn.GetBB()->GetSuccs()) {
+      Insn *newLd = regInfo->BuildLdrInsn(spillMem->GetSize(), stype, phyOpnd, *spillMem);
+      newLd->SetComment(comment);
+      tgtBB->InsertInsnBegin(*newLd);
+    }
+  } else {
+    Insn *ldrInsn = regInfo->BuildLdrInsn(spillMem->GetSize(), stype, phyOpnd, *spillMem);
+    ldrInsn->SetComment(comment);
+    if (isOutOfRange) {
+      if (nextInsn == nullptr) {
+        insn.GetBB()->AppendInsn(*ldrInsn);
+      } else {
+        insn.GetBB()->InsertInsnBefore(*nextInsn, *ldrInsn);
+      }
+    } else {
+      insn.GetBB()->InsertInsnAfter(insn, *ldrInsn);
+    }
+  }
+}
+
+MemOperand *GraphColorRegAllocator::GetSpillOrReuseMem(LiveRange &lr, uint32 regSize, bool &isOutOfRange, Insn &insn,
+                                                       bool isDef) {
+  MemOperand *memOpnd = nullptr;
+  if (lr.GetSpillMem() != nullptr) {
+    /* the saved memOpnd cannot be out-of-range */
+    memOpnd = lr.GetSpillMem();
+  } else {
+#ifdef REUSE_SPILLMEM
+    memOpnd = GetReuseMem(lr.GetRegNO(), regSize, lr.GetRegType());
+    if (memOpnd != nullptr) {
+      lr.SetSpillMem(*memOpnd);
+      lr.SetSpillSize((regSize <= k32BitSize) ? k32BitSize : k64BitSize);
+    } else {
+#endif  /* REUSE_SPILLMEM */
+      regno_t baseRegNO = 0;
+      if (!isDef) {
+        /* src will use its' spill reg as baseRegister when offset out-of-range
+         * add x16, x29, #max-offset  //out-of-range
+         * ldr x16, [x16, #offset]    //reload
+         * mov xd, x16
+         */
+        baseRegNO = lr.GetSpillReg();
+        if (baseRegNO > *regInfo->GetRegsFromType(kRegTyInt).rbegin()) {
+          baseRegNO = regInfo->GetReservedSpillReg();
+        }
+      } else {
+        /* dest will use R16 as baseRegister when offset out-of-range
+         * mov x16, xs
+         * add x17, x29, #max-offset  //out-of-range
+         * str x16, [x17, #offset]    //spill
+         */
+        baseRegNO = regInfo->GetReservedSpillReg();
+      }
+      ASSERT(baseRegNO != 0, "invalid base register number");
+      memOpnd = GetSpillMem(lr.GetRegNO(), isDef, insn, baseRegNO, isOutOfRange);
+      /* dest's spill reg can only be R15 and R16 () */
+      if (isOutOfRange && isDef) {
+        ASSERT(lr.GetSpillReg() != regInfo->GetReservedSpillReg(),
+            "can not find valid memopnd's base register");
+      }
+#ifdef REUSE_SPILLMEM
+      if (!isOutOfRange) {
+        lr.SetSpillMem(*memOpnd);
+        lr.SetSpillSize((regSize <= k32BitSize) ? k32BitSize : k64BitSize);
+      }
+    }
+#endif  /* REUSE_SPILLMEM */
+  }
+  return memOpnd;
+}
+
+/*
+ * Create spill insn for the operand.
+ * When need_spill is true, need to spill the spill operand register first
+ * then use it for the current spill, then reload it again.
+ */
+Insn *GraphColorRegAllocator::SpillOperand(Insn &insn, const Operand &opnd, bool isDef,
+                                           RegOperand &phyOpnd, bool forCall) {
+  auto &regOpnd = static_cast<const RegOperand&>(opnd);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  uint32 pregNO = phyOpnd.GetRegisterNumber();
+  bool isCalleeReg = regInfo->IsCalleeSavedReg(pregNO);
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << "SpillOperand " << regNO << "\n";
+  }
+  LiveRange *lr = lrMap[regNO];
+  bool isForCallerSave = lr->GetSplitLr() == nullptr && (lr->GetNumCall() > 0) && !isCalleeReg;
+  uint32 regSize = regOpnd.GetSize();
+  bool isOutOfRange = false;
+  PrimType stype;
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType == kRegTyInt) {
+    stype = (regSize <= k32BitSize) ? PTY_i32 : PTY_i64;
+  } else {
+    stype = (regSize <= k32BitSize) ? PTY_f32 : PTY_f64;
+  }
+
+  if (isDef) {
+    Insn *spillDefInsn = nullptr;
+    if (lr->GetRematLevel() == kRematOff) {
+      lr->SetSpillReg(pregNO);
+      Insn *nextInsn = insn.GetNextMachineInsn();
+      MemOperand *memOpnd = GetSpillOrReuseMem(*lr, regSize, isOutOfRange, insn, forCall ? false : true);
+      spillDefInsn = regInfo->BuildStrInsn(regSize, stype, phyOpnd, *memOpnd);
+      spillDefInsn->SetIsSpill();
+      std::string comment = " SPILL vreg: " + std::to_string(regNO) + " op:" +
+                            kOpcodeInfo.GetName(lr->GetOp());
+      if (isForCallerSave) {
+        comment += " for caller save in BB " + std::to_string(insn.GetBB()->GetId());
+      }
+      spillDefInsn->SetComment(comment);
+      if (forCall) {
+        insn.GetBB()->InsertInsnBefore(insn, *spillDefInsn);
+      } else if (isOutOfRange) {
+        if (nextInsn == nullptr) {
+          insn.GetBB()->AppendInsn(*spillDefInsn);
+        } else {
+          insn.GetBB()->InsertInsnBefore(*nextInsn, *spillDefInsn);
+        }
+      } else {
+        insn.GetBB()->InsertInsnAfter(insn, *spillDefInsn);
+      }
+    }
+    return spillDefInsn;
+  }
+  Insn *nextInsn = insn.GetNextMachineInsn();
+  lr->SetSpillReg(pregNO);
+
+  std::vector<Insn *> spillUseInsns;
+  std::string comment;
+  if (lr->GetRematLevel() != kRematOff) {
+    spillUseInsns = lr->Rematerialize(*cgFunc, phyOpnd);
+    comment = " REMATERIALIZE vreg: " + std::to_string(regNO);
+  } else {
+    MemOperand *memOpnd = GetSpillOrReuseMem(*lr, regSize, isOutOfRange, insn,
+                                             forCall ? true : false);
+    Insn &spillUseInsn = *regInfo->BuildLdrInsn(regSize, stype, phyOpnd, *memOpnd);
+    spillUseInsn.SetIsReload();
+    spillUseInsns.push_back(&spillUseInsn);
+    comment = " RELOAD vreg: " + std::to_string(regNO) + " op:" +
+              kOpcodeInfo.GetName(lr->GetOp());
+  }
+  if (isForCallerSave) {
+    comment += " for caller save in BB " + std::to_string(insn.GetBB()->GetId());
+  }
+  for (auto &&spillUseInsn : spillUseInsns) {
+    spillUseInsn->SetComment(comment);
+    if (forCall) {
+      if (nextInsn == nullptr) {
+        insn.GetBB()->AppendInsn(*spillUseInsn);
+      } else {
+        insn.GetBB()->InsertInsnBefore(*nextInsn, *spillUseInsn);
+      }
+    } else {
+      insn.GetBB()->InsertInsnBefore(insn, *spillUseInsn);
+    }
+  }
+  return &insn;
+}
+
+/* Try to find available reg for spill. */
+bool GraphColorRegAllocator::SetAvailableSpillReg(std::unordered_set<regno_t> &cannotUseReg,
+    LiveRange &lr, MapleBitVector &usedRegMask) {
+  bool isInt = (lr.GetRegType() == kRegTyInt);
+  MapleSet<uint32> &callerRegSet = isInt ? intCallerRegSet : fpCallerRegSet;
+  MapleSet<uint32> &calleeRegSet = isInt ? intCalleeRegSet : fpCalleeRegSet;
+
+  for (const auto spillReg : callerRegSet) {
+    if (cannotUseReg.find(spillReg) == cannotUseReg.end() && (!usedRegMask[spillReg])) {
+      lr.SetAssignedRegNO(spillReg);
+      usedRegMask[spillReg] = true;
+      return true;
+    }
+  }
+  for (const auto spillReg : calleeRegSet) {
+    if (cannotUseReg.find(spillReg) == cannotUseReg.end() && (!usedRegMask[spillReg])) {
+      lr.SetAssignedRegNO(spillReg);
+      usedRegMask[spillReg] = true;
+      return true;
+    }
+  }
+  return false;
+}
+
+void GraphColorRegAllocator::CollectCannotUseReg(std::unordered_set<regno_t> &cannotUseReg, const LiveRange &lr,
+                                                 Insn &insn) {
+  /* Find the bb in the conflict LR that actually conflicts with the current bb. */
+  for (regno_t regNO = regInfo->GetInvalidReg(); regNO < regInfo->GetAllRegNum(); ++regNO) {
+    if (lr.GetPregveto(regNO)) {
+      (void)cannotUseReg.insert(regNO);
+    }
+  }
+  auto updateCannotUse = [&insn, &cannotUseReg, this](regno_t regNO) {
+    LiveRange *conflictLr = lrMap[regNO];
+    /*
+     * conflictLr->GetAssignedRegNO() might be zero
+     * caller save will be inserted so the assigned reg can be released actually
+     */
+    if ((conflictLr->GetAssignedRegNO() > 0) && IsBitArrElemSet(conflictLr->GetBBMember(), insn.GetBB()->GetId())) {
+      if (!regInfo->IsCalleeSavedReg(conflictLr->GetAssignedRegNO()) &&
+          (conflictLr->GetNumCall() > 0) && !conflictLr->GetProcessed()) {
+        return;
+      }
+      (void)cannotUseReg.insert(conflictLr->GetAssignedRegNO());
+    }
+  };
+  ForEachRegArrElem(lr.GetBBConflict(), updateCannotUse);
+#ifdef USE_LRA
+  if (!doLRA) {
+    return;
+  }
+  BBAssignInfo *bbInfo = bbRegInfo[insn.GetBB()->GetId()];
+  if (bbInfo != nullptr) {
+    for (const auto &regMapPair : bbInfo->GetRegMap()) {
+      (void)cannotUseReg.insert(regMapPair.second);
+    }
+  }
+#endif  /* USE_LRA */
+}
+
+regno_t GraphColorRegAllocator::PickRegForSpill(MapleBitVector &usedRegMask, RegType regType,
+    uint32 spillIdx, bool &needSpillLr) {
+  bool isIntReg = (regType == kRegTyInt);
+  if (JAVALANG) {
+    /* Use predetermined spill register */
+    MapleSet<uint32> &spillRegSet = isIntReg ? intSpillRegSet : fpSpillRegSet;
+    ASSERT(spillIdx < spillRegSet.size(), "spillIdx large than spillRegSet.size()");
+    auto spillRegIt = spillRegSet.begin();
+    for (; spillIdx > 0; --spillIdx) {
+      ++spillRegIt;
+    }
+    return *spillRegIt;
+  }
+
+  /* Temporary find a unused reg to spill */
+  auto &phyRegSet = regInfo->GetRegsFromType(regType);
+  for (auto iter = phyRegSet.rbegin(); iter != phyRegSet.rend(); ++iter) {
+    auto spillReg = *iter;
+    if (!usedRegMask[spillReg]) {
+      usedRegMask[spillReg] = true;
+      needSpillLr = true;
+      return spillReg;
+    }
+  }
+
+  ASSERT(false, "can not find spillReg");
+  return 0;
+}
+
+/* return true if need extra spill */
+bool GraphColorRegAllocator::SetRegForSpill(LiveRange &lr, Insn &insn, uint32 spillIdx,
+    MapleBitVector &usedRegMask, bool isDef) {
+  std::unordered_set<regno_t> cannotUseReg;
+  /* SPILL COALESCE */
+  if (!isDef && insn.IsIntRegisterMov()) {
+    auto &ropnd = static_cast<RegOperand&>(insn.GetOperand(0));
+    if (ropnd.IsPhysicalRegister()) {
+      lr.SetAssignedRegNO(ropnd.GetRegisterNumber());
+      return false;
+    }
+  }
+
+  CollectCannotUseReg(cannotUseReg, lr, insn);
+
+  if (SetAvailableSpillReg(cannotUseReg, lr, usedRegMask)) {
+    return false;
+  }
+
+  bool needSpillLr = false;
+  if (lr.GetAssignedRegNO() == 0) {
+  /*
+   * All regs are assigned and none are free.
+   * Pick a reg to spill and reuse for this spill.
+   * Need to make sure the reg picked is not assigned to this insn,
+   * else there will be conflict.
+   */
+    RegType regType = lr.GetRegType();
+    regno_t spillReg = PickRegForSpill(usedRegMask, regType, spillIdx, needSpillLr);
+    lr.SetAssignedRegNO(spillReg);
+  }
+  return needSpillLr;
+}
+
+RegOperand *GraphColorRegAllocator::GetReplaceOpndForLRA(Insn &insn, const Operand &opnd,
+    uint32 &spillIdx, MapleBitVector &usedRegMask, bool isDef) {
+  auto &regOpnd = static_cast<const RegOperand&>(opnd);
+  uint32 vregNO = regOpnd.GetRegisterNumber();
+  RegType regType = regOpnd.GetRegisterType();
+  BBAssignInfo *bbInfo = bbRegInfo[insn.GetBB()->GetId()];
+  if (bbInfo == nullptr) {
+    return nullptr;
+  }
+  auto regIt = bbInfo->GetRegMap().find(vregNO);
+  if (regIt != bbInfo->GetRegMap().end()) {
+    RegOperand &phyOpnd = cgFunc->GetOpndBuilder()->CreatePReg(regIt->second,
+        regOpnd.GetSize(), regType);
+    return &phyOpnd;
+  }
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << "spill vreg " << vregNO << "\n";
+  }
+  regno_t spillReg;
+  bool needSpillLr = false;
+  if (insn.IsBranch() || insn.IsCall()) {
+    spillReg = regInfo->GetReservedSpillReg();
+  } else {
+    /*
+     * use the reg that exclude livein/liveout/bbInfo->regMap
+     * Need to make sure the reg picked is not assigned to this insn,
+     * else there will be conflict.
+     */
+    spillReg = PickRegForSpill(usedRegMask, regType, spillIdx, needSpillLr);
+    AddCalleeUsed(spillReg, regType);
+    if (GCRA_DUMP) {
+      LogInfo::MapleLogger() << "\tassigning lra spill reg " << spillReg << "\n";
+    }
+  }
+  RegOperand &phyOpnd = cgFunc->GetOpndBuilder()->CreatePReg(spillReg, regOpnd.GetSize(), regType);
+  SpillOperandForSpillPre(insn, regOpnd, phyOpnd, spillIdx, needSpillLr);
+  Insn *spill = SpillOperand(insn, regOpnd, isDef, phyOpnd);
+  if (spill != nullptr) {
+    SpillOperandForSpillPost(*spill, regOpnd, phyOpnd, spillIdx, needSpillLr);
+  }
+  ++spillIdx;
+  return &phyOpnd;
+}
+
+RegOperand *GraphColorRegAllocator::GetReplaceUseDefOpndForLRA(Insn &insn, const Operand &opnd,
+    uint32 &spillIdx, MapleBitVector &usedRegMask) {
+  auto &regOpnd = static_cast<const RegOperand&>(opnd);
+  uint32 vregNO = regOpnd.GetRegisterNumber();
+  RegType regType = regOpnd.GetRegisterType();
+  BBAssignInfo *bbInfo = bbRegInfo[insn.GetBB()->GetId()];
+  if (bbInfo == nullptr) {
+    return nullptr;
+  }
+  auto regIt = bbInfo->GetRegMap().find(vregNO);
+  if (regIt != bbInfo->GetRegMap().end()) {
+    RegOperand &phyOpnd = cgFunc->GetOpndBuilder()->CreatePReg(regIt->second,
+        regOpnd.GetSize(), regType);
+    return &phyOpnd;
+  }
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << "spill vreg " << vregNO << "\n";
+  }
+  regno_t spillReg;
+  bool needSpillLr = false;
+  if (insn.IsBranch() || insn.IsCall()) {
+    spillReg = regInfo->GetReservedSpillReg();
+  } else {
+    /*
+     * use the reg that exclude livein/liveout/bbInfo->regMap
+     * Need to make sure the reg picked is not assigned to this insn,
+     * else there will be conflict.
+     */
+    spillReg = PickRegForSpill(usedRegMask, regType, spillIdx, needSpillLr);
+    AddCalleeUsed(spillReg, regType);
+    if (GCRA_DUMP) {
+      LogInfo::MapleLogger() << "\tassigning lra spill reg " << spillReg << "\n";
+    }
+  }
+  RegOperand &phyOpnd = cgFunc->GetOpndBuilder()->CreatePReg(spillReg, regOpnd.GetSize(), regType);
+  SpillOperandForSpillPre(insn, regOpnd, phyOpnd, spillIdx, needSpillLr);
+  Insn *defSpill = SpillOperand(insn, regOpnd, true, phyOpnd);
+  if (defSpill != nullptr) {
+    SpillOperandForSpillPost(*defSpill, regOpnd, phyOpnd, spillIdx, needSpillLr);
+  }
+  Insn *useSpill = SpillOperand(insn, regOpnd, false, phyOpnd);
+  ASSERT(useSpill != nullptr, "null ptr check!");
+  SpillOperandForSpillPost(*useSpill, regOpnd, phyOpnd, spillIdx, needSpillLr);
+  ++spillIdx;
+  return &phyOpnd;
+}
+
+/* get spill reg and check if need extra spill */
+bool GraphColorRegAllocator::GetSpillReg(Insn &insn, LiveRange &lr, const uint32 &spillIdx,
+    MapleBitVector &usedRegMask, bool isDef) {
+  bool needSpillLr = false;
+  /*
+   * Find a spill reg for the BB among interfereing LR.
+   * Without LRA, this info is very inaccurate.  It will falsely interfere
+   * with all locals which the spill might not be interfering.
+   * For now, every instance of the spill requires a brand new reg assignment.
+   */
+  if (GCRA_DUMP) {
+    LogInfo::MapleLogger() << "LR-regNO " << lr.GetRegNO() << " spilled, finding a spill reg\n";
+  }
+  if (insn.IsBranch() || insn.IsCall()) {
+    /*
+     * When a cond branch reg is spilled, it cannot
+     * restore the value after the branch since it can be the target from other br.
+     * Todo it properly, it will require creating a intermediate bb for the reload.
+     * Use x16, it is taken out from available since it is used as a global in the system.
+     */
+    lr.SetAssignedRegNO(regInfo->GetReservedSpillReg());
+  } else {
+    lr.SetAssignedRegNO(0);
+    needSpillLr = SetRegForSpill(lr, insn, spillIdx, usedRegMask, isDef);
+    AddCalleeUsed(lr.GetAssignedRegNO(), lr.GetRegType());
+  }
+  return needSpillLr;
+}
+
+// find prev use/def after prev call
+bool GraphColorRegAllocator::EncountPrevRef(const BB &pred, LiveRange &lr, bool isDef, std::vector<bool>& visitedMap) {
+  if (!visitedMap[pred.GetId()] && lr.FindInLuMap(pred.GetId()) != lr.EndOfLuMap()) {
+    LiveUnit *lu = lr.GetLiveUnitFromLuMap(pred.GetId());
+    if ((lu->GetDefNum() > 0) || (lu->GetUseNum() > 0) || lu->HasCall()) {
+      MapleMap<uint32, uint32> refs = lr.GetRefs(pred.GetId());
+      auto it = refs.rbegin();
+      bool findPrevRef = (it->second & kIsCall) == 0;
+      return findPrevRef;
+    }
+    if (lu->HasCall()) {
+      return false;
+    }
+  }
+  visitedMap[pred.GetId()] = true;
+  bool found = true;
+  for (auto predBB: pred.GetPreds()) {
+    if (!visitedMap[predBB->GetId()]) {
+      found = EncountPrevRef(*predBB, lr, isDef, visitedMap) && found;
+    }
+  }
+  return found;
+}
+
+bool GraphColorRegAllocator::FoundPrevBeforeCall(Insn &insn, LiveRange &lr, bool isDef) {
+  bool hasFind = true;
+  std::vector<bool> visitedMap(bbVec.size() + 1, false);
+  for (auto pred: insn.GetBB()->GetPreds()) {
+    hasFind = EncountPrevRef(*pred, lr, isDef, visitedMap) && hasFind;
+    if (!hasFind) {
+      return false;
+    }
+  }
+  return insn.GetBB()->GetPreds().size() == 0 ? false : true;
+}
+
+// find next def before next call ?  and no next use
+bool GraphColorRegAllocator::EncountNextRef(const BB &succ, LiveRange &lr, bool isDef, std::vector<bool>& visitedMap) {
+  if (lr.FindInLuMap(succ.GetId()) != lr.EndOfLuMap()) {
+    LiveUnit *lu = lr.GetLiveUnitFromLuMap(succ.GetId());
+    bool findNextDef = false;
+    if ((lu->GetDefNum() > 0) || lu->HasCall()) {
+      MapleMap<uint32, uint32> refs = lr.GetRefs(succ.GetId());
+      for (auto it = refs.begin(); it != refs.end(); ++it) {
+        if ((it->second & kIsDef) != 0) {
+          findNextDef = true;
+          break;
+        }
+        if ((it->second & kIsCall) != 0) {
+          break;
+        }
+        if ((it->second & kIsUse) != 0) {
+          continue;
+        }
+      }
+      return findNextDef;
+    }
+    if (lu->HasCall()) {
+      return false;
+    }
+  }
+  visitedMap[succ.GetId()] = true;
+  bool found = true;
+  for (auto succBB: succ.GetSuccs()) {
+    if (!visitedMap[succBB->GetId()]) {
+      found = EncountNextRef(*succBB, lr, isDef, visitedMap) && found;
+      if (!found) {
+        return false;
+      }
+    }
+  }
+  return found;
+}
+
+bool GraphColorRegAllocator::FoundNextBeforeCall(Insn &insn, LiveRange &lr, bool isDef) {
+  bool haveFind = true;
+  std::vector<bool> visitedMap(bbVec.size() + 1, false);
+  for (auto succ: insn.GetBB()->GetSuccs()) {
+    haveFind = EncountNextRef(*succ, lr, isDef, visitedMap) && haveFind;
+    if (!haveFind) {
+      return false;
+    }
+  }
+  return insn.GetBB()->GetSuccs().size() > 0;
+}
+
+bool GraphColorRegAllocator::HavePrevRefInCurBB(Insn &insn, LiveRange &lr, bool &contSearch) const {
+  LiveUnit *lu = lr.GetLiveUnitFromLuMap(insn.GetBB()->GetId());
+  bool findPrevRef = false;
+  if ((lu->GetDefNum() > 0) || (lu->GetUseNum() > 0) || lu->HasCall()) {
+    MapleMap<uint32, uint32> refs = lr.GetRefs(insn.GetBB()->GetId());
+    for (auto it = refs.rbegin(); it != refs.rend(); ++it) {
+      if (it->first >= insn.GetId()) {
+        continue;
+      }
+      if ((it->second & kIsCall) != 0) {
+        contSearch = false;
+        break;
+      }
+      if (((it->second & kIsUse) != 0) || ((it->second & kIsDef) != 0)) {
+        findPrevRef = true;
+        contSearch = false;
+        break;
+      }
+    }
+  }
+  return findPrevRef;
+}
+
+bool GraphColorRegAllocator::HaveNextDefInCurBB(Insn &insn, LiveRange &lr, bool &contSearch) const {
+  LiveUnit *lu = lr.GetLiveUnitFromLuMap(insn.GetBB()->GetId());
+  bool findNextDef = false;
+  if ((lu->GetDefNum() > 0) || (lu->GetUseNum() > 0) || lu->HasCall()) {
+    MapleMap<uint32, uint32> refs = lr.GetRefs(insn.GetBB()->GetId());
+    for (auto it = refs.begin(); it != refs.end(); ++it) {
+      if (it->first <= insn.GetId()) {
+        continue;
+      }
+      if ((it->second & kIsCall) != 0) {
+        contSearch = false;
+        break;
+      }
+      if ((it->second & kIsDef) != 0) {
+        findNextDef = true;
+        contSearch = false;
+      }
+    }
+  }
+  return findNextDef;
+}
+
+bool GraphColorRegAllocator::NeedCallerSave(Insn &insn, LiveRange &lr, bool isDef) {
+  if (doLRA) {
+    return true;
+  }
+  if (lr.HasDefUse()) {
+    return true;
+  }
+
+  bool contSearch = true;
+  bool needed = true;
+  if (isDef) {
+    needed = !HaveNextDefInCurBB(insn, lr, contSearch);
+  } else {
+    needed = !HavePrevRefInCurBB(insn, lr, contSearch);
+  }
+  if (!contSearch) {
+    return needed;
+  }
+
+  if (isDef) {
+    needed = true;
+  } else {
+    needed = !FoundPrevBeforeCall(insn, lr, isDef);
+  }
+  return needed;
+}
+
+RegOperand *GraphColorRegAllocator::GetReplaceOpnd(Insn &insn, const Operand &opnd, uint32 &spillIdx,
+                                                   MapleBitVector &usedRegMask, bool isDef) {
+  if (!opnd.IsRegister()) {
+    return nullptr;
+  }
+  auto &regOpnd = static_cast<const RegOperand&>(opnd);
+
+  uint32 vregNO = regOpnd.GetRegisterNumber();
+  if (regInfo->IsFramePointReg(vregNO)) {
+    cgFunc->SetSeenFP(true);
+  }
+  RegType regType = regOpnd.GetRegisterType();
+  if (!regInfo->IsVirtualRegister(vregNO) || regInfo->IsUnconcernedReg(regOpnd)) {
+    return nullptr;
+  }
+
+#ifdef USE_LRA
+  if (doLRA && IsLocalReg(vregNO)) {
+    return GetReplaceOpndForLRA(insn, opnd, spillIdx, usedRegMask, isDef);
+  }
+#endif  /* USE_LRA */
+
+  ASSERT(vregNO < numVregs, "index out of range in GraphColorRegAllocator::GetReplaceOpnd");
+  LiveRange *lr = lrMap[vregNO];
+
+  bool isSplitPart = false;
+  bool needSpillLr = false;
+  if (lr->GetSplitLr() && IsBitArrElemSet(lr->GetSplitLr()->GetBBMember(), insn.GetBB()->GetId())) {
+    isSplitPart = true;
+  }
+
+  if (lr->IsSpilled() && !isSplitPart) {
+    needSpillLr = GetSpillReg(insn, *lr, spillIdx, usedRegMask, isDef);
+  }
+
+  regno_t regNO;
+  if (isSplitPart) {
+    regNO = lr->GetSplitLr()->GetAssignedRegNO();
+  } else {
+    regNO = lr->GetAssignedRegNO();
+  }
+  bool isCalleeReg = regInfo->IsCalleeSavedReg(regNO);
+  RegOperand &phyOpnd = cgFunc->GetOpndBuilder()->CreatePReg(regNO, opnd.GetSize(), regType);
+  if (GCRA_DUMP) {
+    std::string regStr = (regType == kRegTyInt) ? "R" : "V";
+    regStr += std::to_string(regNO - *regInfo->GetRegsFromType(kRegTyInt).begin());
+    LogInfo::MapleLogger() << "replace R" << vregNO << " with " << regStr << "\n";
+  }
+
+  insn.AppendComment(" [R" + std::to_string(vregNO) + "] ");
+
+  if (isSplitPart && (isCalleeReg || lr->GetSplitLr()->GetNumCall() == 0)) {
+    if (isDef) {
+      SpillOperand(insn, opnd, isDef, phyOpnd);
+      ++spillIdx;
+    } else {
+      if (lr->GetSplitLr()->GetLiveUnitFromLuMap(insn.GetBB()->GetId())->NeedReload()) {
+        SpillOperand(insn, opnd, isDef, phyOpnd);
+        ++spillIdx;
+      }
+    }
+    return &phyOpnd;
+  }
+
+  bool needCallerSave = false;
+  if ((lr->GetNumCall() > 0) && !isCalleeReg) {
+    if (isDef) {
+      needCallerSave = NeedCallerSave(insn, *lr, isDef) && lr->GetRematLevel() == kRematOff;
+    } else {
+      needCallerSave = !lr->GetProcessed();
+    }
+  }
+
+  if (lr->IsSpilled() || (isSplitPart && (lr->GetSplitLr()->GetNumCall() != 0)) || needCallerSave ||
+      (!isSplitPart && !(lr->IsSpilled()) && lr->GetLiveUnitFromLuMap(insn.GetBB()->GetId())->NeedReload())) {
+    SpillOperandForSpillPre(insn, regOpnd, phyOpnd, spillIdx, needSpillLr);
+    Insn *spill = SpillOperand(insn, opnd, isDef, phyOpnd);
+    if (spill != nullptr) {
+      SpillOperandForSpillPost(*spill, regOpnd, phyOpnd, spillIdx, needSpillLr);
+    }
+    ++spillIdx;
+  }
+
+  return &phyOpnd;
+}
+
+RegOperand *GraphColorRegAllocator::GetReplaceUseDefOpnd(Insn &insn, const Operand &opnd,
+    uint32 &spillIdx, MapleBitVector &usedRegMask) {
+  if (!opnd.IsRegister()) {
+    return nullptr;
+  }
+  auto &regOpnd = static_cast<const RegOperand&>(opnd);
+
+  uint32 vregNO = regOpnd.GetRegisterNumber();
+  if (regInfo->IsFramePointReg(vregNO)) {
+    cgFunc->SetSeenFP(true);
+  }
+  RegType regType = regOpnd.GetRegisterType();
+  if (!regInfo->IsVirtualRegister(vregNO) || regInfo->IsUnconcernedReg(regOpnd)) {
+    return nullptr;
+  }
+
+#ifdef USE_LRA
+  if (doLRA && IsLocalReg(vregNO)) {
+    return GetReplaceUseDefOpndForLRA(insn, opnd, spillIdx, usedRegMask);
+  }
+#endif  /* USE_LRA */
+
+  ASSERT(vregNO < numVregs, "index out of range in GraphColorRegAllocator::GetReplaceUseDefOpnd");
+  LiveRange *lr = lrMap[vregNO];
+
+  bool isSplitPart = false;
+  bool needSpillLr = false;
+  if (lr->GetSplitLr() && IsBitArrElemSet(lr->GetSplitLr()->GetBBMember(), insn.GetBB()->GetId())) {
+    isSplitPart = true;
+  }
+
+  if (lr->IsSpilled() && !isSplitPart) {
+    needSpillLr = GetSpillReg(insn, *lr, spillIdx, usedRegMask, true);
+  }
+
+  regno_t regNO;
+  if (isSplitPart) {
+    regNO = lr->GetSplitLr()->GetAssignedRegNO();
+  } else {
+    regNO = lr->GetAssignedRegNO();
+  }
+  bool isCalleeReg = regInfo->IsCalleeSavedReg(regNO);
+  RegOperand &phyOpnd = cgFunc->GetOpndBuilder()->CreatePReg(regNO, opnd.GetSize(), regType);
+  if (GCRA_DUMP) {
+    std::string regStr = (regType == kRegTyInt) ? "R" : "V";
+    regStr += std::to_string(regNO - *regInfo->GetRegsFromType(kRegTyInt).begin());
+    LogInfo::MapleLogger() << "replace R" << vregNO << " with " << regStr << "\n";
+  }
+
+  insn.AppendComment(" [R" + std::to_string(vregNO) + "] ");
+
+  if (isSplitPart && (isCalleeReg || lr->GetSplitLr()->GetNumCall() == 0)) {
+    (void)SpillOperand(insn, opnd, true, phyOpnd);
+    if (lr->GetSplitLr()->GetLiveUnitFromLuMap(insn.GetBB()->GetId())->NeedReload()) {
+      (void)SpillOperand(insn, opnd, false, phyOpnd);
+    }
+    ++spillIdx;
+    return &phyOpnd;
+  }
+
+  bool needCallerSave = false;
+  if ((lr->GetNumCall() > 0) && !isCalleeReg) {
+    needCallerSave = NeedCallerSave(insn, *lr, true) && lr->GetRematLevel() == kRematOff;
+  }
+
+  if (lr->IsSpilled() || (isSplitPart && (lr->GetSplitLr()->GetNumCall() != 0)) || needCallerSave ||
+      (!isSplitPart && !(lr->IsSpilled()) &&
+          lr->GetLiveUnitFromLuMap(insn.GetBB()->GetId())->NeedReload())) {
+    SpillOperandForSpillPre(insn, regOpnd, phyOpnd, spillIdx, needSpillLr);
+    Insn *defSpill = SpillOperand(insn, opnd, true, phyOpnd);
+    if (defSpill != nullptr) {
+      SpillOperandForSpillPost(*defSpill, regOpnd, phyOpnd, spillIdx, needSpillLr);
+    }
+    Insn *useSpill = SpillOperand(insn, opnd, false, phyOpnd);
+    ASSERT(useSpill != nullptr, "null ptr check!");
+    SpillOperandForSpillPost(*useSpill, regOpnd, phyOpnd, spillIdx, needSpillLr);
+    ++spillIdx;
+  }
+
+  return &phyOpnd;
+}
+
+void GraphColorRegAllocator::MarkUsedRegs(Operand &opnd, MapleBitVector &usedRegMask) {
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  uint32 vregNO = regOpnd.GetRegisterNumber();
+  LiveRange *lr = GetLiveRange(vregNO);
+  if (lr != nullptr) {
+    if (lr->IsSpilled()) {
+      lr->SetAssignedRegNO(0);
+    }
+    if (lr->GetAssignedRegNO() != 0) {
+      usedRegMask[lr->GetAssignedRegNO()] = true;
+    }
+    if ((lr->GetSplitLr() != nullptr) && (lr->GetSplitLr()->GetAssignedRegNO() > 0)) {
+      usedRegMask[lr->GetSplitLr()->GetAssignedRegNO()] = true;
+    }
+  }
+}
+
+bool GraphColorRegAllocator::FinalizeRegisterPreprocess(FinalizeRegisterInfo &fInfo,
+    const Insn &insn, MapleBitVector &usedRegMask) {
+  const InsnDesc *md = insn.GetDesc();
+  uint32 opndNum = insn.GetOperandSize();
+  bool hasVirtual = false;
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    ASSERT(md->GetOpndDes(i) != nullptr, "pointer is null in GraphColorRegAllocator::FinalizeRegisters");
+
+    if (opnd.IsList()) {
+      if (!insn.IsAsmInsn()) {
+        continue;
+      }
+      hasVirtual = true;
+      if (i == kAsmOutputListOpnd) {
+        fInfo.SetDefOperand(opnd, i);
+      }
+      if (i == kAsmInputListOpnd) {
+        fInfo.SetUseOperand(opnd, i);
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      Operand *base = memOpnd.GetBaseRegister();
+      if (base != nullptr) {
+        fInfo.SetBaseOperand(opnd, i);
+        MarkUsedRegs(*base, usedRegMask);
+        hasVirtual = static_cast<RegOperand*>(base)->IsVirtualRegister() || hasVirtual;
+      }
+      Operand *offset = memOpnd.GetIndexRegister();
+      if (offset != nullptr) {
+        fInfo.SetOffsetOperand(opnd);
+        MarkUsedRegs(*offset, usedRegMask);
+        hasVirtual = static_cast<RegOperand*>(offset)->IsVirtualRegister() || hasVirtual;
+      }
+    } else {
+      bool isDef = md->GetOpndDes(i)->IsDef();
+      bool isUse = md->GetOpndDes(i)->IsUse();
+      if (isDef && isUse) {
+        fInfo.SetUseDefOperand(opnd, i);
+      } else if (isDef) {
+        fInfo.SetDefOperand(opnd, i);
+      } else {
+        fInfo.SetUseOperand(opnd, i);
+      }
+      if (opnd.IsRegister()) {
+        hasVirtual |= static_cast<RegOperand&>(opnd).IsVirtualRegister();
+        MarkUsedRegs(opnd, usedRegMask);
+      }
+    }
+  }  /* operand */
+  return hasVirtual;
+}
+
+void GraphColorRegAllocator::GenerateSpillFillRegs(const Insn &insn) {
+  uint32 opndNum = insn.GetOperandSize();
+  std::set<regno_t> defPregs;
+  std::set<regno_t> usePregs;
+  std::vector<LiveRange*> defLrs;
+  std::vector<LiveRange*> useLrs;
+  if (insn.IsIntRegisterMov()) {
+    RegOperand &opnd1 = static_cast<RegOperand&>(insn.GetOperand(1));
+    RegOperand &opnd0 = static_cast<RegOperand&>(insn.GetOperand(0));
+    if (regInfo->IsGPRegister(opnd1.GetRegisterNumber()) &&
+        !regInfo->IsUnconcernedReg(opnd1) &&
+        !regInfo->IsCalleeSavedReg(opnd1.GetRegisterNumber()) &&
+        regInfo->IsVirtualRegister(opnd0.GetRegisterNumber())) {
+      LiveRange *lr = lrMap[opnd0.GetRegisterNumber()];
+      if (lr->IsSpilled()) {
+        lr->SetSpillReg(opnd1.GetRegisterNumber());
+        ASSERT(lr->GetSpillReg() != 0, "no spill reg in GenerateSpillFillRegs");
+        return;
+      }
+    }
+    if (regInfo->IsGPRegister(opnd0.GetRegisterNumber()) &&
+        !regInfo->IsUnconcernedReg(opnd0) &&
+        !regInfo->IsCalleeSavedReg(opnd0.GetRegisterNumber()) &&
+        regInfo->IsVirtualRegister(opnd1.GetRegisterNumber())) {
+      LiveRange *lr = lrMap[opnd1.GetRegisterNumber()];
+      if (lr->IsSpilled()) {
+        lr->SetSpillReg(opnd0.GetRegisterNumber());
+        ASSERT(lr->GetSpillReg() != 0, "no spill reg in GenerateSpillFillRegs");
+        return;
+      }
+    }
+  }
+  const InsnDesc *md = insn.GetDesc();
+  bool isIndexedMemOp = false;
+  for (uint32 opndIdx = 0; opndIdx < opndNum; ++opndIdx) {
+    Operand *opnd = &insn.GetOperand(opndIdx);
+    if (opnd == nullptr) {
+      continue;
+    }
+    if (opnd->IsList()) {
+      // call parameters
+    } else if (opnd->IsMemoryAccessOperand()) {
+      auto *memopnd = static_cast<MemOperand*>(opnd);
+      if (memopnd->GetIndexOpt() == MemOperand::kPreIndex ||
+          memopnd->GetIndexOpt() == MemOperand::kPostIndex) {
+        isIndexedMemOp = true;
+      }
+      auto *base = static_cast<RegOperand*>(memopnd->GetBaseRegister());
+      if (base != nullptr && !regInfo->IsUnconcernedReg(*base)) {
+        if (!memopnd->IsIntactIndexed()) {
+          if (base->IsPhysicalRegister()) {
+            defPregs.insert(base->GetRegisterNumber());
+          } else {
+            LiveRange *lr = lrMap[base->GetRegisterNumber()];
+            if (lr->IsSpilled()) {
+              defLrs.emplace_back(lr);
+            }
+          }
+        }
+        if (base->IsPhysicalRegister()) {
+          usePregs.insert(base->GetRegisterNumber());
+        } else {
+          LiveRange *lr = lrMap[base->GetRegisterNumber()];
+          if (lr->IsSpilled()) {
+            useLrs.emplace_back(lr);
+          }
+        }
+      }
+      RegOperand *offset = static_cast<RegOperand*>(memopnd->GetIndexRegister());
+      if (offset != nullptr) {
+        if (offset->IsPhysicalRegister()) {
+          usePregs.insert(offset->GetRegisterNumber());
+        } else {
+          LiveRange *lr = lrMap[offset->GetRegisterNumber()];
+          if (lr->IsSpilled()) {
+            useLrs.emplace_back(lr);
+          }
+        }
+      }
+    } else if (opnd->IsRegister()) {
+      bool isDef = md->GetOpndDes(static_cast<int>(opndIdx))->IsRegDef();
+      bool isUse = md->GetOpndDes(static_cast<int>(opndIdx))->IsRegUse();
+      RegOperand *ropnd = static_cast<RegOperand*>(opnd);
+      if (regInfo->IsUnconcernedReg(*ropnd)) {
+        continue;
+      }
+      if (ropnd != nullptr) {
+        if (isUse) {
+          if (ropnd->IsPhysicalRegister()) {
+            usePregs.insert(ropnd->GetRegisterNumber());
+          } else {
+            LiveRange *lr = lrMap[ropnd->GetRegisterNumber()];
+            if (lr->IsSpilled()) {
+              useLrs.emplace_back(lr);
+            }
+          }
+        }
+        if (isDef) {
+          if (ropnd->IsPhysicalRegister()) {
+            defPregs.insert(ropnd->GetRegisterNumber());
+          } else {
+            LiveRange *lr = lrMap[ropnd->GetRegisterNumber()];
+            if (lr->IsSpilled()) {
+              defLrs.emplace_back(lr);
+            }
+          }
+        }
+      }
+    }
+  }
+  auto comparator = [=](const LiveRange *lr1, const LiveRange *lr2) -> bool {
+      return lr1->GetID() > lr2->GetID();
+  };
+  std::sort(useLrs.begin(), useLrs.end(), comparator);
+  for (auto lr: useLrs) {
+    lr->SetID(insn.GetId());
+    RegType rtype = lr->GetRegType();
+    regno_t firstSpillReg = (rtype == kRegTyInt) ? regInfo->GetIntSpillFillReg(0) :
+        regInfo->GetFpSpillFillReg(0);
+    if (lr->GetSpillReg() != 0 && lr->GetSpillReg() < firstSpillReg && lr->GetPregveto(lr->GetSpillReg())) {
+      lr->SetSpillReg(0);
+    }
+    if (lr->GetSpillReg() != 0 && lr->GetSpillReg() >= firstSpillReg &&
+        usePregs.find(lr->GetSpillReg()) == usePregs.end()) {
+      usePregs.insert(lr->GetSpillReg());
+      continue;
+    } else {
+      lr->SetSpillReg(0);
+    }
+    for (uint32 i = 0; i < kSpillMemOpndNum; i++) {
+      regno_t preg = (rtype == kRegTyInt) ? regInfo->GetIntSpillFillReg(i) :
+          regInfo->GetFpSpillFillReg(i);
+      if (usePregs.find(preg) == usePregs.end()) {
+        lr->SetSpillReg(preg);
+        usePregs.insert(preg);
+        break;
+      }
+    }
+    ASSERT(lr->GetSpillReg() != 0, "no reg");
+  }
+  size_t spillRegIdx = 0;
+  if (isIndexedMemOp) {
+    spillRegIdx = useLrs.size();
+  }
+  for (auto lr: defLrs) {
+    lr->SetID(insn.GetId());
+    RegType rtype = lr->GetRegType();
+    regno_t firstSpillReg = (rtype == kRegTyInt) ? regInfo->GetIntSpillFillReg(0) :
+        regInfo->GetFpSpillFillReg(0);
+    if (lr->GetSpillReg() != 0) {
+      if (lr->GetSpillReg() < firstSpillReg && lr->GetPregveto(lr->GetSpillReg())) {
+        lr->SetSpillReg(0);
+      }
+      if (lr->GetSpillReg() >= firstSpillReg && defPregs.find(lr->GetSpillReg()) != defPregs.end()) {
+        lr->SetSpillReg(0);
+      }
+    }
+    if (lr->GetSpillReg() != 0) {
+      continue;
+    }
+    for (; spillRegIdx < kSpillMemOpndNum; spillRegIdx++) {
+      regno_t preg = (rtype == kRegTyInt) ? regInfo->GetIntSpillFillReg(spillRegIdx) :
+          regInfo->GetFpSpillFillReg(spillRegIdx);
+      if (defPregs.find(preg) == defPregs.end()) {
+        lr->SetSpillReg(preg);
+        defPregs.insert(preg);
+        break;
+      }
+    }
+    ASSERT(lr->GetSpillReg() != 0, "no reg");
+  }
+}
+
+RegOperand *GraphColorRegAllocator::CreateSpillFillCode(const RegOperand &opnd, Insn &insn,
+                                                        uint32 spillCnt, bool isdef) {
+  regno_t vregno = opnd.GetRegisterNumber();
+  LiveRange *lr = GetLiveRange(vregno);
+  if (lr != nullptr && lr->IsSpilled()) {
+    uint32 bits = opnd.GetSize();
+    if (bits < k32BitSize) {
+      bits = k32BitSize;
+    }
+    if (cgFunc->IsExtendReg(vregno)) {
+      bits = k64BitSize;
+    }
+    regno_t spreg = 0;
+    RegType rtype = lr->GetRegType();
+    spreg = lr->GetSpillReg();
+    ASSERT(lr->GetSpillReg() != 0, "no reg in CreateSpillFillCode");
+    RegOperand *regopnd = &cgFunc->GetOpndBuilder()->CreatePReg(spreg, opnd.GetSize(), rtype);
+
+    if (lr->GetRematLevel() != kRematOff) {
+      if (isdef) {
+        return nullptr;
+      } else {
+        std::vector<Insn *> rematInsns = lr->Rematerialize(*cgFunc, *regopnd);
+        for (auto &&remat : rematInsns) {
+          std::string comment = " REMATERIALIZE color vreg: " + std::to_string(vregno);
+          remat->SetComment(comment);
+          insn.GetBB()->InsertInsnBefore(insn, *remat);
+        }
+        return regopnd;
+      }
+    }
+
+    bool isOutOfRange = false;
+    Insn *nextInsn = insn.GetNextMachineInsn();
+    MemOperand *loadmem = GetSpillOrReuseMem(*lr, opnd.GetSize(), isOutOfRange,
+                                             insn, isdef);
+    PrimType pty =
+        (lr->GetRegType() == kRegTyInt) ? ((bits > k32BitSize) ? PTY_i64 : PTY_i32)
+                                        : ((bits > k32BitSize) ? PTY_f64 : PTY_f32);
+    CHECK_FATAL(spillCnt < kSpillMemOpndNum, "spill count exceeded");
+    Insn *memInsn;
+    if (isdef) {
+      memInsn = regInfo->BuildStrInsn(bits, pty, *regopnd, *loadmem);
+      memInsn->SetIsSpill();
+      std::string comment = " SPILLcolor vreg: " + std::to_string(vregno) +
+                            " op:" + kOpcodeInfo.GetName(lr->GetOp());
+      memInsn->SetComment(comment);
+      if (nextInsn == nullptr) {
+        insn.GetBB()->AppendInsn(*memInsn);
+      } else {
+        insn.GetBB()->InsertInsnBefore(*nextInsn, *memInsn);
+      }
+    } else {
+      memInsn = regInfo->BuildLdrInsn(bits, pty, *regopnd, *loadmem);
+      memInsn->SetIsReload();
+      std::string comment = " RELOADcolor vreg: " + std::to_string(vregno) +
+                            " op:" + kOpcodeInfo.GetName(lr->GetOp());
+      memInsn->SetComment(comment);
+      insn.GetBB()->InsertInsnBefore(insn, *memInsn);
+    }
+    return regopnd;
+  }
+  return nullptr;
+}
+
+bool GraphColorRegAllocator::SpillLiveRangeForSpills() {
+  bool done = false;
+  for (uint32_t bbIdx = 0; bbIdx < bfs->sortedBBs.size(); bbIdx++) {
+    BB *bb = bfs->sortedBBs[bbIdx];
+    FOR_BB_INSNS(insn, bb) {
+      uint32 spillCnt;
+      if (insn->IsImmaterialInsn() || !insn->IsMachineInstruction() || insn->GetId() == 0) {
+        continue;
+      }
+      spillCnt = 0;
+      const InsnDesc *md = insn->GetDesc();
+      uint32 opndNum = insn->GetOperandSize();
+      GenerateSpillFillRegs(*insn);
+      for (uint32 i = 0; i < opndNum; ++i) {
+        Operand *opnd = &insn->GetOperand(i);
+        if (opnd == nullptr) {
+          continue;
+        }
+        if (opnd->IsList()) {
+          // call parameters
+        } else if (opnd->IsMemoryAccessOperand()) {
+          MemOperand *newmemopnd = nullptr;
+          auto *memopnd = static_cast<MemOperand*>(opnd);
+          auto *base = static_cast<RegOperand*>(memopnd->GetBaseRegister());
+          if (base != nullptr && base->IsVirtualRegister()) {
+            RegOperand *replace = CreateSpillFillCode(*base, *insn, spillCnt);
+            if (!memopnd->IsIntactIndexed()) {
+              (void)CreateSpillFillCode(*base, *insn, spillCnt, true);
+            }
+            if (replace != nullptr) {
+              spillCnt++;
+              newmemopnd = (static_cast<MemOperand *>(opnd)->Clone(*cgFunc->GetMemoryPool()));
+              newmemopnd->SetBaseRegister(*replace);
+              insn->SetOperand(i, *newmemopnd);
+              done = true;
+            }
+          }
+          RegOperand *offset = static_cast<RegOperand*>(memopnd->GetIndexRegister());
+          if (offset != nullptr && offset->IsVirtualRegister()) {
+            RegOperand *replace = CreateSpillFillCode(*offset, *insn, spillCnt);
+            if (replace != nullptr) {
+              spillCnt++;
+              if (newmemopnd == nullptr) {
+                newmemopnd = (static_cast<MemOperand*>(opnd)->Clone(*cgFunc->GetMemoryPool()));
+              }
+              newmemopnd->SetIndexRegister(*replace);
+              insn->SetOperand(i, *newmemopnd);
+              done = true;
+            }
+          }
+        } else if (opnd->IsRegister()) {
+          bool isdef = md->opndMD[i]->IsRegDef();
+          bool isuse = md->opndMD[i]->IsRegUse();
+          RegOperand *replace = CreateSpillFillCode(*static_cast<RegOperand*>(opnd), *insn, spillCnt, isdef);
+          if (isuse && isdef) {
+            (void)CreateSpillFillCode(*static_cast<RegOperand*>(opnd), *insn, spillCnt, false);
+          }
+          if (replace != nullptr) {
+            if (!isdef) {
+              spillCnt++;
+            }
+            insn->SetOperand(i, *replace);
+            done = true;
+          }
+        }
+      }
+    }
+  }
+  return done;
+}
+
+void GraphColorRegAllocator::FinalizeSpSaveReg() {
+  if (!cgFunc->GetCG()->IsLmbc() || cgFunc->GetSpSaveReg() == 0) {
+    return;
+  }
+  LiveRange *lr = lrMap[cgFunc->GetSpSaveReg()];
+  if (lr == nullptr) {
+    return;
+  }
+  RegOperand &preg = cgFunc->GetOpndBuilder()->CreatePReg(lr->GetAssignedRegNO(),
+      k64BitSize, kRegTyInt);
+  BB *firstBB = cgFunc->GetFirstBB();
+  FOR_BB_INSNS(insn, firstBB) {
+    if (insn->IsIntRegisterMov() &&
+        static_cast<RegOperand&>(insn->GetOperand(kInsnSecondOpnd)).GetRegisterNumber() ==
+            regInfo->GetStackPointReg()) {
+      if (!static_cast<RegOperand&>(insn->GetOperand(kInsnFirstOpnd)).IsVirtualRegister()) {
+        break;
+      }
+      insn->SetOperand(kInsnFirstOpnd, preg);
+      break;
+    }
+  }
+  for (auto *retBB : cgFunc->GetExitBBsVec()) {
+    FOR_BB_INSNS(insn, retBB) {
+      if (insn->IsIntRegisterMov() &&
+          static_cast<RegOperand&>(insn->GetOperand(kInsnFirstOpnd)).GetRegisterNumber() ==
+              regInfo->GetStackPointReg()) {
+        if (!static_cast<RegOperand&>(insn->GetOperand(kInsnSecondOpnd)).IsVirtualRegister()) {
+          break;
+        }
+        insn->SetOperand(kInsnSecondOpnd, preg);
+        break;
+      }
+    }
+  }
+}
+
+static bool ReloadAtCallee(CgOccur *occ) {
+  auto *defOcc = occ->GetDef();
+  if (defOcc == nullptr || defOcc->GetOccType() != kOccStore) {
+    return false;
+  }
+  return static_cast<CgStoreOcc *>(defOcc)->Reload();
+}
+
+void CallerSavePre::DumpWorkCandAndOcc() {
+  if (workCand->GetTheOperand()->IsRegister()) {
+    LogInfo::MapleLogger() << "Cand R";
+    LogInfo::MapleLogger() << static_cast<RegOperand*>(workCand->GetTheOperand())->GetRegisterNumber() << '\n';
+  } else {
+    LogInfo::MapleLogger() << "Cand Index" << workCand->GetIndex() << '\n';
+  }
+  for (CgOccur *occ : allOccs) {
+    occ->Dump();
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+void CallerSavePre::CodeMotion() {
+  constexpr uint32 limitNum = UINT32_MAX;
+  uint32 cnt = 0;
+  for (auto *occ : allOccs) {
+    if (occ->GetOccType() == kOccUse) {
+      ++cnt;
+      beyondLimit = (cnt == limitNum) || beyondLimit;
+      if (!beyondLimit && dump) {
+        LogInfo::MapleLogger() << "opt use occur: ";
+        occ->Dump();
+      }
+    }
+    if (occ->GetOccType() == kOccUse &&
+        (beyondLimit || (static_cast<CgUseOcc *>(occ)->Reload() && !ReloadAtCallee(occ)))) {
+      RegOperand &phyOpnd = func->GetOpndBuilder()->CreatePReg(workLr->GetAssignedRegNO(),
+          occ->GetOperand()->GetSize(),
+          static_cast<RegOperand*>(occ->GetOperand())->GetRegisterType());
+      (void)regAllocator->SpillOperand(*occ->GetInsn(), *occ->GetOperand(), false, phyOpnd);
+      continue;
+    }
+    if (occ->GetOccType() == kOccPhiopnd && static_cast<CgPhiOpndOcc *>(occ)->Reload() && !ReloadAtCallee(occ)) {
+      RegOperand &phyOpnd = func->GetOpndBuilder()->CreatePReg(workLr->GetAssignedRegNO(),
+          occ->GetOperand()->GetSize(),
+          static_cast<RegOperand*>(occ->GetOperand())->GetRegisterType());
+      Insn *insn = occ->GetBB()->GetLastInsn();
+      if (insn == nullptr) {
+        auto &comment = func->GetOpndBuilder()->CreateComment("reload caller save register");
+        insn = &func->GetInsnBuilder()->BuildCommentInsn(comment);
+        occ->GetBB()->AppendInsn(*insn);
+      }
+      auto defOcc = occ->GetDef();
+      bool forCall = (defOcc != nullptr && insn == defOcc->GetInsn());
+      (void)regAllocator->SpillOperand(*insn, *occ->GetOperand(), false, phyOpnd, forCall);
+      continue;
+    }
+    if (occ->GetOccType() == kOccStore && static_cast<CgStoreOcc *>(occ)->Reload()) {
+      RegOperand &phyOpnd = func->GetOpndBuilder()->CreatePReg(workLr->GetAssignedRegNO(),
+          occ->GetOperand()->GetSize(),
+          static_cast<RegOperand*>(occ->GetOperand())->GetRegisterType());
+      (void)regAllocator->SpillOperand(*occ->GetInsn(), *occ->GetOperand(), false, phyOpnd, true);
+      continue;
+    }
+  }
+  if (dump) {
+    PreWorkCand *curCand = workCand;
+    LogInfo::MapleLogger() << "========ssapre candidate " << curCand->GetIndex() << " after codemotion ===========\n";
+    DumpWorkCandAndOcc();
+    func->DumpCFGToDot("raCodeMotion-");
+  }
+}
+
+void CallerSavePre::UpdateLoadSite(CgOccur *occ) {
+  if (occ == nullptr) {
+    return;
+  }
+  auto *defOcc = occ->GetDef();
+  if (occ->GetOccType() == kOccUse) {
+    defOcc = static_cast<CgUseOcc *>(occ)->GetPrevVersionOccur();
+  }
+  if (defOcc == nullptr) {
+    return;
+  }
+  switch (defOcc->GetOccType()) {
+    case kOccDef:
+      break;
+    case kOccUse:
+      UpdateLoadSite(defOcc);
+      return;
+    case kOccStore: {
+      auto *storeOcc = static_cast<CgStoreOcc *>(defOcc);
+      if (storeOcc->Reload()) {
+        break;
+      }
+      switch (occ->GetOccType()) {
+        case kOccUse: {
+          static_cast<CgUseOcc *>(occ)->SetReload(true);
+          break;
+        }
+        case kOccPhiopnd: {
+          static_cast<CgPhiOpndOcc *>(occ)->SetReload(true);
+          break;
+        }
+        default: {
+          CHECK_FATAL(false, "must not be here");
+        }
+      }
+      return;
+    }
+    case kOccPhiocc: {
+      auto *phiOcc = static_cast<CgPhiOcc *>(defOcc);
+      if (phiOcc->IsFullyAvailable()) {
+        break;
+      }
+      if (!phiOcc->IsDownSafe() || phiOcc->IsNotAvailable()) {
+        switch (occ->GetOccType()) {
+          case kOccUse: {
+            static_cast<CgUseOcc *>(occ)->SetReload(true);
+            break;
+          }
+          case kOccPhiopnd: {
+            static_cast<CgPhiOpndOcc *>(occ)->SetReload(true);
+            break;
+          }
+          default: {
+            CHECK_FATAL(false, "must not be here");
+          }
+        }
+        return;
+      }
+
+      if (defOcc->Processed()) {
+        return;
+      }
+      defOcc->SetProcessed(true);
+      for (auto *opndOcc : phiOcc->GetPhiOpnds()) {
+        UpdateLoadSite(opndOcc);
+      }
+      return;
+    }
+    default: {
+      CHECK_FATAL(false, "NIY");
+      break;
+    }
+  }
+}
+
+void CallerSavePre::CalLoadSites() {
+  for (auto *occ : allOccs) {
+    if (occ->GetOccType() == kOccUse) {
+      UpdateLoadSite(occ);
+    }
+  }
+  std::vector<CgOccur *> availableDef(classCount, nullptr);
+  for (auto *occ : allOccs) {
+    auto classID = static_cast<uint32>(occ->GetClassID());
+    switch (occ->GetOccType()) {
+      case kOccDef:
+        availableDef[classID] = occ;
+        break;
+      case kOccStore: {
+        if (static_cast<CgStoreOcc *>(occ)->Reload()) {
+          availableDef[classID] = occ;
+        } else {
+          availableDef[classID] = nullptr;
+        }
+        break;
+      }
+      case kOccPhiocc: {
+        auto *phiOcc = static_cast<CgPhiOcc *>(occ);
+        if (!phiOcc->IsNotAvailable() && phiOcc->IsDownSafe()) {
+          availableDef[classID] = occ;
+        } else {
+          availableDef[classID] = nullptr;
+        }
+        break;
+      }
+      case kOccUse: {
+        auto *useOcc = static_cast<CgUseOcc *>(occ);
+        if (useOcc->Reload()) {
+          auto *availDef = availableDef[classID];
+          if (availDef != nullptr && dom->Dominate(*availDef->GetBB(), *useOcc->GetBB())) {
+            useOcc->SetReload(false);
+          } else {
+            availableDef[classID] = useOcc;
+          }
+        }
+        break;
+      }
+      case kOccPhiopnd: {
+        auto *phiOpnd = static_cast<CgPhiOpndOcc *>(occ);
+        if (phiOpnd->Reload()) {
+          auto *availDef = availableDef[classID];
+          if (availDef != nullptr && dom->Dominate(*availDef->GetBB(), *phiOpnd->GetBB())) {
+            phiOpnd->SetReload(false);
+          } else {
+            availableDef[classID] = phiOpnd;
+          }
+        }
+        break;
+      }
+      case kOccExit:
+        break;
+      default:
+        CHECK_FATAL(false, "not supported occur type");
+    }
+  }
+  if (dump) {
+    PreWorkCand *curCand = workCand;
+    LogInfo::MapleLogger() << "========ssapre candidate " << curCand->GetIndex()
+        << " after CalLoadSite===================\n";
+    DumpWorkCandAndOcc();
+    LogInfo::MapleLogger() << "\n";
+  }
+}
+
+void CallerSavePre::ComputeAvail() {
+  bool changed = true;
+  while (changed) {
+    changed = false;
+    for (auto *phiOcc : phiOccs) {
+      if (phiOcc->IsNotAvailable()) {
+        continue;
+      }
+      size_t killedCnt = 0;
+      for (auto *opndOcc : phiOcc->GetPhiOpnds()) {
+        auto defOcc = opndOcc->GetDef();
+        if (defOcc == nullptr) {
+          continue;
+        }
+        // for not move load too far from use site, set not-fully-available-phi killing availibity of phiOpnd
+        if ((defOcc->GetOccType() == kOccPhiocc && !static_cast<CgPhiOcc *>(defOcc)->IsFullyAvailable()) ||
+            defOcc->GetOccType() == kOccStore) {
+          ++killedCnt;
+          opndOcc->SetHasRealUse(false);
+          // opnd at back-edge is killed, set phi not avail
+          if (dom->Dominate(*phiOcc->GetBB(), *opndOcc->GetBB())) {
+            killedCnt = phiOcc->GetPhiOpnds().size();
+            break;
+          }
+          if (opndOcc->GetBB()->IsSoloGoto() && opndOcc->GetBB()->GetLoop() != nullptr) {
+            killedCnt = phiOcc->GetPhiOpnds().size();
+            break;
+          }
+          continue;
+        }
+      }
+      if (killedCnt == phiOcc->GetPhiOpnds().size()) {
+        changed = !phiOcc->IsNotAvailable() || changed;
+        phiOcc->SetAvailability(kNotAvailable);
+      } else if (killedCnt > 0) {
+        changed = !phiOcc->IsPartialAvailable() || changed;
+        phiOcc->SetAvailability(kPartialAvailable);
+      } else {} // fully available is default state
+    }
+  }
+}
+
+void CallerSavePre::Rename1() {
+  std::stack<CgOccur*> occStack;
+  classCount = 1;
+  // iterate the occurrence according to its preorder dominator tree
+  for (CgOccur *occ : allOccs) {
+    while (!occStack.empty() && !occStack.top()->IsDominate(*dom, *occ)) {
+      occStack.pop();
+    }
+    switch (occ->GetOccType()) {
+      case kOccUse: {
+        if (occStack.empty()) {
+          // assign new class
+          occ->SetClassID(static_cast<int>(classCount++));
+          occStack.push(occ);
+          break;
+        }
+        CgOccur *topOccur = occStack.top();
+        if (topOccur->GetOccType() == kOccStore || topOccur->GetOccType() == kOccDef ||
+            topOccur->GetOccType() == kOccPhiocc) {
+          // assign new class
+          occ->SetClassID(topOccur->GetClassID());
+          occ->SetPrevVersionOccur(topOccur);
+          occStack.push(occ);
+          break;
+        } else if (topOccur->GetOccType() == kOccUse) {
+          occ->SetClassID(topOccur->GetClassID());
+          if (topOccur->GetDef() != nullptr) {
+            occ->SetDef(topOccur->GetDef());
+          } else {
+            occ->SetDef(topOccur);
+          }
+          break;
+        }
+        CHECK_FATAL(false, "unsupported occur type");
+        break;
+      }
+      case kOccPhiocc: {
+        // assign new class
+        occ->SetClassID(static_cast<int>(classCount++));
+        occStack.push(occ);
+        break;
+      }
+      case kOccPhiopnd: {
+        if (!occStack.empty()) {
+          CgOccur *topOccur = occStack.top();
+          auto *phiOpndOcc = static_cast<CgPhiOpndOcc*>(occ);
+          phiOpndOcc->SetDef(topOccur);
+          phiOpndOcc->SetClassID(topOccur->GetClassID());
+          if (topOccur->GetOccType() == kOccUse) {
+            phiOpndOcc->SetHasRealUse(true);
+          }
+        }
+        break;
+      }
+      case kOccDef: {
+        if (!occStack.empty()) {
+          CgOccur *topOccur = occStack.top();
+          if (topOccur->GetOccType() == kOccPhiocc) {
+            auto *phiTopOccur = static_cast<CgPhiOcc*>(topOccur);
+            phiTopOccur->SetIsDownSafe(false);
+          }
+        }
+
+        // assign new class
+        occ->SetClassID(static_cast<int>(classCount++));
+        occStack.push(occ);
+        break;
+      }
+      case kOccStore: {
+        if (!occStack.empty()) {
+          CgOccur *topOccur = occStack.top();
+          auto prevVersionOcc = topOccur->GetDef() ? topOccur->GetDef() : topOccur;
+          static_cast<CgStoreOcc *>(occ)->SetPrevVersionOccur(prevVersionOcc);
+          if (topOccur->GetOccType() == kOccPhiocc) {
+            auto *phiTopOccur = static_cast<CgPhiOcc*>(topOccur);
+            phiTopOccur->SetIsDownSafe(false);
+          }
+        }
+
+        // assign new class
+        occ->SetClassID(static_cast<int>(classCount++));
+        occStack.push(occ);
+        break;
+      }
+      case kOccExit: {
+        if (occStack.empty()) {
+          break;
+        }
+        CgOccur *topOccur = occStack.top();
+        if (topOccur->GetOccType() == kOccPhiocc) {
+          auto *phiTopOccur = static_cast<CgPhiOcc*>(topOccur);
+          phiTopOccur->SetIsDownSafe(false);
+        }
+        break;
+      }
+      default:
+        ASSERT(false, "should not be here");
+        break;
+    }
+  }
+  if (dump) {
+    PreWorkCand *curCand = workCand;
+    LogInfo::MapleLogger() << "========ssapre candidate " << curCand->GetIndex() << " after rename1============\n";
+    DumpWorkCandAndOcc();
+  }
+}
+
+void CallerSavePre::ComputeVarAndDfPhis() {
+  dfPhiDfns.clear();
+  PreWorkCand *workCand = GetWorkCand();
+  for (auto *realOcc : workCand->GetRealOccs()) {
+    BB *defBB = realOcc->GetBB();
+    GetIterDomFrontier(defBB, &dfPhiDfns);
+  }
+}
+
+void CallerSavePre::BuildWorkList() {
+  size_t numBBs = dom->GetDtPreOrderSize();
+  std::vector<LiveRange*> callSaveLrs;
+  for (auto it: regAllocator->GetLrMap()) {
+    LiveRange *lr = it.second;
+    if (lr == nullptr || lr->IsSpilled()) {
+      continue;
+    }
+    bool isCalleeReg = func->GetTargetRegInfo()->IsCalleeSavedReg(lr->GetAssignedRegNO());
+    if (lr->GetSplitLr() == nullptr && (lr->GetNumCall() > 0) && !isCalleeReg) {
+      callSaveLrs.emplace_back(lr);
+    }
+  }
+  const MapleVector<uint32> &preOrderDt = dom->GetDtPreOrder();
+  for (size_t i = 0; i < numBBs; ++i) {
+    BB *bb = func->GetBBFromID(preOrderDt[i]);
+    std::map<uint32, Insn*> insnMap;
+    FOR_BB_INSNS_SAFE(insn, bb, ninsn) {
+      insnMap.insert(std::make_pair(insn->GetId(), insn));
+    }
+    for (auto lr: callSaveLrs) {
+      LiveUnit *lu = lr->GetLiveUnitFromLuMap(bb->GetId());
+      RegOperand &opnd = func->GetOrCreateVirtualRegisterOperand(lr->GetRegNO());
+      if (lu != nullptr && ((lu->GetDefNum() > 0) || (lu->GetUseNum() > 0) || lu->HasCall())) {
+        const MapleMap<uint32, uint32> &refs = lr->GetRefs(bb->GetId());
+        for (auto it = refs.begin(); it != refs.end(); ++it) {
+          if ((it->second & kIsUse) > 0) {
+            (void)CreateRealOcc(*insnMap[it->first], opnd, kOccUse);
+          }
+          if ((it->second & kIsDef) > 0) {
+            (void)CreateRealOcc(*insnMap[it->first], opnd, kOccDef);
+          }
+          if ((it->second & kIsCall) > 0) {
+            Insn *callInsn = insnMap[it->first];
+            auto *targetOpnd = callInsn->GetCallTargetOperand();
+            if (CGOptions::DoIPARA() && targetOpnd->IsFuncNameOpnd()) {
+              FuncNameOperand *target = static_cast<FuncNameOperand*>(targetOpnd);
+              const MIRSymbol *funcSt = target->GetFunctionSymbol();
+              ASSERT(funcSt->GetSKind() == kStFunc, "funcst must be a function name symbol");
+              MIRFunction *mirFunc = funcSt->GetFunction();
+              if (mirFunc != nullptr && mirFunc->IsReferedRegsValid()) {
+                auto regSet = mirFunc->GetReferedRegs();
+                if (regSet.find(lr->GetAssignedRegNO()) == regSet.end()) {
+                  continue;
+                }
+              }
+            }
+            (void) CreateRealOcc(*callInsn, opnd, kOccStore);
+          }
+        }
+      }
+    }
+    if (bb->GetKind() == BB::kBBReturn) {
+      CreateExitOcc(*bb);
+    }
+  }
+}
+
+void CallerSavePre::ApplySSAPRE() {
+  // #0 build worklist
+  BuildWorkList();
+  uint32 cnt = 0;
+  constexpr uint32 preLimit = UINT32_MAX;
+  while (!workList.empty()) {
+    ++cnt;
+    if (cnt == preLimit) {
+      beyondLimit = true;
+    }
+    workCand = workList.front();
+    workCand->SetIndex(static_cast<int32>(cnt));
+    workLr = regAllocator->GetLiveRange(static_cast<RegOperand *>(workCand->GetTheOperand())->GetRegisterNumber());
+    ASSERT(workLr != nullptr, "exepected non null lr");
+    workList.pop_front();
+    if (workCand->GetRealOccs().empty()) {
+      continue;
+    }
+
+    allOccs.clear();
+    phiOccs.clear();
+    // #1 Insert PHI; results in allOccs and phiOccs
+    ComputeVarAndDfPhis();
+    CreateSortedOccs();
+    if (workCand->GetRealOccs().empty()) {
+      continue;
+    }
+    // #2 Rename
+    Rename1();
+    ComputeDS();
+    ComputeAvail();
+    CalLoadSites();
+    // #6 CodeMotion and recompute worklist based on newly occurrence
+    CodeMotion();
+    ASSERT(workLr->GetProcessed() == false, "exepected unprocessed");
+    workLr->SetProcessed();
+  }
+}
+
+void GraphColorRegAllocator::OptCallerSave() {
+  CallerSavePre callerSavePre(this, *cgFunc, domInfo, *memPool, *memPool, kLoadPre, UINT32_MAX);
+  callerSavePre.SetDump(GCRA_DUMP);
+  callerSavePre.ApplySSAPRE();
+}
+
+void GraphColorRegAllocator::SplitVregAroundLoop(const CGFuncLoops &loop, const std::vector<LiveRange*> &lrs,
+                                                 BB &headerPred, BB &exitSucc, const std::set<regno_t> &cands) {
+  size_t maxSplitCount = lrs.size() - intCalleeRegSet.size();
+  maxSplitCount = maxSplitCount > kMaxSplitCount ? kMaxSplitCount : maxSplitCount;
+  uint32 splitCount = 0;
+  auto it = cands.begin();
+  size_t candsSize = cands.size();
+  maxSplitCount = maxSplitCount > candsSize ? candsSize : maxSplitCount;
+  for (auto &lr: lrs) {
+    if (lr->IsSpilled()) {
+      continue;
+    }
+    if (!regInfo->IsCalleeSavedReg(lr->GetAssignedRegNO())) {
+      continue;
+    }
+    if (cgFunc->GetCG()->IsLmbc() && lr->GetIsSpSave()) {
+      continue;
+    }
+    bool hasRef = false;
+    for (auto *bb : loop.GetLoopMembers()) {
+      LiveUnit *lu = lr->GetLiveUnitFromLuMap(bb->GetId());
+      if (lu != nullptr && (lu->GetDefNum() != 0 || lu->GetUseNum() != 0)) {
+        hasRef = true;
+        break;
+      }
+    }
+    if (!hasRef) {
+      splitCount++;
+      RegOperand *ropnd = &cgFunc->GetOrCreateVirtualRegisterOperand(lr->GetRegNO());
+      RegOperand &phyOpnd = cgFunc->GetOpndBuilder()->CreatePReg(lr->GetAssignedRegNO(),
+          ropnd->GetSize(), lr->GetRegType());
+
+      auto &headerCom = cgFunc->GetOpndBuilder()->CreateComment("split around loop begin");
+      headerPred.AppendInsn(cgFunc->GetInsnBuilder()->BuildCommentInsn(headerCom));
+      Insn *last = headerPred.GetLastInsn();
+      (void)SpillOperand(*last, *ropnd, true, static_cast<RegOperand&>(phyOpnd));
+
+      auto &exitCom = cgFunc->GetOpndBuilder()->CreateComment("split around loop end");
+      exitSucc.InsertInsnBegin(cgFunc->GetInsnBuilder()->BuildCommentInsn(exitCom));
+      Insn *first = exitSucc.GetFirstInsn();
+      (void)SpillOperand(*first, *ropnd, false, static_cast<RegOperand&>(phyOpnd));
+
+      LiveRange *replacedLr = lrMap[*it];
+      replacedLr->SetAssignedRegNO(lr->GetAssignedRegNO());
+      replacedLr->SetSpilled(false);
+      ++it;
+    }
+    if (splitCount >= maxSplitCount) {
+      break;
+    }
+  }
+}
+
+bool GraphColorRegAllocator::LrGetBadReg(const LiveRange &lr) const {
+  if (lr.IsSpilled()) {
+    return true;
+  }
+  if (lr.GetNumCall() != 0 && !regInfo->IsCalleeSavedReg(lr.GetAssignedRegNO())) {
+    return true;
+  }
+  return false;
+}
+
+bool GraphColorRegAllocator::LoopNeedSplit(const CGFuncLoops &loop, std::set<regno_t> &cands) {
+  std::set<regno_t> regPressure;
+  const BB *header = loop.GetHeader();
+  const MapleSet<regno_t> &liveIn = header->GetLiveInRegNO();
+  std::set<BB*> loopBBs;
+  for (auto *bb : loop.GetLoopMembers()) {
+    loopBBs.insert(bb);
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (insn->GetId() == 0) {
+        continue;
+      }
+      uint32 opndNum = insn->GetOperandSize();
+      for (uint32 i = 0; i < opndNum; ++i) {
+        Operand &opnd = insn->GetOperand(i);
+        if (opnd.IsList()) {
+          continue;
+        } else if (opnd.IsMemoryAccessOperand()) {
+          auto &memOpnd = static_cast<MemOperand &>(opnd);
+          Operand *base = memOpnd.GetBaseRegister();
+          Operand *offset = memOpnd.GetIndexRegister();
+          if (base != nullptr && base->IsRegister()) {
+            RegOperand *regOpnd = static_cast<RegOperand *>(base);
+            regno_t regNO = regOpnd->GetRegisterNumber();
+            LiveRange *lr = GetLiveRange(regNO);
+            if (lr != nullptr && lr->GetRegType() == kRegTyInt && LrGetBadReg(*lr) &&
+                liveIn.find(regNO) == liveIn.end()) {
+              regPressure.insert(regOpnd->GetRegisterNumber());
+            }
+          }
+          if (offset != nullptr && offset->IsRegister()) {
+            RegOperand *regOpnd = static_cast<RegOperand *>(offset);
+            regno_t regNO = regOpnd->GetRegisterNumber();
+            LiveRange *lr = GetLiveRange(regNO);
+            if (lr != nullptr && lr->GetRegType() == kRegTyInt && LrGetBadReg(*lr) &&
+                liveIn.find(regNO) == liveIn.end()) {
+              regPressure.insert(regOpnd->GetRegisterNumber());
+            }
+          }
+        } else if (opnd.IsRegister()) {
+          auto &regOpnd = static_cast<RegOperand &>(opnd);
+          regno_t regNO = regOpnd.GetRegisterNumber();
+          LiveRange *lr = GetLiveRange(regNO);
+          if (lr != nullptr && lr->GetRegType() == kRegTyInt && LrGetBadReg(*lr) &&
+              liveIn.find(regNO) == liveIn.end()) {
+            regPressure.insert(regOpnd.GetRegisterNumber());
+          }
+        }
+      }
+    }
+  }
+  if (regPressure.size() != 0) {
+    for (auto reg: regPressure) {
+      LiveRange *lr = lrMap[reg];
+      std::vector<BB*> smember;
+      ForEachBBArrElem(lr->GetBBMember(), [this, &smember](uint32 bbID) { (void)smember.emplace_back(bbVec[bbID]); });
+      bool liveBeyondLoop = false;
+      for (auto bb: smember) {
+        if (loopBBs.find(bb) == loopBBs.end()) {
+          liveBeyondLoop = true;
+          break;
+        }
+      }
+      if (liveBeyondLoop) {
+        continue;
+      }
+      cands.insert(reg);
+    }
+    if (cands.empty()) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+void GraphColorRegAllocator::AnalysisLoop(const CGFuncLoops &loop) {
+  const BB *header = loop.GetHeader();
+  const MapleSet<regno_t> &liveIn = header->GetLiveInRegNO();
+  std::vector<LiveRange*> lrs;
+  size_t intCalleeNum = intCalleeRegSet.size();
+  if (loop.GetMultiEntries().size() != 0) {
+    return;
+  }
+  for (auto regno: liveIn) {
+    LiveRange *lr = GetLiveRange(regno);
+    if (lr != nullptr && lr->GetRegType() == kRegTyInt && lr->GetNumCall() != 0) {
+      lrs.emplace_back(lr);
+    }
+  }
+  if (lrs.size() < intCalleeNum) {
+    return;
+  }
+  bool hasCall = false;
+  std::set<BB*> loopBBs;
+  for (auto *bb : loop.GetLoopMembers()) {
+    if (bb->HasCall()) {
+      hasCall = true;
+    }
+    loopBBs.insert(bb);
+  }
+  if (!hasCall) {
+    return;
+  }
+  auto comparator = [=](const LiveRange *lr1, const LiveRange *lr2) -> bool {
+      return lr1->GetPriority() < lr2->GetPriority();
+  };
+  std::sort(lrs.begin(), lrs.end(), comparator);
+  const MapleVector<BB*> &exits = loop.GetExits();
+  std::set<BB*> loopExits;
+  for (auto &bb: exits) {
+    for (auto &succ: bb->GetSuccs()) {
+      if (loopBBs.find(succ) != loopBBs.end()) {
+        continue;
+      }
+      if (succ->IsSoloGoto() || succ->IsEmpty()) {
+        BB *realSucc = CGCFG::GetTargetSuc(*succ);
+        if (realSucc != nullptr) {
+          loopExits.insert(realSucc);
+        }
+      } else {
+        loopExits.insert(succ);
+      }
+    }
+  }
+  std::set<BB*> loopEntra;
+  for (auto &pred: header->GetPreds()) {
+    if (loopBBs.find(pred) != loopBBs.end()) {
+      continue;
+    }
+    loopEntra.insert(pred);
+  }
+  if (loopEntra.size() != 1 || loopExits.size() != 1) {
+    return;
+  }
+  BB *headerPred = *loopEntra.begin();
+  BB *exitSucc = *loopExits.begin();
+  if (headerPred->GetKind() != BB::kBBFallthru) {
+    return;
+  }
+  if (exitSucc->GetPreds().size() != loop.GetExits().size()) {
+    return;
+  }
+  std::set<regno_t> cands;
+  if (!LoopNeedSplit(loop, cands)) {
+    return;
+  }
+  SplitVregAroundLoop(loop, lrs, *headerPred, *exitSucc, cands);
+}
+void GraphColorRegAllocator::AnalysisLoopPressureAndSplit(const CGFuncLoops &loop) {
+  if (loop.GetInnerLoops().empty()) {
+    // only handle inner-most loop
+    AnalysisLoop(loop);
+    return;
+  }
+  for (const auto *lp : loop.GetInnerLoops()) {
+    AnalysisLoopPressureAndSplit(*lp);
+  }
+}
+
+/* Iterate through all instructions and change the vreg to preg. */
+void GraphColorRegAllocator::FinalizeRegisters() {
+  if (doMultiPass && hasSpill) {
+    if (GCRA_DUMP) {
+      LogInfo::MapleLogger() << "In this round, spill vregs : \n";
+      for (auto &it: std::as_const(lrMap)) {
+        LiveRange *lr = it.second;
+        if (lr->IsSpilled()) {
+          LogInfo::MapleLogger() << "R" << lr->GetRegNO() << " ";
+        }
+      }
+      LogInfo::MapleLogger() << "\n";
+    }
+    bool done = SpillLiveRangeForSpills();
+    if (done) {
+      FinalizeSpSaveReg();
+      return;
+    }
+  }
+  if (CLANG) {
+    if (!cgFunc->GetLoops().empty()) {
+      cgFunc->GetTheCFG()->InitInsnVisitor(*cgFunc);
+      for (const auto *lp : cgFunc->GetLoops()) {
+        AnalysisLoopPressureAndSplit(*lp);
+      }
+    }
+    OptCallerSave();
+  }
+  for (auto *bb : bfs->sortedBBs) {
+    FOR_BB_INSNS_SAFE(insn, bb, nextInsn) {
+      if (insn->IsImmaterialInsn()) {
+        continue;
+      }
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (insn->GetId() == 0) {
+        continue;
+      }
+
+      for (uint32 i = 0; i < kSpillMemOpndNum; ++i) {
+        operandSpilled[i] = false;
+      }
+
+      FinalizeRegisterInfo *fInfo = memPool->New<FinalizeRegisterInfo>(alloc);
+      MapleBitVector usedRegMask(regInfo->GetAllRegNum(), false, alloc.Adapter());
+      bool needProcces = FinalizeRegisterPreprocess(*fInfo, *insn, usedRegMask);
+      if (!needProcces) {
+        continue;
+      }
+      uint32 defSpillIdx = 0;
+      uint32 useSpillIdx = 0;
+      MemOperand *memOpnd = nullptr;
+      if (fInfo->GetBaseOperand()) {
+        memOpnd = static_cast<const MemOperand*>(fInfo->GetBaseOperand())->Clone(*cgFunc->GetMemoryPool());
+        insn->SetOperand(fInfo->GetMemOperandIdx(), *memOpnd);
+        Operand *base = memOpnd->GetBaseRegister();
+        ASSERT(base != nullptr, "nullptr check");
+        /* if base register is both defReg and useReg, defSpillIdx should also be increased. But it doesn't exist yet */
+        RegOperand *phyOpnd = GetReplaceOpnd(*insn, *base, useSpillIdx, usedRegMask, false);
+        if (phyOpnd != nullptr) {
+          memOpnd->SetBaseRegister(*phyOpnd);
+        }
+        if (!memOpnd->IsIntactIndexed()) {
+          (void)GetReplaceOpnd(*insn, *base, useSpillIdx, usedRegMask, true);
+        }
+      }
+      if (fInfo->GetOffsetOperand()) {
+        ASSERT(memOpnd != nullptr, "memOpnd should not be nullptr");
+        Operand *offset = memOpnd->GetIndexRegister();
+        RegOperand *phyOpnd = GetReplaceOpnd(*insn, *offset, useSpillIdx, usedRegMask, false);
+        if (phyOpnd != nullptr) {
+          memOpnd->SetIndexRegister(*phyOpnd);
+        }
+      }
+      for (const auto [idx, defOpnd] : fInfo->GetDefOperands()) {
+        if (insn->IsAsmInsn()) {
+          if (defOpnd->IsList()) {
+            auto *outList = static_cast<const ListOperand *>(defOpnd);
+            auto *srcOpndsNew = &cgFunc->GetOpndBuilder()->CreateList(
+                cgFunc->GetFuncScopeAllocator()->GetMemPool());
+            RegOperand *phyOpnd;
+            for (auto &opnd : outList->GetOperands()) {
+              if (opnd->IsPhysicalRegister()) {
+                phyOpnd = opnd;
+              } else {
+                phyOpnd = GetReplaceOpnd(*insn, *opnd, useSpillIdx, usedRegMask, true);
+              }
+              srcOpndsNew->PushOpnd(*phyOpnd);
+            }
+            insn->SetOperand(kAsmOutputListOpnd, *srcOpndsNew);
+            continue;
+          }
+        }
+        RegOperand *phyOpnd = nullptr;
+        if (insn->IsSpecialIntrinsic()) {
+          phyOpnd = GetReplaceOpnd(*insn, *defOpnd, useSpillIdx, usedRegMask, true);
+        } else {
+          phyOpnd = GetReplaceOpnd(*insn, *defOpnd, defSpillIdx, usedRegMask, true);
+        }
+        if (phyOpnd != nullptr) {
+          insn->SetOperand(idx, *phyOpnd);
+        }
+      }
+      for (const auto [idx, useOpnd] : fInfo->GetUseOperands()) {
+        if (insn->IsAsmInsn()) {
+          if (useOpnd->IsList()) {
+            auto *inList = static_cast<const ListOperand *>(useOpnd);
+            auto *srcOpndsNew = &cgFunc->GetOpndBuilder()->CreateList(
+                cgFunc->GetFuncScopeAllocator()->GetMemPool());
+            for (auto &opnd : inList->GetOperands()) {
+              if (!regInfo->IsVirtualRegister(opnd->GetRegisterNumber())) {
+                srcOpndsNew->PushOpnd(*opnd);
+              } else {
+                RegOperand *phyOpnd = GetReplaceOpnd(*insn, *opnd, useSpillIdx, usedRegMask, false);
+                srcOpndsNew->PushOpnd(*phyOpnd);
+              }
+            }
+            insn->SetOperand(kAsmInputListOpnd, *srcOpndsNew);
+            continue;
+          }
+        }
+        RegOperand *phyOpnd = GetReplaceOpnd(*insn, *useOpnd, useSpillIdx, usedRegMask, false);
+        if (phyOpnd != nullptr) {
+          insn->SetOperand(idx, *phyOpnd);
+        }
+      }
+      for (const auto [idx, useDefOpnd] : fInfo->GetUseDefOperands()) {
+        RegOperand *phyOpnd = nullptr;
+        if (insn->IsSpecialIntrinsic()) {
+          phyOpnd = GetReplaceUseDefOpnd(*insn, *useDefOpnd, useSpillIdx, usedRegMask);
+        } else {
+          phyOpnd = GetReplaceUseDefOpnd(*insn, *useDefOpnd, defSpillIdx, usedRegMask);
+        }
+        if (phyOpnd != nullptr) {
+          insn->SetOperand(idx, *phyOpnd);
+        }
+      }
+      if (insn->IsIntRegisterMov()) {
+        auto &reg1 = static_cast<RegOperand&>(insn->GetOperand(kInsnFirstOpnd));
+        auto &reg2 = static_cast<RegOperand&>(insn->GetOperand(kInsnSecondOpnd));
+        /* remove mov x0,x0 when it cast i32 to i64 */
+        if ((reg1.GetRegisterNumber() == reg2.GetRegisterNumber()) && (reg1.GetSize() >= reg2.GetSize())) {
+          bb->RemoveInsn(*insn);
+        }
+      }
+    }  /* insn */
+  }    /* BB */
+}
+
+void GraphColorRegAllocator::MarkCalleeSaveRegs() {
+  for (auto regNO : intCalleeUsed) {
+    cgFunc->AddtoCalleeSaved(regNO);
+  }
+  for (auto regNO : fpCalleeUsed) {
+    cgFunc->AddtoCalleeSaved(regNO);
+  }
+}
+
+bool GraphColorRegAllocator::AllocateRegisters() {
+#ifdef RANDOM_PRIORITY
+  /* Change this seed for different random numbers */
+  srand(0);
+#endif  /* RANDOM_PRIORITY */
+
+  if (GCRA_DUMP && doMultiPass) {
+    LogInfo::MapleLogger() << "\n round start: \n";
+    cgFunc->DumpCGIR();
+  }
+  /*
+   * we store both FP/LR if using FP or if not using FP, but func has a call
+   * Using FP, record it for saving
+   */
+  regInfo->Fini();
+
+#if DEBUG
+  int32 cnt = 0;
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      ++cnt;
+    }
+  }
+  ASSERT(cnt <= cgFunc->GetTotalNumberOfInstructions(), "Incorrect insn count");
+#endif
+  cgFunc->SetIsAfterRegAlloc();
+  /* EBO propgation extent the live range and might need to be turned off. */
+  Bfs localBfs(*cgFunc, *memPool);
+  bfs = &localBfs;
+  bfs->ComputeBlockOrder();
+
+  ComputeLiveRanges();
+
+  InitFreeRegPool();
+
+  BuildInterferenceGraph();
+
+  Separate();
+
+  SplitAndColor();
+
+#ifdef USE_LRA
+  if (doLRA) {
+    LocalRegisterAllocator(true);
+  }
+#endif  /* USE_LRA */
+
+  FinalizeRegisters();
+
+  MarkCalleeSaveRegs();
+
+  if (GCRA_DUMP) {
+    cgFunc->DumpCGIR();
+  }
+
+  bfs = nullptr; /* bfs is not utilized outside the function. */
+
+  if (doMultiPass && hasSpill) {
+    return false;
+  } else {
+    return true;
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_data_dep_base.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_data_dep_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..313aec1268e1b5d3ae7a9a954540c6580ae60cba
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_data_dep_base.cpp
@@ -0,0 +1,754 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_cg.h"
+#include "aarch64_operand.h"
+#include "pressure.h"
+#include "aarch64_data_dep_base.h"
+
+/* For building dependence graph, The entry is AArch64DataDepBase::Run. */
+namespace maplebe {
+void AArch64DataDepBase::ReplaceDepNodeWithNewInsn(DepNode &firstNode, DepNode &secondNode, Insn& newInsn,
+                                                   bool isFromClinit) const {
+  if (isFromClinit) {
+    firstNode.AddClinitInsn(*firstNode.GetInsn());
+    firstNode.AddClinitInsn(*secondNode.GetInsn());
+    firstNode.SetCfiInsns(secondNode.GetCfiInsns());
+  } else {
+    for (Insn *insn : secondNode.GetCfiInsns()) {
+      firstNode.AddCfiInsn(*insn);
+    }
+    for (Insn *insn : secondNode.GetComments()) {
+      firstNode.AddComments(*insn);
+    }
+    secondNode.ClearComments();
+  }
+  firstNode.SetInsn(newInsn);
+  Reservation *rev = mad.FindReservation(newInsn);
+  CHECK_FATAL(rev != nullptr, "reservation is nullptr.");
+  firstNode.SetReservation(*rev);
+  firstNode.SetUnits(rev->GetUnit());
+  firstNode.SetUnitNum(rev->GetUnitNum());
+  newInsn.SetDepNode(firstNode);
+}
+
+void AArch64DataDepBase::ClearDepNodeInfo(DepNode &depNode) const {
+  Insn &insn = cgFunc.GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_pseudo_none);
+  insn.SetDepNode(depNode);
+  Reservation *seRev = mad.FindReservation(insn);
+  depNode.SetInsn(insn);
+  depNode.SetType(kNodeTypeEmpty);
+  depNode.SetReservation(*seRev);
+  depNode.SetUnitNum(0);
+  depNode.ClearCfiInsns();
+  depNode.SetUnits(nullptr);
+}
+
+/* Combine (adrpldr & clinit_tail) to clinit. */
+void AArch64DataDepBase::CombineClinit(DepNode &firstNode, DepNode &secondNode, bool isAcrossSeparator) {
+  ASSERT(firstNode.GetInsn()->GetMachineOpcode() == MOP_adrp_ldr, "first insn should be adrpldr");
+  ASSERT(secondNode.GetInsn()->GetMachineOpcode() == MOP_clinit_tail, "second insn should be clinit_tail");
+  ASSERT(firstNode.GetCfiInsns().empty(), "There should not be any comment/cfi instructions between clinit.");
+  ASSERT(secondNode.GetComments().empty(), "There should not be any comment/cfi instructions between clinit.");
+  Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(
+      MOP_clinit, firstNode.GetInsn()->GetOperand(0), firstNode.GetInsn()->GetOperand(1));
+  newInsn.SetId(firstNode.GetInsn()->GetId());
+  /* Replace first node with new insn. */
+  ReplaceDepNodeWithNewInsn(firstNode, secondNode, newInsn, true);
+  /* Clear second node information. */
+  ClearDepNodeInfo(secondNode);
+  CombineDependence(firstNode, secondNode, isAcrossSeparator);
+}
+
+/*
+ * Combine memory access pair:
+ *   1.ldr to ldp.
+ *   2.str to stp.
+ */
+void AArch64DataDepBase::CombineMemoryAccessPair(DepNode &firstNode, DepNode &secondNode, bool useFirstOffset) {
+  ASSERT(firstNode.GetInsn(), "the insn of first Node should not be nullptr");
+  ASSERT(secondNode.GetInsn(), "the insn of second Node should not be nullptr");
+  MOperator thisMop = firstNode.GetInsn()->GetMachineOpcode();
+  MOperator mopPair = GetMopPair(thisMop);
+  ASSERT(mopPair != 0, "mopPair should not be zero");
+  Operand *opnd0 = nullptr;
+  Operand *opnd1 = nullptr;
+  Operand *opnd2 = nullptr;
+  if (useFirstOffset) {
+    opnd0 = &(firstNode.GetInsn()->GetOperand(0));
+    opnd1 = &(secondNode.GetInsn()->GetOperand(0));
+    opnd2 = &(firstNode.GetInsn()->GetOperand(1));
+  } else {
+    opnd0 = &(secondNode.GetInsn()->GetOperand(0));
+    opnd1 = &(firstNode.GetInsn()->GetOperand(0));
+    opnd2 = &(secondNode.GetInsn()->GetOperand(1));
+  }
+  Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(mopPair, *opnd0, *opnd1, *opnd2);
+  newInsn.SetId(firstNode.GetInsn()->GetId());
+  std::string newComment;
+  const MapleString &comment = firstNode.GetInsn()->GetComment();
+  if (comment.c_str() != nullptr) {
+    newComment += comment.c_str();
+  }
+  const MapleString &secondComment = secondNode.GetInsn()->GetComment();
+  if (secondComment.c_str() != nullptr) {
+    newComment += "  ";
+    newComment += secondComment.c_str();
+  }
+  if ((newComment.c_str() != nullptr) && (strlen(newComment.c_str()) > 0)) {
+    newInsn.SetComment(newComment);
+  }
+  /* Replace first node with new insn. */
+  ReplaceDepNodeWithNewInsn(firstNode, secondNode, newInsn, false);
+  /* Clear second node information. */
+  ClearDepNodeInfo(secondNode);
+  CombineDependence(firstNode, secondNode, false, true);
+}
+
+bool AArch64DataDepBase::IsFrameReg(const RegOperand &opnd) const {
+  return (opnd.GetRegisterNumber() == RFP) || (opnd.GetRegisterNumber() == RSP);
+}
+
+MemOperand *AArch64DataDepBase::BuildNextMemOperandByByteSize(const MemOperand &aarchMemOpnd, uint32 byteSize) const {
+  MemOperand *nextMemOpnd = aarchMemOpnd.Clone(memPool);
+  Operand *nextOfstOpnd = nextMemOpnd->GetOffsetImmediate()->Clone(memPool);
+  auto *aarchNextOfstOpnd = static_cast<OfstOperand*>(nextOfstOpnd);
+  CHECK_NULL_FATAL(aarchNextOfstOpnd);
+  auto offsetVal = static_cast<int32>(aarchNextOfstOpnd->GetOffsetValue());
+  aarchNextOfstOpnd->SetOffsetValue(offsetVal + static_cast<int32>(byteSize));
+  nextMemOpnd->SetOffsetOperand(*aarchNextOfstOpnd);
+  return nextMemOpnd;
+}
+
+/* Get the second memory access operand of stp/ldp instructions. */
+MemOperand *AArch64DataDepBase::GetNextMemOperand(const Insn &insn, const MemOperand &aarchMemOpnd) const {
+  MemOperand *nextMemOpnd = nullptr;
+  switch (insn.GetMachineOpcode()) {
+    case MOP_wldp:
+    case MOP_sldp:
+    case MOP_xldpsw:
+    case MOP_wstp:
+    case MOP_sstp: {
+      nextMemOpnd = BuildNextMemOperandByByteSize(aarchMemOpnd, k4ByteSize);
+      break;
+    }
+    case MOP_xldp:
+    case MOP_dldp:
+    case MOP_xstp:
+    case MOP_dstp: {
+      nextMemOpnd = BuildNextMemOperandByByteSize(aarchMemOpnd, k8ByteSize);
+      break;
+    }
+    default:
+      break;
+  }
+
+  return nextMemOpnd;
+}
+
+/*
+ * Build data dependence of symbol memory access.
+ * Memory access with symbol must be a heap memory access.
+ */
+void AArch64DataDepBase::BuildDepsAccessStImmMem(Insn &insn, bool isDest) {
+  if (isDest) {
+    AddDependence4InsnInVectorByType(curCDGNode->GetHeapUseInsns(), insn, kDependenceTypeAnti);
+    /* Build output dependence */
+    AddDependence4InsnInVectorByType(curCDGNode->GetHeapDefInsns(), insn, kDependenceTypeOutput);
+    curCDGNode->AddHeapDefInsn(&insn);
+  } else {
+    AddDependence4InsnInVectorByType(curCDGNode->GetHeapDefInsns(), insn, kDependenceTypeTrue);
+    curCDGNode->AddHeapUseInsn(&insn);
+  }
+  Insn *membarInsn = curCDGNode->GetMembarInsn();
+  if (membarInsn != nullptr) {
+    AddDependence(*membarInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeMembar);
+  }
+}
+
+/* Build data dependence of memory bars instructions */
+void AArch64DataDepBase::BuildDepsMemBar(Insn &insn) {
+  if (IsIntraBlockAnalysis()) {
+    AddDependence4InsnInVectorByTypeAndCmp(curCDGNode->GetStackUseInsns(), insn, kDependenceTypeMembar);
+    AddDependence4InsnInVectorByTypeAndCmp(curCDGNode->GetHeapUseInsns(), insn, kDependenceTypeMembar);
+    AddDependence4InsnInVectorByTypeAndCmp(curCDGNode->GetStackDefInsns(), insn, kDependenceTypeMembar);
+    AddDependence4InsnInVectorByTypeAndCmp(curCDGNode->GetHeapDefInsns(), insn, kDependenceTypeMembar);
+  } else {
+    BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), true, kDependenceTypeMembar, kStackUses);
+    BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), true, kDependenceTypeMembar, kHeapUses);
+    BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), true, kDependenceTypeMembar, kStackDefs);
+    BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), true, kDependenceTypeMembar, kHeapDefs);
+  }
+  curCDGNode->SetMembarInsn(&insn);
+}
+
+/* Build data dependence of stack memory and heap memory uses */
+void AArch64DataDepBase::BuildDepsUseMem(Insn &insn, MemOperand &aarchMemOpnd) {
+  aarchMemOpnd.SetAccessSize(insn.GetMemoryByteSize());
+  RegOperand *baseRegister = aarchMemOpnd.GetBaseRegister();
+  MemOperand *nextMemOpnd = GetNextMemOperand(insn, aarchMemOpnd);
+  if (IsIntraBlockAnalysis()) {
+    /* Stack memory address */
+    MapleVector<Insn*> stackDefs = curCDGNode->GetStackDefInsns();
+    for (auto defInsn : stackDefs) {
+      if (defInsn->IsCall() || NeedBuildDepsMem(aarchMemOpnd, nextMemOpnd, *defInsn)) {
+        AddDependence(*defInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeTrue);
+      }
+    }
+    /* Heap memory address */
+    MapleVector<Insn*> heapDefs = curCDGNode->GetHeapDefInsns();
+    AddDependence4InsnInVectorByType(heapDefs, insn, kDependenceTypeTrue);
+  } else {
+    BuildInterBlockMemDefUseDependency(*insn.GetDepNode(), aarchMemOpnd, nextMemOpnd, false);
+  }
+  if (((baseRegister != nullptr) && IsFrameReg(*baseRegister)) || aarchMemOpnd.IsStackMem()) {
+    curCDGNode->AddStackUseInsn(&insn);
+  } else {
+    curCDGNode->AddHeapUseInsn(&insn);
+  }
+  Insn *membarInsn = curCDGNode->GetMembarInsn();
+  if (membarInsn != nullptr) {
+    AddDependence(*membarInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeMembar);
+  } else if (!IsIntraBlockAnalysis()) {
+    BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), false,
+                                             kDependenceTypeMembar, kMembar);
+  }
+}
+
+/* Build data dependence of stack memory and heap memory definitions */
+void AArch64DataDepBase::BuildDepsDefMem(Insn &insn, MemOperand &aarchMemOpnd) {
+  RegOperand *baseRegister = aarchMemOpnd.GetBaseRegister();
+  ASSERT(baseRegister != nullptr, "baseRegister shouldn't be null here");
+  MemOperand *nextMemOpnd = GetNextMemOperand(insn, aarchMemOpnd);
+  aarchMemOpnd.SetAccessSize(insn.GetMemoryByteSize());
+
+  if (IsIntraBlockAnalysis()) {
+    /* Build anti dependence */
+    MapleVector<Insn*> stackUses = curCDGNode->GetStackUseInsns();
+    for (auto *stackUse : stackUses) {
+      if (NeedBuildDepsMem(aarchMemOpnd, nextMemOpnd, *stackUse)) {
+        AddDependence(*stackUse->GetDepNode(), *insn.GetDepNode(), kDependenceTypeAnti);
+      }
+    }
+    /* Build output dependence */
+    MapleVector<Insn*> stackDefs = curCDGNode->GetStackDefInsns();
+    for (auto stackDef : stackDefs) {
+      if (stackDef->IsCall() || NeedBuildDepsMem(aarchMemOpnd, nextMemOpnd, *stackDef)) {
+        AddDependence(*stackDef->GetDepNode(), *insn.GetDepNode(), kDependenceTypeOutput);
+      }
+    }
+    /* Heap memory
+   * Build anti dependence
+   */
+    MapleVector<Insn*> heapUses = curCDGNode->GetHeapUseInsns();
+    AddDependence4InsnInVectorByType(heapUses, insn, kDependenceTypeAnti);
+    /* Build output dependence */
+    MapleVector<Insn*> heapDefs = curCDGNode->GetHeapDefInsns();
+    AddDependence4InsnInVectorByType(heapDefs, insn, kDependenceTypeOutput);
+
+    /* Memory definition can not across may-throw insns */
+    MapleVector<Insn*> mayThrows = curCDGNode->GetMayThrowInsns();
+    AddDependence4InsnInVectorByType(mayThrows, insn, kDependenceTypeThrow);
+  } else {
+    BuildInterBlockMemDefUseDependency(*insn.GetDepNode(), aarchMemOpnd, nextMemOpnd, true);
+    BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), false, kDependenceTypeThrow, kMayThrows);
+  }
+
+  if (baseRegister->GetRegisterNumber() == RSP) {
+    Insn *lastCallInsn = curCDGNode->GetLastCallInsn();
+    if (lastCallInsn != nullptr) {
+      /* Build a dependence between stack passed arguments and call */
+      AddDependence(*lastCallInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeControl);
+    } else if (!IsIntraBlockAnalysis()) {
+      BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), false, kDependenceTypeControl, kLastCall);
+    }
+  }
+
+  Insn *membarInsn = curCDGNode->GetMembarInsn();
+  if (membarInsn != nullptr) {
+    AddDependence(*membarInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeMembar);
+  } else if (!IsIntraBlockAnalysis()) {
+    BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), false, kDependenceTypeMembar, kMembar);
+  }
+
+  /* Update cur cdgNode info */
+  if (IsFrameReg(*baseRegister) || aarchMemOpnd.IsStackMem()) {
+    curCDGNode->AddStackDefInsn(&insn);
+  } else {
+    curCDGNode->AddHeapDefInsn(&insn);
+  }
+}
+
+static bool NoAlias(const MemOperand &leftOpnd, const MemOperand &rightOpnd) {
+  if (leftOpnd.GetAddrMode() == MemOperand::kAddrModeBOi &&
+      rightOpnd.GetAddrMode() == MemOperand::kAddrModeBOi && leftOpnd.GetIndexOpt() == MemOperand::kIntact &&
+      rightOpnd.GetIndexOpt() == MemOperand::kIntact) {
+    if (leftOpnd.GetBaseRegister()->GetRegisterNumber() == RFP ||
+        rightOpnd.GetBaseRegister()->GetRegisterNumber() == RFP) {
+      Operand *ofstOpnd = leftOpnd.GetOffsetOperand();
+      Operand *rofstOpnd = rightOpnd.GetOffsetOperand();
+      ASSERT(ofstOpnd != nullptr, "offset operand should not be null.");
+      ASSERT(rofstOpnd != nullptr, "offset operand should not be null.");
+      auto *ofst = static_cast<ImmOperand*>(ofstOpnd);
+      auto *rofst = static_cast<ImmOperand*>(rofstOpnd);
+      ASSERT(ofst != nullptr, "CG internal error, invalid type.");
+      ASSERT(rofst != nullptr, "CG internal error, invalid type.");
+      return (!ofst->ValueEquals(*rofst));
+    }
+  }
+  return false;
+}
+
+static bool NoOverlap(const MemOperand &leftOpnd, const MemOperand &rightOpnd) {
+  if (leftOpnd.GetAddrMode() != MemOperand::kAddrModeBOi ||
+      rightOpnd.GetAddrMode() != MemOperand::kAddrModeBOi ||
+      leftOpnd.GetIndexOpt() != MemOperand::kIntact ||
+      rightOpnd.GetIndexOpt() != MemOperand::kIntact) {
+    return false;
+  }
+  if (leftOpnd.GetBaseRegister()->GetRegisterNumber() != RFP ||
+      rightOpnd.GetBaseRegister()->GetRegisterNumber() != RFP) {
+    return false;
+  }
+  int64 ofset1 = leftOpnd.GetOffsetOperand()->GetValue();
+  int64 ofset2 = rightOpnd.GetOffsetOperand()->GetValue();
+  if (ofset1 < ofset2) {
+    return ((ofset1 + static_cast<int8>(leftOpnd.GetAccessSize())) <= ofset2);
+  } else {
+    return ((ofset2 + static_cast<int8>(rightOpnd.GetAccessSize())) <= ofset1);
+  }
+}
+
+/* Return true if memInsn's memOpnd no alias with memOpnd and nextMemOpnd */
+bool AArch64DataDepBase::NeedBuildDepsMem(const MemOperand &memOpnd,
+                                          const MemOperand *nextMemOpnd,
+                                          const Insn &memInsn) const {
+  auto *memOpndOfmemInsn = static_cast<MemOperand*>(memInsn.GetMemOpnd());
+  if (!NoAlias(memOpnd, *memOpndOfmemInsn) ||
+      ((nextMemOpnd != nullptr) && !NoAlias(*nextMemOpnd, *memOpndOfmemInsn))) {
+    return true;
+  }
+  if (cgFunc.GetMirModule().GetSrcLang() == kSrcLangC && !memInsn.IsCall()) {
+    static_cast<MemOperand*>(memInsn.GetMemOpnd())->SetAccessSize(memInsn.GetMemoryByteSize());
+    return (!NoOverlap(memOpnd, *memOpndOfmemInsn));
+  }
+  MemOperand *nextMemOpndOfmemInsn = GetNextMemOperand(memInsn, *memOpndOfmemInsn);
+  if (nextMemOpndOfmemInsn != nullptr) {
+    if (!NoAlias(memOpnd, *nextMemOpndOfmemInsn) ||
+        ((nextMemOpnd != nullptr) && !NoAlias(*nextMemOpnd, *nextMemOpndOfmemInsn))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/*
+ * Build dependence of call instructions.
+ * caller-saved physical registers will be defined by a call instruction.
+ * also a conditional register may be modified by a call.
+ */
+void AArch64DataDepBase::BuildCallerSavedDeps(Insn &insn) {
+  /* Build anti dependence and output dependence. */
+  for (uint32 i = R0; i <= R7; ++i) {
+    BuildDepsDefReg(insn, i);
+  }
+  for (uint32 i = V0; i <= V7; ++i) {
+    BuildDepsDefReg(insn, i);
+  }
+  if (!beforeRA) {
+    for (uint32 i = R8; i <= R18; ++i) {
+      BuildDepsDefReg(insn, i);
+    }
+    for (uint32 i = RLR; i <= RSP; ++i) {
+      BuildDepsUseReg(insn, i);
+    }
+    for (uint32 i = V16; i <= V31; ++i) {
+      BuildDepsDefReg(insn, i);
+    }
+  }
+  /* For condition operand, such as NE, EQ, and so on. */
+  if (cgFunc.GetRflag() != nullptr) {
+    BuildDepsDefReg(insn, kRFLAG);
+  }
+}
+
+/*
+ * Build dependence between stack-define-instruction that deal with call-insn's args and a call-instruction.
+ * insn : a call instruction (call/tail-call)
+ */
+void AArch64DataDepBase::BuildStackPassArgsDeps(Insn &insn) {
+  MapleVector<Insn*> stackDefs = curCDGNode->GetStackDefInsns();
+  for (auto stackDefInsn : stackDefs) {
+    if (stackDefInsn->IsCall()) {
+      continue;
+    }
+    Operand *opnd = stackDefInsn->GetMemOpnd();
+    ASSERT(opnd->IsMemoryAccessOperand(), "make sure opnd is memOpnd");
+    auto *memOpnd = static_cast<MemOperand*>(opnd);
+    RegOperand *baseReg = memOpnd->GetBaseRegister();
+    if ((baseReg != nullptr) && (baseReg->GetRegisterNumber() == RSP)) {
+      AddDependence(*stackDefInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeControl);
+    }
+  }
+}
+
+/* Some insns may dirty all stack memory, such as "bl MCC_InitializeLocalStackRef" */
+void AArch64DataDepBase::BuildDepsDirtyStack(Insn &insn) {
+  /* Build anti dependence */
+  MapleVector<Insn*> stackUses = curCDGNode->GetStackUseInsns();
+  AddDependence4InsnInVectorByType(stackUses, insn, kDependenceTypeAnti);
+  /* Build output dependence */
+  MapleVector<Insn*> stackDefs = curCDGNode->GetStackDefInsns();
+  AddDependence4InsnInVectorByType(stackDefs, insn, kDependenceTypeOutput);
+  curCDGNode->AddStackDefInsn(&insn);
+}
+
+/* Some call insns may use all stack memory, such as "bl MCC_CleanupLocalStackRef_NaiveRCFast" */
+void AArch64DataDepBase::BuildDepsUseStack(Insn &insn) {
+  /* Build true dependence */
+  MapleVector<Insn*> stackDefs = curCDGNode->GetStackDefInsns();
+  AddDependence4InsnInVectorByType(stackDefs, insn, kDependenceTypeTrue);
+}
+
+/* Some insns may dirty all heap memory, such as a call insn */
+void AArch64DataDepBase::BuildDepsDirtyHeap(Insn &insn) {
+  /* Build anti dependence */
+  MapleVector<Insn*> heapUses = curCDGNode->GetHeapUseInsns();
+  AddDependence4InsnInVectorByType(heapUses, insn, kDependenceTypeAnti);
+  /* Build output dependence */
+  MapleVector<Insn*> heapDefs = curCDGNode->GetHeapDefInsns();
+  AddDependence4InsnInVectorByType(heapDefs, insn, kDependenceTypeOutput);
+  Insn *membarInsn = curCDGNode->GetMembarInsn();
+  if (membarInsn != nullptr) {
+    AddDependence(*membarInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeMembar);
+  }
+  curCDGNode->AddHeapDefInsn(&insn);
+}
+
+/* Analysis live-in registers in catch bb and cleanup bb */
+void AArch64DataDepBase::AnalysisAmbiInsns(BB &bb) {
+  curCDGNode->SetHasAmbiRegs(false);
+  if (bb.GetEhSuccs().empty()) {
+    return;
+  }
+  MapleSet<regno_t> &ehInRegs = curCDGNode->GetEhInRegs();
+
+  /* Union all catch bb */
+  for (auto succBB : bb.GetEhSuccs()) {
+    const MapleSet<regno_t> &liveInRegSet = succBB->GetLiveInRegNO();
+    (void)set_union(liveInRegSet.begin(), liveInRegSet.end(), ehInRegs.begin(), ehInRegs.end(),
+                    inserter(ehInRegs, ehInRegs.begin()));
+  }
+
+  /* Union cleanup entry bb */
+  const MapleSet<regno_t> &regNOSet = cgFunc.GetCleanupBB()->GetLiveInRegNO();
+  (void)std::set_union(regNOSet.begin(), regNOSet.end(), ehInRegs.begin(), ehInRegs.end(),
+                       inserter(ehInRegs, ehInRegs.begin()));
+
+  /* Subtract R0 and R1, that is defined by eh runtime */
+  (void)ehInRegs.erase(R0);
+  (void)ehInRegs.erase(R1);
+  if (ehInRegs.empty()) {
+    return;
+  }
+  curCDGNode->SetHasAmbiRegs(true);
+}
+
+/*
+ * It is a yieldpoint if loading from a dedicated
+ * register holding polling page address:
+ * ldr  wzr, [RYP]
+ */
+static bool IsYieldPoint(const Insn &insn) {
+  if (insn.IsLoad() && !insn.IsLoadLabel()) {
+    auto mem = static_cast<MemOperand*>(insn.GetMemOpnd());
+    return (mem != nullptr && mem->GetBaseRegister() != nullptr && mem->GetBaseRegister()->GetRegisterNumber() == RYP);
+  }
+  return false;
+}
+
+/*
+ * Build data dependence of memory operand.
+ * insn : an instruction with the memory access operand.
+ * opnd : the memory access operand.
+ * regProp : operand property of the memory access operand.
+ */
+void AArch64DataDepBase::BuildMemOpndDependency(Insn &insn, Operand &opnd, const OpndDesc &regProp) {
+  ASSERT(opnd.IsMemoryAccessOperand(), "opnd must be memory Operand");
+  auto *memOpnd = static_cast<MemOperand*>(&opnd);
+  RegOperand *baseRegister = memOpnd->GetBaseRegister();
+  if (baseRegister != nullptr) {
+    regno_t regNO = baseRegister->GetRegisterNumber();
+    BuildDepsUseReg(insn, regNO);
+    if ((memOpnd->GetAddrMode() == MemOperand::kAddrModeBOi) &&
+        (memOpnd->IsPostIndexed() || memOpnd->IsPreIndexed())) {
+      /* Base operand has changed. */
+      BuildDepsDefReg(insn, regNO);
+    }
+  }
+  RegOperand *indexRegister = memOpnd->GetIndexRegister();
+  if (indexRegister != nullptr) {
+    regno_t regNO = indexRegister->GetRegisterNumber();
+    BuildDepsUseReg(insn, regNO);
+  }
+  if (regProp.IsUse()) {
+    BuildDepsUseMem(insn, *memOpnd);
+  } else {
+    BuildDepsDefMem(insn, *memOpnd);
+    BuildDepsAmbiInsn(insn);
+  }
+  if (IsYieldPoint(insn)) {
+    BuildDepsMemBar(insn);
+    BuildDepsDefReg(insn, kRFLAG);
+  }
+}
+
+/* Build Dependency for each operand of insn */
+void AArch64DataDepBase::BuildOpndDependency(Insn &insn) {
+  const InsnDesc* md = insn.GetDesc();
+  MOperator mOp = insn.GetMachineOpcode();
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    const OpndDesc *regProp = md->opndMD[i];
+    if (opnd.IsMemoryAccessOperand()) {
+      BuildMemOpndDependency(insn, opnd, *regProp);
+    } else if (opnd.IsStImmediate()) {
+      if (mOp != MOP_xadrpl12) {
+        BuildDepsAccessStImmMem(insn, false);
+      }
+    } else if (opnd.IsRegister()) {
+      auto &regOpnd = static_cast<RegOperand&>(opnd);
+      regno_t regNO = regOpnd.GetRegisterNumber();
+      if (regProp->IsUse()) {
+        BuildDepsUseReg(insn, regNO);
+      }
+      if (regProp->IsDef()) {
+        BuildDepsDefReg(insn, regNO);
+      }
+    } else if (opnd.IsConditionCode()) {
+      /* For condition operand, such as NE, EQ, and so on. */
+      if (regProp->IsUse()) {
+        BuildDepsUseReg(insn, kRFLAG);
+        BuildDepsBetweenControlRegAndCall(insn, false);
+      }
+      if (regProp->IsDef()) {
+        BuildDepsDefReg(insn, kRFLAG);
+        BuildDepsBetweenControlRegAndCall(insn, true);
+      }
+    } else if (opnd.IsList()) {
+      auto &listOpnd = static_cast<const ListOperand&>(opnd);
+      /* Build true dependences */
+      for (auto &lst : listOpnd.GetOperands()) {
+        regno_t regNO = lst->GetRegisterNumber();
+        BuildDepsUseReg(insn, regNO);
+      }
+    }
+  }
+}
+
+static bool IsLazyLoad(MOperator op) {
+  return (op == MOP_lazy_ldr) || (op == MOP_lazy_ldr_static) || (op == MOP_lazy_tail);
+}
+
+/*
+ * Build dependences in some special issue (stack/heap/throw/clinit/lazy binding/control flow).
+ * insn :  an instruction.
+ * depNode : insn's depNode.
+ * nodes : the dependence nodes include insn's depNode.
+ */
+void AArch64DataDepBase::BuildSpecialInsnDependency(Insn &insn, const MapleVector<DepNode*> &nodes) {
+  const InsnDesc *md = insn.GetDesc();
+  MOperator mOp = insn.GetMachineOpcode();
+  if (insn.IsCall() || insn.IsTailCall()) {
+    /* Caller saved registers */
+    BuildCallerSavedDeps(insn);
+    BuildStackPassArgsDeps(insn);
+
+    if (mOp == MOP_xbl) {
+      auto &target = static_cast<FuncNameOperand&>(insn.GetOperand(0));
+      if ((target.GetName() == "MCC_InitializeLocalStackRef") ||
+          (target.GetName() == "MCC_ClearLocalStackRef") ||
+          (target.GetName() == "MCC_DecRefResetPair")) {
+        /* Write stack memory */
+        BuildDepsDirtyStack(insn);
+      } else if ((target.GetName() == "MCC_CleanupLocalStackRef_NaiveRCFast") ||
+                 (target.GetName() == "MCC_CleanupLocalStackRefSkip_NaiveRCFast") ||
+                 (target.GetName() == "MCC_CleanupLocalStackRefSkip")) {
+        /* Use Stack Memory */
+        BuildDepsUseStack(insn);
+      } else if (cgFunc.GetMirModule().GetSrcLang() == kSrcLangC) {
+        /* potential C aliasing */
+        BuildDepsDirtyStack(insn);
+      }
+    }
+    BuildDepsDirtyHeap(insn);
+    BuildDepsAmbiInsn(insn);
+    BuildDepsLastCallInsn(insn);
+  } else if (insn.IsClinit() || IsLazyLoad(insn.GetMachineOpcode()) ||
+             insn.GetMachineOpcode() == MOP_arrayclass_cache_ldr) {
+    BuildDepsDirtyHeap(insn);
+    BuildDepsDefReg(insn, kRFLAG);
+    if (insn.GetMachineOpcode() != MOP_adrp_ldr) {
+      BuildDepsDefReg(insn, R16);
+      BuildDepsDefReg(insn, R17);
+    }
+  } else if ((mOp == MOP_xret) || md->IsBranch()) {
+    BuildDepsControlAll(insn, nodes);
+  } else if (insn.IsMemAccessBar()) {
+    BuildDepsMemBar(insn);
+  } else if (insn.IsSpecialIntrinsic()) {
+    BuildDepsDirtyHeap(insn);
+  }
+}
+
+void AArch64DataDepBase::UpdateRegUseAndDef(Insn &insn, const DepNode &depNode, MapleVector<DepNode*> &nodes) {
+  /* Update reg use */
+  const auto &useRegnos = depNode.GetUseRegnos();
+  if (beforeRA) {
+    depNode.InitRegUsesSize(useRegnos.size());
+  }
+  for (auto regNO : useRegnos) {
+    // Update reg use for cur depInfo
+    curCDGNode->AppendUseInsnChain(regNO, &insn, memPool, beforeRA);
+    if (beforeRA) {
+      CHECK_FATAL(curCDGNode->GetUseInsnChain(regNO)->insn != nullptr, "get useInsn failed");
+      depNode.SetRegUses(*curCDGNode->GetUseInsnChain(regNO));
+      if (curCDGNode->GetLatestDefInsn(regNO) == nullptr) {
+        curCDGNode->SetLatestDefInsn(regNO, nodes[separatorIndex]->GetInsn());
+        nodes[separatorIndex]->AddDefReg(regNO);
+        nodes[separatorIndex]->SetRegDefs(nodes[separatorIndex]->GetDefRegnos().size(),
+                                          curCDGNode->GetUseInsnChain(regNO));
+      }
+    }
+  }
+
+  /* Update reg def */
+  const auto &defRegnos = depNode.GetDefRegnos();
+  size_t i = 0;
+  if (beforeRA) {
+    depNode.InitRegDefsSize(defRegnos.size());
+  }
+  for (const auto regNO : defRegnos) {
+    // Update reg def for cur depInfo
+    curCDGNode->SetLatestDefInsn(regNO, &insn);
+    curCDGNode->ClearUseInsnChain(regNO);
+    if (beforeRA) {
+      depNode.SetRegDefs(i, nullptr);
+      if (regNO >= R0 && regNO <= R3) {
+        depNode.SetHasPreg(true);
+      } else if (regNO == R8) {
+        depNode.SetHasNativeCallRegister(true);
+      }
+    }
+    ++i;
+  }
+}
+
+/* Build a pseudo node to separate data dependence graph */
+DepNode *AArch64DataDepBase::BuildSeparatorNode() {
+  Insn &pseudoSepInsn = cgFunc.GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_pseudo_dependence_seperator);
+  auto *separatorNode = memPool.New<DepNode>(pseudoSepInsn, alloc);
+  separatorNode->SetType(kNodeTypeSeparator);
+  pseudoSepInsn.SetDepNode(*separatorNode);
+  if (beforeRA) {
+    auto *regPressure = memPool.New<RegPressure>(alloc);
+    separatorNode->SetRegPressure(*regPressure);
+    separatorNode->InitPressure();
+  }
+  return separatorNode;
+}
+
+void AArch64DataDepBase::BuildInterBlockMemDefUseDependency(DepNode &depNode, MemOperand &memOpnd,
+                                                            MemOperand *nextMemOpnd, bool isMemDef) {
+  CHECK_FATAL(!IsIntraBlockAnalysis(), "must be inter block data dependence analysis");
+  BB *curBB = curCDGNode->GetBB();
+  CHECK_FATAL(curBB != nullptr, "get bb from cdgNode failed");
+  CDGRegion *curRegion = curCDGNode->GetRegion();
+  CHECK_FATAL(curRegion != nullptr, "get region from cdgNode failed");
+  std::vector<bool> visited(curRegion->GetMaxBBIdInRegion(), false);
+  if (isMemDef) {
+    BuildPredPathMemDefDependencyDFS(*curBB, visited, depNode, memOpnd, nextMemOpnd);
+  } else {
+    BuildPredPathMemUseDependencyDFS(*curBB, visited, depNode, memOpnd, nextMemOpnd);
+  }
+}
+
+void AArch64DataDepBase::BuildPredPathMemDefDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                                          MemOperand &memOpnd, MemOperand *nextMemOpnd) {
+  if (visited[curBB.GetId()]) {
+    return;
+  }
+  CDGNode *cdgNode = curBB.GetCDGNode();
+  CHECK_FATAL(cdgNode != nullptr, "get cdgNode from bb failed");
+  CDGRegion *curRegion = cdgNode->GetRegion();
+  CHECK_FATAL(curRegion != nullptr, "get region from cdgNode failed");
+  if (curRegion->GetRegionId() != curCDGNode->GetRegion()->GetRegionId()) {
+    return;
+  }
+  visited[curBB.GetId()] = true;
+  MapleVector<Insn*> stackUses = cdgNode->GetStackUseInsns();
+  for (auto *stackUse : stackUses) {
+    if (NeedBuildDepsMem(memOpnd, nextMemOpnd, *stackUse)) {
+      AddDependence(*stackUse->GetDepNode(), depNode, kDependenceTypeAnti);
+    }
+  }
+  /* Build output dependence */
+  MapleVector<Insn*> stackDefs = cdgNode->GetStackDefInsns();
+  for (auto stackDef : stackDefs) {
+    if (stackDef->IsCall() || NeedBuildDepsMem(memOpnd, nextMemOpnd, *stackDef)) {
+      AddDependence(*stackDef->GetDepNode(), depNode, kDependenceTypeOutput);
+    }
+  }
+  /* Heap memory
+   * Build anti dependence
+   */
+  MapleVector<Insn*> heapUses = curCDGNode->GetHeapUseInsns();
+  AddDependence4InsnInVectorByType(heapUses, *depNode.GetInsn(), kDependenceTypeAnti);
+  /* Build output dependence */
+  MapleVector<Insn*> heapDefs = curCDGNode->GetHeapDefInsns();
+  AddDependence4InsnInVectorByType(heapDefs, *depNode.GetInsn(), kDependenceTypeOutput);
+  for (auto predIt = curBB.GetPredsBegin(); predIt != curBB.GetPredsEnd(); ++predIt) {
+    BuildPredPathMemDefDependencyDFS(**predIt, visited, depNode, memOpnd, nextMemOpnd);
+  }
+}
+
+void AArch64DataDepBase::BuildPredPathMemUseDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                                          MemOperand &memOpnd, MemOperand *nextMemOpnd) {
+  if (visited[curBB.GetId()]) {
+    return;
+  }
+  CDGNode *cdgNode = curBB.GetCDGNode();
+  CHECK_FATAL(cdgNode != nullptr, "get cdgNode from bb failed");
+  CDGRegion *curRegion = cdgNode->GetRegion();
+  CHECK_FATAL(curRegion != nullptr, "get region from cdgNode failed");
+  if (curRegion->GetRegionId() != curCDGNode->GetRegion()->GetRegionId()) {
+    return;
+  }
+  visited[curBB.GetId()] = true;
+  /* Stack memory address */
+  MapleVector<Insn*> stackDefs = cdgNode->GetStackDefInsns();
+  for (auto stackDef : stackDefs) {
+    if (stackDef->IsCall() || NeedBuildDepsMem(memOpnd, nextMemOpnd, *stackDef)) {
+      AddDependence(*stackDef->GetDepNode(), depNode, kDependenceTypeTrue);
+    }
+  }
+  /* Heap memory address */
+  MapleVector<Insn*> heapDefs = cdgNode->GetHeapDefInsns();
+  AddDependence4InsnInVectorByType(heapDefs, *depNode.GetInsn(), kDependenceTypeTrue);
+  for (auto predIt = curBB.GetPredsBegin(); predIt != curBB.GetPredsEnd(); ++predIt) {
+    BuildPredPathMemUseDependencyDFS(**predIt, visited, depNode, memOpnd, nextMemOpnd);
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_dce.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_dce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7983fa68a38ada106fbb6077950d744ac298a65d
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_dce.cpp
@@ -0,0 +1,102 @@
+/*
+* Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+    * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+#include "aarch64_dce.h"
+#include "aarch64_operand.h"
+namespace maplebe {
+bool AArch64Dce::RemoveUnuseDef(VRegVersion &defVersion) {
+  /* delete defs which have no uses */
+  if (defVersion.GetAllUseInsns().empty()) {
+    DUInsnInfo *defInsnInfo = defVersion.GetDefInsnInfo();
+    if (defInsnInfo == nullptr) {
+      return false;
+    }
+    CHECK_FATAL(defInsnInfo->GetInsn() != nullptr, "Get def insn failed");
+    Insn *defInsn = defInsnInfo->GetInsn();
+    /* have not support asm/neon opt yet */
+    if (defInsn->GetMachineOpcode() == MOP_asm || defInsn->IsVectorOp() || defInsn->IsAtomic()) {
+      return false;
+    }
+    std::set<uint32> defRegs = defInsn->GetDefRegs();
+    std::vector<VRegVersion*> defVersions;
+    defVersions.push_back(&defVersion);
+    for (auto defRegNo : defRegs) {
+      if (defRegNo != defVersion.GetSSAvRegOpnd()->GetRegisterNumber()) {
+        VRegVersion *otherVersion = ssaInfo->FindSSAVersion(defRegNo);
+        if (!otherVersion) {  // cannot find def use for physical register, return
+          return false;
+        }
+        if (!otherVersion->GetAllUseInsns().empty()) {
+          return false;
+        }
+        defVersions.push_back(otherVersion);
+      }
+    }
+    uint32 bothDUIdx = defInsn->GetBothDefUseOpnd();
+    if (bothDUIdx == kInsnMaxOpnd ||
+        (defInsnInfo->GetOperands().count(bothDUIdx) > 0 && defInsnInfo->GetOperands().at(bothDUIdx) == 1)) {
+      defInsn->GetBB()->RemoveInsn(*defInsn);
+      if (defInsn->IsPhi()) {
+        for (auto dv : defVersions) {
+          defInsn->GetBB()->RemovePhiInsn(dv->GetOriginalRegNO());
+        }
+      }
+      for (auto dv : defVersions) {
+        dv->MarkDeleted();
+      }
+      uint32 opndNum = defInsn->GetOperandSize();
+      for (uint32 i = opndNum; i > 0; --i) {
+        Operand &opnd = defInsn->GetOperand(i - 1);
+        A64DeleteRegUseVisitor deleteUseRegVisitor(*GetSSAInfo(), defInsn->GetId());
+        opnd.Accept(deleteUseRegVisitor);
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+void A64DeleteRegUseVisitor::Visit(RegOperand *v) {
+  if (v->IsSSAForm()) {
+    VRegVersion *regVersion = GetSSAInfo()->FindSSAVersion(v->GetRegisterNumber());
+    ASSERT(regVersion != nullptr, "regVersion should not be nullptr");
+    MapleUnorderedMap<uint32, DUInsnInfo*> &useInfos = regVersion->GetAllUseInsns();
+    auto it = useInfos.find(deleteInsnId);
+    if (it != useInfos.end()) {
+      useInfos.erase(it);
+    }
+  }
+}
+void A64DeleteRegUseVisitor::Visit(ListOperand *v) {
+  for (auto *regOpnd : std::as_const(v->GetOperands())) {
+    Visit(regOpnd);
+  }
+}
+void A64DeleteRegUseVisitor::Visit(MemOperand *v) {
+  RegOperand *baseRegOpnd = v->GetBaseRegister();
+  RegOperand *indexRegOpnd = v->GetIndexRegister();
+  if (baseRegOpnd != nullptr && baseRegOpnd->IsSSAForm()) {
+    Visit(baseRegOpnd);
+  }
+  if (indexRegOpnd != nullptr && indexRegOpnd->IsSSAForm()) {
+    Visit(indexRegOpnd);
+  }
+}
+
+void A64DeleteRegUseVisitor::Visit(PhiOperand *v) {
+  for (auto &phiOpndIt : std::as_const(v->GetOperands())) {
+    Visit(phiOpndIt.second);
+  }
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_dependence.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_dependence.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..751cb5543934f1374da8e290c20c0257e5598449
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_dependence.cpp
@@ -0,0 +1,1144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_dependence.h"
+
+#include "aarch64_cg.h"
+#include "aarch64_operand.h"
+#include "pressure.h"
+
+/* For building dependence graph, The entry is AArch64DepAnalysis::Run. */
+namespace maplebe {
+/* constructor */
+AArch64DepAnalysis::AArch64DepAnalysis(CGFunc &func, MemPool &mp, MAD &mad, bool beforeRA)
+    : DepAnalysis(func, mp, mad, beforeRA),
+      stackUses(alloc.Adapter()),
+      stackDefs(alloc.Adapter()),
+      heapUses(alloc.Adapter()),
+      heapDefs(alloc.Adapter()),
+      mayThrows(alloc.Adapter()),
+      ambiInsns(alloc.Adapter()),
+      ehInRegs(alloc.Adapter()) {
+  uint32 maxRegNum;
+  if (beforeRA) {
+    maxRegNum = cgFunc.GetMaxVReg();
+  } else {
+    maxRegNum = kAllRegNum;
+  }
+  regDefs = memPool.NewArray<Insn *>(maxRegNum);
+  regUses = memPool.NewArray<RegList *>(maxRegNum);
+}
+
+/* print dep node information */
+void AArch64DepAnalysis::DumpDepNode(DepNode &node) const {
+  node.GetInsn()->Dump();
+  uint32 num = node.GetUnitNum();
+  LogInfo::MapleLogger() << "unit num : " << num << ", ";
+  for (uint32 i = 0; i < num; ++i) {
+    const Unit *unit = node.GetUnitByIndex(i);
+    if (unit != nullptr) {
+      PRINT_VAL(unit->GetName());
+    } else {
+      PRINT_VAL("none");
+    }
+  }
+  LogInfo::MapleLogger() << '\n';
+  node.DumpSchedInfo();
+  if (beforeRA) {
+    node.DumpRegPressure();
+  }
+}
+
+/* print dep link information */
+void AArch64DepAnalysis::DumpDepLink(DepLink &link, const DepNode *node) const {
+  PRINT_VAL(GetDepTypeName(link.GetDepType()));
+  PRINT_STR_VAL("Latency: ", link.GetLatency());
+  if (node != nullptr) {
+    node->GetInsn()->Dump();
+    return;
+  }
+  LogInfo::MapleLogger() << "from : ";
+  link.GetFrom().GetInsn()->Dump();
+  LogInfo::MapleLogger() << "to : ";
+  link.GetTo().GetInsn()->Dump();
+}
+
+/* Append use register to the list. */
+void AArch64DepAnalysis::AppendRegUseList(Insn &insn, regno_t regNO) {
+  RegList *regList = memPool.New<RegList>();
+  regList->insn = &insn;
+  regList->next = nullptr;
+  if (regUses[regNO] == nullptr) {
+    regUses[regNO] = regList;
+    if (beforeRA) {
+      Insn *defInsn = regDefs[regNO];
+      if (defInsn == nullptr) {
+        return;
+      }
+      DepNode *defNode = defInsn->GetDepNode();
+      defNode->SetRegDefs(regNO, regList);
+    }
+    return;
+  }
+  RegList *lastRegList = regUses[regNO];
+  while (lastRegList->next != nullptr) {
+    lastRegList = lastRegList->next;
+  }
+  lastRegList->next = regList;
+}
+
+/*
+ * Add dependence edge.
+ * Two dependence node has a unique edge.
+ * True dependence overwirtes other dependences.
+ */
+void AArch64DepAnalysis::AddDependence(DepNode &fromNode, DepNode &toNode, DepType depType) {
+  /* Can not build a self loop dependence. */
+  if (&fromNode == &toNode) {
+    return;
+  }
+  /* Check if exist edge. */
+  if (!fromNode.GetSuccs().empty()) {
+    DepLink *depLink = fromNode.GetSuccs().back();
+    if (&(depLink->GetTo()) == &toNode) {
+      if (depLink->GetDepType() != kDependenceTypeTrue) {
+        if (depType == kDependenceTypeTrue) {
+          /* Has exist edge, replace it. */
+          depLink->SetDepType(kDependenceTypeTrue);
+          depLink->SetLatency(mad.GetLatency(*fromNode.GetInsn(), *toNode.GetInsn()));
+        }
+      }
+      return;
+    }
+  }
+  DepLink *depLink = memPool.New<DepLink>(fromNode, toNode, depType);
+  if (depType == kDependenceTypeTrue) {
+    depLink->SetLatency(mad.GetLatency(*fromNode.GetInsn(), *toNode.GetInsn()));
+  }
+  fromNode.AddSucc(*depLink);
+  toNode.AddPred(*depLink);
+}
+
+void AArch64DepAnalysis::AddDependence4InsnInVectorByType(MapleVector<Insn *> &insns, Insn &insn, const DepType &type) {
+  for (auto anyInsn : insns) {
+    AddDependence(*anyInsn->GetDepNode(), *insn.GetDepNode(), type);
+  }
+}
+
+void AArch64DepAnalysis::AddDependence4InsnInVectorByTypeAndCmp(MapleVector<Insn *> &insns, Insn &insn,
+                                                                const DepType &type) {
+  for (auto anyInsn : insns) {
+    if (anyInsn != &insn) {
+      AddDependence(*anyInsn->GetDepNode(), *insn.GetDepNode(), type);
+    }
+  }
+}
+
+/* Remove self dependence (self loop) in dependence graph. */
+void AArch64DepAnalysis::RemoveSelfDeps(Insn &insn) {
+  DepNode *node = insn.GetDepNode();
+  ASSERT(node->GetSuccs().back()->GetTo().GetInsn() == &insn, "Is not a self dependence.");
+  ASSERT(node->GetPreds().back()->GetFrom().GetInsn() == &insn, "Is not a self dependence.");
+  node->RemoveSucc();
+  node->RemovePred();
+}
+
+/* Build dependences of source register operand. */
+void AArch64DepAnalysis::BuildDepsUseReg(Insn &insn, regno_t regNO) {
+  DepNode *node = insn.GetDepNode();
+  node->AddUseReg(regNO);
+  if (regDefs[regNO] != nullptr) {
+    /* Build true dependences. */
+    AddDependence(*regDefs[regNO]->GetDepNode(), *insn.GetDepNode(), kDependenceTypeTrue);
+  }
+}
+
+/* Build dependences of destination register operand. */
+void AArch64DepAnalysis::BuildDepsDefReg(Insn &insn, regno_t regNO) {
+  DepNode *node = insn.GetDepNode();
+  node->AddDefReg(regNO);
+  /* Build anti dependences. */
+  RegList *regList = regUses[regNO];
+  while (regList != nullptr) {
+    CHECK_NULL_FATAL(regList->insn);
+    AddDependence(*regList->insn->GetDepNode(), *node, kDependenceTypeAnti);
+    regList = regList->next;
+  }
+  /* Build output depnedence. */
+  if (regDefs[regNO] != nullptr) {
+    AddDependence(*regDefs[regNO]->GetDepNode(), *node, kDependenceTypeOutput);
+  }
+}
+
+void AArch64DepAnalysis::ReplaceDepNodeWithNewInsn(DepNode &firstNode, DepNode &secondNode, Insn &newInsn,
+                                                   bool isFromClinit) const {
+  if (isFromClinit) {
+    firstNode.AddClinitInsn(*firstNode.GetInsn());
+    firstNode.AddClinitInsn(*secondNode.GetInsn());
+    firstNode.SetCfiInsns(secondNode.GetCfiInsns());
+  } else {
+    for (Insn *insn : secondNode.GetCfiInsns()) {
+      firstNode.AddCfiInsn(*insn);
+    }
+    for (Insn *insn : secondNode.GetComments()) {
+      firstNode.AddComments(*insn);
+    }
+    secondNode.ClearComments();
+  }
+  firstNode.SetInsn(newInsn);
+  Reservation *rev = mad.FindReservation(newInsn);
+  CHECK_FATAL(rev != nullptr, "reservation is nullptr.");
+  firstNode.SetReservation(*rev);
+  firstNode.SetUnits(rev->GetUnit());
+  firstNode.SetUnitNum(rev->GetUnitNum());
+  newInsn.SetDepNode(firstNode);
+}
+
+void AArch64DepAnalysis::ClearDepNodeInfo(DepNode &depNode) const {
+  Insn &insn = cgFunc.GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_pseudo_none);
+  insn.SetDepNode(depNode);
+  Reservation *seRev = mad.FindReservation(insn);
+  depNode.SetInsn(insn);
+  depNode.SetType(kNodeTypeEmpty);
+  depNode.SetReservation(*seRev);
+  depNode.SetUnitNum(0);
+  depNode.ClearCfiInsns();
+  depNode.SetUnits(nullptr);
+}
+
+/* Combine adrpldr&clinit_tail to clinit. */
+void AArch64DepAnalysis::CombineClinit(DepNode &firstNode, DepNode &secondNode, bool isAcrossSeparator) {
+  ASSERT(firstNode.GetInsn()->GetMachineOpcode() == MOP_adrp_ldr, "first insn should be adrpldr");
+  ASSERT(secondNode.GetInsn()->GetMachineOpcode() == MOP_clinit_tail, "second insn should be clinit_tail");
+  ASSERT(firstNode.GetCfiInsns().empty(), "There should not be any comment/cfi instructions between clinit.");
+  ASSERT(secondNode.GetComments().empty(), "There should not be any comment/cfi instructions between clinit.");
+  Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(MOP_clinit, firstNode.GetInsn()->GetOperand(0),
+                                                     firstNode.GetInsn()->GetOperand(1));
+  newInsn.SetId(firstNode.GetInsn()->GetId());
+  /* Replace first node with new insn. */
+  ReplaceDepNodeWithNewInsn(firstNode, secondNode, newInsn, true);
+  /* Clear second node information. */
+  ClearDepNodeInfo(secondNode);
+  CombineDependence(firstNode, secondNode, isAcrossSeparator);
+}
+
+/*
+ *  Combine memory access pair:
+ *   1.ldr to ldp.
+ *   2.str to stp.
+ */
+void AArch64DepAnalysis::CombineMemoryAccessPair(DepNode &firstNode, DepNode &secondNode, bool useFirstOffset) {
+  ASSERT(firstNode.GetInsn(), "the insn of first Node should not be nullptr");
+  ASSERT(secondNode.GetInsn(), "the insn of second Node should not be nullptr");
+  MOperator thisMop = firstNode.GetInsn()->GetMachineOpcode();
+  MOperator mopPair = GetMopPair(thisMop);
+  ASSERT(mopPair != 0, "mopPair should not be zero");
+  Operand *opnd0 = nullptr;
+  Operand *opnd1 = nullptr;
+  Operand *opnd2 = nullptr;
+  if (useFirstOffset) {
+    opnd0 = &(firstNode.GetInsn()->GetOperand(0));
+    opnd1 = &(secondNode.GetInsn()->GetOperand(0));
+    opnd2 = &(firstNode.GetInsn()->GetOperand(1));
+  } else {
+    opnd0 = &(secondNode.GetInsn()->GetOperand(0));
+    opnd1 = &(firstNode.GetInsn()->GetOperand(0));
+    opnd2 = &(secondNode.GetInsn()->GetOperand(1));
+  }
+  Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(mopPair, *opnd0, *opnd1, *opnd2);
+  newInsn.SetId(firstNode.GetInsn()->GetId());
+  std::string newComment;
+  const MapleString &comment = firstNode.GetInsn()->GetComment();
+  if (comment.c_str() != nullptr) {
+    newComment += comment.c_str();
+  }
+  const MapleString &secondComment = secondNode.GetInsn()->GetComment();
+  if (secondComment.c_str() != nullptr) {
+    newComment += "  ";
+    newComment += secondComment.c_str();
+  }
+  if ((newComment.c_str() != nullptr) && (strlen(newComment.c_str()) > 0)) {
+    newInsn.SetComment(newComment);
+  }
+  /* Replace first node with new insn. */
+  ReplaceDepNodeWithNewInsn(firstNode, secondNode, newInsn, false);
+  /* Clear second node information. */
+  ClearDepNodeInfo(secondNode);
+  CombineDependence(firstNode, secondNode, false, true);
+}
+
+/* Combine two dependence nodes to one */
+void AArch64DepAnalysis::CombineDependence(DepNode &firstNode, DepNode &secondNode, bool isAcrossSeparator,
+                                           bool isMemCombine) {
+  if (isAcrossSeparator) {
+    /* Clear all latency of the second node. */
+    for (auto predLink : secondNode.GetPreds()) {
+      predLink->SetLatency(0);
+    }
+    for (auto succLink : secondNode.GetSuccs()) {
+      succLink->SetLatency(0);
+    }
+    return;
+  }
+  std::set<DepNode *> uniqueNodes;
+
+  for (auto predLink : firstNode.GetPreds()) {
+    if (predLink->GetDepType() == kDependenceTypeTrue) {
+      predLink->SetLatency(mad.GetLatency(*predLink->GetFrom().GetInsn(), *firstNode.GetInsn()));
+    }
+    (void)uniqueNodes.insert(&predLink->GetFrom());
+  }
+  for (auto predLink : secondNode.GetPreds()) {
+    if (&predLink->GetFrom() != &firstNode) {
+      if (uniqueNodes.insert(&(predLink->GetFrom())).second) {
+        AddDependence(predLink->GetFrom(), firstNode, predLink->GetDepType());
+      }
+    }
+    predLink->SetLatency(0);
+  }
+  uniqueNodes.clear();
+  for (auto succLink : firstNode.GetSuccs()) {
+    if (succLink->GetDepType() == kDependenceTypeTrue) {
+      succLink->SetLatency(mad.GetLatency(*succLink->GetFrom().GetInsn(), *firstNode.GetInsn()));
+    }
+    (void)uniqueNodes.insert(&(succLink->GetTo()));
+  }
+  for (auto succLink : secondNode.GetSuccs()) {
+    if (uniqueNodes.insert(&(succLink->GetTo())).second) {
+      AddDependence(firstNode, succLink->GetTo(), succLink->GetDepType());
+      if (isMemCombine) {
+        succLink->GetTo().IncreaseValidPredsSize();
+      }
+    }
+    succLink->SetLatency(0);
+  }
+}
+
+/*
+ * Build dependences of ambiguous instruction.
+ * ambiguous instruction : instructions that can not across may throw instructions.
+ */
+void AArch64DepAnalysis::BuildDepsAmbiInsn(Insn &insn) {
+  AddDependence4InsnInVectorByType(mayThrows, insn, kDependenceTypeThrow);
+  ambiInsns.emplace_back(&insn);
+}
+
+/* Build dependences of may throw instructions. */
+void AArch64DepAnalysis::BuildDepsMayThrowInsn(Insn &insn) {
+  AddDependence4InsnInVectorByType(ambiInsns, insn, kDependenceTypeThrow);
+}
+
+bool AArch64DepAnalysis::IsFrameReg(const RegOperand &opnd) const {
+  return (opnd.GetRegisterNumber() == RFP) || (opnd.GetRegisterNumber() == RSP);
+}
+
+MemOperand *AArch64DepAnalysis::BuildNextMemOperandByByteSize(const MemOperand &aarchMemOpnd, uint32 byteSize) const {
+  MemOperand *nextMemOpnd = aarchMemOpnd.Clone(memPool);
+  Operand *nextOfstOpnd = nextMemOpnd->GetOffsetImmediate()->Clone(memPool);
+  OfstOperand *aarchNextOfstOpnd = static_cast<OfstOperand *>(nextOfstOpnd);
+  CHECK_NULL_FATAL(aarchNextOfstOpnd);
+  int32 offsetVal = static_cast<int32>(aarchNextOfstOpnd->GetOffsetValue());
+  aarchNextOfstOpnd->SetOffsetValue(offsetVal + byteSize);
+  nextMemOpnd->SetOffsetOperand(*aarchNextOfstOpnd);
+  return nextMemOpnd;
+}
+
+/* Get the second memory access operand of stp/ldp instructions. */
+MemOperand *AArch64DepAnalysis::GetNextMemOperand(const Insn &insn, const MemOperand &aarchMemOpnd) const {
+  MemOperand *nextMemOpnd = nullptr;
+  switch (insn.GetMachineOpcode()) {
+    case MOP_wldp:
+    case MOP_sldp:
+    case MOP_xldpsw:
+    case MOP_wstp:
+    case MOP_sstp: {
+      nextMemOpnd = BuildNextMemOperandByByteSize(aarchMemOpnd, k4ByteSize);
+      break;
+    }
+    case MOP_xldp:
+    case MOP_dldp:
+    case MOP_xstp:
+    case MOP_dstp: {
+      nextMemOpnd = BuildNextMemOperandByByteSize(aarchMemOpnd, k8ByteSize);
+      break;
+    }
+    default:
+      break;
+  }
+
+  return nextMemOpnd;
+}
+
+/*
+ * Build dependences of symbol memory access.
+ * Memory access with symbol must be a heap memory access.
+ */
+void AArch64DepAnalysis::BuildDepsAccessStImmMem(Insn &insn, bool isDest) {
+  if (isDest) {
+    /*
+    * Heap memory
+    * Build anti dependences.
+    */
+    AddDependence4InsnInVectorByType(heapUses, insn, kDependenceTypeAnti);
+    /* Build output depnedence. */
+    AddDependence4InsnInVectorByType(heapDefs, insn, kDependenceTypeOutput);
+    heapDefs.emplace_back(&insn);
+  } else {
+    /* Heap memory */
+    AddDependence4InsnInVectorByType(heapDefs, insn, kDependenceTypeTrue);
+    heapUses.emplace_back(&insn);
+  }
+  if (memBarInsn != nullptr) {
+    AddDependence(*memBarInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeMembar);
+  }
+}
+
+/* Build dependences of stack memory and heap memory uses. */
+void AArch64DepAnalysis::BuildDepsUseMem(Insn &insn, MemOperand &aarchMemOpnd) {
+  RegOperand *baseRegister = aarchMemOpnd.GetBaseRegister();
+  MemOperand *nextMemOpnd = GetNextMemOperand(insn, aarchMemOpnd);
+
+  aarchMemOpnd.SetAccessSize(insn.GetMemoryByteSize());
+  /* Stack memory address */
+  for (auto defInsn : stackDefs) {
+    if (defInsn->IsCall() || NeedBuildDepsMem(aarchMemOpnd, nextMemOpnd, *defInsn)) {
+      AddDependence(*defInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeTrue);
+      continue;
+    }
+  }
+  /* Heap memory */
+  AddDependence4InsnInVectorByType(heapDefs, insn, kDependenceTypeTrue);
+  if (((baseRegister != nullptr) && IsFrameReg(*baseRegister)) || aarchMemOpnd.IsStackMem()) {
+    stackUses.emplace_back(&insn);
+  } else {
+    heapUses.emplace_back(&insn);
+  }
+  if (memBarInsn != nullptr) {
+    AddDependence(*memBarInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeMembar);
+  }
+}
+
+static bool NoAlias(const MemOperand &leftOpnd, const MemOperand &rightOpnd) {
+  if (leftOpnd.GetAddrMode() == MemOperand::kAddrModeBOi && rightOpnd.GetAddrMode() == MemOperand::kAddrModeBOi &&
+      leftOpnd.GetIndexOpt() == MemOperand::kIntact && rightOpnd.GetIndexOpt() == MemOperand::kIntact) {
+    if (leftOpnd.GetBaseRegister()->GetRegisterNumber() == RFP ||
+        rightOpnd.GetBaseRegister()->GetRegisterNumber() == RFP) {
+      Operand *ofstOpnd = leftOpnd.GetOffsetOperand();
+      Operand *rofstOpnd = rightOpnd.GetOffsetOperand();
+      ASSERT(ofstOpnd != nullptr, "offset operand should not be null.");
+      ASSERT(rofstOpnd != nullptr, "offset operand should not be null.");
+      ImmOperand *ofst = static_cast<ImmOperand *>(ofstOpnd);
+      ImmOperand *rofst = static_cast<ImmOperand *>(rofstOpnd);
+      ASSERT(ofst != nullptr, "CG internal error, invalid type.");
+      ASSERT(rofst != nullptr, "CG internal error, invalid type.");
+      return (!ofst->ValueEquals(*rofst));
+    }
+  }
+  return false;
+}
+
+static bool NoOverlap(const MemOperand &leftOpnd, const MemOperand &rightOpnd) {
+  if (leftOpnd.GetAddrMode() != MemOperand::kAddrModeBOi || rightOpnd.GetAddrMode() != MemOperand::kAddrModeBOi ||
+      leftOpnd.GetIndexOpt() != MemOperand::kIntact || rightOpnd.GetIndexOpt() != MemOperand::kIntact) {
+    return false;
+  }
+  if (leftOpnd.GetBaseRegister()->GetRegisterNumber() != RFP ||
+      rightOpnd.GetBaseRegister()->GetRegisterNumber() != RFP) {
+    return false;
+  }
+  int64 ofset1 = leftOpnd.GetOffsetOperand()->GetValue();
+  int64 ofset2 = rightOpnd.GetOffsetOperand()->GetValue();
+  if (ofset1 < ofset2) {
+    return ((ofset1 + static_cast<int8>(leftOpnd.GetAccessSize())) <= ofset2);
+  } else {
+    return ((ofset2 + static_cast<int8>(rightOpnd.GetAccessSize())) <= ofset1);
+  }
+}
+
+/* Return true if memInsn's memOpnd no alias with memOpnd and nextMemOpnd */
+bool AArch64DepAnalysis::NeedBuildDepsMem(const MemOperand &memOpnd, const MemOperand *nextMemOpnd,
+                                          const Insn &memInsn) const {
+  auto *memOpndOfmemInsn = static_cast<MemOperand *>(memInsn.GetMemOpnd());
+  if (!NoAlias(memOpnd, *memOpndOfmemInsn) || ((nextMemOpnd != nullptr) && !NoAlias(*nextMemOpnd, *memOpndOfmemInsn))) {
+    return true;
+  }
+  if (cgFunc.GetMirModule().GetSrcLang() == kSrcLangC && !memInsn.IsCall()) {
+    static_cast<MemOperand *>(memInsn.GetMemOpnd())->SetAccessSize(memInsn.GetMemoryByteSize());
+    return (!NoOverlap(memOpnd, *memOpndOfmemInsn));
+  }
+  MemOperand *nextMemOpndOfmemInsn = GetNextMemOperand(memInsn, *memOpndOfmemInsn);
+  if (nextMemOpndOfmemInsn != nullptr) {
+    if (!NoAlias(memOpnd, *nextMemOpndOfmemInsn) ||
+        ((nextMemOpnd != nullptr) && !NoAlias(*nextMemOpnd, *nextMemOpndOfmemInsn))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/*
+ * Build anti dependences between insn and other insn that use stack memroy.
+ * insn        : the instruction that defines stack memory.
+ * memOpnd     : insn's memOpnd
+ * nextMemOpnd : some memory pair operator instruction (like ldp/stp) defines two memory.
+ */
+void AArch64DepAnalysis::BuildAntiDepsDefStackMem(Insn &insn, MemOperand &memOpnd, const MemOperand *nextMemOpnd) {
+  memOpnd.SetAccessSize(insn.GetMemoryByteSize());
+  for (auto *useInsn : stackUses) {
+    if (NeedBuildDepsMem(memOpnd, nextMemOpnd, *useInsn)) {
+      AddDependence(*useInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeAnti);
+    }
+  }
+}
+
+/*
+ * Build output dependences between insn with other insn that define stack memroy.
+ * insn        : the instruction that defines stack memory.
+ * memOpnd     : insn's memOpnd
+ * nextMemOpnd : some memory pair operator instruction (like ldp/stp) defines two memory.
+ */
+void AArch64DepAnalysis::BuildOutputDepsDefStackMem(Insn &insn, MemOperand &memOpnd, const MemOperand *nextMemOpnd) {
+  memOpnd.SetAccessSize(insn.GetMemoryByteSize());
+  for (auto defInsn : stackDefs) {
+    if (defInsn->IsCall() || NeedBuildDepsMem(memOpnd, nextMemOpnd, *defInsn)) {
+      AddDependence(*defInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeOutput);
+    }
+  }
+}
+
+/* Build dependences of stack memory and heap memory definitions. */
+void AArch64DepAnalysis::BuildDepsDefMem(Insn &insn, MemOperand &aarchMemOpnd) {
+  RegOperand *baseRegister = aarchMemOpnd.GetBaseRegister();
+  MemOperand *nextMemOpnd = GetNextMemOperand(insn, aarchMemOpnd);
+
+  /* Build anti dependences. */
+  BuildAntiDepsDefStackMem(insn, aarchMemOpnd, nextMemOpnd);
+  /* Build output depnedence. */
+  BuildOutputDepsDefStackMem(insn, aarchMemOpnd, nextMemOpnd);
+  if (lastCallInsn != nullptr) {
+    /* Build a dependence between stack passed arguments and call. */
+    ASSERT(baseRegister != nullptr, "baseRegister shouldn't be null here");
+    if (baseRegister->GetRegisterNumber() == RSP) {
+      AddDependence(*lastCallInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeControl);
+    }
+  }
+
+  /* Heap memory
+   * Build anti dependences.
+   */
+  AddDependence4InsnInVectorByType(heapUses, insn, kDependenceTypeAnti);
+  /* Build output depnedence. */
+  AddDependence4InsnInVectorByType(heapDefs, insn, kDependenceTypeOutput);
+
+  if (((baseRegister != nullptr) && IsFrameReg(*baseRegister)) || aarchMemOpnd.IsStackMem()) {
+    stackDefs.emplace_back(&insn);
+  } else {
+    heapDefs.emplace_back(&insn);
+  }
+  if (memBarInsn != nullptr) {
+    AddDependence(*memBarInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeMembar);
+  }
+  /* Memory definition can not across may-throw insns. */
+  AddDependence4InsnInVectorByType(mayThrows, insn, kDependenceTypeThrow);
+}
+
+/* Build dependences of memory barrior instructions. */
+void AArch64DepAnalysis::BuildDepsMemBar(Insn &insn) {
+  AddDependence4InsnInVectorByTypeAndCmp(stackUses, insn, kDependenceTypeMembar);
+  AddDependence4InsnInVectorByTypeAndCmp(heapUses, insn, kDependenceTypeMembar);
+  AddDependence4InsnInVectorByTypeAndCmp(stackDefs, insn, kDependenceTypeMembar);
+  AddDependence4InsnInVectorByTypeAndCmp(heapDefs, insn, kDependenceTypeMembar);
+  memBarInsn = &insn;
+}
+
+/* A pseudo separator node depends all the other nodes. */
+void AArch64DepAnalysis::BuildDepsSeparator(DepNode &newSepNode, MapleVector<DepNode *> &nodes) {
+  uint32 nextSepIndex = (separatorIndex + kMaxDependenceNum) < nodes.size() ? (separatorIndex + kMaxDependenceNum)
+                                                                            : static_cast<uint32>(nodes.size() - 1);
+  newSepNode.ReservePreds(nextSepIndex - separatorIndex);
+  newSepNode.ReserveSuccs(nextSepIndex - separatorIndex);
+  for (uint32 i = separatorIndex; i < nextSepIndex; ++i) {
+    AddDependence(*nodes[i], newSepNode, kDependenceTypeSeparator);
+  }
+}
+
+/* Build control dependence for branch/ret instructions. */
+void AArch64DepAnalysis::BuildDepsControlAll(DepNode &depNode, const MapleVector<DepNode *> &nodes) {
+  for (uint32 i = separatorIndex; i < depNode.GetIndex(); ++i) {
+    AddDependence(*nodes[i], depNode, kDependenceTypeControl);
+  }
+}
+
+/*
+ * Build dependences of call instructions.
+ * Caller-saved physical registers will defined by a call instruction.
+ * Also a conditional register may modified by a call.
+ */
+void AArch64DepAnalysis::BuildCallerSavedDeps(Insn &insn) {
+  /* Build anti dependence and output dependence. */
+  for (uint32 i = R0; i <= R7; ++i) {
+    BuildDepsDefReg(insn, i);
+  }
+  for (uint32 i = V0; i <= V7; ++i) {
+    BuildDepsDefReg(insn, i);
+  }
+  if (!beforeRA) {
+    for (uint32 i = R8; i <= R18; ++i) {
+      BuildDepsDefReg(insn, i);
+    }
+    for (uint32 i = RLR; i <= RSP; ++i) {
+      BuildDepsUseReg(insn, i);
+    }
+    for (uint32 i = V16; i <= V31; ++i) {
+      BuildDepsDefReg(insn, i);
+    }
+  }
+  /* For condition operand, such as NE, EQ, and so on. */
+  if (cgFunc.GetRflag() != nullptr) {
+    BuildDepsDefReg(insn, kRFLAG);
+  }
+}
+
+/*
+ * Build dependence between control register and last call instruction.
+ * insn : instruction that with control register operand.
+ * isDest : if the control register operand is a destination operand.
+ */
+void AArch64DepAnalysis::BuildDepsBetweenControlRegAndCall(Insn &insn, bool isDest) {
+  if (lastCallInsn == nullptr) {
+    return;
+  }
+  if (isDest) {
+    AddDependence(*lastCallInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeOutput);
+    return;
+  }
+  AddDependence(*lastCallInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeAnti);
+}
+
+/*
+ * Build dependence between stack-define-instruction that deal with call-insn's args and a call-instruction.
+ * insn : a call instruction (call/tail-call)
+ */
+void AArch64DepAnalysis::BuildStackPassArgsDeps(Insn &insn) {
+  for (auto stackDefInsn : stackDefs) {
+    if (stackDefInsn->IsCall()) {
+      continue;
+    }
+    Operand *opnd = stackDefInsn->GetMemOpnd();
+    ASSERT(opnd->IsMemoryAccessOperand(), "make sure opnd is memOpnd");
+    MemOperand *memOpnd = static_cast<MemOperand *>(opnd);
+    RegOperand *baseReg = memOpnd->GetBaseRegister();
+    if ((baseReg != nullptr) && (baseReg->GetRegisterNumber() == RSP)) {
+      AddDependence(*stackDefInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeControl);
+    }
+  }
+}
+
+/* Some insns may dirty all stack memory, such as "bl MCC_InitializeLocalStackRef". */
+void AArch64DepAnalysis::BuildDepsDirtyStack(Insn &insn) {
+  /* Build anti dependences. */
+  AddDependence4InsnInVectorByType(stackUses, insn, kDependenceTypeAnti);
+  /* Build output depnedence. */
+  AddDependence4InsnInVectorByType(stackDefs, insn, kDependenceTypeOutput);
+  stackDefs.emplace_back(&insn);
+}
+
+/* Some call insns may use all stack memory, such as "bl MCC_CleanupLocalStackRef_NaiveRCFast". */
+void AArch64DepAnalysis::BuildDepsUseStack(Insn &insn) {
+  /* Build true dependences. */
+  AddDependence4InsnInVectorByType(stackDefs, insn, kDependenceTypeTrue);
+}
+
+/* Some insns may dirty all heap memory, such as a call insn. */
+void AArch64DepAnalysis::BuildDepsDirtyHeap(Insn &insn) {
+  /* Build anti dependences. */
+  AddDependence4InsnInVectorByType(heapUses, insn, kDependenceTypeAnti);
+  /* Build output depnedence. */
+  AddDependence4InsnInVectorByType(heapDefs, insn, kDependenceTypeOutput);
+  if (memBarInsn != nullptr) {
+    AddDependence(*memBarInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeMembar);
+  }
+  heapDefs.emplace_back(&insn);
+}
+
+/* Build a pseudo node to seperate dependence graph. */
+DepNode *AArch64DepAnalysis::BuildSeparatorNode() {
+  Insn &pseudoSepInsn = cgFunc.GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_pseudo_dependence_seperator);
+  DepNode *separatorNode = memPool.New<DepNode>(pseudoSepInsn, alloc);
+  separatorNode->SetType(kNodeTypeSeparator);
+  pseudoSepInsn.SetDepNode(*separatorNode);
+  if (beforeRA) {
+    RegPressure *regPressure = memPool.New<RegPressure>(alloc);
+    separatorNode->SetRegPressure(*regPressure);
+    separatorNode->InitPressure();
+  }
+  return separatorNode;
+}
+
+/* Init depAnalysis data struction */
+void AArch64DepAnalysis::Init(BB &bb, MapleVector<DepNode *> &nodes) {
+  curBB = &bb;
+  ClearAllDepData();
+  lastComments.clear();
+  /* Analysis live-in registers in catch BB. */
+  AnalysisAmbiInsns(bb);
+  /* Clear all dependence nodes and push the first separator node. */
+  nodes.clear();
+  DepNode *pseudoSepNode = BuildSeparatorNode();
+  nodes.emplace_back(pseudoSepNode);
+  separatorIndex = 0;
+
+  if (beforeRA) {
+    /* assump first pseudo_dependence_seperator insn of current bb define live-in's registers */
+    Insn *pseudoSepInsn = pseudoSepNode->GetInsn();
+    for (auto &regNO : bb.GetLiveInRegNO()) {
+      regDefs[regNO] = pseudoSepInsn;
+      pseudoSepNode->AddDefReg(regNO);
+      pseudoSepNode->SetRegDefs(pseudoSepNode->GetDefRegnos().size(), nullptr);
+    }
+  }
+}
+
+/* When a separator build, it is the same as a new basic block. */
+void AArch64DepAnalysis::ClearAllDepData() {
+  uint32 maxRegNum;
+  if (beforeRA) {
+    maxRegNum = cgFunc.GetMaxVReg();
+  } else {
+    maxRegNum = kAllRegNum;
+  }
+  errno_t ret = memset_s(regDefs, sizeof(Insn *) * maxRegNum, 0, sizeof(Insn *) * maxRegNum);
+  CHECK_FATAL(ret == EOK, "call memset_s failed in Unit");
+  ret = memset_s(regUses, sizeof(RegList *) * maxRegNum, 0, sizeof(RegList *) * maxRegNum);
+  CHECK_FATAL(ret == EOK, "call memset_s failed in Unit");
+  memBarInsn = nullptr;
+  lastCallInsn = nullptr;
+  lastFrameDef = nullptr;
+
+  stackUses.clear();
+  stackDefs.clear();
+  heapUses.clear();
+  heapDefs.clear();
+  mayThrows.clear();
+  ambiInsns.clear();
+}
+
+/* Analysis live-in registers in catch bb and cleanup bb. */
+void AArch64DepAnalysis::AnalysisAmbiInsns(BB &bb) {
+  hasAmbiRegs = false;
+  if (bb.GetEhSuccs().empty()) {
+    return;
+  }
+
+  /* Union all catch bb */
+  for (auto succBB : bb.GetEhSuccs()) {
+    const MapleSet<regno_t> &liveInRegSet = succBB->GetLiveInRegNO();
+    set_union(liveInRegSet.begin(), liveInRegSet.end(), ehInRegs.begin(), ehInRegs.end(),
+              inserter(ehInRegs, ehInRegs.begin()));
+  }
+
+  /* Union cleanup entry bb. */
+  const MapleSet<regno_t> &regNOSet = cgFunc.GetCleanupBB()->GetLiveInRegNO();
+  std::set_union(regNOSet.begin(), regNOSet.end(), ehInRegs.begin(), ehInRegs.end(),
+                 inserter(ehInRegs, ehInRegs.begin()));
+
+  /* Subtract R0 and R1, that is defined by eh runtime. */
+  ehInRegs.erase(R0);
+  ehInRegs.erase(R1);
+  if (ehInRegs.empty()) {
+    return;
+  }
+  hasAmbiRegs = true;
+}
+
+/* Check if regNO is in ehInRegs. */
+bool AArch64DepAnalysis::IfInAmbiRegs(regno_t regNO) const {
+  if (!hasAmbiRegs) {
+    return false;
+  }
+  if (ehInRegs.find(regNO) != ehInRegs.end()) {
+    return true;
+  }
+  return false;
+}
+
+static bool IsYieldPoint(Insn &insn) {
+  /*
+   * It is a yieldpoint if loading from a dedicated
+   * register holding polling page address:
+   * ldr  wzr, [RYP]
+   */
+  if (insn.IsLoad() && !insn.IsLoadLabel()) {
+    auto mem = static_cast<MemOperand *>(insn.GetMemOpnd());
+    return (mem != nullptr && mem->GetBaseRegister() != nullptr && mem->GetBaseRegister()->GetRegisterNumber() == RYP);
+  }
+  return false;
+}
+
+/*
+ * Build dependences of memory operand.
+ * insn : a instruction with the memory access operand.
+ * opnd : the memory access operand.
+ * regProp : operand property of the memory access operandess operand.
+ */
+void AArch64DepAnalysis::BuildMemOpndDependency(Insn &insn, Operand &opnd, const OpndDesc &regProp) {
+  ASSERT(opnd.IsMemoryAccessOperand(), "opnd must be memory Operand");
+  MemOperand *memOpnd = static_cast<MemOperand *>(&opnd);
+  RegOperand *baseRegister = memOpnd->GetBaseRegister();
+  if (baseRegister != nullptr) {
+    regno_t regNO = baseRegister->GetRegisterNumber();
+    BuildDepsUseReg(insn, regNO);
+    if ((memOpnd->GetAddrMode() == MemOperand::kAddrModeBOi) && (memOpnd->IsPostIndexed() || memOpnd->IsPreIndexed())) {
+      /* Base operand has changed. */
+      BuildDepsDefReg(insn, regNO);
+    }
+  }
+  RegOperand *indexRegister = memOpnd->GetIndexRegister();
+  if (indexRegister != nullptr) {
+    regno_t regNO = indexRegister->GetRegisterNumber();
+    BuildDepsUseReg(insn, regNO);
+  }
+  if (regProp.IsUse()) {
+    BuildDepsUseMem(insn, *memOpnd);
+  } else {
+    BuildDepsDefMem(insn, *memOpnd);
+    BuildDepsAmbiInsn(insn);
+  }
+  if (IsYieldPoint(insn)) {
+    BuildDepsMemBar(insn);
+    BuildDepsDefReg(insn, kRFLAG);
+  }
+}
+
+/* Build Dependency for each Operand of insn */
+void AArch64DepAnalysis::BuildOpndDependency(Insn &insn) {
+  const InsnDesc *md = insn.GetDesc();
+  MOperator mOp = insn.GetMachineOpcode();
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    const OpndDesc *regProp = md->opndMD[i];
+    if (opnd.IsMemoryAccessOperand()) {
+      BuildMemOpndDependency(insn, opnd, *regProp);
+    } else if (opnd.IsStImmediate()) {
+      if (mOp != MOP_xadrpl12) {
+        BuildDepsAccessStImmMem(insn, false);
+      }
+    } else if (opnd.IsRegister()) {
+      RegOperand &regOpnd = static_cast<RegOperand &>(opnd);
+      regno_t regNO = regOpnd.GetRegisterNumber();
+
+      if (regProp->IsUse()) {
+        BuildDepsUseReg(insn, regNO);
+      }
+
+      if (regProp->IsDef()) {
+        BuildDepsDefReg(insn, regNO);
+      }
+    } else if (opnd.IsConditionCode()) {
+      /* For condition operand, such as NE, EQ, and so on. */
+      if (regProp->IsUse()) {
+        BuildDepsUseReg(insn, kRFLAG);
+        BuildDepsBetweenControlRegAndCall(insn, false);
+      }
+
+      if (regProp->IsDef()) {
+        BuildDepsDefReg(insn, kRFLAG);
+        BuildDepsBetweenControlRegAndCall(insn, true);
+      }
+    } else if (opnd.IsList()) {
+      auto &listOpnd = static_cast<const ListOperand &>(opnd);
+      /* Build true dependences */
+      for (auto &lst : listOpnd.GetOperands()) {
+        regno_t regNO = lst->GetRegisterNumber();
+        BuildDepsUseReg(insn, regNO);
+      }
+    }
+  }
+}
+
+static bool IsLazyLoad(MOperator op) {
+  return (op == MOP_lazy_ldr) || (op == MOP_lazy_ldr_static) || (op == MOP_lazy_tail);
+}
+
+/*
+ * Build dependences in some special issue (stack/heap/throw/clinit/lazy binding/control flow).
+ * insn :  a instruction.
+ * depNode : insn's depNode.
+ * nodes : the dependence nodes inclue insn's depNode.
+ */
+void AArch64DepAnalysis::BuildSpecialInsnDependency(Insn &insn, DepNode &depNode, const MapleVector<DepNode *> &nodes) {
+  const InsnDesc *md = insn.GetDesc();
+  MOperator mOp = insn.GetMachineOpcode();
+  if (insn.IsCall() || insn.IsTailCall()) {
+    /* Caller saved registers. */
+    BuildCallerSavedDeps(insn);
+    BuildStackPassArgsDeps(insn);
+
+    if (mOp == MOP_xbl) {
+      FuncNameOperand &target = static_cast<FuncNameOperand &>(insn.GetOperand(0));
+      if ((target.GetName() == "MCC_InitializeLocalStackRef") || (target.GetName() == "MCC_ClearLocalStackRef") ||
+          (target.GetName() == "MCC_DecRefResetPair")) {
+        /* Write stack memory. */
+        BuildDepsDirtyStack(insn);
+      } else if ((target.GetName() == "MCC_CleanupLocalStackRef_NaiveRCFast") ||
+                 (target.GetName() == "MCC_CleanupLocalStackRefSkip_NaiveRCFast") ||
+                 (target.GetName() == "MCC_CleanupLocalStackRefSkip")) {
+        /* UseStackMemory. */
+        BuildDepsUseStack(insn);
+      } else if (cgFunc.GetMirModule().GetSrcLang() == kSrcLangC) {
+        /* potential C aliasing. */
+        BuildDepsDirtyStack(insn);
+      }
+    }
+    BuildDepsDirtyHeap(insn);
+    BuildDepsAmbiInsn(insn);
+    if (lastCallInsn != nullptr) {
+      AddDependence(*lastCallInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeControl);
+    }
+    lastCallInsn = &insn;
+  } else if (insn.IsClinit() || IsLazyLoad(insn.GetMachineOpcode()) ||
+             insn.GetMachineOpcode() == MOP_arrayclass_cache_ldr) {
+    BuildDepsDirtyHeap(insn);
+    BuildDepsDefReg(insn, kRFLAG);
+    if (insn.GetMachineOpcode() != MOP_adrp_ldr) {
+      BuildDepsDefReg(insn, R16);
+      BuildDepsDefReg(insn, R17);
+    }
+  } else if ((mOp == MOP_xret) || md->IsBranch()) {
+    BuildDepsControlAll(depNode, nodes);
+  } else if (insn.IsMemAccessBar()) {
+    BuildDepsMemBar(insn);
+  } else if (insn.IsSpecialIntrinsic()) {
+    BuildDepsDirtyHeap(insn);
+  }
+}
+
+/*
+ * If the instruction's number of current basic block more than kMaxDependenceNum,
+ * then insert some pseudo separator node to split baic block.
+ */
+void AArch64DepAnalysis::SeperateDependenceGraph(MapleVector<DepNode *> &nodes, uint32 &nodeSum) {
+  if ((nodeSum > 0) && ((nodeSum % kMaxDependenceNum) == 0)) {
+    ASSERT(nodeSum == nodes.size(), "CG internal error, nodeSum should equal to nodes.size.");
+    /* Add a pseudo node to seperate dependence graph. */
+    DepNode *separatorNode = BuildSeparatorNode();
+    separatorNode->SetIndex(nodeSum);
+    nodes.emplace_back(separatorNode);
+    BuildDepsSeparator(*separatorNode, nodes);
+
+    if (beforeRA) {
+      /* for all live-out register of current bb */
+      for (auto &regNO : curBB->GetLiveOutRegNO()) {
+        if (regDefs[regNO] != nullptr) {
+          AppendRegUseList(*(separatorNode->GetInsn()), regNO);
+          separatorNode->AddUseReg(regNO);
+          separatorNode->SetRegUses(*regUses[regNO]);
+        }
+      }
+    }
+    ClearAllDepData();
+    separatorIndex = nodeSum++;
+  }
+}
+
+/*
+ * Generate a depNode,
+ * insn  : create depNode for the instruction.
+ * nodes : a vector to store depNode.
+ * nodeSum  : the new depNode's index.
+ * comments : those comment insn between last no-comment's insn and insn.
+ */
+DepNode *AArch64DepAnalysis::GenerateDepNode(Insn &insn, MapleVector<DepNode *> &nodes, int32 nodeSum,
+                                             const MapleVector<Insn *> &comments) {
+  DepNode *depNode = nullptr;
+  Reservation *rev = mad.FindReservation(insn);
+  ASSERT(rev != nullptr, "rev is nullptr");
+  depNode = memPool.New<DepNode>(insn, alloc, rev->GetUnit(), rev->GetUnitNum(), *rev);
+  if (beforeRA) {
+    RegPressure *regPressure = memPool.New<RegPressure>(alloc);
+    depNode->SetRegPressure(*regPressure);
+    depNode->InitPressure();
+  }
+  depNode->SetIndex(nodeSum);
+  nodes.emplace_back(depNode);
+  insn.SetDepNode(*depNode);
+
+  constexpr size_t vectorSize = 5;
+  depNode->ReservePreds(vectorSize);
+  depNode->ReserveSuccs(vectorSize);
+
+  if (!comments.empty()) {
+    depNode->SetComments(comments);
+  }
+  return depNode;
+}
+
+void AArch64DepAnalysis::BuildAmbiInsnDependency(Insn &insn) {
+  const auto &defRegnos = insn.GetDepNode()->GetDefRegnos();
+  for (const auto &regNO : defRegnos) {
+    if (IfInAmbiRegs(regNO)) {
+      BuildDepsAmbiInsn(insn);
+      break;
+    }
+  }
+}
+
+void AArch64DepAnalysis::BuildMayThrowInsnDependency(Insn &insn) {
+  /* build dependency for maythrow insn; */
+  if (insn.MayThrow()) {
+    BuildDepsMayThrowInsn(insn);
+    if (lastFrameDef != nullptr) {
+      AddDependence(*lastFrameDef->GetDepNode(), *insn.GetDepNode(), kDependenceTypeThrow);
+    }
+  }
+}
+
+void AArch64DepAnalysis::UpdateRegUseAndDef(Insn &insn, const DepNode &depNode, MapleVector<DepNode *> &nodes) {
+  const auto &useRegnos = depNode.GetUseRegnos();
+  if (beforeRA) {
+    depNode.InitRegUsesSize(useRegnos.size());
+  }
+  for (auto regNO : useRegnos) {
+    AppendRegUseList(insn, regNO);
+    if (beforeRA) {
+      depNode.SetRegUses(*regUses[regNO]);
+      if (regDefs[regNO] == nullptr) {
+        regDefs[regNO] = nodes[separatorIndex]->GetInsn();
+        nodes[separatorIndex]->AddDefReg(regNO);
+        nodes[separatorIndex]->SetRegDefs(nodes[separatorIndex]->GetDefRegnos().size(), regUses[regNO]);
+      }
+    }
+  }
+
+  const auto &defRegnos = depNode.GetDefRegnos();
+  size_t i = 0;
+  if (beforeRA) {
+    depNode.InitRegDefsSize(defRegnos.size());
+  }
+  for (const auto regNO : defRegnos) {
+    regDefs[regNO] = &insn;
+    regUses[regNO] = nullptr;
+    if (beforeRA) {
+      depNode.SetRegDefs(i, nullptr);
+      if (regNO >= R0 && regNO <= R3) {
+        depNode.SetHasPreg(true);
+      } else if (regNO == R8) {
+        depNode.SetHasNativeCallRegister(true);
+      }
+    }
+    ++i;
+  }
+}
+
+/* Update stack and heap dependency */
+void AArch64DepAnalysis::UpdateStackAndHeapDependency(DepNode &depNode, Insn &insn, const Insn &locInsn) {
+  if (!insn.MayThrow()) {
+    return;
+  }
+  depNode.SetLocInsn(locInsn);
+  mayThrows.emplace_back(&insn);
+  AddDependence4InsnInVectorByType(stackDefs, insn, kDependenceTypeThrow);
+  AddDependence4InsnInVectorByType(heapDefs, insn, kDependenceTypeThrow);
+}
+
+/* Add a separatorNode to the end of a nodes
+ *  * before RA:  add all live-out registers to this separatorNode'Uses
+ *   */
+void AArch64DepAnalysis::AddEndSeparatorNode(MapleVector<DepNode *> &nodes) {
+  DepNode *separatorNode = BuildSeparatorNode();
+  nodes.emplace_back(separatorNode);
+  BuildDepsSeparator(*separatorNode, nodes);
+
+  if (beforeRA) {
+    /* for all live-out register of current bb */
+    for (auto &regNO : curBB->GetLiveOutRegNO()) {
+      if (regDefs[regNO] != nullptr) {
+        AppendRegUseList(*(separatorNode->GetInsn()), regNO);
+        separatorNode->AddUseReg(regNO);
+        separatorNode->SetRegUses(*regUses[regNO]);
+      }
+    }
+  }
+}
+
+/*
+ * Build dependence graph.
+ * 1: Build dependence nodes.
+ * 2: Build edges between dependence nodes. Edges are:
+ *   2.1) True dependences
+ *   2.2) Anti dependences
+ *   2.3) Output dependences
+ *   2.4) Barrier dependences
+ */
+void AArch64DepAnalysis::Run(BB &bb, MapleVector<DepNode *> &nodes) {
+  /* Initial internal datas. */
+  Init(bb, nodes);
+  uint32 nodeSum = 1;
+  MapleVector<Insn *> comments(alloc.Adapter());
+  const Insn *locInsn = bb.GetFirstLoc();
+  FOR_BB_INSNS(insn, (&bb)) {
+    if (!insn->IsMachineInstruction()) {
+      if (insn->IsImmaterialInsn()) {
+        if (!insn->IsComment()) {
+          locInsn = insn;
+        } else {
+          comments.emplace_back(insn);
+        }
+      } else if (insn->IsCfiInsn()) {
+        if (!nodes.empty()) {
+          nodes.back()->AddCfiInsn(*insn);
+        }
+      }
+      continue;
+    }
+    /* Add a pseudo node to seperate dependence graph when appropriate */
+    SeperateDependenceGraph(nodes, nodeSum);
+    /* generate a DepNode */
+    DepNode *depNode = GenerateDepNode(*insn, nodes, nodeSum, comments);
+    ++nodeSum;
+    comments.clear();
+    /* Build Dependency for maythrow insn; */
+    BuildMayThrowInsnDependency(*insn);
+    /* Build Dependency for each Operand of insn */
+    BuildOpndDependency(*insn);
+    /* Build Dependency for special insn */
+    BuildSpecialInsnDependency(*insn, *depNode, nodes);
+    /* Build Dependency for AmbiInsn if needed */
+    BuildAmbiInsnDependency(*insn);
+    /* Update stack and heap dependency */
+    UpdateStackAndHeapDependency(*depNode, *insn, *locInsn);
+    if (insn->IsFrameDef()) {
+      lastFrameDef = insn;
+    }
+    /* Seperator exists. */
+    AddDependence(*nodes[separatorIndex], *insn->GetDepNode(), kDependenceTypeSeparator);
+    /* Update register use and register def */
+    UpdateRegUseAndDef(*insn, *depNode, nodes);
+  }
+
+  AddEndSeparatorNode(nodes);
+
+  if (!comments.empty()) {
+    lastComments = comments;
+  }
+  comments.clear();
+}
+
+/* return dependence type name */
+const std::string &AArch64DepAnalysis::GetDepTypeName(DepType depType) const {
+  ASSERT(depType <= kDependenceTypeNone, "array boundary check failed");
+  return kDepTypeName[depType];
+}
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_ebo.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ebo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3f1c5c7ca27799c2f8a2ff45ac662ffd9b4aeee9
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ebo.cpp
@@ -0,0 +1,1537 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_ebo.h"
+#include "aarch64_cg.h"
+#include "mpl_logging.h"
+#include "aarch64_utils.h"
+
+namespace maplebe {
+using namespace maple;
+#define EBO_DUMP CG_DEBUG_FUNC(*cgFunc)
+
+enum AArch64Ebo::ExtOpTable : uint8 {
+  AND,
+  SXTB,
+  SXTH,
+  SXTW,
+  ZXTB,
+  ZXTH,
+  ZXTW,
+  ExtTableSize
+};
+
+namespace {
+
+using PairMOperator = MOperator[2];
+
+constexpr uint8 kInsPairsNum = 5;
+
+PairMOperator extInsnPairTable[ExtTableSize][kInsPairsNum] = {
+  /* {origMop, newMop} */
+  {{MOP_wldrb, MOP_wldrb},  {MOP_wldrsh, MOP_wldrb},   {MOP_wldrh, MOP_wldrb},   {MOP_xldrsw, MOP_wldrb},
+   {MOP_wldr, MOP_wldrb}},   /* AND */
+  {{MOP_wldrb, MOP_wldrsb}, {MOP_wldr, MOP_wldrsb},   {MOP_undef, MOP_undef},   {MOP_undef, MOP_undef},
+   {MOP_undef, MOP_undef}},   /* SXTB */
+  {{MOP_wldrh, MOP_wldrsh}, {MOP_wldrb, MOP_wldrb},   {MOP_wldrsb, MOP_wldrsb}, {MOP_wldrsh, MOP_wldrsh},
+   {MOP_undef, MOP_undef}},   /* SXTH */
+  {{MOP_wldrh, MOP_wldrh},  {MOP_wldrsh, MOP_wldrsh}, {MOP_wldrb, MOP_wldrb},   {MOP_wldrsb, MOP_wldrsb},
+   {MOP_wldr, MOP_xldrsw}}, /* SXTW */
+  {{MOP_wldrb, MOP_wldrb},  {MOP_wldrsb, MOP_wldrb},  {MOP_undef, MOP_undef},   {MOP_undef, MOP_undef},
+   {MOP_undef, MOP_undef}},   /* ZXTB */
+  {{MOP_wldrh, MOP_wldrh},  {MOP_wldrb, MOP_wldrb},   {MOP_wldr, MOP_wldrh},   {MOP_undef, MOP_undef},
+   {MOP_undef, MOP_undef}},   /* ZXTH */
+  {{MOP_wldr, MOP_wldr},    {MOP_wldrh, MOP_wldrh},   {MOP_wldrb, MOP_wldrb},   {MOP_undef, MOP_undef},
+   {MOP_undef, MOP_undef}}    /* ZXTW */
+};
+
+} // anonymous namespace
+
+MOperator AArch64Ebo::ExtLoadSwitchBitSize(MOperator lowMop) const {
+  switch (lowMop) {
+    case MOP_wldrsb :
+      return MOP_xldrsb;
+    case MOP_wldrsh :
+      return MOP_xldrsh;
+    default:
+      break;
+  }
+  return lowMop;
+}
+
+bool AArch64Ebo::IsFmov(const Insn &insn) const {
+  return ((insn.GetMachineOpcode() >= MOP_xvmovsr) && (insn.GetMachineOpcode() <= MOP_xvmovrd));
+}
+
+bool AArch64Ebo::IsAdd(const Insn &insn) const {
+  return ((insn.GetMachineOpcode() >= MOP_xaddrrr) && (insn.GetMachineOpcode() <= MOP_ssub));
+}
+
+bool AArch64Ebo::IsInvalidReg(const RegOperand &opnd) const {
+  return (opnd.GetRegisterNumber() == AArch64reg::kRinvalid);
+}
+
+bool AArch64Ebo::IsZeroRegister(const Operand &opnd) const {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  const RegOperand *regOpnd = static_cast<const RegOperand*>(&opnd);
+  return regOpnd->GetRegisterNumber() == RZR;
+}
+
+bool AArch64Ebo::IsConstantImmOrReg(const Operand &opnd) const {
+  if (opnd.IsConstImmediate()) {
+    return true;
+  }
+  return IsZeroRegister(opnd);
+}
+
+bool AArch64Ebo::IsClinitCheck(const Insn &insn) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  return ((mOp == MOP_clinit) || (mOp == MOP_clinit_tail));
+}
+
+bool AArch64Ebo::IsDecoupleStaticOp(Insn &insn) const {
+  if (insn.GetMachineOpcode() == MOP_lazy_ldr_static) {
+    Operand *opnd1 = &insn.GetOperand(kInsnSecondOpnd);
+    CHECK_FATAL(opnd1 != nullptr, "opnd1 is null!");
+    auto *stImmOpnd = static_cast<StImmOperand*>(opnd1);
+    return StringUtils::StartsWith(stImmOpnd->GetName(), namemangler::kDecoupleStaticValueStr);
+  }
+  return false;
+}
+
+static bool IsYieldPoint(Insn &insn) {
+  /*
+   * It is a yieldpoint if loading from a dedicated
+   * register holding polling page address:
+   * ldr  wzr, [RYP]
+   */
+  if (insn.IsLoad() && !insn.IsLoadLabel()) {
+    auto mem = static_cast<MemOperand*>(insn.GetMemOpnd());
+    return (mem != nullptr && mem->GetBaseRegister() != nullptr && mem->GetBaseRegister()->GetRegisterNumber() == RYP);
+  }
+  return false;
+}
+
+/* retrun true if insn is globalneeded */
+bool AArch64Ebo::IsGlobalNeeded(Insn &insn) const {
+  /* Calls may have side effects. */
+  if (insn.IsCall()) {
+    return true;
+  }
+
+  /* Intrinsic call should not be removed. */
+  if (insn.IsSpecialIntrinsic()) {
+    return true;
+  }
+
+  /* Clinit should not be removed. */
+  if (IsClinitCheck(insn)) {
+    return true;
+  }
+
+  /* Yieldpoints should not be removed by optimizer. */
+  if (cgFunc->GetCG()->GenYieldPoint() && IsYieldPoint(insn)) {
+    return true;
+  }
+
+  std::set<uint32> defRegs = insn.GetDefRegs();
+  for (auto defRegNo : defRegs) {
+    if (defRegNo == RZR || defRegNo == RSP || ((defRegNo == RFP || defRegNo == R29) && CGOptions::UseFramePointer())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/* in aarch64,resOp will not be def and use in the same time */
+bool AArch64Ebo::ResIsNotDefAndUse(Insn &insn) const {
+  (void)insn;
+  return true;
+}
+
+/* Return true if opnd live out of bb. */
+bool AArch64Ebo::LiveOutOfBB(const Operand &opnd, const BB &bb) const {
+  CHECK_FATAL(opnd.IsRegister(), "expect register here.");
+  /* when optimize_level < 2, there is need to anlyze live range. */
+  if (live == nullptr) {
+    return false;
+  }
+  bool isLiveOut = false;
+  if (bb.GetLiveOut()->TestBit(static_cast<RegOperand const*>(&opnd)->GetRegisterNumber())) {
+    isLiveOut = true;
+  }
+  return isLiveOut;
+}
+
+bool AArch64Ebo::IsLastAndBranch(BB &bb, Insn &insn) const {
+  return (bb.GetLastInsn() == &insn) && insn.IsBranch();
+}
+
+bool AArch64Ebo::IsSameRedefine(BB &bb, Insn &insn, OpndInfo &opndInfo) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  if (!(mOp == MOP_wmovri32 || mOp == MOP_xmovri64 || mOp == MOP_wsfmovri || mOp == MOP_xdfmovri)) {
+    return false;
+  }
+  OpndInfo *sameInfo = opndInfo.same;
+  if (sameInfo == nullptr || sameInfo->insn == nullptr || sameInfo->bb != &bb ||
+      sameInfo->insn->GetMachineOpcode() != mOp) {
+    return false;
+  }
+  Insn *prevInsn = sameInfo->insn;
+  if (!prevInsn->GetOperand(kInsnSecondOpnd).IsImmediate()) {
+    return false;
+  }
+  auto &sameOpnd = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+  auto &opnd = static_cast<ImmOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  if (sameOpnd.GetValue() == opnd.GetValue()) {
+    sameInfo->refCount += opndInfo.refCount;
+    return true;
+  }
+  return false;
+}
+
+const RegOperand &AArch64Ebo::GetRegOperand(const Operand &opnd) const {
+  CHECK_FATAL(opnd.IsRegister(), "aarch64 shoud not have regShiftOp! opnd is not register!");
+  const auto &res = static_cast<const RegOperand&>(opnd);
+  return res;
+}
+
+/* Create infomation for local_opnd from its def insn current_insn. */
+OpndInfo *AArch64Ebo::OperandInfoDef(BB &currentBB, Insn &currentInsn, Operand &localOpnd) {
+  int32 hashVal = localOpnd.IsRegister() ? -1 : ComputeOpndHash(localOpnd);
+  OpndInfo *opndInfoPrev = GetOpndInfo(localOpnd, hashVal);
+  OpndInfo *opndInfo = GetNewOpndInfo(currentBB, &currentInsn, localOpnd, hashVal);
+  if (localOpnd.IsMemoryAccessOperand()) {
+    MemOpndInfo *memInfo = static_cast<MemOpndInfo*>(opndInfo);
+    MemOperand *mem = static_cast<MemOperand*>(&localOpnd);
+    Operand *base = mem->GetBaseRegister();
+    Operand *offset = mem->GetOffset();
+    if (base != nullptr && base->IsRegister()) {
+      memInfo->SetBaseInfo(*OperandInfoUse(currentBB, *base));
+    }
+    if (offset != nullptr && offset->IsRegister()) {
+      memInfo->SetOffsetInfo(*OperandInfoUse(currentBB, *offset));
+    }
+  }
+  opndInfo->same = opndInfoPrev;
+  if ((opndInfoPrev != nullptr)) {
+    opndInfoPrev->redefined = true;
+    if (opndInfoPrev->bb == &currentBB) {
+      opndInfoPrev->redefinedInBB = true;
+      opndInfoPrev->redefinedInsn = &currentInsn;
+    }
+    UpdateOpndInfo(localOpnd, *opndInfoPrev, opndInfo, hashVal);
+  } else {
+    SetOpndInfo(localOpnd, opndInfo, hashVal);
+  }
+  return opndInfo;
+}
+
+void AArch64Ebo::DefineClinitSpecialRegisters(InsnInfo &insnInfo) {
+  Insn *insn = insnInfo.insn;
+  CHECK_FATAL(insn != nullptr, "nullptr of currInsnInfo");
+  RegOperand &phyOpnd1 = a64CGFunc->GetOrCreatePhysicalRegisterOperand(R16, k64BitSize, kRegTyInt);
+  OpndInfo *opndInfo = OperandInfoDef(*insn->GetBB(), *insn, phyOpnd1);
+  opndInfo->insnInfo = &insnInfo;
+
+  RegOperand &phyOpnd2 = a64CGFunc->GetOrCreatePhysicalRegisterOperand(R17, k64BitSize, kRegTyInt);
+  opndInfo = OperandInfoDef(*insn->GetBB(), *insn, phyOpnd2);
+  opndInfo->insnInfo = &insnInfo;
+}
+
+void AArch64Ebo::BuildCallerSaveRegisters() {
+  callerSaveRegTable.clear();
+  RegOperand &phyOpndR0 = a64CGFunc->GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, kRegTyInt);
+  RegOperand &phyOpndV0 = a64CGFunc->GetOrCreatePhysicalRegisterOperand(V0, k64BitSize, kRegTyFloat);
+  callerSaveRegTable.emplace_back(&phyOpndR0);
+  callerSaveRegTable.emplace_back(&phyOpndV0);
+  for (uint32 i = R1; i <= R18; i++) {
+    RegOperand &phyOpnd =
+        a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyInt);
+    callerSaveRegTable.emplace_back(&phyOpnd);
+  }
+  for (uint32 i = V1; i <= V7; i++) {
+    RegOperand &phyOpnd =
+        a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyFloat);
+    callerSaveRegTable.emplace_back(&phyOpnd);
+  }
+  for (uint32 i = V16; i <= V31; i++) {
+    RegOperand &phyOpnd =
+        a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyFloat);
+    callerSaveRegTable.emplace_back(&phyOpnd);
+  }
+  CHECK_FATAL(callerSaveRegTable.size() < kMaxCallerSaveReg,
+      "number of elements in callerSaveRegTable must less then 45!");
+}
+
+void AArch64Ebo::DefineAsmRegisters(InsnInfo &insnInfo) {
+  Insn *insn = insnInfo.insn;
+  ASSERT(insn->GetMachineOpcode() == MOP_asm, "insn should be a call insn.");
+  auto &outList = static_cast<const ListOperand&>(insn->GetOperand(kAsmOutputListOpnd));
+  for (auto &opnd : outList.GetOperands()) {
+    OpndInfo *opndInfo = OperandInfoDef(*insn->GetBB(), *insn, *opnd);
+    opndInfo->insnInfo = &insnInfo;
+  }
+  auto &clobberList = static_cast<const ListOperand&>(insn->GetOperand(kAsmClobberListOpnd));
+  for (auto &opnd : clobberList.GetOperands()) {
+    OpndInfo *opndInfo = OperandInfoDef(*insn->GetBB(), *insn, *opnd);
+    opndInfo->insnInfo = &insnInfo;
+  }
+  auto &inList = static_cast<const ListOperand&>(insn->GetOperand(kAsmInputListOpnd));
+  for (auto &opnd : inList.GetOperands()) {
+    OperandInfoUse(*(insn->GetBB()), *opnd);
+  }
+}
+
+void AArch64Ebo::DefineCallerSaveRegisters(InsnInfo &insnInfo) {
+  Insn *insn = insnInfo.insn;
+  if (insn->IsAsmInsn()) {
+    DefineAsmRegisters(insnInfo);
+    return;
+  }
+  ASSERT(insn->IsCall() || insn->IsTailCall(), "insn should be a call insn.");
+  if (CGOptions::DoIPARA()) {
+    auto *targetOpnd = insn->GetCallTargetOperand();
+    CHECK_FATAL(targetOpnd != nullptr, "target is null in Insn::IsCallToFunctionThatNeverReturns");
+    if (targetOpnd->IsFuncNameOpnd()) {
+      FuncNameOperand *target = static_cast<FuncNameOperand*>(targetOpnd);
+      const MIRSymbol *funcSt = target->GetFunctionSymbol();
+      ASSERT(funcSt->GetSKind() == kStFunc, "funcst must be a function name symbol");
+      MIRFunction *func = funcSt->GetFunction();
+      if (func != nullptr && func->IsReferedRegsValid()) {
+        for (auto preg : func->GetReferedRegs()) {
+          if (AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(preg))) {
+            continue;
+          }
+          RegOperand *opnd = &a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(preg), k64BitSize,
+              AArch64isa::IsFPSIMDRegister(static_cast<AArch64reg>(preg)) ? kRegTyFloat : kRegTyInt);
+          OpndInfo *opndInfo = OperandInfoDef(*insn->GetBB(), *insn, *opnd);
+          opndInfo->insnInfo = &insnInfo;
+        }
+        return;
+      }
+    }
+  }
+  for (auto opnd : callerSaveRegTable) {
+    OpndInfo *opndInfo = OperandInfoDef(*insn->GetBB(), *insn, *opnd);
+    opndInfo->insnInfo = &insnInfo;
+  }
+}
+
+void AArch64Ebo::DefineReturnUseRegister(Insn &insn) {
+  if (insn.GetMachineOpcode() != MOP_xret) {
+    return;
+  }
+  /* Define scalar callee save register and FP, LR. */
+  for (uint32 i = R19; i <= R30; i++) {
+    RegOperand &phyOpnd =
+        a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyInt);
+    OperandInfoUse(*insn.GetBB(), phyOpnd);
+  }
+
+  /* Define SP */
+  RegOperand &phyOpndSP =
+      a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(RSP), k64BitSize, kRegTyInt);
+  OperandInfoUse(*insn.GetBB(), phyOpndSP);
+
+  /* Define FP callee save registers. */
+  for (uint32 i = V8; i <= V15; i++) {
+    RegOperand &phyOpnd =
+        a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyFloat);
+    OperandInfoUse(*insn.GetBB(), phyOpnd);
+  }
+}
+
+void AArch64Ebo::DefineCallUseSpecialRegister(Insn &insn) {
+  if (insn.GetMachineOpcode() == MOP_asm) {
+    return;
+  }
+  AArch64reg fpRegNO = RFP;
+  if (!beforeRegAlloc && cgFunc->UseFP()) {
+    fpRegNO = R29;
+  }
+  /* Define FP, LR. */
+  RegOperand &phyOpndFP =
+      a64CGFunc->GetOrCreatePhysicalRegisterOperand(fpRegNO, k64BitSize, kRegTyInt);
+  OperandInfoUse(*insn.GetBB(), phyOpndFP);
+  RegOperand &phyOpndLR =
+      a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(RLR), k64BitSize, kRegTyInt);
+  OperandInfoUse(*insn.GetBB(), phyOpndLR);
+
+  /* Define SP */
+  RegOperand &phyOpndSP =
+      a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(RSP), k64BitSize, kRegTyInt);
+  OperandInfoUse(*insn.GetBB(), phyOpndSP);
+}
+
+/* return true if op1 == op2 */
+bool AArch64Ebo::OperandEqSpecial(const Operand &op1, const Operand &op2) const {
+  switch (op1.GetKind()) {
+    case Operand::kOpdRegister: {
+      const RegOperand &reg1 = static_cast<const RegOperand&>(op1);
+      const RegOperand &reg2 = static_cast<const RegOperand&>(op2);
+      return reg1 == reg2;
+    }
+    case Operand::kOpdImmediate: {
+      const ImmOperand &imm1 = static_cast<const ImmOperand&>(op1);
+      const ImmOperand &imm2 = static_cast<const ImmOperand&>(op2);
+      return imm1 == imm2;
+    }
+    case Operand::kOpdOffset: {
+      const OfstOperand &ofst1 = static_cast<const OfstOperand&>(op1);
+      const OfstOperand &ofst2 = static_cast<const OfstOperand&>(op2);
+      return ofst1 == ofst2;
+    }
+    case Operand::kOpdStImmediate: {
+      const StImmOperand &stImm1 = static_cast<const StImmOperand&>(op1);
+      const StImmOperand &stImm2 = static_cast<const StImmOperand&>(op2);
+      return stImm1 == stImm2;
+    }
+    case Operand::kOpdMem: {
+      const MemOperand &mem1 = static_cast<const MemOperand&>(op1);
+      const MemOperand &mem2 = static_cast<const MemOperand&>(op2);
+      if (mem1.GetAddrMode() == mem2.GetAddrMode()) {
+        ASSERT(mem1.GetBaseRegister() != nullptr, "nullptr check");
+        ASSERT(mem2.GetBaseRegister() != nullptr, "nullptr check");
+      }
+      return ((mem1.GetAddrMode() == mem2.GetAddrMode()) &&
+              OperandEqual(*(mem1.GetBaseRegister()), *(mem2.GetBaseRegister())) &&
+              OperandEqual(*(mem1.GetIndexRegister()), *(mem2.GetIndexRegister())) &&
+              OperandEqual(*(mem1.GetOffsetOperand()), *(mem2.GetOffsetOperand())) &&
+              (mem1.GetSymbol() == mem2.GetSymbol()) && (mem1.GetSize() == mem2.GetSize()));
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+int32 AArch64Ebo::GetOffsetVal(const MemOperand &memOpnd) const {
+  OfstOperand *offset = memOpnd.GetOffsetImmediate();
+  int32 val = 0;
+  if (offset != nullptr) {
+    val += static_cast<int>(offset->GetOffsetValue());
+
+    if (offset->IsSymOffset() || offset->IsSymAndImmOffset()) {
+      val += static_cast<int32>(offset->GetSymbol()->GetStIdx().Idx());
+    }
+  }
+  return val;
+}
+
+/*
+ * move vreg1, #1
+ * move vreg2, vreg1
+ * ===>
+ * move vreg1, #1
+ * move vreg2, #1
+ * return true if do simplify successfully.
+ */
+bool AArch64Ebo::DoConstProp(Insn &insn, uint32 idx, Operand &opnd) {
+  ImmOperand *src = static_cast<ImmOperand*>(&opnd);
+  const InsnDesc *md = &AArch64CG::kMd[(insn.GetMachineOpcode())];
+  /* avoid the invalid case "cmp wzr, #0"/"add w1, wzr, #100" */
+  Operand &destOpnd = insn.GetOperand(idx);
+  if (src->IsZero() && destOpnd.IsRegister() &&
+      (static_cast<RegOperand&>(destOpnd).GetRegisterType() == kRegTyInt) &&
+      (insn.IsStore() || insn.IsMove() || md->IsCondDef())) {
+    insn.SetOperand(idx, *GetZeroOpnd(src->GetSize()));
+    return true;
+  }
+  MOperator mopCode = insn.GetMachineOpcode();
+  switch (mopCode) {
+    case MOP_xmovrr:
+    case MOP_wmovrr: {
+      ASSERT(idx == kInsnSecondOpnd, "src const for move must be the second operand.");
+      uint32 targetSize = insn.GetOperand(idx).GetSize();
+      if (src->GetSize() != targetSize) {
+        src = static_cast<ImmOperand*>(src->Clone(*cgFunc->GetMemoryPool()));
+        CHECK_FATAL(src != nullptr, "pointer result is null");
+        src->SetSize(targetSize);
+      }
+      if (src->IsSingleInstructionMovable() && (insn.GetOperand(kInsnFirstOpnd).GetSize() == targetSize)) {
+        if (EBO_DUMP) {
+          LogInfo::MapleLogger() << " Do constprop:Prop constval " << src->GetValue() << "into insn:\n";
+          insn.Dump();
+        }
+        insn.SetOperand(kInsnSecondOpnd, *src);
+        MOperator mOp = (mopCode == MOP_wmovrr) ? MOP_wmovri32 : MOP_xmovri64;
+        insn.SetMOP(AArch64CG::kMd[mOp]);
+        if (EBO_DUMP) {
+          LogInfo::MapleLogger() << " after constprop the insn is:\n";
+          insn.Dump();
+        }
+        return true;
+      }
+      break;
+    }
+    case MOP_xaddrrr:
+    case MOP_waddrrr:
+    case MOP_xsubrrr:
+    case MOP_wsubrrr: {
+      if ((idx != kInsnThirdOpnd) || !src->IsInBitSize(kMaxImmVal24Bits, 0) ||
+          !(src->IsInBitSize(kMaxImmVal12Bits, 0) || src->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits))) {
+        return false;
+      }
+      Operand &result = insn.GetOperand(0);
+      bool is64Bits = (result.GetSize() == k64BitSize);
+      if (EBO_DUMP) {
+        LogInfo::MapleLogger() << " Do constprop:Prop constval " << src->GetValue() << "into insn:\n";
+        insn.Dump();
+      }
+      if (src->IsZero()) {
+        MOperator mOp = is64Bits ? MOP_xmovrr : MOP_wmovrr;
+        insn.SetMOP(AArch64CG::kMd[mOp]);
+        insn.PopBackOperand();
+        if (EBO_DUMP) {
+          LogInfo::MapleLogger() << " after constprop the insn is:\n";
+          insn.Dump();
+        }
+        return true;
+      }
+      insn.SetOperand(kInsnThirdOpnd, *src);
+      if ((mopCode == MOP_xaddrrr) || (mopCode == MOP_waddrrr)) {
+        is64Bits ? insn.SetMOP(AArch64CG::kMd[MOP_xaddrri12]) : insn.SetMOP(AArch64CG::kMd[MOP_waddrri12]);
+      } else if ((mopCode == MOP_xsubrrr) || (mopCode == MOP_wsubrrr)) {
+        is64Bits ? insn.SetMOP(AArch64CG::kMd[MOP_xsubrri12]) : insn.SetMOP(AArch64CG::kMd[MOP_wsubrri12]);
+      }
+      if (EBO_DUMP) {
+        LogInfo::MapleLogger() << " after constprop the insn is:\n";
+        insn.Dump();
+      }
+      return true;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+/* optimize csel to cset */
+bool AArch64Ebo::Csel2Cset(Insn &insn, const MapleVector<Operand*> &opnds) {
+  MOperator opCode = insn.GetMachineOpcode();
+  /* csel ->cset */
+  if ((opCode == MOP_wcselrrrc) || (opCode == MOP_xcselrrrc)) {
+    Operand *res = &insn.GetOperand(kInsnFirstOpnd);
+    ASSERT(res != nullptr, "expect a register");
+    ASSERT(res->IsRegister(), "expect a register");
+    /* only do integers */
+    RegOperand *reg = static_cast<RegOperand*>(res);
+    if ((res == nullptr) || (!reg->IsOfIntClass())) {
+      return false;
+    }
+    Operand *op0 = opnds.at(kInsnSecondOpnd);
+    Operand *op1 = opnds.at(kInsnThirdOpnd);
+    ImmOperand *imm0 = nullptr;
+    ImmOperand *imm1 = nullptr;
+    if (op0->IsImmediate()) {
+      imm0 = static_cast<ImmOperand*>(op0);
+    }
+    if (op1->IsImmediate()) {
+      imm1 = static_cast<ImmOperand*>(op1);
+    }
+
+    bool reverse = (imm1 != nullptr) && imm1->IsOne() &&
+                   (((imm0 != nullptr) && imm0->IsZero()) || IsZeroRegister(*op0));
+    if (((imm0 != nullptr) && imm0->IsOne() && (((imm1 != nullptr) && imm1->IsZero()) || IsZeroRegister(*op1))) ||
+        reverse) {
+      if (EBO_DUMP) {
+        LogInfo::MapleLogger() << "change csel insn :\n";
+        insn.Dump();
+      }
+      AArch64CGFunc *aarFunc = static_cast<AArch64CGFunc *>(cgFunc);
+      Operand &condOperand = insn.GetOperand(kInsnFourthOpnd);
+      Operand &rflag = aarFunc->GetOrCreateRflag();
+      if (!reverse) {
+        Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+            (opCode == MOP_xcselrrrc) ? MOP_xcsetrc : MOP_wcsetrc, *res, condOperand, rflag);
+        insn.GetBB()->ReplaceInsn(insn, newInsn);
+        if (EBO_DUMP) {
+          LogInfo::MapleLogger() << "to cset insn ====>\n";
+          newInsn.Dump();
+        }
+      } else {
+        auto &cond = static_cast<CondOperand&>(condOperand);
+        if (!CheckCondCode(cond)) {
+          return false;
+        }
+        CondOperand &reverseCond = a64CGFunc->GetCondOperand(GetReverseCond(cond));
+        Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+            (opCode == MOP_xcselrrrc) ? MOP_xcsetrc : MOP_wcsetrc, *res, reverseCond, rflag);
+        insn.GetBB()->ReplaceInsn(insn, newInsn);
+        if (EBO_DUMP) {
+          LogInfo::MapleLogger() << "to cset insn ====>\n";
+          newInsn.Dump();
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+/* Look at an expression that has a constant operand and attempt to simplify the computations. */
+bool AArch64Ebo::SimplifyConstOperand(Insn &insn, const MapleVector<Operand*> &opnds,
+                                      const MapleVector<OpndInfo*> &opndInfo) {
+  BB *bb = insn.GetBB();
+  bool result = false;
+  if (insn.GetOperandSize() <= 1) {
+    return false;
+  }
+  ASSERT(opnds.size() > 1, "opnds size must greater than 1");
+  Operand *op0 = opnds[kInsnSecondOpnd];
+  Operand *op1 = opnds[kInsnThirdOpnd];
+  Operand *res = &insn.GetOperand(kInsnFirstOpnd);
+  CHECK_FATAL(res != nullptr, "null ptr check");
+  uint32 opndSize = insn.GetDesc()->GetOperandSize();
+  bool op0IsConstant = IsConstantImmOrReg(*op0) && !IsConstantImmOrReg(*op1);
+  bool op1IsConstant = !IsConstantImmOrReg(*op0) && IsConstantImmOrReg(*op1);
+  bool bothConstant = IsConstantImmOrReg(*op0) && IsConstantImmOrReg(*op1);
+  ImmOperand *immOpnd = nullptr;
+  Operand *op = nullptr;
+  int32 idx0 = kInsnSecondOpnd;
+  if (op0IsConstant) {
+    // cannot convert zero reg (r30) to a immOperand
+    immOpnd = IsZeroRegister(*op0) ? &a64CGFunc->CreateImmOperand(0, op0->GetSize(), false)
+                                    : static_cast<ImmOperand*>(op0);
+    op = op1;
+    if (op->IsMemoryAccessOperand()) {
+      op = &(insn.GetOperand(kInsnThirdOpnd));
+    }
+    idx0 = kInsnThirdOpnd;
+  } else if (op1IsConstant) {
+    // cannot convert zero reg (r30) to a immOperand
+    immOpnd = IsZeroRegister(*op1) ? &a64CGFunc->CreateImmOperand(0, op1->GetSize(), false)
+                                    : static_cast<ImmOperand*>(op1);
+    op = op0;
+    if (op->IsMemoryAccessOperand()) {
+      op = &(insn.GetOperand(kInsnSecondOpnd));
+    }
+  } else if (bothConstant) {
+    ImmOperand *immOpnd0 = IsZeroRegister(*op0) ? &a64CGFunc->CreateImmOperand(0, op0->GetSize(), false)
+                                                 : static_cast<ImmOperand*>(op0);
+    ImmOperand *immOpnd1 = IsZeroRegister(*op1) ? &a64CGFunc->CreateImmOperand(0, op1->GetSize(), false)
+                                                 : static_cast<ImmOperand*>(op1);
+    return SimplifyBothConst(*insn.GetBB(), insn, *immOpnd0, *immOpnd1, opndSize);
+  }
+  CHECK_FATAL(immOpnd != nullptr, "constant operand required!");
+  CHECK_FATAL(op != nullptr, "constant operand required!");
+  /* For orr insn and one of the opnd is zero
+   * orr resOp, imm1, #0  |  orr resOp, #0, imm1
+   * =======>
+   * mov resOp, imm1 */
+  if (((insn.GetMachineOpcode() == MOP_wiorrri12) || (insn.GetMachineOpcode() == MOP_xiorrri13)) && immOpnd->IsZero()) {
+    MOperator mOp = opndSize == k64BitSize ? MOP_xmovrr : MOP_wmovrr;
+    Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, *res, *op);
+    bb->ReplaceInsn(insn, newInsn);
+    return true;
+  }
+  /* For the imm is 0. Then replace the insn by a move insn. */
+  if (((insn.GetMachineOpcode() >= MOP_xaddrrr) && (insn.GetMachineOpcode() <= MOP_sadd) && immOpnd->IsZero()) ||
+      (op1IsConstant && (insn.GetMachineOpcode() >= MOP_xsubrrr) && (insn.GetMachineOpcode() <= MOP_ssub) &&
+       immOpnd->IsZero())) {
+    Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(opndSize == k64BitSize ? MOP_xmovrr : MOP_wmovrr, *res, *op);
+    bb->ReplaceInsn(insn, newInsn);
+    return true;
+  }
+
+  if ((insn.GetMachineOpcode() == MOP_xaddrrr) || (insn.GetMachineOpcode() == MOP_waddrrr)) {
+    if (immOpnd->IsInBitSize(kMaxImmVal24Bits, 0)) {
+      /*
+       * ADD Wd|WSP, Wn|WSP, #imm{, shift} ; 32-bit general registers
+       * ADD Xd|SP,  Xn|SP,  #imm{, shift} ; 64-bit general registers
+       * imm : 0 ~ 4095, shift: none, LSL #0, or LSL #12
+       * aarch64 assembly takes up to 24-bits, if the lower 12 bits is all 0
+       */
+      if (immOpnd->IsInBitSize(kMaxImmVal12Bits, 0) || immOpnd->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits)) {
+        MOperator mOp = opndSize == k64BitSize ? MOP_xaddrri12 : MOP_waddrri12;
+        Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, *res, *op, *immOpnd);
+        bb->ReplaceInsn(insn, newInsn);
+        result = true;
+      }
+    }
+  }
+  /* Look for the sequence which can be simpified. */
+  if (result || (insn.GetMachineOpcode() == MOP_xaddrri12) || (insn.GetMachineOpcode() == MOP_waddrri12)) {
+    Insn *prev = opndInfo[idx0]->insn;
+    if ((prev != nullptr) && ((prev->GetMachineOpcode() == MOP_xaddrri12) ||
+                              (prev->GetMachineOpcode() == MOP_waddrri12))) {
+      OpndInfo *prevInfo0 = opndInfo[idx0]->insnInfo->origOpnd[kInsnSecondOpnd];
+      /* if prevop0 has been redefined. skip this optimiztation. */
+      if (prevInfo0->redefined) {
+        return result;
+      }
+     /* Implicit conversion */
+      if (insn.GetOperand(kInsnFirstOpnd).GetSize() != insn.GetOperand(kInsnSecondOpnd).GetSize()) {
+        return result;
+      }
+      Operand &prevOpnd0 = prev->GetOperand(kInsnSecondOpnd);
+      ImmOperand &imm0 = static_cast<ImmOperand&>(prev->GetOperand(kInsnThirdOpnd));
+      int64_t val = imm0.GetValue() + immOpnd->GetValue();
+      ImmOperand &imm1 = a64CGFunc->CreateImmOperand(val, opndSize, imm0.IsSignedValue());
+      if (imm1.IsInBitSize(kMaxImmVal24Bits, 0) && (imm1.IsInBitSize(kMaxImmVal12Bits, 0) ||
+                                                    imm1.IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits))) {
+        MOperator mOp = (opndSize == k64BitSize ? MOP_xaddrri12 : MOP_waddrri12);
+        bb->ReplaceInsn(insn, cgFunc->GetInsnBuilder()->BuildInsn(mOp, *res, prevOpnd0, imm1));
+        result = true;
+      }
+    }
+  }
+  return result;
+}
+
+ConditionCode AArch64Ebo::GetReverseCond(const CondOperand &cond) const {
+  switch (cond.GetCode()) {
+    case CC_NE:
+      return CC_EQ;
+    case CC_EQ:
+      return CC_NE;
+    case CC_LT:
+      return CC_GE;
+    case CC_GE:
+      return CC_LT;
+    case CC_GT:
+      return CC_LE;
+    case CC_LE:
+      return CC_GT;
+    default:
+      CHECK_FATAL(false, "Not support yet.");
+  }
+  return kCcLast;
+}
+
+/* return true if cond == CC_LE */
+bool AArch64Ebo::CheckCondCode(const CondOperand &cond) const {
+  switch (cond.GetCode()) {
+    case CC_NE:
+    case CC_EQ:
+    case CC_LT:
+    case CC_GE:
+    case CC_GT:
+    case CC_LE:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool AArch64Ebo::SimplifyBothConst(BB &bb, Insn &insn, const ImmOperand &immOperand0,
+                                   const ImmOperand &immOperand1, uint32 opndSize) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  int64 val = 0;
+  /* do not support negative const simplify yet */
+  if (immOperand0.GetValue() < 0 || immOperand1.GetValue() < 0) {
+    return false;
+  }
+  uint64 opndValue0 = static_cast<uint64>(immOperand0.GetValue());
+  uint64 opndValue1 = static_cast<uint64>(immOperand1.GetValue());
+  switch (mOp) {
+    case MOP_weorrri12:
+    case MOP_weorrrr:
+    case MOP_xeorrri13:
+    case MOP_xeorrrr:
+      val = static_cast<int64>(opndValue0 ^ opndValue1);
+      break;
+    case MOP_wandrri12:
+    case MOP_waddrri24:
+    case MOP_wandrrr:
+    case MOP_xandrri13:
+    case MOP_xandrrr:
+      val = static_cast<int64>(opndValue0 & opndValue1);
+      break;
+    case MOP_wiorrri12:
+    case MOP_wiorrrr:
+    case MOP_xiorrri13:
+    case MOP_xiorrrr:
+      val = static_cast<int64>(opndValue0 | opndValue1);
+      break;
+    default:
+      return false;
+  }
+  Operand *res = &insn.GetOperand(kInsnFirstOpnd);
+  ImmOperand *immOperand = &a64CGFunc->CreateImmOperand(val, opndSize, false);
+  if (!immOperand->IsSingleInstructionMovable()) {
+    ASSERT(res->IsRegister(), " expect a register operand");
+    static_cast<AArch64CGFunc*>(cgFunc)->SplitMovImmOpndInstruction(val, *(static_cast<RegOperand*>(res)), &insn);
+    bb.RemoveInsn(insn);
+  } else {
+    MOperator newmOp = opndSize == k64BitSize ? MOP_xmovri64 : MOP_wmovri32;
+    Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newmOp, *res, *immOperand);
+    bb.ReplaceInsn(insn, newInsn);
+  }
+  return true;
+}
+
+bool AArch64Ebo::OperandLiveAfterInsn(const RegOperand &regOpnd, Insn &insn) const {
+  for (Insn *nextInsn = insn.GetNext(); nextInsn != nullptr; nextInsn = nextInsn->GetNext()) {
+    if (!nextInsn->IsMachineInstruction()) {
+      continue;
+    }
+    int32 lastOpndId = static_cast<int32>(nextInsn->GetOperandSize() - 1);
+    for (int32 i = lastOpndId; i >= 0; --i) {
+      Operand &opnd = nextInsn->GetOperand(static_cast<uint32>(i));
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &mem = static_cast<MemOperand&>(opnd);
+        Operand *base = mem.GetBaseRegister();
+        Operand *offset = mem.GetOffset();
+
+        if (base != nullptr && base->IsRegister()) {
+          auto *tmpRegOpnd = static_cast<RegOperand*>(base);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return true;
+          }
+        }
+        if (offset != nullptr && offset->IsRegister()) {
+          auto *tmpRegOpnd = static_cast<RegOperand*>(offset);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return true;
+          }
+        }
+      }
+
+      if (!opnd.IsRegister()) {
+        continue;
+      }
+      auto &tmpRegOpnd = static_cast<RegOperand&>(opnd);
+      if (tmpRegOpnd.GetRegisterNumber() != regOpnd.GetRegisterNumber()) {
+        continue;
+      }
+      auto *regProp = nextInsn->GetDesc()->opndMD[static_cast<uint32>(i)];
+      bool isUse = regProp->IsUse();
+      /* if noUse Redefined, no need to check live-out. */
+      return isUse;
+    }
+  }
+  return LiveOutOfBB(regOpnd, *insn.GetBB());
+}
+
+bool AArch64Ebo::ValidPatternForCombineExtAndLoad(OpndInfo *prevOpndInfo, Insn *insn, MOperator newMop,
+                                                  MOperator oldMop, const RegOperand& opnd) const {
+  if (newMop == oldMop) {
+    return true;
+  }
+  if (prevOpndInfo == nullptr || prevOpndInfo->refCount > 1) {
+    return false;
+  }
+  if (OperandLiveAfterInsn(opnd, *insn)) {
+    return false;
+  }
+  Insn *prevInsn = prevOpndInfo->insn;
+  MemOperand *memOpnd = static_cast<MemOperand*>(prevInsn->GetMemOpnd());
+  ASSERT(!prevInsn->IsStorePair(), "do not do this opt for str pair");
+  ASSERT(!prevInsn->IsLoadPair(), "do not do this opt for ldr pair");
+  if (memOpnd->GetAddrMode() == MemOperand::kAddrModeBOi &&
+      !a64CGFunc->IsOperandImmValid(newMop, prevInsn->GetMemOpnd(), kInsnSecondOpnd)) {
+    return false;
+  }
+  uint32 shiftAmount = memOpnd->ShiftAmount();
+  if (shiftAmount == 0) {
+    return true;
+  }
+  const InsnDesc *md = &AArch64CG::kMd[newMop];
+  uint32 memSize = md->GetOperandSize() / k8BitSize;
+  uint32 validShiftAmount = memSize == 8 ? 3 : memSize == 4 ? 2 : memSize == 2 ? 1 : 0;
+  if (shiftAmount != validShiftAmount) {
+    return false;
+  }
+  return true;
+}
+
+bool AArch64Ebo::CombineExtensionAndLoad(Insn *insn, const MapleVector<OpndInfo*> &origInfos,
+                                         ExtOpTable idx, bool is64bits) const {
+  if (!beforeRegAlloc) {
+    return false;
+  }
+  OpndInfo *opndInfo = origInfos[kInsnSecondOpnd];
+  if (opndInfo == nullptr) {
+    return false;
+  }
+  Insn *prevInsn = opndInfo->insn;
+  if (prevInsn == nullptr) {
+    return false;
+  }
+
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  ASSERT(prevMop != MOP_undef, "Invalid opcode of instruction!");
+  PairMOperator *begin = &extInsnPairTable[idx][0];
+  PairMOperator *end = &extInsnPairTable[idx][kInsPairsNum];
+  auto pairIt = std::find_if(begin, end, [prevMop](const PairMOperator insPair) {
+    return prevMop == insPair[0];
+  });
+  if (pairIt == end) {
+    return false;
+  }
+
+  auto &res = static_cast<RegOperand &>(prevInsn->GetOperand(kInsnFirstOpnd));
+  OpndInfo *prevOpndInfo = GetOpndInfo(res, -1);
+  MOperator newPreMop = (*pairIt)[1];
+  ASSERT(newPreMop != MOP_undef, "Invalid opcode of instruction!");
+  if (!ValidPatternForCombineExtAndLoad(prevOpndInfo, insn, newPreMop, prevMop,
+                                        res)) {
+    return false;
+  }
+  auto *newMemOp =
+      GetOrCreateMemOperandForNewMOP(*cgFunc, *prevInsn, newPreMop);
+  if (newMemOp == nullptr) {
+    return false;
+  }
+  prevInsn->SetMemOpnd(newMemOp);
+  if (is64bits && idx <= SXTW && idx >= SXTB) {
+    newPreMop = ExtLoadSwitchBitSize(newPreMop);
+    auto &prevDstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+    prevDstOpnd.SetSize(k64BitSize);
+    prevDstOpnd.SetValidBitsNum(k64BitSize);
+  }
+  prevInsn->SetMOP(AArch64CG::kMd[newPreMop]);
+  MOperator movOp = is64bits ? MOP_xmovrr : MOP_wmovrr;
+  if (insn->GetMachineOpcode() == MOP_wandrri12 ||
+      insn->GetMachineOpcode() == MOP_xandrri13) {
+    Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+        movOp, insn->GetOperand(kInsnFirstOpnd),
+        insn->GetOperand(kInsnSecondOpnd));
+    insn->GetBB()->ReplaceInsn(*insn, newInsn);
+  } else {
+    insn->SetMOP(AArch64CG::kMd[movOp]);
+  }
+  return true;
+}
+
+bool AArch64Ebo::CombineMultiplyAdd(Insn *insn, const Insn *prevInsn, InsnInfo *insnInfo, Operand *addOpnd,
+                                    bool is64bits, bool isFp) const {
+  /* don't use register if it was redefined. */
+  OpndInfo *opndInfo1 = insnInfo->origOpnd[kInsnSecondOpnd];
+  OpndInfo *opndInfo2 = insnInfo->origOpnd[kInsnThirdOpnd];
+  if (((opndInfo1 != nullptr) && opndInfo1->redefined) || ((opndInfo2 != nullptr) && opndInfo2->redefined)) {
+    return false;
+  }
+  Operand &res = insn->GetOperand(kInsnFirstOpnd);
+  Operand &opnd1 = prevInsn->GetOperand(kInsnSecondOpnd);
+  Operand &opnd2 = prevInsn->GetOperand(kInsnThirdOpnd);
+  /* may overflow */
+  if ((prevInsn->GetOperand(kInsnFirstOpnd).GetSize() == k32BitSize) && is64bits) {
+    return false;
+  }
+  MOperator mOp = isFp ? (is64bits ? MOP_dmadd : MOP_smadd) : (is64bits ? MOP_xmaddrrrr : MOP_wmaddrrrr);
+  insn->GetBB()->ReplaceInsn(*insn, cgFunc->GetInsnBuilder()->BuildInsn(mOp, res, opnd1, opnd2, *addOpnd));
+  return true;
+}
+
+bool AArch64Ebo::CheckCanDoMadd(Insn *insn, OpndInfo *opndInfo, int32 pos, bool is64bits, bool isFp) const {
+  if ((opndInfo == nullptr) || (opndInfo->insn == nullptr)) {
+    return false;
+  }
+  if (!cgFunc->GetMirModule().IsCModule()) {
+    return false;
+  }
+  Insn *insn1 = opndInfo->insn;
+  InsnInfo *insnInfo = opndInfo->insnInfo;
+  if (insnInfo == nullptr) {
+    return false;
+  }
+  Operand &addOpnd = insn->GetOperand(static_cast<uint32>(pos));
+  MOperator opc1 = insn1->GetMachineOpcode();
+  if ((isFp && ((opc1 == MOP_xvmuld) || (opc1 == MOP_xvmuls))) ||
+      (!isFp && ((opc1 == MOP_xmulrrr) || (opc1 == MOP_wmulrrr)))) {
+    return CombineMultiplyAdd(insn, insn1, insnInfo, &addOpnd, is64bits, isFp);
+  }
+  return false;
+}
+
+bool AArch64Ebo::CombineMultiplySub(Insn *insn, OpndInfo *opndInfo, bool is64bits, bool isFp) const {
+  if ((opndInfo == nullptr) || (opndInfo->insn == nullptr)) {
+    return false;
+  }
+  if (!cgFunc->GetMirModule().IsCModule()) {
+    return false;
+  }
+  Insn *insn1 = opndInfo->insn;
+  InsnInfo *insnInfo = opndInfo->insnInfo;
+  if (insnInfo == nullptr) {
+    return false;
+  }
+  Operand &subOpnd = insn->GetOperand(kInsnSecondOpnd);
+  MOperator opc1 = insn1->GetMachineOpcode();
+  if ((isFp && ((opc1 == MOP_xvmuld) || (opc1 == MOP_xvmuls))) ||
+      (!isFp && ((opc1 == MOP_xmulrrr) || (opc1 == MOP_wmulrrr)))) {
+    /* don't use register if it was redefined. */
+    OpndInfo *opndInfo1 = insnInfo->origOpnd[kInsnSecondOpnd];
+    OpndInfo *opndInfo2 = insnInfo->origOpnd[kInsnThirdOpnd];
+    if (((opndInfo1 != nullptr) && opndInfo1->redefined) || ((opndInfo2 != nullptr) && opndInfo2->redefined)) {
+      return false;
+    }
+    Operand &res = insn->GetOperand(kInsnFirstOpnd);
+    Operand &opnd1 = insn1->GetOperand(kInsnSecondOpnd);
+    Operand &opnd2 = insn1->GetOperand(kInsnThirdOpnd);
+    /* may overflow */
+    if ((insn1->GetOperand(kInsnFirstOpnd).GetSize() == k32BitSize) && is64bits) {
+      return false;
+    }
+    MOperator mOp = isFp ? (is64bits ? MOP_dmsub : MOP_smsub) : (is64bits ? MOP_xmsubrrrr : MOP_wmsubrrrr);
+    insn->GetBB()->ReplaceInsn(*insn, cgFunc->GetInsnBuilder()->BuildInsn(mOp, res, opnd1, opnd2, subOpnd));
+    return true;
+  }
+  return false;
+}
+
+bool CheckInsnRefField(const Insn &insn, size_t opndIndex) {
+  if (insn.IsAccessRefField() && insn.AccessMem()) {
+    Operand &opnd0 = insn.GetOperand(opndIndex);
+    if (opnd0.IsRegister()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AArch64Ebo::CombineMultiplyNeg(Insn *insn, OpndInfo *opndInfo, bool is64bits, bool isFp) const {
+  if ((opndInfo == nullptr) || (opndInfo->insn == nullptr)) {
+    return false;
+  }
+  if (!cgFunc->GetMirModule().IsCModule()) {
+    return false;
+  }
+  Operand &res = insn->GetOperand(kInsnFirstOpnd);
+  Operand &src = insn->GetOperand(kInsnSecondOpnd);
+  if (res.GetSize() != src.GetSize()) {
+    return false;
+  }
+  Insn *insn1 = opndInfo->insn;
+  InsnInfo *insnInfo = opndInfo->insnInfo;
+  CHECK_NULL_FATAL(insnInfo);
+  MOperator opc1 = insn1->GetMachineOpcode();
+  if ((isFp && ((opc1 == MOP_xvmuld) || (opc1 == MOP_xvmuls))) ||
+      (!isFp && ((opc1 == MOP_xmulrrr) || (opc1 == MOP_wmulrrr)))) {
+    /* don't use register if it was redefined. */
+    OpndInfo *opndInfo1 = insnInfo->origOpnd[kInsnSecondOpnd];
+    OpndInfo *opndInfo2 = insnInfo->origOpnd[kInsnThirdOpnd];
+    if (((opndInfo1 != nullptr) && opndInfo1->redefined) || ((opndInfo2 != nullptr) && opndInfo2->redefined)) {
+      return false;
+    }
+    Operand &opnd1 = insn1->GetOperand(kInsnSecondOpnd);
+    Operand &opnd2 = insn1->GetOperand(kInsnThirdOpnd);
+    MOperator mOp = isFp ? (is64bits ? MOP_dnmul : MOP_snmul) : (is64bits ? MOP_xmnegrrr : MOP_wmnegrrr);
+    insn->GetBB()->ReplaceInsn(*insn, cgFunc->GetInsnBuilder()->BuildInsn(mOp, res, opnd1, opnd2));
+    return true;
+  }
+  return false;
+}
+
+bool AArch64Ebo::CombineLsrAnd(Insn &insn, const OpndInfo &opndInfo, bool is64bits, bool isFp) const {
+  if (opndInfo.insn == nullptr) {
+    return false;
+  }
+  if (!cgFunc->GetMirModule().IsCModule()) {
+    return false;
+  }
+  AArch64CGFunc *aarchFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  Insn *prevInsn = opndInfo.insn;
+  InsnInfo *insnInfo = opndInfo.insnInfo;
+  if (insnInfo == nullptr) {
+    return false;
+  }
+  CHECK_NULL_FATAL(insnInfo);
+  MOperator opc1 = prevInsn->GetMachineOpcode();
+  if (!isFp && ((opc1 == MOP_xlsrrri6) || (opc1 == MOP_wlsrrri5))) {
+    /* don't use register if it was redefined. */
+    OpndInfo *opndInfo1 = insnInfo->origOpnd[kInsnSecondOpnd];
+    if ((opndInfo1 != nullptr) && opndInfo1->redefined) {
+      return false;
+    }
+    Operand &res = insn.GetOperand(kInsnFirstOpnd);
+    Operand &opnd1 = prevInsn->GetOperand(kInsnSecondOpnd);
+    int64 immVal1 = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd)).GetValue();
+    Operand &immOpnd1 = is64bits ? aarchFunc->CreateImmOperand(immVal1, kMaxImmVal6Bits, false)
+                                 : aarchFunc->CreateImmOperand(immVal1, kMaxImmVal5Bits, false);
+    int64 immVal2 = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd)).GetValue();
+    int64 immV2 = __builtin_ffsll(immVal2 + 1) - 1;
+    if (immVal1 + immV2 < k1BitSize || (is64bits && immVal1 + immV2 > k64BitSize) ||
+        (!is64bits && immVal1 + immV2 > k32BitSize)) {
+        return false;
+    }
+    Operand &immOpnd2 = is64bits ? aarchFunc->CreateImmOperand(immV2, kMaxImmVal6Bits, false)
+                                 : aarchFunc->CreateImmOperand(immV2, kMaxImmVal5Bits, false);
+    MOperator mOp = (is64bits ? MOP_xubfxrri6i6 : MOP_wubfxrri5i5);
+    insn.GetBB()->ReplaceInsn(insn, cgFunc->GetInsnBuilder()->BuildInsn(mOp, res, opnd1, immOpnd1, immOpnd2));
+    return true;
+  }
+  return false;
+}
+
+/*
+ *  extension  dest, src0
+ *  and        dest, dest, 0xff or 0xffff
+ *  ===> if extension is >= imm then can eliminate extension
+ *
+ *  and dst1, src0, imm1
+ *  and dst2, dst1, imm2  where imm2 is 0xff or 0xffff
+ *  ===> and dst2, src0, imm1  if imm1 <= imm2
+ */
+bool AArch64Ebo::CombineExtAnd(Insn &insn, const OpndInfo &opndInfo, bool isFp, int64 immVal) const {
+  if (isFp || opndInfo.insn == nullptr || !cgFunc->GetMirModule().IsCModule()) {
+    return false;
+  }
+  Insn *prevInsn = opndInfo.insn;
+  InsnInfo *insnInfo = opndInfo.insnInfo;
+  if (insnInfo == nullptr) {
+    return false;
+  }
+  CHECK_NULL_FATAL(insnInfo);
+  MOperator opc1 = prevInsn->GetMachineOpcode();
+  if (((immVal == 0xff) &&
+         (opc1 >= MOP_xsxtb32) && (opc1 <= MOP_xuxtw64)) ||
+      ((immVal == 0xffff) &&
+         (opc1 == MOP_xsxth32 || opc1 == MOP_xsxth64 || opc1 == MOP_xsxtw64 ||
+          opc1 == MOP_xsxth32 || opc1 == MOP_xsxtw64))) {
+    /* don't use register if it was redefined. */
+    OpndInfo *opndInfo1 = insnInfo->origOpnd[kInsnSecondOpnd];
+    if ((opndInfo1 != nullptr) && opndInfo1->redefined) {
+      return false;
+    }
+    Operand &opnd1 = prevInsn->GetOperand(kInsnSecondOpnd);
+    insn.SetOperand(kInsnSecondOpnd, opnd1);
+    return true;
+  }
+  if ((immVal == 0xff || immVal == 0xffff) && (opc1 == MOP_wandrri12 || opc1 == MOP_xandrri13)) {
+    OpndInfo *opndInfo1 = insnInfo->origOpnd[kInsnSecondOpnd];
+    if ((opndInfo1 != nullptr) && opndInfo1->redefined) {
+      return false;
+    }
+    int64 prevImmVal = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd)).GetValue();
+    if (static_cast<uint64>(prevImmVal) > static_cast<uint64>(immVal)) {
+      return false;
+    }
+    Operand &opnd1 = prevInsn->GetOperand(kInsnSecondOpnd);
+    insn.SetOperand(kInsnSecondOpnd, opnd1);
+    Operand &opnd2 = prevInsn->GetOperand(kInsnThirdOpnd);
+    insn.SetOperand(kInsnThirdOpnd, opnd2);
+  }
+  return false;
+}
+
+/* Do some special pattern */
+bool AArch64Ebo::SpecialSequence(Insn &insn, const MapleVector<OpndInfo*> &origInfos) {
+  MOperator opCode = insn.GetMachineOpcode();
+  AArch64CGFunc *aarchFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  switch (opCode) {
+    /*
+     * mov R503, R0
+     * mov R0, R503
+     *  ==> mov R0, R0
+     */
+    case MOP_wmovrr:
+    case MOP_xmovrr: {
+      OpndInfo *opndInfo = origInfos[kInsnSecondOpnd];
+      if (opndInfo == nullptr) {
+        return false;
+      }
+      Insn *prevInsn = opndInfo->insn;
+      if ((prevInsn != nullptr) && (prevInsn->GetMachineOpcode() == opCode) &&
+          (prevInsn == insn.GetPreviousMachineInsn()) &&
+          !RegistersIdentical(prevInsn->GetOperand(kInsnFirstOpnd), prevInsn->GetOperand(kInsnSecondOpnd)) &&
+          !RegistersIdentical(insn.GetOperand(kInsnFirstOpnd), insn.GetOperand(kInsnSecondOpnd))) {
+        Operand &reg1 = insn.GetOperand(kInsnFirstOpnd);
+        Operand &reg2 = prevInsn->GetOperand(kInsnSecondOpnd);
+        Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(insn.GetMachineOpcode(), reg1, reg2);
+        insn.GetBB()->ReplaceInsn(insn, newInsn);
+        return true;
+      }
+      break;
+    }
+    /*
+     * Extension elimination.  Look for load extension pair.  There are two cases.
+     * 1) extension size == load size -> change the load type or eliminate the extension
+     * 2) extension size >  load size -> possibly eliminating the extension
+     *
+     * Example of 1)
+     *  ldrb x1, []      or  ldrb x1, []      or   ldrsb x1, []      or   ldrsb x1, []
+     *  sxtb x1, x1          zxtb x1, x1           sxtb  x1, x1           zxtb  x1, x1
+     * ===> ldrsb x1, []     ===> ldrb x1, []      ===> ldrsb x1, []      ===> ldrb x1, []
+     *      mov   x1, x1          mov  x1, x1           mov   x1, x1           mov  x1, x1
+     *
+     * Example of 2)
+     *  ldrb x1, []      or  ldrb x1, []   or   ldrsb x1, []     or   ldrsb x1, []
+     *  sxth x1, x1          zxth x1, x1        sxth  x1, x1          zxth  x1, x1
+     * ===> ldrb x1, []     ===> ldrb x1, []   ===> ldrsb x1, []     ===> no change
+     *      mov x1, x1           mov  x1, x1        mov   x1, x1
+     */
+    case MOP_wandrri12:
+    case MOP_xandrri13: {
+      bool is64Bits = (opCode == MOP_xandrri13);
+      bool doAndOpt = false;
+      if (static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd)).GetValue() == 0xff) {
+        doAndOpt = CombineExtensionAndLoad(&insn, origInfos, AND, is64Bits);
+      }
+      if (doAndOpt) {
+        return doAndOpt;
+      }
+      /*
+      *  lsr     d0, d1, #6
+      *  and     d0, d0, #1
+      * ===> ubfx d0, d1, #6, #1
+      */
+      int64 immValue = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd)).GetValue();
+      if (!beforeRegAlloc && immValue != 0 &&
+          (static_cast<uint64>(immValue) & (static_cast<uint64>(immValue) + 1)) == 0) {
+        /* immValue is (1 << n - 1) */
+        OpndInfo *opndInfo = origInfos.at(kInsnSecondOpnd);
+        return CombineLsrAnd(insn, *opndInfo, is64Bits, false);
+      }
+      if (beforeRegAlloc && immValue != 0 &&
+          (static_cast<uint64>(immValue) & (static_cast<uint64>(immValue) + 1)) == 0) {
+        OpndInfo *opndInfo = origInfos.at(kInsnSecondOpnd);
+        return CombineExtAnd(insn, *opndInfo, false, immValue);
+      }
+      break;
+    }
+    case MOP_xsxtb32:
+      return CombineExtensionAndLoad(&insn, origInfos, SXTB, false);
+    case MOP_xsxtb64:
+      return CombineExtensionAndLoad(&insn, origInfos, SXTB, true);
+    case MOP_xsxth32:
+      return CombineExtensionAndLoad(&insn, origInfos, SXTH, false);
+    case MOP_xsxth64:
+      return CombineExtensionAndLoad(&insn, origInfos, SXTH, true);
+    case MOP_xsxtw64:
+      return CombineExtensionAndLoad(&insn, origInfos, SXTW, true);
+    case MOP_xuxtb32:
+      return CombineExtensionAndLoad(&insn, origInfos, ZXTB, false);
+    case MOP_xuxth32:
+      return CombineExtensionAndLoad(&insn, origInfos, ZXTH, false);
+    case MOP_xuxtw64:
+      return CombineExtensionAndLoad(&insn, origInfos, ZXTW, true);
+    /*
+     *  lsl     x1, x1, #3
+     *  add     x0, x0, x1
+     * ===> add x0, x0, x1, 3
+     *
+     *  mul     x1, x1, x2
+     *  add     x0, x0, x1     or   add   x0, x1, x0
+     * ===> madd x0, x1, x2, x0
+     */
+    case MOP_xaddrrr:
+    case MOP_waddrrr: {
+      bool is64bits = (insn.GetOperand(kInsnFirstOpnd).GetSize() == k64BitSize);
+      OpndInfo *opndInfo = origInfos.at(kInsnThirdOpnd);
+      if ((opndInfo != nullptr) && (opndInfo->insn != nullptr)) {
+        Insn *insn1 = opndInfo->insn;
+        InsnInfo *insnInfo1 = opndInfo->insnInfo;
+        if (insnInfo1 == nullptr) {
+          return false;
+        }
+        Operand &op0 = insn.GetOperand(kInsnSecondOpnd);
+        MOperator opc1 = insn1->GetMachineOpcode();
+        if ((opc1 == MOP_xlslrri6) || (opc1 == MOP_wlslrri5)) {
+          /* don't use register if it was redefined. */
+          if (cgFunc->GetMirModule().IsCModule()) {
+            /* global opt will do this pattern when is CMoudle */
+            return false;
+          }
+          OpndInfo *opndInfo1 = insnInfo1->origOpnd[kInsnSecondOpnd];
+          if ((opndInfo1 != nullptr) && opndInfo1->redefined) {
+            return false;
+          }
+          Operand &res = insn.GetOperand(kInsnFirstOpnd);
+          Operand &opnd1 = insn1->GetOperand(kInsnSecondOpnd);
+          auto &immOpnd = static_cast<ImmOperand&>(insn1->GetOperand(kInsnThirdOpnd));
+          uint32 xLslrriBitLen = 6;
+          uint32 wLslrriBitLen = 5;
+          Operand &shiftOpnd = aarchFunc->CreateBitShiftOperand(BitShiftOperand::kLSL,
+              static_cast<uint32>(immOpnd.GetValue()), static_cast<int32>((
+              opCode == MOP_xlslrri6) ? xLslrriBitLen : wLslrriBitLen));
+          MOperator mOp = (is64bits ? MOP_xaddrrrs : MOP_waddrrrs);
+          insn.GetBB()->ReplaceInsn(insn, cgFunc->GetInsnBuilder()->BuildInsn(mOp, res, op0, opnd1, shiftOpnd));
+          return true;
+        } else if ((opc1 == MOP_xmulrrr) || (opc1 == MOP_wmulrrr)) {
+          return CombineMultiplyAdd(&insn, insn1, insnInfo1, &op0, is64bits, false);
+        }
+      }
+      opndInfo = origInfos.at(kInsnSecondOpnd);
+      return CheckCanDoMadd(&insn, opndInfo, kInsnThirdOpnd, is64bits, false);
+    }
+    /*
+     *  fmul     d1, d1, d2
+     *  fadd     d0, d0, d1     or   add   d0, d1, d0
+     * ===> fmadd d0, d1, d2, d0
+     */
+    case MOP_dadd:
+    case MOP_sadd: {
+      if (!CGOptions::IsFastMath()) {
+        return false;
+      }
+      bool is64bits = (insn.GetOperand(kInsnFirstOpnd).GetSize() == k64BitSize);
+      OpndInfo *opndInfo = origInfos.at(kInsnSecondOpnd);
+      if (CheckCanDoMadd(&insn, opndInfo, kInsnThirdOpnd, is64bits, true)) {
+        return true;
+      }
+      opndInfo = origInfos.at(kInsnThirdOpnd);
+      if (CheckCanDoMadd(&insn, opndInfo, kInsnSecondOpnd, is64bits, true)) {
+        return true;
+      }
+      break;
+    }
+    /*
+     *  mul     x1, x1, x2
+     *  sub     x0, x0, x1
+     * ===> msub x0, x1, x2, x0
+     */
+    case MOP_xsubrrr:
+    case MOP_wsubrrr: {
+      bool is64bits = (insn.GetOperand(kInsnFirstOpnd).GetSize() == k64BitSize);
+      OpndInfo *opndInfo = origInfos.at(kInsnThirdOpnd);
+      if (CombineMultiplySub(&insn, opndInfo, is64bits, false)) {
+        return true;
+      }
+      break;
+    }
+    /*
+     *  fmul     d1, d1, d2
+     *  fsub     d0, d0, d1
+     * ===> fmsub d0, d1, d2, d0
+     */
+    case MOP_dsub:
+    case MOP_ssub: {
+      if (!CGOptions::IsFastMath()) {
+        return false;
+      }
+      bool is64bits = (insn.GetOperand(kInsnFirstOpnd).GetSize() == k64BitSize);
+      OpndInfo *opndInfo = origInfos.at(kInsnThirdOpnd);
+      if (CombineMultiplySub(&insn, opndInfo, is64bits, true)) {
+        return true;
+      }
+      break;
+    }
+    /*
+     *  mul     x1, x1, x2
+     *  neg     x0, x1
+     * ===> mneg x0, x1, x2
+     */
+    case MOP_xinegrr:
+    case MOP_winegrr: {
+      bool is64bits = (insn.GetOperand(kInsnFirstOpnd).GetSize() == k64BitSize);
+      OpndInfo *opndInfo = origInfos.at(kInsnSecondOpnd);
+      if (CombineMultiplyNeg(&insn, opndInfo, is64bits, false)) {
+        return true;
+      }
+      break;
+    }
+    /*
+     *  fmul     d1, d1, d2
+     *  fneg     d0, d1
+     * ===> fnmul d0, d1, d2
+     */
+    case MOP_wfnegrr:
+    case MOP_xfnegrr: {
+      if (!CGOptions::IsFastMath()) {
+        return false;
+      }
+      bool is64bits = (insn.GetOperand(kInsnFirstOpnd).GetSize() == k64BitSize);
+      OpndInfo *opndInfo = origInfos.at(kInsnSecondOpnd);
+      if (CombineMultiplyNeg(&insn, opndInfo, is64bits, true)) {
+        return true;
+      }
+      break;
+    }
+    case MOP_xcsetrc:
+    case MOP_wcsetrc: {
+      /* i.   cmp     x0, x1
+       *      cset    w0, EQ     ===> cmp x0, x1
+       *      cmp     w0, #0          cset w0, EQ
+       *      cset    w0, NE
+       *
+       * ii.  cmp     x0, x1
+       *      cset    w0, EQ     ===> cmp x0, x1
+       *      cmp     w0, #0          cset w0, NE
+       *      cset    w0, EQ
+       *
+       *  a.< -1 : 0x20ff25e0 > < 0 > cmp(226) (opnd0: vreg:C105 class: [CC]) (opnd1: vreg:R104 class: [I]) (opnd2:
+       *  vreg:R106 class: [I])
+       *  b.< -1 : 0x20ff60a0 > < 0 > cset(72) (opnd0: vreg:R101 class: [I]) (opnd1: CC: EQ)
+       *  c.< -1*  : 0x20ff3870 > < 0 > cmp(223) (opnd0: vreg:C105 class: [CC]) (opnd1: vreg:R101 class: [I]) (opnd2:
+       *  imm:0)
+       *  d.< *  -1 : 0x20ff3908 > < 0 > cset(72) (opnd0: vreg:R107 class: [I]) (opnd1: CC: NE)
+       *  d1.< -1 : 0x20ff3908 > < 0 > *  cset(72) (opnd0: vreg:R107 class: [I]) (opnd1: CC: EQ) i, d
+       *  ===> mov R107 R101 ii, a,b,c,d1 ===> a,b,cset Rxx
+       *  NE, c, mov R107 Rxx
+       */
+      auto &cond = static_cast<CondOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      if ((cond.GetCode() != CC_NE) && (cond.GetCode() != CC_EQ)) {
+        return false;
+      }
+      bool reverse = (cond.GetCode() == CC_EQ);
+      OpndInfo *condInfo = origInfos[kInsnSecondOpnd];
+      if ((condInfo != nullptr) && condInfo->insn) {
+        Insn *cmp1 = condInfo->insn;
+        if ((cmp1->GetMachineOpcode() == MOP_xcmpri) || (cmp1->GetMachineOpcode() == MOP_wcmpri)) {
+          InsnInfo *cmpInfo1 = condInfo->insnInfo;
+          CHECK_FATAL(cmpInfo1 != nullptr, "pointor cmpInfo1 is null");
+          OpndInfo *info0 = cmpInfo1->origOpnd[kInsnSecondOpnd];
+          /* if R101 was not redefined. */
+          if ((info0 != nullptr) && (info0->insnInfo != nullptr) && (info0->insn != nullptr) &&
+              (reverse || !info0->redefined) && cmp1->GetOperand(kInsnThirdOpnd).IsImmediate()) {
+            Insn *csetInsn = info0->insn;
+            MOperator opc1 = csetInsn->GetMachineOpcode();
+            if (((opc1 == MOP_xcsetrc) || (opc1 == MOP_wcsetrc)) &&
+                static_cast<ImmOperand&>(cmp1->GetOperand(kInsnThirdOpnd)).IsZero()) {
+              CondOperand &cond1 = static_cast<CondOperand&>(csetInsn->GetOperand(kInsnSecondOpnd));
+              if (!CheckCondCode(cond1)) {
+                return false;
+              }
+              if (EBO_DUMP) {
+                LogInfo::MapleLogger() << "< === do specical condition optimization, replace insn  ===> \n";
+                insn.Dump();
+              }
+              Operand *result = &insn.GetOperand(kInsnFirstOpnd);
+              CHECK_FATAL(result != nullptr, "pointor result is null");
+              uint32 size = result->GetSize();
+              if (reverse) {
+                /* After regalloction, we can't create a new register. */
+                if (!beforeRegAlloc) {
+                  return false;
+                }
+                AArch64CGFunc *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+                Operand &r = aarFunc->CreateRegisterOperandOfType(static_cast<RegOperand*>(result)->GetRegisterType(),
+                                                                  size / kBitsPerByte);
+                /* after generate a new vreg, check if the size of DataInfo is big enough */
+                EnlargeSpaceForLA(*csetInsn);
+                CondOperand &cond2 = aarFunc->GetCondOperand(GetReverseCond(cond1));
+                Operand &rflag = aarFunc->GetOrCreateRflag();
+                Insn &newCset = cgFunc->GetInsnBuilder()->BuildInsn(
+                    result->GetSize() == k64BitSize ? MOP_xcsetrc : MOP_wcsetrc, r, cond2, rflag);
+                /* new_cset use the same cond as cset_insn. */
+                IncRef(*info0->insnInfo->origOpnd[kInsnSecondOpnd]);
+                csetInsn->GetBB()->InsertInsnAfter(*csetInsn, newCset);
+                MOperator mOp = (result->GetSize() == k64BitSize ? MOP_xmovrr : MOP_wmovrr);
+                Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, *result, r);
+                insn.GetBB()->ReplaceInsn(insn, newInsn);
+                if (EBO_DUMP) {
+                  LogInfo::MapleLogger() << "< === with new insn ===> \n";
+                  newInsn.Dump();
+                }
+              } else {
+                Operand *result1 = &csetInsn->GetOperand(kInsnFirstOpnd);
+                MOperator mOp = ((result->GetSize() == k64BitSize) ? MOP_xmovrr : MOP_wmovrr);
+                Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, *result, *result1);
+                insn.GetBB()->ReplaceInsn(insn, newInsn);
+                if (EBO_DUMP) {
+                  LogInfo::MapleLogger() << "< === with new insn ===> \n";
+                  newInsn.Dump();
+                }
+              }
+              return true;
+            }
+          }
+        }
+      }
+    }  /* end case MOP_wcsetrc */
+    [[clang::fallthrough]];
+    default:
+      break;
+  }
+  return false;
+}
+
+/*
+ *  *iii. mov w16, v10.s[1]   //  FMOV from simd 105   ---> replace_insn
+ *      mov w1, w16     ----->insn
+ *      ==>
+ *      mov w1, v10.s[1]
+ */
+bool AArch64Ebo::IsMovToSIMDVmov(Insn &insn, const Insn &replaceInsn) const {
+  if (insn.GetMachineOpcode() == MOP_wmovrr && replaceInsn.GetMachineOpcode() == MOP_xvmovrv) {
+    insn.SetMOP(AArch64CG::kMd[replaceInsn.GetMachineOpcode()]);
+    return true;
+  }
+  return false;
+}
+
+bool AArch64Ebo::IsPseudoRet(Insn &insn) const {
+  MOperator mop = insn.GetMachineOpcode();
+  if (mop == MOP_pseudo_ret_int || mop == MOP_pseudo_ret_float) {
+    return true;
+  }
+  return false;
+}
+
+bool AArch64Ebo::ChangeLdrMop(Insn &insn, const Operand &opnd) const {
+  ASSERT(insn.IsLoad(), "expect insn is load in ChangeLdrMop");
+  ASSERT(opnd.IsRegister(), "expect opnd is a register in ChangeLdrMop");
+
+  const RegOperand *regOpnd = static_cast<const RegOperand*>(&opnd);
+  if (static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd)).GetRegisterType() != regOpnd->GetRegisterType()) {
+    return false;
+  }
+
+  if (static_cast<MemOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetIndexRegister()) {
+    return false;
+  }
+
+  bool bRet = true;
+  if (regOpnd->GetRegisterType() == kRegTyFloat) {
+    switch (insn.GetMachineOpcode()) {
+      case MOP_wldrb:
+        insn.SetMOP(AArch64CG::kMd[MOP_bldr]);
+        break;
+      case MOP_wldrh:
+        insn.SetMOP(AArch64CG::kMd[MOP_hldr]);
+        break;
+      case MOP_wldr:
+        insn.SetMOP(AArch64CG::kMd[MOP_sldr]);
+        break;
+      case MOP_xldr:
+        insn.SetMOP(AArch64CG::kMd[MOP_dldr]);
+        break;
+      case MOP_wldli:
+        insn.SetMOP(AArch64CG::kMd[MOP_sldli]);
+        break;
+      case MOP_xldli:
+        insn.SetMOP(AArch64CG::kMd[MOP_dldli]);
+        break;
+      case MOP_wldrsb:
+      case MOP_wldrsh:
+      default:
+        bRet = false;
+        break;
+    }
+  } else if (regOpnd->GetRegisterType() == kRegTyInt) {
+    switch (insn.GetMachineOpcode()) {
+      case MOP_bldr:
+        insn.SetMOP(AArch64CG::kMd[MOP_wldrb]);
+        break;
+      case MOP_hldr:
+        insn.SetMOP(AArch64CG::kMd[MOP_wldrh]);
+        break;
+      case MOP_sldr:
+        insn.SetMOP(AArch64CG::kMd[MOP_wldr]);
+        break;
+      case MOP_dldr:
+        insn.SetMOP(AArch64CG::kMd[MOP_xldr]);
+        break;
+      case MOP_sldli:
+        insn.SetMOP(AArch64CG::kMd[MOP_wldli]);
+        break;
+      case MOP_dldli:
+        insn.SetMOP(AArch64CG::kMd[MOP_xldli]);
+        break;
+      default:
+        bRet = false;
+        break;
+    }
+  } else {
+    ASSERT(false, "Internal error.");
+  }
+  return bRet;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_emitter.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_emitter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0008e9443a8f7cc9aed0e397bd0e8675f6e918b6
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_emitter.cpp
@@ -0,0 +1,2163 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_emitter.h"
+#include <sys/stat.h>
+#include "aarch64_cgfunc.h"
+#include "aarch64_cg.h"
+#include "metadata_layout.h"
+#include "cfi.h"
+#include "dbg.h"
+
+namespace {
+using namespace maple;
+const std::unordered_set<std::string> kJniNativeFuncList = {
+    "Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V_native",
+    "Landroid_2Fos_2FParcel_3B_7CnativeReadString_7C_28J_29Ljava_2Flang_2FString_3B_native",
+    "Landroid_2Fos_2FParcel_3B_7CnativeWriteInt_7C_28JI_29V_native",
+    "Landroid_2Fos_2FParcel_3B_7CnativeReadInt_7C_28J_29I_native",
+    "Landroid_2Fos_2FParcel_3B_7CnativeWriteInterfaceToken_7C_28JLjava_2Flang_2FString_3B_29V_native",
+    "Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native"
+};
+constexpr uint32 kBinSearchInsnCount = 56;
+// map func name to <filename, insnCount> pair
+using Func2CodeInsnMap = std::unordered_map<std::string, std::pair<std::string, uint32>>;
+Func2CodeInsnMap func2CodeInsnMap {
+    { "Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I",
+      { "maple/mrt/codetricks/arch/arm64/hashCode.s", 29 } },
+    { "Ljava_2Flang_2FString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z",
+      { "maple/mrt/codetricks/arch/arm64/stringEquals.s", 50 } }
+};
+constexpr uint32 kQuadInsnCount = 2;
+
+void GetMethodLabel(const std::string &methodName, std::string &methodLabel) {
+  methodLabel = ".Lmethod_desc." + methodName;
+}
+}
+
+namespace maplebe {
+using namespace maple;
+
+void AArch64AsmEmitter::EmitRefToMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  if (!cgFunc.GetFunction().IsJava()) {
+    return;
+  }
+  std::string methodDescLabel;
+  GetMethodLabel(cgFunc.GetFunction().GetName(), methodDescLabel);
+  (void)emitter.Emit("\t.word " + methodDescLabel + "-.\n");
+  emitter.IncreaseJavaInsnCount();
+}
+
+void AArch64AsmEmitter::EmitRefToMethodInfo(FuncEmitInfo &funcEmitInfo, Emitter &emitter) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  if (cgFunc.GetFunction().GetModule()->IsJavaModule()) {
+    std::string labelName = ".Label.name." + cgFunc.GetFunction().GetName();
+    (void)emitter.Emit("\t.word " + labelName + " - .\n");
+  }
+}
+
+/*
+ * emit java method description which contains address and size of local reference area
+ * as well as method metadata.
+ */
+void AArch64AsmEmitter::EmitMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  if (!cgFunc.GetFunction().IsJava()) {
+    return;
+  }
+  (void)emitter.Emit("\t.section\t.rodata\n");
+  (void)emitter.Emit("\t.align\t2\n");
+  std::string methodInfoLabel;
+  GetMethodLabel(cgFunc.GetFunction().GetName(), methodInfoLabel);
+  (void)emitter.Emit(methodInfoLabel + ":\n");
+  EmitRefToMethodInfo(funcEmitInfo, emitter);
+  /* local reference area */
+  AArch64MemLayout *memLayout = static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout());
+  int32 refOffset = memLayout->GetRefLocBaseLoc();
+  uint32 refNum = memLayout->GetSizeOfRefLocals() / kOffsetAlign;
+  /* for ea usage */
+  AArch64CGFunc &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  IntrinsiccallNode *cleanEANode = aarchCGFunc.GetCleanEANode();
+  if (cleanEANode != nullptr) {
+    refNum += static_cast<uint32>(cleanEANode->NumOpnds());
+    refOffset -= static_cast<int32>(cleanEANode->NumOpnds() * kIntregBytelen);
+  }
+  (void)emitter.Emit("\t.short ").Emit(refOffset).Emit("\n");
+  (void)emitter.Emit("\t.short ").Emit(refNum).Emit("\n");
+}
+
+/* the fast_exception_handling lsda */
+void AArch64AsmEmitter::EmitFastLSDA(FuncEmitInfo &funcEmitInfo) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  AArch64CGFunc &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+
+  Emitter *emitter = currCG->GetEmitter();
+  PUIdx pIdx = currCG->GetMIRModule()->CurFunction()->GetPuidx();
+  const std::string &idx = strdup(std::to_string(pIdx).c_str());
+  /*
+   * .word 0xFFFFFFFF
+   * .word .Label.LTest_3B_7C_3Cinit_3E_7C_28_29V3-func_start_label
+   */
+  (void)emitter->Emit("\t.word 0xFFFFFFFF\n");
+  (void)emitter->Emit("\t.word .L." + idx + "__");
+  if (aarchCGFunc.NeedCleanup()) {
+    emitter->Emit(cgFunc.GetCleanupLabel()->GetLabelIdx());
+  } else {
+    ASSERT(!cgFunc.GetExitBBsVec().empty(), "exitbbsvec is empty in AArch64AsmEmitter::EmitFastLSDA");
+    emitter->Emit(cgFunc.GetExitBB(0)->GetLabIdx());
+  }
+  emitter->Emit("-.L." + idx + "__")
+      .Emit(cgFunc.GetStartLabel()->GetLabelIdx())
+      .Emit("\n");
+  emitter->IncreaseJavaInsnCount();
+}
+
+/* the normal gcc_except_table */
+void AArch64AsmEmitter::EmitFullLSDA(FuncEmitInfo &funcEmitInfo) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  AArch64CGFunc &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  EHFunc *ehFunc = cgFunc.GetEHFunc();
+  Emitter *emitter = currCG->GetEmitter();
+  /* emit header */
+  emitter->Emit("\t.align 3\n");
+  emitter->Emit("\t.section .gcc_except_table,\"a\",@progbits\n");
+  emitter->Emit("\t.align 3\n");
+  /* emit LSDA header */
+  LSDAHeader *lsdaHeader = ehFunc->GetLSDAHeader();
+  emitter->EmitStmtLabel(lsdaHeader->GetLSDALabel()->GetLabelIdx());
+  emitter->Emit("\t.byte ").Emit(lsdaHeader->GetLPStartEncoding()).Emit("\n");
+  emitter->Emit("\t.byte ").Emit(lsdaHeader->GetTTypeEncoding()).Emit("\n");
+  emitter->Emit("\t.uleb128 ");
+  emitter->EmitLabelPair(lsdaHeader->GetTTypeOffset());
+  emitter->EmitStmtLabel(lsdaHeader->GetTTypeOffset().GetStartOffset()->GetLabelIdx());
+  /* emit call site table */
+  emitter->Emit("\t.byte ").Emit(lsdaHeader->GetCallSiteEncoding()).Emit("\n");
+  /* callsite table size */
+  emitter->Emit("\t.uleb128 ");
+  emitter->EmitLabelPair(ehFunc->GetLSDACallSiteTable()->GetCSTable());
+  /* callsite start */
+  emitter->EmitStmtLabel(ehFunc->GetLSDACallSiteTable()->GetCSTable().GetStartOffset()->GetLabelIdx());
+  ehFunc->GetLSDACallSiteTable()->SortCallSiteTable([&aarchCGFunc](const LSDACallSite *a, const LSDACallSite *b) {
+    CHECK_FATAL(a != nullptr, "nullptr check");
+    CHECK_FATAL(b != nullptr, "nullptr check");
+    LabelIDOrder id1 = aarchCGFunc.GetLabelOperand(a->csStart.GetEndOffset()->GetLabelIdx())->GetLabelOrder();
+    LabelIDOrder id2 = aarchCGFunc.GetLabelOperand(b->csStart.GetEndOffset()->GetLabelIdx())->GetLabelOrder();
+    /* id1 and id2 should not be default value -1u */
+    CHECK_FATAL(id1 != 0xFFFFFFFF, "illegal label order assigned");
+    CHECK_FATAL(id2 != 0xFFFFFFFF, "illegal label order assigned");
+    return id1 < id2;
+  });
+  const MapleVector<LSDACallSite*> &callSiteTable = ehFunc->GetLSDACallSiteTable()->GetCallSiteTable();
+  for (size_t i = 0; i < callSiteTable.size(); ++i) {
+    LSDACallSite *lsdaCallSite = callSiteTable[i];
+    emitter->Emit("\t.uleb128 ");
+    emitter->EmitLabelPair(lsdaCallSite->csStart);
+
+    emitter->Emit("\t.uleb128 ");
+    emitter->EmitLabelPair(lsdaCallSite->csLength);
+
+    if (lsdaCallSite->csLandingPad.GetStartOffset()) {
+      emitter->Emit("\t.uleb128 ");
+      emitter->EmitLabelPair(lsdaCallSite->csLandingPad);
+    } else {
+      ASSERT(lsdaCallSite->csAction == 0, "csAction error!");
+      emitter->Emit("\t.uleb128 ");
+      if (aarchCGFunc.NeedCleanup()) {
+        /* if landing pad is 0, we emit this call site as cleanup code */
+        LabelPair cleaupCode;
+        cleaupCode.SetStartOffset(cgFunc.GetStartLabel());
+        cleaupCode.SetEndOffset(cgFunc.GetCleanupLabel());
+        emitter->EmitLabelPair(cleaupCode);
+      } else if (cgFunc.GetFunction().IsJava()) {
+        ASSERT(!cgFunc.GetExitBBsVec().empty(), "exitbbsvec is empty in AArch64Emitter::EmitFullLSDA");
+        PUIdx pIdx = cgFunc.GetMirModule().CurFunction()->GetPuidx();
+        const std::string &idx = strdup(std::to_string(pIdx).c_str());
+        (void)emitter->Emit(".L." + idx).Emit("__").Emit(cgFunc.GetExitBB(0)->GetLabIdx());
+        (void)emitter->Emit(" - .L." + idx).Emit("__").Emit(cgFunc.GetStartLabel()->GetLabelIdx()).Emit("\n");
+      } else {
+        emitter->Emit("0\n");
+      }
+    }
+    emitter->Emit("\t.uleb128 ").Emit(lsdaCallSite->csAction).Emit("\n");
+  }
+
+  /*
+   * quick hack: insert a call site entry for the whole function body.
+   * this will hand in any pending (uncaught) exception to its caller. Note that
+   * __gxx_personality_v0 in libstdc++ is coded so that if exception table exists,
+   * the call site table must have an entry for any possibly raised exception,
+   * otherwise __cxa_call_terminate will be invoked immediately, thus the caller
+   * does not get the chance to take charge.
+   */
+  if (aarchCGFunc.NeedCleanup() || cgFunc.GetFunction().IsJava()) {
+    /* call site for clean-up */
+    LabelPair funcStart;
+    funcStart.SetStartOffset(cgFunc.GetStartLabel());
+    funcStart.SetEndOffset(cgFunc.GetStartLabel());
+    emitter->Emit("\t.uleb128 ");
+    emitter->EmitLabelPair(funcStart);
+    LabelPair funcLength;
+    funcLength.SetStartOffset(cgFunc.GetStartLabel());
+    funcLength.SetEndOffset(cgFunc.GetCleanupLabel());
+    emitter->Emit("\t.uleb128 ");
+    emitter->EmitLabelPair(funcLength);
+    LabelPair cleaupCode;
+    cleaupCode.SetStartOffset(cgFunc.GetStartLabel());
+    cleaupCode.SetEndOffset(cgFunc.GetCleanupLabel());
+    emitter->Emit("\t.uleb128 ");
+    if (aarchCGFunc.NeedCleanup()) {
+      emitter->EmitLabelPair(cleaupCode);
+    } else {
+      ASSERT(!cgFunc.GetExitBBsVec().empty(), "exitbbsvec is empty in AArch64AsmEmitter::EmitFullLSDA");
+      PUIdx pIdx = cgFunc.GetMirModule().CurFunction()->GetPuidx();
+      const std::string &idx = strdup(std::to_string(pIdx).c_str());
+      (void)emitter->Emit(".L." + idx).Emit("__").Emit(cgFunc.GetExitBB(0)->GetLabIdx());
+      (void)emitter->Emit(" - .L." + idx).Emit("__").Emit(cgFunc.GetStartLabel()->GetLabelIdx()).Emit("\n");
+    }
+    emitter->Emit("\t.uleb128 0\n");
+    if (!cgFunc.GetFunction().IsJava()) {
+      /* call site for stack unwind */
+      LabelPair unwindStart;
+      unwindStart.SetStartOffset(cgFunc.GetStartLabel());
+      unwindStart.SetEndOffset(cgFunc.GetCleanupLabel());
+      emitter->Emit("\t.uleb128 ");
+      emitter->EmitLabelPair(unwindStart);
+      LabelPair unwindLength;
+      unwindLength.SetStartOffset(cgFunc.GetCleanupLabel());
+      unwindLength.SetEndOffset(cgFunc.GetEndLabel());
+      emitter->Emit("\t.uleb128 ");
+      emitter->EmitLabelPair(unwindLength);
+      emitter->Emit("\t.uleb128 0\n");
+      emitter->Emit("\t.uleb128 0\n");
+    }
+  }
+  /* callsite end label */
+  emitter->EmitStmtLabel(ehFunc->GetLSDACallSiteTable()->GetCSTable().GetEndOffset()->GetLabelIdx());
+  /* tt */
+  const LSDAActionTable *lsdaActionTable = ehFunc->GetLSDAActionTable();
+  for (size_t i = 0; i < lsdaActionTable->Size(); ++i) {
+    LSDAAction *lsdaAction = lsdaActionTable->GetActionTable().at(i);
+    emitter->Emit("\t.byte ").Emit(lsdaAction->GetActionIndex()).Emit("\n");
+    emitter->Emit("\t.byte ").Emit(lsdaAction->GetActionFilter()).Emit("\n");
+  }
+  emitter->Emit("\t.align 3\n");
+  for (size_t i = ehFunc->GetEHTyTableSize(); i > 0; i--) {
+    MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ehFunc->GetEHTyTableMember(i - 1));
+    MIRTypeKind typeKind = mirType->GetKind();
+    if (((typeKind == kTypeScalar) && (mirType->GetPrimType() == PTY_void)) || (typeKind == kTypeStructIncomplete) ||
+        (typeKind == kTypeInterfaceIncomplete)) {
+      continue;
+    }
+    CHECK_FATAL((typeKind == kTypeClass) || (typeKind == kTypeClassIncomplete), "NYI");
+    const std::string &tyName = GlobalTables::GetStrTable().GetStringFromStrIdx(mirType->GetNameStrIdx());
+    std::string dwRefString(".LDW.ref.");
+    dwRefString += CLASSINFO_PREFIX_STR;
+    dwRefString += tyName;
+    dwRefString += " - .";
+    emitter->Emit("\t.4byte " + dwRefString + "\n");
+  }
+  /* end of lsda */
+  emitter->EmitStmtLabel(lsdaHeader->GetTTypeOffset().GetEndOffset()->GetLabelIdx());
+}
+
+void AArch64AsmEmitter::EmitBBHeaderLabel(FuncEmitInfo &funcEmitInfo, const std::string &name, LabelIdx labIdx) {
+  (void)name;
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  AArch64CGFunc &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  Emitter &emitter = *(currCG->GetEmitter());
+  LabelOperand &label = aarchCGFunc.GetOrCreateLabelOperand(labIdx);
+  /* if label order is default value -1, set new order */
+  if (label.GetLabelOrder() == 0xFFFFFFFF) {
+    label.SetLabelOrder(currCG->GetLabelOrderCnt());
+    currCG->IncreaseLabelOrderCnt();
+  }
+  PUIdx pIdx = currCG->GetMIRModule()->CurFunction()->GetPuidx();
+  char *puIdx = strdup(std::to_string(pIdx).c_str());
+  const std::string &labelName = cgFunc.GetFunction().GetLabelTab()->GetName(labIdx);
+  if (currCG->GenerateVerboseCG()) {
+    (void)emitter.Emit(".L.").Emit(puIdx).Emit("__").Emit(labIdx).Emit(":\t//label order ").Emit(label.GetLabelOrder());
+    if (!labelName.empty() && labelName.at(0) != '@') {
+      /* If label name has @ as its first char, it is not from MIR */
+      (void)emitter.Emit(", MIR: @").Emit(labelName).Emit("\n");
+    } else {
+      (void)emitter.Emit("\n");
+    }
+  } else {
+    (void)emitter.Emit(".L.").Emit(puIdx).Emit("__").Emit(labIdx).Emit(":\n");
+  }
+  free(puIdx);
+  puIdx = nullptr;
+}
+
+void AArch64AsmEmitter::EmitJavaInsnAddr(FuncEmitInfo &funcEmitInfo) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  if (cgFunc.GetFunction().IsJava()) {
+    Emitter *emitter = cgFunc.GetCG()->GetEmitter();
+    /* emit a comment of current address from the begining of java text section */
+    std::stringstream ss;
+    ss << "\n\t// addr: 0x" << std::hex << (emitter->GetJavaInsnCount() * kInsnSize) << "\n";
+    cgFunc.GetCG()->GetEmitter()->Emit(ss.str());
+  }
+}
+
+void AArch64AsmEmitter::RecordRegInfo(FuncEmitInfo &funcEmitInfo) const {
+  if (!CGOptions::DoIPARA() || funcEmitInfo.GetCGFunc().GetFunction().IsJava()) {
+    return;
+  }
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  AArch64CGFunc &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+
+  std::set<regno_t> referedRegs;
+  MIRFunction &mirFunc = cgFunc.GetFunction();
+  FOR_ALL_BB_REV(bb, &aarchCGFunc) {
+    FOR_BB_INSNS_REV(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (insn->IsCall() || insn->IsTailCall()) {
+        auto *targetOpnd = insn->GetCallTargetOperand();
+        bool safeCheck = false;
+        CHECK_FATAL(targetOpnd != nullptr, "target is null in AArch64Emitter::IsCallToFunctionThatNeverReturns");
+        if (targetOpnd->IsFuncNameOpnd()) {
+          FuncNameOperand *target = static_cast<FuncNameOperand*>(targetOpnd);
+          const MIRSymbol *funcSt = target->GetFunctionSymbol();
+          ASSERT(funcSt->GetSKind() == kStFunc, "funcst must be a function name symbol");
+          MIRFunction *func = funcSt->GetFunction();
+          if (func != nullptr && func->IsReferedRegsValid()) {
+            safeCheck = true;
+            for (auto preg : func->GetReferedRegs()) {
+              referedRegs.insert(preg);
+            }
+          }
+        }
+        if (!safeCheck) {
+          mirFunc.SetReferedRegsValid(false);
+          return;
+        }
+      }
+      if (referedRegs.size() == kMaxRegNum) {
+        break;
+      }
+      uint32 opndNum = insn->GetOperandSize();
+      const InsnDesc *md = &AArch64CG::kMd[insn->GetMachineOpcode()];
+      for (uint32 i = 0; i < opndNum; ++i) {
+        if (insn->GetMachineOpcode() == MOP_asm) {
+          if (i == kAsmOutputListOpnd || i == kAsmClobberListOpnd) {
+            for (auto &opnd : static_cast<const ListOperand &>(insn->GetOperand(i)).GetOperands()) {
+              if (opnd->IsRegister()) {
+                referedRegs.insert(static_cast<RegOperand *>(opnd)->GetRegisterNumber());
+              }
+            }
+          }
+          continue;
+        }
+        Operand &opnd = insn->GetOperand(i);
+        if (opnd.IsList()) {
+          /* all use, skip it */
+        } else if (opnd.IsMemoryAccessOperand()) {
+          auto &memOpnd = static_cast<MemOperand&>(opnd);
+          RegOperand *base = memOpnd.GetBaseRegister();
+          if (!memOpnd.IsIntactIndexed()) {
+            referedRegs.insert(base->GetRegisterNumber());
+          }
+        } else if (opnd.IsRegister()) {
+          RegType regType = static_cast<RegOperand&>(opnd).GetRegisterType();
+          if (regType == kRegTyCc || regType == kRegTyVary) {
+            continue;
+          }
+          bool isDef = md->GetOpndDes(i)->IsRegDef();
+          if (isDef) {
+            referedRegs.insert(static_cast<RegOperand&>(opnd).GetRegisterNumber());
+          }
+        }
+      }
+    }
+  }
+  (void)referedRegs.insert(R16);
+  (void)referedRegs.insert(R17);
+  (void)referedRegs.insert(R18);
+  mirFunc.SetReferedRegsValid(true);
+#ifdef DEBUG
+  for (auto reg : referedRegs) {
+    if (reg > kMaxRegNum) {
+      ASSERT(0, "unexpected preg");
+    }
+  }
+#endif
+  mirFunc.CopyReferedRegs(referedRegs);
+}
+
+/* if the last insn is call, then insert nop */
+static void InsertNopAfterLastCall(AArch64CGFunc &cgFunc) {
+    bool found = false;
+    FOR_ALL_BB_REV(bb, &cgFunc) {
+      FOR_BB_INSNS_REV(insn, bb) {
+        if (insn->IsMachineInstruction()) {
+          if (insn->IsCall()) {
+            Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_nop);
+            bb->InsertInsnAfter(*insn, newInsn);
+          }
+          found = true;
+          break;
+        }
+      }
+      if (found) {
+        break;
+      }
+    }
+}
+
+void AArch64AsmEmitter::Run(FuncEmitInfo &funcEmitInfo) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  AArch64CGFunc &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  /* emit header of this function */
+  Emitter &emitter = *currCG->GetEmitter();
+  // insert for  __cxx_global_var_init
+  if (cgFunc.GetName() == "__cxx_global_var_init") {
+    (void)emitter.Emit("\t.section\t.init_array,\"aw\"\n");
+    (void)emitter.Emit("\t.quad\t").Emit(cgFunc.GetName()).Emit("\n");
+  }
+  if (cgFunc.GetFunction().GetAttr(FUNCATTR_initialization)) {
+    (void)emitter.Emit("\t.section\t.init_array,\"aw\"\n");
+    (void)emitter.Emit("\t.quad\t").Emit(cgFunc.GetName()).Emit("\n");
+  }
+  if (cgFunc.GetFunction().GetAttr(FUNCATTR_termination)) {
+    (void)emitter.Emit("\t.section\t.fini_array,\"aw\"\n");
+    (void)emitter.Emit("\t.quad\t").Emit(cgFunc.GetName()).Emit("\n");
+  }
+  (void)emitter.Emit("\n");
+  EmitMethodDesc(funcEmitInfo, emitter);
+  /* emit java code to the java section. */
+  if (cgFunc.GetFunction().IsJava()) {
+    std::string sectionName = namemangler::kMuidJavatextPrefixStr;
+    (void)emitter.Emit("\t.section  ." + sectionName + ",\"ax\"\n");
+  } else if (cgFunc.GetFunction().GetAttr(FUNCATTR_section)) {
+    const std::string &sectionName = cgFunc.GetFunction().GetAttrs().GetPrefixSectionName();
+    (void)emitter.Emit("\t.section  " + sectionName).Emit(",\"ax\",@progbits\n");
+  } else if (CGOptions::IsFunctionSections()) {
+    (void)emitter.Emit("\t.section  .text.").Emit(cgFunc.GetName()).Emit(",\"ax\",@progbits\n");
+  } else if (cgFunc.GetFunction().GetAttr(FUNCATTR_constructor_priority)) {
+    (void)emitter.Emit("\t.section\t.text.startup").Emit(",\"ax\",@progbits\n");
+  } else {
+    (void)emitter.Emit("\t.text\n");
+  }
+  if (CGOptions::GetFuncAlignPow() != 0) {
+    (void)emitter.Emit("\t.align ").Emit(CGOptions::GetFuncAlignPow()).Emit("\n");
+  }
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(cgFunc.GetFunction().GetStIdx().Idx());
+  const std::string &funcName = std::string(cgFunc.GetShortFuncName().c_str());
+
+  // manually replace function with optimized assembly language
+  if (CGOptions::IsReplaceASM()) {
+    auto it = func2CodeInsnMap.find(funcSt->GetName());
+    if (it != func2CodeInsnMap.end()) {
+      std::string optFile = it->second.first;
+      struct stat buffer;
+      if (stat(optFile.c_str(), &buffer) == 0) {
+        std::ifstream codetricksFd(optFile);
+        if (!codetricksFd.is_open()) {
+          ERR(kLncErr, " %s open failed!", optFile.c_str());
+          LogInfo::MapleLogger() << "wrong" << '\n';
+        } else {
+          std::string contend;
+          while (getline(codetricksFd, contend)) {
+            (void)emitter.Emit(contend + "\n");
+          }
+        }
+      }
+      emitter.IncreaseJavaInsnCount(it->second.second);
+#ifdef EMIT_INSN_COUNT
+      EmitJavaInsnAddr(funcEmitInfo);
+#endif /* ~EMIT_INSN_COUNT */
+      return;
+    }
+  }
+  std::string funcStName = funcSt->GetName();
+  if (funcSt->GetFunction()->GetAttr(FUNCATTR_weak)) {
+    (void)emitter.Emit("\t.weak\t" + funcStName + "\n");
+    if (currCG->GetMIRModule()->IsJavaModule()) {
+      (void)emitter.Emit("\t.hidden\t" + funcStName + "\n");
+    }
+  } else if (funcSt->GetFunction()->GetAttr(FUNCATTR_local)) {
+    (void)emitter.Emit("\t.local\t" + funcStName + "\n");
+  } else if (funcSt->GetFunction() && (!funcSt->GetFunction()->IsJava()) && funcSt->GetFunction()->IsStatic()) {
+    // nothing
+  } else {
+  /* should refer to function attribute */
+    (void)emitter.Emit("\t.globl\t").Emit(funcSt->GetName()).Emit("\n");
+    if (!currCG->GetMIRModule()->IsCModule()) {
+      (void)emitter.Emit("\t.hidden\t").Emit(funcSt->GetName()).Emit("\n");
+    }
+  }
+  (void)emitter.Emit("\t.type\t" + funcStName + ", %function\n");
+  /* add these messege , solve the simpleperf tool error */
+  EmitRefToMethodDesc(funcEmitInfo, emitter);
+  (void)emitter.Emit(funcStName + ":\n");
+
+  if (cgFunc.GetFunction().IsJava()) {
+    InsertNopAfterLastCall(aarchCGFunc);
+  }
+
+  RecordRegInfo(funcEmitInfo);
+
+  /* emit instructions */
+  FOR_ALL_BB(bb, &aarchCGFunc) {
+    if (bb->IsUnreachable()) {
+      continue;
+    }
+    if (bb == aarchCGFunc.GetFirstBB() && bb->IsEmpty()) {
+      continue;
+    }
+    if (currCG->GenerateVerboseCG()) {
+      (void)emitter.Emit("#    freq:").Emit(bb->GetFrequency()).Emit("\n");
+    }
+    /* emit bb headers */
+    if (bb->GetLabIdx() != MIRLabelTable::GetDummyLabel()) {
+      if (aarchCGFunc.GetMirModule().IsCModule() && bb->IsBBNeedAlign() && bb->GetAlignNopNum() != kAlignMovedFlag) {
+        uint32 power = bb->GetAlignPower();
+        (void)emitter.Emit("\t.p2align ").Emit(power).Emit("\n");
+      }
+      EmitBBHeaderLabel(funcEmitInfo, funcName, bb->GetLabIdx());
+    }
+
+    FOR_BB_INSNS(insn, bb) {
+      if (insn->IsCfiInsn()) {
+        EmitAArch64CfiInsn(emitter, *insn);
+      } else if (insn->IsDbgInsn()) {
+        EmitAArch64DbgInsn(funcEmitInfo, emitter, *insn);
+      } else {
+        EmitAArch64Insn(emitter, *insn);
+      }
+    }
+  }
+  if (CGOptions::IsMapleLinker()) {
+    /* Emit a label for calculating method size */
+    (void)emitter.Emit(".Label.end." + funcStName + ":\n");
+  }
+  (void)emitter.Emit("\t.size\t" + funcStName + ", .-").Emit(funcStName + "\n");
+
+  auto constructorAttr = funcSt->GetFunction()->GetAttrs().GetConstructorPriority();
+  if (constructorAttr != -1) {
+    (void)emitter.Emit("\t.section\t.init_array." + std::to_string(constructorAttr) + ",\"aw\"\n");
+    (void)emitter.Emit("\t.align 3\n");
+    (void)emitter.Emit("\t.xword\t" + funcStName + "\n");
+  }
+
+  EHFunc *ehFunc = cgFunc.GetEHFunc();
+  /* emit LSDA */
+  if (cgFunc.GetFunction().IsJava() && (ehFunc != nullptr)) {
+    if (!cgFunc.GetHasProEpilogue()) {
+      (void)emitter.Emit("\t.word 0x55555555\n");
+      emitter.IncreaseJavaInsnCount();
+    } else if (ehFunc->NeedFullLSDA()) {
+      LSDAHeader *lsdaHeader = ehFunc->GetLSDAHeader();
+      PUIdx pIdx = emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx();
+      const std::string &idx = strdup(std::to_string(pIdx).c_str());
+      /*  .word .Label.lsda_label-func_start_label */
+      (void)emitter.Emit("\t.word .L." + idx).Emit("__").Emit(lsdaHeader->GetLSDALabel()->GetLabelIdx());
+      (void)emitter.Emit("-.L." + idx).Emit("__").Emit(cgFunc.GetStartLabel()->GetLabelIdx()).Emit("\n");
+      emitter.IncreaseJavaInsnCount();
+    } else if (ehFunc->NeedFastLSDA()) {
+      EmitFastLSDA(funcEmitInfo);
+    }
+  }
+
+  for (auto &it : cgFunc.GetEmitStVec()) {
+    /* emit switch table only here */
+    MIRSymbol *st = it.second;
+    ASSERT(st->IsReadOnly(), "NYI");
+    (void)emitter.Emit("\n");
+    (void)emitter.Emit("\t.align 3\n");
+    emitter.IncreaseJavaInsnCount(0, true); /* just aligned */
+    (void)emitter.Emit(st->GetName() + ":\n");
+    MIRAggConst *arrayConst = safe_cast<MIRAggConst>(st->GetKonst());
+    CHECK_FATAL(arrayConst != nullptr, "null ptr check");
+    PUIdx pIdx = cgFunc.GetMirModule().CurFunction()->GetPuidx();
+    char *idx = strdup(std::to_string(pIdx).c_str());
+    for (size_t i = 0; i < arrayConst->GetConstVec().size(); i++) {
+      MIRLblConst *lblConst = safe_cast<MIRLblConst>(arrayConst->GetConstVecItem(i));
+      CHECK_FATAL(lblConst != nullptr, "null ptr check");
+      (void)emitter.Emit("\t.quad\t.L.").Emit(idx).Emit("__").Emit(lblConst->GetValue());
+      (void)emitter.Emit(" - " + st->GetName() + "\n");
+      emitter.IncreaseJavaInsnCount(kQuadInsnCount);
+    }
+    free(idx);
+    idx = nullptr;
+  }
+  /* insert manually optimized assembly language */
+  if (funcSt->GetName() == "Landroid_2Futil_2FContainerHelpers_3B_7C_3Cinit_3E_7C_28_29V") {
+    std::string optFile = "maple/mrt/codetricks/arch/arm64/ContainerHelpers_binarySearch.s";
+    struct stat buffer;
+    if (stat(optFile.c_str(), &buffer) == 0) {
+      std::ifstream binarySearchFileFD(optFile);
+      if (!binarySearchFileFD.is_open()) {
+        ERR(kLncErr, " %s open failed!", optFile.c_str());
+      } else {
+        std::string contend;
+        while (getline(binarySearchFileFD, contend)) {
+          (void)emitter.Emit(contend + "\n");
+        }
+      }
+    }
+    emitter.IncreaseJavaInsnCount(kBinSearchInsnCount);
+  }
+
+  for (const auto &mpPair : cgFunc.GetLabelAndValueMap()) {
+    LabelOperand &labelOpnd = aarchCGFunc.GetOrCreateLabelOperand(mpPair.first);
+    A64OpndEmitVisitor visitor(emitter, nullptr);
+    labelOpnd.Accept(visitor);
+    (void)emitter.Emit(":\n");
+    (void)emitter.Emit("\t.quad ").Emit(static_cast<int64>(mpPair.second)).Emit("\n");
+    emitter.IncreaseJavaInsnCount(kQuadInsnCount);
+  }
+
+  if (ehFunc != nullptr && ehFunc->NeedFullLSDA()) {
+    EmitFullLSDA(funcEmitInfo);
+  }
+#ifdef EMIT_INSN_COUNT
+  if (cgFunc.GetFunction().IsJava()) {
+    EmitJavaInsnAddr(funcEmitInfo);
+  }
+#endif /* ~EMIT_INSN_COUNT */
+}
+
+void AArch64AsmEmitter::EmitAArch64Insn(maplebe::Emitter &emitter, Insn &insn) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  emitter.SetCurrentMOP(mOp);
+  const InsnDesc *md = insn.GetDesc();
+
+  if (!GetCG()->GenerateVerboseAsm() && !GetCG()->GenerateVerboseCG() && insn.IsComment()) {
+    return;
+  }
+
+  switch (mOp) {
+    case MOP_clinit: {
+      EmitClinit(emitter, insn);
+      emitter.IncreaseJavaInsnCount(md->GetAtomicNum());
+      return;
+    }
+    case MOP_adrp_ldr: {
+      uint32 adrpldrInsnCount = md->GetAtomicNum();
+      emitter.IncreaseJavaInsnCount(adrpldrInsnCount);
+      EmitAdrpLdr(emitter, insn);
+      if (CGOptions::IsLazyBinding() && !GetCG()->IsLibcore()) {
+        EmitLazyBindingRoutine(emitter, insn);
+        emitter.IncreaseJavaInsnCount(adrpldrInsnCount + 1);
+      }
+      return;
+    }
+    case MOP_counter: {
+      EmitCounter(emitter, insn);
+      return;
+    }
+    case MOP_c_counter: {
+      EmitCCounter(emitter, insn);
+      return;
+    }
+    case MOP_asm: {
+      EmitInlineAsm(emitter, insn);
+      return;
+    }
+    case MOP_clinit_tail: {
+      EmitClinitTail(emitter, insn);
+      emitter.IncreaseJavaInsnCount(md->GetAtomicNum());
+      return;
+    }
+    case MOP_lazy_ldr: {
+      EmitLazyLoad(emitter, insn);
+      emitter.IncreaseJavaInsnCount(md->GetAtomicNum());
+      return;
+    }
+    case MOP_adrp_label: {
+      EmitAdrpLabel(emitter, insn);
+      return;
+    }
+    case MOP_lazy_tail: {
+      /* No need to emit this pseudo instruction. */
+      return;
+    }
+    case MOP_lazy_ldr_static: {
+      EmitLazyLoadStatic(emitter, insn);
+      emitter.IncreaseJavaInsnCount(md->GetAtomicNum());
+      return;
+    }
+    case MOP_arrayclass_cache_ldr: {
+      EmitArrayClassCacheLoad(emitter, insn);
+      emitter.IncreaseJavaInsnCount(md->GetAtomicNum());
+      return;
+    }
+    case MOP_get_and_addI:
+    case MOP_get_and_addL: {
+      EmitGetAndAddInt(emitter, insn);
+      return;
+    }
+    case MOP_get_and_setI:
+    case MOP_get_and_setL: {
+      EmitGetAndSetInt(emitter, insn);
+      return;
+    }
+    case MOP_compare_and_swapI:
+    case MOP_compare_and_swapL: {
+      EmitCompareAndSwapInt(emitter, insn);
+      return;
+    }
+    case MOP_string_indexof: {
+      EmitStringIndexOf(emitter, insn);
+      return;
+    }
+    case MOP_pseudo_none: {
+      return;
+    }
+    case MOP_tls_desc_call: {
+      EmitCTlsDescCall(emitter, insn);
+      return;
+    }
+    case MOP_tls_desc_rel: {
+      EmitCTlsDescRel(emitter, insn);
+      return;
+    }
+    case MOP_sync_lock_test_setI:
+    case MOP_sync_lock_test_setL: {
+      EmitSyncLockTestSet(emitter, insn);
+      return;
+    }
+    default:
+      break;
+  }
+
+  if (CGOptions::IsNativeOpt() && mOp == MOP_xbl) {
+    auto *nameOpnd = static_cast<FuncNameOperand*>(&insn.GetOperand(kInsnFirstOpnd));
+    if (nameOpnd->GetName() == "MCC_CheckThrowPendingException") {
+      EmitCheckThrowPendingException(emitter);
+      emitter.IncreaseJavaInsnCount(md->GetAtomicNum());
+      return;
+    }
+  }
+
+  std::string format(md->format);
+  (void)emitter.Emit("\t").Emit(md->name).Emit("\t");
+  size_t opndSize = insn.GetOperandSize();
+  std::vector<int32> seq(opndSize, -1);
+  std::vector<std::string> prefix(opndSize);  /* used for print prefix like "*" in icall *rax */
+  uint32 index = 0;
+  uint32 commaNum = 0;
+  for (uint32 i = 0; i < format.length(); ++i) {
+    char c = format[i];
+    if (c >= '0' && c <= '5') {
+      seq[index++] = static_cast<int32>(c) - kZeroAsciiNum;
+      ++commaNum;
+    } else if (c != ',') {
+      prefix[index].push_back(c);
+    }
+  }
+
+  bool isRefField = (opndSize == 0) ? false : CheckInsnRefField(insn, static_cast<size_t>(static_cast<uint>(seq[0])));
+  if (insn.IsComment()) {
+    emitter.IncreaseJavaInsnCount();
+  }
+  uint32 compositeOpnds = 0;
+  for (uint32 i = 0; i < commaNum; ++i) {
+    if (seq[i] == -1) {
+      continue;
+    }
+    if (prefix[i].length() > 0) {
+      (void)emitter.Emit(prefix[i]);
+    }
+    if (emitter.NeedToDealWithHugeSo() && (mOp ==  MOP_xbl || mOp == MOP_tail_call_opt_xbl)) {
+      auto *nameOpnd = static_cast<FuncNameOperand*>(&insn.GetOperand(kInsnFirstOpnd));
+      /* Suport huge so here
+       * As the PLT section is just before java_text section, when java_text section is larger
+       * then 128M, instrunction of "b" and "bl" would fault to branch to PLT stub functions. Here, to save
+       * instuctions space, we change the branch target to a local target within 120M address, and add non-plt
+       * call to the target function.
+       */
+      emitter.InsertHugeSoTarget(nameOpnd->GetName());
+      (void)emitter.Emit(nameOpnd->GetName() + emitter.HugeSoPostFix());
+      break;
+    }
+    auto *opnd = &insn.GetOperand(static_cast<uint32>(seq[i]));
+    if (opnd && opnd->IsRegister()) {
+      auto *regOpnd = static_cast<RegOperand*>(opnd);
+      if ((md->opndMD[static_cast<uint32>(seq[i])])->IsVectorOperand()) {
+        regOpnd->SetVecLanePosition(-1);
+        regOpnd->SetVecLaneSize(0);
+        regOpnd->SetVecElementSize(0);
+        if (insn.IsVectorOp()) {
+          PrepareVectorOperand(regOpnd, compositeOpnds, insn);
+          if (compositeOpnds != 0) {
+            (void)emitter.Emit("{");
+          }
+        }
+      }
+    }
+    A64OpndEmitVisitor visitor(emitter, md->opndMD[static_cast<uint32>(seq[i])]);
+
+    insn.GetOperand(static_cast<uint32>(seq[i])).Accept(visitor);
+    if (compositeOpnds == 1) {
+      (void)emitter.Emit("}");
+    }
+    if (compositeOpnds > 0) {
+      --compositeOpnds;
+    }
+    /* reset opnd0 ref-field flag, so following instruction has correct register */
+    if (isRefField && (i == 0)) {
+      static_cast<RegOperand*>(&insn.GetOperand(static_cast<uint32>(seq[0])))->SetRefField(false);
+    }
+    /* Temporary comment the label:.Label.debug.callee */
+    if (i != (commaNum - 1)) {
+      (void)emitter.Emit(", ");
+    }
+    const uint32 commaNumForEmitLazy = 2;
+    if (!CGOptions::IsLazyBinding() || GetCG()->IsLibcore() || (mOp != MOP_wldr && mOp != MOP_xldr) ||
+        commaNum != commaNumForEmitLazy || i != 1 ||
+        !insn.GetOperand(static_cast<uint32>(seq[1])).IsMemoryAccessOperand()) {
+      continue;
+    }
+    /*
+     * Only check the last operand of ldr in lo12 mode.
+     * Check the second operand, if it's [AArch64MemOperand::kAddrModeLo12Li]
+     */
+    auto *memOpnd = static_cast<MemOperand*>(&insn.GetOperand(static_cast<uint32>(seq[1])));
+    if (memOpnd == nullptr || memOpnd->GetAddrMode() != MemOperand::kAddrModeLo12Li) {
+      continue;
+    }
+    const MIRSymbol *sym = memOpnd->GetSymbol();
+    if (sym->IsMuidFuncDefTab() || sym->IsMuidFuncUndefTab() ||
+        sym->IsMuidDataDefTab() || sym->IsMuidDataUndefTab()) {
+      (void)emitter.Emit("\n");
+      EmitLazyBindingRoutine(emitter, insn);
+      emitter.IncreaseJavaInsnCount(1);
+    }
+  }
+  if (GetCG()->GenerateVerboseCG() || (GetCG()->GenerateVerboseAsm() && insn.IsComment())) {
+    const char *comment = insn.GetComment().c_str();
+    if (comment != nullptr && strlen(comment) > 0) {
+      (void)emitter.Emit("\t\t// ").Emit(comment);
+    }
+  }
+
+  (void)emitter.Emit("\n");
+}
+
+void AArch64AsmEmitter::EmitClinit(Emitter &emitter, const Insn &insn) const {
+  /*
+   * adrp    x3, __muid_data_undef_tab$$GetBoolean_dex+144
+   * ldr     x3, [x3, #:lo12:__muid_data_undef_tab$$GetBoolean_dex+144]
+   * or,
+   * adrp    x3, _PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B
+   * ldr     x3, [x3, #:lo12:_PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B]
+   *
+   * ldr x3, [x3,#112]
+   * ldr wzr, [x3]
+   */
+  const InsnDesc *md = &AArch64CG::kMd[MOP_clinit];
+
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+  Operand *opnd1 = &insn.GetOperand(kInsnSecondOpnd);
+  const OpndDesc *prop0 = md->opndMD[0];
+  A64OpndEmitVisitor visitor(emitter, prop0);
+  auto *stImmOpnd = static_cast<StImmOperand*>(opnd1);
+  CHECK_FATAL(stImmOpnd != nullptr, "stImmOpnd is null in AArch64Emitter::EmitClinit");
+  /* emit nop for breakpoint */
+  if (GetCG()->GetCGOptions().WithDwarf()) {
+    (void)emitter.Emit("\t").Emit("nop").Emit("\n");
+  }
+
+  if (stImmOpnd->GetSymbol()->IsMuidDataUndefTab()) {
+    /* emit adrp */
+    (void)emitter.Emit("\t").Emit("adrp").Emit("\t");
+    opnd0->Accept(visitor);
+    (void)emitter.Emit(",");
+    (void)emitter.Emit(stImmOpnd->GetName());
+    (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+    (void)emitter.Emit("\n");
+    /* emit ldr */
+    (void)emitter.Emit("\t").Emit("ldr").Emit("\t");
+    opnd0->Accept(visitor);
+    (void)emitter.Emit(",");
+    (void)emitter.Emit("[");
+    opnd0->Accept(visitor);
+    (void)emitter.Emit(",");
+    (void)emitter.Emit("#");
+    (void)emitter.Emit(":lo12:").Emit(stImmOpnd->GetName());
+    (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+    (void)emitter.Emit("]");
+    (void)emitter.Emit("\n");
+  } else {
+    /* adrp    x3, _PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B */
+    (void)emitter.Emit("\tadrp\t");
+    opnd0->Accept(visitor);
+    (void)emitter.Emit(",");
+    (void)emitter.Emit(namemangler::kPtrPrefixStr + stImmOpnd->GetName());
+    (void)emitter.Emit("\n");
+
+    /* ldr     x3, [x3, #:lo12:_PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B] */
+    (void)emitter.Emit("\tldr\t");
+    opnd0->Accept(visitor);
+    (void)emitter.Emit(", [");
+    opnd0->Accept(visitor);
+    (void)emitter.Emit(", #:lo12:");
+    (void)emitter.Emit(namemangler::kPtrPrefixStr + stImmOpnd->GetName());
+    (void)emitter.Emit("]\n");
+  }
+  /* emit "ldr  x0,[x0,#48]" */
+  (void)emitter.Emit("\t").Emit("ldr").Emit("\t");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(",");
+  (void)emitter.Emit("[");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(",#");
+  (void)emitter.Emit(static_cast<uint32>(ClassMetadata::OffsetOfInitState()));
+  (void)emitter.Emit("]");
+  (void)emitter.Emit("\n");
+
+  /* emit "ldr  xzr, [x0]" */
+  (void)emitter.Emit("\t").Emit("ldr\txzr, [");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit("]\n");
+}
+
+static void AsmStringOutputRegNum(
+    bool isInt, uint32 regno, uint32 intBase, uint32 fpBase, std::string &strToEmit) {
+  regno_t newRegno;
+  if (isInt) {
+    newRegno = regno - intBase;
+  } else {
+    newRegno = regno - fpBase;
+  }
+  if (newRegno > (kDecimalMax - 1)) {
+    uint32 tenth = newRegno / kDecimalMax;
+    strToEmit += static_cast<char>(kZeroAsciiNum + tenth);
+    newRegno -= (kDecimalMax * tenth);
+  }
+  strToEmit += static_cast<char>(static_cast<int32>(newRegno) + kZeroAsciiNum);
+}
+
+void AArch64AsmEmitter::EmitInlineAsm(Emitter &emitter, const Insn &insn) const {
+  (void)emitter.Emit("\t//Inline asm begin\n\t");
+  auto &list1 = static_cast<const ListOperand&>(insn.GetOperand(kAsmOutputListOpnd));
+  std::vector<RegOperand *> outOpnds;
+  for (auto *regOpnd : list1.GetOperands()) {
+    outOpnds.push_back(regOpnd);
+  }
+  auto &list2 = static_cast<const ListOperand&>(insn.GetOperand(kAsmInputListOpnd));
+  std::vector<RegOperand *> inOpnds;
+  for (auto *regOpnd : list2.GetOperands()) {
+    inOpnds.push_back(regOpnd);
+  }
+  auto &list6 = static_cast<ListConstraintOperand&>(insn.GetOperand(kAsmOutputRegPrefixOpnd));
+  auto &list7 = static_cast<ListConstraintOperand&>(insn.GetOperand(kAsmInputRegPrefixOpnd));
+  MapleString asmStr = static_cast<StringOperand&>(insn.GetOperand(kAsmStringOpnd)).GetComment();
+  std::string stringToEmit;
+  size_t sidx = 0;
+  auto isMemAccess = [](char c)->bool {
+    return c == '[';
+  };
+  auto emitRegister = [&](const char *p, bool isInt, uint32 regNO, bool unDefRegSize)->void {
+    if (isMemAccess(p[0])) {
+      stringToEmit += "[x";
+      AsmStringOutputRegNum(isInt, regNO, R0, V0, stringToEmit);
+      stringToEmit += "]";
+    } else {
+      ASSERT((p[0] == 'w' || p[0] == 'x' || p[0] == 's' || p[0] == 'd' || p[0] == 'v'), "Asm invalid register type");
+      if ((p[0] == 'w' || p[0] == 'x') && unDefRegSize) {
+        stringToEmit += 'x';
+      } else {
+        stringToEmit += p[0];
+      }
+      if (!unDefRegSize) {
+        isInt = (p[0] == 'w' || p[0] == 'x');
+      }
+      AsmStringOutputRegNum(isInt, regNO, R0, V0, stringToEmit);
+    }
+  };
+  for (size_t i = 0; i < asmStr.length(); ++i) {
+    switch (asmStr[i]) {
+      case '$': {
+        char c = asmStr[++i];
+        if ((c >= '0') && (c <= '9')) {
+          auto val = static_cast<uint32>(static_cast<int32>(c) - kZeroAsciiNum);
+          if (asmStr[i + 1] >= '0' && asmStr[i + 1] <= '9') {
+            val = val * kDecimalMax + static_cast<uint32>(static_cast<int32>(asmStr[++i]) - kZeroAsciiNum);
+          }
+          if (val < outOpnds.size()) {
+            const char *prefix = list6.stringList[val]->GetComment().c_str();
+            RegOperand *opnd = outOpnds[val];
+            emitRegister(prefix, opnd->IsOfIntClass(), opnd->GetRegisterNumber(), true);
+          } else {
+            val -= static_cast<uint32>(outOpnds.size());
+            CHECK_FATAL(val < inOpnds.size(), "Inline asm : invalid register constraint number");
+            RegOperand *opnd = inOpnds[val];
+            /* input is a immediate */
+            const char *prefix = list7.stringList[val]->GetComment().c_str();
+            if (prefix[0] == 'i') {
+              stringToEmit += '#';
+              for (size_t k = 1; k < list7.stringList[val]->GetComment().length(); ++k) {
+                stringToEmit += prefix[k];
+              }
+            } else {
+              emitRegister(prefix, opnd->IsOfIntClass(), opnd->GetRegisterNumber(), true);
+            }
+          }
+        } else if (c == '{') {
+          c = asmStr[++i];
+          CHECK_FATAL(((c >= '0') && (c <= '9')), "Inline asm : invalid register constraint number");
+          auto val = static_cast<uint32>(c - '0');
+          if (asmStr[i + 1] >= '0' && asmStr[i + 1] <= '9') {
+            val = val * kDecimalMax + static_cast<uint32>(asmStr[++i] - '0');
+          }
+          regno_t regno;
+          bool isAddr = false;
+          if (val < outOpnds.size()) {
+            RegOperand *opnd = outOpnds[val];
+            regno = opnd->GetRegisterNumber();
+            isAddr = isMemAccess(list6.stringList[val]->GetComment().c_str()[0]);
+          } else {
+            val -= static_cast<uint32>(outOpnds.size());
+            CHECK_FATAL(val < inOpnds.size(), "Inline asm : invalid register constraint number");
+            RegOperand *opnd = inOpnds[val];
+            regno = opnd->GetRegisterNumber();
+            isAddr = isMemAccess(list7.stringList[val]->GetComment().c_str()[0]);
+          }
+          c = asmStr[++i];
+          CHECK_FATAL(c == ':', "Parsing error in inline asm string during emit");
+          c = asmStr[++i];
+          std::string prefix(1, c);
+          if (c == 'a' || isAddr) {
+            prefix = "[x";
+          }
+          emitRegister(prefix.c_str(), true, regno, false);
+          c = asmStr[++i];
+          CHECK_FATAL(c == '}', "Parsing error in inline asm string during emit");
+        }
+        break;
+      }
+      case '\n': {
+        stringToEmit += "\n\t";
+        break;
+      }
+      default:
+        stringToEmit += asmStr[i];
+        sidx++;
+    }
+  }
+  (void)emitter.Emit(stringToEmit);
+  (void)emitter.Emit("\n\t//Inline asm end\n");
+}
+
+void AArch64AsmEmitter::EmitClinitTail(Emitter &emitter, const Insn &insn) const {
+  /*
+   * ldr x17, [xs, #112]
+   * ldr wzr, [x17]
+   */
+  const InsnDesc *md = &AArch64CG::kMd[MOP_clinit_tail];
+
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+
+  const OpndDesc *prop0 = md->opndMD[0];
+  A64OpndEmitVisitor visitor(emitter, prop0);
+
+  /* emit "ldr  x17,[xs,#112]" */
+  (void)emitter.Emit("\t").Emit("ldr").Emit("\tx17, [");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(", #");
+  (void)emitter.Emit(static_cast<uint32>(ClassMetadata::OffsetOfInitState()));
+  (void)emitter.Emit("]");
+  (void)emitter.Emit("\n");
+
+  /* emit "ldr  xzr, [x17]" */
+  (void)emitter.Emit("\t").Emit("ldr\txzr, [x17]\n");
+}
+
+void AArch64AsmEmitter::EmitLazyLoad(Emitter &emitter, const Insn &insn) const {
+  /*
+   * ldr wd, [xs]  # xd and xs should be differenct register
+   * ldr wd, [xd]
+   */
+  const InsnDesc *md = &AArch64CG::kMd[MOP_lazy_ldr];
+
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+  Operand *opnd1 = &insn.GetOperand(kInsnSecondOpnd);
+  const OpndDesc *prop0 = md->opndMD[0];
+  const OpndDesc *prop1 = md->opndMD[1];
+  A64OpndEmitVisitor visitor(emitter, prop0);
+  A64OpndEmitVisitor visitor1(emitter, prop1);
+
+  /* emit  "ldr wd, [xs]" */
+  (void)emitter.Emit("\t").Emit("ldr\t");
+#ifdef USE_32BIT_REF
+  opnd0->Accept(visitor);
+#else
+  opnd0->Accept(visitor1);
+#endif
+  (void)emitter.Emit(", [");
+  opnd1->Accept(visitor1);
+  (void)emitter.Emit("]\t// lazy load.\n");
+
+  /* emit "ldr wd, [xd]" */
+  (void)emitter.Emit("\t").Emit("ldr\t");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(", [");
+  opnd1->Accept(visitor1);
+  (void)emitter.Emit("]\t// lazy load.\n");
+}
+
+void AArch64AsmEmitter::EmitCounter(Emitter &emitter, const Insn &insn) const {
+  /*
+   * adrp    x1, __profile_bb_table$$GetBoolean_dex+4
+   * ldr     w17, [x1, #:lo12:__profile_bb_table$$GetBoolean_dex+4]
+   * add     w17, w17, #1
+   * str     w17, [x1, #:lo12:__profile_bb_table$$GetBoolean_dex+4]
+   */
+  const InsnDesc *md = &AArch64CG::kMd[MOP_counter];
+
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+  Operand *opnd1 = &insn.GetOperand(kInsnSecondOpnd);
+  const OpndDesc *prop0 = md->opndMD[kInsnFirstOpnd];
+  A64OpndEmitVisitor visitor(emitter, prop0);
+  StImmOperand *stImmOpnd = static_cast<StImmOperand*>(opnd1);
+  CHECK_FATAL(stImmOpnd != nullptr, "stImmOpnd is null in AArch64Emitter::EmitCounter");
+  /* emit nop for breakpoint */
+  if (GetCG()->GetCGOptions().WithDwarf()) {
+    (void)emitter.Emit("\t").Emit("nop").Emit("\n");
+  }
+
+  /* emit adrp */
+  (void)emitter.Emit("\t").Emit("adrp").Emit("\t");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(",");
+  (void)emitter.Emit(stImmOpnd->GetName());
+  (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+  (void)emitter.Emit("\n");
+  /* emit ldr */
+  (void)emitter.Emit("\t").Emit("ldr").Emit("\tw17, [");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(",");
+  (void)emitter.Emit("#");
+  (void)emitter.Emit(":lo12:").Emit(stImmOpnd->GetName());
+  (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+  (void)emitter.Emit("]");
+  (void)emitter.Emit("\n");
+  /* emit add */
+  (void)emitter.Emit("\t").Emit("add").Emit("\tw17, w17, #1");
+  (void)emitter.Emit("\n");
+  /* emit str */
+  (void)emitter.Emit("\t").Emit("str").Emit("\tw17, [");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(",");
+  (void)emitter.Emit("#");
+  (void)emitter.Emit(":lo12:").Emit(stImmOpnd->GetName());
+  (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+  (void)emitter.Emit("]");
+  (void)emitter.Emit("\n");
+}
+
+void AArch64AsmEmitter::EmitCCounter(Emitter &emitter, const Insn &insn) const {
+  const InsnDesc *md = &AArch64CG::kMd[MOP_c_counter];
+
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+  Operand *opnd1 = &insn.GetOperand(kInsnSecondOpnd);
+  const OpndDesc *prop1 = md->opndMD[kInsnSecondOpnd];
+  auto *stImmOpnd = static_cast<StImmOperand*>(opnd0);
+  CHECK_FATAL(stImmOpnd != nullptr, "stImmOpnd is null in AArch64Insn::EmitCounter");
+  /* spill linker register */
+  (void)emitter.Emit("\tstr\tx30, [sp, #-16]!\n");
+  /* get counter symbol address */
+  (void)emitter.Emit("\tadrp\tx16, ");
+
+  if (CGOptions::IsPIC()) {
+    (void)emitter.Emit(":got:");
+  }
+  (void)emitter.Emit(stImmOpnd->GetName()).Emit("\n");
+
+  if (CGOptions::IsPIC()) {
+    (void)emitter.Emit("\tldr\tx16, [x16, :got_lo12:");
+    (void)emitter.Emit(stImmOpnd->GetName());
+    (void)emitter.Emit("]\n");
+  } else {
+    (void)emitter.Emit("\tadd\tx16, x16, :lo12:\n");
+    (void)emitter.Emit(stImmOpnd->GetName());
+    (void)emitter.Emit("\n");
+  }
+
+  A64OpndEmitVisitor visitor(emitter, prop1);
+  /* load current count */
+  (void)emitter.Emit("\tldr\tx30, [x16, ");
+  opnd1->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  /* increment */
+  (void)emitter.Emit("\tadd\tx30, x30, #1\n");
+  /* str new count */
+  (void)emitter.Emit("\tstr\tx30, [x16, ");
+  opnd1->Accept(visitor);
+  (void)emitter.Emit("]\n");
+
+  /* reload linker register */
+  (void)emitter.Emit("\tldr\tx30, [sp], #16\n");
+}
+
+void AArch64AsmEmitter::EmitAdrpLabel(Emitter &emitter, const Insn &insn) const {
+  /* adrp    xd, label
+   * add     xd, xd, #lo12:label
+   */
+  const InsnDesc *md = &AArch64CG::kMd[MOP_adrp_label];
+
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+  Operand *opnd1 = &insn.GetOperand(kInsnSecondOpnd);
+  const OpndDesc *prop0 = md->opndMD[0];
+  A64OpndEmitVisitor visitor(emitter, prop0);
+  auto lidx = static_cast<ImmOperand *>(opnd1)->GetValue();
+
+  /* adrp    xd, label */
+  (void)emitter.Emit("\t").Emit("adrp").Emit("\t");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(", ");
+  char *idx = strdup(
+      std::to_string(Globals::GetInstance()->GetBECommon()->GetMIRModule().CurFunction()->GetPuidx()).c_str());
+  (void)emitter.Emit(".L.").Emit(idx).Emit("__").Emit(lidx).Emit("\n");
+
+  /* add     xd, xd, #lo12:label */
+  (void)emitter.Emit("\tadd\t");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(", ");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(", ");
+  (void)emitter.Emit(":lo12:").Emit(".L.").Emit(idx).Emit("__").Emit(lidx).Emit("\n");
+  (void)emitter.Emit("\n");
+  free(idx);
+  idx = nullptr;
+}
+
+void AArch64AsmEmitter::EmitAdrpLdr(Emitter &emitter, const Insn &insn) const {
+  /*
+   * adrp    xd, _PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B
+   * ldr     xd, [xd, #:lo12:_PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B]
+   */
+  const InsnDesc *md = &AArch64CG::kMd[MOP_adrp_ldr];
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+  Operand *opnd1 = &insn.GetOperand(kInsnSecondOpnd);
+  const OpndDesc *prop0 = md->opndMD[0];
+  A64OpndEmitVisitor visitor(emitter, prop0);
+  auto *stImmOpnd = static_cast<StImmOperand*>(opnd1);
+  CHECK_FATAL(stImmOpnd != nullptr, "stImmOpnd is null in AArch64Emitter::EmitAdrpLdr");
+  /* emit nop for breakpoint */
+  if (GetCG()->GetCGOptions().WithDwarf()) {
+    (void)emitter.Emit("\t").Emit("nop").Emit("\n");
+  }
+
+  /* adrp    xd, _PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B */
+  (void)emitter.Emit("\t").Emit("adrp").Emit("\t");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(", ");
+  (void)emitter.Emit(stImmOpnd->GetName());
+  if (stImmOpnd->GetOffset() != 0) {
+    (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+  }
+  (void)emitter.Emit("\n");
+
+  /* ldr     xd, [xd, #:lo12:_PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B] */
+  (void)emitter.Emit("\tldr\t");
+  static_cast<RegOperand*>(opnd0)->SetRefField(true);
+  opnd0->Accept(visitor);
+  static_cast<RegOperand*>(opnd0)->SetRefField(false);
+  (void)emitter.Emit(", ");
+  (void)emitter.Emit("[");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(",");
+  (void)emitter.Emit("#");
+  (void)emitter.Emit(":lo12:").Emit(stImmOpnd->GetName());
+  if (stImmOpnd->GetOffset() != 0) {
+    (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+  }
+  (void)emitter.Emit("]\n");
+}
+
+void AArch64AsmEmitter::EmitLazyLoadStatic(Emitter &emitter, const Insn &insn) const {
+  /* adrp xd, :got:__staticDecoupleValueOffset$$xxx+offset
+   * ldr wd, [xd, #:got_lo12:__staticDecoupleValueOffset$$xxx+offset]
+   * ldr wzr, [xd]
+   */
+  const InsnDesc *md = &AArch64CG::kMd[MOP_lazy_ldr_static];
+
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+  Operand *opnd1 = &insn.GetOperand(kInsnSecondOpnd);
+  const OpndDesc *prop0 = md->GetOpndDes(0);
+  A64OpndEmitVisitor visitor(emitter, prop0);
+  auto *stImmOpnd = static_cast<StImmOperand*>(opnd1);
+  CHECK_FATAL(stImmOpnd != nullptr, "stImmOpnd is null in AArch64Emitter::EmitLazyLoadStatic");
+
+  /* emit "adrp xd, :got:__staticDecoupleValueOffset$$xxx+offset" */
+  (void)emitter.Emit("\t").Emit("adrp").Emit("\t");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(", ");
+  (void)emitter.Emit(stImmOpnd->GetName());
+  if (stImmOpnd->GetOffset() != 0) {
+    (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+  }
+  (void)emitter.Emit("\t// lazy load static.\n");
+
+  /* emit "ldr wd, [xd, #:got_lo12:__staticDecoupleValueOffset$$xxx+offset]" */
+  (void)emitter.Emit("\tldr\t");
+  static_cast<RegOperand*>(opnd0)->SetRefField(true);
+#ifdef USE_32BIT_REF
+  const OpndDesc prop2(prop0->GetOperandType(), prop0->GetRegProp(), prop0->GetSize() / 2);
+  opnd0->Emit(emitter, &prop2); /* ldr wd, ... for emui */
+#else
+  opnd0->Accept(visitor);  /* ldr xd, ... for qemu */
+#endif /* USE_32BIT_REF */
+  static_cast<RegOperand*>(opnd0)->SetRefField(false);
+  (void)emitter.Emit(", ");
+  (void)emitter.Emit("[");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(",");
+  (void)emitter.Emit("#");
+  (void)emitter.Emit(":lo12:").Emit(stImmOpnd->GetName());
+  if (stImmOpnd->GetOffset() != 0) {
+    (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+  }
+  (void)emitter.Emit("]\t// lazy load static.\n");
+
+  /* emit "ldr wzr, [xd]" */
+  (void)emitter.Emit("\t").Emit("ldr\twzr, [");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit("]\t// lazy load static.\n");
+}
+
+void AArch64AsmEmitter::EmitArrayClassCacheLoad(Emitter &emitter, const Insn &insn) const {
+  /* adrp xd, :got:__arrayClassCacheTable$$xxx+offset
+   * ldr wd, [xd, #:got_lo12:__arrayClassCacheTable$$xxx+offset]
+   * ldr wzr, [xd]
+   */
+  const InsnDesc *md = &AArch64CG::kMd[MOP_arrayclass_cache_ldr];
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+  Operand *opnd1 = &insn.GetOperand(kInsnSecondOpnd);
+  const OpndDesc *prop0 = md->GetOpndDes(kInsnFirstOpnd);
+  A64OpndEmitVisitor visitor(emitter, prop0);
+  auto *stImmOpnd = static_cast<StImmOperand*>(opnd1);
+  CHECK_FATAL(stImmOpnd != nullptr, "stImmOpnd is null in AArch64Emitter::EmitLazyLoadStatic");
+
+  /* emit "adrp xd, :got:__arrayClassCacheTable$$xxx+offset" */
+  (void)emitter.Emit("\t").Emit("adrp").Emit("\t");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(", ");
+  (void)emitter.Emit(stImmOpnd->GetName());
+  if (stImmOpnd->GetOffset() != 0) {
+    (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+  }
+  (void)emitter.Emit("\t// load array class.\n");
+
+  /* emit "ldr wd, [xd, #:got_lo12:__arrayClassCacheTable$$xxx+offset]" */
+  (void)emitter.Emit("\tldr\t");
+  static_cast<RegOperand*>(opnd0)->SetRefField(true);
+#ifdef USE_32BIT_REF
+  const OpndDesc prop2(prop0->GetOperandType(), prop0->GetRegProp(), prop0->GetSize() / 2);
+  A64OpndEmitVisitor visitor2(emitter, prop2);
+  opnd0->Accept(visitor2); /* ldr wd, ... for emui */
+#else
+  opnd0->Accept(visitor);  /* ldr xd, ... for qemu */
+#endif /* USE_32BIT_REF */
+  static_cast<RegOperand*>(opnd0)->SetRefField(false);
+  (void)emitter.Emit(", ");
+  (void)emitter.Emit("[");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit(",");
+  (void)emitter.Emit("#");
+  (void)emitter.Emit(":lo12:").Emit(stImmOpnd->GetName());
+  if (stImmOpnd->GetOffset() != 0) {
+    (void)emitter.Emit("+").Emit(stImmOpnd->GetOffset());
+  }
+  (void)emitter.Emit("]\t// load array class.\n");
+
+  /* emit "ldr wzr, [xd]" */
+  (void)emitter.Emit("\t").Emit("ldr\twzr, [");
+  opnd0->Accept(visitor);
+  (void)emitter.Emit("]\t// check resolve array class.\n");
+}
+
+/*
+ * intrinsic_get_add_int w0, xt, wt, ws, x1, x2, w3, label
+ * add    xt, x1, x2
+ * label:
+ * ldaxr  w0, [xt]
+ * add    wt, w0, w3
+ * stlxr  ws, wt, [xt]
+ * cbnz   ws, label
+ */
+void AArch64AsmEmitter::EmitGetAndAddInt(Emitter &emitter, const Insn &insn) const {
+  ASSERT(insn.GetOperandSize() > kInsnEighthOpnd, "ensure the oprands number");
+  (void)emitter.Emit("\t//\tstart of Unsafe.getAndAddInt.\n");
+  Operand *tempOpnd0 = &insn.GetOperand(kInsnSecondOpnd);
+  Operand *tempOpnd1 = &insn.GetOperand(kInsnThirdOpnd);
+  Operand *tempOpnd2 = &insn.GetOperand(kInsnFourthOpnd);
+  Operand *objOpnd = &insn.GetOperand(kInsnFifthOpnd);
+  Operand *offsetOpnd = &insn.GetOperand(kInsnSixthOpnd);
+  Operand *deltaOpnd = &insn.GetOperand(kInsnSeventhOpnd);
+  Operand *labelOpnd = &insn.GetOperand(kInsnEighthOpnd);
+  A64OpndEmitVisitor visitor(emitter, nullptr);
+  /* emit add. */
+  (void)emitter.Emit("\t").Emit("add").Emit("\t");
+  tempOpnd0->Accept(visitor);
+  (void)emitter.Emit(", ");
+  objOpnd->Accept(visitor);
+  (void)emitter.Emit(", ");
+  offsetOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* emit label. */
+  labelOpnd->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  Operand *retVal = &insn.GetOperand(kInsnFirstOpnd);
+  const MOperator mOp = insn.GetMachineOpcode();
+  const InsnDesc *md = &AArch64CG::kMd[mOp];
+  const OpndDesc *retProp = md->opndMD[kInsnFirstOpnd];
+  A64OpndEmitVisitor retVisitor(emitter, retProp);
+  /* emit ldaxr */
+  (void)emitter.Emit("\t").Emit("ldaxr").Emit("\t");
+  retVal->Accept(retVisitor);
+  (void)emitter.Emit(", [");
+  tempOpnd0->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  /* emit add. */
+  (void)emitter.Emit("\t").Emit("add").Emit("\t");
+  tempOpnd1->Accept(retVisitor);
+  (void)emitter.Emit(", ");
+  retVal->Accept(retVisitor);
+  (void)emitter.Emit(", ");
+  deltaOpnd->Accept(retVisitor);
+  (void)emitter.Emit("\n");
+  /* emit stlxr. */
+  (void)emitter.Emit("\t").Emit("stlxr").Emit("\t");
+  tempOpnd2->Accept(visitor);
+  (void)emitter.Emit(", ");
+  tempOpnd1->Accept(retVisitor);
+  (void)emitter.Emit(", [");
+  tempOpnd0->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  /* emit cbnz. */
+  (void)emitter.Emit("\t").Emit("cbnz").Emit("\t");
+  tempOpnd2->Accept(visitor);
+  (void)emitter.Emit(", ");
+  labelOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+  (void)emitter.Emit("\t//\tend of Unsafe.getAndAddInt.\n");
+}
+
+/*
+ * intrinsic_get_set_int w0, xt, ws, x1, x2, w3, label
+ * add    xt, x1, x2
+ * label:
+ * ldaxr  w0, [xt]
+ * stlxr  ws, w3, [xt]
+ * cbnz   ws, label
+ */
+void AArch64AsmEmitter::EmitGetAndSetInt(Emitter &emitter, const Insn &insn) const {
+  /* MOP_get_and_setI and MOP_get_and_setL have 7 operands */
+  ASSERT(insn.GetOperandSize() > kInsnSeventhOpnd, "ensure the operands number");
+  Operand *tempOpnd0 = &insn.GetOperand(kInsnSecondOpnd);
+  Operand *tempOpnd1 = &insn.GetOperand(kInsnThirdOpnd);
+  Operand *objOpnd = &insn.GetOperand(kInsnFourthOpnd);
+  Operand *offsetOpnd = &insn.GetOperand(kInsnFifthOpnd);
+  A64OpndEmitVisitor visitor(emitter, nullptr);
+  /* add    x1, x1, x2 */
+  (void)emitter.Emit("\tadd\t");
+  tempOpnd0->Accept(visitor);
+  (void)emitter.Emit(", ");
+  objOpnd->Accept(visitor);
+  (void)emitter.Emit(", ");
+  offsetOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+  Operand *labelOpnd = &insn.GetOperand(kInsnSeventhOpnd);
+  /* label: */
+  labelOpnd->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  Operand *retVal = &insn.GetOperand(kInsnFirstOpnd);
+  /* ldaxr  w0, [xt] */
+  (void)emitter.Emit("\tldaxr\t");
+  retVal->Accept(visitor);
+  (void)emitter.Emit(", [");
+  tempOpnd0->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  Operand *newValueOpnd = &insn.GetOperand(kInsnSixthOpnd);
+  /* stlxr  ws, w3, [xt] */
+  (void)emitter.Emit("\tstlxr\t");
+  tempOpnd1->Accept(visitor);
+  (void)emitter.Emit(", ");
+  newValueOpnd->Accept(visitor);
+  (void)emitter.Emit(", [");
+  tempOpnd0->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  /* cbnz   w2, label */
+  (void)emitter.Emit("\tcbnz\t");
+  tempOpnd1->Accept(visitor);
+  (void)emitter.Emit(", ");
+  labelOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+}
+
+/*
+ * intrinsic_string_indexof w0, x1, w2, x3, w4, x5, x6, x7, x8, x9, w10,
+ *                          Label.FIRST_LOOP, Label.STR2_NEXT, Label.STR1_LOOP,
+ *                          Label.STR1_NEXT, Label.LAST_WORD, Label.NOMATCH, Label.RET
+ * cmp       w4, w2
+ * b.gt      .Label.NOMATCH
+ * sub       w2, w2, w4
+ * sub       w4, w4, #8
+ * mov       w10, w2
+ * uxtw      x4, w4
+ * uxtw      x2, w2
+ * add       x3, x3, x4
+ * add       x1, x1, x2
+ * neg       x4, x4
+ * neg       x2, x2
+ * ldr       x5, [x3,x4]
+ * .Label.FIRST_LOOP:
+ * ldr       x7, [x1,x2]
+ * cmp       x5, x7
+ * b.eq      .Label.STR1_LOOP
+ * .Label.STR2_NEXT:
+ * adds      x2, x2, #1
+ * b.le      .Label.FIRST_LOOP
+ * b         .Label.NOMATCH
+ * .Label.STR1_LOOP:
+ * adds      x8, x4, #8
+ * add       x9, x2, #8
+ * b.ge      .Label.LAST_WORD
+ * .Label.STR1_NEXT:
+ * ldr       x6, [x3,x8]
+ * ldr       x7, [x1,x9]
+ * cmp       x6, x7
+ * b.ne      .Label.STR2_NEXT
+ * adds      x8, x8, #8
+ * add       x9, x9, #8
+ * b.lt      .Label.STR1_NEXT
+ * .Label.LAST_WORD:
+ * ldr       x6, [x3]
+ * sub       x9, x1, x4
+ * ldr       x7, [x9,x2]
+ * cmp       x6, x7
+ * b.ne      .Label.STR2_NEXT
+ * add       w0, w10, w2
+ * b         .Label.RET
+ * .Label.NOMATCH:
+ * mov       w0, #-1
+ * .Label.RET:
+ */
+void AArch64AsmEmitter::EmitStringIndexOf(Emitter &emitter, const Insn &insn) const {
+  /* MOP_string_indexof has 18 operands */
+  ASSERT(insn.GetOperandSize() == 18, "ensure the operands number");
+  Operand *patternLengthOpnd = &insn.GetOperand(kInsnFifthOpnd);
+  Operand *srcLengthOpnd = &insn.GetOperand(kInsnThirdOpnd);
+  const std::string patternLengthReg =
+      AArch64CG::intRegNames[AArch64CG::kR64List][static_cast<RegOperand*>(patternLengthOpnd)->GetRegisterNumber()];
+  const std::string srcLengthReg =
+      AArch64CG::intRegNames[AArch64CG::kR64List][static_cast<RegOperand*>(srcLengthOpnd)->GetRegisterNumber()];
+  A64OpndEmitVisitor visitor(emitter, nullptr);
+  /* cmp       w4, w2 */
+  (void)emitter.Emit("\tcmp\t");
+  patternLengthOpnd->Accept(visitor);
+  (void)emitter.Emit(", ");
+  srcLengthOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* the 16th operand of MOP_string_indexof is Label.NOMATCH */
+  Operand *labelNoMatch = &insn.GetOperand(16);
+  /* b.gt      Label.NOMATCH */
+  (void)emitter.Emit("\tb.gt\t");
+  labelNoMatch->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* sub       w2, w2, w4 */
+  (void)emitter.Emit("\tsub\t");
+  srcLengthOpnd->Accept(visitor);
+  (void)emitter.Emit(", ");
+  srcLengthOpnd->Accept(visitor);
+  (void)emitter.Emit(", ");
+  patternLengthOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* sub       w4, w4, #8 */
+  (void)emitter.Emit("\tsub\t");
+  patternLengthOpnd->Accept(visitor);
+  (void)emitter.Emit(", ");
+  patternLengthOpnd->Accept(visitor);
+  (void)emitter.Emit(", #8\n");
+  /* the 10th operand of MOP_string_indexof is w10 */
+  Operand *resultTmp = &insn.GetOperand(10);
+  /* mov       w10, w2 */
+  (void)emitter.Emit("\tmov\t");
+  resultTmp->Accept(visitor);
+  (void)emitter.Emit(", ");
+  srcLengthOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* uxtw      x4, w4 */
+  (void)emitter.Emit("\tuxtw\t").Emit(patternLengthReg);
+  (void)emitter.Emit(", ");
+  patternLengthOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* uxtw      x2, w2 */
+  (void)emitter.Emit("\tuxtw\t").Emit(srcLengthReg);
+  (void)emitter.Emit(", ");
+  srcLengthOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+  Operand *patternStringBaseOpnd = &insn.GetOperand(kInsnFourthOpnd);
+  /* add       x3, x3, x4 */
+  (void)emitter.Emit("\tadd\t");
+  patternStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit(", ");
+  patternStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit(", ").Emit(patternLengthReg);
+  (void)emitter.Emit("\n");
+  Operand *srcStringBaseOpnd = &insn.GetOperand(kInsnSecondOpnd);
+  /* add       x1, x1, x2 */
+  (void)emitter.Emit("\tadd\t");
+  srcStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit(", ");
+  srcStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit(", ").Emit(srcLengthReg);
+  (void)emitter.Emit("\n");
+  /* neg       x4, x4 */
+  (void)emitter.Emit("\tneg\t").Emit(patternLengthReg);
+  (void)emitter.Emit(", ").Emit(patternLengthReg);
+  (void)emitter.Emit("\n");
+  /* neg       x2, x2 */
+  (void)emitter.Emit("\tneg\t").Emit(srcLengthReg);
+  (void)emitter.Emit(", ").Emit(srcLengthReg);
+  (void)emitter.Emit("\n");
+  Operand *first = &insn.GetOperand(kInsnSixthOpnd);
+  /* ldr       x5, [x3,x4] */
+  (void)emitter.Emit("\tldr\t");
+  first->Accept(visitor);
+  (void)emitter.Emit(", [");
+  patternStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit(",").Emit(patternLengthReg);
+  (void)emitter.Emit("]\n");
+  /* the 11th operand of MOP_string_indexof is Label.FIRST_LOOP */
+  Operand *labelFirstLoop = &insn.GetOperand(11);
+  /* .Label.FIRST_LOOP: */
+  labelFirstLoop->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  /* the 7th operand of MOP_string_indexof is x7 */
+  Operand *ch2 = &insn.GetOperand(7);
+  /* ldr       x7, [x1,x2] */
+  (void)emitter.Emit("\tldr\t");
+  ch2->Accept(visitor);
+  (void)emitter.Emit(", [");
+  srcStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit(",").Emit(srcLengthReg);
+  (void)emitter.Emit("]\n");
+  /* cmp       x5, x7 */
+  (void)emitter.Emit("\tcmp\t");
+  first->Accept(visitor);
+  (void)emitter.Emit(", ");
+  ch2->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* the 13th operand of MOP_string_indexof is Label.STR1_LOOP */
+  Operand *labelStr1Loop = &insn.GetOperand(13);
+  /* b.eq      .Label.STR1_LOOP */
+  (void)emitter.Emit("\tb.eq\t");
+  labelStr1Loop->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* the 12th operand of MOP_string_indexof is Label.STR2_NEXT */
+  Operand *labelStr2Next = &insn.GetOperand(12);
+  /* .Label.STR2_NEXT: */
+  labelStr2Next->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  /* adds      x2, x2, #1 */
+  (void)emitter.Emit("\tadds\t").Emit(srcLengthReg);
+  (void)emitter.Emit(", ").Emit(srcLengthReg);
+  (void)emitter.Emit(", #1\n");
+  /* b.le      .Label.FIRST_LOOP */
+  (void)emitter.Emit("\tb.le\t");
+  labelFirstLoop->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* b         .Label.NOMATCH */
+  (void)emitter.Emit("\tb\t");
+  labelNoMatch->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* .Label.STR1_LOOP: */
+  labelStr1Loop->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  /* the 8th operand of MOP_string_indexof is x8 */
+  Operand *tmp1 = &insn.GetOperand(kInsnEighthOpnd);
+  /* adds      x8, x4, #8 */
+  (void)emitter.Emit("\tadds\t");
+  tmp1->Accept(visitor);
+  (void)emitter.Emit(", ").Emit(patternLengthReg);
+  (void)emitter.Emit(", #8\n");
+  /* the 9th operand of MOP_string_indexof is x9 */
+  Operand *tmp2 = &insn.GetOperand(9);
+  /* add       x9, x2, #8 */
+  (void)emitter.Emit("\tadd\t");
+  tmp2->Accept(visitor);
+  (void)emitter.Emit(", ").Emit(srcLengthReg);
+  (void)emitter.Emit(", #8\n");
+  /* the 15th operand of MOP_string_indexof is Label.LAST_WORD */
+  Operand *labelLastWord = &insn.GetOperand(15);
+  /* b.ge      .Label.LAST_WORD */
+  (void)emitter.Emit("\tb.ge\t");
+  labelLastWord->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* the 14th operand of MOP_string_indexof is Label.STR1_NEXT */
+  Operand *labelStr1Next = &insn.GetOperand(14);
+  /* .Label.STR1_NEXT: */
+  labelStr1Next->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  /* the 6th operand of MOP_string_indexof is x6 */
+  Operand *ch1 = &insn.GetOperand(6);
+  /* ldr       x6, [x3,x8] */
+  (void)emitter.Emit("\tldr\t");
+  ch1->Accept(visitor);
+  (void)emitter.Emit(", [");
+  patternStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit(",");
+  tmp1->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  /* ldr       x7, [x1,x9] */
+  (void)emitter.Emit("\tldr\t");
+  ch2->Accept(visitor);
+  (void)emitter.Emit(", [");
+  srcStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit(",");
+  tmp2->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  /* cmp       x6, x7 */
+  (void)emitter.Emit("\tcmp\t");
+  ch1->Accept(visitor);
+  (void)emitter.Emit(", ");
+  ch2->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* b.ne      .Label.STR2_NEXT */
+  (void)emitter.Emit("\tb.ne\t");
+  labelStr2Next->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* adds      x8, x8, #8 */
+  (void)emitter.Emit("\tadds\t");
+  tmp1->Accept(visitor);
+  (void)emitter.Emit(", ");
+  tmp1->Accept(visitor);
+  (void)emitter.Emit(", #8\n");
+  /* add       x9, x9, #8 */
+  (void)emitter.Emit("\tadd\t");
+  tmp2->Accept(visitor);
+  (void)emitter.Emit(", ");
+  tmp2->Accept(visitor);
+  (void)emitter.Emit(", #8\n");
+  /* b.lt      .Label.STR1_NEXT */
+  (void)emitter.Emit("\tb.lt\t");
+  labelStr1Next->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* .Label.LAST_WORD: */
+  labelLastWord->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  /* ldr       x6, [x3] */
+  (void)emitter.Emit("\tldr\t");
+  ch1->Accept(visitor);
+  (void)emitter.Emit(", [");
+  patternStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  /* sub       x9, x1, x4 */
+  (void)emitter.Emit("\tsub\t");
+  tmp2->Accept(visitor);
+  (void)emitter.Emit(", ");
+  srcStringBaseOpnd->Accept(visitor);
+  (void)emitter.Emit(", ").Emit(patternLengthReg);
+  (void)emitter.Emit("\n");
+  /* ldr       x7, [x9,x2] */
+  (void)emitter.Emit("\tldr\t");
+  ch2->Accept(visitor);
+  (void)emitter.Emit(", [");
+  tmp2->Accept(visitor);
+  (void)emitter.Emit(", ").Emit(srcLengthReg);
+  (void)emitter.Emit("]\n");
+  /* cmp       x6, x7 */
+  (void)emitter.Emit("\tcmp\t");
+  ch1->Accept(visitor);
+  (void)emitter.Emit(", ");
+  ch2->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* b.ne      .Label.STR2_NEXT */
+  (void)emitter.Emit("\tb.ne\t");
+  labelStr2Next->Accept(visitor);
+  (void)emitter.Emit("\n");
+  Operand *retVal = &insn.GetOperand(kInsnFirstOpnd);
+  /* add       w0, w10, w2 */
+  (void)emitter.Emit("\tadd\t");
+  retVal->Accept(visitor);
+  (void)emitter.Emit(", ");
+  resultTmp->Accept(visitor);
+  (void)emitter.Emit(", ");
+  srcLengthOpnd->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* the 17th operand of MOP_string_indexof Label.ret */
+  Operand *labelRet = &insn.GetOperand(17);
+  /* b         .Label.ret */
+  (void)emitter.Emit("\tb\t");
+  labelRet->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* .Label.NOMATCH: */
+  labelNoMatch->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  /* mov       w0, #-1 */
+  (void)emitter.Emit("\tmov\t");
+  retVal->Accept(visitor);
+  (void)emitter.Emit(", #-1\n");
+  /* .Label.ret: */
+  labelRet->Accept(visitor);
+  (void)emitter.Emit(":\n");
+}
+
+/*
+ * intrinsic_compare_swap_int x0, xt, xs, x1, x2, w3, w4, lable1, label2
+ * add       xt, x1, x2
+ * label1:
+ * ldaxr     ws, [xt]
+ * cmp       ws, w3
+ * b.ne      label2
+ * stlxr     ws, w4, [xt]
+ * cbnz      ws, label1
+ * label2:
+ * cset      x0, eq
+ */
+void AArch64AsmEmitter::EmitCompareAndSwapInt(Emitter &emitter, const Insn &insn) const {
+  /* MOP_compare_and_swapI and MOP_compare_and_swapL have 8 operands */
+  ASSERT(insn.GetOperandSize() > kInsnEighthOpnd, "ensure the operands number");
+  const MOperator mOp = insn.GetMachineOpcode();
+  const InsnDesc *md = &AArch64CG::kMd[mOp];
+  Operand *temp0 = &insn.GetOperand(kInsnSecondOpnd);
+  Operand *temp1 = &insn.GetOperand(kInsnThirdOpnd);
+  Operand *obj = &insn.GetOperand(kInsnFourthOpnd);
+  Operand *offset = &insn.GetOperand(kInsnFifthOpnd);
+  A64OpndEmitVisitor visitor(emitter, nullptr);
+  /* add       xt, x1, x2 */
+  (void)emitter.Emit("\tadd\t");
+  temp0->Accept(visitor);
+  (void)emitter.Emit(", ");
+  obj->Accept(visitor);
+  (void)emitter.Emit(", ");
+  offset->Accept(visitor);
+  (void)emitter.Emit("\n");
+  Operand *label1 = &insn.GetOperand(kInsnEighthOpnd);
+  /* label1: */
+  label1->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  /* ldaxr     ws, [xt] */
+  (void)emitter.Emit("\tldaxr\t");
+  temp1->Accept(visitor);
+  (void)emitter.Emit(", [");
+  temp0->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  Operand *expectedValue = &insn.GetOperand(kInsnSixthOpnd);
+  const OpndDesc *expectedValueProp = md->opndMD[kInsnSixthOpnd];
+  /* cmp       ws, w3 */
+  (void)emitter.Emit("\tcmp\t");
+  temp1->Accept(visitor);
+  (void)emitter.Emit(", ");
+  A64OpndEmitVisitor visitorExpect(emitter, expectedValueProp);
+  expectedValue->Accept(visitorExpect);
+  (void)emitter.Emit("\n");
+  constexpr uint32 kInsnNinethOpnd = 8;
+  Operand *label2 = &insn.GetOperand(kInsnNinethOpnd);
+  /* b.ne      label2 */
+  (void)emitter.Emit("\tbne\t");
+  label2->Accept(visitor);
+  (void)emitter.Emit("\n");
+  Operand *newValue = &insn.GetOperand(kInsnSeventhOpnd);
+  /* stlxr     ws, w4, [xt] */
+  (void)emitter.Emit("\tstlxr\t");
+  (void)emitter.Emit(AArch64CG::intRegNames[AArch64CG::kR32List][static_cast<RegOperand*>(temp1)->GetRegisterNumber()]);
+  (void)emitter.Emit(", ");
+  newValue->Accept(visitor);
+  (void)emitter.Emit(", [");
+  temp0->Accept(visitor);
+  (void)emitter.Emit("]\n");
+  /* cbnz      ws, label1 */
+  (void)emitter.Emit("\tcbnz\t");
+  (void)emitter.Emit(AArch64CG::intRegNames[AArch64CG::kR32List][static_cast<RegOperand*>(temp1)->GetRegisterNumber()]);
+  (void)emitter.Emit(", ");
+  label1->Accept(visitor);
+  (void)emitter.Emit("\n");
+  /* label2: */
+  label2->Accept(visitor);
+  (void)emitter.Emit(":\n");
+  Operand *retVal = &insn.GetOperand(kInsnFirstOpnd);
+  /* cset      x0, eq */
+  (void)emitter.Emit("\tcset\t");
+  retVal->Accept(visitor);
+  (void)emitter.Emit(", EQ\n");
+}
+
+void AArch64AsmEmitter::EmitCTlsDescRel(Emitter &emitter, const Insn &insn) const {
+  const InsnDesc *md = &AArch64CG::kMd[MOP_tls_desc_rel];
+  Operand *result = &insn.GetOperand(kInsnFirstOpnd);
+  Operand *src = &insn.GetOperand(kInsnSecondOpnd);
+  Operand *symbol = &insn.GetOperand(kInsnThirdOpnd);
+  auto stImmOpnd = static_cast<StImmOperand*>(symbol);
+  std::string symName = stImmOpnd->GetName();
+  symName += stImmOpnd->GetSymbol()->GetStorageClass() == kScPstatic ?
+      std::to_string(emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx()) : "";
+  A64OpndEmitVisitor resultVisitor(emitter, md->opndMD[0]);
+  A64OpndEmitVisitor srcVisitor(emitter, md->opndMD[1]);
+  (void)emitter.Emit("\t").Emit("add").Emit("\t");
+  result->Accept(resultVisitor);
+  (void)emitter.Emit(", ");
+  src->Accept(srcVisitor);
+  (void)emitter.Emit(", #:tprel_hi12:").Emit(symName).Emit(", lsl #12\n");
+  (void)emitter.Emit("\t").Emit("add").Emit("\t");
+  result->Accept(resultVisitor);
+  (void)emitter.Emit(", ");
+  result->Accept(resultVisitor);
+  (void)emitter.Emit(", #:tprel_lo12_nc:").Emit(symName).Emit("\n");
+}
+
+void AArch64AsmEmitter::EmitCTlsDescCall(Emitter &emitter, const Insn &insn) const {
+  const InsnDesc *md = &AArch64CG::kMd[MOP_tls_desc_call];
+  Operand *func = &insn.GetOperand(kInsnSecondOpnd);
+  Operand *symbol = &insn.GetOperand(kInsnThirdOpnd);
+  const OpndDesc *prop = md->opndMD[kInsnSecondOpnd];
+  auto *stImmOpnd = static_cast<StImmOperand*>(symbol);
+  std::string symName = stImmOpnd->GetName();
+  symName += stImmOpnd->GetSymbol()->GetStorageClass() == kScPstatic ?
+      std::to_string(emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx()) : "";
+  A64OpndEmitVisitor funcVisitor(emitter, prop);
+  /*  adrp    x0, :tlsdesc:symbol */
+  (void)emitter.Emit("\t").Emit("adrp\tx0, :tlsdesc:").Emit(symName).Emit("\n");
+  /*  ldr x1, [x0, #tlsdesc_lo12:symbol] */
+  (void)emitter.Emit("\t").Emit("ldr").Emit("\t");
+  func->Accept(funcVisitor);
+  (void)emitter.Emit(", [x0, #:tlsdesc_lo12:").Emit(symName).Emit("]\n");
+  /*  add x0 ,#tlsdesc_lo12:symbol */
+  (void)emitter.Emit("\t").Emit("add\tx0, x0, :tlsdesc_lo12:").Emit(symName).Emit("\n");
+  /* .tlsdesccall <symbolName> */
+  (void)emitter.Emit("\t").Emit(".tlsdesccall").Emit("\t").Emit(symName).Emit("\n");
+  /* blr xd */
+  (void)emitter.Emit("\t").Emit("blr").Emit("\t");
+  func->Accept(funcVisitor);
+  (void)emitter.Emit("\n");
+}
+
+void AArch64AsmEmitter::EmitSyncLockTestSet(Emitter &emitter, const Insn &insn) const {
+  const InsnDesc *md = &AArch64CG::kMd[insn.GetMachineOpcode()];
+  auto *result = &insn.GetOperand(kInsnFirstOpnd);
+  auto *temp = &insn.GetOperand(kInsnSecondOpnd);
+  auto *addr = &insn.GetOperand(kInsnThirdOpnd);
+  auto *value = &insn.GetOperand(kInsnFourthOpnd);
+  auto *label = &insn.GetOperand(kInsnFifthOpnd);
+  A64OpndEmitVisitor resultVisitor(emitter, md->opndMD[kInsnFirstOpnd]);
+  A64OpndEmitVisitor tempVisitor(emitter, md->opndMD[kInsnSecondOpnd]);
+  A64OpndEmitVisitor addrVisitor(emitter, md->opndMD[kInsnThirdOpnd]);
+  A64OpndEmitVisitor valueVisitor(emitter, md->opndMD[kInsnFourthOpnd]);
+  A64OpndEmitVisitor labelVisitor(emitter, md->opndMD[kInsnFifthOpnd]);
+  /* label: */
+  label->Accept(labelVisitor);
+  (void)emitter.Emit(":\n");
+  /* ldxr x0, [x2] */
+  (void)emitter.Emit("\t").Emit("ldxr").Emit("\t");
+  result->Accept(resultVisitor);
+  (void)emitter.Emit(", [");
+  addr->Accept(addrVisitor);
+  (void)emitter.Emit("]\n");
+  /* stxr w1, x3, [x2] */
+  (void)emitter.Emit("\t").Emit("stxr").Emit("\t");
+  temp->Accept(tempVisitor);
+  (void)emitter.Emit(", ");
+  value->Accept(valueVisitor);
+  (void)emitter.Emit(", [");
+  addr->Accept(addrVisitor);
+  (void)emitter.Emit("]\n");
+  /* cbnz w1, label */
+  (void)emitter.Emit("\t").Emit("cbnz").Emit("\t");
+  temp->Accept(tempVisitor);
+  (void)emitter.Emit(", ");
+  label->Accept(labelVisitor);
+  (void)emitter.Emit("\n");
+  /* dmb ish */
+  (void)emitter.Emit("\t").Emit("dmb").Emit("\t").Emit("ish").Emit("\n");
+}
+
+void AArch64AsmEmitter::EmitCheckThrowPendingException(Emitter &emitter) const {
+  /*
+   * mrs x16, TPIDR_EL0
+   * ldr x16, [x16, #64]
+   * ldr x16, [x16, #8]
+   * cbz x16, .lnoexception
+   * bl MCC_ThrowPendingException
+   * .lnoexception:
+   */
+  (void)emitter.Emit("\t").Emit("mrs").Emit("\tx16, TPIDR_EL0");
+  (void)emitter.Emit("\n");
+  (void)emitter.Emit("\t").Emit("ldr").Emit("\tx16, [x16, #64]");
+  (void)emitter.Emit("\n");
+  (void)emitter.Emit("\t").Emit("ldr").Emit("\tx16, [x16, #8]");
+  (void)emitter.Emit("\n");
+  (void)emitter.Emit("\t").Emit("cbz").Emit("\tx16, .lnoeh.").Emit(maplebe::CG::GetCurCGFunc()->GetName());
+  (void)emitter.Emit("\n");
+  (void)emitter.Emit("\t").Emit("bl").Emit("\tMCC_ThrowPendingException");
+  (void)emitter.Emit("\n");
+  (void)emitter.Emit(".lnoeh.").Emit(maplebe::CG::GetCurCGFunc()->GetName()).Emit(":");
+  (void)emitter.Emit("\n");
+}
+
+void AArch64AsmEmitter::EmitLazyBindingRoutine(Emitter &emitter, const Insn &insn) const {
+  /* ldr xzr, [xs] */
+  const InsnDesc *md = &AArch64CG::kMd[MOP_adrp_ldr];
+
+  Operand *opnd0 = &insn.GetOperand(kInsnFirstOpnd);
+  const OpndDesc *prop0 = md->opndMD[0];
+  A64OpndEmitVisitor visitor(emitter, prop0);
+
+  /* emit "ldr  xzr,[xs]" */
+#ifdef USE_32BIT_REF
+  (void)emitter.Emit("\t").Emit("ldr").Emit("\twzr, [");
+#else
+  (void)emitter.Emit("\t").Emit("ldr").Emit("\txzr, [");
+#endif /* USE_32BIT_REF */
+  opnd0->Accept(visitor);
+  (void)emitter.Emit("]");
+  (void)emitter.Emit("\t// Lazy binding\n");
+}
+
+void AArch64AsmEmitter::PrepareVectorOperand(RegOperand *regOpnd, uint32 &compositeOpnds, Insn &insn) const {
+  VectorRegSpec* vecSpec = static_cast<VectorInsn&>(insn).GetAndRemoveRegSpecFromList();
+  compositeOpnds = (vecSpec->compositeOpnds > 0) ? vecSpec->compositeOpnds : compositeOpnds;
+  regOpnd->SetVecLanePosition(vecSpec->vecLane);
+  switch (insn.GetMachineOpcode()) {
+    case MOP_vanduuu:
+    case MOP_vxoruuu:
+    case MOP_voruuu:
+    case MOP_vnotuu:
+    case MOP_vextuuui: {
+      regOpnd->SetVecLaneSize(k8ByteSize);
+      regOpnd->SetVecElementSize(k8BitSize);
+      break;
+    }
+    case MOP_vandvvv:
+    case MOP_vxorvvv:
+    case MOP_vorvvv:
+    case MOP_vnotvv:
+    case MOP_vextvvvi: {
+      regOpnd->SetVecLaneSize(k16ByteSize);
+      regOpnd->SetVecElementSize(k8BitSize);
+      break;
+    }
+    default: {
+      regOpnd->SetVecLaneSize(vecSpec->vecLaneMax);
+      regOpnd->SetVecElementSize(vecSpec->vecElementSize);
+      break;
+    }
+  }
+}
+
+struct CfiDescr {
+  const std::string name;
+  uint32 opndCount;
+  /* create 3 OperandType array to store cfi instruction's operand type */
+  std::array<Operand::OperandType, 3> opndTypes;
+};
+
+static CfiDescr cfiDescrTable[cfi::kOpCfiLast + 1] = {
+#define CFI_DEFINE(k, sub, n, o0, o1, o2) \
+  { ".cfi_" #k, n, { Operand::kOpd##o0, Operand::kOpd##o1, Operand::kOpd##o2 } },
+#define ARM_DIRECTIVES_DEFINE(k, sub, n, o0, o1, o2) \
+  { "." #k, n, { Operand::kOpd##o0, Operand::kOpd##o1, Operand::kOpd##o2 } },
+#include "cfi.def"
+#undef CFI_DEFINE
+#undef ARM_DIRECTIVES_DEFINE
+  { ".cfi_undef", 0, { Operand::kOpdUndef, Operand::kOpdUndef, Operand::kOpdUndef } }
+};
+
+void AArch64AsmEmitter::EmitAArch64CfiInsn(Emitter &emitter, const Insn &insn) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  CfiDescr &cfiDescr = cfiDescrTable[mOp];
+  (void)emitter.Emit("\t").Emit(cfiDescr.name);
+  for (uint32 i = 0; i < cfiDescr.opndCount; ++i) {
+    (void)emitter.Emit(" ");
+    Operand &curOperand = insn.GetOperand(i);
+    cfi::CFIOpndEmitVisitor cfiOpndEmitVisitor(emitter);
+    curOperand.Accept(cfiOpndEmitVisitor);
+    if (i < (cfiDescr.opndCount - 1)) {
+      (void)emitter.Emit(",");
+    }
+  }
+  (void)emitter.Emit("\n");
+}
+
+struct DbgDescr {
+  const std::string name;
+  uint32 opndCount;
+  /* create 3 OperandType array to store dbg instruction's operand type */
+  std::array<Operand::OperandType, 3> opndTypes;
+};
+
+static DbgDescr dbgDescrTable[mpldbg::kOpDbgLast + 1] = {
+#define DBG_DEFINE(k, sub, n, o0, o1, o2) \
+  { #k, n, { Operand::kOpd##o0, Operand::kOpd##o1, Operand::kOpd##o2 } },
+#include "dbg.def"
+#undef DBG_DEFINE
+  { "undef", 0, { Operand::kOpdUndef, Operand::kOpdUndef, Operand::kOpdUndef } }
+};
+
+void AArch64AsmEmitter::EmitAArch64DbgInsn(FuncEmitInfo &funcEmitInfo, Emitter &emitter, const Insn &insn) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  DbgDescr &dbgDescr = dbgDescrTable[mOp];
+  switch (mOp) {
+    case mpldbg::OP_DBG_scope: {
+      unsigned scopeId = static_cast<unsigned>(static_cast<ImmOperand&>(insn.GetOperand(0)).GetValue());
+      (void)emitter.Emit(".LScp." + std::to_string(scopeId));
+      unsigned val = static_cast<unsigned>(static_cast<ImmOperand&>(insn.GetOperand(1)).GetValue());
+      (void)emitter.Emit((val == 0) ? "B:" : "E:");
+
+      CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+      MIRFunction &mirFunc = cgFunc.GetFunction();
+      EmitStatus status = (val == 0) ? kBeginEmited : kEndEmited;
+      cgFunc.GetCG()->GetMIRModule()->GetDbgInfo()->SetFuncScopeIdStatus(&mirFunc, scopeId, status);
+      break;
+    }
+    default: {
+      (void)emitter.Emit("\t.").Emit(dbgDescr.name);
+      for (uint32 i = 0; i < dbgDescr.opndCount; ++i) {
+        (void)emitter.Emit(" ");
+        Operand &curOperand = insn.GetOperand(i);
+        mpldbg::DBGOpndEmitVisitor dbgOpndEmitVisitor(emitter);
+    curOperand.Accept(dbgOpndEmitVisitor);
+      }
+      break;
+    }
+  }
+  (void)emitter.Emit("\n");
+}
+
+bool AArch64AsmEmitter::CheckInsnRefField(const Insn &insn, size_t opndIndex) const {
+  if (insn.IsAccessRefField() && insn.AccessMem()) {
+    Operand &opnd0 = insn.GetOperand(opndIndex);
+    if (opnd0.IsRegister()) {
+      static_cast<RegOperand&>(opnd0).SetRefField(true);
+      return true;
+    }
+  }
+  return false;
+}
+
+/* new phase manager */
+bool CgEmission::PhaseRun(maplebe::CGFunc &f) {
+  Emitter *emitter = f.GetCG()->GetEmitter();
+  CHECK_NULL_FATAL(emitter);
+  AsmFuncEmitInfo funcEmitInfo(f);
+  emitter->EmitLocalVariable(f);
+  static_cast<AArch64AsmEmitter*>(emitter)->Run(funcEmitInfo);
+  emitter->EmitHugeSoRoutines();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgEmission, cgemit)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_fixshortbranch.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_fixshortbranch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5264d2801a999620ccb93e7651b306a0f5e24476
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_fixshortbranch.cpp
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_fixshortbranch.h"
+#include "cg.h"
+#include "mpl_logging.h"
+#include "common_utils.h"
+
+namespace maplebe {
+uint32 AArch64FixShortBranch::CalculateAlignRange(const BB &bb, uint32 addr) const {
+  if (addr == 0) {
+    return addr;
+  }
+  uint32 alignPower = bb.GetAlignPower();
+  /*
+   * The algorithm can avoid the problem that alignment causes conditional branch out of range in two stages.
+   * 1. asm:  .mpl -> .s
+   *          The pseudo-instruction [.p2align 5] is 12B.
+   *          kAlignPseudoSize = 12 / 4 = 3
+   * 2. link: .s -> .o
+   *          The pseudo-instruction will be expanded to nop.
+   *      eg. .p2align 5
+   *          alignPower = 5, alignValue = 2^5 = 32
+   *          range = (32 - ((addr - 1) * 4) % 32) / 4 - 1
+   *
+   * =======> max[range, kAlignPseudoSize]
+   */
+  uint32 range = ((1U << alignPower) - (((addr - 1) * kInsnSize) & ((1U << alignPower) - 1))) / kInsnSize - 1;
+  return range > kAlignPseudoSize ? range : kAlignPseudoSize;
+}
+
+void AArch64FixShortBranch::SetInsnId() const {
+  uint32 i = 0;
+  AArch64CGFunc *aarch64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  FOR_ALL_BB(bb, aarch64CGFunc) {
+    if (aarch64CGFunc->GetMirModule().IsCModule() && bb->IsBBNeedAlign() && bb->GetAlignNopNum() != 0) {
+      i = i + CalculateAlignRange(*bb, i);
+    }
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      i += insn->GetAtomicNum();
+      insn->SetId(i);
+      if (insn->GetMachineOpcode() == MOP_adrp_ldr && CGOptions::IsLazyBinding() && !cgFunc->GetCG()->IsLibcore()) {
+        /* For 1 additional EmitLazyBindingRoutine in lazybinding
+         * see function AArch64Insn::Emit in file aarch64_insn.cpp
+         */
+        ++i;
+      }
+    }
+  }
+}
+
+/*
+ * TBZ/TBNZ instruction is generated under -O2, these branch instructions only have a range of +/-32KB.
+ * If the branch target is not reachable, we split tbz/tbnz into combination of ubfx and cbz/cbnz, which
+ * will clobber one extra register. With LSRA under -O2, we can use one of the reserved registers R16 for
+ * that purpose. To save compile time, we do this change when there are more than 32KB / 4 instructions
+ * in the function.
+ */
+void AArch64FixShortBranch::FixShortBranches() const {
+  AArch64CGFunc *aarch64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  bool change = false;
+  do {
+    change = false;
+    SetInsnId();
+    for (auto *bb = aarch64CGFunc->GetFirstBB(); bb != nullptr && !change; bb = bb->GetNext()) {
+      /* Do a backward scan searching for short branches */
+      for (auto *insn = bb->GetLastInsn(); insn != nullptr && !change; insn = insn->GetPrev()) {
+        if (!insn->IsMachineInstruction()) {
+          continue;
+        }
+        MOperator thisMop = insn->GetMachineOpcode();
+        if (thisMop != MOP_wtbz && thisMop != MOP_wtbnz && thisMop != MOP_xtbz && thisMop != MOP_xtbnz) {
+          continue;
+        }
+        LabelOperand &label = static_cast<LabelOperand&>(insn->GetOperand(kInsnThirdOpnd));
+        /*  should not be commented out after bug fix */
+        if (aarch64CGFunc->DistanceCheck(*bb, label.GetLabelIndex(), insn->GetId())) {
+          continue;
+        }
+        auto &reg = static_cast<RegOperand&>(insn->GetOperand(kInsnFirstOpnd));
+        ImmOperand &bitSize = aarch64CGFunc->CreateImmOperand(1, k8BitSize, false);
+        auto &bitPos = static_cast<ImmOperand&>(insn->GetOperand(kInsnSecondOpnd));
+        MOperator ubfxOp = MOP_undef;
+        MOperator cbOp = MOP_undef;
+        switch (thisMop) {
+          case MOP_wtbz:
+            ubfxOp = MOP_wubfxrri5i5;
+            cbOp = MOP_wcbz;
+            break;
+          case MOP_wtbnz:
+            ubfxOp = MOP_wubfxrri5i5;
+            cbOp = MOP_wcbnz;
+            break;
+          case MOP_xtbz:
+            ubfxOp = MOP_xubfxrri6i6;
+            cbOp = MOP_xcbz;
+            break;
+          case MOP_xtbnz:
+            ubfxOp = MOP_xubfxrri6i6;
+            cbOp = MOP_xcbnz;
+            break;
+          default:
+            break;
+        }
+        RegOperand &tmp = aarch64CGFunc->GetOrCreatePhysicalRegisterOperand(
+            R16, (ubfxOp == MOP_wubfxrri5i5) ? k32BitSize : k64BitSize, kRegTyInt);
+        (void)bb->InsertInsnAfter(*insn, cgFunc->GetInsnBuilder()->BuildInsn(cbOp, tmp, label));
+        (void)bb->InsertInsnAfter(*insn, cgFunc->GetInsnBuilder()->BuildInsn(ubfxOp, tmp, reg, bitPos, bitSize));
+        bb->RemoveInsn(*insn);
+        change = true;
+      }
+    }
+  } while (change);
+}
+
+bool CgFixShortBranch::PhaseRun(maplebe::CGFunc &func) {
+  auto *fixShortBranch = GetPhaseAllocator()->New<AArch64FixShortBranch>(&func);
+  CHECK_FATAL(fixShortBranch != nullptr, "AArch64FixShortBranch instance create failure");
+  fixShortBranch->FixShortBranches();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgFixShortBranch, fixshortbranch)
+}  /* namespace maplebe */
+
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_global.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_global.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d4d2cd5bb5a474f9a47e362878b7071885ee5d3d
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_global.cpp
@@ -0,0 +1,2434 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_global.h"
+#include "aarch64_reaching.h"
+#include "aarch64_cg.h"
+#include "aarch64_live.h"
+
+namespace maplebe {
+using namespace maple;
+#define GLOBAL_DUMP CG_DEBUG_FUNC(cgFunc)
+
+constexpr uint32 kExMOpTypeSize = 9;
+constexpr uint32 kLsMOpTypeSize = 15;
+
+MOperator exMOpTable[kExMOpTypeSize] = {
+    MOP_undef, MOP_xxwaddrrre, MOP_wwwaddrrre, MOP_xxwsubrrre, MOP_wwwsubrrre,
+    MOP_xwcmnrre, MOP_wwcmnrre, MOP_xwcmprre, MOP_wwcmprre
+};
+MOperator lsMOpTable[kLsMOpTypeSize] = {
+    MOP_undef, MOP_xaddrrrs, MOP_waddrrrs, MOP_xsubrrrs, MOP_wsubrrrs,
+    MOP_xcmnrrs, MOP_wcmnrrs, MOP_xcmprrs, MOP_wcmprrs, MOP_xeorrrrs,
+    MOP_weorrrrs, MOP_xinegrrs, MOP_winegrrs, MOP_xiorrrrs, MOP_wiorrrrs
+};
+
+/* Optimize ExtendShiftOptPattern:
+ * ==========================================================
+ *           nosuffix  LSL   LSR   ASR      extrn   (def)
+ * nosuffix |   F    | LSL | LSR | ASR |    extrn  |
+ * LSL      |   F    | LSL |  F  |  F  |    extrn  |
+ * LSR      |   F    |  F  | LSR |  F  |     F     |
+ * ASR      |   F    |  F  |  F  | ASR |     F     |
+ * exten    |   F    |  F  |  F  |  F  |exten(self)|
+ * (use)
+ * ===========================================================
+ */
+
+static bool IsZeroRegister(const Operand &opnd) {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  const RegOperand *regOpnd = static_cast<const RegOperand*>(&opnd);
+  return regOpnd->GetRegisterNumber() == RZR;
+}
+
+void AArch64GlobalOpt::Run() {
+  OptimizeManager optManager(cgFunc);
+  bool hasSpillBarrier = (cgFunc.NumBBs() > kMaxBBNum) || (cgFunc.GetRD()->GetMaxInsnNO() > kMaxInsnNum);
+  if (cgFunc.IsAfterRegAlloc()) {
+    optManager.Optimize<SameRHSPropPattern>();
+    optManager.Optimize<BackPropPattern>();
+    optManager.Optimize<ContinuousLdrPattern>();
+    return;
+  }
+  if (!hasSpillBarrier) {
+    optManager.Optimize<ExtenToMovPattern>();
+    optManager.Optimize<SameRHSPropPattern>();
+    optManager.Optimize<BackPropPattern>();
+    optManager.Optimize<ForwardPropPattern>();
+    optManager.Optimize<CselPattern>();
+    optManager.Optimize<CmpCsetPattern>();
+    optManager.Optimize<RedundantUxtPattern>();
+    optManager.Optimize<LocalVarSaveInsnPattern>();
+  }
+  optManager.Optimize<SameDefPattern>();
+  optManager.Optimize<ExtendShiftOptPattern>();
+  optManager.Optimize<AndCbzPattern>();
+}
+
+/* if used Operand in insn is defined by zero in all define insn, return true */
+bool OptimizePattern::OpndDefByZero(Insn &insn, int32 useIdx) const {
+  ASSERT(insn.GetOperand(useIdx).IsRegister(), "the used Operand must be Register");
+  /* Zero Register don't need be defined */
+  if (IsZeroRegister(insn.GetOperand(static_cast<uint32>(useIdx)))) {
+    return true;
+  }
+
+  InsnSet defInsns = cgFunc.GetRD()->FindDefForRegOpnd(insn, useIdx);
+  if (defInsns.empty()) {
+    return false;
+  }
+  for (auto &defInsn : defInsns) {
+    if (!InsnDefZero(*defInsn)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/* if used Operand in insn is defined by one in all define insn, return true */
+bool OptimizePattern::OpndDefByOne(Insn &insn, int32 useIdx) const {
+  ASSERT(insn.GetOperand(useIdx).IsRegister(), "the used Operand must be Register");
+  /* Zero Register don't need be defined */
+  if (IsZeroRegister(insn.GetOperand(static_cast<uint32>(useIdx)))) {
+    return false;
+  }
+  InsnSet defInsns = cgFunc.GetRD()->FindDefForRegOpnd(insn, useIdx);
+  if (defInsns.empty()) {
+    return false;
+  }
+  for (auto &defInsn : defInsns) {
+    if (!InsnDefOne(*defInsn)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+  /* if used Operand in insn is defined by one valid bit in all define insn, return true */
+bool OptimizePattern::OpndDefByOneOrZero(Insn &insn, int32 useIdx) const {
+  if (IsZeroRegister(insn.GetOperand(static_cast<uint32>(useIdx)))) {
+    return true;
+  }
+
+  InsnSet defInsnSet = cgFunc.GetRD()->FindDefForRegOpnd(insn, useIdx);
+  if (defInsnSet.empty()) {
+    return false;
+  }
+
+  for (auto &defInsn : defInsnSet) {
+    if (!InsnDefOneOrZero(*defInsn)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/* if defined operand(must be first insn currently) in insn is const one, return true */
+bool OptimizePattern::InsnDefOne(const Insn &insn) {
+  MOperator defMop = insn.GetMachineOpcode();
+  switch (defMop) {
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      Operand &srcOpnd = insn.GetOperand(1);
+      ASSERT(srcOpnd.IsIntImmediate(), "expects ImmOperand");
+      ImmOperand &srcConst = static_cast<ImmOperand&>(srcOpnd);
+      int64 srcConstValue = srcConst.GetValue();
+      if (srcConstValue == 1) {
+        return true;
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+
+/* if defined operand(must be first insn currently) in insn is const zero, return true */
+bool OptimizePattern::InsnDefZero(const Insn &insn) {
+  MOperator defMop = insn.GetMachineOpcode();
+  switch (defMop) {
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      Operand &srcOpnd = insn.GetOperand(kInsnSecondOpnd);
+      ASSERT(srcOpnd.IsIntImmediate(), "expects ImmOperand");
+      ImmOperand &srcConst = static_cast<ImmOperand&>(srcOpnd);
+      int64 srcConstValue = srcConst.GetValue();
+      if (srcConstValue == 0) {
+        return true;
+      }
+      return false;
+    }
+    case MOP_xmovrr:
+    case MOP_wmovrr:
+      return IsZeroRegister(insn.GetOperand(kInsnSecondOpnd));
+    default:
+      return false;
+  }
+}
+
+/* if defined operand(must be first insn currently) in insn has only one valid bit, return true */
+bool OptimizePattern::InsnDefOneOrZero(const Insn &insn) {
+  MOperator defMop = insn.GetMachineOpcode();
+  switch (defMop) {
+    case MOP_wcsetrc:
+    case MOP_xcsetrc:
+      return true;
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      Operand &defOpnd = insn.GetOperand(kInsnSecondOpnd);
+      ASSERT(defOpnd.IsIntImmediate(), "expects ImmOperand");
+      auto &defConst = static_cast<ImmOperand&>(defOpnd);
+      int64 defConstValue = defConst.GetValue();
+      if (defConstValue != 0 && defConstValue != 1) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+    case MOP_xmovrr:
+    case MOP_wmovrr: {
+      return IsZeroRegister(insn.GetOperand(kInsnSecondOpnd));
+    }
+    case MOP_wlsrrri5:
+    case MOP_xlsrrri6: {
+      Operand &opnd2 = insn.GetOperand(kInsnThirdOpnd);
+      ASSERT(opnd2.IsIntImmediate(), "expects ImmOperand");
+      ImmOperand &opndImm = static_cast<ImmOperand&>(opnd2);
+      int64 shiftBits = opndImm.GetValue();
+      if (((defMop == MOP_wlsrrri5) && (shiftBits == k32BitSize - 1)) ||
+          ((defMop == MOP_xlsrrri6) && (shiftBits == k64BitSize - 1))) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+    default:
+      return false;
+  }
+}
+
+void ReplaceAsmListReg(const Insn *insn, uint32 index, uint32 regNO, Operand *newOpnd) {
+  MapleList<RegOperand*> *list = &static_cast<ListOperand&>(insn->GetOperand(index)).GetOperands();
+  int32 size = static_cast<int32>(list->size());
+  for (int i = 0; i < size; ++i) {
+    RegOperand *opnd = static_cast<RegOperand *>(*(list->begin()));
+    list->pop_front();
+    if (opnd->GetRegisterNumber() == regNO) {
+      list->push_back(static_cast<RegOperand *>(newOpnd));
+    } else {
+      list->push_back(opnd);
+    }
+  }
+}
+
+void OptimizePattern::ReplaceAllUsedOpndWithNewOpnd(const InsnSet &useInsnSet, uint32 regNO,
+                                                    Operand &newOpnd, bool updateInfo) const {
+  for (auto useInsn : useInsnSet) {
+    if (useInsn->GetMachineOpcode() == MOP_asm) {
+      ReplaceAsmListReg(useInsn, kAsmInputListOpnd, regNO, &newOpnd);
+    }
+    const InsnDesc *md = useInsn->GetDesc();
+    uint32 opndNum = useInsn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = useInsn->GetOperand(i);
+      auto *regProp = md->opndMD[i];
+      if (!regProp->IsRegUse() && !opnd.IsMemoryAccessOperand()) {
+        continue;
+      }
+
+      if (opnd.IsRegister() && (static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO)) {
+        useInsn->SetOperand(i, newOpnd);
+        if (updateInfo) {
+          cgFunc.GetRD()->InitGenUse(*useInsn->GetBB(), false);
+        }
+      } else if (opnd.IsMemoryAccessOperand()) {
+        MemOperand &memOpnd = static_cast<MemOperand&>(opnd);
+        RegOperand *base = memOpnd.GetBaseRegister();
+        RegOperand *index = memOpnd.GetIndexRegister();
+        MemOperand *newMem = nullptr;
+        if (base != nullptr && (base->GetRegisterNumber() == regNO)) {
+          newMem = static_cast<MemOperand*>(opnd.Clone(*cgFunc.GetMemoryPool()));
+          CHECK_FATAL(newMem != nullptr, "null ptr check");
+          newMem->SetBaseRegister(*static_cast<RegOperand*>(&newOpnd));
+          useInsn->SetOperand(i, *newMem);
+          if (updateInfo) {
+            cgFunc.GetRD()->InitGenUse(*useInsn->GetBB(), false);
+          }
+        }
+        if (index != nullptr && (index->GetRegisterNumber() == regNO)) {
+          newMem = static_cast<MemOperand*>(opnd.Clone(*cgFunc.GetMemoryPool()));
+          CHECK_FATAL(newMem != nullptr, "null ptr check");
+          newMem->SetIndexRegister(*static_cast<RegOperand*>(&newOpnd));
+          if (static_cast<RegOperand&>(newOpnd).GetValidBitsNum() != index->GetValidBitsNum()) {
+            newMem->UpdateExtend(MemOperand::kSignExtend);
+          }
+          useInsn->SetOperand(i, *newMem);
+          if (updateInfo) {
+            cgFunc.GetRD()->InitGenUse(*useInsn->GetBB(), false);
+          }
+        }
+      }
+    }
+  }
+}
+
+bool ForwardPropPattern::IsUseInsnSetValid(Insn &insn, regno_t firstRegNO, regno_t secondRegNO) {
+  bool toDoOpt = true;
+  for (auto useInsn : firstRegUseInsnSet) {
+    if (!cgFunc.GetRD()->RegIsLiveBetweenInsn(secondRegNO, insn, *useInsn)) {
+      toDoOpt = false;
+      break;
+    }
+    /* part defined */
+    if ((useInsn->GetMachineOpcode() == MOP_xmovkri16) || (useInsn->GetMachineOpcode() == MOP_wmovkri16) ||
+        (useInsn->GetMachineOpcode() == MOP_wbfirri5i5) || (useInsn->GetMachineOpcode() == MOP_xbfirri6i6)) {
+      toDoOpt = false;
+      break;
+    }
+    if (useInsn->GetMachineOpcode() == MOP_asm) {
+      toDoOpt = false;
+      break;
+    }
+    InsnSet defInsnSet = cgFunc.GetRD()->FindDefForRegOpnd(*useInsn, firstRegNO, true);
+    if (defInsnSet.size() > 1) {
+      toDoOpt = false;
+      break;
+    } else if (defInsnSet.size() == 1 && *defInsnSet.begin() != &insn) {
+      toDoOpt = false;
+      break;
+    }
+  }
+  return toDoOpt;
+}
+
+bool ForwardPropPattern::CheckCondition(Insn &insn) {
+  if (!insn.IsMachineInstruction()) {
+    return false;
+  }
+  if ((insn.GetMachineOpcode() != MOP_xmovrr) && (insn.GetMachineOpcode() != MOP_wmovrr) &&
+      (insn.GetMachineOpcode() != MOP_xmovrr_uxtw)) {
+    return false;
+  }
+  Operand &firstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  Operand &secondOpnd = insn.GetOperand(kInsnSecondOpnd);
+  if (firstOpnd.GetSize() != secondOpnd.GetSize() && insn.GetMachineOpcode() != MOP_xmovrr_uxtw) {
+    return false;
+  }
+  auto &firstRegOpnd = static_cast<RegOperand&>(firstOpnd);
+  auto &secondRegOpnd = static_cast<RegOperand&>(secondOpnd);
+  uint32 firstRegNO = firstRegOpnd.GetRegisterNumber();
+  uint32 secondRegNO = secondRegOpnd.GetRegisterNumber();
+  if (IsZeroRegister(firstRegOpnd) || !firstRegOpnd.IsVirtualRegister() || !secondRegOpnd.IsVirtualRegister()) {
+    return false;
+  }
+  firstRegUseInsnSet = cgFunc.GetRD()->FindUseForRegOpnd(insn, firstRegNO, true);
+  if (firstRegUseInsnSet.empty()) {
+    return false;
+  }
+  InsnSet secondRegDefInsnSet = cgFunc.GetRD()->FindDefForRegOpnd(insn, secondRegNO, true);
+  if (secondRegDefInsnSet.size() != 1 || RegOperand::IsSameReg(firstOpnd, secondOpnd)) {
+    return false;
+  }
+  return IsUseInsnSetValid(insn, firstRegNO, secondRegNO);
+}
+
+void ForwardPropPattern::Optimize(Insn &insn) {
+  Operand &firstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  Operand &secondOpnd = insn.GetOperand(kInsnSecondOpnd);
+  RegOperand &firstRegOpnd = static_cast<RegOperand&>(firstOpnd);
+  uint32 firstRegNO = firstRegOpnd.GetRegisterNumber();
+  for (auto *useInsn : firstRegUseInsnSet) {
+    if (useInsn->GetMachineOpcode() == MOP_asm) {
+      ReplaceAsmListReg(useInsn, kAsmInputListOpnd, firstRegNO, &secondOpnd);
+      cgFunc.GetRD()->InitGenUse(*useInsn->GetBB(), false);
+      continue;
+    }
+    const InsnDesc *md = useInsn->GetDesc();
+    uint32 opndNum = useInsn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = useInsn->GetOperand(i);
+      const OpndDesc *regProp = md->GetOpndDes(i);
+      if (!regProp->IsRegUse() && !opnd.IsMemoryAccessOperand()) {
+        continue;
+      }
+
+      if (opnd.IsRegister() && (static_cast<RegOperand&>(opnd).GetRegisterNumber() == firstRegNO)) {
+        useInsn->SetOperand(i, secondOpnd);
+        if (((useInsn->GetMachineOpcode() == MOP_xmovrr) || (useInsn->GetMachineOpcode() == MOP_wmovrr)) &&
+            (static_cast<RegOperand&>(useInsn->GetOperand(kInsnSecondOpnd)).IsVirtualRegister()) &&
+            (static_cast<RegOperand&>(useInsn->GetOperand(kInsnFirstOpnd)).IsVirtualRegister())) {
+          (void)modifiedBB.insert(useInsn->GetBB());
+        }
+        cgFunc.GetRD()->InitGenUse(*useInsn->GetBB(), false);
+      } else if (opnd.IsMemoryAccessOperand()) {
+        MemOperand &memOpnd = static_cast<MemOperand&>(opnd);
+        RegOperand *base = memOpnd.GetBaseRegister();
+        RegOperand *index = memOpnd.GetIndexRegister();
+        MemOperand *newMem = nullptr;
+        if (base != nullptr && (base->GetRegisterNumber() == firstRegNO)) {
+          newMem = static_cast<MemOperand*>(opnd.Clone(*cgFunc.GetMemoryPool()));
+          CHECK_FATAL(newMem != nullptr, "null ptr check");
+          newMem->SetBaseRegister(static_cast<RegOperand&>(secondOpnd));
+          useInsn->SetOperand(i, *newMem);
+          cgFunc.GetRD()->InitGenUse(*useInsn->GetBB(), false);
+        }
+        if ((index != nullptr) && (index->GetRegisterNumber() == firstRegNO)) {
+          newMem = static_cast<MemOperand*>(opnd.Clone(*cgFunc.GetMemoryPool()));
+          CHECK_FATAL(newMem != nullptr, "null ptr check");
+          newMem->SetIndexRegister(static_cast<RegOperand&>(secondOpnd));
+          if (static_cast<RegOperand&>(secondOpnd).GetValidBitsNum() != index->GetValidBitsNum()) {
+            newMem->UpdateExtend(MemOperand::kSignExtend);
+          }
+          useInsn->SetOperand(i, *newMem);
+          cgFunc.GetRD()->InitGenUse(*useInsn->GetBB(), false);
+        }
+      }
+    }
+  }
+  insn.SetOperand(0, secondOpnd);
+  cgFunc.GetRD()->UpdateInOut(*insn.GetBB(), true);
+}
+
+void ForwardPropPattern::RemoveMopUxtwToMov(Insn &insn) {
+  if (CGOptions::DoCGSSA()) {
+    CHECK_FATAL(false, "check case in ssa");
+  }
+  auto &secondOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  auto &destOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  uint32 destRegNo = destOpnd.GetRegisterNumber();
+  destOpnd.SetRegisterNumber(secondOpnd.GetRegisterNumber());
+  auto *newOpnd = static_cast<RegOperand*>(destOpnd.Clone(*cgFunc.GetMemoryPool()));
+  cgFunc.InsertExtendSet(secondOpnd.GetRegisterNumber());
+  InsnSet regUseInsnSet = cgFunc.GetRD()->FindUseForRegOpnd(insn, destRegNo, true);
+  if (regUseInsnSet.size() >= 1) {
+    for (auto useInsn : regUseInsnSet) {
+      uint32 optSize = useInsn->GetOperandSize();
+      for (uint32 i = 0; i < optSize; i++) {
+        ASSERT(useInsn->GetOperand(i).IsRegister(), "only design for register");
+        if (destRegNo == static_cast<RegOperand&>(useInsn->GetOperand(i)).GetRegisterNumber()) {
+          useInsn->SetOperand(i, *newOpnd);
+        }
+      }
+      cgFunc.GetRD()->InitGenUse(*useInsn->GetBB(), false);
+    }
+  }
+  insn.GetBB()->RemoveInsn(insn);
+}
+
+void ForwardPropPattern::Init() {
+  firstRegUseInsnSet.clear();
+}
+
+void ForwardPropPattern::Run() {
+  bool secondTime = false;
+  do {
+    FOR_ALL_BB(bb, &cgFunc) {
+      if (bb->IsUnreachable() || (secondTime && modifiedBB.find(bb) == modifiedBB.end())) {
+        continue;
+      }
+
+      if (secondTime) {
+        modifiedBB.erase(bb);
+      }
+
+      FOR_BB_INSNS(insn, bb) {
+        Init();
+        if (!CheckCondition(*insn)) {
+          if (insn->GetMachineOpcode() == MOP_xmovrr_uxtw) {
+            insn->SetMOP(AArch64CG::kMd[MOP_xuxtw64]);
+          }
+          continue;
+        }
+        if (insn->GetMachineOpcode() == MOP_xmovrr_uxtw) {
+          RemoveMopUxtwToMov(*insn);
+          continue;
+        }
+        Optimize(*insn);
+      }
+    }
+    secondTime = true;
+  } while (!modifiedBB.empty());
+}
+
+bool BackPropPattern::CheckAndGetOpnd(const Insn &insn) {
+  if (!insn.IsMachineInstruction()) {
+    return false;
+  }
+  if (!cgFunc.IsAfterRegAlloc() && (insn.GetMachineOpcode() != MOP_xmovrr) && (insn.GetMachineOpcode() != MOP_wmovrr)) {
+    return false;
+  }
+  if (cgFunc.IsAfterRegAlloc() &&
+    (insn.GetMachineOpcode() != MOP_xmovrr) && (insn.GetMachineOpcode() != MOP_wmovrr) &&
+    (insn.GetMachineOpcode() != MOP_xvmovs) && (insn.GetMachineOpcode() != MOP_xvmovd)) {
+    return false;
+  }
+  Operand &firstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  Operand &secondOpnd = insn.GetOperand(kInsnSecondOpnd);
+  if (RegOperand::IsSameReg(firstOpnd, secondOpnd)) {
+    return false;
+  }
+  if (firstOpnd.GetSize() != secondOpnd.GetSize()) {
+    return false;
+  }
+  firstRegOpnd = &static_cast<RegOperand&>(firstOpnd);
+  secondRegOpnd = &static_cast<RegOperand&>(secondOpnd);
+  if (IsZeroRegister(*firstRegOpnd)) {
+    return false;
+  }
+  if (!cgFunc.IsAfterRegAlloc() && (!secondRegOpnd->IsVirtualRegister() || !firstRegOpnd->IsVirtualRegister())) {
+    return false;
+  }
+  firstRegNO = firstRegOpnd->GetRegisterNumber();
+  secondRegNO = secondRegOpnd->GetRegisterNumber();
+  return true;
+}
+
+bool BackPropPattern::DestOpndHasUseInsns(Insn &insn) {
+  BB &bb = *insn.GetBB();
+  InsnSet useInsnSetOfFirstOpnd;
+  bool findRes = cgFunc.GetRD()->FindRegUseBetweenInsn(firstRegNO, insn.GetNext(),
+                                                       bb.GetLastInsn(), useInsnSetOfFirstOpnd);
+  if ((findRes && useInsnSetOfFirstOpnd.empty()) ||
+      (!findRes && useInsnSetOfFirstOpnd.empty() && !bb.GetLiveOut()->TestBit(firstRegNO))) {
+    return false;
+  }
+  return true;
+}
+
+bool BackPropPattern::DestOpndLiveOutToEHSuccs(Insn &insn) const {
+  BB &bb = *insn.GetBB();
+  for (auto ehSucc : bb.GetEhSuccs()) {
+    if (ehSucc->GetLiveIn()->TestBit(firstRegNO)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool BackPropPattern::CheckSrcOpndDefAndUseInsns(Insn &insn) {
+  BB &bb = *insn.GetBB();
+  /* secondOpnd is defined in other BB */
+  std::vector<Insn*> defInsnVec = cgFunc.GetRD()->FindRegDefBetweenInsn(secondRegNO, bb.GetFirstInsn(), insn.GetPrev());
+  if (defInsnVec.size() != 1) {
+    return false;
+  }
+  defInsnForSecondOpnd = defInsnVec.back();
+  /* don't prop sp to load/store */
+  if ((defInsnForSecondOpnd->IsLoad() || defInsnForSecondOpnd->IsStore() || defInsnForSecondOpnd->IsLoadStorePair()) &&
+      firstRegNO == RSP && cgFunc.IsAfterRegAlloc()) {
+    return false;
+  }
+  /* part defined */
+  if ((defInsnForSecondOpnd->GetMachineOpcode() == MOP_xmovkri16) ||
+      (defInsnForSecondOpnd->GetMachineOpcode() == MOP_wmovkri16) ||
+      (defInsnForSecondOpnd->GetBothDefUseOpnd() != kInsnMaxOpnd) ||
+      (defInsnForSecondOpnd->GetMachineOpcode() == MOP_asm)) {
+    return false;
+  }
+  if (AArch64isa::IsPseudoInstruction(defInsnForSecondOpnd->GetMachineOpcode()) || defInsnForSecondOpnd->IsCall() ||
+      defInsnForSecondOpnd->IsTailCall()) {
+    return false;
+  }
+  /* unconcerned regs. */
+  if ((secondRegNO >= RLR && secondRegNO <= RZR) || secondRegNO == RFP) {
+    return false;
+  }
+  if (defInsnForSecondOpnd->IsStore() || defInsnForSecondOpnd->IsLoad()) {
+    auto *memOpnd = static_cast<MemOperand*>(defInsnForSecondOpnd->GetMemOpnd());
+    if (memOpnd != nullptr && !memOpnd->IsIntactIndexed()) {
+      return false;
+    }
+  }
+
+  bool findFinish = cgFunc.GetRD()->FindRegUseBetweenInsn(secondRegNO, defInsnForSecondOpnd->GetNext(),
+                                                          bb.GetLastInsn(), srcOpndUseInsnSet);
+  if (!findFinish && bb.GetLiveOut()->TestBit(secondRegNO)) {
+    return false;
+  }
+  if (cgFunc.IsAfterRegAlloc() && findFinish && srcOpndUseInsnSet.size() > 1) {
+    /* use later before killed. */
+    return false;
+  }
+  if (cgFunc.IsAfterRegAlloc()) {
+    for (auto *usePoint : srcOpndUseInsnSet) {
+      if (usePoint->IsCall() || usePoint->IsTailCall()) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool BackPropPattern::CheckSrcOpndDefAndUseInsnsGlobal(Insn &insn) {
+  /* secondOpnd is defined in other BB */
+  InsnSet defInsnVec = cgFunc.GetRD()->FindDefForRegOpnd(insn, secondRegNO, true);
+  if (defInsnVec.size() != 1) {
+    return false;
+  }
+  defInsnForSecondOpnd = *(defInsnVec.begin());
+  /* don't prop sp to load/store */
+  if ((defInsnForSecondOpnd->IsLoad() || defInsnForSecondOpnd->IsStore() || defInsnForSecondOpnd->IsLoadStorePair()) &&
+      firstRegNO == RSP && cgFunc.IsAfterRegAlloc()) {
+    return false;
+  }
+
+  /* ensure that there is no fisrt RegNO def/use between insn and defInsnForSecondOpnd */
+  std::vector<Insn*> defInsnVecFirst;
+
+  if (insn.GetBB() != defInsnForSecondOpnd->GetBB()) {
+    defInsnVecFirst = cgFunc.GetRD()->FindRegDefBetweenInsnGlobal(firstRegNO, defInsnForSecondOpnd, &insn);
+  } else {
+    defInsnVecFirst = cgFunc.GetRD()->FindRegDefBetweenInsn(firstRegNO, defInsnForSecondOpnd, insn.GetPrev());
+  }
+  if (!defInsnVecFirst.empty()) {
+    return false;
+  }
+  /* part defined */
+  if ((defInsnForSecondOpnd->GetMachineOpcode() == MOP_xmovkri16) ||
+      (defInsnForSecondOpnd->GetMachineOpcode() == MOP_wmovkri16) ||
+      (defInsnForSecondOpnd->GetMachineOpcode() == MOP_asm)) {
+    return false;
+  }
+
+  if (defInsnForSecondOpnd->IsStore() || defInsnForSecondOpnd->IsLoad()) {
+    auto *memOpnd = static_cast<MemOperand*>(defInsnForSecondOpnd->GetMemOpnd());
+    if (memOpnd != nullptr && !memOpnd->IsIntactIndexed()) {
+      return false;
+    }
+  }
+
+  srcOpndUseInsnSet = cgFunc.GetRD()->FindUseForRegOpnd(*defInsnForSecondOpnd, secondRegNO, true);
+  /*
+   * useInsn is not expected to have multiple definition
+   * replaced opnd is not expected to have definition already
+   */
+  return CheckReplacedUseInsn(insn);
+}
+
+bool BackPropPattern::CheckPredefineInsn(Insn &insn) {
+  if (insn.GetPrev() == defInsnForSecondOpnd) {
+    return true;
+  }
+  std::vector<Insn *> preDefInsnForFirstOpndVec;
+  /* there is no predefine insn in current bb */
+  if (!cgFunc.GetRD()->RegIsUsedOrDefBetweenInsn(firstRegNO, *defInsnForSecondOpnd, insn)) {
+    return false;
+  }
+  return true;
+}
+
+bool BackPropPattern::CheckReplacedUseInsn(Insn &insn) {
+  for (auto *useInsn : srcOpndUseInsnSet) {
+    if (useInsn->GetMemOpnd() != nullptr) {
+      auto *a64MemOpnd = static_cast<MemOperand*>(useInsn->GetMemOpnd());
+      if (!a64MemOpnd->IsIntactIndexed()) {
+        if (a64MemOpnd->GetBaseRegister() != nullptr &&
+            a64MemOpnd->GetBaseRegister()->GetRegisterNumber() == secondRegNO) {
+          return false;
+        }
+      }
+    }
+    /* insn has been checked def */
+    if (useInsn == &insn) {
+      if (defInsnForSecondOpnd != useInsn->GetPrev() &&
+          cgFunc.GetRD()->FindRegUseBetweenInsnGlobal(firstRegNO, defInsnForSecondOpnd, useInsn, insn.GetBB())) {
+        return false;
+      }
+      continue;
+    }
+    auto checkOneDefOnly = [](const InsnSet &defSet, const Insn &oneDef, bool checkHasDef = false)->bool {
+      if (defSet.size() > 1) {
+        return false;
+      } else if (defSet.size() == 1) {
+        if (&oneDef != *(defSet.begin())) {
+          return false;
+        }
+      } else {
+        if (checkHasDef) {
+          CHECK_FATAL(false, "find def insn failed");
+        }
+      }
+      return true;
+    };
+    /* ensure that the use insns to be replaced is defined by defInsnForSecondOpnd only */
+    if (useInsn->IsMemAccess() && static_cast<MemOperand *>(
+        useInsn->GetMemOpnd())->GetIndexOpt() != MemOperand::kIntact) {
+      return false;
+    }
+    InsnSet defInsnVecOfSrcOpnd = cgFunc.GetRD()->FindDefForRegOpnd(*useInsn, secondRegNO, true);
+    if (!checkOneDefOnly(defInsnVecOfSrcOpnd, *defInsnForSecondOpnd, true)) {
+      return false;
+    }
+
+    InsnSet defInsnVecOfFirstReg = cgFunc.GetRD()->FindDefForRegOpnd(*useInsn, firstRegNO, true);
+    if (!checkOneDefOnly(defInsnVecOfFirstReg, insn)) {
+      return false;
+    }
+
+    if (defInsnForSecondOpnd != useInsn->GetPrev() &&
+        cgFunc.GetRD()->FindRegUseBetweenInsnGlobal(firstRegNO, defInsnForSecondOpnd, useInsn, insn.GetBB())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool BackPropPattern::CheckRedefineInsn(Insn &insn) {
+  for (auto useInsn : srcOpndUseInsnSet) {
+    Insn *startInsn = &insn;
+    Insn *endInsn = useInsn;
+    if (endInsn == startInsn) {
+      if (cgFunc.GetRD()->RegIsUsedIncaller(firstRegNO, insn, *useInsn)) {
+        return false;
+      } else {
+        continue;
+      }
+    }
+
+    if (useInsn->GetBB() == insn.GetBB()) {
+      if (useInsn->GetId() < insn.GetId()) {
+        startInsn = useInsn;
+        endInsn = &insn;
+      }
+    }
+    if (!cgFunc.GetRD()->RegIsLiveBetweenInsn(firstRegNO, *startInsn, *endInsn, true, true)) {
+      return false;
+    }
+    if (!cgFunc.GetRD()->RegIsLiveBetweenInsn(secondRegNO, *startInsn, *endInsn, true)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool BackPropPattern::CheckCondition(Insn &insn) {
+  if (!CheckAndGetOpnd(insn)) {
+    return false;
+  }
+  /* Unless there is a reason that dest can not live out the current BB */
+  if (cgFunc.HasAsm() && !DestOpndHasUseInsns(insn)) {
+    return false;
+  }
+  /* first register must not be live out to eh_succs */
+  if (DestOpndLiveOutToEHSuccs(insn)) {
+    return false;
+  }
+  if (globalProp) {
+    if (!CheckSrcOpndDefAndUseInsnsGlobal(insn)) {
+      return false;
+    }
+  } else {
+    if (!CheckSrcOpndDefAndUseInsns(insn)) {
+      return false;
+    }
+    if (!CheckPredefineInsn(insn)) {
+      return false;
+    }
+    if (!CheckRedefineInsn(insn)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void BackPropPattern::Optimize(Insn &insn) {
+  Operand &firstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  ReplaceAllUsedOpndWithNewOpnd(srcOpndUseInsnSet, secondRegNO, firstOpnd, true);
+  /* replace define insn */
+  const InsnDesc *md = defInsnForSecondOpnd->GetDesc();
+  uint32 opndNum = defInsnForSecondOpnd->GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = defInsnForSecondOpnd->GetOperand(i);
+    if (!md->opndMD[i]->IsRegDef() && !opnd.IsMemoryAccessOperand()) {
+      continue;
+    }
+
+    if (opnd.IsRegister() && (static_cast<RegOperand&>(opnd).GetRegisterNumber() == secondRegNO)) {
+      /* remove remat info */
+      Operand &defOp = defInsnForSecondOpnd->GetOperand(i);
+      CHECK_FATAL(defOp.IsRegister(), "unexpect def opnd type");
+      auto &defRegOp = static_cast<RegOperand&>(defOp);
+      MIRPreg *preg = static_cast<AArch64CGFunc&>(cgFunc).GetPseudoRegFromVirtualRegNO(
+          defRegOp.GetRegisterNumber(), CGOptions::DoCGSSA());
+      if (preg != nullptr) {
+        preg->SetOp(OP_undef);
+      }
+      defInsnForSecondOpnd->SetOperand(i, firstOpnd);
+      cgFunc.GetRD()->UpdateInOut(*defInsnForSecondOpnd->GetBB());
+    } else if (opnd.IsMemoryAccessOperand()) {
+      MemOperand &memOpnd = static_cast<MemOperand&>(opnd);
+      RegOperand *base = memOpnd.GetBaseRegister();
+      if (base != nullptr && memOpnd.GetAddrMode() == MemOperand::kAddrModeBOi &&
+          (memOpnd.IsPostIndexed() || memOpnd.IsPreIndexed()) && base->GetRegisterNumber() == secondRegNO) {
+        MemOperand *newMem = static_cast<MemOperand*>(opnd.Clone(*cgFunc.GetMemoryPool()));
+        CHECK_FATAL(newMem != nullptr, "null ptr check");
+        newMem->SetBaseRegister(static_cast<RegOperand&>(firstOpnd));
+        defInsnForSecondOpnd->SetOperand(i, *newMem);
+        cgFunc.GetRD()->UpdateInOut(*defInsnForSecondOpnd->GetBB());
+      }
+    }
+  }
+  /* There is special implication when backward propagation is allowed for physical register R0.
+   * This is a case that the calling func foo directly returns the result from the callee bar as follows:
+   *
+   * foo:
+   * bl                                               bl // bar()
+   * mov vreg, X0  //res = bar()        naive bkprop
+   * ....          //X0 is not redefined    ====>    ....  //X0 may be reused as RA sees "X0 has not been used" after bl
+   * mov X0, vreg                            //In fact, X0 is implicitly used by foo. We need to tell RA that X0 is live
+   * ret                                              ret
+   *
+   * To make RA simple, we tell RA to not use X0 by keeping "mov X0, X0". That is
+   * foo:
+   * bl //bar()
+   * ....          // Perform backward prop X0 and force X0 cant be reused
+   * mov X0, X0    // This can be easily remved later in peephole phase
+   * ret
+   */
+  if (cgFunc.HasCall() &&
+      !(cgFunc.GetFunction().IsReturnVoid()) &&
+      (firstRegNO == R0) &&
+      (static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetRegisterNumber() == R0))  {
+    /* Keep this instruction: mov R0, R0 */
+    cgFunc.GetRD()->UpdateInOut(*insn.GetBB(), true);
+    return;
+  } else {
+    insn.GetBB()->RemoveInsn(insn);
+    cgFunc.GetRD()->UpdateInOut(*insn.GetBB(), true);
+  }
+}
+
+void BackPropPattern::Init() {
+  firstRegOpnd = nullptr;
+  secondRegOpnd = nullptr;
+  firstRegNO = 0;
+  secondRegNO = 0;
+  srcOpndUseInsnSet.clear();
+  defInsnForSecondOpnd = nullptr;
+}
+
+void BackPropPattern::Run() {
+  bool secondTime = false;
+  std::set<BB*, BBIdCmp> modifiedBB;
+  do {
+    FOR_ALL_BB(bb, &cgFunc) {
+      if (bb->IsUnreachable() || (secondTime && modifiedBB.find(bb) == modifiedBB.end())) {
+        continue;
+      }
+
+      if (secondTime) {
+        modifiedBB.erase(bb);
+      }
+
+      FOR_BB_INSNS_REV(insn, bb) {
+        Init();
+        if (!CheckCondition(*insn)) {
+          continue;
+        }
+        (void)modifiedBB.insert(bb);
+        Optimize(*insn);
+      }
+    }
+    secondTime = true;
+  } while (!modifiedBB.empty());
+}
+
+bool CmpCsetPattern::CheckCondition(Insn &insn) {
+  nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr || !insn.IsMachineInstruction()) {
+    return false;
+  }
+
+  MOperator firstMop = insn.GetMachineOpcode();
+  MOperator secondMop = nextInsn->GetMachineOpcode();
+  if (!(((firstMop == MOP_wcmpri) || (firstMop == MOP_xcmpri)) &&
+        ((secondMop == MOP_wcsetrc) || (secondMop == MOP_xcsetrc)))) {
+    return false;
+  }
+
+  /* get cmp_first operand */
+  cmpFirstOpnd = &(insn.GetOperand(kInsnSecondOpnd));
+  /* get cmp second Operand, ImmOperand must be 0 or 1 */
+  cmpSecondOpnd = &(insn.GetOperand(kInsnThirdOpnd));
+  ASSERT(cmpSecondOpnd->IsIntImmediate(), "expects ImmOperand");
+  ImmOperand *cmpConstOpnd = static_cast<ImmOperand*>(cmpSecondOpnd);
+  cmpConstVal = cmpConstOpnd->GetValue();
+  /* get cset first Operand */
+  csetFirstOpnd = &(nextInsn->GetOperand(kInsnFirstOpnd));
+  if (((cmpConstVal != 0) && (cmpConstVal != 1)) || (cmpFirstOpnd->GetSize() != csetFirstOpnd->GetSize()) ||
+      !OpndDefByOneOrZero(insn, 1)) {
+    return false;
+  }
+
+  InsnSet useInsnSet = cgFunc.GetRD()->FindUseForRegOpnd(insn, 0, false);
+  if (useInsnSet.size() > 1) {
+    return false;
+  }
+  return true;
+}
+
+void CmpCsetPattern::Optimize(Insn &insn) {
+  Insn *csetInsn = nextInsn;
+  BB &bb = *insn.GetBB();
+  nextInsn = nextInsn->GetNextMachineInsn();
+  /* get condition Operand */
+  CondOperand &cond = static_cast<CondOperand&>(csetInsn->GetOperand(kInsnSecondOpnd));
+  if (((cmpConstVal == 0) && (cond.GetCode() == CC_NE)) || ((cmpConstVal == 1) && (cond.GetCode() == CC_EQ))) {
+    if (RegOperand::IsSameReg(*cmpFirstOpnd, *csetFirstOpnd)) {
+      bb.RemoveInsn(insn);
+      bb.RemoveInsn(*csetInsn);
+    } else {
+      MOperator mopCode = (cmpFirstOpnd->GetSize() == k64BitSize) ? MOP_xmovrr : MOP_wmovrr;
+      Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(mopCode, *csetFirstOpnd, *cmpFirstOpnd);
+      newInsn.SetId(insn.GetId());
+      bb.ReplaceInsn(insn, newInsn);
+      bb.RemoveInsn(*csetInsn);
+    }
+  } else if (((cmpConstVal == 1) && (cond.GetCode() == CC_NE)) ||
+             ((cmpConstVal == 0) && (cond.GetCode() == CC_EQ))) {
+    MOperator mopCode = (cmpFirstOpnd->GetSize() == k64BitSize) ? MOP_xeorrri13 : MOP_weorrri12;
+    constexpr int64 eorImm = 1;
+    auto &aarch64CGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+    ImmOperand &one = aarch64CGFunc.CreateImmOperand(eorImm, k8BitSize, false);
+    Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(mopCode, *csetFirstOpnd, *cmpFirstOpnd, one);
+    newInsn.SetId(insn.GetId());
+    bb.ReplaceInsn(insn, newInsn);
+    bb.RemoveInsn(*csetInsn);
+  }
+  cgFunc.GetRD()->UpdateInOut(bb, true);
+}
+
+void CmpCsetPattern::Init() {
+  cmpConstVal  = 0;
+  cmpFirstOpnd = nullptr;
+  cmpSecondOpnd = nullptr;
+  csetFirstOpnd = nullptr;
+}
+
+void CmpCsetPattern::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      Init();
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+bool CselPattern::CheckCondition(Insn &insn) {
+  MOperator mopCode = insn.GetMachineOpcode();
+  if ((mopCode != MOP_xcselrrrc) && (mopCode != MOP_wcselrrrc)) {
+    return false;
+  }
+  return true;
+}
+
+void CselPattern::Optimize(Insn &insn) {
+  BB &bb = *insn.GetBB();
+  Operand &opnd0 = insn.GetOperand(kInsnFirstOpnd);
+  Operand &cond = insn.GetOperand(kInsnFourthOpnd);
+  MOperator newMop = ((opnd0.GetSize()) == k64BitSize ? MOP_xcsetrc : MOP_wcsetrc);
+  Operand &rflag = cgFunc.GetOrCreateRflag();
+  if (OpndDefByOne(insn, kInsnSecondOpnd) && OpndDefByZero(insn, kInsnThirdOpnd)) {
+    Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(newMop, opnd0, cond, rflag);
+    newInsn.SetId(insn.GetId());
+    bb.ReplaceInsn(insn, newInsn);
+    cgFunc.GetRD()->InitGenUse(bb, false);
+  } else if (OpndDefByZero(insn, kInsnSecondOpnd) && OpndDefByOne(insn, kInsnThirdOpnd)) {
+    auto &originCond = static_cast<CondOperand&>(cond);
+    ConditionCode inverseCondCode = GetReverseCC(originCond.GetCode());
+    if (inverseCondCode == kCcLast) {
+      return;
+    }
+    auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+    CondOperand &inverseCond = aarchCGFunc.GetCondOperand(inverseCondCode);
+    Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(newMop, opnd0, inverseCond, rflag);
+    newInsn.SetId(insn.GetId());
+    bb.ReplaceInsn(insn, newInsn);
+    cgFunc.GetRD()->InitGenUse(bb, false);
+  }
+}
+
+void CselPattern::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS_SAFE(insn, bb, nextInsn) {
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+uint32 RedundantUxtPattern::GetInsnValidBit(const Insn &insn) {
+  MOperator mOp = insn.GetMachineOpcode();
+  uint32 nRet;
+  switch (mOp) {
+    case MOP_wcsetrc:
+    case MOP_xcsetrc:
+      nRet = 1;
+      break;
+    case MOP_wldrb:
+    case MOP_wldarb:
+    case MOP_wldxrb:
+    case MOP_wldaxrb:
+      nRet = k8BitSize;
+      break;
+    case MOP_wldrh:
+    case MOP_wldarh:
+    case MOP_wldxrh:
+    case MOP_wldaxrh:
+      nRet = k16BitSize;
+      break;
+    case MOP_wmovrr:
+    case MOP_wmovri32:
+    case MOP_wldrsb:
+    case MOP_wldrsh:
+    case MOP_wldli:
+    case MOP_wldr:
+    case MOP_wldp:
+    case MOP_wldar:
+    case MOP_wmovkri16:
+    case MOP_wmovzri16:
+    case MOP_wmovnri16:
+    case MOP_wldxr:
+    case MOP_wldaxr:
+    case MOP_wldaxp:
+    case MOP_wcsincrrrc:
+    case MOP_wcselrrrc:
+    case MOP_wcsinvrrrc:
+      nRet = k32BitSize;
+      break;
+    default:
+      nRet = k64BitSize;
+      break;
+  }
+  return nRet;
+}
+
+uint32 RedundantUxtPattern::GetMaximumValidBit(Insn &insn, uint8 index, InsnSet &visitedInsn) const {
+  InsnSet defInsnSet = cgFunc.GetRD()->FindDefForRegOpnd(insn, index);
+  if (defInsnSet.empty()) {
+    /* disable opt when there is no def point. */
+    return k64BitSize;
+  }
+
+  uint32 validBit = 0;
+  uint32 nMaxValidBit = 0;
+  for (auto &defInsn : defInsnSet) {
+    if (visitedInsn.find(defInsn) != visitedInsn.end()) {
+      continue;
+    }
+
+    (void)visitedInsn.insert(defInsn);
+    MOperator mOp = defInsn->GetMachineOpcode();
+    if ((mOp == MOP_wmovrr) || (mOp == MOP_xmovrr)) {
+      validBit = GetMaximumValidBit(*defInsn, 1, visitedInsn);
+    } else {
+      validBit = GetInsnValidBit(*defInsn);
+    }
+
+    nMaxValidBit = nMaxValidBit < validBit ? validBit : nMaxValidBit;
+  }
+  return nMaxValidBit;
+}
+
+bool RedundantUxtPattern::CheckCondition(Insn &insn) {
+  BB &bb = *insn.GetBB();
+  InsnSet visitedInsn1;
+  InsnSet visitedInsn2;
+  if (!((insn.GetMachineOpcode() == MOP_xuxth32 &&
+         GetMaximumValidBit(insn, kInsnSecondOpnd, visitedInsn1) <= k16BitSize) ||
+        (insn.GetMachineOpcode() == MOP_xuxtb32 &&
+         GetMaximumValidBit(insn, kInsnSecondOpnd, visitedInsn2) <= k8BitSize))) {
+    return false;
+  }
+
+  Operand &firstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  secondOpnd = &(insn.GetOperand(kInsnSecondOpnd));
+  if (RegOperand::IsSameReg(firstOpnd, *secondOpnd)) {
+    bb.RemoveInsn(insn);
+    /* update in/out */
+    cgFunc.GetRD()->UpdateInOut(bb, true);
+    return false;
+  }
+  useInsnSet = cgFunc.GetRD()->FindUseForRegOpnd(insn, 0, false);
+  RegOperand &firstRegOpnd = static_cast<RegOperand&>(firstOpnd);
+  firstRegNO = firstRegOpnd.GetRegisterNumber();
+  /* for uxth R1, V501, R1 is parameter register, this can't be optimized. */
+  if (firstRegOpnd.IsPhysicalRegister()) {
+    return false;
+  }
+
+  if (useInsnSet.empty()) {
+    bb.RemoveInsn(insn);
+    /* update in/out */
+    cgFunc.GetRD()->UpdateInOut(bb, true);
+    return false;
+  }
+
+  RegOperand *secondRegOpnd = static_cast<RegOperand*>(secondOpnd);
+  ASSERT(secondRegOpnd != nullptr, "secondRegOpnd should not be nullptr");
+  uint32 secondRegNO = secondRegOpnd->GetRegisterNumber();
+  for (auto useInsn : useInsnSet) {
+    InsnSet defInsnSet = cgFunc.GetRD()->FindDefForRegOpnd(*useInsn, firstRegNO, true);
+    if ((defInsnSet.size() > 1) || !(cgFunc.GetRD()->RegIsLiveBetweenInsn(secondRegNO, insn, *useInsn))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void RedundantUxtPattern::Optimize(Insn &insn) {
+  BB &bb = *insn.GetBB();
+  ReplaceAllUsedOpndWithNewOpnd(useInsnSet, firstRegNO, *secondOpnd, true);
+  bb.RemoveInsn(insn);
+  cgFunc.GetRD()->UpdateInOut(bb, true);
+}
+
+void RedundantUxtPattern::Init() {
+  useInsnSet.clear();
+  secondOpnd = nullptr;
+}
+
+void RedundantUxtPattern::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    if (bb->IsUnreachable()) {
+      continue;
+    }
+    FOR_BB_INSNS_SAFE(insn, bb, nextInsn) {
+      Init();
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+bool LocalVarSaveInsnPattern::CheckFirstInsn(const Insn &firstInsn) {
+  MOperator mOp = firstInsn.GetMachineOpcode();
+  if (mOp != MOP_xmovrr && mOp != MOP_wmovrr) {
+    return false;
+  }
+  firstInsnSrcOpnd = &(firstInsn.GetOperand(kInsnSecondOpnd));
+  RegOperand *firstInsnSrcReg = static_cast<RegOperand*>(firstInsnSrcOpnd);
+  if (firstInsnSrcReg->GetRegisterNumber() != R0) {
+    return false;
+  }
+  firstInsnDestOpnd = &(firstInsn.GetOperand(kInsnFirstOpnd));
+  RegOperand *firstInsnDestReg = static_cast<RegOperand*>(firstInsnDestOpnd);
+  if (firstInsnDestReg->IsPhysicalRegister()) {
+    return false;
+  }
+  return true;
+}
+
+bool LocalVarSaveInsnPattern::CheckSecondInsn() {
+  MOperator mOp = secondInsn->GetMachineOpcode();
+  if (mOp != MOP_wstr && mOp != MOP_xstr) {
+    return false;
+  }
+  secondInsnSrcOpnd = &(secondInsn->GetOperand(kInsnFirstOpnd));
+  if (!RegOperand::IsSameReg(*firstInsnDestOpnd, *secondInsnSrcOpnd)) {
+    return false;
+  }
+  /* check memOperand is stack memOperand, and x0 is stored in localref var region */
+  secondInsnDestOpnd = &(secondInsn->GetOperand(kInsnSecondOpnd));
+  MemOperand *secondInsnDestMem = static_cast<MemOperand*>(secondInsnDestOpnd);
+  RegOperand *baseReg = secondInsnDestMem->GetBaseRegister();
+  RegOperand *indexReg = secondInsnDestMem->GetIndexRegister();
+  if ((baseReg == nullptr) || !(cgFunc.IsFrameReg(*baseReg)) || (indexReg != nullptr)) {
+    return false;
+  }
+  return true;
+}
+
+bool LocalVarSaveInsnPattern::CheckAndGetUseInsn(Insn &firstInsn) {
+  InsnSet useInsnSet = cgFunc.GetRD()->FindUseForRegOpnd(firstInsn, kInsnFirstOpnd, false);
+  if (useInsnSet.size() != 2) { /* secondInsn and another useInsn */
+    return false;
+  }
+
+  /* useInsnSet includes secondInsn and another useInsn */
+  for (auto tmpUseInsn : useInsnSet) {
+    if (tmpUseInsn->GetId() != secondInsn->GetId()) {
+      useInsn = tmpUseInsn;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool LocalVarSaveInsnPattern::CheckLiveRange(const Insn &firstInsn) {
+  uint32 maxInsnNO = cgFunc.GetRD()->GetMaxInsnNO();
+  uint32 useInsnID = useInsn->GetId();
+  uint32 defInsnID = firstInsn.GetId();
+  uint32 distance = useInsnID > defInsnID ? useInsnID - defInsnID : defInsnID - useInsnID;
+  float liveRangeProportion = static_cast<float>(distance) / maxInsnNO;
+  /* 0.3 is a balance for real optimization effect */
+  if (liveRangeProportion < 0.3) {
+    return false;
+  }
+  return true;
+}
+
+bool LocalVarSaveInsnPattern::CheckCondition(Insn &firstInsn) {
+  secondInsn = firstInsn.GetNext();
+  if (secondInsn == nullptr) {
+    return false;
+  }
+  /* check firstInsn is : mov vreg, R0; */
+  if (!CheckFirstInsn(firstInsn)) {
+    return false;
+  }
+  /* check the secondInsn is : str vreg, stackMem */
+  if (!CheckSecondInsn()) {
+    return false;
+  }
+  /* find the uses of the vreg */
+  if (!CheckAndGetUseInsn(firstInsn)) {
+    return false;
+  }
+  /* simulate live range using insn distance */
+  if (!CheckLiveRange(firstInsn)) {
+    return false;
+  }
+  RegOperand *firstInsnDestReg = static_cast<RegOperand*>(firstInsnDestOpnd);
+  regno_t firstInsnDestRegNO = firstInsnDestReg->GetRegisterNumber();
+  InsnSet defInsnSet = cgFunc.GetRD()->FindDefForRegOpnd(*useInsn, firstInsnDestRegNO, true);
+  if (defInsnSet.size() != 1) {
+    return false;
+  }
+  ASSERT((*(defInsnSet.begin()))->GetId() == firstInsn.GetId(), "useInsn has only one define Insn : firstInsn");
+  /* check whether the stack mem is changed or not */
+  MemOperand *secondInsnDestMem = static_cast<MemOperand*>(secondInsnDestOpnd);
+  int64 memOffset = secondInsnDestMem->GetOffsetImmediate()->GetOffsetValue();
+  InsnSet memDefInsnSet = cgFunc.GetRD()->FindDefForMemOpnd(*useInsn, memOffset, true);
+  if (memDefInsnSet.size() != 1) {
+    return false;
+  }
+  if ((*(memDefInsnSet.begin()))->GetId() != secondInsn->GetId()) {
+    return false;
+  }
+   /* check whether has call between use and def */
+  if (!cgFunc.GetRD()->HasCallBetweenDefUse(firstInsn, *useInsn)) {
+    return false;
+  }
+  return true;
+}
+
+void LocalVarSaveInsnPattern::Optimize(Insn &insn) {
+  /* insert ldr insn before useInsn */
+  MOperator ldrOpCode = secondInsnSrcOpnd->GetSize() == k64BitSize ? MOP_xldr : MOP_wldr;
+  Insn &ldrInsn = cgFunc.GetInsnBuilder()->BuildInsn(ldrOpCode, *secondInsnSrcOpnd, *secondInsnDestOpnd);
+  ldrInsn.SetId(useInsn->GetId() - 1);
+  useInsn->GetBB()->InsertInsnBefore(*useInsn, ldrInsn);
+  cgFunc.GetRD()->UpdateInOut(*useInsn->GetBB(), true);
+  secondInsn->SetOperand(kInsnFirstOpnd, *firstInsnSrcOpnd);
+  BB *saveInsnBB = insn.GetBB();
+  saveInsnBB->RemoveInsn(insn);
+  cgFunc.GetRD()->UpdateInOut(*saveInsnBB, true);
+}
+
+void LocalVarSaveInsnPattern::Init() {
+  firstInsnSrcOpnd = nullptr;
+  firstInsnDestOpnd = nullptr;
+  secondInsnSrcOpnd = nullptr;
+  secondInsnDestOpnd = nullptr;
+  useInsn = nullptr;
+  secondInsn = nullptr;
+}
+
+void LocalVarSaveInsnPattern::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    if (bb->IsCleanup()) {
+      continue;
+    }
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (!insn->IsCall()) {
+        continue;
+      }
+      Insn *firstInsn = insn->GetNextMachineInsn();
+      if (firstInsn == nullptr) {
+        continue;
+      }
+      Init();
+      if (!CheckCondition(*firstInsn)) {
+        continue;
+      }
+      Optimize(*firstInsn);
+    }
+  }
+}
+
+void ExtendShiftOptPattern::SetExMOpType(const Insn &use) {
+  MOperator op = use.GetMachineOpcode();
+  switch (op) {
+    case MOP_xaddrrr:
+    case MOP_xxwaddrrre:
+    case MOP_xaddrrrs: {
+      exMOpType = kExAdd;
+      break;
+    }
+    case MOP_waddrrr:
+    case MOP_wwwaddrrre:
+    case MOP_waddrrrs: {
+      exMOpType = kEwAdd;
+      break;
+    }
+    case MOP_xsubrrr:
+    case MOP_xxwsubrrre:
+    case MOP_xsubrrrs: {
+      exMOpType = kExSub;
+      break;
+    }
+    case MOP_wsubrrr:
+    case MOP_wwwsubrrre:
+    case MOP_wsubrrrs: {
+      exMOpType = kEwSub;
+      break;
+    }
+    case MOP_xcmnrr:
+    case MOP_xwcmnrre:
+    case MOP_xcmnrrs: {
+      exMOpType = kExCmn;
+      break;
+    }
+    case MOP_wcmnrr:
+    case MOP_wwcmnrre:
+    case MOP_wcmnrrs: {
+      exMOpType = kEwCmn;
+      break;
+    }
+    case MOP_xcmprr:
+    case MOP_xwcmprre:
+    case MOP_xcmprrs: {
+      exMOpType = kExCmp;
+      break;
+    }
+    case MOP_wcmprr:
+    case MOP_wwcmprre:
+    case MOP_wcmprrs: {
+      exMOpType = kEwCmp;
+      break;
+    }
+    default: {
+      exMOpType = kExUndef;
+    }
+  }
+}
+
+void ExtendShiftOptPattern::SetLsMOpType(const Insn &use) {
+  MOperator op = use.GetMachineOpcode();
+  switch (op) {
+    case MOP_xaddrrr:
+    case MOP_xaddrrrs: {
+      lsMOpType = kLxAdd;
+      break;
+    }
+    case MOP_waddrrr:
+    case MOP_waddrrrs: {
+      lsMOpType = kLwAdd;
+      break;
+    }
+    case MOP_xsubrrr:
+    case MOP_xsubrrrs: {
+      lsMOpType = kLxSub;
+      break;
+    }
+    case MOP_wsubrrr:
+    case MOP_wsubrrrs: {
+      lsMOpType = kLwSub;
+      break;
+    }
+    case MOP_xcmnrr:
+    case MOP_xcmnrrs: {
+      lsMOpType = kLxCmn;
+      break;
+    }
+    case MOP_wcmnrr:
+    case MOP_wcmnrrs: {
+      lsMOpType = kLwCmn;
+      break;
+    }
+    case MOP_xcmprr:
+    case MOP_xcmprrs: {
+      lsMOpType = kLxCmp;
+      break;
+    }
+    case MOP_wcmprr:
+    case MOP_wcmprrs: {
+      lsMOpType = kLwCmp;
+      break;
+    }
+    case MOP_xeorrrr:
+    case MOP_xeorrrrs: {
+      lsMOpType = kLxEor;
+      break;
+    }
+    case MOP_weorrrr:
+    case MOP_weorrrrs: {
+      lsMOpType = kLwEor;
+      break;
+    }
+    case MOP_xinegrr:
+    case MOP_xinegrrs: {
+      lsMOpType = kLxNeg;
+      replaceIdx = kInsnSecondOpnd;
+      break;
+    }
+    case MOP_winegrr:
+    case MOP_winegrrs: {
+      lsMOpType = kLwNeg;
+      replaceIdx = kInsnSecondOpnd;
+      break;
+    }
+    case MOP_xiorrrr:
+    case MOP_xiorrrrs: {
+      lsMOpType = kLxIor;
+      break;
+    }
+    case MOP_wiorrrr:
+    case MOP_wiorrrrs: {
+      lsMOpType = kLwIor;
+      break;
+    }
+    default: {
+      lsMOpType = kLsUndef;
+    }
+  }
+}
+
+void ExtendShiftOptPattern::SelectExtendOrShift(const Insn &def) {
+  MOperator op = def.GetMachineOpcode();
+  switch (op) {
+    case MOP_xsxtb32:
+    case MOP_xsxtb64: extendOp = ExtendShiftOperand::kSXTB;
+      break;
+    case MOP_xsxth32:
+    case MOP_xsxth64: extendOp = ExtendShiftOperand::kSXTH;
+      break;
+    case MOP_xsxtw64: extendOp = ExtendShiftOperand::kSXTW;
+      break;
+    case MOP_xuxtb32: extendOp = ExtendShiftOperand::kUXTB;
+      break;
+    case MOP_xuxth32: extendOp = ExtendShiftOperand::kUXTH;
+      break;
+    case MOP_xuxtw64: extendOp = ExtendShiftOperand::kUXTW;
+      break;
+    case MOP_wlslrri5:
+    case MOP_xlslrri6: shiftOp = BitShiftOperand::kLSL;
+      break;
+    case MOP_xlsrrri6:
+    case MOP_wlsrrri5: shiftOp = BitShiftOperand::kLSR;
+      break;
+    case MOP_xasrrri6:
+    case MOP_wasrrri5: shiftOp = BitShiftOperand::kASR;
+      break;
+    default: {
+      extendOp = ExtendShiftOperand::kUndef;
+      shiftOp = BitShiftOperand::kUndef;
+    }
+  }
+}
+
+/* first use must match SelectExtendOrShift */
+bool ExtendShiftOptPattern::CheckDefUseInfo(Insn &use, uint32 size) {
+  auto &regOperand = static_cast<RegOperand&>(defInsn->GetOperand(kInsnFirstOpnd));
+  Operand &defSrcOpnd = defInsn->GetOperand(kInsnSecondOpnd);
+  CHECK_FATAL(defSrcOpnd.IsRegister(), "defSrcOpnd must be register!");
+  auto &regDefSrc = static_cast<RegOperand&>(defSrcOpnd);
+  if (regDefSrc.IsPhysicalRegister()) {
+    return false;
+  }
+  /*
+   * has Implict cvt
+   *
+   * avoid cases as following:
+   *   lsr  x2, x2, #8
+   *   ubfx w2, x2, #0, #32                lsr  x2, x2, #8
+   *   eor  w0, w0, w2           ===>      eor  w0, w0, x2     ==\=>  eor w0, w0, w2, LSR #8
+   *
+   * the truncation causes the wrong value by shift right
+   * shift left does not matter
+   */
+  auto &useDefOpnd = static_cast<RegOperand&>(use.GetOperand(kInsnFirstOpnd));
+  if ((shiftOp != BitShiftOperand::kUndef || extendOp != ExtendShiftOperand::kUndef) &&
+      (regDefSrc.GetSize() > regOperand.GetSize() || useDefOpnd.GetSize() != size)) {
+    return false;
+  }
+  if ((shiftOp == BitShiftOperand::kLSR || shiftOp == BitShiftOperand::kASR) &&
+      (defSrcOpnd.GetSize() > size)) {
+    return false;
+  }
+  regno_t defSrcRegNo = regDefSrc.GetRegisterNumber();
+  /* check regDefSrc */
+  InsnSet defSrcSet = cgFunc.GetRD()->FindDefForRegOpnd(use, defSrcRegNo, true);
+  /* The first defSrcInsn must be closest to useInsn */
+  if (defSrcSet.empty()) {
+    return false;
+  }
+  Insn *defSrcInsn = *defSrcSet.begin();
+  const InsnDesc *md = defSrcInsn->GetDesc();
+  if ((size != regOperand.GetSize()) && md->IsMove()) {
+    return false;
+  }
+  if (defInsn->GetBB() == use.GetBB()) {
+    /* check replace reg def between defInsn and currInsn */
+    Insn *tmpInsn = defInsn->GetNext();
+    while (tmpInsn != &use) {
+      if (tmpInsn == defSrcInsn || tmpInsn == nullptr) {
+        return false;
+      }
+      tmpInsn = tmpInsn->GetNext();
+    }
+  } else { /* def use not in same BB */
+    if (defSrcInsn->GetBB() != defInsn->GetBB()) {
+      return false;
+    }
+    if (defSrcInsn->GetId() > defInsn->GetId()) {
+      return false;
+    }
+  }
+  /* case:
+   * lsl w0, w0, #5
+   * eor w0, w2, w0
+   * --->
+   * eor w0, w2, w0, lsl 5
+   */
+  if (defSrcInsn == defInsn) {
+    InsnSet replaceRegUseSet = cgFunc.GetRD()->FindUseForRegOpnd(*defInsn, defSrcRegNo, true);
+    if (replaceRegUseSet.size() != k1BitSize) {
+      return false;
+    }
+    removeDefInsn = true;
+  }
+  return true;
+}
+
+/* Check whether ExtendShiftOptPattern optimization can be performed. */
+SuffixType ExtendShiftOptPattern::CheckOpType(const Operand &lastOpnd) const {
+  /* Assign values to useType and defType. */
+  uint32 useType = kNoSuffix;
+  uint32 defType = shiftOp;
+  if (extendOp != ExtendShiftOperand::kUndef) {
+    defType = kExten;
+  }
+  if (lastOpnd.IsOpdShift()) {
+    BitShiftOperand lastShiftOpnd = static_cast<const BitShiftOperand&>(lastOpnd);
+    useType = lastShiftOpnd.GetShiftOp();
+  } else if (lastOpnd.IsOpdExtend()) {
+    ExtendShiftOperand lastExtendOpnd = static_cast<const ExtendShiftOperand&>(lastOpnd);
+    useType = kExten;
+    /* two insn is exten and exten ,value is exten(oneself) */
+    if (useType == defType && extendOp != lastExtendOpnd.GetExtendOp()) {
+      return kNoSuffix;
+    }
+  }
+  return kDoOptimizeTable[useType][defType];
+}
+
+/* new Insn extenType:
+ * =====================
+ * (useMop)   (defMop) (newmop)
+ * | nosuffix |  all  | all|
+ * | exten    |  ex   | ex |
+ * |  ls      |  ex   | ls |
+ * |  asr     |  !asr | F  |
+ * |  !asr    |  asr  | F  |
+ * (useMop)   (defMop)
+ * =====================
+ */
+void ExtendShiftOptPattern::ReplaceUseInsn(Insn &use, const Insn &def, uint32 amount) {
+  AArch64CGFunc &a64CGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  uint32 lastIdx = use.GetOperandSize() - k1BitSize;
+  Operand &lastOpnd = use.GetOperand(lastIdx);
+  SuffixType optType = CheckOpType(lastOpnd);
+  Operand *shiftOpnd = nullptr;
+  if (optType == kNoSuffix) {
+    return;
+  }else if (optType == kExten) {
+    replaceOp = exMOpTable[exMOpType];
+    if (amount > k4BitSize) {
+      return;
+    }
+    shiftOpnd = &a64CGFunc.CreateExtendShiftOperand(extendOp, amount, static_cast<int32>(k64BitSize));
+  } else {
+    replaceOp = lsMOpTable[lsMOpType];
+    if (amount >= k32BitSize) {
+      return;
+    }
+    shiftOpnd = &a64CGFunc.CreateBitShiftOperand(shiftOp, amount, static_cast<int32>(k64BitSize));
+  }
+  if (replaceOp == MOP_undef) {
+    return;
+  }
+
+  Insn *replaceUseInsn = nullptr;
+  Operand &firstOpnd = use.GetOperand(kInsnFirstOpnd);
+  Operand *secondOpnd = &use.GetOperand(kInsnSecondOpnd);
+  if (replaceIdx == kInsnSecondOpnd) { /* replace neg insn */
+    secondOpnd = &def.GetOperand(kInsnSecondOpnd);
+    replaceUseInsn = &cgFunc.GetInsnBuilder()->BuildInsn(replaceOp, firstOpnd, *secondOpnd, *shiftOpnd);
+  } else {
+    Operand &thirdOpnd = def.GetOperand(kInsnSecondOpnd);
+    replaceUseInsn = &cgFunc.GetInsnBuilder()->BuildInsn(replaceOp, firstOpnd, *secondOpnd, thirdOpnd, *shiftOpnd);
+  }
+  use.GetBB()->ReplaceInsn(use, *replaceUseInsn);
+  if (GLOBAL_DUMP) {
+    LogInfo::MapleLogger() << ">>>>>>> In ExtendShiftOptPattern : <<<<<<<\n";
+    LogInfo::MapleLogger() << "=======ReplaceInsn :\n";
+    use.Dump();
+    LogInfo::MapleLogger() << "=======NewInsn :\n";
+    replaceUseInsn->Dump();
+  }
+  if (removeDefInsn) {
+    if (GLOBAL_DUMP) {
+      LogInfo::MapleLogger() << ">>>>>>> In ExtendShiftOptPattern : <<<<<<<\n";
+      LogInfo::MapleLogger() << "=======RemoveDefInsn :\n";
+      defInsn->Dump();
+    }
+    defInsn->GetBB()->RemoveInsn(*defInsn);
+  }
+  cgFunc.GetRD()->InitGenUse(*defInsn->GetBB(), false);
+  cgFunc.GetRD()->UpdateInOut(*use.GetBB(), true);
+  newInsn = replaceUseInsn;
+  optSuccess = true;
+}
+
+/*
+ * pattern1:
+ * UXTB/UXTW X0, W1              <---- def x0
+ * ....                          <---- (X0 not used)
+ * AND/SUB/EOR X0, X1, X0        <---- use x0
+ * ======>
+ * AND/SUB/EOR X0, X1, W1 UXTB/UXTW
+ *
+ * pattern2:
+ * LSL/LSR X0, X1, #8
+ * ....(X0 not used)
+ * AND/SUB/EOR X0, X1, X0
+ * ======>
+ * AND/SUB/EOR X0, X1, X1 LSL/LSR #8
+ */
+void ExtendShiftOptPattern::Optimize(Insn &insn) {
+  uint32 amount = 0;
+  uint32 offset = 0;
+  uint32 lastIdx = insn.GetOperandSize() - k1BitSize;
+  Operand &lastOpnd = insn.GetOperand(lastIdx);
+  if (lastOpnd.IsOpdShift()) {
+    BitShiftOperand &lastShiftOpnd = static_cast<BitShiftOperand&>(lastOpnd);
+    amount = lastShiftOpnd.GetShiftAmount();
+  } else if (lastOpnd.IsOpdExtend()) {
+    ExtendShiftOperand &lastExtendOpnd = static_cast<ExtendShiftOperand&>(lastOpnd);
+    amount = lastExtendOpnd.GetShiftAmount();
+  }
+  if (shiftOp != BitShiftOperand::kUndef) {
+    ImmOperand &immOpnd = static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+    offset = static_cast<uint32>(immOpnd.GetValue());
+  }
+  amount += offset;
+
+  ReplaceUseInsn(insn, *defInsn, amount);
+}
+
+void ExtendShiftOptPattern::DoExtendShiftOpt(Insn &insn) {
+  Init();
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  Optimize(insn);
+  if (optSuccess) {
+    DoExtendShiftOpt(*newInsn);
+  }
+}
+
+/* check and set:
+ * exMOpType, lsMOpType, extendOp, shiftOp, defInsn
+ */
+bool ExtendShiftOptPattern::CheckCondition(Insn &insn) {
+  SetLsMOpType(insn);
+  SetExMOpType(insn);
+  MOperator mOp = insn.GetMachineOpcode();
+  if ((exMOpType == kExUndef) && (lsMOpType == kLsUndef)) {
+    return false;
+  }
+  RegOperand &regOperand = static_cast<RegOperand&>(insn.GetOperand(replaceIdx));
+  if (regOperand.IsPhysicalRegister()) {
+    return false;
+  }
+  regno_t regNo = regOperand.GetRegisterNumber();
+  InsnSet regDefInsnSet = cgFunc.GetRD()->FindDefForRegOpnd(insn, regNo, true);
+  Operand &firstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  Operand &secondOpnd = insn.GetOperand(kInsnSecondOpnd);
+  if (firstOpnd.GetSize() != secondOpnd.GetSize() && (mOp == MOP_xcmprr || mOp == MOP_xcmnrr)) {
+    return false;
+  }
+  if (regDefInsnSet.size() != k1BitSize) {
+    return false;
+  }
+  defInsn = *regDefInsnSet.begin();
+  CHECK_FATAL((defInsn != nullptr), "defInsn is null!");
+
+  SelectExtendOrShift(*defInsn);
+  /* defInsn must be shift or extend */
+  if ((extendOp == ExtendShiftOperand::kUndef) && (shiftOp == BitShiftOperand::kUndef)) {
+    return false;
+  }
+  return CheckDefUseInfo(insn, regOperand.GetSize());
+}
+
+void ExtendShiftOptPattern::Init() {
+  replaceOp = MOP_undef;
+  extendOp = ExtendShiftOperand::kUndef;
+  shiftOp = BitShiftOperand::kUndef;
+  defInsn = nullptr;
+  replaceIdx = kInsnThirdOpnd;
+  newInsn = nullptr;
+  optSuccess = false;
+  removeDefInsn = false;
+  exMOpType = kExUndef;
+  lsMOpType = kLsUndef;
+}
+
+void ExtendShiftOptPattern::Run() {
+  if (!cgFunc.GetMirModule().IsCModule()) {
+    return;
+  }
+  FOR_ALL_BB_REV(bb, &cgFunc) {
+    FOR_BB_INSNS_REV(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      DoExtendShiftOpt(*insn);
+    }
+  }
+}
+
+void ExtenToMovPattern::Run() {
+  if (!cgFunc.GetMirModule().IsCModule()) {
+    return;
+  }
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+/* Check for Implicit uxtw */
+bool ExtenToMovPattern::CheckHideUxtw(const Insn &insn, regno_t regno) const {
+  const InsnDesc *md = &AArch64CG::kMd[insn.GetMachineOpcode()];
+  if (md->IsMove()) {
+    return false;
+  }
+  uint32 optSize = insn.GetOperandSize();
+  for (uint32 i = 0; i < optSize; ++i) {
+    if (regno == static_cast<RegOperand&>(insn.GetOperand(i)).GetRegisterNumber()) {
+      auto *curOpndDescription = md->GetOpndDes(i);
+      if (curOpndDescription->IsDef() && curOpndDescription->GetSize() == k32BitSize) {
+        return true;
+      }
+      break;
+    }
+  }
+  return false;
+}
+
+bool ExtenToMovPattern::CheckUxtw(Insn &insn) {
+  if (insn.GetOperand(kInsnFirstOpnd).GetSize() == k64BitSize &&
+      insn.GetOperand(kInsnSecondOpnd).GetSize() == k32BitSize) {
+    ASSERT(insn.GetOperand(kInsnSecondOpnd).IsRegister(), "is not Register");
+    regno_t regno = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetRegisterNumber();
+    InsnSet preDef = cgFunc.GetRD()->FindDefForRegOpnd(insn, kInsnSecondOpnd, false);
+    if (preDef.empty()) {
+      return false;
+    }
+    for (auto defInsn : preDef) {
+      if (!CheckHideUxtw(*defInsn, regno)) {
+        return false;
+      }
+    }
+    replaceMop = MOP_xmovrr_uxtw;
+    return true;
+  }
+  return false;
+}
+
+bool ExtenToMovPattern::CheckSrcReg(Insn &insn, regno_t srcRegNo, uint32 validNum, std::vector<Insn *> &checkedInsns) {
+  InsnSet srcDefSet = cgFunc.GetRD()->FindDefForRegOpnd(insn, srcRegNo, true);
+  for (auto defInsn : srcDefSet) {
+    /* Skip checked instructions */
+    if (std::find(checkedInsns.begin(), checkedInsns.end(), defInsn) != checkedInsns.end()) {
+      continue;
+    }
+    checkedInsns.push_back(defInsn);
+
+    CHECK_FATAL((defInsn != nullptr), "defInsn is null!");
+    /* for loop, def insn might be the same insn */
+    if (defInsn == &insn) {
+      continue;
+    }
+    MOperator mOp = defInsn->GetMachineOpcode();
+    switch (mOp) {
+      case MOP_wiorrri12:
+      case MOP_weorrri12: {
+        /* check immVal if mop is OR */
+        ImmOperand &imm = static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        auto bitNum = static_cast<uint32>(imm.GetValue());
+        if ((bitNum >> validNum) != 0) {
+          return false;
+        }
+      }
+      case MOP_wandrri12: {
+        /* check defSrcReg */
+        RegOperand &defSrcRegOpnd = static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd));
+        regno_t defSrcRegNo = defSrcRegOpnd.GetRegisterNumber();
+        if (!CheckSrcReg(*defInsn, defSrcRegNo, validNum, checkedInsns)) {
+          return false;
+        }
+        break;
+      }
+      case MOP_wandrrr: {
+        /* check defSrcReg */
+        RegOperand &defSrcRegOpnd1 = static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd));
+        RegOperand &defSrcRegOpnd2 = static_cast<RegOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        regno_t defSrcRegNo1 = defSrcRegOpnd1.GetRegisterNumber();
+        regno_t defSrcRegNo2 = defSrcRegOpnd2.GetRegisterNumber();
+        if (!CheckSrcReg(*defInsn, defSrcRegNo1, validNum, checkedInsns) &&
+            !CheckSrcReg(*defInsn, defSrcRegNo2, validNum, checkedInsns)) {
+          return false;
+        }
+        break;
+      }
+      case MOP_wiorrrr:
+      case MOP_weorrrr: {
+        /* check defSrcReg */
+        RegOperand &defSrcRegOpnd1 = static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd));
+        RegOperand &defSrcRegOpnd2 = static_cast<RegOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        regno_t defSrcRegNo1 = defSrcRegOpnd1.GetRegisterNumber();
+        regno_t defSrcRegNo2 = defSrcRegOpnd2.GetRegisterNumber();
+        if (!CheckSrcReg(*defInsn, defSrcRegNo1, validNum, checkedInsns) ||
+            !CheckSrcReg(*defInsn, defSrcRegNo2, validNum, checkedInsns)) {
+          return false;
+        }
+        break;
+      }
+      case MOP_wldrb: {
+        if (validNum != k8BitSize) {
+          return false;
+        }
+        break;
+      }
+      case MOP_wldrh: {
+        if (validNum != k16BitSize) {
+          return false;
+        }
+        break;
+      }
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+
+bool ExtenToMovPattern::BitNotAffected(Insn &insn, uint32 validNum) {
+  RegOperand &firstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  RegOperand &secondOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  regno_t desRegNo = firstOpnd.GetRegisterNumber();
+  regno_t srcRegNo = secondOpnd.GetRegisterNumber();
+  InsnSet desDefSet = cgFunc.GetRD()->FindDefForRegOpnd(insn, desRegNo, true);
+  /* desReg is not redefined */
+  if (!desDefSet.empty()) {
+    return false;
+  }
+  std::vector<Insn *> checkedInsns;
+  if (!CheckSrcReg(insn, srcRegNo, validNum, checkedInsns)) {
+    return false;
+  }
+  replaceMop = MOP_wmovrr;
+  return true;
+}
+
+bool ExtenToMovPattern::CheckCondition(Insn &insn) {
+  MOperator mOp = insn.GetMachineOpcode();
+  switch (mOp) {
+    case MOP_xuxtw64: return CheckUxtw(insn);
+    case MOP_xuxtb32: return BitNotAffected(insn, k8BitSize);
+    case MOP_xuxth32: return BitNotAffected(insn, k16BitSize);
+    default: return false;
+  }
+}
+
+/* No initialization required */
+void ExtenToMovPattern::Init() {
+  replaceMop = MOP_undef;
+}
+
+void ExtenToMovPattern::Optimize(Insn &insn) {
+  insn.SetMOP(AArch64CG::kMd[replaceMop]);
+}
+
+void SameDefPattern::Run() {
+  FOR_ALL_BB_REV(bb, &cgFunc) {
+    FOR_BB_INSNS_REV(insn, bb) {
+      if (!CheckCondition(*insn) || !bb->GetEhPreds().empty()) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+void SameDefPattern::Init() {
+  currInsn = nullptr;
+  sameInsn = nullptr;
+}
+
+bool SameDefPattern::CheckCondition(Insn &insn) {
+  MOperator mOp = insn.GetMachineOpcode();
+  if (insn.GetBB()->GetPreds().size() > k1BitSize) {
+    return false;
+  }
+  if (insn.GetBB()->HasCall()) {
+    return false;
+  }
+  return (mOp == MOP_wcmprr) || (mOp == MOP_xcmprr) || (mOp == MOP_xwcmprre) || (mOp == MOP_xcmprrs);
+}
+
+void SameDefPattern::Optimize(Insn &insn) {
+  InsnSet sameDefSet = cgFunc.GetRD()->FindDefForRegOpnd(insn, 0, false);
+  if (sameDefSet.size() != k1BitSize) {
+    return;
+  }
+  Insn *sameDefInsn = *sameDefSet.begin();
+  if (sameDefInsn == nullptr) {
+    return;
+  }
+  currInsn = &insn;
+  sameInsn = sameDefInsn;
+  if (!IsSameDef()) {
+    return;
+  }
+  if (GLOBAL_DUMP) {
+    LogInfo::MapleLogger() << ">>>>>>> In SameDefPattern : <<<<<<<\n";
+    LogInfo::MapleLogger() << "=======remove insn: \n";
+    insn.Dump();
+    LogInfo::MapleLogger() << "=======sameDef insn: \n";
+    sameDefInsn->Dump();
+  }
+  insn.GetBB()->RemoveInsn(insn);
+}
+
+bool SameDefPattern::IsSameDef() {
+  if (!CheckCondition(*sameInsn)) {
+    return false;
+  }
+  if (currInsn == sameInsn) {
+    return false;
+  }
+  if (currInsn->GetMachineOpcode() != sameInsn->GetMachineOpcode()) {
+    return false;
+  }
+  for (uint32 i = k1BitSize; i < currInsn->GetOperandSize(); ++i) {
+    Operand &opnd0 = currInsn->GetOperand(i);
+    Operand &opnd1 = sameInsn->GetOperand(i);
+    if (!IsSameOperand(opnd0, opnd1)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SameDefPattern::IsSameOperand(Operand &opnd0, Operand &opnd1) {
+  if (opnd0.IsRegister()) {
+    CHECK_FATAL(opnd1.IsRegister(), "must be RegOperand!");
+    RegOperand &regOpnd0 = static_cast<RegOperand&>(opnd0);
+    RegOperand &regOpnd1 = static_cast<RegOperand&>(opnd1);
+    if (!RegOperand::IsSameReg(regOpnd0, regOpnd1)) {
+      return false;
+    }
+    regno_t regNo = regOpnd0.GetRegisterNumber();
+    /* src reg not redefined between sameInsn and currInsn */
+    if (SrcRegIsRedefined(regNo)) {
+      return false;
+    }
+  } else if (opnd0.IsOpdShift()) {
+    CHECK_FATAL(opnd1.IsOpdShift(), "must be ShiftOperand!");
+    BitShiftOperand &shiftOpnd0 = static_cast<BitShiftOperand&>(opnd0);
+    BitShiftOperand &shiftOpnd1 = static_cast<BitShiftOperand&>(opnd1);
+    if (shiftOpnd0.GetShiftAmount() != shiftOpnd1.GetShiftAmount()) {
+      return false;
+    }
+  } else if (opnd0.IsOpdExtend()) {
+    CHECK_FATAL(opnd1.IsOpdExtend(), "must be ExtendOperand!");
+    ExtendShiftOperand &extendOpnd0 = static_cast<ExtendShiftOperand&>(opnd0);
+    ExtendShiftOperand &extendOpnd1 = static_cast<ExtendShiftOperand&>(opnd1);
+    if (extendOpnd0.GetShiftAmount() != extendOpnd1.GetShiftAmount()) {
+      return false;
+    }
+  } else {
+    return false;
+  }
+  return true;
+}
+
+bool SameDefPattern::SrcRegIsRedefined(regno_t regNo) {
+  AArch64ReachingDefinition *a64RD = static_cast<AArch64ReachingDefinition*>(cgFunc.GetRD());
+  if (currInsn->GetBB() == sameInsn->GetBB()) {
+    FOR_BB_INSNS(insn, currInsn->GetBB()) {
+      if (insn->GetMachineOpcode() == MOP_xbl) {
+        return true;
+      }
+    }
+    if (!a64RD->FindRegDefBetweenInsn(regNo, sameInsn, currInsn).empty()) {
+      return true;
+    }
+  } else if (a64RD->HasRegDefBetweenInsnGlobal(regNo, *sameInsn, *currInsn)) {
+    return true;
+  }
+  return false;
+}
+
+void AndCbzPattern::Init() {
+  prevInsn = nullptr;
+}
+
+bool AndCbzPattern::IsAdjacentArea(Insn &prev, Insn &curr) const {
+  if (prev.GetBB() == curr.GetBB()) {
+    return true;
+  }
+  for (auto *succ : prev.GetBB()->GetSuccs()) {
+    if (succ == curr.GetBB()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AndCbzPattern::CheckCondition(Insn &insn) {
+  auto *aar64RD = static_cast<AArch64ReachingDefinition*>(cgFunc.GetRD());
+  MOperator mOp = insn.GetMachineOpcode();
+  if ((mOp != MOP_wcbz) && (mOp != MOP_xcbz) && (mOp != MOP_wcbnz) && (mOp != MOP_xcbnz)) {
+    return false;
+  }
+  regno_t regNo = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd)).GetRegisterNumber();
+  InsnSet defSet = cgFunc.GetRD()->FindDefForRegOpnd(insn, regNo, true);
+  if (defSet.size() != k1BitSize) {
+    return false;
+  }
+  prevInsn = *defSet.begin();
+  if (prevInsn->GetMachineOpcode() != MOP_wandrri12 && prevInsn->GetMachineOpcode() != MOP_xandrri13) {
+    return false;
+  }
+  if (!IsAdjacentArea(*prevInsn, insn)) {
+    return false;
+  }
+  regno_t propRegNo = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd)).GetRegisterNumber();
+  if (prevInsn->GetBB() == insn.GetBB() && !(aar64RD->FindRegDefBetweenInsn(propRegNo, prevInsn, &insn).empty())) {
+    return false;
+  }
+  if (prevInsn->GetBB() != insn.GetBB() && aar64RD->HasRegDefBetweenInsnGlobal(propRegNo, *prevInsn, insn)) {
+    return false;
+  }
+  if (!(cgFunc.GetRD()->FindUseForRegOpnd(insn, regNo, true).empty())) {
+    return false;
+  }
+  return true;
+}
+
+int64 AndCbzPattern::CalculateLogValue(int64 val) const {
+  return (__builtin_popcountll(static_cast<uint64>(val)) == 1) ? (__builtin_ffsll(val) - 1) : -1;
+}
+
+void AndCbzPattern::Optimize(Insn &insn) {
+  BB *bb = insn.GetBB();
+  auto &aarchFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  auto &andImm = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+  int64 tbzVal = CalculateLogValue(andImm.GetValue());
+  if (tbzVal < 0) {
+    return;
+  }
+  MOperator mOp = insn.GetMachineOpcode();
+  MOperator newMop = MOP_undef;
+  switch (mOp) {
+    case MOP_wcbz:
+      newMop = MOP_wtbz;
+      break;
+    case MOP_wcbnz:
+      newMop = MOP_wtbnz;
+      break;
+    case MOP_xcbz:
+      newMop = MOP_xtbz;
+      break;
+    case MOP_xcbnz:
+      newMop = MOP_xtbnz;
+      break;
+    default:
+      CHECK_FATAL(false, "must be cbz/cbnz");
+      break;
+  }
+  auto &label = static_cast<LabelOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  ImmOperand &tbzImm = aarchFunc.CreateImmOperand(tbzVal, k8BitSize, false);
+  Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(newMop, prevInsn->GetOperand(kInsnSecondOpnd), tbzImm, label);
+  newInsn.SetId(insn.GetId());
+  bb->ReplaceInsn(insn, newInsn);
+  if (GLOBAL_DUMP) {
+    LogInfo::MapleLogger() << ">>>>>>> In AndCbzPattern : <<<<<<<\n";
+    LogInfo::MapleLogger() << "=======PrevInsn :\n";
+    LogInfo::MapleLogger() << "=======ReplaceInsn :\n";
+    insn.Dump();
+    LogInfo::MapleLogger() << "=======NewInsn :\n";
+    newInsn.Dump();
+  }
+  cgFunc.GetRD()->UpdateInOut(*bb, true);
+}
+
+void AndCbzPattern::Run() {
+  Init();
+  FOR_ALL_BB_REV(bb, &cgFunc) {
+    FOR_BB_INSNS_REV(insn, bb) {
+      if (!insn->IsMachineInstruction() || !CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+void SameRHSPropPattern::Init() {
+  prevInsn = nullptr;
+  candidates = {MOP_waddrri12, MOP_xaddrri12, MOP_wsubrri12, MOP_xsubrri12,
+                MOP_wmovri32, MOP_xmovri64, MOP_wmovrr, MOP_xmovrr};
+}
+
+bool SameRHSPropPattern::IsSameOperand(Operand *opnd1, Operand *opnd2) const {
+  if (opnd1 == nullptr && opnd2 == nullptr) {
+    return true;
+  } else if (opnd1 == nullptr || opnd2 == nullptr) {
+    return false;
+  }
+  if (opnd1->IsRegister() && opnd2->IsRegister()) {
+    return RegOperand::IsSameReg(*opnd1, *opnd2);
+  } else if (opnd1->IsImmediate() && opnd2->IsImmediate()) {
+    auto *immOpnd1 = static_cast<ImmOperand*>(opnd1);
+    auto *immOpnd2 = static_cast<ImmOperand*>(opnd2);
+    return (immOpnd1->GetSize() == immOpnd2->GetSize()) && (immOpnd1->GetValue() == immOpnd2->GetValue());
+  }
+  return false;
+}
+
+bool SameRHSPropPattern::FindSameRHSInsnInBB(Insn &insn) {
+  uint32 opndNum = insn.GetOperandSize();
+  Operand *curRegOpnd = nullptr;
+  Operand *curImmOpnd = nullptr;
+  for (uint32 i = 0; i < opndNum; ++i) {
+    if (insn.OpndIsDef(i)) {
+      continue;
+    }
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsRegister()) {
+      curRegOpnd = &opnd;
+    } else if (opnd.IsImmediate()) {
+      auto &immOpnd = static_cast<ImmOperand&>(opnd);
+      if (immOpnd.GetVary() == kUnAdjustVary) {
+        return false;
+      }
+      curImmOpnd = &opnd;
+    }
+  }
+  if (curRegOpnd == nullptr && curImmOpnd != nullptr && static_cast<ImmOperand*>(curImmOpnd)->IsZero()) {
+    return false;
+  }
+  BB *bb = insn.GetBB();
+  for (auto *cursor = insn.GetPrev(); cursor != nullptr && cursor != bb->GetFirstInsn(); cursor = cursor->GetPrev()) {
+    if (!cursor->IsMachineInstruction()) {
+      continue;
+    }
+    if (cursor->IsCall() && !cgFunc.IsAfterRegAlloc()) {
+      return false;
+    }
+    if (cursor->GetMachineOpcode() != insn.GetMachineOpcode()) {
+      continue;
+    }
+    uint32 candOpndNum = cursor->GetOperandSize();
+    Operand *candRegOpnd = nullptr;
+    Operand *candImmOpnd = nullptr;
+    for (uint32 i = 0; i < candOpndNum; ++i) {
+      Operand &opnd = cursor->GetOperand(i);
+      if (cursor->OpndIsDef(i)) {
+        continue;
+      }
+      if (opnd.IsRegister()) {
+        candRegOpnd = &opnd;
+      } else if (opnd.IsImmediate()) {
+        auto &immOpnd = static_cast<ImmOperand&>(opnd);
+        if (immOpnd.GetVary() == kUnAdjustVary) {
+          return false;
+        }
+        candImmOpnd = &opnd;
+      }
+    }
+    if (IsSameOperand(curRegOpnd, candRegOpnd) && IsSameOperand(curImmOpnd, candImmOpnd)) {
+      prevInsn = cursor;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool SameRHSPropPattern::CheckCondition(Insn &insn) {
+  if (!insn.IsMachineInstruction()) {
+    return false;
+  }
+  MOperator mOp = insn.GetMachineOpcode();
+  if (std::find(candidates.begin(), candidates.end(), mOp) == candidates.end()) {
+    return false;
+  }
+  if (!FindSameRHSInsnInBB(insn)) {
+    return false;
+  }
+  CHECK_FATAL(prevInsn->GetOperand(kInsnFirstOpnd).IsRegister(), "prevInsn first operand must be register");
+  if (static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd)).GetRegisterNumber() == R16) {
+    return false;
+  }
+  if (prevInsn->GetOperand(kInsnSecondOpnd).IsRegister() &&
+      RegOperand::IsSameReg(prevInsn->GetOperand(kInsnFirstOpnd), prevInsn->GetOperand(kInsnSecondOpnd))) {
+    return false;
+  }
+  uint32 opndNum = prevInsn->GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = prevInsn->GetOperand(i);
+    if (!opnd.IsRegister()) {
+      continue;
+    }
+    regno_t regNO = static_cast<RegOperand&>(opnd).GetRegisterNumber();
+    if (!(cgFunc.GetRD()->FindRegDefBetweenInsn(regNO, prevInsn->GetNext(), insn.GetPrev()).empty())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void SameRHSPropPattern::Optimize(Insn &insn) {
+  BB *bb = insn.GetBB();
+  Operand &destOpnd = insn.GetOperand(kInsnFirstOpnd);
+  uint32 bitSize = static_cast<RegOperand&>(destOpnd).GetSize();
+  MOperator mOp = (bitSize == k64BitSize ? MOP_xmovrr : MOP_wmovrr);
+  Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, destOpnd, prevInsn->GetOperand(kInsnFirstOpnd));
+  newInsn.SetId(insn.GetId());
+  bb->ReplaceInsn(insn, newInsn);
+  if (GLOBAL_DUMP) {
+    LogInfo::MapleLogger() << ">>>>>>> In SameRHSPropPattern : <<<<<<<\n";
+    LogInfo::MapleLogger() << "=======PrevInsn :\n";
+    LogInfo::MapleLogger() << "======= ReplaceInsn :\n";
+    insn.Dump();
+    LogInfo::MapleLogger() << "======= NewInsn :\n";
+    newInsn.Dump();
+  }
+  cgFunc.GetRD()->UpdateInOut(*bb, true);
+}
+
+void SameRHSPropPattern::Run() {
+  Init();
+  FOR_ALL_BB_REV(bb, &cgFunc) {
+    FOR_BB_INSNS_REV(insn, bb) {
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+bool ContinuousLdrPattern::IsMopMatch(const Insn &insn) {
+  auto mop = insn.GetMachineOpcode();
+  return mop == MOP_wldrh || mop == MOP_wldr || mop == MOP_xldr;
+}
+
+bool ContinuousLdrPattern::IsUsedBySameCall(Insn &insn1, Insn &insn2, Insn &insn3) const {
+  auto &reg1 = static_cast<RegOperand &>(insn1.GetOperand(kFirstOpnd));
+  auto &&usesite1 = cgFunc.GetRD()->FindUseForRegOpnd(insn1, reg1.GetRegisterNumber(), true);
+  if (usesite1.size() != 1 || !((*usesite1.begin())->IsCall() || (*usesite1.begin())->IsTailCall())) {
+    return false;
+  }
+  auto &reg2 = static_cast<RegOperand &>(insn2.GetOperand(kFirstOpnd));
+  auto &&usesite2 = cgFunc.GetRD()->FindUseForRegOpnd(insn2, reg2.GetRegisterNumber(), true);
+  if (usesite2.size() != 1 || !((*usesite2.begin())->IsCall() || (*usesite1.begin())->IsTailCall())) {
+    return false;
+  }
+  auto &reg3 = static_cast<RegOperand &>(insn3.GetOperand(kFirstOpnd));
+  auto &&usesite3 = cgFunc.GetRD()->FindUseForRegOpnd(insn3, reg3.GetRegisterNumber(), true);
+  if (usesite3.size() != 1 || !((*usesite3.begin())->IsCall() || (*usesite3.begin())->IsTailCall())) {
+    return false;
+  }
+  return (*usesite1.begin())->GetId() == (*usesite2.begin())->GetId() && (*usesite3.begin())->GetId();
+}
+
+bool ContinuousLdrPattern::IsMemValid(const MemOperand &memopnd) {
+  return memopnd.GetAddrMode() == MemOperand::kAddrModeBOi && memopnd.GetIndexOpt() == MemOperand::kIntact;
+}
+
+bool ContinuousLdrPattern::IsImmValid(MOperator mop, const ImmOperand &imm) {
+  return AArch64CG::kMd[mop].IsValidImmOpnd(imm.GetValue());
+}
+
+int64 ContinuousLdrPattern::GetMemOffsetValue(const Insn &insn) {
+  return static_cast<MemOperand &>(insn.GetOperand(kSecondOpnd)).GetOffsetOperand()->GetValue();
+}
+
+bool ContinuousLdrPattern::CheckCondition(Insn &insn) {
+  if (!IsMopMatch(insn)) {
+    return false;
+  }
+  // merge the three adjacent ldr insns
+  insnList.clear();
+  insnList.push_back(&insn);
+  auto prevInsn = insn.GetPrev();
+  if (!prevInsn || !IsMopMatch(*prevInsn)) {
+    return false;
+  }
+  insnList.push_back(prevInsn);
+  auto prevPrevInsn = prevInsn->GetPrev();
+  if (!prevPrevInsn || !IsMopMatch(*prevPrevInsn)) {
+    return false;
+  }
+  insnList.push_back(prevPrevInsn);
+  if (!IsUsedBySameCall(insn, *prevInsn, *prevPrevInsn)) {
+    return false;
+  }
+
+  auto &currMem = static_cast<MemOperand &>(insn.GetOperand(kSecondOpnd));
+  auto &prevMem = static_cast<MemOperand &>(prevInsn->GetOperand(kSecondOpnd));
+  auto &prevPrevMem = static_cast<MemOperand &>(prevPrevInsn->GetOperand(kSecondOpnd));
+  if (!IsMemValid(currMem) || !IsMemValid(prevMem) || !IsMemValid(prevPrevMem)) {
+    return false;
+  }
+  auto baseRegNumOfCurr = currMem.GetBaseRegister()->GetRegisterNumber();
+  auto baseRegNumOfPrev = prevMem.GetBaseRegister()->GetRegisterNumber();
+  auto baseRegNumOfPrevPrev = prevPrevMem.GetBaseRegister()->GetRegisterNumber();
+  if (baseRegNumOfCurr != baseRegNumOfPrev || baseRegNumOfCurr != baseRegNumOfPrevPrev) {
+    return false;
+  }
+
+  return true;
+}
+
+void ContinuousLdrPattern::Optimize(Insn &insn) {
+  auto bb = insn.GetBB();
+  auto &aarch64CGFunc = static_cast<AArch64CGFunc &>(cgFunc);
+
+  // sort ldr insns by offset value of insn's memopnd
+  std::sort(insnList.begin(), insnList.end(),
+            [](const Insn *insn1, const Insn *insn2) { return GetMemOffsetValue(*insn1) < GetMemOffsetValue(*insn2); });
+
+  auto currMop = insnList[1]->GetMachineOpcode();
+  Insn *currInsn = nullptr;
+  Insn *prevInsn = nullptr;
+  Insn *extraInsn = nullptr;
+
+  // the two adjacent insns's mop should be same (all equals to ldrh)
+  // assign the second ldrh to currInsn, another to prevInsn
+  // and extraInsn will be ldr
+  if (insnList[0]->GetMachineOpcode() == insnList[1]->GetMachineOpcode()) {
+    currInsn = insnList[1];
+    prevInsn = insnList[0];
+    extraInsn = insnList[2];
+  } else if (insnList[1]->GetMachineOpcode() == insnList[2]->GetMachineOpcode()) {
+    currInsn = insnList[2];
+    prevInsn = insnList[1];
+    extraInsn = insnList[0];
+  } else {
+    return;
+  }
+
+  auto offset = GetMemOffsetValue(*currInsn) - GetMemOffsetValue(*prevInsn);
+  auto extraOffset = GetMemOffsetValue(*extraInsn) - GetMemOffsetValue(*prevInsn);
+  MOperator mop = MOP_undef;
+  MOperator ubfx = MOP_undef;
+  ImmOperand *imm;
+  if (currMop == MOP_wldrh && offset == k2ByteSize) {
+    if (abs(extraOffset) == k4ByteSize) {
+      imm = &aarch64CGFunc.CreateImmOperand(k16BitSize, k5BitSize, false);
+      mop = MOP_wldp;
+      ubfx = MOP_wubfxrri5i5;
+    } else if (abs(extraOffset) == k8ByteSize) {
+      imm = &aarch64CGFunc.CreateImmOperand(k16BitSize, k6BitSize, false);
+      mop = MOP_xldp;
+      ubfx = MOP_xubfxrri6i6;
+    } else {
+      return;
+    }
+  } else {
+    return;
+  }
+
+  // ldpRt1's first opnd will be the first opnd of ldp, and second opnd will be ldp's MemOperannd
+  // ldpRt2's first opnd will be ldp's second opnd
+  Insn *ldpRt1 = prevInsn;
+  Insn *ldpRt2 = extraInsn;
+  if (extraOffset < 0) {
+    std::swap(ldpRt1, ldpRt2);
+  }
+
+  if (IsImmValid(mop, *static_cast<MemOperand &>(ldpRt1->GetOperand(kSecondOpnd)).GetOffsetOperand())) {
+    auto &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(mop, ldpRt1->GetOperand(kFirstOpnd),
+                                                       ldpRt2->GetOperand(kFirstOpnd), ldpRt1->GetOperand(kSecondOpnd));
+    auto &ubfxInsn = cgFunc.GetInsnBuilder()->BuildInsn(ubfx, currInsn->GetOperand(kFirstOpnd),
+                                                        prevInsn->GetOperand(kFirstOpnd), *imm, *imm);
+    newInsn.SetId(insn.GetPrev()->GetId());
+    bb->ReplaceInsn(*insn.GetPrev(), newInsn);
+    ubfxInsn.SetId(insn.GetId());
+    bb->ReplaceInsn(insn, ubfxInsn);
+    bb->RemoveInsn(*insn.GetPrev()->GetPrev());
+    cgFunc.GetRD()->UpdateInOut(*bb, true);
+    return;
+  }
+
+  cgFunc.GetRD()->UpdateInOut(*bb, true);
+}
+
+void ContinuousLdrPattern::Run() {
+  if (!cgFunc.GetMirModule().IsCModule()) {
+    return;
+  }
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_ico.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ico.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..ff286bc10b42539fdb9aeec4e4d38d3e87377444
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ico.cpp
@@ -0,0 +1,1229 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_ico.h"
+#include "ico.h"
+#include "cg.h"
+#include "cg_option.h"
+#include "aarch64_isa.h"
+#include "aarch64_insn.h"
+#include "aarch64_cgfunc.h"
+
+/*
+ * This phase implements if-conversion optimization,
+ * which tries to convert conditional branches into cset/csel instructions
+ */
+namespace maplebe {
+void AArch64IfConversionOptimizer::InitOptimizePatterns() {
+  singlePassPatterns.emplace_back(memPool->New<AArch64ICOIfThenElsePattern>(*cgFunc));
+  singlePassPatterns.emplace_back(memPool->New<AArch64ICOSameCondPattern>(*cgFunc));
+  singlePassPatterns.emplace_back(memPool->New<AArch64ICOMorePredsPattern>(*cgFunc));
+}
+
+/* build ccmp Insn */
+Insn *AArch64ICOPattern::BuildCcmpInsn(ConditionCode ccCode, const Insn *cmpInsn) const {
+  Operand &opnd0 = cmpInsn->GetOperand(kInsnFirstOpnd);
+  Operand &opnd1 = cmpInsn->GetOperand(kInsnSecondOpnd);
+  Operand &opnd2 = cmpInsn->GetOperand(kInsnThirdOpnd);
+  /* ccmp has only int opnd */
+  if (!static_cast<RegOperand&>(opnd1).IsOfIntClass()) {
+    return nullptr;
+  }
+  AArch64CGFunc *func = static_cast<AArch64CGFunc*>(cgFunc);
+  uint32 nzcv = GetNZCV(ccCode, false);
+  if (nzcv == k16BitSize) {
+    return nullptr;
+  }
+  ImmOperand &opnd3 = func->CreateImmOperand(PTY_u8, nzcv);
+  CondOperand &cond = static_cast<AArch64CGFunc *>(cgFunc)->GetCondOperand(ccCode);
+  uint32 dSize = opnd1.GetSize();
+  bool isIntTy = opnd2.IsIntImmediate();
+  MOperator mOpCode = isIntTy ? (dSize == k64BitSize ? MOP_xccmpriic : MOP_wccmpriic)
+                              : (dSize == k64BitSize ? MOP_xccmprric : MOP_wccmprric);
+  /* cmp opnd2 in the range 0-4095, ccmp opnd2 in the range 0-31 */
+  if (isIntTy && static_cast<RegOperand&>(opnd2).GetRegisterNumber() >= k32BitSize) {
+    return nullptr;
+  }
+  return &cgFunc->GetInsnBuilder()->BuildInsn(mOpCode, opnd0, opnd1, opnd2, opnd3, cond);
+}
+
+/* Rooted ccCode resource NZCV */
+uint32 AArch64ICOPattern::GetNZCV(ConditionCode ccCode, bool inverse) {
+  switch (ccCode) {
+    case CC_EQ:
+      return inverse ? k4BitSize : k0BitSize;
+    case CC_HS:
+      return inverse ? k2BitSize : k0BitSize;
+    case CC_MI:
+      return inverse ? k8BitSize : k0BitSize;
+    case CC_VS:
+      return inverse ? k1BitSize : k0BitSize;
+    case CC_VC:
+      return inverse ? k0BitSize : k1BitSize;
+    case CC_LS:
+      return inverse ? k4BitSize : k2BitSize;
+    case CC_LO:
+      return inverse ? k0BitSize : k2BitSize;
+    case CC_NE:
+      return inverse ? k0BitSize : k4BitSize;
+    case CC_HI:
+      return inverse ? k2BitSize : k4BitSize;
+    case CC_PL:
+      return inverse ? k0BitSize : k8BitSize;
+    default:
+      return k16BitSize;
+  }
+}
+
+Insn *AArch64ICOPattern::BuildCmpInsn(const Insn &condBr) const {
+  AArch64CGFunc *func = static_cast<AArch64CGFunc*>(cgFunc);
+  RegOperand &reg = static_cast<RegOperand&>(condBr.GetOperand(0));
+  PrimType ptyp = (reg.GetSize() == k64BitSize) ? PTY_u64 : PTY_u32;
+  ImmOperand &numZero = func->CreateImmOperand(ptyp, 0);
+  Operand &rflag = func->GetOrCreateRflag();
+  MOperator mopCode = (reg.GetSize() == k64BitSize) ? MOP_xcmpri : MOP_wcmpri;
+  Insn &cmpInsn = func->GetInsnBuilder()->BuildInsn(mopCode, rflag, reg, numZero);
+  return &cmpInsn;
+}
+
+bool AArch64ICOIfThenElsePattern::IsExpansionMOperator(const Insn &insn) const {
+  MOperator mOpCode = insn.GetMachineOpcode();
+  return mOpCode >= MOP_xuxtb32 && mOpCode <= MOP_xuxtw64;
+}
+
+bool AArch64ICOIfThenElsePattern::IsMovMOperator(const Insn &insn) const {
+  MOperator mOpCode = insn.GetMachineOpcode();
+  return mOpCode >= MOP_xmovrr && mOpCode <= MOP_xvmovd;
+}
+
+bool AArch64ICOIfThenElsePattern::IsShiftMOperator(const Insn &insn) const {
+  MOperator mOpCode = insn.GetMachineOpcode();
+  return mOpCode >= MOP_xlslrri6 && mOpCode <= MOP_wrorrrr;
+}
+
+bool AArch64ICOIfThenElsePattern::IsEorMOperator(const Insn &insn) const {
+  MOperator mOpCode = insn.GetMachineOpcode();
+  return (mOpCode >= MOP_xeorrrr && mOpCode <= MOP_weorrri12);
+}
+
+bool AArch64ICOIfThenElsePattern::Has2SrcOpndSetInsn(const Insn &insn) const {
+  return IsEorMOperator(insn) || IsShiftMOperator(insn) || cgFunc->GetTheCFG()->IsAddOrSubInsn(insn);
+}
+
+bool AArch64ICOIfThenElsePattern::IsSetInsnMOperator(const Insn &insn) const {
+  return IsExpansionMOperator(insn) || IsMovMOperator(insn) || Has2SrcOpndSetInsn(insn);
+}
+
+bool AArch64ICOIfThenElsePattern::IsSetInsn(const Insn &insn, Operand **dest, std::vector<Operand*> &src) const {
+  if (IsSetInsnMOperator(insn)) {
+    *dest = &(insn.GetOperand(0));
+    for (uint32 i = 1; i < insn.GetOperandSize(); ++i) {
+      (void)src.emplace_back(&(insn.GetOperand(i)));
+    }
+    return true;
+  }
+  *dest = nullptr;
+  src.clear();
+  return false;
+}
+
+ConditionCode AArch64ICOPattern::Encode(MOperator mOp, bool inverse) const {
+  switch (mOp) {
+    case MOP_bmi:
+      return inverse ? CC_PL : CC_MI;
+    case MOP_bvc:
+      return inverse ? CC_VS : CC_VC;
+    case MOP_bls:
+      return inverse ? CC_HI : CC_LS;
+    case MOP_blt:
+      return inverse ? CC_GE : CC_LT;
+    case MOP_ble:
+      return inverse ? CC_GT : CC_LE;
+    case MOP_bcs:
+      return inverse ? CC_CC : CC_CS;
+    case MOP_bcc:
+      return inverse ? CC_CS : CC_CC;
+    case MOP_beq:
+      return inverse ? CC_NE : CC_EQ;
+    case MOP_bne:
+      return inverse ? CC_EQ : CC_NE;
+    case MOP_blo:
+      return inverse ? CC_HS : CC_LO;
+    case MOP_bpl:
+      return inverse ? CC_MI : CC_PL;
+    case MOP_bhs:
+      return inverse ? CC_LO : CC_HS;
+    case MOP_bvs:
+      return inverse ? CC_VC : CC_VS;
+    case MOP_bhi:
+      return inverse ? CC_LS : CC_HI;
+    case MOP_bgt:
+      return inverse ? CC_LE : CC_GT;
+    case MOP_bge:
+      return inverse ? CC_LT : CC_GE;
+    case MOP_wcbnz:
+      return inverse ? CC_EQ : CC_NE;
+    case MOP_xcbnz:
+      return inverse ? CC_EQ : CC_NE;
+    case MOP_wcbz:
+      return inverse ? CC_NE : CC_EQ;
+    case MOP_xcbz:
+      return inverse ? CC_NE : CC_EQ;
+    default:
+      return kCcLast;
+  }
+}
+
+Insn *AArch64ICOPattern::BuildCondSet(const Insn &branch, RegOperand &reg, bool inverse) const {
+  ConditionCode ccCode = Encode(branch.GetMachineOpcode(), inverse);
+  ASSERT(ccCode != kCcLast, "unknown cond, ccCode can't be kCcLast");
+  AArch64CGFunc *func = static_cast<AArch64CGFunc*>(cgFunc);
+  CondOperand &cond = func->GetCondOperand(ccCode);
+  Operand &rflag = func->GetOrCreateRflag();
+  MOperator mopCode = (reg.GetSize() == k64BitSize) ? MOP_xcsetrc : MOP_wcsetrc;
+  return &func->GetInsnBuilder()->BuildInsn(mopCode, reg, cond, rflag);
+}
+
+Insn *AArch64ICOPattern::BuildCondSel(const Insn &branch, MOperator mOp, RegOperand &dst, RegOperand &src1,
+                                      RegOperand &src2) const {
+  ConditionCode ccCode = Encode(branch.GetMachineOpcode(), false);
+  ASSERT(ccCode != kCcLast, "unknown cond, ccCode can't be kCcLast");
+  CondOperand &cond = static_cast<AArch64CGFunc *>(cgFunc)->GetCondOperand(ccCode);
+  Operand &rflag = static_cast<AArch64CGFunc *>(cgFunc)->GetOrCreateRflag();
+  return &cgFunc->GetInsnBuilder()->BuildInsn(mOp, dst, src1, src2, cond, rflag);
+}
+
+void AArch64ICOIfThenElsePattern::GenerateInsnForImm(const Insn &branchInsn, Operand &ifDest, Operand &elseDest,
+                                                     RegOperand &destReg, std::vector<Insn*> &generateInsn) const {
+  ImmOperand &imm1 = static_cast<ImmOperand&>(ifDest);
+  ImmOperand &imm2 = static_cast<ImmOperand&>(elseDest);
+  bool inverse = imm1.IsZero() && imm2.IsOne();
+  if (inverse || (imm2.IsZero() && imm1.IsOne())) {
+    Insn *csetInsn = BuildCondSet(branchInsn, destReg, inverse);
+    ASSERT(csetInsn != nullptr, "build a insn failed");
+    generateInsn.emplace_back(csetInsn);
+  } else if (imm1.GetValue() == imm2.GetValue()) {
+    bool destIsIntTy = destReg.IsOfIntClass();
+    MOperator mOp = destIsIntTy ? ((destReg.GetSize() == k64BitSize ? MOP_xmovri64 : MOP_wmovri32)) :
+                    ((destReg.GetSize() == k64BitSize ? MOP_xdfmovri : MOP_wsfmovri));
+    Insn &tempInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, destReg, imm1);
+    generateInsn.emplace_back(&tempInsn);
+  } else {
+    bool destIsIntTy = destReg.IsOfIntClass();
+    uint32 dSize = destReg.GetSize();
+    bool isD64 = dSize == k64BitSize;
+    MOperator mOp = destIsIntTy ? ((destReg.GetSize() == k64BitSize ? MOP_xmovri64 : MOP_wmovri32)) :
+                    ((destReg.GetSize() == k64BitSize ? MOP_xdfmovri : MOP_wsfmovri));
+    RegOperand *tempTarIf = nullptr;
+    if (imm1.IsZero()) {
+      tempTarIf = &cgFunc->GetZeroOpnd(dSize);
+    } else {
+      tempTarIf = cgFunc->GetTheCFG()->CreateVregFromReg(destReg);
+      Insn &tempInsnIf = cgFunc->GetInsnBuilder()->BuildInsn(mOp, *tempTarIf, imm1);
+      generateInsn.emplace_back(&tempInsnIf);
+    }
+
+    RegOperand *tempTarElse = nullptr;
+    if (imm2.IsZero()) {
+      tempTarElse = &cgFunc->GetZeroOpnd(dSize);
+    } else {
+      tempTarElse = cgFunc->GetTheCFG()->CreateVregFromReg(destReg);
+      Insn &tempInsnElse = cgFunc->GetInsnBuilder()->BuildInsn(mOp, *tempTarElse, imm2);
+      generateInsn.emplace_back(&tempInsnElse);
+    }
+
+    bool isIntTy = destReg.IsOfIntClass();
+    MOperator mOpCode = isIntTy ? (isD64 ? MOP_xcselrrrc : MOP_wcselrrrc)
+                                : (isD64 ? MOP_dcselrrrc : (dSize == k32BitSize ? MOP_scselrrrc : MOP_hcselrrrc));
+    Insn *cselInsn = BuildCondSel(branchInsn, mOpCode, destReg, *tempTarIf, *tempTarElse);
+    CHECK_FATAL(cselInsn != nullptr, "build a csel insn failed");
+    generateInsn.emplace_back(cselInsn);
+  }
+}
+
+RegOperand *AArch64ICOIfThenElsePattern::GenerateRegAndTempInsn(Operand &dest, const RegOperand &destReg,
+                                                                std::vector<Insn*> &generateInsn) const {
+  RegOperand *reg = nullptr;
+  if (!dest.IsRegister()) {
+    bool destIsIntTy = destReg.IsOfIntClass();
+    bool isDest64 = destReg.GetSize() == k64BitSize;
+    MOperator mOp = destIsIntTy ? (isDest64 ? MOP_xmovri64 : MOP_wmovri32) : (isDest64 ? MOP_xdfmovri : MOP_wsfmovri);
+    reg = cgFunc->GetTheCFG()->CreateVregFromReg(destReg);
+    ImmOperand &tempSrcElse = static_cast<ImmOperand&>(dest);
+    if (tempSrcElse.IsZero()) {
+      return &cgFunc->GetZeroOpnd(destReg.GetSize());
+    }
+    Insn &tempInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, *reg, tempSrcElse);
+    generateInsn.emplace_back(&tempInsn);
+    return reg;
+  } else {
+    return (static_cast<RegOperand*>(&dest));
+  }
+}
+
+void AArch64ICOIfThenElsePattern::GenerateInsnForReg(const Insn &branchInsn, Operand &ifDest, Operand &elseDest,
+                                                     RegOperand &destReg, std::vector<Insn*> &generateInsn) const {
+  RegOperand *tReg = static_cast<RegOperand*>(&ifDest);
+  RegOperand *eReg = static_cast<RegOperand*>(&elseDest);
+
+  /* mov w0, w1   mov w0, w1  --> mov w0, w1 */
+  if (eReg->GetRegisterNumber() == tReg->GetRegisterNumber()) {
+    uint32 dSize = destReg.GetSize();
+    bool srcIsIntTy = tReg->IsOfIntClass();
+    bool destIsIntTy = destReg.IsOfIntClass();
+    MOperator mOp;
+    if (dSize == k64BitSize) {
+      mOp = srcIsIntTy ? (destIsIntTy ? MOP_xmovrr : MOP_xvmovdr) : (destIsIntTy ? MOP_xvmovrd : MOP_xvmovd);
+    } else {
+      mOp = srcIsIntTy ? (destIsIntTy ? MOP_wmovrr : MOP_xvmovsr) : (destIsIntTy ? MOP_xvmovrs : MOP_xvmovs);
+    }
+    Insn &tempInsnIf = cgFunc->GetInsnBuilder()->BuildInsn(mOp, destReg, *tReg);
+    generateInsn.emplace_back(&tempInsnIf);
+  } else {
+    uint32 dSize = destReg.GetSize();
+    bool isIntTy = destReg.IsOfIntClass();
+    MOperator mOpCode = isIntTy ? (dSize == k64BitSize ? MOP_xcselrrrc : MOP_wcselrrrc)
+                                : (dSize == k64BitSize ? MOP_dcselrrrc : (dSize == k32BitSize ?
+                                                                          MOP_scselrrrc : MOP_hcselrrrc));
+    Insn *cselInsn = BuildCondSel(branchInsn, mOpCode, destReg, *tReg, *eReg);
+    CHECK_FATAL(cselInsn != nullptr, "build a csel insn failed");
+    generateInsn.emplace_back(cselInsn);
+  }
+}
+
+Operand *AArch64ICOIfThenElsePattern::GetDestReg(const std::map<Operand*, std::vector<Operand*>> &destSrcMap,
+                                                 const RegOperand &destReg) const {
+  Operand *dest = nullptr;
+  for (const auto &destSrcPair : destSrcMap) {
+    ASSERT(destSrcPair.first->IsRegister(), "opnd must be register");
+    RegOperand *destRegInMap = static_cast<RegOperand*>(destSrcPair.first);
+    ASSERT(destRegInMap != nullptr, "nullptr check");
+    if (destRegInMap->GetRegisterNumber() == destReg.GetRegisterNumber()) {
+      if (destSrcPair.second.size() > 1) {
+        dest = destSrcPair.first;
+      } else {
+        dest = destSrcPair.second[0];
+      }
+      break;
+    }
+  }
+  return dest;
+}
+
+bool AArch64ICOIfThenElsePattern::BuildCondMovInsn(const BB &bb,
+                                                   const std::map<Operand*, std::vector<Operand*>> &ifDestSrcMap,
+                                                   const std::map<Operand*, std::vector<Operand*>> &elseDestSrcMap,
+                                                   bool elseBBIsProcessed,
+                                                   std::vector<Insn*> &generateInsn) {
+  Insn *branchInsn = cgFunc->GetTheCFG()->FindLastCondBrInsn(*cmpBB);
+  FOR_BB_INSNS_CONST(insn, (&bb)) {
+    if (!insn->IsMachineInstruction() || insn->IsBranch()) {
+      continue;
+    }
+    Operand *dest = nullptr;
+    std::vector<Operand*> src;
+
+    if (!IsSetInsn(*insn, &dest, src)) {
+      ASSERT(false, "insn check");
+    }
+    ASSERT(dest->IsRegister(), "register check");
+    RegOperand *destReg = static_cast<RegOperand*>(dest);
+
+    Operand *elseDest = GetDestReg(elseDestSrcMap, *destReg);
+    Operand *ifDest = GetDestReg(ifDestSrcMap, *destReg);
+
+    if (elseBBIsProcessed) {
+      if (elseDest != nullptr) {
+        continue;
+      }
+      elseDest = dest;
+      ASSERT(ifDest != nullptr, "null ptr check");
+      if (!bb.GetLiveOut()->TestBit(destReg->GetRegisterNumber())) {
+        continue;
+      }
+    } else {
+      ASSERT(elseDest != nullptr, "null ptr check");
+      if (ifDest == nullptr) {
+        if (!bb.GetLiveOut()->TestBit(destReg->GetRegisterNumber())) {
+          continue;
+        }
+        ifDest = dest;
+      }
+    }
+
+    /* generate cset or csel instruction */
+    ASSERT(ifDest != nullptr, "null ptr check");
+    if (ifDest->IsIntImmediate() && elseDest->IsIntImmediate()) {
+      GenerateInsnForImm(*branchInsn, *ifDest, *elseDest, *destReg, generateInsn);
+    } else {
+      RegOperand *tReg = GenerateRegAndTempInsn(*ifDest, *destReg, generateInsn);
+      RegOperand *eReg = GenerateRegAndTempInsn(*elseDest, *destReg, generateInsn);
+      if ((tReg->GetRegisterType() != eReg->GetRegisterType()) ||
+          (tReg->GetRegisterType() != destReg->GetRegisterType())) {
+        return false;
+      }
+      GenerateInsnForReg(*branchInsn, *tReg, *eReg, *destReg, generateInsn);
+    }
+  }
+
+  return true;
+}
+
+bool AArch64ICOIfThenElsePattern::CheckHasSameDest(std::vector<Insn*> &lInsn, std::vector<Insn*> &rInsn) const {
+  for (size_t i = 0; i < lInsn.size(); ++i) {
+    if (Has2SrcOpndSetInsn(*lInsn[i])) {
+      bool hasSameDest = false;
+      for (size_t j = 0; j < rInsn.size(); ++j) {
+        RegOperand *rDestReg = static_cast<RegOperand*>(&rInsn[j]->GetOperand(0));
+        RegOperand *lDestReg = static_cast<RegOperand*>(&lInsn[i]->GetOperand(0));
+        if (lDestReg->GetRegisterNumber() == rDestReg->GetRegisterNumber()) {
+          hasSameDest = true;
+          break;
+        }
+      }
+      if (!hasSameDest) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool AArch64ICOIfThenElsePattern::CheckModifiedRegister(Insn &insn, std::map<Operand*,
+    std::vector<Operand*>> &destSrcMap, std::vector<Operand*> &src,
+    std::map<Operand*, Insn*> &dest2InsnMap, Insn **toBeRremovedOutOfCurrBB) const {
+  /* src was modified in this blcok earlier */
+  for (auto srcOpnd : src) {
+    if (srcOpnd->IsRegister()) {
+      auto &srcReg = static_cast<const RegOperand&>(*srcOpnd);
+      for (auto &destSrcPair : destSrcMap) {
+        ASSERT(destSrcPair.first->IsRegister(), "opnd must be register");
+        RegOperand *mapSrcReg = static_cast<RegOperand*>(destSrcPair.first);
+        if (mapSrcReg->GetRegisterNumber() == srcReg.GetRegisterNumber()) {
+          if (*toBeRremovedOutOfCurrBB == nullptr && mapSrcReg->IsVirtualRegister() &&
+              !insn.GetBB()->GetLiveOut()->TestBit(srcReg.GetRegisterNumber())) {
+            ASSERT(dest2InsnMap.find(mapSrcReg) != dest2InsnMap.end(), "must find");
+            *toBeRremovedOutOfCurrBB = dest2InsnMap[mapSrcReg];
+            continue;
+          }
+          return false;
+        }
+      }
+    }
+  }
+  auto &dest = insn.GetOperand(0);
+  /* dest register was modified earlier in this block */
+  ASSERT(dest.IsRegister(), "opnd must be register");
+  auto &destReg = static_cast<const RegOperand&>(dest);
+  for (auto &destSrcPair : destSrcMap) {
+    ASSERT(destSrcPair.first->IsRegister(), "opnd must be register");
+    RegOperand *mapSrcReg = static_cast<RegOperand*>(destSrcPair.first);
+    if (mapSrcReg->GetRegisterNumber() == destReg.GetRegisterNumber()) {
+      return false;
+    }
+  }
+
+  /* src register is modified later in this block, will not be processed */
+  for (auto srcOpnd : src) {
+    if (srcOpnd->IsRegister()) {
+      RegOperand &srcReg = static_cast<RegOperand&>(*srcOpnd);
+      if (destReg.IsOfFloatOrSIMDClass() && srcReg.GetRegisterNumber() == RZR) {
+        return false;
+      }
+      for (Insn *tmpInsn = &insn; tmpInsn != nullptr; tmpInsn = tmpInsn->GetNext()) {
+        Operand *tmpDest = nullptr;
+        std::vector<Operand*> tmpSrc;
+        if (IsSetInsn(*tmpInsn, &tmpDest, tmpSrc) && tmpDest->Equals(*srcOpnd)) {
+          ASSERT(tmpDest->IsRegister(), "opnd must be register");
+          RegOperand *tmpDestReg = static_cast<RegOperand*>(tmpDest);
+          if (srcReg.GetRegisterNumber() == tmpDestReg->GetRegisterNumber()) {
+            return false;
+          }
+        }
+      }
+    }
+  }
+
+  /* add/sub insn's dest register does not exist in cmp insn. */
+  return CheckModifiedInCmpInsn(insn);
+}
+
+bool AArch64ICOIfThenElsePattern::CheckCondMoveBB(BB *bb, std::map<Operand*, std::vector<Operand*>> &destSrcMap,
+    std::vector<Operand*> &destRegs, std::vector<Insn*> &setInsn, Insn **toBeRremovedOutOfCurrBB) const {
+  std::map<Operand*, Insn*> dest2InsnMap; // CheckModifiedRegister will ensure that dest is defined only once.
+  if (bb == nullptr) {
+    return false;
+  }
+  FOR_BB_INSNS(insn, bb) {
+    if (!insn->IsMachineInstruction() || insn->IsBranch()) {
+      continue;
+    }
+    Operand *dest = nullptr;
+    std::vector<Operand*> src;
+
+    if (!IsSetInsn(*insn, &dest, src)) {
+      return false;
+    }
+    ASSERT(dest != nullptr, "null ptr check");
+    ASSERT(src.size() != 0, "null ptr check");
+
+    if (!dest->IsRegister()) {
+      return false;
+    }
+
+    for (auto srcOpnd : src) {
+      if (!(srcOpnd->IsConstImmediate()) && !srcOpnd->IsRegister()) {
+        return false;
+      }
+    }
+
+    if (flagOpnd != nullptr) {
+      RegOperand *flagReg = static_cast<RegOperand*>(flagOpnd);
+      regno_t flagRegNO = flagReg->GetRegisterNumber();
+      if (bb->GetLiveOut()->TestBit(flagRegNO)) {
+        return false;
+      }
+    }
+
+    if (!CheckModifiedRegister(*insn, destSrcMap, src, dest2InsnMap, toBeRremovedOutOfCurrBB)) {
+      return false;
+    }
+
+    if (insn != *toBeRremovedOutOfCurrBB) {
+      if (IsExpansionMOperator(*insn)) {
+        if (*toBeRremovedOutOfCurrBB == nullptr && static_cast<RegOperand*>(dest)->IsVirtualRegister()) {
+          *toBeRremovedOutOfCurrBB = insn;
+        } else {
+          return false;
+        }
+      }
+    }
+
+    (void)destSrcMap.insert(std::make_pair(dest, src));
+    destRegs.emplace_back(dest);
+    (void)setInsn.emplace_back(insn);
+    dest2InsnMap[dest] = insn;
+  }
+  return true;
+}
+
+bool AArch64ICOIfThenElsePattern::CheckModifiedInCmpInsn(const Insn &insn) const {
+  /* add/sub insn's dest register does not exist in cmp insn. */
+  if (Has2SrcOpndSetInsn(insn)) {
+    RegOperand &insnDestReg = static_cast<RegOperand&>(insn.GetOperand(0));
+    if (flagOpnd) {
+      RegOperand &cmpReg = static_cast<RegOperand&>(cmpInsn->GetOperand(0));
+      if (insnDestReg.GetRegisterNumber() == cmpReg.GetRegisterNumber()) {
+        return false;
+      }
+    } else {
+      RegOperand &cmpReg1 = static_cast<RegOperand&>(cmpInsn->GetOperand(1));
+      if (cmpInsn->GetOperand(2).IsRegister()) {
+        RegOperand &cmpReg2 = static_cast<RegOperand&>(cmpInsn->GetOperand(2));
+        if (insnDestReg.GetRegisterNumber() == cmpReg1.GetRegisterNumber() ||
+            insnDestReg.GetRegisterNumber() == cmpReg2.GetRegisterNumber()) {
+          return false;
+        }
+      } else {
+        if (insnDestReg.GetRegisterNumber() == cmpReg1.GetRegisterNumber()) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+// If the first insn of if/else bb has the same machine opcode and src opnds, put the insn in cmpBB, do opt like:
+// cmp BB:                          cmp BB:
+//                                   lsr  w1, w0, #1 (change)
+//   cmp  w5, #1                     cmp   w5, #1
+//   beq                             beq
+// if bb:                          if bb:
+//   lsr  w1, w0, #1 (change) =>
+//   mov  w3, w1                     mov  w3, w1
+// else bb:                        else bb:
+//   lsr  w2, w0, #1 (change)
+//   mov  w4, w2                     mov  w4, w1 (change)
+bool AArch64ICOIfThenElsePattern::DoHostBeforeDoCselOpt(BB &ifBB, BB &elseBB) {
+  auto firstInsnOfIfBB = ifBB.GetFirstMachineInsn();
+  auto firstInsnOfElseBB = elseBB.GetFirstMachineInsn();
+  if (firstInsnOfIfBB == nullptr || firstInsnOfElseBB == nullptr) {
+    return false;
+  }
+  if (!IsSetInsnMOperator(*firstInsnOfIfBB) ||
+      firstInsnOfIfBB->GetMachineOpcode() != firstInsnOfElseBB->GetMachineOpcode() ||
+      firstInsnOfIfBB->GetOperandSize() != firstInsnOfElseBB->GetOperandSize()) {
+    return false;
+  }
+  if (!firstInsnOfIfBB->GetOperand(0).IsRegister() || !firstInsnOfElseBB->GetOperand(0).IsRegister()) {
+    return false;
+  }
+  auto *destOpndOfInsnInIfBB = static_cast<RegOperand*>(&firstInsnOfIfBB->GetOperand(0));
+  auto *destOpndOfInsnInElseBB = static_cast<RegOperand*>(&firstInsnOfElseBB->GetOperand(0));
+  if (!destOpndOfInsnInIfBB->IsVirtualRegister() || !destOpndOfInsnInElseBB->IsVirtualRegister()) {
+    return false;
+  }
+  for (uint32 i = 1; i < firstInsnOfIfBB->GetOperandSize(); ++i) {
+    auto *opndOfInsnInIfBB = &firstInsnOfIfBB->GetOperand(i);
+    auto *opndOfInsnInElseBB = &firstInsnOfElseBB->GetOperand(i);
+    if (opndOfInsnInIfBB->IsRegister() && static_cast<RegOperand*>(opndOfInsnInIfBB)->Equals(*opndOfInsnInElseBB)) {
+      continue;
+    }
+    if (opndOfInsnInIfBB->GetKind() == Operand::kOpdImmediate &&
+        static_cast<ImmOperand*>(opndOfInsnInIfBB)->Equals(*opndOfInsnInElseBB)) {
+      continue;
+    }
+    return false;
+  }
+  if (ifBB.GetLiveOut()->TestBit(destOpndOfInsnInIfBB->GetRegisterNumber()) ||
+      ifBB.GetLiveOut()->TestBit(destOpndOfInsnInElseBB->GetRegisterNumber())) {
+    return false;
+  }
+  FOR_BB_INSNS(insn, &elseBB) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    for (uint32 i = 0; i < insn->GetOperandSize(); ++i) {
+      auto *opnd = &insn->GetOperand(i);
+      switch (opnd->GetKind()) {
+        case Operand::kOpdRegister: {
+          if (destOpndOfInsnInElseBB->Equals(*opnd)) {
+            insn->SetOperand(i, *destOpndOfInsnInIfBB);
+          }
+          break;
+        }
+        case Operand::kOpdMem: {
+          auto *memOpnd = static_cast<MemOperand*>(opnd);
+          RegOperand *base = memOpnd->GetBaseRegister();
+          RegOperand *index = memOpnd->GetIndexRegister();
+          if (base != nullptr && destOpndOfInsnInElseBB->Equals(*base)) {
+            memOpnd->SetBaseRegister(*destOpndOfInsnInIfBB);
+          }
+          if (index != nullptr && destOpndOfInsnInElseBB->Equals(*index)) {
+            memOpnd->SetIndexRegister(*destOpndOfInsnInIfBB);
+          }
+          break;
+        }
+        case Operand::kOpdList: {
+          auto *listOpnd = static_cast<ListOperand*>(opnd);
+          auto& opndList = listOpnd->GetOperands();
+          std::list<RegOperand*> tempList;
+          while (!opndList.empty()) {
+            auto* op = opndList.front();
+            opndList.pop_front();
+            if (destOpndOfInsnInElseBB->Equals(*op)) {
+              tempList.push_back(destOpndOfInsnInElseBB);
+            } else {
+              tempList.push_back(op);
+            }
+          }
+          listOpnd->GetOperands().assign(tempList.begin(), tempList.end());
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  ifBB.RemoveInsn(*firstInsnOfIfBB);
+  elseBB.RemoveInsn(*firstInsnOfElseBB);
+  (void)cmpBB->InsertInsnBefore(*cmpInsn, *firstInsnOfIfBB);
+  return true;
+}
+
+void AArch64ICOIfThenElsePattern::UpdateTemps(std::vector<Operand*> &destRegs, std::vector<Insn*> &setInsn,
+    std::map<Operand*, std::vector<Operand*>> &destSrcMap, const Insn &oldInsn, Insn *newInsn) {
+  for (auto it = setInsn.begin(); it != setInsn.end(); ++it) {
+    if (*it == &oldInsn) {
+      (void)setInsn.erase(it);
+      break;
+    }
+  }
+  if (newInsn != nullptr) {
+    setInsn.push_back(newInsn);
+    return;
+  }
+  auto &opnd = oldInsn.GetOperand(0);
+  if (!opnd.IsRegister()) {
+    return;
+  }
+  for (auto it = destRegs.begin(); it != destRegs.end(); ++it) {
+    if (opnd.Equals(**it)) {
+      (void)destRegs.erase(it);
+      break;
+    }
+  }
+
+  for (auto it = destSrcMap.begin(); it != destSrcMap.end(); ++it) {
+    if (opnd.Equals(*(it->first))) {
+      (void)destSrcMap.erase(it);
+      break;
+    }
+  }
+}
+
+void AArch64ICOIfThenElsePattern::RevertMoveInsns(BB *bb, Insn *prevInsnInBB, Insn *newInsnOfBB,
+    Insn *insnInBBToBeRremovedOutOfCurrBB) {
+  if (bb == nullptr || insnInBBToBeRremovedOutOfCurrBB == nullptr) {
+    return;
+  }
+  if (newInsnOfBB != nullptr) {
+    bb->RemoveInsn(*newInsnOfBB);
+  }
+  cmpBB->RemoveInsn(*insnInBBToBeRremovedOutOfCurrBB);
+  if (prevInsnInBB != nullptr) {
+    (void)bb->InsertInsnAfter(*prevInsnInBB, *insnInBBToBeRremovedOutOfCurrBB);
+  } else {
+    bb->InsertInsnBegin(*insnInBBToBeRremovedOutOfCurrBB);
+  }
+}
+
+Insn *AArch64ICOIfThenElsePattern::MoveSetInsn2CmpBB(Insn &toBeRremoved2CmpBB, BB &currBB,
+    std::vector<Operand*> &anotherBranchDestRegs, std::map<Operand*, std::vector<Operand*>> &destSrcMap) {
+  Insn *newInsn = nullptr;
+  bool findInAnotherBB = false;
+  for (auto *tempReg: anotherBranchDestRegs) {
+    if (static_cast<RegOperand*>(tempReg)->Equals(static_cast<RegOperand&>(toBeRremoved2CmpBB.GetOperand(0)))) {
+      findInAnotherBB = true;
+    }
+  }
+  if (findInAnotherBB) {
+    // If the target register w0 is both the target register in the if and else branches, do opt like:
+    // cmpBB:                        cmpBB:
+    //                                 uxth  w2, w1 (change)
+    //   cmp  w5, #1                   cmp   w5, #1
+    //   beq                           beq
+    //
+    // if bb:                        if bb:
+    //   eor  w0, w3, w4     =>        eor   w0, w3, w4
+    //
+    // else bb:                      else bb:
+    //   uxth w0, w1                   mov   w0, w2 (change)
+    auto &oldDestReg = static_cast<RegOperand&>(static_cast<RegOperand&>(toBeRremoved2CmpBB.GetOperand(0)));
+    ASSERT(oldDestReg.IsVirtualRegister(), "must be vreg");
+    auto &newDestReg = cgFunc->CreateVirtualRegisterOperand(
+        cgFunc->NewVReg(oldDestReg.GetRegisterType(), oldDestReg.GetSize()));
+    toBeRremoved2CmpBB.SetOperand(0, newDestReg);
+    uint32 mOp = (oldDestReg.GetSize() == 64) ? MOP_xmovrr : MOP_wmovrr;
+    newInsn = &(cgFunc->GetInsnBuilder()->BuildInsn(mOp, oldDestReg, newDestReg));
+    (void)currBB.InsertInsnBefore(toBeRremoved2CmpBB, *newInsn);
+    currBB.RemoveInsn(toBeRremoved2CmpBB);
+    (void)cmpBB->InsertInsnBefore(*cmpInsn, toBeRremoved2CmpBB);
+    destSrcMap[&oldDestReg].clear();
+    destSrcMap[&oldDestReg].push_back(&newDestReg);
+  } else {
+    // If the target register w0 is in if or else branch, do opt like:
+    // cmpBB:                        cmpBB:
+    //                                 mov  w4, #40961 (change)
+    //   cmp w5, #1                    cmp  w5, #1
+    //   beq                           beq
+    //
+    // if bb:                        if bb:
+    //   mov  w4, #40961 (change)
+    //   eor  w1, w3, w4     =>        eor  w1, w3, w4
+    //
+    // else bb:                      else bb:
+    //   uxth w0, w1                   uxth w0, w1
+    toBeRremoved2CmpBB.GetBB()->RemoveInsn(toBeRremoved2CmpBB);
+    (void)cmpBB->InsertInsnBefore(*cmpInsn, toBeRremoved2CmpBB);
+  }
+  return newInsn;
+}
+
+/* Convert conditional branches into cset/csel instructions */
+bool AArch64ICOIfThenElsePattern::DoOpt(BB *ifBB, BB *elseBB, BB &joinBB) {
+  Insn *condBr = cgFunc->GetTheCFG()->FindLastCondBrInsn(*cmpBB);
+  ASSERT(condBr != nullptr, "nullptr check");
+  cmpInsn = FindLastCmpInsn(*cmpBB);
+  flagOpnd = nullptr;
+  /* for cbnz and cbz institution */
+  if (cgFunc->GetTheCFG()->IsCompareAndBranchInsn(*condBr)) {
+    Operand &opnd0 = condBr->GetOperand(0);
+    if (opnd0.IsRegister() && static_cast<RegOperand&>(opnd0).GetRegisterNumber() == RZR) {
+      return false;
+    }
+    cmpInsn = condBr;
+    flagOpnd = &(opnd0);
+  }
+
+  /* tbz will not be optimized */
+  MOperator mOperator = condBr->GetMachineOpcode();
+  if (mOperator == MOP_xtbz || mOperator == MOP_wtbz || mOperator == MOP_xtbnz || mOperator == MOP_wtbnz) {
+    return false;
+  }
+  if (cmpInsn == nullptr) {
+    return false;
+  }
+  if (ifBB != nullptr && elseBB != nullptr) {
+    while (DoHostBeforeDoCselOpt(*ifBB, *elseBB)) {}
+  }
+
+  std::vector<Operand*> ifDestRegs;
+  std::vector<Insn*> ifSetInsn;
+  std::vector<Operand*> elseDestRegs;
+  std::vector<Insn*> elseSetInsn;
+
+  std::map<Operand*, std::vector<Operand*>> ifDestSrcMap;
+  std::map<Operand*, std::vector<Operand*>> elseDestSrcMap;
+
+  Insn *insnInElseBBToBeRremovedOutOfCurrBB = nullptr;
+  Insn *insnInIfBBToBeRremovedOutOfCurrBB = nullptr;
+
+  if (!CheckCondMoveBB(elseBB, elseDestSrcMap, elseDestRegs, elseSetInsn, &insnInElseBBToBeRremovedOutOfCurrBB) ||
+      (ifBB != nullptr && !CheckCondMoveBB(ifBB, ifDestSrcMap, ifDestRegs, ifSetInsn,
+                                           &insnInIfBBToBeRremovedOutOfCurrBB))) {
+    return false;
+  }
+
+  if (!CheckHasSameDest(ifSetInsn, elseSetInsn) || !CheckHasSameDest(elseSetInsn, ifSetInsn)) {
+    return false;
+  }
+
+  size_t count = elseDestRegs.size();
+
+  for (size_t i = 0; i < ifDestRegs.size(); ++i) {
+    bool foundInElse = false;
+    for (size_t j = 0; j < elseDestRegs.size(); ++j) {
+      RegOperand *elseDestReg = static_cast<RegOperand*>(elseDestRegs[j]);
+      RegOperand *ifDestReg = static_cast<RegOperand*>(ifDestRegs[i]);
+      if (ifDestReg->GetRegisterNumber() == elseDestReg->GetRegisterNumber()) {
+        if (Has2SrcOpndSetInsn(*ifSetInsn[i]) && Has2SrcOpndSetInsn(*elseSetInsn[j])) {
+          return false;
+        }
+        foundInElse = true;
+        break;
+      }
+    }
+    if (foundInElse) {
+      continue;
+    } else {
+      ++count;
+    }
+  }
+  if (count > kThreshold) {
+    return false;
+  }
+  Insn *newInsnOfIfBB = nullptr;
+  Insn *newInsnOfElseBB = nullptr;
+  Insn *prevInsnInIfBB = nullptr;
+  Insn *prevInsnInElseBB = nullptr;
+  if (insnInElseBBToBeRremovedOutOfCurrBB != nullptr) {
+    prevInsnInElseBB = insnInElseBBToBeRremovedOutOfCurrBB->GetPrev();
+    ASSERT_NOT_NULL(elseBB);
+    newInsnOfElseBB = MoveSetInsn2CmpBB(
+        *insnInElseBBToBeRremovedOutOfCurrBB, *elseBB, ifDestRegs, elseDestSrcMap);
+    UpdateTemps(elseDestRegs, elseSetInsn, elseDestSrcMap, *insnInElseBBToBeRremovedOutOfCurrBB, newInsnOfElseBB);
+  }
+  if (insnInIfBBToBeRremovedOutOfCurrBB != nullptr) {
+    prevInsnInIfBB = insnInIfBBToBeRremovedOutOfCurrBB->GetPrev();
+    ASSERT_NOT_NULL(ifBB);
+    newInsnOfIfBB = MoveSetInsn2CmpBB(
+        *insnInIfBBToBeRremovedOutOfCurrBB, *ifBB, elseDestRegs, ifDestSrcMap);
+    UpdateTemps(ifDestRegs, ifSetInsn, ifDestSrcMap, *insnInIfBBToBeRremovedOutOfCurrBB, newInsnOfIfBB);
+  }
+
+  /* generate insns */
+  std::vector<Insn*> elseGenerateInsn;
+  std::vector<Insn*> ifGenerateInsn;
+  bool elseBBProcessResult = false;
+  if (elseBB != nullptr) {
+    elseBBProcessResult = BuildCondMovInsn(*elseBB, ifDestSrcMap, elseDestSrcMap, false, elseGenerateInsn);
+  }
+  bool ifBBProcessResult = false;
+  if (ifBB != nullptr) {
+    ifBBProcessResult = BuildCondMovInsn(*ifBB, ifDestSrcMap, elseDestSrcMap, true, ifGenerateInsn);
+  }
+  if (!elseBBProcessResult || (ifBB != nullptr && !ifBBProcessResult)) {
+    RevertMoveInsns(elseBB, prevInsnInElseBB, newInsnOfElseBB, insnInElseBBToBeRremovedOutOfCurrBB);
+    RevertMoveInsns(ifBB, prevInsnInIfBB, newInsnOfIfBB, insnInIfBBToBeRremovedOutOfCurrBB);
+    return false;
+  }
+
+  /* insert insn */
+  if (cgFunc->GetTheCFG()->IsCompareAndBranchInsn(*condBr)) {
+    Insn *innerCmpInsn = BuildCmpInsn(*condBr);
+    cmpBB->InsertInsnBefore(*cmpInsn, *innerCmpInsn);
+    cmpInsn = innerCmpInsn;
+  }
+
+  if (elseBB != nullptr) {
+    cmpBB->SetKind(elseBB->GetKind());
+  } else {
+    ASSERT(ifBB != nullptr, "ifBB should not be nullptr");
+    cmpBB->SetKind(ifBB->GetKind());
+  }
+
+  for (auto setInsn : ifSetInsn) {
+    if (Has2SrcOpndSetInsn(*setInsn)) {
+      (void)cmpBB->InsertInsnBefore(*cmpInsn, *setInsn);
+    }
+  }
+
+  for (auto setInsn : elseSetInsn) {
+    if (Has2SrcOpndSetInsn(*setInsn)) {
+      (void)cmpBB->InsertInsnBefore(*cmpInsn, *setInsn);
+    }
+  }
+
+  /* delete condBr */
+  cmpBB->RemoveInsn(*condBr);
+  /* Insert goto insn after csel insn. */
+  if (cmpBB->GetKind() == BB::kBBGoto || cmpBB->GetKind() == BB::kBBIf) {
+    if (elseBB != nullptr) {
+      (void)cmpBB->InsertInsnAfter(*cmpBB->GetLastInsn(), *elseBB->GetLastInsn());
+    } else {
+      ASSERT(ifBB != nullptr, "ifBB should not be nullptr");
+      (void)cmpBB->InsertInsnAfter(*cmpBB->GetLastInsn(), *ifBB->GetLastInsn());
+    }
+  }
+
+  /* Insert instructions in branches after cmpInsn */
+  for (auto itr = elseGenerateInsn.crbegin(); itr != elseGenerateInsn.crend(); ++itr) {
+    (void)cmpBB->InsertInsnAfter(*cmpInsn, **itr);
+  }
+  for (auto itr = ifGenerateInsn.crbegin(); itr != ifGenerateInsn.crend(); ++itr) {
+    (void)cmpBB->InsertInsnAfter(*cmpInsn, **itr);
+  }
+
+  /* Remove branches and merge join */
+  if (ifBB != nullptr) {
+    BB *prevLast = ifBB->GetPrev();
+    cgFunc->GetTheCFG()->RemoveBB(*ifBB);
+    if (ifBB->GetId() == cgFunc->GetLastBB()->GetId()) {
+      cgFunc->SetLastBB(*prevLast);
+    }
+  }
+  if (elseBB != nullptr) {
+    BB *prevLast = elseBB->GetPrev();
+    cgFunc->GetTheCFG()->RemoveBB(*elseBB);
+    if (elseBB->GetId() == cgFunc->GetLastBB()->GetId()) {
+      cgFunc->SetLastBB(*prevLast);
+    }
+  }
+  /* maintain won't exit bb info. */
+  if ((ifBB != nullptr && ifBB->IsWontExit()) || (elseBB != nullptr && elseBB->IsWontExit())) {
+    cgFunc->GetCommonExitBB()->PushBackPreds(*cmpBB);
+  }
+
+  if (cmpBB->GetKind() != BB::kBBIf && cmpBB->GetNext() == &joinBB &&
+      !maplebe::CGCFG::InLSDA(joinBB.GetLabIdx(), cgFunc->GetEHFunc()) &&
+      cgFunc->GetTheCFG()->CanMerge(*cmpBB, joinBB)) {
+    maplebe::CGCFG::MergeBB(*cmpBB, joinBB, *cgFunc);
+    keepPosition = true;
+  }
+  return true;
+}
+
+/*
+ * Find IF-THEN-ELSE or IF-THEN basic block pattern,
+ * and then invoke DoOpt(...) to finish optimize.
+ */
+bool AArch64ICOIfThenElsePattern::Optimize(BB &curBB) {
+  if (curBB.GetKind() != BB::kBBIf) {
+    return false;
+  }
+  BB *ifBB = nullptr;
+  BB *elseBB = nullptr;
+  BB *joinBB = nullptr;
+
+  BB *thenDest = CGCFG::GetTargetSuc(curBB);
+  BB *elseDest = curBB.GetNext();
+  CHECK_FATAL(thenDest != nullptr, "then_dest is null in ITEPattern::Optimize");
+  CHECK_FATAL(elseDest != nullptr, "else_dest is null in ITEPattern::Optimize");
+  /* IF-THEN-ELSE */
+  if (thenDest->NumPreds() == 1 && thenDest->NumSuccs() == 1 && elseDest->NumSuccs() == 1 &&
+      elseDest->NumPreds() == 1 && thenDest->GetSuccs().front() == elseDest->GetSuccs().front()) {
+    ifBB = thenDest;
+    elseBB = elseDest;
+    joinBB = thenDest->GetSuccs().front();
+  } else if (elseDest->NumPreds() == 1 && elseDest->NumSuccs() == 1 && elseDest->GetSuccs().front() == thenDest) {
+    /* IF-THEN */
+    ifBB = nullptr;
+    elseBB = elseDest;
+    joinBB = thenDest;
+  } else {
+    /* not a form we can handle */
+    return false;
+  }
+  ASSERT(elseBB != nullptr, "elseBB should not be nullptr");
+  if (CGCFG::InLSDA(elseBB->GetLabIdx(), cgFunc->GetEHFunc()) ||
+      CGCFG::InSwitchTable(elseBB->GetLabIdx(), *cgFunc)) {
+    return false;
+  }
+
+  if (ifBB != nullptr &&
+      (CGCFG::InLSDA(ifBB->GetLabIdx(), cgFunc->GetEHFunc()) ||
+       CGCFG::InSwitchTable(ifBB->GetLabIdx(), *cgFunc))) {
+    return false;
+  }
+  cmpBB = &curBB;
+  return DoOpt(ifBB, elseBB, *joinBB);
+}
+
+/* If( cmp || cmp ) then
+ * or
+ * If( cmp && cmp ) then */
+bool AArch64ICOSameCondPattern::Optimize(BB &secondIfBB) {
+  if (secondIfBB.GetKind() != BB::kBBIf || secondIfBB.NumPreds() != 1) {
+    return false;
+  }
+  BB *firstIfBB = secondIfBB.GetPrev();
+  BB *nextBB = firstIfBB->GetNext();
+  CHECK_FATAL(nextBB != nullptr, "nextBB is null in AArch64ICOSameCondPattern::Optimize");
+  /* firstIfBB's nextBB is secondIfBB */
+  if (firstIfBB == nullptr || firstIfBB->GetKind() != BB::kBBIf || nextBB->GetId() != secondIfBB.GetId()) {
+    return false;
+  }
+  return DoOpt(firstIfBB, secondIfBB);
+}
+
+bool AArch64ICOPattern::CheckMop(MOperator mOperator) const {
+  switch (mOperator) {
+    case MOP_beq:
+    case MOP_bne:
+    case MOP_blt:
+    case MOP_ble:
+    case MOP_bgt:
+    case MOP_bge:
+    case MOP_blo:
+    case MOP_bls:
+    case MOP_bhs:
+    case MOP_bhi:
+    case MOP_bpl:
+    case MOP_bmi:
+    case MOP_bvc:
+    case MOP_bvs:
+      return true;
+    default:
+      return false;
+  }
+}
+
+/* branchInsn1 is firstIfBB's LastCondBrInsn
+ * branchInsn2 is secondIfBB's LastCondBrInsn
+ *
+ * Limitations: branchInsn1 is the same as branchInsn2
+ * */
+bool AArch64ICOSameCondPattern::DoOpt(BB *firstIfBB, BB &secondIfBB) const {
+  Insn *branchInsn1 = cgFunc->GetTheCFG()->FindLastCondBrInsn(*firstIfBB);
+  ASSERT(branchInsn1 != nullptr, "nullptr check");
+  Insn *cmpInsn1 = FindLastCmpInsn(*firstIfBB);
+  MOperator mOperator1 = branchInsn1->GetMachineOpcode();
+  Insn *branchInsn2 = cgFunc->GetTheCFG()->FindLastCondBrInsn(secondIfBB);
+  ASSERT(branchInsn2 != nullptr, "nullptr check");
+  Insn *cmpInsn2 = FindLastCmpInsn(secondIfBB);
+  MOperator mOperator2 = branchInsn2->GetMachineOpcode();
+  if (cmpInsn1 == nullptr || cmpInsn2 == nullptr) {
+    return false;
+  }
+
+  /* tbz and cbz will not be optimized */
+  if (mOperator1 != mOperator2 || !CheckMop(mOperator1)) {
+    return false;
+  }
+
+  /* two BB has same branch */
+  std::vector<LabelOperand*> labelOpnd1 = GetLabelOpnds(*branchInsn1);
+  std::vector<LabelOperand*> labelOpnd2 = GetLabelOpnds(*branchInsn2);
+  if (labelOpnd1.size() != 1 || labelOpnd1.size() != 1 ||
+      labelOpnd1[0]->GetLabelIndex() != labelOpnd2[0]->GetLabelIndex()) {
+    return false;
+  }
+
+  /* secondifBB only has branchInsn and cmpInsn */
+  FOR_BB_INSNS_REV(insn, &secondIfBB) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    if (insn != branchInsn2 && insn != cmpInsn2) {
+      return false;
+    }
+  }
+
+  /* build ccmp Insn */
+  ConditionCode ccCode = Encode(branchInsn1->GetMachineOpcode(), true);
+  ASSERT(ccCode != kCcLast, "unknown cond, ccCode can't be kCcLast");
+  Insn *ccmpInsn = BuildCcmpInsn(ccCode, cmpInsn2);
+  if (ccmpInsn == nullptr) {
+    return false;
+  }
+
+  /* insert ccmp Insn */
+  firstIfBB->InsertInsnBefore(*branchInsn1, *ccmpInsn);
+
+  /* Remove secondIfBB */
+  BB *nextBB = secondIfBB.GetNext();
+  cgFunc->GetTheCFG()->RemoveBB(secondIfBB);
+  firstIfBB->PushFrontSuccs(*nextBB);
+  nextBB->PushFrontPreds(*firstIfBB);
+  return true;
+}
+/*
+ * find the preds all is ifBB
+ */
+bool AArch64ICOMorePredsPattern::Optimize(BB &curBB) {
+  if (curBB.GetKind() != BB::kBBGoto) {
+    return false;
+  }
+  for (BB *preBB : curBB.GetPreds()) {
+    if (preBB->GetKind() != BB::kBBIf) {
+      return false;
+    }
+  }
+  for (BB *succsBB : curBB.GetSuccs()) {
+    if (succsBB->GetKind() != BB::kBBFallthru) {
+      return false;
+    }
+    if (succsBB->NumPreds() > 2) {
+      return false;
+    }
+  }
+  Insn *gotoBr = curBB.GetLastMachineInsn();
+  ASSERT(gotoBr != nullptr, "gotoBr should not be nullptr");
+  auto &gotoLabel = static_cast<LabelOperand&>(gotoBr->GetOperand(gotoBr->GetOperandSize() - 1));
+  for (BB *preBB : curBB.GetPreds()) {
+    Insn *condBr = cgFunc->GetTheCFG()->FindLastCondBrInsn(*preBB);
+    ASSERT(condBr != nullptr, "nullptr check");
+    Operand &condBrLastOpnd = condBr->GetOperand(condBr->GetOperandSize() - 1);
+    ASSERT(condBrLastOpnd.IsLabelOpnd(), "label Operand must be exist in branch insn");
+    auto &labelOpnd = static_cast<LabelOperand&>(condBrLastOpnd);
+    if (labelOpnd.GetLabelIndex() != curBB.GetLabIdx()) {
+      return false;
+    }
+    if (gotoLabel.GetLabelIndex() != preBB->GetNext()->GetLabIdx()) {
+      /* do not if convert if 'else' clause present */
+      return false;
+    }
+  }
+  return DoOpt(curBB);
+}
+
+/* this BBGoto only has mov Insn and Branch */
+bool AArch64ICOMorePredsPattern::CheckGotoBB(BB &gotoBB, std::vector<Insn*> &movInsn) const {
+  FOR_BB_INSNS(insn, &gotoBB) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    if (insn->IsMove()) {
+      movInsn.push_back(insn);
+      continue;
+    }
+    if (insn->GetId() != gotoBB.GetLastInsn()->GetId()) {
+      return false;
+    } else if (!insn->IsBranch()) { /* last Insn is Branch */
+      return false;
+    }
+  }
+  return true;
+}
+
+/* this BBGoto only has mov Insn */
+bool AArch64ICOMorePredsPattern::MovToCsel(std::vector<Insn*> &movInsn, std::vector<Insn*> &cselInsn,
+                                           const Insn &branchInsn) const {
+  Operand &branchOpnd0 = branchInsn.GetOperand(kInsnFirstOpnd);
+  regno_t branchRegNo;
+  if (branchOpnd0.IsRegister()) {
+    branchRegNo = static_cast<RegOperand&>(branchOpnd0).GetRegisterNumber();
+  }
+  for (Insn *insn:movInsn) {
+    /* use mov build csel */
+    Operand &opnd0 = insn->GetOperand(kInsnFirstOpnd);
+    Operand &opnd1 = insn->GetOperand(kInsnSecondOpnd);
+    ConditionCode ccCode = AArch64ICOPattern::Encode(branchInsn.GetMachineOpcode(), false);
+    ASSERT(ccCode != kCcLast, "unknown cond, ccCode can't be kCcLast");
+    CondOperand &cond = static_cast<AArch64CGFunc *>(cgFunc)->GetCondOperand(ccCode);
+    Operand &rflag = static_cast<AArch64CGFunc *>(cgFunc)->GetOrCreateRflag();
+    RegOperand &regOpnd0 = static_cast<RegOperand&>(opnd0);
+    RegOperand &regOpnd1 = static_cast<RegOperand&>(opnd1);
+    /* movInsn's opnd1 is Immediate */
+    if (opnd1.IsImmediate()) {
+      return false;
+    }
+    /* opnd0 and opnd1 hsa same type and size */
+    if (regOpnd0.GetSize() != regOpnd1.GetSize() || (regOpnd0.IsOfIntClass() != regOpnd1.IsOfIntClass())) {
+      return false;
+    }
+    /* The branchOpnd0 cannot be modified for csel. */
+    regno_t movRegNo0 = static_cast<RegOperand&>(opnd0).GetRegisterNumber();
+    if (branchOpnd0.IsRegister() && branchRegNo == movRegNo0) {
+      return false;
+    }
+    uint32 dSize = regOpnd0.GetSize();
+    bool isIntTy = regOpnd0.IsOfIntClass();
+    MOperator mOpCode = isIntTy ? (dSize == k64BitSize ? MOP_xcselrrrc : MOP_wcselrrrc)
+                                : (dSize == k64BitSize ? MOP_dcselrrrc : (dSize == k32BitSize ?
+                                                                          MOP_scselrrrc : MOP_hcselrrrc));
+    (void)cselInsn.emplace_back(&cgFunc->GetInsnBuilder()->BuildInsn(mOpCode, opnd0, opnd1, opnd0, cond, rflag));
+  }
+  if (cselInsn.size() < 1) {
+    return false;
+  }
+  return true;
+}
+
+bool AArch64ICOMorePredsPattern::DoOpt(BB &gotoBB) const {
+  std::vector<Insn*> movInsn;
+  std::vector<std::vector<Insn*>> presCselInsn;
+  std::vector<BB*> presBB;
+  Insn *branchInsn = gotoBB.GetLastMachineInsn();
+  if (branchInsn == nullptr || !branchInsn->IsUnCondBranch()) {
+    return false;
+  }
+  /* get preds's new label */
+  std::vector<LabelOperand*> labelOpnd = GetLabelOpnds(*branchInsn);
+  if (labelOpnd.size() != 1) {
+    return false;
+  }
+  if (!CheckGotoBB(gotoBB, movInsn)) {
+    return false;
+  }
+  /* Check all preBB, Exclude gotoBBs that cannot be optimized. */
+  for (BB *preBB : gotoBB.GetPreds()) {
+    Insn *condBr = cgFunc->GetTheCFG()->FindLastCondBrInsn(*preBB);
+    ASSERT(condBr != nullptr, "nullptr check");
+
+    /* tbz/cbz will not be optimized */
+    MOperator mOperator = condBr->GetMachineOpcode();
+    if (!CheckMop(mOperator)) {
+      return false;
+    }
+    std::vector<Insn*> cselInsn;
+    if (!MovToCsel(movInsn, cselInsn, *condBr)) {
+      return false;
+    }
+    if (cselInsn.size() < 1) {
+      return false;
+    }
+    presCselInsn.emplace_back(cselInsn);
+    presBB.emplace_back(preBB);
+  }
+  /* modifies presBB */
+  for (size_t i = 0; i < presCselInsn.size(); ++i) {
+    BB *preBB = presBB[i];
+    Insn *condBr = cgFunc->GetTheCFG()->FindLastCondBrInsn(*preBB);
+    std::vector<Insn*> cselInsn = presCselInsn[i];
+    /* insert csel insn */
+    for (Insn *csel : cselInsn) {
+      preBB->InsertInsnBefore(*condBr, *csel);
+    }
+    /* new condBr */
+    condBr->SetOperand(condBr->GetOperandSize() - 1, *labelOpnd[0]);
+  }
+  /* Remove branches and merge gotoBB */
+  cgFunc->GetTheCFG()->RemoveBB(gotoBB);
+  return true;
+}
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_insn.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_insn.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..390de992738e9db28ef86e0c4d2b027a56f37858
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_insn.cpp
@@ -0,0 +1,603 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_insn.h"
+#include "aarch64_cg.h"
+#include "common_utils.h"
+#include "insn.h"
+#include "metadata_layout.h"
+#include <fstream>
+
+namespace maplebe {
+
+void A64OpndEmitVisitor::EmitIntReg(const RegOperand &v, int32 opndSz) {
+  CHECK_FATAL(v.GetRegisterType() == kRegTyInt, "wrong Type");
+  int32 opndSize = (opndSz == kMaxSimm32) ? static_cast<int32>(v.GetSize()) : opndSz;
+  ASSERT((opndSize == k32BitSizeInt || opndSize == k64BitSizeInt), "illegal register size");
+#ifdef USE_32BIT_REF
+  bool r32 = (opndSize == k32BitSizeInt) || isRefField;
+#else
+  bool r32 = (opndSize == k32BitSizeInt);
+#endif  /* USE_32BIT_REF */
+  (void)emitter.Emit(AArch64CG::intRegNames[(r32 ? AArch64CG::kR32List : AArch64CG::kR64List)][v.GetRegisterNumber()]);
+}
+
+void A64OpndEmitVisitor::Visit(maplebe::RegOperand *v) {
+  ASSERT(opndProp == nullptr || opndProp->IsRegister(),
+         "operand type doesn't match");
+  uint32 size = v->GetSize();
+  regno_t regNO = v->GetRegisterNumber();
+  uint32 opndSize = (opndProp != nullptr) ? opndProp->GetSize() : size;
+  switch (v->GetRegisterType()) {
+    case kRegTyInt: {
+      EmitIntReg(*v, static_cast<int32>(opndSize));
+      break;
+    }
+    case kRegTyFloat: {
+      ASSERT((opndSize == k8BitSize || opndSize == k16BitSize || opndSize == k32BitSize ||
+          opndSize == k64BitSize || opndSize == k128BitSize), "illegal register size");
+      if (opndProp->IsVectorOperand() && v->GetVecLaneSize() != 0) {
+        EmitVectorOperand(*v);
+      } else {
+        /* FP reg cannot be reffield. 8~0, 16~1, 32~2, 64~3. 8 is 1000b, has 3 zero. */
+        int32 regSet = __builtin_ctz(static_cast<uint32>(opndSize)) - 3;
+        (void)emitter.Emit(AArch64CG::intRegNames[static_cast<uint32>(regSet)][regNO]);
+      }
+      break;
+    }
+    default:
+      ASSERT(false, "NYI");
+      break;
+  }
+}
+
+void A64OpndEmitVisitor::Visit(maplebe::ImmOperand *v) {
+  if (v->IsOfstImmediate()) {
+    Visit(static_cast<OfstOperand*>(v));
+    return;
+  }
+
+  if (v->IsStImmediate()) {
+    Visit(*v->GetSymbol(), v->GetValue());
+    return;
+  }
+
+  int64 value = v->GetValue();
+  bool isNegative = (value < 0);
+  if (!v->IsFmov()) {
+    value = (v->GetSize() == k64BitSize ? value : (isNegative ?
+      static_cast<int64>(static_cast<int32>(value)) : static_cast<int64>(static_cast<uint32>(value))));
+    (void)emitter.Emit((opndProp != nullptr && opndProp->IsLoadLiteral()) ? "=" : "#").Emit(value);
+    return;
+  }
+  if (v->GetKind() == Operand::kOpdFPImmediate) {
+    CHECK_FATAL(value == 0, "NIY");
+    (void)emitter.Emit("#0.0");
+  }
+  /*
+   * compute float value
+   * use top 4 bits expect MSB of value . then calculate its fourth power
+   */
+  int32 exp = static_cast<int32>((((static_cast<uint32>(value) & 0x70) >> 4) ^ 0x4) - 3);
+  /* use the lower four bits of value in this expression */
+  const float mantissa = 1.0 + (static_cast<float>(static_cast<uint64>(value) & 0xf) / 16.0);
+  float result = static_cast<float>(std::pow(2, exp)) * mantissa;
+
+  std::stringstream ss;
+  ss << std::setprecision(10) << result;
+  std::string res;
+  ss >> res;
+  size_t dot = res.find('.');
+  if (dot == std::string::npos) {
+    res += ".0";
+    dot = res.find('.');
+    CHECK_FATAL(dot != std::string::npos, "cannot find in string");
+  }
+  (void)res.erase(dot, 1);
+  std::string integer(res, 0, 1);
+  std::string fraction(res, 1);
+  while (fraction.size() != 1 && fraction[fraction.size() - 1] == '0') {
+    fraction.pop_back();
+  }
+  /* fetch the sign bit of this value */
+  std::string sign = ((static_cast<uint64>(value) & 0x80) > 0) ? "-" : "";
+  (void)emitter.Emit(sign + integer + "." + fraction + "e+").Emit(static_cast<int64>(dot) - 1);
+}
+
+void A64OpndEmitVisitor::Visit(maplebe::MemOperand *v) {
+  auto a64v = static_cast<MemOperand*>(v);
+  MemOperand::AArch64AddressingMode addressMode = a64v->GetAddrMode();
+#if DEBUG
+  const InsnDesc *md = &AArch64CG::kMd[emitter.GetCurrentMOP()];
+  bool isLDSTpair = md->IsLoadStorePair();
+  ASSERT(md->Is64Bit() || md->GetOperandSize() <= k32BitSize || md->GetOperandSize() == k128BitSize,
+         "unexpected opnd size");
+#endif
+  if (addressMode == MemOperand::kAddrModeBOi) {
+    (void)emitter.Emit("[");
+    auto *baseReg = v->GetBaseRegister();
+    ASSERT(baseReg != nullptr, "expect an RegOperand here");
+    uint32 baseSize = baseReg->GetSize();
+    if (baseSize != k64BitSize) {
+      baseReg->SetSize(k64BitSize);
+    }
+    EmitIntReg(*baseReg);
+    baseReg->SetSize(baseSize);
+    OfstOperand *offset = a64v->GetOffsetImmediate();
+    if (offset != nullptr) {
+#ifndef USE_32BIT_REF  /* can be load a ref here */
+      /*
+       * Cortex-A57 Software Optimization Guide:
+       * The ARMv8-A architecture allows many types of load and store accesses to be arbitrarily aligned.
+       * The Cortex- A57 processor handles most unaligned accesses without performance penalties.
+       */
+#if DEBUG
+      if (a64v->IsOffsetMisaligned(md->GetOperandSize())) {
+        INFO(kLncInfo, "The Memory operand's offset is misaligned:", "");
+
+      }
+#endif
+#endif  /* USE_32BIT_REF */
+      if (a64v->IsPostIndexed()) {
+        ASSERT(!a64v->IsSIMMOffsetOutOfRange(offset->GetOffsetValue(), md->Is64Bit(), isLDSTpair),
+               "should not be SIMMOffsetOutOfRange");
+        (void)emitter.Emit("]");
+        if (!offset->IsZero()) {
+          (void)emitter.Emit(", ");
+          Visit(offset);
+        }
+      } else if (a64v->IsPreIndexed()) {
+        ASSERT(!a64v->IsSIMMOffsetOutOfRange(offset->GetOffsetValue(), md->Is64Bit(), isLDSTpair),
+               "should not be SIMMOffsetOutOfRange");
+        if (!offset->IsZero()) {
+          (void)emitter.Emit(",");
+          Visit(offset);
+        }
+        (void)emitter.Emit("]!");
+      } else {
+        if (CGOptions::IsPIC() && (offset->IsSymOffset() || offset->IsSymAndImmOffset()) &&
+            (offset->GetSymbol()->NeedPIC() || offset->GetSymbol()->IsThreadLocal())) {
+          std::string gotEntry = offset->GetSymbol()->IsThreadLocal() ? ", #:tlsdesc_lo12:" : ", #:got_lo12:";
+          std::string symbolName = offset->GetSymbolName();
+          symbolName += offset->GetSymbol()->GetStorageClass() == kScPstatic && !offset->GetSymbol()->IsConst() ?
+              std::to_string(emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx()) : "";
+          (void)emitter.Emit(gotEntry + symbolName);
+        } else {
+          if (!offset->IsZero()) {
+            (void)emitter.Emit(",");
+            Visit(offset);
+          }
+        }
+        (void)emitter.Emit("]");
+      }
+    } else {
+      (void)emitter.Emit("]");
+    }
+  } else if (addressMode == MemOperand::kAddrModeBOrX) {
+    /*
+     * Base plus offset   | [base{, #imm}]  [base, Xm{, LSL #imm}]   [base, Wm, (S|U)XTW {#imm}]
+     *                      offset_opnds=nullptr
+     *                                      offset_opnds=64          offset_opnds=32
+     *                                      imm=0 or 3               imm=0 or 2, s/u
+     */
+    (void)emitter.Emit("[");
+    auto *baseReg = v->GetBaseRegister();
+    // After ssa version support different size, the value is changed back
+    baseReg->SetSize(k64BitSize);
+
+    EmitIntReg(*baseReg);
+    (void)emitter.Emit(",");
+    EmitIntReg(*a64v->GetIndexRegister());
+    if (a64v->ShouldEmitExtend() || v->GetBaseRegister()->GetSize() > a64v->GetIndexRegister()->GetSize()) {
+      (void)emitter.Emit(",");
+      /* extend, #0, of #3/#2 */
+      (void)emitter.Emit(a64v->GetExtendAsString());
+      if (a64v->GetExtendAsString() == "LSL" || a64v->ShiftAmount() != 0) {
+        (void)emitter.Emit(" #");
+        (void)emitter.Emit(a64v->ShiftAmount());
+      }
+    }
+    (void)emitter.Emit("]");
+  } else if (addressMode == MemOperand::kAddrModeLiteral) {
+    CHECK_FATAL(opndProp != nullptr, "prop is nullptr in  MemOperand::Emit");
+    if (opndProp->IsMemLow12()) {
+      (void)emitter.Emit("#:lo12:");
+    }
+    PUIdx pIdx = emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx();
+    (void)emitter.Emit(v->GetSymbol()->GetName() + std::to_string(pIdx));
+  } else if (addressMode == MemOperand::kAddrModeLo12Li) {
+    (void)emitter.Emit("[");
+    EmitIntReg(*v->GetBaseRegister());
+
+    OfstOperand *offset = a64v->GetOffsetImmediate();
+    ASSERT(offset != nullptr, "nullptr check");
+
+    (void)emitter.Emit(", #:lo12:");
+    if (v->GetSymbol()->GetAsmAttr() != UStrIdx(0) &&
+        (v->GetSymbol()->GetStorageClass() == kScPstatic || v->GetSymbol()->GetStorageClass() == kScPstatic)) {
+      std::string asmSection = GlobalTables::GetUStrTable().GetStringFromStrIdx(v->GetSymbol()->GetAsmAttr());
+      (void)emitter.Emit(asmSection);
+    } else {
+      if (v->GetSymbol()->GetStorageClass() == kScPstatic && v->GetSymbol()->IsLocal()) {
+        PUIdx pIdx = emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx();
+        (void)emitter.Emit(a64v->GetSymbolName() + std::to_string(pIdx));
+      } else {
+        (void)emitter.Emit(a64v->GetSymbolName());
+      }
+    }
+    if (!offset->IsZero()) {
+      (void)emitter.Emit("+");
+      (void)emitter.Emit(std::to_string(offset->GetOffsetValue()));
+    }
+    (void)emitter.Emit("]");
+  } else {
+    ASSERT(false, "nyi");
+  }
+}
+
+void A64OpndEmitVisitor::Visit(LabelOperand *v) {
+  emitter.EmitLabelRef(v->GetLabelIndex());
+}
+
+void A64OpndEmitVisitor::Visit(CondOperand *v) {
+  (void)emitter.Emit(CondOperand::ccStrs[v->GetCode()]);
+}
+
+void A64OpndEmitVisitor::Visit(ExtendShiftOperand *v) {
+  ASSERT(v->GetShiftAmount() <= k4BitSize && v->GetShiftAmount() >= 0,
+         "shift amount out of range in ExtendShiftOperand");
+  auto emitExtendShift = [this, v](const std::string &extendKind)->void {
+    (void)emitter.Emit(extendKind);
+    if (v->GetShiftAmount() != 0) {
+      (void)emitter.Emit(" #").Emit(v->GetShiftAmount());
+    }
+  };
+  switch (v->GetExtendOp()) {
+    case ExtendShiftOperand::kUXTB:
+      emitExtendShift("UXTB");
+      break;
+    case ExtendShiftOperand::kUXTH:
+      emitExtendShift("UXTH");
+      break;
+    case ExtendShiftOperand::kUXTW:
+      emitExtendShift("UXTW");
+      break;
+    case ExtendShiftOperand::kUXTX:
+      emitExtendShift("UXTX");
+      break;
+    case ExtendShiftOperand::kSXTB:
+      emitExtendShift("SXTB");
+      break;
+    case ExtendShiftOperand::kSXTH:
+      emitExtendShift("SXTH");
+      break;
+    case ExtendShiftOperand::kSXTW:
+      emitExtendShift("SXTW");
+      break;
+    case ExtendShiftOperand::kSXTX:
+      emitExtendShift("SXTX");
+      break;
+    default:
+      ASSERT(false, "should not be here");
+      break;
+  }
+}
+
+void A64OpndEmitVisitor::Visit(BitShiftOperand *v) {
+  std::string shiftOp;
+  switch (v->GetShiftOp()) {
+    case BitShiftOperand::kLSL:
+      shiftOp = "LSL #";
+      break;
+    case BitShiftOperand::kLSR:
+      shiftOp = "LSR #";
+      break;
+    case BitShiftOperand::kASR:
+      shiftOp = "ASR #";
+      break;
+    case BitShiftOperand::kROR:
+      shiftOp = "ROR #";
+      break;
+    default:
+      CHECK_FATAL(false, "check shiftOp");
+  }
+  (void)emitter.Emit(shiftOp).Emit(v->GetShiftAmount());
+}
+
+void A64OpndEmitVisitor::Visit(StImmOperand *v) {
+  Visit(*v->GetSymbol(), v->GetOffset());
+}
+
+void A64OpndEmitVisitor::Visit(const MIRSymbol &symbol, int64 offset) {
+  CHECK_FATAL(opndProp != nullptr, "opndProp is nullptr in  StImmOperand::Emit");
+  const bool isThreadLocal = symbol.IsThreadLocal();
+  const bool isLiteralLow12 = opndProp->IsLiteralLow12();
+  const bool hasGotEntry = CGOptions::IsPIC() && symbol.NeedPIC();
+  bool hasPrefix = false;
+  if (isThreadLocal) {
+    (void)emitter.Emit(":tlsdesc");
+    hasPrefix = true;
+  }
+  if (!hasPrefix && hasGotEntry) {
+    (void)emitter.Emit(":got");
+    hasPrefix = true;
+  }
+  if (isLiteralLow12) {
+    std::string lo12String = hasPrefix ? "_lo12" : ":lo12";
+    (void)emitter.Emit(lo12String);
+    hasPrefix = true;
+  }
+  if (hasPrefix) {
+    (void)emitter.Emit(":");
+  }
+  if (symbol.GetAsmAttr() != UStrIdx(0) &&
+      (symbol.GetStorageClass() == kScPstatic || symbol.GetStorageClass() == kScPstatic)) {
+    std::string asmSection = GlobalTables::GetUStrTable().GetStringFromStrIdx(symbol.GetAsmAttr());
+    (void)emitter.Emit(asmSection);
+  } else {
+    if (symbol.GetStorageClass() == kScPstatic && symbol.GetSKind() != kStConst) {
+      (void)emitter.Emit(symbol.GetName() +
+          std::to_string(emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx()));
+    } else {
+      (void)emitter.Emit(symbol.GetName());
+    }
+  }
+  if (!hasGotEntry && offset != 0) {
+    (void)emitter.Emit("+" + std::to_string(offset));
+  }
+}
+
+void A64OpndEmitVisitor::Visit(FuncNameOperand *v) {
+  (void)emitter.Emit(v->GetName());
+}
+
+void A64OpndEmitVisitor::Visit(CommentOperand *v) {
+  (void)emitter.Emit(v->GetComment());
+}
+
+void A64OpndEmitVisitor::Visit(ListOperand *v) {
+  (void)opndProp;
+  size_t nLeft = v->GetOperands().size();
+  if (nLeft == 0) {
+    return;
+  }
+
+  for (auto it = v->GetOperands().cbegin(); it != v->GetOperands().cend(); ++it) {
+    Visit(*it);
+    if (--nLeft >= 1) {
+      (void)emitter.Emit(", ");
+    }
+  }
+}
+
+void A64OpndEmitVisitor::Visit(OfstOperand *v) {
+  int64 value = v->GetValue();
+  if (v->IsImmOffset()) {
+    (void)emitter.Emit((opndProp != nullptr && opndProp->IsLoadLiteral()) ? "=" : "#")
+        .Emit((v->GetSize() == k64BitSize) ? value : static_cast<int64>(static_cast<int32>(value)));
+    return;
+  }
+  const MIRSymbol *symbol = v->GetSymbol();
+  if (CGOptions::IsPIC() && symbol->NeedPIC()) {
+    (void)emitter.Emit(":got:" + symbol->GetName());
+  } else if (symbol->GetStorageClass() == kScPstatic && symbol->GetSKind() != kStConst && symbol->IsLocal()) {
+    (void)emitter.Emit(symbol->GetName() +
+        std::to_string(emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx()));
+  } else {
+    (void)emitter.Emit(symbol->GetName());
+  }
+  if (value != 0) {
+    (void)emitter.Emit("+" + std::to_string(value));
+  }
+}
+
+void A64OpndEmitVisitor::EmitVectorOperand(const RegOperand &v) {
+  std::string width;
+  switch (v.GetVecElementSize()) {
+    case k8BitSize:
+      width = "b";
+      break;
+    case k16BitSize:
+      width = "h";
+      break;
+    case k32BitSize:
+      width = "s";
+      break;
+    case k64BitSize:
+      width = "d";
+      break;
+    default:
+      CHECK_FATAL(false, "unexpected value size for vector element");
+      break;
+  }
+  (void)emitter.Emit(AArch64CG::vectorRegNames[v.GetRegisterNumber()]);
+  int32 lanePos = v.GetVecLanePosition();
+  if (lanePos == -1) {
+    (void)emitter.Emit("." + std::to_string(v.GetVecLaneSize()) + width);
+  } else {
+    (void)emitter.Emit("." + width + "[" + std::to_string(lanePos) + "]");
+  }
+}
+
+void A64OpndDumpVisitor::Visit(RegOperand *v) {
+  std::array<const std::string, kRegTyLast> prims = { "U", "R", "V", "C", "X", "Vra" };
+  std::array<const std::string, kRegTyLast> classes = { "[U]", "[I]", "[F]", "[CC]", "[X87]", "[Vra]" };
+  uint32 regType = v->GetRegisterType();
+  ASSERT(regType < kRegTyLast, "unexpected regType");
+
+  regno_t reg = v->GetRegisterNumber();
+  reg = v->IsVirtualRegister() ? reg : (reg - 1);
+  LogInfo::MapleLogger() << (v->IsVirtualRegister() ? "vreg:" : " reg:") << prims[regType];
+  if (reg + 1 == RSP && v->IsPhysicalRegister()) {
+    LogInfo::MapleLogger() << "SP";
+  } else if (reg + 1 == RZR && v->IsPhysicalRegister()) {
+    LogInfo::MapleLogger() << "ZR";
+  } else {
+    LogInfo::MapleLogger() << reg;
+  }
+  LogInfo::MapleLogger() << " " << classes[regType];
+  uint32 vb = v->GetValidBitsNum();
+  if (vb != v->GetSize()) {
+    LogInfo::MapleLogger() << " Vb: [" << vb << "]";
+  }
+  LogInfo::MapleLogger() << " Sz: [" << v->GetSize() << "]" ;
+}
+
+void A64OpndDumpVisitor::Visit(ImmOperand *v) {
+  if (v->IsStImmediate()) {
+    LogInfo::MapleLogger() << v->GetName();
+    LogInfo::MapleLogger() << "+offset:" << v->GetValue();
+  } else {
+    LogInfo::MapleLogger() << "imm:" << v->GetValue();
+  }
+}
+
+void A64OpndDumpVisitor::Visit(MemOperand *a64v) {
+  LogInfo::MapleLogger() << "Mem:";
+  LogInfo::MapleLogger() << " size:" << a64v->GetSize() << " ";
+  LogInfo::MapleLogger() << " isStack:" << a64v->IsStackMem() << "-" << a64v->IsStackArgMem() << " ";
+  switch (a64v->GetAddrMode()) {
+    case MemOperand::kAddrModeBOi: {
+      LogInfo::MapleLogger() << "base:";
+      ASSERT(a64v->GetBaseRegister(), " lack of base register");
+      Visit(a64v->GetBaseRegister());
+      LogInfo::MapleLogger() << "offset:";
+      if (a64v->GetOffsetOperand()) {
+        Visit(a64v->GetOffsetOperand());
+      }
+      switch (a64v->GetIndexOpt()) {
+        case MemOperand::kIntact:
+          LogInfo::MapleLogger() << "  intact";
+          break;
+        case MemOperand::kPreIndex:
+          LogInfo::MapleLogger() << "  pre-index";
+          break;
+        case MemOperand::kPostIndex:
+          LogInfo::MapleLogger() << "  post-index";
+          break;
+        default:
+          break;
+      }
+      break;
+    }
+    case MemOperand::kAddrModeBOrX: {
+      LogInfo::MapleLogger() << "base:";
+      Visit(a64v->GetBaseRegister());
+      LogInfo::MapleLogger() << "offset:";
+      Visit(a64v->GetIndexRegister());
+      LogInfo::MapleLogger() << " " << a64v->GetExtendAsString();
+      LogInfo::MapleLogger() << " shift: " << a64v->ShiftAmount();
+      LogInfo::MapleLogger() << " extend: " << a64v->GetExtendAsString();
+      break;
+    }
+    case MemOperand::kAddrModeLiteral:
+      LogInfo::MapleLogger() << "literal: " << a64v->GetSymbolName();
+      break;
+    case MemOperand::kAddrModeLo12Li: {
+      LogInfo::MapleLogger() << "base:";
+      Visit(a64v->GetBaseRegister());
+      LogInfo::MapleLogger() << "offset:";
+      OfstOperand *offOpnd = a64v->GetOffsetImmediate();
+      LogInfo::MapleLogger() << "#:lo12:";
+      if (a64v->GetSymbol()->GetStorageClass() == kScPstatic && a64v->GetSymbol()->IsLocal()) {
+        PUIdx pIdx = CG::GetCurCGFunc()->GetMirModule().CurFunction()->GetPuidx();
+        LogInfo::MapleLogger() << a64v->GetSymbolName() << std::to_string(pIdx);
+      } else {
+        LogInfo::MapleLogger() << a64v->GetSymbolName();
+      }
+      LogInfo::MapleLogger() << "+" << std::to_string(offOpnd->GetOffsetValue());
+      break;
+    }
+    default:
+      ASSERT(false, "error memoperand dump");
+      break;
+  }
+}
+
+void A64OpndDumpVisitor::Visit(CondOperand *v) {
+  LogInfo::MapleLogger() << "CC: " << CondOperand::ccStrs[v->GetCode()];
+}
+void A64OpndDumpVisitor::Visit(StImmOperand *v) {
+  LogInfo::MapleLogger() << v->GetName();
+  LogInfo::MapleLogger() << "+offset:" << v->GetOffset();
+}
+void A64OpndDumpVisitor::Visit(BitShiftOperand *v) {
+  BitShiftOperand::ShiftOp shiftOp = v->GetShiftOp();
+  uint32 shiftAmount = v->GetShiftAmount();
+  LogInfo::MapleLogger() << ((shiftOp == BitShiftOperand::kLSL) ? "LSL: " :
+      ((shiftOp == BitShiftOperand::kLSR) ? "LSR: " : "ASR: "));
+  LogInfo::MapleLogger() << shiftAmount;
+}
+void A64OpndDumpVisitor::Visit(ExtendShiftOperand *v) {
+  auto dumpExtendShift = [v](const std::string &extendKind)->void {
+    LogInfo::MapleLogger() << extendKind;
+    if (v->GetShiftAmount() != 0) {
+      LogInfo::MapleLogger() << " : " << v->GetShiftAmount();
+    }
+  };
+  switch (v->GetExtendOp()) {
+    case ExtendShiftOperand::kUXTB:
+      dumpExtendShift("UXTB");
+      break;
+    case ExtendShiftOperand::kUXTH:
+      dumpExtendShift("UXTH");
+      break;
+    case ExtendShiftOperand::kUXTW:
+      dumpExtendShift("UXTW");
+      break;
+    case ExtendShiftOperand::kUXTX:
+      dumpExtendShift("UXTX");
+      break;
+    case ExtendShiftOperand::kSXTB:
+      dumpExtendShift("SXTB");
+      break;
+    case ExtendShiftOperand::kSXTH:
+      dumpExtendShift("SXTH");
+      break;
+    case ExtendShiftOperand::kSXTW:
+      dumpExtendShift("SXTW");
+      break;
+    case ExtendShiftOperand::kSXTX:
+      dumpExtendShift("SXTX");
+      break;
+    default:
+      ASSERT(false, "should not be here");
+      break;
+  }
+}
+void A64OpndDumpVisitor::Visit(LabelOperand *v) {
+  LogInfo::MapleLogger() << "label:" << v->GetLabelIndex();
+}
+void A64OpndDumpVisitor::Visit(FuncNameOperand *v) {
+  LogInfo::MapleLogger() << "func :" << v->GetName();
+}
+void A64OpndDumpVisitor::Visit(CommentOperand *v) {
+  LogInfo::MapleLogger() << " #" << v->GetComment();
+}
+void A64OpndDumpVisitor::Visit(PhiOperand *v) {
+  auto &phiList = v->GetOperands();
+  for (auto it = phiList.cbegin(); it != phiList.cend();) {
+    Visit(it->second);
+    LogInfo::MapleLogger() << " fBB<" << it->first << ">";
+    LogInfo::MapleLogger() << (++it == phiList.end() ? "" : " ,");
+  }
+}
+void A64OpndDumpVisitor::Visit(ListOperand *v) {
+  auto &opndList = v->GetOperands();
+  for (auto it = opndList.cbegin(); it != opndList.cend();) {
+    Visit(*it);
+    LogInfo::MapleLogger() << (++it == opndList.end() ? "" : " ,");
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_isa.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_isa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..517d7184ed2dcb8ac0ccd299a1ff84de5f798945
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_isa.cpp
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "aarch64_isa.h"
+#include "insn.h"
+
+namespace maplebe {
+/*
+ * Get the ldp/stp corresponding to ldr/str
+ * mop : a ldr or str machine operator
+ */
+MOperator GetMopPair(MOperator mop) {
+  switch (mop) {
+    case MOP_xldr:
+      return MOP_xldp;
+    case MOP_wldr:
+      return MOP_wldp;
+    case MOP_xstr:
+      return MOP_xstp;
+    case MOP_wstr:
+      return MOP_wstp;
+    case MOP_dldr:
+      return MOP_dldp;
+    case MOP_qldr:
+      return MOP_qldp;
+    case MOP_sldr:
+      return MOP_sldp;
+    case MOP_dstr:
+      return MOP_dstp;
+    case MOP_sstr:
+      return MOP_sstp;
+    case MOP_qstr:
+      return MOP_qstp;
+    default:
+      ASSERT(false, "should not run here");
+      return MOP_undef;
+  }
+}
+namespace AArch64isa {
+MOperator FlipConditionOp(MOperator flippedOp) {
+  switch (flippedOp) {
+    case AArch64MOP_t::MOP_beq:
+      return AArch64MOP_t::MOP_bne;
+    case AArch64MOP_t::MOP_bge:
+      return AArch64MOP_t::MOP_blt;
+    case AArch64MOP_t::MOP_bgt:
+      return AArch64MOP_t::MOP_ble;
+    case AArch64MOP_t::MOP_bhi:
+      return AArch64MOP_t::MOP_bls;
+    case AArch64MOP_t::MOP_bhs:
+      return AArch64MOP_t::MOP_blo;
+    case AArch64MOP_t::MOP_ble:
+      return AArch64MOP_t::MOP_bgt;
+    case AArch64MOP_t::MOP_blo:
+      return AArch64MOP_t::MOP_bhs;
+    case AArch64MOP_t::MOP_bls:
+      return AArch64MOP_t::MOP_bhi;
+    case AArch64MOP_t::MOP_blt:
+      return AArch64MOP_t::MOP_bge;
+    case AArch64MOP_t::MOP_bne:
+      return AArch64MOP_t::MOP_beq;
+    case AArch64MOP_t::MOP_bpl:
+      return AArch64MOP_t::MOP_bmi;
+    case AArch64MOP_t::MOP_xcbnz:
+      return AArch64MOP_t::MOP_xcbz;
+    case AArch64MOP_t::MOP_wcbnz:
+      return AArch64MOP_t::MOP_wcbz;
+    case AArch64MOP_t::MOP_xcbz:
+      return AArch64MOP_t::MOP_xcbnz;
+    case AArch64MOP_t::MOP_wcbz:
+      return AArch64MOP_t::MOP_wcbnz;
+    case AArch64MOP_t::MOP_wtbnz:
+      return AArch64MOP_t::MOP_wtbz;
+    case AArch64MOP_t::MOP_wtbz:
+      return AArch64MOP_t::MOP_wtbnz;
+    case AArch64MOP_t::MOP_xtbnz:
+      return AArch64MOP_t::MOP_xtbz;
+    case AArch64MOP_t::MOP_xtbz:
+      return AArch64MOP_t::MOP_xtbnz;
+    default:
+      break;
+  }
+  return AArch64MOP_t::MOP_undef;
+}
+
+uint32 GetJumpTargetIdx(const Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  switch (curMop) {
+    /* unconditional jump */
+    case MOP_xuncond: {
+      return kInsnFirstOpnd;
+    }
+    case MOP_xbr: {
+      ASSERT(insn.GetOperandSize() == 2, "ERR");
+      return kInsnSecondOpnd;
+    }
+    /* conditional jump */
+    case MOP_bcc:
+    case MOP_bcs:
+    case MOP_bmi:
+    case MOP_bvc:
+    case MOP_bls:
+    case MOP_blt:
+    case MOP_ble:
+    case MOP_blo:
+    case MOP_beq:
+    case MOP_bpl:
+    case MOP_bhs:
+    case MOP_bvs:
+    case MOP_bhi:
+    case MOP_bgt:
+    case MOP_bge:
+    case MOP_bne:
+    case MOP_wcbz:
+    case MOP_xcbz:
+    case MOP_wcbnz:
+    case MOP_xcbnz: {
+      return kInsnSecondOpnd;
+    }
+    case MOP_wtbz:
+    case MOP_xtbz:
+    case MOP_wtbnz:
+    case MOP_xtbnz: {
+      return kInsnThirdOpnd;
+    }
+    default:
+      CHECK_FATAL(false, "Not a jump insn");
+  }
+  return kInsnFirstOpnd;
+}
+} /* namespace AArch64isa */
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_isolate_fastpath.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_isolate_fastpath.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cdfca0954444a561d125dcd1bf873cdab86ad3ac
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_isolate_fastpath.cpp
@@ -0,0 +1,432 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_isolate_fastpath.h"
+#include "aarch64_cg.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+bool AArch64IsolateFastPath::FindRegs(Operand &op, std::set<regno_t> &vecRegs) const {
+  Operand *opnd = &op;
+  if (opnd == nullptr || vecRegs.empty()) {
+    return false;
+  }
+  if (opnd->IsList()) {
+    MapleList<RegOperand*> pregList = static_cast<ListOperand *>(opnd)->GetOperands();
+    for (auto *preg : as_const(pregList)) {
+      if (preg->GetRegisterNumber() == R29 ||
+          vecRegs.find(preg->GetRegisterNumber()) != vecRegs.end()) {
+        return true;  /* the opReg will overwrite or reread the vecRegs */
+      }
+    }
+  }
+  if (opnd->IsMemoryAccessOperand()) {  /* the registers of kOpdMem are complex to be detected */
+    RegOperand *baseOpnd = static_cast<MemOperand *>(opnd)->GetBaseRegister();
+    RegOperand *indexOpnd = static_cast<MemOperand *>(opnd)->GetIndexRegister();
+    if ((baseOpnd != nullptr && baseOpnd->GetRegisterNumber() == R29) ||
+        (indexOpnd != nullptr && indexOpnd->GetRegisterNumber() == R29)) {
+      return true;  /* Avoid modifying data on the stack */
+    }
+    if ((baseOpnd != nullptr && vecRegs.find(baseOpnd->GetRegisterNumber()) != vecRegs.end()) ||
+        (indexOpnd != nullptr && vecRegs.find(indexOpnd->GetRegisterNumber()) != vecRegs.end())) {
+      return true;
+    }
+  }
+  if (opnd->IsRegister()) {
+    RegOperand *regOpnd = static_cast<RegOperand *>(opnd);
+    if (regOpnd->GetRegisterNumber() == R29 ||
+        vecRegs.find(regOpnd->GetRegisterNumber()) != vecRegs.end()) {
+      return true;  /* dst is a target register, result_dst is a target register */
+    }
+  }
+  return false;
+}
+
+bool AArch64IsolateFastPath::InsertOpndRegs(Operand &op, std::set<regno_t> &vecRegs) const {
+  Operand *opnd = &op;
+  if (opnd->IsList()) {
+    MapleList<RegOperand *> pregList = static_cast<ListOperand *>(opnd)->GetOperands();
+    for (auto *preg : as_const(pregList)) {
+      if (preg != nullptr) {
+        (void)vecRegs.insert(preg->GetRegisterNumber());
+      }
+    }
+  }
+  if (opnd->IsMemoryAccessOperand()) { /* the registers of kOpdMem are complex to be detected */
+    RegOperand *baseOpnd = static_cast<MemOperand *>(opnd)->GetBaseRegister();
+    if (baseOpnd != nullptr) {
+      (void)vecRegs.insert(baseOpnd->GetRegisterNumber());
+    }
+    RegOperand *indexOpnd = static_cast<MemOperand *>(opnd)->GetIndexRegister();
+    if (indexOpnd != nullptr) {
+      (void)vecRegs.insert(indexOpnd->GetRegisterNumber());
+    }
+  }
+  if (opnd->IsRegister()) {
+    RegOperand *preg = static_cast<RegOperand *>(opnd);
+    if (preg != nullptr) {
+      (void)vecRegs.insert(preg->GetRegisterNumber());
+    }
+  }
+  return true;
+}
+
+bool AArch64IsolateFastPath::InsertInsnRegs(Insn &insn, bool insertSource, std::set<regno_t> &vecSourceRegs,
+                                            bool insertTarget, std::set<regno_t> &vecTargetRegs) const {
+  Insn *curInsn = &insn;
+  for (uint32 o = 0; o < curInsn->GetOperandSize(); ++o) {
+    Operand &opnd = curInsn->GetOperand(o);
+    if (insertSource && curInsn->OpndIsUse(o)) {
+      (void)InsertOpndRegs(opnd, vecSourceRegs);
+    }
+    if (insertTarget && curInsn->OpndIsDef(o)) {
+      (void)InsertOpndRegs(opnd, vecTargetRegs);
+    }
+  }
+  return true;
+}
+
+bool AArch64IsolateFastPath::BackwardFindDependency(BB &ifbb, std::set<regno_t> &vecReturnSourceRegs,
+                                                    std::list<Insn*> &existingInsns,
+                                                    std::list<Insn*> &moveInsns) const {
+  /*
+   * Pattern match,(*) instruction are moved down below branch.
+   *   ********************
+   *   curInsn: <instruction> <target> <source>
+   *   <existingInsns> in predBB
+   *   <existingInsns> in ifBB
+   *   <existingInsns> in returnBB
+   *   *********************
+   *                        list: the insns can be moved into the coldBB
+   * (1) the instruction is neither a branch nor a call, except for the ifbb.GetLastInsn()
+   *     As long as a branch insn exists,
+   *     the fast path finding fails and the return value is false,
+   *     but the code sinking can be continued.
+   * (2) the predBB is not a ifBB,
+   *     As long as a ifBB in preds exists,
+   *     the code sinking fails,
+   *     but fast path finding can be continued.
+   * (3) the targetRegs of insns in existingInsns can neither be reread or overwrite
+   * (4) the sourceRegs of insns in existingInsns can not be overwrite
+   * (5) the sourceRegs of insns in returnBB can neither be reread or overwrite
+   * (6) the targetRegs and sourceRegs cannot be R29 R30, to protect the stack
+   * (7) modified the reg when:
+   *     --------------
+   *     curInsn: move R2,R1
+   *     <existingInsns>: <instruction>s <target>s <source>s
+   *                      <instruction>s <target>s <source-R2>s
+   *                      -> <instruction>s <target>s <source-R1>s
+   *     ------------
+   *     (a) all targets cannot be R1, all sources cannot be R1
+   *         all targets cannot be R2, all return sources cannot be R2
+   *     (b) the targetRegs and sourceRegs cannot be list or MemoryAccess
+   *     (c) no ifBB in preds, no branch insns
+   *     (d) the bits of source-R2 must be equal to the R2
+   *     (e) replace the R2 with R1
+   */
+  BB *pred = &ifbb;
+  std::set<regno_t> vecTargetRegs; /* the targrtRegs of existingInsns */
+  std::set<regno_t> vecSourceRegs; /* the soureRegs of existingInsns */
+  bool ifPred = false; /* Indicates whether a ifBB in pred exists */
+  bool bl = false; /* Indicates whether a branch insn exists */
+  do {
+    FOR_BB_INSNS_REV(insn, pred) {
+      /* code sinking */
+      if (insn->IsImmaterialInsn()) {
+        moveInsns.push_back(insn);
+        continue;
+      }
+      /* code sinking */
+      if (!insn->IsMachineInstruction()) {
+        moveInsns.push_back(insn);
+        continue;
+      }
+      /* code sinking fails, the insns must be retained in the ifBB */
+      if (ifPred || insn == ifbb.GetLastInsn() || insn->IsBranch() || insn->IsCall() ||
+          insn->IsStore() || insn->IsStorePair()) {
+        /* fast path finding fails */
+        if (insn != ifbb.GetLastInsn() && (insn->IsBranch() || insn->IsCall() ||
+            insn->IsStore() || insn->IsStorePair())) {
+          bl = true;
+        }
+        (void)InsertInsnRegs(*insn, true, vecSourceRegs, true, vecTargetRegs);
+        existingInsns.push_back(insn);
+        continue;
+      }
+      bool allow = true;  /* whether allow this insn move into the codeBB */
+      for (uint32 o = 0; allow && o < insn->GetOperandSize(); ++o) {
+        Operand &opnd = insn->GetOperand(o);
+        if (insn->OpndIsDef(o)) {
+          allow = allow && !FindRegs(opnd, vecTargetRegs);
+          allow = allow && !FindRegs(opnd, vecSourceRegs);
+          allow = allow && !FindRegs(opnd, vecReturnSourceRegs);
+        }
+        if (insn->OpndIsUse(o)) {
+          allow = allow && !FindRegs(opnd, vecTargetRegs);
+        }
+      }
+      /* if a result_dst not allowed, this insn can be allowed on the condition of mov Rx,R0/R1,
+       * and tje existing insns cannot be blr
+       * RLR 31, RFP 32, RSP 33, RZR 34 */
+      if (!ifPred && !bl && !allow && (insn->GetMachineOpcode() == MOP_xmovrr ||
+          insn->GetMachineOpcode() == MOP_wmovrr)) {
+        Operand *resultOpnd = &(insn->GetOperand(0));
+        Operand *srcOpnd = &(insn->GetOperand(1));
+        regno_t resultNO = static_cast<RegOperand *>(resultOpnd)->GetRegisterNumber();
+        regno_t srcNO = static_cast<RegOperand *>(srcOpnd)->GetRegisterNumber();
+        if (!FindRegs(*resultOpnd, vecTargetRegs) && !FindRegs(*srcOpnd, vecTargetRegs) &&
+            !FindRegs(*srcOpnd, vecSourceRegs) && !FindRegs(*srcOpnd, vecReturnSourceRegs) &&
+            (srcNO < RLR || srcNO > RZR)) {
+          allow = true; /* allow on the conditional mov Rx,Rxx */
+          for (auto *exit : as_const(existingInsns)) {
+            /* the registers of kOpdMem are complex to be detected */
+            for (uint32 o = 0; o < exit->GetOperandSize(); ++o) {
+              if (!exit->OpndIsUse(o)) {
+                continue;
+              }
+              Operand *opd = &(exit->GetOperand(o));
+              if (opd->IsList() || opd->IsMemoryAccessOperand()) {
+                allow = false;
+                break;
+              }
+              /* Distinguish between 32-bit regs and 64-bit regs */
+              if (opd->IsRegister() &&
+                  static_cast<RegOperand *>(opd)->GetRegisterNumber() == resultNO &&
+                  opd != resultOpnd) {
+                allow = false;
+                break;
+              }
+            }
+          }
+        }
+        /* replace the R2 with R1 */
+        if (allow) {
+          for (auto *exit : existingInsns) {
+            for (uint32 o = 0; o < exit->GetOperandSize(); ++o) {
+              if (!exit->OpndIsUse(o)) {
+                continue;
+              }
+              Operand *opd = &(exit->GetOperand(o));
+              if (opd->IsRegister() && (opd == resultOpnd)) {
+                exit->SetOperand(o, *srcOpnd);
+              }
+            }
+          }
+        }
+      }
+      if (!allow) { /* all result_dsts are not target register */
+        /* code sinking fails */
+        (void)InsertInsnRegs(*insn, true, vecSourceRegs, true, vecTargetRegs);
+        existingInsns.push_back(insn);
+      } else {
+        moveInsns.push_back(insn);
+      }
+    }
+    if (pred->GetPreds().empty()) {
+      break;
+    }
+    if (!ifPred) {
+      for (auto *tmPred : pred->GetPreds()) {
+        pred = tmPred;
+        /* try to find the BB without branch */
+        if (tmPred->GetKind() == BB::kBBGoto || tmPred->GetKind() == BB::kBBFallthru) {
+          ifPred = false;
+          break;
+        } else {
+          ifPred = true;
+        }
+      }
+    }
+  } while (pred != nullptr);
+  for (std::set<regno_t>::iterator it = vecTargetRegs.begin(); it != vecTargetRegs.end(); ++it) {
+    if (AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(*it))) { /* flag register */
+      return false;
+    }
+  }
+  return !bl;
+}
+
+void AArch64IsolateFastPath::IsolateFastPathOpt() {
+  /*
+   * Detect "if (cond) return" fast path, and move extra instructions
+   * to the slow path.
+   * Must match the following block structure. BB1 can be a series of
+   * single-pred/single-succ blocks.
+   *     BB1 ops1 cmp-br to BB3        BB1 cmp-br to BB3
+   *     BB2 ops2 br to retBB    ==>   BB2 ret
+   *     BB3 slow path                 BB3 ops1 ops2
+   * if the detect is successful, BB3 will be used to generate prolog stuff.
+   */
+  BB &bb = *cgFunc.GetFirstBB();
+  if (bb.GetPrev() != nullptr) {
+    return;
+  }
+  BB *ifBB = nullptr;
+  BB *returnBB = nullptr;
+  BB *coldBB = nullptr;
+  {
+    BB *curBB = &bb;
+    /* Look for straight line code */
+    while (1) {
+      if (!curBB->GetEhSuccs().empty()) {
+        return;
+      }
+      if (curBB->GetSuccs().size() == 1) {
+        if (curBB->HasCall()) {
+          return;
+        }
+        BB *succ = curBB->GetSuccs().front();
+        if (succ->GetPreds().size() != 1 || !succ->GetEhPreds().empty()) {
+          return;
+        }
+        curBB = succ;
+      } else if (curBB->GetKind() == BB::kBBIf) {
+        ifBB = curBB;
+        break;
+      } else {
+        return;
+      }
+    }
+  }
+  /* targets of if bb can only be reached by if bb */
+  {
+    CHECK_FATAL(!ifBB->GetSuccs().empty(), "null succs check!");
+    BB *first = ifBB->GetSuccs().front();
+    BB *second = ifBB->GetSuccs().back();
+    if (first->GetPreds().size() != 1 || !first->GetEhPreds().empty()) {
+      return;
+    }
+    if (second->GetPreds().size() != 1 || !second->GetEhPreds().empty()) {
+      return;
+    }
+    /* One target of the if bb jumps to a return bb */
+    if (first->GetKind() != BB::kBBGoto && first->GetKind() != BB::kBBFallthru) {
+      return;
+    }
+    if (first->GetSuccs().size() != 1) {
+      return;
+    }
+    if (first->GetSuccs().front()->GetKind() != BB::kBBReturn) {
+      return;
+    }
+    if (first->GetSuccs().front()->GetPreds().size() != 1) {
+      return;
+    }
+    constexpr int32 maxNumInsn = 2;
+    if (first->GetSuccs().front()->NumInsn() > maxNumInsn) { /* avoid a insn is used to debug */
+      return;
+    }
+    if (second->GetSuccs().empty()) {
+      return;
+    }
+    returnBB = first;
+    coldBB = second;
+  }
+  /* Search backward looking for dependencies for the cond branch */
+  std::list<Insn*> existingInsns; /* the insns must be retained in the ifBB (and the return BB) */
+  std::list<Insn*> moveInsns; /* instructions to be moved to coldbb */
+  /*
+   * The control flow matches at this point.
+   * Make sure the SourceRegs of the insns in returnBB (vecReturnSourceReg) cannot be overwrite.
+   * the regs in insns have three forms: list, MemoryAccess, or Register.
+   */
+  CHECK_FATAL(returnBB != nullptr, "null ptr check");
+  std::set<regno_t> vecReturnSourceRegs;
+  FOR_BB_INSNS_REV(insn, returnBB) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    if (insn->IsBranch() || insn->IsCall() || insn->IsStore() || insn->IsStorePair()) {
+      return;
+    }
+    (void)InsertInsnRegs(*insn, true, vecReturnSourceRegs, false, vecReturnSourceRegs);
+    existingInsns.push_back(insn);
+  }
+  FOR_BB_INSNS_REV(insn, returnBB->GetSuccs().front()) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    if (insn->IsBranch() || insn->IsCall() || insn->IsStore() || insn->IsStorePair()) {
+      return;
+    }
+    (void)InsertInsnRegs(*insn, true, vecReturnSourceRegs, false, vecReturnSourceRegs);
+    existingInsns.push_back(insn);
+  }
+  /*
+   * The mv is the 1st move using the parameter register leading to the branch
+   * The ld is the load using the parameter register indirectly for the branch
+   * The depMv is the move which preserves the result of the load but might
+   *    destroy a parameter register which will be moved below the branch.
+   */
+  bool fast = BackwardFindDependency(*ifBB, vecReturnSourceRegs, existingInsns, moveInsns);
+  /* move extra instructions to the slow path */
+  if (!fast) {
+    return;
+  }
+  for (auto &in : as_const(moveInsns)) {
+    in->GetBB()->RemoveInsn(*in);
+    CHECK_FATAL(coldBB != nullptr, "null ptr check");
+    coldBB->InsertInsnBegin(*in);
+  }
+  /* All instructions are in the right place, replace branch to ret bb to just ret. */
+  /* Remove the lastInsn of gotoBB */
+  if (returnBB->GetKind() == BB::kBBGoto) {
+    returnBB->RemoveInsn(*returnBB->GetLastInsn());
+  }
+  BB *tgtBB = returnBB->GetSuccs().front();
+  CHECK_FATAL(tgtBB->GetKind() == BB::kBBReturn, "check return bb of isolatefastpatch");
+  CHECK_FATAL(tgtBB != nullptr, "null ptr check");
+  FOR_BB_INSNS(insn, tgtBB) {
+    returnBB->AppendInsn(*insn);  /* add the insns such as MOP_xret */
+  }
+  returnBB->AppendInsn(cgFunc.GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_xret));
+  /* bb is now a retbb and has no succ. */
+  returnBB->SetKind(BB::kBBReturn);
+
+  // add to exitvec and common exitpreds
+  BB* commonExit = cgFunc.GetCommonExitBB();
+  auto cEpredtgt = std::find(commonExit->GetPredsBegin(), commonExit->GetPredsEnd(), tgtBB);
+  auto cEpredreturn = std::find(commonExit->GetPredsBegin(), commonExit->GetPredsEnd(), returnBB);
+  if (cEpredtgt == commonExit->GetPredsEnd() || cEpredreturn != commonExit->GetPredsEnd()) {
+    CHECK_FATAL(false, "check case in isolatefast");
+  }
+  commonExit->RemovePreds(*tgtBB);
+  commonExit->PushBackPreds(*returnBB);
+
+  auto commonExitVecTgt = std::find(cgFunc.GetExitBBsVec().begin(), cgFunc.GetExitBBsVec().end(), tgtBB);
+  auto commonExitVecRet = std::find(cgFunc.GetExitBBsVec().begin(), cgFunc.GetExitBBsVec().end(), returnBB);
+  if (commonExitVecTgt == cgFunc.GetExitBBsVec().end() || commonExitVecRet != cgFunc.GetExitBBsVec().end()) {
+    CHECK_FATAL(false, "check case in isolatefast");
+  }
+  (void)cgFunc.GetExitBBsVec().erase(commonExitVecTgt);
+  cgFunc.GetExitBBsVec().push_back(returnBB);
+
+  MapleList<BB*>::const_iterator predIt = std::find(tgtBB->GetPredsBegin(), tgtBB->GetPredsEnd(), returnBB);
+  tgtBB->ErasePreds(predIt);
+  tgtBB->ClearInsns();
+  returnBB->ClearSuccs();
+  if (tgtBB->GetPrev() != nullptr && tgtBB->GetNext() != nullptr) {
+    tgtBB->GetPrev()->SetNext(tgtBB->GetNext());
+    tgtBB->GetNext()->SetPrev(tgtBB->GetPrev());
+  }
+  SetFastPathReturnBB(returnBB);
+  cgFunc.SetPrologureBB(*coldBB);
+}
+
+void AArch64IsolateFastPath::Run() {
+  IsolateFastPathOpt();
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_live.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_live.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e44853b46ec3667a5b2795a3ee1628ea52f275c
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_live.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_live.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+void AArch64LiveAnalysis::GenerateReturnBBDefUse(BB &bb) const {
+  PrimType returnType = cgFunc->GetFunction().GetReturnType()->GetPrimType();
+  auto *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  if (IsPrimitiveFloat(returnType)) {
+    Operand &phyOpnd =
+        aarchCGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(V0), k64BitSize, kRegTyFloat);
+    CollectLiveInfo(bb, phyOpnd, false, true);
+  } else if (IsPrimitiveInteger(returnType)) {
+    Operand &phyOpnd =
+        aarchCGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(R0), k64BitSize, kRegTyInt);
+    CollectLiveInfo(bb, phyOpnd, false, true);
+  }
+}
+
+void AArch64LiveAnalysis::InitEhDefine(BB &bb) {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+
+  /* Insert MOP_pseudo_eh_def_x R1. */
+  RegOperand &regR1 = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(R1, k64BitSize, kRegTyInt);
+  Insn &pseudoInsn1 = cgFunc->GetInsnBuilder()->BuildInsn(MOP_pseudo_eh_def_x, regR1);
+  bb.InsertInsnBegin(pseudoInsn1);
+
+  /* Insert MOP_pseudo_eh_def_x R0. */
+  RegOperand &regR0 = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, kRegTyInt);
+  Insn &pseudoInsn2 = cgFunc->GetInsnBuilder()->BuildInsn(MOP_pseudo_eh_def_x, regR0);
+  bb.InsertInsnBegin(pseudoInsn2);
+}
+
+bool AArch64LiveAnalysis::CleanupBBIgnoreReg(regno_t reg) {
+  regno_t regNO = reg + R0;
+  if (regNO < R8 || (RLR <= regNO && regNO <= RZR)) {
+    return true;
+  }
+  return false;
+}
+
+void AArch64LiveAnalysis::ProcessCallInsnParam(BB &bb, const Insn &insn) const {
+  /* R0 ~ R7（R0 + 0  ~ R0 + 7） and V0 ~ V7 (V0 + 0 ~ V0 + 7) is parameter register */
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  auto *targetOpnd = insn.GetCallTargetOperand();
+  CHECK_FATAL(targetOpnd != nullptr, "target is null in Insn::IsCallToFunctionThatNeverReturns");
+  if (CGOptions::DoIPARA() && targetOpnd->IsFuncNameOpnd()) {
+    FuncNameOperand *target = static_cast<FuncNameOperand*>(targetOpnd);
+    const MIRSymbol *funcSt = target->GetFunctionSymbol();
+    ASSERT(funcSt->GetSKind() == kStFunc, "funcst must be a function name symbol");
+    MIRFunction *func = funcSt->GetFunction();
+    if (func != nullptr && func->IsReferedRegsValid()) {
+      for (auto preg : func->GetReferedRegs()) {
+        if (AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(preg))) {
+          continue;
+        }
+        RegOperand *opnd = &aarchCGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(preg), k64BitSize,
+            AArch64isa::IsFPSIMDRegister(static_cast<AArch64reg>(preg)) ? kRegTyFloat : kRegTyInt);
+        CollectLiveInfo(bb, *opnd, true, false);
+      }
+      return;
+    }
+  }
+  for (uint32 i = 0; i < 8; ++i) {
+    Operand &phyOpndR =
+        aarchCGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(R0 + i), k64BitSize, kRegTyInt);
+    CollectLiveInfo(bb, phyOpndR, true, false);
+    Operand &phyOpndV =
+        aarchCGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(V0 + i), k64BitSize, kRegTyFloat);
+    CollectLiveInfo(bb, phyOpndV, true, false);
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_memlayout.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_memlayout.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..19bfb4a15452a83809ba16d5c0be162fe6e8f397
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_memlayout.cpp
@@ -0,0 +1,586 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_memlayout.h"
+#include "aarch64_cgfunc.h"
+#include "becommon.h"
+#include "mir_nodes.h"
+
+namespace maplebe {
+using namespace maple;
+
+/*
+ *  Returns stack space required for a call
+ *  which is used to pass arguments that cannot be
+ *  passed through registers
+ */
+uint32 AArch64MemLayout::ComputeStackSpaceRequirementForCall(StmtNode &stmt,  int32 &aggCopySize, bool isIcall) {
+  /* instantiate a parm locator */
+  AArch64CallConvImpl parmLocator(be);
+  uint32 sizeOfArgsToStkPass = 0;
+  uint32 i = 0;
+  /* An indirect call's first operand is the invocation target */
+  if (isIcall) {
+    ++i;
+  }
+
+  if (std::strcmp(stmt.GetOpName(), "call") == 0) {
+    CallNode *callNode = static_cast<CallNode*>(&stmt);
+    MIRFunction *fn = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+    CHECK_FATAL(fn != nullptr, "get MIRFunction failed");
+    MIRSymbol *symbol = be.GetMIRModule().CurFunction()->GetLocalOrGlobalSymbol(fn->GetStIdx(), false);
+    if (symbol->GetName() == "MCC_CallFastNative" || symbol->GetName() == "MCC_CallFastNativeExt" ||
+        symbol->GetName() == "MCC_CallSlowNative0" || symbol->GetName() == "MCC_CallSlowNative1" ||
+        symbol->GetName() == "MCC_CallSlowNative2" || symbol->GetName() == "MCC_CallSlowNative3" ||
+        symbol->GetName() == "MCC_CallSlowNative4" || symbol->GetName() == "MCC_CallSlowNative5" ||
+        symbol->GetName() == "MCC_CallSlowNative6" || symbol->GetName() == "MCC_CallSlowNative7" ||
+        symbol->GetName() == "MCC_CallSlowNative8" || symbol->GetName() == "MCC_CallSlowNativeExt") {
+      ++i;
+    }
+  }
+
+  aggCopySize = 0;
+  for (uint32 anum = 0; i < stmt.NumOpnds(); ++i, ++anum) {
+    BaseNode *opnd = stmt.Opnd(i);
+    MIRType *ty = nullptr;
+    if (opnd->GetPrimType() != PTY_agg) {
+      ty = GlobalTables::GetTypeTable().GetTypeTable()[static_cast<uint32>(opnd->GetPrimType())];
+    } else {
+      Opcode opndOpcode = opnd->GetOpCode();
+      if (be.GetMIRModule().GetFlavor() != kFlavorLmbc) {
+        ASSERT(opndOpcode == OP_dread || opndOpcode == OP_iread, "opndOpcode should be OP_dread or OP_iread");
+      }
+      if (opndOpcode == OP_dread) {
+        DreadNode *dread = static_cast<DreadNode*>(opnd);
+        MIRSymbol *sym = be.GetMIRModule().CurFunction()->GetLocalOrGlobalSymbol(dread->GetStIdx());
+        ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx());
+        if (dread->GetFieldID() != 0) {
+          ASSERT(ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeClass ||
+                 ty->GetKind() == kTypeUnion, "expect struct or class");
+          if (ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeUnion) {
+            ty = static_cast<MIRStructType*>(ty)->GetFieldType(dread->GetFieldID());
+          } else {
+            ty = static_cast<MIRClassType*>(ty)->GetFieldType(dread->GetFieldID());
+          }
+        }
+      } else if (opndOpcode == OP_iread) {
+        IreadNode *iread = static_cast<IreadNode*>(opnd);
+        ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx());
+        ASSERT(ty->GetKind() == kTypePointer, "expect pointer");
+        ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<MIRPtrType*>(ty)->GetPointedTyIdx());
+        if (iread->GetFieldID() != 0) {
+          ASSERT(ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeClass ||
+                 ty->GetKind() == kTypeUnion, "expect struct or class");
+          if (ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeUnion) {
+            ty = static_cast<MIRStructType*>(ty)->GetFieldType(iread->GetFieldID());
+          } else {
+            ty = static_cast<MIRClassType*>(ty)->GetFieldType(iread->GetFieldID());
+          }
+        }
+      } else if ((opndOpcode == OP_ireadfpoff || opndOpcode == OP_ireadoff ||
+                  opndOpcode == OP_dreadoff) && opnd->GetPrimType() == PTY_agg) {
+        ty = static_cast<AArch64CGFunc*>(cgFunc)->GetLmbcStructArgType(stmt, i);
+      }
+      if (ty == nullptr) {   /* type mismatch */
+        continue;
+      }
+    }
+    CCLocInfo ploc;
+    aggCopySize += parmLocator.LocateNextParm(*ty, ploc);
+    if (ploc.reg0 != 0) {
+      continue;  /* passed in register, so no effect on actual area */
+    }
+    sizeOfArgsToStkPass = RoundUp(ploc.memOffset + ploc.memSize, GetPointerSize());
+  }
+  return sizeOfArgsToStkPass;
+}
+
+void AArch64MemLayout::SetSizeAlignForTypeIdx(uint32 typeIdx, uint32 &size, uint32 &align) const {
+  if (be.GetTypeSize(typeIdx) > k16ByteSize) {
+    /* size > 16 is passed on stack, the formal is just a pointer to the copy on stack. */
+    if (CGOptions::IsArm64ilp32()) {
+      align = k8ByteSize;
+      size = k8ByteSize;
+    } else {
+      align = GetPointerSize();
+      size = GetPointerSize();
+    }
+  } else {
+    align = be.GetTypeAlign(typeIdx);
+    size = static_cast<uint32>(be.GetTypeSize(typeIdx));
+  }
+}
+
+void AArch64MemLayout::SetSegmentSize(AArch64SymbolAlloc &symbolAlloc, MemSegment &segment, uint32 typeIdx) const {
+  uint32 size;
+  uint32 align;
+  SetSizeAlignForTypeIdx(typeIdx, size, align);
+  segment.SetSize(static_cast<uint32>(RoundUp(static_cast<uint64>(segment.GetSize()), align)));
+  symbolAlloc.SetOffset(segment.GetSize());
+  segment.SetSize(segment.GetSize() + size);
+  segment.SetSize(static_cast<uint32>(RoundUp(static_cast<uint64>(segment.GetSize()), GetPointerSize())));
+}
+
+void AArch64MemLayout::LayoutVarargParams() {
+  uint32 nIntRegs = 0;
+  uint32 nFpRegs = 0;
+  AArch64CallConvImpl parmlocator(be);
+  CCLocInfo ploc;
+  MIRFunction *func = mirFunction;
+  if (be.GetMIRModule().IsCModule() && func->GetAttr(FUNCATTR_varargs)) {
+    for (uint32 i = 0; i < func->GetFormalCount(); i++) {
+      if (i == 0) {
+        if (func->IsFirstArgReturn() && func->GetReturnType()->GetPrimType() != PTY_void) {
+          TyIdx tyIdx = func->GetFuncRetStructTyIdx();
+          if (be.GetTypeSize(tyIdx.GetIdx()) <= k16ByteSize) {
+            continue;
+          }
+        }
+      }
+      MIRType *ty = func->GetNthParamType(i);
+      parmlocator.LocateNextParm(*ty, ploc, i == 0, func);
+      if (ploc.reg0 != kRinvalid) {
+        if (ploc.reg0 >= R0 && ploc.reg0 <= R7) {
+          nIntRegs++;
+        } else if (ploc.reg0 >= V0 && ploc.reg0 <= V7) {
+          nFpRegs++;
+        }
+      }
+      if (ploc.reg1 != kRinvalid) {
+        if (ploc.reg1 >= R0 && ploc.reg1 <= R7) {
+          nIntRegs++;
+        } else if (ploc.reg1 >= V0 && ploc.reg1 <= V7) {
+          nFpRegs++;
+        }
+      }
+      if (ploc.reg2 != kRinvalid) {
+        if (ploc.reg2 >= R0 && ploc.reg2 <= R7) {
+          nIntRegs++;
+        } else if (ploc.reg2 >= V0 && ploc.reg2 <= V7) {
+          nFpRegs++;
+        }
+      }
+      if (ploc.reg3 != kRinvalid) {
+        if (ploc.reg3 >= R0 && ploc.reg3 <= R7) {
+          nIntRegs++;
+        } else if (ploc.reg2 >= V0 && ploc.reg2 <= V7) {
+          nFpRegs++;
+        }
+      }
+    }
+    if (CGOptions::IsArm64ilp32()) {
+      SetSizeOfGRSaveArea((k8BitSize - nIntRegs) * k8ByteSize);
+    } else {
+      SetSizeOfGRSaveArea((k8BitSize - nIntRegs) * GetPointerSize());
+    }
+    if (CGOptions::UseGeneralRegOnly()) {
+      SetSizeOfVRSaveArea(0);
+    } else {
+      if (CGOptions::IsArm64ilp32()) {
+        SetSizeOfVRSaveArea((k8BitSize - nFpRegs) * k8ByteSize * k2ByteSize);
+      } else {
+        SetSizeOfVRSaveArea((k8BitSize - nFpRegs) * GetPointerSize() * k2ByteSize);
+      }
+    }
+  }
+}
+
+void AArch64MemLayout::LayoutFormalParams() {
+  AArch64CallConvImpl parmLocator(be);
+  CCLocInfo ploc;
+  for (size_t i = 0; i < mirFunction->GetFormalCount(); ++i) {
+    MIRSymbol *sym = mirFunction->GetFormal(i);
+    uint32 stIndex = sym->GetStIndex();
+    AArch64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<AArch64SymbolAlloc>();
+    SetSymAllocInfo(stIndex, *symLoc);
+    if (i == 0) {
+      if (mirFunction->IsReturnStruct() && mirFunction->IsFirstArgReturn()) {
+        symLoc->SetMemSegment(GetSegArgsRegPassed());
+        symLoc->SetOffset(GetSegArgsRegPassed().GetSize());
+        TyIdx tyIdx = mirFunction->GetFuncRetStructTyIdx();
+        if (be.GetTypeSize(tyIdx.GetIdx()) > k16ByteSize) {
+          if (CGOptions::IsArm64ilp32()) {
+            segArgsRegPassed.SetSize(segArgsRegPassed.GetSize() + k8ByteSize);
+          } else {
+            segArgsRegPassed.SetSize(segArgsRegPassed.GetSize() + GetPointerSize());
+          }
+        }
+        continue;
+      }
+    }
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirFunction->GetFormalDefVec()[i].formalTyIdx);
+    uint32 ptyIdx = ty->GetTypeIndex();
+    parmLocator.LocateNextParm(*ty, ploc, i == 0, mirFunction);
+    if (ploc.reg0 != kRinvalid) {  /* register */
+      symLoc->SetRegisters(static_cast<AArch64reg>(ploc.reg0), static_cast<AArch64reg>(ploc.reg1),
+                           static_cast<AArch64reg>(ploc.reg2), static_cast<AArch64reg>(ploc.reg3));
+      if (!cgFunc->GetMirModule().IsCModule() && mirFunction->GetNthParamAttr(i).GetAttr(ATTR_localrefvar)) {
+        symLoc->SetMemSegment(segRefLocals);
+        SetSegmentSize(*symLoc, segRefLocals, ptyIdx);
+      } else if (!sym->IsPreg()) {
+        uint32 size;
+        uint32 align;
+        SetSizeAlignForTypeIdx(ptyIdx, size, align);
+        symLoc->SetMemSegment(GetSegArgsRegPassed());
+        /* the type's alignment requirement may be smaller than a registser's byte size */
+        if (ty->GetPrimType() == PTY_agg) {
+          /* struct param aligned on 8 byte boundary unless it is small enough */
+          if (CGOptions::IsArm64ilp32()) {
+            align = k8ByteSize;
+          } else {
+            align = GetPointerSize();
+          }
+        }
+        uint32 tSize = 0;
+        if ((IsPrimitiveVector(ty->GetPrimType()) && GetPrimTypeSize(ty->GetPrimType()) > k8ByteSize) ||
+            AArch64Abi::IsVectorArrayType(ty, tSize) != PTY_void) {
+          align = k16ByteSize;
+        }
+        segArgsRegPassed.SetSize(static_cast<uint32>(RoundUp(segArgsRegPassed.GetSize(), align)));
+        symLoc->SetOffset(segArgsRegPassed.GetSize());
+        segArgsRegPassed.SetSize(segArgsRegPassed.GetSize() + size);
+      }
+    } else {  /* stack */
+      uint32 size;
+      uint32 align;
+      SetSizeAlignForTypeIdx(ptyIdx, size, align);
+      symLoc->SetMemSegment(GetSegArgsStkPassed());
+      segArgsStkPassed.SetSize(static_cast<uint32>(RoundUp(segArgsStkPassed.GetSize(), align)));
+      symLoc->SetOffset(segArgsStkPassed.GetSize());
+      segArgsStkPassed.SetSize(segArgsStkPassed.GetSize() + size);
+      /* We need it as dictated by the AArch64 ABI $5.4.2 C12 */
+      if (CGOptions::IsArm64ilp32()) {
+        segArgsStkPassed.SetSize(static_cast<uint32>(RoundUp(segArgsStkPassed.GetSize(), k8ByteSize)));
+      } else {
+        segArgsStkPassed.SetSize(static_cast<uint32>(RoundUp(segArgsStkPassed.GetSize(), GetPointerSize())));
+      }
+      if (!cgFunc->GetMirModule().IsCModule() && mirFunction->GetNthParamAttr(i).GetAttr(ATTR_localrefvar)) {
+        SetLocalRegLocInfo(sym->GetStIdx(), *symLoc);
+        AArch64SymbolAlloc *symLoc1 = memAllocator->GetMemPool()->New<AArch64SymbolAlloc>();
+        symLoc1->SetMemSegment(segRefLocals);
+        SetSegmentSize(*symLoc1, segRefLocals, ptyIdx);
+        SetSymAllocInfo(stIndex, *symLoc1);
+      }
+    }
+    if (cgFunc->GetCG()->GetCGOptions().WithDwarf() && (symLoc->GetMemSegment() != nullptr)) {
+      cgFunc->AddDIESymbolLocation(sym, symLoc, true);
+    }
+  }
+}
+
+void AArch64MemLayout::LayoutLocalVariables(std::vector<MIRSymbol*> &tempVar, std::vector<MIRSymbol*> &returnDelays) {
+  if (be.GetMIRModule().GetFlavor() == kFlavorLmbc) {
+    segLocals.SetSize(mirFunction->GetFrameSize() - mirFunction->GetOutParmSize());
+    return;
+  }
+
+  uint32 symTabSize = mirFunction->GetSymTab()->GetSymbolTableSize();
+  for (uint32 i = 0; i < symTabSize; ++i) {
+    MIRSymbol *sym = mirFunction->GetSymTab()->GetSymbolFromStIdx(i);
+    if (sym == nullptr || sym->GetStorageClass() != kScAuto || sym->IsDeleted()) {
+      continue;
+    }
+    uint32 stIndex = sym->GetStIndex();
+    TyIdx tyIdx = sym->GetTyIdx();
+    AArch64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<AArch64SymbolAlloc>();
+    SetSymAllocInfo(stIndex, *symLoc);
+    CHECK_FATAL(!symLoc->IsRegister(), "expect not register");
+
+    if (sym->IsRefType()) {
+      if (mirFunction->GetRetRefSym().find(sym) != mirFunction->GetRetRefSym().end()) {
+        /* try to put ret_ref at the end of segRefLocals */
+        returnDelays.emplace_back(sym);
+        continue;
+      }
+      symLoc->SetMemSegment(segRefLocals);
+      segRefLocals.SetSize(RoundUp(segRefLocals.GetSize(), be.GetTypeAlign(tyIdx)));
+      symLoc->SetOffset(segRefLocals.GetSize());
+      segRefLocals.SetSize(segRefLocals.GetSize() + be.GetTypeSize(tyIdx));
+    } else {
+      if (sym->GetName() == "__EARetTemp__" ||
+          sym->GetName().substr(0, kEARetTempNameSize) == "__EATemp__") {
+        tempVar.emplace_back(sym);
+        continue;
+      }
+      symLoc->SetMemSegment(segLocals);
+      MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+      uint32 align = be.GetTypeAlign(tyIdx);
+      uint32 tSize = 0;
+      if ((IsPrimitiveVector(ty->GetPrimType()) && GetPrimTypeSize(ty->GetPrimType()) > k8ByteSize) ||
+          AArch64Abi::IsVectorArrayType(ty, tSize) != PTY_void) {
+        align = k16ByteSize;
+      }
+      if (ty->GetPrimType() == PTY_agg && align < k8BitSize) {
+        segLocals.SetSize(static_cast<uint32>(RoundUp(segLocals.GetSize(), k8BitSize)));
+      } else {
+        segLocals.SetSize(static_cast<uint32>(RoundUp(segLocals.GetSize(), align)));
+      }
+      symLoc->SetOffset(segLocals.GetSize());
+      segLocals.SetSize(segLocals.GetSize() + be.GetTypeSize(tyIdx));
+    }
+    if (cgFunc->GetCG()->GetCGOptions().WithDwarf()) {
+      cgFunc->AddDIESymbolLocation(sym, symLoc, false);
+    }
+  }
+}
+
+void AArch64MemLayout::LayoutEAVariales(std::vector<MIRSymbol*> &tempVar) {
+  for (auto sym : tempVar) {
+    uint32 stIndex = sym->GetStIndex();
+    TyIdx tyIdx = sym->GetTyIdx();
+    AArch64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<AArch64SymbolAlloc>();
+    SetSymAllocInfo(stIndex, *symLoc);
+    ASSERT(!symLoc->IsRegister(), "expect not register");
+    symLoc->SetMemSegment(segRefLocals);
+    segRefLocals.SetSize(RoundUp(segRefLocals.GetSize(), be.GetTypeAlign(tyIdx)));
+    symLoc->SetOffset(segRefLocals.GetSize());
+    segRefLocals.SetSize(segRefLocals.GetSize() + be.GetTypeSize(tyIdx));
+  }
+}
+
+void AArch64MemLayout::LayoutReturnRef(std::vector<MIRSymbol*> &returnDelays,
+                                       int32 &structCopySize, int32 &maxParmStackSize) {
+  for (auto sym : returnDelays) {
+    uint32 stIndex = sym->GetStIndex();
+    TyIdx tyIdx = sym->GetTyIdx();
+    AArch64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<AArch64SymbolAlloc>();
+    SetSymAllocInfo(stIndex, *symLoc);
+    ASSERT(!symLoc->IsRegister(), "expect not register");
+
+    ASSERT(sym->IsRefType(), "expect reftype ");
+    symLoc->SetMemSegment(segRefLocals);
+    segRefLocals.SetSize(RoundUp(segRefLocals.GetSize(), be.GetTypeAlign(tyIdx)));
+    symLoc->SetOffset(segRefLocals.GetSize());
+    segRefLocals.SetSize(segRefLocals.GetSize() + be.GetTypeSize(tyIdx));
+  }
+  segArgsToStkPass.SetSize(FindLargestActualArea(structCopySize));
+  maxParmStackSize = static_cast<int32>(segArgsToStkPass.GetSize());
+  if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+    AssignSpillLocationsToPseudoRegisters();
+  } else {
+    AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+    /* 8-VirtualRegNode occupy byte number */
+    aarchCGFunc->SetCatchRegno(cgFunc->NewVReg(kRegTyInt, 8));
+  }
+  segRefLocals.SetSize(static_cast<uint32>(RoundUp(segRefLocals.GetSize(), GetPointerSize())));
+  if (CGOptions::IsArm64ilp32()) {
+    segLocals.SetSize(static_cast<uint32>(RoundUp(segLocals.GetSize(), k8ByteSize)));
+  } else {
+    segLocals.SetSize(static_cast<uint32>(RoundUp(segLocals.GetSize(), GetPointerSize())));
+  }
+}
+
+void AArch64MemLayout::LayoutActualParams() {
+  for (size_t i = 0; i < mirFunction->GetFormalCount(); ++i) {
+    if (i == 0) {
+      if (mirFunction->IsReturnStruct() && mirFunction->IsFirstArgReturn()) {
+        continue;
+      }
+    }
+    MIRSymbol *sym = mirFunction->GetFormal(i);
+    if (sym->IsPreg()) {
+      continue;
+    }
+    uint32 stIndex = sym->GetStIndex();
+    AArch64SymbolAlloc *symLoc = static_cast<AArch64SymbolAlloc*>(GetSymAllocInfo(stIndex));
+    if (symLoc->GetMemSegment() == &GetSegArgsRegPassed()) {  /* register */
+      /*
+       *  In O0, we store parameters passed via registers into memory.
+       *  So, each of such parameter needs to get assigned storage in stack.
+       *  If a function parameter is never accessed in the function body,
+       *  and if we don't create its memory operand here, its offset gets
+       *  computed when the instruction to store its value into stack
+       *  is generated in the prologue when its memory operand is created.
+       *  But, the parameter would see a different StackFrameSize than
+       *  the parameters that are accessed in the body, because
+       *  the size of the storage for FP/LR is added to the stack frame
+       *  size in between.
+       *  To make offset assignment easier, we create a memory operand
+       *  for each of function parameters in advance.
+       *  This has to be done after all of formal parameters and local
+       *  variables get assigned their respecitve storage, i.e.
+       *  CallFrameSize (discounting callee-saved and FP/LR) is known.
+       */
+      MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirFunction->GetFormalDefVec()[i].formalTyIdx);
+      uint32 ptyIdx = ty->GetTypeIndex();
+      static_cast<AArch64CGFunc*>(cgFunc)->GetOrCreateMemOpnd(*sym, 0, be.GetTypeAlign(ptyIdx) * kBitsPerByte);
+    }
+  }
+}
+
+void AArch64MemLayout::LayoutStackFrame(int32 &structCopySize, int32 &maxParmStackSize) {
+  LayoutVarargParams();
+  LayoutFormalParams();
+  /*
+   * We do need this as LDR/STR with immediate
+   * requires imm be aligned at a 8/4-byte boundary,
+   * and local varirables may need 8-byte alignment.
+   */
+  if (CGOptions::IsArm64ilp32()) {
+    segArgsRegPassed.SetSize(RoundUp(segArgsRegPassed.GetSize(), k8ByteSize));
+    /* we do need this as SP has to be aligned at a 16-bytes bounardy */
+    segArgsStkPassed.SetSize(RoundUp(segArgsStkPassed.GetSize(), k8ByteSize + k8ByteSize));
+  } else {
+    segArgsRegPassed.SetSize(RoundUp(segArgsRegPassed.GetSize(), GetPointerSize()));
+    segArgsStkPassed.SetSize(RoundUp(segArgsStkPassed.GetSize(), GetPointerSize() + GetPointerSize()));
+  }
+  /* allocate the local variables in the stack */
+  std::vector<MIRSymbol*> eaTempVar;
+  std::vector<MIRSymbol*> retDelays;
+  LayoutLocalVariables(eaTempVar, retDelays);
+  LayoutEAVariales(eaTempVar);
+
+  /* handle ret_ref sym now */
+  LayoutReturnRef(retDelays, structCopySize, maxParmStackSize);
+
+  /*
+   * for the actual arguments that cannot be pass through registers
+   * need to allocate space for caller-save registers
+   */
+  LayoutActualParams();
+
+  fixStackSize = static_cast<int32>(RealStackFrameSize());
+  cgFunc->SetUseFP(cgFunc->UseFP() || fixStackSize > kMaxPimm32);
+}
+
+void AArch64MemLayout::AssignSpillLocationsToPseudoRegisters() {
+  MIRPregTable *pregTab = cgFunc->GetFunction().GetPregTab();
+
+  /* BUG: n_regs include index 0 which is not a valid preg index. */
+  size_t nRegs = pregTab->Size();
+  spillLocTable.resize(nRegs);
+  for (size_t i = 1; i < nRegs; ++i) {
+    PrimType pType = pregTab->PregFromPregIdx(i)->GetPrimType();
+    AArch64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<AArch64SymbolAlloc>();
+    symLoc->SetMemSegment(segLocals);
+    segLocals.SetSize(RoundUp(segLocals.GetSize(), GetPrimTypeSize(pType)));
+    symLoc->SetOffset(segLocals.GetSize());
+    MIRType *mirTy = GlobalTables::GetTypeTable().GetTypeTable()[pType];
+    segLocals.SetSize(segLocals.GetSize() + be.GetTypeSize(mirTy->GetTypeIndex()));
+    spillLocTable[i] = symLoc;
+  }
+
+  if (!cgFunc->GetMirModule().IsJavaModule()) {
+    return;
+  }
+
+  /*
+   * Allocate additional stack space for "thrownval".
+   * segLocals need 8 bit align
+   */
+  if (CGOptions::IsArm64ilp32()) {
+    segLocals.SetSize(RoundUp(segLocals.GetSize(), k8ByteSize));
+  } else {
+    segLocals.SetSize(RoundUp(segLocals.GetSize(), GetPointerSize()));
+  }
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  RegOperand &baseOpnd = aarchCGFunc->GetOrCreateStackBaseRegOperand();
+  uint32 offset = segLocals.GetSize();
+
+  OfstOperand *offsetOpnd =
+      &aarchCGFunc->CreateOfstOpnd(offset + k16BitSize, k64BitSize);
+  MemOperand *throwMem = aarchCGFunc->CreateMemOperand(
+      MemOperand::kAddrModeBOi, k64BitSize, baseOpnd, static_cast<RegOperand*>(nullptr), offsetOpnd,
+      nullptr);
+  aarchCGFunc->SetCatchOpnd(*throwMem);
+  if (CGOptions::IsArm64ilp32()) {
+    segLocals.SetSize(segLocals.GetSize() + k8ByteSize);
+  } else {
+    segLocals.SetSize(segLocals.GetSize() + GetPointerSize());
+  }
+}
+
+SymbolAlloc *AArch64MemLayout::AssignLocationToSpillReg(regno_t vrNum) {
+  AArch64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<AArch64SymbolAlloc>();
+  symLoc->SetMemSegment(segSpillReg);
+  uint32 regSize = cgFunc->IsExtendReg(vrNum) ? k8ByteSize : cgFunc->GetVRegSize(vrNum);
+  segSpillReg.SetSize(RoundUp(segSpillReg.GetSize(), regSize));
+  symLoc->SetOffset(segSpillReg.GetSize());
+  segSpillReg.SetSize(segSpillReg.GetSize() + regSize);
+  SetSpillRegLocInfo(vrNum, *symLoc);
+  return symLoc;
+}
+
+uint64 AArch64MemLayout::StackFrameSize() const {
+  uint64 total = segArgsRegPassed.GetSize() + static_cast<AArch64CGFunc*>(cgFunc)->SizeOfCalleeSaved() +
+      GetSizeOfRefLocals() + Locals().GetSize() + GetSizeOfSpillReg();
+
+  if (cgFunc->GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+    if (GetSizeOfGRSaveArea() > 0) {
+      total += RoundUp(GetSizeOfGRSaveArea(), kAarch64StackPtrAlignment);
+    }
+    if (GetSizeOfVRSaveArea() > 0) {
+      total += RoundUp(GetSizeOfVRSaveArea(), kAarch64StackPtrAlignment);
+    }
+  }
+
+  /*
+   * if the function does not have VLA nor alloca,
+   * we allocate space for arguments to stack-pass
+   * in the call frame; otherwise, it has to be allocated for each call and reclaimed afterward.
+   */
+  total += segArgsToStkPass.GetSize();
+  return RoundUp(total, kAarch64StackPtrAlignment);
+}
+
+uint32 AArch64MemLayout::RealStackFrameSize() const {
+  auto size = StackFrameSize();
+  if (cgFunc->GetCG()->IsStackProtectorStrong() || cgFunc->GetCG()->IsStackProtectorAll()) {
+    size += static_cast<uint32>(kAarch64StackPtrAlignment);
+  }
+  return static_cast<uint32>(size);
+}
+
+int32 AArch64MemLayout::GetRefLocBaseLoc() const {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  auto beforeSize = GetSizeOfLocals();
+  if (aarchCGFunc->UsedStpSubPairForCallFrameAllocation()) {
+    return static_cast<int32>(beforeSize);
+  }
+  return static_cast<int32>(beforeSize + kSizeOfFplr);
+}
+
+int32 AArch64MemLayout::GetGRSaveAreaBaseLoc() const {
+  int32 total = static_cast<int32>(RealStackFrameSize() -
+                RoundUp(GetSizeOfGRSaveArea(), kAarch64StackPtrAlignment));
+  total -= static_cast<int32>(SizeOfArgsToStackPass());
+  return total;
+}
+
+int32 AArch64MemLayout::GetVRSaveAreaBaseLoc() const {
+  int32 total = static_cast<int32>((RealStackFrameSize() -
+                RoundUp(GetSizeOfGRSaveArea(), kAarch64StackPtrAlignment)) -
+                RoundUp(GetSizeOfVRSaveArea(), kAarch64StackPtrAlignment));
+  total -= static_cast<int32>(SizeOfArgsToStackPass());
+  return total;
+}
+
+int32 AArch64MemLayout::GetCalleeSaveBaseLoc() const {
+  auto offset = StackFrameSize() - static_cast<AArch64CGFunc*>(cgFunc)->SizeOfCalleeSaved();
+  if (cgFunc->GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+    offset -= GetSizeOfLocals();
+  } else {
+    offset = (offset - SizeOfArgsToStackPass()) + kSizeOfFplr;
+  }
+
+  if (cgFunc->GetMirModule().IsCModule() && cgFunc->GetFunction().GetAttr(FUNCATTR_varargs)) {
+    /* GR/VR save areas are above the callee save area */
+    auto saveareasize = RoundUp(GetSizeOfGRSaveArea(), GetPointerSize() * k2BitSize) +
+                        RoundUp(GetSizeOfVRSaveArea(), GetPointerSize() * k2BitSize);
+    offset -= saveareasize;
+  }
+
+  return static_cast<int32>(offset);
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_offset_adjust.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_offset_adjust.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..01be7f0a07a03e9caf1264c2800531ffc0ad2ad0
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_offset_adjust.cpp
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_offset_adjust.h"
+#include "aarch64_cgfunc.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+void AArch64FPLROffsetAdjustment::Run() {
+  AdjustmentOffsetForFPLR();
+}
+
+void AArch64FPLROffsetAdjustment::AdjustmentOffsetForOpnd(Insn &insn, AArch64CGFunc &aarchCGFunc) const {
+  bool isLmbc = (aarchCGFunc.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc);
+  uint32 opndNum = insn.GetOperandSize();
+  MemLayout *memLayout = aarchCGFunc.GetMemlayout();
+  bool stackBaseOpnd = false;
+  AArch64reg stackBaseReg = isLmbc ? R29 : (aarchCGFunc.UseFP() ? R29 : RSP);
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsRegister()) {
+      auto &regOpnd = static_cast<RegOperand&>(opnd);
+      if (regOpnd.IsOfVary()) {
+        insn.SetOperand(i, aarchCGFunc.GetOrCreateStackBaseRegOperand());
+      }
+      if (regOpnd.GetRegisterNumber() == RFP) {
+        insn.SetOperand(i, aarchCGFunc.GetOrCreatePhysicalRegisterOperand(stackBaseReg, k64BitSize, kRegTyInt));
+        stackBaseOpnd = true;
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      if (((memOpnd.GetAddrMode() == MemOperand::kAddrModeBOi) ||
+           (memOpnd.GetAddrMode() == MemOperand::kAddrModeBOrX)) &&
+          memOpnd.GetBaseRegister() != nullptr) {
+        if (memOpnd.GetBaseRegister()->IsOfVary()) {
+          memOpnd.SetBaseRegister(static_cast<RegOperand&>(aarchCGFunc.GetOrCreateStackBaseRegOperand()));
+        }
+        RegOperand *memBaseReg = memOpnd.GetBaseRegister();
+        if (memBaseReg->GetRegisterNumber() == RFP) {
+          RegOperand &newBaseOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(stackBaseReg, k64BitSize, kRegTyInt);
+          MemOperand &newMemOpnd = aarchCGFunc.GetOrCreateMemOpnd(
+              memOpnd.GetAddrMode(), memOpnd.GetSize(), &newBaseOpnd, memOpnd.GetIndexRegister(),
+              memOpnd.GetOffsetImmediate(), memOpnd.GetSymbol());
+          insn.SetOperand(i, newMemOpnd);
+          stackBaseOpnd = true;
+        }
+      }
+      if ((memOpnd.GetAddrMode() != MemOperand::kAddrModeBOi) || !memOpnd.IsIntactIndexed()) {
+        continue;
+      }
+      OfstOperand *ofstOpnd = memOpnd.GetOffsetImmediate();
+      if (ofstOpnd == nullptr) {
+        continue;
+      }
+      if (ofstOpnd->GetVary() == kUnAdjustVary) {
+        ofstOpnd->AdjustOffset(static_cast<int32>(static_cast<AArch64MemLayout*>(memLayout)->RealStackFrameSize() -
+            (isLmbc ? 0 : memLayout->SizeOfArgsToStackPass())));
+        ofstOpnd->SetVary(kAdjustVary);
+      }
+      if (ofstOpnd->GetVary() == kAdjustVary || ofstOpnd->GetVary() == kNotVary) {
+        bool condition = aarchCGFunc.IsOperandImmValid(insn.GetMachineOpcode(), &memOpnd, i);
+        if (!condition) {
+          MemOperand &newMemOpnd = aarchCGFunc.SplitOffsetWithAddInstruction(
+              memOpnd, memOpnd.GetSize(), static_cast<AArch64reg>(R16), false, &insn, insn.IsLoadStorePair());
+          insn.SetOperand(i, newMemOpnd);
+        }
+      }
+    } else if (opnd.IsIntImmediate()) {
+      AdjustmentOffsetForImmOpnd(insn, i, aarchCGFunc);
+    }
+  }
+  if (stackBaseOpnd && !aarchCGFunc.UseFP()) {
+    AdjustmentStackPointer(insn, aarchCGFunc);
+  }
+}
+
+void AArch64FPLROffsetAdjustment::AdjustmentOffsetForImmOpnd(Insn &insn, uint32 index,
+                                                             AArch64CGFunc &aarchCGFunc) const {
+  auto &immOpnd = static_cast<ImmOperand&>(insn.GetOperand(index));
+  MemLayout *memLayout = aarchCGFunc.GetMemlayout();
+  if (immOpnd.GetVary() == kUnAdjustVary) {
+    int64 ofst = static_cast<AArch64MemLayout*>(memLayout)->RealStackFrameSize() - memLayout->SizeOfArgsToStackPass();
+    if (insn.GetMachineOpcode() == MOP_xsubrri12 || insn.GetMachineOpcode() == MOP_wsubrri12) {
+      immOpnd.SetValue(immOpnd.GetValue() - ofst);
+      if (immOpnd.GetValue() < 0) {
+        immOpnd.Negate();
+      }
+      insn.SetMOP(AArch64CG::kMd[A64ConstProp::GetReversalMOP(insn.GetMachineOpcode())]);
+    } else {
+      immOpnd.Add(ofst);
+    }
+  }
+  if (!aarchCGFunc.IsOperandImmValid(insn.GetMachineOpcode(), &immOpnd, index)) {
+    if (insn.GetMachineOpcode() >= MOP_xaddrri24 && insn.GetMachineOpcode() <= MOP_waddrri12) {
+      PrimType destTy =
+          static_cast<RegOperand &>(insn.GetOperand(kInsnFirstOpnd)).GetSize() == k64BitSize ? PTY_i64 : PTY_i32;
+      RegOperand *resOpnd = &static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      ImmOperand &copyImmOpnd = aarchCGFunc.CreateImmOperand(
+          immOpnd.GetValue(), immOpnd.GetSize(), immOpnd.IsSignedValue());
+      aarchCGFunc.SelectAddAfterInsn(*resOpnd, insn.GetOperand(kInsnSecondOpnd), copyImmOpnd, destTy, false, insn);
+      insn.GetBB()->RemoveInsn(insn);
+    } else if (insn.GetMachineOpcode() == MOP_xsubrri12 || insn.GetMachineOpcode() == MOP_wsubrri12) {
+      if (immOpnd.IsSingleInstructionMovable()) {
+        RegOperand &tempReg = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(R16, k64BitSize, kRegTyInt);
+        bool is64bit = insn.GetOperand(kInsnFirstOpnd).GetSize() == k64BitSize;
+        MOperator tempMovOp = is64bit ? MOP_xmovri64 : MOP_wmovri32;
+        Insn &tempMov = cgFunc->GetInsnBuilder()->BuildInsn(tempMovOp, tempReg, immOpnd);
+        insn.SetOperand(index, tempReg);
+        insn.SetMOP(is64bit ? AArch64CG::kMd[MOP_xsubrrr] : AArch64CG::kMd[MOP_wsubrrr]);
+        (void)insn.GetBB()->InsertInsnBefore(insn, tempMov);
+      }
+    } else {
+      CHECK_FATAL(false, "NIY");
+    }
+  }
+  immOpnd.SetVary(kAdjustVary);
+}
+
+void AArch64FPLROffsetAdjustment::AdjustmentStackPointer(Insn &insn, AArch64CGFunc &aarchCGFunc) const {
+  AArch64MemLayout *aarch64memlayout = static_cast<AArch64MemLayout*>(aarchCGFunc.GetMemlayout());
+  int32 offset = static_cast<int32>(aarch64memlayout->SizeOfArgsToStackPass());
+  if (offset == 0) {
+    return;
+  }
+  if (insn.IsLoad() || insn.IsStore()) {
+    uint32 opndNum = insn.GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = insn.GetOperand(i);
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        ASSERT(memOpnd.GetBaseRegister() != nullptr, "Unexpect, need check");
+        CHECK_FATAL(memOpnd.IsIntactIndexed(), "unsupport yet");
+        if (memOpnd.GetAddrMode() == MemOperand::kAddrModeBOi) {
+          ImmOperand *ofstOpnd = memOpnd.GetOffsetOperand();
+          ImmOperand *newOfstOpnd = &aarchCGFunc.GetOrCreateOfstOpnd(
+              static_cast<uint64>(ofstOpnd->GetValue() + offset), ofstOpnd->GetSize());
+          MemOperand &newOfstMemOpnd = aarchCGFunc.GetOrCreateMemOpnd(
+              MemOperand::kAddrModeBOi, memOpnd.GetSize(), memOpnd.GetBaseRegister(), memOpnd.GetIndexRegister(),
+              newOfstOpnd, memOpnd.GetSymbol());
+          insn.SetOperand(i, newOfstMemOpnd);
+          if (!aarchCGFunc.IsOperandImmValid(insn.GetMachineOpcode(), &newOfstMemOpnd, i)) {
+            bool isPair = (i == kInsnThirdOpnd);
+            MemOperand &newMemOpnd = aarchCGFunc.SplitOffsetWithAddInstruction(
+                newOfstMemOpnd, newOfstMemOpnd.GetSize(), static_cast<AArch64reg>(R16), false, &insn, isPair);
+            insn.SetOperand(i, newMemOpnd);
+          }
+          continue;
+        } else if (memOpnd.GetAddrMode() == MemOperand::kAddrModeBOrX) {
+          CHECK_FATAL(false, "Unexpect adjust insn");
+        } else {
+          insn.Dump();
+          CHECK_FATAL(false, "Unexpect adjust insn");
+        }
+      }
+    }
+  } else {
+    switch (insn.GetMachineOpcode()) {
+      case MOP_xaddrri12: {
+        ASSERT(static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetRegisterNumber() == RSP,
+            "regNumber should be changed in AdjustmentOffsetForOpnd");
+        auto *newAddImmOpnd = static_cast<ImmOperand*>(
+            static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd)).Clone(*cgFunc->GetMemoryPool()));
+        newAddImmOpnd->SetValue(newAddImmOpnd->GetValue() + offset);
+        insn.SetOperand(kInsnThirdOpnd, *newAddImmOpnd);
+        AdjustmentOffsetForImmOpnd(insn, kInsnThirdOpnd, aarchCGFunc); /* legalize imm opnd */
+        break;
+      }
+      case MOP_xaddrri24: {
+        ASSERT(static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetRegisterNumber() == RSP,
+            "regNumber should be changed in AdjustmentOffsetForOpnd");
+        RegOperand &tempReg = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(R16, k64BitSize, kRegTyInt);
+        ImmOperand &offsetReg = aarchCGFunc.CreateImmOperand(offset, k64BitSize, false);
+        aarchCGFunc.SelectAddAfterInsn(tempReg, insn.GetOperand(kInsnSecondOpnd), offsetReg, PTY_i64, false, insn);
+        insn.SetOperand(kInsnSecondOpnd, tempReg);
+        break;
+      }
+      case MOP_xsubrri12: {
+        ASSERT(static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetRegisterNumber() == RSP,
+            "regNumber should be changed in AdjustmentOffsetForOpnd");
+        ImmOperand &subend = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+        subend.SetValue(subend.GetValue() - offset);
+        break;
+      }
+      case MOP_xsubrri24: {
+        ASSERT(static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetRegisterNumber() == RSP,
+            "regNumber should be changed in AdjustmentOffsetForOpnd");
+        RegOperand &tempReg = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(R16, k64BitSize, kRegTyInt);
+        ImmOperand &offsetReg = aarchCGFunc.CreateImmOperand(offset, k64BitSize, false);
+        aarchCGFunc.SelectAddAfterInsn(tempReg, insn.GetOperand(kInsnSecondOpnd), offsetReg, PTY_i64, false, insn);
+        insn.SetOperand(kInsnSecondOpnd, tempReg);
+        break;
+      }
+      case MOP_waddrri12: {
+        if (!CGOptions::IsArm64ilp32()) {
+          insn.Dump();
+          CHECK_FATAL(false, "Unexpect offset adjustment insn");
+        } else {
+          ASSERT(static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetRegisterNumber() == RSP,
+              "regNumber should be changed in AdjustmentOffsetForOpnd");
+          ImmOperand &addend = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+          addend.SetValue(addend.GetValue() + offset);
+          AdjustmentOffsetForImmOpnd(insn, kInsnThirdOpnd, aarchCGFunc); /* legalize imm opnd */
+        }
+        break;
+      }
+      default:
+        insn.Dump();
+        CHECK_FATAL(false, "Unexpect offset adjustment insn");
+    }
+  }
+}
+
+void AArch64FPLROffsetAdjustment::AdjustmentOffsetForFPLR() {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  FOR_ALL_BB(bb, aarchCGFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      AdjustmentOffsetForOpnd(*insn, *aarchCGFunc);
+    }
+  }
+
+#undef STKLAY_DBUG
+#ifdef STKLAY_DBUG
+  AArch64MemLayout *aarch64memlayout = static_cast<AArch64MemLayout*>(cgFunc->GetMemlayout());
+  LogInfo::MapleLogger() << "stkpass: " << aarch64memlayout->GetSegArgsStkpass().size << "\n";
+  LogInfo::MapleLogger() << "local: " << aarch64memlayout->GetSizeOfLocals() << "\n";
+  LogInfo::MapleLogger() << "ref local: " << aarch64memlayout->GetSizeOfRefLocals() << "\n";
+  LogInfo::MapleLogger() << "regpass: " << aarch64memlayout->GetSegArgsRegPassed().size << "\n";
+  LogInfo::MapleLogger() << "regspill: " << aarch64memlayout->GetSizeOfSpillReg() << "\n";
+  LogInfo::MapleLogger() << "calleesave: " << SizeOfCalleeSaved() << "\n";
+
+#endif
+}
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_operand.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_operand.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eda313759eba456fd254d15d179fa47f9d970236
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_operand.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_operand.h"
+#include <fstream>
+#include <string>
+#include "aarch64_abi.h"
+#include "aarch64_cgfunc.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+bool StImmOperand::Less(const Operand &right) const{
+  if (&right == this) {
+    return false;
+  }
+
+  /* For different type. */
+  if (GetKind() != right.GetKind()) {
+    return GetKind() < right.GetKind();
+  }
+
+  const StImmOperand *rightOpnd = static_cast<const StImmOperand*>(&right);
+  if (symbol != rightOpnd->symbol) {
+    return symbol < rightOpnd->symbol;
+  }
+  if (offset != rightOpnd->offset) {
+    return offset < rightOpnd->offset;
+  }
+  return relocs < rightOpnd->relocs;
+}
+
+bool ExtendShiftOperand::Less(const Operand &right) const {
+  if (&right == this) {
+    return false;
+  }
+  /* For different type. */
+  if (GetKind() != right.GetKind()) {
+    return GetKind() < right.GetKind();
+  }
+
+  const ExtendShiftOperand *rightOpnd = static_cast<const ExtendShiftOperand*>(&right);
+
+  /* The same type. */
+  if (extendOp != rightOpnd->extendOp) {
+    return extendOp < rightOpnd->extendOp;
+  }
+  return shiftAmount < rightOpnd->shiftAmount;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_optimize_common.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_optimize_common.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d962ed7b966d6181d4e2f98a9c085151d4c8b182
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_optimize_common.cpp
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_optimize_common.h"
+#include "aarch64_cg.h"
+#include "aarch64_cgfunc.h"
+#include "cgbb.h"
+
+namespace maplebe {
+void AArch64InsnVisitor::ModifyJumpTarget(Operand &targetOperand, BB &bb) {
+  if (bb.GetKind() == BB::kBBIgoto) {
+    bool modified = false;
+    for (Insn *insn = bb.GetLastInsn(); insn != nullptr; insn = insn->GetPrev()) {
+      if (insn->GetMachineOpcode() == MOP_adrp_label) {
+        LabelIdx labIdx = static_cast<LabelOperand&>(targetOperand).GetLabelIndex();
+        ImmOperand &immOpnd = static_cast<AArch64CGFunc *>(GetCGFunc())->CreateImmOperand(labIdx, k8BitSize, false);
+        insn->SetOperand(1, immOpnd);
+        modified = true;
+      }
+    }
+    CHECK_FATAL(modified, "ModifyJumpTarget: Could not change jump target");
+    return;
+  } else if (bb.GetKind() == BB::kBBGoto) {
+    for (Insn *insn = bb.GetLastInsn(); insn != nullptr; insn = insn->GetPrev()) {
+      if (insn->GetMachineOpcode() == MOP_adrp_label) {
+        maple::LabelIdx labidx = static_cast<LabelOperand&>(targetOperand).GetLabelIndex();
+        LabelOperand &label = static_cast<AArch64CGFunc *>(GetCGFunc())->GetOrCreateLabelOperand(labidx);
+        insn->SetOperand(1, label);
+        break;
+      }
+    }
+    // fallthru below to patch the branch insn
+  }
+  bb.GetLastInsn()->SetOperand(AArch64isa::GetJumpTargetIdx(*bb.GetLastInsn()), targetOperand);
+}
+
+void AArch64InsnVisitor::ModifyJumpTarget(maple::LabelIdx targetLabel, BB &bb) {
+  ModifyJumpTarget(static_cast<AArch64CGFunc*>(GetCGFunc())->GetOrCreateLabelOperand(targetLabel), bb);
+}
+
+void AArch64InsnVisitor::ModifyJumpTarget(BB &newTarget, BB &bb) {
+  ModifyJumpTarget(newTarget.GetLastInsn()->GetOperand(
+      AArch64isa::GetJumpTargetIdx(*newTarget.GetLastInsn())), bb);
+}
+
+Insn *AArch64InsnVisitor::CloneInsn(Insn &originalInsn) {
+  MemPool *memPool = const_cast<MemPool*>(CG::GetCurCGFunc()->GetMemoryPool());
+  if (originalInsn.IsTargetInsn()) {
+    if (!originalInsn.IsVectorOp()) {
+      return memPool->Clone<Insn>(originalInsn);
+    } else {
+      auto *insn = memPool->Clone<VectorInsn>(*static_cast<VectorInsn*>(&originalInsn));
+      insn->SetRegSpecList(static_cast<VectorInsn&>(originalInsn).GetRegSpecList());
+      return insn;
+    }
+  } else if (originalInsn.IsCfiInsn()) {
+    return memPool->Clone<cfi::CfiInsn>(*static_cast<cfi::CfiInsn*>(&originalInsn));
+  } else if (originalInsn.IsDbgInsn()) {
+    return memPool->Clone<mpldbg::DbgInsn>(*static_cast<mpldbg::DbgInsn*>(&originalInsn));
+  }
+  if (originalInsn.IsComment()) {
+    return memPool->Clone<Insn>(originalInsn);
+  }
+  CHECK_FATAL(false, "Cannot clone");
+  return nullptr;
+}
+
+/*
+ * Precondition: The given insn is a jump instruction.
+ * Get the jump target label from the given instruction.
+ * Note: MOP_xbr is a branching instruction, but the target is unknown at compile time,
+ * because a register instead of label. So we don't take it as a branching instruction.
+ */
+LabelIdx AArch64InsnVisitor::GetJumpLabel(const Insn &insn) const {
+  uint32 operandIdx = AArch64isa::GetJumpTargetIdx(insn);
+  if (insn.GetOperand(operandIdx).IsLabelOpnd()) {
+    return static_cast<LabelOperand&>(insn.GetOperand(operandIdx)).GetLabelIndex();
+  }
+  ASSERT(false, "Operand is not label");
+  return 0;
+}
+
+bool AArch64InsnVisitor::IsCompareInsn(const Insn &insn) const {
+  switch (insn.GetMachineOpcode()) {
+    case MOP_wcmpri:
+    case MOP_wcmprr:
+    case MOP_xcmpri:
+    case MOP_xcmprr:
+    case MOP_hcmperi:
+    case MOP_hcmperr:
+    case MOP_scmperi:
+    case MOP_scmperr:
+    case MOP_dcmperi:
+    case MOP_dcmperr:
+    case MOP_hcmpqri:
+    case MOP_hcmpqrr:
+    case MOP_scmpqri:
+    case MOP_scmpqrr:
+    case MOP_dcmpqri:
+    case MOP_dcmpqrr:
+    case MOP_wcmnri:
+    case MOP_wcmnrr:
+    case MOP_xcmnri:
+    case MOP_xcmnrr:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool AArch64InsnVisitor::IsCompareAndBranchInsn(const Insn &insn) const {
+  switch (insn.GetMachineOpcode()) {
+    case MOP_wcbnz:
+    case MOP_xcbnz:
+    case MOP_wcbz:
+    case MOP_xcbz:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool AArch64InsnVisitor::IsAddOrSubInsn(const Insn &insn) const {
+  switch (insn.GetMachineOpcode()) {
+    case MOP_xaddrrr:
+    case MOP_xaddrri12:
+    case MOP_waddrrr:
+    case MOP_waddrri12:
+    case MOP_xsubrrr:
+    case MOP_xsubrri12:
+    case MOP_wsubrrr:
+    case MOP_wsubrri12:
+      return true;
+    default:
+      return false;
+  }
+}
+
+RegOperand *AArch64InsnVisitor::CreateVregFromReg(const RegOperand &pReg) {
+  return &static_cast<AArch64CGFunc*>(GetCGFunc())->CreateRegisterOperandOfType(
+      pReg.GetRegisterType(), pReg.GetSize() / k8BitSize);
+}
+
+void AArch64InsnVisitor::ReTargetSuccBB(BB &bb, LabelIdx newTarget) const {
+  Insn *lastInsn = bb.GetLastMachineInsn();
+  if (lastInsn && (lastInsn->IsBranch() || lastInsn->IsCondBranch() || lastInsn->IsUnCondBranch())) {
+    CHECK_FATAL(false, "check last insn of a ft BB");
+  }
+  LabelOperand &targetOpnd = GetCGFunc()->GetOrCreateLabelOperand(newTarget);
+  Insn &newInsn = GetCGFunc()->GetInsnBuilder()->BuildInsn(MOP_xuncond, targetOpnd);
+  bb.AppendInsn(newInsn);
+}
+
+void AArch64InsnVisitor::FlipIfBB(BB &bb, LabelIdx ftLabel) const {
+  Insn *lastInsn = bb.GetLastMachineInsn();
+  CHECK_FATAL(lastInsn && lastInsn->IsCondBranch(), "must be ? of a if BB");
+  uint32 targetIdx = AArch64isa::GetJumpTargetIdx(*lastInsn);
+  MOperator mOp = AArch64isa::FlipConditionOp(lastInsn->GetMachineOpcode());
+  if (mOp == 0 || mOp > MOP_nop) {
+    CHECK_FATAL(false, "get flip op failed");
+  }
+  lastInsn->SetMOP(AArch64CG::kMd[mOp]);
+  LabelOperand &targetOpnd = GetCGFunc()->GetOrCreateLabelOperand(ftLabel);
+  lastInsn->SetOperand(targetIdx, targetOpnd);
+}
+
+BB *AArch64InsnVisitor::CreateGotoBBAfterCondBB(BB &bb, BB &fallthru, bool isTargetFallthru) const {
+  BB *newBB = GetCGFunc()->CreateNewBB();
+  newBB->SetKind(BB::kBBGoto);
+  LabelIdx fallthruLabel = fallthru.GetLabIdx();
+  if (fallthruLabel == MIRLabelTable::GetDummyLabel()) {
+    fallthruLabel = GetCGFunc()->CreateLabel();
+    fallthru.SetLabIdx(fallthruLabel);
+  }
+  LabelOperand &targetOpnd = GetCGFunc()->GetOrCreateLabelOperand(fallthruLabel);
+  Insn &gotoInsn = GetCGFunc()->GetInsnBuilder()->BuildInsn(MOP_xuncond, targetOpnd);
+  newBB->AppendInsn(gotoInsn);
+
+  /* maintain pred and succ */
+  if (!isTargetFallthru) {
+    fallthru.RemovePreds(bb);
+  }
+  fallthru.PushBackPreds(*newBB);
+  if (!isTargetFallthru) {
+    bb.RemoveSuccs(fallthru);
+  }
+  bb.PushBackSuccs(*newBB);
+  newBB->PushBackSuccs(fallthru);
+  newBB->PushBackPreds(bb);
+  return newBB;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_peep.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_peep.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba3911004f0f8926e54e05a2a848f18deb1c8a1e
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_peep.cpp
@@ -0,0 +1,4796 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_peep.h"
+#include "cg.h"
+#include "mpl_logging.h"
+#include "common_utils.h"
+#include "cg_option.h"
+#include "aarch64_utils.h"
+
+namespace maplebe {
+#define JAVALANG (cgFunc->GetMirModule().IsJavaModule())
+#define CG_PEEP_DUMP CG_DEBUG_FUNC(*cgFunc)
+namespace {
+const std::string kMccLoadRef = "MCC_LoadRefField";
+const std::string kMccLoadRefV = "MCC_LoadVolatileField";
+const std::string kMccLoadRefS = "MCC_LoadRefStatic";
+const std::string kMccLoadRefVS = "MCC_LoadVolatileStaticField";
+const std::string kMccDummy = "MCC_Dummy";
+
+const std::string GetReadBarrierName(const Insn &insn) {
+  constexpr int32 totalBarrierNamesNum = 5;
+  std::array<std::string, totalBarrierNamesNum> barrierNames = {
+    kMccLoadRef, kMccLoadRefV, kMccLoadRefS, kMccLoadRefVS, kMccDummy
+  };
+  if (insn.GetMachineOpcode() == MOP_xbl ||
+      insn.GetMachineOpcode() == MOP_tail_call_opt_xbl) {
+    auto &op = static_cast<FuncNameOperand&>(insn.GetOperand(kInsnFirstOpnd));
+    const std::string &funcName = op.GetName();
+    for (const std::string &singleBarrierName : barrierNames) {
+      if (funcName == singleBarrierName) {
+        return singleBarrierName;
+      }
+    }
+  }
+  return "";
+}
+
+MOperator GetLoadOperator(uint32 refSize, bool isVolatile) {
+  if (refSize == k32BitSize) {
+    return isVolatile ? MOP_wldar : MOP_wldr;
+  }
+  return isVolatile ? MOP_xldar : MOP_xldr;
+}
+}
+
+static bool IsZeroRegister(const Operand &opnd) {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  const RegOperand *regOpnd = static_cast<const RegOperand*>(&opnd);
+  return regOpnd->GetRegisterNumber() == RZR;
+}
+
+void AArch64CGPeepHole::Run() {
+  bool optSuccess = false;
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS_SAFE(insn, bb, nextInsn) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (ssaInfo != nullptr) {
+        optSuccess |= DoSSAOptimize(*bb, *insn);
+      } else {
+        DoNormalOptimize(*bb, *insn);
+      }
+    }
+  }
+  if (optSuccess) {
+    Run();
+  }
+}
+
+bool AArch64CGPeepHole::DoSSAOptimize(BB &bb, Insn &insn) {
+  MOperator thisMop = insn.GetMachineOpcode();
+  manager = peepMemPool->New<PeepOptimizeManager>(*cgFunc, bb, insn, *ssaInfo);
+  manager->SetOptSuccess(false);
+  switch (thisMop) {
+    case MOP_xandrrr:
+    case MOP_wandrrr: {
+      manager->Optimize<MvnAndToBicPattern>(true);
+      break;
+    }
+    case MOP_wiorrri12:
+    case MOP_xiorrri13: {
+      manager->Optimize<OrrToMovPattern>(true);
+      break;
+    }
+    case MOP_wcbz:
+    case MOP_xcbz:
+    case MOP_wcbnz:
+    case MOP_xcbnz: {
+      manager->Optimize<AndCbzToTbzPattern>(true);
+      manager->Optimize<CsetCbzToBeqPattern>(true);
+      manager->Optimize<OneHoleBranchPattern>(true);
+      break;
+    }
+    case MOP_beq:
+    case MOP_bne: {
+      manager->Optimize<AndCmpBranchesToTbzPattern>(true);
+      break;
+    }
+    case MOP_wcsetrc:
+    case MOP_xcsetrc: {
+      manager->Optimize<ContinuousCmpCsetPattern>(true);
+      break;
+    }
+    case MOP_waddrrr:
+    case MOP_xaddrrr: {
+      manager->Optimize<SimplifyMulArithmeticPattern>(true);
+      manager->Optimize<CsetToCincPattern>(true);
+      break;
+    }
+    case MOP_dadd:
+    case MOP_sadd:
+    case MOP_wsubrrr:
+    case MOP_xsubrrr:
+    case MOP_dsub:
+    case MOP_ssub:
+    case MOP_xinegrr:
+    case MOP_winegrr:
+    case MOP_wfnegrr:
+    case MOP_xfnegrr: {
+      manager->Optimize<SimplifyMulArithmeticPattern>(true);
+      break;
+    }
+    case MOP_wandrri12:
+    case MOP_xandrri13: {
+      manager->Optimize<LsrAndToUbfxPattern>(true);
+      manager->Optimize<LslAndToUbfizPattern>(true);
+      break;
+    }
+    case MOP_wcselrrrc:
+    case MOP_xcselrrrc: {
+      manager->Optimize<CselToCsetPattern>(true);
+      break;
+    }
+    case MOP_wiorrrr:
+    case MOP_xiorrrr:
+    case MOP_wiorrrrs:
+    case MOP_xiorrrrs: {
+      manager->Optimize<LogicShiftAndOrrToExtrPattern>(true);
+      break;
+    }
+    case MOP_bge:
+    case MOP_ble:
+    case MOP_blt:
+    case MOP_bgt: {
+      manager->Optimize<ZeroCmpBranchesToTbzPattern>(true);
+      break;
+    }
+    case MOP_wcmprr:
+    case MOP_xcmprr: {
+      manager->Optimize<NegCmpToCmnPattern>(true);
+      break;
+    }
+    case MOP_xlslrri6: {
+      manager->Optimize<ExtLslToBitFieldInsertPattern>();
+      manager->Optimize<CombineSameArithmeticPattern>(true);
+      manager->Optimize<LslAndToUbfizPattern>(true);
+      break;
+    }
+    case MOP_xsxtb32:
+    case MOP_xsxtb64:
+    case MOP_xsxth32:
+    case MOP_xsxth64:
+    case MOP_xsxtw64:
+    case MOP_xuxtb32:
+    case MOP_xuxth32:
+    case MOP_xuxtw64: {
+      manager->Optimize<ElimSpecificExtensionPattern>(true);
+      break;
+    }
+    case MOP_wlsrrri5:
+    case MOP_xlsrrri6:
+    case MOP_wasrrri5:
+    case MOP_xasrrri6:
+    case MOP_waddrri12:
+    case MOP_xaddrri12:
+    case MOP_wsubrri12:
+    case MOP_xsubrri12: {
+      manager->Optimize<CombineSameArithmeticPattern>(true);
+      break;
+    }
+    case MOP_wlslrri5: {
+      manager->Optimize<CombineSameArithmeticPattern>(true);
+      manager->Optimize<LslAndToUbfizPattern>(true);
+      break;
+    }
+    case MOP_wubfxrri5i5:
+    case MOP_xubfxrri6i6: {
+      manager->Optimize<UbfxAndCbzToTbzPattern>(true);
+      break;
+    }
+    default:
+      break;
+  }
+  return manager->OptSuccess();
+}
+
+bool ContinuousCmpCsetPattern::CheckCondCode(const CondOperand &condOpnd) const {
+  switch (condOpnd.GetCode()) {
+    case CC_NE:
+    case CC_EQ:
+    case CC_LT:
+    case CC_GE:
+    case CC_GT:
+    case CC_LE:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool ContinuousCmpCsetPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wcsetrc && curMop != MOP_xcsetrc) {
+    return false;
+  }
+  auto &condOpnd = static_cast<CondOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  if (condOpnd.GetCode() != CC_NE && condOpnd.GetCode() != CC_EQ) {
+    return false;
+  }
+  reverse = (condOpnd.GetCode() == CC_EQ);
+  auto &ccReg = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  prevCmpInsn = ssaInfo->GetDefInsn(ccReg);
+  if (prevCmpInsn == nullptr) {
+    return false;
+  }
+  MOperator prevCmpMop = prevCmpInsn->GetMachineOpcode();
+  if (prevCmpMop != MOP_wcmpri && prevCmpMop != MOP_xcmpri) {
+    return false;
+  }
+  if (!static_cast<ImmOperand&>(prevCmpInsn->GetOperand(kInsnThirdOpnd)).IsZero()) {
+    return false;
+  }
+  auto &cmpCCReg = static_cast<RegOperand&>(prevCmpInsn->GetOperand(kInsnFirstOpnd));
+  InsnSet useSet = GetAllUseInsn(cmpCCReg);
+  if (useSet.size() > 1) {
+    return false;
+  }
+  auto &cmpUseReg = static_cast<RegOperand&>(prevCmpInsn->GetOperand(kInsnSecondOpnd));
+  prevCsetInsn1 = ssaInfo->GetDefInsn(cmpUseReg);
+  if (prevCsetInsn1 == nullptr) {
+    return false;
+  }
+  MOperator prevCsetMop1 = prevCsetInsn1->GetMachineOpcode();
+  if (prevCsetMop1 != MOP_wcsetrc && prevCsetMop1 != MOP_xcsetrc) {
+    return false;
+  }
+  auto &condOpnd1 = static_cast<CondOperand&>(prevCsetInsn1->GetOperand(kInsnSecondOpnd));
+  if (!CheckCondCode(condOpnd1)) {
+    return false;
+  }
+  auto &ccReg1 = static_cast<RegOperand&>(prevCsetInsn1->GetOperand(kInsnThirdOpnd));
+  prevCmpInsn1 = ssaInfo->GetDefInsn(ccReg1);
+  if (prevCmpInsn1 == nullptr) {
+    return false;
+  }
+  if (IsCCRegCrossVersion(*prevCsetInsn1, *prevCmpInsn, ccReg1)) {
+    return false;
+  }
+  return true;
+}
+
+void ContinuousCmpCsetPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  MOperator curMop = insn.GetMachineOpcode();
+  Operand &resOpnd = insn.GetOperand(kInsnFirstOpnd);
+  Insn *newCsetInsn = nullptr;
+  if (reverse) {
+    MOperator prevCsetMop = prevCsetInsn1->GetMachineOpcode();
+    auto &prevCsetCondOpnd = static_cast<CondOperand&>(prevCsetInsn1->GetOperand(kInsnSecondOpnd));
+    CondOperand &newCondOpnd = aarFunc->GetCondOperand(GetReverseCC(prevCsetCondOpnd.GetCode()));
+    regno_t tmpRegNO = 0;
+    auto *tmpDefOpnd = aarFunc->CreateVirtualRegisterOperand(tmpRegNO,
+        resOpnd.GetSize(), static_cast<RegOperand&>(resOpnd).GetRegisterType());
+    tmpDefOpnd->SetValidBitsNum(k1BitSize);
+    newCsetInsn = &cgFunc->GetInsnBuilder()->BuildInsn(
+        prevCsetMop, *tmpDefOpnd, newCondOpnd, prevCsetInsn1->GetOperand(kInsnThirdOpnd));
+    BB *prevCsetBB = prevCsetInsn1->GetBB();
+    (void)prevCsetBB->InsertInsnAfter(*prevCsetInsn1, *newCsetInsn);
+    /* update ssa info */
+    auto *a64SSAInfo = static_cast<AArch64CGSSAInfo*>(ssaInfo);
+    a64SSAInfo->CreateNewInsnSSAInfo(*newCsetInsn);
+    /* dump pattern info */
+    if (CG_PEEP_DUMP) {
+      std::vector<Insn*> prevs;
+      prevs.emplace_back(prevCmpInsn1);
+      prevs.emplace_back(&insn);
+      DumpAfterPattern(prevs, prevCmpInsn, newCsetInsn);
+    }
+  }
+  MOperator newMop = (curMop == MOP_wcsetrc) ? MOP_wmovrr : MOP_xmovrr;
+  Insn *newInsn = nullptr;
+  if (newCsetInsn == nullptr) {
+    newInsn = &cgFunc->GetInsnBuilder()->BuildInsn(
+        newMop, insn.GetOperand(kInsnFirstOpnd), prevCsetInsn1->GetOperand(kInsnFirstOpnd));
+  } else {
+    newInsn = &cgFunc->GetInsnBuilder()->BuildInsn(
+        newMop, insn.GetOperand(kInsnFirstOpnd), newCsetInsn->GetOperand(kInsnFirstOpnd));
+  }
+  bb.ReplaceInsn(insn, *newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, *newInsn);
+  optSuccess = true;
+  SetCurrInsn(newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevCmpInsn1);
+    prevs.emplace_back(prevCsetInsn1);
+    if (newCsetInsn == nullptr) {
+      (void)prevs.emplace_back(prevCmpInsn);
+    } else {
+      (void)prevs.emplace_back(newCsetInsn);
+    }
+    DumpAfterPattern(prevs, &insn, newInsn);
+  }
+}
+
+bool NegCmpToCmnPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wcmprr && curMop != MOP_xcmprr) {
+    return false;
+  }
+  auto &useReg = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  prevInsn = ssaInfo->GetDefInsn(useReg);
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  if (prevMop != MOP_winegrr && prevMop != MOP_xinegrr &&
+      prevMop != MOP_winegrrs && prevMop != MOP_xinegrrs) {
+    return false;
+  }
+  // Determine whether implicit conversion is existed.
+  if ((prevMop == MOP_winegrr && curMop == MOP_xcmprr) || (prevMop == MOP_winegrrs && curMop == MOP_xcmprr) ||
+      (prevMop == MOP_xinegrr && curMop == MOP_wcmprr) || (prevMop == MOP_winegrrs && curMop == MOP_xcmprr)) {
+    return false;
+  }
+  auto &ccReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  InsnSet useInsns = GetAllUseInsn(ccReg);
+  for (auto *useInsn : useInsns) {
+    if (useInsn == nullptr) {
+      continue;
+    }
+    MOperator useMop = useInsn->GetMachineOpcode();
+    if (useMop == MOP_bhi || useMop == MOP_bls) {
+      return false;
+    }
+    bool findUnsignedCond = false;
+    for (uint32 i = 0; i < useInsn->GetOperandSize(); ++i) {
+      if (useInsn->GetOperand(i).GetKind() == Operand::kOpdCond) {
+        ConditionCode cond = static_cast<CondOperand&>(useInsn->GetOperand(i)).GetCode();
+        /* in case of ignoring v flag
+         *  adds xt, x0, x1 (0x8000000000000000) -> not set v
+         *  ==>
+         *  neg x1 x1 (0x8000000000000000) which is same for negative 0
+         *  subs xt, x0, x1 () -> set v
+         */
+        if (cond == CC_HI || cond == CC_LS || cond == CC_GE || cond == CC_GT ||
+            cond == CC_LE || cond == CC_LT) {
+          findUnsignedCond = true;
+          break;
+        }
+      }
+    }
+    if (findUnsignedCond) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void NegCmpToCmnPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  Operand &opnd1 = insn.GetOperand(kInsnSecondOpnd);
+  Operand &opnd2 = prevInsn->GetOperand(kInsnSecondOpnd);
+  auto &ccReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  MOperator currMop = insn.GetMachineOpcode();
+  Insn *newInsn = nullptr;
+  if (prevMop == MOP_winegrr || prevMop == MOP_xinegrr) {
+    MOperator newMop = (currMop == MOP_wcmprr) ? MOP_wcmnrr : MOP_xcmnrr;
+    newInsn = &(cgFunc->GetInsnBuilder()->BuildInsn(newMop, ccReg, opnd1, opnd2));
+  } else {
+    /* prevMop == MOP_winegrrs || prevMop == MOP_xinegrrs */
+    MOperator newMop = (currMop == MOP_wcmprr) ? MOP_wcmnrrs : MOP_xcmnrrs;
+    Operand &shiftOpnd = prevInsn->GetOperand(kInsnThirdOpnd);
+    newInsn = &(cgFunc->GetInsnBuilder()->BuildInsn(newMop, ccReg, opnd1, opnd2, shiftOpnd));
+  }
+  CHECK_FATAL(newInsn != nullptr, "must create newInsn");
+  bb.ReplaceInsn(insn, *newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, *newInsn);
+  optSuccess = true;
+  SetCurrInsn(newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &insn, newInsn);
+  }
+}
+
+void LdrCmpPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  bb.RemoveInsn(*ldr2);
+  bb.RemoveInsn(*ldr1);
+  bb.RemoveInsn(insn);
+  bb.RemoveInsn(*bne1);
+  prevLdr1->SetMOP(AArch64CG::kMd[MOP_xldr]);
+  prevLdr2->SetMOP(AArch64CG::kMd[MOP_xldr]);
+  prevCmp->SetMOP(AArch64CG::kMd[MOP_xcmprr]);
+}
+
+bool LdrCmpPattern::CheckCondition(Insn &insn) {
+  /* a pattern which breaks cfg
+   * it is more suitable for peephole after pgo using */
+  if (CGOptions::DoLiteProfGen() || CGOptions::DoLiteProfUse()) {
+    return false;
+  }
+  if (currInsn != &insn) {
+    return false;
+  }
+  if (!SetInsns()) {
+    return false;
+  }
+  if (!CheckInsns()) {
+    return false;
+  }
+  auto &reg0 = static_cast<RegOperand&>(currInsn->GetOperand(kInsnSecondOpnd));
+  auto &reg1 = static_cast<RegOperand&>(currInsn->GetOperand(kInsnThirdOpnd));
+  return !(IfOperandIsLiveAfterInsn(reg0, insn) || IfOperandIsLiveAfterInsn(reg1, insn));
+}
+
+/*
+ * mopSeq:
+ * ldr,ldr,cmp,bne
+ */
+bool LdrCmpPattern::SetInsns() {
+  if (!IsLdr(currInsn->GetPreviousMachineInsn())) {
+    return false;
+  }
+  ldr2 = currInsn->GetPreviousMachineInsn();
+  if (!IsLdr(ldr2->GetPreviousMachineInsn())) {
+    return false;
+  }
+  ldr1 = ldr2->GetPreviousMachineInsn();
+  /* ldr1 must be firstInsn in currBB */
+  if (currInsn->GetBB()->GetFirstInsn() != ldr1) {
+    return false;
+  }
+  if (!IsBne(currInsn->GetNextMachineInsn())) {
+    return false;
+  }
+  bne1 = currInsn->GetNextMachineInsn();
+  BB *prevBB = currInsn->GetBB()->GetPrev();
+  /* single prev, single pred */
+  const MapleList<BB*> &predBBs = currInsn->GetBB()->GetPreds();
+  if ((prevBB == nullptr) || (predBBs.size() != 1) || (prevBB != *predBBs.begin())) {
+    return false;
+  }
+  if (!IsBne(prevBB->GetLastInsn())) {
+    return false;
+  }
+  bne2 = prevBB->GetLastInsn();
+  if (!IsCmp(bne2->GetPreviousMachineInsn())) {
+    return false;
+  }
+  prevCmp = bne2->GetPreviousMachineInsn();
+  if (!IsLdr(prevCmp->GetPreviousMachineInsn())) {
+    return false;
+  }
+  prevLdr2 = prevCmp->GetPreviousMachineInsn();
+  if (!IsLdr(prevLdr2->GetPreviousMachineInsn())) {
+    return false;
+  }
+  prevLdr1 = prevLdr2->GetPreviousMachineInsn();
+  return true;
+}
+
+bool LdrCmpPattern::CheckInsns() const {
+  auto &label1 = static_cast<LabelOperand&>(bne1->GetOperand(kInsnSecondOpnd));
+  auto &label2 = static_cast<LabelOperand&>(bne2->GetOperand(kInsnSecondOpnd));
+  if (label1.GetLabelIndex() != label2.GetLabelIndex()) {
+    return false;
+  }
+  auto &reg0 = static_cast<RegOperand&>(currInsn->GetOperand(kInsnSecondOpnd));
+  auto &reg1 = static_cast<RegOperand&>(currInsn->GetOperand(kInsnThirdOpnd));
+  regno_t regno0 = reg0.GetRegisterNumber();
+  regno_t regno1 = reg1.GetRegisterNumber();
+  if (regno0 == regno1) {
+    return false;
+  }
+  auto &mem1 = static_cast<MemOperand&>(ldr1->GetOperand(kInsnSecondOpnd));
+  auto &preMem1 = static_cast<MemOperand&>(prevLdr1->GetOperand(kInsnSecondOpnd));
+  auto &mem2 = static_cast<MemOperand&>(ldr2->GetOperand(kInsnSecondOpnd));
+  auto &preMem2 = static_cast<MemOperand&>(prevLdr2->GetOperand(kInsnSecondOpnd));
+  regno_t regnoBase0 = mem1.GetBaseRegister()->GetRegisterNumber();
+  regno_t regnoBase1 = mem2.GetBaseRegister()->GetRegisterNumber();
+  if (regnoBase0 == regnoBase1) {
+    return false;
+  }
+  if ((regno0 == regnoBase0) || (regno0 == regnoBase1) || (regno1 == regnoBase0) || (regno1 == regnoBase1)) {
+    return false;
+  }
+  if ((reg0 == static_cast<RegOperand&>(ldr2->GetOperand(kInsnFirstOpnd))) &&
+      (reg0 == static_cast<RegOperand&>(prevLdr2->GetOperand(kInsnFirstOpnd))) &&
+      (reg1 == static_cast<RegOperand&>(ldr1->GetOperand(kInsnFirstOpnd))) &&
+      (reg1 == static_cast<RegOperand&>(prevLdr1->GetOperand(kInsnFirstOpnd)))) {
+    if (MemOffet4Bit(preMem2, mem2) && MemOffet4Bit(preMem1, mem1)) {
+      return true;
+    }
+  }
+  if ((reg0 == static_cast<RegOperand&>(ldr1->GetOperand(kInsnFirstOpnd))) &&
+      (reg0 == static_cast<RegOperand&>(prevLdr1->GetOperand(kInsnFirstOpnd))) &&
+      (reg1 == static_cast<RegOperand&>(ldr2->GetOperand(kInsnFirstOpnd))) &&
+      (reg1 == static_cast<RegOperand&>(prevLdr2->GetOperand(kInsnFirstOpnd)))) {
+    if (MemOffet4Bit(preMem2, mem2) && MemOffet4Bit(preMem1, mem1)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool LdrCmpPattern::MemOffet4Bit(const MemOperand &m1, const MemOperand &m2) const {
+  if (m1.GetAddrMode() != m2.GetAddrMode()) {
+    return false;
+  }
+  if (m1.GetAddrMode() != MemOperand::kAddrModeBOi) {
+    return false;
+  }
+  if (m1.GetBaseRegister()->GetRegisterNumber() != m2.GetBaseRegister()->GetRegisterNumber()) {
+    return false;
+  }
+  int64 offset = m2.GetOffsetOperand()->GetValue() - m1.GetOffsetOperand()->GetValue();
+  return offset == k4BitSizeInt;
+}
+
+bool CsetCbzToBeqPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wcbz && curMop != MOP_xcbz && curMop != MOP_wcbnz && curMop != MOP_xcbnz) {
+    return false;
+  }
+  auto &useReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  prevInsn = ssaInfo->GetDefInsn(useReg);
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  if (prevMop != MOP_wcsetrc && prevMop != MOP_xcsetrc) {
+    return false;
+  }
+  auto &ccReg = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+  if (IsCCRegCrossVersion(*prevInsn, insn, ccReg)) {
+    return false;
+  }
+  return true;
+}
+
+MOperator CsetCbzToBeqPattern::SelectNewMop(ConditionCode condCode, bool inverse) const {
+  switch (condCode) {
+    case CC_NE:
+      return inverse ? MOP_beq : MOP_bne;
+    case CC_EQ:
+      return inverse ? MOP_bne : MOP_beq;
+    case CC_MI:
+      return inverse ? MOP_bpl : MOP_bmi;
+    case CC_PL:
+      return inverse ? MOP_bmi : MOP_bpl;
+    case CC_VS:
+      return inverse ? MOP_bvc : MOP_bvs;
+    case CC_VC:
+      return inverse ? MOP_bvs : MOP_bvc;
+    case CC_HI:
+      return inverse ? MOP_bls : MOP_bhi;
+    case CC_LS:
+      return inverse ? MOP_bhi : MOP_bls;
+    case CC_GE:
+      return inverse ? MOP_blt : MOP_bge;
+    case CC_LT:
+      return inverse ? MOP_bge : MOP_blt;
+    case CC_HS:
+      return inverse ? MOP_blo : MOP_bhs;
+    case CC_LO:
+      return inverse ? MOP_bhs : MOP_blo;
+    case CC_LE:
+      return inverse ? MOP_bgt : MOP_ble;
+    case CC_GT:
+      return inverse ? MOP_ble : MOP_bgt;
+    case CC_CS:
+      return inverse ? MOP_bcc : MOP_bcs;
+    default:
+      return MOP_undef;
+  }
+}
+
+void CsetCbzToBeqPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator curMop = insn.GetMachineOpcode();
+  bool reverse = (curMop == MOP_wcbz || curMop == MOP_xcbz);
+  auto &labelOpnd = static_cast<LabelOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  auto &condOpnd = static_cast<CondOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+  MOperator newMop = SelectNewMop(condOpnd.GetCode(), reverse);
+  ASSERT(newMop != MOP_undef, "unknown condition code");
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, prevInsn->GetOperand(kInsnThirdOpnd), labelOpnd);
+  bb.ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  optSuccess = true;
+  SetCurrInsn(&newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+bool ExtLslToBitFieldInsertPattern::CheckCondition(Insn &insn) {
+  auto &useReg = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  prevInsn = ssaInfo->GetDefInsn(useReg);
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  if (prevMop != MOP_xsxtw64 && prevMop != MOP_xuxtw64) {
+    return false;
+  }
+  auto &immOpnd = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  if (immOpnd.GetValue() > k32BitSize) {
+    return false;
+  }
+  return true;
+}
+
+void ExtLslToBitFieldInsertPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto &prevSrcReg = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+  cgFunc->InsertExtendSet(prevSrcReg.GetRegisterNumber());
+  MOperator newMop = (prevInsn->GetMachineOpcode() == MOP_xsxtw64) ? MOP_xsbfizrri6i6 : MOP_xubfizrri6i6;
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  auto &newImmOpnd1 = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  ImmOperand &newImmOpnd2 = aarFunc->CreateImmOperand(k32BitSize, k6BitSize, false);
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+      newMop, insn.GetOperand(kInsnFirstOpnd), prevSrcReg, newImmOpnd1, newImmOpnd2);
+  bb.ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  optSuccess = true;
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+bool CselToCsetPattern::IsOpndDefByZero(const Insn &insn) const {
+  MOperator movMop = insn.GetMachineOpcode();
+  switch (movMop) {
+    case MOP_xmovrr:
+    case MOP_wmovrr: {
+      return IsZeroRegister(insn.GetOperand(kInsnSecondOpnd));
+    }
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      auto &immOpnd = static_cast<ImmOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      return immOpnd.GetValue() == 0;
+    }
+    default:
+      return false;
+  }
+}
+
+bool CselToCsetPattern::IsOpndDefByOne(const Insn &insn) const {
+  MOperator movMop = insn.GetMachineOpcode();
+  if ((movMop != MOP_wmovri32) && (movMop != MOP_xmovri64)) {
+    return false;
+  }
+  auto &immOpnd = static_cast<ImmOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  return immOpnd.GetValue() == 1;
+}
+
+bool CselToCsetPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wcselrrrc && curMop != MOP_xcselrrrc) {
+    return false;
+  }
+  auto &useOpnd1 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  prevMovInsn1 = ssaInfo->GetDefInsn(useOpnd1);
+  if (prevMovInsn1 == nullptr) {
+    return false;
+  }
+  MOperator prevMop1 = prevMovInsn1->GetMachineOpcode();
+  if (prevMop1 != MOP_wmovri32 && prevMop1 != MOP_xmovri64 &&
+      prevMop1 != MOP_wmovrr && prevMop1 != MOP_xmovrr) {
+    return false;
+  }
+  auto &useOpnd2 = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  prevMovInsn2 = ssaInfo->GetDefInsn(useOpnd2);
+  if (prevMovInsn2 == nullptr) {
+    return false;
+  }
+  MOperator prevMop2 = prevMovInsn2->GetMachineOpcode();
+  if (prevMop2 != MOP_wmovri32 && prevMop2 != MOP_xmovri64 &&
+      prevMop2 != MOP_wmovrr && prevMop2 != MOP_xmovrr) {
+    return false;
+  }
+  return true;
+}
+
+void CselToCsetPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  Operand &dstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  MOperator newMop = (dstOpnd.GetSize() == k64BitSize ? MOP_xcsetrc : MOP_wcsetrc);
+  Operand &condOpnd = insn.GetOperand(kInsnFourthOpnd);
+  Operand &rflag = insn.GetOperand(kInsnFifthOpnd);
+  Insn *newInsn = nullptr;
+  if (IsOpndDefByOne(*prevMovInsn1) && IsOpndDefByZero(*prevMovInsn2)) {
+    newInsn = &(cgFunc->GetInsnBuilder()->BuildInsn(newMop, dstOpnd, condOpnd, rflag));
+  } else if (IsOpndDefByZero(*prevMovInsn1) && IsOpndDefByOne(*prevMovInsn2)) {
+    auto &origCondOpnd = static_cast<CondOperand&>(condOpnd);
+    ConditionCode inverseCondCode = GetReverseCC(origCondOpnd.GetCode());
+    if (inverseCondCode == kCcLast) {
+      return;
+    }
+    auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+    CondOperand &inverseCondOpnd = aarFunc->GetCondOperand(inverseCondCode);
+    newInsn = &(cgFunc->GetInsnBuilder()->BuildInsn(newMop, dstOpnd, inverseCondOpnd, rflag));
+  }
+  if (newInsn == nullptr) {
+    return;
+  }
+  bb.ReplaceInsn(insn, *newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, *newInsn);
+  optSuccess = true;
+  SetCurrInsn(newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevMovInsn1);
+    prevs.emplace_back(prevMovInsn2);
+    DumpAfterPattern(prevs, &insn, newInsn);
+  }
+}
+
+bool CsetToCincPattern::CheckDefInsn(const RegOperand &opnd, Insn &insn) {
+  Insn *tempDefInsn = ssaInfo->GetDefInsn(opnd);
+  if (tempDefInsn != nullptr && tempDefInsn->GetBB()->GetId() == insn.GetBB()->GetId()) {
+    InsnSet useInsns = GetAllUseInsn(opnd);
+    if (useInsns.size() != 1) {
+      return false;
+    }
+    MOperator mop = tempDefInsn->GetMachineOpcode();
+    if (mop == MOP_wcsetrc || mop == MOP_xcsetrc) {
+      /* DefInsn and tempDefInsn are in the same BB. Select a close to useInsn(add) */
+      if (!CheckRegTyCc(*tempDefInsn, insn)) {
+        return false;
+      }
+      defInsn = tempDefInsn;
+      return true;
+    }
+  }
+  return false;
+}
+
+/* If a new ConditionCode is generated after csetInsn, this optimization is not performed. */
+bool CsetToCincPattern::CheckRegTyCc(const Insn &tempDefInsn, Insn &insn) {
+  bool betweenUseAndDef = false;
+  FOR_BB_INSNS_REV(bbInsn, insn.GetBB()) {
+    if (!bbInsn->IsMachineInstruction()) {
+      continue;
+    }
+    if (bbInsn->GetId() == insn.GetId()) {
+      betweenUseAndDef = true;
+    }
+    if (betweenUseAndDef) {
+      /* Select a close to useInsn(add) */
+      if (defInsn != nullptr && bbInsn->GetId() == defInsn->GetId()) {
+        return false;
+      } else if (bbInsn->GetId() == tempDefInsn.GetId()) {
+        return true;
+      } else if (static_cast<RegOperand&>(bbInsn->GetOperand(kInsnFirstOpnd)).IsOfCC()) {
+        return false;
+      }
+    }
+  }
+  return false;
+}
+
+bool CsetToCincPattern::CheckCondition(Insn &insn) {
+  RegOperand &opnd2 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  RegOperand &opnd3 = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  bool opnd2Cset = CheckDefInsn(opnd2, insn);
+  bool opnd3Cset = CheckDefInsn(opnd3, insn);
+  if (opnd3Cset) {
+    csetOpnd1 = kInsnThirdOpnd;
+    return true;
+  } else if (opnd2Cset) {
+    csetOpnd1 = kInsnSecondOpnd;
+    return true;
+  }
+  return false;
+}
+
+void CsetToCincPattern::Run(BB &bb, Insn &insn) {
+  RegOperand &opnd1 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  /* Exclude other patterns that have been optimized. */
+  Insn *newAddInsn = ssaInfo->GetDefInsn(opnd1);
+  if (newAddInsn == nullptr) {
+    return;
+  }
+  MOperator mop = newAddInsn->GetMachineOpcode();
+  if (mop != MOP_waddrrr && mop != MOP_xaddrrr) {
+    return;
+  }
+  if (!CheckCondition(insn) || defInsn == nullptr || csetOpnd1 == 0) {
+    return;
+  }
+  MOperator newMop = (insn.GetMachineOpcode() == MOP_waddrrr) ? MOP_wcincrc : MOP_xcincrc;
+  int32 cincOpnd2 = (csetOpnd1 == kInsnSecondOpnd) ? kInsnThirdOpnd : kInsnSecondOpnd;
+  RegOperand &opnd2 = static_cast<RegOperand&>(insn.GetOperand(static_cast<uint32>(cincOpnd2)));
+  Operand &condOpnd = defInsn->GetOperand(kInsnSecondOpnd);
+  Operand &rflag = defInsn->GetOperand(kInsnThirdOpnd);
+  Insn *newInsn = &(cgFunc->GetInsnBuilder()->BuildInsn(newMop, opnd1, opnd2, condOpnd, rflag));
+  bb.ReplaceInsn(insn, *newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, *newInsn);
+  optSuccess = true;
+  SetCurrInsn(newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    (void)prevs.emplace_back(defInsn);
+    DumpAfterPattern(prevs, &insn, newInsn);
+  }
+}
+
+bool AndCmpBranchesToTbzPattern::CheckAndSelectPattern(const Insn &currInsn) {
+  MOperator curMop = currInsn.GetMachineOpcode();
+  MOperator prevAndMop = prevAndInsn->GetMachineOpcode();
+  auto &andImmOpnd = static_cast<ImmOperand&>(prevAndInsn->GetOperand(kInsnThirdOpnd));
+  auto &cmpImmOpnd = static_cast<ImmOperand&>(prevCmpInsn->GetOperand(kInsnThirdOpnd));
+  if (cmpImmOpnd.GetValue() == 0) {
+    tbzImmVal = GetLogValueAtBase2(andImmOpnd.GetValue());
+    if (tbzImmVal < 0) {
+      return false;
+    }
+    switch (curMop) {
+      case MOP_beq:
+        newMop = (prevAndMop == MOP_wandrri12) ?  MOP_wtbz : MOP_xtbz;
+        break;
+      case MOP_bne:
+        newMop = (prevAndMop == MOP_wandrri12) ? MOP_wtbnz : MOP_xtbnz;
+        break;
+      default:
+        return false;
+    }
+  } else {
+    tbzImmVal = GetLogValueAtBase2(andImmOpnd.GetValue());
+    int64 tmpVal = GetLogValueAtBase2(cmpImmOpnd.GetValue());
+    if (tbzImmVal < 0 || tmpVal < 0 || tbzImmVal != tmpVal) {
+      return false;
+    }
+    switch (curMop) {
+      case MOP_beq:
+        newMop = (prevAndMop == MOP_wandrri12) ?  MOP_wtbnz : MOP_xtbnz;
+        break;
+      case MOP_bne:
+        newMop = (prevAndMop == MOP_wandrri12) ? MOP_wtbz : MOP_xtbz;
+        break;
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+
+bool AndCmpBranchesToTbzPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_beq && curMop != MOP_bne) {
+    return false;
+  }
+  auto &ccReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  prevCmpInsn = ssaInfo->GetDefInsn(ccReg);
+  if (prevCmpInsn == nullptr) {
+    return false;
+  }
+  MOperator prevCmpMop = prevCmpInsn->GetMachineOpcode();
+  if (prevCmpMop != MOP_wcmpri && prevCmpMop != MOP_xcmpri) {
+    return false;
+  }
+  auto &cmpUseReg = static_cast<RegOperand&>(prevCmpInsn->GetOperand(kInsnSecondOpnd));
+  prevAndInsn = ssaInfo->GetDefInsn(cmpUseReg);
+  if (prevAndInsn == nullptr) {
+    return false;
+  }
+  MOperator prevAndMop = prevAndInsn->GetMachineOpcode();
+  if (prevAndMop != MOP_wandrri12 && prevAndMop != MOP_xandrri13) {
+    return false;
+  }
+  CHECK_FATAL(prevAndInsn->GetOperand(kInsnFirstOpnd).GetSize() ==
+              prevCmpInsn->GetOperand(kInsnSecondOpnd).GetSize(), "def-use reg size must be same based-on ssa");
+  if (!CheckAndSelectPattern(insn)) {
+    return false;
+  }
+  return true;
+}
+
+void AndCmpBranchesToTbzPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  auto &labelOpnd = static_cast<LabelOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  ImmOperand &tbzImmOpnd = aarFunc->CreateImmOperand(tbzImmVal, k8BitSize, false);
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+      newMop, prevAndInsn->GetOperand(kInsnSecondOpnd), tbzImmOpnd, labelOpnd);
+  bb.ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  optSuccess = true;
+  SetCurrInsn(&newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevAndInsn);
+    prevs.emplace_back(prevCmpInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+bool ZeroCmpBranchesToTbzPattern::CheckAndSelectPattern(const Insn &currInsn) {
+  MOperator currMop = currInsn.GetMachineOpcode();
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  switch (prevMop) {
+    case MOP_wcmpri:
+    case MOP_xcmpri: {
+      regOpnd = &static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+      auto &immOpnd = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+      if (immOpnd.GetValue() != 0) {
+        return false;
+      }
+      switch (currMop) {
+        case MOP_bge:
+          newMop = (regOpnd->GetSize() <= k32BitSize) ? MOP_wtbz : MOP_xtbz;
+          break;
+        case MOP_blt:
+          newMop = (regOpnd->GetSize() <= k32BitSize) ? MOP_wtbnz : MOP_xtbnz;
+          break;
+        default:
+          return false;
+      }
+      break;
+    }
+    case MOP_wcmprr:
+    case MOP_xcmprr: {
+      auto &regOpnd0 = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+      auto &regOpnd1 = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+      if (!IsZeroRegister(regOpnd0) && !IsZeroRegister(regOpnd1)) {
+        return false;
+      }
+      switch (currMop) {
+        case MOP_bge:
+          if (IsZeroRegister(regOpnd1)) {
+            regOpnd = &static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+            newMop = (regOpnd->GetSize() <= k32BitSize) ? MOP_wtbz : MOP_xtbz;
+          } else {
+            return false;
+          }
+          break;
+        case MOP_ble:
+          if (IsZeroRegister(regOpnd0)) {
+            regOpnd = &static_cast<RegOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+            newMop = (regOpnd->GetSize() <= k32BitSize) ? MOP_wtbz : MOP_xtbz;
+          } else {
+            return false;
+          }
+          break;
+        case MOP_blt:
+          if (IsZeroRegister(regOpnd1)) {
+            regOpnd = &static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+            newMop = (regOpnd->GetSize() <= k32BitSize) ? MOP_wtbnz : MOP_xtbnz;
+          } else {
+            return false;
+          }
+          break;
+        case MOP_bgt:
+          if (IsZeroRegister(regOpnd0)) {
+            regOpnd = &static_cast<RegOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+            newMop = (regOpnd->GetSize() <= k32BitSize) ? MOP_wtbnz : MOP_xtbnz;
+          } else {
+            return false;
+          }
+          break;
+        default:
+          return false;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  return true;
+}
+
+bool ZeroCmpBranchesToTbzPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_bge && curMop != MOP_ble && curMop != MOP_blt && curMop != MOP_bgt) {
+    return false;
+  }
+  CHECK_FATAL(insn.GetOperand(kInsnSecondOpnd).IsLabel(), "must be labelOpnd");
+  auto &ccReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  prevInsn = ssaInfo->GetDefInsn(ccReg);
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  if (prevMop != MOP_wcmpri && prevMop != MOP_xcmpri && prevMop != MOP_wcmprr && prevMop != MOP_xcmprr) {
+    return false;
+  }
+  if (!CheckAndSelectPattern(insn)) {
+    return false;
+  }
+  return true;
+}
+
+void ZeroCmpBranchesToTbzPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  CHECK_FATAL(regOpnd != nullptr, "must have regOpnd");
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  ImmOperand &bitOpnd = aarFunc->CreateImmOperand(
+      (regOpnd->GetSize() <= k32BitSize) ? (k32BitSize - 1) : (k64BitSize - 1), k8BitSize, false);
+  auto &labelOpnd = static_cast<LabelOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, *static_cast<RegOperand*>(regOpnd), bitOpnd, labelOpnd);
+  bb.ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  optSuccess = true;
+  SetCurrInsn(&newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+bool LsrAndToUbfxPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wandrri12 && curMop != MOP_xandrri13) {
+    return false;
+  }
+  int64 immValue = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd)).GetValue();
+  /* and_imm value must be (1 << n - 1) */
+  if (immValue <= 0 ||
+      (((static_cast<uint64>(immValue)) & (static_cast<uint64>(immValue) + 1)) != 0)) {
+    return false;
+  }
+  auto &useReg = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  prevInsn = ssaInfo->GetDefInsn(useReg);
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  if (prevMop != MOP_wlsrrri5 && prevMop != MOP_xlsrrri6) {
+    return false;
+  }
+  auto &prevDstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+  auto &currUseOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  /* check def-use reg size found by ssa */
+  CHECK_FATAL(prevDstOpnd.GetSize() == currUseOpnd.GetSize(), "def-use reg size must be same");
+  auto &andDstReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  VRegVersion *andDstVersion = ssaInfo->FindSSAVersion(andDstReg.GetRegisterNumber());
+  ASSERT(andDstVersion != nullptr, "find destReg Version failed");
+  for (auto useDUInfoIt : andDstVersion->GetAllUseInsns()) {
+    if (useDUInfoIt.second == nullptr) {
+      continue;
+    }
+    Insn *useInsn = (useDUInfoIt.second)->GetInsn();
+    if (useInsn == nullptr) {
+      continue;
+    }
+    MOperator useMop = useInsn->GetMachineOpcode();
+    /* combine [and & cbz --> tbz] first, to eliminate more insns becase of incompleted copy prop */
+    if (useMop == MOP_wcbz || useMop == MOP_xcbz || useMop == MOP_wcbnz || useMop == MOP_xcbnz) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void LsrAndToUbfxPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  bool is64Bits = (static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd)).GetSize() == k64BitSize);
+  Operand &resOpnd = insn.GetOperand(kInsnFirstOpnd);
+  Operand &srcOpnd = prevInsn->GetOperand(kInsnSecondOpnd);
+  int64 immVal1 = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd)).GetValue();
+  Operand &immOpnd1 = is64Bits ? aarFunc->CreateImmOperand(immVal1, kMaxImmVal6Bits, false) :
+                      aarFunc->CreateImmOperand(immVal1, kMaxImmVal5Bits, false);
+  int64 tmpVal = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd)).GetValue();
+  int64 immVal2 = __builtin_ffsll(tmpVal + 1) - 1;
+  if ((immVal2 < k1BitSize) || (is64Bits && (immVal1 + immVal2) > k64BitSize) ||
+      (!is64Bits && (immVal1 + immVal2) > k32BitSize)) {
+    return;
+  }
+  Operand &immOpnd2 = is64Bits ? aarFunc->CreateImmOperand(immVal2, kMaxImmVal6Bits, false) :
+                      aarFunc->CreateImmOperand(immVal2, kMaxImmVal5Bits, false);
+  MOperator newMop = (is64Bits ? MOP_xubfxrri6i6 : MOP_wubfxrri5i5);
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, resOpnd, srcOpnd, immOpnd1, immOpnd2);
+  bb.ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  optSuccess = true;
+  SetCurrInsn(&newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+bool LslAndToUbfizPattern::CheckCondition(Insn &insn) {
+  MOperator mop = insn.GetMachineOpcode();
+  RegOperand &opnd2 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  defInsn = ssaInfo->GetDefInsn(opnd2);
+  InsnSet useInsns = GetAllUseInsn(opnd2);
+  if (useInsns.size() != 1 || defInsn == nullptr) {
+    return false;
+  }
+  MOperator defMop = defInsn->GetMachineOpcode();
+  if ((mop == MOP_wandrri12 || mop == MOP_xandrri13) && (defMop == MOP_wlslrri5 || defMop == MOP_xlslrri6)) {
+    return true;
+  } else if ((defMop == MOP_wandrri12 || defMop == MOP_xandrri13) && (mop == MOP_wlslrri5 || mop == MOP_xlslrri6)) {
+    /* lsl w1, w2, #n. insn and w1's useInsn can do prop, skipping this pattern */
+    for (auto *useInsn : GetAllUseInsn(static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd)))) {
+      if (useInsn == nullptr) {
+        continue;
+      }
+      if (!CheckUseInsnMop(*useInsn)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+bool LslAndToUbfizPattern::CheckUseInsnMop(const Insn &useInsn) {
+  if (useInsn.IsLoad() || useInsn.IsStore()) {
+    return false;
+  }
+  MOperator useMop = useInsn.GetMachineOpcode();
+  switch (useMop) {
+    case MOP_xeorrrr:
+    case MOP_xeorrrrs:
+    case MOP_weorrrr:
+    case MOP_weorrrrs:
+    case MOP_xiorrrr:
+    case MOP_xiorrrrs:
+    case MOP_wiorrrr:
+    case MOP_wiorrrrs:
+    case MOP_xaddrrr:
+    case MOP_xxwaddrrre:
+    case MOP_xaddrrrs:
+    case MOP_waddrrr:
+    case MOP_wwwaddrrre:
+    case MOP_waddrrrs:
+    case MOP_waddrri12:
+    case MOP_xaddrri12:
+    case MOP_xsubrrr:
+    case MOP_xxwsubrrre:
+    case MOP_xsubrrrs:
+    case MOP_wsubrrr:
+    case MOP_wwwsubrrre:
+    case MOP_wsubrrrs:
+    case MOP_xinegrr:
+    case MOP_winegrr:
+    case MOP_xsxtb32:
+    case MOP_xsxtb64:
+    case MOP_xsxth32:
+    case MOP_xsxth64:
+    case MOP_xuxtb32:
+    case MOP_xuxth32:
+    case MOP_xuxtw64:
+    case MOP_xsxtw64:
+    case MOP_xubfxrri6i6:
+    case MOP_xcmprr:
+    case MOP_xwcmprre:
+    case MOP_xcmprrs:
+    case MOP_wcmprr:
+    case MOP_wwcmprre:
+    case MOP_wcmprrs:
+      return false;
+    default:
+      break;
+  }
+  return true;
+}
+
+void LslAndToUbfizPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator mop = insn.GetMachineOpcode();
+  Insn *newInsn = nullptr;
+  if (mop == MOP_wandrri12 || mop == MOP_xandrri13) {
+    newInsn = BuildNewInsn(insn, *defInsn, insn);
+  }
+  if (mop == MOP_wlslrri5 || mop == MOP_xlslrri6) {
+    newInsn = BuildNewInsn(*defInsn, insn, insn);
+  }
+  if (newInsn == nullptr) {
+    return;
+  }
+  bb.ReplaceInsn(insn, *newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, *newInsn);
+  optSuccess = true;
+  SetCurrInsn(newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    (void)prevs.emplace_back(defInsn);
+    DumpAfterPattern(prevs, &insn, newInsn);
+  }
+}
+
+/* Build ubfiz insn or mov insn */
+Insn *LslAndToUbfizPattern::BuildNewInsn(const Insn &andInsn, const Insn &lslInsn, const Insn &useInsn) {
+  uint64 andImmValue = static_cast<uint64>(static_cast<ImmOperand&>(andInsn.GetOperand(kInsnThirdOpnd)).GetValue());
+  /* Check whether the value of immValue is 2^n-1. */
+  uint64 judgment = andImmValue & (andImmValue + 1);
+  if (judgment != 0) {
+    return nullptr;
+  }
+  MOperator mop = andInsn.GetMachineOpcode();
+  MOperator useMop = useInsn.GetMachineOpcode();
+  RegOperand &ubfizOpnd1 = static_cast<RegOperand&>(useInsn.GetOperand(kInsnFirstOpnd));
+  uint32 opnd1Size = ubfizOpnd1.GetSize();
+  RegOperand &ubfizOpnd2 = static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd));
+  uint32 opnd2Size = ubfizOpnd2.GetSize();
+  ImmOperand &ubfizOpnd3 = static_cast<ImmOperand&>(lslInsn.GetOperand(kInsnThirdOpnd));
+  uint32 mValue = static_cast<uint32>(ubfizOpnd3.GetValue());
+  uint32 nValue = static_cast<uint32>(__builtin_popcountll(andImmValue));
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  if (opnd1Size != opnd2Size) {
+    return nullptr;
+  }
+  if (nValue > mValue || useMop == MOP_wlslrri5 || useMop == MOP_xlslrri6) {
+    MOperator newMop = (mop == MOP_wandrri12) ? MOP_wubfizrri5i5 : MOP_xubfizrri6i6;
+    uint32 size = (mop == MOP_wandrri12) ? kMaxImmVal5Bits : kMaxImmVal6Bits;
+    int64 val = 0;
+    if (useMop == MOP_wlslrri5 || useMop == MOP_xlslrri6) {
+      val = opnd1Size > (nValue + mValue) ? nValue : opnd1Size - mValue;
+    } else {
+      val = nValue - mValue;
+    }
+    ImmOperand &ubfizOpnd4 = aarFunc->CreateImmOperand(val, size, false);
+    Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, ubfizOpnd1, ubfizOpnd2, ubfizOpnd3, ubfizOpnd4);
+    return &newInsn;
+  }
+  return nullptr;
+}
+
+bool MvnAndToBicPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wandrrr && curMop != MOP_xandrrr) {
+    return false;
+  }
+  auto &useReg1 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  auto &useReg2 = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  prevInsn1 = ssaInfo->GetDefInsn(useReg1);
+  prevInsn2 = ssaInfo->GetDefInsn(useReg2);
+  MOperator mop = insn.GetMachineOpcode();
+  MOperator desMop = mop == MOP_xandrrr ? MOP_xnotrr : MOP_wnotrr;
+  op1IsMvnDef = prevInsn1 != nullptr && prevInsn1->GetMachineOpcode() == desMop;
+  op2IsMvnDef = prevInsn2 != nullptr && prevInsn2->GetMachineOpcode() == desMop;
+  if (op1IsMvnDef || op2IsMvnDef) {
+    return true;
+  }
+  return false;
+}
+
+void MvnAndToBicPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator newMop = insn.GetMachineOpcode() == MOP_xandrrr ? MOP_xbicrrr : MOP_wbicrrr;
+  Insn *prevInsn = op1IsMvnDef ? prevInsn1 : prevInsn2;
+  auto &prevOpnd1 = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+  auto &opnd0 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &opnd1 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  auto &opnd2 = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+      newMop, opnd0, op1IsMvnDef ? opnd2 : opnd1, prevOpnd1);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  bb.ReplaceInsn(insn, newInsn);
+  optSuccess = true;
+  SetCurrInsn(&newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+bool AndCbzToTbzPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wcbz && curMop != MOP_xcbz && curMop != MOP_wcbnz && curMop != MOP_xcbnz) {
+    return false;
+  }
+  auto &useReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  prevInsn = ssaInfo ? ssaInfo->GetDefInsn(useReg) : insn.GetPreviousMachineInsn();
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  if (prevMop != MOP_wandrri12 && prevMop != MOP_xandrri13) {
+    return false;
+  }
+  if (!ssaInfo && (&(prevInsn->GetOperand(kInsnFirstOpnd)) != &(insn.GetOperand(kInsnFirstOpnd)))) {
+    return false;
+  }
+  return true;
+}
+
+void AndCbzToTbzPattern::Run(BB &bb, Insn &insn) {
+  auto *aarchFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto &andImm = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+  int64 tbzVal = GetLogValueAtBase2(andImm.GetValue());
+  if (tbzVal == -1) {
+    return;
+  }
+  MOperator mOp = insn.GetMachineOpcode();
+  MOperator newMop = MOP_undef;
+  switch (mOp) {
+    case MOP_wcbz:
+      newMop = MOP_wtbz;
+      break;
+    case MOP_wcbnz:
+      newMop = MOP_wtbnz;
+      break;
+    case MOP_xcbz:
+      newMop = MOP_xtbz;
+      break;
+    case MOP_xcbnz:
+      newMop = MOP_xtbnz;
+      break;
+    default:
+      CHECK_FATAL(false, "must be cbz/cbnz");
+      break;
+  }
+  auto &labelOpnd = static_cast<LabelOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  ImmOperand &tbzImm = aarchFunc->CreateImmOperand(tbzVal, k8BitSize, false);
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, prevInsn->GetOperand(kInsnSecondOpnd),
+                                                      tbzImm, labelOpnd);
+  bb.ReplaceInsn(insn, newInsn);
+  if (ssaInfo) {
+    /* update ssa info */
+    ssaInfo->ReplaceInsn(insn, newInsn);
+  }
+  optSuccess = true;
+  SetCurrInsn(&newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+bool CombineSameArithmeticPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (std::find(validMops.begin(), validMops.end(), curMop) == validMops.end()) {
+    return false;
+  }
+  Operand &useOpnd = insn.GetOperand(kInsnSecondOpnd);
+  CHECK_FATAL(useOpnd.IsRegister(), "expect regOpnd");
+  prevInsn = ssaInfo->GetDefInsn(static_cast<RegOperand&>(useOpnd));
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  if (prevInsn->GetMachineOpcode() != curMop) {
+    return false;
+  }
+  auto &prevDefOpnd = prevInsn->GetOperand(kInsnFirstOpnd);
+  CHECK_FATAL(prevDefOpnd.IsRegister(), "expect regOpnd");
+  InsnSet useInsns = GetAllUseInsn(static_cast<RegOperand&>(prevDefOpnd));
+  if (useInsns.size() > 1) {
+    return false;
+  }
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  CHECK_FATAL(prevInsn->GetOperand(kInsnThirdOpnd).IsIntImmediate(), "expect immOpnd");
+  CHECK_FATAL(insn.GetOperand(kInsnThirdOpnd).IsIntImmediate(), "expect immOpnd");
+  auto &prevImmOpnd = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+  auto &curImmOpnd = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  int64 prevImm = prevImmOpnd.GetValue();
+  int64 curImm = curImmOpnd.GetValue();
+  newImmOpnd = &aarFunc->CreateImmOperand(prevImmOpnd.GetValue() + curImmOpnd.GetValue(),
+                                          curImmOpnd.GetSize(), curImmOpnd.IsSignedValue());
+  switch (curMop) {
+    case MOP_wlsrrri5:
+    case MOP_wasrrri5:
+    case MOP_wlslrri5: {
+      if ((prevImm + curImm) < k0BitSizeInt || (prevImm + curImm) >= k32BitSizeInt) {
+        return false;
+      }
+      break;
+    }
+    case MOP_xlsrrri6:
+    case MOP_xasrrri6:
+    case MOP_xlslrri6: {
+      if ((prevImm + curImm) < k0BitSizeInt || (prevImm + curImm) >= k64BitSizeInt) {
+        return false;
+      }
+      break;
+    }
+    case MOP_waddrri12:
+    case MOP_xaddrri12:
+    case MOP_wsubrri12:
+    case MOP_xsubrri12: {
+      if (!newImmOpnd->IsSingleInstructionMovable()) {
+        return false;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  return true;
+}
+
+void CombineSameArithmeticPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(insn.GetMachineOpcode(),
+                                                      insn.GetOperand(kInsnFirstOpnd),
+                                                      prevInsn->GetOperand(kInsnSecondOpnd),
+                                                      *newImmOpnd);
+  bb.ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  optSuccess = true;
+  SetCurrInsn(&newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    (void)prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+bool LogicShiftAndOrrToExtrPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wiorrrr && curMop != MOP_xiorrrr && curMop != MOP_wiorrrrs && curMop != MOP_xiorrrrs) {
+    return false;
+  }
+  Operand &curDstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  is64Bits = (curDstOpnd.GetSize() == k64BitSize);
+  if (curMop == MOP_wiorrrr || curMop == MOP_xiorrrr) {
+    auto &useReg1 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+    Insn *prevInsn1 = ssaInfo->GetDefInsn(useReg1);
+    auto &useReg2 = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+    Insn *prevInsn2 = ssaInfo->GetDefInsn(useReg2);
+    if (prevInsn1 == nullptr || prevInsn2 == nullptr) {
+      return false;
+    }
+    MOperator prevMop1 = prevInsn1->GetMachineOpcode();
+    MOperator prevMop2 = prevInsn2->GetMachineOpcode();
+    if ((prevMop1 == MOP_wlsrrri5 || prevMop1 == MOP_xlsrrri6) &&
+        (prevMop2 == MOP_wlslrri5 || prevMop2 == MOP_xlslrri6)) {
+      prevLsrInsn = prevInsn1;
+      prevLslInsn = prevInsn2;
+    } else if ((prevMop2 == MOP_wlsrrri5 || prevMop2 == MOP_xlsrrri6) &&
+               (prevMop1 == MOP_wlslrri5 || prevMop1 == MOP_xlslrri6)) {
+      prevLsrInsn = prevInsn2;
+      prevLslInsn = prevInsn1;
+    } else {
+      return false;
+    }
+    int64 prevLsrImmValue = static_cast<ImmOperand&>(prevLsrInsn->GetOperand(kInsnThirdOpnd)).GetValue();
+    int64 prevLslImmValue = static_cast<ImmOperand&>(prevLslInsn->GetOperand(kInsnThirdOpnd)).GetValue();
+    if ((prevLsrImmValue + prevLslImmValue) < 0) {
+      return false;
+    }
+    if ((is64Bits && (prevLsrImmValue + prevLslImmValue) != k64BitSize) ||
+        (!is64Bits && (prevLsrImmValue + prevLslImmValue) != k32BitSize)) {
+      return false;
+    }
+    shiftValue = prevLsrImmValue;
+  } else if (curMop == MOP_wiorrrrs || curMop == MOP_xiorrrrs) {
+    auto &useReg = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+    Insn *prevInsn = ssaInfo->GetDefInsn(useReg);
+    if (prevInsn == nullptr) {
+      return false;
+    }
+    MOperator prevMop = prevInsn->GetMachineOpcode();
+    if (prevMop != MOP_wlsrrri5 && prevMop != MOP_xlsrrri6 && prevMop != MOP_wlslrri5 && prevMop != MOP_xlslrri6) {
+      return false;
+    }
+    int64 prevImm = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd)).GetValue();
+    auto &shiftOpnd = static_cast<BitShiftOperand&>(insn.GetOperand(kInsnFourthOpnd));
+    uint32 shiftAmount = shiftOpnd.GetShiftAmount();
+    if (shiftOpnd.GetShiftOp() == BitShiftOperand::kLSL && (prevMop == MOP_wlsrrri5 || prevMop == MOP_xlsrrri6)) {
+      prevLsrInsn = prevInsn;
+      shiftValue = prevImm;
+    } else if (shiftOpnd.GetShiftOp() == BitShiftOperand::kLSR &&
+               (prevMop == MOP_wlslrri5 || prevMop == MOP_xlslrri6)) {
+      prevLslInsn = prevInsn;
+      shiftValue = shiftAmount;
+    } else {
+      return false;
+    }
+    if (prevImm + static_cast<int64>(shiftAmount) < 0) {
+      return false;
+    }
+    if ((is64Bits && (prevImm + static_cast<int64>(shiftAmount)) != k64BitSize) ||
+        (!is64Bits && (prevImm + static_cast<int64>(shiftAmount)) != k32BitSize)) {
+      return false;
+    }
+  } else {
+    CHECK_FATAL(false, "must be above mop");
+    return false;
+  }
+  return true;
+}
+
+void LogicShiftAndOrrToExtrPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  Operand &opnd1 = (prevLslInsn == nullptr ? insn.GetOperand(kInsnThirdOpnd) :
+                    prevLslInsn->GetOperand(kInsnSecondOpnd));
+  Operand &opnd2 = (prevLsrInsn == nullptr ? insn.GetOperand(kInsnThirdOpnd) :
+                    prevLsrInsn->GetOperand(kInsnSecondOpnd));
+  ImmOperand &immOpnd = is64Bits ? aarFunc->CreateImmOperand(shiftValue, kMaxImmVal6Bits, false) :
+      aarFunc->CreateImmOperand(shiftValue, kMaxImmVal5Bits, false);
+  MOperator newMop = is64Bits ? MOP_xextrrrri6 : MOP_wextrrrri5;
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, insn.GetOperand(kInsnFirstOpnd), opnd1, opnd2, immOpnd);
+  bb.ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  optSuccess = true;
+  SetCurrInsn(&newInsn);
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevLsrInsn);
+    prevs.emplace_back(prevLslInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+void SimplifyMulArithmeticPattern::SetArithType(const Insn &currInsn) {
+  MOperator mOp = currInsn.GetMachineOpcode();
+  switch (mOp) {
+    case MOP_waddrrr:
+    case MOP_xaddrrr: {
+      arithType = kAdd;
+      isFloat = false;
+      break;
+    }
+    case MOP_dadd:
+    case MOP_sadd: {
+      arithType = kFAdd;
+      isFloat = true;
+      break;
+    }
+    case MOP_wsubrrr:
+    case MOP_xsubrrr: {
+      arithType = kSub;
+      isFloat = false;
+      validOpndIdx = kInsnThirdOpnd;
+      break;
+    }
+    case MOP_dsub:
+    case MOP_ssub: {
+      arithType = kFSub;
+      isFloat = true;
+      validOpndIdx = kInsnThirdOpnd;
+      break;
+    }
+    case MOP_xinegrr:
+    case MOP_winegrr: {
+      arithType = kNeg;
+      isFloat = false;
+      validOpndIdx = kInsnSecondOpnd;
+      break;
+    }
+    case MOP_wfnegrr:
+    case MOP_xfnegrr: {
+      arithType = kFNeg;
+      isFloat = true;
+      validOpndIdx = kInsnSecondOpnd;
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "must be above mop");
+      break;
+    }
+  }
+}
+
+bool SimplifyMulArithmeticPattern::CheckCondition(Insn &insn) {
+  if (arithType == kUndef || validOpndIdx < 0) {
+    return false;
+  }
+  auto &useReg = static_cast<RegOperand&>(insn.GetOperand(static_cast<uint32>(validOpndIdx)));
+  prevInsn = ssaInfo->GetDefInsn(useReg);
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  regno_t useRegNO = useReg.GetRegisterNumber();
+  VRegVersion *useVersion = ssaInfo->FindSSAVersion(useRegNO);
+  ASSERT(useVersion != nullptr, "useVersion should not be nullptr");
+  if (useVersion->GetAllUseInsns().size() > 1) {
+    return false;
+  }
+  MOperator currMop = insn.GetMachineOpcode();
+  if (currMop == MOP_dadd || currMop == MOP_sadd || currMop == MOP_dsub || currMop == MOP_ssub ||
+      currMop == MOP_wfnegrr || currMop == MOP_xfnegrr) {
+    isFloat = true;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  if (prevMop != MOP_wmulrrr && prevMop != MOP_xmulrrr && prevMop != MOP_xvmuld && prevMop != MOP_xvmuls) {
+    return false;
+  }
+  if (isFloat && (prevMop == MOP_wmulrrr || prevMop == MOP_xmulrrr)) {
+    return false;
+  }
+  if (!isFloat && (prevMop == MOP_xvmuld || prevMop == MOP_xvmuls)) {
+    return false;
+  }
+  if ((currMop == MOP_xaddrrr) || (currMop == MOP_waddrrr)) {
+    return true;
+  }
+  return CGOptions::IsFastMath();
+}
+
+void SimplifyMulArithmeticPattern::DoOptimize(BB &currBB, Insn &currInsn) {
+  Operand &resOpnd = currInsn.GetOperand(kInsnFirstOpnd);
+  Operand &opndMulOpnd1 = prevInsn->GetOperand(kInsnSecondOpnd);
+  Operand &opndMulOpnd2 = prevInsn->GetOperand(kInsnThirdOpnd);
+  bool is64Bits = (static_cast<RegOperand&>(resOpnd).GetSize() == k64BitSize);
+  /* may overflow */
+  if ((prevInsn->GetOperand(kInsnFirstOpnd).GetSize() == k32BitSize) && is64Bits) {
+    return;
+  }
+  MOperator newMop = is64Bits ? curMop2NewMopTable[arithType][1] : curMop2NewMopTable[arithType][0];
+  Insn *newInsn = nullptr;
+  if (arithType == kNeg || arithType == kFNeg) {
+    newInsn = &(cgFunc->GetInsnBuilder()->BuildInsn(newMop, resOpnd, opndMulOpnd1, opndMulOpnd2));
+  } else {
+    Operand &opnd3 = (validOpndIdx == kInsnSecondOpnd) ? currInsn.GetOperand(kInsnThirdOpnd) :
+        currInsn.GetOperand(kInsnSecondOpnd);
+    newInsn = &(cgFunc->GetInsnBuilder()->BuildInsn(newMop, resOpnd, opndMulOpnd1, opndMulOpnd2, opnd3));
+  }
+  CHECK_FATAL(newInsn != nullptr, "must create newInsn");
+  currBB.ReplaceInsn(currInsn, *newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(currInsn, *newInsn);
+  optSuccess = true;
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &currInsn, newInsn);
+  }
+}
+
+void SimplifyMulArithmeticPattern::Run(BB &bb, Insn &insn) {
+  SetArithType(insn);
+  if (arithType == kAdd || arithType == kFAdd) {
+    validOpndIdx = kInsnSecondOpnd;
+    if (CheckCondition(insn)) {
+      DoOptimize(bb, insn);
+      return;
+    } else {
+      validOpndIdx = kInsnThirdOpnd;
+    }
+  }
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  DoOptimize(bb, insn);
+}
+
+void ElimSpecificExtensionPattern::SetSpecificExtType(const Insn &currInsn) {
+  MOperator mOp = currInsn.GetMachineOpcode();
+  switch (mOp) {
+    case MOP_xsxtb32: {
+      is64Bits = false;
+      extTypeIdx = SXTB;
+      break;
+    }
+    case MOP_xsxtb64: {
+      is64Bits = true;
+      extTypeIdx = SXTB;
+      break;
+    }
+    case MOP_xsxth32: {
+      is64Bits = false;
+      extTypeIdx = SXTH;
+      break;
+    }
+    case MOP_xsxth64: {
+      is64Bits = true;
+      extTypeIdx = SXTH;
+      break;
+    }
+    case MOP_xsxtw64: {
+      is64Bits = true;
+      extTypeIdx = SXTW;
+      break;
+    }
+    case MOP_xuxtb32: {
+      is64Bits = false;
+      extTypeIdx = UXTB;
+      break;
+    }
+    case MOP_xuxth32: {
+      is64Bits = false;
+      extTypeIdx = UXTH;
+      break;
+    }
+    case MOP_xuxtw64: {
+      is64Bits = true;
+      extTypeIdx = UXTW;
+      break;
+    }
+    default: {
+      extTypeIdx = EXTUNDEF;
+    }
+  }
+}
+
+void ElimSpecificExtensionPattern::SetOptSceneType() {
+  if (prevInsn->IsCall()) {
+    sceneType = kSceneMov;
+    return;
+  }
+  MOperator preMop = prevInsn->GetMachineOpcode();
+  switch (preMop) {
+    case MOP_wldr:
+    case MOP_wldrb:
+    case MOP_wldrsb:
+    case MOP_wldrh:
+    case MOP_wldrsh:
+    case MOP_xldrsw: {
+      sceneType = kSceneLoad;
+      break;
+    }
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      sceneType = kSceneMov;
+      break;
+    }
+    case MOP_xsxtb32:
+    case MOP_xsxtb64:
+    case MOP_xsxth32:
+    case MOP_xsxth64:
+    case MOP_xsxtw64:
+    case MOP_xuxtb32:
+    case MOP_xuxth32:
+    case MOP_xuxtw64: {
+      sceneType = kSceneSameExt;
+      break;
+    }
+    default: {
+      sceneType = kSceneUndef;
+    }
+  }
+}
+
+void ElimSpecificExtensionPattern::ReplaceExtWithMov(Insn &currInsn) {
+  auto &prevDstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+  auto &currDstOpnd = static_cast<RegOperand&>(currInsn.GetOperand(kInsnFirstOpnd));
+  MOperator newMop = is64Bits ? MOP_xmovrr : MOP_wmovrr;
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, currDstOpnd, prevDstOpnd);
+  currBB->ReplaceInsn(currInsn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(currInsn, newInsn);
+  optSuccess = true;
+  /* dump pattern info */
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevInsn);
+    DumpAfterPattern(prevs, &currInsn, &newInsn);
+  }
+}
+
+void ElimSpecificExtensionPattern::ElimExtensionAfterMov(Insn &insn) {
+  if (&insn == currBB->GetFirstInsn()) {
+    return;
+  }
+  auto &prevDstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+  auto &currDstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &currSrcOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  if (prevDstOpnd.GetSize() != currDstOpnd.GetSize()) {
+    return;
+  }
+  MOperator currMop = insn.GetMachineOpcode();
+  /* example 2) [mov w0, R0] is return value of call and return size is not of range */
+  if (prevInsn->IsCall() && (currSrcOpnd.GetRegisterNumber() == R0 || currSrcOpnd.GetRegisterNumber() == V0) &&
+      currDstOpnd.GetRegisterNumber() == currSrcOpnd.GetRegisterNumber()) {
+    uint32 retSize = prevInsn->GetRetSize();
+    if (retSize > 0 &&
+        ((currMop == MOP_xuxtb32 && retSize <= k1ByteSize) ||
+         (currMop == MOP_xuxth32 && retSize <= k2ByteSize) ||
+         (currMop == MOP_xuxtw64 && retSize <= k4ByteSize))) {
+      ReplaceExtWithMov(insn);
+    }
+    return;
+  }
+  if (prevInsn->IsCall() && prevInsn->GetIsCallReturnSigned()) {
+    return;
+  }
+  auto &immMovOpnd = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+  int64 value = immMovOpnd.GetValue();
+  uint64 minRange = extValueRangeTable[extTypeIdx][0];
+  uint64 maxRange = extValueRangeTable[extTypeIdx][1];
+  if (currMop == MOP_xsxtb32 || currMop == MOP_xsxth32) {
+    /* value should be in valid range */
+    if (static_cast<uint64>(value) >= minRange && static_cast<uint64>(value) <= maxRange &&
+        immMovOpnd.IsSingleInstructionMovable(currDstOpnd.GetSize())) {
+      ReplaceExtWithMov(insn);
+    }
+  } else if (currMop == MOP_xuxtb32 || currMop == MOP_xuxth32) {
+    if ((static_cast<uint64>(value) & minRange) == 0) {
+      ReplaceExtWithMov(insn);
+    }
+  } else if (currMop == MOP_xuxtw64) {
+    ReplaceExtWithMov(insn);
+  } else {
+    /* MOP_xsxtb64 & MOP_xsxth64 & MOP_xsxtw64 */
+    if ((static_cast<uint64>(value) & minRange) == 0 && immMovOpnd.IsSingleInstructionMovable(currDstOpnd.GetSize())) {
+      ReplaceExtWithMov(insn);
+    }
+  }
+}
+
+bool ElimSpecificExtensionPattern::IsValidLoadExtPattern(MOperator oldMop, MOperator newMop) const {
+  if (oldMop == newMop) {
+    return true;
+  }
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  auto *memOpnd = static_cast<MemOperand*>(prevInsn->GetMemOpnd());
+  ASSERT(!prevInsn->IsStorePair(), "do not do ElimSpecificExtensionPattern for str pair");
+  ASSERT(!prevInsn->IsLoadPair(), "do not do ElimSpecificExtensionPattern for ldr pair");
+  if (memOpnd->GetAddrMode() == MemOperand::kAddrModeBOi &&
+      !aarFunc->IsOperandImmValid(newMop, memOpnd, kInsnSecondOpnd)) {
+    return false;
+  }
+  uint32 shiftAmount = memOpnd->ShiftAmount();
+  if (shiftAmount == 0) {
+    return true;
+  }
+  const InsnDesc *md = &AArch64CG::kMd[newMop];
+  uint32 memSize = md->GetOperandSize() / k8BitSize;
+  uint32 validShiftAmount = ((memSize == k8BitSize) ? k3BitSize : ((memSize == k4BitSize) ? k2BitSize :
+      ((memSize == k2BitSize) ? k1BitSize : k0BitSize)));
+  if (shiftAmount != validShiftAmount) {
+    return false;
+  }
+  return true;
+}
+
+MOperator ElimSpecificExtensionPattern::SelectNewLoadMopByBitSize(MOperator lowBitMop) const {
+  auto &prevDstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+  switch (lowBitMop) {
+    case MOP_wldrsb: {
+      prevDstOpnd.SetSize(k64BitSize);
+      return MOP_xldrsb;
+    }
+    case MOP_wldrsh: {
+      prevDstOpnd.SetSize(k64BitSize);
+      return MOP_xldrsh;
+    }
+    default:
+      break;
+  }
+  return lowBitMop;
+}
+
+void ElimSpecificExtensionPattern::ElimExtensionAfterLoad(Insn &insn) {
+  if (extTypeIdx == EXTUNDEF) {
+    return;
+  }
+  MOperator prevOrigMop = prevInsn->GetMachineOpcode();
+  for (uint8 i = 0; i < kPrevLoadPatternNum; i++) {
+    ASSERT(extTypeIdx < SETS, "extTypeIdx must be lower than SETS");
+    if (prevOrigMop != loadMappingTable[extTypeIdx][i][0]) {
+      continue;
+    }
+    MOperator prevNewMop = loadMappingTable[extTypeIdx][i][1];
+    if (!IsValidLoadExtPattern(prevOrigMop, prevNewMop)) {
+      return;
+    }
+    if (is64Bits && extTypeIdx >= SXTB && extTypeIdx <= SXTW) {
+      prevNewMop = SelectNewLoadMopByBitSize(prevNewMop);
+    }
+    auto &prevDstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+    auto &currDstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+    /* to avoid {mov [64], [32]} in the case of big endian */
+    if (prevDstOpnd.GetSize() != currDstOpnd.GetSize()) {
+      return;
+    }
+
+    auto *newMemOp =
+        GetOrCreateMemOperandForNewMOP(*cgFunc, *prevInsn, prevNewMop);
+
+    if (newMemOp == nullptr) {
+      return;
+    }
+
+    auto *aarCGSSAInfo = static_cast<AArch64CGSSAInfo*>(ssaInfo);
+    if (CG_PEEP_DUMP) {
+      LogInfo::MapleLogger() << ">>>>>>> In " << GetPatternName() << " : <<<<<<<\n";
+      if (prevOrigMop != prevNewMop) {
+        LogInfo::MapleLogger() << "======= OrigPrevInsn : \n";
+        prevInsn->Dump();
+        aarCGSSAInfo->DumpInsnInSSAForm(*prevInsn);
+      }
+    }
+
+    prevInsn->SetMemOpnd(newMemOp);
+    prevInsn->SetMOP(AArch64CG::kMd[prevNewMop]);
+
+    if ((prevOrigMop != prevNewMop) && CG_PEEP_DUMP) {
+      LogInfo::MapleLogger() << "======= NewPrevInsn : \n";
+      prevInsn->Dump();
+      aarCGSSAInfo->DumpInsnInSSAForm(*prevInsn);
+    }
+
+    MOperator movMop = is64Bits ? MOP_xmovrr : MOP_wmovrr;
+    Insn &newMovInsn = cgFunc->GetInsnBuilder()->BuildInsn(movMop, insn.GetOperand(kInsnFirstOpnd),
+                                                           prevInsn->GetOperand(kInsnFirstOpnd));
+    currBB->ReplaceInsn(insn, newMovInsn);
+    /* update ssa info */
+    ssaInfo->ReplaceInsn(insn, newMovInsn);
+    optSuccess = true;
+    /* dump pattern info */
+    if (CG_PEEP_DUMP) {
+      LogInfo::MapleLogger() << "======= ReplacedInsn :\n";
+      insn.Dump();
+      aarCGSSAInfo->DumpInsnInSSAForm(insn);
+      LogInfo::MapleLogger() << "======= NewInsn :\n";
+      newMovInsn.Dump();
+      aarCGSSAInfo->DumpInsnInSSAForm(newMovInsn);
+    }
+  }
+}
+
+void ElimSpecificExtensionPattern::ElimExtensionAfterSameExt(Insn &insn) {
+  if (extTypeIdx == EXTUNDEF) {
+    return;
+  }
+  auto &prevDstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+  auto &currDstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  if (prevDstOpnd.GetSize() != currDstOpnd.GetSize()) {
+    return;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  MOperator currMop = insn.GetMachineOpcode();
+  for (uint8 i = 0; i < kSameExtPatternNum; i++) {
+    ASSERT(extTypeIdx < SETS, "extTypeIdx must be lower than SETS");
+    if (sameExtMappingTable[extTypeIdx][i][0] == MOP_undef || sameExtMappingTable[extTypeIdx][i][1] == MOP_undef) {
+      continue;
+    }
+    if (prevMop == sameExtMappingTable[extTypeIdx][i][0] && currMop == sameExtMappingTable[extTypeIdx][i][1]) {
+      ReplaceExtWithMov(insn);
+    }
+  }
+}
+
+bool ElimSpecificExtensionPattern::CheckCondition(Insn &insn) {
+  auto &useReg = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  prevInsn = ssaInfo->GetDefInsn(useReg);
+  InsnSet useInsns = GetAllUseInsn(useReg);
+  if ((prevInsn == nullptr) || (useInsns.size() != 1)) {
+    return false;
+  }
+  SetOptSceneType();
+  SetSpecificExtType(insn);
+  if (sceneType == kSceneUndef) {
+    return false;
+  }
+  return true;
+}
+
+void ElimSpecificExtensionPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  if (sceneType == kSceneMov) {
+    ElimExtensionAfterMov(insn);
+  } else if (sceneType == kSceneLoad) {
+    ElimExtensionAfterLoad(insn);
+  } else if (sceneType == kSceneSameExt) {
+    ElimExtensionAfterSameExt(insn);
+  }
+}
+
+void OneHoleBranchPattern::FindNewMop(const BB &bb, const Insn &insn) {
+  if (&insn != bb.GetLastInsn()) {
+    return;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  switch (thisMop) {
+    case MOP_wcbz:
+      newOp = MOP_wtbnz;
+      break;
+    case MOP_wcbnz:
+      newOp = MOP_wtbz;
+      break;
+    case MOP_xcbz:
+      newOp = MOP_xtbnz;
+      break;
+    case MOP_xcbnz:
+      newOp = MOP_xtbz;
+      break;
+    default:
+      break;
+  }
+}
+
+/*
+ * pattern1:
+ *  uxtb w0, w1     <-----(ValidBitsNum <= 8)
+ *  cbz w0, .label
+ *  ===>
+ *  cbz w1, .label
+ *
+ * pattern2:
+ *  uxtb w2, w1     <-----(ValidBitsNum == 1)
+ *  eor w3, w2, #1
+ *  cbz w3, .label
+ *  ===>
+ *   tbnz w1, #0, .label
+ */
+void OneHoleBranchPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  LabelOperand &label = static_cast<LabelOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  bool pattern1 = (prevInsn->GetMachineOpcode() == MOP_xuxtb32) &&
+                  (static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd)).GetValidBitsNum() <= k8BitSize ||
+                   static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd)).GetValidBitsNum() <= k8BitSize);
+  if (pattern1) {
+    Insn &newCbzInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+        insn.GetMachineOpcode(), prevInsn->GetOperand(kInsnSecondOpnd), label);
+    bb.ReplaceInsn(insn, newCbzInsn);
+    ssaInfo->ReplaceInsn(insn, newCbzInsn);
+    optSuccess = true;
+    SetCurrInsn(&newCbzInsn);
+    if (CG_PEEP_DUMP) {
+      std::vector<Insn*> prevs;
+      prevs.emplace_back(prevInsn);
+      DumpAfterPattern(prevs, &newCbzInsn, nullptr);
+    }
+    return;
+  }
+  bool pattern2 = (prevInsn->GetMachineOpcode() == MOP_xeorrri13 || prevInsn->GetMachineOpcode() == MOP_weorrri12) &&
+                  (static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd)).GetValue() == 1);
+  if (pattern2) {
+    if (!CheckPrePrevInsn()) {
+      return;
+    }
+    AArch64CGFunc *aarch64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+    ImmOperand &oneHoleOpnd = aarch64CGFunc->CreateImmOperand(0, k8BitSize, false);
+    auto &regOperand = static_cast<RegOperand&>(prePrevInsn->GetOperand(kInsnSecondOpnd));
+    Insn &newTbzInsn = cgFunc->GetInsnBuilder()->BuildInsn(newOp, regOperand, oneHoleOpnd, label);
+    bb.ReplaceInsn(insn, newTbzInsn);
+    ssaInfo->ReplaceInsn(insn, newTbzInsn);
+    optSuccess = true;
+    if (CG_PEEP_DUMP) {
+      std::vector<Insn*> prevs;
+      prevs.emplace_back(prevInsn);
+      prevs.emplace_back(prePrevInsn);
+      DumpAfterPattern(prevs, &newTbzInsn, nullptr);
+    }
+  }
+}
+
+bool OneHoleBranchPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wcbz && curMop != MOP_xcbz && curMop != MOP_wcbnz && curMop != MOP_xcbnz) {
+    return false;
+  }
+  FindNewMop(*insn.GetBB(), insn);
+  if (newOp == MOP_undef) {
+    return false;
+  }
+  auto &useReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  prevInsn = ssaInfo->GetDefInsn(useReg);
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  if (&(prevInsn->GetOperand(kInsnFirstOpnd)) != &(insn.GetOperand(kInsnFirstOpnd))) {
+    return false;
+  }
+  return true;
+}
+
+bool OneHoleBranchPattern::CheckPrePrevInsn() {
+  auto &useReg = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+  prePrevInsn = ssaInfo->GetDefInsn(useReg);
+  if (prePrevInsn == nullptr) {
+    return false;
+  }
+  if (prePrevInsn->GetMachineOpcode() != MOP_xuxtb32 ||
+      static_cast<RegOperand&>(prePrevInsn->GetOperand(kInsnSecondOpnd)).GetValidBitsNum() != 1) {
+    return false;
+  }
+  if (&(prePrevInsn->GetOperand(kInsnFirstOpnd)) != &(prevInsn->GetOperand(kInsnSecondOpnd))) {
+    return false;
+  }
+  return true;
+}
+
+void OrrToMovPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  RegOperand *reg1 = &static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, *reg1, *reg2);
+  bb.ReplaceInsn(insn, newInsn);
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  optSuccess = true;
+  SetCurrInsn(&newInsn);
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(&insn);
+    DumpAfterPattern(prevs, &newInsn, nullptr);
+  }
+}
+
+bool OrrToMovPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wiorrri12 && curMop != MOP_xiorrri13) {
+    return false;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  Operand *opndOfOrr = nullptr;
+  switch (thisMop) {
+    case MOP_wiorrri12: {  /* opnd1 is reg32 and opnd3 is immediate. */
+      opndOfOrr = &(insn.GetOperand(kInsnThirdOpnd));
+      reg2 = &static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      newMop = MOP_wmovrr;
+      break;
+    }
+    case MOP_xiorrri13: {  /* opnd1 is reg64 and opnd3 is immediate. */
+      opndOfOrr = &(insn.GetOperand(kInsnThirdOpnd));
+      reg2 = &static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      newMop = MOP_xmovrr;
+      break;
+    }
+    default:
+      return false;
+  }
+  CHECK_FATAL(opndOfOrr->IsIntImmediate(), "expects immediate operand");
+  ImmOperand *immOpnd = static_cast<ImmOperand*>(opndOfOrr);
+  if (immOpnd->GetValue() != 0) {
+    return false;
+  }
+  return true;
+}
+
+void AArch64CGPeepHole::DoNormalOptimize(BB &bb, Insn &insn) {
+  MOperator thisMop = insn.GetMachineOpcode();
+  manager = peepMemPool->New<PeepOptimizeManager>(*cgFunc, bb, insn);
+  switch (thisMop) {
+    /*
+     * e.g.
+     * execute before & after RA: manager->NormalPatternOpt<>(true)
+     * execute before RA: manager->NormalPatternOpt<>(!cgFunc->IsAfterRegAlloc())
+     * execute after RA: manager->NormalPatternOpt<>(cgFunc->IsAfterRegAlloc())
+     */
+    case MOP_xubfxrri6i6: {
+      manager->NormalPatternOpt<UbfxToUxtwPattern>(!cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_xmovzri16: {
+      manager->NormalPatternOpt<LoadFloatPointPattern>(!cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_wcmpri: {
+      manager->NormalPatternOpt<LongIntCompareWithZPattern>(!cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_wcmprr: {
+      manager->NormalPatternOpt<LdrCmpPattern>(cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_wmovrr:
+    case MOP_xmovrr:
+    case MOP_xvmovs:
+    case MOP_xvmovd:
+    case MOP_vmovuu:
+    case MOP_vmovvv: {
+      manager->NormalPatternOpt<RemoveMovingtoSameRegPattern>(cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_wstrb:
+    case MOP_wldrb:
+    case MOP_wstrh:
+    case MOP_wldrh:
+    case MOP_xldr:
+    case MOP_xstr:
+    case MOP_wldr:
+    case MOP_wstr:
+    case MOP_dldr:
+    case MOP_dstr:
+    case MOP_sldr:
+    case MOP_sstr:
+    case MOP_qldr:
+    case MOP_qstr: {
+      manager->NormalPatternOpt<CombineContiLoadAndStorePattern>(cgFunc->IsAfterRegAlloc());
+      manager->NormalPatternOpt<ContiLDRorSTRToSameMEMPattern>(cgFunc->IsAfterRegAlloc());
+      manager->NormalPatternOpt<RemoveIdenticalLoadAndStorePattern>(cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_xvmovrv:
+    case MOP_xvmovrd: {
+      manager->NormalPatternOpt<FmovRegPattern>(cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_xsbfxrri6i6: {
+      manager->NormalPatternOpt<SbfxOptPattern>(cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_wcbz:
+    case MOP_xcbz:
+    case MOP_wcbnz:
+    case MOP_xcbnz: {
+      manager->NormalPatternOpt<AndCbzToTbzPattern>(!cgFunc->IsAfterRegAlloc());
+      manager->NormalPatternOpt<CbnzToCbzPattern>(cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_xsxtb32:
+    case MOP_xsxth32:
+    case MOP_xsxtb64:
+    case MOP_xsxth64:
+    case MOP_xsxtw64: {
+      manager->NormalPatternOpt<EliminateSpecifcSXTPattern>(cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_wsdivrrr: {
+      manager->NormalPatternOpt<ReplaceDivToMultiPattern>(cgFunc->IsAfterRegAlloc());
+      break;
+    }
+    case MOP_xbl: {
+      if (JAVALANG) {
+        manager->NormalPatternOpt<RemoveIncRefPattern>(!cgFunc->IsAfterRegAlloc());
+        manager->NormalPatternOpt<RemoveDecRefPattern>(!cgFunc->IsAfterRegAlloc());
+        manager->NormalPatternOpt<ReplaceIncDecWithIncPattern>(!cgFunc->IsAfterRegAlloc());
+        manager->NormalPatternOpt<RemoveIncDecRefPattern>(cgFunc->IsAfterRegAlloc());
+      }
+      if (CGOptions::IsGCOnly() && CGOptions::DoWriteRefFieldOpt()) {
+        manager->NormalPatternOpt<WriteFieldCallPattern>(!cgFunc->IsAfterRegAlloc());
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  /* skip if it is not a read barrier call. */
+  if (GetReadBarrierName(insn) != "") {
+    manager->NormalPatternOpt<InlineReadBarriersPattern>(!cgFunc->IsAfterRegAlloc());
+  }
+}
+/* ======== CGPeepPattern End ======== */
+
+void AArch64PeepHole::InitOpts() {
+  optimizations.resize(kPeepholeOptsNum);
+  optimizations[kEliminateSpecifcUXTOpt] = optOwnMemPool->New<EliminateSpecifcUXTAArch64>(cgFunc);
+  optimizations[kAndCmpBranchesToCsetOpt] = optOwnMemPool->New<AndCmpBranchesToCsetAArch64>(cgFunc);
+  optimizations[kAndCbzBranchesToTstOpt] = optOwnMemPool->New<AndCbzBranchesToTstAArch64>(cgFunc);
+}
+
+void AArch64PeepHole::Run(BB &bb, Insn &insn) {
+  MOperator thisMop = insn.GetMachineOpcode();
+  switch (thisMop) {
+    case MOP_xuxtb32:
+    case MOP_xuxth32:
+    case MOP_xuxtw64: {
+      (static_cast<EliminateSpecifcUXTAArch64*>(optimizations[kEliminateSpecifcUXTOpt]))->Run(bb, insn);
+      break;
+    }
+    case MOP_wcsetrc:
+    case MOP_xcsetrc: {
+      (static_cast<AndCmpBranchesToCsetAArch64*>(optimizations[kAndCmpBranchesToCsetOpt]))->Run(bb, insn);
+      break;
+    }
+    case MOP_xandrrr:
+    case MOP_wandrrr:
+    case MOP_wandrri12:
+    case MOP_xandrri13: {
+      (static_cast<AndCbzBranchesToTstAArch64*>(optimizations[kAndCbzBranchesToTstOpt]))->Run(bb, insn);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void AArch64PeepHole0::InitOpts() {
+  optimizations.resize(kPeepholeOptsNum);
+  optimizations[kDeleteMovAfterCbzOrCbnzOpt] = optOwnMemPool->New<DeleteMovAfterCbzOrCbnzAArch64>(cgFunc);
+  optimizations[kRemoveMovingtoSameRegOpt] = optOwnMemPool->New<RemoveMovingtoSameRegAArch64>(cgFunc);
+}
+
+void AArch64PeepHole0::Run(BB &bb, Insn &insn) {
+  MOperator thisMop = insn.GetMachineOpcode();
+  switch (thisMop) {
+    case MOP_wcbz:
+    case MOP_xcbz:
+    case MOP_wcbnz:
+    case MOP_xcbnz: {
+      (static_cast<DeleteMovAfterCbzOrCbnzAArch64*>(optimizations[kDeleteMovAfterCbzOrCbnzOpt]))->Run(bb, insn);
+      break;
+    }
+    case MOP_wmovrr:
+    case MOP_xmovrr:
+    case MOP_xvmovs:
+    case MOP_xvmovd:
+    case MOP_vmovuu:
+    case MOP_vmovvv: {
+      (static_cast<RemoveMovingtoSameRegAArch64*>(optimizations[kRemoveMovingtoSameRegOpt]))->Run(bb, insn);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void AArch64PrePeepHole::InitOpts() {
+  optimizations.resize(kPeepholeOptsNum);
+  optimizations[kReplaceCmpToCmnOpt] = optOwnMemPool->New<ReplaceCmpToCmnAArch64>(cgFunc);
+  optimizations[kComplexMemOperandOpt] = optOwnMemPool->New<ComplexMemOperandAArch64>(cgFunc);
+  optimizations[kComplexMemOperandPreOptAdd] = optOwnMemPool->New<ComplexMemOperandPreAddAArch64>(cgFunc);
+  optimizations[kEnhanceStrLdrAArch64Opt] = optOwnMemPool->New<EnhanceStrLdrAArch64>(cgFunc);
+}
+
+void AArch64PrePeepHole::Run(BB &bb, Insn &insn) {
+  MOperator thisMop = insn.GetMachineOpcode();
+  switch (thisMop) {
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      (static_cast<ReplaceCmpToCmnAArch64*>(optimizations[kReplaceCmpToCmnOpt]))->Run(bb, insn);
+      break;
+    }
+    case MOP_xadrpl12: {
+      (static_cast<ComplexMemOperandAArch64*>(optimizations[kComplexMemOperandOpt]))->Run(bb, insn);
+      break;
+    }
+    case MOP_xaddrrr: {
+      (static_cast<ComplexMemOperandPreAddAArch64*>(optimizations[kComplexMemOperandPreOptAdd]))->Run(bb, insn);
+      break;
+    }
+    case MOP_xldr:
+    case MOP_xstr:
+    case MOP_wldr:
+    case MOP_wstr:
+    case MOP_dldr:
+    case MOP_dstr:
+    case MOP_sldr:
+    case MOP_sstr: {
+      (static_cast<EnhanceStrLdrAArch64*>(optimizations[kEnhanceStrLdrAArch64Opt]))->Run(bb, insn);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void AArch64PrePeepHole1::InitOpts() {
+  optimizations.resize(kPeepholeOptsNum);
+  optimizations[kComplexExtendWordLslOpt] = optOwnMemPool->New<ComplexExtendWordLslAArch64>(cgFunc);
+}
+
+void AArch64PrePeepHole1::Run(BB &bb, Insn &insn) {
+  MOperator thisMop = insn.GetMachineOpcode();
+  switch (thisMop) {
+    case MOP_xsxtw64:
+    case MOP_xuxtw64: {
+      (static_cast<ComplexExtendWordLslAArch64*>(optimizations[kComplexExtendWordLslOpt]))->Run(bb, insn);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+bool RemoveIdenticalLoadAndStorePattern::CheckCondition(Insn &insn) {
+  nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr) {
+    return false;
+  }
+  return true;
+}
+
+void RemoveIdenticalLoadAndStorePattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator mop1 = insn.GetMachineOpcode();
+  MOperator mop2 = nextInsn->GetMachineOpcode();
+  if ((mop1 == MOP_wstr && mop2 == MOP_wstr) || (mop1 == MOP_xstr && mop2 == MOP_xstr)) {
+    if (IsMemOperandsIdentical(insn, *nextInsn)) {
+      bb.RemoveInsn(insn);
+    }
+  } else if ((mop1 == MOP_wstr && mop2 == MOP_wldr) || (mop1 == MOP_xstr && mop2 == MOP_xldr)) {
+    if (IsMemOperandsIdentical(insn, *nextInsn)) {
+      bb.RemoveInsn(*nextInsn);
+    }
+  }
+}
+
+bool RemoveIdenticalLoadAndStorePattern::IsMemOperandsIdentical(const Insn &insn1, const Insn &insn2) const {
+  regno_t regNO1 = static_cast<RegOperand&>(insn1.GetOperand(kInsnFirstOpnd)).GetRegisterNumber();
+  regno_t regNO2 = static_cast<RegOperand&>(insn2.GetOperand(kInsnFirstOpnd)).GetRegisterNumber();
+  if (regNO1 != regNO2) {
+    return false;
+  }
+  /* Match only [base + offset] */
+  auto &memOpnd1 = static_cast<MemOperand&>(insn1.GetOperand(kInsnSecondOpnd));
+  if (memOpnd1.GetAddrMode() != MemOperand::kAddrModeBOi || !memOpnd1.IsIntactIndexed()) {
+    return false;
+  }
+  auto &memOpnd2 = static_cast<MemOperand&>(insn2.GetOperand(kInsnSecondOpnd));
+  if (memOpnd2.GetAddrMode() != MemOperand::kAddrModeBOi || !memOpnd1.IsIntactIndexed()) {
+    return false;
+  }
+  Operand *base1 = memOpnd1.GetBaseRegister();
+  Operand *base2 = memOpnd2.GetBaseRegister();
+  if (!((base1 != nullptr) && base1->IsRegister()) || !((base2 != nullptr) && base2->IsRegister())) {
+    return false;
+  }
+
+  regno_t baseRegNO1 = static_cast<RegOperand*>(base1)->GetRegisterNumber();
+  /* First insn re-write base addr   reg1 <- [ reg1 + offset ] */
+  if (baseRegNO1 == regNO1) {
+    return false;
+  }
+
+  regno_t baseRegNO2 = static_cast<RegOperand*>(base2)->GetRegisterNumber();
+  if (baseRegNO1 != baseRegNO2) {
+    return false;
+  }
+
+  return memOpnd1.GetOffsetImmediate()->GetOffsetValue() == memOpnd2.GetOffsetImmediate()->GetOffsetValue();
+}
+
+bool RemoveMovingtoSameRegPattern::CheckCondition(Insn &insn) {
+  ASSERT(insn.GetOperand(kInsnFirstOpnd).IsRegister(), "expects registers");
+  ASSERT(insn.GetOperand(kInsnSecondOpnd).IsRegister(), "expects registers");
+  auto &reg1 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &reg2 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  /* remove mov x0,x0 when it cast i32 to i64 */
+  if ((reg1.GetRegisterNumber() == reg2.GetRegisterNumber()) && (reg1.GetSize() >= reg2.GetSize())) {
+    return true;
+  }
+  return false;
+}
+
+void RemoveMovingtoSameRegPattern::Run(BB &bb, Insn &insn) {
+  /* remove mov x0,x0 when it cast i32 to i64 */
+  if (CheckCondition(insn)) {
+    bb.RemoveInsn(insn);
+  }
+}
+
+void RemoveMovingtoSameRegAArch64::Run(BB &bb, Insn &insn) {
+  ASSERT(insn.GetOperand(kInsnFirstOpnd).IsRegister(), "expects registers");
+  ASSERT(insn.GetOperand(kInsnSecondOpnd).IsRegister(), "expects registers");
+  auto &reg1 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &reg2 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  /* remove mov x0,x0 when it cast i32 to i64 */
+  if ((reg1.GetRegisterNumber() == reg2.GetRegisterNumber()) && (reg1.GetSize() >= reg2.GetSize())) {
+    bb.RemoveInsn(insn);
+  }
+}
+
+void EnhanceStrLdrAArch64::Run(BB &bb, Insn &insn) {
+  Insn *prevInsn = insn.GetPrev();
+  if (!cgFunc.GetMirModule().IsCModule()) {
+    return;
+  }
+
+  if (prevInsn == nullptr) {
+    return;
+  }
+  Operand &memOpnd = insn.GetOperand(kInsnSecondOpnd);
+  CHECK_FATAL(memOpnd.GetKind() == Operand::kOpdMem, "Unexpected operand in EnhanceStrLdrAArch64");
+  auto &a64MemOpnd = static_cast<MemOperand&>(memOpnd);
+  RegOperand *baseOpnd = a64MemOpnd.GetBaseRegister();
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  if (IsEnhanceAddImm(prevMop) && a64MemOpnd.GetAddrMode() == MemOperand::kAddrModeBOi &&
+      a64MemOpnd.GetOffsetImmediate()->GetValue() == 0) {
+    auto &addDestOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+    if (baseOpnd == &addDestOpnd && !IfOperandIsLiveAfterInsn(addDestOpnd, insn)) {
+      auto &concreteMemOpnd = static_cast<MemOperand&>(memOpnd);
+      auto *origBaseReg = concreteMemOpnd.GetBaseRegister();
+      concreteMemOpnd.SetBaseRegister(
+          static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd)));
+      auto &ofstOpnd = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+      OfstOperand &offOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateOfstOpnd(
+          static_cast<uint64>(ofstOpnd.GetValue()), k32BitSize);
+      offOpnd.SetVary(ofstOpnd.GetVary());
+      auto *origOffOpnd = concreteMemOpnd.GetOffsetImmediate();
+      concreteMemOpnd.SetOffsetOperand(offOpnd);
+      if (!static_cast<AArch64CGFunc&>(cgFunc).IsOperandImmValid(insn.GetMachineOpcode(), &memOpnd, kInsnSecondOpnd)) {
+        // If new offset is invalid, undo it
+        concreteMemOpnd.SetBaseRegister(*static_cast<RegOperand*>(origBaseReg));
+        concreteMemOpnd.SetOffsetOperand(*origOffOpnd);
+        return;
+      }
+      bb.RemoveInsn(*prevInsn);
+    }
+  }
+}
+
+bool EnhanceStrLdrAArch64::IsEnhanceAddImm(MOperator prevMop) const {
+  return prevMop == MOP_xaddrri12 ||  prevMop == MOP_waddrri12;
+}
+
+bool IsSameRegisterOperation(const RegOperand &desMovOpnd,
+                             const RegOperand &uxtDestOpnd,
+                             const RegOperand &uxtFromOpnd) {
+  return ((desMovOpnd.GetRegisterNumber() == uxtDestOpnd.GetRegisterNumber()) &&
+          (uxtDestOpnd.GetRegisterNumber() == uxtFromOpnd.GetRegisterNumber()));
+}
+
+bool CombineContiLoadAndStorePattern::IsRegNotSameMemUseInInsn(const Insn &insn, regno_t regNO, bool isStore,
+                                                               int64 baseOfst) const {
+  uint32 opndNum = insn.GetOperandSize();
+  bool sameMemAccess = false; /* both store or load */
+  if (insn.IsStore() == isStore) {
+    sameMemAccess = true;
+  }
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsList()) {
+      auto &listOpnd = static_cast<const ListOperand&>(opnd);
+      for (auto &listElem : listOpnd.GetOperands()) {
+        RegOperand *regOpnd = static_cast<RegOperand*>(listElem);
+        ASSERT(regOpnd != nullptr, "parameter operand must be RegOperand");
+        if (regNO == regOpnd->GetRegisterNumber()) {
+          return true;
+        }
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOperand = static_cast<MemOperand&>(opnd);
+      RegOperand *base = memOperand.GetBaseRegister();
+      /* need check offset as well */
+      regno_t stackBaseRegNO = cgFunc->UseFP() ? R29 : RSP;
+      if (!sameMemAccess && base != nullptr) {
+        regno_t curBaseRegNO = base->GetRegisterNumber();
+        int64 memBarrierRange = static_cast<int64>(insn.IsLoadStorePair() ? k16BitSize : k8BitSize);
+        if (!(curBaseRegNO == regNO && memOperand.GetAddrMode() == MemOperand::kAddrModeBOi &&
+            memOperand.GetOffsetImmediate() != nullptr &&
+            (memOperand.GetOffsetImmediate()->GetOffsetValue() <= (baseOfst - memBarrierRange) ||
+            memOperand.GetOffsetImmediate()->GetOffsetValue() >= (baseOfst + memBarrierRange)))) {
+          return true;
+        }
+      }
+      /* do not trust the following situation :
+       * str x1, [x9]
+       * str x6, [x2]
+       * str x3, [x9, #8]
+       */
+      if (isStore && regNO != stackBaseRegNO && base != nullptr &&
+          base->GetRegisterNumber() != stackBaseRegNO && base->GetRegisterNumber() != regNO) {
+        return true;
+      }
+      if (isStore && base != nullptr && base->GetRegisterNumber() == regNO) {
+        if (memOperand.GetAddrMode() == MemOperand::kAddrModeBOi && memOperand.GetOffsetImmediate() != nullptr) {
+          int64 curOffset = memOperand.GetOffsetImmediate()->GetOffsetValue();
+          if (memOperand.GetSize() == k64BitSize) {
+            uint32 memBarrierRange = insn.IsLoadStorePair() ? k16BitSize : k8BitSize;
+            if (curOffset < baseOfst + memBarrierRange && curOffset > baseOfst - static_cast<int32>(memBarrierRange)) {
+              return true;
+            }
+          } else if (memOperand.GetSize() == k32BitSize) {
+            uint32 memBarrierRange = insn.IsLoadStorePair() ? k8BitSize : k4BitSize;
+            if (curOffset < baseOfst + memBarrierRange && curOffset > baseOfst - memBarrierRange) {
+              return true;
+            }
+          }
+        }
+      }
+    } else if (opnd.IsConditionCode()) {
+      Operand &rflagOpnd = cgFunc->GetOrCreateRflag();
+      RegOperand &rflagReg = static_cast<RegOperand&>(rflagOpnd);
+      if (rflagReg.GetRegisterNumber() == regNO) {
+        return true;
+      }
+    } else if (opnd.IsRegister()) {
+      if (!isStore && static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+std::vector<Insn*> CombineContiLoadAndStorePattern::FindPrevStrLdr(Insn &insn, regno_t destRegNO,
+                                                                   regno_t memBaseRegNO, int64 baseOfst) const {
+  std::vector<Insn*> prevContiInsns;
+  bool isStr = insn.IsStore();
+  for (Insn *curInsn = insn.GetPrev(); curInsn != nullptr; curInsn = curInsn->GetPrev()) {
+    if (!curInsn->IsMachineInstruction()) {
+      continue;
+    }
+    if (curInsn->IsRegDefined(memBaseRegNO)) {
+      return prevContiInsns;
+    }
+    if (IsRegNotSameMemUseInInsn(*curInsn, memBaseRegNO, insn.IsStore(), static_cast<int32>(baseOfst))) {
+      return prevContiInsns;
+    }
+    /* return continuous STD/LDR insn */
+    if (((isStr && curInsn->IsStore()) || (!isStr && curInsn->IsLoad())) && !curInsn->IsLoadStorePair()) {
+      auto *memOperand = static_cast<MemOperand*>(curInsn->GetMemOpnd());
+      /* do not combine ldr r0, label */
+      if (memOperand != nullptr) {
+        auto *baseRegOpnd = static_cast<RegOperand*>(memOperand->GetBaseRegister());
+        ASSERT(baseRegOpnd == nullptr || !baseRegOpnd->IsVirtualRegister(),
+            "physical register has not been allocated?");
+        if (memOperand->GetAddrMode() == MemOperand::kAddrModeBOi &&
+            baseRegOpnd->GetRegisterNumber() == memBaseRegNO) {
+          prevContiInsns.emplace_back(curInsn);
+        }
+      }
+    }
+    /* check insn that changes the data flow */
+    regno_t stackBaseRegNO = cgFunc->UseFP() ? R29 : RSP;
+    /* ldr x8, [x21, #8]
+     * call foo()
+     * ldr x9, [x21, #16]
+     * although x21 is a calleeSave register, there is no guarantee data in memory [x21] is not changed
+     */
+    if (curInsn->IsCall() && (!AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(destRegNO)) ||
+        memBaseRegNO != stackBaseRegNO)) {
+      return prevContiInsns;
+    }
+    /* store opt should not cross call due to stack args */
+    if (curInsn->IsCall() && isStr) {
+      return prevContiInsns;
+    }
+    if (curInsn->GetMachineOpcode() == MOP_asm) {
+      return prevContiInsns;
+    }
+    if (curInsn->ScanReg(destRegNO)) {
+      return prevContiInsns;
+    }
+  }
+  return prevContiInsns;
+}
+
+Insn *CombineContiLoadAndStorePattern::FindValidSplitAddInsn(Insn &combineInsn, const RegOperand &baseOpnd) const {
+  Insn *splitAdd = nullptr;
+  for (Insn *cursor = combineInsn.GetPrev(); cursor != nullptr; cursor = cursor->GetPrev()) {
+    if (!cursor->IsMachineInstruction()) {
+      continue;
+    }
+    if (cursor->IsCall()) {
+      break;
+    }
+    if (cursor->IsRegDefined(baseOpnd.GetRegisterNumber())) {
+      break;
+    }
+    MOperator mOp = cursor->GetMachineOpcode();
+    if (mOp != MOP_xaddrri12 && mOp != MOP_waddrri12) {
+      continue;
+    }
+    auto &destOpnd = static_cast<RegOperand&>(cursor->GetOperand(kInsnFirstOpnd));
+    if (destOpnd.GetRegisterNumber() != R16 || destOpnd.GetSize() != baseOpnd.GetSize()) {
+      continue;
+    }
+    auto &useOpnd = static_cast<RegOperand&>(cursor->GetOperand(kInsnSecondOpnd));
+    /*
+     * split add as following:
+     * add R16, R0, #2, LSL #12
+     * add R16, R16, #1536
+     */
+    if (useOpnd.GetRegisterNumber() != baseOpnd.GetRegisterNumber()) {
+      if (useOpnd.GetRegisterNumber() == R16) {
+        Insn *defInsn = cursor->GetPrev();
+        CHECK_FATAL(defInsn != nullptr, "invalid defInsn");
+        CHECK_FATAL(defInsn->GetMachineOpcode() == MOP_xaddrri24 || defInsn->GetMachineOpcode() == MOP_waddrri24,
+                    "split with wrong add");
+        auto &opnd = static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd));
+        if (opnd.GetRegisterNumber() == baseOpnd.GetRegisterNumber()) {
+          splitAdd = cursor;
+        }
+      }
+      break;
+    } else {
+      splitAdd = cursor;
+      break;
+    }
+  }
+  return splitAdd;
+}
+
+bool CombineContiLoadAndStorePattern::FindTmpRegOnlyUseAfterCombineInsn(const Insn &curInsn) const {
+  /*
+   * avoid the case as following:
+   *   add R16, R20, #28672
+   *   stp R1, R2, [R16, #408]
+   *   ldr R1, [R0, #14032]         add R16, R0, #3, LSL #12
+   *                      ====>     add R16, R16, #1536     (this r16 will clobber use of ldp R2, R3)
+   *                                ldp R1, R0, [R16, #208]
+   *   ldp R2, R3, [R16, #424]
+   *   ldr R0, [R0, #14036]
+   */
+  for (Insn *cursor = curInsn.GetNext(); cursor != nullptr; cursor = cursor->GetNext()) {
+    if (!cursor->IsMachineInstruction()) {
+      continue;
+    }
+    MOperator mOp = cursor->GetMachineOpcode();
+    if (mOp == MOP_xaddrri12 || mOp == MOP_waddrri12 || mOp == MOP_xaddrri24 || mOp == MOP_waddrri24) {
+      auto &destOpnd = static_cast<RegOperand&>(cursor->GetOperand(kInsnFirstOpnd));
+      if (destOpnd.GetRegisterNumber() == R16) {
+        return false;
+      }
+    }
+    if (!cursor->IsLoad() && !cursor->IsStore() && !cursor->IsLoadStorePair()) {
+      continue;
+    }
+    const InsnDesc *md = &AArch64CG::kMd[cursor->GetMachineOpcode()];
+    if (cursor->IsLoadLabel() || md->IsLoadAddress()) {
+      continue;
+    }
+    uint32 memIdx = (cursor->IsLoadStorePair() ? kInsnThirdOpnd : kInsnSecondOpnd);
+    auto &curMemOpnd = static_cast<MemOperand&>(cursor->GetOperand(memIdx));
+    RegOperand *baseOpnd = curMemOpnd.GetBaseRegister();
+    if (baseOpnd != nullptr && baseOpnd->GetRegisterNumber() == R16) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool CombineContiLoadAndStorePattern::PlaceSplitAddInsn(const Insn &curInsn, Insn &combineInsn,
+                                                        const MemOperand &memOperand,
+                                                        RegOperand &baseOpnd, uint32 bitLen) const {
+  Insn *cursor = nullptr;
+  MemOperand *maxOfstMem = nullptr;
+  int64 maxOfstVal = 0;
+  MOperator mop = curInsn.GetMachineOpcode();
+  OfstOperand *ofstOpnd = memOperand.GetOffsetImmediate();
+  int64 ofstVal = ofstOpnd->GetOffsetValue();
+  auto &aarFunc = static_cast<AArch64CGFunc&>(*cgFunc);
+  for (cursor = curInsn.GetNext(); cursor != nullptr; cursor = cursor->GetNext()) {
+    if (!cursor->IsMachineInstruction()) {
+      continue;
+    }
+    if (cursor->GetMachineOpcode() == mop && (cursor->IsLoad() || cursor->IsStore())) {
+      auto &curMemOpnd = static_cast<MemOperand&>(cursor->GetOperand(kInsnSecondOpnd));
+      RegOperand *curBaseOpnd = curMemOpnd.GetBaseRegister();
+      if (curMemOpnd.GetAddrMode() == MemOperand::kAddrModeBOi && RegOperand::IsSameReg(baseOpnd, *curBaseOpnd)) {
+        OfstOperand *curOfstOpnd = curMemOpnd.GetOffsetImmediate();
+        CHECK_FATAL(curOfstOpnd != nullptr, "invalid OfstOperand");
+        if (curOfstOpnd->GetOffsetValue() > ofstVal &&
+            (curOfstOpnd->GetOffsetValue() - ofstVal) < MemOperand::GetMaxPairPIMM(bitLen) &&
+            !aarFunc.IsOperandImmValid(combineInsn.GetMachineOpcode(), &curMemOpnd, kInsnThirdOpnd)) {
+          maxOfstMem = &curMemOpnd;
+          maxOfstVal = curOfstOpnd->GetOffsetValue();
+        }
+      }
+    }
+    if (cursor->IsRegDefined(baseOpnd.GetRegisterNumber())) {
+      break;
+    }
+    if (cursor->IsRegDefined(R16)) {
+      break;
+    }
+  }
+  MemOperand *newMemOpnd = nullptr;
+  if (maxOfstMem == nullptr) {
+    newMemOpnd = &aarFunc.SplitOffsetWithAddInstruction(memOperand, bitLen, static_cast<AArch64reg>(R16),
+                                                        false, &combineInsn, true);
+  } else {
+    RegOperand *addResOpnd = aarFunc.GetBaseRegForSplit(R16);
+    ImmOperand &immAddend = aarFunc.SplitAndGetRemained(*maxOfstMem, bitLen, maxOfstVal, true);
+    newMemOpnd = &aarFunc.CreateReplacementMemOperand(bitLen, *addResOpnd, ofstVal - immAddend.GetValue());
+    if (!(aarFunc.IsOperandImmValid(combineInsn.GetMachineOpcode(), newMemOpnd, kInsnThirdOpnd))) {
+      newMemOpnd = &aarFunc.SplitOffsetWithAddInstruction(memOperand, bitLen, static_cast<AArch64reg>(R16),
+                                                          false, &combineInsn, true);
+    } else {
+      aarFunc.SelectAddAfterInsn(*addResOpnd, baseOpnd, immAddend, PTY_i64, false, combineInsn);
+    }
+  }
+  if (!(aarFunc.IsOperandImmValid(combineInsn.GetMachineOpcode(), newMemOpnd, kInsnThirdOpnd))) {
+    return false;
+  }
+  combineInsn.SetOperand(kInsnThirdOpnd, *newMemOpnd);
+  return true;
+}
+
+bool CombineContiLoadAndStorePattern::SplitOfstWithAddToCombine(const Insn &curInsn, Insn &combineInsn,
+                                                                const MemOperand &memOperand) const {
+  auto *baseRegOpnd = static_cast<RegOperand*>(memOperand.GetBaseRegister());
+  auto *ofstOpnd = static_cast<OfstOperand*>(memOperand.GetOffsetImmediate());
+  ASSERT(baseRegOpnd && ofstOpnd, "get baseOpnd and ofstOpnd failed");
+  CHECK_FATAL(combineInsn.GetOperand(kInsnFirstOpnd).GetSize() == combineInsn.GetOperand(kInsnSecondOpnd).GetSize(),
+              "the size must equal");
+  if (baseRegOpnd->GetRegisterNumber() == R16) {
+    return false;
+  }
+  Insn *splitAdd = FindValidSplitAddInsn(combineInsn, *baseRegOpnd);
+  const InsnDesc *md = &AArch64CG::kMd[combineInsn.GetMachineOpcode()];
+  auto *opndProp = md->opndMD[kInsnFirstOpnd];
+  auto &aarFunc = static_cast<AArch64CGFunc&>(*cgFunc);
+  if (splitAdd == nullptr) {
+    if (combineInsn.IsLoadStorePair() && ofstOpnd->GetOffsetValue() < 0) {
+      return false; /* do not split */
+    }
+    if (FindTmpRegOnlyUseAfterCombineInsn(combineInsn)) {
+      return false;
+    }
+    /* create and place addInsn */
+    return PlaceSplitAddInsn(curInsn, combineInsn, memOperand, *baseRegOpnd, opndProp->GetSize());
+  } else {
+    auto &newBaseReg = static_cast<RegOperand&>(splitAdd->GetOperand(kInsnFirstOpnd));
+    auto &addImmOpnd = static_cast<ImmOperand&>(splitAdd->GetOperand(kInsnThirdOpnd));
+    int64 addVal = 0;
+    if (static_cast<RegOperand&>(splitAdd->GetOperand(kInsnSecondOpnd)).GetRegisterNumber() == R16) {
+      Insn *defInsn = splitAdd->GetPrev();
+      CHECK_FATAL(defInsn->GetMachineOpcode() == MOP_xaddrri24 || defInsn->GetMachineOpcode() == MOP_waddrri24,
+                  "split with wrong add");
+      auto &immOpnd = static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+      auto &shiftOpnd = static_cast<BitShiftOperand&>(defInsn->GetOperand(kInsnFourthOpnd));
+      addVal = static_cast<int64>((static_cast<uint64>(immOpnd.GetValue()) << shiftOpnd.GetShiftAmount())) +
+          addImmOpnd.GetValue();
+    } else {
+      addVal = addImmOpnd.GetValue();
+    }
+    auto *newOfstOpnd = &aarFunc.CreateOfstOpnd(static_cast<uint64>(ofstOpnd->GetOffsetValue() - addVal),
+        ofstOpnd->GetSize());
+    auto *newMemOpnd = aarFunc.CreateMemOperand(MemOperand::kAddrModeBOi, opndProp->GetSize(),
+        newBaseReg, nullptr, newOfstOpnd, memOperand.GetSymbol());
+    if (!(static_cast<AArch64CGFunc&>(*cgFunc).IsOperandImmValid(combineInsn.GetMachineOpcode(), newMemOpnd,
+                                                                 kInsnThirdOpnd))) {
+      return PlaceSplitAddInsn(curInsn, combineInsn, memOperand, *baseRegOpnd, opndProp->GetSize());
+    }
+    combineInsn.SetOperand(kInsnThirdOpnd, *newMemOpnd);
+    return true;
+  }
+}
+
+bool CombineContiLoadAndStorePattern::CheckCondition(Insn &insn) {
+  memOpnd = static_cast<MemOperand*>(insn.GetMemOpnd());
+  ASSERT(memOpnd != nullptr, "get mem operand failed");
+  if (memOpnd->GetAddrMode() != MemOperand::kAddrModeBOi) {
+    return false;
+  }
+  if (!doAggressiveCombine) {
+    return false;
+  }
+  return true;
+}
+
+/* Combining 2 STRs into 1 stp or 2 LDRs into 1 ldp */
+void CombineContiLoadAndStorePattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  ASSERT(insn.GetOperand(kInsnFirstOpnd).IsRegister(), "unexpect operand");
+  auto &destOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto *baseRegOpnd = static_cast<RegOperand*>(memOpnd->GetBaseRegister());
+  OfstOperand *offsetOpnd = memOpnd->GetOffsetImmediate();
+  CHECK_FATAL(offsetOpnd != nullptr, "offset opnd lost");
+  ASSERT(baseRegOpnd == nullptr || !baseRegOpnd->IsVirtualRegister(), "physical register has not been allocated?");
+  std::vector<Insn*> prevContiInsnVec = FindPrevStrLdr(
+      insn, destOpnd.GetRegisterNumber(), baseRegOpnd->GetRegisterNumber(), offsetOpnd->GetOffsetValue());
+  for (auto prevContiInsn : prevContiInsnVec) {
+    ASSERT(prevContiInsn != nullptr, "get previous consecutive instructions failed");
+    auto *prevMemOpnd = static_cast<MemOperand*>(prevContiInsn->GetMemOpnd());
+    if (memOpnd->GetIndexOpt() != prevMemOpnd->GetIndexOpt()) {
+      continue;
+    }
+    OfstOperand *prevOffsetOpnd = prevMemOpnd->GetOffsetImmediate();
+    CHECK_FATAL(offsetOpnd != nullptr && prevOffsetOpnd != nullptr, "both conti str/ldr have no offset");
+    auto &prevDestOpnd = static_cast<RegOperand&>(prevContiInsn->GetOperand(kInsnFirstOpnd));
+    uint32 memSize = insn.GetMemoryByteSize();
+    uint32 prevMemSize = prevContiInsn->GetMemoryByteSize();
+    if (prevDestOpnd.GetRegisterType() != destOpnd.GetRegisterType()) {
+      continue;
+    }
+    int64 offsetVal = offsetOpnd->GetOffsetValue();
+    int64 prevOffsetVal = prevOffsetOpnd->GetOffsetValue();
+    auto diffVal = std::abs(offsetVal - prevOffsetVal);
+    regno_t destRegNO = destOpnd.GetRegisterNumber();
+    regno_t prevDestRegNO = prevDestOpnd.GetRegisterNumber();
+    if (insn.IsStore() && memOpnd->IsStackArgMem() && prevMemOpnd->IsStackArgMem() &&
+        (memSize == k4ByteSize || memSize == k8ByteSize) && diffVal == k8BitSize &&
+        (prevMemSize == k4ByteSize || prevMemSize == k8ByteSize) &&
+        (destOpnd.GetValidBitsNum() == memSize * k8BitSize) &&
+        (prevDestOpnd.GetValidBitsNum() == prevMemSize * k8BitSize)) {
+      RegOperand &newDest = static_cast<AArch64CGFunc*>(cgFunc)->GetOrCreatePhysicalRegisterOperand(
+          static_cast<AArch64reg>(destRegNO), k64BitSize, destOpnd.GetRegisterType());
+      RegOperand &newPrevDest = static_cast<AArch64CGFunc*>(cgFunc)->GetOrCreatePhysicalRegisterOperand(
+          static_cast<AArch64reg>(prevDestRegNO), k64BitSize, prevDestOpnd.GetRegisterType());
+      MemOperand *combineMemOpnd = (offsetVal < prevOffsetVal) ? memOpnd : prevMemOpnd;
+      MOperator mopPair = (destOpnd.GetRegisterType() == kRegTyInt) ? MOP_xstp : MOP_dstp;
+      if ((static_cast<AArch64CGFunc&>(*cgFunc).IsOperandImmValid(mopPair, combineMemOpnd, kInsnThirdOpnd))) {
+        Insn &combineInsn = (offsetVal < prevOffsetVal) ?
+                            cgFunc->GetInsnBuilder()->BuildInsn(mopPair, newDest, newPrevDest, *combineMemOpnd):
+                            cgFunc->GetInsnBuilder()->BuildInsn(mopPair, newPrevDest, newDest, *combineMemOpnd);
+        bb.InsertInsnAfter(*prevContiInsn, combineInsn);
+        RemoveInsnAndKeepComment(bb, insn, *prevContiInsn);
+        return;
+      }
+    }
+    if (memSize != prevMemSize  ||
+        thisMop != prevContiInsn->GetMachineOpcode() || prevDestOpnd.GetSize() != destOpnd.GetSize()) {
+      continue;
+    }
+    /* do combination str/ldr -> stp/ldp */
+    if ((insn.IsStore() || destRegNO != prevDestRegNO) || (destRegNO == RZR && prevDestRegNO == RZR)) {
+      if ((memSize == k8ByteSize && diffVal == k8BitSize) ||
+          (memSize == k4ByteSize && diffVal == k4BitSize) ||
+          (memSize == k16ByteSize && diffVal == k16BitSize)) {
+        MOperator mopPair = GetMopPair(thisMop);
+        MemOperand *combineMemOpnd = (offsetVal < prevOffsetVal) ? memOpnd : prevMemOpnd;
+        Insn &combineInsn = (offsetVal < prevOffsetVal) ?
+                            cgFunc->GetInsnBuilder()->BuildInsn(mopPair, destOpnd, prevDestOpnd, *combineMemOpnd) :
+                            cgFunc->GetInsnBuilder()->BuildInsn(mopPair, prevDestOpnd, destOpnd, *combineMemOpnd);
+        bb.InsertInsnAfter(*prevContiInsn, combineInsn);
+        if (!(static_cast<AArch64CGFunc&>(*cgFunc).IsOperandImmValid(mopPair, combineMemOpnd, kInsnThirdOpnd)) &&
+            !SplitOfstWithAddToCombine(insn, combineInsn, *combineMemOpnd)) {
+            bb.RemoveInsn(combineInsn);
+            return;
+        }
+        RemoveInsnAndKeepComment(bb, insn, *prevContiInsn);
+        return;
+      }
+    }
+    /* do combination strb/ldrb -> strh/ldrh -> str/ldr */
+    if (destRegNO == prevDestRegNO && destRegNO == RZR && prevDestRegNO == RZR) {
+      if ((memSize == k1ByteSize && diffVal == k1ByteSize) ||  (memSize == k2ByteSize && diffVal == k2ByteSize)) {
+        MOperator mopPair = GetMopHigherByte(thisMop);
+        if (offsetVal < prevOffsetVal) {
+          if (static_cast<AArch64CGFunc&>(*cgFunc).IsOperandImmValid(mopPair, memOpnd, kInsnSecondOpnd)) {
+            Insn &combineInsn = cgFunc->GetInsnBuilder()->BuildInsn(mopPair, destOpnd, *memOpnd);
+            bb.InsertInsnAfter(*prevContiInsn, combineInsn);
+            RemoveInsnAndKeepComment(bb, insn, *prevContiInsn);
+            return;
+          }
+        } else {
+          if (static_cast<AArch64CGFunc&>(*cgFunc).IsOperandImmValid(mopPair, prevMemOpnd, kInsnSecondOpnd)) {
+            Insn &combineInsn = cgFunc->GetInsnBuilder()->BuildInsn(mopPair, prevDestOpnd, *prevMemOpnd);
+            bb.InsertInsnAfter(*prevContiInsn, combineInsn);
+            RemoveInsnAndKeepComment(bb, insn, *prevContiInsn);
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+
+MOperator CombineContiLoadAndStorePattern::GetMopHigherByte(MOperator mop) const {
+  switch (mop) {
+    case MOP_wldrb:
+      return MOP_wldrh;
+    case MOP_wstrb:
+      return MOP_wstrh;
+    case MOP_wldrh:
+      return MOP_wldr;
+    case MOP_wstrh:
+      return MOP_wstr;
+    default:
+      ASSERT(false, "should not run here");
+      return MOP_undef;
+  }
+}
+
+void CombineContiLoadAndStorePattern::RemoveInsnAndKeepComment(BB &bb, Insn &insn, Insn &prevInsn) const {
+  /* keep the comment */
+  Insn *nn = prevInsn.GetNextMachineInsn();
+  std::string newComment = "";
+  MapleString comment = insn.GetComment();
+  if (comment.c_str() != nullptr && strlen(comment.c_str()) > 0) {
+    newComment += comment.c_str();
+  }
+  comment = prevInsn.GetComment();
+  if (comment.c_str() != nullptr && strlen(comment.c_str()) > 0) {
+    newComment = newComment + "  " + comment.c_str();
+  }
+  if (newComment.c_str() != nullptr && strlen(newComment.c_str()) > 0) {
+    ASSERT(nn != nullptr, "nn should not be nullptr");
+    nn->SetComment(newComment);
+  }
+  bb.RemoveInsn(insn);
+  bb.RemoveInsn(prevInsn);
+}
+
+bool EliminateSpecifcSXTPattern::CheckCondition(Insn &insn) {
+  BB *bb = insn.GetBB();
+  if (bb->GetFirstMachineInsn() == &insn) {
+    BB *prevBB = bb->GetPrev();
+    if (prevBB != nullptr && (bb->GetPreds().size() == 1) && (*(bb->GetPreds().cbegin()) == prevBB)) {
+      prevInsn = prevBB->GetLastMachineInsn();
+    }
+  } else {
+    prevInsn = insn.GetPreviousMachineInsn();
+  }
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  return true;
+}
+
+void EliminateSpecifcSXTPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  auto &regOpnd0 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &regOpnd1 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  if (&insn != bb.GetFirstInsn() && regOpnd0.GetRegisterNumber() == regOpnd1.GetRegisterNumber() &&
+      prevInsn->IsMachineInstruction()) {
+    if (prevInsn->GetMachineOpcode() == MOP_wmovri32 || prevInsn->GetMachineOpcode() == MOP_xmovri64) {
+      auto &dstMovOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+      if (dstMovOpnd.GetRegisterNumber() != regOpnd1.GetRegisterNumber()) {
+        return;
+      }
+      Operand &opnd = prevInsn->GetOperand(kInsnSecondOpnd);
+      if (opnd.IsIntImmediate()) {
+        auto &immOpnd = static_cast<ImmOperand&>(opnd);
+        int64 value = immOpnd.GetValue();
+        if (thisMop == MOP_xsxtb32) {
+          /* value should in range between -127 and 127 */
+          if (value >= static_cast<int64>(0xFFFFFFFFFFFFFF80) && value <= 0x7F &&
+              immOpnd.IsSingleInstructionMovable(regOpnd0.GetSize())) {
+            bb.RemoveInsn(insn);
+          }
+        } else if (thisMop == MOP_xsxth32) {
+          /* value should in range between -32678 and 32678 */
+          if (value >= static_cast<int64>(0xFFFFFFFFFFFF8000) && value <= 0x7FFF &&
+              immOpnd.IsSingleInstructionMovable(regOpnd0.GetSize())) {
+            bb.RemoveInsn(insn);
+          }
+        } else {
+          uint64 flag = 0xFFFFFFFFFFFFFF80; /* initialize the flag with fifty-nine 1s at top */
+          if (thisMop == MOP_xsxth64) {
+            flag = 0xFFFFFFFFFFFF8000;      /* specify the flag with forty-nine 1s at top in this case */
+          } else if (thisMop == MOP_xsxtw64) {
+            flag = 0xFFFFFFFF80000000;      /* specify the flag with thirty-three 1s at top in this case */
+          }
+          if ((static_cast<uint64>(value) & flag) == 0 && immOpnd.IsSingleInstructionMovable(regOpnd0.GetSize())) {
+            auto *aarch64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+            RegOperand &dstOpnd = aarch64CGFunc->GetOrCreatePhysicalRegisterOperand(
+                static_cast<AArch64reg>(dstMovOpnd.GetRegisterNumber()), k64BitSize, dstMovOpnd.GetRegisterType());
+            prevInsn->SetOperand(kInsnFirstOpnd, dstOpnd);
+            prevInsn->SetMOP(AArch64CG::kMd[MOP_xmovri64]);
+            bb.RemoveInsn(insn);
+          }
+        }
+      }
+    }
+  }
+}
+
+void EliminateSpecifcUXTAArch64::Run(BB &bb, Insn &insn) {
+  MOperator thisMop = insn.GetMachineOpcode();
+  Insn *prevInsn = insn.GetPreviousMachineInsn();
+  if (prevInsn == nullptr) {
+    return;
+  }
+  auto &regOpnd0 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &regOpnd1 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  if (prevInsn->IsCall() &&
+      prevInsn->GetIsCallReturnUnsigned() &&
+      regOpnd0.GetRegisterNumber() == regOpnd1.GetRegisterNumber() &&
+      (regOpnd1.GetRegisterNumber() == R0 || regOpnd1.GetRegisterNumber() == V0)) {
+    uint32 retSize = prevInsn->GetRetSize();
+    if (retSize > 0 &&
+        ((thisMop == MOP_xuxtb32 && retSize <= k1ByteSize) ||
+         (thisMop == MOP_xuxth32 && retSize <= k2ByteSize) ||
+         (thisMop == MOP_xuxtw64 && retSize <= k4ByteSize))) {
+      bb.RemoveInsn(insn);
+    }
+    return;
+  }
+  if (&insn == bb.GetFirstInsn() || regOpnd0.GetRegisterNumber() != regOpnd1.GetRegisterNumber() ||
+      !prevInsn->IsMachineInstruction()) {
+    return;
+  }
+  if (cgFunc.GetMirModule().GetSrcLang() == kSrcLangC && prevInsn->IsCall() && prevInsn->GetIsCallReturnSigned()) {
+    return;
+  }
+  if (thisMop == MOP_xuxtb32) {
+    if (prevInsn->GetMachineOpcode() == MOP_wmovri32 || prevInsn->GetMachineOpcode() == MOP_xmovri64) {
+      auto &dstMovOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+      if (!IsSameRegisterOperation(dstMovOpnd, regOpnd1, regOpnd0)) {
+        return;
+      }
+      Operand &opnd = prevInsn->GetOperand(kInsnSecondOpnd);
+      if (opnd.IsIntImmediate()) {
+        auto &immOpnd = static_cast<ImmOperand&>(opnd);
+        int64 value = immOpnd.GetValue();
+        /* check the top 56 bits of value */
+        if ((static_cast<uint64>(value) & 0xFFFFFFFFFFFFFF00) == 0) {
+          bb.RemoveInsn(insn);
+        }
+      }
+    } else if (prevInsn->GetMachineOpcode() == MOP_wldrb) {
+      auto &dstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+      if (dstOpnd.GetRegisterNumber() != regOpnd1.GetRegisterNumber()) {
+        return;
+      }
+      bb.RemoveInsn(insn);
+    }
+  } else if (thisMop == MOP_xuxth32) {
+    if (prevInsn->GetMachineOpcode() == MOP_wmovri32 || prevInsn->GetMachineOpcode() == MOP_xmovri64) {
+      auto &dstMovOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+      if (!IsSameRegisterOperation(dstMovOpnd, regOpnd1, regOpnd0)) {
+        return;
+      }
+      Operand &opnd = prevInsn->GetOperand(kInsnSecondOpnd);
+      if (opnd.IsIntImmediate()) {
+        auto &immOpnd = static_cast<ImmOperand&>(opnd);
+        int64 value = immOpnd.GetValue();
+        if ((static_cast<uint64>(value) & 0xFFFFFFFFFFFF0000) == 0) {
+          bb.RemoveInsn(insn);
+        }
+      }
+    } else if (prevInsn->GetMachineOpcode() == MOP_wldrh) {
+      auto &dstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+      if (dstOpnd.GetRegisterNumber() != regOpnd1.GetRegisterNumber()) {
+        return;
+      }
+      bb.RemoveInsn(insn);
+    }
+  } else {
+    /* this_mop == MOP_xuxtw64 */
+    if (prevInsn->GetMachineOpcode() == MOP_wmovri32 || prevInsn->GetMachineOpcode() == MOP_wldrsb ||
+        prevInsn->GetMachineOpcode() == MOP_wldrb || prevInsn->GetMachineOpcode() == MOP_wldrsh ||
+        prevInsn->GetMachineOpcode() == MOP_wldrh || prevInsn->GetMachineOpcode() == MOP_wldr) {
+      auto &dstOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+      if (!IsSameRegisterOperation(dstOpnd, regOpnd1, regOpnd0)) {
+        return;
+      }
+      /* 32-bit ldr does zero-extension by default, so this conversion can be skipped */
+      bb.RemoveInsn(insn);
+    }
+  }
+}
+
+bool FmovRegPattern::CheckCondition(Insn &insn) {
+  nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr) {
+    return false;
+  }
+  if (&insn == insn.GetBB()->GetFirstInsn()) {
+    return false;
+  }
+  prevInsn = insn.GetPrev();
+  auto &curSrcRegOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  auto &prevSrcRegOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+  /* same src freg */
+  if (curSrcRegOpnd.GetRegisterNumber() != prevSrcRegOpnd.GetRegisterNumber()) {
+    return false;
+  }
+  return true;
+}
+
+void FmovRegPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  MOperator newMop;
+  uint32 doOpt = 0;
+  if (prevMop == MOP_xvmovrv && thisMop == MOP_xvmovrv) {
+    doOpt = k32BitSize;
+    newMop = MOP_wmovrr;
+  } else if (prevMop == MOP_xvmovrd && thisMop == MOP_xvmovrd) {
+    doOpt = k64BitSize;
+    newMop = MOP_xmovrr;
+  }
+  if (doOpt == 0) {
+    return;
+  }
+  auto &curDstRegOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  regno_t curDstReg = curDstRegOpnd.GetRegisterNumber();
+  /* optimize case 1 */
+  auto &prevDstRegOpnd = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+  regno_t prevDstReg = prevDstRegOpnd.GetRegisterNumber();
+  auto *aarch64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  RegOperand &dst =
+      aarch64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(curDstReg), doOpt, kRegTyInt);
+  RegOperand &src =
+      aarch64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(prevDstReg), doOpt, kRegTyInt);
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, dst, src);
+  bb.InsertInsnBefore(insn, newInsn);
+  bb.RemoveInsn(insn);
+  RegOperand &newOpnd =
+      aarch64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(prevDstReg), doOpt, kRegTyInt);
+  uint32 opndNum = nextInsn->GetOperandSize();
+  for (uint32 opndIdx = 0; opndIdx < opndNum; ++opndIdx) {
+    Operand &opnd = nextInsn->GetOperand(opndIdx);
+    if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      Operand *base = memOpnd.GetBaseRegister();
+      if (base != nullptr) {
+        if (base->IsRegister()) {
+          auto *reg = static_cast<RegOperand*>(base);
+          if (reg->GetRegisterNumber() == curDstReg) {
+            memOpnd.SetBaseRegister(newOpnd);
+          }
+        }
+      }
+      Operand *offset = memOpnd.GetIndexRegister();
+      if (offset != nullptr) {
+        if (offset->IsRegister()) {
+          auto *reg = static_cast<RegOperand*>(offset);
+          if (reg->GetRegisterNumber() == curDstReg) {
+            memOpnd.SetIndexRegister(newOpnd);
+          }
+        }
+      }
+    } else if (opnd.IsRegister()) {
+      /* Check if it is a source operand. */
+      auto *regProp = nextInsn->GetDesc()->opndMD[opndIdx];
+      if (regProp->IsUse()) {
+        auto &reg = static_cast<RegOperand&>(opnd);
+        if (reg.GetRegisterNumber() == curDstReg) {
+          nextInsn->SetOperand(opndIdx, newOpnd);
+        }
+      }
+    }
+  }
+}
+
+bool SbfxOptPattern::CheckCondition(Insn &insn) {
+  nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr) {
+    return false;
+  }
+  auto &curDstRegOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  uint32 opndNum = nextInsn->GetOperandSize();
+  const InsnDesc *md = nextInsn->GetDesc();
+  for (uint32 opndIdx = 0; opndIdx < opndNum; ++opndIdx) {
+    Operand &opnd = nextInsn->GetOperand(opndIdx);
+    /* Check if it is a source operand. */
+    if (opnd.IsMemoryAccessOperand() || opnd.IsList()) {
+      return false;
+    } else if (opnd.IsRegister()) {
+      auto &reg = static_cast<RegOperand&>(opnd);
+      auto *regProp = md->opndMD[opndIdx];
+      if (reg.GetRegisterNumber() == curDstRegOpnd.GetRegisterNumber()) {
+        if (reg.GetSize() != k32BitSize) {
+          return false;
+        }
+        if (regProp->IsDef()) {
+          toRemove = true;
+        } else {
+          (void)cands.emplace_back(opndIdx);
+        }
+      }
+    }
+  }
+  return cands.size() != 0;
+}
+
+void SbfxOptPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto &srcRegOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  RegOperand &newReg = static_cast<AArch64CGFunc*>(cgFunc)->GetOrCreatePhysicalRegisterOperand(
+      static_cast<AArch64reg>(srcRegOpnd.GetRegisterNumber()), k32BitSize, srcRegOpnd.GetRegisterType());
+  // replace use point of opnd in nextInsn
+  for (auto i: cands) {
+    nextInsn->SetOperand(i, newReg);
+  }
+  if (toRemove) {
+    bb.RemoveInsn(insn);
+  }
+}
+
+bool CbnzToCbzPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wcbnz && curMop != MOP_xcbnz) {
+    return false;
+  }
+  /* reg has to be R0, since return value is in R0 */
+  auto &regOpnd0 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  if (regOpnd0.GetRegisterNumber() != R0) {
+    return false;
+  }
+  nextBB = insn.GetBB()->GetNext();
+  /* Make sure nextBB can only be reached by bb */
+  if (nextBB->GetPreds().size() > 1 || nextBB->GetEhPreds().empty()) {
+    return false;
+  }
+  /* Next insn should be a mov R0 = 0 */
+  movInsn = nextBB->GetFirstMachineInsn();
+  if (movInsn == nullptr) {
+    return false;
+  }
+  MOperator movInsnMop = movInsn->GetMachineOpcode();
+  if (movInsnMop != MOP_wmovri32 && movInsnMop != MOP_xmovri64) {
+    return false;
+  }
+  auto &movDest = static_cast<RegOperand&>(movInsn->GetOperand(kInsnFirstOpnd));
+  if (movDest.GetRegisterNumber() != R0) {
+    return false;
+  }
+  auto &movImm = static_cast<ImmOperand&>(movInsn->GetOperand(kInsnSecondOpnd));
+  if (movImm.GetValue() != 0) {
+    return false;
+  }
+  Insn *nextBrInsn = movInsn->GetNextMachineInsn();
+  if (nextBrInsn == nullptr) {
+    return false;
+  }
+  if (nextBrInsn->GetMachineOpcode() != MOP_xuncond) {
+    return false;
+  }
+  /* Is nextBB branch to the return-bb? */
+  if (nextBB->GetSuccs().size() != 1) {
+    return false;
+  }
+  return true;
+}
+
+void CbnzToCbzPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  BB *targetBB = nullptr;
+  auto it = bb.GetSuccsBegin();
+  if (*it == nextBB) {
+    ++it;
+  }
+  targetBB = *it;
+  /* Make sure when nextBB is empty, targetBB is fallthru of bb. */
+  if (targetBB != nextBB->GetNext()) {
+    return;
+  }
+  BB *nextBBTarget = *(nextBB->GetSuccsBegin());
+  if (nextBBTarget->GetKind() != BB::kBBReturn) {
+    return;
+  }
+  /* Control flow looks nice, instruction looks nice */
+  Operand &brTarget = brInsn->GetOperand(kInsnFirstOpnd);
+  insn.SetOperand(kInsnSecondOpnd, brTarget);
+  if (thisMop == MOP_wcbnz) {
+    insn.SetMOP(AArch64CG::kMd[MOP_wcbz]);
+  } else {
+    insn.SetMOP(AArch64CG::kMd[MOP_xcbz]);
+  }
+  nextBB->RemoveInsn(*movInsn);
+  nextBB->RemoveInsn(*brInsn);
+  /* nextBB is now a fallthru bb, not a goto bb */
+  nextBB->SetKind(BB::kBBFallthru);
+  /*
+   * fix control flow, we have bb, nextBB, targetBB, nextBB_target
+   * connect bb -> nextBB_target erase targetBB
+   */
+  it = bb.GetSuccsBegin();
+  CHECK_FATAL(it != bb.GetSuccsEnd(), "succs is empty.");
+  if (*it == targetBB) {
+    bb.EraseSuccs(it);
+    bb.PushFrontSuccs(*nextBBTarget);
+  } else {
+    ++it;
+    bb.EraseSuccs(it);
+    bb.PushBackSuccs(*nextBBTarget);
+  }
+  for (auto targetBBIt = targetBB->GetPredsBegin(); targetBBIt != targetBB->GetPredsEnd(); ++targetBBIt) {
+    if (*targetBBIt == &bb) {
+      targetBB->ErasePreds(targetBBIt);
+      break;
+    }
+  }
+  for (auto nextIt = nextBBTarget->GetPredsBegin(); nextIt != nextBBTarget->GetPredsEnd(); ++nextIt) {
+    if (*nextIt == nextBB) {
+      nextBBTarget->ErasePreds(nextIt);
+      break;
+    }
+  }
+  nextBBTarget->PushBackPreds(bb);
+
+  /* nextBB has no target, originally just branch target */
+  nextBB->EraseSuccs(nextBB->GetSuccsBegin());
+  ASSERT(nextBB->GetSuccs().empty(), "peep: branch target incorrect");
+  /* Now make nextBB fallthru to targetBB */
+  nextBB->PushFrontSuccs(*targetBB);
+  targetBB->PushBackPreds(*nextBB);
+}
+
+bool ContiLDRorSTRToSameMEMPattern::CheckCondition(Insn &insn) {
+  prevInsn = insn.GetPrev();
+  while (prevInsn != nullptr && prevInsn->GetMachineOpcode() == 0 && prevInsn != insn.GetBB()->GetFirstInsn()) {
+    prevInsn = prevInsn->GetPrev();
+  }
+  if (!insn.IsMachineInstruction() || prevInsn == nullptr) {
+    return false;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  /*
+   * store regB, RegC, offset
+   * load regA, RegC, offset
+   */
+  if ((thisMop == MOP_xldr && prevMop == MOP_xstr) || (thisMop == MOP_wldr && prevMop == MOP_wstr) ||
+      (thisMop == MOP_dldr && prevMop == MOP_dstr) || (thisMop == MOP_sldr && prevMop == MOP_sstr)) {
+    loadAfterStore = true;
+  }
+  /*
+   * load regA, RegC, offset
+   * load regB, RegC, offset
+   */
+  if ((thisMop == MOP_xldr || thisMop == MOP_wldr || thisMop == MOP_dldr || thisMop == MOP_sldr) &&
+      prevMop == thisMop) {
+    loadAfterLoad = true;
+  }
+  if (!loadAfterStore && !loadAfterLoad) {
+    return false;
+  }
+  ASSERT(insn.GetOperand(kInsnSecondOpnd).IsMemoryAccessOperand(), "expects mem operands");
+  ASSERT(prevInsn->GetOperand(kInsnSecondOpnd).IsMemoryAccessOperand(), "expects mem operands");
+  return true;
+}
+
+void ContiLDRorSTRToSameMEMPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  auto &memOpnd1 = static_cast<MemOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  MemOperand::AArch64AddressingMode addrMode1 = memOpnd1.GetAddrMode();
+  if (addrMode1 != MemOperand::kAddrModeBOi || (!memOpnd1.IsIntactIndexed())) {
+    return;
+  }
+
+  auto *base1 = static_cast<RegOperand*>(memOpnd1.GetBaseRegister());
+  ASSERT(base1 == nullptr || !base1->IsVirtualRegister(), "physical register has not been allocated?");
+  OfstOperand *offset1 = memOpnd1.GetOffsetImmediate();
+
+  auto &memOpnd2 = static_cast<MemOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+  MemOperand::AArch64AddressingMode addrMode2 = memOpnd2.GetAddrMode();
+  if (addrMode2 != MemOperand::kAddrModeBOi || (!memOpnd2.IsIntactIndexed())) {
+    return;
+  }
+
+  auto *base2 = static_cast<RegOperand*>(memOpnd2.GetBaseRegister());
+  ASSERT(base2 == nullptr || !base2->IsVirtualRegister(), "physical register has not been allocated?");
+  OfstOperand *offset2 = memOpnd2.GetOffsetImmediate();
+
+  if (base1 == nullptr || base2 == nullptr || offset1 == nullptr || offset2 == nullptr) {
+    return;
+  }
+
+  auto &reg1 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &reg2 = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+  int64 offsetVal1 = offset1->GetOffsetValue();
+  int64 offsetVal2 = offset2->GetOffsetValue();
+  if (base1->GetRegisterNumber() != base2->GetRegisterNumber() ||
+      reg1.GetRegisterType() != reg2.GetRegisterType() || reg1.GetSize() != reg2.GetSize() ||
+      offsetVal1 != offsetVal2) {
+    return;
+  }
+  if (loadAfterStore && reg1.GetRegisterNumber() != reg2.GetRegisterNumber()) {
+    /* replace it with mov */
+    MOperator newOp = MOP_wmovrr;
+    if (reg1.GetRegisterType() == kRegTyInt) {
+      newOp = (reg1.GetSize() <= k32BitSize) ? MOP_wmovrr : MOP_xmovrr;
+    } else if (reg1.GetRegisterType() == kRegTyFloat) {
+      newOp = (reg1.GetSize() <= k32BitSize) ? MOP_xvmovs : MOP_xvmovd;
+    }
+    Insn *nextInsn = insn.GetNext();
+    while (nextInsn != nullptr && nextInsn->GetMachineOpcode() == 0 && nextInsn != bb.GetLastInsn()) {
+      nextInsn = nextInsn->GetNext();
+    }
+    bool moveSameReg = false;
+    if (nextInsn && nextInsn->GetIsSpill() && !IfOperandIsLiveAfterInsn(reg1, *nextInsn)) {
+      MOperator nextMop = nextInsn->GetMachineOpcode();
+      if ((thisMop == MOP_xldr && nextMop == MOP_xstr) || (thisMop == MOP_wldr && nextMop == MOP_wstr) ||
+          (thisMop == MOP_dldr && nextMop == MOP_dstr) || (thisMop == MOP_sldr && nextMop == MOP_sstr)) {
+        nextInsn->Insn::SetOperand(kInsnFirstOpnd, reg2);
+        moveSameReg = true;
+      }
+    }
+    if (!moveSameReg) {
+      (void)bb.InsertInsnAfter(*prevInsn, cgFunc->GetInsnBuilder()->BuildInsn(newOp, reg1, reg2));
+    }
+    bb.RemoveInsn(insn);
+  } else if (reg1.GetRegisterNumber() == reg2.GetRegisterNumber() &&
+             base1->GetRegisterNumber() != reg2.GetRegisterNumber()) {
+    bb.RemoveInsn(insn);
+  }
+}
+
+bool RemoveIncDecRefPattern::CheckCondition(Insn &insn) {
+  if (insn.GetMachineOpcode() !=  MOP_xbl) {
+    return false;
+  }
+  prevInsn = insn.GetPreviousMachineInsn();
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  if (prevMop != MOP_xmovrr) {
+    return false;
+  }
+  auto &target = static_cast<FuncNameOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  if (target.GetName() != "MCC_IncDecRef_NaiveRCFast") {
+    return false;
+  }
+  if (static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd)).GetRegisterNumber() != R1 ||
+      static_cast<RegOperand&>(prevInsn->GetOperand(kInsnSecondOpnd)).GetRegisterNumber() != R0) {
+    return false;
+  }
+  return true;
+}
+
+void RemoveIncDecRefPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  bb.RemoveInsn(*prevInsn);
+  bb.RemoveInsn(insn);
+}
+
+#ifdef USE_32BIT_REF
+constexpr uint32 kRefSize = 32;
+#else
+constexpr uint32 kRefSize = 64;
+#endif
+
+bool InlineReadBarriersPattern::CheckCondition(Insn &insn) {
+  /* Inline read barriers only enabled for GCONLY. */
+  if (!CGOptions::IsGCOnly()) {
+    return false;
+  }
+  return true;
+}
+
+void InlineReadBarriersPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  const std::string &barrierName = GetReadBarrierName(insn);
+  if (barrierName == kMccDummy) {
+    /* remove dummy call. */
+    bb.RemoveInsn(insn);
+  } else {
+    /* replace barrier function call with load instruction. */
+    bool isVolatile = (barrierName == kMccLoadRefV || barrierName == kMccLoadRefVS);
+    bool isStatic = (barrierName == kMccLoadRefS || barrierName == kMccLoadRefVS);
+    /* refSize is 32 if USE_32BIT_REF defined, otherwise 64. */
+    const uint32 refSize = kRefSize;
+    auto *aarch64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+    MOperator loadOp = GetLoadOperator(refSize, isVolatile);
+    RegOperand &regOp = aarch64CGFunc->GetOrCreatePhysicalRegisterOperand(R0, refSize, kRegTyInt);
+    AArch64reg addrReg = isStatic ? R0 : R1;
+    MemOperand &addr = aarch64CGFunc->CreateMemOpnd(addrReg, 0, refSize);
+    Insn &loadInsn = cgFunc->GetInsnBuilder()->BuildInsn(loadOp, regOp, addr);
+    bb.ReplaceInsn(insn, loadInsn);
+  }
+  bool isTailCall = (insn.GetMachineOpcode() == MOP_tail_call_opt_xbl);
+  if (isTailCall) {
+    /* add 'ret' instruction for tail call optimized load barrier. */
+    Insn &retInsn = cgFunc->GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_xret);
+    bb.AppendInsn(retInsn);
+    bb.SetKind(BB::kBBReturn);
+  }
+}
+
+bool ReplaceDivToMultiPattern::CheckCondition(Insn &insn) {
+  prevInsn = insn.GetPreviousMachineInsn();
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  prePrevInsn = prevInsn->GetPreviousMachineInsn();
+  auto &sdivOpnd1 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  auto &sdivOpnd2 = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  if (sdivOpnd1.GetRegisterNumber() == sdivOpnd2.GetRegisterNumber() || sdivOpnd1.GetRegisterNumber() == R16 ||
+      sdivOpnd2.GetRegisterNumber() == R16 || prePrevInsn == nullptr) {
+    return false;
+  }
+  MOperator prevMop = prevInsn->GetMachineOpcode();
+  MOperator prePrevMop = prePrevInsn->GetMachineOpcode();
+  if ((prevMop > 0) && (prevMop == MOP_wmovkri16) && (prePrevMop > 0) && (prePrevMop == MOP_wmovri32)) {
+    return true;
+  }
+  return false;
+}
+
+void ReplaceDivToMultiPattern::Run(BB &bb, Insn &insn) {
+  if (CheckCondition(insn)) {
+    auto &sdivOpnd1 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+    auto &sdivOpnd2 = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+    /* Check if dest operand of insn is idential with  register of prevInsn and prePrevInsn. */
+    auto &prevReg = prevInsn->GetOperand(kInsnFirstOpnd);
+    auto &prePrevReg = prePrevInsn->GetOperand(kInsnFirstOpnd);
+    if (!prevReg.IsRegister() ||
+        !prePrevReg.IsRegister() ||
+        static_cast<RegOperand&>(prevReg).GetRegisterNumber() != sdivOpnd2.GetRegisterNumber() ||
+        static_cast<RegOperand&>(prePrevReg).GetRegisterNumber() != sdivOpnd2.GetRegisterNumber()) {
+      return;
+    }
+    auto &prevLsl = static_cast<BitShiftOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+    if (prevLsl.GetShiftAmount() != k16BitSize) {
+      return;
+    }
+    auto &prevImmOpnd = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+    auto &prePrevImmOpnd = static_cast<ImmOperand&>(prePrevInsn->GetOperand(kInsnSecondOpnd));
+    /*
+     * expect the immediate value of first mov is 0x086A0 which matches 0x186A0
+     * because 0x10000 is ignored in 32 bits register
+     */
+    if ((prevImmOpnd.GetValue() != 1) || (prePrevImmOpnd.GetValue() != 34464)) {
+      return;
+    }
+    auto *aarch64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+    /* mov   w16, #0x588f */
+    RegOperand &tempOpnd = aarch64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(R16),
+                                                                             k64BitSize, kRegTyInt);
+    /* create a immedate operand with this specific value */
+    ImmOperand &multiplierLow = aarch64CGFunc->CreateImmOperand(0x588f, k32BitSize, false);
+    Insn &multiplierLowInsn = cgFunc->GetInsnBuilder()->BuildInsn(MOP_wmovri32, tempOpnd, multiplierLow);
+    bb.InsertInsnBefore(*prePrevInsn, multiplierLowInsn);
+
+    /*
+     * movk    w16, #0x4f8b, LSL #16
+     * create a immedate operand with this specific value
+     */
+    ImmOperand &multiplierHigh = aarch64CGFunc->CreateImmOperand(0x4f8b, k32BitSize, false);
+    BitShiftOperand *multiplierHighLsl = aarch64CGFunc->GetLogicalShiftLeftOperand(k16BitSize, true);
+    Insn &multiplierHighInsn =
+        cgFunc->GetInsnBuilder()->BuildInsn(MOP_wmovkri16, tempOpnd, multiplierHigh, *multiplierHighLsl);
+    bb.InsertInsnBefore(*prePrevInsn, multiplierHighInsn);
+
+    /* smull   x16, w0, w16 */
+    Insn &newSmullInsn =
+        cgFunc->GetInsnBuilder()->BuildInsn(MOP_xsmullrrr, tempOpnd, sdivOpnd1, tempOpnd);
+    bb.InsertInsnBefore(*prePrevInsn, newSmullInsn);
+
+    /* asr     x16, x16, #32 */
+    ImmOperand &dstLsrImmHigh = aarch64CGFunc->CreateImmOperand(k32BitSize, k32BitSize, false);
+    Insn &dstLsrInsnHigh =
+        cgFunc->GetInsnBuilder()->BuildInsn(MOP_xasrrri6, tempOpnd, tempOpnd, dstLsrImmHigh);
+    bb.InsertInsnBefore(*prePrevInsn, dstLsrInsnHigh);
+
+    /* add     x16, x16, w0, SXTW */
+    Operand &sxtw = aarch64CGFunc->CreateExtendShiftOperand(ExtendShiftOperand::kSXTW, 0, 3);
+    Insn &addInsn =
+        cgFunc->GetInsnBuilder()->BuildInsn(MOP_xxwaddrrre, tempOpnd, tempOpnd, sdivOpnd1, sxtw);
+    bb.InsertInsnBefore(*prePrevInsn, addInsn);
+
+    /* asr     x16, x16, #17 */
+    ImmOperand &dstLsrImmChange = aarch64CGFunc->CreateImmOperand(17, k32BitSize, false);
+    Insn &dstLsrInsnChange =
+        cgFunc->GetInsnBuilder()->BuildInsn(MOP_xasrrri6, tempOpnd, tempOpnd, dstLsrImmChange);
+    bb.InsertInsnBefore(*prePrevInsn, dstLsrInsnChange);
+
+    /* add     x2, x16, x0, LSR #31 */
+    auto &sdivOpnd0 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+    regno_t sdivOpnd0RegNO = sdivOpnd0.GetRegisterNumber();
+    RegOperand &extSdivO0 =
+        aarch64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(sdivOpnd0RegNO),
+                                                          k64BitSize, kRegTyInt);
+
+    regno_t sdivOpnd1RegNum = sdivOpnd1.GetRegisterNumber();
+    RegOperand &extSdivO1 =
+        aarch64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(sdivOpnd1RegNum),
+                                                          k64BitSize, kRegTyInt);
+    /* shift bit amount is thirty-one at this insn */
+    BitShiftOperand &addLsrOpnd = aarch64CGFunc->CreateBitShiftOperand(BitShiftOperand::kLSR, 31, 6);
+    Insn &addLsrInsn = cgFunc->GetInsnBuilder()->BuildInsn(MOP_xaddrrrs, extSdivO0, tempOpnd, extSdivO1, addLsrOpnd);
+    bb.InsertInsnBefore(*prePrevInsn, addLsrInsn);
+
+    /*
+     * remove insns
+     * Check if x1 is used after sdiv insn, and if it is in live-out.
+     */
+    if (sdivOpnd2.GetRegisterNumber() != sdivOpnd0.GetRegisterNumber()) {
+      if (IfOperandIsLiveAfterInsn(sdivOpnd2, insn)) {
+        /* Only remove div instruction. */
+        bb.RemoveInsn(insn);
+        return;
+      }
+    }
+
+    bb.RemoveInsn(*prePrevInsn);
+    bb.RemoveInsn(*prevInsn);
+    bb.RemoveInsn(insn);
+  }
+}
+
+Insn *AndCmpBranchesToCsetAArch64::FindPreviousCmp(Insn &insn) const {
+  regno_t defRegNO = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd)).GetRegisterNumber();
+  for (Insn *curInsn = insn.GetPrev(); curInsn != nullptr; curInsn = curInsn->GetPrev()) {
+    if (!curInsn->IsMachineInstruction()) {
+      continue;
+    }
+    if (curInsn->GetMachineOpcode() == MOP_wcmpri || curInsn->GetMachineOpcode() == MOP_xcmpri) {
+      return curInsn;
+    }
+    /*
+     * if any def/use of CC or insn defReg between insn and curInsn, stop searching and return nullptr.
+     */
+    if (curInsn->ScanReg(defRegNO) ||
+        curInsn->ScanReg(kRFLAG)) {
+      return nullptr;
+    }
+  }
+  return nullptr;
+}
+
+void AndCmpBranchesToCsetAArch64::Run(BB &bb, Insn &insn) {
+   /* prevInsn must be "cmp" insn */
+  Insn *prevInsn = FindPreviousCmp(insn);
+  if (prevInsn == nullptr) {
+    return;
+  }
+  /* prevPrevInsn must be "and" insn */
+  Insn *prevPrevInsn = prevInsn->GetPreviousMachineInsn();
+  if (prevPrevInsn == nullptr ||
+      (prevPrevInsn->GetMachineOpcode() != MOP_wandrri12 && prevPrevInsn->GetMachineOpcode() != MOP_xandrri13)) {
+    return;
+  }
+
+  auto &csetCond = static_cast<CondOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  auto &cmpImm = static_cast<ImmOperand&>(prevInsn->GetOperand(kInsnThirdOpnd));
+  int64 cmpImmVal = cmpImm.GetValue();
+  auto &andImm = static_cast<ImmOperand&>(prevPrevInsn->GetOperand(kInsnThirdOpnd));
+  int64 andImmVal = andImm.GetValue();
+  if ((csetCond.GetCode() == CC_EQ && cmpImmVal == andImmVal) ||
+      (csetCond.GetCode() == CC_NE && cmpImmVal == 0)) {
+    /* if flag_reg of "cmp" is live later, we can't remove cmp insn. */
+    auto &flagReg = static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd));
+    if (IfOperandIsLiveAfterInsn(flagReg, insn)) {
+      return;
+    }
+
+    auto &csetReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+    auto &prevInsnSecondReg = prevInsn->GetOperand(kInsnSecondOpnd);
+    bool isRegDiff = !RegOperand::IsSameRegNO(csetReg, prevInsnSecondReg);
+    if (isRegDiff && IfOperandIsLiveAfterInsn(static_cast<RegOperand&>(prevInsnSecondReg), insn)) {
+      return;
+    }
+    if (andImmVal == 1) {
+      if (!RegOperand::IsSameRegNO(prevInsnSecondReg, prevPrevInsn->GetOperand(kInsnFirstOpnd))) {
+        return;
+      }
+      /* save the "and" insn only. */
+      bb.RemoveInsn(insn);
+      bb.RemoveInsn(*prevInsn);
+      if (isRegDiff) {
+        prevPrevInsn->Insn::SetOperand(kInsnFirstOpnd, csetReg);
+      }
+    } else {
+      if (!RegOperand::IsSameReg(prevInsnSecondReg, prevPrevInsn->GetOperand(kInsnFirstOpnd)) ||
+          !RegOperand::IsSameReg(prevInsnSecondReg, prevPrevInsn->GetOperand(kInsnSecondOpnd))) {
+        return;
+      }
+
+      /* andImmVal is n power of 2 */
+      int n = LogValueAtBase2(andImmVal);
+      if (n < 0) {
+        return;
+      }
+
+      /* create ubfx insn */
+      MOperator ubfxOp = (csetReg.GetSize() <= k32BitSize) ? MOP_wubfxrri5i5 : MOP_xubfxrri6i6;
+      if (ubfxOp == MOP_wubfxrri5i5 && static_cast<uint32>(n) >= k32BitSize) {
+        return;
+      }
+      auto &dstReg = static_cast<RegOperand&>(csetReg);
+      auto &srcReg = static_cast<RegOperand&>(prevInsnSecondReg);
+      auto *aarch64CGFunc = static_cast<AArch64CGFunc*>(&cgFunc);
+      ImmOperand &bitPos = aarch64CGFunc->CreateImmOperand(n, k8BitSize, false);
+      ImmOperand &bitSize = aarch64CGFunc->CreateImmOperand(1, k8BitSize, false);
+      Insn &ubfxInsn = cgFunc.GetInsnBuilder()->BuildInsn(ubfxOp, dstReg, srcReg, bitPos, bitSize);
+      bb.InsertInsnBefore(*prevPrevInsn, ubfxInsn);
+      bb.RemoveInsn(insn);
+      bb.RemoveInsn(*prevInsn);
+      bb.RemoveInsn(*prevPrevInsn);
+    }
+  }
+}
+
+void AndCbzBranchesToTstAArch64::Run(BB &bb, Insn &insn) {
+  /* nextInsn must be "cbz" or "cbnz" insn */
+  Insn *nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr ||
+      (nextInsn->GetMachineOpcode() != MOP_wcbz && nextInsn->GetMachineOpcode() != MOP_xcbz)) {
+    return;
+  }
+  auto &andRegOp = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  regno_t andRegNO1 = andRegOp.GetRegisterNumber();
+  auto &cbzRegOp2 = static_cast<RegOperand&>(nextInsn->GetOperand(kInsnFirstOpnd));
+  regno_t cbzRegNO2 = cbzRegOp2.GetRegisterNumber();
+  if (andRegNO1 != cbzRegNO2) {
+    return;
+  }
+  /* If the reg will be used later, we shouldn't optimize the and insn here */
+  if (IfOperandIsLiveAfterInsn(andRegOp, *nextInsn)) {
+    return;
+  }
+  /* build tst insn */
+  Operand &andOpnd3 = insn.GetOperand(kInsnThirdOpnd);
+  auto &andRegOp2 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  auto &andRegOp3 = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  MOperator newTstOp = MOP_undef;
+  if (andOpnd3.IsRegister()) {
+    newTstOp = (andRegOp2.GetSize() <= k32BitSize && andRegOp3.GetSize() <= k32BitSize) ? MOP_wtstrr : MOP_xtstrr;
+  } else {
+    newTstOp = (andRegOp2.GetSize() <= k32BitSize && andRegOp3.GetSize() <= k32BitSize) ? MOP_wtstri32 : MOP_xtstri64;
+  }
+  Operand &rflag = static_cast<AArch64CGFunc*>(&cgFunc)->GetOrCreateRflag();
+  Insn &newInsnTst = cgFunc.GetInsnBuilder()->BuildInsn(newTstOp, rflag, andRegOp2, andOpnd3);
+  if (andOpnd3.IsImmediate()) {
+    if (!static_cast<ImmOperand&>(andOpnd3).IsBitmaskImmediate(andRegOp2.GetSize())) {
+      return;
+    }
+  }
+  /* build beq insn */
+  MOperator opCode = nextInsn->GetMachineOpcode();
+  bool reverse = (opCode == MOP_xcbz || opCode == MOP_wcbz);
+  auto &label = static_cast<LabelOperand&>(nextInsn->GetOperand(kInsnSecondOpnd));
+  MOperator jmpOperator = reverse ? MOP_beq : MOP_bne;
+  Insn &newInsnJmp = cgFunc.GetInsnBuilder()->BuildInsn(jmpOperator, rflag, label);
+  bb.ReplaceInsn(insn, newInsnTst);
+  bb.ReplaceInsn(*nextInsn, newInsnJmp);
+}
+
+/*
+ * help function for DeleteMovAfterCbzOrCbnz
+ * input:
+ *        bb: the bb to be checked out
+ *        checkCbz: to check out BB end with cbz or cbnz, if cbz, input true
+ *        opnd: for MOV reg, #0, opnd indicate reg
+ * return:
+ *        according to cbz, return true if insn is cbz or cbnz and the first operand of cbz(cbnz) is same as input
+ *      operand
+ */
+bool DeleteMovAfterCbzOrCbnzAArch64::PredBBCheck(BB &bb, bool checkCbz, const Operand &opnd) const {
+  if (bb.GetKind() != BB::kBBIf) {
+    return false;
+  }
+
+  Insn *condBr = cgcfg->FindLastCondBrInsn(bb);
+  ASSERT(condBr != nullptr, "condBr must be found");
+  if (!cgcfg->IsCompareAndBranchInsn(*condBr)) {
+    return false;
+  }
+  MOperator mOp = condBr->GetMachineOpcode();
+  if (checkCbz && mOp != MOP_wcbz && mOp != MOP_xcbz) {
+    return false;
+  }
+  if (!checkCbz && mOp != MOP_xcbnz && mOp != MOP_wcbnz) {
+    return false;
+  }
+  return RegOperand::IsSameRegNO(condBr->GetOperand(kInsnFirstOpnd), opnd);
+}
+
+bool DeleteMovAfterCbzOrCbnzAArch64::OpndDefByMovZero(const Insn &insn) const {
+  MOperator defMop = insn.GetMachineOpcode();
+  switch (defMop) {
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      Operand &defOpnd = insn.GetOperand(kInsnSecondOpnd);
+      ASSERT(defOpnd.IsIntImmediate(), "expects ImmOperand");
+      auto &defConst = static_cast<ImmOperand&>(defOpnd);
+      int64 defConstValue = defConst.GetValue();
+      if (defConstValue == 0) {
+        return true;
+      }
+      return false;
+    }
+    case MOP_xmovrr:
+    case MOP_wmovrr: {
+      Operand &secondOpnd = insn.GetOperand(kInsnSecondOpnd);
+      ASSERT(secondOpnd.IsRegister(), "expects RegOperand here");
+      auto &regOpnd = static_cast<RegOperand&>(secondOpnd);
+      return IsZeroRegister(regOpnd);
+    }
+    default:
+      return false;
+  }
+}
+
+/* check whether predefine insn of first operand of test_insn is exist in current BB */
+bool DeleteMovAfterCbzOrCbnzAArch64::NoPreDefine(Insn &testInsn) const {
+  Insn *nextInsn = nullptr;
+  for (Insn *insn = testInsn.GetBB()->GetFirstInsn(); insn != nullptr && insn != &testInsn; insn = nextInsn) {
+    nextInsn = insn->GetNextMachineInsn();
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    ASSERT(!insn->IsCall(), "CG internal error, call insn should not be at the middle of the BB.");
+    const InsnDesc *md = insn->GetDesc();
+    uint32 opndNum = insn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = insn->GetOperand(i);
+      if (!md->opndMD[i]->IsDef()) {
+        continue;
+      }
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        RegOperand *base = memOpnd.GetBaseRegister();
+        ASSERT(base != nullptr, "nullptr check");
+        ASSERT(base->IsRegister(), "expects RegOperand");
+        if (RegOperand::IsSameRegNO(*base, testInsn.GetOperand(kInsnFirstOpnd)) &&
+            memOpnd.GetAddrMode() == MemOperand::kAddrModeBOi &&
+            (memOpnd.IsPostIndexed() || memOpnd.IsPreIndexed())) {
+          return false;
+        }
+      } else if (opnd.IsList()) {
+        for (auto &operand : static_cast<const ListOperand&>(opnd).GetOperands()) {
+          if (RegOperand::IsSameRegNO(testInsn.GetOperand(kInsnFirstOpnd), *operand)) {
+            return false;
+          }
+        }
+      } else if (opnd.IsRegister()) {
+        if (RegOperand::IsSameRegNO(testInsn.GetOperand(kInsnFirstOpnd), opnd)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+void DeleteMovAfterCbzOrCbnzAArch64::ProcessBBHandle(BB *processBB, const BB &bb, const Insn &insn) const {
+  ASSERT(processBB != nullptr, "process_bb is null in ProcessBBHandle");
+  FOR_BB_INSNS_SAFE(processInsn, processBB, nextProcessInsn) {
+    nextProcessInsn = processInsn->GetNextMachineInsn();
+    if (!processInsn->IsMachineInstruction()) {
+      continue;
+    }
+    /* register may be a caller save register */
+    if (processInsn->IsCall()) {
+      break;
+    }
+    if (!OpndDefByMovZero(*processInsn) || !NoPreDefine(*processInsn) ||
+        !RegOperand::IsSameRegNO(processInsn->GetOperand(kInsnFirstOpnd), insn.GetOperand(kInsnFirstOpnd))) {
+      continue;
+    }
+    bool toDoOpt = true;
+    MOperator condBrMop = insn.GetMachineOpcode();
+    /* process elseBB, other preds must be cbz */
+    if (condBrMop == MOP_wcbnz || condBrMop == MOP_xcbnz) {
+      /* check out all preds of process_bb */
+      for (auto *processBBPred : processBB->GetPreds()) {
+        if (processBBPred == &bb) {
+          continue;
+        }
+        if (!PredBBCheck(*processBBPred, true, processInsn->GetOperand(kInsnFirstOpnd))) {
+          toDoOpt = false;
+          break;
+        }
+      }
+    } else {
+      /* process ifBB, other preds can be cbz or cbnz(one at most) */
+      for (auto processBBPred : processBB->GetPreds()) {
+        if (processBBPred == &bb) {
+          continue;
+        }
+        /* for cbnz pred, there is one at most */
+        if (!PredBBCheck(*processBBPred, processBBPred != processBB->GetPrev(),
+                         processInsn->GetOperand(kInsnFirstOpnd))) {
+          toDoOpt = false;
+          break;
+        }
+      }
+    }
+    if (!toDoOpt) {
+      continue;
+    }
+    processBB->RemoveInsn(*processInsn);
+  }
+}
+
+void DeleteMovAfterCbzOrCbnzAArch64::Run(BB &bb, Insn &insn) {
+  if (bb.GetKind() != BB::kBBIf) {
+    return;
+  }
+  if (&insn != cgcfg->FindLastCondBrInsn(bb)) {
+    return;
+  }
+  if (!cgcfg->IsCompareAndBranchInsn(insn)) {
+    return;
+  }
+  BB *processBB = nullptr;
+  if (bb.GetNext() == maplebe::CGCFG::GetTargetSuc(bb)) {
+    return;
+  }
+
+  MOperator condBrMop = insn.GetMachineOpcode();
+  if (condBrMop == MOP_wcbnz || condBrMop == MOP_xcbnz) {
+    processBB = bb.GetNext();
+  } else {
+    processBB = maplebe::CGCFG::GetTargetSuc(bb);
+  }
+
+  ProcessBBHandle(processBB, bb, insn);
+}
+
+bool LoadFloatPointPattern::FindLoadFloatPoint(Insn &insn) {
+  MOperator mOp = insn.GetMachineOpcode();
+  optInsn.clear();
+  if (mOp != MOP_xmovzri16) {
+    return false;
+  }
+  optInsn.emplace_back(&insn);
+
+  Insn *insnMov2 = insn.GetNextMachineInsn();
+  if (insnMov2 == nullptr) {
+    return false;
+  }
+  if (insnMov2->GetMachineOpcode() != MOP_xmovkri16) {
+    return false;
+  }
+  optInsn.emplace_back(insnMov2);
+
+  Insn *insnMov3 = insnMov2->GetNextMachineInsn();
+  if (insnMov3 == nullptr) {
+    return false;
+  }
+  if (insnMov3->GetMachineOpcode() != MOP_xmovkri16) {
+    return false;
+  }
+  optInsn.emplace_back(insnMov3);
+
+  Insn *insnMov4 = insnMov3->GetNextMachineInsn();
+  if (insnMov4 == nullptr) {
+    return false;
+  }
+  if (insnMov4->GetMachineOpcode() != MOP_xmovkri16) {
+    return false;
+  }
+  optInsn.emplace_back(insnMov4);
+  return true;
+}
+
+bool LoadFloatPointPattern::IsPatternMatch() {
+  int insnNum = 0;
+  Insn *insn1 = optInsn[insnNum];
+  Insn *insn2 = optInsn[++insnNum];
+  Insn *insn3 = optInsn[++insnNum];
+  Insn *insn4 = optInsn[++insnNum];
+  if ((static_cast<RegOperand&>(insn1->GetOperand(kInsnFirstOpnd)).GetRegisterNumber() !=
+       static_cast<RegOperand&>(insn2->GetOperand(kInsnFirstOpnd)).GetRegisterNumber()) ||
+      (static_cast<RegOperand&>(insn2->GetOperand(kInsnFirstOpnd)).GetRegisterNumber() !=
+       static_cast<RegOperand&>(insn3->GetOperand(kInsnFirstOpnd)).GetRegisterNumber()) ||
+      (static_cast<RegOperand&>(insn3->GetOperand(kInsnFirstOpnd)).GetRegisterNumber() !=
+       static_cast<RegOperand&>(insn4->GetOperand(kInsnFirstOpnd)).GetRegisterNumber())) {
+    return false;
+  }
+  if ((static_cast<BitShiftOperand&>(insn1->GetOperand(kInsnThirdOpnd)).GetShiftAmount() != 0) ||
+      (static_cast<BitShiftOperand&>(insn2->GetOperand(kInsnThirdOpnd)).GetShiftAmount() != k16BitSize) ||
+      (static_cast<BitShiftOperand&>(insn3->GetOperand(kInsnThirdOpnd)).GetShiftAmount() != k32BitSize) ||
+      (static_cast<BitShiftOperand&>(insn4->GetOperand(kInsnThirdOpnd)).GetShiftAmount() !=
+       (k16BitSize + k32BitSize))) {
+    return false;
+  }
+  return true;
+}
+
+bool LoadFloatPointPattern::CheckCondition(Insn &insn) {
+  if (FindLoadFloatPoint(insn) && IsPatternMatch()) {
+    return true;
+  }
+  return false;
+}
+
+void LoadFloatPointPattern::Run(BB &bb, Insn &insn) {
+  /* logical shift left values in three optimized pattern */
+  if (CheckCondition(insn)) {
+    int insnNum = 0;
+    Insn *insn1 = optInsn[insnNum];
+    Insn *insn2 = optInsn[++insnNum];
+    Insn *insn3 = optInsn[++insnNum];
+    Insn *insn4 = optInsn[++insnNum];
+    auto &movConst1 = static_cast<ImmOperand&>(insn1->GetOperand(kInsnSecondOpnd));
+    auto &movConst2 = static_cast<ImmOperand&>(insn2->GetOperand(kInsnSecondOpnd));
+    auto &movConst3 = static_cast<ImmOperand&>(insn3->GetOperand(kInsnSecondOpnd));
+    auto &movConst4 = static_cast<ImmOperand&>(insn4->GetOperand(kInsnSecondOpnd));
+    /* movk/movz's immOpnd is 16-bit unsigned immediate */
+    uint64 value = static_cast<uint64>(movConst1.GetValue()) +
+                   (static_cast<uint64>(movConst2.GetValue()) << k16BitSize) +
+                   (static_cast<uint64>(movConst3.GetValue()) << k32BitSize) +
+                   (static_cast<uint64>(movConst4.GetValue()) << (k16BitSize + k32BitSize));
+
+    LabelIdx lableIdx = cgFunc->CreateLabel();
+    AArch64CGFunc *aarch64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+    LabelOperand &target = aarch64CGFunc->GetOrCreateLabelOperand(lableIdx);
+    cgFunc->InsertLabelMap(lableIdx, value);
+    Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(MOP_xldli, insn4->GetOperand(kInsnFirstOpnd),
+                                                                  target);
+    bb.InsertInsnAfter(*insn4, newInsn);
+    bb.RemoveInsn(*insn1);
+    bb.RemoveInsn(*insn2);
+    bb.RemoveInsn(*insn3);
+    bb.RemoveInsn(*insn4);
+  }
+}
+
+void ReplaceCmpToCmnAArch64::Run(BB &bb, Insn &insn) {
+  AArch64CGFunc *aarch64CGFunc = static_cast<AArch64CGFunc*>(&cgFunc);
+  MOperator thisMop = insn.GetMachineOpcode();
+  MOperator nextMop = MOP_undef;
+  MOperator newMop = MOP_undef;
+  uint64 negOne = UINT64_MAX;
+  switch (thisMop) {
+    case MOP_wmovri32: {
+      nextMop = MOP_wcmprr;
+      newMop = MOP_wcmnri;
+      negOne = UINT32_MAX;
+      break;
+    }
+    case MOP_xmovri64: {
+      nextMop = MOP_xcmprr;
+      newMop = MOP_xcmnri;
+      break;
+    }
+    default:
+      break;
+  }
+  Operand *opnd1OfMov = &(insn.GetOperand(kInsnFirstOpnd));
+  Operand *opnd2OfMov = &(insn.GetOperand(kInsnSecondOpnd));
+  if (opnd2OfMov->IsIntImmediate()) {
+    ImmOperand *immOpnd = static_cast<ImmOperand*>(opnd2OfMov);
+    int64 iVal = immOpnd->GetValue();
+    if ((kNegativeImmLowerLimit <= iVal && iVal < 0) || static_cast<uint64>(iVal) == negOne) {
+      Insn *nextInsn = insn.GetNextMachineInsn();  /* get the next insn to judge if it is a cmp instruction. */
+      if (nextInsn != nullptr) {
+        if (nextInsn->GetMachineOpcode() == nextMop) {
+          Operand *opndCmp2 = &(nextInsn->GetOperand(kInsnSecondOpnd));
+          Operand *opndCmp3 = &(nextInsn->GetOperand(kInsnThirdOpnd));  /* get the third operand of cmp */
+          /* if the first operand of mov equals the third operand of cmp, match the pattern. */
+          if (opnd1OfMov == opndCmp3) {
+            if (iVal == static_cast<int64>(negOne)) {
+              iVal = -1;
+            }
+            ImmOperand &newOpnd = aarch64CGFunc->CreateImmOperand(iVal * (-1), immOpnd->GetSize(), false);
+            Operand &regFlag = nextInsn->GetOperand(kInsnFirstOpnd);
+            bb.ReplaceInsn(*nextInsn, cgFunc.GetInsnBuilder()->BuildInsn(newMop, regFlag, *opndCmp2, newOpnd));
+          }
+        }
+      }
+    }
+  }
+}
+
+bool RemoveIncRefPattern::CheckCondition(Insn &insn) {
+  MOperator mOp = insn.GetMachineOpcode();
+  if (mOp != MOP_xbl) {
+    return false;
+  }
+  auto &target = static_cast<FuncNameOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  if (target.GetName() != "MCC_IncDecRef_NaiveRCFast") {
+    return false;
+  }
+  insnMov2 = insn.GetPreviousMachineInsn();
+  if (insnMov2 == nullptr) {
+    return false;
+  }
+  MOperator mopMov2 = insnMov2->GetMachineOpcode();
+  if (mopMov2 != MOP_xmovrr) {
+    return false;
+  }
+  insnMov1 = insnMov2->GetPreviousMachineInsn();
+  if (insnMov1 == nullptr) {
+    return false;
+  }
+  MOperator mopMov1 = insnMov1->GetMachineOpcode();
+  if (mopMov1 != MOP_xmovrr) {
+    return false;
+  }
+  if (static_cast<RegOperand&>(insnMov1->GetOperand(kInsnSecondOpnd)).GetRegisterNumber() !=
+      static_cast<RegOperand&>(insnMov2->GetOperand(kInsnSecondOpnd)).GetRegisterNumber()) {
+    return false;
+  }
+  auto &mov2Dest = static_cast<RegOperand&>(insnMov2->GetOperand(kInsnFirstOpnd));
+  auto &mov1Dest = static_cast<RegOperand&>(insnMov1->GetOperand(kInsnFirstOpnd));
+  if (mov1Dest.IsVirtualRegister() || mov2Dest.IsVirtualRegister() || mov1Dest.GetRegisterNumber() != R0 ||
+      mov2Dest.GetRegisterNumber() != R1) {
+    return false;
+  }
+  return true;
+}
+
+void RemoveIncRefPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  bb.RemoveInsn(insn);
+  bb.RemoveInsn(*insnMov2);
+  bb.RemoveInsn(*insnMov1);
+}
+
+bool LongIntCompareWithZPattern::FindLondIntCmpWithZ(Insn &insn) {
+  MOperator thisMop = insn.GetMachineOpcode();
+  optInsn.clear();
+  /* forth */
+  if (thisMop != MOP_wcmpri) {
+    return false;
+  }
+  (void)optInsn.emplace_back(&insn);
+
+  /* third */
+  Insn *preInsn1 = insn.GetPreviousMachineInsn();
+  if (preInsn1 == nullptr) {
+    return false;
+  }
+  MOperator preMop1 = preInsn1->GetMachineOpcode();
+  if (preMop1 != MOP_wcsincrrrc) {
+    return false;
+  }
+  (void)optInsn.emplace_back(preInsn1);
+
+  /* second */
+  Insn *preInsn2 = preInsn1->GetPreviousMachineInsn();
+  if (preInsn2 == nullptr) {
+    return false;
+  }
+  MOperator preMop2 = preInsn2->GetMachineOpcode();
+  if (preMop2 != MOP_wcsinvrrrc) {
+    return false;
+  }
+  (void)optInsn.emplace_back(preInsn2);
+
+  /* first */
+  Insn *preInsn3 = preInsn2->GetPreviousMachineInsn();
+  if (preInsn3 == nullptr) {
+    return false;
+  }
+  MOperator preMop3 = preInsn3->GetMachineOpcode();
+  if (preMop3 != MOP_xcmpri) {
+    return false;
+  }
+  (void)optInsn.emplace_back(preInsn3);
+  return true;
+}
+
+bool LongIntCompareWithZPattern::IsPatternMatch() {
+  constexpr int insnLen = 4;
+  if (optInsn.size() != insnLen) {
+    return false;
+  }
+  int insnNum = 0;
+  Insn *insn1 = optInsn[insnNum];
+  Insn *insn2 = optInsn[++insnNum];
+  Insn *insn3 = optInsn[++insnNum];
+  Insn *insn4 = optInsn[++insnNum];
+  ASSERT(insnNum == 3, " this specific case has three insns");
+  if (IsZeroRegister(insn3->GetOperand(kInsnSecondOpnd)) && IsZeroRegister(insn3->GetOperand(kInsnThirdOpnd)) &&
+      IsZeroRegister(insn2->GetOperand(kInsnThirdOpnd)) &&
+      &(insn2->GetOperand(kInsnFirstOpnd)) == &(insn2->GetOperand(kInsnSecondOpnd)) &&
+      static_cast<CondOperand&>(insn3->GetOperand(kInsnFourthOpnd)).GetCode() == CC_GE &&
+      static_cast<CondOperand&>(insn2->GetOperand(kInsnFourthOpnd)).GetCode() == CC_LE &&
+      static_cast<ImmOperand&>(insn1->GetOperand(kInsnThirdOpnd)).GetValue() == 0 &&
+      static_cast<ImmOperand&>(insn4->GetOperand(kInsnThirdOpnd)).GetValue() == 0) {
+    return true;
+  }
+  return false;
+}
+
+bool LongIntCompareWithZPattern::CheckCondition(Insn &insn) {
+  if (FindLondIntCmpWithZ(insn) && IsPatternMatch()) {
+    return true;
+  }
+  return false;
+}
+
+void LongIntCompareWithZPattern::Run(BB &bb, Insn &insn) {
+  /* found pattern */
+  if (CheckCondition(insn)) {
+    Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(optInsn[3]->GetMachineOpcode(),
+                                                        optInsn[3]->GetOperand(kInsnFirstOpnd),
+                                                        optInsn[3]->GetOperand(kInsnSecondOpnd),
+                                                        optInsn[3]->GetOperand(kInsnThirdOpnd));
+    /* use newInsn to replace  the third optInsn */
+    bb.ReplaceInsn(*optInsn[0], newInsn);
+    optInsn.clear();
+  }
+}
+
+void ComplexMemOperandAArch64::Run(BB &bb, Insn &insn) {
+  AArch64CGFunc *aarch64CGFunc = static_cast<AArch64CGFunc*>(&cgFunc);
+  Insn *nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr) {
+    return;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  if (thisMop != MOP_xadrpl12) {
+    return;
+  }
+
+  MOperator nextMop = nextInsn->GetMachineOpcode();
+  if (nextMop > 0 &&
+      ((nextMop >= MOP_wldrsb && nextMop <= MOP_dldp) || (nextMop >= MOP_wstrb && nextMop <= MOP_dstp))) {
+    /* Check if base register of nextInsn and the dest operand of insn are identical. */
+    MemOperand *memOpnd = static_cast<MemOperand*>(nextInsn->GetMemOpnd());
+    ASSERT(memOpnd != nullptr, "memOpnd is null in AArch64Peep::ComplexMemOperandAArch64");
+
+    /* Only for AddrMode_B_OI addressing mode. */
+    if (memOpnd->GetAddrMode() != MemOperand::kAddrModeBOi) {
+      return;
+    }
+
+    /* Only for intact memory addressing. */
+    if (!memOpnd->IsIntactIndexed()) {
+      return;
+    }
+
+    auto &regOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+
+    /* Avoid linking issues when object is not 16byte aligned */
+    if (memOpnd->GetSize() == k128BitSize) {
+      return;
+    }
+
+    /* Check if dest operand of insn is idential with base register of nextInsn. */
+    if (memOpnd->GetBaseRegister() != &regOpnd) {
+      return;
+    }
+
+    /* Check if x0 is used after ldr insn, and if it is in live-out. */
+    if (IfOperandIsLiveAfterInsn(regOpnd, *nextInsn)) {
+      return;
+    }
+
+    /* load store pairs cannot have relocation */
+    if (nextInsn->IsLoadStorePair() && insn.GetOperand(kInsnThirdOpnd).IsStImmediate()) {
+      return;
+    }
+
+    auto &stImmOpnd = static_cast<StImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+    OfstOperand &offOpnd = aarch64CGFunc->GetOrCreateOfstOpnd(
+        stImmOpnd.GetOffset() + memOpnd->GetOffsetImmediate()->GetOffsetValue(), k32BitSize);
+
+    /* do not guarantee rodata alignment at Os */
+    if (CGOptions::OptimizeForSize() && stImmOpnd.GetSymbol()->IsReadOnly()) {
+      return;
+    }
+
+    /* avoid relocation */
+    if ((offOpnd.GetValue() % static_cast<int8>(kBitsPerByte)) != 0) {
+      return;
+    }
+
+    if (cgFunc.GetMirModule().IsCModule()) {
+      Insn *prevInsn = insn.GetPrev();
+      MOperator prevMop = prevInsn->GetMachineOpcode();
+      if (prevMop != MOP_xadrp) {
+        return;
+      } else {
+        auto &prevStImmOpnd = static_cast<StImmOperand&>(prevInsn->GetOperand(kInsnSecondOpnd));
+        prevStImmOpnd.SetOffset(offOpnd.GetValue());
+      }
+    }
+    auto &newBaseOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+    MemOperand &newMemOpnd =
+        aarch64CGFunc->GetOrCreateMemOpnd(MemOperand::kAddrModeLo12Li, memOpnd->GetSize(),
+                                          &newBaseOpnd, nullptr, &offOpnd, stImmOpnd.GetSymbol());
+
+    nextInsn->SetMemOpnd(&newMemOpnd);
+    bb.RemoveInsn(insn);
+    CHECK_FATAL(!CGOptions::IsLazyBinding() || cgFunc.GetCG()->IsLibcore(),
+        "this pattern can't be found in this phase");
+  }
+}
+
+void ComplexMemOperandPreAddAArch64::Run(BB &bb, Insn &insn) {
+  AArch64CGFunc *aarch64CGFunc = static_cast<AArch64CGFunc*>(&cgFunc);
+  Insn *nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr) {
+    return;
+  }
+  MOperator thisMop = insn.GetMachineOpcode();
+  if (thisMop != MOP_xaddrrr && thisMop != MOP_waddrrr) {
+    return;
+  }
+  MOperator nextMop = nextInsn->GetMachineOpcode();
+  if (nextMop > 0 &&
+      ((nextMop >= MOP_wldrsb && nextMop <= MOP_dldr) || (nextMop >= MOP_wstrb && nextMop <= MOP_dstr))) {
+    if (!IsMemOperandOptPattern(insn, *nextInsn)) {
+      return;
+    }
+    MemOperand *memOpnd = static_cast<MemOperand*>(nextInsn->GetMemOpnd());
+    auto &newBaseOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+    if (newBaseOpnd.GetSize() != k64BitSize) {
+      return;
+    }
+    auto &newIndexOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd));
+    if (newIndexOpnd.GetSize() <= k32BitSize) {
+      MemOperand &newMemOpnd =
+          aarch64CGFunc->GetOrCreateMemOpnd(MemOperand::kAddrModeBOrX, memOpnd->GetSize(), &newBaseOpnd,
+                                            &newIndexOpnd, 0, false);
+      nextInsn->SetOperand(kInsnSecondOpnd, newMemOpnd);
+    } else {
+      auto *newOfstOpnd = &aarch64CGFunc->GetOrCreateOfstOpnd(0, k32BitSize);
+      MemOperand &newMemOpnd =
+          aarch64CGFunc->GetOrCreateMemOpnd(MemOperand::kAddrModeBOrX, memOpnd->GetSize(), &newBaseOpnd,
+                                            &newIndexOpnd, newOfstOpnd, nullptr);
+      nextInsn->SetOperand(kInsnSecondOpnd, newMemOpnd);
+    }
+    bb.RemoveInsn(insn);
+  }
+}
+
+static bool MayThrowBetweenInsn(const Insn &prevCallInsn, const Insn &currCallInsn) {
+  for (Insn *insn = prevCallInsn.GetNext(); insn != nullptr && insn != &currCallInsn; insn = insn->GetNext()) {
+    if (insn->MayThrow()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/*
+ * mov R0, vreg1 / R0      -> objDesignateInsn
+ * add vreg2, vreg1, #imm  -> fieldDesignateInsn
+ * mov R1, vreg2           -> fieldParamDefInsn
+ * mov R2, vreg3           -> fieldValueDefInsn
+ */
+bool WriteFieldCallPattern::WriteFieldCallOptPatternMatch(const Insn &writeFieldCallInsn, WriteRefFieldParam &param) {
+  Insn *fieldValueDefInsn = writeFieldCallInsn.GetPreviousMachineInsn();
+  if (fieldValueDefInsn == nullptr || fieldValueDefInsn->GetMachineOpcode() != MOP_xmovrr) {
+    return false;
+  }
+  Operand &fieldValueDefInsnDestOpnd = fieldValueDefInsn->GetOperand(kInsnFirstOpnd);
+  auto &fieldValueDefInsnDestReg = static_cast<RegOperand&>(fieldValueDefInsnDestOpnd);
+  if (fieldValueDefInsnDestReg.GetRegisterNumber() != R2) {
+    return false;
+  }
+  paramDefInsns.emplace_back(fieldValueDefInsn);
+  param.fieldValue = &(fieldValueDefInsn->GetOperand(kInsnSecondOpnd));
+  Insn *fieldParamDefInsn = fieldValueDefInsn->GetPreviousMachineInsn();
+  if (fieldParamDefInsn == nullptr || fieldParamDefInsn->GetMachineOpcode() != MOP_xmovrr) {
+    return false;
+  }
+  Operand &fieldParamDestOpnd = fieldParamDefInsn->GetOperand(kInsnFirstOpnd);
+  auto &fieldParamDestReg = static_cast<RegOperand&>(fieldParamDestOpnd);
+  if (fieldParamDestReg.GetRegisterNumber() != R1) {
+    return false;
+  }
+  paramDefInsns.emplace_back(fieldParamDefInsn);
+  Insn *fieldDesignateInsn = fieldParamDefInsn->GetPreviousMachineInsn();
+  if (fieldDesignateInsn == nullptr || fieldDesignateInsn->GetMachineOpcode() != MOP_xaddrri12) {
+    return false;
+  }
+  Operand &fieldParamDefSrcOpnd = fieldParamDefInsn->GetOperand(kInsnSecondOpnd);
+  Operand &fieldDesignateDestOpnd = fieldDesignateInsn->GetOperand(kInsnFirstOpnd);
+  if (!RegOperand::IsSameReg(fieldParamDefSrcOpnd, fieldDesignateDestOpnd)) {
+    return false;
+  }
+  Operand &fieldDesignateBaseOpnd = fieldDesignateInsn->GetOperand(kInsnSecondOpnd);
+  param.fieldBaseOpnd = &(static_cast<RegOperand&>(fieldDesignateBaseOpnd));
+  auto &immOpnd = static_cast<ImmOperand&>(fieldDesignateInsn->GetOperand(kInsnThirdOpnd));
+  param.fieldOffset = immOpnd.GetValue();
+  paramDefInsns.emplace_back(fieldDesignateInsn);
+  Insn *objDesignateInsn = fieldDesignateInsn->GetPreviousMachineInsn();
+  if (objDesignateInsn == nullptr || objDesignateInsn->GetMachineOpcode() != MOP_xmovrr) {
+    return false;
+  }
+  Operand &objDesignateDestOpnd = objDesignateInsn->GetOperand(kInsnFirstOpnd);
+  auto &objDesignateDestReg = static_cast<RegOperand&>(objDesignateDestOpnd);
+  if (objDesignateDestReg.GetRegisterNumber() != R0) {
+    return false;
+  }
+  Operand &objDesignateSrcOpnd = objDesignateInsn->GetOperand(kInsnSecondOpnd);
+  if (RegOperand::IsSameReg(objDesignateDestOpnd, objDesignateSrcOpnd) ||
+      !RegOperand::IsSameReg(objDesignateSrcOpnd, fieldDesignateBaseOpnd)) {
+    return false;
+  }
+  param.objOpnd = &(objDesignateInsn->GetOperand(kInsnSecondOpnd));
+  paramDefInsns.emplace_back(objDesignateInsn);
+  return true;
+}
+
+bool WriteFieldCallPattern::IsWriteRefFieldCallInsn(const Insn &insn) const {
+  if (!insn.IsCall() || insn.GetMachineOpcode() == MOP_xblr) {
+    return false;
+  }
+  Operand *targetOpnd = insn.GetCallTargetOperand();
+  ASSERT(targetOpnd != nullptr, "targetOpnd must not be nullptr");
+  if (!targetOpnd->IsFuncNameOpnd()) {
+    return false;
+  }
+  auto *target = static_cast<FuncNameOperand*>(targetOpnd);
+  const MIRSymbol *funcSt = target->GetFunctionSymbol();
+  ASSERT(funcSt->GetSKind() == kStFunc, "the kind of funcSt is unreasonable");
+  const std::string &funcName = funcSt->GetName();
+  return funcName == "MCC_WriteRefField" || funcName == "MCC_WriteVolatileField";
+}
+
+bool WriteFieldCallPattern::CheckCondition(Insn &insn) {
+  nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr) {
+    return false;
+  }
+  if (!IsWriteRefFieldCallInsn(insn)) {
+    return false;
+  }
+  if (!hasWriteFieldCall) {
+    if (!WriteFieldCallOptPatternMatch(insn, firstCallParam)) {
+      return false;
+    }
+    prevCallInsn = &insn;
+    hasWriteFieldCall = true;
+    return false;
+  }
+  if (!WriteFieldCallOptPatternMatch(insn, currentCallParam)) {
+    return false;
+  }
+  if (prevCallInsn == nullptr || MayThrowBetweenInsn(*prevCallInsn, insn)) {
+    return false;
+  }
+  if (firstCallParam.objOpnd == nullptr || currentCallParam.objOpnd == nullptr ||
+      currentCallParam.fieldBaseOpnd == nullptr) {
+    return false;
+  }
+  if (!RegOperand::IsSameReg(*firstCallParam.objOpnd, *currentCallParam.objOpnd)) {
+    return false;
+  }
+  return true;
+}
+
+void WriteFieldCallPattern::Run(BB &bb, Insn &insn) {
+  paramDefInsns.clear();
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto *aarCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  MemOperand &addr =
+      aarCGFunc->CreateMemOpnd(*currentCallParam.fieldBaseOpnd, currentCallParam.fieldOffset, k64BitSize);
+  Insn &strInsn = cgFunc->GetInsnBuilder()->BuildInsn(MOP_xstr, *currentCallParam.fieldValue, addr);
+  strInsn.AppendComment("store reference field");
+  strInsn.MarkAsAccessRefField(true);
+  bb.InsertInsnAfter(insn, strInsn);
+  for (Insn *paramDefInsn : paramDefInsns) {
+    bb.RemoveInsn(*paramDefInsn);
+  }
+  bb.RemoveInsn(insn);
+  prevCallInsn = &strInsn;
+  nextInsn = strInsn.GetNextMachineInsn();
+}
+
+bool RemoveDecRefPattern::CheckCondition(Insn &insn) {
+  if (insn.GetMachineOpcode() != MOP_xbl) {
+    return false;
+  }
+  auto &target = static_cast<FuncNameOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  if (target.GetName() != "MCC_DecRef_NaiveRCFast") {
+    return false;
+  }
+  prevInsn = insn.GetPreviousMachineInsn();
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  MOperator mopMov = prevInsn->GetMachineOpcode();
+  if ((mopMov != MOP_xmovrr && mopMov != MOP_xmovri64) ||
+      static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd)).GetRegisterNumber() != R0) {
+    return false;
+  }
+  Operand &srcOpndOfMov = prevInsn->GetOperand(kInsnSecondOpnd);
+  if (!IsZeroRegister(srcOpndOfMov) &&
+      !(srcOpndOfMov.IsImmediate() && static_cast<ImmOperand&>(srcOpndOfMov).GetValue() == 0)) {
+    return false;
+  }
+  return true;
+}
+
+void RemoveDecRefPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  bb.RemoveInsn(*prevInsn);
+  bb.RemoveInsn(insn);
+}
+
+bool ReplaceIncDecWithIncPattern::CheckCondition(Insn &insn) {
+  if (insn.GetMachineOpcode() != MOP_xbl) {
+    return false;
+  }
+  target = &static_cast<FuncNameOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  if (target->GetName() != "MCC_IncDecRef_NaiveRCFast") {
+    return false;
+  }
+  prevInsn = insn.GetPreviousMachineInsn();
+  if (prevInsn == nullptr) {
+    return false;
+  }
+  MOperator mopMov = prevInsn->GetMachineOpcode();
+  if (mopMov != MOP_xmovrr) {
+    return false;
+  }
+  if (static_cast<RegOperand&>(prevInsn->GetOperand(kInsnFirstOpnd)).GetRegisterNumber() != R1 ||
+      !IsZeroRegister(prevInsn->GetOperand(kInsnSecondOpnd))) {
+    return false;
+  }
+  return true;
+}
+
+void ReplaceIncDecWithIncPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  std::string funcName = "MCC_IncRef_NaiveRCFast";
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(funcName);
+  MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx, true);
+  if (st == nullptr) {
+    LogInfo::MapleLogger() << "WARNING: Replace IncDec With Inc fail due to no MCC_IncRef_NaiveRCFast func\n";
+    return;
+  }
+  bb.RemoveInsn(*prevInsn);
+  target->SetFunctionSymbol(*st);
+}
+
+void UbfxToUxtwPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  Insn *newInsn = &cgFunc->GetInsnBuilder()->BuildInsn(
+      MOP_xuxtw64, insn.GetOperand(kInsnFirstOpnd), insn.GetOperand(kInsnSecondOpnd));
+  bb.ReplaceInsn(insn, *newInsn);
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(&insn);
+    DumpAfterPattern(prevs, newInsn, nullptr);
+  }
+}
+
+bool UbfxToUxtwPattern::CheckCondition(Insn &insn) {
+  ImmOperand &imm0 = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  ImmOperand &imm1 = static_cast<ImmOperand&>(insn.GetOperand(kInsnFourthOpnd));
+  if ((imm0.GetValue() != 0) || (imm1.GetValue() != k32BitSize)) {
+    return false;
+  }
+  return true;
+}
+
+void UbfxAndCbzToTbzPattern::Run(BB &bb, Insn &insn) {
+  Operand &opnd2 = static_cast<Operand&>(insn.GetOperand(kInsnSecondOpnd));
+  ImmOperand &imm3 = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto &label = static_cast<LabelOperand&>(useInsn->GetOperand(kInsnSecondOpnd));
+  MOperator nextMop = useInsn->GetMachineOpcode();
+  switch (nextMop) {
+    case MOP_wcbz:
+    case MOP_xcbz:
+      newMop = opnd2.GetSize() == k64BitSize ? MOP_xtbz : MOP_wtbz;
+      break;
+    case MOP_wcbnz:
+    case MOP_xcbnz:
+      newMop = opnd2.GetSize() == k64BitSize ? MOP_xtbnz : MOP_wtbnz;
+      break;
+    default:
+      return;
+  }
+  if (newMop == MOP_undef) {
+    return;
+  }
+  Insn *newInsn = &cgFunc->GetInsnBuilder()->BuildInsn(newMop, opnd2, imm3, label);
+  BB *useInsnBB = useInsn->GetBB();
+  useInsnBB->ReplaceInsn(*useInsn, *newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(*useInsn, *newInsn);
+  optSuccess = true;
+  if (CG_PEEP_DUMP) {
+    std::vector<Insn*> prevs;
+    (void)prevs.emplace_back(useInsn);
+    DumpAfterPattern(prevs, newInsn, nullptr);
+  }
+}
+
+bool UbfxAndCbzToTbzPattern::CheckCondition(Insn &insn) {
+  ImmOperand &imm4 = static_cast<ImmOperand&>(insn.GetOperand(kInsnFourthOpnd));
+  RegOperand &opnd1 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  InsnSet useInsns = GetAllUseInsn(opnd1);
+  if (useInsns.size() != 1) {
+    return false;
+  }
+  useInsn = *useInsns.begin();
+  if (useInsn == nullptr) {
+    return false;
+  }
+  if (imm4.GetValue() == 1) {
+    switch (useInsn->GetMachineOpcode()) {
+      case MOP_wcbz:
+      case MOP_xcbz:
+      case MOP_wcbnz:
+      case MOP_xcbnz:
+        return true;
+      default:
+        break;
+    }
+  }
+  return false;
+}
+
+bool ComplexExtendWordLslAArch64::IsExtendWordLslPattern(const Insn &insn) const {
+  Insn *nextInsn = insn.GetNext();
+  if (nextInsn == nullptr) {
+    return false;
+  }
+  MOperator nextMop = nextInsn->GetMachineOpcode();
+  if (nextMop != MOP_xlslrri6) {
+    return false;
+  }
+  return true;
+}
+
+void ComplexExtendWordLslAArch64::Run(BB &bb, Insn &insn) {
+  if (!IsExtendWordLslPattern(insn)) {
+    return;
+  }
+  MOperator mop = insn.GetMachineOpcode();
+  Insn *nextInsn = insn.GetNext();
+  auto &nextOpnd2 = static_cast<ImmOperand&>(nextInsn->GetOperand(kInsnThirdOpnd));
+  if (nextOpnd2.GetValue() > k32BitSize) {
+    return;
+  }
+  auto &opnd0 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &nextOpnd1 = static_cast<RegOperand&>(nextInsn->GetOperand(kInsnSecondOpnd));
+  regno_t regNO0 = opnd0.GetRegisterNumber();
+  regno_t nextRegNO1 = nextOpnd1.GetRegisterNumber();
+  if (regNO0 != nextRegNO1 || IfOperandIsLiveAfterInsn(opnd0, *nextInsn)) {
+    return;
+  }
+  auto &opnd1 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  auto &nextOpnd0 = static_cast<RegOperand&>(nextInsn->GetOperand(kInsnFirstOpnd));
+  regno_t regNO1 = opnd1.GetRegisterNumber();
+  cgFunc.InsertExtendSet(regNO1);
+  MOperator mopNew = mop == MOP_xsxtw64 ? MOP_xsbfizrri6i6 : MOP_xubfizrri6i6;
+  auto *aarch64CGFunc = static_cast<AArch64CGFunc*>(&cgFunc);
+  RegOperand &reg1 = aarch64CGFunc->GetOrCreateVirtualRegisterOperand(regNO1);
+  ImmOperand &newImm = aarch64CGFunc->CreateImmOperand(k32BitSize, k6BitSize, false);
+  Insn &newInsnSbfiz = cgFunc.GetInsnBuilder()->BuildInsn(mopNew,
+      nextOpnd0, reg1, nextOpnd2, newImm);
+  bb.RemoveInsn(*nextInsn);
+  bb.ReplaceInsn(insn, newInsnSbfiz);
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_pgo_gen.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_pgo_gen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..68196db3bd7a135784da82cf0e8bd8cee1ce13ea
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_pgo_gen.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_pgo_gen.h"
+#include "aarch64_cg.h"
+namespace maplebe {
+
+void AArch64ProfGen::CreateClearIcall(BB &bb, const std::string &symName) {
+  auto *mirBuilder = f->GetFunction().GetModule()->GetMIRBuilder();
+  auto *voidPtrType = GlobalTables::GetTypeTable().GetVoidPtr();
+  auto *funcPtrSym = mirBuilder->GetOrCreateGlobalDecl(symName, *voidPtrType);
+  funcPtrSym->SetAttr(ATTR_weak);  // weak symbol
+  CHECK_FATAL(!bb.IsEmpty() || bb.IsUnreachable(), "empty first BB?");
+
+  auto *a64Func = static_cast<AArch64CGFunc*>(f);
+  RegOperand &tempReg = a64Func->GetOrCreatePhysicalRegisterOperand(R16, k64BitSize, kRegTyInt);
+  StImmOperand &funcPtrSymOpnd = a64Func->CreateStImmOperand(*funcPtrSym, 0, 0);
+  auto &adrpInsn = f->GetInsnBuilder()->BuildInsn(MOP_xadrp, tempReg, funcPtrSymOpnd);
+
+  Insn *firstI = bb.GetFirstMachineInsn();
+
+  while (firstI && firstI->GetNextMachineInsn() && firstI->GetNextMachineInsn()->IsStore()) {
+    firstI = firstI->GetPreviousMachineInsn();
+  }
+
+  if (firstI) {
+    (void)bb.InsertInsnAfter(*firstI, adrpInsn);
+  } else {
+    bb.InsertInsnBegin(adrpInsn);
+  }
+
+  /* load func ptr */
+  OfstOperand &funcPtrSymOfst = a64Func->CreateOfstOpnd(*funcPtrSym, 0, 0);
+  MemOperand *ldrOpnd = a64Func->CreateMemOperand(MemOperand::kAddrModeBOi, k64BitSize, tempReg,
+                                                  nullptr, &funcPtrSymOfst, funcPtrSym);
+  auto &ldrSymInsn = f->GetInsnBuilder()->BuildInsn(MOP_xldr, tempReg, *ldrOpnd);
+  (void)bb.InsertInsnAfter(adrpInsn, ldrSymInsn);
+
+  Insn *getAddressInsn = &ldrSymInsn;
+  if (CGOptions::IsPIC()) {
+    MemOperand *ldrOpndPic = a64Func->CreateMemOperand(MemOperand::kAddrModeBOi, k64BitSize, tempReg,
+                                                       nullptr, nullptr, nullptr);
+    auto &ldrSymPicInsn = f->GetInsnBuilder()->BuildInsn(MOP_xldr, tempReg, *ldrOpndPic);
+    (void)bb.InsertInsnAfter(ldrSymInsn, ldrSymPicInsn);
+    getAddressInsn = &ldrSymPicInsn;
+  }
+  /* call weak symbol */
+  auto &bInsn = f->GetInsnBuilder()->BuildInsn(MOP_xblr, tempReg);
+  (void)bb.InsertInsnAfter(*getAddressInsn, bInsn);
+}
+
+void AArch64ProfGen::CreateIcallForWeakSymbol(BB &bb, const std::string &symName) {
+  auto *mirBuilder = f->GetFunction().GetModule()->GetMIRBuilder();
+  auto *voidPtrType = GlobalTables::GetTypeTable().GetVoidPtr();
+  auto *funcPtrSym = mirBuilder->GetOrCreateGlobalDecl(symName, *voidPtrType);
+  funcPtrSym->SetAttr(ATTR_weak);  // weak symbol
+
+  CHECK_FATAL(!bb.IsEmpty() || bb.IsUnreachable(), "empty exit BB?");
+
+  Insn *lastI = bb.GetLastMachineInsn();
+  if (lastI) {
+    CHECK_FATAL(lastI->GetMachineOpcode() == MOP_xret || lastI->GetMachineOpcode() == MOP_tail_call_opt_xbl,
+        "check this return bb");
+  }
+
+  while (lastI && lastI->GetPreviousMachineInsn() &&
+      (lastI->GetPreviousMachineInsn()->IsLoad() ||
+      lastI->GetMachineOpcode() == MOP_pseudo_ret_int || lastI->GetMachineOpcode() == MOP_pseudo_ret_float)) {
+    lastI = lastI->GetPreviousMachineInsn();
+  }
+
+  auto *a64Func = static_cast<AArch64CGFunc*>(f);
+  /* load func ptr page */
+  RegOperand &tempReg = a64Func->GetOrCreatePhysicalRegisterOperand(R16, k64BitSize, kRegTyInt);
+  StImmOperand &funcPtrSymOpnd = a64Func->CreateStImmOperand(*funcPtrSym, 0, 0);
+  auto &adrpInsn = f->GetInsnBuilder()->BuildInsn(MOP_xadrp, tempReg, funcPtrSymOpnd);
+
+  if (lastI) {
+    (void)bb.InsertInsnBefore(*lastI, adrpInsn);
+  } else {
+    bb.InsertInsnBegin(adrpInsn);
+  }
+
+  /* load func ptr */
+  OfstOperand &funcPtrSymOfst = a64Func->CreateOfstOpnd(*funcPtrSym, 0, 0);
+  MemOperand *ldrOpnd = a64Func->CreateMemOperand(MemOperand::kAddrModeBOi, k64BitSize, tempReg,
+      nullptr, &funcPtrSymOfst, funcPtrSym);
+  Insn &ldrSymInsn = f->GetInsnBuilder()->BuildInsn(MOP_xldr, tempReg, *ldrOpnd);
+  (void)bb.InsertInsnAfter(adrpInsn, ldrSymInsn);
+
+  Insn *getAddressInsn = &ldrSymInsn;
+  if (CGOptions::IsPIC()) {
+    MemOperand *ldrOpndPic = a64Func->CreateMemOperand(MemOperand::kAddrModeBOi, k64BitSize, tempReg,
+                                                       nullptr, nullptr, nullptr);
+    CHECK_FATAL(ldrOpndPic != nullptr, "create mem failed");
+    Insn &ldrSymPicInsn = f->GetInsnBuilder()->BuildInsn(MOP_xldr, tempReg, *ldrOpndPic);
+    (void)bb.InsertInsnAfter(ldrSymInsn, ldrSymPicInsn);
+    getAddressInsn = &ldrSymPicInsn;
+  }
+  /* call weak symbol */
+  Insn &bInsn = f->GetInsnBuilder()->BuildInsn(MOP_xblr, tempReg);
+  (void)bb.InsertInsnAfter(*getAddressInsn, bInsn);
+}
+
+void AArch64ProfGen::InstrumentBB(BB &bb, MIRSymbol &countTab, uint32 offset) {
+  auto *a64Func = static_cast<AArch64CGFunc*>(f);
+  StImmOperand &funcPtrSymOpnd = a64Func->CreateStImmOperand(countTab, 0, 0);
+  CHECK_FATAL(offset <= kMaxPimm8, "profile BB number out of range!!!");
+  /* skip size */
+  uint32 ofStByteSize = (offset + 1U) << 3U;
+  ImmOperand &countOfst = a64Func->CreateImmOperand(ofStByteSize, k64BitSize, false);
+  auto &counterInsn = f->GetInsnBuilder()->BuildInsn(MOP_c_counter, funcPtrSymOpnd, countOfst);
+  bb.InsertInsnBegin(counterInsn);
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_phi_elimination.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_phi_elimination.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d2ca7adab7cdca45f4060899a15833323e6952c1
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_phi_elimination.cpp
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_phi_elimination.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+RegOperand &AArch64PhiEliminate::CreateTempRegForCSSA(RegOperand &oriOpnd) {
+  return *phiEliAlloc.New<RegOperand>(GetAndIncreaseTempRegNO(), oriOpnd.GetSize(), oriOpnd.GetRegisterType());
+}
+
+Insn &AArch64PhiEliminate::CreateMov(RegOperand &destOpnd, RegOperand &fromOpnd) {
+  ASSERT(destOpnd.GetRegisterType() == fromOpnd.GetRegisterType(), "do not support this move in aarch64");
+  bool is64bit = destOpnd.GetSize() == k64BitSize;
+  bool isFloat = destOpnd.IsOfFloatOrSIMDClass();
+  Insn *insn = nullptr;
+  if (destOpnd.GetSize() == k128BitSize) {
+    ASSERT(isFloat, "unexpect 128bit int operand in aarch64");
+    insn = &cgFunc->GetInsnBuilder()->BuildVectorInsn(MOP_vmovvv, AArch64CG::kMd[MOP_vmovvv]);
+    (void)insn->AddOpndChain(destOpnd).AddOpndChain(fromOpnd);
+    auto *vecSpecSrc = cgFunc->GetMemoryPool()->New<VectorRegSpec>(k128BitSize >> k3ByteSize, k8BitSize);
+    auto *vecSpecDest = cgFunc->GetMemoryPool()->New<VectorRegSpec>(k128BitSize >> k3ByteSize, k8BitSize);
+    (void)static_cast<VectorInsn*>(insn)->PushRegSpecEntry(vecSpecDest).PushRegSpecEntry(vecSpecSrc);
+  } else {
+    insn = &cgFunc->GetInsnBuilder()->BuildInsn(
+        is64bit ? isFloat ? MOP_xvmovd : MOP_xmovrr : isFloat ? MOP_xvmovs : MOP_wmovrr, destOpnd, fromOpnd);
+  }
+  /* copy remat info */
+  MaintainRematInfo(destOpnd, fromOpnd, true);
+  ASSERT(insn != nullptr, "create move insn failed");
+  insn->SetIsPhiMovInsn(true);
+  return *insn;
+}
+
+RegOperand &AArch64PhiEliminate::GetCGVirtualOpearnd(RegOperand &ssaOpnd, const Insn &curInsn) {
+  VRegVersion *ssaVersion = GetSSAInfo()->FindSSAVersion(ssaOpnd.GetRegisterNumber());
+  ASSERT(ssaVersion != nullptr, "find ssaVersion failed");
+  ASSERT(!ssaVersion->IsDeleted(), "ssaVersion has been deleted");
+  RegOperand *regForRecreate = &ssaOpnd;
+  if (curInsn.GetMachineOpcode() != MOP_asm &&
+      !curInsn.IsVectorOp() &&
+      !curInsn.IsSpecialIntrinsic() &&
+      ssaVersion->GetAllUseInsns().empty() &&
+      !curInsn.IsAtomic()) {
+    CHECK_FATAL(false, "plz delete dead version");
+  }
+  if (GetSSAInfo()->IsNoDefVReg(ssaOpnd.GetRegisterNumber())) {
+    regForRecreate = MakeRoomForNoDefVreg(ssaOpnd);
+  } else {
+    ASSERT(regForRecreate->IsSSAForm(), "Opnd is not in ssa form");
+  }
+  RegOperand &newReg = cgFunc->GetOrCreateVirtualRegisterOperand(*regForRecreate);
+
+  DUInsnInfo *defInfo = ssaVersion->GetDefInsnInfo();
+  Insn *defInsn = defInfo != nullptr ? defInfo->GetInsn() : nullptr;
+  /*
+   * case1 : both def/use
+   * case2 : inline-asm  (do not do aggressive optimization) "0"
+   * case3 : cc flag operand
+   */
+  if (defInsn != nullptr) {
+    /* case 1 */
+    uint32 defUseIdx = defInsn->GetBothDefUseOpnd();
+    if (defUseIdx != kInsnMaxOpnd) {
+      if (defInfo->GetOperands().count(defUseIdx) > 0) {
+        CHECK_FATAL(defInfo->GetOperands()[defUseIdx] == 1, "multiple definiation");
+        Operand &preOpnd = defInsn->GetOperand(defUseIdx);
+        ASSERT(preOpnd.IsRegister(), "unexpect operand type");
+        newReg.SetRegisterNumber(RecursiveBothDU(static_cast<RegOperand&>(preOpnd)));
+      }
+    }
+    /* case 2 */
+    if (defInsn->GetMachineOpcode() == MOP_asm) {
+      auto &inputList = static_cast<const ListOperand&>(defInsn->GetOperand(kAsmInputListOpnd));
+      VRegVersion *lastVersion = nullptr;
+      for (auto &inputReg : inputList.GetOperands()) {
+        lastVersion = GetSSAInfo()->FindSSAVersion(inputReg->GetRegisterNumber());
+        if (lastVersion != nullptr && lastVersion->GetOriginalRegNO() == ssaVersion->GetOriginalRegNO()) {
+          break;
+        }
+        lastVersion = nullptr;
+      }
+      if (lastVersion != nullptr) {
+        newReg.SetRegisterNumber(lastVersion->GetSSAvRegOpnd()->GetRegisterNumber());
+      } else {
+        const MapleMap<uint32, uint32>& bindingMap = defInsn->GetRegBinding();
+        auto pairIt = bindingMap.find(ssaVersion->GetOriginalRegNO());
+        if (pairIt != bindingMap.end()) {
+          newReg.SetRegisterNumber(pairIt->second);
+        }
+      }
+    }
+    /* case 3 */
+    if (ssaVersion->GetOriginalRegNO() == kRFLAG) {
+      newReg.SetRegisterNumber(kRFLAG);
+    }
+  } else {
+    newReg.SetRegisterNumber(ssaVersion->GetOriginalRegNO());
+  }
+  MaintainRematInfo(newReg, ssaOpnd, true);
+  newReg.SetOpndOutOfSSAForm();
+  return newReg;
+}
+
+void AArch64PhiEliminate::AppendMovAfterLastVregDef(BB &bb, Insn &movInsn) const {
+  Insn *posInsn = nullptr;
+  bool isPosPhi = false;
+  FOR_BB_INSNS_REV(insn, &bb) {
+    if (insn->IsPhi()) {
+      posInsn = insn;
+      isPosPhi = true;
+      break;
+    }
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    if (insn->IsBranch()) {
+      posInsn = insn;
+      continue;
+    }
+    break;
+  }
+  CHECK_FATAL(posInsn != nullptr, "insert mov for phi failed");
+  if (isPosPhi) {
+    bb.InsertInsnAfter(*posInsn, movInsn);
+  } else {
+    bb.InsertInsnBefore(*posInsn, movInsn);
+  }
+}
+
+/* copy remat info */
+void AArch64PhiEliminate::MaintainRematInfo(RegOperand &destOpnd, RegOperand &fromOpnd, bool isCopy) {
+  if (CGOptions::GetRematLevel() > 0 && isCopy) {
+    if (fromOpnd.IsSSAForm()) {
+      VRegVersion *fromSSAVersion = GetSSAInfo()->FindSSAVersion(fromOpnd.GetRegisterNumber());
+      ASSERT(fromSSAVersion != nullptr, "fromSSAVersion should not be nullptr");
+      regno_t rematRegNO = fromSSAVersion->GetOriginalRegNO();
+      MIRPreg *fPreg = static_cast<AArch64CGFunc*>(cgFunc)->GetPseudoRegFromVirtualRegNO(rematRegNO);
+      if (fPreg != nullptr) {
+        PregIdx fPregIdx = cgFunc->GetFunction().GetPregTab()->GetPregIdxFromPregno(
+            static_cast<uint32>(fPreg->GetPregNo()));
+        RecordRematInfo(destOpnd.GetRegisterNumber(), fPregIdx);
+      }
+    } else {
+      regno_t rematRegNO = fromOpnd.GetRegisterNumber();
+      PregIdx fPreg = FindRematInfo(rematRegNO);
+      if (fPreg > 0) {
+        RecordRematInfo(destOpnd.GetRegisterNumber(), fPreg);
+      }
+    }
+  }
+}
+
+void AArch64PhiEliminate::ReCreateRegOperand(Insn &insn) {
+  auto opndNum = static_cast<int32>(insn.GetOperandSize());
+  for (int i = opndNum - 1; i >= 0; --i) {
+    Operand &opnd = insn.GetOperand(static_cast<uint32>(i));
+    A64OperandPhiElmVisitor a64OpndPhiElmVisitor(this, insn, i);
+    opnd.Accept(a64OpndPhiElmVisitor);
+  }
+}
+
+void A64OperandPhiElmVisitor::Visit(RegOperand *v) {
+  if (v->IsSSAForm()) {
+    ASSERT(v->GetRegisterNumber() != kRFLAG, "both condi and reg");
+    insn->SetOperand(idx, a64PhiEliminator->GetCGVirtualOpearnd(*v, *insn));
+  }
+}
+
+void A64OperandPhiElmVisitor::Visit(ListOperand *v) {
+  std::list<RegOperand*> tempRegStore;
+  auto& opndList = v->GetOperands();
+
+  while (!opndList.empty()) {
+    auto *regOpnd = opndList.front();
+    opndList.pop_front();
+
+    if (regOpnd->IsSSAForm()) {
+      tempRegStore.push_back(&a64PhiEliminator->GetCGVirtualOpearnd(*regOpnd, *insn));
+    } else {
+      tempRegStore.push_back(regOpnd);
+    }
+  }
+
+  ASSERT(v->GetOperands().empty(), "need to clean list");
+  v->GetOperands().assign(tempRegStore.begin(), tempRegStore.end());
+}
+
+void A64OperandPhiElmVisitor::Visit(MemOperand *a64MemOpnd) {
+  RegOperand *baseRegOpnd = a64MemOpnd->GetBaseRegister();
+  RegOperand *indexRegOpnd = a64MemOpnd->GetIndexRegister();
+  if ((baseRegOpnd != nullptr && baseRegOpnd->IsSSAForm()) ||
+      (indexRegOpnd != nullptr && indexRegOpnd->IsSSAForm())) {
+    if (baseRegOpnd != nullptr && baseRegOpnd->IsSSAForm()) {
+      a64MemOpnd->SetBaseRegister(a64PhiEliminator->GetCGVirtualOpearnd(*baseRegOpnd, *insn));
+    }
+    if (indexRegOpnd != nullptr && indexRegOpnd->IsSSAForm()) {
+      a64MemOpnd->SetIndexRegister(a64PhiEliminator->GetCGVirtualOpearnd(*indexRegOpnd, *insn));
+    }
+  }
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5918ed14881e9bb0e086ce04f3ce50d2c396b0ab
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
@@ -0,0 +1,1192 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_proepilog.h"
+#include "aarch64_cg.h"
+#include "cg_option.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+namespace {
+
+constexpr int32 kSoeChckOffset = 8192;
+
+enum RegsPushPop : uint8 {
+  kRegsPushOp,
+  kRegsPopOp
+};
+
+enum PushPopType : uint8 {
+  kPushPopSingle = 0,
+  kPushPopPair = 1
+};
+
+MOperator pushPopOps[kRegsPopOp + 1][kRegTyFloat + 1][kPushPopPair + 1] = {
+  { /* push */
+      { 0 }, /* undef */
+      { /* kRegTyInt */
+        MOP_xstr, /* single */
+        MOP_xstp, /* pair   */
+      },
+      { /* kRegTyFloat */
+        MOP_dstr, /* single */
+        MOP_dstp, /* pair   */
+      },
+  },
+  { /* pop */
+      { 0 }, /* undef */
+      { /* kRegTyInt */
+        MOP_xldr, /* single */
+        MOP_xldp, /* pair   */
+      },
+      { /* kRegTyFloat */
+        MOP_dldr, /* single */
+        MOP_dldp, /* pair   */
+      },
+  }
+};
+
+inline void AppendInstructionTo(Insn &insn, CGFunc &func) {
+  func.GetCurBB()->AppendInsn(insn);
+}
+}
+
+bool AArch64GenProEpilog::NeedProEpilog() {
+  if (cgFunc.GetMirModule().GetSrcLang() != kSrcLangC) {
+    return true;
+  } else if (cgFunc.GetFunction().GetAttr(FUNCATTR_varargs) || cgFunc.HasVLAOrAlloca()) {
+    return true;
+  }
+  bool funcHasCalls = false;
+  /* note that tailcall insn is not a call */
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS_REV(insn, bb) {
+      if (insn->IsMachineInstruction() && insn->IsCall()) {
+        funcHasCalls = true;
+      }
+    }
+  }
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  const MapleVector<AArch64reg> &regsToRestore = (aarchCGFunc.GetProEpilogSavedRegs().empty()) ?
+      aarchCGFunc.GetCalleeSavedRegs() : aarchCGFunc.GetProEpilogSavedRegs();
+  size_t calleeSavedRegSize = kTwoRegister;
+  CHECK_FATAL(regsToRestore.size() >= calleeSavedRegSize, "Forgot FP and LR ?");
+  if (funcHasCalls || regsToRestore.size() > calleeSavedRegSize || aarchCGFunc.HasStackLoadStore() ||
+      static_cast<AArch64MemLayout *>(cgFunc.GetMemlayout())->GetSizeOfLocals() > 0 ||
+      cgFunc.GetFunction().GetAttr(FUNCATTR_callersensitive)) {
+    return true;
+  }
+  return false;
+}
+MemOperand *AArch64GenProEpilog::GetDownStack() {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  uint64 vArea = 0;
+  if (cgFunc.GetMirModule().IsCModule() && cgFunc.GetFunction().GetAttr(FUNCATTR_varargs)) {
+    AArch64MemLayout *ml = static_cast<AArch64MemLayout *>(cgFunc.GetMemlayout());
+    if (ml->GetSizeOfGRSaveArea() > 0) {
+      vArea += RoundUp(ml->GetSizeOfGRSaveArea(), kAarch64StackPtrAlignment);
+    }
+    if (ml->GetSizeOfVRSaveArea() > 0) {
+      vArea += RoundUp(ml->GetSizeOfVRSaveArea(), kAarch64StackPtrAlignment);
+    }
+  }
+
+  int32 stkSize = static_cast<int32>(static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize());
+  if (useFP) {
+    stkSize -= static_cast<int32>(static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->SizeOfArgsToStackPass());
+  }
+  int32 memSize = (stkSize - kOffset8MemPos) - static_cast<int32>(vArea);
+  MemOperand *downStk = aarchCGFunc.CreateStackMemOpnd(stackBaseReg, memSize, GetPointerSize() * kBitsPerByte);
+  if (downStk->GetMemVaryType() == kNotVary &&
+      aarchCGFunc.IsImmediateOffsetOutOfRange(*downStk, k64BitSize)) {
+    downStk = &aarchCGFunc.SplitOffsetWithAddInstruction(*downStk, k64BitSize, R10);
+  }
+  return downStk;
+}
+
+void AArch64GenProEpilog::GenStackGuard() {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  aarchCGFunc.GetDummyBB()->ClearInsns();
+  cgFunc.SetCurBB(*aarchCGFunc.GetDummyBB());
+
+  MIRSymbol *stkGuardSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetStrIdxFromName(std::string("__stack_chk_guard")));
+  StImmOperand &stOpnd = aarchCGFunc.CreateStImmOperand(*stkGuardSym, 0, 0);
+  RegOperand &stAddrOpnd =
+    aarchCGFunc.GetOrCreatePhysicalRegisterOperand(R9, GetPointerSize() * kBitsPerByte, kRegTyInt);
+  aarchCGFunc.SelectAddrof(stAddrOpnd, stOpnd);
+
+  MemOperand *guardMemOp =
+    aarchCGFunc.CreateMemOperand(MemOperand::kAddrModeBOi, GetPointerSize() * kBitsPerByte,
+        stAddrOpnd, nullptr, &aarchCGFunc.GetOrCreateOfstOpnd(0, k32BitSize), stkGuardSym);
+  MOperator mOp = aarchCGFunc.PickLdInsn(k64BitSize, PTY_u64);
+  Insn &insn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, stAddrOpnd, *guardMemOp);
+  insn.SetDoNotRemove(true);
+  cgFunc.GetCurBB()->AppendInsn(insn);
+}
+
+void AArch64GenProEpilog::AddStackGuard(BB &bb) {
+  if (!stackProtect) {
+    return;
+  }
+  BB *formerCurBB = cgFunc.GetCurBB();
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  aarchCGFunc.GetDummyBB()->SetIsProEpilog(true);
+  GenStackGuard();
+  RegOperand &stAddrOpnd =
+    aarchCGFunc.GetOrCreatePhysicalRegisterOperand(R9, GetPointerSize() * kBitsPerByte, kRegTyInt);
+  auto mOp = aarchCGFunc.PickStInsn(GetPointerSize() * kBitsPerByte, PTY_u64);
+  Insn &tmpInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, stAddrOpnd, *GetDownStack());
+  tmpInsn.SetDoNotRemove(true);
+  cgFunc.GetCurBB()->AppendInsn(tmpInsn);
+
+  bb.InsertAtBeginning(*aarchCGFunc.GetDummyBB());
+  aarchCGFunc.GetDummyBB()->SetIsProEpilog(false);
+  cgFunc.SetCurBB(*formerCurBB);
+}
+
+BB &AArch64GenProEpilog::GenStackGuardCheckInsn(BB &bb) {
+  if (!stackProtect) {
+    return bb;
+  }
+
+  BB *formerCurBB = cgFunc.GetCurBB();
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  GenStackGuard();
+  RegOperand &stAddrOpnd =
+    aarchCGFunc.GetOrCreatePhysicalRegisterOperand(R9, GetPointerSize() * kBitsPerByte, kRegTyInt);
+  RegOperand &checkOp =
+      aarchCGFunc.GetOrCreatePhysicalRegisterOperand(R10, GetPointerSize() * kBitsPerByte, kRegTyInt);
+  auto mOp = aarchCGFunc.PickLdInsn(GetPointerSize() * kBitsPerByte, PTY_u64);
+  Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, checkOp, *GetDownStack());
+  newInsn.SetDoNotRemove(true);
+  cgFunc.GetCurBB()->AppendInsn(newInsn);
+
+  cgFunc.SelectBxor(stAddrOpnd, stAddrOpnd, checkOp, PTY_u64);
+  LabelIdx failLable = aarchCGFunc.CreateLabel();
+  aarchCGFunc.SelectCondGoto(aarchCGFunc.GetOrCreateLabelOperand(failLable), OP_brtrue, OP_ne,
+                             stAddrOpnd, aarchCGFunc.CreateImmOperand(0, k64BitSize, false), PTY_u64, false);
+
+  bb.AppendBBInsns(*(cgFunc.GetCurBB()));
+
+  LabelIdx nextBBLableIdx = aarchCGFunc.CreateLabel();
+  BB *nextBB = cgFunc.CreateNewBB(nextBBLableIdx, bb.IsUnreachable(), BB::kBBFallthru, bb.GetFrequency());
+  bb.AppendBB(*nextBB);
+  bb.PushBackSuccs(*nextBB);
+  nextBB->PushBackPreds(bb);
+  if (cgFunc.GetLastBB() == &bb) {
+    cgFunc.SetLastBB(*nextBB);
+  }
+
+  BB *newBB = aarchCGFunc.CreateNewBB(failLable, bb.IsUnreachable(), bb.GetKind(), bb.GetFrequency());
+  cgFunc.SetCurBB(*newBB);
+  MIRSymbol *failFunc = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetStrIdxFromName(std::string("__stack_chk_fail")));
+  ListOperand *srcOpnds = aarchCGFunc.CreateListOpnd(*cgFunc.GetFuncScopeAllocator());
+  Insn &callInsn = aarchCGFunc.AppendCall(*failFunc, *srcOpnds);
+  callInsn.SetDoNotRemove(true);
+  nextBB->AppendBB(*newBB);
+  bb.PushBackSuccs(*newBB);
+  nextBB->PushBackSuccs(*newBB);
+  newBB->PushBackPreds(*nextBB);
+  newBB->PushBackPreds(bb);
+
+  bb.SetKind(BB::kBBIf);
+  cgFunc.SetCurBB(*formerCurBB);
+  return *nextBB;
+}
+
+MemOperand *AArch64GenProEpilog::SplitStpLdpOffsetForCalleeSavedWithAddInstruction(CGFunc &cgFunc,
+    const MemOperand &mo, uint32 bitLen, AArch64reg baseRegNum) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CHECK_FATAL(mo.GetAddrMode() == MemOperand::kAddrModeBOi, "mode should be kAddrModeBOi");
+  OfstOperand *ofstOp = mo.GetOffsetImmediate();
+  int32 offsetVal = static_cast<int32>(ofstOp->GetOffsetValue());
+  CHECK_FATAL(offsetVal > 0, "offsetVal should be greater than 0");
+  CHECK_FATAL((static_cast<uint32>(offsetVal) & 0x7) == 0, "(offsetVal & 0x7) should be equal to 0");
+  /*
+   * Offset adjustment due to FP/SP has already been done
+   * in AArch64GenProEpilog::GeneratePushRegs() and AArch64GenProEpilog::GeneratePopRegs()
+   */
+  RegOperand &br = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(baseRegNum, bitLen, kRegTyInt);
+  if (aarchCGFunc.GetSplitBaseOffset() == 0) {
+    aarchCGFunc.SetSplitBaseOffset(offsetVal);  /* remember the offset; don't forget to clear it */
+    ImmOperand &immAddEnd = aarchCGFunc.CreateImmOperand(offsetVal, k64BitSize, true);
+    RegOperand *origBaseReg = mo.GetBaseRegister();
+    aarchCGFunc.SelectAdd(br, *origBaseReg, immAddEnd, PTY_i64);
+  }
+  offsetVal = offsetVal - aarchCGFunc.GetSplitBaseOffset();
+  return &aarchCGFunc.CreateReplacementMemOperand(bitLen, br, offsetVal);
+}
+
+void AArch64GenProEpilog::AppendInstructionPushPair(CGFunc &cgFunc,
+    AArch64reg reg0, AArch64reg reg1, RegType rty, int32 offset) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  MOperator mOp = pushPopOps[kRegsPushOp][rty][kPushPopPair];
+  Operand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, GetPointerSize() * kBitsPerByte, rty);
+  Operand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, GetPointerSize() * kBitsPerByte, rty);
+  Operand *o2 = &aarchCGFunc.CreateStkTopOpnd(static_cast<uint32>(offset), GetPointerSize() * kBitsPerByte);
+
+  uint32 dataSize = GetPointerSize() * kBitsPerByte;
+  CHECK_FATAL(offset >= 0, "offset must >= 0");
+  if (offset > kStpLdpImm64UpperBound) {
+    o2 = SplitStpLdpOffsetForCalleeSavedWithAddInstruction(cgFunc, *static_cast<MemOperand*>(o2), dataSize, R16);
+  }
+  Insn &pushInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, *o2);
+  std::string comment = "SAVE CALLEE REGISTER PAIR";
+  pushInsn.SetComment(comment);
+  AppendInstructionTo(pushInsn, cgFunc);
+}
+
+void AArch64GenProEpilog::AppendInstructionPushSingle(CGFunc &cgFunc,
+    AArch64reg reg, RegType rty, int32 offset) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  MOperator mOp = pushPopOps[kRegsPushOp][rty][kPushPopSingle];
+  Operand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg, GetPointerSize() * kBitsPerByte, rty);
+  Operand *o1 = &aarchCGFunc.CreateStkTopOpnd(static_cast<uint32>(offset), GetPointerSize() * kBitsPerByte);
+
+  MemOperand *aarchMemO1 = static_cast<MemOperand*>(o1);
+  uint32 dataSize = GetPointerSize() * kBitsPerByte;
+  if (aarchMemO1->GetMemVaryType() == kNotVary &&
+      aarchCGFunc.IsImmediateOffsetOutOfRange(*aarchMemO1, dataSize)) {
+    o1 = &aarchCGFunc.SplitOffsetWithAddInstruction(*aarchMemO1, dataSize, R16);
+  }
+
+  Insn &pushInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, *o1);
+  std::string comment = "SAVE CALLEE REGISTER";
+  pushInsn.SetComment(comment);
+  AppendInstructionTo(pushInsn, cgFunc);
+}
+
+Insn &AArch64GenProEpilog::AppendInstructionForAllocateOrDeallocateCallFrame(int64 argsToStkPassSize,
+                                                                             AArch64reg reg0, AArch64reg reg1,
+                                                                             RegType rty, bool isAllocate) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  MOperator mOp = isAllocate ? pushPopOps[kRegsPushOp][rty][kPushPopPair] : pushPopOps[kRegsPopOp][rty][kPushPopPair];
+  uint8 size;
+  if (CGOptions::IsArm64ilp32()) {
+    size = k8ByteSize;
+  } else {
+    size = GetPointerSize();
+  }
+  if (argsToStkPassSize <= kStrLdrImm64UpperBound - kOffset8MemPos) {
+    mOp = isAllocate ? pushPopOps[kRegsPushOp][rty][kPushPopSingle] : pushPopOps[kRegsPopOp][rty][kPushPopSingle];
+    RegOperand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, size * kBitsPerByte, rty);
+    MemOperand *o2 = aarchCGFunc.CreateStackMemOpnd(RSP, static_cast<int32>(argsToStkPassSize), size * kBitsPerByte);
+    Insn &insn1 = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, *o2);
+    AppendInstructionTo(insn1, cgFunc);
+    RegOperand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, size * kBitsPerByte, rty);
+    o2 = aarchCGFunc.CreateStackMemOpnd(RSP, static_cast<int32>(argsToStkPassSize + size),
+                                        size * kBitsPerByte);
+    Insn &insn2 = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o1, *o2);
+    AppendInstructionTo(insn2, cgFunc);
+    return insn2;
+  } else {
+    RegOperand &oo = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(R9, size * kBitsPerByte, kRegTyInt);
+    ImmOperand &io1 = aarchCGFunc.CreateImmOperand(argsToStkPassSize, k64BitSize, true);
+    aarchCGFunc.SelectCopyImm(oo, io1, PTY_i64);
+    RegOperand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, size * kBitsPerByte, rty);
+    RegOperand &rsp = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, size * kBitsPerByte, kRegTyInt);
+    MemOperand *mo = aarchCGFunc.CreateMemOperand(
+        MemOperand::kAddrModeBOrX, size * kBitsPerByte, rsp, oo, 0);
+    Insn &insn1 = cgFunc.GetInsnBuilder()->BuildInsn(isAllocate ? MOP_xstr : MOP_xldr, o0, *mo);
+    AppendInstructionTo(insn1, cgFunc);
+    ImmOperand &io2 = aarchCGFunc.CreateImmOperand(size, k64BitSize, true);
+    aarchCGFunc.SelectAdd(oo, oo, io2, PTY_i64);
+    RegOperand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, size * kBitsPerByte, rty);
+    mo = aarchCGFunc.CreateMemOperand(MemOperand::kAddrModeBOrX,
+                                      size * kBitsPerByte, rsp, oo, 0);
+    Insn &insn2 = cgFunc.GetInsnBuilder()->BuildInsn(isAllocate ? MOP_xstr : MOP_xldr, o1, *mo);
+    AppendInstructionTo(insn2, cgFunc);
+    return insn2;
+  }
+}
+
+Insn &AArch64GenProEpilog::CreateAndAppendInstructionForAllocateCallFrame(int64 argsToStkPassSize,
+                                                                          AArch64reg reg0, AArch64reg reg1,
+                                                                          RegType rty) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  MOperator mOp = pushPopOps[kRegsPushOp][rty][kPushPopPair];
+  Insn *allocInsn = nullptr;
+  if (argsToStkPassSize > kStpLdpImm64UpperBound) {
+    allocInsn = &AppendInstructionForAllocateOrDeallocateCallFrame(argsToStkPassSize, reg0, reg1, rty, true);
+  } else {
+    Operand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, GetPointerSize() * kBitsPerByte, rty);
+    Operand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, GetPointerSize() * kBitsPerByte, rty);
+    Operand *o2 = aarchCGFunc.CreateStackMemOpnd(RSP, static_cast<int32>(argsToStkPassSize),
+                                                 GetPointerSize() * kBitsPerByte);
+    allocInsn = &cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, *o2);
+    AppendInstructionTo(*allocInsn, cgFunc);
+  }
+  if (currCG->InstrumentWithDebugTraceCall()) {
+    aarchCGFunc.AppendCall(*currCG->GetDebugTraceEnterFunction());
+  }
+  return *allocInsn;
+}
+
+void AArch64GenProEpilog::AppendInstructionAllocateCallFrame(AArch64reg reg0, AArch64reg reg1, RegType rty) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  if (currCG->GenerateVerboseCG()) {
+    auto &comment = cgFunc.GetOpndBuilder()->CreateComment("allocate activation frame");
+    cgFunc.GetCurBB()->AppendInsn(cgFunc.GetInsnBuilder()->BuildCommentInsn(comment));
+  }
+
+  Insn *ipoint = nullptr;
+  /*
+   * stackFrameSize includes the size of args to stack-pass
+   * if a function has neither VLA nor alloca.
+   */
+  int32 stackFrameSize = static_cast<int32>(
+      static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize());
+  int64 argsToStkPassSize = cgFunc.GetMemlayout()->SizeOfArgsToStackPass();
+  /*
+   * ldp/stp's imm should be within -512 and 504;
+   * if stp's imm > 512, we fall back to the stp-sub version
+   */
+  bool useStpSub = false;
+  int64 offset = 0;
+  if (!cgFunc.HasVLAOrAlloca() && argsToStkPassSize > 0) {
+    /*
+     * stack_frame_size == size of formal parameters + callee-saved (including FP/RL)
+     *                     + size of local vars
+     *                     + size of actuals
+     * (when passing more than 8 args, its caller's responsibility to
+     *  allocate space for it. size of actuals represent largest such size in the function.
+     */
+    Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+    Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+    aarchCGFunc.SelectSub(spOpnd, spOpnd, immOpnd, PTY_u64);
+    ipoint = cgFunc.GetCurBB()->GetLastInsn();
+  } else {
+    if (stackFrameSize > kStpLdpImm64UpperBound) {
+      useStpSub = true;
+      offset = kOffset16MemPos;
+      stackFrameSize -= offset;
+    } else {
+      offset = stackFrameSize;
+    }
+    MOperator mOp = pushPopOps[kRegsPushOp][rty][kPushPopPair];
+    RegOperand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, GetPointerSize() * kBitsPerByte, rty);
+    RegOperand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, GetPointerSize() * kBitsPerByte, rty);
+    MemOperand &o2 = aarchCGFunc.CreateCallFrameOperand(static_cast<int32>(-offset), GetPointerSize() * kBitsPerByte);
+    ipoint = &cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, o2);
+    AppendInstructionTo(*ipoint, cgFunc);
+    if (currCG->InstrumentWithDebugTraceCall()) {
+      aarchCGFunc.AppendCall(*currCG->GetDebugTraceEnterFunction());
+    }
+  }
+  ipoint->SetStackDef(true);
+
+  if (!cgFunc.HasVLAOrAlloca() && argsToStkPassSize > 0) {
+    CHECK_FATAL(!useStpSub, "Invalid assumption");
+    ipoint = &CreateAndAppendInstructionForAllocateCallFrame(argsToStkPassSize, reg0, reg1, rty);
+  }
+
+  CHECK_FATAL(ipoint != nullptr, "ipoint should not be nullptr at this point");
+  if (useStpSub) {
+    Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+    Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+    aarchCGFunc.SelectSub(spOpnd, spOpnd, immOpnd, PTY_u64);
+    ipoint = cgFunc.GetCurBB()->GetLastInsn();
+    aarchCGFunc.SetUsedStpSubPairForCallFrameAllocation(true);
+    ipoint->SetStackDef(true);
+  }
+}
+
+void AArch64GenProEpilog::AppendInstructionAllocateCallFrameDebug(AArch64reg reg0, AArch64reg reg1, RegType rty) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  if (currCG->GenerateVerboseCG()) {
+    auto &comment = cgFunc.GetOpndBuilder()->CreateComment("allocate activation frame for debugging");
+    cgFunc.GetCurBB()->AppendInsn(cgFunc.GetInsnBuilder()->BuildCommentInsn(comment));
+  }
+
+  int32 stackFrameSize = static_cast<int32>(
+      static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize());
+  int64 argsToStkPassSize = cgFunc.GetMemlayout()->SizeOfArgsToStackPass();
+
+  Insn *ipoint = nullptr;
+
+  if (argsToStkPassSize > 0) {
+    Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+    Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+    aarchCGFunc.SelectSub(spOpnd, spOpnd, immOpnd, PTY_u64);
+    ipoint = cgFunc.GetCurBB()->GetLastInsn();
+    ipoint->SetStackDef(true);
+    ipoint = &CreateAndAppendInstructionForAllocateCallFrame(argsToStkPassSize, reg0, reg1, rty);
+    CHECK_FATAL(ipoint != nullptr, "ipoint should not be nullptr at this point");
+  } else {
+    bool useStpSub = false;
+
+    if (stackFrameSize > kStpLdpImm64UpperBound) {
+      useStpSub = true;
+      RegOperand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+      ImmOperand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+      aarchCGFunc.SelectSub(spOpnd, spOpnd, immOpnd, PTY_u64);
+      ipoint = cgFunc.GetCurBB()->GetLastInsn();
+      ipoint->SetStackDef(true);
+    } else {
+      MOperator mOp = pushPopOps[kRegsPushOp][rty][kPushPopPair];
+      RegOperand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, GetPointerSize() * kBitsPerByte, rty);
+      RegOperand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, GetPointerSize() * kBitsPerByte, rty);
+      MemOperand &o2 = aarchCGFunc.CreateCallFrameOperand(-stackFrameSize, GetPointerSize() * kBitsPerByte);
+      ipoint = &cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, o2);
+      AppendInstructionTo(*ipoint, cgFunc);
+      ipoint->SetStackDef(true);
+    }
+
+    if (useStpSub) {
+      MOperator mOp = pushPopOps[kRegsPushOp][rty][kPushPopPair];
+      RegOperand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, GetPointerSize() * kBitsPerByte, rty);
+      RegOperand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, GetPointerSize() * kBitsPerByte, rty);
+      MemOperand *o2 = aarchCGFunc.CreateStackMemOpnd(RSP, 0, GetPointerSize() * kBitsPerByte);
+      ipoint = &cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, *o2);
+      AppendInstructionTo(*ipoint, cgFunc);
+    }
+    if (currCG->InstrumentWithDebugTraceCall()) {
+      aarchCGFunc.AppendCall(*currCG->GetDebugTraceEnterFunction());
+    }
+  }
+}
+
+/*
+ *  From AArch64 Reference Manual
+ *  C1.3.3 Load/Store Addressing Mode
+ *  ...
+ *  When stack alignment checking is enabled by system software and
+ *  the base register is the SP, the current stack pointer must be
+ *  initially quadword aligned, that is aligned to 16 bytes. Misalignment
+ *  generates a Stack Alignment fault.  The offset does not have to
+ *  be a multiple of 16 bytes unless the specific Load/Store instruction
+ *  requires this. SP cannot be used as a register offset.
+ */
+void AArch64GenProEpilog::GeneratePushRegs() {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  const MapleVector<AArch64reg> &regsToSave = (aarchCGFunc.GetProEpilogSavedRegs().empty()) ?
+      aarchCGFunc.GetCalleeSavedRegs() : aarchCGFunc.GetProEpilogSavedRegs();
+
+  CHECK_FATAL(!regsToSave.empty(), "FP/LR not added to callee-saved list?");
+
+  AArch64reg intRegFirstHalf = kRinvalid;
+  AArch64reg fpRegFirstHalf = kRinvalid;
+
+  if (currCG->GenerateVerboseCG()) {
+    auto &comment = cgFunc.GetOpndBuilder()->CreateComment("save callee-saved registers");
+    cgFunc.GetCurBB()->AppendInsn(cgFunc.GetInsnBuilder()->BuildCommentInsn(comment));
+  }
+
+  /*
+   * Even if we don't use RFP, since we push a pair of registers in one instruction
+   * and the stack needs be aligned on a 16-byte boundary, push RFP as well if function has a call
+   * Make sure this is reflected when computing callee_saved_regs.size()
+   */
+  if (!currCG->GenerateDebugFriendlyCode()) {
+    AppendInstructionAllocateCallFrame(R29, RLR, kRegTyInt);
+  } else {
+    AppendInstructionAllocateCallFrameDebug(R29, RLR, kRegTyInt);
+  }
+
+  if (useFP) {
+    if (currCG->GenerateVerboseCG()) {
+      auto &comment = cgFunc.GetOpndBuilder()->CreateComment("copy SP to FP");
+      cgFunc.GetCurBB()->AppendInsn(cgFunc.GetInsnBuilder()->BuildCommentInsn(comment));
+    }
+    Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+    Operand &fpOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(stackBaseReg, k64BitSize, kRegTyInt);
+    int64 argsToStkPassSize = cgFunc.GetMemlayout()->SizeOfArgsToStackPass();
+    bool isLmbc = cgFunc.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc;
+    if ((argsToStkPassSize > 0) || isLmbc) {
+      Operand *immOpnd;
+      if (isLmbc) {
+        int32 size = static_cast<int32>(static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize());
+        immOpnd = &aarchCGFunc.CreateImmOperand(size, k32BitSize, true);
+      } else {
+        immOpnd = &aarchCGFunc.CreateImmOperand(argsToStkPassSize, k32BitSize, true);
+      }
+      if (!isLmbc || cgFunc.SeenFP() || cgFunc.GetFunction().GetAttr(FUNCATTR_varargs)) {
+        aarchCGFunc.SelectAdd(fpOpnd, spOpnd, *immOpnd, PTY_u64);
+      }
+      cgFunc.GetCurBB()->GetLastInsn()->SetFrameDef(true);
+    } else {
+      aarchCGFunc.SelectCopy(fpOpnd, PTY_u64, spOpnd, PTY_u64);
+      cgFunc.GetCurBB()->GetLastInsn()->SetFrameDef(true);
+    }
+  }
+
+  MapleVector<AArch64reg>::const_iterator it = regsToSave.begin();
+  /* skip the first two registers */
+  CHECK_FATAL(*it == RFP, "The first callee saved reg is expected to be RFP");
+  ++it;
+  CHECK_FATAL(*it == RLR, "The second callee saved reg is expected to be RLR");
+  ++it;
+
+  AArch64MemLayout *memLayout = static_cast<AArch64MemLayout *>(cgFunc.GetMemlayout());
+  int32 offset;
+  int32 tmp;
+  if (cgFunc.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc) {
+    tmp = static_cast<int32>(memLayout->RealStackFrameSize() -
+        /* FP/LR */
+        (aarchCGFunc.SizeOfCalleeSaved() - (kDivide2 * kIntregBytelen)));
+    offset = tmp - static_cast<int32>(memLayout->GetSizeOfLocals());
+             /* SizeOfArgsToStackPass not deducted since
+                AdjustmentStackPointer() is not called for lmbc */
+  } else {
+    tmp = static_cast<int32>(memLayout->RealStackFrameSize() -
+        /* FP/LR */
+        (aarchCGFunc.SizeOfCalleeSaved() - (kDivide2 * kIntregBytelen)));
+    offset = tmp - static_cast<int32>(memLayout->SizeOfArgsToStackPass());
+  }
+
+  if (cgFunc.GetCG()->IsStackProtectorStrong() || cgFunc.GetCG()->IsStackProtectorAll()) {
+    offset -= kAarch64StackPtrAlignmentInt;
+  }
+
+  if (cgFunc.GetMirModule().IsCModule() &&
+      cgFunc.GetFunction().GetAttr(FUNCATTR_varargs) &&
+      cgFunc.GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+    /* GR/VR save areas are above the callee save area */
+    AArch64MemLayout *ml = static_cast<AArch64MemLayout *>(cgFunc.GetMemlayout());
+    auto saveareasize = static_cast<int32>(RoundUp(ml->GetSizeOfGRSaveArea(), GetPointerSize() * k2BitSize) +
+        RoundUp(ml->GetSizeOfVRSaveArea(), GetPointerSize() * k2BitSize));
+    offset -= saveareasize;
+  }
+
+  for (; it != regsToSave.end(); ++it) {
+    AArch64reg reg = *it;
+    CHECK_FATAL(reg != RFP, "stray RFP in callee_saved_list?");
+    CHECK_FATAL(reg != RLR, "stray RLR in callee_saved_list?");
+    RegType regType = AArch64isa::IsGPRegister(reg) ? kRegTyInt : kRegTyFloat;
+    AArch64reg &firstHalf = AArch64isa::IsGPRegister(reg) ? intRegFirstHalf : fpRegFirstHalf;
+    if (firstHalf == kRinvalid) {
+      /* remember it */
+      firstHalf = reg;
+    } else {
+      AppendInstructionPushPair(cgFunc, firstHalf, reg, regType, offset);
+      GetNextOffsetCalleeSaved(offset);
+      firstHalf = kRinvalid;
+    }
+  }
+
+  if (intRegFirstHalf != kRinvalid) {
+    AppendInstructionPushSingle(cgFunc, intRegFirstHalf, kRegTyInt, offset);
+    GetNextOffsetCalleeSaved(offset);
+  }
+
+  if (fpRegFirstHalf != kRinvalid) {
+    AppendInstructionPushSingle(cgFunc, fpRegFirstHalf, kRegTyFloat, offset);
+    GetNextOffsetCalleeSaved(offset);
+  }
+
+  /*
+   * in case we split stp/ldp instructions,
+   * so that we generate a load-into-base-register instruction
+   * for pop pairs as well.
+   */
+  aarchCGFunc.SetSplitBaseOffset(0);
+}
+
+void AArch64GenProEpilog::GeneratePushUnnamedVarargRegs() {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  uint32 offset;
+  if (cgFunc.GetMirModule().IsCModule() && cgFunc.GetFunction().GetAttr(FUNCATTR_varargs)) {
+    AArch64MemLayout *memlayout = static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout());
+    uint8 size;
+    if (CGOptions::IsArm64ilp32()) {
+      size = k8ByteSize;
+    } else {
+      size = GetPointerSize();
+    }
+    uint32 dataSizeBits = size * kBitsPerByte;
+    if (cgFunc.GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+      offset = static_cast<uint32>(memlayout->GetGRSaveAreaBaseLoc()); /* SP reference */
+    } else {
+      offset = static_cast<uint32>(memlayout->GetGRSaveAreaBaseLoc()) +
+               memlayout->SizeOfArgsToStackPass();
+    }
+    if (memlayout->GetSizeOfGRSaveArea() % kAarch64StackPtrAlignment) {
+      offset += size;  /* End of area should be aligned. Hole between VR and GR area */
+    }
+    uint32 startRegno = k8BitSize - (memlayout->GetSizeOfGRSaveArea() / size);
+    ASSERT(startRegno <= k8BitSize, "Incorrect starting GR regno for GR Save Area");
+    for (uint32 i = startRegno + static_cast<uint32>(R0); i < static_cast<uint32>(R8); i++) {
+      uint32 tmpOffset = 0;
+      if (CGOptions::IsBigEndian()) {
+        if ((dataSizeBits >> 3) < 8) {
+          tmpOffset += 8U - (dataSizeBits >> 3);
+        }
+      }
+      Operand *stackLoc = &aarchCGFunc.CreateStkTopOpnd(offset + tmpOffset, dataSizeBits);
+      RegOperand &reg =
+          aarchCGFunc.GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyInt);
+      Insn &inst = cgFunc.GetInsnBuilder()->BuildInsn(aarchCGFunc.PickStInsn(dataSizeBits, PTY_i64), reg, *stackLoc);
+      cgFunc.GetCurBB()->AppendInsn(inst);
+      offset += size;
+    }
+    if (!CGOptions::UseGeneralRegOnly()) {
+      if (cgFunc.GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+        offset = static_cast<uint32>(memlayout->GetVRSaveAreaBaseLoc()); /* SP reference */
+      } else {
+        offset = static_cast<uint32>(memlayout->GetVRSaveAreaBaseLoc()) +
+                 memlayout->SizeOfArgsToStackPass();
+      }
+      startRegno = k8BitSize - (memlayout->GetSizeOfVRSaveArea() / (size * k2BitSize));
+      ASSERT(startRegno <= k8BitSize, "Incorrect starting GR regno for VR Save Area");
+      for (uint32 i = startRegno + static_cast<uint32>(V0); i < static_cast<uint32>(V8); i++) {
+        uint32 tmpOffset = 0;
+        if (CGOptions::IsBigEndian()) {
+          if ((dataSizeBits >> 3) < 16) {
+            tmpOffset += 16U - (dataSizeBits >> 3);
+          }
+        }
+        Operand *stackLoc = &aarchCGFunc.CreateStkTopOpnd(offset + tmpOffset, dataSizeBits);
+        RegOperand &reg =
+            aarchCGFunc.GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyFloat);
+        Insn &inst = cgFunc.GetInsnBuilder()->BuildInsn(aarchCGFunc.PickStInsn(dataSizeBits, PTY_f64), reg, *stackLoc);
+        cgFunc.GetCurBB()->AppendInsn(inst);
+        offset += (size * k2BitSize);
+      }
+    }
+  }
+}
+
+void AArch64GenProEpilog::AppendInstructionStackCheck(AArch64reg reg, RegType rty, int32 offset) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  /* sub x16, sp, #0x2000 */
+  auto &x16Opnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg, k64BitSize, rty);
+  auto &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, rty);
+  auto &imm1 = aarchCGFunc.CreateImmOperand(offset, k64BitSize, true);
+  aarchCGFunc.SelectSub(x16Opnd, spOpnd, imm1, PTY_u64);
+
+  /* ldr wzr, [x16] */
+  auto &wzr = cgFunc.GetZeroOpnd(k32BitSize);
+  auto &refX16 = aarchCGFunc.CreateMemOpnd(reg, 0, k64BitSize);
+  auto &soeInstr = cgFunc.GetInsnBuilder()->BuildInsn(MOP_wldr, wzr, refX16);
+  if (currCG->GenerateVerboseCG()) {
+    soeInstr.SetComment("soerror");
+  }
+  soeInstr.SetDoNotRemove(true);
+  AppendInstructionTo(soeInstr, cgFunc);
+}
+
+void AArch64GenProEpilog::GenerateProlog(BB &bb) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  BB *formerCurBB = cgFunc.GetCurBB();
+  aarchCGFunc.GetDummyBB()->ClearInsns();
+  aarchCGFunc.GetDummyBB()->SetIsProEpilog(true);
+  cgFunc.SetCurBB(*aarchCGFunc.GetDummyBB());
+
+  bool hasProEpilogue = cgFunc.GetHasProEpilogue();
+  if (!hasProEpilogue) {
+    return;
+  }
+
+  // insert .loc for function
+  if (currCG->GetCGOptions().WithLoc() && (!currCG->GetMIRModule()->IsCModule())) {
+    MIRFunction *func = &cgFunc.GetFunction();
+    MIRSymbol *fSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
+    if (currCG->GetCGOptions().WithSrc()) {
+      uint32 tempmaxsize = static_cast<uint32>(currCG->GetMIRModule()->GetSrcFileInfo().size());
+      uint32 endfilenum = currCG->GetMIRModule()->GetSrcFileInfo()[tempmaxsize - 1].second;
+      if (fSym->GetSrcPosition().FileNum() != 0 && fSym->GetSrcPosition().FileNum() <= endfilenum) {
+        Operand *o0 = cgFunc.CreateDbgImmOperand(fSym->GetSrcPosition().FileNum());
+        int64_t lineNum = fSym->GetSrcPosition().LineNum();
+        if (lineNum == 0) {
+          if (cgFunc.GetFunction().GetAttr(FUNCATTR_native)) {
+            lineNum = 0xffffe;
+          } else {
+            lineNum = 0xffffd;
+          }
+        }
+        Operand *o1 = cgFunc.CreateDbgImmOperand(lineNum);
+        Operand *o2 = cgFunc.CreateDbgImmOperand(fSym->GetSrcPosition().Column());
+        Insn &loc = cgFunc.GetInsnBuilder()->BuildDbgInsn(
+            mpldbg::OP_DBG_loc).AddOpndChain(*o0).AddOpndChain(*o1).AddOpndChain(*o2);
+        cgFunc.GetCurBB()->AppendInsn(loc);
+      }
+    } else {
+      Operand *o0 = cgFunc.CreateDbgImmOperand(1);
+      Operand *o1 = cgFunc.CreateDbgImmOperand(fSym->GetSrcPosition().MplLineNum());
+      Operand *o2 = cgFunc.CreateDbgImmOperand(0);
+      Insn &loc = cgFunc.GetInsnBuilder()->BuildDbgInsn(
+          mpldbg::OP_DBG_loc).AddOpndChain(*o0).AddOpndChain(*o1).AddOpndChain(*o2);
+      cgFunc.GetCurBB()->AppendInsn(loc);
+    }
+  }
+
+  const MapleVector<AArch64reg> &regsToSave = (aarchCGFunc.GetProEpilogSavedRegs().empty()) ?
+      aarchCGFunc.GetCalleeSavedRegs() : aarchCGFunc.GetProEpilogSavedRegs();
+  if (!regsToSave.empty()) {
+    /*
+     * Among other things, push the FP & LR pair.
+     * FP/LR are added to the callee-saved list in AllocateRegisters()
+     * We add them to the callee-saved list regardless of UseFP() being true/false.
+     * Activation Frame is allocated as part of pushing FP/LR pair
+     */
+    GeneratePushRegs();
+  } else {
+    Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+    int32 stackFrameSize = static_cast<int32>(
+        static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize());
+    if (stackFrameSize > 0) {
+      if (currCG->GenerateVerboseCG()) {
+        auto &comment = cgFunc.GetOpndBuilder()->CreateComment("allocate activation frame");
+        cgFunc.GetCurBB()->AppendInsn(cgFunc.GetInsnBuilder()->BuildCommentInsn(comment));
+      }
+      Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+      aarchCGFunc.SelectSub(spOpnd, spOpnd, immOpnd, PTY_u64);
+      cgFunc.GetCurBB()->GetLastInsn()->SetStackDef(true);
+    }
+    if (currCG->GenerateVerboseCG()) {
+      auto &comment = cgFunc.GetOpndBuilder()->CreateComment("copy SP to FP");
+      cgFunc.GetCurBB()->AppendInsn(cgFunc.GetInsnBuilder()->BuildCommentInsn(comment));
+    }
+    if (useFP) {
+      Operand &fpOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(stackBaseReg, k64BitSize, kRegTyInt);
+      bool isLmbc = cgFunc.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc;
+      int64 argsToStkPassSize = cgFunc.GetMemlayout()->SizeOfArgsToStackPass();
+      if ((argsToStkPassSize > 0) || isLmbc) {
+        Operand *immOpnd;
+        if (isLmbc) {
+          int32 size = static_cast<int32>(static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize());
+          immOpnd = &aarchCGFunc.CreateImmOperand(size, k32BitSize, true);
+        } else {
+          immOpnd = &aarchCGFunc.CreateImmOperand(argsToStkPassSize, k32BitSize, true);
+        }
+        aarchCGFunc.SelectAdd(fpOpnd, spOpnd, *immOpnd, PTY_u64);
+        cgFunc.GetCurBB()->GetLastInsn()->SetFrameDef(true);
+      } else {
+        aarchCGFunc.SelectCopy(fpOpnd, PTY_u64, spOpnd, PTY_u64);
+        cgFunc.GetCurBB()->GetLastInsn()->SetFrameDef(true);
+      }
+    }
+  }
+  GeneratePushUnnamedVarargRegs();
+  if (currCG->DoCheckSOE()) {
+    AppendInstructionStackCheck(R16, kRegTyInt, kSoeChckOffset);
+  }
+  bb.InsertAtBeginning(*aarchCGFunc.GetDummyBB());
+  cgFunc.SetCurBB(*formerCurBB);
+  aarchCGFunc.GetDummyBB()->SetIsProEpilog(false);
+}
+
+void AArch64GenProEpilog::GenerateRet(BB &bb) {
+  bb.AppendInsn(cgFunc.GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_xret));
+}
+
+/*
+ * If exitBB made the TailcallOpt(replace blr/bl with br/b), return true, we don't create ret insn.
+ * Otherwise, return false, create the ret insn.
+ */
+bool AArch64GenProEpilog::TestPredsOfRetBB(const BB &exitBB) {
+  AArch64MemLayout *ml = static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout());
+  if (cgFunc.GetMirModule().IsCModule() &&
+      (cgFunc.GetFunction().GetAttr(FUNCATTR_varargs) ||
+       ml->GetSizeOfLocals() > 0 || cgFunc.HasVLAOrAlloca())) {
+    return false;
+  }
+  const Insn *lastInsn = exitBB.GetLastInsn();
+  while (lastInsn != nullptr && (!lastInsn->IsMachineInstruction() ||
+                                 AArch64isa::IsPseudoInstruction(lastInsn->GetMachineOpcode()))) {
+    lastInsn = lastInsn->GetPrev();
+  }
+  bool isTailCall = lastInsn == nullptr ? false : lastInsn->IsTailCall();
+  return isTailCall;
+}
+
+void AArch64GenProEpilog::AppendInstructionPopSingle(CGFunc &cgFunc, AArch64reg reg, RegType rty, int32 offset) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  MOperator mOp = pushPopOps[kRegsPopOp][rty][kPushPopSingle];
+  Operand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg, GetPointerSize() * kBitsPerByte, rty);
+  Operand *o1 = &aarchCGFunc.CreateStkTopOpnd(static_cast<uint32>(offset), GetPointerSize() * kBitsPerByte);
+  MemOperand *aarchMemO1 = static_cast<MemOperand*>(o1);
+  uint32 dataSize = GetPointerSize() * kBitsPerByte;
+  if (aarchMemO1->GetMemVaryType() == kNotVary && aarchCGFunc.IsImmediateOffsetOutOfRange(*aarchMemO1, dataSize)) {
+    o1 = &aarchCGFunc.SplitOffsetWithAddInstruction(*aarchMemO1, dataSize, R16);
+  }
+
+  Insn &popInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, *o1);
+  popInsn.SetComment("RESTORE");
+  cgFunc.GetCurBB()->AppendInsn(popInsn);
+}
+
+void AArch64GenProEpilog::AppendInstructionPopPair(CGFunc &cgFunc,
+    AArch64reg reg0, AArch64reg reg1, RegType rty, int32 offset) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  MOperator mOp = pushPopOps[kRegsPopOp][rty][kPushPopPair];
+  Operand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, GetPointerSize() * kBitsPerByte, rty);
+  Operand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, GetPointerSize() * kBitsPerByte, rty);
+  Operand *o2 = &aarchCGFunc.CreateStkTopOpnd(static_cast<uint32>(offset), GetPointerSize() * kBitsPerByte);
+
+  uint32 dataSize = GetPointerSize() * kBitsPerByte;
+  CHECK_FATAL(offset >= 0, "offset must >= 0");
+  if (offset > kStpLdpImm64UpperBound) {
+    o2 = SplitStpLdpOffsetForCalleeSavedWithAddInstruction(cgFunc,
+        static_cast<MemOperand&>(*o2), dataSize, R16);
+  }
+  Insn &popInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, *o2);
+  popInsn.SetComment("RESTORE RESTORE");
+  cgFunc.GetCurBB()->AppendInsn(popInsn);
+}
+
+
+void AArch64GenProEpilog::AppendInstructionDeallocateCallFrame(AArch64reg reg0, AArch64reg reg1, RegType rty) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  MOperator mOp = pushPopOps[kRegsPopOp][rty][kPushPopPair];
+  Operand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, GetPointerSize() * kBitsPerByte, rty);
+  Operand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, GetPointerSize() * kBitsPerByte, rty);
+  int32 stackFrameSize = static_cast<int32>(
+      static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize());
+  int64 argsToStkPassSize = cgFunc.GetMemlayout()->SizeOfArgsToStackPass();
+  /*
+   * ldp/stp's imm should be within -512 and 504;
+   * if ldp's imm > 504, we fall back to the ldp-add version
+   */
+  bool useLdpAdd = false;
+  int32 offset = 0;
+
+  Operand *o2 = nullptr;
+  if (!cgFunc.HasVLAOrAlloca() && argsToStkPassSize > 0) {
+    o2 = aarchCGFunc.CreateStackMemOpnd(RSP, static_cast<int32>(argsToStkPassSize), GetPointerSize() * kBitsPerByte);
+  } else {
+    if (stackFrameSize > kStpLdpImm64UpperBound) {
+      useLdpAdd = true;
+      offset = kOffset16MemPos;
+      stackFrameSize -= offset;
+    } else {
+      offset = stackFrameSize;
+    }
+    o2 = &aarchCGFunc.CreateCallFrameOperand(offset, GetPointerSize() * kBitsPerByte);
+  }
+
+  if (useLdpAdd) {
+    Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+    Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+    aarchCGFunc.SelectAdd(spOpnd, spOpnd, immOpnd, PTY_u64);
+  }
+
+  if (!cgFunc.HasVLAOrAlloca() && argsToStkPassSize > 0) {
+    CHECK_FATAL(!useLdpAdd, "Invalid assumption");
+    if (argsToStkPassSize > kStpLdpImm64UpperBound) {
+      (void)AppendInstructionForAllocateOrDeallocateCallFrame(argsToStkPassSize, reg0, reg1, rty, false);
+    } else {
+      Insn &deallocInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, *o2);
+      cgFunc.GetCurBB()->AppendInsn(deallocInsn);
+    }
+    Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+    Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+    aarchCGFunc.SelectAdd(spOpnd, spOpnd, immOpnd, PTY_u64);
+  } else {
+    Insn &deallocInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, *o2);
+    cgFunc.GetCurBB()->AppendInsn(deallocInsn);
+  }
+}
+
+void AArch64GenProEpilog::AppendInstructionDeallocateCallFrameDebug(AArch64reg reg0, AArch64reg reg1, RegType rty) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  MOperator mOp = pushPopOps[kRegsPopOp][rty][kPushPopPair];
+  Operand &o0 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg0, GetPointerSize() * kBitsPerByte, rty);
+  Operand &o1 = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(reg1, GetPointerSize() * kBitsPerByte, rty);
+  int32 stackFrameSize = static_cast<int32>(
+      static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize());
+  int32 argsToStkPassSize = static_cast<int32>(cgFunc.GetMemlayout()->SizeOfArgsToStackPass());
+  /*
+   * ldp/stp's imm should be within -512 and 504;
+   * if ldp's imm > 504, we fall back to the ldp-add version
+   */
+  bool isLmbc = cgFunc.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc;
+  if (cgFunc.HasVLAOrAlloca() || argsToStkPassSize == 0 || isLmbc) {
+    int32 lmbcOffset = 0;
+    if (!isLmbc) {
+      stackFrameSize -= argsToStkPassSize;
+    } else {
+      lmbcOffset = argsToStkPassSize;
+    }
+    if (stackFrameSize > kStpLdpImm64UpperBound || isLmbc) {
+      Operand *o2 = aarchCGFunc.CreateStackMemOpnd(RSP, (isLmbc ? lmbcOffset : 0), GetPointerSize() * kBitsPerByte);
+      Insn &deallocInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, *o2);
+      cgFunc.GetCurBB()->AppendInsn(deallocInsn);
+      Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+      Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+      aarchCGFunc.SelectAdd(spOpnd, spOpnd, immOpnd, PTY_u64);
+    } else {
+      MemOperand &o2 = aarchCGFunc.CreateCallFrameOperand(stackFrameSize, GetPointerSize() * kBitsPerByte);
+      Insn &deallocInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, o2);
+      cgFunc.GetCurBB()->AppendInsn(deallocInsn);
+    }
+  } else {
+    Operand *o2 = aarchCGFunc.CreateStackMemOpnd(RSP, static_cast<int32>(argsToStkPassSize), GetPointerSize() * kBitsPerByte);
+    if (argsToStkPassSize > kStpLdpImm64UpperBound) {
+      (void)AppendInstructionForAllocateOrDeallocateCallFrame(argsToStkPassSize, reg0, reg1, rty, false);
+    } else {
+      Insn &deallocInsn = cgFunc.GetInsnBuilder()->BuildInsn(mOp, o0, o1, *o2);
+      cgFunc.GetCurBB()->AppendInsn(deallocInsn);
+    }
+
+    Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+    Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+    aarchCGFunc.SelectAdd(spOpnd, spOpnd, immOpnd, PTY_u64);
+  }
+}
+
+void AArch64GenProEpilog::GeneratePopRegs() {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+
+  const MapleVector<AArch64reg> &regsToRestore = (aarchCGFunc.GetProEpilogSavedRegs().empty()) ?
+      aarchCGFunc.GetCalleeSavedRegs() : aarchCGFunc.GetProEpilogSavedRegs();
+
+  CHECK_FATAL(!regsToRestore.empty(), "FP/LR not added to callee-saved list?");
+
+  AArch64reg intRegFirstHalf = kRinvalid;
+  AArch64reg fpRegFirstHalf = kRinvalid;
+
+  if (currCG->GenerateVerboseCG()) {
+    auto &comment = cgFunc.GetOpndBuilder()->CreateComment("restore callee-saved registers");
+    cgFunc.GetCurBB()->AppendInsn(cgFunc.GetInsnBuilder()->BuildCommentInsn(comment));
+  }
+
+  MapleVector<AArch64reg>::const_iterator it = regsToRestore.begin();
+  /*
+   * Even if we don't use FP, since we push a pair of registers
+   * in a single instruction (i.e., stp) and the stack needs be aligned
+   * on a 16-byte boundary, push FP as well if the function has a call.
+   * Make sure this is reflected when computing calleeSavedRegs.size()
+   * skip the first two registers
+   */
+  CHECK_FATAL(*it == RFP, "The first callee saved reg is expected to be RFP");
+  ++it;
+  CHECK_FATAL(*it == RLR, "The second callee saved reg is expected to be RLR");
+  ++it;
+
+  AArch64MemLayout *memLayout = static_cast<AArch64MemLayout *>(cgFunc.GetMemlayout());
+  int32 offset;
+  int32 tmp;
+  if (cgFunc.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc) {
+    tmp = static_cast<int32>(memLayout->RealStackFrameSize() -
+        /* FP/LR */
+        (aarchCGFunc.SizeOfCalleeSaved() - (kDivide2 * kIntregBytelen)));
+    offset = tmp - static_cast<int32>(memLayout->GetSizeOfLocals());
+             /* SizeOfArgsToStackPass not deducted since
+                AdjustmentStackPointer() is not called for lmbc */
+  } else {
+    tmp = static_cast<int32>(static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize() -
+        /* for FP/LR */
+        (aarchCGFunc.SizeOfCalleeSaved() - (kDivide2 * kIntregBytelen)));
+    offset = tmp - static_cast<int32>(memLayout->SizeOfArgsToStackPass());
+  }
+
+  if (cgFunc.GetCG()->IsStackProtectorStrong() || cgFunc.GetCG()->IsStackProtectorAll()) {
+    offset -= kAarch64StackPtrAlignmentInt;
+  }
+
+  if (cgFunc.GetMirModule().IsCModule() && cgFunc.GetFunction().GetAttr(FUNCATTR_varargs) &&
+      cgFunc.GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+    /* GR/VR save areas are above the callee save area */
+    AArch64MemLayout *ml = static_cast<AArch64MemLayout *>(cgFunc.GetMemlayout());
+    auto saveareasize = static_cast<int32>(RoundUp(ml->GetSizeOfGRSaveArea(), GetPointerSize() * k2BitSize) +
+        RoundUp(ml->GetSizeOfVRSaveArea(), GetPointerSize() * k2BitSize));
+    offset -= saveareasize;
+  }
+
+  /*
+   * We are using a cleared dummy block; so insertPoint cannot be ret;
+   * see GenerateEpilog()
+   */
+  for (; it != regsToRestore.end(); ++it) {
+    AArch64reg reg = *it;
+    CHECK_FATAL(reg != RFP, "stray RFP in callee_saved_list?");
+    CHECK_FATAL(reg != RLR, "stray RLR in callee_saved_list?");
+
+    RegType regType = AArch64isa::IsGPRegister(reg) ? kRegTyInt : kRegTyFloat;
+    AArch64reg &firstHalf = AArch64isa::IsGPRegister(reg) ? intRegFirstHalf : fpRegFirstHalf;
+    if (firstHalf == kRinvalid) {
+      /* remember it */
+      firstHalf = reg;
+    } else {
+      /* flush the pair */
+      AppendInstructionPopPair(cgFunc, firstHalf, reg, regType, offset);
+      GetNextOffsetCalleeSaved(offset);
+      firstHalf = kRinvalid;
+    }
+  }
+
+  if (intRegFirstHalf != kRinvalid) {
+    AppendInstructionPopSingle(cgFunc, intRegFirstHalf, kRegTyInt, offset);
+    GetNextOffsetCalleeSaved(offset);
+  }
+
+  if (fpRegFirstHalf != kRinvalid) {
+    AppendInstructionPopSingle(cgFunc, fpRegFirstHalf, kRegTyFloat, offset);
+    GetNextOffsetCalleeSaved(offset);
+  }
+
+  if (!currCG->GenerateDebugFriendlyCode()) {
+    AppendInstructionDeallocateCallFrame(R29, RLR, kRegTyInt);
+  } else {
+    AppendInstructionDeallocateCallFrameDebug(R29, RLR, kRegTyInt);
+  }
+
+  /*
+   * in case we split stp/ldp instructions,
+   * so that we generate a load-into-base-register instruction
+   * for the next function, maybe? (seems not necessary, but...)
+   */
+  aarchCGFunc.SetSplitBaseOffset(0);
+}
+
+void AArch64GenProEpilog::AppendJump(const MIRSymbol &funcSymbol) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  Operand &targetOpnd = aarchCGFunc.GetOrCreateFuncNameOpnd(funcSymbol);
+  cgFunc.GetCurBB()->AppendInsn(cgFunc.GetInsnBuilder()->BuildInsn(MOP_xuncond, targetOpnd));
+}
+
+void AArch64GenProEpilog::AppendBBtoEpilog(BB &epilogBB, BB &newBB) {
+  if (epilogBB.GetPreds().empty() && cgFunc.GetMirModule().IsCModule() && cgFunc.GetCG()->DoTailCall()) {
+    epilogBB.SetNeedRestoreCfi(false);
+    Insn &junk = cgFunc.GetInsnBuilder()->BuildInsn<AArch64CG>(MOP_pseudo_none);
+    epilogBB.AppendInsn(junk);
+    return;
+  }
+  FOR_BB_INSNS(insn, &newBB) {
+    insn->SetDoNotRemove(true);
+  }
+  Insn *lastInsn = epilogBB.GetLastInsn();
+  while (lastInsn != nullptr && (!lastInsn->IsMachineInstruction() ||
+                                 AArch64isa::IsPseudoInstruction(lastInsn->GetMachineOpcode()))) {
+    lastInsn = lastInsn->GetPrev();
+  }
+  bool isTailCall = lastInsn == nullptr ? false : lastInsn->IsTailCall();
+  if (isTailCall) {
+    Insn *retInsn = newBB.GetLastInsn();
+    if (retInsn != nullptr && retInsn->GetMachineOpcode() == MOP_xret) {
+      newBB.RemoveInsn(*retInsn);
+    }
+    epilogBB.RemoveInsn(*lastInsn);
+    epilogBB.AppendBBInsns(newBB);
+    epilogBB.AppendInsn(*lastInsn);
+  } else {
+    epilogBB.AppendBBInsns(newBB);
+  }
+  epilogBB.SetNeedRestoreCfi(true);;
+}
+
+void AArch64GenProEpilog::GenerateEpilog(BB &bb) {
+  if (!cgFunc.GetHasProEpilogue()) {
+    if (!bb.GetPreds().empty() && !TestPredsOfRetBB(bb)) {
+      GenerateRet(bb);
+    }
+    return;
+  }
+  /* generate stack protected instruction */
+  BB &epilogBB = GenStackGuardCheckInsn(bb);
+
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  BB *formerCurBB = cgFunc.GetCurBB();
+  aarchCGFunc.GetDummyBB()->ClearInsns();
+  aarchCGFunc.GetDummyBB()->SetIsProEpilog(true);
+  cgFunc.SetCurBB(*aarchCGFunc.GetDummyBB());
+
+  Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+  Operand &fpOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(stackBaseReg, k64BitSize, kRegTyInt);
+
+  if (cgFunc.HasVLAOrAlloca() && cgFunc.GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+    aarchCGFunc.SelectCopy(spOpnd, PTY_u64, fpOpnd, PTY_u64);
+  }
+
+  const MapleVector<AArch64reg> &regsToSave = (aarchCGFunc.GetProEpilogSavedRegs().empty()) ?
+      aarchCGFunc.GetCalleeSavedRegs() : aarchCGFunc.GetProEpilogSavedRegs();
+  if (!regsToSave.empty()) {
+    GeneratePopRegs();
+  } else {
+    auto stackFrameSize = static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize();
+    if (stackFrameSize > 0) {
+      if (currCG->GenerateVerboseCG()) {
+        auto &comment = cgFunc.GetOpndBuilder()->CreateComment("pop up activation frame");
+        cgFunc.GetCurBB()->AppendInsn(cgFunc.GetInsnBuilder()->BuildCommentInsn(comment));
+      }
+
+      if (cgFunc.HasVLAOrAlloca()) {
+        auto size = static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->GetSegArgsToStkPass().GetSize();
+        stackFrameSize = stackFrameSize < size ? 0 : stackFrameSize - size;
+      }
+
+      if (stackFrameSize > 0) {
+        Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
+        aarchCGFunc.SelectAdd(spOpnd, spOpnd, immOpnd, PTY_u64);
+      }
+    }
+  }
+
+  if (currCG->InstrumentWithDebugTraceCall()) {
+    AppendJump(*(currCG->GetDebugTraceExitFunction()));
+  }
+
+  GenerateRet(*(cgFunc.GetCurBB()));
+  AppendBBtoEpilog(epilogBB, *cgFunc.GetCurBB());
+  if (cgFunc.GetCurBB()->GetHasCfi()) {
+    epilogBB.SetHasCfi();
+  }
+
+  cgFunc.SetCurBB(*formerCurBB);
+  aarchCGFunc.GetDummyBB()->SetIsProEpilog(false);
+}
+
+void AArch64GenProEpilog::GenerateEpilogForCleanup(BB &bb) {
+  auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  CHECK_FATAL(!cgFunc.GetExitBBsVec().empty(), "exit bb size is zero!");
+  if (cgFunc.GetExitBB(0)->IsUnreachable()) {
+    /* if exitbb is unreachable then exitbb can not be generated */
+    GenerateEpilog(bb);
+  } else if (aarchCGFunc.NeedCleanup()) {  /* bl to the exit epilogue */
+    LabelOperand &targetOpnd = aarchCGFunc.GetOrCreateLabelOperand(cgFunc.GetExitBB(0)->GetLabIdx());
+    bb.AppendInsn(cgFunc.GetInsnBuilder()->BuildInsn(MOP_xuncond, targetOpnd));
+  }
+}
+
+void AArch64GenProEpilog::Run() {
+  CHECK_FATAL(cgFunc.GetFunction().GetBody()->GetFirst()->GetOpCode() == OP_label,
+              "The first statement should be a label");
+  stackProtect = cgFunc.GetNeedStackProtect();
+  cgFunc.SetHasProEpilogue(NeedProEpilog());
+  if (cgFunc.GetHasProEpilogue()) {
+    AddStackGuard(*(cgFunc.GetFirstBB()));
+  }
+
+  if (cgFunc.IsExitBBsVecEmpty()) {
+    if (cgFunc.GetCleanupBB() != nullptr && cgFunc.GetCleanupBB()->GetPrev() != nullptr) {
+      cgFunc.PushBackExitBBsVec(*cgFunc.GetCleanupBB()->GetPrev());
+    } else {
+      cgFunc.PushBackExitBBsVec(*cgFunc.GetLastBB()->GetPrev());
+    }
+  }
+
+  GenerateProlog(*(cgFunc.GetPrologureBB()));
+
+  for (auto *exitBB : cgFunc.GetExitBBsVec()) {
+    GenerateEpilog(*exitBB);
+  }
+
+  if (cgFunc.GetFunction().IsJava()) {
+    GenerateEpilogForCleanup(*(cgFunc.GetCleanupBB()));
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_prop.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_prop.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c009e7d9a62223e9391e4356ece4c709fa846e1b
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_prop.cpp
@@ -0,0 +1,2912 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <climits>
+#include "aarch64_isa.h"
+#include "aarch64_cg.h"
+#include "aarch64_reg_coalesce.h"
+#include "aarch64_prop.h"
+
+namespace maplebe {
+
+#define PROP_DUMP CG_DEBUG_FUNC(cgFunc)
+
+bool MayOverflow(const ImmOperand &value1, const ImmOperand &value2, bool is64Bit, bool isAdd, bool isSigned) {
+  if (value1.GetVary() > 0 || value2.GetVary() > 0) {
+    return false;
+  }
+  int64 cstA = value1.GetValue();
+  int64 cstB = value2.GetValue();
+  if (isAdd) {
+    int64 res = static_cast<int64>(static_cast<uint64>(cstA) + static_cast<uint64>(cstB));
+    if (!isSigned) {
+      return static_cast<uint64>(res) < static_cast<uint64>(cstA);
+    }
+    uint32 rightShiftNumToGetSignFlag = (is64Bit ? k64BitSize : k32BitSize) - 1;
+    return (static_cast<uint64>(res) >> rightShiftNumToGetSignFlag !=
+            static_cast<uint64>(cstA) >> rightShiftNumToGetSignFlag) &&
+           (static_cast<uint64>(res) >> rightShiftNumToGetSignFlag !=
+            static_cast<uint64>(cstB) >> rightShiftNumToGetSignFlag);
+  } else {
+    /* sub */
+    if (!isSigned) {
+      return cstA < cstB;
+    }
+    int64 res = static_cast<int64>(static_cast<uint64>(cstA) - static_cast<uint64>(cstB));
+    uint32 rightShiftNumToGetSignFlag = (is64Bit ? k64BitSize : k32BitSize) - 1;
+    return (static_cast<uint64>(cstA) >> rightShiftNumToGetSignFlag !=
+            static_cast<uint64>(cstB) >> rightShiftNumToGetSignFlag) &&
+           (static_cast<uint64>(res) >> rightShiftNumToGetSignFlag !=
+            static_cast<uint64>(cstA) >> rightShiftNumToGetSignFlag);
+  }
+}
+
+bool AArch64Prop::IsInLimitCopyRange(VRegVersion *toBeReplaced) {
+  uint32 baseID = toBeReplaced->GetDefInsnInfo()->GetInsn()->GetId();
+  MapleUnorderedMap<uint32, DUInsnInfo*> &useList = toBeReplaced->GetAllUseInsns();
+  for (auto it : useList) {
+    if (it.second->GetInsn()->GetId() - baseID > k16BitSize) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void AArch64Prop::CopyProp() {
+  PropOptimizeManager optManager;
+  optManager.Optimize<CopyRegProp>(*cgFunc, GetSSAInfo(), GetRegll());
+  optManager.Optimize<ValidBitNumberProp>(*cgFunc, GetSSAInfo());
+  optManager.Optimize<RedundantPhiProp>(*cgFunc, GetSSAInfo());
+}
+
+void AArch64Prop::TargetProp(Insn &insn) {
+  A64ConstProp a64ConstProp(*memPool, *cgFunc, *GetSSAInfo(), insn);
+  a64ConstProp.DoOpt();
+  A64StrLdrProp a64StrLdrProp(*memPool, *cgFunc, *GetSSAInfo(), insn, *GetDce());
+  a64StrLdrProp.DoOpt();
+}
+
+void A64ConstProp::DoOpt() {
+  if (curInsn->GetMachineOpcode() == MOP_wmovri32 || curInsn->GetMachineOpcode() == MOP_xmovri64) {
+    Operand &destOpnd = curInsn->GetOperand(kInsnFirstOpnd);
+    CHECK_FATAL(destOpnd.IsRegister(), "must be reg operand");
+    auto &destReg = static_cast<RegOperand&>(destOpnd);
+    if (destReg.IsSSAForm()) {
+      VRegVersion *destVersion = ssaInfo->FindSSAVersion(destReg.GetRegisterNumber());
+      ASSERT(destVersion != nullptr, "find Version failed");
+      Operand &constOpnd = curInsn->GetOperand(kInsnSecondOpnd);
+      CHECK_FATAL(constOpnd.IsImmediate(), "must be imm operand");
+      auto &immOperand = static_cast<ImmOperand&>(constOpnd);
+      bool isZero = immOperand.IsZero();
+      for (auto useDUInfoIt : destVersion->GetAllUseInsns()) {
+        if (isZero) {
+          ZeroRegProp(*useDUInfoIt.second, *destVersion->GetSSAvRegOpnd());
+          destVersion->CheckDeadUse(*useDUInfoIt.second->GetInsn());
+        }
+        (void)ConstProp(*useDUInfoIt.second, immOperand);
+      }
+    }
+  }
+}
+
+void A64ConstProp::ZeroRegProp(DUInsnInfo &useDUInfo, RegOperand &toReplaceReg) const {
+  auto *useInsn = useDUInfo.GetInsn();
+  const InsnDesc *md = &AArch64CG::kMd[(useInsn->GetMachineOpcode())];
+  /* special case */
+  bool isSpecficCase = useInsn->GetMachineOpcode() == MOP_wbfirri5i5 || useInsn->GetMachineOpcode() == MOP_xbfirri6i6;
+  isSpecficCase = (useDUInfo.GetOperands().size() == 1) &&
+      (useDUInfo.GetOperands().begin()->first == kInsnSecondOpnd) && isSpecficCase;
+  if (useInsn->IsStore() || md->IsCondDef() || isSpecficCase)  {
+    RegOperand &zeroOpnd = cgFunc->GetZeroOpnd(toReplaceReg.GetSize());
+    for (auto &opndIt : as_const(useDUInfo.GetOperands())) {
+      if (useInsn->IsStore() && opndIt.first != 0) {
+        return;
+      }
+      Operand &opnd = useInsn->GetOperand(opndIt.first);
+      A64ReplaceRegOpndVisitor replaceRegOpndVisitor(*cgFunc, *useInsn,
+          opndIt.first, toReplaceReg, zeroOpnd);
+      opnd.Accept(replaceRegOpndVisitor);
+      useDUInfo.ClearDU(opndIt.first);
+    }
+  }
+}
+
+MOperator A64ConstProp::GetReversalMOP(MOperator arithMop) {
+  switch (arithMop) {
+    case MOP_waddrri12:
+      return MOP_wsubrri12;
+    case MOP_xaddrri12:
+      return MOP_xsubrri12;
+    case MOP_xsubrri12:
+      return MOP_xaddrri12;
+    case MOP_wsubrri12:
+      return MOP_waddrri12;
+    default:
+      CHECK_FATAL(false, "NYI");
+      break;
+  }
+  return MOP_undef;
+}
+
+MOperator A64ConstProp::GetRegImmMOP(MOperator regregMop, bool withLeftShift) {
+  switch (regregMop) {
+    case MOP_xaddrrrs:
+    case MOP_xaddrrr: {
+      return withLeftShift ? MOP_xaddrri24 : MOP_xaddrri12;
+    }
+    case MOP_waddrrrs:
+    case MOP_waddrrr: {
+      return withLeftShift ? MOP_waddrri24 : MOP_waddrri12;
+    }
+    case MOP_xsubrrrs:
+    case MOP_xsubrrr: {
+      return withLeftShift ? MOP_xsubrri24 : MOP_xsubrri12;
+    }
+    case MOP_wsubrrrs:
+    case MOP_wsubrrr: {
+      return withLeftShift ? MOP_wsubrri24 : MOP_wsubrri12;
+    }
+    case MOP_xandrrr:
+    case MOP_xandrrrs:
+      return MOP_xandrri13;
+    case MOP_wandrrr:
+    case MOP_wandrrrs:
+      return MOP_wandrri12;
+    case MOP_xeorrrr:
+    case MOP_xeorrrrs:
+      return MOP_xeorrri13;
+    case MOP_weorrrr:
+    case MOP_weorrrrs:
+      return MOP_weorrri12;
+    case MOP_xiorrrr:
+    case MOP_xiorrrrs:
+    case MOP_xbfirri6i6:
+      return MOP_xiorrri13;
+    case MOP_wiorrrr:
+    case MOP_wiorrrrs:
+    case MOP_wbfirri5i5:
+      return MOP_wiorrri12;
+    case MOP_xmovrr: {
+      return MOP_xmovri64;
+    }
+    case MOP_wmovrr: {
+      return MOP_wmovri32;
+    }
+    default:
+      CHECK_FATAL(false, "NYI");
+      break;
+  }
+  return MOP_undef;
+}
+
+MOperator A64ConstProp::GetFoldMopAndVal(int64 &newVal, int64 constVal, const Insn &arithInsn) {
+  MOperator arithMop = arithInsn.GetMachineOpcode();
+  MOperator newMop = MOP_undef;
+  switch (arithMop) {
+    case MOP_waddrrr:
+    case MOP_xaddrrr: {
+      newVal = constVal + constVal;
+      newMop = (arithMop == MOP_waddrrr) ? MOP_wmovri32 : MOP_xmovri64;
+      break;
+    }
+    case MOP_waddrrrs:
+    case MOP_xaddrrrs: {
+      auto &shiftOpnd = static_cast<BitShiftOperand&>(arithInsn.GetOperand(kInsnFourthOpnd));
+      uint32 amount = shiftOpnd.GetShiftAmount();
+      BitShiftOperand::ShiftOp sOp = shiftOpnd.GetShiftOp();
+      switch (sOp) {
+        case BitShiftOperand::kLSL: {
+          newVal = constVal + static_cast<int64>((static_cast<unsigned>(constVal) << amount));
+          break;
+        }
+        case BitShiftOperand::kLSR: {
+          newVal = constVal + (static_cast<unsigned>(constVal) >> amount);
+          break;
+        }
+        case BitShiftOperand::kASR: {
+          newVal = constVal + (constVal >> amount);
+          break;
+        }
+        default:
+          CHECK_FATAL(false, "NYI");
+          break;
+      }
+      newMop = (arithMop == MOP_waddrrrs) ? MOP_wmovri32 : MOP_xmovri64;
+      break;
+    }
+    case MOP_wsubrrr:
+    case MOP_xsubrrr: {
+      newVal = 0;
+      newMop = (arithMop == MOP_wsubrrr) ? MOP_wmovri32 : MOP_xmovri64;
+      break;
+    }
+    case MOP_wsubrrrs:
+    case MOP_xsubrrrs: {
+      auto &shiftOpnd = static_cast<BitShiftOperand&>(arithInsn.GetOperand(kInsnFourthOpnd));
+      uint32 amount = shiftOpnd.GetShiftAmount();
+      BitShiftOperand::ShiftOp sOp = shiftOpnd.GetShiftOp();
+      switch (sOp) {
+        case BitShiftOperand::kLSL: {
+          newVal = constVal - static_cast<int64>((static_cast<unsigned>(constVal) << amount));
+          break;
+        }
+        case BitShiftOperand::kLSR: {
+          newVal = constVal - (static_cast<unsigned>(constVal) >> amount);
+          break;
+        }
+        case BitShiftOperand::kASR: {
+          newVal = constVal - (constVal >> amount);
+          break;
+        }
+        default:
+          CHECK_FATAL(false, "NYI");
+          break;
+      }
+      newMop = (arithMop == MOP_wsubrrrs) ? MOP_wmovri32 : MOP_xmovri64;
+      break;
+    }
+    default:
+      ASSERT(false, "this case is not supported currently");
+      break;
+  }
+  return newMop;
+}
+
+void A64ConstProp::ReplaceInsnAndUpdateSSA(Insn &oriInsn, Insn &newInsn) const {
+  ssaInfo->ReplaceInsn(oriInsn, newInsn);
+  oriInsn.GetBB()->ReplaceInsn(oriInsn, newInsn);
+  /* dump insn replacement here */
+}
+
+bool A64ConstProp::MovConstReplace(DUInsnInfo &useDUInfo, ImmOperand &constOpnd) const {
+  Insn *useInsn = useDUInfo.GetInsn();
+  MOperator curMop = useInsn->GetMachineOpcode();
+  if (useDUInfo.GetOperands().size() == 1) {
+    MOperator newMop = GetRegImmMOP(curMop, false);
+    Operand &destOpnd = useInsn->GetOperand(kInsnFirstOpnd);
+    if (constOpnd.IsSingleInstructionMovable(destOpnd.GetSize())) {
+      auto useOpndInfoIt = useDUInfo.GetOperands().cbegin();
+      uint32 useOpndIdx = useOpndInfoIt->first;
+      ASSERT(useOpndIdx == kInsnSecondOpnd, "invalid instruction in ssa form");
+      if (useOpndIdx == kInsnSecondOpnd) {
+        Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, destOpnd, constOpnd);
+        ReplaceInsnAndUpdateSSA(*useInsn, newInsn);
+        return true;
+      }
+    }
+  } else {
+    ASSERT(false, "invalid instruction in ssa form");
+  }
+  return false;
+}
+
+bool A64ConstProp::ArithConstReplaceForOneOpnd(Insn &useInsn, DUInsnInfo &useDUInfo,
+                                               ImmOperand &constOpnd, ArithmeticType aT) {
+  MOperator curMop = useInsn.GetMachineOpcode();
+  MOperator newMop = GetRegImmMOP(curMop, false);
+  auto useOpndInfoIt = useDUInfo.GetOperands().cbegin();
+  uint32 useOpndIdx = useOpndInfoIt->first;
+  CHECK_FATAL(useOpndIdx == kInsnSecondOpnd || useOpndIdx == kInsnThirdOpnd, "check this insn");
+  Insn *newInsn = nullptr;
+  if (static_cast<AArch64CGFunc*>(cgFunc)->IsOperandImmValid(newMop, &constOpnd, kInsnThirdOpnd)) {
+    if (useOpndIdx == kInsnThirdOpnd) {
+      newInsn = &cgFunc->GetInsnBuilder()->BuildInsn(
+        newMop, useInsn.GetOperand(kInsnFirstOpnd), useInsn.GetOperand(kInsnSecondOpnd), constOpnd);
+    } else if (useOpndIdx == kInsnSecondOpnd && aT == kAArch64Add) { /* swap operand due to legality in aarch */
+      newInsn = &cgFunc->GetInsnBuilder()->BuildInsn(
+        newMop, useInsn.GetOperand(kInsnFirstOpnd), useInsn.GetOperand(kInsnThirdOpnd), constOpnd);
+    }
+  }
+  /* try aggressive opt in aarch64 add and sub */
+  if (newInsn == nullptr && (aT == kAArch64Add || aT == kAArch64Sub)) {
+    auto *tempImm = static_cast<ImmOperand*>(constOpnd.Clone(*constPropMp));
+    /* try aarch64 imm shift mode */
+    tempImm->SetValue(tempImm->GetValue() >> 12);
+    if (static_cast<AArch64CGFunc*>(cgFunc)->IsOperandImmValid(newMop, tempImm, kInsnThirdOpnd) &&
+        CGOptions::GetInstance().GetOptimizeLevel() < CGOptions::kLevel0) {
+      ASSERT(false, "NIY");
+    }
+    auto *zeroImm = &(static_cast<AArch64CGFunc*>(cgFunc)->
+      CreateImmOperand(0, constOpnd.GetSize(), true));
+    /* value in immOpnd is signed */
+    if (MayOverflow(*zeroImm, constOpnd, constOpnd.GetSize() == 64, false, true)) {
+      return false;
+    }
+    /* (constA - var) can not reversal to (var + (-constA)) */
+    if (useOpndIdx == kInsnSecondOpnd && aT == kAArch64Sub) {
+      return false;
+    }
+    /* Addition and subtraction reversal */
+    tempImm->SetValue(-constOpnd.GetValue());
+    newMop = GetReversalMOP(newMop);
+    if (static_cast<AArch64CGFunc*>(cgFunc)->IsOperandImmValid(newMop, tempImm, kInsnThirdOpnd)) {
+      auto *cgImm = static_cast<ImmOperand*>(tempImm->Clone(*cgFunc->GetMemoryPool()));
+      newInsn = &cgFunc->GetInsnBuilder()->BuildInsn(
+        newMop, useInsn.GetOperand(kInsnFirstOpnd), useInsn.GetOperand(kInsnSecondOpnd), *cgImm);
+      if (useOpndIdx == kInsnSecondOpnd) { /* swap operand due to legality in aarch */
+        newInsn->SetOperand(kInsnSecondOpnd, useInsn.GetOperand(kInsnThirdOpnd));
+      }
+    }
+  }
+  if (newInsn == nullptr) {
+    return false;
+  }
+  ReplaceInsnAndUpdateSSA(useInsn, *newInsn);
+  return true;
+}
+
+bool A64ConstProp::ArithmeticConstReplace(DUInsnInfo &useDUInfo, ImmOperand &constOpnd, ArithmeticType aT) {
+  Insn *useInsn = useDUInfo.GetInsn();
+  CHECK_FATAL(useInsn != nullptr, "get useInsn failed");
+  if (useDUInfo.GetOperands().size() == 1) {
+    return ArithConstReplaceForOneOpnd(*useInsn, useDUInfo, constOpnd, aT);
+  } else if (useDUInfo.GetOperands().size() == 2) {
+    /* only support add & sub now */
+    int64 newValue = 0;
+    MOperator newMop = GetFoldMopAndVal(newValue, constOpnd.GetValue(), *useInsn);
+    bool isSigned = (newValue < 0);
+    auto *tempImm = static_cast<ImmOperand*>(constOpnd.Clone(*constPropMp));
+    tempImm->SetValue(newValue);
+    tempImm->SetSigned(isSigned);
+    if (tempImm->IsSingleInstructionMovable()) {
+      auto *newImmOpnd = static_cast<ImmOperand*>(tempImm->Clone(*cgFunc->GetMemoryPool()));
+      auto &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+          newMop, useInsn->GetOperand(kInsnFirstOpnd), *newImmOpnd);
+      ReplaceInsnAndUpdateSSA(*useInsn, newInsn);
+      return true;
+    } else {
+      CHECK_FATAL(false, "invalid immediate");
+    }
+  } else {
+    ASSERT(false, "invalid instruction in ssa form");
+  }
+  return false;
+}
+
+bool A64ConstProp::ArithmeticConstFold(DUInsnInfo &useDUInfo, const ImmOperand &constOpnd,
+                                       ArithmeticType aT) const {
+  Insn *useInsn = useDUInfo.GetInsn();
+  if (useDUInfo.GetOperands().size() == 1) {
+    Operand &existedImm = useInsn->GetOperand(kInsnThirdOpnd);
+    ASSERT(existedImm.IsImmediate(), "must be");
+    Operand &destOpnd = useInsn->GetOperand(kInsnFirstOpnd);
+    bool is64Bit = destOpnd.GetSize() == k64BitSize;
+    ImmOperand *foldConst = CanDoConstFold(constOpnd, static_cast<ImmOperand&>(existedImm), aT, is64Bit);
+    if (foldConst != nullptr) {
+      MOperator newMop = is64Bit ? MOP_xmovri64 : MOP_wmovri32;
+      Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, destOpnd, *foldConst);
+      ReplaceInsnAndUpdateSSA(*useInsn, newInsn);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool A64ConstProp::ShiftConstReplace(DUInsnInfo &useDUInfo, const ImmOperand &constOpnd) {
+  Insn *useInsn = useDUInfo.GetInsn();
+  MOperator curMop = useInsn->GetMachineOpcode();
+  if (useDUInfo.GetOperands().size() == 1) {
+    auto useOpndInfoIt = useDUInfo.GetOperands().cbegin();
+    uint32 useOpndIdx = useOpndInfoIt->first;
+    if (useOpndIdx == kInsnThirdOpnd) {
+      auto &shiftBit = static_cast<BitShiftOperand&>(useInsn->GetOperand(kInsnFourthOpnd));
+      int64 val = constOpnd.GetValue();
+      if (shiftBit.GetShiftOp() == BitShiftOperand::kLSL) {
+        val = val << shiftBit.GetShiftAmount();
+      } else if (shiftBit.GetShiftOp() == BitShiftOperand::kLSR) {
+        val = val >> shiftBit.GetShiftAmount();
+      } else if (shiftBit.GetShiftOp() == BitShiftOperand::kASR) {
+        val = static_cast<int64>((static_cast<uint64>(val)) >> shiftBit.GetShiftAmount());
+      } else {
+        CHECK_FATAL(false, "shift type is not defined");
+      }
+      auto *newImm = static_cast<ImmOperand*>(constOpnd.Clone(*constPropMp));
+      newImm->SetValue(val);
+      MOperator newMop = GetRegImmMOP(curMop, false);
+      if (static_cast<AArch64CGFunc*>(cgFunc)->IsOperandImmValid(newMop, newImm, kInsnThirdOpnd)) {
+        auto *cgNewImm = static_cast<ImmOperand*>(constOpnd.Clone(*cgFunc->GetMemoryPool()));
+        Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+            newMop, useInsn->GetOperand(kInsnFirstOpnd), useInsn->GetOperand(kInsnSecondOpnd), *cgNewImm);
+        ReplaceInsnAndUpdateSSA(*useInsn, newInsn);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool A64ConstProp::ConstProp(DUInsnInfo &useDUInfo, ImmOperand &constOpnd) {
+  MOperator curMop = useDUInfo.GetInsn()->GetMachineOpcode();
+  switch (curMop) {
+    case MOP_xmovrr:
+    case MOP_wmovrr: {
+      return MovConstReplace(useDUInfo, constOpnd);
+    }
+    case MOP_xsubrrr:
+    case MOP_wsubrrr: {
+      return ArithmeticConstReplace(useDUInfo, constOpnd, kAArch64Sub);
+    }
+    case MOP_xaddrrr:
+    case MOP_waddrrr: {
+      return ArithmeticConstReplace(useDUInfo, constOpnd, kAArch64Add);
+    }
+    case MOP_xaddrri12:
+    case MOP_waddrri12: {
+      return ArithmeticConstFold(useDUInfo, constOpnd, kAArch64Add);
+    }
+    case MOP_xsubrri12:
+    case MOP_wsubrri12: {
+      return ArithmeticConstFold(useDUInfo, constOpnd, kAArch64Sub);
+    }
+    case MOP_xandrrr:
+    case MOP_wandrrr:
+    case MOP_xeorrrr:
+    case MOP_weorrrr:
+    case MOP_xiorrrr:
+    case MOP_wiorrrr: {
+      return ArithmeticConstReplace(useDUInfo, constOpnd, kAArch64Logic);
+    }
+    case MOP_xiorrrrs:
+    case MOP_wiorrrrs:
+    case MOP_xeorrrrs:
+    case MOP_weorrrrs:
+    case MOP_xandrrrs:
+    case MOP_wandrrrs:
+    case MOP_xaddrrrs:
+    case MOP_waddrrrs:
+    case MOP_wsubrrrs:
+    case MOP_xsubrrrs: {
+      return ShiftConstReplace(useDUInfo, constOpnd);
+    }
+    case MOP_wbfirri5i5:
+    case MOP_xbfirri6i6: {
+      return BitInsertReplace(useDUInfo, constOpnd);
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+bool A64ConstProp::BitInsertReplace(DUInsnInfo &useDUInfo, const ImmOperand &constOpnd) const {
+  Insn *useInsn = useDUInfo.GetInsn();
+  MOperator curMop = useInsn->GetMachineOpcode();
+  if (useDUInfo.GetOperands().size() == 1) {
+    auto useOpndInfoIt = useDUInfo.GetOperands().cbegin();
+    uint32 useOpndIdx = useOpndInfoIt->first;
+    if (useOpndIdx == kInsnSecondOpnd) {
+      auto &lsbOpnd = static_cast<ImmOperand&>(useInsn->GetOperand(kInsnThirdOpnd));
+      auto &widthOpnd = static_cast<ImmOperand&>(useInsn->GetOperand(kInsnFourthOpnd));
+      auto val = static_cast<uint64>(constOpnd.GetValue());
+      /* bfi width in the range [1 -64] */
+      auto width = static_cast<uint64>(widthOpnd.GetValue());
+      /*  bit number of the lsb of the destination bitfield */
+      auto lsb = static_cast<uint64>(lsbOpnd.GetValue());
+      val = val & ((1U << width) - 1U);
+      if (__builtin_popcountl(val) == static_cast<int64>(width)) {
+        val = val << lsb;
+        MOperator newMop = GetRegImmMOP(curMop, false);
+        Operand &newOpnd = cgFunc->CreateImmOperand(PTY_i64, static_cast<int64>(val));
+        if (static_cast<AArch64CGFunc*>(cgFunc)->IsOperandImmValid(newMop, &newOpnd, kInsnThirdOpnd)) {
+          RegOperand *defOpnd = useInsn->GetSSAImpDefOpnd();
+          CHECK_FATAL(defOpnd, "check ssaInfo of the defOpnd");
+          Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(
+              newMop, *defOpnd, useInsn->GetOperand(kInsnFirstOpnd), newOpnd);
+          ReplaceInsnAndUpdateSSA(*useInsn, newInsn);
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+ImmOperand *A64ConstProp::CanDoConstFold(
+    const ImmOperand &value1, const ImmOperand &value2, ArithmeticType aT, bool is64Bit) const {
+  auto *tempImm = static_cast<ImmOperand*>(value1.Clone(*constPropMp));
+  int64 newVal = 0;
+  bool isSigned = value1.IsSignedValue();
+  if (value1.IsSignedValue() != value2.IsSignedValue()) {
+    isSigned = false;
+  }
+  if (MayOverflow(value1, value2, is64Bit, aT == kAArch64Add, isSigned)) {
+    return nullptr;
+  }
+  switch (aT) {
+    case kAArch64Add : {
+      newVal = value1.GetValue() + value2.GetValue();
+      break;
+    }
+    case kAArch64Sub : {
+      newVal = value1.GetValue() - value2.GetValue();
+      break;
+    }
+    default:
+      return nullptr;
+  }
+  if (!is64Bit && isSigned && (newVal > INT_MAX || newVal < INT_MIN)) {
+    return nullptr;
+  }
+  if (!is64Bit && !isSigned && (newVal > UINT_MAX || newVal < 0)) {
+    return nullptr;
+  }
+  if (newVal < 0) {
+    tempImm->SetSigned();
+  }
+  tempImm->SetValue(newVal);
+  if (value2.GetVary() == kUnAdjustVary) {
+    tempImm->SetVary(kUnAdjustVary);
+  }
+  bool canBeMove = tempImm->IsSingleInstructionMovable(k64BitSize);
+  return canBeMove ? static_cast<ImmOperand*>(tempImm->Clone(*cgFunc->GetMemoryPool())) : nullptr;
+}
+
+void A64StrLdrProp::DoOpt() {
+  ASSERT(curInsn != nullptr, "not input insn");
+  bool tryOptAgain = false;
+  do {
+    tryOptAgain = false;
+    Init();
+    MemOperand *currMemOpnd = StrLdrPropPreCheck(*curInsn);
+    if (currMemOpnd != nullptr && memPropMode != kUndef) {
+      /* can be changed to recursive propagation */
+      if (ReplaceMemOpnd(*currMemOpnd)) {
+        tryOptAgain = true;
+      }
+      replaceVersions.clear();
+    }
+  } while (tryOptAgain);
+}
+
+bool A64StrLdrProp::IsSameOpndsOfInsn(const Insn &insn1, const Insn &insn2, uint32 opndIdx) {
+  Operand &opnd = insn2.GetOperand(opndIdx);
+  Operand::OperandType opndType = opnd.GetKind();
+  switch (opndType) {
+    case Operand::kOpdRegister: {
+      if (!static_cast<RegOperand&>(opnd).Equals(static_cast<RegOperand&>(insn1.GetOperand(opndIdx)))) {
+        return false;
+      }
+      break;
+    }
+    case Operand::kOpdImmediate: {
+      if (!static_cast<ImmOperand&>(opnd).Equals(static_cast<ImmOperand&>(insn1.GetOperand(opndIdx)))) {
+        return false;
+      }
+      break;
+    }
+    case Operand::kOpdExtend: {
+      if (!static_cast<ExtendShiftOperand&>(opnd).Equals(
+          static_cast<ExtendShiftOperand&>(insn1.GetOperand(opndIdx)))) {
+        return false;
+      }
+      break;
+    }
+    case Operand::kOpdShift: {
+      if (!static_cast<BitShiftOperand&>(opnd).Equals(
+          static_cast<BitShiftOperand&>(insn1.GetOperand(opndIdx)))) {
+        return false;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  return true;
+}
+
+bool A64StrLdrProp::IsPhiInsnValid(const Insn &phiInsn) {
+  std::vector<Insn*> validDefInsns;
+  auto &phiOpnd = static_cast<PhiOperand&>(phiInsn.GetOperand(kInsnSecondOpnd));
+  for (auto useIt : phiOpnd.GetOperands()) {
+    ASSERT(useIt.second != nullptr, "get phiUseOpnd failed");
+    Insn *defPhiInsn = ssaInfo->GetDefInsn(*useIt.second);
+    /* check only one layer of phi */
+    if (defPhiInsn == nullptr || defPhiInsn->IsPhi()) {
+      return false;
+    }
+    (void)validDefInsns.emplace_back(defPhiInsn);
+  }
+  if (validDefInsns.empty()) {
+    return false;
+  }
+  MOperator mOp = validDefInsns[0]->GetMachineOpcode();
+  uint32 opndNum = validDefInsns[0]->GetOperandSize();
+  for (uint32 insnIdx = 1; insnIdx < validDefInsns.size(); ++insnIdx) {
+    Insn *insn = validDefInsns[insnIdx];
+    if (insn->GetMachineOpcode() != mOp) {
+      return false;
+    }
+    if (insn->GetOperandSize() != opndNum) {
+      return false;
+    }
+    for (uint i = 0 ; i < opndNum; ++i) {
+      if (insn->OpndIsDef(i)) {
+        continue;
+      }
+      if (!IsSameOpndsOfInsn(*validDefInsns[0], *insn, i)) {
+        return false;
+      }
+    }
+  }
+  defInsn = validDefInsns[0];
+  return true;
+}
+
+Insn *A64StrLdrProp::GetDefInsn(const RegOperand &regOpnd, std::vector<Insn*> &allUseInsns) {
+  Insn *insn = nullptr;
+  if (regOpnd.IsSSAForm()) {
+    VRegVersion *replacedV = ssaInfo->FindSSAVersion(regOpnd.GetRegisterNumber());
+    if (replacedV->GetDefInsnInfo() != nullptr) {
+      for (auto it : replacedV->GetAllUseInsns()) {
+        (void)allUseInsns.emplace_back(it.second->GetInsn());
+      }
+      insn = replacedV->GetDefInsnInfo()->GetInsn();
+    }
+  }
+  return insn;
+}
+
+bool A64StrLdrProp::ReplaceMemOpnd(const MemOperand &currMemOpnd) {
+  RegOperand *replacedReg = nullptr;
+  if (memPropMode == kPropBase) {
+    replacedReg = currMemOpnd.GetBaseRegister();
+  } else {
+    Operand *offset = currMemOpnd.GetOffset();
+    ASSERT(offset->IsRegister(), "must be");
+    replacedReg = static_cast<RegOperand*>(offset);
+  }
+  CHECK_FATAL(replacedReg != nullptr, "check this insn");
+  std::vector<Insn*> allUseInsns;
+  std::vector<MemOperand*> newMemOpnds;
+  defInsn = GetDefInsn(*replacedReg, allUseInsns);
+  if (defInsn == nullptr) {
+    return false;
+  }
+  for (auto useInsn : allUseInsns) {
+    MemOperand *oldMemOpnd = StrLdrPropPreCheck(*useInsn, memPropMode);
+    if (CheckSameReplace(*replacedReg, oldMemOpnd)) {
+      if (defInsn->IsPhi() && !IsPhiInsnValid(*defInsn)) {
+        return false;
+      }
+      MemOperand *newMemOpnd = SelectReplaceMem(*oldMemOpnd);
+      if (newMemOpnd != nullptr) {
+        uint32 opndIdx = GetMemOpndIdx(oldMemOpnd, *useInsn);
+        if (CheckNewMemOffset(*useInsn, newMemOpnd, opndIdx)) {
+          newMemOpnds.emplace_back(newMemOpnd);
+          continue;
+        }
+      }
+    }
+    return false;
+  }
+  /* due to register pressure, do not do partial prop */
+  for (size_t i = 0; i < newMemOpnds.size(); ++i) {
+    DoMemReplace(*replacedReg, *newMemOpnds[i], *allUseInsns[i]);
+  }
+  return true;
+}
+
+bool A64StrLdrProp::CheckSameReplace(const RegOperand &replacedReg, const MemOperand *memOpnd) const {
+  if (memOpnd != nullptr && memPropMode != kUndef) {
+    if (memPropMode == kPropBase) {
+      return replacedReg.GetRegisterNumber() ==  memOpnd->GetBaseRegister()->GetRegisterNumber();
+    } else {
+      Operand *offset = memOpnd->GetOffset();
+      ASSERT(offset != nullptr, "offset should not be nullptr");
+      ASSERT(offset->IsRegister(), "must be");
+      return replacedReg.GetRegisterNumber() == static_cast<RegOperand*>(offset)->GetRegisterNumber();
+    }
+  }
+  return false;
+}
+
+uint32 A64StrLdrProp::GetMemOpndIdx(MemOperand *newMemOpnd, const Insn &insn) const {
+  uint32 opndIdx = kInsnMaxOpnd;
+  if (insn.IsLoadPair() || insn.IsStorePair()) {
+    ASSERT(newMemOpnd->GetOffsetImmediate() != nullptr, "unexpect insn");
+    opndIdx = kInsnThirdOpnd;
+  } else {
+    opndIdx = kInsnSecondOpnd;
+  }
+  return opndIdx;
+}
+
+void A64StrLdrProp::DoMemReplace(const RegOperand &replacedReg, MemOperand &newMem, Insn &useInsn) {
+  VRegVersion *replacedV = ssaInfo->FindSSAVersion(replacedReg.GetRegisterNumber());
+  ASSERT(replacedV != nullptr, "must in ssa form");
+  uint32 opndIdx = GetMemOpndIdx(&newMem, useInsn);
+  replacedV->RemoveUseInsn(useInsn, opndIdx);
+  if (replacedV->GetAllUseInsns().empty()) {
+    (void)cgDce->RemoveUnuseDef(*replacedV);
+  }
+  for (auto &replaceit : as_const(replaceVersions)) {
+    replaceit.second->AddUseInsn(*ssaInfo, useInsn, opndIdx);
+  }
+  useInsn.SetOperand(opndIdx, newMem);
+}
+
+MemOperand *A64StrLdrProp::StrLdrPropPreCheck(const Insn &insn, MemPropMode prevMod) {
+  memPropMode = kUndef;
+  if (insn.IsLoad() || insn.IsStore()) {
+    if (insn.IsAtomic()) {
+      return nullptr;
+    }
+    auto *currMemOpnd = static_cast<MemOperand*>(insn.GetMemOpnd());
+    if (currMemOpnd != nullptr) {
+      memPropMode = SelectStrLdrPropMode(*currMemOpnd);
+      if (prevMod != kUndef) {
+        if (prevMod != memPropMode) {
+          memPropMode = prevMod;
+          return nullptr;
+        }
+      }
+      return currMemOpnd;
+    }
+  }
+  return nullptr;
+}
+
+MemPropMode A64StrLdrProp::SelectStrLdrPropMode(const MemOperand &currMemOpnd) {
+  MemOperand::AArch64AddressingMode currAddrMode = currMemOpnd.GetAddrMode();
+  MemPropMode innerMemPropMode = kUndef;
+  switch (currAddrMode) {
+    case MemOperand::kAddrModeBOi: {
+      if (!currMemOpnd.IsPreIndexed() && !currMemOpnd.IsPostIndexed()) {
+        innerMemPropMode = kPropBase;
+      }
+      break;
+    }
+    case MemOperand::kAddrModeBOrX: {
+      innerMemPropMode = kPropOffset;
+      auto amount = currMemOpnd.ShiftAmount();
+      if (currMemOpnd.GetExtendAsString() == "LSL") {
+        if (amount != 0) {
+          innerMemPropMode = kPropShift;
+        }
+        break;
+      } else if (currMemOpnd.SignedExtend()) {
+        innerMemPropMode = kPropSignedExtend;
+      } else if (currMemOpnd.UnsignedExtend()) {
+        innerMemPropMode = kPropUnsignedExtend;
+      }
+      break;
+    }
+    default:
+      innerMemPropMode = kUndef;
+  }
+  return innerMemPropMode;
+}
+
+MemOperand *A64StrLdrProp::SelectReplaceMem(const MemOperand &currMemOpnd) {
+  MemOperand *newMemOpnd = nullptr;
+  Operand *offset = currMemOpnd.GetOffset();
+  RegOperand *base = currMemOpnd.GetBaseRegister();
+  MOperator opCode = defInsn->GetMachineOpcode();
+  switch (opCode) {
+    case MOP_xsubrri12:
+    case MOP_wsubrri12: {
+      RegOperand *replace = GetReplaceReg(static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd)));
+      if (replace != nullptr) {
+        auto &immOpnd = static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        int64 defVal = -(immOpnd.GetValue());
+        newMemOpnd = HandleArithImmDef(*replace, offset, defVal, currMemOpnd.GetSize());
+      }
+      break;
+    }
+    case MOP_xaddrri12:
+    case MOP_waddrri12: {
+      RegOperand *replace = GetReplaceReg(static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd)));
+      if (replace != nullptr) {
+        auto &immOpnd = static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        int64 defVal = immOpnd.GetValue();
+        newMemOpnd = HandleArithImmDef(*replace, offset, defVal, currMemOpnd.GetSize());
+      }
+      break;
+    }
+    case MOP_xaddrri24:
+    case MOP_waddrri24: {
+      RegOperand *replace = GetReplaceReg(static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd)));
+      if (replace != nullptr) {
+        auto &immOpnd = static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        auto &shiftOpnd = static_cast<BitShiftOperand&>(defInsn->GetOperand(kInsnFourthOpnd));
+        CHECK_FATAL(shiftOpnd.GetShiftAmount() == 12, "invalid shiftAmount");
+        auto defVal = static_cast<int64>(static_cast<uint64>(immOpnd.GetValue()) << shiftOpnd.GetShiftAmount());
+        newMemOpnd = HandleArithImmDef(*replace, offset, defVal, currMemOpnd.GetSize());
+      }
+      break;
+    }
+    case MOP_xsubrri24:
+    case MOP_wsubrri24: {
+      RegOperand *replace = GetReplaceReg(static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd)));
+      if (replace != nullptr) {
+        auto &immOpnd = static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        auto &shiftOpnd = static_cast<BitShiftOperand&>(defInsn->GetOperand(kInsnFourthOpnd));
+        CHECK_FATAL(shiftOpnd.GetShiftAmount() == 12, "invalid shiftAmount");
+        int64 defVal = -static_cast<int64>(static_cast<uint64>(immOpnd.GetValue()) << shiftOpnd.GetShiftAmount());
+        newMemOpnd = HandleArithImmDef(*replace, offset, defVal, currMemOpnd.GetSize());
+      }
+      break;
+    }
+    case MOP_xaddrrr:
+    case MOP_waddrrr:
+    case MOP_dadd:
+    case MOP_sadd: {
+      if (memPropMode == kPropBase) {
+        ASSERT(offset != nullptr, "offset should not be nullptr");
+        auto *ofstOpnd = static_cast<ImmOperand*>(offset);
+        if (!ofstOpnd->IsZero()) {
+          break;
+        }
+
+        RegOperand *replace = GetReplaceReg(static_cast<RegOperand &>(defInsn->GetOperand(kInsnSecondOpnd)));
+        RegOperand *newOfst = GetReplaceReg(static_cast<RegOperand &>(defInsn->GetOperand(kInsnThirdOpnd)));
+        if (replace != nullptr && newOfst != nullptr) {
+          newMemOpnd = static_cast<AArch64CGFunc *>(cgFunc)->CreateMemOperand(
+              MemOperand::kAddrModeBOrX, currMemOpnd.GetSize(), *replace, newOfst, nullptr, nullptr);
+        }
+      }
+      break;
+    }
+    case MOP_xaddrrrs:
+    case MOP_waddrrrs: {
+      if (memPropMode == kPropBase) {
+        auto *ofstOpnd = static_cast<ImmOperand*>(offset);
+        if (!ofstOpnd->IsZero()) {
+          break;
+        }
+        RegOperand *newBaseOpnd = GetReplaceReg(
+            static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd)));
+        RegOperand *newIndexOpnd = GetReplaceReg(
+            static_cast<RegOperand&>(defInsn->GetOperand(kInsnThirdOpnd)));
+        auto &shift = static_cast<BitShiftOperand&>(defInsn->GetOperand(kInsnFourthOpnd));
+        if (shift.GetShiftOp() != BitShiftOperand::kLSL) {
+          break;
+        }
+        if (newBaseOpnd != nullptr && newIndexOpnd != nullptr) {
+          newMemOpnd = static_cast<AArch64CGFunc*>(cgFunc)->CreateMemOperand(
+              MemOperand::kAddrModeBOrX, currMemOpnd.GetSize(), *newBaseOpnd, *newIndexOpnd,
+              shift.GetShiftAmount(), false);
+        }
+      }
+      break;
+    }
+    case MOP_xadrpl12: {
+      if (memPropMode == kPropBase) {
+        if (currMemOpnd.GetSize() >= 128) {
+          // We can not be sure that the page offset is 16-byte aligned
+          break;
+        }
+        auto *ofstOpnd = static_cast<ImmOperand*>(offset);
+        CHECK_FATAL(ofstOpnd != nullptr, "oldOffset is null!");
+        int64 val = ofstOpnd->GetValue();
+        auto *offset1 = static_cast<StImmOperand*>(&defInsn->GetOperand(kInsnThirdOpnd));
+        CHECK_FATAL(offset1 != nullptr, "offset1 is null!");
+        val += offset1->GetOffset();
+        OfstOperand *newOfsetOpnd = &static_cast<AArch64CGFunc*>(cgFunc)->CreateOfstOpnd(static_cast<uint64>(val),
+            k32BitSize);
+        CHECK_FATAL(newOfsetOpnd != nullptr, "newOfsetOpnd is null!");
+        const MIRSymbol *addr = offset1->GetSymbol();
+        /* do not guarantee rodata alignment at Os */
+        if (CGOptions::OptimizeForSize() && addr->IsReadOnly()) {
+          break;
+        }
+        RegOperand *replace = GetReplaceReg(
+            static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd)));
+        if (replace != nullptr) {
+          newMemOpnd = static_cast<AArch64CGFunc*>(cgFunc)->CreateMemOperand(
+              MemOperand::kAddrModeLo12Li, currMemOpnd.GetSize(), *replace, nullptr, newOfsetOpnd, addr);
+        }
+      }
+      break;
+    }
+    /* do this in const prop ? */
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      if (memPropMode == kPropOffset) {
+        auto *imm = static_cast<ImmOperand*>(&defInsn->GetOperand(kInsnSecondOpnd));
+        OfstOperand *newOffset = &static_cast<AArch64CGFunc*>(cgFunc)->CreateOfstOpnd(
+            static_cast<uint64>(imm->GetValue()), k32BitSize);
+        CHECK_FATAL(newOffset != nullptr, "newOffset is null!");
+        newMemOpnd = static_cast<AArch64CGFunc*>(cgFunc)->CreateMemOperand(
+            MemOperand::kAddrModeBOi, currMemOpnd.GetSize(), *base, nullptr, newOffset, nullptr);
+      }
+      break;
+    }
+    case MOP_xlslrri6:
+    case MOP_wlslrri5: {
+      auto *imm = static_cast<ImmOperand*>(&defInsn->GetOperand(kInsnThirdOpnd));
+      RegOperand *newOfst = GetReplaceReg(static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd)));
+      if (newOfst != nullptr) {
+        auto shift = static_cast<uint32>(static_cast<int32>(imm->GetValue()));
+        if (memPropMode == kPropOffset) {
+          if (shift < k4ByteSize) {
+            newMemOpnd = static_cast<AArch64CGFunc*>(cgFunc)->CreateMemOperand(
+                MemOperand::kAddrModeBOrX, currMemOpnd.GetSize(), *base, *newOfst, shift);
+          }
+        } else if (memPropMode == kPropShift) {
+          shift += currMemOpnd.ShiftAmount();
+          if (shift < k4ByteSize) {
+            newMemOpnd = static_cast<AArch64CGFunc*>(cgFunc)->CreateMemOperand(
+                MemOperand::kAddrModeBOrX, currMemOpnd.GetSize(), *base, *newOfst, shift);
+          }
+        }
+      }
+      break;
+    }
+    case MOP_xsxtw64: {
+      newMemOpnd = SelectReplaceExt(*base, static_cast<uint32>(currMemOpnd.ShiftAmount()),
+                                    true, currMemOpnd.GetSize());
+      break;
+    }
+    case MOP_xuxtw64: {
+      newMemOpnd = SelectReplaceExt(*base, static_cast<uint32>(currMemOpnd.ShiftAmount()),
+                                    false, currMemOpnd.GetSize());
+      break;
+    }
+    default:
+      break;
+  }
+  return newMemOpnd;
+}
+
+RegOperand *A64StrLdrProp::GetReplaceReg(RegOperand &a64Reg) {
+  if (a64Reg.IsSSAForm()) {
+    regno_t ssaIndex = a64Reg.GetRegisterNumber();
+    replaceVersions[ssaIndex] = ssaInfo->FindSSAVersion(ssaIndex);
+    ASSERT(replaceVersions.size() <= 2, "CHECK THIS CASE IN A64PROP");
+    return &a64Reg;
+  }
+  return nullptr;
+}
+
+MemOperand *A64StrLdrProp::HandleArithImmDef(RegOperand &replace, Operand *oldOffset,
+                                             int64 defVal, uint32 memSize) const {
+  if (memPropMode != kPropBase) {
+    return nullptr;
+  }
+  OfstOperand *newOfstImm = nullptr;
+  if (oldOffset == nullptr) {
+    newOfstImm = &static_cast<AArch64CGFunc*>(cgFunc)->CreateOfstOpnd(static_cast<uint64>(defVal), k32BitSize);
+  } else {
+    auto *ofstOpnd = static_cast<OfstOperand*>(oldOffset);
+    CHECK_FATAL(ofstOpnd != nullptr, "oldOffsetOpnd is null");
+    newOfstImm = &static_cast<AArch64CGFunc*>(cgFunc)->CreateOfstOpnd(
+        static_cast<uint64>(defVal + ofstOpnd->GetValue()), k32BitSize);
+  }
+  CHECK_FATAL(newOfstImm != nullptr, "newOffset is null!");
+  return static_cast<AArch64CGFunc*>(cgFunc)->CreateMemOperand(MemOperand::kAddrModeBOi, memSize,
+      replace, nullptr, newOfstImm, nullptr);
+}
+
+MemOperand *A64StrLdrProp::SelectReplaceExt(RegOperand &base, uint32 amount, bool isSigned, uint32 memSize) {
+  MemOperand *newMemOpnd = nullptr;
+  RegOperand *newOfst = GetReplaceReg(static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd)));
+  if (newOfst == nullptr) {
+    return nullptr;
+  }
+  /* defInsn is extend, currMemOpnd is same extend or shift */
+  bool propExtend = (memPropMode == kPropShift) || ((memPropMode == kPropSignedExtend) && isSigned) ||
+                    ((memPropMode == kPropUnsignedExtend) && !isSigned);
+  if (memPropMode == kPropOffset) {
+    newMemOpnd = static_cast<AArch64CGFunc*>(cgFunc)->CreateMemOperand(
+        MemOperand::kAddrModeBOrX, memSize, base, *newOfst, 0, isSigned);
+  } else if (propExtend) {
+    newMemOpnd = static_cast<AArch64CGFunc*>(cgFunc)->CreateMemOperand(
+        MemOperand::kAddrModeBOrX, memSize, base, *newOfst, amount, isSigned);
+  } else {
+    return nullptr;
+  }
+  return newMemOpnd;
+}
+
+bool A64StrLdrProp::CheckNewMemOffset(const Insn &insn, MemOperand *newMemOpnd, uint32 opndIdx) const {
+  auto *a64CgFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  if ((newMemOpnd->GetOffsetImmediate() != nullptr) &&
+      !a64CgFunc->IsOperandImmValid(insn.GetMachineOpcode(), newMemOpnd, opndIdx)) {
+    return false;
+  }
+  auto newAmount = static_cast<uint32>(newMemOpnd->ShiftAmount());
+  if (!AArch64StoreLoadOpt::CheckNewAmount(insn, newAmount)) {
+    return false;
+  }
+  /* is ldp or stp, addrMode must be BOI */
+  if ((opndIdx == kInsnThirdOpnd) && (newMemOpnd->GetAddrMode() != MemOperand::kAddrModeBOi)) {
+    return false;
+  }
+  return true;
+}
+
+void AArch64Prop::PropPatternOpt() {
+  PropOptimizeManager optManager;
+  optManager.Optimize<ExtendMovPattern>(*cgFunc, GetSSAInfo());
+  optManager.Optimize<ExtendShiftPattern>(*cgFunc, GetSSAInfo());
+  optManager.Optimize<FpSpConstProp>(*cgFunc, GetSSAInfo());
+  optManager.Optimize<A64PregCopyPattern>(*cgFunc, GetSSAInfo());
+  optManager.Optimize<A64ConstFoldPattern>(*cgFunc, GetSSAInfo());
+}
+
+bool ExtendShiftPattern::IsSwapInsn(const Insn &insn) const {
+  MOperator op = insn.GetMachineOpcode();
+  switch (op) {
+    case MOP_xaddrrr:
+    case MOP_waddrrr:
+    case MOP_xiorrrr:
+    case MOP_wiorrrr:
+      return true;
+    default:
+      return false;
+  }
+}
+
+void ExtendShiftPattern::SetExMOpType(const Insn &use) {
+  MOperator op = use.GetMachineOpcode();
+  switch (op) {
+    case MOP_xaddrrr:
+    case MOP_xxwaddrrre:
+    case MOP_xaddrrrs: {
+      exMOpType = kExAdd;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_waddrrr:
+    case MOP_wwwaddrrre:
+    case MOP_waddrrrs: {
+      exMOpType = kEwAdd;
+      break;
+    }
+    case MOP_xsubrrr:
+    case MOP_xxwsubrrre:
+    case MOP_xsubrrrs: {
+      exMOpType = kExSub;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_wsubrrr:
+    case MOP_wwwsubrrre:
+    case MOP_wsubrrrs: {
+      exMOpType = kEwSub;
+      break;
+    }
+    case MOP_xcmnrr:
+    case MOP_xwcmnrre:
+    case MOP_xcmnrrs: {
+      exMOpType = kExCmn;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_wcmnrr:
+    case MOP_wwcmnrre:
+    case MOP_wcmnrrs: {
+      exMOpType = kEwCmn;
+      break;
+    }
+    case MOP_xcmprr:
+    case MOP_xwcmprre:
+    case MOP_xcmprrs: {
+      exMOpType = kExCmp;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_wcmprr:
+    case MOP_wwcmprre:
+    case MOP_wcmprrs: {
+      exMOpType = kEwCmp;
+      break;
+    }
+    default: {
+      exMOpType = kExUndef;
+    }
+  }
+}
+
+void ExtendShiftPattern::SetLsMOpType(const Insn &use) {
+  MOperator op = use.GetMachineOpcode();
+  switch (op) {
+    case MOP_xaddrrr:
+    case MOP_xaddrrrs: {
+      lsMOpType = kLxAdd;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_waddrrr:
+    case MOP_waddrrrs: {
+      lsMOpType = kLwAdd;
+      break;
+    }
+    case MOP_xsubrrr:
+    case MOP_xsubrrrs: {
+      lsMOpType = kLxSub;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_wsubrrr:
+    case MOP_wsubrrrs: {
+      lsMOpType = kLwSub;
+      break;
+    }
+    case MOP_xcmnrr:
+    case MOP_xcmnrrs: {
+      lsMOpType = kLxCmn;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_wcmnrr:
+    case MOP_wcmnrrs: {
+      lsMOpType = kLwCmn;
+      break;
+    }
+    case MOP_xcmprr:
+    case MOP_xcmprrs: {
+      lsMOpType = kLxCmp;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_wcmprr:
+    case MOP_wcmprrs: {
+      lsMOpType = kLwCmp;
+      break;
+    }
+    case MOP_xeorrrr:
+    case MOP_xeorrrrs: {
+      lsMOpType = kLxEor;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_weorrrr:
+    case MOP_weorrrrs: {
+      lsMOpType = kLwEor;
+      break;
+    }
+    case MOP_xinegrr:
+    case MOP_xinegrrs: {
+      lsMOpType = kLxNeg;
+      replaceIdx = kInsnSecondOpnd;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_winegrr:
+    case MOP_winegrrs: {
+      lsMOpType = kLwNeg;
+      replaceIdx = kInsnSecondOpnd;
+      break;
+    }
+    case MOP_xiorrrr:
+    case MOP_xiorrrrs: {
+      lsMOpType = kLxIor;
+      is64BitSize = true;
+      break;
+    }
+    case MOP_wiorrrr:
+    case MOP_wiorrrrs: {
+      lsMOpType = kLwIor;
+      break;
+    }
+    default: {
+      lsMOpType = kLsUndef;
+    }
+  }
+}
+
+void ExtendShiftPattern::SelectExtendOrShift(const Insn &def) {
+  MOperator op = def.GetMachineOpcode();
+  switch (op) {
+    case MOP_xsxtb32:
+    case MOP_xsxtb64: extendOp = ExtendShiftOperand::kSXTB;
+      break;
+    case MOP_xsxth32:
+    case MOP_xsxth64: extendOp = ExtendShiftOperand::kSXTH;
+      break;
+    case MOP_xsxtw64: extendOp = ExtendShiftOperand::kSXTW;
+      break;
+    case MOP_xuxtb32: extendOp = ExtendShiftOperand::kUXTB;
+      break;
+    case MOP_xuxth32: extendOp = ExtendShiftOperand::kUXTH;
+      break;
+    case MOP_xuxtw64: extendOp = ExtendShiftOperand::kUXTW;
+      break;
+    case MOP_wlslrri5:
+    case MOP_xlslrri6: shiftOp = BitShiftOperand::kLSL;
+      break;
+    case MOP_xlsrrri6:
+    case MOP_wlsrrri5: shiftOp = BitShiftOperand::kLSR;
+      break;
+    case MOP_xasrrri6:
+    case MOP_wasrrri5: shiftOp = BitShiftOperand::kASR;
+      break;
+    case MOP_wextrrrri5:
+    case MOP_xextrrrri6: shiftOp = BitShiftOperand::kROR;
+      break;
+    default: {
+      extendOp = ExtendShiftOperand::kUndef;
+      shiftOp = BitShiftOperand::kUndef;
+    }
+  }
+}
+
+/* Optimize ExtendShiftPattern:
+ * ==========================================================
+ *           nosuffix  LSL   LSR   ASR      extrn   (def)
+ * nosuffix |   F    | LSL | LSR | ASR |    extrn  |
+ * LSL      |   F    | LSL |  F  |  F  |    extrn  |
+ * LSR      |   F    |  F  | LSR |  F  |     F     |
+ * ASR      |   F    |  F  |  F  | ASR |     F     |
+ * exten    |   F    |  F  |  F  |  F  |exten(self)|
+ * (use)
+ * ===========================================================
+ */
+
+
+/* Check whether ExtendShiftPattern optimization can be performed. */
+SuffixType ExtendShiftPattern::CheckOpType(const Operand &lastOpnd) const {
+  /* Assign values to useType and defType. */
+  uint32 useType = kNoSuffix;
+  uint32 defType = shiftOp;
+  if (extendOp != ExtendShiftOperand::kUndef) {
+    defType = kExten;
+  }
+  if (lastOpnd.IsOpdShift()) {
+    BitShiftOperand lastShiftOpnd = static_cast<const BitShiftOperand&>(lastOpnd);
+    useType = lastShiftOpnd.GetShiftOp();
+  } else if (lastOpnd.IsOpdExtend()) {
+    ExtendShiftOperand lastExtendOpnd = static_cast<const ExtendShiftOperand&>(lastOpnd);
+    useType = kExten;
+    /* two insn is exten and exten ,value is exten(oneself) */
+    if (useType == defType && extendOp != lastExtendOpnd.GetExtendOp()) {
+      return kNoSuffix;
+    }
+  }
+  return kDoOptimizeTable[useType][defType];
+}
+
+constexpr uint32 kExMopTypeSize = 9;
+constexpr uint32 kLsMopTypeSize = 15;
+
+MOperator exMopTable[kExMopTypeSize] = {
+    MOP_undef, MOP_xxwaddrrre, MOP_wwwaddrrre, MOP_xxwsubrrre, MOP_wwwsubrrre,
+    MOP_xwcmnrre, MOP_wwcmnrre, MOP_xwcmprre, MOP_wwcmprre
+};
+MOperator lsMopTable[kLsMopTypeSize] = {
+    MOP_undef, MOP_xaddrrrs, MOP_waddrrrs, MOP_xsubrrrs, MOP_wsubrrrs,
+    MOP_xcmnrrs, MOP_wcmnrrs, MOP_xcmprrs, MOP_wcmprrs, MOP_xeorrrrs,
+    MOP_weorrrrs, MOP_xinegrrs, MOP_winegrrs, MOP_xiorrrrs, MOP_wiorrrrs
+};
+/* new Insn extenType:
+ * =====================
+ * (useMop)   (defMop) (newmop)
+ * | nosuffix |  all  | all|
+ * | exten    |  ex   | ex |
+ * |  ls      |  ex   | ls |
+ * |  asr     |  !asr | F  |
+ * |  !asr    |  asr  | F  |
+ * (useMop)   (defMop)
+ * =====================
+ */
+void ExtendShiftPattern::ReplaceUseInsn(Insn &use, const Insn &def, uint32 amount) {
+  AArch64CGFunc &a64CGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  uint32 lastIdx = use.GetOperandSize() - k1BitSize;
+  Operand &lastOpnd = use.GetOperand(lastIdx);
+  SuffixType optType = CheckOpType(lastOpnd);
+  Operand *shiftOpnd = nullptr;
+  if (optType == kNoSuffix) {
+    return;
+  }else if (optType == kExten) {
+    replaceOp = exMopTable[exMOpType];
+    if (amount > k4BitSize) {
+      return;
+    }
+    shiftOpnd = &a64CGFunc.CreateExtendShiftOperand(extendOp, amount, static_cast<int32>(k64BitSize));
+  } else {
+    replaceOp = lsMopTable[lsMOpType];
+    if ((is64BitSize && amount >= k64BitSize) || (!is64BitSize && amount >= k32BitSize)) {
+      return;
+    }
+    shiftOpnd = &a64CGFunc.CreateBitShiftOperand(shiftOp, amount, static_cast<int32>(k64BitSize));
+  }
+  if (replaceOp == MOP_undef) {
+    return;
+  }
+
+  Insn *replaceUseInsn = nullptr;
+  Operand &firstOpnd = use.GetOperand(kInsnFirstOpnd);
+  Operand *secondOpnd = &use.GetOperand(kInsnSecondOpnd);
+  if (replaceIdx == kInsnSecondOpnd) { /* replace neg insn */
+    secondOpnd = &def.GetOperand(kInsnSecondOpnd);
+    replaceUseInsn = &cgFunc.GetInsnBuilder()->BuildInsn(replaceOp, firstOpnd, *secondOpnd, *shiftOpnd);
+  } else {
+    Operand &thirdOpnd = def.GetOperand(kInsnSecondOpnd);
+    replaceUseInsn = &cgFunc.GetInsnBuilder()->BuildInsn(replaceOp, firstOpnd, *secondOpnd, thirdOpnd, *shiftOpnd);
+  }
+  use.GetBB()->ReplaceInsn(use, *replaceUseInsn);
+  if (PROP_DUMP) {
+    LogInfo::MapleLogger() << ">>>>>>> In ExtendShiftPattern : <<<<<<<\n";
+    LogInfo::MapleLogger() << "=======ReplaceInsn :\n";
+    use.Dump();
+    LogInfo::MapleLogger() << "=======NewInsn :\n";
+    replaceUseInsn->Dump();
+  }
+  /* update ssa info */
+  optSsaInfo->ReplaceInsn(use, *replaceUseInsn);
+  newInsn = replaceUseInsn;
+  optSuccess = true;
+}
+
+/*
+ * pattern1:
+ * UXTB/UXTW X0, W1              <---- def x0
+ * ....                          <---- (X0 not used)
+ * AND/SUB/EOR X0, X1, X0        <---- use x0
+ * ======>
+ * AND/SUB/EOR X0, X1, W1 UXTB/UXTW
+ *
+ * pattern2:
+ * LSL/LSR X0, X1, #8
+ * ....(X0 not used)
+ * AND/SUB/EOR X0, X1, X0
+ * ======>
+ * AND/SUB/EOR X0, X1, X1 LSL/LSR #8
+ */
+void ExtendShiftPattern::Optimize(Insn &insn) {
+  uint32 amount = 0;
+  uint32 offset = 0;
+  uint32 lastIdx = insn.GetOperandSize() - k1BitSize;
+  Operand &lastOpnd = insn.GetOperand(lastIdx);
+  if (lastOpnd.IsOpdShift()) {
+    auto &lastShiftOpnd = static_cast<BitShiftOperand&>(lastOpnd);
+    amount = lastShiftOpnd.GetShiftAmount();
+  } else if (lastOpnd.IsOpdExtend()) {
+    auto &lastExtendOpnd = static_cast<ExtendShiftOperand&>(lastOpnd);
+    amount = lastExtendOpnd.GetShiftAmount();
+  }
+  if (shiftOp != BitShiftOperand::kUndef) {
+    auto &immOpnd = (shiftOp == BitShiftOperand::kROR ?
+      static_cast<ImmOperand&>(defInsn->GetOperand(kInsnFourthOpnd)) :
+      static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd)));
+    offset = static_cast<uint32>(immOpnd.GetValue());
+  }
+  amount += offset;
+
+  ReplaceUseInsn(insn, *defInsn, amount);
+}
+
+void ExtendShiftPattern::DoExtendShiftOpt(Insn &insn) {
+  if (!CheckAllOpndCondition(insn)) {
+    return;
+  }
+  Optimize(*curInsn);
+  if (optSuccess) {
+    DoExtendShiftOpt(*newInsn);
+  }
+}
+
+void ExtendShiftPattern::SwapOpnd(Insn &insn) {
+  Insn *swapInsn = &cgFunc.GetInsnBuilder()->BuildInsn(insn.GetMachineOpcode(),
+                                                       insn.GetOperand(kInsnFirstOpnd),
+                                                       insn.GetOperand(kInsnThirdOpnd),
+                                                       insn.GetOperand(kInsnSecondOpnd));
+  insn.GetBB()->ReplaceInsn(insn, *swapInsn);
+  optSsaInfo->ReplaceInsn(insn, *swapInsn);
+  curInsn = swapInsn;
+  replaceIdx = kInsnThirdOpnd;
+}
+
+bool ExtendShiftPattern::CheckAllOpndCondition(Insn &insn) {
+  Init();
+  SetLsMOpType(insn);
+  SetExMOpType(insn);
+  curInsn = &insn;
+  if (IsSwapInsn(insn)) {
+    if (CheckCondition(insn)) {
+      return true;
+    }
+    Init();
+    SetLsMOpType(insn);
+    SetExMOpType(insn);
+    replaceIdx = kInsnSecondOpnd;
+    if (CheckCondition(insn)) {
+      SwapOpnd(insn);
+      return true;
+    }
+  } else {
+    return CheckCondition(insn);
+  }
+  return false;
+}
+
+/* check and set:
+ * exMOpType, lsMOpType, extendOp, shiftOp, defInsn
+ */
+bool ExtendShiftPattern::CheckCondition(Insn &insn) {
+  if ((exMOpType == kExUndef) && (lsMOpType == kLsUndef)) {
+    return false;
+  }
+  auto &regOperand = static_cast<RegOperand&>(insn.GetOperand(replaceIdx));
+  regno_t regNo = regOperand.GetRegisterNumber();
+  VRegVersion *useVersion = optSsaInfo->FindSSAVersion(regNo);
+  defInsn = FindDefInsn(useVersion);
+  // useVersion must not be nullptr when defInsn is not nullptr
+  if (!defInsn || (useVersion->GetAllUseInsns().size() > 1)) {
+    return false;
+  }
+  SelectExtendOrShift(*defInsn);
+  /* defInsn must be shift or extend */
+  if ((extendOp == ExtendShiftOperand::kUndef) && (shiftOp == BitShiftOperand::kUndef)) {
+    return false;
+  }
+  Operand &defSrcOpnd = defInsn->GetOperand(kInsnSecondOpnd);
+  CHECK_FATAL(defSrcOpnd.IsRegister(), "defSrcOpnd must be register!");
+  if (shiftOp == BitShiftOperand::kROR) {
+    if (lsMOpType != kLxEor && lsMOpType != kLwEor && lsMOpType != kLxIor && lsMOpType != kLwIor) {
+      return false;
+    }
+    Operand &defThirdOpnd = defInsn->GetOperand(kInsnThirdOpnd);
+    CHECK_FATAL(defThirdOpnd.IsRegister(), "defThirdOpnd must be register");
+    if (static_cast<RegOperand&>(defSrcOpnd).GetRegisterNumber() !=
+        static_cast<RegOperand&>(defThirdOpnd).GetRegisterNumber()) {
+      return false;
+    }
+  }
+  auto &regDefSrc = static_cast<RegOperand&>(defSrcOpnd);
+  if (regDefSrc.IsPhysicalRegister()) {
+    return false;
+  }
+  /*
+   * has Implict cvt
+   *
+   * avoid cases as following:
+   *   lsr  x2, x2, #8
+   *   ubfx w2, x2, #0, #32                lsr  x2, x2, #8
+   *   eor  w0, w0, w2           ===>      eor  w0, w0, x2     ==\=>  eor w0, w0, w2, LSR #8
+   *
+   * the truncation causes the wrong value by shift right
+   * shift left does not matter
+   */
+  if (useVersion->HasImplicitCvt() && shiftOp != BitShiftOperand::kUndef) {
+    return false;
+  }
+  if ((shiftOp == BitShiftOperand::kLSR || shiftOp == BitShiftOperand::kASR) &&
+      (defSrcOpnd.GetSize() > regOperand.GetSize())) {
+    return false;
+  }
+  regno_t defSrcRegNo = regDefSrc.GetRegisterNumber();
+  /* check regDefSrc */
+  VRegVersion *replaceUseV = optSsaInfo->FindSSAVersion(defSrcRegNo);
+  CHECK_FATAL(replaceUseV != nullptr, "useVRegVersion must not be null based on ssa");
+  if (replaceUseV->GetAllUseInsns().size() > 1 && shiftOp != BitShiftOperand::kROR) {
+    return false;
+  }
+  return true;
+}
+
+void ExtendShiftPattern::Init() {
+  replaceOp = MOP_undef;
+  extendOp = ExtendShiftOperand::kUndef;
+  shiftOp = BitShiftOperand::kUndef;
+  defInsn = nullptr;
+  newInsn = nullptr;
+  replaceIdx = kInsnThirdOpnd;
+  optSuccess = false;
+  exMOpType = kExUndef;
+  lsMOpType = kLsUndef;
+  is64BitSize = false;
+}
+
+void ExtendShiftPattern::Run() {
+  if (!cgFunc.GetMirModule().IsCModule()) {
+    return;
+  }
+  FOR_ALL_BB_REV(bb, &cgFunc) {
+    FOR_BB_INSNS_REV(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      DoExtendShiftOpt(*insn);
+    }
+  }
+}
+
+void ExtendMovPattern::Run() {
+  if (!cgFunc.GetMirModule().IsCModule()) {
+    return;
+  }
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+bool ExtendMovPattern::CheckSrcReg(regno_t srcRegNo, uint32 validNum) {
+  InsnSet srcDefSet;
+  VRegVersion *useVersion = optSsaInfo->FindSSAVersion(srcRegNo);
+  CHECK_FATAL(useVersion != nullptr, "useVRegVersion must not be null based on ssa");
+  DUInsnInfo *defInfo = useVersion->GetDefInsnInfo();
+  if (defInfo == nullptr) {
+    return false;
+  }
+  Insn *insn = defInfo->GetInsn();
+  srcDefSet.insert(insn);
+  /* reserve insn set for non ssa version. */
+  for (auto defInsn : srcDefSet) {
+    CHECK_FATAL((defInsn != nullptr), "defInsn is null!");
+    MOperator mOp = defInsn->GetMachineOpcode();
+    switch (mOp) {
+      case MOP_wiorrri12:
+      case MOP_weorrri12: {
+        /* check immVal if mop is OR */
+        ImmOperand &imm = static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        uint32 bitNum = static_cast<uint32>(imm.GetValue());
+        if ((bitNum >> validNum) != 0) {
+          return false;
+        }
+      }
+      case MOP_wandrri12: {
+        /* check defSrcReg */
+        RegOperand &defSrcRegOpnd = static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd));
+        regno_t defSrcRegNo = defSrcRegOpnd.GetRegisterNumber();
+        if (!CheckSrcReg(defSrcRegNo, validNum)) {
+          return false;
+        }
+        break;
+      }
+      case MOP_wandrrr: {
+        /* check defSrcReg */
+        RegOperand &defSrcRegOpnd1 = static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd));
+        RegOperand &defSrcRegOpnd2 = static_cast<RegOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        regno_t defSrcRegNo1 = defSrcRegOpnd1.GetRegisterNumber();
+        regno_t defSrcRegNo2 = defSrcRegOpnd2.GetRegisterNumber();
+        if (!CheckSrcReg(defSrcRegNo1, validNum) && !CheckSrcReg(defSrcRegNo2, validNum)) {
+          return false;
+        }
+        break;
+      }
+      case MOP_wiorrrr:
+      case MOP_weorrrr: {
+        /* check defSrcReg */
+        RegOperand &defSrcRegOpnd1 = static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd));
+        RegOperand &defSrcRegOpnd2 = static_cast<RegOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+        regno_t defSrcRegNo1 = defSrcRegOpnd1.GetRegisterNumber();
+        regno_t defSrcRegNo2 = defSrcRegOpnd2.GetRegisterNumber();
+        if (!CheckSrcReg(defSrcRegNo1, validNum) || !CheckSrcReg(defSrcRegNo2, validNum)) {
+          return false;
+        }
+        break;
+      }
+      case MOP_wldrb: {
+        if (validNum != k8BitSize) {
+          return false;
+        }
+        break;
+      }
+      case MOP_wldrh: {
+        if (validNum != k16BitSize) {
+          return false;
+        }
+        break;
+      }
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+
+bool ExtendMovPattern::BitNotAffected(const Insn &insn, uint32 validNum) {
+  RegOperand &firstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  if (firstOpnd.IsPhysicalRegister()) {
+    return false;
+  }
+  RegOperand &secondOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  regno_t desRegNo = firstOpnd.GetRegisterNumber();
+  regno_t srcRegNo = secondOpnd.GetRegisterNumber();
+  VRegVersion *useVersion = optSsaInfo->FindSSAVersion(desRegNo);
+  CHECK_FATAL(useVersion != nullptr, "useVRegVersion must not be null based on ssa");
+  DUInsnInfo *defInfo = useVersion->GetDefInsnInfo();
+  if (defInfo == nullptr) {
+    return false;
+  }
+  if (!CheckSrcReg(srcRegNo, validNum)) {
+    return false;
+  }
+  replaceMop = MOP_wmovrr;
+  return true;
+}
+
+bool ExtendMovPattern::CheckCondition(Insn &insn) {
+  MOperator mOp = insn.GetMachineOpcode();
+  switch (mOp) {
+    case MOP_xuxtb32: return BitNotAffected(insn, k8BitSize);
+    case MOP_xuxth32: return BitNotAffected(insn, k16BitSize);
+    default: return false;
+  }
+}
+
+/* No initialization required */
+void ExtendMovPattern::Init() {
+  replaceMop = MOP_undef;
+}
+
+void ExtendMovPattern::Optimize(Insn &insn) {
+  insn.SetMOP(AArch64CG::kMd[replaceMop]);
+}
+
+void CopyRegProp::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      Init();
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+bool CopyRegProp::IsValidCopyProp(const RegOperand &dstReg, const RegOperand &srcReg) const {
+  ASSERT(destVersion != nullptr, "find destVersion failed");
+  ASSERT(srcVersion != nullptr, "find srcVersion failed");
+  LiveInterval *dstll = nullptr;
+  LiveInterval *srcll = nullptr;
+  if (destVersion->GetOriginalRegNO() == srcVersion->GetOriginalRegNO()) {
+    return true;
+  }
+  regno_t dstRegNO = dstReg.GetRegisterNumber();
+  regno_t srcRegNO = srcReg.GetRegisterNumber();
+  for (auto useDUInfoIt : destVersion->GetAllUseInsns()) {
+    if (useDUInfoIt.second == nullptr) {
+      continue;
+    }
+    Insn *useInsn = (useDUInfoIt.second)->GetInsn();
+    if (useInsn == nullptr) {
+      continue;
+    }
+    if (useInsn->IsPhi() && dstReg.GetSize() != srcReg.GetSize()) {
+      return false;
+    }
+
+    dstll = regll->GetLiveInterval(dstRegNO);
+    srcll = regll->GetLiveInterval(srcRegNO);
+    ASSERT(dstll != nullptr, "dstll should not be nullptr");
+    ASSERT(srcll != nullptr, "srcll should not be nullptr");
+    static_cast<AArch64LiveIntervalAnalysis*>(regll)->CheckInterference(*dstll, *srcll);
+    BB *useBB = useInsn->GetBB();
+    if (dstll->IsConflictWith(srcRegNO) &&
+        /* support override value when the version is not transphi */
+        (((useBB->IsInPhiDef(srcRegNO) || useBB->IsInPhiList(srcRegNO)) && useBB->HasCriticalEdge()) ||
+        useBB->IsInPhiList(dstRegNO))) {
+      return false;
+    }
+  }
+  if (dstll && srcll) {
+    regll->CoalesceLiveIntervals(*dstll, *srcll);
+  }
+  return true;
+}
+
+bool CopyRegProp::CheckCondition(Insn &insn) {
+  if (Globals::GetInstance()->GetTarget()->IsEffectiveCopy(insn)) {
+    MOperator mOp = insn.GetMachineOpcode();
+    if (mOp == MOP_xmovrr || mOp == MOP_wmovrr || mOp == MOP_xvmovs || mOp == MOP_xvmovd) {
+      Operand &destOpnd = insn.GetOperand(kInsnFirstOpnd);
+      Operand &srcOpnd = insn.GetOperand(kInsnSecondOpnd);
+      ASSERT(destOpnd.IsRegister() && srcOpnd.IsRegister(), "must be");
+      auto &destReg = static_cast<RegOperand &>(destOpnd);
+      auto &srcReg = static_cast<RegOperand &>(srcOpnd);
+      if (srcReg.GetRegisterNumber() == RZR) {
+        insn.SetMOP(AArch64CG::kMd[mOp == MOP_xmovrr ? MOP_xmovri64 : MOP_wmovri32]);
+        insn.SetOperand(kInsnSecondOpnd, cgFunc.CreateImmOperand(PTY_u64, 0));
+      }
+      if (destReg.IsSSAForm() && srcReg.IsSSAForm()) {
+        /* case for ExplicitExtendProp  */
+        auto &propInsns = optSsaInfo->GetSafePropInsns();
+        bool isSafeCvt = std::find(propInsns.begin(), propInsns.end(), insn.GetId()) != propInsns.end();
+        if (destReg.GetSize() != srcReg.GetSize() && !isSafeCvt) {
+          VaildateImplicitCvt(destReg, srcReg, insn);
+          return false;
+        }
+        if (destReg.GetValidBitsNum() >= srcReg.GetValidBitsNum()) {
+          destReg.SetValidBitsNum(srcReg.GetValidBitsNum());
+        } else if (!isSafeCvt) {
+          CHECK_FATAL(false, "do not support explicit extract bit in mov");
+          return false;
+        }
+        destVersion = optSsaInfo->FindSSAVersion(destReg.GetRegisterNumber());
+        ASSERT(destVersion != nullptr, "find Version failed");
+        srcVersion = optSsaInfo->FindSSAVersion(srcReg.GetRegisterNumber());
+        ASSERT(srcVersion != nullptr, "find Version failed");
+        if (!IsValidCopyProp(destReg, srcReg)) {
+          return false;
+        }
+        return true;
+      } else {
+        /* should be eliminated by ssa peep */
+      }
+    }
+  }
+  return false;
+}
+
+bool CopyRegProp::IsNotSpecialOptimizedInsn(const Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_wbfirri5i5 && curMop != MOP_xbfirri6i6) {
+    return true;
+  }
+  auto &useOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  VRegVersion *version = optSsaInfo->FindSSAVersion(useOpnd.GetRegisterNumber());
+  CHECK_FATAL(version != nullptr, "get SSAVersion failed");
+  Insn *defInsn = FindDefInsn(version);
+  if (defInsn == nullptr) {
+    return true;
+  }
+  MOperator defMop = defInsn->GetMachineOpcode();
+  if (defMop == MOP_wmovri32 || defMop == MOP_xmovri64) {
+    return false;
+  }
+
+  bool hasCrossDUUse = false;
+  int32 bothDUId = -1;
+  for (auto duInfoIt : srcVersion->GetAllUseInsns()) {
+    CHECK_FATAL(duInfoIt.second != nullptr, "get DUInsnInfo failed");
+    Insn *useInsn = duInfoIt.second->GetInsn();
+    MOperator useMop = useInsn->GetMachineOpcode();
+    if (useInsn->GetSSAImpDefOpnd() != nullptr) {
+      bothDUId = static_cast<int32>(useInsn->GetId());
+    }
+    if (useInsn->GetSSAImpDefOpnd() == nullptr && useMop != MOP_xmovrr && useMop != MOP_wmovrr &&
+        useMop != MOP_xvmovs && useMop != MOP_xvmovd && bothDUId > -1 &&
+        useInsn->GetId() > static_cast<uint32>(bothDUId)) {
+      hasCrossDUUse = true;
+      break;
+    }
+  }
+  return hasCrossDUUse;
+}
+
+void CopyRegProp::ReplaceAllUseForCopyProp() {
+  MapleUnorderedMap<uint32, DUInsnInfo*> &useList = destVersion->GetAllUseInsns();
+  Insn *srcRegDefInsn = FindDefInsn(srcVersion);
+  for (auto it = useList.begin(); it != useList.end();) {
+    Insn *useInsn = it->second->GetInsn();
+    if (srcRegDefInsn != nullptr && srcRegDefInsn->GetSSAImpDefOpnd() != nullptr &&
+        useInsn->GetSSAImpDefOpnd() != nullptr) {
+      if (IsNotSpecialOptimizedInsn(*useInsn)) {
+        ++it;
+        continue;
+      }
+    }
+    auto *a64SSAInfo = static_cast<AArch64CGSSAInfo*>(optSsaInfo);
+    a64SSAInfo->CheckAsmDUbinding(*useInsn, destVersion, srcVersion);
+    for (auto &opndIt : it->second->GetOperands()) {
+      Operand &opnd = useInsn->GetOperand(opndIt.first);
+      A64ReplaceRegOpndVisitor replaceRegOpndVisitor(cgFunc, *useInsn, opndIt.first,
+                                                     *destVersion->GetSSAvRegOpnd(), *srcVersion->GetSSAvRegOpnd());
+      opnd.Accept(replaceRegOpndVisitor);
+      srcVersion->AddUseInsn(*optSsaInfo, *useInsn, opndIt.first);
+      it->second->ClearDU(opndIt.first);
+    }
+    it = useList.erase(it);
+  }
+}
+
+void CopyRegProp::Optimize(Insn &insn) {
+  ReplaceAllUseForCopyProp();
+  if (cgFunc.IsExtendReg(destVersion->GetSSAvRegOpnd()->GetRegisterNumber())) {
+    cgFunc.InsertExtendSet(srcVersion->GetSSAvRegOpnd()->GetRegisterNumber());
+  }
+}
+
+void CopyRegProp::VaildateImplicitCvt(RegOperand &destReg, const RegOperand &srcReg, Insn &movInsn) {
+  ASSERT(movInsn.GetMachineOpcode() == MOP_xmovrr || movInsn.GetMachineOpcode() == MOP_wmovrr, "NIY explicit CVT");
+  if (destReg.GetSize() == k64BitSize && srcReg.GetSize() == k32BitSize) {
+    movInsn.SetMOP(AArch64CG::kMd[MOP_xuxtw64]);
+  } else if (destReg.GetSize() == k32BitSize && srcReg.GetSize() == k64BitSize) {
+    movInsn.SetMOP(AArch64CG::kMd[MOP_xubfxrri6i6]);
+    movInsn.AddOperand(cgFunc.CreateImmOperand(PTY_i64, 0));
+    movInsn.AddOperand(cgFunc.CreateImmOperand(PTY_i64, k32BitSize));
+  } else {
+    CHECK_FATAL(false, " unknown explicit integer cvt,  need implement in ssa prop ");
+  }
+  destReg.SetValidBitsNum(k32BitSize);
+}
+
+void RedundantPhiProp::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    for (auto &phiIt : as_const(bb->GetPhiInsns())) {
+      Init();
+      if (!CheckCondition(*phiIt.second)) {
+        continue;
+      }
+      Optimize(*phiIt.second);
+    }
+  }
+}
+
+void RedundantPhiProp::Optimize(Insn &insn) {
+  optSsaInfo->ReplaceAllUse(destVersion, srcVersion);
+}
+
+bool RedundantPhiProp::CheckCondition(Insn &insn) {
+  ASSERT(insn.IsPhi(), "must be phi insn here");
+  auto &phiOpnd = static_cast<PhiOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  if (phiOpnd.IsRedundancy()) {
+    auto &phiDestReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+    destVersion = optSsaInfo->FindSSAVersion(phiDestReg.GetRegisterNumber());
+    ASSERT(destVersion != nullptr, "find Version failed");
+    uint32 srcRegNO = phiOpnd.GetOperands().cbegin()->second->GetRegisterNumber();
+    srcVersion = optSsaInfo->FindSSAVersion(srcRegNO);
+    ASSERT(srcVersion != nullptr, "find Version failed");
+    return true;
+  }
+  return false;
+}
+
+bool ValidBitNumberProp::IsImplicitUse(const RegOperand &dstOpnd, const RegOperand &srcOpnd) const {
+  for (auto destUseIt : destVersion->GetAllUseInsns()) {
+    Insn *useInsn = destUseIt.second->GetInsn();
+    if (useInsn->GetMachineOpcode() == MOP_xuxtw64) {
+      return true;
+    }
+    if (useInsn->GetMachineOpcode() == MOP_xubfxrri6i6) {
+      auto &lsbOpnd = static_cast<ImmOperand&>(useInsn->GetOperand(kInsnThirdOpnd));
+      auto &widthOpnd = static_cast<ImmOperand&>(useInsn->GetOperand(kInsnFourthOpnd));
+      if (lsbOpnd.GetValue() == k0BitSize && widthOpnd.GetValue() == k32BitSize) {
+        return false;
+      }
+    }
+    if (useInsn->IsPhi()) {
+      auto &defOpnd = static_cast<RegOperand&>(useInsn->GetOperand(kInsnFirstOpnd));
+      if (defOpnd.GetSize() == k32BitSize) {
+        return false;
+      }
+    }
+    /* if srcOpnd upper 32 bits are valid, it can not prop to mop_x */
+    if (srcOpnd.GetSize() == k64BitSize && dstOpnd.GetSize() == k64BitSize) {
+      const InsnDesc *useMD = &AArch64CG::kMd[useInsn->GetMachineOpcode()];
+      for (auto &opndUseIt : as_const(destUseIt.second->GetOperands())) {
+        const OpndDesc *useProp = useMD->GetOpndDes(opndUseIt.first);
+        if (useProp->GetSize() == k64BitSize) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+bool ValidBitNumberProp::CheckCondition(Insn &insn) {
+  /* extend to all shift pattern in future */
+  RegOperand *destOpnd = nullptr;
+  RegOperand *srcOpnd = nullptr;
+  if (insn.GetMachineOpcode() == MOP_xuxtw64) {
+    destOpnd = &static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+    srcOpnd = &static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  }
+  if (insn.GetMachineOpcode() == MOP_xubfxrri6i6) {
+    destOpnd = &static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+    srcOpnd = &static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+    auto &lsb = static_cast<ImmOperand &>(insn.GetOperand(kInsnThirdOpnd));
+    auto &width = static_cast<ImmOperand &>(insn.GetOperand(kInsnFourthOpnd));
+    if ((lsb.GetValue() != 0) || (width.GetValue() != k32BitSize)) {
+      return false;
+    }
+  }
+  if (destOpnd != nullptr && destOpnd->IsSSAForm() && srcOpnd != nullptr && srcOpnd->IsSSAForm()) {
+    destVersion = optSsaInfo->FindSSAVersion(destOpnd->GetRegisterNumber());
+    ASSERT(destVersion != nullptr, "find Version failed");
+    srcVersion = optSsaInfo->FindSSAVersion(srcOpnd->GetRegisterNumber());
+    ASSERT(srcVersion != nullptr, "find Version failed");
+    if (destVersion->HasImplicitCvt()) {
+      return false;
+    }
+    if (IsImplicitUse(*destOpnd, *srcOpnd)) {
+      return false;
+    }
+    srcVersion->SetImplicitCvt();
+    return true;
+  }
+  return false;
+}
+
+void ValidBitNumberProp::Optimize(Insn &insn) {
+  optSsaInfo->ReplaceAllUse(destVersion, srcVersion);
+  cgFunc.InsertExtendSet(srcVersion->GetSSAvRegOpnd()->GetRegisterNumber());
+}
+
+void ValidBitNumberProp::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      Init();
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+void FpSpConstProp::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      Init();
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+bool FpSpConstProp::CheckCondition(Insn &insn) {
+  std::set<uint32> defRegs = insn.GetDefRegs();
+  auto &a64CGFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  if (defRegs.size() <= 1) {
+    if (insn.ScanReg(RSP)) {
+      fpSpBase = &a64CGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
+      /* not safe due to varied sp in alloca */
+      if (cgFunc.HasVLAOrAlloca()) {
+        return false;
+      }
+    }
+    if (insn.ScanReg(RFP)) {
+      ASSERT(fpSpBase == nullptr, " unexpect for both sp fp using ");
+      fpSpBase = &a64CGFunc.GetOrCreatePhysicalRegisterOperand(RFP, k64BitSize, kRegTyInt);
+    }
+    if (fpSpBase == nullptr) {
+      return false;
+    }
+    if (insn.GetMachineOpcode() == MOP_xaddrri12) {
+      aT = kAArch64Add;
+      if (GetValidSSAInfo(insn.GetOperand(kInsnFirstOpnd))) {
+        shiftOpnd = &static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+        return true;
+      }
+    } else if (insn.GetMachineOpcode() == MOP_xsubrri12) {
+      aT = kAArch64Sub;
+      if (GetValidSSAInfo(insn.GetOperand(kInsnFirstOpnd))) {
+        shiftOpnd = &static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool FpSpConstProp::GetValidSSAInfo(Operand &opnd) {
+  if (opnd.IsRegister()) {
+    auto &regOpnd = static_cast<RegOperand&>(opnd);
+    if (regOpnd.IsSSAForm()) {
+      replaced = optSsaInfo->FindSSAVersion(regOpnd.GetRegisterNumber());
+      ASSERT(replaced != nullptr, "find ssa version failed in FpSpConstProp");
+      return true;
+    }
+  }
+  return false;
+}
+
+int64 FpSpConstProp::ArithmeticFold(int64 valInUse, ArithmeticType useAT) const {
+  int64 valInDef = shiftOpnd->GetValue();
+  int64 returnVal = 0;
+  CHECK_FATAL(aT == kAArch64Add || aT == kAArch64Sub, "unsupport sp/fp arthimetic  in aarch64");
+  if (useAT == aT) {
+    returnVal = valInUse + valInDef;
+  } else {
+    returnVal = valInUse - valInDef;
+  }
+  return returnVal;
+}
+
+void FpSpConstProp::PropInMem(DUInsnInfo &useDUInfo, Insn &useInsn) {
+  MOperator useMop = useInsn.GetMachineOpcode();
+  if (useInsn.IsAtomic()) {
+    return;
+  }
+  if (useInsn.IsStore() || useInsn.IsLoad()) {
+    if (useDUInfo.GetOperands().size() == 1) {
+      auto useOpndIt = useDUInfo.GetOperands().begin();
+      if (useOpndIt->first == kInsnSecondOpnd || useOpndIt->first == kInsnThirdOpnd) {
+        ASSERT(useOpndIt->second == 1, "multiple use in memory opnd");
+        auto *a64memOpnd = static_cast<MemOperand*>(useInsn.GetMemOpnd());
+        if (a64memOpnd->IsIntactIndexed() && a64memOpnd->GetAddrMode() == MemOperand::kAddrModeBOi) {
+          auto *ofstOpnd = static_cast<OfstOperand*>(a64memOpnd->GetOffsetImmediate());
+          CHECK_FATAL(ofstOpnd != nullptr, "oldOffsetOpnd is null");
+          int64 newVal = ArithmeticFold(ofstOpnd->GetValue(), kAArch64Add);
+          auto *newOfstImm = &static_cast<AArch64CGFunc&>(cgFunc).CreateOfstOpnd(static_cast<uint64>(newVal),
+              k64BitSize);
+          if (ofstOpnd->GetVary() == kUnAdjustVary || shiftOpnd->GetVary() == kUnAdjustVary) {
+            newOfstImm->SetVary(kUnAdjustVary);
+          }
+          auto *newMem = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+              MemOperand::kAddrModeBOi, a64memOpnd->GetSize(), *fpSpBase,
+              nullptr, newOfstImm, nullptr);
+          if (static_cast<AArch64CGFunc&>(cgFunc).IsOperandImmValid(useMop, newMem, useOpndIt->first)) {
+            useInsn.SetMemOpnd(newMem);
+            useDUInfo.DecreaseDU(useOpndIt->first);
+            replaced->CheckDeadUse(useInsn);
+          }
+        }
+      }
+    } else {
+      /*
+       * case : store stack location on stack
+       * add x1, sp, #8
+       *  ...
+       * store x1 [x1, #16]
+       * not prop , not benefit to live range yet
+       */
+      return;
+    }
+  }
+}
+
+void FpSpConstProp::PropInArith(DUInsnInfo &useDUInfo, Insn &useInsn, ArithmeticType curAT) {
+  if (useDUInfo.GetOperands().size() == 1) {
+    auto &a64cgFunc = static_cast<AArch64CGFunc&>(cgFunc);
+    MOperator useMop = useInsn.GetMachineOpcode();
+    ASSERT(useDUInfo.GetOperands().begin()->first == kInsnSecondOpnd, "NIY");
+    ASSERT(useDUInfo.GetOperands().begin()->second == 1, "multiple use in add/sub");
+    auto &curVal = static_cast<ImmOperand&>(useInsn.GetOperand(kInsnThirdOpnd));
+    ImmOperand &newVal = a64cgFunc.CreateImmOperand(ArithmeticFold(curVal.GetValue(), curAT),
+                                                    curVal.GetSize(), false);
+    if (newVal.GetValue() < 0) {
+      newVal.Negate();
+      useMop = A64ConstProp::GetReversalMOP(useMop);
+    }
+    if (curVal.GetVary() == kUnAdjustVary || shiftOpnd->GetVary() == kUnAdjustVary) {
+      newVal.SetVary(kUnAdjustVary);
+    }
+    if (static_cast<AArch64CGFunc&>(cgFunc).IsOperandImmValid(useMop, &newVal, kInsnThirdOpnd)) {
+      Insn &newInsn =
+          cgFunc.GetInsnBuilder()->BuildInsn(useMop, useInsn.GetOperand(kInsnFirstOpnd), *fpSpBase, newVal);
+      useInsn.GetBB()->ReplaceInsn(useInsn, newInsn);
+      optSsaInfo->ReplaceInsn(useInsn, newInsn);
+    }
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+}
+
+void FpSpConstProp::PropInCopy(DUInsnInfo &useDUInfo, Insn &useInsn, MOperator oriMop) {
+  if (useDUInfo.GetOperands().size() == 1) {
+    ASSERT(useDUInfo.GetOperands().begin()->first == kInsnSecondOpnd, "NIY");
+    ASSERT(useDUInfo.GetOperands().begin()->second == 1, "multiple use in add/sub");
+    auto &newVal = *static_cast<ImmOperand*>(shiftOpnd->Clone(*cgFunc.GetMemoryPool()));
+    Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(oriMop, useInsn.GetOperand(kInsnFirstOpnd), *fpSpBase, newVal);
+    useInsn.GetBB()->ReplaceInsn(useInsn, newInsn);
+    optSsaInfo->ReplaceInsn(useInsn, newInsn);
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+}
+
+void FpSpConstProp::Optimize(Insn &insn) {
+  for (auto &useInsnInfo : replaced->GetAllUseInsns()) {
+    Insn *useInsn = useInsnInfo.second->GetInsn();
+    MOperator useMop = useInsn->GetMachineOpcode();
+    PropInMem(*useInsnInfo.second, *useInsn);
+    switch (useMop) {
+      case MOP_xmovrr:
+      case MOP_wmovrr:
+        PropInCopy(*useInsnInfo.second, *useInsn, insn.GetMachineOpcode());
+        break;
+      case MOP_xaddrri12:
+        PropInArith(*useInsnInfo.second, *useInsn, kAArch64Add);
+        break;
+      case MOP_xsubrri12:
+        PropInArith(*useInsnInfo.second, *useInsn, kAArch64Sub);
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+A64ConstFoldPattern::TypeAndSize A64ConstFoldPattern::SelectFoldTypeAndCheck64BitSize(const Insn &insn) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  switch (mOp) {
+    case MOP_waddrri12: return std::pair<FoldType, bool>{kAdd, false};
+    case MOP_xaddrri12: return std::pair<FoldType, bool>{kAdd, true};
+    case MOP_wsubrri12: return std::pair<FoldType, bool>{kSub, false};
+    case MOP_xsubrri12: return std::pair<FoldType, bool>{kSub, true};
+    case MOP_wlslrri5: return std::pair<FoldType, bool>{kLsl, false};
+    case MOP_xlslrri6: return std::pair<FoldType, bool>{kLsl, true};
+    case MOP_wlsrrri5: return std::pair<FoldType, bool>{kLsr, false};
+    case MOP_xlsrrri6: return std::pair<FoldType, bool>{kLsr, true};
+    case MOP_wasrrri5: return std::pair<FoldType, bool>{kAsr, false};
+    case MOP_xasrrri6: return std::pair<FoldType, bool>{kAsr, true};
+    case MOP_wandrri12: return std::pair<FoldType, bool>{kAnd, false};
+    case MOP_xandrri13: return std::pair<FoldType, bool>{kAnd, true};
+    case MOP_wiorrri12: return std::pair<FoldType, bool>{kOrr, false};
+    case MOP_xiorrri13: return std::pair<FoldType, bool>{kOrr, true};
+    case MOP_weorrri12: return std::pair<FoldType, bool>{kEor, false};
+    case MOP_xeorrri13: return std::pair<FoldType, bool>{kEor, true};
+    default:
+      return std::pair<FoldType, bool>{kFoldUndef, false};
+  }
+}
+
+bool A64ConstFoldPattern::IsDefInsnValid(const Insn &curInsn, const Insn &validDefInsn) {
+  std::pair<FoldType, bool> defInfo = SelectFoldTypeAndCheck64BitSize(validDefInsn);
+  defFoldType = defInfo.first;
+  if (defFoldType == kFoldUndef) {
+    return false;
+  }
+  /* do not optimize MOP_x and MOP_w */
+  if (is64Bit != defInfo.second) {
+    return false;
+  }
+  ASSERT(curInsn.GetOperand(kInsnFirstOpnd).IsRegister() &&
+         validDefInsn.GetOperand(kInsnSecondOpnd).IsRegister(), "must be");
+  dstOpnd = &static_cast<RegOperand&>(curInsn.GetOperand(kInsnFirstOpnd));
+  srcOpnd = &static_cast<RegOperand&>(validDefInsn.GetOperand(kInsnSecondOpnd));
+  if (dstOpnd->IsPhysicalRegister() || srcOpnd->IsPhysicalRegister()) {
+    return false;
+  }
+  optType = constFoldTable[useFoldType][defFoldType];
+  if (optType == kOptUndef) {
+    return false;
+  }
+  ASSERT(defInsn->GetOperand(kInsnFirstOpnd).IsRegister(), "must be");
+  defDstOpnd = &static_cast<RegOperand&>(defInsn->GetOperand(kInsnFirstOpnd));
+  return true;
+}
+
+bool A64ConstFoldPattern::IsPhiInsnValid(const Insn &curInsn, const Insn &phiInsn) {
+  std::vector<Insn*> validDefInsns;
+  auto &phiOpnd = static_cast<PhiOperand&>(phiInsn.GetOperand(kInsnSecondOpnd));
+  for (auto useIt : phiOpnd.GetOperands()) {
+    ASSERT(useIt.second != nullptr, "get phiUseOpnd failed");
+    Insn *defPhiInsn = optSsaInfo->GetDefInsn(*useIt.second);
+    /* check only one layer of phi */
+    if (defPhiInsn == nullptr || defPhiInsn->IsPhi()) {
+      return false;
+    }
+    (void)validDefInsns.emplace_back(defPhiInsn);
+  }
+  if (validDefInsns.empty()) {
+    return false;
+  }
+  if (!IsDefInsnValid(curInsn, *validDefInsns[0])) {
+    return false;
+  }
+  MOperator mOp = validDefInsns[0]->GetMachineOpcode();
+  CHECK_FATAL(validDefInsns[0]->GetOperand(kInsnSecondOpnd).IsRegister(), "check this insn");
+  CHECK_FATAL(validDefInsns[0]->GetOperand(kInsnThirdOpnd).IsImmediate(), "check this insn");
+  auto &validSrcOpnd = static_cast<RegOperand&>(validDefInsns[0]->GetOperand(kInsnSecondOpnd));
+  auto &validImmOpnd = static_cast<ImmOperand&>(validDefInsns[0]->GetOperand(kInsnThirdOpnd));
+  uint32 opndNum = validDefInsns[0]->GetOperandSize();
+  for (uint32 insnIdx = 1; insnIdx < validDefInsns.size(); ++insnIdx) {
+    Insn *insn = validDefInsns[insnIdx];
+    if (insn->GetMachineOpcode() != mOp) {
+      return false;
+    }
+    if (insn->GetOperandSize() != opndNum) {
+      return false;
+    }
+    if (!insn->GetOperand(kInsnSecondOpnd).IsRegister() || !insn->GetOperand(kInsnThirdOpnd).IsImmediate()) {
+      return false;
+    }
+    if (!static_cast<RegOperand&>(insn->GetOperand(kInsnSecondOpnd)).Equals(validSrcOpnd) ||
+        !static_cast<ImmOperand&>(insn->GetOperand(kInsnThirdOpnd)).Equals(validImmOpnd)) {
+      return false;
+    }
+  }
+  defInsn = validDefInsns[0];
+  return true;
+}
+
+bool A64ConstFoldPattern::IsCompleteOptimization() {
+  VRegVersion *defDstVersion = optSsaInfo->FindSSAVersion(defDstOpnd->GetRegisterNumber());
+  ASSERT(defDstVersion != nullptr, "get defDstVersion failed");
+  /* check all uses of dstOpnd of defInsn to avoid spill */
+  for (auto useInfoIt : defDstVersion->GetAllUseInsns()) {
+    ASSERT(useInfoIt.second != nullptr, "get duInsnInfo failed");
+    Insn *useInsn = useInfoIt.second->GetInsn();
+    ASSERT(useInsn != nullptr, "get useInsn failed");
+    if (useInsn->IsPhi()) {
+      continue;
+    }
+    std::pair<FoldType, bool> useInfo = SelectFoldTypeAndCheck64BitSize(*useInsn);
+    if (useInfo.first == kFoldUndef) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool A64ConstFoldPattern::CheckCondition(Insn &insn) {
+  std::pair<FoldType, bool> useInfo = SelectFoldTypeAndCheck64BitSize(insn);
+  useFoldType = useInfo.first;
+  if (useFoldType == kFoldUndef) {
+    return false;
+  }
+  is64Bit = useInfo.second;
+  ASSERT(insn.GetOperand(kInsnSecondOpnd).IsRegister(), "check this insn");
+  auto &useOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  defInsn = optSsaInfo->GetDefInsn(useOpnd);
+  if (defInsn == nullptr) {
+    return false;
+  }
+  if (defInsn->IsPhi()) {
+    return IsPhiInsnValid(insn, *defInsn);
+  } else {
+    return IsDefInsnValid(insn, *defInsn);
+  }
+}
+
+MOperator A64ConstFoldPattern::GetNewMop(bool isNegativeVal, MOperator curMop) const {
+  MOperator newMop = MOP_undef;
+  switch (useFoldType) {
+    case kAdd:
+      newMop = (isNegativeVal ? (is64Bit ? MOP_xsubrri12 : MOP_wsubrri12) : curMop);
+      break;
+    case kSub:
+      newMop = (isNegativeVal ? curMop : (is64Bit ? MOP_xaddrri12 : MOP_waddrri12));
+      break;
+    case kLsl:
+      newMop = (isNegativeVal ? (is64Bit ? MOP_xlsrrri6 : MOP_wlsrrri5) : curMop);
+      break;
+    case kLsr:
+      newMop = (isNegativeVal ? (is64Bit ? MOP_xlslrri6 : MOP_wlslrri5) : curMop);
+      break;
+    case kAsr:
+      newMop = (isNegativeVal ? MOP_undef : curMop);
+      break;
+    case kAnd:
+    case kOrr:
+    case kEor:
+      return curMop;
+    default:
+      return MOP_undef;
+  }
+  return newMop;
+}
+
+ImmOperand &A64ConstFoldPattern::GetNewImmOpnd(const ImmOperand &immOpnd, int64 newImmVal) const {
+  auto &a64Func = static_cast<AArch64CGFunc&>(cgFunc);
+  switch (useFoldType) {
+    case kAdd:
+    case kSub:
+    case kLsl:
+    case kLsr:
+    case kAsr:
+      return (newImmVal < 0 ?
+              a64Func.CreateImmOperand(-newImmVal, immOpnd.GetSize(), immOpnd.IsSignedValue()) :
+              a64Func.CreateImmOperand(newImmVal, immOpnd.GetSize(), immOpnd.IsSignedValue()));
+    case kAnd:
+    case kOrr:
+    case kEor:
+      return a64Func.CreateImmOperand(newImmVal, immOpnd.GetSize(), immOpnd.IsSignedValue());
+    default:
+      CHECK_FATAL(false, "can not run here");
+  }
+}
+
+void A64ConstFoldPattern::ReplaceWithNewInsn(Insn &insn, const ImmOperand &immOpnd, int64 newImmVal) {
+  auto &a64Func = static_cast<AArch64CGFunc&>(cgFunc);
+  MOperator curMop = insn.GetMachineOpcode();
+  MOperator newMop = GetNewMop(newImmVal < 0, curMop);
+  ImmOperand &newImmOpnd = GetNewImmOpnd(immOpnd, newImmVal);
+  if (!a64Func.IsOperandImmValid(newMop, &newImmOpnd, kInsnThirdOpnd)) {
+    return;
+  }
+  if (useFoldType == kLsl || useFoldType == kLsr || useFoldType == kAsr) {
+    if (newImmVal < 0 || (is64Bit && newImmVal >= k64BitSize) || (!is64Bit && newImmVal >= k32BitSize)) {
+      return;
+    }
+  }
+  Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(newMop, *dstOpnd, *srcOpnd, newImmOpnd);
+  insn.GetBB()->ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  optSsaInfo->ReplaceInsn(insn, newInsn);
+  if (PROP_DUMP) {
+    LogInfo::MapleLogger() << ">>>>>>> In A64ConstFoldPattern : <<<<<<<\n";
+    LogInfo::MapleLogger() << "=======ReplaceInsn :\n";
+    insn.Dump();
+    LogInfo::MapleLogger() << "=======NewInsn :\n";
+    newInsn.Dump();
+  }
+}
+
+int64 A64ConstFoldPattern::GetNewImmVal(const Insn &insn, const ImmOperand &defImmOpnd) const {
+  ASSERT(insn.GetOperand(kInsnThirdOpnd).IsImmediate(), "check this insn");
+  auto &useImmOpnd = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  int64 newImmVal = 0;
+  switch (optType) {
+    case kPositive:
+      newImmVal = useImmOpnd.GetValue() + defImmOpnd.GetValue();
+      break;
+    case kNegativeDef:
+      newImmVal = useImmOpnd.GetValue() - defImmOpnd.GetValue();
+      break;
+    case kNegativeUse:
+      newImmVal = defImmOpnd.GetValue() - useImmOpnd.GetValue();
+      break;
+    case kNegativeBoth:
+      newImmVal = -defImmOpnd.GetValue() - useImmOpnd.GetValue();
+      break;
+    case kLogicalAnd:
+      newImmVal = defImmOpnd.GetValue() & useImmOpnd.GetValue();
+      break;
+    case kLogicalOrr:
+      newImmVal = defImmOpnd.GetValue() | useImmOpnd.GetValue();
+      break;
+    case kLogicalEor:
+      newImmVal = defImmOpnd.GetValue() ^ useImmOpnd.GetValue();
+      break;
+    default:
+      CHECK_FATAL(false, "can not be here");
+  }
+  return newImmVal;
+}
+
+void A64ConstFoldPattern::Optimize(Insn &insn) {
+  ASSERT(defInsn->GetOperand(kInsnThirdOpnd).IsImmediate(), "check this insn");
+  auto &defImmOpnd = static_cast<ImmOperand&>(defInsn->GetOperand(kInsnThirdOpnd));
+  int64 newImmVal = GetNewImmVal(insn, defImmOpnd);
+  if (newImmVal == 0 && optType != kLogicalAnd && optType != kLogicalOrr && optType != kLogicalEor) {
+    VRegVersion *dstVersion = optSsaInfo->FindSSAVersion(dstOpnd->GetRegisterNumber());
+    VRegVersion *srcVersion = optSsaInfo->FindSSAVersion(srcOpnd->GetRegisterNumber());
+    CHECK_FATAL(dstVersion != nullptr, "get dstVersion failed");
+    CHECK_FATAL(srcVersion != nullptr, "get srcVersion failed");
+    if (cgFunc.IsExtendReg(dstOpnd->GetRegisterNumber())) {
+      cgFunc.InsertExtendSet(srcOpnd->GetRegisterNumber());
+    }
+    optSsaInfo->ReplaceAllUse(dstVersion, srcVersion);
+  } else if (IsCompleteOptimization()) {
+    ReplaceWithNewInsn(insn, defImmOpnd, newImmVal);
+  }
+}
+
+void A64ConstFoldPattern::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      Init();
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+}
+
+bool A64PregCopyPattern::DFSFindValidDefInsns(Insn *curDefInsn, std::vector<regno_t> &visitedPhiDefs,
+                                              std::unordered_map<uint32, bool> &visited) {
+  if (curDefInsn == nullptr) {
+    return false;
+  }
+  /*
+   * avoid the case as following:
+   * R113 and R117 define each other.
+   *                               [BB5]     ----------------------------
+   *                    phi: R113, (R111<4>, R117<9>)                   |
+   *                              /     \                               |
+   *                             /       \                              |
+   *                        [BB6]  ----  [BB7]                          |
+   *            add R116, R113, #4     phi: R117, (R113<5>, R116<6>)    |
+   *                                     /   \                          |
+   *                                    /     \                         |
+   *                                 [BB8]    [BB28]                    |
+   *                                   /                                |
+   *                                  /                                 |
+   *                                 [BB9] ------ [BB5]                 |
+   *                             mov R1, R117  --------------------------
+   *
+   * but the cases as following is right:
+   * (1)
+   *                              [BB124]
+   *                       add R339, R336, #345      --------  is found twice
+   *                              /    \
+   *                             /      \
+   *                            /     [BB125]
+   *                            \        /
+   *                             \      /
+   *                              [BB56]
+   *                       phi: R370, (R339<124>, R339<125>)
+   *                                |
+   *                                |
+   *                             [BB61]
+   *                           mov R0, R370
+   * (2)
+   *                                [BB17]
+   *                       phi: R242, (R241<14>, R218<53>)    ------- is found twice
+   *                              /          \
+   *                             /            \
+   *                            /           [BB26]     [BB32]
+   *                            \               \      /
+   *                             \               [BB27]
+   *                              \      phi: R273, (R242<26>, R320<32>)
+   *                           [BB25]           /
+   *                                \        [BB42]
+   *                                 \       /
+   *                                  [BB43]
+   *                        phi: R321, (R242<25>, R273<42>)
+   *                                    |
+   *                                  [BB47]
+   *                               mov R0, R321
+   */
+  if (visited[curDefInsn->GetId()] && curDefInsn->IsPhi() && !visitedPhiDefs.empty()) {
+    auto &curPhiOpnd = static_cast<const PhiOperand&>(curDefInsn->GetOperand(kInsnSecondOpnd));
+    for (auto &curPhiListIt : curPhiOpnd.GetOperands()) {
+      auto &curUseOpnd = static_cast<RegOperand&>(*curPhiListIt.second);
+      if (std::find(visitedPhiDefs.begin(), visitedPhiDefs.end(), curUseOpnd.GetRegisterNumber()) !=
+          visitedPhiDefs.end()) {
+        return false;
+      }
+    }
+  }
+  if (visited[curDefInsn->GetId()]) {
+    return true;
+  }
+  visited[curDefInsn->GetId()] = true;
+  if (!curDefInsn->IsPhi()) {
+    CHECK_FATAL(curDefInsn->IsMachineInstruction(), "expect valid insn");
+    (void)validDefInsns.emplace_back(curDefInsn);
+    return true;
+  }
+  auto &phiOpnd = static_cast<const PhiOperand&>(curDefInsn->GetOperand(kInsnSecondOpnd));
+  for (auto &phiListIt : phiOpnd.GetOperands()) {
+    auto &useOpnd = static_cast<RegOperand&>(*phiListIt.second);
+    VRegVersion *useVersion = optSsaInfo->FindSSAVersion(useOpnd.GetRegisterNumber());
+    Insn *defInsn = FindDefInsn(useVersion);
+    if (defInsn == nullptr) {
+      return false;
+    }
+    if (defInsn->IsPhi()) {
+      auto &curPhiDef = static_cast<RegOperand&>(curDefInsn->GetOperand(kInsnFirstOpnd));
+      (void)visitedPhiDefs.emplace_back(curPhiDef.GetRegisterNumber());
+    }
+    if (!DFSFindValidDefInsns(defInsn, visitedPhiDefs, visited)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool A64PregCopyPattern::CheckMultiUsePoints(const Insn *defInsn) const {
+  Operand &dstOpnd = defInsn->GetOperand(kInsnFirstOpnd);
+  CHECK_FATAL(dstOpnd.IsRegister(), "dstOpnd must be register");
+  VRegVersion *defVersion = optSsaInfo->FindSSAVersion(static_cast<RegOperand&>(dstOpnd).GetRegisterNumber());
+  ASSERT(defVersion != nullptr, "defVersion should not be nullptr");
+  /* use: (phi) or (mov preg) */
+  for (auto &useInfoIt : defVersion->GetAllUseInsns()) {
+    DUInsnInfo *useInfo = useInfoIt.second;
+    CHECK_FATAL(useInfo, "get useDUInfo failed");
+    Insn *useInsn = useInfo->GetInsn();
+    CHECK_FATAL(useInsn, "get useInsn failed");
+    if (!useInsn->IsPhi() && useInsn->GetMachineOpcode() != MOP_wmovrr && useInsn->GetMachineOpcode() != MOP_xmovrr) {
+      return false;
+    }
+    if ((useInsn->GetMachineOpcode() == MOP_wmovrr || useInsn->GetMachineOpcode() == MOP_xmovrr) &&
+         !static_cast<RegOperand&>(useInsn->GetOperand(kInsnFirstOpnd)).IsPhysicalRegister()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool A64PregCopyPattern::CheckPhiCaseCondition(Insn &defInsn) {
+  std::unordered_map<uint32, bool> visited;
+  std::vector<regno_t> visitedPhiDefs;
+  if (defInsn.IsPhi()) {
+    (void)visitedPhiDefs.emplace_back(
+        static_cast<RegOperand&>(defInsn.GetOperand(kInsnFirstOpnd)).GetRegisterNumber());
+  }
+  if (!DFSFindValidDefInsns(&defInsn, visitedPhiDefs, visited)) {
+    return false;
+  }
+  if (!CheckValidDefInsn(validDefInsns[0])) {
+    return false;
+  }
+  MOperator defMop = validDefInsns[0]->GetMachineOpcode();
+  uint32 defOpndNum = validDefInsns[0]->GetOperandSize();
+  for (size_t i = 1; i < validDefInsns.size(); ++i) {
+    if (defMop != validDefInsns[i]->GetMachineOpcode()) {
+      return false;
+    }
+    if (!CheckMultiUsePoints(validDefInsns[i])) {
+      return false;
+    }
+    for (uint32 idx = 0; idx < defOpndNum; ++idx) {
+      if (validDefInsns[0]->OpndIsDef(idx) && validDefInsns[i]->OpndIsDef(idx)) {
+        continue;
+      }
+      Operand &opnd1 = validDefInsns[0]->GetOperand(idx);
+      Operand &opnd2 = validDefInsns[i]->GetOperand(idx);
+      if (!opnd1.Equals(opnd2) && differIdx == -1) {
+        differIdx = static_cast<int>(idx);
+        if (!validDefInsns[0]->GetOperand(static_cast<uint32>(differIdx)).IsRegister() ||
+            !validDefInsns[i]->GetOperand(static_cast<uint32>(differIdx)).IsRegister()) {
+          return false;
+        }
+        auto &differOpnd1 = static_cast<RegOperand&>(validDefInsns[0]->GetOperand(static_cast<uint32>(differIdx)));
+        auto &differOpnd2 = static_cast<RegOperand&>(validDefInsns[1]->GetOperand(static_cast<uint32>(differIdx)));
+        /* avoid cc reg */
+        if (!differOpnd1.IsOfIntClass() || !differOpnd2.IsOfIntClass() ||
+            differOpnd1.IsPhysicalRegister() || differOpnd2.IsPhysicalRegister()) {
+          return false;
+        }
+        VRegVersion *differVersion1 = optSsaInfo->FindSSAVersion(differOpnd1.GetRegisterNumber());
+        VRegVersion *differVersion2 = optSsaInfo->FindSSAVersion(differOpnd2.GetRegisterNumber());
+        if (!differVersion1 || !differVersion2) {
+          return false;
+        }
+        if (differVersion1->GetOriginalRegNO() != differVersion2->GetOriginalRegNO()) {
+          return false;
+        }
+        differOrigNO = differVersion1->GetOriginalRegNO();
+      } else if (!opnd1.Equals(opnd2) && static_cast<int32>(idx) != differIdx) {
+        return false;
+      }
+    }
+    if (differIdx <= 0) {
+      return false;
+    }
+  }
+  if (differIdx == -1) {
+    return false;
+  }
+  return true;
+}
+
+bool A64PregCopyPattern::CheckUselessDefInsn(const Insn *defInsn) const {
+  Operand &dstOpnd = defInsn->GetOperand(kInsnFirstOpnd);
+  CHECK_FATAL(dstOpnd.IsRegister(), "dstOpnd must be register");
+  VRegVersion *defVersion = optSsaInfo->FindSSAVersion(static_cast<RegOperand&>(dstOpnd).GetRegisterNumber());
+  ASSERT(defVersion != nullptr, "defVersion should not be nullptr");
+  if (defVersion->GetAllUseInsns().size() == 1) {
+    return true;
+  }
+  /*
+   * avoid the case as following
+   * In a loop:
+   *                      [BB43]
+   *            phi: R356, (R345<42>, R377<63>)
+   *                     /           \
+   *                    /             \
+   *                 [BB44]            \
+   *             add R377, R356, #1    /
+   *             mov R1, R377         /
+   *                  bl             /
+   *                     \          /
+   *                      \        /
+   *                        [BB63]
+   */
+  for (auto &useInfoIt : defVersion->GetAllUseInsns()) {
+    DUInsnInfo *useInfo = useInfoIt.second;
+    CHECK_FATAL(useInfo, "get useDUInfo failed");
+    Insn *useInsn = useInfo->GetInsn();
+    CHECK_FATAL(useInsn, "get useInsn failed");
+    if (useInsn->IsPhi()) {
+      auto &phiDefOpnd = static_cast<RegOperand&>(useInsn->GetOperand(kInsnFirstOpnd));
+      uint32 opndNum = defInsn->GetOperandSize();
+      for (uint32 i = 0; i < opndNum; ++i) {
+        if (defInsn->OpndIsDef(i)) {
+          continue;
+        }
+        Operand &opnd = defInsn->GetOperand(i);
+        if (opnd.IsRegister() && static_cast<RegOperand&>(opnd).GetRegisterNumber() == phiDefOpnd.GetRegisterNumber()) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool A64PregCopyPattern::CheckValidDefInsn(const Insn *defInsn) {
+  const auto *md = defInsn->GetDesc();
+  CHECK_FATAL(md != nullptr, "expect valid AArch64MD");
+  /* this pattern applies to all basicOps */
+  if (md->IsMove() || md->IsStore() || md->IsLoad() || md->IsLoadStorePair() || md->IsLoadAddress() || md->IsCall() ||
+      md->IsDMB() || md->IsVectorOp() || md->IsCondDef() || md->IsCondBranch() || md->IsUnCondBranch()) {
+    return false;
+  }
+  uint32 opndNum = defInsn->GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = defInsn->GetOperand(i);
+    if (!opnd.IsRegister() && !opnd.IsImmediate() && !opnd.IsOpdShift() && !opnd.IsOpdExtend()) {
+      return false;
+    }
+    if (opnd.IsRegister()) {
+      auto &regOpnd = static_cast<RegOperand&>(opnd);
+      if (cgFunc.IsSPOrFP(regOpnd) || regOpnd.IsPhysicalRegister() ||
+          (!regOpnd.IsOfIntClass() && !regOpnd.IsOfFloatOrSIMDClass())) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool A64PregCopyPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_xmovrr && curMop != MOP_wmovrr) {
+    return false;
+  }
+  auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  if (!dstOpnd.IsPhysicalRegister()) {
+    return false;
+  }
+  regno_t useRegNO = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetRegisterNumber();
+  VRegVersion *useVersion = optSsaInfo->FindSSAVersion(useRegNO);
+  Insn *defInsn = FindDefInsn(useVersion);
+  if (defInsn == nullptr) {
+    return false;
+  }
+  Operand &defDstOpnd = defInsn->GetOperand(kInsnFirstOpnd);
+  /* avoid inline-asm */
+  if (!defDstOpnd.IsRegister()) {
+    return false;
+  }
+  if (!CheckMultiUsePoints(defInsn)) {
+    return false;
+  }
+  if (defInsn->IsPhi()) {
+    isCrossPhi = true;
+    firstPhiInsn = defInsn;
+    return CheckPhiCaseCondition(*defInsn);
+  } else {
+    if (!CheckValidDefInsn(defInsn)) {
+      return false;
+    }
+    if (!CheckUselessDefInsn(defInsn)) {
+      return false;
+    }
+    (void)validDefInsns.emplace_back(defInsn);
+  }
+  return true;
+}
+
+Insn &A64PregCopyPattern::CreateNewPhiInsn(std::unordered_map<uint32, RegOperand*> &newPhiList, Insn *curInsn) {
+  CHECK_FATAL(!newPhiList.empty(), "empty newPhiList");
+  RegOperand *differOrigOpnd = cgFunc.GetVirtualRegisterOperand(differOrigNO);
+  CHECK_FATAL(differOrigOpnd != nullptr, "get original opnd default");
+  PhiOperand &phiList = optSsaInfo->CreatePhiOperand();
+  for (auto &it : newPhiList) {
+    phiList.InsertOpnd(it.first, *it.second);
+  }
+  Insn &phiInsn = cgFunc.GetCG()->BuildPhiInsn(*differOrigOpnd, phiList);
+  optSsaInfo->CreateNewInsnSSAInfo(phiInsn);
+  BB *bb = curInsn->GetBB();
+  (void)bb->InsertInsnBefore(*curInsn, phiInsn);
+  /* <phiDef-ssaRegNO, phiInsn> */
+  bb->AddPhiInsn(differOrigNO, phiInsn);
+  return phiInsn;
+}
+
+/*
+ * Check whether the required phi is available, do not insert phi repeatedly.
+ */
+RegOperand *A64PregCopyPattern::CheckAndGetExistPhiDef(Insn &phiInsn, std::vector<regno_t> &validDifferRegNOs) const {
+  std::set<regno_t> validDifferOrigRegNOs;
+  for (regno_t ssaRegNO : validDifferRegNOs) {
+    VRegVersion *version = optSsaInfo->FindSSAVersion(ssaRegNO);
+    (void)validDifferOrigRegNOs.insert(version->GetOriginalRegNO());
+  }
+  MapleMap<regno_t, Insn*> &phiInsns = phiInsn.GetBB()->GetPhiInsns();
+  for (auto &phiIt : as_const(phiInsns)) {
+    auto &def = static_cast<RegOperand&>(phiIt.second->GetOperand(kInsnFirstOpnd));
+    VRegVersion *defVersion = optSsaInfo->FindSSAVersion(def.GetRegisterNumber());
+    ASSERT(defVersion != nullptr, "defVersion should not be nullptr");
+    /*
+     * if the phi of the change point has been created (according to original regNO), return the phiDefOpnd.
+     * But, there is a problem: the phiDefOpnd of the same original regNO is not the required phi.
+     * For example: (in parentheses is the original regNO)
+     *           add R110(R80), R106(R80), #1              add R122(R80), R118(R80), #1
+     *                                       \            /
+     *                                        \          /
+     *                              (1) phi: R123(R80), [R110, R122]
+     *                                  mov R0, R123
+     *           It will return R123 of phi(1) because the differOrigNO is 80, but that's not what we want,
+     *           we need to create a new phi(2): R140(R80), [R106, R118].
+     *           so we need to check whether all phiOpnds have correct ssaRegNO.
+     */
+    if (defVersion->GetOriginalRegNO() == differOrigNO) {
+      auto &phiOpnd = static_cast<const PhiOperand&>(phiIt.second->GetOperand(kInsnSecondOpnd));
+      if (phiOpnd.GetOperands().size() == validDifferRegNOs.size()) {
+        bool exist = true;
+        for (auto &phiListIt : phiOpnd.GetOperands()) {
+          VRegVersion *phiUseVersion = optSsaInfo->FindSSAVersion(
+              static_cast<RegOperand*>(phiListIt.second)->GetRegisterNumber());
+          if (validDifferOrigRegNOs.find(phiUseVersion->GetOriginalRegNO()) == validDifferOrigRegNOs.end()) {
+            exist = false;
+            break;
+          }
+        }
+        if (exist) {
+          return &static_cast<RegOperand&>(phiIt.second->GetOperand(kInsnFirstOpnd));
+        }
+      }
+    }
+  }
+  return nullptr;
+}
+
+RegOperand &A64PregCopyPattern::DFSBuildPhiInsn(Insn *curInsn, std::unordered_map<uint32, RegOperand*> &visited) {
+  CHECK_FATAL(curInsn, "curInsn must not be null");
+  if (visited[curInsn->GetId()] != nullptr) {
+    return *visited[curInsn->GetId()];
+  }
+  if (!curInsn->IsPhi()) {
+    return static_cast<RegOperand&>(curInsn->GetOperand(static_cast<uint32>(differIdx)));
+  }
+  std::unordered_map<uint32, RegOperand*> differPhiList;
+  std::vector<regno_t> validDifferRegNOs;
+  auto &phiOpnd = static_cast<const PhiOperand&>(curInsn->GetOperand(kInsnSecondOpnd));
+  for (auto &phiListIt : phiOpnd.GetOperands()) {
+    auto &useOpnd = static_cast<RegOperand&>(*phiListIt.second);
+    VRegVersion *useVersion = optSsaInfo->FindSSAVersion(useOpnd.GetRegisterNumber());
+    Insn *defInsn = FindDefInsn(useVersion);
+    CHECK_FATAL(defInsn != nullptr, "get defInsn failed");
+    RegOperand &phiDefOpnd = DFSBuildPhiInsn(defInsn, visited);
+    (void)differPhiList.emplace(phiListIt.first, &phiDefOpnd);
+    (void)validDifferRegNOs.emplace_back(phiDefOpnd.GetRegisterNumber());
+  }
+  /*
+   * The phi in control flow may already exists.
+   * For example:
+   *                              [BB26]                         [BB45]
+   *                          add R191, R103, R187           add R166, R103, R164
+   *                                              \         /
+   *                                               \       /
+   *                                                [BB27]
+   *                                      phi: R192, (R191<26>, R166<45>)  ------ curInsn
+   *                                      phi: R194, (R187<26>, R164<45>)  ------ the phi witch we need already exists
+   *                                                 /                            validDifferRegNOs : [187, 164]
+   *                                                /
+   *                   [BB28]                    [BB46]
+   *              add R215, R103, R211           /
+   *                                  \         /
+   *                                   \       /
+   *                                    [BB29]
+   *                            phi: R216, (R215<28>, R192<46>)
+   *                            phi: R218, (R211<28>, R194<46>)  ------ the phi witch we need already exists
+   *                            mov R0, R216                            validDifferRegNOs : [211, 194]
+   */
+  RegOperand *existPhiDef = CheckAndGetExistPhiDef(*curInsn, validDifferRegNOs);
+  if (existPhiDef == nullptr) {
+    Insn &phiInsn = CreateNewPhiInsn(differPhiList, curInsn);
+    visited[curInsn->GetId()] = &static_cast<RegOperand&>(phiInsn.GetOperand(kInsnFirstOpnd));
+    existPhiDef = &static_cast<RegOperand&>(phiInsn.GetOperand(kInsnFirstOpnd));
+  }
+  return *existPhiDef;
+}
+
+void A64PregCopyPattern::Optimize(Insn &insn) {
+  Insn *defInsn = *validDefInsns.begin();
+  MOperator newMop = defInsn->GetMachineOpcode();
+  Operand &dstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  Insn &newInsn = cgFunc.GetInsnBuilder()->BuildInsn(newMop, AArch64CG::kMd[newMop]);
+  uint32 opndNum = defInsn->GetOperandSize();
+  newInsn.ResizeOpnds(opndNum);
+  if (!isCrossPhi) {
+    for (uint32 i = 0; i < opndNum; ++i) {
+      if (defInsn->OpndIsDef(i)) {
+        newInsn.SetOperand(i, dstOpnd);
+      } else {
+        newInsn.SetOperand(i, defInsn->GetOperand(i));
+      }
+    }
+  } else {
+    std::vector<regno_t> validDifferRegNOs;
+    for (Insn *vdInsn : validDefInsns) {
+      auto &vdOpnd = static_cast<RegOperand&>(vdInsn->GetOperand(static_cast<uint32>(differIdx)));
+      (void)validDifferRegNOs.emplace_back(vdOpnd.GetRegisterNumber());
+    }
+    RegOperand *differPhiDefOpnd = CheckAndGetExistPhiDef(*firstPhiInsn, validDifferRegNOs);
+    if (differPhiDefOpnd == nullptr) {
+      std::unordered_map<uint32, RegOperand*> visited;
+      differPhiDefOpnd = &DFSBuildPhiInsn(firstPhiInsn, visited);
+    }
+    CHECK_FATAL(differPhiDefOpnd, "get differPhiDefOpnd failed");
+    for (uint32 i = 0; i < opndNum; ++i) {
+      if (defInsn->OpndIsDef(i)) {
+        newInsn.SetOperand(i, dstOpnd);
+      } else if (i == static_cast<uint32>(differIdx)) {
+        newInsn.SetOperand(i, *differPhiDefOpnd);
+      } else {
+        newInsn.SetOperand(i, defInsn->GetOperand(i));
+      }
+    }
+  }
+  insn.GetBB()->ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  optSsaInfo->ReplaceInsn(insn, newInsn);
+
+  if (PROP_DUMP) {
+    LogInfo::MapleLogger() << ">>>>>>> In A64PregCopyPattern : <<<<<<<\n";
+    LogInfo::MapleLogger() << "======= ReplaceInsn :\n";
+    insn.Dump();
+    LogInfo::MapleLogger() << "======= NewInsn :\n";
+    newInsn.Dump();
+  }
+}
+
+void A64PregCopyPattern::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      Init();
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*insn);
+    }
+  }
+  validDefInsns.clear();
+  validDefInsns.shrink_to_fit();
+}
+
+void A64ReplaceRegOpndVisitor::Visit(RegOperand *v) {
+  (void)v;
+  insn->SetOperand(idx, *newReg);
+}
+void A64ReplaceRegOpndVisitor::Visit(MemOperand *a64memOpnd) {
+  bool changed = false;
+  CHECK_FATAL(a64memOpnd->IsIntactIndexed(), "NYI post/pre index model");
+  StackMemPool tempMemPool(memPoolCtrler, "temp mempool for A64ReplaceRegOpndVisitor");
+  auto *cpyMem = a64memOpnd->Clone(tempMemPool);
+  if (cpyMem->GetBaseRegister() != nullptr &&
+      cpyMem->GetBaseRegister()->GetRegisterNumber() == oldReg->GetRegisterNumber()) {
+    cpyMem->SetBaseRegister(*static_cast<RegOperand*>(newReg));
+    changed = true;
+  }
+  if (cpyMem->GetIndexRegister() != nullptr &&
+      cpyMem->GetIndexRegister()->GetRegisterNumber() == oldReg->GetRegisterNumber()) {
+    CHECK_FATAL(!changed, "base reg is equal to index reg");
+    cpyMem->SetIndexRegister(*newReg);
+    changed = true;
+  }
+  if (changed) {
+    insn->SetMemOpnd(&static_cast<AArch64CGFunc*>(cgFunc)->GetOrCreateMemOpnd(*cpyMem));
+  }
+}
+void A64ReplaceRegOpndVisitor::Visit(ListOperand *v) {
+  for (auto &it : v->GetOperands()) {
+    if (it->GetRegisterNumber() == oldReg->GetRegisterNumber()) {
+      it = newReg;
+    }
+  }
+}
+void A64ReplaceRegOpndVisitor::Visit(PhiOperand *v) {
+  for (auto &it : v->GetOperands()) {
+    if (it.second->GetRegisterNumber() == oldReg->GetRegisterNumber()) {
+      it.second = newReg;
+    }
+  }
+  auto &phiDest = static_cast<RegOperand&>(insn->GetOperand(kInsnFirstOpnd));
+  if (phiDest.GetValidBitsNum() > v->GetLeastCommonValidBit()) {
+    phiDest.SetValidBitsNum(v->GetLeastCommonValidBit());
+  }
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_ra_opt.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ra_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4b4615d309809e4d75c8246d071d4f73c008fd1d
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ra_opt.cpp
@@ -0,0 +1,696 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "loop.h"
+#include "aarch64_ra_opt.h"
+
+namespace maplebe {
+
+#define RAOPT_DUMP CG_DEBUG_FUNC(*cgFunc)
+
+using namespace std;
+bool RaX0Opt::PropagateX0CanReplace(Operand *opnd, regno_t replaceReg) const {
+  if (opnd != nullptr) {
+    RegOperand *regopnd = static_cast<RegOperand*>(opnd);
+    regno_t regCandidate = regopnd->GetRegisterNumber();
+    if (regCandidate == replaceReg) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/*
+ * Replace replace_reg with rename_reg.
+ * return true if there is a redefinition that needs to terminate the propagation.
+ */
+bool RaX0Opt::PropagateRenameReg(Insn *nInsn, const X0OptInfo &optVal) const {
+  uint32 renameReg = static_cast<RegOperand*>(optVal.GetRenameOpnd())->GetRegisterNumber();
+  const InsnDesc *md = nInsn->GetDesc();
+  int32 lastOpndId = static_cast<int32>(nInsn->GetOperandSize() - 1);
+  for (int32_t i = lastOpndId; i >= 0; i--) {
+    Operand &opnd = nInsn->GetOperand(static_cast<uint32>(i));
+
+    if (opnd.IsList()) {
+      /* call parameters */
+    } else if (opnd.IsMemoryAccessOperand()) {
+      MemOperand &memopnd = static_cast<MemOperand&>(opnd);
+      if (PropagateX0CanReplace(memopnd.GetBaseRegister(), optVal.GetReplaceReg())) {
+        RegOperand *renameOpnd = static_cast<RegOperand*>(optVal.GetRenameOpnd());
+        memopnd.SetBaseRegister(*renameOpnd);
+      }
+      if (PropagateX0CanReplace(memopnd.GetIndexRegister(), optVal.GetReplaceReg())) {
+        RegOperand *renameOpnd = static_cast<RegOperand*>(optVal.GetRenameOpnd());
+        memopnd.SetIndexRegister(*renameOpnd);
+      }
+    } else if (opnd.IsRegister()) {
+      bool isdef = (md->GetOpndDes(static_cast<uint32>(i)))->IsRegDef();
+      RegOperand &regopnd = static_cast<RegOperand&>(opnd);
+      regno_t regCandidate = regopnd.GetRegisterNumber();
+      if (isdef) {
+        /* Continue if both replace_reg & rename_reg are not redefined. */
+        if (regCandidate == optVal.GetReplaceReg() || regCandidate == renameReg) {
+          return true;
+        }
+      } else {
+        if (regCandidate == optVal.GetReplaceReg()) {
+          nInsn->SetOperand(static_cast<uint32>(i), *optVal.GetRenameOpnd());
+        }
+      }
+    }
+  }
+  return false;  /* false == no redefinition */
+}
+
+/* Propagate x0 from a call return value to a def of x0.
+ * This eliminates some local reloads under high register pressure, since
+ * the use has been replaced by x0.
+ */
+bool RaX0Opt::PropagateX0DetectX0(const Insn *insn, X0OptInfo &optVal) const {
+  if (insn->GetMachineOpcode() != MOP_xmovrr && insn->GetMachineOpcode() != MOP_wmovrr) {
+    return false;
+  }
+  RegOperand &movSrc = static_cast<RegOperand&>(insn->GetOperand(1));
+  if (movSrc.GetRegisterNumber() != R0) {
+    return false;
+  }
+
+  optVal.SetMovSrc(&movSrc);
+  return true;
+}
+
+bool RaX0Opt::PropagateX0DetectRedefine(const InsnDesc *md, const Insn *ninsn, const X0OptInfo &optVal,
+                                        uint32 index) const {
+  bool isdef = (md->GetOpndDes(static_cast<int>(index)))->IsRegDef();
+  if (isdef) {
+    RegOperand &opnd = static_cast<RegOperand&>(ninsn->GetOperand(index));
+    if (opnd.GetRegisterNumber() == optVal.GetReplaceReg()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool RaX0Opt::PropagateX0Optimize(const BB *bb, const Insn *insn, X0OptInfo &optVal) const {
+  bool redefined = false;
+  for (Insn *ninsn = insn->GetNext(); (ninsn != nullptr) && ninsn != bb->GetLastInsn()->GetNext();
+       ninsn = ninsn->GetNext()) {
+    if (!ninsn->IsMachineInstruction()) {
+      continue;
+    }
+
+    if (ninsn->IsCall()) {
+      break;
+    }
+
+    /* Will continue as long as the reg being replaced is not redefined.
+     * Does not need to check for x0 redefinition.  The mov instruction src
+     * being replaced already defines x0 and will terminate this loop.
+     */
+    const InsnDesc *md = ninsn->GetDesc();
+    for (uint32 i = 0; i < ninsn->GetDefRegs().size(); i++) {
+      redefined = PropagateX0DetectRedefine(md, ninsn, optVal, i);
+      if (redefined) {
+        break;
+      }
+    }
+    if (redefined) {
+      break;
+    }
+
+    /* Look for move where src is the register equivalent to x0. */
+    if (ninsn->GetMachineOpcode() != MOP_xmovrr && ninsn->GetMachineOpcode() != MOP_wmovrr) {
+      continue;
+    }
+
+    Operand *src = &ninsn->GetOperand(1);
+    RegOperand *srcreg = static_cast<RegOperand*>(src);
+    if (srcreg->GetRegisterNumber() != optVal.GetReplaceReg()) {
+      continue;
+    }
+
+    /* Setup for the next optmization pattern. */
+    Operand *dst = &ninsn->GetOperand(0);
+    RegOperand *dstreg = static_cast<RegOperand*>(dst);
+    if (dstreg->GetRegisterNumber() != R0) {
+      /* This is to set up for further propagation later. */
+      if (srcreg->GetRegisterNumber() == optVal.GetReplaceReg()) {
+        if (optVal.GetRenameInsn() != nullptr) {
+          redefined = true;
+          break;
+        } else {
+          optVal.SetRenameInsn(ninsn);
+          optVal.SetRenameOpnd(dst);
+          optVal.SetRenameReg(dstreg->GetRegisterNumber());
+        }
+      }
+      continue;
+    }
+
+    if (redefined) {
+      break;
+    }
+
+    /* x0 = x0 */
+    ninsn->SetOperand(1, *optVal.GetMovSrc());
+    break;
+  }
+
+  return redefined;
+}
+
+bool RaX0Opt::PropagateX0ForCurrBb(BB *bb, const X0OptInfo &optVal) const {
+  bool redefined = false;
+  for (Insn *ninsn = optVal.GetRenameInsn()->GetNext(); (ninsn != nullptr) && ninsn != bb->GetLastInsn()->GetNext();
+       ninsn = ninsn->GetNext()) {
+    if (!ninsn->IsMachineInstruction()) {
+      continue;
+    }
+    redefined = PropagateRenameReg(ninsn, optVal);
+    if (redefined) {
+      break;
+    }
+  }
+  if (!redefined) {
+    auto it = bb->GetLiveOutRegNO().find(optVal.GetReplaceReg());
+    if (it != bb->GetLiveOutRegNO().end()) {
+      bb->EraseLiveOutRegNO(it);
+    }
+    uint32 renameReg = static_cast<RegOperand*>(optVal.GetRenameOpnd())->GetRegisterNumber();
+    bb->InsertLiveOutRegNO(renameReg);
+  }
+  return redefined;
+}
+
+void RaX0Opt::PropagateX0ForNextBb(BB *nextBb, const X0OptInfo &optVal) const {
+  bool redefined = false;
+  for (Insn *ninsn = nextBb->GetFirstInsn(); ninsn != nextBb->GetLastInsn()->GetNext(); ninsn = ninsn->GetNext()) {
+    if (!ninsn->IsMachineInstruction()) {
+      continue;
+    }
+    redefined = PropagateRenameReg(ninsn, optVal);
+    if (redefined) {
+      break;
+    }
+  }
+  if (!redefined) {
+    auto it = nextBb->GetLiveOutRegNO().find(optVal.GetReplaceReg());
+    if (it != nextBb->GetLiveOutRegNO().end()) {
+      nextBb->EraseLiveOutRegNO(it);
+    }
+    uint32 renameReg = static_cast<RegOperand *>(optVal.GetRenameOpnd())->GetRegisterNumber();
+    nextBb->InsertLiveOutRegNO(renameReg);
+  }
+}
+
+/*
+ * Perform optimization.
+ * First propagate x0 in a bb.
+ * Second propagation see comment in function.
+ */
+void RaX0Opt::PropagateX0() {
+  FOR_ALL_BB(bb, cgFunc) {
+    X0OptInfo optVal;
+
+    Insn *insn = bb->GetFirstInsn();
+    while ((insn != nullptr) && !insn->IsMachineInstruction()) {
+      insn = insn->GetNext();
+      continue;
+    }
+    if (insn == nullptr) {
+      continue;
+    }
+    if (!PropagateX0DetectX0(insn, optVal)) {
+      continue;
+    }
+
+    /* At this point the 1st insn is a mov from x0. */
+    RegOperand &movDst = static_cast<RegOperand&>(insn->GetOperand(0));
+    optVal.SetReplaceReg(movDst.GetRegisterNumber());
+    optVal.ResetRenameInsn();
+    bool redefined = PropagateX0Optimize(bb, insn, optVal);
+    if (redefined || (optVal.GetRenameInsn() == nullptr)) {
+      continue;
+    }
+
+    /* Next pattern to help LSRA.  Short cross bb live interval.
+     *  Straight line code.  Convert reg2 into bb local.
+     *  bb1
+     *     mov  reg2 <- x0          =>   mov  reg2 <- x0
+     *     mov  reg1 <- reg2             mov  reg1 <- reg2
+     *     call                          call
+     *  bb2  : livein< reg1 reg2 >
+     *     use          reg2             use          reg1
+     *     ....
+     *     reg2 not liveout
+     *
+     * Can allocate caller register for reg2.
+     *
+     * Further propagation of very short live interval cross bb reg
+     */
+    if (optVal.GetRenameReg() < kMaxRegNum) {  /* dont propagate physical reg */
+      continue;
+    }
+    BB *nextBb = bb->GetNext();
+    if (nextBb == nullptr) {
+      break;
+    }
+    if (bb->GetSuccs().size() != 1 || nextBb->GetPreds().size() != 1) {
+      continue;
+    }
+    if (bb->GetSuccs().front() != nextBb || nextBb->GetPreds().front() != bb) {
+      continue;
+    }
+    if (bb->GetLiveOutRegNO().find(optVal.GetReplaceReg()) == bb->GetLiveOutRegNO().end() ||
+        bb->GetLiveOutRegNO().find(optVal.GetRenameReg()) == bb->GetLiveOutRegNO().end() ||
+        nextBb->GetLiveOutRegNO().find(optVal.GetReplaceReg()) != nextBb->GetLiveOutRegNO().end()) {
+      continue;
+    }
+    /* Replace replace_reg by rename_reg. */
+    redefined = PropagateX0ForCurrBb(bb, optVal);
+    if (redefined) {
+      continue;
+    }
+    PropagateX0ForNextBb(nextBb, optVal);
+  }
+}
+
+void VregRename::PrintRenameInfo(regno_t regno) const {
+  VregRenameInfo *info = (regno <= maxRegnoSeen) ? renameInfo[regno] : nullptr;
+  if (info == nullptr || (info->numDefs == 0 && info->numUses == 0)) {
+    return;
+  }
+  LogInfo::MapleLogger() << "reg: " << regno;
+  if (info->firstBBLevelSeen != nullptr) {
+    LogInfo::MapleLogger() << " fromLevel " << info->firstBBLevelSeen->GetInternalFlag2();
+  }
+  if (info->lastBBLevelSeen != nullptr) {
+    LogInfo::MapleLogger() << " toLevel " << info->lastBBLevelSeen->GetInternalFlag2();
+  }
+  if (info->numDefs > 0) {
+    LogInfo::MapleLogger() << " defs " << info->numDefs;
+  }
+  if (info->numUses > 0) {
+    LogInfo::MapleLogger() << " uses " << info->numUses;
+  }
+  if (info->numDefs > 0) {
+    LogInfo::MapleLogger() << " innerDefs " << info->numInnerDefs;
+  }
+  if (info->numUses > 0) {
+    LogInfo::MapleLogger() << " innerUses " << info->numInnerUses;
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void VregRename::PrintAllRenameInfo() const {
+  for (uint32 regno = 0; regno < cgFunc->GetMaxRegNum(); ++regno) {
+    PrintRenameInfo(regno);
+  }
+}
+
+bool VregRename::IsProfitableToRename(const VregRenameInfo *info) const{
+  if ((info->numInnerDefs == 0) && (info->numUses != info->numInnerUses)) {
+    return true;
+  }
+  return false;
+}
+
+void VregRename::RenameProfitableVreg(RegOperand *ropnd, const CGFuncLoops *loop) {
+  regno_t vreg = ropnd->GetRegisterNumber();
+  VregRenameInfo *info = (vreg <= maxRegnoSeen) ? renameInfo[vreg] : nullptr;
+  if ((info == nullptr) || loop->GetMultiEntries().size() > 0 || (!IsProfitableToRename(info))) {
+    return;
+  }
+
+  uint32 size = (ropnd->GetSize() == k64BitSize) ? k8ByteSize : k4ByteSize;
+  regno_t newRegno = cgFunc->NewVReg(ropnd->GetRegisterType(), size);
+  RegOperand *renameVreg = &cgFunc->CreateVirtualRegisterOperand(newRegno);
+
+  const BB *header = loop->GetHeader();
+  for (auto pred : header->GetPreds()) {
+    if (find(loop->GetBackedge().begin(), loop->GetBackedge().end(), pred) != loop->GetBackedge().end()) {
+      continue;
+    }
+    MOperator mOp = (ropnd->GetRegisterType() == kRegTyInt) ?
+        ((size == k8BitSize) ? MOP_xmovrr : MOP_wmovrr) :
+        ((size == k8BitSize) ? MOP_xvmovd : MOP_xvmovs);
+    Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, *renameVreg, *ropnd);
+    Insn *last = pred->GetLastInsn();
+    if (last) {
+      if (last->IsBranch()) {
+        last->GetBB()->InsertInsnBefore(*last, newInsn);
+      } else {
+        last->GetBB()->InsertInsnAfter(*last, newInsn);
+      }
+    } else {
+      pred->AppendInsn(newInsn);
+    }
+  }
+
+  for (auto bb : loop->GetLoopMembers()) {
+    FOR_BB_INSNS(insn, bb) {
+      if (insn->IsImmaterialInsn() || !insn->IsMachineInstruction()) {
+        continue;
+      }
+      for (uint32 i = 0; i < insn->GetOperandSize(); ++i) {
+        Operand *opnd = &insn->GetOperand(i);
+        if (opnd->IsList()) {
+          /* call parameters */
+        } else if (opnd->IsMemoryAccessOperand()) {
+          MemOperand *memopnd = static_cast<MemOperand*>(opnd);
+          RegOperand *base = static_cast<RegOperand*>(memopnd->GetBaseRegister());
+          MemOperand *newMemOpnd = nullptr;
+          if (base != nullptr && base->IsVirtualRegister() && base->GetRegisterNumber() == vreg) {
+            newMemOpnd = static_cast<MemOperand*>(memopnd->Clone(*cgFunc->GetMemoryPool()));
+            newMemOpnd->SetBaseRegister(*renameVreg);
+            insn->SetOperand(i, *newMemOpnd);
+          }
+          RegOperand *offset = static_cast<RegOperand*>(memopnd->GetIndexRegister());
+          if (offset != nullptr && offset->IsVirtualRegister() && offset->GetRegisterNumber() == vreg) {
+            if (newMemOpnd == nullptr) {
+              newMemOpnd = static_cast<MemOperand*>(memopnd->Clone(*cgFunc->GetMemoryPool()));
+            }
+            newMemOpnd->SetIndexRegister(*renameVreg);
+            insn->SetOperand(i, *newMemOpnd);
+          }
+        } else if (opnd->IsRegister() && static_cast<RegOperand *>(opnd)->IsVirtualRegister() &&
+                   static_cast<RegOperand *>(opnd)->GetRegisterNumber() == vreg) {
+          insn->SetOperand(i, *renameVreg);
+        }
+      }
+    }
+  }
+}
+
+void VregRename::RenameFindLoopVregs(const CGFuncLoops *loop) {
+  for (auto *bb : loop->GetLoopMembers()) {
+    FOR_BB_INSNS(insn, bb) {
+      if (insn->IsImmaterialInsn() || !insn->IsMachineInstruction()) {
+        continue;
+      }
+      for (uint32 i = 0; i < insn->GetOperandSize(); ++i) {
+        Operand *opnd = &insn->GetOperand(i);
+        if (opnd->IsList()) {
+          /* call parameters */
+        } else if (opnd->IsMemoryAccessOperand()) {
+          MemOperand *memopnd = static_cast<MemOperand*>(opnd);
+          RegOperand *base = static_cast<RegOperand*>(memopnd->GetBaseRegister());
+          if (base != nullptr && base->IsVirtualRegister()) {
+            RenameProfitableVreg(base, loop);
+          }
+          RegOperand *offset = static_cast<RegOperand*>(memopnd->GetIndexRegister());
+          if (offset != nullptr && offset->IsVirtualRegister()) {
+            RenameProfitableVreg(offset, loop);
+          }
+        } else if (opnd->IsRegister() && static_cast<RegOperand *>(opnd)->IsVirtualRegister() &&
+                   static_cast<RegOperand *>(opnd)->GetRegisterNumber() != ccRegno) {
+          RenameProfitableVreg(static_cast<RegOperand *>(opnd), loop);
+        }
+      }
+    }
+  }
+}
+
+/* Only the bb level is important, not the bb itself.
+ * So if multiple bbs have the same level, only one bb represents the level
+ */
+void VregRename::UpdateVregInfo(regno_t vreg, BB *bb, bool isInner, bool isDef) {
+  VregRenameInfo *info = renameInfo[vreg];
+  if (info == nullptr) {
+    info = memPool->New<VregRenameInfo>();
+    renameInfo[vreg] = info;
+    if (vreg > maxRegnoSeen) {
+      maxRegnoSeen = vreg;
+    }
+  }
+  if (isDef) {
+    info->numDefs++;
+    if (isInner) {
+      info->numInnerDefs++;
+    }
+  } else {
+    info->numUses++;
+    if (isInner) {
+      info->numInnerUses++;
+    }
+  }
+  if (info->firstBBLevelSeen) {
+    if (info->firstBBLevelSeen->GetInternalFlag2() > bb->GetInternalFlag2()) {
+      info->firstBBLevelSeen = bb;
+    }
+  } else {
+    info->firstBBLevelSeen = bb;
+  }
+  if (info->lastBBLevelSeen) {
+    if (info->lastBBLevelSeen->GetInternalFlag2() < bb->GetInternalFlag2()) {
+      info->lastBBLevelSeen = bb;
+    }
+  } else {
+    info->lastBBLevelSeen = bb;
+  }
+}
+
+void VregRename::RenameGetFuncVregInfo() {
+  FOR_ALL_BB(bb, cgFunc) {
+    bool isInner = bb->GetLoop() ? bb->GetLoop()->GetInnerLoops().empty() : false;
+    FOR_BB_INSNS(insn, bb) {
+      if (insn->IsImmaterialInsn() || !insn->IsMachineInstruction()) {
+        continue;
+      }
+      const InsnDesc *md = insn->GetDesc();
+      for (uint32 i = 0; i < insn->GetOperandSize(); ++i) {
+        Operand *opnd = &insn->GetOperand(i);
+        if (opnd->IsList()) {
+          /* call parameters */
+        } else if (opnd->IsMemoryAccessOperand()) {
+          MemOperand *memopnd = static_cast<MemOperand*>(opnd);
+          RegOperand *base = static_cast<RegOperand*>(memopnd->GetBaseRegister());
+          if (base != nullptr && base->IsVirtualRegister()) {
+            regno_t vreg = base->GetRegisterNumber();
+            UpdateVregInfo(vreg, bb, isInner, false);
+          }
+          RegOperand *offset = static_cast<RegOperand*>(memopnd->GetIndexRegister());
+          if (offset != nullptr && offset->IsVirtualRegister()) {
+            regno_t vreg = offset->GetRegisterNumber();
+            UpdateVregInfo(vreg, bb, isInner, false);
+          }
+        } else if (opnd->IsRegister() && static_cast<RegOperand *>(opnd)->IsVirtualRegister() &&
+                   static_cast<RegOperand *>(opnd)->GetRegisterNumber() != ccRegno) {
+          bool isdef = (md->opndMD[i])->IsRegDef();
+          regno_t vreg = static_cast<RegOperand *>(opnd)->GetRegisterNumber();
+          UpdateVregInfo(vreg, bb, isInner, isdef);
+        }
+      }
+    }
+  }
+}
+
+void VregRename::RenameFindVregsToRename(const CGFuncLoops *loop) {
+  if (loop->GetInnerLoops().empty()) {
+    RenameFindLoopVregs(loop);
+    return;
+  }
+  for (auto inner : loop->GetInnerLoops()) {
+    RenameFindVregsToRename(inner);
+  }
+}
+
+
+void VregRename::VregLongLiveRename() {
+  if (cgFunc->GetLoops().size() == 0) {
+    return;
+  }
+  RenameGetFuncVregInfo();
+  for (const auto *lp : cgFunc->GetLoops()) {
+    RenameFindVregsToRename(lp);
+  }
+}
+
+bool ParamRegOpt::DominatorAll(uint32 domBB, std::set<uint32> &refBBs) const {
+  for (auto it: refBBs) {
+    if (!domInfo->Dominate(*cgFunc->GetBBFromID(domBB), *cgFunc->GetBBFromID(it))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+BB* ParamRegOpt::GetCommondDom(std::set<uint32> &refBBs) {
+  MapleVector<uint32> &domOrder = domInfo->GetDtPreOrder();
+  uint32 minId = static_cast<uint32>(domOrder.size());
+  for (auto it = domOrder.crbegin(); it != domOrder.crend(); ++it) {
+    uint32 curBBId = *it;
+    if (refBBs.find(curBBId) != refBBs.end()) {
+      minId = curBBId;
+    }
+  }
+  if (DominatorAll(minId, refBBs)) {
+    BB* domBB = cgFunc->GetBBFromID(minId);
+    while (domBB->GetLoop() != nullptr) {
+      domBB = domInfo->GetDom(domBB->GetId());
+    }
+    return domBB;
+  }
+  BB *curBB = domInfo->GetDom(minId);
+  while (curBB != nullptr && curBB != cgFunc->GetFirstBB()) {
+    if (DominatorAll(curBB->GetId(), refBBs)) {
+      break;
+    }
+    curBB = domInfo->GetDom(curBB->GetId());
+  }
+  if (curBB == nullptr || curBB == cgFunc->GetFirstBB()) {
+    return nullptr;
+  }
+  while (curBB->GetLoop() != nullptr) {
+    curBB = domInfo->GetDom(curBB->GetId());
+  }
+  return curBB;
+}
+
+void ParamRegOpt::SplitAtDomBB(RegOperand &movDest, BB &domBB, Insn &posInsn) const {
+  if (dumpInfo) {
+    LogInfo::MapleLogger() << "----cand R" << movDest.GetRegisterNumber() <<
+        " to split at BB" << domBB.GetId() << " \n";
+  }
+  uint32 size = (movDest.GetSize() == k64BitSize) ? k8ByteSize : k4ByteSize;
+  regno_t newRegno = cgFunc->NewVReg(movDest.GetRegisterType(), size);
+  RegOperand *renameVreg = &cgFunc->CreateVirtualRegisterOperand(newRegno);
+  MOperator mOp = (movDest.GetRegisterType() == kRegTyInt) ?
+                  ((size == k8BitSize) ? MOP_xmovrr : MOP_wmovrr) :
+                  ((size == k8BitSize) ? MOP_xvmovd : MOP_xvmovs);
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, movDest, *renameVreg);
+  domBB.InsertInsnBegin(newInsn);
+  posInsn.SetOperand(kFirstOpnd, *renameVreg);
+}
+
+void ParamRegOpt::CollectRefBBs(RegOperand &movDest, std::set<uint32> &refBBs) {
+  regno_t cand = movDest.GetRegisterNumber();
+  BB* firstBB = cgFunc->GetFirstBB();
+  std::set<uint32> defBBs;
+  std::set<uint32> useBBs;
+  std::set<uint32> crossCallBBs;
+  FOR_ALL_BB(bb, cgFunc) {
+    bool bbHasCall = false;
+    FOR_BB_INSNS(insn, bb) {
+      if (insn->IsImmaterialInsn() || !insn->IsMachineInstruction()) {
+        continue;
+      }
+      bbHasCall = bbHasCall || insn->IsCall();
+      if (insn->ScanReg(cand)) {
+        if (insn->IsRegDefined(cand)) {
+          (void)defBBs.insert(bb->GetId());
+          if (bbHasCall) {
+            (void)crossCallBBs.insert(bb->GetId());
+          }
+        } else {
+          (void)useBBs.insert(bb->GetId());
+          if (bbHasCall) {
+            (void)crossCallBBs.insert(bb->GetId());
+          }
+        }
+      }
+    }
+    if (bbHasCall && (bb->GetLiveOutRegNO().find(cand) != bb->GetLiveOutRegNO().end() ||
+                      bb->GetLiveInRegNO().find(cand) != bb->GetLiveInRegNO().end())) {
+      (void)crossCallBBs.insert(bb->GetId());
+    }
+  }
+  /* expect single def and cross call */
+  if (defBBs.size() != 1 || crossCallBBs.empty()) {
+    return;
+  }
+  /* single defBB should be the firstBB */
+  if (defBBs.find(firstBB->GetId()) == defBBs.end()) {
+    return;
+  }
+  /* expect no use or call in the firstBB */
+  if (useBBs.find(firstBB->GetId()) != useBBs.end() || crossCallBBs.find(firstBB->GetId()) != crossCallBBs.end()) {
+    return;
+  }
+  useBBs.insert(crossCallBBs.cbegin(), crossCallBBs.cend());
+  refBBs.insert(useBBs.cbegin(), useBBs.cend());
+}
+
+void ParamRegOpt::TryToSplitParamReg(RegOperand &movDest, Insn &posInsn) {
+  std::set<uint32> useBBs;
+  CollectRefBBs(movDest, useBBs);
+  if (useBBs.empty()) {
+    return;
+  }
+  /* common dom */
+  BB* firstBB = cgFunc->GetFirstBB();
+  BB *domBB = GetCommondDom(useBBs);
+  BB *secondBB = nullptr;
+  if (firstBB->GetSuccs().size() == 1) {
+    secondBB = *firstBB->GetSuccs().begin();
+  }
+  if (domBB == nullptr || domBB == firstBB || domBB == secondBB) {
+    return;
+  }
+  /* do split */
+  SplitAtDomBB(movDest, *domBB, posInsn);
+}
+
+void ParamRegOpt::HandleParamReg() {
+  uint32 formalCount = static_cast<uint32>(cgFunc->GetFunction().GetFormalCount());
+  if (formalCount == 0) {
+    return;
+  }
+  BB* firstBB = cgFunc->GetFirstBB();
+  FOR_BB_INSNS(insn, firstBB) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    if (insn->GetMachineOpcode() != MOP_xmovrr && insn->GetMachineOpcode() != MOP_wmovrr &&
+        insn->GetMachineOpcode() != MOP_xvmovd && insn->GetMachineOpcode() != MOP_xvmovs) {
+      return;
+    }
+    RegOperand &movDest = static_cast<RegOperand&>(insn->GetOperand(kFirstOpnd));
+    RegOperand &movSrc = static_cast<RegOperand&>(insn->GetOperand(kSecondOpnd));
+    if (movSrc.IsVirtualRegister()) {
+      return;
+    }
+    if (movSrc.IsPhysicalRegister() && movSrc.GetRegisterNumber() == RSP) {
+      return;
+    }
+    TryToSplitParamReg(movDest, *insn);
+  }
+}
+
+void AArch64RaOpt::Run() {
+  RaX0Opt x0Opt(cgFunc);
+  x0Opt.PropagateX0();
+
+  if (RAOPT_DUMP) {
+    LogInfo::MapleLogger() << "Handle func:" << cgFunc->GetName() << ", funcid: " <<
+        cgFunc->GetFunction().GetPuidx() << " \n";
+  }
+  ParamRegOpt argOpt(cgFunc, domInfo);
+  argOpt.SetDumpInfo(RAOPT_DUMP);
+  argOpt.HandleParamReg();
+
+  if (cgFunc->GetMirModule().GetSrcLang() == kSrcLangC && CGOptions::DoVregRename()) {
+    /* loop detection considers EH bb.  That is not handled.  So C only for now. */
+    LoopFinder *lf = memPool->New<LoopFinder>(*cgFunc, *memPool);
+    lf->FormLoopHierarchy();
+    VregRename rename(cgFunc, memPool);
+    Bfs localBfs(*cgFunc, *memPool);
+    rename.bfs = &localBfs;
+    rename.bfs->ComputeBlockOrder();
+    rename.VregLongLiveRename();
+    cgFunc->ClearLoopInfo();
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_rce.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_rce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..27f8c1cfefb3ca2332e96b55857585361bcda155
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_rce.cpp
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_rce.h"
+
+namespace maplebe {
+void AArch64RedundantComputeElim::Run() {
+  FOR_ALL_BB(bb, cgFunc) {
+    if (bb->IsUnreachable()) {
+      continue;
+    }
+    bool opt;
+    g_count = 0;
+    do {
+      /* reset hashSeed and hashSet */
+      g_hashSeed = 0;
+      candidates.clear();
+      opt = DoOpt(bb);
+      ++g_count;
+    } while (opt);
+  }
+  if (CG_RCE_DUMP) {
+    DumpHash();
+  }
+}
+
+bool AArch64RedundantComputeElim::CheckFakeOptmization(const Insn &existInsn) const {
+  /* insns such as {movrr & zxt/sxt & ...} are optimized by prop */
+  MOperator mop = existInsn.GetMachineOpcode();
+  if (mop == MOP_wmovrr || mop == MOP_xmovrr || (mop >= MOP_xsxtb32 && mop <= MOP_xuxtw64)) {
+    return false;
+  }
+  /* patterns such as {movz ... movk ...} are optimized by LoadFloatPointPattern in cgprepeephole */
+  if (mop == MOP_wmovzri16 || mop == MOP_xmovzri16) {
+    auto &dstOpnd = static_cast<RegOperand&>(existInsn.GetOperand(kInsnFirstOpnd));
+    VRegVersion *dstVersion = ssaInfo->FindSSAVersion(dstOpnd.GetRegisterNumber());
+    ASSERT(dstVersion, "get ssa version failed");
+    for (auto useIt : dstVersion->GetAllUseInsns()) {
+      ASSERT(useIt.second, "get DUInsnInfo failed");
+      Insn *useInsn = useIt.second->GetInsn();
+      ASSERT(useInsn, "get useInsn by ssaVersion failed");
+      if (useInsn->GetMachineOpcode() == MOP_wmovkri16 || useInsn->GetMachineOpcode() == MOP_xmovkri16) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+void AArch64RedundantComputeElim::CheckCondition(const Insn &existInsn, const Insn &curInsn) {
+  if (!CheckFakeOptmization(existInsn)) {
+    doOpt = false;
+    return;
+  }
+  RegOperand *existDefOpnd = nullptr;
+  RegOperand *curDefOpnd = nullptr;
+  /*
+   * the case as following is 'fake' redundancy opportunity:
+   *                              [BB8]       --------------------
+   *                     phi: R138, (R136<7>, R146<12>)          |
+   *                     phi: R139, (R131<7>, R147<12>)          |
+   *                         /                \                  |
+   *                        /                  \                 |
+   *                      [BB9]  ----------- [BB12]              |
+   *                                      sub R146, R139, #1     |
+   *                                      sub R147, R139, #1     |
+   *                                      cbnz R147, label    ----
+   */
+  uint32 opndNum = existInsn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    if (existInsn.OpndIsDef(i) && existInsn.OpndIsUse(i) && curInsn.OpndIsDef(i) && curInsn.OpndIsUse(i)) {
+      doOpt = true;
+      return;
+    }
+    if (!existInsn.GetOperand(i).IsRegister()) {
+      CHECK_FATAL(!curInsn.GetOperand(i).IsRegister(), "check the two insns");
+      continue;
+    }
+    if (existInsn.OpndIsDef(i) && curInsn.OpndIsDef(i)) {
+      existDefOpnd = &static_cast<RegOperand&>(existInsn.GetOperand(i));
+      curDefOpnd = &static_cast<RegOperand&>(curInsn.GetOperand(i));
+      /* def points without use are not processed */
+      VRegVersion *existDefVer = ssaInfo->FindSSAVersion(existDefOpnd->GetRegisterNumber());
+      VRegVersion *curDefVer = ssaInfo->FindSSAVersion(curDefOpnd->GetRegisterNumber());
+      CHECK_FATAL(existDefVer && curDefVer, "get ssa version failed");
+      if (existDefVer->GetAllUseInsns().empty() || curDefVer->GetAllUseInsns().empty()) {
+        doOpt = false;
+        return;
+      }
+    }
+    if (existInsn.OpndIsUse(i) && curInsn.OpndIsUse(i)) {
+      auto &existUseOpnd = static_cast<RegOperand&>(existInsn.GetOperand(i));
+      Insn *predInsn = ssaInfo->GetDefInsn(existUseOpnd);
+      if (predInsn != nullptr && predInsn->IsPhi()) {
+        auto &phiOpnd = static_cast<const PhiOperand&>(predInsn->GetOperand(kInsnSecondOpnd));
+        for (auto &phiListIt : phiOpnd.GetOperands()) {
+          if (phiListIt.second == nullptr) {
+            continue;
+          }
+          regno_t phiRegNO = phiListIt.second->GetRegisterNumber();
+          CHECK_FATAL(existDefOpnd && curDefOpnd, "check the def of this insn");
+          if (phiRegNO == existDefOpnd->GetRegisterNumber() || phiRegNO == curDefOpnd->GetRegisterNumber()) {
+            doOpt = false;
+            return;
+          }
+        }
+      }
+    }
+  }
+  /*
+   * 1) avoid spills for propagating across calls:
+   *      mov R100, #1
+   *      ...
+   *      bl func
+   *      mov R103, #1
+   *      str R103, [mem]
+   *
+   * 2) avoid cc redefine between two same insns that define cc
+   */
+  CHECK_FATAL(existDefOpnd != nullptr && curDefOpnd != nullptr, "invalied defOpnd");
+  bool isDefCC = (existDefOpnd->IsOfCC() || curDefOpnd->IsOfCC());
+  for (const Insn *cursor = &existInsn; cursor != nullptr && cursor != &curInsn; cursor = cursor->GetNext()) {
+    if (!cursor->IsMachineInstruction()) {
+      continue;
+    }
+    if (cursor->IsCall()) {
+      doOpt = false;
+      return;
+    }
+    if (isDefCC && cursor->GetOperand(kInsnFirstOpnd).IsRegister() &&
+        static_cast<RegOperand&>(cursor->GetOperand(kInsnFirstOpnd)).IsOfCC()) {
+      doOpt = false;
+      return;
+    }
+  }
+}
+
+std::size_t AArch64RedundantComputeElim::ComputeDefUseHash(const Insn &insn, const RegOperand *replaceOpnd) const {
+  std::size_t hashSeed = 0;
+  std::string hashS = std::to_string(insn.GetMachineOpcode());
+  uint32 opndNum = insn.GetOperandSize();
+  hashS += std::to_string(opndNum);
+  for (uint i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    if (insn.OpndIsDef(i) && insn.OpndIsUse(i)) {
+      CHECK_FATAL(opnd.IsRegister(), "must be");
+      hashS += (replaceOpnd == nullptr ?
+        static_cast<RegOperand&>(opnd).GetHashContent() : replaceOpnd->GetHashContent());
+    } else if (insn.OpndIsUse(i)) {
+      Operand::OperandType opndKind = opnd.GetKind();
+      if (opndKind == Operand::kOpdImmediate) {
+        hashS += static_cast<ImmOperand &>(opnd).GetHashContent();
+      } else if (opndKind == Operand::kOpdExtend) {
+        hashS += static_cast<ExtendShiftOperand &>(opnd).GetHashContent();
+      } else if (opndKind == Operand::kOpdShift) {
+        hashS += static_cast<BitShiftOperand &>(opnd).GetHashContent();
+      } else {
+        hashS += std::to_string(++hashSeed);
+      }
+    }
+  }
+  return std::hash<std::string>{}(hashS);
+}
+
+DUInsnInfo *AArch64RedundantComputeElim::GetDefUseInsnInfo(VRegVersion &defVersion) {
+  DUInsnInfo *defUseInfo = nullptr;
+  for (auto duInfoIt : defVersion.GetAllUseInsns()) {
+    ASSERT(duInfoIt.second, "get DUInsnInfo failed");
+    Insn *useInsn = duInfoIt.second->GetInsn();
+    ASSERT(useInsn, "get useInsn by ssaVersion failed");
+    for (auto &opndIt : as_const(duInfoIt.second->GetOperands())) {
+      if (opndIt.first == useInsn->GetBothDefUseOpnd()) {
+        if (defUseInfo != nullptr) {
+          doOpt = false;
+          return nullptr;
+        } else {
+          defUseInfo = duInfoIt.second;
+          break;
+        }
+      }
+    }
+  }
+  return defUseInfo;
+}
+
+/*
+ * useInsns of existVersion that have both def & use must check complete chain
+ * For example:
+ *   movn  R143, #2
+ *   movk  R143(use){implicit-def: R144}, #32767, LSL #16
+ *   movk  R144(use){implicit-def: R145}, #65534, LSL #32
+ *   ...
+ *   movn  R152, #2                                         ===> can not be optimized
+ *   movk  R152(use){implicit-def: R153), #32767, LSL #16
+ *   movk  R153(use){implicit-def: R154), #8198, LSL #48    ----> different
+ */
+void AArch64RedundantComputeElim::CheckBothDefAndUseChain(RegOperand *curDstOpnd, RegOperand *existDstOpnd) {
+  if (curDstOpnd == nullptr || existDstOpnd == nullptr) {
+    doOpt = false;
+    return;
+  }
+  VRegVersion *existDefVer = ssaInfo->FindSSAVersion(existDstOpnd->GetRegisterNumber());
+  VRegVersion *curDefVer = ssaInfo->FindSSAVersion(curDstOpnd->GetRegisterNumber());
+  CHECK_FATAL(existDefVer && curDefVer, "get ssa version failed");
+  DUInsnInfo *existInfo = GetDefUseInsnInfo(*existDefVer);
+  DUInsnInfo *curInfo = GetDefUseInsnInfo(*curDefVer);
+  if (existInfo == nullptr) {
+    return;
+  }
+  if (curInfo == nullptr) {
+    doOpt = false;
+    return;
+  }
+  if (existInfo->GetOperands().size() > 1 || curInfo->GetOperands().size() > 1 ||
+      existInfo->GetOperands().begin()->first != curInfo->GetOperands().begin()->first) {
+    doOpt = false;
+    return;
+  }
+  uint32 opndIdx = existInfo->GetOperands().cbegin()->first;
+  Insn *existUseInsn = existInfo->GetInsn();
+  Insn *curUseInsn = curInfo->GetInsn();
+  CHECK_FATAL(existUseInsn && curUseInsn, "get useInsn failed");
+  if (existUseInsn->OpndIsDef(opndIdx) && curUseInsn->OpndIsDef(opndIdx)) {
+    std::size_t existHash = ComputeDefUseHash(*existUseInsn, nullptr);
+    std::size_t curHash = ComputeDefUseHash(*curUseInsn, existDstOpnd);
+    if (existHash != curHash) {
+      doOpt = false;
+      return;
+    } else {
+      curDstOpnd = curUseInsn->GetSSAImpDefOpnd();
+      existDstOpnd = existUseInsn->GetSSAImpDefOpnd();
+      CheckBothDefAndUseChain(curDstOpnd, existDstOpnd);
+    }
+  } else if (existUseInsn->OpndIsDef(opndIdx)) {
+    doOpt = false;
+    return;
+  }
+}
+
+bool AArch64RedundantComputeElim::IsBothDefUseCase(VRegVersion &version) const {
+  for (auto infoIt : version.GetAllUseInsns()) {
+    ASSERT(infoIt.second != nullptr, "get duInsnInfo failed");
+    Insn *useInsn = infoIt.second->GetInsn();
+    ASSERT(useInsn != nullptr, "get useInsn failed");
+    for (auto &opndIt : as_const(infoIt.second->GetOperands())) {
+      if (useInsn->GetBothDefUseOpnd() == opndIt.first) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool AArch64RedundantComputeElim::DoOpt(BB *bb) {
+  bool optimize = false;
+  FOR_BB_INSNS(insn, bb) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    doOpt = true;
+    if (cgFunc->GetName() == "expand_shift" && insn->GetId() == 144) {
+      std::cout << "add logical shift!" << std::endl;
+    }
+    auto iter = candidates.find(insn);
+    if (iter != candidates.end()) {
+      /* during iteration, avoid repeated processing of insn, which may access wrong duInsnInfo of ssaVersion */
+      if (insn->HasProcessedRHS()) {
+        continue;
+      }
+      Operand *curDst = &insn->GetOperand(kInsnFirstOpnd);
+      ASSERT(curDst->IsRegister(), "must be");
+      auto *curDstOpnd = static_cast<RegOperand*>(curDst);
+      regno_t curRegNO = curDstOpnd->GetRegisterNumber();
+      if (!insn->IsRegDefined(curRegNO) || static_cast<RegOperand*>(curDstOpnd)->IsPhysicalRegister()) {
+        continue;
+      }
+      Insn *existInsn = *iter;
+      Operand *existDst = &existInsn->GetOperand(kInsnFirstOpnd);
+      ASSERT(existDst->IsRegister(), "must be");
+      auto *existDstOpnd = static_cast<RegOperand*>(existDst);
+      regno_t existRegNO = (existDstOpnd)->GetRegisterNumber();
+      if (!existInsn->IsRegDefined(existRegNO) || static_cast<RegOperand*>(existDstOpnd)->IsPhysicalRegister()) {
+        continue;
+      }
+      /* two insns have both def & use opnd */
+      if (insn->OpndIsUse(kInsnFirstOpnd) && existInsn->OpndIsUse(kInsnFirstOpnd)) {
+        curDstOpnd = insn->GetSSAImpDefOpnd();
+        existDstOpnd = existInsn->GetSSAImpDefOpnd();
+        CHECK_FATAL(curDstOpnd && existDstOpnd, "get ssa implicit def opnd failed");
+      }
+      VRegVersion *existDefVer = ssaInfo->FindSSAVersion(existDstOpnd->GetRegisterNumber());
+      VRegVersion *curDefVer = ssaInfo->FindSSAVersion(curDstOpnd->GetRegisterNumber());
+      CHECK_FATAL(existDefVer && curDefVer, "get ssa version failed");
+      isBothDefUse = IsBothDefUseCase(*existDefVer);
+      if (isBothDefUse) {
+        CheckBothDefAndUseChain(curDstOpnd, existDstOpnd);
+      }
+      if (!doOpt) {
+        continue;
+      }
+      CheckCondition(*existInsn, *insn);
+      if (!doOpt) {
+        continue;
+      }
+      if (CG_RCE_DUMP) {
+        Dump(existInsn, insn);
+      }
+      Optimize(*bb, *insn, *curDstOpnd, *existDstOpnd);
+      optimize = true;
+    } else {
+      (void)candidates.insert(insn);
+    }
+  }
+  return optimize;
+}
+
+MOperator AArch64RedundantComputeElim::GetNewMop(const RegOperand &curDstOpnd, const RegOperand &existDstOpnd) const {
+  MOperator newMop = MOP_undef;
+  bool is64Bit = (curDstOpnd.GetSize() == k64BitSize);
+  if (curDstOpnd.IsOfFloatOrSIMDClass() && existDstOpnd.IsOfIntClass()) {
+    newMop = (is64Bit ? MOP_xvmovdr : MOP_xvmovsr);
+  } else if (curDstOpnd.IsOfIntClass() && existDstOpnd.IsOfFloatOrSIMDClass()) {
+    newMop = (is64Bit ? MOP_xvmovrd : MOP_xvmovrs);
+  } else if (curDstOpnd.IsOfFloatOrSIMDClass() && existDstOpnd.IsOfFloatOrSIMDClass()) {
+    newMop = (is64Bit ? MOP_xvmovd : MOP_xvmovs);
+  } else {
+    newMop = (is64Bit ? MOP_xmovrr : MOP_wmovrr);
+  }
+  return newMop;
+}
+
+void AArch64RedundantComputeElim::Optimize(BB &curBB, Insn &curInsn,
+                                           RegOperand &curDstOpnd, RegOperand &existDstOpnd) const {
+  /*
+   * 1) useInsns of existVersion that have both def & use need replace ssaVersion first.
+   * 2) other cases can be replaced by mov.
+   */
+  if (isBothDefUse) {
+    VRegVersion *existDefVersion = ssaInfo->FindSSAVersion(existDstOpnd.GetRegisterNumber());
+    VRegVersion *curDefVersion = ssaInfo->FindSSAVersion(curDstOpnd.GetRegisterNumber());
+    CHECK_FATAL(existDefVersion && curDefVersion, "get ssa version failed");
+    ssaInfo->ReplaceAllUse(curDefVersion, existDefVersion);
+    curInsn.SetProcessRHS();
+  } else {
+    MOperator newMop = GetNewMop(curDstOpnd, existDstOpnd);
+    Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, curDstOpnd, existDstOpnd);
+    curBB.ReplaceInsn(curInsn, newInsn);
+    ssaInfo->ReplaceInsn(curInsn, newInsn);
+    newInsn.SetProcessRHS();
+  }
+}
+
+void AArch64RedundantComputeElim::DumpHash() const {
+  LogInfo::MapleLogger() << "\n";
+  LogInfo::MapleLogger() << ">>>>>> Insn Hash For " << cgFunc->GetName() << " <<<<<<\n";
+  FOR_ALL_BB(bb, cgFunc) {
+    g_hashSeed = 0;
+    if (bb->IsUnreachable()) {
+      continue;
+    }
+    cgFunc->DumpBBInfo(bb);
+    FOR_BB_INSNS(insn, bb) {
+      LogInfo::MapleLogger() << "[primal form] ";
+      insn->Dump();
+      if (insn->IsMachineInstruction()) {
+        LogInfo::MapleLogger() << "{ RHSHashCode: " << InsnRHSHash{}(insn) << " }\n";
+      }
+    }
+  }
+}
+} /* namespace maplebe */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_reaching.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_reaching.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..797eca00fdb4188c089276a6cf12b5c2bc8b8f92
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_reaching.cpp
@@ -0,0 +1,1259 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_reaching.h"
+#include "aarch64_cg.h"
+namespace maplebe {
+/* MCC_ClearLocalStackRef clear 1 stack slot, and MCC_DecRefResetPair clear 2 stack slot,
+ * the stack positins cleared are recorded in callInsn->clearStackOffset
+ */
+constexpr short kFirstClearMemIndex = 0;
+constexpr short kSecondClearMemIndex = 1;
+
+/* insert pseudo insn for parameters definition */
+void AArch64ReachingDefinition::InitStartGen() {
+  BB *bb = cgFunc->GetFirstBB();
+
+  /* Parameters should be define first. */
+  AArch64CallConvImpl parmLocator(cgFunc->GetBecommon());
+  CCLocInfo pLoc;
+  for (uint32 i = 0; i < cgFunc->GetFunction().GetFormalCount(); ++i) {
+    MIRType *type = cgFunc->GetFunction().GetNthParamType(i);
+    (void)parmLocator.LocateNextParm(*type, pLoc, i == 0, &cgFunc->GetFunction());
+    if (pLoc.reg0 == 0) {
+      /* If is a large frame, parameter addressing mode is based vreg:Vra. */
+      continue;
+    }
+
+    uint64 symSize = cgFunc->GetBecommon().GetTypeSize(type->GetTypeIndex());
+    if ((cgFunc->GetMirModule().GetSrcLang() == kSrcLangC) && (symSize > k8ByteSize)) {
+      /* For C structure passing in one or two registers. */
+      symSize = k8ByteSize;
+    }
+    RegType regType = (pLoc.reg0 < V0) ? kRegTyInt : kRegTyFloat;
+    uint32 srcBitSize = ((symSize < k4ByteSize) ? k4ByteSize : symSize) * kBitsPerByte;
+
+    MOperator mOp;
+    if (regType == kRegTyInt) {
+      if (srcBitSize <= k32BitSize) {
+        mOp = MOP_pseudo_param_def_w;
+      } else {
+        mOp = MOP_pseudo_param_def_x;
+      }
+    } else {
+      if (srcBitSize <= k32BitSize) {
+        mOp = MOP_pseudo_param_def_s;
+      } else {
+        mOp = MOP_pseudo_param_def_d;
+      }
+    }
+
+    AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+
+    RegOperand &regOpnd = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(
+        static_cast<AArch64reg>(pLoc.reg0), srcBitSize, regType);
+    Insn &pseudoInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, regOpnd);
+    bb->InsertInsnBegin(pseudoInsn);
+    pseudoInsns.emplace_back(&pseudoInsn);
+    if (pLoc.reg1 > 0) {
+      RegOperand &regOpnd1 = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(
+          static_cast<AArch64reg>(pLoc.reg1), srcBitSize, regType);
+      Insn &pseudoInsn1 = cgFunc->GetInsnBuilder()->BuildInsn(mOp, regOpnd1);
+      bb->InsertInsnBegin(pseudoInsn1);
+      pseudoInsns.emplace_back(&pseudoInsn1);
+    }
+    if (pLoc.reg2 > 0) {
+      RegOperand &regOpnd2 = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(
+          static_cast<AArch64reg>(pLoc.reg2), srcBitSize, regType);
+      Insn &pseudoInsn1 = cgFunc->GetInsnBuilder()->BuildInsn(mOp, regOpnd2);
+      bb->InsertInsnBegin(pseudoInsn1);
+      pseudoInsns.emplace_back(&pseudoInsn1);
+    }
+    if (pLoc.reg3 > 0) {
+      RegOperand &regOpnd3 = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(
+          static_cast<AArch64reg>(pLoc.reg3), srcBitSize, regType);
+      Insn &pseudoInsn1 = cgFunc->GetInsnBuilder()->BuildInsn(mOp, regOpnd3);
+      bb->InsertInsnBegin(pseudoInsn1);
+      pseudoInsns.emplace_back(&pseudoInsn1);
+    }
+
+    {
+      /*
+       * define memory address since store param may be transfered to stp and which with the short offset range.
+       *  we can not get the correct definition before RA.
+       *  example:
+       *   add  x8, sp, #712
+       *   stp  x0, x1, [x8]    // store param: _this Reg40_R313644
+       *   stp  x2, x3, [x8,#16]    // store param: Reg41_R333743 Reg42_R333622
+       *   stp  x4, x5, [x8,#32]    // store param: Reg43_R401297 Reg44_R313834
+       *   str  x7, [x8,#48]    // store param: Reg46_R401297
+       */
+      MIRSymbol *sym = cgFunc->GetFunction().GetFormal(i);
+      if (!sym->IsPreg()) {
+        MIRSymbol *firstSym = cgFunc->GetFunction().GetFormal(i);
+        const AArch64SymbolAlloc *firstSymLoc =
+            static_cast<AArch64SymbolAlloc*>(cgFunc->GetMemlayout()->GetSymAllocInfo(firstSym->GetStIndex()));
+        int32 stOffset = cgFunc->GetBaseOffset(*firstSymLoc);
+        MIRType *firstType = cgFunc->GetFunction().GetNthParamType(i);
+        uint32 firstSymSize = cgFunc->GetBecommon().GetTypeSize(firstType->GetTypeIndex());
+        uint32 firstStackSize = firstSymSize < k4ByteSize ? k4ByteSize : firstSymSize;
+
+        MemOperand *memOpnd = aarchCGFunc->CreateStackMemOpnd(RFP, stOffset, firstStackSize * kBitsPerByte);
+        MOperator mopTemp = firstStackSize <= k4ByteSize ? MOP_pseudo_param_store_w : MOP_pseudo_param_store_x;
+        Insn &pseudoInsnTemp = cgFunc->GetInsnBuilder()->BuildInsn(mopTemp, *memOpnd);
+        bb->InsertInsnBegin(pseudoInsnTemp);
+        pseudoInsns.emplace_back(&pseudoInsnTemp);
+      }
+    }
+  }
+
+  /* if function has "bl  MCC_InitializeLocalStackRef", should define corresponding memory. */
+  AArch64CGFunc *a64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+
+  for (uint32 i = 0; i < a64CGFunc->GetRefCount(); ++i) {
+    MemOperand *memOpnd = a64CGFunc->CreateStackMemOpnd(
+        RFP, a64CGFunc->GetBeginOffset() + static_cast<int32>(i * k8BitSize), k64BitSize);
+    Insn &pseudoInsn = cgFunc->GetInsnBuilder()->BuildInsn(MOP_pseudo_ref_init_x, *memOpnd);
+
+    bb->InsertInsnBegin(pseudoInsn);
+    pseudoInsns.emplace_back(&pseudoInsn);
+  }
+}
+
+/* insert pseudoInsns for ehBB, R0 and R1 are defined in pseudoInsns */
+void AArch64ReachingDefinition::InitEhDefine(BB &bb) {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+
+  /* Insert MOP_pseudo_eh_def_x R1. */
+  RegOperand &regOpnd1 = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(R1, k64BitSize, kRegTyInt);
+  Insn &pseudoInsn = cgFunc->GetInsnBuilder()->BuildInsn(MOP_pseudo_eh_def_x, regOpnd1);
+  bb.InsertInsnBegin(pseudoInsn);
+  pseudoInsns.emplace_back(&pseudoInsn);
+
+  /* insert MOP_pseudo_eh_def_x R0. */
+  RegOperand &regOpnd2 = aarchCGFunc->GetOrCreatePhysicalRegisterOperand(R0, k64BitSize, kRegTyInt);
+  Insn &newPseudoInsn = cgFunc->GetInsnBuilder()->BuildInsn(MOP_pseudo_eh_def_x, regOpnd2);
+  bb.InsertInsnBegin(newPseudoInsn);
+  pseudoInsns.emplace_back(&newPseudoInsn);
+}
+
+/* insert pseudoInsns for return value R0/V0 */
+void AArch64ReachingDefinition::AddRetPseudoInsn(BB &bb) {
+  AArch64reg regNO = static_cast<AArch64CGFunc*>(cgFunc)->GetReturnRegisterNumber();
+  if (regNO == kInvalidRegNO) {
+    return;
+  }
+
+  if (regNO == R0) {
+    RegOperand &regOpnd =
+        static_cast<AArch64CGFunc*>(cgFunc)->GetOrCreatePhysicalRegisterOperand(regNO, k64BitSize, kRegTyInt);
+    Insn &retInsn = cgFunc->GetInsnBuilder()->BuildInsn(MOP_pseudo_ret_int, regOpnd);
+    bb.AppendInsn(retInsn);
+    pseudoInsns.emplace_back(&retInsn);
+  } else if (regNO == V0) {
+    RegOperand &regOpnd =
+        static_cast<AArch64CGFunc*>(cgFunc)->GetOrCreatePhysicalRegisterOperand(regNO, k64BitSize, kRegTyFloat);
+    Insn &retInsn = cgFunc->GetInsnBuilder()->BuildInsn(MOP_pseudo_ret_float, regOpnd);
+    bb.AppendInsn(retInsn);
+    pseudoInsns.emplace_back(&retInsn);
+  }
+}
+
+void AArch64ReachingDefinition::AddRetPseudoInsns() {
+  uint32 exitBBSize = cgFunc->GetExitBBsVec().size();
+  if (exitBBSize == 0) {
+    if (cgFunc->GetCleanupBB() != nullptr && cgFunc->GetCleanupBB()->GetPrev() != nullptr) {
+      AddRetPseudoInsn(*cgFunc->GetCleanupBB()->GetPrev());
+    } else {
+      AddRetPseudoInsn(*cgFunc->GetLastBB()->GetPrev());
+    }
+  } else {
+    for (uint32 i = 0; i < exitBBSize; ++i) {
+      AddRetPseudoInsn(*cgFunc->GetExitBB(i));
+    }
+  }
+}
+
+void AArch64ReachingDefinition::GenAllAsmDefRegs(BB &bb, Insn &insn, uint32 index) {
+  for (auto &reg : static_cast<const ListOperand&>(insn.GetOperand(index)).GetOperands()) {
+    regGen[bb.GetId()]->SetBit(static_cast<RegOperand *>(reg)->GetRegisterNumber());
+  }
+}
+
+void AArch64ReachingDefinition::GenAllAsmUseRegs(BB &bb, Insn &insn, uint32 index) {
+  for (auto &reg : static_cast<const ListOperand&>(insn.GetOperand(index)).GetOperands()) {
+    regUse[bb.GetId()]->SetBit(static_cast<RegOperand *>(reg)->GetRegisterNumber());
+  }
+}
+
+/* all caller saved register are modified by call insn */
+void AArch64ReachingDefinition::GenAllCallerSavedRegs(BB &bb, Insn &insn) {
+  if (CGOptions::DoIPARA()) {
+    std::set<regno_t> callerSaveRegs;
+    cgFunc->GetRealCallerSaveRegs(insn, callerSaveRegs);
+    for (auto i : callerSaveRegs) {
+      regGen[bb.GetId()]->SetBit(i);
+    }
+  } else {
+    for (uint32 i = R0; i <= V31; ++i) {
+      if (AArch64Abi::IsCallerSaveReg(static_cast<AArch64reg>(i))) {
+        regGen[bb.GetId()]->SetBit(i);
+      }
+    }
+  }
+}
+
+/* reg killed killed by call insn */
+bool AArch64ReachingDefinition::IsRegKilledByCallInsn(const Insn &insn, regno_t regNO) const {
+  if (CGOptions::DoIPARA()) {
+    std::set<regno_t> callerSaveRegs;
+    cgFunc->GetRealCallerSaveRegs(insn, callerSaveRegs);
+    return callerSaveRegs.find(regNO) != callerSaveRegs.end();
+  } else {
+    return AArch64Abi::IsCallerSaveReg(static_cast<AArch64reg>(regNO));
+  }
+}
+
+bool AArch64ReachingDefinition::KilledByCallBetweenInsnInSameBB(const Insn &startInsn,
+    const Insn &endInsn, regno_t regNO) const {
+  ASSERT(startInsn.GetBB() == endInsn.GetBB(), "two insns must be in same bb");
+  if (CGOptions::DoIPARA()) {
+    for (const Insn *insn = &startInsn; insn != endInsn.GetNext(); insn = insn->GetNext()) {
+      if (insn->IsMachineInstruction() && insn->IsCall() && IsRegKilledByCallInsn(*insn, regNO)) {
+        return true;
+      }
+    }
+    return false;
+  } else {
+    return HasCallBetweenInsnInSameBB(startInsn, endInsn);
+  }
+}
+/*
+ * find definition for register between startInsn and endInsn.
+ * startInsn and endInsn is not in same BB
+ * make sure that in path between startBB and endBB there is no redefine.
+ */
+std::vector<Insn*> AArch64ReachingDefinition::FindRegDefBetweenInsnGlobal(
+    uint32 regNO, Insn *startInsn, Insn *endInsn) const {
+  ASSERT(startInsn->GetBB() != endInsn->GetBB(), "call FindRegDefBetweenInsn please");
+  std::vector<Insn *> defInsnVec;
+  if (startInsn == nullptr || endInsn == nullptr) {
+    return defInsnVec;
+  }
+  /* check startBB */
+  BB *startBB = startInsn->GetBB();
+  std::vector<Insn *> startBBdefInsnVec = FindRegDefBetweenInsn(regNO, startInsn->GetNext(), startBB->GetLastInsn());
+  if (startBBdefInsnVec.size() == 1) {
+    defInsnVec.emplace_back(*startBBdefInsnVec.begin());
+  }
+  if (startBBdefInsnVec.size() > 1 ||
+      (startBBdefInsnVec.empty() && regOut[startBB->GetId()]->TestBit(regNO))) {
+    defInsnVec.emplace_back(startInsn);
+    defInsnVec.emplace_back(endInsn);
+    return defInsnVec;
+  }
+  if (IsCallerSavedReg(regNO) && startInsn->GetNext() != nullptr &&
+      KilledByCallBetweenInsnInSameBB(*startInsn->GetNext(), *startBB->GetLastInsn(), regNO)) {
+    defInsnVec.emplace_back(startInsn);
+    defInsnVec.emplace_back(endInsn);
+    return defInsnVec;
+  }
+  /* check endBB */
+  BB *endBB = endInsn->GetBB();
+  std::vector<Insn *> endBBdefInsnVec = FindRegDefBetweenInsn(regNO, endBB->GetFirstInsn(), endInsn->GetPrev());
+  if (endBBdefInsnVec.size() == 1) {
+    defInsnVec.emplace_back(*endBBdefInsnVec.begin());
+  }
+  if (endBBdefInsnVec.size() > 1 || (endBBdefInsnVec.empty() && regIn[endBB->GetId()]->TestBit(regNO))) {
+    defInsnVec.emplace_back(startInsn);
+    defInsnVec.emplace_back(endInsn);
+    return defInsnVec;
+  }
+  if (IsCallerSavedReg(regNO) && endInsn->GetPrev() != nullptr &&
+      KilledByCallBetweenInsnInSameBB(*endBB->GetFirstInsn(), *endInsn->GetPrev(), regNO)) {
+    defInsnVec.emplace_back(startInsn);
+    defInsnVec.emplace_back(endInsn);
+    return defInsnVec;
+  }
+  InsnSet defInsnSet;
+  std::vector<VisitStatus> visitedBB(kMaxBBNum, kNotVisited);
+  visitedBB[endBB->GetId()] = kNormalVisited;
+  visitedBB[startBB->GetId()]  = kNormalVisited;
+  std::list<bool> pathStatus;
+  if (DFSFindRegInfoBetweenBB(*startBB, *endBB, regNO, visitedBB, pathStatus, kDumpRegIn)) {
+    defInsnVec.emplace_back(endInsn);
+  }
+  return defInsnVec;
+}
+
+static bool IsRegInAsmList(Insn *insn, uint32 index, uint32 regNO, InsnSet &insnSet) {
+  for (auto &reg : static_cast<const ListOperand&>(insn->GetOperand(index)).GetOperands()) {
+    if (static_cast<RegOperand *>(reg)->GetRegisterNumber() == regNO) {
+      insnSet.insert(insn);
+      return true;
+    }
+  }
+  return false;
+}
+
+void AArch64ReachingDefinition::FindRegDefInBB(uint32 regNO, BB &bb, InsnSet &defInsnSet) const {
+  if (!regGen[bb.GetId()]->TestBit(regNO)) {
+    return;
+  }
+
+  FOR_BB_INSNS(insn, (&bb)) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+
+    if (insn->GetMachineOpcode() == MOP_asm) {
+      if (IsRegInAsmList(insn, kAsmOutputListOpnd, regNO, defInsnSet)) {
+        continue;
+      }
+      IsRegInAsmList(insn, kAsmClobberListOpnd, regNO, defInsnSet);
+      continue;
+    }
+    if (insn->IsCall() && IsRegKilledByCallInsn(*insn, regNO)) {
+      (void)defInsnSet.insert(insn);
+      continue;
+    }
+    if (insn->IsRegDefined(regNO)) {
+      (void)defInsnSet.insert(insn);
+    }
+  }
+}
+
+/* check whether call insn changed the stack status or not. */
+bool AArch64ReachingDefinition::CallInsnClearDesignateStackRef(const Insn &callInsn, int64 offset) const {
+  return offset == callInsn.GetClearStackOffset(kFirstClearMemIndex) ||
+         offset == callInsn.GetClearStackOffset(kSecondClearMemIndex);
+}
+
+/*
+ * find definition for stack memory operand between startInsn and endInsn.
+ * startInsn and endInsn must be in same BB and startInsn and endInsn are included
+ * special case:
+ *   MCC_ClearLocalStackRef clear designate stack position, the designate stack position is thought defined
+ *    for example:
+ *      add x0, x29, #24
+ *      bl MCC_ClearLocalStackRef
+ */
+std::vector<Insn*> AArch64ReachingDefinition::FindMemDefBetweenInsn(
+    uint32 offset, const Insn *startInsn, Insn *endInsn) const {
+  std::vector<Insn*> defInsnVec;
+  if (startInsn == nullptr || endInsn == nullptr) {
+    return defInsnVec;
+  }
+
+  ASSERT(startInsn->GetBB() == endInsn->GetBB(), "two insns must be in a same BB");
+  ASSERT(endInsn->GetId() >= startInsn->GetId(), "two insns must be in a same BB");
+  if (!memGen[startInsn->GetBB()->GetId()]->TestBit(offset / kMemZoomSize)) {
+    return defInsnVec;
+  }
+
+  for (Insn *insn = endInsn; insn != nullptr && insn != startInsn->GetPrev(); insn = insn->GetPrev()) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+
+    if (insn->GetMachineOpcode() == MOP_asm) {
+      if (insn->IsAsmModMem()) {
+        defInsnVec.emplace_back(insn);
+        return defInsnVec;
+      }
+      continue;
+    }
+
+    if (insn->IsCall()) {
+      if (CallInsnClearDesignateStackRef(*insn, offset)) {
+        defInsnVec.emplace_back(insn);
+        return defInsnVec;
+      }
+      continue;
+    }
+
+    if (!(insn->IsStore() || AArch64isa::IsPseudoInstruction(insn->GetMachineOpcode()))) {
+      continue;
+    }
+
+    uint32 opndNum = insn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = insn->GetOperand(i);
+
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        RegOperand *base = memOpnd.GetBaseRegister();
+        RegOperand *index = memOpnd.GetIndexRegister();
+
+        if (base == nullptr || !IsFrameReg(*base) || index != nullptr) {
+          break;
+        }
+
+        if (!insn->IsSpillInsn() && cgFunc->IsAfterRegAlloc()) {
+          break;
+        }
+
+        ASSERT(memOpnd.GetOffsetImmediate() != nullptr, "offset must be a immediate value");
+        int64 memOffset = memOpnd.GetOffsetImmediate()->GetOffsetValue();
+        if (memOffset < 0) {
+          memOffset = stackSize + memOffset;
+        }
+        if ((offset == memOffset) ||
+            (insn->IsStorePair() && offset == memOffset + GetEachMemSizeOfPair(insn->GetMachineOpcode()))) {
+          defInsnVec.emplace_back(insn);
+          return defInsnVec;
+        }
+      }
+    }
+  }
+  return defInsnVec;
+}
+
+void AArch64ReachingDefinition::FindMemDefInBB(uint32 offset, BB &bb, InsnSet &defInsnSet) const {
+  if (!memGen[bb.GetId()]->TestBit(offset / kMemZoomSize)) {
+    return;
+  }
+
+  FOR_BB_INSNS(insn, (&bb)) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+
+    if (insn->IsCall()) {
+      if (insn->GetMachineOpcode() == MOP_asm) {
+        if (insn->IsAsmModMem()) {
+          (void)defInsnSet.insert(insn);
+        }
+        continue;
+      }
+      if (CallInsnClearDesignateStackRef(*insn, offset)) {
+        (void)defInsnSet.insert(insn);
+      }
+      continue;
+    }
+
+    if (!(insn->IsStore() || AArch64isa::IsPseudoInstruction(insn->GetMachineOpcode()))) {
+      continue;
+    }
+
+    uint32 opndNum = insn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = insn->GetOperand(i);
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        RegOperand *base = memOpnd.GetBaseRegister();
+        RegOperand *index = memOpnd.GetIndexRegister();
+
+        if (base == nullptr || !IsFrameReg(*base) || index != nullptr) {
+          break;
+        }
+
+        ASSERT(memOpnd.GetOffsetImmediate() != nullptr, "offset must be a immediate value");
+        int64 memOffset = memOpnd.GetOffsetImmediate()->GetOffsetValue();
+        if (memOffset < 0) {
+          memOffset = stackSize + memOffset;
+        }
+        if (offset == memOffset) {
+          (void)defInsnSet.insert(insn);
+          break;
+        }
+        if (insn->IsStorePair() && offset == memOffset + GetEachMemSizeOfPair(insn->GetMachineOpcode())) {
+          (void)defInsnSet.insert(insn);
+          break;
+        }
+      }
+    }
+  }
+}
+
+/*
+ * find defininition for register Iteratively.
+ *  input:
+ *    startBB: find definnition starting from startBB
+ *    regNO: the No of register to be find
+ *    visitedBB: record these visited BB
+ *    defInsnSet: insn defining register is saved in this set
+ */
+void AArch64ReachingDefinition::DFSFindDefForRegOpnd(const BB &startBB, uint32 regNO,
+                                                     std::vector<VisitStatus> &visitedBB, InsnSet &defInsnSet) const {
+  std::vector<Insn*> defInsnVec;
+  for (auto predBB : startBB.GetPreds()) {
+    if (visitedBB[predBB->GetId()] != kNotVisited) {
+      continue;
+    }
+    visitedBB[predBB->GetId()] = kNormalVisited;
+    if (regGen[predBB->GetId()]->TestBit(regNO) || (regNO == kRFLAG && predBB->HasCall())) {
+      defInsnVec.clear();
+      defInsnVec = FindRegDefBetweenInsn(regNO, predBB->GetFirstInsn(), predBB->GetLastInsn());
+      defInsnSet.insert(defInsnVec.cbegin(), defInsnVec.cend());
+    } else if (regIn[predBB->GetId()]->TestBit(regNO)) {
+      DFSFindDefForRegOpnd(*predBB, regNO, visitedBB, defInsnSet);
+    }
+  }
+
+  for (auto predEhBB : startBB.GetEhPreds()) {
+    if (visitedBB[predEhBB->GetId()] == kEHVisited) {
+      continue;
+    }
+    visitedBB[predEhBB->GetId()] = kEHVisited;
+    if (regGen[predEhBB->GetId()]->TestBit(regNO) || (regNO == kRFLAG && predEhBB->HasCall())) {
+      FindRegDefInBB(regNO, *predEhBB, defInsnSet);
+    }
+
+    if (regIn[predEhBB->GetId()]->TestBit(regNO)) {
+      DFSFindDefForRegOpnd(*predEhBB, regNO, visitedBB, defInsnSet);
+    }
+  }
+}
+
+/*
+ * find defininition for stack memory iteratively.
+ *  input:
+ *    startBB: find definnition starting from startBB
+ *    offset: the offset of memory to be find
+ *    visitedBB: record these visited BB
+ *    defInsnSet: insn defining register is saved in this set
+ */
+void AArch64ReachingDefinition::DFSFindDefForMemOpnd(const BB &startBB, uint32 offset,
+                                                     std::vector<VisitStatus> &visitedBB, InsnSet &defInsnSet) const {
+  std::vector<Insn*> defInsnVec;
+  for (auto predBB : startBB.GetPreds()) {
+    if (visitedBB[predBB->GetId()] != kNotVisited) {
+      continue;
+    }
+    visitedBB[predBB->GetId()] = kNormalVisited;
+    if (memGen[predBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+      defInsnVec.clear();
+      defInsnVec = FindMemDefBetweenInsn(offset, predBB->GetFirstInsn(), predBB->GetLastInsn());
+      ASSERT(!defInsnVec.empty(), "opnd must be defined in this bb");
+      defInsnSet.insert(defInsnVec.cbegin(), defInsnVec.cend());
+    } else if (memIn[predBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+      DFSFindDefForMemOpnd(*predBB, offset, visitedBB, defInsnSet);
+    }
+  }
+
+  for (auto predEhBB : startBB.GetEhPreds()) {
+    if (visitedBB[predEhBB->GetId()] == kEHVisited) {
+      continue;
+    }
+    visitedBB[predEhBB->GetId()] = kEHVisited;
+    if (memGen[predEhBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+      FindMemDefInBB(offset, *predEhBB, defInsnSet);
+    }
+
+    if (memIn[predEhBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+      DFSFindDefForMemOpnd(*predEhBB, offset, visitedBB, defInsnSet);
+    }
+  }
+}
+
+/*
+ * find defininition for register.
+ *  input:
+ *    insn: the insn in which register is used
+ *    indexOrRegNO: the index of register in insn or the No of register to be find
+ *    isRegNO: if indexOrRegNO is index, this argument is false, else is true
+ *  return:
+ *    the set of definition insns for register
+ */
+InsnSet AArch64ReachingDefinition::FindDefForRegOpnd(Insn &insn, uint32 indexOrRegNO, bool isRegNO) const {
+  uint32 regNO = indexOrRegNO;
+  if (!isRegNO) {
+    Operand &opnd = insn.GetOperand(indexOrRegNO);
+    auto &regOpnd = static_cast<RegOperand&>(opnd);
+    regNO = regOpnd.GetRegisterNumber();
+  }
+
+  std::vector<Insn*> defInsnVec;
+  if (regGen[insn.GetBB()->GetId()]->TestBit(regNO)) {
+    defInsnVec = FindRegDefBetweenInsn(regNO, insn.GetBB()->GetFirstInsn(), insn.GetPrev());
+  }
+  InsnSet defInsnSet;
+  if (!defInsnVec.empty()) {
+    defInsnSet.insert(defInsnVec.cbegin(), defInsnVec.cend());
+    return defInsnSet;
+  }
+  std::vector<VisitStatus> visitedBB(kMaxBBNum, kNotVisited);
+  if (insn.GetBB()->IsCleanup()) {
+    DFSFindDefForRegOpnd(*insn.GetBB(), regNO, visitedBB, defInsnSet);
+    if (defInsnSet.empty()) {
+      FOR_ALL_BB(bb, cgFunc) {
+        if (bb->IsCleanup()) {
+          continue;
+        }
+        if (regGen[bb->GetId()]->TestBit(regNO)) {
+          FindRegDefInBB(regNO, *bb, defInsnSet);
+        }
+      }
+    }
+  } else {
+    DFSFindDefForRegOpnd(*insn.GetBB(), regNO, visitedBB, defInsnSet);
+  }
+  return defInsnSet;
+}
+
+bool AArch64ReachingDefinition::FindRegUseBetweenInsnGlobal(uint32 regNO, Insn *startInsn, Insn *endInsn,
+                                                            BB* movBB) const {
+  if (startInsn == nullptr || endInsn == nullptr) {
+    return false;
+  }
+  if (startInsn->GetBB() == endInsn->GetBB()) {
+    if (startInsn->GetNextMachineInsn() == endInsn) {
+      return false;
+    } else {
+      return FindRegUsingBetweenInsn(regNO, startInsn->GetNextMachineInsn(), endInsn->GetPreviousMachineInsn());
+    }
+  } else {
+    /* check Start BB */
+    BB* startBB = startInsn->GetBB();
+    if (FindRegUsingBetweenInsn(regNO, startInsn->GetNextMachineInsn(), startBB->GetLastInsn())) {
+      return true;
+    }
+    /* check End BB */
+    BB *endBB = endInsn->GetBB();
+    if (FindRegUsingBetweenInsn(regNO, endBB->GetFirstInsn(), endInsn->GetPreviousMachineInsn())) {
+      return true;
+    }
+    /* Global : startBB cannot dominate BB which it doesn't dominate before */
+    if (startBB == movBB) {
+      return false; /* it will not change dominate */
+    }
+    std::vector<VisitStatus> visitedBB(kMaxBBNum, kNotVisited);
+    visitedBB[movBB->GetId()] = kNormalVisited;
+    visitedBB[startBB->GetId()]  = kNormalVisited;
+    if (DFSFindRegDomianBetweenBB(*startBB, regNO, visitedBB)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AArch64ReachingDefinition::HasRegDefBetweenInsnGlobal(uint32 regNO, Insn &startInsn, Insn &endInsn) const {
+  CHECK_FATAL((startInsn.GetBB() != endInsn.GetBB()), "Is same BB!");
+  /* check Start BB */
+  BB* startBB = startInsn.GetBB();
+  auto startInsnSet = FindRegDefBetweenInsn(regNO, startInsn.GetNext(), startBB->GetLastInsn());
+  if (!startInsnSet.empty()) {
+    return true;
+  }
+  /* check End BB */
+  BB *endBB = endInsn.GetBB();
+  auto endInsnSet = FindRegDefBetweenInsn(regNO, endBB->GetFirstInsn(), endInsn.GetPrev());
+  if (!endInsnSet.empty()) {
+    return true;
+  }
+  if (!startBB->GetSuccs().empty()) {
+    for (auto *succ : startBB->GetSuccs()) {
+      if (succ == endBB) {
+        return (!startInsnSet.empty() && !endInsnSet.empty());
+      }
+    }
+  }
+  /* check bb Between start and end */
+  std::vector<VisitStatus> visitedBB(kMaxBBNum, kNotVisited);
+  visitedBB[startBB->GetId()] = kNormalVisited;
+  visitedBB[endBB->GetId()] = kNormalVisited;
+  return DFSFindRegDefBetweenBB(*startBB, *endBB, regNO, visitedBB);
+}
+
+bool AArch64ReachingDefinition::DFSFindRegDefBetweenBB(const BB &startBB, const BB &endBB, uint32 regNO,
+                                                       std::vector<VisitStatus> &visitedBB) const {
+  if (&startBB == &endBB) {
+    return false;
+  }
+  for (auto succBB : startBB.GetSuccs()) {
+    if (visitedBB[succBB->GetId()] != kNotVisited) {
+      continue;
+    }
+    visitedBB[succBB->GetId()] = kNormalVisited;
+    if (regGen[succBB->GetId()]->TestBit(regNO)) {
+      return true;
+    }
+    if (DFSFindRegDefBetweenBB(*succBB, endBB, regNO, visitedBB)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AArch64ReachingDefinition::DFSFindRegDomianBetweenBB(const BB startBB, uint32 regNO,
+                                                          std::vector<VisitStatus> &visitedBB) const {
+  for (auto succBB : startBB.GetSuccs()) {
+    if (visitedBB[succBB->GetId()] != kNotVisited) {
+      continue;
+    }
+    visitedBB[succBB->GetId()] = kNormalVisited;
+    if (regIn[succBB->GetId()]->TestBit(regNO)) {
+      return true;
+    } else if (regGen[succBB->GetId()]->TestBit(regNO)) {
+      continue;
+    }
+    if (DFSFindRegDomianBetweenBB(*succBB, regNO, visitedBB)) {
+      return true;
+    }
+  }
+  CHECK_FATAL(startBB.GetEhSuccs().empty(), "C Module have no eh");
+  return false;
+}
+
+bool AArch64ReachingDefinition::DFSFindRegInfoBetweenBB(const BB startBB, const BB &endBB, uint32 regNO,
+                                                        std::vector<VisitStatus> &visitedBB,
+                                                        std::list<bool> &pathStatus, DumpType infoType) const {
+  for (auto succBB : startBB.GetSuccs()) {
+    if (succBB == &endBB) {
+      for (auto &status : as_const(pathStatus)) {
+        if (!status) {
+          return true;
+        }
+      }
+      continue;
+    }
+    if (visitedBB[succBB->GetId()] != kNotVisited) {
+      continue;
+    }
+    visitedBB[succBB->GetId()] = kNormalVisited;
+    /* path is no clean check regInfo */
+    bool isPathClean = true;
+    switch (infoType) {
+      case kDumpRegUse: {
+        isPathClean = !regUse[succBB->GetId()]->TestBit(regNO);
+        break;
+      }
+      case kDumpRegGen: {
+        isPathClean = !regGen[succBB->GetId()]->TestBit(regNO);
+        break;
+      }
+      case kDumpRegIn: {
+        isPathClean =  !(regIn[succBB->GetId()]->TestBit(regNO) || regGen[succBB->GetId()]->TestBit(regNO));
+        break;
+      }
+      default:
+        CHECK_FATAL(false, "NIY");
+    }
+    pathStatus.emplace_back(isPathClean);
+    if (DFSFindRegInfoBetweenBB(*succBB, endBB, regNO, visitedBB, pathStatus, infoType)) {
+      return true;
+    }
+    pathStatus.pop_back();
+  }
+  CHECK_FATAL(startBB.GetEhSuccs().empty(), "C Module have no eh");
+  return false;
+}
+
+bool AArch64ReachingDefinition::FindRegUsingBetweenInsn(uint32 regNO, Insn *startInsn, const Insn *endInsn) const {
+  if (startInsn == nullptr || endInsn == nullptr) {
+    return false;
+  }
+
+  ASSERT(startInsn->GetBB() == endInsn->GetBB(), "two insns must be in a same BB");
+  for (Insn *insn = startInsn; insn != nullptr && insn != endInsn->GetNext(); insn = insn->GetNext()) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    if (insn->GetMachineOpcode() == MOP_asm) {
+      InsnSet temp;
+      if (IsRegInAsmList(insn, kAsmInputListOpnd, regNO, temp) ||
+          IsRegInAsmList(insn, kAsmOutputListOpnd, regNO, temp)) {
+        return true;
+      }
+      continue;
+    }
+    const InsnDesc *md = insn->GetDesc();
+    uint32 opndNum = insn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = insn->GetOperand(i);
+      if (opnd.IsList()) {
+        auto &listOpnd = static_cast<const ListOperand&>(opnd);
+        for (auto &listElem : listOpnd.GetOperands()) {
+          RegOperand *regOpnd = static_cast<RegOperand*>(listElem);
+          ASSERT(regOpnd != nullptr, "parameter operand must be RegOperand");
+          if (regNO == regOpnd->GetRegisterNumber()) {
+            return true;
+          }
+        }
+        continue;
+      }
+
+      auto *regProp = md->opndMD[i];
+      if (!regProp->IsUse() && !opnd.IsMemoryAccessOperand()) {
+        continue;
+      }
+
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        RegOperand *base = memOpnd.GetBaseRegister();
+        RegOperand *index = memOpnd.GetIndexRegister();
+        if ((base != nullptr && base->GetRegisterNumber() == regNO) ||
+            (index != nullptr && index->GetRegisterNumber() == regNO)) {
+          return true;
+        }
+      } else if (opnd.IsConditionCode()) {
+        Operand &rflagOpnd = cgFunc->GetOrCreateRflag();
+        RegOperand &rflagReg = static_cast<RegOperand&>(rflagOpnd);
+        if (rflagReg.GetRegisterNumber() == regNO) {
+          return true;
+        }
+      } else if (opnd.IsRegister() && (static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/*
+ * find insn using register between startInsn and endInsn.
+ * startInsn and endInsn must be in same BB and startInsn and endInsn are included
+ */
+bool AArch64ReachingDefinition::FindRegUseBetweenInsn(uint32 regNO, Insn *startInsn, Insn *endInsn,
+                                                      InsnSet &regUseInsnSet) const {
+  bool findFinish = false;
+  if (startInsn == nullptr || endInsn == nullptr) {
+    return findFinish;
+  }
+
+  ASSERT(startInsn->GetBB() == endInsn->GetBB(), "two insns must be in a same BB");
+  for (Insn *insn = startInsn; insn != nullptr && insn != endInsn->GetNext(); insn = insn->GetNext()) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    if (insn->GetMachineOpcode() == MOP_asm) {
+      IsRegInAsmList(insn, kAsmInputListOpnd, regNO, regUseInsnSet);
+      if (IsRegInAsmList(insn, kAsmOutputListOpnd, regNO, regUseInsnSet)) {
+        break;
+      }
+      continue;
+    }
+    /* if insn is call and regNO is caller-saved register, then regNO will not be used later */
+    if (insn->IsCall() && IsRegKilledByCallInsn(*insn, regNO)) {
+      findFinish = true;
+    }
+
+    const InsnDesc *md = insn->GetDesc();
+    uint32 opndNum = insn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = insn->GetOperand(i);
+      if (opnd.IsList()) {
+        auto &listOpnd = static_cast<const ListOperand&>(opnd);
+        for (auto &listElem : listOpnd.GetOperands()) {
+          auto *regOpnd = static_cast<const RegOperand*>(listElem);
+          ASSERT(regOpnd != nullptr, "parameter operand must be RegOperand");
+          if (regNO == regOpnd->GetRegisterNumber()) {
+            (void)regUseInsnSet.insert(insn);
+          }
+        }
+        continue;
+      } else if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        RegOperand *baseOpnd = memOpnd.GetBaseRegister();
+        if (baseOpnd != nullptr &&
+            (memOpnd.GetAddrMode() == MemOperand::kAddrModeBOi) &&
+            (memOpnd.IsPostIndexed() || memOpnd.IsPreIndexed()) &&
+            baseOpnd->GetRegisterNumber() == regNO) {
+          findFinish = true;
+        }
+      }
+
+      auto *regProp = md->opndMD[i];
+      if (regProp->IsDef() && opnd.IsRegister() &&
+          (static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO)) {
+        findFinish = true;
+      }
+
+      if (!regProp->IsUse() && !opnd.IsMemoryAccessOperand()) {
+        continue;
+      }
+
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        RegOperand *base = memOpnd.GetBaseRegister();
+        RegOperand *index = memOpnd.GetIndexRegister();
+        if ((base != nullptr && base->GetRegisterNumber() == regNO) ||
+            (index != nullptr && index->GetRegisterNumber() == regNO)) {
+          (void)regUseInsnSet.insert(insn);
+        }
+      } else if (opnd.IsConditionCode()) {
+        Operand &rflagOpnd = cgFunc->GetOrCreateRflag();
+        RegOperand &rflagReg = static_cast<RegOperand&>(rflagOpnd);
+        if (rflagReg.GetRegisterNumber() == regNO) {
+          (void)regUseInsnSet.insert(insn);
+        }
+      } else if (opnd.IsRegister() && (static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO)) {
+        (void)regUseInsnSet.insert(insn);
+      }
+    }
+
+    if (findFinish) {
+      break;
+    }
+  }
+  return findFinish;
+}
+
+/*
+ * find insn using stack memory operand between startInsn and endInsn.
+ * startInsn and endInsn must be in same BB and startInsn and endInsn are included
+ */
+bool AArch64ReachingDefinition::FindMemUseBetweenInsn(uint32 offset, Insn *startInsn, const Insn *endInsn,
+                                                      InsnSet &memUseInsnSet) const {
+  bool findFinish = false;
+  if (startInsn == nullptr || endInsn == nullptr) {
+    return findFinish;
+  }
+
+  ASSERT(startInsn->GetBB() == endInsn->GetBB(), "two insns must be in a same BB");
+  ASSERT(endInsn->GetId() >= startInsn->GetId(), "end ID must be greater than or equal to start ID");
+
+  for (Insn *insn = startInsn; insn != nullptr && insn != endInsn->GetNext(); insn = insn->GetNext()) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+
+    if (insn->IsCall()) {
+      if (insn->GetMachineOpcode() == MOP_asm) {
+        return true;
+      }
+      if (CallInsnClearDesignateStackRef(*insn, offset)) {
+        return true;
+      }
+      continue;
+    }
+
+    const InsnDesc *md = insn->GetDesc();
+    uint32 opndNum = insn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = insn->GetOperand(i);
+      if (!opnd.IsMemoryAccessOperand()) {
+        continue;
+      }
+
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      RegOperand *base = memOpnd.GetBaseRegister();
+      if (base == nullptr || !IsFrameReg(*base)) {
+        continue;
+      }
+
+      ASSERT(memOpnd.GetIndexRegister() == nullptr, "offset must not be Register for frame MemOperand");
+      ASSERT(memOpnd.GetOffsetImmediate() != nullptr, "offset must be a immediate value");
+      int64 memOffset = memOpnd.GetOffsetImmediate()->GetValue();
+      if (memOffset < 0) {
+        memOffset = stackSize + memOffset;
+      }
+
+      if (insn->IsStore() || AArch64isa::IsPseudoInstruction(insn->GetMachineOpcode())) {
+        if (memOffset == offset) {
+          findFinish = true;
+          continue;
+        }
+        if (insn->IsStorePair() && offset == memOffset + GetEachMemSizeOfPair(insn->GetMachineOpcode())) {
+          findFinish = true;
+          continue;
+        }
+      }
+
+      if (!md->opndMD[i]->IsUse()) {
+        continue;
+      }
+
+      if (offset == memOffset) {
+        (void)memUseInsnSet.insert(insn);
+      } else if (insn->IsLoadPair() && offset == memOffset + GetEachMemSizeOfPair(insn->GetMachineOpcode())) {
+        (void)memUseInsnSet.insert(insn);
+      }
+    }
+
+    if (findFinish) {
+      break;
+    }
+  }
+  return findFinish;
+}
+
+/* find all definition for stack memory operand insn.opnd[index] */
+InsnSet AArch64ReachingDefinition::FindDefForMemOpnd(Insn &insn, uint32 indexOrOffset, bool isOffset) const {
+  InsnSet defInsnSet;
+  int64 memOffSet = 0;
+  if (!isOffset) {
+    Operand &opnd = insn.GetOperand(indexOrOffset);
+    ASSERT(opnd.IsMemoryAccessOperand(), "opnd must be MemOperand");
+
+    auto &memOpnd = static_cast<MemOperand&>(opnd);
+    RegOperand *base = memOpnd.GetBaseRegister();
+    RegOperand *indexReg = memOpnd.GetIndexRegister();
+
+    if (base == nullptr || !IsFrameReg(*base) || indexReg) {
+      return defInsnSet;
+    }
+    ASSERT(memOpnd.GetOffsetImmediate() != nullptr, "offset must be a immediate value");
+    memOffSet = memOpnd.GetOffsetImmediate()->GetOffsetValue();
+    if (memOffSet < 0) {
+      memOffSet = stackSize + memOffSet;
+    }
+  } else {
+    memOffSet = indexOrOffset;
+  }
+  std::vector<Insn*> defInsnVec;
+  if (memGen[insn.GetBB()->GetId()]->TestBit(static_cast<uint32>(memOffSet / kMemZoomSize))) {
+    defInsnVec = FindMemDefBetweenInsn(memOffSet, insn.GetBB()->GetFirstInsn(), insn.GetPrev());
+  }
+
+  if (!defInsnVec.empty()) {
+    defInsnSet.insert(defInsnVec.cbegin(), defInsnVec.cend());
+    return defInsnSet;
+  }
+  std::vector<VisitStatus> visitedBB(kMaxBBNum, kNotVisited);
+  if (insn.GetBB()->IsCleanup()) {
+    DFSFindDefForMemOpnd(*insn.GetBB(), memOffSet, visitedBB, defInsnSet);
+    if (defInsnSet.empty()) {
+      FOR_ALL_BB(bb, cgFunc) {
+        if (bb->IsCleanup()) {
+          continue;
+        }
+
+        if (memGen[bb->GetId()]->TestBit(static_cast<uint32>(memOffSet / kMemZoomSize))) {
+          FindMemDefInBB(memOffSet, *bb, defInsnSet);
+        }
+      }
+    }
+  } else {
+    DFSFindDefForMemOpnd(*insn.GetBB(), memOffSet, visitedBB, defInsnSet);
+  }
+
+  return defInsnSet;
+}
+
+/*
+ * find all insn using stack memory operand insn.opnd[index]
+ * secondMem is used to represent the second stack memory opernad in store pair insn
+ */
+InsnSet AArch64ReachingDefinition::FindUseForMemOpnd(Insn &insn, uint8 index, bool secondMem) const {
+  Operand &opnd = insn.GetOperand(index);
+  ASSERT(opnd.IsMemoryAccessOperand(), "opnd must be MemOperand");
+  auto &memOpnd = static_cast<MemOperand&>(opnd);
+  RegOperand *base = memOpnd.GetBaseRegister();
+
+  InsnSet useInsnSet;
+  if (base == nullptr || !IsFrameReg(*base)) {
+    return useInsnSet;
+  }
+
+  ASSERT(memOpnd.GetIndexRegister() == nullptr, "IndexRegister no nullptr");
+  ASSERT(memOpnd.GetOffsetImmediate() != nullptr, "offset must be a immediate value");
+  int64 memOffSet = memOpnd.GetOffsetImmediate()->GetOffsetValue();
+  if (memOffSet < 0) {
+    memOffSet = stackSize + memOffSet;
+  }
+  if (secondMem) {
+    ASSERT(insn.IsStorePair(), "second MemOperand can only be defined in stp insn");
+    memOffSet += GetEachMemSizeOfPair(insn.GetMachineOpcode());
+  }
+  /* memOperand may be redefined in current BB */
+  bool findFinish = FindMemUseBetweenInsn(memOffSet, insn.GetNext(), insn.GetBB()->GetLastInsn(), useInsnSet);
+  std::vector<bool> visitedBB(kMaxBBNum, false);
+  if (findFinish || !memOut[insn.GetBB()->GetId()]->TestBit(static_cast<uint32>(memOffSet / kMemZoomSize))) {
+    if (insn.GetBB()->GetEhSuccs().size() != 0) {
+      DFSFindUseForMemOpnd(*insn.GetBB(), memOffSet, visitedBB, useInsnSet, true);
+    }
+  } else {
+    DFSFindUseForMemOpnd(*insn.GetBB(), memOffSet, visitedBB, useInsnSet, false);
+  }
+  if (!insn.GetBB()->IsCleanup() && firstCleanUpBB) {
+    if (memUse[firstCleanUpBB->GetId()]->TestBit(static_cast<uint32>(memOffSet / kMemZoomSize))) {
+      findFinish = FindMemUseBetweenInsn(memOffSet, firstCleanUpBB->GetFirstInsn(),
+                                         firstCleanUpBB->GetLastInsn(), useInsnSet);
+      if (findFinish || !memOut[firstCleanUpBB->GetId()]->TestBit(static_cast<uint32>(memOffSet / kMemZoomSize))) {
+        return useInsnSet;
+      }
+    }
+    DFSFindUseForMemOpnd(*firstCleanUpBB, memOffSet, visitedBB, useInsnSet, false);
+  }
+  return useInsnSet;
+}
+
+/*
+ * initialize bb.gen and bb.use
+ * if it is not computed in first time, bb.gen and bb.use must be cleared firstly
+ */
+void AArch64ReachingDefinition::InitGenUse(BB &bb, bool firstTime) {
+  if (!firstTime && (mode & kRDRegAnalysis) != 0) {
+    regGen[bb.GetId()]->ResetAllBit();
+    regUse[bb.GetId()]->ResetAllBit();
+  }
+  if (!firstTime && ((mode & kRDMemAnalysis) != 0)) {
+    memGen[bb.GetId()]->ResetAllBit();
+    memUse[bb.GetId()]->ResetAllBit();
+  }
+
+  if (bb.IsEmpty()) {
+    return;
+  }
+
+  FOR_BB_INSNS(insn, (&bb)) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+
+    if (insn->GetMachineOpcode() == MOP_asm) {
+      GenAllAsmDefRegs(bb, *insn, kAsmOutputListOpnd);
+      GenAllAsmDefRegs(bb, *insn, kAsmClobberListOpnd);
+      GenAllAsmUseRegs(bb, *insn, kAsmInputListOpnd);
+      continue;
+    }
+    if (insn->IsCall() || insn->IsTailCall()) {
+      GenAllCallerSavedRegs(bb, *insn);
+      InitMemInfoForClearStackCall(*insn);
+    }
+
+    const InsnDesc *md = insn->GetDesc();
+    uint32 opndNum = insn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = insn->GetOperand(i);
+      auto *regProp = md->opndMD[i];
+      if (opnd.IsList() && (mode & kRDRegAnalysis) != 0) {
+        ASSERT(regProp->IsUse(), "ListOperand is used in insn");
+        InitInfoForListOpnd(bb, opnd);
+      } else if (opnd.IsMemoryAccessOperand()) {
+        InitInfoForMemOperand(*insn, opnd, regProp->IsDef());
+      } else if (opnd.IsConditionCode() && ((mode & kRDRegAnalysis) != 0)) {
+        ASSERT(regProp->IsUse(), "condition code is used in insn");
+        InitInfoForConditionCode(bb);
+      } else if (opnd.IsRegister() && (mode & kRDRegAnalysis) != 0) {
+        InitInfoForRegOpnd(bb, opnd, regProp->IsDef());
+      }
+    }
+  }
+}
+
+void AArch64ReachingDefinition::InitMemInfoForClearStackCall(Insn &callInsn) {
+  if ((mode & kRDMemAnalysis) == 0 || !callInsn.IsClearDesignateStackCall()) {
+    return;
+  }
+  int64 firstOffset = callInsn.GetClearStackOffset(kFirstClearMemIndex);
+  constexpr int64 defaultValOfClearMemOffset = -1;
+  if (firstOffset != defaultValOfClearMemOffset) {
+    memGen[callInsn.GetBB()->GetId()]->SetBit(firstOffset / kMemZoomSize);
+  }
+  int64 secondOffset = callInsn.GetClearStackOffset(kSecondClearMemIndex);
+  if (secondOffset != defaultValOfClearMemOffset) {
+    memGen[callInsn.GetBB()->GetId()]->SetBit(static_cast<uint32>(secondOffset / kMemZoomSize));
+  }
+}
+
+void AArch64ReachingDefinition::InitInfoForMemOperand(Insn &insn, Operand &opnd, bool isDef) {
+  ASSERT(opnd.IsMemoryAccessOperand(), "opnd must be MemOperand");
+  MemOperand &memOpnd = static_cast<MemOperand&>(opnd);
+  RegOperand *base = memOpnd.GetBaseRegister();
+  RegOperand *index = memOpnd.GetIndexRegister();
+
+  if (base == nullptr) {
+    return;
+  }
+  if (((mode & kRDMemAnalysis) != 0) && IsFrameReg(*base)) {
+    if (index != nullptr) {
+      SetAnalysisMode(kRDRegAnalysis);
+      return;
+    }
+    CHECK_FATAL(index == nullptr, "Existing [x29 + index] Memory Address");
+    ASSERT(memOpnd.GetOffsetImmediate(), "offset must be a immediate value");
+    int64 offsetVal = memOpnd.GetOffsetImmediate()->GetOffsetValue();
+    if (offsetVal < 0) {
+      offsetVal = stackSize + offsetVal;
+    }
+    if ((offsetVal % kMemZoomSize) != 0) {
+      SetAnalysisMode(kRDRegAnalysis);
+    }
+
+    if (!isDef) {
+      memUse[insn.GetBB()->GetId()]->SetBit(offsetVal / kMemZoomSize);
+      if (insn.IsLoadPair()) {
+        int64 nextMemOffset = offsetVal + GetEachMemSizeOfPair(insn.GetMachineOpcode());
+        memUse[insn.GetBB()->GetId()]->SetBit(nextMemOffset / kMemZoomSize);
+      }
+    } else if (isDef) {
+      memGen[insn.GetBB()->GetId()]->SetBit(offsetVal / kMemZoomSize);
+      if (insn.IsStorePair()) {
+        int64 nextMemOffset = offsetVal + GetEachMemSizeOfPair(insn.GetMachineOpcode());
+        memGen[insn.GetBB()->GetId()]->SetBit(nextMemOffset / kMemZoomSize);
+      }
+    }
+  }
+
+  if ((mode & kRDRegAnalysis) != 0) {
+    regUse[insn.GetBB()->GetId()]->SetBit(base->GetRegisterNumber());
+    if (index != nullptr) {
+      regUse[insn.GetBB()->GetId()]->SetBit(index->GetRegisterNumber());
+    }
+    if (memOpnd.GetAddrMode() == MemOperand::kAddrModeBOi &&
+        (memOpnd.IsPostIndexed() || memOpnd.IsPreIndexed())) {
+      /* Base operand has changed. */
+      regGen[insn.GetBB()->GetId()]->SetBit(base->GetRegisterNumber());
+    }
+  }
+}
+
+void AArch64ReachingDefinition::InitInfoForListOpnd(const BB &bb, const Operand &opnd) {
+  auto *listOpnd = static_cast<const ListOperand*>(&opnd);
+  for (auto &listElem : listOpnd->GetOperands()) {
+    auto *regOpnd = static_cast<const RegOperand*>(listElem);
+    ASSERT(regOpnd != nullptr, "used Operand in call insn must be Register");
+    regUse[bb.GetId()]->SetBit(regOpnd->GetRegisterNumber());
+  }
+}
+
+void AArch64ReachingDefinition::InitInfoForConditionCode(const BB &bb) {
+  Operand &rflagOpnd = cgFunc->GetOrCreateRflag();
+  RegOperand &rflagReg = static_cast<RegOperand&>(rflagOpnd);
+  regUse[bb.GetId()]->SetBit(rflagReg.GetRegisterNumber());
+}
+
+void AArch64ReachingDefinition::InitInfoForRegOpnd(const BB &bb, Operand &opnd, bool isDef) {
+  RegOperand *regOpnd = static_cast<RegOperand*>(&opnd);
+  if (!isDef) {
+    regUse[bb.GetId()]->SetBit(regOpnd->GetRegisterNumber());
+  } else {
+    regGen[bb.GetId()]->SetBit(regOpnd->GetRegisterNumber());
+  }
+}
+
+int32 AArch64ReachingDefinition::GetStackSize() const {
+  const int sizeofFplr = kDivide2 * kIntregBytelen;
+  return static_cast<int32>(static_cast<AArch64MemLayout*>(cgFunc->GetMemlayout())->RealStackFrameSize() + sizeofFplr);
+}
+
+bool AArch64ReachingDefinition::IsCallerSavedReg(uint32 regNO) const {
+  return AArch64Abi::IsCallerSaveReg(static_cast<AArch64reg>(regNO));
+}
+
+int64 AArch64ReachingDefinition::GetEachMemSizeOfPair(MOperator opCode) const {
+  switch (opCode) {
+    case MOP_wstp:
+    case MOP_sstp:
+    case MOP_wstlxp:
+    case MOP_wldp:
+    case MOP_xldpsw:
+    case MOP_sldp:
+    case MOP_wldaxp:
+      return kWordByteNum;
+    case MOP_xstp:
+    case MOP_dstp:
+    case MOP_xstlxp:
+    case MOP_xldp:
+    case MOP_dldp:
+    case MOP_xldaxp:
+      return kDoubleWordByteNum;
+    default:
+      return 0;
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_reg_coalesce.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_reg_coalesce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..70b43641f245cd0be7a0d4ea33507e7e24023686
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_reg_coalesce.cpp
@@ -0,0 +1,428 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_reg_coalesce.h"
+#include "cg.h"
+#include "cg_option.h"
+#include "aarch64_isa.h"
+#include "aarch64_insn.h"
+#include "aarch64_cgfunc.h"
+#include "aarch64_cg.h"
+
+/*
+ * This phase implements if-conversion optimization,
+ * which tries to convert conditional branches into cset/csel instructions
+ */
+namespace maplebe {
+
+#define REGCOAL_DUMP CG_DEBUG_FUNC(*cgFunc)
+
+bool AArch64LiveIntervalAnalysis::IsUnconcernedReg(const RegOperand &regOpnd) const {
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType == kRegTyCc || regType == kRegTyVary) {
+    return true;
+  }
+  if (regOpnd.GetRegisterNumber() == RZR) {
+    return true;
+  }
+  if (!regOpnd.IsVirtualRegister()) {
+    return true;
+  }
+  return false;
+}
+
+LiveInterval *AArch64LiveIntervalAnalysis::GetOrCreateLiveInterval(regno_t regNO) {
+  LiveInterval *lr = GetLiveInterval(regNO);
+  if (lr == nullptr) {
+    lr = memPool->New<LiveInterval>(alloc);
+    vregIntervals[regNO] = lr;
+    lr->SetRegNO(regNO);
+  }
+  return lr;
+}
+
+void AArch64LiveIntervalAnalysis::UpdateCallInfo() {
+  for (auto vregNO : vregLive) {
+    LiveInterval *lr = GetLiveInterval(vregNO);
+    if (lr == nullptr) {
+      return;
+    }
+    lr->IncNumCall();
+  }
+}
+
+void AArch64LiveIntervalAnalysis::SetupLiveIntervalByOp(const Operand &op, Insn &insn, bool isDef) {
+  if (!op.IsRegister()) {
+    return;
+  }
+  auto &regOpnd = static_cast<const RegOperand&>(op);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  if (IsUnconcernedReg(regOpnd)) {
+    return;
+  }
+  LiveInterval *lr = GetOrCreateLiveInterval(regNO);
+  uint32 point = isDef ? insn.GetId() : (insn.GetId() - 1);
+  lr->AddRange(insn.GetBB()->GetId(), point, vregLive.find(regNO) != vregLive.end());
+  if (lr->GetRegType() == kRegTyUndef) {
+    lr->SetRegType(regOpnd.GetRegisterType());
+  }
+  if (candidates.find(regNO) != candidates.end()) {
+    lr->AddRefPoint(&insn, isDef);
+  }
+  if (isDef) {
+    vregLive.erase(regNO);
+  } else {
+    vregLive.insert(regNO);
+  }
+}
+
+void AArch64LiveIntervalAnalysis::ComputeLiveIntervalsForEachDefOperand(Insn &insn) {
+  const InsnDesc *md = insn.GetDesc();
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    if (insn.GetMachineOpcode() == MOP_asm && (i == kAsmOutputListOpnd || i == kAsmClobberListOpnd)) {
+      for (auto &opnd : static_cast<const ListOperand &>(insn.GetOperand(i)).GetOperands()) {
+        SetupLiveIntervalByOp(*static_cast<const RegOperand *>(opnd), insn, true);
+      }
+      continue;
+    }
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      if (!memOpnd.IsIntactIndexed()) {
+        SetupLiveIntervalByOp(opnd, insn, true);
+      }
+    }
+    if (!md->GetOpndDes(i)->IsRegDef()) {
+      continue;
+    }
+    SetupLiveIntervalByOp(opnd, insn, true);
+  }
+}
+
+void AArch64LiveIntervalAnalysis::ComputeLiveIntervalsForEachUseOperand(Insn &insn) {
+  const InsnDesc *md = insn.GetDesc();
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    if (insn.GetMachineOpcode() == MOP_asm && i == kAsmInputListOpnd) {
+      for (auto &opnd : static_cast<const ListOperand &>(insn.GetOperand(i)).GetOperands()) {
+        SetupLiveIntervalByOp(*static_cast<const RegOperand *>(opnd), insn, false);
+      }
+      continue;
+    }
+    if (md->GetOpndDes(i)->IsRegDef() && !md->GetOpndDes(i)->IsRegUse()) {
+      continue;
+    }
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsList()) {
+      auto &listOpnd = static_cast<const ListOperand&>(opnd);
+      for (auto &op : listOpnd.GetOperands()) {
+        SetupLiveIntervalByOp(*op, insn, false);
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      Operand *base = memOpnd.GetBaseRegister();
+      Operand *offset = memOpnd.GetIndexRegister();
+      if (base != nullptr) {
+        SetupLiveIntervalByOp(*base, insn, false);
+      }
+      if (offset != nullptr) {
+        SetupLiveIntervalByOp(*offset, insn, false);
+      }
+    } else if (opnd.IsPhi()) {
+      auto &phiOpnd = static_cast<const PhiOperand&>(opnd);
+      for (auto &opIt : phiOpnd.GetOperands()) {
+        SetupLiveIntervalByOp(*opIt.second, insn, false);
+      }
+    } else {
+      SetupLiveIntervalByOp(opnd, insn, false);
+    }
+  }
+}
+
+/* handle live range for bb->live_out */
+void AArch64LiveIntervalAnalysis::SetupLiveIntervalInLiveOut(regno_t liveOut, const BB &bb, uint32 currPoint) {
+  --currPoint;
+
+  if (liveOut >= kAllRegNum) {
+    (void)vregLive.insert(liveOut);
+    LiveInterval *lr = GetOrCreateLiveInterval(liveOut);
+    if (lr == nullptr) {
+      return;
+    }
+    lr->AddRange(bb.GetId(), currPoint, false);
+    return;
+  }
+}
+
+void AArch64LiveIntervalAnalysis::CollectCandidate() {
+  for (size_t bbIdx = bfs->sortedBBs.size(); bbIdx > 0; --bbIdx) {
+    BB *bb = bfs->sortedBBs[bbIdx - 1];
+
+    FOR_BB_INSNS_SAFE(insn, bb, ninsn) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (IsRegistersCopy(*insn)) {
+        RegOperand &regDest = static_cast<RegOperand&>(insn->GetOperand(kInsnFirstOpnd));
+        RegOperand &regSrc = static_cast<RegOperand&>(insn->GetOperand(kInsnSecondOpnd));
+        if (regDest.GetRegisterNumber() == regSrc.GetRegisterNumber()) {
+          continue;
+        }
+        if (regDest.IsVirtualRegister()) {
+          candidates.insert(regDest.GetRegisterNumber());
+        }
+        if (regSrc.IsVirtualRegister()) {
+          candidates.insert(regSrc.GetRegisterNumber());
+        }
+      }
+    }
+  }
+}
+
+bool AArch64LiveIntervalAnalysis::IsRegistersCopy(Insn &insn) {
+  MOperator mOp = insn.GetMachineOpcode();
+  if (mOp == MOP_xmovrr || mOp == MOP_wmovrr || mOp == MOP_xvmovs || mOp  == MOP_xvmovd) {
+    return true;
+  }
+  return false;
+}
+
+void AArch64LiveIntervalAnalysis::ComputeLiveIntervals() {
+  /* colloct refpoints and build interfere only for cands. */
+  CollectCandidate();
+
+  uint32 currPoint = static_cast<uint32>(cgFunc->GetTotalNumberOfInstructions()) +
+      static_cast<uint32>(bfs->sortedBBs.size());
+  /* distinguish use/def */
+  CHECK_FATAL(currPoint < (INT_MAX >> 2), "integer overflow check");
+  currPoint = currPoint << 2;
+  for (size_t bbIdx = bfs->sortedBBs.size(); bbIdx > 0; --bbIdx) {
+    BB *bb = bfs->sortedBBs[bbIdx - 1];
+
+    vregLive.clear();
+    for (auto liveOut : bb->GetLiveOutRegNO()) {
+      SetupLiveIntervalInLiveOut(liveOut, *bb, currPoint);
+    }
+    --currPoint;
+
+    if (bb->GetLastInsn() != nullptr &&  bb->GetLastInsn()->IsMachineInstruction() && bb->GetLastInsn()->IsCall()) {
+      UpdateCallInfo();
+    }
+
+    FOR_BB_INSNS_REV_SAFE(insn, bb, ninsn) {
+      if (!runAnalysis) {
+        insn->SetId(currPoint);
+      }
+      if (!insn->IsMachineInstruction() && !insn->IsPhi()) {
+        --currPoint;
+        if (ninsn != nullptr && ninsn->IsMachineInstruction() && ninsn->IsCall()) {
+          UpdateCallInfo();
+        }
+        continue;
+      }
+
+      ComputeLiveIntervalsForEachDefOperand(*insn);
+      ComputeLiveIntervalsForEachUseOperand(*insn);
+
+      if (ninsn != nullptr && ninsn->IsMachineInstruction() && ninsn->IsCall()) {
+        UpdateCallInfo();
+      }
+
+      /* distinguish use/def */
+      currPoint -= 2;
+    }
+    for (auto lin : bb->GetLiveInRegNO()) {
+      if (lin >= kAllRegNum) {
+        LiveInterval *li = GetLiveInterval(lin);
+        if (li != nullptr) {
+          li->AddRange(bb->GetId(), currPoint, currPoint);
+        }
+      }
+    }
+    /* move one more step for each BB */
+    --currPoint;
+  }
+
+  if (REGCOAL_DUMP) {
+    LogInfo::MapleLogger() << "\nAfter ComputeLiveIntervals\n";
+    Dump();
+  }
+}
+
+void AArch64LiveIntervalAnalysis::CheckInterference(LiveInterval &li1, LiveInterval &li2) const {
+  auto ranges1 = li1.GetRanges();
+  auto ranges2 = li2.GetRanges();
+  bool conflict = false;
+  for (auto &range : as_const(ranges1)) {
+    auto bbid = range.first;
+    auto posVec1 = range.second;
+    MapleMap<uint32, MapleVector<PosPair>>::const_iterator it = ranges2.find(bbid);
+    if (it == ranges2.cend()) {
+      continue;
+    } else {
+      /* check overlap */
+      auto posVec2 = it->second;
+      for (auto pos1 : posVec1) {
+        for (auto pos2 : posVec2) {
+          if (!((pos1.first < pos2.first && pos1.second < pos2.first) ||
+              (pos2.first < pos1.second && pos2.second < pos1.first))) {
+            conflict = true;
+            break;
+          }
+        }
+      }
+    }
+  }
+  if (conflict) {
+    li1.AddConflict(li2.GetRegNO());
+    li2.AddConflict(li1.GetRegNO());
+  }
+  return;
+}
+
+/* replace regDest with regSrc. */
+void AArch64LiveIntervalAnalysis::CoalesceRegPair(RegOperand &regDest, RegOperand &regSrc) {
+  LiveInterval *lrDest = GetLiveInterval(regDest.GetRegisterNumber());
+  LiveInterval *lrSrc = GetLiveInterval(regSrc.GetRegisterNumber());
+  CHECK_FATAL(lrDest && lrSrc, "find live interval failed");
+  /* replace dest with src */
+  if (regDest.GetSize() != regSrc.GetSize()) {
+    if (!cgFunc->IsExtendReg(regDest.GetRegisterNumber()) && !cgFunc->IsExtendReg(regSrc.GetRegisterNumber())) {
+      lrDest->AddConflict(lrSrc->GetRegNO());
+      lrSrc->AddConflict(lrDest->GetRegNO());
+      return;
+    }
+    cgFunc->InsertExtendSet(regSrc.GetRegisterNumber());
+  }
+
+  regno_t destNO = regDest.GetRegisterNumber();
+  /* replace all refPoints */
+  for (auto insn : lrDest->GetDefPoint()) {
+    cgFunc->ReplaceOpndInInsn(regDest, regSrc, *insn, destNO);
+  }
+  for (auto insn : lrDest->GetUsePoint()) {
+    cgFunc->ReplaceOpndInInsn(regDest, regSrc, *insn, destNO);
+  }
+
+  ASSERT(lrDest && lrSrc, "get live interval failed");
+  CoalesceLiveIntervals(*lrDest, *lrSrc);
+}
+
+void AArch64LiveIntervalAnalysis::CollectMoveForEachBB(BB &bb, std::vector<Insn*> &movInsns) const {
+  FOR_BB_INSNS_SAFE(insn, &bb, ninsn) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    if (IsRegistersCopy(*insn)) {
+      auto &regDest = static_cast<RegOperand&>(insn->GetOperand(kInsnFirstOpnd));
+      auto &regSrc = static_cast<RegOperand&>(insn->GetOperand(kInsnSecondOpnd));
+      if (!regSrc.IsVirtualRegister() || !regDest.IsVirtualRegister()) {
+        continue;
+      }
+      if (regSrc.GetRegisterNumber() == regDest.GetRegisterNumber()) {
+        continue;
+      }
+      movInsns.emplace_back(insn);
+    }
+  }
+}
+
+void AArch64LiveIntervalAnalysis::CoalesceMoves(std::vector<Insn*> &movInsns, bool phiOnly) {
+  AArch64CGFunc *a64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  bool changed = false;
+  do {
+    changed = false;
+    for (auto insn : movInsns) {
+      RegOperand &regDest = static_cast<RegOperand &>(insn->GetOperand(kInsnFirstOpnd));
+      RegOperand &regSrc = static_cast<RegOperand &>(insn->GetOperand(kInsnSecondOpnd));
+      if (regSrc.GetRegisterNumber() == regDest.GetRegisterNumber()) {
+        continue;
+      }
+      if (!insn->IsPhiMovInsn() && phiOnly) {
+        continue;
+      }
+      if (a64CGFunc->IsRegRematCand(regDest) != a64CGFunc->IsRegRematCand(regSrc)) {
+        if (insn->IsPhiMovInsn()) {
+          a64CGFunc->ClearRegRematInfo(regDest);
+          a64CGFunc->ClearRegRematInfo(regSrc);
+        } else {
+          continue;
+        }
+      }
+      if (a64CGFunc->IsRegRematCand(regDest) && a64CGFunc->IsRegRematCand(regSrc) &&
+          !a64CGFunc->IsRegSameRematInfo(regDest, regSrc)) {
+        if (insn->IsPhiMovInsn()) {
+          a64CGFunc->ClearRegRematInfo(regDest);
+          a64CGFunc->ClearRegRematInfo(regSrc);
+        } else {
+          continue;
+        }
+      }
+      LiveInterval *li1 = GetLiveInterval(regDest.GetRegisterNumber());
+      LiveInterval *li2 = GetLiveInterval(regSrc.GetRegisterNumber());
+      if (li1 == nullptr || li2 == nullptr) {
+        return;
+      }
+      CheckInterference(*li1, *li2);
+      if (!li1->IsConflictWith(regSrc.GetRegisterNumber()) ||
+          (li1->GetDefPoint().size() == 1 && li2->GetDefPoint().size() == 1)) {
+        if (REGCOAL_DUMP) {
+          LogInfo::MapleLogger() << "try to coalesce: " << regDest.GetRegisterNumber() << " <- "
+                                 << regSrc.GetRegisterNumber() << std::endl;
+        }
+        CoalesceRegPair(regDest, regSrc);
+        changed = true;
+      } else {
+        if (insn->IsPhiMovInsn() && phiOnly && REGCOAL_DUMP) {
+          LogInfo::MapleLogger() << "fail to coalesce: " << regDest.GetRegisterNumber() << " <- "
+                                 << regSrc.GetRegisterNumber() << std::endl;
+        }
+      }
+    }
+  } while (changed);
+}
+
+void AArch64LiveIntervalAnalysis::CoalesceRegisters() {
+  std::vector<Insn*> movInsns;
+  AArch64CGFunc *a64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  if (REGCOAL_DUMP) {
+    cgFunc->DumpCFGToDot("regcoal-");
+    LogInfo::MapleLogger() << "handle function: " << a64CGFunc->GetFunction().GetName() << std::endl;
+  }
+  for (size_t bbIdx = bfs->sortedBBs.size(); bbIdx > 0; --bbIdx) {
+    BB *bb = bfs->sortedBBs[bbIdx - 1];
+
+    if (!bb->GetCritical()) {
+      continue;
+    }
+    CollectMoveForEachBB(*bb, movInsns);
+  }
+  for (size_t bbIdx = bfs->sortedBBs.size(); bbIdx > 0; --bbIdx) {
+    BB *bb = bfs->sortedBBs[bbIdx - 1];
+
+    if (bb->GetCritical()) {
+      continue;
+    }
+    CollectMoveForEachBB(*bb, movInsns);
+  }
+
+  /* handle phi move first. */
+  CoalesceMoves(movInsns, true);
+
+  /* clean up dead mov */
+  a64CGFunc->CleanupDeadMov(REGCOAL_DUMP);
+}
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_reg_info.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_reg_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..179d7f998977d401f01246a79347fd3b6650d91a
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_reg_info.cpp
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_cgfunc.h"
+#include "aarch64_cg.h"
+#include "becommon.h"
+
+namespace maplebe {
+using namespace maple;
+
+void AArch64RegInfo::Init() {
+  for (regno_t regNO = kRinvalid; regNO < kMaxRegNum; ++regNO) {
+    /* when yieldpoint is enabled, x19 is reserved. */
+    if (IsYieldPointReg(regNO)) {
+      continue;
+    }
+    if (regNO == R29 && GetCurrFunction()->UseFP()) {
+      continue;
+    }
+    if (!AArch64Abi::IsAvailableReg(static_cast<AArch64reg>(regNO))) {
+      continue;
+    }
+    if (AArch64isa::IsGPRegister(static_cast<AArch64reg>(regNO))) {
+      AddToIntRegs(regNO);
+    } else {
+      AddToFpRegs(regNO);
+    }
+    AddToAllRegs(regNO);
+  }
+  return;
+}
+
+void AArch64RegInfo::Fini() {
+  AArch64CGFunc *a64CGFunc = static_cast<AArch64CGFunc*>(GetCurrFunction());
+  a64CGFunc->AddtoCalleeSaved(RFP);
+  a64CGFunc->AddtoCalleeSaved(RLR);
+  a64CGFunc->NoteFPLRAddedToCalleeSavedList();
+}
+
+void AArch64RegInfo::SaveCalleeSavedReg(MapleSet<regno_t> savedRegs) {
+  AArch64CGFunc *a64CGFunc = static_cast<AArch64CGFunc*>(GetCurrFunction());
+  for (auto reg: savedRegs) {
+    a64CGFunc->AddtoCalleeSaved(static_cast<AArch64reg>(reg));
+  }
+}
+
+bool AArch64RegInfo::IsSpecialReg(regno_t regno) const {
+  AArch64reg reg = static_cast<AArch64reg>(regno);
+  if ((reg == RLR) || (reg == RSP)) {
+    return true;
+  }
+
+  /* when yieldpoint is enabled, the dedicated register can not be allocated. */
+  if (IsYieldPointReg(reg)) {
+    return true;
+  }
+
+  return false;
+}
+bool AArch64RegInfo::IsSpillRegInRA(regno_t regNO, bool has3RegOpnd) {
+  return AArch64Abi::IsSpillRegInRA(static_cast<AArch64reg>(regNO), has3RegOpnd);
+}
+bool AArch64RegInfo::IsCalleeSavedReg(regno_t regno) const {
+  return AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(regno));
+}
+bool AArch64RegInfo::IsYieldPointReg(regno_t regno) const {
+  /* when yieldpoint is enabled, x19 is reserved. */
+  if (GetCurrFunction()->GetCG()->GenYieldPoint()) {
+    return (static_cast<AArch64reg>(regno) == RYP);
+  }
+  return false;
+}
+bool AArch64RegInfo::IsUnconcernedReg(regno_t regNO) const {
+  /* RFP = 32, RLR = 31, RSP = 33, RZR = 34, ccReg = 68 */
+  if ((regNO >= RLR && regNO <= RZR) || regNO == RFP || regNO == kRFLAG) {
+    return true;
+  }
+
+  /* when yieldpoint is enabled, the RYP(x19) can not be used. */
+  if (IsYieldPointReg(regNO)) {
+    return true;
+  }
+  return false;
+}
+
+bool AArch64RegInfo::IsUnconcernedReg(const RegOperand &regOpnd) const {
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType == kRegTyCc || regType == kRegTyVary) {
+    return true;
+  }
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  if (regNO == RZR) {
+    return true;
+  }
+  return IsUnconcernedReg(regNO);
+}
+
+/* r16,r17 are used besides ra. */
+bool AArch64RegInfo::IsReservedReg(regno_t regNO, bool doMultiPass) const {
+  if (!doMultiPass || GetCurrFunction()->GetMirModule().GetSrcLang() != kSrcLangC) {
+    return (regNO == R16) || (regNO == R17);
+  } else {
+    return (regNO == R16);
+  }
+}
+
+RegOperand *AArch64RegInfo::GetOrCreatePhyRegOperand(regno_t regNO, uint32 size, maplebe::RegType kind, uint32 flag) {
+  AArch64CGFunc *aarch64CgFunc = static_cast<AArch64CGFunc*>(GetCurrFunction());
+  return &aarch64CgFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(regNO), size, kind, flag);
+}
+
+Insn *AArch64RegInfo::BuildStrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) {
+  AArch64CGFunc *a64CGFunc = static_cast<AArch64CGFunc*>(GetCurrFunction());
+  return &a64CGFunc->GetInsnBuilder()->BuildInsn(a64CGFunc->PickStInsn(regSize, stype), phyOpnd, memOpnd);
+}
+
+Insn *AArch64RegInfo::BuildLdrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) {
+  AArch64CGFunc *a64CGFunc = static_cast<AArch64CGFunc*>(GetCurrFunction());
+  return &a64CGFunc->GetInsnBuilder()->BuildInsn(a64CGFunc->PickLdInsn(regSize, stype), phyOpnd, memOpnd);
+}
+
+MemOperand *AArch64RegInfo::AdjustMemOperandIfOffsetOutOfRange(MemOperand *memOpnd, regno_t vrNum,
+    bool isDest, Insn &insn, regno_t regNum, bool &isOutOfRange) {
+  AArch64CGFunc *a64CGFunc = static_cast<AArch64CGFunc*>(GetCurrFunction());
+  return a64CGFunc->AdjustMemOperandIfOffsetOutOfRange(memOpnd, static_cast<AArch64reg>(vrNum), isDest, insn,
+      static_cast<AArch64reg>(regNum), isOutOfRange);
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_regsaves.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_regsaves.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..76c3c17d630cde790d04a810413005a2529956e3
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_regsaves.cpp
@@ -0,0 +1,856 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_regsaves.h"
+#include "aarch64_cg.h"
+#include "aarch64_live.h"
+#include "aarch64_cg.h"
+#include "aarch64_proepilog.h"
+#include "cg_dominance.h"
+#include "cg_ssa_pre.h"
+#include "cg_ssu_pre.h"
+
+namespace maplebe {
+
+#define RS_DUMP 0
+#define M_LOG LogInfo::MapleLogger()
+
+#define SKIP_FPLR(REG) \
+  if (REG >= R29 && REG < V8) { \
+    continue; \
+  }
+
+void AArch64RegSavesOpt::InitData() {
+  calleeBitsDef = cgFunc->GetMemoryPool()->NewArray<CalleeBitsType>(cgFunc->NumBBs());
+  errno_t retDef = memset_s(calleeBitsDef, cgFunc->NumBBs() * sizeof(CalleeBitsType),
+                            0, cgFunc->NumBBs() * sizeof(CalleeBitsType));
+  calleeBitsUse = cgFunc->GetMemoryPool()->NewArray<CalleeBitsType>(cgFunc->NumBBs());
+  errno_t retUse = memset_s(calleeBitsUse, cgFunc->NumBBs() * sizeof(CalleeBitsType),
+                            0, cgFunc->NumBBs() * sizeof(CalleeBitsType));
+  calleeBitsAcc = cgFunc->GetMemoryPool()->NewArray<CalleeBitsType>(cgFunc->NumBBs());
+  errno_t retAccDef = memset_s(calleeBitsAcc, cgFunc->NumBBs() * sizeof(CalleeBitsType),
+                               0, cgFunc->NumBBs() * sizeof(CalleeBitsType));
+  CHECK_FATAL(retDef == EOK && retUse == EOK && retAccDef == EOK, "memset_s of calleesBits failed");
+
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  const MapleVector<AArch64reg> &sp = aarchCGFunc->GetCalleeSavedRegs();
+  if (!sp.empty()) {
+    if (std::find(sp.begin(), sp.end(), RFP) != sp.end()) {
+      aarchCGFunc->GetProEpilogSavedRegs().push_back(RFP);
+    }
+    if (std::find(sp.begin(), sp.end(), RLR) != sp.end()) {
+      aarchCGFunc->GetProEpilogSavedRegs().push_back(RLR);
+    }
+  }
+
+  for (auto bb : bfs->sortedBBs) {
+    SetId2bb(bb);
+  }
+}
+
+
+void AArch64RegSavesOpt::CollectLiveInfo(const BB &bb, const Operand &opnd, bool isDef, bool isUse) {
+  if (!opnd.IsRegister()) {
+    return;
+  }
+  const RegOperand &regOpnd = static_cast<const RegOperand&>(opnd);
+  regno_t regNO = regOpnd.GetRegisterNumber();
+  if (!AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(regNO)) ||
+      (regNO >= R29 && regNO <= R31)) {
+    return;   /* check only callee-save registers */
+  }
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType == kRegTyVary) {
+    return;
+  }
+  if (isDef) {
+    /* First def */
+    if (!IsCalleeBitSet(GetCalleeBitsDef(), bb.GetId(), regNO)) {
+      SetCalleeBit(GetCalleeBitsDef(), bb.GetId(), regNO);
+    }
+  }
+  if (isUse) {
+    /* Last use */
+    SetCalleeBit(GetCalleeBitsUse(), bb.GetId(), regNO);
+  }
+}
+
+void AArch64RegSavesOpt::GenerateReturnBBDefUse(const BB &bb) {
+  PrimType returnType = cgFunc->GetFunction().GetReturnType()->GetPrimType();
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  if (IsPrimitiveFloat(returnType)) {
+    Operand &phyOpnd =
+        aarchCGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(V0), k64BitSize, kRegTyFloat);
+    CollectLiveInfo(bb, phyOpnd, false, true);
+  } else if (IsPrimitiveInteger(returnType)) {
+    Operand &phyOpnd =
+        aarchCGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(R0), k64BitSize, kRegTyInt);
+    CollectLiveInfo(bb, phyOpnd, false, true);
+  }
+}
+
+void AArch64RegSavesOpt::ProcessAsmListOpnd(const BB &bb, const Operand &opnd, uint32 idx) {
+  bool isDef = false;
+  bool isUse = false;
+  switch (idx) {
+    case kAsmOutputListOpnd:
+    case kAsmClobberListOpnd: {
+      isDef = true;
+      break;
+    }
+    case kAsmInputListOpnd: {
+      isUse = true;
+      break;
+    }
+    default:
+      return;
+  }
+  auto &listOpnd = static_cast<const ListOperand&>(opnd);
+  for (auto &op : listOpnd.GetOperands()) {
+    CollectLiveInfo(bb, *op, isDef, isUse);
+  }
+}
+
+void AArch64RegSavesOpt::ProcessListOpnd(const BB &bb, const Operand &opnd) {
+  auto &listOpnd = static_cast<const ListOperand&>(opnd);
+  for (auto &op : listOpnd.GetOperands()) {
+    CollectLiveInfo(bb, *op, false, true);
+  }
+}
+
+void AArch64RegSavesOpt::ProcessMemOpnd(const BB &bb, Operand &opnd) {
+  auto &memOpnd = static_cast<MemOperand&>(opnd);
+  Operand *base = memOpnd.GetBaseRegister();
+  Operand *offset = memOpnd.GetIndexRegister();
+  if (base != nullptr) {
+    CollectLiveInfo(bb, *base, !memOpnd.IsIntactIndexed(), true);
+  }
+  if (offset != nullptr) {
+    CollectLiveInfo(bb, *offset, false, true);
+  }
+}
+
+void AArch64RegSavesOpt::ProcessCondOpnd(const BB &bb) {
+  Operand &rflag = cgFunc->GetOrCreateRflag();
+  CollectLiveInfo(bb, rflag, false, true);
+}
+
+void AArch64RegSavesOpt::ProcessOperands(const Insn &insn, const BB &bb) {
+  const InsnDesc *md = insn.GetDesc();
+  bool isAsm = (insn.GetMachineOpcode() == MOP_asm);
+
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    auto *regProp = md->opndMD[i];
+    bool isDef = regProp->IsRegDef();
+    bool isUse = regProp->IsRegUse();
+    if (opnd.IsList()) {
+      if (isAsm) {
+        ProcessAsmListOpnd(bb, opnd, i);
+      } else {
+        ProcessListOpnd(bb, opnd);
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      ProcessMemOpnd(bb, opnd);
+    } else if (opnd.IsConditionCode()) {
+      ProcessCondOpnd(bb);
+    } else {
+      CollectLiveInfo(bb, opnd, isDef, isUse);
+    }
+  } /* for all operands */
+}
+
+static bool IsBackEdge(BB* bb, BB* targ) {
+  CGFuncLoops *loop = bb->GetLoop();
+  if (loop != nullptr && loop->GetHeader() == bb) {
+    if (find(loop->GetBackedge().begin(), loop->GetBackedge().end(), targ) != loop->GetBackedge().end()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void AArch64RegSavesOpt::GenAccDefs() {
+  /* Set up accumulated callee def bits in all blocks */
+  for (auto bb : bfs->sortedBBs) {
+    if (bb->GetPreds().size() == 0) {
+      SetCalleeBit(GetCalleeBitsAcc(), bb->GetId(), GetBBCalleeBits(GetCalleeBitsDef(), bb->GetId()));
+    } else {
+      CalleeBitsType curbbBits = GetBBCalleeBits(GetCalleeBitsDef(), bb->GetId());
+      int64 n = -1;
+      CalleeBitsType tmp = static_cast<CalleeBitsType>(n);
+      for (auto pred : bb->GetPreds()) {
+        if (IsBackEdge(bb, pred)) {
+          continue;
+        }
+        tmp &= GetBBCalleeBits(GetCalleeBitsAcc(), pred->GetId());
+      }
+      SetCalleeBit(GetCalleeBitsAcc(), bb->GetId(), curbbBits | tmp);
+    }
+  }
+}
+
+/* Record in each local BB the 1st def and the last use of a callee-saved
+   register  */
+void AArch64RegSavesOpt::GenRegDefUse() {
+  for (auto bbp : bfs->sortedBBs) {
+    BB &bb = *bbp;
+    if (bb.GetKind() == BB::kBBReturn) {
+      GenerateReturnBBDefUse(bb);
+    }
+    if (bb.IsEmpty()) {
+      continue;
+    }
+
+    FOR_BB_INSNS(insn, &bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      ProcessOperands(*insn, bb);
+    } /* for all insns */
+  } /* for all sortedBBs */
+
+  GenAccDefs();
+
+#if RS_DUMP
+  M_LOG << "CalleeBits for " << cgFunc->GetName() << ":\n";
+  for (BBID i = 1; i < cgFunc->NumBBs(); ++i) {
+    M_LOG << i << " : " << calleeBitsDef[i] << " " << calleeBitsUse[i] << " " << calleeBitsAcc[i] << "\n";
+  }
+#endif
+}
+
+bool AArch64RegSavesOpt::CheckForUseBeforeDefPath() {
+  /* Check if any block has a use without a def as shown in its accumulated
+     calleeBitsDef from above */
+  BBID found = 0;
+  CalleeBitsType use;
+  CalleeBitsType acc;
+  for (BBID bid = 0; bid < cgFunc->NumBBs(); ++bid) {
+    use = GetBBCalleeBits(GetCalleeBitsUse(), bid);
+    acc = GetBBCalleeBits(GetCalleeBitsAcc(), bid);
+    if ((use & acc) != use) {
+      found = bid;
+      break;
+    }
+  }
+  if (found) {
+#if RS_DUMP
+  CalleeBitsType mask = 1;
+  for (uint32 i = 0; i < static_cast<uint32>(sizeof(CalleeBitsType) << k3BitSize); ++i) {
+    regno_t reg = ReverseRegBitMap(i);
+    if ((use & mask) != 0 && (acc & mask) == 0) {
+      M_LOG << "R" << (reg - 1) << " in BB" << found << " is in a use before def path\n";
+    }
+    mask <<= 1;
+  }
+#endif
+    return true;
+  }
+  return false;
+}
+
+void AArch64RegSavesOpt::PrintBBs() const {
+  M_LOG << "RegSaves LiveIn/Out of BFS nodes:\n";
+  for (auto *bb : bfs->sortedBBs) {
+    M_LOG << "< === > ";
+    M_LOG << bb->GetId();
+    M_LOG << " pred:[";
+    for (auto predBB : bb->GetPreds()) {
+      M_LOG << " " << predBB->GetId();
+    }
+    M_LOG << "] succs:[";
+    for (auto succBB : bb->GetSuccs()) {
+      M_LOG << " " << succBB->GetId();
+    }
+    M_LOG << "]\n LiveIn of [" << bb->GetId() << "]: ";
+    for (auto liveIn: bb->GetLiveInRegNO()) {
+        M_LOG << liveIn << " ";
+    }
+    M_LOG << "\n LiveOut of [" << bb->GetId() << "]: ";
+    for (auto liveOut: bb->GetLiveOutRegNO()) {
+      M_LOG << liveOut  << " ";
+    }
+    M_LOG << "\n";
+  }
+}
+
+/* 1st def MUST not have preceding save in dominator list. Each dominator
+   block must not have livein or liveout of the register */
+int32 AArch64RegSavesOpt::CheckCriteria(BB *bb, regno_t reg) const {
+  /* Already a site to save */
+  SavedRegInfo *sp = bbSavedRegs[bb->GetId()];
+  if (sp != nullptr && sp->ContainSaveReg(reg)) {
+    return 1;
+  }
+
+  /* This preceding block has livein OR liveout of reg */
+  MapleSet<regno_t> &liveIn = bb->GetLiveInRegNO();
+  MapleSet<regno_t> &liveOut = bb->GetLiveOutRegNO();
+  if (liveIn.find(reg) != liveIn.end() ||
+    liveOut.find(reg) != liveOut.end()) {
+    return 2;
+  }
+
+  return 0;
+}
+
+/* Return true if reg is already to be saved in its dominator list */
+bool AArch64RegSavesOpt::AlreadySavedInDominatorList(const BB *bb, regno_t reg) const {
+  BB *aBB = GetDomInfo()->GetDom(bb->GetId());
+
+#if RS_DUMP
+  M_LOG << "Checking dom list starting " << bb->GetId() << " for saved R" << (reg - 1) << ":\n  ";
+#endif
+  while (!aBB->GetPreds().empty()) {  /* can't go beyond prolog */
+#if RS_DUMP
+    M_LOG << aBB->GetId() << " ";
+#endif
+    int t = CheckCriteria(aBB, reg);
+    if (t != 0) {
+#if RS_DUMP
+      std::string str = t == 1 ?  " saved here, skip!\n" : " has livein/out, skip!\n";
+      M_LOG << " --R" << (reg - 1) << str;
+#endif
+      return true;                   /* previously saved, inspect next reg */
+    }
+    aBB = GetDomInfo()->GetDom(aBB->GetId());
+  }
+  return false;                      /* not previously saved, to save at bb */
+}
+
+BB* AArch64RegSavesOpt::FindLoopDominator(BB *bb, regno_t reg, bool *done) {
+  BB *bbDom = bb;
+  while (bbDom->GetLoop() != nullptr) {
+    bbDom = GetDomInfo()->GetDom(bbDom->GetId());
+    if (CheckCriteria(bbDom, reg) != 0) {
+      *done = true;
+      break;
+    }
+    ASSERT(bbDom, "Can't find dominator for save location");
+  }
+  return bbDom;
+}
+
+/* If the newly found blk is a dominator of blk(s) in the current
+   to be saved list, remove these blks from bbSavedRegs */
+void AArch64RegSavesOpt::CheckAndRemoveBlksFromCurSavedList(SavedBBInfo *sp, BB *bbDom, regno_t reg) {
+  for (BB *sbb : sp->GetBBList()) {
+    for (BB *abb = sbb; !abb->GetPreds().empty();) {
+      if (abb->GetId() == bbDom->GetId()) {
+        /* Found! Don't plan to save in abb */
+        sp->RemoveBB(sbb);
+        bbSavedRegs[sbb->GetId()]->RemoveSaveReg(reg);
+#if RS_DUMP
+        M_LOG << " --R" << (reg - 1) << " save removed from BB" << sbb->GetId() << "\n";
+#endif
+        break;
+      }
+      abb = GetDomInfo()->GetDom(abb->GetId());
+    }
+  }
+}
+
+/* Determine callee-save regs save locations and record them in bbSavedRegs.
+   Save is needed for a 1st def callee-save register at its dominator block
+   outside any loop. */
+void AArch64RegSavesOpt::DetermineCalleeSaveLocationsDoms() {
+#if RS_DUMP
+  M_LOG << "Determining regsave sites using dom list for " << cgFunc->GetName() << ":\n";
+#endif
+  for (auto *bb : bfs->sortedBBs) {
+#if RS_DUMP
+    M_LOG << "BB: " << bb->GetId() << "\n";
+#endif
+    CalleeBitsType c = GetBBCalleeBits(GetCalleeBitsDef(), bb->GetId());
+    if (c == 0) {
+      continue;
+    }
+    CalleeBitsType mask = 1;
+    for (uint32 i = 0; i < static_cast<uint32>(sizeof(CalleeBitsType) << 3); ++i) {
+      MapleSet<regno_t> &liveIn = bb->GetLiveInRegNO();
+      regno_t reg = ReverseRegBitMap(i);
+      if ((c & mask) != 0 && liveIn.find(reg) == liveIn.end()) { /* not livein */
+        BB *bbDom = bb;  /* start from current BB */
+        bool done = false;
+        bbDom = FindLoopDominator(bbDom, reg, &done);
+        if (done) {
+          mask <<= 1;
+          continue;
+        }
+
+        /* Check if a dominator of bbDom was already a location to save */
+        if (AlreadySavedInDominatorList(bbDom, reg)) {
+          mask <<= 1;
+          continue;    /* no need to save again, next reg */
+        }
+
+        /* If the newly found blk is a dominator of blk(s) in the current
+           to be saved list, remove these blks from bbSavedRegs */
+        uint32 creg = i;
+        SavedBBInfo *sp = regSavedBBs[creg];
+        if (sp == nullptr) {
+          regSavedBBs[creg] = memPool->New<SavedBBInfo>(alloc);
+        } else {
+          CheckAndRemoveBlksFromCurSavedList(sp, bbDom, reg);
+        }
+        regSavedBBs[creg]->InsertBB(bbDom);
+
+        BBID bid = bbDom->GetId();
+#if RS_DUMP
+        M_LOG << " --R" << (reg - 1);
+        M_LOG << " to save in " << bid << "\n";
+#endif
+        SavedRegInfo *ctx = GetbbSavedRegsEntry(bid);
+        if (!ctx->ContainSaveReg(reg)) {
+          ctx->InsertSaveReg(reg);
+        }
+      }
+      mask <<= 1;
+      CalleeBitsType t = c;
+      t >>= 1;
+      if (t == 0) {
+        break;  /* short cut */
+      }
+    }
+  }
+}
+
+void AArch64RegSavesOpt::DetermineCalleeSaveLocationsPre() {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  MapleAllocator sprealloc(memPool);
+#if RS_DUMP
+  M_LOG << "Determining regsave sites using ssa_pre for " << cgFunc->GetName() << ":\n";
+#endif
+  const MapleVector<AArch64reg> &callees = aarchCGFunc->GetCalleeSavedRegs();
+  /* do 2 regs at a time to force store pairs */
+  for (uint32 i = 0; i < callees.size(); ++i) {
+    AArch64reg reg1 = callees[i];
+    SKIP_FPLR(reg1);
+    AArch64reg reg2 = kRinvalid;
+    if ((i + 1) < callees.size()) {
+      reg2 = callees[i + 1];
+      SKIP_FPLR(reg2);
+      ++i;
+    }
+
+    SsaPreWorkCand wkCand(&sprealloc);
+    for (BBID bid = 1; bid < static_cast<BBID>(bbSavedRegs.size()); ++bid) {
+      /* Set the BB occurrences of this callee-saved register */
+      if (IsCalleeBitSet(GetCalleeBitsDef(), bid, reg1) ||
+          IsCalleeBitSet(GetCalleeBitsUse(), bid, reg1)) {
+        (void)wkCand.occBBs.insert(bid);
+      }
+      if (reg2 != kRinvalid) {
+        if (IsCalleeBitSet(GetCalleeBitsDef(), bid, reg2) ||
+            IsCalleeBitSet(GetCalleeBitsUse(), bid, reg2)) {
+          (void)wkCand.occBBs.insert(bid);
+        }
+      }
+    }
+    DoSavePlacementOpt(cgFunc, GetDomInfo(), &wkCand);
+    if (wkCand.saveAtEntryBBs.empty()) {
+      /* something gone wrong, skip this reg */
+      wkCand.saveAtProlog = true;
+    }
+    if (wkCand.saveAtProlog) {
+      /* Save cannot be applied, skip this reg and place save/restore
+         in prolog/epilog */
+      MapleVector<AArch64reg> &pe = aarchCGFunc->GetProEpilogSavedRegs();
+      if (std::find(pe.begin(), pe.end(), reg1) == pe.end()) {
+        pe.push_back(reg1);
+      }
+      if (reg2 != kRinvalid && std::find(pe.begin(), pe.end(), reg2) == pe.end()) {
+        pe.push_back(reg2);
+      }
+#if RS_DUMP
+      M_LOG << "Save R" << (reg1 - 1) << " n/a, do in Pro/Epilog\n";
+      if (reg2 != kRinvalid) {
+        M_LOG << "    R  " << (reg2 - 1) << " n/a, do in Pro/Epilog\n";
+      }
+#endif
+      continue;
+    }
+    if (!wkCand.saveAtEntryBBs.empty()) {
+      for (BBID entBB : wkCand.saveAtEntryBBs) {
+#if RS_DUMP
+        std::string r = reg1 <= R28 ? "R" : "V";
+        M_LOG << "BB " << entBB << " save for : " << r << (reg1 - 1) << "\n";
+        if (reg2 != kRinvalid) {
+          std::string r2 = reg2 <= R28 ? "R" : "V";
+          M_LOG << "              : " << r2 << (reg2 - 1) << "\n";
+        }
+#endif
+        GetbbSavedRegsEntry(entBB)->InsertSaveReg(reg1);
+        if (reg2 != kRinvalid) {
+          GetbbSavedRegsEntry(entBB)->InsertSaveReg(reg2);
+        }
+      }
+    }
+  }
+}
+
+void AArch64RegSavesOpt::CheckCriticalEdge(BB *bb, AArch64reg reg) {
+  for (BB *sbb : bb->GetSuccs()) {
+    if (sbb->GetPreds().size() > 1) {
+      CHECK_FATAL(false, "critical edge detected");
+    }
+    /* To insert at all succs */
+    GetbbSavedRegsEntry(sbb->GetId())->InsertEntryReg(reg);
+  }
+}
+
+/* Restore cannot be applied, skip this reg and place save/restore
+   in prolog/epilog */
+void AArch64RegSavesOpt::RevertToRestoreAtEpilog(AArch64reg reg) {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  for (size_t bid = 1; bid < bbSavedRegs.size(); ++bid) {
+    SavedRegInfo *sp = bbSavedRegs[bid];
+    if (sp != nullptr && !sp->GetSaveSet().empty() && sp->ContainSaveReg(reg)) {
+      sp->RemoveSaveReg(reg);
+    }
+  }
+  MapleVector<AArch64reg> &pe = aarchCGFunc->GetProEpilogSavedRegs();
+  if (std::find(pe.begin(), pe.end(), reg) == pe.end()) {
+    pe.push_back(reg);
+  }
+#if RS_DUMP
+      M_LOG << "Restore R" << (reg - 1) << " n/a, do in Pro/Epilog\n";
+#endif
+}
+
+/* Determine calleesave regs restore locations by calling ssu-pre,
+   previous bbSavedRegs memory is cleared and restore locs recorded in it */
+void AArch64RegSavesOpt::DetermineCalleeRestoreLocations() {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  MapleAllocator sprealloc(memPool);
+#if RS_DUMP
+  M_LOG << "Determining Callee Restore Locations:\n";
+#endif
+  const MapleVector<AArch64reg> &callees = aarchCGFunc->GetCalleeSavedRegs();
+  for (auto reg : callees) {
+    SKIP_FPLR(reg);
+
+    SPreWorkCand wkCand(&sprealloc);
+    for (BBID bid = 1; bid < static_cast<uint32>(bbSavedRegs.size()); ++bid) {
+      /* Set the saved BB locations of this callee-saved register */
+      SavedRegInfo *sp = bbSavedRegs[bid];
+      if (sp != nullptr) {
+        if (sp->ContainSaveReg(reg)) {
+          (void)wkCand.saveBBs.insert(bid);
+        }
+      }
+      /* Set the BB occurrences of this callee-saved register */
+      if (IsCalleeBitSet(GetCalleeBitsDef(), bid, reg) ||
+          IsCalleeBitSet(GetCalleeBitsUse(), bid, reg)) {
+        (void)wkCand.occBBs.insert(bid);
+      }
+    }
+    DoRestorePlacementOpt(cgFunc, GetPostDomInfo(), &wkCand);
+    if (wkCand.saveBBs.empty()) {
+      /* something gone wrong, skip this reg */
+      wkCand.restoreAtEpilog = true;
+    }
+    if (wkCand.restoreAtEpilog) {
+      RevertToRestoreAtEpilog(reg);
+      continue;
+    }
+    if (!wkCand.restoreAtEntryBBs.empty() || !wkCand.restoreAtExitBBs.empty()) {
+      for (BBID entBB : wkCand.restoreAtEntryBBs) {
+#if RS_DUMP
+        std::string r = reg <= R28 ? "r" : "v";
+        M_LOG << "BB " << entBB << " restore: " << r << (reg - 1) << "\n";
+#endif
+        GetbbSavedRegsEntry(entBB)->InsertEntryReg(reg);
+      }
+      for (BBID exitBB : wkCand.restoreAtExitBBs) {
+        BB *bb = GetId2bb(exitBB);
+        if (bb->GetKind() == BB::kBBIgoto) {
+          CHECK_FATAL(false, "igoto detected");
+        }
+        Insn *lastInsn = bb->GetLastMachineInsn();
+        if (lastInsn != nullptr && (lastInsn->IsBranch() || lastInsn->IsTailCall()) &&
+            lastInsn->GetOperand(0).IsRegister() &&
+            static_cast<RegOperand&>(lastInsn->GetOperand(0)).GetRegisterNumber() == reg) {
+          RevertToRestoreAtEpilog(reg);
+        }
+        if (lastInsn != nullptr && (lastInsn->IsBranch() || lastInsn->IsTailCall())) {
+          /* To insert in this block - 1 instr */
+          SavedRegInfo *sp = GetbbSavedRegsEntry(exitBB);
+          sp->InsertExitReg(reg);
+          sp->insertAtLastMinusOne = true;
+        } else if (bb->GetSuccs().size() > 1) {
+          CheckCriticalEdge(bb, reg);
+        } else {
+          /* otherwise, BB_FT etc */
+          GetbbSavedRegsEntry(exitBB)->InsertExitReg(reg);
+        }
+#if RS_DUMP
+          std::string r = reg <= R28 ? "R" : "V";
+          M_LOG << "BB " << exitBB << " restore: " << r << (reg - 1) << "\n";
+#endif
+      }
+    }
+  }
+}
+
+int32 AArch64RegSavesOpt::FindCalleeBase() const {
+  int32 offset = static_cast<int32>(
+      static_cast<AArch64MemLayout*>(cgFunc->GetMemlayout())->RealStackFrameSize() -
+      (static_cast<AArch64CGFunc*>(cgFunc)->SizeOfCalleeSaved() - (kDivide2 * kIntregBytelen) /* FP/LR */) -
+      cgFunc->GetMemlayout()->SizeOfArgsToStackPass());
+
+  if (cgFunc->GetFunction().GetAttr(FUNCATTR_varargs)) {
+    /* GR/VR save areas are above the callee save area */
+    AArch64MemLayout *ml = static_cast<AArch64MemLayout *>(cgFunc->GetMemlayout());
+    int saveareasize = static_cast<int>(RoundUp(ml->GetSizeOfGRSaveArea(), GetPointerSize() * k2BitSize) +
+        RoundUp(ml->GetSizeOfVRSaveArea(), GetPointerSize() * k2BitSize));
+    offset -= saveareasize;
+  }
+  return offset;
+}
+
+void AArch64RegSavesOpt::SetupRegOffsets() {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  const MapleVector<AArch64reg> &proEpilogRegs = aarchCGFunc->GetProEpilogSavedRegs();
+  int32 regsInProEpilog = static_cast<int32>(proEpilogRegs.size() - 2);
+  const MapleVector<AArch64reg> &callees = aarchCGFunc->GetCalleeSavedRegs();
+
+  int32 offset = FindCalleeBase();
+  for (auto reg : callees) {
+    SKIP_FPLR(reg);
+    if (std::count(proEpilogRegs.begin(), proEpilogRegs.end(), reg)) {
+      continue;
+    }
+    if (regOffset.find(reg) == regOffset.end()) {
+      regOffset[reg] = static_cast<uint32>(offset + (regsInProEpilog * kBitsPerByte));
+      offset += static_cast<int32>(kIntregBytelen);
+    }
+  }
+}
+
+void AArch64RegSavesOpt::InsertCalleeSaveCode() {
+  BBID bid = 0;
+  BB *saveBB = cgFunc->GetCurBB();
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+
+#if RS_DUMP
+  M_LOG << "Inserting Save for " << cgFunc->GetName() << ":\n";
+#endif
+  int32 offset = FindCalleeBase();
+  for (BB *bb : bfs->sortedBBs) {
+    bid = bb->GetId();
+    aarchCGFunc->SetSplitBaseOffset(0);
+    if (bbSavedRegs[bid] != nullptr && !bbSavedRegs[bid]->GetSaveSet().empty()) {
+      aarchCGFunc->GetDummyBB()->ClearInsns();
+      cgFunc->SetCurBB(*aarchCGFunc->GetDummyBB());
+      AArch64reg intRegFirstHalf = kRinvalid;
+      AArch64reg fpRegFirstHalf = kRinvalid;
+      for (auto areg : bbSavedRegs[bid]->GetSaveSet()) {
+        AArch64reg reg = static_cast<AArch64reg>(areg);
+        RegType regType = AArch64isa::IsGPRegister(reg) ? kRegTyInt : kRegTyFloat;
+        AArch64reg &firstHalf = AArch64isa::IsGPRegister(reg) ? intRegFirstHalf : fpRegFirstHalf;
+        std::string r = reg <= R28 ? "R" : "V";
+        /* If reg not seen before, record offset and then update */
+        if (regOffset.find(areg) == regOffset.end()) {
+          regOffset[areg] = static_cast<uint32>(offset);
+          offset += static_cast<int32>(kIntregBytelen);
+        }
+        if (firstHalf == kRinvalid) {
+          /* 1st half in reg pair */
+          firstHalf = reg;
+#if RS_DUMP
+          M_LOG << r << (reg - 1) << " save in BB" << bid << "  Offset = " << regOffset[reg]<< "\n";
+#endif
+        } else {
+          if (regOffset[reg] == (regOffset[firstHalf] + k8ByteSize)) {
+            /* firstHalf & reg consecutive, make regpair */
+            AArch64GenProEpilog::AppendInstructionPushPair(*cgFunc, firstHalf, reg, regType,
+                                                           static_cast<int32>(regOffset[firstHalf]));
+          } else if (regOffset[firstHalf] == (regOffset[reg] + k8ByteSize)) {
+            /* reg & firstHalf consecutive, make regpair */
+            AArch64GenProEpilog::AppendInstructionPushPair(*cgFunc, reg, firstHalf, regType,
+                                                           static_cast<int32>(regOffset[reg]));
+          } else {
+            /* regs cannot be paired */
+            AArch64GenProEpilog::AppendInstructionPushSingle(*cgFunc, firstHalf, regType,
+                                                             static_cast<int32>(regOffset[firstHalf]));
+            AArch64GenProEpilog::AppendInstructionPushSingle(*cgFunc, reg, regType,
+                                                             static_cast<int32>(regOffset[reg]));
+          }
+          firstHalf = kRinvalid;
+#if RS_DUMP
+          M_LOG << r << (reg - 1) << " save in BB" << bid << "  Offset = " << regOffset[reg]<< "\n";
+#endif
+        }
+      }
+
+      if (intRegFirstHalf != kRinvalid) {
+        AArch64GenProEpilog::AppendInstructionPushSingle(*cgFunc,
+            intRegFirstHalf, kRegTyInt, static_cast<int32>(regOffset[intRegFirstHalf]));
+      }
+
+      if (fpRegFirstHalf != kRinvalid) {
+        AArch64GenProEpilog::AppendInstructionPushSingle(*cgFunc,
+            fpRegFirstHalf, kRegTyFloat, static_cast<int32>(regOffset[fpRegFirstHalf]));
+      }
+      bb->InsertAtBeginning(*aarchCGFunc->GetDummyBB());
+    }
+  }
+  cgFunc->SetCurBB(*saveBB);
+}
+
+void AArch64RegSavesOpt::PrintSaveLocs(AArch64reg reg) {
+  M_LOG << "  for save @BB [ ";
+  for (size_t b = 1; b < bbSavedRegs.size(); ++b) {
+    if (bbSavedRegs[b] != nullptr && bbSavedRegs[b]->ContainSaveReg(reg)) {
+      M_LOG << b << " ";
+    }
+  }
+  M_LOG << "]\n";
+}
+
+void AArch64RegSavesOpt::InsertCalleeRestoreCode() {
+  BBID bid = 0;
+  BB *saveBB = cgFunc->GetCurBB();
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+
+#if RS_DUMP
+  M_LOG << "Inserting Restore: \n";
+#endif
+  int32 offset = FindCalleeBase();
+  for (BB *bb : bfs->sortedBBs) {
+    bid = bb->GetId();
+    aarchCGFunc->SetSplitBaseOffset(0);
+    SavedRegInfo *sp = bbSavedRegs[bid];
+    if (sp != nullptr) {
+      if (sp->GetEntrySet().empty() && sp->GetExitSet().empty()) {
+        continue;
+      }
+
+      aarchCGFunc->GetDummyBB()->ClearInsns();
+      cgFunc->SetCurBB(*aarchCGFunc->GetDummyBB());
+      for (auto areg : sp->GetEntrySet()) {
+        AArch64reg reg = static_cast<AArch64reg>(areg);
+        offset = static_cast<int32>(regOffset[areg]);
+#if RS_DUMP
+        std::string r = reg <= R28 ? "R" : "V";
+        M_LOG << r << (reg - 1) << " entry restore in BB " << bid << "  Saved Offset = " << offset << "\n";
+        PrintSaveLocs(reg);
+#endif
+
+        /* restore is always the same from saved offset */
+        RegType regType = AArch64isa::IsGPRegister(reg) ? kRegTyInt : kRegTyFloat;
+        AArch64GenProEpilog::AppendInstructionPopSingle(*cgFunc, reg, regType, offset);
+      }
+      FOR_BB_INSNS(insn, aarchCGFunc->GetDummyBB()) {
+        insn->SetDoNotRemove(true); /* do not let ebo remove these restores */
+      }
+      bb->InsertAtBeginning(*aarchCGFunc->GetDummyBB());
+
+      aarchCGFunc->GetDummyBB()->ClearInsns();
+      cgFunc->SetCurBB(*aarchCGFunc->GetDummyBB());
+      for (auto areg : sp->GetExitSet()) {
+        AArch64reg reg = static_cast<AArch64reg>(areg);
+        offset = static_cast<int32>(regOffset[areg]);
+#if RS_DUMP
+        std::string r = reg <= R28 ? "R" : "V";
+        M_LOG << r << (reg - 1) << " exit restore in BB " << bid << " Offset = " << offset << "\n";
+        PrintSaveLocs(reg);
+#endif
+
+        /* restore is always single from saved offset */
+        RegType regType = AArch64isa::IsGPRegister(reg) ? kRegTyInt : kRegTyFloat;
+        AArch64GenProEpilog::AppendInstructionPopSingle(*cgFunc, reg, regType, offset);
+      }
+      FOR_BB_INSNS(insn, aarchCGFunc->GetDummyBB()) {
+        insn->SetDoNotRemove(true);
+      }
+      if (sp->insertAtLastMinusOne) {
+        bb->InsertAtEndMinus1(*aarchCGFunc->GetDummyBB());
+      } else {
+        bb->InsertAtEnd(*aarchCGFunc->GetDummyBB());
+      }
+    }
+  }
+  cgFunc->SetCurBB(*saveBB);
+}
+
+/* Callee-save registers save/restore placement optimization */
+void AArch64RegSavesOpt::Run() {
+  // DotGenerator::GenerateDot("SR", *cgFunc, cgFunc->GetMirModule(), true, cgFunc->GetName());
+  if (Globals::GetInstance()->GetOptimLevel() <= CGOptions::kLevel1 || !cgFunc->GetMirModule().IsCModule()) {
+    return;
+  }
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+
+  Bfs localBfs(*cgFunc, *memPool);
+  bfs = &localBfs;
+  bfs->ComputeBlockOrder();
+#if RS_DUMP
+  M_LOG << "##Calleeregs Placement for: " << cgFunc->GetName() << "\n";
+  PrintBBs();
+#endif
+
+  /* Determined 1st def and last use of all callee-saved registers used
+     for all BBs */
+  InitData();
+  GenRegDefUse();
+
+  if (CGOptions::UseSsaPreSave()) {
+    /* Use ssapre */
+    if (cgFunc->GetNeedStackProtect() || CheckForUseBeforeDefPath()) {
+      for (auto reg : aarchCGFunc->GetCalleeSavedRegs()) {
+        if (reg != RFP && reg != RLR) {
+          aarchCGFunc->GetProEpilogSavedRegs().push_back(reg);
+        }
+      }
+      return;
+    }
+    DetermineCalleeSaveLocationsPre();
+  } else {
+    /* Determine save sites at dominators of 1st def with no live-in and
+       not within loop */
+    /* Obsolete, to be deleted */
+    DetermineCalleeSaveLocationsDoms();
+  }
+
+  /* Determine restore sites */
+  DetermineCalleeRestoreLocations();
+
+#ifdef VERIFY
+  /* Verify saves/restores are in pair */
+  std::vector<regno_t> rlist = { R19, R20, R21, R22, R23, R24, R25, R26, R27, R28 };
+  for (auto reg : rlist) {
+    M_LOG << "Verify calleeregs_placement data for R" << (reg - 1) << ":\n";
+    std::set<BB*, BBIdCmp> visited;
+    uint32 saveBid = 0;
+    uint32 restoreBid = 0;
+    Verify(reg, cgFunc->GetFirstBB(), &visited, &saveBid, &restoreBid);
+    M_LOG << "\nVerify Done\n";
+  }
+#endif
+
+  /* Assign stack offset to each shrinkwrapped register, skip over the offsets
+     for registers saved in prolog */
+  SetupRegOffsets();
+
+  /* Generate callee save instrs at found sites */
+  InsertCalleeSaveCode();
+
+  /* Generate callee restores at found sites */
+  InsertCalleeRestoreCode();
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_rematerialize.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_rematerialize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dd44849a78419ee64476227b1a4353323f3e19ca
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_rematerialize.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "aarch64_rematerialize.h"
+#include "aarch64_color_ra.h"
+#include "aarch64_insn.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+bool AArch64Rematerializer::IsRematerializableForConstval(int64 val, uint32 bitLen) const {
+  if (val >= -kMax16UnsignedImm && val <= kMax16UnsignedImm) {
+    return true;
+  }
+  auto uval = static_cast<uint64>(val);
+  if (IsMoveWidableImmediate(uval, bitLen)) {
+    return true;
+  }
+  return IsBitmaskImmediate(uval, bitLen);
+}
+
+bool AArch64Rematerializer::IsRematerializableForDread(int32 offset) const {
+  /* check stImm.GetOffset() is in addri12 */
+  return IsBitSizeImmediate(static_cast<uint64>(static_cast<int64>(offset)), kMaxImmVal12Bits, 0);
+}
+
+std::vector<Insn*> AArch64Rematerializer::RematerializeForConstval(CGFunc &cgFunc,
+    RegOperand &regOp, const LiveRange &lr) {
+  std::vector<Insn*> insns;
+  auto intConst = static_cast<const MIRIntConst*>(rematInfo.mirConst);
+  ImmOperand *immOp = &cgFunc.GetOpndBuilder()->CreateImm(
+      GetPrimTypeBitSize(intConst->GetType().GetPrimType()), intConst->GetExtValue());
+  MOperator movOp = (lr.GetSpillSize() == k32BitSize) ? MOP_wmovri32 : MOP_xmovri64;
+  insns.push_back(&cgFunc.GetInsnBuilder()->BuildInsn(movOp, regOp, *immOp));
+  return insns;
+}
+
+std::vector<Insn*> AArch64Rematerializer::RematerializeForAddrof(CGFunc &cgFunc,
+    RegOperand &regOp, int32 offset) {
+  std::vector<Insn*> insns;
+  auto &a64Func = static_cast<AArch64CGFunc&>(cgFunc);
+  const MIRSymbol *symbol = rematInfo.sym;
+
+  StImmOperand &stImm = a64Func.CreateStImmOperand(*symbol, offset, 0);
+  if ((symbol->GetStorageClass() == kScAuto) || (symbol->GetStorageClass() == kScFormal)) {
+    SymbolAlloc *symLoc = cgFunc.GetMemlayout()->GetSymAllocInfo(symbol->GetStIndex());
+    ImmOperand *offsetOp = &cgFunc.GetOpndBuilder()->CreateImm(k64BitSize,
+        static_cast<int64>(cgFunc.GetBaseOffset(*symLoc)) + offset);
+    Insn *insn = &cgFunc.GetInsnBuilder()->BuildInsn(MOP_xaddrri12, regOp,
+        *cgFunc.GetBaseReg(*symLoc), *offsetOp);
+    if (cgFunc.GetCG()->GenerateVerboseCG()) {
+      std::string comm = "local/formal var: " + symbol->GetName();
+      insn->SetComment(comm);
+    }
+    insns.push_back(insn);
+  } else {
+    Insn *insn = &cgFunc.GetInsnBuilder()->BuildInsn(MOP_xadrp, regOp, stImm);
+    insns.push_back(insn);
+    if (!addrUpper && CGOptions::IsPIC() && ((symbol->GetStorageClass() == kScGlobal) ||
+        (symbol->GetStorageClass() == kScExtern))) {
+      /* ldr     x0, [x0, #:got_lo12:Ljava_2Flang_2FSystem_3B_7Cout] */
+      OfstOperand &offsetOp = a64Func.CreateOfstOpnd(*symbol, offset, 0);
+      MemOperand &memOpnd = a64Func.GetOrCreateMemOpnd(MemOperand::kAddrModeBOi,
+          GetPointerSize() * kBitsPerByte, &regOp, nullptr, &offsetOp, nullptr);
+      MOperator ldOp = (memOpnd.GetSize() == k64BitSize) ? MOP_xldr : MOP_wldr;
+      insn = &cgFunc.GetInsnBuilder()->BuildInsn(ldOp, regOp, memOpnd);
+      insns.push_back(insn);
+      if (offset > 0) {
+        ImmOperand &ofstOpnd = cgFunc.GetOpndBuilder()->CreateImm(k32BitSize, offset);
+        insns.push_back(&cgFunc.GetInsnBuilder()->BuildInsn(MOP_xaddrri12, regOp, regOp, ofstOpnd));
+      }
+    } else if (!addrUpper) {
+      insns.push_back(&cgFunc.GetInsnBuilder()->BuildInsn(MOP_xadrpl12, regOp, regOp, stImm));
+    }
+  }
+  return insns;
+}
+
+std::vector<Insn*> AArch64Rematerializer::RematerializeForDread(CGFunc &cgFunc,
+    RegOperand &regOp, int32 offset, PrimType type) {
+  std::vector<Insn*> insns;
+  auto &a64Func = static_cast<AArch64CGFunc&>(cgFunc);
+  RegOperand *regOp64 = &cgFunc.GetOpndBuilder()->CreatePReg(regOp.GetRegisterNumber(),
+      k64BitSize, regOp.GetRegisterType());
+  uint32 dataSize = GetPrimTypeBitSize(type);
+  MemOperand *spillMemOp = &a64Func.GetOrCreateMemOpndAfterRa(*rematInfo.sym,
+      offset, dataSize, false, regOp64, insns);
+  Insn *ldInsn = cgFunc.GetTargetRegInfo()->BuildLdrInsn(dataSize, type, regOp, *spillMemOp);
+  insns.push_back(ldInsn);
+  return insns;
+}
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_schedule.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_schedule.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..28b74b6f8e561b6171755763212f29fced444534
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_schedule.cpp
@@ -0,0 +1,1515 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "aarch64_schedule.h"
+#include <ctime>
+#include "aarch64_cg.h"
+#include "aarch64_operand.h"
+#include "aarch64_data_dep_base.h"
+#include "control_dep_analysis.h"
+#include "pressure.h"
+
+/*
+ * This phase is Instruction Scheduling.
+ * There is a local list scheduling, it is scheduling in basic block.
+ * The entry is AArch64Schedule::ListScheduling, will traversal all basic block,
+ * for a basic block:
+ *  1. build a dependence graph;
+ *  2. combine clinit pairs and str&ldr pairs;
+ *  3. reorder instructions.
+ */
+namespace maplebe {
+namespace {
+constexpr uint32 kClinitAdvanceCycle = 10;
+constexpr uint32 kAdrpLdrAdvanceCycle = 2;
+constexpr uint32 kClinitTailAdvanceCycle = 4;
+constexpr uint32 kSecondToLastNode = 2;
+}
+
+uint32 AArch64Schedule::maxUnitIndex = 0;
+/* reserve two register for special purpose */
+int AArch64Schedule::intRegPressureThreshold = static_cast<int>(R27 - R0);
+int AArch64Schedule::fpRegPressureThreshold = static_cast<int>(V30 - V0);
+int AArch64Schedule::intCalleeSaveThresholdBase = static_cast<int>(R29 - R19);
+int AArch64Schedule::intCalleeSaveThresholdEnhance = static_cast<int>(R30 - R19);
+int AArch64Schedule::fpCalleeSaveThreshold = static_cast<int>(R16 - R8);
+/* Init schedule's data struction. */
+void AArch64Schedule::Init() {
+  readyList.clear();
+  nodeSize = nodes.size();
+  lastSeparatorIndex = 0;
+  mad->ReleaseAllUnits();
+  DepNode *node = nodes[0];
+
+  ASSERT(node->GetType() == kNodeTypeSeparator, "CG internal error, the first node should be a separator node.");
+
+  if (CGOptions::IsDruteForceSched() || CGOptions::IsSimulateSched()) {
+    for (auto nodeTemp : nodes) {
+      nodeTemp->SetVisit(0);
+      nodeTemp->SetState(kNormal);
+      nodeTemp->SetSchedCycle(0);
+      nodeTemp->SetEStart(0);
+      nodeTemp->SetLStart(0);
+    }
+  }
+
+  readyList.emplace_back(node);
+  node->SetState(kReady);
+
+  /* Init validPredsSize and validSuccsSize. */
+  for (auto nodeTemp : nodes) {
+    nodeTemp->SetValidPredsSize(nodeTemp->GetPreds().size());
+    nodeTemp->SetValidSuccsSize(nodeTemp->GetSuccs().size());
+  }
+}
+
+/*
+ *  A insn which can be combine should meet this conditions:
+ *  1. it is str/ldr insn;
+ *  2. address mode is kAddrModeBOi, [baseReg, offset];
+ *  3. the register operand size equal memory operand size;
+ *  4. if define USE_32BIT_REF, register operand size should be 4 byte;
+ *  5. for stp/ldp, the imm should be within -512 and 504(64bit), or -256 and 252(32bit);
+ *  6. pair instr for 8/4 byte registers must have multiple of 8/4 for imm.
+ *  If insn can be combine, return true.
+ */
+bool AArch64Schedule::CanCombine(const Insn &insn) const {
+  MOperator opCode = insn.GetMachineOpcode();
+  if ((opCode != MOP_xldr) && (opCode != MOP_wldr) && (opCode != MOP_dldr) && (opCode != MOP_sldr) &&
+      (opCode != MOP_xstr) && (opCode != MOP_wstr) && (opCode != MOP_dstr) && (opCode != MOP_sstr)) {
+    return false;
+  }
+
+  ASSERT(insn.GetOperand(1).IsMemoryAccessOperand(), "expects mem operands");
+  auto &memOpnd = static_cast<MemOperand&>(insn.GetOperand(1));
+  MemOperand::AArch64AddressingMode addrMode = memOpnd.GetAddrMode();
+  if ((addrMode != MemOperand::kAddrModeBOi) || !memOpnd.IsIntactIndexed()) {
+    return false;
+  }
+
+  auto &regOpnd = static_cast<RegOperand&>(insn.GetOperand(0));
+  if (regOpnd.GetSize() != memOpnd.GetSize()) {
+    return false;
+  }
+
+  uint32 size = regOpnd.GetSize() >> kLog2BitsPerByte;
+#ifdef USE_32BIT_REF
+  if (insn.IsAccessRefField() && (size > (kIntregBytelen >> 1))) {
+    return false;
+  }
+#endif /* USE_32BIT_REF */
+
+  OfstOperand *offset = memOpnd.GetOffsetImmediate();
+  if (offset == nullptr) {
+    return false;
+  }
+  int32 offsetValue = static_cast<int32>(offset->GetOffsetValue());
+  if (size == kIntregBytelen) {              /* 64 bit */
+    if ((offsetValue <= kStpLdpImm64LowerBound) || (offsetValue >= kStpLdpImm64UpperBound)) {
+      return false;
+    }
+  } else if (size == (kIntregBytelen >> 1)) { /* 32 bit */
+    if ((offsetValue <= kStpLdpImm32LowerBound) || (offsetValue >= kStpLdpImm32UpperBound)) {
+      return false;
+    }
+  }
+
+  /* pair instr for 8/4 byte registers must have multiple of 8/4 for imm */
+  if ((static_cast<uint32>(offsetValue) % size) != 0) {
+    return false;
+  }
+  return true;
+}
+
+/* After building dependence graph, combine str&ldr pairs. */
+void AArch64Schedule::MemoryAccessPairOpt() {
+  Init();
+  std::vector<DepNode*> memList;
+
+  while ((!readyList.empty()) || !memList.empty()) {
+    DepNode *readNode = nullptr;
+    if (!readyList.empty()) {
+      readNode = readyList[0];
+      readyList.erase(readyList.begin());
+    } else {
+      if (memList[0]->GetType() != kNodeTypeEmpty) {
+        FindAndCombineMemoryAccessPair(memList);
+      }
+      readNode = memList[0];
+      memList.erase(memList.begin());
+    }
+
+    /* schedule readNode */
+    CHECK_FATAL(readNode != nullptr, "readNode is null in MemoryAccessPairOpt");
+    readNode->SetState(kScheduled);
+
+    /* add readNode's succs to readyList or memList. */
+    for (auto succLink : readNode->GetSuccs()) {
+      DepNode &succNode = succLink->GetTo();
+      succNode.DescreaseValidPredsSize();
+      if (succNode.GetValidPredsSize() == 0) {
+        ASSERT(succNode.GetState() == kNormal, "schedule state should be kNormal");
+        succNode.SetState(kReady);
+        ASSERT(succNode.GetInsn() != nullptr, "insn can't be nullptr!");
+        if (CanCombine(*succNode.GetInsn())) {
+          memList.emplace_back(&succNode);
+        } else {
+          readyList.emplace_back(&succNode);
+        }
+      }
+    }
+  }
+
+  for (auto node : nodes) {
+    node->SetVisit(0);
+    node->SetState(kNormal);
+  }
+}
+
+/* Find and combine correct MemoryAccessPair for memList[0]. */
+void AArch64Schedule::FindAndCombineMemoryAccessPair(const std::vector<DepNode*> &memList) {
+  ASSERT(!memList.empty(), "memList should not be empty");
+  CHECK_FATAL(memList[0]->GetInsn() != nullptr, "memList[0]'s insn should not be nullptr");
+  MemOperand *currMemOpnd = static_cast<MemOperand*>(memList[0]->GetInsn()->GetMemOpnd());
+  ASSERT(currMemOpnd != nullptr, "opnd should not be nullptr");
+  ASSERT(currMemOpnd->IsMemoryAccessOperand(), "opnd should be memOpnd");
+  int32 currOffsetVal = static_cast<int32>(currMemOpnd->GetOffsetImmediate()->GetOffsetValue());
+  MOperator currMop = memList[0]->GetInsn()->GetMachineOpcode();
+  /* find a depNode to combine with memList[0], and break; */
+  for (auto it = std::next(memList.begin(), 1); it != memList.end(); ++it) {
+    ASSERT((*it)->GetInsn() != nullptr, "null ptr check");
+
+    if (currMop == (*it)->GetInsn()->GetMachineOpcode()) {
+      MemOperand *nextMemOpnd = static_cast<MemOperand*>((*it)->GetInsn()->GetMemOpnd());
+      CHECK_FATAL(nextMemOpnd != nullptr, "opnd should not be nullptr");
+      CHECK_FATAL(nextMemOpnd->IsMemoryAccessOperand(), "opnd should be MemOperand");
+      int32 nextOffsetVal = static_cast<int32>(nextMemOpnd->GetOffsetImmediate()->GetOffsetValue());
+      uint32 size = currMemOpnd->GetSize() >> kLog2BitsPerByte;
+      if ((nextMemOpnd->GetBaseRegister() == currMemOpnd->GetBaseRegister()) &&
+          (nextMemOpnd->GetSize() == currMemOpnd->GetSize()) &&
+          (static_cast<uint32>(abs(nextOffsetVal - currOffsetVal)) == size)) {
+        /*
+         * In ARM Architecture Reference Manual ARMv8, for ARMv8-A architecture profile
+         * LDP on page K1-6125 declare that ldp can't use same reg
+         */
+        if (((currMop == MOP_xldr) || (currMop == MOP_sldr) || (currMop == MOP_dldr) || (currMop == MOP_wldr)) &&
+            &(memList[0]->GetInsn()->GetOperand(0)) == &((*it)->GetInsn()->GetOperand(0))) {
+          continue;
+        }
+        if (static_cast<RegOperand&>((*it)->GetInsn()->GetOperand(0)).GetRegisterType() !=
+            static_cast<RegOperand&>(memList[0]->GetInsn()->GetOperand(0)).GetRegisterType()) {
+          continue;
+        }
+
+        if (LIST_SCHED_DUMP_REF) {
+          LogInfo::MapleLogger() << "Combine insn: " << "\n";
+          memList[0]->GetInsn()->Dump();
+          (*it)->GetInsn()->Dump();
+        }
+        ddb->CombineMemoryAccessPair(*memList[0], **it, nextOffsetVal > currOffsetVal);
+        if (LIST_SCHED_DUMP_REF) {
+          LogInfo::MapleLogger() << "To: " << "\n";
+          memList[0]->GetInsn()->Dump();
+        }
+        break;
+      }
+    }
+  }
+}
+
+/* combine clinit pairs. */
+void AArch64Schedule::ClinitPairOpt() {
+  for (auto it = nodes.begin(); it != nodes.end(); ++it) {
+    auto nextIt = std::next(it, 1);
+    if (nextIt == nodes.end()) {
+      return;
+    }
+
+    if ((*it)->GetInsn()->GetMachineOpcode() == MOP_adrp_ldr) {
+      if ((*nextIt)->GetInsn()->GetMachineOpcode() == MOP_clinit_tail) {
+        ddb->CombineClinit(**it, **(nextIt), false);
+      } else if ((*nextIt)->GetType() == kNodeTypeSeparator) {
+        nextIt = std::next(nextIt, 1);
+        if (nextIt == nodes.end()) {
+          return;
+        }
+        if ((*nextIt)->GetInsn()->GetMachineOpcode() == MOP_clinit_tail) {
+          /* Do something. */
+          ddb->CombineClinit(**it, **(nextIt), true);
+        }
+      }
+    }
+  }
+}
+
+/* Return the next node's index who is kNodeTypeSeparator. */
+uint32 AArch64Schedule::GetNextSepIndex() const {
+  return ((lastSeparatorIndex + kMaxDependenceNum) < nodeSize) ? (lastSeparatorIndex + kMaxDependenceNum)
+                                                               : (nodes.size() - 1);
+}
+
+/* Do register pressure schduling. */
+void AArch64Schedule::RegPressureScheduling(BB &bb, MapleVector<DepNode*> &nodes) {
+  RegPressureSchedule *regSchedule = memPool.New<RegPressureSchedule>(cgFunc, alloc);
+  /*
+   * Get physical register amount currently
+   * undef, Int Reg, Float Reg, Flag Reg
+   */
+  const std::vector<int32> kRegNumVec = { 0, V0, (kMaxRegNum - V0) + 1, 1 };
+  regSchedule->InitBBInfo(bb, memPool, nodes);
+  regSchedule->BuildPhyRegInfo(kRegNumVec);
+  regSchedule->DoScheduling(nodes);
+}
+
+/*
+ * Compute earliest start of the node,
+ * return value : the maximum estart.
+ */
+uint32 AArch64Schedule::ComputeEstart(uint32 cycle) {
+  std::vector<DepNode*> readyNodes;
+  uint32 maxIndex = GetNextSepIndex();
+
+  if (CGOptions::IsDebugSched()) {
+    /* Check validPredsSize. */
+    for (uint32 i = lastSeparatorIndex; i <= maxIndex; ++i) {
+      DepNode *node = nodes[i];
+      int32 schedNum = 0;
+      for (const auto *predLink : node->GetPreds()) {
+        if (predLink->GetFrom().GetState() == kScheduled) {
+          ++schedNum;
+        }
+      }
+      ASSERT((node->GetPreds().size() - schedNum) == node->GetValidPredsSize(), "validPredsSize error.");
+    }
+  }
+
+  ASSERT(nodes[maxIndex]->GetType() == kNodeTypeSeparator,
+         "CG internal error, nodes[maxIndex] should be a separator node.");
+
+  (void)readyNodes.insert(readyNodes.begin(), readyList.begin(), readyList.end());
+
+  uint32 maxEstart = cycle;
+  for (uint32 i = lastSeparatorIndex; i <= maxIndex; ++i) {
+    DepNode *node = nodes[i];
+    node->SetVisit(0);
+  }
+
+  for (auto *node : readyNodes) {
+    ASSERT(node->GetState() == kReady, "CG internal error, all nodes in ready list should be ready.");
+    if (node->GetEStart() < cycle) {
+      node->SetEStart(cycle);
+    }
+  }
+
+  while (!readyNodes.empty()) {
+    DepNode *node = readyNodes.front();
+    readyNodes.erase(readyNodes.begin());
+
+    for (const auto *succLink : node->GetSuccs()) {
+      DepNode &succNode = succLink->GetTo();
+      if (succNode.GetType() == kNodeTypeSeparator) {
+        continue;
+      }
+
+      if (succNode.GetEStart() < (node->GetEStart() + succLink->GetLatency())) {
+        succNode.SetEStart(node->GetEStart() + succLink->GetLatency());
+      }
+      maxEstart = (maxEstart < succNode.GetEStart() ? succNode.GetEStart() : maxEstart);
+      succNode.IncreaseVisit();
+      if ((succNode.GetVisit() >= succNode.GetValidPredsSize()) && (succNode.GetType() != kNodeTypeSeparator)) {
+        readyNodes.emplace_back(&succNode);
+      }
+      ASSERT(succNode.GetVisit() <= succNode.GetValidPredsSize(), "CG internal error.");
+    }
+  }
+
+  return maxEstart;
+}
+
+/* Compute latest start of the node. */
+void AArch64Schedule::ComputeLstart(uint32 maxEstart) {
+  /* std::vector is better than std::queue in run time */
+  std::vector<DepNode*> readyNodes;
+  uint32 maxIndex = GetNextSepIndex();
+
+  ASSERT(nodes[maxIndex]->GetType() == kNodeTypeSeparator,
+         "CG internal error, nodes[maxIndex] should be a separator node.");
+
+  for (uint32 i = lastSeparatorIndex; i <= maxIndex; ++i) {
+    DepNode *node = nodes[i];
+    node->SetLStart(maxEstart);
+    node->SetVisit(0);
+  }
+
+  readyNodes.emplace_back(nodes[maxIndex]);
+  while (!readyNodes.empty()) {
+    DepNode *node = readyNodes.front();
+    readyNodes.erase(readyNodes.begin());
+    for (const auto *predLink : node->GetPreds()) {
+      DepNode &predNode = predLink->GetFrom();
+      if (predNode.GetState() == kScheduled) {
+        continue;
+      }
+
+      if (predNode.GetLStart() > (node->GetLStart() - predLink->GetLatency())) {
+        predNode.SetLStart(node->GetLStart() - predLink->GetLatency());
+      }
+      predNode.IncreaseVisit();
+      if ((predNode.GetVisit() >= predNode.GetValidSuccsSize()) && (predNode.GetType() != kNodeTypeSeparator)) {
+        readyNodes.emplace_back(&predNode);
+      }
+
+      ASSERT(predNode.GetVisit() <= predNode.GetValidSuccsSize(), "CG internal error.");
+    }
+  }
+}
+
+/* Compute earliest start and latest start of the node that is in readyList and not be scheduled. */
+void AArch64Schedule::UpdateELStartsOnCycle(uint32 cycle) {
+  ComputeLstart(ComputeEstart(cycle));
+}
+
+/*
+ * If all unit of this node need when it be scheduling is free, this node can be scheduled,
+ * Return true.
+ */
+bool DepNode::CanBeScheduled() const {
+  for (uint32 i = 0; i < unitNum; ++i) {
+    Unit *unit = units[i];
+    if (unit != nullptr) {
+      if (!unit->IsFree(i)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+/* Mark those unit that this node need occupy unit when it is being scheduled. */
+void DepNode::OccupyUnits() {
+  for (uint32 i = 0; i < unitNum; ++i) {
+    Unit *unit = units[i];
+    if (unit != nullptr) {
+      unit->Occupy(*insn, i);
+    }
+  }
+}
+
+/* Get unit kind of this node's units[0]. */
+uint32 DepNode::GetUnitKind() const {
+  uint32 retValue = 0;
+  if ((units == nullptr) || (units[0] == nullptr)) {
+    return retValue;
+  }
+
+  switch (units[0]->GetUnitId()) {
+    case kUnitIdSlotD:
+      retValue |= kUnitKindSlot0;
+      break;
+    case kUnitIdAgen:
+    case kUnitIdSlotSAgen:
+      retValue |= kUnitKindAgen;
+      break;
+    case kUnitIdSlotDAgen:
+      retValue |= kUnitKindAgen;
+      retValue |= kUnitKindSlot0;
+      break;
+    case kUnitIdHazard:
+    case kUnitIdSlotSHazard:
+      retValue |= kUnitKindHazard;
+      break;
+    case kUnitIdCrypto:
+      retValue |= kUnitKindCrypto;
+      break;
+    case kUnitIdMul:
+    case kUnitIdSlotSMul:
+      retValue |= kUnitKindMul;
+      break;
+    case kUnitIdDiv:
+      retValue |= kUnitKindDiv;
+      break;
+    case kUnitIdBranch:
+    case kUnitIdSlotSBranch:
+      retValue |= kUnitKindBranch;
+      break;
+    case kUnitIdStAgu:
+      retValue |= kUnitKindStAgu;
+      break;
+    case kUnitIdLdAgu:
+      retValue |= kUnitKindLdAgu;
+      break;
+    case kUnitIdFpAluS:
+    case kUnitIdFpAluD:
+      retValue |= kUnitKindFpAlu;
+      break;
+    case kUnitIdFpMulS:
+    case kUnitIdFpMulD:
+      retValue |= kUnitKindFpMul;
+      break;
+    case kUnitIdFpDivS:
+    case kUnitIdFpDivD:
+      retValue |= kUnitKindFpDiv;
+      break;
+    case kUnitIdSlot0LdAgu:
+      retValue |= kUnitKindSlot0;
+      retValue |= kUnitKindLdAgu;
+      break;
+    case kUnitIdSlot0StAgu:
+      retValue |= kUnitKindSlot0;
+      retValue |= kUnitKindStAgu;
+      break;
+    default:
+      break;
+  }
+
+  return retValue;
+}
+
+/* Count unit kinds to an array. Each element of the array indicates the unit kind number of a node set. */
+void AArch64Schedule::CountUnitKind(const DepNode &depNode, uint32 array[], const uint32 arraySize) const {
+  (void)arraySize;
+  ASSERT(arraySize >= kUnitKindLast, "CG internal error. unit kind number is not correct.");
+  uint32 unitKind = depNode.GetUnitKind();
+  uint32 index = static_cast<uint32>(__builtin_ffs(unitKind));
+  while (index != 0) {
+    ASSERT(index < kUnitKindLast, "CG internal error. index error.");
+    ++array[index];
+    unitKind &= ~(1u << (index - 1u));
+    index = static_cast<uint32>(__builtin_ffs(unitKind));
+  }
+}
+
+/* Check if a node use a specific unit kind. */
+bool AArch64Schedule::IfUseUnitKind(const DepNode &depNode, uint32 index) {
+  uint32 unitKind = depNode.GetUnitKind();
+  uint32 idx = static_cast<uint32>(__builtin_ffs(unitKind));
+  while (idx != 0) {
+    ASSERT(index < kUnitKindLast, "CG internal error. index error.");
+    if (idx == index) {
+      return true;
+    }
+    unitKind &= ~(1u << (idx - 1u));
+    idx = static_cast<uint32>(__builtin_ffs(unitKind));
+  }
+
+  return false;
+}
+
+/* A sample schedule according dependence graph only, to verify correctness of dependence graph. */
+void AArch64Schedule::RandomTest() {
+  Init();
+  nodes.clear();
+
+  while (!readyList.empty()) {
+    DepNode *currNode = readyList.back();
+    currNode->SetState(kScheduled);
+    readyList.pop_back();
+    nodes.emplace_back(currNode);
+
+    for (auto succLink : currNode->GetSuccs()) {
+      DepNode &succNode = succLink->GetTo();
+      bool ready = true;
+      for (auto predLink : succNode.GetPreds()) {
+        DepNode &predNode = predLink->GetFrom();
+        if (predNode.GetState() != kScheduled) {
+          ready = false;
+          break;
+        }
+      }
+
+      if (ready) {
+        ASSERT(succNode.GetState() == kNormal, "succNode must be kNormal");
+        readyList.emplace_back(&succNode);
+        succNode.SetState(kReady);
+      }
+    }
+  }
+}
+
+/* Remove target from readyList. */
+void AArch64Schedule::EraseNodeFromReadyList(const DepNode &target) {
+  EraseNodeFromNodeList(target, readyList);
+}
+
+/* Remove target from nodeList. */
+void AArch64Schedule::EraseNodeFromNodeList(const DepNode &target, MapleVector<DepNode*> &nodeList) {
+  for (auto it = nodeList.begin(); it != nodeList.end(); ++it) {
+    if ((*it) == &target) {
+      nodeList.erase(it);
+      return;
+    }
+  }
+
+  ASSERT(false, "CG internal error, erase node fail.");
+}
+
+/* Dump all node of availableReadyList schedule information in current cycle. */
+void AArch64Schedule::DumpDebugInfo(const ScheduleProcessInfo &scheduleInfo) {
+  LogInfo::MapleLogger() << "Current cycle[ " << scheduleInfo.GetCurrCycle() << " ], Available in readyList is : \n";
+  for (auto node : scheduleInfo.GetAvailableReadyList()) {
+    LogInfo::MapleLogger() << "NodeIndex[ " << node->GetIndex()
+                           << " ], Estart[ " << node->GetEStart() << " ], Lstart[ ";
+    LogInfo::MapleLogger() << node->GetLStart() << " ], slot[ ";
+    LogInfo::MapleLogger() <<
+        (node->GetReservation() == nullptr ? "SlotNone" : node->GetReservation()->GetSlotName()) << " ], ";
+    LogInfo::MapleLogger() << "succNodeNum[ " << node->GetSuccs().size() << " ], ";
+    node->GetInsn()->Dump();
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+/*
+ * Select a node from availableReadyList according to some heuristic rules, then:
+ *   1. change targetNode's schedule information;
+ *   2. try to add successors of targetNode to readyList;
+ *   3. update unscheduled node set, when targetNode is last kNodeTypeSeparator;
+ *   4. update AdvanceCycle.
+ */
+void AArch64Schedule::SelectNode(AArch64ScheduleProcessInfo &scheduleInfo) {
+  auto &availableReadyList = scheduleInfo.GetAvailableReadyList();
+  auto it = availableReadyList.begin();
+  DepNode *targetNode = *it;
+  if (availableReadyList.size() > 1) {
+    CalculateMaxUnitKindCount(scheduleInfo);
+    if (GetConsiderRegPressure()) {
+      UpdateReleaseRegInfo(scheduleInfo);
+    }
+    ++it;
+    for (; it != availableReadyList.end(); ++it) {
+      if (CompareDepNode(**it, *targetNode, scheduleInfo)) {
+        targetNode = *it;
+      }
+    }
+  }
+  /* The priority of free-reg node is higher than pipeline */
+  while (!targetNode->CanBeScheduled()) {
+    scheduleInfo.IncCurrCycle();
+    mad->AdvanceCycle();
+  }
+  if (GetConsiderRegPressure() && !scheduleInfo.IsFirstSeparator()) {
+    UpdateLiveRegSet(scheduleInfo, *targetNode);
+  }
+  /* push target node into scheduled nodes and turn it into kScheduled state */
+  scheduleInfo.PushElemIntoScheduledNodes(targetNode);
+
+  EraseNodeFromReadyList(*targetNode);
+
+  if (CGOptions::IsDebugSched()) {
+    LogInfo::MapleLogger() << "TargetNode : ";
+    targetNode->GetInsn()->Dump();
+    LogInfo::MapleLogger() << "\n";
+  }
+
+  /* Update readyList. */
+  UpdateReadyList(*targetNode, readyList, true);
+
+  if (targetNode->GetType() == kNodeTypeSeparator) {
+    /* If target node is separator node, update lastSeparatorIndex and calculate those depNodes's estart and lstart
+     * between current separator node  and new Separator node.
+     */
+    if (!scheduleInfo.IsFirstSeparator()) {
+      lastSeparatorIndex += kMaxDependenceNum;
+      UpdateELStartsOnCycle(scheduleInfo.GetCurrCycle());
+    } else {
+      scheduleInfo.ResetIsFirstSeparator();
+    }
+  }
+
+  UpdateAdvanceCycle(scheduleInfo, *targetNode);
+}
+
+void AArch64Schedule::UpdateAdvanceCycle(AArch64ScheduleProcessInfo &scheduleInfo, const DepNode &targetNode) const {
+  switch (targetNode.GetInsn()->GetLatencyType()) {
+    case kLtClinit:
+      scheduleInfo.SetAdvanceCycle(kClinitAdvanceCycle);
+      break;
+    case kLtAdrpLdr:
+      scheduleInfo.SetAdvanceCycle(kAdrpLdrAdvanceCycle);
+      break;
+    case kLtClinitTail:
+      scheduleInfo.SetAdvanceCycle(kClinitTailAdvanceCycle);
+      break;
+    default:
+      break;
+  }
+
+  if ((scheduleInfo.GetAdvanceCycle() == 0) && mad->IsFullIssued()) {
+    if (targetNode.GetEStart() > scheduleInfo.GetCurrCycle()) {
+      scheduleInfo.SetAdvanceCycle(1 + targetNode.GetEStart() - scheduleInfo.GetCurrCycle());
+    } else {
+      scheduleInfo.SetAdvanceCycle(1);
+    }
+  }
+}
+
+/*
+ * Advance mad's cycle until info's advanceCycle equal zero,
+ * and then clear info's availableReadyList.
+ */
+void AArch64Schedule::UpdateScheduleProcessInfo(AArch64ScheduleProcessInfo &info) const {
+  while (info.GetAdvanceCycle() > 0) {
+    info.IncCurrCycle();
+    mad->AdvanceCycle();
+    info.DecAdvanceCycle();
+  }
+  info.ClearAvailableReadyList();
+}
+
+/*
+ * Forward traversal readyList, if a node in readyList can be Schedule, add it to availableReadyList.
+ * Return true, if availableReadyList is not empty.
+ */
+bool AArch64Schedule::CheckSchedulable(AArch64ScheduleProcessInfo &info) const {
+  for (auto node : readyList) {
+    if (GetConsiderRegPressure()) {
+      info.PushElemIntoAvailableReadyList(node);
+    } else {
+      if (node->CanBeScheduled() && node->GetEStart() <= info.GetCurrCycle()) {
+        info.PushElemIntoAvailableReadyList(node);
+      }
+    }
+  }
+  return info.AvailableReadyListIsEmpty() ? false : true;
+}
+
+/*
+ * Calculate estimated machine cycle count for an input node series
+ */
+int AArch64Schedule::CalSeriesCycles(const MapleVector<DepNode*> &nodes) const {
+  int currentCycle = 0;
+  /* after an instruction is issued, the minimum cycle count for the next instruction is 1 */
+  int instructionBaseCycleCount = 1;
+  std::map<DepNode*, int> scheduledCycleMap;
+  for (auto node : nodes) {
+    int latencyCycle = 0;
+    /* calculate the latest begin time of this node based on its predecessor's issue time and latency */
+    for (auto pred : node->GetPreds()) {
+      DepNode &from = pred->GetFrom();
+      int latency = static_cast<int>(pred->GetLatency());
+      int fromCycle = scheduledCycleMap[&from];
+      if (fromCycle + latency > latencyCycle) {
+        latencyCycle = fromCycle + latency;
+      }
+    }
+    /* the issue time of this node is the max value between the next cycle and latest begin time */
+    if (currentCycle + instructionBaseCycleCount >= latencyCycle) {
+      currentCycle = currentCycle + instructionBaseCycleCount;
+    } else {
+      currentCycle = latencyCycle;
+    }
+    /* record this node's issue cycle */
+    scheduledCycleMap[node] = currentCycle;
+  }
+  return currentCycle;
+}
+
+/* After building dependence graph, schedule insns. */
+uint32 AArch64Schedule::DoSchedule() {
+  AArch64ScheduleProcessInfo scheduleInfo(nodeSize);
+  Init();
+  UpdateELStartsOnCycle(scheduleInfo.GetCurrCycle());
+  InitLiveRegSet(scheduleInfo);
+  while (!readyList.empty()) {
+    UpdateScheduleProcessInfo(scheduleInfo);
+    /* Check if schedulable */
+    if (!CheckSchedulable(scheduleInfo)) {
+      /* Advance cycle. */
+      scheduleInfo.SetAdvanceCycle(1);
+      continue;
+    }
+
+    if (scheduleInfo.GetLastUpdateCycle() < scheduleInfo.GetCurrCycle()) {
+      scheduleInfo.SetLastUpdateCycle(scheduleInfo.GetCurrCycle());
+    }
+
+    if (CGOptions::IsDebugSched()) {
+      DumpDebugInfo(scheduleInfo);
+    }
+
+    /* Select a node to scheduling */
+    SelectNode(scheduleInfo);
+  }
+
+  ASSERT(scheduleInfo.SizeOfScheduledNodes() == nodes.size(), "CG internal error, Not all nodes scheduled.");
+
+  nodes.clear();
+  (void)nodes.insert(nodes.begin(), scheduleInfo.GetScheduledNodes().begin(), scheduleInfo.GetScheduledNodes().end());
+  /* the second to last node is the true last node, because the last is kNodeTypeSeparator node */
+  ASSERT(nodes.size() - 2 >= 0, "size of nodes should be greater than or equal 2");
+  return (nodes[nodes.size() - 2]->GetSchedCycle());
+}
+
+struct RegisterInfoUnit {
+  RegisterInfoUnit() : intRegNum(0), fpRegNum(0), ccRegNum(0) {}
+  uint32 intRegNum = 0;
+  uint32 fpRegNum = 0;
+  uint32 ccRegNum = 0;
+};
+
+RegisterInfoUnit GetDepNodeDefType(const DepNode &depNode, CGFunc &f) {
+  RegisterInfoUnit rIU;
+  for (auto defRegNO : depNode.GetDefRegnos()) {
+    RegType defRegTy = AArch64ScheduleProcessInfo::GetRegisterType(f, defRegNO);
+    if (defRegTy == kRegTyInt) {
+      rIU.intRegNum++;
+    } else if (defRegTy == kRegTyFloat) {
+      rIU.fpRegNum++;
+    } else if (defRegTy == kRegTyCc) {
+      rIU.ccRegNum++;
+      ASSERT(rIU.ccRegNum <= 1, "spill cc reg?");
+    } else {
+      CHECK_FATAL(false, "NIY aarch64 register type");
+    }
+  }
+  /* call node will not increase reg def pressure */
+  if (depNode.GetInsn() != nullptr && depNode.GetInsn()->IsCall()) {
+    rIU.intRegNum = 0;
+    rIU.fpRegNum = 0;
+  }
+  return rIU;
+}
+
+AArch64Schedule::CSRResult AArch64Schedule::DoCSR(DepNode &node1, DepNode &node2,
+                                                  AArch64ScheduleProcessInfo &scheduleInfo) const {
+  RegisterInfoUnit defRIU1 = GetDepNodeDefType(node1, cgFunc);
+  RegisterInfoUnit defRIU2 = GetDepNodeDefType(node2, cgFunc);
+  /* do not increase callee save pressure before call */
+  if (static_cast<int>(scheduleInfo.SizeOfCalleeSaveLiveRegister(true)) >= intCalleeSaveThreshold) {
+    if (defRIU1.intRegNum > 0 && defRIU2.intRegNum > 0) {
+      CSRResult csrInfo = ScheduleCrossCall(node1, node2);
+      if ((csrInfo == kNode1 && defRIU1.intRegNum >= scheduleInfo.GetFreeIntRegs(node1)) ||
+          (csrInfo == kNode2 && defRIU2.intRegNum >= scheduleInfo.GetFreeIntRegs(node2))) {
+        return csrInfo;
+      }
+    }
+  }
+  if (static_cast<int>(scheduleInfo.SizeOfCalleeSaveLiveRegister(false)) >= fpCalleeSaveThreshold) {
+    if (defRIU1.fpRegNum > 0 && defRIU2.fpRegNum > 0) {
+      CSRResult csrInfo = ScheduleCrossCall(node1, node2);
+      if ((csrInfo == kNode1 && defRIU1.fpRegNum >= scheduleInfo.GetFreeFpRegs(node1)) ||
+          (csrInfo == kNode2 && defRIU2.fpRegNum >= scheduleInfo.GetFreeFpRegs(node2))) {
+        return csrInfo;
+      }
+    }
+  }
+  auto findFreeRegNode = [&](bool isInt)->CSRResult {
+    auto freeRegNodes = isInt ? scheduleInfo.GetFreeIntRegNodeSet() : scheduleInfo.GetFreeFpRegNodeSet();
+    if (freeRegNodes.find(&node1) != freeRegNodes.end() && freeRegNodes.find(&node2) == freeRegNodes.end()) {
+      return kNode1;
+    }
+    if (freeRegNodes.find(&node1) == freeRegNodes.end() && freeRegNodes.find(&node2) != freeRegNodes.end()) {
+      return kNode2;
+    }
+    return kDoCSP;
+  };
+  if (static_cast<int>(scheduleInfo.SizeOfIntLiveRegSet()) >= intRegPressureThreshold) {
+    if (findFreeRegNode(true) != kDoCSP) {
+      return findFreeRegNode(true);
+    }
+  }
+  if (static_cast<int>(scheduleInfo.SizeOfFpLiveRegSet()) >= fpRegPressureThreshold) {
+    if (findFreeRegNode(false) != kDoCSP) {
+      return findFreeRegNode(false);
+    }
+  }
+
+  bool canDoCSPFurther = false;
+  if (static_cast<int>(scheduleInfo.SizeOfIntLiveRegSet()) >= intRegPressureThreshold) {
+    if (defRIU1.intRegNum != defRIU2.intRegNum) {
+      return defRIU1.intRegNum < defRIU2.intRegNum ? kNode1 : kNode2;
+    } else  {
+      canDoCSPFurther = defRIU1.intRegNum == 0;
+    }
+  }
+  if (static_cast<int>(scheduleInfo.SizeOfFpLiveRegSet()) >= fpRegPressureThreshold) {
+    if (defRIU1.fpRegNum != defRIU2.fpRegNum) {
+      return defRIU1.fpRegNum < defRIU2.fpRegNum ? kNode1 : kNode2;
+    } else {
+      canDoCSPFurther = (defRIU1.fpRegNum == 0 && canDoCSPFurther);
+    }
+  }
+  /* if both nodes are going to increase reg pressure, do not do CSP further */
+  return canDoCSPFurther ? kDoCSP : (node1.GetInsn()->GetId() < node2.GetInsn()->GetId() ? kNode1 : kNode2);
+}
+
+AArch64Schedule::CSRResult AArch64Schedule::ScheduleCrossCall(const DepNode &node1, const DepNode &node2) const {
+  uint32 node1ID = node1.GetInsn()->GetId();
+  uint32 node2ID = node2.GetInsn()->GetId();
+  bool order = node1ID < node2ID; /* true -- node1 before node2  false -- node1 after node2 */
+  Insn *beginInsn = order ? node1.GetInsn() : node2.GetInsn();
+  uint32 finialId = order ? node2ID : node1ID;
+  for (Insn *checkInsn = beginInsn; (checkInsn != nullptr && checkInsn->GetId() <= finialId);
+      checkInsn = checkInsn->GetNextMachineInsn()) {
+    if (checkInsn->IsCall()) {
+      return order ? kNode1 : kNode2;
+    }
+  }
+  return kDoCSP;
+};
+
+/*
+ * Comparing priorities of node1 and node2 according to some heuristic rules
+ * return true if node1's priority is higher
+ * crp -- consider reg pressure
+ */
+bool AArch64Schedule::CompareDepNode(DepNode &node1, DepNode &node2, AArch64ScheduleProcessInfo &scheduleInfo) const {
+  /*
+   * strategy CSR -- code schedule for register pressure
+   * if pressure is above the threshold, select the node which can reduce register pressure
+   */
+  if (GetConsiderRegPressure()) {
+    switch (DoCSR(node1, node2, scheduleInfo)) {
+      case kNode1:
+        return true;
+      case kNode2:
+        return false;
+      default:
+        break;
+    }
+  }
+  /* strategy CSP -- code schedule for CPU pipeline */
+  /* less LStart first */
+  if (node1.GetLStart() != node2.GetLStart()) {
+    return node1.GetLStart() < node2.GetLStart();
+  }
+
+  /* max unit kind use */
+  bool use1 = IfUseUnitKind(node1, maxUnitIndex);
+  bool use2 = IfUseUnitKind(node2, maxUnitIndex);
+  if (use1 != use2) {
+    return use1;
+  }
+
+  /* slot0 first */
+  SlotType slotType1 = node1.GetReservation()->GetSlot();
+  SlotType slotType2 = node2.GetReservation()->GetSlot();
+  if (slotType1 == kSlots) {
+    slotType1 = kSlot0;
+  }
+  if (slotType2 == kSlots) {
+    slotType2 = kSlot0;
+  }
+  if (slotType1 != slotType2) {
+    return slotType1 < slotType2;
+  }
+
+  /* more succNodes fisrt */
+  if (node1.GetSuccs().size() != node2.GetSuccs().size()) {
+    return node1.GetSuccs().size() > node2.GetSuccs().size();
+  }
+
+  /* default order */
+  return node1.GetInsn()->GetId() < node2.GetInsn()->GetId();
+}
+
+/*
+ * Calculate number of every unit that used by avaliableReadyList's nodes and save the max in maxUnitIndex
+ */
+void AArch64Schedule::CalculateMaxUnitKindCount(ScheduleProcessInfo &scheduleInfo) const {
+  uint32 unitKindCount[kUnitKindLast] = { 0 };
+  for (auto node : scheduleInfo.GetAvailableReadyList()) {
+    CountUnitKind(*node, unitKindCount, kUnitKindLast);
+  }
+
+  uint32 maxCount = 0;
+  maxUnitIndex = 0;
+  for (size_t i = 1; i < kUnitKindLast; ++i) {
+    if (maxCount < unitKindCount[i]) {
+      maxCount = unitKindCount[i];
+      maxUnitIndex = i;
+    }
+  }
+}
+
+/*
+ * Update the release reg node set
+ * When node in this set is scheduled, register pressure can be reduced
+ */
+void AArch64Schedule::UpdateReleaseRegInfo(AArch64ScheduleProcessInfo &scheduleInfo) {
+  auto &availableReadyList = scheduleInfo.GetAvailableReadyList();
+  scheduleInfo.ClearALLFreeRegNodeSet();
+  /* Traverse availableReadyList and add those can reduce register pressure to release reg node set */
+  for (auto node : availableReadyList) {
+    std::set<regno_t> freeRegNO = CanFreeRegister(*node);
+    if (!freeRegNO.empty()) {
+      scheduleInfo.VaryFreeRegSet(cgFunc, freeRegNO, *node);
+    }
+  }
+}
+
+/*
+ * return registers which an instruction can release after being scheduled
+ */
+std::set<regno_t> AArch64Schedule::CanFreeRegister(const DepNode &node) const {
+  std::set<regno_t> freeRegSet;
+  for (auto reg : node.GetUseRegnos()) {
+    if (RegPressureSchedule::IsLastUse(node, reg)) {
+      freeRegSet.emplace(reg);
+    }
+  }
+  return freeRegSet;
+}
+
+/*
+ * After an instruction is scheduled, update live reg set
+ */
+void AArch64Schedule::UpdateLiveRegSet(AArch64ScheduleProcessInfo &scheduleInfo, const DepNode& node) {
+  /* dealing with def reg, add def reg into the live reg set */
+  size_t i = 1;
+  for (auto &defReg : node.GetDefRegnos()) {
+    if (scheduleInfo.FindIntLiveReg(defReg) == 0 && scheduleInfo.FindFpLiveReg(defReg) == 0) {
+      scheduleInfo.VaryLiveRegSet(cgFunc, defReg, true);
+    }
+    /* delete dead def reg from live reg set because its live range is only 1 cycle */
+    if (node.GetRegDefs(i) == nullptr && liveOutRegNo.find(defReg) == liveOutRegNo.end()) {
+      scheduleInfo.VaryLiveRegSet(cgFunc, defReg, false);
+    }
+    ++i;
+  }
+  /* dealing with use reg, delete use reg from live reg set if this instruction is last use of it */
+  for (auto &useReg : node.GetUseRegnos()) {
+    if (RegPressureSchedule::IsLastUse(node, useReg)) {
+      if ((scheduleInfo.FindIntLiveReg(useReg) != 0 || scheduleInfo.FindFpLiveReg(useReg) != 0) &&
+          liveOutRegNo.find(useReg) == liveOutRegNo.end()) {
+        scheduleInfo.VaryLiveRegSet(cgFunc, useReg, false);
+      }
+    }
+  }
+}
+
+/*
+ * Initialize the live reg set based on the live in reg information
+ */
+void AArch64Schedule::InitLiveRegSet(AArch64ScheduleProcessInfo &scheduleInfo) {
+  if (GetConsiderRegPressure()) {
+    for (auto reg : liveInRegNo) {
+      scheduleInfo.VaryLiveRegSet(cgFunc, reg, true);
+    }
+  }
+}
+
+/*
+ * A simulated schedule:
+ * scheduling instruction in original order to calculate original execute cycles.
+ */
+uint32 AArch64Schedule::SimulateOnly() {
+  uint32 currCycle = 0;
+  uint32 advanceCycle = 0;
+  Init();
+
+  for (uint32 i = 0; i < nodes.size();) {
+    while (advanceCycle > 0) {
+      ++currCycle;
+      mad->AdvanceCycle();
+      --advanceCycle;
+    }
+
+    DepNode *targetNode = nodes[i];
+    if ((currCycle >= targetNode->GetEStart()) && targetNode->CanBeScheduled()) {
+      targetNode->SetSimulateCycle(currCycle);
+      targetNode->OccupyUnits();
+
+      /* Update estart. */
+      for (auto succLink : targetNode->GetSuccs()) {
+        DepNode &succNode = succLink->GetTo();
+        uint32 eStart = currCycle + succLink->GetLatency();
+        if (succNode.GetEStart() < eStart) {
+          succNode.SetEStart(eStart);
+        }
+      }
+
+      if (CGOptions::IsDebugSched()) {
+        LogInfo::MapleLogger() << "[Simulate] TargetNode : ";
+        targetNode->GetInsn()->Dump();
+        LogInfo::MapleLogger() << "\n";
+      }
+
+      switch (targetNode->GetInsn()->GetLatencyType()) {
+        case kLtClinit:
+          advanceCycle = kClinitAdvanceCycle;
+          break;
+        case kLtAdrpLdr:
+          advanceCycle = kAdrpLdrAdvanceCycle;
+          break;
+        case kLtClinitTail:
+          advanceCycle = kClinitTailAdvanceCycle;
+          break;
+        default:
+          break;
+      }
+
+      ++i;
+    } else {
+      advanceCycle = 1;
+    }
+  }
+  /* the second to last node is the true last node, because the last is kNodeTypeSeparator nod */
+  ASSERT(nodes.size() - kSecondToLastNode >= 0, "size of nodes should be greater than or equal 2");
+  return (nodes[nodes.size() - kSecondToLastNode]->GetSimulateCycle());
+}
+
+/* Restore dependence graph to normal CGIR */
+void AArch64Schedule::FinalizeScheduling(BB &bb, const DataDepBase &dataDepBase) {
+  bb.ClearInsns();
+
+  const Insn *prevLocInsn = (bb.GetPrev() != nullptr ? bb.GetPrev()->GetLastLoc() : nullptr);
+  for (auto node : nodes) {
+    /* Append comments first */
+    for (auto comment : node->GetComments()) {
+      if (comment->GetPrev() != nullptr && comment->GetPrev()->IsDbgInsn()) {
+        bb.AppendInsn(*comment->GetPrev());
+      }
+      bb.AppendInsn(*comment);
+    }
+    /* Append insn */
+    if (!node->GetClinitInsns().empty()) {
+      for (auto clinit : node->GetClinitInsns()) {
+        bb.AppendInsn(*clinit);
+      }
+    } else if (node->GetType() == kNodeTypeNormal) {
+      if (node->GetInsn()->GetPrev() != nullptr && node->GetInsn()->GetPrev()->IsDbgInsn()) {
+        bb.AppendInsn(*node->GetInsn()->GetPrev());
+      }
+      bb.AppendInsn(*node->GetInsn());
+    }
+
+    /* Append cfi instructions. */
+    for (auto cfi : node->GetCfiInsns()) {
+      bb.AppendInsn(*cfi);
+    }
+  }
+  bb.SetLastLoc(prevLocInsn);
+
+  for (auto lastComment : dataDepBase.GetLastComments()) {
+    bb.AppendInsn(*lastComment);
+  }
+  dataDepBase.ClearLastComments();
+}
+
+/* For every node of nodes, update it's bruteForceSchedCycle. */
+void AArch64Schedule::UpdateBruteForceSchedCycle() {
+  for (auto node : nodes) {
+    node->SetBruteForceSchedCycle(node->GetSchedCycle());
+  }
+}
+
+/* Recursively schedule all of the possible node. */
+void AArch64Schedule::IterateBruteForce(DepNode &targetNode, MapleVector<DepNode*> &readyList, uint32 currCycle,
+                                        MapleVector<DepNode*> &scheduledNodes, uint32 &maxCycleCount,
+                                        MapleVector<DepNode*> &optimizedScheduledNodes) {
+  /* Save states. */
+  constexpr int32 unitSize = 31;
+  ASSERT(unitSize == mad->GetAllUnitsSize(), "CG internal error.");
+  std::vector<uint32> occupyTable;
+  occupyTable.resize(unitSize, 0);
+  mad->SaveStates(occupyTable, unitSize);
+
+  /* Schedule targetNode first. */
+  targetNode.SetState(kScheduled);
+  targetNode.SetSchedCycle(currCycle);
+  scheduledNodes.emplace_back(&targetNode);
+
+  MapleVector<DepNode*> tempList = readyList;
+  EraseNodeFromNodeList(targetNode, tempList);
+  targetNode.OccupyUnits();
+
+  /* Update readyList. */
+  UpdateReadyList(targetNode, tempList, true);
+
+  if (targetNode.GetType() == kNodeTypeSeparator) {
+    /* If target node is separator node, update lastSeparatorIndex. */
+    lastSeparatorIndex += kMaxDependenceNum;
+  }
+
+  if (tempList.empty()) {
+    ASSERT(scheduledNodes.size() == nodes.size(), "CG internal error, Not all nodes scheduled.");
+    if (currCycle < maxCycleCount) {
+      maxCycleCount = currCycle;
+      UpdateBruteForceSchedCycle();
+      optimizedScheduledNodes = scheduledNodes;
+    }
+  } else {
+    uint32 advanceCycle = 0;
+    switch (targetNode.GetInsn()->GetLatencyType()) {
+      case kLtClinit:
+        advanceCycle = kClinitAdvanceCycle;
+        break;
+      case kLtAdrpLdr:
+        advanceCycle = kAdrpLdrAdvanceCycle;
+        break;
+      case kLtClinitTail:
+        advanceCycle = kClinitTailAdvanceCycle;
+        break;
+      default:
+        break;
+    }
+
+    do {
+      std::vector<DepNode*> availableReadyList;
+      std::vector<DepNode*> tempAvailableList;
+      while (advanceCycle > 0) {
+        ++currCycle;
+        mad->AdvanceCycle();
+        --advanceCycle;
+      }
+      /* Check EStart. */
+      for (auto node : tempList) {
+        if (node->GetEStart() <= currCycle) {
+          tempAvailableList.emplace_back(node);
+        }
+      }
+
+      if (tempAvailableList.empty()) {
+        /* Advance cycle. */
+        advanceCycle = 1;
+        continue;
+      }
+
+      /* Check if schedulable */
+      for (auto node : tempAvailableList) {
+        if (node->CanBeScheduled()) {
+          availableReadyList.emplace_back(node);
+        }
+      }
+
+      if (availableReadyList.empty()) {
+        /* Advance cycle. */
+        advanceCycle = 1;
+        continue;
+      }
+
+      for (auto node : availableReadyList) {
+        IterateBruteForce(*node, tempList, currCycle, scheduledNodes, maxCycleCount, optimizedScheduledNodes);
+      }
+
+      break;
+    } while (true);
+  }
+
+  /*
+   * Recover states.
+   * Restore targetNode first.
+   */
+  targetNode.SetState(kReady);
+  targetNode.SetSchedCycle(0);
+  scheduledNodes.pop_back();
+  mad->RestoreStates(occupyTable, unitSize);
+
+  /* Update readyList. */
+  for (auto succLink : targetNode.GetSuccs()) {
+    DepNode &succNode = succLink->GetTo();
+    succNode.IncreaseValidPredsSize();
+    succNode.SetState(kNormal);
+  }
+
+  if (targetNode.GetType() == kNodeTypeSeparator) {
+    /* If target node is separator node, update lastSeparatorIndex. */
+    lastSeparatorIndex -= kMaxDependenceNum;
+  }
+}
+
+/*
+ * Brute force schedule:
+ * Finding all possibile schedule list of current bb, and calculate every list's execute cycles,
+ * return the optimal schedule list and it's cycles.
+ */
+uint32 AArch64Schedule::DoBruteForceSchedule() {
+  MapleVector<DepNode*> scheduledNodes(alloc.Adapter());
+  MapleVector<DepNode*> optimizedScheduledNodes(alloc.Adapter());
+
+  uint32 currCycle = 0;
+  uint32 maxCycleCount = 0xFFFFFFFF;
+  Init();
+
+  /* Schedule First separator. */
+  DepNode *targetNode = readyList.front();
+  targetNode->SetState(kScheduled);
+  targetNode->SetSchedCycle(currCycle);
+  scheduledNodes.emplace_back(targetNode);
+  readyList.clear();
+
+  /* Update readyList. */
+  UpdateReadyList(*targetNode, readyList, false);
+
+  ASSERT(targetNode->GetType() == kNodeTypeSeparator, "The first node should be separator node.");
+  ASSERT(!readyList.empty(), "readyList should not be empty.");
+
+  for (auto targetNodeTemp : readyList) {
+    IterateBruteForce(*targetNodeTemp, readyList, currCycle, scheduledNodes, maxCycleCount, optimizedScheduledNodes);
+  }
+
+  nodes = optimizedScheduledNodes;
+  return maxCycleCount;
+}
+
+/*
+ * Update ready list after the targetNode has been scheduled.
+ * For every targetNode's successor, if it's all predecessors have been scheduled,
+ * add it to ready list and update it's information (like state, estart).
+ */
+void AArch64Schedule::UpdateReadyList(DepNode &targetNode, MapleVector<DepNode*> &readyList, bool updateEStart) {
+  for (auto succLink : targetNode.GetSuccs()) {
+    DepNode &succNode = succLink->GetTo();
+    succNode.DescreaseValidPredsSize();
+    if (succNode.GetValidPredsSize() == 0) {
+      readyList.emplace_back(&succNode);
+      succNode.SetState(kReady);
+
+      /* Set eStart. */
+      if (updateEStart) {
+        uint32 maxEstart = 0;
+        for (auto predLink : succNode.GetPreds()) {
+          DepNode &predNode = predLink->GetFrom();
+          uint32 eStart = predNode.GetSchedCycle() + predLink->GetLatency();
+          maxEstart = (maxEstart < eStart ? eStart : maxEstart);
+        }
+        succNode.SetEStart(maxEstart);
+      }
+    }
+  }
+}
+
+/* For every node of nodes, dump it's Depdence information. */
+void AArch64Schedule::DumpDepGraph(const MapleVector<DepNode*> &nodes) const {
+  for (auto node : nodes) {
+    ddb->DumpDepNode(*node);
+    LogInfo::MapleLogger() << "---------- preds ----------" << "\n";
+    for (auto pred : node->GetPreds()) {
+      ddb->DumpDepLink(*pred, &(pred->GetFrom()));
+    }
+    LogInfo::MapleLogger() << "---------- succs ----------" << "\n";
+    for (auto succ : node->GetSuccs()) {
+      ddb->DumpDepLink(*succ, &(succ->GetTo()));
+    }
+    LogInfo::MapleLogger() << "---------------------------" << "\n";
+  }
+}
+
+/* For every node of nodes, dump it's schedule time according simulate type and instruction information. */
+void AArch64Schedule::DumpScheduleResult(const MapleVector<DepNode*> &nodes, SimulateType type) const {
+  for (auto node : nodes) {
+    LogInfo::MapleLogger() << "cycle[ ";
+    switch (type) {
+      case kListSchedule:
+        LogInfo::MapleLogger() << node->GetSchedCycle();
+        break;
+      case kBruteForce:
+        LogInfo::MapleLogger() << node->GetBruteForceSchedCycle();
+        break;
+      case kSimulateOnly:
+        LogInfo::MapleLogger() << node->GetSimulateCycle();
+        break;
+    }
+    LogInfo::MapleLogger() << " ]  ";
+    node->GetInsn()->Dump();
+    LogInfo::MapleLogger() << "\n";
+  }
+}
+
+/* Print bb's dependence dot graph information to a file. */
+void AArch64Schedule::GenerateDot(const BB &bb, const MapleVector<DepNode*> &nodes) const {
+  std::streambuf *coutBuf = std::cout.rdbuf();  /* keep original cout buffer */
+  std::ofstream dgFile;
+  std::streambuf *buf = dgFile.rdbuf();
+  std::cout.rdbuf(buf);
+
+  /* construct the file name */
+  std::string fileName;
+  fileName.append(phaseName);
+  fileName.append("_");
+  fileName.append(cgFunc.GetName());
+  fileName.append("_BB");
+  auto str = std::to_string(bb.GetId());
+  fileName.append(str);
+  fileName.append("_dep_graph.dot");
+
+  dgFile.open(fileName.c_str(), std::ios::trunc);
+  if (!dgFile.is_open()) {
+    LogInfo::MapleLogger(kLlWarn) << "fileName:" << fileName << " open failure.\n";
+    return;
+  }
+  dgFile << "digraph {\n";
+  for (auto node : nodes) {
+    for (auto succ : node->GetSuccs()) {
+      dgFile << "insn" << node->GetInsn() << " -> " << "insn" << succ->GetTo().GetInsn();
+      dgFile << " [";
+      if (succ->GetDepType() == kDependenceTypeTrue) {
+        dgFile << "color=red,";
+      }
+      dgFile << "label= \"" << succ->GetLatency() << "\"";
+      dgFile << "];\n";
+    }
+  }
+
+  for (auto node : nodes) {
+    MOperator mOp = node->GetInsn()->GetMachineOpcode();
+    const InsnDesc *md = &AArch64CG::kMd[mOp];
+    dgFile << "insn" << node->GetInsn() << "[";
+    dgFile << "shape=box,label= \" " << node->GetInsn()->GetId() << ":\n";
+    dgFile << "{ ";
+    dgFile << md->name << "\n";
+    dgFile << "}\"];\n";
+  }
+  dgFile << "}\n";
+  dgFile.flush();
+  dgFile.close();
+  std::cout.rdbuf(coutBuf);
+}
+
+RegType AArch64ScheduleProcessInfo::GetRegisterType(CGFunc &f, regno_t regNO) {
+  if (AArch64isa::IsPhysicalRegister(regNO)) {
+    if (AArch64isa::IsGPRegister(static_cast<AArch64reg>(regNO))) {
+      return kRegTyInt;
+    } else if (AArch64isa::IsFPSIMDRegister(static_cast<AArch64reg>(regNO))) {
+      return kRegTyFloat;
+    } else {
+      CHECK_FATAL(false, "unknown physical reg");
+    }
+  } else {
+    RegOperand *curRegOpnd = f.GetVirtualRegisterOperand(regNO);
+    ASSERT(curRegOpnd != nullptr, "register which is not physical and virtual");
+    return curRegOpnd->GetRegisterType();
+  }
+}
+
+void AArch64ScheduleProcessInfo::VaryLiveRegSet(CGFunc &f, regno_t regNO, bool isInc) {
+  RegType registerTy = GetRegisterType(f, regNO);
+  if (registerTy == kRegTyInt || registerTy == kRegTyVary) {
+    isInc ? IncIntLiveRegSet(regNO) : DecIntLiveRegSet(regNO);
+  } else if (registerTy == kRegTyFloat) {
+    isInc ? IncFpLiveRegSet(regNO) : DecFpLiveRegSet(regNO);
+  }
+  /* consider other type register */
+}
+
+void AArch64ScheduleProcessInfo::VaryFreeRegSet(CGFunc &f, std::set<regno_t> regNOs, DepNode &node) {
+  for (auto regNO : regNOs) {
+    RegType registerTy = GetRegisterType(f, regNO);
+    if (registerTy == kRegTyInt || registerTy == kRegTyVary /* memory base register must be int */) {
+      IncFreeIntRegNode(node);
+    } else if (registerTy == kRegTyFloat) {
+      IncFreeFpRegNode(node);
+    } else if (registerTy == kRegTyCc) {
+      /* do not count CC reg */
+      return;
+    } else  {
+      /* consider other type register */
+      CHECK_FATAL(false, "do not support this type of register");
+    }
+  }
+}
+
+/* Do brute force scheduling and dump scheduling information */
+void AArch64Schedule::BruteForceScheduling(const BB &bb) {
+  LogInfo::MapleLogger() << "\n\n$$ Function: " << cgFunc.GetName();
+  LogInfo::MapleLogger() << "\n    BB id = " << bb.GetId() << "; nodes.size = " << nodes.size() << "\n";
+
+  constexpr uint32 maxBruteForceNum = 50;
+  if (nodes.size() < maxBruteForceNum) {
+    GenerateDot(bb, nodes);
+    uint32 maxBruteForceCycle = DoBruteForceSchedule();
+    MapleVector<DepNode*> bruteNodes = nodes;
+    uint32 maxSchedCycle = DoSchedule();
+    if (maxBruteForceCycle < maxSchedCycle) {
+      LogInfo::MapleLogger() << "maxBruteForceCycle = " << maxBruteForceCycle << "; maxSchedCycle = ";
+      LogInfo::MapleLogger() << maxSchedCycle << "\n";
+      LogInfo::MapleLogger() << "\n    ## Dump dependence graph ##    " << "\n";
+      DumpDepGraph(nodes);
+      LogInfo::MapleLogger() << "\n    ** Dump bruteForce scheduling result." << "\n";
+      DumpScheduleResult(bruteNodes, kBruteForce);
+      LogInfo::MapleLogger() << "\n    ^^ Dump list scheduling result." << "\n";
+      DumpScheduleResult(nodes, kListSchedule);
+    }
+  } else {
+    LogInfo::MapleLogger() << "Skip BruteForce scheduling." << "\n";
+    DoSchedule();
+  }
+}
+
+/* Do simulate scheduling and dump scheduling information */
+void AArch64Schedule::SimulateScheduling(const BB &bb) {
+  uint32 originCycle = SimulateOnly();
+  MapleVector<DepNode*> oldNodes = nodes;
+  uint32 schedCycle = DoSchedule();
+  if (originCycle < schedCycle) {
+    LogInfo::MapleLogger() << "Worse cycle [ " << (schedCycle - originCycle) << " ]; ";
+    LogInfo::MapleLogger() << "originCycle = " << originCycle << "; schedCycle = ";
+    LogInfo::MapleLogger() << schedCycle << "; nodes.size = " << nodes.size();
+    LogInfo::MapleLogger() << ";    $$ Function: " << cgFunc.GetName();
+    LogInfo::MapleLogger() << ";    BB id = " << bb.GetId() << "\n";
+    LogInfo::MapleLogger() << "\n    ** Dump original result." << "\n";
+    DumpScheduleResult(oldNodes, kSimulateOnly);
+    LogInfo::MapleLogger() << "\n    ^^ Dump list scheduling result." << "\n";
+    DumpScheduleResult(nodes, kListSchedule);
+  } else if (originCycle > schedCycle) {
+    LogInfo::MapleLogger() << "Advance cycle [ " << (originCycle - schedCycle) << " ]; ";
+    LogInfo::MapleLogger() << "originCycle = " << originCycle << "; schedCycle = ";
+    LogInfo::MapleLogger() << schedCycle << "; nodes.size = " << nodes.size();
+    LogInfo::MapleLogger() << ";    $$ Function: " << cgFunc.GetName();
+    LogInfo::MapleLogger() << ";    BB id = " << bb.GetId() << "\n";
+  } else {
+    LogInfo::MapleLogger() << "Equal cycle [ 0 ]; originCycle = " << originCycle;
+    LogInfo::MapleLogger() << " ], ignore. nodes.size = " << nodes.size() << "\n";
+  }
+}
+
+/*
+ * A local list scheduling.
+ * Schedule insns in basic blocks.
+ */
+void AArch64Schedule::ListScheduling(bool beforeRA) {
+  InitIDAndLoc();
+
+  mad = Globals::GetInstance()->GetMAD();
+  if (beforeRA) {
+    RegPressure::SetMaxRegClassNum(kRegisterLast);
+  }
+  // construct cdgNode for each BB
+  auto *cda = memPool.New<ControlDepAnalysis>(cgFunc, memPool);
+  cda->CreateAllCDGNodes();
+  ddb = memPool.New<AArch64DataDepBase>(memPool, cgFunc, *mad);
+  intraDDA = memPool.New<IntraDataDepAnalysis>(memPool, cgFunc, *ddb);
+  FOR_ALL_BB(bb, &cgFunc) {
+    intraDDA->Run(*bb, nodes);
+
+    if (LIST_SCHED_DUMP_REF) {
+      GenerateDot(*bb, nodes);
+      DumpDepGraph(nodes);
+    }
+    if (beforeRA) {
+      liveInRegNo = bb->GetLiveInRegNO();
+      liveOutRegNo = bb->GetLiveOutRegNO();
+      if (bb->GetKind() != BB::kBBReturn) {
+        SetConsiderRegPressure();
+        DoSchedule();
+      } else {
+        RegPressureScheduling(*bb, nodes);
+      }
+    } else {
+      ClinitPairOpt();
+      MemoryAccessPairOpt();
+      if (CGOptions::IsDruteForceSched()) {
+        BruteForceScheduling(*bb);
+      } else if (CGOptions::IsSimulateSched()) {
+        SimulateScheduling(*bb);
+      } else {
+        DoSchedule();
+      }
+    }
+
+    FinalizeScheduling(*bb, *ddb);
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_ssa.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ssa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..212b82c122b935b1e956722dbaf9348bd5b1d4ad
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ssa.cpp
@@ -0,0 +1,384 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "aarch64_ssa.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+void AArch64CGSSAInfo::RenameInsn(Insn &insn) {
+  auto opndNum = static_cast<int32>(insn.GetOperandSize());
+  const InsnDesc *md = insn.GetDesc();
+  if (md->IsPhi()) {
+    return;
+  }
+  for (int i = opndNum - 1; i >= 0; --i) {
+    Operand &opnd = insn.GetOperand(static_cast<uint32>(i));
+    auto *opndProp = (md->opndMD[static_cast<uint32>(i)]);
+    A64SSAOperandRenameVisitor renameVisitor(*this, insn, *opndProp, i);
+    opnd.Accept(renameVisitor);
+  }
+}
+
+MemOperand *AArch64CGSSAInfo::CreateMemOperand(MemOperand &memOpnd, bool isOnSSA) const {
+  return isOnSSA ? memOpnd.Clone(*memPool) :
+      &static_cast<AArch64CGFunc*>(cgFunc)->GetOrCreateMemOpnd(memOpnd);
+}
+
+RegOperand *AArch64CGSSAInfo::GetRenamedOperand(RegOperand &vRegOpnd, bool isDef, Insn &curInsn, uint32 idx) {
+  if (vRegOpnd.IsVirtualRegister()) {
+    ASSERT(!vRegOpnd.IsSSAForm(), "Unexpect ssa operand");
+    if (isDef) {
+      VRegVersion *newVersion = CreateNewVersion(vRegOpnd, curInsn, idx);
+      CHECK_FATAL(newVersion != nullptr, "get ssa version failed");
+      return newVersion->GetSSAvRegOpnd();
+    } else {
+      VRegVersion *curVersion = GetVersion(vRegOpnd);
+      if (curVersion == nullptr) {
+        curVersion = RenamedOperandSpecialCase(vRegOpnd, curInsn, idx);
+      }
+      curVersion->AddUseInsn(*this, curInsn, idx);
+      return curVersion->GetSSAvRegOpnd();
+    }
+  }
+  ASSERT(false, "Get Renamed operand failed");
+  return nullptr;
+}
+
+VRegVersion *AArch64CGSSAInfo::RenamedOperandSpecialCase(RegOperand &vRegOpnd, Insn &curInsn, uint32 idx) {
+  LogInfo::MapleLogger() << "WARNING: " << vRegOpnd.GetRegisterNumber() << " has no def info in function : "
+                         << cgFunc->GetName() << " !\n";
+  /* occupy operand for no def vreg */
+  if (!IncreaseSSAOperand(vRegOpnd.GetRegisterNumber(), nullptr)) {
+    ASSERT(GetAllSSAOperands().find(vRegOpnd.GetRegisterNumber()) != GetAllSSAOperands().end(), "should find");
+    AddNoDefVReg(vRegOpnd.GetRegisterNumber());
+  }
+  VRegVersion *version = CreateNewVersion(vRegOpnd, curInsn, idx);
+  version->SetDefInsn(nullptr, kDefByNo);
+  return version;
+}
+
+RegOperand *AArch64CGSSAInfo::CreateSSAOperand(RegOperand &virtualOpnd) {
+  regno_t ssaRegNO = static_cast<regno_t>(GetAllSSAOperands().size()) + ssaRegNObase;
+  while (GetAllSSAOperands().count(ssaRegNO) != 0) {
+    ssaRegNO++;
+    ssaRegNObase++;
+  }
+  RegOperand *newVreg = memPool->New<RegOperand>(ssaRegNO,
+      virtualOpnd.GetSize(), virtualOpnd.GetRegisterType());
+  newVreg->SetOpndSSAForm();
+  return newVreg;
+}
+
+void AArch64CGSSAInfo::ReplaceInsn(Insn &oriInsn, Insn &newInsn) {
+  A64OpndSSAUpdateVsitor ssaUpdator(*this);
+  auto updateInsnSSAInfo = [&ssaUpdator](Insn &curInsn, bool isDelete) {
+    const InsnDesc *md = curInsn.GetDesc();
+    for (uint32 i = 0; i < curInsn.GetOperandSize(); ++i) {
+      Operand &opnd = curInsn.GetOperand(i);
+      auto *opndProp = md->opndMD[i];
+      if (isDelete) {
+        ssaUpdator.MarkDecrease();
+      } else {
+        ssaUpdator.MarkIncrease();
+      }
+      ssaUpdator.SetInsnOpndInfo(curInsn, *opndProp, i);
+      opnd.Accept(ssaUpdator);
+    }
+  };
+  updateInsnSSAInfo(oriInsn, true);
+  newInsn.SetId(oriInsn.GetId());
+  updateInsnSSAInfo(newInsn, false);
+  CHECK_FATAL(!ssaUpdator.HasDeleteDef(), "delete def point in replace insn, please check");
+}
+
+/* do not break binding between input and output operands in asm */
+void AArch64CGSSAInfo::CheckAsmDUbinding(Insn &insn, const VRegVersion *toBeReplaced, VRegVersion *newVersion) {
+  if (insn.GetMachineOpcode() == MOP_asm) {
+    for (auto &opndIt : static_cast<ListOperand&>(insn.GetOperand(kAsmOutputListOpnd)).GetOperands()) {
+      if (opndIt->IsSSAForm()) {
+        VRegVersion *defVersion = FindSSAVersion(opndIt->GetRegisterNumber());
+        if (defVersion && defVersion->GetOriginalRegNO() == toBeReplaced->GetOriginalRegNO()) {
+          insn.AddRegBinding(defVersion->GetOriginalRegNO(), newVersion->GetSSAvRegOpnd()->GetRegisterNumber());
+        }
+      }
+    }
+  }
+}
+
+void AArch64CGSSAInfo::ReplaceAllUse(VRegVersion *toBeReplaced, VRegVersion *newVersion) {
+  MapleUnorderedMap<uint32, DUInsnInfo*> &useList = toBeReplaced->GetAllUseInsns();
+  for (auto it = useList.begin(); it != useList.end();) {
+    Insn *useInsn = it->second->GetInsn();
+    CheckAsmDUbinding(*useInsn, toBeReplaced, newVersion);
+    for (auto &opndIt : it->second->GetOperands()) {
+      Operand &opnd = useInsn->GetOperand(opndIt.first);
+      A64ReplaceRegOpndVisitor replaceRegOpndVisitor(
+          *cgFunc, *useInsn, opndIt.first, *toBeReplaced->GetSSAvRegOpnd(), *newVersion->GetSSAvRegOpnd());
+      opnd.Accept(replaceRegOpndVisitor);
+      newVersion->AddUseInsn(*this, *useInsn, opndIt.first);
+      it->second->ClearDU(opndIt.first);
+    }
+    it = useList.erase(it);
+  }
+}
+
+void AArch64CGSSAInfo::CreateNewInsnSSAInfo(Insn &newInsn) {
+  uint32 opndNum = newInsn.GetOperandSize();
+  MarkInsnsInSSA(newInsn);
+  for (uint32 i = 0; i < opndNum; i++) {
+    Operand &opnd = newInsn.GetOperand(i);
+    auto *opndProp = newInsn.GetDesc()->opndMD[i];
+    if (opndProp->IsDef() && opndProp->IsUse()) {
+      CHECK_FATAL(false, "do not support both def and use");
+    }
+    if (opndProp->IsDef()) {
+      CHECK_FATAL(opnd.IsRegister(), "defOpnd must be reg");
+      auto &defRegOpnd = static_cast<RegOperand&>(opnd);
+      regno_t defRegNO = defRegOpnd.GetRegisterNumber();
+      uint32 defVIdx = IncreaseVregCount(defRegNO);
+      RegOperand *defSSAOpnd = CreateSSAOperand(defRegOpnd);
+      newInsn.SetOperand(i, *defSSAOpnd);
+      auto *defVersion = memPool->New<VRegVersion>(ssaAlloc, *defSSAOpnd, defVIdx, defRegNO);
+      auto *defInfo = CreateDUInsnInfo(&newInsn, i);
+      defVersion->SetDefInsn(defInfo, kDefByInsn);
+      if (!IncreaseSSAOperand(defSSAOpnd->GetRegisterNumber(), defVersion)) {
+        CHECK_FATAL(false, "insert ssa operand failed");
+      }
+      uint32 curSSAVregCount = cgFunc->GetSSAvRegCount();
+      cgFunc->SetSSAvRegCount(++curSSAVregCount);
+    } else if (opndProp->IsUse()) {
+      A64OpndSSAUpdateVsitor ssaUpdator(*this);
+      ssaUpdator.MarkIncrease();
+      ssaUpdator.SetInsnOpndInfo(newInsn, *opndProp, i);
+      opnd.Accept(ssaUpdator);
+    }
+  }
+}
+
+void AArch64CGSSAInfo::DumpInsnInSSAForm(const Insn &insn) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  const InsnDesc *md = insn.GetDesc();
+  ASSERT(md != nullptr, "md should not be nullptr");
+
+  LogInfo::MapleLogger() << "< " << insn.GetId() << " > ";
+  LogInfo::MapleLogger() << md->name << "(" << mOp << ")";
+
+  for (uint32 i = 0; i < insn.GetOperandSize(); ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    LogInfo::MapleLogger() << " (opnd" << i << ": ";
+    A64SSAOperandDumpVisitor a64OpVisitor(GetAllSSAOperands());
+    opnd.Accept(a64OpVisitor);
+    if (!a64OpVisitor.HasDumped()) {
+      A64OpndDumpVisitor dumpVisitor(*md->GetOpndDes(i));
+      opnd.Accept(dumpVisitor);
+      LogInfo::MapleLogger() << ")";
+    }
+  }
+  if (insn.IsVectorOp()) {
+    auto &vInsn = static_cast<const VectorInsn&>(insn);
+    if (vInsn.GetNumOfRegSpec() != 0) {
+      LogInfo::MapleLogger() << " (vecSpec: " << vInsn.GetNumOfRegSpec() << ")";
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void A64SSAOperandRenameVisitor::Visit(RegOperand *v) {
+  if (v->IsVirtualRegister()) {
+    if (opndDes->IsRegDef() && opndDes->IsRegUse()) {        /* both def use */
+      insn->SetOperand(idx, *ssaInfo->GetRenamedOperand(*v, false, *insn, idx));
+      RegOperand *ssaDefOpnd = ssaInfo->GetRenamedOperand(*v, true, *insn, idx);
+      insn->SetSSAImpDefOpnd(ssaDefOpnd);
+    } else {
+      insn->SetOperand(idx, *ssaInfo->GetRenamedOperand(*v, opndDes->IsRegDef(), *insn, idx));
+    }
+  }
+}
+
+void A64SSAOperandRenameVisitor::Visit(MemOperand *v) {
+  RegOperand *base = v->GetBaseRegister();
+  RegOperand *index = v->GetIndexRegister();
+  bool needCopy = (base != nullptr && base->IsVirtualRegister()) || (index != nullptr && index->IsVirtualRegister());
+  if (needCopy) {
+    MemOperand *cpyMem = ssaInfo->CreateMemOperand(*v, true);
+    if (base != nullptr && base->IsVirtualRegister()) {
+      bool isDef = !v->IsIntactIndexed();
+      cpyMem->SetBaseRegister(*ssaInfo->GetRenamedOperand(*base, isDef, *insn, idx));
+    }
+    if (index != nullptr && index->IsVirtualRegister()) {
+      cpyMem->SetIndexRegister(*ssaInfo->GetRenamedOperand(*index, false, *insn, idx));
+    }
+    insn->SetMemOpnd(ssaInfo->CreateMemOperand(*cpyMem, false));
+  }
+}
+
+void A64SSAOperandRenameVisitor::Visit(ListOperand *v) {
+  bool isAsm = insn->GetMachineOpcode() == MOP_asm;
+  /* record the orignal list order */
+  std::list<RegOperand*> tempList;
+  auto& opndList = v->GetOperands();
+  while (!opndList.empty()) {
+    auto* op = opndList.front();
+    opndList.pop_front();
+
+    if (op->IsSSAForm() || !op->IsVirtualRegister()) {
+      tempList.push_back(op);
+      continue;
+    }
+
+    bool isDef =
+        isAsm && (idx == kAsmClobberListOpnd || idx == kAsmOutputListOpnd);
+    RegOperand *renameOpnd = ssaInfo->GetRenamedOperand(*op, isDef, *insn, idx);
+    tempList.push_back(renameOpnd);
+  }
+  ASSERT(v->GetOperands().empty(), "need to clean list");
+  v->GetOperands().assign(tempList.begin(), tempList.end());
+}
+
+void A64OpndSSAUpdateVsitor::Visit(RegOperand *v) {
+  if (v->IsSSAForm()) {
+    if (opndDes->IsRegDef() && opndDes->IsRegUse()) {
+      UpdateRegUse(v->GetRegisterNumber());
+      ASSERT(insn->GetSSAImpDefOpnd(), "must be");
+      UpdateRegDef(insn->GetSSAImpDefOpnd()->GetRegisterNumber());
+    } else {
+      if (opndDes->IsRegDef()) {
+        UpdateRegDef(v->GetRegisterNumber());
+      } else if (opndDes->IsRegUse()) {
+        UpdateRegUse(v->GetRegisterNumber());
+      } else if (IsPhi()) {
+        UpdateRegUse(v->GetRegisterNumber());
+      } else {
+        ASSERT(false, "invalid opnd");
+      }
+    }
+  }
+}
+
+void A64OpndSSAUpdateVsitor::Visit(maplebe::MemOperand *a64MemOpnd) {
+  RegOperand *base = a64MemOpnd->GetBaseRegister();
+  RegOperand *index = a64MemOpnd->GetIndexRegister();
+  if (base != nullptr && base->IsSSAForm()) {
+    if (a64MemOpnd->IsIntactIndexed()) {
+      UpdateRegUse(base->GetRegisterNumber());
+    } else {
+      UpdateRegDef(base->GetRegisterNumber());
+    }
+  }
+  if (index != nullptr && index->IsSSAForm()) {
+    UpdateRegUse(index->GetRegisterNumber());
+  }
+}
+
+void A64OpndSSAUpdateVsitor::Visit(PhiOperand *v) {
+  SetPhi(true);
+  for (auto phiListIt = v->GetOperands().begin(); phiListIt != v->GetOperands().end(); ++phiListIt) {
+    Visit(phiListIt->second);
+  }
+  SetPhi(false);
+}
+
+void A64OpndSSAUpdateVsitor::Visit(ListOperand *v) {
+  /* do not handle asm here, so there is no list def */
+  if (insn->GetMachineOpcode() == MOP_asm) {
+    ASSERT(false, "do not support asm yet");
+    return;
+  }
+  for (auto *op : v->GetOperands()) {
+    if (op->IsSSAForm()) {
+      UpdateRegUse(op->GetRegisterNumber());
+    }
+  }
+}
+
+void A64OpndSSAUpdateVsitor::UpdateRegUse(uint32 ssaIdx) {
+  VRegVersion *curVersion = ssaInfo->FindSSAVersion(ssaIdx);
+  CHECK_NULL_FATAL(curVersion);
+  if (isDecrease) {
+    curVersion->RemoveUseInsn(*insn, idx);
+  } else {
+    curVersion->AddUseInsn(*ssaInfo, *insn, idx);
+  }
+}
+
+void A64OpndSSAUpdateVsitor::UpdateRegDef(uint32 ssaIdx) {
+  VRegVersion *curVersion = ssaInfo->FindSSAVersion(ssaIdx);
+  CHECK_NULL_FATAL(curVersion);
+  if (isDecrease) {
+    deletedDef.emplace(ssaIdx);
+    curVersion->MarkDeleted();
+  } else {
+    if (deletedDef.count(ssaIdx) != 0) {
+      deletedDef.erase(ssaIdx);
+      curVersion->MarkRecovery();
+    } else {
+      CHECK_FATAL(false, "do no support new define in ssaUpdating");
+    }
+    ASSERT(!insn->IsPhi(), "do no support yet");
+    curVersion->SetDefInsn(ssaInfo->CreateDUInsnInfo(insn, idx), kDefByInsn);
+  }
+}
+
+void A64SSAOperandDumpVisitor::Visit(RegOperand *v) {
+  ASSERT(!v->IsConditionCode(), "both condi and reg");
+  if (v->IsSSAForm()) {
+    std::array<const std::string, kRegTyLast> prims = { "U", "R", "V", "C", "X", "Vra" };
+    std::array<const std::string, kRegTyLast> classes = { "[U]", "[I]", "[F]", "[CC]", "[X87]", "[Vra]" };
+    CHECK_FATAL(v->IsVirtualRegister() && v->IsSSAForm(), "only dump ssa opnd here");
+    RegType regType = v->GetRegisterType();
+    ASSERT(regType < kRegTyLast, "unexpected regType");
+    auto ssaVit = allSSAOperands.find(v->GetRegisterNumber());
+    CHECK_FATAL(ssaVit != allSSAOperands.end(), "find ssa version failed");
+    LogInfo::MapleLogger() << "ssa_reg:" << prims[regType] << ssaVit->second->GetOriginalRegNO() << "_"
+                           << ssaVit->second->GetVersionIdx() << " class: " << classes[regType] << " validBitNum: ["
+                           << static_cast<uint32>(v->GetValidBitsNum()) << "]";
+    LogInfo::MapleLogger() << ")";
+    SetHasDumped();
+  }
+}
+
+void A64SSAOperandDumpVisitor::Visit(ListOperand *v) {
+  for (auto regOpnd : v->GetOperands()) {
+    if (regOpnd->IsSSAForm()) {
+      Visit(regOpnd);
+      continue;
+    }
+  }
+}
+
+void A64SSAOperandDumpVisitor::Visit(MemOperand *v) {
+  if (v->GetBaseRegister() != nullptr && v->GetBaseRegister()->IsSSAForm()) {
+    LogInfo::MapleLogger() << "Mem: ";
+    Visit(v->GetBaseRegister());
+    if (v->GetAddrMode() == MemOperand::kAddrModeBOi) {
+      LogInfo::MapleLogger() << "offset:";
+      v->GetOffsetOperand()->Dump();
+    }
+  }
+  if (v->GetIndexRegister() != nullptr && v->GetIndexRegister()->IsSSAForm()) {
+    ASSERT(v->GetAddrMode() == MemOperand::kAddrModeBOrX, "mem mode false");
+    LogInfo::MapleLogger() << "offset:";
+    Visit(v->GetIndexRegister());
+  }
+}
+
+void A64SSAOperandDumpVisitor::Visit(PhiOperand *v) {
+  for (auto phiListIt = v->GetOperands().begin(); phiListIt != v->GetOperands().end();) {
+    Visit(phiListIt->second);
+    LogInfo::MapleLogger() << " fBB<" << phiListIt->first << ">";
+    LogInfo::MapleLogger() << (++phiListIt == v->GetOperands().end() ? ")" : ", ");
+  }
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_strldr.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_strldr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4300efbb0e36543f3b389d1b87bcf53c37154ac2
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_strldr.cpp
@@ -0,0 +1,1079 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_strldr.h"
+#include "aarch64_reaching.h"
+#include "aarch64_cgfunc.h"
+#include "common_utils.h"
+
+namespace maplebe {
+using namespace maple;
+
+static MOperator SelectMovMop(bool isFloatOrSIMD, bool is64Bit) {
+  return isFloatOrSIMD ? (is64Bit ? MOP_xvmovd : MOP_xvmovs)
+                       : (is64Bit ? MOP_xmovrr : MOP_wmovrr);
+}
+
+void AArch64StoreLoadOpt::Run() {
+  DoStoreLoadOpt();
+}
+
+/*
+ * Transfer: store x100, [MEM]
+ *           ... // May exist branches.
+ *           load  x200, [MEM]
+ *       ==>
+ *        OPT_VERSION_STR_LIVE:
+ *           store x100, [MEM]
+ *           ... // May exist branches. if x100 not dead here.
+ *           mov   x200, x100
+ *       OPT_VERSION_STR_DIE:
+ *           store x100, [MEM]
+ *           mov x9000(new reg), x100
+ *           ... // May exist branches. if x100 dead here.
+ *           mov   x200, x9000
+ *  Params:
+ *    strInsn: indicate store insn.
+ *    strSrcIdx: index of source register operand of store insn. (x100 in this example)
+ *    memSeq: represent first memOpreand or second memOperand
+ *    memUseInsnSet: insns using memOperand
+ */
+void AArch64StoreLoadOpt::DoLoadToMoveTransfer(Insn &strInsn, short strSrcIdx,
+                                               short memSeq, const InsnSet &memUseInsnSet) {
+  /* stp instruction need two registers, str only need one register */
+  ASSERT(strSrcIdx < kDivide2, "CG internal error.");
+  /* Find x100's definition insn. */
+  InsnSet regDefInsnSet = cgFunc.GetRD()->FindDefForRegOpnd(strInsn, strSrcIdx);
+  ASSERT(!regDefInsnSet.empty(), "RegOperand is used before defined");
+  if (regDefInsnSet.size() != 1) {
+    return;
+  }
+  std::map<Insn*, bool> insnState;
+  for (auto *ldrInsn : memUseInsnSet) {
+    insnState[ldrInsn] = true;
+  }
+  for (auto *ldrInsn : memUseInsnSet) {
+    if (!ldrInsn->IsLoad() || (ldrInsn->GetDefRegs().size() > 1) || ldrInsn->GetBB()->IsCleanup()) {
+      continue;
+    }
+
+    if (HasMemBarrier(*ldrInsn, strInsn)) {
+      continue;
+    }
+
+    /* ldr x200, [mem], mem index is 1, x200 index is 0 */
+    InsnSet memDefInsnSet = cgFunc.GetRD()->FindDefForMemOpnd(*ldrInsn, kInsnSecondOpnd);
+    ASSERT(!memDefInsnSet.empty(), "load insn should have definitions.");
+    /* If load has multiple definition, continue. */
+    if (memDefInsnSet.size() > 1) {
+      insnState[ldrInsn] = false;
+      continue;
+    }
+
+    Operand &resOpnd = ldrInsn->GetOperand(kInsnFirstOpnd);
+    Operand &srcOpnd = strInsn.GetOperand(static_cast<uint32>(strSrcIdx));
+    if (resOpnd.GetSize() != srcOpnd.GetSize()) {
+      return;
+    }
+
+    auto &resRegOpnd = static_cast<RegOperand&>(resOpnd);
+    auto &srcRegOpnd = static_cast<RegOperand&>(srcOpnd);
+    if (resRegOpnd.GetRegisterType() != srcRegOpnd.GetRegisterType()) {
+      continue;
+    }
+
+    /* Check if use operand of store is live at load insn. */
+    if (cgFunc.GetRD()->RegIsLiveBetweenInsn(srcRegOpnd.GetRegisterNumber(), strInsn, *ldrInsn)) {
+      GenerateMoveLiveInsn(resRegOpnd, srcRegOpnd, *ldrInsn, strInsn, memSeq);
+      insnState[ldrInsn] = false;
+    } else if (!cgFunc.IsAfterRegAlloc()) {
+      GenerateMoveDeadInsn(resRegOpnd, srcRegOpnd, *ldrInsn, strInsn, memSeq);
+    }
+
+    if (CG_DEBUG_FUNC(cgFunc)) {
+      LogInfo::MapleLogger() << "Do store-load optimization 1: str version";
+      LogInfo::MapleLogger() << cgFunc.GetName() << '\n';
+      LogInfo::MapleLogger() << "Store insn: ";
+      strInsn.Dump();
+      LogInfo::MapleLogger() << "Load insn: ";
+      ldrInsn->Dump();
+    }
+  }
+  auto it = memUseInsnSet.begin();
+  ++it;
+  for (; it != memUseInsnSet.end(); ++it) {
+    Insn *curInsn = *it;
+    if (insnState[curInsn] == false) {
+      continue;
+    }
+    if (!curInsn->IsLoad() || (curInsn->GetDefRegs().size() > 1) || curInsn->GetBB()->IsCleanup()) {
+      continue;
+    }
+    InsnSet memDefInsnSet = cgFunc.GetRD()->FindDefForMemOpnd(*curInsn, kInsnSecondOpnd);
+    ASSERT(!memDefInsnSet.empty(), "load insn should have definitions.");
+    if (memDefInsnSet.size() > 1) {
+      continue;
+    }
+    auto prevIt = it;
+    do {
+      --prevIt;
+      Insn *prevInsn = *prevIt;
+      if (insnState[prevInsn] == false) {
+        continue;
+      }
+      if (prevInsn->GetBB() != curInsn->GetBB()) {
+        break;
+      }
+      if (!prevInsn->IsLoad() || (prevInsn->GetDefRegs().size() > 1) || prevInsn->GetBB()->IsCleanup()) {
+        continue;
+      }
+      InsnSet memoryDefInsnSet = cgFunc.GetRD()->FindDefForMemOpnd(*curInsn, kInsnSecondOpnd);
+      ASSERT(!memoryDefInsnSet.empty(), "load insn should have definitions.");
+      if (memoryDefInsnSet.size() > 1) {
+        break;
+      }
+      Operand &resOpnd = curInsn->GetOperand(kInsnFirstOpnd);
+      Operand &srcOpnd = prevInsn->GetOperand(kInsnFirstOpnd);
+      if (resOpnd.GetSize() != srcOpnd.GetSize()) {
+        continue;
+      }
+
+      auto &resRegOpnd = static_cast<RegOperand&>(resOpnd);
+      auto &srcRegOpnd = static_cast<RegOperand&>(srcOpnd);
+      if (resRegOpnd.GetRegisterType() != srcRegOpnd.GetRegisterType()) {
+        continue;
+      }
+      /* Check if use operand of store is live at load insn. */
+      if (cgFunc.GetRD()->FindRegDefBetweenInsn(srcRegOpnd.GetRegisterNumber(),
+          prevInsn->GetNext(), curInsn->GetPrev()).empty()) {
+        GenerateMoveLiveInsn(resRegOpnd, srcRegOpnd, *curInsn, *prevInsn, memSeq);
+        insnState[curInsn] = false;
+      }
+      break;
+    } while (prevIt != memUseInsnSet.begin());
+  }
+}
+
+void AArch64StoreLoadOpt::GenerateMoveLiveInsn(RegOperand &resRegOpnd, RegOperand &srcRegOpnd,
+                                               Insn &ldrInsn, Insn &strInsn, short memSeq) {
+  MOperator movMop = SelectMovMop(resRegOpnd.IsOfFloatOrSIMDClass(), resRegOpnd.GetSize() == k64BitSize);
+  Insn *movInsn = nullptr;
+  if (str2MovMap[&strInsn][memSeq] != nullptr && !cgFunc.IsAfterRegAlloc()) {
+    Insn *movInsnOfStr = str2MovMap[&strInsn][memSeq];
+    auto &vregOpnd = static_cast<RegOperand&>(movInsnOfStr->GetOperand(kInsnFirstOpnd));
+    movInsn = &cgFunc.GetInsnBuilder()->BuildInsn(movMop, resRegOpnd, vregOpnd);
+  } else {
+    movInsn = &cgFunc.GetInsnBuilder()->BuildInsn(movMop, resRegOpnd, srcRegOpnd);
+  }
+  if (resRegOpnd.GetRegisterNumber() == srcRegOpnd.GetRegisterNumber() &&
+      cgFunc.IsAfterRegAlloc()) {
+    ldrInsn.GetBB()->RemoveInsn(ldrInsn);
+    cgFunc.GetRD()->InitGenUse(*ldrInsn.GetBB(), false);
+    return;
+  }
+  movInsn->SetId(ldrInsn.GetId());
+  ldrInsn.GetBB()->ReplaceInsn(ldrInsn, *movInsn);
+  if (CG_DEBUG_FUNC(cgFunc)) {
+    LogInfo::MapleLogger() << "replace ldrInsn:\n";
+    ldrInsn.Dump();
+    LogInfo::MapleLogger() << "with movInsn:\n";
+    movInsn->Dump();
+  }
+  /* Add comment. */
+  MapleString newComment = ldrInsn.GetComment();
+  if (strInsn.IsStorePair()) {
+    newComment += ";  stp-load live version.";
+  } else {
+    newComment += ";  str-load live version.";
+  }
+  movInsn->SetComment(newComment);
+  cgFunc.GetRD()->InitGenUse(*ldrInsn.GetBB(), false);
+}
+
+void AArch64StoreLoadOpt::GenerateMoveDeadInsn(RegOperand &resRegOpnd, RegOperand &srcRegOpnd,
+                                               Insn &ldrInsn, Insn &strInsn, short memSeq) {
+  Insn *newMovInsn = nullptr;
+  RegOperand *vregOpnd = nullptr;
+
+  if (str2MovMap[&strInsn][memSeq] == nullptr) {
+    RegType regTy = srcRegOpnd.IsOfFloatOrSIMDClass() ? kRegTyFloat : kRegTyInt;
+    regno_t vRegNO =
+        cgFunc.NewVReg(regTy, srcRegOpnd.GetSize() <= k32BitSize ? k4ByteSize : k8ByteSize);
+    /* generate a new vreg, check if the size of DataInfo is big enough */
+    if (vRegNO >= cgFunc.GetRD()->GetRegSize(*strInsn.GetBB())) {
+      cgFunc.GetRD()->EnlargeRegCapacity(vRegNO);
+    }
+    vregOpnd = &cgFunc.CreateVirtualRegisterOperand(vRegNO);
+    MOperator newMop = SelectMovMop(resRegOpnd.IsOfFloatOrSIMDClass(), resRegOpnd.GetSize() == k64BitSize);
+    newMovInsn = &cgFunc.GetInsnBuilder()->BuildInsn(newMop, *vregOpnd, srcRegOpnd);
+    newMovInsn->SetId(strInsn.GetId() + memSeq + 1);
+    strInsn.GetBB()->InsertInsnAfter(strInsn, *newMovInsn);
+    str2MovMap[&strInsn][memSeq] = newMovInsn;
+    /* update DataInfo */
+    cgFunc.GetRD()->UpdateInOut(*strInsn.GetBB(), true);
+  } else {
+    newMovInsn = str2MovMap[&strInsn][memSeq];
+    vregOpnd = &static_cast<RegOperand&>(newMovInsn->GetOperand(kInsnFirstOpnd));
+  }
+  MOperator movMop = SelectMovMop(resRegOpnd.IsOfFloatOrSIMDClass(), resRegOpnd.GetSize() == k64BitSize);
+  Insn &movInsn = cgFunc.GetInsnBuilder()->BuildInsn(movMop, resRegOpnd, *vregOpnd);
+  movInsn.SetId(ldrInsn.GetId());
+  ldrInsn.GetBB()->ReplaceInsn(ldrInsn, movInsn);
+  if (CG_DEBUG_FUNC(cgFunc)) {
+    LogInfo::MapleLogger() << "replace ldrInsn:\n";
+    ldrInsn.Dump();
+    LogInfo::MapleLogger() << "with movInsn:\n";
+    movInsn.Dump();
+  }
+
+  /* Add comment. */
+  MapleString newComment = ldrInsn.GetComment();
+  if (strInsn.IsStorePair()) {
+    newComment += ";  stp-load die version.";
+  } else {
+    newComment += ";  str-load die version.";
+  }
+  movInsn.SetComment(newComment);
+  cgFunc.GetRD()->InitGenUse(*ldrInsn.GetBB(), false);
+}
+
+bool AArch64StoreLoadOpt::HasMemBarrier(const Insn &ldrInsn, const Insn &strInsn) const {
+  if (!cgFunc.GetMirModule().IsCModule()) {
+    return false;
+  }
+  const Insn *currInsn = strInsn.GetNext();
+  while (currInsn != &ldrInsn) {
+    if (currInsn == nullptr) {
+      return false;
+    }
+    if (currInsn->IsMachineInstruction() && currInsn->IsCall()) {
+      return true;
+    }
+    currInsn = currInsn->GetNext();
+  }
+  return false;
+}
+
+/*
+ * Transfer: store wzr, [MEM]
+ *           ... // May exist branches.
+ *           load  x200, [MEM]
+ *        ==>
+ *        OPT_VERSION_STP_ZERO / OPT_VERSION_STR_ZERO:
+ *            store wzr, [MEM]
+ *            ... // May exist branches. if x100 not dead here.
+ *            mov   x200, wzr
+ *
+ *  Params:
+ *    stInsn: indicate store insn.
+ *    strSrcIdx: index of source register operand of store insn. (wzr in this example)
+ *    memUseInsnSet: insns using memOperand
+ */
+void AArch64StoreLoadOpt::DoLoadZeroToMoveTransfer(const Insn &strInsn, short strSrcIdx,
+                                                   const InsnSet &memUseInsnSet) const {
+  /* comment for strInsn should be only added once */
+  for (auto *ldrInsn : memUseInsnSet) {
+    /* Currently we don't support useInsn is ldp insn. */
+    if (!ldrInsn->IsLoad() || ldrInsn->GetDefRegs().size() > 1) {
+      continue;
+    }
+    if (HasMemBarrier(*ldrInsn, strInsn)) {
+      continue;
+    }
+    /* ldr reg, [mem], the index of [mem] is 1 */
+    InsnSet defInsnForUseInsns = cgFunc.GetRD()->FindDefForMemOpnd(*ldrInsn, 1);
+    /* If load has multiple definition, continue. */
+    if (defInsnForUseInsns.size() > 1) {
+      continue;
+    }
+
+    auto &resOpnd = ldrInsn->GetOperand(0);
+    auto &srcOpnd = strInsn.GetOperand(static_cast<uint32>(strSrcIdx));
+
+    if (resOpnd.GetSize() != srcOpnd.GetSize()) {
+      return;
+    }
+    RegOperand &resRegOpnd = static_cast<RegOperand&>(resOpnd);
+    MOperator movMop = SelectMovMop(resRegOpnd.IsOfFloatOrSIMDClass(), resRegOpnd.GetSize() == k64BitSize);
+    Insn &movInsn = cgFunc.GetInsnBuilder()->BuildInsn(movMop, resOpnd, srcOpnd);
+    movInsn.SetId(ldrInsn->GetId());
+    ldrInsn->GetBB()->ReplaceInsn(*ldrInsn, movInsn);
+
+    /* Add comment. */
+    MapleString newComment = ldrInsn->GetComment();
+    newComment += ",  str-load zero version";
+    movInsn.SetComment(newComment);
+  }
+}
+
+bool AArch64StoreLoadOpt::CheckStoreOpCode(MOperator opCode) const {
+  switch (opCode) {
+    case MOP_wstr:
+    case MOP_xstr:
+    case MOP_sstr:
+    case MOP_dstr:
+    case MOP_wstp:
+    case MOP_xstp:
+    case MOP_sstp:
+    case MOP_dstp:
+    case MOP_wstrb:
+    case MOP_wstrh:
+      return true;
+    default:
+      return false;
+  }
+}
+
+void AArch64StoreLoadOpt::MemPropInit() {
+  propMode = kUndef;
+  amount = 0;
+  removeDefInsn = false;
+}
+
+bool AArch64StoreLoadOpt::CheckReplaceReg(Insn &defInsn, Insn &currInsn, InsnSet &replaceRegDefSet,
+                                          regno_t replaceRegNo) {
+  if (replaceRegDefSet.empty()) {
+    return true;
+  }
+  if (defInsn.GetBB() == currInsn.GetBB()) {
+    /* check replace reg def between defInsn and currInsn */
+    Insn *tmpInsn = defInsn.GetNext();
+    while (tmpInsn != nullptr && tmpInsn != &currInsn) {
+      if (replaceRegDefSet.find(tmpInsn) != replaceRegDefSet.end()) {
+        return false;
+      }
+      tmpInsn = tmpInsn->GetNext();
+    }
+  } else {
+    regno_t defRegno = static_cast<RegOperand&>(defInsn.GetOperand(kInsnFirstOpnd)).GetRegisterNumber();
+    if (defRegno == replaceRegNo) {
+      uint32 defLoopId = 0;
+      uint32 curLoopId = 0;
+      if (defInsn.GetBB()->GetLoop()) {
+        defLoopId = defInsn.GetBB()->GetLoop()->GetHeader()->GetId();
+      }
+      if (currInsn.GetBB()->GetLoop()) {
+        curLoopId = currInsn.GetBB()->GetLoop()->GetHeader()->GetId();
+      }
+      if (defLoopId != curLoopId) {
+        return false;
+      }
+    }
+    AArch64ReachingDefinition *a64RD = static_cast<AArch64ReachingDefinition*>(cgFunc.GetRD());
+    if (a64RD->HasRegDefBetweenInsnGlobal(replaceRegNo, defInsn, currInsn)) {
+      return false;
+    }
+  }
+
+  if (replaceRegDefSet.size() == 1 && *replaceRegDefSet.begin() == &defInsn) {
+    /* lsl x1, x1, #3    <-----should be removed after replace MemOperand of ldrInsn.
+     * ldr x0, [x0,x1]   <-----should be single useInsn for x1
+     */
+    InsnSet newRegUseSet = cgFunc.GetRD()->FindUseForRegOpnd(defInsn, replaceRegNo, true);
+    if (newRegUseSet.size() != k1BitSize) {
+      return false;
+    }
+    removeDefInsn = true;
+  }
+  return true;
+}
+
+bool AArch64StoreLoadOpt::CheckDefInsn(Insn &defInsn, Insn &currInsn) {
+  if (defInsn.GetOperandSize() < k2ByteSize) {
+    return false;
+  }
+  for (uint32 i = kInsnSecondOpnd; i < defInsn.GetOperandSize(); i++) {
+    Operand &opnd = defInsn.GetOperand(i);
+    if (defInsn.IsMove() && opnd.IsRegister() && !cgFunc.IsSPOrFP(static_cast<RegOperand&>(opnd))) {
+      return false;
+    }
+    if (opnd.IsRegister()) {
+      RegOperand &a64OpndTmp = static_cast<RegOperand&>(opnd);
+      regno_t replaceRegNo = a64OpndTmp.GetRegisterNumber();
+      InsnSet newRegDefSet = cgFunc.GetRD()->FindDefForRegOpnd(currInsn, replaceRegNo, true);
+      if (!CheckReplaceReg(defInsn, currInsn, newRegDefSet, replaceRegNo)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool AArch64StoreLoadOpt::CheckNewAmount(const Insn &insn, uint32 newAmount) {
+  MOperator mOp = insn.GetMachineOpcode();
+  switch (mOp) {
+    case MOP_wstrb:
+    case MOP_wldrsb:
+    case MOP_xldrsb:
+    case MOP_wldrb: {
+      return newAmount == 0;
+    }
+    case MOP_wstrh:
+    case MOP_wldrsh:
+    case MOP_xldrsh:
+    case MOP_wldrh: {
+      return (newAmount == 0) || (newAmount == k1BitSize);
+    }
+    case MOP_wstr:
+    case MOP_sstr:
+    case MOP_wldr:
+    case MOP_sldr:
+    case MOP_xldrsw: {
+      return (newAmount == 0) || (newAmount == k2BitSize);
+    }
+    case MOP_qstr:
+    case MOP_qldr: {
+      return (newAmount == 0) || (newAmount == k4BitSize);
+    }
+    default: {
+      return (newAmount == 0) || (newAmount == k3ByteSize);
+    }
+  }
+}
+
+bool AArch64StoreLoadOpt::CheckNewMemOffset(const Insn &insn, MemOperand *newMemOpnd, uint32 opndIdx) {
+  AArch64CGFunc &a64CgFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  if ((newMemOpnd->GetOffsetImmediate() != nullptr) &&
+      !a64CgFunc.IsOperandImmValid(insn.GetMachineOpcode(), newMemOpnd, opndIdx)) {
+    return false;
+  }
+  auto newAmount = newMemOpnd->ShiftAmount();
+  if (!CheckNewAmount(insn, newAmount)) {
+    return false;
+  }
+  /* is ldp or stp, addrMode must be BOI */
+  if ((opndIdx == kInsnThirdOpnd) && (newMemOpnd->GetAddrMode() != MemOperand::kAddrModeBOi)) {
+    return false;
+  }
+  return true;
+}
+
+MemOperand *AArch64StoreLoadOpt::SelectReplaceExt(const Insn &defInsn, RegOperand &base, bool isSigned) {
+  MemOperand *newMemOpnd = nullptr;
+  RegOperand *newOffset = static_cast<RegOperand*>(&defInsn.GetOperand(kInsnSecondOpnd));
+  CHECK_FATAL(newOffset != nullptr, "newOffset is null!");
+  /* defInsn is extend, currMemOpnd is same extend or shift */
+  bool propExtend = (propMode == kPropShift) || ((propMode == kPropSignedExtend) && isSigned) ||
+                    ((propMode == kPropUnsignedExtend) && !isSigned);
+  if (propMode == kPropOffset) {
+    newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+        MemOperand::kAddrModeBOrX, k64BitSize, base, *newOffset, 0, isSigned);
+  } else if (propExtend) {
+    newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+        MemOperand::kAddrModeBOrX, k64BitSize, base, *newOffset, amount, isSigned);
+  } else {
+    return nullptr;
+  }
+  return newMemOpnd;
+}
+
+MemOperand *AArch64StoreLoadOpt::HandleArithImmDef(RegOperand &replace,
+                                                   Operand *oldOffset, int64 defVal) {
+  if (propMode != kPropBase) {
+    return nullptr;
+  }
+  OfstOperand *newOfstImm = nullptr;
+  if (oldOffset == nullptr) {
+    newOfstImm = &static_cast<AArch64CGFunc&>(cgFunc).CreateOfstOpnd(static_cast<uint64>(defVal), k32BitSize);
+  } else {
+    auto *ofstOpnd = static_cast<OfstOperand*>(oldOffset);
+    CHECK_FATAL(ofstOpnd != nullptr, "oldOffsetOpnd is null");
+    newOfstImm = &static_cast<AArch64CGFunc&>(cgFunc).CreateOfstOpnd(
+        static_cast<uint64>(defVal + ofstOpnd->GetValue()), k32BitSize);
+  }
+  CHECK_FATAL(newOfstImm != nullptr, "newOffset is null!");
+  return static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(MemOperand::kAddrModeBOi, k64BitSize,
+                                                              replace, nullptr, newOfstImm, nullptr);
+}
+
+/*
+ * limit to adjacent bb to avoid ra spill.
+ */
+bool AArch64StoreLoadOpt::IsAdjacentBB(Insn &defInsn, Insn &curInsn) const {
+  if (defInsn.GetBB() == curInsn.GetBB()) {
+    return true;
+  }
+  for (auto *bb : defInsn.GetBB()->GetSuccs()) {
+    if (bb == curInsn.GetBB()) {
+      return true;
+    }
+    if (bb->IsSoloGoto()) {
+      BB *tragetBB = CGCFG::GetTargetSuc(*bb);
+      if (tragetBB == curInsn.GetBB()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/*
+ * currAddrMode | defMop       | propMode | replaceAddrMode
+ * =============================================================================
+ * boi          | addrri       | base     | boi, update imm(offset)
+ *              | addrrr       | base     | imm(offset) == 0(nullptr) ? borx : NA
+ *              | subrri       | base     | boi, update imm(offset)
+ *              | subrrr       | base     | NA
+ *              | adrpl12      | base     | imm(offset) == 0(nullptr) ? literal : NA
+ *              | movrr        | base     | boi
+ *              | movri        | base     | NA
+ *              | extend/lsl   | base     | NA
+ * =============================================================================
+ * borx         | addrri       | offset   | NA
+ * (noextend)   | addrrr       | offset   | NA
+ *              | subrri       | offset   | NA
+ *              | subrrr       | offset   | NA
+ *              | adrpl12      | offset   | NA
+ *              | movrr        | offset   | borx
+ *              | movri        | offset   | bori
+ *              | extend/lsl   | offset   | borx(with extend)
+ * =============================================================================
+ * borx         | addrri       | extend   | NA
+ * (extend)     | addrrr       | extend   | NA
+ *              | subrri       | extend   | NA
+ *              | subrrr       | extend   | NA
+ *              | adrpl12      | extend   | NA
+ *              | movrr        | extend   | borx
+ *              | movri        | extend   | NA
+ *              | extend/lsl   | extend   | borx(with extend)
+ * =============================================================================
+ */
+MemOperand *AArch64StoreLoadOpt::SelectReplaceMem(Insn &defInsn, Insn &curInsn,
+                                                  RegOperand &base, Operand *offset) {
+  MemOperand *newMemOpnd = nullptr;
+  MOperator opCode = defInsn.GetMachineOpcode();
+  RegOperand *replace = static_cast<RegOperand*>(&defInsn.GetOperand(kInsnSecondOpnd));
+  switch (opCode) {
+    case MOP_xsubrri12:
+    case MOP_wsubrri12: {
+      if (!IsAdjacentBB(defInsn, curInsn)) {
+        break;
+      }
+      auto &immOpnd = static_cast<ImmOperand&>(defInsn.GetOperand(kInsnThirdOpnd));
+      int64 defVal = -(immOpnd.GetValue());
+      newMemOpnd = HandleArithImmDef(*replace, offset, defVal);
+      break;
+    }
+    case MOP_xaddrri12:
+    case MOP_waddrri12: {
+      auto &immOpnd = static_cast<ImmOperand&>(defInsn.GetOperand(kInsnThirdOpnd));
+      int64 defVal = immOpnd.GetValue();
+      newMemOpnd = HandleArithImmDef(*replace, offset, defVal);
+      break;
+    }
+    case MOP_xaddrrr:
+    case MOP_waddrrr:
+    case MOP_dadd:
+    case MOP_sadd: {
+      if (propMode == kPropBase) {
+        ImmOperand *ofstOpnd = static_cast<ImmOperand*>(offset);
+        if (!ofstOpnd->IsZero()) {
+          break;
+        }
+        RegOperand *newOffset = static_cast<RegOperand*>(&defInsn.GetOperand(kInsnThirdOpnd));
+        CHECK_FATAL(newOffset != nullptr, "newOffset is null!");
+        newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+            MemOperand::kAddrModeBOrX, k64BitSize, *replace, newOffset, nullptr, nullptr);
+      }
+      break;
+    }
+    case MOP_xadrpl12: {
+      if (propMode == kPropBase) {
+        ImmOperand *ofstOpnd = static_cast<ImmOperand*>(offset);
+        CHECK_FATAL(ofstOpnd != nullptr, "oldOffset is null!");
+        int64 val = ofstOpnd->GetValue();
+        StImmOperand *offset1 = static_cast<StImmOperand*>(&defInsn.GetOperand(kInsnThirdOpnd));
+        CHECK_FATAL(offset1 != nullptr, "offset1 is null!");
+        val += offset1->GetOffset();
+        OfstOperand *newOfsetOpnd = &static_cast<AArch64CGFunc&>(cgFunc).CreateOfstOpnd(
+            static_cast<uint64>(val), k32BitSize);
+        CHECK_FATAL(newOfsetOpnd != nullptr, "newOfsetOpnd is null!");
+        const MIRSymbol *addr = offset1->GetSymbol();
+        /* do not guarantee rodata alignment at Os */
+        if (CGOptions::OptimizeForSize() && addr->IsReadOnly()) {
+          break;
+        }
+        newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+            MemOperand::kAddrModeLo12Li, k64BitSize, *replace, nullptr, newOfsetOpnd, addr);
+      }
+      break;
+    }
+    case MOP_xmovrr:
+    case MOP_wmovrr: {
+      if (propMode == kPropBase) {
+        OfstOperand *offsetTmp = static_cast<OfstOperand*>(offset);
+        CHECK_FATAL(offsetTmp != nullptr, "newOffset is null!");
+        newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+            MemOperand::kAddrModeBOi, k64BitSize, *replace, nullptr, offsetTmp, nullptr);
+      } else if (propMode == kPropOffset) { /* if newOffset is SP, swap base and newOffset */
+        if (cgFunc.IsSPOrFP(*replace)) {
+          newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+              MemOperand::kAddrModeBOrX, k64BitSize, *replace, &base, nullptr, nullptr);
+        } else {
+          newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+              MemOperand::kAddrModeBOrX, k64BitSize, base, replace, nullptr, nullptr);
+        }
+      } else if (propMode == kPropSignedExtend) {
+        newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+            MemOperand::kAddrModeBOrX, k64BitSize, base, *replace, amount, true);
+      } else {
+        newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+            MemOperand::kAddrModeBOrX, k64BitSize, base, *replace, amount);
+      }
+      break;
+    }
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      if (propMode == kPropOffset) {
+        ImmOperand *imm = static_cast<ImmOperand*>(&defInsn.GetOperand(kInsnSecondOpnd));
+        OfstOperand *newOffset = &static_cast<AArch64CGFunc&>(cgFunc).CreateOfstOpnd(
+            static_cast<uint64>(imm->GetValue()), k32BitSize);
+        CHECK_FATAL(newOffset != nullptr, "newOffset is null!");
+        newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+            MemOperand::kAddrModeBOi, k64BitSize, base, nullptr, newOffset, nullptr);
+      }
+      break;
+    }
+    case MOP_xlslrri6:
+    case MOP_wlslrri5: {
+      ImmOperand *imm = static_cast<ImmOperand*>(&defInsn.GetOperand(kInsnThirdOpnd));
+      RegOperand *newOffset = static_cast<RegOperand*>(&defInsn.GetOperand(kInsnSecondOpnd));
+      CHECK_FATAL(newOffset != nullptr, "newOffset is null!");
+      uint32 shift = static_cast<uint32>(imm->GetValue());
+      if (propMode == kPropOffset) {
+        if ((shift < k4ByteSize) && (shift >= 0)) {
+          newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+              MemOperand::kAddrModeBOrX, k64BitSize, base, *newOffset, shift);
+        }
+      } else if (propMode == kPropShift) {
+        shift += amount;
+        if ((shift < k4ByteSize) && (shift >= 0)) {
+          newMemOpnd = static_cast<AArch64CGFunc&>(cgFunc).CreateMemOperand(
+              MemOperand::kAddrModeBOrX, k64BitSize, base, *newOffset, shift);
+        }
+      }
+      break;
+    }
+    case MOP_xsxtw64: {
+      newMemOpnd = SelectReplaceExt(defInsn, base, true);
+      break;
+    }
+    case MOP_xuxtw64: {
+      newMemOpnd = SelectReplaceExt(defInsn, base, false);
+      break;
+    }
+    default:
+      break;
+  }
+  return newMemOpnd;
+}
+
+bool AArch64StoreLoadOpt::ReplaceMemOpnd(Insn &insn, regno_t regNo, RegOperand &base, Operand *offset) {
+  AArch64ReachingDefinition *a64RD = static_cast<AArch64ReachingDefinition*>(cgFunc.GetRD());
+  CHECK_FATAL((a64RD != nullptr), "check a64RD!");
+  InsnSet regDefSet = a64RD->FindDefForRegOpnd(insn, regNo, true);
+  if (regDefSet.size() != k1BitSize) {
+    return false;
+  }
+  Insn *regDefInsn = *regDefSet.begin();
+  if (!CheckDefInsn(*regDefInsn, insn)) {
+    return false;
+  }
+  MemOperand *newMemOpnd = SelectReplaceMem(*regDefInsn, insn, base, offset);
+  if (newMemOpnd == nullptr) {
+    return false;
+  }
+
+  /* check new memOpnd */
+  if (newMemOpnd->GetBaseRegister() != nullptr) {
+    InsnSet regDefSetForNewBase =
+        a64RD->FindDefForRegOpnd(insn, newMemOpnd->GetBaseRegister()->GetRegisterNumber(), true);
+    if (regDefSetForNewBase.size() != k1BitSize) {
+      return false;
+    }
+  }
+  if (newMemOpnd->GetIndexRegister() != nullptr) {
+    InsnSet regDefSetForNewIndex =
+        a64RD->FindDefForRegOpnd(insn, newMemOpnd->GetIndexRegister()->GetRegisterNumber(), true);
+    if (regDefSetForNewIndex.size() != k1BitSize) {
+      return false;
+    }
+  }
+
+  uint32 opndIdx;
+  if (insn.IsLoadPair() || insn.IsStorePair()) {
+    if (newMemOpnd->GetOffsetImmediate() == nullptr) {
+      return false;
+    }
+    opndIdx = kInsnThirdOpnd;
+  } else {
+    opndIdx = kInsnSecondOpnd;
+  }
+  if (!CheckNewMemOffset(insn, newMemOpnd, opndIdx)) {
+    return false;
+  }
+  if (CG_DEBUG_FUNC(cgFunc)) {
+    std::cout << "replace insn:" << std::endl;
+    insn.Dump();
+  }
+  insn.SetOperand(opndIdx, *newMemOpnd);
+  if (CG_DEBUG_FUNC(cgFunc)) {
+    std::cout << "new insn:" << std::endl;
+    insn.Dump();
+  }
+  if (removeDefInsn) {
+    if (CG_DEBUG_FUNC(cgFunc)) {
+      std::cout << "remove insn:" << std::endl;
+      regDefInsn->Dump();
+    }
+    regDefInsn->GetBB()->RemoveInsn(*regDefInsn);
+  }
+  cgFunc.GetRD()->InitGenUse(*regDefInsn->GetBB(), false);
+  cgFunc.GetRD()->UpdateInOut(*insn.GetBB(), false);
+  cgFunc.GetRD()->UpdateInOut(*insn.GetBB(), true);
+  return true;
+}
+
+bool AArch64StoreLoadOpt::CanDoMemProp(const Insn *insn) {
+  if (!cgFunc.GetMirModule().IsCModule()) {
+    return false;
+  }
+  if (!insn->IsMachineInstruction()) {
+    return false;
+  }
+  if (insn->GetMachineOpcode() == MOP_qstr) {
+    return false;
+  }
+
+  if (insn->IsLoad() || insn->IsStore()) {
+    if (insn->IsAtomic()) {
+      return false;
+    }
+    // It is not desired to propagate on 128bit reg with immediate offset
+    // which may cause linker to issue misalignment error
+    if (insn->IsAtomic() || insn->GetOperand(0).GetSize() == k128BitSize) {
+      return false;
+    }
+    MemOperand *currMemOpnd = static_cast<MemOperand*>(insn->GetMemOpnd());
+    return currMemOpnd != nullptr;
+  }
+  return false;
+}
+
+void AArch64StoreLoadOpt::SelectPropMode(const MemOperand &currMemOpnd) {
+  MemOperand::AArch64AddressingMode currAddrMode = currMemOpnd.GetAddrMode();
+  switch (currAddrMode) {
+    case MemOperand::kAddrModeBOi: {
+      if (!currMemOpnd.IsPreIndexed() && !currMemOpnd.IsPostIndexed()) {
+        propMode = kPropBase;
+      }
+      break;
+    }
+    case MemOperand::kAddrModeBOrX: {
+      propMode = kPropOffset;
+      amount = currMemOpnd.ShiftAmount();
+      if (currMemOpnd.GetExtendAsString() == "LSL") {
+        if (amount != 0) {
+          propMode = kPropShift;
+        }
+        break;
+      } else if (currMemOpnd.SignedExtend()) {
+        propMode = kPropSignedExtend;
+      } else if (currMemOpnd.UnsignedExtend()) {
+        propMode = kPropUnsignedExtend;
+      }
+      break;
+    }
+    default:
+      propMode = kUndef;
+  }
+}
+
+/*
+ * Optimize: store x100, [MEM]
+ *           ... // May exist branches.
+ *           load  x200, [MEM]
+ *        ==>
+ *        OPT_VERSION_STP_LIVE / OPT_VERSION_STR_LIVE:
+ *           store x100, [MEM]
+ *           ... // May exist branches. if x100 not dead here.
+ *           mov   x200, x100
+ *        OPT_VERSION_STP_DIE / OPT_VERSION_STR_DIE:
+ *           store x100, [MEM]
+ *           mov x9000(new reg), x100
+ *           ... // May exist branches. if x100 dead here.
+ *           mov   x200, x9000
+ *
+ *  Note: x100 may be wzr/xzr registers.
+ */
+void AArch64StoreLoadOpt::DoStoreLoadOpt() {
+  AArch64CGFunc &a64CgFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  if (a64CgFunc.IsIntrnCallForC()) {
+    return;
+  }
+  FOR_ALL_BB(bb, &a64CgFunc) {
+    FOR_BB_INSNS_SAFE(insn, bb, next) {
+      MOperator mOp = insn->GetMachineOpcode();
+      if (CanDoMemProp(insn)) {
+        MemProp(*insn);
+      }
+      if (a64CgFunc.GetMirModule().IsCModule() && cgFunc.GetRD()->OnlyAnalysisReg()) {
+        continue;
+      }
+      if (!insn->IsMachineInstruction() || !insn->IsStore() || !CheckStoreOpCode(mOp) ||
+          (a64CgFunc.GetMirModule().IsCModule() && !a64CgFunc.IsAfterRegAlloc()) ||
+          (!a64CgFunc.GetMirModule().IsCModule() && a64CgFunc.IsAfterRegAlloc())) {
+        continue;
+      }
+      if (insn->IsStorePair()) {
+        ProcessStrPair(*insn);
+        continue;
+      }
+      ProcessStr(*insn);
+    }
+  }
+}
+
+/*
+ * PropBase:
+ *   add/sub x1, x2, #immVal1
+ *   ...(no def of x2)
+ *   ldr/str x0, [x1, #immVal2]
+ *   ======>
+ *   add/sub x1, x2, #immVal1
+ *   ...
+ *   ldr/str x0, [x2, #(immVal1 + immVal2)/#(-immVal1 + immVal2)]
+ *
+ * PropOffset:
+ *   sxtw x2, w2
+ *   lsl x1, x2, #1~3
+ *   ...(no def of x2)
+ *   ldr/str x0, [x0, x1]
+ *   ======>
+ *   sxtw x2, w2
+ *   lsl x1, x2, #1~3
+ *   ...
+ *   ldr/str x0, [x0, w2, sxtw 1~3]
+ */
+void AArch64StoreLoadOpt::MemProp(Insn &insn) {
+  MemPropInit();
+  MemOperand *currMemOpnd = static_cast<MemOperand*>(insn.GetMemOpnd());
+  SelectPropMode(*currMemOpnd);
+  RegOperand *base = currMemOpnd->GetBaseRegister();
+  Operand *offset = currMemOpnd->GetOffset();
+  bool memReplaced = false;
+
+  if (propMode == kUndef) {
+    return;
+  } else if (propMode == kPropBase) {
+    ImmOperand *immOffset = static_cast<ImmOperand*>(offset);
+    CHECK_FATAL(immOffset != nullptr, "immOffset is nullptr!");
+    regno_t baseRegNo = base->GetRegisterNumber();
+    memReplaced = ReplaceMemOpnd(insn, baseRegNo, *base, immOffset);
+  } else {
+    RegOperand *regOffset = static_cast<RegOperand*>(offset);
+    if (regOffset == nullptr) {
+      return;
+    }
+    regno_t offsetRegNo = regOffset->GetRegisterNumber();
+    memReplaced = ReplaceMemOpnd(insn, offsetRegNo, *base, regOffset);
+  }
+
+  /* if prop success, find more prop chance */
+  if (memReplaced) {
+    MemProp(insn);
+  }
+}
+
+/*
+ * Assume stack(FP) will not be varied out of pro/epi log
+ * PreIndex:
+ *   add/sub x1, x1 #immVal1
+ *   ...(no def/use of x1)
+ *   ldr/str x0, [x1]
+ *   ======>
+ *   ldr/str x0, [x1, #immVal1]!
+ *
+ * PostIndex:
+ *   ldr/str x0, [x1]
+ *   ...(no def/use of x1)
+ *   add/sub x1, x1, #immVal1
+ *   ======>
+ *   ldr/str x0, [x1],  #immVal1
+ */
+void AArch64StoreLoadOpt::StrLdrIndexModeOpt(Insn &currInsn) {
+  auto *curMemopnd = static_cast<MemOperand*>(currInsn.GetMemOpnd());
+  ASSERT(curMemopnd != nullptr, " get memopnd failed");
+  /* one instruction cannot define one register twice */
+  if (!CanDoIndexOpt(*curMemopnd) || currInsn.IsRegDefined(curMemopnd->GetBaseRegister()->GetRegisterNumber())) {
+    return;
+  }
+  MemOperand *newMemopnd = SelectIndexOptMode(currInsn, *curMemopnd);
+  if (newMemopnd != nullptr) {
+    currInsn.SetMemOpnd(newMemopnd);
+  }
+}
+
+bool AArch64StoreLoadOpt::CanDoIndexOpt(const MemOperand &currMemOpnd) {
+  if (currMemOpnd.GetAddrMode() != MemOperand::kAddrModeBOi || !currMemOpnd.IsIntactIndexed()) {
+    return false;
+  }
+  ASSERT(currMemOpnd.GetOffsetImmediate() != nullptr, " kAddrModeBOi memopnd have no offset imm");
+  if (!currMemOpnd.GetOffsetImmediate()->IsImmOffset()) {
+    return false;
+  }
+  if (cgFunc.IsSPOrFP(*currMemOpnd.GetBaseRegister())) {
+    return false;
+  }
+  OfstOperand *a64Ofst = currMemOpnd.GetOffsetImmediate();
+  if (a64Ofst == nullptr) {
+    return false;
+  }
+  return a64Ofst->GetValue() == 0;
+}
+
+int64 AArch64StoreLoadOpt::GetOffsetForNewIndex(Insn &defInsn, Insn &insn,
+                                                regno_t baseRegNO, uint32 memOpndSize) const {
+  bool subMode = defInsn.GetMachineOpcode() == MOP_wsubrri12 || defInsn.GetMachineOpcode() == MOP_xsubrri12;
+  bool addMode = defInsn.GetMachineOpcode() == MOP_waddrri12 || defInsn.GetMachineOpcode() == MOP_xaddrri12;
+  if (addMode || subMode) {
+    ASSERT(static_cast<RegOperand&>(defInsn.GetOperand(kInsnFirstOpnd)).GetRegisterNumber() == baseRegNO,
+           "check def opnd");
+    auto &srcOpnd = static_cast<RegOperand&>(defInsn.GetOperand(kInsnSecondOpnd));
+    if (srcOpnd.GetRegisterNumber() == baseRegNO && defInsn.GetBB() == insn.GetBB()) {
+      int64 offsetVal = static_cast<ImmOperand&>(defInsn.GetOperand(kInsnThirdOpnd)).GetValue();
+      if (!MemOperand::IsSIMMOffsetOutOfRange(offsetVal, memOpndSize == k64BitSize, insn.IsLoadStorePair())) {
+        return subMode ? -offsetVal : offsetVal;
+      }
+    }
+  }
+  return kMaxPimm8; /* simm max value cannot excced pimm max value */
+};
+
+
+MemOperand *AArch64StoreLoadOpt::SelectIndexOptMode(Insn &insn, const MemOperand &curMemOpnd) {
+  AArch64ReachingDefinition *a64RD = static_cast<AArch64ReachingDefinition*>(cgFunc.GetRD());
+  ASSERT((a64RD != nullptr), "check a64RD!");
+  regno_t baseRegisterNO = curMemOpnd.GetBaseRegister()->GetRegisterNumber();
+  auto &a64cgFunc = static_cast<AArch64CGFunc&>(cgFunc);
+  /* pre index */
+  InsnSet regDefSet = a64RD->FindDefForRegOpnd(insn, baseRegisterNO, true);
+  if (regDefSet.size() == k1BitSize) {
+    Insn *defInsn = *regDefSet.begin();
+    int64 defOffset = GetOffsetForNewIndex(*defInsn, insn, baseRegisterNO, curMemOpnd.GetSize());
+    if (defOffset < kMaxPimm8) {
+      InsnSet tempCheck;
+      (void)a64RD->FindRegUseBetweenInsn(baseRegisterNO, defInsn->GetNext(), insn.GetPrev(), tempCheck);
+      if (tempCheck.empty() && (defInsn->GetBB() == insn.GetBB())) {
+        auto &newMem =
+            a64cgFunc.CreateMemOpnd(*curMemOpnd.GetBaseRegister(), defOffset, curMemOpnd.GetSize());
+        ASSERT(newMem.GetOffsetImmediate() != nullptr, "need offset for memopnd in this case");
+        newMem.SetIndexOpt(MemOperand::kPreIndex);
+        insn.GetBB()->RemoveInsn(*defInsn);
+        return &newMem;
+      }
+    }
+  }
+  /* post index */
+  std::vector<Insn*> refDefVec = a64RD->FindRegDefBetweenInsn(baseRegisterNO, &insn, insn.GetBB()->GetLastInsn(), true);
+  if (!refDefVec.empty()) {
+    Insn *defInsn = refDefVec.back();
+    int64 defOffset = GetOffsetForNewIndex(*defInsn, insn, baseRegisterNO, curMemOpnd.GetSize());
+    if (defOffset < kMaxPimm8) {
+      InsnSet tempCheck;
+      (void)a64RD->FindRegUseBetweenInsn(baseRegisterNO, insn.GetNext(), defInsn->GetPrev(), tempCheck);
+      if (tempCheck.empty() && (defInsn->GetBB() == insn.GetBB())) {
+        auto &newMem = a64cgFunc.CreateMemOpnd(
+            *curMemOpnd.GetBaseRegister(), defOffset, curMemOpnd.GetSize());
+        ASSERT(newMem.GetOffsetImmediate() != nullptr, "need offset for memopnd in this case");
+        newMem.SetIndexOpt(MemOperand::kPostIndex);
+        insn.GetBB()->RemoveInsn(*defInsn);
+        return &newMem;
+      }
+    }
+  }
+  return nullptr;
+}
+
+void AArch64StoreLoadOpt::ProcessStrPair(Insn &insn) {
+  const short memIndex = 2;
+  short regIndex = 0;
+  Operand &opnd = insn.GetOperand(memIndex);
+  auto &memOpnd = static_cast<MemOperand&>(opnd);
+  RegOperand *base = memOpnd.GetBaseRegister();
+  if ((base == nullptr) || !(cgFunc.GetRD()->IsFrameReg(*base))) {
+    return;
+  }
+  if (cgFunc.IsAfterRegAlloc() && !insn.IsSpillInsn()) {
+    return;
+  }
+  ASSERT(memOpnd.GetIndexRegister() == nullptr, "frame MemOperand must not be exist register index");
+  InsnSet memUseInsnSet;
+  for (int i = 0; i != kMaxMovNum; ++i) {
+    memUseInsnSet.clear();
+    if (i == 0) {
+      regIndex = 0;
+      memUseInsnSet = cgFunc.GetRD()->FindUseForMemOpnd(insn, memIndex);
+    } else {
+      regIndex = 1;
+      memUseInsnSet = cgFunc.GetRD()->FindUseForMemOpnd(insn, memIndex, true);
+    }
+    if (memUseInsnSet.empty()) {
+      return;
+    }
+    auto &regOpnd = static_cast<RegOperand&>(insn.GetOperand(static_cast<uint32>(regIndex)));
+    if (regOpnd.GetRegisterNumber() == RZR) {
+      DoLoadZeroToMoveTransfer(insn, regIndex, memUseInsnSet);
+    } else {
+      DoLoadToMoveTransfer(insn, regIndex, i, memUseInsnSet);
+    }
+  }
+}
+
+void AArch64StoreLoadOpt::ProcessStr(Insn &insn) {
+  /* str x100, [mem], mem index is 1, x100 index is 0; */
+  const short memIndex = 1;
+  const short regIndex = 0;
+  Operand &opnd = insn.GetOperand(memIndex);
+  auto &memOpnd = static_cast<MemOperand&>(opnd);
+  RegOperand *base = memOpnd.GetBaseRegister();
+  if ((base == nullptr) || !(cgFunc.GetRD()->IsFrameReg(*base))) {
+    return;
+  }
+
+  if (cgFunc.IsAfterRegAlloc() && !insn.IsSpillInsn()) {
+    return;
+  }
+  ASSERT(memOpnd.GetIndexRegister() == nullptr, "frame MemOperand must not be exist register index");
+
+  InsnSet memUseInsnSet = cgFunc.GetRD()->FindUseForMemOpnd(insn, memIndex);
+  if (memUseInsnSet.empty()) {
+    return;
+  }
+
+  auto *regOpnd = static_cast<RegOperand*>(&insn.GetOperand(regIndex));
+  CHECK_NULL_FATAL(regOpnd);
+  if (regOpnd->GetRegisterNumber() == RZR) {
+    DoLoadZeroToMoveTransfer(insn, regIndex, memUseInsnSet);
+  } else {
+    DoLoadToMoveTransfer(insn, regIndex, 0, memUseInsnSet);
+  }
+  if (cgFunc.IsAfterRegAlloc() && insn.IsSpillInsn()) {
+    InsnSet newmemUseInsnSet = cgFunc.GetRD()->FindUseForMemOpnd(insn, memIndex);
+    if (newmemUseInsnSet.empty()) {
+      insn.GetBB()->RemoveInsn(insn);
+    }
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_tailcall.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_tailcall.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df44817e5197f6325e654be6a4b4df4f4701eaa9
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_tailcall.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#include "aarch64_tailcall.h"
+#include "aarch64_abi.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+using namespace std;
+const std::set<std::string> kFrameWhiteListFunc {
+#include "framewhitelist.def"
+};
+
+bool AArch64TailCallOpt::IsFuncNeedFrame(Insn &callInsn) const {
+  auto &target = static_cast<FuncNameOperand&>(callInsn.GetOperand(0));
+  return kFrameWhiteListFunc.find(target.GetName()) != kFrameWhiteListFunc.end();
+}
+
+bool AArch64TailCallOpt::InsnIsCallCand(Insn &insn) const {
+  return (insn.GetMachineOpcode() == MOP_xbr ||
+          insn.GetMachineOpcode() == MOP_xblr ||
+          insn.GetMachineOpcode() == MOP_xbl ||
+          insn.GetMachineOpcode() == MOP_xuncond);
+}
+
+bool AArch64TailCallOpt::InsnIsLoadPair(Insn &insn) const {
+  return (insn.GetMachineOpcode() == MOP_xldr ||
+          insn.GetMachineOpcode() == MOP_xldp ||
+          insn.GetMachineOpcode() == MOP_dldr ||
+          insn.GetMachineOpcode() == MOP_dldp);
+}
+
+bool AArch64TailCallOpt::InsnIsMove(Insn &insn) const {
+  return (insn.GetMachineOpcode() == MOP_wmovrr ||
+          insn.GetMachineOpcode() == MOP_xmovrr);
+}
+
+bool AArch64TailCallOpt::InsnIsIndirectCall(Insn &insn) const {
+  return (insn.GetMachineOpcode() == MOP_xblr);
+}
+
+bool AArch64TailCallOpt::InsnIsCall(Insn &insn) const {
+  return (insn.GetMachineOpcode() == MOP_xbl);
+}
+
+bool AArch64TailCallOpt::InsnIsUncondJump(Insn &insn) const {
+  return (insn.GetMachineOpcode() == MOP_xuncond);
+}
+
+bool AArch64TailCallOpt::InsnIsAddWithRsp(Insn &insn) const {
+  if (insn.GetMachineOpcode() == MOP_xaddrri12 || insn.GetMachineOpcode() == MOP_xaddrri24) {
+    RegOperand &reg = static_cast<RegOperand&>(insn.GetOperand(0));
+    if (reg.GetRegisterNumber() == RSP) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AArch64TailCallOpt::OpndIsStackRelatedReg(RegOperand &opnd) const {
+  return (opnd.GetRegisterNumber() == R29 || opnd.GetRegisterNumber() == R31 || opnd.GetRegisterNumber() == RSP);
+}
+
+bool AArch64TailCallOpt::OpndIsR0Reg(RegOperand &opnd) const {
+  return (opnd.GetRegisterNumber() == R0);
+}
+
+bool AArch64TailCallOpt::OpndIsCalleeSaveReg(RegOperand &opnd) const {
+  return AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(opnd.GetRegisterNumber()));
+}
+
+bool AArch64TailCallOpt::IsAddOrSubOp(MOperator mOp) const {
+  switch (mOp) {
+    case MOP_xaddrrr:
+    case MOP_xaddrrrs:
+    case MOP_xxwaddrrre:
+    case MOP_xaddrri24:
+    case MOP_xaddrri12:
+    case MOP_xsubrrr:
+    case MOP_xsubrrrs:
+    case MOP_xxwsubrrre:
+    case MOP_xsubrri12:
+      return true;
+    default:
+      return false;
+  }
+}
+
+void AArch64TailCallOpt::ReplaceInsnMopWithTailCall(Insn &insn) {
+  MOperator insnMop = insn.GetMachineOpcode();
+  switch (insnMop) {
+    case MOP_xbl: {
+      insn.SetMOP(AArch64CG::kMd[MOP_tail_call_opt_xbl]);
+      break;
+    }
+    case MOP_xblr: {
+      insn.SetMOP(AArch64CG::kMd[MOP_tail_call_opt_xblr]);
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "Internal error.");
+      break;
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_utils.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4de26aa51e2bcbe651ccb8f03b76a516564c7511
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_utils.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_utils.h"
+#include "cg_option.h"
+
+namespace maplebe {
+
+MemOperand *GetOrCreateMemOperandForNewMOP(CGFunc &cgFunc,
+                                           const Insn &loadIns,
+                                           MOperator newLoadMop) {
+  MemPool &memPool = *cgFunc.GetMemoryPool();
+  auto *memOp = static_cast<MemOperand *>(loadIns.GetMemOpnd());
+  MOperator loadMop = loadIns.GetMachineOpcode();
+
+  ASSERT(loadIns.IsLoad() && AArch64CG::kMd[newLoadMop].IsLoad(),
+         "ins and Mop must be load");
+
+  MemOperand *newMemOp = memOp;
+
+  uint32 memSize = AArch64CG::kMd[loadMop].GetOperandSize();
+  uint32 newMemSize = AArch64CG::kMd[newLoadMop].GetOperandSize();
+  if (newMemSize == memSize) {
+    // if sizes are the same just return old memory operand
+    return newMemOp;
+  }
+
+  newMemOp = memOp->Clone(memPool);
+  newMemOp->SetSize(newMemSize);
+
+  if (!CGOptions::IsBigEndian()) {
+    return newMemOp;
+  }
+
+  // for big-endian it's necessary to adjust offset if it's present
+  if (memOp->GetAddrMode() != MemOperand::kAddrModeBOi ||
+      newMemSize > memSize) {
+    // currently, it's possible to adjust an offset only for immediate offset
+    // operand if new size is less than the original one
+    return nullptr;
+  }
+
+  auto *newOffOp = static_cast<OfstOperand *>(
+      memOp->GetOffsetImmediate()->Clone(memPool));
+
+  newOffOp->AdjustOffset(static_cast<int32>((memSize - newMemSize) >> kLog2BitsPerByte));
+  newMemOp->SetOffsetOperand(*newOffOp);
+
+  ASSERT(memOp->IsOffsetMisaligned(memSize) ||
+         !newMemOp->IsOffsetMisaligned(newMemSize),
+         "New offset value is misaligned!");
+
+  return newMemOp;
+}
+
+} // namespace maplebe
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_validbit_opt.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_validbit_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..39e0e0b8e582a49f93c85f048e3e94f3c737a668
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_validbit_opt.cpp
@@ -0,0 +1,621 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_validbit_opt.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+void AArch64ValidBitOpt::DoOpt(BB &bb, Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  switch (curMop) {
+    case MOP_wandrri12:
+    case MOP_xandrri13: {
+      Optimize<AndValidBitPattern>(bb, insn);
+      break;
+    }
+    case MOP_xuxtb32:
+    case MOP_xuxth32:
+    case MOP_xsxtw64:
+    case MOP_wubfxrri5i5:
+    case MOP_xubfxrri6i6:
+    case MOP_wsbfxrri5i5:
+    case MOP_xsbfxrri6i6: {
+      Optimize<ExtValidBitPattern>(bb, insn);
+      break;
+    }
+    case MOP_wcsetrc:
+    case MOP_xcsetrc: {
+      Optimize<CmpCsetVBPattern>(bb, insn);
+      break;
+    }
+    case MOP_bge:
+    case MOP_blt: {
+      Optimize<CmpBranchesPattern>(bb, insn);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void AArch64ValidBitOpt::SetValidBits(Insn &insn) {
+  MOperator mop = insn.GetMachineOpcode();
+  switch (mop) {
+    case MOP_wuxtb_vb:
+    case MOP_wuxth_vb: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      auto &srcOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      uint32 newVB = (mop == MOP_wuxtb_vb ? k8BitSize : k16BitSize);
+      dstOpnd.SetValidBitsNum(newVB);
+      MOperator recoverMop = (srcOpnd.GetSize() == k32BitSize ? MOP_wmovrr : MOP_xmovrr);
+      insn.SetMOP(AArch64CG::kMd[recoverMop]);
+      break;
+    }
+    case MOP_wcsetrc:
+    case MOP_xcsetrc: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      dstOpnd.SetValidBitsNum(k1BitSize);
+      break;
+    }
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      Operand &srcOpnd = insn.GetOperand(kInsnSecondOpnd);
+      ASSERT(srcOpnd.IsIntImmediate(), "must be ImmOperand");
+      auto &immOpnd = static_cast<ImmOperand&>(srcOpnd);
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      dstOpnd.SetValidBitsNum(GetImmValidBit(immOpnd.GetValue(), dstOpnd.GetSize()));
+      break;
+    }
+    case MOP_xmovrr:
+    case MOP_wmovrr: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      auto &srcOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      if (srcOpnd.IsPhysicalRegister() || dstOpnd.IsPhysicalRegister()) {
+        return;
+      }
+      if (srcOpnd.GetRegisterNumber() == RZR) {
+        srcOpnd.SetValidBitsNum(k1BitSize);
+      }
+      if (!(dstOpnd.GetSize() == k64BitSize && srcOpnd.GetSize() == k32BitSize) &&
+          !(dstOpnd.GetSize() == k32BitSize && srcOpnd.GetSize() == k64BitSize)) {
+        dstOpnd.SetValidBitsNum(srcOpnd.GetValidBitsNum());
+      }
+      break;
+    }
+    case MOP_wlsrrri5:
+    case MOP_xlsrrri6: {
+      Operand &opnd = insn.GetOperand(kInsnThirdOpnd);
+      ASSERT(opnd.IsIntImmediate(), "must be ImmOperand");
+      auto shiftBits = static_cast<uint32>(static_cast<ImmOperand&>(opnd).GetValue());
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      auto &srcOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      if ((static_cast<int64>(srcOpnd.GetValidBitsNum()) - shiftBits) <= 0) {
+        dstOpnd.SetValidBitsNum(k1BitSize);
+      } else {
+        dstOpnd.SetValidBitsNum(srcOpnd.GetValidBitsNum() - shiftBits);
+      }
+      break;
+    }
+    case MOP_wlslrri5:
+    case MOP_xlslrri6: {
+      Operand &opnd = insn.GetOperand(kInsnThirdOpnd);
+      ASSERT(opnd.IsIntImmediate(), "must be ImmOperand");
+      auto shiftBits = static_cast<uint32>(static_cast<ImmOperand&>(opnd).GetValue());
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      auto &srcOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      uint32 newVB = ((srcOpnd.GetValidBitsNum() + shiftBits) > srcOpnd.GetSize()) ?
+                     srcOpnd.GetSize() : (srcOpnd.GetValidBitsNum() + shiftBits);
+      dstOpnd.SetValidBitsNum(newVB);
+      break;
+    }
+    case MOP_wasrrri5:
+    case MOP_xasrrri6: {
+      auto &srcOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      if ((mop == MOP_wasrrri5 && srcOpnd.GetValidBitsNum() < k32BitSize) ||
+          (mop == MOP_xasrrri6 && srcOpnd.GetValidBitsNum() < k64BitSize)) {
+        Operand &opnd = insn.GetOperand(kInsnThirdOpnd);
+        ASSERT(opnd.IsIntImmediate(), "must be ImmOperand");
+        auto shiftBits = static_cast<uint32>(static_cast<ImmOperand&>(opnd).GetValue());
+        auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+        if ((static_cast<int64>(srcOpnd.GetValidBitsNum()) - shiftBits) <= 0) {
+          dstOpnd.SetValidBitsNum(k1BitSize);
+        } else {
+          dstOpnd.SetValidBitsNum(srcOpnd.GetValidBitsNum() - shiftBits);
+        }
+      }
+      break;
+    }
+    case MOP_xuxtb32:
+    case MOP_xuxth32: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      auto &srcOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      uint32 srcVB = srcOpnd.GetValidBitsNum();
+      uint32 newVB = dstOpnd.GetValidBitsNum();
+      newVB = (mop == MOP_xuxtb32) ? ((srcVB < k8BitSize) ? srcVB : k8BitSize) : newVB;
+      newVB = (mop == MOP_xuxth32) ? ((srcVB < k16BitSize) ? srcVB : k16BitSize) : newVB;
+      dstOpnd.SetValidBitsNum(newVB);
+      break;
+    }
+    case MOP_wubfxrri5i5:
+    case MOP_xubfxrri6i6: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      auto &widthOpnd = static_cast<ImmOperand&>(insn.GetOperand(kInsnFourthOpnd));
+      dstOpnd.SetValidBitsNum(static_cast<uint32>(widthOpnd.GetValue()));
+      break;
+    }
+    case MOP_wldrb:
+    case MOP_wldrh: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      uint32 newVB = (mop == MOP_wldrb) ? k8BitSize : k16BitSize;
+      dstOpnd.SetValidBitsNum(newVB);
+      break;
+    }
+    case MOP_wandrrr:
+    case MOP_xandrrr: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      uint32 src1VB = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetValidBitsNum();
+      uint32 src2VB = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd)).GetValidBitsNum();
+      uint32 newVB = (src1VB <= src2VB ? src1VB : src2VB);
+      dstOpnd.SetValidBitsNum(newVB);
+      break;
+    }
+    case MOP_wandrri12:
+    case MOP_xandrri13: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      auto &immOpnd = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+      uint32 src1VB = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetValidBitsNum();
+      uint32 src2VB = GetImmValidBit(immOpnd.GetValue(), dstOpnd.GetSize());
+      uint32 newVB = (src1VB <= src2VB ? src1VB : src2VB);
+      dstOpnd.SetValidBitsNum(newVB);
+      break;
+    }
+    case MOP_wiorrrr:
+    case MOP_xiorrrr: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      uint32 src1VB = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetValidBitsNum();
+      uint32 src2VB = static_cast<RegOperand&>(insn.GetOperand(kInsnThirdOpnd)).GetValidBitsNum();
+      uint32 newVB = (src1VB >= src2VB ? src1VB : src2VB);
+      dstOpnd.SetValidBitsNum(newVB);
+      break;
+    }
+    case MOP_wiorrri12:
+    case MOP_xiorrri13: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      auto &immOpnd = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+      uint32 src1VB = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetValidBitsNum();
+      uint32 src2VB = GetImmValidBit(immOpnd.GetValue(), dstOpnd.GetSize());
+      uint32 newVB = (src1VB >= src2VB ? src1VB : src2VB);
+      dstOpnd.SetValidBitsNum(newVB);
+      break;
+    }
+    case MOP_wrevrr16: {
+      auto &dstOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+      auto &srcOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+      if (srcOpnd.GetValidBitsNum() <= k16BitSize) {
+        dstOpnd.SetValidBitsNum(k16BitSize);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+bool AArch64ValidBitOpt::SetPhiValidBits(Insn &insn) {
+  Operand &defOpnd = insn.GetOperand(kInsnFirstOpnd);
+  ASSERT(defOpnd.IsRegister(), "expect register");
+  auto &defRegOpnd = static_cast<RegOperand&>(defOpnd);
+  Operand &phiOpnd = insn.GetOperand(kInsnSecondOpnd);
+  ASSERT(phiOpnd.IsPhi(), "expect phiList");
+  auto &phiList = static_cast<PhiOperand&>(phiOpnd);
+  int32 maxVB = -1;
+  for (auto phiOpndIt : phiList.GetOperands()) {
+    if (phiOpndIt.second != nullptr) {
+      maxVB = (maxVB < static_cast<int32>(phiOpndIt.second->GetValidBitsNum())) ?
+              static_cast<int32>(phiOpndIt.second->GetValidBitsNum()) : maxVB;
+    }
+  }
+  if (maxVB >= static_cast<int32>(k0BitSize) && static_cast<uint32>(maxVB) != defRegOpnd.GetValidBitsNum()) {
+    defRegOpnd.SetValidBitsNum(static_cast<uint32>(maxVB));
+    return true;
+  }
+  return false;
+}
+
+static bool IsZeroRegister(const Operand &opnd) {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  const RegOperand *regOpnd = static_cast<const RegOperand*>(&opnd);
+  return regOpnd->GetRegisterNumber() == RZR;
+}
+
+bool AndValidBitPattern::CheckImmValidBit(int64 andImm, uint32 andImmVB, int64 shiftImm) const {
+  if ((__builtin_ffs(static_cast<int>(andImm)) - 1 == shiftImm) &&
+      ((andImm >> shiftImm) == ((1 << (andImmVB - shiftImm)) - 1))) {
+    return true;
+  }
+  return false;
+}
+
+bool AndValidBitPattern::CheckCondition(Insn &insn) {
+  MOperator mOp = insn.GetMachineOpcode();
+  if (mOp == MOP_wandrri12) {
+    newMop = MOP_wmovrr;
+  } else if (mOp == MOP_xandrri13) {
+    newMop = MOP_xmovrr;
+  }
+  if (newMop == MOP_undef) {
+    return false;
+  }
+  CHECK_FATAL(insn.GetOperand(kInsnFirstOpnd).IsRegister(), "must be register!");
+  CHECK_FATAL(insn.GetOperand(kInsnSecondOpnd).IsRegister(), "must be register!");
+  CHECK_FATAL(insn.GetOperand(kInsnThirdOpnd).IsImmediate(), "must be imm!");
+  desReg = static_cast<RegOperand*>(&insn.GetOperand(kInsnFirstOpnd));
+  srcReg = static_cast<RegOperand*>(&insn.GetOperand(kInsnSecondOpnd));
+  auto &andImm = static_cast<ImmOperand&>(insn.GetOperand(kInsnThirdOpnd));
+  int64 immVal = andImm.GetValue();
+  uint32 validBit = srcReg->GetValidBitsNum();
+  if (validBit == k8BitSize && immVal == 0xFF) {
+    return true;
+  } else if (validBit == k16BitSize && immVal == 0xFFFF) {
+    return true;
+  }
+  /* and R287[32], R286[64], #255 */
+  if ((desReg->GetSize() < srcReg->GetSize()) && (srcReg->GetValidBitsNum() > desReg->GetSize())) {
+    return false;
+  }
+  InsnSet useInsns = GetAllUseInsn(*desReg);
+  if (useInsns.size() == 1) {
+    Insn *useInsn = *useInsns.begin();
+    MOperator useMop = useInsn->GetMachineOpcode();
+    if (useMop != MOP_wasrrri5 && useMop != MOP_xasrrri6 && useMop != MOP_wlsrrri5 && useMop != MOP_xlsrrri6) {
+      return false;
+    }
+    Operand &shiftOpnd = useInsn->GetOperand(kInsnThirdOpnd);
+    CHECK_FATAL(shiftOpnd.IsImmediate(), "must be immediate");
+    int64 shiftImm = static_cast<ImmOperand&>(shiftOpnd).GetValue();
+    uint32 andImmVB = ValidBitOpt::GetImmValidBit(andImm.GetValue(), desReg->GetSize());
+    if ((srcReg->GetValidBitsNum() == andImmVB) && CheckImmValidBit(andImm.GetValue(), andImmVB, shiftImm)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void AndValidBitPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, *desReg, *srcReg);
+  bb.ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  ssaInfo->InsertSafePropInsn(newInsn.GetId());
+  /* dump pattern info */
+  if (CG_VALIDBIT_OPT_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(&insn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+
+bool ExtValidBitPattern::CheckCondition(Insn &insn) {
+  Operand &dstOpnd = insn.GetOperand(kInsnFirstOpnd);
+  Operand &srcOpnd = insn.GetOperand(kInsnSecondOpnd);
+  CHECK_FATAL(dstOpnd.IsRegister() && srcOpnd.IsRegister(), "must be register");
+  MOperator mOp = insn.GetMachineOpcode();
+  switch (mOp) {
+    case MOP_xuxtb32:
+    case MOP_xuxth32: {
+      if (static_cast<RegOperand&>(dstOpnd).GetValidBitsNum() !=
+          static_cast<RegOperand&>(srcOpnd).GetValidBitsNum()) {
+        return false;
+      }
+      newMop = MOP_wmovrr;
+      break;
+    }
+    case MOP_xsxtw64: {
+      if (static_cast<RegOperand&>(srcOpnd).GetValidBitsNum() >= k32BitSize) {
+        return false;
+      }
+      newMop = MOP_xmovrr;
+      break;
+    }
+    case MOP_wubfxrri5i5:
+    case MOP_xubfxrri6i6:
+    case MOP_wsbfxrri5i5:
+    case MOP_xsbfxrri6i6: {
+      Operand &immOpnd1 = insn.GetOperand(kInsnThirdOpnd);
+      Operand &immOpnd2 = insn.GetOperand(kInsnFourthOpnd);
+      CHECK_FATAL(immOpnd1.IsImmediate(), "must be immediate");
+      CHECK_FATAL(immOpnd2.IsImmediate(), "must be immediate");
+      int64 lsb = static_cast<ImmOperand&>(immOpnd1).GetValue();
+      int64 width = static_cast<ImmOperand&>(immOpnd2).GetValue();
+      if (lsb != 0 || static_cast<RegOperand&>(srcOpnd).GetValidBitsNum() > width) {
+        return false;
+      }
+      if ((mOp == MOP_wsbfxrri5i5 || mOp == MOP_xsbfxrri6i6) &&
+          static_cast<RegOperand&>(srcOpnd).GetValidBitsNum() == width) {
+        return false;
+      }
+      if (mOp == MOP_wubfxrri5i5 || mOp == MOP_wsbfxrri5i5) {
+        newMop = MOP_wmovrr;
+      } else if (mOp == MOP_xubfxrri6i6 || mOp == MOP_xsbfxrri6i6) {
+        newMop = MOP_xmovrr;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  newDstOpnd = &static_cast<RegOperand&>(dstOpnd);
+  newSrcOpnd = &static_cast<RegOperand&>(srcOpnd);
+  return true;
+}
+
+void ExtValidBitPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  MOperator mOp = insn.GetMachineOpcode();
+  switch (mOp) {
+    case MOP_xuxtb32:
+    case MOP_xuxth32:
+    case MOP_xsxtw64: {
+      insn.SetMOP(AArch64CG::kMd[newMop]);
+      if (newDstOpnd->GetSize() > newSrcOpnd->GetSize()) {
+        ssaInfo->InsertSafePropInsn(insn.GetId());
+      }
+      break;
+    }
+    case MOP_wubfxrri5i5:
+    case MOP_xubfxrri6i6:
+    case MOP_wsbfxrri5i5:
+    case MOP_xsbfxrri6i6: {
+      Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, *newDstOpnd, *newSrcOpnd);
+      bb.ReplaceInsn(insn, newInsn);
+      /* update ssa info */
+      ssaInfo->ReplaceInsn(insn, newInsn);
+      if (newDstOpnd->GetSize() > newSrcOpnd->GetSize() || newDstOpnd->GetSize() != newDstOpnd->GetValidBitsNum()) {
+        ssaInfo->InsertSafePropInsn(newInsn.GetId());
+      }
+      /* dump pattern info */
+      if (CG_VALIDBIT_OPT_DUMP) {
+        std::vector<Insn*> prevs;
+        prevs.emplace_back(&insn);
+        DumpAfterPattern(prevs, &insn, &newInsn);
+      }
+    }
+    default:
+      return;
+  }
+}
+
+bool CmpCsetVBPattern::IsContinuousCmpCset(const Insn &curInsn) const {
+  auto &csetDstReg = static_cast<RegOperand&>(curInsn.GetOperand(kInsnFirstOpnd));
+  CHECK_FATAL(csetDstReg.IsSSAForm(), "dstOpnd must be ssa form");
+  VRegVersion *dstVersion = ssaInfo->FindSSAVersion(csetDstReg.GetRegisterNumber());
+  ASSERT(dstVersion != nullptr, "find vRegVersion failed");
+  for (auto useDUInfoIt : dstVersion->GetAllUseInsns()) {
+    if (useDUInfoIt.second == nullptr) {
+      continue;
+    }
+    Insn *useInsn = useDUInfoIt.second->GetInsn();
+    if (useInsn == nullptr) {
+      continue;
+    }
+    MOperator useMop = useInsn->GetMachineOpcode();
+    if (useMop == MOP_wcmpri || useMop == MOP_xcmpri) {
+      auto &ccDstReg = static_cast<RegOperand&>(useInsn->GetOperand(kInsnFirstOpnd));
+      CHECK_FATAL(ccDstReg.IsSSAForm(), "dstOpnd must be ssa form");
+      VRegVersion *ccDstVersion = ssaInfo->FindSSAVersion(ccDstReg.GetRegisterNumber());
+      ASSERT(ccDstVersion != nullptr, "find vRegVersion failed");
+      for (auto ccUseDUInfoIt : ccDstVersion->GetAllUseInsns()) {
+        if (ccUseDUInfoIt.second == nullptr) {
+          continue;
+        }
+        Insn *ccUseInsn = ccUseDUInfoIt.second->GetInsn();
+        if (ccUseInsn == nullptr) {
+          continue;
+        }
+        MOperator ccUseMop = ccUseInsn->GetMachineOpcode();
+        if (ccUseMop == MOP_wcsetrc || ccUseMop == MOP_xcsetrc) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+bool CmpCsetVBPattern::OpndDefByOneValidBit(const Insn &defInsn) const {
+  if (defInsn.IsPhi()) {
+    return (static_cast<RegOperand&>(cmpInsn->GetOperand(kInsnSecondOpnd)).GetValidBitsNum() == k1BitSize) ||
+           (static_cast<RegOperand&>(cmpInsn->GetOperand(kInsnSecondOpnd)).GetValidBitsNum() == k0BitSize);
+  }
+  MOperator defMop = defInsn.GetMachineOpcode();
+  switch (defMop) {
+    case MOP_wcsetrc:
+    case MOP_xcsetrc:
+      return true;
+    case MOP_wmovri32:
+    case MOP_xmovri64: {
+      Operand &defOpnd = defInsn.GetOperand(kInsnSecondOpnd);
+      ASSERT(defOpnd.IsIntImmediate(), "expects ImmOperand");
+      auto &defConst = static_cast<ImmOperand&>(defOpnd);
+      int64 defConstValue = defConst.GetValue();
+      return (defConstValue == 0 || defConstValue == 1);
+    }
+    case MOP_xmovrr:
+    case MOP_wmovrr:
+      return IsZeroRegister(defInsn.GetOperand(kInsnSecondOpnd));
+    case MOP_wlsrrri5:
+    case MOP_xlsrrri6: {
+      Operand &opnd2 = defInsn.GetOperand(kInsnThirdOpnd);
+      ASSERT(opnd2.IsIntImmediate(), "expects ImmOperand");
+      auto &opndImm = static_cast<ImmOperand&>(opnd2);
+      int64 shiftBits = opndImm.GetValue();
+      return ((defMop == MOP_wlsrrri5 && shiftBits == (k32BitSize - 1)) ||
+              (defMop == MOP_xlsrrri6 && shiftBits == (k64BitSize - 1)));
+    }
+    default:
+      return false;
+  }
+}
+
+bool CmpCsetVBPattern::CheckCondition(Insn &csetInsn) {
+  MOperator curMop = csetInsn.GetMachineOpcode();
+  if (curMop != MOP_wcsetrc && curMop != MOP_xcsetrc) {
+    return false;
+  }
+  /* combine [continuous cmp & cset] first, to eliminate more insns */
+  if (IsContinuousCmpCset(csetInsn)) {
+    return false;
+  }
+  RegOperand &ccReg = static_cast<RegOperand&>(csetInsn.GetOperand(kInsnThirdOpnd));
+  regno_t ccRegNo = ccReg.GetRegisterNumber();
+  cmpInsn = ssaInfo->GetDefInsn(ccReg);
+  CHECK_NULL_FATAL(cmpInsn);
+  MOperator mop = cmpInsn->GetMachineOpcode();
+  if ((mop != MOP_wcmpri) && (mop != MOP_xcmpri)) {
+    return false;
+  }
+  VRegVersion *ccRegVersion = ssaInfo->FindSSAVersion(ccRegNo);
+  CHECK_NULL_FATAL(ccRegVersion);
+  if (ccRegVersion->GetAllUseInsns().size() > k1BitSize) {
+    return false;
+  }
+  Operand &cmpSecondOpnd = cmpInsn->GetOperand(kInsnThirdOpnd);
+  CHECK_FATAL(cmpSecondOpnd.IsIntImmediate(), "expects ImmOperand");
+  auto &cmpConst = static_cast<ImmOperand&>(cmpSecondOpnd);
+  cmpConstVal = cmpConst.GetValue();
+  /* get ImmOperand, must be 0 or 1 */
+  if ((cmpConstVal != 0) && (cmpConstVal != k1BitSize)) {
+    return false;
+  }
+  Operand &cmpFirstOpnd = cmpInsn->GetOperand(kInsnSecondOpnd);
+  CHECK_FATAL(cmpFirstOpnd.IsRegister(), "cmpFirstOpnd must be register!");
+  RegOperand &cmpReg = static_cast<RegOperand&>(cmpFirstOpnd);
+  Insn *defInsn = ssaInfo->GetDefInsn(cmpReg);
+  if (defInsn == nullptr) {
+    return false;
+  }
+  if (defInsn->GetMachineOpcode() == MOP_wmovrr || defInsn->GetMachineOpcode() == MOP_xmovrr) {
+    auto &srcOpnd = static_cast<RegOperand&>(defInsn->GetOperand(kInsnSecondOpnd));
+    if (!srcOpnd.IsVirtualRegister()) {
+      return false;
+    }
+  }
+  return ((cmpReg.GetValidBitsNum() == k1BitSize) || (cmpReg.GetValidBitsNum() == k0BitSize) ||
+          OpndDefByOneValidBit(*defInsn));
+}
+
+void CmpCsetVBPattern::Run(BB &bb, Insn &csetInsn) {
+  if (!CheckCondition(csetInsn)) {
+    return;
+  }
+  Operand &csetFirstOpnd = csetInsn.GetOperand(kInsnFirstOpnd);
+  Operand &cmpFirstOpnd = cmpInsn->GetOperand(kInsnSecondOpnd);
+  auto &cond = static_cast<CondOperand&>(csetInsn.GetOperand(kInsnSecondOpnd));
+  Insn *newInsn = nullptr;
+
+  /* cmpFirstOpnd == 1 */
+  if ((cmpConstVal == 0 && cond.GetCode() == CC_NE) || (cmpConstVal == 1 && cond.GetCode() == CC_EQ)) {
+    MOperator mopCode = (cmpFirstOpnd.GetSize() == k64BitSize) ? MOP_xmovrr : MOP_wmovrr;
+    newInsn = &cgFunc->GetInsnBuilder()->BuildInsn(mopCode, csetFirstOpnd, cmpFirstOpnd);
+  } else if ((cmpConstVal == 1 && cond.GetCode() == CC_NE) || (cmpConstVal == 0 && cond.GetCode() == CC_EQ)) {
+    /* cmpFirstOpnd == 0 */
+    MOperator mopCode = (cmpFirstOpnd.GetSize() == k64BitSize) ? MOP_xeorrri13 : MOP_weorrri12;
+    ImmOperand &one = static_cast<AArch64CGFunc*>(cgFunc)->CreateImmOperand(1, k8BitSize, false);
+    newInsn = &cgFunc->GetInsnBuilder()->BuildInsn(mopCode, csetFirstOpnd, cmpFirstOpnd, one);
+  }
+  if (newInsn == nullptr) {
+    return;
+  }
+  bb.ReplaceInsn(csetInsn, *newInsn);
+  ssaInfo->ReplaceInsn(csetInsn, *newInsn);
+  if (CG_VALIDBIT_OPT_DUMP && (newInsn != nullptr)) {
+    std::vector<Insn*> prevInsns;
+    prevInsns.emplace_back(cmpInsn);
+    prevInsns.emplace_back(&csetInsn);
+    DumpAfterPattern(prevInsns, newInsn, nullptr);
+  }
+}
+
+void CmpBranchesPattern::SelectNewMop(MOperator mop) {
+  switch (mop) {
+    case MOP_bge: {
+      newMop = is64Bit ? MOP_xtbnz : MOP_wtbnz;
+      break;
+    }
+    case MOP_blt: {
+      newMop = is64Bit ? MOP_xtbz : MOP_wtbz;
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+bool CmpBranchesPattern::CheckCondition(Insn &insn) {
+  MOperator curMop = insn.GetMachineOpcode();
+  if (curMop != MOP_bge && curMop != MOP_blt) {
+    return false;
+  }
+  auto &ccReg = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  prevCmpInsn = ssaInfo->GetDefInsn(ccReg);
+  if (prevCmpInsn == nullptr) {
+    return false;
+  }
+  MOperator cmpMop = prevCmpInsn->GetMachineOpcode();
+  if (cmpMop != MOP_wcmpri && cmpMop != MOP_xcmpri) {
+    return false;
+  }
+  is64Bit = (cmpMop == MOP_xcmpri);
+  auto &cmpUseOpnd = static_cast<RegOperand&>(prevCmpInsn->GetOperand(kInsnSecondOpnd));
+  auto &cmpImmOpnd = static_cast<ImmOperand&>(prevCmpInsn->GetOperand(kInsnThirdOpnd));
+  int64 cmpImmVal = cmpImmOpnd.GetValue();
+  newImmVal = ValidBitOpt::GetLogValueAtBase2(cmpImmVal);
+  if (newImmVal < 0 || cmpUseOpnd.GetValidBitsNum() != (newImmVal + 1)) {
+    return false;
+  }
+  SelectNewMop(curMop);
+  if (newMop == MOP_undef) {
+    return false;
+  }
+  return true;
+}
+
+void CmpBranchesPattern::Run(BB &bb, Insn &insn) {
+  if (!CheckCondition(insn)) {
+    return;
+  }
+  auto *aarFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  auto &labelOpnd = static_cast<LabelOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  ImmOperand &newImmOpnd = aarFunc->CreateImmOperand(newImmVal, k8BitSize, false);
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(newMop, prevCmpInsn->GetOperand(kInsnSecondOpnd),
+                                                                 newImmOpnd, labelOpnd);
+  bb.ReplaceInsn(insn, newInsn);
+  /* update ssa info */
+  ssaInfo->ReplaceInsn(insn, newInsn);
+  /* dump pattern info */
+  if (CG_VALIDBIT_OPT_DUMP) {
+    std::vector<Insn*> prevs;
+    prevs.emplace_back(prevCmpInsn);
+    DumpAfterPattern(prevs, &insn, &newInsn);
+  }
+}
+} /* namespace maplebe */
+
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_yieldpoint.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_yieldpoint.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d64980001498bef25d57a01e35b2eadcdabb3852
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_yieldpoint.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "aarch64_yieldpoint.h"
+#include "aarch64_cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+void AArch64YieldPointInsertion::Run() {
+  InsertYieldPoint();
+}
+
+void AArch64YieldPointInsertion::InsertYieldPoint() const {
+  AArch64CGFunc *aarchCGFunc = static_cast<AArch64CGFunc*>(cgFunc);
+  std::string refQueueName = "Ljava_2Flang_2Fref_2FReference_3B_7C_3Cinit_3E_7C_"
+                             "28Ljava_2Flang_2FObject_3BLjava_2Flang_2Fref_2FReferenceQueue_3B_29V";
+  if (!CGOptions::IsGCOnly() && (aarchCGFunc->GetName() == refQueueName)) {
+    /* skip insert yieldpoint in reference constructor, avoid rc verify issue */
+    ASSERT(aarchCGFunc->GetYieldPointInsn() != nullptr, "the entry yield point has been inserted");
+    aarchCGFunc->GetYieldPointInsn()->GetBB()->RemoveInsn(*aarchCGFunc->GetYieldPointInsn());
+    return;
+  }
+
+  /*
+   * do not insert yieldpoint in function that not saved X30 into stack,
+   * because X30 will be changed after yieldpoint is taken.
+   */
+  if (!aarchCGFunc->GetHasProEpilogue()) {
+    ASSERT (aarchCGFunc->GetYieldPointInsn() != nullptr, "the entry yield point has been inserted");
+    aarchCGFunc->GetYieldPointInsn()->GetBB()->RemoveInsn(*aarchCGFunc->GetYieldPointInsn());
+    return;
+  }
+  /* skip if no GetFirstbb(). */
+  if (aarchCGFunc->GetFirstBB() == nullptr) {
+    return;
+  }
+  /*
+   * The yield point in the entry of the GetFunction() is inserted just after the initialization
+   * of localrefvars in HandleRCCall.
+   * for BBs after firstbb.
+   */
+  for (BB *bb = aarchCGFunc->GetFirstBB()->GetNext(); bb != nullptr; bb = bb->GetNext()) {
+    /* insert a yieldpoint at beginning if BB is BackEdgeDest. */
+    if (bb->IsBackEdgeDest()) {
+      aarchCGFunc->GetDummyBB()->ClearInsns();
+      aarchCGFunc->GenerateYieldpoint(*aarchCGFunc->GetDummyBB());
+      bb->InsertAtBeginning(*aarchCGFunc->GetDummyBB());
+    }
+  }
+}
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/aarch64/mpl_atomic.cpp b/src/mapleall/maple_be/src/cg/aarch64/mpl_atomic.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1b966afc91d26c2dface288fc3910de50e8ac66d
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/aarch64/mpl_atomic.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mpl_atomic.h"
+#include <cstdint>
+#include "mpl_logging.h"
+
+namespace maple {
+namespace {
+constexpr int32 kMaxSizeOfTab = 6;
+};
+MemOrd MemOrdFromU32(uint32 val) {
+  /* 6 is the size of tab below. 2 is memory_order_consume, it is Disabled. */
+  CHECK_FATAL(val <= kMaxSizeOfTab, "Illegal number for MemOrd: %u", val);
+  CHECK_FATAL(val != 2, "Illegal number for MemOrd: %u", val);
+  static std::array<MemOrd, kMaxSizeOfTab + 1> tab = {
+      MemOrd::kNotAtomic,
+      MemOrd::memory_order_relaxed,
+    /*
+     * memory_order_consume Disabled. Its semantics is debatable.
+     * We don't support it now, but reserve the number. Use memory_order_acquire instead.
+     */
+      MemOrd::memory_order_acquire,  /* padding entry */
+      MemOrd::memory_order_acquire,
+      MemOrd::memory_order_release,
+      MemOrd::memory_order_acq_rel,
+      MemOrd::memory_order_seq_cst,
+  };
+  return tab[val];
+}
+
+bool MemOrdIsAcquire(MemOrd ord) {
+  static std::array<bool, kMaxSizeOfTab + 1> tab = {
+      false,  /* kNotAtomic */
+      false,  /* memory_order_relaxed */
+      true,   /* memory_order_consume */
+      true,   /* memory_order_acquire */
+      false,  /* memory_order_release */
+      true,   /* memory_order_acq_rel */
+      true,   /* memory_order_seq_cst */
+  };
+  uint32 tabIndex = static_cast<uint32>(ord);
+  CHECK_FATAL(tabIndex <= kMaxSizeOfTab, "Illegal number for MemOrd: %u", tabIndex);
+  return tab[tabIndex];
+}
+
+bool MemOrdIsRelease(MemOrd ord) {
+  static std::array<bool, kMaxSizeOfTab + 1> tab = {
+      false,  /* kNotAtomic */
+      false,  /* memory_order_relaxed */
+      false,  /* memory_order_consume */
+      false,  /* memory_order_acquire */
+      true,   /* memory_order_release */
+      true,   /* memory_order_acq_rel */
+      true,   /* memory_order_seq_cst */
+  };
+  uint32 tabIndex = static_cast<uint32>(ord);
+  CHECK_FATAL(tabIndex <= kMaxSizeOfTab, "Illegal number for MemOrd: %u", tabIndex);
+  return tab[tabIndex];
+}
+}  /* namespace maple */
diff --git a/src/mapleall/maple_be/src/cg/alignment.cpp b/src/mapleall/maple_be/src/cg/alignment.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bad9a5b690e5e4f96dcb6d48fd50a60ef5ce2fdc
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/alignment.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "alignment.h"
+#include "optimize_common.h"
+#include "cgfunc.h"
+#include "cg.h"
+#include "cg_option.h"
+
+namespace maplebe {
+#define ALIGN_ANALYZE_DUMP_NEWPW CG_DEBUG_FUNC(func)
+
+void AlignAnalysis::AnalysisAlignment() {
+  FindLoopHeader();
+  FindJumpTarget();
+  ComputeLoopAlign();
+  ComputeJumpAlign();
+  if (CGOptions::DoCondBrAlign()) {
+    ComputeCondBranchAlign();
+  }
+}
+
+void AlignAnalysis::Dump() {
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(cgFunc->GetFunction().GetStIdx().Idx());
+  ASSERT(funcSt != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << "\n********* alignment for " << funcSt->GetName() << " *********\n";
+  LogInfo::MapleLogger() << "------ jumpTargetBBs: " << jumpTargetBBs.size() << " total ------\n";
+  for (auto *jumpLabel : jumpTargetBBs) {
+    LogInfo::MapleLogger() << " === BB_" << jumpLabel->GetId() << " (" << std::hex << jumpLabel << ")"
+                           << std::dec << " <" << jumpLabel->GetKindName();
+    if (jumpLabel->GetLabIdx() != MIRLabelTable::GetDummyLabel()) {
+      LogInfo::MapleLogger() << "[labeled with " << jumpLabel->GetLabIdx() << "]> ===\n";
+    }
+    if (!jumpLabel->GetPreds().empty()) {
+      LogInfo::MapleLogger() << "\tpreds: [ ";
+      for (auto *pred : jumpLabel->GetPreds()) {
+        LogInfo::MapleLogger() << "BB_" << pred->GetId();
+        if (pred->GetLabIdx() != MIRLabelTable::GetDummyLabel()) {
+          LogInfo::MapleLogger() << "<labeled with " << jumpLabel->GetLabIdx() << ">";
+        }
+        LogInfo::MapleLogger() << " (" << std::hex << pred << ") " << std::dec << " ";
+      }
+      LogInfo::MapleLogger() << "]\n";
+    }
+    if (jumpLabel->GetPrev() != nullptr) {
+      LogInfo::MapleLogger() << "\tprev: [ ";
+      LogInfo::MapleLogger() << "BB_" << jumpLabel->GetPrev()->GetId();
+      if (jumpLabel->GetPrev()->GetLabIdx() != MIRLabelTable::GetDummyLabel()) {
+        LogInfo::MapleLogger() << "<labeled with " << jumpLabel->GetLabIdx() << ">";
+      }
+      LogInfo::MapleLogger() << " (" << std::hex << jumpLabel->GetPrev() << ") " << std::dec << " ";
+      LogInfo::MapleLogger() << "]\n";
+    }
+    FOR_BB_INSNS_CONST(insn, jumpLabel) {
+      insn->Dump();
+    }
+  }
+  LogInfo::MapleLogger() << "\n------ loopHeaderBBs: " << loopHeaderBBs.size() << " total ------\n";
+  for (auto *loopHeader : loopHeaderBBs) {
+    LogInfo::MapleLogger() << " === BB_" << loopHeader->GetId() << " (" << std::hex << loopHeader << ")"
+                           << std::dec << " <" << loopHeader->GetKindName();
+    if (loopHeader->GetLabIdx() != MIRLabelTable::GetDummyLabel()) {
+      LogInfo::MapleLogger() << "[labeled with " << loopHeader->GetLabIdx() << "]> ===\n";
+    }
+    LogInfo::MapleLogger() << "\tLoop Level: " << loopHeader->GetLoop()->GetLoopLevel() << "\n";
+    FOR_BB_INSNS_CONST(insn, loopHeader) {
+      insn->Dump();
+    }
+  }
+  LogInfo::MapleLogger() << "\n------ alignInfos: " << alignInfos.size() << " total ------\n";
+  MapleUnorderedMap<BB*, uint32>::iterator iter;
+  for (iter = alignInfos.begin(); iter != alignInfos.end(); ++iter) {
+    BB *bb = iter->first;
+    LogInfo::MapleLogger() << " === BB_" << bb->GetId() << " (" << std::hex << bb << ")"
+                           << std::dec << " <" << bb->GetKindName();
+    if (bb->GetLabIdx() != MIRLabelTable::GetDummyLabel()) {
+      LogInfo::MapleLogger() << "[labeled with " << bb->GetLabIdx() << "]> ===\n";
+    }
+    LogInfo::MapleLogger() << "\talignPower: " << iter->second << "\n";
+  }
+}
+
+bool CgAlignAnalysis::PhaseRun(maplebe::CGFunc &func) {
+  if (ALIGN_ANALYZE_DUMP_NEWPW) {
+    DotGenerator::GenerateDot("alignanalysis", func, func.GetMirModule(), true, func.GetName());
+  }
+  MemPool *alignMemPool = GetPhaseMemPool();
+  AlignAnalysis *alignAnalysis = func.GetCG()->CreateAlignAnalysis(*alignMemPool, func);
+
+  CHECK_FATAL(alignAnalysis != nullptr, "AlignAnalysis instance create failure");
+  alignAnalysis->AnalysisAlignment();
+  if (ALIGN_ANALYZE_DUMP_NEWPW) {
+    alignAnalysis->Dump();
+  }
+  return true;
+}
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/args.cpp b/src/mapleall/maple_be/src/cg/args.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b647ec327c22840814b195dfabf34b1e651c8ac1
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/args.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "args.h"
+#include "cg.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+bool CgMoveRegArgs::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *memPool = GetPhaseMemPool();
+  MoveRegArgs *movRegArgs = nullptr;
+  movRegArgs = f.GetCG()->CreateMoveRegArgs(*memPool, f);
+  movRegArgs->Run();
+  return true;
+}
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cfgo.cpp b/src/mapleall/maple_be/src/cg/cfgo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a9c8040b3860a6f6008b15e8e8c848362d11f7d3
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cfgo.cpp
@@ -0,0 +1,915 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cfgo.h"
+#include "cgbb.h"
+#include "cg.h"
+#include "loop.h"
+#include "mpl_logging.h"
+
+/*
+ * This phase traverses all basic block of cgFunc and finds special
+ * basic block patterns, like continuous fallthrough basic block, continuous
+ * uncondition jump basic block, unreachable basic block and empty basic block,
+ * then do basic mergering, basic block placement transformations,
+ * unnecessary jumps elimination, and remove unreachable or empty basic block.
+ * This optimization is done on control flow graph basis.
+ */
+namespace maplebe {
+using namespace maple;
+
+#define CFGO_DUMP_NEWPM CG_DEBUG_FUNC(f)
+
+/* return true if to is put after from and there is no real insns between from and to, */
+bool ChainingPattern::NoInsnBetween(const BB &from, const BB &to) const {
+  const BB *bb = nullptr;
+  for (bb = from.GetNext(); bb != nullptr && bb != &to && bb != cgFunc->GetLastBB(); bb = bb->GetNext()) {
+    if (!bb->IsEmptyOrCommentOnly() || bb->IsUnreachable() || bb->GetKind() != BB::kBBFallthru) {
+      return false;
+    }
+  }
+  return (bb == &to);
+}
+
+/* return true if insns in bb1 and bb2 are the same except the last goto insn. */
+bool ChainingPattern::DoSameThing(const BB &bb1, const Insn &last1, const BB &bb2, const Insn &last2) const {
+  const Insn *insn1 = bb1.GetFirstInsn();
+  const Insn *insn2 = bb2.GetFirstInsn();
+  while (insn1 != nullptr && insn1 != last1.GetNext() && insn2 != nullptr && insn2 != last2.GetNext()) {
+    if (!insn1->IsMachineInstruction()) {
+      insn1 = insn1->GetNext();
+      continue;
+    }
+    if (!insn2->IsMachineInstruction()) {
+      insn2 = insn2->GetNext();
+      continue;
+    }
+    if (insn1->GetMachineOpcode() != insn2->GetMachineOpcode()) {
+      return false;
+    }
+    uint32 opndNum = insn1->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &op1 = insn1->GetOperand(i);
+      Operand &op2 = insn2->GetOperand(i);
+      if (&op1 == &op2) {
+        continue;
+      }
+      if (!op1.Equals(op2)) {
+        return false;
+      }
+    }
+    insn1 = insn1->GetNext();
+    insn2 = insn2->GetNext();
+  }
+  return (insn1 == last1.GetNext() && insn2 == last2.GetNext());
+}
+
+/*
+ * BB2 can be merged into BB1, if
+ *   1. BB1's kind is fallthrough;
+ *   2. BB2 has only one predecessor which is BB1 and BB2 is not the lastbb
+ *   3. BB2 is neither catch BB nor switch case BB
+ */
+bool ChainingPattern::MergeFallthuBB(BB &curBB) {
+  BB *sucBB = curBB.GetNext();
+  if (sucBB == nullptr ||
+      IsLabelInLSDAOrSwitchTable(sucBB->GetLabIdx()) ||
+      !cgFunc->GetTheCFG()->CanMerge(curBB, *sucBB)) {
+    return false;
+  }
+  Log(curBB.GetId());
+  if (checkOnly) {
+    return false;
+  }
+  if (sucBB == cgFunc->GetLastBB()) {
+    cgFunc->SetLastBB(curBB);
+  }
+  cgFunc->GetTheCFG()->MergeBB(curBB, *sucBB, *cgFunc);
+  keepPosition = true;
+  return true;
+}
+
+bool ChainingPattern::MergeGotoBB(BB &curBB, BB &sucBB) {
+  Log(curBB.GetId());
+  if (checkOnly) {
+    return false;
+  }
+  cgFunc->GetTheCFG()->MergeBB(curBB, sucBB, *cgFunc);
+  keepPosition = true;
+  return true;
+}
+
+bool ChainingPattern::MoveSuccBBAsCurBBNext(BB &curBB, BB &sucBB) {
+  /*
+   * without the judge below, there is
+   * Assembler Error: CFI state restore without previous remember
+   */
+  if (sucBB.GetHasCfi() || (sucBB.GetFirstInsn() != nullptr && sucBB.GetFirstInsn()->IsCfiInsn())) {
+    return false;
+  }
+  Log(curBB.GetId());
+  if (checkOnly) {
+    return false;
+  }
+  /* put sucBB as curBB's next. */
+  ASSERT(sucBB.GetPrev() != nullptr, "the target of current goto BB will not be the first bb");
+  sucBB.GetPrev()->SetNext(sucBB.GetNext());
+  if (sucBB.GetNext() != nullptr) {
+    sucBB.GetNext()->SetPrev(sucBB.GetPrev());
+  }
+  sucBB.SetNext(curBB.GetNext());
+  if (curBB.GetNext() != nullptr) {
+    curBB.GetNext()->SetPrev(&sucBB);
+  }
+  if (sucBB.GetId() == cgFunc->GetLastBB()->GetId()) {
+    cgFunc->SetLastBB(*(sucBB.GetPrev()));
+  } else if (curBB.GetId() == cgFunc->GetLastBB()->GetId()) {
+    cgFunc->SetLastBB(sucBB);
+  }
+  sucBB.SetPrev(&curBB);
+  curBB.SetNext(&sucBB);
+  curBB.RemoveInsn(*curBB.GetLastInsn());
+  curBB.SetKind(BB::kBBFallthru);
+  return true;
+}
+
+bool ChainingPattern::RemoveGotoInsn(BB &curBB, BB &sucBB) {
+  Log(curBB.GetId());
+  if (checkOnly) {
+    return false;
+  }
+  if (&sucBB != curBB.GetNext()) {
+    ASSERT(curBB.GetNext() != nullptr, "nullptr check");
+    curBB.RemoveSuccs(sucBB);
+    curBB.PushBackSuccs(*curBB.GetNext());
+    curBB.GetNext()->PushBackPreds(curBB);
+    sucBB.RemovePreds(curBB);
+  }
+  curBB.RemoveInsn(*curBB.GetLastInsn());
+  curBB.SetKind(BB::kBBFallthru);
+  return true;
+}
+
+bool ChainingPattern::ClearCurBBAndResetTargetBB(BB &curBB, BB &sucBB) {
+  if (curBB.GetHasCfi() || (curBB.GetFirstInsn() != nullptr && curBB.GetFirstInsn()->IsCfiInsn())) {
+    return false;
+  }
+  Insn *brInsn = nullptr;
+  for (brInsn = curBB.GetLastInsn(); brInsn != nullptr; brInsn = brInsn->GetPrev()) {
+    if (brInsn->IsUnCondBranch()){
+      break;
+    }
+  }
+  ASSERT(brInsn != nullptr, "goto BB has no branch");
+  BB *newTarget = sucBB.GetPrev();
+  ASSERT(newTarget != nullptr, "get prev bb failed in ChainingPattern::ClearCurBBAndResetTargetBB");
+  Insn *last1 = newTarget->GetLastInsn();
+  if (newTarget->GetKind() == BB::kBBGoto) {
+    Insn *br = nullptr;
+    for (br = newTarget->GetLastInsn(); br != newTarget->GetFirstInsn()->GetPrev(); br = br->GetPrev()) {
+      if (br->IsUnCondBranch()){
+        break;
+      }
+    }
+    ASSERT(br != nullptr, "goto BB has no branch");
+    last1 = br->GetPrev();
+  }
+  if (last1 == nullptr || !DoSameThing(*newTarget, *last1, curBB, *brInsn->GetPrev())) {
+    return false;
+  }
+
+  Log(curBB.GetId());
+  if (checkOnly) {
+    return false;
+  }
+
+  LabelIdx tgtLabIdx = newTarget->GetLabIdx();
+  if (newTarget->GetLabIdx() == MIRLabelTable::GetDummyLabel()) {
+    tgtLabIdx = cgFunc->CreateLabel();
+    newTarget->AddLabel(tgtLabIdx);
+  }
+  LabelOperand &brTarget = cgFunc->GetOrCreateLabelOperand(tgtLabIdx);
+  brInsn->SetOperand(0, brTarget);
+  curBB.RemoveInsnSequence(*curBB.GetFirstInsn(), *brInsn->GetPrev());
+
+  curBB.RemoveFromSuccessorList(sucBB);
+  curBB.PushBackSuccs(*newTarget);
+  sucBB.RemoveFromPredecessorList(curBB);
+  newTarget->PushBackPreds(curBB);
+
+  sucBB.GetPrev()->SetUnreachable(false);
+  keepPosition = true;
+  return true;
+}
+
+/*
+ * Following optimizations are performed:
+ * 1. Basic block merging
+ * 2. unnecessary jumps elimination
+ * 3. Remove duplicates Basic block.
+ */
+bool ChainingPattern::Optimize(BB &curBB) {
+  if (curBB.GetKind() == BB::kBBFallthru) {
+    return MergeFallthuBB(curBB);
+  }
+
+  if (curBB.GetKind() == BB::kBBGoto && !curBB.IsEmpty()) {
+    Insn* last = curBB.GetLastInsn();
+    if (last->IsTailCall()) {
+      return false;
+    }
+
+    BB *sucBB = cgFunc->GetTheCFG()->GetTargetSuc(curBB);
+    /*
+     * BB2 can be merged into BB1, if
+     *   1. BB1 ends with a goto;
+     *   2. BB2 has only one predecessor which is BB1
+     *   3. BB2 is of goto kind. Otherwise, the original fall through will be broken
+     *   4. BB2 is neither catch BB nor switch case BB
+     */
+    if (sucBB == nullptr || curBB.GetEhSuccs().size() != sucBB->GetEhSuccs().size()) {
+      return false;
+    }
+    if (!curBB.GetEhSuccs().empty() && (curBB.GetEhSuccs().front() != sucBB->GetEhSuccs().front())) {
+      return false;
+    }
+    if (sucBB->GetKind() == BB::kBBGoto &&
+        !IsLabelInLSDAOrSwitchTable(sucBB->GetLabIdx()) &&
+        cgFunc->GetTheCFG()->CanMerge(curBB, *sucBB)) {
+      return MergeGotoBB(curBB, *sucBB);
+    } else if (sucBB != &curBB &&
+               curBB.GetNext() != sucBB &&
+               sucBB != cgFunc->GetLastBB() &&
+               !sucBB->IsPredecessor(*sucBB->GetPrev()) &&
+               !(sucBB->GetNext() != nullptr && sucBB->GetNext()->IsPredecessor(*sucBB)) &&
+               !IsLabelInLSDAOrSwitchTable(sucBB->GetLabIdx()) &&
+               sucBB->GetEhSuccs().empty() &&
+               sucBB->GetKind() != BB::kBBThrow && curBB.GetNext() != nullptr) {
+      return MoveSuccBBAsCurBBNext(curBB, *sucBB);
+    }
+    /*
+     * Last goto instruction can be removed, if:
+     *  1. The goto target is physically the next one to current BB.
+     */
+    else if (sucBB == curBB.GetNext() ||
+             (NoInsnBetween(curBB, *sucBB) && !IsLabelInLSDAOrSwitchTable(curBB.GetNext()->GetLabIdx()))) {
+      return RemoveGotoInsn(curBB, *sucBB);
+    }
+    /*
+     * Clear curBB and target it to sucBB->GetPrev()
+     *  if sucBB->GetPrev() and curBB's insns are the same.
+     *
+     * curBB:           curBB:
+     *   insn_x0          b prevbb
+     *   b sucBB        ...
+     * ...         ==>  prevbb:
+     * prevbb:            insn_x0
+     *   insn_x0        sucBB:
+     * sucBB:
+     */
+    else if (sucBB != curBB.GetNext() &&
+             !curBB.IsSoloGoto() &&
+             !IsLabelInLSDAOrSwitchTable(curBB.GetLabIdx()) &&
+             sucBB->GetKind() == BB::kBBReturn &&
+             sucBB->GetPreds().size() > 1 &&
+             sucBB->GetPrev() != nullptr &&
+             sucBB->IsPredecessor(*sucBB->GetPrev()) &&
+             (sucBB->GetPrev()->GetKind() == BB::kBBFallthru || sucBB->GetPrev()->GetKind() == BB::kBBGoto)) {
+      return ClearCurBBAndResetTargetBB(curBB, *sucBB);
+    }
+  }
+  return false;
+}
+
+/*
+ * curBB:             curBB:
+ *   insn_x0            insn_x0
+ *   b targetBB         b BB
+ * ...           ==>  ...
+ * targetBB:          targetBB:
+ *   b BB               b BB
+ * ...                ...
+ * BB:                BB:
+ * *------------------------------
+ * curBB:             curBB:
+ *   insn_x0            insn_x0
+ *   cond_br brBB       cond_br BB
+ * ...                ...
+ * brBB:         ==>  brBB:
+ *   b BB               b BB
+ * ...                ...
+ * BB:                BB:
+ *
+ * conditions:
+ *   1. only goto and comment in brBB;
+ */
+bool SequentialJumpPattern::Optimize(BB &curBB) {
+  if (curBB.IsUnreachable()) {
+    return false;
+  }
+  if (curBB.GetKind() == BB::kBBGoto && !curBB.IsEmpty()) {
+    BB *sucBB = cgFunc->GetTheCFG()->GetTargetSuc(curBB);
+    CHECK_FATAL(sucBB != nullptr, "sucBB is null in SequentialJumpPattern::Optimize");
+    BB *tragetBB = CGCFG::GetTargetSuc(*sucBB);
+    if ((sucBB != &curBB) && sucBB->IsSoloGoto() &&  tragetBB != nullptr && tragetBB != sucBB) {
+      Log(curBB.GetId());
+      if (checkOnly) {
+        return false;
+      }
+      cgFunc->GetTheCFG()->RetargetJump(*sucBB, curBB);
+      SkipSucBB(curBB, *sucBB);
+      return true;
+    }
+  } else if (curBB.GetKind() == BB::kBBIf) {
+    for (BB *sucBB : curBB.GetSuccs()) {
+      BB *tragetBB = CGCFG::GetTargetSuc(*sucBB);
+      if (sucBB != curBB.GetNext() && sucBB->IsSoloGoto() &&
+          tragetBB != nullptr && tragetBB != sucBB) {
+        Log(curBB.GetId());
+        if (checkOnly) {
+          return false;
+        }
+        cgFunc->GetTheCFG()->RetargetJump(*sucBB, curBB);
+        SkipSucBB(curBB, *sucBB);
+        return true;
+      }
+    }
+  } else if (curBB.GetKind() == BB::kBBRangeGoto) {
+    bool changed = false;
+    for (BB *sucBB : curBB.GetSuccs()) {
+      if (sucBB != curBB.GetNext() && sucBB->IsSoloGoto() &&
+          cgFunc->GetTheCFG()->GetTargetSuc(*sucBB) != nullptr) {
+        Log(curBB.GetId());
+        if (checkOnly) {
+          return false;
+        }
+        UpdateSwitchSucc(curBB, *sucBB);
+        cgFunc->GetTheCFG()->FlushUnReachableStatusAndRemoveRelations(*sucBB, *cgFunc);
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  return false;
+}
+
+void SequentialJumpPattern::UpdateSwitchSucc(BB &curBB, BB &sucBB) const {
+  BB *gotoTarget = cgFunc->GetTheCFG()->GetTargetSuc(sucBB);
+  CHECK_FATAL(gotoTarget != nullptr, "gotoTarget is null in SequentialJumpPattern::UpdateSwitchSucc");
+  const MapleVector<LabelIdx> &labelVec = curBB.GetRangeGotoLabelVec();
+  bool isPred = false;
+  for (auto label: labelVec) {
+    if (label == gotoTarget->GetLabIdx()) {
+      isPred = true;
+      break;
+    }
+  }
+  for (size_t i = 0; i < labelVec.size(); ++i) {
+    if (labelVec[i] == sucBB.GetLabIdx()) {
+      curBB.SetRangeGotoLabel(i, gotoTarget->GetLabIdx());
+    }
+  }
+  cgFunc->UpdateEmitSt(curBB, sucBB.GetLabIdx(), gotoTarget->GetLabIdx());
+
+  /* connect curBB, gotoTarget */
+  for (auto it = gotoTarget->GetPredsBegin(); it != gotoTarget->GetPredsEnd(); ++it) {
+    if (*it == &sucBB) {
+      auto origIt = it;
+      if (isPred) {
+        break;
+      }
+      if (origIt != gotoTarget->GetPredsBegin()) {
+        --origIt;
+        gotoTarget->InsertPred(origIt, curBB);
+      } else {
+        gotoTarget->PushFrontPreds(curBB);
+      }
+      break;
+    }
+  }
+  for (auto it = curBB.GetSuccsBegin(); it != curBB.GetSuccsEnd(); ++it) {
+    if (*it == &sucBB) {
+      auto origIt = it;
+      curBB.EraseSuccs(it);
+      if (isPred) {
+        break;
+      }
+      if (origIt != curBB.GetSuccsBegin()) {
+        --origIt;
+        curBB.InsertSucc(origIt, *gotoTarget);
+      } else {
+        curBB.PushFrontSuccs(*gotoTarget);
+      }
+      break;
+    }
+  }
+  /* cut curBB -> sucBB */
+  for (auto it = sucBB.GetPredsBegin(); it != sucBB.GetPredsEnd(); ++it) {
+    if (*it == &curBB) {
+      sucBB.ErasePreds(it);
+    }
+  }
+  for (auto it = curBB.GetSuccsBegin(); it != curBB.GetSuccsEnd(); ++it) {
+    if (*it == &sucBB) {
+      curBB.EraseSuccs(it);
+    }
+  }
+}
+
+/*
+ * preCond:
+ * sucBB is one of curBB's successor.
+ *
+ * Change curBB's successor to sucBB's successor
+ */
+void SequentialJumpPattern::SkipSucBB(BB &curBB, BB &sucBB) const {
+  BB *gotoTarget = cgFunc->GetTheCFG()->GetTargetSuc(sucBB);
+  CHECK_FATAL(gotoTarget != nullptr, "gotoTarget is null in SequentialJumpPattern::SkipSucBB");
+  curBB.RemoveSuccs(sucBB);
+  curBB.PushBackSuccs(*gotoTarget);
+  sucBB.RemovePreds(curBB);
+  gotoTarget->PushBackPreds(curBB);
+  cgFunc->GetTheCFG()->FlushUnReachableStatusAndRemoveRelations(sucBB, *cgFunc);
+}
+
+/*
+ * Found pattern
+ * curBB:                      curBB:
+ *       ...            ==>          ...
+ *       cond_br brBB                cond1_br ftBB
+ * ftBB:                       brBB:
+ *       bl throwfunc                ...
+ * brBB:                       retBB:
+ *       ...                         ...
+ * retBB:                      ftBB:
+ *       ...                         bl throwfunc
+ */
+void FlipBRPattern::RelocateThrowBB(BB &curBB) {
+  BB *ftBB = curBB.GetNext();
+  CHECK_FATAL(ftBB != nullptr, "ifBB has a fall through BB");
+  CGCFG *theCFG = cgFunc->GetTheCFG();
+  CHECK_FATAL(theCFG != nullptr, "nullptr check");
+  BB *retBB = theCFG->FindLastRetBB();
+  retBB = (retBB == nullptr ? cgFunc->GetLastBB() : retBB);
+  if (ftBB->GetKind() != BB::kBBThrow || !ftBB->GetEhSuccs().empty() ||
+      IsLabelInLSDAOrSwitchTable(ftBB->GetLabIdx()) || !retBB->GetEhSuccs().empty()) {
+    return;
+  }
+  BB *brBB = theCFG->GetTargetSuc(curBB);
+  if (brBB != ftBB->GetNext()) {
+    return;
+  }
+
+  EHFunc *ehFunc = cgFunc->GetEHFunc();
+  if (ehFunc != nullptr && ehFunc->GetLSDACallSiteTable() != nullptr) {
+    const MapleVector<LSDACallSite*> &callsiteTable = ehFunc->GetLSDACallSiteTable()->GetCallSiteTable();
+    for (size_t i = 0; i < callsiteTable.size(); ++i) {
+      LSDACallSite *lsdaCallsite = callsiteTable[i];
+      BB *endTry = cgFunc->GetBBFromLab2BBMap(lsdaCallsite->csLength.GetEndOffset()->GetLabelIdx());
+      BB *startTry = cgFunc->GetBBFromLab2BBMap(lsdaCallsite->csLength.GetStartOffset()->GetLabelIdx());
+      if (retBB->GetId() >= startTry->GetId() && retBB->GetId() <= endTry->GetId()) {
+        if (retBB->GetNext()->GetId() < startTry->GetId() || retBB->GetNext()->GetId() > endTry->GetId() ||
+            curBB.GetId() < startTry->GetId() || curBB.GetId() > endTry->GetId()) {
+          return;
+        }
+      } else {
+        if ((retBB->GetNext()->GetId() >= startTry->GetId() && retBB->GetNext()->GetId() <= endTry->GetId()) ||
+            (curBB.GetId() >= startTry->GetId() && curBB.GetId() <= endTry->GetId())) {
+          return;
+        }
+      }
+    }
+  }
+  /* get branch insn of curBB */
+  Insn *curBBBranchInsn = theCFG->FindLastCondBrInsn(curBB);
+  CHECK_FATAL(curBBBranchInsn != nullptr, "curBB(it is a kBBif) has no branch");
+
+  /* Reverse the branch */
+  uint32 targetIdx = GetJumpTargetIdx(*curBBBranchInsn);
+  MOperator mOp = FlipConditionOp(curBBBranchInsn->GetMachineOpcode());
+  LabelOperand &brTarget = cgFunc->GetOrCreateLabelOperand(*ftBB);
+  curBBBranchInsn->SetMOP(cgFunc->GetCG()->GetTargetMd(mOp));
+  curBBBranchInsn->SetOperand(targetIdx, brTarget);
+
+  /* move ftBB after retBB */
+  curBB.SetNext(brBB);
+  CHECK_NULL_FATAL(brBB);
+  brBB->SetPrev(&curBB);
+
+  retBB->GetNext()->SetPrev(ftBB);
+  ftBB->SetNext(retBB->GetNext());
+  ftBB->SetPrev(retBB);
+  retBB->SetNext(ftBB);
+}
+
+/*
+ * 1. relocate goto BB
+ * Found pattern             (1) ftBB->GetPreds().size() == 1
+ * curBB:                      curBB: cond1_br target
+ *       ...            ==>    brBB:
+ *       cond_br brBB           ...
+ * ftBB:                       targetBB: (ftBB,targetBB)
+ *       goto target         (2) ftBB->GetPreds().size() > 1
+ * brBB:                       curBB : cond1_br ftBB
+ *       ...                   brBB:
+ * targetBB                      ...
+ *                            ftBB
+ *                            targetBB
+ *
+ * loopHeaderBB:              loopHeaderBB:
+ *       ...                        ...
+ *       cond_br loopExit:          cond_br loopHeaderBB
+ * ftBB:                      ftBB:
+ *       goto loopHeaderBB:         goto loopExit
+ *
+ * 3. relocate throw BB in RelocateThrowBB()
+ */
+bool FlipBRPattern::Optimize(BB &curBB) {
+  if (curBB.GetKind() == BB::kBBIf && !curBB.IsEmpty()) {
+    BB *ftBB = curBB.GetNext();
+    ASSERT(ftBB != nullptr, "ftBB is null in  FlipBRPattern::Optimize");
+    BB *brBB = cgFunc->GetTheCFG()->GetTargetSuc(curBB);
+    ASSERT(brBB != nullptr, "brBB is null in  FlipBRPattern::Optimize");
+    /* Check if it can be optimized */
+    if (ftBB->GetKind() == BB::kBBGoto && ftBB->GetNext() == brBB) {
+      if (!ftBB->GetEhSuccs().empty()) {
+        return false;
+      }
+      Insn *curBBBranchInsn = nullptr;
+      for (curBBBranchInsn = curBB.GetLastInsn(); curBBBranchInsn != nullptr;
+           curBBBranchInsn = curBBBranchInsn->GetPrev()) {
+        if (curBBBranchInsn->IsBranch()) {
+          break;
+        }
+      }
+      ASSERT(curBBBranchInsn != nullptr, "FlipBRPattern: curBB has no branch");
+      Insn *brInsn = nullptr;
+      for (brInsn = ftBB->GetLastInsn(); brInsn != nullptr; brInsn = brInsn->GetPrev()) {
+        if (brInsn->IsUnCondBranch()) {
+          break;
+        }
+      }
+      ASSERT(brInsn != nullptr, "FlipBRPattern: ftBB has no branch");
+
+      /* Reverse the branch */
+      uint32 targetIdx = GetJumpTargetIdx(*curBBBranchInsn);
+      MOperator mOp = FlipConditionOp(curBBBranchInsn->GetMachineOpcode());
+      if (mOp == 0) {
+        return false;
+      }
+      auto it = ftBB->GetSuccsBegin();
+      BB *tgtBB = *it;
+      if (ftBB->GetPreds().size() == 1 &&
+          (ftBB->IsSoloGoto() ||
+           (!IsLabelInLSDAOrSwitchTable(tgtBB->GetLabIdx()) &&
+            cgFunc->GetTheCFG()->CanMerge(*ftBB, *tgtBB)))) {
+        curBBBranchInsn->SetMOP(cgFunc->GetCG()->GetTargetMd(mOp));
+        Operand &brTarget = brInsn->GetOperand(GetJumpTargetIdx(*brInsn));
+        curBBBranchInsn->SetOperand(targetIdx, brTarget);
+        /* Insert ftBB's insn at the beginning of tgtBB. */
+        if (!ftBB->IsSoloGoto()) {
+          ftBB->RemoveInsn(*brInsn);
+          tgtBB->InsertAtBeginning(*ftBB);
+        }
+        /* Patch pred and succ lists */
+        ftBB->EraseSuccs(it);
+        ftBB->PushBackSuccs(*brBB);
+        it = curBB.GetSuccsBegin();
+        CHECK_FATAL(*it != nullptr, "nullptr check");
+        if (*it == brBB) {
+          curBB.EraseSuccs(it);
+          curBB.PushBackSuccs(*tgtBB);
+        } else {
+          ++it;
+          curBB.EraseSuccs(it);
+          curBB.PushFrontSuccs(*tgtBB);
+        }
+        for (it = tgtBB->GetPredsBegin(); it != tgtBB->GetPredsEnd(); ++it) {
+          if (*it == ftBB) {
+            tgtBB->ErasePreds(it);
+            break;
+          }
+        }
+        tgtBB->PushBackPreds(curBB);
+        for (it = brBB->GetPredsBegin(); it != brBB->GetPredsEnd(); ++it) {
+          if (*it == &curBB) {
+            brBB->ErasePreds(it);
+            break;
+          }
+        }
+        brBB->PushFrontPreds(*ftBB);
+        /* Remove instructions from ftBB so curBB falls thru to brBB */
+        ftBB->SetFirstInsn(nullptr);
+        ftBB->SetLastInsn(nullptr);
+        ftBB->SetKind(BB::kBBFallthru);
+      } else if (!IsLabelInLSDAOrSwitchTable(ftBB->GetLabIdx()) &&
+                 !tgtBB->IsPredecessor(*tgtBB->GetPrev())) {
+        curBBBranchInsn->SetMOP(cgFunc->GetCG()->GetTargetMd(mOp));
+        LabelIdx tgtLabIdx = ftBB->GetLabIdx();
+        if (ftBB->GetLabIdx() == MIRLabelTable::GetDummyLabel()) {
+          tgtLabIdx = cgFunc->CreateLabel();
+          ftBB->AddLabel(tgtLabIdx);
+        }
+        LabelOperand &brTarget = cgFunc->GetOrCreateLabelOperand(tgtLabIdx);
+        curBBBranchInsn->SetOperand(targetIdx, brTarget);
+        curBB.SetNext(brBB);
+        brBB->SetPrev(&curBB);
+        ftBB->SetPrev(tgtBB->GetPrev());
+        tgtBB->GetPrev()->SetNext(ftBB);
+        ftBB->SetNext(tgtBB);
+        tgtBB->SetPrev(ftBB);
+
+        ftBB->RemoveInsn(*brInsn);
+        ftBB->SetKind(BB::kBBFallthru);
+      }
+    } else if (GetPhase() == kCfgoPostRegAlloc && ftBB->GetKind() == BB::kBBGoto &&
+               curBB.GetLoop() != nullptr &&  curBB.GetLoop() == ftBB->GetLoop() &&
+               ftBB->IsSoloGoto() &&
+               ftBB->GetLoop()->GetHeader() == *(ftBB->GetSuccsBegin()) &&
+               !curBB.GetLoop()->IsBBLoopMember((curBB.GetSuccs().front() == ftBB) ?
+                                                curBB.GetSuccs().back() : curBB.GetSuccs().front())) {
+      Insn *curBBBranchInsn = nullptr;
+      for (curBBBranchInsn = curBB.GetLastInsn(); curBBBranchInsn != nullptr;
+           curBBBranchInsn = curBBBranchInsn->GetPrev()) {
+        if (curBBBranchInsn->IsBranch()) {
+          break;
+        }
+      }
+      ASSERT(curBBBranchInsn != nullptr, "FlipBRPattern: curBB has no branch");
+      Insn *brInsn = nullptr;
+      for (brInsn = ftBB->GetLastInsn(); brInsn != nullptr; brInsn = brInsn->GetPrev()) {
+        if (brInsn->IsUnCondBranch()) {
+          break;
+        }
+      }
+      ASSERT(brInsn != nullptr, "FlipBRPattern: ftBB has no branch");
+      uint32 condTargetIdx = GetJumpTargetIdx(*curBBBranchInsn);
+      LabelOperand &condTarget = static_cast<LabelOperand&>(curBBBranchInsn->GetOperand(condTargetIdx));
+      MOperator mOp = FlipConditionOp(curBBBranchInsn->GetMachineOpcode());
+      if (mOp == 0) {
+        return false;
+      }
+      uint32 gotoTargetIdx = GetJumpTargetIdx(*brInsn);
+      LabelOperand &gotoTarget = static_cast<LabelOperand&>(brInsn->GetOperand(gotoTargetIdx));
+      curBBBranchInsn->SetMOP(cgFunc->GetCG()->GetTargetMd(mOp));
+      curBBBranchInsn->SetOperand(condTargetIdx, gotoTarget);
+      brInsn->SetOperand(gotoTargetIdx, condTarget);
+      auto it = ftBB->GetSuccsBegin();
+      BB *loopHeadBB = *it;
+
+      curBB.RemoveSuccs(*brBB);
+      brBB->RemovePreds(curBB);
+      ftBB->RemoveSuccs(*loopHeadBB);
+      loopHeadBB->RemovePreds(*ftBB);
+
+      curBB.PushBackSuccs(*loopHeadBB);
+      loopHeadBB->PushBackPreds(curBB);
+      ftBB->PushBackSuccs(*brBB);
+      brBB->PushBackPreds(*ftBB);
+    } else {
+      RelocateThrowBB(curBB);
+    }
+  }
+  return false;
+}
+
+/* remove a basic block that contains nothing */
+bool EmptyBBPattern::Optimize(BB &curBB) {
+  if (curBB.IsUnreachable()) {
+    return false;
+  }
+  /* Empty bb and it's not a cleanupBB/returnBB/lastBB/catchBB. */
+  if (curBB.GetPrev() != nullptr && !curBB.IsCleanup() &&
+      curBB.GetFirstInsn() == nullptr && curBB.GetLastInsn() == nullptr && &curBB != cgFunc->GetLastBB() &&
+      curBB.GetKind() != BB::kBBReturn && !IsLabelInLSDAOrSwitchTable(curBB.GetLabIdx())) {
+    Log(curBB.GetId());
+    if (checkOnly) {
+      return false;
+    }
+
+    BB *sucBB = cgFunc->GetTheCFG()->GetTargetSuc(curBB);
+    if (sucBB == nullptr || sucBB->IsCleanup()) {
+      return false;
+    }
+    cgFunc->GetTheCFG()->RemoveBB(curBB);
+    /* removeBB may do nothing. since no need to repeat, always ret false here. */
+    return false;
+  }
+  return false;
+}
+
+/*
+ * remove unreachable BB
+ * condition:
+ *   1. unreachable BB can't have cfi instruction when postcfgo.
+ */
+bool UnreachBBPattern::Optimize(BB &curBB) {
+  if (curBB.IsUnreachable()) {
+    Log(curBB.GetId());
+    if (checkOnly) {
+      return false;
+    }
+    /* if curBB in exitbbsvec,return false. */
+    if (cgFunc->IsExitBB(curBB)) {
+      /* In C some bb follow noreturn calls should remain unreachable */
+      curBB.SetUnreachable(cgFunc->GetMirModule().GetSrcLang() == kSrcLangC);
+      return false;
+    }
+
+    if (curBB.GetHasCfi() || (curBB.GetFirstInsn() != nullptr && curBB.GetFirstInsn()->IsCfiInsn())) {
+      return false;
+    }
+
+    EHFunc *ehFunc = cgFunc->GetEHFunc();
+    /* if curBB InLSDA ,replace curBB's label with nextReachableBB before remove it. */
+    if (ehFunc != nullptr && ehFunc->NeedFullLSDA() &&
+        cgFunc->GetTheCFG()->InLSDA(curBB.GetLabIdx(), ehFunc)) {
+      /* find nextReachableBB */
+      BB *nextReachableBB = nullptr;
+      for (BB *bb = &curBB; bb != nullptr; bb = bb->GetNext()) {
+        if (!bb->IsUnreachable()) {
+          nextReachableBB = bb;
+          break;
+        }
+      }
+      CHECK_FATAL(nextReachableBB != nullptr, "nextReachableBB not be nullptr");
+      if (nextReachableBB->GetLabIdx() == 0) {
+        LabelIdx labIdx = cgFunc->CreateLabel();
+        nextReachableBB->AddLabel(labIdx);
+        cgFunc->SetLab2BBMap(labIdx, *nextReachableBB);
+      }
+
+      ehFunc->GetLSDACallSiteTable()->UpdateCallSite(curBB, *nextReachableBB);
+    }
+    if (curBB.GetPrev() != nullptr) {
+      curBB.GetPrev()->SetNext(curBB.GetNext());
+    }
+    if (curBB.GetNext() != nullptr) {
+      curBB.GetNext()->SetPrev(curBB.GetPrev());
+    } else {
+      cgFunc->SetLastBB(*(curBB.GetPrev()));
+    }
+
+    /* flush after remove; */
+    for (BB *bb : curBB.GetSuccs()) {
+      bb->RemovePreds(curBB);
+      cgFunc->GetTheCFG()->FlushUnReachableStatusAndRemoveRelations(*bb, *cgFunc);
+    }
+    for (BB *bb : curBB.GetEhSuccs()) {
+      bb->RemoveEhPreds(curBB);
+      cgFunc->GetTheCFG()->FlushUnReachableStatusAndRemoveRelations(*bb, *cgFunc);
+    }
+    curBB.ClearSuccs();
+    curBB.ClearEhSuccs();
+    /* return always be false */
+  }
+  return false;
+}
+
+/* BB_pred1:        BB_pred1:
+ *   b curBB          insn_x0
+ * ...                b BB2
+ * BB_pred2:   ==>  ...
+ *   b curBB        BB_pred2:
+ * ...                insn_x0
+ * curBB:             b BB2
+ *   insn_x0        ...
+ *   b BB2          curBB:
+ *                    insn_x0
+ *                    b BB2
+ * condition:
+ *   1. The number of instruct in curBB
+ *        is less than THRESHOLD;
+ *   2. curBB can't have cfi instruction when postcfgo.
+ */
+bool DuplicateBBPattern::Optimize(BB &curBB) {
+  if (curBB.IsUnreachable()) {
+    return false;
+  }
+  if (CGOptions::IsNoDupBB() || CGOptions::OptimizeForSize()) {
+    return false;
+  }
+
+  /* curBB can't be in try block */
+  if (curBB.GetKind() != BB::kBBGoto || IsLabelInLSDAOrSwitchTable(curBB.GetLabIdx()) ||
+      !curBB.GetEhSuccs().empty()) {
+    return false;
+  }
+
+#if TARGARM32
+  FOR_BB_INSNS(insn, (&curBB)) {
+    if (insn->IsPCLoad() || insn->IsClinit()) {
+      return false;
+    }
+  }
+#endif
+  /* It is possible curBB jump to itself */
+  uint32 numPreds = curBB.NumPreds();
+  for (BB *bb : curBB.GetPreds()) {
+    if (bb == &curBB) {
+      numPreds--;
+    }
+  }
+
+  if (numPreds > 1 && cgFunc->GetTheCFG()->GetTargetSuc(curBB) != nullptr &&
+      cgFunc->GetTheCFG()->GetTargetSuc(curBB)->NumPreds() > 1) {
+    std::vector<BB*> candidates;
+    for (BB *bb : curBB.GetPreds()) {
+      if (bb->GetKind() == BB::kBBGoto && bb->GetNext() != &curBB && bb != &curBB && !bb->IsEmpty()) {
+        candidates.emplace_back(bb);
+      }
+    }
+    if (candidates.empty()) {
+      return false;
+    }
+    if (curBB.NumInsn() <= kThreshold) {
+      if (curBB.GetHasCfi() || (curBB.GetFirstInsn() != nullptr && curBB.GetFirstInsn()->IsCfiInsn())) {
+        return false;
+      }
+      Log(curBB.GetId());
+      if (checkOnly) {
+        return false;
+      }
+      bool changed = false;
+      for (BB *bb : candidates) {
+        if (curBB.GetEhSuccs().size() != bb->GetEhSuccs().size()) {
+          continue;
+        }
+        if (!curBB.GetEhSuccs().empty() && (curBB.GetEhSuccs().front() != bb->GetEhSuccs().front())) {
+          continue;
+        }
+        bb->RemoveInsn(*bb->GetLastInsn());
+        FOR_BB_INSNS(insn, (&curBB)) {
+          Insn *clonedInsn = cgFunc->GetTheCFG()->CloneInsn(*insn);
+          clonedInsn->SetPrev(nullptr);
+          clonedInsn->SetNext(nullptr);
+          clonedInsn->SetBB(nullptr);
+          bb->AppendInsn(*clonedInsn);
+        }
+        bb->RemoveSuccs(curBB);
+        for (BB *item : curBB.GetSuccs()) {
+          bb->PushBackSuccs(*item);
+          item->PushBackPreds(*bb);
+        }
+        curBB.RemovePreds(*bb);
+        changed = true;
+      }
+      cgFunc->GetTheCFG()->FlushUnReachableStatusAndRemoveRelations(curBB, *cgFunc);
+      return changed;
+    }
+  }
+  return false;
+}
+
+/* === new pm === */
+bool CgCfgo::PhaseRun(maplebe::CGFunc &f) {
+  CFGOptimizer *cfgOptimizer = f.GetCG()->CreateCFGOptimizer(*GetPhaseMemPool(), f);
+  if (f.IsAfterRegAlloc()) {
+    (void)GetAnalysisInfoHook()->ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgLoopAnalysis::id, f);
+    cfgOptimizer->SetPhase(kCfgoPostRegAlloc);
+  }
+  const std::string &funcClass = f.GetFunction().GetBaseClassName();
+  const std::string &funcName = f.GetFunction().GetBaseFuncName();
+  const std::string &name = funcClass + funcName;
+  if (CFGO_DUMP_NEWPM) {
+    DotGenerator::GenerateDot("before-cfgo", f, f.GetMirModule());
+  }
+  cfgOptimizer->Run(name);
+  if (f.IsAfterRegAlloc()) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &CgLoopAnalysis::id);
+  }
+  if (CFGO_DUMP_NEWPM) {
+    f.GetTheCFG()->CheckCFG();
+    DotGenerator::GenerateDot("after-cfgo", f, f.GetMirModule());
+  }
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgCfgo, cfgo)
+
+bool CgPostCfgo::PhaseRun(maplebe::CGFunc &f) {
+  CFGOptimizer *cfgOptimizer = f.GetCG()->CreateCFGOptimizer(*GetPhaseMemPool(), f);
+  const std::string &funcClass = f.GetFunction().GetBaseClassName();
+  const std::string &funcName = f.GetFunction().GetBaseFuncName();
+  const std::string &name = funcClass + funcName;
+  if (CFGO_DUMP_NEWPM) {
+    DotGenerator::GenerateDot("before-postcfgo", f, f.GetMirModule());
+  }
+  cfgOptimizer->Run(name);
+  if (CFGO_DUMP_NEWPM) {
+    DotGenerator::GenerateDot("after-postcfgo", f, f.GetMirModule());
+  }
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPostCfgo, postcfgo)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cfi.cpp b/src/mapleall/maple_be/src/cg/cfi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3c5e64769cd83a2c5a2ab32736f081f5879e5432
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cfi.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cfi.h"
+#include "emit.h"
+
+namespace cfi {
+using maplebe::Operand;
+using maplebe::MOperator;
+using maplebe::CG;
+using maplebe::Emitter;
+using maplebe::OpndDesc;
+
+struct CfiDescr {
+  const std::string name;
+  uint32 opndCount;
+  /* create 3 OperandType array to store cfi instruction's operand type */
+  std::array<Operand::OperandType, 3> opndTypes;
+};
+
+static CfiDescr cfiDescrTable[kOpCfiLast + 1] = {
+#define CFI_DEFINE(k, sub, n, o0, o1, o2) \
+  { ".cfi_" #k, n, { Operand::kOpd##o0, Operand::kOpd##o1, Operand::kOpd##o2 } },
+#define ARM_DIRECTIVES_DEFINE(k, sub, n, o0, o1, o2) \
+  { "." #k, n, { Operand::kOpd##o0, Operand::kOpd##o1, Operand::kOpd##o2 } },
+#include "cfi.def"
+#undef CFI_DEFINE
+#undef ARM_DIRECTIVES_DEFINE
+  { ".cfi_undef", 0, { Operand::kOpdUndef, Operand::kOpdUndef, Operand::kOpdUndef } }
+};
+
+void CfiInsn::Dump() const {
+  MOperator mOp = GetMachineOpcode();
+  CfiDescr &cfiDescr = cfiDescrTable[mOp];
+  LogInfo::MapleLogger() << "CFI " << cfiDescr.name;
+  for (uint32 i = 0; i < static_cast<uint32>(cfiDescr.opndCount); ++i) {
+    LogInfo::MapleLogger() << (i == 0 ? " : " : " ");
+    Operand &curOperand = GetOperand(i);
+    curOperand.Dump();
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+#if DEBUG
+void CfiInsn::Check() const {
+  CfiDescr &cfiDescr = cfiDescrTable[GetMachineOpcode()];
+  /* cfi instruction's 3rd /4th/5th operand must be null */
+  for (uint32 i = 0; i < static_cast<uint32>(cfiDescr.opndCount); ++i) {
+    Operand &opnd = GetOperand(i);
+    if (opnd.GetKind() != cfiDescr.opndTypes[i]) {
+      CHECK_FATAL(false, "incorrect operand in cfi insn");
+    }
+  }
+}
+#endif
+
+void RegOperand::Dump() const {
+  LogInfo::MapleLogger() << "reg: " << regNO << "[ size: " << GetSize() << "] ";
+}
+
+void ImmOperand::Dump() const {
+  LogInfo::MapleLogger() << "imm: " << val << "[ size: " << GetSize() << "] ";
+}
+
+void StrOperand::Dump() const {
+  LogInfo::MapleLogger() << str;
+}
+
+void LabelOperand::Dump() const {
+  LogInfo::MapleLogger() << "label:" << labelIndex;
+}
+void CFIOpndEmitVisitor::Visit(RegOperand *v) {
+  emitter.Emit(v->GetRegisterNO());
+}
+void CFIOpndEmitVisitor::Visit(ImmOperand *v) {
+  emitter.Emit(v->GetValue());
+}
+void CFIOpndEmitVisitor::Visit(SymbolOperand *v) {
+  CHECK_FATAL(false, "NIY");
+}
+void CFIOpndEmitVisitor::Visit(StrOperand *v) {
+  emitter.Emit(v->GetStr());
+}
+void CFIOpndEmitVisitor::Visit(LabelOperand *v) {
+  if (emitter.GetCG()->GetMIRModule()->IsCModule()) {
+    PUIdx pIdx = emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx();
+    const char *idx = strdup(std::to_string(pIdx).c_str());
+    emitter.Emit(".label.").Emit(idx).Emit("__").Emit(v->GetIabelIdx());
+  } else {
+    emitter.Emit(".label.").Emit(v->GetParentFunc()).Emit(v->GetIabelIdx());
+  }
+}
+}  /* namespace cfi */
diff --git a/src/mapleall/maple_be/src/cg/cfi_generator.cpp b/src/mapleall/maple_be/src/cg/cfi_generator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..40862914cff3c1e79548b6d4b024f165bcac1845
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cfi_generator.cpp
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cfi_generator.h"
+#include "cgfunc.h"
+#if TARGAARCH64
+#include "aarch64_cfi_generator.h"
+#include "aarch64_cgfunc.h"
+#endif
+
+namespace maplebe {
+Insn &GenCfi::FindStackDefNextInsn(BB &bb) const {
+  FOR_BB_INSNS(insn, &bb) {
+    if (insn->IsStackDef()) {
+      if (insn->GetNext() == nullptr) {
+        auto &comment = cgFunc.GetOpndBuilder()->CreateComment("stack alloc end");
+        bb.AppendInsn(cgFunc.GetInsnBuilder()->BuildCommentInsn(comment));
+      }
+      return *(insn->GetNext());
+    }
+  }
+  CHECK_FATAL(false, "bb need a stackdef insn");
+}
+
+void GenCfi::InsertCFIDefCfaOffset(BB &bb, Insn &insn, int32 &cfiOffset) {
+  cfiOffset = AddtoOffsetFromCFA(cfiOffset);
+  Insn &cfiInsn = cgFunc.GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_def_cfa_offset).AddOpndChain(
+      cgFunc.CreateCfiImmOperand(cfiOffset, k64BitSize));
+  (void)bb.InsertInsnBefore(insn, cfiInsn);
+  cgFunc.SetDbgCallFrameOffset(cfiOffset);
+}
+
+void GenCfi::GenerateStartDirective(BB &bb) {
+  Insn &startprocInsn = cgFunc.GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_startproc);
+  if (bb.GetFirstInsn() != nullptr) {
+    (void)bb.InsertInsnBefore(*bb.GetFirstInsn(), startprocInsn);
+  } else {
+    bb.AppendInsn(startprocInsn);
+  }
+
+#if !defined(TARGARM32)
+  /*
+   * always generate ".cfi_personality 155, DW.ref.__mpl_personality_v0" for Java methods.
+   * we depend on this to tell whether it is a java method. (maybe we can get a function attribute to determine it)
+   */
+  if (cgFunc.GetFunction().IsJava()) {
+    Insn &personality = cgFunc.GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_personality_symbol).AddOpndChain(
+        cgFunc.CreateCfiImmOperand(EHFunc::kTypeEncoding, k8BitSize)).AddOpndChain(
+        cgFunc.CreateCfiStrOperand("DW.ref.__mpl_personality_v0"));
+    bb.InsertInsnAfter(startprocInsn, personality);
+  }
+#endif
+}
+
+void GenCfi::GenerateEndDirective(BB &bb) {
+  bb.AppendInsn(cgFunc.GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_endproc));
+}
+
+void GenCfi::GenerateRegisterStateDirective(BB &bb) {
+  if (cg.GetMIRModule()->IsCModule()) {
+    return;
+  }
+
+  if (&bb == cgFunc.GetLastBB() || bb.GetNext() == nullptr) {
+    return;
+  }
+
+  BB *nextBB = bb.GetNext();
+  do {
+    if (nextBB == cgFunc.GetLastBB() || !nextBB->IsEmpty()) {
+      break;
+    }
+    nextBB = nextBB->GetNext();
+  } while (nextBB != nullptr);
+
+  if (nextBB != nullptr && !nextBB->IsEmpty()) {
+    bb.InsertInsnBegin(cgFunc.GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_remember_state));
+    nextBB->InsertInsnBegin(cgFunc.GetInsnBuilder()->BuildCfiInsn(cfi::OP_CFI_restore_state));
+  }
+}
+
+void GenCfi::InsertFirstLocation(BB &bb) {
+  MIRSymbol *fSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(cgFunc.GetFunction().GetStIdx().Idx());
+
+  if (fSym == nullptr || !cg.GetCGOptions().WithLoc() || !cg.GetMIRModule()->IsCModule() ||
+      (fSym->GetSrcPosition().FileNum() == 0)) {
+    return;
+  }
+
+  uint32 fileNum = fSym->GetSrcPosition().FileNum();
+  uint32 lineNum = fSym->GetSrcPosition().LineNum();
+  uint32 columnNum = fSym->GetSrcPosition().Column();
+  Operand *fileNumOpnd = cgFunc.CreateDbgImmOperand(fileNum);
+  Operand *lineNumOpnd = cgFunc.CreateDbgImmOperand(lineNum);
+  Operand *columnNumOpnd = cgFunc.CreateDbgImmOperand(columnNum);
+  Insn &loc = cgFunc.GetInsnBuilder()->BuildDbgInsn(mpldbg::OP_DBG_loc).AddOpndChain(
+      *fileNumOpnd).AddOpndChain(*lineNumOpnd).AddOpndChain(*columnNumOpnd);
+  (void)(bb.InsertInsnBefore(*bb.GetFirstInsn(), loc));
+}
+
+void GenCfi::Run() {
+  auto *startBB = cgFunc.GetFirstBB();
+  GenerateStartDirective(*startBB);
+  InsertFirstLocation(*startBB);
+
+  if (cgFunc.GetHasProEpilogue()) {
+    GenerateRegisterSaveDirective(*(cgFunc.GetPrologureBB()));
+
+    FOR_ALL_BB(bb, &cgFunc) {
+      if (!bb->IsFastPathReturn() && bb->IsNeedRestoreCfi()) {
+        GenerateRegisterStateDirective(*bb);
+        GenerateRegisterRestoreDirective(*bb);
+      }
+    }
+  }
+
+  GenerateEndDirective(*(cgFunc.GetLastBB()));
+}
+
+bool CgGenCfi::PhaseRun(maplebe::CGFunc &f) {
+#if TARGAARCH64
+  GenCfi *genCfi = GetPhaseAllocator()->New<AArch64GenCfi>(f);
+  genCfi->Run();
+#endif
+  return true;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgGenCfi, gencfi)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cg.cpp b/src/mapleall/maple_be/src/cg/cg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9fe0fc7afb0bd583bde9a8ca2186b5c9b20ab150
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg.cpp
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <set>
+#include "emit.h"
+
+namespace maplebe {
+using namespace maple;
+
+#define JAVALANG (mirModule->IsJavaModule())
+
+void Globals::SetTarget(CG &target) {
+  cg = &target;
+}
+const CG *Globals::GetTarget() const  {
+  ASSERT(cg, " set target info please ");
+  return cg;
+}
+
+CGFunc *CG::currentCGFunction = nullptr;
+std::map<MIRFunction*, std::pair<LabelIdx, LabelIdx>> CG::funcWrapLabels;
+
+CG::~CG() {
+  if (emitter != nullptr) {
+    emitter->CloseOutput();
+  }
+  delete memPool;
+  memPool = nullptr;
+  mirModule = nullptr;
+  emitter = nullptr;
+  currentCGFunction = nullptr;
+  dbgTraceEnter = nullptr;
+  dbgTraceExit = nullptr;
+  dbgFuncProfile = nullptr;
+}
+/* This function intends to be a more general form of GenFieldOffsetmap. */
+void CG::GenExtraTypeMetadata(const std::string &classListFileName, const std::string &outputBaseName) {
+  const std::string &cMacroDefSuffix = ".macros.def";
+  BECommon *beCommon = Globals::GetInstance()->GetBECommon();
+  std::vector<MIRClassType*> classesToGenerate;
+
+  if (classListFileName.empty()) {
+    /*
+     * Class list not specified. Visit all classes.
+     */
+    std::set<std::string> visited;
+
+    for (const auto &tyId : mirModule->GetClassList()) {
+      MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyId);
+      if ((mirType->GetKind() != kTypeClass) && (mirType->GetKind() != kTypeClassIncomplete)) {
+        continue;  /* Skip non-class. Too paranoid. We just enumerated classlist_! */
+      }
+      MIRClassType *classType = static_cast<MIRClassType*>(mirType);
+      const std::string &name = classType->GetName();
+
+      if (visited.find(name) != visited.end()) {
+        continue;  /* Skip duplicated class definitions. */
+      }
+
+      (void)visited.insert(name);
+      classesToGenerate.emplace_back(classType);
+    }
+  } else {
+    /* Visit listed classes. */
+    std::ifstream inFile(classListFileName);
+    CHECK_FATAL(inFile.is_open(), "Failed to open file: %s", classListFileName.c_str());
+    std::string str;
+
+    /* check each class name first and expose all unknown classes */
+    while (inFile >> str) {
+      MIRType *type = GlobalTables::GetTypeTable().GetOrCreateClassType(str, *mirModule);
+      MIRClassType *classType = static_cast<MIRClassType*>(type);
+      if (classType == nullptr) {
+        LogInfo::MapleLogger() << " >>>>>>>> unknown class: " << str.c_str() << "\n";
+        return;
+      }
+
+      classesToGenerate.emplace_back(classType);
+    }
+  }
+
+  if (cgOption.GenDef()) {
+    const std::string &outputFileName = outputBaseName + cMacroDefSuffix;
+    FILE *outputFile = fopen(outputFileName.c_str(), "w");
+    if (outputFile == nullptr) {
+      FATAL(kLncFatal, "open file failed in CG::GenExtraTypeMetadata");
+    }
+
+    for (auto classType : classesToGenerate) {
+      beCommon->GenObjSize(*classType, *outputFile);
+      beCommon->GenFieldOffsetMap(*classType, *outputFile);
+    }
+    fclose(outputFile);
+  }
+
+  if (cgOption.GenGctib()) {
+    maple::LogInfo::MapleLogger(kLlErr) << "--gen-gctib-file option not implemented";
+  }
+}
+
+void CG::GenPrimordialObjectList(const std::string &outputBaseName) {
+  const std::string &kPrimorListSuffix = ".primordials.txt";
+  if (!cgOption.GenPrimorList()) {
+    return;
+  }
+
+  const std::string &outputFileName = outputBaseName + kPrimorListSuffix;
+  FILE *outputFile = fopen(outputFileName.c_str(), "w");
+  if (outputFile == nullptr) {
+    FATAL(kLncFatal, "open file failed in CG::GenPrimordialObjectList");
+  }
+
+  for (StIdx stIdx : mirModule->GetSymbolSet()) {
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+    ASSERT(symbol != nullptr, "get symbol from st idx failed");
+    if (symbol->IsPrimordialObject()) {
+      const std::string &name = symbol->GetName();
+      fprintf(outputFile, "%s\n", name.c_str());
+    }
+  }
+
+  fclose(outputFile);
+}
+
+void CG::AddStackGuardvar() const {
+  MIRSymbol *chkGuard = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  chkGuard->SetNameStrIdx(std::string("__stack_chk_guard"));
+  chkGuard->SetStorageClass(kScExtern);
+  chkGuard->SetSKind(kStVar);
+  CHECK_FATAL(GlobalTables::GetTypeTable().GetTypeTable().size() > PTY_u64, "out of vector range");
+  chkGuard->SetTyIdx(GlobalTables::GetTypeTable().GetTypeTable()[PTY_u64]->GetTypeIndex());
+  GlobalTables::GetGsymTable().AddToStringSymbolMap(*chkGuard);
+
+  MIRSymbol *chkFunc = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  chkFunc->SetNameStrIdx(std::string("__stack_chk_fail"));
+  chkFunc->SetStorageClass(kScText);
+  chkFunc->SetSKind(kStFunc);
+  GlobalTables::GetGsymTable().AddToStringSymbolMap(*chkFunc);
+}
+
+#define DBG_TRACE_ENTER MplDtEnter
+#define DBG_TRACE_EXIT MplDtExit
+#define XSTR(s) str(s)
+#define str(s) #s
+
+void CG::DefineDebugTraceFunctions() {
+  dbgTraceEnter = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  dbgTraceEnter->SetNameStrIdx(std::string("__" XSTR(DBG_TRACE_ENTER) "__"));
+  dbgTraceEnter->SetStorageClass(kScText);
+  dbgTraceEnter->SetSKind(kStFunc);
+
+  dbgTraceExit = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  dbgTraceExit->SetNameStrIdx(std::string("__" XSTR(DBG_TRACE_EXIT) "__"));
+  dbgTraceExit->SetStorageClass(kScText);
+  dbgTraceExit->SetSKind(kStFunc);
+
+  dbgFuncProfile = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  dbgFuncProfile->SetNameStrIdx(std::string("__" XSTR(MplFuncProfile) "__"));
+  dbgFuncProfile->SetStorageClass(kScText);
+  dbgFuncProfile->SetSKind(kStFunc);
+}
+
+/*
+ * Add the fields of curStructType to the result. Used to handle recursive
+ * structures.
+ */
+static void AppendReferenceOffsets64(const BECommon &beCommon, MIRStructType &curStructType, int64 &curOffset,
+                                     std::vector<int64> &result) {
+  /*
+   * We are going to reimplement BECommon::GetFieldOffset so that we can do
+   * this in one pass through all fields.
+   *
+   * The tricky part is to make sure the object layout described here is
+   * compatible with the rest of the system. This implies that we need
+   * something like a "Maple ABI" documented for each platform.
+   */
+  if (curStructType.GetKind() == kTypeClass) {
+    MIRClassType &curClassTy = static_cast<MIRClassType&>(curStructType);
+    auto maybeParent = GlobalTables::GetTypeTable().GetTypeFromTyIdx(curClassTy.GetParentTyIdx());
+    if (maybeParent != nullptr) {
+      if (maybeParent->GetKind() == kTypeClass) {
+        auto parentClassType = static_cast<MIRClassType*>(maybeParent);
+        AppendReferenceOffsets64(beCommon, *parentClassType, curOffset, result);
+      } else {
+        LogInfo::MapleLogger() << "WARNING:: generating objmap for incomplete class\n";
+      }
+    }
+  }
+
+  for (const auto &fieldPair : curStructType.GetFields()) {
+    auto fieldNameIdx = fieldPair.first;
+    auto fieldTypeIdx = fieldPair.second.first;
+
+    auto &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldNameIdx);
+    auto fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTypeIdx);
+    auto &fieldTypeName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldType->GetNameStrIdx());
+    auto fieldTypeKind = fieldType->GetKind();
+
+    auto fieldSize = beCommon.GetTypeSize(fieldTypeIdx);
+    auto fieldAlign = beCommon.GetTypeAlign(fieldTypeIdx);
+    int64 myOffset = static_cast<int64>(RoundUp(curOffset, fieldAlign));
+    int64 nextOffset = myOffset + fieldSize;
+
+    if (!CGOptions::IsQuiet()) {
+      LogInfo::MapleLogger() << "    field: " << fieldName << "\n";
+      LogInfo::MapleLogger() << "      type: " << fieldTypeIdx << ": " << fieldTypeName << "\n";
+      LogInfo::MapleLogger() << "      type kind: " << fieldTypeKind << "\n";
+      LogInfo::MapleLogger() << "      size: " << fieldSize << "\n";                               /* int64 */
+      LogInfo::MapleLogger() << "      align: " << static_cast<uint32>(fieldAlign) << "\n";  /* int8_t */
+      LogInfo::MapleLogger() << "      field offset:" << myOffset << "\n";                         /* int64 */
+    }
+
+    if (fieldTypeKind == kTypePointer) {
+      if (!CGOptions::IsQuiet()) {
+        LogInfo::MapleLogger() << "      ** Is a pointer field.\n";
+      }
+      result.emplace_back(myOffset);
+    }
+
+    if ((fieldTypeKind == kTypeArray) || (fieldTypeKind == kTypeStruct) || (fieldTypeKind == kTypeClass) ||
+        (fieldTypeKind == kTypeInterface)) {
+      if (!CGOptions::IsQuiet()) {
+        LogInfo::MapleLogger() << "    ** ERROR: We are not expecting nested aggregate type. ";
+        LogInfo::MapleLogger() << "All Java classes are flat -- no nested structs. ";
+        LogInfo::MapleLogger() << "Please extend me if we are going to work with non-java languages.\n";
+      }
+    }
+
+    curOffset = nextOffset;
+  }
+}
+
+/* Return a list of offsets of reference fields. */
+std::vector<int64> CG::GetReferenceOffsets64(const BECommon &beCommon, MIRStructType &structType) const {
+  std::vector<int64> result;
+  /* java class layout has already been done in previous phase. */
+  if (structType.GetKind() == kTypeClass) {
+    for (auto fieldInfo : beCommon.GetJClassLayout(static_cast<MIRClassType&>(structType))) {
+      if (fieldInfo.IsRef()) {
+        result.emplace_back(static_cast<int64>(fieldInfo.GetOffset()));
+      }
+    }
+  } else if (structType.GetKind() != kTypeInterface) {  /* interface doesn't have reference fields */
+    int64 curOffset = 0;
+    AppendReferenceOffsets64(beCommon, structType, curOffset, result);
+  }
+
+  return result;
+}
+
+const std::string CG::ExtractFuncName(const std::string &str) const {
+  /* 3: length of "_7C" */
+  size_t offset = 3;
+  size_t pos1 = str.find("_7C");
+  if (pos1 == std::string::npos) {
+    return str;
+  }
+  size_t pos2 = str.find("_7C", pos1 + offset);
+  if (pos2 == std::string::npos) {
+    return str;
+  }
+  std::string funcName = str.substr(pos1 + offset, pos2 - pos1 - offset);
+  /* avoid funcName like __LINE__ and __FILE__ which will be resolved by assembler */
+  if (funcName.find("__") != std::string::npos) {
+    return str;
+  }
+  if (funcName == "_3Cinit_3E") {
+    return "init";
+  }
+  if (funcName == "_3Cclinit_3E") {
+    return "clinit";
+  }
+  return funcName;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cg_cfg.cpp b/src/mapleall/maple_be/src/cg/cg_cfg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4572d2501e052bb7ff7ad0c63d310371659e8800
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_cfg.cpp
@@ -0,0 +1,986 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_cfg.h"
+#if TARGAARCH64
+#include "aarch64_insn.h"
+#elif TARGRISCV64
+#include "riscv64_insn.h"
+#endif
+#if TARGARM32
+#include "arm32_insn.h"
+#endif
+#include "cg_option.h"
+#include "mpl_logging.h"
+#if TARGX86_64
+#include "x64_cgfunc.h"
+#include "cg.h"
+#endif
+#include <cstdlib>
+
+namespace {
+using namespace maplebe;
+bool CanBBThrow(const BB &bb) {
+  FOR_BB_INSNS_CONST(insn, &bb) {
+    if (insn->IsTargetInsn() && insn->CanThrow()) {
+      return true;
+    }
+  }
+  return false;
+}
+}
+
+namespace maplebe {
+void CGCFG::BuildCFG() {
+  /*
+   * Second Pass:
+   * Link preds/succs in the BBs
+   */
+  BB *firstBB = cgFunc->GetFirstBB();
+  for (BB *curBB = firstBB; curBB != nullptr; curBB = curBB->GetNext()) {
+    BB::BBKind kind = curBB->GetKind();
+    switch (kind) {
+      case BB::kBBIntrinsic:
+        /*
+         * An intrinsic BB append a MOP_wcbnz instruction at the end, check
+         * AArch64CGFunc::SelectIntrinCall(IntrinsiccallNode *intrinsiccallNode) for details
+         */
+        if (!curBB->GetLastInsn()->IsBranch()) {
+          break;
+        }
+      /* else fall through */
+      [[clang::fallthrough]];
+      case BB::kBBIf: {
+        BB *fallthruBB = curBB->GetNext();
+        curBB->PushBackSuccs(*fallthruBB);
+        fallthruBB->PushBackPreds(*curBB);
+        Insn *branchInsn = curBB->GetLastMachineInsn();
+        CHECK_FATAL(branchInsn != nullptr, "machine instruction must be exist in ifBB");
+        ASSERT(branchInsn->IsCondBranch(), "must be a conditional branch generated from an intrinsic");
+        /* Assume the last non-null operand is the branch target */
+        int lastOpndIndex = curBB->GetLastMachineInsn()->GetOperandSize() - 1;
+        ASSERT(lastOpndIndex > -1, "lastOpndIndex's opnd is greater than -1");
+        Operand &lastOpnd = branchInsn->GetOperand(static_cast<uint32>(lastOpndIndex));
+        ASSERT(lastOpnd.IsLabelOpnd(), "label Operand must be exist in branch insn");
+        auto &labelOpnd = static_cast<LabelOperand&>(lastOpnd);
+        BB *brToBB = cgFunc->GetBBFromLab2BBMap(labelOpnd.GetLabelIndex());
+        if (fallthruBB->GetId() != brToBB->GetId()) {
+          curBB->PushBackSuccs(*brToBB);
+          brToBB->PushBackPreds(*curBB);
+        }
+        break;
+      }
+      case BB::kBBGoto: {
+        Insn *insn = curBB->GetLastMachineInsn();
+        CHECK_FATAL(insn != nullptr, "machine insn must be exist in gotoBB");
+        ASSERT(insn->IsUnCondBranch(), "insn must be a unconditional branch insn");
+        LabelIdx labelIdx = static_cast<LabelOperand&>(insn->GetOperand(0)).GetLabelIndex();
+        BB *gotoBB = cgFunc->GetBBFromLab2BBMap(labelIdx);
+        CHECK_FATAL(gotoBB != nullptr, "gotoBB is null");
+        curBB->PushBackSuccs(*gotoBB);
+        gotoBB->PushBackPreds(*curBB);
+        break;
+      }
+      case BB::kBBIgoto: {
+        for (auto lidx : CG::GetCurCGFunc()->GetMirModule().CurFunction()->GetLabelTab()->GetAddrTakenLabels()) {
+          BB *igotobb = cgFunc->GetBBFromLab2BBMap(lidx);
+          CHECK_FATAL(igotobb, "igotobb is null");
+          curBB->PushBackSuccs(*igotobb);
+          igotobb->PushBackPreds(*curBB);
+        }
+        break;
+      }
+      case BB::kBBRangeGoto: {
+        std::set<BB*, BBIdCmp> bbs;
+        for (auto labelIdx : curBB->GetRangeGotoLabelVec()) {
+          BB *gotoBB = cgFunc->GetBBFromLab2BBMap(labelIdx);
+          bbs.insert(gotoBB);
+        }
+        for (auto gotoBB : bbs) {
+          curBB->PushBackSuccs(*gotoBB);
+          gotoBB->PushBackPreds(*curBB);
+        }
+        break;
+      }
+      case BB::kBBThrow:
+        break;
+      case BB::kBBFallthru: {
+        BB *fallthruBB = curBB->GetNext();
+        if (fallthruBB != nullptr) {
+          curBB->PushBackSuccs(*fallthruBB);
+          fallthruBB->PushBackPreds(*curBB);
+        }
+        break;
+      }
+      default:
+        break;
+    }  /* end switch */
+
+    EHFunc *ehFunc = cgFunc->GetEHFunc();
+    /* Check exception table. If curBB is in a try block, add catch BB to its succs */
+    if (ehFunc != nullptr && ehFunc->GetLSDACallSiteTable() != nullptr) {
+      /* Determine if insn in bb can actually except */
+      if (CanBBThrow(*curBB)) {
+        const MapleVector<LSDACallSite*> &callsiteTable = ehFunc->GetLSDACallSiteTable()->GetCallSiteTable();
+        for (size_t i = 0; i < callsiteTable.size(); ++i) {
+          LSDACallSite *lsdaCallsite = callsiteTable[i];
+          BB *endTry = cgFunc->GetBBFromLab2BBMap(lsdaCallsite->csLength.GetEndOffset()->GetLabelIdx());
+          BB *startTry = cgFunc->GetBBFromLab2BBMap(lsdaCallsite->csLength.GetStartOffset()->GetLabelIdx());
+          if (curBB->GetId() >= startTry->GetId() && curBB->GetId() <= endTry->GetId() &&
+              lsdaCallsite->csLandingPad.GetEndOffset() != nullptr) {
+            BB *landingPad = cgFunc->GetBBFromLab2BBMap(lsdaCallsite->csLandingPad.GetEndOffset()->GetLabelIdx());
+            curBB->PushBackEhSuccs(*landingPad);
+            landingPad->PushBackEhPreds(*curBB);
+          }
+        }
+      }
+    }
+  }
+  FindAndMarkUnreachable(*cgFunc);
+}
+
+void CGCFG::CheckCFG() {
+  FOR_ALL_BB(bb, cgFunc) {
+    for (BB *sucBB : bb->GetSuccs()) {
+      bool found = false;
+      for (BB *sucPred : sucBB->GetPreds()) {
+        if (sucPred == bb) {
+          if (found == false) {
+            found = true;
+          } else {
+            LogInfo::MapleLogger() << "dup pred " << sucPred->GetId() << " for sucBB " << sucBB->GetId() << "\n";
+          }
+        }
+      }
+      if (found == false) {
+        LogInfo::MapleLogger() << "non pred for sucBB " << sucBB->GetId() << " for BB " << bb->GetId() << "\n";
+      }
+    }
+  }
+  FOR_ALL_BB(bb, cgFunc) {
+    for (BB *predBB : bb->GetPreds()) {
+      bool found = false;
+      for (BB *predSucc : predBB->GetSuccs()) {
+        if (predSucc == bb) {
+          if (found == false) {
+            found = true;
+          } else {
+            LogInfo::MapleLogger() << "dup succ " << predSucc->GetId() << " for predBB " << predBB->GetId() << "\n";
+          }
+        }
+      }
+      if (found == false) {
+        LogInfo::MapleLogger() << "non succ for predBB " << predBB->GetId() << " for BB " << bb->GetId() << "\n";
+      }
+    }
+  }
+}
+
+void CGCFG::CheckCFGFreq() {
+  auto verifyBBFreq = [this](const BB *bb, uint32 succFreq) {
+    uint32 res = bb->GetFrequency();
+    if ((res != 0 && static_cast<uint32>(abs(static_cast<int>(res - succFreq)) / res > 1.0)) ||
+        (res == 0 && res != succFreq)) {
+      // Not included
+      if (bb->GetSuccs().size() > 1 && bb->GetPreds().size() > 1) {
+        return;
+      }
+      LogInfo::MapleLogger() << cgFunc->GetName() << " curBB: " << bb->GetId() << " freq: "
+                             << bb->GetFrequency() << std::endl;
+      CHECK_FATAL(false, "Verifyfreq failure BB frequency!");
+    }
+  };
+  FOR_ALL_BB(bb, cgFunc) {
+    if (bb->IsUnreachable() || bb->IsCleanup()) {
+      continue;
+    }
+    uint32 res = 0;
+    if (bb->GetSuccs().size() > 1) {
+      for (auto *succBB : bb->GetSuccs()) {
+        res += succBB->GetFrequency();
+        if (succBB->GetPreds().size() > 1) {
+          LogInfo::MapleLogger() << cgFunc->GetName() << " critical edges: curBB: " << bb->GetId() << std::endl;
+          CHECK_FATAL(false, "The CFG has critical edges!");
+        }
+      }
+      verifyBBFreq(bb, res);
+    } else if (bb->GetSuccs().size() == 1) {
+      auto *succBB = bb->GetSuccs().front();
+      if (succBB->GetPreds().size() == 1) {
+        verifyBBFreq(bb, succBB->GetFrequency());
+      } else if (succBB->GetPreds().size() > 1) {
+        for (auto *pred : succBB->GetPreds()) {
+          res += pred->GetFrequency();
+        }
+        verifyBBFreq(succBB, res);
+      }
+    }
+  }
+  LogInfo::MapleLogger() << "Check Frequency for " << cgFunc->GetName() << " success!\n";
+}
+
+InsnVisitor *CGCFG::insnVisitor;
+
+void CGCFG::InitInsnVisitor(CGFunc &func) const {
+  insnVisitor = func.NewInsnModifier();
+}
+
+Insn *CGCFG::CloneInsn(Insn &originalInsn) const {
+  cgFunc->IncTotalNumberOfInstructions();
+  return insnVisitor->CloneInsn(originalInsn);
+}
+
+RegOperand *CGCFG::CreateVregFromReg(const RegOperand &pReg) const {
+  return insnVisitor->CreateVregFromReg(pReg);
+}
+
+/*
+ * return true if:
+ * mergee has only one predecessor which is merger,
+ * or mergee has other comments only predecessors & merger is soloGoto
+ * mergee can't have cfi instruction when postcfgo.
+ */
+bool CGCFG::BBJudge(const BB &first, const BB &second) const {
+  if (first.GetKind() == BB::kBBReturn || second.GetKind() == BB::kBBReturn) {
+    return false;
+  }
+  if (&first == &second) {
+    return false;
+  }
+  if (second.GetPreds().size() == 1 && second.GetPreds().front() == &first) {
+    return true;
+  }
+  for (BB *bb : second.GetPreds()) {
+    if (bb != &first && !AreCommentAllPreds(*bb)) {
+      return false;
+    }
+  }
+  return first.IsSoloGoto();
+}
+
+/*
+ * Check if a given BB mergee can be merged into BB merger.
+ * Returns true if:
+ * 1. mergee has only one predecessor which is merger, or mergee has
+ *   other comments only predecessors.
+ * 2. merge has only one successor which is mergee.
+ * 3. mergee can't have cfi instruction when postcfgo.
+ */
+bool CGCFG::CanMerge(const BB &merger, const BB &mergee) const {
+  if (!BBJudge(merger, mergee)) {
+    return false;
+  }
+  if (mergee.GetFirstInsn() != nullptr && mergee.GetFirstInsn()->IsCfiInsn()) {
+    return false;
+  }
+  return (merger.GetSuccs().size() == 1) && (merger.GetSuccs().front() == &mergee);
+}
+
+/* Check if the given BB contains only comments and all its predecessors are comments */
+bool CGCFG::AreCommentAllPreds(const BB &bb) {
+  if (!bb.IsCommentBB()) {
+    return false;
+  }
+  for (BB *pred : bb.GetPreds()) {
+    if (!AreCommentAllPreds(*pred)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/* Merge sucBB into curBB. */
+void CGCFG::MergeBB(BB &merger, BB &mergee, CGFunc &func) {
+  BB *prevLast = mergee.GetPrev();
+  MergeBB(merger, mergee);
+  if (func.GetLastBB()->GetId() == mergee.GetId()) {
+    func.SetLastBB(*prevLast);
+  }
+  if (mergee.GetKind() == BB::kBBReturn) {
+    for (size_t i = 0; i < func.ExitBBsVecSize(); ++i) {
+      if (func.GetExitBB(i) == &mergee) {
+        func.EraseExitBBsVec(func.GetExitBBsVec().begin() + i);
+      }
+    }
+    func.PushBackExitBBsVec(merger);
+  }
+  /* if mergee is infinite loop */
+  BB *commonExit =  func.GetCommonExitBB();
+  auto exitPredIt = std::find(commonExit->GetPredsBegin(), commonExit->GetPredsEnd(), &mergee);
+  if (exitPredIt != commonExit->GetPredsEnd()) {
+    commonExit->ErasePreds(exitPredIt);
+    commonExit->PushBackPreds(merger);
+  }
+
+  if (mergee.GetKind() == BB::kBBRangeGoto) {
+    func.AddEmitSt(merger.GetId(), *func.GetEmitSt(mergee.GetId()));
+    func.DeleteEmitSt(mergee.GetId());
+  }
+}
+
+void CGCFG::MergeBB(BB &merger, BB &mergee) {
+  if (merger.GetKind() == BB::kBBGoto) {
+    if (!merger.GetLastInsn()->IsBranch()) {
+      CHECK_FATAL(false, "unexpected insn kind");
+    }
+    merger.RemoveInsn(*merger.GetLastInsn());
+  }
+  merger.AppendBBInsns(mergee);
+  if (mergee.GetPrev() != nullptr) {
+    mergee.GetPrev()->SetNext(mergee.GetNext());
+  }
+  if (mergee.GetNext() != nullptr) {
+    mergee.GetNext()->SetPrev(mergee.GetPrev());
+  }
+  merger.RemoveSuccs(mergee);
+  if (!merger.GetEhSuccs().empty()) {
+#if DEBUG
+    for (BB *bb : merger.GetEhSuccs()) {
+      ASSERT((bb != &mergee), "CGCFG::MergeBB: Merging of EH bb");
+    }
+#endif
+  }
+  if (!mergee.GetEhSuccs().empty()) {
+    for (BB *bb : mergee.GetEhSuccs()) {
+      bb->RemoveEhPreds(mergee);
+      bb->PushBackEhPreds(merger);
+      merger.PushBackEhSuccs(*bb);
+    }
+  }
+  for (BB *bb : mergee.GetSuccs()) {
+    bb->RemovePreds(mergee);
+    bb->PushBackPreds(merger);
+    merger.PushBackSuccs(*bb);
+  }
+  merger.SetKind(mergee.GetKind());
+  merger.SetNeedRestoreCfi(mergee.IsNeedRestoreCfi());
+  mergee.SetNext(nullptr);
+  mergee.SetPrev(nullptr);
+  mergee.ClearPreds();
+  mergee.ClearSuccs();
+  mergee.ClearEhPreds();
+  mergee.ClearEhSuccs();
+  mergee.SetFirstInsn(nullptr);
+  mergee.SetLastInsn(nullptr);
+}
+
+/*
+ * Find all reachable BBs by dfs in cgfunc and mark their field<unreachable> false, then all other bbs should be
+ * unreachable.
+ */
+void CGCFG::FindAndMarkUnreachable(CGFunc &func) {
+  BB *firstBB = func.GetFirstBB();
+  std::stack<BB*> toBeAnalyzedBBs;
+  toBeAnalyzedBBs.push(firstBB);
+  std::unordered_set<uint32> instackBBs;
+
+  BB *bb = firstBB;
+  /* set all bb's unreacable to true */
+  while (bb != nullptr) {
+    /* Check if bb is the cleanupBB/switchTableBB/firstBB/lastBB of the function */
+    if (bb->IsCleanup() || InSwitchTable(bb->GetLabIdx(), func) || bb == func.GetFirstBB() || bb == func.GetLastBB()) {
+      toBeAnalyzedBBs.push(bb);
+    } else if (bb->IsLabelTaken() == false) {
+      bb->SetUnreachable(true);
+    }
+    bb = bb->GetNext();
+  }
+
+  /* do a dfs to see which bbs are reachable */
+  while (!toBeAnalyzedBBs.empty()) {
+    bb = toBeAnalyzedBBs.top();
+    toBeAnalyzedBBs.pop();
+    (void)instackBBs.insert(bb->GetId());
+
+    bb->SetUnreachable(false);
+
+    for (BB *succBB : bb->GetSuccs()) {
+      if (instackBBs.count(succBB->GetId()) == 0) {
+        toBeAnalyzedBBs.push(succBB);
+        (void)instackBBs.insert(succBB->GetId());
+      }
+    }
+    for (BB *succBB : bb->GetEhSuccs()) {
+      if (instackBBs.count(succBB->GetId()) == 0) {
+        toBeAnalyzedBBs.push(succBB);
+        (void)instackBBs.insert(succBB->GetId());
+      }
+    }
+  }
+  FOR_ALL_BB(tmpBB, &func) {
+    for (MapleList<BB*>::iterator predIt = tmpBB->GetPredsBegin(); predIt != tmpBB->GetPredsEnd(); ++predIt) {
+      if ((*predIt)->IsUnreachable()) {
+        tmpBB->ErasePreds(predIt);
+      }
+    }
+    for (MapleList<BB*>::iterator predIt = tmpBB->GetEhPredsBegin(); predIt != tmpBB->GetEhPredsEnd(); ++predIt) {
+      if ((*predIt)->IsUnreachable()) {
+        tmpBB->ErasePreds(predIt);
+      }
+    }
+  }
+}
+
+/*
+ * Theoretically, every time you remove from a bb's preds, you should consider invoking this method.
+ *
+ * @param bb
+ * @param func
+ */
+void CGCFG::FlushUnReachableStatusAndRemoveRelations(BB &bb, const CGFunc &func) const {
+  bool isFirstBBInfunc = (&bb == func.GetFirstBB());
+  bool isLastBBInfunc = (&bb == func.GetLastBB());
+  /* Check if bb is the cleanupBB/switchTableBB/firstBB/lastBB of the function */
+  if (bb.IsCleanup() || InSwitchTable(bb.GetLabIdx(), func) || isFirstBBInfunc || isLastBBInfunc) {
+    return;
+  }
+  std::stack<BB*> toBeAnalyzedBBs;
+  toBeAnalyzedBBs.push(&bb);
+  std::set<uint32> instackBBs;
+  BB *it = nullptr;
+  while (!toBeAnalyzedBBs.empty()) {
+    it = toBeAnalyzedBBs.top();
+    (void)instackBBs.insert(it->GetId());
+    toBeAnalyzedBBs.pop();
+    /* Check if bb is the first or the last BB of the function */
+    isFirstBBInfunc = (it == func.GetFirstBB());
+    isLastBBInfunc = (it == func.GetLastBB());
+    bool needFlush = !isFirstBBInfunc && !isLastBBInfunc && !it->IsCleanup() &&
+                     (it->GetPreds().empty() || (it->GetPreds().size() == 1 && it->GetEhPreds().front() == it)) &&
+                     it->GetEhPreds().empty() &&
+                     !InSwitchTable(it->GetLabIdx(), *cgFunc) &&
+                     !cgFunc->IsExitBB(*it) &&
+                     (it->IsLabelTaken() == false);
+    if (!needFlush) {
+      continue;
+    }
+    it->SetUnreachable(true);
+    it->SetFirstInsn(nullptr);
+    it->SetLastInsn(nullptr);
+    for (BB *succ : it->GetSuccs()) {
+      if (instackBBs.count(succ->GetId()) == 0) {
+        toBeAnalyzedBBs.push(succ);
+        (void)instackBBs.insert(succ->GetId());
+      }
+      succ->RemovePreds(*it);
+      succ->RemoveEhPreds(*it);
+    }
+    it->ClearSuccs();
+    for (BB *succ : it->GetEhSuccs()) {
+      if (instackBBs.count(succ->GetId()) == 0) {
+        toBeAnalyzedBBs.push(succ);
+        (void)instackBBs.insert(succ->GetId());
+      }
+      succ->RemoveEhPreds(*it);
+      succ->RemovePreds(*it);
+    }
+    it->ClearEhSuccs();
+  }
+}
+
+void CGCFG::RemoveBB(BB &curBB, bool isGotoIf) const {
+  BB *sucBB = CGCFG::GetTargetSuc(curBB, false, isGotoIf);
+  if (sucBB != nullptr) {
+    sucBB->RemovePreds(curBB);
+  }
+  BB *fallthruSuc = nullptr;
+  if (isGotoIf) {
+    for (BB *succ : curBB.GetSuccs()) {
+      if (succ == sucBB) {
+        continue;
+      }
+      fallthruSuc = succ;
+      break;
+    }
+    ASSERT(fallthruSuc == curBB.GetNext(), "fallthru succ should be its next bb.");
+    if (fallthruSuc != nullptr) {
+      fallthruSuc->RemovePreds(curBB);
+    }
+  }
+  for (BB *preBB : curBB.GetPreds()) {
+    if (preBB->GetKind() == BB::kBBIgoto) {
+      sucBB->PushBackPreds(curBB);
+      return;
+    }
+    /*
+     * If curBB is the target of its predecessor, change
+     * the jump target.
+     */
+    if (&curBB == GetTargetSuc(*preBB, true, isGotoIf)) {
+      LabelIdx targetLabel;
+      if (curBB.GetNext()->GetLabIdx() == 0) {
+        targetLabel = insnVisitor->GetCGFunc()->CreateLabel();
+        curBB.GetNext()->SetLabIdx(targetLabel);
+      } else {
+        targetLabel = curBB.GetNext()->GetLabIdx();
+      }
+      insnVisitor->ModifyJumpTarget(targetLabel, *preBB);
+    }
+    if (fallthruSuc != nullptr && !fallthruSuc->IsPredecessor(*preBB)) {
+      preBB->PushBackSuccs(*fallthruSuc);
+      fallthruSuc->PushBackPreds(*preBB);
+    }
+    if (sucBB != nullptr && !sucBB->IsPredecessor(*preBB)) {
+      preBB->PushBackSuccs(*sucBB);
+      sucBB->PushBackPreds(*preBB);
+    }
+    preBB->RemoveSuccs(curBB);
+  }
+
+  for (BB *ehSucc : curBB.GetEhSuccs()) {
+    ehSucc->RemoveEhPreds(curBB);
+  }
+  for (BB *ehPred : curBB.GetEhPreds()) {
+    ehPred->RemoveEhSuccs(curBB);
+  }
+  if (curBB.GetNext() != nullptr) {
+    cgFunc->GetCommonExitBB()->RemovePreds(curBB);
+    curBB.GetNext()->RemovePreds(curBB);
+    curBB.GetNext()->SetPrev(curBB.GetPrev());
+  } else {
+    cgFunc->SetLastBB(*curBB.GetPrev());
+  }
+  curBB.GetPrev()->SetNext(curBB.GetNext());
+  cgFunc->ClearBBInVec(curBB.GetId());
+  /* remove callsite */
+  EHFunc *ehFunc = cgFunc->GetEHFunc();
+  /* only java try has ehFunc->GetLSDACallSiteTable */
+  if (ehFunc != nullptr && ehFunc->GetLSDACallSiteTable() != nullptr) {
+    ehFunc->GetLSDACallSiteTable()->RemoveCallSite(curBB);
+  }
+}
+
+void CGCFG::RetargetJump(BB &srcBB, BB &targetBB) const {
+  insnVisitor->ModifyJumpTarget(srcBB, targetBB);
+}
+
+BB *CGCFG::GetTargetSuc(BB &curBB, bool branchOnly, bool isGotoIf) {
+  switch (curBB.GetKind()) {
+    case BB::kBBGoto:
+    case BB::kBBIntrinsic:
+    case BB::kBBIf: {
+      const Insn* origLastInsn = curBB.GetLastMachineInsn();
+      if (isGotoIf && (curBB.GetPrev() != nullptr) &&
+          (curBB.GetKind() == BB::kBBGoto || curBB.GetKind() == BB::kBBIf) &&
+          (curBB.GetPrev()->GetKind() == BB::kBBGoto || curBB.GetPrev()->GetKind() == BB::kBBIf)) {
+        origLastInsn = curBB.GetPrev()->GetLastMachineInsn();
+      }
+      LabelIdx label = insnVisitor->GetJumpLabel(*origLastInsn);
+      for (BB *bb : curBB.GetSuccs()) {
+        if (bb->GetLabIdx() == label) {
+          return bb;
+        }
+      }
+      break;
+    }
+    case BB::kBBIgoto: {
+      for (Insn *insn = curBB.GetLastInsn(); insn != nullptr; insn = insn->GetPrev()) {
+#if TARGAARCH64
+        if (insn->GetMachineOpcode() == MOP_adrp_label) {
+          int64 label = static_cast<ImmOperand&>(insn->GetOperand(1)).GetValue();
+          for (BB *bb : curBB.GetSuccs()) {
+            if (bb->GetLabIdx() == static_cast<LabelIdx>(label)) {
+              return bb;
+            }
+          }
+        }
+#endif
+      }
+      /* can also be a MOP_xbr. */
+      return nullptr;
+    }
+    case BB::kBBFallthru: {
+      return (branchOnly ? nullptr : curBB.GetNext());
+    }
+    case BB::kBBThrow:
+      return nullptr;
+    default:
+      return nullptr;
+  }
+  return nullptr;
+}
+
+bool CGCFG::InLSDA(LabelIdx label, const EHFunc *ehFunc) {
+  /* the function have no exception handle module */
+  if (ehFunc == nullptr) {
+    return false;
+  }
+
+  if ((label == 0) || ehFunc->GetLSDACallSiteTable() == nullptr) {
+    return false;
+  }
+  if (label == ehFunc->GetLSDACallSiteTable()->GetCSTable().GetEndOffset()->GetLabelIdx() ||
+      label == ehFunc->GetLSDACallSiteTable()->GetCSTable().GetStartOffset()->GetLabelIdx()) {
+    return true;
+  }
+  return ehFunc->GetLSDACallSiteTable()->InCallSiteTable(label);
+}
+
+bool CGCFG::InSwitchTable(LabelIdx label, const CGFunc &func) {
+  if (label == 0) {
+    return false;
+  }
+  return func.InSwitchTable(label);
+}
+
+bool CGCFG::IsCompareAndBranchInsn(const Insn &insn) const {
+  return insnVisitor->IsCompareAndBranchInsn(insn);
+}
+
+bool CGCFG::IsAddOrSubInsn(const Insn &insn) const {
+  return insnVisitor->IsAddOrSubInsn(insn);
+}
+
+Insn *CGCFG::FindLastCondBrInsn(BB &bb) const {
+  if (bb.GetKind() != BB::kBBIf) {
+    return nullptr;
+  }
+  FOR_BB_INSNS_REV(insn, (&bb)) {
+    if (insn->IsBranch()) {
+      return insn;
+    }
+  }
+  return nullptr;
+}
+
+void CGCFG::MarkLabelTakenBB() const {
+  if (cgFunc->GetMirModule().GetSrcLang() != kSrcLangC) {
+    return;
+  }
+  for (BB *bb = cgFunc->GetFirstBB(); bb != nullptr; bb = bb->GetNext()) {
+    if (cgFunc->GetFunction().GetLabelTab()->GetAddrTakenLabels().find(bb->GetLabIdx()) !=
+        cgFunc->GetFunction().GetLabelTab()->GetAddrTakenLabels().end()) {
+      cgFunc->SetHasTakenLabel();
+      bb->SetLabelTaken();
+    }
+  }
+}
+
+/*
+ * analyse the CFG to find the BBs that are not reachable from function entries
+ * and delete them
+ */
+void CGCFG::UnreachCodeAnalysis() const {
+  if (cgFunc->GetMirModule().GetSrcLang() == kSrcLangC &&
+      (cgFunc->HasTakenLabel() ||
+      (cgFunc->GetEHFunc() && cgFunc->GetEHFunc()->GetLSDAHeader()))) {
+    return;
+  }
+  /*
+   * Find all reachable BBs by dfs in cgfunc and mark their field<unreachable> false,
+   * then all other bbs should be unreachable.
+   */
+  BB *firstBB = cgFunc->GetFirstBB();
+  std::forward_list<BB*> toBeAnalyzedBBs;
+  toBeAnalyzedBBs.push_front(firstBB);
+  std::set<BB*, BBIdCmp> unreachBBs;
+
+  BB *bb = firstBB;
+  /* set all bb's unreacable to true */
+  while (bb != nullptr) {
+    /* Check if bb is the firstBB/cleanupBB/returnBB/lastBB of the function */
+    if (bb->IsCleanup() || InSwitchTable(bb->GetLabIdx(), *cgFunc) ||
+        bb == cgFunc->GetFirstBB() || bb == cgFunc->GetLastBB() ||
+        (bb->GetKind() == BB::kBBReturn && !cgFunc->GetMirModule().IsCModule())) {
+      toBeAnalyzedBBs.push_front(bb);
+    } else {
+      (void)unreachBBs.insert(bb);
+    }
+    if (bb->IsLabelTaken() == false) {
+      bb->SetUnreachable(true);
+    }
+    bb = bb->GetNext();
+  }
+
+  /* do a dfs to see which bbs are reachable */
+  while (!toBeAnalyzedBBs.empty()) {
+    bb = toBeAnalyzedBBs.front();
+    toBeAnalyzedBBs.pop_front();
+    if (!bb->IsUnreachable()) {
+      continue;
+    }
+    bb->SetUnreachable(false);
+    for (BB *succBB : bb->GetSuccs()) {
+      toBeAnalyzedBBs.push_front(succBB);
+      unreachBBs.erase(succBB);
+    }
+    for (BB *succBB : bb->GetEhSuccs()) {
+      toBeAnalyzedBBs.push_front(succBB);
+      unreachBBs.erase(succBB);
+    }
+  }
+
+  /* remove unreachable bb */
+  std::set<BB*, BBIdCmp>::iterator it;
+  for (it = unreachBBs.begin(); it != unreachBBs.end(); it++) {
+    BB *unreachBB = *it;
+    ASSERT(unreachBB != nullptr, "unreachBB must not be nullptr");
+    if (cgFunc->IsExitBB(*unreachBB) && !cgFunc->GetMirModule().IsCModule()) {
+      unreachBB->SetUnreachable(false);
+    }
+    EHFunc *ehFunc = cgFunc->GetEHFunc();
+    /* if unreachBB InLSDA ,replace unreachBB's label with nextReachableBB before remove it. */
+    if (ehFunc != nullptr && ehFunc->NeedFullLSDA() &&
+        cgFunc->GetTheCFG()->InLSDA(unreachBB->GetLabIdx(), ehFunc)) {
+      /* find next reachable BB */
+      BB* nextReachableBB = nullptr;
+      for (BB* curBB = unreachBB; curBB != nullptr; curBB = curBB->GetNext()) {
+        if (!curBB->IsUnreachable()) {
+          nextReachableBB = curBB;
+          break;
+        }
+      }
+      CHECK_FATAL(nextReachableBB != nullptr, "nextReachableBB not be nullptr");
+      if (nextReachableBB->GetLabIdx() == 0) {
+        LabelIdx labelIdx = cgFunc->CreateLabel();
+        nextReachableBB->AddLabel(labelIdx);
+        cgFunc->SetLab2BBMap(labelIdx, *nextReachableBB);
+      }
+
+      ehFunc->GetLSDACallSiteTable()->UpdateCallSite(*unreachBB, *nextReachableBB);
+    }
+
+    unreachBB->GetPrev()->SetNext(unreachBB->GetNext());
+    unreachBB->GetNext()->SetPrev(unreachBB->GetPrev());
+
+    for (BB *sucBB : unreachBB->GetSuccs()) {
+      sucBB->RemovePreds(*unreachBB);
+    }
+    for (BB *ehSucBB : unreachBB->GetEhSuccs()) {
+      ehSucBB->RemoveEhPreds(*unreachBB);
+    }
+
+    unreachBB->ClearSuccs();
+    unreachBB->ClearEhSuccs();
+
+    cgFunc->ClearBBInVec(unreachBB->GetId());
+
+    /* Clear insns in GOT Map. */
+    cgFunc->ClearUnreachableGotInfos(*unreachBB);
+    cgFunc->ClearUnreachableConstInfos(*unreachBB);
+  }
+}
+
+void CGCFG::FindWillExitBBs(BB *bb, std::set<BB*, BBIdCmp> *visitedBBs) {
+  if (visitedBBs->count(bb) != 0) {
+    return;
+  }
+  visitedBBs->insert(bb);
+  for (BB *predbb : bb->GetPreds()) {
+    FindWillExitBBs(predbb, visitedBBs);
+  }
+}
+
+/*
+ * analyse the CFG to find the BBs that will not reach any function exit; these
+ * are BBs inside infinite loops; mark their wontExit flag and create
+ * artificial edges from them to commonExitBB
+ */
+void CGCFG::WontExitAnalysis() {
+  std::set<BB*, BBIdCmp> visitedBBs;
+  FindWillExitBBs(cgFunc->GetCommonExitBB(), &visitedBBs);
+  BB *bb = cgFunc->GetFirstBB();
+  while (bb != nullptr) {
+    if (visitedBBs.count(bb) == 0) {
+      bb->SetWontExit(true);
+      if (bb->GetKind() == BB::kBBGoto || bb->GetKind() == BB::kBBThrow) {
+        // make this bb a predecessor of commonExitBB
+        cgFunc->GetCommonExitBB()->PushBackPreds(*bb);
+      }
+    }
+    bb = bb->GetNext();
+  }
+}
+
+BB *CGCFG::FindLastRetBB() {
+  FOR_ALL_BB_REV(bb, cgFunc) {
+    if (bb->GetKind() == BB::kBBReturn) {
+      return bb;
+    }
+  }
+  return nullptr;
+}
+
+void CGCFG::UpdatePredsSuccsAfterSplit(BB &pred, BB &succ, BB &newBB) const {
+  /* connext newBB -> succ */
+  for (auto it = succ.GetPredsBegin(); it != succ.GetPredsEnd(); ++it) {
+    if (*it == &pred) {
+      auto origIt = it;
+      succ.ErasePreds(it);
+      if (origIt != succ.GetPredsBegin()) {
+        --origIt;
+        succ.InsertPred(origIt, newBB);
+      } else {
+        succ.PushFrontPreds(newBB);
+      }
+      break;
+    }
+  }
+  newBB.PushBackSuccs(succ);
+
+  /* connext pred -> newBB */
+  for (auto it = pred.GetSuccsBegin(); it != pred.GetSuccsEnd(); ++it) {
+    if (*it == &succ) {
+      auto origIt = it;
+      pred.EraseSuccs(it);
+      if (origIt != succ.GetSuccsBegin()) {
+        --origIt;
+        pred.InsertSucc(origIt, newBB);
+      } else {
+        pred.PushFrontSuccs(newBB);
+      }
+      break;
+    }
+  }
+  newBB.PushBackPreds(pred);
+
+  /* maintain eh info */
+  for (auto it = pred.GetEhSuccs().begin(); it != pred.GetEhSuccs().end(); ++it) {
+    newBB.PushBackEhSuccs(**it);
+  }
+  for (auto it = pred.GetEhPredsBegin(); it != pred.GetEhPredsEnd(); ++it) {
+    newBB.PushBackEhPreds(**it);
+  }
+
+  /* update phi */
+  for (auto phiInsnIt : succ.GetPhiInsns()) {
+    auto &phiList = static_cast<PhiOperand&>(phiInsnIt.second->GetOperand(kInsnSecondOpnd));
+    for (auto phiOpndIt : phiList.GetOperands()) {
+      uint32 fBBId = phiOpndIt.first;
+      ASSERT(fBBId != 0, "GetFromBBID = 0");
+      BB *predBB = cgFunc->GetBBFromID(fBBId);
+      if (predBB == &pred) {
+        phiList.UpdateOpnd(fBBId, newBB.GetId(), *phiOpndIt.second);
+        break;
+      }
+    }
+  }
+}
+
+#if TARGAARCH64
+BB *CGCFG::BreakCriticalEdge(BB &pred, BB &succ) {
+  LabelIdx newLblIdx = cgFunc->CreateLabel();
+  BB *newBB = cgFunc->CreateNewBB(newLblIdx, false, BB::kBBGoto, pred.GetFrequency());
+  newBB->SetCritical(true);
+  bool isFallThru = pred.GetNext() == &succ;
+  /* set prev, next */
+  if (isFallThru) {
+    BB *origNext = pred.GetNext();
+    origNext->SetPrev(newBB);
+    newBB->SetNext(origNext);
+    pred.SetNext(newBB);
+    newBB->SetPrev(&pred);
+    newBB->SetKind(BB::kBBFallthru);
+  } else {
+    BB *exitBB = cgFunc->GetExitBBsVec().size() == 0 ? nullptr : cgFunc->GetExitBB(0);
+    if (exitBB == nullptr || exitBB->IsUnreachable()) {
+      cgFunc->GetLastBB()->AppendBB(*newBB);
+      cgFunc->SetLastBB(*newBB);
+    } else {
+      exitBB->AppendBB(*newBB);
+      if (cgFunc->GetLastBB() == exitBB) {
+        cgFunc->SetLastBB(*newBB);
+      }
+    }
+    newBB->AppendInsn(
+        cgFunc->GetInsnBuilder()->BuildInsn(MOP_xuncond, cgFunc->GetOrCreateLabelOperand(succ.GetLabIdx())));
+  }
+
+  /* update offset if succ is goto target */
+  if (pred.GetKind() == BB::kBBIf) {
+    Insn *brInsn = FindLastCondBrInsn(pred);
+    ASSERT(brInsn != nullptr, "null ptr check");
+    LabelOperand &brTarget = static_cast<LabelOperand&>(brInsn->GetOperand(AArch64isa::GetJumpTargetIdx(*brInsn)));
+    if (brTarget.GetLabelIndex() == succ.GetLabIdx()) {
+      brInsn->SetOperand(AArch64isa::GetJumpTargetIdx(*brInsn), cgFunc->GetOrCreateLabelOperand(newLblIdx));
+    }
+  } else if (pred.GetKind() == BB::kBBRangeGoto) {
+    const MapleVector<LabelIdx> &labelVec = pred.GetRangeGotoLabelVec();
+    for (size_t i = 0; i < labelVec.size(); ++i) {
+      if (labelVec[i] == succ.GetLabIdx()) {
+        /* single edge for multi jump target, so have to replace all. */
+        pred.SetRangeGotoLabel(i, newLblIdx);
+      }
+    }
+    cgFunc->UpdateEmitSt(pred, succ.GetLabIdx(), newLblIdx);
+  } else {
+    ASSERT(0, "unexpeced bb kind in BreakCriticalEdge");
+  }
+
+  /* update pred, succ */
+  UpdatePredsSuccsAfterSplit(pred, succ, *newBB);
+  return newBB;
+}
+
+void CGCFG::ReverseCriticalEdge(BB &cbb) {
+  CHECK_FATAL(cbb.GetPreds().size() == 1, "critical edge bb has more than 1 preds");
+  CHECK_FATAL(cbb.GetSuccs().size() == 1, "critical edge bb has more than 1 succs");
+
+  BB *pred = *cbb.GetPreds().begin();
+  BB *succ = *cbb.GetSuccs().begin();
+
+  if (pred->GetKind() == BB::kBBIf) {
+    Insn *brInsn = FindLastCondBrInsn(*pred);
+    ASSERT(brInsn != nullptr, "null ptr check");
+    LabelOperand &brTarget = static_cast<LabelOperand&>(brInsn->GetOperand(AArch64isa::GetJumpTargetIdx(*brInsn)));
+    if (brTarget.GetLabelIndex() == cbb.GetLabIdx()) {
+      CHECK_FATAL(succ->GetLabIdx() != MIRLabelTable::GetDummyLabel(), "unexpect label");
+      brInsn->SetOperand(AArch64isa::GetJumpTargetIdx(*brInsn), cgFunc->GetOrCreateLabelOperand(succ->GetLabIdx()));
+    } else {
+      CHECK_FATAL(false, "pred of critical edge bb do not goto cbb");
+    }
+  } else if (pred->GetKind() == BB::kBBRangeGoto) {
+    const MapleVector<LabelIdx> &labelVec = pred->GetRangeGotoLabelVec();
+    uint32 index = 0;
+    CHECK_FATAL(succ->GetLabIdx() != MIRLabelTable::GetDummyLabel(), "unexpect label");
+    for (auto label: labelVec) {
+      /* single edge for multi jump target, so have to replace all. */
+      if (label == cbb.GetLabIdx()) {
+        pred->SetRangeGotoLabel(index, succ->GetLabIdx());
+      }
+      index++;
+    }
+    MIRSymbol *st = cgFunc->GetEmitSt(pred->GetId());
+    MIRAggConst *arrayConst = safe_cast<MIRAggConst>(st->GetKonst());
+    MIRType *etype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_a64));
+    MIRConst *mirConst = cgFunc->GetMemoryPool()->New<MIRLblConst>(succ->GetLabIdx(), cgFunc->GetFunction().GetPuidx(),
+        *etype);
+    for (size_t i = 0; i < arrayConst->GetConstVec().size(); ++i) {
+      CHECK_FATAL(arrayConst->GetConstVecItem(i)->GetKind() == kConstLblConst, "not a kConstLblConst");
+      MIRLblConst *lblConst = safe_cast<MIRLblConst>(arrayConst->GetConstVecItem(i));
+      if (cbb.GetLabIdx() == lblConst->GetValue()) {
+        arrayConst->SetConstVecItem(i, *mirConst);
+      }
+    }
+  } else {
+    ASSERT(0, "unexpeced bb kind in BreakCriticalEdge");
+  }
+
+  pred->RemoveSuccs(cbb);
+  pred->PushBackSuccs(*succ);
+  succ->RemovePreds(cbb);
+  succ->PushBackPreds(*pred);
+}
+#endif
+
+bool CgHandleCFG::PhaseRun(maplebe::CGFunc &f) {
+  CGCFG *cfg = f.GetMemoryPool()->New<CGCFG>(f);
+  f.SetTheCFG(cfg);
+  /* build control flow graph */
+  f.GetTheCFG()->BuildCFG();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgHandleCFG, handlecfg)
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cg_critical_edge.cpp b/src/mapleall/maple_be/src/cg/cg_critical_edge.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..37b2226e6567bc64353e4dadc77f9251dbae1f1e
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_critical_edge.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_critical_edge.h"
+#include "cg_ssa.h"
+
+namespace maplebe {
+void CriticalEdge::SplitCriticalEdges() {
+  for (auto it = criticalEdges.begin(); it != criticalEdges.end(); ++it) {
+    BB *newBB = cgFunc->GetTheCFG()->BreakCriticalEdge(*((*it).first), *((*it).second));
+    (void)newBBcreated.emplace(newBB->GetId());
+  }
+}
+
+void CriticalEdge::CollectCriticalEdges() {
+  constexpr int multiPredsNum = 2;
+  FOR_ALL_BB(bb, cgFunc) {
+    const auto &preds = bb->GetPreds();
+    if (preds.size() < multiPredsNum) {
+      continue;
+    }
+    // current BB is a merge
+    for (BB *pred : preds) {
+      if (pred->GetKind() == BB::kBBGoto || pred->GetKind() == BB::kBBIgoto) {
+        continue;
+      }
+      if (pred->GetSuccs().size() > 1) {
+        // pred has more than one succ
+        criticalEdges.push_back(std::make_pair(pred, bb));
+      }
+    }
+  }
+}
+
+bool CgCriticalEdge::PhaseRun(maplebe::CGFunc &f) {
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel2 && f.NumBBs() < kBBLimit) {
+    MemPool *memPool = GetPhaseMemPool();
+    CriticalEdge *split = memPool->New<CriticalEdge>(f, *memPool);
+    f.GetTheCFG()->InitInsnVisitor(f);
+    split->CollectCriticalEdges();
+    split->SplitCriticalEdges();
+  }
+  return false;
+}
+
+void CgCriticalEdge::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddPreserved<CgSSAConstruct>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgCriticalEdge, cgsplitcriticaledge)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cg_dce.cpp b/src/mapleall/maple_be/src/cg/cg_dce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..658f69c368f8fadf0b7f2d2bdc36cdb4529324bb
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_dce.cpp
@@ -0,0 +1,45 @@
+/*
+* Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+    * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+#include "cg_dce.h"
+#include "cg.h"
+namespace maplebe {
+void CGDce::DoDce() {
+  bool tryDceAgain = false;
+  do {
+    tryDceAgain = false;
+    for (auto &ssaIt : GetSSAInfo()->GetAllSSAOperands()) {
+      if (ssaIt.second != nullptr && !ssaIt.second->IsDeleted()) {
+        if (RemoveUnuseDef(*ssaIt.second)) {
+          tryDceAgain = true;
+        }
+      }
+    }
+  } while (tryDceAgain);
+}
+
+bool CgDce::PhaseRun(maplebe::CGFunc &f) {
+  CGSSAInfo *ssaInfo = GET_ANALYSIS(CgSSAConstruct, f);
+  CGDce *cgDce = f.GetCG()->CreateCGDce(*GetPhaseMemPool(), f, *ssaInfo);
+  cgDce->DoDce();
+  return false;
+}
+
+void CgDce::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgSSAConstruct>();
+  aDep.AddPreserved<CgSSAConstruct>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgDce, cgdeadcodeelimination)
+}
+
diff --git a/src/mapleall/maple_be/src/cg/cg_dominance.cpp b/src/mapleall/maple_be/src/cg/cg_dominance.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..468205daf219723eb2826ef7ebf30611c02beb65
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_dominance.cpp
@@ -0,0 +1,545 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_dominance.h"
+#include <set>
+#include "cg_option.h"
+#include "cgfunc.h"
+
+/*
+ * This phase build dominance
+ */
+namespace maplebe {
+constexpr uint32 kBBVectorInitialSize = 2;
+void DomAnalysis::PostOrderWalk(const BB &bb, int32 &pid, MapleVector<bool> &visitedMap) {
+  ASSERT(bb.GetId() < visitedMap.size(), "index out of range in Dominance::PostOrderWalk");
+  if (visitedMap[bb.GetId()]) {
+    return;
+  }
+  visitedMap[bb.GetId()] = true;
+  for (const BB *suc : bb.GetSuccs()) {
+    PostOrderWalk(*suc, pid, visitedMap);
+  }
+  ASSERT(bb.GetId() < postOrderIDVec.size(), "index out of range in Dominance::PostOrderWalk");
+  postOrderIDVec[bb.GetId()] = pid++;
+}
+
+void DomAnalysis::GenPostOrderID() {
+  ASSERT(!bbVec.empty(), "size to be allocated is 0");
+  MapleVector<bool> visitedMap(bbVec.size() + 1, false, cgFunc.GetFuncScopeAllocator()->Adapter());
+  int32 postOrderID = 0;
+  PostOrderWalk(commonEntryBB, postOrderID, visitedMap);
+  // initialize reversePostOrder
+  int32 maxPostOrderID = postOrderID - 1;
+  reversePostOrder.resize(static_cast<uint32>(maxPostOrderID + 1));
+  for (size_t i = 0; i < postOrderIDVec.size(); ++i) {
+    int32 postOrderNo = postOrderIDVec[i];
+    if (postOrderNo == -1) {
+      continue;
+    }
+    reversePostOrder[static_cast<uint32>(maxPostOrderID - postOrderNo)] = bbVec[i];
+  }
+}
+
+BB *DomAnalysis::Intersect(BB &bb1, const BB &bb2) {
+  auto *ptrBB1 = &bb1;
+  auto *ptrBB2 = &bb2;
+  while (ptrBB1 != ptrBB2) {
+    while (postOrderIDVec[ptrBB1->GetId()] < postOrderIDVec[ptrBB2->GetId()]) {
+      ptrBB1 = GetDom(ptrBB1->GetId());
+    }
+    while (postOrderIDVec[ptrBB2->GetId()] < postOrderIDVec[ptrBB1->GetId()]) {
+      ptrBB2 = GetDom(ptrBB2->GetId());
+    }
+  }
+  return ptrBB1;
+}
+
+bool DominanceBase::CommonEntryBBIsPred(const BB &bb) const {
+  for (const BB *suc : commonEntryBB.GetSuccs()) {
+    if (suc == &bb) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Figure 3 in "A Simple, Fast Dominance Algorithm" by Keith Cooper et al.
+void DomAnalysis::ComputeDominance() {
+  SetDom(commonEntryBB.GetId(), &commonEntryBB);
+  bool changed;
+  do {
+    changed = false;
+    for (size_t i = 1; i < reversePostOrder.size(); ++i) {
+      BB *bb = reversePostOrder[i];
+      if (bb == nullptr) {
+        continue;
+      }
+      BB *pre = nullptr;
+      auto it = bb->GetPredsBegin();
+      if (CommonEntryBBIsPred(*bb) || bb->GetPreds().empty()) {
+        pre = &commonEntryBB;
+      } else {
+        pre = *it;
+      }
+      ++it;
+      while ((GetDom(pre->GetId()) == nullptr || pre == bb) && it != bb->GetPredsEnd()) {
+        pre = *it;
+        ++it;
+      }
+      BB *newIDom = pre;
+      for (; it != bb->GetPredsEnd(); ++it) {
+        pre = *it;
+        if (GetDom(pre->GetId()) != nullptr && pre != bb) {
+          newIDom = Intersect(*pre, *newIDom);
+        }
+      }
+      if (GetDom(bb->GetId()) != newIDom) {
+        SetDom(bb->GetId(), newIDom);
+        changed = true;
+      }
+    }
+  } while (changed);
+}
+
+// Figure 5 in "A Simple, Fast Dominance Algorithm" by Keith Cooper et al.
+void DomAnalysis::ComputeDomFrontiers() {
+  for (const BB *bb : bbVec) {
+    if (bb == nullptr || bb == &commonExitBB) {
+      continue;
+    }
+    if (bb->GetPreds().size() < kBBVectorInitialSize) {
+      continue;
+    }
+    for (BB *pre : bb->GetPreds()) {
+      BB *runner = pre;
+      while (runner != nullptr && runner != GetDom(bb->GetId()) && runner != &commonEntryBB) {
+        if (!HasDomFrontier(runner->GetId(), bb->GetId())) {
+          domFrontier[runner->GetId()].push_back(bb->GetId());
+        }
+        runner = GetDom(runner->GetId());
+      }
+    }
+  }
+  // check entry bb's predBB, such as :
+  // bb1 is commonEntryBB, bb2 is entryBB, bb2 is domFrontier of bb3 and bb7.
+  //       1
+  //       |
+  //       2 <-
+  //      /   |
+  //     3    |
+  //    / \   |
+  //   4   7---
+  //  / \  ^
+  // |   | |
+  // 5-->6--
+  for (BB *succ : commonEntryBB.GetSuccs()) {
+    if (succ->GetPreds().size() != 1) { // Only deal with one pred bb.
+      continue;
+    }
+    for (BB *pre : succ->GetPreds()) {
+      BB *runner = pre;
+      while (runner != GetDom(succ->GetId()) && runner != &commonEntryBB && runner != succ) {
+        if (!HasDomFrontier(runner->GetId(), succ->GetId())) {
+          domFrontier[runner->GetId()].push_back(succ->GetId());
+        }
+        runner = GetDom(runner->GetId());
+      }
+    }
+  }
+}
+
+void DomAnalysis::ComputeDomChildren() {
+  for (auto *bb : reversePostOrder) {
+    if (bb == nullptr || GetDom(bb->GetId()) == nullptr) {
+      continue;
+    }
+    BB *parent = GetDom(bb->GetId());
+    if (parent == bb) {
+      continue;
+    }
+    domChildren[parent->GetId()].push_back(bb->GetId());
+  }
+}
+
+// bbidMarker indicates that the iterDomFrontier results for bbid < bbidMarker
+// have been computed
+void DomAnalysis::GetIterDomFrontier(const BB *bb, MapleSet<uint32> *dfset, uint32 bbidMarker,
+                                     std::vector<bool> &visitedMap) {
+  if (visitedMap[bb->GetId()]) {
+    return;
+  }
+  visitedMap[bb->GetId()] = true;
+  for (uint32 frontierbbid : domFrontier[bb->GetId()]) {
+    (void)dfset->insert(frontierbbid);
+    if (frontierbbid < bbidMarker) {  // union with its computed result
+      dfset->insert(iterDomFrontier[frontierbbid].begin(), iterDomFrontier[frontierbbid].end());
+    } else {  // recursive call
+      BB *frontierbb = bbVec[frontierbbid];
+      GetIterDomFrontier(frontierbb, dfset, bbidMarker, visitedMap);
+    }
+  }
+}
+
+void DomAnalysis::ComputeIterDomFrontiers() {
+  for (BB *bb : bbVec) {
+    if (bb == nullptr || bb == &commonExitBB) {
+      continue;
+    }
+    std::vector<bool> visitedMap(bbVec.size(), false);
+    GetIterDomFrontier(bb, &iterDomFrontier[bb->GetId()], bb->GetId(), visitedMap);
+  }
+}
+
+
+uint32 DomAnalysis::ComputeDtPreorder(const BB &bb, uint32 &num) {
+  ASSERT(num < dtPreOrder.size(), "index out of range in Dominance::ComputeDtPreorder");
+  dtPreOrder[num] = bb.GetId();
+  dtDfn[bb.GetId()] = num;
+  uint32 maxDtDfnOut = num;
+  ++num;
+
+  for (uint32 k : domChildren[bb.GetId()]) {
+    maxDtDfnOut = ComputeDtPreorder(*bbVec[k], num);
+  }
+
+  dtDfnOut[bb.GetId()] = maxDtDfnOut;
+  return maxDtDfnOut;
+}
+
+// true if b1 dominates b2
+bool DomAnalysis::Dominate(const BB &bb1, const BB &bb2) {
+  return dtDfn[bb1.GetId()] <= dtDfn[bb2.GetId()] && dtDfnOut[bb1.GetId()] >= dtDfnOut[bb2.GetId()];
+}
+
+void DomAnalysis::Compute() {
+  GenPostOrderID();
+  ComputeDominance();
+  ComputeDomFrontiers();
+  ComputeDomChildren();
+  ComputeIterDomFrontiers();
+  uint32 num = 0;
+  (void)ComputeDtPreorder(*cgFunc.GetFirstBB(), num);
+  GetDtPreOrder().resize(num);
+}
+
+void DomAnalysis::Dump() {
+  for (BB *bb : reversePostOrder) {
+    LogInfo::MapleLogger() << "postorder no " << postOrderIDVec[bb->GetId()];
+    LogInfo::MapleLogger() << " is bb:" << bb->GetId();
+    LogInfo::MapleLogger() << " im_dom is bb:" << GetDom(bb->GetId())->GetId();
+    LogInfo::MapleLogger() << " domfrontier: [";
+    for (uint32 id : domFrontier[bb->GetId()]) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "] domchildren: [";
+    for (uint32 id : domChildren[bb->GetId()]) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "]\n";
+  }
+  LogInfo::MapleLogger() << "\npreorder traversal of dominator tree:";
+  for (uint32 id : dtPreOrder) {
+    LogInfo::MapleLogger() << id << " ";
+  }
+  LogInfo::MapleLogger() << "\n\n";
+}
+
+/* ================= for PostDominance ================= */
+void PostDomAnalysis::PdomPostOrderWalk(const BB &bb, int32 &pid, MapleVector<bool> &visitedMap) {
+  ASSERT(bb.GetId() < visitedMap.size(), "index out of range in  Dominance::PdomPostOrderWalk");
+  if (bbVec[bb.GetId()] == nullptr) {
+    return;
+  }
+  if (visitedMap[bb.GetId()]) {
+    return;
+  }
+  visitedMap[bb.GetId()] = true;
+  for (BB *pre : bb.GetPreds()) {
+    PdomPostOrderWalk(*pre, pid, visitedMap);
+  }
+  ASSERT(bb.GetId() < pdomPostOrderIDVec.size(), "index out of range in  Dominance::PdomPostOrderWalk");
+  pdomPostOrderIDVec[bb.GetId()] = pid++;
+}
+
+void PostDomAnalysis::PdomGenPostOrderID() {
+  ASSERT(!bbVec.empty(), "call calloc failed in Dominance::PdomGenPostOrderID");
+  MapleVector<bool> visitedMap(bbVec.size(), false, cgFunc.GetFuncScopeAllocator()->Adapter());
+  int32 postOrderID = 0;
+  PdomPostOrderWalk(commonExitBB, postOrderID, visitedMap);
+  // initialize pdomReversePostOrder
+  int32 maxPostOrderID = postOrderID - 1;
+  pdomReversePostOrder.resize(static_cast<uint32>(maxPostOrderID + 1));
+  for (size_t i = 0; i < pdomPostOrderIDVec.size(); ++i) {
+    int32 postOrderNo = pdomPostOrderIDVec[i];
+    if (postOrderNo == -1) {
+      continue;
+    }
+    pdomReversePostOrder[static_cast<uint32>(maxPostOrderID - postOrderNo)] = bbVec[i];
+  }
+}
+
+BB *PostDomAnalysis::PdomIntersect(BB &bb1, const BB &bb2) {
+  auto *ptrBB1 = &bb1;
+  auto *ptrBB2 = &bb2;
+  while (ptrBB1 != ptrBB2) {
+    while (pdomPostOrderIDVec[ptrBB1->GetId()] < pdomPostOrderIDVec[ptrBB2->GetId()]) {
+      ptrBB1 = GetPdom(ptrBB1->GetId());
+    }
+    while (pdomPostOrderIDVec[ptrBB2->GetId()] < pdomPostOrderIDVec[ptrBB1->GetId()]) {
+      ptrBB2 = GetPdom(ptrBB2->GetId());
+    }
+  }
+  return ptrBB1;
+}
+
+// Figure 3 in "A Simple, Fast Dominance Algorithm" by Keith Cooper et al.
+void PostDomAnalysis::ComputePostDominance() {
+  SetPdom(commonExitBB.GetId(), &commonExitBB);
+  bool changed = false;
+  do {
+    changed = false;
+    for (size_t i = 1; i < pdomReversePostOrder.size(); ++i) {
+      BB *bb = pdomReversePostOrder[i];
+      BB *suc = nullptr;
+      auto it = bb->GetSuccsBegin();
+      if (cgFunc.IsExitBB(*bb) || bb->GetSuccs().empty() ||
+          (bb->IsWontExit() && bb->GetKind() == BB::kBBGoto)) {
+        suc = &commonExitBB;
+      } else {
+        suc = *it;
+      }
+      ++it;
+      while ((GetPdom(suc->GetId()) == nullptr || suc == bb) && it != bb->GetSuccsEnd()) {
+        suc = *it;
+        ++it;
+      }
+      if (GetPdom(suc->GetId()) == nullptr) {
+        suc = &commonExitBB;
+      }
+      BB *newIDom = suc;
+      for (; it != bb->GetSuccsEnd(); ++it) {
+        suc = *it;
+        if (GetPdom(suc->GetId()) != nullptr && suc != bb) {
+          newIDom = PdomIntersect(*suc, *newIDom);
+        }
+      }
+      if (GetPdom(bb->GetId()) != newIDom) {
+        SetPdom(bb->GetId(), newIDom);
+        ASSERT(GetPdom(newIDom->GetId()) != nullptr, "null ptr check");
+        changed = true;
+      }
+    }
+  } while (changed);
+}
+
+// Figure 5 in "A Simple, Fast Dominance Algorithm" by Keith Cooper et al.
+void PostDomAnalysis::ComputePdomFrontiers() {
+  for (const BB *bb : bbVec) {
+    if (bb == nullptr || bb == &commonEntryBB) {
+      continue;
+    }
+    if (bb->GetSuccs().size() < kBBVectorInitialSize) {
+      continue;
+    }
+    for (BB *suc : bb->GetSuccs()) {
+      BB *runner = suc;
+      while (runner != GetPdom(bb->GetId()) && runner != &commonEntryBB &&
+          GetPdom(runner->GetId()) != nullptr) {   // add infinite loop code limit
+        if (!HasPdomFrontier(runner->GetId(), bb->GetId())) {
+          pdomFrontier[runner->GetId()].push_back(bb->GetId());
+        }
+        runner = GetPdom(runner->GetId());
+      }
+    }
+  }
+}
+
+void PostDomAnalysis::ComputePdomChildren() {
+  for (const BB *bb : bbVec) {
+    if (bb == nullptr || GetPdom(bb->GetId()) == nullptr) {
+      continue;
+    }
+    const BB *parent = GetPdom(bb->GetId());
+    if (parent == bb) {
+      continue;
+    }
+    pdomChildren[parent->GetId()].push_back(bb->GetId());
+  }
+}
+
+// bbidMarker indicates that the iterPdomFrontier results for bbid < bbidMarker
+// have been computed
+void PostDomAnalysis::GetIterPdomFrontier(const BB *bb, MapleSet<uint32> *dfset, uint32 bbidMarker,
+                                          std::vector<bool> &visitedMap) {
+  if (visitedMap[bb->GetId()]) {
+    return;
+  }
+  visitedMap[bb->GetId()] = true;
+  for (uint32 frontierbbid : pdomFrontier[bb->GetId()]) {
+    (void)dfset->insert(frontierbbid);
+    if (frontierbbid < bbidMarker) {  // union with its computed result
+      dfset->insert(iterPdomFrontier[frontierbbid].begin(), iterPdomFrontier[frontierbbid].end());
+    } else {  // recursive call
+      BB *frontierbb = bbVec[frontierbbid];
+      GetIterPdomFrontier(frontierbb, dfset, bbidMarker, visitedMap);
+    }
+  }
+}
+
+void PostDomAnalysis::ComputeIterPdomFrontiers() {
+  for (BB *bb : bbVec) {
+    if (bb == nullptr || bb == &commonEntryBB) {
+      continue;
+    }
+    std::vector<bool> visitedMap(bbVec.size(), false);
+    GetIterPdomFrontier(bb, &iterPdomFrontier[bb->GetId()], bb->GetId(), visitedMap);
+  }
+}
+
+uint32 PostDomAnalysis::ComputePdtPreorder(const BB &bb, uint32 &num) {
+  ASSERT(num < pdtPreOrder.size(), "index out of range in Dominance::ComputePdtPreOrder");
+  pdtPreOrder[num] = bb.GetId();
+  pdtDfn[bb.GetId()] = num;
+  uint32 maxDtDfnOut = num;
+  ++num;
+
+  for (uint32 k : pdomChildren[bb.GetId()]) {
+    maxDtDfnOut = ComputePdtPreorder(*bbVec[k], num);
+  }
+
+  pdtDfnOut[bb.GetId()] = maxDtDfnOut;
+  return maxDtDfnOut;
+}
+
+// true if b1 postdominates b2
+bool PostDomAnalysis::PostDominate(const BB &bb1, const BB &bb2) {
+  return pdtDfn[bb1.GetId()] <= pdtDfn[bb2.GetId()] && pdtDfnOut[bb1.GetId()] >= pdtDfnOut[bb2.GetId()];
+}
+
+void PostDomAnalysis::Dump() {
+  for (BB *bb : pdomReversePostOrder) {
+    LogInfo::MapleLogger() << "pdom_postorder no " << pdomPostOrderIDVec[bb->GetId()];
+    LogInfo::MapleLogger() << " is bb:" << bb->GetId();
+    LogInfo::MapleLogger() << " im_pdom is bb:" << GetPdom(bb->GetId())->GetId();
+    LogInfo::MapleLogger() << " pdomfrontier: [";
+    for (uint32 id : pdomFrontier[bb->GetId()]) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "] pdomchildren: [";
+    for (uint32 id : pdomChildren[bb->GetId()]) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "]\n";
+  }
+  LogInfo::MapleLogger() << "\n";
+  LogInfo::MapleLogger() << "preorder traversal of post-dominator tree:";
+  for (uint32 id : pdtPreOrder) {
+    LogInfo::MapleLogger() << id << " ";
+  }
+  LogInfo::MapleLogger() << "\n\n";
+}
+
+void PostDomAnalysis::GeneratePdomTreeDot() {
+  std::streambuf *coutBuf = std::cout.rdbuf();
+  std::ofstream pdomFile;
+  std::streambuf *fileBuf = pdomFile.rdbuf();
+  (void)std::cout.rdbuf(fileBuf);
+
+  std::string fileName;
+  (void)fileName.append("pdom_tree_");
+  (void)fileName.append(cgFunc.GetName());
+  (void)fileName.append(".dot");
+
+  pdomFile.open(fileName.c_str(), std::ios::trunc);
+  if (!pdomFile.is_open()) {
+    LogInfo::MapleLogger(kLlWarn) << "fileName:" << fileName << " open failed.\n";
+    return;
+  }
+  pdomFile << "digraph Pdom_" << cgFunc.GetName() << " {\n\n";
+  pdomFile << "  node [shape=box];\n\n";
+
+  FOR_ALL_BB_CONST(bb, &cgFunc) {
+    if (bb->IsUnreachable()) {
+      continue;
+    }
+    pdomFile << "  BB_" << bb->GetId();
+    pdomFile << "[label= \"";
+    if (bb == cgFunc.GetFirstBB()) {
+      pdomFile << "ENTRY\n";
+    }
+    pdomFile << "BB_" << bb->GetId() << "\"];\n";
+  }
+  BB *exitBB = cgFunc.GetCommonExitBB();
+  pdomFile << "  BB_" << exitBB->GetId();
+  pdomFile << "[label= \"EXIT\n";
+  pdomFile << "BB_" << exitBB->GetId() << "\"];\n";
+  pdomFile << "\n";
+
+  for (uint32 bbId = 0; bbId < pdomChildren.size(); ++bbId) {
+    if (pdomChildren[bbId].empty()) {
+      continue;
+    }
+    BB *parent = cgFunc.GetBBFromID(bbId);
+    CHECK_FATAL(parent != nullptr, "get pdom parent-node failed");
+    for (auto childId : pdomChildren[bbId]) {
+      BB *child = cgFunc.GetBBFromID(childId);
+      CHECK_FATAL(child != nullptr, "get pdom child-node failed");
+      pdomFile << "  BB_" << parent->GetId() << " -> " << "BB_" << child->GetId();
+      pdomFile << " [dir=none]" << ";\n";
+    }
+  }
+  pdomFile << "\n";
+
+  pdomFile << "}\n";
+  (void)pdomFile.flush();
+  pdomFile.close();
+  (void)std::cout.rdbuf(coutBuf);
+}
+
+void PostDomAnalysis::Compute() {
+  PdomGenPostOrderID();
+  ComputePostDominance();
+  ComputePdomFrontiers();
+  ComputePdomChildren();
+  ComputeIterPdomFrontiers();
+  uint32 num = 0;
+  (void)ComputePdtPreorder(GetCommonExitBB(), num);
+  ResizePdtPreOrder(num);
+}
+
+bool CgDomAnalysis::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *domMemPool = GetPhaseMemPool();
+  domAnalysis = domMemPool->New<DomAnalysis>(f, *domMemPool, *domMemPool, f.GetAllBBs(),
+                                             *f.GetFirstBB(), *f.GetCommonExitBB());
+  domAnalysis->Compute();
+  if (CG_DEBUG_FUNC(f)) {
+    domAnalysis->Dump();
+  }
+  return false;
+}
+MAPLE_ANALYSIS_PHASE_REGISTER(CgDomAnalysis, domanalysis)
+
+bool CgPostDomAnalysis::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *pdomMemPool = GetPhaseMemPool();
+  pdomAnalysis = pdomMemPool->New<PostDomAnalysis>(f, *pdomMemPool, *pdomMemPool, f.GetAllBBs(),
+                                                   *f.GetFirstBB(), *f.GetCommonExitBB());
+  pdomAnalysis->Compute();
+  if (CG_DEBUG_FUNC(f)) {
+    pdomAnalysis->Dump();
+  }
+  return false;
+}
+MAPLE_ANALYSIS_PHASE_REGISTER(CgPostDomAnalysis, pdomanalysis)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cg_irbuilder.cpp b/src/mapleall/maple_be/src/cg/cg_irbuilder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cd31bfdb889ff0492edd786a159d31711fbe3fc1
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_irbuilder.cpp
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "cg_irbuilder.h"
+#include "isa.h"
+#include "cg.h"
+#include "cfi.h"
+#include "dbg.h"
+
+namespace maplebe {
+Insn &InsnBuilder::BuildInsn(MOperator opCode, const InsnDesc &idesc) {
+  auto *newInsn = mp->New<Insn>(*mp, opCode);
+  newInsn->SetInsnDescrption(idesc);
+  IncreaseInsnNum();
+  return *newInsn;
+}
+
+Insn &InsnBuilder::BuildInsn(MOperator opCode, Operand &o0) {
+  const InsnDesc &tMd = Globals::GetInstance()->GetTarget()->GetTargetMd(opCode);
+  return BuildInsn(opCode, tMd).AddOpndChain(o0);
+}
+Insn &InsnBuilder::BuildInsn(MOperator opCode, Operand &o0, Operand &o1) {
+  const InsnDesc &tMd = Globals::GetInstance()->GetTarget()->GetTargetMd(opCode);
+  return BuildInsn(opCode, tMd).AddOpndChain(o0).AddOpndChain(o1);
+}
+Insn &InsnBuilder::BuildInsn(MOperator opCode, Operand &o0, Operand &o1, Operand &o2) {
+  const InsnDesc &tMd = Globals::GetInstance()->GetTarget()->GetTargetMd(opCode);
+  return BuildInsn(opCode, tMd).AddOpndChain(o0).AddOpndChain(o1).AddOpndChain(o2);
+}
+
+Insn &InsnBuilder::BuildInsn(MOperator opCode, Operand &o0, Operand &o1, Operand &o2, Operand &o3) {
+  const InsnDesc &tMd = Globals::GetInstance()->GetTarget()->GetTargetMd(opCode);
+  return BuildInsn(opCode, tMd).AddOpndChain(o0).AddOpndChain(o1).AddOpndChain(o2).AddOpndChain(o3);
+}
+
+Insn &InsnBuilder::BuildInsn(MOperator opCode, Operand &o0, Operand &o1, Operand &o2, Operand &o3, Operand &o4) {
+  const InsnDesc &tMd = Globals::GetInstance()->GetTarget()->GetTargetMd(opCode);
+  Insn &nI = BuildInsn(opCode, tMd);
+  return nI.AddOpndChain(o0).AddOpndChain(o1).AddOpndChain(o2).AddOpndChain(o3).AddOpndChain(o4);
+}
+
+Insn &InsnBuilder::BuildInsn(MOperator opCode, std::vector<Operand*> &opnds) {
+  const InsnDesc &tMd = Globals::GetInstance()->GetTarget()->GetTargetMd(opCode);
+  Insn &nI = BuildInsn(opCode, tMd);
+  for (auto *opnd : opnds) {
+    nI.AddOperand(*opnd);
+  }
+  return nI;
+}
+
+Insn &InsnBuilder::BuildCfiInsn(MOperator opCode) {
+  auto *nI = mp->New<cfi::CfiInsn>(*mp, opCode);
+  IncreaseInsnNum();
+  return *nI;
+}
+Insn &InsnBuilder::BuildDbgInsn(MOperator opCode) {
+  auto *nI = mp->New<mpldbg::DbgInsn>(*mp, opCode);
+  IncreaseInsnNum();
+  return *nI;
+}
+Insn &InsnBuilder::BuildCommentInsn(CommentOperand &comment) {
+  Insn &insn = BuildInsn(abstract::MOP_comment, InsnDesc::GetAbstractId(abstract::MOP_comment));
+  insn.AddOperand(comment);
+  return insn;
+}
+VectorInsn &InsnBuilder::BuildVectorInsn(MOperator opCode, const InsnDesc &idesc) {
+  auto *newInsn = mp->New<VectorInsn>(*mp, opCode);
+  newInsn->SetInsnDescrption(idesc);
+  IncreaseInsnNum();
+  return *newInsn;
+}
+
+ImmOperand &OperandBuilder::CreateImm(uint32 size, int64 value, MemPool *mp) {
+  return mp ? *mp->New<ImmOperand>(value, size, false) : *alloc.New<ImmOperand>(value, size, false);
+}
+
+ImmOperand &OperandBuilder::CreateImm(const MIRSymbol &symbol, int64 offset, int32 relocs, MemPool *mp) {
+  return mp ? *mp->New<ImmOperand>(symbol, offset, relocs, false) :
+      *alloc.New<ImmOperand>(symbol, offset, relocs, false);
+}
+
+MemOperand &OperandBuilder::CreateMem(uint32 size, MemPool *mp) {
+  return mp ? *mp->New<MemOperand>(size) : *alloc.New<MemOperand>(size);
+}
+
+MemOperand &OperandBuilder::CreateMem(RegOperand &baseOpnd, int64 offset, uint32 size) {
+  MemOperand *memOprand = &CreateMem(size);
+  memOprand->SetBaseRegister(baseOpnd);
+  memOprand->SetOffsetOperand(CreateImm(baseOpnd.GetSize(), offset));
+  return *memOprand;
+}
+
+RegOperand &OperandBuilder::CreateVReg(uint32 size, RegType type, MemPool *mp) {
+  virtualRegNum++;
+  regno_t vRegNO = kBaseVirtualRegNO + virtualRegNum;
+  return mp ? *mp->New<RegOperand>(vRegNO, size, type) : *alloc.New<RegOperand>(vRegNO, size, type);
+}
+
+RegOperand &OperandBuilder::CreateVReg(regno_t vRegNO, uint32 size, RegType type, MemPool *mp) {
+  return mp ? *mp->New<RegOperand>(vRegNO, size, type) : *alloc.New<RegOperand>(vRegNO, size, type);
+}
+
+RegOperand &OperandBuilder::CreatePReg(regno_t pRegNO, uint32 size, RegType type, MemPool *mp) {
+  return mp ? *mp->New<RegOperand>(pRegNO, size, type) : *alloc.New<RegOperand>(pRegNO, size, type);
+}
+
+ListOperand &OperandBuilder::CreateList(MemPool *mp) {
+  return mp ? *mp->New<ListOperand>(alloc) : *alloc.New<ListOperand>(alloc);
+}
+
+FuncNameOperand &OperandBuilder::CreateFuncNameOpnd(MIRSymbol &symbol, MemPool *mp){
+  return mp ? *mp->New<FuncNameOperand>(symbol) : *alloc.New<FuncNameOperand>(symbol);
+}
+
+LabelOperand &OperandBuilder::CreateLabel(const char *parent, LabelIdx idx, MemPool *mp){
+  return mp ? *mp->New<LabelOperand>(parent, idx, *mp) : *alloc.New<LabelOperand>(parent, idx, *alloc.GetMemPool());
+}
+
+CommentOperand &OperandBuilder::CreateComment(const std::string &s, MemPool *mp) {
+  return mp ? *mp->New<CommentOperand>(s, *mp) : *alloc.New<CommentOperand>(s, *alloc.GetMemPool());
+}
+
+CommentOperand &OperandBuilder::CreateComment(const MapleString &s, MemPool *mp) {
+  return mp ? *mp->New<CommentOperand>(s.c_str(), *mp) : *alloc.New<CommentOperand>(s.c_str(), *alloc.GetMemPool());
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/cg_occur.cpp b/src/mapleall/maple_be/src/cg/cg_occur.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec87c882bec82988ef7386abc1c5e603c0d39786
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_occur.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_occur.h"
+#include "cg_pre.h"
+
+/* The methods associated with the data structures that represent occurrences and work candidates for PRE */
+namespace maplebe {
+/* return if this occur dominate occ */
+bool CgOccur::IsDominate(DomAnalysis &dom, CgOccur &occ) {
+  return dom.Dominate(*GetBB(), *occ.GetBB());
+}
+
+/* compute bucket index for the work candidate in workCandHashTable */
+uint32 PreWorkCandHashTable::ComputeWorkCandHashIndex(const Operand &opnd) {
+  uint32 hashIdx = static_cast<uint32>(reinterpret_cast<uint64>(&opnd) >> k4ByteSize);
+  return hashIdx % workCandHashLength;
+}
+
+uint32 PreWorkCandHashTable::ComputeStmtWorkCandHashIndex(const Insn &insn) {
+  uint32 hIdx = (static_cast<uint32>(insn.GetMachineOpcode())) << k3ByteSize;
+  return hIdx % workCandHashLength;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_be/src/cg/cg_option.cpp b/src/mapleall/maple_be/src/cg/cg_option.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4d64e1c8ca0f7d93cda2361f0729546b1be1be28
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_option.cpp
@@ -0,0 +1,876 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_option.h"
+#include <fstream>
+#include <unordered_map>
+#include "cg_options.h"
+#include "driver_options.h"
+#include "mpl_logging.h"
+#include "parser_opt.h"
+#include "mir_parser.h"
+#include "string_utils.h"
+#include "triple.h"
+
+namespace maplebe {
+using namespace maple;
+
+const std::string kMplcgVersion = "";
+
+bool CGOptions::timePhases = false;
+std::string CGOptions::targetArch = "";
+std::unordered_set<std::string> CGOptions::dumpPhases = {};
+std::unordered_set<std::string> CGOptions::skipPhases = {};
+std::unordered_map<std::string, std::vector<std::string>> CGOptions::cyclePatternMap = {};
+std::string CGOptions::skipFrom = "";
+std::string CGOptions::skipAfter = "";
+std::string CGOptions::dumpFunc = "*";
+std::string CGOptions::globalVarProfile = "";
+std::string CGOptions::profileData = "";
+std::string CGOptions::profileFuncData = "";
+std::string CGOptions::profileClassData = "";
+#ifdef TARGARM32
+std::string CGOptions::duplicateAsmFile = "";
+#else
+std::string CGOptions::duplicateAsmFile = "maple/mrt/codetricks/arch/arm64/duplicateFunc.s";
+#endif
+Range CGOptions::range = Range();
+std::string CGOptions::fastFuncsAsmFile = "";
+Range CGOptions::spillRanges = Range();
+uint8 CGOptions::fastAllocMode = 0;  /* 0: fast, 1: spill all */
+bool CGOptions::fastAlloc = false;
+uint64 CGOptions::lsraBBOptSize = 150000;
+uint64 CGOptions::lsraInsnOptSize = 200000;
+uint64 CGOptions::overlapNum = 28;
+uint8 CGOptions::rematLevel = 2;
+bool CGOptions::optForSize = false;
+bool CGOptions::enableHotColdSplit = false;
+uint32 CGOptions::alignMinBBSize = 16;
+uint32 CGOptions::alignMaxBBSize = 96;
+uint32 CGOptions::loopAlignPow = 4;
+uint32 CGOptions::jumpAlignPow = 5;
+uint32 CGOptions::funcAlignPow = 5;
+bool CGOptions::liteProfGen = false;
+bool CGOptions::liteProfUse = false;
+std::string CGOptions::liteProfile = "";
+std::string CGOptions::instrumentationWhiteList = "";
+std::string CGOptions::litePgoOutputFunction = "main";
+#if TARGAARCH64 || TARGRISCV64
+bool CGOptions::useBarriersForVolatile = false;
+#else
+bool CGOptions::useBarriersForVolatile = true;
+#endif
+bool CGOptions::exclusiveEH = false;
+bool CGOptions::doEBO = false;
+bool CGOptions::doCGSSA = false;
+bool CGOptions::doIPARA = true;
+bool CGOptions::doCFGO = false;
+bool CGOptions::doICO = false;
+bool CGOptions::doStoreLoadOpt = false;
+bool CGOptions::doGlobalOpt = false;
+bool CGOptions::doVregRename = false;
+bool CGOptions::doMultiPassColorRA = true;
+bool CGOptions::doPrePeephole = false;
+bool CGOptions::doPeephole = false;
+bool CGOptions::doRetMerge = false;
+bool CGOptions::doSchedule = false;
+bool CGOptions::doWriteRefFieldOpt = false;
+bool CGOptions::dumpOptimizeCommonLog = false;
+bool CGOptions::checkArrayStore = false;
+bool CGOptions::doPIC = false;
+bool CGOptions::noDupBB = false;
+bool CGOptions::noCalleeCFI = true;
+bool CGOptions::emitCyclePattern = false;
+bool CGOptions::insertYieldPoint = false;
+bool CGOptions::mapleLinker = false;
+bool CGOptions::printFunction = false;
+bool CGOptions::nativeOpt = false;
+bool CGOptions::lazyBinding = false;
+bool CGOptions::hotFix = false;
+bool CGOptions::debugSched = false;
+bool CGOptions::bruteForceSched = false;
+bool CGOptions::simulateSched = false;
+CGOptions::ABIType CGOptions::abiType = kABIHard;
+CGOptions::EmitFileType CGOptions::emitFileType = kAsm;
+bool CGOptions::genLongCalls = false;
+bool CGOptions::functionSections = false;
+bool CGOptions::useFramePointer = false;
+bool CGOptions::gcOnly = false;
+bool CGOptions::quiet = false;
+bool CGOptions::doPatchLongBranch = false;
+bool CGOptions::doPreSchedule = false;
+bool CGOptions::emitBlockMarker = true;
+bool CGOptions::inRange = false;
+bool CGOptions::doPreLSRAOpt = false;
+bool CGOptions::doLocalRefSpill = false;
+bool CGOptions::doCalleeToSpill = false;
+bool CGOptions::doRegSavesOpt = false;
+bool CGOptions::useSsaPreSave = false;
+bool CGOptions::useSsuPreRestore = false;
+bool CGOptions::replaceASM = false;
+bool CGOptions::generalRegOnly = false;
+bool CGOptions::fastMath = false;
+bool CGOptions::doAlignAnalysis = false;
+bool CGOptions::doCondBrAlign = false;
+bool CGOptions::cgBigEndian = false;
+bool CGOptions::arm64ilp32 = false;
+bool CGOptions::noCommon = false;
+bool CGOptions::flavorLmbc = false;
+
+CGOptions &CGOptions::GetInstance() {
+  static CGOptions instance;
+  return instance;
+}
+
+void CGOptions::DecideMplcgRealLevel(bool isDebug) {
+  if (opts::cg::o0) {
+    if (isDebug) {
+      LogInfo::MapleLogger() << "Real Mplcg level: O0\n";
+    }
+    EnableO0();
+  }
+
+  if (opts::cg::o1) {
+    if (isDebug) {
+      LogInfo::MapleLogger() << "Real Mplcg level: O1\n";
+    }
+    EnableO1();
+  }
+
+  if (opts::cg::o2 || opts::cg::os) {
+    if (opts::cg::os) {
+      optForSize = true;
+    }
+    if (isDebug) {
+      std::string oLog = (opts::cg::os == true) ? "Os" : "O2";
+      LogInfo::MapleLogger() << "Real Mplcg level: " << oLog << "\n";
+    }
+    EnableO2();
+  }
+  if (opts::cg::olitecg) {
+    if (isDebug) {
+      LogInfo::MapleLogger() << "Real Mplcg level: LiteCG\n";
+    }
+    EnableLiteCG();
+  }
+}
+
+bool CGOptions::SolveOptions(bool isDebug) {
+  DecideMplcgRealLevel(isDebug);
+
+  for (const auto &opt : cgCategory.GetEnabledOptions()) {
+    std::string printOpt;
+    if (isDebug) {
+      for (const auto &val : opt->GetRawValues()) {
+        printOpt += opt->GetName() + " " + val + " ";
+      }
+      LogInfo::MapleLogger() << "cg options: " << printOpt << '\n';
+    }
+  }
+
+  if (opts::cg::quiet.IsEnabledByUser()) {
+    SetQuiet(true);
+  }
+
+  if (opts::verbose.IsEnabledByUser()) {
+    SetQuiet(false);
+  }
+
+  if (opts::cg::pie.IsEnabledByUser()) {
+    opts::cg::pie ? SetOption(CGOptions::kGenPie) : ClearOption(CGOptions::kGenPie);
+  }
+
+  if (opts::cg::fpic.IsEnabledByUser()) {
+    if (opts::cg::fpic) {
+      EnablePIC();
+      SetOption(CGOptions::kGenPic);
+    } else {
+      DisablePIC();
+      ClearOption(CGOptions::kGenPic);
+    }
+  }
+
+  if (opts::cg::verboseAsm.IsEnabledByUser()) {
+    opts::cg::verboseAsm ? SetOption(CGOptions::kVerboseAsm) : ClearOption(CGOptions::kVerboseAsm);
+  }
+
+  if (opts::cg::verboseCg.IsEnabledByUser()) {
+    opts::cg::verboseCg ? SetOption(CGOptions::kVerboseCG) : ClearOption(CGOptions::kVerboseCG);
+  }
+
+  if (opts::cg::maplelinker.IsEnabledByUser()) {
+    opts::cg::maplelinker ? EnableMapleLinker() : DisableMapleLinker();
+  }
+
+  if (opts::cg::fastAlloc.IsEnabledByUser()) {
+    EnableFastAlloc();
+    SetFastAllocMode(opts::cg::fastAlloc);
+  }
+
+  if (opts::cg::useBarriersForVolatile.IsEnabledByUser()) {
+    opts::cg::useBarriersForVolatile ? EnableBarriersForVolatile() : DisableBarriersForVolatile();
+  }
+
+  if (opts::cg::spillRange.IsEnabledByUser()) {
+    SetRange(opts::cg::spillRange, "--pill-range", GetSpillRanges());
+  }
+
+  if (opts::cg::range.IsEnabledByUser()) {
+    SetRange(opts::cg::range, "--range", GetRange());
+  }
+
+  if (opts::cg::timePhases.IsEnabledByUser()) {
+    opts::cg::timePhases ? EnableTimePhases() : DisableTimePhases();
+  }
+
+  if (opts::cg::dumpFunc.IsEnabledByUser()) {
+    SetDumpFunc(opts::cg::dumpFunc);
+  }
+
+  if (opts::cg::duplicateAsmList.IsEnabledByUser()) {
+    SetDuplicateAsmFile(opts::cg::duplicateAsmList);
+  }
+
+  if (opts::cg::duplicateAsmList2.IsEnabledByUser()) {
+    SetFastFuncsAsmFile(opts::cg::duplicateAsmList2);
+  }
+
+  if (opts::stackProtectorStrong.IsEnabledByUser()) {
+    SetOption(kUseStackProtectorStrong);
+  }
+
+  if (opts::stackProtectorAll.IsEnabledByUser()) {
+    SetOption(kUseStackProtectorAll);
+  }
+
+  if (opts::cg::debug.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    ClearOption(kSuppressFileInfo);
+  }
+
+  if (opts::cg::gdwarf.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    SetOption(kWithDwarf);
+    SetParserOption(kWithDbgInfo);
+    ClearOption(kSuppressFileInfo);
+  }
+
+  if (opts::cg::gsrc.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    SetOption(kWithSrc);
+    ClearOption(kWithMpl);
+  }
+
+  if (opts::cg::gmixedsrc.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    SetOption(kWithSrc);
+    SetOption(kWithMpl);
+  }
+
+  if (opts::cg::gmixedasm.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    SetOption(kWithSrc);
+    SetOption(kWithMpl);
+    SetOption(kWithAsm);
+  }
+
+  if (opts::cg::profile.IsEnabledByUser()) {
+    SetOption(kWithProfileCode);
+    SetParserOption(kWithProfileInfo);
+  }
+
+  if (opts::cg::withRaLinearScan.IsEnabledByUser()) {
+    SetOption(kDoLinearScanRegAlloc);
+    ClearOption(kDoColorRegAlloc);
+  }
+
+  if (opts::cg::withRaGraphColor.IsEnabledByUser()) {
+    SetOption(kDoColorRegAlloc);
+    ClearOption(kDoLinearScanRegAlloc);
+  }
+
+  if (opts::cg::printFunc.IsEnabledByUser()) {
+    opts::cg::printFunc ? EnablePrintFunction() : DisablePrintFunction();
+  }
+
+  if (opts::cg::addDebugTrace.IsEnabledByUser()) {
+    SetOption(kAddDebugTrace);
+  }
+
+  if (opts::cg::suppressFileinfo.IsEnabledByUser()) {
+    SetOption(kSuppressFileInfo);
+  }
+
+  if (opts::cg::patchLongBranch.IsEnabledByUser()) {
+    SetOption(kPatchLongBranch);
+  }
+
+  if (opts::cg::constFold.IsEnabledByUser()) {
+    opts::cg::constFold ? SetOption(kConstFold) : ClearOption(kConstFold);
+  }
+
+  if (opts::cg::dumpCfg.IsEnabledByUser()) {
+    SetOption(kDumpCFG);
+  }
+
+  if (opts::cg::classListFile.IsEnabledByUser()) {
+    SetClassListFile(opts::cg::classListFile);
+  }
+
+  if (opts::cg::genCMacroDef.IsEnabledByUser()) {
+    SetOrClear(GetGenerateFlags(), CGOptions::kCMacroDef, opts::cg::genCMacroDef);
+  }
+
+  if (opts::cg::genGctibFile.IsEnabledByUser()) {
+    SetOrClear(GetGenerateFlags(), CGOptions::kGctib, opts::cg::genGctibFile);
+  }
+
+  if (opts::cg::yieldpoint.IsEnabledByUser()) {
+    SetOrClear(GetGenerateFlags(), CGOptions::kGenYieldPoint, opts::cg::yieldpoint);
+  }
+
+  if (opts::cg::localRc.IsEnabledByUser()) {
+    SetOrClear(GetGenerateFlags(), CGOptions::kGenLocalRc, opts::cg::localRc);
+  }
+
+  if (opts::cg::ehExclusiveList.IsEnabledByUser()) {
+    SetEHExclusiveFile(opts::cg::ehExclusiveList);
+    EnableExclusiveEH();
+    ParseExclusiveFunc(opts::cg::ehExclusiveList);
+  }
+
+  if (opts::cg::cyclePatternList.IsEnabledByUser()) {
+    SetCyclePatternFile(opts::cg::cyclePatternList);
+    EnableEmitCyclePattern();
+    ParseCyclePattern(opts::cg::cyclePatternList);
+  }
+
+  if (opts::cg::cg.IsEnabledByUser()) {
+    SetRunCGFlag(opts::cg::cg);
+    opts::cg::cg ? SetOption(CGOptions::kDoCg) : ClearOption(CGOptions::kDoCg);
+  }
+
+  if (opts::cg::objmap.IsEnabledByUser()) {
+    SetGenerateObjectMap(opts::cg::objmap);
+  }
+
+  if (opts::cg::replaceAsm.IsEnabledByUser()) {
+    opts::cg::replaceAsm ? EnableReplaceASM() : DisableReplaceASM();
+  }
+
+  if (opts::cg::generalRegOnly.IsEnabledByUser()) {
+    opts::cg::generalRegOnly ? EnableGeneralRegOnly() : DisableGeneralRegOnly();
+  }
+
+  if (opts::cg::lazyBinding.IsEnabledByUser()) {
+    opts::cg::lazyBinding ? EnableLazyBinding() : DisableLazyBinding();
+  }
+
+  if (opts::cg::hotFix.IsEnabledByUser()) {
+    opts::cg::hotFix ? EnableHotFix() : DisableHotFix();
+  }
+
+  if (opts::cg::soeCheck.IsEnabledByUser()) {
+    SetOption(CGOptions::kSoeCheckInsert);
+  }
+
+  if (opts::cg::checkArraystore.IsEnabledByUser()) {
+    opts::cg::checkArraystore ? EnableCheckArrayStore() : DisableCheckArrayStore();
+  }
+
+  if (opts::cg::ebo.IsEnabledByUser()) {
+    opts::cg::ebo ? EnableEBO() : DisableEBO();
+  }
+
+  if (opts::cg::cfgo.IsEnabledByUser()) {
+    opts::cg::cfgo ? EnableCFGO() : DisableCFGO();
+  }
+
+  if (opts::cg::ico.IsEnabledByUser()) {
+    opts::cg::ico ? EnableICO() : DisableICO();
+  }
+
+  if (opts::cg::storeloadopt.IsEnabledByUser()) {
+    opts::cg::storeloadopt ? EnableStoreLoadOpt() : DisableStoreLoadOpt();
+  }
+
+  if (opts::cg::globalopt.IsEnabledByUser()) {
+    opts::cg::globalopt ? EnableGlobalOpt() : DisableGlobalOpt();
+  }
+
+  // only on master
+  if (opts::cg::hotcoldsplit.IsEnabledByUser()) {
+    opts::cg::hotcoldsplit ? EnableHotColdSplit() : DisableHotColdSplit();
+  }
+
+  if (opts::cg::prelsra.IsEnabledByUser()) {
+    opts::cg::prelsra ? EnablePreLSRAOpt() : DisablePreLSRAOpt();
+  }
+
+  if (opts::cg::lsraLvarspill.IsEnabledByUser()) {
+    opts::cg::lsraLvarspill ? EnableLocalRefSpill() : DisableLocalRefSpill();
+  }
+
+  if (opts::cg::lsraOptcallee.IsEnabledByUser()) {
+    opts::cg::lsraOptcallee ? EnableCalleeToSpill() : DisableCalleeToSpill();
+  }
+
+  if (opts::cg::prepeep.IsEnabledByUser()) {
+    opts::cg::prepeep ? EnablePrePeephole() : DisablePrePeephole();
+  }
+
+  if (opts::cg::peep.IsEnabledByUser()) {
+    opts::cg::peep ? EnablePeephole() : DisablePeephole();
+  }
+
+  if (opts::cg::retMerge.IsEnabledByUser()) {
+    opts::cg::retMerge ? EnableRetMerge() : DisableRetMerge();
+  }
+
+  if (opts::cg::preschedule.IsEnabledByUser()) {
+    opts::cg::preschedule ? EnablePreSchedule() : DisablePreSchedule();
+  }
+
+  if (opts::cg::schedule.IsEnabledByUser()) {
+    opts::cg::schedule ? EnableSchedule() : DisableSchedule();
+  }
+
+  if (opts::cg::vregRename.IsEnabledByUser()) {
+    opts::cg::vregRename ? EnableVregRename() : DisableVregRename();
+  }
+
+  if (opts::cg::fullcolor.IsEnabledByUser()) {
+    opts::cg::fullcolor ? EnableMultiPassColorRA() : DisableMultiPassColorRA();
+  }
+
+  if (opts::cg::writefieldopt.IsEnabledByUser()) {
+    opts::cg::writefieldopt ? EnableWriteRefFieldOpt() : DisableWriteRefFieldOpt();
+  }
+
+  if (opts::cg::dumpOlog.IsEnabledByUser()) {
+    opts::cg::dumpOlog ? EnableDumpOptimizeCommonLog() : DisableDumpOptimizeCommonLog();
+  }
+
+  if (opts::cg::nativeopt.IsEnabledByUser()) {
+    // FIXME: Disabling Looks strage: should be checked by author of the code
+    DisableNativeOpt();
+  }
+
+  if (opts::cg::dupBb.IsEnabledByUser()) {
+    opts::cg::dupBb ? DisableNoDupBB() : EnableNoDupBB();
+  }
+
+  if (opts::cg::calleeCfi.IsEnabledByUser()) {
+    opts::cg::calleeCfi ? DisableNoCalleeCFI() : EnableNoCalleeCFI();
+  }
+
+  if (opts::cg::proepilogue.IsEnabledByUser()) {
+    opts::cg::proepilogue ? SetOption(CGOptions::kProEpilogueOpt)
+                          : ClearOption(CGOptions::kProEpilogueOpt);
+  }
+
+  if (opts::cg::tailcall.IsEnabledByUser()) {
+    opts::cg::tailcall ? SetOption(CGOptions::kTailCallOpt)
+                       : ClearOption(CGOptions::kTailCallOpt);
+  }
+
+  if (opts::cg::calleeregsPlacement.IsEnabledByUser()) {
+    opts::cg::calleeregsPlacement ? EnableRegSavesOpt() : DisableRegSavesOpt();
+  }
+
+  if (opts::cg::ssapreSave.IsEnabledByUser()) {
+    opts::cg::ssapreSave ? EnableSsaPreSave() : DisableSsaPreSave();
+  }
+
+  if (opts::cg::ssupreRestore.IsEnabledByUser()) {
+    opts::cg::ssupreRestore ? EnableSsuPreRestore() : DisableSsuPreRestore();
+  }
+
+  if (opts::cg::lsraBb.IsEnabledByUser()) {
+    SetLSRABBOptSize(opts::cg::lsraBb);
+  }
+
+  if (opts::cg::lsraInsn.IsEnabledByUser()) {
+    SetLSRAInsnOptSize(opts::cg::lsraInsn);
+  }
+
+  if (opts::cg::lsraOverlap.IsEnabledByUser()) {
+    SetOverlapNum(opts::cg::lsraOverlap);
+  }
+
+  if (opts::cg::remat.IsEnabledByUser()) {
+    SetRematLevel(opts::cg::remat);
+  }
+
+  if (opts::cg::dumpPhases.IsEnabledByUser()) {
+    SplitPhases(opts::cg::dumpPhases, GetDumpPhases());
+  }
+
+  if (opts::cg::target.IsEnabledByUser()) {
+    SetTargetMachine(opts::cg::target);
+  }
+
+  if (opts::cg::skipPhases.IsEnabledByUser()) {
+    SplitPhases(opts::cg::skipPhases, GetSkipPhases());
+  }
+
+  if (opts::cg::skipFrom.IsEnabledByUser()) {
+    SetSkipFrom(opts::cg::skipFrom);
+  }
+
+  if (opts::cg::skipAfter.IsEnabledByUser()) {
+    SetSkipAfter(opts::cg::skipAfter);
+  }
+
+  if (opts::cg::debugSchedule.IsEnabledByUser()) {
+    opts::cg::debugSchedule ? EnableDebugSched() : DisableDebugSched();
+  }
+
+  if (opts::cg::bruteforceSchedule.IsEnabledByUser()) {
+    opts::cg::bruteforceSchedule ? EnableDruteForceSched() : DisableDruteForceSched();
+  }
+
+  if (opts::cg::simulateSchedule.IsEnabledByUser()) {
+    opts::cg::simulateSchedule ? EnableSimulateSched() : DisableSimulateSched();
+  }
+
+  if (opts::profile.IsEnabledByUser()) {
+    SetProfileData(opts::profile);
+  }
+
+  if (opts::cg::unwindTables.IsEnabledByUser()) {
+    SetOption(kUseUnwindTables);
+  }
+
+  if (opts::cg::nativeopt.IsEnabledByUser()) {
+    DisableNativeOpt();
+  }
+
+  if (opts::cg::floatAbi.IsEnabledByUser()) {
+    SetABIType(opts::cg::floatAbi);
+  }
+
+  if (opts::cg::filetype.IsEnabledByUser()) {
+    SetEmitFileType(opts::cg::filetype);
+  }
+
+  if (opts::cg::longCalls.IsEnabledByUser()) {
+    opts::cg::longCalls ? EnableLongCalls() : DisableLongCalls();
+  }
+
+  if (opts::cg::functionSections.IsEnabledByUser()) {
+    opts::cg::functionSections ? EnableFunctionSections() : DisableFunctionSections();
+  }
+
+  if (opts::cg::omitFramePointer.IsEnabledByUser()) {
+    opts::cg::omitFramePointer ? DisableFramePointer() : EnableFramePointer();
+  }
+
+  if (opts::gcOnly.IsEnabledByUser()) {
+    opts::gcOnly ? EnableGCOnly() : DisableGCOnly();
+  }
+
+  if (opts::cg::fastMath.IsEnabledByUser()) {
+    opts::cg::fastMath ? EnableFastMath() : DisableFastMath();
+  }
+
+  if (opts::cg::alignAnalysis.IsEnabledByUser()) {
+    opts::cg::alignAnalysis ? EnableAlignAnalysis() : DisableAlignAnalysis();
+  }
+
+  if (opts::cg::condbrAlign.IsEnabledByUser()) {
+    opts::cg::condbrAlign ? EnableCondBrAlign() : DisableCondBrAlign();
+  }
+
+  /* big endian can be set with several options: --target, -Be.
+   * Triple takes to account all these options and allows to detect big endian with IsBigEndian() interface */
+  Triple::GetTriple().IsBigEndian() ? EnableBigEndianInCG() : DisableBigEndianInCG();
+  (maple::Triple::GetTriple().GetEnvironment() == Triple::GNUILP32) ? EnableArm64ilp32() : DisableArm64ilp32();
+
+  if (opts::cg::cgSsa.IsEnabledByUser()) {
+    opts::cg::cgSsa ? EnableCGSSA() : DisableCGSSA();
+  }
+
+  if (opts::cg::common.IsEnabledByUser()) {
+    opts::cg::common ? EnableCommon() : DisableCommon();
+  }
+
+  if (opts::cg::alignMinBbSize.IsEnabledByUser()) {
+    SetAlignMinBBSize(opts::cg::alignMinBbSize);
+  }
+
+  if (opts::cg::alignMaxBbSize.IsEnabledByUser()) {
+    SetAlignMaxBBSize(opts::cg::alignMaxBbSize);
+  }
+
+  if (opts::cg::loopAlignPow.IsEnabledByUser()) {
+    SetLoopAlignPow(opts::cg::loopAlignPow);
+  }
+
+  if (opts::cg::jumpAlignPow.IsEnabledByUser()) {
+    SetJumpAlignPow(opts::cg::jumpAlignPow);
+  }
+
+  if (opts::cg::funcAlignPow.IsEnabledByUser()) {
+    SetFuncAlignPow(opts::cg::funcAlignPow);
+  }
+
+  if (opts::cg::litePgoGen.IsEnabledByUser()) {
+    opts::cg::litePgoGen ? EnableLiteProfGen() : DisableLiteProfGen();
+  }
+
+  if (opts::cg::litePgoOutputFunc.IsEnabledByUser()) {
+    EnableLiteProfGen();
+    if (!opts::cg::litePgoOutputFunc.GetValue().empty()) {
+      SetLitePgoOutputFunction(opts::cg::litePgoOutputFunc);
+    }
+  }
+
+  if (opts::cg::instrumentationFile.IsEnabledByUser()) {
+    SetInstrumentationWhiteList(opts::cg::instrumentationFile);
+    if (!opts::cg::instrumentationFile.GetValue().empty()) {
+      EnableLiteProfGen();
+    }
+  }
+
+  if (opts::cg::litePgoFile.IsEnabledByUser()) {
+    SetLiteProfile(opts::cg::litePgoFile);
+    if (!opts::cg::litePgoFile.GetValue().empty()) {
+      EnableLiteProfUse();
+    }
+  }
+
+  /* override some options when loc, dwarf is generated */
+  if (WithLoc()) {
+    DisableSchedule();
+    SetOption(kWithSrc);
+  }
+  if (WithDwarf()) {
+    DisableEBO();
+    DisableCFGO();
+    DisableICO();
+    DisableSchedule();
+    SetOption(kDebugFriendly);
+    SetOption(kWithSrc);
+    SetOption(kWithLoc);
+    ClearOption(kSuppressFileInfo);
+  }
+
+  return true;
+}
+
+void CGOptions::ParseExclusiveFunc(const std::string &fileName) {
+  std::ifstream file(fileName);
+  if (!file.is_open()) {
+    ERR(kLncErr, "%s open failed!", fileName.c_str());
+    return;
+  }
+  std::string content;
+  while (file >> content) {
+    ehExclusiveFunctionName.push_back(content);
+  }
+}
+
+void CGOptions::ParseCyclePattern(const std::string &fileName) const {
+  std::ifstream file(fileName);
+  if (!file.is_open()) {
+    ERR(kLncErr, "%s open failed!", fileName.c_str());
+    return;
+  }
+  std::string content;
+  std::string classStr("class: ");
+  while (getline(file, content)) {
+    if (content.compare(0, classStr.length(), classStr) == 0) {
+      std::vector<std::string> classPatternContent;
+      std::string patternContent;
+      while (getline(file, patternContent)) {
+        if (patternContent.length() == 0) {
+          break;
+        }
+        classPatternContent.push_back(patternContent);
+      }
+      std::string className = content.substr(classStr.length());
+      CGOptions::cyclePatternMap[className] = move(classPatternContent);
+    }
+  }
+}
+
+void CGOptions::SetRange(const std::string &str, const std::string &cmd, Range &subRange) const {
+  const std::string &tmpStr = str;
+  size_t comma = tmpStr.find_first_of(",", 0);
+  subRange.enable = true;
+
+  if (comma != std::string::npos) {
+    subRange.begin = std::stoul(tmpStr.substr(0, comma), nullptr);
+    subRange.end = std::stoul(tmpStr.substr(comma + 1, std::string::npos - (comma + 1)), nullptr);
+  }
+  CHECK_FATAL(range.begin < range.end, "invalid values for %s=%lu,%lu", cmd.c_str(), subRange.begin, subRange.end);
+}
+
+/* Set default options according to different languages. */
+void CGOptions::SetDefaultOptions(const maple::MIRModule &mod) {
+  if (mod.IsJavaModule()) {
+    generateFlag = generateFlag | kGenYieldPoint | kGenLocalRc | kGrootList | kPrimorList;
+  }
+  if (mod.GetFlavor() == MIRFlavor::kFlavorLmbc) {
+    EnableFlavorLmbc();
+  }
+  insertYieldPoint = GenYieldPoint();
+}
+
+void CGOptions::EnableO0() {
+  optimizeLevel = kLevel0;
+  doEBO = false;
+  doCGSSA = false;
+  doCFGO = false;
+  doICO = false;
+  doPrePeephole = false;
+  doPeephole = false;
+  doStoreLoadOpt = false;
+  doGlobalOpt = false;
+  doPreLSRAOpt = false;
+  doLocalRefSpill = false;
+  doCalleeToSpill = false;
+  doPreSchedule = false;
+  doSchedule = false;
+  doRegSavesOpt = false;
+  useSsaPreSave = false;
+  useSsuPreRestore = false;
+  doWriteRefFieldOpt = false;
+  doAlignAnalysis = false;
+  doCondBrAlign = false;
+  SetOption(kUseUnwindTables);
+  if (maple::Triple::GetTriple().GetEnvironment() == Triple::GNUILP32) {
+    ClearOption(kUseStackProtectorStrong);
+  } else {
+    SetOption(kUseStackProtectorStrong);
+  }
+  ClearOption(kUseStackProtectorAll);
+  ClearOption(kConstFold);
+  ClearOption(kProEpilogueOpt);
+  ClearOption(kTailCallOpt);
+}
+
+void CGOptions::EnableO1() {
+  optimizeLevel = kLevel1;
+  doPreLSRAOpt = true;
+  doCalleeToSpill = true;
+  SetOption(kConstFold);
+  SetOption(kProEpilogueOpt);
+  SetOption(kTailCallOpt);
+  SetOption(kUseUnwindTables);
+  ClearOption(kUseStackProtectorStrong);
+  ClearOption(kUseStackProtectorAll);
+}
+
+void CGOptions::EnableO2() {
+  optimizeLevel = kLevel2;
+  doEBO = true;
+  doCGSSA = true;
+  doCFGO = true;
+  doICO = true;
+  doPrePeephole = true;
+  doPeephole = true;
+  doStoreLoadOpt = true;
+  doGlobalOpt = true;
+  doPreSchedule = true;
+  doSchedule = true;
+  doAlignAnalysis = true;
+  doCondBrAlign = true;
+  doRetMerge = true;
+  SetOption(kConstFold);
+  SetOption(kUseUnwindTables);
+  ClearOption(kUseStackProtectorStrong);
+  ClearOption(kUseStackProtectorAll);
+#if TARGARM32
+  doPreLSRAOpt = false;
+  doLocalRefSpill = false;
+  doCalleeToSpill = false;
+  doWriteRefFieldOpt = false;
+  ClearOption(kProEpilogueOpt);
+  ClearOption(kTailCallOpt);
+#else
+  doPreLSRAOpt = true;
+  doLocalRefSpill = true;
+  doCalleeToSpill = true;
+  doRegSavesOpt = true;
+  useSsaPreSave = true;
+  useSsuPreRestore = true;
+  doWriteRefFieldOpt = true;
+  SetOption(kProEpilogueOpt);
+  SetOption(kTailCallOpt);
+#endif
+}
+
+void CGOptions::EnableLiteCG() {
+  optimizeLevel = kLevelLiteCG;
+  doEBO = false;
+  doCGSSA = false;
+  doCFGO = false;
+  doICO = false;
+  doPrePeephole = false;
+  doPeephole = false;
+  doStoreLoadOpt = false;
+  doGlobalOpt = false;
+  doPreLSRAOpt = false;
+  doLocalRefSpill = false;
+  doCalleeToSpill = false;
+  doPreSchedule = false;
+  doSchedule = false;
+  doRegSavesOpt = false;
+  useSsaPreSave = false;
+  useSsuPreRestore = false;
+  doWriteRefFieldOpt = false;
+  doAlignAnalysis = false;
+  doCondBrAlign = false;
+
+  ClearOption(kUseStackProtectorStrong);
+  ClearOption(kUseStackProtectorAll);
+  ClearOption(kConstFold);
+  ClearOption(kProEpilogueOpt);
+  ClearOption(kTailCallOpt);
+}
+
+void CGOptions::SetTargetMachine(const std::string &str) {
+  if (str == "aarch64") {
+    targetArch = "aarch64";
+  } else if (str == "x86_64") {
+    targetArch = "x86_64";
+  }
+  CHECK_FATAL(false, "unknown target. not implement yet");
+}
+
+void CGOptions::SplitPhases(const std::string &str, std::unordered_set<std::string> &set) const {
+  const std::string& tmpStr{ str };
+  if ((tmpStr.compare("*") == 0) || (tmpStr.compare("cgir") == 0)) {
+    (void)set.insert(tmpStr);
+    return;
+  }
+  StringUtils::Split(tmpStr, set, ',');
+}
+
+bool CGOptions::DumpPhase(const std::string &phase) {
+  return (IS_STR_IN_SET(dumpPhases, "*") || IS_STR_IN_SET(dumpPhases, "cgir") || IS_STR_IN_SET(dumpPhases, phase));
+}
+
+/* match sub std::string of function name */
+bool CGOptions::FuncFilter(const std::string &name) {
+  return dumpFunc == "*" || dumpFunc == name;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cg_options.cpp b/src/mapleall/maple_be/src/cg/cg_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..635bb79df8ce3ad1e76ffcfa5d80fa9248c7e75e
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_options.cpp
@@ -0,0 +1,618 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "driver_options.h"
+
+#include <bits/stdint-uintn.h>
+#include <cstdint>
+#include <string>
+
+namespace opts::cg {
+
+maplecl::Option<bool> pie({"-fPIE", "--pie", "-pie"},
+                          "  --pie                       \tGenerate position-independent executable\n"
+                          "  --no-pie\n",
+                          {cgCategory, driverCategory, ldCategory},
+                          maplecl::DisableWith("--no-pie"));
+
+maplecl::Option<bool> fpic({"-fPIC", "--fpic", "-fpic"},
+                           "  --fpic                      \tGenerate position-independent shared library\n"
+                           "  --no-fpic\n",
+                           {cgCategory, driverCategory, ldCategory},
+                           maplecl::DisableWith("--no-fpic"));
+
+maplecl::Option<bool> verboseAsm({"--verbose-asm"},
+                                 "  --verbose-asm               \tAdd comments to asm output\n"
+                                 "  --no-verbose-asm\n",
+                                 {cgCategory},
+                                 maplecl::DisableWith("--no-verbose-asm"));
+
+maplecl::Option<bool> verboseCg({"--verbose-cg"},
+                                "  --verbose-cg               \tAdd comments to cg output\n"
+                                "  --no-verbose-cg\n",
+                                {cgCategory},
+                                maplecl::DisableWith("--no-verbose-cg"));
+
+maplecl::Option<bool> maplelinker({"--maplelinker"},
+                                  "  --maplelinker               \tGenerate the MapleLinker .s format\n"
+                                  "  --no-maplelinker\n",
+                                  {cgCategory},
+                                  maplecl::DisableWith("--no-maplelinker"));
+
+maplecl::Option<bool> quiet({"--quiet"},
+                            "  --quiet                     \tBe quiet (don't output debug messages)\n"
+                            "  --no-quiet\n",
+                            {cgCategory},
+                            maplecl::DisableWith("--no-quiet"));
+
+maplecl::Option<bool> cg({"--cg"},
+                         "  --cg                        \tGenerate the output .s file\n"
+                         "  --no-cg\n",
+                         {cgCategory},
+                         maplecl::DisableWith("--no-cg"));
+
+maplecl::Option<bool> replaceAsm({"--replaceasm"},
+                                 "  --replaceasm                \tReplace the the assembly code\n"
+                                 "  --no-replaceasm\n",
+                                 {cgCategory},
+                                 maplecl::DisableWith("--no-replaceasm"));
+
+maplecl::Option<bool> generalRegOnly({"--general-reg-only"},
+                                     " --general-reg-only           \tdisable floating-point or Advanced SIMD registers\n"
+                                     " --no-general-reg-only\n",
+                                     {cgCategory},
+                                     maplecl::DisableWith("--no-general-reg-only"));
+
+maplecl::Option<bool> lazyBinding({"--lazy-binding"},
+                                  "  --lazy-binding              \tBind class symbols lazily[default off]\n",
+                                  {cgCategory},
+                                  maplecl::DisableWith("--no-lazy-binding"));
+
+maplecl::Option<bool> hotFix({"--hot-fix"},
+                             "  --hot-fix                   \tOpen for App hot fix[default off]\n"
+                             "  --no-hot-fix\n",
+                             {cgCategory},
+                             maplecl::DisableWith("--no-hot-fix"));
+
+maplecl::Option<bool> ebo({"--ebo"},
+                          "  --ebo                       \tPerform Extend block optimization\n"
+                          "  --no-ebo\n",
+                          {cgCategory},
+                          maplecl::DisableWith("--no-ebo"));
+
+maplecl::Option<bool> cfgo({"--cfgo"},
+                           "  --cfgo                      \tPerform control flow optimization\n"
+                           "  --no-cfgo\n",
+                           {cgCategory},
+                           maplecl::DisableWith("--no-cfgo"));
+
+maplecl::Option<bool> ico({"--ico"},
+                          "  --ico                       \tPerform if-conversion optimization\n"
+                          "  --no-ico\n",
+                          {cgCategory},
+                          maplecl::DisableWith("--no-ico"));
+
+maplecl::Option<bool> storeloadopt({"--storeloadopt"},
+                                   "  --storeloadopt              \tPerform global store-load optimization\n"
+                                   "  --no-storeloadopt\n",
+                                   {cgCategory},
+                                   maplecl::DisableWith("--no-storeloadopt"));
+
+maplecl::Option<bool> globalopt({"--globalopt"},
+                                "  --globalopt                 \tPerform global optimization\n"
+                                "  --no-globalopt\n",
+                                {cgCategory},
+                                maplecl::DisableWith("--no-globalopt"));
+
+maplecl::Option<bool> hotcoldsplit({"--hotcoldsplit"},
+                                   "  --hotcoldsplit        \tPerform HotColdSplit optimization\n"
+                                   "  --no-hotcoldsplit\n",
+                                   {cgCategory},
+                                   maplecl::DisableWith("--no-hotcoldsplit"));
+
+maplecl::Option<bool> prelsra({"--prelsra"},
+                              "  --prelsra                   \tPerform live interval simplification in LSRA\n"
+                              "  --no-prelsra\n",
+                              {cgCategory},
+                              maplecl::DisableWith("--no-prelsra"));
+
+maplecl::Option<bool> lsraLvarspill({"--lsra-lvarspill"},
+                                    "  --lsra-lvarspill"
+                                    "            \tPerform LSRA spill using local ref var stack locations\n"
+                                    "  --no-lsra-lvarspill\n",
+                                    {cgCategory},
+                                    maplecl::DisableWith("--no-lsra-lvarspill"));
+
+maplecl::Option<bool> lsraOptcallee({"--lsra-optcallee"},
+                                    "  --lsra-optcallee            \tSpill callee if only one def to use\n"
+                                    "  --no-lsra-optcallee\n",
+                                    {cgCategory},
+                                    maplecl::DisableWith("--no-lsra-optcallee"));
+
+maplecl::Option<bool> calleeregsPlacement({"--calleeregs-placement"},
+                                          "  --calleeregs-placement      \tOptimize placement of callee-save registers\n"
+                                          "  --no-calleeregs-placement\n",
+                                          {cgCategory},
+                                          maplecl::DisableWith("--no-calleeregs-placement"));
+
+maplecl::Option<bool> ssapreSave({"--ssapre-save"},
+                                 "  --ssapre-save                \tUse ssapre algorithm to save callee-save registers\n"
+                                 "  --no-ssapre-save\n",
+                                 {cgCategory},
+                                 maplecl::DisableWith("--no-ssapre-save"));
+
+maplecl::Option<bool> ssupreRestore({"--ssupre-restore"},
+                                    "  --ssupre-restore"
+                                    "             \tUse ssupre algorithm to restore callee-save registers\n"
+                                    "  --no-ssupre-restore\n",
+                                    {cgCategory},
+                                    maplecl::DisableWith("--no-ssupre-restore"));
+
+maplecl::Option<bool> prepeep({"--prepeep"},
+                              "  --prepeep                   \tPerform peephole optimization before RA\n"
+                              "  --no-prepeep\n",
+                              {cgCategory},
+                              maplecl::DisableWith("--no-prepeep"));
+
+maplecl::Option<bool> peep({"--peep"},
+                           "  --peep                      \tPerform peephole optimization after RA\n"
+                           "  --no-peep\n",
+                           {cgCategory},
+                           maplecl::DisableWith("--no-peep"));
+
+maplecl::Option<bool> preschedule({"--preschedule"},
+                                  "  --preschedule               \tPerform prescheduling\n"
+                                  "  --no-preschedule\n",
+                                  {cgCategory},
+                                  maplecl::DisableWith("--no-preschedule"));
+
+maplecl::Option<bool> schedule({"--schedule"},
+                               "  --schedule                  \tPerform scheduling\n"
+                               "  --no-schedule\n",
+                               {cgCategory},
+                               maplecl::DisableWith("--no-schedule"));
+
+maplecl::Option<bool> retMerge({"--ret-merge"},
+                               "  --ret-merge                 \tMerge return bb into a single destination\n"
+                               "  --no-ret-merge              \tallows for multiple return bb\n",
+                               {cgCategory},
+                               maplecl::DisableWith("--no-ret-merge"));
+
+maplecl::Option<bool> vregRename({"--vreg-rename"},
+                                 "  --vreg-rename"
+                                 "                  \tPerform rename of long live range around loops in coloring RA\n"
+                                 "  --no-vreg-rename\n",
+                                 {cgCategory},
+                                 maplecl::DisableWith("--no-vreg-rename"));
+
+maplecl::Option<bool> fullcolor({"--fullcolor"},
+                                "  --fullcolor                  \tPerform multi-pass coloring RA\n"
+                                "  --no-fullcolor\n",
+                                {cgCategory},
+                                maplecl::DisableWith("--no-fullcolor"));
+
+maplecl::Option<bool> writefieldopt({"--writefieldopt"},
+                                    "  --writefieldopt                  \tPerform WriteRefFieldOpt\n"
+                                    "  --no-writefieldopt\n",
+                                    {cgCategory},
+                                    maplecl::DisableWith("--no-writefieldopt"));
+
+maplecl::Option<bool> dumpOlog({"--dump-olog"},
+                               "  --dump-olog                 \tDump CFGO and ICO debug information\n"
+                               "  --no-dump-olog\n",
+                               {cgCategory},
+                               maplecl::DisableWith("--no-dump-olog"));
+
+maplecl::Option<bool> nativeopt({"--nativeopt"},
+                                "  --nativeopt                 \tEnable native opt\n"
+                                "  --no-nativeopt\n",
+                                {cgCategory},
+                                maplecl::DisableWith("--no-nativeopt"));
+
+maplecl::Option<bool> objmap({"--objmap"},
+                             "  --objmap"
+                             "                    \tCreate object maps (GCTIBs) inside the main output (.s) file\n"
+                             "  --no-objmap\n",
+                             {cgCategory},
+                             maplecl::DisableWith("--no-objmap"));
+
+maplecl::Option<bool> yieldpoint({"--yieldpoint"},
+                                 "  --yieldpoint                \tGenerate yieldpoints [default]\n"
+                                 "  --no-yieldpoint\n",
+                                 {cgCategory},
+                                 maplecl::DisableWith("--no-yieldpoint"));
+
+maplecl::Option<bool> proepilogue({"--proepilogue"},
+                                  "  --proepilogue               \tDo tail call optimization and"
+                                  " eliminate unnecessary prologue and epilogue.\n"
+                                  "  --no-proepilogue\n",
+                                  {cgCategory},
+                                  maplecl::DisableWith("--no-proepilogue"));
+
+maplecl::Option<bool> localRc({"--local-rc"},
+                              "  --local-rc                  \tHandle Local Stack RC [default]\n"
+                              "  --no-local-rc\n",
+                              {cgCategory},
+                              maplecl::DisableWith("--no-local-rc"));
+
+maplecl::Option<bool> addDebugTrace({"--add-debug-trace"},
+                                    "  --add-debug-trace"
+                                    "           \tInstrumentation the output .s file to print call traces at runtime\n",
+                                    {cgCategory});
+
+
+maplecl::Option<std::string> classListFile({"--class-list-file"},
+                                           "  --class-list-file"
+                                           "           \tSet the class list file for the following generation options,\n"
+                                           "                              \tif not given, "
+                                           "generate for all visible classes\n"
+                                           "                              \t--class-list-file=class_list_file\n",
+                                           {cgCategory});
+
+maplecl::Option<bool> genCMacroDef({"--gen-c-macro-def"},
+                                   "  --gen-c-macro-def"
+                                   "           \tGenerate a .def file that contains extra type metadata, including the\n"
+                                   "                              \tclass instance sizes and field offsets (default)\n"
+                                   "  --no-gen-c-macro-def\n",
+                                   {cgCategory},
+                                   maplecl::DisableWith("--no-gen-c-macro-def"));
+
+maplecl::Option<bool> genGctibFile({"--gen-gctib-file"},
+                                   "  --gen-gctib-file"
+                                   "            \tGenerate a separate .s file for GCTIBs. Usually used together with\n"
+                                   "                              \t--no-objmap (not implemented yet)\n"
+                                   "  --no-gen-gctib-file\n",
+                                   {cgCategory},
+                                   maplecl::DisableWith("--no-gen-gctib-file"));
+
+maplecl::Option<bool> unwindTables({"--unwind-tables"},
+                            "  --unwind-tables                 \tgenerate unwind tables for function \n"
+                            "  --no-unwind-tables\n",
+                            {cgCategory},
+                            maplecl::DisableWith("--no-unwind-tables"));
+
+maplecl::Option<bool> debug({"-g", "--g"},
+                            "  -g                          \tGenerate debug information\n",
+                            {cgCategory});
+
+maplecl::Option<bool> gdwarf({"--gdwarf"},
+                             "  --gdwarf                    \tGenerate dwarf infomation\n",
+                             {cgCategory});
+
+maplecl::Option<bool> gsrc({"--gsrc"},
+                           "  --gsrc                      \tUse original source file instead of mpl file for debugging\n",
+                           {cgCategory});
+
+maplecl::Option<bool> gmixedsrc({"--gmixedsrc"},
+                                "  --gmixedsrc"
+                                "                 \tUse both original source file and mpl file for debugging\n",
+                                {cgCategory});
+
+maplecl::Option<bool> gmixedasm({"--gmixedasm"},
+                                "  --gmixedasm"
+                                "                 \tComment out both original source file and mpl file for debugging\n",
+                                {cgCategory});
+
+maplecl::Option<bool> profile({"--p", "-p"},
+                              "  -p                          \tGenerate profiling infomation\n",
+                              {cgCategory});
+
+maplecl::Option<bool> withRaLinearScan({"--with-ra-linear-scan"},
+                                       "  --with-ra-linear-scan       \tDo linear-scan register allocation\n",
+                                       {cgCategory});
+
+maplecl::Option<bool> withRaGraphColor({"--with-ra-graph-color"},
+                                       "  --with-ra-graph-color       \tDo coloring-based register allocation\n",
+                                       {cgCategory});
+
+maplecl::Option<bool> patchLongBranch({"--patch-long-branch"},
+                                      "  --patch-long-branch"
+                                      "         \tEnable patching long distance branch with jumping pad\n",
+                                      {cgCategory});
+
+maplecl::Option<bool> constFold({"--const-fold"},
+                                "  --const-fold                \tEnable constant folding\n"
+                                "  --no-const-fold\n",
+                                {cgCategory},
+                                maplecl::DisableWith("--no-const-fold"));
+
+maplecl::Option<std::string> ehExclusiveList({"--eh-exclusive-list"},
+                                             "  --eh-exclusive-list         \tFor generating gold files in unit testing\n"
+                                             "                              \t--eh-exclusive-list=list_file\n",
+                                             {cgCategory});
+
+maplecl::Option<bool> o0({"-O0", "--O0"},
+                         "  -O0                         \tNo optimization.\n",
+                         {cgCategory});
+
+maplecl::Option<bool> o1({"-O1", "--O1"},
+                         "  -O1                         \tDo some optimization.\n",
+                         {cgCategory});
+
+maplecl::Option<bool> o2({"-O2", "--O2"},
+                         "  -O2                          \tDo some optimization.\n",
+                         {cgCategory});
+
+maplecl::Option<bool> os({"-Os", "--Os"},
+                         "  -Os                          \tOptimize for size, based on O2.\n",
+                         {cgCategory});
+
+maplecl::Option<bool> olitecg({"-Olitecg", "--Olitecg"},
+                              " -Olitecg                       \tOptimize for litecg.\n",
+                              {cgCategory});
+
+maplecl::Option<uint64_t> lsraBb({"--lsra-bb"},
+                                 "  --lsra-bb=NUM"
+                                 "               \tSwitch to spill mode if number of bb in function exceeds NUM\n",
+                                 {cgCategory});
+
+maplecl::Option<uint64_t> lsraInsn({"--lsra-insn"},
+                                   "  --lsra-insn=NUM"
+                                   "             \tSwitch to spill mode if number of instructons in function exceeds NUM\n",
+                                   {cgCategory});
+
+maplecl::Option<uint64_t> lsraOverlap({"--lsra-overlap"},
+                                      "  --lsra-overlap=NUM          \toverlap NUM to decide pre spill in lsra\n",
+                                      {cgCategory});
+
+maplecl::Option<uint8_t> remat({"--remat"},
+                               "  --remat                     \tEnable rematerialization during register allocation\n"
+                               "                              \t     0: no rematerialization (default)\n"
+                               "                              \t  >= 1: rematerialize constants\n"
+                               "                              \t  >= 2: rematerialize addresses\n"
+                               "                              \t  >= 3: rematerialize local dreads\n"
+                               "                              \t  >= 4: rematerialize global dreads\n",
+                               {cgCategory});
+
+maplecl::Option<bool> suppressFileinfo({"--suppress-fileinfo"},
+                                       "  --suppress-fileinfo         \tFor generating gold files in unit testing\n",
+                                       {cgCategory});
+
+maplecl::Option<bool> dumpCfg({"--dump-cfg"},
+                              "  --dump-cfg\n",
+                              {cgCategory});
+
+maplecl::Option<std::string> target({"--target"},
+                                    "  --target=TARGETMACHINE \t generate code for TARGETMACHINE\n",
+                                    {cgCategory},
+                                    maplecl::optionalValue);
+
+maplecl::Option<std::string> dumpPhases({"--dump-phases"},
+                                        "  --dump-phases=PHASENAME,..."
+                                        " \tEnable debug trace for specified phases in the comma separated list\n",
+                                        {cgCategory});
+
+maplecl::Option<std::string> skipPhases({"--skip-phases"},
+                                        "  --skip-phases=PHASENAME,..."
+                                        " \tSkip the phases specified in the comma separated list\n",
+                                        {cgCategory});
+
+maplecl::Option<std::string> skipFrom({"--skip-from"},
+                                      "  --skip-from=PHASENAME       \tSkip the rest phases from PHASENAME(included)\n",
+                                      {cgCategory});
+
+maplecl::Option<std::string> skipAfter({"--skip-after"},
+                                       "  --skip-after=PHASENAME      \tSkip the rest phases after PHASENAME(excluded)\n",
+                                       {cgCategory});
+
+maplecl::Option<std::string> dumpFunc({"--dump-func"},
+                                      "  --dump-func=FUNCNAME"
+                                      "        \tDump/trace only for functions whose names contain FUNCNAME as substring\n"
+                                      "                              \t(can only specify once)\n",
+                                      {cgCategory});
+
+maplecl::Option<bool> timePhases({"--time-phases"},
+                                 "  --time-phases               \tCollect compilation time stats for each phase\n"
+                                 "  --no-time-phases            \tDon't Collect compilation time stats for each phase\n",
+                                 {cgCategory},
+                                 maplecl::DisableWith("--no-time-phases"));
+
+maplecl::Option<bool> useBarriersForVolatile({"--use-barriers-for-volatile"},
+                                             "  --use-barriers-for-volatile \tOptimize volatile load/str\n"
+                                             "  --no-use-barriers-for-volatile\n",
+                                             {cgCategory},
+                                             maplecl::DisableWith("--no-use-barriers-for-volatile"));
+
+maplecl::Option<std::string> range({"--range"},
+                                   "  --range=NUM0,NUM1           \tOptimize only functions in the range [NUM0, NUM1]\n",
+                                   {cgCategory});
+
+maplecl::Option<uint8_t> fastAlloc({"--fast-alloc"},
+                                   "  --fast-alloc=[0/1]          \tO2 RA fast mode, set to 1 to spill all registers\n",
+                                   {cgCategory});
+
+maplecl::Option<std::string> spillRange({"--spill_range"},
+                                        "  --spill_range=NUM0,NUM1     \tO2 RA spill registers in the range [NUM0, NUM1]\n",
+                                        {cgCategory});
+
+maplecl::Option<bool> dupBb({"--dup-bb"},
+                            "  --dup-bb                 \tAllow cfg optimizer to duplicate bb\n"
+                            "  --no-dup-bb              \tDon't allow cfg optimizer to duplicate bb\n",
+                            {cgCategory},
+                            maplecl::DisableWith("--no-dup-bb"));
+
+maplecl::Option<bool> calleeCfi({"--callee-cfi"},
+                                "  --callee-cfi                \tcallee cfi message will be generated\n"
+                                "  --no-callee-cfi             \tcallee cfi message will not be generated\n",
+                                {cgCategory},
+                                maplecl::DisableWith("--no-callee-cfi"));
+
+maplecl::Option<bool> printFunc({"--print-func"},
+                                "  --print-func\n"
+                                "  --no-print-func\n",
+                                {cgCategory},
+                                maplecl::DisableWith("--no-print-func"));
+
+maplecl::Option<std::string> cyclePatternList({"--cycle-pattern-list"},
+                                              "  --cycle-pattern-list        \tFor generating cycle pattern meta\n"
+                                              "                              \t--cycle-pattern-list=list_file\n",
+                                              {cgCategory});
+
+maplecl::Option<std::string> duplicateAsmList({"--duplicate_asm_list"},
+                                              "  --duplicate_asm_list        \tDuplicate asm functions to delete plt call\n"
+                                              "                              \t--duplicate_asm_list=list_file\n",
+                                              {cgCategory});
+
+maplecl::Option<std::string> duplicateAsmList2({"--duplicate_asm_list2"},
+                                               "  --duplicate_asm_list2"
+                                               "       \tDuplicate more asm functions to delete plt call\n"
+                                               "                              \t--duplicate_asm_list2=list_file\n",
+                                               {cgCategory});
+
+maplecl::Option<std::string> blockMarker({"--block-marker"},
+                                         "  --block-marker"
+                                         "              \tEmit block marker symbols in emitted assembly files\n",
+                                         {cgCategory});
+
+maplecl::Option<bool> soeCheck({"--soe-check"},
+                               "  --soe-check                 \tInsert a soe check instruction[default off]\n",
+                               {cgCategory});
+
+maplecl::Option<bool> checkArraystore({"--check-arraystore"},
+                                      "  --check-arraystore          \tcheck arraystore exception[default off]\n"
+                                      "  --no-check-arraystore\n",
+                                      {cgCategory},
+                                      maplecl::DisableWith("--no-check-arraystore"));
+
+maplecl::Option<bool> debugSchedule({"--debug-schedule"},
+                                    "  --debug-schedule            \tdump scheduling information\n"
+                                    "  --no-debug-schedule\n",
+                                    {cgCategory},
+                                    maplecl::DisableWith("--no-debug-schedule"));
+
+maplecl::Option<bool> bruteforceSchedule({"--bruteforce-schedule"},
+                                         "  --bruteforce-schedule       \tdo brute force schedule\n"
+                                         "  --no-bruteforce-schedule\n",
+                                         {cgCategory},
+                                         maplecl::DisableWith("--no-bruteforce-schedule"));
+
+maplecl::Option<bool> simulateSchedule({"--simulate-schedule"},
+                                       "  --simulate-schedule         \tdo simulate schedule\n"
+                                       "  --no-simulate-schedule\n",
+                                       {cgCategory},
+                                       maplecl::DisableWith("--no-simulate-schedule"));
+
+maplecl::Option<bool> crossLoc({"--cross-loc"},
+                               "  --cross-loc                 \tcross loc insn schedule\n"
+                               "  --no-cross-loc\n",
+                               {cgCategory},
+                               maplecl::DisableWith("--no-cross-loc"));
+
+maplecl::Option<std::string> floatAbi({"--float-abi"},
+                                      "  --float-abi=name            \tPrint the abi type.\n"
+                                      "                              \tname=hard: abi-hard (Default)\n"
+                                      "                              \tname=soft: abi-soft\n"
+                                      "                              \tname=softfp: abi-softfp\n",
+                                      {cgCategory});
+
+maplecl::Option<std::string> filetype({"--filetype"},
+                                      "  --filetype=name             \tChoose a file type.\n"
+                                      "                              \tname=asm: Emit an assembly file (Default)\n"
+                                      "                              \tname=obj: Emit an object file\n"
+                                      "                              \tname=null: not support yet\n",
+                                      {cgCategory});
+
+maplecl::Option<bool> longCalls({"--long-calls"},
+                                "  --long-calls                \tgenerate long call\n"
+                                "  --no-long-calls\n",
+                                {cgCategory},
+                                maplecl::DisableWith("--no-long-calls"));
+
+maplecl::Option<bool> functionSections({"--function-sections"},
+                                       " --function-sections           \t \n"
+                                       "  --no-function-sections\n",
+                                       {cgCategory},
+                                       maplecl::DisableWith("--no-function-sections"));
+
+maplecl::Option<bool> omitFramePointer({"--omit-frame-pointer", "-fomit-frame-pointer"},
+                                       " --omit-frame-pointer          \t do not use frame pointer \n"
+                                       " --no-omit-frame-pointer\n",
+                                       {cgCategory, driverCategory},
+                                       maplecl::DisableEvery({"--no-omit-frame-pointer",  "-fno-omit-frame-pointer"}));
+
+maplecl::Option<bool> fastMath({"--fast-math"},
+                               "  --fast-math                  \tPerform fast math\n"
+                               "  --no-fast-math\n",
+                               {cgCategory},
+                               maplecl::DisableWith("--no-fast-math"));
+
+maplecl::Option<bool> tailcall({"--tailcall"},
+                               "  --tailcall                   \tDo tail call optimization\n"
+                               "  --no-tailcall\n",
+                               {cgCategory},
+                               maplecl::DisableWith("--no-tailcall"));
+
+maplecl::Option<bool> alignAnalysis({"--align-analysis"},
+                                    "  --align-analysis                 \tPerform alignanalysis\n"
+                                    "  --no-align-analysis\n",
+                                    {cgCategory},
+                                    maplecl::DisableWith("--no-align-analysis"));
+
+maplecl::Option<bool> cgSsa({"--cg-ssa"},
+                            "  --cg-ssa                     \tPerform cg ssa\n"
+                            "  --no-cg-ssa\n",
+                            {cgCategory},
+                            maplecl::DisableWith("--no-cg-ssa"));
+
+maplecl::Option<bool> common({"--common", "-fcommon"},
+                             " --common           \t \n"
+                             " --no-common\n",
+                             {cgCategory, driverCategory},
+                             maplecl::DisableEvery({"--no-common", "-fno-common"}));
+
+maplecl::Option<bool> condbrAlign({"--condbr-align"},
+                                  "  --condbr-align                   \tPerform condbr align\n"
+                                  "  --no-condbr-align\n",
+                                  {cgCategory},
+                                  maplecl::DisableWith("--no-condbr-align"));
+
+maplecl::Option<uint32_t> alignMinBbSize({"--align-min-bb-size"},
+                                         " --align-min-bb-size=NUM"
+                                         "           \tO2 Minimum bb size for alignment   unit:byte\n",
+                                         {cgCategory});
+
+maplecl::Option<uint32_t> alignMaxBbSize({"--align-max-bb-size"},
+                                         " --align-max-bb-size=NUM"
+                                         "           \tO2 Maximum bb size for alignment   unit:byte\n",
+                                         {cgCategory});
+
+maplecl::Option<uint32_t> loopAlignPow({"--loop-align-pow"},
+                                       " --loop-align-pow=NUM           \tO2 loop bb align pow (NUM == 0, no loop-align)\n",
+                                       {cgCategory});
+
+maplecl::Option<uint32_t> jumpAlignPow({"--jump-align-pow"},
+                                       " --jump-align-pow=NUM           \tO2 jump bb align pow (NUM == 0, no jump-align)\n",
+                                       {cgCategory});
+
+maplecl::Option<uint32_t> funcAlignPow({"--func-align-pow"},
+                                       " --func-align-pow=NUM           \tO2 func bb align pow (NUM == 0, no func-align)\n",
+                                       {cgCategory});
+maplecl::Option<bool> litePgoGen({"--lite-pgo-gen"},
+                                 " --lite-pgo-gen           \tinstrumentation CG bb and generate bb-cnt info\n"
+                                 "  --no-lite-pgo-gen\n",
+                                 {cgCategory},
+                                 maplecl::DisableWith("--no-lite-pgo-gen"));
+maplecl::Option<std::string> instrumentationFile ({"--instrumentation-file"},
+                                                  "--instrumentation-file=filepath \t instrumentation function white list\n",
+                                                  {cgCategory});
+
+maplecl::Option<std::string> litePgoOutputFunc ({"--lite-pgo-output-func"},
+                                                 "--lite-pgo-output-func=function name \t genereate lite profile at the exit of the output function[default main]\n",
+                                                 {cgCategory});
+
+maplecl::Option<std::string> litePgoFile({"--lite-pgo-file"},
+                                         " --lite-pgo-file=filepath          \tlite pgo guide file\n",
+                                         {cgCategory});
+}
diff --git a/src/mapleall/maple_be/src/cg/cg_pgo_gen.cpp b/src/mapleall/maple_be/src/cg/cg_pgo_gen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a69ee1515bc91f5df5d118bc04c671faaf7cdd81
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_pgo_gen.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_pgo_gen.h"
+#include "optimize_common.h"
+#include "instrument.h"
+#include "cg.h"
+namespace maplebe {
+uint64 CGProfGen::counterIdx = 0;
+void CGProfGen::InstrumentFunction() {
+  instrumenter.PrepareInstrumentInfo(f->GetFirstBB(), f->GetCommonExitBB());
+  std::vector<maplebe::BB*> iBBs;
+  instrumenter.GetInstrumentBBs(iBBs, f->GetFirstBB());
+  /* skip large bb function currently due to offset in ldr/store */
+  if (iBBs.size() > kMaxPimm8) {
+    return;
+  }
+
+  uint32 oldTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  MIRSymbol *bbCounterTab = GetOrCreateProfSymForFunc(f->GetFunction(), static_cast<uint32>(iBBs.size() + 1U));
+  BECommon *be = Globals::GetInstance()->GetBECommon();
+  uint32 newTypeTableSize = GlobalTables::GetTypeTable().GetTypeTableSize();
+  if (newTypeTableSize != oldTypeTableSize) {
+    ASSERT(be, "get be in CGProfGen::InstrumentFunction() failed");
+    be->AddNewTypeAfterBecommon(oldTypeTableSize, newTypeTableSize);
+  }
+  for (uint32 i = 0; i < iBBs.size(); ++i) {
+    InstrumentBB(*iBBs[i], *bbCounterTab, i);
+  }
+}
+
+void CGProfGen::CreateProfileCalls() {
+  static bool created = false;
+  if (created) {
+    return;
+  }
+  created = true;
+
+  // Create symbol for recording call times
+  auto *mirBuilder = f->GetFunction().GetModule()->GetMIRBuilder();
+  auto *u64Type = GlobalTables::GetTypeTable().GetUInt64();
+  std::string symNameCallTimes = "MCC_profile_call_times";
+  auto *symCallTimes = mirBuilder->GetOrCreateGlobalDecl(symNameCallTimes, *u64Type);
+  MIRIntConst *constVal = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *u64Type);
+  symCallTimes->SetKonst(constVal);
+  symCallTimes->SetStorageClass(kScGlobal);
+
+  /* Insert ClearProfile */
+  CreateClearIcall(*f->GetFirstBB(), "MCC_ClearProfile");
+
+  /* Insert SaveProfile */
+  for (auto *bb : f->GetCommonExitBB()->GetPreds()) {
+    CreateIcallForWeakSymbol(*bb, "MCC_SaveProfile");
+  }
+}
+
+bool CgPgoGen::PhaseRun(maplebe::CGFunc &f) {
+  if (!LiteProfile::IsInWhiteList(f.GetName()) && f.GetName() != CGOptions::GetLitePgoOutputFunction()) {
+    return false;
+  }
+  CHECK_FATAL(f.NumBBs() < LiteProfile::GetBBNoThreshold(), "stop ! bb out of range!");
+
+  CGProfGen *cgProfGeg = f.GetCG()->CreateCGProfGen(*GetPhaseMemPool(), f);
+  cgProfGeg->InstrumentFunction();
+  if (f.GetName() == CGOptions::GetLitePgoOutputFunction()) {
+    cgProfGeg->CreateProfileCalls();
+  }
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgPgoGen, cgpgogen)
+}
diff --git a/src/mapleall/maple_be/src/cg/cg_pgo_use.cpp b/src/mapleall/maple_be/src/cg/cg_pgo_use.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..232e6ae4be70b141d0d5a403fb84d15979c92ede
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_pgo_use.cpp
@@ -0,0 +1,753 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_pgo_use.h"
+#include "cg_critical_edge.h"
+#include "loop.h"
+#include "optimize_common.h"
+namespace maplebe {
+bool CGProfUse::ApplyPGOData() {
+  instrumenter.PrepareInstrumentInfo(f->GetFirstBB(), f->GetCommonExitBB());
+  std::vector<maplebe::BB *> iBBs;
+  instrumenter.GetInstrumentBBs(iBBs, f->GetFirstBB());
+  /* skip large bb function currently due to offset in ldr/store */
+  if (iBBs.size() > kMaxPimm8) {
+    return false;
+  }
+  LiteProfile::BBInfo *bbInfo = f->GetFunction().GetModule()->GetLiteProfile().GetFuncBBProf(f->GetName());
+  if (bbInfo == nullptr) {
+    std::cout << "find profile for " << f->GetName() << "Failed" << std::endl;
+  }
+  CHECK_FATAL(bbInfo != nullptr, "Get profile Failed");
+
+  if (bbInfo->counter.size() != iBBs.size()) {
+    LogInfo::MapleLogger() << f->GetName() << " counter doesn't match profile counter "
+                           << bbInfo->counter.size() << " func real counter " << iBBs.size() << '\n';
+    CHECK_FATAL(false, "");
+    return false;
+  }
+
+  for (size_t i = 0; i < iBBs.size(); ++i) {
+    auto *bbUseInfo = GetOrCreateBBUseInfo(*iBBs[i]);
+    bbUseInfo->SetCount(bbInfo->counter[i]);
+  }
+
+  InitBBEdgeInfo();
+  ComputeEdgeFreq();
+
+  ApplyOnBB();
+#if DEBUG
+  f->GetTheCFG()->CheckCFGFreq();
+#endif
+  return true;
+}
+
+void CGProfUse::InitBBEdgeInfo() {
+  const std::vector<maple::BBUseEdge<maplebe::BB> *> &allEdges = instrumenter.GetAllEdges();
+  for (auto &e : allEdges) {
+    BB *src = e->GetSrcBB();
+    BB *dest = e->GetDestBB();
+    BBUseInfo<BB> *srcUseInfo = GetOrCreateBBUseInfo(*src);
+    srcUseInfo->AddOutEdge(e);
+    BBUseInfo<BB> *destUseInfo = GetOrCreateBBUseInfo(*dest);
+    destUseInfo->AddInEdge(e);
+  }
+  for (auto &e : allEdges) {
+    if (e->IsInMST()) {
+      continue;
+    }
+    BB *src = e->GetSrcBB();
+    BBUseInfo<BB> *srcUseInfo = GetOrCreateBBUseInfo(*src, true);
+    if (srcUseInfo->GetStatus() && srcUseInfo->GetOutEdgeSize() == 1) {
+      SetEdgeCount(*e, srcUseInfo->GetCount());
+    } else {
+      BB *dest = e->GetDestBB();
+      auto destUseInfo = GetOrCreateBBUseInfo(*dest, true);
+      if (destUseInfo->GetStatus() && destUseInfo->GetInEdgeSize() == 1) {
+        SetEdgeCount(*e, destUseInfo->GetCount());
+      }
+    }
+    if (e->GetStatus()) {
+      continue;
+    }
+    SetEdgeCount(*e, 0);
+  }
+}
+
+void CGProfUse::ComputeEdgeFreq() {
+  bool change = true;
+  size_t times = 0;
+  BB *commonEntry = f->GetFirstBB();
+  while (change) {
+    change = false;
+    times++;
+    CHECK_FATAL(times != UINT32_MAX, "parse all edges fail");
+    for (BB *curbb = commonEntry; curbb != nullptr; curbb = curbb->GetNext()) {
+      /* skip isolated bb */
+      if (curbb->GetSuccs().empty() && curbb->GetPreds().empty()) {
+        continue;
+      }
+      BBUseInfo<BB> *useInfo = GetOrCreateBBUseInfo(*curbb, true);
+      if (!useInfo) {
+        continue;
+      }
+      ComputeBBFreq(*useInfo, change);
+      if (useInfo->GetStatus()) {
+        if (useInfo->GetUnknownOutEdges() == 1) {
+          uint64 total = 0;
+          uint64 outCount = SumEdgesCount(useInfo->GetOutEdges());
+          if (useInfo->GetCount() > outCount) {
+            total = useInfo->GetCount() - outCount;
+          }
+          ASSERT(useInfo->GetCount() >= outCount, "find bad frequency");
+          /* set the only unknown edge frequency */
+          SetEdgeCount(*useInfo->GetOnlyUnknownOutEdges(), total);
+          change = true;
+        }
+        if (useInfo->GetUnknownInEdges() == 1) {
+          uint64 total = 0;
+          uint64 inCount = SumEdgesCount(useInfo->GetInEdges());
+          if (useInfo->GetCount() > inCount) {
+            total = useInfo->GetCount() - inCount;
+          }
+          ASSERT(useInfo->GetCount() >= inCount, "find bad frequency");
+          SetEdgeCount(*useInfo->GetOnlyUnknownInEdges(), total);
+          change = true;
+        }
+      }
+    }
+  }
+  if (debugChainLayout) {
+    LogInfo::MapleLogger() << "parse all edges in " << times << " times" << '\n';
+    LogInfo::MapleLogger() << f->GetName() << " succ compute all edges " << '\n';
+  }
+}
+
+void CGProfUse::ApplyOnBB() {
+  BB *commonEntry = f->GetFirstBB();
+  for (BB *curbb = commonEntry; curbb != nullptr; curbb = curbb->GetNext()) {
+    /* skip isolated bb */
+    if (curbb->GetSuccs().empty() && curbb->GetPreds().empty()) {
+      continue;
+    }
+    BBUseInfo<BB> *useInfo = GetOrCreateBBUseInfo(*curbb, true);
+    if (!useInfo) {
+      LogInfo::MapleLogger() << "find use info for bb " << curbb->GetId();
+      CHECK_FATAL(false, "");
+    }
+    curbb->SetFrequency(static_cast<uint32>(useInfo->GetCount()));
+    if (curbb == f->GetCommonExitBB()) {
+      continue;
+    }
+    curbb->InitEdgeFreq();
+    auto outEdges = useInfo->GetOutEdges();
+    for (auto *e : outEdges) {
+      auto *destBB = e->GetDestBB();
+      if (destBB == f->GetCommonExitBB()) {
+        continue;
+      }
+      curbb->SetEdgeFreq(*destBB, e->GetCount());
+    }
+  }
+}
+
+void CGProfUse::ComputeBBFreq(BBUseInfo<maplebe::BB> &bbInfo, bool &change) {
+  uint64 count = 0;
+  if (!bbInfo.GetStatus()) {
+    if (bbInfo.GetUnknownOutEdges() == 0) {
+      count = SumEdgesCount(bbInfo.GetOutEdges());
+      bbInfo.SetCount(count);
+      change = true;
+    } else if (bbInfo.GetUnknownInEdges() == 0) {
+      count = SumEdgesCount(bbInfo.GetInEdges());
+      bbInfo.SetCount(count);
+      change = true;
+    }
+  }
+}
+
+uint64 CGProfUse::SumEdgesCount(const MapleVector<BBUseEdge<maplebe::BB> *> &edges) const {
+  uint64 count = 0;
+  for (const auto &e : edges) {
+    count += e->GetCount();
+  }
+  return count;
+}
+
+void CGProfUse::SetEdgeCount(maple::BBUseEdge<maplebe::BB> &e, size_t count) {
+  if (!e.GetStatus()) {
+    e.SetCount(count);
+    BBUseInfo<BB> *srcUseInfo = GetOrCreateBBUseInfo(*(e.GetSrcBB()), true);
+    BBUseInfo<BB> *destUseInfo = GetOrCreateBBUseInfo(*(e.GetDestBB()), true);
+    srcUseInfo->DecreaseUnKnownOutEdges();
+    destUseInfo->DecreaseUnKnownInEdges();
+  }
+}
+
+BBUseInfo<maplebe::BB> *CGProfUse::GetOrCreateBBUseInfo(const maplebe::BB &bb, bool notCreate) {
+  auto item = bbProfileInfo.find(bb.GetId());
+  if (item != bbProfileInfo.end()) {
+    return item->second;
+  } else {
+    CHECK_FATAL(!notCreate, "do not create new bb useinfo in this case");
+    auto *newInfo = mp->New<BBUseInfo<maplebe::BB>>(*mp);
+    (void)bbProfileInfo.emplace(std::make_pair(bb.GetId(), newInfo));
+    return newInfo;
+  }
+}
+
+void CGProfUse::LayoutBBwithProfile() {
+  /* initialize */
+  laidOut.resize(f->GetAllBBs().size(), false);
+  /* BB chain layout */
+  BuildChainForFunc();
+  BBChain *mainChain = bb2chain[f->GetFirstBB()->GetId()];
+  for (auto bbId : bbSplit) {
+    BB *cbb = f->GetBBFromID(bbId);
+    CHECK_FATAL(cbb, "get bb failed");
+    f->GetTheCFG()->ReverseCriticalEdge(*cbb);
+  }
+  for (auto it = mainChain->begin(); it != mainChain->end(); ++it) {
+    if (!bbSplit.count((*it)->GetId())) {
+      AddBBProf(**it);
+    }
+  }
+}
+
+void CGProfUse::InitBBChains() {
+  uint32 id = 0;
+  bb2chain.resize(f->GetAllBBs().size(), nullptr);
+  BB *commonEntry = f->GetFirstBB();
+  for (BB *curbb = commonEntry; curbb != nullptr; curbb = curbb->GetNext()) {
+    // BBChain constructor will update bb2chain
+    // attention cleanup & unreachable
+    (void)mp->New<BBChain>(puAlloc, bb2chain, *curbb, id++);
+  }
+}
+
+void CGProfUse::BuildChainForFunc() {
+  uint32 validBBNum = 0;
+  BB *commonEntry = f->GetFirstBB();
+  // attention cleanup & unreachable
+  for (BB *curbb = commonEntry; curbb != nullptr; curbb = curbb->GetNext()) {
+    if (curbb->IsUnreachable()) {
+      ASSERT(false, "check unreachable bb");
+      continue;
+    }
+    if (f->IsExitBB(*curbb)) {
+      if (curbb->GetPrev() && curbb->GetPrev()->GetKind() == BB::kBBGoto &&
+          curbb->GetPreds().empty() && curbb->GetSuccs().empty()) {
+        continue;
+      }
+    }
+    ++validBBNum;
+  }
+  // --validBBNum;  // exclude cleanup BB
+  LogInfo::MapleLogger() << "\n[Chain layout] " << f->GetName() << ", valid bb num: " << validBBNum << std::endl;
+  InitBBChains();
+  BuildChainForLoops();
+  // init ready chains for func
+  for (BB *curbb = commonEntry; curbb != nullptr; curbb = curbb->GetNext()) {
+    uint32 bbId = curbb->GetId();
+    BBChain *chain = bb2chain[bbId];
+
+    if (chain->IsReadyToLayout(nullptr)) {
+      (void)readyToLayoutChains.insert(chain);
+    }
+  }
+  BBChain *entryChain = bb2chain[commonEntry->GetId()];
+  DoBuildChain(*commonEntry, *entryChain, nullptr);
+
+  /* merge clean up */
+  if (f->GetCleanupBB()) {
+    BBChain *cleanup = bb2chain[f->GetCleanupBB()->GetId()];
+    if (readyToLayoutChains.find(cleanup) == readyToLayoutChains.end()) {
+      LogInfo::MapleLogger() << "clean up bb is not in ready layout ";
+    }
+    entryChain->MergeFrom(cleanup);
+  }
+  /* merge symbol label in C which is not in control flow */
+  std::vector<BB*> labelBB;
+  {
+    for (BB *curbb = commonEntry; curbb != nullptr; curbb = curbb->GetNext()) {
+      if (curbb->IsUnreachable()) {
+        /* delete unreachable bb in cfgo */
+        ASSERT(false, "check unreachable bb");
+        continue;
+      }
+      if (f->IsExitBB(*curbb)) {
+        if (curbb->GetPrev() && curbb->GetPrev()->GetKind() == BB::kBBGoto &&
+            curbb->GetPreds().empty() && curbb->GetSuccs().empty()) {
+          continue;
+        }
+      }
+      if (!entryChain->FindBB(*curbb)) {
+        if (curbb->GetPreds().empty() && CGCFG::InSwitchTable(curbb->GetLabIdx(), *f)) {
+          labelBB.push_back(curbb);
+        } else {
+          LogInfo::MapleLogger() << "In function " << f->GetName() << " bb " << curbb->GetId() << "  is no in chain\n";
+        }
+      }
+    }
+
+    for (auto bb : labelBB) {
+      BBChain *labelchain = bb2chain[bb->GetId()];
+      if (readyToLayoutChains.find(labelchain) == readyToLayoutChains.end()) {
+        LogInfo::MapleLogger() << "label bb is not in ready layout ";
+      }
+      entryChain->MergeFrom(labelchain);
+      bb->SetNext(nullptr);
+      bb->SetPrev(nullptr);
+    }
+  }
+
+  // To sure all of BBs have been laid out
+  CHECK_FATAL(entryChain->size() == validBBNum, "has any BB not been laid out?");
+}
+
+void CGProfUse::BuildChainForLoops() {
+  if (f->GetLoops().empty()) {
+    return;
+  }
+  auto &loops = f->GetLoops();
+  // sort loops from inner most to outer most
+  std::stable_sort(loops.begin(), loops.end(), [](const CGFuncLoops *loop1, const CGFuncLoops *loop2) {
+    return loop1->GetLoopLevel() > loop2->GetLoopLevel();
+  });
+  auto *context = mp->New<MapleVector<bool>>(f->GetAllBBs().size(), false, puAlloc.Adapter());
+  for (auto *loop : loops) {
+    BuildChainForLoop(*loop, context);
+  }
+}
+
+void CGProfUse::BuildChainForLoop(CGFuncLoops &loop, MapleVector<bool> *context) {
+  // init loop context
+  std::fill(context->begin(), context->end(), false);
+  for (auto *bbMember : loop.GetLoopMembers()) {
+    CHECK_FATAL(bbMember->GetId() < context->size(), "index out of range");
+    (*context)[bbMember->GetId()] = true;
+  }
+  // init ready chains for loop
+  for (auto *bbMember : loop.GetLoopMembers()) {
+    BBChain *chain = bb2chain[bbMember->GetId()];
+    if (chain->IsReadyToLayout(context)) {
+      (void)readyToLayoutChains.insert(chain);
+    }
+  }
+  // find loop chain starting BB
+  BB *startBB = FindBestStartBBForLoop(loop, context);
+  if (startBB == nullptr) {
+    return;  // all blocks in the loop have been laid out, just return
+  }
+  BBChain *startChain = bb2chain[startBB->GetId()];
+  DoBuildChain(*startBB, *startChain, context);
+  readyToLayoutChains.clear();
+}
+
+// Multiple loops may share the same header, we try to find the best unplaced BB in the loop
+BB *CGProfUse::FindBestStartBBForLoop(CGFuncLoops &loop, const MapleVector<bool> *context) {
+  auto *headerChain = bb2chain[loop.GetHeader()->GetId()];
+  if (headerChain->size() == 1) {
+    return loop.GetHeader();
+  }
+  // take inner loop chain tail BB as start BB
+  if (headerChain->size() > 1 && IsBBInCurrContext(*headerChain->GetTail(), context)) {
+    return headerChain->GetTail();
+  }
+  for (auto *bbMember : loop.GetLoopMembers()) {
+    if (bb2chain[bbMember->GetId()]->size() == 1) {
+      return f->GetBBFromID(bbMember->GetId());
+    }
+  }
+  return nullptr;
+}
+
+bool CGProfUse::IsBBInCurrContext(const BB &bb, const MapleVector<bool> *context) const {
+  if (context == nullptr) {
+    return true;
+  }
+  return (*context)[bb.GetId()];
+}
+
+void CGProfUse::DoBuildChain(const BB &header, BBChain &chain, const MapleVector<bool> *context) {
+  CHECK_FATAL(bb2chain[header.GetId()] == &chain, "bb2chain mis-match");
+  BB *bb = chain.GetTail();
+  BB *bestSucc = GetBestSucc(*bb, chain, context, true);
+  while (bestSucc != nullptr) {
+    BBChain *succChain = bb2chain[bestSucc->GetId()];
+    succChain->UpdateSuccChainBeforeMerged(chain, context, readyToLayoutChains);
+    chain.MergeFrom(succChain);
+    (void)readyToLayoutChains.erase(succChain);
+    bb = chain.GetTail();
+    bestSucc = GetBestSucc(*bb, chain, context, true);
+  }
+
+  if (debugChainLayout) {
+    bool inLoop = context != nullptr;
+    LogInfo::MapleLogger() << "Finish forming " << (inLoop ? "loop" : "func") << " chain: ";
+    chain.Dump();
+  }
+}
+
+BB *CGProfUse::GetBestSucc(BB &bb, const BBChain &chain, const MapleVector<bool> *context, bool considerBetterPred) {
+  // (1) search in succ
+  CHECK_FATAL(bb2chain[bb.GetId()] == &chain, "bb2chain mis-match");
+  uint64 bestEdgeFreq = 0;
+  BB *bestSucc = nullptr;
+  auto iterBB = bb.GetSuccsBegin();
+  for (uint32 i = 0; i < bb.GetSuccs().size(); ++i, ++iterBB) {
+    CHECK_FATAL(iterBB != bb.GetSuccsEnd(), "check unexpect BB");
+    BB *succ = *iterBB;
+    CHECK_FATAL(succ, "check Empty BB");
+    if (!IsCandidateSucc(bb, *succ, context)) {
+      continue;
+    }
+    if (considerBetterPred && HasBetterLayoutPred(bb, *succ)) {
+      continue;
+    }
+    uint64 currEdgeFreq = bb.GetEdgeFreq(i);  // attention: entryBB->succFreq[i] is always 0
+    if (bb.GetId() == 0) {  // special case for common entry BB
+      CHECK_FATAL(bb.GetSuccs().size() == 1, "common entry BB should not have more than 1 succ");
+      bestSucc = succ;
+      break;
+    }
+    if (currEdgeFreq > bestEdgeFreq) {  // find max edge freq
+      bestEdgeFreq = currEdgeFreq;
+      bestSucc = succ;
+    }
+  }
+  if (bestSucc != nullptr) {
+    if (debugChainLayout) {
+      LogInfo::MapleLogger() << "Select [range1 succ ]: ";
+      LogInfo::MapleLogger() << bb.GetId() << " -> " << bestSucc->GetId() << std::endl;
+    }
+    return bestSucc;
+  }
+
+  // (2) search in readyToLayoutChains
+  uint32 bestFreq = 0;
+  for (auto it = readyToLayoutChains.begin(); it != readyToLayoutChains.end(); ++it) {
+    BBChain *readyChain = *it;
+    BB *header = readyChain->GetHeader();
+    if (!IsCandidateSucc(bb, *header, context)) {
+      continue;
+    }
+    bool useBBFreq = false;
+    if (useBBFreq) { // use bb freq
+      if (header->GetFrequency() > bestFreq) {  // find max bb freq
+        bestFreq = header->GetFrequency();
+        bestSucc = header;
+      }
+    } else { // use edge freq
+      uint32 subBestFreq = 0;
+      for (auto *pred : header->GetPreds()) {
+        uint32 curFreq = static_cast<uint32>(pred->GetEdgeFreq(*header));
+        if (curFreq > subBestFreq) {
+          subBestFreq = curFreq;
+        }
+      }
+      if (subBestFreq > bestFreq) {
+        bestFreq = subBestFreq;
+        bestSucc = header;
+      } else if (subBestFreq == bestFreq && bestSucc != nullptr &&
+                 bb2chain[header->GetId()]->GetId() < bb2chain[bestSucc->GetId()]->GetId()) {
+        bestSucc = header;
+      }
+    }
+  }
+  if (bestSucc != nullptr) {
+    (void)readyToLayoutChains.erase(bb2chain[bestSucc->GetId()]);
+    if (debugChainLayout) {
+      LogInfo::MapleLogger() << "Select [range2 ready]: ";
+      LogInfo::MapleLogger() << bb.GetId() << " -> " << bestSucc->GetId() << std::endl;
+    }
+    return bestSucc;
+  }
+
+  // (3) search left part in context by topological sequence
+  const auto &rpoVec = domInfo->GetReversePostOrder();
+  bool searchedAgain = false;
+  for (uint32 i = rpoSearchPos; i < rpoVec.size(); ++i) {
+    BB *candBB = rpoVec[i];
+    if (IsBBInCurrContext(*candBB, context) && bb2chain[candBB->GetId()] != &chain) {
+      rpoSearchPos = i;
+      if (debugChainLayout) {
+        LogInfo::MapleLogger() << "Select [range3 rpot ]: ";
+        LogInfo::MapleLogger() << bb.GetId() << " -> " << candBB->GetId() << std::endl;
+      }
+      return candBB;
+    }
+    if (i == rpoVec.size() - 1 && !searchedAgain) {
+      i = 0;
+      searchedAgain = true;
+    }
+  }
+  return nullptr;
+}
+
+bool CGProfUse::HasBetterLayoutPred(const BB &bb, const BB &succ) const {
+  auto &predList = succ.GetPreds();
+  // predList.size() may be 0 if bb is common entry BB
+  if (predList.size() <= 1) {
+    return false;
+  }
+  uint32 sumEdgeFreq = succ.GetFrequency();
+  const double hotEdgeFreqPercent = 0.6;  // should further fine tuning
+  uint64 hotEdgeFreq = static_cast<uint64>(sumEdgeFreq * hotEdgeFreqPercent);
+  // if edge freq(bb->succ) contribute more than 60% to succ block freq, no better layout pred than bb
+  for (auto predIt = predList.begin(); predIt != predList.end(); ++predIt) {
+    if (*predIt == &bb) {
+      continue;
+    }
+    uint64 edgeFreq = (*predIt)->GetEdgeFreq(succ);
+    if (edgeFreq > (sumEdgeFreq - hotEdgeFreq)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool CGProfUse::IsCandidateSucc(const BB &bb, const BB &succ, const MapleVector<bool> *context) {
+  if (!IsBBInCurrContext(succ, context)) { // succ must be in the current context (current loop or current func)
+    return false;
+  }
+  if (bb2chain[succ.GetId()] == bb2chain[bb.GetId()]) { // bb and succ should belong to different chains
+    return false;
+  }
+  if (succ.GetId() == 1) { // special case, exclude common exit BB
+    return false;
+  }
+  return true;
+}
+
+bool CgPgoUse::PhaseRun(maplebe::CGFunc &f) {
+  CHECK_FATAL(f.NumBBs() < LiteProfile::GetBBNoThreshold(), "stop ! bb out of range!");
+  if (!LiteProfile::IsInWhiteList(f.GetName())) {
+    return false;
+  }
+
+  // for 525 538 only
+  LiteProfile::BBInfo *bbInfo = f.GetFunction().GetModule()->GetLiteProfile().GetFuncBBProf(f.GetName());
+  if (!bbInfo) {
+    return false;
+  }
+
+  MemPool *memPool = GetPhaseMemPool();
+  auto *split = memPool->New<CriticalEdge>(f, *memPool);
+  f.GetTheCFG()->InitInsnVisitor(f);
+  split->CollectCriticalEdges();
+  split->SplitCriticalEdges();
+  MapleSet<uint32> newbbinsplit = split->CopyNewBBInfo();
+
+  MaplePhase *it = GetAnalysisInfoHook()->
+      ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgDomAnalysis::id, f);
+  auto *domInfo = static_cast<CgDomAnalysis*>(it)->GetResult();
+
+  (void)GetAnalysisInfoHook()->
+      ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgLoopAnalysis::id, f);
+
+  CHECK_FATAL(domInfo, "find dom failed");
+  CGProfUse pUse(f, *memPool, domInfo, newbbinsplit);
+  if (pUse.ApplyPGOData()) {
+    pUse.LayoutBBwithProfile();
+  }
+
+  if (f.GetName() == "LBM_performStreamCollideTRT") {
+    LogInfo::MapleLogger() << "After applying pgo : " << f.GetName() << "\n";
+    DotGenerator::GenerateDot("litePGO", f, f.GetMirModule(), true);
+  }
+
+  uint64 count = 0;
+  FOR_ALL_BB(bb, &f) {
+    count++;
+    if (count > f.GetAllBBs().size()) {
+      CHECK_FATAL(false, "infinte loop");
+    }
+  }
+  return false;
+}
+
+MAPLE_TRANSFORM_PHASE_REGISTER(CgPgoUse, cgpgouse)
+
+void RelinkBB(BB &prev, BB &next) {
+  prev.SetNext(&next);
+  next.SetPrev(&prev);
+}
+
+void CGProfUse::AddBBProf(BB &bb) {
+  if (layoutBBs.empty()) {
+    AddBB(bb);
+    return;
+  }
+  BB *curBB = layoutBBs.back();
+  if ((curBB->GetKind() == BB::kBBFallthru || curBB->GetKind() == BB::kBBGoto) && !curBB->GetSuccs().empty()) {
+    BB *targetBB = curBB->GetSuccs().front();
+    CHECK_FATAL(!bbSplit.count(targetBB->GetId()), "check split bb");
+    if (curBB->GetKind() == BB::kBBFallthru && (&bb != targetBB)) {
+      ReTargetSuccBB(*curBB, *targetBB);
+    } else if (curBB->GetKind() == BB::kBBGoto && (&bb == targetBB)) {
+      // delete the goto
+      ChangeToFallthruFromGoto(*curBB);
+    }
+  } else if (curBB->GetKind() == BB::kBBIf) {
+    CHECK_FATAL(curBB->GetSuccs().size() <= kSuccSizeOfIfBB, " if bb have more than 2 succs");
+    CHECK_FATAL(!curBB->GetSuccs().empty(), " if bb have no succs");
+    BB *targetBB = CGCFG::GetTargetSuc(*curBB);
+    BB *ftBB = nullptr;
+    for (BB *sucBB : curBB->GetSuccs()) {
+      if (sucBB != targetBB) {
+        ftBB = sucBB;
+      }
+    }
+    if (curBB->GetSuccs().size() == 1 && targetBB != curBB->GetNext()) {
+      CHECK_FATAL(false, " only 1 succs for if bb and ft not equal to target");
+    }
+    if (curBB->GetSuccs().size() == 1 && targetBB == curBB->GetNext()) {
+      ftBB = targetBB;
+    }
+    if (!ftBB && curBB->GetSuccs().size() == kSuccSizeOfIfBB) {
+      auto bIt = curBB->GetSuccs().begin();
+      BB *firstSucc = *bIt++;
+      BB *secondSucc = *bIt;
+      if (firstSucc == secondSucc) {
+        ftBB = targetBB;
+      }
+    }
+    CHECK_FATAL(ftBB, "find ft bb after ifBB failed");
+    if (&bb == targetBB) {
+      CHECK_FATAL(!bbSplit.count(ftBB->GetId()), "check split bb");
+      LabelIdx fallthruLabel = ftBB->GetLabIdx();
+      if (fallthruLabel == MIRLabelTable::GetDummyLabel()) {
+        fallthruLabel = f->CreateLabel();
+        ftBB->SetLabIdx(fallthruLabel);
+      }
+      f->GetTheCFG()->GetInsnModifier()->FlipIfBB(*curBB, fallthruLabel);
+    } else if (&bb != ftBB) {
+      CHECK_FATAL(!bbSplit.count(targetBB->GetId()), "check split bb");
+      BB *newBB = f->GetTheCFG()->GetInsnModifier()->CreateGotoBBAfterCondBB(*curBB, *ftBB, targetBB == ftBB);
+      CHECK_FATAL(newBB, "create goto failed");
+      newBB->SetFrequency(ftBB->GetFrequency());
+      laidOut.push_back(false);
+      RelinkBB(*curBB, *newBB);
+      AddBB(*newBB);
+      curBB = newBB;
+    }
+  } else if (curBB->GetKind() == BB::kBBIntrinsic) {
+    CHECK_FATAL(false, "check intrinsic bb");
+  }
+  RelinkBB(*curBB, bb);
+  AddBB(bb);
+}
+
+void CGProfUse::ReTargetSuccBB(BB &bb, BB &fallthru) {
+  LabelIdx fallthruLabel = fallthru.GetLabIdx();
+  if (fallthruLabel == MIRLabelTable::GetDummyLabel()) {
+    fallthruLabel = f->CreateLabel();
+    fallthru.SetLabIdx(fallthruLabel);
+  }
+  f->GetTheCFG()->GetInsnModifier()->ReTargetSuccBB(bb, fallthruLabel);
+  bb.SetKind(BB::kBBGoto);
+}
+
+void CGProfUse::ChangeToFallthruFromGoto(BB &bb) {
+  CHECK_FATAL(bb.GetLastMachineInsn(), "Get last insn in GOTO bb failed");
+  bb.RemoveInsn(*bb.GetLastMachineInsn());
+  bb.SetKind(BB::kBBFallthru);
+}
+
+void CGProfUse::AddBB(BB &bb) {
+  CHECK_FATAL(bb.GetId() < laidOut.size(), "index out of range in BBLayout::AddBB");
+  CHECK_FATAL(!laidOut[bb.GetId()], "AddBB: bb already laid out");
+  layoutBBs.push_back(&bb);
+  laidOut[bb.GetId()] = true;
+
+  if (bb.GetKind() == BB::kBBReturn) {
+    CHECK_FATAL(bb.GetSuccs().empty(), " common entry?");
+    bb.SetNext(nullptr);
+  }
+
+  // If the pred bb is goto bb and the target bb of goto bb is the current bb which is be added to layoutBBs, change the
+  // goto bb to fallthru bb.
+  if (layoutBBs.size() > 1) {
+    BB *predBB = layoutBBs.at(layoutBBs.size() - 2); // Get the pred of bb.
+    if (predBB->GetKind() != BB::kBBGoto) {
+      return;
+    }
+    if (predBB->GetSuccs().front() != &bb) {
+      return;
+    }
+    CHECK_FATAL(false, " implement ft bb to goto bb optimize ");
+    ChangeToFallthruFromGoto(*predBB);
+  }
+}
+
+void BBChain::MergeFrom(BBChain *srcChain) {
+  CHECK_FATAL(this != srcChain, "merge same chain?");
+  ASSERT_NOT_NULL(srcChain);
+  if (srcChain->empty()) {
+    return;
+  }
+  for (BB *bb : *srcChain) {
+    bbVec.push_back(bb);
+    bb2chain[bb->GetId()] = this;
+  }
+  srcChain->bbVec.clear();
+  srcChain->unlaidPredCnt = 0;
+  srcChain->isCacheValid = false;
+  isCacheValid = false;  // is this necessary?
+}
+
+void BBChain::UpdateSuccChainBeforeMerged(const BBChain &destChain, const MapleVector<bool> *context,
+                                          MapleSet<BBChain *> &readyToLayoutChains) {
+  for (BB *bb : bbVec) {
+    for (BB *succ : bb->GetSuccs()) {
+      if (context != nullptr && !(*context)[succ->GetId()]) {
+        continue;
+      }
+      if (bb2chain[succ->GetId()] == this || bb2chain[succ->GetId()] == &destChain) {
+        continue;
+      }
+      BBChain *succChain = bb2chain[succ->GetId()];
+      succChain->MayRecalculateUnlaidPredCnt(context);
+      if (succChain->unlaidPredCnt != 0) {
+        --succChain->unlaidPredCnt;
+      }
+      if (succChain->unlaidPredCnt == 0) {
+        (void)readyToLayoutChains.insert(succChain);
+      }
+    }
+  }
+}
+
+void BBChain::MayRecalculateUnlaidPredCnt(const MapleVector<bool> *context) {
+  if (isCacheValid) {
+    return;  // If cache is trustable, no need to recalculate
+  }
+  unlaidPredCnt = 0;
+  for (BB *bb : bbVec) {
+    for (BB *pred : bb->GetPreds()) {
+      // exclude blocks out of context
+      if (context != nullptr && !(*context)[pred->GetId()]) {
+        continue;
+      }
+      // exclude blocks within the same chain
+      if (bb2chain[pred->GetId()] == this) {
+        continue;
+      }
+      ++unlaidPredCnt;
+    }
+  }
+  isCacheValid = true;
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/cg_phasemanager.cpp b/src/mapleall/maple_be/src/cg/cg_phasemanager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0285694e1fc83ecf98dd8230954d7778e5d7800b
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_phasemanager.cpp
@@ -0,0 +1,549 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_phasemanager.h"
+#include <vector>
+#include <string>
+#include "cg_option.h"
+#include "args.h"
+#include "label_creation.h"
+#include "isel.h"
+#include "offset_adjust.h"
+#include "alignment.h"
+#include "yieldpoint.h"
+#include "emit.h"
+#include "reg_alloc.h"
+#include "target_info.h"
+#include "standardize.h"
+#if TARGAARCH64
+#include "aarch64_emitter.h"
+#include "aarch64_cg.h"
+#elif TARGRISCV64
+#include "riscv64_emitter.h"
+#elif TARGX86_64
+#include "x64_cg.h"
+#include "x64_emitter.h"
+#include "string_utils.h"
+#endif
+
+namespace maplebe {
+#define JAVALANG (module.IsJavaModule())
+#define CLANG (module.GetSrcLang() == kSrcLangC)
+
+#define RELEASE(pointer)      \
+  do {                        \
+    if (pointer != nullptr) { \
+      delete pointer;         \
+      pointer = nullptr;      \
+    }                         \
+  } while (0)
+
+namespace {
+
+void DumpMIRFunc(MIRFunction &func, const char *msg, bool printAlways = false, const char* extraMsg = nullptr) {
+  bool dumpAll = (CGOptions::GetDumpPhases().find("*") != CGOptions::GetDumpPhases().end());
+  bool dumpFunc = CGOptions::FuncFilter(func.GetName());
+  if (printAlways || (dumpAll && dumpFunc)) {
+    LogInfo::MapleLogger() << msg << '\n';
+    func.Dump();
+    if (extraMsg) {
+      LogInfo::MapleLogger() << extraMsg << '\n';
+    }
+  }
+}
+
+} /* anonymous namespace */
+
+void CgFuncPM::GenerateOutPutFile(MIRModule &m) const {
+  CHECK_FATAL(cg != nullptr, "cg is null");
+  CHECK_FATAL(cg->GetEmitter(), "emitter is null");
+  if (!cgOptions->SuppressFileInfo()) {
+    cg->GetEmitter()->EmitFileInfo(m.GetInputFileName());
+  }
+  if (cgOptions->WithDwarf()) {
+    cg->GetEmitter()->EmitDIHeader();
+  }
+  InitProfile(m);
+}
+
+bool CgFuncPM::FuncLevelRun(CGFunc &cgFunc, AnalysisDataManager &serialADM) {
+  bool changed = false;
+  for (size_t i = 0; i < phasesSequence.size(); ++i) {
+    SolveSkipFrom(CGOptions::GetSkipFromPhase(), i);
+    const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+    if (!IsQuiet()) {
+      LogInfo::MapleLogger() << "---Run MplCG " << (curPhase->IsAnalysis() ? "analysis" : "transform")
+                             << " Phase [ " << curPhase->PhaseName() << " ]---\n";
+    }
+    if (curPhase->IsAnalysis()) {
+      changed = RunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(*curPhase, serialADM, cgFunc) || changed;
+    } else  {
+      changed = RunTransformPhase<MapleFunctionPhase<CGFunc>, CGFunc>(*curPhase, serialADM, cgFunc) || changed;
+      DumpFuncCGIR(cgFunc, curPhase->PhaseName());
+    }
+    SolveSkipAfter(CGOptions::GetSkipAfterPhase(), i);
+  }
+  return changed;
+}
+
+void CgFuncPM::PostOutPut(MIRModule &m) const {
+  cg->GetEmitter()->EmitHugeSoRoutines(true);
+  if (cgOptions->WithDwarf()) {
+    cg->GetEmitter()->EmitDIFooter();
+  }
+  /* Emit global info */
+  EmitGlobalInfo(m);
+}
+
+void MarkUsedStaticSymbol(const StIdx &symbolIdx);
+std::map<StIdx, bool> visitedSym;
+
+void CollectStaticSymbolInVar(MIRConst *mirConst) {
+  if (mirConst->GetKind() == kConstAddrof) {
+    auto *addrSymbol = static_cast<MIRAddrofConst*>(mirConst);
+    MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(addrSymbol->GetSymbolIndex().Idx(), true);
+    if (sym != nullptr) {
+      MarkUsedStaticSymbol(sym->GetStIdx());
+    }
+  } else if (mirConst->GetKind() == kConstAggConst) {
+    auto &constVec = static_cast<MIRAggConst*>(mirConst)->GetConstVec();
+    for (auto &cst : constVec) {
+      CollectStaticSymbolInVar(cst);
+    }
+  }
+}
+
+void MarkUsedStaticSymbol(const StIdx &symbolIdx) {
+  if (!symbolIdx.IsGlobal()) {
+    return;
+  }
+  MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolIdx.Idx(), true);
+  if (symbol == nullptr) {
+    return;
+  }
+  if (visitedSym[symbolIdx]) {
+    return;
+  } else {
+    visitedSym[symbolIdx] = true;
+  }
+  symbol->ResetIsDeleted();
+  if (symbol->IsConst()) {
+    auto *konst = symbol->GetKonst();
+    CollectStaticSymbolInVar(konst);
+  }
+}
+
+void RecursiveMarkUsedStaticSymbol(const BaseNode *baseNode) {
+  if (baseNode == nullptr) {
+    return;
+  }
+  Opcode op = baseNode->GetOpCode();
+  switch (op) {
+    case OP_block: {
+      const BlockNode *blk = static_cast<const BlockNode*>(baseNode);
+      for (auto &stmt : blk->GetStmtNodes()) {
+        RecursiveMarkUsedStaticSymbol(&stmt);
+      }
+      break;
+    }
+    case OP_dassign: {
+      const DassignNode *dassignNode = static_cast<const DassignNode*>(baseNode);
+      MarkUsedStaticSymbol(dassignNode->GetStIdx());
+      break;
+    }
+    case OP_addrof:
+    case OP_addrofoff:
+    case OP_dread: {
+      const AddrofNode *dreadNode = static_cast<const AddrofNode*>(baseNode);
+      MarkUsedStaticSymbol(dreadNode->GetStIdx());
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  for (size_t i = 0; i < baseNode->NumOpnds(); ++i) {
+    RecursiveMarkUsedStaticSymbol(baseNode->Opnd(i));
+  }
+}
+
+void CollectStaticSymbolInFunction(MIRFunction &func) {
+  RecursiveMarkUsedStaticSymbol(func.GetBody());
+}
+
+void CgFuncPM::SweepUnusedStaticSymbol(MIRModule &m) const {
+  if (!m.IsCModule()) {
+    return;
+  }
+  size_t size = GlobalTables::GetGsymTable().GetSymbolTableSize();
+  for (size_t i = 0; i < size; ++i) {
+    MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(static_cast<uint32>(i));
+    if (mirSymbol != nullptr && (mirSymbol->GetSKind() == kStVar || mirSymbol->GetSKind() == kStConst) &&
+        (mirSymbol->GetStorageClass() == kScFstatic || mirSymbol->GetStorageClass() == kScPstatic)) {
+      mirSymbol->SetIsDeleted();
+    }
+  }
+
+  visitedSym.clear();
+  /* scan all funtions  */
+  std::vector<MIRFunction*> &funcTable = GlobalTables::GetFunctionTable().GetFuncTable();
+  /* don't optimize this loop to iterator or range-base loop
+   * because AddCallGraphNode(mirFunc) will change GlobalTables::GetFunctionTable().GetFuncTable()
+   */
+  for (size_t index = 0; index < funcTable.size(); ++index) {
+    MIRFunction *mirFunc = funcTable.at(index);
+    if (mirFunc == nullptr || mirFunc->GetBody() == nullptr) {
+      continue;
+    }
+    m.SetCurFunction(mirFunc);
+    CollectStaticSymbolInFunction(*mirFunc);
+    /* scan function symbol declaration
+     * find addrof static const */
+    MIRSymbolTable *funcSymTab = mirFunc->GetSymTab();
+    if (funcSymTab) {
+      size_t localSymSize = funcSymTab->GetSymbolTableSize();
+      for (uint32 i = 0; i < localSymSize; ++i) {
+        MIRSymbol *st = funcSymTab->GetSymbolFromStIdx(i);
+        if (st && st->IsConst()) {
+          MIRConst *mirConst = st->GetKonst();
+          CollectStaticSymbolInVar(mirConst);
+        }
+      }
+    }
+  }
+  /* scan global symbol declaration
+   * find addrof static const */
+  auto &symbolSet = m.GetSymbolSet();
+  for (auto sit = symbolSet.begin(); sit != symbolSet.end(); ++sit) {
+    MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx(sit->Idx(), true);
+    if (s->IsConst()) {
+      MIRConst *mirConst = s->GetKonst();
+      CollectStaticSymbolInVar(mirConst);
+    }
+  }
+}
+
+/* =================== new phase manager ===================  */
+#ifdef RA_PERF_ANALYSIS
+extern void printLSRATime();
+extern void printRATime();
+#endif
+
+bool CgFuncPM::PhaseRun(MIRModule &m) {
+  CreateCGAndBeCommon(m);
+  bool changed = false;
+  /* reserve static symbol for debugging */
+  if (!cgOptions->WithDwarf()) {
+    SweepUnusedStaticSymbol(m);
+  }
+  if (cgOptions->IsRunCG()) {
+    GenerateOutPutFile(m);
+
+    /* Run the cg optimizations phases */
+    PrepareLower(m);
+
+    uint32 countFuncId = 0;
+    unsigned long rangeNum = 0;
+
+    auto userDefinedOptLevel = cgOptions->GetOptimizeLevel();
+    cg->EnrollTargetPhases(this);
+
+    auto admMempool = AllocateMemPoolInPhaseManager("cg phase manager's analysis data manager mempool");
+    auto *serialADM = GetManagerMemPool()->New<AnalysisDataManager>(*(admMempool.get()));
+    for (auto it = m.GetFunctionList().begin(); it != m.GetFunctionList().end(); ++it) {
+      ASSERT(serialADM->CheckAnalysisInfoEmpty(), "clean adm before function run");
+      MIRFunction *mirFunc = *it;
+      if (mirFunc->GetBody() == nullptr) {
+        continue;
+      }
+      if (userDefinedOptLevel == CGOptions::kLevel2 && m.HasPartO2List()) {
+        if (m.IsInPartO2List(mirFunc->GetNameStrIdx())) {
+          cgOptions->EnableO2();
+        } else {
+          cgOptions->EnableO0();
+        }
+        ClearAllPhases();
+        cg->EnrollTargetPhases(this);
+        cg->UpdateCGOptions(*cgOptions);
+        Globals::GetInstance()->SetOptimLevel(cgOptions->GetOptimizeLevel());
+      }
+      if (!IsQuiet()) {
+        LogInfo::MapleLogger() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>> Optimizing Function  < " << mirFunc->GetName()
+                               << " id=" << mirFunc->GetPuidxOrigin() << " >---\n";
+      }
+      /* LowerIR. */
+      m.SetCurFunction(mirFunc);
+      if (cg->DoConstFold()) {
+        DumpMIRFunc(*mirFunc, "************* before ConstantFold **************");
+        ConstantFold cf(m);
+        (void)cf.Simplify(mirFunc->GetBody());
+      }
+
+      if (m.GetFlavor() != MIRFlavor::kFlavorLmbc) {
+        DoFuncCGLower(m, *mirFunc);
+      }
+      /* create CGFunc */
+      MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(mirFunc->GetStIdx().Idx());
+      auto funcMp = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, funcSt->GetName());
+      auto stackMp = std::make_unique<StackMemPool>(funcMp->GetCtrler(), "");
+      MapleAllocator funcScopeAllocator(funcMp.get());
+      mirFunc->SetPuidxOrigin(++countFuncId);
+      CGFunc *cgFunc = cg->CreateCGFunc(m, *mirFunc, *beCommon, *funcMp, *stackMp, funcScopeAllocator, countFuncId);
+      CHECK_FATAL(cgFunc != nullptr, "Create CG Function failed in cg_phase_manager");
+      CG::SetCurCGFunc(*cgFunc);
+
+      if (cgOptions->WithDwarf()) {
+        cgFunc->SetDebugInfo(m.GetDbgInfo());
+      }
+      /* Run the cg optimizations phases. */
+      if (CGOptions::UseRange() && rangeNum >= CGOptions::GetRangeBegin() && rangeNum <= CGOptions::GetRangeEnd()) {
+        CGOptions::EnableInRange();
+      }
+      changed = FuncLevelRun(*cgFunc, *serialADM);
+      /* Delete mempool. */
+      mirFunc->ReleaseCodeMemory();
+      ++rangeNum;
+      CGOptions::DisableInRange();
+    }
+    PostOutPut(m);
+#ifdef RA_PERF_ANALYSIS
+    if (cgOptions->IsEnableTimePhases()) {
+      printLSRATime();
+      printRATime();
+    }
+#endif
+  } else {
+    LogInfo::MapleLogger(kLlErr) << "Skipped generating .s because -no-cg is given" << '\n';
+  }
+  RELEASE(cg);
+  RELEASE(beCommon);
+  return changed;
+}
+
+void CgFuncPM::DumpFuncCGIR(const CGFunc &f, const std::string &phaseName) const {
+  if (CGOptions::DumpPhase(phaseName) && CGOptions::FuncFilter(f.GetName())) {
+    LogInfo::MapleLogger() << "\n******** CG IR After " << phaseName << ": *********\n";
+    f.DumpCGIR();
+  }
+}
+
+void CgFuncPM::EmitGlobalInfo(MIRModule &m) const {
+  EmitDuplicatedAsmFunc(m);
+  EmitFastFuncs(m);
+  if (cgOptions->IsGenerateObjectMap()) {
+    cg->GenerateObjectMaps(*beCommon);
+  }
+  cg->GetEmitter()->EmitGlobalVariable();
+  EmitDebugInfo(m);
+  cg->GetEmitter()->CloseOutput();
+}
+
+void CgFuncPM::InitProfile(MIRModule &m)  const {
+  if (!CGOptions::IsProfileDataEmpty()) {
+    uint32 dexNameIdx = m.GetFileinfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_filename"));
+    const std::string &dexName = GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(dexNameIdx));
+    bool deCompressSucc = m.GetProfile().DeCompress(CGOptions::GetProfileData(), dexName);
+    if (!deCompressSucc) {
+      LogInfo::MapleLogger() << "WARN: DeCompress() " << CGOptions::GetProfileData() << "failed in mplcg()\n";
+    }
+  }
+  if (!CGOptions::GetInstrumentationWhiteList().empty()) {
+    bool handleSucc = m.GetLiteProfile().HandleInstrumentationWhiteList(CGOptions::GetInstrumentationWhiteList());
+    if (!handleSucc) {
+      LogInfo::MapleLogger() << "WARN: Handle instrumentation white list file " <<
+                                CGOptions::GetInstrumentationWhiteList() <<
+                                "failed in mplcg\n";
+    }
+  }
+  if (!CGOptions::GetLiteProfile().empty()) {
+    bool handleSucc = m.GetLiteProfile().HandleLitePGOFile(CGOptions::GetLiteProfile(), m.GetFileName());
+    if (!handleSucc) {
+      LogInfo::MapleLogger() << "WARN: Handle Lite PGO input file " << CGOptions::GetLiteProfile() <<
+                                "failed in mplcg\n";
+    }
+  }
+}
+
+void CgFuncPM::CreateCGAndBeCommon(MIRModule &m) {
+  ASSERT(cgOptions != nullptr, "New cg phase manager running FAILED  :: cgOptions unset");
+#if TARGAARCH64 || TARGRISCV64
+  cg = new AArch64CG(m, *cgOptions, cgOptions->GetEHExclusiveFunctionNameVec(), CGOptions::GetCyclePatternMap());
+  cg->SetEmitter(*m.GetMemPool()->New<AArch64AsmEmitter>(*cg, m.GetOutputFileName()));
+#elif TARGARM32
+  cg = new Arm32CG(m, *cgOptions, cgOptions->GetEHExclusiveFunctionNameVec(), CGOptions::GetCyclePatternMap());
+  cg->SetEmitter(*m.GetMemPool()->New<Arm32AsmEmitter>(*cg, m.GetOutputFileName()));
+#elif TARGX86_64
+  cg = new X64CG(m, *cgOptions);
+  cg->SetEmitter(*m.GetMemPool()->New<X64Emitter>(*cg, m.GetOutputFileName()));
+#else
+#error "unknown platform"
+#endif
+
+
+  /*
+   * Must be done before creating any BECommon instances.
+   *
+   * BECommon, when constructed, will calculate the type, size and align of all types.  As a side effect, it will also
+   * lower ptr and ref types into a64. That will drop the information of what a ptr or ref points to.
+   *
+   * All metadata generation passes which depend on the pointed-to type must be done here.
+   */
+  cg->GenPrimordialObjectList(m.GetBaseName());
+  /* We initialize a couple of BECommon's tables using the size information of GlobalTables.type_table_.
+   * So, BECommon must be allocated after all the parsing is done and user-defined types are all acounted.
+   */
+  beCommon = new BECommon(m);
+  Globals::GetInstance()->SetBECommon(*beCommon);
+  Globals::GetInstance()->SetTarget(*cg);
+
+  /* If a metadata generation pass depends on object layout it must be done after creating BECommon. */
+  cg->GenExtraTypeMetadata(cgOptions->GetClassListFile(), m.GetBaseName());
+
+#if TARGAARCH64
+  if (!m.IsCModule()) {
+    CGOptions::EnableFramePointer();
+  }
+#endif
+}
+
+void CgFuncPM::PrepareLower(MIRModule &m) {
+  mirLower = GetManagerMemPool()->New<MIRLower>(m, nullptr);
+  mirLower->Init();
+  cgLower = GetManagerMemPool()->New<CGLowerer>(m,
+      *beCommon, *GetPhaseMemPool(), cg->GenerateExceptionHandlingCode(), cg->GenerateVerboseCG());
+  cgLower->RegisterBuiltIns();
+  if (m.IsJavaModule()) {
+    cgLower->InitArrayClassCacheTableIndex();
+  }
+  cgLower->RegisterExternalLibraryFunctions();
+  cgLower->SetCheckLoadStore(CGOptions::IsCheckArrayStore());
+  if (cg->IsStackProtectorStrong() || cg->IsStackProtectorAll() || m.HasPartO2List()) {
+    cg->AddStackGuardvar();
+  }
+}
+
+void CgFuncPM::DoFuncCGLower(const MIRModule &m, MIRFunction &mirFunc) const {
+  if (m.GetFlavor() <= kFeProduced) {
+    mirLower->SetLowerCG();
+    mirLower->SetMirFunc(&mirFunc);
+
+    DumpMIRFunc(mirFunc, "************* before MIRLowerer **************");
+    mirLower->LowerFunc(mirFunc);
+  }
+
+  bool isNotQuiet = !CGOptions::IsQuiet();
+  DumpMIRFunc(mirFunc, "************* before CGLowerer **************", isNotQuiet);
+
+  cgLower->LowerFunc(mirFunc);
+
+  DumpMIRFunc(mirFunc, "************* after  CGLowerer **************", isNotQuiet,
+              "************* end    CGLowerer **************");
+}
+
+void CgFuncPM::EmitDuplicatedAsmFunc(MIRModule &m) const {
+  if (CGOptions::IsDuplicateAsmFileEmpty()) {
+    return;
+  }
+
+  std::ifstream duplicateAsmFileFD(CGOptions::GetDuplicateAsmFile());
+
+  if (!duplicateAsmFileFD.is_open()) {
+    duplicateAsmFileFD.close();
+    ERR(kLncErr, " %s open failed!", CGOptions::GetDuplicateAsmFile().c_str());
+    return;
+  }
+  std::string contend;
+  bool onlyForFramework = false;
+  bool isFramework = IsFramework(m);
+
+  while (getline(duplicateAsmFileFD, contend)) {
+    if (contend.compare("#Libframework_start") == 0) {
+      onlyForFramework = true;
+    }
+
+    if (contend.compare("#Libframework_end") == 0) {
+      onlyForFramework = false;
+    }
+
+    if (onlyForFramework && !isFramework) {
+      continue;
+    }
+
+    (void)cg->GetEmitter()->Emit(contend + "\n");
+  }
+  duplicateAsmFileFD.close();
+}
+
+void CgFuncPM::EmitFastFuncs(const MIRModule &m) const {
+  if (CGOptions::IsFastFuncsAsmFileEmpty() || !(m.IsJavaModule())) {
+    return;
+  }
+
+  struct stat buffer;
+  if (stat(CGOptions::GetFastFuncsAsmFile().c_str(), &buffer) != 0) {
+    return;
+  }
+
+  std::ifstream fastFuncsAsmFileFD(CGOptions::GetFastFuncsAsmFile());
+  if (fastFuncsAsmFileFD.is_open()) {
+    std::string contend;
+    (void)cg->GetEmitter()->Emit("#define ENABLE_LOCAL_FAST_FUNCS 1\n");
+
+    while (getline(fastFuncsAsmFileFD, contend)) {
+      (void)cg->GetEmitter()->Emit(contend + "\n");
+    }
+  }
+  fastFuncsAsmFileFD.close();
+}
+
+void CgFuncPM::EmitDebugInfo(const MIRModule &m) const {
+  if (!cgOptions->WithDwarf()) {
+    return;
+  }
+  cg->GetEmitter()->SetupDBGInfo(m.GetDbgInfo());
+  cg->GetEmitter()->EmitDIHeaderFileInfo();
+  cg->GetEmitter()->EmitDIDebugInfoSection(m.GetDbgInfo());
+  cg->GetEmitter()->EmitDIDebugAbbrevSection(m.GetDbgInfo());
+  cg->GetEmitter()->EmitDIDebugARangesSection();
+  cg->GetEmitter()->EmitDIDebugRangesSection();
+  cg->GetEmitter()->EmitDIDebugLineSection();
+  cg->GetEmitter()->EmitDIDebugStrSection();
+}
+
+bool CgFuncPM::IsFramework(MIRModule &m) const {
+  auto &funcList = m.GetFunctionList();
+  for (auto it = funcList.begin(); it != funcList.end(); ++it) {
+    MIRFunction *mirFunc = *it;
+    ASSERT(mirFunc != nullptr, "nullptr check");
+    if (mirFunc->GetBody() != nullptr &&
+        mirFunc->GetName() == "Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V") {
+      return true;
+    }
+  }
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgFuncPM, cgFuncPhaseManager)
+/* register codegen common phases */
+MAPLE_TRANSFORM_PHASE_REGISTER(CgLayoutFrame, layoutstackframe)
+MAPLE_TRANSFORM_PHASE_REGISTER(CgCreateLabel, createstartendlabel)
+MAPLE_TRANSFORM_PHASE_REGISTER(InstructionSelector, instructionselector)
+MAPLE_TRANSFORM_PHASE_REGISTER(InstructionStandardize, instructionstandardize)
+MAPLE_TRANSFORM_PHASE_REGISTER(CgMoveRegArgs, moveargs)
+MAPLE_TRANSFORM_PHASE_REGISTER(CgRegAlloc, regalloc)
+MAPLE_TRANSFORM_PHASE_REGISTER(CgAlignAnalysis, alignanalysis)
+MAPLE_TRANSFORM_PHASE_REGISTER(CgFrameFinalize, framefinalize)
+MAPLE_TRANSFORM_PHASE_REGISTER(CgYieldPointInsertion, yieldpoint)
+MAPLE_TRANSFORM_PHASE_REGISTER(CgGenProEpiLog, generateproepilog)
+MAPLE_TRANSFORM_PHASE_REGISTER(CgIsolateFastPath, isolatefastpath)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cg_phi_elimination.cpp b/src/mapleall/maple_be/src/cg/cg_phi_elimination.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..09d4c704b7a5dfefd65a1107a7f3484bd64aa64c
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_phi_elimination.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_phi_elimination.h"
+#include "cg.h"
+#include "cgbb.h"
+
+namespace maplebe {
+void PhiEliminate::TranslateTSSAToCSSA() {
+  FOR_ALL_BB(bb, cgFunc) {
+    eliminatedBB.emplace(bb->GetId());
+    for (auto phiInsnIt : bb->GetPhiInsns()) {
+      /* Method I create a temp move for phi-node */
+      auto &destReg = static_cast<RegOperand&>(phiInsnIt.second->GetOperand(kInsnFirstOpnd));
+      RegOperand &tempMovDest = cgFunc->GetOrCreateVirtualRegisterOperand(CreateTempRegForCSSA(destReg));
+      auto &phiList = static_cast<PhiOperand&>(phiInsnIt.second->GetOperand(kInsnSecondOpnd));
+      for (auto phiOpndIt : phiList.GetOperands()) {
+        uint32 fBBId = phiOpndIt.first;
+        ASSERT(fBBId != 0, "GetFromBBID = 0");
+#if DEBUG
+        bool find = false;
+        for (auto predBB : bb->GetPreds()) {
+          if (predBB->GetId() == fBBId) {
+            find = true;
+          }
+        }
+        CHECK_FATAL(find, "dont exited pred for phi-node");
+#endif
+        PlaceMovInPredBB(fBBId, CreateMov(tempMovDest, *(phiOpndIt.second)));
+      }
+      Insn &movInsn = CreateMov(destReg, tempMovDest);
+      bb->ReplaceInsn(*phiInsnIt.second, movInsn);
+    }
+  }
+
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      CHECK_FATAL(eliminatedBB.count(bb->GetId()) != 0, "still have phi");
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      ReCreateRegOperand(*insn);
+      bb->GetPhiInsns().clear();
+      insn->SetSSAImpDefOpnd(nullptr);
+    }
+  }
+  UpdateRematInfo();
+  cgFunc->SetSSAvRegCount(0);
+}
+
+void PhiEliminate::UpdateRematInfo() {
+  if (CGOptions::GetRematLevel() > 0) {
+    cgFunc->UpdateAllRegisterVregMapping(remateInfoAfterSSA);
+  }
+}
+
+void PhiEliminate::PlaceMovInPredBB(uint32 predBBId, Insn &movInsn) const {
+  BB *predBB = cgFunc->GetBBFromID(predBBId);
+  ASSERT(movInsn.GetOperand(kInsnSecondOpnd).IsRegister(), "unexpect operand");
+  if (predBB->GetKind() == BB::kBBFallthru) {
+    predBB->AppendInsn(movInsn);
+  } else {
+    AppendMovAfterLastVregDef(*predBB, movInsn);
+  }
+}
+
+regno_t PhiEliminate::RecursiveBothDU(RegOperand &ssaOpnd) {
+  if (!ssaOpnd.IsSSAForm()) {
+    return ssaOpnd.GetRegisterNumber();
+  }
+  VRegVersion *ssaVersion = GetSSAInfo()->FindSSAVersion(ssaOpnd.GetRegisterNumber());
+  ASSERT(ssaVersion != nullptr, "find ssaVersion failed");
+  ASSERT(!ssaVersion->IsDeleted(), "ssaVersion has been deleted");
+  RegOperand *regForRecreate = &ssaOpnd;
+  if (GetSSAInfo()->IsNoDefVReg(ssaOpnd.GetRegisterNumber())) {
+    regForRecreate = MakeRoomForNoDefVreg(ssaOpnd);
+  } else {
+    ASSERT(regForRecreate->IsSSAForm(), "Opnd is not in ssa form");
+  }
+  DUInsnInfo *defInfo = ssaVersion->GetDefInsnInfo();
+  Insn *defInsn = defInfo != nullptr ? defInfo->GetInsn() : nullptr;
+  if (defInsn != nullptr) {
+    uint32 defUseIdx = defInsn->GetBothDefUseOpnd();
+    if (defUseIdx != kInsnMaxOpnd) {
+      if (defInfo->GetOperands().count(defUseIdx) > 0) {
+        CHECK_FATAL(defInfo->GetOperands()[defUseIdx] == 1, "multiple definiation");
+        Operand &preOpnd = defInsn->GetOperand(defUseIdx);
+        ASSERT(preOpnd.IsRegister(), "unexpect operand type");
+        return RecursiveBothDU(static_cast<RegOperand&>(preOpnd));
+      }
+    }
+    CHECK_FATAL(defInsn->GetMachineOpcode() != MOP_asm,  "not implement yet");
+    CHECK_FATAL(ssaVersion->GetOriginalRegNO() != kRFLAG,  "not implement yet");
+  } else {
+    return ssaVersion->GetOriginalRegNO();
+  }
+  return regForRecreate->GetRegisterNumber();
+}
+
+regno_t PhiEliminate::GetAndIncreaseTempRegNO() {
+  while (GetSSAInfo()->GetAllSSAOperands().count(tempRegNO) != 0) {
+    tempRegNO++;
+  }
+  regno_t ori = tempRegNO;
+  tempRegNO++;
+  return ori;
+}
+
+RegOperand *PhiEliminate::MakeRoomForNoDefVreg(RegOperand &conflictReg) {
+  regno_t conflictVregNO = conflictReg.GetRegisterNumber();
+  auto rVregIt = replaceVreg.find(conflictVregNO);
+  if (rVregIt != replaceVreg.end()) {
+    return rVregIt->second;
+  } else {
+    RegOperand *regForRecreate = &CreateTempRegForCSSA(conflictReg);
+    (void)replaceVreg.emplace(std::pair<regno_t, RegOperand*>(conflictVregNO, regForRecreate));
+    return regForRecreate;
+  }
+}
+
+void PhiEliminate::RecordRematInfo(regno_t vRegNO, PregIdx pIdx) {
+  if (remateInfoAfterSSA.count(vRegNO) != 0) {
+    if (remateInfoAfterSSA[vRegNO] != pIdx) {
+      remateInfoAfterSSA.erase(vRegNO);
+    }
+  } else {
+    (void)remateInfoAfterSSA.emplace(std::pair<regno_t, PregIdx>(vRegNO, pIdx));
+  }
+}
+
+bool CgPhiElimination::PhaseRun(maplebe::CGFunc &f) {
+  CGSSAInfo *ssaInfo = GET_ANALYSIS(CgSSAConstruct, f);
+  PhiEliminate *pe = f.GetCG()->CreatePhiElimintor(*GetPhaseMemPool(), f, *ssaInfo);
+  pe->TranslateTSSAToCSSA();
+  return false;
+}
+void CgPhiElimination::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgSSAConstruct>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgPhiElimination, cgphielimination)
+}
diff --git a/src/mapleall/maple_be/src/cg/cg_pre.cpp b/src/mapleall/maple_be/src/cg/cg_pre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5730f91da6f5c4bd0972c202ed2cd5a39cefc2ab
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_pre.cpp
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_pre.h"
+#include "cg_dominance.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+/* Implement PRE in cgir */
+void CGPre::ResetDS(CgPhiOcc *phiOcc) {
+  if (!phiOcc->IsDownSafe()) {
+    return;
+  }
+
+  phiOcc->SetIsDownSafe(false);
+  for (auto *phiOpnd : phiOcc->GetPhiOpnds()) {
+    auto *defOcc = phiOpnd->GetDef();
+    if (defOcc != nullptr && defOcc->GetOccType() == kOccPhiocc) {
+      ResetDS(static_cast<CgPhiOcc *>(defOcc));
+    }
+  }
+}
+
+void CGPre::ComputeDS() {
+  for (auto phiIt = phiOccs.rbegin(); phiIt != phiOccs.rend(); ++phiIt) {
+    auto *phiOcc = *phiIt;
+    if (phiOcc->IsDownSafe()) {
+      continue;
+    }
+    for (auto *phiOpnd : phiOcc->GetPhiOpnds()) {
+      if (phiOpnd->HasRealUse()) {
+        continue;
+      }
+      auto *defOcc = phiOpnd->GetDef();
+      if (defOcc != nullptr && defOcc->GetOccType() == kOccPhiocc) {
+        ResetDS(static_cast<CgPhiOcc *>(defOcc));
+      }
+    }
+  }
+}
+
+/* based on ssapre->workCand's realOccs and dfPhiDfns (which now privides all
+   the inserted phis), create the phi and phiOpnd occ nodes; link them all up in
+   order of dt_preorder in ssapre->allOccs; the phi occ nodes are in addition
+   provided in order of dt_preorder in ssapre->phiOccs */
+void CGPre::CreateSortedOccs() {
+  // merge varPhiDfns to dfPhiDfns
+  dfPhiDfns.insert(varPhiDfns.begin(), varPhiDfns.end());
+
+  auto comparator = [this](const CgPhiOpndOcc *occA, const CgPhiOpndOcc *occB) -> bool {
+    return dom->GetDtDfnItem(occA->GetBB()->GetId()) < dom->GetDtDfnItem(occB->GetBB()->GetId());
+  };
+
+  std::vector<CgPhiOpndOcc *> phiOpnds;
+  for (auto dfn : dfPhiDfns) {
+    uint32 bbId = dom->GetDtPreOrderItem(dfn);
+    BB *bb = GetBB(bbId);
+    auto *phiOcc = perCandMemPool->New<CgPhiOcc>(*bb, workCand->GetTheOperand(), perCandAllocator);
+    phiOccs.push_back(phiOcc);
+
+    for (BB *pred : bb->GetPreds()) {
+      auto phiOpnd = perCandMemPool->New<CgPhiOpndOcc>(pred, workCand->GetTheOperand(), phiOcc);
+      phiOpnds.push_back(phiOpnd);
+      phiOcc->AddPhiOpnd(*phiOpnd);
+      phiOpnd->SetPhiOcc(*phiOcc);
+    }
+  }
+  std::sort(phiOpnds.begin(), phiOpnds.end(), comparator);
+
+  auto realOccIt = workCand->GetRealOccs().begin();
+  auto exitOccIt = exitOccs.begin();
+  auto phiIt = phiOccs.begin();
+  auto phiOpndIt = phiOpnds.begin();
+
+  CgOccur *nextRealOcc = nullptr;
+  if (realOccIt != workCand->GetRealOccs().end()) {
+    nextRealOcc = *realOccIt;
+  }
+
+  CgOccur *nextExitOcc = nullptr;
+  if (exitOccIt != exitOccs.end()) {
+    nextExitOcc = *exitOccIt;
+  }
+
+  CgPhiOcc *nextPhiOcc = nullptr;
+  if (phiIt != phiOccs.end()) {
+    nextPhiOcc = *phiIt;
+  }
+
+  CgPhiOpndOcc *nextPhiOpndOcc = nullptr;
+  if (phiOpndIt != phiOpnds.end()) {
+    nextPhiOpndOcc = *phiOpndIt;
+  }
+
+  CgOccur *pickedOcc;  // the next picked occ in order of preorder traveral of dominator tree
+  do {
+    pickedOcc = nullptr;
+    // the 4 kinds of occ must be checked in this order, so it will be right
+    // if more than 1 has the same dfn
+    if (nextPhiOcc != nullptr) {
+      pickedOcc = nextPhiOcc;
+    }
+    if (nextRealOcc != nullptr && (pickedOcc == nullptr ||
+                                   dom->GetDtDfnItem(nextRealOcc->GetBB()->GetId()) <
+                                   dom->GetDtDfnItem(pickedOcc->GetBB()->GetId()))) {
+      pickedOcc = nextRealOcc;
+    }
+    if (nextExitOcc != nullptr && (pickedOcc == nullptr ||
+                                   dom->GetDtDfnItem(nextExitOcc->GetBB()->GetId()) <
+                                   dom->GetDtDfnItem(pickedOcc->GetBB()->GetId()))) {
+      pickedOcc = nextExitOcc;
+    }
+    if (nextPhiOpndOcc != nullptr && (pickedOcc == nullptr ||
+                                      dom->GetDtDfnItem(nextPhiOpndOcc->GetBB()->GetId()) <
+                                      dom->GetDtDfnItem(pickedOcc->GetBB()->GetId()))) {
+      pickedOcc = nextPhiOpndOcc;
+    }
+    if (pickedOcc != nullptr) {
+      allOccs.push_back(pickedOcc);
+      switch (pickedOcc->GetOccType()) {
+        case kOccReal:
+        case kOccUse:
+        case kOccDef:
+        case kOccStore:
+        case kOccMembar: {
+          ++realOccIt;
+          if (realOccIt != workCand->GetRealOccs().end()) {
+            nextRealOcc = *realOccIt;
+          } else {
+            nextRealOcc = nullptr;
+          }
+          break;
+        }
+        case kOccExit: {
+          ++exitOccIt;
+          if (exitOccIt != exitOccs.end()) {
+            nextExitOcc = *exitOccIt;
+          } else {
+            nextExitOcc = nullptr;
+          }
+          break;
+        }
+        case kOccPhiocc: {
+          ++phiIt;
+          if (phiIt != phiOccs.end()) {
+            nextPhiOcc = *phiIt;
+          } else {
+            nextPhiOcc = nullptr;
+          }
+          break;
+        }
+        case kOccPhiopnd: {
+          ++phiOpndIt;
+          if (phiOpndIt != phiOpnds.end()) {
+            nextPhiOpndOcc = *phiOpndIt;
+          } else {
+            nextPhiOpndOcc = nullptr;
+          }
+          break;
+        }
+        default:
+          ASSERT(false, "CreateSortedOccs: unexpected occty");
+          break;
+      }
+    }
+  } while (pickedOcc != nullptr);
+}
+
+CgOccur *CGPre::CreateRealOcc(Insn &insn, Operand &opnd, OccType occType) {
+  uint64 hashIdx = PreWorkCandHashTable::ComputeWorkCandHashIndex(opnd);
+  PreWorkCand *wkCand = preWorkCandHashTable.GetWorkcandFromIndex(hashIdx);
+  while (wkCand != nullptr) {
+    Operand *currOpnd = wkCand->GetTheOperand();
+    ASSERT(currOpnd != nullptr, "CreateRealOcc: found workcand with theMeExpr as nullptr");
+    if (currOpnd == &opnd) {
+      break;
+    }
+    wkCand = static_cast<PreWorkCand*>(wkCand->GetNext());
+  }
+
+  CgOccur *newOcc = nullptr;
+  switch (occType) {
+    case kOccDef:
+      newOcc = ssaPreMemPool->New<CgDefOcc>(insn.GetBB(), &insn, &opnd);
+      break;
+    case kOccStore:
+      newOcc = ssaPreMemPool->New<CgStoreOcc>(insn.GetBB(), &insn, &opnd);
+      break;
+    case kOccUse:
+      newOcc = ssaPreMemPool->New<CgUseOcc>(insn.GetBB(), &insn, &opnd);
+      break;
+    default:
+      CHECK_FATAL(false, "unsupported occur type");
+      break;
+  }
+
+  if (wkCand != nullptr) {
+    wkCand->AddRealOccAsLast(*newOcc, GetPUIdx());
+    return newOcc;
+  }
+
+  // workcand not yet created; create a new one and add to worklist
+  wkCand = ssaPreMemPool->New<PreWorkCand>(ssaPreAllocator, &opnd, GetPUIdx());
+  workList.push_back(wkCand);
+  wkCand->AddRealOccAsLast(*newOcc, GetPUIdx());
+  // add to bucket at workcandHashTable[hashIdx]
+  wkCand->SetNext(*preWorkCandHashTable.GetWorkcandFromIndex(hashIdx));
+  preWorkCandHashTable.SetWorkCandAt(hashIdx, *wkCand);
+  return newOcc;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_be/src/cg/cg_prop.cpp b/src/mapleall/maple_be/src/cg/cg_prop.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8d3339323e9e458e8d27cf02d6fcbc55007894f7
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_prop.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "loop.h"
+#include "cg_prop.h"
+
+namespace maplebe {
+void CGProp::DoCopyProp() {
+  CopyProp();
+  cgDce->DoDce();
+}
+
+void CGProp::DoTargetProp() {
+  DoCopyProp();
+  /* instruction level opt */
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      TargetProp(*insn);
+    }
+  }
+  /* pattern  level opt */
+  if (CGOptions::GetInstance().GetOptimizeLevel() == CGOptions::kLevel2) {
+    PropPatternOpt();
+  }
+}
+
+Insn *PropOptimizePattern::FindDefInsn(const VRegVersion *useVersion) const {
+  if (!useVersion) {
+    return nullptr;
+  }
+  DUInsnInfo *defInfo = useVersion->GetDefInsnInfo();
+  if (!defInfo) {
+    return nullptr;
+  }
+  return defInfo->GetInsn();
+}
+
+bool CgCopyProp::PhaseRun(maplebe::CGFunc &f) {
+  CGSSAInfo *ssaInfo = GET_ANALYSIS(CgSSAConstruct, f);
+  LiveIntervalAnalysis *ll = GET_ANALYSIS(CGliveIntervalAnalysis, f);
+  CGProp *cgProp = f.GetCG()->CreateCGProp(*GetPhaseMemPool(), f, *ssaInfo, *ll);
+  cgProp->DoCopyProp();
+  ll->ClearBFS();
+  return false;
+}
+void CgCopyProp::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgSSAConstruct>();
+  aDep.AddRequired<CGliveIntervalAnalysis>();
+  aDep.AddPreserved<CgSSAConstruct>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgCopyProp, cgcopyprop)
+
+bool CgTargetProp::PhaseRun(maplebe::CGFunc &f) {
+  CGSSAInfo *ssaInfo = GET_ANALYSIS(CgSSAConstruct, f);
+  LiveIntervalAnalysis *ll = GET_ANALYSIS(CGliveIntervalAnalysis, f);
+  CGProp *cgProp = f.GetCG()->CreateCGProp(*GetPhaseMemPool(), f, *ssaInfo, *ll);
+  cgProp->DoTargetProp();
+  ll->ClearBFS();
+  return false;
+}
+void CgTargetProp::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgSSAConstruct>();
+  aDep.AddRequired<CGliveIntervalAnalysis>();
+  aDep.AddPreserved<CgSSAConstruct>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgTargetProp, cgtargetprop)
+}
diff --git a/src/mapleall/maple_be/src/cg/cg_rce.cpp b/src/mapleall/maple_be/src/cg/cg_rce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8479ba2a295e31327df41c32afcca239eaebd9e4
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_rce.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_rce.h"
+
+namespace maplebe {
+void RedundantComputeElim::Dump(const Insn *insn1, const Insn *insn2) const {
+  CHECK_FATAL(insn1 && insn2, "dump insn is null");
+  LogInfo::MapleLogger() << ">>>>>> SameRHSInsnPair in BB(" <<
+      insn1->GetBB()->GetId() << ") at {" << g_count << "} <<<<<<\n";
+  insn1->Dump();
+  insn2->Dump();
+}
+
+bool CgRedundantCompElim::PhaseRun(maplebe::CGFunc &f) {
+  CGSSAInfo *ssaInfo = GET_ANALYSIS(CgSSAConstruct, f);
+  CHECK_FATAL(ssaInfo != nullptr, "Get ssaInfo failed");
+  MemPool *mp = GetPhaseMemPool();
+  CHECK_FATAL(mp != nullptr, "get memPool failed");
+  auto *rce = f.GetCG()->CreateRedundantCompElim(*mp, f, *ssaInfo);
+  CHECK_FATAL(rce != nullptr, "rce instance create failed");
+  rce->Run();
+  return true;
+}
+
+void CgRedundantCompElim::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<CgSSAConstruct>();
+  aDep.AddPreserved<CgSSAConstruct>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgRedundantCompElim, cgredundantcompelim)
+} /* namespace maplebe */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/src/cg/cg_ssa.cpp b/src/mapleall/maple_be/src/cg/cg_ssa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4b4aa8f09ef73946c965233149c60689094544e0
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_ssa.cpp
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_ssa.h"
+#include "cg.h"
+
+#include "optimize_common.h"
+
+namespace maplebe {
+uint32 CGSSAInfo::ssaRegNObase = 100;
+void CGSSAInfo::ConstructSSA() {
+  InsertPhiInsn();
+  /* Rename variables */
+  RenameVariablesForBB(domInfo->GetCommonEntryBB().GetId());
+#if DEBUG
+  /* Check phiListOpnd, must be ssaForm */
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsPhi()) {
+        continue;
+      }
+      Operand &phiListOpnd = insn->GetOperand(kInsnSecondOpnd);
+      CHECK_FATAL(phiListOpnd.IsPhi(), "unexpect phi operand");
+      MapleMap<uint32, RegOperand*> &phiList = static_cast<PhiOperand&>(phiListOpnd).GetOperands();
+      for (auto &phiOpndIt : phiList) {
+        if (!phiOpndIt.second->IsSSAForm()) {
+          CHECK_FATAL(false, "phiOperand is not ssaForm!");
+        }
+      }
+    }
+  }
+#endif
+  cgFunc->SetSSAvRegCount(static_cast<uint32>(GetAllSSAOperands().size()) + ssaRegNObase + 1);
+  /* save reversePostOrder of bbs for rectify validbit */
+  SetReversePostOrder();
+}
+
+void CGSSAInfo::MarkInsnsInSSA(Insn &insn) {
+  CHECK_FATAL(insn.GetId() == 0, "insn is not clean !!"); /* change to assert */
+  insnCount += 2;
+  insn.SetId(static_cast<uint32>(insnCount));
+}
+
+void CGSSAInfo::InsertPhiInsn() {
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      std::set<uint32> defRegNOs = insn->GetDefRegs();
+      for (auto vRegNO : defRegNOs) {
+        RegOperand *virtualOpnd = cgFunc->GetVirtualRegisterOperand(vRegNO);
+        if (virtualOpnd != nullptr) {
+          PrunedPhiInsertion(*bb, *virtualOpnd);
+        }
+      }
+    }
+  }
+}
+
+void CGSSAInfo::PrunedPhiInsertion(const BB &bb, RegOperand &virtualOpnd) {
+  regno_t vRegNO = virtualOpnd.GetRegisterNumber();
+  MapleVector<uint32> frontiers = domInfo->GetDomFrontier(bb.GetId());
+  for (auto i : frontiers) {
+    BB *phiBB = cgFunc->GetBBFromID(i);
+    CHECK_FATAL(phiBB != nullptr, "get phiBB failed change to ASSERT");
+    if (phiBB->HasPhiInsn(vRegNO)) {
+      continue;
+    }
+    if (phiBB->GetLiveIn()->TestBit(vRegNO)) {
+      CG *codeGen = cgFunc->GetCG();
+      PhiOperand &phiList = codeGen->CreatePhiOperand(*memPool, ssaAlloc);
+      /* do not insert phi opnd when insert phi insn? */
+      for (auto prevBB : phiBB->GetPreds()) {
+        if (prevBB->GetLiveOut()->TestBit(vRegNO)) {
+          auto *paraOpnd = static_cast<RegOperand*>(virtualOpnd.Clone(*tempMp));
+          phiList.InsertOpnd(prevBB->GetId(), *paraOpnd);
+        } else {
+          CHECK_FATAL(false, "multipule BB in");
+        }
+      }
+      Insn &phiInsn = codeGen->BuildPhiInsn(virtualOpnd, phiList);
+      MarkInsnsInSSA(phiInsn);
+      bool insertSuccess = false;
+      FOR_BB_INSNS(insn, phiBB) {
+        if (insn->IsMachineInstruction()) {
+          (void)phiBB->InsertInsnBefore(*insn, phiInsn);
+          insertSuccess = true;
+          break;
+        }
+      }
+      if (!insertSuccess) {
+        phiBB->InsertInsnBegin(phiInsn);
+      }
+      phiBB->AddPhiInsn(vRegNO, phiInsn);
+      PrunedPhiInsertion(*phiBB, virtualOpnd);
+    }
+  }
+}
+
+void CGSSAInfo::RenameVariablesForBB(uint32 bbID) {
+  RenameBB(*cgFunc->GetBBFromID(bbID)); /* rename first BB */
+  const auto &domChildren = domInfo->GetDomChildren(bbID);
+  for (const auto &child : domChildren) {
+    RenameBB(*cgFunc->GetBBFromID(child));
+  }
+}
+
+void CGSSAInfo::RenameBB(BB &bb) {
+  if (IsBBRenamed(bb.GetId())) {
+    return;
+  }
+  AddRenamedBB(bb.GetId());
+  /* record version stack size */
+  size_t tempSize = vRegStk.empty() ? allSSAOperands.size() + cgFunc->GetFirstMapleIrVRegNO() + 1 :
+      vRegStk.rbegin()->first + 1;
+  std::vector<int32> oriStackSize(tempSize, -1);
+  for (auto it : vRegStk) {
+    ASSERT(it.first < oriStackSize.size(), "out of range");
+    oriStackSize[it.first] = static_cast<int32>(it.second.size());
+  }
+  RenamePhi(bb);
+  FOR_BB_INSNS(insn, &bb) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    MarkInsnsInSSA(*insn);
+    RenameInsn(*insn);
+  }
+  RenameSuccPhiUse(bb);
+  RenameVariablesForBB(bb.GetId());
+  /* stack pop up */
+  for (auto &it : vRegStk) {
+    if (it.first < oriStackSize.size() && oriStackSize[it.first] >= 0) {
+      while (static_cast<int32>(it.second.size()) > oriStackSize[static_cast<uint64>(it.first)]) {
+        ASSERT(!it.second.empty(), "empty stack");
+        it.second.pop();
+      }
+    }
+  }
+}
+
+void CGSSAInfo::RenamePhi(BB &bb) {
+  for (auto phiInsnIt : bb.GetPhiInsns()) {
+    Insn *phiInsn = phiInsnIt.second;
+    CHECK_FATAL(phiInsn != nullptr, "get phi insn failed");
+    auto *phiDefOpnd = static_cast<RegOperand*>(&phiInsn->GetOperand(kInsnFirstOpnd));
+    VRegVersion *newVst = CreateNewVersion(*phiDefOpnd, *phiInsn, kInsnFirstOpnd, true);
+    phiInsn->SetOperand(kInsnFirstOpnd, *newVst->GetSSAvRegOpnd());
+  }
+}
+
+void CGSSAInfo::RenameSuccPhiUse(const BB &bb) {
+  for (auto *sucBB : bb.GetSuccs()) {
+    for (auto phiInsnIt : sucBB->GetPhiInsns()) {
+      Insn *phiInsn = phiInsnIt.second;
+      CHECK_FATAL(phiInsn != nullptr, "get phi insn failed");
+      Operand *phiListOpnd = &phiInsn->GetOperand(kInsnSecondOpnd);
+      CHECK_FATAL(phiListOpnd->IsPhi(), "unexpect phi operand");
+      MapleMap<uint32, RegOperand*> &phiList = static_cast<PhiOperand*>(phiListOpnd)->GetOperands();
+      ASSERT(phiList.size() <= sucBB->GetPreds().size(), "unexpect phiList size need check");
+      for (auto phiOpndIt = phiList.begin(); phiOpndIt != phiList.end(); ++phiOpndIt) {
+        if (phiOpndIt->first == bb.GetId()) {
+          RegOperand *renamedOpnd = GetRenamedOperand(*(phiOpndIt->second), false, *phiInsn, kInsnSecondOpnd);
+          phiList[phiOpndIt->first] = renamedOpnd;
+        }
+      }
+    }
+  }
+}
+
+uint32 CGSSAInfo::IncreaseVregCount(regno_t vRegNO) {
+  if (vRegDefCount.count(vRegNO) == 0) {
+    vRegDefCount.emplace(vRegNO, 0);
+  } else {
+    vRegDefCount[vRegNO]++;
+  }
+  return vRegDefCount[vRegNO];
+}
+
+bool CGSSAInfo::IncreaseSSAOperand(regno_t vRegNO, VRegVersion *vst) {
+  if (allSSAOperands.count(vRegNO) != 0) {
+    return false;
+  }
+  allSSAOperands.emplace(vRegNO, vst);
+  return true;
+}
+
+VRegVersion *CGSSAInfo::CreateNewVersion(RegOperand &virtualOpnd, Insn &defInsn, uint32 idx, bool isDefByPhi) {
+  regno_t vRegNO = virtualOpnd.GetRegisterNumber();
+  uint32 verionIdx = IncreaseVregCount(vRegNO);
+  RegOperand *ssaOpnd = CreateSSAOperand(virtualOpnd);
+  auto *newVst = memPool->New<VRegVersion>(ssaAlloc, *ssaOpnd, verionIdx, vRegNO);
+  auto *defInfo = CreateDUInsnInfo(&defInsn, idx);
+  newVst->SetDefInsn(defInfo, isDefByPhi ? kDefByPhi : kDefByInsn);
+  if (!IncreaseSSAOperand(ssaOpnd->GetRegisterNumber(), newVst)) {
+    CHECK_FATAL(false, "insert ssa operand failed");
+  }
+  auto it = vRegStk.find(vRegNO);
+  if (it == vRegStk.end()) {
+    MapleStack<VRegVersion*> vRegVersionStack(ssaAlloc.Adapter());
+    auto ret = vRegStk.emplace(std::pair<regno_t, MapleStack<VRegVersion*>>(vRegNO, vRegVersionStack));
+    CHECK_FATAL(ret.second, "insert failed");
+    it = ret.first;
+  }
+  it->second.push(newVst);
+  return newVst;
+}
+
+VRegVersion *CGSSAInfo::GetVersion(const RegOperand &virtualOpnd) {
+  regno_t vRegNO = virtualOpnd.GetRegisterNumber();
+  auto vRegIt = vRegStk.find(vRegNO);
+  return vRegIt != vRegStk.end() ? vRegIt->second.top() : nullptr;
+}
+
+VRegVersion *CGSSAInfo::FindSSAVersion(regno_t ssaRegNO) {
+  auto it = allSSAOperands.find(ssaRegNO);
+  return it != allSSAOperands.end() ? it->second : nullptr;
+}
+
+PhiOperand &CGSSAInfo::CreatePhiOperand() {
+  return cgFunc->GetCG()->CreatePhiOperand(*memPool, ssaAlloc);
+}
+
+void CGSSAInfo::SetReversePostOrder() {
+  MapleVector<BB*> &reverse = domInfo->GetReversePostOrder();
+  for (auto *bb : reverse) {
+    if (bb != nullptr) {
+      reversePostOrder.emplace_back(bb->GetId());
+    }
+  }
+}
+
+Insn *CGSSAInfo::GetDefInsn(const RegOperand &useReg) {
+  if (!useReg.IsSSAForm()) {
+    return nullptr;
+  }
+  regno_t useRegNO = useReg.GetRegisterNumber();
+  VRegVersion *useVersion = FindSSAVersion(useRegNO);
+  ASSERT(useVersion != nullptr, "useVRegVersion must not be null based on ssa");
+  CHECK_FATAL(!useVersion->IsDeleted(), "deleted version");
+  DUInsnInfo *defInfo = useVersion->GetDefInsnInfo();
+  return defInfo == nullptr ? nullptr : defInfo->GetInsn();
+}
+
+void CGSSAInfo::DumpFuncCGIRinSSAForm() const {
+  LogInfo::MapleLogger() << "\n******  SSA CGIR for " << cgFunc->GetName() << " *******\n";
+  FOR_ALL_BB_CONST(bb, cgFunc) {
+    cgFunc->DumpBBInfo(bb);
+    FOR_BB_INSNS_CONST(insn, bb) {
+      if (insn->IsCfiInsn() && insn->IsDbgInsn()) {
+        insn->Dump();
+      } else {
+        DumpInsnInSSAForm(*insn);
+      }
+    }
+  }
+}
+
+void VRegVersion::AddUseInsn(CGSSAInfo &ssaInfo, Insn &useInsn, uint32 idx) {
+  ASSERT(useInsn.GetId() > 0, "insn should be marked during ssa");
+  auto useInsnIt = useInsnInfos.find(useInsn.GetId());
+  if (useInsnIt != useInsnInfos.end()) {
+    useInsnIt->second->IncreaseDU(idx);
+  } else {
+    useInsnInfos.insert(std::make_pair(useInsn.GetId(), ssaInfo.CreateDUInsnInfo(&useInsn, idx)));
+  }
+}
+
+void VRegVersion::RemoveUseInsn(const Insn &useInsn, uint32 idx) {
+  auto useInsnIt = useInsnInfos.find(useInsn.GetId());
+  ASSERT(useInsnIt != useInsnInfos.end(), "use Insn not found");
+  useInsnIt->second->DecreaseDU(idx);
+  if (useInsnIt->second->HasNoDU()) {
+    useInsnInfos.erase(useInsnIt);
+  }
+}
+
+void VRegVersion::CheckDeadUse(const Insn &useInsn) {
+  auto useInsnIt = useInsnInfos.find(useInsn.GetId());
+  ASSERT(useInsnIt != useInsnInfos.end(), "use Insn not found");
+  if (useInsnIt->second->HasNoDU()) {
+    useInsnInfos.erase(useInsnIt);
+  }
+}
+
+void CgSSAConstruct::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgDomAnalysis>();
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.PreservedAllExcept<CgLiveAnalysis>();
+}
+
+bool CgSSAConstruct::PhaseRun(maplebe::CGFunc &f) {
+  if (CG_DEBUG_FUNC(f)) {
+    DotGenerator::GenerateDot("beforessa", f, f.GetMirModule(), true);
+  }
+  MemPool *ssaMemPool = GetPhaseMemPool();
+  MemPool *ssaTempMp = ApplyTempMemPool();
+  DomAnalysis *domInfo = nullptr;
+  domInfo = GET_ANALYSIS(CgDomAnalysis, f);
+  LiveAnalysis *liveInfo = nullptr;
+  liveInfo = GET_ANALYSIS(CgLiveAnalysis, f);
+  ssaInfo = f.GetCG()->CreateCGSSAInfo(*ssaMemPool, f, *domInfo, *ssaTempMp);
+  ssaInfo->ConstructSSA();
+
+  if (CG_DEBUG_FUNC(f)) {
+    LogInfo::MapleLogger() << "******** CG IR After ssaconstruct in ssaForm: *********" << "\n";
+    ssaInfo->DumpFuncCGIRinSSAForm();
+  }
+  if (liveInfo != nullptr) {
+    liveInfo->ClearInOutDataInfo();
+  }
+  /* due to change of register number */
+  GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &CgLiveAnalysis::id);
+  return true;
+}
+MAPLE_ANALYSIS_PHASE_REGISTER(CgSSAConstruct, cgssaconstruct) /* both transform & analysis */
+}
diff --git a/src/mapleall/maple_be/src/cg/cg_ssa_pre.cpp b/src/mapleall/maple_be/src/cg/cg_ssa_pre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..30e92d384122922eb234883ebe3beb9b1a2c9cb9
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_ssa_pre.cpp
@@ -0,0 +1,602 @@
+/*
+ * Copyright (c) [2022] Futureweiwei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cgfunc.h"
+#include "loop.h"
+#include "cg_ssa_pre.h"
+
+namespace maplebe {
+
+// ================ Step 6: Code Motion ================
+void SSAPre::CodeMotion() {
+  // pass 1 only doing insertion
+  for (Occ *occ : allOccs) {
+    if (occ->occTy != kAOccPhiOpnd) {
+      continue;
+    }
+    PhiOpndOcc *phiOpndOcc = static_cast<PhiOpndOcc*>(occ);
+    if (phiOpndOcc->insertHere) {
+      ASSERT(phiOpndOcc->cgbb->GetLoop() == nullptr, "cg_ssapre: save inserted inside loop");
+      workCand->saveAtEntryBBs.insert(phiOpndOcc->cgbb->GetId());
+    }
+  }
+  // pass 2 only doing deletion
+  for (Occ *occ : realOccs) {
+    if (occ->occTy != kAOccReal) {
+      continue;
+    }
+    RealOcc *realOcc = static_cast<RealOcc*>(occ);
+    if (!realOcc->redundant) {
+      ASSERT(realOcc->cgbb->GetLoop() == nullptr, "cg_ssapre: save in place inside loop");
+      workCand->saveAtEntryBBs.insert(realOcc->cgbb->GetId());
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ output _______" << '\n';
+    LogInfo::MapleLogger() << " saveAtEntryBBs: [";
+    for (uint32 id : workCand->saveAtEntryBBs) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "]\n\n";
+  }
+}
+
+// ================ Step 5: Finalize ================
+// for setting RealOcc's redundant flag and PhiOpndOcc's insertHere flag
+void SSAPre::Finalize() {
+  std::vector<Occ*> availDefVec(classCount + 1, nullptr);
+  // preorder traversal of dominator tree
+  for (Occ *occ : allOccs) {
+    size_t classId = static_cast<size_t>(occ->classId);
+    switch (occ->occTy) {
+      case kAOccPhi: {
+        PhiOcc *phiOcc = static_cast<PhiOcc*>(occ);
+        if (phiOcc->WillBeAvail()) {
+          availDefVec[classId] = phiOcc;
+        }
+        break;
+      }
+      case kAOccReal: {
+        RealOcc *realOcc = static_cast<RealOcc*>(occ);
+        if (availDefVec[classId] == nullptr || !availDefVec[classId]->IsDominate(dom, occ)) {
+          realOcc->redundant = false;
+          availDefVec[classId] = realOcc;
+        } else {
+          realOcc->redundant = true;
+        }
+        break;
+      }
+      case kAOccPhiOpnd: {
+        PhiOpndOcc *phiOpndOcc = static_cast<PhiOpndOcc*>(occ);
+        const PhiOcc *phiOcc = phiOpndOcc->defPhiOcc;
+        if (phiOcc->WillBeAvail()) {
+          if (phiOpndOcc->def == nullptr || (!phiOpndOcc->hasRealUse &&
+                                             phiOpndOcc->def->occTy == kAOccPhi &&
+                                             !static_cast<PhiOcc*>(phiOpndOcc->def)->WillBeAvail())) {
+            // insert a store
+            if (phiOpndOcc->cgbb->GetSuccs().size() != 1) {  // critical edge
+              workCand->saveAtProlog = true;
+              break;
+            }
+            phiOpndOcc->insertHere = true;
+          } else {
+            phiOpndOcc->def = availDefVec[classId];
+          }
+        }
+        break;
+      }
+      case kAOccExit:
+        break;
+      default:
+        ASSERT(false, "Finalize: unexpected occ type");
+        break;
+    }
+    if (workCand->saveAtProlog) {
+      break;
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after finalize _______" << '\n';
+    if (workCand->saveAtProlog) {
+      LogInfo::MapleLogger() << "Giving up because of insertion at critical edge" << '\n';
+      return;
+    }
+    for (Occ *occ : allOccs) {
+      if (occ->occTy == kAOccReal) {
+        RealOcc *realOcc = static_cast<RealOcc*>(occ);
+        if (!realOcc->redundant) {
+          occ->Dump();
+          LogInfo::MapleLogger() << " non-redundant" << '\n';
+        }
+      } else if (occ->occTy == kAOccPhiOpnd) {
+        PhiOpndOcc *phiOpndOcc = static_cast<PhiOpndOcc*>(occ);
+        if (phiOpndOcc->insertHere) {
+          occ->Dump();
+          LogInfo::MapleLogger() << " insertHere" << '\n';
+        }
+      }
+    }
+  }
+}
+
+// ================ Step 4: WillBeAvail Computation ================
+
+void SSAPre::ResetCanBeAvail(PhiOcc *phi) const {
+  phi->isCanBeAvail = false;
+  // the following loop finds phi's uses and reset them
+  for (PhiOcc *phiOcc : phiOccs) {
+    for (PhiOpndOcc *phiOpndOcc : phiOcc->phiOpnds) {
+      if (phiOpndOcc->def != nullptr && phiOpndOcc->def == phi) {
+        if (!phiOpndOcc->hasRealUse && !phiOcc->isDownsafe && phiOcc->isCanBeAvail) {
+          ResetCanBeAvail(phiOcc);
+        }
+      }
+    }
+  }
+}
+
+void SSAPre::ComputeCanBeAvail() const {
+  for (PhiOcc *phiOcc : phiOccs) {
+    if (!phiOcc->isDownsafe && phiOcc->isCanBeAvail) {
+      bool existNullUse = false;
+      for (PhiOpndOcc *phiOpndOcc : phiOcc->phiOpnds) {
+        if (phiOpndOcc->def == nullptr) {
+          existNullUse = true;
+          break;
+        }
+      }
+      if (existNullUse) {
+        ResetCanBeAvail(phiOcc);
+      }
+    }
+  }
+}
+
+void SSAPre::ResetLater(PhiOcc *phi) const {
+  phi->isLater = false;
+  // the following loop finds phi's uses and reset them
+  for (PhiOcc *phiOcc : phiOccs) {
+    for (PhiOpndOcc *phiOpndOcc : phiOcc->phiOpnds) {
+      if (phiOpndOcc->def != nullptr && phiOpndOcc->def == phi) {
+        if (phiOcc->isLater) {
+          ResetLater(phiOcc);
+        }
+      }
+    }
+  }
+}
+
+void SSAPre::ComputeLater() const {
+  for (PhiOcc *phiOcc : phiOccs) {
+    phiOcc->isLater = phiOcc->isCanBeAvail;
+  }
+  for (PhiOcc *phiOcc : phiOccs) {
+    if (phiOcc->isLater) {
+      bool existNonNullUse = false;
+      for (PhiOpndOcc *phiOpndOcc : phiOcc->phiOpnds) {
+        if (phiOpndOcc->def != nullptr && phiOpndOcc->hasRealUse) {
+          existNonNullUse = true;
+          break;
+        }
+      }
+      if (existNonNullUse || phiOcc->speculativeDownsafe) {
+        ResetLater(phiOcc);
+      }
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after later computation _______" << '\n';
+    for (PhiOcc *phiOcc : phiOccs) {
+      phiOcc->Dump();
+      if (phiOcc->isCanBeAvail) {
+        LogInfo::MapleLogger() << " canbeAvail";
+      }
+      if (phiOcc->isLater) {
+        LogInfo::MapleLogger() << " later";
+      }
+      if (phiOcc->isCanBeAvail && !phiOcc->isLater) {
+        LogInfo::MapleLogger() << " will be Avail";
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 3: Downsafe Computation ================
+void SSAPre::ResetDownsafe(const PhiOpndOcc *phiOpnd) const {
+  if (phiOpnd->hasRealUse) {
+    return;
+  }
+  Occ *defOcc = phiOpnd->def;
+  if (defOcc == nullptr || defOcc->occTy != kAOccPhi) {
+    return;
+  }
+  PhiOcc *defPhiOcc = static_cast<PhiOcc*>(defOcc);
+  if (defPhiOcc->speculativeDownsafe) {
+    return;
+  }
+  if (!defPhiOcc->isDownsafe) {
+    return;
+  }
+  defPhiOcc->isDownsafe = false;
+  for (PhiOpndOcc *phiOpndOcc : defPhiOcc->phiOpnds) {
+    ResetDownsafe(phiOpndOcc);
+  }
+}
+
+void SSAPre::ComputeDownsafe() const {
+  for (PhiOcc *phiOcc : phiOccs) {
+    if (!phiOcc->isDownsafe) {
+      // propagate not-Downsafe backward along use-def edges
+      for (PhiOpndOcc *phiOpndOcc : phiOcc->phiOpnds) {
+        ResetDownsafe(phiOpndOcc);
+      }
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after downsafe computation _______" << '\n';
+    for (PhiOcc *phiOcc : phiOccs) {
+      phiOcc->Dump();
+      if (phiOcc->speculativeDownsafe) {
+        LogInfo::MapleLogger() << " spec_downsafe /";
+      }
+      if (phiOcc->isDownsafe) {
+        LogInfo::MapleLogger() << " downsafe";
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 2: rename ================
+static void PropagateSpeculativeDownsafe(PhiOcc *phiOcc) {
+  if (phiOcc->speculativeDownsafe) {
+    return;
+  }
+  phiOcc->isDownsafe = true;
+  phiOcc->speculativeDownsafe = true;
+  for (PhiOpndOcc *phiOpndOcc : phiOcc->phiOpnds) {
+    if (phiOpndOcc->def != nullptr && phiOpndOcc->def->occTy == kAOccPhi) {
+      PhiOcc *nextPhiOcc = static_cast<PhiOcc *>(phiOpndOcc->def);
+      if (nextPhiOcc->cgbb->GetLoop() != nullptr) {
+        PropagateSpeculativeDownsafe(nextPhiOcc);
+      }
+    }
+  }
+}
+
+void SSAPre::Rename() {
+  std::stack<Occ*> occStack;
+  classCount = 0;
+  // iterate thru the occurrences in order of preorder traversal of dominator
+  // tree
+  for (Occ *occ : allOccs) {
+    while (!occStack.empty() && !occStack.top()->IsDominate(dom, occ)) {
+      occStack.pop();
+    }
+    switch (occ->occTy) {
+      case kAOccExit:
+        if (!occStack.empty()) {
+          Occ *topOcc = occStack.top();
+          if (topOcc->occTy == kAOccPhi) {
+            PhiOcc *phiTopOcc = static_cast<PhiOcc *>(topOcc);
+            if (!phiTopOcc->speculativeDownsafe) {
+              phiTopOcc->isDownsafe = false;
+            }
+          }
+        }
+        break;
+      case kAOccPhi:
+        // assign new class
+        occ->classId = ++classCount;
+        occStack.push(occ);
+        break;
+      case kAOccReal: {
+        if (occStack.empty()) {
+          // assign new class
+          occ->classId = ++classCount;
+          occStack.push(occ);
+          break;
+        }
+        Occ *topOcc = occStack.top();
+        occ->classId = topOcc->classId;
+        if (topOcc->occTy == kAOccPhi) {
+          occStack.push(occ);
+          if (occ->cgbb->GetLoop() != nullptr) {
+            static_cast<PhiOcc *>(topOcc)->isDownsafe = true;
+            static_cast<PhiOcc *>(topOcc)->speculativeDownsafe = true;
+          }
+        }
+        break;
+      }
+      case kAOccPhiOpnd: {
+        if (occStack.empty()) {
+          // leave classId as 0
+          break;
+        }
+        Occ *topOcc = occStack.top();
+        occ->def = topOcc;
+        occ->classId = topOcc->classId;
+        if (topOcc->occTy == kAOccReal) {
+          static_cast<PhiOpndOcc*>(occ)->hasRealUse = true;
+        }
+        break;
+      }
+      default:
+        ASSERT(false, "Rename: unexpected type of occurrence");
+        break;
+    }
+  }
+  // loop thru phiOccs to propagate speculativeDownsafe
+  for (PhiOcc *phiOcc : phiOccs) {
+    if (phiOcc->speculativeDownsafe) {
+      for (PhiOpndOcc *phiOpndOcc : phiOcc->phiOpnds) {
+        if (phiOpndOcc->def != nullptr && phiOpndOcc->def->occTy == kAOccPhi) {
+          PhiOcc *nextPhiOcc = static_cast<PhiOcc *>(phiOpndOcc->def);
+          if (nextPhiOcc->cgbb->GetLoop() != nullptr) {
+            PropagateSpeculativeDownsafe(nextPhiOcc);
+          }
+        }
+      }
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after rename _______" << '\n';
+    for (Occ *occ : allOccs) {
+      occ->Dump();
+      if (occ->occTy == kAOccPhi) {
+        PhiOcc *phiOcc = static_cast<PhiOcc *>(occ);
+        if (phiOcc->speculativeDownsafe) {
+          LogInfo::MapleLogger() << " spec_downsafe /";
+        }
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 1: insert phis ================
+
+// form pih occ based on the real occ in workCand->realOccs; result is
+// stored in phiDfns
+void SSAPre::FormPhis() {
+  for (Occ *occ : realOccs) {
+    GetIterDomFrontier(occ->cgbb, &phiDfns);
+  }
+}
+
+// form allOccs inclusive of real, phi, phiOpnd, exit occurrences;
+// form phiOccs containing only the phis
+void SSAPre::CreateSortedOccs() {
+  // form phiOpnd occs based on the preds of the phi occs; result is
+  // stored in phiOpndDfns
+  std::multiset<uint32> phiOpndDfns;
+  for (uint32 dfn : phiDfns) {
+    const BBId bbId = dom->GetDtPreOrderItem(dfn);
+    BB *cgbb = cgFunc->GetAllBBs()[bbId];
+    for (BB *pred : cgbb->GetPreds()) {
+      (void)phiOpndDfns.insert(dom->GetDtDfnItem(pred->GetId()));
+    }
+  }
+  std::unordered_map<BBId, std::forward_list<PhiOpndOcc*>> bb2PhiOpndMap;
+  MapleVector<Occ*>::iterator realOccIt = realOccs.begin();
+  MapleVector<ExitOcc*>::iterator exitOccIt = exitOccs.begin();
+  MapleSet<uint32>::iterator phiDfnIt = phiDfns.begin();
+  MapleSet<uint32>::iterator phiOpndDfnIt = phiOpndDfns.begin();
+  Occ *nextRealOcc = nullptr;
+  if (realOccIt != realOccs.end()) {
+    nextRealOcc = *realOccIt;
+  }
+  ExitOcc *nextExitOcc = nullptr;
+  if (exitOccIt != exitOccs.end()) {
+    nextExitOcc = *exitOccIt;
+  }
+  PhiOcc *nextPhiOcc = nullptr;
+  if (phiDfnIt != phiDfns.end()) {
+    nextPhiOcc = preMp->New<PhiOcc>(cgFunc->GetAllBBs().at(dom->GetDtPreOrderItem(*phiDfnIt)), preAllocator);
+  }
+  PhiOpndOcc *nextPhiOpndOcc = nullptr;
+  if (phiOpndDfnIt != phiOpndDfns.end()) {
+    nextPhiOpndOcc = preMp->New<PhiOpndOcc>(cgFunc->GetAllBBs().at(dom->GetDtPreOrderItem(*phiOpndDfnIt)));
+    auto it = bb2PhiOpndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt));
+    if (it == bb2PhiOpndMap.end()) {
+      std::forward_list<PhiOpndOcc*> newlist = { nextPhiOpndOcc };
+      bb2PhiOpndMap[dom->GetDtPreOrderItem(*phiOpndDfnIt)] = newlist;
+    } else {
+      it->second.push_front(nextPhiOpndOcc);
+    }
+  }
+  Occ *pickedOcc = nullptr;  // the next picked occ in order of preorder traversal of dominator tree
+  do {
+    pickedOcc = nullptr;
+    if (nextPhiOcc != nullptr) {
+      pickedOcc = nextPhiOcc;
+    }
+    if (nextRealOcc != nullptr && (pickedOcc == nullptr || dom->GetDtDfnItem(nextRealOcc->cgbb->GetId()) <
+                                   dom->GetDtDfnItem(pickedOcc->cgbb->GetId()))) {
+      pickedOcc = nextRealOcc;
+    }
+    if (nextPhiOpndOcc != nullptr &&
+        (pickedOcc == nullptr || *phiOpndDfnIt < dom->GetDtDfnItem(pickedOcc->cgbb->GetId()))) {
+      pickedOcc = nextPhiOpndOcc;
+    }
+    if (nextExitOcc != nullptr && (pickedOcc == nullptr || dom->GetDtDfnItem(nextExitOcc->cgbb->GetId()) <
+                                    dom->GetDtDfnItem(pickedOcc->cgbb->GetId()))) {
+      pickedOcc = nextExitOcc;
+    }
+    if (pickedOcc != nullptr) {
+      allOccs.push_back(pickedOcc);
+      switch (pickedOcc->occTy) {
+        case kAOccReal: {
+          // get the next real occ
+          CHECK_FATAL(realOccIt != realOccs.end(), "iterator check");
+          ++realOccIt;
+          if (realOccIt != realOccs.end()) {
+            nextRealOcc = *realOccIt;
+          } else {
+            nextRealOcc = nullptr;
+          }
+          break;
+        }
+        case kAOccExit: {
+          CHECK_FATAL(exitOccIt != exitOccs.end(), "iterator check");
+          ++exitOccIt;
+          if (exitOccIt != exitOccs.end()) {
+            nextExitOcc = *exitOccIt;
+          } else {
+            nextExitOcc = nullptr;
+          }
+          break;
+        }
+        case kAOccPhi: {
+          phiOccs.push_back(static_cast<PhiOcc*>(pickedOcc));
+          CHECK_FATAL(phiDfnIt != phiDfns.end(), "iterator check");
+          ++phiDfnIt;
+          if (phiDfnIt != phiDfns.end()) {
+            nextPhiOcc = preMp->New<PhiOcc>(cgFunc->GetAllBBs().at(dom->GetDtPreOrderItem(*phiDfnIt)), preAllocator);
+          } else {
+            nextPhiOcc = nullptr;
+          }
+          break;
+        }
+        case kAOccPhiOpnd: {
+          CHECK_FATAL(phiOpndDfnIt != phiOpndDfns.end(), "iterator check");
+          ++phiOpndDfnIt;
+          if (phiOpndDfnIt != phiOpndDfns.end()) {
+            nextPhiOpndOcc = preMp->New<PhiOpndOcc>(cgFunc->GetAllBBs().at(dom->GetDtPreOrderItem(*phiOpndDfnIt)));
+            auto it = bb2PhiOpndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt));
+            if (it == bb2PhiOpndMap.end()) {
+              std::forward_list<PhiOpndOcc*> newlist = { nextPhiOpndOcc };
+              bb2PhiOpndMap[dom->GetDtPreOrderItem(*phiOpndDfnIt)] = newlist;
+            } else {
+              it->second.push_front(nextPhiOpndOcc);
+            }
+          } else {
+            nextPhiOpndOcc = nullptr;
+          }
+          break;
+        }
+        default:
+          ASSERT(false, "CreateSortedOccs: unexpected occTy");
+          break;
+      }
+    }
+  } while (pickedOcc != nullptr);
+  // initialize phiOpnd vector in each PhiOcc node and defPhiOcc in each PhiOpndOcc
+  for (PhiOcc *phiOcc : phiOccs) {
+    for (BB *pred : phiOcc->cgbb->GetPreds()) {
+      PhiOpndOcc *phiOpndOcc = bb2PhiOpndMap[pred->GetId()].front();
+      phiOcc->phiOpnds.push_back(phiOpndOcc);
+      phiOpndOcc->defPhiOcc = phiOcc;
+      bb2PhiOpndMap[pred->GetId()].pop_front();
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after phi insertion _______" << '\n';
+    for (Occ *occ : allOccs) {
+      occ->Dump();
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 0: Preparations ================
+
+void SSAPre::PropagateNotAnt(BB *bb, std::set<BB*, BBIdCmp> *visitedBBs) {
+  if (visitedBBs->count(bb) != 0) {
+    return;
+  }
+  visitedBBs->insert(bb);
+  if (workCand->occBBs.count(bb->GetId()) != 0) {
+    return;
+  }
+  fullyAntBBs[bb->GetId()] = false;
+  for (BB *predbb : bb->GetPreds()) {
+    PropagateNotAnt(predbb, visitedBBs);
+  }
+}
+
+void SSAPre::FormRealsNExits() {
+  std::set<BB*, BBIdCmp> visitedBBs;
+  if (asEarlyAsPossible) {
+    for (BB *cgbb : cgFunc->GetExitBBsVec()) {
+      if (!cgbb->IsUnreachable()) {
+        PropagateNotAnt(cgbb, &visitedBBs);
+      }
+    }
+  }
+
+  for (uint32 i = 0; i < dom->GetDtPreOrderSize(); i++) {
+    BBId bbid = dom->GetDtPreOrderItem(i);
+    BB *cgbb = cgFunc->GetAllBBs()[bbid];
+    if (asEarlyAsPossible) {
+      if (fullyAntBBs[cgbb->GetId()]) {
+        RealOcc *realOcc = preMp->New<RealOcc>(cgbb);
+        realOccs.push_back(realOcc);
+      }
+    } else {
+      if (workCand->occBBs.count(cgbb->GetId()) != 0) {
+        RealOcc *realOcc = preMp->New<RealOcc>(cgbb);
+        realOccs.push_back(realOcc);
+      }
+    }
+    if (!cgbb->IsUnreachable() && (cgbb->NumSuccs() == 0 || cgbb->GetKind() == BB::kBBReturn)) {
+      ExitOcc *exitOcc = preMp->New<ExitOcc>(cgbb);
+      exitOccs.push_back(exitOcc);
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "Placement Optimization for callee-save saves" << '\n';
+    LogInfo::MapleLogger() << "-----------------------------------------------" << '\n';
+    LogInfo::MapleLogger() << " _______ input _______" << '\n';
+    LogInfo::MapleLogger() << " occBBs: [";
+    for (uint32 id : workCand->occBBs) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "]\n";
+  }
+}
+
+void SSAPre::ApplySSAPre() {
+  FormRealsNExits();
+  // #1 insert phis; results in allOccs and phiOccs
+  FormPhis();  // result put in the set phi_bbs
+  CreateSortedOccs();
+  // #2 rename
+  Rename();
+  if (!phiOccs.empty()) {
+    // #3 DownSafety
+    ComputeDownsafe();
+    // #4 CanBeAvail
+    ComputeCanBeAvail();
+    ComputeLater();
+  }
+  // #5 Finalize
+  Finalize();
+  if (!workCand->saveAtProlog) {
+    // #6 Code Motion
+    CodeMotion();
+  }
+}
+
+void DoSavePlacementOpt(CGFunc *f, DomAnalysis *dom, SsaPreWorkCand *workCand) {
+  MemPool *tempMP = memPoolCtrler.NewMemPool("cg_ssa_pre", true);
+  SSAPre cgssapre(f, dom, tempMP, workCand, false/*asEarlyAsPossible*/, false/*enabledDebug*/);
+
+  cgssapre.ApplySSAPre();
+
+  memPoolCtrler.DeleteMemPool(tempMP);
+}
+
+}  // namespace maplebe
diff --git a/src/mapleall/maple_be/src/cg/cg_ssu_pre.cpp b/src/mapleall/maple_be/src/cg/cg_ssu_pre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..65e5529a8e4306e85d6b7aadffe8d784ba047e40
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_ssu_pre.cpp
@@ -0,0 +1,603 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cgfunc.h"
+#include "cg_ssu_pre.h"
+
+namespace maplebe {
+
+// ================ Step 6: Code Motion ================
+void SSUPre::CodeMotion() {
+  // pass 1 only donig insertion
+  for (SOcc *occ : allOccs) {
+    if (occ->occTy != kSOccLambdaRes) {
+      continue;
+    }
+    SLambdaResOcc *lambdaResOcc = static_cast<SLambdaResOcc*>(occ);
+    if (lambdaResOcc->insertHere) {
+      workCand->restoreAtEntryBBs.insert(lambdaResOcc->cgbb->GetId());
+    }
+  }
+  // pass 2 only doing deletion
+  for (SOcc *occ : realOccs) {
+    if (occ->occTy != kSOccReal) {
+      continue;
+    }
+    SRealOcc *realOcc = static_cast<SRealOcc*>(occ);
+    if (!realOcc->redundant) {
+      if (realOcc->cgbb->IsWontExit()) {
+        workCand->restoreAtEpilog = true;
+        break;
+      }
+      workCand->restoreAtExitBBs.insert(realOcc->cgbb->GetId());
+    }
+  }
+  if (enabledDebug) {
+    if (workCand->restoreAtEpilog) {
+      LogInfo::MapleLogger() << "Giving up because of restore inside infinite loop" << '\n';
+      return;
+    }
+    LogInfo::MapleLogger() << " _______ output _______" << '\n';
+    LogInfo::MapleLogger() << " restoreAtEntryBBs: [";
+    for (uint32 id : workCand->restoreAtEntryBBs) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "]\n restoreAtExitBBs: [";
+    for (uint32 id : workCand->restoreAtExitBBs) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "]\n\n";
+  }
+}
+
+// ================ Step 5: Finalize ================
+// for setting SRealOcc's redundant flag and SLambdaResOcc's insertHere flag
+void SSUPre::Finalize() {
+  std::vector<SOcc*> anticipatedDefVec(classCount + 1, nullptr);
+  // preorder traversal of post-dominator tree
+  for (SOcc *occ : allOccs) {
+    size_t classId = static_cast<size_t>(occ->classId);
+    switch (occ->occTy) {
+      case kSOccLambda: {
+        auto *lambdaOcc = static_cast<SLambdaOcc*>(occ);
+        if (lambdaOcc->WillBeAnt()) {
+          anticipatedDefVec[classId] = lambdaOcc;
+        }
+        break;
+      }
+      case kSOccReal: {
+        auto *realOcc = static_cast<SRealOcc*>(occ);
+        if (anticipatedDefVec[classId] == nullptr || !anticipatedDefVec[classId]->IsPostDominate(pdom, occ)) {
+          realOcc->redundant = false;
+          anticipatedDefVec[classId] = realOcc;
+        } else {
+          realOcc->redundant = true;
+        }
+        break;
+      }
+      case kSOccLambdaRes: {
+        auto *lambdaResOcc = static_cast<SLambdaResOcc*>(occ);
+        const SLambdaOcc *lambdaOcc = lambdaResOcc->useLambdaOcc;
+        if (lambdaOcc->WillBeAnt()) {
+          if (lambdaResOcc->use == nullptr || (!lambdaResOcc->hasRealUse &&
+                                               lambdaResOcc->use->occTy == kSOccLambda &&
+                                               !static_cast<SLambdaOcc*>(lambdaResOcc->use)->WillBeAnt())) {
+            // insert a store
+            if (lambdaResOcc->cgbb->GetPreds().size() != 1) {  // critical edge
+              workCand->restoreAtEpilog = true;
+              break;
+            }
+            lambdaResOcc->insertHere = true;
+          } else {
+            lambdaResOcc->use = anticipatedDefVec[classId];
+          }
+        }
+        break;
+      }
+      case kSOccEntry:
+      case kSOccKill:
+        break;
+      default:
+        ASSERT(false, "Finalize: unexpected occ type");
+        break;
+    }
+    if (workCand->restoreAtEpilog) {
+      break;
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after finalize _______" << '\n';
+    if (workCand->restoreAtEpilog) {
+      LogInfo::MapleLogger() << "Giving up because of insertion at critical edge" << '\n';
+      return;
+    }
+    for (SOcc *occ : allOccs) {
+      if (occ->occTy == kSOccReal) {
+        SRealOcc *realOcc = static_cast<SRealOcc*>(occ);
+        if (!realOcc->redundant) {
+          occ->Dump();
+          LogInfo::MapleLogger() << " non-redundant" << '\n';
+        }
+      } else if (occ->occTy == kSOccLambdaRes) {
+        SLambdaResOcc *lambdaResOcc = static_cast<SLambdaResOcc*>(occ);
+        if (lambdaResOcc->insertHere) {
+          occ->Dump();
+          LogInfo::MapleLogger() << " insertHere" << '\n';
+        }
+      }
+    }
+  }
+}
+
+// ================ Step 4: WillBeAnt Computation ================
+
+void SSUPre::ResetCanBeAnt(SLambdaOcc *lambda) const {
+  lambda->isCanBeAnt = false;
+  // the following loop finds lambda's defs and reset them
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    for (SLambdaResOcc *lambdaResOcc : lambdaOcc->lambdaRes) {
+      if (lambdaResOcc->use != nullptr && lambdaResOcc->use == lambda) {
+        if (!lambdaResOcc->hasRealUse && !lambdaOcc->isUpsafe && lambdaOcc->isCanBeAnt) {
+          ResetCanBeAnt(lambdaOcc);
+        }
+      }
+    }
+  }
+}
+
+void SSUPre::ComputeCanBeAnt() const {
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    if (!lambdaOcc->isUpsafe && lambdaOcc->isCanBeAnt) {
+      bool existNullUse = false;
+      for (SLambdaResOcc *lambdaResOcc : lambdaOcc->lambdaRes) {
+        if (lambdaResOcc->use == nullptr) {
+          existNullUse = true;
+          break;
+        }
+      }
+      if (existNullUse) {
+        ResetCanBeAnt(lambdaOcc);
+      }
+    }
+  }
+}
+
+void SSUPre::ResetEarlier(SLambdaOcc *lambda) const {
+  lambda->isEarlier = false;
+  // the following loop finds lambda's defs and reset them
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    for (SLambdaResOcc *lambdaResOcc : lambdaOcc->lambdaRes) {
+      if (lambdaResOcc->use != nullptr && lambdaResOcc->use == lambda) {
+        if (lambdaOcc->isEarlier) {
+          ResetEarlier(lambdaOcc);
+        }
+      }
+    }
+  }
+}
+
+void SSUPre::ComputeEarlier() const {
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    lambdaOcc->isEarlier = lambdaOcc->isCanBeAnt;
+  }
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    if (lambdaOcc->isEarlier) {
+      bool existNonNullUse = false;
+      for (SLambdaResOcc *lambdaResOcc : lambdaOcc->lambdaRes) {
+        if (lambdaResOcc->use != nullptr && lambdaResOcc->hasRealUse) {
+          existNonNullUse = true;
+          break;
+        }
+      }
+      if (existNonNullUse) {
+        ResetEarlier(lambdaOcc);
+      }
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after earlier computation _______" << '\n';
+    for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+      lambdaOcc->Dump();
+      if (lambdaOcc->isCanBeAnt) {
+        LogInfo::MapleLogger() << " canbeant";
+      }
+      if (lambdaOcc->isEarlier) {
+        LogInfo::MapleLogger() << " earlier";
+      }
+      if (lambdaOcc->isCanBeAnt && !lambdaOcc->isEarlier) {
+        LogInfo::MapleLogger() << " will be ant";
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 3: Upsafe Computation ================
+void SSUPre::ResetUpsafe(const SLambdaResOcc *lambdaRes) const {
+  if (lambdaRes->hasRealUse) {
+    return;
+  }
+  SOcc *useOcc = lambdaRes->use;
+  if (useOcc == nullptr || useOcc->occTy != kSOccLambda) {
+    return;
+  }
+  auto *useLambdaOcc = static_cast<SLambdaOcc*>(useOcc);
+  if (!useLambdaOcc->isUpsafe) {
+    return;
+  }
+  useLambdaOcc->isUpsafe = false;
+  for (SLambdaResOcc *lambdaResOcc : useLambdaOcc->lambdaRes) {
+    ResetUpsafe(lambdaResOcc);
+  }
+}
+
+void SSUPre::ComputeUpsafe() const {
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    if (!lambdaOcc->isUpsafe) {
+      // propagate not-upsafe forward along def-use edges
+      for (SLambdaResOcc *lambdaResOcc : lambdaOcc->lambdaRes) {
+        ResetUpsafe(lambdaResOcc);
+      }
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after upsafe computation _______" << '\n';
+    for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+      lambdaOcc->Dump();
+      if (lambdaOcc->isUpsafe) {
+        LogInfo::MapleLogger() << " upsafe";
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 2: rename ================
+void SSUPre::Rename() {
+  std::stack<SOcc*> occStack;
+  classCount = 0;
+  // iterate thru the occurrences in order of preorder traversal of
+  // post-dominator tree
+  for (SOcc *occ : allOccs) {
+    while (!occStack.empty() && !occStack.top()->IsPostDominate(pdom, occ)) {
+      occStack.pop();
+    }
+    switch (occ->occTy) {
+      case kSOccKill:
+        if (!occStack.empty()) {
+          SOcc *topOcc = occStack.top();
+          if (topOcc->occTy == kSOccLambda) {
+            static_cast<SLambdaOcc*>(topOcc)->isUpsafe = false;
+          }
+        }
+        occStack.push(occ);
+        break;
+      case kSOccEntry:
+        if (!occStack.empty()) {
+          SOcc *topOcc = occStack.top();
+          if (topOcc->occTy == kSOccLambda) {
+            static_cast<SLambdaOcc *>(topOcc)->isUpsafe = false;
+          }
+        }
+        break;
+      case kSOccLambda:
+        // assign new class
+        occ->classId = ++classCount;
+        occStack.push(occ);
+        break;
+      case kSOccReal: {
+        if (occStack.empty()) {
+          // assign new class
+          occ->classId = ++classCount;
+          occStack.push(occ);
+          break;
+        }
+        SOcc *topOcc = occStack.top();
+        if (topOcc->occTy == kSOccKill) {
+          // assign new class
+          occ->classId = ++classCount;
+          occStack.push(occ);
+          break;
+        }
+        ASSERT(topOcc->occTy == kSOccLambda || topOcc->occTy == kSOccReal,
+               "Rename: unexpected top-of-stack occ");
+        occ->classId = topOcc->classId;
+        if (topOcc->occTy == kSOccLambda) {
+          occStack.push(occ);
+        }
+        break;
+      }
+      case kSOccLambdaRes: {
+        if (occStack.empty()) {
+          // leave classId as 0
+          break;
+        }
+        SOcc *topOcc = occStack.top();
+        if (topOcc->occTy == kSOccKill) {
+          // leave classId as 0
+          break;
+        }
+        ASSERT(topOcc->occTy == kSOccLambda || topOcc->occTy == kSOccReal,
+               "Rename: unexpected top-of-stack occ");
+        occ->use = topOcc;
+        occ->classId = topOcc->classId;
+        if (topOcc->occTy == kSOccReal) {
+          static_cast<SLambdaResOcc*>(occ)->hasRealUse = true;
+        }
+        break;
+      }
+      default:
+        ASSERT(false, "Rename: unexpected type of occurrence");
+        break;
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after rename _______" << '\n';
+    for (SOcc *occ : allOccs) {
+      occ->Dump();
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 1: insert lambdas ================
+
+// form lambda occ based on the real occ in workCand->realOccs; result is
+// stored in lambdaDfns
+void SSUPre::FormLambdas() {
+  for (SOcc *occ : realOccs) {
+    if (occ->occTy == kSOccKill) {
+      continue;
+    }
+    GetIterPdomFrontier(occ->cgbb, &lambdaDfns);
+  }
+}
+
+// form allOccs inclusive of real, kill, lambda, lambdaRes, entry occurrences;
+// form lambdaOccs containing only the lambdas
+void SSUPre::CreateSortedOccs() {
+  // form lambdaRes occs based on the succs of the lambda occs; result is
+  // stored in lambdaResDfns
+  std::multiset<uint32> lambdaResDfns;
+  for (uint32 dfn : lambdaDfns) {
+    const BBId bbId = pdom->GetPdtPreOrderItem(dfn);
+    BB *cgbb = cgFunc->GetAllBBs()[bbId];
+    for (BB *succ : cgbb->GetSuccs()) {
+      (void)lambdaResDfns.insert(pdom->GetPdtDfnItem(succ->GetId()));
+    }
+  }
+  std::unordered_map<BBId, std::forward_list<SLambdaResOcc*>> bb2LambdaResMap;
+  MapleVector<SOcc*>::iterator realOccIt = realOccs.begin();
+  MapleVector<SEntryOcc*>::iterator entryOccIt = entryOccs.begin();
+  MapleSet<uint32>::iterator lambdaDfnIt = lambdaDfns.begin();
+  MapleSet<uint32>::iterator lambdaResDfnIt = lambdaResDfns.begin();
+  SOcc *nextRealOcc = nullptr;
+  if (realOccIt != realOccs.end()) {
+    nextRealOcc = *realOccIt;
+  }
+  SEntryOcc *nextEntryOcc = nullptr;
+  if (entryOccIt != entryOccs.end()) {
+    nextEntryOcc = *entryOccIt;
+  }
+  SLambdaOcc *nextLambdaOcc = nullptr;
+  if (lambdaDfnIt != lambdaDfns.end()) {
+    nextLambdaOcc =
+        spreMp->New<SLambdaOcc>(cgFunc->GetAllBBs().at(pdom->GetPdtPreOrderItem(*lambdaDfnIt)), spreAllocator);
+  }
+  SLambdaResOcc *nextLambdaResOcc = nullptr;
+  if (lambdaResDfnIt != lambdaResDfns.end()) {
+    nextLambdaResOcc = spreMp->New<SLambdaResOcc>(cgFunc->GetAllBBs().at(pdom->GetPdtPreOrderItem(*lambdaResDfnIt)));
+    auto it = bb2LambdaResMap.find(pdom->GetPdtPreOrderItem(*lambdaResDfnIt));
+    if (it == bb2LambdaResMap.end()) {
+      std::forward_list<SLambdaResOcc*> newlist = { nextLambdaResOcc };
+      bb2LambdaResMap[pdom->GetPdtPreOrderItem(*lambdaResDfnIt)] = newlist;
+    } else {
+      it->second.push_front(nextLambdaResOcc);
+    }
+  }
+  SOcc *pickedOcc = nullptr;  // the next picked occ in order of preorder traversal of post-dominator tree
+  do {
+    pickedOcc = nullptr;
+    if (nextLambdaOcc != nullptr) {
+      pickedOcc = nextLambdaOcc;
+    }
+    if (nextRealOcc != nullptr && (pickedOcc == nullptr || pdom->GetPdtDfnItem(nextRealOcc->cgbb->GetId()) <
+                                   pdom->GetPdtDfnItem(pickedOcc->cgbb->GetId()))) {
+      pickedOcc = nextRealOcc;
+    }
+    if (nextLambdaResOcc != nullptr &&
+        (pickedOcc == nullptr || *lambdaResDfnIt < pdom->GetPdtDfnItem(pickedOcc->cgbb->GetId()))) {
+      pickedOcc = nextLambdaResOcc;
+    }
+    if (nextEntryOcc != nullptr && (pickedOcc == nullptr || pdom->GetPdtDfnItem(nextEntryOcc->cgbb->GetId()) <
+                                    pdom->GetPdtDfnItem(pickedOcc->cgbb->GetId()))) {
+      pickedOcc = nextEntryOcc;
+    }
+    if (pickedOcc != nullptr) {
+      allOccs.push_back(pickedOcc);
+      switch (pickedOcc->occTy) {
+        case kSOccReal:
+        case kSOccKill: {
+          // get the next real/kill occ
+          CHECK_FATAL(realOccIt != realOccs.end(), "iterator check");
+          ++realOccIt;
+          if (realOccIt != realOccs.end()) {
+            nextRealOcc = *realOccIt;
+          } else {
+            nextRealOcc = nullptr;
+          }
+          break;
+        }
+        case kSOccEntry: {
+          CHECK_FATAL(entryOccIt != entryOccs.end(), "iterator check");
+          ++entryOccIt;
+          if (entryOccIt != entryOccs.end()) {
+            nextEntryOcc = *entryOccIt;
+          } else {
+            nextEntryOcc = nullptr;
+          }
+          break;
+        }
+        case kSOccLambda: {
+          lambdaOccs.push_back(static_cast<SLambdaOcc*>(pickedOcc));
+          CHECK_FATAL(lambdaDfnIt != lambdaDfns.end(), "iterator check");
+          ++lambdaDfnIt;
+          if (lambdaDfnIt != lambdaDfns.end()) {
+            nextLambdaOcc =
+                spreMp->New<SLambdaOcc>(cgFunc->GetAllBBs().at(pdom->GetPdtPreOrderItem(*lambdaDfnIt)), spreAllocator);
+          } else {
+            nextLambdaOcc = nullptr;
+          }
+          break;
+        }
+        case kSOccLambdaRes: {
+          CHECK_FATAL(lambdaResDfnIt != lambdaResDfns.end(), "iterator check");
+          ++lambdaResDfnIt;
+          if (lambdaResDfnIt != lambdaResDfns.end()) {
+            nextLambdaResOcc =
+                spreMp->New<SLambdaResOcc>(cgFunc->GetAllBBs().at(pdom->GetPdtPreOrderItem(*lambdaResDfnIt)));
+            auto it = bb2LambdaResMap.find(pdom->GetPdtPreOrderItem(*lambdaResDfnIt));
+            if (it == bb2LambdaResMap.end()) {
+              std::forward_list<SLambdaResOcc*> newlist = { nextLambdaResOcc };
+              bb2LambdaResMap[pdom->GetPdtPreOrderItem(*lambdaResDfnIt)] = newlist;
+            } else {
+              it->second.push_front(nextLambdaResOcc);
+            }
+          } else {
+            nextLambdaResOcc = nullptr;
+          }
+          break;
+        }
+        default:
+          ASSERT(false, "CreateSortedOccs: unexpected occTy");
+          break;
+      }
+    }
+  } while (pickedOcc != nullptr);
+  // initialize lambdaRes vector in each SLambdaOcc node and useLambdaOcc in each SLambdaResOcc
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    for (BB *succ : lambdaOcc->cgbb->GetSuccs()) {
+      SLambdaResOcc *lambdaResOcc = bb2LambdaResMap[succ->GetId()].front();
+      lambdaOcc->lambdaRes.push_back(lambdaResOcc);
+      lambdaResOcc->useLambdaOcc = lambdaOcc;
+      bb2LambdaResMap[succ->GetId()].pop_front();
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after lambda insertion _______" << '\n';
+    for (SOcc *occ : allOccs) {
+      occ->Dump();
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 0: Preparations ================
+
+void SSUPre::PropagateNotAvail(BB *bb, std::set<BB*, BBIdCmp> *visitedBBs) {
+  if (visitedBBs->count(bb) != 0) {
+    return;
+  }
+  visitedBBs->insert(bb);
+  if (workCand->occBBs.count(bb->GetId()) != 0 ||
+      workCand->saveBBs.count(bb->GetId()) != 0) {
+    return;
+  }
+  fullyAvailBBs[bb->GetId()] = false;
+  for (BB *succbb : bb->GetSuccs()) {
+    PropagateNotAvail(succbb, visitedBBs);
+  }
+}
+
+void SSUPre::FormReals() {
+  if (!asLateAsPossible) {
+    for (uint32 i = 0; i < pdom->GetPdtPreOrderSize(); i++) {
+      BBId bbid = pdom->GetPdtPreOrderItem(i);
+      BB *cgbb = cgFunc->GetAllBBs()[bbid];
+      if (workCand->saveBBs.count(cgbb->GetId()) != 0) {
+        SRealOcc *realOcc = spreMp->New<SRealOcc>(cgbb);
+        realOccs.push_back(realOcc);
+        SKillOcc *killOcc = spreMp->New<SKillOcc>(cgbb);
+        realOccs.push_back(killOcc);
+      } else if (workCand->occBBs.count(cgbb->GetId()) != 0) {
+        SRealOcc *realOcc = spreMp->New<SRealOcc>(cgbb);
+        realOccs.push_back(realOcc);
+      }
+    }
+  } else {
+    std::set<BB*, BBIdCmp> visitedBBs;
+    fullyAvailBBs[cgFunc->GetCommonExitBB()->GetId()] = false;
+    PropagateNotAvail(cgFunc->GetFirstBB(), &visitedBBs);
+    for (uint32 i = 0; i < pdom->GetPdtPreOrderSize(); i++) {
+      BBId bbid = pdom->GetPdtPreOrderItem(i);
+      BB *cgbb = cgFunc->GetAllBBs()[bbid];
+      if (fullyAvailBBs[cgbb->GetId()]) {
+        SRealOcc *realOcc = spreMp->New<SRealOcc>(cgbb);
+        realOccs.push_back(realOcc);
+        if (workCand->saveBBs.count(cgbb->GetId()) != 0) {
+          SKillOcc *killOcc = spreMp->New<SKillOcc>(cgbb);
+          realOccs.push_back(killOcc);
+        }
+      }
+    }
+  }
+
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "Placement Optimization for callee-save restores" << '\n';
+    LogInfo::MapleLogger() << "-----------------------------------------------" << '\n';
+    LogInfo::MapleLogger() << " _______ input _______" << '\n';
+    LogInfo::MapleLogger() << " occBBs: [";
+    for (uint32 id : workCand->occBBs) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "]\n saveBBs: [";
+    for (uint32 id : workCand->saveBBs) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "]\n";
+  }
+}
+
+void SSUPre::ApplySSUPre() {
+  FormReals();
+  // #1 insert lambdas; results in allOccs and lambdaOccs
+  FormLambdas();  // result put in the set lambda_bbs
+  CreateSortedOccs();
+  // #2 rename
+  Rename();
+  if (!lambdaOccs.empty()) {
+    // #3 UpSafety
+    ComputeUpsafe();
+    // #4 CanBeAnt
+    ComputeCanBeAnt();
+    ComputeEarlier();
+  }
+  // #5 Finalize
+  Finalize();
+  if (!workCand->restoreAtEpilog) {
+    // #6 Code Motion
+    CodeMotion();
+  }
+}
+
+void DoRestorePlacementOpt(CGFunc *f, PostDomAnalysis *pdom, SPreWorkCand *workCand) {
+  MemPool *tempMP = memPoolCtrler.NewMemPool("cg_ssu_pre", true);
+  SSUPre cgssupre(f, pdom, tempMP, workCand, true, false); /* asLateAsPossible, enabledDebug */
+
+  cgssupre.ApplySSUPre();
+
+  memPoolCtrler.DeleteMemPool(tempMP);
+}
+
+}  // namespace maplebe
diff --git a/src/mapleall/maple_be/src/cg/cg_validbit_opt.cpp b/src/mapleall/maple_be/src/cg/cg_validbit_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..586f1135fafff2aec1edeb706254e2424e7363dc
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_validbit_opt.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cg_validbit_opt.h"
+#include "mempool.h"
+#include "aarch64_validbit_opt.h"
+
+namespace maplebe {
+InsnSet ValidBitPattern::GetAllUseInsn(const RegOperand &defReg) {
+  InsnSet allUseInsn;
+  if ((ssaInfo != nullptr) && defReg.IsSSAForm()) {
+    VRegVersion *defVersion = ssaInfo->FindSSAVersion(defReg.GetRegisterNumber());
+    CHECK_FATAL(defVersion != nullptr, "useVRegVersion must not be null based on ssa");
+    for (auto insnInfo : defVersion->GetAllUseInsns()) {
+      Insn *currInsn = insnInfo.second->GetInsn();
+      allUseInsn.emplace(currInsn);
+    }
+  }
+  return allUseInsn;
+}
+
+void ValidBitPattern::DumpAfterPattern(std::vector<Insn*> &prevInsns, const Insn *replacedInsn, const Insn *newInsn) {
+  LogInfo::MapleLogger() << ">>>>>>> In " << GetPatternName() << " : <<<<<<<\n";
+  if (!prevInsns.empty()) {
+    if ((replacedInsn == nullptr) && (newInsn == nullptr)) {
+      LogInfo::MapleLogger() << "======= RemoveInsns : {\n";
+    } else {
+      LogInfo::MapleLogger() << "======= PrevInsns : {\n";
+    }
+    for (auto *prevInsn : prevInsns) {
+      if (prevInsn != nullptr) {
+        LogInfo::MapleLogger() << "[primal form] ";
+        prevInsn->Dump();
+        if (ssaInfo != nullptr) {
+          LogInfo::MapleLogger() << "[ssa form] ";
+          ssaInfo->DumpInsnInSSAForm(*prevInsn);
+        }
+      }
+    }
+    LogInfo::MapleLogger() << "}\n";
+  }
+  if (replacedInsn != nullptr) {
+    LogInfo::MapleLogger() << "======= OldInsn :\n";
+    LogInfo::MapleLogger() << "[primal form] ";
+    replacedInsn->Dump();
+    if (ssaInfo != nullptr) {
+      LogInfo::MapleLogger() << "[ssa form] ";
+      ssaInfo->DumpInsnInSSAForm(*replacedInsn);
+    }
+  }
+  if (newInsn != nullptr) {
+    LogInfo::MapleLogger() << "======= NewInsn :\n";
+    LogInfo::MapleLogger() << "[primal form] ";
+    newInsn->Dump();
+    if (ssaInfo != nullptr) {
+      LogInfo::MapleLogger() << "[ssa form] ";
+      ssaInfo->DumpInsnInSSAForm(*newInsn);
+    }
+  }
+}
+
+void ValidBitOpt::RectifyValidBitNum() {
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      SetValidBits(*insn);
+    }
+  }
+  bool iterate;
+  /* Use reverse postorder to converge with minimal iterations */
+  do {
+    iterate = false;
+    MapleVector<uint32> reversePostOrder = ssaInfo->GetReversePostOrder();
+    for (uint32 bbId : reversePostOrder) {
+      BB *bb = cgFunc->GetBBFromID(bbId);
+      FOR_BB_INSNS(insn, bb) {
+        if (!insn->IsPhi()) {
+          continue;
+        }
+        bool change = SetPhiValidBits(*insn);
+        if (change) {
+          /* if vb changes once, iterate. */
+          iterate = true;
+        }
+      }
+    }
+  } while (iterate);
+}
+
+void ValidBitOpt::RecoverValidBitNum() {
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction() && !insn->IsPhi()) {
+        continue;
+      }
+      uint32 opndNum = insn->GetOperandSize();
+      for (uint32 i = 0; i < opndNum; ++i) {
+        Operand &opnd = insn->GetOperand(i);
+        if (!opnd.IsRegister()) {
+          continue;
+        }
+        auto &regOpnd = static_cast<RegOperand&>(opnd);
+        if (insn->OpndIsDef(i)) {
+          regOpnd.SetValidBitsNum(regOpnd.GetSize());
+        }
+      }
+    }
+  }
+}
+
+void ValidBitOpt::Run() {
+  /*
+   * Set validbit of regOpnd before optimization
+   */
+  RectifyValidBitNum();
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      DoOpt(*bb, *insn);
+    }
+  }
+  /*
+   * Recover validbit of regOpnd after optimization
+   */
+  RecoverValidBitNum();
+}
+
+bool CgValidBitOpt::PhaseRun(maplebe::CGFunc &f) {
+  CGSSAInfo *ssaInfo = GET_ANALYSIS(CgSSAConstruct, f);
+  CHECK_FATAL(ssaInfo != nullptr, "Get ssaInfo failed");
+  auto *vbOpt = f.GetCG()->CreateValidBitOpt(*GetPhaseMemPool(), f, *ssaInfo);
+  CHECK_FATAL(vbOpt != nullptr, "vbOpt instance create failed");
+  vbOpt->Run();
+  return true;
+}
+
+void CgValidBitOpt::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<CgSSAConstruct>();
+  aDep.AddPreserved<CgSSAConstruct>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgValidBitOpt, cgvalidbitopt)
+} /* namespace maplebe */
+
diff --git a/src/mapleall/maple_be/src/cg/cgbb.cpp b/src/mapleall/maple_be/src/cg/cgbb.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1a4b3f72163b5709189dca7ef1998de09e16621b
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cgbb.cpp
@@ -0,0 +1,557 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cgbb.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+constexpr uint32 kCondBrNum = 2;
+constexpr uint32 kSwitchCaseNum = 5;
+
+const std::string BB::bbNames[BB::kBBLast] = {
+    "BB_ft",
+    "BB_if",
+    "BB_goto",
+    "BB_igoto",
+    "BB_ret",
+    "BB_intrinsic",
+    "BB_rangegoto",
+    "BB_throw"
+};
+
+Insn *BB::InsertInsnBefore(Insn &existing, Insn &newInsn) {
+  Insn *pre = existing.GetPrev();
+  newInsn.SetPrev(pre);
+  newInsn.SetNext(&existing);
+  existing.SetPrev(&newInsn);
+  if (pre != nullptr) {
+    pre->SetNext(&newInsn);
+  }
+  if (&existing == firstInsn) {
+    firstInsn = &newInsn;
+  }
+  newInsn.SetBB(this);
+  return &newInsn;
+}
+
+Insn *BB::InsertInsnAfter(Insn &existing, Insn &newInsn) {
+  newInsn.SetPrev(&existing);
+  newInsn.SetNext(existing.GetNext());
+  existing.SetNext(&newInsn);
+  if (&existing == lastInsn) {
+    lastInsn = &newInsn;
+  } else if (newInsn.GetNext()) {
+    newInsn.GetNext()->SetPrev(&newInsn);
+  }
+  newInsn.SetBB(this);
+  internalFlag1++;
+  return &newInsn;
+}
+
+void BB::ReplaceInsn(Insn &insn, Insn &newInsn) {
+  if (insn.IsAccessRefField()) {
+    newInsn.MarkAsAccessRefField(true);
+  }
+  if (insn.GetDoNotRemove()) {
+    newInsn.SetDoNotRemove(true);
+  }
+  newInsn.SetPrev(insn.GetPrev());
+  newInsn.SetNext(insn.GetNext());
+  if (&insn == lastInsn) {
+    lastInsn = &newInsn;
+  } else if (newInsn.GetNext() != nullptr) {
+    newInsn.GetNext()->SetPrev(&newInsn);
+  }
+  if (firstInsn == &insn) {
+    firstInsn = &newInsn;
+  } else if (newInsn.GetPrev() != nullptr) {
+    newInsn.GetPrev()->SetNext(&newInsn);
+  }
+  newInsn.SetComment(insn.GetComment());
+  newInsn.SetBB(this);
+}
+
+void BB::RemoveInsn(Insn &insn) {
+  if ((firstInsn == &insn) && (lastInsn == &insn)) {
+    firstInsn = lastInsn = nullptr;
+  } else if (firstInsn == &insn) {
+    firstInsn = insn.GetNext();
+  } else if (lastInsn == &insn) {
+    lastInsn = insn.GetPrev();
+  }
+  /* remove insn from lir list */
+  Insn *prevInsn = insn.GetPrev();
+  Insn *nextInsn = insn.GetNext();
+  if (prevInsn != nullptr) {
+    prevInsn->SetNext(nextInsn);
+  }
+  if (nextInsn != nullptr) {
+    nextInsn->SetPrev(prevInsn);
+  }
+}
+
+void BB::RemoveInsnPair(Insn &insn, const Insn &nextInsn) {
+  ASSERT(insn.GetNext() == &nextInsn, "next_insn is supposed to follow insn");
+  ASSERT(nextInsn.GetPrev() == &insn, "next_insn is supposed to follow insn");
+  if ((firstInsn == &insn) && (lastInsn == &nextInsn)) {
+    firstInsn = lastInsn = nullptr;
+  } else if (firstInsn == &insn) {
+    firstInsn = nextInsn.GetNext();
+  } else if (lastInsn == &nextInsn) {
+    lastInsn = insn.GetPrev();
+  }
+  if (insn.GetPrev() != nullptr) {
+    insn.GetPrev()->SetNext(nextInsn.GetNext());
+  }
+  if (nextInsn.GetNext() != nullptr) {
+    nextInsn.GetNext()->SetPrev(insn.GetPrev());
+  }
+}
+
+/* Remove insns in this bb from insn1 to insn2. */
+void BB::RemoveInsnSequence(Insn &insn, const Insn &nextInsn) {
+  ASSERT(insn.GetBB() == this, "remove insn sequence in one bb");
+  ASSERT(nextInsn.GetBB() == this, "remove insn sequence in one bb");
+  if ((firstInsn == &insn) && (lastInsn == &nextInsn)) {
+    firstInsn = lastInsn = nullptr;
+  } else if (firstInsn == &insn) {
+    firstInsn = nextInsn.GetNext();
+  } else if (lastInsn == &nextInsn) {
+    lastInsn = insn.GetPrev();
+  }
+
+  if (insn.GetPrev() != nullptr) {
+    insn.GetPrev()->SetNext(nextInsn.GetNext());
+  }
+  if (nextInsn.GetNext() != nullptr) {
+    nextInsn.GetNext()->SetPrev(insn.GetPrev());
+  }
+}
+
+/* append all insns from bb into this bb */
+void BB::AppendBBInsns(BB &bb) {
+  if (firstInsn == nullptr) {
+    firstInsn = bb.firstInsn;
+    lastInsn = bb.lastInsn;
+    if (firstInsn != nullptr) {
+      FOR_BB_INSNS(i, &bb) {
+        i->SetBB(this);
+      }
+    }
+    return;
+  }
+  if ((bb.firstInsn == nullptr) || (bb.lastInsn == nullptr)) {
+    return;
+  }
+  FOR_BB_INSNS_SAFE(insn, &bb, nextInsn) {
+    AppendInsn(*insn);
+  }
+}
+
+/* prepend all insns from bb into this bb */
+void BB::InsertAtBeginning(BB &bb) {
+  if (bb.firstInsn == nullptr) { /* nothing to add */
+    return;
+  }
+
+  FOR_BB_INSNS(insn, &bb) {
+    insn->SetBB(this);
+  }
+
+  if (firstInsn == nullptr) {
+    firstInsn = bb.firstInsn;
+    lastInsn = bb.lastInsn;
+  } else {
+    bb.lastInsn->SetNext(firstInsn);
+    firstInsn->SetPrev(bb.lastInsn);
+    firstInsn = bb.firstInsn;
+  }
+  bb.firstInsn = bb.lastInsn = nullptr;
+}
+
+/* append all insns from bb into this bb */
+void BB::InsertAtEnd(BB &bb) {
+  if (bb.firstInsn == nullptr) { /* nothing to add */
+    return;
+  }
+
+  FOR_BB_INSNS(insn, &bb) {
+    insn->SetBB(this);
+  }
+
+  if (firstInsn == nullptr) {
+    firstInsn = bb.firstInsn;
+    lastInsn = bb.lastInsn;
+  } else {
+    bb.firstInsn->SetPrev(lastInsn);
+    lastInsn->SetNext(bb.firstInsn);
+    lastInsn = bb.lastInsn;
+  }
+  bb.firstInsn = bb.lastInsn = nullptr;
+}
+
+/* Insert all insns from bb into this bb before the last instr */
+void BB::InsertAtEndMinus1(BB &bb) {
+  if (bb.firstInsn == nullptr) { /* nothing to add */
+    return;
+  }
+
+  if (NumInsn() == 1) {
+    InsertAtBeginning(bb);
+    return;
+  }
+
+  FOR_BB_INSNS(insn, &bb) {
+    insn->SetBB(this);
+  }
+
+  if (firstInsn == nullptr) {
+    firstInsn = bb.firstInsn;
+    lastInsn = bb.lastInsn;
+  } else {
+    /* Add between prevLast and lastInsn */
+    Insn *realLastInsn = GetLastMachineInsn() != nullptr ? GetLastMachineInsn() : lastInsn;
+    Insn *prevLast = realLastInsn->GetPrev();
+    if (prevLast == nullptr) {
+      firstInsn = bb.firstInsn;
+    } else {
+      bb.firstInsn->SetPrev(prevLast);
+      prevLast->SetNext(bb.firstInsn);
+    }
+    if (lastInsn == realLastInsn) {
+      lastInsn->SetPrev(bb.lastInsn);
+      bb.lastInsn->SetNext(lastInsn);
+    } else {
+      realLastInsn->SetPrev(bb.lastInsn);
+      bb.lastInsn->SetNext(realLastInsn);
+    }
+  }
+  bb.firstInsn = bb.lastInsn = nullptr;
+}
+
+/* Number of instructions excluding DbgInsn and comments */
+int32 BB::NumInsn() const {
+  int32 bbSize = 0;
+  FOR_BB_INSNS_CONST(i, this) {
+    if (i->IsImmaterialInsn() || i->IsDbgInsn()) {
+      continue;
+    }
+    ++bbSize;
+  }
+  return bbSize;
+}
+
+bool BB::IsInPhiList(regno_t regNO) {
+  for (auto phiInsnIt : phiInsnList) {
+    Insn *phiInsn = phiInsnIt.second;
+    if (phiInsn == nullptr) {
+      continue;
+    }
+    auto &phiListOpnd = static_cast<PhiOperand&>(phiInsn->GetOperand(kInsnSecondOpnd));
+    for (auto phiListIt : phiListOpnd.GetOperands()) {
+      RegOperand *phiUseOpnd = phiListIt.second;
+      if (phiUseOpnd == nullptr) {
+        continue;
+      }
+      if (phiUseOpnd->GetRegisterNumber() == regNO) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool BB::IsInPhiDef(regno_t regNO) {
+  for (auto phiInsnIt : phiInsnList) {
+    Insn *phiInsn = phiInsnIt.second;
+    if (phiInsn == nullptr) {
+      continue;
+    }
+    auto &phiDefOpnd = static_cast<RegOperand&>(phiInsn->GetOperand(kInsnFirstOpnd));
+    if (phiDefOpnd.GetRegisterNumber() == regNO) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool BB::HasCriticalEdge() {
+  constexpr int minPredsNum = 2;
+  if (preds.size() < minPredsNum) {
+    return false;
+  }
+  for (BB *pred : preds) {
+    if (pred->GetKind() == BB::kBBGoto || pred->GetKind() == BB::kBBIgoto) {
+      continue;
+    }
+    if (pred->GetSuccs().size() > 1) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void BB::Dump() const {
+  LogInfo::MapleLogger() << "=== BB " << this << " <" << GetKindName();
+  if (labIdx != 0) {
+    LogInfo::MapleLogger() << "[labeled with " << labIdx << "]";
+    if (labelTaken) {
+      LogInfo::MapleLogger() << " taken";
+    }
+  }
+  LogInfo::MapleLogger() << "> <" << id << "> ";
+  if (isCleanup) {
+    LogInfo::MapleLogger() << "[is_cleanup] ";
+  }
+  if (unreachable) {
+    LogInfo::MapleLogger() << "[unreachable] ";
+  }
+  LogInfo::MapleLogger() << "succs ";
+  for (auto *bb : succs) {
+    LogInfo::MapleLogger() << bb->id << " ";
+  }
+  LogInfo::MapleLogger() << "preds ";
+  for (auto *bb : preds) {
+    LogInfo::MapleLogger() << bb->id << " ";
+  }
+  LogInfo::MapleLogger() << "frequency:" << frequency << "===\n";
+
+  Insn *insn = firstInsn;
+  while (insn != nullptr) {
+    insn->Dump();
+    insn = insn->GetNext();
+  }
+}
+
+bool BB::IsCommentBB() const {
+  if (GetKind() != kBBFallthru) {
+    return false;
+  }
+  FOR_BB_INSNS_CONST(insn, this) {
+    if (insn->IsMachineInstruction()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/* return true if bb has no real insns. */
+bool BB::IsEmptyOrCommentOnly() const {
+  return (IsEmpty() || IsCommentBB());
+}
+
+bool BB::IsSoloGoto() const {
+  if (GetKind() != kBBGoto) {
+    return false;
+  }
+  if (GetHasCfi()) {
+    return false;
+  }
+  FOR_BB_INSNS_CONST(insn, this) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    return (insn->IsUnCondBranch());
+  }
+  return false;
+}
+
+BB *BB::GetValidPrev() {
+  BB *pre = GetPrev();
+  while (pre != nullptr && (pre->IsEmptyOrCommentOnly() || pre->IsUnreachable())) {
+    pre = pre->GetPrev();
+  }
+  return pre;
+}
+
+bool Bfs::AllPredBBVisited(const BB &bb, long &level) const {
+  bool isAllPredsVisited = true;
+  for (const auto *predBB : bb.GetPreds()) {
+    /* See if pred bb is a loop back edge */
+    bool isBackEdge = false;
+    for (const auto *loopBB : predBB->GetLoopSuccs()) {
+      if (loopBB == &bb) {
+        isBackEdge = true;
+        break;
+      }
+    }
+    if (!isBackEdge && !visitedBBs[predBB->GetId()]) {
+      isAllPredsVisited = false;
+      break;
+    }
+    level = std::max(level, predBB->GetInternalFlag2());
+  }
+  for (const auto *predEhBB : bb.GetEhPreds()) {
+    bool isBackEdge = false;
+    for (const auto *loopBB : predEhBB->GetLoopSuccs()) {
+      if (loopBB == &bb) {
+        isBackEdge = true;
+        break;
+      }
+    }
+    if (!isBackEdge && !visitedBBs[predEhBB->GetId()]) {
+      isAllPredsVisited = false;
+      break;
+    }
+    level = std::max(level, predEhBB->GetInternalFlag2());
+  }
+  return isAllPredsVisited;
+}
+
+/*
+ * During live interval construction, bb has only one predecessor and/or one
+ * successor are stright line bb.  It can be considered to be a single large bb
+ * for the purpose of finding live interval.  This is to prevent extending live
+ * interval of registers unnecessarily when interleaving bb from other paths.
+ */
+BB *Bfs::MarkStraightLineBBInBFS(BB *bb) {
+  while (true) {
+    if ((bb->GetSuccs().size() != 1) || !bb->GetEhSuccs().empty()) {
+      break;
+    }
+    BB *sbb = bb->GetSuccs().front();
+    if (visitedBBs[sbb->GetId()]) {
+      break;
+    }
+    if ((sbb->GetPreds().size() != 1) || !sbb->GetEhPreds().empty()) {
+      break;
+    }
+    sortedBBs.push_back(sbb);
+    visitedBBs[sbb->GetId()] = true;
+    sbb->SetInternalFlag2(bb->GetInternalFlag2() + 1);
+    bb = sbb;
+  }
+  return bb;
+}
+
+BB *Bfs::SearchForStraightLineBBs(BB &bb) {
+  if ((bb.GetSuccs().size() != kCondBrNum) || bb.GetEhSuccs().empty()) {
+    return &bb;
+  }
+  BB *sbb1 = bb.GetSuccs().front();
+  BB *sbb2 = bb.GetSuccs().back();
+  size_t predSz1 = sbb1->GetPreds().size();
+  size_t predSz2 = sbb2->GetPreds().size();
+  BB *candidateBB = nullptr;
+  if ((predSz1 == 1) && (predSz2 > kSwitchCaseNum)) {
+    candidateBB = sbb1;
+  } else if ((predSz2 == 1) && (predSz1 > kSwitchCaseNum)) {
+    candidateBB = sbb2;
+  } else {
+    return &bb;
+  }
+  ASSERT(candidateBB->GetId() < visitedBBs.size(), "index out of range in RA::SearchForStraightLineBBs");
+  if (visitedBBs[candidateBB->GetId()]) {
+    return &bb;
+  }
+  if (!candidateBB->GetEhPreds().empty()) {
+    return &bb;
+  }
+  if (candidateBB->GetSuccs().size() != 1) {
+    return &bb;
+  }
+
+  sortedBBs.push_back(candidateBB);
+  visitedBBs[candidateBB->GetId()] = true;
+  return MarkStraightLineBBInBFS(candidateBB);
+}
+
+void Bfs::BFS(BB &curBB) {
+  std::queue<BB*> workList;
+  workList.push(&curBB);
+  ASSERT(curBB.GetId() < cgfunc->NumBBs(), "RA::BFS visitedBBs overflow");
+  ASSERT(curBB.GetId() < visitedBBs.size(), "index out of range in RA::BFS");
+  visitedBBs[curBB.GetId()] = true;
+  do {
+    BB *bb = workList.front();
+    sortedBBs.push_back(bb);
+    ASSERT(bb->GetId() < cgfunc->NumBBs(), "RA::BFS visitedBBs overflow");
+    visitedBBs[bb->GetId()] = true;
+    workList.pop();
+    /* Look for straight line bb */
+    bb = MarkStraightLineBBInBFS(bb);
+    /* Look for an 'if' followed by some straight-line bb */
+    bb = SearchForStraightLineBBs(*bb);
+    for (auto *ibb : bb->GetSuccs()) {
+      /* See if there are unvisited predecessor */
+      if (visitedBBs[ibb->GetId()]) {
+        continue;
+      }
+      long prevLevel = 0;
+      if (AllPredBBVisited(*ibb, prevLevel)) {
+        ibb->SetInternalFlag2(prevLevel + 1);
+        workList.push(ibb);
+        ASSERT(ibb->GetId() < cgfunc->NumBBs(), "GCRA::BFS visitedBBs overflow");
+        visitedBBs[ibb->GetId()] = true;
+      }
+    }
+  } while (!workList.empty());
+}
+
+void Bfs::ComputeBlockOrder() {
+  visitedBBs.clear();
+  sortedBBs.clear();
+  visitedBBs.resize(cgfunc->NumBBs());
+  for (uint32 i = 0; i < cgfunc->NumBBs(); ++i) {
+    visitedBBs[i] = false;
+  }
+  BB *cleanupBB = nullptr;
+  FOR_ALL_BB(bb, cgfunc) {
+    bb->SetInternalFlag1(0);
+    bb->SetInternalFlag2(1);
+    if (bb->IsCleanup()) {
+      ASSERT(cleanupBB == nullptr, "one cleanupBB in the function only");
+      cleanupBB = bb;
+    }
+  }
+  if (cleanupBB != nullptr) {
+    cleanupBB->SetInternalFlag1(1);
+  }
+
+  bool changed;
+  size_t sortedCnt = 0;
+  bool done = false;
+  do {
+    changed = false;
+    FOR_ALL_BB(bb, cgfunc) {
+      if (bb->GetInternalFlag1() == 1) {
+        continue;
+      }
+      if (visitedBBs[bb->GetId()]) {
+        continue;
+      }
+      changed = true;
+      long prevLevel = 0;
+      if (AllPredBBVisited(*bb, prevLevel)) {
+        bb->SetInternalFlag2(prevLevel + 1);
+        BFS(*bb);
+      }
+    }
+    /* Make sure there is no infinite loop. */
+    if (sortedCnt == sortedBBs.size()) {
+      if (!done) {
+        done = true;
+      } else {
+        LogInfo::MapleLogger() << "Error: RA BFS loop " << sortedCnt << " in func " << cgfunc->GetName() << "\n";
+        CHECK_FATAL(false, "");
+      }
+    }
+    sortedCnt = sortedBBs.size();
+  } while (changed);
+
+  if (cleanupBB != nullptr) {
+    sortedBBs.push_back(cleanupBB);
+  }
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/cgfunc.cpp b/src/mapleall/maple_be/src/cg/cgfunc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9162042dd37b5553cd51d9ba2702f180514daa52
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cgfunc.cpp
@@ -0,0 +1,2352 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cgfunc.h"
+#if DEBUG
+#include <iomanip>
+#endif
+#include "cg.h"
+#include "insn.h"
+#include "loop.h"
+#include "mir_builder.h"
+#include "factory.h"
+#include "debug_info.h"
+#include "cfgo.h"
+#include "optimize_common.h"
+#include "me_function.h"
+
+namespace maplebe {
+using namespace maple;
+
+#define JAVALANG (GetMirModule().IsJavaModule())
+
+Operand *HandleDread(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &dreadNode = static_cast<AddrofNode&>(expr);
+  return cgFunc.SelectDread(parent, dreadNode);
+}
+
+Operand *HandleRegread(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  (void)parent;
+  auto &regReadNode = static_cast<RegreadNode&>(expr);
+  if (regReadNode.GetRegIdx() == -kSregRetval0 || regReadNode.GetRegIdx() == -kSregRetval1) {
+    return &cgFunc.ProcessReturnReg(regReadNode.GetPrimType(), -(regReadNode.GetRegIdx()));
+  }
+  return cgFunc.SelectRegread(regReadNode);
+}
+
+Operand *HandleConstVal(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &constValNode = static_cast<ConstvalNode&>(expr);
+  MIRConst *mirConst = constValNode.GetConstVal();
+  ASSERT(mirConst != nullptr, "get constval of constvalnode failed");
+  if (mirConst->GetKind() == kConstInt) {
+    auto *mirIntConst = safe_cast<MIRIntConst>(mirConst);
+    return cgFunc.SelectIntConst(*mirIntConst);
+  } else if (mirConst->GetKind() == kConstFloatConst) {
+    auto *mirFloatConst = safe_cast<MIRFloatConst>(mirConst);
+    return cgFunc.SelectFloatConst(*mirFloatConst, parent);
+  } else if (mirConst->GetKind() == kConstDoubleConst) {
+    auto *mirDoubleConst = safe_cast<MIRDoubleConst>(mirConst);
+    return cgFunc.SelectDoubleConst(*mirDoubleConst, parent);
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+  return nullptr;
+}
+
+Operand *HandleConstStr(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  (void)parent;
+  auto &constStrNode = static_cast<ConststrNode&>(expr);
+#if TARGAARCH64 || TARGRISCV64
+  if (CGOptions::IsArm64ilp32()) {
+    return cgFunc.SelectStrConst(*cgFunc.GetMemoryPool()->New<MIRStrConst>(
+        constStrNode.GetStrIdx(), *GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_a32))));
+  } else {
+    return cgFunc.SelectStrConst(*cgFunc.GetMemoryPool()->New<MIRStrConst>(
+        constStrNode.GetStrIdx(), *GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_a64))));
+  }
+#else
+  return cgFunc.SelectStrConst(*cgFunc.GetMemoryPool()->New<MIRStrConst>(
+      constStrNode.GetStrIdx(), *GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)PTY_a32)));
+#endif
+}
+
+Operand *HandleConstStr16(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  (void)parent;
+  auto &constStr16Node = static_cast<Conststr16Node&>(expr);
+#if TARGAARCH64 || TARGRISCV64
+  if (CGOptions::IsArm64ilp32()) {
+    return cgFunc.SelectStr16Const(*cgFunc.GetMemoryPool()->New<MIRStr16Const>(
+        constStr16Node.GetStrIdx(), *GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_a32))));
+  } else {
+    return cgFunc.SelectStr16Const(*cgFunc.GetMemoryPool()->New<MIRStr16Const>(
+        constStr16Node.GetStrIdx(), *GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_a64))));
+  }
+#else
+  return cgFunc.SelectStr16Const(*cgFunc.GetMemoryPool()->New<MIRStr16Const>(
+      constStr16Node.GetStrIdx(), *GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)PTY_a32)));
+#endif
+}
+
+Operand *HandleAdd(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel2 && expr.Opnd(0)->GetOpCode() == OP_mul &&
+      !IsPrimitiveVector(expr.GetPrimType()) &&
+      !IsPrimitiveFloat(expr.GetPrimType()) && expr.Opnd(0)->Opnd(0)->GetOpCode() != OP_constval &&
+      expr.Opnd(0)->Opnd(1)->GetOpCode() != OP_constval) {
+    return cgFunc.SelectMadd(static_cast<BinaryNode&>(expr),
+                             *cgFunc.HandleExpr(*expr.Opnd(0), *expr.Opnd(0)->Opnd(0)),
+                             *cgFunc.HandleExpr(*expr.Opnd(0), *expr.Opnd(0)->Opnd(1)),
+                             *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+  } else if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel2 && expr.Opnd(1)->GetOpCode() == OP_mul &&
+             !IsPrimitiveVector(expr.GetPrimType()) &&
+             !IsPrimitiveFloat(expr.GetPrimType()) && expr.Opnd(1)->Opnd(0)->GetOpCode() != OP_constval &&
+             expr.Opnd(1)->Opnd(1)->GetOpCode() != OP_constval) {
+    return cgFunc.SelectMadd(static_cast<BinaryNode&>(expr),
+                             *cgFunc.HandleExpr(*expr.Opnd(0), *expr.Opnd(1)->Opnd(0)),
+                             *cgFunc.HandleExpr(*expr.Opnd(0), *expr.Opnd(1)->Opnd(1)),
+                             *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+  } else {
+    return cgFunc.SelectAdd(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                            *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+  }
+}
+
+Operand *HandleCGArrayElemAdd(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return &cgFunc.SelectCGArrayElemAdd(static_cast<BinaryNode&>(expr), parent);
+}
+
+BaseNode *IsConstantInVectorFromScalar(BaseNode *expr) {
+  if (expr->op != OP_intrinsicop) {
+    return nullptr;
+  }
+  IntrinsicopNode *intrn = static_cast<IntrinsicopNode *>(expr);
+  switch (intrn->GetIntrinsic()) {
+    case INTRN_vector_from_scalar_v8u8: case INTRN_vector_from_scalar_v8i8:
+    case INTRN_vector_from_scalar_v4u16: case INTRN_vector_from_scalar_v4i16:
+    case INTRN_vector_from_scalar_v2u32: case INTRN_vector_from_scalar_v2i32:
+    case INTRN_vector_from_scalar_v1u64: case INTRN_vector_from_scalar_v1i64:
+    case INTRN_vector_from_scalar_v16u8: case INTRN_vector_from_scalar_v16i8:
+    case INTRN_vector_from_scalar_v8u16: case INTRN_vector_from_scalar_v8i16:
+    case INTRN_vector_from_scalar_v4u32: case INTRN_vector_from_scalar_v4i32:
+    case INTRN_vector_from_scalar_v2u64: case INTRN_vector_from_scalar_v2i64: {
+      if (intrn->Opnd(0) != nullptr && intrn->Opnd(0)->op == OP_constval) {
+        return intrn->Opnd(0);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return nullptr;
+}
+
+Operand *HandleShift(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  BaseNode *cExpr = IsConstantInVectorFromScalar(expr.Opnd(1));
+  if (cExpr == nullptr) {
+    return cgFunc.SelectShift(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                              *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+  } else {
+    return cgFunc.SelectShift(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                              *cgFunc.HandleExpr(*expr.Opnd(1), *cExpr), parent);
+  }
+}
+
+Operand *HandleRor(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectRor(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                          *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleMpy(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectMpy(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                          *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleDiv(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectDiv(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                          *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleRem(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectRem(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                          *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleAddrof(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &addrofNode = static_cast<AddrofNode&>(expr);
+  return cgFunc.SelectAddrof(addrofNode, parent, false);
+}
+
+Operand *HandleAddrofoff(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &addrofoffNode = static_cast<AddrofoffNode&>(expr);
+  return cgFunc.SelectAddrofoff(addrofoffNode, parent);
+}
+
+Operand *HandleAddroffunc(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &addroffuncNode = static_cast<AddroffuncNode&>(expr);
+  return &cgFunc.SelectAddrofFunc(addroffuncNode, parent);
+}
+
+Operand *HandleAddrofLabel(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &addrofLabelNode = static_cast<AddroflabelNode&>(expr);
+  return &cgFunc.SelectAddrofLabel(addrofLabelNode, parent);
+}
+
+Operand *HandleIread(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &ireadNode = static_cast<IreadNode&>(expr);
+  return cgFunc.SelectIread(parent, ireadNode);
+}
+
+Operand *HandleIreadoff(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &ireadNode = static_cast<IreadoffNode&>(expr);
+  return cgFunc.SelectIreadoff(parent, ireadNode);
+}
+
+Operand *HandleIreadfpoff(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &ireadNode = static_cast<IreadFPoffNode&>(expr);
+  return cgFunc.SelectIreadfpoff(parent, ireadNode);
+}
+
+Operand *HandleSub(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectSub(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                          *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleBand(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectBand(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                           *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleBior(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectBior(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                           *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleBxor(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectBxor(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                           *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleAbs(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  (void)parent;
+  return cgFunc.SelectAbs(static_cast<UnaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleBnot(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectBnot(static_cast<UnaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleExtractBits(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  ExtractbitsNode &node = static_cast<ExtractbitsNode&>(expr);
+  uint8 bitOffset = node.GetBitsOffset();
+  uint8 bitSize = node.GetBitsSize();
+  if (!CGOptions::IsBigEndian() && (bitSize == k8BitSize || bitSize == k16BitSize) &&
+      GetPrimTypeBitSize(node.GetPrimType()) != k64BitSize &&
+      (bitOffset == 0 || bitOffset == k8BitSize || bitOffset == k16BitSize || bitOffset == k24BitSize) &&
+      expr.Opnd(0)->GetOpCode() == OP_iread && node.GetOpCode() == OP_extractbits) {
+    return cgFunc.SelectRegularBitFieldLoad(node, parent);
+  }
+  return cgFunc.SelectExtractbits(static_cast<ExtractbitsNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleDepositBits(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectDepositBits(static_cast<DepositbitsNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                                  *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleLnot(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectLnot(static_cast<UnaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleLand(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectLand(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                           *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleLor(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  if (parent.IsCondBr()) {
+    return cgFunc.SelectLor(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                            *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent, true);
+  } else {
+    return cgFunc.SelectLor(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                            *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+  }
+}
+
+Operand *HandleMin(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectMin(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                          *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleMax(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectMax(static_cast<BinaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                          *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleNeg(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectNeg(static_cast<UnaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleRecip(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectRecip(static_cast<UnaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleSqrt(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectSqrt(static_cast<UnaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleCeil(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectCeil(static_cast<TypeCvtNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleFloor(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectFloor(static_cast<TypeCvtNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleRetype(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  (void)parent;
+  return cgFunc.SelectRetype(static_cast<TypeCvtNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleCvt(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectCvt(parent, static_cast<TypeCvtNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleRound(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectRound(static_cast<TypeCvtNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleTrunc(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  return cgFunc.SelectTrunc(static_cast<TypeCvtNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+static bool HasCompare(const BaseNode *expr) {
+  if (kOpcodeInfo.IsCompare(expr->GetOpCode())) {
+    return true;
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    if (HasCompare(expr->Opnd(i))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+Operand *HandleSelect(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  /* 0,1,2 represent the first opnd and the second opnd and the third opnd of expr */
+  bool hasCompare = false;
+  if (HasCompare(expr.Opnd(1)) || HasCompare(expr.Opnd(2))) {
+    hasCompare = true;
+  }
+  Operand &trueOpnd = *cgFunc.HandleExpr(expr, *expr.Opnd(1));
+  Operand &falseOpnd = *cgFunc.HandleExpr(expr, *expr.Opnd(2));
+  Operand *cond = cgFunc.HandleExpr(expr, *expr.Opnd(0));
+  return cgFunc.SelectSelect(static_cast<TernaryNode&>(expr), *cond, trueOpnd, falseOpnd, parent, hasCompare);
+}
+
+Operand *HandleCmp(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  // fix opnd type before select insn
+  PrimType targetPtyp = parent.GetPrimType();
+  if (kOpcodeInfo.IsCompare(parent.GetOpCode())) {
+    targetPtyp = static_cast<const CompareNode&>(parent).GetOpndType();
+  } else if (kOpcodeInfo.IsTypeCvt(parent.GetOpCode())) {
+    targetPtyp = static_cast<const TypeCvtNode&>(parent).FromType();
+  }
+  if (IsPrimitiveInteger(targetPtyp) && targetPtyp != expr.GetPrimType()) {
+    expr.SetPrimType(targetPtyp);
+  }
+  return cgFunc.SelectCmpOp(static_cast<CompareNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)),
+                            *cgFunc.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleAlloca(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  (void)parent;
+  return cgFunc.SelectAlloca(static_cast<UnaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleMalloc(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  (void)parent;
+  return cgFunc.SelectMalloc(static_cast<UnaryNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleGCMalloc(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  (void)parent;
+  return cgFunc.SelectGCMalloc(static_cast<GCMallocNode&>(expr));
+}
+
+Operand *HandleJarrayMalloc(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  (void)parent;
+  return cgFunc.SelectJarrayMalloc(static_cast<JarrayMallocNode&>(expr), *cgFunc.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+/* Neon intrinsic handling */
+Operand *HandleVectorAddLong(const BaseNode &expr, CGFunc &cgFunc, bool isLow) {
+  Operand *o1 = cgFunc.HandleExpr(expr, *expr.Opnd(0));
+  Operand *o2 = cgFunc.HandleExpr(expr, *expr.Opnd(1));
+  return cgFunc.SelectVectorAddLong(expr.GetPrimType(), o1, o2, expr.Opnd(0)->GetPrimType(), isLow);
+}
+
+Operand *HandleVectorAddWiden(const BaseNode &expr, CGFunc &cgFunc, bool isLow) {
+  Operand *o1 = cgFunc.HandleExpr(expr, *expr.Opnd(0));
+  Operand *o2 = cgFunc.HandleExpr(expr, *expr.Opnd(1));
+  return cgFunc.SelectVectorAddWiden(o1, expr.Opnd(0)->GetPrimType(), o2, expr.Opnd(1)->GetPrimType(), isLow);
+}
+
+Operand *HandleVectorFromScalar(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  return cgFunc.SelectVectorFromScalar(intrnNode.GetPrimType(), cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0)),
+                                       intrnNode.Opnd(0)->GetPrimType());
+}
+
+Operand *HandleVectorAbsSubL(const IntrinsicopNode &intrnNode, CGFunc &cgFunc, bool isLow) {
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand 1 */
+  Operand *opnd2 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(1));   /* vector operand 2 */
+  return cgFunc.SelectVectorAbsSubL(intrnNode.GetPrimType(), opnd1, opnd2, intrnNode.Opnd(0)->GetPrimType(), isLow);
+}
+
+Operand *HandleVectorMerge(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand1 */
+  Operand *opnd2 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(1));   /* vector operand2 */
+  BaseNode *index = intrnNode.Opnd(2);                                 /* index operand */
+  int32 iNum = 0;
+  if (index->GetOpCode() == OP_constval) {
+    MIRConst *mirConst = static_cast<ConstvalNode *>(index)->GetConstVal();
+    iNum = static_cast<int32>(safe_cast<MIRIntConst>(mirConst)->GetExtValue());
+    PrimType ty = intrnNode.Opnd(0)->GetPrimType();
+    if (!IsPrimitiveVector(ty)) {
+      iNum = 0;
+    } else {
+      iNum *= GetPrimTypeSize(ty) / GetVecLanes(ty);              /* 64x2: 0-1 -> 0-8 */
+    }
+  } else {                                                             /* 32x4: 0-3 -> 0-12 */
+    CHECK_FATAL(0, "VectorMerge does not have const index");
+  }
+  return cgFunc.SelectVectorMerge(intrnNode.GetPrimType(), opnd1, opnd2, iNum);
+}
+
+Operand *HandleVectorGetHigh(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  PrimType rType = intrnNode.GetPrimType();                            /* result operand */
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand */
+  return cgFunc.SelectVectorDup(rType, opnd1, false);
+}
+
+Operand *HandleVectorGetLow(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  PrimType rType = intrnNode.GetPrimType();                            /* result operand */
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand */
+  return cgFunc.SelectVectorDup(rType, opnd1, true);
+}
+
+Operand *HandleVectorGetElement(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand */
+  PrimType o1Type = intrnNode.Opnd(0)->GetPrimType();
+  Operand *opndLane = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(1));
+  int32 laneNum = -1;
+  if (opndLane->IsConstImmediate()) {
+    MIRConst *mirConst = static_cast<ConstvalNode*>(intrnNode.Opnd(1))->GetConstVal();
+    laneNum = static_cast<int32>(safe_cast<MIRIntConst>(mirConst)->GetExtValue());
+  } else {
+    CHECK_FATAL(0, "VectorGetElement does not have lane const");
+  }
+  return cgFunc.SelectVectorGetElement(intrnNode.GetPrimType(), opnd1, o1Type, laneNum);
+}
+
+Operand *HandleVectorPairwiseAdd(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  Operand *src = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));     /* vector src operand */
+  PrimType sType = intrnNode.Opnd(0)->GetPrimType();
+  return cgFunc.SelectVectorPairwiseAdd(intrnNode.GetPrimType(), src, sType);
+}
+
+Operand *HandleVectorPairwiseAdalp(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  BaseNode *arg1 = intrnNode.Opnd(0);
+  BaseNode *arg2 = intrnNode.Opnd(1);
+  Operand *src1 = cgFunc.HandleExpr(intrnNode, *arg1);                  /* vector src operand 1 */
+  Operand *src2 = cgFunc.HandleExpr(intrnNode, *arg2);                  /* vector src operand 2 */
+  return cgFunc.SelectVectorPairwiseAdalp(src1, arg1->GetPrimType(), src2, arg2->GetPrimType());
+}
+
+Operand *HandleVectorSetElement(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  BaseNode *arg0 = intrnNode.Opnd(0);                                  /* uint32_t operand */
+  Operand *opnd0 = cgFunc.HandleExpr(intrnNode, *arg0);
+  PrimType aType = arg0->GetPrimType();
+
+  BaseNode *arg1 = intrnNode.Opnd(1);                                  /* vector operand == result */
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *arg1);
+  PrimType vType = arg1->GetPrimType();
+
+  BaseNode *arg2 = intrnNode.Opnd(2);                                  /* lane const operand */
+  Operand *opnd2 = cgFunc.HandleExpr(intrnNode, *arg2);
+  int32 laneNum = -1;
+  if (opnd2->IsConstImmediate()) {
+    MIRConst *mirConst = static_cast<ConstvalNode*>(arg2)->GetConstVal();
+    laneNum = static_cast<int32>(safe_cast<MIRIntConst>(mirConst)->GetExtValue());
+  } else {
+    CHECK_FATAL(0, "VectorSetElement does not have lane const");
+  }
+  return cgFunc.SelectVectorSetElement(opnd0, aType, opnd1, vType, laneNum);
+}
+
+Operand *HandleVectorReverse(const IntrinsicopNode &intrnNode, CGFunc &cgFunc, uint32 size) {
+  BaseNode *argExpr = intrnNode.Opnd(0);                               /* src operand */
+  Operand *src = cgFunc.HandleExpr(intrnNode, *argExpr);
+  MIRType *type = intrnNode.GetIntrinDesc().GetReturnType();
+  ASSERT(type != nullptr, "null ptr check");
+  auto revVecType = type->GetPrimType();
+  return cgFunc.SelectVectorReverse(revVecType, src, revVecType, size);
+}
+
+Operand *HandleVectorShiftNarrow(const IntrinsicopNode &intrnNode, CGFunc &cgFunc, bool isLow) {
+  PrimType rType = intrnNode.GetPrimType();                          /* vector result */
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand */
+  Operand *opnd2 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(1));   /* shift const */
+  if (!opnd2->IsConstImmediate()) {
+    CHECK_FATAL(0, "VectorShiftNarrow does not have shift const");
+  }
+  return cgFunc.SelectVectorShiftRNarrow(rType, opnd1, intrnNode.Opnd(0)->GetPrimType(), opnd2, isLow);
+}
+
+Operand *HandleVectorSubWiden(const IntrinsicopNode &intrnNode, CGFunc &cgFunc, bool isLow, bool isWide) {
+  PrimType resType = intrnNode.GetPrimType();                          /* uint32_t result */
+  Operand *o1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));
+  Operand *o2 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(1));
+  return cgFunc.SelectVectorSubWiden(resType, o1, intrnNode.Opnd(0)->GetPrimType(),
+                                     o2, intrnNode.Opnd(1)->GetPrimType(), isLow, isWide);
+}
+
+Operand *HandleVectorSum(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  PrimType resType = intrnNode.GetPrimType();                          /* uint32_t result */
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand */
+  return cgFunc.SelectVectorSum(resType, opnd1, intrnNode.Opnd(0)->GetPrimType());
+}
+
+Operand *HandleVectorTableLookup(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  PrimType rType = intrnNode.GetPrimType();                            /* result operand */
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand 1 */
+  Operand *opnd2 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(1));   /* vector operand 2 */
+  return cgFunc.SelectVectorTableLookup(rType, opnd1, opnd2);
+}
+
+Operand *HandleVectorMadd(const IntrinsicopNode &intrnNode, CGFunc &cgFunc) {
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand 1 */
+  Operand *opnd2 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(1));   /* vector operand 2 */
+  Operand *opnd3 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(2));   /* vector operand 3 */
+  PrimType oTyp1 = intrnNode.Opnd(0)->GetPrimType();
+  PrimType oTyp2 = intrnNode.Opnd(1)->GetPrimType();
+  PrimType oTyp3 = intrnNode.Opnd(2)->GetPrimType();
+  return cgFunc.SelectVectorMadd(opnd1, oTyp1, opnd2, oTyp2, opnd3, oTyp3);
+}
+
+Operand *HandleVectorMull(const IntrinsicopNode &intrnNode, CGFunc &cgFunc, bool isLow) {
+  PrimType rType = intrnNode.GetPrimType();                            /* result operand */
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector operand 1 */
+  Operand *opnd2 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(1));   /* vector operand 2 */
+  PrimType oTyp1 = intrnNode.Opnd(0)->GetPrimType();
+  PrimType oTyp2 = intrnNode.Opnd(1)->GetPrimType();
+  return cgFunc.SelectVectorMull(rType, opnd1, oTyp1, opnd2, oTyp2, isLow);
+}
+
+Operand *HandleVectorNarrow(const IntrinsicopNode &intrnNode, CGFunc &cgFunc, bool isLow) {
+  PrimType rType = intrnNode.GetPrimType();                            /* result operand */
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector opnd 1 */
+  if (isLow) {
+    return cgFunc.SelectVectorNarrow(rType, opnd1, intrnNode.Opnd(0)->GetPrimType());
+  } else {
+    Operand *opnd2 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(1)); /* vector opnd 2 */
+    return cgFunc.SelectVectorNarrow2(rType, opnd1, intrnNode.Opnd(0)->GetPrimType(), opnd2,
+                                      intrnNode.Opnd(1)->GetPrimType());
+  }
+}
+
+Operand *HandleVectorWiden(const IntrinsicopNode &intrnNode, CGFunc &cgFunc, bool isLow) {
+  PrimType rType = intrnNode.GetPrimType();                            /* result operand */
+  Operand *opnd1 = cgFunc.HandleExpr(intrnNode, *intrnNode.Opnd(0));   /* vector opnd 1 */
+  return cgFunc.SelectVectorWiden(rType, opnd1, intrnNode.Opnd(0)->GetPrimType(), isLow);
+}
+
+Operand *HandleVectorMovNarrow(const IntrinsicopNode &intrinsicNode, CGFunc &cgFunc) {
+  PrimType rType = intrinsicNode.GetPrimType();                            /* result operand */
+  Operand *opnd = cgFunc.HandleExpr(intrinsicNode, *intrinsicNode.Opnd(0));   /* vector opnd 1 */
+  return cgFunc.SelectVectorMovNarrow(rType, opnd, intrinsicNode.Opnd(0)->GetPrimType());
+}
+
+Operand *HandleIntrinOp(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc) {
+  auto &intrinsicopNode = static_cast<IntrinsicopNode&>(expr);
+  switch (intrinsicopNode.GetIntrinsic()) {
+    case INTRN_MPL_READ_OVTABLE_ENTRY_LAZY: {
+      Operand *srcOpnd = cgFunc.HandleExpr(intrinsicopNode, *intrinsicopNode.Opnd(0));
+      return cgFunc.SelectLazyLoad(*srcOpnd, intrinsicopNode.GetPrimType());
+    }
+    case INTRN_MPL_READ_STATIC_OFFSET_TAB: {
+      auto addrOfNode = static_cast<AddrofNode*>(intrinsicopNode.Opnd(0));
+      MIRSymbol *st = cgFunc.GetMirModule().CurFunction()->GetLocalOrGlobalSymbol(addrOfNode->GetStIdx());
+      auto constNode = static_cast<ConstvalNode*>(intrinsicopNode.Opnd(1));
+      CHECK_FATAL(constNode != nullptr, "null ptr check");
+      auto mirIntConst = static_cast<MIRIntConst*>(constNode->GetConstVal());
+      return cgFunc.SelectLazyLoadStatic(*st, mirIntConst->GetExtValue(), intrinsicopNode.GetPrimType());
+    }
+    case INTRN_MPL_READ_ARRAYCLASS_CACHE_ENTRY: {
+      auto addrOfNode = static_cast<AddrofNode*>(intrinsicopNode.Opnd(0));
+      MIRSymbol *st = cgFunc.GetMirModule().CurFunction()->GetLocalOrGlobalSymbol(addrOfNode->GetStIdx());
+      auto constNode = static_cast<ConstvalNode*>(intrinsicopNode.Opnd(1));
+      CHECK_FATAL(constNode != nullptr, "null ptr check");
+      auto mirIntConst = static_cast<MIRIntConst*>(constNode->GetConstVal());
+      return cgFunc.SelectLoadArrayClassCache(*st, mirIntConst->GetExtValue(), intrinsicopNode.GetPrimType());
+    }
+    // double
+    case INTRN_C_sin:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "sin");
+    case INTRN_C_sinh:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "sinh");
+    case INTRN_C_asin:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "asin");
+    case INTRN_C_cos:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "cos");
+    case INTRN_C_cosh:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "cosh");
+    case INTRN_C_acos:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "acos");
+    case INTRN_C_atan:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "atan");
+    case INTRN_C_exp:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "exp");
+    case INTRN_C_log:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "log");
+    case INTRN_C_log10:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "log10");
+    // float
+    case INTRN_C_sinf:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "sinf");
+    case INTRN_C_sinhf:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "sinhf");
+    case INTRN_C_asinf:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "asinf");
+    case INTRN_C_cosf:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "cosf");
+    case INTRN_C_coshf:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "coshf");
+    case INTRN_C_acosf:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "acosf");
+    case INTRN_C_atanf:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "atanf");
+    case INTRN_C_expf:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "expf");
+    case INTRN_C_logf:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "logf");
+    case INTRN_C_log10f:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "log10f");
+    // int
+    case INTRN_C_ffs:
+      return cgFunc.SelectIntrinsicOpWithOneParam(intrinsicopNode, "ffs");
+    // libc mem* and str* functions as intrinsicops
+    case INTRN_C_memcmp:
+      return cgFunc.SelectIntrinsicOpWithNParams(intrinsicopNode, PTY_i32, "memcmp");
+    case INTRN_C_strlen:
+      return cgFunc.SelectIntrinsicOpWithNParams(intrinsicopNode, PTY_u64, "strlen");
+    case INTRN_C_strcmp:
+      return cgFunc.SelectIntrinsicOpWithNParams(intrinsicopNode, PTY_i32, "strcmp");
+    case INTRN_C_strncmp:
+      return cgFunc.SelectIntrinsicOpWithNParams(intrinsicopNode, PTY_i32, "strncmp");
+    case INTRN_C_strchr:
+      return cgFunc.SelectIntrinsicOpWithNParams(intrinsicopNode, PTY_a64, "strchr");
+    case INTRN_C_strrchr:
+      return cgFunc.SelectIntrinsicOpWithNParams(intrinsicopNode, PTY_a64, "strrchr");
+    case INTRN_C_rev16_2:
+    case INTRN_C_rev_4:
+    case INTRN_C_rev_8:
+    case INTRN_C_bswap64:
+    case INTRN_C_bswap32:
+    case INTRN_C_bswap16:
+      return cgFunc.SelectBswap(intrinsicopNode, *cgFunc.HandleExpr(expr, *expr.Opnd(0)), parent);
+    case INTRN_C_clz32:
+    case INTRN_C_clz64:
+      return cgFunc.SelectCclz(intrinsicopNode);
+    case INTRN_C_ctz32:
+    case INTRN_C_ctz64:
+      return cgFunc.SelectCctz(intrinsicopNode);
+    case INTRN_C_popcount32:
+    case INTRN_C_popcount64:
+      return cgFunc.SelectCpopcount(intrinsicopNode);
+    case INTRN_C_parity32:
+    case INTRN_C_parity64:
+      return cgFunc.SelectCparity(intrinsicopNode);
+    case INTRN_C_clrsb32:
+    case INTRN_C_clrsb64:
+      return cgFunc.SelectCclrsb(intrinsicopNode);
+    case INTRN_C_isaligned:
+      return cgFunc.SelectCisaligned(intrinsicopNode);
+    case INTRN_C_alignup:
+      return cgFunc.SelectCalignup(intrinsicopNode);
+    case INTRN_C_aligndown:
+      return cgFunc.SelectCaligndown(intrinsicopNode);
+    case INTRN_C___sync_add_and_fetch_1:
+    case INTRN_C___sync_add_and_fetch_2:
+    case INTRN_C___sync_add_and_fetch_4:
+    case INTRN_C___sync_add_and_fetch_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_add, false);
+    case INTRN_C___sync_sub_and_fetch_1:
+    case INTRN_C___sync_sub_and_fetch_2:
+    case INTRN_C___sync_sub_and_fetch_4:
+    case INTRN_C___sync_sub_and_fetch_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_sub, false);
+    case INTRN_C___sync_fetch_and_add_1:
+    case INTRN_C___sync_fetch_and_add_2:
+    case INTRN_C___sync_fetch_and_add_4:
+    case INTRN_C___sync_fetch_and_add_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_add, true);
+    case INTRN_C___sync_fetch_and_sub_1:
+    case INTRN_C___sync_fetch_and_sub_2:
+    case INTRN_C___sync_fetch_and_sub_4:
+    case INTRN_C___sync_fetch_and_sub_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_sub, true);
+    case INTRN_C___sync_bool_compare_and_swap_1:
+    case INTRN_C___sync_bool_compare_and_swap_2:
+    case INTRN_C___sync_bool_compare_and_swap_4:
+    case INTRN_C___sync_bool_compare_and_swap_8:
+      return cgFunc.SelectCSyncBoolCmpSwap(intrinsicopNode);
+    case INTRN_C___sync_val_compare_and_swap_1:
+    case INTRN_C___sync_val_compare_and_swap_2:
+    case INTRN_C___sync_val_compare_and_swap_4:
+    case INTRN_C___sync_val_compare_and_swap_8:
+      return cgFunc.SelectCSyncValCmpSwap(intrinsicopNode);
+    case INTRN_C___sync_lock_test_and_set_1:
+      return cgFunc.SelectCSyncLockTestSet(intrinsicopNode, PTY_i8);
+    case INTRN_C___sync_lock_test_and_set_2:
+      return cgFunc.SelectCSyncLockTestSet(intrinsicopNode, PTY_i16);
+    case INTRN_C___sync_lock_test_and_set_4:
+      return cgFunc.SelectCSyncLockTestSet(intrinsicopNode, PTY_i32);
+    case INTRN_C___sync_lock_test_and_set_8:
+      return cgFunc.SelectCSyncLockTestSet(intrinsicopNode, PTY_i64);
+    case INTRN_C___sync_fetch_and_and_1:
+    case INTRN_C___sync_fetch_and_and_2:
+    case INTRN_C___sync_fetch_and_and_4:
+    case INTRN_C___sync_fetch_and_and_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_band, true);
+    case INTRN_C___sync_and_and_fetch_1:
+    case INTRN_C___sync_and_and_fetch_2:
+    case INTRN_C___sync_and_and_fetch_4:
+    case INTRN_C___sync_and_and_fetch_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_band, false);
+    case INTRN_C___sync_fetch_and_or_1:
+    case INTRN_C___sync_fetch_and_or_2:
+    case INTRN_C___sync_fetch_and_or_4:
+    case INTRN_C___sync_fetch_and_or_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_bior, true);
+    case INTRN_C___sync_or_and_fetch_1:
+    case INTRN_C___sync_or_and_fetch_2:
+    case INTRN_C___sync_or_and_fetch_4:
+    case INTRN_C___sync_or_and_fetch_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_bior, false);
+    case INTRN_C___sync_fetch_and_xor_1:
+    case INTRN_C___sync_fetch_and_xor_2:
+    case INTRN_C___sync_fetch_and_xor_4:
+    case INTRN_C___sync_fetch_and_xor_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_bxor, true);
+    case INTRN_C___sync_xor_and_fetch_1:
+    case INTRN_C___sync_xor_and_fetch_2:
+    case INTRN_C___sync_xor_and_fetch_4:
+    case INTRN_C___sync_xor_and_fetch_8:
+      return cgFunc.SelectCSyncFetch(intrinsicopNode, OP_bxor, false);
+    case INTRN_C___sync_synchronize:
+      return cgFunc.SelectCSyncSynchronize(intrinsicopNode);
+    case INTRN_C___atomic_load_n:
+      return cgFunc.SelectCAtomicLoadN(intrinsicopNode);
+    case INTRN_C___atomic_fetch_add:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_add, true);
+    case INTRN_C___atomic_fetch_sub:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_sub, true);
+    case INTRN_C___atomic_fetch_and:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_band, true);
+    case INTRN_C___atomic_fetch_or:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_bior, true);
+    case INTRN_C___atomic_fetch_xor:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_bxor, true);
+    case INTRN_C___atomic_add_fetch:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_add, false);
+    case INTRN_C___atomic_sub_fetch:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_sub, false);
+    case INTRN_C___atomic_and_fetch:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_band, false);
+    case INTRN_C___atomic_or_fetch:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_bior, false);
+    case INTRN_C___atomic_xor_fetch:
+      return cgFunc.SelectCAtomicFetch(intrinsicopNode, OP_bxor, false);
+
+    case INTRN_C__builtin_return_address:
+    case INTRN_C__builtin_extract_return_addr:
+      return cgFunc.SelectCReturnAddress(intrinsicopNode);
+
+    case INTRN_vector_abs_v8i8: case INTRN_vector_abs_v4i16:
+    case INTRN_vector_abs_v2i32: case INTRN_vector_abs_v1i64:
+    case INTRN_vector_abs_v16i8: case INTRN_vector_abs_v8i16:
+    case INTRN_vector_abs_v4i32: case INTRN_vector_abs_v2i64:
+      return HandleAbs(parent, intrinsicopNode, cgFunc);
+
+    case INTRN_vector_addl_low_v8i8: case INTRN_vector_addl_low_v8u8:
+    case INTRN_vector_addl_low_v4i16: case INTRN_vector_addl_low_v4u16:
+    case INTRN_vector_addl_low_v2i32: case INTRN_vector_addl_low_v2u32:
+      return HandleVectorAddLong(intrinsicopNode, cgFunc, true);
+
+    case INTRN_vector_addl_high_v8i8: case INTRN_vector_addl_high_v8u8:
+    case INTRN_vector_addl_high_v4i16: case INTRN_vector_addl_high_v4u16:
+    case INTRN_vector_addl_high_v2i32: case INTRN_vector_addl_high_v2u32:
+      return HandleVectorAddLong(intrinsicopNode, cgFunc, false);
+
+    case INTRN_vector_addw_low_v8i8: case INTRN_vector_addw_low_v8u8:
+    case INTRN_vector_addw_low_v4i16: case INTRN_vector_addw_low_v4u16:
+    case INTRN_vector_addw_low_v2i32: case INTRN_vector_addw_low_v2u32:
+      return HandleVectorAddWiden(intrinsicopNode, cgFunc, true);
+
+    case INTRN_vector_addw_high_v8i8: case INTRN_vector_addw_high_v8u8:
+    case INTRN_vector_addw_high_v4i16: case INTRN_vector_addw_high_v4u16:
+    case INTRN_vector_addw_high_v2i32: case INTRN_vector_addw_high_v2u32:
+      return HandleVectorAddWiden(intrinsicopNode, cgFunc, false);
+
+    case INTRN_vector_sum_v8u8: case INTRN_vector_sum_v8i8:
+    case INTRN_vector_sum_v4u16: case INTRN_vector_sum_v4i16:
+    case INTRN_vector_sum_v2u32: case INTRN_vector_sum_v2i32:
+    case INTRN_vector_sum_v16u8: case INTRN_vector_sum_v16i8:
+    case INTRN_vector_sum_v8u16: case INTRN_vector_sum_v8i16:
+    case INTRN_vector_sum_v4u32: case INTRN_vector_sum_v4i32:
+    case INTRN_vector_sum_v2u64: case INTRN_vector_sum_v2i64:
+      return HandleVectorSum(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_from_scalar_v8u8: case INTRN_vector_from_scalar_v8i8:
+    case INTRN_vector_from_scalar_v4u16: case INTRN_vector_from_scalar_v4i16:
+    case INTRN_vector_from_scalar_v2u32: case INTRN_vector_from_scalar_v2i32:
+    case INTRN_vector_from_scalar_v1u64: case INTRN_vector_from_scalar_v1i64:
+    case INTRN_vector_from_scalar_v16u8: case INTRN_vector_from_scalar_v16i8:
+    case INTRN_vector_from_scalar_v8u16: case INTRN_vector_from_scalar_v8i16:
+    case INTRN_vector_from_scalar_v4u32: case INTRN_vector_from_scalar_v4i32:
+    case INTRN_vector_from_scalar_v2u64: case INTRN_vector_from_scalar_v2i64:
+      return HandleVectorFromScalar(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_labssub_low_v8u8: case INTRN_vector_labssub_low_v8i8:
+    case INTRN_vector_labssub_low_v4u16: case INTRN_vector_labssub_low_v4i16:
+    case INTRN_vector_labssub_low_v2u32: case INTRN_vector_labssub_low_v2i32:
+      return HandleVectorAbsSubL(intrinsicopNode, cgFunc, true);
+
+    case INTRN_vector_labssub_high_v8u8: case INTRN_vector_labssub_high_v8i8:
+    case INTRN_vector_labssub_high_v4u16: case INTRN_vector_labssub_high_v4i16:
+    case INTRN_vector_labssub_high_v2u32: case INTRN_vector_labssub_high_v2i32:
+      return HandleVectorAbsSubL(intrinsicopNode, cgFunc, false);
+
+    case INTRN_vector_merge_v8u8: case INTRN_vector_merge_v8i8:
+    case INTRN_vector_merge_v4u16: case INTRN_vector_merge_v4i16:
+    case INTRN_vector_merge_v2u32: case INTRN_vector_merge_v2i32:
+    case INTRN_vector_merge_v1u64: case INTRN_vector_merge_v1i64:
+    case INTRN_vector_merge_v16u8: case INTRN_vector_merge_v16i8:
+    case INTRN_vector_merge_v8u16: case INTRN_vector_merge_v8i16:
+    case INTRN_vector_merge_v4u32: case INTRN_vector_merge_v4i32:
+    case INTRN_vector_merge_v2u64: case INTRN_vector_merge_v2i64:
+      return HandleVectorMerge(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_set_element_v8u8: case INTRN_vector_set_element_v8i8:
+    case INTRN_vector_set_element_v4u16: case INTRN_vector_set_element_v4i16:
+    case INTRN_vector_set_element_v2u32: case INTRN_vector_set_element_v2i32:
+    case INTRN_vector_set_element_v1u64: case INTRN_vector_set_element_v1i64:
+    case INTRN_vector_set_element_v16u8: case INTRN_vector_set_element_v16i8:
+    case INTRN_vector_set_element_v8u16: case INTRN_vector_set_element_v8i16:
+    case INTRN_vector_set_element_v4u32: case INTRN_vector_set_element_v4i32:
+    case INTRN_vector_set_element_v2u64: case INTRN_vector_set_element_v2i64:
+      return HandleVectorSetElement(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_get_high_v16u8: case INTRN_vector_get_high_v16i8:
+    case INTRN_vector_get_high_v8u16: case INTRN_vector_get_high_v8i16:
+    case INTRN_vector_get_high_v4u32: case INTRN_vector_get_high_v4i32:
+    case INTRN_vector_get_high_v2u64: case INTRN_vector_get_high_v2i64:
+      return HandleVectorGetHigh(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_get_low_v16u8: case INTRN_vector_get_low_v16i8:
+    case INTRN_vector_get_low_v8u16: case INTRN_vector_get_low_v8i16:
+    case INTRN_vector_get_low_v4u32: case INTRN_vector_get_low_v4i32:
+    case INTRN_vector_get_low_v2u64: case INTRN_vector_get_low_v2i64:
+      return HandleVectorGetLow(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_get_element_v8u8: case INTRN_vector_get_element_v8i8:
+    case INTRN_vector_get_element_v4u16: case INTRN_vector_get_element_v4i16:
+    case INTRN_vector_get_element_v2u32: case INTRN_vector_get_element_v2i32:
+    case INTRN_vector_get_element_v1u64: case INTRN_vector_get_element_v1i64:
+    case INTRN_vector_get_element_v16u8: case INTRN_vector_get_element_v16i8:
+    case INTRN_vector_get_element_v8u16: case INTRN_vector_get_element_v8i16:
+    case INTRN_vector_get_element_v4u32: case INTRN_vector_get_element_v4i32:
+    case INTRN_vector_get_element_v2u64: case INTRN_vector_get_element_v2i64:
+      return HandleVectorGetElement(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_pairwise_adalp_v8i8: case INTRN_vector_pairwise_adalp_v4i16:
+    case INTRN_vector_pairwise_adalp_v2i32: case INTRN_vector_pairwise_adalp_v8u8:
+    case INTRN_vector_pairwise_adalp_v4u16: case INTRN_vector_pairwise_adalp_v2u32:
+    case INTRN_vector_pairwise_adalp_v16i8: case INTRN_vector_pairwise_adalp_v8i16:
+    case INTRN_vector_pairwise_adalp_v4i32: case INTRN_vector_pairwise_adalp_v16u8:
+    case INTRN_vector_pairwise_adalp_v8u16: case INTRN_vector_pairwise_adalp_v4u32:
+      return HandleVectorPairwiseAdalp(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_pairwise_add_v8u8: case INTRN_vector_pairwise_add_v8i8:
+    case INTRN_vector_pairwise_add_v4u16: case INTRN_vector_pairwise_add_v4i16:
+    case INTRN_vector_pairwise_add_v2u32: case INTRN_vector_pairwise_add_v2i32:
+    case INTRN_vector_pairwise_add_v16u8: case INTRN_vector_pairwise_add_v16i8:
+    case INTRN_vector_pairwise_add_v8u16: case INTRN_vector_pairwise_add_v8i16:
+    case INTRN_vector_pairwise_add_v4u32: case INTRN_vector_pairwise_add_v4i32:
+      return HandleVectorPairwiseAdd(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_madd_v8u8: case INTRN_vector_madd_v8i8:
+    case INTRN_vector_madd_v4u16: case INTRN_vector_madd_v4i16:
+    case INTRN_vector_madd_v2u32: case INTRN_vector_madd_v2i32:
+      return HandleVectorMadd(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_mull_low_v8u8: case INTRN_vector_mull_low_v8i8:
+    case INTRN_vector_mull_low_v4u16: case INTRN_vector_mull_low_v4i16:
+    case INTRN_vector_mull_low_v2u32: case INTRN_vector_mull_low_v2i32:
+      return HandleVectorMull(intrinsicopNode, cgFunc, true);
+
+    case INTRN_vector_mull_high_v8u8: case INTRN_vector_mull_high_v8i8:
+    case INTRN_vector_mull_high_v4u16: case INTRN_vector_mull_high_v4i16:
+    case INTRN_vector_mull_high_v2u32: case INTRN_vector_mull_high_v2i32:
+      return HandleVectorMull(intrinsicopNode, cgFunc, false);
+
+    case INTRN_vector_narrow_low_v8u16: case INTRN_vector_narrow_low_v8i16:
+    case INTRN_vector_narrow_low_v4u32: case INTRN_vector_narrow_low_v4i32:
+    case INTRN_vector_narrow_low_v2u64: case INTRN_vector_narrow_low_v2i64:
+      return HandleVectorNarrow(intrinsicopNode, cgFunc, true);
+
+    case INTRN_vector_narrow_high_v8u16: case INTRN_vector_narrow_high_v8i16:
+    case INTRN_vector_narrow_high_v4u32: case INTRN_vector_narrow_high_v4i32:
+    case INTRN_vector_narrow_high_v2u64: case INTRN_vector_narrow_high_v2i64:
+      return HandleVectorNarrow(intrinsicopNode, cgFunc, false);
+
+    case INTRN_vector_reverse_v8u8: case INTRN_vector_reverse_v8i8:
+    case INTRN_vector_reverse_v4u16: case INTRN_vector_reverse_v4i16:
+    case INTRN_vector_reverse_v16u8: case INTRN_vector_reverse_v16i8:
+    case INTRN_vector_reverse_v8u16: case INTRN_vector_reverse_v8i16:
+      return HandleVectorReverse(intrinsicopNode, cgFunc, k32BitSize);
+
+    case INTRN_vector_reverse16_v16u8: case INTRN_vector_reverse16_v16i8:
+    case INTRN_vector_reverse16_v8u8: case INTRN_vector_reverse16_v8i8:
+      return HandleVectorReverse(intrinsicopNode, cgFunc, k16BitSize);
+
+    case INTRN_vector_reverse64_v16u8: case INTRN_vector_reverse64_v16i8:
+    case INTRN_vector_reverse64_v8u8: case INTRN_vector_reverse64_v8i8:
+    case INTRN_vector_reverse64_v8u16: case INTRN_vector_reverse64_v8i16:
+    case INTRN_vector_reverse64_v4u16: case INTRN_vector_reverse64_v4i16:
+    case INTRN_vector_reverse64_v4u32: case INTRN_vector_reverse64_v4i32:
+    case INTRN_vector_reverse64_v2u32: case INTRN_vector_reverse64_v2i32:
+      return HandleVectorReverse(intrinsicopNode, cgFunc, k64BitSize);
+
+    case INTRN_vector_shr_narrow_low_v8u16: case INTRN_vector_shr_narrow_low_v8i16:
+    case INTRN_vector_shr_narrow_low_v4u32: case INTRN_vector_shr_narrow_low_v4i32:
+    case INTRN_vector_shr_narrow_low_v2u64: case INTRN_vector_shr_narrow_low_v2i64:
+      return HandleVectorShiftNarrow(intrinsicopNode, cgFunc, true);
+
+    case INTRN_vector_subl_low_v8i8: case INTRN_vector_subl_low_v8u8:
+    case INTRN_vector_subl_low_v4i16: case INTRN_vector_subl_low_v4u16:
+    case INTRN_vector_subl_low_v2i32: case INTRN_vector_subl_low_v2u32:
+      return HandleVectorSubWiden(intrinsicopNode, cgFunc, true, false);
+
+    case INTRN_vector_subl_high_v8i8: case INTRN_vector_subl_high_v8u8:
+    case INTRN_vector_subl_high_v4i16: case INTRN_vector_subl_high_v4u16:
+    case INTRN_vector_subl_high_v2i32: case INTRN_vector_subl_high_v2u32:
+      return HandleVectorSubWiden(intrinsicopNode, cgFunc, false, false);
+
+    case INTRN_vector_subw_low_v8i8: case INTRN_vector_subw_low_v8u8:
+    case INTRN_vector_subw_low_v4i16: case INTRN_vector_subw_low_v4u16:
+    case INTRN_vector_subw_low_v2i32: case INTRN_vector_subw_low_v2u32:
+      return HandleVectorSubWiden(intrinsicopNode, cgFunc, true, true);
+
+    case INTRN_vector_subw_high_v8i8: case INTRN_vector_subw_high_v8u8:
+    case INTRN_vector_subw_high_v4i16: case INTRN_vector_subw_high_v4u16:
+    case INTRN_vector_subw_high_v2i32: case INTRN_vector_subw_high_v2u32:
+      return HandleVectorSubWiden(intrinsicopNode, cgFunc, false, true);
+
+    case INTRN_vector_table_lookup_v8u8: case INTRN_vector_table_lookup_v8i8:
+    case INTRN_vector_table_lookup_v16u8: case INTRN_vector_table_lookup_v16i8:
+      return HandleVectorTableLookup(intrinsicopNode, cgFunc);
+
+    case INTRN_vector_widen_low_v8u8: case INTRN_vector_widen_low_v8i8:
+    case INTRN_vector_widen_low_v4u16: case INTRN_vector_widen_low_v4i16:
+    case INTRN_vector_widen_low_v2u32: case INTRN_vector_widen_low_v2i32:
+      return HandleVectorWiden(intrinsicopNode, cgFunc, true);
+
+    case INTRN_vector_widen_high_v8u8: case INTRN_vector_widen_high_v8i8:
+    case INTRN_vector_widen_high_v4u16: case INTRN_vector_widen_high_v4i16:
+    case INTRN_vector_widen_high_v2u32: case INTRN_vector_widen_high_v2i32:
+      return HandleVectorWiden(intrinsicopNode, cgFunc, false);
+
+    case INTRN_vector_mov_narrow_v2i64: case INTRN_vector_mov_narrow_v2u64:
+    case INTRN_vector_mov_narrow_v4i32: case INTRN_vector_mov_narrow_v4u32:
+    case INTRN_vector_mov_narrow_v8i16: case INTRN_vector_mov_narrow_v8u16:
+      return HandleVectorMovNarrow(intrinsicopNode, cgFunc);
+    default:
+      ASSERT(false, "Should not reach here.");
+      return nullptr;
+  }
+}
+
+using HandleExprFactory = FunctionFactory<Opcode, maplebe::Operand*, const BaseNode&, BaseNode&, CGFunc&>;
+void InitHandleExprFactory() {
+  RegisterFactoryFunction<HandleExprFactory>(OP_dread, HandleDread);
+  RegisterFactoryFunction<HandleExprFactory>(OP_regread, HandleRegread);
+  RegisterFactoryFunction<HandleExprFactory>(OP_constval, HandleConstVal);
+  RegisterFactoryFunction<HandleExprFactory>(OP_conststr, HandleConstStr);
+  RegisterFactoryFunction<HandleExprFactory>(OP_conststr16, HandleConstStr16);
+  RegisterFactoryFunction<HandleExprFactory>(OP_add, HandleAdd);
+  RegisterFactoryFunction<HandleExprFactory>(OP_CG_array_elem_add, HandleCGArrayElemAdd);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ashr, HandleShift);
+  RegisterFactoryFunction<HandleExprFactory>(OP_lshr, HandleShift);
+  RegisterFactoryFunction<HandleExprFactory>(OP_shl, HandleShift);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ror, HandleRor);
+  RegisterFactoryFunction<HandleExprFactory>(OP_mul, HandleMpy);
+  RegisterFactoryFunction<HandleExprFactory>(OP_div, HandleDiv);
+  RegisterFactoryFunction<HandleExprFactory>(OP_rem, HandleRem);
+  RegisterFactoryFunction<HandleExprFactory>(OP_addrof, HandleAddrof);
+  RegisterFactoryFunction<HandleExprFactory>(OP_addrofoff, HandleAddrofoff);
+  RegisterFactoryFunction<HandleExprFactory>(OP_addroffunc, HandleAddroffunc);
+  RegisterFactoryFunction<HandleExprFactory>(OP_addroflabel, HandleAddrofLabel);
+  RegisterFactoryFunction<HandleExprFactory>(OP_iread, HandleIread);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ireadoff, HandleIreadoff);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ireadfpoff, HandleIreadfpoff);
+  RegisterFactoryFunction<HandleExprFactory>(OP_sub, HandleSub);
+  RegisterFactoryFunction<HandleExprFactory>(OP_band, HandleBand);
+  RegisterFactoryFunction<HandleExprFactory>(OP_bior, HandleBior);
+  RegisterFactoryFunction<HandleExprFactory>(OP_bxor, HandleBxor);
+  RegisterFactoryFunction<HandleExprFactory>(OP_abs, HandleAbs);
+  RegisterFactoryFunction<HandleExprFactory>(OP_bnot, HandleBnot);
+  RegisterFactoryFunction<HandleExprFactory>(OP_sext, HandleExtractBits);
+  RegisterFactoryFunction<HandleExprFactory>(OP_zext, HandleExtractBits);
+  RegisterFactoryFunction<HandleExprFactory>(OP_extractbits, HandleExtractBits);
+  RegisterFactoryFunction<HandleExprFactory>(OP_depositbits, HandleDepositBits);
+  RegisterFactoryFunction<HandleExprFactory>(OP_lnot, HandleLnot);
+  RegisterFactoryFunction<HandleExprFactory>(OP_land, HandleLand);
+  RegisterFactoryFunction<HandleExprFactory>(OP_lior, HandleLor);
+  RegisterFactoryFunction<HandleExprFactory>(OP_min, HandleMin);
+  RegisterFactoryFunction<HandleExprFactory>(OP_max, HandleMax);
+  RegisterFactoryFunction<HandleExprFactory>(OP_neg, HandleNeg);
+  RegisterFactoryFunction<HandleExprFactory>(OP_recip, HandleRecip);
+  RegisterFactoryFunction<HandleExprFactory>(OP_sqrt, HandleSqrt);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ceil, HandleCeil);
+  RegisterFactoryFunction<HandleExprFactory>(OP_floor, HandleFloor);
+  RegisterFactoryFunction<HandleExprFactory>(OP_retype, HandleRetype);
+  RegisterFactoryFunction<HandleExprFactory>(OP_cvt, HandleCvt);
+  RegisterFactoryFunction<HandleExprFactory>(OP_round, HandleRound);
+  RegisterFactoryFunction<HandleExprFactory>(OP_trunc, HandleTrunc);
+  RegisterFactoryFunction<HandleExprFactory>(OP_select, HandleSelect);
+  RegisterFactoryFunction<HandleExprFactory>(OP_le, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ge, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_gt, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_lt, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ne, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_eq, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_cmp, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_cmpl, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_cmpg, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_alloca, HandleAlloca);
+  RegisterFactoryFunction<HandleExprFactory>(OP_malloc, HandleMalloc);
+  RegisterFactoryFunction<HandleExprFactory>(OP_gcmalloc, HandleGCMalloc);
+  RegisterFactoryFunction<HandleExprFactory>(OP_gcpermalloc, HandleGCMalloc);
+  RegisterFactoryFunction<HandleExprFactory>(OP_gcmallocjarray, HandleJarrayMalloc);
+  RegisterFactoryFunction<HandleExprFactory>(OP_gcpermallocjarray, HandleJarrayMalloc);
+  RegisterFactoryFunction<HandleExprFactory>(OP_intrinsicop, HandleIntrinOp);
+}
+
+void HandleLabel(StmtNode &stmt, CGFunc &cgFunc) {
+  ASSERT(stmt.GetOpCode() == OP_label, "error");
+  auto &label = static_cast<LabelNode&>(stmt);
+  BB *newBB = cgFunc.StartNewBBImpl(false, label);
+  newBB->AddLabel(label.GetLabelIdx());
+  if (newBB->GetId() == 1) {
+    newBB->SetFrequency(kFreqBase);
+  }
+  cgFunc.SetLab2BBMap(newBB->GetLabIdx(), *newBB);
+  cgFunc.SetCurBB(*newBB);
+
+  if (cgFunc.GetCleanupLabel() == &label) {
+    cgFunc.SetCleanupBB(*newBB);
+  } else if (cgFunc.GetReturnLabel() == &label) {
+    cgFunc.SetReturnBB(*newBB);
+  }
+}
+
+void HandleGoto(StmtNode &stmt, CGFunc &cgFunc) {
+  cgFunc.UpdateFrequency(stmt);
+  auto &gotoNode = static_cast<GotoNode&>(stmt);
+  cgFunc.SetCurBBKind(BB::kBBGoto);
+  cgFunc.SelectGoto(gotoNode);
+  cgFunc.SetCurBB(*cgFunc.StartNewBB(gotoNode));
+  ASSERT(&stmt == &gotoNode, "stmt must be same as gotoNoe");
+
+  if ((gotoNode.GetNext() != nullptr) && (gotoNode.GetNext()->GetOpCode() != OP_label)) {
+    ASSERT(cgFunc.GetCurBB()->GetPrev()->GetLastStmt() == &stmt, "check the relation between BB and stmt");
+  }
+}
+
+void HandleIgoto(StmtNode &stmt, CGFunc &cgFunc) {
+  auto &igotoNode = static_cast<UnaryStmtNode&>(stmt);
+  Operand *targetOpnd = cgFunc.HandleExpr(stmt, *igotoNode.Opnd(0));
+  cgFunc.SelectIgoto(targetOpnd);
+  cgFunc.SetCurBB(*cgFunc.StartNewBB(igotoNode));
+}
+
+void HandleCondbr(StmtNode &stmt, CGFunc &cgFunc) {
+  cgFunc.UpdateFrequency(stmt);
+  auto &condGotoNode = static_cast<CondGotoNode&>(stmt);
+  BaseNode *condNode = condGotoNode.Opnd(0);
+  ASSERT(condNode != nullptr, "expect first operand of cond br");
+  Opcode condOp = condGotoNode.GetOpCode();
+  if (condNode->GetOpCode() == OP_constval) {
+    auto *constValNode = static_cast<ConstvalNode*>(condNode);
+    if ((constValNode->GetConstVal()->IsZero() && (OP_brfalse == condOp)) ||
+        (!constValNode->GetConstVal()->IsZero() && (OP_brtrue == condOp))) {
+      auto *gotoStmt = cgFunc.GetMemoryPool()->New<GotoNode>(OP_goto);
+      gotoStmt->SetOffset(condGotoNode.GetOffset());
+      HandleGoto(*gotoStmt, cgFunc);
+      auto *labelStmt = cgFunc.GetMemoryPool()->New<LabelNode>();
+      labelStmt->SetLabelIdx(cgFunc.CreateLabel());
+      HandleLabel(*labelStmt, cgFunc);
+    }
+    return;
+  }
+  cgFunc.SetCurBBKind(BB::kBBIf);
+  /* if condNode is not a cmp node, cmp it with zero. */
+  if (!kOpcodeInfo.IsCompare(condNode->GetOpCode())) {
+    Operand *opnd0 = cgFunc.HandleExpr(condGotoNode, *condNode);
+    PrimType primType = condNode->GetPrimType();
+    Operand *zeroOpnd = nullptr;
+    if (IsPrimitiveInteger(primType)) {
+      zeroOpnd = &cgFunc.CreateImmOperand(primType, 0);
+    } else {
+      ASSERT(((PTY_f32 == primType) || (PTY_f64 == primType)), "we don't support half-precision FP operands yet");
+      zeroOpnd = &cgFunc.CreateImmOperand(primType, 0);
+    }
+    cgFunc.SelectCondGoto(condGotoNode, *opnd0, *zeroOpnd);
+    cgFunc.SetCurBB(*cgFunc.StartNewBB(condGotoNode));
+    return;
+  }
+  /*
+   * Special case:
+   * bgt (cmp (op0, op1), 0) ==>
+   * bgt (op0, op1)
+   * but skip the case cmp(op0, 0)
+   */
+  BaseNode *op0 = condNode->Opnd(0);
+  ASSERT(op0 != nullptr, "get first opnd of a condNode failed");
+  BaseNode *op1 = condNode->Opnd(1);
+  ASSERT(op1 != nullptr, "get second opnd of a condNode failed");
+  if ((op0->GetOpCode() == OP_cmp) && (op1->GetOpCode() == OP_constval)) {
+    auto *constValNode = static_cast<ConstvalNode*>(op1);
+    MIRConst *mirConst = constValNode->GetConstVal();
+    auto *cmpNode = static_cast<CompareNode*>(op0);
+    bool skip = false;
+    if (cmpNode->Opnd(1)->GetOpCode() == OP_constval) {
+      auto *constVal = static_cast<ConstvalNode*>(cmpNode->Opnd(1))->GetConstVal();
+      if (constVal->IsZero()) {
+        skip = true;
+      }
+    }
+    if (!skip && mirConst->IsZero()) {
+      cgFunc.SelectCondSpecialCase1(condGotoNode, *op0);
+      cgFunc.SetCurBB(*cgFunc.StartNewBB(condGotoNode));
+      return;
+    }
+  }
+  /*
+   * Special case:
+   * brfalse(ge (cmpg (op0, op1), 0) ==>
+   * fcmp op1, op2
+   * blo
+   */
+  if ((condGotoNode.GetOpCode() == OP_brfalse) && (condNode->GetOpCode() == OP_ge) &&
+      (op0->GetOpCode() == OP_cmpg) && (op1->GetOpCode() == OP_constval)) {
+    auto *constValNode = static_cast<ConstvalNode*>(op1);
+    MIRConst *mirConst = constValNode->GetConstVal();
+    if (mirConst->IsZero()) {
+      cgFunc.SelectCondSpecialCase2(condGotoNode, *op0);
+      cgFunc.SetCurBB(*cgFunc.StartNewBB(condGotoNode));
+      return;
+    }
+  }
+  Operand *opnd0 = cgFunc.HandleExpr(*condNode, *condNode->Opnd(0));
+  Operand *opnd1 = cgFunc.HandleExpr(*condNode, *condNode->Opnd(1));
+  cgFunc.SelectCondGoto(condGotoNode, *opnd0, *opnd1);
+  cgFunc.SetCurBB(*cgFunc.StartNewBB(condGotoNode));
+}
+
+void HandleReturn(StmtNode &stmt, CGFunc &cgFunc) {
+  cgFunc.UpdateFrequency(stmt);
+  auto &retNode = static_cast<NaryStmtNode&>(stmt);
+  cgFunc.HandleRetCleanup(retNode);
+  ASSERT(retNode.NumOpnds() <= 1, "NYI return nodes number > 1");
+  Operand *opnd = nullptr;
+  if (retNode.NumOpnds() != 0) {
+    if (!cgFunc.GetFunction().StructReturnedInRegs()) {
+      opnd = cgFunc.HandleExpr(retNode, *retNode.Opnd(0));
+    } else {
+      cgFunc.SelectReturnSendOfStructInRegs(retNode.Opnd(0));
+    }
+  }
+  cgFunc.SelectReturn(opnd);
+  cgFunc.SetCurBBKind(BB::kBBGoto);
+  cgFunc.SetCurBB(*cgFunc.StartNewBB(retNode));
+}
+
+void HandleCall(StmtNode &stmt, CGFunc &cgFunc) {
+  cgFunc.UpdateFrequency(stmt);
+  auto &callNode = static_cast<CallNode&>(stmt);
+  cgFunc.SelectCall(callNode);
+  if (cgFunc.GetCurBB()->GetKind() != BB::kBBFallthru) {
+    cgFunc.SetCurBB(*cgFunc.StartNewBB(callNode));
+  }
+
+  StmtNode *prevStmt = stmt.GetPrev();
+  if (prevStmt == nullptr || prevStmt->GetOpCode() != OP_catch) {
+    return;
+  }
+  if ((stmt.GetNext() != nullptr) && (stmt.GetNext()->GetOpCode() == OP_label)) {
+    cgFunc.SetCurBB(*cgFunc.StartNewBBImpl(true, stmt));
+  }
+  cgFunc.HandleCatch();
+}
+
+void HandleICall(StmtNode &stmt, CGFunc &cgFunc) {
+  cgFunc.UpdateFrequency(stmt);
+  auto &icallNode = static_cast<IcallNode&>(stmt);
+  cgFunc.GetCurBB()->SetHasCall();
+  Operand *opnd0 = cgFunc.HandleExpr(stmt, *icallNode.GetNopndAt(0));
+  cgFunc.SelectIcall(icallNode, *opnd0);
+  if (cgFunc.GetCurBB()->GetKind() != BB::kBBFallthru) {
+    cgFunc.SetCurBB(*cgFunc.StartNewBB(icallNode));
+  }
+}
+
+void HandleIntrinCall(StmtNode &stmt, CGFunc &cgFunc) {
+  auto &call = static_cast<IntrinsiccallNode&>(stmt);
+  cgFunc.SelectIntrinCall(call);
+}
+
+void HandleDassign(StmtNode &stmt, CGFunc &cgFunc) {
+  auto &dassignNode = static_cast<DassignNode&>(stmt);
+  ASSERT(dassignNode.GetOpCode() == OP_dassign, "expect dassign");
+  BaseNode *rhs = dassignNode.GetRHS();
+  ASSERT(rhs != nullptr, "get rhs of dassignNode failed");
+  if (rhs->GetOpCode() == OP_malloc || rhs->GetOpCode() == OP_alloca) {
+    UnaryStmtNode &uNode = static_cast<UnaryStmtNode &>(stmt);
+    Operand *opnd0 = cgFunc.HandleExpr(dassignNode, *(uNode.Opnd()));
+    cgFunc.SelectDassign(dassignNode, *opnd0);
+    return;
+  } else if (rhs->GetPrimType() == PTY_agg) {
+    cgFunc.SelectAggDassign(dassignNode);
+    return;
+  }
+  bool isSaveRetvalToLocal = false;
+  if (rhs->GetOpCode() == OP_regread) {
+    isSaveRetvalToLocal = (static_cast<RegreadNode*>(rhs)->GetRegIdx() == -kSregRetval0);
+  }
+  Operand *opnd0 = cgFunc.HandleExpr(dassignNode, *rhs);
+  cgFunc.SelectDassign(dassignNode, *opnd0);
+  if (isSaveRetvalToLocal) {
+    cgFunc.GetCurBB()->GetLastInsn()->MarkAsSaveRetValToLocal();
+  }
+}
+
+void HandleDassignoff(StmtNode &stmt, CGFunc &cgFunc) {
+  auto &dassignoffNode = static_cast<DassignoffNode&>(stmt);
+  BaseNode *rhs = dassignoffNode.GetRHS();
+  CHECK_FATAL(rhs->GetOpCode() == OP_constval, "dassignoffNode without constval");
+  Operand *opnd0 = cgFunc.HandleExpr(dassignoffNode, *rhs);
+  cgFunc.SelectDassignoff(dassignoffNode, *opnd0);
+}
+
+void HandleRegassign(StmtNode &stmt, CGFunc &cgFunc) {
+  ASSERT(stmt.GetOpCode() == OP_regassign, "expect regAssign");
+  auto &regAssignNode = static_cast<RegassignNode&>(stmt);
+  bool isSaveRetvalToLocal = false;
+  BaseNode *operand = regAssignNode.Opnd(0);
+  ASSERT(operand != nullptr, "get operand of regassignNode failed");
+  if (operand->GetOpCode() == OP_regread) {
+    isSaveRetvalToLocal = (static_cast<RegreadNode*>(operand)->GetRegIdx() == -kSregRetval0);
+  }
+  Operand *opnd0 = cgFunc.HandleExpr(regAssignNode, *operand);
+  cgFunc.SelectRegassign(regAssignNode, *opnd0);
+  if (isSaveRetvalToLocal) {
+    cgFunc.GetCurBB()->GetLastInsn()->MarkAsSaveRetValToLocal();
+  }
+}
+
+void HandleIassign(StmtNode &stmt, CGFunc &cgFunc) {
+  ASSERT(stmt.GetOpCode() == OP_iassign, "expect stmt");
+  auto &iassignNode = static_cast<IassignNode&>(stmt);
+  if ((iassignNode.GetRHS() != nullptr) && iassignNode.GetRHS()->GetPrimType() != PTY_agg) {
+    cgFunc.SelectIassign(iassignNode);
+  } else {
+    BaseNode *addrNode = iassignNode.Opnd(0);
+    if (addrNode == nullptr) {
+      return;
+    }
+    cgFunc.SelectAggIassign(iassignNode, *cgFunc.HandleExpr(stmt, *addrNode));
+  }
+}
+
+void HandleIassignoff(StmtNode &stmt, CGFunc &cgFunc) {
+  ASSERT(stmt.GetOpCode() == OP_iassignoff, "expect iassignoff");
+  auto &iassignoffNode = static_cast<IassignoffNode&>(stmt);
+  cgFunc.SelectIassignoff(iassignoffNode);
+}
+
+void HandleIassignfpoff(StmtNode &stmt, CGFunc &cgFunc) {
+  ASSERT(stmt.GetOpCode() == OP_iassignfpoff, "expect iassignfpoff");
+  auto &iassignfpoffNode = static_cast<IassignFPoffNode&>(stmt);
+  cgFunc.SelectIassignfpoff(iassignfpoffNode, *cgFunc.HandleExpr(stmt, *stmt.Opnd(0)));
+}
+
+void HandleIassignspoff(StmtNode &stmt, CGFunc &cgFunc) {
+  ASSERT(stmt.GetOpCode() == OP_iassignspoff, "expect iassignspoff");
+  auto &baseNode = static_cast<IassignFPoffNode&>(stmt); /* same as FP */
+  BaseNode *rhs = baseNode.GetRHS();
+  ASSERT(rhs != nullptr, "get rhs of iassignspoffNode failed");
+  Operand *opnd0 = cgFunc.HandleExpr(baseNode, *rhs);
+  cgFunc.SelectIassignspoff(baseNode.GetPrimType(), baseNode.GetOffset(), *opnd0);
+}
+
+void HandleBlkassignoff(StmtNode &stmt, CGFunc &cgFunc) {
+  ASSERT(stmt.GetOpCode() == OP_blkassignoff, "expect blkassignoff");
+  auto &baseNode = static_cast<BlkassignoffNode&>(stmt);
+  Operand *src = cgFunc.HandleExpr(baseNode, *baseNode.Opnd(1));
+  cgFunc.SelectBlkassignoff(baseNode, src);
+}
+
+void HandleEval(const StmtNode &stmt, CGFunc &cgFunc) {
+  (void)cgFunc.HandleExpr(stmt, *static_cast<const UnaryStmtNode&>(stmt).Opnd(0));
+}
+
+void HandleRangeGoto(StmtNode &stmt, CGFunc &cgFunc) {
+  cgFunc.UpdateFrequency(stmt);
+  auto &rangeGotoNode = static_cast<RangeGotoNode&>(stmt);
+  cgFunc.SetCurBBKind(BB::kBBRangeGoto);
+  cgFunc.SelectRangeGoto(rangeGotoNode, *cgFunc.HandleExpr(rangeGotoNode, *rangeGotoNode.Opnd(0)));
+  cgFunc.SetCurBB(*cgFunc.StartNewBB(rangeGotoNode));
+}
+
+void HandleMembar(StmtNode &stmt, CGFunc &cgFunc) {
+  cgFunc.SelectMembar(stmt);
+  if (stmt.GetOpCode() != OP_membarrelease) {
+    return;
+  }
+#if TARGAARCH64 || TARGRISCV64
+  if (CGOptions::UseBarriersForVolatile()) {
+    return;
+  }
+#endif
+  StmtNode *secondStmt = stmt.GetRealNext();
+  if (secondStmt == nullptr ||
+      ((secondStmt->GetOpCode() != OP_iassign) && (secondStmt->GetOpCode() != OP_dassign))) {
+    return;
+  }
+  StmtNode *thirdStmt = secondStmt->GetRealNext();
+  if (thirdStmt == nullptr || thirdStmt->GetOpCode() != OP_membarstoreload) {
+    return;
+  }
+  cgFunc.SetVolStore(true);
+  cgFunc.SetVolReleaseInsn(cgFunc.GetCurBB()->GetLastInsn());
+}
+
+void HandleComment(StmtNode &stmt, CGFunc &cgFunc) {
+  if (cgFunc.GetCG()->GenerateVerboseAsm() || cgFunc.GetCG()->GenerateVerboseCG()) {
+    cgFunc.SelectComment(static_cast<CommentNode&>(stmt));
+  }
+}
+
+void HandleCatchOp(const StmtNode &stmt, const CGFunc &cgFunc) {
+  (void)stmt;
+  (void)cgFunc;
+  ASSERT(stmt.GetNext()->GetOpCode() == OP_call, "The next statement of OP_catch should be OP_call.");
+}
+
+void HandleAssertNull(StmtNode &stmt, CGFunc &cgFunc) {
+  auto &cgAssertNode = static_cast<UnaryStmtNode&>(stmt);
+  cgFunc.SelectAssertNull(cgAssertNode);
+}
+
+void HandleAbort(const StmtNode &stmt, CGFunc &cgFunc) {
+  (void)stmt;
+  cgFunc.SelectAbort();
+}
+
+void HandleAsm(StmtNode &stmt, CGFunc &cgFunc) {
+  cgFunc.SelectAsm(static_cast<AsmNode&>(stmt));
+}
+
+using HandleStmtFactory = FunctionFactory<Opcode, void, StmtNode&, CGFunc&>;
+void InitHandleStmtFactory() {
+  RegisterFactoryFunction<HandleStmtFactory>(OP_label, HandleLabel);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_goto, HandleGoto);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_igoto, HandleIgoto);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_brfalse, HandleCondbr);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_brtrue, HandleCondbr);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_return, HandleReturn);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_call, HandleCall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_icall, HandleICall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_icallproto, HandleICall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_intrinsiccall, HandleIntrinCall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_intrinsiccallassigned, HandleIntrinCall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_intrinsiccallwithtype, HandleIntrinCall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_intrinsiccallwithtypeassigned, HandleIntrinCall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_dassign, HandleDassign);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_dassignoff, HandleDassignoff);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_regassign, HandleRegassign);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_iassign, HandleIassign);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_iassignoff, HandleIassignoff);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_iassignfpoff, HandleIassignfpoff);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_iassignspoff, HandleIassignspoff);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_blkassignoff, HandleBlkassignoff);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_eval, HandleEval);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_rangegoto, HandleRangeGoto);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_membarrelease, HandleMembar);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_membaracquire, HandleMembar);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_membarstoreload, HandleMembar);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_membarstorestore, HandleMembar);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_comment, HandleComment);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_catch, HandleCatchOp);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_abort, HandleAbort);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_assertnonnull, HandleAssertNull);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_callassertnonnull, HandleAssertNull);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_assignassertnonnull, HandleAssertNull);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_returnassertnonnull, HandleAssertNull);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_asm, HandleAsm);
+}
+
+CGFunc::CGFunc(MIRModule &mod, CG &cg, MIRFunction &mirFunc, BECommon &beCommon, MemPool &memPool,
+               StackMemPool &stackMp, MapleAllocator &allocator, uint32 funcId)
+    : vRegTable(allocator.Adapter()),
+      bbVec(allocator.Adapter()),
+      vRegOperandTable(allocator.Adapter()),
+      pRegSpillMemOperands(allocator.Adapter()),
+      spillRegMemOperands(allocator.Adapter()),
+      reuseSpillLocMem(allocator.Adapter()),
+      labelMap(std::less<LabelIdx>(), allocator.Adapter()),
+      vregsToPregsMap(std::less<regno_t>(), allocator.Adapter()),
+      hasVLAOrAlloca(mirFunc.HasVlaOrAlloca()),
+      dbgParamCallFrameLocations(allocator.Adapter()),
+      dbgLocalCallFrameLocations(allocator.Adapter()),
+      cg(&cg),
+      mirModule(mod),
+      memPool(&memPool),
+      stackMp(stackMp),
+      func(mirFunc),
+      exitBBVec(allocator.Adapter()),
+      noReturnCallBBVec(allocator.Adapter()),
+      extendSet(allocator.Adapter()),
+      lab2BBMap(allocator.Adapter()),
+      beCommon(beCommon),
+      funcScopeAllocator(&allocator),
+      emitStVec(allocator.Adapter()),
+      switchLabelCnt(allocator.Adapter()),
+#if TARGARM32
+      sortedBBs(allocator.Adapter()),
+      lrVec(allocator.Adapter()),
+#endif  /* TARGARM32 */
+      loops(allocator.Adapter()),
+      lmbcParamVec(allocator.Adapter()),
+      scpIdSet(allocator.Adapter()),
+      shortFuncName(cg.ExtractFuncName(mirFunc.GetName()) + "." + std::to_string(funcId), &memPool) {
+  mirModule.SetCurFunction(&func);
+  SetMemlayout(*GetCG()->CreateMemLayout(memPool, beCommon, func, allocator));
+  GetMemlayout()->SetCurrFunction(*this);
+  SetTargetRegInfo(*GetCG()->CreateRegisterInfo(memPool, allocator));
+  GetTargetRegInfo()->SetCurrFunction(*this);
+  if (func.GetAttr(FUNCATTR_varargs) || func.HasVlaOrAlloca()) {
+    SetHasVLAOrAlloca(true);
+  }
+  SetHasAlloca(func.HasVlaOrAlloca());
+
+  dummyBB = CreateNewBB();
+  vRegCount = firstMapleIrVRegNO + func.GetPregTab()->Size();
+  firstNonPregVRegNO = vRegCount;
+  /* maximum register count initial be increased by 1024 */
+  maxRegCount = vRegCount + 1024;
+  if (func.GetMayWriteToAddrofStack()) {
+    SetStackProtectInfo(kAddrofStack);
+  }
+
+  insnBuilder = memPool.New<InsnBuilder>(memPool);
+  opndBuilder = memPool.New<OperandBuilder>(memPool, func.GetPregTab()->Size());
+
+  vRegTable.resize(maxRegCount);
+  /* func.GetPregTab()->_preg_table[0] is nullptr, so skip it */
+  ASSERT(func.GetPregTab()->PregFromPregIdx(0) == nullptr, "PregFromPregIdx(0) must be nullptr");
+  for (size_t i = 1; i < func.GetPregTab()->Size(); ++i) {
+    PrimType primType = func.GetPregTab()->PregFromPregIdx(i)->GetPrimType();
+    uint32 byteLen = GetPrimTypeSize(primType);
+    if (byteLen < k4ByteSize) {
+      byteLen = k4ByteSize;
+    }
+    if (primType == PTY_u128 || primType == PTY_i128) {
+      byteLen = k8ByteSize;
+    }
+    new (&GetVirtualRegNodeFromPseudoRegIdx(i)) VirtualRegNode(GetRegTyFromPrimTy(primType), byteLen);
+  }
+  firstCGGenLabelIdx = func.GetLabelTab()->GetLabelTableSize();
+  lSymSize = 0;
+  if (func.GetSymTab()) {
+    lSymSize = func.GetSymTab()->GetSymbolTableSize();
+  }
+}
+
+CGFunc::~CGFunc() {
+  mirModule.SetCurFunction(nullptr);
+}
+
+Operand *CGFunc::HandleExpr(const BaseNode &parent, BaseNode &expr) {
+  auto function = CreateProductFunction<HandleExprFactory>(expr.GetOpCode());
+  CHECK_FATAL(function != nullptr, "unsupported opCode in HandleExpr()");
+  return function(parent, expr, *this);
+}
+
+StmtNode *CGFunc::HandleFirstStmt() {
+  BlockNode *block = func.GetBody();
+
+  ASSERT(block != nullptr, "get func body block failed in CGFunc::GenerateInstruction");
+  StmtNode *stmt = block->GetFirst();
+  if (stmt == nullptr) {
+    return nullptr;
+  }
+  bool withFreqInfo = func.HasFreqMap() && !func.GetLastFreqMap().empty();
+  if (withFreqInfo) {
+    frequency = kFreqBase;
+  }
+  ASSERT(stmt->GetOpCode() == OP_label, "The first statement should be a label");
+  HandleLabel(*stmt, *this);
+  firstBB = curBB;
+  stmt = stmt->GetNext();
+  if (stmt == nullptr) {
+    return nullptr;
+  }
+  curBB = StartNewBBImpl(false, *stmt);
+  curBB->SetFrequency(frequency);
+  if (JAVALANG) {
+    HandleRCCall(true);
+  }
+  return stmt;
+}
+
+bool CGFunc::CheckSkipMembarOp(const StmtNode &stmt) {
+  StmtNode *nextStmt = stmt.GetRealNext();
+  if (nextStmt == nullptr) {
+    return false;
+  }
+
+  Opcode opCode = stmt.GetOpCode();
+  if (((opCode == OP_membaracquire) || (opCode == OP_membarrelease)) && (nextStmt->GetOpCode() == stmt.GetOpCode())) {
+    return true;
+  }
+  if ((opCode == OP_membarstorestore) && (nextStmt->GetOpCode() == OP_membarrelease)) {
+    return true;
+  }
+  if ((opCode == OP_membarstorestore) && func.IsConstructor() && MemBarOpt(stmt)) {
+    return true;
+  }
+#if TARGAARCH64 || TARGRISCV64
+  if ((!CGOptions::UseBarriersForVolatile()) && (nextStmt->GetOpCode() == OP_membaracquire)) {
+    isVolLoad = true;
+  }
+#endif /* TARGAARCH64 */
+  return false;
+}
+
+void CGFunc::RemoveUnreachableBB() {
+  OptimizationPattern *pattern = memPool->New<UnreachBBPattern>(*this);
+  for (BB *bb = firstBB; bb != nullptr; bb = bb->GetNext()) {
+    (void)pattern->Optimize(*bb);
+    if (bb->GetPreds().size() == 0 && bb->GetSuccs().size() == 0) {
+      auto it = find(noReturnCallBBVec.begin(), noReturnCallBBVec.end(), bb);
+      if (it != noReturnCallBBVec.end()) {
+        (void)noReturnCallBBVec.erase(it);
+      }
+    }
+  }
+}
+
+void CGFunc::GenerateLoc(StmtNode *stmt, SrcPosition &lastSrcPos, SrcPosition &lastMplPos) {
+  /* insert Insn for .loc before cg for the stmt */
+  if (cg->GetCGOptions().WithLoc() && stmt->op != OP_label && stmt->op != OP_comment) {
+    /* if original src file location info is availiable for this stmt,
+     * use it and skip mpl file location info for this stmt
+     */
+    bool hasLoc = false;
+    SrcPosition &newSrcPos = stmt->GetSrcPos();
+    if (!newSrcPos.IsValid()) {
+      return;
+    }
+
+    if (cg->GetCGOptions().WithSrc() && !lastSrcPos.IsEq(newSrcPos)) {
+      /* .loc for original src file */
+      Operand *o0 = CreateDbgImmOperand(newSrcPos.FileNum());
+      Operand *o1 = CreateDbgImmOperand(newSrcPos.LineNum());
+      Operand *o2 = CreateDbgImmOperand(newSrcPos.Column());
+      Insn &loc =
+          GetInsnBuilder()->BuildDbgInsn(mpldbg::OP_DBG_loc).AddOpndChain(*o0).AddOpndChain(*o1).AddOpndChain(*o2);
+      curBB->AppendInsn(loc);
+      lastSrcPos.UpdateWith(newSrcPos);
+      hasLoc = true;
+    }
+    /* .loc for mpl file, skip if already has .loc from src for this stmt */
+    if (cg->GetCGOptions().WithMpl() && !hasLoc && !lastMplPos.IsEqMpl(newSrcPos)) {
+      Operand *o0 = CreateDbgImmOperand(1);
+      Operand *o1 = CreateDbgImmOperand(newSrcPos.MplLineNum());
+      Operand *o2 = CreateDbgImmOperand(0);
+      Insn &loc =
+          GetInsnBuilder()->BuildDbgInsn(mpldbg::OP_DBG_loc).AddOpndChain(*o0).AddOpndChain(*o1).AddOpndChain(*o2);
+      curBB->AppendInsn(loc);
+      lastMplPos.UpdateWith(newSrcPos);
+    }
+  }
+}
+
+void CGFunc::GenerateScopeLabel(StmtNode *stmt, SrcPosition &lastSrcPos, bool &posDone) {
+  /* insert lable for scope begin and end .LScp.1B .LScp.1E */
+  MIRFunction &mirFunc = GetFunction();
+  DebugInfo *dbgInfo = GetMirModule().GetDbgInfo();
+  if (cg->GetCGOptions().WithDwarf() && stmt->op != OP_comment) {
+    SrcPosition newSrcPos = stmt->GetSrcPos();
+    if (!newSrcPos.IsValid()) {
+      return;
+    }
+    // check if newSrcPos is done
+    if (posDone && lastSrcPos.IsEq(newSrcPos)) {
+      return;
+    }
+    std::unordered_set<uint32> idSetB;
+    std::unordered_set<uint32> idSetE;
+    idSetB.clear();
+    idSetE.clear();
+    dbgInfo->GetCrossScopeId(&mirFunc, idSetB, true, lastSrcPos, newSrcPos);
+    dbgInfo->GetCrossScopeId(&mirFunc, idSetE, false, lastSrcPos, newSrcPos);
+    for (auto id : idSetE) {
+      // skip if begin label is not in yet
+      if (scpIdSet.find(id) == scpIdSet.end()) {
+        continue;
+      }
+      Operand *o0 = CreateDbgImmOperand(id);
+      Operand *o1 = CreateDbgImmOperand(1);
+      Insn &scope = GetInsnBuilder()->BuildDbgInsn(mpldbg::OP_DBG_scope).AddOpndChain(*o0).AddOpndChain(*o1);
+      curBB->AppendInsn(scope);
+      (void)scpIdSet.erase(id);
+    }
+    for (auto id : idSetB) {
+      // skip if begin label is already in
+      if (scpIdSet.find(id) != scpIdSet.end()) {
+        continue;
+      }
+      Operand *o0 = CreateDbgImmOperand(id);
+      Operand *o1 = CreateDbgImmOperand(0);
+      Insn &scope = GetInsnBuilder()->BuildDbgInsn(mpldbg::OP_DBG_scope).AddOpndChain(*o0).AddOpndChain(*o1);
+      curBB->AppendInsn(scope);
+      (void)scpIdSet.insert(id);
+    }
+    lastSrcPos.UpdateWith(newSrcPos);
+    posDone = false;
+  }
+}
+
+int32 CGFunc::GetFreqFromStmt(uint32 stmtId) {
+  int32 freq = GetFunction().GetFreqFromLastStmt(stmtId);
+  if (freq != -1) {
+    return freq;
+  }
+  return GetFunction().GetFreqFromFirstStmt(stmtId);
+}
+
+LmbcFormalParamInfo *CGFunc::GetLmbcFormalParamInfo(uint32 offset) {
+  MapleVector<LmbcFormalParamInfo*> &paramVec = GetLmbcParamVec();
+  for (auto *param : paramVec) {
+    uint32 paramOffset = param->GetOffset();
+    uint32 paramSize = param->GetSize();
+    if (paramOffset <= offset && offset < (paramOffset + paramSize)) {
+      return param;
+    }
+  }
+  return nullptr;
+}
+
+/*
+ * For formals of lmbc, the formal list is deleted if there is no
+ * passing of aggregate by value.
+ */
+void CGFunc::CreateLmbcFormalParamInfo() {
+  if (GetMirModule().GetFlavor() != MIRFlavor::kFlavorLmbc) {
+    return;
+  }
+  PrimType primType;
+  uint32 offset;
+  uint32 typeSize;
+  MIRFunction &lmbcFunc = GetFunction();
+  if (lmbcFunc.GetFormalCount() > 0) {
+    /* Whenever lmbc cannot delete call type info, the prototype is available */
+    uint32 stackOffset = 0;
+    for (size_t idx = 0; idx < lmbcFunc.GetFormalCount(); ++idx) {
+      MIRSymbol *sym = lmbcFunc.GetFormal(idx);
+      MIRType *type;
+      TyIdx tyIdx;
+      if (sym) {
+        tyIdx = lmbcFunc.GetFormalDefVec()[idx].formalTyIdx;
+        type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+      } else {
+        FormalDef vec = const_cast<MIRFunction *>(GetBecommon().GetMIRModule().CurFunction())->GetFormalDefAt(idx);
+        tyIdx = vec.formalTyIdx;
+        type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+      }
+      primType = type->GetPrimType();
+      offset = stackOffset;
+      typeSize = static_cast<uint32>(GetBecommon().GetTypeSize(tyIdx));
+      stackOffset += (typeSize + 7) & (-8);
+      LmbcFormalParamInfo *info = GetMemoryPool()->New<LmbcFormalParamInfo>(primType, offset, typeSize);
+      lmbcParamVec.push_back(info);
+      if (idx == 0 && lmbcFunc.IsFirstArgReturn()) {
+        info->SetIsReturn();
+      }
+      if (type->GetKind() == kTypeStruct) {
+        MIRStructType *structType = static_cast<MIRStructType *>(type);
+        info->SetType(structType);
+        uint32 fpSize;
+        uint32 numFpRegs = FloatParamRegRequired(structType, fpSize);
+        if (numFpRegs > 0) {
+          info->SetIsPureFloat();
+          info->SetNumRegs(numFpRegs);
+          info->SetFpSize(fpSize);
+        }
+      }
+    }
+  } else {
+    /* No aggregate pass by value here */
+    for (StmtNode *stmt = lmbcFunc.GetBody()->GetFirst(); stmt != nullptr; stmt = stmt->GetNext()) {
+      if (stmt == nullptr) {
+        break;
+      }
+      if (stmt->GetOpCode() == OP_label) {
+        continue;
+      }
+      if (stmt->GetOpCode() != OP_regassign) {
+        break;
+      }
+      RegassignNode *regAssignNode = static_cast<RegassignNode *>(stmt);
+      BaseNode *operand = regAssignNode->Opnd(0);
+      if (operand->GetOpCode() != OP_ireadfpoff) {
+        break;
+      }
+      IreadFPoffNode *ireadNode = static_cast<IreadFPoffNode *>(operand);
+      primType = ireadNode->GetPrimType();
+      if (ireadNode->GetOffset() < 0) {
+        continue;
+      }
+      offset = static_cast<uint32>(ireadNode->GetOffset());
+      typeSize = GetPrimTypeSize(primType);
+      CHECK_FATAL((offset % k8ByteSize) == 0, "");  /* scalar only, no struct for now */
+      LmbcFormalParamInfo *info = GetMemoryPool()->New<LmbcFormalParamInfo>(primType, offset, typeSize);
+      lmbcParamVec.push_back(info);
+    }
+  }
+  std::sort(lmbcParamVec.begin(), lmbcParamVec.end(),
+            [] (const LmbcFormalParamInfo *x, const LmbcFormalParamInfo *y)
+            { return x->GetOffset() < y->GetOffset(); }
+            );
+
+  /* When a scalar param address is taken, its regassign is not in the 1st block */
+  for (StmtNode *stmt = lmbcFunc.GetBody()->GetFirst(); stmt != nullptr; stmt = stmt->GetNext()) {
+    if (stmt == nullptr) {
+      break;
+    }
+    if (stmt->GetOpCode() == OP_label) {
+      continue;
+    }
+    if (stmt->GetOpCode() != OP_regassign) {
+      break;
+    }
+    RegassignNode *regAssignNode = static_cast<RegassignNode *>(stmt);
+    BaseNode *operand = regAssignNode->Opnd(0);
+    if (operand->GetOpCode() != OP_ireadfpoff) {
+      break;
+    }
+    IreadFPoffNode *ireadNode = static_cast<IreadFPoffNode *>(operand);
+    if (ireadNode->GetOffset() < 0) {
+      continue;
+    }
+    LmbcFormalParamInfo *info = GetLmbcFormalParamInfo(static_cast<uint32>(ireadNode->GetOffset()));
+    ASSERT_NOT_NULL(info);
+    info->SetHasRegassign();
+  }
+
+  AssignLmbcFormalParams();
+}
+
+void CGFunc::GenerateInstruction() {
+  InitHandleExprFactory();
+  InitHandleStmtFactory();
+  StmtNode *secondStmt = HandleFirstStmt();
+
+  /* First Pass: Creates the doubly-linked list of BBs (next,prev) */
+  volReleaseInsn = nullptr;
+
+  SrcPosition pos = GetFunction().GetScope()->GetRangeLow();
+  if (!pos.IsValid()) {
+    pos = GetFunction().GetSrcPosition();
+  }
+  SrcPosition lastScpPos = pos;
+  SrcPosition lastStmtPos = pos;
+  SrcPosition lastLocPos = SrcPosition();
+  SrcPosition lastMplPos = SrcPosition();
+  std::set<uint32> bbFreqSet;
+  bool posDone = false;
+  scpIdSet.clear();
+  for (StmtNode *stmt = secondStmt; stmt != nullptr; stmt = stmt->GetNext()) {
+    /* insert Insn for scope begin/end labels */
+    if (lastStmtPos.IsBfOrEq(stmt->GetSrcPos())) {
+      GenerateScopeLabel(stmt, lastScpPos, posDone);
+      lastStmtPos = stmt->GetSrcPos();
+    }
+    /* insert Insn for .loc before cg for the stmt */
+    GenerateLoc(stmt, lastLocPos, lastMplPos);
+    BB *tmpBB = curBB;
+    isVolLoad = false;
+    if (CheckSkipMembarOp(*stmt)) {
+      continue;
+    }
+    bool tempLoad = isVolLoad;
+    auto function = CreateProductFunction<HandleStmtFactory>(stmt->GetOpCode());
+    CHECK_FATAL(function != nullptr, "unsupported opCode or has been lowered before");
+    function(*stmt, *this);
+    /* skip the membar acquire if it is just after the iread. ldr + membaraquire->ldar */
+    if (tempLoad && !isVolLoad) {
+      stmt = stmt->GetNext();
+    }
+    int32 freq = GetFreqFromStmt(stmt->GetStmtID());
+    if (freq != -1) {
+      if (tmpBB != curBB) {
+        if (curBB->GetFirstInsn() == nullptr && curBB->GetLabIdx() == 0 && bbFreqSet.count(tmpBB->GetId()) == 0) {
+          tmpBB->SetFrequency(static_cast<uint32>(freq));
+          bbFreqSet.insert(tmpBB->GetId());
+        } else if ((curBB->GetFirstInsn() != nullptr  || curBB->GetLabIdx() != 0) &&
+                   bbFreqSet.count(curBB->GetId()) == 0) {
+          curBB->SetFrequency(static_cast<uint32>(freq));
+          bbFreqSet.insert(tmpBB->GetId());
+        }
+      } else if (bbFreqSet.count(curBB->GetId()) == 0) {
+        curBB->SetFrequency(static_cast<uint32>(freq));
+        bbFreqSet.insert(curBB->GetId());
+      }
+    }
+
+    /*
+     * skip the membarstoreload if there is the pattern for volatile write( membarrelease + store + membarstoreload )
+     * membarrelease + store + membarstoreload -> stlr
+     */
+    if (volReleaseInsn != nullptr) {
+      if ((stmt->GetOpCode() != OP_membarrelease) && (stmt->GetOpCode() != OP_comment)) {
+        if (!isVolStore) {
+          /* remove the generated membar release insn. */
+          curBB->RemoveInsn(*volReleaseInsn);
+          /* skip the membarstoreload. */
+          stmt = stmt->GetNext();
+        }
+        volReleaseInsn = nullptr;
+        isVolStore = false;
+      }
+    }
+  }
+
+  /* Set lastbb's frequency */
+  BlockNode *block = func.GetBody();
+  ASSERT(block != nullptr, "get func body block failed in CGFunc::GenerateInstruction");
+  curBB->SetLastStmt(*block->GetLast());
+  curBB->SetFrequency(frequency);
+  lastBB = curBB;
+  /* All stmts are handled */
+  frequency = 0;
+}
+
+LabelIdx CGFunc::CreateLabel() {
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(func.GetStIdx().Idx());
+  ASSERT(funcSt != nullptr, "Get func failed at CGFunc::CreateLabel");
+  std::string funcName = funcSt->GetName();
+  std::string labelStr = funcName.append(std::to_string(labelIdx++));
+  return func.GetOrCreateLableIdxFromName(labelStr);
+}
+
+MIRSymbol *CGFunc::GetRetRefSymbol(BaseNode &expr) {
+  Opcode opcode = expr.GetOpCode();
+  if (opcode != OP_dread) {
+    return nullptr;
+  }
+  auto &retExpr = static_cast<AddrofNode&>(expr);
+  MIRSymbol *symbol = mirModule.CurFunction()->GetLocalOrGlobalSymbol(retExpr.GetStIdx());
+  ASSERT(symbol != nullptr, "get symbol in mirmodule failed");
+  if (symbol->IsRefType()) {
+    MIRSymbol *sym = nullptr;
+    for (uint32 i = 0; i < func.GetFormalCount(); i++) {
+      sym = func.GetFormal(i);
+      if (sym == symbol) {
+        return nullptr;
+      }
+    }
+    return symbol;
+  }
+  return nullptr;
+}
+
+void CGFunc::TraverseAndClearCatchMark(BB &bb) {
+  /* has bb been visited */
+  if (bb.GetInternalFlag3() != 0) {
+    return;
+  }
+  bb.SetIsCatch(false);
+  bb.SetInternalFlag3(1);
+  for (auto succBB : bb.GetSuccs()) {
+    TraverseAndClearCatchMark(*succBB);
+  }
+}
+
+/*
+ * Two types of successor edges, normal and eh. Any bb which is not
+ * reachable by a normal successor edge is considered to be in a
+ * catch block.
+ * Marking it as a catch block does not automatically make it into
+ * a catch block. Unreachables can be marked as such too.
+ */
+void CGFunc::MarkCatchBBs() {
+  /* First, suspect all bb to be in catch */
+  FOR_ALL_BB(bb, this) {
+    bb->SetIsCatch(true);
+    bb->SetInternalFlag3(0);  /* mark as not visited */
+  }
+  /* Eliminate cleanup section from catch */
+  FOR_ALL_BB(bb, this) {
+    if (bb->IsCleanup()) {
+      bb->SetIsCatch(false);
+      ASSERT(bb->GetSuccs().size() <= 1, "MarkCatchBBs incorrect cleanup label");
+      BB *succ = nullptr;
+      if (!bb->GetSuccs().empty()) {
+        succ = bb->GetSuccs().front();
+      } else {
+        continue;
+      }
+      ASSERT(succ != nullptr, "Get front succsBB failed");
+      while (1) {
+        ASSERT(succ->GetSuccs().size() <= 1, "MarkCatchBBs incorrect cleanup label");
+        succ->SetIsCatch(false);
+        if (!succ->GetSuccs().empty()) {
+          succ = succ->GetSuccs().front();
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  /* Unmark all normally reachable bb as NOT catch. */
+  TraverseAndClearCatchMark(*firstBB);
+}
+
+/*
+ * Mark CleanupBB
+ * Note: Cleanup bb and func body bbs are seperated, no edges between them.
+ * No ehSuccs or eh_prevs between cleanup bbs.
+ */
+void CGFunc::MarkCleanupBB() const {
+  /* there is no cleanup BB in the function */
+  if (cleanupBB == nullptr) {
+    return;
+  }
+  ASSERT(ExitbbNotInCleanupArea(*cleanupBB), "exitBB created in cleanupArea.");
+  ASSERT(cleanupBB->GetEhSuccs().empty(), "CG internal error. Cleanup bb should not have ehSuccs.");
+
+#if DEBUG  /* Please don't remove me. */
+  /* Check if all of the cleanup bb is at bottom of the function. */
+  bool isCleanupArea = true;
+  if (!mirModule.IsCModule()) {
+    FOR_ALL_BB_REV_CONST(bb, this) {
+      if (bb == GetLastBB()) {
+        continue;
+      }
+      if (isCleanupArea) {
+        ASSERT(bb->IsCleanup(), "CG internal error, cleanup BBs should be at the bottom of the function.");
+      } else {
+        ASSERT(!bb->IsCleanup(), "CG internal error, cleanup BBs should be at the bottom of the function.");
+      }
+
+      if (bb == cleanupBB) {
+        isCleanupArea = false;
+      }
+    }
+  }
+#endif  /* DEBUG */
+}
+
+bool CGFunc::ExitbbNotInCleanupArea(const BB &bb) const {
+  for (const BB *nextBB = bb.GetNext(); nextBB != nullptr; nextBB = nextBB->GetNext()) {
+    if (nextBB->GetKind() == BB::kBBReturn) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/*
+ * Do mem barrier optimization for constructor funcs as follow:
+ * membarstorestore
+ * write field of this_  ==> write field of this_
+ * membarrelease             membarrelease.
+ */
+bool CGFunc::MemBarOpt(const StmtNode &membar) {
+  if (func.GetFormalCount() == 0) {
+    return false;
+  }
+  MIRSymbol *thisSym = func.GetFormal(0);
+  if (thisSym == nullptr) {
+    return false;
+  }
+  StmtNode *stmt = membar.GetNext();
+  for (; stmt != nullptr; stmt = stmt->GetNext()) {
+    BaseNode *base = nullptr;
+    if (stmt->GetOpCode() == OP_comment) {
+      continue;
+    } else if (stmt->GetOpCode() == OP_iassign) {
+      base = static_cast<IassignNode *>(stmt)->Opnd(0);
+    } else if (stmt->GetOpCode() == OP_call) {
+      auto *callNode = static_cast<CallNode*>(stmt);
+      MIRFunction *fn = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+      MIRSymbol *fsym = GetMirModule().CurFunction()->GetLocalOrGlobalSymbol(fn->GetStIdx(), false);
+      ASSERT(fsym != nullptr, "null ptr check");
+      if (fsym->GetName() == "MCC_WriteRefFieldNoDec") {
+        base = callNode->Opnd(0);
+      }
+    }
+    if (base != nullptr) {
+      Opcode op = base->GetOpCode();
+      if (op == OP_regread && thisSym->IsPreg() &&
+          thisSym->GetPreg()->GetPregNo() == static_cast<RegreadNode*>(base)->GetRegIdx()) {
+        continue;
+      }
+      if ((op == OP_dread || op == OP_addrof) && !thisSym->IsPreg() &&
+          static_cast<AddrofNode*>(base)->GetStIdx() == thisSym->GetStIdx()) {
+        continue;
+      }
+    }
+    break;
+  }
+
+  CHECK_NULL_FATAL(stmt);
+  return stmt->GetOpCode() == OP_membarrelease;
+}
+
+void CGFunc::MakeupScopeLabels(BB &bb) {
+  /* insert leftover scope-end labels */
+  if (!scpIdSet.empty()) {
+    std::set<uint32>::reverse_iterator rit;
+    for (rit=scpIdSet.rbegin(); rit != scpIdSet.rend(); ++rit) {
+      Operand *o0 = CreateDbgImmOperand(*rit);
+      Operand *o1 = CreateDbgImmOperand(1);
+      Insn &scope = GetInsnBuilder()->BuildDbgInsn(mpldbg::OP_DBG_scope).AddOpndChain(*o0).AddOpndChain(*o1);
+      bb.AppendInsn(scope);
+    }
+  }
+}
+
+void CGFunc::ProcessExitBBVec() {
+  ASSERT(exitBBVec.size() == 1, "there must be one BB_return in func");
+  MakeupScopeLabels(*exitBBVec[0]);
+}
+
+void CGFunc::AddCommonExitBB() {
+  // create fake commonExitBB
+  commonExitBB = CreateNewBB(true, BB::kBBFallthru, 0);
+  ASSERT(commonExitBB != nullptr, "cannot create fake commonExitBB");
+  for (BB *cgbb : exitBBVec) {
+    if (!cgbb->IsUnreachable()) {
+      commonExitBB->PushBackPreds(*cgbb);
+    }
+  }
+  for (BB *cgbb : noReturnCallBBVec) {
+    commonExitBB->PushBackPreds(*cgbb);
+  }
+}
+
+void CGFunc::UpdateCallBBFrequency() {
+  if (!func.HasFreqMap() || func.GetLastFreqMap().empty()) {
+    return;
+  }
+  FOR_ALL_BB(bb, this) {
+    if (bb->GetKind() != BB::kBBFallthru || !bb->HasCall()) {
+      continue;
+    }
+    ASSERT(bb->GetSuccs().size() <= 1, "fallthru BB has only one successor.");
+    if (!bb->GetSuccs().empty()) {
+      bb->SetFrequency((*(bb->GetSuccsBegin()))->GetFrequency());
+    }
+  }
+}
+
+void CGFunc::HandleFunction() {
+  /* select instruction */
+  GenerateInstruction();
+  ProcessExitBBVec();
+  LmbcGenSaveSpForAlloca();
+
+  if (func.IsJava()) {
+    GenerateCleanupCodeForExtEpilog(*cleanupBB);
+  } else if (!func.GetModule()->IsCModule()) {
+    GenerateCleanupCode(*cleanupBB);
+  }
+  GenSaveMethodInfoCode(*firstBB);
+  /* build control flow graph */
+  theCFG = memPool->New<CGCFG>(*this);
+  theCFG->BuildCFG();
+  RemoveUnreachableBB();
+  AddCommonExitBB();
+  if (mirModule.GetSrcLang() != kSrcLangC) {
+    MarkCatchBBs();
+  }
+  MarkCleanupBB();
+  DetermineReturnTypeofCall();
+  theCFG->MarkLabelTakenBB();
+  theCFG->UnreachCodeAnalysis();
+  if (mirModule.GetSrcLang() == kSrcLangC) {
+    theCFG->WontExitAnalysis();
+  }
+  if (CGOptions::IsLazyBinding() && !GetCG()->IsLibcore()) {
+    ProcessLazyBinding();
+  }
+  if (GetCG()->DoPatchLongBranch()) {
+    PatchLongBranch();
+  }
+  if (CGOptions::DoEnableHotColdSplit()) {
+    theCFG->CheckCFGFreq();
+  }
+  NeedStackProtect();
+}
+
+void CGFunc::AddDIESymbolLocation(const MIRSymbol *sym, SymbolAlloc *loc, bool isParam) {
+  ASSERT(debugInfo != nullptr, "debugInfo is null!");
+  ASSERT(loc->GetMemSegment() != nullptr, "only support those variable that locate at stack now");
+  DBGDie *sdie = debugInfo->GetLocalDie(&func, sym->GetNameStrIdx());
+  if (sdie == nullptr) {
+    return;
+  }
+
+  DBGExprLoc *exprloc = sdie->GetExprLoc();
+  CHECK_FATAL(exprloc != nullptr, "exprloc is null in CGFunc::AddDIESymbolLocation");
+  exprloc->SetSymLoc(loc);
+
+  GetDbgCallFrameLocations(isParam).push_back(exprloc);
+}
+
+void CGFunc::DumpCFG() const {
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(func.GetStIdx().Idx());
+  ASSERT(funcSt != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << "\n****** CFG built by CG for " << funcSt->GetName() << " *******\n";
+  FOR_ALL_BB_CONST(bb, this) {
+    LogInfo::MapleLogger() << "=== BB ( " << std::hex << bb << std::dec << " ) <" << bb->GetKindName() << "> ===\n";
+    LogInfo::MapleLogger() << "BB id:" << bb->GetId() << "\n";
+    if (!bb->GetPreds().empty()) {
+      LogInfo::MapleLogger() << " pred [ ";
+      for (auto *pred : bb->GetPreds()) {
+        LogInfo::MapleLogger() << pred->GetId() << " ";
+      }
+      LogInfo::MapleLogger() << "]\n";
+    }
+    if (!bb->GetSuccs().empty()) {
+      LogInfo::MapleLogger() << " succ [ ";
+      for (auto *succ : bb->GetSuccs()) {
+        LogInfo::MapleLogger() << succ->GetId() << " ";
+      }
+      LogInfo::MapleLogger() << "]\n";
+    }
+    const StmtNode *stmt = bb->GetFirstStmt();
+    if (stmt != nullptr) {
+      bool done = false;
+      do {
+        done = stmt == bb->GetLastStmt();
+        stmt->Dump(1);
+        LogInfo::MapleLogger() << "\n";
+        stmt = stmt->GetNext();
+      } while (!done);
+    } else {
+      LogInfo::MapleLogger() << "<empty BB>\n";
+    }
+  }
+}
+
+void CGFunc::DumpBBInfo(const BB *bb) const {
+  LogInfo::MapleLogger() << "=== BB " << " <" << bb->GetKindName();
+  if (bb->GetLabIdx() != MIRLabelTable::GetDummyLabel()) {
+    LogInfo::MapleLogger() << "[labeled with " << bb->GetLabIdx();
+    LogInfo::MapleLogger() << " ==> @" << func.GetLabelName(bb->GetLabIdx()) << "]";
+  }
+
+  LogInfo::MapleLogger() << "> <" << bb->GetId() << "> ";
+  if (bb->GetLoop()) {
+    LogInfo::MapleLogger() << "[Loop level " << bb->GetLoop()->GetLoopLevel();
+    LogInfo::MapleLogger() << ", head BB " <<  bb->GetLoop()->GetHeader()->GetId() << "]";
+  }
+  if (bb->IsCleanup()) {
+    LogInfo::MapleLogger() << "[is_cleanup] ";
+  }
+  if (bb->IsUnreachable()) {
+    LogInfo::MapleLogger() << "[unreachable] ";
+  }
+  if (!bb->GetSuccs().empty()) {
+    LogInfo::MapleLogger() << "succs: ";
+    for (auto *succBB : bb->GetSuccs()) {
+      LogInfo::MapleLogger() << succBB->GetId() << " ";
+    }
+  }
+  if (!bb->GetPreds().empty()) {
+    LogInfo::MapleLogger() << "preds: ";
+    for (auto *predBB : bb->GetPreds()) {
+      LogInfo::MapleLogger() << predBB->GetId() << " ";
+    }
+  }
+  if (!bb->GetEhSuccs().empty()) {
+    LogInfo::MapleLogger() << "eh_succs: ";
+    for (auto *ehSuccBB : bb->GetEhSuccs()) {
+      LogInfo::MapleLogger() << ehSuccBB->GetId() << " ";
+    }
+  }
+  if (!bb->GetEhPreds().empty()) {
+    LogInfo::MapleLogger() << "eh_preds: ";
+    for (auto *ehPredBB : bb->GetEhPreds()) {
+      LogInfo::MapleLogger() << ehPredBB->GetId() << " ";
+    }
+  }
+  LogInfo::MapleLogger() << "===\n";
+  LogInfo::MapleLogger() << "frequency:" << bb->GetFrequency() << "\n";
+}
+
+void CGFunc::DumpCGIR() const {
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(func.GetStIdx().Idx());
+  ASSERT(funcSt != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << "\n******  CGIR for " << funcSt->GetName() << " *******\n";
+  FOR_ALL_BB_CONST(bb, this) {
+    if (bb->IsUnreachable()) {
+      continue;
+    }
+    DumpBBInfo(bb);
+    FOR_BB_INSNS_CONST(insn, bb) {
+      insn->Dump();
+    }
+  }
+}
+
+void CGFunc::DumpLoop() const {
+  for (const auto *lp : loops) {
+    lp->PrintLoops(*lp);
+  }
+}
+
+void CGFunc::ClearLoopInfo() {
+  loops.clear();
+  loops.shrink_to_fit();
+  FOR_ALL_BB(bb, this) {
+    bb->ClearLoopPreds();
+    bb->ClearLoopSuccs();
+  }
+}
+
+void CGFunc::DumpCFGToDot(const std::string &fileNamePrefix) {
+  std::ofstream file(fileNamePrefix + GetName());
+  file << "digraph {" << std::endl;
+  for (auto *bb : GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    auto &succs = bb->GetSuccs();
+    if (succs.empty()) {
+      continue;
+    }
+    file << "  " << bb->GetId() << "->{";
+    for (auto *succ : succs) {
+      file << succ->GetId() << " ";
+    }
+    file << "};";
+  }
+  file << "}" << std::endl;
+}
+
+void CGFunc::PatchLongBranch() {
+  for (BB *bb = firstBB->GetNext(); bb != nullptr; bb = bb->GetNext()) {
+    bb->SetInternalFlag1(bb->GetInternalFlag1() + bb->GetPrev()->GetInternalFlag1());
+  }
+  BB *next = nullptr;
+  for (BB *bb = firstBB; bb != nullptr; bb = next) {
+    next = bb->GetNext();
+    if (bb->GetKind() != BB::kBBIf && bb->GetKind() != BB::kBBGoto) {
+      continue;
+    }
+    Insn *insn = bb->GetLastMachineInsn();
+    while (insn->IsImmaterialInsn()) {
+      insn = insn->GetPrev();
+    }
+    BB *tbb = GetBBFromLab2BBMap(GetLabelInInsn(*insn));
+    if ((tbb->GetInternalFlag1() - bb->GetInternalFlag1()) < MaxCondBranchDistance()) {
+      continue;
+    }
+    InsertJumpPad(insn);
+  }
+}
+
+void CGFunc::UpdateAllRegisterVregMapping(MapleMap<regno_t, PregIdx> &newMap) {
+  vregsToPregsMap.clear();
+  for (auto it : newMap) {
+    vregsToPregsMap[it.first] = it.second;
+  }
+}
+
+/* there are two stack protector:
+ * 1. stack protector all: for all function
+ * 2. stack protector strong: for some functon that
+ *   <1> invoke alloca functon;
+ *   <2> use stack address (address of or array symbol);
+ *   <3> callee use return stack slot;
+ * */
+void CGFunc::NeedStackProtect() {
+  ASSERT(GetNeedStackProtect() == false, "no stack protect default");
+  CG *currCG = GetCG();
+  if (currCG->IsStackProtectorAll()) {
+    SetNeedStackProtect(true);
+    return;
+  }
+
+  if (!currCG->IsStackProtectorStrong()) {
+    return;
+  }
+
+  if (HasAlloca()) {
+    SetNeedStackProtect(true);
+    return;
+  }
+
+  /* check if function use stack address or callee function return stack slot */
+  auto stackProInfo = GetStackProtectInfo();
+  if ((stackProInfo & kAddrofStack) != 0 || (stackProInfo & kRetureStackSlot) != 0) {
+    SetNeedStackProtect(true);
+    return;
+  }
+}
+
+bool CgHandleFunction::PhaseRun(maplebe::CGFunc &f) {
+  f.HandleFunction();
+  if (!f.GetCG()->GetCGOptions().DoEmitCode() || f.GetCG()->GetCGOptions().DoDumpCFG()) {
+    f.DumpCFG();
+  }
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgHandleFunction, handlefunction)
+
+bool CgFixCFLocOsft::PhaseRun(maplebe::CGFunc &f) {
+  if (f.GetCG()->GetCGOptions().WithDwarf()) {
+    f.DBGFixCallFrameLocationOffsets();
+  }
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgFixCFLocOsft, dbgfixcallframeoffsets)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/control_dep_analysis.cpp b/src/mapleall/maple_be/src/cg/control_dep_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4952edf920e6b812f72fe0e9ba79fe811e9939df
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/control_dep_analysis.cpp
@@ -0,0 +1,504 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "control_dep_analysis.h"
+#include "mpl_logging.h"
+
+namespace maplebe {
+void ControlDepAnalysis::Run() {
+  pdom->GeneratePdomTreeDot();
+  BuildCFGInfo();
+  ConstructFCDG();
+  ComputeRegions();
+}
+
+/* Augment CFG info */
+void ControlDepAnalysis::BuildCFGInfo() {
+  CHECK_FATAL(cgFunc.GetCommonExitBB() != nullptr, "there must be a virtual ExitBB in cfg");
+  cfgMST->BuildEdges(cgFunc.GetFirstBB(), cgFunc.GetCommonExitBB());
+  // denote back-edge on CFGEdge
+  for (auto cfgEdge : cfgMST->GetAllEdges()) {
+    BB *srcBB = cfgEdge->GetSrcBB();
+    BB *destBB = cfgEdge->GetDestBB();
+    for (auto loop : cgFunc.GetLoops()) {
+      if (loop->IsBackEdge(*srcBB, *destBB)) {
+        cfgEdge->SetIsBackEdge();
+      }
+    }
+  }
+  // denote the condition on CFGEdge except for back-edge
+  for (auto &cfgEdge : cfgMST->GetAllEdges()) {
+    if (cfgEdge->IsBackEdge()) {
+      continue;
+    }
+    BB *srcBB = cfgEdge->GetSrcBB();
+    BB *destBB = cfgEdge->GetDestBB();
+    CHECK_FATAL(srcBB != nullptr, "get srcBB of cfgEdge failed");
+    if (srcBB == cgFunc.GetFirstBB()) {
+      CHECK_FATAL(srcBB->GetSuccsSize() == 1, "EntryBB should have only one succ");
+      cfgEdge->SetCondition(0);
+      continue;
+    } else if (srcBB == cgFunc.GetCommonExitBB()) {
+      continue;
+    }
+    BB::BBKind srcKind = srcBB->GetKind();
+    switch (srcKind) {
+      case BB::kBBFallthru:
+      case BB::kBBGoto:
+      case BB::kBBIgoto:
+      case BB::kBBReturn:
+        cfgEdge->SetCondition(0);
+        break;
+      case BB::kBBIntrinsic:
+        if (!srcBB->GetLastMachineInsn()->IsBranch()) {
+          // set default cond number
+          cfgEdge->SetCondition(0);
+        }
+        /* else fall through */
+        [[clang::fallthrough]];
+      case BB::kBBIf: {
+        Insn *branchInsn = srcBB->GetLastMachineInsn();
+        CHECK_FATAL(branchInsn != nullptr, "ifBB must have a machine insn at the end");
+        ASSERT(branchInsn->IsCondBranch(), "ifBB must have a conditional branch insn at the end");
+        int lastOpndIdx = static_cast<int>(branchInsn->GetOperandSize()) - 1;
+        ASSERT(lastOpndIdx > -1, "lastOpndIdx must greater than -1");
+        Operand &lastOpnd = branchInsn->GetOperand(static_cast<uint32>(lastOpndIdx));
+        ASSERT(lastOpnd.IsLabelOpnd(), "lastOpnd must be labelOpnd in branchInsn");
+        BB *jumpBB = cgFunc.GetBBFromLab2BBMap(static_cast<LabelOperand&>(lastOpnd).GetLabelIndex());
+        if (jumpBB == destBB) {
+          cfgEdge->SetCondition(0);
+        } else {
+          cfgEdge->SetCondition(1);
+        }
+        break;
+      }
+      case BB::kBBRangeGoto: {
+        // Each successor cfgEdge is assigned a different cond number
+        cfgEdge->SetCondition(static_cast<int32>(GetAndAccSuccedCondNum(srcBB->GetId())));
+        break;
+      }
+      default:
+        // these kindBBs set default cond number [kBBNoReturn kBBThrow kBBLast]
+        cfgEdge->SetCondition(0);
+        break;
+    }
+  }
+}
+
+/* Construct forward control dependence graph */
+void ControlDepAnalysis::ConstructFCDG() {
+  CreateAllCDGNodes();
+  /* 1. Collect all edges(A, B) in CFG that B does not post-dom A */
+  for (auto cfgEdge : cfgMST->GetAllEdges()) {
+    if (cfgEdge->IsBackEdge()) {
+      continue;
+    }
+    BB *srcBB = cfgEdge->GetSrcBB();
+    BB *destBB = cfgEdge->GetDestBB();
+    CHECK_FATAL(srcBB != nullptr && destBB != nullptr, "get edge-connected nodes in cfg failed");
+    if (srcBB == cgFunc.GetCommonExitBB()) {
+      continue;
+    }
+    if (!pdom->PostDominate(*destBB, *srcBB)) {
+      AddNonPdomEdges(cfgEdge);
+    }
+  }
+
+  /* 2. Determine control dependence by traversal backward in the post-dom tree for every bbEdge in nonPdomEdges */
+  for (auto candiEdge : nonPdomEdges) {
+    BB *srcBB = candiEdge->GetSrcBB();
+    BB *destBB = candiEdge->GetDestBB();
+    CHECK_FATAL(srcBB != nullptr && destBB != nullptr, "get edge-connected nodes in nonPdomEdges failed");
+    /*
+     * Find the nearest common ancestor (L) of srcBB and destBB in the pdom-tree :
+     *   (1) L == parent of srcBB in the pdom-tree (immediate dominator of srcBB)
+     *   (2) L == srcBB
+     */
+    BB *ancestor = (pdom->GetPdom(destBB->GetId()) == srcBB) ? srcBB : pdom->GetPdom(srcBB->GetId());
+    BB *curBB = destBB;
+    while (curBB != ancestor && curBB != cgFunc.GetCommonExitBB()) {
+      (void)BuildControlDependence(*srcBB, *curBB, candiEdge->GetCondition());
+      curBB = pdom->GetPdom(curBB->GetId());
+    }
+  }
+}
+
+/*
+ * Divide regions for the CDGNodes :
+ *   Traverse the post-dominator tree by means of a post-order to
+ *   assure that all children in the post-dominator tree are visited before their parent.
+ */
+void ControlDepAnalysis::ComputeRegions() {
+  // The default bbId starts from 1
+  std::vector<bool> visited(fcdg->GetFCDGNodeSize(), false);
+  for (uint32 bbId = 1; bbId < fcdg->GetFCDGNodeSize(); ++bbId) {
+    if (!visited[bbId]) {
+      ComputeRegionForCurNode(bbId, visited);
+    }
+  }
+  ComputeRegionForNonDepNodes();
+}
+
+/* Nodes that don't have any control dependency are divided into a region */
+void ControlDepAnalysis::ComputeRegionForNonDepNodes() {
+  CDGRegion *curRegion = nullptr;
+  CDGNode *mergeNode = nullptr;
+  for (auto node : fcdg->GetAllFCDGNodes()) {
+    if (node == nullptr) {
+      continue;
+    }
+    if (node->GetInEdgesNum() != 0) {
+      continue;
+    }
+    if (curRegion == nullptr) {
+      curRegion = node->GetRegion();
+      CHECK_FATAL(curRegion != nullptr, "each CDGNode must be in a region");
+      mergeNode = node;
+    } else if (node->GetRegion() != curRegion) {
+      // Merge Region
+      CHECK_FATAL(mergeNode != nullptr, "invalid non-dep cdgNode");
+      MergeRegions(*mergeNode, *node);
+    }
+  }
+}
+
+/* Recursively computes the region of each node */
+void ControlDepAnalysis::ComputeRegionForCurNode(uint32 curBBId, std::vector<bool> &visited) {
+  if (visited[curBBId]) {
+    return;
+  }
+  visited[curBBId] = true;
+  MapleVector<uint32> children = pdom->GetPdomChildrenItem(curBBId);
+  if (!children.empty()) {
+    // Check that each child of the node has been computed
+    for (auto childId : children) {
+      if (!visited[childId]) {
+        ComputeRegionForCurNode(childId, visited);
+      }
+    }
+  }
+  /* Leaf nodes and the nodes whose children have been computed in the pdom-tree that can be merged region */
+  CreateAndDivideRegion(curBBId);
+}
+
+void ControlDepAnalysis::CreateAndDivideRegion(uint32 pBBId) {
+  /* 1. Visit every CDGNode:N, Get and Create the region of the control dependence set */
+  CDGNode *parentNode = fcdg->GetCDGNodeFromId(CDGNodeId(pBBId));
+  CHECK_FATAL(parentNode != nullptr, "get CDGNode failed");
+  CDGRegion *region = FindExistRegion(*parentNode);
+  if (region == nullptr) {
+    region = CreateFCDGRegion(*parentNode);
+  } else {
+    region->AddCDGNode(parentNode);
+    parentNode->SetRegion(*region);
+  }
+  MapleVector<CDGNode*> &regionNodes = region->GetRegionNodes();
+  /* 2. Visit each immediate child of N in the post-dom tree, compute the intersection of CDs */
+  BB *curBB = parentNode->GetBB();
+  CHECK_FATAL(curBB != nullptr, "get bb of CDGNode failed");
+  for (auto childBBId : pdom->GetPdomChildrenItem(curBB->GetId())) {
+    CDGNode *childNode = fcdg->GetCDGNodeFromId(CDGNodeId(childBBId));
+    if (std::find(regionNodes.begin(), regionNodes.end(), childNode) != regionNodes.end()) {
+      continue;
+    }
+    if (IsISEqualToCDs(*parentNode, *childNode)) {
+      MergeRegions(*parentNode, *childNode);
+    }
+  }
+}
+
+/* Check whether the region corresponding to the control dependence set exists */
+CDGRegion *ControlDepAnalysis::FindExistRegion(CDGNode &node) {
+  MapleVector<CDGRegion*> &allRegions = fcdg->GetAllRegions();
+  MapleVector<CDGEdge*> &curCDs = node.GetAllInEdges();
+  // Nodes that don't have control dependencies are processed in a unified method at last
+  if (curCDs.empty()) {
+    return nullptr;
+  }
+  for (auto region : allRegions) {
+    if (region == nullptr) {
+      continue;
+    }
+    MapleVector<CDGEdge*> &regionCDs = region->GetCDEdges();
+    if (regionCDs.size() != curCDs.size()) {
+      continue;
+    }
+    bool isAllCDExist = true;
+    for (auto curCD : curCDs) {
+      CHECK_FATAL(curCD != nullptr, "invalid control dependence edge");
+      bool isOneCDExist = false;
+      for (auto regionCD : regionCDs) {
+        CHECK_FATAL(regionCD != nullptr, "invalid control dependence edge");
+        if (IsSameControlDependence(*curCD, *regionCD)) {
+          isOneCDExist = true;
+          break;
+        }
+      }
+      if (!isOneCDExist) {
+        isAllCDExist = false;
+        break;
+      }
+    }
+    if (isAllCDExist) {
+      return region;
+    }
+  }
+  return nullptr;
+}
+
+/*
+ * Check whether the intersection(IS) of the control dependency set of the parent node (CDs)
+ * and the child node is equal to the control dependency set of the parent node
+ */
+bool ControlDepAnalysis::IsISEqualToCDs(CDGNode &parent, CDGNode &child) {
+  MapleVector<CDGEdge*> &parentCDs = parent.GetAllInEdges();
+  MapleVector<CDGEdge*> &childCDs = child.GetAllInEdges();
+  // Nodes that don't have control dependencies are processed in a unified method at last
+  if (parentCDs.empty() || childCDs.empty()) {
+    return false;
+  }
+  bool equal = true;
+  for (auto parentCD : parentCDs) {
+    CHECK_FATAL(parentCD != nullptr, "invalid CDGEdge in parentCDs");
+    for (auto childCD : childCDs) {
+      if (!IsSameControlDependence(*parentCD, *childCD)) {
+        equal = false;
+        continue;
+      }
+    }
+    if (!equal) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/* Merge regions of parentNode and childNode */
+void ControlDepAnalysis::MergeRegions(CDGNode &mergeNode, CDGNode &candiNode) {
+  CDGRegion *oldRegion = candiNode.GetRegion();
+  CHECK_FATAL(oldRegion != nullptr, "get child's CDGRegion failed");
+
+  // Set newRegion of all memberNodes in oldRegion of child
+  CDGRegion *mergeRegion = mergeNode.GetRegion();
+  CHECK_FATAL(mergeRegion != nullptr, "get parent's CDGRegion failed");
+  for (auto node : oldRegion->GetRegionNodes()) {
+    node->SetRegion(*mergeRegion);
+    mergeRegion->AddCDGNode(node);
+    oldRegion->RemoveCDGNode(node);
+  }
+
+  if (oldRegion->GetRegionNodeSize() == 0) {
+    fcdg->RemoveRegionById(oldRegion->GetRegionId());
+  }
+}
+
+CDGEdge *ControlDepAnalysis::BuildControlDependence(const BB &fromBB, const BB &toBB, int32 condition) {
+  auto *fromNode = fcdg->GetCDGNodeFromId(CDGNodeId(fromBB.GetId()));
+  auto *toNode = fcdg->GetCDGNodeFromId(CDGNodeId(toBB.GetId()));
+  CHECK_FATAL(fromNode != nullptr && toNode != nullptr, "get CDGNode failed");
+  auto *cdgEdge = cdgMemPool.New<CDGEdge>(*fromNode, *toNode, condition);
+
+  fromNode->AddOutEdges(cdgEdge);
+  toNode->AddInEdges(cdgEdge);
+  fcdg->AddFCDGEdge(cdgEdge);
+  return cdgEdge;
+}
+
+/* Create CDGNode for every BB */
+void ControlDepAnalysis::CreateAllCDGNodes() {
+  fcdg = cdgMemPool.New<FCDG>(cgFunc, cdgAlloc);
+  FOR_ALL_BB(bb, &cgFunc) {
+    if (bb->IsUnreachable()) {
+      continue;
+    }
+    auto *node = cdgMemPool.New<CDGNode>(CDGNodeId(bb->GetId()), *bb, cdgAlloc);
+    if (bb == cgFunc.GetFirstBB()) {
+      node->SetEntryNode();
+    }
+    bb->SetCDGNode(node);
+    fcdg->AddFCDGNode(*node);
+  }
+  // Create CDGNode for exitBB
+  BB *exitBB = cgFunc.GetCommonExitBB();
+  auto *exitNode = cdgMemPool.New<CDGNode>(CDGNodeId(exitBB->GetId()), *exitBB, cdgAlloc);
+  exitNode->SetExitNode();
+  exitBB->SetCDGNode(exitNode);
+  fcdg->AddFCDGNode(*exitNode);
+}
+
+CDGRegion *ControlDepAnalysis::CreateFCDGRegion(CDGNode &curNode) {
+  MapleVector<CDGEdge*> cdEdges = curNode.GetAllInEdges();
+  auto *region = cdgMemPool.New<CDGRegion>(CDGRegionId(lastRegionId++), cdgAlloc);
+  region->AddCDEdgeSet(cdEdges);
+  region->AddCDGNode(&curNode);
+  fcdg->AddRegion(*region);
+  curNode.SetRegion(*region);
+  return region;
+}
+
+void ControlDepAnalysis::GenerateFCDGDot() const {
+  CHECK_FATAL(fcdg != nullptr, "construct FCDG failed");
+  MapleVector<CDGNode*> &allNodes = fcdg->GetAllFCDGNodes();
+  MapleVector<CDGEdge*> &allEdges = fcdg->GetAllFCDGEdges();
+  MapleVector<CDGRegion*> &allRegions = fcdg->GetAllRegions();
+
+  std::streambuf *coutBuf = std::cout.rdbuf();
+  std::ofstream fcdgFile;
+  std::streambuf *fileBuf = fcdgFile.rdbuf();
+  (void)std::cout.rdbuf(fileBuf);
+
+  /* Define the output file name */
+  std::string fileName;
+  (void)fileName.append("fcdg_");
+  (void)fileName.append(cgFunc.GetName());
+  (void)fileName.append(".dot");
+
+  fcdgFile.open(fileName.c_str(), std::ios::trunc);
+  if (!fcdgFile.is_open()) {
+    LogInfo::MapleLogger(kLlWarn) << "fileName:" << fileName << " open failed.\n";
+    return;
+  }
+  fcdgFile << "digraph FCDG_" << cgFunc.GetName() << " {\n\n";
+  fcdgFile << "  node [shape=box,style=filled,color=lightgrey];\n\n";
+
+  /* Dump nodes style */
+  for (auto node : allNodes) {
+    if (node == nullptr) {
+      continue;
+    }
+    BB *bb = node->GetBB();
+    CHECK_FATAL(bb != nullptr, "get bb of CDGNode failed");
+    fcdgFile << "  BB_" << bb->GetId();
+    fcdgFile << "[label= \"";
+    if (node->IsEntryNode()) {
+      fcdgFile << "ENTRY\n";
+    } else if (node->IsExitNode()) {
+      fcdgFile << "EXIT\n";
+    }
+    fcdgFile << "BB_" << bb->GetId() << " Label_" << bb->GetLabIdx() << ":\n";
+    fcdgFile << "  { " << bb->GetKindName() <<  " }\"];\n";
+  }
+  fcdgFile << "\n";
+
+  /* Dump edges style */
+  for (auto edge : allEdges) {
+    CDGNode &fromNode = edge->GetFromNode();
+    CDGNode &toNode = edge->GetToNode();
+    fcdgFile << "  BB_" << fromNode.GetBB()->GetId() << " -> " << "BB_" << toNode.GetBB()->GetId();
+    fcdgFile << " [label = \"";
+    fcdgFile << edge->GetCondition() << "\"];\n";
+  }
+  fcdgFile << "\n";
+
+  /* Dump region style using cluster in dot language */
+  for (auto region : allRegions) {
+    if (region == nullptr) {
+      continue;
+    }
+    CHECK_FATAL(region->GetRegionNodeSize() != 0, "invalid region");
+    fcdgFile << "  subgraph cluster_" << region->GetRegionId() << " {\n";
+    fcdgFile << "    color=red;\n";
+    fcdgFile << "    label = \"region #" << region->GetRegionId() << "\";\n";
+    MapleVector<CDGNode*> &memberNodes = region->GetRegionNodes();
+    for (auto node : memberNodes) {
+      fcdgFile << "    BB_" << node->GetBB()->GetId() << ";\n";
+    }
+    fcdgFile << "}\n\n";
+  }
+
+  fcdgFile << "}\n";
+  (void)fcdgFile.flush();
+  fcdgFile.close();
+  (void)std::cout.rdbuf(coutBuf);
+}
+
+void ControlDepAnalysis::GenerateCFGDot() const {
+  std::streambuf *coutBuf = std::cout.rdbuf();
+  std::ofstream cfgFile;
+  std::streambuf *fileBuf = cfgFile.rdbuf();
+  (void)std::cout.rdbuf(fileBuf);
+
+  /* Define the output file name */
+  std::string fileName;
+  (void)fileName.append("cfg_before_cdg_");
+  (void)fileName.append(cgFunc.GetName());
+  (void)fileName.append(".dot");
+
+  cfgFile.open(fileName.c_str(), std::ios::trunc);
+  if (!cfgFile.is_open()) {
+    LogInfo::MapleLogger(kLlWarn) << "fileName:" << fileName << " open failed.\n";
+    return;
+  }
+
+  cfgFile << "digraph CFG_" << cgFunc.GetName() << " {\n\n";
+  cfgFile << "  node [shape=box];\n\n";
+
+  /* Dump nodes style */
+  FOR_ALL_BB_CONST(bb, &cgFunc) {
+    if (bb->IsUnreachable()) {
+      continue;
+    }
+    cfgFile << "  BB_" << bb->GetId();
+    cfgFile << "[label= \"";
+    if (bb == cgFunc.GetFirstBB()) {
+      cfgFile << "ENTRY\n";
+    }
+    cfgFile << "BB_" << bb->GetId() << " Label_" << bb->GetLabIdx() << ":\n";
+    cfgFile << "  { " << bb->GetKindName() <<  " }\"];\n";
+  }
+  BB *exitBB = cgFunc.GetCommonExitBB();
+  cfgFile << "  BB_" << exitBB->GetId();
+  cfgFile << "[label= \"EXIT\n";
+  cfgFile << "BB_" << exitBB->GetId() << "\"];\n";
+  cfgFile << "\n";
+
+  /* Dump edges style */
+  for (auto cfgEdge : cfgMST->GetAllEdges()) {
+    BB *srcBB = cfgEdge->GetSrcBB();
+    BB *destBB = cfgEdge->GetDestBB();
+    CHECK_FATAL(srcBB != nullptr && destBB != nullptr, "get wrong cfg-edge");
+    if (srcBB == cgFunc.GetCommonExitBB()) {
+      continue;
+    }
+    cfgFile << "  BB_" << srcBB->GetId() << " -> " << "BB_" << destBB->GetId();
+    cfgFile << " [label = \"";
+    cfgFile << cfgEdge->GetCondition() << "\"];\n";
+  }
+  cfgFile << "\n";
+
+  cfgFile << "}\n";
+  (void)cfgFile.flush();
+  cfgFile.close();
+  (void)std::cout.rdbuf(coutBuf);
+}
+
+void CgControlDepAnalysis::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgPostDomAnalysis>();
+}
+
+bool CgControlDepAnalysis::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *cdgMemPool = GetPhaseMemPool();
+  MemPool *tmpMemPool = ApplyTempMemPool();
+  CHECK_FATAL(cdgMemPool != nullptr && tmpMemPool != nullptr, "get memPool failed");
+  PostDomAnalysis *pdomInfo = GET_ANALYSIS(CgPostDomAnalysis, f);
+  CHECK_FATAL(pdomInfo != nullptr, "get result of PostDomAnalysis failed");
+  auto *cfgmst = cdgMemPool->New<CFGMST<BBEdge<maplebe::BB>, maplebe::BB>>(*cdgMemPool);
+  cda = cdgMemPool->New<ControlDepAnalysis>(f, *cdgMemPool, *tmpMemPool,
+                                                                           *pdomInfo, *cfgmst);
+  cda->Run();
+  return true;
+}
+MAPLE_ANALYSIS_PHASE_REGISTER(CgControlDepAnalysis, cgcontroldepanalysis)
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/data_dep_analysis.cpp b/src/mapleall/maple_be/src/cg/data_dep_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c055683ece14296f6fd4dca4734ca544bbe47ea7
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/data_dep_analysis.cpp
@@ -0,0 +1,271 @@
+/*
+* Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include "data_dep_analysis.h"
+#include "control_dep_analysis.h"
+#include "aarch64_cg.h"
+
+namespace maplebe {
+void IntraDataDepAnalysis::Run(BB &bb, MapleVector<DepNode*> &dataNodes) {
+  if (bb.IsUnreachable()) {
+    return;
+  }
+  MemPool *localMp = memPoolCtrler.NewMemPool("dda for bb mempool", true);
+  auto *localAlloc = new MapleAllocator(localMp);
+  InitCurNodeInfo(*localMp, *localAlloc, bb, dataNodes);
+  uint32 nodeSum = 1;
+  MapleVector<Insn*> comments(intraAlloc.Adapter());
+  const Insn *locInsn = bb.GetFirstLoc();
+  FOR_BB_INSNS(insn, &bb) {
+    if (!insn->IsMachineInstruction()) {
+      ddb.ProcessNonMachineInsn(*insn, comments, dataNodes, locInsn);
+      continue;
+    }
+    /* Add a pseudo node to separate dependence graph when appropriate */
+    ddb.SeparateDependenceGraph(dataNodes, nodeSum);
+    /* Generate a DepNode */
+    DepNode *ddgNode = ddb.GenerateDepNode(*insn, dataNodes, nodeSum, comments);
+    /* Build Dependency for may-throw insn */
+    ddb.BuildMayThrowInsnDependency(*insn);
+    /* Build Dependency for each operand of insn */
+    ddb.BuildOpndDependency(*insn);
+    /* Build Dependency for special insn */
+    ddb.BuildSpecialInsnDependency(*insn, dataNodes);
+    /* Build Dependency for ambi insn if needed */
+    ddb.BuildAmbiInsnDependency(*insn);
+    /* Update stack and heap dependency */
+    ddb.UpdateStackAndHeapDependency(*ddgNode, *insn, *locInsn);
+    if (insn->IsFrameDef()) {
+      ddb.SetLastFrameDefInsn(insn);
+    }
+    /* Separator exists */
+    uint32 separatorIndex = ddb.GetSeparatorIndex();
+    ddb.AddDependence(*dataNodes[separatorIndex], *insn->GetDepNode(), kDependenceTypeSeparator);
+    /* Update register use and register def */
+    ddb.UpdateRegUseAndDef(*insn, *ddgNode, dataNodes);
+  }
+  AddEndSeparatorNode(bb, dataNodes);
+  ddb.CopyAndClearComments(comments);
+  ClearCurNodeInfo(localMp, localAlloc);
+}
+
+/* Init dataDepBase data struct */
+void IntraDataDepAnalysis::InitCurNodeInfo(MemPool &tmpMp, MapleAllocator &tmpAlloc, BB &bb,
+                                           MapleVector<DepNode*> &dataNodes) {
+  CDGNode *curCDGNode = bb.GetCDGNode();
+  CHECK_FATAL(curCDGNode != nullptr, "invalid cdgNode from bb");
+  ddb.SetCDGNode(curCDGNode);
+  // Need to move to target subclass
+  uint32 maxRegNum = (cgFunc.IsAfterRegAlloc() ? AArch64reg::kAllRegNum : cgFunc.GetMaxVReg());
+  curCDGNode->InitDataDepInfo(tmpMp, tmpAlloc, maxRegNum);
+  /* Analysis live-in registers in catch BB */
+  ddb.AnalysisAmbiInsns(bb);
+  /* Clear all dependence nodes and push the first separator node */
+  dataNodes.clear();
+  DepNode *pseudoSepNode = ddb.BuildSeparatorNode();
+  (void)dataNodes.emplace_back(pseudoSepNode);
+  curCDGNode->AddPseudoSepNodes(pseudoSepNode);
+  ddb.SetSeparatorIndex(0);
+
+  if (!cgFunc.IsAfterRegAlloc()) {
+    /* assume first pseudo_dependence_separator insn of current bb define live-in's registers */
+    Insn *pseudoSepInsn = pseudoSepNode->GetInsn();
+    for (auto &regNO : bb.GetLiveInRegNO()) {
+      curCDGNode->SetLatestDefInsn(regNO, pseudoSepInsn);
+      pseudoSepNode->AddDefReg(regNO);
+      pseudoSepNode->SetRegDefs(pseudoSepNode->GetDefRegnos().size(), nullptr);
+    }
+  }
+}
+
+/* Clear local mempool and data-dep-info for cur cdgNode */
+void IntraDataDepAnalysis::ClearCurNodeInfo(MemPool *tmpMp, MapleAllocator *tmpAlloc) {
+  delete tmpAlloc;
+  memPoolCtrler.DeleteMemPool(tmpMp);
+  CDGNode *curCDGNode = ddb.GetCDGNode();
+  curCDGNode->ClearDataDepInfo();
+}
+
+/* Add a separatorNode to the end of a nodes
+ * before RA: add all live-out registers to Uses of this separatorNode
+ */
+void IntraDataDepAnalysis::AddEndSeparatorNode(BB &bb, MapleVector<DepNode*> &nodes) {
+  CDGNode *curCDGNode = bb.GetCDGNode();
+  CHECK_FATAL(curCDGNode != nullptr, "invalid cdgNode from bb");
+  DepNode *separatorNode = ddb.BuildSeparatorNode();
+  (void)nodes.emplace_back(separatorNode);
+  curCDGNode->AddPseudoSepNodes(separatorNode);
+  ddb.BuildDepsSeparator(*separatorNode, nodes);
+
+  bool beforeRA = !cgFunc.IsAfterRegAlloc();
+  if (beforeRA) {
+    /* for all live-out register of current bb */
+    for (auto &regNO : bb.GetLiveOutRegNO()) {
+      if (curCDGNode->GetLatestDefInsn(regNO) != nullptr) {
+        curCDGNode->AppendUseInsnChain(regNO, separatorNode->GetInsn(), intraMp, beforeRA);
+        separatorNode->AddUseReg(regNO);
+        CHECK_FATAL(curCDGNode->GetUseInsnChain(regNO) != nullptr, "get useInsnChain failed");
+        separatorNode->SetRegUses(*curCDGNode->GetUseInsnChain(regNO));
+      }
+    }
+  }
+}
+
+void InterDataDepAnalysis::Run(CDGRegion &region, MapleVector<DepNode*> &dataNodes) {
+  uint32 nodeSum = 1;
+  MapleVector<Insn*> comments(interAlloc.Adapter());
+  // Visit CDGNodes in the region follow the topological order of CFG
+  ComputeTopologicalOrderInRegion(region);
+  // Init data dependence info for the entire region
+  GlobalInit(dataNodes);
+  ddb.SeparateDependenceGraph(dataNodes, nodeSum);
+  for (std::size_t idx = 0; idx < readyNodes.size(); ++idx) {
+    CDGNode *cdgNode = readyNodes[idx];
+    BB *curBB = cdgNode->GetBB();
+    CHECK_FATAL(curBB != nullptr, "get bb from CDGNode failed");
+    // Init data dependence info for cur cdgNode
+    LocalInit(*curBB, *cdgNode, dataNodes, idx);
+    const Insn *locInsn = curBB->GetFirstLoc();
+    FOR_BB_INSNS(insn, curBB) {
+      if (!insn->IsMachineInstruction()) {
+        ddb.ProcessNonMachineInsn(*insn, comments, dataNodes, locInsn);
+        continue;
+      }
+      /* Add a pseudo node to separate dependence graph when appropriate */
+      ddb.SeparateDependenceGraph(dataNodes, nodeSum);
+      /* Generate a DepNode */
+      DepNode *ddgNode = ddb.GenerateDepNode(*insn, dataNodes, nodeSum, comments);
+      /* Build Dependency for may-throw insn */
+      ddb.BuildMayThrowInsnDependency(*insn);
+      /* Build Dependency for each operand of insn */
+      ddb.BuildOpndDependency(*insn);
+      /* Build Dependency for special insn */
+      ddb.BuildSpecialInsnDependency(*insn, dataNodes);
+      /* Build Dependency for ambi insn if needed */
+      ddb.BuildAmbiInsnDependency(*insn);
+      /* Update stack and heap dependency */
+      ddb.UpdateStackAndHeapDependency(*ddgNode, *insn, *locInsn);
+      if (insn->IsFrameDef()) {
+        ddb.SetLastFrameDefInsn(insn);
+      }
+      /* Separator exists */
+      uint32 separatorIndex = ddb.GetSeparatorIndex();
+      ddb.AddDependence(*dataNodes[separatorIndex], *insn->GetDepNode(), kDependenceTypeSeparator);
+      /* Update register use and register def */
+      ddb.UpdateRegUseAndDef(*insn, *ddgNode, dataNodes);
+    }
+    ddb.CopyAndClearComments(comments);
+  }
+}
+
+void InterDataDepAnalysis::GlobalInit(MapleVector<DepNode*> &dataNodes) {
+  dataNodes.clear();
+  // Need Check: where to record the pseudoSepNode? cdgNode? pseudoNode is of BB or of Region?
+  DepNode *pseudoSepNode = ddb.BuildSeparatorNode();
+  (void)dataNodes.emplace_back(pseudoSepNode);
+  ddb.SetSeparatorIndex(0);
+}
+
+void InterDataDepAnalysis::LocalInit(BB &bb, CDGNode &cdgNode, MapleVector<DepNode*> &dataNodes, std::size_t idx) {
+  ddb.SetCDGNode(&cdgNode);
+  cdgNode.ClearDataDepInfo();
+  /* Analysis live-in registers in catch BB */
+  ddb.AnalysisAmbiInsns(bb);
+
+  if (!cgFunc.IsAfterRegAlloc() && idx == 0) {
+    /* assume first pseudo_dependence_separator insn of current region define live-in's registers for first bb */
+    DepNode *pseudoSepNode = dataNodes[0];
+    Insn *pseudoSepInsn = pseudoSepNode->GetInsn();
+    for (auto &regNO : bb.GetLiveInRegNO()) {
+      cdgNode.SetLatestDefInsn(regNO, pseudoSepInsn);
+      pseudoSepNode->AddDefReg(regNO);
+      pseudoSepNode->SetRegDefs(pseudoSepNode->GetDefRegnos().size(), nullptr);
+    }
+  }
+}
+
+void InterDataDepAnalysis::ComputeTopologicalOrderInRegion(CDGRegion &region) {
+  MapleVector<CDGNode*> controlNodes = region.GetRegionNodes();
+  InitRestNodes(controlNodes);
+  for (auto cdgNode : restNodes) {
+    // Check whether CFG preds of the CDGNode are in the cur region
+    BB *bb = cdgNode->GetBB();
+    CHECK_FATAL(bb != nullptr, "get bb from CDGNode failed");
+    bool hasNonPredsInRegion = true;
+    for (auto predIt = bb->GetPredsBegin(); predIt != bb->GetPredsEnd(); ++predIt) {
+      CDGNode *predNode = (*predIt)->GetCDGNode();
+      CHECK_FATAL(predNode != nullptr, "get CDGNode from bb failed");
+      if (predNode->GetRegion() == &region) {
+        hasNonPredsInRegion = false;
+        break;
+      }
+    }
+    if (hasNonPredsInRegion) {
+      AddReadyNode(cdgNode);
+    }
+  }
+}
+
+void InterDataDepAnalysis::GenerateInterDDGDot(MapleVector<DepNode*> &dataNodes) {
+  std::streambuf *coutBuf = std::cout.rdbuf();
+  std::ofstream iddgFile;
+  std::streambuf *fileBuf = iddgFile.rdbuf();
+  (void)std::cout.rdbuf(fileBuf);
+
+  /* Define the output file name */
+  std::string fileName;
+  (void)fileName.append("interDDG_");
+  (void)fileName.append(cgFunc.GetName());
+  (void)fileName.append(".dot");
+
+  iddgFile.open(fileName.c_str(), std::ios::trunc);
+  if (!iddgFile.is_open()) {
+    LogInfo::MapleLogger(kLlWarn) << "fileName:" << fileName << " open failed.\n";
+    return;
+  }
+  iddgFile << "digraph InterDDG_" << cgFunc.GetName() << " {\n\n";
+  iddgFile << "  node [shape=box];\n\n";
+
+  /* Dump nodes style */
+  for (auto node : dataNodes) {
+    MOperator mOp = node->GetInsn()->GetMachineOpcode();
+    // Need move to target
+    const InsnDesc *md = &AArch64CG::kMd[mOp];
+    iddgFile << "  insn_" << node->GetInsn() << "[";
+    iddgFile << "label = \"" << node->GetInsn()->GetId() << ":\n";
+    iddgFile << "{ " << md->name << "}\"];\n";
+  }
+  iddgFile << "\n";
+
+  /* Dump edges style */
+  for (auto node : dataNodes) {
+    for (auto succ : node->GetSuccs()) {
+      iddgFile << "  insn" << node->GetInsn() << " -> " << "insn" << succ->GetTo().GetInsn();
+      iddgFile <<" [";
+      if (succ->GetDepType() == kDependenceTypeTrue) {
+        iddgFile << "color=red,";
+      }
+      iddgFile << "label= \"" << succ->GetLatency() << "\"";
+      iddgFile << "];\n";
+    }
+  }
+  iddgFile << "\n";
+
+  iddgFile << "}\n";
+  (void)iddgFile.flush();
+  iddgFile.close();
+  (void)std::cout.rdbuf(coutBuf);
+}
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/data_dep_base.cpp b/src/mapleall/maple_be/src/cg/data_dep_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8ed355d25d5f880e43cb35784ad6c149be3bda30
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/data_dep_base.cpp
@@ -0,0 +1,593 @@
+/*
+* Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include "data_dep_base.h"
+
+namespace maplebe {
+void DataDepBase::ProcessNonMachineInsn(Insn &insn, MapleVector<Insn*> &comments, MapleVector<DepNode*> &dataNodes,
+                                        const Insn *&locInsn) {
+  CHECK_FATAL(!insn.IsMachineInstruction(), "need non-machine-instruction");
+  if (insn.IsImmaterialInsn()) {
+    if (!insn.IsComment()) {
+      locInsn = &insn;
+    } else {
+      (void)comments.emplace_back(&insn);
+    }
+  } else if (insn.IsCfiInsn()) {
+    if (!dataNodes.empty()) {
+      dataNodes.back()->AddCfiInsn(insn);
+    }
+  }
+}
+
+/*
+ * If the instruction's number of current basic block more than kMaxDependenceNum,
+ * then insert some pseudo separator node to split basic block.
+ */
+void DataDepBase::SeparateDependenceGraph(MapleVector<DepNode*> &nodes, uint32 &nodeSum) {
+  if ((nodeSum > 0) && ((nodeSum % kMaxDependenceNum) == 0)) {
+    ASSERT(nodeSum == nodes.size(), "CG internal error, nodeSum should equal to nodes.size.");
+    /* Add a pseudo node to separate dependence graph */
+    DepNode *separatorNode = BuildSeparatorNode();
+    separatorNode->SetIndex(nodeSum);
+    (void)nodes.emplace_back(separatorNode);
+    curCDGNode->AddPseudoSepNodes(separatorNode);
+    BuildDepsSeparator(*separatorNode, nodes);
+
+    if (beforeRA) {
+      /* for all live-out register of current bb */
+      BB *curBB = curCDGNode->GetBB();
+      CHECK_FATAL(curBB != nullptr, "get bb from cdgNode failed");
+      for (auto &regNO : curBB->GetLiveOutRegNO()) {
+        if (curCDGNode->GetLatestDefInsn(regNO) != nullptr) {
+          curCDGNode->AppendUseInsnChain(regNO, separatorNode->GetInsn(), memPool, beforeRA);
+          separatorNode->AddUseReg(regNO);
+          CHECK_FATAL(curCDGNode->GetUseInsnChain(regNO)->insn != nullptr, "get useInsn failed");
+          separatorNode->SetRegUses(*curCDGNode->GetUseInsnChain(regNO));
+        }
+      }
+    }
+    curCDGNode->ClearDepDataVec();
+    separatorIndex = nodeSum++;
+  }
+}
+
+/*
+ * Generate a data depNode.
+ * insn  : create depNode for the instruction.
+ * nodes : a vector to store depNode.
+ * nodeSum  : the new depNode's index.
+ * comments : those comment insn between last no-comment's insn and insn.
+ */
+DepNode *DataDepBase::GenerateDepNode(Insn &insn, MapleVector<DepNode*> &nodes,
+                                      uint32 &nodeSum, MapleVector<Insn*> &comments) {
+  Reservation *rev = mad.FindReservation(insn);
+  ASSERT(rev != nullptr, "get reservation of insn failed");
+  auto *depNode = memPool.New<DepNode>(insn, alloc, rev->GetUnit(), rev->GetUnitNum(), *rev);
+  if (beforeRA) {
+    auto *regPressure = memPool.New<RegPressure>(alloc);
+    depNode->SetRegPressure(*regPressure);
+    depNode->InitPressure();
+  }
+  depNode->SetIndex(nodeSum++);
+  (void)nodes.emplace_back(depNode);
+  insn.SetDepNode(*depNode);
+
+  constexpr size_t vectorSize = 5;
+  depNode->ReservePreds(vectorSize);
+  depNode->ReserveSuccs(vectorSize);
+
+  if (!comments.empty()) {
+    depNode->SetComments(comments);
+    comments.clear();
+  }
+  return depNode;
+}
+
+void DataDepBase::BuildDepsLastCallInsn(Insn &insn) {
+  Insn *lastCallInsn = curCDGNode->GetLastCallInsn();
+  if (lastCallInsn != nullptr) {
+    AddDependence(*lastCallInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeControl);
+  }
+  curCDGNode->SetLastCallInsn(&insn);
+}
+
+void DataDepBase::BuildMayThrowInsnDependency(Insn &insn) {
+  /* Build dependency for may throw insn */
+  if (insn.MayThrow()) {
+    BuildDepsMayThrowInsn(insn);
+    Insn *lastFrameDef = curCDGNode->GetLastFrameDefInsn();
+    if (lastFrameDef != nullptr) {
+      AddDependence(*lastFrameDef->GetDepNode(), *insn.GetDepNode(), kDependenceTypeThrow);
+    } else if (!IsIntraBlockAnalysis()) {
+      BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), false, kDependenceTypeThrow, kLastFrameDef);
+    }
+  }
+}
+
+void DataDepBase::BuildAmbiInsnDependency(Insn &insn) {
+  const auto &defRegnos = insn.GetDepNode()->GetDefRegnos();
+  for (const auto &regNO : defRegnos) {
+    if (IfInAmbiRegs(regNO)) {
+      BuildDepsAmbiInsn(insn);
+      break;
+    }
+  }
+}
+
+/*
+ * Build data dependence between control register and last call instruction.
+ * insn : instruction that with control register operand.
+ * isDest : if the control register operand is a destination operand.
+ */
+void DataDepBase::BuildDepsBetweenControlRegAndCall(Insn &insn, bool isDest) {
+  Insn *lastCallInsn = curCDGNode->GetLastCallInsn();
+  if (lastCallInsn == nullptr) {
+    return;
+  }
+  if (isDest) {
+    AddDependence(*lastCallInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeOutput);
+    return;
+  }
+  AddDependence(*lastCallInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeAnti);
+}
+
+/* Build control data dependence for branch/ret instructions */
+void DataDepBase::BuildDepsControlAll(Insn &insn, const MapleVector<DepNode*> &nodes) {
+  DepNode *depNode = insn.GetDepNode();
+  for (uint32 i = separatorIndex; i < depNode->GetIndex(); ++i) {
+    AddDependence(*nodes[i], *depNode, kDependenceTypeControl);
+  }
+}
+
+/* A pseudo separator node depends all the other nodes */
+void DataDepBase::BuildDepsSeparator(DepNode &newSepNode, MapleVector<DepNode*> &nodes) {
+  uint32 nextSepIndex = (separatorIndex + kMaxDependenceNum) < nodes.size() ? (separatorIndex + kMaxDependenceNum)
+                                                                            : static_cast<uint32>(nodes.size() - 1);
+  newSepNode.ReservePreds(nextSepIndex - separatorIndex);
+  newSepNode.ReserveSuccs(nextSepIndex - separatorIndex);
+  for (uint32 i = separatorIndex; i < nextSepIndex; ++i) {
+    AddDependence(*nodes[i], newSepNode, kDependenceTypeSeparator);
+  }
+}
+
+/* Build data dependence of may throw instructions */
+void DataDepBase::BuildDepsMayThrowInsn(Insn &insn) {
+  if (IsIntraBlockAnalysis()) {
+    MapleVector<Insn*> ambiInsns = curCDGNode->GetAmbiguousInsns();
+    AddDependence4InsnInVectorByType(ambiInsns, insn, kDependenceTypeThrow);
+  } else {
+    BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), false, kDependenceTypeThrow, kAmbiguous);
+  }
+}
+
+/*
+ * Build data dependence of ambiguous instruction.
+ * ambiguous instruction: instructions that can not across may throw instructions
+ */
+void DataDepBase::BuildDepsAmbiInsn(Insn &insn) {
+  if (IsIntraBlockAnalysis()) {
+    MapleVector<Insn*> mayThrows = curCDGNode->GetMayThrowInsns();
+    AddDependence4InsnInVectorByType(mayThrows, insn, kDependenceTypeThrow);
+  } else {
+    BuildInterBlockSpecialDataInfoDependency(*insn.GetDepNode(), false, kDependenceTypeThrow, kMayThrows);
+  }
+  curCDGNode->AddAmbiguousInsn(&insn);
+}
+
+/* Build data dependence of destination register operand */
+void DataDepBase::BuildDepsDefReg(Insn &insn, regno_t regNO) {
+  DepNode *node = insn.GetDepNode();
+  node->AddDefReg(regNO);
+  /*
+   * 1. For building intra-block data dependence, only require the data flow info of the curBB(cur CDGNode)
+   * 2. For building inter-block data dependence, require the data flow info of all BBs on the pred path in CFG
+   */
+  /* Build anti dependence */
+  // Build intra block data dependence
+  RegList *regList = curCDGNode->GetUseInsnChain(regNO);
+  while (regList != nullptr) {
+    CHECK_NULL_FATAL(regList->insn);
+    AddDependence(*regList->insn->GetDepNode(), *node, kDependenceTypeAnti);
+    regList = regList->next;
+  }
+  // Build inter block data dependence
+  if (!IsIntraBlockAnalysis()) {
+    BuildInterBlockDefUseDependency(*node, regNO, kDependenceTypeAnti, false);
+  }
+
+  /* Build output dependence */
+  // Build intra block data dependence
+  Insn *defInsn = curCDGNode->GetLatestDefInsn(regNO);
+  if (defInsn != nullptr) {
+    AddDependence(*defInsn->GetDepNode(), *node, kDependenceTypeOutput);
+  } else if (!IsIntraBlockAnalysis()) {
+    // Build inter block data dependence
+    BuildInterBlockDefUseDependency(*node, regNO, kDependenceTypeOutput, true);
+  }
+}
+
+/* Build data dependence of source register operand */
+void DataDepBase::BuildDepsUseReg(Insn &insn, regno_t regNO) {
+  DepNode *node = insn.GetDepNode();
+  node->AddUseReg(regNO);
+
+  // Build intra block data dependence
+  Insn *defInsn = curCDGNode->GetLatestDefInsn(regNO);
+  if (defInsn != nullptr) {
+    AddDependence(*defInsn->GetDepNode(), *node, kDependenceTypeTrue);
+  } else if (!IsIntraBlockAnalysis()) {
+    // Build inter block data dependence
+    BuildInterBlockDefUseDependency(*node, regNO, kDependenceTypeTrue, true);
+  }
+}
+
+/* Update stack and heap dependency */
+void DataDepBase::UpdateStackAndHeapDependency(DepNode &depNode, Insn &insn, const Insn &locInsn) {
+  if (!insn.MayThrow()) {
+    return;
+  }
+  depNode.SetLocInsn(locInsn);
+  curCDGNode->AddMayThrowInsn(&insn);
+  if (IsIntraBlockAnalysis()) {
+    AddDependence4InsnInVectorByType(curCDGNode->GetStackDefInsns(), insn, kDependenceTypeThrow);
+    AddDependence4InsnInVectorByType(curCDGNode->GetHeapDefInsns(), insn, kDependenceTypeThrow);
+  } else {
+    BuildInterBlockSpecialDataInfoDependency(depNode, false, kDependenceTypeThrow, kStackDefs);
+    BuildInterBlockSpecialDataInfoDependency(depNode, false, kDependenceTypeThrow, kHeapDefs);
+  }
+}
+
+void DataDepBase::BuildSeparatorNodeDependency(MapleVector<DepNode*> &dataNodes, Insn &insn) {
+  AddDependence(*dataNodes[separatorIndex], *insn.GetDepNode(), kDependenceTypeSeparator);
+}
+
+/* For inter data dependence analysis */
+void DataDepBase::BuildInterBlockDefUseDependency(DepNode &curDepNode, regno_t regNO, DepType depType,
+                                                  bool isDef) {
+  CHECK_FATAL(!IsIntraBlockAnalysis(), "must be inter block data dependence analysis");
+  BB *curBB = curCDGNode->GetBB();
+  CHECK_FATAL(curBB != nullptr, "get bb from cdgNode failed");
+  CDGRegion *curRegion = curCDGNode->GetRegion();
+  CHECK_FATAL(curRegion != nullptr, "get region from cdgNode failed");
+  std::vector<bool> visited(curRegion->GetMaxBBIdInRegion(), false);
+  if (isDef) {
+    BuildPredPathDefDependencyDFS(*curBB, visited, curDepNode, regNO, depType);
+  } else {
+    BuildPredPathUseDependencyDFS(*curBB, visited, curDepNode, regNO, depType);
+  }
+}
+
+void DataDepBase::BuildPredPathDefDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                                regno_t regNO, DepType depType) {
+  if (visited[curBB.GetId()]) {
+    return;
+  }
+  CDGNode *cdgNode = curBB.GetCDGNode();
+  CHECK_FATAL(cdgNode != nullptr, "get cdgNode from bb failed");
+  CDGRegion *curRegion = cdgNode->GetRegion();
+  CHECK_FATAL(curRegion != nullptr, "get region from cdgNode failed");
+  if (curRegion->GetRegionId() != curCDGNode->GetRegion()->GetRegionId()) {
+    return;
+  }
+  Insn *curDefInsn = cdgNode->GetLatestDefInsn(regNO);
+  if (curDefInsn != nullptr) {
+    visited[curBB.GetId()] = true;
+    AddDependence(*curDefInsn->GetDepNode(), depNode, depType);
+    return;
+  }
+  for (auto predIt = curBB.GetPredsBegin(); predIt != curBB.GetPredsEnd(); ++predIt) {
+    BuildPredPathDefDependencyDFS(**predIt, visited, depNode, regNO, depType);
+  }
+}
+
+void DataDepBase::BuildPredPathUseDependencyDFS(BB &curBB, std::vector<bool> &visited, DepNode &depNode,
+                                                regno_t regNO, DepType depType) {
+  if (visited[curBB.GetId()]) {
+    return;
+  }
+  CDGNode *cdgNode = curBB.GetCDGNode();
+  CHECK_FATAL(cdgNode != nullptr, "get cdgNode from bb failed");
+  CDGRegion *curRegion = cdgNode->GetRegion();
+  CHECK_FATAL(curRegion != nullptr, "get region from cdgNode failed");
+  if (curRegion->GetRegionId() != curCDGNode->GetRegion()->GetRegionId()) {
+    return;
+  }
+  visited[curBB.GetId()] = true;
+  RegList *useChain = cdgNode->GetUseInsnChain(regNO);
+  while (useChain != nullptr) {
+    Insn *useInsn = useChain->insn;
+    CHECK_FATAL(useInsn != nullptr, "get useInsn failed");
+    AddDependence(*useInsn->GetDepNode(), depNode, depType);
+  }
+  for (auto predIt = curBB.GetPredsBegin(); predIt != curBB.GetPredsEnd(); ++predIt) {
+    BuildPredPathDefDependencyDFS(**predIt, visited, depNode, regNO, depType);
+  }
+}
+
+void DataDepBase::BuildInterBlockSpecialDataInfoDependency(DepNode &curDepNode, bool needCmp, DepType depType,
+                                                           DataDepBase::DataFlowInfoType infoType) {
+  CHECK_FATAL(!IsIntraBlockAnalysis(), "must be inter block data dependence analysis");
+  BB *curBB = curCDGNode->GetBB();
+  CHECK_FATAL(curBB != nullptr, "get bb from cdgNode failed");
+  CDGRegion *curRegion = curCDGNode->GetRegion();
+  CHECK_FATAL(curRegion != nullptr, "get region from cdgNode failed");
+  std::vector<bool> visited(curRegion->GetMaxBBIdInRegion(), false);
+  BuildPredPathSpecialDataInfoDependencyDFS(*curBB, visited, needCmp, curDepNode, depType, infoType);
+}
+
+void DataDepBase::BuildPredPathSpecialDataInfoDependencyDFS(BB &curBB, std::vector<bool> &visited, bool needCmp,
+                                                            DepNode &depNode, DepType depType,
+                                                            DataDepBase::DataFlowInfoType infoType) {
+  if (visited[curBB.GetId()]) {
+    return;
+  }
+  CDGNode *cdgNode = curBB.GetCDGNode();
+  CHECK_FATAL(cdgNode != nullptr, "get cdgNode from bb failed");
+  CDGRegion *curRegion = cdgNode->GetRegion();
+  CHECK_FATAL(curRegion != nullptr, "get region from cdgNode failed");
+  if (curRegion->GetRegionId() != curCDGNode->GetRegion()->GetRegionId()) {
+    return;
+  }
+
+  switch (infoType) {
+    case kMembar: {
+      Insn *membarInsn = cdgNode->GetMembarInsn();
+      if (membarInsn != nullptr) {
+        visited[curBB.GetId()] = true;
+        AddDependence(*membarInsn->GetDepNode(), depNode, depType);
+      }
+      break;
+    }
+    case kLastCall: {
+      Insn *lastCallInsn = cdgNode->GetLastCallInsn();
+      if (lastCallInsn != nullptr) {
+        visited[curBB.GetId()] = true;
+        AddDependence(*lastCallInsn->GetDepNode(), depNode, depType);
+      }
+      break;
+    }
+    case kLastFrameDef: {
+      Insn *lastFrameDef = cdgNode->GetLastFrameDefInsn();
+      if (lastFrameDef != nullptr) {
+        visited[curBB.GetId()] = true;
+        AddDependence(*lastFrameDef->GetDepNode(), depNode, depType);
+      }
+      break;
+    }
+    case kStackUses: {
+      visited[curBB.GetId()] = true;
+      MapleVector<Insn*> stackUses = cdgNode->GetStackUseInsns();
+      if (needCmp) {
+        AddDependence4InsnInVectorByTypeAndCmp(stackUses, *depNode.GetInsn(), depType);
+      } else {
+        AddDependence4InsnInVectorByType(stackUses, *depNode.GetInsn(), depType);
+      }
+      break;
+    }
+    case kStackDefs: {
+      visited[curBB.GetId()] = true;
+      MapleVector<Insn*> stackDefs = cdgNode->GetStackDefInsns();
+      if (needCmp) {
+        AddDependence4InsnInVectorByTypeAndCmp(stackDefs, *depNode.GetInsn(), depType);
+      } else {
+        AddDependence4InsnInVectorByType(stackDefs, *depNode.GetInsn(), depType);
+      }
+      break;
+    }
+    case kHeapUses: {
+      visited[curBB.GetId()] = true;
+      MapleVector<Insn*> heapUses = cdgNode->GetHeapUseInsns();
+      if (needCmp) {
+        AddDependence4InsnInVectorByTypeAndCmp(heapUses, *depNode.GetInsn(), depType);
+      } else {
+        AddDependence4InsnInVectorByType(heapUses, *depNode.GetInsn(), depType);
+      }
+      break;
+    }
+    case kHeapDefs: {
+      visited[curBB.GetId()] = true;
+      MapleVector<Insn*> heapDefs = cdgNode->GetHeapDefInsns();
+      if (needCmp) {
+        AddDependence4InsnInVectorByTypeAndCmp(heapDefs, *depNode.GetInsn(), depType);
+      } else {
+        AddDependence4InsnInVectorByType(heapDefs, *depNode.GetInsn(), depType);
+      }
+      break;
+    }
+    case kMayThrows: {
+      visited[curBB.GetId()] = true;
+      MapleVector<Insn*> mayThrows = cdgNode->GetMayThrowInsns();
+      AddDependence4InsnInVectorByType(mayThrows, *depNode.GetInsn(), depType);
+      break;
+    }
+    case kAmbiguous: {
+      visited[curBB.GetId()] = true;
+      MapleVector<Insn*> ambiInsns = cdgNode->GetAmbiguousInsns();
+      AddDependence4InsnInVectorByType(ambiInsns, *depNode.GetInsn(), depType);
+      break;
+    }
+    default: {
+      visited[curBB.GetId()] = true;
+      break;
+    }
+  }
+  for (auto predIt = curBB.GetPredsBegin(); predIt != curBB.GetPredsEnd(); ++predIt) {
+    BuildPredPathSpecialDataInfoDependencyDFS(**predIt, visited, needCmp, depNode, depType, infoType);
+  }
+}
+
+/*
+ * Add data dependence edge :
+ *   Two data dependence node has a unique edge.
+ *   True data dependence overwrites other dependence.
+ */
+void DataDepBase::AddDependence(DepNode &fromNode, DepNode &toNode, DepType depType) {
+  /* Can not build a self loop dependence */
+  if (&fromNode == &toNode) {
+    return;
+  }
+  /* Check if exist edge */
+  if (!fromNode.GetSuccs().empty()) {
+    DepLink *depLink = fromNode.GetSuccs().back();
+    if (&(depLink->GetTo()) == &toNode) {
+      if (depLink->GetDepType() != kDependenceTypeTrue && depType == kDependenceTypeTrue) {
+        /* Has existed edge, replace it */
+        depLink->SetDepType(kDependenceTypeTrue);
+        depLink->SetLatency(static_cast<uint32>(mad.GetLatency(*fromNode.GetInsn(), *toNode.GetInsn())));
+      }
+      return;
+    }
+  }
+  auto *depLink = memPool.New<DepLink>(fromNode, toNode, depType);
+  if (depType == kDependenceTypeTrue) {
+    depLink->SetLatency(static_cast<uint32>(mad.GetLatency(*fromNode.GetInsn(), *toNode.GetInsn())));
+  }
+  fromNode.AddSucc(*depLink);
+  toNode.AddPred(*depLink);
+}
+
+void DataDepBase::AddDependence4InsnInVectorByType(MapleVector<Insn*> &insns, Insn &insn, const DepType &type) {
+  for (auto anyInsn : insns) {
+    AddDependence(*anyInsn->GetDepNode(), *insn.GetDepNode(), type);
+  }
+}
+
+void DataDepBase::AddDependence4InsnInVectorByTypeAndCmp(MapleVector<Insn*> &insns, Insn &insn, const DepType &type) {
+  for (auto anyInsn : insns) {
+    if (anyInsn != &insn) {
+      AddDependence(*anyInsn->GetDepNode(), *insn.GetDepNode(), type);
+    }
+  }
+}
+
+/* Combine two data dependence nodes to one */
+void DataDepBase::CombineDependence(DepNode &firstNode, const DepNode &secondNode, bool isAcrossSeparator,
+                                    bool isMemCombine) {
+  if (isAcrossSeparator) {
+    /* Clear all latency of the second node. */
+    for (auto predLink : secondNode.GetPreds()) {
+      predLink->SetLatency(0);
+    }
+    for (auto succLink : secondNode.GetSuccs()) {
+      succLink->SetLatency(0);
+    }
+    return;
+  }
+  std::set<DepNode*> uniqueNodes;
+
+  for (auto predLink : firstNode.GetPreds()) {
+    if (predLink->GetDepType() == kDependenceTypeTrue) {
+      predLink->SetLatency(
+          static_cast<uint32>(mad.GetLatency(*predLink->GetFrom().GetInsn(), *firstNode.GetInsn())));
+    }
+    (void)uniqueNodes.insert(&predLink->GetFrom());
+  }
+  for (auto predLink : secondNode.GetPreds()) {
+    if (&predLink->GetFrom() != &firstNode) {
+      if (uniqueNodes.insert(&(predLink->GetFrom())).second) {
+        AddDependence(predLink->GetFrom(), firstNode, predLink->GetDepType());
+      }
+    }
+    predLink->SetLatency(0);
+  }
+  uniqueNodes.clear();
+  for (auto succLink : firstNode.GetSuccs()) {
+    if (succLink->GetDepType() == kDependenceTypeTrue) {
+      succLink->SetLatency(
+          static_cast<uint32>(mad.GetLatency(*succLink->GetFrom().GetInsn(), *firstNode.GetInsn())));
+    }
+    (void)uniqueNodes.insert(&(succLink->GetTo()));
+  }
+  for (auto succLink : secondNode.GetSuccs()) {
+    if (uniqueNodes.insert(&(succLink->GetTo())).second) {
+      AddDependence(firstNode, succLink->GetTo(), succLink->GetDepType());
+      if (isMemCombine) {
+        succLink->GetTo().IncreaseValidPredsSize();
+      }
+    }
+    succLink->SetLatency(0);
+  }
+}
+
+/* Remove self data dependence (self loop) in data dependence graph. */
+void DataDepBase::RemoveSelfDeps(Insn &insn) {
+  DepNode *node = insn.GetDepNode();
+  ASSERT(node->GetSuccs().back()->GetTo().GetInsn() == &insn, "Is not a self dependence.");
+  ASSERT(node->GetPreds().back()->GetFrom().GetInsn() == &insn, "Is not a self dependence.");
+  node->RemoveSucc();
+  node->RemovePred();
+}
+
+/* Check if in intra-block data dependence analysis */
+bool DataDepBase::IsIntraBlockAnalysis() const {
+  if (curCDGNode->GetRegion() == nullptr || curCDGNode->GetRegion()->GetRegionNodes().size() == 1) {
+    return true;
+  }
+  return false;
+}
+
+/* Check if regNO is in ehInRegs. */
+bool DataDepBase::IfInAmbiRegs(regno_t regNO) const {
+  if (!curCDGNode->HasAmbiRegs()) {
+    return false;
+  }
+  MapleSet<regno_t> ehInRegs = curCDGNode->GetEhInRegs();
+  if (ehInRegs.find(regNO) != ehInRegs.end()) {
+    return true;
+  }
+  return false;
+}
+
+/* Return data dependence type name */
+const std::string &DataDepBase::GetDepTypeName(DepType depType) const {
+  ASSERT(depType <= kDependenceTypeNone, "array boundary check failed");
+  return kDepTypeName[depType];
+}
+
+/* Print data dep node information */
+void DataDepBase::DumpDepNode(const DepNode &node) const {
+  node.GetInsn()->Dump();
+  uint32 num = node.GetUnitNum();
+  LogInfo::MapleLogger() << "unit num : " << num << ", ";
+  for (uint32 i = 0; i < num; ++i) {
+    const Unit *unit = node.GetUnitByIndex(i);
+    if (unit != nullptr) {
+      PRINT_VAL(unit->GetName());
+    } else {
+      PRINT_VAL("none");
+    }
+  }
+  LogInfo::MapleLogger() << '\n';
+  node.DumpSchedInfo();
+  if (beforeRA) {
+    node.DumpRegPressure();
+  }
+}
+
+/* Print dep link information */
+void DataDepBase::DumpDepLink(const DepLink &link, const DepNode *node) const {
+  PRINT_VAL(GetDepTypeName(link.GetDepType()));
+  PRINT_STR_VAL("Latency: ", link.GetLatency());
+  if (node != nullptr) {
+    node->GetInsn()->Dump();
+    return;
+  }
+  LogInfo::MapleLogger() << "from : ";
+  link.GetFrom().GetInsn()->Dump();
+  LogInfo::MapleLogger() << "to : ";
+  link.GetTo().GetInsn()->Dump();
+}
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/dbg.cpp b/src/mapleall/maple_be/src/cg/dbg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a5fecd9b8c63e8230aa80989cd1bbfd71034fe4a
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/dbg.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) [2020-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dbg.h"
+#include "emit.h"
+
+namespace mpldbg {
+using maplebe::Operand;
+using maplebe::MOperator;
+using maplebe::CG;
+using maplebe::Emitter;
+using maplebe::OpndDesc;
+
+struct DbgDescr {
+  const std::string name;
+  uint32 opndCount;
+  /* create 3 OperandType array to store dbg instruction's operand type */
+  std::array<Operand::OperandType, 3> opndTypes;
+};
+
+static DbgDescr dbgDescrTable[kOpDbgLast + 1] = {
+#define DBG_DEFINE(k, sub, n, o0, o1, o2) \
+  { #k, n, { Operand::kOpd##o0, Operand::kOpd##o1, Operand::kOpd##o2 } },
+#include "dbg.def"
+#undef DBG_DEFINE
+  { "undef", 0, { Operand::kOpdUndef, Operand::kOpdUndef, Operand::kOpdUndef } }
+};
+
+void DbgInsn::Dump() const {
+  MOperator mOp = GetMachineOpcode();
+  DbgDescr &dbgDescr = dbgDescrTable[mOp];
+  LogInfo::MapleLogger() << "DBG " << dbgDescr.name;
+  for (uint32 i = 0; i < dbgDescr.opndCount; ++i) {
+    LogInfo::MapleLogger() << (i == 0 ? " : " : " ");
+    Operand &curOperand = GetOperand(i);
+    curOperand.Dump();
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+#if DEBUG
+void DbgInsn::Check() const {
+  DbgDescr &dbgDescr = dbgDescrTable[GetMachineOpcode()];
+  /* dbg instruction's 3rd /4th/5th operand must be null */
+  for (uint32 i = 0; i < dbgDescr.opndCount; ++i) {
+    Operand &opnd = GetOperand(i);
+    if (opnd.GetKind() != dbgDescr.opndTypes[i]) {
+      CHECK_FATAL(false, "incorrect operand in debug insn");
+    }
+  }
+}
+#endif
+
+uint32 DbgInsn::GetLoc() const {
+  if (mOp != OP_DBG_loc) {
+    return 0;
+  }
+  return static_cast<uint32>(static_cast<ImmOperand *>(opnds[0])->GetVal());
+}
+
+void ImmOperand::Dump() const {
+  LogInfo::MapleLogger() << " " << val;
+}
+void DBGOpndEmitVisitor::Visit(ImmOperand *v) {
+  emitter.Emit(v->GetVal());
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/ebo.cpp b/src/mapleall/maple_be/src/cg/ebo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..258808e83bf2572f4efa862a5091ba75bfe2a5df
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/ebo.cpp
@@ -0,0 +1,1306 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#if TARGAARCH64
+#include "aarch64_ebo.h"
+#elif TARGRISCV64
+#include "riscv64_ebo.h"
+#endif
+#if TARGARM32
+#include "arm32_ebo.h"
+#endif
+#include "securec.h"
+
+#include "optimize_common.h"
+
+/*
+ * The Optimizations include forward propagation, common expression elimination, constant folding,
+ * dead code elimination and some target optimizations. The main entry of the optimization is run.
+ * When the Optimization level is less than O2, it can only perform in single block. and in O2 it
+ * can perform it a sequence of blocks.
+ */
+namespace maplebe {
+using namespace maple;
+
+#define EBO_DUMP CG_DEBUG_FUNC(*cgFunc)
+#define EBO_DUMP_NEWPM CG_DEBUG_FUNC(f)
+#define TRUE_OPND cgFunc->GetTrueOpnd()
+
+constexpr uint32 kEboOpndHashLength = 521;
+constexpr uint32 kEboMaxBBNums = 200;
+
+/* Return the opndInfo for the first mem operand of insn. */
+MemOpndInfo *Ebo::GetMemInfo(InsnInfo &insnInfo) const {
+  Insn *insn = insnInfo.insn;
+  CHECK_FATAL(insn != nullptr, "insnInfo.insn is nullptr!");
+  CHECK_FATAL(insn->AccessMem(), "insn is not access memory!");
+  uint32 opndNum = insn->GetOperandSize();
+  if (insn->IsLoad()) {
+    for (uint32 i = 0; i < opndNum; ++i) {
+      if (insn->GetOperand(i).IsMemoryAccessOperand()) {
+        return static_cast<MemOpndInfo*>(insnInfo.origOpnd[i]);
+      }
+    }
+  } else if (insn->IsStore()) {
+    int32 resId = 0;
+    for (uint32 i = 0; i < opndNum; ++i) {
+      if (insn->OpndIsDef(i)) {
+        if (insn->GetOperand(i).IsMemoryAccessOperand()) {
+          return static_cast<MemOpndInfo*>(insnInfo.result[resId]);
+        } else {
+          resId++;
+        }
+      }
+    }
+  }
+  return nullptr;
+}
+
+void Ebo::EnlargeSpaceForLA(Insn &csetInsn) const {
+  CHECK_FATAL(live != nullptr, "no live info!");
+  live->EnlargeSpaceForLiveAnalysis(*csetInsn.GetBB());
+}
+
+bool Ebo::IsFrameReg(Operand &opnd) const {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  RegOperand &reg = static_cast<RegOperand&>(opnd);
+  return cgFunc->IsFrameReg(reg);
+}
+
+Operand *Ebo::GetZeroOpnd(uint32 size) const {
+#if TARGAARCH64 || TARGRISCV64
+  return size > k64BitSize ? nullptr : &cgFunc->GetZeroOpnd(size);
+#else
+  return nullptr;
+#endif
+}
+
+bool Ebo::IsSaveReg(const Operand &opnd) const {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  const RegOperand &reg = static_cast<const RegOperand&>(opnd);
+  return cgFunc->IsSaveReg(reg, *cgFunc->GetFunction().GetReturnType(), cgFunc->GetBecommon());
+}
+
+bool Ebo::IsPhysicalReg(const Operand &opnd) const {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  const RegOperand &reg = static_cast<const RegOperand&>(opnd);
+  return reg.IsPhysicalRegister();
+}
+
+bool Ebo::HasAssignedReg(const Operand &opnd) const {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  const auto &reg = static_cast<const RegOperand&>(opnd);
+  return reg.IsVirtualRegister() ? (!IsInvalidReg(reg)) : true;
+}
+
+bool Ebo::IsOfSameClass(const Operand &op0, const Operand &op1) const {
+  if (!op0.IsRegister() || !op1.IsRegister()) {
+    return false;
+  }
+  const auto &reg0 = static_cast<const RegOperand&>(op0);
+  const auto &reg1 = static_cast<const RegOperand&>(op1);
+  return reg0.GetRegisterType() == reg1.GetRegisterType();
+}
+
+/* return true if opnd of bb is available. */
+bool Ebo::OpndAvailableInBB(const BB &bb, OpndInfo *info) const {
+  if (info == nullptr) {
+    return false;
+  }
+  if (info->opnd == nullptr) {
+    return false;
+  }
+
+  Operand *op = info->opnd;
+  if (IsConstantImmOrReg(*op)) {
+    return true;
+  }
+
+  int32 hashVal = 0;
+  if (op->IsRegShift() || op->IsRegister()) {
+    hashVal = -1;
+  } else {
+    hashVal = info->hashVal;
+  }
+  if (GetOpndInfo(*op, hashVal) != info) {
+    return false;
+  }
+  /* global operands aren't supported at low levels of optimization. */
+  if ((Globals::GetInstance()->GetOptimLevel() < CGOptions::kLevel2) && (&bb != info->bb)) {
+    return false;
+  }
+  if (beforeRegAlloc && IsPhysicalReg(*op)) {
+    return false;
+  }
+  return true;
+}
+
+bool Ebo::ForwardPropCheck(const Operand *opndReplace, const OpndInfo &opndInfo, const Operand &opnd, Insn &insn) {
+  if (opndReplace == nullptr) {
+    return false;
+  }
+  if ((opndInfo.replacementInfo != nullptr) && opndInfo.replacementInfo->redefined) {
+    return false;
+  }
+#if TARGARM32
+  /* for arm32, disable forwardProp in strd insn. */
+  if (insn.GetMachineOpcode() == MOP_strd) {
+    return false;
+  }
+  if (opndInfo.mayReDef) {
+    return false;
+  }
+#endif
+  if (!(IsConstantImmOrReg(*opndReplace) ||
+        ((OpndAvailableInBB(*insn.GetBB(), opndInfo.replacementInfo) || RegistersIdentical(opnd, *opndReplace)) &&
+         (HasAssignedReg(opnd) == HasAssignedReg(*opndReplace))))) {
+    return false;
+  }
+  /* if beforeRA, replace op should not be PhysicalRe */
+  return !beforeRegAlloc || !IsPhysicalReg(*opndReplace);
+}
+
+bool Ebo::RegForwardCheck(Insn &insn, const Operand &opnd, const Operand *opndReplace, Operand &oldOpnd,
+                          const OpndInfo *tmpInfo) const {
+  if (IsConstantImmOrReg(opnd)) {
+    return false;
+  }
+  if (!(!beforeRegAlloc || (HasAssignedReg(oldOpnd) == HasAssignedReg(*opndReplace)) || IsZeroRegister(opnd) ||
+        !insn.IsMove())) {
+    return false;
+  }
+  std::set<regno_t> defRegs = insn.GetDefRegs();
+  if (!(defRegs.empty() ||
+      ((opnd.IsRegister() && !defRegs.count(static_cast<const RegOperand&>(opnd).GetRegisterNumber())) ||
+      !beforeRegAlloc))) {
+    return false;
+  }
+  if (!(beforeRegAlloc || !IsFrameReg(oldOpnd))) {
+    return false;
+  }
+  if (insn.GetBothDefUseOpnd() != kInsnMaxOpnd) {
+    return false;
+  }
+  if (IsPseudoRet(insn)) {
+    return false;
+  }
+
+  return ((IsOfSameClass(oldOpnd, *opndReplace) && (oldOpnd.GetSize() <= opndReplace->GetSize())) ||
+          ((tmpInfo != nullptr) && IsMovToSIMDVmov(insn, *tmpInfo->insn)));
+}
+
+/* For Memory Operand, its info was stored in a hash table, this function is to compute its hash value. */
+int32 Ebo::ComputeOpndHash(const Operand &opnd) const {
+  uint64 hashIdx = reinterpret_cast<uint64>(&opnd) >> k4ByteSize;
+  return static_cast<int32>(hashIdx % kEboOpndHashLength);
+}
+
+/* Store the operand information. Store it to the vRegInfo if is register. otherwise put it to the hash table. */
+void Ebo::SetOpndInfo(const Operand &opnd, OpndInfo *opndInfo, int32 hashVal) {
+  /* opnd is Register or RegShift */
+  if (hashVal == -1) {
+    const RegOperand &reg = GetRegOperand(opnd);
+    vRegInfo[reg.GetRegisterNumber()] = opndInfo;
+    return;
+  }
+
+  CHECK_FATAL(static_cast<uint64>(static_cast<int64>(hashVal)) < exprInfoTable.size(),
+              "SetOpndInfo hashval outof range!");
+  opndInfo->hashVal = hashVal;
+  opndInfo->hashNext = exprInfoTable.at(hashVal);
+  exprInfoTable.at(hashVal) = opndInfo;
+}
+
+/* Used to change the info of opnd from opndinfo to newinfo. */
+void Ebo::UpdateOpndInfo(const Operand &opnd, OpndInfo &opndInfo, OpndInfo *newInfo, int32 hashVal) {
+  if (hashVal == -1) {
+    const RegOperand &reg = GetRegOperand(opnd);
+    vRegInfo[reg.GetRegisterNumber()] = newInfo;
+    return;
+  }
+  ASSERT(hashVal < exprInfoTable.size(), "SetOpndInfo hashval outof range!");
+  OpndInfo *info = exprInfoTable.at(hashVal);
+  if (newInfo != nullptr) {
+    newInfo->hashNext = opndInfo.hashNext;
+    opndInfo.hashNext = nullptr;
+    if (info == &opndInfo) {
+      exprInfoTable.at(hashVal) = newInfo;
+      return;
+    }
+    while (info != nullptr) {
+      if (info->hashNext == &opndInfo) {
+        info->hashNext = newInfo;
+        return;
+      }
+      info = info->hashNext;
+    }
+    return;
+  }
+  if (info == &opndInfo) {
+    exprInfoTable.at(hashVal) = opndInfo.hashNext;
+    return;
+  }
+  while (info != nullptr) {
+    if (info->hashNext == &opndInfo) {
+      info->hashNext = opndInfo.next;
+      opndInfo.hashNext = nullptr;
+      return;
+    }
+    info = info->hashNext;
+  }
+}
+
+/* return true if op1 op2 is equal */
+bool Ebo::OperandEqual(const Operand &op1, const Operand &op2) const {
+  if (&op1 == &op2) {
+    return true;
+  }
+  if (op1.GetKind() != op2.GetKind()) {
+    return false;
+  }
+  return OperandEqSpecial(op1, op2);
+}
+
+OpndInfo *Ebo::GetOpndInfo(const Operand &opnd, int32 hashVal) const {
+  if (hashVal < 0) {
+    const RegOperand &reg = GetRegOperand(opnd);
+    auto it = vRegInfo.find(reg.GetRegisterNumber());
+    return it != vRegInfo.end() ? it->second : nullptr;
+  }
+  /* do not find prev memOpend */
+  if (opnd.IsMemoryAccessOperand()) {
+    return nullptr;
+  }
+  ASSERT(hashVal < exprInfoTable.size(), "SetOpndInfo hashval outof range!");
+  OpndInfo *info = exprInfoTable.at(hashVal);
+  while (info != nullptr) {
+    if (&opnd == info->opnd) {
+      return info;
+    }
+    info = info->hashNext;
+  }
+  return nullptr;
+}
+
+/* Create a opndInfo for opnd. */
+OpndInfo *Ebo::GetNewOpndInfo(BB &bb, Insn *insn, Operand &opnd, int32 hashVal) {
+  OpndInfo *opndInfo = nullptr;
+  if (opnd.IsMemoryAccessOperand()) {
+    opndInfo = eboMp->New<MemOpndInfo>(opnd);
+  } else {
+    opndInfo = eboMp->New<OpndInfo>(opnd);
+  }
+  /* Initialize the entry. */
+  opndInfo->hashVal = hashVal;
+  opndInfo->opnd = &opnd;
+  opndInfo->bb = &bb;
+  opndInfo->insn = insn;
+  opndInfo->prev = lastOpndInfo;
+  if (firstOpndInfo == nullptr) {
+    firstOpndInfo = opndInfo;
+  } else {
+    lastOpndInfo->next = opndInfo;
+  }
+  lastOpndInfo = opndInfo;
+  return opndInfo;
+}
+
+/* Update the use infomation for localOpnd because of its use insn currentInsn. */
+OpndInfo *Ebo::OperandInfoUse(BB &currentBB, Operand &localOpnd) {
+  if (!(localOpnd.IsRegister() || localOpnd.IsRegShift()) && !localOpnd.IsMemoryAccessOperand()) {
+    return nullptr;
+  }
+  int hashVal = 0;
+  /* only arm32 has regShift */
+  if (localOpnd.IsRegister() || localOpnd.IsRegShift()) {
+    hashVal = -1;
+  } else {
+    hashVal = ComputeOpndHash(localOpnd);
+  }
+  OpndInfo *opndInfo = GetOpndInfo(localOpnd, hashVal);
+
+  if (opndInfo == nullptr) {
+    opndInfo = GetNewOpndInfo(currentBB, nullptr, localOpnd, hashVal);
+    SetOpndInfo(localOpnd, opndInfo, hashVal);
+  }
+  IncRef(*opndInfo);
+  return opndInfo;
+}
+
+/* return true if op0 is identical with op1 */
+bool Ebo::RegistersIdentical(const Operand &op0, const Operand &op1) const {
+  if (&op0 == &op1) {
+    return true;
+  }
+  if (!(op0.IsRegister() && op1.IsRegister())) {
+    return false;
+  }
+  const RegOperand &reg0 = static_cast<const RegOperand&>(op0);
+  const RegOperand &reg1 = static_cast<const RegOperand&>(op1);
+  return ((reg0.IsPhysicalRegister() || !IsInvalidReg(reg0)) &&
+          (reg1.IsPhysicalRegister() || !IsInvalidReg(reg1)) &&
+          (reg0.GetRegisterType() == reg1.GetRegisterType()) &&
+          (reg0.GetRegisterNumber() == reg1.GetRegisterNumber()));
+}
+
+InsnInfo *Ebo::GetNewInsnInfo(Insn &insn) {
+  InsnInfo *insnInfo = eboMp->New<InsnInfo>(*eboMp, insn);
+  insnInfo->prev = lastInsnInfo;
+  if (firstInsnInfo == nullptr) {
+    firstInsnInfo = insnInfo;
+  } else {
+    lastInsnInfo->next = insnInfo;
+  }
+  lastInsnInfo = insnInfo;
+  insnInfo->next = nullptr;
+  return insnInfo;
+}
+
+uint32 Ebo::ComputeHashVal(Insn &insn, const MapleVector<OpndInfo*> &opndInfos) const {
+  uint32 hashVal = 0;
+  if (insn.AccessMem()) {
+    hashVal = kEboDefaultMemHash;
+    if (insn.NoAlias()) {
+      hashVal = kEboNoAliasMemHash;
+    }
+    MemOperand *memOpnd = static_cast<MemOperand *>(insn.GetMemOpnd());
+    if (memOpnd != nullptr) {
+      Operand *baseReg = memOpnd->GetBaseRegister();
+      if ((baseReg != nullptr) && IsFrameReg(*baseReg)) {
+        hashVal = kEboSpillMemHash;
+      }
+    }
+  } else if (Globals::GetInstance()->GetTarget()->IsEffectiveCopy(insn)) {
+    hashVal = kEboCopyInsnHash;
+  } else {
+    uint32 opndNum = insn.GetOperandSize();
+    hashVal = insn.GetMachineOpcode();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      hashVal += static_cast<uint32>(reinterpret_cast<uintptr_t>(opndInfos.at(i)));
+    }
+    hashVal = static_cast<uint32>(kEboReservedInsnHash + EBO_EXP_INSN_HASH(hashVal));
+  }
+  return hashVal;
+}
+
+/* computeHashVal of insn */
+void Ebo::HashInsn(Insn &insn, const MapleVector<OpndInfo*> &origInfo, const MapleVector<OpndInfo*> &opndInfos) {
+  uint32 hashVal = ComputeHashVal(insn, opndInfos);
+  /* Create a new insnInfo entry and add the new insn to the hash table. */
+  InsnInfo *insnInfo = GetNewInsnInfo(insn);
+  insnInfo->bb = insn.GetBB();
+  insnInfo->insn = &insn;
+  insnInfo->hashIndex = hashVal;
+  insnInfo->same = insnInfoTable.at(hashVal);
+
+  if (!beforeRegAlloc) {
+    if ((insn.IsCall() || insn.IsTailCall() || insn.IsAsmInsn()) && !insn.GetIsThrow()) {
+      DefineCallerSaveRegisters(*insnInfo);
+    } else if (IsClinitCheck(insn)) {
+      DefineClinitSpecialRegisters(*insnInfo);
+    }
+  }
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    /* Copy all the opndInfo entries for the operands. */
+    insnInfo->origOpnd.emplace_back(origInfo.at(i));
+    insnInfo->optimalOpnd.emplace_back(opndInfos.at(i));
+    /* Keep the result info. */
+    if (!insn.OpndIsDef(i)) {
+      continue;
+    }
+    auto genOpndInfoDef = [this, insnInfo](Operand &op) {
+      OpndInfo *opndInfo = nullptr;
+      if ((&op != TRUE_OPND) &&
+          ((op.IsRegister() && (&op) != GetZeroOpnd(op.GetSize())) ||
+           (op.IsMemoryAccessOperand() && (static_cast<MemOperand&>(op)).GetBaseRegister() != nullptr))) {
+        opndInfo = OperandInfoDef(*insnInfo->bb, *insnInfo->insn, op);
+        opndInfo->insnInfo = insnInfo;
+      }
+      insnInfo->result.emplace_back(opndInfo);
+    };
+    Operand &op = insn.GetOperand(i);
+    if (op.IsList() && !static_cast<ListOperand&>(op).GetOperands().empty()) {
+      for (auto operand : static_cast<ListOperand&>(op).GetOperands()) {
+        genOpndInfoDef(*operand);
+      }
+    } else {
+      genOpndInfoDef(op);
+    }
+  }
+  SetInsnInfo(hashVal, *insnInfo);
+}
+
+/* do decref of orig_info, refCount will be set to 0 */
+void Ebo::RemoveUses(uint32 opndNum, const MapleVector<OpndInfo*> &origInfo) const {
+  OpndInfo *info = nullptr;
+  for (uint32 i = 0; i < opndNum; ++i) {
+    info = origInfo.at(i);
+    if (info != nullptr) {
+      DecRef(*info);
+      if (info->opnd->IsMemoryAccessOperand()) {
+        MemOpndInfo *memInfo = static_cast<MemOpndInfo*>(info);
+        OpndInfo *baseInfo = memInfo->GetBaseInfo();
+        OpndInfo *offsetInfo = memInfo->GetOffsetInfo();
+        if (baseInfo != nullptr) {
+          DecRef(*baseInfo);
+        }
+        if (offsetInfo != nullptr) {
+          DecRef(*offsetInfo);
+        }
+      }
+    }
+  }
+}
+
+OpndInfo *Ebo::BuildMemOpndInfo(BB &bb, Insn &insn, Operand &opnd, uint32 opndIndex) {
+  auto *memOpnd = static_cast<MemOperand*>(&opnd);
+  Operand *base = memOpnd->GetBaseRegister();
+  Operand *offset = memOpnd->GetOffset();
+  OpndInfo *baseInfo = nullptr;
+  OpndInfo *offsetInfo = nullptr;
+  if (base != nullptr) {
+    if (!memOpnd->IsIntactIndexed()) {
+      baseInfo = OperandInfoUse(bb, *base);
+      baseInfo = OperandInfoDef(bb, insn, *base);
+      return baseInfo;
+    } else {
+      baseInfo = OperandInfoUse(bb, *base);
+    }
+    /* forward prop for base register. */
+    if ((baseInfo != nullptr) && base->IsRegister()) {
+      auto *baseReg = static_cast<RegOperand*>(base);
+      Operand *replaceOpnd = baseInfo->replacementOpnd;
+      OpndInfo *replaceInfo = baseInfo->replacementInfo;
+      if ((replaceInfo != nullptr) && (replaceOpnd != nullptr) && !cgFunc->IsSPOrFP(*baseReg) &&
+          (!beforeRegAlloc || (!IsPhysicalReg(*replaceOpnd) && !IsPhysicalReg(*base))) &&
+          IsOfSameClass(*base, *replaceOpnd) && memOpnd->IsIntactIndexed() &&
+          (base->GetSize() <= replaceOpnd->GetSize()) &&
+          /* In case that replace opnd was redefined. */
+          !replaceInfo->redefined) {
+        MemOperand *newMem = static_cast<MemOperand*>(memOpnd->Clone(*cgFunc->GetMemoryPool()));
+        CHECK_FATAL(newMem != nullptr, "newMem is null in Ebo::BuildAllInfo(BB *bb)");
+        newMem->SetBaseRegister(*static_cast<RegOperand*>(replaceOpnd));
+        insn.SetOperand(opndIndex, *newMem);
+        DecRef(*baseInfo);
+        IncRef(*replaceInfo);
+        baseInfo = replaceInfo;
+      }
+    }
+  }
+  if ((offset != nullptr) && offset->IsRegister()) {
+    offsetInfo = OperandInfoUse(bb, *offset);
+  }
+  OpndInfo *opndInfo = OperandInfoUse(bb, insn.GetOperand(opndIndex));
+  CHECK_FATAL(opndInfo != nullptr, "opndInfo should not be null ptr");
+  MemOpndInfo *memInfo = static_cast<MemOpndInfo*>(opndInfo);
+  if (baseInfo != nullptr) {
+    memInfo->SetBaseInfo(*baseInfo);
+  }
+  if (offsetInfo != nullptr) {
+    memInfo->SetOffsetInfo(*offsetInfo);
+  }
+  return memInfo;
+}
+
+OpndInfo *Ebo::BuildOperandInfo(BB &bb, Insn &insn, Operand &opnd, uint32 opndIndex,
+                                MapleVector<OpndInfo*> &origInfos) {
+  if (opnd.IsList()) {
+    ListOperand *listOpnd = static_cast<ListOperand*>(&opnd);
+    for (auto op : listOpnd->GetOperands()) {
+      OperandInfoUse(bb, *op);
+    }
+    return nullptr;
+  }
+  ASSERT(opndIndex < origInfos.size(), "SetOpndInfo hashval outof range!");
+  if (opnd.IsConditionCode()) {
+    Operand &rFlag = cgFunc->GetOrCreateRflag();
+    OperandInfoUse(bb, rFlag);
+    /* if operand is Opnd_cond, the orig_info store the info of rFlag. */
+    OpndInfo *tempOpndInfo = GetOpndInfo(rFlag, -1);
+    origInfos.at(opndIndex) = tempOpndInfo;
+    return nullptr;
+  }
+
+  if (!(opnd.IsRegister() || opnd.IsRegShift()) && !opnd.IsMemoryAccessOperand()) {
+    return nullptr;
+  }
+
+  if (opnd.IsMemoryAccessOperand()) {
+    OpndInfo *memInfo = BuildMemOpndInfo(bb, insn, opnd, opndIndex);
+    CHECK_FATAL(memInfo != nullptr, "build memopnd info failed in Ebo::BuildAllInfo");
+    origInfos.at(opndIndex) = memInfo;
+    return nullptr;
+  }
+  OpndInfo *opndInfo = OperandInfoUse(bb, opnd);
+  origInfos.at(opndIndex) = opndInfo;
+  return opndInfo;
+}
+
+bool Ebo::ForwardPropagateOpnd(Insn &insn, Operand *&opnd, uint32 opndIndex,
+                               OpndInfo *&opndInfo, MapleVector<OpndInfo*> &origInfos) {
+  CHECK_FATAL(opnd != nullptr, "nullptr check");
+  Operand *opndReplace = opndInfo->replacementOpnd;
+  /* Don't propagate physical registers before register allocation. */
+  if (beforeRegAlloc && (opndReplace != nullptr) && (IsPhysicalReg(*opndReplace) || IsPhysicalReg(*opnd))) {
+    return false;
+  }
+
+  /* forward propagation of constants */
+  CHECK_FATAL(opndIndex < origInfos.size(), "SetOpndInfo hashval outof range!");
+  if (!ForwardPropCheck(opndReplace, *opndInfo, *opnd, insn)) {
+    return false;
+  }
+  Operand *oldOpnd = opnd;
+  opnd = opndInfo->replacementOpnd;
+  opndInfo = opndInfo->replacementInfo;
+
+  /* constant prop. */
+  if (opnd->IsIntImmediate() && oldOpnd->IsRegister()) {
+    if (DoConstProp(insn, opndIndex, *opnd)) {
+      DecRef(*origInfos.at(opndIndex));
+      /* Update the actual expression info. */
+      origInfos.at(opndIndex) = opndInfo;
+    }
+  }
+  /* move reg, wzr, store vreg, mem ==> store wzr, mem */
+#if TARGAARCH64 || TARGRISCV64
+  if (IsZeroRegister(*opnd) && opndIndex == 0 &&
+      (insn.GetMachineOpcode() == MOP_wstr || insn.GetMachineOpcode() == MOP_xstr)) {
+    if (EBO_DUMP) {
+      LogInfo::MapleLogger() << "===replace operand " << opndIndex << " of insn: \n";
+      insn.Dump();
+      LogInfo::MapleLogger() << "the new insn is:\n";
+    }
+    insn.SetOperand(opndIndex, *opnd);
+    DecRef(*origInfos.at(opndIndex));
+    /* Update the actual expression info. */
+    origInfos.at(opndIndex) = opndInfo;
+    if (EBO_DUMP) {
+      insn.Dump();
+    }
+  }
+#endif
+  /* forward prop for registers. */
+  if (!RegForwardCheck(insn, *opnd, opndReplace, *oldOpnd, origInfos.at(opndIndex))) {
+    return false;
+  }
+  /* Copies to and from the same register are not needed. */
+  if (!beforeRegAlloc && Globals::GetInstance()->GetTarget()->IsEffectiveCopy(insn) && (opndIndex == kInsnSecondOpnd) &&
+      RegistersIdentical(*opnd, insn.GetOperand(kInsnFirstOpnd)) && !LiveOutOfBB(*opnd, *(insn.GetBB()))) {
+    if (EBO_DUMP) {
+      LogInfo::MapleLogger() << "===replace operand " << opndIndex << " of insn: \n";
+      insn.Dump();
+      LogInfo::MapleLogger() << "===Remove the new insn because Copies to and from the same register. \n";
+    }
+    return true;
+  }
+  if (static_cast<RegOperand *>(opnd)->GetRegisterNumber() == RSP) {
+    /* Disallow optimization with stack pointer */
+    return false;
+  }
+
+  if (EBO_DUMP) {
+    LogInfo::MapleLogger() << "===replace operand " << opndIndex << " of insn: \n";
+    insn.Dump();
+    LogInfo::MapleLogger() << "the new insn is:\n";
+  }
+  DecRef(*origInfos.at(opndIndex));
+  insn.SetOperand(opndIndex, *opnd);
+
+  if (EBO_DUMP) {
+    insn.Dump();
+  }
+  IncRef(*opndInfo);
+  /* Update the actual expression info. */
+  origInfos.at(opndIndex) = opndInfo;
+  /* extend the live range of the replacement operand. */
+  if ((opndInfo->bb != insn.GetBB()) && opnd->IsRegister()) {
+    MarkOpndLiveIntoBB(*opnd, *insn.GetBB(), *opndInfo->bb);
+  }
+  return false;
+}
+
+/*
+ * this func do only one of the following optimization:
+ * 1. Remove DupInsns
+ * 2. SpecialSequence OPT
+ * 3. Remove Redundant "Load"
+ * 4. Constant Fold
+ */
+void Ebo::SimplifyInsn(Insn &insn, bool &insnReplaced, bool opndsConstant,
+                       const MapleVector<Operand*> &opnds, const MapleVector<OpndInfo*> &opndInfos,
+                       const MapleVector<OpndInfo*> &origInfos) {
+  if (insn.AccessMem()) {
+    if (!insnReplaced) {
+      insnReplaced = SpecialSequence(insn, origInfos);
+    }
+    return;
+  }
+  if (Globals::GetInstance()->GetTarget()->IsEffectiveCopy(insn)) {
+    if (!insnReplaced) {
+      insnReplaced = SpecialSequence(insn, opndInfos);
+    }
+    return;
+  }
+  if (!insnReplaced && !insn.HasSideEffects()) {
+    uint32 opndNum = insn.GetOperandSize();
+    if (opndsConstant && (opndNum > 1)) {
+      if (!insn.GetDefRegs().empty()) {
+        insnReplaced = Csel2Cset(insn, opnds);
+      }
+    }
+    if (insnReplaced) {
+      return;
+    }
+    if (opndNum >= 2) {
+      /* special case */
+      if (!insn.GetDefRegs().empty() && ResIsNotDefAndUse(insn)) {
+        if ((opndNum == 3) && (insn.GetDefRegs().size() == 1) &&
+            (((kInsnSecondOpnd < opnds.size()) && (opnds[kInsnSecondOpnd] != nullptr) &&
+              IsConstantImmOrReg(*opnds[kInsnSecondOpnd])) ||
+             ((kInsnThirdOpnd < opnds.size()) && (opnds[kInsnThirdOpnd] != nullptr) &&
+              IsConstantImmOrReg(*opnds[kInsnThirdOpnd])))) {
+          insnReplaced = SimplifyConstOperand(insn, opnds, opndInfos);
+        }
+      }
+      if (!insnReplaced) {
+        insnReplaced = SpecialSequence(insn, origInfos);
+      }
+    }
+  }
+}
+
+/*
+ * this func do:
+ * 1. delete DupInsn if SimplifyInsn failed.
+ * 2. buildInsnInfo if delete DupInsn failed(func HashInsn do this).
+ * 3. update replaceInfo.
+ */
+void Ebo::FindRedundantInsns(BB &bb, Insn *&insn, const Insn *prev, bool insnReplaced,
+                             MapleVector<Operand*> &opnds, MapleVector<OpndInfo*> &opndInfos,
+                             const MapleVector<OpndInfo*> &origInfos) {
+  CHECK_FATAL(insn != nullptr, "nullptr check");
+  if (!insnReplaced) {
+    CHECK_FATAL(origInfos.size() != 0, "null ptr check");
+    CHECK_FATAL(opndInfos.size() != 0, "null ptr check");
+    HashInsn(*insn, origInfos, opndInfos);
+    /* Processing the result of the insn. */
+    if ((Globals::GetInstance()->GetTarget()->IsEffectiveCopy(*insn) ||
+        !insn->GetDefRegs().empty()) && !insn->IsSpecialIntrinsic()) {
+      Operand *res = &insn->GetOperand(kInsnFirstOpnd);
+      if ((res != nullptr) && (res != TRUE_OPND) && (res != GetZeroOpnd(res->GetSize()))) {
+        CHECK_FATAL(lastInsnInfo != nullptr, "lastInsnInfo is null!");
+        OpndInfo *opndInfo = lastInsnInfo->result[0];
+        /* Don't propagate for fmov insns. */
+        if (Globals::GetInstance()->GetTarget()->IsEffectiveCopy(*insn) && (opndInfo != nullptr) && !IsFmov(*insn)) {
+          CHECK_FATAL(!opnds.empty(), "null container!");
+          opndInfo->replacementOpnd = opnds[kInsnSecondOpnd];
+          opndInfo->replacementInfo = opndInfos[kInsnSecondOpnd];
+        } else if (insn->GetBothDefUseOpnd() != kInsnMaxOpnd && (opndInfo != nullptr)) {
+          opndInfo->replacementOpnd = nullptr;
+          opndInfo->replacementInfo = nullptr;
+        }
+      }
+    }
+    insn = insn->GetNext();
+  } else {
+    uint32 opndNum = insn->GetOperandSize();
+    RemoveUses(opndNum, origInfos);
+    /* If insn is replaced, reanalyze the new insn to have more opportunities. */
+    insn = (prev == nullptr ? bb.GetFirstInsn() : prev->GetNext());
+  }
+}
+
+void Ebo::PreProcessSpecialInsn(Insn &insn) {
+  DefineReturnUseRegister(insn);
+
+  if (insn.IsCall() || insn.IsClinit()) {
+    DefineCallUseSpecialRegister(insn);
+  }
+}
+
+/*
+ * this func do :
+ * 1.build opereand info of bb;
+ * 2.do Forward propagation after regalloc;
+ * 3.simplify the insn,include Constant folding,redundant insns elimination.
+ */
+void Ebo::BuildAllInfo(BB &bb) {
+  if (EBO_DUMP) {
+    LogInfo::MapleLogger() << "===Enter BuildOperandinfo of bb:" << bb.GetId() << "===\n";
+  }
+  Insn *insn = bb.GetFirstInsn();
+  while ((insn != nullptr) && (insn != bb.GetLastInsn()->GetNext())) {
+    if (!insn->IsTargetInsn()) {
+      insn = insn->GetNext();
+      continue;
+    }
+    PreProcessSpecialInsn(*insn);
+    uint32 opndNum = insn->GetOperandSize();
+    if (!insn->IsMachineInstruction () || opndNum == 0) {
+      insn = insn->GetNext();
+      continue;
+    }
+    MapleVector<Operand*> opnds(eboAllocator.Adapter());
+    MapleVector<OpndInfo*> opndInfos(eboAllocator.Adapter());
+    MapleVector<OpndInfo*> origInfos(eboAllocator.Adapter());
+    Insn *prev = insn->GetPrev();
+    bool insnReplaced = false;
+    bool opndsConstant = true;
+    /* start : Process all the operands. */
+    for (uint32 i = 0; i < opndNum; ++i) {
+      if (!insn->OpndIsUse(i)) {
+        opnds.emplace_back(nullptr);
+        opndInfos.emplace_back(nullptr);
+        origInfos.emplace_back(nullptr);
+        continue;
+      }
+      Operand *opnd = &(insn->GetOperand(i));
+      opnds.emplace_back(opnd);
+      opndInfos.emplace_back(nullptr);
+      origInfos.emplace_back(nullptr);
+      if (IsConstantImmOrReg(*opnd)) {
+        continue;
+      }
+      OpndInfo *opndInfo = BuildOperandInfo(bb, *insn, *opnd, i, origInfos);
+      if (opndInfo == nullptr) {
+        continue;
+      }
+
+      /* Don't do propagation for special intrinsic insn. */
+      if (!insn->IsSpecialIntrinsic()) {
+        insnReplaced = ForwardPropagateOpnd(*insn, opnd, i, opndInfo, origInfos);
+      }
+      if (insnReplaced) {
+        continue;
+      }
+      opnds.at(i) = opnd;
+      opndInfos.at(i) = opndInfo;
+      if (!IsConstantImmOrReg(*opnd)) {
+        opndsConstant = false;
+      }
+    }  /* End : Process all the operands. */
+#if TARGARM32
+    Arm32Insn *currArm32Insn = static_cast<Arm32Insn*>(insn);
+    if (currArm32Insn->IsCondExecution()) {
+      Operand &rFlag = cgFunc->GetOrCreateRflag();
+      OperandInfoUse(bb, rFlag);
+    }
+#endif
+
+    if (insnReplaced) {
+      RemoveUses(opndNum, origInfos);
+      Insn *temp = insn->GetNext();
+      bb.RemoveInsn(*insn);
+      insn = temp;
+      continue;
+    }
+
+    /* simplify the insn. */
+    if (!insn->IsSpecialIntrinsic()) {
+      SimplifyInsn(*insn, insnReplaced, opndsConstant, opnds, opndInfos, origInfos);
+    }
+    FindRedundantInsns(bb, insn, prev, insnReplaced, opnds, opndInfos, origInfos);
+  }
+}
+
+/* Decrement the use counts for the actual operands of an insnInfo. */
+void Ebo::RemoveInsn(InsnInfo &info) const {
+  Insn *insn = info.insn;
+  CHECK_FATAL(insn != nullptr, "get insn in info failed in Ebo::RemoveInsn");
+  uint32 opndNum = insn->GetOperandSize();
+  OpndInfo *opndInfo = nullptr;
+  for (uint32 i = 0; i < opndNum; i++) {
+    if (!insn->OpndIsUse(i)) {
+      continue;
+    }
+    opndInfo = info.origOpnd[i];
+    if (opndInfo != nullptr) {
+      DecRef(*opndInfo);
+      Operand *opndTemp = opndInfo->opnd;
+      if (opndTemp == nullptr) {
+        continue;
+      }
+      if (opndTemp->IsMemoryAccessOperand()) {
+        MemOpndInfo *memInfo = static_cast<MemOpndInfo*>(opndInfo);
+        OpndInfo *baseInfo = memInfo->GetBaseInfo();
+        OpndInfo *offInfo = memInfo->GetOffsetInfo();
+        if (baseInfo != nullptr) {
+          DecRef(*baseInfo);
+        }
+        if (offInfo != nullptr) {
+          DecRef(*offInfo);
+        }
+      }
+    }
+  }
+#if TARGARM32
+  Arm32CGFunc *a32CGFunc = static_cast<Arm32CGFunc*>(cgFunc);
+  auto &gotInfosMap = a32CGFunc->GetGotInfosMap();
+  for (auto it = gotInfosMap.begin(); it != gotInfosMap.end();) {
+    if (it->first == insn) {
+      it = gotInfosMap.erase(it);
+    } else {
+      ++it;
+    }
+  }
+  auto &constInfosMap = a32CGFunc->GetConstInfosMap();
+  for (auto it = constInfosMap.begin(); it != constInfosMap.end();) {
+    if (it->first == insn) {
+      it = constInfosMap.erase(it);
+    } else {
+      ++it;
+    }
+  }
+#endif
+}
+
+/* Mark opnd is live between def bb and into bb. */
+void Ebo::MarkOpndLiveIntoBB(const Operand &opnd, BB &into, BB &def) const {
+  if (live == nullptr) {
+    return;
+  }
+  if (&into == &def) {
+    return;
+  }
+  CHECK_FATAL(opnd.IsRegister(), "expect register here.");
+  const RegOperand &reg = static_cast<const RegOperand&>(opnd);
+  into.SetLiveInBit(reg.GetRegisterNumber());
+  def.SetLiveOutBit(reg.GetRegisterNumber());
+}
+
+/* return insn information if has insnInfo,else,return lastInsnInfo */
+InsnInfo *Ebo::LocateInsnInfo(const OpndInfo &info) const {
+  if (info.insn != nullptr) {
+    if (info.insnInfo != nullptr) {
+      return info.insnInfo;
+    } else {
+      InsnInfo *insnInfo = lastInsnInfo;
+      int32 limit = 50;
+      for (; (insnInfo != nullptr) && (limit != 0); insnInfo = insnInfo->prev, limit--) {
+        if (insnInfo->insn == info.insn) {
+          return insnInfo;
+        }
+      }
+    }
+  }
+  return nullptr;
+}
+
+/* redundant insns elimination */
+void Ebo::RemoveUnusedInsns(BB &bb, bool normal) {
+  OpndInfo *opndInfo = nullptr;
+  Operand *opnd = nullptr;
+
+  if (firstInsnInfo == nullptr) {
+    return;
+  }
+
+  for (InsnInfo *insnInfo = lastInsnInfo; insnInfo != nullptr; insnInfo = insnInfo->prev) {
+    Insn *insn = insnInfo->insn;
+    if ((insn == nullptr) || (insn->GetBB() == nullptr)) {
+      continue;
+    }
+    /* stop looking for insn when it goes out of bb. */
+    if (insn->GetBB() != &bb) {
+      break;
+    }
+
+    uint32 resNum = insn->GetDefRegs().size();
+    if (IsLastAndBranch(bb, *insn)) {
+      goto insn_is_needed;
+    }
+
+    if (insn->IsClinit()) {
+      goto insn_is_needed;
+    }
+
+    if ((resNum == 0) || IsGlobalNeeded(*insn) || insn->IsStore() ||
+        IsDecoupleStaticOp(*insn) || insn->GetBothDefUseOpnd() != kInsnMaxOpnd) {
+      goto insn_is_needed;
+    }
+
+    /* last insn of a 64x1 function is a float, 64x1 function may not be a float */
+    if (cgFunc->GetFunction().GetAttr(FUNCATTR_oneelem_simd) &&
+        insnInfo == lastInsnInfo) {
+      goto insn_is_needed;
+    }
+
+    if (insn->GetMachineOpcode() == MOP_asm || insn->IsAtomic()) {
+      goto insn_is_needed;
+    }
+
+    /* Check all result that can be removed. */
+    for (uint32 i = 0; i < resNum; ++i) {
+      opndInfo = insnInfo->result[i];
+      /* A couple of checks. */
+      if (opndInfo == nullptr) {
+        continue;
+      }
+      if ((opndInfo->bb != &bb) || (opndInfo->insn == nullptr)) {
+        goto insn_is_needed;
+      }
+      opnd = opndInfo->opnd;
+      if (opnd == GetZeroOpnd(opnd->GetSize())) {
+        continue;
+      }
+/* this part optimize some spacial case after RA. */
+      if (!beforeRegAlloc && Globals::GetInstance()->GetTarget()->IsEffectiveCopy(*insn) && opndInfo  &&
+          insn->GetOperand(kInsnSecondOpnd).IsImmediate() && IsSameRedefine(bb, *insn, *opndInfo)) {
+        goto can_be_removed;
+      }
+      /* end special case optimize */
+      if ((beforeRegAlloc && IsPhysicalReg(*opnd)) || (IsSaveReg(*opnd) && !opndInfo->redefinedInBB)) {
+        goto insn_is_needed;
+      }
+      /* Copies to and from the same register are not needed. */
+      if (Globals::GetInstance()->GetTarget()->IsEffectiveCopy(*insn)) {
+        if (HasAssignedReg(*opnd) && HasAssignedReg(insn->GetOperand(kInsnSecondOpnd)) &&
+            RegistersIdentical(*opnd, insn->GetOperand(kInsnSecondOpnd))) {
+          /* We may be able to get rid of the copy, but be sure that the operand is marked live into this block. */
+          if ((insnInfo->origOpnd[kInsnSecondOpnd] != nullptr) && (&bb != insnInfo->origOpnd[kInsnSecondOpnd]->bb)) {
+            MarkOpndLiveIntoBB(*opnd, bb, *insnInfo->origOpnd[kInsnSecondOpnd]->bb);
+          }
+          /* propagate use count for this opnd to it's input operand. */
+          if (opndInfo->same != nullptr) {
+            opndInfo->same->refCount += opndInfo->refCount;
+          }
+
+          /* remove the copy causes the previous def to reach the end of the block. */
+          if (!opndInfo->redefined && (opndInfo->same != nullptr)) {
+            opndInfo->same->redefined = false;
+            opndInfo->same->redefinedInBB = false;
+          }
+          goto can_be_removed;
+        }
+      }
+      /* there must bo no direct references to the operand. */
+      if (!normal || (opndInfo->refCount != 0)) {
+        goto insn_is_needed;
+      }
+      /*
+       * When O1, the vreg who live out of bb should be recognized.
+       * The regs for clinit is also be marked to recognize it can't be deleted. so extend it to O2.
+       */
+      if (opnd->IsRegister()) {
+        RegOperand *reg = static_cast<RegOperand*>(opnd);
+        if (beforeRegAlloc && !reg->IsBBLocalVReg()) {
+          goto insn_is_needed;
+        }
+      }
+      /* Volatile || sideeffect */
+      if (opndInfo->insn->IsVolatile() || opndInfo->insn->HasSideEffects()) {
+        goto insn_is_needed;
+      }
+
+      if (!opndInfo->redefinedInBB && LiveOutOfBB(*opnd, *opndInfo->bb)) {
+        goto insn_is_needed;
+      }
+
+      if (opndInfo->redefinedInBB && opndInfo->redefinedInsn != nullptr &&
+          opndInfo->redefinedInsn->GetBothDefUseOpnd() != kInsnMaxOpnd) {
+        goto insn_is_needed;
+      }
+    }
+
+    if (!normal || insnInfo->mustNotBeRemoved || insn->GetDoNotRemove()) {
+      goto insn_is_needed;
+    }
+can_be_removed:
+    if (EBO_DUMP) {
+      LogInfo::MapleLogger() << "< ==== Remove Unused insn in bb:" << bb.GetId() << "====\n";
+      insn->Dump();
+    }
+    RemoveInsn(*insnInfo);
+    bb.RemoveInsn(*insn);
+    insnInfo->insn = nullptr;
+    insnInfo->bb = nullptr;
+    for (uint32 i = 0; i < resNum; i++) {
+      opndInfo = insnInfo->result[i];
+      if (opndInfo == nullptr) {
+        continue;
+      }
+      if (opndInfo->redefined && (opndInfo->same != nullptr)) {
+        OpndInfo *next = opndInfo->same;
+        next->redefined = true;
+        if (opndInfo->redefinedInBB && (opndInfo->same->bb == &bb)) {
+          next->redefinedInBB = true;
+        }
+      }
+      if (!opndInfo->redefinedInBB && (opndInfo->same != nullptr) && (opndInfo->same->bb == &bb)) {
+        opndInfo->same->redefinedInBB = false;
+      }
+      if (!opndInfo->redefined && (opndInfo->same != nullptr)) {
+        opndInfo->same->redefined = false;
+        opndInfo->same->redefinedInBB = false;
+      }
+    }
+    optSuccess = true;
+    continue;
+insn_is_needed:
+    if (!bb.GetEhSuccs().empty()) {
+      for (uint32 i = 0; i < resNum; i++) {
+        opndInfo = insnInfo->result[i];
+        if ((opndInfo != nullptr) && (opndInfo->opnd != nullptr) && (opndInfo->same != nullptr)) {
+          UpdateNextInfo(*opndInfo);
+        }
+      }
+    }
+
+    if (!bb.GetEhPreds().empty()) {
+      for (uint32 i = 0; i < insn->GetOperandSize(); ++i) {
+        opndInfo = insnInfo->origOpnd[i];
+        if ((opndInfo != nullptr) && (opndInfo->opnd != nullptr) && (opndInfo->same != nullptr)) {
+          UpdateNextInfo(*opndInfo);
+        }
+        if ((opndInfo != nullptr) && opndInfo->opnd && (&bb != opndInfo->bb) && opndInfo->opnd->IsRegister()) {
+          MarkOpndLiveIntoBB(*opndInfo->opnd, bb, *opndInfo->bb);
+        }
+      }
+    }
+  } /* end proccess insnInfo in currBB */
+}
+
+void Ebo::UpdateNextInfo(const OpndInfo &opndInfo) {
+  OpndInfo *nextInfo = opndInfo.same;
+  while (nextInfo != nullptr) {
+    if (nextInfo->insn != nullptr) {
+      InsnInfo *info = LocateInsnInfo(*nextInfo);
+      if (info != nullptr) {
+        info->mustNotBeRemoved = true;
+      } else {
+        /*
+         * Couldn't find the insnInfo entry.  Make sure that the operand has
+         * a use count so that the defining insn will not be deleted.
+         */
+        nextInfo->refCount += opndInfo.refCount;
+      }
+    }
+    nextInfo = nextInfo->same;
+  }
+}
+
+/* back up to last saved OpndInfo */
+void Ebo::BackupOpndInfoList(OpndInfo *saveLast) {
+  if (lastOpndInfo == saveLast) {
+    return;
+  }
+  OpndInfo *opndInfo = lastOpndInfo;
+  while (opndInfo != saveLast) {
+    int32 hashVal = 0;
+    if (opndInfo->opnd->IsRegister() || opndInfo->opnd->IsRegShift()) {
+      hashVal = -1;
+    } else {
+      hashVal = opndInfo->hashVal;
+    }
+    UpdateOpndInfo(*opndInfo->opnd, *opndInfo, opndInfo->same, hashVal);
+    opndInfo = opndInfo->prev;
+  }
+  if (saveLast != nullptr) {
+    saveLast->next = nullptr;
+    lastOpndInfo = saveLast;
+  } else {
+    firstOpndInfo = nullptr;
+    lastOpndInfo = nullptr;
+  }
+}
+
+/* back up to last saved insn */
+void Ebo::BackupInsnInfoList(InsnInfo *saveLast) {
+  if (lastInsnInfo == saveLast) {
+    return;
+  }
+  InsnInfo *insnInfo = lastInsnInfo;
+  while (insnInfo != saveLast) {
+    SetInsnInfo(insnInfo->hashIndex, *(insnInfo->same));
+    insnInfo = insnInfo->prev;
+  }
+  if (saveLast != nullptr) {
+    saveLast->next = nullptr;
+    lastInsnInfo = saveLast;
+  } else {
+    firstInsnInfo = nullptr;
+    lastInsnInfo = nullptr;
+  }
+}
+
+/* add bb to eb ,and build operandinfo of bb */
+void Ebo::AddBB2EB(BB &bb) {
+  OpndInfo *saveLastOpndInfo = lastOpndInfo;
+  InsnInfo *saveLastInsnInfo = lastInsnInfo;
+  SetBBVisited(bb);
+  bbNum++;
+  BuildAllInfo(bb);
+  /* Stop adding BB to EB if the bbs in the current EB exceeds kEboMaxBBNums */
+  if (bbNum < kEboMaxBBNums) {
+    for (auto *bbSucc : bb.GetSuccs()) {
+      if ((bbSucc->GetPreds().size() == 1) && IsNotVisited(*bbSucc)) {
+        AddBB2EB(*bbSucc);
+      }
+    }
+  }
+
+  RemoveUnusedInsns(bb, true);
+  /* Remove information about Operand's and Insn's in this block. */
+  BackupOpndInfoList(saveLastOpndInfo);
+  BackupInsnInfoList(saveLastInsnInfo);
+  bbNum--;
+}
+
+/* Perform EBO */
+void Ebo::EboProcess() {
+  FOR_ALL_BB(bb, cgFunc) {
+    if (IsNotVisited(*bb)) {
+      bbNum = 0;
+      AddBB2EB(*bb);
+    }
+  }
+}
+
+/* Perform EBO on O1 which the optimization can only be in a single block. */
+void Ebo::EboProcessSingleBB() {
+  FOR_ALL_BB(bb, cgFunc) {
+    OpndInfo *saveLastOpndInfo = lastOpndInfo;
+    InsnInfo *saveLastInsnInfo = lastInsnInfo;
+    BuildAllInfo(*bb);
+    RemoveUnusedInsns(*bb, true);
+    /* Remove information about Operand's and Insn's in this block. */
+    BackupOpndInfoList(saveLastOpndInfo);
+    BackupInsnInfoList(saveLastInsnInfo);
+  }
+}
+
+void Ebo::EboInit() {
+  visitedBBs.resize(cgFunc->NumBBs());
+  for (uint32 i = 0; i < cgFunc->NumBBs(); ++i) {
+    visitedBBs[i] = false;
+  }
+  exprInfoTable.resize(kEboMaxOpndHash);
+  for (uint32 i = 0; i < kEboMaxOpndHash; ++i) {
+    exprInfoTable.at(i) = nullptr;
+  }
+  insnInfoTable.resize(kEboMaxInsnHash);
+  for (uint32 i = 0; i < kEboMaxInsnHash; ++i) {
+    insnInfoTable.at(i) = nullptr;
+  }
+  if (!beforeRegAlloc) {
+    BuildCallerSaveRegisters();
+  }
+  optSuccess = false;
+}
+
+/* perform EB optimizations right after instruction selection. */
+void Ebo::Run() {
+  EboInit();
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel2) {
+    EboProcess();
+  } else {
+    EboProcessSingleBB(); /* Perform SingleBB Optimization when -O1. */
+  }
+  if (optSuccess && cgFunc->GetMirModule().IsCModule()) {
+    Run();
+  }
+}
+
+/* === new pm === */
+bool CgEbo0::PhaseRun(maplebe::CGFunc &f) {
+  if (EBO_DUMP_NEWPM) {
+    DotGenerator::GenerateDot("ebo0", f, f.GetMirModule());
+  }
+  LiveAnalysis *live = GET_ANALYSIS(CgLiveAnalysis, f);
+  MemPool *eboMp = GetPhaseMemPool();
+  Ebo *ebo = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  ebo = eboMp->New<AArch64Ebo>(f, *eboMp, live, true, PhaseName());
+#endif
+#if TARGARM32
+  ebo = eboMp->New<Arm32Ebo>(f, *eboMp, live, true, "ebo0");
+#endif
+  ebo->Run();
+  /* the live range info may changed, so invalid the info. */
+  if (live != nullptr) {
+    live->ClearInOutDataInfo();
+  }
+  return true;
+}
+
+void CgEbo0::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.AddPreserved<CgLoopAnalysis>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgEbo0, ebo)
+
+bool CgEbo1::PhaseRun(maplebe::CGFunc &f) {
+  if (EBO_DUMP_NEWPM) {
+    DotGenerator::GenerateDot(PhaseName(), f, f.GetMirModule(), true);
+  }
+  LiveAnalysis *live = GET_ANALYSIS(CgLiveAnalysis, f);
+  MemPool *eboMp = GetPhaseMemPool();
+  Ebo *ebo = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  ebo = eboMp->New<AArch64Ebo>(f, *eboMp, live, true, PhaseName());
+#endif
+#if TARGARM32
+  ebo = eboMp->New<Arm32Ebo>(f, *eboMp, live, true, PhaseName());
+#endif
+  ebo->Run();
+  /* the live range info may changed, so invalid the info. */
+  if (live != nullptr) {
+    live->ClearInOutDataInfo();
+  }
+  return true;
+}
+
+void CgEbo1::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.AddPreserved<CgLoopAnalysis>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgEbo1, ebo1)
+
+bool CgPostEbo::PhaseRun(maplebe::CGFunc &f) {
+  if (EBO_DUMP_NEWPM) {
+    DotGenerator::GenerateDot(PhaseName(), f, f.GetMirModule());
+  }
+  LiveAnalysis *live = GET_ANALYSIS(CgLiveAnalysis, f);
+  MemPool *eboMp = GetPhaseMemPool();
+  Ebo *ebo = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  ebo = eboMp->New<AArch64Ebo>(f, *eboMp, live, false, PhaseName());
+#endif
+#if TARGARM32
+  ebo = eboMp->New<Arm32Ebo>(f, *eboMp, live, false, PhaseName());
+#endif
+  ebo->Run();
+  /* the live range info may changed, so invalid the info. */
+  if (live != nullptr) {
+    live->ClearInOutDataInfo();
+  }
+  return true;
+}
+
+void CgPostEbo::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.AddPreserved<CgLoopAnalysis>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPostEbo, postebo)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/eh_func.cpp b/src/mapleall/maple_be/src/cg/eh_func.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d761e65c26e8aba3d5c39eea883a2c4091447768
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/eh_func.cpp
@@ -0,0 +1,739 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "eh_func.h"
+#include "cgfunc.h"
+#include "cg.h"
+#include "mir_builder.h"
+#include "switch_lowerer.h"
+
+namespace maplebe {
+using namespace maple;
+
+void EHFunc::CollectEHInformation(std::vector<std::pair<LabelIdx, CatchNode*>> &catchVec) {
+  MIRFunction &mirFunc = cgFunc->GetFunction();
+  MIRModule *mirModule = mirFunc.GetModule();
+  CHECK_FATAL(mirModule != nullptr, "mirModule is nullptr in CGFunc::BuildEHFunc");
+  BlockNode *blkNode = mirFunc.GetBody();
+  CHECK_FATAL(blkNode != nullptr, "current function body is nullptr in CGFunc::BuildEHFunc");
+  EHTry *lastTry = nullptr;  /* record last try */
+  /*
+   * curTry: record the current try wrapping the current statement,
+   *         reset to null when meet a endtry
+   */
+  EHTry *curTry = nullptr;
+  StmtNode *nextStmt = nullptr;
+
+  /* collect all try-catch blocks */
+  for (StmtNode *stmt = blkNode->GetFirst(); stmt != nullptr; stmt = nextStmt) {
+    nextStmt = stmt->GetNext();
+    Opcode op = stmt->GetOpCode();
+    switch (op) {
+      case OP_try: {
+        TryNode *tryNode = static_cast<TryNode*>(stmt);
+        EHTry *ehTry = cgFunc->GetMemoryPool()->New<EHTry>(*(cgFunc->GetFuncScopeAllocator()), *tryNode);
+        lastTry = ehTry;
+        curTry = ehTry;
+        AddTry(*ehTry);
+        break;
+      }
+      case OP_endtry: {
+        ASSERT(lastTry != nullptr, "lastTry is nullptr when current node is endtry");
+        lastTry->SetEndtryNode(*stmt);
+        lastTry = nullptr;
+        curTry = nullptr;
+        break;
+      }
+      case OP_catch: {
+        CatchNode *catchNode = static_cast<CatchNode*>(stmt);
+        ASSERT(stmt->GetPrev()->GetOpCode() == OP_label, "catch's previous node is not a label");
+        LabelNode *labelStmt = static_cast<LabelNode*>(stmt->GetPrev());
+        catchVec.emplace_back(std::pair<LabelIdx, CatchNode*>(labelStmt->GetLabelIdx(), catchNode));
+        /* rename the type of <*void> to <*Throwable> */
+        for (uint32 i = 0; i < catchNode->Size(); i++) {
+          MIRType *ehType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchNode->GetExceptionTyIdxVecElement(i));
+          ASSERT(ehType->GetKind() == kTypePointer, "ehType must be kTypePointer.");
+          MIRPtrType *ehPointedTy = static_cast<MIRPtrType*>(ehType);
+          if (ehPointedTy->GetPointedTyIdx() == static_cast<TyIdx>(PTY_void)) {
+            ASSERT(mirModule->GetThrowableTyIdx() != 0, "throwable type id is 0");
+            const MIRType *throwType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirModule->GetThrowableTyIdx());
+            MIRType *pointerType = cgFunc->GetBecommon().BeGetOrCreatePointerType(*throwType);
+            catchNode->SetExceptionTyIdxVecElement(pointerType->GetTypeIndex(), i);
+          }
+        }
+        break;
+      }
+      case OP_throw: {
+        if (!cgFunc->GetCG()->GetCGOptions().GenerateExceptionHandlingCode() ||
+            (cgFunc->GetCG()->IsExclusiveEH() && cgFunc->GetCG()->IsExclusiveFunc(mirFunc))) {
+          /* remove the statment */
+          BlockNode *bodyNode = mirFunc.GetBody();
+          bodyNode->RemoveStmt(stmt);
+          break;
+        }
+        UnaryStmtNode *throwNode = static_cast<UnaryStmtNode*>(stmt);
+        EHThrow *ehReThrow = cgFunc->GetMemoryPool()->New<EHThrow>(*throwNode);
+        ehReThrow->SetJavaTry(curTry);
+        AddRethrow(*ehReThrow);
+        break;
+      }
+      case OP_block:
+        CHECK_FATAL(false, "should've lowered earlier");
+      default:
+        break;
+    }
+  }
+}
+
+void EHTry::DumpEHTry(const MIRModule &mirModule [[maybe_unused]]) {
+  if (tryNode != nullptr) {
+    tryNode->Dump();
+  }
+
+  if (endTryNode != nullptr) {
+    endTryNode->Dump();
+  }
+
+  for (const auto *currCatch : catchVec) {
+    if (currCatch == nullptr) {
+      continue;
+    }
+    currCatch->Dump();
+  }
+}
+
+void EHThrow::ConvertThrowToRuntime(CGFunc &cgFunc, BaseNode &arg) const {
+  MIRFunction &mirFunc = cgFunc.GetFunction();
+  MIRModule *mirModule = mirFunc.GetModule();
+  MIRFunction *calleeFunc = mirModule->GetMIRBuilder()->GetOrCreateFunction(
+      "MCC_ThrowException", static_cast<TyIdx>(PTY_void));
+  cgFunc.GetBecommon().UpdateTypeTable(*calleeFunc->GetMIRFuncType());
+  calleeFunc->SetNoReturn();
+  MapleVector<BaseNode*> args(mirModule->GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.emplace_back(&arg);
+  CallNode *callAssign = mirModule->GetMIRBuilder()->CreateStmtCall(calleeFunc->GetPuidx(), args);
+  mirFunc.GetBody()->ReplaceStmt1WithStmt2(rethrow, callAssign);
+}
+
+void EHThrow::ConvertThrowToRethrow(CGFunc &cgFunc) const {
+  MIRFunction &mirFunc = cgFunc.GetFunction();
+  MIRModule *mirModule = mirFunc.GetModule();
+  MIRBuilder *mirBuilder = mirModule->GetMIRBuilder();
+  MIRFunction *unFunc = mirBuilder->GetOrCreateFunction("MCC_RethrowException", static_cast<TyIdx>(PTY_void));
+  cgFunc.GetBecommon().UpdateTypeTable(*unFunc->GetMIRFuncType());
+  unFunc->SetNoReturn();
+  MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.emplace_back(rethrow->Opnd(0));
+  CallNode *callNode = mirBuilder->CreateStmtCall(unFunc->GetPuidx(), args);
+  mirFunc.GetBody()->ReplaceStmt1WithStmt2(rethrow, callNode);
+}
+
+void EHThrow::Lower(CGFunc &cgFunc) {
+  BaseNode *opnd0 = rethrow->Opnd(0);
+  ASSERT(((opnd0->GetPrimType() == GetLoweredPtrType()) || (opnd0->GetPrimType() == PTY_ref)),
+         "except a dread of a pointer to get its type");
+  MIRFunction &mirFunc = cgFunc.GetFunction();
+  MIRModule *mirModule = mirFunc.GetModule();
+  MIRBuilder *mirBuilder = mirModule->GetMIRBuilder();
+  ASSERT(mirBuilder != nullptr, "get mirBuilder failed in EHThrow::Lower");
+  MIRSymbol *mirSymbol = nullptr;
+  BaseNode *arg = nullptr;
+  MIRType *pstType = nullptr;
+  switch (opnd0->GetOpCode()) {
+    case OP_dread: {
+      DreadNode *drNode = static_cast<DreadNode*>(opnd0);
+      mirSymbol = mirFunc.GetLocalOrGlobalSymbol(drNode->GetStIdx());
+      ASSERT(mirSymbol != nullptr, "get symbol failed in EHThrow::Lower");
+      pstType = mirSymbol->GetType();
+      arg = drNode->CloneTree(mirModule->GetCurFuncCodeMPAllocator());
+      break;
+    }
+    case OP_iread: {
+      IreadNode *irNode = static_cast<IreadNode*>(opnd0);
+      MIRPtrType *pointerTy =
+          static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(irNode->GetTyIdx()));
+      if (irNode->GetFieldID() != 0) {
+        MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerTy->GetPointedTyIdx());
+        MIRStructType *structTy = nullptr;
+        if (pointedTy->GetKind() != kTypeJArray) {
+          structTy = static_cast<MIRStructType*>(pointedTy);
+        } else {
+          /* it's a Jarray type. using it's parent's field info: java.lang.Object */
+          structTy = static_cast<MIRJarrayType*>(pointedTy)->GetParentType();
+        }
+        ASSERT(structTy != nullptr, "structTy is nullptr in EHThrow::Lower ");
+        pstType = structTy->GetFieldType(irNode->GetFieldID());
+      } else {
+        pstType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerTy->GetPointedTyIdx());
+      }
+      arg = irNode->CloneTree(mirModule->GetCurFuncCodeMPAllocator());
+      break;
+    }
+    case OP_regread: {
+      RegreadNode *rrNode = static_cast<RegreadNode*>(opnd0);
+      MIRPreg *pReg = mirFunc.GetPregTab()->PregFromPregIdx(rrNode->GetRegIdx());
+      ASSERT(pReg->GetPrimType() == GetLoweredPtrType(), "must be a pointer type");
+      pstType = pReg->GetMIRType();
+      arg = rrNode->CloneTree(mirModule->GetCurFuncCodeMPAllocator());
+      break;
+    }
+    case OP_retype: {
+      RetypeNode *retypeNode = static_cast<RetypeNode*>(opnd0);
+      pstType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retypeNode->GetTyIdx());
+      arg = retypeNode->CloneTree(mirModule->GetCurFuncCodeMPAllocator());
+      break;
+    }
+    case OP_cvt: {
+      TypeCvtNode *cvtNode = static_cast<TypeCvtNode*>(opnd0);
+      PrimType prmType = cvtNode->GetPrimType();
+      // prmType supposed to be Pointer.
+      if ((prmType == PTY_ptr) || (prmType == PTY_ref) || (prmType == PTY_a32) || (prmType == PTY_a64)) {
+        ConvertThrowToRethrow(cgFunc);
+      }
+      return;
+    }
+    default:
+      ASSERT(false, " NYI throw something");
+  }
+  CHECK_FATAL(pstType != nullptr, "pstType is null in EHThrow::Lower");
+  if (pstType->GetKind() != kTypePointer) {
+    LogInfo::MapleLogger() << "Error in function " << mirFunc.GetName() << "\n";
+    rethrow->Dump();
+    LogInfo::MapleLogger() << "pstType is supposed to be Pointer, but is not";
+    pstType->Dump(0);
+    CHECK_FATAL(false, "throw operand type kind must be kTypePointer");
+  }
+
+  MIRType *stType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<MIRPtrType*>(pstType)->GetPointedTyIdx());
+  if (!IsUnderTry()) {
+    /*
+     * in this case the throw happens without a try...endtry wrapping it, need to generate lsda.
+     * insert 2 labels before and after throw
+     */
+    LabelNode *throwBeginLbl = mirBuilder->CreateStmtLabel(mirBuilder->CreateLabIdx(mirFunc));
+    LabelNode *throwEndLbl = mirBuilder->CreateStmtLabel(mirBuilder->CreateLabIdx(mirFunc));
+    BlockNode *bodyNode = mirFunc.GetBody();
+    bodyNode->InsertBefore(rethrow, throwBeginLbl);
+    bodyNode->InsertAfter(rethrow, throwEndLbl);
+    startLabel = throwBeginLbl;
+    endLabel = throwEndLbl;
+  }
+
+  if (stType->GetKind() == kTypeClass) {
+    ConvertThrowToRuntime(cgFunc, *arg);
+  } else {
+    ConvertThrowToRethrow(cgFunc);
+  }
+}
+
+EHFunc::EHFunc(CGFunc &func)
+    : cgFunc(&func),
+      tryVec(func.GetFuncScopeAllocator()->Adapter()),
+      ehTyTable(func.GetFuncScopeAllocator()->Adapter()),
+      ty2IndexTable(std::less<TyIdx>(), func.GetFuncScopeAllocator()->Adapter()),
+      rethrowVec(func.GetFuncScopeAllocator()->Adapter()) {}
+
+EHFunc *CGFunc::BuildEHFunc() {
+  EHFunc *newEHFunc = GetMemoryPool()->New<EHFunc>(*this);
+  SetEHFunc(*newEHFunc);
+  std::vector<std::pair<LabelIdx, CatchNode*>> catchVec;
+  newEHFunc->CollectEHInformation(catchVec);
+  newEHFunc->MergeCatchToTry(catchVec);
+  newEHFunc->BuildEHTypeTable(catchVec);
+  newEHFunc->InsertEHSwitchTable();
+  newEHFunc->InsertCxaAfterEachCatch(catchVec);
+  newEHFunc->GenerateCleanupLabel();
+
+  GetBecommon().BeGetOrCreatePointerType(*GlobalTables::GetTypeTable().GetVoid());
+  if (newEHFunc->NeedFullLSDA()) {
+    newEHFunc->CreateLSDA();
+  } else if (newEHFunc->HasThrow()) {
+    newEHFunc->LowerThrow();
+  }
+  if (GetCG()->GetCGOptions().GenerateExceptionHandlingCode()) {
+    newEHFunc->CreateTypeInfoSt();
+  }
+
+  return newEHFunc;
+}
+
+bool EHFunc::NeedFullLSDA() const {
+  if (cgFunc->GetFunction().IsJava()) {
+    return HasTry();
+  } else {
+    return false;
+  }
+}
+
+bool EHFunc::NeedFastLSDA() const {
+  if (cgFunc->GetFunction().IsJava()) {
+    return !HasTry();
+  } else {
+    return false;
+  }
+}
+
+bool EHFunc::HasTry() const {
+  return !tryVec.empty();
+}
+
+void EHFunc::CreateTypeInfoSt() const {
+  MIRFunction &mirFunc = cgFunc->GetFunction();
+  bool ctorDefined = false;
+  if (mirFunc.GetAttr(FUNCATTR_constructor) && !mirFunc.GetAttr(FUNCATTR_static) && (mirFunc.GetBody() != nullptr)) {
+    ctorDefined = true;
+  }
+
+  if (!ctorDefined) {
+    return;
+  }
+
+  const auto *classType = static_cast<const MIRClassType*>(mirFunc.GetClassType());
+  if (cgFunc->GetMirModule().IsCModule() && classType == nullptr) {
+    return;
+  }
+  ASSERT(classType != nullptr, "");
+  if (classType->GetMethods().empty() && (classType->GetFieldsSize() == 0)) {
+    return;
+  }
+
+  if (classType->GetExceptionRootType() == nullptr) {
+    return;  /* not a exception type */
+  }
+}
+
+void EHFunc::LowerThrow() {
+  MIRFunction &mirFunc = cgFunc->GetFunction();
+  /* just lower without building LSDA */
+  for (EHThrow *rethrow : rethrowVec) {
+    BaseNode *opnd0 = rethrow->GetRethrow()->Opnd(0);
+    /* except a dread of a point to get its type */
+    switch (opnd0->GetOpCode()) {
+      case OP_retype: {
+        RetypeNode *retypeNode = static_cast<RetypeNode*>(opnd0);
+        ASSERT(GlobalTables::GetTypeTable().GetTypeFromTyIdx(retypeNode->GetTyIdx())->GetKind() == kTypePointer,
+               "expecting a pointer type");
+        rethrow->ConvertThrowToRuntime(*cgFunc, *retypeNode->CloneTree(
+            mirFunc.GetModule()->GetCurFuncCodeMPAllocator()));
+        break;
+      }
+      case OP_dread: {
+        DreadNode *drNode = static_cast<DreadNode*>(opnd0);
+        ASSERT(mirFunc.GetLocalOrGlobalSymbol(drNode->GetStIdx())->GetType()->GetKind() == kTypePointer,
+               "expect pointer type");
+        rethrow->ConvertThrowToRuntime(*cgFunc, *drNode->CloneTree(
+            mirFunc.GetModule()->GetCurFuncCodeMPAllocator()));
+        break;
+      }
+      case OP_iread: {
+        IreadNode *irNode = static_cast<IreadNode*>(opnd0);
+        MIRPtrType *receiverPtrType = nullptr;
+        if (irNode->GetFieldID() != 0) {
+          MIRPtrType *pointerTy =
+              static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(irNode->GetTyIdx()));
+          MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerTy->GetPointedTyIdx());
+          MIRStructType *structTy = nullptr;
+          if (pointedTy->GetKind() != kTypeJArray) {
+            structTy = static_cast<MIRStructType*>(pointedTy);
+          } else {
+            /* it's a Jarray type. using it's parent's field info: java.lang.Object */
+            structTy = static_cast<MIRJarrayType*>(pointedTy)->GetParentType();
+          }
+          ASSERT(structTy != nullptr, "structTy is nullptr in EHFunc::LowerThrow");
+          receiverPtrType =
+              static_cast<MIRPtrType*>(structTy->GetFieldType(irNode->GetFieldID()));
+        } else {
+          receiverPtrType =
+              static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(irNode->GetTyIdx()));
+          receiverPtrType = static_cast<MIRPtrType*>(
+              GlobalTables::GetTypeTable().GetTypeFromTyIdx(receiverPtrType->GetPointedTyIdx()));
+        }
+        ASSERT(receiverPtrType->GetKind() == kTypePointer, "expecting a pointer type");
+        rethrow->ConvertThrowToRuntime(*cgFunc, *irNode->CloneTree(
+            mirFunc.GetModule()->GetCurFuncCodeMPAllocator()));
+        break;
+      }
+      case OP_regread: {
+        RegreadNode *rrNode = static_cast<RegreadNode*>(opnd0);
+        ASSERT(mirFunc.GetPregTab()->PregFromPregIdx(rrNode->GetRegIdx())->GetPrimType() == GetLoweredPtrType(),
+               "expect GetLoweredPtrType()");
+        ASSERT(mirFunc.GetPregTab()->PregFromPregIdx(rrNode->GetRegIdx())->GetMIRType()->GetKind() == kTypePointer,
+               "expect pointer type");
+        rethrow->ConvertThrowToRuntime(*cgFunc, *rrNode->CloneTree(
+            mirFunc.GetModule()->GetCurFuncCodeMPAllocator()));
+        break;
+      }
+      case OP_constval: {
+        ConstvalNode *constValNode = static_cast<ConstvalNode*>(opnd0);
+        BaseNode *newNode = constValNode->CloneTree(mirFunc.GetModule()->GetCurFuncCodeMPAllocator());
+        ASSERT(newNode != nullptr, "nullptr check");
+        rethrow->ConvertThrowToRuntime(*cgFunc, *newNode);
+        break;
+      }
+      case OP_cvt: {
+        TypeCvtNode *cvtNode = static_cast<TypeCvtNode*>(opnd0);
+        PrimType prmType = cvtNode->GetPrimType();
+        // prmType supposed to be Pointer.
+        if ((prmType == PTY_ptr) || (prmType == PTY_ref) || (prmType == PTY_a32) || (prmType == PTY_a64)) {
+          BaseNode *newNode = cvtNode->CloneTree(mirFunc.GetModule()->GetCurFuncCodeMPAllocator());
+          rethrow->ConvertThrowToRuntime(*cgFunc, *newNode);
+        }
+        break;
+      }
+      default:
+        ASSERT(false, "unexpected or NYI");
+    }
+  }
+}
+
+/*
+ * merge catch to try
+ */
+void EHFunc::MergeCatchToTry(const std::vector<std::pair<LabelIdx, CatchNode*>> &catchVec) {
+  size_t tryOffsetCount;
+  for (auto *ehTry : tryVec) {
+    tryOffsetCount = ehTry->GetTryNode()->GetOffsetsCount();
+    for (size_t i = 0; i < tryOffsetCount; i++) {
+      auto o = ehTry->GetTryNode()->GetOffset(i);
+      for (const auto &catchVecPair : catchVec) {
+        LabelIdx lbIdx = catchVecPair.first;
+        if (lbIdx == o) {
+          ehTry->PushBackCatchVec(*catchVecPair.second);
+          break;
+        }
+      }
+    }
+    CHECK_FATAL(ehTry->GetCatchVecSize() == tryOffsetCount, "EHTry instance offset does not equal catch node amount.");
+  }
+}
+
+/* catchvec is going to be released by the caller */
+void EHFunc::BuildEHTypeTable(const std::vector<std::pair<LabelIdx, CatchNode*>> &catchVec) {
+  if (!catchVec.empty()) {
+    /* the first one assume to be <*void> */
+    TyIdx voidTyIdx(PTY_void);
+    ehTyTable.emplace_back(voidTyIdx);
+    ty2IndexTable[voidTyIdx] = 0;
+    /* create void pointer and update becommon's size table */
+    cgFunc->GetBecommon().UpdateTypeTable(*GlobalTables::GetTypeTable().GetVoidPtr());
+  }
+
+  /* create the type table for this function, just iterate each catch */
+  CatchNode *jCatchNode = nullptr;
+  size_t catchNodeSize;
+  for (const auto &catchVecPair : catchVec) {
+    jCatchNode = catchVecPair.second;
+    catchNodeSize = jCatchNode->Size();
+    for (size_t i = 0; i < catchNodeSize; i++) {
+      MIRType *mirTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(jCatchNode->GetExceptionTyIdxVecElement(i));
+      ASSERT(mirTy->GetKind() == kTypePointer, "mirTy is not pointer type");
+      TyIdx ehTyIdx = static_cast<MIRPtrType*>(mirTy)->GetPointedTyIdx();
+      if (ty2IndexTable.find(ehTyIdx) != ty2IndexTable.end()) {
+        continue;
+      }
+
+      ty2IndexTable[ehTyIdx] = ehTyTable.size();
+      ehTyTable.emplace_back(ehTyIdx);
+      MIRClassType *catchType = static_cast<MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ehTyIdx));
+      MIRClassType *rootType = catchType->GetExceptionRootType();
+      if (rootType == nullptr) {
+        rootType = static_cast<MIRClassType*>(GlobalTables::GetTypeTable().GetOrCreateClassType(
+            "Ljava_2Flang_2FThrowable_3B", *GlobalTables::GetGsymTable().GetModule()));
+        catchType->SetParentTyIdx(rootType->GetTypeIndex());
+      }
+    }
+  }
+}
+
+void EHFunc::DumpEHFunc() const {
+  MIRModule &mirModule = *cgFunc->GetFunction().GetModule();
+  for (uint32 i = 0; i < this->tryVec.size(); i++) {
+    LogInfo::MapleLogger() << "\n========== start " << i << " th eh:\n";
+    EHTry *ehTry = tryVec[i];
+    ehTry->DumpEHTry(mirModule);
+    LogInfo::MapleLogger() << "========== end " << i << " th eh =========\n";
+  }
+
+  LogInfo::MapleLogger() << "\n========== start LSDA type table ========\n";
+  for (uint32 i = 0; i < this->ehTyTable.size(); i++) {
+    LogInfo::MapleLogger() << i << " vector to ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(ehTyTable[i])->Dump(0);
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "========== end LSDA type table ========\n";
+
+  LogInfo::MapleLogger() << "\n========== start type-index map ========\n";
+  for (const auto &ty2indexTablePair : ty2IndexTable) {
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(ty2indexTablePair.first)->Dump(0);
+    LogInfo::MapleLogger() << " map to ";
+    LogInfo::MapleLogger() << ty2indexTablePair.second << "\n";
+  }
+  LogInfo::MapleLogger() << "========== end type-index map ========\n";
+}
+
+/*
+ * cleanup_label is an LabelNode, and placed just before endLabel.
+ * cleanup_label is the first statement of cleanupbb.
+ * the layout of clean up code is:
+ * //return bb
+ *   ...
+ * //cleanup bb = lastbb->prev; cleanupbb->PrependBB(retbb)
+ *   cleanup_label:
+ *     ...
+ * //lastbb
+ *   endLabel:
+ *     .cfi_endproc
+ *   .Label.xx.end:
+ *     .size
+ */
+void EHFunc::GenerateCleanupLabel() {
+  MIRModule *mirModule = cgFunc->GetFunction().GetModule();
+  cgFunc->SetCleanupLabel(*mirModule->GetMIRBuilder()->CreateStmtLabel(CreateLabel(".LCLEANUP")));
+  BlockNode *blockNode = cgFunc->GetFunction().GetBody();
+  blockNode->InsertBefore(cgFunc->GetEndLabel(), cgFunc->GetCleanupLabel());
+}
+
+void EHFunc::InsertDefaultLabelAndAbortFunc(BlockNode &blkNode, SwitchNode &switchNode,
+                                            const StmtNode &beforeEndLabel) const {
+  MIRModule &mirModule = *cgFunc->GetFunction().GetModule();
+  LabelIdx dfLabIdx = cgFunc->GetFunction().GetLabelTab()->CreateLabel();
+  cgFunc->GetFunction().GetLabelTab()->AddToStringLabelMap(dfLabIdx);
+  StmtNode *dfLabStmt = mirModule.GetMIRBuilder()->CreateStmtLabel(dfLabIdx);
+  blkNode.InsertAfter(&beforeEndLabel, dfLabStmt);
+  MIRFunction *calleeFunc = mirModule.GetMIRBuilder()->GetOrCreateFunction("abort", static_cast<TyIdx>(PTY_void));
+  calleeFunc->SetAttr(FUNCATTR_noreturn);
+  cgFunc->GetBecommon().UpdateTypeTable(*calleeFunc->GetMIRFuncType());
+  MapleVector<BaseNode*> args(mirModule.GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
+  CallNode *callExit = mirModule.GetMIRBuilder()->CreateStmtCall(calleeFunc->GetPuidx(), args);
+  blkNode.InsertAfter(dfLabStmt, callExit);
+  switchNode.SetDefaultLabel(dfLabIdx);
+}
+
+void EHFunc::FillSwitchTable(SwitchNode &switchNode, const EHTry &ehTry) {
+  CatchNode *catchNode = nullptr;
+  MIRType *exceptionType = nullptr;
+  MIRPtrType *ptType = nullptr;
+  size_t catchVecSize = ehTry.GetCatchVecSize();
+  /* update switch node's cases */
+  for (size_t i = 0; i < catchVecSize; i++) {
+    catchNode = ehTry.GetCatchNodeAt(i);
+    for (size_t j = 0; j < catchNode->Size(); j++) {
+      exceptionType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchNode->GetExceptionTyIdxVecElement(j));
+      ptType = static_cast<MIRPtrType*>(exceptionType);
+      MapleMap<TyIdx, uint32>::iterator ty2IdxIt = ty2IndexTable.find(ptType->GetPointedTyIdx());
+      ASSERT(ty2IdxIt != ty2IndexTable.end(), "find tyIdx failed!");
+      uint32 tableIdx = ty2IdxIt->second;
+      LabelNode *catchLabelNode = static_cast<LabelNode*>(catchNode->GetPrev());
+      CasePair p(tableIdx, catchLabelNode->GetLabelIdx());
+      bool inserted = false;
+      for (auto x : switchNode.GetSwitchTable()) {
+        if (x == p) {
+          inserted = true;
+          break;
+        }
+      }
+      if (!inserted) {
+        switchNode.InsertCasePair(p);
+      }
+    }
+  }
+}
+
+/* this is also the landing pad code. */
+void EHFunc::InsertEHSwitchTable() {
+  MIRModule &mirModule = *cgFunc->GetFunction().GetModule();
+  BlockNode *blockNode = cgFunc->GetFunction().GetBody();
+  CHECK_FATAL(blockNode != nullptr, "get function body failed in EHThrow::InsertEHSwitchTable");
+  StmtNode *endLabelPrevNode = nullptr;
+  SwitchNode *switchNode = nullptr;
+  for (auto *ehTry : tryVec) {
+    endLabelPrevNode = cgFunc->GetEndLabel()->GetPrev();
+    /*
+     * get the next statement of the trynode. when no throw happend in try block, jump to the statement directly
+     * create a switch statement and insert after tryend;
+     */
+    switchNode = mirModule.CurFuncCodeMemPool()->New<SwitchNode>(mirModule);
+    /* create a new label as default, and if program excute here, error it */
+    InsertDefaultLabelAndAbortFunc(*blockNode, *switchNode, *endLabelPrevNode);
+    /* create s special symbol that use the second return of __builtin_eh_return() */
+    MIRSymbol *mirSymbol = mirModule.GetMIRBuilder()->CreateSymbol(TyIdx(PTY_i32), "__eh_index__", kStVar, kScAuto,
+                                                                   &cgFunc->GetFunction(), kScopeLocal);
+    switchNode->SetSwitchOpnd(mirModule.GetMIRBuilder()->CreateExprDread(*mirSymbol));
+    FillSwitchTable(*switchNode, *ehTry);
+    SwitchLowerer switchLower(mirModule, *switchNode, *cgFunc->GetFuncScopeAllocator());
+    blockNode->InsertBlockAfter(*switchLower.LowerSwitch(), endLabelPrevNode);
+    ehTry->SetFallthruGoto(endLabelPrevNode->GetNext());
+  }
+  if (!CGOptions::IsQuiet()) {
+    cgFunc->GetFunction().Dump();
+  }
+}
+
+LabelIdx EHFunc::CreateLabel(const std::string &cstr) {
+  MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(cgFunc->GetFunction().GetStIdx().Idx());
+  CHECK_FATAL(mirSymbol != nullptr, "get function symbol failed in EHFunc::CreateLabel");
+  std::string funcName = mirSymbol->GetName();
+  std::string labStr = funcName.append(cstr).append(std::to_string(labelIdx++));
+  return cgFunc->GetFunction().GetOrCreateLableIdxFromName(labStr);
+}
+
+/* think about moving this to BELowerer where LowerThrownval is already written */
+void EHFunc::InsertCxaAfterEachCatch(const std::vector<std ::pair<LabelIdx, CatchNode*>> &catchVec) const {
+  MIRModule &mirModule = *cgFunc->GetFunction().GetModule();
+  BlockNode *funcBody = cgFunc->GetFunction().GetBody();
+  CatchNode *jCatchNode = nullptr;
+  TyIdx voidPTy = GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex();
+  for (const auto &catchVecPair : catchVec) {
+    jCatchNode = catchVecPair.second;
+    MIRFunction *calleeFunc = mirModule.GetMIRBuilder()->GetOrCreateFunction("MCC_JavaBeginCatch", voidPTy);
+    cgFunc->GetBecommon().UpdateTypeTable(*calleeFunc->GetMIRFuncType());
+    RegreadNode *retRegRead0 = mirModule.CurFuncCodeMemPool()->New<RegreadNode>();
+    retRegRead0->SetRegIdx(-kSregRetval0);
+    retRegRead0->SetPrimType(GetLoweredPtrType());
+    MapleVector<BaseNode*> args(mirModule.GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
+    args.emplace_back(retRegRead0);
+    CallNode *callAssign = mirModule.GetMIRBuilder()->CreateStmtCall(calleeFunc->GetPuidx(), args);
+    funcBody->InsertAfter(jCatchNode, callAssign);
+  }
+}
+
+void EHFunc::CreateLSDAHeader() {
+  constexpr uint8 startEncoding = 0xff;
+  constexpr uint8 typeEncoding = 0x9b;
+  constexpr uint8 callSiteEncoding = 0x1;
+  MIRBuilder *mirBuilder = cgFunc->GetFunction().GetModule()->GetMIRBuilder();
+
+  LSDAHeader *lsdaHeaders = cgFunc->GetMemoryPool()->New<LSDAHeader>();
+  LabelIdx lsdaHdLblIdx = CreateLabel("LSDAHD");  /* LSDA head */
+  LabelNode *lsdaHdLblNode = mirBuilder->CreateStmtLabel(lsdaHdLblIdx);
+  lsdaHeaders->SetLSDALabel(*lsdaHdLblNode);
+
+  LabelIdx lsdaTTStartIdx = CreateLabel("LSDAALLS");  /* LSDA all start; */
+  LabelNode *lsdaTTLblNode = mirBuilder->CreateStmtLabel(lsdaTTStartIdx);
+  LabelIdx lsdaTTEndIdx = CreateLabel("LSDAALLE");  /* LSDA all end; */
+  LabelNode *lsdaCSTELblNode = mirBuilder->CreateStmtLabel(lsdaTTEndIdx);
+  lsdaHeaders->SetTTypeOffset(lsdaTTLblNode, lsdaCSTELblNode);
+
+  lsdaHeaders->SetLPStartEncoding(startEncoding);
+  lsdaHeaders->SetTTypeEncoding(typeEncoding);
+  lsdaHeaders->SetCallSiteEncoding(callSiteEncoding);
+  lsdaHeader = lsdaHeaders;
+}
+
+void EHFunc::FillLSDACallSiteTable() {
+  constexpr uint8 callSiteFirstAction = 0x1;
+  MIRBuilder *mirBuilder = cgFunc->GetFunction().GetModule()->GetMIRBuilder();
+  BlockNode *bodyNode = cgFunc->GetFunction().GetBody();
+
+  lsdaCallSiteTable = cgFunc->GetMemoryPool()->New<LSDACallSiteTable>(*cgFunc->GetFuncScopeAllocator());
+  LabelIdx lsdaCSTStartIdx = CreateLabel("LSDACSTS");  /* LSDA callsite table start; */
+  LabelNode *lsdaCSTStartLabel = mirBuilder->CreateStmtLabel(lsdaCSTStartIdx);
+  LabelIdx lsdaCSTEndIdx = CreateLabel("LSDACSTE");  /* LSDA callsite table end; */
+  LabelNode *lsdaCSTEndLabel = mirBuilder->CreateStmtLabel(lsdaCSTEndIdx);
+  lsdaCallSiteTable->SetCSTable(lsdaCSTStartLabel, lsdaCSTEndLabel);
+
+  /* create LDSACallSite for each EHTry instance */
+  for (auto *ehTry : tryVec) {
+    ASSERT(ehTry != nullptr, "null ptr check");
+    /* replace try with a label which is the callsite_start */
+    LabelIdx csStartLblIdx = CreateLabel("LSDACS");
+    LabelNode *csLblNode = mirBuilder->CreateStmtLabel(csStartLblIdx);
+    LabelIdx csEndLblIdx = CreateLabel("LSDACE");
+    LabelNode *ceLblNode = mirBuilder->CreateStmtLabel(csEndLblIdx);
+    TryNode *tryNode = ehTry->GetTryNode();
+    bodyNode->ReplaceStmt1WithStmt2(tryNode, csLblNode);
+    StmtNode *endTryNode = ehTry->GetEndtryNode();
+    bodyNode->ReplaceStmt1WithStmt2(endTryNode, ceLblNode);
+
+    LabelNode *ladpadEndLabel = nullptr;
+    if (ehTry->GetFallthruGoto()) {
+      ladpadEndLabel = mirBuilder->CreateStmtLabel(CreateLabel("LSDALPE"));
+      bodyNode->InsertBefore(ehTry->GetFallthruGoto(), ladpadEndLabel);
+    } else {
+      ladpadEndLabel = ceLblNode;
+    }
+    /* When there is only one catch, the exception table is optimized. */
+    if (ehTry->GetCatchVecSize() == 1) {
+      ladpadEndLabel = static_cast<LabelNode*>(ehTry->GetCatchNodeAt(0)->GetPrev());
+    }
+
+    LSDACallSite *lsdaCallSite = cgFunc->GetMemoryPool()->New<LSDACallSite>();
+    LabelPair csStart(cgFunc->GetStartLabel(), csLblNode);
+    LabelPair csLength(csLblNode, ceLblNode);
+    LabelPair csLandingPad(cgFunc->GetStartLabel(), ladpadEndLabel);
+    lsdaCallSite->Init(csStart, csLength, csLandingPad, callSiteFirstAction);
+    ehTry->SetLSDACallSite(*lsdaCallSite);
+    lsdaCallSiteTable->PushBack(*lsdaCallSite);
+  }
+}
+
+void EHFunc::CreateLSDA() {
+  constexpr uint8 callSiteCleanUpAction = 0x0;
+  /* create header */
+  CreateLSDAHeader();
+  /* create and fill callsite table */
+  FillLSDACallSiteTable();
+
+  for (auto *rethrow : rethrowVec) {
+    ASSERT(rethrow != nullptr, "null ptr check");
+    /* replace throw (void * obj) with call __java_rethrow and unwind resume */
+    rethrow->Lower(*cgFunc);
+    if (rethrow->HasLSDA()) {
+      LSDACallSite *lsdaCallSite = cgFunc->GetMemoryPool()->New<LSDACallSite>();
+      LabelPair csStart(cgFunc->GetStartLabel(), rethrow->GetStartLabel());
+      LabelPair csLength(rethrow->GetStartLabel(), rethrow->GetEndLabel());
+      LabelPair csLandingPad(nullptr, nullptr);
+      lsdaCallSite->Init(csStart, csLength, csLandingPad, callSiteCleanUpAction);
+      lsdaCallSiteTable->PushBack(*lsdaCallSite);
+    }
+  }
+
+  /* LSDAAction table */
+  CreateLSDAAction();
+}
+
+void EHFunc::CreateLSDAAction() {
+  constexpr uint8 actionTableNextEncoding = 0x7d;
+  /* iterate each try and its corresponding catch */
+  LSDAActionTable *actionTable = cgFunc->GetMemoryPool()->New<LSDAActionTable>(*cgFunc->GetFuncScopeAllocator());
+  lsdaActionTable = actionTable;
+
+  for (auto *ehTry : tryVec) {
+    LSDAAction *lastAction = nullptr;
+    for (int32 j = static_cast<int32>(ehTry->GetCatchVecSize()) - 1; j >= 0; --j) {
+      CatchNode *catchNode = ehTry->GetCatchNodeAt(j);
+      ASSERT(catchNode != nullptr, "null ptr check");
+      for (uint32 idx = 0; idx < catchNode->Size(); ++idx) {
+        MIRPtrType *ptType = static_cast<MIRPtrType*>(
+            GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchNode->GetExceptionTyIdxVecElement(idx)));
+        uint32 tyIndex = ty2IndexTable[ptType->GetPointedTyIdx()];  /* get the index of ptType of ehTyTable; */
+        ASSERT(tyIndex != 0, "exception type index not allow equal zero");
+        LSDAAction *lsdaAction =
+            cgFunc->GetMemoryPool()->New<LSDAAction>(tyIndex, lastAction == nullptr ? 0 : actionTableNextEncoding);
+        lastAction = lsdaAction;
+        actionTable->PushBack(*lsdaAction);
+      }
+    }
+
+    /* record actionTable group offset, per LSDAAction object in actionTable occupy 2 bytes */
+    ehTry->SetCSAction((actionTable->Size() - 1) * 2 + 1);
+  }
+}
+
+bool CgBuildEHFunc::PhaseRun(maplebe::CGFunc &f) {
+  f.BuildEHFunc();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgBuildEHFunc, buildehfunc)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/emit.cpp b/src/mapleall/maple_be/src/cg/emit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53c7a1ba050c3999790d871b17e27f9f65987b0c
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/emit.cpp
@@ -0,0 +1,3723 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "emit.h"
+#include <unistd.h>
+#ifdef _WIN32
+#include <direct.h>
+#endif
+#include "reflection_analysis.h"
+#include "muid_replacement.h"
+#include "metadata_layout.h"
+#include "string_utils.h"
+using namespace namemangler;
+
+namespace {
+using namespace maple;
+constexpr uint32 kSizeOfHugesoRoutine = 3;
+constexpr uint32 kFromDefIndexMask32Mod = 0x40000000;
+
+int32 GetPrimitiveTypeSize(const std::string &name) {
+  if (name.length() != 1) {
+    return -1;
+  }
+  char typeName = name[0];
+  switch (typeName) {
+    case 'Z':
+      return static_cast<int32>(GetPrimTypeSize(PTY_u1));
+    case 'B':
+      return static_cast<int32>(GetPrimTypeSize(PTY_i8));
+    case 'S':
+      return static_cast<int32>(GetPrimTypeSize(PTY_i16));
+    case 'C':
+      return static_cast<int32>(GetPrimTypeSize(PTY_u16));
+    case 'I':
+      return static_cast<int32>(GetPrimTypeSize(PTY_i32));
+    case 'J':
+      return static_cast<int32>(GetPrimTypeSize(PTY_i64));
+    case 'F':
+      return static_cast<int32>(GetPrimTypeSize(PTY_f32));
+    case 'D':
+      return static_cast<int32>(GetPrimTypeSize(PTY_f64));
+    case 'V':
+      return static_cast<int32>(GetPrimTypeSize(PTY_void));
+    default:
+      return -1;
+  }
+}
+DBGDieAttr *LFindAttribute(MapleVector<DBGDieAttr*> &vec, DwAt key) {
+  for (DBGDieAttr *at : vec)
+    if (at->GetDwAt() == key) {
+      return at;
+    }
+  return nullptr;
+}
+
+DBGAbbrevEntry *LFindAbbrevEntry(MapleVector<DBGAbbrevEntry*> &abbvec, unsigned int key) {
+  for (DBGAbbrevEntry *daie : abbvec) {
+    if (!daie) {
+      continue;
+    }
+    if (daie->GetAbbrevId() == key) {
+      return daie;
+    }
+  }
+  ASSERT(0, "");
+  return nullptr;
+}
+
+bool LShouldEmit(unsigned int dwform) {
+  return dwform != DW_FORM_flag_present;
+}
+
+DBGDie *LFindChildDieWithName(DBGDie *die, DwTag tag, const GStrIdx key) {
+  for (DBGDie *c : die->GetSubDieVec()) {
+    if (c->GetTag() == tag) {
+      for (DBGDieAttr *a : c->GetAttrVec()) {
+        if (a->GetDwAt() == DW_AT_name) {
+          if ((a->GetDwForm() == DW_FORM_string || a->GetDwForm() == DW_FORM_strp) && a->GetId() == key.GetIdx()) {
+            return c;
+          } else {
+            break;
+          }
+        }
+      }
+    }
+  }
+  return nullptr;
+}
+
+DBGDieAttr *LFindDieAttr(DBGDie *die, DwAt attrname) {
+  for (DBGDieAttr *attr : die->GetAttrVec()) {
+    if (attr->GetDwAt() == attrname) {
+      return attr;
+    }
+  }
+  return nullptr;
+}
+
+static void LUpdateAttrValue(DBGDieAttr *attr, int64_t newval) {
+  attr->SetI(int32_t(newval));
+}
+}
+
+namespace maplebe {
+using namespace maple;
+using namespace cfi;
+
+void Emitter::EmitLabelRef(LabelIdx labIdx) {
+  PUIdx pIdx = GetCG()->GetMIRModule()->CurFunction()->GetPuidx();
+  char *idx = strdup(std::to_string(pIdx).c_str());
+  outStream << ".L." << idx << "__" << labIdx;
+  free(idx);
+  idx = nullptr;
+}
+
+void Emitter::EmitStmtLabel(LabelIdx labIdx) {
+  EmitLabelRef(labIdx);
+  outStream << ":\n";
+}
+
+void Emitter::EmitLabelPair(const LabelPair &pairLabel) {
+  ASSERT(pairLabel.GetEndOffset() || pairLabel.GetStartOffset(), "NYI");
+  EmitLabelRef(pairLabel.GetEndOffset()->GetLabelIdx());
+  outStream << " - ";
+  EmitLabelRef(pairLabel.GetStartOffset()->GetLabelIdx());
+  outStream << "\n";
+}
+
+void Emitter::EmitLabelForFunc(const MIRFunction *func, LabelIdx labIdx) {
+  char *idx = strdup(std::to_string(func->GetPuidx()).c_str());
+  outStream << ".L." << idx << "__" << labIdx;
+  free(idx);
+  idx = nullptr;
+}
+
+AsmLabel Emitter::GetTypeAsmInfoName(PrimType primType) const {
+  uint32 size = GetPrimTypeSize(primType);
+  /* case x : x occupies bytes of pty */
+  switch (size) {
+    case k1ByteSize:
+      return kAsmByte;
+    case k2ByteSize:
+#if TARGAARCH64 || TARGRISCV64
+      return kAsmShort;
+#else
+      return kAsmValue;
+#endif
+    case k4ByteSize:
+      return kAsmLong;
+    case k8ByteSize:
+      return kAsmQuad;
+    default:
+      ASSERT(false, "NYI");
+      break;
+  }
+  return kAsmLong;
+}
+
+void Emitter::EmitFileInfo(const std::string &fileName) {
+#if defined(_WIN32) || defined(DARWIN)
+  char *curDirName = getcwd(nullptr, 0);
+#else
+  char *curDirName = get_current_dir_name();
+#endif
+  CHECK_FATAL(curDirName != nullptr, "null ptr check ");
+  Emit(asmInfo->GetCmnt());
+  std::string path(curDirName);
+#ifdef _WIN32
+  std::string cgFile(path.append("\\mplcg"));
+#else
+  std::string cgFile(path.append("/mplcg"));
+#endif
+  Emit(cgFile);
+  Emit("\n");
+
+  std::string compile("Compiling ");
+  Emit(asmInfo->GetCmnt());
+  Emit(compile);
+  Emit("\n");
+
+  std::string beOptions("Be options");
+  Emit(asmInfo->GetCmnt());
+  Emit(beOptions);
+  Emit("\n");
+
+  path = curDirName;
+  path.append("/").append(fileName);
+  /* strip path before out/ */
+  std::string out = "/out/";
+  size_t pos = path.find(out.c_str(), 0, out.length());
+  if (pos != std::string::npos) {
+    path.erase(0, pos + 1);
+  }
+  std::string irFile("\"");
+  irFile.append(path).append("\"");
+  Emit(asmInfo->GetFile());
+  Emit(irFile);
+  Emit("\n");
+
+  /* save directory path in index 8 */
+  SetFileMapValue(0, path);
+
+  /* .file #num src_file_name */
+  if (cg->GetCGOptions().WithLoc()) {
+    /* .file 1 mpl_file_name */
+    if (cg->GetCGOptions().WithAsm()) {
+      Emit("\t// ");
+    }
+    Emit(asmInfo->GetFile());
+    Emit("1 ");
+    Emit(irFile);
+    Emit("\n");
+    SetFileMapValue(1, irFile);   /* save ir file in 1 */
+    if (cg->GetCGOptions().WithSrc()) {
+      /* insert a list of src files */
+      uint32 i = 2;
+      for (auto it : cg->GetMIRModule()->GetSrcFileInfo()) {
+        if (cg->GetCGOptions().WithAsm()) {
+          Emit("\t// ");
+        }
+        Emit(asmInfo->GetFile());
+        Emit(it.second).Emit(" \"");
+        std::string kStr = GlobalTables::GetStrTable().GetStringFromStrIdx(it.first);
+        Emit(kStr);
+        Emit("\"\n");
+        SetFileMapValue(i++, kStr);
+      }
+    }
+  }
+  free(curDirName);
+
+  EmitInlineAsmSection();
+#if TARGARM32
+  Emit("\t.syntax unified\n");
+  /*
+   * "The arm instruction set is a subset of
+   *  the most commonly used 32-bit ARM instructions."
+   * http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0210c/CACBCAAE.html
+   */
+  Emit("\t.arm\n");
+  Emit("\t.fpu vfpv4\n");
+  Emit("\t.arch armv7-a\n");
+  Emit("\t.eabi_attribute Tag_ABI_PCS_RW_data, 1\n");
+  Emit("\t.eabi_attribute Tag_ABI_PCS_RO_data, 1\n");
+  Emit("\t.eabi_attribute Tag_ABI_PCS_GOT_use, 2\n");
+  if (CGOptions::GetABIType() == CGOptions::kABIHard) {
+    Emit("\t.eabi_attribute Tag_ABI_VFP_args, 1\n");
+  }
+  Emit("\t.eabi_attribute Tag_ABI_FP_denormal, 1\n");
+  Emit("\t.eabi_attribute Tag_ABI_FP_exceptions, 1\n");
+  Emit("\t.eabi_attribute Tag_ABI_FP_number_model, 3\n");
+  Emit("\t.eabi_attribute Tag_ABI_align_needed, 1\n");
+  Emit("\t.eabi_attribute Tag_ABI_align_preserved, 1\n");
+  Emit("\t.eabi_attribute Tag_ABI_enum_size, 2\n");
+  Emit("\t.eabi_attribute 30, 6\n");
+  Emit("\t.eabi_attribute Tag_CPU_unaligned_access, 1\n");
+  Emit("\t.eabi_attribute Tag_ABI_PCS_wchar_t, 4\n");
+#endif /* TARGARM32 */
+}
+
+void Emitter::EmitInlineAsmSection() {
+  MapleVector<MapleString> &asmSections = cg->GetMIRModule()->GetAsmDecls();
+  if (!asmSections.empty()) {
+    Emit("#APP\n");
+    for (auto &singleSection : asmSections) {
+      Emit("\t");
+      Emit(singleSection);
+      Emit("\n");
+    }
+    Emit("#NO_APP\n");
+  }
+}
+void Emitter::EmitAsmLabel(AsmLabel label) {
+  switch (label) {
+    case kAsmData: {
+      (void)Emit(asmInfo->GetData());
+      (void)Emit("\n");
+      return;
+    }
+    case kAsmText: {
+      (void)Emit(asmInfo->GetText());
+      (void)Emit("\n");
+      return;
+    }
+    case kAsmType: {
+      (void)Emit(asmInfo->GetType());
+      return;
+    }
+    case kAsmByte: {
+      (void)Emit(asmInfo->GetByte());
+      return;
+    }
+    case kAsmShort: {
+      (void)Emit(asmInfo->GetShort());
+      return;
+    }
+    case kAsmValue: {
+      (void)Emit(asmInfo->GetValue());
+      return;
+    }
+    case kAsmLong: {
+      (void)Emit(asmInfo->GetLong());
+      return;
+    }
+    case kAsmQuad: {
+      (void)Emit(asmInfo->GetQuad());
+      return;
+    }
+    case kAsmZero:
+      (void)Emit(asmInfo->GetZero());
+      return;
+    default:
+      ASSERT(false, "should not run here");
+      return;
+  }
+}
+
+void Emitter::EmitAsmLabel(const MIRSymbol &mirSymbol, AsmLabel label) {
+  MIRType *mirType = mirSymbol.GetType();
+  std::string symName;
+  if (mirSymbol.GetStorageClass() == kScPstatic && mirSymbol.IsLocal()) {
+    PUIdx pIdx = GetCG()->GetMIRModule()->CurFunction()->GetPuidx();
+    symName = mirSymbol.GetName() + std::to_string(pIdx);
+  } else {
+    symName = mirSymbol.GetName();
+  }
+  if (mirSymbol.GetAsmAttr() != UStrIdx(0) &&
+      (mirSymbol.GetStorageClass() == kScPstatic || mirSymbol.GetStorageClass() == kScPstatic)) {
+    std::string asmSection = GlobalTables::GetUStrTable().GetStringFromStrIdx(mirSymbol.GetAsmAttr());
+    symName = asmSection;
+  }
+  if (Globals::GetInstance()->GetBECommon()->IsEmptyOfTypeAlignTable()) {
+    ASSERT(false, "container empty check");
+  }
+
+  switch (label) {
+    case kAsmGlbl: {
+      Emit(asmInfo->GetGlobal());
+      Emit(symName);
+      Emit("\n");
+      return;
+    }
+    case kAsmHidden: {
+      Emit(asmInfo->GetHidden());
+      Emit(symName);
+      Emit("\n");
+      return;
+    }
+    case kAsmLocal: {
+      Emit(asmInfo->GetLocal());
+      Emit(symName);
+      Emit("\n");
+      return;
+    }
+    case kAsmWeak: {
+      Emit(asmInfo->GetWeak());
+      Emit(symName);
+      Emit("\n");
+      return;
+    }
+    case kAsmZero: {
+      uint64 size = Globals::GetInstance()->GetBECommon()->GetTypeSize(mirType->GetTypeIndex());
+      EmitNullConstant(size);
+      return;
+    }
+    case kAsmComm: {
+      std::string size;
+      if (isFlexibleArray) {
+        size = std::to_string(Globals::GetInstance()->GetBECommon()->GetTypeSize(mirType->GetTypeIndex()) + arraySize);
+      } else {
+        size = std::to_string(Globals::GetInstance()->GetBECommon()->GetTypeSize(mirType->GetTypeIndex()));
+      }
+      (void)Emit(asmInfo->GetComm()).Emit(symName).Emit(", ").Emit(size).Emit(", ");
+#if PECOFF
+#if TARGARM || TARGAARCH64 || TARGARK || TARGRISCV64
+      std::string align = std::to_string(
+          static_cast<int>(log2(Globals::GetInstance()->GetBECommon()->GetTypeAlign(mirType->GetTypeIndex()))));
+#else
+      std::string align = std::to_string(
+          Globals::GetInstance()->GetBECommon()->GetTypeAlign(mirType->GetTypeIndex()));
+#endif
+      emit(align.c_str());
+#else /* ELF */
+      /* output align, symbol name begin with "classInitProtectRegion" align is 4096 */
+      MIRTypeKind kind = mirSymbol.GetType()->GetKind();
+      MIRStorageClass storage = mirSymbol.GetStorageClass();
+      if (symName.find("classInitProtectRegion") == 0) {
+        Emit(4096);
+      } else if (((kind == kTypeStruct) || (kind == kTypeClass) || (kind == kTypeArray) || (kind == kTypeUnion)) &&
+                 ((storage == kScGlobal) || (storage == kScPstatic) || (storage == kScFstatic))) {
+        int32 align = Globals::GetInstance()->GetBECommon()->GetTypeAlign(mirType->GetTypeIndex());
+        if (GetPointerSize() < align) {
+          (void)Emit(std::to_string(align));
+        } else {
+          (void)Emit(std::to_string(k8ByteSize));
+        }
+      } else {
+        (void)Emit(std::to_string(Globals::GetInstance()->GetBECommon()->GetTypeAlign(mirType->GetTypeIndex())));
+      }
+#endif
+      Emit("\n");
+      return;
+    }
+    case kAsmAlign: {
+      uint8 align = mirSymbol.GetAttrs().GetAlignValue();
+      if (align == 0) {
+        if (mirSymbol.GetType()->GetKind() == kTypeStruct ||
+            mirSymbol.GetType()->GetKind() == kTypeClass ||
+            mirSymbol.GetType()->GetKind() == kTypeArray ||
+            mirSymbol.GetType()->GetKind() == kTypeUnion) {
+#if TARGX86 || TARGX86_64
+          return;
+#else
+          align = kAlignOfU8;
+#endif
+        } else {
+          align = Globals::GetInstance()->GetBECommon()->GetTypeAlign(mirSymbol.GetType()->GetTypeIndex());
+#if TARGARM32 || TARGAARCH64 || TARGARK || TARGRISCV64
+          if (CGOptions::IsArm64ilp32() && mirSymbol.GetType()->GetPrimType() == PTY_a32) {
+            align = kAlignOfU8;
+          } else {
+            align = static_cast<uint8>(log2(align));
+          }
+#endif
+        }
+      }
+      Emit(asmInfo->GetAlign());
+      Emit(std::to_string(align));
+      Emit("\n");
+      return;
+    }
+    case kAsmSyname: {
+      Emit(symName);
+      Emit(":\n");
+      return;
+    }
+    case kAsmSize: {
+      Emit(asmInfo->GetSize());
+      Emit(symName);
+      Emit(", ");
+#if TARGX86 || TARGX86_64
+      Emit(".-");
+      Emit(symName);
+#else
+      std::string size;
+      if (isFlexibleArray) {
+          size = std::to_string(
+              Globals::GetInstance()->GetBECommon()->GetTypeSize(mirType->GetTypeIndex()) + arraySize);
+      } else {
+          size = std::to_string(Globals::GetInstance()->GetBECommon()->GetTypeSize(mirType->GetTypeIndex()));
+      }
+      Emit(size);
+#endif
+      Emit("\n");
+      return;
+    }
+    case kAsmType: {
+      Emit(asmInfo->GetType());
+      if (GetCG()->GetMIRModule()->IsCModule() && (symName == "sys_nerr" || symName == "sys_errlist")) {
+        /* eliminate warning from deprecated C name */
+        Emit("strerror");
+      } else {
+        Emit(symName);
+      }
+      Emit(",");
+      Emit(asmInfo->GetAtobt());
+      Emit("\n");
+      return;
+    }
+    default:
+      ASSERT(false, "should not run here");
+      return;
+  }
+}
+
+void Emitter::EmitNullConstant(uint64 size) {
+  EmitAsmLabel(kAsmZero);
+  Emit(std::to_string(size));
+  Emit("\n");
+}
+
+void Emitter::EmitCombineBfldValue(StructEmitInfo &structEmitInfo) {
+  uint8 charBitWidth = GetPrimTypeSize(PTY_i8) * kBitsPerByte;
+  auto emitBfldValue = [&structEmitInfo, charBitWidth, this](bool flag) {
+    while (structEmitInfo.GetCombineBitFieldWidth() > charBitWidth) {
+      uint8 shift = flag ? (structEmitInfo.GetCombineBitFieldWidth() - charBitWidth) : 0U;
+      uint64 tmp = (structEmitInfo.GetCombineBitFieldValue() >> shift) & 0x00000000000000ffUL;
+      EmitAsmLabel(kAsmByte);
+      Emit(std::to_string(tmp));
+      Emit("\n");
+      structEmitInfo.DecreaseCombineBitFieldWidth(charBitWidth);
+      uint64 value = flag ?
+          structEmitInfo.GetCombineBitFieldValue() - (tmp << structEmitInfo.GetCombineBitFieldWidth()) :
+          structEmitInfo.GetCombineBitFieldValue() >> charBitWidth;
+      structEmitInfo.SetCombineBitFieldValue(value);
+    }
+  };
+  if (CGOptions::IsBigEndian()) {
+    /*
+     * If the total number of bits in the bit field is not a multiple of 8,
+     * the bits must be aligned to 8 bits to prevent errors in the emit.
+     */
+    auto width = static_cast<uint8>(RoundUp(structEmitInfo.GetCombineBitFieldWidth(), charBitWidth));
+    if (structEmitInfo.GetCombineBitFieldWidth() < width) {
+      structEmitInfo.SetCombineBitFieldValue(structEmitInfo.GetCombineBitFieldValue() <<
+                                             (width - structEmitInfo.GetCombineBitFieldWidth()));
+      structEmitInfo.IncreaseCombineBitFieldWidth(static_cast<uint8>(
+          width - structEmitInfo.GetCombineBitFieldWidth()));
+    }
+    emitBfldValue(true);
+  } else {
+    emitBfldValue(false);
+  }
+  if (structEmitInfo.GetCombineBitFieldWidth() != 0) {
+    EmitAsmLabel(kAsmByte);
+    uint64 value = structEmitInfo.GetCombineBitFieldValue() & 0x00000000000000ffUL;
+    Emit(std::to_string(value));
+    Emit("\n");
+  }
+  CHECK_FATAL(charBitWidth != 0, "divide by zero");
+  if ((structEmitInfo.GetNextFieldOffset() % charBitWidth) != 0) {
+    uint8 value = charBitWidth - (structEmitInfo.GetNextFieldOffset() % charBitWidth);
+    structEmitInfo.IncreaseNextFieldOffset(value);
+  }
+  structEmitInfo.SetTotalSize(structEmitInfo.GetNextFieldOffset() / charBitWidth);
+  structEmitInfo.SetCombineBitFieldValue(0);
+  structEmitInfo.SetCombineBitFieldWidth(0);
+}
+
+void Emitter::EmitBitFieldConstant(StructEmitInfo &structEmitInfo, MIRConst &mirConst, const MIRType *nextType,
+                                   uint64 fieldOffset) {
+  MIRType &mirType = mirConst.GetType();
+  if (fieldOffset > structEmitInfo.GetNextFieldOffset()) {
+    uint16 curFieldOffset = structEmitInfo.GetNextFieldOffset() - structEmitInfo.GetCombineBitFieldWidth();
+    structEmitInfo.SetCombineBitFieldWidth(fieldOffset - curFieldOffset);
+    EmitCombineBfldValue(structEmitInfo);
+    ASSERT(structEmitInfo.GetNextFieldOffset() <= fieldOffset,
+           "structEmitInfo's nextFieldOffset should be <= fieldOffset");
+    structEmitInfo.SetNextFieldOffset(fieldOffset);
+  }
+  uint32 fieldSize = static_cast<MIRBitFieldType&>(mirType).GetFieldSize();
+  MIRIntConst &fieldValue = static_cast<MIRIntConst&>(mirConst);
+  /* Truncate the size of FieldValue to the bit field size. */
+  if (fieldSize < fieldValue.GetActualBitWidth()) {
+    fieldValue.Trunc(fieldSize);
+  }
+  /* Clear higher Bits for signed value  */
+  if (structEmitInfo.GetCombineBitFieldValue() != 0) {
+    structEmitInfo.SetCombineBitFieldValue((~(~0ULL << structEmitInfo.GetCombineBitFieldWidth())) &
+                                           structEmitInfo.GetCombineBitFieldValue());
+  }
+  if (CGOptions::IsBigEndian()) {
+    uint64 beValue = static_cast<uint64_t>(fieldValue.GetExtValue());
+    if (fieldValue.IsNegative()) {
+      beValue = beValue - ((beValue >> fieldSize) << fieldSize);
+    }
+    structEmitInfo.SetCombineBitFieldValue(
+        (structEmitInfo.GetCombineBitFieldValue() << fieldSize) + beValue);
+  } else {
+    structEmitInfo.SetCombineBitFieldValue((fieldValue.GetExtValue() << structEmitInfo.GetCombineBitFieldWidth()) +
+                                           structEmitInfo.GetCombineBitFieldValue());
+  }
+  structEmitInfo.IncreaseCombineBitFieldWidth(fieldSize);
+  structEmitInfo.IncreaseNextFieldOffset(fieldSize);
+  if ((nextType == nullptr) || (kTypeBitField != nextType->GetKind())) {
+    /* emit structEmitInfo->combineBitFieldValue */
+    EmitCombineBfldValue(structEmitInfo);
+  }
+}
+
+void Emitter::EmitStr(const std::string& mplStr, bool emitAscii, bool emitNewline) {
+  const char *str = mplStr.c_str();
+  size_t len = mplStr.size();
+
+  if (emitAscii) {
+    Emit("\t.ascii\t\"");  /* Do not terminate with \0 */
+  } else {
+    Emit("\t.string\t\"");
+  }
+
+  /*
+   * don't expand special character in a writeout to .s,
+   * convert all \s to \\s in string for storing in .string
+   */
+  for (size_t i = 0; i < len; i++) {
+    /* Referred to GNU AS: 3.6.1.1 Strings */
+    constexpr int kBufSize = 5;
+    constexpr int kFirstChar = 0;
+    constexpr int kSecondChar = 1;
+    constexpr int kThirdChar = 2;
+    constexpr int kLastChar = 4;
+    char buf[kBufSize];
+    if (isprint(*str)) {
+      buf[kFirstChar] = *str;
+      buf[kSecondChar] = 0;
+      if (*str == '\\' || *str == '\"') {
+        buf[kFirstChar] = '\\';
+        buf[kSecondChar] = *str;
+        buf[kThirdChar] = 0;
+      }
+      Emit(buf);
+    } else if (*str == '\b') {
+      Emit("\\b");
+    } else if (*str == '\n') {
+      Emit("\\n");
+    } else if (*str == '\r') {
+      Emit("\\r");
+    } else if (*str == '\t') {
+      Emit("\\t");
+    } else if (*str == '\0') {
+      buf[kFirstChar] = '\\';
+      buf[kSecondChar] = '0';
+      buf[kThirdChar] = 0;
+      Emit(buf);
+    } else {
+      /* all others, print as number */
+      int ret = snprintf_s(buf, sizeof(buf), k4BitSize, "\\%03o", (*str) & 0xFF);
+      if (ret < 0) {
+        FATAL(kLncFatal, "snprintf_s failed");
+      }
+      buf[kLastChar] = '\0';
+      Emit(buf);
+    }
+    str++;
+  }
+
+  Emit("\"");
+  if (emitNewline) {
+    Emit("\n");
+  }
+}
+
+void Emitter::EmitStrConstant(const MIRStrConst &mirStrConst, bool isIndirect) {
+  if (isIndirect) {
+    uint32 strId = mirStrConst.GetValue().GetIdx();
+
+    if (stringPtr.find(mirStrConst.GetValue()) == stringPtr.end()) {
+      stringPtr.insert(mirStrConst.GetValue());
+    }
+    if (CGOptions::IsArm64ilp32()) {
+      (void)Emit("\t.word\t").Emit(".LSTR__").Emit(std::to_string(strId).c_str());
+    } else {
+#if TARGAARCH64
+      (void)Emit("\t.xword\t").Emit(".LSTR__").Emit(std::to_string(strId).c_str());
+#elif TARGX86_64
+      EmitAsmLabel(kAsmQuad);
+      (void)Emit(".LSTR__").Emit(std::to_string(strId).c_str());
+#else
+      CHECK_FATAL(false, "target not supported");
+#endif
+    }
+    return;
+  }
+
+  const std::string ustr = GlobalTables::GetUStrTable().GetStringFromStrIdx(mirStrConst.GetValue());
+  size_t len = ustr.size();
+  if (isFlexibleArray) {
+    arraySize += static_cast<uint32>(len) + 1;
+  }
+  EmitStr(ustr, false, false);
+}
+
+void Emitter::EmitStr16Constant(const MIRStr16Const &mirStr16Const) {
+  Emit("\t.byte ");
+  /* note: for now, u16string is emitted 2 bytes without any \u indication */
+  const std::u16string &str16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(mirStr16Const.GetValue());
+  constexpr int bufSize = 9;
+  char buf[bufSize];
+  char16_t c = str16[0];
+  /* fetch the type of char16_t c's top 8 bit data */
+  int ret1 = snprintf_s(buf, sizeof(buf), bufSize - 1, "%d,%d", (c >> 8) & 0xFF, c & 0xFF);
+  if (ret1 < 0) {
+    FATAL(kLncFatal, "snprintf_s failed");
+  }
+  buf[bufSize - 1] = '\0';
+  Emit(buf);
+  for (uint32 i = 1; i < str16.length(); ++i) {
+    c = str16[i];
+    /* fetch the type of char16_t c's top 8 bit data */
+    int ret2 = snprintf_s(buf, sizeof(buf), bufSize - 1, ",%d,%d", (c >> 8) & 0xFF, c & 0xFF);
+    if (ret2 < 0) {
+      FATAL(kLncFatal, "snprintf_s failed");
+    }
+    buf[bufSize - 1] = '\0';
+    Emit(buf);
+  }
+  if ((str16.length() & 0x1) == 1) {
+    Emit(",0,0");
+  }
+}
+
+void Emitter::EmitScalarConstant(MIRConst &mirConst, bool newLine, bool flag32, bool isIndirect) {
+  MIRType &mirType = mirConst.GetType();
+  AsmLabel asmName = GetTypeAsmInfoName(mirType.GetPrimType());
+  switch (mirConst.GetKind()) {
+    case kConstInt: {
+      MIRIntConst &intCt = static_cast<MIRIntConst&>(mirConst);
+      uint32 sizeInBits = GetPrimTypeBitSize(mirType.GetPrimType());
+      if (intCt.GetActualBitWidth() > sizeInBits) {
+        intCt.Trunc(sizeInBits);
+      }
+      if (flag32) {
+        EmitAsmLabel(AsmLabel::kAsmLong);
+      } else {
+        EmitAsmLabel(asmName);
+      }
+      Emit(intCt.GetValue());
+      if (isFlexibleArray) {
+        arraySize += (sizeInBits / kBitsPerByte);
+      }
+      break;
+    }
+    case kConstFloatConst: {
+      MIRFloatConst &floatCt = static_cast<MIRFloatConst&>(mirConst);
+      EmitAsmLabel(asmName);
+      Emit(std::to_string(floatCt.GetIntValue()));
+      if (isFlexibleArray) {
+        arraySize += k4ByteFloatSize;
+      }
+      break;
+    }
+    case kConstDoubleConst: {
+      MIRDoubleConst &doubleCt = static_cast<MIRDoubleConst&>(mirConst);
+      EmitAsmLabel(asmName);
+      Emit(std::to_string(doubleCt.GetIntValue()));
+      if (isFlexibleArray) {
+        arraySize += k8ByteDoubleSize;
+      }
+      break;
+    }
+    case kConstStrConst: {
+      MIRStrConst &strCt = static_cast<MIRStrConst&>(mirConst);
+      if (cg->GetMIRModule()->IsCModule()) {
+        EmitStrConstant(strCt, isIndirect);
+      } else {
+        EmitStrConstant(strCt);
+      }
+      break;
+    }
+    case kConstStr16Const: {
+      MIRStr16Const &str16Ct = static_cast<MIRStr16Const&>(mirConst);
+      EmitStr16Constant(str16Ct);
+      break;
+    }
+    case kConstAddrof: {
+      MIRAddrofConst &symAddr = static_cast<MIRAddrofConst&>(mirConst);
+      StIdx stIdx = symAddr.GetSymbolIndex();
+      MIRSymbol *symAddrSym = stIdx.IsGlobal() ? GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx())
+          : CG::GetCurCGFunc()->GetMirModule().CurFunction()->GetSymTab()->GetSymbolFromStIdx(stIdx.Idx());
+      ASSERT(symAddrSym != nullptr, "null ptr check");
+      std::string str;
+      if (CGOptions::IsArm64ilp32()) {
+        str = ".word";
+      } else {
+        str = ".quad";
+      }
+      if (stIdx.IsGlobal() == false && symAddrSym->GetStorageClass() == kScPstatic) {
+        PUIdx pIdx = GetCG()->GetMIRModule()->CurFunction()->GetPuidx();
+        (void)Emit("\t" + str + "\t" + symAddrSym->GetName() + std::to_string(pIdx));
+      } else {
+        (void)Emit("\t" + str + "\t" + symAddrSym->GetName());
+      }
+      if (symAddr.GetOffset() != 0) {
+        (void)Emit(" + ").Emit(symAddr.GetOffset());
+      }
+      if (symAddr.GetFieldID() > 1) {
+        MIRStructType *structType = static_cast<MIRStructType *>(symAddrSym->GetType());
+        ASSERT(structType != nullptr, "EmitScalarConstant: non-zero fieldID for non-structure");
+        (void)Emit(" + ").Emit(Globals::GetInstance()->GetBECommon()->GetFieldOffset(
+            *structType, symAddr.GetFieldID()).first);
+      }
+      break;
+    }
+    case kConstAddrofFunc: {
+      MIRAddroffuncConst &funcAddr = static_cast<MIRAddroffuncConst&>(mirConst);
+      MIRFunction *func = GlobalTables::GetFunctionTable().GetFuncTable().at(funcAddr.GetValue());
+      MIRSymbol *symAddrSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
+      std::string str;
+      if (CGOptions::IsArm64ilp32()) {
+        str = ".word";
+      } else {
+        str = ".quad";
+      }
+      (void)Emit("\t" + str + "\t" + symAddrSym->GetName());
+      break;
+    }
+    case kConstLblConst: {
+      MIRLblConst &lbl = static_cast<MIRLblConst&>(mirConst);
+      if (CGOptions::IsArm64ilp32()) {
+        (void)Emit("\t.word\t");
+      } else {
+        EmitAsmLabel(kAsmQuad);
+      }
+      EmitLabelRef(lbl.GetValue());
+      break;
+    }
+    default:
+      ASSERT(false, "NYI");
+      break;
+  }
+  if (newLine) {
+    Emit("\n");
+  }
+}
+
+void Emitter::EmitAddrofFuncConst(const MIRSymbol &mirSymbol, MIRConst &elemConst, size_t idx) {
+  MIRAddroffuncConst &funcAddr = static_cast<MIRAddroffuncConst&>(elemConst);
+  const std::string stName = mirSymbol.GetName();
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(funcAddr.GetValue());
+  const std::string &funcName = func->GetName();
+  if ((idx == kFuncDefNameIndex) && mirSymbol.IsMuidFuncInfTab()) {
+    Emit("\t.long\t.Label.name.");
+    Emit(funcName + " - .");
+    Emit("\n");
+    return;
+  }
+  if ((idx == kFuncDefSizeIndex) && mirSymbol.IsMuidFuncInfTab()) {
+    Emit("\t.long\t.Label.end.");
+    Emit(funcName + " - ");
+    Emit(funcName + "\n");
+    return;
+  }
+  if ((idx == static_cast<uint32>(MethodProperty::kPaddrData)) && mirSymbol.IsReflectionMethodsInfo()) {
+#ifdef USE_32BIT_REF
+    Emit("\t.long\t");
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+    Emit(funcName + " - .\n");
+    return;
+  }
+  if (((idx == static_cast<uint32>(MethodInfoCompact::kPaddrData)) && mirSymbol.IsReflectionMethodsInfoCompact()) ||
+      ((idx == static_cast<uint32>(ClassRO::kClinitAddr)) && mirSymbol.IsReflectionClassInfoRO())) {
+    Emit("\t.long\t");
+    Emit(funcName + " - .\n");
+    return;
+  }
+
+  if (mirSymbol.IsReflectionMethodAddrData()) {
+#ifdef USE_32BIT_REF
+    Emit("\t.long\t");
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+    Emit(funcName + " - .\n");
+    return;
+  }
+
+  if (idx == kFuncDefAddrIndex && mirSymbol.IsMuidFuncDefTab()) {
+#if defined(USE_32BIT_REF)
+    Emit("\t.long\t");
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+    if (CGOptions::IsLazyBinding() && !cg->IsLibcore()) {
+      /*
+       * Check enum BindingState defined in Mpl_Binding.h,
+       * 6 means kBindingStateMethodDef:6 offset away from base __BindingProtectRegion__.
+       */
+#if defined(USE_32BIT_REF)
+      Emit("0x6\n"); /* Fix it in runtime, __BindingProtectRegion__ + kBindingStateMethodDef:6. */
+#else
+      Emit("__BindingProtectRegion__ + 6\n");
+#endif  /* USE_32BIT_REF */
+    } else {
+#if defined(USE_32BIT_REF)
+#if defined(MPL_LNK_ADDRESS_VIA_BASE)
+      Emit(funcName + "\n");
+#else  /* MPL_LNK_ADDRESS_VIA_BASE */
+      Emit(funcName + "-.\n");
+#endif /* MPL_LNK_ADDRESS_VIA_BASE */
+#else  /* USE_32BIT_REF */
+      Emit(funcName + "\n");
+#endif /* USE_32BIT_REF */
+    }
+    return;
+  }
+
+  if (idx == kFuncDefAddrIndex && mirSymbol.IsMuidFuncDefOrigTab()) {
+    if (CGOptions::IsLazyBinding() && !cg->IsLibcore()) {
+#if defined(USE_32BIT_REF)
+      Emit("\t.long\t");
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+      EmitAsmLabel(kAsmQuad);
+#else
+      Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+#if defined(USE_32BIT_REF)
+#if defined(MPL_LNK_ADDRESS_VIA_BASE)
+      Emit(funcName + "\n");
+#else /* MPL_LNK_ADDRESS_VIA_BASE */
+      Emit(funcName + "-.\n");
+#endif /* MPL_LNK_ADDRESS_VIA_BASE */
+#else /* USE_32BIT_REF */
+      Emit(funcName + "\n");
+#endif /* USE_32BIT_REF */
+    }
+    return;
+  }
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+  Emit(funcName);
+  if ((stName.find(VTAB_PREFIX_STR) == 0) || (stName.find(ITAB_PREFIX_STR) == 0) ||
+      (stName.find(ITAB_CONFLICT_PREFIX_STR) == 0)) {
+    Emit(" - .\n");
+    return;
+  }
+  if (cg->GetCGOptions().GeneratePositionIndependentExecutable()) {
+    Emit(" - ");
+    Emit(stName);
+  }
+  Emit("\n");
+}
+
+void Emitter::EmitAddrofSymbolConst(const MIRSymbol &mirSymbol, MIRConst &elemConst, size_t idx) {
+  MIRAddrofConst &symAddr = static_cast<MIRAddrofConst&>(elemConst);
+  const std::string stName = mirSymbol.GetName();
+
+  MIRSymbol *symAddrSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(symAddr.GetSymbolIndex().Idx());
+  const std::string &symAddrName = symAddrSym->GetName();
+
+  if (((idx == static_cast<uint32>(FieldProperty::kPOffset)) && mirSymbol.IsReflectionFieldsInfo()) ||
+      mirSymbol.IsReflectionFieldOffsetData()) {
+#if USE_32BIT_REF
+    Emit("\t.long\t");
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+    Emit(symAddrName + " - .\n");
+    return;
+  }
+
+  if (((idx == static_cast<uint32>(FieldPropertyCompact::kPOffset)) && mirSymbol.IsReflectionFieldsInfoCompact())  ||
+      ((idx == static_cast<uint32>(MethodProperty::kSigName)) && mirSymbol.IsReflectionMethodsInfo()) ||
+      ((idx == static_cast<uint32>(MethodSignatureProperty::kParameterTypes)) &&
+      mirSymbol.IsReflectionMethodSignature())) {
+    Emit("\t.long\t");
+    Emit(symAddrName + " - .\n");
+    return;
+  }
+
+  if (((idx == static_cast<uint32>(MethodProperty::kDeclarclass)) ||
+      (idx == static_cast<uint32>(MethodProperty::kPaddrData))) && mirSymbol.IsReflectionMethodsInfo()) {
+#if USE_32BIT_REF
+    Emit("\t.long\t");
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+    if (idx == static_cast<uint32>(MethodProperty::kDeclarclass)) {
+      Emit(symAddrName + " - .\n");
+    } else {
+      Emit(symAddrName + " - . + 2\n");
+    }
+    return;
+  }
+
+  if ((idx == static_cast<uint32>(MethodInfoCompact::kPaddrData)) && mirSymbol.IsReflectionMethodsInfoCompact()) {
+    Emit("\t.long\t");
+    Emit(symAddrName + " - . + 2\n");
+    return;
+  }
+
+  if ((idx == static_cast<uint32>(FieldProperty::kDeclarclass)) && mirSymbol.IsReflectionFieldsInfo()) {
+#if USE_32BIT_REF
+    Emit("\t.long\t");
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+    Emit(symAddrName + " - .\n");
+    return;
+  }
+
+  if ((idx == kDataDefAddrIndex) && (mirSymbol.IsMuidDataUndefTab() || mirSymbol.IsMuidDataDefTab())) {
+    if (symAddrSym->IsReflectionClassInfo()) {
+      Emit(".LDW.ref." + symAddrName + ":\n");
+    }
+    Emit(kPtrPrefixStr + symAddrName + ":\n");
+#if defined(USE_32BIT_REF)
+    Emit("\t.long\t");
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+    if (mirSymbol.IsMuidDataUndefTab()) {
+      if (CGOptions::IsLazyBinding() && !cg->IsLibcore()) {
+        if (symAddrSym->IsReflectionClassInfo()) {
+          /*
+           * Check enum BindingState defined in Mpl_Binding.h,
+           * 1 means kBindingStateCinfUndef:1 offset away from base __BindingProtectRegion__.
+           */
+#if defined(USE_32BIT_REF)
+          Emit("0x1\n"); /* Fix it in runtime, __BindingProtectRegion__ + kBindingStateCinfUndef:1. */
+#else
+          Emit("__BindingProtectRegion__ + 1\n");
+#endif  /* USE_32BIT_REF */
+        } else {
+          /*
+           * Check enum BindingState defined in Mpl_Binding.h,
+           * 3 means kBindingStateDataUndef:3 offset away from base __BindingProtectRegion__.
+           */
+#if defined(USE_32BIT_REF)
+          Emit("0x3\n"); /* Fix it in runtime, __BindingProtectRegion__ + kBindingStateDataUndef:3. */
+#else
+          Emit("__BindingProtectRegion__ + 3\n");
+#endif  /* USE_32BIT_REF */
+        }
+      } else {
+        Emit("0\n");
+      }
+    } else {
+      if (CGOptions::IsLazyBinding() && !cg->IsLibcore()) {
+        if (symAddrSym->IsReflectionClassInfo()) {
+          /*
+           * Check enum BindingState defined in Mpl_Binding.h,
+           * 2 means kBindingStateCinfDef:2 offset away from base __BindingProtectRegion__.
+           */
+#if defined(USE_32BIT_REF)
+          Emit("0x2\n"); /* Fix it in runtime, __BindingProtectRegion__ + kBindingStateCinfDef:2. */
+#else
+          Emit("__BindingProtectRegion__ + 2\n");
+#endif  /* USE_32BIT_REF */
+        } else {
+          /*
+           * Check enum BindingState defined in Mpl_Binding.h,
+           * 4 means kBindingStateDataDef:4 offset away from base __BindingProtectRegion__.
+           */
+#if defined(USE_32BIT_REF)
+          Emit("0x4\n"); /* Fix it in runtime, __BindingProtectRegion__ + kBindingStateDataDef:4. */
+#else
+          Emit("__BindingProtectRegion__ + 4\n");
+#endif  /* USE_32BIT_REF */
+        }
+      } else {
+#if defined(USE_32BIT_REF)
+#if defined(MPL_LNK_ADDRESS_VIA_BASE)
+        Emit(symAddrName + "\n");
+#else /* MPL_LNK_ADDRESS_VIA_BASE */
+        Emit(symAddrName + "-.\n");
+#endif /* MPL_LNK_ADDRESS_VIA_BASE */
+#else /* USE_32BIT_REF */
+        Emit(symAddrName + "\n");
+#endif /* USE_32BIT_REF */
+      }
+    }
+    return;
+  }
+
+  if (idx == kDataDefAddrIndex && mirSymbol.IsMuidDataDefOrigTab()) {
+    if (CGOptions::IsLazyBinding() && !cg->IsLibcore()) {
+#if defined(USE_32BIT_REF)
+      Emit("\t.long\t");
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+      EmitAsmLabel(kAsmQuad);
+#else
+      Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+
+#if defined(USE_32BIT_REF)
+#if defined(MPL_LNK_ADDRESS_VIA_BASE)
+      Emit(symAddrName + "\n");
+#else /* MPL_LNK_ADDRESS_VIA_BASE */
+      Emit(symAddrName + "-.\n");
+#endif /* MPL_LNK_ADDRESS_VIA_BASE */
+#else /* USE_32BIT_REF */
+      Emit(symAddrName + "\n");
+#endif /* USE_32BIT_REF */
+    }
+    return;
+  }
+
+  if (StringUtils::StartsWith(stName, kLocalClassInfoStr)) {
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+    Emit(symAddrName);
+    Emit(" - . + ").Emit(kDataRefIsOffset);
+    Emit("\n");
+    return;
+  }
+#ifdef USE_32BIT_REF
+  if (mirSymbol.IsReflectionHashTabBucket() || (stName.find(ITAB_PREFIX_STR) == 0) ||
+      (mirSymbol.IsReflectionClassInfo() && (idx == static_cast<uint32>(ClassProperty::kInfoRo)))) {
+    Emit("\t.word\t");
+  } else {
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+  }
+#else
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word\t");
+#endif
+
+#endif  /* USE_32BIT_REF */
+
+  if ((stName.find(ITAB_CONFLICT_PREFIX_STR) == 0) || (stName.find(ITAB_PREFIX_STR) == 0)) {
+    Emit(symAddrName + " - .\n");
+    return;
+  }
+  if (mirSymbol.IsMuidRangeTab()) {
+    if (idx == kRangeBeginIndex) {
+      Emit(symAddrSym->GetMuidTabName() + "_begin\n");
+    } else {
+      Emit(symAddrSym->GetMuidTabName() + "_end\n");
+    }
+    return;
+  }
+
+  if (symAddrName.find(GCTIB_PREFIX_STR) == 0) {
+    Emit(cg->FindGCTIBPatternName(symAddrName));
+  } else {
+    Emit(symAddrName);
+  }
+
+  if ((((idx == static_cast<uint32>(ClassRO::kIfields)) || (idx == static_cast<uint32>(ClassRO::kMethods))) &&
+       mirSymbol.IsReflectionClassInfoRO()) ||
+       mirSymbol.IsReflectionHashTabBucket()) {
+    Emit(" - .");
+    if (symAddrSym->IsReflectionFieldsInfoCompact() ||
+        symAddrSym->IsReflectionMethodsInfoCompact()) {
+      /* Mark the least significant bit as 1 for compact fieldinfo */
+      Emit(" + ").Emit(MethodFieldRef::kMethodFieldRefIsCompact);
+    }
+  } else if (mirSymbol.IsReflectionClassInfo()) {
+    if ((idx == static_cast<uint32>(ClassProperty::kItab)) ||
+        (idx == static_cast<uint32>(ClassProperty::kVtab)) ||
+        (idx == static_cast<uint32>(ClassProperty::kInfoRo))) {
+      Emit(" - . + ").Emit(kDataRefIsOffset);
+    } else if (idx == static_cast<uint32>(ClassProperty::kGctib)) {
+      if (cg->FindGCTIBPatternName(symAddrName).find(REF_PREFIX_STR) == 0) {
+        Emit(" - . + ").Emit(kGctibRefIsIndirect);
+      } else {
+        Emit(" - .");
+      }
+    }
+  } else if (mirSymbol.IsReflectionClassInfoRO()) {
+    if (idx == static_cast<uint32>(ClassRO::kSuperclass)) {
+      Emit(" - . + ").Emit(kDataRefIsOffset);
+    }
+  }
+
+  if (cg->GetCGOptions().GeneratePositionIndependentExecutable()) {
+    Emit(" - ");
+    Emit(stName);
+  }
+  Emit("\n");
+}
+
+MIRAddroffuncConst *Emitter::GetAddroffuncConst(const MIRSymbol &mirSymbol, MIRAggConst &aggConst) const {
+  MIRAddroffuncConst *innerFuncAddr = nullptr;
+  size_t addrIndex = mirSymbol.IsReflectionMethodsInfo() ? static_cast<size_t>(MethodProperty::kPaddrData) :
+      static_cast<size_t>(MethodInfoCompact::kPaddrData);
+  MIRConst *pAddrConst = aggConst.GetConstVecItem(addrIndex);
+  if (pAddrConst->GetKind() == kConstAddrof) {
+    /* point addr data. */
+    MIRAddrofConst *pAddr = safe_cast<MIRAddrofConst>(pAddrConst);
+    MIRSymbol *symAddrSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(pAddr->GetSymbolIndex().Idx());
+    MIRAggConst *methodAddrAggConst = safe_cast<MIRAggConst>(symAddrSym->GetKonst());
+    MIRAggConst *addrAggConst = safe_cast<MIRAggConst>(methodAddrAggConst->GetConstVecItem(0));
+    MIRConst *funcAddrConst = addrAggConst->GetConstVecItem(0);
+    if (funcAddrConst->GetKind() == kConstAddrofFunc) {
+      /* func sybmol. */
+      innerFuncAddr = safe_cast<MIRAddroffuncConst>(funcAddrConst);
+    } else if (funcAddrConst->GetKind() == kConstInt) {
+      /* def table index, replaced by def table for lazybinding. */
+      std::string funcDefTabName = namemangler::kMuidFuncDefTabPrefixStr + cg->GetMIRModule()->GetFileNameAsPostfix();
+      MIRSymbol *funDefTabSy = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+          GlobalTables::GetStrTable().GetStrIdxFromName(funcDefTabName));
+      MIRAggConst &funDefTabAggConst = static_cast<MIRAggConst&>(*funDefTabSy->GetKonst());
+      MIRIntConst *funcAddrIndexConst = safe_cast<MIRIntConst>(funcAddrConst);
+      uint64 indexDefTab = static_cast<uint64_t>(funcAddrIndexConst->GetExtValue());
+      MIRAggConst *defTabAggConst = safe_cast<MIRAggConst>(funDefTabAggConst.GetConstVecItem(indexDefTab));
+      MIRConst *funcConst = defTabAggConst->GetConstVecItem(0);
+      if (funcConst->GetKind() == kConstAddrofFunc) {
+        innerFuncAddr = safe_cast<MIRAddroffuncConst>(funcConst);
+      }
+    }
+  } else if (pAddrConst->GetKind() == kConstAddrofFunc) {
+    innerFuncAddr = safe_cast<MIRAddroffuncConst>(pAddrConst);
+  }
+  return innerFuncAddr;
+}
+
+int64 Emitter::GetFieldOffsetValue(const std::string &className, const MIRIntConst &intConst,
+                                   const std::map<GStrIdx, MIRType*> &strIdx2Type) const {
+  uint64 idx = static_cast<uint64_t>(intConst.GetExtValue());
+  bool isDefTabIndex = ((idx & 0x1) != 0);
+  int64 fieldIdx = static_cast<int64>(idx >> 1);
+  if (isDefTabIndex) {
+    /* it's def table index. */
+    return fieldIdx;
+  } else {
+    /* really offset. */
+    uint8 charBitWidth = GetPrimTypeSize(PTY_i8) * kBitsPerByte;
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(className);
+    auto it = strIdx2Type.find(strIdx);
+    CHECK_FATAL(it->second != nullptr, "valid iterator check");
+    ASSERT(it != strIdx2Type.end(), "Can not find type");
+    MIRType &ty = *it->second;
+    MIRStructType &structType = static_cast<MIRStructType&>(ty);
+    std::pair<int32, int32> fieldOffsetPair =
+        Globals::GetInstance()->GetBECommon()->GetFieldOffset(structType, fieldIdx);
+    int64 fieldOffset = fieldOffsetPair.first * static_cast<int64>(charBitWidth) + fieldOffsetPair.second;
+    return fieldOffset;
+  }
+}
+
+void Emitter::InitRangeIdx2PerfixStr() {
+  rangeIdx2PrefixStr[RangeIdx::kVtabAndItab] = kMuidVtabAndItabPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kItabConflict] = kMuidItabConflictPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kVtabOffset] = kMuidVtabOffsetPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kFieldOffset] = kMuidFieldOffsetPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kValueOffset] = kMuidValueOffsetPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kLocalClassInfo] = kMuidLocalClassInfoStr;
+  rangeIdx2PrefixStr[RangeIdx::kConststr] = kMuidConststrPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kSuperclass] = kMuidSuperclassPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kGlobalRootlist] = kMuidGlobalRootlistPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kClassmetaData] = kMuidClassMetadataPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kClassBucket] = kMuidClassMetadataBucketPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kJavatext] = kMuidJavatextPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kDataSection] = kMuidDataSectionStr;
+  rangeIdx2PrefixStr[RangeIdx::kJavajni] = kRegJNITabPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kJavajniFunc] = kRegJNIFuncTabPrefixStr;
+  rangeIdx2PrefixStr[RangeIdx::kDecoupleStaticKey] = kDecoupleStaticKeyStr;
+  rangeIdx2PrefixStr[RangeIdx::kDecoupleStaticValue] = kDecoupleStaticValueStr;
+  rangeIdx2PrefixStr[RangeIdx::kBssStart] = kBssSectionStr;
+  rangeIdx2PrefixStr[RangeIdx::kLinkerSoHash] = kLinkerHashSoStr;
+  rangeIdx2PrefixStr[RangeIdx::kArrayClassCache] = kArrayClassCacheTable;
+  rangeIdx2PrefixStr[RangeIdx::kArrayClassCacheName] = kArrayClassCacheNameTable;
+}
+
+void Emitter::EmitIntConst(const MIRSymbol &mirSymbol, MIRAggConst &aggConst, uint32 itabConflictIndex,
+                           const std::map<GStrIdx, MIRType*> &strIdx2Type, size_t idx) {
+  MIRConst *elemConst = aggConst.GetConstVecItem(idx);
+  const std::string stName = mirSymbol.GetName();
+
+  MIRIntConst *intConst = safe_cast<MIRIntConst>(elemConst);
+  ASSERT(intConst != nullptr, "Uexpected const type");
+
+  /* ignore abstract function addr */
+  if ((idx == static_cast<uint32>(MethodInfoCompact::kPaddrData)) && mirSymbol.IsReflectionMethodsInfoCompact()) {
+    return;
+  }
+
+  if (((idx == static_cast<uint32>(MethodProperty::kVtabIndex)) && (mirSymbol.IsReflectionMethodsInfo())) ||
+      ((idx == static_cast<uint32>(MethodInfoCompact::kVtabIndex)) && mirSymbol.IsReflectionMethodsInfoCompact())) {
+    MIRAddroffuncConst *innerFuncAddr = GetAddroffuncConst(mirSymbol, aggConst);
+    if (innerFuncAddr != nullptr) {
+      Emit(".Label.name." + GlobalTables::GetFunctionTable().GetFunctionFromPuidx(
+          innerFuncAddr->GetValue())->GetName());
+      Emit(":\n");
+    }
+  }
+  /* refer to DeCouple::GenOffsetTableType */
+  constexpr int fieldTypeIdx = 2;
+  constexpr int methodTypeIdx = 2;
+  bool isClassInfo = (idx == static_cast<uint32>(ClassRO::kClassName) ||
+                      idx == static_cast<uint32>(ClassRO::kAnnotation)) && mirSymbol.IsReflectionClassInfoRO();
+  bool isMethodsInfo = (idx == static_cast<uint32>(MethodProperty::kMethodName) ||
+                        idx == static_cast<uint32>(MethodProperty::kSigName) ||
+                        idx == static_cast<uint32>(MethodProperty::kAnnotation)) && mirSymbol.IsReflectionMethodsInfo();
+  bool isFieldsInfo = (idx == static_cast<uint32>(FieldProperty::kTypeName) ||
+                       idx == static_cast<uint32>(FieldProperty::kName) ||
+                       idx == static_cast<uint32>(FieldProperty::kAnnotation)) && mirSymbol.IsReflectionFieldsInfo();
+  bool isMethodSignature = (idx == static_cast<uint32>(MethodSignatureProperty::kSignatureOffset)) &&
+                            mirSymbol.IsReflectionMethodSignature();
+  /* RegisterTable has been Int Array, visit element instead of field. */
+  bool isInOffsetTab = (idx == 1 || idx == methodTypeIdx) &&
+                       (StringUtils::StartsWith(stName, kVtabOffsetTabStr) ||
+                        StringUtils::StartsWith(stName, kFieldOffsetTabStr));
+  /* The 1 && 2 of Decouple static struct is the string name */
+  bool isStaticStr = (idx == 1 || idx == 2) && aggConst.GetConstVec().size() == kSizeOfDecoupleStaticStruct &&
+                     StringUtils::StartsWith(stName, kDecoupleStaticKeyStr);
+  /* process conflict table index larger than itabConflictIndex * 2 + 2 element */
+  bool isConflictPerfix = (idx >= (static_cast<uint64>(itabConflictIndex) * 2 + 2)) && (idx % 2 == 0) &&
+                          StringUtils::StartsWith(stName, ITAB_CONFLICT_PREFIX_STR);
+  bool isArrayClassCacheName = mirSymbol.IsArrayClassCacheName();
+  if (isClassInfo || isMethodsInfo || isFieldsInfo || mirSymbol.IsRegJNITab() || isInOffsetTab ||
+      isStaticStr || isConflictPerfix || isArrayClassCacheName || isMethodSignature) {
+    /* compare with all 1s */
+    uint32 index = static_cast<uint32>((safe_cast<MIRIntConst>(elemConst))->GetExtValue()) & 0xFFFFFFFF;
+    bool isHotReflectStr = (index & 0x00000003) != 0;     /* use the last two bits of index in this expression */
+    std::string hotStr;
+    if (isHotReflectStr) {
+      uint32 tag = (index & 0x00000003) - kCStringShift;  /* use the last two bits of index in this expression */
+      if (tag == kLayoutBootHot) {
+        hotStr = kReflectionStartHotStrtabPrefixStr;
+      } else if (tag == kLayoutBothHot) {
+        hotStr = kReflectionBothHotStrTabPrefixStr;
+      } else {
+        hotStr = kReflectionRunHotStrtabPrefixStr;
+      }
+    }
+    std::string reflectStrTabPrefix = isHotReflectStr ? hotStr : kReflectionStrtabPrefixStr;
+    std::string strTabName = reflectStrTabPrefix + cg->GetMIRModule()->GetFileNameAsPostfix();
+    /* left shift 2 bit to get low 30 bit data for MIRIntConst */
+    elemConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(index >> 2, elemConst->GetType());
+    intConst = safe_cast<MIRIntConst>(elemConst);
+    aggConst.SetItem(static_cast<uint32>(idx), intConst, aggConst.GetFieldIdItem(idx));
+#ifdef USE_32BIT_REF
+    if (stName.find(ITAB_CONFLICT_PREFIX_STR) == 0) {
+      EmitScalarConstant(*elemConst, false, true);
+    } else {
+      EmitScalarConstant(*elemConst, false);
+    }
+#else
+    EmitScalarConstant(*elemConst, false);
+#endif  /* USE_32BIT_REF */
+    Emit("+" + strTabName);
+    if (mirSymbol.IsRegJNITab() || mirSymbol.IsReflectionMethodsInfo() || mirSymbol.IsReflectionFieldsInfo() ||
+        mirSymbol.IsArrayClassCacheName() || mirSymbol.IsReflectionMethodSignature()) {
+      Emit("-.");
+    }
+    if (StringUtils::StartsWith(stName, kDecoupleStaticKeyStr)) {
+      Emit("-.");
+    }
+    if (mirSymbol.IsReflectionClassInfoRO()) {
+      if (idx == static_cast<uint32>(ClassRO::kAnnotation)) {
+        Emit("-.");
+      } else if (idx == static_cast<uint32>(ClassRO::kClassName)) {
+        /* output in hex format to show it is a flag of bits. */
+        std::stringstream ss;
+        ss << std::hex << "0x" << MByteRef::kPositiveOffsetBias;
+        Emit(" - . + " + ss.str());
+      }
+    }
+    if (StringUtils::StartsWith(stName, ITAB_PREFIX_STR)) {
+      Emit("-.");
+    }
+    if (StringUtils::StartsWith(stName, ITAB_CONFLICT_PREFIX_STR)) {
+      /* output in hex format to show it is a flag of bits. */
+      std::stringstream ss;
+      ss << std::hex << "0x" << MByteRef32::kPositiveOffsetBias;
+      Emit(" - . + " + ss.str());
+    }
+    if ((idx == 1 || idx == methodTypeIdx) && StringUtils::StartsWith(stName, kVtabOffsetTabStr)) {
+      Emit("-.");
+    }
+    if ((idx == 1 || idx == fieldTypeIdx) && StringUtils::StartsWith(stName, kFieldOffsetTabStr)) {
+      Emit("-.");
+    }
+    Emit("\n");
+  } else if (idx == kFuncDefAddrIndex && mirSymbol.IsMuidFuncUndefTab()) {
+#if defined(USE_32BIT_REF)
+    Emit("\t.long\t");
+#else
+    EmitAsmLabel(kAsmQuad);
+#endif  /* USE_32BIT_REF */
+    if (CGOptions::IsLazyBinding() && !cg->IsLibcore()) {
+      /*
+       * Check enum BindingState defined in Mpl_Binding.h,
+       * 5 means kBindingStateMethodUndef:5 offset away from base __BindingProtectRegion__.
+       */
+#if defined(USE_32BIT_REF)
+      Emit("0x5\n");  /* Fix it in runtime, __BindingProtectRegion__ + kBindingStateMethodUndef:5. */
+#else
+      Emit("__BindingProtectRegion__ + 5\n");
+#endif  /* USE_32BIT_REF */
+    } else {
+      Emit("0\n");
+    }
+  } else if (idx == static_cast<uint32>(FieldProperty::kPClassType) && mirSymbol.IsReflectionFieldsInfo()) {
+#ifdef USE_32BIT_REF
+    Emit("\t.long\t");
+    const int width = 4;
+#else
+    EmitAsmLabel(kAsmQuad);
+    const int width = 8;
+#endif  /* USE_32BIT_REF */
+    uint32 muidDataTabAddr = static_cast<uint32>((safe_cast<MIRIntConst>(elemConst))->GetExtValue());
+    if (muidDataTabAddr != 0) {
+      bool isDefTabIndex = (muidDataTabAddr & kFromDefIndexMask32Mod) == kFromDefIndexMask32Mod;
+      std::string muidDataTabPrefix = isDefTabIndex ? kMuidDataDefTabPrefixStr : kMuidDataUndefTabPrefixStr;
+      std::string muidDataTabName = muidDataTabPrefix + cg->GetMIRModule()->GetFileNameAsPostfix();
+      (void)Emit(muidDataTabName + "+");
+      uint32 muidDataTabIndex = muidDataTabAddr & 0x3FFFFFFF; /* high 2 bit is the mask of muid tab */
+      (void)Emit(std::to_string(muidDataTabIndex * width));
+      (void)Emit("-.\n");
+    } else {
+      (void)Emit(muidDataTabAddr);
+      Emit("\n");
+    }
+    return;
+  } else if (mirSymbol.IsRegJNIFuncTab()) {
+    std::string strTabName = kRegJNITabPrefixStr + cg->GetMIRModule()->GetFileNameAsPostfix();
+    EmitScalarConstant(*elemConst, false);
+#ifdef TARGARM32
+    (void)Emit("+" + strTabName).Emit("+").Emit(MByteRef::kPositiveOffsetBias).Emit("-.\n");
+#else
+    Emit("+" + strTabName + "\n");
+#endif
+  } else if (mirSymbol.IsReflectionMethodAddrData()) {
+#ifdef USE_32BIT_REF
+    Emit("\t.long\t");
+#else
+    EmitAsmLabel(kAsmQuad);
+#endif  /* USE_32BIT_REF */
+    Emit(intConst->GetValue());
+    Emit("\n");
+  } else if (mirSymbol.IsReflectionFieldOffsetData()) {
+    /* Figure out instance field offset now. */
+    size_t prefixStrLen = strlen(kFieldOffsetDataPrefixStr);
+    size_t pos = stName.find("_FieldID_");
+    std::string typeName = stName.substr(prefixStrLen, pos - prefixStrLen);
+#ifdef USE_32BIT_REF
+    std::string widthFlag = ".long";
+#else
+    std::string widthFlag = ".quad";
+#endif  /* USE_32BIT_REF */
+    int64 fieldOffset = GetFieldOffsetValue(typeName, *intConst, strIdx2Type);
+    uint64 fieldIdx = static_cast<uint64_t>(intConst->GetExtValue());
+    bool isDefTabIndex = ((fieldIdx & 0x1) != 0);
+    if (isDefTabIndex) {
+      /* it's def table index. */
+      Emit("\t//  " + typeName + " static field, data def table index " + std::to_string(fieldOffset) + "\n");
+    } else {
+      /* really offset. */
+      fieldIdx >>= 1;
+      Emit("\t//  " + typeName + "\t field" + std::to_string(fieldIdx) + "\n");
+    }
+    Emit("\t" + widthFlag + "\t" + std::to_string(fieldOffset) + "\n");
+  } else if (((idx == static_cast<uint32>(FieldProperty::kPOffset)) && mirSymbol.IsReflectionFieldsInfo()) ||
+             ((idx == static_cast<uint32>(FieldPropertyCompact::kPOffset)) &&
+              mirSymbol.IsReflectionFieldsInfoCompact())) {
+    std::string typeName;
+    std::string widthFlag;
+#ifdef USE_32BIT_REF
+    const int width = 4;
+#else
+    const int width = 8;
+#endif  /* USE_32BIT_REF */
+    if (mirSymbol.IsReflectionFieldsInfo()) {
+      typeName = stName.substr(strlen(kFieldsInfoPrefixStr));
+#ifdef USE_32BIT_REF
+      widthFlag = ".long";
+#else
+      widthFlag = ".quad";
+#endif  /* USE_32BIT_REF */
+    } else {
+      size_t prefixStrLen = strlen(kFieldsInfoCompactPrefixStr);
+      typeName = stName.substr(prefixStrLen);
+      widthFlag = ".long";
+    }
+    int64 fieldIdx = intConst->GetExtValue();
+    MIRSymbol *pOffsetData = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+        GlobalTables::GetStrTable().GetStrIdxFromName(kFieldOffsetDataPrefixStr + typeName));
+    if (pOffsetData != nullptr) {
+      fieldIdx *= width;
+      std::string fieldOffset = kFieldOffsetDataPrefixStr + typeName;
+      Emit("\t" + widthFlag + "\t" + std::to_string(fieldIdx) + " + " + fieldOffset + " - .\n");
+    } else {
+      /* pOffsetData null, means FieldMeta.offset is really offset */
+      int64 fieldOffset = GetFieldOffsetValue(typeName, *intConst, strIdx2Type);
+      Emit("\t//  " + typeName + "\t field" + std::to_string(fieldIdx) + "\n");
+      Emit("\t" + widthFlag + "\t" + std::to_string(fieldOffset) + "\n");
+    }
+  } else if ((idx == static_cast<uint32>(ClassProperty::kObjsize)) && mirSymbol.IsReflectionClassInfo()) {
+    std::string delimiter = "$$";
+    std::string typeName =
+        stName.substr(strlen(CLASSINFO_PREFIX_STR), stName.find(delimiter) - strlen(CLASSINFO_PREFIX_STR));
+    uint32 objSize = 0;
+    std::string comments;
+
+    if (typeName.size() > 1 && typeName[0] == '$') {
+      /* fill element size for array class; */
+      std::string newTypeName = typeName.substr(1);
+      /* another $(arraysplitter) */
+      if (newTypeName.find("$") == std::string::npos) {
+        CHECK_FATAL(false, "can not find $ in std::string");
+      }
+      typeName = newTypeName.substr(newTypeName.find("$") + 1);
+      int32 pTypeSize;
+
+      /* we only need to calculate primitive type in arrays. */
+      if ((pTypeSize = GetPrimitiveTypeSize(typeName)) != -1) {
+        objSize = static_cast<uint32>(pTypeSize);
+      }
+      comments = "// elemobjsize";
+    } else {
+      comments = "// objsize";
+    }
+
+    if (objSize == 0) {
+      GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+      auto it = strIdx2Type.find(strIdx);
+      ASSERT(it != strIdx2Type.end(), "Can not find type");
+      MIRType *mirType = it->second;
+      ASSERT_NOT_NULL(mirType);
+      objSize = Globals::GetInstance()->GetBECommon()->GetTypeSize(mirType->GetTypeIndex());
+    }
+    /* objSize should not exceed 16 bits */
+    CHECK_FATAL(objSize <= 0xffff, "Error:the objSize is too large");
+    Emit("\t.short\t" + std::to_string(objSize) + comments + "\n");
+  } else if (mirSymbol.IsMuidRangeTab()) {
+    MIRIntConst *subIntCt = safe_cast<MIRIntConst>(elemConst);
+    int flag = static_cast<int>(subIntCt->GetExtValue());
+    InitRangeIdx2PerfixStr();
+    if (rangeIdx2PrefixStr.find(flag) == rangeIdx2PrefixStr.end()) {
+      EmitScalarConstant(*elemConst, false);
+      Emit("\n");
+      return;
+    }
+    std::string prefix = rangeIdx2PrefixStr[flag];
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    (void)Emit("\t.word\t");
+#endif
+    if (idx == kRangeBeginIndex) {
+      Emit(prefix + "_begin\n");
+    } else {
+      Emit(prefix + "_end\n");
+    }
+  } else {
+#ifdef USE_32BIT_REF
+    if (StringUtils::StartsWith(stName, ITAB_CONFLICT_PREFIX_STR) || StringUtils::StartsWith(stName, ITAB_PREFIX_STR) ||
+        StringUtils::StartsWith(stName, VTAB_PREFIX_STR)) {
+      EmitScalarConstant(*elemConst, false, true);
+    } else {
+      EmitScalarConstant(*elemConst, false);
+    }
+#else
+    EmitScalarConstant(*elemConst, false);
+#endif  /* USE_32BIT_REF */
+    Emit("\n");
+  }
+}
+
+void Emitter::EmitConstantTable(const MIRSymbol &mirSymbol, MIRConst &mirConst,
+                                const std::map<GStrIdx, MIRType*> &strIdx2Type) {
+  const std::string stName = mirSymbol.GetName();
+  MIRAggConst &aggConst = static_cast<MIRAggConst&>(mirConst);
+  uint32 itabConflictIndex = 0;
+  for (size_t i = 0; i < aggConst.GetConstVec().size(); ++i) {
+    MIRConst *elemConst = aggConst.GetConstVecItem(i);
+    if (i == 0 && StringUtils::StartsWith(stName, ITAB_CONFLICT_PREFIX_STR)) {
+#ifdef USE_32BIT_REF
+      itabConflictIndex = static_cast<uint64>((safe_cast<MIRIntConst>(elemConst))->GetValue()) & 0xffff;
+#else
+      itabConflictIndex = safe_cast<MIRIntConst>(elemConst)->GetExtValue() & 0xffffffff;
+#endif
+    }
+    if (IsPrimitiveScalar(elemConst->GetType().GetPrimType())) {
+      if (elemConst->GetKind() == kConstAddrofFunc) {     /* addroffunc const */
+        EmitAddrofFuncConst(mirSymbol, *elemConst, i);
+      } else if (elemConst->GetKind() == kConstAddrof) {  /* addrof symbol const */
+        EmitAddrofSymbolConst(mirSymbol, *elemConst, i);
+      } else {                                            /* intconst */
+        EmitIntConst(mirSymbol, aggConst, itabConflictIndex, strIdx2Type, i);
+      }
+    } else if (elemConst->GetType().GetKind() == kTypeArray || elemConst->GetType().GetKind() == kTypeStruct) {
+      if (StringUtils::StartsWith(mirSymbol.GetName(), namemangler::kOffsetTabStr) && (i == 0 || i == 1)) {
+        /* EmitOffsetValueTable */
+#ifdef USE_32BIT_REF
+        Emit("\t.long\t");
+#else
+        EmitAsmLabel(kAsmQuad);
+#endif
+        if (i == 0) {
+          (void)Emit(namemangler::kVtabOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
+        } else {
+          (void)Emit(namemangler::kFieldOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
+        }
+      } else {
+        EmitConstantTable(mirSymbol, *elemConst, strIdx2Type);
+      }
+    }
+  }
+}
+
+void Emitter::EmitArrayConstant(MIRConst &mirConst) {
+  MIRType &mirType = mirConst.GetType();
+  MIRAggConst &arrayCt = static_cast<MIRAggConst&>(mirConst);
+  MIRArrayType &arrayType = static_cast<MIRArrayType&>(mirType);
+  size_t uNum = arrayCt.GetConstVec().size();
+  uint32 dim = arrayType.GetSizeArrayItem(0);
+  TyIdx scalarIdx = arrayType.GetElemTyIdx();
+  MIRType *subTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(scalarIdx);
+  if (uNum == 0 && dim != 0) {
+    while (subTy->GetKind() == kTypeArray) {
+      MIRArrayType *aSubTy = static_cast<MIRArrayType *>(subTy);
+      if (aSubTy->GetSizeArrayItem(0) > 0) {
+        dim *= (aSubTy->GetSizeArrayItem(0));
+      }
+      scalarIdx = aSubTy->GetElemTyIdx();
+      subTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(scalarIdx);
+    }
+  }
+  for (size_t i = 0; i < uNum; ++i) {
+    MIRConst *elemConst = arrayCt.GetConstVecItem(i);
+    if (IsPrimitiveVector(subTy->GetPrimType())) {
+      EmitVectorConstant(*elemConst);
+    } else if (IsPrimitiveScalar(elemConst->GetType().GetPrimType())) {
+      if (cg->GetMIRModule()->IsCModule()) {
+        bool strLiteral = false;
+        if (arrayType.GetDim() == 1) {
+          MIRType *ety = arrayType.GetElemType();
+          if (ety->GetPrimType() == PTY_i8 || ety->GetPrimType() == PTY_u8) {
+            strLiteral = true;
+          }
+        }
+        EmitScalarConstant(*elemConst, true, false, strLiteral == false);
+      } else {
+        EmitScalarConstant(*elemConst);
+      }
+    } else if (elemConst->GetType().GetKind() == kTypeArray) {
+      EmitArrayConstant(*elemConst);
+    } else if (elemConst->GetType().GetKind() == kTypeStruct || elemConst->GetType().GetKind() == kTypeClass ||
+               elemConst->GetType().GetKind() == kTypeUnion) {
+      EmitStructConstant(*elemConst);
+    } else if (elemConst->GetKind() == kConstAddrofFunc) {
+      EmitScalarConstant(*elemConst);
+    } else {
+      ASSERT(false, "should not run here");
+    }
+  }
+  int64 iNum = (arrayType.GetSizeArrayItem(0) > 0) ? (static_cast<int64>(arrayType.GetSizeArrayItem(0))) - uNum : 0;
+  if (iNum > 0) {
+    if (!cg->GetMIRModule()->IsCModule()) {
+      CHECK_FATAL(!Globals::GetInstance()->GetBECommon()->IsEmptyOfTypeSizeTable(), "container empty check");
+      CHECK_FATAL(!arrayCt.GetConstVec().empty(), "container empty check");
+    }
+    if (uNum > 0) {
+      uint64 unInSizeInByte = static_cast<uint64>(iNum) * static_cast<uint64>(
+          Globals::GetInstance()->GetBECommon()->GetTypeSize(arrayCt.GetConstVecItem(0)->GetType().GetTypeIndex()));
+      if (unInSizeInByte != 0) {
+        EmitNullConstant(unInSizeInByte);
+      }
+    } else {
+      uint64 size = Globals::GetInstance()->GetBECommon()->GetTypeSize(scalarIdx.GetIdx()) * dim;
+      Emit("\t.zero\t").Emit(static_cast<int64>(size)).Emit("\n");
+    }
+  }
+}
+
+void Emitter::EmitVectorConstant(MIRConst &mirConst) {
+  MIRType &mirType = mirConst.GetType();
+  MIRAggConst &vecCt = static_cast<MIRAggConst&>(mirConst);
+  size_t uNum = vecCt.GetConstVec().size();
+  for (size_t i = 0; i < uNum; ++i) {
+    MIRConst *elemConst = vecCt.GetConstVecItem(i);
+    if (IsPrimitiveScalar(elemConst->GetType().GetPrimType())) {
+      bool strLiteral = false;
+      EmitScalarConstant(*elemConst, true, false, strLiteral == false);
+    } else {
+      ASSERT(false, "should not run here");
+    }
+  }
+  size_t lanes = GetVecLanes(mirType.GetPrimType());
+  if (lanes > uNum) {
+    MIRIntConst zConst(0, vecCt.GetConstVecItem(0)->GetType());
+    for (size_t i = uNum; i < lanes; i++) {
+      EmitScalarConstant(zConst, true, false, false);
+    }
+  }
+}
+
+void Emitter::EmitStructConstant(MIRConst &mirConst) {
+  uint32 subStructFieldCounts = 0;
+  EmitStructConstant(mirConst, subStructFieldCounts);
+}
+
+void Emitter::EmitStructConstant(MIRConst &mirConst, uint32 &subStructFieldCounts) {
+  StructEmitInfo *sEmitInfo = cg->GetMIRModule()->GetMemPool()->New<StructEmitInfo>();
+  CHECK_FATAL(sEmitInfo != nullptr, "create a new struct emit info failed in Emitter::EmitStructConstant");
+  MIRType &mirType = mirConst.GetType();
+  MIRAggConst &structCt = static_cast<MIRAggConst&>(mirConst);
+  MIRStructType &structType = static_cast<MIRStructType&>(mirType);
+  auto structPack = static_cast<uint8>(structType.GetTypeAttrs().GetPack());
+  /* all elements of struct. */
+  uint8 num;
+  if (structType.GetKind() == kTypeUnion) {
+    num = 1;
+  } else {
+    num = static_cast<uint8>(structType.GetFieldsSize());
+  }
+  BECommon *beCommon = Globals::GetInstance()->GetBECommon();
+  /* total size of emitted elements size. */
+  uint32 size = beCommon->GetTypeSize(structType.GetTypeIndex());
+  uint32 fieldIdx = 1;
+  if (structType.GetKind() == kTypeUnion) {
+    fieldIdx = structCt.GetFieldIdItem(0);
+  }
+  for (uint32 i = 0; i < num; ++i) {
+    if (((i + 1) == num) && cg->GetMIRModule()->GetSrcLang() == kSrcLangC) {
+      isFlexibleArray = beCommon->GetHasFlexibleArray(mirType.GetTypeIndex().GetIdx());
+      arraySize = 0;
+    }
+    MIRConst *elemConst;
+    if (structType.GetKind() == kTypeStruct) {
+      elemConst = structCt.GetAggConstElement(i + 1);
+    } else {
+      elemConst = structCt.GetAggConstElement(fieldIdx);
+    }
+    MIRType *elemType = structType.GetElemType(i);
+    if (structType.GetKind() == kTypeUnion) {
+      elemType = &(elemConst->GetType());
+    }
+    MIRType *nextElemType = nullptr;
+    if (i != static_cast<uint32>(num - 1)) {
+      nextElemType = structType.GetElemType(i + 1);
+    }
+    uint64 elemSize = beCommon->GetTypeSize(elemType->GetTypeIndex());
+    uint8 charBitWidth = GetPrimTypeSize(PTY_i8) * kBitsPerByte;
+    if (elemType->GetKind() == kTypeBitField) {
+      if (elemConst == nullptr) {
+        MIRIntConst *zeroFill = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *elemType);
+        elemConst = zeroFill;
+      }
+      uint64 fieldOffset = static_cast<uint64>(static_cast<int64>(beCommon->GetFieldOffset(
+          structType, fieldIdx).first)) * static_cast<uint64>(charBitWidth) + static_cast<uint64>(
+          static_cast<int64>(beCommon->GetFieldOffset(structType, fieldIdx).second));
+      EmitBitFieldConstant(*sEmitInfo, *elemConst, nextElemType, fieldOffset);
+    } else {
+      if (elemConst != nullptr) {
+        if (IsPrimitiveVector(elemType->GetPrimType())) {
+          EmitVectorConstant(*elemConst);
+        } else if (IsPrimitiveScalar(elemType->GetPrimType())) {
+          EmitScalarConstant(*elemConst, true, false, true);
+        } else if (elemType->GetKind() == kTypeArray) {
+          if (elemType->GetSize() != 0) {
+            EmitArrayConstant(*elemConst);
+          }
+        } else if ((elemType->GetKind() == kTypeStruct) || (elemType->GetKind() == kTypeClass) ||
+                   (elemType->GetKind() == kTypeUnion)) {
+          EmitStructConstant(*elemConst, subStructFieldCounts);
+          fieldIdx += subStructFieldCounts;
+        } else {
+          ASSERT(false, "should not run here");
+        }
+      } else {
+        EmitNullConstant(elemSize);
+      }
+      sEmitInfo->IncreaseTotalSize(elemSize);
+      sEmitInfo->SetNextFieldOffset(sEmitInfo->GetTotalSize() * charBitWidth);
+    }
+
+    if (nextElemType != nullptr && kTypeBitField != nextElemType->GetKind()) {
+      ASSERT(i < static_cast<uint32>(num - 1), "NYI");
+      uint8 nextAlign = Globals::GetInstance()->GetBECommon()->GetTypeAlign(nextElemType->GetTypeIndex());
+      auto fieldAttr = structType.GetFields()[i + 1].second.second;
+      nextAlign = fieldAttr.IsPacked() ? 1 : std::min(nextAlign, structPack);
+      ASSERT(nextAlign != 0, "expect non-zero");
+      /* append size, append 0 when align need. */
+      uint64 totalSize = sEmitInfo->GetTotalSize();
+      uint64 psize = (totalSize % nextAlign == 0) ? 0 : (nextAlign - (totalSize % nextAlign));
+      if (psize != 0) {
+        EmitNullConstant(psize);
+        sEmitInfo->IncreaseTotalSize(psize);
+        sEmitInfo->SetNextFieldOffset(sEmitInfo->GetTotalSize() * charBitWidth);
+      }
+      /* element is uninitialized, emit null constant. */
+    }
+    fieldIdx++;
+  }
+  if (structType.GetKind() == kTypeStruct) {
+    /* The reason of subtracting one is that fieldIdx adds one at the end of the cycle. */
+    subStructFieldCounts = fieldIdx - 1;
+  } else if (structType.GetKind() == kTypeUnion) {
+    subStructFieldCounts = static_cast<uint32>(beCommon->GetStructFieldCount(structType.GetTypeIndex()));
+  }
+
+  isFlexibleArray = false;
+  uint64 opSize = size - sEmitInfo->GetTotalSize();
+  if (opSize != 0) {
+    EmitNullConstant(opSize);
+  }
+}
+
+/* BlockMarker is for Debugging/Profiling */
+void Emitter::EmitBlockMarker(const std::string &markerName, const std::string &sectionName,
+                              bool withAddr, const std::string &addrName) {
+  /*
+   * .type $marker_name$, %object
+   * .global $marker_name$
+   * .data
+   * .align 3
+   * $marker_name$:
+   * .quad 0xdeadbeefdeadbeef
+   * .size $marker_name$, 8
+   */
+  Emit(asmInfo->GetType());
+  Emit(markerName);
+  Emit(", %object\n");
+  if (CGOptions::IsEmitBlockMarker()) {  /* exposed as global symbol, for profiling */
+    Emit(asmInfo->GetGlobal());
+  } else {                               /* exposed as local symbol, for release. */
+    Emit(asmInfo->GetLocal());
+  }
+  Emit(markerName);
+  Emit("\n");
+
+  if (!sectionName.empty()) {
+    Emit("\t.section ." + sectionName);
+    if (sectionName.find("ro") == 0) {
+      Emit(",\"a\",%progbits\n");
+    } else {
+      Emit(",\"aw\",%progbits\n");
+    }
+  } else {
+    EmitAsmLabel(kAsmData);
+  }
+  Emit(asmInfo->GetAlign());
+#if TARGX86 || TARGX86_64
+  Emit("8\n" + markerName + ":\n");
+#else
+  Emit("3\n" + markerName + ":\n");
+#endif
+  EmitAsmLabel(kAsmQuad);
+  if (withAddr) {
+    Emit(addrName + "\n");
+  } else {
+    Emit("0xdeadbeefdeadbeef\n"); /* hexspeak in aarch64 represents crash or dead lock */
+  }
+  Emit(asmInfo->GetSize());
+  Emit(markerName + ", 8\n");
+}
+
+void Emitter::EmitLiteral(const MIRSymbol &literal, const std::map<GStrIdx, MIRType*> &strIdx2Type) {
+  /*
+   * .type _C_STR_xxxx, %object
+   * .local _C_STR_xxxx
+   * .data
+   * .align 3
+   * _C_STR_xxxx:
+   * .quad __cinf_Ljava_2Flang_2FString_3B
+   * ....
+   * .size _C_STR_xxxx, 40
+   */
+  if (literal.GetStorageClass() == kScUnused) {
+    return;
+  }
+  EmitAsmLabel(literal, kAsmType);
+  /* literal should always be fstatic and readonly? */
+  EmitAsmLabel(literal, kAsmLocal);  /* alwasy fstatic */
+  (void)Emit("\t.section\t." + std::string(kMapleLiteralString) + ",\"aw\", %progbits\n");
+  EmitAsmLabel(literal, kAsmAlign);
+  EmitAsmLabel(literal, kAsmSyname);
+  /* literal is an array */
+  MIRConst *mirConst = literal.GetKonst();
+  CHECK_FATAL(mirConst != nullptr, "mirConst should not be nullptr in EmitLiteral");
+  if (literal.HasAddrOfValues()) {
+    EmitConstantTable(literal, *mirConst, strIdx2Type);
+  } else {
+    EmitArrayConstant(*mirConst);
+  }
+  EmitAsmLabel(literal, kAsmSize);
+}
+
+void Emitter::EmitFuncLayoutInfo(const MIRSymbol &layout) {
+  /*
+   * .type $marker_name$, %object
+   * .global $marker_name$
+   * .data
+   * .align 3
+   * $marker_name$:
+   * .quad funcaddr
+   * .size $marker_name$, 8
+   */
+  MIRConst *mirConst = layout.GetKonst();
+  MIRAggConst *aggConst = safe_cast<MIRAggConst>(mirConst);
+  ASSERT(aggConst != nullptr, "null ptr check");
+  if (aggConst->GetConstVec().size() != static_cast<uint32>(LayoutType::kLayoutTypeCount)) {
+    maple::LogInfo::MapleLogger(kLlErr) << "something wrong happen in funclayoutsym\t"
+         << "constVec size\t" << aggConst->GetConstVec().size() << "\n";
+    return;
+  }
+  for (size_t i = 0; i < static_cast<size_t>(LayoutType::kLayoutTypeCount); ++i) {
+    std::string markerName = "__MBlock_" + GetLayoutTypeString(i) + "_func_start";
+    CHECK_FATAL(aggConst->GetConstVecItem(i)->GetKind() == kConstAddrofFunc, "expect kConstAddrofFunc type");
+    MIRAddroffuncConst *funcAddr = safe_cast<MIRAddroffuncConst>(aggConst->GetConstVecItem(i));
+    ASSERT(funcAddr != nullptr, "null ptr check");
+    Emit(asmInfo->GetType());
+    Emit(markerName + ", %object\n");
+    Emit(asmInfo->GetGlobal());
+    Emit(markerName + "\n");
+    EmitAsmLabel(kAsmData);
+#if TARGX86 || TARGX86_64
+    EmitAsmLabel(layout, kAsmAlign);
+    Emit(markerName + ":\n");
+#else
+    Emit(asmInfo->GetAlign());
+    Emit("3\n" + markerName + ":\n");
+#endif
+
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    EmitAsmLabel(kAsmQuad);
+#else
+    Emit("\t.word ");
+#endif
+    Emit(GlobalTables::GetFunctionTable().GetFunctionFromPuidx(funcAddr->GetValue())->GetName());
+    Emit("\n");
+    Emit(asmInfo->GetSize());
+    Emit(markerName + ", 8\n");
+  }
+}
+
+void Emitter::EmitStaticFields(const std::vector<MIRSymbol*> &fields) {
+  for (auto *itSymbol : fields) {
+    EmitAsmLabel(*itSymbol, kAsmType);
+    /* literal should always be fstatic and readonly? */
+    EmitAsmLabel(*itSymbol, kAsmLocal);  /* alwasy fstatic */
+    EmitAsmLabel(kAsmData);
+    EmitAsmLabel(*itSymbol, kAsmAlign);
+    EmitAsmLabel(*itSymbol, kAsmSyname);
+    /* literal is an array */
+    MIRConst *mirConst = itSymbol->GetKonst();
+    EmitArrayConstant(*mirConst);
+  }
+}
+
+void Emitter::EmitLiterals(std::vector<std::pair<MIRSymbol*, bool>> &literals,
+                           const std::map<GStrIdx, MIRType*> &strIdx2Type) {
+  /*
+   * load literals profile
+   * currently only used here, so declare it as local
+   */
+  if (cg->GetMIRModule()->GetProfile().GetLiteralProfileSize() == 0) {
+    for (const auto &literalPair : literals) {
+      EmitLiteral(*(literalPair.first), strIdx2Type);
+    }
+    return;
+  }
+  /* emit hot literal start symbol */
+  EmitBlockMarker("__MBlock_literal_hot_begin", "", false);
+  /*
+   * emit literals into .data section
+   * emit literals in the profile first
+   */
+  for (auto &literalPair : literals) {
+    if (cg->GetMIRModule()->GetProfile().CheckLiteralHot(literalPair.first->GetName())) {
+      /* it's in the literal profiling data, means it's "hot" */
+      EmitLiteral(*(literalPair.first), strIdx2Type);
+      literalPair.second = true;
+    }
+  }
+  /* emit hot literal end symbol */
+  EmitBlockMarker("__MBlock_literal_hot_end", "", false);
+
+  /* emit cold literal start symbol */
+  EmitBlockMarker("__MBlock_literal_cold_begin", "", false);
+  /* emit other literals (not in the profile) next. */
+  for (const auto &literalPair : literals) {
+    if (!literalPair.second) {
+      /* not emit yet */
+      EmitLiteral(*(literalPair.first), strIdx2Type);
+    }
+  }
+  /* emit cold literal end symbol */
+  EmitBlockMarker("__MBlock_literal_cold_end", "", false);
+}
+
+void Emitter::GetHotAndColdMetaSymbolInfo(const std::vector<MIRSymbol*> &mirSymbolVec,
+                                          std::vector<MIRSymbol*> &hotFieldInfoSymbolVec,
+                                          std::vector<MIRSymbol*> &coldFieldInfoSymbolVec, const std::string &prefixStr,
+                                          bool forceCold) const {
+  bool isHot = false;
+  for (auto mirSymbol : mirSymbolVec) {
+    CHECK_FATAL(prefixStr.length() < mirSymbol->GetName().length(), "string length check");
+    std::string name = mirSymbol->GetName().substr(prefixStr.length());
+    std::string klassJavaDescriptor;
+    namemangler::DecodeMapleNameToJavaDescriptor(name, klassJavaDescriptor);
+    if (prefixStr == kFieldsInfoPrefixStr) {
+      isHot = cg->GetMIRModule()->GetProfile().CheckFieldHot(klassJavaDescriptor);
+    } else if (prefixStr == kMethodsInfoPrefixStr) {
+      isHot = cg->GetMIRModule()->GetProfile().CheckMethodHot(klassJavaDescriptor);
+    } else {
+      isHot = cg->GetMIRModule()->GetProfile().CheckClassHot(klassJavaDescriptor);
+    }
+    if (isHot && !forceCold) {
+      hotFieldInfoSymbolVec.emplace_back(mirSymbol);
+    } else {
+      coldFieldInfoSymbolVec.emplace_back(mirSymbol);
+    }
+  }
+}
+
+void Emitter::EmitMetaDataSymbolWithMarkFlag(const std::vector<MIRSymbol*> &mirSymbolVec,
+                                             const std::map<GStrIdx, MIRType*> &strIdx2Type,
+                                             const std::string &prefixStr, const std::string &sectionName,
+                                             bool isHotFlag) {
+  if (cg->GetMIRModule()->IsCModule()) {
+    return;
+  }
+  if (mirSymbolVec.empty()) {
+    return;
+  }
+  const std::string &markString = "__MBlock" + prefixStr;
+  const std::string &hotOrCold = isHotFlag ? "hot" : "cold";
+  EmitBlockMarker((markString + hotOrCold + "_begin"), sectionName, false);
+  if (prefixStr == kFieldsInfoCompactPrefixStr || prefixStr == kMethodsInfoCompactPrefixStr ||
+      prefixStr == kFieldOffsetDataPrefixStr || prefixStr == kMethodAddrDataPrefixStr) {
+    for (auto s : mirSymbolVec) {
+      EmitMethodFieldSequential(*s, strIdx2Type, sectionName);
+    }
+  } else {
+    for (auto s : mirSymbolVec) {
+      EmitClassInfoSequential(*s, strIdx2Type, sectionName);
+    }
+  }
+  EmitBlockMarker((markString + hotOrCold + "_end"), sectionName, false);
+}
+
+void Emitter::MarkVtabOrItabEndFlag(const std::vector<MIRSymbol*> &mirSymbolVec) const {
+  for (auto mirSymbol : mirSymbolVec) {
+    auto *aggConst = safe_cast<MIRAggConst>(mirSymbol->GetKonst());
+    if ((aggConst == nullptr) || (aggConst->GetConstVec().empty())) {
+      continue;
+    }
+    size_t size = aggConst->GetConstVec().size();
+    MIRConst *elemConst = aggConst->GetConstVecItem(size - 1);
+    ASSERT(elemConst != nullptr, "null ptr check");
+    if (elemConst->GetKind() == kConstAddrofFunc) {
+      maple::LogInfo::MapleLogger(kLlErr) << "ERROR: the last vtab/itab content should not be funcAddr\n";
+    } else {
+      if (elemConst->GetKind() != kConstInt) {
+        CHECK_FATAL(elemConst->GetKind() == kConstAddrof, "must be");
+        continue;
+      }
+      MIRIntConst *tabConst = static_cast<MIRIntConst*>(elemConst);
+#ifdef USE_32BIT_REF
+      /* #define COLD VTAB ITAB END FLAG  0X4000000000000000 */
+      tabConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          static_cast<uint32>(tabConst->GetValue()) | 0X40000000, tabConst->GetType());
+#else
+      /* #define COLD VTAB ITAB END FLAG  0X4000000000000000 */
+      tabConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          static_cast<uint64_t>(tabConst->GetExtValue()) | 0X4000000000000000, tabConst->GetType());
+#endif
+      aggConst->SetItem(static_cast<uint32>(size) - 1, tabConst, aggConst->GetFieldIdItem(size - 1));
+    }
+  }
+}
+
+void Emitter::EmitStringPointers() {
+  if (CGOptions::OptimizeForSize()) {
+    (void)Emit(asmInfo->GetSection()).Emit(".rodata,\"aMS\",@progbits,1").Emit("\n");
+#if TARGX86 || TARGX86_64
+    Emit("\t.align 8\n");
+#else
+    Emit("\t.align 3\n");
+#endif
+  } else {
+    (void)Emit(asmInfo->GetSection()).Emit(".rodata").Emit("\n");
+  }
+  for (auto idx: localStrPtr) {
+    if (idx == 0) {
+      continue;
+    }
+    if (!CGOptions::OptimizeForSize()) {
+#if TARGX86 || TARGX86_64
+      Emit("\t.align 8\n");
+#else
+      Emit("\t.align 3\n");
+#endif
+    }
+    uint32 strId = idx.GetIdx();
+    std::string str = GlobalTables::GetUStrTable().GetStringFromStrIdx(idx);
+    (void)Emit(".LUstr_").Emit(strId).Emit(":\n");
+    std::string mplstr(str);
+    EmitStr(mplstr, false, true);
+  }
+  for (auto idx: stringPtr) {
+    if (idx == 0) {
+      continue;
+    }
+    if (!CGOptions::OptimizeForSize()) {
+#if TARGX86 || TARGX86_64
+      Emit("\t.align 8\n");
+#else
+      Emit("\t.align 3\n");
+#endif
+    }
+    uint32 strId = idx.GetIdx();
+    std::string str = GlobalTables::GetUStrTable().GetStringFromStrIdx(idx);
+#if TARGX86 || TARGX86_64
+    Emit(asmInfo->GetAlign());
+    Emit("8\n");
+#endif
+    Emit(".LSTR__").Emit(strId).Emit(":\n");
+    std::string mplstr(str);
+    EmitStr(mplstr, false, true);
+  }
+}
+
+void Emitter::EmitLocalVariable(const CGFunc &cgFunc) {
+  MIRSymbolTable *lSymTab = cgFunc.GetMirModule().CurFunction()->GetSymTab();
+  if (lSymTab == nullptr) {
+    return;
+  }
+
+  size_t lsize = lSymTab->GetSymbolTableSize();
+  for (size_t i = 0; i < lsize; i++) {
+    if (i < cgFunc.GetLSymSize() && !cg->GetMIRModule()->IsCModule()) {
+      continue;
+    }
+    MIRSymbol *st = lSymTab->GetSymbolFromStIdx(static_cast<uint32>(i));
+    if (st == nullptr || st->GetStorageClass() != kScPstatic) {
+      continue;
+    }
+    /*
+     * Local static names can repeat.
+     * Append the current program unit index to the name.
+     */
+    PUIdx puIdx = cgFunc.GetMirModule().CurFunction()->GetPuidx();
+    std::string localName = st->GetName() + std::to_string(puIdx);
+    static std::vector<std::string> emittedLocalSym;
+    if (std::find(emittedLocalSym.begin(), emittedLocalSym.end(), localName) != emittedLocalSym.end()) {
+      continue;
+    }
+    emittedLocalSym.push_back(localName);
+
+    MIRType *ty = st->GetType();
+    MIRConst *ct = st->GetKonst();
+    if (ct == nullptr) {
+      EmitUninitializedSymbol(*st);
+      continue;
+    }
+    /* cg created data should be located in .text */
+    /* [cgFunc.GetLSymSize(), lSymTab->GetSymbolTableSize()) -> cg created symbol */
+    if (i < cgFunc.GetLSymSize()) {
+      if (st->IsThreadLocal()) {
+        (void)Emit("\t.section\t.tdata,\"awT\",@progbits\n");
+      } else {
+        Emit(asmInfo->GetSection());
+        Emit(asmInfo->GetData());
+        Emit("\n");
+      }
+    } else {
+      CHECK_FATAL(st->GetStorageClass() == kScPstatic && st->GetSKind() == kStConst, "cg should create constant!");
+      /* cg created data should be located in .text */
+      (void)Emit("\t.section\t.text\n");
+    }
+    EmitAsmLabel(*st, kAsmAlign);
+    EmitAsmLabel(*st, kAsmLocal);
+    if (kTypeStruct == ty->GetKind() || kTypeUnion == ty->GetKind() || kTypeClass == ty->GetKind()) {
+      EmitAsmLabel(*st, kAsmSyname);
+      EmitStructConstant(*ct);
+      continue;
+    }
+    if (kTypeArray != ty->GetKind()) {
+      EmitAsmLabel(*st, kAsmSyname);
+      EmitScalarConstant(*ct, true, false, true /* isIndirect */);
+      continue;
+    }
+    if (ty->GetSize() != 0) {
+      EmitAsmLabel(*st, kAsmSyname);
+      EmitArrayConstant(*ct);
+    }
+  }
+}
+
+void Emitter::EmitGlobalVar(const MIRSymbol &globalVar) {
+  EmitAsmLabel(globalVar, kAsmType);
+  if (globalVar.sectionAttr != UStrIdx(0)) { /* check section info if it is from inline asm */
+    Emit("\t.section\t");
+    Emit(GlobalTables::GetUStrTable().GetStringFromStrIdx(globalVar.sectionAttr));
+    Emit(",\"aw\",%progbits\n");
+  } else {
+    EmitAsmLabel(globalVar, kAsmLocal);
+  }
+  EmitAsmLabel(globalVar, kAsmComm);
+}
+
+void Emitter::EmitGlobalVars(std::vector<std::pair<MIRSymbol*, bool>> &globalVars) {
+  if (GetCG()->IsLmbc() && GetCG()->GetGP() != nullptr) {
+    (void)Emit(asmInfo->GetLocal()).Emit("\t").Emit(GetCG()->GetGP()->GetName()).Emit("\n");
+    (void)Emit(asmInfo->GetComm()).Emit("\t").Emit(GetCG()->GetGP()->GetName());
+    (void)Emit(", ").Emit(GetCG()->GetMIRModule()->GetGlobalMemSize()).Emit(", ").Emit("8\n");
+  }
+  /* load globalVars profile */
+  if (globalVars.empty()) {
+    return;
+  }
+  std::unordered_set<std::string> hotVars;
+  std::ifstream inFile;
+  if (!CGOptions::IsGlobalVarProFileEmpty()) {
+    inFile.open(CGOptions::GetGlobalVarProFile());
+    if (inFile.fail()) {
+      maple::LogInfo::MapleLogger(kLlErr) << "Cannot open globalVar profile file " << CGOptions::GetGlobalVarProFile()
+                                         << "\n";
+    }
+  }
+  if (CGOptions::IsGlobalVarProFileEmpty() || inFile.fail()) {
+    for (const auto &globalVarPair : globalVars) {
+      EmitGlobalVar(*(globalVarPair.first));
+    }
+    return;
+  }
+  std::string globalVarName;
+  while (inFile >> globalVarName) {
+    (void)hotVars.insert(globalVarName);
+  }
+  inFile.close();
+  bool hotBeginSet = false;
+  bool coldBeginSet = false;
+  for (auto &globalVarPair : globalVars) {
+    if (hotVars.find(globalVarPair.first->GetName()) != hotVars.end()) {
+      if (!hotBeginSet) {
+        /* emit hot globalvar start symbol */
+        EmitBlockMarker("__MBlock_globalVars_hot_begin", "", true, globalVarPair.first->GetName());
+        hotBeginSet = true;
+      }
+      EmitGlobalVar(*(globalVarPair.first));
+      globalVarPair.second = true;
+    }
+  }
+  for (const auto &globalVarPair : globalVars) {
+    if (!globalVarPair.second) {  /* not emit yet */
+      if (!coldBeginSet) {
+        /* emit hot globalvar start symbol */
+        EmitBlockMarker("__MBlock_globalVars_cold_begin", "", true, globalVarPair.first->GetName());
+        coldBeginSet = true;
+      }
+      EmitGlobalVar(*(globalVarPair.first));
+    }
+  }
+  MIRSymbol *endSym = globalVars.back().first;
+  MIRType *mirType = endSym->GetType();
+  ASSERT_NOT_NULL(endSym);
+  ASSERT_NOT_NULL(mirType);
+  const std::string kStaticVarEndAdd =
+      std::to_string(Globals::GetInstance()->GetBECommon()->GetTypeSize(mirType->GetTypeIndex())) + "+" +
+                     endSym->GetName();
+  EmitBlockMarker("__MBlock_globalVars_cold_end", "", true, kStaticVarEndAdd);
+}
+
+void Emitter::EmitUninitializedSymbolsWithPrefixSection(const MIRSymbol &symbol, const std::string &sectionName) {
+  EmitAsmLabel(symbol, kAsmType);
+  Emit(asmInfo->GetSection());
+  auto sectionConstrains = symbol.IsThreadLocal() ? ",\"awT\"," : ",\"aw\",";
+  (void)Emit(sectionName).Emit(sectionConstrains);
+  if (sectionName == ".bss" || StringUtils::StartsWith(sectionName, ".bss.") ||
+      sectionName == ".tbss" || StringUtils::StartsWith(sectionName, ".tbss.")) {
+    Emit("%nobits\n");
+  } else {
+    Emit("%progbits\n");
+  }
+  if (symbol.GetAttr(ATTR_weak)) {
+    EmitAsmLabel(symbol, kAsmWeak);
+  } else if (symbol.GetStorageClass() == kScGlobal) {
+    EmitAsmLabel(symbol, kAsmGlbl);
+  }
+  EmitAsmLabel(symbol, kAsmAlign);
+  EmitAsmLabel(symbol, kAsmSyname);
+  EmitAsmLabel(symbol, kAsmZero);
+  EmitAsmLabel(symbol, kAsmSize);
+}
+
+void Emitter::EmitUninitializedSymbol(const MIRSymbol &mirSymbol) {
+  if (mirSymbol.sectionAttr != UStrIdx(0)) {
+    auto &sectionName = GlobalTables::GetUStrTable().GetStringFromStrIdx(mirSymbol.sectionAttr);
+    EmitUninitializedSymbolsWithPrefixSection(mirSymbol, sectionName);
+  } else if (mirSymbol.IsThreadLocal()) {
+    EmitUninitializedSymbolsWithPrefixSection(mirSymbol, ".tbss");
+  } else if (CGOptions::IsNoCommon() || mirSymbol.GetAttr(ATTR_static_init_zero)) {
+    EmitUninitializedSymbolsWithPrefixSection(mirSymbol, ".bss");
+  } else {
+    if (mirSymbol.GetStorageClass() != kScGlobal) {
+      EmitAsmLabel(mirSymbol, kAsmLocal);
+    }
+    EmitAsmLabel(mirSymbol, kAsmType);
+    EmitAsmLabel(mirSymbol, kAsmComm);
+  }
+}
+
+void Emitter::EmitGlobalVariable() {
+  std::vector<MIRSymbol*> typeStVec;
+  std::vector<MIRSymbol*> typeNameStVec;
+  std::map<GStrIdx, MIRType*> strIdx2Type;
+
+  /* Create name2type map which will be used by reflection. */
+  for (MIRType *type : GlobalTables::GetTypeTable().GetTypeTable()) {
+    if (type == nullptr || (type->GetKind() != kTypeClass && type->GetKind() != kTypeInterface)) {
+      continue;
+    }
+    GStrIdx strIdx = type->GetNameStrIdx();
+    strIdx2Type[strIdx] = type;
+  }
+
+  /* sort symbols; classinfo-->field-->method */
+  size_t size = GlobalTables::GetGsymTable().GetSymbolTableSize();
+  std::vector<MIRSymbol*> classInfoVec;
+  std::vector<MIRSymbol*> vtabVec;
+  std::vector<MIRSymbol*> staticFieldsVec;
+  std::vector<std::pair<MIRSymbol*, bool>> globalVarVec;
+  std::vector<MIRSymbol*> itabVec;
+  std::vector<MIRSymbol*> itabConflictVec;
+  std::vector<MIRSymbol*> vtabOffsetVec;
+  std::vector<MIRSymbol*> fieldOffsetVec;
+  std::vector<MIRSymbol*> valueOffsetVec;
+  std::vector<MIRSymbol*> localClassInfoVec;
+  std::vector<MIRSymbol*> constStrVec;
+  std::vector<std::pair<MIRSymbol*, bool>> literalVec;
+  std::vector<MIRSymbol*> muidVec = { nullptr };
+  std::vector<MIRSymbol*> fieldOffsetDatas;
+  std::vector<MIRSymbol*> methodAddrDatas;
+  std::vector<MIRSymbol*> methodSignatureDatas;
+  std::vector<MIRSymbol*> staticDecoupleKeyVec;
+  std::vector<MIRSymbol*> staticDecoupleValueVec;
+  std::vector<MIRSymbol*> superClassStVec;
+  std::vector<MIRSymbol*> arrayClassCacheVec;
+  std::vector<MIRSymbol*> arrayClassCacheNameVec;
+
+  for (size_t i = 0; i < size; ++i) {
+    MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
+    if (mirSymbol == nullptr || mirSymbol->IsDeleted() || mirSymbol->GetStorageClass() == kScUnused) {
+      continue;
+    }
+    if (mirSymbol->GetSKind() == kStFunc) {
+      EmitAliasAndRef(*mirSymbol);
+    }
+
+    if (mirSymbol->GetName().find(VTAB_PREFIX_STR) == 0) {
+      vtabVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->GetName().find(ITAB_PREFIX_STR) == 0) {
+      itabVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->GetName().find(ITAB_CONFLICT_PREFIX_STR) == 0) {
+      itabConflictVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->GetName().find(kVtabOffsetTabStr) == 0) {
+      vtabOffsetVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->GetName().find(kFieldOffsetTabStr) == 0) {
+      fieldOffsetVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->GetName().find(kOffsetTabStr) == 0) {
+      valueOffsetVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->IsArrayClassCache()) {
+      arrayClassCacheVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->IsArrayClassCacheName()) {
+      arrayClassCacheNameVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->GetName().find(kLocalClassInfoStr) == 0) {
+      localClassInfoVec.emplace_back(mirSymbol);
+      continue;
+    } else if (StringUtils::StartsWith(mirSymbol->GetName(), namemangler::kDecoupleStaticKeyStr)) {
+      staticDecoupleKeyVec.emplace_back(mirSymbol);
+      continue;
+    } else if (StringUtils::StartsWith(mirSymbol->GetName(), namemangler::kDecoupleStaticValueStr)) {
+      staticDecoupleValueVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->IsLiteral()) {
+      literalVec.emplace_back(std::make_pair(mirSymbol, false));
+      continue;
+    } else if (mirSymbol->IsConstString() || mirSymbol->IsLiteralPtr()) {
+      MIRConst *mirConst = mirSymbol->GetKonst();
+      if (mirConst != nullptr && mirConst->GetKind() == kConstAddrof) {
+        constStrVec.emplace_back(mirSymbol);
+        continue;
+      }
+    } else if (mirSymbol->IsReflectionClassInfoPtr()) {
+      /* _PTR__cinf is emitted in dataDefTab and dataUndefTab */
+      continue;
+    } else if (mirSymbol->IsMuidTab()) {
+      muidVec[0] = mirSymbol;
+      EmitMuidTable(muidVec, strIdx2Type, mirSymbol->GetMuidTabName());
+      continue;
+    } else if (mirSymbol->IsCodeLayoutInfo()) {
+      if (!GetCG()->GetMIRModule()->IsCModule()) {
+        EmitFuncLayoutInfo(*mirSymbol);
+      }
+      continue;
+    } else if (mirSymbol->GetName().find(kStaticFieldNamePrefixStr) == 0) {
+      staticFieldsVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->GetName().find(kGcRootList) == 0) {
+      EmitGlobalRootList(*mirSymbol);
+      continue;
+    } else if (mirSymbol->GetName().find(kFunctionProfileTabPrefixStr) == 0) {
+      muidVec[0] = mirSymbol;
+      EmitMuidTable(muidVec, strIdx2Type, kFunctionProfileTabPrefixStr);
+      continue;
+    } else if (mirSymbol->IsReflectionFieldOffsetData()) {
+      fieldOffsetDatas.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->IsReflectionMethodAddrData()) {
+      methodAddrDatas.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->IsReflectionSuperclassInfo()) {
+      superClassStVec.emplace_back(mirSymbol);
+      continue;
+    } else if (mirSymbol->IsReflectionMethodSignature()) {
+      methodSignatureDatas.push_back(mirSymbol);
+      continue;
+    }
+
+    if (mirSymbol->IsReflectionInfo()) {
+      if (mirSymbol->IsReflectionClassInfo()) {
+        classInfoVec.emplace_back(mirSymbol);
+      }
+      continue;
+    }
+    /* symbols we do not emit here. */
+    if (mirSymbol->GetSKind() == kStFunc || mirSymbol->GetSKind() == kStJavaClass ||
+        mirSymbol->GetSKind() == kStJavaInterface) {
+      continue;
+    }
+    if (mirSymbol->GetStorageClass() == kScTypeInfo) {
+      typeStVec.emplace_back(mirSymbol);
+      continue;
+    }
+    if (mirSymbol->GetStorageClass() == kScTypeInfoName) {
+      typeNameStVec.emplace_back(mirSymbol);
+      continue;
+    }
+    if (mirSymbol->GetStorageClass() == kScTypeCxxAbi) {
+      continue;
+    }
+
+    MIRType *mirType = mirSymbol->GetType();
+    if (mirType == nullptr) {
+      continue;
+    }
+    if (GetCG()->GetMIRModule()->IsCModule() && mirSymbol->GetStorageClass() == kScExtern) {
+      /* only emit weak & initialized extern at present */
+      if (mirSymbol->IsWeak() || mirSymbol->IsConst()) {
+        EmitAsmLabel(*mirSymbol, kAsmWeak);
+      } else {
+        continue;
+      }
+    }
+    /*
+     * emit uninitialized global/static variables.
+     * these variables store in .comm section.
+     */
+    if ((mirSymbol->GetStorageClass() == kScGlobal || mirSymbol->GetStorageClass() == kScFstatic) &&
+        !mirSymbol->IsConst()) {
+      if (mirSymbol->IsGctibSym()) {
+        /* GCTIB symbols are generated in GenerateObjectMaps */
+        continue;
+      }
+      if (mirSymbol->GetStorageClass() != kScGlobal && cg->GetMIRModule()->IsJavaModule()) {
+        globalVarVec.emplace_back(std::make_pair(mirSymbol, false));
+        continue;
+      }
+      EmitUninitializedSymbol(*mirSymbol);
+      continue;
+    }
+
+    /* emit initialized global/static variables. */
+    if (mirSymbol->GetStorageClass() == kScGlobal ||
+        (mirSymbol->GetStorageClass() == kScExtern && GetCG()->GetMIRModule()->IsCModule()) ||
+        (mirSymbol->GetStorageClass() == kScFstatic && !mirSymbol->IsReadOnly())) {
+      /* Emit section */
+      EmitAsmLabel(*mirSymbol, kAsmType);
+      if (mirSymbol->IsReflectionStrTab()) {
+        std::string sectionName = ".reflection_strtab";
+        if (mirSymbol->GetName().find(kReflectionStartHotStrtabPrefixStr) == 0) {
+          sectionName = ".reflection_start_hot_strtab";
+        } else if (mirSymbol->GetName().find(kReflectionBothHotStrTabPrefixStr) == 0) {
+          sectionName = ".reflection_both_hot_strtab";
+        } else if (mirSymbol->GetName().find(kReflectionRunHotStrtabPrefixStr) == 0) {
+          sectionName = ".reflection_run_hot_strtab";
+        }
+        Emit("\t.section\t" + sectionName + ",\"a\",%progbits\n");
+      } else if (mirSymbol->GetName().find(kDecoupleOption) == 0) {
+        Emit("\t.section\t." + std::string(kDecoupleStr) + ",\"a\",%progbits\n");
+      } else if (mirSymbol->IsRegJNITab()) {
+        Emit("\t.section\t.reg_jni_tab,\"a\", %progbits\n");
+      } else if (mirSymbol->GetName().find(kCompilerVersionNum) == 0) {
+        Emit("\t.section\t." + std::string(kCompilerVersionNumStr) + ",\"a\", %progbits\n");
+      } else if (mirSymbol->GetName().find(kSourceMuid) == 0) {
+        Emit("\t.section\t." + std::string(kSourceMuidSectionStr) + ",\"a\", %progbits\n");
+      } else if (mirSymbol->GetName().find(kCompilerMfileStatus) == 0) {
+        Emit("\t.section\t." + std::string(kCompilerMfileStatus) + ",\"a\", %progbits\n");
+      } else if (mirSymbol->IsRegJNIFuncTab()) {
+        Emit("\t.section\t.reg_jni_func_tab,\"aw\", %progbits\n");
+      } else if (mirSymbol->IsReflectionPrimitiveClassInfo()) {
+        Emit("\t.section\t.primitive_classinfo,\"awG\", %progbits,__primitive_classinfo__,comdat\n");
+      } else if (mirSymbol->IsReflectionHashTabBucket()) {
+        std::string stName = mirSymbol->GetName();
+        const std::string delimiter = "$$";
+        if (stName.find(delimiter) == std::string::npos) {
+          FATAL(kLncFatal, "Can not find delimiter in target ");
+        }
+        std::string secName = stName.substr(0, stName.find(delimiter));
+        /* remove leading "__" in sec name. */
+        secName.erase(0, 2);
+        Emit("\t.section\t." + secName + ",\"a\",%progbits\n");
+      } else {
+        bool isThreadLocal = mirSymbol->IsThreadLocal();
+        if (cg->GetMIRModule()->IsJavaModule()) {
+          (void)Emit("\t.section\t." + std::string(kMapleGlobalVariable) + ",\"aw\", @progbits\n");
+        } else if (mirSymbol->sectionAttr != UStrIdx(0)) {
+          auto &sectionName = GlobalTables::GetUStrTable().GetStringFromStrIdx(mirSymbol->sectionAttr);
+          auto sectionConstrains = isThreadLocal ? ",\"awT\"," : ",\"aw\",";
+          (void)Emit("\t.section\t" + sectionName + sectionConstrains + "@progbits\n");
+        } else if (isThreadLocal) {
+          (void)Emit("\t.section\t.tdata,\"awT\",@progbits\n");
+        } else {
+          (void)Emit("\t.data\n");
+        }
+      }
+      /* Emit size and align by type */
+      if (mirSymbol->GetStorageClass() == kScGlobal) {
+        if (mirSymbol->GetAttr(ATTR_weak) || mirSymbol->IsReflectionPrimitiveClassInfo()) {
+          EmitAsmLabel(*mirSymbol, kAsmWeak);
+        } else {
+          EmitAsmLabel(*mirSymbol, kAsmGlbl);
+        }
+        if (theMIRModule->IsJavaModule()) {
+          EmitAsmLabel(*mirSymbol, kAsmHidden);
+        }
+      } else if (mirSymbol->GetStorageClass() == kScFstatic) {
+        if (mirSymbol->sectionAttr == UStrIdx(0)) {
+          EmitAsmLabel(*mirSymbol, kAsmLocal);
+        }
+      }
+      if (mirSymbol->IsReflectionStrTab()) {  /* reflection-string-tab also aligned to 8B boundaries. */
+        Emit(asmInfo->GetAlign());
+#if TARGX86 || TARGX86_64
+        Emit("8\n");
+#else
+        Emit("3\n");
+#endif
+      } else {
+        EmitAsmLabel(*mirSymbol, kAsmAlign);
+      }
+      EmitAsmLabel(*mirSymbol, kAsmSyname);
+      MIRConst *mirConst = mirSymbol->GetKonst();
+      if (IsPrimitiveVector(mirType->GetPrimType())) {
+        EmitVectorConstant(*mirConst);
+      } else if (IsPrimitiveScalar(mirType->GetPrimType())) {
+        if (!CGOptions::IsArm64ilp32()) {
+          if (IsAddress(mirType->GetPrimType())) {
+            uint32 sizeinbits = GetPrimTypeBitSize(mirConst->GetType().GetPrimType());
+            CHECK_FATAL(sizeinbits == k64BitSize, "EmitGlobalVariable: pointer must be of size 8");
+          }
+        }
+        if (cg->GetMIRModule()->IsCModule()) {
+          EmitScalarConstant(*mirConst, true, false, true);
+        } else {
+          EmitScalarConstant(*mirConst);
+        }
+      } else if (mirType->GetKind() == kTypeArray) {
+        if (mirSymbol->HasAddrOfValues()) {
+          EmitConstantTable(*mirSymbol, *mirConst, strIdx2Type);
+        } else {
+          EmitArrayConstant(*mirConst);
+        }
+      } else if (mirType->GetKind() == kTypeStruct || mirType->GetKind() == kTypeClass ||
+                 mirType->GetKind() == kTypeUnion) {
+        if (mirSymbol->HasAddrOfValues()) {
+          EmitConstantTable(*mirSymbol, *mirConst, strIdx2Type);
+        } else {
+          EmitStructConstant(*mirConst);
+        }
+      } else {
+        ASSERT(false, "NYI");
+      }
+      EmitAsmLabel(*mirSymbol, kAsmSize);
+      /* emit constant float/double */
+    } else if (mirSymbol->IsReadOnly()) {
+      MIRConst *mirConst = mirSymbol->GetKonst();
+      if (mirConst->GetKind() == maple::kConstStrConst) {
+        auto strCt = static_cast<MIRStrConst*>(mirConst);
+        localStrPtr.push_back(strCt->GetValue());
+      } else {
+        EmitAsmLabel(*mirSymbol, kAsmType);
+        (void)Emit(asmInfo->GetSection()).Emit(asmInfo->GetRodata()).Emit("\n");
+        if (!CGOptions::OptimizeForSize()) {
+          EmitAsmLabel(*mirSymbol, kAsmAlign);
+        }
+        EmitAsmLabel(*mirSymbol, kAsmSyname);
+        EmitScalarConstant(*mirConst);
+      }
+    } else if (mirSymbol->GetStorageClass() == kScPstatic) {
+      EmitAsmLabel(*mirSymbol, kAsmType);
+      Emit(asmInfo->GetSection());
+      Emit(asmInfo->GetData());
+      Emit("\n");
+      EmitAsmLabel(*mirSymbol, kAsmAlign);
+      EmitAsmLabel(*mirSymbol, kAsmLocal);
+      MIRConst *ct = mirSymbol->GetKonst();
+      if (ct == nullptr) {
+        EmitAsmLabel(*mirSymbol, kAsmComm);
+      } else if (IsPrimitiveScalar(mirType->GetPrimType())) {
+        EmitAsmLabel(*mirSymbol, kAsmSyname);
+        EmitScalarConstant(*ct, true, false, true);
+      } else if (kTypeArray == mirType->GetKind()) {
+        EmitAsmLabel(*mirSymbol, kAsmSyname);
+        EmitArrayConstant(*ct);
+      } else if (kTypeStruct == mirType->GetKind() || kTypeClass == mirType->GetKind() ||
+                 kTypeUnion == mirType->GetKind()) {
+        EmitAsmLabel(*mirSymbol, kAsmSyname);
+        EmitStructConstant(*ct);
+      } else {
+        CHECK_FATAL(0, "Unknown type in Global pstatic");
+      }
+    }
+  } /* end proccess all mirSymbols. */
+  EmitStringPointers();
+  /* emit global var */
+  EmitGlobalVars(globalVarVec);
+  /* emit literal std::strings */
+  EmitLiterals(literalVec, strIdx2Type);
+  /* emit static field std::strings */
+  EmitStaticFields(staticFieldsVec);
+
+  if (GetCG()->GetMIRModule()->IsCModule()) {
+    return;
+  }
+
+  EmitMuidTable(constStrVec, strIdx2Type, kMuidConststrPrefixStr);
+
+  /* emit classinfo, field, method */
+  std::vector<MIRSymbol*> fieldInfoStVec;
+  std::vector<MIRSymbol*> fieldInfoStCompactVec;
+  std::vector<MIRSymbol*> methodInfoStVec;
+  std::vector<MIRSymbol*> methodInfoStCompactVec;
+
+  std::string sectionName = kMuidClassMetadataPrefixStr;
+  Emit("\t.section ." + sectionName + ",\"aw\",%progbits\n");
+  Emit(sectionName + "_begin:\n");
+
+  for (size_t i = 0; i < classInfoVec.size(); ++i) {
+    MIRSymbol *mirSymbol = classInfoVec[i];
+    if (mirSymbol != nullptr && mirSymbol->GetKonst() != nullptr && mirSymbol->IsReflectionClassInfo()) {
+      /* Emit classinfo */
+      EmitClassInfoSequential(*mirSymbol, strIdx2Type, sectionName);
+      std::string stName = mirSymbol->GetName();
+      std::string className = stName.substr(strlen(CLASSINFO_PREFIX_STR));
+      /* Get classinfo ro symbol */
+      MIRSymbol *classInfoROSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+          GlobalTables::GetStrTable().GetStrIdxFromName(CLASSINFO_RO_PREFIX_STR + className));
+      EmitClassInfoSequential(*classInfoROSt, strIdx2Type, sectionName);
+      /* Get fields */
+      MIRSymbol *fieldSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+          GlobalTables::GetStrTable().GetStrIdxFromName(kFieldsInfoPrefixStr + className));
+      MIRSymbol *fieldStCompact = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+          GlobalTables::GetStrTable().GetStrIdxFromName(kFieldsInfoCompactPrefixStr + className));
+      /* Get methods */
+      MIRSymbol *methodSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+          GlobalTables::GetStrTable().GetStrIdxFromName(kMethodsInfoPrefixStr + className));
+      MIRSymbol *methodStCompact = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+          GlobalTables::GetStrTable().GetStrIdxFromName(kMethodsInfoCompactPrefixStr + className));
+
+      if (fieldSt != nullptr) {
+        fieldInfoStVec.emplace_back(fieldSt);
+      }
+      if (fieldStCompact != nullptr) {
+        fieldInfoStCompactVec.emplace_back(fieldStCompact);
+      }
+      if (methodSt != nullptr) {
+        methodInfoStVec.emplace_back(methodSt);
+      }
+      if (methodStCompact != nullptr) {
+        methodInfoStCompactVec.emplace_back(methodStCompact);
+      }
+    }
+  }
+  Emit(sectionName + "_end:\n");
+
+  std::vector<MIRSymbol*> hotVtabStVec;
+  std::vector<MIRSymbol*> coldVtabStVec;
+  std::vector<MIRSymbol*> hotItabStVec;
+  std::vector<MIRSymbol*> coldItabStVec;
+  std::vector<MIRSymbol*> hotItabCStVec;
+  std::vector<MIRSymbol*> coldItabCStVec;
+  std::vector<MIRSymbol*> hotMethodsInfoCStVec;
+  std::vector<MIRSymbol*> coldMethodsInfoCStVec;
+  std::vector<MIRSymbol*> hotFieldsInfoCStVec;
+  std::vector<MIRSymbol*> coldFieldsInfoCStVec;
+  GetHotAndColdMetaSymbolInfo(vtabVec, hotVtabStVec, coldVtabStVec, VTAB_PREFIX_STR,
+                              ((CGOptions::IsLazyBinding() || CGOptions::IsHotFix()) && !cg->IsLibcore()));
+  GetHotAndColdMetaSymbolInfo(itabVec, hotItabStVec, coldItabStVec, ITAB_PREFIX_STR,
+                              ((CGOptions::IsLazyBinding() || CGOptions::IsHotFix()) && !cg->IsLibcore()));
+  GetHotAndColdMetaSymbolInfo(itabConflictVec, hotItabCStVec, coldItabCStVec, ITAB_CONFLICT_PREFIX_STR,
+                              ((CGOptions::IsLazyBinding() || CGOptions::IsHotFix()) && !cg->IsLibcore()));
+  GetHotAndColdMetaSymbolInfo(fieldInfoStVec, hotFieldsInfoCStVec, coldFieldsInfoCStVec, kFieldsInfoPrefixStr);
+  GetHotAndColdMetaSymbolInfo(methodInfoStVec, hotMethodsInfoCStVec, coldMethodsInfoCStVec, kMethodsInfoPrefixStr);
+
+  std::string sectionNameIsEmpty;
+  std::string fieldSectionName("rometadata.field");
+  std::string methodSectionName("rometadata.method");
+
+  /* fieldinfo */
+  EmitMetaDataSymbolWithMarkFlag(hotFieldsInfoCStVec, strIdx2Type, kFieldsInfoPrefixStr, fieldSectionName, true);
+  EmitMetaDataSymbolWithMarkFlag(coldFieldsInfoCStVec, strIdx2Type, kFieldsInfoPrefixStr, fieldSectionName, false);
+  EmitMetaDataSymbolWithMarkFlag(fieldInfoStCompactVec, strIdx2Type, kFieldsInfoCompactPrefixStr, fieldSectionName,
+                                 false);
+  /* methodinfo */
+  EmitMetaDataSymbolWithMarkFlag(hotMethodsInfoCStVec, strIdx2Type, kMethodsInfoPrefixStr, methodSectionName, true);
+  EmitMetaDataSymbolWithMarkFlag(coldMethodsInfoCStVec, strIdx2Type, kMethodsInfoPrefixStr, methodSectionName, false);
+  EmitMetaDataSymbolWithMarkFlag(methodInfoStCompactVec, strIdx2Type, kMethodsInfoCompactPrefixStr, methodSectionName,
+                                 false);
+
+  /* itabConflict */
+  MarkVtabOrItabEndFlag(coldItabCStVec);
+  EmitMuidTable(hotItabCStVec, strIdx2Type, kMuidItabConflictPrefixStr);
+  EmitMetaDataSymbolWithMarkFlag(coldItabCStVec, strIdx2Type, ITAB_CONFLICT_PREFIX_STR, kMuidColdItabConflictPrefixStr,
+                                 false);
+
+  /*
+   * vtab
+   * And itab to vtab section
+   */
+  for (auto sym : hotItabStVec) {
+    hotVtabStVec.emplace_back(sym);
+  }
+  for (auto sym : coldItabStVec) {
+    coldVtabStVec.emplace_back(sym);
+  }
+  MarkVtabOrItabEndFlag(coldVtabStVec);
+  EmitMuidTable(hotVtabStVec, strIdx2Type, kMuidVtabAndItabPrefixStr);
+  EmitMetaDataSymbolWithMarkFlag(coldVtabStVec, strIdx2Type, VTAB_AND_ITAB_PREFIX_STR, kMuidColdVtabAndItabPrefixStr,
+                                 false);
+
+  /* vtab_offset */
+  EmitMuidTable(vtabOffsetVec, strIdx2Type, kMuidVtabOffsetPrefixStr);
+  /* field_offset */
+  EmitMuidTable(fieldOffsetVec, strIdx2Type, kMuidFieldOffsetPrefixStr);
+  /* value_offset */
+  EmitMuidTable(valueOffsetVec, strIdx2Type, kMuidValueOffsetPrefixStr);
+  /* local clasinfo */
+  EmitMuidTable(localClassInfoVec, strIdx2Type, kMuidLocalClassInfoStr);
+  /* Emit decouple static */
+  EmitMuidTable(staticDecoupleKeyVec, strIdx2Type, kDecoupleStaticKeyStr);
+  EmitMuidTable(staticDecoupleValueVec, strIdx2Type, kDecoupleStaticValueStr);
+
+  /* super class */
+  EmitMuidTable(superClassStVec, strIdx2Type, kMuidSuperclassPrefixStr);
+
+  /* field offset rw */
+  EmitMetaDataSymbolWithMarkFlag(fieldOffsetDatas, strIdx2Type, kFieldOffsetDataPrefixStr, sectionNameIsEmpty, false);
+  /* method address rw */
+  EmitMetaDataSymbolWithMarkFlag(methodAddrDatas, strIdx2Type, kMethodAddrDataPrefixStr, sectionNameIsEmpty, false);
+  /* method address ro */
+  std::string methodSignatureSectionName("romethodsignature");
+  EmitMetaDataSymbolWithMarkFlag(methodSignatureDatas, strIdx2Type, kMethodSignaturePrefixStr,
+                                 methodSignatureSectionName, false);
+
+  /* array class cache table */
+  EmitMuidTable(arrayClassCacheVec, strIdx2Type, kArrayClassCacheTable);
+  /* array class cache name table */
+  EmitMuidTable(arrayClassCacheNameVec, strIdx2Type, kArrayClassCacheNameTable);
+
+#if !defined(TARGARM32)
+  /* finally emit __gxx_personality_v0 DW.ref */
+  if (!cg->GetMIRModule()->IsCModule())  {
+    EmitDWRef("__mpl_personality_v0");
+  }
+#endif
+}
+void Emitter::EmitAddressString(const std::string &address) {
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+  EmitAsmLabel(kAsmQuad);
+  Emit(address);
+#else
+  Emit("\t.word\t" + address);
+#endif
+}
+void Emitter::EmitGlobalRootList(const MIRSymbol &mirSymbol) {
+  Emit("\t.section .maple.gcrootsmap").Emit(",\"aw\",%progbits\n");
+  std::vector<std::string> nameVec;
+  std::string name = mirSymbol.GetName();
+  nameVec.emplace_back(name);
+  nameVec.emplace_back(name + "Size");
+  bool gcrootsFlag = true;
+  uint64 vecSize = 0;
+  for (const auto &gcrootsName : nameVec) {
+#if TARGAARCH64 || TARGRISCV64 || TARGX86_64
+    Emit("\t.type\t" + gcrootsName + ", @object\n" + "\t.p2align 3\n");
+#else
+    Emit("\t.type\t" + gcrootsName + ", %object\n" + "\t.p2align 3\n");
+#endif
+    Emit("\t.global\t" + gcrootsName + "\n");
+    if (gcrootsFlag) {
+      Emit(kMuidGlobalRootlistPrefixStr).Emit("_begin:\n");
+    }
+    Emit(gcrootsName + ":\n");
+    if (gcrootsFlag) {
+      MIRAggConst *aggConst = safe_cast<MIRAggConst>(mirSymbol.GetKonst());
+      if (aggConst == nullptr) {
+        continue;
+      }
+      size_t i = 0;
+      while (i < aggConst->GetConstVec().size()) {
+        MIRConst *elemConst = aggConst->GetConstVecItem(i);
+        if (elemConst->GetKind() == kConstAddrof) {
+          MIRAddrofConst *symAddr = safe_cast<MIRAddrofConst>(elemConst);
+          CHECK_FATAL(symAddr != nullptr, "nullptr of symAddr");
+          MIRSymbol *symAddrSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(symAddr->GetSymbolIndex().Idx());
+          const std::string &symAddrName = symAddrSym->GetName();
+          EmitAddressString(symAddrName + "\n");
+        } else {
+          EmitScalarConstant(*elemConst);
+        }
+        i++;
+      }
+      vecSize = i;
+    } else {
+      EmitAddressString(std::to_string(vecSize) + "\n");
+    }
+    Emit("\t.size\t" + gcrootsName + ",.-").Emit(gcrootsName + "\n");
+    if (gcrootsFlag) {
+      Emit(kMuidGlobalRootlistPrefixStr).Emit("_end:\n");
+    }
+    gcrootsFlag = false;
+  }
+}
+
+void Emitter::EmitMuidTable(const std::vector<MIRSymbol*> &vec, const std::map<GStrIdx, MIRType*> &strIdx2Type,
+                            const std::string &sectionName) {
+  MIRSymbol *st = nullptr;
+  if (!vec.empty()) {
+    st = vec[0];
+  }
+  if (st != nullptr && st->IsMuidRoTab()) {
+    Emit("\t.section  ." + sectionName + ",\"a\",%progbits\n");
+  } else {
+    Emit("\t.section  ." + sectionName + ",\"aw\",%progbits\n");
+  }
+  if (!CGOptions::DoLiteProfGen()) {
+    Emit(sectionName + "_begin:\n");
+  }
+  bool isConstString = sectionName == kMuidConststrPrefixStr;
+  for (size_t i = 0; i < vec.size(); i++) {
+    MIRSymbol *st1 = vec[i];
+    ASSERT(st1 != nullptr, "null ptr check");
+    if (st1->GetStorageClass() == kScUnused) {
+      continue;
+    }
+    EmitAsmLabel(*st1, kAsmType);
+    if (st1->GetStorageClass() == kScFstatic) {
+      EmitAsmLabel(*st1, kAsmLocal);
+    } else {
+      EmitAsmLabel(*st1, kAsmGlbl);
+      EmitAsmLabel(*st1, kAsmHidden);
+    }
+    EmitAsmLabel(*st1, kAsmAlign);
+    EmitAsmLabel(*st1, kAsmSyname);
+    MIRConst *mirConst = st1->GetKonst();
+    CHECK_FATAL(mirConst != nullptr, "mirConst should not be nullptr in EmitMuidTable");
+    if (mirConst->GetKind() == kConstAddrof) {
+      MIRAddrofConst *symAddr = safe_cast<MIRAddrofConst>(mirConst);
+      CHECK_FATAL(symAddr != nullptr, "call static_cast failed in EmitMuidTable");
+      MIRSymbol *symAddrSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(symAddr->GetSymbolIndex().Idx());
+      if (isConstString) {
+        EmitAddressString(symAddrSym->GetName() + " - . + ");
+        Emit(kDataRefIsOffset);
+        Emit("\n");
+      } else {
+        EmitAddressString(symAddrSym->GetName() + "\n");
+      }
+    } else if (mirConst->GetKind() == kConstInt) {
+      EmitScalarConstant(*mirConst, true);
+    } else {
+      EmitConstantTable(*st1, *mirConst, strIdx2Type);
+    }
+    EmitAsmLabel(*st1, kAsmSize);
+  }
+  if (!CGOptions::DoLiteProfGen()) {
+    Emit(sectionName + "_end:\n");
+  }
+}
+
+void Emitter::EmitClassInfoSequential(const MIRSymbol &mirSymbol, const std::map<GStrIdx, MIRType*> &strIdx2Type,
+                                      const std::string &sectionName) {
+  EmitAsmLabel(mirSymbol, kAsmType);
+  if (!sectionName.empty()) {
+    Emit("\t.section ." + sectionName);
+    if (StringUtils::StartsWith(sectionName, "ro")) {
+      Emit(",\"a\",%progbits\n");
+    } else {
+      Emit(",\"aw\",%progbits\n");
+    }
+  } else {
+    EmitAsmLabel(kAsmData);
+  }
+  EmitAsmLabel(mirSymbol, kAsmGlbl);
+  EmitAsmLabel(mirSymbol, kAsmHidden);
+  EmitAsmLabel(mirSymbol, kAsmAlign);
+  EmitAsmLabel(mirSymbol, kAsmSyname);
+  MIRConst *mirConst = mirSymbol.GetKonst();
+  CHECK_FATAL(mirConst != nullptr, "mirConst should not be nullptr in EmitClassInfoSequential");
+  EmitConstantTable(mirSymbol, *mirConst, strIdx2Type);
+  EmitAsmLabel(mirSymbol, kAsmSize);
+}
+
+void Emitter::EmitMethodDeclaringClass(const MIRSymbol &mirSymbol, const std::string &sectionName) {
+  std::string symName = mirSymbol.GetName();
+  std::string emitSyName = symName + "_DeclaringClass";
+  std::string declaringClassName = symName.substr(strlen(kFieldsInfoCompactPrefixStr) + 1);
+  Emit(asmInfo->GetType());
+  Emit(emitSyName + ", %object\n");
+  if (!sectionName.empty()) {
+    Emit("\t.section  ." + sectionName + "\n");
+  } else {
+    EmitAsmLabel(kAsmData);
+  }
+  Emit(asmInfo->GetLocal());
+  Emit(emitSyName + "\n");
+  Emit(asmInfo->GetAlign());
+  Emit("  2\n" + emitSyName + ":\n");
+  Emit("\t.long\t");
+  Emit(CLASSINFO_PREFIX_STR + declaringClassName + " - .\n");
+  Emit(asmInfo->GetSize());
+  Emit(emitSyName + ", 4\n");
+}
+
+void Emitter::EmitMethodFieldSequential(const MIRSymbol &mirSymbol,
+                                        const std::map<GStrIdx, MIRType*> &strIdx2Type,
+                                        const std::string &sectionName) {
+  std::string symName = mirSymbol.GetName();
+  if (symName.find(kMethodsInfoCompactPrefixStr) != std::string::npos) {
+    EmitMethodDeclaringClass(mirSymbol, sectionName);
+  }
+  EmitAsmLabel(mirSymbol, kAsmType);
+  if (!sectionName.empty()) {
+    Emit("\t.section  ." + sectionName + "\n");
+  } else {
+    EmitAsmLabel(kAsmData);
+  }
+  EmitAsmLabel(mirSymbol, kAsmLocal);
+
+  /* Emit(2) is 4 bit align */
+  Emit(asmInfo->GetAlign()).Emit(2).Emit("\n");
+  EmitAsmLabel(mirSymbol, kAsmSyname);
+  MIRConst *ct = mirSymbol.GetKonst();
+  EmitConstantTable(mirSymbol, *ct, strIdx2Type);
+  std::string symbolName = mirSymbol.GetName();
+  Emit("\t.size\t" + symbolName + ", .-");
+  Emit(symbolName + "\n");
+}
+
+void Emitter::EmitDWRef(const std::string &name) {
+  /*
+   *   .hidden DW.ref._ZTI3xxx
+   *   .weak DW.ref._ZTI3xxx
+   *   .section  .data.DW.ref._ZTI3xxx,"awG",@progbits,DW.ref._ZTI3xxx,comdat
+   *   .align  3
+   *   .type DW.ref._ZTI3xxx, %object
+   *   .size DW.ref._ZTI3xxx, 8
+   * DW.ref._ZTI3xxx:
+   *   .xword  _ZTI3xxx
+   */
+  Emit("\t.hidden DW.ref." + name + "\n");
+  Emit("\t.weak DW.ref." + name + "\n");
+  Emit("\t.section .data.DW.ref." + name + ",\"awG\",%progbits,DW.ref.");
+  Emit(name + ",comdat\n");
+  Emit(asmInfo->GetAlign());
+#if TARGX86 || TARGX86_64
+  Emit("8\n");
+#else
+  Emit("3\n");
+#endif
+  Emit("\t.type DW.ref." + name + ", \%object\n");
+  Emit("\t.size DW.ref." + name + ",8\n");
+  Emit("DW.ref." + name + ":\n");
+#if TARGAARCH64 || TARGRISCV64
+  Emit("\t.xword " + name + "\n");
+#else
+  Emit("\t.word " + name + "\n");
+#endif
+}
+
+void Emitter::EmitDecSigned(int64 num) {
+  std::ios::fmtflags flag(outStream.flags());
+  outStream << std::dec << num;
+  outStream.flags(flag);
+}
+
+void Emitter::EmitDecUnsigned(uint64 num) {
+  std::ios::fmtflags flag(outStream.flags());
+  outStream << std::dec << num;
+  outStream.flags(flag);
+}
+
+void Emitter::EmitHexUnsigned(uint64 num) {
+  std::ios::fmtflags flag(outStream.flags());
+  outStream << "0x" << std::hex << num;
+  outStream.flags(flag);
+}
+
+#define XSTR(s) STR(s)
+#define STR(s) #s
+
+void Emitter::EmitDIHeader() {
+  if (cg->GetMIRModule()->GetSrcLang() == kSrcLangC) {
+    (void)Emit("\t.section ." + std::string("c_text") + ",\"ax\"\n");
+  } else {
+    (void)Emit("\t.section ." + std::string(namemangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
+  }
+  Emit(".L" XSTR(TEXT_BEGIN) ":\n");
+}
+
+void Emitter::EmitDIFooter() {
+  if (cg->GetMIRModule()->GetSrcLang() == kSrcLangC) {
+    (void)Emit("\t.section ." + std::string("c_text") + ",\"ax\"\n");
+  } else {
+    (void)Emit("\t.section ." + std::string(namemangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
+  }
+  Emit(".L" XSTR(TEXT_END) ":\n");
+}
+
+void Emitter::EmitDIHeaderFileInfo() {
+  Emit("// dummy header file 1\n");
+  Emit("// dummy header file 2\n");
+  Emit("// dummy header file 3\n");
+}
+
+void Emitter::AddLabelDieToLabelIdxMapping(DBGDie *lblDie, LabelIdx lblIdx) {
+  InsertLabdie2labidxTable(lblDie, lblIdx);
+}
+
+LabelIdx Emitter::GetLabelIdxForLabelDie(DBGDie *lblDie) {
+  auto it = labdie2labidxTable.find(lblDie);
+  CHECK_FATAL(it != labdie2labidxTable.end(), "");
+  return it->second;
+}
+
+void Emitter::ApplyInPrefixOrder(DBGDie *die, const std::function<void(DBGDie*)> &func) {
+  func(die);
+  ASSERT(die, "");
+  if (die->GetSubDieVec().size() > 0) {
+    for (auto c : die->GetSubDieVec()) {
+      ApplyInPrefixOrder(c, func);
+    }
+    /* mark the end of the sibling list */
+    func(nullptr);
+  }
+}
+
+void Emitter::EmitDIFormSpecification(unsigned int dwform) {
+  switch (dwform) {
+    case DW_FORM_string:
+      Emit(".string  ");
+      break;
+    case DW_FORM_strp:
+    case DW_FORM_data4:
+    case DW_FORM_ref4:
+      Emit(".4byte   ");
+      break;
+    case DW_FORM_data1:
+      Emit(".byte    ");
+      break;
+    case DW_FORM_data2:
+      Emit(".2byte   ");
+      break;
+    case DW_FORM_data8:
+      Emit(".8byte   ");
+      break;
+    case DW_FORM_sec_offset:
+      /* if DWARF64, should be .8byte? */
+      Emit(".4byte   ");
+      break;
+    case DW_FORM_addr: /* Should we use DWARF64? for now, we generate .8byte as gcc does for DW_FORM_addr */
+      Emit(".8byte   ");
+      break;
+    case DW_FORM_exprloc:
+      Emit(".uleb128 ");
+      break;
+    default:
+      CHECK_FATAL(maple::GetDwFormName(dwform) != nullptr,
+                  "GetDwFormName() return null in Emitter::EmitDIFormSpecification");
+      LogInfo::MapleLogger() << "unhandled : " << maple::GetDwFormName(dwform) << std::endl;
+      ASSERT(0, "NYI");
+  }
+}
+
+void Emitter::EmitDIAttrValue(DBGDie *die, DBGDieAttr *attr, DwAt attrName, DwTag tagName, DebugInfo *di) {
+  MapleVector<DBGDieAttr*> &attrvec = die->GetAttrVec();
+
+  static MIRFunction *lastMIRFunc = nullptr;
+
+  switch (attr->GetDwForm()) {
+    case DW_FORM_string: {
+      const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(attr->GetId());
+      Emit("\"").Emit(name).Emit("\"");
+      Emit(CMNT "len = ");
+      EmitDecUnsigned(name.length() + 1);
+    } break;
+    case DW_FORM_strp:
+      Emit(".L" XSTR(DEBUG_STR_LABEL));
+      outStream << attr->GetId();
+      break;
+    case DW_FORM_data1:
+#if DEBUG
+      if (attr->GetI() == kDbgDefaultVal) {
+        EmitHexUnsigned(attr->GetI());
+      } else
+#endif
+      EmitHexUnsigned(uint8_t(attr->GetI()));
+      break;
+    case DW_FORM_data2:
+#if DEBUG
+      if (attr->GetI() == kDbgDefaultVal) {
+        EmitHexUnsigned(attr->GetI());
+      } else
+#endif
+      EmitHexUnsigned(uint16_t(attr->GetI()));
+      break;
+    case DW_FORM_data4:
+#if DEBUG
+      if (attr->GetI() == kDbgDefaultVal) {
+        EmitHexUnsigned(attr->GetI());
+      } else
+#endif
+      EmitHexUnsigned(uint32_t(attr->GetI()));
+      break;
+    case DW_FORM_data8:
+      if (attrName == DW_AT_high_pc) {
+        if (tagName == DW_TAG_compile_unit) {
+          Emit(".L" XSTR(TEXT_END) "-.L" XSTR(TEXT_BEGIN));
+        } else if (tagName == DW_TAG_subprogram) {
+          DBGDieAttr *name = LFindAttribute(attrvec, DW_AT_name);
+          if (name == nullptr) {
+            DBGDieAttr *spec = LFindAttribute(attrvec, DW_AT_specification);
+            CHECK_FATAL(spec != nullptr, "spec is null in Emitter::EmitDIAttrValue");
+            DBGDie *decl = di->GetDie(spec->GetId());
+            name = LFindAttribute(decl->GetAttrVec(), DW_AT_name);
+          }
+          CHECK_FATAL(name != nullptr, "name is null in Emitter::EmitDIAttrValue");
+          const std::string &str = GlobalTables::GetStrTable().GetStringFromStrIdx(name->GetId());
+
+          MIRBuilder *mirbuilder = GetCG()->GetMIRModule()->GetMIRBuilder();
+          MIRFunction *mfunc = mirbuilder->GetFunctionFromName(str);
+          lastMIRFunc = mfunc;
+          MapleMap<MIRFunction*, std::pair<LabelIdx, LabelIdx> >::iterator it =
+              CG::GetFuncWrapLabels().find(mfunc);
+          if (it != CG::GetFuncWrapLabels().end()) {
+            EmitLabelForFunc(mfunc, (*it).second.second);  /* end label */
+          } else {
+            EmitLabelRef(attr->GetId());      /* maybe deadbeef */
+          }
+          Emit("-");
+          if (it != CG::GetFuncWrapLabels().end()) {
+            EmitLabelForFunc(mfunc, (*it).second.first);  /* start label */
+          } else {
+            DBGDieAttr *lowpc = LFindAttribute(attrvec, DW_AT_low_pc);
+            CHECK_FATAL(lowpc != nullptr, "lowpc is null in Emitter::EmitDIAttrValue");
+            EmitLabelRef(lowpc->GetId());    /* maybe deadbeef */
+          }
+        } else if (tagName == DW_TAG_lexical_block) {
+          auto i = static_cast<uint32>(attr->GetU());
+          if (GetCG()->GetMIRModule()->GetDbgInfo()->IsScopeIdEmited(lastMIRFunc, i)) {
+            (void)Emit(".LScp." + std::to_string(i) + "E-.LScp." + std::to_string(i) + "B");
+          } else {
+            (void)Emit(0);
+          }
+        }
+      } else {
+        EmitHexUnsigned(static_cast<uint64>(static_cast<int64>(attr->GetI())));
+      }
+      break;
+    case DW_FORM_sec_offset:
+      if (attrName == DW_AT_stmt_list) {
+        Emit(".L");
+        Emit(XSTR(DEBUG_LINE_0));
+      }
+      break;
+    case DW_FORM_addr:
+      if (attrName == DW_AT_low_pc) {
+        if (tagName == DW_TAG_compile_unit) {
+          Emit(".L" XSTR(TEXT_BEGIN));
+        } else if (tagName == DW_TAG_subprogram) {
+          /* if decl, name should be found; if def, we try DW_AT_specification */
+          DBGDieAttr *name = LFindAttribute(attrvec, DW_AT_name);
+          if (name == nullptr) {
+            DBGDieAttr *spec = LFindAttribute(attrvec, DW_AT_specification);
+            CHECK_FATAL(spec != nullptr, "spec is null in Emitter::EmitDIAttrValue");
+            DBGDie *decl = di->GetDie(spec->GetId());
+            name = LFindAttribute(decl->GetAttrVec(), DW_AT_name);
+          }
+          CHECK_FATAL(name != nullptr, "name is null in Emitter::EmitDIAttrValue");
+          const std::string &str = GlobalTables::GetStrTable().GetStringFromStrIdx(name->GetId());
+          MIRBuilder *mirbuilder = GetCG()->GetMIRModule()->GetMIRBuilder();
+          MIRFunction *mfunc = mirbuilder->GetFunctionFromName(str);
+          MapleMap<MIRFunction*, std::pair<LabelIdx, LabelIdx> >::iterator
+              it = CG::GetFuncWrapLabels().find(mfunc);
+          if (it != CG::GetFuncWrapLabels().end()) {
+            EmitLabelForFunc(mfunc, (*it).second.first);  /* it is a <pair> */
+          } else {
+            EmitLabelRef(attr->GetId());     /* maybe deadbeef */
+          }
+        } else if (tagName == DW_TAG_label) {
+          LabelIdx labelIdx = GetLabelIdxForLabelDie(die);
+          DBGDie *subpgm = die->GetParent();
+          ASSERT(subpgm->GetTag() == DW_TAG_subprogram, "Label DIE should be a child of a Subprogram DIE");
+          DBGDieAttr *fnameAttr = LFindAttribute(subpgm->GetAttrVec(), DW_AT_name);
+          if (!fnameAttr) {
+            DBGDieAttr *specAttr = LFindAttribute(subpgm->GetAttrVec(), DW_AT_specification);
+            CHECK_FATAL(specAttr, "pointer is null");
+            DBGDie *twin = di->GetDie(static_cast<uint32>(specAttr->GetU()));
+            fnameAttr = LFindAttribute(twin->GetAttrVec(), DW_AT_name);
+          }
+          CHECK_FATAL(fnameAttr, "");
+          const std::string &fnameStr = GlobalTables::GetStrTable().GetStringFromStrIdx(fnameAttr->GetId());
+          auto *res = memPool->New<cfi::LabelOperand>(fnameStr.c_str(), labelIdx, *memPool);
+          cfi::CFIOpndEmitVisitor cfiVisitor(*this);
+          res->Accept(cfiVisitor);
+        } else if (tagName == DW_TAG_lexical_block) {
+          auto i = static_cast<uint32>(attr->GetU());
+          if (GetCG()->GetMIRModule()->GetDbgInfo()->IsScopeIdEmited(lastMIRFunc, i)) {
+            (void)Emit(".LScp." + std::to_string(i) + "B");
+          } else {
+            (void)Emit(0);
+          }
+        }
+      } else if (attrName == DW_AT_high_pc) {
+        if (tagName == DW_TAG_compile_unit) {
+          Emit(".L" XSTR(TEXT_END) "-.L" XSTR(TEXT_BEGIN));
+        }
+      } else {
+        Emit("XXX--ADDR--XXX");
+      }
+      break;
+    case DW_FORM_ref4:
+      if (attrName == DW_AT_type) {
+        DBGDie *die0 = di->GetDie(static_cast<uint32>(attr->GetU()));
+        if (die0->GetOffset() != 0) {
+          EmitHexUnsigned(die0->GetOffset());
+        } else {
+          /* unknown type, missing mplt */
+          EmitHexUnsigned(di->GetDummyTypeDie()->GetOffset());
+          Emit(CMNT "Warning: dummy type used");
+        }
+      } else if (attrName == DW_AT_specification || attrName == DW_AT_sibling) {
+        DBGDie *die0 = di->GetDie(static_cast<uint32>(attr->GetU()));
+        ASSERT(die0->GetOffset(), "");
+        EmitHexUnsigned(die0->GetOffset());
+      } else if (attrName == DW_AT_object_pointer) {
+        GStrIdx thisIdx = GlobalTables::GetStrTable().GetStrIdxFromName(kDebugMapleThis);
+        DBGDie *that = LFindChildDieWithName(die, DW_TAG_formal_parameter, thisIdx);
+        /* need to find the this or self based on the source language
+           what is the name for 'this' used in mapleir?
+           this has to be with respect to a function */
+        if (that) {
+          EmitHexUnsigned(that->GetOffset());
+        } else {
+          EmitHexUnsigned(attr->GetU());
+        }
+      } else {
+        Emit(" OFFSET ");
+        EmitHexUnsigned(attr->GetU());
+      }
+      break;
+    case DW_FORM_exprloc: {
+      DBGExprLoc *elp = attr->GetPtr();
+      switch (elp->GetOp()) {
+        case DW_OP_call_frame_cfa:
+          EmitHexUnsigned(1);
+          (void)Emit(CMNT "size");
+          Emit("\n\t.byte    ");
+          EmitHexUnsigned(elp->GetOp());
+          (void)Emit(CMNT);
+          (void)Emit(maple::GetDwOpName(elp->GetOp()));
+          break;
+        case DW_OP_addr:
+          EmitHexUnsigned(k9ByteSize);
+          (void)Emit(CMNT "size");
+          Emit("\n\t.byte    ");
+          EmitHexUnsigned(elp->GetOp());
+          Emit(CMNT);
+          (void)Emit(maple::GetDwOpName(elp->GetOp()));
+          Emit("\n\t.8byte   ");
+          (void)Emit(GlobalTables::GetStrTable().GetStringFromStrIdx(
+              static_cast<uint32>(elp->GetGvarStridx())).c_str());
+          break;
+        case DW_OP_fbreg:
+          EmitHexUnsigned(1 + namemangler::GetSleb128Size(elp->GetFboffset()));
+          (void)Emit(CMNT "uleb128 size");
+          Emit("\n\t.byte    ");
+          EmitHexUnsigned(elp->GetOp());
+          (void)Emit(CMNT);
+          (void)Emit(maple::GetDwOpName(elp->GetOp()));
+          Emit("\n\t.sleb128 ");
+          EmitDecSigned(elp->GetFboffset());
+          (void)Emit(CMNT "fboffset");
+          break;
+        case DW_OP_breg0:
+        case DW_OP_breg1:
+        case DW_OP_breg2:
+        case DW_OP_breg3:
+        case DW_OP_breg4:
+        case DW_OP_breg5:
+        case DW_OP_breg6:
+        case DW_OP_breg7:
+          EmitHexUnsigned(k2ByteSize);
+          (void)Emit(CMNT "size");
+          Emit("\n\t.byte    ");
+          EmitHexUnsigned(elp->GetOp());
+          Emit(CMNT);
+          (void)Emit(maple::GetDwOpName(elp->GetOp()));
+          Emit("\n\t.sleb128 ");
+          EmitDecSigned(0);
+          (void)Emit(CMNT "offset");
+          break;
+        default:
+          EmitHexUnsigned(uintptr_t(elp));
+          break;
+      }
+    } break;
+    default:
+      CHECK_FATAL(maple::GetDwFormName(attr->GetDwForm()) != nullptr,
+                  "GetDwFormName return null in Emitter::EmitDIAttrValue");
+      LogInfo::MapleLogger() << "unhandled : " << maple::GetDwFormName(attr->GetDwForm()) << std::endl;
+      ASSERT(0, "NYI");
+  }
+}
+
+void Emitter::EmitDIDebugInfoSection(DebugInfo *mirdi) {
+  /* From DWARF Standard Specification V4. 7.5.1
+     collect section size */
+  Emit("\t.section\t.debug_info,\"\",@progbits\n");
+  /* label to mark start of the .debug_info section */
+  Emit(".L" XSTR(DEBUG_INFO_0) ":\n");
+  /* $ 7.5.1.1 */
+  Emit("\t.4byte\t");
+  EmitHexUnsigned(mirdi->GetDebugInfoLength());
+  Emit(CMNT "section length\n");
+  /* DWARF version. uhalf. */
+  Emit("\t.2byte\t");
+  /* 4 for version 4. */
+  EmitHexUnsigned(kDwarfVersion);
+  Emit("\n");
+  /* debug_abbrev_offset. 4byte for 32-bit, 8byte for 64-bit */
+  Emit("\t.4byte\t.L" XSTR(DEBUG_ABBREV_0) "\n");
+  /* address size. ubyte */
+  Emit("\t.byte\t");
+  EmitHexUnsigned(kSizeOfPTR);
+  Emit("\n");
+  /*
+   * 7.5.1.2 type unit header
+   * currently empty...
+   *
+   * 7.5.2 Debugging Information Entry (DIE)
+   */
+  Emitter *emitter = this;
+  MapleVector<DBGAbbrevEntry*> &abbrevVec = mirdi->GetAbbrevVec();
+  ApplyInPrefixOrder(mirdi->GetCompUnit(), [&abbrevVec, &emitter, &mirdi](DBGDie *die) {
+    if (!die) {
+      /* emit the null entry and return */
+      emitter->Emit("\t.byte    0x0\n");
+      return;
+    }
+    if (!die->GetKeep()) {
+      return;
+    }
+    bool verbose = emitter->GetCG()->GenerateVerboseAsm();
+    if (verbose) {
+      emitter->Emit("\n");
+    }
+    emitter->Emit("\t.uleb128 ");
+    emitter->EmitHexUnsigned(die->GetAbbrevId());
+    if (verbose) {
+      emitter->Emit(CMNT);
+      CHECK_FATAL(maple::GetDwTagName(die->GetTag()) != nullptr,
+                  "GetDwTagName(die->GetTag()) return null in Emitter::EmitDIDebugInfoSection");
+      emitter->Emit(maple::GetDwTagName(die->GetTag()));
+      emitter->Emit(" Offset= ");
+      emitter->EmitHexUnsigned(die->GetOffset());
+      emitter->Emit(" (");
+      emitter->EmitDecUnsigned(die->GetOffset());
+      emitter->Emit(" ),  Size= ");
+      emitter->EmitHexUnsigned(die->GetSize());
+      emitter->Emit(" (");
+      emitter->EmitDecUnsigned(die->GetSize());
+      emitter->Emit(" )\n");
+    } else {
+      emitter->Emit("\n");
+    }
+    DBGAbbrevEntry *diae = LFindAbbrevEntry(abbrevVec, die->GetAbbrevId());
+    CHECK_FATAL(diae != nullptr, "diae is null in Emitter::EmitDIDebugInfoSection");
+    MapleVector<uint32> &apl = diae->GetAttrPairs();  /* attribute pair list */
+
+    std::string sfile, spath;
+    if (diae->GetTag() == DW_TAG_compile_unit && sfile.empty()) {
+      /* get full source path from fileMap[2] */
+      if (emitter->GetFileMap().size() > k2ByteSize) {  /* have src file map */
+        std::string srcPath = emitter->GetFileMap()[k2ByteSize];
+        size_t t = srcPath.rfind("/");
+        ASSERT(t != std::string::npos, "");
+        sfile = srcPath.substr(t + 1);
+        spath = srcPath.substr(0, t);
+      }
+    }
+
+    for (size_t i = 0; i < diae->GetAttrPairs().size(); i += k2ByteSize) {
+      DBGDieAttr *attr = LFindAttribute(die->GetAttrVec(), DwAt(apl[i]));
+      ASSERT_NOT_NULL(attr);
+      if (!attr->GetKeep()) {
+        continue;
+      }
+      if (!LShouldEmit(unsigned(apl[i + 1]))) {
+        continue;
+      }
+      /* update DW_AT_name and DW_AT_comp_dir attrs under DW_TAG_compile_unit
+         to be C/C++ */
+      if (!sfile.empty()) {
+        if (attr->GetDwAt() == DW_AT_name) {
+          attr->SetId(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(sfile).GetIdx());
+          emitter->GetCG()->GetMIRModule()->GetDbgInfo()->AddStrps(attr->GetId());
+        } else if (attr->GetDwAt() == DW_AT_comp_dir) {
+          attr->SetId(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(spath).GetIdx());
+          emitter->GetCG()->GetMIRModule()->GetDbgInfo()->AddStrps(attr->GetId());
+        }
+      }
+      emitter->Emit("\t");
+      emitter->EmitDIFormSpecification(unsigned(apl[i + 1]));
+      emitter->EmitDIAttrValue(die, attr, unsigned(apl[i]), diae->GetTag(), mirdi);
+      if (verbose) {
+        emitter->Emit(CMNT);
+        emitter->Emit(maple::GetDwAtName(unsigned(apl[i])));
+        emitter->Emit(" : ");
+        emitter->Emit(maple::GetDwFormName(unsigned(apl[i + 1])));
+        if (apl[i + 1] == DW_FORM_strp || apl[i + 1] == DW_FORM_string) {
+          emitter->Emit(" : ");
+          emitter->Emit(GlobalTables::GetStrTable().GetStringFromStrIdx(attr->GetId()).c_str());
+        } else if (apl[i] == DW_AT_data_member_location) {
+          emitter->Emit(" : ");
+          emitter->Emit(apl[i + 1]).Emit("  attr= ");
+          emitter->EmitHexUnsigned(uintptr_t(attr));
+        }
+      }
+      emitter->Emit("\n");
+    }
+  });
+}
+
+void Emitter::EmitDIDebugAbbrevSection(DebugInfo *mirdi) {
+  Emit("\t.section\t.debug_abbrev,\"\",@progbits\n");
+  Emit(".L" XSTR(DEBUG_ABBREV_0) ":\n");
+
+  /* construct a list of DI abbrev entries
+     1. DW_TAG_compile_unit 0x11
+     2. DW_TAG_subprogram   0x2e */
+  bool verbose = GetCG()->GenerateVerboseAsm();
+  for (DBGAbbrevEntry *diae : mirdi->GetAbbrevVec()) {
+    if (!diae) {
+      continue;
+    }
+    /* ID */
+    if (verbose) {
+      Emit("\n");
+    }
+    Emit("\t.uleb128 ");
+    EmitHexUnsigned(diae->GetAbbrevId());
+    if (verbose) {
+      Emit(CMNT "Abbrev Entry ID");
+    }
+    Emit("\n");
+    /* TAG */
+    Emit("\t.uleb128 ");
+    EmitHexUnsigned(diae->GetTag());
+    CHECK_FATAL(maple::GetDwTagName(diae->GetTag()) != nullptr,
+                "GetDwTagName return null in Emitter::EmitDIDebugAbbrevSection");
+    if (verbose) {
+      Emit(CMNT);
+      Emit(maple::GetDwTagName(diae->GetTag()));
+    }
+    Emit("\n");
+
+    MapleVector<uint32> &apl = diae->GetAttrPairs();  /* attribute pair list */
+    /* children? */
+    Emit("\t.byte    ");
+    EmitHexUnsigned(diae->GetWithChildren());
+    if (verbose) {
+      Emit(diae->GetWithChildren() ? CMNT "DW_CHILDREN_yes" : CMNT "DW_CHILDREN_no");
+    }
+    Emit("\n");
+
+    for (size_t i = 0; i < diae->GetAttrPairs().size(); i += k2ByteSize) {
+      /* odd entry -- DW_AT_*, even entry -- DW_FORM_* */
+      Emit("\t.uleb128 ");
+      EmitHexUnsigned(apl[i]);
+      CHECK_FATAL(maple::GetDwAtName(unsigned(apl[i])) != nullptr,
+                  "GetDwAtName return null in Emitter::EmitDIDebugAbbrevSection");
+      if (verbose) {
+        Emit(CMNT);
+        Emit(maple::GetDwAtName(unsigned(apl[i])));
+      }
+      Emit("\n");
+      Emit("\t.uleb128 ");
+      EmitHexUnsigned(apl[i + 1]);
+      CHECK_FATAL(maple::GetDwFormName(unsigned(apl[i + 1])) != nullptr,
+                  "GetDwFormName return null in Emitter::EmitDIDebugAbbrevSection");
+      if (verbose) {
+        Emit(CMNT);
+        Emit(maple::GetDwFormName(unsigned(apl[i + 1])));
+      }
+      Emit("\n");
+    }
+    /* end of an abbreviation record */
+    Emit("\t.byte    0x0\n");
+    Emit("\t.byte    0x0\n");
+  }
+  Emit("\t.byte    0x0\n");
+}
+
+void Emitter::EmitDIDebugARangesSection() {
+  Emit("\t.section\t.debug_aranges,\"\",@progbits\n");
+}
+
+void Emitter::EmitDIDebugRangesSection() {
+  Emit("\t.section\t.debug_ranges,\"\",@progbits\n");
+}
+
+void Emitter::EmitDIDebugLineSection() {
+  Emit("\t.section\t.debug_line,\"\",@progbits\n");
+  Emit(".L" XSTR(DEBUG_LINE_0) ":\n");
+}
+
+void Emitter::EmitDIDebugStrSection() {
+  Emit("\t.section\t.debug_str,\"MS\",@progbits,1\n");
+  for (auto it : GetCG()->GetMIRModule()->GetDbgInfo()->GetStrps()) {
+    Emit(".L" XSTR(DEBUG_STR_LABEL));
+    outStream << it;
+    Emit(":\n");
+    const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(it);
+    Emit("\t.string \"").Emit(name).Emit("\"\n");
+  }
+}
+
+void Emitter::FillInClassByteSize(DBGDie *die, DBGDieAttr *byteSizeAttr) const {
+  ASSERT(byteSizeAttr->GetDwForm() == DW_FORM_data1 || byteSizeAttr->GetDwForm() == DW_FORM_data2 ||
+         byteSizeAttr->GetDwForm() == DW_FORM_data4 || byteSizeAttr->GetDwForm() == DW_FORM_data8,
+         "Unknown FORM value for DW_AT_byte_size");
+  if (static_cast<uint32>(byteSizeAttr->GetI()) == kDbgDefaultVal) {
+    /* get class size */
+    DBGDieAttr *typeAttr = LFindDieAttr(die, DW_AT_type);
+    CHECK_FATAL(typeAttr != nullptr, "at_type is nullptr in Emitter::FillInClassByteSize");
+    /* hope this is a global type */
+    uint32 tid = typeAttr->GetId();
+    CHECK_FATAL(tid < Globals::GetInstance()->GetBECommon()->GetSizeOfTypeSizeTable(),
+                "index out of range in Emitter::FillInClassByteSize");
+    int64_t byteSize = static_cast<int64_t>(Globals::GetInstance()->GetBECommon()->GetTypeSize(tid));
+    LUpdateAttrValue(byteSizeAttr, byteSize);
+  }
+}
+
+void Emitter::SetupDBGInfo(DebugInfo *mirdi) {
+  Emitter *emitter = this;
+  MapleVector<DBGAbbrevEntry*> &abbrevVec = mirdi->GetAbbrevVec();
+  ApplyInPrefixOrder(mirdi->GetCompUnit(), [&abbrevVec, &emitter](DBGDie *die) {
+    if (!die || !die->GetKeep()) {
+      return;
+    }
+
+    CHECK_FATAL(maple::GetDwTagName(die->GetTag()) != nullptr,
+                "maple::GetDwTagName(die->GetTag()) is nullptr in Emitter::SetupDBGInfo");
+    if (die->GetAbbrevId() == 0) {
+      LogInfo::MapleLogger() << maple::GetDwTagName(die->GetTag()) << std::endl;
+    }
+    CHECK_FATAL(die->GetAbbrevId() < abbrevVec.size(), "index out of range in Emitter::SetupDBGInfo");
+    ASSERT(abbrevVec[die->GetAbbrevId()]->GetAbbrevId() == die->GetAbbrevId(), "");
+    DBGAbbrevEntry *diae = abbrevVec[die->GetAbbrevId()];
+    switch (diae->GetTag()) {
+      case DW_TAG_subprogram: {
+        DBGExprLoc *exprloc = emitter->memPool->New<DBGExprLoc>(emitter->GetCG()->GetMIRModule());
+        exprloc->GetSimpLoc()->SetDwOp(DW_OP_call_frame_cfa);
+        die->SetAttr(DW_AT_frame_base, exprloc);
+      } break;
+      case DW_TAG_structure_type:
+      case DW_TAG_union_type:
+      case DW_TAG_class_type:
+      case DW_TAG_interface_type: {
+        DBGDieAttr *byteSizeAttr = LFindDieAttr(die, DW_AT_byte_size);
+        if (byteSizeAttr) {
+          emitter->FillInClassByteSize(die, byteSizeAttr);
+        }
+        /* get the type from tid instead of name as it could be changed by type alias */
+        DBGDieAttr *typeAttr = LFindDieAttr(die, DW_AT_type);
+        CHECK_FATAL(typeAttr != nullptr, "at_type is null in Emitter::SetupDBGInfo");
+        uint32 tid = typeAttr->GetId();
+        MIRType *mty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tid);
+        MIRStructType *sty = static_cast<MIRStructType *>(mty);
+        CHECK_FATAL(sty != nullptr, "pointer cast failed");
+        CHECK_FATAL(sty->GetTypeIndex().GetIdx() <
+                    Globals::GetInstance()->GetBECommon()->GetSizeOfStructFieldCountTable(), "");
+        uint32 embeddedIDs = 0;
+        MIRStructType *prevSubstruct = nullptr;
+        for (size_t i = 0; i < sty->GetFields().size(); i++) {
+          TyIdx fieldtyidx = sty->GetFieldsElemt(i).second.first;
+          MIRType *fieldty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldtyidx);
+          if (prevSubstruct) {
+            embeddedIDs += static_cast<uint32>(Globals::GetInstance()->GetBECommon()->GetStructFieldCount(
+                static_cast<uint32>(prevSubstruct->GetTypeIndex().GetIdx())));
+          }
+          prevSubstruct = fieldty->EmbeddedStructType();
+          FieldID fieldID = static_cast<int32>(i + embeddedIDs) + 1;
+          int offset = Globals::GetInstance()->GetBECommon()->GetFieldOffset(*sty, fieldID).first;
+          GStrIdx fldName = sty->GetFieldsElemt(i).first;
+          DBGDie *cdie = LFindChildDieWithName(die, DW_TAG_member, fldName);
+          CHECK_FATAL(cdie != nullptr, "cdie is null in Emitter::SetupDBGInfo");
+          DBGDieAttr *mloc = LFindDieAttr(cdie, DW_AT_data_member_location);
+          CHECK_FATAL(mloc != nullptr, "mloc is null in Emitter::SetupDBGInfo");
+          DBGAbbrevEntry *childDiae = abbrevVec[cdie->GetAbbrevId()];
+          CHECK_FATAL(childDiae != nullptr, "child_diae is null in Emitter::SetupDBGInfo");
+          LUpdateAttrValue(mloc, offset);
+        }
+      } break;
+      default:
+        break;
+    }
+  });
+
+  /* compute DIE sizes and offsets */
+  mirdi->ComputeSizeAndOffsets();
+}
+
+void Emitter::EmitAliasAndRef(const MIRSymbol &sym) {
+  MIRFunction *mFunc = sym.GetFunction();
+  if (mFunc == nullptr || !mFunc->GetAttr(FUNCATTR_alias)) {
+    return;
+  }
+  if (mFunc->GetAttr(FUNCATTR_extern)) {
+    Emit(asmInfo->GetGlobal()).Emit(mFunc->GetName()).Emit("\n");
+  }
+  auto &aliasPrefix = mFunc->GetAttr(FUNCATTR_weakref) ? asmInfo->GetWeakref() : asmInfo->GetSet();
+  Emit(aliasPrefix);
+  Emit(sym.GetName()).Emit(",").Emit(mFunc->GetAttrs().GetAliasFuncName()).Emit("\n");
+}
+
+void Emitter::EmitHugeSoRoutines(bool lastRoutine) {
+  if (!lastRoutine && (javaInsnCount < (static_cast<uint64>(hugeSoSeqence) *
+                                        static_cast<uint64>(kHugeSoInsnCountThreshold)))) {
+    return;
+  }
+  for (auto &target : hugeSoTargets) {
+    (void)Emit("\t.section\t." + std::string(namemangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
+#if TARGX86 || TARGX86_64
+    Emit("\t.align\t8\n");
+#else
+    Emit("\t.align 3\n");
+#endif
+    std::string routineName = target + HugeSoPostFix();
+    Emit("\t.type\t" + routineName + ", %function\n");
+    Emit(routineName + ":\n");
+    Emit("\tadrp\tx17, :got:" + target + "\n");
+    Emit("\tldr\tx17, [x17, :got_lo12:" + target + "]\n");
+    Emit("\tbr\tx17\n");
+    javaInsnCount += kSizeOfHugesoRoutine;
+  }
+  hugeSoTargets.clear();
+  ++hugeSoSeqence;
+}
+
+void ImmOperand::Dump() const {
+  LogInfo::MapleLogger() << "imm:" << value;
+}
+
+void LabelOperand::Dump() const {
+  LogInfo::MapleLogger() << "label:" << labelIndex;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/global.cpp b/src/mapleall/maple_be/src/cg/global.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3801745db379d8eb1ff5c9c1a12b432f06c55f81
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/global.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#if TARGAARCH64
+#include "aarch64_global.h"
+#elif TARGRISCV64
+#include "riscv64_global.h"
+#endif
+#if TARGARM32
+#include "arm32_global.h"
+#endif
+#include "reaching.h"
+#include "cgfunc.h"
+#include "live.h"
+/*
+ * This phase do some optimization using use-def chain and def-use chain.
+ * each function in Run() is a optimization. mainly include 2 parts:
+ * 1. find the number of valid bits for register by finding the definition insn of register,
+ *  and then using the valid bits to delete redundant insns.
+ * 2. copy Propagate:
+ *  a. forward copy propagate
+ *      this optimization aim to optimize following:
+ *    mov x100, x200;
+ *    BBs:
+ *    ...
+ *    mOp ..., x100  /// multiple site that use x100
+ *    =>
+ *    mov x200, x200
+ *    BBs:
+ *    ...
+ *    mOp ..., x200 // multiple site that use x100
+ *   b. backward copy propagate
+ *      this optimization aim to optimize following:
+ *    mOp x200, ...  // Define insn of x200
+ *    ...
+ *    mOp ..., x200  // use site of x200
+ *    mov x100, x200;
+ *      =>
+ *    mOp x100, ...  // Define insn of x200
+ *    ...
+ *    mOp ..., x100  // use site of x200
+ *    mov x100, x100;
+ *
+ * NOTE: after insn is modified, UD-chain and DU-chain should be maintained by self. currently several common
+ *   interface has been implemented in RD, but they must be used reasonably. specific instructions for use
+ *   can be found at the begining of corresponding function.
+ */
+namespace maplebe {
+using namespace maple;
+
+bool CgGlobalOpt::PhaseRun(maplebe::CGFunc &f) {
+  ReachingDefinition *reachingDef = nullptr;
+  LiveAnalysis *live = nullptr;
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel2) {
+    reachingDef = GET_ANALYSIS(CgReachingDefinition, f);
+    live = GET_ANALYSIS(CgLiveAnalysis, f);
+  }
+  if (reachingDef == nullptr || !f.GetRDStatus()) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &CgReachingDefinition::id);
+    return false;
+  }
+  reachingDef->SetAnalysisMode(kRDAllAnalysis);
+  GlobalOpt *globalOpt = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  globalOpt = GetPhaseAllocator()->New<AArch64GlobalOpt>(f);
+#endif
+#if TARGARM32
+  globalOpt = GetPhaseAllocator()->New<Arm32GlobalOpt>(f);
+#endif
+  globalOpt->Run();
+  if (live != nullptr) {
+    live->ClearInOutDataInfo();
+  }
+  return true;
+}
+
+void CgGlobalOpt::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgReachingDefinition>();
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.PreservedAllExcept<CgLiveAnalysis>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgGlobalOpt, globalopt)
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/global_schedule.cpp b/src/mapleall/maple_be/src/cg/global_schedule.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..efab5310db4399defd033645f2d9dd25dc5202c1
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/global_schedule.cpp
@@ -0,0 +1,54 @@
+/*
+* Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include "global_schedule.h"
+#include "optimize_common.h"
+#include "aarch64_data_dep_base.h"
+#include "cg.h"
+
+namespace maplebe {
+void GlobalSchedule::Run() {
+  FCDG *fcdg = cda.GetFCDG();
+  CHECK_FATAL(fcdg != nullptr, "control dependence analysis failed");
+  cda.GenerateFCDGDot();
+  cda.GenerateCFGDot();
+  DotGenerator::GenerateDot("globalsched", cgFunc, cgFunc.GetMirModule(),
+                            true, cgFunc.GetName());
+  for (auto region : fcdg->GetAllRegions()) {
+    if (region == nullptr) {
+      continue;
+    }
+    idda.Run(*region, dataNodes);
+    idda.GenerateInterDDGDot(dataNodes);
+  }
+}
+
+void CgGlobalSchedule::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgControlDepAnalysis>();
+}
+
+bool CgGlobalSchedule::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *gsMemPool = GetPhaseMemPool();
+  ControlDepAnalysis *cda = GET_ANALYSIS(CgControlDepAnalysis, f);
+  MAD *mad = Globals::GetInstance()->GetMAD();
+  // Need move to target
+  auto *ddb = gsMemPool->New<AArch64DataDepBase>(*gsMemPool, f, *mad);
+  auto *idda = gsMemPool->New<InterDataDepAnalysis>(f, *gsMemPool, *ddb);
+  auto *globalSched = gsMemPool->New<GlobalSchedule>(*gsMemPool, f, *cda, *idda);
+  globalSched->Run();
+  return true;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgGlobalSchedule, globalschedule)
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/ico.cpp b/src/mapleall/maple_be/src/cg/ico.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..078260aeb49139edc3cb2ea4af4f2c358ff92cfd
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/ico.cpp
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ico.h"
+#include "cg_option.h"
+#ifdef TARGAARCH64
+#include "aarch64_ico.h"
+#include "aarch64_isa.h"
+#include "aarch64_insn.h"
+#elif TARGRISCV64
+#include "riscv64_ico.h"
+#include "riscv64_isa.h"
+#include "riscv64_insn.h"
+#elif TARGARM32
+#include "arm32_ico.h"
+#include "arm32_isa.h"
+#include "arm32_insn.h"
+#endif
+#include "cg.h"
+
+/*
+ * This phase implements if-conversion optimization,
+ * which tries to convert conditional branches into cset/csel instructions
+ */
+#define ICO_DUMP_NEWPM CG_DEBUG_FUNC(f)
+namespace maplebe {
+Insn *ICOPattern::FindLastCmpInsn(BB &bb) const {
+  if (bb.GetKind() != BB::kBBIf) {
+    return nullptr;
+  }
+  FOR_BB_INSNS_REV(insn, (&bb)) {
+    if (cgFunc->GetTheCFG()->GetInsnModifier()->IsCompareInsn(*insn)) {
+      return insn;
+    }
+  }
+  return nullptr;
+}
+
+std::vector<LabelOperand*> ICOPattern::GetLabelOpnds(Insn &insn) const {
+  std::vector<LabelOperand*> labelOpnds;
+  for (uint32 i = 0; i < insn.GetOperandSize(); i++) {
+    if (insn.GetOperand(i).IsLabelOpnd()) {
+      labelOpnds.emplace_back(static_cast<LabelOperand*>(&insn.GetOperand(i)));
+    }
+  }
+  return labelOpnds;
+}
+
+bool CgIco::PhaseRun(maplebe::CGFunc &f) {
+  LiveAnalysis *live = GET_ANALYSIS(CgLiveAnalysis, f);
+  if (ICO_DUMP_NEWPM) {
+    DotGenerator::GenerateDot("ico-before", f, f.GetMirModule());
+  }
+  MemPool *memPool = GetPhaseMemPool();
+  IfConversionOptimizer *ico = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  ico = memPool->New<AArch64IfConversionOptimizer>(f, *memPool);
+#endif
+#if TARGARM32
+  ico = memPool->New<Arm32IfConversionOptimizer>(f, *memPool);
+#endif
+  const std::string &funcClass = f.GetFunction().GetBaseClassName();
+  const std::string &funcName = f.GetFunction().GetBaseFuncName();
+  std::string name = funcClass + funcName;
+  ico->Run(name);
+  if (ICO_DUMP_NEWPM) {
+    DotGenerator::GenerateDot("ico-after", f, f.GetMirModule());
+  }
+  /* the live range info may changed, so invalid the info. */
+  if (live != nullptr) {
+    live->ClearInOutDataInfo();
+  }
+  return false;
+}
+void CgIco::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.PreservedAllExcept<CgLiveAnalysis>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgIco, ico)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/insn.cpp b/src/mapleall/maple_be/src/cg/insn.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a74c72254a4682fb2a9ff05b1867b6b62efacadb
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/insn.cpp
@@ -0,0 +1,350 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "insn.h"
+#include "isa.h"
+#include "cg.h"
+namespace maplebe {
+bool Insn::IsMachineInstruction() const {
+  return md && md->IsPhysicalInsn() && Globals::GetInstance()->GetTarget()->IsTargetInsn(mOp);
+}
+/* phi is not physical insn */
+bool Insn::IsPhi() const {
+  return md ? md->IsPhi() : false;
+}
+bool Insn::IsLoad() const {
+  return md ? md->IsLoad() : false;
+}
+bool Insn::IsStore() const {
+  return md ? md->IsStore() : false;
+}
+bool Insn::IsMove() const {
+  return md ? md->IsMove() : false;
+}
+bool Insn::IsBranch() const {
+  return md ? md->IsBranch() : false;
+}
+bool Insn::IsCondBranch() const {
+  return md ? md->IsCondBranch() : false;
+}
+bool Insn::IsUnCondBranch() const {
+  return md ? md->IsUnCondBranch() : false;
+}
+bool Insn::IsBasicOp() const {
+  return md ? md->IsBasicOp() : false;
+}
+bool Insn::IsConversion() const {
+  return md? md->IsConversion() : false;
+}
+bool Insn::IsUnaryOp() const {
+  return md ? md->IsUnaryOp() : false;
+}
+bool Insn::IsShift() const {
+  return md ? md->IsShift() : false;
+}
+bool Insn::IsCall() const {
+  return md ? md->IsCall() : false;
+}
+bool Insn::IsTailCall() const {
+  return md ? md->IsTailCall() : false;
+}
+bool Insn::IsAsmInsn() const {
+  return md ? md->IsInlineAsm() : false;
+}
+bool Insn::IsDMBInsn() const {
+  return md ? md->IsDMB() : false;
+}
+bool Insn::IsAtomic() const {
+  return md ? md->IsAtomic() : false;
+}
+bool Insn::IsVolatile() const {
+  return md ? md->IsVolatile() : false;
+}
+bool Insn::IsMemAccessBar() const {
+  return md ? md->IsMemAccessBar() : false;
+}
+bool Insn::IsMemAccess() const {
+  return md ? md->IsMemAccess() : false;
+}
+bool Insn::CanThrow() const {
+  return md ? md->CanThrow() : false;
+}
+bool Insn::IsVectorOp() const {
+  return md ? md->IsVectorOp() : false;
+}
+bool Insn::HasLoop() const {
+  return md ? md->HasLoop() : false;
+}
+uint32 Insn::GetLatencyType() const {
+  return md ? md->GetLatencyType() : false;
+}
+uint32 Insn::GetAtomicNum() const {
+  return md ? md->GetAtomicNum() : false;
+}
+bool Insn::IsSpecialIntrinsic() const {
+  return md ? md->IsSpecialIntrinsic() : false;
+}
+bool Insn::IsLoadPair() const {
+  return md ? md->IsLoadPair() : false;
+}
+bool Insn::IsStorePair() const {
+  return md ? md->IsStorePair() : false;
+}
+bool Insn::IsLoadStorePair() const {
+  return md ? md->IsLoadStorePair() : false;
+}
+bool Insn::IsLoadLabel() const {
+  return md && md->IsLoad() && GetOperand(kInsnSecondOpnd).GetKind() == Operand::kOpdBBAddress;
+}
+bool Insn::OpndIsDef(uint32 id) const {
+  return md ? md->GetOpndDes(id)->IsDef() : false;
+}
+bool Insn::OpndIsUse(uint32 id) const {
+  return md ? md->GetOpndDes(id)->IsUse() : false;
+}
+bool Insn::IsClinit() const {
+  return Globals::GetInstance()->GetTarget()->IsClinitInsn(mOp);
+}
+bool Insn::IsComment() const {
+  return mOp == abstract::MOP_comment && !md->IsPhysicalInsn();
+}
+
+bool Insn::IsImmaterialInsn() const {
+  return IsComment();
+}
+Operand *Insn::GetMemOpnd() const {
+  for (uint32 i = 0; i < opnds.size(); ++i) {
+    Operand &opnd = GetOperand(i);
+    if (opnd.IsMemoryAccessOperand()) {
+      return &opnd;
+    }
+  }
+  return nullptr;
+}
+void Insn::SetMemOpnd(MemOperand *memOpnd) {
+  for (uint32 i = 0; i < static_cast<uint32>(opnds.size()); ++i) {
+    Operand &opnd = GetOperand(i);
+    if (opnd.IsMemoryAccessOperand()) {
+      SetOperand(i, *memOpnd);
+      return;
+    }
+  }
+}
+
+bool Insn::IsRegDefined(regno_t regNO) const {
+  return GetDefRegs().count(regNO);
+}
+
+std::set<uint32> Insn::GetDefRegs() const {
+  std::set<uint32> defRegNOs;
+  size_t opndNum = opnds.size();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = GetOperand(i);
+    auto *regProp = md->opndMD[i];
+    bool isDef = regProp->IsDef();
+    if (!isDef && !opnd.IsMemoryAccessOperand()) {
+      continue;
+    }
+    if (opnd.IsList()) {
+      for (auto *op : static_cast<ListOperand&>(opnd).GetOperands()) {
+        ASSERT(op != nullptr, "invalid operand in list operand");
+        defRegNOs.emplace(op->GetRegisterNumber());
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      RegOperand *base = memOpnd.GetBaseRegister();
+      if (base != nullptr) {
+        if (memOpnd.GetAddrMode() == MemOperand::kAddrModeBOi &&
+            (memOpnd.IsPostIndexed() || memOpnd.IsPreIndexed())) {
+          ASSERT(!defRegNOs.count(base->GetRegisterNumber()), "duplicate def in one insn");
+          defRegNOs.emplace(base->GetRegisterNumber());
+        }
+      }
+    } else if (opnd.IsConditionCode() || opnd.IsRegister()) {
+      defRegNOs.emplace(static_cast<RegOperand&>(opnd).GetRegisterNumber());
+    }
+  }
+  return defRegNOs;
+}
+
+#if DEBUG
+void Insn::Check() const {
+  if (!md) {
+    CHECK_FATAL(false, " need machine description for target insn ");
+  }
+  for (uint32 i = 0; i < GetOperandSize(); ++i) {
+    Operand &opnd = GetOperand(i);
+    if (opnd.GetKind() != md->GetOpndDes(i)->GetOperandType()) {
+      CHECK_FATAL(false, " operand type does not match machine description ");
+    }
+  }
+}
+#endif
+
+Insn *Insn::Clone(MemPool &memPool) const {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *Insn::GetCallTargetOperand() const {
+  ASSERT(IsCall() || IsTailCall(), "should be call");
+  return &GetOperand(kInsnFirstOpnd);
+}
+
+ListOperand *Insn::GetCallArgumentOperand() {
+  ASSERT(IsCall(), "should be call");
+  ASSERT(GetOperand(1).IsList(), "should be list");
+  return &static_cast<ListOperand&>(GetOperand(kInsnSecondOpnd));
+}
+
+
+void Insn::CommuteOperands(uint32 dIndex, uint32 sIndex) {
+  Operand *tempCopy = opnds[sIndex];
+  opnds[sIndex] = opnds[dIndex];
+  opnds[dIndex] = tempCopy;
+}
+
+uint32 Insn::GetBothDefUseOpnd() const {
+  size_t opndNum = opnds.size();
+  uint32 opndIdx = kInsnMaxOpnd;
+  if (md->GetAtomicNum() > 1) {
+    return opndIdx;
+  }
+  for (uint32 i = 0; i < opndNum; ++i) {
+    auto *opndProp = md->GetOpndDes(i);
+    if (opndProp->IsRegUse() && opndProp->IsDef()) {
+      ASSERT(opndIdx == kInsnMaxOpnd, "Do not support yet");
+      opndIdx = i;
+    }
+    if (opnds[i]->IsMemoryAccessOperand()) {
+      auto *MemOpnd = static_cast<MemOperand*>(opnds[i]);
+      if (!MemOpnd->IsIntactIndexed()) {
+        ASSERT(opndIdx == kInsnMaxOpnd, "Do not support yet");
+        opndIdx = i;
+      }
+    }
+  }
+  return opndIdx;
+}
+
+uint32 Insn::GetMemoryByteSize() const {
+  ASSERT(IsMemAccess(), "must be memory access insn");
+  uint32 res = 0;
+  for (size_t i = 0 ; i < opnds.size(); ++i) {
+    if (md->GetOpndDes(i)->GetOperandType() == Operand::kOpdMem) {
+      res = md->GetOpndDes(i)->GetSize();
+    }
+  }
+  ASSERT(res, "cannot access empty memory");
+  if (IsLoadStorePair()) {
+    res = res << 1;
+  }
+  res = res >> 3;
+  return res;
+}
+
+bool Insn::ScanReg(regno_t regNO) const {
+  uint32 opndNum = GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = GetOperand(i);
+    if (opnd.IsList()) {
+      auto &listOpnd = static_cast<ListOperand&>(opnd);
+      for (auto listElem : listOpnd.GetOperands()) {
+        auto *regOpnd = static_cast<RegOperand*>(listElem);
+        ASSERT(regOpnd != nullptr, "parameter operand must be RegOperand");
+        if (regNO == regOpnd->GetRegisterNumber()) {
+          return true;
+        }
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      RegOperand *base = memOpnd.GetBaseRegister();
+      RegOperand *index = memOpnd.GetIndexRegister();
+      if ((base != nullptr && base->GetRegisterNumber() == regNO) ||
+          (index != nullptr && index->GetRegisterNumber() == regNO)) {
+        return true;
+      }
+    } else if (opnd.IsRegister()) {
+      if (static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool Insn::MayThrow() const {
+  if (md->IsMemAccess() && !IsLoadLabel()) {
+    auto *memOpnd = static_cast<MemOperand*>(GetMemOpnd());
+    ASSERT(memOpnd != nullptr, "CG invalid memory operand.");
+    if (memOpnd->IsStackMem()) {
+      return false;
+    }
+  }
+  return md->CanThrow();
+}
+
+void Insn::SetMOP(const InsnDesc &idesc) {
+  mOp = idesc.GetOpc();
+  md = &idesc;
+}
+
+void Insn::Dump() const {
+ASSERT(md != nullptr, "md should not be nullptr");
+  LogInfo::MapleLogger() << "< " << GetId() << " > ";
+  LogInfo::MapleLogger() << md->name << "(" << mOp << ")";
+
+  for (uint32 i = 0; i < GetOperandSize(); ++i) {
+    Operand &opnd = GetOperand(i);
+    LogInfo::MapleLogger() << " (opnd" << i << ": ";
+    Globals::GetInstance()->GetTarget()->DumpTargetOperand(opnd, *md->GetOpndDes(i));
+    LogInfo::MapleLogger() << ")";
+  }
+
+  if (ssaImplicitDefOpnd != nullptr) {
+    LogInfo::MapleLogger() << " (implicitDefOpnd: ";
+    std::array<const std::string, kRegTyLast> prims = { "U", "R", "V", "C", "X", "Vra" };
+    uint32 regType = ssaImplicitDefOpnd->GetRegisterType();
+    ASSERT(regType < kRegTyLast, "unexpected regType");
+    LogInfo::MapleLogger() << (ssaImplicitDefOpnd->IsVirtualRegister() ? "vreg:" : " reg:") << prims[regType];
+    regno_t reg = ssaImplicitDefOpnd->GetRegisterNumber();
+    reg = ssaImplicitDefOpnd->IsVirtualRegister() ? reg : (reg - 1);
+    LogInfo::MapleLogger() << reg;
+    uint32 vb = ssaImplicitDefOpnd->GetValidBitsNum();
+    if (ssaImplicitDefOpnd->GetValidBitsNum() != ssaImplicitDefOpnd->GetSize()) {
+      LogInfo::MapleLogger() << " Vb: [" << vb << "]";
+    }
+    LogInfo::MapleLogger() << " Sz: [" << ssaImplicitDefOpnd->GetSize() << "]" ;
+    LogInfo::MapleLogger() << ")";
+  }
+
+  if (IsVectorOp()) {
+    auto *vInsn = static_cast<const VectorInsn*>(this);
+    if (vInsn->GetNumOfRegSpec() != 0) {
+      LogInfo::MapleLogger() << " (vecSpec: " << vInsn->GetNumOfRegSpec() << ")";
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+VectorRegSpec *VectorInsn::GetAndRemoveRegSpecFromList() {
+  if (regSpecList.size() == 0) {
+    VectorRegSpec *vecSpec = CG::GetCurCGFuncNoConst()->GetMemoryPool()->New<VectorRegSpec>() ;
+    return vecSpec;
+  }
+  VectorRegSpec *ret = regSpecList.back();
+  regSpecList.pop_back();
+  return ret;
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/instruction_selection.cpp b/src/mapleall/maple_be/src/cg/instruction_selection.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df804ae7dd0788c6d6d47b18a73c706443ade05c
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/instruction_selection.cpp
@@ -0,0 +1,19 @@
+/*
+* Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+*
+* OpenArkCompiler is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*
+*     http://license.coscl.org.cn/MulanPSL2
+*
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+    * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+* FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include "instruction_selection.h"
+namespace maplebe {
+bool CgIsel::PhaseRun(maplebe::CGFunc &f) {}
+} /* namespace maplebe */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/src/cg/isa.cpp b/src/mapleall/maple_be/src/cg/isa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..966ab3de81445f0133713260e7a616a3e22594e3
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/isa.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "isa.h"
+namespace maplebe {
+#define DEFINE_MOP(op, ...) const OpndDesc OpndDesc::op = __VA_ARGS__;
+#include "operand.def"
+#undef DEFINE_MOP
+#define DEFINE_MOP(op, ...) {abstract::op, __VA_ARGS__},
+const InsnDesc InsnDesc::abstractId[abstract::kMopLast] = {
+#include "abstract_mmir.def"
+};
+#undef DEFINE_MOP
+
+bool InsnDesc::IsSame(const InsnDesc &left,
+    std::function<bool (const InsnDesc &left, const InsnDesc &right)> cmp) const {
+  return cmp == nullptr ? false : cmp(left, *this);
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/isel.cpp b/src/mapleall/maple_be/src/cg/isel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..45a030c8f982530876f4fbbed9e136a5020ef518
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/isel.cpp
@@ -0,0 +1,1524 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "isel.h"
+#include <map>
+#include <utility>
+#include "factory.h"
+#include "cg.h"
+
+namespace maplebe {
+/* register,                       imm ,                         memory,                        cond */
+#define DEF_FAST_ISEL_MAPPING_INT(SIZE)                                                                       \
+MOperator fastIselMapI##SIZE[Operand::OperandType::kOpdPhi][Operand::OperandType::kOpdPhi] = {                \
+{abstract::MOP_copy_rr_##SIZE, abstract::MOP_copy_ri_##SIZE, abstract::MOP_load_##SIZE, abstract::MOP_undef}, \
+{abstract::MOP_undef,          abstract::MOP_undef,          abstract::MOP_undef,       abstract::MOP_undef}, \
+{abstract::MOP_str_##SIZE,     abstract::MOP_undef,          abstract::MOP_undef,       abstract::MOP_undef}, \
+{abstract::MOP_undef,          abstract::MOP_undef,          abstract::MOP_undef,       abstract::MOP_undef}, \
+};
+#define DEF_FAST_ISEL_MAPPING_FLOAT(SIZE)                                                                       \
+MOperator fastIselMapF##SIZE[Operand::OperandType::kOpdPhi][Operand::OperandType::kOpdPhi] = {                  \
+{abstract::MOP_copy_ff_##SIZE, abstract::MOP_copy_fi_##SIZE, abstract::MOP_load_f_##SIZE, abstract::MOP_undef}, \
+{abstract::MOP_undef,          abstract::MOP_undef,          abstract::MOP_undef,         abstract::MOP_undef}, \
+{abstract::MOP_str_f_##SIZE,   abstract::MOP_undef,          abstract::MOP_undef,         abstract::MOP_undef}, \
+{abstract::MOP_undef,          abstract::MOP_undef,          abstract::MOP_undef,         abstract::MOP_undef}, \
+};
+
+DEF_FAST_ISEL_MAPPING_INT(8)
+DEF_FAST_ISEL_MAPPING_INT(16)
+DEF_FAST_ISEL_MAPPING_INT(32)
+DEF_FAST_ISEL_MAPPING_INT(64)
+DEF_FAST_ISEL_MAPPING_FLOAT(8)
+DEF_FAST_ISEL_MAPPING_FLOAT(16)
+DEF_FAST_ISEL_MAPPING_FLOAT(32)
+DEF_FAST_ISEL_MAPPING_FLOAT(64)
+
+#define DEF_SEL_MAPPING_TBL(SIZE)                                     \
+MOperator SelMapping##SIZE(bool isInt, uint32 x, uint32 y) {          \
+  return isInt ? fastIselMapI##SIZE[x][y] : fastIselMapF##SIZE[x][y]; \
+}
+#define USE_SELMAPPING_TBL(SIZE) \
+{SIZE, SelMapping##SIZE}
+
+DEF_SEL_MAPPING_TBL(8);
+DEF_SEL_MAPPING_TBL(16);
+DEF_SEL_MAPPING_TBL(32);
+DEF_SEL_MAPPING_TBL(64);
+
+std::map<uint32, std::function<MOperator (bool, uint32, uint32)>> fastIselMappingTable = {
+    USE_SELMAPPING_TBL(8),
+    USE_SELMAPPING_TBL(16),
+    USE_SELMAPPING_TBL(32),
+    USE_SELMAPPING_TBL(64)};
+
+MOperator GetFastIselMop(Operand::OperandType dTy, Operand::OperandType sTy, PrimType type) {
+  uint32 bitSize = GetPrimTypeBitSize(type);
+  bool isInteger = IsPrimitiveInteger(type);
+  auto tableDriven = fastIselMappingTable.find(bitSize);
+  if (tableDriven != fastIselMappingTable.end())  {
+    auto funcIt = tableDriven->second;
+    return funcIt(isInteger, dTy, sTy);
+  } else {
+    CHECK_FATAL(false, "unsupport type");
+  }
+  return abstract::MOP_undef;
+}
+
+#define DEF_EXTEND_MAPPING_TBL(TYPE) [](bool isSigned) -> MOperator {                       \
+  return isSigned ? abstract::MOP_sext_rr_##TYPE : abstract::MOP_zext_rr_##TYPE;            \
+}
+using fromToTy = std::pair<uint32, uint32>; /* std::pair<from, to> */
+#define DEF_USE_EXTEND_MAPPING_TBL(FROMSIZE, TOSIZE)                                        \
+{{k##FROMSIZE##BitSize, k##TOSIZE##BitSize}, DEF_EXTEND_MAPPING_TBL(TOSIZE##_##FROMSIZE)}
+
+std::map<fromToTy, std::function<MOperator (bool)>> fastCvtMappingTableI = {
+    DEF_USE_EXTEND_MAPPING_TBL(8, 16),      /* Extend Mapping */
+    DEF_USE_EXTEND_MAPPING_TBL(8, 32),
+    DEF_USE_EXTEND_MAPPING_TBL(8, 64),
+    DEF_USE_EXTEND_MAPPING_TBL(16, 32),
+    DEF_USE_EXTEND_MAPPING_TBL(16, 64),
+    DEF_USE_EXTEND_MAPPING_TBL(32, 64),
+};
+#undef DEF_USE_EXTEND_MAPPING_TBL
+#undef DEF_EXTEND_MAPPING_TBL
+
+static MOperator GetFastCvtMopI(uint32 fromSize, uint32 toSize, bool isSigned) {
+  if (toSize <  k8BitSize || toSize >  k64BitSize) {
+    CHECK_FATAL(false, "unsupport type");
+  }
+  if (fromSize <  k8BitSize || fromSize >  k64BitSize) {
+    CHECK_FATAL(false, "unsupport type");
+  }
+  /* Extend: fromSize < toSize */
+  auto tableDriven =  fastCvtMappingTableI.find({fromSize, toSize});
+  if (tableDriven == fastCvtMappingTableI.end()) {
+    CHECK_FATAL(false, "unsupport cvt");
+  }
+  MOperator mOp = tableDriven->second(isSigned);
+  if (mOp == abstract::MOP_undef) {
+    CHECK_FATAL(false, "unsupport cvt");
+  }
+  return mOp;
+}
+
+/*
+ * fast get MOperator
+ * such as : and, or, shl ...
+ */
+#define DEF_MOPERATOR_MAPPING_FUNC(TYPE) [](uint32 bitSize)->MOperator {                                            \
+  /* 8-bits,                16-bits,                   32-bits,                   64-bits */                        \
+  constexpr static std::array<MOperator, kBitIndexEnd> fastMapping_##TYPE =                                         \
+      {abstract::MOP_##TYPE##_8, abstract::MOP_##TYPE##_16, abstract::MOP_##TYPE##_32, abstract::MOP_##TYPE##_64};  \
+  return fastMapping_##TYPE[GetBitIndex(bitSize)];                                                                  \
+}
+
+#define DEF_FLOAT_MOPERATOR_MAPPING_FUNC(TYPE) [](uint32 bitSize)->MOperator {                                      \
+  /* 8-bits,                16-bits,                   32-bits,                   64-bits */                        \
+  constexpr static std::array<MOperator, kBitIndexEnd> fastMapping_f_##TYPE =                                       \
+      {abstract::MOP_##TYPE##_f_8, abstract::MOP_##TYPE##_f_16,                                                     \
+      abstract::MOP_##TYPE##_f_32, abstract::MOP_##TYPE##_f_64};                                                    \
+  return fastMapping_f_##TYPE[GetBitIndex(bitSize)];                                                                \
+}
+
+void HandleDassign(StmtNode &stmt, MPISel &iSel) {
+  ASSERT(stmt.GetOpCode() == OP_dassign, "expect dassign");
+  auto &dassignNode = static_cast<DassignNode&>(stmt);
+  BaseNode *rhs = dassignNode.GetRHS();
+  ASSERT(rhs != nullptr, "get rhs of dassignNode failed");
+  Operand* opndRhs = iSel.HandleExpr(dassignNode, *rhs);
+  if (opndRhs == nullptr) {
+    return;
+  }
+  iSel.SelectDassign(dassignNode, *opndRhs);
+}
+
+void HandleDassignoff(StmtNode &stmt, MPISel &iSel) {
+  auto &dassignoffNode = static_cast<DassignoffNode&>(stmt);
+  BaseNode *rhs = dassignoffNode.GetRHS();
+  CHECK_FATAL(rhs->GetOpCode() == OP_constval, "dassignoffNode without constval");
+  Operand *opnd0 = iSel.HandleExpr(dassignoffNode, *rhs);
+  iSel.SelectDassignoff(dassignoffNode, *opnd0);
+}
+
+void HandleIassign(StmtNode &stmt, MPISel &iSel) {
+  ASSERT(stmt.GetOpCode() == OP_iassign, "expect iassign");
+  auto &iassignNode = static_cast<IassignNode&>(stmt);
+  BaseNode *rhs = iassignNode.GetRHS();
+  ASSERT(rhs != nullptr, "null ptr check");
+  Operand *opndRhs = iSel.HandleExpr(stmt, *rhs);
+  BaseNode *addr = iassignNode.Opnd(0);
+  ASSERT(addr != nullptr, "null ptr check");
+  Operand *opndAddr = iSel.HandleExpr(stmt, *addr);
+  if (opndRhs == nullptr || opndAddr == nullptr) {
+    return;
+  }
+  if (rhs->GetPrimType() != PTY_agg) {
+    iSel.SelectIassign(iassignNode, *opndAddr, *opndRhs);
+  } else {
+    iSel.SelectAggIassign(iassignNode, *opndAddr, *opndRhs);
+  }
+}
+
+void HandleRegassign(StmtNode &stmt, MPISel &iSel) {
+  ASSERT(stmt.GetOpCode() == OP_regassign, "expect regAssign");
+  auto &regAssignNode = static_cast<RegassignNode&>(stmt);
+  BaseNode *operand = regAssignNode.Opnd(0);
+  ASSERT(operand != nullptr, "get operand of regassignNode failed");
+  Operand *opnd0 = iSel.HandleExpr(regAssignNode, *operand);
+  iSel.SelectRegassign(regAssignNode, *opnd0);
+}
+
+void HandleIassignoff(StmtNode &stmt, MPISel &iSel) {
+  auto &iassignoffNode = static_cast<IassignoffNode&>(stmt);
+  iSel.SelectIassignoff(iassignoffNode);
+}
+
+void HandleLabel(StmtNode &stmt, const MPISel &iSel) {
+  CGFunc *cgFunc = iSel.GetCurFunc();
+  ASSERT(stmt.GetOpCode() == OP_label, "error");
+  auto &label = static_cast<LabelNode&>(stmt);
+  BB *newBB = cgFunc->StartNewBBImpl(false, label);
+  newBB->AddLabel(label.GetLabelIdx());
+  cgFunc->SetLab2BBMap(static_cast<int32>(newBB->GetLabIdx()), *newBB);
+  cgFunc->SetCurBB(*newBB);
+
+  if (cgFunc->GetCleanupLabel() == &label) {
+    cgFunc->SetCleanupBB(*newBB);
+  } else if (cgFunc->GetReturnLabel() == &label) {
+    cgFunc->SetReturnBB(*newBB);
+  }
+}
+
+void HandleGoto(StmtNode &stmt, MPISel &iSel) {
+  CGFunc *cgFunc = iSel.GetCurFunc();
+  cgFunc->UpdateFrequency(stmt);
+  auto &gotoNode = static_cast<GotoNode&>(stmt);
+  ASSERT(gotoNode.GetOpCode() == OP_goto, "expect goto");
+  cgFunc->SetCurBBKind(BB::kBBGoto);
+  iSel.SelectGoto(gotoNode);
+  cgFunc->SetCurBB(*cgFunc->StartNewBB(gotoNode));
+  ASSERT(&stmt == &gotoNode, "stmt must be same as gotoNoe");
+  if ((gotoNode.GetNext() != nullptr) && (gotoNode.GetNext()->GetOpCode() != OP_label)) {
+    ASSERT(cgFunc->GetCurBB()->GetPrev()->GetLastStmt() == &stmt, "check the relation between BB and stmt");
+  }
+}
+
+void HandleIntrinCall(StmtNode &stmt, MPISel &iSel) {
+  auto &call = static_cast<IntrinsiccallNode&>(stmt);
+  iSel.SelectIntrinCall(call);
+}
+
+void HandleRangeGoto(StmtNode &stmt, MPISel &iSel) {
+  CGFunc *cgFunc = iSel.GetCurFunc();
+  auto &rangeGotoNode = static_cast<RangeGotoNode&>(stmt);
+  ASSERT(rangeGotoNode.GetOpCode() == OP_rangegoto, "expect rangegoto");
+  BaseNode *srcNode = rangeGotoNode.Opnd(0);
+  Operand *srcOpnd = iSel.HandleExpr(rangeGotoNode, *srcNode);
+  cgFunc->SetCurBBKind(BB::kBBRangeGoto);
+  iSel.SelectRangeGoto(rangeGotoNode, *srcOpnd);
+}
+
+void HandleIgoto(StmtNode &stmt, MPISel &iSel) {
+  CGFunc *cgFunc = iSel.GetCurFunc();
+  auto &igotoNode = static_cast<UnaryStmtNode&>(stmt);
+  BaseNode *targetNode = igotoNode.Opnd(0);
+  Operand *targetOpnd = iSel.HandleExpr(igotoNode, *targetNode);
+  iSel.SelectIgoto(*targetOpnd);
+  cgFunc->SetCurBBKind(BB::kBBIgoto);
+  cgFunc->SetCurBB(*cgFunc->StartNewBB(igotoNode));
+}
+
+void HandleReturn(StmtNode &stmt, MPISel &iSel) {
+  CGFunc *cgFunc = iSel.GetCurFunc();
+  auto &retNode = static_cast<NaryStmtNode&>(stmt);
+  ASSERT(retNode.NumOpnds() <= 1, "NYI return nodes number > 1");
+  if (retNode.NumOpnds() != 0) {
+    Operand *opnd = iSel.HandleExpr(retNode, *retNode.Opnd(0));
+    iSel.SelectReturn(retNode, *opnd);
+  }
+  iSel.SelectReturn();
+  /* return stmt will jump to the ret BB, so curBB is gotoBB */
+  cgFunc->SetCurBBKind(BB::kBBGoto);
+  cgFunc->SetCurBB(*cgFunc->StartNewBB(retNode));
+}
+
+void HandleComment(StmtNode &stmt [[maybe_unused]], MPISel &iSel [[maybe_unused]]) {
+  return;
+}
+
+void HandleIcall(StmtNode &stmt, MPISel &iSel) {
+  ASSERT(stmt.GetOpCode() == OP_icall || stmt.GetOpCode() == OP_icallproto, "error");
+  auto &iCallNode = static_cast<IcallNode&>(stmt);
+  Operand *opnd0 = iSel.HandleExpr(iCallNode, *iCallNode.Opnd(0));
+  iSel.SelectIcall(iCallNode, *opnd0);
+  iSel.SelectCallCommon(stmt, iSel);
+}
+
+void HandleCall(StmtNode &stmt, MPISel &iSel) {
+  ASSERT(stmt.GetOpCode() == OP_call, "error");
+  auto &callNode = static_cast<CallNode&>(stmt);
+  iSel.SelectCall(callNode);
+  iSel.SelectCallCommon(stmt, iSel);
+}
+
+void HandleCondbr(StmtNode &stmt, MPISel &iSel) {
+  CGFunc *cgFunc = iSel.GetCurFunc();
+  auto &condGotoNode = static_cast<CondGotoNode&>(stmt);
+  BaseNode *condNode = condGotoNode.Opnd(0);
+  ASSERT(condNode != nullptr, "expect first operand of cond br");
+  /* select cmpOp Insn and get the result "opnd0". However, the opnd0 is not used
+   * in most backend architectures */
+  Operand *opnd0 = iSel.HandleExpr(stmt, *condNode);
+  iSel.SelectCondGoto(condGotoNode, *condNode, *opnd0);
+  cgFunc->SetCurBB(*cgFunc->StartNewBB(condGotoNode));
+}
+
+Operand *HandleAddrof(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  auto &addrofNode = static_cast<AddrofNode&>(expr);
+  return iSel.SelectAddrof(addrofNode, parent);
+}
+
+Operand *HandleAddroffunc(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  auto &addrofNode = static_cast<AddroffuncNode&>(expr);
+  return iSel.SelectAddrofFunc(addrofNode, parent);
+}
+
+Operand *HandleAddrofLabel(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  auto &addrofLabelNode = static_cast<AddroflabelNode&>(expr);
+  return iSel.SelectAddrofLabel(addrofLabelNode, parent);
+}
+
+Operand *HandleShift(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectShift(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                          *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleCvt(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectCvt(parent, static_cast<TypeCvtNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleExtractBits(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectExtractbits(parent, static_cast<ExtractbitsNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleDread(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  auto &dreadNode = static_cast<AddrofNode&>(expr);
+  return iSel.SelectDread(parent, dreadNode);
+}
+
+Operand *HandleAdd(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectAdd(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                        *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleBior(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectBior(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                         *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleBxor(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectBxor(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                         *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleSub(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectSub(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                        *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleNeg(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectNeg(static_cast<UnaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+Operand *HandleDiv(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectDiv(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                        *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleRem(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectRem(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                        *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleBand(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectBand(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                         *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleMpy(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectMpy(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                        *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleConstStr(const BaseNode &parent [[maybe_unused]], BaseNode &expr, MPISel &iSel) {
+  auto &constStrNode = static_cast<ConststrNode&>(expr);
+  return iSel.SelectStrLiteral(constStrNode);
+}
+
+Operand *HandleTrunc(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectCvt(parent, static_cast<TypeCvtNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleConstVal(const BaseNode &parent [[maybe_unused]], BaseNode &expr, const MPISel &iSel) {
+  auto &constValNode = static_cast<ConstvalNode&>(expr);
+  MIRConst *mirConst = constValNode.GetConstVal();
+  ASSERT(mirConst != nullptr, "get constval of constvalnode failed");
+  if (mirConst->GetKind() == kConstInt) {
+    auto *mirIntConst = safe_cast<MIRIntConst>(mirConst);
+    return iSel.SelectIntConst(*mirIntConst, constValNode.GetPrimType());
+  } else if (mirConst->GetKind() == kConstDoubleConst) {
+    auto *mirDoubleConst = safe_cast<MIRDoubleConst>(mirConst);
+    return iSel.SelectDoubleConst(*mirDoubleConst, constValNode.GetPrimType());
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  return nullptr;
+}
+
+Operand *HandleRegread(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  (void)parent;
+  auto &regReadNode = static_cast<RegreadNode&>(expr);
+  /* handle return Val */
+  if (regReadNode.GetRegIdx() == -kSregRetval0 || regReadNode.GetRegIdx() == -kSregRetval1) {
+    return &iSel.ProcessReturnReg(regReadNode.GetPrimType(), -(regReadNode.GetRegIdx()));
+  }
+  return iSel.SelectRegread(regReadNode);
+}
+
+Operand *HandleIread(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  auto &ireadNode = static_cast<IreadNode&>(expr);
+  return iSel.SelectIread(parent, ireadNode);
+}
+Operand *HandleIreadoff(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  auto &ireadNode = static_cast<IreadoffNode&>(expr);
+  return iSel.SelectIreadoff(parent, ireadNode);
+}
+
+Operand *HandleBnot(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectBnot(static_cast<UnaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)), parent);
+}
+
+void HandleEval(const StmtNode &stmt, MPISel &iSel) {
+  (void)iSel.HandleExpr(stmt, *static_cast<const UnaryStmtNode&>(stmt).Opnd(0));
+}
+
+Operand *HandleDepositBits(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectDepositBits(static_cast<DepositbitsNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                                *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleCmp(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  // fix opnd type before select insn
+  PrimType targetPtyp = parent.GetPrimType();
+  if (kOpcodeInfo.IsCompare(parent.GetOpCode())) {
+    targetPtyp = static_cast<const CompareNode&>(parent).GetOpndType();
+  } else if (kOpcodeInfo.IsTypeCvt(parent.GetOpCode())) {
+    targetPtyp = static_cast<const TypeCvtNode&>(parent).FromType();
+  }
+  if (IsPrimitiveInteger(targetPtyp) && targetPtyp != expr.GetPrimType()) {
+    expr.SetPrimType(targetPtyp);
+  }
+  return iSel.SelectCmpOp(static_cast<CompareNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                          *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleAbs(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectAbs(static_cast<UnaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleAlloca(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectAlloca(static_cast<UnaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleCGArrayElemAdd(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectCGArrayElemAdd(static_cast<BinaryNode&>(expr), parent);
+}
+
+void HandleAsm(StmtNode &stmt, MPISel &iSel) {
+  iSel.SelectAsm(static_cast<AsmNode&>(stmt));
+}
+
+Operand *HandleSelect(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  /* 0,1,2 represent the first opnd and the second opnd and the third opnd of expr */
+  Operand &trueOpnd = *iSel.HandleExpr(expr, *expr.Opnd(1));
+  Operand &falseOpnd = *iSel.HandleExpr(expr, *expr.Opnd(2));
+  Operand &condOpnd = *iSel.HandleExpr(expr, *expr.Opnd(0));
+  if (condOpnd.IsImmediate()) {
+    return (static_cast<ImmOperand&>(condOpnd).GetValue() == 0) ? &falseOpnd : &trueOpnd;
+  }
+  return iSel.SelectSelect(static_cast<TernaryNode&>(expr), condOpnd, trueOpnd, falseOpnd, parent);
+}
+
+Operand *HandleMin(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectMin(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                        *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+
+Operand *HandleMax(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectMax(static_cast<BinaryNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)),
+                        *iSel.HandleExpr(expr, *expr.Opnd(1)), parent);
+}
+Operand *HandleRetype(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  return iSel.SelectRetype(static_cast<TypeCvtNode&>(expr), *iSel.HandleExpr(expr, *expr.Opnd(0)));
+}
+
+Operand *HandleIntrinOp(const BaseNode &parent, BaseNode &expr, MPISel &iSel) {
+  auto &intrinsicopNode = static_cast<IntrinsicopNode&>(expr);
+  switch (intrinsicopNode.GetIntrinsic()) {
+    case INTRN_C_rev16_2:
+    case INTRN_C_rev_4:
+    case INTRN_C_rev_8:
+      return iSel.SelectBswap(intrinsicopNode, *iSel.HandleExpr(expr, *expr.Opnd(0)), parent);
+
+    default:
+      ASSERT(false, "NIY, unsupported intrinsicop.");
+      return nullptr;
+  }
+}
+
+using HandleStmtFactory = FunctionFactory<Opcode, void, StmtNode&, MPISel&>;
+using HandleExprFactory = FunctionFactory<Opcode, maplebe::Operand*, const BaseNode&, BaseNode&, MPISel&>;
+namespace isel {
+void InitHandleStmtFactory() {
+  RegisterFactoryFunction<HandleStmtFactory>(OP_label, HandleLabel);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_dassign, HandleDassign);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_dassignoff, HandleDassignoff);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_iassign, HandleIassign);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_iassignoff, HandleIassignoff);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_regassign, HandleRegassign);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_return, HandleReturn);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_comment, HandleComment);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_call, HandleCall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_icall, HandleIcall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_icallproto, HandleIcall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_goto, HandleGoto);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_intrinsiccall, HandleIntrinCall);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_rangegoto, HandleRangeGoto);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_igoto, HandleIgoto);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_brfalse, HandleCondbr);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_brtrue, HandleCondbr);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_eval, HandleEval);
+  RegisterFactoryFunction<HandleStmtFactory>(OP_asm, HandleAsm);
+}
+void InitHandleExprFactory() {
+  RegisterFactoryFunction<HandleExprFactory>(OP_dread, HandleDread);
+  RegisterFactoryFunction<HandleExprFactory>(OP_add, HandleAdd);
+  RegisterFactoryFunction<HandleExprFactory>(OP_sub, HandleSub);
+  RegisterFactoryFunction<HandleExprFactory>(OP_neg, HandleNeg);
+  RegisterFactoryFunction<HandleExprFactory>(OP_mul, HandleMpy);
+  RegisterFactoryFunction<HandleExprFactory>(OP_constval, HandleConstVal);
+  RegisterFactoryFunction<HandleExprFactory>(OP_regread, HandleRegread);
+  RegisterFactoryFunction<HandleExprFactory>(OP_addrof, HandleAddrof);
+  RegisterFactoryFunction<HandleExprFactory>(OP_addroffunc, HandleAddroffunc);
+  RegisterFactoryFunction<HandleExprFactory>(OP_addroflabel, HandleAddrofLabel);
+  RegisterFactoryFunction<HandleExprFactory>(OP_shl, HandleShift);
+  RegisterFactoryFunction<HandleExprFactory>(OP_lshr, HandleShift);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ashr, HandleShift);
+  RegisterFactoryFunction<HandleExprFactory>(OP_cvt, HandleCvt);
+  RegisterFactoryFunction<HandleExprFactory>(OP_zext, HandleExtractBits);
+  RegisterFactoryFunction<HandleExprFactory>(OP_sext, HandleExtractBits);
+  RegisterFactoryFunction<HandleExprFactory>(OP_extractbits, HandleExtractBits);
+  RegisterFactoryFunction<HandleExprFactory>(OP_depositbits, HandleDepositBits);
+  RegisterFactoryFunction<HandleExprFactory>(OP_band, HandleBand);
+  RegisterFactoryFunction<HandleExprFactory>(OP_bior, HandleBior);
+  RegisterFactoryFunction<HandleExprFactory>(OP_bxor, HandleBxor);
+  RegisterFactoryFunction<HandleExprFactory>(OP_iread, HandleIread);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ireadoff, HandleIreadoff);
+  RegisterFactoryFunction<HandleExprFactory>(OP_bnot, HandleBnot);
+  RegisterFactoryFunction<HandleExprFactory>(OP_div, HandleDiv);
+  RegisterFactoryFunction<HandleExprFactory>(OP_rem, HandleRem);
+  RegisterFactoryFunction<HandleExprFactory>(OP_conststr, HandleConstStr);
+  RegisterFactoryFunction<HandleExprFactory>(OP_le, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ge, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_gt, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_lt, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_ne, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_eq, HandleCmp);
+  RegisterFactoryFunction<HandleExprFactory>(OP_abs, HandleAbs);
+  RegisterFactoryFunction<HandleExprFactory>(OP_alloca, HandleAlloca);
+  RegisterFactoryFunction<HandleExprFactory>(OP_CG_array_elem_add, HandleCGArrayElemAdd);
+  RegisterFactoryFunction<HandleExprFactory>(OP_select, HandleSelect);
+  RegisterFactoryFunction<HandleExprFactory>(OP_min, HandleMin);
+  RegisterFactoryFunction<HandleExprFactory>(OP_max, HandleMax);
+  RegisterFactoryFunction<HandleExprFactory>(OP_retype, HandleRetype);
+  RegisterFactoryFunction<HandleExprFactory>(OP_trunc, HandleTrunc);
+  RegisterFactoryFunction<HandleExprFactory>(OP_intrinsicop, HandleIntrinOp);
+}
+}
+
+Operand *MPISel::HandleExpr(const BaseNode &parent, BaseNode &expr) {
+  auto function = CreateProductFunction<HandleExprFactory>(expr.GetOpCode());
+  CHECK_FATAL(function != nullptr, "unsupported opCode in HandleExpr()");
+  return function(parent, expr, *this);
+}
+
+void MPISel::DoMPIS() {
+  isel::InitHandleStmtFactory();
+  isel::InitHandleExprFactory();
+  StmtNode *secondStmt = HandleFuncEntry();
+  for (StmtNode *stmt = secondStmt; stmt != nullptr; stmt = stmt->GetNext()) {
+    auto function = CreateProductFunction<HandleStmtFactory>(stmt->GetOpCode());
+    CHECK_FATAL(function != nullptr, "unsupported opCode or has been lowered before");
+    function(*stmt, *this);
+  }
+  HandleFuncExit();
+}
+
+PrimType MPISel::GetIntegerPrimTypeFromSize(bool isSigned, uint32 bitSize) const {
+  static constexpr std::array<PrimType, kBitIndexEnd> signedPrimType = {PTY_i8, PTY_i16, PTY_i32, PTY_i64};
+  static constexpr std::array<PrimType, kBitIndexEnd> unsignedPrimType = {PTY_u8, PTY_u16, PTY_u32, PTY_u64};
+  BitIndex index = GetBitIndex(bitSize);
+  return isSigned ? signedPrimType[index] : unsignedPrimType[index];
+}
+
+void MPISel::SelectCallCommon(StmtNode &stmt, const MPISel &iSel) {
+  CGFunc *cgFunc = iSel.GetCurFunc();
+  if (cgFunc->GetCurBB()->GetKind() != BB::kBBFallthru) {
+    cgFunc->SetCurBB(*cgFunc->StartNewBB(stmt));
+  }
+  StmtNode *prevStmt = stmt.GetPrev();
+  if (prevStmt == nullptr || prevStmt->GetOpCode() != OP_catch) {
+    return;
+  }
+  if ((stmt.GetNext() != nullptr) && (stmt.GetNext()->GetOpCode() == OP_label)) {
+    cgFunc->SetCurBB(*cgFunc->StartNewBBImpl(true, stmt));
+  }
+}
+
+void MPISel::SelectBasicOp(Operand &resOpnd, Operand &opnd0, Operand &opnd1, MOperator mOp, PrimType primType) {
+  RegOperand &firstOpnd = SelectCopy2Reg(opnd0, primType);
+  RegOperand &secondOpnd = SelectCopy2Reg(opnd1, primType);
+  Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, InsnDesc::GetAbstractId(mOp));
+  (void)insn.AddOpndChain(resOpnd).AddOpndChain(firstOpnd).AddOpndChain(secondOpnd);
+  cgFunc->GetCurBB()->AppendInsn(insn);
+}
+
+std::pair<FieldID, MIRType*> MPISel::GetFieldIdAndMirTypeFromMirNode(const BaseNode &node) {
+  FieldID fieldId = 0;
+  MIRType *mirType = nullptr;
+  if (node.GetOpCode() == maple::OP_iread) {
+    /* mirType stored in an addr. */
+    auto &iread = static_cast<const IreadNode&>(node);
+    fieldId = iread.GetFieldID();
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread.GetTyIdx());
+    MIRPtrType *pointerType = static_cast<MIRPtrType*>(type);
+    ASSERT(pointerType != nullptr, "expect a pointer type at iread node");
+    mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerType->GetPointedTyIdx());
+    if (mirType->GetKind() == kTypeArray) {
+      MIRArrayType *arrayType = static_cast<MIRArrayType*>(mirType);
+      mirType =  GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrayType->GetElemTyIdx());
+    }
+  } else if (node.GetOpCode() == maple::OP_dassign) {
+    /* mirSymbol */
+    auto &dassign = static_cast<const DassignNode&>(node);
+    fieldId = dassign.GetFieldID();
+    MIRSymbol *symbol = cgFunc->GetFunction().GetLocalOrGlobalSymbol(dassign.GetStIdx());
+    mirType = symbol->GetType();
+  } else if (node.GetOpCode() == maple::OP_dread) {
+    /* mirSymbol */
+    auto &dread = static_cast<const AddrofNode&>(node);
+    fieldId = dread.GetFieldID();
+    MIRSymbol *symbol = cgFunc->GetFunction().GetLocalOrGlobalSymbol(dread.GetStIdx());
+    mirType = symbol->GetType();
+  } else if (node.GetOpCode() == maple::OP_iassign) {
+    auto &iassign = static_cast<const IassignNode&>(node);
+    fieldId = iassign.GetFieldID();
+    AddrofNode &addrofNode = static_cast<AddrofNode&>(iassign.GetAddrExprBase());
+    MIRType *iassignMirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iassign.GetTyIdx());
+    MIRPtrType *pointerType = nullptr;
+    if (iassignMirType->GetPrimType() == PTY_agg) {
+      MIRSymbol *addrSym = cgFunc->GetMirModule().CurFunction()->GetLocalOrGlobalSymbol(addrofNode.GetStIdx());
+      MIRType *addrMirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(addrSym->GetTyIdx());
+      addrMirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(addrMirType->GetTypeIndex());
+      ASSERT(addrMirType->GetKind() == kTypePointer, "non-pointer");
+      pointerType = static_cast<MIRPtrType*>(addrMirType);
+    } else {
+      ASSERT(iassignMirType->GetKind() == kTypePointer, "non-pointer");
+      pointerType = static_cast<MIRPtrType*>(iassignMirType);
+    }
+    mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerType->GetPointedTyIdx());
+  } else {
+    CHECK_FATAL(false, "unsupported OpCode");
+  }
+  return {fieldId, mirType};
+}
+
+MirTypeInfo MPISel::GetMirTypeInfoFormFieldIdAndMirType(FieldID fieldId, MIRType *mirType) {
+  MirTypeInfo mirTypeInfo;
+  /* fixup primType and offset */
+  if (fieldId != 0) {
+    ASSERT((mirType->IsMIRStructType() || mirType->IsMIRUnionType()), "non-structure");
+    MIRStructType *structType = static_cast<MIRStructType*>(mirType);
+    mirType = structType->GetFieldType(fieldId);
+    mirTypeInfo.offset = static_cast<uint32>(cgFunc->GetBecommon().GetFieldOffset(*structType, fieldId).first);
+  }
+  mirTypeInfo.primType = mirType->GetPrimType();
+  // aggSize for AggType
+  if (mirTypeInfo.primType == maple::PTY_agg) {
+    mirTypeInfo.size = cgFunc->GetBecommon().GetTypeSize(mirType->GetTypeIndex());
+  }
+  return mirTypeInfo;
+}
+
+MirTypeInfo MPISel::GetMirTypeInfoFromMirNode(const BaseNode &node) {
+  auto [fieldId, mirType] = GetFieldIdAndMirTypeFromMirNode(node);
+  return GetMirTypeInfoFormFieldIdAndMirType(fieldId, mirType);
+}
+
+void MPISel::SelectDassign(const DassignNode &stmt, Operand &opndRhs) {
+  /* mirSymbol info */
+  MIRSymbol *symbol = cgFunc->GetFunction().GetLocalOrGlobalSymbol(stmt.GetStIdx());
+  MirTypeInfo symbolInfo = GetMirTypeInfoFromMirNode(stmt);
+  CHECK_NULL_FATAL(symbol);
+  /* Get symbol location */
+  MemOperand &symbolMem = GetOrCreateMemOpndFromSymbol(*symbol, stmt.GetFieldID());
+  /* rhs mirType info */
+  PrimType rhsType = stmt.GetRHS()->GetPrimType();
+  /* Generate Insn */
+  if (rhsType == PTY_agg) {
+    /* Agg Type */
+    SelectAggDassign(symbolInfo, symbolMem, opndRhs);
+    return;
+  }
+  PrimType memType = symbolInfo.primType;
+  if (memType == PTY_agg) {
+    memType = PTY_a64;
+  }
+  SelectCopy(symbolMem, opndRhs, memType, rhsType);
+  return;
+}
+
+void MPISel::SelectDassignoff(DassignoffNode &stmt, Operand &opnd0) {
+  MIRSymbol *symbol = cgFunc->GetFunction().GetLocalOrGlobalSymbol(stmt.stIdx);
+  PrimType primType = stmt.GetPrimType();
+  uint32 bitSize = GetPrimTypeBitSize(primType);
+  MemOperand &memOpnd = GetOrCreateMemOpndFromSymbol(*symbol, bitSize, stmt.offset);
+
+  SelectCopy(memOpnd, opnd0, primType);
+}
+
+void MPISel::SelectIassign(const IassignNode &stmt, Operand &opndAddr, Operand &opndRhs) {
+  /* mirSymbol info */
+  MirTypeInfo symbolInfo = GetMirTypeInfoFromMirNode(stmt);
+  /* handle Lhs, generate (%Rxx) via Rxx */
+  PrimType memType = symbolInfo.primType;
+  if (memType == PTY_agg) {
+    memType = PTY_a64;
+  }
+  RegOperand &lhsBaseOpnd = SelectCopy2Reg(opndAddr, stmt.Opnd(0)->GetPrimType());
+  MemOperand &lhsMemOpnd = cgFunc->GetOpndBuilder()->CreateMem(lhsBaseOpnd, symbolInfo.offset,
+      GetPrimTypeBitSize(memType));
+  /* handle Rhs, get R## from Rhs */
+  PrimType rhsType = stmt.GetRHS()->GetPrimType();
+  /* mov %R##, (%Rxx) */
+  SelectCopy(lhsMemOpnd, opndRhs, memType, rhsType);
+}
+
+void MPISel::SelectIassignoff(const IassignoffNode &stmt) {
+  Operand *addr = HandleExpr(stmt, *stmt.Opnd(0));
+  ASSERT(addr != nullptr, "null ptr check");
+  Operand *rhs = HandleExpr(stmt, *stmt.Opnd(1));
+  ASSERT(rhs != nullptr, "null ptr check");
+
+  int32 offset = stmt.GetOffset();
+  PrimType primType = stmt.GetPrimType();
+  uint32 bitSize = GetPrimTypeBitSize(primType);
+  RegOperand &addrReg = SelectCopy2Reg(*addr, PTY_a64);
+  RegOperand &rhsReg = SelectCopy2Reg(*rhs, primType);
+
+  MemOperand &memOpnd = cgFunc->GetOpndBuilder()->CreateMem(addrReg, offset, bitSize);
+  SelectCopy(memOpnd, rhsReg, primType);
+}
+
+ImmOperand *MPISel::SelectIntConst(MIRIntConst &intConst, PrimType primType) const {
+  return &cgFunc->GetOpndBuilder()->CreateImm(GetPrimTypeBitSize(primType), intConst.GetExtValue());
+}
+
+Operand *MPISel::SelectShift(const BinaryNode &node, Operand &opnd0,
+                             Operand &opnd1, const BaseNode &parent [[maybe_unused]]) {
+  PrimType primType = node.GetPrimType();
+  RegOperand *resOpnd = nullptr;
+  Opcode opcode = node.GetOpCode();
+
+  if (IsPrimitiveInteger(primType)) {
+    resOpnd = &(cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+        cgFunc->GetRegTyFromPrimTy(primType)));
+    RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primType, node.Opnd(0)->GetPrimType());
+    SelectShift(*resOpnd, regOpnd0, opnd1, opcode, primType, node.Opnd(1)->GetPrimType());
+  } else {
+    CHECK_FATAL(false, "NIY vector cvt");
+  }
+  return resOpnd;
+}
+
+void MPISel::SelectShift(Operand &resOpnd, Operand &opnd0, Operand &opnd1, Opcode shiftDirect,
+    PrimType opnd0Type, PrimType opnd1Type) {
+  if (opnd1.IsIntImmediate() && static_cast<ImmOperand&>(opnd1).GetValue() == 0) {
+    SelectCopy(resOpnd, opnd0, opnd0Type);
+    return;
+  }
+
+  uint32 dsize = GetPrimTypeBitSize(opnd0Type);
+  MOperator mOp = abstract::MOP_undef;
+  if (shiftDirect == OP_shl) {
+    const static auto fastShlMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(shl);
+    mOp = fastShlMappingFunc(dsize);
+  } else if (shiftDirect == OP_ashr) {
+    const static auto fastAshrMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(ashr);
+    mOp = fastAshrMappingFunc(dsize);
+  } else if (shiftDirect == OP_lshr) {
+    const static auto fastLshrMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(lshr);
+    mOp = fastLshrMappingFunc(dsize);
+  } else {
+    CHECK_FATAL(false, "NIY, Not support shiftdirect case");
+  }
+  RegOperand &firstOpnd = SelectCopy2Reg(opnd0, opnd0Type);
+  RegOperand &secondOpnd = SelectCopy2Reg(opnd1, opnd1Type);
+  Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, InsnDesc::GetAbstractId(mOp));
+  insn.AddOpndChain(resOpnd).AddOpndChain(firstOpnd).AddOpndChain(secondOpnd);
+  cgFunc->GetCurBB()->AppendInsn(insn);
+}
+
+void MPISel::SelectRegassign(RegassignNode &stmt, Operand &opnd0) {
+  PrimType rhsType = stmt.Opnd(0)->GetPrimType();
+  PregIdx pregIdx = stmt.GetRegIdx();
+  PrimType regType = stmt.GetPrimType();
+  RegOperand &regOpnd = cgFunc->GetOpndBuilder()->CreateVReg(cgFunc->GetVirtualRegNOFromPseudoRegIdx(pregIdx),
+      GetPrimTypeBitSize(regType), cgFunc->GetRegTyFromPrimTy(regType));
+  SelectCopy(regOpnd, opnd0, regType, rhsType);
+  if ((Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) && (pregIdx >= 0)) {
+    const SymbolAlloc *symLoc = cgFunc->GetMemlayout()->GetSpillLocOfPseduoRegister(pregIdx);
+    int64 offset = static_cast<int64>(cgFunc->GetBaseOffset(*symLoc));
+    MIRPreg *preg = cgFunc->GetFunction().GetPregTab()->PregFromPregIdx(pregIdx);
+    uint32 bitLen = GetPrimTypeSize(preg->GetPrimType()) * kBitsPerByte;
+    RegOperand &base = GetTargetBasicPointer(PTY_u64);
+    MemOperand *dest = &cgFunc->GetOpndBuilder()->CreateMem(base, offset, bitLen);
+    SelectCopy(*dest, regOpnd, preg->GetPrimType(), regType);
+  }
+}
+
+RegOperand *MPISel::SelectRegread(RegreadNode &expr) {
+  PregIdx pregIdx = expr.GetRegIdx();
+  PrimType rhsType = expr.GetPrimType();
+  RegOperand &reg = cgFunc->GetOpndBuilder()->CreateVReg(cgFunc->GetVirtualRegNOFromPseudoRegIdx(pregIdx),
+      GetPrimTypeSize(rhsType) * kBitsPerByte, cgFunc->GetRegTyFromPrimTy(rhsType));
+  if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+    const SymbolAlloc *symLoc = cgFunc->GetMemlayout()->GetSpillLocOfPseduoRegister(pregIdx);
+    int64 offset = static_cast<int64>(cgFunc->GetBaseOffset(*symLoc));
+    MIRPreg *preg = cgFunc->GetFunction().GetPregTab()->PregFromPregIdx(pregIdx);
+    uint32 bitLen = GetPrimTypeSize(preg->GetPrimType()) * kBitsPerByte;
+    RegOperand &base = GetTargetBasicPointer(PTY_u64);
+    MemOperand *src = &cgFunc->GetOpndBuilder()->CreateMem(base, offset, bitLen);
+    SelectCopy(reg, *src, rhsType, preg->GetPrimType());
+  }
+  return &reg;
+}
+
+Operand *MPISel::SelectDread(const BaseNode &parent [[maybe_unused]], const AddrofNode &expr) {
+  /* get mirSymbol info*/
+  MIRSymbol *symbol = cgFunc->GetFunction().GetLocalOrGlobalSymbol(expr.GetStIdx());
+  MirTypeInfo symbolInfo = GetMirTypeInfoFromMirNode(expr);
+  PrimType symbolType = symbolInfo.primType;
+  /* Get symbol location */
+  MemOperand &symbolMem = GetOrCreateMemOpndFromSymbol(*symbol, expr.GetFieldID());
+  PrimType primType = expr.GetPrimType();
+  /* for AggType, return it's location in stack. */
+  if (symbolType == maple::PTY_agg) {
+    CHECK_FATAL(primType == maple::PTY_agg, "NIY");
+    return &symbolMem;
+  }
+  /* for BasicType, load symbolVal to register. */
+  RegOperand &regOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  /* Generate Insn */
+  SelectCopy(regOpnd, symbolMem, primType, symbolType);
+  return &regOpnd;
+}
+
+Operand *MPISel::SelectAdd(const BinaryNode &node, Operand &opnd0,
+                           Operand &opnd1, const BaseNode &parent [[maybe_unused]]) {
+  PrimType primType = node.GetPrimType();
+  RegOperand &resReg = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primType, node.Opnd(0)->GetPrimType());
+  RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, primType, node.Opnd(1)->GetPrimType());
+  SelectAdd(resReg, regOpnd0, regOpnd1, primType);
+  return &resReg;
+}
+
+Operand *MPISel::SelectBand(const BinaryNode &node, Operand &opnd0,
+                            Operand &opnd1, const BaseNode &parent [[maybe_unused]]) {
+  PrimType primType = node.GetPrimType();
+  RegOperand &resReg = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primType, node.Opnd(0)->GetPrimType());
+  RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, primType, node.Opnd(1)->GetPrimType());
+  SelectBand(resReg, regOpnd0, regOpnd1, primType);
+  return &resReg;
+}
+
+Operand *MPISel::SelectSub(const BinaryNode &node, Operand &opnd0, Operand &opnd1,
+                           const BaseNode &parent [[maybe_unused]]) {
+  PrimType primType = node.GetPrimType();
+  RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primType, node.Opnd(0)->GetPrimType());
+  RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, primType, node.Opnd(1)->GetPrimType());
+  SelectSub(resOpnd, regOpnd0, regOpnd1, primType);
+  return &resOpnd;
+}
+
+void MPISel::SelectExtractbits(RegOperand &resOpnd, RegOperand &opnd0, uint8 bitOffset,
+                               uint8 bitSize, PrimType primType) {
+  uint32 primBitSize = GetPrimTypeBitSize(primType);
+  bool isSigned = IsSignedInteger(primType);
+  if (bitOffset == 0 && !isSigned) {
+    /*
+     * resOpnd = opnd0 & ((1 << bitSize) - 1)
+     */
+    ImmOperand &imm = cgFunc->GetOpndBuilder()->CreateImm(primBitSize,
+        (static_cast<int64>(1) << bitSize) - 1);
+    SelectBand(resOpnd, opnd0, imm, primType);
+  } else {
+    /*
+     * tmpOpnd = opnd0 << (primBitSize - bitSize - bitOffset)
+     * resOpnd = tmpOpnd >> (primBitSize - bitSize)
+     * if signed : use sar; else use shr
+     */
+    RegOperand &tmpOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+        cgFunc->GetRegTyFromPrimTy(primType));
+    ImmOperand &imm1Opnd = cgFunc->GetOpndBuilder()->CreateImm(primBitSize,
+        primBitSize - bitSize - bitOffset);
+    SelectShift(tmpOpnd, opnd0, imm1Opnd, OP_shl, primType, primType);
+    Opcode opcode = isSigned ? OP_ashr : OP_lshr;
+    ImmOperand &imm2Opnd = cgFunc->GetOpndBuilder()->CreateImm(primBitSize, primBitSize - bitSize);
+    SelectShift(resOpnd, tmpOpnd, imm2Opnd, opcode, primType, primType);
+  }
+}
+
+Operand *MPISel::SelectExtractbits(const BaseNode &parent [[maybe_unused]],
+                                   const ExtractbitsNode &node, Operand &opnd0) {
+  PrimType fromType = node.Opnd(0)->GetPrimType();
+  PrimType toType = node.GetPrimType();
+  uint8 bitSize = node.GetBitsSize();
+  RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(toType),
+      cgFunc->GetRegTyFromPrimTy(toType));
+  if (IsPrimitiveInteger(toType)) {
+    // OP_extractbits or bitSize < 8-bit or bitSize is not pow of 2
+    if (node.GetOpCode() == OP_extractbits || bitSize < k8BitSize || (bitSize & (bitSize - 1)) != 0) {
+      SelectCopy(resOpnd, opnd0, toType, fromType);
+      SelectExtractbits(resOpnd, resOpnd, node.GetBitsOffset(), bitSize, toType);
+    } else {
+      PrimType opndType = GetIntegerPrimTypeFromSize(node.GetOpCode() == OP_sext, bitSize);
+      RegOperand &tmpRegOpnd = SelectCopy2Reg(opnd0, opndType, fromType);
+      SelectIntCvt(resOpnd, tmpRegOpnd, toType, opndType);
+    }
+  } else {
+    CHECK_FATAL(false, "NIY vector cvt");
+  }
+  return &resOpnd;
+}
+
+Operand *MPISel::SelectCvt(const BaseNode &parent [[maybe_unused]], const TypeCvtNode &node, Operand &opnd0) {
+  PrimType fromType = node.Opnd(0)->GetPrimType();
+  PrimType toType = node.GetPrimType();
+  if (fromType == toType) {
+    return &opnd0;
+  }
+  RegOperand *resOpnd = &cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(toType),
+      cgFunc->GetRegTyFromPrimTy(toType));
+  if (IsPrimitiveInteger(toType) && IsPrimitiveInteger(fromType)) {
+    SelectIntCvt(*resOpnd, opnd0, toType, fromType);
+  } else if (IsPrimitiveFloat(toType) && IsPrimitiveInteger(fromType)) {
+    SelectCvtInt2Float(*resOpnd, opnd0, toType, fromType);
+  } else if (IsPrimitiveFloat(toType) && IsPrimitiveFloat(fromType)) {
+    SelectFloatCvt(*resOpnd, opnd0, toType, fromType);
+  } else if (IsPrimitiveInteger(toType) && IsPrimitiveFloat(fromType)) {
+    SelectCvtFloat2Int(*resOpnd, opnd0, toType, fromType);
+  } else {
+    CHECK_FATAL(false, "NIY cvt");
+  }
+  return resOpnd;
+}
+
+
+void MPISel::SelectCvtFloat2Int(RegOperand &resOpnd, Operand &opnd0, PrimType toType, PrimType fromType) {
+  uint32 toSize = GetPrimTypeBitSize(toType);
+  bool isSigned = !IsPrimitiveUnsigned(toType);
+  RegOperand &tmpFloatOpnd = cgFunc->GetOpndBuilder()->CreateVReg(toSize, kRegTyFloat);
+  SelectFloatCvt(tmpFloatOpnd, opnd0, toType, fromType);
+  MOperator mOp = abstract::MOP_undef;
+  if (toSize == k32BitSize) {
+    mOp = isSigned ? abstract::MOP_cvt_rf_i32 : abstract::MOP_cvt_rf_u32;
+  } else if (toSize == k64BitSize) {
+    mOp = isSigned ? abstract::MOP_cvt_rf_i64 : abstract::MOP_cvt_rf_u64;
+  } else {
+    CHECK_FATAL(false, "niy");
+  }
+  Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, InsnDesc::GetAbstractId(mOp));
+  (void)insn.AddOpndChain(resOpnd).AddOpndChain(tmpFloatOpnd);
+  cgFunc->GetCurBB()->AppendInsn(insn);
+}
+
+void MPISel::SelectCvtInt2Float(RegOperand &resOpnd, Operand &opnd0, PrimType toType, PrimType fromType) {
+  uint32 fromSize = GetPrimTypeBitSize(fromType);
+  bool isSigned = !IsPrimitiveUnsigned(fromType);
+  MOperator mOp = abstract::MOP_undef;
+  PrimType newFromType = PTY_begin;
+  if (fromSize == k32BitSize) {
+    mOp = isSigned ? abstract::MOP_cvt_fr_i32 : abstract::MOP_cvt_fr_u32;
+    newFromType = PTY_f32;
+  } else if (fromSize == k64BitSize) {
+    mOp = isSigned ? abstract::MOP_cvt_fr_i64 : abstract::MOP_cvt_fr_u64;
+    newFromType = PTY_f64;
+  } else {
+    CHECK_FATAL(false, "niy");
+  }
+  RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, fromType);
+  RegOperand &tmpFloatOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(newFromType),
+      cgFunc->GetRegTyFromPrimTy(newFromType));
+  Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, InsnDesc::GetAbstractId(mOp));
+  (void)insn.AddOpndChain(tmpFloatOpnd).AddOpndChain(regOpnd0);
+  cgFunc->GetCurBB()->AppendInsn(insn);
+  SelectFloatCvt(resOpnd, tmpFloatOpnd, toType, newFromType);
+}
+
+void MPISel::SelectIntCvt(RegOperand &resOpnd, Operand &opnd0, PrimType toType, PrimType fromType) {
+  uint32 fromSize = GetPrimTypeBitSize(fromType);
+  uint32 toSize = GetPrimTypeBitSize(toType);
+  /*
+   * It is redundancy to insert "nop" casts (unsigned 32 -> singed 32) in abstract CG IR
+   * The signedness of operands would be shown in the expression.
+   */
+  RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, fromType);
+  if (toSize <= fromSize) {
+    resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(regOpnd0.GetRegisterNumber(),
+        GetPrimTypeBitSize(toType), cgFunc->GetRegTyFromPrimTy(toType));
+    return;
+  }
+  bool isSigned = !IsPrimitiveUnsigned(fromType);
+  MOperator mOp = GetFastCvtMopI(fromSize, toSize, isSigned);
+  Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, InsnDesc::GetAbstractId(mOp));
+  (void)insn.AddOpndChain(resOpnd).AddOpndChain(regOpnd0);
+  cgFunc->GetCurBB()->AppendInsn(insn);
+  return;
+}
+
+void MPISel::SelectFloatCvt(RegOperand &resOpnd, Operand &opnd0, PrimType toType, PrimType fromType) {
+  uint32 fromSize = GetPrimTypeBitSize(fromType);
+  uint32 toSize = GetPrimTypeBitSize(toType);
+  RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, fromType);
+  if (fromSize == toSize) {
+    resOpnd = regOpnd0;
+    return;
+  }
+  MOperator mOp = abstract::MOP_undef;
+  if (fromSize == k32BitSize && toSize == k64BitSize) {
+    mOp = abstract::MOP_cvt_ff_64_32;
+  } else if (fromSize == k64BitSize && toSize == k32BitSize) {
+    mOp = abstract::MOP_cvt_ff_32_64;
+  } else {
+    CHECK_FATAL(false, "niy");
+  }
+  Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, InsnDesc::GetAbstractId(mOp));
+  (void)insn.AddOpndChain(resOpnd).AddOpndChain(regOpnd0);
+  cgFunc->GetCurBB()->AppendInsn(insn);
+  return;
+}
+
+void MPISel::SelectSub(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  MOperator mOp = abstract::MOP_undef;
+  if (IsPrimitiveInteger(primType)) {
+    const static auto fastSubMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(sub);
+    mOp = fastSubMappingFunc(GetPrimTypeBitSize(primType));
+  } else {
+    const static auto fastSubFloatMappingFunc = DEF_FLOAT_MOPERATOR_MAPPING_FUNC(sub);
+    mOp = fastSubFloatMappingFunc(GetPrimTypeBitSize(primType));
+  }
+  SelectBasicOp(resOpnd, opnd0, opnd1, mOp, primType);
+}
+
+void MPISel::SelectBand(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  const static auto fastBandMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(and);
+  MOperator mOp = fastBandMappingFunc(GetPrimTypeBitSize(primType));
+  SelectBasicOp(resOpnd, opnd0, opnd1, mOp, primType);
+}
+
+void MPISel::SelectAdd(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  MOperator mOp = abstract::MOP_undef;
+  if (IsPrimitiveInteger(primType)) {
+    const static auto fastAddMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(add);
+    mOp = fastAddMappingFunc(GetPrimTypeBitSize(primType));
+  } else {
+    const static auto fastAddFloatMappingFunc = DEF_FLOAT_MOPERATOR_MAPPING_FUNC(add);
+    mOp = fastAddFloatMappingFunc(GetPrimTypeBitSize(primType));
+  }
+  SelectBasicOp(resOpnd, opnd0, opnd1, mOp, primType);
+}
+
+Operand* MPISel::SelectNeg(const UnaryNode &node, Operand &opnd0, const BaseNode &parent [[maybe_unused]]) {
+  PrimType dtype = node.GetPrimType();
+
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(dtype)) {
+    resOpnd = &cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(dtype),
+        cgFunc->GetRegTyFromPrimTy(dtype));
+    RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, dtype, node.Opnd(0)->GetPrimType());
+    SelectNeg(*resOpnd, regOpnd0, dtype);
+  } else {
+    /* vector operand */
+    CHECK_FATAL(false, "NIY");
+  }
+  return resOpnd;
+}
+
+void MPISel::SelectNeg(Operand &resOpnd, Operand &opnd0, PrimType primType) const {
+  MOperator mOp = abstract::MOP_undef;
+  if (IsPrimitiveInteger(primType)) {
+    const static auto fastNegMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(neg);
+    mOp = fastNegMappingFunc(GetPrimTypeBitSize(primType));
+  } else {
+    const static auto fastNegFloatMappingFunc = DEF_FLOAT_MOPERATOR_MAPPING_FUNC(neg);
+    mOp = fastNegFloatMappingFunc(GetPrimTypeBitSize(primType));
+  }
+  Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, InsnDesc::GetAbstractId(mOp));
+  (void)insn.AddOpndChain(resOpnd).AddOpndChain(opnd0);
+  cgFunc->GetCurBB()->AppendInsn(insn);
+}
+
+Operand *MPISel::SelectBior(const BinaryNode &node, Operand &opnd0,
+                            Operand &opnd1, const BaseNode &parent [[maybe_unused]]) {
+  PrimType primType = node.GetPrimType();
+  RegOperand *resOpnd = &cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primType, node.Opnd(0)->GetPrimType());
+  RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, primType, node.Opnd(1)->GetPrimType());
+  SelectBior(*resOpnd, regOpnd0, regOpnd1, primType);
+  return resOpnd;
+}
+
+void MPISel::SelectBior(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  const static auto fastBiorMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(or);
+  MOperator mOp = fastBiorMappingFunc(GetPrimTypeBitSize(primType));
+  SelectBasicOp(resOpnd, opnd0, opnd1, mOp, primType);
+}
+
+Operand *MPISel::SelectBxor(const BinaryNode &node, Operand &opnd0,
+                            Operand &opnd1, const BaseNode &parent [[maybe_unused]]) {
+  PrimType primType = node.GetPrimType();
+  RegOperand *resOpnd = &cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primType, node.Opnd(0)->GetPrimType());
+  RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, primType, node.Opnd(1)->GetPrimType());
+  SelectBxor(*resOpnd, regOpnd0, regOpnd1, primType);
+  return resOpnd;
+}
+
+void MPISel::SelectBxor(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  const static auto fastBxorMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(xor);
+  MOperator mOp = fastBxorMappingFunc(GetPrimTypeBitSize(primType));
+  SelectBasicOp(resOpnd, opnd0, opnd1, mOp, primType);
+}
+
+MemOperand *MPISel::GetOrCreateMemOpndFromIreadNode(const IreadNode &expr, PrimType primType, int offset) {
+  /* get rhs*/
+  Operand *addrOpnd = HandleExpr(expr, *expr.Opnd(0));
+  RegOperand &addrOnReg = SelectCopy2Reg(*addrOpnd, PTY_a64);
+  /* Generate memOpnd */
+  MemOperand &memOpnd = cgFunc->GetOpndBuilder()->CreateMem(addrOnReg,
+      offset, GetPrimTypeBitSize(primType));
+  return &memOpnd;
+}
+
+Operand *MPISel::SelectIread(const BaseNode &parent [[maybe_unused]], const IreadNode &expr, int extraOffset) {
+  /* get lhs mirType info */
+  MirTypeInfo lhsInfo = GetMirTypeInfoFromMirNode(expr);
+  /* get memOpnd */
+  MemOperand &memOpnd = *GetOrCreateMemOpndFromIreadNode(expr, lhsInfo.primType, lhsInfo.offset + extraOffset);
+  /* for AggType, return addr it self. */
+  if (lhsInfo.primType == PTY_agg) {
+    return &memOpnd;
+  }
+  /* for BasicType, load val in addr to register. */
+  PrimType primType = expr.GetPrimType();
+  RegOperand &result = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  SelectCopy(result, memOpnd, primType, lhsInfo.primType);
+  return &result;
+}
+
+Operand *MPISel::SelectIreadoff(const BaseNode &parent [[maybe_unused]], const IreadoffNode &ireadoff) {
+  int32 offset = ireadoff.GetOffset();
+  PrimType primType = ireadoff.GetPrimType();
+  uint32 bitSize = GetPrimTypeBitSize(primType);
+
+  Operand *addrOpnd = HandleExpr(ireadoff, *ireadoff.Opnd(0));
+  RegOperand &addrOnReg = SelectCopy2Reg(*addrOpnd, PTY_a64);
+  MemOperand &memOpnd = cgFunc->GetOpndBuilder()->CreateMem(addrOnReg, offset, bitSize);
+  RegOperand &result = cgFunc->GetOpndBuilder()->CreateVReg(bitSize,
+      cgFunc->GetRegTyFromPrimTy(primType));
+  SelectCopy(result, memOpnd, primType);
+  return &result;
+}
+
+static inline uint64 CreateDepositBitsImm1(uint32 primBitSize, uint8 bitOffset, uint8 bitSize) {
+  /* $imm1 = 1(primBitSize - bitSize - bitOffset)0(bitSize)1(bitOffset) */
+  uint64 val = UINT64_MAX;      // 0xFFFFFFFFFFFFFFFF
+  if (bitSize + bitOffset >= primBitSize) {
+    val = 0;
+  } else {
+    val <<= (bitSize + bitOffset);
+  }
+  val |= (static_cast<uint64>(1) << bitOffset) - 1;
+  return val;
+}
+
+Operand *MPISel::SelectDepositBits(const DepositbitsNode &node, Operand &opnd0, Operand &opnd1,
+                                   const BaseNode &parent [[maybe_unused]]) {
+  uint8 bitOffset = node.GetBitsOffset();
+  uint8 bitSize = node.GetBitsSize();
+  PrimType primType = node.GetPrimType();
+  uint32 primBitSize = GetPrimTypeBitSize(primType);
+  ASSERT((primBitSize == k64BitSize) || (bitOffset < k32BitSize), "wrong bitSize");
+  ASSERT(bitSize < k64BitSize, "wrong bitSize");
+
+  RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(primBitSize,
+      cgFunc->GetRegTyFromPrimTy(primType));
+  /*
+   * resOpnd = (opnd0 and $imm1) or ((opnd1 << bitOffset) and (~$imm1));
+   * $imm1 = 1(primBitSize - bitSize - bitOffset)0(bitSize)1(bitOffset)
+   */
+  uint64 imm1Val = CreateDepositBitsImm1(primBitSize, bitOffset, bitSize);
+  ImmOperand &imm1Opnd = cgFunc->GetOpndBuilder()->CreateImm(primBitSize,
+      static_cast<int64>(imm1Val));
+  /* and */
+  SelectBand(resOpnd, opnd0, imm1Opnd, primType);
+  if (opnd1.IsIntImmediate()) {
+    /* opnd1 is immediate, imm2 = (opnd1.val << bitOffset) & (~$imm1) */
+    int64 imm2Val = (static_cast<ImmOperand&>(opnd1).GetValue() << bitOffset) & (~imm1Val);
+    ImmOperand &imm2Opnd = cgFunc->GetOpndBuilder()->CreateImm(primBitSize, imm2Val);
+    /* or */
+    SelectBior(resOpnd, resOpnd, imm2Opnd, primType);
+  } else {
+    RegOperand &tmpOpnd = cgFunc->GetOpndBuilder()->CreateVReg(primBitSize,
+        cgFunc->GetRegTyFromPrimTy(primType));
+    SelectCopy(tmpOpnd, opnd1, primType, node.Opnd(1)->GetPrimType());
+    /* shift -- (opnd1 << bitOffset) */
+    ImmOperand &countOpnd = cgFunc->GetOpndBuilder()->CreateImm(primBitSize, bitOffset);
+    SelectShift(tmpOpnd, tmpOpnd, countOpnd, OP_shl, primType, primType);
+    /* and (~$imm1) */
+    ImmOperand &nonImm1Opnd = cgFunc->GetOpndBuilder()->CreateImm(primBitSize, (~imm1Val));
+    SelectBand(tmpOpnd, tmpOpnd, nonImm1Opnd, primType);
+    /* or */
+    SelectBior(resOpnd, resOpnd, tmpOpnd, primType);
+  }
+  return &resOpnd;
+}
+
+Operand *MPISel::SelectAbs(UnaryNode &node, Operand &opnd0) {
+  PrimType primType = node.GetPrimType();
+  if (IsPrimitiveVector(primType)) {
+    CHECK_FATAL(false, "NIY");
+  } else if (IsPrimitiveFloat(primType)) {
+    CHECK_FATAL(false, "NIY");
+  } else if (IsUnsignedInteger(primType)) {
+    return &opnd0;
+  } else {
+    /*
+     * abs(x) = (x XOR y) - y
+     * y = x >>> (bitSize - 1)
+     */
+    uint32 bitSize = GetPrimTypeBitSize(primType);
+    CHECK_FATAL(bitSize == k64BitSize || bitSize == k32BitSize, "only support 32-bits or 64-bits");
+    RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primType);
+    ImmOperand &immOpnd = cgFunc->GetOpndBuilder()->CreateImm(bitSize, bitSize - 1);
+    RegOperand &regOpndy = cgFunc->GetOpndBuilder()->CreateVReg(bitSize,
+        cgFunc->GetRegTyFromPrimTy(primType));
+    SelectShift(regOpndy, regOpnd0, immOpnd, OP_ashr, primType, primType);
+    RegOperand &tmpOpnd = cgFunc->GetOpndBuilder()->CreateVReg(bitSize,
+        cgFunc->GetRegTyFromPrimTy(primType));
+    SelectBxor(tmpOpnd, regOpnd0, regOpndy, primType);
+    RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(bitSize,
+        cgFunc->GetRegTyFromPrimTy(primType));
+    SelectSub(resOpnd, tmpOpnd, regOpndy, primType);
+    return &resOpnd;
+  }
+}
+
+Operand *MPISel::SelectAlloca(UnaryNode &node, Operand &opnd0) {
+  ASSERT(node.GetPrimType() == PTY_a64, "wrong type");
+  PrimType srcType = node.Opnd(0)->GetPrimType();
+  RegOperand &sizeOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(PTY_u64),
+      cgFunc->GetRegTyFromPrimTy(PTY_u64));
+  SelectCopy(sizeOpnd, opnd0, PTY_u64, srcType);
+
+  /* stack byte alignment */
+  uint32 stackPtrAlignment = cgFunc->GetMemlayout()->GetStackPtrAlignment();
+  RegOperand &aliOp = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(PTY_u64),
+      cgFunc->GetRegTyFromPrimTy(PTY_u64));
+  SelectAdd(aliOp, sizeOpnd, cgFunc->GetOpndBuilder()->CreateImm(k64BitSize,
+      stackPtrAlignment - 1), PTY_u64);
+  ImmOperand &shiftOpnd = cgFunc->GetOpndBuilder()->CreateImm(k64BitSize,
+      __builtin_ctz(stackPtrAlignment));
+  SelectShift(aliOp, aliOp, shiftOpnd, OP_lshr, PTY_u64, PTY_u64);
+  SelectShift(aliOp, aliOp, shiftOpnd, OP_shl, PTY_u64, PTY_u64);
+
+  RegOperand &spOpnd = GetTargetStackPointer(PTY_u64);
+  SelectSub(spOpnd, spOpnd, aliOp, PTY_u64);
+
+  RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(PTY_u64),
+      cgFunc->GetRegTyFromPrimTy(PTY_u64));
+  uint32 argsToStkpassSize = cgFunc->GetMemlayout()->SizeOfArgsToStackPass();
+  if (argsToStkpassSize > 0) {
+    SelectAdd(resOpnd, spOpnd, cgFunc->GetOpndBuilder()->CreateImm(k64BitSize, argsToStkpassSize), PTY_u64);
+  } else {
+    SelectCopy(resOpnd, spOpnd, PTY_u64);
+  }
+  return &resOpnd;
+}
+
+Operand *MPISel::SelectCGArrayElemAdd(BinaryNode &node, const BaseNode &parent) {
+  BaseNode *opnd0 = node.Opnd(0);
+  BaseNode *opnd1 = node.Opnd(1);
+  ASSERT(opnd1->GetOpCode() == OP_constval, "NIY, opnd1->op should be OP_constval.");
+
+  switch (opnd0->GetOpCode()) {
+    case OP_regread: {
+      return SelectRegread(static_cast<RegreadNode&>(*opnd0));
+    }
+    case OP_addrof: {
+      Operand *addrOpnd = SelectAddrof(static_cast<AddrofNode&>(*opnd0), node);
+
+      /* OP_constval */
+      ConstvalNode *constvalNode = static_cast<ConstvalNode*>(opnd1);
+      MIRConst *mirConst = constvalNode->GetConstVal();
+      ASSERT(mirConst->GetKind() == kConstInt, "NIY");
+      MIRIntConst *mirIntConst = static_cast<MIRIntConst*>(mirConst);
+      Operand *immOpnd = SelectIntConst(*mirIntConst, constvalNode->GetPrimType());
+
+      Operand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(PTY_a64),
+          cgFunc->GetRegTyFromPrimTy(PTY_a64));
+      SelectAdd(resOpnd, *addrOpnd, *immOpnd, node.GetPrimType());
+      return &resOpnd;
+    }
+    default:
+      CHECK_FATAL(false, "cannot handle opnd0.");
+  }
+}
+
+StmtNode *MPISel::HandleFuncEntry() {
+  MIRFunction &mirFunc = cgFunc->GetFunction();
+  BlockNode *block = mirFunc.GetBody();
+
+  ASSERT(block != nullptr, "get func body block failed in CGFunc::GenerateInstruction");
+
+  StmtNode *stmt = block->GetFirst();
+  if (stmt == nullptr) {
+    return nullptr;
+  }
+  ASSERT(stmt->GetOpCode() == OP_label, "The first statement should be a label");
+  HandleLabel(*stmt, *this);
+  cgFunc->SetFirstBB(*cgFunc->GetCurBB());
+  stmt = stmt->GetNext();
+  if (stmt == nullptr) {
+    return nullptr;
+  }
+  cgFunc->SetCurBB(*cgFunc->StartNewBBImpl(false, *stmt));
+  bool withFreqInfo = mirFunc.HasFreqMap() && !mirFunc.GetLastFreqMap().empty();
+  if (withFreqInfo) {
+    cgFunc->GetCurBB()->SetFrequency(kFreqBase);
+  }
+
+  return stmt;
+}
+
+/* This function loads src to a register, the src can be an imm, mem or a label.
+ * Once the source and result(destination) types are different,
+ * implicit conversion is executed here.*/
+RegOperand &MPISel::SelectCopy2Reg(Operand &src, PrimType toType, PrimType fromType) {
+  uint32 fromSize = GetPrimTypeBitSize(fromType);
+  uint32 toSize = GetPrimTypeBitSize(toType);
+  if (src.IsRegister() && fromSize == toSize) {
+    return static_cast<RegOperand&>(src);
+  }
+  RegOperand &dest = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(toType),
+      cgFunc->GetRegTyFromPrimTy(toType));
+  if (fromSize != toSize) {
+    SelectCopy(dest, src, toType, fromType);
+  } else {
+    SelectCopy(dest, src, toType);
+  }
+  return dest;
+}
+/* Pretty sure that implicit type conversions will not occur. */
+RegOperand &MPISel::SelectCopy2Reg(Operand &src, PrimType dtype) {
+  ASSERT(src.GetSize() == GetPrimTypeBitSize(dtype), "NIY");
+  if (src.IsRegister()) {
+    return static_cast<RegOperand&>(src);
+  }
+  RegOperand &dest = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(dtype),
+      cgFunc->GetRegTyFromPrimTy(dtype));
+  SelectCopy(dest, src, dtype);
+  return dest;
+}
+/* This function copy/load/store src to a dest, Once the src and dest types
+ * are different, implicit conversion is executed here. */
+void MPISel::SelectCopy(Operand &dest, Operand &src, PrimType toType, PrimType fromType) {
+  if (GetPrimTypeBitSize(fromType) != GetPrimTypeBitSize(toType)) {
+    RegOperand &srcRegOpnd = SelectCopy2Reg(src, fromType);
+    RegOperand &dstRegOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(toType),
+        cgFunc->GetRegTyFromPrimTy(toType));
+    SelectIntCvt(dstRegOpnd, srcRegOpnd, toType, fromType);
+    SelectCopy(dest, dstRegOpnd, toType);
+  } else {
+    SelectCopy(dest, src, toType);
+  }
+}
+
+/* Pretty sure that implicit type conversions will not occur. */
+void MPISel::SelectCopy(Operand &dest, Operand &src, PrimType type) {
+  ASSERT(dest.GetSize() == src.GetSize(), "NIY");
+  if (dest.GetKind() == Operand::kOpdRegister) {
+    SelectCopyInsn(dest, src, type);
+  } else if (dest.GetKind() == Operand::kOpdMem) {
+    if (src.GetKind() != Operand::kOpdRegister) {
+      RegOperand &tempReg = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(type),
+          cgFunc->GetRegTyFromPrimTy(type));
+      SelectCopyInsn(tempReg, src, type);
+      SelectCopyInsn(dest, tempReg, type);
+    } else {
+      SelectCopyInsn(dest, src, type);
+    }
+  }else {
+    CHECK_FATAL(false, "NIY, CPU supports more than memory and registers");
+  }
+}
+
+void MPISel::SelectCopyInsn(Operand &dest, Operand &src, PrimType type) {
+  MOperator mop = GetFastIselMop(dest.GetKind(), src.GetKind(), type);
+  CHECK_FATAL(mop != abstract::MOP_undef, "get mop failed");
+  Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mop, InsnDesc::GetAbstractId(mop));
+  /* For Store, md defines [src, dest] */
+  if (insn.IsStore()) {
+    (void)insn.AddOpndChain(src).AddOpndChain(dest);
+  } else {
+    (void)insn.AddOpndChain(dest).AddOpndChain(src);
+  }
+  cgFunc->GetCurBB()->AppendInsn(insn);
+}
+
+Operand *MPISel::SelectBnot(const UnaryNode &node, Operand &opnd0, const BaseNode &parent [[maybe_unused]]) {
+  PrimType dtype = node.GetPrimType();
+
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(dtype)) {
+    resOpnd = &cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(dtype),
+        cgFunc->GetRegTyFromPrimTy(dtype));
+    RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, dtype, node.Opnd(0)->GetPrimType());
+    SelectBnot(*resOpnd, regOpnd0, dtype);
+  } else {
+    /* vector operand */
+    CHECK_FATAL(false, "NIY");
+  }
+  return resOpnd;
+}
+
+void MPISel::SelectBnot(Operand &resOpnd, Operand &opnd0, PrimType primType) {
+  const static auto fastBnotMappingFunc = DEF_MOPERATOR_MAPPING_FUNC(not);
+  MOperator mOp = fastBnotMappingFunc(GetPrimTypeBitSize(primType));
+  Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, InsnDesc::GetAbstractId(mOp));
+  (void)insn.AddOpndChain(resOpnd).AddOpndChain(opnd0);
+  cgFunc->GetCurBB()->AppendInsn(insn);
+}
+
+Operand *MPISel::SelectMin(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType primType = node.GetPrimType();
+  RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  SelectMin(resOpnd, opnd0, opnd1, primType);
+  return &resOpnd;
+}
+
+void MPISel::SelectMin(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  SelectMinOrMax(true, resOpnd, opnd0, opnd1, primType);
+}
+
+Operand *MPISel::SelectLiteral(MIRDoubleConst &c, MIRFunction &func, uint32 labelIdx) const {
+  MIRSymbol *st = func.GetSymTab()->CreateSymbol(kScopeLocal);
+  std::string lblStr(".LB_");
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(func.GetStIdx().Idx());
+  std::string funcName = funcSt->GetName();
+  (void)lblStr.append(funcName).append(std::to_string(labelIdx));
+  st->SetNameStrIdx(lblStr);
+  st->SetStorageClass(kScPstatic);
+  st->SetSKind(kStConst);
+  st->SetKonst(&c);
+  PrimType primType = c.GetType().GetPrimType();
+  st->SetTyIdx(TyIdx(primType));
+  uint32 typeBitSize = GetPrimTypeBitSize(primType);
+
+  if (cgFunc->GetMirModule().IsCModule()) {
+    return &GetOrCreateMemOpndFromSymbol(*st, typeBitSize, 0);
+  }
+  return nullptr;
+}
+
+Operand *MPISel::SelectMax(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType primType = node.GetPrimType();
+  RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  SelectMax(resOpnd, opnd0, opnd1, primType);
+  return &resOpnd;
+}
+
+void MPISel::SelectMax(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  SelectMinOrMax(false, resOpnd, opnd0, opnd1, primType);
+}
+
+Operand *MPISel::SelectRetype(TypeCvtNode &node, Operand &opnd0) {
+  PrimType fromType = node.Opnd(0)->GetPrimType();
+  PrimType toType = node.GetPrimType();
+  ASSERT(GetPrimTypeSize(fromType) == GetPrimTypeSize(toType), "retype bit widith doesn' match");
+  if (IsPrimitivePoint(fromType) && IsPrimitivePoint(toType)) {
+    return &SelectCopy2Reg(opnd0, toType);
+  }
+  if (IsPrimitiveVector(fromType) || IsPrimitiveVector(toType)) {
+    return &SelectCopy2Reg(opnd0, toType);
+  }
+  if (IsPrimitiveInteger(fromType) && IsPrimitiveInteger(toType)) {
+    return &SelectCopy2Reg(opnd0, toType, fromType);
+  }
+  CHECK_FATAL(false, "NIY, retype");
+  return nullptr;
+}
+
+void MPISel::HandleFuncExit() const {
+  BlockNode *block = cgFunc->GetFunction().GetBody();
+  ASSERT(block != nullptr, "get func body block failed in CGFunc::GenerateInstruction");
+  cgFunc->GetCurBB()->SetLastStmt(*block->GetLast());
+  /* Set lastbb's frequency */
+  cgFunc->SetLastBB(*cgFunc->GetCurBB());
+  /* the last BB is return BB */
+  cgFunc->GetLastBB()->SetKind(BB::kBBReturn);
+
+  cgFunc->AddCommonExitBB();
+}
+
+bool InstructionSelector::PhaseRun(maplebe::CGFunc &f) {
+  MPISel *mpIS = f.GetCG()->CreateMPIsel(*GetPhaseMemPool(), f);
+  mpIS->DoMPIS();
+  return true;
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/isolate_fastpath.cpp b/src/mapleall/maple_be/src/cg/isolate_fastpath.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ebcdc28cd077a29065f12bac4b9af29d47a08da1
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/isolate_fastpath.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "isolate_fastpath.h"
+#if TARGAARCH64
+#include "aarch64_isolate_fastpath.h"
+#endif
+#include "cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+bool CgIsolateFastPath::PhaseRun(maplebe::CGFunc &f) {
+  IsolateFastPath *isolateFastPath = nullptr;
+#if TARGAARCH64
+  isolateFastPath = GetPhaseAllocator()->New<AArch64IsolateFastPath>(f);
+#endif
+  isolateFastPath->Run();
+  return false;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/label_creation.cpp b/src/mapleall/maple_be/src/cg/label_creation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e329da4937ceeb49986ddd1bd2d9b7419b94cda0
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/label_creation.cpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "label_creation.h"
+#include "cgfunc.h"
+#include "cg.h"
+#include "debug_info.h"
+
+namespace maplebe {
+using namespace maple;
+
+void LabelCreation::Run() {
+  CreateStartEndLabel();
+}
+
+void LabelCreation::CreateStartEndLabel() const {
+  ASSERT(cgFunc != nullptr, "expect a cgfunc before CreateStartEndLabel");
+  MIRBuilder *mirBuilder = cgFunc->GetFunction().GetModule()->GetMIRBuilder();
+  ASSERT(mirBuilder != nullptr, "get mirbuilder failed in CreateStartEndLabel");
+
+  /* create start label */
+  LabelIdx startLblIdx = cgFunc->CreateLabel();
+  LabelNode *startLabel = mirBuilder->CreateStmtLabel(startLblIdx);
+  cgFunc->SetStartLabel(*startLabel);
+  cgFunc->GetFunction().GetBody()->InsertFirst(startLabel);
+
+  /* creat return label */
+  LabelIdx returnLblIdx = cgFunc->CreateLabel();
+  LabelNode *returnLabel = mirBuilder->CreateStmtLabel(returnLblIdx);
+  cgFunc->SetReturnLabel(*returnLabel);
+  cgFunc->GetFunction().GetBody()->InsertLast(returnLabel);
+
+  /* create end label */
+  LabelIdx endLblIdx = cgFunc->CreateLabel();
+  LabelNode *endLabel = mirBuilder->CreateStmtLabel(endLblIdx);
+  cgFunc->SetEndLabel(*endLabel);
+  cgFunc->GetFunction().GetBody()->InsertLast(endLabel);
+  ASSERT(cgFunc->GetFunction().GetBody()->GetLast() == endLabel, "last stmt must be a endLabel");
+
+  /* create function's low/high pc if dwarf enabled */
+  MIRFunction *func = &cgFunc->GetFunction();
+  CG *cg = cgFunc->GetCG();
+  if (cg->GetCGOptions().WithDwarf()) {
+    DebugInfo *di = cg->GetMIRModule()->GetDbgInfo();
+    DBGDie *fdie = di->GetDie(func);
+    fdie->SetAttr(DW_AT_low_pc, startLblIdx);
+    fdie->SetAttr(DW_AT_high_pc, endLblIdx);
+  }
+
+  /* add start/end labels into the static map table in class cg */
+  if (!CG::IsInFuncWrapLabels(func)) {
+    CG::SetFuncWrapLabels(func, std::make_pair(startLblIdx, endLblIdx));
+  }
+}
+
+bool CgCreateLabel::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *memPool = GetPhaseMemPool();
+  LabelCreation *labelCreate = memPool->New<LabelCreation>(f);
+  labelCreate->Run();
+  return false;
+}
+} /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/live.cpp b/src/mapleall/maple_be/src/cg/live.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..60e7070b4be8d90a8cda5812a0cefc68603555df
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/live.cpp
@@ -0,0 +1,431 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "live.h"
+#include <set>
+#include "cg.h"
+#include "cg_option.h"
+#include "cgfunc.h"
+
+/*
+ * This phase build two sets: liveOutRegno and liveInRegno of each BB.
+ * This algorithm mainly include 3 parts:
+ * 1. initialize and get def[]/use[] of each BB;
+ * 2. build live_in and live_out based on this algorithm
+ *   Out[B] = U In[S] //S means B's successor;
+ *   In[B] = use[B] U (Out[B]-def[B]);
+ * 3. deal with cleanup BB.
+ */
+namespace maplebe {
+#define LIVE_ANALYZE_DUMP_NEWPM CG_DEBUG_FUNC(f)
+
+void LiveAnalysis::InitAndGetDefUse() {
+  FOR_ALL_BB(bb, cgFunc) {
+    if (!bb->GetEhPreds().empty()) {
+      InitEhDefine(*bb);
+    }
+    InitBB(*bb);
+    GetBBDefUse(*bb);
+    if (bb->GetEhPreds().empty()) {
+      continue;
+    }
+    bb->RemoveInsn(*bb->GetFirstInsn()->GetNext());
+    cgFunc->DecTotalNumberOfInstructions();
+    bb->RemoveInsn(*bb->GetFirstInsn());
+    cgFunc->DecTotalNumberOfInstructions();
+  }
+}
+
+/* Out[BB] = Union all of In[Succs(BB)] */
+bool LiveAnalysis::GenerateLiveOut(BB &bb) const {
+  const auto bbLiveOutBak(bb.GetLiveOut()->GetInfo());
+  for (auto succBB : bb.GetSuccs()) {
+    if (succBB->GetLiveInChange() && !succBB->GetLiveIn()->NoneBit()) {
+      bb.LiveOutOrBits(*succBB->GetLiveIn());
+    }
+    if (!succBB->GetEhSuccs().empty()) {
+      for (auto ehSuccBB : succBB->GetEhSuccs()) {
+        bb.LiveOutOrBits(*ehSuccBB->GetLiveIn());
+      }
+    }
+  }
+  for (auto ehSuccBB : bb.GetEhSuccs()) {
+    if (ehSuccBB->GetLiveInChange() && !ehSuccBB->GetLiveIn()->NoneBit()) {
+      bb.LiveOutOrBits(*ehSuccBB->GetLiveIn());
+    }
+  }
+  return !bb.GetLiveOut()->IsEqual(bbLiveOutBak);
+}
+
+/* In[BB] = use[BB] Union (Out[BB]-def[BB]) */
+bool LiveAnalysis::GenerateLiveIn(BB &bb) {
+  LocalMapleAllocator allocator(stackMp);
+  const auto bbLiveInBak(bb.GetLiveIn()->GetInfo());
+  if (!bb.GetInsertUse()) {
+    bb.SetLiveInInfo(*bb.GetUse());
+    bb.SetInsertUse(true);
+  }
+  SparseDataInfo &bbLiveOut = bb.GetLiveOut()->Clone(allocator);
+  if (!bbLiveOut.NoneBit()) {
+    bbLiveOut.Difference(*bb.GetDef());
+    bb.LiveInOrBits(bbLiveOut);
+  }
+
+  if (!bb.GetEhSuccs().empty()) {
+    /* If bb has eh successors, check if multi-gen exists. */
+    SparseDataInfo allInOfEhSuccs(cgFunc->GetMaxVReg(), allocator);
+    for (auto ehSucc : bb.GetEhSuccs()) {
+      allInOfEhSuccs.OrBits(*ehSucc->GetLiveIn());
+    }
+    allInOfEhSuccs.AndBits(*bb.GetDef());
+    bb.LiveInOrBits(allInOfEhSuccs);
+  }
+
+  if (!bb.GetLiveIn()->IsEqual(bbLiveInBak)) {
+    return true;
+  }
+  return false;
+}
+
+/* building liveIn and liveOut of each BB. */
+void LiveAnalysis::BuildInOutforFunc() {
+  iteration = 0;
+  bool hasChange;
+  do {
+    ++iteration;
+    hasChange = false;
+    FOR_ALL_BB_REV(bb, cgFunc) {
+      if (!GenerateLiveOut(*bb) && bb->GetInsertUse()) {
+        continue;
+      }
+      if (GenerateLiveIn(*bb)) {
+        bb->SetLiveInChange(true);
+        hasChange = true;
+      } else {
+        bb->SetLiveInChange(false);
+      }
+    }
+  } while (hasChange);
+}
+
+/*  reset to liveout/in_regno */
+void LiveAnalysis::ResetLiveSet() {
+  FOR_ALL_BB(bb, cgFunc) {
+    bb->GetLiveIn()->GetBitsOfInfo<MapleSet<uint32>>(bb->GetLiveInRegNO());
+    bb->GetLiveOut()->GetBitsOfInfo<MapleSet<uint32>>(bb->GetLiveOutRegNO());
+  }
+}
+
+/* entry function for LiveAnalysis */
+void LiveAnalysis::AnalysisLive() {
+  InitAndGetDefUse();
+  BuildInOutforFunc();
+  InsertInOutOfCleanupBB();
+}
+
+void LiveAnalysis::DealWithInOutOfCleanupBB() {
+  const BB *cleanupBB = cgFunc->GetCleanupBB();
+  if (cleanupBB == nullptr) {
+    return;
+  }
+  for (size_t i = 0; i != cleanupBB->GetLiveIn()->Size(); ++i) {
+    if (!cleanupBB->GetLiveIn()->TestBit(i)) {
+      continue;
+    }
+    if (CleanupBBIgnoreReg(regno_t(i))) {
+      continue;
+    }
+    /*
+     * a param vreg may used in cleanup bb. So this param vreg will live on the whole function
+     * since everywhere in function body may occur exceptions.
+     */
+    FOR_ALL_BB(bb, cgFunc) {
+      if (bb->IsCleanup()) {
+        continue;
+      }
+      /* If bb is not a cleanup bb, then insert reg to both livein and liveout. */
+      if ((bb != cgFunc->GetFirstBB()) && !bb->GetDef()->TestBit(i)) {
+        bb->SetLiveInBit(i);
+      }
+      bb->SetLiveOutBit(i);
+    }
+  }
+}
+
+void LiveAnalysis::InsertInOutOfCleanupBB() {
+  LocalMapleAllocator allocator(stackMp);
+  const BB *cleanupBB = cgFunc->GetCleanupBB();
+  if (cleanupBB == nullptr) {
+    return;
+  }
+  if (cleanupBB->GetLiveIn() == nullptr || cleanupBB->GetLiveIn()->NoneBit()) {
+    return;
+  }
+  SparseDataInfo &cleanupBBLi = cleanupBB->GetLiveIn()->Clone(allocator);
+  /* registers need to be ignored: (reg < 8) || (29 <= reg && reg <= 32) */
+  for (uint32 i = 1; i < 8; ++i) {
+    cleanupBBLi.ResetBit(i);
+  }
+  for (uint32 j = 29; j <= 32; ++j) {
+    cleanupBBLi.ResetBit(j);
+  }
+
+  FOR_ALL_BB(bb, cgFunc) {
+    if (bb->IsCleanup()) {
+      continue;
+    }
+    if (bb != cgFunc->GetFirstBB()) {
+      cleanupBBLi.Difference(*bb->GetDef());
+      bb->LiveInOrBits(cleanupBBLi);
+    }
+    bb->LiveOutOrBits(cleanupBBLi);
+  }
+}
+
+/*
+ * entry of get def/use of bb.
+ * getting the def or use info of each regopnd as parameters of CollectLiveInfo().
+*/
+void LiveAnalysis::GetBBDefUse(BB &bb) {
+  if (bb.GetKind() == BB::kBBReturn) {
+    GenerateReturnBBDefUse(bb);
+  }
+  if (bb.IsEmpty()) {
+    return;
+  }
+  bb.DefResetAllBit();
+  bb.UseResetAllBit();
+
+  FOR_BB_INSNS_REV(insn, &bb) {
+    if (!insn->IsMachineInstruction() && !insn->IsPhi()) {
+      continue;
+    }
+
+    bool isAsm = insn->IsAsmInsn();
+    const InsnDesc *md = insn->GetDesc();
+    if (insn->IsCall() || insn->IsTailCall()) {
+      ProcessCallInsnParam(bb, *insn);
+    }
+    uint32 opndNum = insn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      const OpndDesc *opndDesc = md->GetOpndDes(i);
+      ASSERT(opndDesc != nullptr, "null ptr check");
+      Operand &opnd = insn->GetOperand(i);
+      if (opnd.IsList()) {
+        if (isAsm) {
+          ProcessAsmListOpnd(bb, opnd, i);
+        } else {
+          ProcessListOpnd(bb, opnd, opndDesc->IsDef());
+        }
+      } else if (opnd.IsMemoryAccessOperand()) {
+        ProcessMemOpnd(bb, opnd);
+      } else if (opnd.IsConditionCode()) {
+        ProcessCondOpnd(bb);
+      } else if (opnd.IsPhi()) {
+        auto &phiOpnd = static_cast<PhiOperand &>(opnd);
+        for (auto opIt : phiOpnd.GetOperands()) {
+          CollectLiveInfo(bb, *opIt.second, false, true);
+        }
+      } else {
+        bool isDef = opndDesc->IsRegDef();
+        bool isUse = opndDesc->IsRegUse();
+        CollectLiveInfo(bb, opnd, isDef, isUse);
+      }
+    }
+  }
+}
+
+/* build use and def sets of each BB according to the type of regOpnd. */
+void LiveAnalysis::CollectLiveInfo(BB &bb, const Operand &opnd, bool isDef, bool isUse) const {
+  if (!opnd.IsRegister()) {
+    return;
+  }
+  const RegOperand &regOpnd = static_cast<const RegOperand&>(opnd);
+  regno_t regNO = regOpnd.GetRegisterNumber();
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType == kRegTyVary) {
+    return;
+  }
+  if (isDef) {
+    bb.SetDefBit(regNO);
+    if (!isUse) {
+      bb.UseResetBit(regNO);
+    }
+  }
+  if (isUse) {
+    bb.SetUseBit(regNO);
+    bb.DefResetBit(regNO);
+  }
+}
+
+void LiveAnalysis::ProcessAsmListOpnd(BB &bb, Operand &opnd, uint32 idx) const {
+  bool isDef = false;
+  bool isUse = false;
+  switch (idx) {
+    case kAsmOutputListOpnd:
+    case kAsmClobberListOpnd: {
+      isDef = true;
+      break;
+    }
+    case kAsmInputListOpnd: {
+      isUse = true;
+      break;
+    }
+    default:
+      return;
+  }
+  ListOperand &listOpnd = static_cast<ListOperand&>(opnd);
+  for (auto op : listOpnd.GetOperands()) {
+    CollectLiveInfo(bb, *op, isDef, isUse);
+  }
+}
+
+void LiveAnalysis::ProcessListOpnd(BB &bb, Operand &opnd, bool isDef) const {
+  ListOperand &listOpnd = static_cast<ListOperand&>(opnd);
+  for (auto op : listOpnd.GetOperands()) {
+    CollectLiveInfo(bb, *op, isDef, !isDef);
+  }
+}
+
+void LiveAnalysis::ProcessMemOpnd(BB &bb, Operand &opnd) const {
+  auto &memOpnd = static_cast<MemOperand&>(opnd);
+  Operand *base = memOpnd.GetBaseRegister();
+  Operand *offset = memOpnd.GetIndexRegister();
+  if (base != nullptr) {
+    CollectLiveInfo(bb, *base, !memOpnd.IsIntactIndexed(), true);
+  }
+  if (offset != nullptr) {
+    CollectLiveInfo(bb, *offset, false, true);
+  }
+}
+
+void LiveAnalysis::ProcessCondOpnd(BB &bb) const {
+  Operand &rflag = cgFunc->GetOrCreateRflag();
+  CollectLiveInfo(bb, rflag, false, true);
+}
+
+/* dump the current info of def/use/livein/liveout */
+void LiveAnalysis::Dump() const {
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(cgFunc->GetFunction().GetStIdx().Idx());
+  ASSERT(funcSt != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << "\n---------  liveness for " << funcSt->GetName() << "  iteration ";
+  LogInfo::MapleLogger() << iteration << " ---------\n";
+  FOR_ALL_BB(bb, cgFunc) {
+    LogInfo::MapleLogger() << "  === BB_" << bb->GetId() << " (" << std::hex << bb << ") "
+                           << std::dec << " <" << bb->GetKindName();
+    if (bb->GetLabIdx() != MIRLabelTable::GetDummyLabel()) {
+      LogInfo::MapleLogger() << "[labeled with " << bb->GetLabIdx() << "]";
+    }
+    LogInfo::MapleLogger() << "> idx " << bb->GetId() << " ===\n";
+
+    if (!bb->GetPreds().empty()) {
+      LogInfo::MapleLogger() << "    pred [ ";
+      for (auto *pred : bb->GetPreds()) {
+        LogInfo::MapleLogger() << pred->GetId() << " (" << std::hex << pred << ") " << std::dec << " ";
+      }
+      LogInfo::MapleLogger() << "]\n";
+    }
+    if (!bb->GetSuccs().empty()) {
+      LogInfo::MapleLogger() << "    succ [ ";
+      for (auto *succ : bb->GetSuccs()) {
+        LogInfo::MapleLogger() << succ->GetId() << " (" << std::hex << succ << ") " << std::dec << " ";
+      }
+      LogInfo::MapleLogger() << "]\n";
+    }
+
+    const SparseDataInfo *infoDef = nullptr;
+    LogInfo::MapleLogger() << "    DEF: ";
+    infoDef = bb->GetDef();
+    DumpInfo(*infoDef);
+
+    const SparseDataInfo *infoUse = nullptr;
+    LogInfo::MapleLogger() << "\n    USE: ";
+    infoUse = bb->GetUse();
+    DumpInfo(*infoUse);
+
+    const SparseDataInfo *infoLiveIn = nullptr;
+    LogInfo::MapleLogger() << "\n    Live IN: ";
+    infoLiveIn = bb->GetLiveIn();
+    DumpInfo(*infoLiveIn);
+
+    const SparseDataInfo *infoLiveOut = nullptr;
+    LogInfo::MapleLogger() << "\n    Live OUT: ";
+    infoLiveOut = bb->GetLiveOut();
+    DumpInfo(*infoLiveOut);
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "---------------------------\n";
+}
+
+void LiveAnalysis::DumpInfo(const SparseDataInfo &info) const {
+  uint32 count = 1;
+  std::set<uint32> res;
+  info.GetInfo().ConvertToSet(res);
+  for (uint32 x : res) {
+    LogInfo::MapleLogger() << x << " ";
+    ++count;
+    /* 20 output one line */
+    if ((count % 20) == 0) {
+      LogInfo::MapleLogger() << "\n";
+    }
+  }
+  LogInfo::MapleLogger() << '\n';
+}
+
+/* initialize dependent info and container of BB. */
+void LiveAnalysis::InitBB(BB &bb) {
+  bb.SetLiveInChange(true);
+  bb.SetInsertUse(false);
+  bb.ClearLiveInRegNO();
+  bb.ClearLiveOutRegNO();
+  const uint32 maxRegCount = cgFunc->GetSSAvRegCount() > cgFunc->GetMaxVReg() ?
+      cgFunc->GetSSAvRegCount() : cgFunc->GetMaxVReg();
+  bb.SetLiveIn(*NewLiveIn(maxRegCount));
+  bb.SetLiveOut(*NewLiveOut(maxRegCount));
+  bb.SetDef(*NewDef(maxRegCount));
+  bb.SetUse(*NewUse(maxRegCount));
+}
+
+void LiveAnalysis::ClearInOutDataInfo() {
+  FOR_ALL_BB(bb, cgFunc) {
+    bb->SetLiveInChange(false);
+    bb->DefClearDataInfo();
+    bb->UseClearDataInfo();
+    bb->LiveInClearDataInfo();
+    bb->LiveOutClearDataInfo();
+  }
+}
+
+void LiveAnalysis::EnlargeSpaceForLiveAnalysis(BB &currBB) {
+  regno_t currMaxVRegNO = cgFunc->GetMaxVReg();
+  if (currMaxVRegNO >= currBB.GetLiveIn()->Size()) {
+    FOR_ALL_BB(bb, cgFunc) {
+      bb->LiveInEnlargeCapacity(currMaxVRegNO);
+      bb->LiveOutEnlargeCapacity(currMaxVRegNO);
+    }
+  }
+}
+
+bool CgLiveAnalysis::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *liveMemPool = GetPhaseMemPool();
+  live = f.GetCG()->CreateLiveAnalysis(*liveMemPool, f);
+  CHECK_FATAL(live != nullptr, "NIY");
+  live->AnalysisLive();
+  if (LIVE_ANALYZE_DUMP_NEWPM) {
+    live->Dump();
+  }
+  return false;
+}
+MAPLE_ANALYSIS_PHASE_REGISTER(CgLiveAnalysis, liveanalysis)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/local_opt.cpp b/src/mapleall/maple_be/src/cg/local_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..65b5639c324c401e7e500e9d63c848ce97be6337
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/local_opt.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "local_opt.h"
+#include "cg.h"
+#include "mpl_logging.h"
+#if defined TARGX86_64
+#include "x64_reaching.h"
+#endif
+/*
+ * this phase does optimization on local level(single bb or super bb)
+ * this phase requires liveanalysis
+ */
+namespace maplebe {
+void LocalOpt::DoLocalCopyPropOptmize() {
+  DoLocalCopyProp();
+}
+
+void LocalPropOptimizePattern::Run() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (!CheckCondition(*insn)) {
+        continue;
+      }
+      Optimize(*bb, *insn);
+    }
+  }
+}
+
+bool LocalCopyProp::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *mp = GetPhaseMemPool();
+  LiveAnalysis *liveInfo = nullptr;
+  liveInfo = GET_ANALYSIS(CgLiveAnalysis, f);
+  liveInfo->ResetLiveSet();
+  auto *reachingDef = f.GetCG()->CreateReachingDefinition(*mp, f);
+  LocalOpt *localOpt = f.GetCG()->CreateLocalOpt(*mp, f, *reachingDef);
+  localOpt->DoLocalCopyPropOptmize();
+  return false;
+}
+
+void LocalCopyProp::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.AddPreserved<CgLiveAnalysis>();
+}
+
+bool RedundantDefRemove::CheckCondition(Insn &insn) {
+  uint32 opndNum = insn.GetOperandSize();
+  const InsnDesc *md = insn.GetDesc();
+  std::vector<Operand*> defOpnds;
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    auto *opndDesc = md->opndMD[i];
+    if (opndDesc->IsDef() && opndDesc->IsUse()) {
+      return false;
+    }
+    if (opnd.IsList()) {
+      continue;
+    }
+    if (opndDesc->IsDef()) {
+      defOpnds.emplace_back(&opnd);
+    }
+  }
+  if (defOpnds.size() != 1 || !defOpnds[0]->IsRegister()) {
+    return false;
+  }
+  auto &regDef = static_cast<RegOperand&>(*defOpnds[0]);
+  auto &liveOutRegSet = insn.GetBB()->GetLiveOutRegNO();
+  if (liveOutRegSet.find(regDef.GetRegisterNumber()) != liveOutRegSet.end()) {
+    return false;
+  }
+  return true;
+}
+
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(LocalCopyProp, localcopyprop)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/loop.cpp b/src/mapleall/maple_be/src/cg/loop.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7e752bb0a18d298e5992c315d901fda2c0991479
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/loop.cpp
@@ -0,0 +1,679 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "loop.h"
+#include "cg.h"
+#include "optimize_common.h"
+
+namespace maplebe {
+#define LOOP_ANALYSIS_DUMP_NEWPM CG_DEBUG_FUNC(f)
+
+static void PrintLoopInfo(const LoopHierarchy &loop) {
+  LogInfo::MapleLogger() << "header " << loop.GetHeader()->GetId();
+  if (loop.GetOtherLoopEntries().size() != 0) {
+    LogInfo::MapleLogger() << " multi-header ";
+    for (auto en : loop.GetOtherLoopEntries()) {
+      LogInfo::MapleLogger() << en->GetId() << " ";
+    }
+  }
+  if (loop.GetOuterLoop() != nullptr) {
+    LogInfo::MapleLogger() << " parent " << loop.GetOuterLoop()->GetHeader()->GetId();
+  }
+  LogInfo::MapleLogger() << " backedge ";
+  for (auto *bb : loop.GetBackedge()) {
+    LogInfo::MapleLogger() << bb->GetId() << " ";
+  }
+  LogInfo::MapleLogger() << "\n members ";
+  for (auto *bb : loop.GetLoopMembers()) {
+    LogInfo::MapleLogger() << bb->GetId() << " ";
+  }
+  if (!loop.GetInnerLoops().empty()) {
+    LogInfo::MapleLogger() << "\n inner_loop_headers ";
+    for (auto *inner : loop.GetInnerLoops()) {
+      LogInfo::MapleLogger() << inner->GetHeader()->GetId() << " ";
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+static void PrintInner(const LoopHierarchy &loop, uint32 level) {
+  for (auto *inner : loop.GetInnerLoops()) {
+    LogInfo::MapleLogger() << "loop-level-" << level << "\n";
+    PrintLoopInfo(*inner);
+    PrintInner(*inner, level + 1);
+  }
+}
+
+void LoopHierarchy::PrintLoops(const std::string &name) const {
+  LogInfo::MapleLogger() << name << "\n";
+  for (const LoopHierarchy *loop = this; loop != nullptr; loop = loop->next) {
+    PrintLoopInfo(*loop);
+  }
+  for (const LoopHierarchy *loop = this; loop != nullptr; loop = loop->next) {
+    PrintInner(*loop, 1);
+  }
+}
+
+void CGFuncLoops::CheckOverlappingInnerLoops(const MapleVector<CGFuncLoops*> &iLoops,
+                                             const MapleVector<BB*> &loopMem) const {
+  for (auto iloop : iLoops) {
+    CHECK_FATAL(iloop->loopMembers.size() > 0, "Empty loop");
+    for (auto bb: iloop->loopMembers) {
+      if (find(loopMem.begin(), loopMem.end(), bb) != loopMem.end()) {
+        LogInfo::MapleLogger() << "Error: inconsistent loop member";
+        CHECK_FATAL(0, "loop member overlap with inner loop");
+      }
+    }
+    CheckOverlappingInnerLoops(iloop->innerLoops, loopMem);
+  }
+}
+
+void CGFuncLoops::CheckLoops() const {
+  // Make sure backedge -> header relationship holds
+  for (auto bEdge: backedge) {
+    if (find(bEdge->GetSuccs().begin(), bEdge->GetSuccs().end(), header) == bEdge->GetSuccs().end()) {
+      bool inOtherEntry = false;
+      for (auto entry: multiEntries) {
+        if (find(bEdge->GetSuccs().begin(), bEdge->GetSuccs().end(), entry) != bEdge->GetSuccs().end()) {
+          inOtherEntry = true;
+          break;
+        }
+      }
+      if (inOtherEntry == false) {
+        if (find(bEdge->GetEhSuccs().begin(), bEdge->GetEhSuccs().end(), header) == bEdge->GetEhSuccs().end()) {
+          LogInfo::MapleLogger() << "Error: inconsistent loop backedge";
+          CHECK_FATAL(0, "loop backedge does not go to loop header");
+        }
+      }
+    }
+    if (find(header->GetPreds().begin(), header->GetPreds().end(), bEdge) == header->GetPreds().end()) {
+      bool inOtherEntry = false;
+      for (auto entry: multiEntries) {
+        if (find(entry->GetPreds().begin(), entry->GetPreds().end(), bEdge) != entry->GetPreds().end()) {
+          inOtherEntry = true;
+          break;
+        }
+      }
+      if (inOtherEntry == false) {
+        if (find(header->GetEhPreds().begin(), header->GetEhPreds().end(), bEdge) == header->GetEhPreds().end()) {
+          LogInfo::MapleLogger() << "Error: inconsistent loop header";
+          CHECK_FATAL(0, "loop header does not have a backedge");
+        }
+      }
+    }
+  }
+
+  // Make sure containing loop members do not overlap
+  CheckOverlappingInnerLoops(innerLoops, loopMembers);
+
+  if (innerLoops.empty() == false) {
+    for (auto lp : innerLoops) {
+      lp->CheckLoops();
+    }
+  }
+}
+
+void CGFuncLoops::PrintLoops(const CGFuncLoops &funcLoop) const {
+  LogInfo::MapleLogger() << "loop_level(" << funcLoop.loopLevel << ") ";
+  LogInfo::MapleLogger() << "header " << funcLoop.GetHeader()->GetId() << " ";
+  if (funcLoop.multiEntries.size() != 0) {
+    LogInfo::MapleLogger() << "other-header ";
+    for (auto bb : funcLoop.multiEntries) {
+      LogInfo::MapleLogger() << bb->GetId() << " ";
+    }
+  }
+  if (funcLoop.GetOuterLoop() != nullptr) {
+    LogInfo::MapleLogger() << "parent " << funcLoop.GetOuterLoop()->GetHeader()->GetId() << " ";
+  }
+  LogInfo::MapleLogger() << "backedge ";
+  for (auto *bb : funcLoop.GetBackedge()) {
+    LogInfo::MapleLogger() << bb->GetId() << " ";
+  }
+  LogInfo::MapleLogger() << "\n members ";
+  for (auto *bb : funcLoop.GetLoopMembers()) {
+    LogInfo::MapleLogger() << bb->GetId() << " ";
+  }
+  LogInfo::MapleLogger() << "\n exits ";
+  for (auto *bb : funcLoop.GetExits()) {
+    LogInfo::MapleLogger() << bb->GetId() << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+  if (!funcLoop.GetInnerLoops().empty()) {
+    LogInfo::MapleLogger() << " inner_loop_headers ";
+    for (auto *inner : funcLoop.GetInnerLoops()) {
+      LogInfo::MapleLogger() << inner->GetHeader()->GetId() << " ";
+    }
+    LogInfo::MapleLogger() << "\n";
+    for (auto *inner : funcLoop.GetInnerLoops()) {
+      PrintLoops(*inner);
+    }
+  }
+}
+
+bool CGFuncLoops::IsBBLoopMember(const BB *bb) const {
+  return (*(std::find(loopMembers.begin(), loopMembers.end(), bb)) == bb);
+}
+
+// partial loop body found with formLoop is NOT really needed in down stream
+//       It should be simplied later
+void LoopFinder::FormLoop(BB* headBB, BB* backBB) {
+  ASSERT(headBB != nullptr && backBB != nullptr, "headBB or backBB is nullptr");
+  LoopHierarchy *simpleLoop = memPool->New<LoopHierarchy>(*memPool);
+
+  if (headBB != backBB) {
+    ASSERT(!dfsBBs.empty(), "dfsBBs is empty");
+    ASSERT(onPathBBs[headBB->GetId()], "headBB is not on execution path");
+    std::stack<BB*> tempStk;
+
+    tempStk.push(dfsBBs.top());
+    dfsBBs.pop();
+
+    while (tempStk.top() != headBB && !dfsBBs.empty()) {
+      tempStk.push(dfsBBs.top());
+      dfsBBs.pop();
+    }
+
+    while (!tempStk.empty()) {
+      BB *topBB = tempStk.top();
+      tempStk.pop();
+
+      if (onPathBBs[topBB->GetId()]) {
+        simpleLoop->InsertLoopMembers(*topBB);
+      }
+      dfsBBs.push(topBB);
+    }
+  }
+  // Note: backBB is NOT on dfsBBs
+  simpleLoop->InsertLoopMembers(*backBB);
+  simpleLoop->SetHeader(*headBB);
+  simpleLoop->InsertBackedge(*backBB);
+  simpleLoop->InsertBackBBEdge(*backBB, *headBB);
+
+  if (loops) {
+    loops->SetPrev(simpleLoop);
+  }
+  simpleLoop->SetNext(loops);
+  loops = simpleLoop;
+}
+
+void LoopFinder::SeekBackEdge(BB* bb, MapleList<BB*> succs) {
+  for (const auto succBB : succs) {
+    if (!visitedBBs[succBB->GetId()]) {
+      dfsBBs.push(succBB);
+    } else {
+      if (onPathBBs[succBB->GetId()]) {
+        FormLoop(succBB, bb);
+        bb->PushBackLoopSuccs(*succBB);
+        succBB->PushBackLoopPreds(*bb);
+      }
+    }
+  }
+}
+
+void LoopFinder::SeekCycles() {
+  while (!dfsBBs.empty()) {
+    BB *bb = dfsBBs.top();
+    if (visitedBBs[bb->GetId()]) {
+      onPathBBs[bb->GetId()] = false;
+      dfsBBs.pop();
+      continue;
+    }
+
+    visitedBBs[bb->GetId()] = true;
+    onPathBBs[bb->GetId()] = true;
+    SeekBackEdge(bb, bb->GetSuccs());
+    SeekBackEdge(bb, bb->GetEhSuccs());
+  }
+}
+
+void LoopFinder::MarkExtraEntryAndEncl() {
+  ASSERT(dfsBBs.empty(), "dfsBBs is NOT empty");
+  std::vector<BB *> loopEnclosure;
+  loopEnclosure.resize(cgFunc->NumBBs());
+  std::vector<bool> startProcess;
+  startProcess.resize(cgFunc->NumBBs());
+  std::vector<BB *> origEntries;
+  origEntries.resize(cgFunc->NumBBs());
+  std::vector<BB *> newEntries;
+  newEntries.resize(cgFunc->NumBBs());
+
+  for (LoopHierarchy *loop = loops; loop != nullptr; loop = loop->GetNext()) {
+    fill(visitedBBs.begin(), visitedBBs.end(), false);
+    fill(loopEnclosure.begin(), loopEnclosure.end(), nullptr);
+    fill(startProcess.begin(), startProcess.end(), false);
+    fill(origEntries.begin(), origEntries.end(), nullptr);
+    fill(newEntries.begin(), newEntries.end(), nullptr);
+
+    for (auto *bb : loop->GetLoopMembers()) {
+      loopEnclosure[bb->GetId()] = bb;
+    }
+    origEntries[loop->GetHeader()->GetId()] = loop->GetHeader();
+
+    // Form loop closure from the primary entry. At end collect all other entries
+    bool changed = false;
+    dfsBBs.push(loop->GetHeader());
+    while (true) {
+      while (!dfsBBs.empty()) {
+        BB *bb = dfsBBs.top();
+        visitedBBs[bb->GetId()] = true;
+        if (startProcess[bb->GetId()]) {
+          dfsBBs.pop();
+          for (const auto succBB : bb->GetSuccs()) {
+            if (loopEnclosure[bb->GetId()] == nullptr &&
+                loopEnclosure[succBB->GetId()] != nullptr &&
+                succBB != loop->GetHeader()) {
+              changed = true;
+              loopEnclosure[bb->GetId()] = bb;
+              break;
+            }
+          }
+          continue;
+        } else {
+          startProcess[bb->GetId()] = true;
+          for (const auto succBB : bb->GetSuccs()) {
+            if (!visitedBBs[succBB->GetId()]) {
+              dfsBBs.push(succBB);
+            }
+          }
+        }
+      }
+
+      // Repeat till no new item is added in
+      if (changed) {
+        dfsBBs.push(loop->GetHeader());
+        changed = false;
+        fill(visitedBBs.begin(), visitedBBs.end(), false);
+        fill(startProcess.begin(), startProcess.end(), false);
+        continue;
+      }
+
+      // Collect all entries
+      bool foundNewEntry = false;
+      fill(visitedBBs.begin(), visitedBBs.end(), false);
+      FOR_ALL_BB(bb, cgFunc) {
+        if (!visitedBBs[bb->GetId()]) {
+          dfsBBs.push(bb);
+          visitedBBs[bb->GetId()] = true;
+          while (!dfsBBs.empty()) {
+            BB *currBB = dfsBBs.top();
+            visitedBBs[currBB->GetId()] = true;
+            dfsBBs.pop();
+            for (const auto succBB : currBB->GetSuccs()) {
+              // check if entering a loop.
+              if ((loopEnclosure[succBB->GetId()] != nullptr) &&
+                  (loopEnclosure[currBB->GetId()] == nullptr)) {
+                newEntries[succBB->GetId()] = succBB;
+                if (origEntries[succBB->GetId()] == nullptr) {
+                  foundNewEntry = true;
+                }
+              }
+              if (!visitedBBs[succBB->GetId()]) {
+                dfsBBs.push(succBB);
+              }
+            }
+          }
+        }
+      }
+      if (foundNewEntry) {
+        origEntries = newEntries;
+        for (const auto bb : newEntries) {
+          if (bb != nullptr) {
+            dfsBBs.push(bb);
+          }
+        }
+        fill(visitedBBs.begin(), visitedBBs.end(), false);
+        fill(startProcess.begin(), startProcess.end(), false);
+        fill(newEntries.begin(), newEntries.end(), nullptr);
+      } else {
+        break;
+      }
+    }
+
+    // Setup loop body
+    for (size_t id = 0; id < loopEnclosure.size(); id++) {
+      if (loopEnclosure[id] != nullptr) {
+        loop->InsertLoopMembers(*loopEnclosure[id]);
+      }
+    }
+
+    // Setup head and extra entries
+    for (const auto bb : newEntries) {
+      if (bb != nullptr) {
+        loop->InsertBBToOtherLoopEntries(bb);
+      }
+    }
+    loop->EraseBBFromOtherLoopEntries(loop->GetHeader());
+  }
+}
+
+bool LoopFinder::HasSameHeader(const LoopHierarchy *lp1, const LoopHierarchy *lp2) const {
+  if (lp1->GetHeader() == lp2->GetHeader()) {
+    return true;
+  }
+  for (auto other1 : lp1->GetOtherLoopEntries()) {
+    if (lp2->GetHeader() == other1) {
+      return true;
+    }
+    for (auto other2 : lp2->GetOtherLoopEntries()) {
+      if (other2 == other1) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void LoopFinder::MergeLoops() {
+  for (LoopHierarchy *loopHierarchy1 = loops; loopHierarchy1 != nullptr; loopHierarchy1 = loopHierarchy1->GetNext()) {
+    for (LoopHierarchy *loopHierarchy2 = loopHierarchy1->GetNext(); loopHierarchy2 != nullptr;
+         loopHierarchy2 = loopHierarchy2->GetNext()) {
+      // Different loop bodies imply different loops
+      bool sameLoop = true;
+      if (loopHierarchy1->GetLoopMembers().size() == loopHierarchy2->GetLoopMembers().size()) {
+        for (auto *bb : loopHierarchy2->GetLoopMembers()) {
+          if (find(loopHierarchy1->GetLoopMembers().begin(), loopHierarchy1->GetLoopMembers().end(), bb) ==
+              loopHierarchy1->GetLoopMembers().end()) {
+            sameLoop = false;
+            break;
+          }
+        }
+        if (sameLoop) {
+          for (auto *bb : loopHierarchy1->GetLoopMembers()) {
+            if (find(loopHierarchy2->GetLoopMembers().begin(), loopHierarchy2->GetLoopMembers().end(), bb) ==
+                loopHierarchy2->GetLoopMembers().end()) {
+              sameLoop = false;
+              break;
+            }
+          }
+        }
+        if (sameLoop) {
+          loopHierarchy2->GetPrev()->SetNext(loopHierarchy2->GetNext());
+          if (loopHierarchy2->GetNext() != nullptr) {
+            loopHierarchy2->GetNext()->SetPrev(loopHierarchy2->GetPrev());
+          }
+          continue;
+        }
+      }
+      if (HasSameHeader(loopHierarchy1, loopHierarchy2) == false) {
+        continue;
+      }
+      for (auto *bb : loopHierarchy2->GetLoopMembers()) {
+        loopHierarchy1->InsertLoopMembers(*bb);
+      }
+      if (loopHierarchy1->GetHeader() != loopHierarchy2->GetHeader()) {
+        loopHierarchy1->InsertBBToOtherLoopEntries(loopHierarchy2->GetHeader());
+      }
+      for (auto bb : loopHierarchy2->GetOtherLoopEntries()) {
+        if (loopHierarchy1->GetHeader() != bb) {
+          loopHierarchy1->InsertBBToOtherLoopEntries(bb);
+        }
+      }
+      for (auto *bb : loopHierarchy2->GetBackedge()) {
+        loopHierarchy1->InsertBackedge(*bb);
+      }
+      loopHierarchy2->GetPrev()->SetNext(loopHierarchy2->GetNext());
+      if (loopHierarchy2->GetNext() != nullptr) {
+        loopHierarchy2->GetNext()->SetPrev(loopHierarchy2->GetPrev());
+      }
+    }
+  }
+}
+
+void LoopFinder::SortLoops() {
+  LoopHierarchy *head = nullptr;
+  LoopHierarchy *next1 = nullptr;
+  LoopHierarchy *next2 = nullptr;
+  bool swapped;
+  do {
+    swapped = false;
+    for (LoopHierarchy *loopHierarchy1 = loops; loopHierarchy1 != nullptr;) {
+      /* remember loopHierarchy1's prev in case if loopHierarchy1 moved */
+      head = loopHierarchy1;
+      next1 = loopHierarchy1->GetNext();
+      for (LoopHierarchy *loopHierarchy2 = loopHierarchy1->GetNext(); loopHierarchy2 != nullptr;) {
+        next2 = loopHierarchy2->GetNext();
+
+        if (loopHierarchy1->GetLoopMembers().size() > loopHierarchy2->GetLoopMembers().size()) {
+          if (head->GetPrev() == nullptr) {
+            /* remove loopHierarchy2 from list */
+            loopHierarchy2->GetPrev()->SetNext(loopHierarchy2->GetNext());
+            if (loopHierarchy2->GetNext() != nullptr) {
+              loopHierarchy2->GetNext()->SetPrev(loopHierarchy2->GetPrev());
+            }
+            /* link loopHierarchy2 as head */
+            loops = loopHierarchy2;
+            loopHierarchy2->SetPrev(nullptr);
+            loopHierarchy2->SetNext(head);
+            head->SetPrev(loopHierarchy2);
+          } else {
+            loopHierarchy2->GetPrev()->SetNext(loopHierarchy2->GetNext());
+            if (loopHierarchy2->GetNext() != nullptr) {
+              loopHierarchy2->GetNext()->SetPrev(loopHierarchy2->GetPrev());
+            }
+            head->GetPrev()->SetNext(loopHierarchy2);
+            loopHierarchy2->SetPrev(head->GetPrev());
+            loopHierarchy2->SetNext(head);
+            head->SetPrev(loopHierarchy2);
+          }
+          head = loopHierarchy2;
+          swapped = true;
+        }
+        loopHierarchy2 = next2;
+      }
+      loopHierarchy1 = next1;
+    }
+  } while (swapped);
+}
+
+void LoopFinder::UpdateOuterForInnerLoop(BB *bb, LoopHierarchy *outer) {
+  if (outer == nullptr) {
+    return;
+  }
+  for (auto ito = outer->GetLoopMembers().begin(); ito != outer->GetLoopMembers().end();) {
+    if (*ito == bb) {
+      ito = outer->EraseLoopMembers(ito);
+    } else {
+      ++ito;
+    }
+  }
+  if (outer->GetOuterLoop() != nullptr) {
+    UpdateOuterForInnerLoop(bb, const_cast<LoopHierarchy *>(outer->GetOuterLoop()));
+  }
+}
+
+void LoopFinder::UpdateOuterLoop(const LoopHierarchy *loop) {
+  for (auto inner : loop->GetInnerLoops()) {
+    UpdateOuterLoop(inner);
+  }
+  for (auto *bb : loop->GetLoopMembers()) {
+    UpdateOuterForInnerLoop(bb, const_cast<LoopHierarchy *>(loop->GetOuterLoop()));
+  }
+}
+
+void LoopFinder::CreateInnerLoop(LoopHierarchy &inner, LoopHierarchy &outer) {
+  outer.InsertInnerLoops(inner);
+  inner.SetOuterLoop(outer);
+  if (loops == &inner) {
+    loops = inner.GetNext();
+  } else {
+    LoopHierarchy *prev = loops;
+    for (LoopHierarchy *loopHierarchy1 = loops->GetNext(); loopHierarchy1 != nullptr;
+         loopHierarchy1 = loopHierarchy1->GetNext()) {
+      if (loopHierarchy1 == &inner) {
+        prev->SetNext(prev->GetNext()->GetNext());
+      }
+      prev = loopHierarchy1;
+    }
+  }
+}
+
+static void FindLoopExits(LoopHierarchy *loop) {
+  for (auto *bb : loop->GetLoopMembers()) {
+    for (auto succ : bb->GetSuccs()) {
+      if (find(loop->GetLoopMembers().begin(), loop->GetLoopMembers().end(), succ) == loop->GetLoopMembers().end()) {
+        loop->InsertExit(*bb);
+      }
+    }
+  }
+  for (auto *inner : loop->GetInnerLoops()) {
+    FindLoopExits(inner);
+  }
+}
+
+void LoopFinder::DetectInnerLoop() {
+  for (LoopHierarchy *loop = loops; loop != nullptr; loop = loop->GetNext()) {
+    FindLoopExits(loop);
+  }
+  bool innerCreated;
+  do {
+    innerCreated = false;
+    for (LoopHierarchy *loopHierarchy1 = loops; loopHierarchy1 != nullptr;
+         loopHierarchy1 = loopHierarchy1->GetNext()) {
+      for (LoopHierarchy *loopHierarchy2 = loopHierarchy1->GetNext(); loopHierarchy2 != nullptr;
+           loopHierarchy2 = loopHierarchy2->GetNext()) {
+        if (loopHierarchy1->GetHeader() != loopHierarchy2->GetHeader()) {
+          const auto &loopHierarchy2Members = loopHierarchy2->GetLoopMembers();
+          if (find(loopHierarchy2Members.begin(), loopHierarchy2Members.end(), loopHierarchy1->GetHeader()) !=
+              loopHierarchy2Members.end()) {
+            bool allin = true;
+            // Make sure body is included
+            for (auto *bb1 : loopHierarchy1->GetLoopMembers()) {
+              if (find(loopHierarchy2Members.begin(), loopHierarchy2Members.end(), bb1) ==
+                  loopHierarchy2Members.end()) {
+                allin = false;
+                break;
+              }
+            }
+            if (allin) {
+              CreateInnerLoop(*loopHierarchy1, *loopHierarchy2);
+              innerCreated = true;
+            }
+          }
+          if (innerCreated) {
+            break;
+          }
+        }
+      }
+      if (innerCreated) {
+        break;
+      }
+    }
+  } while (innerCreated);
+
+  for (LoopHierarchy *outer = loops; outer != nullptr; outer = outer->GetNext()) {
+    UpdateOuterLoop(outer);
+  }
+}
+
+static void CopyLoopInfo(const LoopHierarchy *from, CGFuncLoops *to, CGFuncLoops *parent, MemPool *memPool) {
+  to->SetHeader(*const_cast<BB*>(from->GetHeader()));
+  for (auto bb : from->GetOtherLoopEntries()) {
+    to->AddMultiEntries(*bb);
+  }
+  for (auto *bb : from->GetLoopMembers()) {
+    to->AddLoopMembers(*bb);
+    bb->SetLoop(*to);
+  }
+  for (auto *bb : from->GetBackedge()) {
+    to->AddBackedge(*bb);
+  }
+  for (auto &backPair : from->GetBackBBEdges()) {
+    CHECK_FATAL(backPair.first != nullptr, "get invalid backEdge info");
+    CHECK_FATAL(!backPair.second->empty(), "get invalid backEdge info");
+    for (auto headers : *(backPair.second)) {
+      to->AddBackBBEdge(*backPair.first, *headers);
+    }
+  }
+  for (auto *bb : from->GetExits()) {
+    to->AddExit(*bb);
+  }
+  if (!from->GetInnerLoops().empty()) {
+    for (auto *inner : from->GetInnerLoops()) {
+      auto *floop = memPool->New<CGFuncLoops>(*memPool);
+      to->AddInnerLoops(*floop);
+      floop->SetLoopLevel(to->GetLoopLevel() + 1);
+      CopyLoopInfo(inner, floop, to, memPool);
+    }
+  }
+  if (parent != nullptr) {
+    to->SetOuterLoop(*parent);
+  }
+}
+
+void LoopFinder::UpdateCGFunc() const {
+  for (LoopHierarchy *loop = loops; loop != nullptr; loop = loop->GetNext()) {
+    auto *floop = cgFunc->GetMemoryPool()->New<CGFuncLoops>(*cgFunc->GetMemoryPool());
+    cgFunc->PushBackLoops(*floop);
+    floop->SetLoopLevel(1);    /* top level */
+    CopyLoopInfo(loop, floop, nullptr, cgFunc->GetMemoryPool());
+  }
+}
+
+void LoopFinder::FormLoopHierarchy() {
+  visitedBBs.clear();
+  visitedBBs.resize(cgFunc->NumBBs(), false);
+  sortedBBs.clear();
+  sortedBBs.resize(cgFunc->NumBBs(), nullptr);
+  onPathBBs.clear();
+  onPathBBs.resize(cgFunc->NumBBs(), false);
+
+  FOR_ALL_BB(bb, cgFunc) {
+    bb->SetLevel(0);
+  }
+  bool changed;
+  do {
+    changed = false;
+    FOR_ALL_BB(bb, cgFunc) {
+      if (!visitedBBs[bb->GetId()]) {
+        dfsBBs.push(bb);
+        SeekCycles();
+        changed = true;
+      }
+    }
+  } while (changed);
+
+  MarkExtraEntryAndEncl();
+  /*
+   * FIX : Should merge the partial loops at the time of initial
+   * construction.  And make the linked list as a sorted set,
+   * then the merge and sort phases below can go away.
+   *
+   * Start merging the loops with the same header
+   */
+  MergeLoops();
+  /* order loops from least number of members */
+  SortLoops();
+  DetectInnerLoop();
+  UpdateCGFunc();
+}
+
+bool CgLoopAnalysis::PhaseRun(maplebe::CGFunc &f) {
+  f.ClearLoopInfo();
+  MemPool *loopMemPool = GetPhaseMemPool();
+  LoopFinder *loopFinder = loopMemPool->New<LoopFinder>(f, *loopMemPool);
+  loopFinder->FormLoopHierarchy();
+
+  if (LOOP_ANALYSIS_DUMP_NEWPM) {
+    /* do dot gen after detection so the loop backedge can be properly colored using the loop info */
+    DotGenerator::GenerateDot("buildloop", f, f.GetMirModule(), true, f.GetName());
+  }
+#if DEBUG
+  for (const auto *lp : f.GetLoops()) {
+    lp->CheckLoops();
+  }
+#endif
+  return false;
+}
+MAPLE_ANALYSIS_PHASE_REGISTER(CgLoopAnalysis, loopanalysis)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/memlayout.cpp b/src/mapleall/maple_be/src/cg/memlayout.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c242edf32f3460e0090483bde7da582d1e7ada6
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/memlayout.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "memlayout.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+/*
+ * Go over all outgoing calls in the function body and get the maximum space
+ * needed for storing the actuals based on the actual parameters and the ABI.
+ * These are usually those arguments that cannot be passed
+ * through registers because a call passes more than 8 arguments, or
+ * they cannot be fit in a pair of registers.
+
+ * This assumes that all nesting of statements has been removed,
+ * so that all the statements are at only one block level.
+ */
+uint32 MemLayout::FindLargestActualArea(int32 &aggCopySize) {
+  StmtNode *stmt = mirFunction->GetBody()->GetFirst();
+  if (stmt == nullptr) {
+    return 0;
+  }
+  uint32 maxActualSize = 0;
+  uint32 maxParamStackSize = 0;  // Size of parameter stack requirement
+  uint32 maxCopyStackSize = 0;   // Size of aggregate param stack copy requirement
+  for (; stmt != nullptr; stmt = stmt->GetNext()) {
+    Opcode opCode = stmt->GetOpCode();
+    if ((opCode < OP_call || opCode > OP_xintrinsiccallassigned) && opCode != OP_icallproto) {
+      continue;
+    }
+    if (opCode == OP_intrinsiccallwithtypeassigned || opCode == OP_intrinsiccallwithtype ||
+        opCode == OP_intrinsiccallassigned || opCode == OP_intrinsiccall) {
+      /*
+       * Some intrinsics, such as MPL_ATOMIC_EXCHANGE_PTR, are handled by CG,
+       * and map to machine code sequences.  We ignore them because they are not
+       * function calls.
+       */
+      continue;
+    }
+    /*
+     * if the following check fails, most likely dex has invoke-custom etc
+     * that is not supported yet
+     */
+    DCHECK((opCode == OP_call || opCode == OP_icall || opCode == OP_icallproto), "Not lowered to call or icall?");
+    int32 copySize;
+    uint32 size = ComputeStackSpaceRequirementForCall(*stmt, copySize, opCode == OP_icall || opCode == OP_icallproto);
+    if (size > maxParamStackSize) {
+      maxParamStackSize = size;
+    }
+    if (static_cast<uint32>(copySize) > maxCopyStackSize) {
+      maxCopyStackSize = static_cast<uint32>(copySize);
+    }
+    if ((maxParamStackSize + maxCopyStackSize) > maxActualSize) {
+      maxActualSize = maxParamStackSize + maxCopyStackSize;
+    }
+  }
+  aggCopySize = static_cast<int32>(maxCopyStackSize);
+  /* GetPointerSize() * 2's pow 2 is 4, set the low 4 bit of maxActualSize to 0 */
+  if (CGOptions::IsArm64ilp32()) {
+    maxActualSize = RoundUp(maxActualSize, k8ByteSize * 2);
+  } else {
+    maxActualSize = RoundUp(maxActualSize, GetPointerSize() * 2);
+  }
+  return maxActualSize;
+}
+
+bool CgLayoutFrame::PhaseRun(maplebe::CGFunc &f) {
+  if (CGOptions::IsPrintFunction()) {
+    LogInfo::MapleLogger() << f.GetName() << "\n";
+  }
+  f.LayoutStackFrame();
+  return false;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/offset_adjust.cpp b/src/mapleall/maple_be/src/cg/offset_adjust.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed94c8593df9a59d31e13288ff336758134db09e
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/offset_adjust.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "offset_adjust.h"
+#if TARGAARCH64
+#include "aarch64_offset_adjust.h"
+#elif TARGRISCV64
+#include "riscv64_offset_adjust.h"
+#endif
+#if TARGARM32
+#include "arm32_offset_adjust.h"
+#endif
+
+#include "cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+bool CgFrameFinalize::PhaseRun(maplebe::CGFunc &f) {
+  FrameFinalize *offsetAdjustment = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  offsetAdjustment = GetPhaseAllocator()->New<AArch64FPLROffsetAdjustment>(f);
+#endif
+#if TARGARM32
+  offsetAdjustment = GetPhaseAllocator()->New<Arm32FPLROffsetAdjustment>(f);
+#endif
+  offsetAdjustment->Run();
+  return false;
+}
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/operand.cpp b/src/mapleall/maple_be/src/cg/operand.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..35df6e6b82cfd9c8d040f5cd0eea9c1b58ea3a64
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/operand.cpp
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "operand.h"
+#include "common_utils.h"
+#include "mpl_logging.h"
+
+namespace maplebe {
+bool IsMoveWidableImmediate(uint64 val, uint32 bitLen) {
+  if (bitLen == k64BitSize) {
+    /* 0xHHHH000000000000 or 0x0000HHHH00000000, return true */
+    if (((val & ((static_cast<uint64>(0xffff)) << k48BitSize)) == val) ||
+        ((val & ((static_cast<uint64>(0xffff)) << k32BitSize)) == val)) {
+      return true;
+    }
+  } else {
+    /* get lower 32 bits */
+    val &= static_cast<uint64>(0xffffffff);
+  }
+  /* 0x00000000HHHH0000 or 0x000000000000HHHH, return true */
+  return ((val & ((static_cast<uint64>(0xffff)) << k16BitSize)) == val ||
+          (val & ((static_cast<uint64>(0xffff)) << 0)) == val);
+}
+
+bool BetterUseMOVZ(uint64 val) {
+  int32 n16zerosChunks = 0;
+  int32 n16onesChunks = 0;
+  uint64 sa = 0;
+  /* a 64 bits number is split 4 chunks, each chunk has 16 bits. check each chunk whether is all 1 or is all 0 */
+  for (uint64 i = 0; i < k4BitSize; ++i, sa += k16BitSize) {
+    uint64 chunkVal = (val >> (static_cast<uint64>(sa))) & 0x0000FFFFUL;
+    if (chunkVal == 0) {
+      ++n16zerosChunks;
+    } else if (chunkVal == 0xFFFFUL) {
+      ++n16onesChunks;
+    }
+  }
+  /*
+   * note that since we already check if the value
+   * can be movable with as a single mov instruction,
+   * we should not exepct either n_16zeros_chunks>=3 or n_16ones_chunks>=3
+   */
+#if DEBUG
+  constexpr uint32 kN16ChunksCheck = 2;
+  ASSERT(n16zerosChunks <= kN16ChunksCheck, "n16zerosChunks ERR");
+  ASSERT(n16onesChunks <= kN16ChunksCheck, "n16onesChunks ERR");
+#endif
+  return (n16zerosChunks >= n16onesChunks);
+}
+
+bool RegOperand::operator==(const RegOperand &o) const {
+  regno_t myRn = GetRegisterNumber();
+  uint32 mySz = GetSize();
+  uint32 myFl = regFlag;
+  regno_t otherRn = o.GetRegisterNumber();
+  uint32 otherSz = o.GetSize();
+  uint32 otherFl = o.regFlag;
+
+  if (IsPhysicalRegister()) {
+    return (myRn == otherRn && mySz == otherSz && myFl == otherFl);
+  }
+  return (myRn == otherRn && mySz == otherSz);
+}
+
+bool RegOperand::operator<(const RegOperand &o) const {
+  regno_t myRn = GetRegisterNumber();
+  uint32 mySz = GetSize();
+  uint32 myFl = regFlag;
+  regno_t otherRn = o.GetRegisterNumber();
+  uint32 otherSz = o.GetSize();
+  uint32 otherFl = o.regFlag;
+  return myRn < otherRn || (myRn == otherRn && mySz < otherSz) ||
+         (myRn == otherRn && mySz == otherSz && myFl < otherFl);
+}
+
+Operand *MemOperand::GetOffset() const {
+  switch (addrMode) {
+    case kAddrModeBOi:
+      return GetOffsetOperand();
+    case kAddrModeBOrX:
+      return GetIndexRegister();
+    case kAddrModeLiteral:
+      break;
+    case kAddrModeLo12Li:
+      break;
+    default:
+      ASSERT(false, "error memoperand dump");
+      break;
+  }
+  return nullptr;
+}
+
+bool MemOperand::Equals(Operand &op) const {
+  if (!op.IsMemoryAccessOperand()) {
+    return false;
+  }
+  return Equals(static_cast<MemOperand&>(op));
+}
+
+bool MemOperand::Equals(const MemOperand &op) const {
+  if (&op == this) {
+    return true;
+  }
+
+  if (addrMode == op.GetAddrMode()) {
+    switch (addrMode) {
+      case kAddrModeBOi:
+        return (GetBaseRegister()->Equals(*op.GetBaseRegister()) &&
+                GetOffsetImmediate()->Equals(*op.GetOffsetImmediate()));
+      case kAddrModeBOrX:
+        return (GetBaseRegister()->Equals(*op.GetBaseRegister()) &&
+                GetIndexRegister()->Equals(*op.GetIndexRegister()) &&
+                GetExtendAsString() == op.GetExtendAsString() &&
+                ShiftAmount() == op.ShiftAmount());
+      case kAddrModeLiteral:
+        return GetSymbolName() == op.GetSymbolName();
+      case kAddrModeLo12Li:
+        return (GetBaseRegister()->Equals(*op.GetBaseRegister()) &&
+                GetSymbolName() == op.GetSymbolName() &&
+                GetOffsetImmediate()->Equals(*op.GetOffsetImmediate()));
+      default:
+        ASSERT(false, "error memoperand");
+        break;
+    }
+  }
+  return false;
+}
+
+bool MemOperand::Less(const Operand &right) const {
+  if (&right == this) {
+    return false;
+  }
+
+  /* For different type. */
+  if (GetKind() != right.GetKind()) {
+    return GetKind() < right.GetKind();
+  }
+
+  const MemOperand *rightOpnd = static_cast<const MemOperand*>(&right);
+  if (addrMode != rightOpnd->addrMode) {
+    return addrMode < rightOpnd->addrMode;
+  }
+
+  switch (addrMode) {
+    case kAddrModeBOi: {
+      ASSERT(idxOpt == kIntact, "Should not compare pre/post index addressing.");
+
+      RegOperand *baseReg = GetBaseRegister();
+      RegOperand *rbaseReg = rightOpnd->GetBaseRegister();
+      int32 nRet = baseReg->RegCompare(*rbaseReg);
+      if (nRet == 0) {
+        Operand *ofstOpnd = GetOffsetOperand();
+        const Operand *rofstOpnd = rightOpnd->GetOffsetOperand();
+        return ofstOpnd->Less(*rofstOpnd);
+      }
+      return nRet < 0;
+    }
+    case kAddrModeBOrX: {
+      if (noExtend != rightOpnd->noExtend) {
+        return noExtend;
+      }
+      if (!noExtend && extend != rightOpnd->extend) {
+        return extend < rightOpnd->extend;
+      }
+      RegOperand *indexReg = GetIndexRegister();
+      const RegOperand *rindexReg = rightOpnd->GetIndexRegister();
+      return indexReg->Less(*rindexReg);
+    }
+    case kAddrModeLiteral: {
+      return static_cast<const void*>(GetSymbol()) < static_cast<const void*>(rightOpnd->GetSymbol());
+    }
+    case kAddrModeLo12Li: {
+      if (GetSymbol() != rightOpnd->GetSymbol()) {
+        return static_cast<const void*>(GetSymbol()) < static_cast<const void*>(rightOpnd->GetSymbol());
+      }
+      Operand *ofstOpnd = GetOffsetOperand();
+      const Operand *rofstOpnd = rightOpnd->GetOffsetOperand();
+      return ofstOpnd->Less(*rofstOpnd);
+    }
+    default:
+      ASSERT(false, "Internal error.");
+      return false;
+  }
+}
+
+const char *CondOperand::ccStrs[kCcLast] = {
+  "EQ", "NE", "CS", "HS", "CC", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL"
+};
+
+bool CondOperand::Less(const Operand &right) const {
+  if (&right == this) {
+    return false;
+  }
+
+  /* For different type. */
+  if (GetKind() != right.GetKind()) {
+    return GetKind() < right.GetKind();
+  }
+
+  const CondOperand *rightOpnd = static_cast<const CondOperand*>(&right);
+
+  /* The same type. */
+  if (cc == CC_AL || rightOpnd->cc == CC_AL) {
+    return false;
+  }
+  return cc < rightOpnd->cc;
+}
+
+uint32 PhiOperand::GetLeastCommonValidBit() const{
+  uint32 leastCommonVb = 0;
+  for (auto phiOpnd : phiList) {
+    uint32 curVb = phiOpnd.second->GetValidBitsNum();
+    if (curVb > leastCommonVb) {
+      leastCommonVb = curVb;
+    }
+  }
+  return leastCommonVb;
+}
+bool PhiOperand::IsRedundancy() const {
+  uint32 srcSsaIdx = 0;
+  for (auto phiOpnd : phiList) {
+    if (srcSsaIdx == 0) {
+      srcSsaIdx = phiOpnd.second->GetRegisterNumber();
+    }
+    if (srcSsaIdx != phiOpnd.second->GetRegisterNumber()) {
+      return false;
+    }
+  }
+  return true;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/optimize_common.cpp b/src/mapleall/maple_be/src/cg/optimize_common.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eba06363011710ca479156b2a066b56a5b219d55
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/optimize_common.cpp
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "optimize_common.h"
+#include "cgbb.h"
+#include "cg.h"
+#include "cg_option.h"
+#include "loop.h"
+#include "securec.h"
+
+/* This file provides common class and function for cfgo and ico. */
+namespace maplebe {
+void Optimizer::Run(const std::string &funcName, bool checkOnly) {
+  /* Initialize cfg optimization patterns */
+  InitOptimizePatterns();
+
+  /* For each pattern, search cgFunc for optimization */
+  for (OptimizationPattern *p : diffPassPatterns) {
+    p->Search2Op(checkOnly);
+  }
+  /* Search the cgFunc for multiple possible optimizations in one pass */
+  if (!singlePassPatterns.empty()) {
+    BB *curBB = cgFunc->GetFirstBB();
+    bool flag = false;
+    while (curBB != nullptr) {
+      for (OptimizationPattern *p : singlePassPatterns) {
+        if (p->Optimize(*curBB)) {
+          flag = p->IsKeepPosition();
+          p->SetKeepPosition(false);
+          break;
+        }
+      }
+
+      if (flag) {
+        flag = false;
+      } else {
+        curBB = curBB->GetNext();
+      }
+    }
+  }
+
+  if (CGOptions::IsDumpOptimizeCommonLog()) {
+    constexpr int arrSize = 80;
+    char post[arrSize];
+    errno_t cpyRet = strcpy_s(post, arrSize, "post-");
+    CHECK_FATAL(cpyRet == EOK, "call strcpy_s failed");
+    errno_t catRes = strcat_s(post, arrSize, name);
+    CHECK_FATAL(catRes == EOK, "call strcat_s failed ");
+    OptimizeLogger::GetLogger().Print(funcName);
+  }
+  OptimizeLogger::GetLogger().ClearLocal();
+}
+
+void OptimizationPattern::Search2Op(bool noOptimize) {
+  checkOnly = noOptimize;
+  BB *curBB = cgFunc->GetFirstBB();
+  while (curBB != nullptr) {
+    bool changed = false;
+    do {
+      changed = Optimize(*curBB);
+    } while (changed);
+    if (keepPosition) {
+      keepPosition = false;
+    } else {
+      curBB = curBB->GetNext();
+    }
+  }
+}
+
+void OptimizationPattern::Log(uint32 bbID) {
+  OptimizeLogger::GetLogger().Log(patternName.c_str());
+  DotGenerator::SetColor(bbID, dotColor.c_str());
+}
+
+std::map<uint32, std::string> DotGenerator::coloringMap;
+
+void DotGenerator::SetColor(uint32 bbID, const std::string &color) {
+  coloringMap[bbID] = color;
+}
+
+std::string DotGenerator::GetFileName(const MIRModule &mirModule, const std::string &filePreFix) {
+  std::string fileName;
+  if (!filePreFix.empty()) {
+    fileName.append(filePreFix);
+    fileName.append("-");
+  }
+  fileName.append(mirModule.GetFileName());
+  for (uint32 i = 0; i < fileName.length(); i++) {
+    if (fileName[i] == ';' || fileName[i] == '/' || fileName[i] == '|') {
+      fileName[i] = '_';
+    }
+  }
+
+  fileName.append(".dot");
+  return fileName;
+}
+
+static bool IsBackEdgeForLoop(const CGFuncLoops &loop, const BB &from, const BB &to) {
+  const BB *header = loop.GetHeader();
+  if (header->GetId() == to.GetId()) {
+    for (auto *be : loop.GetBackedge()) {
+      if (be->GetId() == from.GetId()) {
+        return true;
+      }
+    }
+  }
+  for (auto *inner : loop.GetInnerLoops()) {
+    if (IsBackEdgeForLoop(*inner, from, to)) {
+      return true;
+    }
+  }
+  return false;
+}
+bool DotGenerator::IsBackEdge(const CGFunc &cgFunction, const BB &from, const BB &to) {
+  for (const auto *loop : cgFunction.GetLoops()) {
+    if (IsBackEdgeForLoop(*loop, from, to)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void DotGenerator::DumpEdge(const CGFunc &cgFunction, std::ofstream &cfgFileOfStream, bool isIncludeEH) {
+  FOR_ALL_BB_CONST(bb, &cgFunction) {
+    for (auto *succBB : bb->GetSuccs()) {
+      cfgFileOfStream << "BB" << bb->GetId();
+      cfgFileOfStream << " -> "
+              << "BB" << succBB->GetId();
+      if (IsBackEdge(cgFunction, *bb, *succBB)) {
+        cfgFileOfStream << " [color=red]";
+      } else {
+        cfgFileOfStream << " [color=green]";
+      }
+      cfgFileOfStream << ";\n";
+    }
+    if (isIncludeEH) {
+      for (auto *ehSuccBB : bb->GetEhSuccs()) {
+        cfgFileOfStream << "BB" << bb->GetId();
+        cfgFileOfStream << " -> "
+                << "BB" << ehSuccBB->GetId();
+        cfgFileOfStream << "[color=red]";
+        cfgFileOfStream << ";\n";
+      }
+    }
+  }
+}
+
+bool DotGenerator::FoundListOpndRegNum(ListOperand &listOpnd, const Insn &insnObj, regno_t vReg) {
+  bool exist = false;
+  for (auto op : listOpnd.GetOperands()) {
+    RegOperand *regOpnd = static_cast<RegOperand*>(op);
+    if (op->IsRegister() && regOpnd->GetRegisterNumber() == vReg) {
+      LogInfo::MapleLogger() << "BB" << insnObj.GetBB()->GetId() << " [style=filled, fillcolor=red];\n";
+      exist = true;
+      break;
+    }
+  }
+  return exist;
+}
+
+bool DotGenerator::FoundMemAccessOpndRegNum(const MemOperand &memOperand, const Insn &insnObj, regno_t vReg) {
+  Operand *base = memOperand.GetBaseRegister();
+  Operand *offset = memOperand.GetIndexRegister();
+  bool exist = false;
+  if (base != nullptr && base->IsRegister()) {
+    RegOperand *regOpnd = static_cast<RegOperand*>(base);
+    if (regOpnd->GetRegisterNumber() == vReg) {
+      LogInfo::MapleLogger() << "BB" << insnObj.GetBB()->GetId() << " [style=filled, fillcolor=red];\n";
+      exist = true;
+    }
+  } else if (offset != nullptr && offset->IsRegister()) {
+    RegOperand *regOpnd = static_cast<RegOperand*>(offset);
+    if (regOpnd->GetRegisterNumber() == vReg) {
+      LogInfo::MapleLogger() << "BB" << insnObj.GetBB()->GetId() << " [style=filled, fillcolor=red];\n";
+      exist = true;
+    }
+  }
+  return exist;
+}
+
+bool DotGenerator::FoundNormalOpndRegNum(const RegOperand &regOpnd, const Insn &insnObj, regno_t vReg) {
+  bool exist = false;
+  if (regOpnd.GetRegisterNumber() == vReg) {
+    LogInfo::MapleLogger() << "BB" << insnObj.GetBB()->GetId() << " [style=filled, fillcolor=red];\n";
+    exist = true;
+  }
+  return exist;
+}
+
+void DotGenerator::DumpBBInstructions(const CGFunc &cgFunction, regno_t vReg, std::ofstream &cfgFile) {
+  FOR_ALL_BB_CONST(bb, &cgFunction) {
+    if (vReg != 0) {
+      FOR_BB_INSNS_CONST(insn, bb) {
+        bool found = false;
+        uint32 opndNum = insn->GetOperandSize();
+        for (uint32 i = 0; i < opndNum; ++i) {
+          Operand &opnd = insn->GetOperand(i);
+          if (opnd.IsList()) {
+            auto &listOpnd = static_cast<ListOperand&>(opnd);
+            found = FoundListOpndRegNum(listOpnd, *insn, vReg);
+          } else if (opnd.IsMemoryAccessOperand()) {
+            auto &memOpnd = static_cast<MemOperand&>(opnd);
+            found = FoundMemAccessOpndRegNum(memOpnd, *insn, vReg);
+          } else {
+            if (opnd.IsRegister()) {
+              auto &regOpnd = static_cast<RegOperand&>(opnd);
+              found = FoundNormalOpndRegNum(regOpnd, *insn, vReg);
+            }
+          }
+          if (found) {
+            break;
+          }
+        }
+        if (found) {
+          break;
+        }
+      }
+    }
+    cfgFile << "BB" << bb->GetId() << "[";
+    auto it = coloringMap.find(bb->GetId());
+    if (it != coloringMap.end()) {
+      cfgFile << "style=filled,fillcolor=" << it->second << ",";
+    }
+    if (bb->GetKind() == BB::kBBIf) {
+      cfgFile << "shape=diamond,label= \" BB" << bb->GetId() << ":\n";
+    } else {
+      cfgFile << "shape=box,label= \" BB" << bb->GetId() << ":\n";
+    }
+    cfgFile << "{ ";
+    cfgFile << bb->GetKindName() << "\n";
+    cfgFile << bb->GetFrequency() << "\n";
+    if (bb->GetLabIdx() != 0) {
+      cfgFile << "LabIdx=" << bb->GetLabIdx() << "\n";
+    }
+    cfgFile << "}\"];\n";
+  }
+}
+
+/* Generate dot file for cfg */
+void DotGenerator::GenerateDot(const std::string &preFix, const CGFunc &cgFunc, const MIRModule &mod,
+                               bool includeEH, const std::string fname, regno_t vReg) {
+  std::ofstream cfgFile;
+  std::streambuf *coutBuf = std::cout.rdbuf(); /* keep original cout buffer */
+  std::streambuf *buf = cfgFile.rdbuf();
+  std::cout.rdbuf(buf);
+  std::string fileName = GetFileName(mod, (preFix + "-" + fname));
+
+  cfgFile.open(fileName, std::ios::trunc);
+  CHECK_FATAL(cfgFile.is_open(), "Failed to open output file: %s", fileName.c_str());
+  cfgFile << "digraph {\n";
+  /* dump edge */
+  DumpEdge(cgFunc, cfgFile, includeEH);
+
+  /* dump instruction in each BB */
+  DumpBBInstructions(cgFunc, vReg, cfgFile);
+
+  cfgFile << "}\n";
+  coloringMap.clear();
+  cfgFile.flush();
+  cfgFile.close();
+  std::cout.rdbuf(coutBuf);
+}
+
+void OptimizeLogger::Print(const std::string &funcName) {
+  if (!localStat.empty()) {
+    LogInfo::MapleLogger() << funcName << '\n';
+    for (const auto &localStatPair : localStat) {
+      LogInfo::MapleLogger() << "Optimized " << localStatPair.first << ":" << localStatPair.second << "\n";
+    }
+
+    ClearLocal();
+    LogInfo::MapleLogger() << "Total:" << '\n';
+    for (const auto &globalStatPair : globalStat) {
+      LogInfo::MapleLogger() << "Optimized " << globalStatPair.first << ":" << globalStatPair.second << "\n";
+    }
+  }
+}
+
+void OptimizeLogger::Log(const std::string &patternName) {
+  auto itemInGlobal = globalStat.find(patternName);
+  if (itemInGlobal != globalStat.end()) {
+    itemInGlobal->second++;
+  } else {
+    (void)globalStat.emplace(std::pair<const std::string, int>(patternName, 1));
+  }
+  auto itemInLocal = localStat.find(patternName);
+  if (itemInLocal != localStat.end()) {
+    itemInLocal->second++;
+  } else {
+    (void)localStat.emplace(std::pair<const std::string, int>(patternName, 1));
+  }
+}
+
+void OptimizeLogger::ClearLocal() {
+  localStat.clear();
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/peep.cpp b/src/mapleall/maple_be/src/cg/peep.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2469d5c3cd14e748b801833387aeec299040edab
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/peep.cpp
@@ -0,0 +1,724 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "peep.h"
+#include "cg.h"
+#include "mpl_logging.h"
+#include "common_utils.h"
+#if TARGAARCH64
+#include "aarch64_peep.h"
+#elif TARGRISCV64
+#include "riscv64_peep.h"
+#elif defined TARGX86_64
+#include "x64_peep.h"
+#endif
+#if TARGARM32
+#include "arm32_peep.h"
+#endif
+
+namespace maplebe {
+#if TARGAARCH64
+bool CGPeepPattern::IsCCRegCrossVersion(Insn &startInsn, Insn &endInsn, const RegOperand &ccReg) const {
+  if (startInsn.GetBB() != endInsn.GetBB()) {
+    return true;
+  }
+  CHECK_FATAL(ssaInfo != nullptr, "must have ssaInfo");
+  CHECK_FATAL(ccReg.IsSSAForm(), "cc reg must be ssa form");
+  for (auto *curInsn = startInsn.GetNext(); curInsn != nullptr && curInsn != &endInsn; curInsn = curInsn->GetNext()) {
+    if (!curInsn->IsMachineInstruction()) {
+      continue;
+    }
+    if (curInsn->IsCall()) {
+      return true;
+    }
+    uint32 opndNum = curInsn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = curInsn->GetOperand(i);
+      if (!opnd.IsRegister()) {
+        continue;
+      }
+      auto &regOpnd = static_cast<RegOperand&>(opnd);
+      if (!curInsn->IsRegDefined(regOpnd.GetRegisterNumber())) {
+        continue;
+      }
+      if (static_cast<RegOperand&>(opnd).IsOfCC()) {
+        VRegVersion *ccVersion = ssaInfo->FindSSAVersion(ccReg.GetRegisterNumber());
+        VRegVersion *curCCVersion = ssaInfo->FindSSAVersion(regOpnd.GetRegisterNumber());
+        CHECK_FATAL(ccVersion != nullptr && curCCVersion != nullptr, "RegVersion must not be null based on ssa");
+        CHECK_FATAL(!ccVersion->IsDeleted() && !curCCVersion->IsDeleted(), "deleted version");
+        if (ccVersion->GetVersionIdx() != curCCVersion->GetVersionIdx()) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+int64 CGPeepPattern::GetLogValueAtBase2(int64 val) const {
+  return (__builtin_popcountll(static_cast<uint64>(val)) == 1) ? (__builtin_ffsll(val) - 1) : -1;
+}
+
+InsnSet CGPeepPattern::GetAllUseInsn(const RegOperand &defReg) const {
+  InsnSet allUseInsn;
+  if ((ssaInfo != nullptr) && defReg.IsSSAForm()) {
+    VRegVersion *defVersion = ssaInfo->FindSSAVersion(defReg.GetRegisterNumber());
+    CHECK_FATAL(defVersion != nullptr, "useVRegVersion must not be null based on ssa");
+    for (auto insnInfo : defVersion->GetAllUseInsns()) {
+      Insn *secondInsn = insnInfo.second->GetInsn();
+      allUseInsn.emplace(secondInsn);
+    }
+  }
+  return allUseInsn;
+}
+
+void CGPeepPattern::DumpAfterPattern(std::vector<Insn*> &prevInsns, const Insn *replacedInsn, const Insn *newInsn) {
+  LogInfo::MapleLogger() << ">>>>>>> In " << GetPatternName() << " : <<<<<<<\n";
+  if (!prevInsns.empty()) {
+    if ((replacedInsn == nullptr) && (newInsn == nullptr)) {
+      LogInfo::MapleLogger() << "======= RemoveInsns : {\n";
+    } else {
+      LogInfo::MapleLogger() << "======= PrevInsns : {\n";
+    }
+    for (auto *prevInsn : prevInsns) {
+      if (prevInsn != nullptr) {
+        LogInfo::MapleLogger() << "[primal form] ";
+        prevInsn->Dump();
+        if (ssaInfo != nullptr) {
+          LogInfo::MapleLogger() << "[ssa form] ";
+          ssaInfo->DumpInsnInSSAForm(*prevInsn);
+        }
+      }
+    }
+    LogInfo::MapleLogger() << "}\n";
+  }
+  if (replacedInsn != nullptr) {
+    LogInfo::MapleLogger() << "======= OldInsn :\n";
+    LogInfo::MapleLogger() << "[primal form] ";
+    replacedInsn->Dump();
+    if (ssaInfo != nullptr) {
+      LogInfo::MapleLogger() << "[ssa form] ";
+      ssaInfo->DumpInsnInSSAForm(*replacedInsn);
+    }
+  }
+  if (newInsn != nullptr) {
+    LogInfo::MapleLogger() << "======= NewInsn :\n";
+    LogInfo::MapleLogger() << "[primal form] ";
+    newInsn->Dump();
+    if (ssaInfo != nullptr) {
+      LogInfo::MapleLogger() << "[ssa form] ";
+      ssaInfo->DumpInsnInSSAForm(*newInsn);
+    }
+  }
+}
+
+/* Check if a regOpnd is live after insn. True if live, otherwise false. */
+bool CGPeepPattern::IfOperandIsLiveAfterInsn(const RegOperand &regOpnd, Insn &insn) {
+  for (Insn *nextInsn = insn.GetNext(); nextInsn != nullptr; nextInsn = nextInsn->GetNext()) {
+    if (!nextInsn->IsMachineInstruction()) {
+      continue;
+    }
+    int32 lastOpndId = static_cast<int32>(nextInsn->GetOperandSize() - 1);
+    for (int32 i = lastOpndId; i >= 0; --i) {
+      Operand &opnd = nextInsn->GetOperand(static_cast<uint32>(i));
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &mem = static_cast<MemOperand&>(opnd);
+        Operand *base = mem.GetBaseRegister();
+        Operand *offset = mem.GetOffset();
+
+        if (base != nullptr && base->IsRegister()) {
+          auto *tmpRegOpnd = static_cast<RegOperand*>(base);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return true;
+          }
+        }
+        if (offset != nullptr && offset->IsRegister()) {
+          auto *tmpRegOpnd = static_cast<RegOperand*>(offset);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return true;
+          }
+        }
+      } else if (opnd.IsList()) {
+        auto &opndList = static_cast<ListOperand&>(opnd).GetOperands();
+        if (find(opndList.begin(), opndList.end(), &regOpnd) != opndList.end()) {
+          return true;
+        }
+      }
+
+      if (!opnd.IsRegister()) {
+        continue;
+      }
+      auto &tmpRegOpnd = static_cast<RegOperand&>(opnd);
+      if (opnd.IsRegister() && tmpRegOpnd.GetRegisterNumber() != regOpnd.GetRegisterNumber()) {
+        continue;
+      }
+      const InsnDesc *md = nextInsn->GetDesc();
+      auto *regProp = (md->opndMD[static_cast<uint64>(i)]);
+      bool isUse = regProp->IsUse();
+      /* if noUse Redefined, no need to check live-out. */
+      return isUse;
+    }
+  }
+  /* Check if it is live-out. */
+  return FindRegLiveOut(regOpnd, *insn.GetBB());
+}
+
+/* entrance for find if a regOpnd is live-out. */
+bool CGPeepPattern::FindRegLiveOut(const RegOperand &regOpnd, const BB &bb) {
+  /*
+   * Each time use peephole, index is initialized by the constructor,
+   * and the internal_flags3 should be cleared.
+   */
+  if (PeepOptimizer::index == 0) {
+    FOR_ALL_BB(currbb, cgFunc) {
+      currbb->SetInternalFlag3(0);
+    }
+  }
+  /* before each invoke check function, increase index. */
+  ++PeepOptimizer::index;
+  return CheckOpndLiveinSuccs(regOpnd, bb);
+}
+
+/* Check regOpnd in succs/ehSuccs. True is live-out, otherwise false. */
+bool CGPeepPattern::CheckOpndLiveinSuccs(const RegOperand &regOpnd, const BB &bb) const {
+  for (auto succ : bb.GetSuccs()) {
+    ASSERT(succ->GetInternalFlag3() <= PeepOptimizer::index, "internal error.");
+    if (succ->GetInternalFlag3() == PeepOptimizer::index)  {
+      continue;
+    }
+    succ->SetInternalFlag3(PeepOptimizer::index);
+    ReturnType result = IsOpndLiveinBB(regOpnd, *succ);
+    if (result == kResNotFind) {
+      if (CheckOpndLiveinSuccs(regOpnd, *succ)) {
+        return true;
+      }
+      continue;
+    } else if (result == kResUseFirst) {
+      return true;
+    } else if (result == kResDefFirst) {
+      continue;
+    }
+  }
+  for (auto ehSucc : bb.GetEhSuccs()) {
+    ASSERT(ehSucc->GetInternalFlag3() <= PeepOptimizer::index, "internal error.");
+    if (ehSucc->GetInternalFlag3() == PeepOptimizer::index) {
+      continue;
+    }
+    ehSucc->SetInternalFlag3(PeepOptimizer::index);
+    ReturnType result = IsOpndLiveinBB(regOpnd, *ehSucc);
+    if (result == kResNotFind) {
+      if (CheckOpndLiveinSuccs(regOpnd, *ehSucc)) {
+        return true;
+      }
+      continue;
+    } else if (result == kResUseFirst) {
+      return true;
+    } else if (result == kResDefFirst) {
+      continue;
+    }
+  }
+  return CheckRegLiveinReturnBB(regOpnd, bb);
+}
+
+/* Check if the reg is used in return BB */
+bool CGPeepPattern::CheckRegLiveinReturnBB(const RegOperand &regOpnd, const BB &bb) const {
+#if TARGAARCH64 || TARGRISCV64
+  if (bb.GetKind() == BB::kBBReturn) {
+    regno_t regNO = regOpnd.GetRegisterNumber();
+    RegType regType = regOpnd.GetRegisterType();
+    if (regType == kRegTyVary) {
+      return false;
+    }
+    PrimType returnType = cgFunc->GetFunction().GetReturnType()->GetPrimType();
+    regno_t returnReg = R0;
+    if (IsPrimitiveFloat(returnType)) {
+      returnReg = V0;
+    } else if (IsPrimitiveInteger(returnType)) {
+      returnReg = R0;
+    }
+    if (regNO == returnReg) {
+      return true;
+    }
+  }
+#endif
+  return false;
+}
+
+/*
+ * Check regNO in current bb:
+ * kResUseFirst:first find use point; kResDefFirst:first find define point;
+ * kResNotFind:cannot find regNO, need to continue searching.
+ */
+ReturnType CGPeepPattern::IsOpndLiveinBB(const RegOperand &regOpnd, const BB &bb) const {
+  FOR_BB_INSNS_CONST(insn, &bb) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    const InsnDesc *md = insn->GetDesc();
+    int32 lastOpndId = static_cast<int32>(insn->GetOperandSize() - 1);
+    for (int32 i = lastOpndId; i >= 0; --i) {
+      Operand &opnd = insn->GetOperand(static_cast<uint32>(i));
+      auto *regProp = (md->opndMD[static_cast<uint64>(i)]);
+      if (opnd.IsConditionCode()) {
+        if (regOpnd.GetRegisterNumber() == kRFLAG) {
+          bool isUse = regProp->IsUse();
+          if (isUse) {
+            return kResUseFirst;
+          }
+          ASSERT(regProp->IsDef(), "register should be redefined.");
+          return kResDefFirst;
+        }
+      } else if (opnd.IsList()) {
+        auto &listOpnd = static_cast<ListOperand&>(opnd);
+        if (insn->GetMachineOpcode() == MOP_asm) {
+          if (static_cast<uint32>(i) == kAsmOutputListOpnd || static_cast<uint32>(i) == kAsmClobberListOpnd) {
+            for (auto op : listOpnd.GetOperands()) {
+              if (op->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+                return kResDefFirst;
+              }
+            }
+            continue;
+          } else if (static_cast<uint32>(i) != kAsmInputListOpnd) {
+            continue;
+          }
+          /* fall thru for kAsmInputListOpnd */
+        }
+        for (auto op : listOpnd.GetOperands()) {
+          if (op->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return kResUseFirst;
+          }
+        }
+      } else if (opnd.IsMemoryAccessOperand()) {
+        auto &mem = static_cast<MemOperand&>(opnd);
+        Operand *base = mem.GetBaseRegister();
+        Operand *offset = mem.GetOffset();
+
+        if (base != nullptr) {
+          ASSERT(base->IsRegister(), "internal error.");
+          auto *tmpRegOpnd = static_cast<RegOperand*>(base);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return kResUseFirst;
+          }
+        }
+        if (offset != nullptr && offset->IsRegister()) {
+          auto *tmpRegOpnd = static_cast<RegOperand*>(offset);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return kResUseFirst;
+          }
+        }
+      } else if (opnd.IsRegister()) {
+        auto &tmpRegOpnd = static_cast<RegOperand&>(opnd);
+        if (tmpRegOpnd.GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+          bool isUse = regProp->IsUse();
+          if (isUse) {
+            return kResUseFirst;
+          }
+          ASSERT(regProp->IsDef(), "register should be redefined.");
+          return kResDefFirst;
+        }
+      }
+    }
+  }
+  return kResNotFind;
+}
+
+int PeepPattern::LogValueAtBase2(int64 val) const {
+  return (__builtin_popcountll(static_cast<uint64>(val)) == 1) ? (__builtin_ffsll(val) - 1) : (-1);
+}
+
+/* Check if a regOpnd is live after insn. True if live, otherwise false. */
+bool PeepPattern::IfOperandIsLiveAfterInsn(const RegOperand &regOpnd, Insn &insn) {
+  for (Insn *nextInsn = insn.GetNext(); nextInsn != nullptr; nextInsn = nextInsn->GetNext()) {
+    if (!nextInsn->IsMachineInstruction()) {
+      continue;
+    }
+    int32 lastOpndId = static_cast<int32>(nextInsn->GetOperandSize() - 1);
+    for (int32 i = lastOpndId; i >= 0; --i) {
+      Operand &opnd = nextInsn->GetOperand(static_cast<uint32>(i));
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &mem = static_cast<MemOperand&>(opnd);
+        Operand *base = mem.GetBaseRegister();
+        Operand *offset = mem.GetOffset();
+
+        if (base != nullptr && base->IsRegister()) {
+          auto *tmpRegOpnd = static_cast<RegOperand*>(base);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return true;
+          }
+        }
+        if (offset != nullptr && offset->IsRegister()) {
+          auto *tmpRegOpnd = static_cast<RegOperand*>(offset);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return true;
+          }
+        }
+      } else if (opnd.IsList()) {
+        auto &opndList = static_cast<ListOperand&>(opnd).GetOperands();
+        if (find(opndList.begin(), opndList.end(), &regOpnd) != opndList.end()) {
+          return true;
+        }
+      }
+
+      if (!opnd.IsRegister()) {
+        continue;
+      }
+      auto &tmpRegOpnd = static_cast<RegOperand&>(opnd);
+      if (opnd.IsRegister() && tmpRegOpnd.GetRegisterNumber() != regOpnd.GetRegisterNumber()) {
+        continue;
+      }
+      const InsnDesc *md = nextInsn->GetDesc();
+      auto *regProp = (md->opndMD[static_cast<uint64>(i)]);
+      bool isUse = regProp->IsUse();
+      /* if noUse Redefined, no need to check live-out. */
+      return isUse;
+    }
+  }
+  /* Check if it is live-out. */
+  return FindRegLiveOut(regOpnd, *insn.GetBB());
+}
+
+/* entrance for find if a regOpnd is live-out. */
+bool PeepPattern::FindRegLiveOut(const RegOperand &regOpnd, const BB &bb) {
+  /*
+   * Each time use peephole, index is initialized by the constructor,
+   * and the internal_flags3 should be cleared.
+   */
+  if (PeepOptimizer::index == 0) {
+    FOR_ALL_BB(currbb, &cgFunc) {
+      currbb->SetInternalFlag3(0);
+    }
+  }
+  /* before each invoke check function, increase index. */
+  ++PeepOptimizer::index;
+  return CheckOpndLiveinSuccs(regOpnd, bb);
+}
+
+/* Check regOpnd in succs/ehSuccs. True is live-out, otherwise false. */
+bool PeepPattern::CheckOpndLiveinSuccs(const RegOperand &regOpnd, const BB &bb) const {
+  for (auto succ : bb.GetSuccs()) {
+    ASSERT(succ->GetInternalFlag3() <= PeepOptimizer::index, "internal error.");
+    if (succ->GetInternalFlag3() == PeepOptimizer::index)  {
+      continue;
+    }
+    succ->SetInternalFlag3(PeepOptimizer::index);
+    ReturnType result = IsOpndLiveinBB(regOpnd, *succ);
+    if (result == kResNotFind) {
+      if (CheckOpndLiveinSuccs(regOpnd, *succ)) {
+        return true;
+      }
+      continue;
+    } else if (result == kResUseFirst) {
+      return true;
+    } else if (result == kResDefFirst) {
+      continue;
+    }
+  }
+  for (auto ehSucc : bb.GetEhSuccs()) {
+    ASSERT(ehSucc->GetInternalFlag3() <= PeepOptimizer::index, "internal error.");
+    if (ehSucc->GetInternalFlag3() == PeepOptimizer::index) {
+      continue;
+    }
+    ehSucc->SetInternalFlag3(PeepOptimizer::index);
+    ReturnType result = IsOpndLiveinBB(regOpnd, *ehSucc);
+    if (result == kResNotFind) {
+      if (CheckOpndLiveinSuccs(regOpnd, *ehSucc)) {
+        return true;
+      }
+      continue;
+    } else if (result == kResUseFirst) {
+      return true;
+    } else if (result == kResDefFirst) {
+      continue;
+    }
+  }
+  return CheckRegLiveinReturnBB(regOpnd, bb);
+}
+
+/* Check if the reg is used in return BB */
+bool PeepPattern::CheckRegLiveinReturnBB(const RegOperand &regOpnd, const BB &bb) const {
+#if TARGAARCH64 || TARGRISCV64
+  if (bb.GetKind() == BB::kBBReturn) {
+    regno_t regNO = regOpnd.GetRegisterNumber();
+    RegType regType = regOpnd.GetRegisterType();
+    if (regType == kRegTyVary) {
+      return false;
+    }
+    PrimType returnType = cgFunc.GetFunction().GetReturnType()->GetPrimType();
+    regno_t returnReg = R0;
+    if (IsPrimitiveFloat(returnType)) {
+        returnReg = V0;
+    } else if (IsPrimitiveInteger(returnType)) {
+        returnReg = R0;
+    }
+    if (regNO == returnReg) {
+      return true;
+    }
+  }
+#endif
+  return false;
+}
+
+/*
+ * Check regNO in current bb:
+ * kResUseFirst:first find use point; kResDefFirst:first find define point;
+ * kResNotFind:cannot find regNO, need to continue searching.
+ */
+ReturnType PeepPattern::IsOpndLiveinBB(const RegOperand &regOpnd, const BB &bb) const {
+  FOR_BB_INSNS_CONST(insn, &bb) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    const InsnDesc *md = insn->GetDesc();
+    int32 lastOpndId = static_cast<int32>(insn->GetOperandSize() - 1);
+    for (int32 i = lastOpndId; i >= 0; --i) {
+      Operand &opnd = insn->GetOperand(static_cast<uint32>(i));
+      auto *regProp = (md->opndMD[static_cast<uint64>(i)]);
+      if (opnd.IsConditionCode()) {
+        if (regOpnd.GetRegisterNumber() == kRFLAG) {
+          bool isUse = regProp->IsUse();
+          if (isUse) {
+            return kResUseFirst;
+          }
+          ASSERT(regProp->IsDef(), "register should be redefined.");
+          return kResDefFirst;
+        }
+      } else if (opnd.IsList()) {
+        auto &listOpnd = static_cast<ListOperand&>(opnd);
+        if (insn->GetMachineOpcode() == MOP_asm) {
+          if (static_cast<uint32>(i) == kAsmOutputListOpnd || static_cast<uint32>(i) == kAsmClobberListOpnd) {
+            for (auto op : listOpnd.GetOperands()) {
+              if (op->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+                return kResDefFirst;
+              }
+            }
+            continue;
+          } else if (static_cast<uint32>(i) != kAsmInputListOpnd) {
+            continue;
+          }
+          /* fall thru for kAsmInputListOpnd */
+        }
+        for (auto op : listOpnd.GetOperands()) {
+          if (op->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return kResUseFirst;
+          }
+        }
+      } else if (opnd.IsMemoryAccessOperand()) {
+        auto &mem = static_cast<MemOperand&>(opnd);
+        Operand *base = mem.GetBaseRegister();
+        Operand *offset = mem.GetOffset();
+
+        if (base != nullptr) {
+          ASSERT(base->IsRegister(), "internal error.");
+          auto *tmpRegOpnd = static_cast<RegOperand*>(base);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return kResUseFirst;
+          }
+        }
+        if (offset != nullptr && offset->IsRegister()) {
+          auto *tmpRegOpnd = static_cast<RegOperand*>(offset);
+          if (tmpRegOpnd->GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+            return kResUseFirst;
+          }
+        }
+      } else if (opnd.IsRegister()) {
+        auto &tmpRegOpnd = static_cast<RegOperand&>(opnd);
+        if (tmpRegOpnd.GetRegisterNumber() == regOpnd.GetRegisterNumber()) {
+          bool isUse = regProp->IsUse();
+          if (isUse) {
+            return kResUseFirst;
+          }
+          ASSERT(regProp->IsDef(), "register should be redefined.");
+          return kResDefFirst;
+        }
+      }
+    }
+  }
+  return kResNotFind;
+}
+
+bool PeepPattern::IsMemOperandOptPattern(const Insn &insn, Insn &nextInsn) {
+  /* Check if base register of nextInsn and the dest operand of insn are identical. */
+  auto *memOpnd = static_cast<MemOperand*>(nextInsn.GetMemOpnd());
+  ASSERT(memOpnd != nullptr, "null ptr check");
+  /* Only for AddrMode_B_OI addressing mode. */
+  if (memOpnd->GetAddrMode() != MemOperand::kAddrModeBOi) {
+    return false;
+  }
+  /* Only for immediate is  0. */
+  if (memOpnd->GetOffsetImmediate()->GetOffsetValue() != 0) {
+    return false;
+  }
+  /* Only for intact memory addressing. */
+  if (!memOpnd->IsIntactIndexed()) {
+    return false;
+  }
+
+  auto &oldBaseOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  /* Check if dest operand of insn is idential with base register of nextInsn. */
+  if (memOpnd->GetBaseRegister() != &oldBaseOpnd) {
+    return false;
+  }
+
+#ifdef USE_32BIT_REF
+  if (nextInsn.IsAccessRefField() && nextInsn.GetOperand(kInsnFirstOpnd).GetSize() > k32BitSize) {
+    return false;
+  }
+#endif
+  /* Check if x0 is used after ldr insn, and if it is in live-out. */
+  if (IfOperandIsLiveAfterInsn(oldBaseOpnd, nextInsn)) {
+    return false;
+  }
+  return true;
+}
+
+template<typename T>
+void PeepOptimizer::Run() {
+  auto *patterMatcher = peepOptMemPool->New<T>(cgFunc, peepOptMemPool);
+  patterMatcher->InitOpts();
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS_SAFE(insn, bb, nextInsn) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      patterMatcher->Run(*bb, *insn);
+    }
+  }
+}
+
+int32 PeepOptimizer::index = 0;
+
+void PeepHoleOptimizer::Peephole0() {
+  auto memPool = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "peepholeOptObj");
+  PeepOptimizer peepOptimizer(*cgFunc, memPool.get());
+#if TARGAARCH64 || TARGRISCV64
+  peepOptimizer.Run<AArch64PeepHole0>();
+#endif
+#if TARGARM32
+  peepOptimizer.Run<Arm32PeepHole0>();
+#endif
+}
+
+void PeepHoleOptimizer::PeepholeOpt() {
+  auto memPool = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "peepholeOptObj");
+  PeepOptimizer peepOptimizer(*cgFunc, memPool.get());
+#if TARGAARCH64 || TARGRISCV64
+  peepOptimizer.Run<AArch64PeepHole>();
+#endif
+#if TARGARM32
+  peepOptimizer.Run<Arm32PeepHole>();
+#endif
+}
+
+void PeepHoleOptimizer::PrePeepholeOpt() {
+  auto memPool = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "peepholeOptObj");
+  PeepOptimizer peepOptimizer(*cgFunc, memPool.get());
+#if TARGAARCH64 || TARGRISCV64
+  peepOptimizer.Run<AArch64PrePeepHole>();
+#endif
+#if TARGARM32
+  peepOptimizer.Run<Arm32PrePeepHole>();
+#endif
+}
+
+void PeepHoleOptimizer::PrePeepholeOpt1() {
+  auto memPool = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "peepholeOptObj");
+  PeepOptimizer peepOptimizer(*cgFunc, memPool.get());
+#if TARGAARCH64 || TARGRISCV64
+  peepOptimizer.Run<AArch64PrePeepHole1>();
+#endif
+#if TARGARM32
+  peepOptimizer.Run<Arm32PrePeepHole1>();
+#endif
+}
+
+/* === SSA form === */
+bool CgPeepHole::PhaseRun(maplebe::CGFunc &f) {
+  CGSSAInfo *cgssaInfo = GET_ANALYSIS(CgSSAConstruct, f);
+  CHECK_FATAL((cgssaInfo != nullptr), "Get ssaInfo failed!");
+  MemPool *mp = GetPhaseMemPool();
+  auto *cgpeep = mp->New<AArch64CGPeepHole>(f, mp, cgssaInfo);
+  CHECK_FATAL((cgpeep != nullptr), "Creat AArch64CGPeepHole failed!");
+  cgpeep->Run();
+  return false;
+}
+
+void CgPeepHole::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<CgSSAConstruct>();
+  aDep.AddPreserved<CgSSAConstruct>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPeepHole, cgpeephole)
+#endif
+/* === Physical Pre Form === */
+bool CgPrePeepHole::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *mp = GetPhaseMemPool();
+  #if defined TARGAARCH64
+  auto *cgpeep = mp->New<AArch64CGPeepHole>(f, mp);
+  #elif defined TARGX86_64
+  auto *cgpeep = mp->New<X64CGPeepHole>(f, mp);
+  #endif
+  CHECK_FATAL(cgpeep != nullptr, "PeepHoleOptimizer instance create failure");
+  cgpeep->Run();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPrePeepHole, cgprepeephole)
+
+/* === Physical Post Form === */
+bool CgPostPeepHole::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *mp = GetPhaseMemPool();
+  #if defined TARGAARCH64
+  auto *cgpeep = mp->New<AArch64CGPeepHole>(f, mp);
+  #elif defined TARGX86_64
+  auto *cgpeep = mp->New<X64CGPeepHole>(f, mp);
+  #endif
+  CHECK_FATAL(cgpeep != nullptr, "PeepHoleOptimizer instance create failure");
+  cgpeep->Run();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPostPeepHole, cgpostpeephole)
+
+#if TARGAARCH64
+bool CgPrePeepHole0::PhaseRun(maplebe::CGFunc &f) {
+  auto *peep = GetPhaseMemPool()->New<PeepHoleOptimizer>(&f);
+  CHECK_FATAL(peep != nullptr, "PeepHoleOptimizer instance create failure");
+  peep->PrePeepholeOpt();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPrePeepHole0, prepeephole)
+
+bool CgPrePeepHole1::PhaseRun(maplebe::CGFunc &f) {
+  auto *peep = GetPhaseMemPool()->New<PeepHoleOptimizer>(&f);
+  CHECK_FATAL(peep != nullptr, "PeepHoleOptimizer instance create failure");
+  peep->PrePeepholeOpt1();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPrePeepHole1, prepeephole1)
+
+bool CgPeepHole0::PhaseRun(maplebe::CGFunc &f) {
+  auto *peep = GetPhaseMemPool()->New<PeepHoleOptimizer>(&f);
+  CHECK_FATAL(peep != nullptr, "PeepHoleOptimizer instance create failure");
+  peep->Peephole0();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPeepHole0, peephole0)
+
+bool CgPeepHole1::PhaseRun(maplebe::CGFunc &f) {
+  auto *peep = GetPhaseMemPool()->New<PeepHoleOptimizer>(&f);
+  CHECK_FATAL(peep != nullptr, "PeepHoleOptimizer instance create failure");
+  peep->PeepholeOpt();
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPeepHole1, peephole)
+#endif
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/pressure.cpp b/src/mapleall/maple_be/src/cg/pressure.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..65369ba5707882185658aad3d6f7271b80210807
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/pressure.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "pressure.h"
+#if TARGAARCH64
+#include "aarch64_schedule.h"
+#elif TARGRISCV64
+#include "riscv64_schedule.h"
+#endif
+#include "deps.h"
+
+namespace maplebe {
+/* ------- RegPressure function -------- */
+int32 RegPressure::maxRegClassNum = 0;
+
+/* print regpressure information */
+void RegPressure::DumpRegPressure() const {
+  PRINT_STR_VAL("Priority: ", priority);
+  PRINT_STR_VAL("maxDepth: ", maxDepth);
+  PRINT_STR_VAL("near: ", near);
+  PRINT_STR_VAL("callNum: ", callNum);
+
+  LogInfo::MapleLogger() << "\n";
+}
+} /* namespace maplebe */
+
diff --git a/src/mapleall/maple_be/src/cg/proepilog.cpp b/src/mapleall/maple_be/src/cg/proepilog.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53e392d7e1bd30f7c03c120713f19f8944b2d10e
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/proepilog.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "proepilog.h"
+#if TARGAARCH64
+#include "aarch64_proepilog.h"
+#elif TARGRISCV64
+#include "riscv64_proepilog.h"
+#endif
+#if TARGARM32
+#include "arm32_proepilog.h"
+#endif
+#if TARGX86_64
+#include "x64_proepilog.h"
+#endif
+#include "cgfunc.h"
+#include "cg.h"
+
+namespace maplebe {
+using namespace maple;
+
+bool CgGenProEpiLog::PhaseRun(maplebe::CGFunc &f) {
+  GenProEpilog *genPE = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  genPE = GetPhaseAllocator()->New<AArch64GenProEpilog>(f, *ApplyTempMemPool());
+#endif
+#if TARGARM32
+  genPE = GetPhaseAllocator()->New<Arm32GenProEpilog>(f);
+#endif
+#if TARGX86_64
+  genPE = GetPhaseAllocator()->New<X64GenProEpilog>(f);
+#endif
+  genPE->Run();
+  return false;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/ra_opt.cpp b/src/mapleall/maple_be/src/cg/ra_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..72af928e06ef62b83b6e0ea3c00bf14dfb09e5d1
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/ra_opt.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "cgfunc.h"
+#if TARGAARCH64
+#include "aarch64_ra_opt.h"
+#elif TARGRISCV64
+#include "riscv64_ra_opt.h"
+#endif
+
+namespace maplebe {
+using namespace maple;
+
+bool CgRaOpt::PhaseRun(maplebe::CGFunc &f) {
+  MemPool *memPool = GetPhaseMemPool();
+  RaOpt *raOpt = nullptr;
+#if TARGAARCH64
+  raOpt = memPool->New<AArch64RaOpt>(f, *memPool);
+#elif || TARGRISCV64
+  raOpt = memPool->New<Riscv64RaOpt>(f, *memPool);
+#endif
+
+  if (raOpt) {
+    LiveAnalysis *live = GET_ANALYSIS(CgLiveAnalysis, f);
+    live->ResetLiveSet();
+    MaplePhase *phase = GetAnalysisInfoHook()->
+        ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgDomAnalysis::id, f);
+    DomAnalysis *dom = static_cast<CgDomAnalysis*>(phase)->GetResult();
+    raOpt->SetDomInfo(dom);
+    raOpt->Run();
+    /* the live range info may changed, so invalid the info. */
+    if (live != nullptr) {
+      live->ClearInOutDataInfo();
+    }
+  }
+  return false;
+}
+void CgRaOpt::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.PreservedAllExcept<CgLiveAnalysis>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgRaOpt, raopt)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/reaching.cpp b/src/mapleall/maple_be/src/cg/reaching.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a2797a8aa835db48afb9355246110c8b9c2382a1
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/reaching.cpp
@@ -0,0 +1,1464 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#if TARGAARCH64
+#include "aarch64_reaching.h"
+#include "aarch64_isa.h"
+#elif TARGRISCV64
+#include "riscv64_reaching.h"
+#endif
+#if TARGARM32
+#include "arm32_reaching.h"
+#endif
+#include "cg_option.h"
+#include "cgfunc.h"
+#include "cg.h"
+
+/*
+ * This phase build bb->in and bb->out infomation for stack memOperand and RegOperand. each bit in DataInfo
+ * represent whether the register or memory is live or not. to save storage space, the offset of stack is divided
+ * by 4, since the offset is a multiple 4.
+ * this algorithm mainly include 2 parts:
+ *   1. initialize each BB
+ *     (1) insert pseudoInsns for function parameters, ehBB, and return R0/V0
+ *     (2) init bb->gen, bb->use, bb->out
+ *   2. build in and out
+ *     (1) In[BB] = Union all of out[Parents(bb)]
+ *     (2) Out[BB] = gen[BB] union in[BB]
+ * aditionally, this phase provide several commen funcfion about data flow. users can call these functions in
+ * optimization phase conveniently.
+ */
+namespace maplebe {
+ReachingDefinition::ReachingDefinition(CGFunc &func, MemPool &memPool)
+    : AnalysisResult(&memPool), cgFunc(&func), rdAlloc(&memPool), stackMp(func.GetStackMemPool()),
+      pseudoInsns(rdAlloc.Adapter()), kMaxBBNum(cgFunc->NumBBs() + 1), normalBBSet(rdAlloc.Adapter()),
+      cleanUpBBSet(rdAlloc.Adapter()) {}
+
+/* check whether the opnd is stack register or not */
+bool ReachingDefinition::IsFrameReg(const Operand &opnd) const {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  auto &reg = static_cast<const RegOperand&>(opnd);
+  return cgFunc->IsFrameReg(reg);
+}
+
+/* intialize bb->out, bb->out only include generated DataInfo */
+void ReachingDefinition::InitOut(const BB &bb) {
+  if ((mode & kRDRegAnalysis) != 0) {
+    *regOut[bb.GetId()] = *regGen[bb.GetId()];
+  }
+  if ((mode & kRDMemAnalysis) != 0) {
+    *memOut[bb.GetId()] = *memGen[bb.GetId()];
+  }
+}
+
+/* when DataInfo will not be used later, they should be cleared. */
+void ReachingDefinition::ClearDefUseInfo() {
+  for (auto insn : pseudoInsns) {
+    /* Keep return pseudo to extend the return register liveness to 'ret'.
+     * Backward propagation can move the return register definition far from the return.
+     */
+#ifndef TARGX86_64
+    if (insn->GetMachineOpcode() == MOP_pseudo_ret_int || insn->GetMachineOpcode() == MOP_pseudo_ret_float) {
+      continue;
+    }
+#endif
+    insn->GetBB()->RemoveInsn(*insn);
+  }
+  FOR_ALL_BB(bb, cgFunc) {
+    delete (regGen[bb->GetId()]);
+    regGen[bb->GetId()] = nullptr;
+    delete (regUse[bb->GetId()]);
+    regUse[bb->GetId()] = nullptr;
+    delete (regIn[bb->GetId()]);
+    regIn[bb->GetId()] = nullptr;
+    delete (regOut[bb->GetId()]);
+    regOut[bb->GetId()] = nullptr;
+    delete (memGen[bb->GetId()]);
+    memGen[bb->GetId()] = nullptr;
+    delete (memUse[bb->GetId()]);
+    memUse[bb->GetId()] = nullptr;
+    delete (memIn[bb->GetId()]);
+    memIn[bb->GetId()] = nullptr;
+    delete (memOut[bb->GetId()]);
+    memOut[bb->GetId()] = nullptr;
+  }
+  regGen.clear();
+  regGen.shrink_to_fit();
+  regUse.clear();
+  regUse.shrink_to_fit();
+  regIn.clear();
+  regIn.shrink_to_fit();
+  regOut.clear();
+  regOut.shrink_to_fit();
+  memGen.clear();
+  memGen.shrink_to_fit();
+  memUse.clear();
+  memUse.shrink_to_fit();
+  memIn.clear();
+  memIn.shrink_to_fit();
+  memOut.clear();
+  memOut.shrink_to_fit();
+  cgFunc->SetRD(nullptr);
+}
+
+/*
+ * find used insns for register.
+ *  input:
+ *    insn: the insn in which register is defined
+ *    regNO: the No of register
+ *    isRegNO: this argument is used to form function overloading
+ *  return:
+ *    the set of used insns for register
+ */
+InsnSet ReachingDefinition::FindUseForRegOpnd(Insn &insn, uint32 indexOrRegNO, bool isRegNO) const {
+  InsnSet useInsnSet;
+  uint32 regNO = indexOrRegNO;
+  if (!isRegNO) {
+    Operand &opnd = insn.GetOperand(indexOrRegNO);
+    auto &regOpnd = static_cast<RegOperand&>(opnd);
+    regNO = regOpnd.GetRegisterNumber();
+  }
+  /* register may be redefined in current bb */
+  bool findFinish = FindRegUseBetweenInsn(regNO, insn.GetNext(), insn.GetBB()->GetLastInsn(), useInsnSet);
+  std::vector<bool> visitedBB(kMaxBBNum, false);
+  if (findFinish || !regOut[insn.GetBB()->GetId()]->TestBit(regNO)) {
+    if (!insn.GetBB()->GetEhSuccs().empty()) {
+      DFSFindUseForRegOpnd(*insn.GetBB(), regNO, visitedBB, useInsnSet, true);
+    }
+  } else {
+    DFSFindUseForRegOpnd(*insn.GetBB(), regNO, visitedBB, useInsnSet, false);
+  }
+
+  if (!insn.GetBB()->IsCleanup() && firstCleanUpBB != nullptr) {
+    if (regUse[firstCleanUpBB->GetId()]->TestBit(regNO)) {
+      findFinish = FindRegUseBetweenInsn(regNO, firstCleanUpBB->GetFirstInsn(),
+                                         firstCleanUpBB->GetLastInsn(), useInsnSet);
+      if (findFinish || !regOut[firstCleanUpBB->GetId()]->TestBit(regNO)) {
+        return useInsnSet;
+      }
+    }
+    DFSFindUseForRegOpnd(*firstCleanUpBB, regNO, visitedBB, useInsnSet, false);
+  }
+
+  return useInsnSet;
+}
+
+/*
+ * find used insns for register iteratively.
+ *  input:
+ *    startBB: find used insns starting from startBB
+ *    regNO: the No of register to be find
+ *    visitedBB: record these visited BB
+ *    useInsnSet: used insns of register is saved in this set
+ */
+void ReachingDefinition::DFSFindUseForRegOpnd(const BB &startBB, uint32 regNO, std::vector<bool> &visitedBB,
+                                              InsnSet &useInsnSet, bool onlyFindForEhSucc = false) const {
+  if (!onlyFindForEhSucc) {
+    for (auto succBB : startBB.GetSuccs()) {
+      if (!regIn[succBB->GetId()]->TestBit(regNO)) {
+        continue;
+      }
+      if (visitedBB[succBB->GetId()]) {
+        continue;
+      }
+      visitedBB[succBB->GetId()] = true;
+      bool findFinish = false;
+      if (regUse[succBB->GetId()]->TestBit(regNO)) {
+        findFinish = FindRegUseBetweenInsn(regNO, succBB->GetFirstInsn(), succBB->GetLastInsn(), useInsnSet);
+      } else if (regGen[succBB->GetId()]->TestBit(regNO)) {
+        findFinish = true;
+      }
+      if (!findFinish && regOut[succBB->GetId()]->TestBit(regNO)) {
+        DFSFindUseForRegOpnd(*succBB, regNO, visitedBB, useInsnSet, false);
+      }
+    }
+  }
+
+  for (auto ehSuccBB : startBB.GetEhSuccs()) {
+    if (!regIn[ehSuccBB->GetId()]->TestBit(regNO)) {
+      continue;
+    }
+    if (visitedBB[ehSuccBB->GetId()]) {
+      continue;
+    }
+    visitedBB[ehSuccBB->GetId()] = true;
+
+    bool findFinish = false;
+    if (regUse[ehSuccBB->GetId()]->TestBit(regNO)) {
+      findFinish = FindRegUseBetweenInsn(regNO, ehSuccBB->GetFirstInsn(), ehSuccBB->GetLastInsn(), useInsnSet);
+    } else if (regGen[ehSuccBB->GetId()]->TestBit(regNO)) {
+      findFinish = true;
+    }
+    if (!findFinish && regOut[ehSuccBB->GetId()]->TestBit(regNO)) {
+      DFSFindUseForRegOpnd(*ehSuccBB, regNO, visitedBB, useInsnSet, false);
+    }
+  }
+}
+
+/* check whether register defined in regDefInsn has used insns */
+bool ReachingDefinition::RegHasUsePoint(uint32 regNO, Insn &regDefInsn) const {
+  InsnSet useInsnSet;
+  bool findFinish = FindRegUseBetweenInsn(regNO, regDefInsn.GetNext(), regDefInsn.GetBB()->GetLastInsn(), useInsnSet);
+  if (!useInsnSet.empty()) {
+    return true;
+  }
+  if (!findFinish) {
+    std::vector<bool> visitedBB(kMaxBBNum, false);
+    return RegIsUsedInOtherBB(*regDefInsn.GetBB(), regNO, visitedBB);
+  }
+  return false;
+}
+
+/* check whether register is used in other BB except startBB */
+bool ReachingDefinition::RegIsUsedInOtherBB(const BB &startBB, uint32 regNO, std::vector<bool> &visitedBB) const {
+  InsnSet useInsnSet;
+  for (auto succBB : startBB.GetSuccs()) {
+    if (!regIn[succBB->GetId()]->TestBit(regNO)) {
+      continue;
+    }
+    if (visitedBB[succBB->GetId()]) {
+      continue;
+    }
+    visitedBB[succBB->GetId()] = true;
+    bool findFinish = false;
+    if (regUse[succBB->GetId()]->TestBit(regNO)) {
+      if (!regGen[succBB->GetId()]->TestBit(regNO)) {
+        return true;
+      }
+      useInsnSet.clear();
+      findFinish = FindRegUseBetweenInsn(regNO, succBB->GetFirstInsn(), succBB->GetLastInsn(), useInsnSet);
+      if (!useInsnSet.empty()) {
+        return true;
+      }
+    } else if (regGen[succBB->GetId()]->TestBit(regNO)) {
+      findFinish = true;
+    }
+    if (!findFinish && regOut[succBB->GetId()]->TestBit(regNO)) {
+      if (RegIsUsedInOtherBB(*succBB, regNO, visitedBB)) {
+        return true;
+      }
+    }
+  }
+
+  for (auto ehSuccBB : startBB.GetEhSuccs()) {
+    if (!regIn[ehSuccBB->GetId()]->TestBit(regNO)) {
+      continue;
+    }
+    if (visitedBB[ehSuccBB->GetId()]) {
+      continue;
+    }
+    visitedBB[ehSuccBB->GetId()] = true;
+
+    bool findFinish = false;
+    if (regUse[ehSuccBB->GetId()]->TestBit(regNO)) {
+      if (!regGen[ehSuccBB->GetId()]->TestBit(regNO)) {
+        return true;
+      }
+      useInsnSet.clear();
+      findFinish = FindRegUseBetweenInsn(regNO, ehSuccBB->GetFirstInsn(), ehSuccBB->GetLastInsn(), useInsnSet);
+      if (!useInsnSet.empty()) {
+        return true;
+      }
+    } else if (regGen[ehSuccBB->GetId()]->TestBit(regNO)) {
+      findFinish = true;
+    }
+    if (!findFinish && regOut[ehSuccBB->GetId()]->TestBit(regNO)) {
+      if (RegIsUsedInOtherBB(*ehSuccBB, regNO, visitedBB)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+bool ReachingDefinition::RegIsUsedInCleanUpBB(uint32 regNO) const {
+  if (firstCleanUpBB == nullptr) {
+    return false;
+  }
+  InsnSet useInsnSet;
+  if (regUse[firstCleanUpBB->GetId()]->TestBit(regNO)) {
+    bool findFinish = FindRegUseBetweenInsn(regNO, firstCleanUpBB->GetFirstInsn(),
+                                            firstCleanUpBB->GetLastInsn(), useInsnSet);
+    if (!useInsnSet.empty()) {
+      return true;
+    }
+    if (findFinish) {
+      return false;
+    }
+  }
+
+  std::vector<bool> visitedBB(kMaxBBNum, false);
+  DFSFindUseForRegOpnd(*firstCleanUpBB, regNO, visitedBB, useInsnSet, false);
+  if (useInsnSet.empty()) {
+    return true;
+  }
+
+  return false;
+}
+
+/*
+ * find used insns for stack memory operand iteratively.
+ *  input:
+ *    startBB: find used insns starting from startBB
+ *    offset: the offset of memory to be find
+ *    visitedBB: record these visited BB
+ *    useInsnSet: used insns of stack memory operand is saved in this set
+ */
+void ReachingDefinition::DFSFindUseForMemOpnd(const BB &startBB, uint32 offset, std::vector<bool> &visitedBB,
+                                              InsnSet &useInsnSet, bool onlyFindForEhSucc = false) const {
+  if (!onlyFindForEhSucc) {
+    for (auto succBB : startBB.GetSuccs()) {
+      if (!memIn[succBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+        continue;
+      }
+      if (visitedBB[succBB->GetId()]) {
+        continue;
+      }
+      visitedBB[succBB->GetId()] = true;
+      bool findFinish = false;
+      if (memUse[succBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+        findFinish = FindMemUseBetweenInsn(offset, succBB->GetFirstInsn(), succBB->GetLastInsn(), useInsnSet);
+      } else if (memGen[succBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+        findFinish = true;
+      }
+      if (!findFinish && memOut[succBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+        DFSFindUseForMemOpnd(*succBB, offset, visitedBB, useInsnSet);
+      }
+    }
+  }
+
+  for (auto ehSuccBB : startBB.GetEhSuccs()) {
+    if (!memIn[ehSuccBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+      continue;
+    }
+    if (visitedBB[ehSuccBB->GetId()]) {
+      continue;
+    }
+    visitedBB[ehSuccBB->GetId()] = true;
+    bool findFinish = false;
+    if (memUse[ehSuccBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+      findFinish = FindMemUseBetweenInsn(offset, ehSuccBB->GetFirstInsn(), ehSuccBB->GetLastInsn(), useInsnSet);
+    } else if (memGen[ehSuccBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+      findFinish = true;
+    }
+    if (!findFinish && memOut[ehSuccBB->GetId()]->TestBit(offset / kMemZoomSize)) {
+      DFSFindUseForMemOpnd(*ehSuccBB, offset, visitedBB, useInsnSet);
+    }
+  }
+}
+
+/* Out[BB] = gen[BB] union in[BB]. if bb->out changed, return true. */
+bool ReachingDefinition::GenerateOut(const BB &bb) {
+  bool outInfoChanged = false;
+  if ((mode & kRDRegAnalysis) != 0) {
+    LocalMapleAllocator alloc(stackMp);
+    DataInfo &bbRegOutBak = regOut[bb.GetId()]->Clone(alloc);
+    *regOut[bb.GetId()] = *(regIn[bb.GetId()]);
+    regOut[bb.GetId()]->OrBits(*regGen[bb.GetId()]);
+    if (!regOut[bb.GetId()]->IsEqual(bbRegOutBak)) {
+      outInfoChanged = true;
+    }
+  }
+
+  if ((mode & kRDMemAnalysis) != 0) {
+    LocalMapleAllocator alloc(stackMp);
+    DataInfo &bbMemOutBak = memOut[bb.GetId()]->Clone(alloc);
+    *memOut[bb.GetId()] = *memIn[bb.GetId()];
+    memOut[bb.GetId()]->OrBits(*memGen[bb.GetId()]);
+    if (!memOut[bb.GetId()]->IsEqual(bbMemOutBak)) {
+      outInfoChanged = true;
+    }
+  }
+  return outInfoChanged;
+}
+
+bool ReachingDefinition::GenerateOut(const BB &bb, const std::set<uint32> &infoIndex, const bool isReg) {
+  bool outInfoChanged = false;
+  if (isReg) {
+    for (auto index : infoIndex) {
+      uint64 bbRegOutBak = regOut[bb.GetId()]->GetElem(index);
+      regOut[bb.GetId()]->SetElem(index, regIn[bb.GetId()]->GetElem(index));
+      regOut[bb.GetId()]->OrDesignateBits(*regGen[bb.GetId()], index);
+      if (!outInfoChanged && (bbRegOutBak != regOut[bb.GetId()]->GetElem(index))) {
+        outInfoChanged = true;
+      }
+    }
+  } else {
+    for (auto index : infoIndex) {
+      uint64 bbMemOutBak = memOut[bb.GetId()]->GetElem(index);
+      memOut[bb.GetId()]->SetElem(index, memIn[bb.GetId()]->GetElem(index));
+      memOut[bb.GetId()]->OrDesignateBits(*memGen[bb.GetId()], index);
+      if (bbMemOutBak != memOut[bb.GetId()]->GetElem(index)) {
+        outInfoChanged = true;
+      }
+    }
+  }
+  return outInfoChanged;
+}
+
+
+/* In[BB] = Union all of out[Parents(bb)]. return true if bb->in changed. */
+bool ReachingDefinition::GenerateIn(const BB &bb) {
+  bool inInfoChanged = false;
+  if ((mode & kRDRegAnalysis) != 0) {
+    LocalMapleAllocator alloc(stackMp);
+    DataInfo &bbRegInBak = regIn[bb.GetId()]->Clone(alloc);
+    for (auto predBB : bb.GetPreds()) {
+      regIn[bb.GetId()]->OrBits(*regOut[predBB->GetId()]);
+    }
+    for (auto predEhBB : bb.GetEhPreds()) {
+      regIn[bb.GetId()]->OrBits(*regOut[predEhBB->GetId()]);
+    }
+
+    if (!regIn[bb.GetId()]->IsEqual(bbRegInBak)) {
+      inInfoChanged = true;
+    }
+  }
+  if ((mode & kRDMemAnalysis) != 0) {
+    LocalMapleAllocator alloc(stackMp);
+    DataInfo &memInBak = memIn[bb.GetId()]->Clone(alloc);
+    for (auto predBB : bb.GetPreds()) {
+      memIn[bb.GetId()]->OrBits(*memOut[predBB->GetId()]);
+    }
+    for (auto predEhBB : bb.GetEhPreds()) {
+      memIn[bb.GetId()]->OrBits(*memOut[predEhBB->GetId()]);
+    }
+
+    if (!memIn[bb.GetId()]->IsEqual(memInBak)) {
+      inInfoChanged = true;
+    }
+  }
+  return inInfoChanged;
+}
+
+/* In[BB] = Union all of out[Parents(bb)]. return true if bb->in changed. */
+bool ReachingDefinition::GenerateIn(const BB &bb, const std::set<uint32> &infoIndex, const bool isReg) {
+  bool inInfoChanged = false;
+
+  if (isReg) {
+    for (auto index : infoIndex) {
+      uint64 bbRegInBak = regIn[bb.GetId()]->GetElem(index);
+      regIn[bb.GetId()]->SetElem(index, 0ULL);
+      for (auto predBB : bb.GetPreds()) {
+        regIn[bb.GetId()]->OrDesignateBits(*regOut[predBB->GetId()], index);
+      }
+      for (auto predEhBB : bb.GetEhPreds()) {
+        regIn[bb.GetId()]->OrDesignateBits(*regOut[predEhBB->GetId()], index);
+      }
+
+      if (bbRegInBak != regIn[bb.GetId()]->GetElem(index)) {
+        inInfoChanged = true;
+      }
+    }
+  } else {
+    for (auto index : infoIndex) {
+      uint64 bbMemInBak = memIn[bb.GetId()]->GetElem(index);
+      memIn[bb.GetId()]->SetElem(index, 0ULL);
+      for (auto predBB : bb.GetPreds()) {
+        memIn[bb.GetId()]->OrDesignateBits(*memOut[predBB->GetId()], index);
+      }
+      for (auto predEhBB : bb.GetEhPreds()) {
+        memIn[bb.GetId()]->OrDesignateBits(*memOut[predEhBB->GetId()], index);
+      }
+
+      if (bbMemInBak != memIn[bb.GetId()]->GetElem(index)) {
+        inInfoChanged = true;
+      }
+    }
+  }
+  return inInfoChanged;
+}
+
+
+/* In[firstCleanUpBB] = Union all of out[bbNormalSet] */
+bool ReachingDefinition::GenerateInForFirstCleanUpBB() {
+  CHECK_NULL_FATAL(firstCleanUpBB);
+  if ((mode & kRDRegAnalysis) != 0) {
+    regIn[firstCleanUpBB->GetId()]->ResetAllBit();
+  }
+  if ((mode & kRDMemAnalysis) != 0) {
+    memIn[firstCleanUpBB->GetId()]->ResetAllBit();
+  }
+
+  for (auto normalBB : normalBBSet) {
+    if ((mode & kRDRegAnalysis) != 0) {
+      regIn[firstCleanUpBB->GetId()]->OrBits(*regOut[normalBB->GetId()]);
+    }
+
+    if ((mode & kRDMemAnalysis) != 0) {
+      memIn[firstCleanUpBB->GetId()]->OrBits(*memOut[normalBB->GetId()]);
+    }
+  }
+
+  return ((regIn[firstCleanUpBB->GetId()] != nullptr && regIn[firstCleanUpBB->GetId()]->Size() > 0) ||
+          (memIn[firstCleanUpBB->GetId()] != nullptr && memIn[firstCleanUpBB->GetId()]->Size() > 0));
+}
+
+bool ReachingDefinition::GenerateInForFirstCleanUpBB(bool isReg, const std::set<uint32> &infoIndex) {
+  CHECK_NULL_FATAL(firstCleanUpBB);
+  bool inInfoChanged = false;
+  if (isReg) {
+    for (auto index : infoIndex) {
+      uint64 regInElemBak = regIn[firstCleanUpBB->GetId()]->GetElem(index);
+      regIn[firstCleanUpBB->GetId()]->SetElem(index, 0ULL);
+      for (auto &normalBB : normalBBSet) {
+        regIn[firstCleanUpBB->GetId()]->OrDesignateBits(*regOut[normalBB->GetId()], index);
+      }
+      if (!inInfoChanged && (regIn[firstCleanUpBB->GetId()]->GetElem(index) != regInElemBak)) {
+        inInfoChanged = true;
+      }
+    }
+  } else {
+    for (auto index : infoIndex) {
+      uint64 memInElemBak = memIn[firstCleanUpBB->GetId()]->GetElem(index);
+      memIn[firstCleanUpBB->GetId()]->SetElem(index, 0ULL);
+      for (auto &normalBB : normalBBSet) {
+        memIn[firstCleanUpBB->GetId()]->OrDesignateBits(*memOut[normalBB->GetId()], index);
+      }
+      if (!inInfoChanged && (memIn[firstCleanUpBB->GetId()]->GetElem(index) != memInElemBak)) {
+        inInfoChanged = true;
+      }
+    }
+  }
+  return inInfoChanged;
+}
+
+/* allocate memory for DataInfo of bb */
+void ReachingDefinition::InitRegAndMemInfo(const BB &bb) {
+  if ((mode & kRDRegAnalysis) != 0) {
+    const uint32 kMaxRegCount = cgFunc->GetMaxVReg();
+    regGen[bb.GetId()] = new DataInfo(kMaxRegCount, rdAlloc);
+    regUse[bb.GetId()] = new DataInfo(kMaxRegCount, rdAlloc);
+    regIn[bb.GetId()] = new DataInfo(kMaxRegCount, rdAlloc);
+    regOut[bb.GetId()] = new DataInfo(kMaxRegCount, rdAlloc);
+  }
+
+  if ((mode & kRDMemAnalysis) != 0) {
+    const int32 kStackSize = GetStackSize();
+    memGen[bb.GetId()] = new DataInfo((kStackSize / kMemZoomSize), rdAlloc);
+    memUse[bb.GetId()] = new DataInfo((kStackSize / kMemZoomSize), rdAlloc);
+    memIn[bb.GetId()] = new DataInfo((kStackSize / kMemZoomSize), rdAlloc);
+    memOut[bb.GetId()] = new DataInfo((kStackSize / kMemZoomSize), rdAlloc);
+  }
+}
+
+/* insert pseudoInsns for function parameters, ehBB, and return R0/V0. init bb->gen, bb->use, bb->out */
+void ReachingDefinition::Initialize() {
+  InitDataSize();
+  AddRetPseudoInsns();
+  FOR_ALL_BB(bb, cgFunc) {
+    InitRegAndMemInfo(*bb);
+  }
+  FOR_ALL_BB(bb, cgFunc) {
+    if (bb == cgFunc->GetFirstBB()) {
+      InitStartGen();
+    }
+    if (!bb->GetEhPreds().empty()) {
+      InitEhDefine(*bb);
+    }
+    InitGenUse(*bb);
+    InitOut(*bb);
+
+    if (bb->IsCleanup()) {
+      (void)cleanUpBBSet.insert(bb);
+    } else {
+      (void)normalBBSet.insert(bb);
+    }
+  }
+  maxInsnNO = 0;
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      insn->SetId(maxInsnNO);
+      maxInsnNO += kInsnNoInterval;
+    }
+  }
+}
+
+void ReachingDefinition::InitDataSize() {
+  /* to visit vec[cgFunc->NumBBs()], size should be cgFunc->NumBBs() + 1 */
+  const uint32 dataSize = cgFunc->NumBBs() + 1;
+  regIn.resize(dataSize);
+  regOut.resize(dataSize);
+  regGen.resize(dataSize);
+  regUse.resize(dataSize);
+  memIn.resize(dataSize);
+  memOut.resize(dataSize);
+  memGen.resize(dataSize);
+  memUse.resize(dataSize);
+}
+
+/* compute bb->in, bb->out for each BB execpt cleanup BB */
+void ReachingDefinition::BuildInOutForFuncBody() {
+  std::unordered_set<BB*> normalBBSetBak(normalBBSet.begin(), normalBBSet.end());
+  std::unordered_set<BB*>::iterator setItr;
+  while (!normalBBSetBak.empty()) {
+    setItr = normalBBSetBak.begin();
+    BB *bb = *setItr;
+    ASSERT(bb != nullptr, "null ptr check");
+    (void)normalBBSetBak.erase(setItr);
+
+    if (GenerateIn(*bb)) {
+      if (GenerateOut(*bb)) {
+        for (auto succ : bb->GetSuccs()) {
+          (void)normalBBSetBak.insert(succ);
+        }
+
+        for (auto ehSucc : bb->GetEhSuccs()) {
+          (void)normalBBSetBak.insert(ehSucc);
+        }
+      }
+    }
+  }
+  ASSERT(normalBBSetBak.empty(), "CG internal error.");
+}
+
+void ReachingDefinition::BuildInOutForFuncBodyBFS() {
+  std::vector<bool> inQueued(kMaxBBNum, false);
+  std::vector<bool> firstVisited(kMaxBBNum, true);
+  std::queue<BB*> worklist;
+  for (auto *bb : normalBBSet) {
+    worklist.push(bb);
+    inQueued[bb->GetId()] = true;
+  }
+
+  while (!worklist.empty()) {
+    auto *curBB = worklist.front();
+    worklist.pop();
+    inQueued[curBB->GetId()] = false;
+    if (GenerateOut(*curBB) || firstVisited[curBB->GetId()]) {
+      firstVisited[curBB->GetId()] = false;
+      GenerateIn(*curBB, worklist, inQueued);
+    }
+  }
+}
+
+/* In[BB] = Union all of out[Parents(bb)]. add succ to worklist, if it is changed and not in worklist */
+void ReachingDefinition::GenerateIn(const BB &bb, std::queue<BB*> &worklist, std::vector<bool> &inQueued) {
+  if ((mode & kRDRegAnalysis) != 0) {
+    for (auto *succBB : bb.GetSuccs()) {
+      if (regIn[succBB->GetId()]->OrBitsCheck(*regOut[bb.GetId()]) && !inQueued[succBB->GetId()]) {
+        worklist.push(succBB);
+        inQueued[succBB->GetId()] = true;
+      }
+    }
+    for (auto succEhBB : bb.GetEhSuccs()) {
+      if (regIn[succEhBB->GetId()]->OrBitsCheck(*regOut[bb.GetId()]) && !inQueued[succEhBB->GetId()]) {
+        worklist.push(succEhBB);
+        inQueued[succEhBB->GetId()] = true;
+      }
+    }
+  }
+  if ((mode & kRDMemAnalysis) != 0) {
+    for (auto *succBB : bb.GetSuccs()) {
+      if (memIn[succBB->GetId()]->OrBitsCheck(*memOut[bb.GetId()]) && !inQueued[succBB->GetId()]) {
+        worklist.push(succBB);
+        inQueued[succBB->GetId()] = true;
+      }
+    }
+    for (auto succEhBB : bb.GetEhSuccs()) {
+      if (memIn[succEhBB->GetId()]->OrBitsCheck(*memOut[bb.GetId()]) && !inQueued[succEhBB->GetId()]) {
+        worklist.push(succEhBB);
+        inQueued[succEhBB->GetId()] = true;
+      }
+    }
+  }
+}
+
+/* if bb->out changed, update in and out */
+void ReachingDefinition::UpdateInOut(BB &changedBB) {
+  InitGenUse(changedBB, false);
+  if (!GenerateOut(changedBB)) {
+    return;
+  }
+
+  std::unordered_set<BB*> bbSet;
+  std::unordered_set<BB*>::iterator setItr;
+
+  for (auto succ : changedBB.GetSuccs()) {
+    (void)bbSet.insert(succ);
+  }
+
+  for (auto ehSucc : changedBB.GetEhSuccs()) {
+    (void)bbSet.insert(ehSucc);
+  }
+
+  while (!bbSet.empty()) {
+    setItr = bbSet.begin();
+    BB *bb = *setItr;
+    ASSERT(bb != nullptr, "null ptr check");
+    bbSet.erase(setItr);
+
+    if (GenerateIn(*bb)) {
+      if (GenerateOut(*bb)) {
+        for (auto succ : bb->GetSuccs()) {
+          (void)bbSet.insert(succ);
+        }
+
+        for (auto ehSucc : bb->GetEhSuccs()) {
+          (void)bbSet.insert(ehSucc);
+        }
+      }
+    }
+  }
+
+  if (!changedBB.IsCleanup() && firstCleanUpBB != nullptr) {
+    BuildInOutForCleanUpBB();
+  }
+}
+
+void ReachingDefinition::UpdateInOut(BB &changedBB, bool isReg) {
+  std::set<uint32> changedInfoIndex;
+  if (isReg) {
+    LocalMapleAllocator alloc(stackMp);
+    DataInfo &genInfoBak = regGen[changedBB.GetId()]->Clone(alloc);
+    InitGenUse(changedBB, false);
+    genInfoBak.EorBits(*regGen[changedBB.GetId()]);
+    genInfoBak.GetNonZeroElemsIndex(changedInfoIndex);
+  } else {
+    LocalMapleAllocator alloc(stackMp);
+    DataInfo &genInfoBak = memGen[changedBB.GetId()]->Clone(alloc);
+    InitGenUse(changedBB, false);
+    genInfoBak.EorBits(*memGen[changedBB.GetId()]);
+    genInfoBak.GetNonZeroElemsIndex(changedInfoIndex);
+  }
+  if (changedInfoIndex.empty()) {
+    return;
+  }
+  if (!GenerateOut(changedBB, changedInfoIndex, isReg)) {
+    return;
+  }
+  std::set<BB*, BBIdCmp> bbSet;
+  std::set<BB*, BBIdCmp>::iterator setItr;
+  for (auto &succ : changedBB.GetSuccs()) {
+    (void)bbSet.insert(succ);
+  }
+
+  for (auto &ehSucc : changedBB.GetEhSuccs()) {
+    (void)bbSet.insert(ehSucc);
+  }
+  while (!bbSet.empty()) {
+    setItr = bbSet.begin();
+    BB *bb = *setItr;
+    bbSet.erase(setItr);
+    if (GenerateIn(*bb, changedInfoIndex, isReg)) {
+      if (GenerateOut(*bb, changedInfoIndex, isReg)) {
+        for (auto &succ : bb->GetSuccs()) {
+          (void)bbSet.insert(succ);
+        }
+        for (auto &ehSucc : bb->GetEhSuccs()) {
+          (void)bbSet.insert(ehSucc);
+        }
+      }
+    }
+  }
+
+  if (!changedBB.IsCleanup() && firstCleanUpBB != nullptr) {
+    BuildInOutForCleanUpBB(isReg, changedInfoIndex);
+  }
+}
+
+
+/* compute bb->in, bb->out for cleanup BBs */
+void ReachingDefinition::BuildInOutForCleanUpBB() {
+  ASSERT(firstCleanUpBB != nullptr, "firstCleanUpBB must not be nullptr");
+  if (GenerateInForFirstCleanUpBB()) {
+    GenerateOut(*firstCleanUpBB);
+  }
+  std::unordered_set<BB*> cleanupBBSetBak(cleanUpBBSet.begin(), cleanUpBBSet.end());
+  std::unordered_set<BB*>::iterator setItr;
+
+  while (!cleanupBBSetBak.empty()) {
+    setItr = cleanupBBSetBak.begin();
+    BB *bb = *setItr;
+    cleanupBBSetBak.erase(setItr);
+    if (GenerateIn(*bb)) {
+      if (GenerateOut(*bb)) {
+        for (auto succ : bb->GetSuccs()) {
+          (void)cleanupBBSetBak.insert(succ);
+        }
+        for (auto ehSucc : bb->GetEhSuccs()) {
+          (void)cleanupBBSetBak.insert(ehSucc);
+        }
+      }
+    }
+  }
+  ASSERT(cleanupBBSetBak.empty(), "CG internal error.");
+}
+
+void ReachingDefinition::BuildInOutForCleanUpBB(bool isReg, const std::set<uint32> &index) {
+  ASSERT(firstCleanUpBB != nullptr, "firstCleanUpBB must not be nullptr");
+  if (GenerateInForFirstCleanUpBB(isReg, index)) {
+    GenerateOut(*firstCleanUpBB, index, isReg);
+  }
+  std::unordered_set<BB*> cleanupBBSetBak(cleanUpBBSet.begin(), cleanUpBBSet.end());
+  std::unordered_set<BB*>::iterator setItr;
+  while (!cleanupBBSetBak.empty()) {
+    setItr = cleanupBBSetBak.begin();
+    BB *bb = *setItr;
+    cleanupBBSetBak.erase(setItr);
+    if (GenerateIn(*bb, index, isReg)) {
+      if (GenerateOut(*bb, index, isReg)) {
+        for (auto &succ : bb->GetSuccs()) {
+          (void)cleanupBBSetBak.insert(succ);
+        }
+        for (auto &ehSucc : bb->GetEhSuccs()) {
+          (void)cleanupBBSetBak.insert(ehSucc);
+        }
+      }
+    }
+  }
+  ASSERT(cleanupBBSetBak.empty(), "CG internal error.");
+}
+
+/* entry for ReachingDefinition Analysis, mode represent to analyze RegOperand, MemOperand or both of them */
+void ReachingDefinition::AnalysisStart() {
+  if (!cgFunc->GetFirstBB()) {
+    return;
+  }
+  stackSize = static_cast<uint32>(GetStackSize());
+  Initialize();
+  /* Build in/out for function body first. (Except cleanup bb) */
+  BuildInOutForFuncBodyBFS();
+  /* If cleanup bb exists, build in/out for cleanup bbs. firstCleanUpBB->in = Union all non-cleanup bb's out. */
+  if (firstCleanUpBB != nullptr) {
+    BuildInOutForCleanUpBB();
+  }
+  cgFunc->SetRD(this);
+}
+
+/* check whether currentBB can reach endBB according to control flow */
+bool ReachingDefinition::CanReachEndBBFromCurrentBB(const BB &currentBB, const BB &endBB,
+                                                    std::vector<bool> &traversedBBSet) const {
+  if (&currentBB == &endBB) {
+    return true;
+  }
+  for (auto predBB : endBB.GetPreds()) {
+    if (traversedBBSet[predBB->GetId()]) {
+      continue;
+    }
+    traversedBBSet[predBB->GetId()] = true;
+    if (predBB == &currentBB) {
+      return true;
+    }
+    if (CanReachEndBBFromCurrentBB(currentBB, *predBB, traversedBBSet)) {
+      return true;
+    }
+  }
+  for (auto ehPredBB : endBB.GetEhPreds()) {
+    if (traversedBBSet[ehPredBB->GetId()]) {
+      continue;
+    }
+    traversedBBSet[ehPredBB->GetId()] = true;
+    if (ehPredBB == &currentBB) {
+      return true;
+    }
+    if (CanReachEndBBFromCurrentBB(currentBB, *ehPredBB, traversedBBSet)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/* check whether register may be redefined form startBB to endBB */
+bool ReachingDefinition::IsLiveInAllPathBB(uint32 regNO, const BB &startBB, const BB &endBB,
+                                           std::vector<bool> &visitedBB, bool isFirstNo) const {
+  for (auto succ : startBB.GetSuccs()) {
+    if (visitedBB[succ->GetId()]) {
+      continue;
+    }
+    visitedBB[succ->GetId()] = true;
+    if (isFirstNo && CheckRegLiveinReturnBB(regNO, *succ)) {
+      return false;
+    }
+    std::vector<bool> traversedPathSet(kMaxBBNum, false);
+    bool canReachEndBB = true;
+    if (regGen[succ->GetId()]->TestBit(regNO)) {
+      canReachEndBB = CanReachEndBBFromCurrentBB(*succ, endBB, traversedPathSet);
+      if (canReachEndBB) {
+        return false;
+      }
+    }
+    if (!canReachEndBB) {
+      continue;
+    }
+    bool isLive = IsLiveInAllPathBB(regNO, *succ, endBB, visitedBB, isFirstNo);
+    if (!isLive) {
+      return false;
+    }
+  }
+
+  for (auto ehSucc : startBB.GetEhSuccs()) {
+    if (visitedBB[ehSucc->GetId()]) {
+      continue;
+    }
+    visitedBB[ehSucc->GetId()] = true;
+    if (isFirstNo && CheckRegLiveinReturnBB(regNO, *ehSucc)) {
+      return false;
+    }
+    std::vector<bool> traversedPathSet(kMaxBBNum, false);
+    bool canReachEndBB = true;
+    if (regGen[ehSucc->GetId()]->TestBit(regNO)) {
+      canReachEndBB = CanReachEndBBFromCurrentBB(*ehSucc, endBB, traversedPathSet);
+      if (canReachEndBB) {
+        return false;
+      }
+    }
+    if (!canReachEndBB) {
+      continue;
+    }
+    bool isLive = IsLiveInAllPathBB(regNO, *ehSucc, endBB, visitedBB, isFirstNo);
+    if (!isLive) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/* Check if the reg is used in return BB */
+bool ReachingDefinition::CheckRegLiveinReturnBB(uint32 regNO, const BB &bb) const {
+#if TARGAARCH64 || TARGRISCV64
+  if (bb.GetKind() == BB::kBBReturn) {
+    PrimType returnType = cgFunc->GetFunction().GetReturnType()->GetPrimType();
+    regno_t returnReg = R0;
+    if (IsPrimitiveFloat(returnType)) {
+      returnReg = V0;
+    } else if (IsPrimitiveInteger(returnType)) {
+      returnReg = R0;
+    }
+    if (regNO == returnReg) {
+      return true;
+    }
+  }
+#endif
+  return false;
+}
+
+bool ReachingDefinition::RegIsUsedIncaller(uint32 regNO, Insn &startInsn, Insn &endInsn) const {
+  if (startInsn.GetBB() != endInsn.GetBB()) {
+    return false;
+  }
+  if (startInsn.GetNext() == &endInsn || &startInsn == &endInsn) {
+    return false;
+  }
+  auto regDefVec = FindRegDefBetweenInsn(regNO, startInsn.GetNext(), endInsn.GetPrev());
+  if (!regDefVec.empty()) {
+    return false;
+  }
+  if (IsCallerSavedReg(regNO) && startInsn.GetNext() != nullptr &&
+      KilledByCallBetweenInsnInSameBB(*startInsn.GetNext(), *(startInsn.GetBB()->GetLastInsn()), regNO)) {
+    return true;
+  }
+  if (CheckRegLiveinReturnBB(regNO, *startInsn.GetBB())) {
+    return true;
+  }
+  return false;
+}
+
+/* check whether control flow can reach endInsn from startInsn */
+bool ReachingDefinition::RegIsLiveBetweenInsn(uint32 regNO, Insn &startInsn, Insn &endInsn, bool isBack,
+    bool isFirstNo) const {
+  ASSERT(&startInsn != &endInsn, "startInsn is not equal to endInsn");
+  if (startInsn.GetBB() == endInsn.GetBB()) {
+    /* register is difined more than once */
+    if (startInsn.GetId() > endInsn.GetId()) {
+      if (!isBack) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+    if (startInsn.GetNext() == &endInsn) {
+      return true;
+    }
+    if (regGen[startInsn.GetBB()->GetId()]->TestBit(regNO)) {
+      std::vector<Insn*> regDefVec;
+      if (isBack) {
+        regDefVec = FindRegDefBetweenInsn(regNO, startInsn.GetNext(), endInsn.GetPrev());
+      } else {
+        regDefVec = FindRegDefBetweenInsn(regNO, &startInsn, endInsn.GetPrev());
+      }
+      if (!regDefVec.empty()) {
+        return false;
+      }
+    }
+    if (IsCallerSavedReg(regNO) && KilledByCallBetweenInsnInSameBB(*startInsn.GetNext(), *endInsn.GetPrev(), regNO)) {
+      return false;
+    }
+    return true;
+  }
+
+  if (&startInsn != startInsn.GetBB()->GetLastInsn() &&
+      regGen[startInsn.GetBB()->GetId()]->TestBit(regNO) &&
+      !FindRegDefBetweenInsn(regNO, startInsn.GetNext(), startInsn.GetBB()->GetLastInsn()).empty()) {
+    return false;
+  }
+
+  if (&startInsn != startInsn.GetBB()->GetLastInsn() &&
+      IsCallerSavedReg(regNO) &&
+      KilledByCallBetweenInsnInSameBB(*startInsn.GetNext(), *startInsn.GetBB()->GetLastInsn(), regNO)) {
+    return false;
+  }
+
+  if (&endInsn != endInsn.GetBB()->GetFirstInsn() &&
+      regGen[endInsn.GetBB()->GetId()]->TestBit(regNO) &&
+      !FindRegDefBetweenInsn(regNO, endInsn.GetBB()->GetFirstInsn(), endInsn.GetPrev()).empty()) {
+    return false;
+  }
+
+  if (&endInsn != endInsn.GetBB()->GetFirstInsn() &&
+      IsCallerSavedReg(regNO) &&
+      KilledByCallBetweenInsnInSameBB(*endInsn.GetBB()->GetFirstInsn(), *endInsn.GetPrev(), regNO)) {
+    return false;
+  }
+
+  std::vector<bool> visitedBB(kMaxBBNum, false);
+  return IsLiveInAllPathBB(regNO, *startInsn.GetBB(), *endInsn.GetBB(), visitedBB, isFirstNo);
+}
+
+static bool SetDefInsnVecForAsm(Insn *insn, uint32 index, uint32 regNO, std::vector<Insn *> &defInsnVec) {
+  for (auto reg : static_cast<ListOperand&>(insn->GetOperand(index)).GetOperands()) {
+    if (static_cast<RegOperand *>(reg)->GetRegisterNumber() == regNO) {
+      defInsnVec.emplace_back(insn);
+      return true;
+    }
+  }
+  return false;
+}
+
+std::vector<Insn*> ReachingDefinition::FindRegDefBetweenInsn(
+      uint32 regNO, Insn *startInsn, Insn *endInsn, bool findAll, bool analysisDone) const {
+  std::vector<Insn*> defInsnVec;
+  if (startInsn == nullptr || endInsn == nullptr) {
+    return defInsnVec;
+  }
+
+  ASSERT(startInsn->GetBB() == endInsn->GetBB(), "two insns must be in a same BB");
+  if (analysisDone && !regGen[startInsn->GetBB()->GetId()]->TestBit(regNO)) {
+    return defInsnVec;
+  }
+
+  for (Insn *insn = endInsn; insn != nullptr && insn != startInsn->GetPrev(); insn = insn->GetPrev()) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+
+    if (insn->IsAsmInsn()) {
+      if (SetDefInsnVecForAsm(insn, kAsmOutputListOpnd, regNO, defInsnVec) ||
+          SetDefInsnVecForAsm(insn, kAsmClobberListOpnd, regNO, defInsnVec)) {
+        if (findAll) {
+          defInsnVec.emplace_back(insn);
+        } else {
+          return defInsnVec;
+        }
+      }
+    }
+    if (insn->IsCall() && IsRegKilledByCallInsn(*insn, regNO)) {
+      defInsnVec.emplace_back(insn);
+      if (!findAll) {
+        return defInsnVec;
+      }
+    }
+    if (insn->IsRegDefined(regNO)) {
+      defInsnVec.emplace_back(insn);
+      if (!findAll) {
+        return defInsnVec;
+      }
+    }
+  }
+  return defInsnVec;
+}
+
+bool ReachingDefinition::RegIsUsedOrDefBetweenInsn(uint32 regNO, Insn &startInsn, Insn &endInsn) const {
+  ASSERT(&startInsn != &endInsn, "startInsn is not equal to endInsn");
+  if (startInsn.GetBB() == endInsn.GetBB()) {
+    /* register is difined more than once */
+    if (startInsn.GetId() > endInsn.GetId()) {
+      return false;
+    }
+    if (startInsn.GetNext() == &endInsn) {
+      return true;
+    }
+    if (regGen[startInsn.GetBB()->GetId()]->TestBit(regNO) &&
+        !FindRegDefBetweenInsn(regNO, startInsn.GetNext(), endInsn.GetPrev()).empty()) {
+      return false;
+    }
+    if (regUse[startInsn.GetBB()->GetId()]->TestBit(regNO)) {
+      InsnSet useInsnSet;
+      FindRegUseBetweenInsn(regNO, startInsn.GetNext(), endInsn.GetPrev(), useInsnSet);
+      if (!useInsnSet.empty()) {
+        return false;
+      }
+    }
+    if (IsCallerSavedReg(regNO) && KilledByCallBetweenInsnInSameBB(*startInsn.GetNext(), *endInsn.GetPrev(), regNO)) {
+      return false;
+    }
+    return true;
+  }
+
+  if (&startInsn != startInsn.GetBB()->GetLastInsn() &&
+      regGen[startInsn.GetBB()->GetId()]->TestBit(regNO) &&
+      !FindRegDefBetweenInsn(regNO, startInsn.GetNext(), startInsn.GetBB()->GetLastInsn()).empty()) {
+    return false;
+  }
+
+  if (regUse[startInsn.GetBB()->GetId()]->TestBit(regNO)) {
+    InsnSet useInsnSet;
+    FindRegUseBetweenInsn(regNO, startInsn.GetNext(), startInsn.GetBB()->GetLastInsn(), useInsnSet);
+    if (!useInsnSet.empty()) {
+      return false;
+    }
+  }
+
+  if (&startInsn != startInsn.GetBB()->GetLastInsn() &&
+      IsCallerSavedReg(regNO) &&
+      KilledByCallBetweenInsnInSameBB(*startInsn.GetNext(), *startInsn.GetBB()->GetLastInsn(), regNO)) {
+    return false;
+  }
+
+  if (&endInsn != endInsn.GetBB()->GetFirstInsn() &&
+      regGen[endInsn.GetBB()->GetId()]->TestBit(regNO) &&
+      !FindRegDefBetweenInsn(regNO, endInsn.GetBB()->GetFirstInsn(), endInsn.GetPrev()).empty()) {
+    return false;
+  }
+
+  if (regUse[startInsn.GetBB()->GetId()]->TestBit(regNO)) {
+    InsnSet useInsnSet;
+    FindRegUseBetweenInsn(regNO, endInsn.GetBB()->GetFirstInsn(), endInsn.GetPrev(), useInsnSet);
+    if (!useInsnSet.empty()) {
+      return false;
+    }
+  }
+
+  if (&endInsn != endInsn.GetBB()->GetFirstInsn() &&
+      IsCallerSavedReg(regNO) &&
+      KilledByCallBetweenInsnInSameBB(*endInsn.GetBB()->GetFirstInsn(), *endInsn.GetPrev(), regNO)) {
+    return false;
+  }
+
+  std::vector<bool> visitedBB(kMaxBBNum, false);
+  return IsUseOrDefInAllPathBB(regNO, *startInsn.GetBB(), *endInsn.GetBB(), visitedBB);
+}
+
+/* check whether register may be redefined form in the same BB */
+bool ReachingDefinition::IsUseOrDefBetweenInsn(uint32 regNO, const BB &curBB,
+                                               const Insn &startInsn, Insn &endInsn) const {
+  if (regGen[curBB.GetId()]->TestBit(regNO)) {
+    if (!FindRegDefBetweenInsn(regNO, startInsn.GetNext(), endInsn.GetPrev()).empty()) {
+      return false;
+    }
+  }
+  if (regUse[curBB.GetId()]->TestBit(regNO)) {
+    InsnSet useInsnSet;
+    FindRegUseBetweenInsn(regNO, startInsn.GetNext(), endInsn.GetPrev(), useInsnSet);
+    if (!useInsnSet.empty()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/* check whether register may be redefined form startBB to endBB */
+bool ReachingDefinition::IsUseOrDefInAllPathBB(uint32 regNO, const BB &startBB, const BB &endBB,
+                                               std::vector<bool> &visitedBB) const {
+  for (auto succ : startBB.GetSuccs()) {
+    if (visitedBB[succ->GetId()] || succ == &endBB) {
+      continue;
+    }
+    visitedBB[succ->GetId()] = true;
+    std::vector<bool> traversedPathSet(kMaxBBNum, false);
+    bool canReachEndBB = true;
+    if (regGen[succ->GetId()]->TestBit(regNO) || regUse[succ->GetId()]->TestBit(regNO) ||
+        (succ->HasCall() && IsCallerSavedReg(regNO))) {
+      canReachEndBB = CanReachEndBBFromCurrentBB(*succ, endBB, traversedPathSet);
+      if (canReachEndBB) {
+        return false;
+      }
+    }
+    if (!canReachEndBB) {
+      continue;
+    }
+    bool isLive = IsUseOrDefInAllPathBB(regNO, *succ, endBB, visitedBB);
+    if (!isLive) {
+      return false;
+    }
+  }
+
+  for (auto ehSucc : startBB.GetEhSuccs()) {
+    if (visitedBB[ehSucc->GetId()]) {
+      continue;
+    }
+    visitedBB[ehSucc->GetId()] = true;
+    std::vector<bool> traversedPathSet(kMaxBBNum, false);
+    bool canReachEndBB = true;
+    if (regGen[ehSucc->GetId()]->TestBit(regNO) || regUse[ehSucc->GetId()]->TestBit(regNO)) {
+      canReachEndBB = CanReachEndBBFromCurrentBB(*ehSucc, endBB, traversedPathSet);
+      if (canReachEndBB) {
+        return false;
+      }
+    }
+    if (!canReachEndBB) {
+      continue;
+    }
+    bool isLive = IsUseOrDefInAllPathBB(regNO, *ehSucc, endBB, visitedBB);
+    if (!isLive) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool ReachingDefinition::HasCallBetweenInsnInSameBB(const Insn &startInsn, const Insn &endInsn) const {
+  ASSERT(startInsn.GetBB() == endInsn.GetBB(), "two insns must be in same bb");
+  for (const Insn *insn = &startInsn; insn != endInsn.GetNext(); insn = insn->GetNext()) {
+    if (insn->IsMachineInstruction() && insn->IsCall()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/* operand is only defined in startBB, and only used in endBB.
+ * so traverse from endBB to startBB, all paths reach startBB finally.
+ * startBB and endBB are different, and call insns in both of them are not counted.
+ * whether startBB and endBB are in a loop is not counted.
+ */
+bool ReachingDefinition::HasCallInPath(const BB &startBB, const BB &endBB, std::vector<bool> &visitedBB) const {
+  ASSERT(&startBB != &endBB, "startBB and endBB are not counted");
+  std::queue<const BB*> bbQueue;
+  bbQueue.push(&endBB);
+  visitedBB[endBB.GetId()] = true;
+  while (!bbQueue.empty()) {
+    const BB *bb = bbQueue.front();
+    bbQueue.pop();
+    for (auto predBB : bb->GetPreds()) {
+      if (predBB == &startBB || visitedBB[predBB->GetId()]) {
+        continue;
+      }
+      if (predBB->HasCall()) {
+        return true;
+      }
+      visitedBB[predBB->GetId()] = true;
+      bbQueue.push(predBB);
+    }
+    for (auto ehPredBB : bb->GetEhPreds()) {
+      if (ehPredBB == &startBB || visitedBB[ehPredBB->GetId()]) {
+        continue;
+      }
+      if (ehPredBB->HasCall()) {
+        return true;
+      }
+      visitedBB[ehPredBB->GetId()] = true;
+      bbQueue.push(ehPredBB);
+    }
+  }
+  return false;
+}
+
+/* because of time cost, this function is not precise, BB in loop is not counted */
+bool ReachingDefinition::HasCallBetweenDefUse(const Insn &defInsn, const Insn &useInsn) const {
+  if (defInsn.GetBB()->GetId() == useInsn.GetBB()->GetId()) {
+    if (&useInsn == defInsn.GetNext()) {
+      return false;
+    }
+    if (useInsn.GetId() > defInsn.GetId()) {
+      return HasCallBetweenInsnInSameBB(defInsn, *useInsn.GetPrev());
+    }
+    /* useInsn is in front of defInsn, we think there is call insn between them conservatively */
+    return true;
+  }
+  /* check defInsn->GetBB() */
+  if (&defInsn != defInsn.GetBB()->GetLastInsn() &&
+      defInsn.GetBB()->HasCall() &&
+      HasCallBetweenInsnInSameBB(*defInsn.GetNext(), *defInsn.GetBB()->GetLastInsn())) {
+    return true;
+  }
+  /* check useInsn->GetBB() */
+  if (&useInsn != useInsn.GetBB()->GetFirstInsn() &&
+      useInsn.GetBB()->HasCall() &&
+      HasCallBetweenInsnInSameBB(*useInsn.GetBB()->GetFirstInsn(), *useInsn.GetPrev())) {
+    return true;
+  }
+  std::vector<bool> visitedBB(kMaxBBNum, false);
+  return HasCallInPath(*defInsn.GetBB(), *useInsn.GetBB(), visitedBB);
+}
+
+void ReachingDefinition::EnlargeRegCapacity(uint32 size) {
+  FOR_ALL_BB(bb, cgFunc) {
+    regIn[bb->GetId()]->EnlargeCapacityToAdaptSize(size);
+    regOut[bb->GetId()]->EnlargeCapacityToAdaptSize(size);
+    regGen[bb->GetId()]->EnlargeCapacityToAdaptSize(size);
+    regUse[bb->GetId()]->EnlargeCapacityToAdaptSize(size);
+  }
+}
+
+void ReachingDefinition::DumpInfo(const BB &bb, DumpType flag) const {
+  const DataInfo *info = nullptr;
+  switch (flag) {
+    case kDumpRegGen:
+      LogInfo::MapleLogger() << "    regGen:\n";
+      info = regGen[bb.GetId()];
+      break;
+    case kDumpRegUse:
+      LogInfo::MapleLogger() << "    regUse:\n";
+      info = regUse[bb.GetId()];
+      break;
+    case kDumpRegIn:
+      LogInfo::MapleLogger() << "    regIn:\n";
+      info = regIn[bb.GetId()];
+      break;
+    case kDumpRegOut:
+      LogInfo::MapleLogger() << "    regOut:\n";
+      info = regOut[bb.GetId()];
+      break;
+    case kDumpMemGen:
+      LogInfo::MapleLogger() << "    memGen:\n";
+      info = memGen[bb.GetId()];
+      break;
+    case kDumpMemIn:
+      LogInfo::MapleLogger() << "    memIn:\n";
+      info = memIn[bb.GetId()];
+      break;
+    case kDumpMemOut:
+      LogInfo::MapleLogger() << "    memOut:\n";
+      info = memOut[bb.GetId()];
+      break;
+    case kDumpMemUse:
+      LogInfo::MapleLogger() << "    memUse:\n";
+      info = memUse[bb.GetId()];
+      break;
+    default:
+      return;
+  }
+  ASSERT(info != nullptr, "null ptr check");
+  uint32 count = 1;
+  LogInfo::MapleLogger() << "        ";
+  for (uint32 i = 0; i != info->Size(); ++i) {
+    if (info->TestBit(i)) {
+      count += 1;
+      if (kDumpMemGen <= flag && flag <= kDumpMemUse) {
+        /* Each element i means a 4 byte stack slot. */
+        LogInfo::MapleLogger() << (i * 4) << " ";
+      } else {
+        LogInfo::MapleLogger() << i << " ";
+      }
+      /* 10 output per line */
+      if (count % 10 == 0) {
+        LogInfo::MapleLogger() << "\n";
+        LogInfo::MapleLogger() << "        ";
+      }
+    }
+  }
+
+  LogInfo::MapleLogger() << "\n";
+}
+
+void ReachingDefinition::DumpBBCGIR(const BB &bb) const {
+  if (bb.IsCleanup()) {
+    LogInfo::MapleLogger() << "[is_cleanup] ";
+  }
+  if (bb.IsUnreachable()) {
+    LogInfo::MapleLogger() << "[unreachable] ";
+  }
+  if (bb.GetSuccs().size() != 0) {
+    LogInfo::MapleLogger() << "      succs: ";
+    for (auto *succBB : bb.GetSuccs()) {
+      LogInfo::MapleLogger() << succBB->GetId() << " ";
+    }
+  }
+  if (bb.GetEhSuccs().size() != 0) {
+    LogInfo::MapleLogger() << "      eh_succs: ";
+    for (auto *ehSuccBB : bb.GetEhSuccs()) {
+      LogInfo::MapleLogger() << ehSuccBB->GetId() << " ";
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+
+  FOR_BB_INSNS_CONST(insn, &bb) {
+    LogInfo::MapleLogger() << "        ";
+    insn->Dump();
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void ReachingDefinition::Dump(uint32 flag) const {
+  MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(cgFunc->GetFunction().GetStIdx().Idx());
+  ASSERT(mirSymbol != nullptr, "get symbol in function failed in ReachingDefinition::Dump");
+  LogInfo::MapleLogger() << "\n----  Reaching definition analysis for " << mirSymbol->GetName();
+  LogInfo::MapleLogger() << " ----\n";
+  FOR_ALL_BB(bb, cgFunc) {
+    LogInfo::MapleLogger() << "  === BB_" << bb->GetId() << " ===\n";
+
+    if ((flag & kDumpBBCGIR) != 0) {
+      DumpBBCGIR(*bb);
+    }
+
+    if ((flag & kDumpRegIn) != 0) {
+      DumpInfo(*bb, kDumpRegIn);
+    }
+
+    if ((flag & kDumpRegUse) != 0) {
+      DumpInfo(*bb, kDumpRegUse);
+    }
+
+    if ((flag & kDumpRegGen) != 0) {
+      DumpInfo(*bb, kDumpRegGen);
+    }
+
+    if ((flag & kDumpRegOut) != 0) {
+      DumpInfo(*bb, kDumpRegOut);
+    }
+
+    if ((flag & kDumpMemIn) != 0) {
+      DumpInfo(*bb, kDumpMemIn);
+    }
+
+    if ((flag & kDumpMemGen) != 0) {
+      DumpInfo(*bb, kDumpMemGen);
+    }
+
+    if ((flag & kDumpMemOut) != 0) {
+      DumpInfo(*bb, kDumpMemOut);
+    }
+
+    if ((flag & kDumpMemUse) != 0) {
+      DumpInfo(*bb, kDumpMemUse);
+    }
+  }
+  LogInfo::MapleLogger() << "------------------------------------------------------\n";
+}
+
+bool CgReachingDefinition::PhaseRun(maplebe::CGFunc &f) {
+#if TARGAARCH64 || TARGRISCV64
+  reachingDef = GetPhaseAllocator()->New<AArch64ReachingDefinition>(f, *GetPhaseMemPool());
+#endif
+#if TARGARM32
+  reachingDef = GetPhaseAllocator()->New<Arm32ReachingDefinition>(f, *GetPhaseMemPool());
+#endif
+  reachingDef->SetAnalysisMode(kRDAllAnalysis);
+  reachingDef->AnalysisStart();
+  return false;
+}
+MAPLE_ANALYSIS_PHASE_REGISTER(CgReachingDefinition, reachingdefinition)
+
+bool CgClearRDInfo::PhaseRun(maplebe::CGFunc &f) {
+  if (f.GetRDStatus()) {
+    f.GetRD()->ClearDefUseInfo();
+  }
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgClearRDInfo, clearrdinfo)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/reg_alloc.cpp b/src/mapleall/maple_be/src/cg/reg_alloc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..04442defd2703e2006aa53484f661da07f1d2d8e
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/reg_alloc.cpp
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "reg_alloc.h"
+#include "live.h"
+#include "loop.h"
+#include "cg_dominance.h"
+#include "mir_lower.h"
+#include "securec.h"
+#include "reg_alloc_basic.h"
+#include "reg_alloc_lsra.h"
+#include "cg.h"
+#if TARGAARCH64
+#include "aarch64_color_ra.h"
+#endif
+
+namespace maplebe {
+
+#ifdef RA_PERF_ANALYSIS
+static long loopAnalysisUS = 0;
+static long liveAnalysisUS = 0;
+static long createRAUS = 0;
+static long raUS = 0;
+static long cleanupUS = 0;
+static long totalUS = 0;
+extern void printRATime() {
+  std::cout << "============================================================\n";
+  std::cout << "               RA sub-phase time information              \n";
+  std::cout << "============================================================\n";
+  std::cout << "loop analysis cost: " << loopAnalysisUS << "us \n";
+  std::cout << "live analysis cost: " << liveAnalysisUS << "us \n";
+  std::cout << "create RA cost: " << createRAUS << "us \n";
+  std::cout << "doRA cost: " << raUS << "us \n";
+  std::cout << "cleanup cost: " << cleanupUS << "us \n";
+  std::cout << "RA total cost: " << totalUS << "us \n";
+  std::cout << "============================================================\n";
+}
+#endif
+
+bool CgRegAlloc::PhaseRun(maplebe::CGFunc &f) {
+  bool success = false;
+
+#ifdef RA_PERF_ANALYSIS
+  auto begin = std::chrono::system_clock::now();
+#endif
+
+  /* loop Analysis */
+#ifdef RA_PERF_ANALYSIS
+  auto start = std::chrono::system_clock::now();
+#endif
+  if (Globals::GetInstance()->GetOptimLevel() > CGOptions::kLevel0) {
+    (void)GetAnalysisInfoHook()->ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgLoopAnalysis::id, f);
+  }
+
+#if TARGAARCH64
+  /* dom Analysis */
+  DomAnalysis *dom = nullptr;
+  if (Globals::GetInstance()->GetOptimLevel() > CGOptions::kLevel0 &&
+      f.GetCG()->GetCGOptions().DoColoringBasedRegisterAllocation()) {
+    MaplePhase *it = GetAnalysisInfoHook()->ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(
+        &CgDomAnalysis::id, f);
+    dom = static_cast<CgDomAnalysis*>(it)->GetResult();
+    CHECK_FATAL(dom != nullptr, "null ptr check");
+  }
+#endif
+
+#ifdef RA_PERF_ANALYSIS
+  auto end = std::chrono::system_clock::now();
+  loopAnalysisUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+
+  while (success == false) {
+    MemPool *phaseMp = GetPhaseMemPool();
+#ifdef RA_PERF_ANALYSIS
+    start = std::chrono::system_clock::now();
+#endif
+    /* live analysis */
+    LiveAnalysis *live = nullptr;
+    if (Globals::GetInstance()->GetOptimLevel() > CGOptions::kLevel0) {
+      MaplePhase *it = GetAnalysisInfoHook()->ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(
+          &CgLiveAnalysis::id, f);
+      live = static_cast<CgLiveAnalysis*>(it)->GetResult();
+      CHECK_FATAL(live != nullptr, "null ptr check");
+      /* revert liveanalysis result container. */
+      live->ResetLiveSet();
+    }
+#ifdef RA_PERF_ANALYSIS
+    end = std::chrono::system_clock::now();
+    liveAnalysisUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+
+#ifdef RA_PERF_ANALYSIS
+    start = std::chrono::system_clock::now();
+#endif
+    /* create register allocator */
+    RegAllocator *regAllocator = nullptr;
+    MemPool *tempMP = nullptr;
+    if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+      regAllocator = phaseMp->New<DefaultO0RegAllocator>(f, *phaseMp);
+    } else if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevelLiteCG) {
+#if TARGX86_64
+      regAllocator = phaseMp->New<LSRALinearScanRegAllocator>(f, *phaseMp);
+#endif
+#if TARGAARCH64
+      maple::LogInfo::MapleLogger(kLlErr) << "Error: -LiteCG option is unsupported for aarch64.\n";
+#endif
+    } else {
+#if TARGAARCH64
+      if (f.GetCG()->GetCGOptions().DoLinearScanRegisterAllocation()) {
+        regAllocator = phaseMp->New<LSRALinearScanRegAllocator>(f, *phaseMp);
+      } else if (f.GetCG()->GetCGOptions().DoColoringBasedRegisterAllocation()) {
+        tempMP = memPoolCtrler.NewMemPool("colrRA", true);
+        regAllocator = phaseMp->New<GraphColorRegAllocator>(f, *tempMP, *dom);
+      } else {
+        maple::LogInfo::MapleLogger(kLlErr) <<
+            "Warning: We only support Linear Scan and GraphColor register allocation\n";
+      }
+#endif
+#if TARGX86_64
+      maple::LogInfo::MapleLogger(kLlErr) <<
+          "Error: We only support -O0, and -LiteCG for x64.\n";
+#endif
+    }
+#ifdef RA_PERF_ANALYSIS
+    end = std::chrono::system_clock::now();
+    createRAUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+
+#ifdef RA_PERF_ANALYSIS
+    start = std::chrono::system_clock::now();
+#endif
+    /* do register allocation */
+    CHECK_FATAL(regAllocator != nullptr, "regAllocator is null in CgDoRegAlloc::Run");
+    f.SetIsAfterRegAlloc();
+    success = regAllocator->AllocateRegisters();
+#ifdef RA_PERF_ANALYSIS
+    end = std::chrono::system_clock::now();
+    raUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+
+#ifdef RA_PERF_ANALYSIS
+    start = std::chrono::system_clock::now();
+#endif
+    /* the live range info may changed, so invalid the info. */
+    if (live != nullptr) {
+      live->ClearInOutDataInfo();
+    }
+    if (Globals::GetInstance()->GetOptimLevel() > CGOptions::kLevel0) {
+      GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &CgLiveAnalysis::id);
+    }
+#ifdef RA_PERF_ANALYSIS
+    end = std::chrono::system_clock::now();
+    cleanupUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+    memPoolCtrler.DeleteMemPool(tempMP);
+  }
+  if (Globals::GetInstance()->GetOptimLevel() > CGOptions::kLevel0) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &CgLoopAnalysis::id);
+  }
+
+#ifdef RA_PERF_ANALYSIS
+  end = std::chrono::system_clock::now();
+  totalUS += std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count();
+#endif
+  return false;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/reg_alloc_basic.cpp b/src/mapleall/maple_be/src/cg/reg_alloc_basic.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c413d49c6c7a9040f3ac6a3eaac0e0e2e1eb8e2
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/reg_alloc_basic.cpp
@@ -0,0 +1,453 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "reg_alloc_basic.h"
+#include "cg.h"
+
+namespace maplebe {
+/*
+*  NB. As an optimization we can use X8 as a scratch (temporary)
+*     register if the return value is not returned through memory.
+*/
+Operand *DefaultO0RegAllocator::HandleRegOpnd(Operand &opnd) {
+  ASSERT(opnd.IsRegister(), "Operand should be register operand");
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  if (regOpnd.IsOfCC()) {
+    return &opnd;
+  }
+  if (!regInfo->IsVirtualRegister(regOpnd)) {
+    availRegSet[regOpnd.GetRegisterNumber()] = false;
+    (void)liveReg.insert(regOpnd.GetRegisterNumber());
+    return &regOpnd;
+  }
+  auto regMapIt = regMap.find(regOpnd.GetRegisterNumber());
+  if (regMapIt != regMap.end()) {  /* already allocated this register */
+    ASSERT(regMapIt->second < regInfo->GetAllRegNum(), "must be a physical register");
+    regno_t newRegNO = regMapIt->second;
+    availRegSet[newRegNO] = false;  /* make sure the real register can not be allocated and live */
+    (void)liveReg.insert(newRegNO);
+    (void)allocatedSet.insert(&opnd);
+    return &cgFunc->GetOpndBuilder()->CreatePReg(newRegNO, regOpnd.GetSize(), regOpnd.GetRegisterType());
+  }
+  if (AllocatePhysicalRegister(regOpnd)) {
+    (void)allocatedSet.insert(&opnd);
+    auto regMapItSecond = regMap.find(regOpnd.GetRegisterNumber());
+    ASSERT(regMapItSecond != regMap.end(), " ERROR: can not find register number in regmap ");
+    return &cgFunc->GetOpndBuilder()->CreatePReg(regMapItSecond->second, regOpnd.GetSize(), regOpnd.GetRegisterType());
+  }
+
+  /* use 0 register as spill register */
+  regno_t regNO = 0;
+  return &cgFunc->GetOpndBuilder()->CreatePReg(regNO, regOpnd.GetSize(), regOpnd.GetRegisterType());
+}
+
+Operand *DefaultO0RegAllocator::HandleMemOpnd(Operand &opnd) {
+  ASSERT(opnd.IsMemoryAccessOperand(), "Operand should be memory access operand");
+  auto *memOpnd = static_cast<MemOperand*>(&opnd);
+  Operand *res = nullptr;
+  if (memOpnd->GetBaseRegister() != nullptr) {
+    res = AllocSrcOpnd(*memOpnd->GetBaseRegister());
+    memOpnd->SetBaseRegister(static_cast<RegOperand&>(*res));
+  }
+  if (memOpnd->GetIndexRegister() != nullptr) {
+    res = AllocSrcOpnd(*memOpnd->GetIndexRegister());
+    memOpnd->SetIndexRegister(static_cast<RegOperand&>(*res));
+  }
+  (void)allocatedSet.insert(&opnd);
+  return memOpnd;
+}
+
+Operand *DefaultO0RegAllocator::AllocSrcOpnd(Operand &opnd) {
+  if (opnd.IsRegister()) {
+    if (regInfo->IsUnconcernedReg(static_cast<RegOperand&>(opnd))) {
+      return &opnd;
+    }
+    return HandleRegOpnd(opnd);
+  } else if (opnd.IsMemoryAccessOperand()) {
+    return HandleMemOpnd(opnd);
+  }
+  ASSERT(false, "NYI");
+  return nullptr;
+}
+
+Operand *DefaultO0RegAllocator::AllocDestOpnd(Operand &opnd, const Insn &insn) {
+  if (!opnd.IsRegister()) {
+    ASSERT(false, "result operand must be of type register");
+    return nullptr;
+  }
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  if (regInfo->IsUnconcernedReg(static_cast<RegOperand&>(opnd))) {
+    return &opnd;
+  }
+  if (!regInfo->IsVirtualRegister(regOpnd)) {
+    auto reg = regOpnd.GetRegisterNumber();
+    availRegSet[reg] = true;
+    uint32 id = GetRegLivenessId(regOpnd.GetRegisterNumber());
+    if (id != 0 && id <= insn.GetId()) {
+      ReleaseReg(reg);
+    }
+    return &opnd;
+  }
+
+  auto regMapIt = regMap.find(regOpnd.GetRegisterNumber());
+  if (regMapIt != regMap.end()) {
+    regno_t reg = regMapIt->second;
+    if (!insn.IsCondDef()) {
+      uint32 id = GetRegLivenessId(regOpnd.GetRegisterNumber());
+      if (id != 0 && id <= insn.GetId()) {
+        ReleaseReg(reg);
+      }
+    }
+  } else {
+    /* AllocatePhysicalRegister insert a mapping from vreg no to phy reg no into regMap */
+    if (AllocatePhysicalRegister(regOpnd)) {
+      regMapIt = regMap.find(regOpnd.GetRegisterNumber());
+      if (!insn.IsCondDef()) {
+        uint32 id = GetRegLivenessId(regOpnd.GetRegisterNumber());
+        if (id && (id <= insn.GetId())) {
+          ReleaseReg(regMapIt->second);
+        }
+      }
+    } else {
+      /* For register spill. use 0 register as spill register */
+      regno_t regNO = 0;
+      return &cgFunc->GetOpndBuilder()->CreatePReg(regNO, regOpnd.GetSize(), regOpnd.GetRegisterType());
+    }
+  }
+  (void)allocatedSet.insert(&opnd);
+  return &cgFunc->GetOpndBuilder()->CreatePReg(regMapIt->second, regOpnd.GetSize(), regOpnd.GetRegisterType());
+}
+
+void DefaultO0RegAllocator::InitAvailReg() {
+  for (auto it : regInfo->GetAllRegs()) {
+    availRegSet[it] = true;
+  }
+}
+
+void DefaultO0RegAllocator::ReleaseReg(const RegOperand &regOpnd) {
+  ReleaseReg(regMap[regOpnd.GetRegisterNumber()]);
+}
+
+void DefaultO0RegAllocator::ReleaseReg(regno_t reg) {
+  ASSERT(reg < regInfo->GetAllRegNum(), "can't release virtual register");
+  liveReg.erase(reg);
+  /* Special registers can not be allocated */
+  if (!regInfo->IsSpecialReg(reg)) {
+    availRegSet[reg] = true;
+  }
+}
+
+/* trying to allocate a physical register to opnd. return true if success */
+bool DefaultO0RegAllocator::AllocatePhysicalRegister(const RegOperand &opnd) {
+  RegType regType = opnd.GetRegisterType();
+  regno_t regNo = opnd.GetRegisterNumber();
+  auto &regBank = regInfo->GetRegsFromType(regType);
+  regno_t regStart = *regBank.begin();
+  regno_t regEnd = *regBank.rbegin();
+
+  const auto opndRegIt = regLiveness.find(regNo);
+  for (regno_t reg = regStart; reg <= regEnd; ++reg) {
+    if (!availRegSet[reg]) {
+      continue;
+    }
+
+    if (opndRegIt != regLiveness.end()) {
+      const auto regIt = regLiveness.find(reg);
+      ASSERT(opndRegIt->second.size() == 1, "NIY, opnd reg liveness range must be 1.");
+      if (regIt != regLiveness.end() &&
+          CheckRangesOverlap(opndRegIt->second.front(), regIt->second)) {
+        continue;
+      }
+    }
+
+    regMap[opnd.GetRegisterNumber()] = reg;
+    availRegSet[reg] = false;
+    (void)liveReg.insert(reg);  /* this register is live now */
+    return true;
+  }
+  return false;
+}
+
+/* If opnd is a callee saved register, save it in the prolog and restore it in the epilog */
+void DefaultO0RegAllocator::SaveCalleeSavedReg(const RegOperand &regOpnd) {
+  regno_t regNO = regOpnd.GetRegisterNumber();
+  auto phyReg = regInfo->IsVirtualRegister(regOpnd) ? regMap[regNO] : regNO;
+  /* when yieldpoint is enabled, skip the reserved register for yieldpoint. */
+  if (cgFunc->GetCG()->GenYieldPoint() && (regInfo->IsYieldPointReg(phyReg))) {
+    return;
+  }
+
+  if (regInfo->IsCalleeSavedReg(phyReg)) {
+    calleeSaveUsed.insert(phyReg);
+  }
+}
+
+uint32 DefaultO0RegAllocator::GetRegLivenessId(regno_t regNo) {
+  auto regIt = regLiveness.find(regNo);
+  return ((regIt == regLiveness.end()) ? 0 : regIt->second.back().second);
+}
+
+bool DefaultO0RegAllocator::CheckRangesOverlap(const std::pair<uint32, uint32> &range1,
+    const MapleVector<std::pair<uint32, uint32>> &ranges2) const {
+  /*
+   * Check whether range1 and ranges2 overlap.
+   * The ranges2 is sorted.
+   */
+  auto pos = std::lower_bound(ranges2.begin(), ranges2.end(), range1,
+      [](const std::pair<uint32, uint32> &r2, const std::pair<uint32, uint32> &r1) {
+        return r1.first >= r2.second;
+      });
+  if (pos == ranges2.end()) {
+    return false;
+  }
+  auto &range2 = *pos;
+  if (std::max(range1.first, range2.first) <= std::min(range1.second, range2.second)) {
+    return true;
+  }
+  return false;
+}
+
+void DefaultO0RegAllocator::SetupRegLiveness(BB *bb) {
+  regLiveness.clear();
+
+  uint32 id = 1;
+  FOR_BB_INSNS_REV(insn, bb) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    insn->SetId(id);
+    id++;
+    uint32 opndNum = insn->GetOperandSize();
+    const InsnDesc *curMd = insn->GetDesc();
+    for (uint32 i = 0; i < opndNum; i++) {
+      Operand &opnd = insn->GetOperand(i);
+      const OpndDesc *opndDesc = curMd->GetOpndDes(i);
+      if (opnd.IsRegister()) {
+        /* def-use is processed by use */
+        SetupRegLiveness(static_cast<RegOperand&>(opnd), insn->GetId(), !opndDesc->IsUse());
+      } else if (opnd.IsMemoryAccessOperand()) {
+        SetupRegLiveness(static_cast<MemOperand&>(opnd), insn->GetId());
+      } else if (opnd.IsList()) {
+        SetupRegLiveness(static_cast<ListOperand&>(opnd), insn->GetId(), opndDesc->IsDef());
+      }
+    }
+  }
+
+  /* clear the last empty range */
+  for (auto &regLivenessIt : regLiveness) {
+    auto &regLivenessRanges = regLivenessIt.second;
+    if (regLivenessRanges.back().first == 0) {
+      regLivenessRanges.pop_back();
+    }
+  }
+}
+
+void DefaultO0RegAllocator::SetupRegLiveness(MemOperand &opnd, uint32 insnId) {
+  /* base regOpnd is use in O0 */
+  if (opnd.GetBaseRegister()) {
+    SetupRegLiveness(*opnd.GetBaseRegister(), insnId, false);
+  }
+  /* index regOpnd must be use */
+  if (opnd.GetIndexRegister()) {
+    SetupRegLiveness(*opnd.GetIndexRegister(), insnId, false);
+  }
+}
+
+void DefaultO0RegAllocator::SetupRegLiveness(ListOperand &opnd, uint32 insnId, bool isDef) {
+  for (RegOperand *regOpnd : opnd.GetOperands()) {
+    SetupRegLiveness(*regOpnd, insnId, isDef);
+  }
+}
+
+void DefaultO0RegAllocator::SetupRegLiveness(RegOperand &opnd, uint32 insnId, bool isDef) {
+  MapleVector<std::pair<uint32, uint32>> ranges(alloc.Adapter());
+  auto regLivenessIt = regLiveness.emplace(opnd.GetRegisterNumber(), ranges).first;
+  auto &regLivenessRanges = regLivenessIt->second;
+  if (regLivenessRanges.empty()) {
+    regLivenessRanges.push_back(std::make_pair(0, 0));
+  }
+  auto &regLivenessLastRange = regLivenessRanges.back();
+  if (regLivenessLastRange.first == 0) {
+    regLivenessLastRange.first = insnId;
+  }
+  regLivenessLastRange.second = insnId;
+
+  /* create new range, only phyReg need to be segmented */
+  if (isDef && regInfo->IsAvailableReg(opnd.GetRegisterNumber())) {
+    regLivenessRanges.push_back(std::make_pair(0, 0));
+  }
+}
+
+void DefaultO0RegAllocator::AllocHandleDestList(Insn &insn, Operand &opnd, uint32 idx) {
+  if (!opnd.IsList()) {
+    return;
+  }
+  auto *listOpnds = &static_cast<ListOperand&>(opnd);
+  auto *listOpndsNew = &cgFunc->GetOpndBuilder()->CreateList();
+  for (auto *dstOpnd : listOpnds->GetOperands()) {
+    if (allocatedSet.find(dstOpnd) != allocatedSet.end()) {
+      auto &regOpnd = static_cast<RegOperand&>(*dstOpnd);
+      SaveCalleeSavedReg(regOpnd);
+      listOpndsNew->PushOpnd(
+          cgFunc->GetOpndBuilder()->CreatePReg(
+              regMap[regOpnd.GetRegisterNumber()], regOpnd.GetSize(), regOpnd.GetRegisterType()));
+      continue;  /* already allocated */
+    }
+    RegOperand *regOpnd = static_cast<RegOperand*>(AllocDestOpnd(*dstOpnd, insn));
+    ASSERT(regOpnd != nullptr, "null ptr check");
+    auto physRegno = regOpnd->GetRegisterNumber();
+    availRegSet[physRegno] = false;
+    (void)liveReg.insert(physRegno);
+    listOpndsNew->PushOpnd(
+        cgFunc->GetOpndBuilder()->CreatePReg(physRegno, regOpnd->GetSize(), regOpnd->GetRegisterType()));
+  }
+  insn.SetOperand(idx, *listOpndsNew);
+  for (auto *dstOpnd : listOpndsNew->GetOperands()) {
+    uint32 id = GetRegLivenessId(dstOpnd->GetRegisterNumber());
+    if (id != 0 && id <= insn.GetId()) {
+      ReleaseReg(*dstOpnd);
+    }
+  }
+}
+
+void DefaultO0RegAllocator::AllocHandleDest(Insn &insn, Operand &opnd, uint32 idx) {
+  if (allocatedSet.find(&opnd) != allocatedSet.end()) {
+    /* free the live range of this register */
+    auto &regOpnd = static_cast<RegOperand&>(opnd);
+    SaveCalleeSavedReg(regOpnd);
+    if (insn.IsAtomicStore() || insn.IsSpecialIntrinsic()) {
+      /* remember the physical machine register assigned */
+      regno_t regNO = regOpnd.GetRegisterNumber();
+      rememberRegs.push_back(regInfo->IsVirtualRegister(regOpnd) ? regMap[regNO] : regNO);
+    } else if (!insn.IsCondDef()) {
+      uint32 id = GetRegLivenessId(regOpnd.GetRegisterNumber());
+      if (id != 0 && id <= insn.GetId()) {
+        ReleaseReg(regOpnd);
+      }
+    }
+    insn.SetOperand(idx, cgFunc->GetOpndBuilder()->CreatePReg(
+        regMap[regOpnd.GetRegisterNumber()], regOpnd.GetSize(), regOpnd.GetRegisterType()));
+    return;  /* already allocated */
+  }
+
+  if (opnd.IsRegister()) {
+    insn.SetOperand(idx, *AllocDestOpnd(opnd, insn));
+    SaveCalleeSavedReg(static_cast<RegOperand&>(opnd));
+  }
+}
+
+void DefaultO0RegAllocator::AllocHandleSrcList(Insn &insn, Operand &opnd, uint32 idx) {
+  if (!opnd.IsList()) {
+    return;
+  }
+  auto *listOpnds = &static_cast<ListOperand&>(opnd);
+  auto *listOpndsNew = &cgFunc->GetOpndBuilder()->CreateList();
+  for (auto *srcOpnd : listOpnds->GetOperands()) {
+    if (allocatedSet.find(srcOpnd) != allocatedSet.end()) {
+      auto *regOpnd = static_cast<RegOperand *>(srcOpnd);
+      regno_t reg = regMap[regOpnd->GetRegisterNumber()];
+      availRegSet[reg] = false;
+      (void)liveReg.insert(reg);  /* this register is live now */
+      listOpndsNew->PushOpnd(
+          cgFunc->GetOpndBuilder()->CreatePReg(reg, regOpnd->GetSize(), regOpnd->GetRegisterType()));
+      continue;  /* already allocated */
+    }
+    RegOperand *regOpnd = static_cast<RegOperand *>(AllocSrcOpnd(*srcOpnd));
+    CHECK_NULL_FATAL(regOpnd);
+    listOpndsNew->PushOpnd(*regOpnd);
+  }
+  insn.SetOperand(idx, *listOpndsNew);
+}
+
+void DefaultO0RegAllocator::AllocHandleSrc(Insn &insn, Operand &opnd, uint32 idx) {
+  if (allocatedSet.find(&opnd) != allocatedSet.end() && opnd.IsRegister()) {
+    auto *regOpnd = &static_cast<RegOperand&>(opnd);
+    regno_t reg = regMap[regOpnd->GetRegisterNumber()];
+    availRegSet[reg] = false;
+    (void)liveReg.insert(reg);  /* this register is live now */
+    insn.SetOperand(
+        idx, cgFunc->GetOpndBuilder()->CreatePReg(reg, regOpnd->GetSize(), regOpnd->GetRegisterType()));
+  } else {
+    Operand *srcOpnd = AllocSrcOpnd(opnd);
+    CHECK_NULL_FATAL(srcOpnd);
+    insn.SetOperand(idx, *srcOpnd);
+  }
+}
+
+bool DefaultO0RegAllocator::AllocateRegisters() {
+  InitAvailReg();
+  cgFunc->SetIsAfterRegAlloc();
+
+  FOR_ALL_BB_REV(bb, cgFunc) {
+    if (bb->IsEmpty()) {
+      continue;
+    }
+
+    SetupRegLiveness(bb);
+    FOR_BB_INSNS_REV(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+
+      /* handle inline assembly first due to specific def&use order */
+      if (insn->IsAsmInsn()) {
+        AllocHandleDestList(*insn, insn->GetOperand(kAsmClobberListOpnd), kAsmClobberListOpnd);
+        AllocHandleDestList(*insn, insn->GetOperand(kAsmOutputListOpnd), kAsmOutputListOpnd);
+        AllocHandleSrcList(*insn, insn->GetOperand(kAsmInputListOpnd), kAsmInputListOpnd);
+      }
+
+      const InsnDesc *curMd = insn->GetDesc();
+
+      for (uint32 i = 0; i < insn->GetOperandSize() && !insn->IsAsmInsn(); ++i) {  /* the dest registers */
+        Operand &opnd = insn->GetOperand(i);
+        if (!(opnd.IsRegister() && curMd->GetOpndDes(i)->IsDef())) {
+          continue;
+        }
+        if (opnd.IsList()) {
+          AllocHandleDestList(*insn, opnd, i);
+        } else {
+          AllocHandleDest(*insn, opnd, i);
+        }
+      }
+
+      for (uint32 i = 0; i < insn->GetOperandSize() && !insn->IsAsmInsn(); ++i) {  /* the src registers */
+        Operand &opnd = insn->GetOperand(i);
+        if (!((opnd.IsRegister() && curMd->GetOpndDes(i)->IsUse()) || opnd.IsMemoryAccessOperand())) {
+          continue;
+        }
+        if (opnd.IsList()) {
+          AllocHandleSrcList(*insn, opnd, i);
+        } else {
+          AllocHandleSrc(*insn, opnd, i);
+        }
+      }
+
+      /* hack. a better way to handle intrinsics? */
+      for (auto rememberReg : rememberRegs) {
+        ASSERT(rememberReg != regInfo->GetInvalidReg(), "not a valid register");
+        ReleaseReg(rememberReg);
+      }
+      rememberRegs.clear();
+    }
+  }
+  /*
+   * we store both FP/LR if using FP or if not using FP, but func has a call
+   * Using FP, record it for saving
+   * notice the order here : the first callee saved reg is expected to be RFP.
+   */
+  regInfo->Fini();
+  regInfo->SaveCalleeSavedReg(calleeSaveUsed);
+  return true;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/reg_alloc_lsra.cpp b/src/mapleall/maple_be/src/cg/reg_alloc_lsra.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fc6fe9957180f4a93d478e634901947279057a5f
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/reg_alloc_lsra.cpp
@@ -0,0 +1,2462 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "reg_alloc_lsra.h"
+#include <iomanip>
+#include <queue>
+#include <chrono>
+
+namespace maplebe {
+/*
+ * ==================
+ * = Linear Scan RA
+ * ==================
+ */
+#define LSRA_DUMP (CG_DEBUG_FUNC(*cgFunc))
+
+namespace {
+constexpr uint32 kSpilled = 1;
+constexpr uint32 kSpecialIntSpillReg = 16;
+constexpr uint32 kMinLiveIntervalLength = 20;
+constexpr uint32 kPrintedActiveListLength = 10;
+constexpr uint32 kMinRangesSize = 2;
+}
+
+static uint32 insnNumBeforRA = 0;
+
+#define IN_SPILL_RANGE                                                                                          \
+  (cgFunc->GetName().find(CGOptions::GetDumpFunc()) != std::string::npos && (++debugSpillCnt > 0) &&            \
+  (CGOptions::GetSpillRangesBegin() < debugSpillCnt) && (debugSpillCnt < CGOptions::GetSpillRangesEnd()))
+
+#undef LSRA_GRAPH
+
+#ifdef RA_PERF_ANALYSIS
+static long bfsUS = 0;
+static long liveIntervalUS = 0;
+static long holesUS = 0;
+static long lsraUS = 0;
+static long finalizeUS = 0;
+static long totalUS = 0;
+
+extern void printLSRATime() {
+  std::cout << "============================================================\n";
+  std::cout << "               LSRA sub-phase time information              \n";
+  std::cout << "============================================================\n";
+  std::cout << "BFS BB sorting cost: " << bfsUS << "us \n";
+  std::cout << "live interval computing cost: " << liveIntervalUS << "us \n";
+  std::cout << "live range approximation cost: " << holesUS << "us \n";
+  std::cout << "LSRA cost: " << lsraUS << "us \n";
+  std::cout << "finalize cost: " << finalizeUS << "us \n";
+  std::cout << "LSRA total cost: " << totalUS << "us \n";
+  std::cout << "============================================================\n";
+}
+#endif
+
+/*
+ * This LSRA implementation is an interpretation of the [Poletto97] paper.
+ * BFS BB ordering is used to order the instructions.  The live intervals are vased on
+ * this instruction order.  All vreg defines should come before an use, else a warning is
+ * given.
+ * Live interval is traversed in order from lower instruction order to higher order.
+ * When encountering a live interval for the first time, it is assumed to be live and placed
+ * inside the 'active' structure until the vreg's last access.  During the time a vreg
+ * is in 'active', the vreg occupies a physical register allocation and no other vreg can
+ * be allocated the same physical register.
+ */
+void LSRALinearScanRegAllocator::PrintRegSet(const MapleSet<uint32> &set, const std::string &str) const {
+  LogInfo::MapleLogger() << str;
+  for (auto reg : set) {
+    LogInfo::MapleLogger() << " " << reg;
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+bool LSRALinearScanRegAllocator::CheckForReg(Operand &opnd, const Insn &insn, const LiveInterval &li, regno_t regNO,
+                                             bool isDef) const {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  if (regOpnd.GetRegisterType() == kRegTyCc || regOpnd.GetRegisterType() == kRegTyVary) {
+    return false;
+  }
+  if (regOpnd.GetRegisterNumber() == regNO) {
+    LogInfo::MapleLogger() << "set object circle at " << insn.GetId() << "," << li.GetRegNO() <<
+                              " size 5 fillcolor rgb \"";
+    if (isDef) {
+      LogInfo::MapleLogger() << "black\"\n";
+    } else {
+      LogInfo::MapleLogger() << "orange\"\n";
+    }
+  }
+  return true;
+}
+
+/*
+ * This is a support routine to compute the overlapping live intervals in graph form.
+ * The output file can be viewed by gnuplot.
+ * Despite the function name of LiveRanges, it is using live intervals.
+ */
+void LSRALinearScanRegAllocator::PrintLiveRanges() const {
+  /* ================= Output to plot.pg =============== */
+  std::ofstream out("plot.pg");
+  CHECK_FATAL(out.is_open(), "Failed to open output file: plot.pg");
+  std::streambuf *coutBuf = LogInfo::MapleLogger().rdbuf();  /* old buf */
+  LogInfo::MapleLogger().rdbuf(out.rdbuf());                 /* new buf */
+
+  LogInfo::MapleLogger() << "#!/usr/bin/gnuplot\n";
+  LogInfo::MapleLogger() << "#maxInsnNum " << maxInsnNum << "\n";
+  LogInfo::MapleLogger() << "#minVregNum " << minVregNum << "\n";
+  LogInfo::MapleLogger() << "#maxVregNum " << maxVregNum << "\n";
+  LogInfo::MapleLogger() << "reset\nset terminal png\n";
+  LogInfo::MapleLogger() << "set xrange [1:" << maxInsnNum << "]\n";
+  LogInfo::MapleLogger() << "set grid\nset style data linespoints\n";
+  LogInfo::MapleLogger() << "set datafile missing '0'\n";
+  std::vector<std::vector<uint32>> graph;
+  graph.resize(maxVregNum);
+  for (uint32 i = 0; i < maxVregNum; ++i) {
+    graph[i].resize(maxInsnNum);
+  }
+  uint32 minY = 0xFFFFFFFF;
+  uint32 maxY = 0;
+  for (auto *li : liveIntervalsArray) {
+    if (li == nullptr || li->GetRegNO() == 0) {
+      continue;
+    }
+    uint32 regNO = li->GetRegNO();
+    if ((li->GetLastUse() - li->GetFirstDef()) < kMinLiveIntervalLength) {
+      continue;
+    }
+    if (regNO < minY) {
+      minY = regNO;
+    }
+    if (regNO > maxY) {
+      maxY = regNO;
+    }
+    uint32 n;
+    for (n = 0; n <= (li->GetFirstDef() - 1); ++n) {
+      graph[regNO - minVregNum][n] = 0;
+    }
+    if (li->GetLastUse() >= n) {
+      for (; n <= (li->GetLastUse() - 1); ++n) {
+        graph[regNO - minVregNum][n] = regNO;
+      }
+    }
+    for (; n < maxInsnNum; ++n) {
+      graph[regNO - minVregNum][n] = 0;
+    }
+
+    for (auto *bb : bfs->sortedBBs) {
+      FOR_BB_INSNS(insn, bb) {
+        const InsnDesc *md = insn->GetDesc();
+        uint32 opndNum = insn->GetOperandSize();
+        for (uint32 iSecond = 0; iSecond < opndNum; ++iSecond) {
+          Operand &opnd = insn->GetOperand(iSecond);
+          const OpndDesc *regProp = md->GetOpndDes(iSecond);
+          ASSERT(regProp != nullptr, "pointer is null in LSRALinearScanRegAllocator::PrintLiveRanges");
+          bool isDef = regProp->IsRegDef();
+          if (opnd.IsList()) {
+            auto &listOpnd = static_cast<ListOperand&>(opnd);
+            for (auto op : listOpnd.GetOperands()) {
+              (void)CheckForReg(*op, *insn, *li, regNO, isDef);
+            }
+          } else if (opnd.IsMemoryAccessOperand()) {
+            auto &memOpnd = static_cast<MemOperand&>(opnd);
+            Operand *base = memOpnd.GetBaseRegister();
+            Operand *offset = memOpnd.GetIndexRegister();
+            if (base != nullptr && !CheckForReg(*base, *insn, *li, regNO, false)) {
+              continue;
+            }
+            if (offset != nullptr && !CheckForReg(*offset, *insn, *li, regNO, false)) {
+              continue;
+            }
+          } else {
+            (void)CheckForReg(opnd, *insn, *li, regNO, isDef);
+          }
+        }
+      }
+    }
+  }
+  LogInfo::MapleLogger() << "set yrange [" << (minY - 1) << ":" << (maxY + 1) << "]\n";
+
+  LogInfo::MapleLogger() << "plot \"plot.dat\" using 1:2 title \"R" << minVregNum << "\"";
+  for (uint32 i = 1; i < ((maxVregNum - minVregNum) + 1); ++i) {
+    LogInfo::MapleLogger() << ", \\\n\t\"\" using 1:" << (i + kDivide2) << " title \"R" << (minVregNum + i) << "\"";
+  }
+  LogInfo::MapleLogger() << ";\n";
+
+  /* ================= Output to plot.dat =============== */
+  std::ofstream out2("plot.dat");
+  CHECK_FATAL(out2.is_open(), "Failed to open output file: plot.dat");
+  LogInfo::MapleLogger().rdbuf(out2.rdbuf());  /* new buf */
+  LogInfo::MapleLogger() << "##reg";
+  for (uint32 i = minVregNum; i <= maxVregNum; ++i) {
+    LogInfo::MapleLogger() << " R" << i;
+  }
+  LogInfo::MapleLogger() << "\n";
+  for (uint32 n = 0; n < maxInsnNum; ++n) {
+    LogInfo::MapleLogger() << (n + 1);
+    for (uint32 i = minVregNum; i <= maxVregNum; ++i) {
+      LogInfo::MapleLogger() << " " << graph[i - minVregNum][n];
+    }
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger().rdbuf(coutBuf);
+}
+
+void LSRALinearScanRegAllocator::PrintLiveInterval(const LiveInterval &li, const std::string &str) const {
+  LogInfo::MapleLogger() << str << "\n";
+  if (li.GetIsCall() != nullptr) {
+    LogInfo::MapleLogger() << " firstDef " << li.GetFirstDef();
+    LogInfo::MapleLogger() << " isCall";
+  } else if (li.GetPhysUse() > 0) {
+    LogInfo::MapleLogger() << "\tregNO " << li.GetRegNO();
+    LogInfo::MapleLogger() << " firstDef " << li.GetFirstDef();
+    LogInfo::MapleLogger() << " physUse " << li.GetPhysUse();
+    LogInfo::MapleLogger() << " endByCall " << li.IsEndByCall();
+  } else {
+    /* show regno/firstDef/lastUse with 5/8/8 width respectively */
+    LogInfo::MapleLogger() << "\tregNO " << std::setw(5) << li.GetRegNO();
+    LogInfo::MapleLogger() << " firstDef " << std::setw(8) << li.GetFirstDef();
+    LogInfo::MapleLogger() << " lastUse " << std::setw(8) << li.GetLastUse();
+    LogInfo::MapleLogger() << " assigned " << li.GetAssignedReg();
+    LogInfo::MapleLogger() << " refCount " << li.GetRefCount();
+    LogInfo::MapleLogger() << " priority " << li.GetPriority();
+  }
+  LogInfo::MapleLogger() << " object_address 0x" << std::hex << &li << std::dec << "\n";
+}
+
+void LSRALinearScanRegAllocator::PrintParamQueue(const std::string &str) {
+  LogInfo::MapleLogger() << str << "\n";
+  for (SingleQue &que : intParamQueue) {
+    if (que.empty()) {
+      continue;
+    }
+    LiveInterval *li = que.front();
+    LiveInterval *last = que.back();
+    PrintLiveInterval(*li, "");
+    while (li != last) {
+      que.pop_front();
+      que.push_back(li);
+      li = que.front();
+      PrintLiveInterval(*li, "");
+    }
+    que.pop_front();
+    que.push_back(li);
+  }
+}
+
+void LSRALinearScanRegAllocator::PrintCallQueue(const std::string &str) const {
+  LogInfo::MapleLogger() << str << "\n";
+  for (auto *li : callList) {
+    PrintLiveInterval(*li, "");
+  }
+}
+
+void LSRALinearScanRegAllocator::PrintActiveList(const std::string &str, uint32 len) const {
+  uint32 count = 0;
+  LogInfo::MapleLogger() << str << " " << active.size() << "\n";
+  for (auto *li : active) {
+    PrintLiveInterval(*li, "");
+    ++count;
+    if ((len != 0) && (count == len)) {
+      break;
+    }
+  }
+}
+
+void LSRALinearScanRegAllocator::PrintActiveListSimple() const {
+  for (const auto *li : active) {
+    uint32 assignedReg = li->GetAssignedReg();
+    if (li->GetStackSlot() == kSpilled) {
+      assignedReg = kSpecialIntSpillReg;
+    }
+    LogInfo::MapleLogger() << li->GetRegNO() << "(" << assignedReg << ", ";
+    if (li->GetPhysUse() > 0) {
+      LogInfo::MapleLogger() << "p) ";
+    } else {
+      LogInfo::MapleLogger() << li->GetFirstAcrossedCall();
+    }
+    LogInfo::MapleLogger() << "<" << li->GetFirstDef() << "," << li->GetLastUse() << ">) ";
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void LSRALinearScanRegAllocator::PrintLiveIntervals() const {
+  /* vreg LogInfo */
+  for (auto *li : liveIntervalsArray) {
+    if (li == nullptr || li->GetRegNO() == 0) {
+      continue;
+    }
+    PrintLiveInterval(*li, "");
+  }
+  LogInfo::MapleLogger() << "\n";
+  /* preg LogInfo */
+  for (auto param : intParamQueue) {
+    for (auto *li : param) {
+      if (li == nullptr || li->GetRegNO() == 0) {
+        continue;
+      }
+      PrintLiveInterval(*li, "");
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void LSRALinearScanRegAllocator::DebugCheckActiveList() const {
+  LiveInterval *prev = nullptr;
+  for (auto *li : active) {
+    if (prev != nullptr) {
+      if ((li->GetRegNO() <= regInfo->GetLastParamsFpReg()) && (prev->GetRegNO() > regInfo->GetLastParamsFpReg())) {
+        if (li->GetFirstDef() < prev->GetFirstDef()) {
+          LogInfo::MapleLogger() << "ERRer: active list with out of order phys + vreg\n";
+          PrintLiveInterval(*prev, "prev");
+          PrintLiveInterval(*li, "current");
+          PrintActiveList("Active", kPrintedActiveListLength);
+        }
+      }
+      if ((li->GetRegNO() <= regInfo->GetLastParamsFpReg()) && (prev->GetRegNO() <= regInfo->GetLastParamsFpReg())) {
+        if (li->GetFirstDef() < prev->GetFirstDef()) {
+          LogInfo::MapleLogger() << "ERRer: active list with out of order phys reg use\n";
+          PrintLiveInterval(*prev, "prev");
+          PrintLiveInterval(*li, "current");
+          PrintActiveList("Active", kPrintedActiveListLength);
+        }
+      }
+    } else {
+      prev = li;
+    }
+  }
+}
+
+/*
+ * Prepare the free physical register pool for allocation.
+ * When a physical register is allocated, it is removed from the pool.
+ * The physical register is re-inserted into the pool when the associated live
+ * interval has ended.
+ */
+void LSRALinearScanRegAllocator::InitFreeRegPool() {
+  for (regno_t regNO = regInfo->GetInvalidReg(); regNO < regInfo->GetAllRegNum(); ++regNO) {
+    if (!regInfo->IsAvailableReg(regNO)) {
+      continue;
+    }
+    if (regInfo->IsGPRegister(regNO)) {
+      if (regInfo->IsYieldPointReg(regNO)) {
+        continue;
+      }
+      /* ExtraSpillReg */
+      if (regInfo->IsSpillRegInRA(regNO, needExtraSpillReg)) {
+        intSpillRegSet.push_back(regNO - firstIntReg);
+        continue;
+      }
+      if (regInfo->IsPreAssignedReg(regNO)) {
+        /* Parameters/Return registers */
+        (void)intParamRegSet.insert(regNO - firstIntReg);
+        intParamMask |= 1u << (regNO - firstIntReg);
+      } else if (regInfo->IsCalleeSavedReg(regNO)) {
+        /* callee-saved registers */
+        (void)intCalleeRegSet.insert(regNO - firstIntReg);
+        intCalleeMask |= 1u << (regNO - firstIntReg);
+      } else {
+        /* caller-saved registers */
+        (void)intCallerRegSet.insert(regNO - firstIntReg);
+        intCallerMask |= 1u << (regNO - firstIntReg);
+      }
+    } else {
+      /* fp ExtraSpillReg */
+      if (regInfo->IsSpillRegInRA(regNO, needExtraSpillReg)) {
+        fpSpillRegSet.push_back(regNO - firstFpReg);
+        continue;
+      }
+      if (regInfo->IsPreAssignedReg(regNO)) {
+        /* fp Parameters/Return registers */
+        (void)fpParamRegSet.insert(regNO - firstFpReg);
+        fpParamMask |= 1u << (regNO - firstFpReg);
+      } else if (regInfo->IsCalleeSavedReg(regNO)) {
+        /* fp callee-saved registers */
+        (void)fpCalleeRegSet.insert(regNO - firstFpReg);
+        fpCalleeMask |= 1u << (regNO - firstFpReg);
+      } else {
+        /* fp caller-saved registers */
+        (void)fpCallerRegSet.insert(regNO - firstFpReg);
+        fpCallerMask |= 1u << (regNO - firstFpReg);
+      }
+    }
+  }
+
+  if (LSRA_DUMP) {
+    PrintRegSet(intCallerRegSet, "ALLOCATABLE_INT_CALLER");
+    PrintRegSet(intCalleeRegSet, "ALLOCATABLE_INT_CALLEE");
+    PrintRegSet(intParamRegSet, "ALLOCATABLE_INT_PARAM");
+    PrintRegSet(fpCallerRegSet, "ALLOCATABLE_FP_CALLER");
+    PrintRegSet(fpCalleeRegSet, "ALLOCATABLE_FP_CALLEE");
+    PrintRegSet(fpParamRegSet, "ALLOCATABLE_FP_PARAM");
+    LogInfo::MapleLogger() << "INT_SPILL_REGS";
+    for (uint32 intSpillRegNO : intSpillRegSet) {
+      LogInfo::MapleLogger() << " " << intSpillRegNO;
+    }
+    LogInfo::MapleLogger() << "\n";
+    LogInfo::MapleLogger() << "FP_SPILL_REGS";
+    for (uint32 fpSpillRegNO : fpSpillRegSet) {
+      LogInfo::MapleLogger() << " " << fpSpillRegNO;
+    }
+    LogInfo::MapleLogger() << "\n";
+    LogInfo::MapleLogger() << std::hex;
+    LogInfo::MapleLogger() << "INT_CALLER_MASK " << intCallerMask << "\n";
+    LogInfo::MapleLogger() << "INT_CALLEE_MASK " << intCalleeMask << "\n";
+    LogInfo::MapleLogger() << "INT_PARAM_MASK " << intParamMask << "\n";
+    LogInfo::MapleLogger() << "FP_CALLER_FP_MASK " << fpCallerMask << "\n";
+    LogInfo::MapleLogger() << "FP_CALLEE_FP_MASK " << fpCalleeMask << "\n";
+    LogInfo::MapleLogger() << "FP_PARAM_FP_MASK " << fpParamMask << "\n";
+    LogInfo::MapleLogger() << std::dec;
+  }
+}
+
+/* Remember calls for caller/callee allocation. */
+void LSRALinearScanRegAllocator::RecordCall(Insn &insn) {
+  /* Maintain call at the beginning of active list */
+  auto *li = memPool->New<LiveInterval>(alloc);
+  li->SetFirstDef(insn.GetId());
+  li->SetIsCall(insn);
+  callList.push_back(li);
+}
+
+void LSRALinearScanRegAllocator::RecordPhysRegs(const RegOperand &regOpnd, uint32 insnNum, bool isDef) {
+  RegType regType = regOpnd.GetRegisterType();
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  if (regType == kRegTyCc || regType == kRegTyVary) {
+    return;
+  }
+  if (regInfo->IsUntouchableReg(regNO)) {
+    return;
+  }
+  if (!regInfo->IsPreAssignedReg(regNO)) {
+    return;
+  }
+  if (isDef) {
+    /* parameter/return register def is assumed to be live until a call. */
+    auto *li = memPool->New<LiveInterval>(alloc);
+    li->SetRegNO(regNO);
+    li->SetRegType(regType);
+    li->SetStackSlot(0xFFFFFFFF);
+    li->SetFirstDef(insnNum);
+    li->SetPhysUse(insnNum);
+    li->SetAssignedReg(regNO);
+
+    if (regType == kRegTyInt) {
+      intParamQueue[regInfo->GetIntParamRegIdx(regNO)].push_back(li);
+    } else {
+      fpParamQueue[regInfo->GetFpParamRegIdx(regNO)].push_back(li);
+    }
+  } else {
+    if (regType == kRegTyInt) {
+      CHECK_FATAL(!intParamQueue[regInfo->GetIntParamRegIdx(regNO)].empty(),
+          "was not defined before use, impossible");
+      LiveInterval *li = intParamQueue[regInfo->GetIntParamRegIdx(regNO)].back();
+      li->SetPhysUse(insnNum);
+    } else {
+      CHECK_FATAL(!fpParamQueue[regInfo->GetFpParamRegIdx(regNO)].empty(),
+          "was not defined before use, impossible");
+      LiveInterval *li = fpParamQueue[regInfo->GetFpParamRegIdx(regNO)].back();
+      li->SetPhysUse(insnNum);
+    }
+  }
+}
+
+void LSRALinearScanRegAllocator::UpdateLiveIntervalState(const BB &bb, LiveInterval &li) const {
+  if (bb.IsCatch()) {
+    li.SetInCatchState();
+  } else {
+    li.SetNotInCatchState();
+  }
+
+  if (bb.GetInternalFlag1() != 0) {
+    li.SetInCleanupState();
+  } else {
+    li.SetNotInCleanupState(bb.GetId() == 1);
+  }
+}
+
+/* main entry function for live interval computation. */
+void LSRALinearScanRegAllocator::SetupLiveInterval(Operand &opnd, Insn &insn, bool isDef, uint32 &nUses) {
+  if (!opnd.IsRegister()) {
+    return;
+  }
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  uint32 insnNum = insn.GetId();
+  if (regOpnd.IsPhysicalRegister()) {
+    RecordPhysRegs(regOpnd, insnNum, isDef);
+    return;
+  }
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType == kRegTyCc || regType == kRegTyVary) {
+    return;
+  }
+
+  LiveInterval *li = nullptr;
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  if (liveIntervalsArray[regNO] == nullptr) {
+    li = memPool->New<LiveInterval>(alloc);
+    li->SetRegNO(regNO);
+    li->SetStackSlot(0xFFFFFFFF);
+    liveIntervalsArray[regNO] = li;
+  } else {
+    li = liveIntervalsArray[regNO];
+  }
+  li->SetRegType(regType);
+
+  BB *curBB = insn.GetBB();
+  if (isDef) {
+    /* never set to 0 before, why consider this condition ? */
+    if (li->GetFirstDef() == 0) {
+      li->SetFirstDef(insnNum);
+      li->SetLastUse(insnNum + 1);
+    } else if (!curBB->IsUnreachable()) {
+      if (li->GetLastUse() < insnNum || li->IsUseBeforeDef()) {
+        li->SetLastUse(insnNum + 1);
+      }
+    }
+    /*
+     * try-catch related
+     *   Not set when extending live interval with bb's livein in ComputeLiveInterval.
+     */
+    li->SetResultCount(li->GetResultCount() + 1);
+  } else {
+    if (li->GetFirstDef() == 0) {
+      ASSERT(false, "SetupLiveInterval: use before def");
+    }
+    /*
+     * In ComputeLiveInterval when extending live interval using
+     * live-out information, li created does not have a type.
+     */
+    if (!curBB->IsUnreachable()) {
+      li->SetLastUse(insnNum);
+    }
+    ++nUses;
+  }
+  UpdateLiveIntervalState(*curBB, *li);
+
+  li->SetRefCount(li->GetRefCount() + 1);
+
+  uint32 index = regNO / (sizeof(uint64) * k8ByteSize);
+  uint64 bit = regNO % (sizeof(uint64) * k8ByteSize);
+  if ((regUsedInBB[index] & (static_cast<uint64>(1) << bit)) != 0) {
+    li->SetMultiUseInBB(true);
+  }
+  regUsedInBB[index] |= (static_cast<uint64>(1) << bit);
+
+  if (minVregNum > regNO) {
+    minVregNum = regNO;
+  }
+  if (maxVregNum < regNO) {
+    maxVregNum = regNO;
+  }
+
+  /* setup the def/use point for it */
+  ASSERT(regNO < liveIntervalsArray.size(), "out of range of vector liveIntervalsArray");
+}
+
+/*
+ * Support 'hole' in LSRA.
+ * For a live interval, there might be multiple segments of live ranges,
+ * and between these segments a 'hole'.
+ * Some other short lived vreg can go into these 'holes'.
+ *
+ * from : starting instruction sequence id
+ * to   : ending instruction sequence id
+ */
+void LSRALinearScanRegAllocator::LiveInterval::AddRange(uint32 from, uint32 to) {
+  if (ranges.empty()) {
+    ranges.push_back(std::pair<uint32, uint32>(from, to));
+  } else {
+    if (to < ranges.front().first) {
+      (void)ranges.insert(ranges.cbegin(), std::pair<uint32, uint32>(from, to));
+    } else if (to >= ranges.front().second && from < ranges.front().first) {
+      ranges.front().first = from;
+      ranges.front().second = to;
+    } else if (to >= ranges.front().first && from < ranges.front().first) {
+      ranges.front().first = from;
+    } else if (from > ranges.front().second) {
+      ASSERT(false, "No possible on reverse traverse.");
+    }
+  }
+}
+
+void LSRALinearScanRegAllocator::LiveInterval::AddUsePos(uint32 pos) {
+  (void)usePositions.insert(pos);
+}
+
+/* See if a vreg can fit in one of the holes of a longer live interval. */
+uint32 LSRALinearScanRegAllocator::FillInHole(LiveInterval &li) {
+  MapleSet<LiveInterval*, ActiveCmp>::iterator it;
+  for (it = active.begin(); it != active.end(); ++it) {
+    auto *ili = static_cast<LiveInterval*>(*it);
+
+    /*
+     * If ili is part in cleanup, the hole info will be not correct,
+     * since cleanup bb do not have edge to normal func bb, and the
+     * live-out info will not correct.
+     */
+    if (!ili->IsAllOutCleanup() || ili->IsInCatch()) {
+      continue;
+    }
+
+    if (ili->GetRegType() != li.GetRegType() || ili->GetStackSlot() != 0xFFFFFFFF || ili->GetLiChild() != nullptr ||
+        ili->GetAssignedReg() == 0) {
+      continue;
+    }
+    for (const auto &inner : ili->GetHoles()) {
+      if (inner.first <= li.GetFirstDef() && inner.second >= li.GetLastUse()) {
+        ili->SetLiChild(&li);
+        li.SetLiParent(ili);
+        li.SetAssignedReg(ili->GetAssignedReg());
+        /* If assigned physical register is callee save register, set shouldSave false; */
+        regno_t phyReg = regInfo->GetInvalidReg();
+        if (li.GetRegType() == kRegTyInt || li.GetRegType() == kRegTyFloat) {
+          phyReg = li.GetAssignedReg();
+        } else {
+          ASSERT(false, "FillInHole, Invalid register type");
+        }
+
+        if (regInfo->IsAvailableReg(phyReg) && regInfo->IsCalleeSavedReg(phyReg)) {
+          li.SetShouldSave(false);
+        }
+        return ili->GetAssignedReg();
+      } else if (inner.first > li.GetLastUse()) {
+        break;
+      }
+    }
+  }
+  return 0;
+}
+
+void LSRALinearScanRegAllocator::SetupIntervalRangesByOperand(Operand &opnd, const Insn &insn, uint32 blockFrom,
+                                                              bool isDef, bool isUse) {
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType != kRegTyCc && regType != kRegTyVary) {
+    regno_t regNO = regOpnd.GetRegisterNumber();
+    if (regNO > regInfo->GetAllRegNum()) {
+      if (isDef) {
+        if (!liveIntervalsArray[regNO]->GetRanges().empty()) {
+          liveIntervalsArray[regNO]->GetRanges().front().first = insn.GetId();
+          liveIntervalsArray[regNO]->UsePositionsInsert(insn.GetId());
+        }
+      }
+      if (isUse) {
+        liveIntervalsArray[regNO]->AddRange(blockFrom, insn.GetId());
+        liveIntervalsArray[regNO]->UsePositionsInsert(insn.GetId());
+      }
+    }
+  }
+}
+
+void LSRALinearScanRegAllocator::BuildIntervalRangesForEachOperand(const Insn &insn, uint32 blockFrom) {
+  const InsnDesc *md = insn.GetDesc();
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      Operand *base = memOpnd.GetBaseRegister();
+      Operand *offset = memOpnd.GetIndexRegister();
+      if (base != nullptr && base->IsRegister()) {
+        SetupIntervalRangesByOperand(*base, insn, blockFrom, false, true);
+      }
+      if (offset != nullptr && offset->IsRegister()) {
+        SetupIntervalRangesByOperand(*offset, insn, blockFrom, false, true);
+      }
+    } else if (opnd.IsRegister()) {
+      const OpndDesc *regProp = md->GetOpndDes(i);
+      ASSERT(regProp != nullptr, "pointer is null in LSRALinearScanRegAllocator::BuildIntervalRangesForEachOperand");
+      bool isDef = regProp->IsRegDef();
+      bool isUse = regProp->IsRegUse();
+      SetupIntervalRangesByOperand(opnd, insn, blockFrom, isDef, isUse);
+    }
+  }
+}
+
+/* Support finding holes by searching for ranges where holes exist. */
+void LSRALinearScanRegAllocator::BuildIntervalRanges() {
+  size_t bbIdx = bfs->sortedBBs.size();
+  if (bbIdx == 0) {
+    return;
+  }
+
+  do {
+    --bbIdx;
+    BB *bb = bfs->sortedBBs[bbIdx];
+    if (bb->GetFirstInsn() == nullptr || bb->GetLastInsn() == nullptr) {
+      continue;
+    }
+    uint32 blockFrom = bb->GetFirstInsn()->GetId();
+    uint32 blockTo = bb->GetLastInsn()->GetId() + 1;
+
+    for (auto regNO : bb->GetLiveOutRegNO()) {
+      if (regNO < regInfo->GetAllRegNum()) {
+        /* Do not consider physical regs. */
+        continue;
+      }
+      liveIntervalsArray[regNO]->AddRange(blockFrom, blockTo);
+    }
+
+    FOR_BB_INSNS_REV(insn, bb) {
+      BuildIntervalRangesForEachOperand(*insn, blockFrom);
+    }
+  } while (bbIdx != 0);
+
+  /* Build holes. */
+  for (uint32 i = 0; i < cgFunc->GetMaxVReg(); ++i) {
+    LiveInterval *li = liveIntervalsArray[i];
+    if (li == nullptr) {
+      continue;
+    }
+    if (li->GetRangesSize() < kMinRangesSize) {
+      continue;
+    }
+
+    auto it = li->GetRanges().begin();
+    auto itPrev = it++;
+    for (; it != li->GetRanges().end(); ++it) {
+      if (((*it).first - (*itPrev).second) > kMinRangesSize) {
+        li->HolesPushBack((*itPrev).second, (*it).first);
+      }
+      itPrev = it;
+    }
+  }
+}
+
+/* Extend live interval with live-in info */
+void LSRALinearScanRegAllocator::UpdateLiveIntervalByLiveIn(const BB &bb, uint32 insnNum) {
+  for (const auto &regNO : bb.GetLiveInRegNO()) {
+    if (regNO < regInfo->GetAllRegNum()) {
+      /* Do not consider physical regs. */
+      continue;
+    }
+    LiveInterval *liOuter = liveIntervalsArray[regNO];
+    if (liOuter != nullptr || (bb.IsEmpty() && bb.GetId() != 1)) {
+      continue;
+    }
+    /*
+    * try-catch related
+    *   Since it is livein but not seen before, its a use before def
+    *   spill it temporarily
+    */
+    auto *li = memPool->New<LiveInterval>(alloc);
+    li->SetRegNO(regNO);
+    li->SetStackSlot(kSpilled);
+    liveIntervalsArray[regNO] = li;
+    li->SetFirstDef(insnNum);
+    li->SetUseBeforeDef(true);
+
+    if (!bb.IsUnreachable()) {
+      if (bb.GetId() != 1) {
+        LogInfo::MapleLogger() << "ERROR: " << regNO << " use before def in bb " << bb.GetId() << " : " <<
+            cgFunc->GetName() << "\n";
+        ASSERT(false, "There should only be [use before def in bb 1], temporarily.");
+      }
+      LogInfo::MapleLogger() << "WARNING: " << regNO << " use before def in bb " << bb.GetId() << " : " <<
+          cgFunc->GetName() << "\n";
+    }
+    UpdateLiveIntervalState(bb, *li);
+  }
+}
+
+/*  traverse live in regNO, for each live in regNO create a new liveinterval */
+void LSRALinearScanRegAllocator::UpdateParamLiveIntervalByLiveIn(const BB &bb, uint32 insnNum) {
+  for (const auto &regNO : bb.GetLiveInRegNO()) {
+    if (!regInfo->IsPreAssignedReg(regNO)) {
+      continue;
+    }
+    auto *li = memPool->New<LiveInterval>(alloc);
+    li->SetRegNO(regNO);
+    li->SetStackSlot(0xFFFFFFFF);
+    li->SetFirstDef(insnNum);
+    li->SetPhysUse(insnNum);
+    li->SetAssignedReg(regNO);
+
+    if (regInfo->IsGPRegister(regNO)) {
+      li->SetRegType(kRegTyInt);
+      intParamQueue[regInfo->GetIntParamRegIdx(regNO)].push_back(li);
+    } else {
+      li->SetRegType(kRegTyFloat);
+      fpParamQueue[regInfo->GetFpParamRegIdx(regNO)].push_back(li);
+    }
+  }
+}
+
+void LSRALinearScanRegAllocator::ComputeLiveIn(BB &bb, uint32 insnNum) {
+  UpdateLiveIntervalByLiveIn(bb, insnNum);
+
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "bb(" << bb.GetId() << ")LIVEOUT:";
+    for (const auto &liveOutRegNO : bb.GetLiveOutRegNO()) {
+      LogInfo::MapleLogger() << " " << liveOutRegNO;
+    }
+    LogInfo::MapleLogger() << ".\n";
+    LogInfo::MapleLogger() << "bb(" << bb.GetId() << ")LIVEIN:";
+    for (const auto &liveInRegNO : bb.GetLiveInRegNO()) {
+      LogInfo::MapleLogger() << " " << liveInRegNO;
+    }
+    LogInfo::MapleLogger() << ".\n";
+  }
+
+  regUsedInBBSz = (cgFunc->GetMaxVReg() / (sizeof(uint64) * k8ByteSize) + 1);
+  regUsedInBB = new uint64[regUsedInBBSz];
+  CHECK_FATAL(regUsedInBB != nullptr, "alloc regUsedInBB memory failure.");
+  errno_t ret = memset_s(regUsedInBB, regUsedInBBSz * sizeof(uint64), 0, regUsedInBBSz * sizeof(uint64));
+  if (ret != EOK) {
+    CHECK_FATAL(false, "call memset_s failed in LSRALinearScanRegAllocator::ComputeLiveInterval()");
+  }
+
+  if (bb.GetFirstInsn() == nullptr) {
+    return;
+  }
+  if (!bb.GetEhPreds().empty()) {
+    bb.InsertLiveInRegNO(firstIntReg);
+    bb.InsertLiveInRegNO(firstIntReg + 1);
+  }
+  UpdateParamLiveIntervalByLiveIn(bb, insnNum);
+  if (!bb.GetEhPreds().empty()) {
+    bb.EraseLiveInRegNO(firstIntReg);
+    bb.EraseLiveInRegNO(firstIntReg + 1);
+  }
+}
+
+void LSRALinearScanRegAllocator::ComputeLiveOut(BB &bb, uint32 insnNum) {
+  /*
+   *  traverse live out regNO
+   *  for each live out regNO if the last corresponding live interval is created within this bb
+   *  update this lastUse of li to the end of BB
+   */
+  for (const auto &regNO : bb.GetLiveOutRegNO()) {
+    if (regInfo->IsPreAssignedReg(static_cast<regno_t>(regNO))) {
+      LiveInterval *liOut = nullptr;
+      if (regInfo->IsGPRegister(regNO)) {
+        if (intParamQueue[regInfo->GetIntParamRegIdx(regNO)].empty()) {
+          continue;
+        }
+        liOut = intParamQueue[regInfo->GetIntParamRegIdx(regNO)].back();
+        if (bb.GetFirstInsn() && liOut->GetFirstDef() >= bb.GetFirstInsn()->GetId()) {
+          liOut->SetPhysUse(insnNum);
+        }
+      } else {
+        if (fpParamQueue[regInfo->GetFpParamRegIdx(regNO)].empty()) {
+          continue;
+        }
+        liOut = fpParamQueue[regInfo->GetFpParamRegIdx(regNO)].back();
+        if (bb.GetFirstInsn() && liOut->GetFirstDef() >= bb.GetFirstInsn()->GetId()) {
+          liOut->SetPhysUse(insnNum);
+        }
+      }
+    }
+    /* Extend live interval with live-out info */
+    LiveInterval *li = liveIntervalsArray[regNO];
+    if (li != nullptr && !bb.IsEmpty()) {
+      li->SetLastUse(bb.GetLastInsn()->GetId());
+      UpdateLiveIntervalState(bb, *li);
+    }
+  }
+}
+
+void LSRALinearScanRegAllocator::ComputeLiveIntervalForEachOperand(Insn &insn) {
+  uint32 numUses = 0;
+  const InsnDesc *md = insn.GetDesc();
+  uint32 opndNum = insn.GetOperandSize();
+  /*
+   * we need to process src opnd first just in case the src/dest vreg are the same and the src vreg belongs to the
+   * last interval.
+   */
+  for (int32 i = opndNum - 1; i >= 0; --i) {
+    Operand &opnd = insn.GetOperand(static_cast<uint32>(i));
+    const OpndDesc *opndDesc = md->GetOpndDes(i);
+    ASSERT(opndDesc != nullptr, "ptr null check.");
+    if (opnd.IsList()) {
+      auto &listOpnd = static_cast<const ListOperand&>(opnd);
+      for (auto &op : listOpnd.GetOperands()) {
+        SetupLiveInterval(*op, insn, opndDesc->IsDef(), numUses);
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      bool isDef = false;
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      Operand *base = memOpnd.GetBaseRegister();
+      Operand *offset = memOpnd.GetIndexRegister();
+      if (base != nullptr) {
+        SetupLiveInterval(*base, insn, isDef, numUses);
+      }
+      if (offset != nullptr) {
+        SetupLiveInterval(*offset, insn, isDef, numUses);
+      }
+    } else {
+      /* Specifically, the "use-def" opnd is treated as a "use" opnd */
+      bool isUse = opndDesc->IsRegUse();
+      SetupLiveInterval(opnd, insn, !isUse, numUses);
+    }
+  }
+  if (numUses >= regInfo->GetNormalUseOperandNum()) {
+    needExtraSpillReg = true;
+  }
+}
+
+void LSRALinearScanRegAllocator::ComputeLiveInterval() {
+  calleeUseCnt.resize(regInfo->GetAllRegNum());
+  liveIntervalsArray.resize(cgFunc->GetMaxVReg());
+  /* LiveInterval queue for each param/return register */
+  lastIntParamLi.resize(regInfo->GetIntRegsParmsNum());
+  lastFpParamLi.resize(regInfo->GetFloatRegsParmsNum());
+  uint32 insnNum = 1;
+  for (BB *bb : bfs->sortedBBs) {
+    ComputeLiveIn(*bb, insnNum);
+    FOR_BB_INSNS(insn, bb) {
+      insn->SetId(insnNum);
+      /* skip comment and debug insn */
+      if (insn->IsImmaterialInsn() || !insn->IsMachineInstruction()) {
+        continue;
+      }
+      /* RecordCall */
+      if (insn->IsCall()) {
+        if (!insn->GetIsThrow() || !bb->GetEhSuccs().empty()) {
+          RecordCall(*insn);
+        }
+      }
+
+      ComputeLiveIntervalForEachOperand(*insn);
+
+      /* handle return value for call insn */
+      if (insn->IsCall()) {
+        /* For all backend architectures so far, adopt all RetRegs as Def via this insn,
+         * and then their live begins.
+         * next optimization, you can determine which registers are actually used.
+         */
+        RegOperand *retReg = nullptr;
+        if (insn->GetRetType() == Insn::kRegInt) {
+          for (int i = 0; i < regInfo->GetIntRetRegsNum(); i++) {
+            retReg = regInfo->GetOrCreatePhyRegOperand(regInfo->GetIntRetReg(i),
+                k64BitSize, kRegTyInt);
+            RecordPhysRegs(*retReg, insnNum, true);
+          }
+        } else {
+          for (int i = 0; i < regInfo->GetFpRetRegsNum(); i++) {
+            retReg = regInfo->GetOrCreatePhyRegOperand(regInfo->GetFpRetReg(i),
+                k64BitSize, kRegTyFloat);
+            RecordPhysRegs(*retReg, insnNum, true);
+          }
+        }
+      }
+      ++insnNum;
+    }
+
+    ComputeLiveOut(*bb, insnNum);
+
+    delete[] regUsedInBB;
+    regUsedInBB = nullptr;
+    maxInsnNum = insnNum - 1;  /* insn_num started from 1 */
+  }
+
+  for (auto *li : liveIntervalsArray) {
+    if (li == nullptr || li->GetRegNO() == 0) {
+      continue;
+    }
+    if (li->GetIsCall() != nullptr || (li->GetPhysUse() > 0)) {
+      continue;
+    }
+    if (li->GetLastUse() > li->GetFirstDef()) {
+      li->SetPriority(static_cast<float>(li->GetRefCount()) /
+          static_cast<float>(li->GetLastUse() - li->GetFirstDef()));
+    } else {
+      li->SetPriority(static_cast<float>(li->GetRefCount()) /
+          static_cast<float>(li->GetFirstDef() - li->GetLastUse()));
+    }
+  }
+
+  if (LSRA_DUMP) {
+    PrintLiveIntervals();
+  }
+
+}
+
+/* A physical register is freed at the end of the live interval.  Return to pool. */
+void LSRALinearScanRegAllocator::ReturnPregToSet(const LiveInterval &li, uint32 preg) {
+  if (preg == 0) {
+    return;
+  }
+  if (li.GetRegType() == kRegTyInt) {
+    preg -= firstIntReg;
+  } else if (li.GetRegType() == kRegTyFloat) {
+    preg -= firstFpReg;
+  } else {
+    ASSERT(false, "ReturnPregToSet: Invalid reg type");
+  }
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "\trestoring preg " << preg << " as allocatable\n";
+  }
+  uint32 mask = 1u << preg;
+  if (preg == kSpecialIntSpillReg && li.GetStackSlot() == 0xFFFFFFFF) {
+    /* this reg is temporary used for liveinterval which lastUse-firstDef == 1 */
+    return;
+  }
+  if (li.GetRegType() == kRegTyInt) {
+    if ((intCallerMask & mask) > 0) {
+      (void)intCallerRegSet.insert(preg);
+    } else if ((intCalleeMask & mask) > 0) {
+      (void)intCalleeRegSet.insert(preg);
+    } else if ((intParamMask & mask) > 0) {
+      (void)intParamRegSet.insert(preg);
+    } else {
+      ASSERT(false, "ReturnPregToSet: Unknown caller/callee type");
+    }
+  } else if ((fpCallerMask & mask) > 0) {
+    (void)fpCallerRegSet.insert(preg);
+  } else if ((fpCalleeMask & mask) > 0) {
+    (void)fpCalleeRegSet.insert(preg);
+  } else if ((fpParamMask & mask) > 0) {
+    (void)fpParamRegSet.insert(preg);
+  } else {
+    ASSERT(false, "ReturnPregToSet invalid physical register");
+  }
+}
+
+/* A physical register is removed from allocation as it is assigned. */
+void LSRALinearScanRegAllocator::ReleasePregToSet(const LiveInterval &li, uint32 preg) {
+  if (preg == 0) {
+    return;
+  }
+  if (li.GetRegType() == kRegTyInt) {
+    preg -= firstIntReg;
+  } else if (li.GetRegType() == kRegTyFloat) {
+    preg -= firstFpReg;
+  } else {
+    ASSERT(false, "ReleasePregToSet: Invalid reg type");
+  }
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "\treleasing preg " << preg << " as allocatable\n";
+  }
+  uint32 mask = 1u << preg;
+  if (preg == kSpecialIntSpillReg && li.GetStackSlot() == 0xFFFFFFFF) {
+    /* this reg is temporary used for liveinterval which lastUse-firstDef == 1 */
+    return;
+  }
+  if (li.GetRegType() == kRegTyInt) {
+    if ((intCallerMask & mask) > 0) {
+      intCallerRegSet.erase(preg);
+    } else if ((intCalleeMask & mask) > 0) {
+      intCalleeRegSet.erase(preg);
+    } else if ((intParamMask & mask) > 0) {
+      intParamRegSet.erase(preg);
+    } else {
+      ASSERT(false, "ReleasePregToSet: Unknown caller/callee type");
+    }
+  } else if ((fpCallerMask & mask) > 0) {
+    fpCallerRegSet.erase(preg);
+  } else if ((fpCalleeMask & mask) > 0) {
+    fpCalleeRegSet.erase(preg);
+  } else if ((fpParamMask & mask) > 0) {
+    fpParamRegSet.erase(preg);
+  } else {
+    ASSERT(false, "ReleasePregToSet invalid physical register");
+  }
+}
+
+/* update active in retire */
+void LSRALinearScanRegAllocator::UpdateActiveAtRetirement(uint32 insnID) {
+  /* Retire live intervals from active list */
+  MapleSet<LiveInterval*, ActiveCmp>::iterator it;
+  for (it = active.begin(); it != active.end(); /* erase will update */) {
+    auto *li = static_cast<LiveInterval*>(*it);
+    if (li->GetLastUse() > insnID) {
+      break;
+    }
+    /* Is it phys reg which can be pre-Assignment? */
+    if (li->GetRegNO() >= firstIntReg && regInfo->IsPreAssignedReg(li->GetRegNO())) {
+      if (li->GetPhysUse() != 0 && li->GetPhysUse() <= insnID) {
+        it = active.erase(it);
+        if (li->GetPhysUse() != 0) {
+          ReturnPregToSet(*li, li->GetRegNO());
+        }
+        if (LSRA_DUMP) {
+          PrintLiveInterval(*li, "\tRemoving phys_reg li\n");
+        }
+      } else {
+        ++it;
+      }
+      continue;
+    } else if (li->GetRegNO() >= firstFpReg && regInfo->IsPreAssignedReg(li->GetRegNO())) {
+      if (li->GetPhysUse() != 0 && li->GetPhysUse() <= insnID) {
+        it = active.erase(it);
+        if (li->GetPhysUse() != 0) {
+          ReturnPregToSet(*li, li->GetRegNO());
+        }
+        if (LSRA_DUMP) {
+          PrintLiveInterval(*li, "\tRemoving phys_reg li\n");
+        }
+      } else {
+        ++it;
+      }
+      continue;
+    }
+    /*
+     * live interval ended for this reg in active
+     * release physical reg assigned to free reg pool
+     */
+    if (li->GetLiParent() != nullptr) {
+      li->SetLiParentChild(nullptr);
+      li->SetLiParent(nullptr);
+    } else {
+      ReturnPregToSet(*li, li->GetAssignedReg());
+    }
+    if (LSRA_DUMP) {
+      LogInfo::MapleLogger() << "Removing " << "(" << li->GetAssignedReg() << ")" << "from regset\n";
+      PrintLiveInterval(*li, "\tRemoving virt_reg li\n");
+    }
+    it = active.erase(it);
+  }
+}
+
+/* Remove a live interval from 'active' list. */
+void LSRALinearScanRegAllocator::RetireFromActive(const Insn &insn) {
+  uint32 insnID = insn.GetId();
+  /*
+   * active list is sorted based on increasing lastUse
+   * any operand whose use is greater than current
+   * instruction number is still in use.
+   * If the use is less than or equal to instruction number
+   * then it is possible to retire this live interval and
+   * reclaim the physical register associated with it.
+   */
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "RetireFromActive instr_num " << insnID << "\n";
+  }
+  /* Retire call from call queue */
+  for (auto it = callList.cbegin(); it != callList.cend();) {
+    auto *li = static_cast<LiveInterval*>(*it);
+    if (li->GetFirstDef() > insnID) {
+      break;
+    }
+    callList.pop_front();
+    /* at here, it is invalidated */
+    it = callList.begin();
+  }
+
+  for (uint32 i = 0; i < intParamQueue.size(); ++i) {
+    /* push back the param not yet use  <-  as only one is popped, just push it back again */
+    if (lastIntParamLi[i] != nullptr) {
+      intParamQueue[i].push_front(lastIntParamLi[i]);
+      (void)intParamRegSet.insert(lastIntParamLi[i]->GetAssignedReg() - firstIntReg);
+      lastIntParamLi[i] = nullptr;
+    }
+    if (lastFpParamLi[i] != nullptr) {
+      fpParamQueue[i].push_front(lastFpParamLi[i]);
+      (void)fpParamRegSet.insert(lastFpParamLi[i]->GetAssignedReg() - firstFpReg);
+      lastFpParamLi[i] = nullptr;
+    }
+  }
+
+  UpdateActiveAtRetirement(insnID);
+}
+
+/* the return value is a physical reg */
+uint32 LSRALinearScanRegAllocator::GetRegFromSet(MapleSet<uint32> &set, regno_t offset, LiveInterval &li,
+                                                 regno_t forcedReg) const {
+  uint32 regNO;
+  if (forcedReg > 0) {
+    /* forced_reg is a caller save reg */
+    regNO = forcedReg;
+  } else {
+    CHECK(!set.empty(), "set is null in LSRALinearScanRegAllocator::GetRegFromSet");
+    regNO = *(set.begin());
+  }
+  set.erase(regNO);
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "\tAssign " << regNO << "\n";
+  }
+  regNO += offset;  /* Mapping into Maplecg reg */
+  li.SetAssignedReg(regNO);
+  if (LSRA_DUMP) {
+    PrintRegSet(set, "Reg Set AFTER");
+    PrintLiveInterval(li, "LiveInterval after assignment");
+  }
+  return regNO;
+}
+
+/*
+ * Handle adrp register assignment. Use the same register for the next
+ * instruction.
+ */
+uint32 LSRALinearScanRegAllocator::AssignSpecialPhysRegPattern(const Insn &insn, LiveInterval &li) {
+  Insn *nInsn = insn.GetNext();
+  if (nInsn == nullptr || !nInsn->IsMachineInstruction() || nInsn->IsDMBInsn()) {
+    return 0;
+  }
+
+  const InsnDesc *md = insn.GetDesc();
+  if (!md->GetOpndDes(0)->IsRegDef()) {
+    return 0;
+  }
+  Operand &opnd = nInsn->GetOperand(0);
+  if (!opnd.IsRegister()) {
+    return 0;
+  }
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  if (!regOpnd.IsPhysicalRegister()) {
+    return 0;
+  }
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  if (!regInfo->IsPreAssignedReg(regNO)) {
+    return 0;
+  }
+
+  /* next insn's dest is a physical param reg 'regNO' */
+  bool match = false;
+  uint32 opndNum = nInsn->GetOperandSize();
+  for (uint32 i = 1; i < opndNum; ++i) {
+    Operand &src = nInsn->GetOperand(i);
+    if (src.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(src);
+      Operand *base = memOpnd.GetBaseRegister();
+      if (base != nullptr) {
+        auto *regSrc = static_cast<RegOperand*>(base);
+        uint32 srcRegNO = regSrc->GetRegisterNumber();
+        if (li.GetRegNO() == srcRegNO) {
+          match = true;
+          break;
+        }
+      }
+      Operand *offset = memOpnd.GetIndexRegister();
+      if (offset != nullptr) {
+        auto *regSrc = static_cast<RegOperand*>(offset);
+        uint32 srcRegNO = regSrc->GetRegisterNumber();
+        if (li.GetRegNO() == srcRegNO) {
+          match = true;
+          break;
+        }
+      }
+    } else if (src.IsRegister()) {
+      auto &regSrc = static_cast<RegOperand&>(src);
+      uint32 srcRegNO = regSrc.GetRegisterNumber();
+      if (li.GetRegNO() == srcRegNO) {
+        ASSERT(md->GetOpndDes(i) != nullptr,
+            "pointer is null in LSRALinearScanRegAllocator::AssignSpecialPhysRegPattern");
+        if (md->GetOpndDes(i)->IsRegDef()) {
+          break;
+        }
+        match = true;
+        break;
+      }
+    }
+  }
+  if (match && li.GetLastUse() > nInsn->GetId()) {
+    return 0;
+  }
+  /* dest of adrp is src of next insn */
+  if (match) {
+    return GetRegFromSet(intParamRegSet, firstIntReg, li, regNO - firstIntReg);
+  }
+  return 0;
+}
+
+uint32 LSRALinearScanRegAllocator::FindAvailablePhyRegByFastAlloc(LiveInterval &li) {
+  uint32 regNO = 0;
+  if (li.GetRegType() == kRegTyInt) {
+    if (!intCalleeRegSet.empty()) {
+      regNO = GetRegFromSet(intCalleeRegSet, firstIntReg, li);
+      li.SetShouldSave(false);
+    } else if (!intCallerRegSet.empty()) {
+      regNO = GetRegFromSet(intCallerRegSet, firstIntReg, li);
+      li.SetShouldSave(true);
+    } else {
+      li.SetShouldSave(false);
+    }
+  } else if (li.GetRegType() == kRegTyFloat) {
+    if (!fpCalleeRegSet.empty()) {
+      regNO = GetRegFromSet(fpCalleeRegSet, firstFpReg, li);
+      li.SetShouldSave(false);
+    } else if (!fpCallerRegSet.empty()) {
+      regNO = GetRegFromSet(fpCallerRegSet, firstFpReg, li);
+      li.SetShouldSave(true);
+    } else {
+      li.SetShouldSave(false);
+    }
+  }
+  return regNO;
+}
+
+bool LSRALinearScanRegAllocator::NeedSaveAcrossCall(LiveInterval &li) {
+  bool saveAcrossCall = false;
+  for (auto *cli : std::as_const(callList)) {
+    if (cli->GetFirstDef() > li.GetLastUse()) {
+      break;
+    }
+    /* Determine if live interval crosses the call */
+    if ((cli->GetFirstDef() > li.GetFirstDef()) && (cli->GetFirstDef() < li.GetLastUse())) {
+      li.SetShouldSave(true);
+      /* Need to spill/fill around this call */
+      saveAcrossCall = true;
+      break;
+    }
+  }
+  return saveAcrossCall;
+}
+
+uint32 LSRALinearScanRegAllocator::FindAvailablePhyReg(LiveInterval &li, const Insn &insn,
+                                                       bool isIntReg) {
+  uint32 regNO = 0;
+  MapleSet<uint32> &callerRegSet = isIntReg ? intCallerRegSet : fpCallerRegSet;
+  MapleSet<uint32> &calleeRegSet = isIntReg ? intCalleeRegSet : fpCalleeRegSet;
+  MapleSet<uint32> &paramRegSet = isIntReg ? intParamRegSet : fpParamRegSet;
+  regno_t reg0 = isIntReg ? firstIntReg : firstFpReg;
+
+  /* See if register is live accross a call */
+  bool saveAcrossCall = NeedSaveAcrossCall(li);
+  if (saveAcrossCall) {
+    if (LSRA_DUMP) {
+      LogInfo::MapleLogger() << "\t\tlive interval crosses a call\n";
+    }
+    if (regNO == 0) {
+      if (!li.IsInCatch() && !li.IsAllInCleanupOrFirstBB() && !calleeRegSet.empty()) {
+        /* call in live interval, use callee if available */
+        regNO = GetRegFromSet(calleeRegSet, reg0, li);
+        /* Since it is callee saved, no need to continue search */
+        li.SetShouldSave(false);
+      } else if (li.IsMultiUseInBB()) {
+        /*
+         * allocate caller save if there are multiple uses in one bb
+         * else it is no different from spilling
+         */
+        if (!callerRegSet.empty()) {
+          regNO = GetRegFromSet(callerRegSet, reg0, li);
+        } else if (!paramRegSet.empty()) {
+          regNO = GetRegFromSet(paramRegSet, reg0, li);
+        }
+      }
+    }
+    if (regNO == 0) {
+      /* No register left for allocation */
+      regNO = FillInHole(li);
+      if (regNO == 0) {
+        li.SetShouldSave(false);
+      }
+    }
+    return regNO;
+  } else {
+    if (LSRA_DUMP) {
+      LogInfo::MapleLogger() << "\t\tlive interval does not cross a call\n";
+    }
+    if (isIntReg) {
+      regNO = AssignSpecialPhysRegPattern(insn, li);
+      if (regNO != 0) {
+        return regNO;
+      }
+    }
+    if (!paramRegSet.empty()) {
+      regNO = GetRegFromSet(paramRegSet, reg0, li);
+    }
+    if (regNO == 0) {
+      if (!callerRegSet.empty()) {
+        regNO = GetRegFromSet(callerRegSet, reg0, li);
+      } else if (!calleeRegSet.empty()) {
+        regNO = GetRegFromSet(calleeRegSet, reg0, li);
+      } else {
+        regNO = FillInHole(li);
+      }
+    }
+    return regNO;
+  }
+}
+
+/* Return a phys register number for the live interval. */
+uint32 LSRALinearScanRegAllocator::FindAvailablePhyReg(LiveInterval &li, const Insn &insn) {
+  if (fastAlloc) {
+    return FindAvailablePhyRegByFastAlloc(li);
+  }
+  uint32 regNO = 0;
+  if (li.GetRegType() == kRegTyInt) {
+    regNO = FindAvailablePhyReg(li, insn, true);
+  } else if (li.GetRegType() == kRegTyFloat) {
+    regNO = FindAvailablePhyReg(li, insn, false);
+  }
+  return regNO;
+}
+
+/* Spill and reload for caller saved registers. */
+void LSRALinearScanRegAllocator::InsertCallerSave(Insn &insn, Operand &opnd, bool isDef) {
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  uint32 vRegNO = regOpnd.GetRegisterNumber();
+  if (vRegNO >= liveIntervalsArray.size()) {
+    CHECK_FATAL(false, "index out of range in LSRALinearScanRegAllocator::InsertCallerSave");
+  }
+  LiveInterval *rli = liveIntervalsArray[vRegNO];
+  RegType regType = regOpnd.GetRegisterType();
+
+  isSpillZero = false;
+  if (!isDef) {
+    uint32 mask;
+    uint32 regBase;
+    if (regType == kRegTyInt) {
+      mask = intBBDefMask;
+      regBase = firstIntReg;
+    } else {
+      mask = fpBBDefMask;
+      regBase = firstFpReg;
+    }
+    if ((mask & (1u << (rli->GetAssignedReg() - regBase))) > 0) {
+      if (LSRA_DUMP) {
+        LogInfo::MapleLogger() << "InsertCallerSave " << rli->GetAssignedReg() << " skipping due to local def\n";
+      }
+      return;
+    }
+  }
+
+  if (!rli->IsShouldSave()) {
+    return;
+  }
+
+  uint32 regSize = regOpnd.GetSize();
+  PrimType spType;
+
+  if (regType == kRegTyInt) {
+    spType = (regSize <= k32BitSize) ? PTY_i32 : PTY_i64;
+    intBBDefMask |= (1u << (rli->GetAssignedReg() - firstIntReg));
+  } else {
+    spType = (regSize <= k32BitSize) ? PTY_f32 : PTY_f64;
+    fpBBDefMask |= (1u << (rli->GetAssignedReg() - firstFpReg));
+  }
+
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "InsertCallerSave " << vRegNO << "\n";
+  }
+
+  if (!isDef && !rli->IsCallerSpilled()) {
+    LogInfo::MapleLogger() << "WARNING: " << vRegNO << " caller restore without spill in bb "
+                           << insn.GetBB()->GetId() << " : " << cgFunc->GetName() << "\n";
+  }
+  rli->SetIsCallerSpilled(true);
+
+  MemOperand *memOpnd = nullptr;
+  RegOperand *phyOpnd = nullptr;
+
+  phyOpnd = regInfo->GetOrCreatePhyRegOperand(static_cast<regno_t>(rli->GetAssignedReg()), regSize,
+      regType);
+  std::string comment;
+  bool isOutOfRange = false;
+  if (isDef) {
+    memOpnd = GetSpillMem(vRegNO, true, insn, static_cast<regno_t>(intSpillRegSet[0] + firstIntReg),
+        isOutOfRange);
+    Insn *stInsn = regInfo->BuildStrInsn(regSize, spType, *phyOpnd, *memOpnd);
+    comment = " SPILL for caller_save " + std::to_string(vRegNO);
+    ++callerSaveSpillCount;
+    if (rli->GetLastUse() == insn.GetId()) {
+      cgFunc->FreeSpillRegMem(vRegNO);
+      comment += " end";
+    }
+    stInsn->SetComment(comment);
+    if (isOutOfRange) {
+      insn.GetBB()->InsertInsnAfter(*insn.GetNext(), *stInsn);
+    } else {
+      insn.GetBB()->InsertInsnAfter(insn, *stInsn);
+    }
+  } else {
+    memOpnd = GetSpillMem(vRegNO, false, insn, static_cast<regno_t>(intSpillRegSet[0] + firstIntReg),
+        isOutOfRange);
+    Insn *ldInsn = regInfo->BuildLdrInsn(regSize, spType, *phyOpnd, *memOpnd);
+    comment = " RELOAD for caller_save " + std::to_string(vRegNO);
+    ++callerSaveReloadCount;
+    if (rli->GetLastUse() == insn.GetId()) {
+      cgFunc->FreeSpillRegMem(vRegNO);
+      comment += " end";
+    }
+    ldInsn->SetComment(comment);
+    insn.GetBB()->InsertInsnBefore(insn, *ldInsn);
+  }
+}
+
+/* Shell function to find a physical register for an operand. */
+RegOperand *LSRALinearScanRegAllocator::AssignPhysRegs(Operand &opnd, const Insn &insn) {
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  uint32 vRegNO = regOpnd.GetRegisterNumber();
+  RegType regType = regOpnd.GetRegisterType();
+  if (vRegNO >= liveIntervalsArray.size()) {
+    CHECK_FATAL(false, "index out of range in LSRALinearScanRegAllocator::AssignPhysRegs");
+  }
+  LiveInterval *li = liveIntervalsArray[vRegNO];
+
+  /*
+   * if only def, no use, then should assign a new phyreg,
+   * otherwise, there may be conflict
+   */
+  if (li->GetAssignedReg() != 0 && (li->GetLastUse() != 0 || li->GetPhysUse() != 0)) {
+    if (regInfo->IsCalleeSavedReg(li->GetAssignedReg())) {
+      ++calleeUseCnt[li->GetAssignedReg()];
+    }
+    if (li->GetStackSlot() == 0xFFFFFFFF) {
+      return regInfo->GetOrCreatePhyRegOperand(
+          static_cast<regno_t>(li->GetAssignedReg()), opnd.GetSize(), regType);
+    } else {
+      /* need to reload */
+      return nullptr;
+    }
+  }
+
+  /* pre spilled: */
+  if (li->GetStackSlot() != 0xFFFFFFFF) {
+    return nullptr;
+  }
+
+  if (LSRA_DUMP) {
+    uint32 activeSz = active.size();
+    LogInfo::MapleLogger() << "\tAssignPhysRegs-active_sz " << activeSz << "\n";
+  }
+
+  uint32 regNO = FindAvailablePhyReg(*li, insn);
+  if (regNO != 0) {
+    if (regInfo->IsCalleeSavedReg(regNO)) {
+      if (!CGOptions::DoCalleeToSpill()) {
+        if (LSRA_DUMP) {
+          LogInfo::MapleLogger() << "\tCallee-save register for save/restore in prologue/epilogue: " << regNO << "\n";
+        }
+        cgFunc->AddtoCalleeSaved(regNO);
+      }
+      ++calleeUseCnt[regNO];
+    }
+    return regInfo->GetOrCreatePhyRegOperand(
+        static_cast<regno_t>(li->GetAssignedReg()), opnd.GetSize(), regType);
+  }
+
+  return nullptr;
+}
+
+MemOperand *LSRALinearScanRegAllocator::GetSpillMem(uint32 vRegNO, bool isDest, Insn &insn,
+                                                    regno_t regNO, bool &isOutOfRange) const {
+  MemOperand *memOpnd = cgFunc->GetOrCreatSpillMem(vRegNO);
+  return regInfo->AdjustMemOperandIfOffsetOutOfRange(memOpnd, vRegNO, isDest, insn, regNO, isOutOfRange);
+}
+
+/* Set a vreg in live interval as being marked for spill. */
+void LSRALinearScanRegAllocator::SetOperandSpill(Operand &opnd) {
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "SetOperandSpill " << regNO;
+    LogInfo::MapleLogger() << "(" << liveIntervalsArray[regNO]->GetFirstAcrossedCall();
+    LogInfo::MapleLogger() << ", refCount " << liveIntervalsArray[regNO]->GetRefCount() << ")\n";
+  }
+
+  ASSERT(regNO < liveIntervalsArray.size(),
+         "index out of vector size in LSRALinearScanRegAllocator::SetOperandSpill");
+  LiveInterval *li = liveIntervalsArray[regNO];
+  li->SetStackSlot(kSpilled);
+}
+
+/*
+ * Generate spill/reload for an operand.
+ * spill_idx : one of 3 phys regs set aside for the purpose of spills.
+ */
+void LSRALinearScanRegAllocator::SpillOperand(Insn &insn, Operand &opnd, bool isDef, uint32 spillIdx) {
+  /*
+   * Insert spill (def)  and fill (use)  instructions for the operand.
+   *  Keep track of the 'slot' (base 0). The actual slot on the stack
+   *  will be some 'base_slot_offset' + 'slot' off FP.
+   *  For simplification, entire 64bit register is spilled/filled.
+   *
+   *  For example, a virtual register home 'slot' on the stack is location 5.
+   *  This represents a 64bit slot (8bytes).  The base_slot_offset
+   *  from the base 'slot' determined by whoever is added, off FP.
+   *     stack address is  ( FP - (5 * 8) + base_slot_offset )
+   *  So the algorithm is simple, for each virtual register that is not
+   *  allocated, it has to have a home address on the stack (a slot).
+   *  A class variable is used, start from 0, increment by 1.
+   *  Since LiveInterval already represent unique regNO information,
+   *  just add a slot number to it.  Subsequent reference to a regNO
+   *  will either get an allocated physical register or a slot number
+   *  for computing the stack location.
+   *
+   *  This function will also determine the operand to be a def or use.
+   *  For def, spill instruction(s) is appended after the insn.
+   *  For use, spill instruction(s) is prepended before the insn.
+   *  Use FP - (slot# *8) for now.  Will recompute if base_slot_offset
+   *  is not 0.
+   *
+   *  The total number of slots used will be used to compute the stack
+   *  frame size.  This will require some interface external to LSRA.
+   *
+   *  For normal instruction, two spill regs should be enough.  The caller
+   *  controls which ones to use.
+   *  For more complex operations, need to break down the instruction.
+   *    eg.  store  v1 -> [v2 + v3]  // 3 regs needed
+   *         =>  p1 <- v2        // address part 1
+   *             p2 <- v3        // address part 2
+   *             p1 <- p1 + p2   // freeing up p2
+   *             p2 <- v1
+   *            store p2 -> [p1]
+   *      or we can allocate more registers to the spill register set
+   *  For store multiple, need to break it down into two or more instr.
+   */
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "SpillOperand " << regNO << "\n";
+  }
+
+  regno_t spReg;
+  PrimType spType;
+  CHECK_FATAL(regNO < liveIntervalsArray.size(), "index out of range in LSRALinearScanRegAllocator::SpillOperand");
+  LiveInterval *li = liveIntervalsArray[regNO];
+  ASSERT(!li->IsShouldSave(), "SpillOperand: Should not be caller");
+  uint32 regSize = regOpnd.GetSize();
+  RegType regType = regOpnd.GetRegisterType();
+
+  if (li->GetRegType() == kRegTyInt) {
+    ASSERT((spillIdx < intSpillRegSet.size()), "SpillOperand: ran out int spill reg");
+    spReg = intSpillRegSet[spillIdx] + firstIntReg;
+    spType = (regSize <= k32BitSize) ? PTY_i32 : PTY_i64;
+  } else if (li->GetRegType() == kRegTyFloat) {
+    ASSERT((spillIdx < fpSpillRegSet.size()), "SpillOperand: ran out fp spill reg");
+    spReg = fpSpillRegSet[spillIdx] + firstFpReg;
+    spType = (regSize <= k32BitSize) ? PTY_f32 : PTY_f64;
+  } else {
+    CHECK_FATAL(false, "SpillOperand: Should be int or float type");
+  }
+
+  bool isOutOfRange = false;
+  RegOperand *phyOpnd = nullptr;
+  if (isSpillZero) {
+    phyOpnd = &cgFunc->GetZeroOpnd(regSize);
+  } else {
+    phyOpnd = regInfo->GetOrCreatePhyRegOperand(static_cast<regno_t>(spReg), regSize, regType);
+  }
+  li->SetAssignedReg(phyOpnd->GetRegisterNumber());
+
+  MemOperand *memOpnd = nullptr;
+  if (isDef) {
+    /*
+     * Need to assign spReg (one of the two spill reg) to the destination of the insn.
+     *    spill_vreg <- opn1 op opn2
+     * to
+     *    spReg <- opn1 op opn2
+     *    store spReg -> spillmem
+     */
+    li->SetStackSlot(kSpilled);
+
+    ++spillCount;
+    memOpnd = GetSpillMem(regNO, true, insn,
+        static_cast<regno_t>(intSpillRegSet[spillIdx + 1] + firstIntReg), isOutOfRange);
+    Insn *stInsn = regInfo->BuildStrInsn(regSize, spType, *phyOpnd, *memOpnd);
+    std::string comment = " SPILL vreg:" + std::to_string(regNO);
+    if (li->GetLastUse() == insn.GetId()) {
+      cgFunc->FreeSpillRegMem(regNO);
+      comment += " end";
+    }
+    stInsn->SetComment(comment);
+    if (isOutOfRange) {
+      insn.GetBB()->InsertInsnAfter(*insn.GetNext(), *stInsn);
+    } else {
+      insn.GetBB()->InsertInsnAfter(insn, *stInsn);
+    }
+  } else {
+    /* Here, reverse of isDef, change either opn1 or opn2 to the spReg. */
+    if (li->GetStackSlot() == 0xFFFFFFFF) {
+      LogInfo::MapleLogger() << "WARNING: " << regNO << " assigned " << li->GetAssignedReg() <<
+                             " restore without spill in bb " << insn.GetBB()->GetId() << " : " <<
+                             cgFunc->GetName() << "\n";
+    }
+    ++reloadCount;
+    memOpnd = GetSpillMem(regNO, false, insn,
+        static_cast<regno_t>(intSpillRegSet[spillIdx] + firstIntReg), isOutOfRange);
+    Insn *ldInsn = regInfo->BuildLdrInsn(regSize, spType, *phyOpnd, *memOpnd);
+    std::string comment = " RELOAD vreg" + std::to_string(regNO);
+    if (li->GetLastUse() == insn.GetId()) {
+      cgFunc->FreeSpillRegMem(regNO);
+      comment += " end";
+    }
+    ldInsn->SetComment(comment);
+    insn.GetBB()->InsertInsnBefore(insn, *ldInsn);
+  }
+}
+
+RegOperand *LSRALinearScanRegAllocator::HandleSpillForInsn(const Insn &insn, Operand &opnd) {
+  /* choose the lowest priority li to spill */
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  ASSERT(regNO < liveIntervalsArray.size(),
+         "index out of range of MapleVector in LSRALinearScanRegAllocator::HandleSpillForInsn");
+  LiveInterval *li = liveIntervalsArray[regNO];
+  RegType regType = regOpnd.GetRegisterType();
+  LiveInterval *spillLi = nullptr;
+  FindLowestPrioInActive(spillLi, regType, true);
+
+  /*
+   * compare spill_li with current li
+   * spill_li is null and li->SetStackSlot(Spilled) when the li is spilled due to LiveIntervalAnalysis
+   */
+  if (spillLi == nullptr || spillLi->GetLiParent() || spillLi->GetLiChild() || li->GetStackSlot() == kSpilled ||
+      li->GetFirstDef() != insn.GetId() || li->GetPriority() < spillLi->GetPriority() ||
+      li->GetRefCount() < spillLi->GetRefCount() ||
+      !(regInfo->IsCalleeSavedReg(spillLi->GetAssignedReg()))) {
+    /* spill current li */
+    if (LSRA_DUMP) {
+      LogInfo::MapleLogger() << "Flexible Spill: still spill " << li->GetRegNO() << ".\n";
+    }
+    SetOperandSpill(opnd);
+    return nullptr;
+  }
+
+  ReturnPregToSet(*spillLi, spillLi->GetAssignedReg());
+  RegOperand *newOpnd = AssignPhysRegs(opnd, insn);
+  if (newOpnd == nullptr) {
+    ReleasePregToSet(*spillLi, spillLi->GetAssignedReg());
+    SetOperandSpill(opnd);
+    return nullptr;
+  }
+
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "Flexible Spill: " << spillLi->GetRegNO() << " instead of " << li->GetRegNO() << ".\n";
+    PrintLiveInterval(*spillLi, "TO spill: ");
+    PrintLiveInterval(*li, "Instead of: ");
+  }
+
+  /* spill this live interval */
+  active.erase(itFinded);
+  spillLi->SetStackSlot(kSpilled);
+
+  return newOpnd;
+}
+
+bool LSRALinearScanRegAllocator::OpndNeedAllocation(const Insn &insn, Operand &opnd, bool isDef, uint32 insnNum) {
+  if (!opnd.IsRegister()) {
+    return false;
+  }
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  RegType regType = regOpnd.GetRegisterType();
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  if (regType == kRegTyCc || regType == kRegTyVary) {
+    return false;
+  }
+  if (regInfo->IsUntouchableReg(regNO)) {
+    return false;
+  }
+
+  if (regOpnd.IsPhysicalRegister()) {
+    if (isDef) {
+      if (regType == kRegTyInt) {
+        if (!regInfo->IsPreAssignedReg(regNO)) {
+          return false;
+        }
+        if (intParamQueue[regInfo->GetIntParamRegIdx(regNO)].empty()) {
+          return false;
+        }
+        LiveInterval *li = intParamQueue[regInfo->GetIntParamRegIdx(regNO)].front();
+        /* li may have been inserted by InsertParamToActive */
+        if (li->GetFirstDef() == insnNum) {
+          CHECK_FATAL(intParamRegSet.find(regNO - firstIntReg) != intParamRegSet.end(), "impossible");
+          intParamRegSet.erase(regNO - firstIntReg);
+          (void)active.insert(li);
+          CHECK_FATAL(active.find(li) != active.end(), "impossible");
+          intParamQueue[regInfo->GetIntParamRegIdx(regNO)].pop_front();
+        }
+      } else {
+        if (regNO > regInfo->GetLastParamsFpReg() || fpParamQueue[regInfo->GetFpParamRegIdx(regNO)].empty()) {
+          return false;
+        }
+        LiveInterval *li = fpParamQueue[regInfo->GetFpParamRegIdx(regNO)].front();
+        /* li may have been inserted by InsertParamToActive */
+        if (li->GetFirstDef() == insnNum) {
+          CHECK_FATAL(fpParamRegSet.find(regNO - firstIntReg) != fpParamRegSet.end(), "impossible");
+          fpParamRegSet.erase(regInfo->GetFpParamRegIdx(regNO));
+          (void)active.insert(li);
+          CHECK_FATAL(active.find(li) != active.end(), "impossible");
+          fpParamQueue[regInfo->GetFpParamRegIdx(regNO)].pop_front();
+        }
+      }
+    }
+    return false;
+  }
+  /* This is a virtual register */
+  return true;
+}
+
+void LSRALinearScanRegAllocator::InsertParamToActive(Operand &opnd) {
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  CHECK_FATAL(regNO < liveIntervalsArray.size(),
+              "index out of range in LSRALinearScanRegAllocator::InsertParamToActive");
+  LiveInterval *li = liveIntervalsArray[regNO];
+  /* Search for parameter registers that is in the live range to insert into queue */
+  if (li->GetRegType() == kRegTyInt) {
+    for (uint32 i = 0; i < intParamQueue.size(); ++i) {
+      if (intParamQueue[i].empty()) {
+        continue;
+      }
+      LiveInterval *pli = intParamQueue[i].front();
+      do {
+        if ((pli->GetFirstDef() <= li->GetFirstDef()) && (pli->GetPhysUse() <= li->GetFirstDef())) {
+          /* just discard it */
+          intParamQueue[i].pop_front();
+          if (intParamQueue[i].empty()) {
+            break;
+          }
+          pli = intParamQueue[i].front();
+        } else {
+          break;
+        }
+      } while (true);
+      if ((pli->GetFirstDef() < li->GetLastUse()) && (pli->GetPhysUse() > li->GetFirstDef())) {
+        if (intParamRegSet.find(pli->GetAssignedReg() - firstIntReg) != intParamRegSet.end()) {
+          /* reserve this param register and active the its first use */
+          lastIntParamLi[i] = pli;
+          intParamRegSet.erase(pli->GetAssignedReg() - firstIntReg);
+          intParamQueue[i].pop_front();
+        }
+      }
+    }
+  } else {
+    ASSERT((li->GetRegType() == kRegTyFloat), "InsertParamToActive: Incorrect register type");
+    for (uint32 i = 0; i < fpParamQueue.size(); ++i) {
+      if (fpParamQueue[i].empty()) {
+        continue;
+      }
+      LiveInterval *pli = fpParamQueue[i].front();
+      do {
+        if ((pli->GetFirstDef() <= li->GetFirstDef()) && (pli->GetPhysUse() <= li->GetFirstDef())) {
+          /* just discard it */
+          fpParamQueue[i].pop_front();
+          if (fpParamQueue[i].empty()) {
+            break;
+          }
+          pli = fpParamQueue[i].front();
+        } else {
+          break;
+        }
+      } while (true);
+      if ((pli->GetFirstDef() < li->GetLastUse()) && (pli->GetPhysUse() > li->GetFirstDef())) {
+        if (fpParamRegSet.find(i) != fpParamRegSet.end()) {
+          lastFpParamLi[i] = pli;
+          fpParamRegSet.erase(i);
+          fpParamQueue[i].pop_front();
+        }
+      }
+    }
+  }
+}
+
+/* Insert a live interval into the 'active' list. */
+void LSRALinearScanRegAllocator::InsertToActive(Operand &opnd, uint32 insnNum) {
+  auto &regOpnd = static_cast<RegOperand&>(opnd);
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  CHECK_FATAL(regNO < liveIntervalsArray.size(),
+              "index out of range in LSRALinearScanRegAllocator::InsertToActive");
+  LiveInterval *li = liveIntervalsArray[regNO];
+  if (li->GetLastUse() <= insnNum) {
+    /* insert first, and retire later, then the assigned reg can be released */
+    (void)active.insert(li);
+    if (LSRA_DUMP) {
+      PrintLiveInterval(*li, "LiveInterval is skip due to past insn num --- opt to remove redunant insn");
+    }
+    return;
+  }
+  (void)active.insert(li);
+}
+
+/* find the lowest one and erase it from active */
+void LSRALinearScanRegAllocator::FindLowestPrioInActive(LiveInterval *&targetLi, RegType regType, bool startRa) {
+  float lowestPrio = 100.0;
+  bool found = false;
+  MapleSet<LiveInterval*, ActiveCmp>::iterator it;
+  MapleSet<LiveInterval*, ActiveCmp>::iterator lowestIt;
+  for (it = active.begin(); it != active.end(); ++it) {
+    auto *li = static_cast<LiveInterval*>(*it);
+    if (startRa && li->GetPhysUse() != 0) {
+      continue;
+    }
+    if (li->GetPriority() < lowestPrio && li->GetRegType() == regType) {
+      lowestPrio = li->GetPriority();
+      lowestIt = it;
+      found = true;
+    }
+  }
+  if (found) {
+    targetLi = *lowestIt;
+    itFinded = lowestIt;
+  }
+}
+
+/* Calculate the weight of a live interval for pre-spill and flexible spill */
+void LSRALinearScanRegAllocator::LiveIntervalAnalysis() {
+  for (uint32 bbIdx = 0; bbIdx < bfs->sortedBBs.size(); ++bbIdx) {
+    BB *bb = bfs->sortedBBs[bbIdx];
+
+    FOR_BB_INSNS(insn, bb) {
+      insnNumBeforRA++;
+      /* 1 calculate live interfere */
+      if (insn->IsImmaterialInsn() || !insn->IsMachineInstruction() || insn->GetId() == 0) {
+        /* New instruction inserted by reg alloc (ie spill) */
+        continue;
+      }
+      /* 1.1 simple retire from active */
+      MapleSet<LiveInterval*, ActiveCmp>::iterator it;
+      for (it = active.begin(); it != active.end(); /* erase will update */) {
+        auto *li = static_cast<LiveInterval*>(*it);
+        if (li->GetLastUse() > insn->GetId()) {
+          break;
+        }
+        it = active.erase(it);
+      }
+      const InsnDesc *md = insn->GetDesc();
+      uint32 opndNum = insn->GetOperandSize();
+      for (uint32 i = 0; i < opndNum; ++i) {
+        const OpndDesc *regProp = md->GetOpndDes(i);
+        ASSERT(regProp != nullptr, "pointer is null in LSRALinearScanRegAllocator::LiveIntervalAnalysis");
+        bool isDef = regProp->IsRegDef();
+        Operand &opnd = insn->GetOperand(i);
+        if (isDef) {
+          auto &regOpnd = static_cast<RegOperand&>(opnd);
+          if (regOpnd.IsVirtualRegister() && regOpnd.GetRegisterType() != kRegTyCc) {
+            /* 1.2 simple insert to active */
+            uint32 regNO = regOpnd.GetRegisterNumber();
+            LiveInterval *li = liveIntervalsArray[regNO];
+            if (li->GetFirstDef() == insn->GetId()) {
+              (void)active.insert(li);
+            }
+          }
+        }
+      }
+
+      /* 2 get interfere info, and analysis */
+      uint32 interNum = active.size();
+      if (LSRA_DUMP) {
+        LogInfo::MapleLogger() << "In insn " << insn->GetId() << ", " << interNum << " overlap live intervals.\n";
+        LogInfo::MapleLogger() << "\n";
+      }
+
+      /* 2.2 interfere with each other, analysis which to spill */
+      while (interNum > CGOptions::GetOverlapNum()) {
+        LiveInterval *lowestLi = nullptr;
+        FindLowestPrioInActive(lowestLi);
+        if (lowestLi != nullptr) {
+          if (LSRA_DUMP) {
+            PrintLiveInterval(*lowestLi, "Pre spilled: ");
+          }
+          lowestLi->SetStackSlot(kSpilled);
+          active.erase(itFinded);
+          interNum = active.size();
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  active.clear();
+}
+
+/* Iterate through the operands of an instruction for allocation. */
+void LSRALinearScanRegAllocator::AssignPhysRegsForInsn(Insn &insn) {
+  const InsnDesc *md = insn.GetDesc();
+  /* At the beginning of the landing pad, we handle the x1, x2 as if they are implicitly defined. */
+  if (!insn.GetBB()->GetEhPreds().empty() && &insn == insn.GetBB()->GetFirstInsn()) {
+    if (!intParamQueue[0].empty()) {
+      LiveInterval *li = intParamQueue[0].front();
+      if (li->GetFirstDef() == insn.GetId()) {
+        intParamRegSet.erase(li->GetAssignedReg() - firstIntReg);
+        (void)active.insert(li);
+        intParamQueue[0].pop_front();
+      }
+    }
+
+    if (!intParamQueue[1].empty()) {
+      LiveInterval *li = intParamQueue[1].front();
+      if (li->GetFirstDef() == insn.GetId()) {
+        intParamRegSet.erase(li->GetAssignedReg() - firstIntReg);
+        (void)active.insert(li);
+        intParamQueue[1].pop_front();
+      }
+    }
+  }
+
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "active in " << insn.GetId() << " :";
+    PrintActiveListSimple();
+  }
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    const OpndDesc *regProp = md->GetOpndDes(i);
+    ASSERT(regProp != nullptr, "pointer is null in LSRALinearScanRegAllocator::AssignPhysRegsForInsn");
+    bool isDef = regProp->IsRegDef();
+    Operand &opnd = insn.GetOperand(i);
+    RegOperand *newOpnd = nullptr;
+    if (opnd.IsList()) {
+      auto &listOpnd = static_cast<ListOperand&>(opnd);
+      for (auto op : listOpnd.GetOperands()) {
+        if (!OpndNeedAllocation(insn, *op, isDef, insn.GetId())) {
+          continue;
+        }
+        if (isDef && !fastAlloc) {
+          InsertParamToActive(*op);
+        }
+        newOpnd = AssignPhysRegs(*op, insn);
+        if (newOpnd != nullptr) {
+          if (isDef) {
+            InsertToActive(*op, insn.GetId());
+          }
+        } else {
+          /*
+           * If dest and both src are spilled, src will use both of the
+           * spill registers.
+           * dest can use any spill reg, choose 0
+           */
+          if (isDef) {
+            newOpnd = HandleSpillForInsn(insn, *op);
+            if (newOpnd != nullptr) {
+              InsertToActive(*op, insn.GetId());
+            }
+          } else {
+            SetOperandSpill(*op);
+          }
+        }
+      }
+    } else if (opnd.IsMemoryAccessOperand()) {
+      auto &memOpnd = static_cast<MemOperand&>(opnd);
+      Operand *base = memOpnd.GetBaseRegister();
+      Operand *offset = memOpnd.GetIndexRegister();
+      isDef = false;
+      if (base != nullptr) {
+        if (OpndNeedAllocation(insn, *base, isDef, insn.GetId())) {
+          newOpnd = AssignPhysRegs(*base, insn);
+          if (newOpnd == nullptr) {
+            SetOperandSpill(*base);
+          }
+          /* add ASSERT here. */
+        }
+      }
+      if (offset != nullptr) {
+        if (!OpndNeedAllocation(insn, *offset, isDef, insn.GetId())) {
+          continue;
+        }
+        newOpnd = AssignPhysRegs(*offset, insn);
+        if (newOpnd == nullptr) {
+          SetOperandSpill(*offset);
+        }
+      }
+    } else {
+      if (!OpndNeedAllocation(insn, opnd, isDef, insn.GetId())) {
+        continue;
+      }
+      if (isDef && !fastAlloc) {
+        InsertParamToActive(opnd);
+      }
+      newOpnd = AssignPhysRegs(opnd, insn);
+      if (newOpnd != nullptr) {
+        if (isDef) {
+          InsertToActive(opnd, insn.GetId());
+        }
+      } else {
+        /*
+         * If dest and both src are spilled, src will use both of the
+         * spill registers.
+         * dest can use any spill reg, choose 0
+         */
+        if (isDef) {
+          newOpnd = HandleSpillForInsn(insn, opnd);
+          if (newOpnd != nullptr) {
+            InsertToActive(opnd, insn.GetId());
+          }
+        } else {
+          SetOperandSpill(opnd);
+        }
+      }
+    }
+  }
+}
+
+/* Replace Use-Def Opnd */
+RegOperand *LSRALinearScanRegAllocator::GetReplaceUdOpnd(Insn &insn, Operand &opnd, uint32 &spillIdx) {
+  if (!opnd.IsRegister()) {
+    return nullptr;
+  }
+  const auto *regOpnd = static_cast<RegOperand*>(&opnd);
+
+  uint32 vRegNO = regOpnd->GetRegisterNumber();
+  RegType regType = regOpnd->GetRegisterType();
+  if (regType == kRegTyCc || regType == kRegTyVary) {
+    return nullptr;
+  }
+  if (regInfo->IsUntouchableReg(vRegNO)) {
+    return nullptr;
+  }
+  if (regOpnd->IsPhysicalRegister()) {
+    return nullptr;
+  }
+
+  ASSERT(vRegNO < liveIntervalsArray.size(),
+         "index out of range of MapleVector in LSRALinearScanRegAllocator::GetReplaceUdOpnd");
+  LiveInterval *li = liveIntervalsArray[vRegNO];
+
+  regno_t regNO = li->GetAssignedReg();
+  if (regInfo->IsCalleeSavedReg(regNO)) {
+    cgFunc->AddtoCalleeSaved(regNO);
+  }
+
+  if (li->IsShouldSave()) {
+    InsertCallerSave(insn, opnd, false);
+  } else if (li->GetStackSlot() == kSpilled) {
+    SpillOperand(insn, opnd, false, spillIdx);
+    SpillOperand(insn, opnd, true, spillIdx);
+    ++spillIdx;
+  }
+  RegOperand *phyOpnd = regInfo->GetOrCreatePhyRegOperand(
+      static_cast<regno_t>(li->GetAssignedReg()), opnd.GetSize(), regType);
+
+  return phyOpnd;
+}
+
+/*
+ * Create an operand with physical register assigned, or a spill register
+ * in the case where a physical register cannot be assigned.
+ */
+RegOperand *LSRALinearScanRegAllocator::GetReplaceOpnd(Insn &insn, Operand &opnd, uint32 &spillIdx, bool isDef) {
+  if (!opnd.IsRegister()) {
+    return nullptr;
+  }
+  const auto *regOpnd = static_cast<RegOperand*>(&opnd);
+
+  uint32 vRegNO = regOpnd->GetRegisterNumber();
+  RegType regType = regOpnd->GetRegisterType();
+  if (regType == kRegTyCc || regType == kRegTyVary) {
+    return nullptr;
+  }
+  if (regInfo->IsUntouchableReg(vRegNO)) {
+    return nullptr;
+  }
+  if (regOpnd->IsPhysicalRegister()) {
+    return nullptr;
+  }
+
+  ASSERT(vRegNO < liveIntervalsArray.size(),
+         "index out of range of MapleVector in LSRALinearScanRegAllocator::GetReplaceOpnd");
+  LiveInterval *li = liveIntervalsArray[vRegNO];
+
+  regno_t regNO = li->GetAssignedReg();
+  if (regInfo->IsCalleeSavedReg(regNO)) {
+    cgFunc->AddtoCalleeSaved(regNO);
+  }
+
+  if (li->IsShouldSave()) {
+    InsertCallerSave(insn, opnd, isDef);
+  } else if (li->GetStackSlot() == kSpilled) {
+    spillIdx = isDef ? 0 : spillIdx;
+    SpillOperand(insn, opnd, isDef, spillIdx);
+    if (!isDef) {
+      ++spillIdx;
+    }
+  }
+  RegOperand *phyOpnd = regInfo->GetOrCreatePhyRegOperand(
+      static_cast<regno_t>(li->GetAssignedReg()), opnd.GetSize(), regType);
+
+  return phyOpnd;
+}
+
+/* Try to estimate if spill callee should be done based on even/odd for stp in prolog. */
+void LSRALinearScanRegAllocator::CheckSpillCallee() {
+  if (CGOptions::DoCalleeToSpill()) {
+    uint32 pairCnt = 0;
+    for (size_t idx = 0; idx < sizeof(uint32); ++idx) {
+      if ((intCalleeMask & (1ULL << idx)) != 0 && calleeUseCnt[idx] != 0) {
+        ++pairCnt;
+      }
+    }
+    if ((pairCnt & 0x01) != 0) {
+      shouldOptIntCallee = true;
+    }
+
+    for (size_t idx = 0; idx < sizeof(uint32); ++idx) {
+      if ((fpCalleeMask & (1ULL << idx)) != 0 && calleeUseCnt[idx] != 0) {
+        ++pairCnt;
+      }
+    }
+    if ((pairCnt & 0x01) != 0) {
+      shouldOptFpCallee = true;
+    }
+  }
+}
+
+/* Iterate through all instructions and change the vreg to preg. */
+void LSRALinearScanRegAllocator::FinalizeRegisters() {
+  CheckSpillCallee();
+  for (BB *bb : bfs->sortedBBs) {
+    intBBDefMask = 0;
+    fpBBDefMask = 0;
+
+    FOR_BB_INSNS(insn, bb) {
+      if (insn->IsImmaterialInsn() || !insn->IsMachineInstruction() || insn->GetId() == 0) {
+        continue;
+      }
+      if (insn->IsCall()) {
+        intBBDefMask = 0;
+        fpBBDefMask = 0;
+      }
+
+      uint32 spillIdx = 0;
+      const InsnDesc *md = insn->GetDesc();
+      uint opndNum = insn->GetOperandSize();
+      /* Handle source(use) opernads first */
+      for (uint32 i = 0; i < opndNum; ++i) {
+        const OpndDesc *regProp = md->GetOpndDes(i);
+        ASSERT(regProp != nullptr, "pointer is null in LSRALinearScanRegAllocator::FinalizeRegisters");
+        bool isDef = regProp->IsRegDef();
+        if (isDef) {
+          continue;
+        }
+        Operand &opnd = insn->GetOperand(i);
+        RegOperand *phyOpnd = nullptr;
+        if (opnd.IsList()) {
+          /* For arm32, not arm64 */
+        } else if (opnd.IsMemoryAccessOperand()) {
+          auto *memOpnd =
+              static_cast<MemOperand*>(static_cast<MemOperand&>(opnd).Clone(*cgFunc->GetMemoryPool()));
+          ASSERT(memOpnd != nullptr, "memopnd is null in LSRALinearScanRegAllocator::FinalizeRegisters");
+          insn->SetOperand(i, *memOpnd);
+          Operand *base = memOpnd->GetBaseRegister();
+          Operand *offset = memOpnd->GetIndexRegister();
+          if (base != nullptr) {
+            phyOpnd = GetReplaceOpnd(*insn, *base, spillIdx, false);
+            if (phyOpnd != nullptr) {
+              memOpnd->SetBaseRegister(*phyOpnd);
+            }
+          }
+          if (offset != nullptr) {
+            phyOpnd = GetReplaceOpnd(*insn, *offset, spillIdx, false);
+            if (phyOpnd != nullptr) {
+              memOpnd->SetIndexRegister(*phyOpnd);
+            }
+          }
+        } else {
+          phyOpnd = GetReplaceOpnd(*insn, opnd, spillIdx, false);
+          if (phyOpnd != nullptr) {
+            insn->SetOperand(i, *phyOpnd);
+          }
+        }
+      }
+      /* Handle ud(use-def) opernads */
+      for (uint32 i = 0; i < opndNum; ++i) {
+        const OpndDesc *regProp = md->GetOpndDes(i);
+        ASSERT(regProp != nullptr, "pointer is null in LSRALinearScanRegAllocator::FinalizeRegisters");
+        Operand &opnd = insn->GetOperand(i);
+        bool isUseDef = regProp->IsRegDef() && regProp->IsRegUse();
+        if (!isUseDef) {
+          continue;
+        }
+        RegOperand *phyOpnd = GetReplaceUdOpnd(*insn, opnd, spillIdx);
+        if (phyOpnd != nullptr) {
+          insn->SetOperand(i, *phyOpnd);
+        }
+      }
+      /* Handle dest(def) opernads last */
+      for (uint32 i = 0; i < opndNum; ++i) {
+        const OpndDesc *regProp = md->GetOpndDes(i);
+        ASSERT(regProp != nullptr, "pointer is null in LSRALinearScanRegAllocator::FinalizeRegisters");
+        Operand &opnd = insn->GetOperand(i);
+        bool isUse = (regProp->IsRegUse()) || (opnd.IsMemoryAccessOperand());
+        if (isUse) {
+          continue;
+        }
+        isSpillZero = false;
+        RegOperand *phyOpnd = GetReplaceOpnd(*insn, opnd, spillIdx, true);
+        if (phyOpnd != nullptr) {
+          insn->SetOperand(i, *phyOpnd);
+          if (isSpillZero) {
+            insn->GetBB()->RemoveInsn(*insn);
+          }
+        }
+      }
+    }
+  }
+}
+
+void LSRALinearScanRegAllocator::SetAllocMode() {
+  if (CGOptions::IsFastAlloc()) {
+    if (CGOptions::GetFastAllocMode() == 0) {
+      fastAlloc = true;
+    } else {
+      spillAll = true;
+    }
+    /* In-Range spill range can still be specified (only works with --dump-func=). */
+  } else if (cgFunc->NumBBs() > CGOptions::GetLSRABBOptSize()) {
+    /* instruction size is checked in ComputeLieveInterval() */
+    fastAlloc = true;
+  }
+
+  if (LSRA_DUMP) {
+    if (fastAlloc) {
+      LogInfo::MapleLogger() << "fastAlloc mode on\n";
+    }
+    if (spillAll) {
+      LogInfo::MapleLogger() << "spillAll mode on\n";
+    }
+  }
+}
+
+void LSRALinearScanRegAllocator::LinearScanRegAllocator() {
+  if (LSRA_DUMP) {
+    PrintParamQueue("Initial param queue");
+    PrintCallQueue("Initial call queue");
+  }
+  /* handle param register */
+  for (auto &intParam : intParamQueue) {
+    if (!intParam.empty() && intParam.front()->GetFirstDef() == 0) {
+      LiveInterval *li = intParam.front();
+      intParamRegSet.erase(li->GetAssignedReg() - firstIntReg);
+      (void)active.insert(li);
+      intParam.pop_front();
+    }
+  }
+  for (auto &fpParam : fpParamQueue) {
+    if (!fpParam.empty() && fpParam.front()->GetFirstDef() == 0) {
+      LiveInterval *li = fpParam.front();
+      fpParamRegSet.erase(li->GetAssignedReg() - firstFpReg);
+      (void)active.insert(li);
+      fpParam.pop_front();
+    }
+  }
+
+  for (BB *bb : bfs->sortedBBs) {
+    if (LSRA_DUMP) {
+      LogInfo::MapleLogger() << "======New BB=====" << bb->GetId() << " " << std::hex << bb << std::dec << "\n";
+    }
+    FOR_BB_INSNS(insn, bb) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (insn->GetId() == 0) {
+        /* New instruction inserted by reg alloc (ie spill) */
+        continue;
+      }
+      if (LSRA_DUMP) {
+        LogInfo::MapleLogger() << "======New Insn=====" << insn->GetId() << " " << insn->GetBB()->GetId() << "\n";
+        insn->Dump();
+      }
+      RetireFromActive(*insn);
+#ifdef LSRA_DEBUG
+      DebugCheckActiveList();
+#endif
+      AssignPhysRegsForInsn(*insn);
+      if (LSRA_DUMP) {
+        LogInfo::MapleLogger() << "======After Alloc=====" << insn->GetId() << " " << insn->GetBB()->GetId() << "\n";
+        insn->Dump();
+      }
+    }
+  }
+}
+
+/* Main entrance for the LSRA register allocator */
+bool LSRALinearScanRegAllocator::AllocateRegisters() {
+  cgFunc->SetIsAfterRegAlloc();
+  SetAllocMode();
+#ifdef RA_PERF_ANALYSIS
+  auto begin = std::chrono::system_clock::now();
+#endif
+  if (LSRA_DUMP) {
+    const MIRModule &mirModule = cgFunc->GetMirModule();
+    DotGenerator::GenerateDot("RA", *cgFunc, mirModule);
+    DotGenerator::GenerateDot("RAe", *cgFunc, mirModule, true);
+    LogInfo::MapleLogger() << "Entering LinearScanRegAllocator\n";
+  }
+/* ================= ComputeBlockOrder =============== */
+#ifdef RA_PERF_ANALYSIS
+  auto start = std::chrono::system_clock::now();
+#endif
+  /*
+   * The basic blocks are sorted into a linear order for allocation.
+   * initialize block ordering
+   * Can be either breadth first or depth first.
+   * To avoid use before set, we prefer breadth first.
+   * TODO: why we need sort BB here? can it be merged with ISel?
+   */
+  Bfs localBfs(*cgFunc, *memPool);
+  bfs = &localBfs;
+  bfs->ComputeBlockOrder();
+#ifdef RA_PERF_ANALYSIS
+  auto end = std::chrono::system_clock::now();
+  bfsUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+
+/* ================= LiveInterval =============== */
+#ifdef RA_PERF_ANALYSIS
+  start = std::chrono::system_clock::now();
+#endif
+  ComputeLiveInterval();
+
+#ifdef LSRA_GRAPH
+  PrintLiveRanges();
+#endif
+
+  LiveIntervalAnalysis();
+#ifdef RA_PERF_ANALYSIS
+  end = std::chrono::system_clock::now();
+  liveIntervalUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+
+/* ================= LiveRange =============== */
+#ifdef RA_PERF_ANALYSIS
+  start = std::chrono::system_clock::now();
+#endif
+  /* using live interval + holes to approximate live ranges */
+  BuildIntervalRanges();
+#ifdef RA_PERF_ANALYSIS
+  end = std::chrono::system_clock::now();
+  holesUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+/* ================= InitFreeRegPool =============== */
+  InitFreeRegPool();
+
+/* ================= LinearScanRegAllocator =============== */
+#ifdef RA_PERF_ANALYSIS
+  start = std::chrono::system_clock::now();
+#endif
+  LinearScanRegAllocator();
+#ifdef RA_PERF_ANALYSIS
+  end = std::chrono::system_clock::now();
+  lsraUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+
+#ifdef RA_PERF_ANALYSIS
+  start = std::chrono::system_clock::now();
+#endif
+  FinalizeRegisters();
+#ifdef RA_PERF_ANALYSIS
+  end = std::chrono::system_clock::now();
+  finalizeUS += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
+#endif
+
+  if (LSRA_DUMP) {
+    LogInfo::MapleLogger() << "Total " << spillCount << " spillCount in " << cgFunc->GetName() << " \n";
+    LogInfo::MapleLogger() << "Total " << reloadCount << " reloadCount\n";
+    LogInfo::MapleLogger() << "Total " << "(" << spillCount << "+ " << callerSaveSpillCount << ") = " <<
+        (spillCount + callerSaveSpillCount) << " SPILL\n";
+    LogInfo::MapleLogger() << "Total " << "(" << reloadCount << "+ " << callerSaveReloadCount << ") = " <<
+        (reloadCount + callerSaveReloadCount) << " RELOAD\n";
+    uint32_t insertInsn = spillCount + callerSaveSpillCount + reloadCount + callerSaveReloadCount;
+    float rate = (float(insertInsn) / float(insnNumBeforRA));
+    LogInfo::MapleLogger() <<"insn Num Befor RA:"<< insnNumBeforRA <<", insert " << insertInsn <<
+        " insns: " << ", insertInsn/insnNumBeforRA: "<< rate <<"\n";
+  }
+
+  bfs = nullptr; /* bfs is not utilized outside the function. */
+
+#ifdef RA_PERF_ANALYSIS
+  end = std::chrono::system_clock::now();
+  totalUS += std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count();
+#endif
+
+  return true;
+}
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/reg_coalesce.cpp b/src/mapleall/maple_be/src/cg/reg_coalesce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c41a6762ebc891dd8ab74381d60695b5b2b2b911
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/reg_coalesce.cpp
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "reg_coalesce.h"
+#include "cg_option.h"
+#ifdef TARGAARCH64
+#include "aarch64_reg_coalesce.h"
+#include "aarch64_isa.h"
+#include "aarch64_insn.h"
+#endif
+#include "cg.h"
+
+/*
+ * This phase implements if-conversion optimization,
+ * which tries to convert conditional branches into cset/csel instructions
+ */
+namespace maplebe {
+
+void LiveIntervalAnalysis::Run() {
+  Analysis();
+  CoalesceRegisters();
+  ClearBFS();
+}
+
+void LiveIntervalAnalysis::DoAnalysis() {
+  runAnalysis = true;
+  Analysis();
+}
+
+void LiveIntervalAnalysis::Analysis() {
+  bfs = memPool->New<Bfs>(*cgFunc, *memPool);
+  bfs->ComputeBlockOrder();
+  ComputeLiveIntervals();
+}
+
+/* bfs is not utilized outside the function. */
+void LiveIntervalAnalysis::ClearBFS() {
+  bfs = nullptr;
+}
+
+void LiveIntervalAnalysis::Dump() {
+  for (auto it : vregIntervals) {
+    LiveInterval *li = it.second;
+    li->Dump();
+    li->DumpDefs();
+    li->DumpUses();
+  }
+}
+
+void LiveIntervalAnalysis::CoalesceLiveIntervals(LiveInterval &lrDest, LiveInterval &lrSrc) {
+  if (cgFunc->IsExtendReg(lrDest.GetRegNO())) {
+    cgFunc->InsertExtendSet(lrSrc.GetRegNO());
+  }
+  cgFunc->RemoveFromExtendSet(lrDest.GetRegNO());
+  /* merge destlr to srclr */
+  lrSrc.MergeRanges(lrDest);
+  /* update conflicts */
+  lrSrc.MergeConflict(lrDest);
+  for (auto reg : lrDest.GetConflict()) {
+    LiveInterval *conf = GetLiveInterval(reg);
+    if (conf) {
+      conf->AddConflict(lrSrc.GetRegNO());
+    }
+  }
+  /* merge refpoints */
+  lrSrc.MergeRefPoints(lrDest);
+  vregIntervals.erase(lrDest.GetRegNO());
+}
+
+bool CGliveIntervalAnalysis::PhaseRun(maplebe::CGFunc &f) {
+  LiveAnalysis *live = GET_ANALYSIS(CgLiveAnalysis, f);
+  live->ResetLiveSet();
+  MemPool *memPool = GetPhaseMemPool();
+  liveInterval = f.GetCG()->CreateLLAnalysis(*memPool, f);
+  liveInterval->DoAnalysis();
+  return false;
+}
+void CGliveIntervalAnalysis::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.AddRequired<CgLoopAnalysis>();
+}
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(CGliveIntervalAnalysis, cgliveintervalananlysis)
+
+bool CgRegCoalesce::PhaseRun(maplebe::CGFunc &f) {
+  LiveAnalysis *live = GET_ANALYSIS(CgLiveAnalysis, f);
+  live->ResetLiveSet();
+  MemPool *memPool = GetPhaseMemPool();
+  LiveIntervalAnalysis *ll = f.GetCG()->CreateLLAnalysis(*memPool, f);
+  ll->Run();
+  /* the live range info may changed, so invalid the info. */
+  if (live != nullptr) {
+    live->ClearInOutDataInfo();
+  }
+  return false;
+}
+
+void CgRegCoalesce::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.AddRequired<CgLoopAnalysis>();
+  aDep.PreservedAllExcept<CgLiveAnalysis>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgRegCoalesce, cgregcoalesce)
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/regsaves.cpp b/src/mapleall/maple_be/src/cg/regsaves.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e37a768ca3348285b533a964e16f6f5fdf5cf91c
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/regsaves.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "cgfunc.h"
+#if TARGAARCH64
+#include "aarch64_regsaves.h"
+#elif TARGRISCV64
+#include "riscv64_regsaves.h"
+#endif
+
+namespace maplebe {
+using namespace maple;
+
+bool CgRegSavesOpt::PhaseRun(maplebe::CGFunc &f) {
+  if (Globals::GetInstance()->GetOptimLevel() <= CGOptions::kLevel1 ||
+      f.GetMirModule().GetFlavor() == MIRFlavor::kFlavorLmbc) {
+    return false;
+  }
+
+  /* Perform loop analysis, result to be obtained in CGFunc */
+  (void)GetAnalysisInfoHook()->ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgLoopAnalysis::id, f);
+
+  /* Perform live analysis, result to be obtained in CGFunc */
+  LiveAnalysis *live = nullptr;
+  MaplePhase *it = GetAnalysisInfoHook()->
+      ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgLiveAnalysis::id, f);
+  live = static_cast<CgLiveAnalysis*>(it)->GetResult();
+  CHECK_FATAL(live != nullptr, "null ptr check");
+  /* revert liveanalysis result container. */
+  live->ResetLiveSet();
+
+  /* Perform dom analysis, result to be inserted into AArch64RegSavesOpt object */
+  DomAnalysis *dom = nullptr;
+  PostDomAnalysis *pdom = nullptr;
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel1 &&
+      f.GetCG()->GetCGOptions().DoColoringBasedRegisterAllocation()) {
+    MaplePhase *phase = GetAnalysisInfoHook()->
+        ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgDomAnalysis::id, f);
+    dom = static_cast<CgDomAnalysis*>(phase)->GetResult();
+    CHECK_FATAL(dom != nullptr, "null ptr check");
+    phase = GetAnalysisInfoHook()->
+        ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgPostDomAnalysis::id, f);
+    pdom = static_cast<CgPostDomAnalysis*>(phase)->GetResult();
+    CHECK_FATAL(pdom != nullptr, "null ptr check");
+  }
+
+  MemPool *memPool = GetPhaseMemPool();
+  RegSavesOpt *regSavesOpt = nullptr;
+#if TARGAARCH64
+  regSavesOpt = memPool->New<AArch64RegSavesOpt>(f, *memPool, *dom, *pdom);
+#elif || TARGRISCV64
+  regSavesOpt = memPool->New<Riscv64RegSavesOpt>(f, *memPool);
+#endif
+
+  if (regSavesOpt) {
+    regSavesOpt->SetEnabledDebug(false);   /* To turn on debug trace */
+    if (regSavesOpt->GetEnabledDebug()) {
+      dom->Dump();
+    }
+    regSavesOpt->Run();
+  }
+  return true;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgRegSavesOpt, regsaves)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/rematerialize.cpp b/src/mapleall/maple_be/src/cg/rematerialize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a9db0a12cc54c2ed0e5938bde0b29bb40fb83a1b
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/rematerialize.cpp
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "rematerialize.h"
+#if TARGAARCH64
+#include "aarch64_color_ra.h"
+#endif
+
+namespace maplebe {
+
+bool Rematerializer::IsRematerializableForAddrof(CGFunc &cgFunc, const LiveRange &lr) const {
+  const MIRSymbol *symbol = rematInfo.sym;
+  if (symbol->IsDeleted()) {
+    return false;
+  }
+  if (symbol->IsThreadLocal()) {
+    return false;
+  }
+  /* cost too much to remat */
+  if ((symbol->GetStorageClass() == kScFormal) && (symbol->GetSKind() == kStVar) &&
+      ((fieldID != 0) ||
+          (cgFunc.GetBecommon().GetTypeSize(symbol->GetType()->GetTypeIndex().GetIdx()) >
+              k16ByteSize))) {
+    return false;
+  }
+  if (!addrUpper && CGOptions::IsPIC() && ((symbol->GetStorageClass() == kScGlobal) ||
+      (symbol->GetStorageClass() == kScExtern))) {
+    /* check if in loop  */
+    bool useInLoop = false;
+    bool defOutLoop = false;
+    for (auto luIt: lr.GetLuMap()) {
+      BB *bb = cgFunc.GetBBFromID(luIt.first);
+      LiveUnit *curLu = luIt.second;
+      if (bb->GetLoop() != nullptr && curLu->GetUseNum() != 0) {
+        useInLoop = true;
+      }
+      if (bb->GetLoop() == nullptr && curLu->GetDefNum() != 0) {
+        defOutLoop = true;
+      }
+    }
+    return !(useInLoop && defOutLoop);
+  }
+  return true;
+}
+
+bool Rematerializer::IsRematerializableForDread(CGFunc &cgFunc, RematLevel rematLev) const {
+  const MIRSymbol *symbol = rematInfo.sym;
+  if (symbol->IsDeleted()) {
+    return false;
+  }
+  // cost greater than benefit
+  if (symbol->IsThreadLocal()) {
+    return false;
+  }
+  MIRStorageClass storageClass = symbol->GetStorageClass();
+  if ((storageClass == kScAuto) || (storageClass == kScFormal)) {
+    /* cost too much to remat. */
+    return false;
+  }
+  int32 offset = 0;
+  if (fieldID != 0) {
+    ASSERT(symbol->GetType()->IsMIRStructType(), "non-zero fieldID for non-structure");
+    MIRStructType *structType = static_cast<MIRStructType*>(symbol->GetType());
+    offset = cgFunc.GetBecommon().GetFieldOffset(*structType, fieldID).first;
+  }
+  if (rematLev < kRematDreadGlobal && !symbol->IsLocal()) {
+    return false;
+  }
+  return IsRematerializableForDread(offset);
+}
+
+bool Rematerializer::IsRematerializable(CGFunc &cgFunc, RematLevel rematLev,
+    const LiveRange &lr) const {
+  if (rematLev == kRematOff) {
+    return false;
+  }
+  switch (op) {
+    case OP_undef:
+      return false;
+    case OP_constval: {
+      const MIRConst *mirConst = rematInfo.mirConst;
+      if (mirConst->GetKind() != kConstInt) {
+        return false;
+      }
+      const MIRIntConst *intConst = static_cast<const MIRIntConst*>(rematInfo.mirConst);
+      int64 val = intConst->GetExtValue();
+      return IsRematerializableForConstval(val, lr.GetSpillSize());
+    }
+    case OP_addrof: {
+      if (rematLev < kRematAddr) {
+        return false;
+      }
+      return IsRematerializableForAddrof(cgFunc, lr);
+    }
+    case OP_dread: {
+      if (rematLev < kRematDreadLocal) {
+        return false;
+      }
+      return IsRematerializableForDread(cgFunc, rematLev);
+    }
+    default:
+      return false;
+  }
+}
+
+std::vector<Insn*> Rematerializer::Rematerialize(CGFunc &cgFunc, RegOperand &regOp,
+    const LiveRange &lr) {
+  switch (op) {
+    case OP_constval: {
+      ASSERT(rematInfo.mirConst->GetKind() == kConstInt, "Unsupported constant");
+      return RematerializeForConstval(cgFunc, regOp, lr);
+    }
+    case OP_dread: {
+      const MIRSymbol *symbol = rematInfo.sym;
+      PrimType symType = symbol->GetType()->GetPrimType();
+      int32 offset = 0;
+      if (fieldID != 0) {
+        ASSERT(symbol->GetType()->IsMIRStructType(), "non-zero fieldID for non-structure");
+        MIRStructType *structType = static_cast<MIRStructType*>(symbol->GetType());
+        symType = structType->GetFieldType(fieldID)->GetPrimType();
+        offset = cgFunc.GetBecommon().GetFieldOffset(*structType, fieldID).first;
+      }
+      return RematerializeForDread(cgFunc, regOp, offset, symType);
+    }
+    case OP_addrof: {
+      const MIRSymbol *symbol = rematInfo.sym;
+      int32 offset = 0;
+      if (fieldID != 0) {
+        ASSERT(symbol->GetType()->IsMIRStructType(), "non-zero fieldID for non-structure");
+        MIRStructType *structType = static_cast<MIRStructType*>(symbol->GetType());
+        offset = cgFunc.GetBecommon().GetFieldOffset(*structType, fieldID).first;
+      }
+      return RematerializeForAddrof(cgFunc, regOp, offset);
+    }
+    default:
+      ASSERT(false, "Unexpected op in live range");
+  }
+
+  return std::vector<Insn*>();
+}
+
+}  /* namespace maplebe */
\ No newline at end of file
diff --git a/src/mapleall/maple_be/src/cg/schedule.cpp b/src/mapleall/maple_be/src/cg/schedule.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..920b5bad2306d5a2f3f29771f76e705820caa33a
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/schedule.cpp
@@ -0,0 +1,940 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#if TARGAARCH64
+#include "aarch64_schedule.h"
+#elif TARGRISCV64
+#include "riscv64_schedule.h"
+#endif
+#if TARGARM32
+#include "arm32_schedule.h"
+#endif
+#include "cg.h"
+#include "optimize_common.h"
+
+#undef PRESCHED_DEBUG
+
+namespace maplebe {
+/* pressure standard value; pressure under this value will not lead to spill operation */
+static constexpr int kPressureStandard = 27;
+/* optimistic scheduling option */
+static constexpr bool kOptimisticScheduling = false;
+/* brute maximum count limit option */
+static constexpr bool kBruteMaximumLimit = true;
+/* brute maximum count */
+static constexpr int kSchedulingMaximumCount = 20000;
+
+/* ---- RegPressureSchedule function ---- */
+void RegPressureSchedule::InitBBInfo(BB &b, MemPool &memPool, const MapleVector<DepNode*> &nodes) {
+  bb = &b;
+  liveReg.clear();
+  scheduledNode.clear();
+  readyList.clear();
+  maxPriority = 0;
+  maxPressure = memPool.NewArray<int32>(RegPressure::GetMaxRegClassNum());
+  curPressure = memPool.NewArray<int32>(RegPressure::GetMaxRegClassNum());
+  physicalRegNum = memPool.NewArray<int32>(RegPressure::GetMaxRegClassNum());
+  for (auto node : nodes) {
+    node->SetState(kNormal);
+  }
+}
+
+/* return register type according to register number */
+RegType RegPressureSchedule::GetRegisterType(regno_t reg) const {
+  return cgFunc.GetRegisterType(reg);
+}
+
+/* Get amount of every physical register */
+void RegPressureSchedule::BuildPhyRegInfo(const std::vector<int32> &regNumVec) {
+  FOR_ALL_REGCLASS(i) {
+    physicalRegNum[i] = regNumVec[i];
+  }
+}
+
+/* Initialize pre-scheduling split point in BB */
+void RegPressureSchedule::InitPartialSplitters(const MapleVector<DepNode*> &nodes) {
+  bool addFirstAndLastNodeIndex = false;
+  constexpr uint32 kSecondLastNodeIndexFromBack = 2;
+  constexpr uint32 kLastNodeIndexFromBack = 1;
+  constexpr uint32 kFirstNodeIndex = 0;
+  constexpr uint32 kMiniMumBBSize = 2;
+  /* Add split point for the last instruction in return BB */
+  if (bb->GetKind() == BB::kBBReturn && nodes.size() > kMiniMumBBSize) {
+    splitterIndexes.emplace_back(nodes.size() - kSecondLastNodeIndexFromBack);
+    addFirstAndLastNodeIndex = true;
+  }
+  /* Add first and last node as split point if needed */
+  if (addFirstAndLastNodeIndex) {
+    splitterIndexes.emplace_back(nodes.size() - kLastNodeIndexFromBack);
+    splitterIndexes.emplace_back(kFirstNodeIndex);
+  }
+  std::sort(splitterIndexes.begin(), splitterIndexes.end(), std::less<int>{});
+}
+
+/* initialize register pressure information according to bb's live-in data.
+ * initialize node's valid preds size.
+ */
+void RegPressureSchedule::Init(const MapleVector<DepNode*> &nodes) {
+  readyList.clear();
+  scheduledNode.clear();
+  liveReg.clear();
+  liveInRegNO.clear();
+  liveOutRegNO.clear();
+  liveInRegNO = bb->GetLiveInRegNO();
+  liveOutRegNO = bb->GetLiveOutRegNO();
+
+  FOR_ALL_REGCLASS(i) {
+    curPressure[i] = 0;
+    maxPressure[i] = 0;
+  }
+
+  for (auto *node : nodes) {
+    /* calculate the node uses'register pressure */
+    for (auto &useReg : node->GetUseRegnos()) {
+      CalculatePressure(*node, useReg, false);
+    }
+
+    /* calculate the node defs'register pressure */
+    size_t i = 0;
+    for (auto &defReg : node->GetDefRegnos()) {
+      CalculatePressure(*node, defReg, true);
+      RegType regType = GetRegisterType(defReg);
+      /* if no use list, a register is only defined, not be used */
+      if (node->GetRegDefs(i) == nullptr && liveOutRegNO.find(defReg) == liveOutRegNO.end()) {
+        node->IncDeadDefByIndex(regType);
+      }
+      ++i;
+    }
+    /* Calculate pred size of the node */
+    CalculatePredSize(*node);
+  }
+
+  DepNode *firstNode = nodes.front();
+  readyList.emplace_back(firstNode);
+  firstNode->SetState(kReady);
+  scheduledNode.reserve(nodes.size());
+  constexpr size_t readyListSize = 10;
+  readyList.reserve(readyListSize);
+}
+
+void RegPressureSchedule::SortReadyList() {
+  std::sort(readyList.begin(), readyList.end(), DepNodePriorityCmp);
+}
+
+/* return true if nodes1 first. */
+bool RegPressureSchedule::DepNodePriorityCmp(const DepNode *node1, const DepNode *node2) {
+  CHECK_NULL_FATAL(node1);
+  CHECK_NULL_FATAL(node2);
+  int32 priority1 = node1->GetPriority();
+  int32 priority2 = node2->GetPriority();
+  if (priority1 != priority2) {
+    return priority1 > priority2;
+  }
+
+  int32 numCall1 = node1->GetNumCall();
+  int32 numCall2 = node2->GetNumCall();
+  if (node1->GetIncPressure() == true && node2->GetIncPressure() == true) {
+    if (numCall1 != numCall2) {
+      return numCall1 > numCall2;
+    }
+  }
+
+  int32 near1 = node1->GetNear();
+  int32 near2 = node1->GetNear();
+  int32 depthS1 = node1->GetMaxDepth() + near1;
+  int32 depthS2 = node2->GetMaxDepth() + near2;
+  if (depthS1 != depthS2) {
+    return depthS1 > depthS2;
+  }
+
+  if (near1 != near2) {
+    return near1 > near2;
+  }
+
+  if (numCall1 != numCall2) {
+    return numCall1 > numCall2;
+  }
+
+  size_t succsSize1 = node1->GetSuccs().size();
+  size_t succsSize2 = node1->GetSuccs().size();
+  if (succsSize1 != succsSize2) {
+    return succsSize1 < succsSize2;
+  }
+
+  if (node1->GetHasPreg() != node2->GetHasPreg()) {
+    return node1->GetHasPreg();
+  }
+
+  return node1->GetInsn()->GetId() < node2->GetInsn()->GetId();
+}
+
+/* set a node's incPressure is true, when a class register inscrease */
+void RegPressureSchedule::ReCalculateDepNodePressure(DepNode &node) const {
+  /* if there is a type of register pressure increases, set incPressure as true. */
+  auto &pressures = node.GetPressure();
+  node.SetIncPressure(pressures[kRegisterInt] > 0);
+}
+
+/* calculate the maxDepth of every node in nodes. */
+void RegPressureSchedule::CalculateMaxDepth(const MapleVector<DepNode*> &nodes) const {
+  /* from the last node to first node. */
+  for (auto it = nodes.rbegin(); it != nodes.rend(); ++it) {
+    /* init call count */
+    if ((*it)->GetInsn()->IsCall()) {
+      (*it)->SetNumCall(1);
+    }
+    /* traversing each successor of it. */
+    for (auto succ : (*it)->GetSuccs()) {
+      DepNode &to = succ->GetTo();
+      if ((*it)->GetMaxDepth() < (to.GetMaxDepth() + 1)) {
+        (*it)->SetMaxDepth(to.GetMaxDepth() + 1);
+      }
+
+      if (to.GetInsn()->IsCall() && ((*it)->GetNumCall() < to.GetNumCall() + 1)) {
+        (*it)->SetNumCall(to.GetNumCall() + 1);
+      } else if ((*it)->GetNumCall() < to.GetNumCall()) {
+        (*it)->SetNumCall(to.GetNumCall());
+      }
+    }
+  }
+}
+
+/* calculate the near of every successor of the node. */
+void RegPressureSchedule::CalculateNear(const DepNode &node) {
+  for (auto succ : node.GetSuccs()) {
+    DepNode &to = succ->GetTo();
+    if (succ->GetDepType() == kDependenceTypeTrue && to.GetNear() < node.GetNear() + 1) {
+      to.SetNear(node.GetNear() + 1);
+    }
+  }
+}
+
+/* return true if it is last time using the regNO. */
+bool RegPressureSchedule::IsLastUse(const DepNode &node, regno_t regNO) {
+  size_t i = 0;
+  for (auto reg : node.GetUseRegnos()) {
+    if (reg == regNO) {
+      break;
+    }
+    ++i;
+  }
+  RegList *regList = node.GetRegUses(i);
+
+  /*
+   * except the node, if there are insn that has no scheduled in regNO's regList,
+   * then it is not the last time using the regNO, return false.
+   */
+  while (regList != nullptr) {
+    CHECK_NULL_FATAL(regList->insn);
+    DepNode *useNode = regList->insn->GetDepNode();
+    ASSERT(useNode != nullptr, "get depend node failed in RegPressureSchedule::IsLastUse");
+    if ((regList->insn != node.GetInsn()) && (useNode->GetState() != kScheduled)) {
+      return false;
+    }
+    regList = regList->next;
+  }
+  return true;
+}
+
+void RegPressureSchedule::CalculatePressure(DepNode &node, regno_t reg, bool def) const {
+  RegType regType = GetRegisterType(reg);
+  /* if def a register, register pressure increase. */
+  if (def) {
+    node.IncPressureByIndex(regType);
+  } else {
+    /* if it is the last time using the reg, register pressure decrease. */
+    if (IsLastUse(node, reg)) {
+      node.DecPressureByIndex(regType);
+    }
+  }
+}
+
+/* update live reg information. */
+void RegPressureSchedule::UpdateLiveReg(const DepNode &node, regno_t reg, bool def) {
+  if (def) {
+    if (liveReg.find(reg) == liveReg.end()) {
+      (void)liveReg.insert(reg);
+#ifdef PRESCHED_DEBUG
+      LogInfo::MapleLogger() << "Add new def R" << reg << " to live reg list \n";
+#endif
+    }
+    /* if no use list, a register is only defined, not be used */
+    size_t i = 1;
+    for (auto defReg : node.GetDefRegnos()) {
+      if (defReg == reg) {
+        break;
+      }
+      ++i;
+    }
+    if (node.GetRegDefs(i) == nullptr && liveOutRegNO.find(reg) == liveOutRegNO.end()) {
+#ifdef PRESCHED_DEBUG
+      LogInfo::MapleLogger() << "Remove dead def " << reg << " from live reg list \n";
+#endif
+      liveReg.erase(reg);
+    } else if (node.GetRegDefs(i) != nullptr) {
+#ifdef PRESCHED_DEBUG
+      auto regList = node.GetRegDefs(i);
+      LogInfo::MapleLogger() << i << " Live def, dump use insn here \n";
+      while (regList != nullptr) {
+        node.GetRegDefs(i)->insn->Dump();
+        regList = regList->next;
+      }
+#endif
+    }
+  } else {
+    if (IsLastUse(node, reg)) {
+      if (liveReg.find(reg) != liveReg.end() && liveOutRegNO.find(reg) == liveOutRegNO.end()) {
+#ifdef PRESCHED_DEBUG
+        LogInfo::MapleLogger() << "Remove last use R" << reg << " from live reg list\n";
+#endif
+        liveReg.erase(reg);
+      }
+    }
+  }
+}
+
+/* update register pressure information. */
+void RegPressureSchedule::UpdateBBPressure(const DepNode &node) {
+  size_t idx = 0;
+  for (auto &reg : node.GetUseRegnos()) {
+#ifdef PRESCHED_DEBUG
+    LogInfo::MapleLogger() << "Use Reg : R" << reg << "\n";
+    UpdateLiveReg(node, reg, false);
+    if (liveReg.find(reg) == liveReg.end()) {
+      ++idx;
+      continue;
+    }
+#endif
+
+    /* find all insn that use the reg, if a insn use the reg lastly, insn'pressure - 1 */
+    RegList *regList = node.GetRegUses(idx);
+
+    while (regList != nullptr) {
+      CHECK_NULL_FATAL(regList->insn);
+      DepNode *useNode = regList->insn->GetDepNode();
+      if (useNode->GetState() == kScheduled) {
+        regList = regList->next;
+        continue;
+      }
+
+      if (IsLastUse(*useNode, reg)) {
+        RegType regType = GetRegisterType(reg);
+        useNode->DecPressureByIndex(regType);
+      }
+      break;
+    }
+    ++idx;
+  }
+
+#ifdef PRESCHED_DEBUG
+  for (auto &defReg : node.GetDefRegnos()) {
+    UpdateLiveReg(node, defReg, true);
+  }
+#endif
+
+  const auto &pressures = node.GetPressure();
+  const auto &deadDefNum = node.GetDeadDefNum();
+#ifdef PRESCHED_DEBUG
+  LogInfo::MapleLogger() << "\nnode's pressure: ";
+  for (auto pressure : pressures) {
+    LogInfo::MapleLogger() << pressure << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+#endif
+
+  FOR_ALL_REGCLASS(i) {
+    curPressure[i] += pressures[i];
+    curPressure[i] -= deadDefNum[i];
+    if (curPressure[i] > maxPressure[i]) {
+      maxPressure[i] = curPressure[i];
+    }
+  }
+}
+
+/* update node priority and try to update the priority of all node's ancestor. */
+void RegPressureSchedule::UpdatePriority(DepNode &node) {
+  std::vector<DepNode*> workQueue;
+  workQueue.emplace_back(&node);
+  node.SetPriority(maxPriority++);
+  do {
+    DepNode *nowNode = workQueue.front();
+    (void)workQueue.erase(workQueue.begin());
+    for (auto pred : nowNode->GetPreds()) {
+      DepNode &from = pred->GetFrom();
+      if (from.GetState() != kScheduled && from.GetPriority() < maxPriority) {
+        from.SetPriority(maxPriority);
+        workQueue.emplace_back(&from);
+      }
+    }
+  } while (!workQueue.empty());
+}
+
+/* return true if all node's pred has been scheduled. */
+bool RegPressureSchedule::CanSchedule(const DepNode &node) const {
+  return node.GetValidPredsSize() == 0;
+}
+
+/*
+ * delete node from readylist and
+ * add the successor of node to readyList when
+ *  1. successor has no been scheduled;
+ *  2. successor's has been scheduled or the dependence between node and successor is true-dependence.
+ */
+void RegPressureSchedule::UpdateReadyList(const DepNode &node) {
+  /* delete node from readylist */
+  for (auto it = readyList.begin(); it != readyList.end(); ++it) {
+    if (*it == &node) {
+      readyList.erase(it);
+      break;
+    }
+  }
+  /* update dependency information of the successors and add nodes into readyList */
+  for (auto *succ : node.GetSuccs()) {
+    DepNode &succNode = succ->GetTo();
+    if (!partialSet.empty() && (partialSet.find(&succNode) == partialSet.end())) {
+      continue;
+    }
+    succNode.DescreaseValidPredsSize();
+    if (((succ->GetDepType() == kDependenceTypeTrue) || CanSchedule(succNode)) && (succNode.GetState() == kNormal)) {
+      readyList.emplace_back(&succNode);
+      succNode.SetState(kReady);
+    }
+  }
+}
+/*
+ * Another version of UpdateReadyList for brute force ready list update
+ * The difference is to store the state change status for the successors for later restoring
+ */
+void RegPressureSchedule::BruteUpdateReadyList(const DepNode &node, std::vector<bool> &changedToReady) {
+  /* delete node from readylist */
+  for (auto it = readyList.begin(); it != readyList.end(); ++it) {
+    if (*it == &node) {
+      readyList.erase(it);
+      break;
+    }
+  }
+  /* update dependency information of the successors and add nodes into readyList */
+  for (auto *succ : node.GetSuccs()) {
+    DepNode &succNode = succ->GetTo();
+    if (!partialSet.empty() && (partialSet.find(&succNode) == partialSet.end())) {
+      continue;
+    }
+    succNode.DescreaseValidPredsSize();
+    if (((succ->GetDepType() == kDependenceTypeTrue) || CanSchedule(succNode)) && (succNode.GetState() == kNormal)) {
+      readyList.emplace_back(&succNode);
+      succNode.SetState(kReady);
+      changedToReady.emplace_back(true);
+    } else {
+      changedToReady.emplace_back(false);
+    }
+  }
+}
+
+/*
+ * Restore the ready list status when finishing one brute scheduling series generation
+ */
+void RegPressureSchedule::RestoreReadyList(DepNode &node, std::vector<bool> &changedToReady) {
+  uint32 i = 0;
+  /* restore state information of the successors and delete them from readyList */
+  for (auto *succ : node.GetSuccs()) {
+    DepNode &succNode = succ->GetTo();
+    succNode.IncreaseValidPredsSize();
+    if (changedToReady.at(i)) {
+      succNode.SetState(kNormal);
+      for (auto it = readyList.begin(); it != readyList.end(); ++it) {
+        if (*it == &succNode) {
+          readyList.erase(it);
+          break;
+        }
+      }
+    }
+    ++i;
+  }
+  /* add the node back into the readyList */
+  readyList.emplace_back(&node);
+}
+/* choose a node to schedule */
+DepNode *RegPressureSchedule::ChooseNode() {
+  DepNode *node = nullptr;
+  for (auto *it : readyList) {
+    if (!it->GetIncPressure() && !it->GetHasNativeCallRegister()) {
+      if (CanSchedule(*it)) {
+        return it;
+      } else if (node == nullptr) {
+        node = it;
+      }
+    }
+  }
+  if (node == nullptr) {
+    node = readyList.front();
+  }
+  return node;
+}
+
+void RegPressureSchedule::DumpBBLiveInfo() const {
+  LogInfo::MapleLogger() << "Live In: ";
+  for (auto reg : bb->GetLiveInRegNO()) {
+    LogInfo::MapleLogger() << "R" <<reg << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+
+  LogInfo::MapleLogger() << "Live Out: ";
+  for (auto reg : bb->GetLiveOutRegNO()) {
+    LogInfo::MapleLogger() << "R" << reg << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void RegPressureSchedule::DumpReadyList() const {
+  LogInfo::MapleLogger() << "readyList: " << "\n";
+  for (DepNode *it : readyList) {
+    if (CanSchedule(*it)) {
+      LogInfo::MapleLogger() << it->GetInsn()->GetId() << "CS ";
+    } else {
+      LogInfo::MapleLogger() << it->GetInsn()->GetId() << "NO ";
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void RegPressureSchedule::DumpSelectInfo(const DepNode &node) const {
+  LogInfo::MapleLogger() << "select a node: " << "\n";
+  node.DumpSchedInfo();
+  node.DumpRegPressure();
+  node.GetInsn()->Dump();
+
+  LogInfo::MapleLogger() << "liveReg: ";
+  for (auto reg : liveReg) {
+    LogInfo::MapleLogger() << "R" << reg << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+
+  LogInfo::MapleLogger() << "\n";
+}
+
+void RegPressureSchedule::DumpDependencyInfo(const MapleVector<DepNode*> &nodes) {
+  LogInfo::MapleLogger() << "Dump Dependency Begin \n";
+  for (auto node : nodes) {
+    LogInfo::MapleLogger() << "Insn \n";
+    node->GetInsn()->Dump();
+    LogInfo::MapleLogger() << "Successors \n";
+    /* update dependency information of the successors and add nodes into readyList */
+    for (auto *succ : node->GetSuccs()) {
+      DepNode &succNode = succ->GetTo();
+      succNode.GetInsn()->Dump();
+    }
+  }
+  LogInfo::MapleLogger() << "Dump Dependency End \n";
+}
+
+void RegPressureSchedule::ReportScheduleError() const {
+  LogInfo::MapleLogger() << "Error No Equal Length for Series" << "\n";
+  DumpDependencyInfo(originalNodeSeries);
+  for (auto node : scheduledNode) {
+    node->GetInsn()->Dump();
+  }
+  LogInfo::MapleLogger() << "Original One" << "\n";
+  for (auto node : originalNodeSeries) {
+    node->GetInsn()->Dump();
+  }
+  LogInfo::MapleLogger() << "Error No Equal Length for End" << "\n";
+}
+
+void RegPressureSchedule::ReportScheduleOutput() const {
+  LogInfo::MapleLogger() << "Original Pressure : " << originalPressure << " \n";
+  LogInfo::MapleLogger() << "Scheduled Pressure : " << scheduledPressure << " \n";
+  if (originalPressure > scheduledPressure) {
+    LogInfo::MapleLogger() << "Pressure Reduced by : " << (originalPressure - scheduledPressure) << " \n";
+    return;
+  } else if (originalPressure == scheduledPressure) {
+    LogInfo::MapleLogger() << "Pressure Not Changed \n";
+  } else {
+    LogInfo::MapleLogger() << "Pressure Increased by : " << (scheduledPressure - originalPressure) << " \n";
+  }
+  LogInfo::MapleLogger() << "Pressure Not Reduced, Restore Node Series \n";
+}
+
+void RegPressureSchedule::DumpBBPressureInfo() const {
+  LogInfo::MapleLogger() << "curPressure: ";
+  FOR_ALL_REGCLASS(i) {
+    LogInfo::MapleLogger() << curPressure[i] << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+
+  LogInfo::MapleLogger() << "maxPressure: ";
+  FOR_ALL_REGCLASS(i) {
+    LogInfo::MapleLogger() << maxPressure[i] << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void RegPressureSchedule::DoScheduling(MapleVector<DepNode*> &nodes) {
+  /* Store the original series */
+  originalNodeSeries.clear();
+  for (auto node : nodes) {
+    originalNodeSeries.emplace_back(node);
+  }
+  InitPartialSplitters(nodes);
+#if PRESCHED_DEBUG
+  LogInfo::MapleLogger() << "\n Calculate Pressure Info for Schedule Input Series \n";
+#endif
+  originalPressure = CalculateRegisterPressure(nodes);
+#if PRESCHED_DEBUG
+  LogInfo::MapleLogger() << "Original pressure : " << originalPressure << "\n";
+#endif
+  /* Original pressure is small enough, skip pre-scheduling */
+  if (originalPressure < kPressureStandard) {
+#if PRESCHED_DEBUG
+    LogInfo::MapleLogger() << "Original pressure is small enough, skip pre-scheduling \n";
+#endif
+    return;
+  }
+  if (splitterIndexes.empty()) {
+    LogInfo::MapleLogger() << "No splitter, normal scheduling \n";
+    if (!kOptimisticScheduling) {
+      HeuristicScheduling(nodes);
+    } else {
+      InitBruteForceScheduling(nodes);
+      BruteForceScheduling();
+      if (optimisticScheduledNodes.size() == nodes.size() && minPressure < originalPressure) {
+        nodes.clear();
+        for (auto node : optimisticScheduledNodes) {
+          nodes.emplace_back(node);
+        }
+      }
+    }
+  } else {
+    /* Split the node list into multiple parts based on split point and conduct scheduling */
+    PartialScheduling(nodes);
+  }
+  scheduledPressure = CalculateRegisterPressure(nodes);
+  EmitSchedulingSeries(nodes);
+}
+
+void RegPressureSchedule::HeuristicScheduling(MapleVector<DepNode*> &nodes) {
+#ifdef PRESCHED_DEBUG
+  LogInfo::MapleLogger() << "--------------- bb " << bb->GetId() <<" begin scheduling -------------" << "\n";
+  DumpBBLiveInfo();
+#endif
+
+  /* initialize register pressure information and readylist. */
+  Init(nodes);
+  CalculateMaxDepth(nodes);
+  while (!readyList.empty()) {
+    /* calculate register pressure */
+    for (DepNode *it : readyList) {
+      ReCalculateDepNodePressure(*it);
+    }
+    if (readyList.size() > 1) {
+      SortReadyList();
+    }
+
+    /* choose a node can be scheduled currently. */
+    DepNode *node = ChooseNode();
+#ifdef PRESCHED_DEBUG
+    DumpBBPressureInfo();
+    DumpReadyList();
+    LogInfo::MapleLogger() << "first tmp select node: " << node->GetInsn()->GetId() << "\n";
+#endif
+
+    while (!CanSchedule(*node)) {
+      UpdatePriority(*node);
+      SortReadyList();
+      node = readyList.front();
+#ifdef PRESCHED_DEBUG
+      LogInfo::MapleLogger() << "update ready list: " << "\n";
+      DumpReadyList();
+#endif
+    }
+
+    scheduledNode.emplace_back(node);
+    /* mark node has scheduled */
+    node->SetState(kScheduled);
+    UpdateBBPressure(*node);
+    CalculateNear(*node);
+    UpdateReadyList(*node);
+#ifdef PRESCHED_DEBUG
+    DumpSelectInfo(*node);
+#endif
+  }
+
+#ifdef PRESCHED_DEBUG
+  LogInfo::MapleLogger() << "---------------------------------- end --------------------------------" << "\n";
+#endif
+  /* update nodes according to scheduledNode. */
+  nodes.clear();
+  for (auto node : scheduledNode) {
+    nodes.emplace_back(node);
+  }
+}
+/*
+ * Calculate the register pressure for current BB based on an instruction series
+ */
+int RegPressureSchedule::CalculateRegisterPressure(MapleVector<DepNode*> &nodes) {
+  /* Initialize the live, live in, live out register max pressure information */
+  liveReg.clear();
+  liveInRegNO = bb->GetLiveInRegNO();
+  liveOutRegNO = bb->GetLiveOutRegNO();
+  std::vector<ScheduleState> restoreStateSeries;
+  int maximumPressure = 0;
+  /* Mock all the nodes to kScheduled status for pressure calculation */
+  for (auto node : nodes) {
+    restoreStateSeries.emplace_back(node->GetState());
+    node->SetState(kScheduled);
+  }
+  /* Update live register set according to the instruction series */
+  for (auto node : nodes) {
+    for (auto &reg : node->GetUseRegnos()) {
+      UpdateLiveReg(*node, reg, false);
+    }
+    for (auto &defReg : node->GetDefRegnos()) {
+      UpdateLiveReg(*node, defReg, true);
+    }
+    int currentPressure = static_cast<int>(liveReg.size());
+    if (currentPressure > maximumPressure) {
+      maximumPressure = currentPressure;
+    }
+#ifdef PRESCHED_DEBUG
+    node->GetInsn()->Dump();
+    LogInfo::MapleLogger() << "Dump Live Reg : " << "\n";
+    for (auto reg : liveReg) {
+      LogInfo::MapleLogger() << "R" << reg << " ";
+    }
+    LogInfo::MapleLogger() << "\n";
+#endif
+  }
+  /* Restore the Schedule State */
+  uint32 i = 0;
+  for (auto node : nodes){
+    node->SetState(restoreStateSeries.at(i));
+    ++i;
+  }
+  return maximumPressure;
+}
+
+/*
+ * Split the series into multiple parts and conduct pre-scheduling in every part
+ */
+void RegPressureSchedule::PartialScheduling(MapleVector<DepNode*> &nodes) {
+  for (size_t i = 0; i < splitterIndexes.size() - 1; ++i) {
+    constexpr uint32 lastTwoNodeIndex = 2;
+    auto begin = static_cast<uint32>(splitterIndexes.at(i));
+    auto end = static_cast<uint32>(splitterIndexes.at(i + 1));
+    for (uint32 j = begin; j < end; ++j) {
+      partialList.emplace_back(nodes.at(j));
+    }
+    if (i == splitterIndexes.size() - lastTwoNodeIndex) {
+      partialList.emplace_back(nodes.at(end));
+    }
+    for (auto node : partialList) {
+      partialSet.insert(node);
+    }
+    HeuristicScheduling(partialList);
+    for (auto node : partialList) {
+      partialScheduledNode.emplace_back(node);
+    }
+    partialList.clear();
+    partialSet.clear();
+  }
+  nodes.clear();
+  /* Construct overall scheduling output */
+  for (auto node : partialScheduledNode) {
+    nodes.emplace_back(node);
+  }
+}
+
+/*
+ * Brute-force scheduling algorithm
+ * It enumerates all the possible schedule series and pick a best one
+ */
+void RegPressureSchedule::BruteForceScheduling() {
+  /* stop brute force scheduling when exceeding the count limit */
+  if (kBruteMaximumLimit && (scheduleSeriesCount > kSchedulingMaximumCount)) {
+    return;
+  }
+  int defaultPressureValue = -1;
+  /* ReadyList is empty, scheduling is over */
+  if (readyList.empty()) {
+    if (originalNodeSeries.size() != scheduledNode.size()) {
+#ifdef PRESCHED_DEBUG
+      ReportScheduleError();
+#endif
+      return;
+    }
+    ++scheduleSeriesCount;
+    int currentPressure = CalculateRegisterPressure(scheduledNode);
+    if (minPressure == defaultPressureValue || currentPressure < minPressure) {
+      minPressure = currentPressure;
+      /* update better scheduled series */
+      optimisticScheduledNodes.clear();
+      for (auto node : scheduledNode) {
+        optimisticScheduledNodes.emplace_back(node);
+      }
+      return;
+    }
+    return;
+  }
+  /* store the current status of the ready list */
+  std::vector<DepNode*> innerList;
+  for (auto tempNode : readyList) {
+    innerList.emplace_back(tempNode);
+  }
+  for (auto *node : innerList) {
+    if (CanSchedule(*node)) {
+      /* update readyList and node dependency info */
+      std::vector<bool> changedToReady;
+      BruteUpdateReadyList(*node, changedToReady);
+      scheduledNode.emplace_back(node);
+      node->SetState(kScheduled);
+      BruteForceScheduling();
+      node->SetState(kReady);
+      /* restore readyList and node dependency info */
+      RestoreReadyList(*node, changedToReady);
+      scheduledNode.pop_back();
+    }
+  }
+}
+
+/*
+ * Calculate the pred size based on the dependency information
+ */
+void RegPressureSchedule::CalculatePredSize(DepNode &node) {
+  constexpr uint32 emptyPredsSize = 0;
+  node.SetValidPredsSize(emptyPredsSize);
+  for (auto pred : node.GetPreds()) {
+    DepNode &from = pred->GetFrom();
+    if (!partialSet.empty() && (partialSet.find(&from) == partialSet.end())) {
+      continue;
+    } else {
+      node.IncreaseValidPredsSize();
+    }
+  }
+}
+
+void RegPressureSchedule::InitBruteForceScheduling(MapleVector<DepNode*> &nodes) {
+  /* Calculate pred size of the node */
+  for (auto node : nodes) {
+    CalculatePredSize(*node);
+  }
+  readyList.clear();
+  optimisticScheduledNodes.clear();
+  scheduledNode.clear();
+  DepNode *firstNode = nodes.front();
+  firstNode->SetState(kReady);
+  readyList.emplace_back(firstNode);
+}
+
+/*
+ * Give out the pre-scheduling output based on new register pressure
+ */
+void RegPressureSchedule::EmitSchedulingSeries(MapleVector<DepNode*> &nodes) {
+#ifdef PRESCHED_DEBUG
+  ReportScheduleOutput();
+#endif
+  if (originalPressure <= scheduledPressure) {
+    /* Restore the original series */
+    nodes.clear();
+    for (auto node : originalNodeSeries) {
+      nodes.emplace_back(node);
+    }
+  }
+}
+
+/*
+ * ------------- Schedule function ----------
+ * calculate and mark each insn id, each BB's firstLoc and lastLoc.
+ */
+void Schedule::InitIDAndLoc() {
+  uint32 id = 0;
+  FOR_ALL_BB(bb, &cgFunc) {
+    bb->SetLastLoc(bb->GetPrev() ? bb->GetPrev()->GetLastLoc() : nullptr);
+    FOR_BB_INSNS(insn, bb) {
+      insn->SetId(id++);
+#if DEBUG
+      insn->AppendComment(" Insn id: " + std::to_string(insn->GetId()));
+#endif
+      if (insn->IsImmaterialInsn() && !insn->IsComment()) {
+        bb->SetLastLoc(insn);
+      } else if (!bb->GetFirstLoc() && insn->IsMachineInstruction()) {
+        bb->SetFirstLoc(*bb->GetLastLoc());
+      }
+    }
+  }
+}
+
+/* === new pm === */
+bool CgPreScheduling::PhaseRun(maplebe::CGFunc &f) {
+  if (f.HasAsm()) {
+    return true;
+  }
+  if (LIST_SCHED_DUMP_NEWPM) {
+    LogInfo::MapleLogger() << "Before CgDoPreScheduling : " << f.GetName() << "\n";
+    DotGenerator::GenerateDot("preschedule", f, f.GetMirModule(), true);
+  }
+  auto *live = GET_ANALYSIS(CgLiveAnalysis, f);
+  /* revert liveanalysis result container. */
+  ASSERT(live != nullptr, "nullptr check");
+  live->ResetLiveSet();
+
+  Schedule *schedule = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  schedule = GetPhaseAllocator()->New<AArch64Schedule>(f, *GetPhaseMemPool(), *live, PhaseName());
+#endif
+#if TARGARM32
+  schedule = GetPhaseAllocator()->New<Arm32Schedule>(f, *GetPhaseMemPool(), *live, PhaseName());
+#endif
+  schedule->ListScheduling(true);
+  live->ClearInOutDataInfo();
+
+  return true;
+}
+
+void CgPreScheduling::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.PreservedAllExcept<CgLiveAnalysis>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgPreScheduling, prescheduling)
+
+bool CgScheduling::PhaseRun(maplebe::CGFunc &f) {
+  if (f.HasAsm()) {
+    return true;
+  }
+  if (LIST_SCHED_DUMP_NEWPM) {
+    LogInfo::MapleLogger() << "Before CgDoScheduling : " << f.GetName() << "\n";
+    DotGenerator::GenerateDot("scheduling", f, f.GetMirModule(), true);
+  }
+  auto *live = GET_ANALYSIS(CgLiveAnalysis, f);
+  /* revert liveanalysis result container. */
+  ASSERT(live != nullptr, "nullptr check");
+  live->ResetLiveSet();
+
+  Schedule *schedule = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  schedule = GetPhaseAllocator()->New<AArch64Schedule>(f, *GetPhaseMemPool(), *live, PhaseName());
+#endif
+#if TARGARM32
+  schedule = GetPhaseAllocator()->New<Arm32Schedule>(f, *GetPhaseMemPool(), *live, PhaseName());
+#endif
+  schedule->ListScheduling(false);
+  live->ClearInOutDataInfo();
+
+  return true;
+}
+
+void CgScheduling::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgLiveAnalysis>();
+  aDep.PreservedAllExcept<CgLiveAnalysis>();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgScheduling, scheduling)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/standardize.cpp b/src/mapleall/maple_be/src/cg/standardize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cf14b253f5931e460dbebcc406cbdd0131ed9079
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/standardize.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "isel.h"
+#include "standardize.h"
+#include "cg.h"
+
+namespace maplebe {
+
+void Standardize::DoStandardize() {
+  /* two address mapping first */
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (NeedAddressMapping(*insn)) {
+        AddressMapping(*insn);
+      }
+    }
+  }
+
+  /* standardize for each op */
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (insn->IsMove()) {
+        StdzMov(*insn);
+      } else if (insn->IsStore() || insn->IsLoad()) {
+        StdzStrLdr(*insn);
+      } else if (insn->IsBasicOp()) {
+        StdzBasicOp(*insn);
+      } else if (insn->IsUnaryOp()) {
+        StdzUnaryOp(*insn, *cgFunc);
+      } else if (insn->IsConversion()) {
+        StdzCvtOp(*insn, *cgFunc);
+      } else if (insn->IsShift()) {
+        StdzShiftOp(*insn, *cgFunc);
+      } else {
+        LogInfo::MapleLogger() << "Need STDZ function for " << insn->GetDesc()->GetName() << "\n";
+        CHECK_FATAL(false, "NIY");
+      }
+    }
+  }
+}
+
+void Standardize::AddressMapping(Insn &insn) const {
+  Operand &dest = insn.GetOperand(kInsnFirstOpnd);
+  Operand &src1 = insn.GetOperand(kInsnSecondOpnd);
+  uint32 destSize = dest.GetSize();
+  MOperator mOp = abstract::MOP_undef;
+  switch (destSize) {
+    case k8BitSize:
+      mOp = abstract::MOP_copy_rr_8;
+      break;
+    case k16BitSize:
+      mOp = abstract::MOP_copy_rr_16;
+      break;
+    case k32BitSize:
+      mOp = abstract::MOP_copy_rr_32;
+      break;
+    case k64BitSize:
+      mOp = abstract::MOP_copy_rr_64;
+      break;
+    default:
+      break;
+  }
+  CHECK_FATAL(mOp != abstract::MOP_undef, "do two address mapping failed");
+  Insn &newInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, InsnDesc::GetAbstractId(mOp));
+  (void)newInsn.AddOpndChain(dest).AddOpndChain(src1);
+  (void)insn.GetBB()->InsertInsnBefore(insn, newInsn);
+}
+
+bool InstructionStandardize::PhaseRun(maplebe::CGFunc &f) {
+  Standardize *stdz = f.GetCG()->CreateStandardize(*GetPhaseMemPool(), f);
+  stdz->DoStandardize();
+  return true;
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/strldr.cpp b/src/mapleall/maple_be/src/cg/strldr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c621bf4450f25d6d09ea953ba048758b434cdbc0
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/strldr.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#if TARGAARCH64
+#include "aarch64_strldr.h"
+#elif TARGRISCV64
+#include "riscv64_strldr.h"
+#endif
+#if TARGARM32
+#include "arm32_strldr.h"
+#endif
+#include "reaching.h"
+#include "cg.h"
+#include "optimize_common.h"
+
+namespace maplebe {
+using namespace maple;
+#define SCHD_DUMP_NEWPM CG_DEBUG_FUNC(f)
+bool CgStoreLoadOpt::PhaseRun(maplebe::CGFunc &f) {
+  if (SCHD_DUMP_NEWPM) {
+    DotGenerator::GenerateDot("storeloadopt", f, f.GetMirModule(), true);
+  }
+  ReachingDefinition *reachingDef = nullptr;
+  if (Globals::GetInstance()->GetOptimLevel() >= CGOptions::kLevel2) {
+    reachingDef = GET_ANALYSIS(CgReachingDefinition, f);
+  }
+  if (reachingDef == nullptr || !f.GetRDStatus()) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &CgReachingDefinition::id);
+    return false;
+  }
+  (void)GetAnalysisInfoHook()->ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgLoopAnalysis::id, f);
+
+  StoreLoadOpt *storeLoadOpt = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  storeLoadOpt = GetPhaseMemPool()->New<AArch64StoreLoadOpt>(f, *GetPhaseMemPool());
+#endif
+#if TARGARM32
+  storeLoadOpt = GetPhaseMemPool()->New<Arm32StoreLoadOpt>(f, *GetPhaseMemPool());
+#endif
+  storeLoadOpt->Run();
+  return true;
+}
+void CgStoreLoadOpt::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<CgReachingDefinition>();
+  aDep.SetPreservedAll();
+}
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgStoreLoadOpt, storeloadopt)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/tailcall.cpp b/src/mapleall/maple_be/src/cg/tailcall.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..34b90aa5f1d1baaf1077be96b9ed521e4616adaf
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/tailcall.cpp
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "tailcall.h"
+#include "cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+/* tailcallopt cannot be used if stack address of this function is taken and passed,
+   not checking the passing for now, just taken */
+bool TailCallOpt::IsStackAddrTaken() {
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS_REV(insn, bb) {
+      if (!IsAddOrSubOp(insn->GetMachineOpcode())) {
+        continue;
+      }
+      for (uint32 i = 0; i < insn->GetOperandSize(); i++) {
+        if (insn->GetOperand(i).IsRegister()) {
+          RegOperand &reg = static_cast<RegOperand&>(insn->GetOperand(i));
+          if (OpndIsStackRelatedReg(reg)) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
+/*
+ *  Remove redundant mov and mark optimizable bl/blr insn in the BB.
+ *  Return value: true to call this modified block again.
+ */
+bool TailCallOpt::OptimizeTailBB(BB &bb, MapleSet<Insn*> &callInsns, const BB &exitBB) const {
+  Insn *lastInsn = bb.GetLastInsn();
+  if (bb.NumInsn() == 1 && lastInsn->IsMachineInstruction() &&
+      !AArch64isa::IsPseudoInstruction(lastInsn->GetMachineOpcode()) && !InsnIsCallCand(*bb.GetLastInsn())) {
+    return false;
+  }
+  FOR_BB_INSNS_REV_SAFE(insn, &bb, prevInsn) {
+    if (!insn->IsMachineInstruction() || AArch64isa::IsPseudoInstruction(insn->GetMachineOpcode())) {
+      continue;
+    }
+    if (InsnIsLoadPair(*insn)) {
+      if (bb.GetKind() == BB::kBBReturn) {
+        RegOperand &reg = static_cast<RegOperand &>(insn->GetOperand(0));
+        if (OpndIsCalleeSaveReg(reg)) {
+          continue;  /* inserted restore from calleeregs-placement, ignore */
+        }
+      }
+      return false;
+    } else if (InsnIsMove(*insn)) {
+      CHECK_FATAL(insn->GetOperand(0).IsRegister(), "operand0 is not register");
+      CHECK_FATAL(insn->GetOperand(1).IsRegister(), "operand1 is not register");
+      auto &reg1 = static_cast<RegOperand&>(insn->GetOperand(0));
+      auto &reg2 = static_cast<RegOperand&>(insn->GetOperand(1));
+      if (!OpndIsR0Reg(reg1) || !OpndIsR0Reg(reg2)) {
+        return false;
+      }
+      bb.RemoveInsn(*insn);
+      continue;
+    } else if (InsnIsIndirectCall(*insn)) {
+      if (insn->GetOperand(0).IsRegister()) {
+        RegOperand &reg = static_cast<RegOperand&>(insn->GetOperand(0));
+        if (OpndIsCalleeSaveReg(reg)) {
+          return false;  /* can't tailcall, register will be overwritten by restore */
+        }
+      }
+      (void)callInsns.insert(insn);
+      return false;
+    } else if (InsnIsCall(*insn)) {
+      (void)callInsns.insert(insn);
+      return false;
+    } else if (InsnIsUncondJump(*insn)) {
+      LabelOperand &bLab = static_cast<LabelOperand&>(insn->GetOperand(0));
+      if (exitBB.GetLabIdx() == bLab.GetLabelIndex()) {
+        continue;
+      }
+      return false;
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+/* Recursively invoke this function for all predecessors of exitBB */
+void TailCallOpt::TailCallBBOpt(BB &bb, MapleSet<Insn*> &callInsns, BB &exitBB) {
+  /* callsite also in the return block as in "if () return; else foo();"
+     call in the exit block */
+  if (!bb.IsEmpty() && !OptimizeTailBB(bb, callInsns, exitBB)) {
+    return;
+  }
+
+  for (auto tmpBB : bb.GetPreds()) {
+    if (tmpBB->GetSuccs().size() != 1 || !tmpBB->GetEhSuccs().empty() ||
+        (tmpBB->GetKind() != BB::kBBFallthru && tmpBB->GetKind() != BB::kBBGoto)) {
+      continue;
+    }
+
+    if (OptimizeTailBB(*tmpBB, callInsns, exitBB)) {
+      TailCallBBOpt(*tmpBB, callInsns, exitBB);
+    }
+  }
+}
+
+/*
+ *  If a function without callee-saved register, and end with a function call,
+ *  then transfer bl/blr to b/br.
+ *  Return value: true if function do not need Prologue/Epilogue. false otherwise.
+ */
+bool TailCallOpt::DoTailCallOpt() {
+  /* Count how many call insns in the whole function. */
+  uint32 nCount = 0;
+  bool hasGetStackClass = false;
+
+  FOR_ALL_BB(bb, &cgFunc) {
+    FOR_BB_INSNS(insn, bb) {
+      if (insn->IsCall()) {
+        /*
+         * lib call "savectx, vfork, getcontext" which might cause fault
+         * not in whitelist yet
+         */
+        if (InsnIsCall(*insn) && IsFuncNeedFrame(*insn)) {
+          hasGetStackClass = true;
+        }
+        ++nCount;
+      }
+    }
+  }
+  if ((nCount > 0 && cgFunc.GetFunction().GetAttr(FUNCATTR_interface)) || hasGetStackClass) {
+    return false;
+  }
+
+  if (nCount == 0) {
+    // no bl instr in any bb
+    return true;
+  }
+
+  size_t exitBBSize = cgFunc.GetExitBBsVec().size();
+  /* For now to reduce complexity */
+
+  BB *exitBB = nullptr;
+  if (exitBBSize == 0) {
+    if (cgFunc.GetCleanupBB() != nullptr && cgFunc.GetCleanupBB()->GetPrev() != nullptr) {
+      exitBB = cgFunc.GetCleanupBB()->GetPrev();
+    } else {
+      exitBB = cgFunc.GetLastBB()->GetPrev();
+    }
+  } else {
+    exitBB = cgFunc.GetExitBBsVec().front();
+  }
+  uint32 i = 1;
+  size_t optCount = 0;
+  do {
+    MapleSet<Insn*> callInsns(tmpAlloc.Adapter());
+    TailCallBBOpt(*exitBB, callInsns, *exitBB);
+    if (callInsns.size() != 0) {
+      optCount += callInsns.size();
+      (void)exitBB2CallSitesMap.emplace(exitBB, callInsns);
+    }
+    if (i < exitBBSize) {
+      exitBB = cgFunc.GetExitBBsVec()[i];
+      ++i;
+    } else {
+      break;
+    }
+  } while (true);
+
+  /* unequal means regular calls exist in function */
+  return nCount == optCount;
+}
+
+void TailCallOpt::ConvertToTailCalls(MapleSet<Insn*> &callInsnsMap) {
+  BB *exitBB = GetCurTailcallExitBB();
+
+  /* ExitBB is filled only by now. If exitBB has restore of SP indicating extra stack space has
+     been allocated, such as a function call with more than 8 args, argument with large aggr etc */
+  int64 argsToStkPassSize = cgFunc.GetMemlayout()->SizeOfArgsToStackPass();
+  if (!cgFunc.HasVLAOrAlloca() && argsToStkPassSize > 0) {
+    return;
+  }
+  FOR_BB_INSNS(insn, exitBB) {
+    if (InsnIsAddWithRsp(*insn)) {
+      return;
+    }
+  }
+
+  /* Replace all of the call insns. */
+  for (Insn *callInsn : callInsnsMap) {
+    ReplaceInsnMopWithTailCall(*callInsn);
+    BB *bb = callInsn->GetBB();
+    if (bb->GetKind() == BB::kBBGoto) {
+      bb->SetKind(BB::kBBFallthru);
+      if (InsnIsUncondJump(*bb->GetLastInsn())) {
+        bb->RemoveInsn(*bb->GetLastInsn());
+      }
+    }
+    ASSERT(bb->GetSuccs().size() <= 1, "expect no succ or single succ");
+    for (auto sBB: bb->GetSuccs()) {
+      bb->RemoveSuccs(*sBB);
+      sBB->RemovePreds(*bb);
+      bb->SetKind(BB::kBBReturn);
+      cgFunc.PushBackExitBBsVec(*bb);
+      cgFunc.GetCommonExitBB()->PushBackPreds(*bb);
+        /* if next bb is exit BB */
+      if (sBB->GetKind() == BB::kBBReturn && sBB->GetPreds().empty() &&
+          !CGCFG::InSwitchTable(sBB->GetLabIdx(), cgFunc)) {
+        auto it = std::find(cgFunc.GetExitBBsVec().begin(), cgFunc.GetExitBBsVec().end(), sBB);
+        CHECK_FATAL(it != cgFunc.GetExitBBsVec().end(), "find unuse exit failed");
+        cgFunc.EraseExitBBsVec(it);
+        cgFunc.GetTheCFG()->RemoveBB(*sBB);
+      }
+      break;
+    }
+  }
+}
+
+void TailCallOpt::TideExitBB() {
+  cgFunc.GetTheCFG()->UnreachCodeAnalysis();
+  std::vector<BB*> realRets;
+  for (auto *exitBB : cgFunc.GetExitBBsVec()) {
+    if (!exitBB->GetPreds().empty()) {
+      (void)realRets.emplace_back(exitBB);
+    }
+  }
+  cgFunc.ClearExitBBsVec();
+  for (auto *cand: realRets) {
+    cgFunc.PushBackExitBBsVec(*cand);
+  }
+}
+
+void TailCallOpt::Run() {
+  stackProtect = cgFunc.GetNeedStackProtect();
+  if (cgFunc.GetCG()->DoTailCall() && !IsStackAddrTaken() && !stackProtect) {
+    (void)DoTailCallOpt(); // return value == "no call instr/only or 1 tailcall"
+  }
+  if (cgFunc.GetMirModule().IsCModule() && !exitBB2CallSitesMap.empty()) {
+    cgFunc.GetTheCFG()->InitInsnVisitor(cgFunc);
+    for (auto pair : exitBB2CallSitesMap) {
+      BB *curExitBB = pair.first;
+      MapleSet<Insn*>& callInsnsMap = pair.second;
+      SetCurTailcallExitBB(curExitBB);
+      ConvertToTailCalls(callInsnsMap);
+    }
+    TideExitBB();
+  }
+}
+
+bool CgTailCallOpt::PhaseRun(maplebe::CGFunc &f) {
+  TailCallOpt *tailCallOpt = f.GetCG()->CreateCGTailCallOpt(*GetPhaseMemPool(), f);
+  tailCallOpt->Run();
+  return false;
+}
+
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CgTailCallOpt, tailcallopt)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_MPIsel.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_MPIsel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0ab915ee2d448f25422d6815c5feb0c41060eaf
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_MPIsel.cpp
@@ -0,0 +1,1278 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "x64_MPISel.h"
+#include "x64_memlayout.h"
+#include "x64_cgfunc.h"
+#include "x64_isa_tbl.h"
+#include "x64_cg.h"
+#include "isel.h"
+
+namespace maplebe {
+/* Field-ID 0 is assigned to the top level structure. (Field-ID also defaults to 0 if it is not a structure.) */
+MemOperand &X64MPIsel::GetOrCreateMemOpndFromSymbol(const MIRSymbol &symbol, FieldID fieldId) const {
+  PrimType symType;
+  int32 fieldOffset = 0;
+  if (fieldId == 0) {
+    symType = symbol.GetType()->GetPrimType();
+  } else {
+    MIRType *mirType = symbol.GetType();
+    ASSERT((mirType->IsMIRStructType() || mirType->IsMIRUnionType()), "non-structure");
+    MIRStructType *structType = static_cast<MIRStructType*>(mirType);
+    symType = structType->GetFieldType(fieldId)->GetPrimType();
+    fieldOffset = static_cast<uint32>(cgFunc->GetBecommon().GetFieldOffset(*structType, fieldId).first);
+  }
+  uint32 opndSz = (symType == PTY_agg) ? k64BitSize : GetPrimTypeBitSize(symType);
+  return GetOrCreateMemOpndFromSymbol(symbol, opndSz, fieldOffset);
+}
+
+MemOperand &X64MPIsel::GetOrCreateMemOpndFromSymbol(const MIRSymbol &symbol, uint32 opndSize, int64 offset) const {
+  MIRStorageClass storageClass = symbol.GetStorageClass();
+  MemOperand *result = nullptr;
+  RegOperand *stackBaseReg = nullptr;
+  if ((storageClass == kScAuto) || (storageClass == kScFormal)) {
+    auto *symloc = static_cast<X64SymbolAlloc*>(cgFunc->GetMemlayout()->GetSymAllocInfo(symbol.GetStIndex()));
+    ASSERT(symloc != nullptr, "sym loc should have been defined");
+    stackBaseReg = static_cast<X64CGFunc*>(cgFunc)->GetBaseReg(*symloc);
+    int stOfst = cgFunc->GetBaseOffset(*symloc);
+    /* Create field symbols in aggregate structure */
+    result = &GetCurFunc()->GetOpndBuilder()->CreateMem(opndSize);
+    result->SetBaseRegister(*stackBaseReg);
+    result->SetOffsetOperand(GetCurFunc()->GetOpndBuilder()->CreateImm(
+        k64BitSize, stOfst + offset));
+    CHECK_FATAL(result != nullptr, "NIY");
+    return *result;
+  }
+  if ((storageClass == kScGlobal) || (storageClass == kScExtern) ||
+      (storageClass == kScPstatic) || (storageClass == kScFstatic)) {
+    stackBaseReg = &GetCurFunc()->GetOpndBuilder()->CreatePReg(x64::RIP, k64BitSize, kRegTyInt);
+    result = &GetCurFunc()->GetOpndBuilder()->CreateMem(opndSize);
+    ImmOperand &stOfstOpnd = GetCurFunc()->GetOpndBuilder()->CreateImm(symbol, offset, 0);
+    result->SetBaseRegister(*stackBaseReg);
+    result->SetOffsetOperand(stOfstOpnd);
+    CHECK_FATAL(result != nullptr, "NIY");
+    return *result;
+  }
+  CHECK_FATAL(false, "NIY");
+  return *result;
+}
+
+void X64MPIsel::SelectReturn(NaryStmtNode &retNode, Operand &opnd) {
+  MIRType *retType = cgFunc->GetFunction().GetReturnType();
+  X64CallConvImpl retLocator(cgFunc->GetBecommon());
+  CCLocInfo retMech;
+  retLocator.LocateRetVal(*retType, retMech);
+  if (retMech.GetRegCount() == 0) {
+    return;
+  }
+  std::vector<RegOperand*> retRegs;
+  if (!cgFunc->GetFunction().StructReturnedInRegs() ||
+      retNode.Opnd(0)->GetOpCode() == OP_constval) {
+    PrimType oriPrimType = retMech.GetPrimTypeOfReg0();
+    regno_t retReg = retMech.GetReg0();
+    ASSERT(retReg != kRinvalid, "NIY");
+    RegOperand &retOpnd = cgFunc->GetOpndBuilder()->CreatePReg(retReg, GetPrimTypeBitSize(oriPrimType),
+        cgFunc->GetRegTyFromPrimTy(oriPrimType));
+    retRegs.push_back(&retOpnd);
+    SelectCopy(retOpnd, opnd, oriPrimType, retNode.Opnd(0)->GetPrimType());
+  } else {
+    CHECK_FATAL(opnd.IsMemoryAccessOperand(), "NIY");
+    MemOperand &memOpnd = static_cast<MemOperand&>(opnd);
+    ImmOperand *offsetOpnd = memOpnd.GetOffsetOperand();
+    RegOperand *baseOpnd = memOpnd.GetBaseRegister();
+
+    PrimType oriPrimType0 = retMech.GetPrimTypeOfReg0();
+    regno_t retReg0 = retMech.GetReg0();
+    ASSERT(retReg0 != kRinvalid, "NIY");
+    RegOperand &retOpnd0 = cgFunc->GetOpndBuilder()->CreatePReg(retReg0, GetPrimTypeBitSize(oriPrimType0),
+        cgFunc->GetRegTyFromPrimTy(oriPrimType0));
+    MemOperand &rhsMemOpnd0 = cgFunc->GetOpndBuilder()->CreateMem(GetPrimTypeBitSize(oriPrimType0));
+    rhsMemOpnd0.SetBaseRegister(*baseOpnd);
+    rhsMemOpnd0.SetOffsetOperand(*offsetOpnd);
+    retRegs.push_back(&retOpnd0);
+    SelectCopy(retOpnd0, rhsMemOpnd0, oriPrimType0);
+
+    regno_t retReg1 = retMech.GetReg1();
+    if (retReg1 != kRinvalid) {
+      PrimType oriPrimType1 = retMech.GetPrimTypeOfReg1();
+      RegOperand &retOpnd1 = cgFunc->GetOpndBuilder()->CreatePReg(retReg1, GetPrimTypeBitSize(oriPrimType1),
+          cgFunc->GetRegTyFromPrimTy(oriPrimType1));
+      MemOperand &rhsMemOpnd1 = cgFunc->GetOpndBuilder()->CreateMem(GetPrimTypeBitSize(oriPrimType1));
+      ImmOperand &newOffsetOpnd = static_cast<ImmOperand&>(*offsetOpnd->Clone(*cgFunc->GetMemoryPool()));
+      newOffsetOpnd.SetValue(newOffsetOpnd.GetValue() + GetPrimTypeSize(oriPrimType0));
+      rhsMemOpnd1.SetBaseRegister(*baseOpnd);
+      rhsMemOpnd1.SetOffsetOperand(newOffsetOpnd);
+      retRegs.push_back(&retOpnd1);
+      SelectCopy(retOpnd1, rhsMemOpnd1, oriPrimType1);
+    }
+  }
+  /* for optimization ,insert pseudo ret ,in case rax,rdx is removed*/
+  SelectPseduoForReturn(retRegs);
+}
+
+void X64MPIsel::SelectPseduoForReturn(std::vector<RegOperand*> &retRegs) {
+  for (auto retReg : retRegs) {
+    MOperator mop = x64::MOP_pseudo_ret_int;
+    Insn &pInsn = cgFunc->GetInsnBuilder()->BuildInsn(mop, X64CG::kMd[mop]);
+    cgFunc->GetCurBB()->AppendInsn(pInsn);
+    pInsn.AddOpndChain(*retReg);
+  }
+}
+
+void X64MPIsel::SelectReturn() {
+  /* jump to epilogue */
+  MOperator mOp = x64::MOP_jmpq_l;
+  LabelNode *endLabel = cgFunc->GetEndLabel();
+  auto endLabelName = ".L." + std::to_string(cgFunc->GetUniqueID()) + "__" + std::to_string(endLabel->GetLabelIdx());
+  LabelOperand &targetOpnd = cgFunc->GetOpndBuilder()->CreateLabel(endLabelName.c_str(), endLabel->GetLabelIdx());
+  Insn &jmpInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  jmpInsn.AddOpndChain(targetOpnd);
+  cgFunc->GetCurBB()->AppendInsn(jmpInsn);
+  cgFunc->GetExitBBsVec().emplace_back(cgFunc->GetCurBB());
+}
+
+void X64MPIsel::CreateCallStructParamPassByStack(MemOperand &memOpnd, int32 symSize, int32 baseOffset) {
+  int32 copyTime = RoundUp(symSize, GetPointerSize()) / GetPointerSize();
+  for (int32 i = 0; i < copyTime; ++i) {
+    MemOperand &addrMemOpnd = cgFunc->GetOpndBuilder()->CreateMem(k64BitSize);
+    addrMemOpnd.SetBaseRegister(*memOpnd.GetBaseRegister());
+    ImmOperand &newImmOpnd = static_cast<ImmOperand&>(*memOpnd.GetOffsetOperand()->Clone(*cgFunc->GetMemoryPool()));
+    newImmOpnd.SetValue(newImmOpnd.GetValue() + i * GetPointerSize());
+    addrMemOpnd.SetOffsetOperand(newImmOpnd);
+    RegOperand &spOpnd = cgFunc->GetOpndBuilder()->CreatePReg(x64::RSP, k64BitSize, kRegTyInt);
+    Operand &stMemOpnd = cgFunc->GetOpndBuilder()->CreateMem(spOpnd,
+        (baseOffset + i * GetPointerSize()), k64BitSize);
+    SelectCopy(stMemOpnd, addrMemOpnd, PTY_u64);
+  }
+}
+
+void X64MPIsel::CreateCallStructParamPassByReg(MemOperand &memOpnd, regno_t regNo, uint32 parmNum) {
+  CHECK_FATAL(parmNum < kMaxStructParamByReg, "Exceeded maximum allowed fp parameter registers for struct passing");
+  RegOperand &parmOpnd = cgFunc->GetOpndBuilder()->CreatePReg(regNo, k64BitSize, kRegTyInt);
+  MemOperand &addrMemOpnd = cgFunc->GetOpndBuilder()->CreateMem(k64BitSize);
+  addrMemOpnd.SetBaseRegister(*memOpnd.GetBaseRegister());
+  ImmOperand &newImmOpnd = static_cast<ImmOperand&>(*memOpnd.GetOffsetOperand()->Clone(*cgFunc->GetMemoryPool()));
+  newImmOpnd.SetValue(newImmOpnd.GetValue() + parmNum * GetPointerSize());
+  addrMemOpnd.SetOffsetOperand(newImmOpnd);
+  paramPassByReg.push_back({&parmOpnd, &addrMemOpnd, PTY_a64});
+}
+
+std::tuple<Operand*, size_t, MIRType*> X64MPIsel::GetMemOpndInfoFromAggregateNode(BaseNode &argExpr) {
+  /* get mirType info */
+  auto [fieldId, mirType] = GetFieldIdAndMirTypeFromMirNode(argExpr);
+  MirTypeInfo symInfo = GetMirTypeInfoFormFieldIdAndMirType(fieldId, mirType);
+  /* get symbol memOpnd info */
+  MemOperand *symMemOpnd = nullptr;
+  if (argExpr.GetOpCode() == OP_dread) {
+    AddrofNode &dread = static_cast<AddrofNode&>(argExpr);
+    MIRSymbol *symbol = cgFunc->GetFunction().GetLocalOrGlobalSymbol(dread.GetStIdx());
+    symMemOpnd = &GetOrCreateMemOpndFromSymbol(*symbol, dread.GetFieldID());
+  } else if (argExpr.GetOpCode() == OP_iread) {
+    IreadNode &iread = static_cast<IreadNode&>(argExpr);
+    symMemOpnd = GetOrCreateMemOpndFromIreadNode(iread, symInfo.primType, symInfo.offset);
+  } else {
+    CHECK_FATAL(false, "unsupported opcode");
+  }
+  return {symMemOpnd, symInfo.size, mirType};
+}
+
+void X64MPIsel::SelectParmListForAggregate(BaseNode &argExpr, X64CallConvImpl &parmLocator, bool isArgUnused) {
+  auto [argOpnd, argSize, mirType] = GetMemOpndInfoFromAggregateNode(argExpr);
+  ASSERT(argOpnd->IsMemoryAccessOperand(), "wrong opnd");
+  MemOperand &memOpnd = static_cast<MemOperand&>(*argOpnd);
+
+  CCLocInfo ploc;
+  parmLocator.LocateNextParm(*mirType, ploc);
+  if (isArgUnused) {
+    return;
+  }
+
+  /* create call struct param pass */
+  if (argSize > k16ByteSize || ploc.reg0 == kRinvalid) {
+    CreateCallStructParamPassByStack(memOpnd, argSize, ploc.memOffset);
+  } else {
+    CHECK_FATAL(ploc.fpSize == 0, "Unknown call parameter state");
+    CreateCallStructParamPassByReg(memOpnd, ploc.reg0, 0);
+    if (ploc.reg1 != kRinvalid) {
+      CreateCallStructParamPassByReg(memOpnd, ploc.reg1, 1);
+    }
+    if (ploc.reg2 != kRinvalid) {
+      CreateCallStructParamPassByReg(memOpnd, ploc.reg2, 2);
+    }
+    if (ploc.reg3 != kRinvalid) {
+      CreateCallStructParamPassByReg(memOpnd, ploc.reg3, 3);
+    }
+  }
+}
+
+/*
+ * SelectParmList generates an instrunction for each of the parameters
+ * to load the parameter value into the corresponding register.
+ * We return a list of registers to the call instruction because
+ * they may be needed in the register allocation phase.
+ * fp Num is a return value which is the number of vector
+ * registers used;
+ */
+void X64MPIsel::SelectParmList(StmtNode &naryNode, ListOperand &srcOpnds, uint32 &fpNum) {
+  paramPassByReg.clear();
+  fpNum = 0;
+  /* for IcallNode, the 0th operand is the function pointer */
+  size_t argBegin = 0;
+  if (naryNode.GetOpCode() == OP_icall || naryNode.GetOpCode() == OP_icallproto) {
+    ++argBegin;
+  }
+
+  MIRFunction *callee = nullptr;
+  if (naryNode.GetOpCode() == OP_call) {
+    PUIdx calleePuIdx = static_cast<CallNode&>(naryNode).GetPUIdx();
+    callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleePuIdx);
+  }
+  X64CallConvImpl parmLocator(cgFunc->GetBecommon());
+  CCLocInfo ploc;
+  for (size_t i = argBegin; i < naryNode.NumOpnds(); ++i) {
+    BaseNode *argExpr = naryNode.Opnd(i);
+    ASSERT(argExpr != nullptr, "not null check");
+    PrimType primType = argExpr->GetPrimType();
+    ASSERT(primType != PTY_void, "primType should not be void");
+    bool isArgUnused = (callee != nullptr && callee->GetFuncDesc().IsArgUnused(i));
+    if (primType == PTY_agg) {
+      SelectParmListForAggregate(*argExpr, parmLocator, isArgUnused);
+      continue;
+    }
+
+    Operand *argOpnd = HandleExpr(naryNode, *argExpr);
+    ASSERT(argOpnd != nullptr, "not null check");
+    MIRType *mirType = GlobalTables::GetTypeTable().GetTypeTable()[static_cast<uint32>(primType)];
+    parmLocator.LocateNextParm(*mirType, ploc);
+
+    /* skip unused args */
+    if (isArgUnused) {
+      continue;
+    }
+
+    if (ploc.reg0 != x64::kRinvalid) {
+      /* load to the register. */
+      RegOperand &parmRegOpnd = cgFunc->GetOpndBuilder()->CreatePReg(ploc.reg0,
+          GetPrimTypeBitSize(primType), cgFunc->GetRegTyFromPrimTy(primType));
+      paramPassByReg.push_back({&parmRegOpnd, argOpnd, primType});
+      if (x64::IsFPSIMDRegister(static_cast<X64reg>(ploc.reg0))) {
+        fpNum++;
+      }
+    } else {
+      /* load to stack memory */
+      RegOperand &baseOpnd = cgFunc->GetOpndBuilder()->CreatePReg(x64::RSP, k64BitSize,
+          cgFunc->GetRegTyFromPrimTy(primType));
+      MemOperand &actMemOpnd = cgFunc->GetOpndBuilder()->CreateMem(baseOpnd, ploc.memOffset,
+          GetPrimTypeBitSize(primType));
+      SelectCopy(actMemOpnd, *argOpnd, primType);
+    }
+    ASSERT(ploc.reg1 == 0, "SelectCall NIY");
+  }
+
+  /* param pass by reg */
+  for (auto [regOpnd, argOpnd, primType] : paramPassByReg) {
+    ASSERT(regOpnd != nullptr, "not null check");
+    ASSERT(argOpnd != nullptr, "not null check");
+    SelectCopy(*regOpnd, *argOpnd, primType);
+    srcOpnds.PushOpnd(*regOpnd);
+  }
+}
+
+bool X64MPIsel::IsParamStructCopy(const MIRSymbol &symbol) {
+  if (symbol.GetStorageClass() == kScFormal &&
+      cgFunc->GetBecommon().GetTypeSize(symbol.GetTyIdx().GetIdx()) > k16ByteSize) {
+    return true;
+  }
+  return false;
+}
+
+void X64MPIsel::SelectIntAggCopyReturn(MemOperand &symbolMem, uint64 aggSize) {
+  CHECK_FATAL((aggSize > 0) && (aggSize <= k16ByteSize), "out of range.");
+  RegOperand *baseOpnd = symbolMem.GetBaseRegister();
+  int32 stOffset = symbolMem.GetOffsetOperand()->GetValue();
+  bool isCopyOneReg = (aggSize <= k8ByteSize);
+  int32 extraSize = (aggSize % k8ByteSize) * kBitsPerByte;
+  if (extraSize == 0) {
+    extraSize = k64BitSize;
+  } else if (extraSize <= k8BitSize) {
+    extraSize = k8BitSize;
+  } else if (extraSize <= k16BitSize) {
+    extraSize = k16BitSize;
+  } else if (extraSize <= k32BitSize) {
+    extraSize = k32BitSize;
+  } else {
+    extraSize = k64BitSize;
+  }
+  /* generate move from return registers(rax, rdx) to mem of symbol */
+  PrimType extraTy = GetIntegerPrimTypeFromSize(false, extraSize);
+  /* mov %rax mem */
+  RegOperand &regRhs0 = cgFunc->GetOpndBuilder()->CreatePReg(x64::RAX,
+      (isCopyOneReg ? extraSize : k64BitSize), kRegTyInt);
+  MemOperand &memSymbo0 = cgFunc->GetOpndBuilder()->CreateMem(*baseOpnd,
+      static_cast<int32>(stOffset), isCopyOneReg ? extraSize : k64BitSize);
+  SelectCopy(memSymbo0, regRhs0, isCopyOneReg ? extraTy : PTY_u64);
+  /* mov %rdx mem */
+  if (!isCopyOneReg) {
+    RegOperand &regRhs1 = cgFunc->GetOpndBuilder()->CreatePReg(x64::RDX, extraSize, kRegTyInt);
+    MemOperand &memSymbo1 = cgFunc->GetOpndBuilder()->CreateMem(*baseOpnd,
+        static_cast<int32>(stOffset + k8ByteSize), extraSize);
+    SelectCopy(memSymbo1, regRhs1, extraTy);
+  }
+  return;
+}
+
+void X64MPIsel::SelectAggCopy(MemOperand &lhs, MemOperand &rhs, uint32 copySize) {
+  /* in x86-64, 8 bytes data is copied at a time */
+  uint32 copyTimes = copySize / k8ByteSize;
+  uint32 extraCopySize = copySize % k8ByteSize;
+  ImmOperand *stOfstLhs = lhs.GetOffsetOperand();
+  ImmOperand *stOfstRhs = rhs.GetOffsetOperand();
+  RegOperand *baseLhs = lhs.GetBaseRegister();
+  RegOperand *baseRhs = rhs.GetBaseRegister();
+  if (copySize < 40U) {
+    for (int32 i = 0; i < copyTimes; ++i) {
+      /* prepare dest addr */
+      MemOperand &memOpndLhs = cgFunc->GetOpndBuilder()->CreateMem(k64BitSize);
+      memOpndLhs.SetBaseRegister(*baseLhs);
+      ImmOperand &newStOfstLhs = static_cast<ImmOperand&>(*stOfstLhs->Clone(*cgFunc->GetMemoryPool()));
+      newStOfstLhs.SetValue(newStOfstLhs.GetValue() + i * k8ByteSize);
+      memOpndLhs.SetOffsetOperand(newStOfstLhs);
+      /* prepare src addr */
+      MemOperand &memOpndRhs = cgFunc->GetOpndBuilder()->CreateMem(k64BitSize);
+      memOpndRhs.SetBaseRegister(*baseRhs);
+      ImmOperand &newStOfstRhs = static_cast<ImmOperand&>(*stOfstRhs->Clone(*cgFunc->GetMemoryPool()));
+      newStOfstRhs.SetValue(newStOfstRhs.GetValue() + i * k8ByteSize);
+      memOpndRhs.SetOffsetOperand(newStOfstRhs);
+      /* copy data */
+      SelectCopy(memOpndLhs, memOpndRhs, PTY_a64);
+    }
+  } else {
+    /* adopt rep insn in x64's isa */
+    std::vector<Operand*> opndVec;
+    opndVec.push_back(PrepareMemcpyParm(lhs, MOP_leaq_m_r));
+    opndVec.push_back(PrepareMemcpyParm(rhs, MOP_leaq_m_r));
+    opndVec.push_back(PrepareMemcpyParm(copySize));
+    SelectLibCallNoReturn("memcpy", opndVec, PTY_a64);
+    return;
+  }
+  /* take care of extra content at the end less than the unit */
+  if (extraCopySize == 0) {
+    return;
+  }
+  extraCopySize = ((extraCopySize <= k4ByteSize) ? k4ByteSize : k8ByteSize) * kBitsPerByte;
+  PrimType extraTy = GetIntegerPrimTypeFromSize(false, extraCopySize);
+  MemOperand &memOpndLhs = cgFunc->GetOpndBuilder()->CreateMem(extraCopySize);
+  memOpndLhs.SetBaseRegister(*baseLhs);
+  ImmOperand &newStOfstLhs = static_cast<ImmOperand&>(*stOfstLhs->Clone(*cgFunc->GetMemoryPool()));
+  newStOfstLhs.SetValue(newStOfstLhs.GetValue() + copyTimes * k8ByteSize);
+  memOpndLhs.SetOffsetOperand(newStOfstLhs);
+  MemOperand &memOpndRhs = cgFunc->GetOpndBuilder()->CreateMem(extraCopySize);
+  memOpndRhs.SetBaseRegister(*baseRhs);
+  ImmOperand &newStOfstRhs = static_cast<ImmOperand&>(*stOfstRhs->Clone(*cgFunc->GetMemoryPool()));
+  newStOfstRhs.SetValue(newStOfstRhs.GetValue() + copyTimes * k8ByteSize);
+  memOpndRhs.SetOffsetOperand(newStOfstRhs);
+  SelectCopy(memOpndLhs, memOpndRhs, extraTy);
+}
+
+void X64MPIsel::SelectLibCallNoReturn(const std::string &funcName, std::vector<Operand*> &opndVec, PrimType primType) {
+  /* generate libcall withou return value */
+  std::vector <PrimType> pt(opndVec.size(), primType);
+  SelectLibCallNArg(funcName, opndVec, pt);
+  return;
+}
+
+void X64MPIsel::SelectLibCallNArg(const std::string &funcName, std::vector<Operand*> &opndVec,
+                                      std::vector<PrimType> pt) {
+  std::string newName = funcName;
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  st->SetNameStrIdx(newName);
+  st->SetStorageClass(kScExtern);
+  st->SetSKind(kStFunc);
+
+  /* setup the type of the callee function */
+  std::vector<TyIdx> vec;
+  std::vector<TypeAttrs> vecAt;
+  for (size_t i = 1; i < opndVec.size(); ++i) {
+    vec.emplace_back(GlobalTables::GetTypeTable().GetTypeTable()[static_cast<size_t>(pt[i])]->GetTypeIndex());
+    vecAt.emplace_back(TypeAttrs());
+  }
+
+  /* only support no return function */
+  MIRType *retType = GlobalTables::GetTypeTable().GetTypeTable().at(static_cast<size_t>(PTY_void));
+  st->SetTyIdx(cgFunc->GetBecommon().BeGetOrCreateFunctionType(retType->GetTypeIndex(), vec, vecAt)->GetTypeIndex());
+
+  /* setup actual parameters */
+  ListOperand &paramOpnds = cgFunc->GetOpndBuilder()->CreateList();
+
+  X64CallConvImpl parmLocator(cgFunc->GetBecommon());
+  CCLocInfo ploc;
+  for (size_t i = 0; i < opndVec.size(); ++i) {
+    ASSERT(pt[i] != PTY_void, "primType check");
+    MIRType *ty;
+    ty = GlobalTables::GetTypeTable().GetTypeTable()[static_cast<size_t>(pt[i])];
+    Operand *stOpnd = opndVec[i];
+    ASSERT(stOpnd->IsRegister(), "exp result should be reg");
+    RegOperand *expRegOpnd = static_cast<RegOperand*>(stOpnd);
+    parmLocator.LocateNextParm(*ty, ploc);
+    if (ploc.reg0 != 0) {  /* load to the register */
+      RegOperand &parmRegOpnd = cgFunc->GetOpndBuilder()->CreatePReg(ploc.reg0,
+          expRegOpnd->GetSize(), cgFunc->GetRegTyFromPrimTy(pt[i]));
+      SelectCopy(parmRegOpnd, *expRegOpnd, pt[i]);
+      paramOpnds.PushOpnd(parmRegOpnd);
+    }
+    ASSERT(ploc.reg1 == 0, "SelectCall NYI");
+  }
+
+  MIRSymbol *sym = cgFunc->GetFunction().GetLocalOrGlobalSymbol(st->GetStIdx(), false);
+  Operand &targetOpnd = cgFunc->GetOpndBuilder()->CreateFuncNameOpnd(*sym);
+  ListOperand &retOpnds = cgFunc->GetOpndBuilder()->CreateList();
+  Insn &callInsn = AppendCall(x64::MOP_callq_l, targetOpnd, paramOpnds, retOpnds);
+
+  callInsn.SetRetType(Insn::kRegInt);
+  if (retType != nullptr) {
+    callInsn.SetRetSize(static_cast<uint32>(retType->GetSize()));
+    callInsn.SetIsCallReturnUnsigned(IsUnsignedInteger(retType->GetPrimType()));
+  }
+  return;
+}
+
+Operand *X64MPIsel::SelectDoubleConst(MIRDoubleConst &doubleConst, PrimType primType) const {
+  uint32 labelIdxTmp = cgFunc->GetLabelIdx();
+  Operand *result = SelectLiteral(doubleConst, cgFunc->GetFunction(), labelIdxTmp++);
+  cgFunc->SetLabelIdx(labelIdxTmp);
+  return result;
+}
+
+RegOperand *X64MPIsel::PrepareMemcpyParm(MemOperand &memOperand, MOperator mOp) {
+  RegOperand &regResult = cgFunc->GetOpndBuilder()->CreateVReg(k64BitSize, kRegTyInt);
+  Insn &addrInsn = (cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]));
+  addrInsn.AddOpndChain(memOperand).AddOpndChain(regResult);
+  cgFunc->GetCurBB()->AppendInsn(addrInsn);
+  return &regResult;
+}
+
+RegOperand *X64MPIsel::PrepareMemcpyParm(uint64 copySize) {
+  RegOperand &regResult = cgFunc->GetOpndBuilder()->CreateVReg(k64BitSize, kRegTyInt);
+  ImmOperand &sizeOpnd = cgFunc->GetOpndBuilder()->CreateImm(k64BitSize, copySize);
+  SelectCopy(regResult, sizeOpnd, PTY_i64);
+  return &regResult;
+}
+
+void X64MPIsel::SelectAggDassign(MirTypeInfo &lhsInfo, MemOperand &symbolMem, Operand &opndRhs) {
+  /* rhs is Func Return, it must be from Regread */
+  if (opndRhs.IsRegister()) {
+    SelectIntAggCopyReturn(symbolMem, lhsInfo.size);
+    return;
+  }
+  /* In generally, rhs is from Dread/Iread */
+  CHECK_FATAL(opndRhs.IsMemoryAccessOperand(), "Aggregate Type RHS must be mem");
+  MemOperand &memRhs = static_cast<MemOperand&>(opndRhs);
+  SelectAggCopy(symbolMem, memRhs, lhsInfo.size);
+}
+
+void X64MPIsel::SelectAggIassign(IassignNode &stmt, Operand &AddrOpnd, Operand &opndRhs) {
+  /* mirSymbol info */
+  MirTypeInfo symbolInfo = GetMirTypeInfoFromMirNode(stmt);
+  MIRType *stmtMirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(stmt.GetTyIdx());
+
+  /* In generally, RHS is from Dread/Iread */
+  CHECK_FATAL(opndRhs.IsMemoryAccessOperand(), "Aggregate Type RHS must be mem");
+  MemOperand &memRhs = static_cast<MemOperand&>(opndRhs);
+  ImmOperand *stOfstSrc = memRhs.GetOffsetOperand();
+  RegOperand *baseSrc = memRhs.GetBaseRegister();
+
+  if (stmtMirType->GetPrimType() == PTY_agg) {
+    /* generate move to regs for agg return */
+    RegOperand *result[kFourRegister] = { nullptr }; /* up to 2 int or 4 fp */
+    uint32 numRegs = (symbolInfo.size <= k8ByteSize) ? kOneRegister : kTwoRegister;
+    PrimType retPrimType = (symbolInfo.size <= k4ByteSize) ? PTY_u32 : PTY_u64;
+    for (int i = 0; i < numRegs; i++) {
+      MemOperand &rhsMemOpnd = cgFunc->GetOpndBuilder()->CreateMem(GetPrimTypeBitSize(retPrimType));
+      rhsMemOpnd.SetBaseRegister(*baseSrc);
+      ImmOperand &newStOfstSrc = static_cast<ImmOperand&>(*stOfstSrc->Clone(*cgFunc->GetMemoryPool()));
+      newStOfstSrc.SetValue(newStOfstSrc.GetValue() + i * k8ByteSize);
+      rhsMemOpnd.SetOffsetOperand(newStOfstSrc);
+      regno_t regNo = (i == 0) ? x64::RAX : x64::RDX;
+      result[i] = &cgFunc->GetOpndBuilder()->CreatePReg(regNo, GetPrimTypeBitSize(retPrimType),
+          cgFunc->GetRegTyFromPrimTy(retPrimType));
+      SelectCopy(*(result[i]), rhsMemOpnd, retPrimType);
+    }
+  } else {
+    RegOperand *lhsAddrOpnd = &SelectCopy2Reg(AddrOpnd, stmt.Opnd(0)->GetPrimType());
+    MemOperand &symbolMem = cgFunc->GetOpndBuilder()->CreateMem(*lhsAddrOpnd, symbolInfo.offset,
+        GetPrimTypeBitSize(PTY_u64));
+    SelectAggCopy(symbolMem, memRhs, symbolInfo.size);
+  }
+}
+
+Insn &X64MPIsel::AppendCall(x64::X64MOP_t mOp, Operand &targetOpnd,
+    ListOperand &paramOpnds, ListOperand &retOpnds) {
+  Insn &callInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  callInsn.AddOpndChain(targetOpnd).AddOpndChain(paramOpnds).AddOpndChain(retOpnds);
+  cgFunc->GetCurBB()->AppendInsn(callInsn);
+  cgFunc->GetCurBB()->SetHasCall();
+  cgFunc->GetFunction().SetHasCall();
+  return callInsn;
+}
+
+void X64MPIsel::SelectCalleeReturn(MIRType *retType, ListOperand &retOpnds) {
+  if (retType == nullptr) {
+    return;
+  }
+  auto retSize = retType->GetSize() * kBitsPerByte;
+  if (retType->GetPrimType() != PTY_agg || retSize <= k128BitSize) {
+    if (retSize > k0BitSize) {
+      retOpnds.PushOpnd(cgFunc->GetOpndBuilder()->CreatePReg(x64::RAX, k64BitSize, kRegTyInt));
+    }
+    if (retSize > k64BitSize) {
+      retOpnds.PushOpnd(cgFunc->GetOpndBuilder()->CreatePReg(x64::RDX, k64BitSize, kRegTyInt));
+    }
+  }
+}
+
+void X64MPIsel::SelectCall(CallNode &callNode) {
+  MIRFunction *fn = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode.GetPUIdx());
+  MIRSymbol *fsym = GlobalTables::GetGsymTable().GetSymbolFromStidx(fn->GetStIdx().Idx(), false);
+  Operand &targetOpnd = cgFunc->GetOpndBuilder()->CreateFuncNameOpnd(*fsym);
+
+  ListOperand &paramOpnds = cgFunc->GetOpndBuilder()->CreateList();
+  uint32 fpNum = 0;
+  SelectParmList(callNode, paramOpnds, fpNum);
+  /* x64abi： rax = with variable arguments passes information about the number of vector registers used */
+  if (fn->IsVarargs()) {
+    ImmOperand &fpNumImm = cgFunc->GetOpndBuilder()->CreateImm(k64BitSize, fpNum);
+    RegOperand &raxOpnd = cgFunc->GetOpndBuilder()->CreatePReg(x64::RAX, k64BitSize, kRegTyInt);
+    SelectCopy(raxOpnd, fpNumImm, PTY_i64);
+  }
+
+  MIRType *retType = fn->GetReturnType();
+  ListOperand &retOpnds = cgFunc->GetOpndBuilder()->CreateList();
+  SelectCalleeReturn(retType, retOpnds);
+
+  Insn &callInsn = AppendCall(x64::MOP_callq_l, targetOpnd, paramOpnds, retOpnds);
+  callInsn.SetRetType(Insn::kRegInt);
+  if (retType != nullptr) {
+    callInsn.SetRetSize(static_cast<uint32>(retType->GetSize()));
+    callInsn.SetIsCallReturnUnsigned(IsUnsignedInteger(retType->GetPrimType()));
+  }
+}
+
+void X64MPIsel::SelectIcall(IcallNode &iCallNode, Operand &opnd0) {
+  RegOperand &targetOpnd = SelectCopy2Reg(opnd0, iCallNode.Opnd(0)->GetPrimType());
+  ListOperand &paramOpnds = cgFunc->GetOpndBuilder()->CreateList();
+  uint32 fpNum = 0;
+  SelectParmList(iCallNode, paramOpnds, fpNum);
+  MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iCallNode.GetRetTyIdx());
+  if (iCallNode.GetOpCode() == OP_icallproto) {
+    MIRPtrType *ptrType = static_cast<MIRPtrType *>(retType);
+    MIRFuncType *calleeType = static_cast<MIRFuncType*>(ptrType->GetPointedType());
+    retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(calleeType->GetRetTyIdx());
+  }
+  ListOperand &retOpnds = cgFunc->GetOpndBuilder()->CreateList();
+  SelectCalleeReturn(retType, retOpnds);
+
+  Insn &callInsn = AppendCall(x64::MOP_callq_r, targetOpnd, paramOpnds, retOpnds);
+  callInsn.SetRetType(Insn::kRegInt);
+  if (retType != nullptr) {
+    callInsn.SetRetSize(static_cast<uint32>(retType->GetSize()));
+    callInsn.SetIsCallReturnUnsigned(IsUnsignedInteger(retType->GetPrimType()));
+  }
+}
+
+Operand &X64MPIsel::ProcessReturnReg(PrimType primType, int32 sReg) {
+  return GetTargetRetOperand(primType, sReg);
+}
+
+void X64MPIsel::SelectGoto(GotoNode &stmt) {
+  MOperator mOp = x64::MOP_jmpq_l;
+  auto funcName = ".L." + std::to_string(cgFunc->GetUniqueID()) + "__" + std::to_string(stmt.GetOffset());
+  LabelOperand &targetOpnd = cgFunc->GetOpndBuilder()->CreateLabel(funcName.c_str(), stmt.GetOffset());
+  Insn &jmpInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  cgFunc->GetCurBB()->AppendInsn(jmpInsn);
+  jmpInsn.AddOpndChain(targetOpnd);
+  cgFunc->GetCurBB()->SetKind(BB::kBBGoto);
+  return;
+}
+
+void X64MPIsel::SelectIgoto(Operand &opnd0) {
+  CHECK_FATAL(opnd0.IsRegister(), "only register implemented!");
+  MOperator mOp = x64::MOP_jmpq_r;
+  Insn &jmpInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  jmpInsn.AddOpndChain(opnd0);
+  cgFunc->GetCurBB()->AppendInsn(jmpInsn);
+  return;
+}
+
+/* This function is to generate an inline function to generate the va_list data structure */
+/* type $__va_list <struct {
+     @__stack <* void> align(8),
+     @__gr_top <* void> align(8),
+     @__vr_top <* void> align(8),
+     @__gr_offs i32 align(4),
+     @__vr_offs i32 align(4)}>
+   }
+*/
+void X64MPIsel::GenCVaStartIntrin(RegOperand &opnd, uint32 stkOffset) {
+  /* FPLR only pushed in regalloc() after intrin function */
+  RegOperand &fpOpnd = cgFunc->GetOpndBuilder()->CreatePReg(RFP, k64BitSize, kRegTyInt);
+
+  uint32 fpLrLength = k16BitSize;
+  /* __stack */
+  if (stkOffset != 0) {
+    stkOffset += fpLrLength;
+  }
+
+  /* isvary reset StackFrameSize */
+  ImmOperand &vaListOnPassArgStackOffset = cgFunc->GetOpndBuilder()->CreateImm(k64BitSize, stkOffset);
+  RegOperand &vReg = cgFunc->GetOpndBuilder()->CreateVReg(k64BitSize, kRegTyInt);
+  SelectAdd(vReg, fpOpnd, vaListOnPassArgStackOffset, GetLoweredPtrType());
+
+  // The 8-byte data in the a structure needs to use this mop.
+  MOperator mOp = x64::MOP_movq_r_m;
+
+  /* mem operand in va_list struct (lhs) */
+  MemOperand &vaList = GetCurFunc()->GetOpndBuilder()->CreateMem(opnd, 0, k64BitSize);
+  Insn &fillInStkOffsetInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  fillInStkOffsetInsn.AddOpndChain(vReg).AddOpndChain(vaList);
+  cgFunc->GetCurBB()->AppendInsn(fillInStkOffsetInsn);
+
+  /* __gr_top   ; it's the same as __stack before the 1st va_arg */
+  stkOffset = 0;
+  ImmOperand &grTopOffset = cgFunc->GetOpndBuilder()->CreateImm(k64BitSize, stkOffset);
+  SelectSub(vReg, fpOpnd, grTopOffset, PTY_a64);
+
+  /* mem operand in va_list struct (lhs) */
+  MemOperand &vaListGRTop = GetCurFunc()->GetOpndBuilder()->CreateMem(opnd, k8BitSize, k64BitSize);
+  Insn &fillInGRTopInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  fillInGRTopInsn.AddOpndChain(vReg).AddOpndChain(vaListGRTop);
+  cgFunc->GetCurBB()->AppendInsn(fillInGRTopInsn);
+
+  /* __vr_top */
+  int32 grAreaSize = static_cast<int32>(static_cast<X64MemLayout*>(cgFunc->GetMemlayout())->GetSizeOfGRSaveArea());
+  stkOffset += grAreaSize;
+  stkOffset += k8BitSize;
+  ImmOperand &vaListVRTopOffset = cgFunc->GetOpndBuilder()->CreateImm(k64BitSize, stkOffset);
+  SelectSub(vReg, fpOpnd, vaListVRTopOffset, PTY_a64);
+
+  MemOperand &vaListVRTop = GetCurFunc()->GetOpndBuilder()->CreateMem(opnd, k16BitSize, k64BitSize);
+  Insn &fillInVRTopInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  fillInVRTopInsn.AddOpndChain(vReg).AddOpndChain(vaListVRTop);
+  cgFunc->GetCurBB()->AppendInsn(fillInVRTopInsn);
+
+  // The 4-byte data in the a structure needs to use this mop.
+  mOp = x64::MOP_movl_r_m;
+
+  /* __gr_offs */
+  int32 grOffs = 0 - grAreaSize;
+  ImmOperand &vaListGROffsOffset = cgFunc->GetOpndBuilder()->CreateImm(k32BitSize, grOffs);
+  RegOperand &grOffsRegOpnd = SelectCopy2Reg(vaListGROffsOffset, PTY_a32);
+
+  MemOperand &vaListGROffs = GetCurFunc()->GetOpndBuilder()->CreateMem(opnd, k24BitSize, k64BitSize);
+  Insn &fillInGROffsInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  fillInGROffsInsn.AddOpndChain(grOffsRegOpnd).AddOpndChain(vaListGROffs);
+  cgFunc->GetCurBB()->AppendInsn(fillInGROffsInsn);
+
+  /* __vr_offs */
+  int32 vrOffs = static_cast<int32>(0UL - static_cast<int32>(static_cast<X64MemLayout*>(
+      cgFunc->GetMemlayout())->GetSizeOfVRSaveArea()));
+  ImmOperand &vaListVROffsOffset = cgFunc->GetOpndBuilder()->CreateImm(k32BitSize, vrOffs);
+  RegOperand &vrOffsRegOpnd = SelectCopy2Reg(vaListVROffsOffset, PTY_a32);
+
+  MemOperand &vaListVROffs = GetCurFunc()->GetOpndBuilder()->CreateMem(opnd, k24BitSize + 4, k64BitSize);
+  Insn &fillInVROffsInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  fillInVROffsInsn.AddOpndChain(vrOffsRegOpnd).AddOpndChain(vaListVROffs);
+  cgFunc->GetCurBB()->AppendInsn(fillInVROffsInsn);
+}
+
+/* The second parameter in function va_start does not need to be concerned here,
+ * it is mainly used in proepilog */
+void X64MPIsel::SelectCVaStart(const IntrinsiccallNode &intrnNode) {
+  ASSERT(intrnNode.NumOpnds() == 2, "must be 2 operands");
+  /* 2 operands, but only 1 needed. Don't need to emit code for second operand
+   *
+   * va_list is a passed struct with an address, load its address
+   */
+  BaseNode *argExpr = intrnNode.Opnd(0);
+  Operand *opnd = HandleExpr(intrnNode, *argExpr);
+  RegOperand &opnd0 = SelectCopy2Reg(*opnd, GetLoweredPtrType());  /* first argument of intrinsic */
+
+  /* Find beginning of unnamed arg on stack.
+   * Ex. void foo(int i1, int i2, ... int i8, struct S r, struct S s, ...)
+   *     where struct S has size 32, address of r and s are on stack but they are named.
+   */
+  X64CallConvImpl parmLocator(cgFunc->GetBecommon());
+  CCLocInfo pLoc;
+  uint32 stkSize = 0;
+  for (uint32 i = 0; i < cgFunc->GetFunction().GetFormalCount(); i++) {
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(cgFunc->GetFunction().GetNthParamTyIdx(i));
+    parmLocator.LocateNextParm(*ty, pLoc);
+    if (pLoc.reg0 == kRinvalid) {  /* on stack */
+      stkSize = static_cast<uint32_t>(pLoc.memOffset + pLoc.memSize);
+    }
+  }
+
+  stkSize = static_cast<uint32>(RoundUp(stkSize, GetPointerSize()));
+
+  GenCVaStartIntrin(opnd0, stkSize);
+
+  return;
+}
+
+void X64MPIsel::SelectIntrinCall(IntrinsiccallNode &intrinsiccallNode) {
+  MIRIntrinsicID intrinsic = intrinsiccallNode.GetIntrinsic();
+
+  if (intrinsic == INTRN_C_va_start) {
+    SelectCVaStart(intrinsiccallNode);
+    return;
+  }
+  if (intrinsic == INTRN_C_stack_save || intrinsic == INTRN_C_stack_restore) {
+    return;
+  }
+
+  CHECK_FATAL(false, "Intrinsic %d: %s not implemented by the X64 CG.", intrinsic, GetIntrinsicName(intrinsic));
+}
+
+void X64MPIsel::SelectRangeGoto(RangeGotoNode &rangeGotoNode, Operand &srcOpnd) {
+  MIRType *etype = GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)PTY_a64);
+  std::vector<uint32> sizeArray;
+  const SmallCaseVector &switchTable = rangeGotoNode.GetRangeGotoTable();
+  sizeArray.emplace_back(switchTable.size());
+  MemPool *memPool = cgFunc->GetMemoryPool();
+  MIRArrayType *arrayType = memPool->New<MIRArrayType>(etype->GetTypeIndex(), sizeArray);
+  MIRAggConst *arrayConst = memPool->New<MIRAggConst>(cgFunc->GetMirModule(), *arrayType);
+  for (const auto &itPair : switchTable) {
+    LabelIdx labelIdx = itPair.second;
+    cgFunc->GetCurBB()->PushBackRangeGotoLabel(labelIdx);
+    MIRConst *mirConst = memPool->New<MIRLblConst>(labelIdx, cgFunc->GetFunction().GetPuidx(), *etype);
+    arrayConst->AddItem(mirConst, 0);
+  }
+  MIRSymbol *lblSt = cgFunc->GetFunction().GetSymTab()->CreateSymbol(kScopeLocal);
+  lblSt->SetStorageClass(kScFstatic);
+  lblSt->SetSKind(kStConst);
+  lblSt->SetTyIdx(arrayType->GetTypeIndex());
+  lblSt->SetKonst(arrayConst);
+  std::string lblStr(".L_");
+  uint32 labelIdxTmp = cgFunc->GetLabelIdx();
+  lblStr.append(std::to_string(cgFunc->GetUniqueID())).append("_LOCAL_CONST.").append(std::to_string(labelIdxTmp++));
+  cgFunc->SetLabelIdx(labelIdxTmp);
+  lblSt->SetNameStrIdx(lblStr);
+  cgFunc->AddEmitSt(cgFunc->GetCurBB()->GetId(), *lblSt);
+  ImmOperand &stOpnd = cgFunc->GetOpndBuilder()->CreateImm(*lblSt, 0, 0);
+  /* get index */
+  PrimType srcType = rangeGotoNode.Opnd(0)->GetPrimType();
+  RegOperand &opnd0 = SelectCopy2Reg(srcOpnd, srcType);
+  int32 minIdx = switchTable[0].first;
+  ImmOperand &opnd1 = cgFunc->GetOpndBuilder()->CreateImm(GetPrimTypeBitSize(srcType),
+                                                          -minIdx - rangeGotoNode.GetTagOffset());
+  RegOperand &indexOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(srcType), kRegTyInt);
+  SelectAdd(indexOpnd, opnd0, opnd1, srcType);
+
+  /* load the displacement into a register by accessing memory at base + index * 8 */
+  /* mov .L_xxx_LOCAL_CONST.x(%baseReg, %indexOpnd, 8), %dstRegOpnd */
+  MemOperand &dstMemOpnd = cgFunc->GetOpndBuilder()->CreateMem(GetPrimTypeBitSize(PTY_a64));
+  RegOperand &baseReg = cgFunc->GetOpndBuilder()->CreatePReg(x64::RBP, GetPrimTypeBitSize(PTY_i64), kRegTyInt);
+  dstMemOpnd.SetBaseRegister(baseReg);
+  dstMemOpnd.SetIndexRegister(indexOpnd);
+  dstMemOpnd.SetOffsetOperand(stOpnd);
+  dstMemOpnd.SetScaleOperand(cgFunc->GetOpndBuilder()->CreateImm(baseReg.GetSize(), k8ByteSize));
+
+  /* jumping to the absolute address which is stored in dstRegOpnd */
+  MOperator mOp = x64::MOP_jmpq_m;
+  Insn &jmpInsn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  jmpInsn.AddOpndChain(dstMemOpnd);
+  cgFunc->GetCurBB()->AppendInsn(jmpInsn);
+}
+
+Operand *X64MPIsel::SelectAddrof(AddrofNode &expr, const BaseNode &parent) {
+  /* get mirSymbol info*/
+  MIRSymbol *symbol = cgFunc->GetFunction().GetLocalOrGlobalSymbol(expr.GetStIdx());
+  /* <prim-type> of AddrofNode must be either ptr, a32 or a64 */
+  PrimType ptype = expr.GetPrimType();
+  RegOperand &resReg = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(ptype),
+      cgFunc->GetRegTyFromPrimTy(ptype));
+  MemOperand &memOperand = GetOrCreateMemOpndFromSymbol(*symbol, expr.GetFieldID());
+  uint pSize = GetPrimTypeSize(ptype);
+  MOperator mOp;
+  if (pSize <= k4ByteSize) {
+    mOp = x64::MOP_leal_m_r;
+  } else if (pSize <= k8ByteSize) {
+    mOp = x64::MOP_leaq_m_r;
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  Insn &addrInsn = (cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]));
+  addrInsn.AddOpndChain(memOperand).AddOpndChain(resReg);
+  cgFunc->GetCurBB()->AppendInsn(addrInsn);
+  return &resReg;
+}
+
+Operand *X64MPIsel::SelectAddrofFunc(AddroffuncNode &expr, const BaseNode &parent) {
+  uint32 instrSize = static_cast<uint32>(expr.SizeOfInstr());
+  /* <prim-type> must be either a32 or a64. */
+  PrimType primType = (instrSize == k8ByteSize) ? PTY_a64 : (instrSize == k4ByteSize) ? PTY_a32 : PTY_begin;
+  CHECK_FATAL(primType != PTY_begin, "prim-type of Func Addr must be either a32 or a64!");
+  MIRFunction *mirFunction = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(expr.GetPUIdx());
+  MIRSymbol *symbol = mirFunction->GetFuncSymbol();
+  MIRStorageClass storageClass = symbol->GetStorageClass();
+  RegOperand &resReg = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+  if (storageClass == maple::kScText && symbol->GetSKind() == maple::kStFunc) {
+    ImmOperand &stOpnd = cgFunc->GetOpndBuilder()->CreateImm(*symbol, 0, 0);
+    X64MOP_t mOp = x64::MOP_movabs_s_r;
+    Insn &addrInsn = (cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]));
+    addrInsn.AddOpndChain(stOpnd).AddOpndChain(resReg);
+    cgFunc->GetCurBB()->AppendInsn(addrInsn);
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  return &resReg;
+}
+
+Operand *X64MPIsel::SelectAddrofLabel(AddroflabelNode &expr, const BaseNode &parent) {
+  PrimType primType = expr.GetPrimType();
+  uint32 bitSize = GetPrimTypeBitSize(primType);
+  RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(bitSize,
+      cgFunc->GetRegTyFromPrimTy(primType));
+  RegOperand &baseOpnd = cgFunc->GetOpndBuilder()->CreatePReg(x64::RIP, bitSize,
+      cgFunc->GetRegTyFromPrimTy(primType));
+
+  auto labelStr = ".L." + std::to_string(cgFunc->GetUniqueID()) + "__" + std::to_string(expr.GetOffset());
+  MIRSymbol *labelSym = cgFunc->GetFunction().GetSymTab()->CreateSymbol(kScopeLocal);
+  ASSERT(labelSym != nullptr, "null ptr check");
+  labelSym->SetStorageClass(kScFstatic);
+  labelSym->SetSKind(kStConst);
+  labelSym->SetNameStrIdx(labelStr);
+  MIRType *etype = GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)PTY_a64);
+  ASSERT(etype != nullptr, "null ptr check");
+  auto *labelConst = cgFunc->GetMemoryPool()->New<MIRLblConst>(expr.GetOffset(),
+      cgFunc->GetFunction().GetPuidx(), *etype);
+  ASSERT(labelConst != nullptr, "null ptr check");
+  labelSym->SetKonst(labelConst);
+  ImmOperand &stOpnd = cgFunc->GetOpndBuilder()->CreateImm(*labelSym, 0, 0);
+
+  MemOperand &memOpnd = cgFunc->GetOpndBuilder()->CreateMem(bitSize);
+  memOpnd.SetBaseRegister(baseOpnd);
+  memOpnd.SetOffsetOperand(stOpnd);
+
+  X64MOP_t mOp = x64::MOP_begin;
+  if (bitSize <= k32BitSize) {
+    mOp = x64::MOP_leal_m_r;
+  } else if (bitSize <= k64BitSize) {
+    mOp = x64::MOP_leaq_m_r;
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  Insn &addrInsn = (cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]));
+  addrInsn.AddOpndChain(memOpnd).AddOpndChain(resOpnd);
+  cgFunc->GetCurBB()->AppendInsn(addrInsn);
+  return &resOpnd;
+}
+
+static X64MOP_t PickJmpInsn(Opcode brOp, Opcode cmpOp, bool isFloat, bool isSigned) {
+  switch (cmpOp) {
+    case OP_ne:
+      return (brOp == OP_brtrue) ? MOP_jne_l : MOP_je_l;
+    case OP_eq:
+      return (brOp == OP_brtrue) ? MOP_je_l : MOP_jne_l;
+    case OP_lt:
+      return (brOp == OP_brtrue) ? (isSigned ? MOP_jl_l  : MOP_jb_l)
+                                 : (isSigned ? MOP_jge_l : MOP_jae_l);
+    case OP_le:
+      return (brOp == OP_brtrue) ? (isSigned ? MOP_jle_l : MOP_jbe_l)
+                                 : (isSigned ? MOP_jg_l  : MOP_ja_l);
+    case OP_gt:
+      return (brOp == OP_brtrue) ? (isFloat ? MOP_ja_l : (isSigned ? MOP_jg_l  : MOP_ja_l))
+                                 : (isSigned ? MOP_jle_l : MOP_jbe_l);
+    case OP_ge:
+      return (brOp == OP_brtrue) ? (isSigned ? MOP_jge_l : MOP_jae_l)
+                                 : (isSigned ? MOP_jl_l  : MOP_jb_l);
+    default:
+      CHECK_FATAL(false, "PickJmpInsn error");
+  }
+}
+
+/*
+ * handle brfalse/brtrue op, opnd0 can be a compare node or non-compare node
+ * such as a dread for example
+ */
+void X64MPIsel::SelectCondGoto(CondGotoNode &stmt, BaseNode &condNode, Operand &opnd0) {
+  Opcode opcode = stmt.GetOpCode();
+  X64MOP_t jmpOperator = x64::MOP_begin;
+  if (opnd0.IsImmediate()) {
+    ASSERT(opnd0.IsIntImmediate(), "only support int immediate");
+    ASSERT(opcode == OP_brtrue || opcode == OP_brfalse, "unsupported opcode");
+    ImmOperand &immOpnd0 = static_cast<ImmOperand&>(opnd0);
+    if ((opcode == OP_brtrue && !(immOpnd0.GetValue() != 0)) ||
+        (opcode == OP_brfalse && !(immOpnd0.GetValue() == 0))) {
+      return;
+    }
+    jmpOperator = x64::MOP_jmpq_l;
+    cgFunc->SetCurBBKind(BB::kBBGoto);
+  } else {
+    PrimType primType;
+    Opcode condOpcode = condNode.GetOpCode();
+    if (!kOpcodeInfo.IsCompare(condOpcode)) {
+      primType = condNode.GetPrimType();
+      ImmOperand &imm0 = cgFunc->GetOpndBuilder()->CreateImm(GetPrimTypeBitSize(primType), 0);
+      SelectCmp(opnd0, imm0, primType);
+      condOpcode = OP_ne;
+    } else {
+      primType = static_cast<CompareNode&>(condNode).GetOpndType();
+    }
+    bool isFloat = IsPrimitiveFloat(primType);
+    jmpOperator = PickJmpInsn(opcode, condOpcode, isFloat, IsSignedInteger(primType));
+    cgFunc->SetCurBBKind(BB::kBBIf);
+  }
+  /* gen targetOpnd, .L.xxx__xx */
+  auto funcName = ".L." + std::to_string(cgFunc->GetUniqueID()) + "__" + std::to_string(stmt.GetOffset());
+  LabelOperand &targetOpnd = cgFunc->GetOpndBuilder()->CreateLabel(funcName.c_str(), stmt.GetOffset());
+  /* select jump Insn */
+  Insn &jmpInsn = (cgFunc->GetInsnBuilder()->BuildInsn(jmpOperator, X64CG::kMd[jmpOperator]));
+  jmpInsn.AddOpndChain(targetOpnd);
+  cgFunc->GetCurBB()->AppendInsn(jmpInsn);
+}
+
+Operand *X64MPIsel::SelectStrLiteral(ConststrNode &constStr) {
+  std::string labelStr;
+  labelStr.append(".LUstr_");
+  labelStr.append(std::to_string(constStr.GetStrIdx()));
+  MIRSymbol *labelSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetStrIdxFromName(labelStr));
+  MIRType *etype = GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)PTY_a64);
+  auto *c = cgFunc->GetMemoryPool()->New<MIRStrConst>(constStr.GetStrIdx(), *etype);
+  if (labelSym == nullptr) {
+    labelSym = cgFunc->GetMirModule().GetMIRBuilder()->CreateGlobalDecl(labelStr, c->GetType());
+    labelSym->SetStorageClass(kScFstatic);
+    labelSym->SetSKind(kStConst);
+    /* c may be local, we need a global node here */
+    labelSym->SetKonst(cgFunc->NewMirConst(*c));
+  }
+  if (c->GetPrimType() == PTY_ptr) {
+    ImmOperand &stOpnd = cgFunc->GetOpndBuilder()->CreateImm(*labelSym, 0, 0);
+    RegOperand &addrOpnd = cgFunc->GetOpndBuilder()->CreateVReg(k64BitSize, cgFunc->GetRegTyFromPrimTy(PTY_a64));
+    Insn &addrOfInsn = (cgFunc->GetInsnBuilder()->BuildInsn(x64::MOP_movabs_s_r, X64CG::kMd[x64::MOP_movabs_s_r]));
+    addrOfInsn.AddOpndChain(stOpnd).AddOpndChain(addrOpnd);
+    cgFunc->GetCurBB()->AppendInsn(addrOfInsn);
+    return &addrOpnd;
+  }
+  CHECK_FATAL(false, "Unsupported const string type");
+  return nullptr;
+}
+
+Operand &X64MPIsel::GetTargetRetOperand(PrimType primType, int32 sReg) {
+  uint32 bitSize = GetPrimTypeBitSize(primType);
+  regno_t retReg = 0;
+  switch (sReg) {
+    case kSregRetval0:
+      retReg = IsPrimitiveFloat(primType) ? x64::V0 : x64::RAX;
+      break;
+    case kSregRetval1:
+      retReg = x64::RDX;
+      break;
+    default:
+      CHECK_FATAL(false, "GetTargetRetOperand: NIY");
+      break;
+  }
+  RegOperand &parmRegOpnd = cgFunc->GetOpndBuilder()->CreatePReg(retReg, bitSize,
+      cgFunc->GetRegTyFromPrimTy(primType));
+  return parmRegOpnd;
+}
+
+Operand *X64MPIsel::SelectMpy(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  RegOperand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(dtype)) {
+    resOpnd = &cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(dtype),
+        cgFunc->GetRegTyFromPrimTy(dtype));
+    RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, dtype, node.Opnd(0)->GetPrimType());
+    RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, dtype, node.Opnd(1)->GetPrimType());
+    SelectMpy(*resOpnd, regOpnd0, regOpnd1, dtype);
+  } else {
+    /* vector operand */
+    CHECK_FATAL(false, "NIY");
+  }
+
+  return resOpnd;
+}
+
+void X64MPIsel::SelectMpy(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  uint32 bitSize = GetPrimTypeBitSize(primType);
+  SelectCopy(resOpnd, opnd0, primType);
+  RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, primType);
+  if (IsSignedInteger(primType) || IsUnsignedInteger(primType)) {
+    X64MOP_t mOp = (bitSize == k64BitSize) ? x64::MOP_imulq_r_r :
+        (bitSize == k32BitSize) ? x64::MOP_imull_r_r : (bitSize == k16BitSize) ? x64::MOP_imulw_r_r : x64::MOP_begin;
+    CHECK_FATAL(mOp != x64::MOP_begin, "NIY mapping");
+    Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+    insn.AddOpndChain(regOpnd1).AddOpndChain(resOpnd);
+    cgFunc->GetCurBB()->AppendInsn(insn);
+  } else if (IsPrimitiveFloat(primType)) {
+    X64MOP_t mOp = (bitSize == k64BitSize) ? x64::MOP_mulfd_r_r :
+        (bitSize == k32BitSize) ? x64::MOP_mulfs_r_r : x64::MOP_begin;
+    CHECK_FATAL(mOp != x64::MOP_begin, "NIY mapping");
+    Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+    insn.AddOpndChain(regOpnd1).AddOpndChain(resOpnd);
+    cgFunc->GetCurBB()->AppendInsn(insn);
+  }
+}
+
+/*
+ *  Dividend(EDX:EAX) / Divisor(reg/mem32) = Quotient(EAX)     Remainder(EDX)
+ *  IDIV instruction perform signed division of EDX:EAX by the contents of 32-bit register or memory location and
+ *  store the quotient in EAX and the remainder in EDX.
+ *  The instruction truncates non-integral results towards 0. The sign of the remainder is always the same as the sign
+ *  of the dividend, and the absolute value of the remainder is less than the absolute value of the divisor.
+ *  An overflow generates a #DE (divide error) exception, rather than setting the OF flag.
+ *  To avoid overflow problems, precede this instruction with a CDQ instruction to sign-extend the dividend Divisor.
+ *  CDQ Sign-extend EAX into EDX:EAX. This action helps avoid overflow problems in signed number arithmetic.
+ */
+Operand *X64MPIsel::SelectDiv(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType primType = node.GetPrimType();
+  Operand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(primType)) {
+    RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primType, node.Opnd(0)->GetPrimType());
+    RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, primType, node.Opnd(1)->GetPrimType());
+    resOpnd = SelectDivRem(regOpnd0, regOpnd1, primType, node.GetOpCode());
+  } else {
+    /* vector operand */
+    CHECK_FATAL(false, "NIY");
+  }
+  return resOpnd;
+}
+
+Operand *X64MPIsel::SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType primType = node.GetPrimType();
+  Operand *resOpnd = nullptr;
+  if (!IsPrimitiveVector(primType)) {
+    RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primType, node.Opnd(0)->GetPrimType());
+    RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, primType, node.Opnd(1)->GetPrimType());
+    resOpnd = SelectDivRem(regOpnd0, regOpnd1, primType, node.GetOpCode());
+  } else {
+    /* vector operand */
+    CHECK_FATAL(false, "NIY");
+  }
+  return resOpnd;
+}
+
+Operand *X64MPIsel::SelectDivRem(RegOperand &opnd0, RegOperand &opnd1, PrimType primType, Opcode opcode) {
+  ASSERT(opcode == OP_div || opcode == OP_rem, "unsupported opcode");
+  if(IsSignedInteger(primType) || IsUnsignedInteger(primType)) {
+    uint32 bitSize = GetPrimTypeBitSize(primType);
+    /* copy dividend to eax */
+    RegOperand &raxOpnd = cgFunc->GetOpndBuilder()->CreatePReg(x64::RAX, bitSize,
+        cgFunc->GetRegTyFromPrimTy(primType));
+    SelectCopy(raxOpnd, opnd0, primType);
+
+    RegOperand &rdxOpnd = cgFunc->GetOpndBuilder()->CreatePReg(x64::RDX, bitSize,
+        cgFunc->GetRegTyFromPrimTy(primType));
+    bool isSigned = IsSignedInteger(primType);
+    if (isSigned) {
+      /* cdq edx:eax = sign-extend of eax*/
+      X64MOP_t cvtMOp = (bitSize == k64BitSize) ? x64::MOP_cqo :
+                        (bitSize == k32BitSize) ? x64::MOP_cdq :
+                        (bitSize == k16BitSize) ? x64::MOP_cwd : x64::MOP_begin;
+      CHECK_FATAL(cvtMOp != x64::MOP_begin, "NIY mapping");
+      Insn &cvtInsn = cgFunc->GetInsnBuilder()->BuildInsn(cvtMOp, raxOpnd, rdxOpnd);
+      cgFunc->GetCurBB()->AppendInsn(cvtInsn);
+    } else {
+      /* set edx = 0 */
+      SelectCopy(rdxOpnd, cgFunc->GetOpndBuilder()->CreateImm(bitSize, 0), primType);
+    }
+    /* div */
+    X64MOP_t divMOp = (bitSize == k64BitSize) ? (isSigned ? x64::MOP_idivq_r : x64::MOP_divq_r) :
+                      (bitSize == k32BitSize) ? (isSigned ? x64::MOP_idivl_r : x64::MOP_divl_r) :
+                      (bitSize == k16BitSize) ? (isSigned ? x64::MOP_idivw_r : x64::MOP_divw_r) :
+                      x64::MOP_begin;
+    CHECK_FATAL(divMOp != x64::MOP_begin, "NIY mapping");
+    Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(divMOp, opnd1, raxOpnd, rdxOpnd);
+    cgFunc->GetCurBB()->AppendInsn(insn);
+    /* return */
+    RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(bitSize,
+        cgFunc->GetRegTyFromPrimTy(primType));
+    SelectCopy(resOpnd, ((opcode == OP_div) ? raxOpnd : rdxOpnd), primType);
+    return &resOpnd;
+  } else if (IsPrimitiveFloat(primType)) {
+    X64MOP_t divMOp = x64::MOP_divsd_r;
+    Insn &insn = cgFunc->GetInsnBuilder()->BuildInsn(divMOp, opnd1, opnd0);
+    cgFunc->GetCurBB()->AppendInsn(insn);
+    return &opnd0;
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+}
+
+Operand *X64MPIsel::SelectCmpOp(CompareNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  PrimType primOpndType = node.GetOpndType();
+  RegOperand *resOpnd = nullptr;
+  RegOperand &regOpnd0 = SelectCopy2Reg(opnd0, primOpndType, node.Opnd(0)->GetPrimType());
+  RegOperand &regOpnd1 = SelectCopy2Reg(opnd1, primOpndType, node.Opnd(1)->GetPrimType());
+  if (!IsPrimitiveVector(node.GetPrimType())) {
+    resOpnd = &cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(dtype),
+        cgFunc->GetRegTyFromPrimTy(dtype));
+    SelectCmp(regOpnd0, regOpnd1, primOpndType);
+    Opcode parentOp = parent.GetOpCode();
+    if (parentOp == OP_brfalse || parentOp == OP_brtrue || parentOp == OP_select) {
+      return resOpnd;
+    }
+    SelectCmpResult(*resOpnd, node.GetOpCode(), dtype, primOpndType);
+  } else {
+    /* vector operand */
+    CHECK_FATAL(false, "NIY");
+  }
+  return resOpnd;
+}
+
+void X64MPIsel::SelectCmp(Operand &opnd0, Operand &opnd1, PrimType primType) {
+  x64::X64MOP_t cmpMOp = x64::MOP_begin;
+  if (IsPrimitiveInteger(primType)) {
+    cmpMOp = GetCmpMop(opnd0.GetKind(), opnd1.GetKind(), primType);
+  } else if (IsPrimitiveFloat(primType)) {
+    cmpMOp = x64::MOP_ucomisd_r_r;
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  ASSERT(cmpMOp != x64::MOP_begin, "unsupported mOp");
+  Insn &cmpInsn = (cgFunc->GetInsnBuilder()->BuildInsn(cmpMOp, X64CG::kMd[cmpMOp]));
+  cmpInsn.AddOpndChain(opnd1).AddOpndChain(opnd0);
+  cgFunc->GetCurBB()->AppendInsn(cmpInsn);
+}
+
+void X64MPIsel::SelectCmpResult(RegOperand &resOpnd, Opcode opCode, PrimType primType, PrimType primOpndType) {
+  bool isSigned = !IsPrimitiveUnsigned(primOpndType);
+  /* set result -> u8 */
+  RegOperand &tmpResOpnd = cgFunc->GetOpndBuilder()->CreateVReg(k8BitSize, cgFunc->GetRegTyFromPrimTy(PTY_u8));
+  x64::X64MOP_t setMOp = GetSetCCMop(opCode, tmpResOpnd.GetKind(), isSigned);
+  ASSERT(setMOp != x64::MOP_begin, "unsupported mOp");
+  Insn &setInsn = cgFunc->GetInsnBuilder()->BuildInsn(setMOp, X64CG::kMd[setMOp]);
+  setInsn.AddOpndChain(tmpResOpnd);
+  cgFunc->GetCurBB()->AppendInsn(setInsn);
+  /* cvt u8 -> primType */
+  SelectIntCvt(resOpnd, tmpResOpnd, primType, PTY_u8);
+}
+
+Operand *X64MPIsel::SelectSelect(TernaryNode &expr, Operand &cond, Operand &trueOpnd, Operand &falseOpnd,
+                                 const BaseNode &parent) {
+  PrimType dtype = expr.GetPrimType();
+  RegOperand &resOpnd = cgFunc->GetOpndBuilder()->CreateVReg(GetPrimTypeBitSize(dtype),
+      cgFunc->GetRegTyFromPrimTy(dtype));
+  RegOperand &trueRegOpnd = SelectCopy2Reg(trueOpnd, dtype, expr.Opnd(1)->GetPrimType());
+  RegOperand &falseRegOpnd = SelectCopy2Reg(falseOpnd, dtype, expr.Opnd(2)->GetPrimType());
+  Opcode cmpOpcode;
+  PrimType cmpPrimType;
+  if (kOpcodeInfo.IsCompare(expr.Opnd(0)->GetOpCode())) {
+    CompareNode* cmpNode = static_cast<CompareNode*>(expr.Opnd(0));
+    ASSERT(cmpNode != nullptr, "null ptr check");
+    cmpOpcode = cmpNode->GetOpCode();
+    cmpPrimType = cmpNode->GetOpndType();
+  } else {
+    cmpPrimType = expr.Opnd(0)->GetPrimType();
+    cmpOpcode = OP_ne;
+    ImmOperand &immOpnd = cgFunc->GetOpndBuilder()->CreateImm(GetPrimTypeBitSize(cmpPrimType), 0);
+    SelectCmp(cond, immOpnd, cmpPrimType);
+  }
+  SelectSelect(resOpnd, trueRegOpnd, falseRegOpnd, dtype, cmpOpcode, cmpPrimType);
+  return &resOpnd;
+}
+
+void X64MPIsel::SelectSelect(Operand &resOpnd, Operand &trueOpnd, Operand &falseOpnd, PrimType primType,
+                             Opcode cmpOpcode, PrimType cmpPrimType) {
+  CHECK_FATAL(!IsPrimitiveFloat(primType), "NIY");
+  bool isSigned = !IsPrimitiveUnsigned(primType);
+  uint32 bitSize = GetPrimTypeBitSize(primType);
+  if (bitSize == k8BitSize) {
+    /* cmov unsupported 8bit, cvt to 32bit */
+    PrimType cvtType = isSigned ? PTY_i32 : PTY_u32;
+    RegOperand &tmpResOpnd = cgFunc->GetOpndBuilder()->CreateVReg(k32BitSize, kRegTyInt);
+    Operand &tmpTrueOpnd = SelectCopy2Reg(trueOpnd, cvtType, primType);
+    Operand &tmpFalseOpnd = SelectCopy2Reg(falseOpnd, cvtType, primType);
+    SelectSelect(tmpResOpnd, tmpTrueOpnd, tmpFalseOpnd, cvtType, cmpOpcode, cmpPrimType);
+    SelectCopy(resOpnd, tmpResOpnd, primType, cvtType);
+    return;
+  }
+  RegOperand &tmpOpnd = SelectCopy2Reg(trueOpnd, primType);
+  SelectCopy(resOpnd, falseOpnd, primType);
+  x64::X64MOP_t cmovMop = GetCMovCCMop(cmpOpcode, bitSize, !IsPrimitiveUnsigned(cmpPrimType));
+  ASSERT(cmovMop != x64::MOP_begin, "unsupported mOp");
+  Insn &comvInsn = cgFunc->GetInsnBuilder()->BuildInsn(cmovMop, X64CG::kMd[cmovMop]);
+  comvInsn.AddOpndChain(tmpOpnd).AddOpndChain(resOpnd);
+  cgFunc->GetCurBB()->AppendInsn(comvInsn);
+}
+
+void X64MPIsel::SelectMinOrMax(bool isMin, Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  if (IsPrimitiveInteger(primType)) {
+    SelectCmp(opnd0, opnd1, primType);
+    Opcode cmpOpcode = isMin ? OP_lt : OP_gt;
+    SelectSelect(resOpnd, opnd0, opnd1, primType, cmpOpcode, primType);
+  } else {
+    CHECK_FATAL(false, "NIY type max or min");
+  }
+}
+
+Operand *X64MPIsel::SelectBswap(IntrinsicopNode &node, Operand &opnd0, const BaseNode &parent) {
+  PrimType dtype = node.GetPrimType();
+  auto bitWidth = GetPrimTypeBitSize(dtype);
+  // bswap only support 32/64-bit, xchg support 16-bit -- xchg al, ah
+  CHECK_FATAL(bitWidth == k16BitSize || bitWidth == k32BitSize ||
+      bitWidth == k64BitSize, "NIY, unsupported bitWidth.");
+
+  RegOperand *resOpnd = nullptr;
+
+  if (bitWidth == k16BitSize) {
+    /*
+     * For 16-bit, use xchg, such as: xchg ah, al. So, the register must support high 8-bit.
+     * For x64, we can use RAX(AH:AL), RBX(BH:BL), RCX(CH:CL), RDX(DH:DL).
+     * The RA does not perform special processing for the high 8-bit case.
+     * So, we use the RAX regiser in here.
+     */
+    resOpnd = &cgFunc->GetOpndBuilder()->CreatePReg(x64::RAX, bitWidth,
+        cgFunc->GetRegTyFromPrimTy(dtype));
+    SelectCopy(*resOpnd, opnd0, dtype, node.Opnd(0)->GetPrimType());
+    RegOperand &lowerOpnd = cgFunc->GetOpndBuilder()->CreatePReg(x64::RAX, k8BitSize,
+        cgFunc->GetRegTyFromPrimTy(dtype));
+    RegOperand &highOpnd = cgFunc->GetOpndBuilder()->CreatePReg(x64::RAX, k8BitSize,
+        cgFunc->GetRegTyFromPrimTy(dtype));
+    highOpnd.SetHigh8Bit();
+    x64::X64MOP_t xchgMop = MOP_xchgb_r_r;
+    Insn &xchgInsn = cgFunc->GetInsnBuilder()->BuildInsn(xchgMop, X64CG::kMd[xchgMop]);
+    xchgInsn.AddOpndChain(highOpnd).AddOpndChain(lowerOpnd);
+    cgFunc->GetCurBB()->AppendInsn(xchgInsn);
+  } else {
+    resOpnd = &cgFunc->GetOpndBuilder()->CreateVReg(bitWidth,
+        cgFunc->GetRegTyFromPrimTy(dtype));
+    SelectCopy(*resOpnd, opnd0, dtype, node.Opnd(0)->GetPrimType());
+    x64::X64MOP_t bswapMop = (bitWidth == k64BitSize) ? MOP_bswapq_r : MOP_bswapl_r;
+    Insn &bswapInsn = cgFunc->GetInsnBuilder()->BuildInsn(bswapMop, X64CG::kMd[bswapMop]);
+    bswapInsn.AddOperand(*resOpnd);
+    cgFunc->GetCurBB()->AppendInsn(bswapInsn);
+  }
+  return resOpnd;
+}
+
+RegOperand &X64MPIsel::GetTargetStackPointer(PrimType primType) {
+  return cgFunc->GetOpndBuilder()->CreatePReg(x64::RSP, GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+}
+
+RegOperand &X64MPIsel::GetTargetBasicPointer(PrimType primType) {
+  return cgFunc->GetOpndBuilder()->CreatePReg(x64::RBP, GetPrimTypeBitSize(primType),
+      cgFunc->GetRegTyFromPrimTy(primType));
+}
+
+void X64MPIsel::SelectAsm(AsmNode &node) {
+  cgFunc->SetHasAsm();
+  CHECK_FATAL(false, "NIY");
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_abi.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_abi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c3aff7ba3ebdc9673f2c540b8bd5cd60eb7c32d
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_abi.cpp
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_cgfunc.h"
+#include "becommon.h"
+#include "x64_isa.h"
+
+namespace maplebe {
+using namespace maple;
+namespace x64 {
+bool IsAvailableReg(X64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF8, PREF8_16, PREF16, PREF32, PREF64, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                           \
+      return canBeAssigned;
+#define INT_REG_ALIAS(ALIAS, ID)
+#include "x64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                   \
+      return canBeAssigned;
+#include "x64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+    default:
+      return false;
+  }
+}
+
+bool IsCallerSaveReg(X64reg regNO) {
+  return (regNO == R0) || (regNO == R4) || (R2 <= regNO && regNO <= R3) ||
+    (R6 <= regNO && regNO <= R7) || (R8 <= regNO && regNO <= R11) ||
+    (V2 <= regNO && regNO <= V7) || (V16 <= regNO && regNO <= V23);
+}
+
+bool IsCalleeSavedReg(X64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF8, PREF8_16, PREF16, PREF32, PREF64, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                           \
+      return isCalleeSave;
+#define INT_REG_ALIAS(ALIAS, ID)
+#include "x64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                   \
+      return isCalleeSave;
+#include "x64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+    default:
+      return false;
+  }
+}
+
+bool IsParamReg(X64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF8, PREF8_16, PREF16, PREF32, PREF64, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                           \
+      return isParam;
+#define INT_REG_ALIAS(ALIAS, ID)
+#include "x64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                   \
+      return isParam;
+#include "x64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+    default:
+      return false;
+  }
+}
+
+bool IsSpillReg(X64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF8, PREF8_16, PREF16, PREF32, PREF64, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                           \
+      return isSpill;
+#define INT_REG_ALIAS(ALIAS, ID)
+#include "x64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                   \
+      return isSpill;
+#include "x64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+    default:
+      return false;
+  }
+}
+
+bool IsExtraSpillReg(X64reg reg) {
+  switch (reg) {
+/* integer registers */
+#define INT_REG(ID, PREF8, PREF8_16, PREF16, PREF32, PREF64, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case R##ID:                                                                           \
+      return isExtraSpill;
+#define INT_REG_ALIAS(ALIAS, ID)
+#include "x64_int_regs.def"
+#undef INT_REG
+#undef INT_REG_ALIAS
+/* fp-simd registers */
+#define FP_SIMD_REG(ID, P8, P16, P32, P64, P128, canBeAssigned, isCalleeSave, \
+    isParam, isSpill, isExtraSpill) \
+    case V##ID:                                                                   \
+      return isExtraSpill;
+#include "x64_fp_simd_regs.def"
+#undef FP_SIMD_REG
+    default:
+      return false;
+  }
+}
+
+bool IsSpillRegInRA(X64reg regNO, bool has3RegOpnd) {
+  /* if has 3 RegOpnd, previous reg used to spill. */
+  if (has3RegOpnd) {
+    return IsSpillReg(regNO) || IsExtraSpillReg(regNO);
+  }
+  return IsSpillReg(regNO);
+}
+}  /* namespace x64 */
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_args.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_args.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8ed44aa639461c1c7e45bd0b9d87c18f67caff44
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_args.cpp
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_cg.h"
+#include "x64_isa.h"
+#include "x64_MPISel.h"
+
+namespace maplebe {
+using namespace maple;
+
+void X64MoveRegArgs::Run() {
+  MoveVRegisterArgs();
+  MoveRegisterArgs();
+}
+
+void X64MoveRegArgs::CollectRegisterArgs(std::map<uint32, X64reg> &argsList,
+                                         std::vector<uint32> &indexList,
+                                         std::map<uint32, X64reg> &pairReg,
+                                         std::vector<uint32> &numFpRegs,
+                                         std::vector<uint32> &fpSize) const {
+  X64CGFunc *x64CGFunc = static_cast<X64CGFunc*>(cgFunc);
+  uint32 numFormal = static_cast<uint32>(x64CGFunc->GetFunction().GetFormalCount());
+  numFpRegs.resize(numFormal);
+  fpSize.resize(numFormal);
+  X64CallConvImpl parmlocator(x64CGFunc->GetBecommon());
+  CCLocInfo ploc;
+  uint32 start = 0;
+  if (numFormal) {
+    MIRFunction *func = const_cast<MIRFunction *>(x64CGFunc->GetBecommon().GetMIRModule().CurFunction());
+    if (x64CGFunc->GetBecommon().HasFuncReturnType(*func)) {
+      TyIdx tyIdx = x64CGFunc->GetBecommon().GetFuncReturnType(*func);
+      if (x64CGFunc->GetBecommon().GetTypeSize(tyIdx) <= k16ByteSize) {
+        start = 1;
+      }
+    }
+  }
+  for (uint32 i = start; i < numFormal; ++i) {
+    MIRType *ty = x64CGFunc->GetFunction().GetNthParamType(i);
+    parmlocator.LocateNextParm(*ty, ploc, i == 0, &x64CGFunc->GetFunction());
+    if (ploc.reg0 == kRinvalid) {
+      continue;
+    }
+    X64reg reg0 = static_cast<X64reg>(ploc.reg0);
+    MIRSymbol *sym = x64CGFunc->GetFunction().GetFormal(i);
+    if (sym->IsPreg()) {
+      continue;
+    }
+    argsList[i] = reg0;
+    indexList.emplace_back(i);
+    if (ploc.reg1 == kRinvalid) {
+      continue;
+    }
+    if (ploc.numFpPureRegs) {
+      uint32 index = i;
+      numFpRegs[index] = ploc.numFpPureRegs;
+      fpSize[index] = ploc.fpSize;
+      continue;
+    }
+    pairReg[i] = static_cast<X64reg>(ploc.reg1);
+  }
+}
+
+ArgInfo X64MoveRegArgs::GetArgInfo(std::map<uint32, X64reg> &argsList,
+    uint32 argIndex, std::vector<uint32> &numFpRegs, std::vector<uint32> &fpSize) const {
+  X64CGFunc *x64CGFunc = static_cast<X64CGFunc*>(cgFunc);
+  ArgInfo argInfo;
+  argInfo.reg = argsList[argIndex];
+  argInfo.mirTy = x64CGFunc->GetFunction().GetNthParamType(argIndex);
+  argInfo.symSize = x64CGFunc->GetBecommon().GetTypeSize(argInfo.mirTy->GetTypeIndex());
+  argInfo.memPairSecondRegSize = 0;
+  argInfo.doMemPairOpt = false;
+  argInfo.createTwoStores  = false;
+  argInfo.isTwoRegParm = false;
+  if ((argInfo.symSize > k8ByteSize) && (argInfo.symSize <= k16ByteSize)) {
+    argInfo.isTwoRegParm = true;
+    if (numFpRegs[argIndex] > kOneRegister) {
+      argInfo.symSize = argInfo.stkSize = fpSize[argIndex];
+    } else {
+      if (argInfo.symSize > k12ByteSize) {
+        argInfo.memPairSecondRegSize = k8ByteSize;
+      } else {
+        /* Round to 4 the stack space required for storing the struct */
+        argInfo.memPairSecondRegSize = k4ByteSize;
+      }
+      argInfo.doMemPairOpt = true;
+      argInfo.symSize = argInfo.stkSize = GetPointerSize();
+    }
+  } else if (argInfo.symSize > k16ByteSize) {
+    /* For large struct passing, a pointer to the copy is used. */
+    argInfo.symSize = argInfo.stkSize = GetPointerSize();
+  } else if ((argInfo.mirTy->GetPrimType() == PTY_agg) && (argInfo.symSize < k8ByteSize)) {
+    argInfo.symSize = argInfo.stkSize = k8ByteSize;
+  } else {
+    argInfo.stkSize = (argInfo.symSize < k4ByteSize) ? k4ByteSize : argInfo.symSize;
+    if (argInfo.symSize > k4ByteSize) {
+      argInfo.symSize = k8ByteSize;
+    }
+  }
+
+  if (GetVecLanes(argInfo.mirTy->GetPrimType()) > 0) {
+    /* vector type */
+    CHECK_FATAL(false, "NIY");
+  }
+
+  argInfo.regType = (argInfo.reg < V0) ? kRegTyInt : kRegTyFloat;
+  argInfo.sym = x64CGFunc->GetFunction().GetFormal(argIndex);
+  CHECK_NULL_FATAL(argInfo.sym);
+  argInfo.symLoc = static_cast<const X64SymbolAlloc*>(x64CGFunc->GetMemlayout()->
+      GetSymAllocInfo(argInfo.sym->GetStIndex()));
+  CHECK_NULL_FATAL(argInfo.symLoc);
+  return argInfo;
+}
+
+void X64MoveRegArgs::GenerateMovInsn(ArgInfo &argInfo, X64reg reg2) {
+  /* reg2 is required when the struct size is between 8-16 bytes */
+  X64CGFunc *x64CGFunc = static_cast<X64CGFunc*>(cgFunc);
+  int32 stOffset = x64CGFunc->GetBaseOffset(*argInfo.symLoc);
+  RegOperand *baseOpnd = static_cast<RegOperand*>(x64CGFunc->GetBaseReg(*argInfo.symLoc));
+  uint32 opndSize = argInfo.symSize * kBitsPerByte;
+  RegOperand &regOpnd = x64CGFunc->GetOpndBuilder()->CreatePReg(argInfo.reg,
+      opndSize, argInfo.regType);
+  MemOperand *memOpnd = &x64CGFunc->GetOpndBuilder()->CreateMem(*baseOpnd, stOffset, opndSize);
+
+  MOperator mOp;
+  if (opndSize == k64BitSize) {
+    mOp = x64::MOP_movq_r_m;
+  } else if (opndSize == k32BitSize) {
+    mOp = x64::MOP_movl_r_m;
+  } else if (opndSize == k16BitSize) {
+    mOp = x64::MOP_movw_r_m;
+  } else if (opndSize == k8BitSize) {
+    mOp = x64::MOP_movb_r_m;
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  Insn &insn = x64CGFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  insn.AddOpndChain(regOpnd).AddOpndChain(*memOpnd);
+  x64CGFunc->GetCurBB()->AppendInsn(insn);
+  if (reg2 != kRinvalid) {
+    RegOperand &regOpnd2 = x64CGFunc->GetOpndBuilder()->CreatePReg(reg2, opndSize, argInfo.regType);
+    MemOperand *memOpnd2 = &x64CGFunc->GetOpndBuilder()->CreateMem(*baseOpnd, stOffset + 8, opndSize);
+    Insn &insn2 = x64CGFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+    insn2.AddOpndChain(regOpnd2).AddOpndChain(*memOpnd2);
+    x64CGFunc->GetCurBB()->AppendInsn(insn2);
+  }
+}
+
+void X64MoveRegArgs::MoveRegisterArgs() {
+  X64CGFunc *x64CGFunc = static_cast<X64CGFunc*>(cgFunc);
+  BB *formerCurBB = x64CGFunc->GetCurBB();
+  x64CGFunc->GetDummyBB()->ClearInsns();
+  x64CGFunc->SetCurBB(*x64CGFunc->GetDummyBB());
+
+  /* <[0], maplebe::R0>; <[1], maplebe::V0> */
+  std::map<uint32, X64reg> movePara;
+  /* [0], [1] */
+  std::vector<uint32> moveParaIndex;
+  std::map<uint32, X64reg> pairReg;
+  std::vector<uint32> numFpRegs;
+  std::vector<uint32> fpSize;
+  CollectRegisterArgs(movePara, moveParaIndex, pairReg, numFpRegs, fpSize);
+
+  for (auto indexItem = moveParaIndex.begin(); indexItem != moveParaIndex.end(); ++indexItem) {
+    uint32 index = *indexItem;
+    ArgInfo argInfo = GetArgInfo(movePara, index, numFpRegs, fpSize);
+    GenerateMovInsn(argInfo, pairReg[index]);
+  }
+
+  x64CGFunc->GetFirstBB()->InsertAtBeginning(*x64CGFunc->GetDummyBB());
+  x64CGFunc->SetCurBB(*formerCurBB);
+}
+
+void X64MoveRegArgs::LoadStackArgsToVReg(MIRSymbol &mirSym) {
+  ASSERT(mirSym.GetStorageClass() == kScFormal, "NIY, vreg parameters should be kScFormal type.");
+  X64CGFunc *x64CGFunc = static_cast<X64CGFunc*>(cgFunc);
+  PrimType stype = mirSym.GetType()->GetPrimType();
+  uint32 opndSize = GetPrimTypeBitSize(stype);
+  auto symLoc = static_cast<const X64SymbolAlloc*>(x64CGFunc->GetMemlayout()->
+      GetSymAllocInfo(mirSym.GetStIndex()));
+  int32 stOffset = x64CGFunc->GetBaseOffset(*symLoc);
+  RegOperand *baseOpnd = static_cast<RegOperand*>(x64CGFunc->GetBaseReg(*symLoc));
+  MemOperand &memOpnd = x64CGFunc->GetOpndBuilder()->CreateMem(*baseOpnd, stOffset, opndSize);
+  PregIdx pregIdx = x64CGFunc->GetFunction().GetPregTab()->GetPregIdxFromPregno(mirSym.GetPreg()->GetPregNo());
+  RegOperand &dstRegOpnd = x64CGFunc->GetOpndBuilder()->CreateVReg(
+      x64CGFunc->GetVirtualRegNOFromPseudoRegIdx(pregIdx), opndSize, cgFunc->GetRegTyFromPrimTy(stype));
+
+  MOperator mOp;
+  if (opndSize == k64BitSize) {
+    mOp = x64::MOP_movq_m_r;
+  } else if (opndSize == k32BitSize) {
+    mOp = x64::MOP_movl_m_r;
+  } else if (opndSize == k16BitSize) {
+    mOp = x64::MOP_movw_m_r;
+  } else if (opndSize == k8BitSize) {
+    mOp = x64::MOP_movb_m_r;
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  Insn &insn = x64CGFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  insn.AddOpndChain(memOpnd).AddOpndChain(dstRegOpnd);
+  if (x64CGFunc->GetCG()->GenerateVerboseCG()) {
+    std::string key = "param: %%";
+    key += std::to_string(mirSym.GetPreg()->GetPregNo());
+    insn.SetComment(key);
+  }
+  x64CGFunc->GetCurBB()->InsertInsnBegin(insn);
+}
+
+void X64MoveRegArgs::MoveArgsToVReg(const CCLocInfo &ploc, MIRSymbol &mirSym) {
+  ASSERT(mirSym.GetStorageClass() == kScFormal, "NIY, vreg parameters should be kScFormal type.");
+  X64CGFunc *x64CGFunc = static_cast<X64CGFunc*>(cgFunc);
+  RegType regType = (ploc.reg0 < V0) ? kRegTyInt : kRegTyFloat;
+  PrimType stype = mirSym.GetType()->GetPrimType();
+  uint32 byteSize = GetPrimTypeSize(stype);
+  uint32 srcBitSize = ((byteSize < k4ByteSize) ? k4ByteSize : byteSize) * kBitsPerByte;
+  PregIdx pregIdx = x64CGFunc->GetFunction().GetPregTab()->GetPregIdxFromPregno(mirSym.GetPreg()->GetPregNo());
+  RegOperand &dstRegOpnd = x64CGFunc->GetOpndBuilder()->CreateVReg(
+      x64CGFunc->GetVirtualRegNOFromPseudoRegIdx(pregIdx), srcBitSize, regType);
+  RegOperand &srcRegOpnd = x64CGFunc->GetOpndBuilder()->CreateVReg(ploc.reg0, srcBitSize, regType);
+
+  MOperator mOp;
+  if (srcBitSize == k64BitSize) {
+    mOp = x64::MOP_movq_r_r;
+  } else if (srcBitSize == k32BitSize) {
+    mOp = x64::MOP_movl_r_r;
+  } else if (srcBitSize == k16BitSize) {
+    mOp = x64::MOP_movw_r_r;
+  } else if (srcBitSize == k8BitSize) {
+    mOp = x64::MOP_movb_r_r;
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  Insn &insn = x64CGFunc->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  insn.AddOpndChain(srcRegOpnd).AddOpndChain(dstRegOpnd);
+  if (x64CGFunc->GetCG()->GenerateVerboseCG()) {
+    std::string key = "param: %%";
+    key += std::to_string(mirSym.GetPreg()->GetPregNo());
+    insn.SetComment(key);
+  }
+  x64CGFunc->GetCurBB()->InsertInsnBegin(insn);
+}
+
+void X64MoveRegArgs::MoveVRegisterArgs() {
+  X64CGFunc *x64CGFunc = static_cast<X64CGFunc*>(cgFunc);
+  BB *formerCurBB = x64CGFunc->GetCurBB();
+  x64CGFunc->GetDummyBB()->ClearInsns();
+  x64CGFunc->SetCurBB(*x64CGFunc->GetDummyBB());
+  X64CallConvImpl parmlocator(x64CGFunc->GetBecommon());
+  CCLocInfo ploc;
+
+  uint32 formalCount = static_cast<uint32>(x64CGFunc->GetFunction().GetFormalCount());
+  uint32 start = 0;
+  if (formalCount) {
+    MIRFunction *func = const_cast<MIRFunction*>(x64CGFunc->GetBecommon().GetMIRModule().CurFunction());
+    if (x64CGFunc->GetBecommon().HasFuncReturnType(*func)) {
+      TyIdx idx = x64CGFunc->GetBecommon().GetFuncReturnType(*func);
+      if (x64CGFunc->GetBecommon().GetTypeSize(idx) <= k16BitSize) {
+        start = 1;
+      }
+    }
+  }
+  for (uint32 i = start; i < formalCount; ++i) {
+    MIRType *ty = x64CGFunc->GetFunction().GetNthParamType(i);
+    parmlocator.LocateNextParm(*ty, ploc, i == 0, &x64CGFunc->GetFunction());
+    MIRSymbol *sym = x64CGFunc->GetFunction().GetFormal(i);
+
+    /* load locarefvar formals to store in the reflocals. */
+    if (x64CGFunc->GetFunction().GetNthParamAttr(i).GetAttr(ATTR_localrefvar) && ploc.reg0 == kRinvalid) {
+      CHECK_FATAL(false, "NIY");
+    }
+
+    if (!sym->IsPreg()) {
+      continue;
+    }
+
+    if (ploc.reg0 == kRinvalid) {
+      /* load stack parameters to the vreg. */
+      LoadStackArgsToVReg(*sym);
+    } else {
+      MoveArgsToVReg(ploc, *sym);
+    }
+  }
+
+  x64CGFunc->GetFirstBB()->InsertAtBeginning(*x64CGFunc->GetDummyBB());
+  x64CGFunc->SetCurBB(*formerCurBB);
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_call_conv.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_call_conv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e3c4adf654a7b924945cd48d42692bd2595afbe
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_call_conv.cpp
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_cgfunc.h"
+#include "becommon.h"
+#include "abi.h"
+#include "x64_call_conv.h"
+namespace maplebe {
+using namespace maple;
+using namespace x64;
+constexpr int kMaxRegCount = 4;
+
+int32 ClassifyAggregate(MIRType &mirType, uint64 sizeOfTy, ArgumentClass classes[kMaxRegCount]) {
+  /*
+   * 1. If the size of an object is larger than four eightbytes, or it contains unaligned
+   * fields, it has class MEMORY;
+   * 2. for the processors that do not support the __m256 type, if the size of an object
+   * is larger than two eightbytes and the first eightbyte is not SSE or any other eightbyte
+   * is not SSEUP, it still has class MEMORY.
+   * This in turn ensures that for rocessors that do support the __m256 type, if the size of
+   * an object is four eightbytes and the first eightbyte is SSE and all other eightbytes are
+   * SSEUP, it can be passed in a register.
+   *(Currently, assume that m256 is not supported)
+   */
+  if (sizeOfTy > k2EightBytesSize) {
+    classes[0] = kMemoryClass;
+  } else if (sizeOfTy > k1EightBytesSize) {
+    classes[0] = kIntegerClass;
+    classes[1] = kIntegerClass;
+  } else {
+    classes[0] = kIntegerClass;
+  }
+  return static_cast<int32>(sizeOfTy);
+}
+
+int32 Classification(const BECommon &be, MIRType &mirType, ArgumentClass classes[kMaxRegCount]) {
+  switch (mirType.GetPrimType()) {
+    /*
+     * Arguments of types void, (signed and unsigned) _Bool, char, short, int,
+     * long, long long, and pointers are in the INTEGER class.
+     */
+    case PTY_void:
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_i8:
+    case PTY_u16:
+    case PTY_i16:
+    case PTY_a32:
+    case PTY_u32:
+    case PTY_i32:
+    case PTY_a64:
+    case PTY_ptr:
+    case PTY_ref:
+    case PTY_u64:
+    case PTY_i64:
+      classes[0] = kIntegerClass;
+      return k8ByteSize;
+    /*
+     * Arguments of type __int128 offer the same operations as INTEGERs,
+     * yet they do not fit into one general purpose register but require
+     * two registers.
+     */
+    case PTY_i128:
+    case PTY_u128:
+      classes[0] = kIntegerClass;
+      classes[1] = kIntegerClass;
+      return k16ByteSize;
+    case PTY_f32:
+    case PTY_f64:
+      classes[0] = kFloatClass;
+      return k8ByteSize;
+    case PTY_agg: {
+      /*
+       * The size of each argument gets rounded up to eightbytes,
+       * Therefore the stack will always be eightbyte aligned.
+       */
+      uint64 sizeOfTy = RoundUp(be.GetTypeSize(mirType.GetTypeIndex()), k8ByteSize);
+      if (sizeOfTy == 0) {
+        return 0;
+      }
+      /* If the size of an object is larger than four eightbytes, it has class MEMORY */
+      if ((sizeOfTy > k4EightBytesSize)) {
+          classes[0] = kMemoryClass;
+          return static_cast<int32>(sizeOfTy);
+      }
+      return ClassifyAggregate(mirType, sizeOfTy, classes);
+    }
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+  return 0;
+}
+
+void X64CallConvImpl::InitCCLocInfo(CCLocInfo &pLoc) const {
+  pLoc.reg0 = kRinvalid;
+  pLoc.reg1 = kRinvalid;
+  pLoc.reg2 = kRinvalid;
+  pLoc.reg3 = kRinvalid;
+  pLoc.memOffset = nextStackArgAdress;
+  pLoc.fpSize = 0;
+  pLoc.numFpPureRegs = 0;
+}
+
+int32 X64CallConvImpl::LocateNextParm(MIRType &mirType, CCLocInfo &pLoc, bool isFirst, MIRFunction *tFunc) {
+  InitCCLocInfo(pLoc);
+  ArgumentClass classes[kMaxRegCount] = { kNoClass };  /* Max of four Regs. */
+  int32 alignedTySize = Classification(beCommon, mirType, classes);
+  if (alignedTySize == 0) {
+    return 0;
+  }
+  pLoc.memSize = alignedTySize;
+  ++paramNum;
+  if (classes[0] == kIntegerClass) {
+    if (alignedTySize == k8ByteSize) {
+      pLoc.reg0 = AllocateGPParmRegister();
+      ASSERT(nextGeneralParmRegNO <= kNumIntParmRegs, "RegNo should be pramRegNO");
+    } else if (alignedTySize == k16ByteSize) {
+      AllocateTwoGPParmRegisters(pLoc);
+      ASSERT(nextGeneralParmRegNO <= kNumIntParmRegs, "RegNo should be pramRegNO");
+    }
+  } else if (classes[0] == kFloatClass) {
+    if (alignedTySize == k8ByteSize) {
+      pLoc.reg0 = AllocateSIMDFPRegister();
+      ASSERT(nextGeneralParmRegNO <= kNumFloatParmRegs, "RegNo should be pramRegNO");
+    } else {
+      CHECK_FATAL(false, "niy");
+    }
+  }
+  if (pLoc.reg0 == kRinvalid || classes[0] == kMemoryClass) {
+    /* being passed in memory */
+    nextStackArgAdress = pLoc.memOffset + alignedTySize;
+  }
+  return 0;
+}
+
+int32 X64CallConvImpl::LocateRetVal(MIRType &retType, CCLocInfo &pLoc) {
+  InitCCLocInfo(pLoc);
+  ArgumentClass classes[kMaxRegCount] = { kNoClass };  /* Max of four Regs. */
+  int32 alignedTySize = Classification(beCommon, retType, classes);
+  if (alignedTySize == 0) {
+    return 0;    /* size 0 ret val */
+  }
+  if (classes[0] == kIntegerClass) {
+    /* If the class is INTEGER, the next available register of the sequence %rax, */
+    /* %rdx is used. */
+    CHECK_FATAL(alignedTySize <= k16ByteSize, "LocateRetVal: illegal number of regs");
+    pLoc.regCount = alignedTySize;
+    if (alignedTySize == k8ByteSize) {
+      pLoc.reg0 = AllocateGPReturnRegister();
+      ASSERT(nextGeneralReturnRegNO <= kNumIntReturnRegs, "RegNo should be pramRegNO");
+    } else if (alignedTySize == k16ByteSize) {
+      AllocateTwoGPReturnRegisters(pLoc);
+      ASSERT(nextGeneralReturnRegNO <= kNumIntReturnRegs, "RegNo should be pramRegNO");
+    }
+    if (nextGeneralReturnRegNO == kOneRegister) {
+      pLoc.primTypeOfReg0 = retType.GetPrimType() == PTY_agg ? PTY_u64 : retType.GetPrimType();
+    } else if (nextGeneralReturnRegNO == kTwoRegister) {
+      pLoc.primTypeOfReg0 = retType.GetPrimType() == PTY_agg ? PTY_u64 : retType.GetPrimType();
+      pLoc.primTypeOfReg1 = retType.GetPrimType() == PTY_agg ? PTY_u64 : retType.GetPrimType();
+    }
+    return 0;
+  } else if (classes[0] == kFloatClass) {
+    /* If the class is SSE, the next available vector register of the sequence %xmm0, */
+    /* %xmm1 is used. */
+    CHECK_FATAL(alignedTySize <= k16ByteSize, "LocateRetVal: illegal number of regs");
+    pLoc.regCount = alignedTySize;
+    if (alignedTySize == k8ByteSize) {
+      pLoc.reg0 = AllocateSIMDFPRegister();
+      ASSERT(nextGeneralParmRegNO <= kNumFloatParmRegs, "RegNo should be pramRegNO");
+    } else if (alignedTySize == k16ByteSize) {
+      CHECK_FATAL(false, "niy");
+    }
+    if (nextFloatRegNO == kOneRegister) {
+      pLoc.primTypeOfReg0 = retType.GetPrimType() == PTY_agg ? PTY_f64 : retType.GetPrimType();
+    } else if (nextFloatRegNO == kTwoRegister) {
+      CHECK_FATAL(false, "niy");
+    }
+    return 0;
+  }
+  if (pLoc.reg0 == kRinvalid || classes[0] == kMemoryClass) {
+    /*
+     * the caller provides space for the return value and passes
+     * the address of this storage in %rdi as if it were the first
+     * argument to the function. In effect, this address becomes a
+     * “hidden” first argument.
+     * On return %rax will contain the address that has been passed
+     * in by the caller in %rdi.
+     * Currently, this scenario is not fully supported.
+     */
+    pLoc.reg0 = AllocateGPReturnRegister();
+    return 0;
+  }
+  CHECK_FATAL(false, "NYI");
+  return 0;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_cfgo.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_cfgo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b3a34fe6680b9ac055b1541c374949a51a2e2758
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_cfgo.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "x64_cfgo.h"
+#include "x64_isa.h"
+
+namespace maplebe {
+/* Initialize cfg optimization patterns */
+void X64CFGOptimizer::InitOptimizePatterns() {
+  diffPassPatterns.emplace_back(memPool->New<SequentialJumpPattern>(*cgFunc));
+  diffPassPatterns.emplace_back(memPool->New<X64FlipBRPattern>(*cgFunc));
+  diffPassPatterns.emplace_back(memPool->New<DuplicateBBPattern>(*cgFunc));
+  diffPassPatterns.emplace_back(memPool->New<UnreachBBPattern>(*cgFunc));
+  diffPassPatterns.emplace_back(memPool->New<EmptyBBPattern>(*cgFunc));
+}
+
+uint32 X64FlipBRPattern::GetJumpTargetIdx(const Insn &insn) {
+  return x64::GetJumpTargetIdx(insn);
+}
+MOperator X64FlipBRPattern::FlipConditionOp(MOperator flippedOp) {
+  return x64::FlipConditionOp(flippedOp);
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_cg.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_cg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d58b82d54848e2c8adf999d902bcb5dbb166cbc6
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_cg.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "x64_cg.h"
+#include "x64_cgfunc.h"
+#include "x64_isa.h"
+namespace maplebe {
+using namespace x64;
+#define DEFINE_MOP(...) {__VA_ARGS__},
+const InsnDesc X64CG::kMd[kMopLast] = {
+#include "abstract_mmir.def"
+#include "x64_md.def"
+};
+#undef DEFINE_MOP
+
+std::array<std::array<const std::string, kAllRegNum>, kIntRegTypeNum> X64CG::intRegNames = {
+    std::array<const std::string, kAllRegNum> {
+        "err", "al", "bl", "cl", "dl", "spl", "bpl", "sil", "dil", "r8b", "r9b", "r10b", "r11b", "r12b", "r13b",
+        "r14b", "r15b", "err1", "errMaxRegNum"
+    }, std::array<const std::string, kAllRegNum> {
+        "err", "ah", "bh", "ch", "dh", "err0", "err1", "err2", "err3", "err4", "err5", "err6", "err7", "err8", "err9",
+        "err10", "err11", "err12", "errMaxRegNum"
+    }, std::array<const std::string, kAllRegNum> {
+        "err", "ax", "bx", "cx", "dx", "sp", "bp", "si", "di", "r8w", "r9w", "r10w", "r11w", "r12w", "r13w",
+        "r14w", "r15w", "err1", "errMaxRegNum"
+    }, std::array<const std::string, kAllRegNum> {
+        "err", "eax", "ebx", "ecx", "edx", "esp", "ebp", "esi", "edi", "r8d", "r9d", "r10d", "r11d", "r12d", "r13d",
+        "r14d", "r15d", "err1", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", "xmm8", "xmm9", "xmm10",
+        "xmm11", "xmm12", "xmm13", "xmm14", "xmm15", "errMaxRegNum"
+    }, std::array<const std::string, kAllRegNum> {
+        "err", "rax", "rbx", "rcx", "rdx", "rsp", "rbp", "rsi", "rdi", "r8", "r9", "r10", "r11", "r12", "r13",
+        "r14", "r15", "rip", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", "xmm8", "xmm9", "xmm10",
+    "xmm11", "xmm12", "xmm13", "xmm14", "xmm15", "errMaxRegNum"
+    },
+};
+
+void X64CG::EnrollTargetPhases(maple::MaplePhaseManager *pm) const {
+#include "x64_phases.def"
+}
+
+CGFunc *X64CG::CreateCGFunc(MIRModule &mod, MIRFunction &mirFunc, BECommon &bec, MemPool &memPool,
+                            StackMemPool &stackMp, MapleAllocator &mallocator, uint32 funcId) {
+  return memPool.New<X64CGFunc>(mod, *this, mirFunc, bec, memPool, stackMp, mallocator, funcId);
+}
+
+bool X64CG::IsEffectiveCopy(Insn &insn) const {
+  return false;
+}
+bool X64CG::IsTargetInsn(MOperator mOp) const {
+  return (mOp >= MOP_movb_r_r && mOp <= MOP_pseudo_ret_int);
+}
+bool X64CG::IsClinitInsn(MOperator mOp) const {
+  return false;
+}
+
+Insn &X64CG::BuildPhiInsn(RegOperand &defOpnd, Operand &listParam) {
+  CHECK_FATAL(false, "NIY");
+  Insn *a = nullptr;
+  return *a;
+}
+
+PhiOperand &X64CG::CreatePhiOperand(MemPool &mp, MapleAllocator &mAllocator) {
+  CHECK_FATAL(false, "NIY");
+  PhiOperand *a = nullptr;
+  return *a;
+}
+
+void X64CG::DumpTargetOperand(Operand &opnd, const OpndDesc &opndDesc) const {
+  X64OpndDumpVisitor visitor(opndDesc);
+  opnd.Accept(visitor);
+}
+
+bool X64CG::IsExclusiveFunc(MIRFunction &mirFunc) {
+  return false;
+}
+
+/* NOTE: Consider making be_common a field of CG. */
+void X64CG::GenerateObjectMaps(BECommon &beCommon) {}
+
+/* Used for GCTIB pattern merging */
+std::string X64CG::FindGCTIBPatternName(const std::string &name) const {
+  return "";
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_cgfunc.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_cgfunc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..af38d2fca193381b330470fdce3d9351b52ea735
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_cgfunc.cpp
@@ -0,0 +1,918 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <x86_64/x64_cg.h>
+#include "x64_cgfunc.h"
+#include "x64_memlayout.h"
+#include "x64_isa.h"
+
+namespace maplebe {
+/* null implementation yet */
+void X64CGFunc::GenSaveMethodInfoCode(BB &bb) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::GenerateCleanupCode(BB &bb) {
+  CHECK_FATAL(false, "NIY");
+}
+bool X64CGFunc::NeedCleanup() {
+  CHECK_FATAL(false, "NIY");
+  return false;
+}
+void X64CGFunc::GenerateCleanupCodeForExtEpilog(BB &bb) {
+  CHECK_FATAL(false, "NIY");
+}
+uint32 X64CGFunc::FloatParamRegRequired(MIRStructType *structType, uint32 &fpSize) {
+  CHECK_FATAL(false, "NIY");
+  return 0;
+}
+void X64CGFunc::AssignLmbcFormalParams() {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::LmbcGenSaveSpForAlloca() {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::MergeReturn() {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::DetermineReturnTypeofCall() {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::HandleRCCall(bool begin, const MIRSymbol *retRef) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::HandleRetCleanup(NaryStmtNode &retNode) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectDassign(DassignNode &stmt, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectDassignoff(DassignoffNode &stmt, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectRegassign(RegassignNode &stmt, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectAbort() {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectAssertNull(UnaryStmtNode &stmt) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectAsm(AsmNode &node) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectAggDassign(DassignNode &stmt) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectIassign(IassignNode &stmt) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectIassignoff(IassignoffNode &stmt) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectIassignfpoff(IassignFPoffNode &stmt, Operand &opnd) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectIassignspoff(PrimType pTy, int32 offset, Operand &opnd) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectBlkassignoff(BlkassignoffNode &bNode, Operand *src) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectAggIassign(IassignNode &stmt, Operand &lhsAddrOpnd) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectReturnSendOfStructInRegs(BaseNode *x) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectReturn(Operand *opnd) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectIgoto(Operand *opnd0) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectCondGoto(CondGotoNode &stmt, Operand &opnd0, Operand &opnd1) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectCondSpecialCase1(CondGotoNode &stmt, BaseNode &opnd0) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectCondSpecialCase2(const CondGotoNode &stmt, BaseNode &opnd0) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectGoto(GotoNode &stmt) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectCall(CallNode &callNode) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectIcall(IcallNode &icallNode, Operand &fptrOpnd) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectIntrinCall(IntrinsiccallNode &intrinsiccallNode) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectIntrinsicOpWithOneParam(IntrinsicopNode &intrinopNode, std::string name) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCclz(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCctz(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCpopcount(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCparity(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCclrsb(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCisaligned(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCalignup(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCaligndown(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCSyncBoolCmpSwap(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCSyncValCmpSwap(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCSyncLockTestSet(IntrinsicopNode &intrinopNode, PrimType pty) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectBswap(IntrinsicopNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCSyncFetch(IntrinsicopNode &intrinsicopNode, Opcode op, bool fetchBefore) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCSyncSynchronize(IntrinsicopNode &intrinsicopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCAtomicLoadN(IntrinsicopNode &intrinsicopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCAtomicExchangeN(const IntrinsiccallNode &intrinsiccallNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCAtomicFetch(IntrinsicopNode &intrinsicopNode, Opcode op, bool fetchBefore) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCReturnAddress(IntrinsicopNode &intrinopNode) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectCAtomicExchange(const IntrinsiccallNode &intrinsiccallNode) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectMembar(StmtNode &membar) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::SelectComment(CommentNode &comment) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::HandleCatch() {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectDread(const BaseNode &parent, AddrofNode &expr) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectRegread(RegreadNode &expr) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectAddrof(AddrofNode &expr, const BaseNode &parent, bool isAddrofoff) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectAddrofoff(AddrofoffNode &expr, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+
+Operand &X64CGFunc::SelectAddrofFunc(AddroffuncNode &expr, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  Operand *a;
+  return *a;
+}
+Operand &X64CGFunc::SelectAddrofLabel(AddroflabelNode &expr, const BaseNode &parent)  {
+  CHECK_FATAL(false, "NIY");
+  Operand *a;
+  return *a;
+}
+Operand *X64CGFunc::SelectIread(const BaseNode &parent, IreadNode &expr, int extraOffset,
+                                PrimType finalBitFieldDestType) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectIreadoff(const BaseNode &parent, IreadoffNode &ireadoff) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectIreadfpoff(const BaseNode &parent, IreadFPoffNode &ireadoff) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectIntConst(MIRIntConst &intConst) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectFloatConst(MIRFloatConst &floatConst, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectDoubleConst(MIRDoubleConst &doubleConst, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectStrConst(MIRStrConst &strConst) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectStr16Const(MIRStr16Const &strConst) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectAdd(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectAdd(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectMadd(Operand &resOpnd, Operand &opndM0, Operand &opndM1, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectMadd(BinaryNode &node, Operand &opndM0, Operand &opndM1, Operand &opnd1,
+                               const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectRor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand &X64CGFunc::SelectCGArrayElemAdd(BinaryNode &node, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  Operand *a;
+  return *a;
+}
+Operand *X64CGFunc::SelectShift(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectMpy(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectMpy(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectDiv(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectDiv(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectSub(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectSub(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectBand(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectBand(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectLand(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectLor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent,
+                              bool parentIsBr) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectMin(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectMin(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectMax(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectMax(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCmpOp(CompareNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectBior(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectBior(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectBxor(BinaryNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectBxor(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectAbs(UnaryNode &node, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectBnot(UnaryNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectExtractbits(ExtractbitsNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectDepositBits(DepositbitsNode &node, Operand &opnd0, Operand &opnd1, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectRegularBitFieldLoad(ExtractbitsNode &node, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectLnot(UnaryNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectNeg(UnaryNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectRecip(UnaryNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectSqrt(UnaryNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCeil(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectFloor(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectRetype(TypeCvtNode &node, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectRound(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectCvt(const BaseNode &parent, TypeCvtNode &node, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectTrunc(TypeCvtNode &node, Operand &opnd0, const BaseNode &parent) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectSelect(TernaryNode &node, Operand &cond, Operand &opnd0, Operand &opnd1,
+                                 const BaseNode &parent, bool hasCompare) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectMalloc(UnaryNode &call, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand &X64CGFunc::SelectCopy(Operand &src, PrimType srcType, PrimType dstType) {
+  CHECK_FATAL(false, "NIY");
+  RegOperand *a;
+  return *a;
+}
+Operand *X64CGFunc::SelectAlloca(UnaryNode &call, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectGCMalloc(GCMallocNode &call) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectJarrayMalloc(JarrayMallocNode &call, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::SelectRangeGoto(RangeGotoNode &rangeGotoNode, Operand &opnd0) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand *X64CGFunc::SelectLazyLoad(Operand &opnd0, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectLazyLoadStatic(MIRSymbol &st, int64 offset, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectLoadArrayClassCache(MIRSymbol &st, int64 offset, PrimType primType) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::GenerateYieldpoint(BB &bb) {
+  CHECK_FATAL(false, "NIY");
+}
+Operand &X64CGFunc::ProcessReturnReg(PrimType primType, int32 sReg) {
+  CHECK_FATAL(false, "NIY");
+  Operand *a;
+  return *a;
+}
+Operand &X64CGFunc::GetOrCreateRflag() {
+  CHECK_FATAL(false, "NIY");
+  Operand *a;
+  return *a;
+}
+const Operand *X64CGFunc::GetRflag() const {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+const Operand *X64CGFunc::GetFloatRflag() const {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+const LabelOperand *X64CGFunc::GetLabelOperand(LabelIdx labIdx) const {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+LabelOperand &X64CGFunc::GetOrCreateLabelOperand(LabelIdx labIdx) {
+  std::string lableName = ".L." + std::to_string(GetUniqueID()) +
+      "__" + std::to_string(labIdx);
+  return GetOpndBuilder()->CreateLabel(lableName.c_str(), labIdx);
+}
+LabelOperand &X64CGFunc::GetOrCreateLabelOperand(BB &bb) {
+  CHECK_FATAL(false, "NIY");
+  LabelOperand *a;
+  return *a;
+}
+RegOperand &X64CGFunc::CreateVirtualRegisterOperand(regno_t vRegNO) {
+  CHECK_FATAL(false, "NIY");
+  RegOperand *a;
+  return *a;
+}
+RegOperand &X64CGFunc::GetOrCreateVirtualRegisterOperand(regno_t vRegNO) {
+  CHECK_FATAL(false, "NIY");
+  RegOperand *a;
+  return *a;
+}
+RegOperand &X64CGFunc::GetOrCreateVirtualRegisterOperand(RegOperand &regOpnd) {
+  CHECK_FATAL(false, "NIY");
+  RegOperand *a;
+  return *a;
+}
+RegOperand &X64CGFunc::GetOrCreateFramePointerRegOperand() {
+  CHECK_FATAL(false, "NIY");
+  RegOperand *a;
+  return *a;
+}
+RegOperand &X64CGFunc::GetOrCreateStackBaseRegOperand() {
+  return GetOpndBuilder()->CreatePReg(x64::RBP, GetPointerSize() * kBitsPerByte, kRegTyInt);
+}
+RegOperand &X64CGFunc::GetZeroOpnd(uint32 size) {
+  CHECK_FATAL(false, "NIY");
+  RegOperand *a;
+  return *a;
+}
+Operand &X64CGFunc::CreateCfiRegOperand(uint32 reg, uint32 size) {
+  CHECK_FATAL(false, "NIY");
+  Operand *a;
+  return *a;
+}
+Operand &X64CGFunc::GetTargetRetOperand(PrimType primType, int32 sReg) {
+  CHECK_FATAL(false, "NIY");
+  Operand *a;
+  return *a;
+}
+Operand &X64CGFunc::CreateImmOperand(PrimType primType, int64 val) {
+  CHECK_FATAL(false, "NIY");
+  Operand *a;
+  return *a;
+}
+void X64CGFunc::ReplaceOpndInInsn(RegOperand &regDest, RegOperand &regSrc, Insn &insn, regno_t regno) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::CleanupDeadMov(bool dump) {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::GetRealCallerSaveRegs(const Insn &insn, std::set<regno_t> &realCallerSave) {
+  CHECK_FATAL(false, "NIY");
+}
+bool X64CGFunc::IsFrameReg(const RegOperand &opnd) const {
+  CHECK_FATAL(false, "NIY");
+  return false;
+}
+RegOperand *X64CGFunc::SelectVectorAddLong(PrimType rTy, Operand *o1, Operand *o2, PrimType oty, bool isLow) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorAddWiden(Operand *o1, PrimType oty1, Operand *o2, PrimType oty2, bool isLow) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorAbs(PrimType rType, Operand *o1) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorBinOp(PrimType rType, Operand *o1, PrimType oTyp1, Operand *o2,
+                                         PrimType oTyp2, Opcode opc) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorBitwiseOp(PrimType rType, Operand *o1, PrimType oty1, Operand *o2,
+                                             PrimType oty2, Opcode opc) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorCompareZero(Operand *o1, PrimType oty1, Operand *o2, Opcode opc) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorCompare(Operand *o1, PrimType oty1,  Operand *o2, PrimType oty2, Opcode opc) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorFromScalar(PrimType pType, Operand *opnd, PrimType sType) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorDup(PrimType rType, Operand *src, bool getLow) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorGetElement(PrimType rType, Operand *src, PrimType sType, int32 lane) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorAbsSubL(PrimType rType, Operand *o1, Operand *o2, PrimType oTy, bool isLow) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorMadd(Operand *o1, PrimType oTyp1, Operand *o2, PrimType oTyp2, Operand *o3,
+                                        PrimType oTyp3) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorMerge(PrimType rTyp, Operand *o1, Operand *o2, int32 iNum) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorMull(PrimType rType, Operand *o1, PrimType oTyp1, Operand *o2, PrimType oTyp2,
+                                        bool isLow) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorNarrow(PrimType rType, Operand *o1, PrimType otyp) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorNarrow2(PrimType rType, Operand *o1, PrimType oty1, Operand *o2, PrimType oty2) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorNeg(PrimType rType, Operand *o1) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorNot(PrimType rType, Operand *o1) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorPairwiseAdalp(Operand *src1, PrimType sty1, Operand *src2, PrimType sty2) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorPairwiseAdd(PrimType rType, Operand *src, PrimType sType) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorReverse(PrimType rtype, Operand *src, PrimType stype, uint32 size) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorSetElement(Operand *eOp, PrimType eTyp, Operand *vOpd, PrimType vTyp,
+                                              int32 lane) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorShift(PrimType rType, Operand *o1, PrimType oty1, Operand *o2, PrimType oty2,
+                                         Opcode opc) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorShiftImm(PrimType rType, Operand *o1, Operand *imm, int32 sVal, Opcode opc) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorShiftRNarrow(PrimType rType, Operand *o1, PrimType oType, Operand *o2, bool isLow) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorSubWiden(PrimType resType, Operand *o1, PrimType otyp1, Operand *o2, PrimType otyp2,
+                                            bool isLow, bool isWide) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorSum(PrimType rtype, Operand *o1, PrimType oType) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorTableLookup(PrimType rType, Operand *o1, Operand *o2) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorWiden(PrimType rType, Operand *o1, PrimType otyp, bool isLow) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+RegOperand *X64CGFunc::SelectVectorMovNarrow(PrimType rType, Operand *opnd, PrimType oType) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+Operand *X64CGFunc::SelectIntrinsicOpWithNParams(IntrinsicopNode &intrinopNode, PrimType retType,
+                                                 const std::string &name) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+void X64CGFunc::ProcessLazyBinding() {
+  CHECK_FATAL(false, "NIY");
+}
+void X64CGFunc::DBGFixCallFrameLocationOffsets() {
+  CHECK_FATAL(false, "NIY");
+}
+MemOperand *X64CGFunc::GetPseudoRegisterSpillMemoryOperand(PregIdx idx) {
+  CHECK_FATAL(false, "NIY");
+  return nullptr;
+}
+int32 X64CGFunc::GetBaseOffset(const SymbolAlloc &symbolAlloc) {
+  const auto *symAlloc = static_cast<const X64SymbolAlloc*>(&symbolAlloc);
+  /* Call Frame layout of X64
+   * Refer to layout in x64_memlayout.h.
+   * Do Not change this unless you know what you do
+   * memlayout like this
+   * rbp position
+   * ArgsReg  --
+   * Locals     | -- FrameSize
+   * Spill      |
+   * ArgsStk  --
+   */
+  constexpr const int32 sizeofFplr = 2 * kIntregBytelen;
+  // baseOffset is the offset of this symbol based on the rbp position.
+  int32 baseOffset = symAlloc->GetOffset();
+  MemSegmentKind sgKind = symAlloc->GetMemSegment()->GetMemSegmentKind();
+  auto *memLayout = static_cast<X64MemLayout*>(this->GetMemlayout());
+  if (sgKind == kMsSpillReg) {
+    /* spill = -(Locals + ArgsReg + baseOffset + kSizeOfPtr) */
+    return -(memLayout->GetSizeOfLocals() + memLayout->SizeOfArgsRegisterPassed() + baseOffset + GetPointerSize());
+  }
+  else if (sgKind == kMsLocals) {
+    /* Locals = baseOffset-(Locals + ArgsReg) */
+    return baseOffset - (memLayout->GetSizeOfLocals() + memLayout->SizeOfArgsRegisterPassed());
+  } else if (sgKind == kMsArgsRegPassed) {
+    /* ArgsReg = baseOffset-(ArgsReg) */
+    return baseOffset - memLayout->SizeOfArgsRegisterPassed();
+  } else if (sgKind == kMsArgsStkPassed) {
+    return baseOffset + sizeofFplr;
+  } else {
+    CHECK_FATAL(false, "sgKind check");
+  }
+  return 0;
+}
+
+RegOperand *X64CGFunc::GetBaseReg(const maplebe::SymbolAlloc &symAlloc) {
+  MemSegmentKind sgKind = symAlloc.GetMemSegment()->GetMemSegmentKind();
+  ASSERT(((sgKind == kMsArgsRegPassed) || (sgKind == kMsLocals) || (sgKind == kMsRefLocals) ||
+      (sgKind == kMsArgsToStkPass) || (sgKind == kMsArgsStkPassed)), "NIY");
+  if (sgKind == kMsLocals || sgKind == kMsArgsRegPassed || sgKind == kMsArgsStkPassed) {
+    return &GetOpndBuilder()->CreatePReg(x64::RBP, GetPointerSize() * kBitsPerByte, kRegTyInt);
+  } else {
+    CHECK_FATAL(false, "NIY sgKind");
+  }
+  return nullptr;
+}
+
+void X64CGFunc::FreeSpillRegMem(regno_t vrNum) {
+  MemOperand *memOpnd = nullptr;
+
+  auto p = spillRegMemOperands.find(vrNum);
+  if (p != spillRegMemOperands.end()) {
+    memOpnd = p->second;
+  }
+
+  if ((memOpnd == nullptr) && IsVRegNOForPseudoRegister(vrNum)) {
+    auto pSecond = pRegSpillMemOperands.find(GetPseudoRegIdxFromVirtualRegNO(vrNum));
+    if (pSecond != pRegSpillMemOperands.end()) {
+      memOpnd = pSecond->second;
+    }
+  }
+
+  if (memOpnd == nullptr) {
+    ASSERT(false, "free spillreg have no mem");
+    return;
+  }
+
+  uint32 size = memOpnd->GetSize();
+  MapleUnorderedMap<uint32, SpillMemOperandSet*>::iterator iter;
+  if ((iter = reuseSpillLocMem.find(size)) != reuseSpillLocMem.end()) {
+    iter->second->Add(*memOpnd);
+  } else {
+    reuseSpillLocMem[size] = memPool->New<SpillMemOperandSet>(*GetFuncScopeAllocator());
+    reuseSpillLocMem[size]->Add(*memOpnd);
+  }
+}
+
+MemOperand *X64CGFunc::GetOrCreatSpillMem(regno_t vrNum) {
+  /* NOTES: must used in RA, not used in other place. */
+  if (IsVRegNOForPseudoRegister(vrNum)) {
+    auto p = pRegSpillMemOperands.find(GetPseudoRegIdxFromVirtualRegNO(vrNum));
+    if (p != pRegSpillMemOperands.end()) {
+      return p->second;
+    }
+  }
+
+  auto p = spillRegMemOperands.find(vrNum);
+  if (p == spillRegMemOperands.end()) {
+    uint32 memBitSize = k64BitSize;
+    auto it = reuseSpillLocMem.find(memBitSize);
+    if (it != reuseSpillLocMem.end()) {
+      MemOperand *memOpnd = it->second->GetOne();
+      if (memOpnd != nullptr) {
+        spillRegMemOperands.emplace(std::pair<regno_t, MemOperand*>(vrNum, memOpnd));
+        return memOpnd;
+      }
+    }
+
+    RegOperand &baseOpnd = GetOrCreateStackBaseRegOperand();
+    int32 offset = GetOrCreatSpillRegLocation(vrNum);
+    MemOperand *memOpnd = &GetOpndBuilder()->CreateMem(baseOpnd, offset, memBitSize);
+    spillRegMemOperands.emplace(std::pair<regno_t, MemOperand*>(vrNum, memOpnd));
+    return memOpnd;
+  } else {
+    return p->second;
+  }
+}
+
+void X64OpndDumpVisitor::Visit(maplebe::RegOperand *v) {
+  DumpOpndPrefix();
+  LogInfo::MapleLogger() << "reg ";
+  DumpRegInfo(*v);
+  DumpSize(*v);
+  const OpndDesc *regDesc = GetOpndDesc();
+  LogInfo::MapleLogger() << " [";
+  if (regDesc->IsRegDef()) {
+    LogInfo::MapleLogger() << "DEF ";
+  }
+  if (regDesc->IsRegUse()) {
+    LogInfo::MapleLogger() << "USE";
+  }
+  LogInfo::MapleLogger() << "]";
+  DumpOpndSuffix();
+}
+
+void X64OpndDumpVisitor::Visit(CommentOperand *v) {
+  LogInfo::MapleLogger() << ":#" << v->GetComment();
+}
+
+void X64OpndDumpVisitor::Visit(maplebe::ImmOperand *v) {
+  DumpOpndPrefix();
+  if (v->IsStImmediate()) {
+    LogInfo::MapleLogger() << v->GetName();
+    LogInfo::MapleLogger() << "+offset:" << v->GetValue();
+  } else {
+    LogInfo::MapleLogger() << "imm:" << v->GetValue();
+  }
+  DumpSize(*v);
+  DumpOpndSuffix();
+}
+
+void X64OpndDumpVisitor::Visit(maplebe::MemOperand *v) {
+  DumpOpndPrefix();
+  LogInfo::MapleLogger() << "mem ";
+  if (v->GetBaseRegister() != nullptr) {
+    DumpRegInfo(*v->GetBaseRegister());
+    if (v->GetOffsetOperand() != nullptr) {
+      LogInfo::MapleLogger() << " + " << v->GetOffsetOperand()->GetValue();
+    }
+  }
+  DumpSize(*v);
+  DumpOpndSuffix();
+}
+void X64OpndDumpVisitor::DumpRegInfo(maplebe::RegOperand &v) {
+  if (v.GetRegisterNumber() > kBaseVirtualRegNO) {
+    LogInfo::MapleLogger() << "V" << v.GetRegisterNumber();
+  } else {
+    bool r32 = (v.GetSize() == k32BitSize);
+    LogInfo::MapleLogger() << "%"
+                           << X64CG::intRegNames[(r32 ? X64CG::kR32List : X64CG::kR64List)][v.GetRegisterNumber()];
+  }
+}
+
+void X64OpndDumpVisitor::Visit(maplebe::FuncNameOperand *v) {
+  DumpOpndPrefix();
+  LogInfo::MapleLogger() << "funcname ";
+  LogInfo::MapleLogger() << v->GetName();
+  DumpSize(*v);
+  DumpOpndSuffix();
+}
+
+void X64OpndDumpVisitor::Visit(maplebe::ListOperand *v) {
+  DumpOpndPrefix();
+  LogInfo::MapleLogger() << "list ";
+
+  MapleList<RegOperand*> opndList = v->GetOperands();
+  for (auto it = opndList.begin(); it != opndList.end();) {
+    (*it)->Dump();
+    LogInfo::MapleLogger() << (++it == opndList.end() ? "" : " ,");
+  }
+  DumpSize(*v);
+  DumpOpndSuffix();
+}
+
+void X64OpndDumpVisitor::Visit(maplebe::LabelOperand *v) {
+  DumpOpndPrefix();
+  LogInfo::MapleLogger() << "label ";
+  LogInfo::MapleLogger() << v->GetLabelIndex();
+  DumpSize(*v);
+  DumpOpndSuffix();
+}
+
+void X64OpndDumpVisitor::Visit(PhiOperand *v) {
+  CHECK_FATAL(false, "NIY");
+}
+
+void X64OpndDumpVisitor::Visit(CondOperand *v) {
+  CHECK_FATAL(false, "do not use this operand, it will be eliminated soon");
+}
+void X64OpndDumpVisitor::Visit(StImmOperand *v) {
+  CHECK_FATAL(false, "do not use this operand, it will be eliminated soon");
+}
+void X64OpndDumpVisitor::Visit(BitShiftOperand *v) {
+  CHECK_FATAL(false, "do not use this operand, it will be eliminated soon");
+}
+void X64OpndDumpVisitor::Visit(ExtendShiftOperand *v) {
+  CHECK_FATAL(false, "do not use this operand, it will be eliminated soon");
+}
+}
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_emitter.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_emitter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ab229f3d61fbbeffe1df2878fb315c21b2e6d6dd
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_emitter.cpp
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "x64_cgfunc.h"
+#include "x64_cg.h"
+#include "x64_emitter.h"
+#include "insn.h"
+
+namespace maplebe {
+void X64Emitter::EmitRefToMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) {}
+void X64Emitter::EmitRefToMethodInfo(FuncEmitInfo &funcEmitInfo, Emitter &emitter) {}
+void X64Emitter::EmitMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emitter) {}
+void X64Emitter::EmitFastLSDA(FuncEmitInfo &funcEmitInfo) {}
+void X64Emitter::EmitFullLSDA(FuncEmitInfo &funcEmitInfo) {}
+void X64Emitter::EmitJavaInsnAddr(FuncEmitInfo &funcEmitInfo) {}
+
+void X64Emitter::EmitBBHeaderLabel(FuncEmitInfo &funcEmitInfo, const std::string &name, LabelIdx labIdx) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  CG *currCG = cgFunc.GetCG();
+  Emitter &emitter = *(currCG->GetEmitter());
+
+  PUIdx pIdx = currCG->GetMIRModule()->CurFunction()->GetPuidx();
+  const char *puIdx = strdup(std::to_string(pIdx).c_str());
+  const std::string &labelName = cgFunc.GetFunction().GetLabelTab()->GetName(labIdx);
+  if (currCG->GenerateVerboseCG()) {
+    emitter.Emit(".L.").Emit(puIdx).Emit("__").Emit(labIdx).Emit(":\t");
+    if (!labelName.empty() && labelName.at(0) != '@') {
+      /* If label name has @ as its first char, it is not from MIR */
+      emitter.Emit("//  MIR: @").Emit(labelName).Emit("\n");
+    } else {
+      emitter.Emit("\n");
+    }
+  } else {
+    emitter.Emit(".L.").Emit(puIdx).Emit("__").Emit(labIdx).Emit(":\n");
+  }
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::RegOperand *v) {
+  ASSERT(v->IsRegister(), "NIY");
+  /* check legality of register operand: reg no. should not be larger than 100 or equal to 0 */
+  ASSERT(v->IsPhysicalRegister(), "register is still virtual");
+  ASSERT(v->GetRegisterNumber() > 0, "register no. is 0: ERR");
+  /* Mapping with physical register after register allocation is done
+   * try table-driven register mapping ? */
+  uint8 regType = -1;
+  switch (v->GetSize()) {
+    case k8BitSize:
+      regType = v->IsHigh8Bit() ? X64CG::kR8HighList : X64CG::kR8LowList;
+      break;
+    case k16BitSize:
+      regType = X64CG::kR16List;
+      break;
+    case k32BitSize:
+      regType = X64CG::kR32List;
+      break;
+    case k64BitSize:
+      regType = X64CG::kR64List;
+      break;
+    default:
+      CHECK_FATAL(false, "unkown reg size");
+      break;
+  }
+  emitter.Emit("%").Emit(X64CG::intRegNames[regType][v->GetRegisterNumber()]);
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::ImmOperand *v) {
+  ASSERT(v->IsImmediate(), "NIY");
+  emitter.Emit("$");
+  if (v->GetKind() == maplebe::Operand::kOpdStImmediate) {
+    /* symbol form imm */
+    emitter.Emit(v->GetName());
+  } else {
+    /* general imm */
+    emitter.Emit(v->GetValue());
+  }
+  return;
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::MemOperand *v) {
+  if (v->GetOffsetOperand() != nullptr) {
+    if (v->GetOffsetOperand()->GetKind() == maplebe::Operand::kOpdStImmediate) {
+      /* symbol form offset */
+      emitter.Emit(v->GetOffsetOperand()->GetName());
+      MIRStorageClass storageClass = v->GetOffsetOperand()->GetSymbol()->GetStorageClass();
+      bool isLocalVar = v->GetOffsetOperand()->GetSymbol()->IsLocal();
+      if (storageClass == kScPstatic && isLocalVar) {
+        PUIdx pIdx = emitter.GetCG()->GetMIRModule()->CurFunction()->GetPuidx();
+        emitter.Emit(pIdx);
+      }
+      if (v->GetOffsetOperand()->GetValue() != 0) {
+        emitter.Emit("+").Emit(v->GetOffsetOperand()->GetValue());
+      }
+
+    } else {
+      /* general offset */
+      emitter.Emit(v->GetOffsetOperand()->GetValue());
+    }
+  }
+  emitter.Emit("(");
+  if (v->GetBaseRegister() != nullptr) {
+    /* Emit RBP or EBP only when index register doesn't exist */
+    if ((v->GetIndexRegister() != nullptr && v->GetBaseRegister()->GetRegisterNumber() != x64::RBP) ||
+        v->GetIndexRegister() == nullptr) {
+      Visit(v->GetBaseRegister());
+    }
+  }
+  if (v->GetIndexRegister() != nullptr) {
+    emitter.Emit(", ");
+    Visit(v->GetIndexRegister());
+    emitter.Emit(", ").Emit(v->GetScaleOperand()->GetValue());
+  }
+  emitter.Emit(")");
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::LabelOperand *v) {
+  ASSERT(v->IsLabel(), "NIY");
+  const MapleString &labelName = v->GetParentFunc();
+  /* If this label indicates a bb's addr (named as: ".L." + UniqueID + "__" + Offset),
+   * prefix "$" is not required. */
+  if (!labelName.empty() && labelName[0] != '.') {
+    emitter.Emit("$");
+  }
+  emitter.Emit(labelName);
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::FuncNameOperand *v) {
+  emitter.Emit(v->GetName());
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::ListOperand *v) {
+  CHECK_FATAL(false, "do not run here");
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::StImmOperand *v) {
+  CHECK_FATAL(false, "do not run here");
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::CondOperand *v) {
+  CHECK_FATAL(false, "do not run here");
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::BitShiftOperand *v) {
+  CHECK_FATAL(false, "do not run here");
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::ExtendShiftOperand *v) {
+  CHECK_FATAL(false, "do not run here");
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::CommentOperand *v) {
+  CHECK_FATAL(false, "do not run here");
+}
+
+void X64OpndEmitVisitor::Visit(maplebe::OfstOperand *v) {
+  CHECK_FATAL(false, "do not run here");
+}
+
+void DumpTargetASM(Emitter &emitter, Insn &insn) {
+  emitter.Emit("\t");
+  const InsnDesc &curMd = X64CG::kMd[insn.GetMachineOpcode()];
+
+  /* Get Operands Number */
+  size_t size = 0;
+  std::string format(curMd.format);
+  for (char c : format) {
+    if (c != ',') {
+      size = size + 1;
+    }
+  }
+
+#if DEBUG
+  insn.Check();
+#endif
+
+  emitter.Emit(curMd.GetName()).Emit("\t");
+  /* In AT&T assembly syntax, Indirect jump/call operands are indicated
+   * with asterisk "*" (as opposed to direct).
+   * Direct jump/call: jmp .L.xxx__x or callq funcName
+   * Indirect jump/call: jmp *%rax; jmp *(%rax) or callq *%rax; callq *(%rax)
+   */
+  if (curMd.IsCall() || curMd.IsUnCondBranch()) {
+    const OpndDesc* opndDesc = curMd.GetOpndDes(0);
+    if (opndDesc->IsRegister() || opndDesc->IsMem()) {
+      emitter.Emit("*");
+    }
+  }
+
+  for (int i = 0; i < size; i++) {
+    Operand *opnd = &insn.GetOperand(i);
+    X64OpndEmitVisitor visitor(emitter);
+    opnd->Accept(visitor);
+    if (i != size - 1) {
+      emitter.Emit(",\t");
+    }
+  }
+  emitter.Emit("\n");
+}
+
+void EmitFunctionHeader(FuncEmitInfo &funcEmitInfo) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  CG *currCG = cgFunc.GetCG();
+  const MIRSymbol *funcSymbol = cgFunc.GetFunction().GetFuncSymbol();
+  Emitter &emitter = *currCG->GetEmitter();
+
+  if (cgFunc.GetFunction().GetAttr(FUNCATTR_section)) {
+    const std::string &sectionName = cgFunc.GetFunction().GetAttrs().GetPrefixSectionName();
+    (void)emitter.Emit("\t.section  " + sectionName).Emit(",\"ax\",@progbits\n");
+  } else {
+    emitter.EmitAsmLabel(kAsmText);
+  }
+  emitter.EmitAsmLabel(*funcSymbol, kAsmAlign);
+
+  if (funcSymbol->GetFunction()->GetAttr(FUNCATTR_weak)) {
+    emitter.EmitAsmLabel(*funcSymbol, kAsmWeak);
+    emitter.EmitAsmLabel(*funcSymbol, kAsmHidden);
+  } else if (funcSymbol->GetFunction()->GetAttr(FUNCATTR_local)) {
+    emitter.EmitAsmLabel(*funcSymbol, kAsmLocal);
+  } else if (!funcSymbol->GetFunction()->GetAttr(FUNCATTR_static)) {
+    emitter.EmitAsmLabel(*funcSymbol, kAsmGlbl);
+    if (!currCG->GetMIRModule()->IsCModule()) {
+      emitter.EmitAsmLabel(*funcSymbol, kAsmHidden);
+    }
+  }
+  emitter.EmitAsmLabel(kAsmType);
+  emitter.Emit(funcSymbol->GetName()).Emit(", %function\n");
+  emitter.EmitAsmLabel(*funcSymbol, kAsmSyname);
+}
+
+/* Specially, emit switch table here */
+void EmitJmpTable(Emitter &emitter, CGFunc &cgFunc) {
+  const MIRSymbol *funcSymbol = cgFunc.GetFunction().GetFuncSymbol();
+  for (auto &it : cgFunc.GetEmitStVec()) {
+    MIRSymbol *st = it.second;
+    ASSERT(st->IsReadOnly(), "NYI");
+    emitter.Emit("\n");
+    emitter.EmitAsmLabel(*funcSymbol, kAsmAlign);
+    emitter.Emit(st->GetName() + ":\n");
+    MIRAggConst *arrayConst = safe_cast<MIRAggConst>(st->GetKonst());
+    CHECK_FATAL(arrayConst != nullptr, "null ptr check");
+    PUIdx pIdx = cgFunc.GetMirModule().CurFunction()->GetPuidx();
+    const std::string &idx = strdup(std::to_string(pIdx).c_str());
+    for (size_t i = 0; i < arrayConst->GetConstVec().size(); i++) {
+      MIRLblConst *lblConst = safe_cast<MIRLblConst>(arrayConst->GetConstVecItem(i));
+      CHECK_FATAL(lblConst != nullptr, "null ptr check");
+      emitter.EmitAsmLabel(kAsmQuad);
+      (void)emitter.Emit(".L." + idx).Emit("__").Emit(lblConst->GetValue());
+      (void)emitter.Emit("\n");
+    }
+    (void)emitter.Emit("\n");
+  }
+}
+
+void X64Emitter::Run(FuncEmitInfo &funcEmitInfo) {
+  CGFunc &cgFunc = funcEmitInfo.GetCGFunc();
+  X64CGFunc &x64CGFunc = static_cast<X64CGFunc&>(cgFunc);
+  CG *currCG = cgFunc.GetCG();
+  const MIRSymbol *funcSymbol = cgFunc.GetFunction().GetFuncSymbol();
+  Emitter &emitter = *currCG->GetEmitter();
+  /* emit function header */
+  EmitFunctionHeader(funcEmitInfo);
+
+  /* emit instructions */
+  const std::string &funcName = std::string(cgFunc.GetShortFuncName().c_str());
+  FOR_ALL_BB(bb, &x64CGFunc) {
+    if (bb->IsUnreachable()) {
+      continue;
+    }
+    if (currCG->GenerateVerboseCG()) {
+      emitter.Emit("//    freq:").Emit(bb->GetFrequency()).Emit("\n");
+    }
+    /* emit bb headers */
+    if (bb->GetLabIdx() != MIRLabelTable::GetDummyLabel()) {
+      EmitBBHeaderLabel(funcEmitInfo, funcName, bb->GetLabIdx());
+    }
+
+    FOR_BB_INSNS(insn, bb) {
+      DumpTargetASM(emitter, *insn);
+    }
+  }
+
+  EmitJmpTable(emitter, cgFunc);
+
+  emitter.EmitAsmLabel(*funcSymbol, kAsmSize);
+}
+
+bool CgEmission::PhaseRun(maplebe::CGFunc &f) {
+  Emitter *emitter = f.GetCG()->GetEmitter();
+  CHECK_NULL_FATAL(emitter);
+  AsmFuncEmitInfo funcEmitInfo(f);
+  emitter->EmitLocalVariable(f);
+  static_cast<X64Emitter*>(emitter)->Run(funcEmitInfo);
+  return false;
+}
+MAPLE_TRANSFORM_PHASE_REGISTER(CgEmission, cgemit)
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_isa.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_isa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..770caf0000379b47b1fbc1f8793ccaecacdc1de8
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_isa.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "x64_isa.h"
+#include "insn.h"
+
+namespace maplebe {
+namespace x64 {
+MOperator FlipConditionOp(MOperator flippedOp) {
+  switch (flippedOp) {
+    case X64MOP_t::MOP_je_l:
+      return X64MOP_t::MOP_jne_l;
+    case X64MOP_t::MOP_jne_l:
+      return X64MOP_t::MOP_je_l;
+    case X64MOP_t::MOP_ja_l:
+      return X64MOP_t::MOP_jbe_l;
+    case X64MOP_t::MOP_jbe_l:
+      return X64MOP_t::MOP_ja_l;
+    case X64MOP_t::MOP_jae_l:
+      return X64MOP_t::MOP_jb_l;
+    case X64MOP_t::MOP_jb_l:
+      return X64MOP_t::MOP_jae_l;
+    case X64MOP_t::MOP_jg_l:
+      return X64MOP_t::MOP_jle_l;
+    case X64MOP_t::MOP_jle_l:
+      return X64MOP_t::MOP_jg_l;
+    case X64MOP_t::MOP_jge_l:
+      return X64MOP_t::MOP_jl_l;
+    case X64MOP_t::MOP_jl_l:
+      return X64MOP_t::MOP_jge_l;
+     default:
+      break;
+  }
+  return X64MOP_t::MOP_begin;
+}
+
+uint32 GetJumpTargetIdx(const Insn &insn) {
+  CHECK_FATAL(insn.IsCondBranch() || insn.IsUnCondBranch(), "Not a jump insn");
+  return kInsnFirstOpnd;
+}
+} /* namespace x64 */
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_live.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_live.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..994d33a5f3d940cfd5c5f0d2f784e68d3d73ddd1
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_live.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_live.h"
+#include "x64_cg.h"
+
+namespace maplebe {
+static const std::set<regno_t> intParamRegSet = {RDI, RSI, RDX, RCX, R8, R9};
+
+bool X64LiveAnalysis::CleanupBBIgnoreReg(regno_t reg) {
+  if (intParamRegSet.find(reg) != intParamRegSet.end()) {
+    return true;
+  }
+  return false;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_local_opt.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_local_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1fea1d297f38c7c365047a87e5044c47a6a74289
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_local_opt.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_local_opt.h"
+#include "x64_reaching.h"
+#include "operand.h"
+#include "x64_cg.h"
+
+namespace maplebe {
+void X64LocalOpt::DoLocalCopyProp() {
+  LocalOptimizeManager optManager(*cgFunc, *GetRDInfo());
+  optManager.Optimize<CopyRegProp>();
+  optManager.Optimize<X64RedundantDefRemove>();
+}
+
+bool CopyRegProp::CheckCondition(Insn &insn) {
+  MOperator mOp = insn.GetMachineOpcode();
+  if (mOp != MOP_movb_r_r && mOp != MOP_movw_r_r && mOp != MOP_movl_r_r && mOp != MOP_movq_r_r) {
+    return false;
+  }
+  ASSERT(insn.GetOperand(kInsnFirstOpnd).IsRegister(), "expects registers");
+  ASSERT(insn.GetOperand(kInsnSecondOpnd).IsRegister(), "expects registers");
+  auto &regUse = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &regDef = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  if (regUse.GetRegisterNumber() == regDef.GetRegisterNumber()) {
+    return false;
+  }
+  auto &liveOutRegSet = insn.GetBB()->GetLiveOutRegNO();
+  if (liveOutRegSet.find(regDef.GetRegisterNumber()) != liveOutRegSet.end()) {
+    return false;
+  }
+  return true;
+}
+
+void CopyRegProp::Optimize(BB &bb, Insn &insn) {
+  InsnSet useInsnSet;
+  Insn *nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr) {
+    return;
+  }
+  auto &regDef = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  reachingDef->FindRegUseBetweenInsn(regDef.GetRegisterNumber(), nextInsn, bb.GetLastInsn(), useInsnSet);
+  bool redefined = false;
+  auto &replaceOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  for (Insn *tInsn : useInsnSet) {
+    std::vector<Insn*> defInsnVec = reachingDef->FindRegDefBetweenInsn(replaceOpnd.GetRegisterNumber(),
+        &insn, tInsn, false, false);
+    if (defInsnVec.size() > 0) {
+      redefined = true;
+    }
+    if (redefined) {
+      break;
+    }
+    propagateOperand(*tInsn, regDef, replaceOpnd);
+  }
+  return;
+}
+
+bool CopyRegProp::propagateOperand(Insn &insn, RegOperand& oldOpnd, RegOperand& replaceOpnd) {
+  bool propagateSuccess = false;
+  uint32 opndNum = insn.GetOperandSize();
+  const InsnDesc *md = insn.GetDesc();
+  if (insn.IsShift() && oldOpnd.GetRegisterNumber() == x64::RCX) {
+    return false;
+  }
+  if (insn.GetMachineOpcode() == MOP_pseudo_ret_int) {
+    return false;
+  }
+  for (int i = 0; i < opndNum; i++) {
+    Operand &opnd = insn.GetOperand(i);
+    if (opnd.IsList()) {
+      /* list operands are used by call,
+       * which can not be propagated
+       */
+      continue;
+    }
+
+    auto *regProp = md->opndMD[i];
+    if (regProp->IsUse() && !regProp->IsDef() && opnd.IsRegister()) {
+      RegOperand &regOpnd = static_cast<RegOperand&>(opnd);
+      if (RegOperand::IsSameReg(regOpnd, oldOpnd)) {
+        insn.SetOperand(i, replaceOpnd);
+        propagateSuccess = true;
+      }
+    }
+  }
+  return propagateSuccess;
+}
+
+void X64RedundantDefRemove::Optimize(BB &bb, Insn &insn) {
+  const InsnDesc *md = insn.GetDesc();
+  RegOperand *regDef = nullptr;
+  uint32 opndNum = insn.GetOperandSize();
+  for (uint32 i = 0; i < opndNum; ++i) {
+    Operand &opnd = insn.GetOperand(i);
+    auto *opndDesc = md->opndMD[i];
+    if (opndDesc->IsRegDef()) {
+      regDef = static_cast<RegOperand*>(&opnd);
+    }
+  }
+  InsnSet useInsnSet;
+  Insn *nextInsn = insn.GetNextMachineInsn();
+  if (nextInsn == nullptr) {
+    return;
+  }
+  reachingDef->FindRegUseBetweenInsn(regDef->GetRegisterNumber(),
+      nextInsn, bb.GetLastInsn(), useInsnSet);
+  if (useInsnSet.size() == 0) {
+    bb.RemoveInsn(insn);
+    return;
+  }
+  return;
+}
+}
+
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_memlayout.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_memlayout.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2bd58bdc9a39a902bc5a84de6fe2f712d454bdfd
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_memlayout.cpp
@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_memlayout.h"
+#include "x64_cgfunc.h"
+#include "becommon.h"
+#include "mir_nodes.h"
+#include "x64_call_conv.h"
+#include "cg.h"
+
+namespace maplebe {
+using namespace maple;
+
+uint32 X64MemLayout::ComputeStackSpaceRequirementForCall(StmtNode &stmt,  int32 &aggCopySize, bool isIcall) {
+  /* instantiate a parm locator */
+  X64CallConvImpl parmLocator(be);
+  uint32 sizeOfArgsToStkPass = 0;
+  size_t i = 0;
+  /* An indirect call's first operand is the invocation target */
+  if (isIcall) {
+    ++i;
+  }
+
+  aggCopySize = 0;
+  for (uint32 anum = 0; i < stmt.NumOpnds(); ++i, ++anum) {
+    BaseNode *opnd = stmt.Opnd(i);
+    MIRType *ty = nullptr;
+    if (opnd->GetPrimType() != PTY_agg) {
+      ty = GlobalTables::GetTypeTable().GetTypeTable()[static_cast<uint32>(opnd->GetPrimType())];
+    } else {
+      Opcode opndOpcode = opnd->GetOpCode();
+      ASSERT(opndOpcode == OP_dread || opndOpcode == OP_iread, "opndOpcode should be OP_dread or OP_iread");
+      if (opndOpcode == OP_dread) {
+        DreadNode *dread = static_cast<DreadNode*>(opnd);
+        MIRSymbol *sym = be.GetMIRModule().CurFunction()->GetLocalOrGlobalSymbol(dread->GetStIdx());
+        ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx());
+        if (dread->GetFieldID() != 0) {
+          ASSERT(ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeClass ||
+                 ty->GetKind() == kTypeUnion, "expect struct or class");
+          if (ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeUnion) {
+            ty = static_cast<MIRStructType*>(ty)->GetFieldType(dread->GetFieldID());
+          } else {
+            ty = static_cast<MIRClassType*>(ty)->GetFieldType(dread->GetFieldID());
+          }
+        }
+      } else {
+        /* OP_iread */
+        IreadNode *iread = static_cast<IreadNode*>(opnd);
+        ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx());
+        ASSERT(ty->GetKind() == kTypePointer, "expect pointer");
+        ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<MIRPtrType*>(ty)->GetPointedTyIdx());
+        if (iread->GetFieldID() != 0) {
+          ASSERT(ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeClass ||
+                 ty->GetKind() == kTypeUnion, "expect struct or class");
+          if (ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeUnion) {
+            ty = static_cast<MIRStructType*>(ty)->GetFieldType(iread->GetFieldID());
+          } else {
+            ty = static_cast<MIRClassType*>(ty)->GetFieldType(iread->GetFieldID());
+          }
+        }
+      }
+    }
+    CCLocInfo ploc;
+    aggCopySize += parmLocator.LocateNextParm(*ty, ploc);
+    if (ploc.reg0 != 0) {
+      continue;  /* passed in register, so no effect on actual area */
+    }
+    sizeOfArgsToStkPass = RoundUp(ploc.memOffset + ploc.memSize, GetPointerSize());
+  }
+  return sizeOfArgsToStkPass;
+}
+
+void X64MemLayout::SetSizeAlignForTypeIdx(uint32 typeIdx, uint32 &size, uint32 &align) const {
+  align = be.GetTypeAlign(typeIdx);
+  size = static_cast<uint32>(be.GetTypeSize(typeIdx));
+}
+
+void X64MemLayout::LayoutVarargParams() {
+  uint32 nIntRegs = 0;
+  uint32 nFpRegs = 0;
+  X64CallConvImpl parmlocator(be);
+  CCLocInfo ploc;
+  MIRFunction *func = mirFunction;
+  if (be.GetMIRModule().IsCModule() && func->GetAttr(FUNCATTR_varargs)) {
+    for (uint32 i = 0; i < func->GetFormalCount(); i++) {
+      if (i == 0) {
+        if (be.HasFuncReturnType(*func)) {
+          TyIdx tidx = be.GetFuncReturnType(*func);
+          if (be.GetTypeSize(tidx.GetIdx()) <= k16ByteSize) {
+            continue;
+          }
+        }
+      }
+      MIRType *ty = func->GetNthParamType(i);
+      parmlocator.LocateNextParm(*ty, ploc, i == 0, func);
+      if (ploc.reg0 != kRinvalid) {
+        /* The range here is R0 to R15. However, not all registers in the range are parameter registers.
+         * If necessary later, you can add parameter register checks. */
+        if (ploc.reg0 >= R0 && ploc.reg0 <= R15) {
+          nIntRegs++;
+        } else if (ploc.reg0 >= V0 && ploc.reg0 <= V7) {
+          nFpRegs++;
+        }
+      }
+      if (ploc.reg1 != kRinvalid) {
+        if (ploc.reg1 >= R0 && ploc.reg1 <= R15) {
+          nIntRegs++;
+        } else if (ploc.reg1 >= V0 && ploc.reg1 <= V7) {
+          nFpRegs++;
+        }
+      }
+      if (ploc.reg2 != kRinvalid) {
+        if (ploc.reg2 >= R0 && ploc.reg2 <= R15) {
+          nIntRegs++;
+        } else if (ploc.reg2 >= V0 && ploc.reg2 <= V7) {
+          nFpRegs++;
+        }
+      }
+      if (ploc.reg3 != kRinvalid) {
+        if (ploc.reg3 >= R0 && ploc.reg3 <= R15) {
+          nIntRegs++;
+        } else if (ploc.reg2 >= V0 && ploc.reg2 <= V7) {
+          nFpRegs++;
+        }
+      }
+    }
+
+    SetSizeOfGRSaveArea((k6BitSize - nIntRegs) * GetPointerSize());
+    SetSizeOfVRSaveArea((k6BitSize - nFpRegs) * GetPointerSize() * k2ByteSize);
+  }
+}
+
+void X64MemLayout::LayoutFormalParams() {
+  X64CallConvImpl parmLocator(be);
+  CCLocInfo ploc;
+  for (size_t i = 0; i < mirFunction->GetFormalCount(); ++i) {
+    MIRSymbol *sym = mirFunction->GetFormal(i);
+    uint32 stIndex = sym->GetStIndex();
+    X64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<X64SymbolAlloc>();
+    SetSymAllocInfo(stIndex, *symLoc);
+    if (i == 0) {
+      // The function name here is not appropriate, it should be to determine
+      // whether the function returns a structure less than 16 bytes. At this
+      // time, the first parameter is a structure occupant, which has no
+      // practical significance.
+      if (be.HasFuncReturnType(*mirFunction)) {
+        symLoc->SetMemSegment(GetSegArgsRegPassed());
+        symLoc->SetOffset(GetSegArgsRegPassed().GetSize());
+        continue;
+      }
+    }
+
+    MIRType *ty = mirFunction->GetNthParamType(i);
+    uint32 ptyIdx = ty->GetTypeIndex();
+    parmLocator.LocateNextParm(*ty, ploc, i == 0, mirFunction);
+    uint32 size = 0;
+    uint32 align = 0;
+    if (ploc.reg0 != kRinvalid) {
+      if (!sym->IsPreg()) {
+        SetSizeAlignForTypeIdx(ptyIdx, size, align);
+        symLoc->SetMemSegment(GetSegArgsRegPassed());
+        if (ty->GetPrimType() == PTY_agg &&  be.GetTypeSize(ptyIdx) > k4ByteSize) {
+          /* struct param aligned on 8 byte boundary unless it is small enough */
+          align = GetPointerSize();
+        }
+        segArgsRegPassed.SetSize(static_cast<uint32>(RoundUp(segArgsRegPassed.GetSize(), align)));
+        symLoc->SetOffset(segArgsRegPassed.GetSize());
+        segArgsRegPassed.SetSize(segArgsRegPassed.GetSize() + size);
+      }
+    } else {
+      SetSizeAlignForTypeIdx(ptyIdx, size, align);
+      symLoc->SetMemSegment(GetSegArgsStkPassed());
+      segArgsStkPassed.SetSize(static_cast<uint32>(RoundUp(segArgsStkPassed.GetSize(), align)));
+      symLoc->SetOffset(segArgsStkPassed.GetSize());
+      segArgsStkPassed.SetSize(segArgsStkPassed.GetSize() + size);
+      segArgsStkPassed.SetSize(static_cast<uint32>(RoundUp(segArgsStkPassed.GetSize(), GetPointerSize())));
+    }
+  }
+}
+
+void X64MemLayout::LayoutLocalVariables() {
+  uint32 symTabSize = mirFunction->GetSymTab()->GetSymbolTableSize();
+  for (uint32 i = 0; i < symTabSize; ++i) {
+    MIRSymbol *sym = mirFunction->GetSymTab()->GetSymbolFromStIdx(i);
+    if (sym == nullptr || sym->GetStorageClass() != kScAuto || sym->IsDeleted()) {
+      continue;
+    }
+    uint32 stIndex = sym->GetStIndex();
+    TyIdx tyIdx = sym->GetTyIdx();
+    X64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<X64SymbolAlloc>();
+    SetSymAllocInfo(stIndex, *symLoc);
+    CHECK_FATAL(!symLoc->IsRegister(), "expect not register");
+
+    symLoc->SetMemSegment(segLocals);
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    uint32 align = be.GetTypeAlign(tyIdx);
+    if (ty->GetPrimType() == PTY_agg && align < k8BitSize) {
+      segLocals.SetSize(static_cast<uint32>(RoundUp(segLocals.GetSize(), k8BitSize)));
+    } else {
+      segLocals.SetSize(static_cast<uint32>(RoundUp(segLocals.GetSize(), align)));
+    }
+    symLoc->SetOffset(segLocals.GetSize());
+    segLocals.SetSize(segLocals.GetSize() + be.GetTypeSize(tyIdx));
+  }
+}
+
+void X64MemLayout::AssignSpillLocationsToPseudoRegisters() {
+  MIRPregTable *pregTab = cgFunc->GetFunction().GetPregTab();
+
+  /* BUG: n_regs include index 0 which is not a valid preg index. */
+  size_t nRegs = pregTab->Size();
+  spillLocTable.resize(nRegs);
+  for (size_t i = 1; i < nRegs; ++i) {
+    PrimType pType = pregTab->PregFromPregIdx(i)->GetPrimType();
+    X64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<X64SymbolAlloc>();
+    symLoc->SetMemSegment(segLocals);
+    segLocals.SetSize(RoundUp(segLocals.GetSize(), GetPrimTypeSize(pType)));
+    symLoc->SetOffset(segLocals.GetSize());
+    MIRType *mirTy = GlobalTables::GetTypeTable().GetTypeTable()[pType];
+    segLocals.SetSize(segLocals.GetSize() + be.GetTypeSize(mirTy->GetTypeIndex()));
+    spillLocTable[i] = symLoc;
+  }
+}
+
+SymbolAlloc *X64MemLayout::AssignLocationToSpillReg(regno_t vrNum) {
+  X64SymbolAlloc *symLoc = memAllocator->GetMemPool()->New<X64SymbolAlloc>();
+  symLoc->SetMemSegment(segSpillReg);
+  uint32 regSize = GetPointerSize();
+  segSpillReg.SetSize(RoundUp(segSpillReg.GetSize(), regSize));
+  symLoc->SetOffset(segSpillReg.GetSize());
+  segSpillReg.SetSize(segSpillReg.GetSize() + regSize);
+  SetSpillRegLocInfo(vrNum, *symLoc);
+  return symLoc;
+}
+
+void X64MemLayout::LayoutReturnRef(int32 &structCopySize, int32 &maxParmStackSize) {
+  segArgsToStkPass.SetSize(FindLargestActualArea(structCopySize));
+  maxParmStackSize = static_cast<int32>(segArgsToStkPass.GetSize());
+  if (Globals::GetInstance()->GetOptimLevel() == CGOptions::kLevel0) {
+    AssignSpillLocationsToPseudoRegisters();
+  }
+  segLocals.SetSize(static_cast<uint32>(RoundUp(segLocals.GetSize(), GetPointerSize())));
+}
+
+void X64MemLayout::LayoutStackFrame(int32 &structCopySize, int32 &maxParmStackSize) {
+  LayoutVarargParams();
+  LayoutFormalParams();
+
+  // Need to be aligned ?
+  segArgsRegPassed.SetSize(RoundUp(segArgsRegPassed.GetSize(), GetPointerSize()));
+  segArgsStkPassed.SetSize(RoundUp(segArgsStkPassed.GetSize(), GetPointerSize() + GetPointerSize()));
+
+  /* allocate the local variables in the stack */
+  LayoutLocalVariables();
+  LayoutReturnRef(structCopySize, maxParmStackSize);
+
+  // Need to adapt to the cc interface.
+  structCopySize = 0;
+  // Scenes with more than 6 parameters are not yet enabled.
+  maxParmStackSize = 0;
+
+  cgFunc->SetUseFP(cgFunc->UseFP() || static_cast<int32>(StackFrameSize()) > kMaxPimm32);
+}
+
+uint64 X64MemLayout::StackFrameSize() const {
+  uint64 total = Locals().GetSize() + segArgsRegPassed.GetSize() + segArgsToStkPass.GetSize() +
+      segGrSaveArea.GetSize() + segVrSaveArea.GetSize() + segSpillReg.GetSize();
+  return RoundUp(total, stackPtrAlignment);
+}
+
+int32 X64MemLayout::GetGRSaveAreaBaseLoc() {
+  int32 total = static_cast<int32>(RoundUp(GetSizeOfGRSaveArea(), stackPtrAlignment));
+  return total;
+}
+
+int32 X64MemLayout::GetVRSaveAreaBaseLoc() {
+  int32 total = static_cast<int32>(RoundUp(GetSizeOfGRSaveArea(), stackPtrAlignment) +
+      RoundUp(GetSizeOfVRSaveArea(), stackPtrAlignment));
+  return total;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_optimize_common.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_optimize_common.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..125369f0bbee242043f82c910f6cdffb7023ac10
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_optimize_common.cpp
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_optimize_common.h"
+#include "x64_cgfunc.h"
+#include "cgbb.h"
+#include "cg.h"
+
+namespace maplebe {
+void X64InsnVisitor::ModifyJumpTarget(Operand &targetOperand, BB &bb) {
+  Insn *jmpInsn = bb.GetLastInsn();
+  if (bb.GetKind() == BB::kBBIgoto) {
+    CHECK_FATAL(targetOperand.IsLabel(), "NIY");
+    CHECK_FATAL(false, "NIY");
+  }
+  jmpInsn->SetOperand(x64::GetJumpTargetIdx(*jmpInsn), targetOperand);
+}
+
+void X64InsnVisitor::ModifyJumpTarget(LabelIdx targetLabel, BB &bb) {
+  std::string lableName = ".L." + std::to_string(GetCGFunc()->GetUniqueID()) +
+      "__" + std::to_string(targetLabel);
+  ModifyJumpTarget(GetCGFunc()->GetOpndBuilder()->CreateLabel(lableName.c_str(), targetLabel), bb);
+}
+
+void X64InsnVisitor::ModifyJumpTarget(BB &newTarget, BB &bb) {
+  ModifyJumpTarget(newTarget.GetLastInsn()->GetOperand(
+      x64::GetJumpTargetIdx(*newTarget.GetLastInsn())), bb);
+}
+
+Insn *X64InsnVisitor::CloneInsn(Insn &originalInsn) {
+  MemPool *memPool = const_cast<MemPool*>(CG::GetCurCGFunc()->GetMemoryPool());
+  if (originalInsn.IsTargetInsn()) {
+    if (!originalInsn.IsVectorOp()) {
+      return memPool->Clone<Insn>(originalInsn);
+    } else {
+      auto *insn = memPool->Clone<VectorInsn>(*static_cast<VectorInsn*>(&originalInsn));
+      insn->SetRegSpecList(static_cast<VectorInsn&>(originalInsn).GetRegSpecList());
+      return insn;
+    }
+  } else if (originalInsn.IsCfiInsn()) {
+    return memPool->Clone<cfi::CfiInsn>(*static_cast<cfi::CfiInsn*>(&originalInsn));
+  } else if (originalInsn.IsDbgInsn()) {
+    return memPool->Clone<mpldbg::DbgInsn>(*static_cast<mpldbg::DbgInsn*>(&originalInsn));
+  }
+  if (originalInsn.IsComment()) {
+    return memPool->Clone<Insn>(originalInsn);
+  }
+  CHECK_FATAL(false, "Cannot clone");
+  return nullptr;
+}
+
+/*
+ * Precondition: The given insn is a jump instruction.
+ * Get the jump target label operand index from the given instruction.
+ * Note: MOP_jmp_m, MOP_jmp_r is a jump instruction, but the target is unknown at compile time.
+ */
+LabelIdx X64InsnVisitor::GetJumpLabel(const Insn &insn) const {
+  uint32 operandIdx = x64::GetJumpTargetIdx(insn);
+  if (insn.GetOperand(operandIdx).IsLabelOpnd()) {
+    return static_cast<LabelOperand&>(insn.GetOperand(operandIdx)).GetLabelIndex();
+  }
+  ASSERT(false, "Operand is not label");
+  return 0;
+}
+
+bool X64InsnVisitor::IsCompareInsn(const Insn &insn) const {
+  switch (insn.GetMachineOpcode()) {
+      case x64::MOP_cmpb_r_r:
+      case x64::MOP_cmpb_m_r:
+      case x64::MOP_cmpb_i_r:
+      case x64::MOP_cmpb_r_m:
+      case x64::MOP_cmpb_i_m:
+      case x64::MOP_cmpw_r_r:
+      case x64::MOP_cmpw_m_r:
+      case x64::MOP_cmpw_i_r:
+      case x64::MOP_cmpw_r_m:
+      case x64::MOP_cmpw_i_m:
+      case x64::MOP_cmpl_r_r:
+      case x64::MOP_cmpl_m_r:
+      case x64::MOP_cmpl_i_r:
+      case x64::MOP_cmpl_r_m:
+      case x64::MOP_cmpl_i_m:
+      case x64::MOP_cmpq_r_r:
+      case x64::MOP_cmpq_m_r:
+      case x64::MOP_cmpq_i_r:
+      case x64::MOP_cmpq_r_m:
+      case x64::MOP_cmpq_i_m:
+      case x64::MOP_testq_r_r:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool X64InsnVisitor::IsCompareAndBranchInsn(const Insn &insn) const {
+  return false;
+}
+
+bool X64InsnVisitor::IsAddOrSubInsn(const Insn &insn) const {
+  switch (insn.GetMachineOpcode()) {
+    case x64::MOP_addb_r_r:
+    case x64::MOP_addw_r_r:
+    case x64::MOP_addl_r_r:
+    case x64::MOP_addq_r_r:
+    case x64::MOP_addb_m_r:
+    case x64::MOP_addw_m_r:
+    case x64::MOP_addl_m_r:
+    case x64::MOP_addq_m_r:
+    case x64::MOP_addb_i_r:
+    case x64::MOP_addw_i_r:
+    case x64::MOP_addl_i_r:
+    case x64::MOP_addq_i_r:
+    case x64::MOP_addb_r_m:
+    case x64::MOP_addw_r_m:
+    case x64::MOP_addl_r_m:
+    case x64::MOP_addq_r_m:
+    case x64::MOP_addb_i_m:
+    case x64::MOP_addw_i_m:
+    case x64::MOP_addl_i_m:
+    case x64::MOP_addq_i_m:
+    case x64::MOP_subb_r_r:
+    case x64::MOP_subw_r_r:
+    case x64::MOP_subl_r_r:
+    case x64::MOP_subq_r_r:
+    case x64::MOP_subb_m_r:
+    case x64::MOP_subw_m_r:
+    case x64::MOP_subl_m_r:
+    case x64::MOP_subq_m_r:
+    case x64::MOP_subb_i_r:
+    case x64::MOP_subw_i_r:
+    case x64::MOP_subl_i_r:
+    case x64::MOP_subq_i_r:
+    case x64::MOP_subb_r_m:
+    case x64::MOP_subw_r_m:
+    case x64::MOP_subl_r_m:
+    case x64::MOP_subq_r_m:
+    case x64::MOP_subb_i_m:
+    case x64::MOP_subw_i_m:
+    case x64::MOP_subl_i_m:
+    case x64::MOP_subq_i_m:
+      return true;
+    default:
+      return false;
+  }
+}
+
+RegOperand *X64InsnVisitor::CreateVregFromReg(const RegOperand &pReg) {
+  return &GetCGFunc()->GetOpndBuilder()->CreateVReg(pReg.GetRegisterNumber(),
+      pReg.GetSize(), pReg.GetRegisterType());
+}
+
+void X64InsnVisitor::ReTargetSuccBB(BB &bb, LabelIdx newTarget) const {
+  ASSERT(false, "not implement in X86_64");
+  (void)bb;
+  (void)newTarget;
+  return;
+}
+void X64InsnVisitor::FlipIfBB(BB &bb, LabelIdx ftLabel) const {
+  ASSERT(false, "not implement in X86_64");
+  (void)bb;
+  (void)ftLabel;
+  return;
+}
+BB *X64InsnVisitor::CreateGotoBBAfterCondBB(BB &bb, BB &fallthru, bool isTargetFallthru) const {
+  ASSERT(false, "not implement in X86_64");
+  (void)bb;
+  (void)fallthru;
+  (void)isTargetFallthru;
+  return nullptr;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_peep.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_peep.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..08356b89bdc1932b0c49dc1176026053011468f5
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_peep.cpp
@@ -0,0 +1,75 @@
+ /*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_peep.h"
+#include "cg.h"
+#include "mpl_logging.h"
+#include "common_utils.h"
+#include "cg_option.h"
+#include "x64_cg.h"
+
+namespace maplebe {
+void X64CGPeepHole::Run() {
+  FOR_ALL_BB(bb, cgFunc) {
+    FOR_BB_INSNS_SAFE(insn, bb, nextInsn) {
+      if (!insn->IsMachineInstruction()) {
+        continue;
+      }
+      if (ssaInfo == nullptr) {
+        DoNormalOptimize(*bb, *insn);
+      }
+    }
+  }
+}
+
+bool X64CGPeepHole::DoSSAOptimize(BB &bb, Insn &insn) {
+  CHECK_FATAL(false, "x64 does not support ssa optimize");
+  return false;
+}
+
+bool RemoveMovingtoSameRegPattern::CheckCondition(Insn &insn) {
+  ASSERT(insn.GetOperand(kInsnFirstOpnd).IsRegister(), "expects registers");
+  ASSERT(insn.GetOperand(kInsnSecondOpnd).IsRegister(), "expects registers");
+  auto &reg1 = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  auto &reg2 = static_cast<RegOperand&>(insn.GetOperand(kInsnSecondOpnd));
+  /* remove mov x0,x0 when it cast i32 to i64 */
+  if ((reg1.GetRegisterNumber() == reg2.GetRegisterNumber()) && (reg1.GetSize() >= reg2.GetSize())) {
+    return true;
+  }
+  return false;
+}
+
+void RemoveMovingtoSameRegPattern::Run(BB &bb, Insn &insn) {
+  /* remove mov x0,x0 when it cast i32 to i64 */
+  if (CheckCondition(insn)) {
+    bb.RemoveInsn(insn);
+  }
+}
+
+void X64CGPeepHole::DoNormalOptimize(BB &bb, Insn &insn) {
+  MOperator thisMop = insn.GetMachineOpcode();
+  manager = peepMemPool->New<PeepOptimizeManager>(*cgFunc, bb, insn);
+  switch (thisMop) {
+    case MOP_movb_r_r:
+    case MOP_movw_r_r:
+    case MOP_movl_r_r:
+    case MOP_movq_r_r: {
+      manager->NormalPatternOpt<RemoveMovingtoSameRegPattern>(true);
+      break;
+    }
+    default:
+      break;
+  }
+  }
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_proepilog.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_proepilog.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d541dcf3978d95a6a6764d7aaf45ebfa7814ad1c
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_proepilog.cpp
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_proepilog.h"
+#include "x64_memlayout.h"
+#include "x64_isa.h"
+#include "isel.h"
+#include "x64_cg.h"
+
+namespace maplebe {
+using namespace maple;
+
+bool X64GenProEpilog::NeedProEpilog() {
+  return true;
+}
+void X64GenProEpilog::GenerateCalleeSavedRegs(bool isPush) {
+  X64CGFunc &x64cgFunc = static_cast<X64CGFunc&>(cgFunc);
+  const auto &calleeSavedRegs = x64cgFunc.GetCalleeSavedRegs();
+  if (calleeSavedRegs.empty()) {
+    return;
+  }
+  /* CalleeSave(0) = -(FrameSize + CalleeReg - ArgsStk) */
+  X64MemLayout *memLayout = static_cast<X64MemLayout*>(cgFunc.GetMemlayout());
+  int64 offset = -(memLayout->StackFrameSize() + static_cast<X64CGFunc&>(cgFunc).SizeOfCalleeSaved() -
+      memLayout->SizeOfArgsToStackPass());
+  RegOperand &baseReg = cgFunc.GetOpndBuilder()->CreatePReg(x64::RBP, k64BitSize, kRegTyInt);
+  for (const auto &reg : calleeSavedRegs) {
+    RegType regType = IsGPRegister(reg) ? kRegTyInt : kRegTyFloat;
+    uint32 regByteSize = IsGPRegister(reg) ? kIntregBytelen : kFpregBytelen;
+    uint32 regSize = regByteSize * kBitsPerByte;
+    ASSERT((regSize == k32BitSize || regSize == k64BitSize), "only supported 32/64-bits");
+    RegOperand &calleeReg = cgFunc.GetOpndBuilder()->CreatePReg(reg, regSize, regType);
+    MemOperand &memOpnd = cgFunc.GetOpndBuilder()->CreateMem(baseReg, offset, regSize);
+    if (isPush) {
+      GeneratePushCalleeSavedRegs(calleeReg, memOpnd, regSize);
+    } else {
+      GeneratePopCalleeSavedRegs(calleeReg, memOpnd, regSize);
+    }
+    offset += regByteSize;
+  }
+}
+
+void X64GenProEpilog::GeneratePushCalleeSavedRegs(RegOperand &regOpnd, MemOperand &memOpnd, uint32 regSize) {
+  MOperator mMovrmOp = (regSize == k32BitSize) ? x64::MOP_movl_r_m : x64::MOP_movq_r_m;
+  Insn &copyInsn = cgFunc.GetInsnBuilder()->BuildInsn(mMovrmOp, X64CG::kMd[mMovrmOp]);
+  copyInsn.AddOpndChain(regOpnd).AddOpndChain(memOpnd);
+  cgFunc.GetCurBB()->AppendInsn(copyInsn);
+}
+
+void X64GenProEpilog::GeneratePopCalleeSavedRegs(RegOperand &regOpnd, MemOperand &memOpnd, uint32 regSize) {
+  MOperator mMovrmOp = (regSize == k32BitSize) ? x64::MOP_movl_m_r : x64::MOP_movq_m_r;
+  Insn &copyInsn = cgFunc.GetInsnBuilder()->BuildInsn(mMovrmOp, X64CG::kMd[mMovrmOp]);
+  copyInsn.AddOpndChain(memOpnd).AddOpndChain(regOpnd);
+  cgFunc.GetCurBB()->AppendInsn(copyInsn);
+}
+
+void X64GenProEpilog::GeneratePushUnnamedVarargRegs() {
+  if (cgFunc.GetMirModule().IsCModule() && cgFunc.GetFunction().GetAttr(FUNCATTR_varargs)) {
+    X64MemLayout *memlayout = static_cast<X64MemLayout*>(cgFunc.GetMemlayout());
+    uint8 size = GetPointerSize();
+    uint32 dataSizeBits = size * kBitsPerByte;
+    int64 offset = -memlayout->GetGRSaveAreaBaseLoc();
+    if (memlayout->GetSizeOfGRSaveArea() % kX64StackPtrAlignment) {
+      offset += size;  /* End of area should be aligned. Hole between VR and GR area */
+    }
+    uint32 start_regno = k6BitSize - (memlayout->GetSizeOfGRSaveArea() / size);
+    ASSERT(start_regno <= k6BitSize, "Incorrect starting GR regno for GR Save Area");
+
+    /* Parameter registers in x86: %rdi, %rsi, %rdx, %rcx, %r8, %r9 */
+    std::vector<X64reg> paramRegs = {RDI, RSI, RDX, RCX, R8, R9};
+    for (uint32 i = start_regno; i < paramRegs.size(); i++) {
+      MOperator mMovrmOp = x64::MOP_movq_r_m;
+      RegOperand &opndFpReg = cgFunc.GetOpndBuilder()->CreatePReg(x64::RBP, k64BitSize, kRegTyInt);
+      MemOperand &memOpnd = cgFunc.GetOpndBuilder()->CreateMem(opndFpReg, offset, dataSizeBits);
+      Insn &copyInsn = cgFunc.GetInsnBuilder()->BuildInsn(mMovrmOp, X64CG::kMd[mMovrmOp]);
+      RegOperand &regOpnd = cgFunc.GetOpndBuilder()->CreatePReg(paramRegs[i], k64BitSize, kRegTyInt);
+      copyInsn.AddOpndChain(regOpnd).AddOpndChain(memOpnd);
+      cgFunc.GetCurBB()->AppendInsn(copyInsn);
+      offset += size;
+    }
+
+    if (!CGOptions::UseGeneralRegOnly()) {
+      offset = -memlayout->GetVRSaveAreaBaseLoc();
+      start_regno = k6BitSize - (memlayout->GetSizeOfVRSaveArea() / (size * k2BitSize));
+      ASSERT(start_regno <= k6BitSize, "Incorrect starting GR regno for VR Save Area");
+      for (uint32 i = start_regno + static_cast<uint32>(V0); i < static_cast<uint32>(V6); i++) {
+        MOperator mMovrmOp = x64::MOP_movq_r_m;
+        RegOperand &opndFpReg = cgFunc.GetOpndBuilder()->CreatePReg(x64::RBP, k64BitSize, kRegTyInt);
+        MemOperand &memOpnd = cgFunc.GetOpndBuilder()->CreateMem(opndFpReg, offset, dataSizeBits);
+        Insn &copyInsn = cgFunc.GetInsnBuilder()->BuildInsn(mMovrmOp, X64CG::kMd[mMovrmOp]);
+        RegOperand &regOpnd = cgFunc.GetOpndBuilder()->CreatePReg(static_cast<X64reg>(i), k64BitSize, kRegTyInt);
+        copyInsn.AddOpndChain(regOpnd).AddOpndChain(memOpnd);
+
+        cgFunc.GetCurBB()->AppendInsn(copyInsn);
+        offset += (size * k2BitSize);
+      }
+    }
+  }
+}
+
+void X64GenProEpilog::GenerateProlog(BB &bb) {
+  auto &x64CGFunc = static_cast<X64CGFunc&>(cgFunc);
+  BB *formerCurBB = cgFunc.GetCurBB();
+  x64CGFunc.GetDummyBB()->ClearInsns();
+  x64CGFunc.GetDummyBB()->SetIsProEpilog(true);
+  cgFunc.SetCurBB(*x64CGFunc.GetDummyBB());
+
+  /* push %rbp */
+  MOperator mPushrOp = x64::MOP_pushq_r;
+  Insn &pushInsn = cgFunc.GetInsnBuilder()->BuildInsn(mPushrOp, X64CG::kMd[mPushrOp]);
+  RegOperand &opndFpReg = cgFunc.GetOpndBuilder()->CreatePReg(x64::RBP, k64BitSize, kRegTyInt);
+  pushInsn.AddOpndChain(opndFpReg);
+  cgFunc.GetCurBB()->AppendInsn(pushInsn);
+
+  /* mov %rsp, %rbp */
+  MOperator mMovrrOp = x64::MOP_movq_r_r;
+  Insn &copyInsn = cgFunc.GetInsnBuilder()->BuildInsn(mMovrrOp, X64CG::kMd[mMovrrOp]);
+  RegOperand &opndSpReg = cgFunc.GetOpndBuilder()->CreatePReg(x64::RSP, k64BitSize, kRegTyInt);
+  copyInsn.AddOpndChain(opndSpReg).AddOpndChain(opndFpReg);
+  cgFunc.GetCurBB()->AppendInsn(copyInsn);
+
+  /* sub $framesize, %rsp */
+  if (cgFunc.GetFunction().HasCall() || cgFunc.HasVLAOrAlloca()) {
+    MOperator mSubirOp = x64::MOP_subq_i_r;
+    Insn &subInsn = cgFunc.GetInsnBuilder()->BuildInsn(mSubirOp, X64CG::kMd[mSubirOp]);
+    auto *memLayout = static_cast<X64MemLayout*>(cgFunc.GetMemlayout());
+    int64 trueFrameSize = memLayout->StackFrameSize() +
+        static_cast<X64CGFunc&>(cgFunc).SizeOfCalleeSaved();
+    ImmOperand &opndImm = cgFunc.GetOpndBuilder()->CreateImm(k32BitSize, trueFrameSize);
+    subInsn.AddOpndChain(opndImm).AddOpndChain(opndSpReg);
+    cgFunc.GetCurBB()->AppendInsn(subInsn);
+  }
+
+  GenerateCalleeSavedRegs(true);
+  GeneratePushUnnamedVarargRegs();
+
+  bb.InsertAtBeginning(*x64CGFunc.GetDummyBB());
+  x64CGFunc.GetDummyBB()->SetIsProEpilog(false);
+  cgFunc.SetCurBB(*formerCurBB);
+}
+
+void X64GenProEpilog::GenerateEpilog(BB &bb) {
+  auto &x64CGFunc = static_cast<X64CGFunc&>(cgFunc);
+  BB *formerCurBB = cgFunc.GetCurBB();
+  x64CGFunc.GetDummyBB()->ClearInsns();
+  x64CGFunc.GetDummyBB()->SetIsProEpilog(true);
+  cgFunc.SetCurBB(*x64CGFunc.GetDummyBB());
+
+  GenerateCalleeSavedRegs(false);
+
+  if (cgFunc.GetFunction().HasCall() || cgFunc.HasVLAOrAlloca()) {
+    /*
+     * leave  equal with
+     * mov rsp rbp
+     * pop rbp
+     */
+    MOperator mLeaveOp = x64::MOP_leaveq;
+    Insn &popInsn = cgFunc.GetInsnBuilder()->BuildInsn(mLeaveOp, X64CG::kMd[mLeaveOp]);
+    cgFunc.GetCurBB()->AppendInsn(popInsn);
+  } else {
+    /* pop %rbp */
+    MOperator mPopOp = x64::MOP_popq_r;
+    Insn &pushInsn = cgFunc.GetInsnBuilder()->BuildInsn(mPopOp, X64CG::kMd[mPopOp]);
+    RegOperand &opndFpReg = cgFunc.GetOpndBuilder()->CreatePReg(x64::RBP, k64BitSize, kRegTyInt);
+    pushInsn.AddOpndChain(opndFpReg);
+    cgFunc.GetCurBB()->AppendInsn(pushInsn);
+  }
+  /* ret */
+  MOperator mRetOp = x64::MOP_retq;
+  Insn &retInsn = cgFunc.GetInsnBuilder()->BuildInsn(mRetOp, X64CG::kMd[mRetOp]);
+  cgFunc.GetCurBB()->AppendInsn(retInsn);
+
+  bb.AppendBBInsns(*x64CGFunc.GetDummyBB());
+  x64CGFunc.GetDummyBB()->SetIsProEpilog(false);
+  cgFunc.SetCurBB(*formerCurBB);
+}
+
+void X64GenProEpilog::Run() {
+  GenerateProlog(*(cgFunc.GetFirstBB()));
+  GenerateEpilog(*(cgFunc.GetLastBB()));
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_reaching.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_reaching.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba9d9dbb9793f1357d10517a76db6daab5749cf6
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_reaching.cpp
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_reaching.h"
+#include "x64_cg.h"
+#include "insn.h"
+#include "isa.h"
+namespace maplebe {
+/* find insn using register between startInsn and endInsn
+* startInsn and endInsn must be in the same BB.
+*/
+bool X64ReachingDefinition::FindRegUseBetweenInsn(uint32 regNO, Insn *startInsn,
+    Insn *endInsn, InsnSet &regUseInsnSet) const {
+  ASSERT(startInsn->GetBB() == endInsn->GetBB(), "two insns must be in a same BB");
+  bool findFinish = false;
+  if (startInsn == nullptr || endInsn == nullptr) {
+    return findFinish;
+  }
+  for (Insn *insn = startInsn; insn != nullptr && insn != endInsn->GetNext(); insn = insn->GetNext()) {
+    if (!insn->IsMachineInstruction()) {
+      continue;
+    }
+    /* if insn is call and regNO is caller-saved register, then regNO will not be used later */
+    if (insn->IsCall() && IsRegKilledByCallInsn(*insn, regNO)) {
+      findFinish = true;
+    }
+
+    if (IsDiv(*insn) && regNO == x64::RAX) {
+      /* div insn use rax implicitly */
+      findFinish = true;
+    }
+
+    const InsnDesc *md = insn->GetDesc();
+    uint32 opndNum = insn->GetOperandSize();
+    for (uint32 i = 0; i < opndNum; ++i) {
+      Operand &opnd = insn->GetOperand(i);
+      /* handle def or def use */
+      auto *regProp = md->opndMD[i];
+      if (regProp->IsDef() && opnd.IsRegister() &&
+          (static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO)) {
+        findFinish = true;
+      }
+
+      if (opnd.IsList()) {
+        auto &listOpnd = static_cast<ListOperand&>(opnd);
+        for (auto listElem : listOpnd.GetOperands()) {
+          RegOperand *regOpnd = static_cast<RegOperand*>(listElem);
+          ASSERT(regOpnd != nullptr, "parameter operand must be RegOperand");
+          if (regNO == regOpnd->GetRegisterNumber()) {
+            (void)regUseInsnSet.insert(insn);
+          }
+        }
+        continue;
+      }
+      if (!regProp->IsUse() && !opnd.IsMemoryAccessOperand()) {
+        continue;
+      }
+
+      /* handle use */
+      if (opnd.IsMemoryAccessOperand()) {
+        auto &memOpnd = static_cast<MemOperand&>(opnd);
+        RegOperand *base = memOpnd.GetBaseRegister();
+        RegOperand *index = memOpnd.GetIndexRegister();
+        if ((base != nullptr && base->GetRegisterNumber() == regNO) ||
+            (index != nullptr && index->GetRegisterNumber() == regNO)) {
+          (void)regUseInsnSet.insert(insn);
+        }
+      } else if (opnd.IsConditionCode()) {
+        Operand &rflagOpnd = cgFunc->GetOrCreateRflag();
+        RegOperand &rflagReg = static_cast<RegOperand&>(rflagOpnd);
+        if (rflagReg.GetRegisterNumber() == regNO) {
+          (void)regUseInsnSet.insert(insn);
+        }
+      } else if (opnd.IsRegister() && (static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO)) {
+        (void)regUseInsnSet.insert(insn);
+      }
+    }
+    if (findFinish) {
+      break;
+    }
+  }
+  return findFinish;
+}
+
+std::vector<Insn*> X64ReachingDefinition::FindRegDefBetweenInsnGlobal(uint32 regNO,
+    Insn *startInsn, Insn *endInsn) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return {};
+}
+
+std::vector<Insn*> X64ReachingDefinition::FindMemDefBetweenInsn(uint32 offset,
+    const Insn *startInsn, Insn *endInsn) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return {};
+}
+
+bool X64ReachingDefinition::FindRegUseBetweenInsnGlobal(uint32 regNO, Insn *startInsn, Insn *endInsn, BB* movBB) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return false;
+}
+
+bool X64ReachingDefinition::FindMemUseBetweenInsn(uint32 offset, Insn *startInsn, const Insn *endInsn,
+                                                  InsnSet &useInsnSet) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return false;
+}
+
+bool X64ReachingDefinition::HasRegDefBetweenInsnGlobal(uint32 regNO, Insn &startInsn, Insn &endInsn) {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return false;
+}
+
+bool X64ReachingDefinition::DFSFindRegDefBetweenBB(const BB &startBB, const BB &endBB, uint32 regNO,
+                                                   std::vector<VisitStatus> &visitedBB) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return false;
+}
+
+InsnSet X64ReachingDefinition::FindDefForRegOpnd(Insn &insn, uint32 indexOrRegNO, bool isRegNO) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return {};
+}
+
+InsnSet X64ReachingDefinition::FindDefForMemOpnd(Insn &insn, uint32 indexOrOffset, bool isOffset) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return {};
+}
+
+InsnSet X64ReachingDefinition::FindUseForMemOpnd(Insn &insn, uint8 index, bool secondMem) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return {};
+}
+
+bool X64ReachingDefinition::FindRegUsingBetweenInsn(uint32 regNO, Insn *startInsn, const Insn *endInsn) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return false;
+}
+
+void X64ReachingDefinition::InitStartGen() {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+void X64ReachingDefinition::InitEhDefine(BB &bb) {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+void X64ReachingDefinition::InitGenUse(BB &bb, bool firstTime) {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+void X64ReachingDefinition::GenAllAsmDefRegs(BB &bb, Insn &insn, uint32 index) {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+void X64ReachingDefinition::GenAllAsmUseRegs(BB &bb, Insn &insn, uint32 index) {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+void X64ReachingDefinition::GenAllCallerSavedRegs(BB &bb, Insn &insn) {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+bool X64ReachingDefinition::KilledByCallBetweenInsnInSameBB(const Insn &startInsn,
+    const Insn &endInsn, regno_t regNO) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return false;
+}
+
+void X64ReachingDefinition::AddRetPseudoInsn(BB &bb) {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+bool X64ReachingDefinition::IsCallerSavedReg(uint32 regNO) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return false;
+}
+
+void X64ReachingDefinition::FindRegDefInBB(uint32 regNO, BB &bb, InsnSet &defInsnSet) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+void X64ReachingDefinition::FindMemDefInBB(uint32 offset, BB &bb, InsnSet &defInsnSet) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+void X64ReachingDefinition::DFSFindDefForRegOpnd(const BB &startBB, uint32 regNO, std::vector<VisitStatus> &visitedBB,
+                                                 InsnSet &defInsnSet) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+void X64ReachingDefinition::DFSFindDefForMemOpnd(const BB &startBB, uint32 offset, std::vector<VisitStatus> &visitedBB,
+                                                 InsnSet &defInsnSet) const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+}
+
+int32 X64ReachingDefinition::GetStackSize() const {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return 0;
+};
+
+void X64ReachingDefinition::AddRetPseudoInsns() {
+  CHECK_FATAL(false, "x64_reaching analysis not implemented yet!");
+  return;
+};
+
+/* reg killed killed by call insn */
+bool X64ReachingDefinition::IsRegKilledByCallInsn(const Insn &insn, regno_t regNO) const {
+  return x64::IsCallerSaveReg((X64reg)regNO);
+}
+
+bool X64ReachingDefinition::IsDiv(const Insn &insn) const {
+  MOperator mOp = insn.GetMachineOpcode();
+  return (MOP_idivw_r <= mOp && mOp <= MOP_divq_m);
+}
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_reg_info.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_reg_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..63a3460430f5067208df4fd0734a243fc5348901
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_reg_info.cpp
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "x64_reg_info.h"
+#include "x64_cgfunc.h"
+#include "x64_cg.h"
+
+namespace maplebe {
+using namespace maple;
+using namespace x64;
+void X64RegInfo::Init() {
+  for (regno_t regNO = kRinvalid; regNO < kMaxRegNum; ++regNO) {
+    /* when yieldpoint is enabled, the RYP(R12) can not be used. */
+    if (IsYieldPointReg(static_cast<X64reg>(regNO))) {
+      continue;
+    }
+    if (!x64::IsAvailableReg(static_cast<X64reg>(regNO))) {
+      continue;
+    }
+    if (x64::IsGPRegister(static_cast<X64reg>(regNO))) {
+      AddToIntRegs(regNO);
+    } else {
+      AddToFpRegs(regNO);
+    }
+    AddToAllRegs(regNO);
+  }
+  return;
+}
+
+void X64RegInfo::SaveCalleeSavedReg(MapleSet<regno_t> savedRegs) {
+  X64CGFunc *x64CGFunc = static_cast<X64CGFunc*>(GetCurrFunction());
+  for (auto reg: savedRegs) {
+    x64CGFunc->AddtoCalleeSaved(static_cast<X64reg>(reg));
+  }
+}
+
+bool X64RegInfo::IsSpecialReg(regno_t regno) const {
+  X64reg reg = static_cast<X64reg>(regno);
+  if ((reg == RBP) || (reg == RSP)) {
+    return true;
+  }
+
+  /* when yieldpoint is enabled, the dedicated register(RYP) can not be allocated. */
+  if (IsYieldPointReg(reg)) {
+    return true;
+  }
+  return false;
+}
+
+bool X64RegInfo::IsCalleeSavedReg(regno_t regno) const {
+  return x64::IsCalleeSavedReg(static_cast<X64reg>(regno));
+}
+
+bool X64RegInfo::IsYieldPointReg(regno_t regno) const {
+  return false;
+}
+
+bool X64RegInfo::IsUnconcernedReg(regno_t regNO) const {
+  /* when yieldpoint is enabled, the RYP(R12) can not be used. */
+  if (IsYieldPointReg(static_cast<X64reg>(regNO))) {
+    return true;
+  }
+  return false;
+}
+
+bool X64RegInfo::IsUnconcernedReg(const RegOperand &regOpnd) const {
+  RegType regType = regOpnd.GetRegisterType();
+  if (regType == kRegTyCc || regType == kRegTyVary) {
+    return true;
+  }
+  uint32 regNO = regOpnd.GetRegisterNumber();
+  return IsUnconcernedReg(regNO);
+}
+
+void X64RegInfo::Fini() {
+}
+
+RegOperand *X64RegInfo::GetOrCreatePhyRegOperand(regno_t regNO, uint32 size, RegType kind, uint32 flag) {
+  return &(GetCurrFunction()->GetOpndBuilder()->CreatePReg(regNO, size, kind));
+}
+
+Insn *X64RegInfo::BuildStrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) {
+  X64MOP_t mOp = x64::MOP_begin;
+  switch (regSize) {
+    case k8BitSize:
+      mOp = x64::MOP_movb_r_m;
+      break;
+    case k16BitSize:
+      mOp = x64::MOP_movw_r_m;
+      break;
+    case k32BitSize:
+      mOp = x64::MOP_movl_r_m;
+      break;
+    case k64BitSize:
+      mOp = x64::MOP_movq_r_m;
+      break;
+    default:
+      CHECK_FATAL(false, "NIY");
+      break;
+  }
+  Insn &insn = GetCurrFunction()->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  insn.AddOpndChain(phyOpnd).AddOpndChain(memOpnd);
+  return &insn;
+}
+
+Insn *X64RegInfo::BuildLdrInsn(uint32 regSize, PrimType stype, RegOperand &phyOpnd, MemOperand &memOpnd) {
+  X64MOP_t mOp = x64::MOP_begin;
+  switch (regSize) {
+    case k8BitSize:
+      mOp = x64::MOP_movb_m_r;
+      break;
+    case k16BitSize:
+      mOp = x64::MOP_movw_m_r;
+      break;
+    case k32BitSize:
+      mOp = x64::MOP_movl_m_r;
+      break;
+    case k64BitSize:
+      mOp = x64::MOP_movq_m_r;
+      break;
+    default:
+      CHECK_FATAL(false, "NIY");
+      break;
+  }
+  Insn &insn = GetCurrFunction()->GetInsnBuilder()->BuildInsn(mOp, X64CG::kMd[mOp]);
+  insn.AddOpndChain(memOpnd).AddOpndChain(phyOpnd);
+  return &insn;
+}
+
+MemOperand *X64RegInfo::AdjustMemOperandIfOffsetOutOfRange(MemOperand *memOpnd, regno_t vrNum,
+    bool isDest, Insn &insn, regno_t regNum, bool &isOutOfRange) {
+  isOutOfRange = false;
+  return memOpnd;
+}
+
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_be/src/cg/x86_64/x64_standardize.cpp b/src/mapleall/maple_be/src/cg/x86_64/x64_standardize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a506e0e28fdff46c7bcdaef3fee4bcd6f93fe861
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/x86_64/x64_standardize.cpp
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "x64_standardize.h"
+#include "x64_isa.h"
+#include "x64_cg.h"
+#include "insn.h"
+
+namespace maplebe {
+#define DEFINE_MAPPING(ABSTRACT_IR, X64_MOP, ...) {ABSTRACT_IR, X64_MOP},
+std::unordered_map<MOperator, X64MOP_t> x64AbstractMapping = {
+#include "x64_abstract_mapping.def"
+};
+
+static inline X64MOP_t GetMopFromAbstraceIRMop(MOperator mOp) {
+  auto iter = x64AbstractMapping.find(mOp);
+  if (iter == x64AbstractMapping.end()) {
+    CHECK_FATAL(false, "NIY mapping");
+  }
+  CHECK_FATAL(iter->second != x64::MOP_begin, "NIY mapping");
+  return iter->second;
+}
+
+void X64Standardize::StdzMov(maplebe::Insn &insn) {
+  X64MOP_t directlyMappingMop = GetMopFromAbstraceIRMop(insn.GetMachineOpcode());
+  insn.SetMOP(X64CG::kMd[directlyMappingMop]);
+  insn.CommuteOperands(kInsnFirstOpnd, kInsnSecondOpnd);
+}
+
+void X64Standardize::StdzStrLdr(Insn &insn) {
+  /* abstract ir store is in same order with x86, so reverse twice */
+  if (insn.IsStore()) {
+    insn.CommuteOperands(kInsnFirstOpnd, kInsnSecondOpnd);
+  }
+  StdzMov(insn);
+}
+
+void X64Standardize::StdzBasicOp(Insn &insn) {
+  X64MOP_t directlyMappingMop = GetMopFromAbstraceIRMop(insn.GetMachineOpcode());
+  insn.SetMOP(X64CG::kMd[directlyMappingMop]);
+  Operand &dest = insn.GetOperand(kInsnFirstOpnd);
+  Operand &src2 = insn.GetOperand(kInsnThirdOpnd);
+  insn.CleanAllOperand();
+  insn.AddOpndChain(src2).AddOpndChain(dest);
+}
+
+void X64Standardize::StdzUnaryOp(Insn &insn, CGFunc &cgFunc) {
+  MOperator mOp = insn.GetMachineOpcode();
+  if (mOp == abstract::MOP_neg_f_32 || mOp == abstract::MOP_neg_f_64) {
+    StdzFloatingNeg(insn, cgFunc);
+    return;
+  }
+  X64MOP_t directlyMappingMop = GetMopFromAbstraceIRMop(insn.GetMachineOpcode());
+  insn.SetMOP(X64CG::kMd[directlyMappingMop]);
+  Operand &dest = insn.GetOperand(kInsnFirstOpnd);
+  insn.CleanAllOperand();
+  insn.AddOpndChain(dest);
+}
+
+void X64Standardize::StdzCvtOp(Insn &insn, CGFunc &cgFunc) {
+  uint32 OpndDesSize = insn.GetDesc()->GetOpndDes(kInsnFirstOpnd)->GetSize();
+  uint32 destSize = OpndDesSize;
+  uint32 OpndSrcSize = insn.GetDesc()->GetOpndDes(kInsnSecondOpnd)->GetSize();
+  uint32 srcSize = OpndSrcSize;
+  switch (insn.GetMachineOpcode()) {
+    case abstract::MOP_zext_rr_64_8:
+    case abstract::MOP_zext_rr_64_16:
+    case abstract::MOP_zext_rr_64_32:
+      destSize = k32BitSize;
+      break;
+    case abstract::MOP_cvt_fr_u32:
+      srcSize = k64BitSize;
+      break;
+    case abstract::MOP_cvt_rf_u32:
+      destSize = k64BitSize;
+      break;
+    default:
+      break;
+  }
+  MOperator directlyMappingMop = GetMopFromAbstraceIRMop(insn.GetMachineOpcode());
+  if (directlyMappingMop != abstract::MOP_undef) {
+    insn.SetMOP(X64CG::kMd[directlyMappingMop]);
+    Operand *opnd0 = &insn.GetOperand(kInsnSecondOpnd);
+    RegOperand *src = static_cast<RegOperand*>(opnd0);
+    if (srcSize != OpndSrcSize) {
+      src = &cgFunc.GetOpndBuilder()->CreateVReg(src->GetRegisterNumber(),
+          srcSize, src->GetRegisterType());
+    }
+    Operand *opnd1 = &insn.GetOperand(kInsnFirstOpnd);
+    RegOperand *dest = static_cast<RegOperand*>(opnd1);
+    if (destSize != OpndDesSize) {
+      dest = &cgFunc.GetOpndBuilder()->CreateVReg(dest->GetRegisterNumber(),
+          destSize, dest->GetRegisterType());
+    }
+    insn.CleanAllOperand();
+    insn.AddOpndChain(*src).AddOpndChain(*dest);
+  } else {
+    CHECK_FATAL(false, "NIY mapping");
+  }
+}
+
+/* x86 does not have floating point neg instruction
+ * neg_f   operand0  operand1
+ * ==>
+ * movd    xmm0 R1
+ * 64: movabsq 0x8000000000000000 R2
+ *     xorq R2 R1
+ * 32: xorl 0x80000000 R1
+ * movd R1 xmm0
+*/
+void X64Standardize::StdzFloatingNeg(Insn &insn, CGFunc &cgFunc) {
+  MOperator mOp = insn.GetMachineOpcode();
+  uint32 bitSize = mOp == abstract::MOP_neg_f_32 ? k32BitSize : k64BitSize;
+
+  // mov dest -> tmpOperand0
+  MOperator movOp = mOp == abstract::MOP_neg_f_32 ? x64::MOP_movd_fr_r : x64::MOP_movq_fr_r;
+  RegOperand *tmpOperand0 = &cgFunc.GetOpndBuilder()->CreateVReg(bitSize, kRegTyInt);
+  Insn &movInsn0 = cgFunc.GetInsnBuilder()->BuildInsn(movOp, X64CG::kMd[movOp]);
+  Operand &dest = insn.GetOperand(kInsnFirstOpnd);
+  movInsn0.AddOpndChain(dest).AddOpndChain(*tmpOperand0);
+  insn.GetBB()->InsertInsnBefore(insn, movInsn0);
+
+  // 32 : xorl   0x80000000         tmpOperand0
+  // 64 : movabs 0x8000000000000000 tmpOperand1
+  //      xorq   tmpOperand1        tmpOperand0
+  ImmOperand &imm = cgFunc.GetOpndBuilder()->CreateImm(bitSize, (static_cast<int64>(1) << (bitSize - 1)));
+  if (mOp == abstract::MOP_neg_f_64) {
+    Operand *tmpOperand1 = &cgFunc.GetOpndBuilder()->CreateVReg(k64BitSize, kRegTyInt);
+    Insn &movabs = cgFunc.GetInsnBuilder()->BuildInsn(x64::MOP_movabs_i_r, X64CG::kMd[x64::MOP_movabs_i_r]);
+    movabs.AddOpndChain(imm).AddOpndChain(*tmpOperand1);
+    insn.GetBB()->InsertInsnBefore(insn, movabs);
+
+    MOperator xorOp = x64::MOP_xorq_r_r;
+    Insn &xorq = cgFunc.GetInsnBuilder()->BuildInsn(xorOp, X64CG::kMd[xorOp]);
+    xorq.AddOpndChain(*tmpOperand1).AddOpndChain(*tmpOperand0);
+    insn.GetBB()->InsertInsnBefore(insn, xorq);
+  } else {
+    MOperator xorOp = x64::MOP_xorl_i_r;
+    Insn &xorq = cgFunc.GetInsnBuilder()->BuildInsn(xorOp, X64CG::kMd[xorOp]);
+    xorq.AddOpndChain(imm).AddOpndChain(*tmpOperand0);
+    insn.GetBB()->InsertInsnBefore(insn, xorq);
+  }
+
+  // mov tmpOperand0 -> dest
+  Insn &movq = cgFunc.GetInsnBuilder()->BuildInsn(movOp, X64CG::kMd[movOp]);
+  movq.AddOpndChain(*tmpOperand0).AddOpndChain(dest);
+  insn.GetBB()->InsertInsnBefore(insn, movq);
+
+  insn.GetBB()->RemoveInsn(insn);
+  return;
+}
+
+void X64Standardize::StdzShiftOp(Insn &insn, CGFunc &cgFunc) {
+  RegOperand *countOpnd = static_cast<RegOperand*>(&insn.GetOperand(kInsnThirdOpnd));
+  /* count operand cvt -> PTY_u8 */
+  if (countOpnd->GetSize() != GetPrimTypeBitSize(PTY_u8)) {
+    countOpnd = &cgFunc.GetOpndBuilder()->CreateVReg(countOpnd->GetRegisterNumber(),
+        GetPrimTypeBitSize(PTY_u8), countOpnd->GetRegisterType());
+  }
+  /* copy count operand to cl(rcx) register */
+  RegOperand &clOpnd = cgFunc.GetOpndBuilder()->CreatePReg(x64::RCX, GetPrimTypeBitSize(PTY_u8), kRegTyInt);
+  X64MOP_t copyMop = x64::MOP_movb_r_r;
+  Insn &copyInsn = cgFunc.GetInsnBuilder()->BuildInsn(copyMop, X64CG::kMd[copyMop]);
+  copyInsn.AddOpndChain(*countOpnd).AddOpndChain(clOpnd);
+  insn.GetBB()->InsertInsnBefore(insn, copyInsn);
+  /* shift OP */
+  X64MOP_t directlyMappingMop = GetMopFromAbstraceIRMop(insn.GetMachineOpcode());
+  insn.SetMOP(X64CG::kMd[directlyMappingMop]);
+  RegOperand &destOpnd = static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd));
+  insn.CleanAllOperand();
+  insn.AddOpndChain(clOpnd).AddOpndChain(destOpnd);
+}
+
+}
diff --git a/src/mapleall/maple_be/src/cg/yieldpoint.cpp b/src/mapleall/maple_be/src/cg/yieldpoint.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..082e19251ba3f836f8c0fa5e08608d459d75738e
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/yieldpoint.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "yieldpoint.h"
+#include "loop.h"
+#if TARGAARCH64
+#include "aarch64_yieldpoint.h"
+#elif TARGRISCV64
+#include "riscv64_yieldpoint.h"
+#endif
+#if TARGARM32
+#include "arm32_yieldpoint.h"
+#endif
+#include "cgfunc.h"
+
+namespace maplebe {
+using namespace maple;
+
+bool CgYieldPointInsertion::PhaseRun(maplebe::CGFunc &f) {
+  YieldPointInsertion *yieldPoint = nullptr;
+  (void)GetAnalysisInfoHook()->ForceRunAnalysisPhase<MapleFunctionPhase<CGFunc>, CGFunc>(&CgLoopAnalysis::id, f);
+#if TARGAARCH64 || TARGRISCV64
+  yieldPoint = GetPhaseAllocator()->New<AArch64YieldPointInsertion>(f);
+#endif
+#if TARGARM32
+  yieldPoint = GetPhaseAllocator()->New<Arm32YieldPointInsertion>(f);
+#endif
+  yieldPoint->Run();
+  return false;
+}
+}  /* namespace maplebe */
diff --git a/src/mapleall/maple_driver/BUILD.gn b/src/mapleall/maple_driver/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..009891ecc246174732c62bcb8c4f0034fca0bfc1
--- /dev/null
+++ b/src/mapleall/maple_driver/BUILD.gn
@@ -0,0 +1,101 @@
+#
+#Copyright(c)[2020 - 2021] Huawei Technologies Co., Ltd.All rights reserved.
+#
+#OpenArkCompiler is licensed under Mulan PSL v2.
+#You can use this software according to the terms and conditions of the Mulan PSL v2.
+#You may obtain a copy of Mulan PSL v2 at:
+#
+#http:  // license.coscl.org.cn/MulanPSL2
+#
+#THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+#EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON - INFRINGEMENT, MERCHANTABILITY OR
+#FIT FOR A PARTICULAR PURPOSE.
+#See the Mulan PSL v2 for more details.
+#
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+
+include_directories = [
+  "${MAPLEALL_ROOT}",
+  "${MAPLEALL_ROOT}/maple_be/include",
+  "${MAPLEALL_ROOT}/maple_be/include/cg",
+  "${MAPLEALL_ROOT}/maple_be/include/be",
+  "${MAPLEALL_ROOT}/maple_be/include/ad",
+  "${MAPLEALL_ROOT}/maple_be/include/ad/target",
+  "${MAPLE_BUILD_OUTPUT}/common/target",
+  "${MAPLEALL_ROOT}/maple_be/include/cg/aarch64",
+  "${MAPLEALL_ROOT}/maple_be/include/be/aarch64",
+  "${MAPLEALL_ROOT}/maple_driver/defs",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/mpl2mpl/include",
+  "${MAPLEALL_ROOT}/maple_me/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include/old",
+  "${MAPLEALL_ROOT}/maple_phase/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  "${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat",
+]
+
+executable("maple") {
+  sources = [
+    "src/as_compiler.cpp",
+    "src/compiler.cpp",
+    "src/compiler_factory.cpp",
+    "src/dex2mpl_compiler.cpp",
+    "src/driver_runner.cpp",
+    "src/ipa_compiler.cpp",
+    "src/jbc2mpl_compiler.cpp",
+    "src/cpp2mpl_compiler.cpp",
+    "src/clang_compiler.cpp",
+    "src/ld_compiler.cpp",
+    "src/maple.cpp",
+    "src/maple_comb_compiler_wrapper.cpp",
+    "src/maple_comb_compiler.cpp",
+    "src/mpl_options.cpp",
+    "src/mplcg_compiler.cpp",
+    "src/hided_options.cpp",
+  ]
+
+  include_dirs = include_directories
+
+  deps = [
+    ":libdriver_option",
+    ":libmaple_driver",
+    "${MAPLEALL_ROOT}/maple_be:libcg",
+    "${MAPLEALL_ROOT}/maple_be:libmplad",
+    "${MAPLEALL_ROOT}/maple_be:libmplbe",
+    "${MAPLEALL_ROOT}/maple_ipa:libmplipa",
+    "${MAPLEALL_ROOT}/maple_ir:libmplir",
+    "${MAPLEALL_ROOT}/maple_me:libmplme",
+    "${MAPLEALL_ROOT}/maple_me:libmplmewpo",
+    "${MAPLEALL_ROOT}/maple_phase:libmplphase",
+    "${MAPLEALL_ROOT}/maple_phase:libmplphase",
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/maple_util:libcommandline",
+    "${MAPLEALL_ROOT}/mempool:libmempool",
+    "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
+  ]
+}
+
+static_library("libmaple_driver") {
+  sources = [ "src/triple.cpp" ]
+
+  include_dirs = [ "${MAPLEALL_ROOT}/maple_driver/include",
+                   "${MAPLEALL_ROOT}/maple_util/include"
+                 ]
+
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
+
+static_library("libdriver_option") {
+  sources = [ "src/driver_options.cpp" ]
+
+  include_dirs = [ "${MAPLEALL_ROOT}/maple_driver/include",
+                   "${MAPLEALL_ROOT}/maple_util/include"
+                 ]
+
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
diff --git a/src/mapleall/maple_driver/CMakeLists.txt b/src/mapleall/maple_driver/CMakeLists.txt
new file mode 100755
index 0000000000000000000000000000000000000000..f2d9dc73dd2a1893ee46bbbf598f7a2cd802fbe7
--- /dev/null
+++ b/src/mapleall/maple_driver/CMakeLists.txt
@@ -0,0 +1,104 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#   http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN AS IS BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(inc_libmaple
+  ${MAPLEALL_ROOT}
+  ${MAPLEALL_ROOT}/maple_be/include
+  ${MAPLEALL_ROOT}/maple_be/include/cg
+  ${MAPLEALL_ROOT}/maple_be/include/be
+  ${MAPLEALL_ROOT}/maple_be/include/ad
+  ${MAPLEALL_ROOT}/maple_be/include/ad/target
+  ${MAPLE_BUILD_OUTPUT}/common/target
+  ${MAPLEALL_ROOT}/maple_be/include/cg/aarch64
+  ${MAPLEALL_ROOT}/maple_be/include/be/aarch64
+  ${MAPLEALL_ROOT}/maple_driver/defs
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${MAPLEALL_ROOT}/maple_util/include
+  ${MAPLEALL_ROOT}/mpl2mpl/include
+  ${MAPLEALL_ROOT}/maple_me/include
+  ${MAPLEALL_ROOT}/maple_ipa/include
+  ${MAPLEALL_ROOT}/maple_ipa/include/old
+  ${MAPLEALL_ROOT}/maple_phase/include
+  ${MAPLEALL_ROOT}/maple_ir/include
+  ${MAPLEALL_ROOT}/mempool/include
+  ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+  ${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat
+)
+
+set(src_libmaple
+  src/as_compiler.cpp
+  src/compiler.cpp
+  src/compiler_factory.cpp
+  src/dex2mpl_compiler.cpp
+  src/driver_runner.cpp
+  src/ipa_compiler.cpp
+  src/jbc2mpl_compiler.cpp
+  src/cpp2mpl_compiler.cpp
+  src/clang_compiler.cpp
+  src/ld_compiler.cpp
+  src/maple.cpp
+  src/maple_comb_compiler_wrapper.cpp
+  src/maple_comb_compiler.cpp
+  src/mpl_options.cpp
+  src/mplcg_compiler.cpp
+  src/hided_options.cpp
+)
+
+#libmaple
+add_library(libmaple STATIC ${src_libmaple})
+set_target_properties(libmaple PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${inc_libmaple}"
+  LINK_LIBRARIES ""
+  RUNTIME_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}"
+)
+
+set(src_libmaple_driver
+  src/triple.cpp
+)
+
+set(inc_libmaple_driver
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${MAPLEALL_ROOT}/maple_util/include
+)
+
+#libmaple_driver
+add_library(libmaple_driver STATIC ${src_libmaple_driver})
+set_target_properties(libmaple_driver PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${inc_libmaple_driver}"
+  LINK_LIBRARIES ""
+  ARCHIVE_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}"
+)
+
+set(src_libdriver_option
+  src/driver_options.cpp
+)
+
+set(inc_libdriver_option
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${MAPLEALL_ROOT}/maple_util/include
+)
+
+#libdriver_option
+add_library(libdriver_option STATIC ${src_libdriver_option})
+set_target_properties(libdriver_option PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${inc_libdriver_option}"
+  LINK_LIBRARIES ""
+  ARCHIVE_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}"
+)
+
+
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_clang.def b/src/mapleall/maple_driver/defs/default/O0_options_clang.def
new file mode 100644
index 0000000000000000000000000000000000000000..fb70797f01067addccfdeb08a9b7a1d6fd843524
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_clang.def
@@ -0,0 +1 @@
+{"-emit-ast", "", false},
\ No newline at end of file
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_cpp2mpl.def b/src/mapleall/maple_driver/defs/default/O0_options_cpp2mpl.def
new file mode 100644
index 0000000000000000000000000000000000000000..04bbc03d702e2d0ceb7b15a16077132a597ff6b5
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_cpp2mpl.def
@@ -0,0 +1 @@
+{"--enable-variable-array", "", false},
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_dex2mpl.def b/src/mapleall/maple_driver/defs/default/O0_options_dex2mpl.def
new file mode 100644
index 0000000000000000000000000000000000000000..2878491cab305fe95e99cca35ce2d8187761ccd0
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_dex2mpl.def
@@ -0,0 +1,4 @@
+// option name, option value, append maple root path?
+{ "-j100", "", false },
+{ "-litprofile", "out/target/product/maple_arm64/lib/codetricks/profile/meta.list", true },
+{ "-refine-catch", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_jbc2mpl.def b/src/mapleall/maple_driver/defs/default/O0_options_jbc2mpl.def
new file mode 100644
index 0000000000000000000000000000000000000000..4d82bd2e54cfc7894a41d3c87013c5904f03c759
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_jbc2mpl.def
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_ld.def b/src/mapleall/maple_driver/defs/default/O0_options_ld.def
new file mode 100644
index 0000000000000000000000000000000000000000..9e26dfeeb6e641a33dae4961196235bdb965b21b
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_ld.def
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_me.def b/src/mapleall/maple_driver/defs/default/O0_options_me.def
new file mode 100644
index 0000000000000000000000000000000000000000..ddb4ef6084bcae13795a469adaa0f751c1f6d481
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_me.def
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "--quiet", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_mpl2mpl.def b/src/mapleall/maple_driver/defs/default/O0_options_mpl2mpl.def
new file mode 100644
index 0000000000000000000000000000000000000000..bda5ba0de368fd40763d76d96f8ce8585cafb599
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_mpl2mpl.def
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "--quiet", "", false },
+{ "-regnativefunc", "", false },
+{ "--maplelinker", "", false },
+{ "--profile", "out/target/product/maple_arm64/lib/codetricks/profile.pv/meta.list", true },
+{ "--maplelinker-nolocal", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_mpl2mpl_c.def b/src/mapleall/maple_driver/defs/default/O0_options_mpl2mpl_c.def
new file mode 100644
index 0000000000000000000000000000000000000000..c015aa6e5225dc457651ad1c1e5570cee881ba39
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_mpl2mpl_c.def
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "--quiet", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_mplcg.def b/src/mapleall/maple_driver/defs/default/O0_options_mplcg.def
new file mode 100644
index 0000000000000000000000000000000000000000..c92727c76559c1b50577a3aeb6a8e2b27fb7dce9
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_mplcg.def
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "--quiet", "", false  },
+{ "--no-pie", "", false  },
+{ "--fpic", "", false  },
+{ "--verbose-asm", "", false  },
+{ "--maplelinker", "", false  },
+{ "--duplicate_asm_list", "out/target/product/maple_arm64/lib/codetricks/asm/duplicateFunc.s", true },
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_mplcg_c.def b/src/mapleall/maple_driver/defs/default/O0_options_mplcg_c.def
new file mode 100644
index 0000000000000000000000000000000000000000..1ab10cf1a3f4000518600963eb32399065e8beb0
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_mplcg_c.def
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-O0", "", false },
+{ "--quiet", "", false  },
+{ "--fpic", "", false  },
diff --git a/src/mapleall/maple_driver/defs/default/O2_options_dex2mpl.def b/src/mapleall/maple_driver/defs/default/O2_options_dex2mpl.def
new file mode 100644
index 0000000000000000000000000000000000000000..2878491cab305fe95e99cca35ce2d8187761ccd0
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O2_options_dex2mpl.def
@@ -0,0 +1,4 @@
+// option name, option value, append maple root path?
+{ "-j100", "", false },
+{ "-litprofile", "out/target/product/maple_arm64/lib/codetricks/profile/meta.list", true },
+{ "-refine-catch", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/O2_options_me.def b/src/mapleall/maple_driver/defs/default/O2_options_me.def
new file mode 100644
index 0000000000000000000000000000000000000000..47d61b942e8d94dc16a89820ec14811c9d4aa398
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O2_options_me.def
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
+{ "--inlinefunclist", "out/target/product/maple_arm64/lib/codetricks/profile.pv/inline_funcs.list", true },
+{ "--no-nativeopt", "", false },
+{ "--no-ignoreipa", "", false },
+{ "--enable-ea", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/O2_options_me_c.def b/src/mapleall/maple_driver/defs/default/O2_options_me_c.def
new file mode 100644
index 0000000000000000000000000000000000000000..8ed5de607fd8829c860c032deeeba28d8d62b122
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O2_options_me_c.def
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/O2_options_mpl2mpl.def b/src/mapleall/maple_driver/defs/default/O2_options_mpl2mpl.def
new file mode 100644
index 0000000000000000000000000000000000000000..b74863dcc076f8c50f6db0fba121730d11a6c773
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O2_options_mpl2mpl.def
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
+{ "--regnativefunc", "", false },
+{ "--no-nativeopt", "", false },
+{ "--maplelinker", "", false },
+{ "--profile", "out/target/product/maple_arm64/lib/codetricks/profile.pv/meta.list", true },
+{ "--maplelinker-nolocal", "", false },
\ No newline at end of file
diff --git a/src/mapleall/maple_driver/defs/default/O2_options_mpl2mpl_c.def b/src/mapleall/maple_driver/defs/default/O2_options_mpl2mpl_c.def
new file mode 100644
index 0000000000000000000000000000000000000000..83c259a8086271412158d2716f8bfe626c2259d0
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O2_options_mpl2mpl_c.def
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
\ No newline at end of file
diff --git a/src/mapleall/maple_driver/defs/default/O2_options_mplcg.def b/src/mapleall/maple_driver/defs/default/O2_options_mplcg.def
new file mode 100644
index 0000000000000000000000000000000000000000..fc489f6b0e90e884a9fd48e09a88023994b3569b
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O2_options_mplcg.def
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
+{ "--no-pie", "", false },
+{ "--verbose-asm", "", false },
+{ "--fpic", "", false },
+{ "--maplelinker", "", false },
+{ "--gen-c-macro-def", "", false },
+{ "--duplicate_asm_list", "out/target/product/maple_arm64/lib/codetricks/asm/duplicateFunc.s", true },
diff --git a/src/mapleall/maple_driver/defs/default/O2_options_mplcg_c.def b/src/mapleall/maple_driver/defs/default/O2_options_mplcg_c.def
new file mode 100644
index 0000000000000000000000000000000000000000..b4cb79a23af2ab5b3423374163ed9e77ef27bb89
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O2_options_mplcg_c.def
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
+{ "--fpic", "", false  },
diff --git a/src/mapleall/maple_driver/defs/default/O2_options_mplipa.def b/src/mapleall/maple_driver/defs/default/O2_options_mplipa.def
new file mode 100644
index 0000000000000000000000000000000000000000..1791acef4470a9f8718fc7644eb56a8d51f70110
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O2_options_mplipa.def
@@ -0,0 +1,3 @@
+// option name, option value, append maple root path?
+{ "--quiet", "", false },
+{ "--effectipa", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/Os_options_me.def b/src/mapleall/maple_driver/defs/default/Os_options_me.def
new file mode 100644
index 0000000000000000000000000000000000000000..020c5c8c83a6ac4e2191e75fd943ab86af17a7e3
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/Os_options_me.def
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-Os", "", false },
+{ "--quiet", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/Os_options_mpl2mpl.def b/src/mapleall/maple_driver/defs/default/Os_options_mpl2mpl.def
new file mode 100644
index 0000000000000000000000000000000000000000..55189dc380c24a08bdfa24e4b4a6882d441bcd9e
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/Os_options_mpl2mpl.def
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-Os", "", false },
+{ "--quiet", "", false },
\ No newline at end of file
diff --git a/src/mapleall/maple_driver/defs/default/Os_options_mplcg.def b/src/mapleall/maple_driver/defs/default/Os_options_mplcg.def
new file mode 100644
index 0000000000000000000000000000000000000000..197ad1f12714d1c2c4c7411435c6eff8f49bc232
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/Os_options_mplcg.def
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-Os", "", false },
+{ "--quiet", "", false },
+{ "--fpic", "", false  },
diff --git a/src/mapleall/maple_driver/defs/default_options.def b/src/mapleall/maple_driver/defs/default_options.def
new file mode 100644
index 0000000000000000000000000000000000000000..9b8978ca917e949aa7fb5d0a50b814c866e5de39
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default_options.def
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MAPLE_DRIVER_INCLUDE_DEFAULT_OPTIONS_H
+#define MAPLE_DRIVER_INCLUDE_DEFAULT_OPTIONS_H
+
+namespace maple {
+// O0 ME options
+static MplOption kMeDefaultOptionsO0[] = {
+#ifdef ANDROID
+#include "android/O0_options_me.def"
+#else
+#include "default/O0_options_me.def"
+#endif
+};
+// O2 ME options
+static MplOption kMeDefaultOptionsO2[] = {
+#ifdef ANDROID
+#include "android/O2_options_me.def"
+#else
+#include "default/O2_options_me.def"
+#endif
+};
+// Os ME options
+static MplOption kMeDefaultOptionsOs[] = {
+#include "default/Os_options_me.def"
+};
+// O0 mpl2mpl options
+static MplOption kMpl2MplDefaultOptionsO0[] = {
+#ifdef ANDROID
+#include "android/O0_options_mpl2mpl.def"
+#else
+#include "default/O0_options_mpl2mpl.def"
+#endif
+};
+// O2 mpl2mpl options
+static MplOption kMpl2MplDefaultOptionsO2[] = {
+#ifdef ANDROID
+#include "android/O2_options_mpl2mpl.def"
+#else
+#include "default/O2_options_mpl2mpl.def"
+#endif
+};
+// Os mpl2mpl options
+static MplOption kMpl2MplDefaultOptionsOs[] = {
+#include "default/Os_options_mpl2mpl.def"
+};
+// O0 mplcg options
+static MplOption kMplcgDefaultOptionsO0[] = {
+#ifdef ANDROID
+#include "android/O0_options_mplcg.def"
+#else
+#include "default/O0_options_mplcg.def"
+#endif
+};
+// O2 mplcg options
+static MplOption kMplcgDefaultOptionsO2[] = {
+#ifdef ANDROID
+#include "android/O2_options_mplcg.def"
+#else
+#include "default/O2_options_mplcg.def"
+#endif
+};
+// Os mplcg options
+static MplOption kMplcgDefaultOptionsOs[] = {
+#include "default/Os_options_mplcg.def"
+};
+// O2 mplipa options
+static MplOption kMplipaDefaultOptionsO2[] = {
+#ifdef ANDROID
+#include "android/O2_options_mplipa.def"
+#else
+#include "default/O2_options_mplipa.def"
+#endif
+};
+// O0 dex2mpl options
+static MplOption kDex2mplDefaultOptionsO0[] = {
+#ifdef ANDROID
+#include "android/O0_options_dex2mpl.def"
+#else
+#include "default/O0_options_dex2mpl.def"
+#endif
+};
+// O2 dex2mpl options
+static MplOption kDex2mplDefaultOptionsO2[] = {
+#ifdef ANDROID
+#include "android/O2_options_dex2mpl.def"
+#else
+#include "default/O2_options_dex2mpl.def"
+#endif
+};
+// O0 mpl2mpl options for C language
+static MplOption kMpl2MplDefaultOptionsO0ForC[] = {
+#include "default/O0_options_mpl2mpl_c.def"
+};
+// O2 mpl2mpl options for C language
+static MplOption kMpl2MplDefaultOptionsO2ForC[] = {
+#include "default/O2_options_mpl2mpl_c.def"
+};
+// O0 mplcg options for C language
+static MplOption kMplcgDefaultOptionsO0ForC[] = {
+#include "default/O0_options_mplcg_c.def"
+};
+// O2 ME options for C language
+static MplOption kMeDefaultOptionsO2ForC[] = {
+#include "default/O2_options_me_c.def"
+};
+// O2 mplcg options for C language
+static MplOption kMplcgDefaultOptionsO2ForC[] = {
+#include "default/O2_options_mplcg_c.def"
+};
+// O0 cpp2mpl options
+static MplOption kCpp2MplDefaultOptionsForAst[] = {
+#include "default/O0_options_cpp2mpl.def"
+};
+// O0 clang options
+static MplOption kClangDefaultOptions[] = {
+#include "default/O0_options_clang.def"
+};
+// O0 ld options
+static MplOption kLdDefaultOptions[] = {
+#include "default/O0_options_ld.def"
+};
+}  // namespace maple
+#endif  // MAPLE_DRIVER_INCLUDE_DEFAULT_OPTIONS_H
diff --git a/src/mapleall/maple_driver/include/compiler.h b/src/mapleall/maple_driver/include/compiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e77f7966afda8baa6dc430b2102c65c80f29c1d
--- /dev/null
+++ b/src/mapleall/maple_driver/include/compiler.h
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_DRIVER_INCLUDE_COMPILER_H
+#define MAPLE_DRIVER_INCLUDE_COMPILER_H
+#include <map>
+#include <unordered_set>
+#include "error_code.h"
+#include "mpl_options.h"
+#include "cg_option.h"
+#include "me_option.h"
+#include "option.h"
+#include "mir_module.h"
+#include "mir_parser.h"
+#include "driver_runner.h"
+#include "bin_mplt.h"
+
+namespace maple {
+const std::string kBinNameNone = "";
+const std::string kBinNameJbc2mpl = "jbc2mpl";
+const std::string kBinNameCpp2mpl = "hir2mpl";
+const std::string kBinNameClang = "clang";
+const std::string kBinNameDex2mpl = "dex2mpl";
+const std::string kBinNameMplipa = "mplipa";
+const std::string kBinNameMe = "me";
+const std::string kBinNameMpl2mpl = "mpl2mpl";
+const std::string kBinNameMplcg = "mplcg";
+const std::string kBinNameMapleComb = "maplecomb";
+const std::string kBinNameMapleCombWrp = "maplecombwrp";
+const std::string kMachine = "aarch64-";
+const std::string kVendor = "unknown-";
+const std::string kOperatingSystem = "linux-gnu-";
+const std::string kLdFlag = "ld";
+const std::string kGccFlag = "gcc";
+const std::string kGppFlag = "g++";
+const std::string kAsFlag = "as";
+const std::string kInputPhase = "input";
+const std::string kBinNameLd = kMachine + kOperatingSystem + kLdFlag;
+const std::string kBinNameAs = kMachine + kOperatingSystem + kAsFlag;
+const std::string kBinNameGcc = kMachine + kOperatingSystem + kGccFlag;
+const std::string kBinNameGpp = kMachine + kOperatingSystem + kGppFlag;
+
+constexpr char kGccBeIlp32SysrootPathEnv[] = "GCC_BIGEND_ILP32_SYSROOT_PATH";
+constexpr char kGccBeSysrootPathEnv[] = "GCC_BIGEND_SYSROOT_PATH";
+constexpr char kGccBePathEnv[] = "GCC_BIGEND_PATH";
+
+class Compiler {
+ public:
+  explicit Compiler(const std::string &name) : name(name) {}
+
+  virtual ~Compiler() = default;
+
+  virtual ErrorCode Compile(MplOptions &options, const Action &action,
+                            std::unique_ptr<MIRModule> &theModule);
+
+  virtual void GetTmpFilesToDelete(const MplOptions &mplOptions [[maybe_unused]],
+                                   const Action &action [[maybe_unused]],
+                                   std::vector<std::string> &tempFiles [[maybe_unused]]) const {}
+
+  virtual std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions [[maybe_unused]],
+                                                          const Action &action [[maybe_unused]]) const {
+    return std::unordered_set<std::string>();
+  }
+
+  virtual void PrintCommand(const MplOptions&, const Action&) const {}
+
+ protected:
+  virtual std::string GetBinPath(const MplOptions &mplOptions) const;
+  virtual const std::string &GetBinName() const {
+    return kBinNameNone;
+  }
+
+  /* Default behaviour ToolName==BinName, But some tools have another behaviour:
+   * AsCompiler: ToolName=kAsFlag, BinName=kMachine + kOperatingSystem + kAsFlag
+   */
+  virtual const std::string &GetTool() const {
+    return GetBinName();
+  }
+
+  virtual std::string GetInputFileName(const MplOptions &options [[maybe_unused]], const Action &action) const {
+    return action.GetInputFile();
+  }
+
+  virtual DefaultOption GetDefaultOptions(const MplOptions &options [[maybe_unused]],
+                                          const Action &action [[maybe_unused]]) const {
+    return DefaultOption();
+  }
+
+  virtual void AppendOutputOption(std::vector<MplOption> &, const std::string &) const {
+    return;
+  }
+
+ private:
+  const std::string name;
+  std::vector<MplOption> MakeOption(const MplOptions &options,
+                                    const Action &action) const;
+  void AppendDefaultOptions(std::vector<MplOption> &finalOptions,
+                            const std::vector<MplOption> &defaultOptions,
+                            bool isDebug) const;
+  void AppendExtraOptions(std::vector<MplOption> &finalOptions, const MplOptions &options,
+                          bool isDebug, const Action &action) const;
+  void AppendInputsAsOptions(std::vector<MplOption> &finalOptions,
+                             const MplOptions &mplOptions, const Action &action) const;
+  void ReplaceOrInsertOption(std::vector<MplOption> &finalOptions,
+                             const std::string &key, const std::string &value) const;
+  std::vector<MplOption> MakeDefaultOptions(const MplOptions &options,
+                                            const Action &action) const;
+  int Exe(const MplOptions &mplOptions, const std::vector<MplOption> &options) const;
+  const std::string &GetName() const {
+    return name;
+  }
+};
+
+class Jbc2MplCompiler : public Compiler {
+ public:
+  explicit Jbc2MplCompiler(const std::string &name) : Compiler(name) {}
+
+  ~Jbc2MplCompiler() = default;
+
+ private:
+  const std::string &GetBinName() const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
+};
+
+class ClangCompiler : public Compiler {
+ public:
+  explicit ClangCompiler(const std::string &name) : Compiler(name) {}
+
+  ~ClangCompiler() = default;
+
+ private:
+  const std::string &GetBinName() const override;
+  std::string GetBinPath(const MplOptions &mplOptions) const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override ;
+  void AppendOutputOption(std::vector<MplOption> &finalOptions, const std::string &name) const override;
+};
+
+class ClangCompilerBeILP32 : public ClangCompiler {
+ public:
+  explicit ClangCompilerBeILP32(const std::string &name) : ClangCompiler(name) {}
+ private:
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+};
+
+class Cpp2MplCompiler : public Compiler {
+ public:
+  explicit Cpp2MplCompiler(const std::string &name) : Compiler(name) {}
+
+  ~Cpp2MplCompiler() = default;
+
+ private:
+  std::string GetBinPath(const MplOptions &mplOptions) const override;
+  const std::string &GetBinName() const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
+  void AppendOutputOption(std::vector<MplOption> &finalOptions, const std::string &name) const override;
+};
+
+class Dex2MplCompiler : public Compiler {
+ public:
+  explicit Dex2MplCompiler(const std::string &name) : Compiler(name) {}
+
+  ~Dex2MplCompiler() = default;
+#ifdef INTERGRATE_DRIVER
+  ErrorCode Compile(MplOptions &options, const Action &action,
+                    std::unique_ptr<MIRModule> &theModule) override;
+#endif
+
+  void PrintCommand(const MplOptions &options, const Action &action) const override;
+
+ private:
+  const std::string &GetBinName() const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
+#ifdef INTERGRATE_DRIVER
+  void PostDex2Mpl(std::unique_ptr<MIRModule> &theModule) const;
+  bool MakeDex2mplOptions(const MplOptions &options);
+#endif
+};
+
+class IpaCompiler : public Compiler {
+ public:
+  explicit IpaCompiler(const std::string &name) : Compiler(name) {}
+
+  ~IpaCompiler() = default;
+
+ private:
+  const std::string &GetBinName() const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+};
+
+class MapleCombCompiler : public Compiler {
+ public:
+  explicit MapleCombCompiler(const std::string &name) : Compiler(name) {}
+
+  ~MapleCombCompiler() = default;
+
+  ErrorCode Compile(MplOptions &options, const Action &action,
+                    std::unique_ptr<MIRModule> &theModule) override;
+  void PrintCommand(const MplOptions &options, const Action &action) const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+
+ private:
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  ErrorCode MakeMeOptions(const MplOptions &options, DriverRunner &runner) const;
+  ErrorCode MakeMpl2MplOptions(const MplOptions &options, DriverRunner &runner) const;
+  std::string DecideOutExe(const MplOptions &options) const;
+  std::string GetStringOfSafetyOption() const;
+};
+
+class MplcgCompiler : public Compiler {
+ public:
+  explicit MplcgCompiler(const std::string &name) : Compiler(name) {}
+
+  ~MplcgCompiler() = default;
+  ErrorCode Compile(MplOptions &options, const Action &action,
+                    std::unique_ptr<MIRModule> &theModule) override;
+  void PrintMplcgCommand(const MplOptions &options, const Action &action, const MIRModule &md) const;
+  void SetOutputFileName(const MplOptions &options, const Action &action, const MIRModule &md);
+  std::string GetInputFile(const MplOptions &options, const Action &action, const MIRModule *md) const;
+ private:
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  ErrorCode GetMplcgOptions(MplOptions &options, const Action &action, const MIRModule *theModule) const;
+  ErrorCode MakeCGOptions(const MplOptions &options) const;
+  const std::string &GetBinName() const override;
+  std::string baseName;
+  std::string outputFile;
+};
+
+class MapleCombCompilerWrp : public Compiler {
+ public:
+  explicit MapleCombCompilerWrp(const std::string &name) : Compiler(name) {}
+  ~MapleCombCompilerWrp() = default;
+
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+
+ private:
+  std::string GetBinPath(const MplOptions &mplOptions) const override;
+  const std::string &GetBinName() const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
+};
+
+// Build .s to .o
+class AsCompiler : public Compiler {
+ public:
+  explicit AsCompiler(const std::string &name) : Compiler(name) {}
+
+  ~AsCompiler() = default;
+
+ private:
+  std::string GetBinPath(const MplOptions &mplOptions) const override;
+  const std::string &GetBinName() const override;
+  const std::string &GetTool() const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
+  void AppendOutputOption(std::vector<MplOption> &finalOptions, const std::string &name) const override;
+};
+
+class AsCompilerBeILP32 : public AsCompiler {
+ public:
+  explicit AsCompilerBeILP32(const std::string &name) : AsCompiler(name) {}
+ private:
+  std::string GetBinPath(const MplOptions &mplOptions) const override;
+  const std::string &GetBinName() const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+};
+
+// Build .o to .so
+class LdCompiler : public Compiler {
+ public:
+  explicit LdCompiler(const std::string &name) : Compiler(name) {}
+
+  ~LdCompiler() = default;
+
+ private:
+  std::string GetBinPath(const MplOptions &mplOptions) const override;
+  const std::string &GetBinName() const override;
+  const std::string &GetTool() const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+  void AppendOutputOption(std::vector<MplOption> &finalOptions, const std::string &name) const override;
+};
+
+class LdCompilerBeILP32 : public LdCompiler {
+ public:
+  explicit LdCompilerBeILP32(const std::string &name) : LdCompiler(name) {}
+ private:
+  std::string GetBinPath(const MplOptions &mplOptions) const override;
+  const std::string &GetBinName() const override;
+};
+
+}  // namespace maple
+#endif  // MAPLE_DRIVER_INCLUDE_COMPILER_H
diff --git a/src/mapleall/maple_driver/include/compiler_factory.h b/src/mapleall/maple_driver/include/compiler_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd5f417c50c4b2d8f7eab3e69a9b10d39072e205
--- /dev/null
+++ b/src/mapleall/maple_driver/include/compiler_factory.h
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_DRIVER_INCLUDE_COMPILER_FACTORY_H
+#define MAPLE_DRIVER_INCLUDE_COMPILER_FACTORY_H
+#include <unordered_set>
+#include "compiler.h"
+#include "error_code.h"
+#include "mir_module.h"
+#include "mir_parser.h"
+#include "triple.h"
+
+namespace maple {
+
+class Toolchain {
+  using SupportedCompilers = std::unordered_map<std::string, std::unique_ptr<Compiler>>;
+  SupportedCompilers compilers;
+
+ public:
+  Compiler *Find(const std::string &toolName) {
+    auto it = compilers.find(toolName);
+    if (it != compilers.end()) {
+      return it->second.get();
+    }
+    return nullptr;
+  }
+
+  const SupportedCompilers &GetSupportedCompilers() const {
+    return compilers;
+  }
+
+  virtual ~Toolchain() = default;
+
+ protected:
+  template<typename T>
+  void AddCompiler(const std::string &toolName) {
+    (void)compilers.emplace(std::make_pair(toolName, std::make_unique<T>(toolName)));
+  }
+};
+
+class Aarch64Toolchain : public Toolchain {
+ public:
+  Aarch64Toolchain() {
+    AddCompiler<Jbc2MplCompiler>("jbc2mpl");
+    AddCompiler<Dex2MplCompiler>("dex2mpl");
+    AddCompiler<Cpp2MplCompiler>("hir2mpl");
+    AddCompiler<ClangCompiler>("clang");
+    AddCompiler<IpaCompiler>("mplipa");
+    AddCompiler<MapleCombCompiler>("me");
+    AddCompiler<MapleCombCompiler>("mpl2mpl");
+    AddCompiler<MplcgCompiler>("mplcg");
+    AddCompiler<MapleCombCompiler>("maplecomb");
+    AddCompiler<MapleCombCompilerWrp>("maplecombwrp");
+    AddCompiler<AsCompiler>("as");
+    AddCompiler<LdCompiler>("ld");
+  }
+};
+
+class Aarch64BeILP32Toolchain : public Toolchain {
+ public:
+  Aarch64BeILP32Toolchain() {
+    AddCompiler<Jbc2MplCompiler>("jbc2mpl");
+    AddCompiler<Dex2MplCompiler>("dex2mpl");
+    AddCompiler<Cpp2MplCompiler>("hir2mpl");
+    AddCompiler<ClangCompilerBeILP32>("clang");
+    AddCompiler<IpaCompiler>("mplipa");
+    AddCompiler<MapleCombCompiler>("me");
+    AddCompiler<MapleCombCompiler>("mpl2mpl");
+    AddCompiler<MplcgCompiler>("mplcg");
+    AddCompiler<MapleCombCompiler>("maplecomb");
+    AddCompiler<MapleCombCompilerWrp>("maplecombwrp");
+    AddCompiler<AsCompilerBeILP32>("as");
+    AddCompiler<LdCompilerBeILP32>("ld");
+  }
+};
+
+class CompilerFactory {
+ public:
+  static CompilerFactory &GetInstance();
+  CompilerFactory(const CompilerFactory&) = delete;
+  CompilerFactory(CompilerFactory&&) = delete;
+  CompilerFactory &operator=(const CompilerFactory&) = delete;
+  CompilerFactory &operator=(CompilerFactory&&) = delete;
+  ~CompilerFactory() = default;
+
+  ErrorCode Compile(MplOptions &mplOptions);
+  Toolchain *GetToolChain();
+
+ private:
+  CompilerFactory() = default;
+
+  ErrorCode Select(const MplOptions &mplOptions, std::vector<Action*> &selectedActions);
+  ErrorCode Select(Action &action, std::vector<Action*> &selectedActions);
+  ErrorCode DeleteTmpFiles(const MplOptions &mplOptions,
+                           const std::vector<std::string> &tempFiles) const;
+
+  bool compileFinished = false;
+  std::unique_ptr<MIRModule> theModule;
+  std::unique_ptr<Toolchain> toolchain;
+};
+}  // namespace maple
+#endif  // MAPLE_DRIVER_INCLUDE_COMPILER_FACTORY_H
diff --git a/src/mapleall/maple_driver/include/driver_options.h b/src/mapleall/maple_driver/include/driver_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..61a57df5d896e03f2ebbe9a2aff3ae44cd27237c
--- /dev/null
+++ b/src/mapleall/maple_driver/include/driver_options.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_DRIVER_INCLUDE_DRIVER_OPTIONS_H
+#define MAPLE_DRIVER_INCLUDE_DRIVER_OPTIONS_H
+
+#include "cl_option.h"
+#include "cl_parser.h"
+
+static maplecl::OptionCategory &driverCategory = maplecl::CommandLine::GetCommandLine().defaultCategory;
+
+static maplecl::OptionCategory &clangCategory = maplecl::CommandLine::GetCommandLine().clangCategory;
+static maplecl::OptionCategory &hir2mplCategory = maplecl::CommandLine::GetCommandLine().hir2mplCategory;
+static maplecl::OptionCategory &mpl2mplCategory = maplecl::CommandLine::GetCommandLine().mpl2mplCategory;
+static maplecl::OptionCategory &meCategory = maplecl::CommandLine::GetCommandLine().meCategory;
+static maplecl::OptionCategory &cgCategory = maplecl::CommandLine::GetCommandLine().cgCategory;
+static maplecl::OptionCategory &asCategory = maplecl::CommandLine::GetCommandLine().asCategory;
+static maplecl::OptionCategory &ldCategory = maplecl::CommandLine::GetCommandLine().ldCategory;
+
+static maplecl::OptionCategory &dex2mplCategory = maplecl::CommandLine::GetCommandLine().dex2mplCategory;
+static maplecl::OptionCategory &jbc2mplCategory = maplecl::CommandLine::GetCommandLine().jbc2mplCategory;
+static maplecl::OptionCategory &ipaCategory = maplecl::CommandLine::GetCommandLine().ipaCategory;
+
+namespace opts {
+
+/* ##################### BOOL Options ############################################################### */
+
+extern maplecl::Option<bool> version;
+extern maplecl::Option<bool> ignoreUnkOpt;
+extern maplecl::Option<bool> o0;
+extern maplecl::Option<bool> o1;
+extern maplecl::Option<bool> o2;
+extern maplecl::Option<bool> os;
+extern maplecl::Option<bool> verify;
+extern maplecl::Option<bool> decoupleStatic;
+extern maplecl::Option<bool> bigEndian;
+extern maplecl::Option<bool> gcOnly;
+extern maplecl::Option<bool> timePhase;
+extern maplecl::Option<bool> genMeMpl;
+extern maplecl::Option<bool> compileWOLink;
+extern maplecl::Option<bool> genVtable;
+extern maplecl::Option<bool> verbose;
+extern maplecl::Option<bool> debug;
+extern maplecl::Option<bool> withDwarf;
+extern maplecl::Option<bool> withIpa;
+extern maplecl::Option<bool> npeNoCheck;
+extern maplecl::Option<bool> npeStaticCheck;
+extern maplecl::Option<bool> npeDynamicCheck;
+extern maplecl::Option<bool> npeDynamicCheckSilent;
+extern maplecl::Option<bool> npeDynamicCheckAll;
+extern maplecl::Option<bool> boundaryNoCheck;
+extern maplecl::Option<bool> boundaryStaticCheck;
+extern maplecl::Option<bool> boundaryDynamicCheck;
+extern maplecl::Option<bool> boundaryDynamicCheckSilent;
+extern maplecl::Option<bool> safeRegionOption;
+extern maplecl::Option<bool> printDriverPhases;
+extern maplecl::Option<bool> ldStatic;
+extern maplecl::Option<bool> maplePhase;
+extern maplecl::Option<bool> genMapleBC;
+extern maplecl::Option<bool> genLMBC;
+extern maplecl::Option<bool> profileGen;
+extern maplecl::Option<bool> profileUse;
+extern maplecl::Option<bool> stackProtectorStrong;
+extern maplecl::Option<bool> stackProtectorAll;
+extern maplecl::Option<bool> inlineAsWeak;
+
+/* ##################### STRING Options ############################################################### */
+
+extern maplecl::Option<std::string> help;
+extern maplecl::Option<std::string> infile;
+extern maplecl::Option<std::string> mplt;
+extern maplecl::Option<std::string> partO2;
+extern maplecl::List<std::string> jbc2mplOpt;
+extern maplecl::List<std::string> hir2mplOpt;
+extern maplecl::List<std::string> clangOpt;
+extern maplecl::List<std::string> asOpt;
+extern maplecl::List<std::string> ldOpt;
+extern maplecl::List<std::string> dex2mplOpt;
+extern maplecl::List<std::string> mplipaOpt;
+extern maplecl::List<std::string> mplcgOpt;
+extern maplecl::List<std::string> meOpt;
+extern maplecl::List<std::string> mpl2mplOpt;
+extern maplecl::Option<std::string> profile;
+extern maplecl::Option<std::string> run;
+extern maplecl::Option<std::string> optionOpt;
+extern maplecl::List<std::string> ldLib;
+extern maplecl::List<std::string> ldLibPath;
+extern maplecl::List<std::string> enableMacro;
+extern maplecl::List<std::string> disableMacro;
+extern maplecl::List<std::string> includeDir;
+extern maplecl::List<std::string> includeSystem;
+extern maplecl::Option<std::string> output;
+extern maplecl::Option<std::string> saveTempOpt;
+extern maplecl::Option<std::string> target;
+
+/* ##################### DIGITAL Options ############################################################### */
+
+extern maplecl::Option<uint32_t> helpLevel;
+
+/* #################################################################################################### */
+
+} /* opts */
+
+#endif /* MAPLE_DRIVER_INCLUDE_DRIVER_OPTIONS_H */
diff --git a/src/mapleall/maple_driver/include/driver_runner.h b/src/mapleall/maple_driver/include/driver_runner.h
new file mode 100644
index 0000000000000000000000000000000000000000..4eb40886088e31f32645113f545570badfc50cf3
--- /dev/null
+++ b/src/mapleall/maple_driver/include/driver_runner.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_DRIVER_INCLUDE_DRIVER_RUNNER_H
+#define MAPLE_DRIVER_INCLUDE_DRIVER_RUNNER_H
+
+#include <vector>
+#include <string>
+#include "me_option.h"
+#include "module_phase_manager.h"
+#include "error_code.h"
+#include "cg.h"
+#include "cg_option.h"
+#include "cg_phasemanager.h"
+#include "maple_phase_manager.h"
+namespace maple {
+using namespace maplebe;
+
+extern const std::string mplCG;
+extern const std::string mpl2Mpl;
+extern const std::string mplME;
+
+class DriverRunner final {
+ public:
+  DriverRunner(MIRModule *theModule, const std::vector<std::string> &exeNames, InputFileType inpFileType,
+               const std::string &mpl2mplInput, const std::string &meInput, const std::string &actualInput,
+               bool dwarf, bool fileParsed = false, bool timePhases = false,
+               bool genVtableImpl = false, bool genMeMpl = false, bool genMapleBC = false, bool genLMBC = false)
+      : theModule(theModule),
+        exeNames(exeNames),
+        mpl2mplInput(mpl2mplInput),
+        meInput(meInput),
+        actualInput(actualInput),
+        withDwarf(dwarf),
+        fileParsed(fileParsed),
+        timePhases(timePhases),
+        genVtableImpl(genVtableImpl),
+        genMeMpl(genMeMpl),
+        genMapleBC(genMapleBC),
+        genLMBC(genLMBC),
+        inputFileType(inpFileType) {
+    auto lastDot = actualInput.find_last_of(".");
+    baseName = (lastDot == std::string::npos) ? actualInput : actualInput.substr(0, lastDot);
+  }
+
+  DriverRunner(MIRModule *theModule, const std::vector<std::string> &exeNames, InputFileType inpFileType,
+               const std::string &actualInput, bool dwarf, bool fileParsed = false, bool timePhases = false,
+               bool genVtableImpl = false, bool genMeMpl = false, bool genMapleBC = false, bool genLMBC = false)
+      : DriverRunner(theModule, exeNames, inpFileType, "", "", actualInput, dwarf,
+                     fileParsed, timePhases, genVtableImpl, genMeMpl, genMapleBC, genLMBC) {
+    auto lastDot = actualInput.find_last_of(".");
+    baseName = (lastDot == std::string::npos) ? actualInput : actualInput.substr(0, lastDot);
+  }
+
+  ~DriverRunner() = default;
+
+  ErrorCode Run();
+  void RunNewPM(const std::string &output, const std::string &vtableImplFile);
+  void ProcessCGPhase(const std::string &output, const std::string &originBaseName) const;
+  void SetCGInfo(CGOptions *newCgOptions, const std::string &newCgInput) {
+    this->cgOptions = newCgOptions;
+    this->cgInput = newCgInput;
+  }
+  ErrorCode ParseInput() const;
+  ErrorCode ParseSrcLang(MIRSrcLang &srcLang) const;
+  void SolveCrossModuleInJava(MIRParser &parser) const;
+  void SolveCrossModuleInC(MIRParser &parser) const;
+  void SetPrintOutExe(const std::string outExe) {
+    printOutExe = outExe;
+  }
+
+  void SetMpl2mplOptions(Options *options) {
+    mpl2mplOptions = options;
+  }
+
+  void SetMeOptions(MeOption *options) {
+      meOptions = options;
+  }
+
+ private:
+  std::string GetPostfix();
+  void ProcessMpl2mplAndMePhases(const std::string &output, const std::string &vtableImplFile);
+  CGOptions *cgOptions = nullptr;
+  std::string cgInput;
+  void InitProfile() const;
+  MIRModule *theModule;
+  std::vector<std::string> exeNames = {};
+  Options *mpl2mplOptions = nullptr;
+  std::string mpl2mplInput;
+  MeOption *meOptions = nullptr;
+  std::string meInput;
+  std::string actualInput;
+  bool withDwarf = false;
+  bool fileParsed = false;
+  bool timePhases = false;
+  bool genVtableImpl = false;
+  bool genMeMpl = false;
+  bool genMapleBC = false;
+  bool genLMBC = false;
+  std::string printOutExe = "";
+  std::string baseName;
+  std::string outputFile;
+  InputFileType inputFileType;
+};
+}  // namespace maple
+
+#endif  // MAPLE_DRIVER_INCLUDE_DRIVER_RUNNER_H
diff --git a/src/mapleall/maple_driver/include/mpl_options.h b/src/mapleall/maple_driver/include/mpl_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..6422cd4acd7a555a1ad7f71b245b81285d151827
--- /dev/null
+++ b/src/mapleall/maple_driver/include/mpl_options.h
@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H
+#define MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H
+#include <iterator>
+#include <map>
+#include <set>
+#include <string>
+#include <tuple>
+#include <vector>
+#include <memory>
+#include <unordered_set>
+#include <unordered_map>
+#include "driver_options.h"
+#include "error_code.h"
+#include "file_utils.h"
+#include "mpl_logging.h"
+#include "mir_module.h"
+
+namespace maple {
+enum InputFileType {
+  kFileTypeNone,
+  kFileTypeClass,
+  kFileTypeJar,
+  kFileTypeAst,
+  kFileTypeCpp,
+  kFileTypeC,
+  kFileTypeDex,
+  kFileTypeMpl,
+  kFileTypeVtableImplMpl,
+  kFileTypeS,
+  kFileTypeObj,
+  kFileTypeBpl,
+  kFileTypeMeMpl,
+  kFileTypeMbc,
+  kFileTypeLmbc,
+};
+
+enum OptimizationLevel {
+  kO0,
+  kO1,
+  kO2,
+  kCLangO0,
+  kCLangO2,
+};
+
+enum RunMode {
+  kAutoRun,
+  kCustomRun,
+  kUnkownRun
+};
+
+enum SafetyCheckMode {
+  kNoCheck,
+  kStaticCheck,
+  kDynamicCheck,
+  kDynamicCheckSilent
+};
+
+class Compiler;
+
+class InputInfo {
+ public:
+  explicit InputInfo(const std::string &inputFile)
+      : inputFile(inputFile) {
+    inputFileType = GetInputFileType(inputFile);
+
+    inputName = FileUtils::GetFileName(inputFile, true);
+    inputFolder = FileUtils::GetFileFolder(inputFile);
+    outputFolder = inputFolder;
+    outputName = FileUtils::GetFileName(inputFile, false);
+    fullOutput = outputFolder + outputName;
+  }
+
+  ~InputInfo() = default;
+  static InputFileType GetInputFileType(const std::string &inputFilePath) {
+    InputFileType fileType = InputFileType::kFileTypeNone;
+    std::string extensionName = FileUtils::GetFileExtension(inputFilePath);
+    if (extensionName == "class") {
+      fileType = InputFileType::kFileTypeClass;
+    }
+    else if (extensionName == "dex") {
+      fileType = InputFileType::kFileTypeDex;
+    }
+    else if (extensionName == "c") {
+      fileType = InputFileType::kFileTypeC;
+    }
+    else if (extensionName == "cpp") {
+      fileType = InputFileType::kFileTypeCpp;
+    }
+    else if (extensionName == "ast") {
+      fileType = InputFileType::kFileTypeAst;
+    }
+    else if (extensionName == "jar") {
+      fileType = InputFileType::kFileTypeJar;
+    }
+    else if (extensionName == "mpl" || extensionName == "bpl") {
+      if (inputFilePath.find("VtableImpl") == std::string::npos) {
+        if (inputFilePath.find(".me.mpl") != std::string::npos) {
+          fileType = InputFileType::kFileTypeMeMpl;
+        } else {
+          fileType = extensionName == "mpl" ? InputFileType::kFileTypeMpl : InputFileType::kFileTypeBpl;
+        }
+      } else {
+        fileType = InputFileType::kFileTypeVtableImplMpl;
+      }
+    } else if (extensionName == "s") {
+      fileType = InputFileType::kFileTypeS;
+    } else if (extensionName == "o") {
+      fileType = InputFileType::kFileTypeObj;
+    } else if (extensionName == "mbc") {
+      fileType = InputFileType::kFileTypeMbc;
+    } else if (extensionName == "lmbc") {
+      fileType = InputFileType::kFileTypeLmbc;
+    }
+
+    return fileType;
+  }
+
+  InputFileType GetInputFileType() const {
+    return inputFileType;
+  }
+
+  const std::string &GetInputFile() const {
+    return inputFile;
+  }
+
+  const std::string &GetOutputFolder() const {
+    return outputFolder;
+  }
+
+  const std::string &GetOutputName() const {
+    return outputName;
+  }
+
+  const std::string &GetFullOutputName() const {
+    return fullOutput;
+  }
+
+ private:
+  std::string inputFile = "";
+  InputFileType inputFileType = InputFileType::kFileTypeNone;
+
+  std::string inputName = "";
+  std::string inputFolder = "";
+  std::string outputName = "";
+  std::string outputFolder = "";
+  std::string fullOutput = "";
+};
+
+class Action {
+ public:
+  Action(const std::string &tool, const InputInfo *const inputInfo)
+      : inputInfo(inputInfo), tool(tool) {}
+
+  Action(const std::string &tool, const InputInfo *const inputInfo,
+         std::unique_ptr<Action> &inAction)
+      : inputInfo(inputInfo), tool(tool)  {
+    inputActions.push_back(std::move(inAction));
+  }
+
+  Action(const std::string &tool, std::vector<std::unique_ptr<Action>> &inActions,
+         const InputInfo *const inputInfo)
+      : inputInfo(inputInfo), tool(tool)  {
+    for (auto &inAction : inActions) {
+      linkInputFiles.push_back(inAction->GetInputFile());
+    }
+
+    std::move(begin(inActions), end(inActions), std::back_inserter(inputActions));
+  }
+
+  ~Action() = default;
+
+  const std::string &GetTool() const {
+    return tool;
+  }
+
+  const std::string &GetInputFile() const {
+    return inputInfo->GetInputFile();
+  }
+
+  const std::string &GetOutputFolder() const {
+    return inputInfo->GetOutputFolder();
+  }
+
+  const std::string &GetOutputName() const {
+    return inputInfo->GetOutputName();
+  }
+
+  const std::string &GetFullOutputName() const {
+    return inputInfo->GetFullOutputName();
+  }
+
+  InputFileType GetInputFileType() const {
+    return inputInfo->GetInputFileType();
+  }
+
+  const std::vector<std::string> &GetLinkFiles() const {
+    return linkInputFiles;
+  }
+
+  const std::vector<std::unique_ptr<Action>> &GetInputActions() const {
+    return inputActions;
+  }
+
+  Compiler *GetCompiler() const {
+    return compilerTool;
+  }
+
+  void SetCompiler(Compiler *compiler) {
+    compilerTool = compiler;
+  }
+
+  bool IsItFirstRealAction() const {
+    /* First action is always "Input".
+     * But first real  action will be a tool from kMapleCompilers.
+     */
+    if (inputActions.size() > 0 && inputActions[0]->tool == "input") {
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  const InputInfo *inputInfo;
+
+  std::string tool = "";
+  std::string exeFolder = "";
+  std::vector<std::string> linkInputFiles;
+
+  Compiler *compilerTool = nullptr;
+
+  /* This vector contains a links to previous actions in Action tree */
+  std::vector<std::unique_ptr<Action>> inputActions;
+};
+
+class MplOption {
+ public:
+  MplOption(){needRootPath = false;}
+  MplOption(const std::string &key, const std::string &value, bool needRootPath = false)
+      : key(key),
+        value(value),
+        needRootPath(needRootPath) {
+    CHECK_FATAL(!key.empty(), "MplOption got an empty key.");
+  }
+
+  ~MplOption() = default;
+
+  const std::string &GetKey() const {
+    return key;
+  }
+
+  const std::string &GetValue() const {
+    return value;
+  }
+
+  void SetValue(std::string val) {
+    value = val;
+  }
+
+  void SetKey(const std::string &k) {
+    key = k;
+  }
+
+  bool GetNeedRootPath() const {
+    return needRootPath;
+  }
+
+ private:
+  // option key
+  std::string key;
+  // option value
+  std::string value;
+  bool needRootPath;
+};
+
+struct DefaultOption {
+  std::unique_ptr<MplOption[]> mplOptions;
+  uint32_t length = 0;
+};
+
+class MplOptions {
+ public:
+  using ExeOptMapType = std::unordered_map<std::string, std::deque<std::string>>;
+
+  MplOptions() = default;
+  MplOptions(const MplOptions &options) = delete;
+  MplOptions &operator=(const MplOptions &options) = delete;
+  ~MplOptions() = default;
+
+  ErrorCode Parse(int argc, char **argv);
+
+  const ExeOptMapType &GetExeOptions() const {
+    return exeOptions;
+  }
+
+  const std::vector<std::string> &GetInputFiles() const {
+    return inputFiles;
+  }
+
+  const std::string &GetExeFolder() const {
+    return exeFolder;
+  }
+
+  const RunMode &GetRunMode() const {
+    return runMode;
+  }
+
+  const std::vector<std::string> &GetSaveFiles() const {
+    return saveFiles;
+  }
+
+  const std::vector<std::string> &GetRunningExes() const {
+    return runningExes;
+  }
+
+  const std::vector<std::string> &GetSelectedExes() const {
+    return selectedExes;
+  }
+
+  bool HasSetGeneralRegOnly() const {
+    return generalRegOnly;
+  }
+
+  SafetyCheckMode GetNpeCheckMode() const {
+    return npeCheckMode;
+  }
+
+  SafetyCheckMode GetBoundaryCheckMode() const {
+    return boundaryCheckMode;
+  }
+
+  const std::vector<std::unique_ptr<Action>> &GetActions() const {
+    return rootActions;
+  }
+
+  maplecl::OptionCategory *GetCategory(const std::string &tool) const;
+  ErrorCode AppendCombOptions(MIRSrcLang srcLang);
+  ErrorCode AppendMplcgOptions(MIRSrcLang srcLang);
+  std::string GetInputFileNameForPrint(const Action * const action) const;
+  void PrintCommand(const Action * const action);
+  void ConnectOptStr(std::string &optionStr, const std::string &exeName, bool &firstComb, std::string &runStr);
+  std::string GetCommonOptionsStr() const;
+  void PrintDetailCommand(const Action * const action, bool isBeforeParse);
+  inline void PrintDetailCommand(bool isBeforeParse) {
+    PrintDetailCommand(nullptr, isBeforeParse);
+  }
+
+ private:
+  ErrorCode CheckInputFiles();
+  ErrorCode HandleOptions();
+  void HandleExtraOptions();
+  ErrorCode HandleEarlyOptions();
+  ErrorCode DecideRunningPhases();
+  ErrorCode DecideRunningPhases(const std::vector<std::string> &runExes);
+  std::unique_ptr<Action> DecideRunningPhasesByType(const InputInfo *const inputInfo, bool isMultipleFiles);
+  ErrorCode MFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
+                                const InputInfo *const inputInfo, bool &wasWrpCombCompilerCreated) const;
+  ErrorCode SFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
+                                const InputInfo *const inputInfo, bool &isCombCompiler) const;
+  InputInfo *AllocateInputInfo(const std::string &inputFile);
+  ErrorCode AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length);
+  void DumpAppendedOptions(const std::string &exeName,
+                           const MplOption mplOptions[], unsigned int length) const;
+  void UpdateRunningExe(const std::string &args);
+  void UpdateExeOptions(const std::string &options, const std::string &tool);
+  ErrorCode UpdateExeOptions(const std::string &args);
+  void DumpActionTree(const Action &action, int indents) const;
+  void DumpActionTree() const;
+
+  std::vector<std::string> inputFiles;
+  std::string exeFolder;
+  RunMode runMode = RunMode::kUnkownRun;
+  std::vector<std::string> saveFiles = {};
+  std::vector<std::string> runningExes = {};
+  std::vector<std::string> selectedExes = {};
+  std::ostringstream printExtraOptStr;
+
+  /* exeOptions is used to forward options to necessary tool.
+   * As example: --ld-opt="opt1 opt2" will be forwarded to linker */
+  ExeOptMapType exeOptions;
+
+  bool hasPrinted = false;
+  bool generalRegOnly = false;
+  SafetyCheckMode npeCheckMode = SafetyCheckMode::kNoCheck;
+  SafetyCheckMode boundaryCheckMode = SafetyCheckMode::kNoCheck;
+
+  std::vector<std::unique_ptr<InputInfo>> inputInfos;
+  std::vector<std::unique_ptr<Action>> rootActions;
+};
+
+enum Level {
+  kLevelZero = 0,
+  kLevelOne = 1,
+  kLevelTwo = 2,
+  kLevelThree = 3,
+  kLevelFour = 4
+};
+
+}  // namespace maple
+#endif  // MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H
diff --git a/src/mapleall/maple_driver/include/safe_exe.h b/src/mapleall/maple_driver/include/safe_exe.h
new file mode 100644
index 0000000000000000000000000000000000000000..28cfa4df2672a7e6d816f811a875d2c255a90742
--- /dev/null
+++ b/src/mapleall/maple_driver/include/safe_exe.h
@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_DRIVER_INCLUDE_SAFE_EXE_H
+#define MAPLE_DRIVER_INCLUDE_SAFE_EXE_H
+
+/* To start a new process for dex2mpl/mplipa, we need sys/wait on unix-like systems to
+ * make it complete. However, there is not a sys/wait.h for mingw, so we used createprocess
+ * in windows.h instead
+ */
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/wait.h>
+#endif
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <cstdlib>
+#include "error_code.h"
+#include "mpl_logging.h"
+#include "mpl_options.h"
+#include "string_utils.h"
+#include "securec.h"
+
+namespace maple {
+class SafeExe {
+ public:
+#ifndef _WIN32
+  static ErrorCode HandleCommand(const std::string &cmd, const std::string &args) {
+    std::vector<std::string> vectorArgs = ParseArgsVector(cmd, args);
+    // extra space for exe name and args
+    char **argv = new char *[vectorArgs.size() + 1];
+    // argv[0] is program name
+    // copy args
+    for (size_t j = 0; j < vectorArgs.size(); ++j) {
+      size_t strLength = vectorArgs[j].size();
+      argv[j] = new char[strLength + 1];
+      strncpy_s(argv[j], strLength + 1, vectorArgs[j].c_str(), strLength);
+      argv[j][strLength] = '\0';
+    }
+    // end of arguments sentinel is nullptr
+    argv[vectorArgs.size()] = nullptr;
+    pid_t pid = fork();
+    ErrorCode ret = kErrorNoError;
+    if (pid == 0) {
+      // child process
+      fflush(nullptr);
+      if (execv(cmd.c_str(), argv) < 0) {
+        for (size_t j = 0; j < vectorArgs.size(); ++j) {
+          delete [] argv[j];
+        }
+        delete [] argv;
+        exit(1);
+      }
+    } else {
+      // parent process
+      int status = -1;
+      waitpid(pid, &status, 0);
+      if (!WIFEXITED(status)) {
+        LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << " args: " << args << '\n';
+        ret = kErrorCompileFail;
+      } else if (WEXITSTATUS(status) != 0) {
+        LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << " args: " << args << '\n';
+        ret = kErrorCompileFail;
+      }
+    }
+
+    for (size_t j = 0; j < vectorArgs.size(); ++j) {
+      delete [] argv[j];
+    }
+    delete [] argv;
+    return ret;
+  }
+
+  static ErrorCode HandleCommand(const std::string &cmd,
+                                 const std::vector<MplOption> &options) {
+    size_t argIndex;
+    char **argv;
+    std::tie(argv, argIndex) = GenerateUnixArguments(cmd, options);
+
+    LogInfo::MapleLogger() << "Run: " << cmd;
+    for (auto &opt : options) {
+      LogInfo::MapleLogger() << " " << opt.GetKey() << " " << opt.GetValue();
+    }
+    LogInfo::MapleLogger() << "\n";
+
+    pid_t pid = fork();
+    ErrorCode ret = kErrorNoError;
+    if (pid == 0) {
+      // child process
+      fflush(nullptr);
+      if (execv(cmd.c_str(), argv) < 0) {
+        /* last argv[argIndex] is nullptr, so it's j < argIndex (NOT j <= argIndex) */
+        for (size_t j = 0; j < argIndex; ++j) {
+          delete [] argv[j];
+        }
+        delete [] argv;
+        exit(1);
+      }
+    } else {
+      // parent process
+      int status = -1;
+      waitpid(pid, &status, 0);
+      if (!WIFEXITED(status)) {
+        ret = kErrorCompileFail;
+      } else if (WEXITSTATUS(status) != 0) {
+        ret = kErrorCompileFail;
+      }
+
+      if (ret != kErrorNoError) {
+        LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << " args: ";
+        for (auto &opt : options) {
+          LogInfo::MapleLogger() << opt.GetKey() << " " << opt.GetValue();
+        }
+        LogInfo::MapleLogger() << "\n";
+      }
+    }
+
+    /* last argv[argIndex] is nullptr, so it's j < argIndex (NOT j <= argIndex) */
+    for (size_t j = 0; j < argIndex; ++j) {
+      delete [] argv[j];
+    }
+    delete [] argv;
+    return ret;
+  }
+#else
+  static ErrorCode HandleCommand(const std::string &cmd, const std::string &args) {
+    ErrorCode ret = ErrorCode::kErrorNoError;
+
+    STARTUPINFO startInfo;
+    PROCESS_INFORMATION pInfo;
+    DWORD exitCode;
+
+    errno_t retSafe = memset_s(&startInfo, sizeof(STARTUPINFO), 0, sizeof(STARTUPINFO));
+    CHECK_FATAL(retSafe == EOK, "memset_s for StartUpInfo failed when HandleComand");
+
+    startInfo.cb = sizeof(STARTUPINFO);
+
+    char* appName = strdup(cmd.c_str());
+    char* cmdLine = strdup(args.c_str());
+    CHECK_FATAL(appName != nullptr, "strdup for appName failed");
+    CHECK_FATAL(cmdLine != nullptr, "strdup for cmdLine failed");
+
+    bool success = CreateProcess(appName, cmdLine, NULL, NULL, FALSE,
+                                 NORMAL_PRIORITY_CLASS, NULL, NULL, &startInfo, &pInfo);
+    CHECK_FATAL(success != 0, "CreateProcess failed when HandleCommond");
+
+    WaitForSingleObject(pInfo.hProcess, INFINITE);
+    GetExitCodeProcess(pInfo.hProcess, &exitCode);
+
+    if (exitCode != 0) {
+      LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << " args: " << args
+                             << " exitCode: " << exitCode << '\n';
+      ret = ErrorCode::kErrorCompileFail;
+    }
+
+    free(appName);
+    free(cmdLine);
+    appName = nullptr;
+    cmdLine = nullptr;
+    return ret;
+  }
+
+  static ErrorCode HandleCommand(const std::string &cmd,
+                                 const std::vector<MplOption> &options) {
+    ErrorCode ret = ErrorCode::kErrorNoError;
+
+    STARTUPINFO startInfo;
+    PROCESS_INFORMATION pInfo;
+    DWORD exitCode;
+
+    errno_t retSafe = memset_s(&startInfo, sizeof(STARTUPINFO), 0, sizeof(STARTUPINFO));
+    CHECK_FATAL(retSafe == EOK, "memset_s for StartUpInfo failed when HandleComand");
+
+    startInfo.cb = sizeof(STARTUPINFO);\
+    std::string argString;
+    for (auto &opt : options) {
+      argString += opt.GetKey() + " " + opt.GetValue() + " ";
+    }
+
+    char* appName = strdup(cmd.c_str());
+    char* cmdLine = strdup(argString.c_str());
+    CHECK_FATAL(appName != nullptr, "strdup for appName failed");
+    CHECK_FATAL(cmdLine != nullptr, "strdup for cmdLine failed");
+
+    bool success = CreateProcess(appName, cmdLine, NULL, NULL, FALSE,
+                                 NORMAL_PRIORITY_CLASS, NULL, NULL, &startInfo, &pInfo);
+    CHECK_FATAL(success != 0, "CreateProcess failed when HandleCommond");
+
+    WaitForSingleObject(pInfo.hProcess, INFINITE);
+    GetExitCodeProcess(pInfo.hProcess, &exitCode);
+
+    if (exitCode != 0) {
+      LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << " args: " << argString
+                             << " exitCode: " << exitCode << '\n';
+      ret = ErrorCode::kErrorCompileFail;
+    }
+
+    free(appName);
+    free(cmdLine);
+    appName = nullptr;
+    cmdLine = nullptr;
+    return ret;
+  }
+#endif
+
+  static ErrorCode Exe(const std::string &cmd, const std::string &args) {
+    LogInfo::MapleLogger() << "Starting:" << cmd << args << '\n';
+    if (StringUtils::HasCommandInjectionChar(cmd) || StringUtils::HasCommandInjectionChar(args)) {
+      LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << " args: " << args << '\n';
+      return kErrorCompileFail;
+    }
+    ErrorCode ret = HandleCommand(cmd, args);
+    return ret;
+  }
+
+  static ErrorCode Exe(const std::string &cmd,
+                       const std::vector<MplOption> &options) {
+    if (StringUtils::HasCommandInjectionChar(cmd)) {
+      LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << '\n';
+      return kErrorCompileFail;
+    }
+    ErrorCode ret = HandleCommand(cmd, options);
+    return ret;
+  }
+
+ private:
+  static std::vector<std::string> ParseArgsVector(const std::string &cmd, const std::string &args) {
+    std::vector<std::string> tmpArgs;
+    StringUtils::Split(args, tmpArgs, ' ');
+    // remove ' ' in vector
+    for (auto iter = tmpArgs.begin(); iter != tmpArgs.end();) {
+      if (*iter == " " || *iter == "") {
+        iter = tmpArgs.erase(iter);
+      } else {
+        ++iter;
+      }
+    }
+    (void)tmpArgs.insert(tmpArgs.cbegin(), cmd);
+    return tmpArgs;
+  }
+
+  static std::tuple<char **, size_t> GenerateUnixArguments(const std::string &cmd,
+                                                        const std::vector<MplOption> &options) {
+    /* argSize=2, because we reserve 1st arg as exe binary, and another arg as last nullptr arg */
+    size_t argSize = 2;
+
+    /* Calculate how many args are needed.
+     * (* 2) is needed, because we have key and value arguments in each option
+     */
+    argSize += options.size() * 2;
+
+    /* extra space for exe name and args */
+    char **argv = new char *[argSize];
+
+    // argv[0] is program name
+    // copy args
+    auto cmdSize = cmd.size() + 1; // +1 for NUL terminal
+    argv[0] = new char[cmdSize];
+    strncpy_s(argv[0], cmdSize, cmd.c_str(), cmdSize); // c_str includes NUL terminal
+
+    /* Allocate and fill all arguments */
+    size_t argIndex = 1; // firts index is reserved for cmd, so it starts with 1
+    for (auto &opt : options) {
+      auto key = opt.GetKey();
+      auto val = opt.GetValue();
+      /* +1 for NUL terminal */
+      auto keySize = key.size() + 1;
+      auto valSize = val.size() + 1;
+
+      if (keySize != 1) {
+        argv[argIndex] = new char[keySize];
+        strncpy_s(argv[argIndex], keySize, key.c_str(), keySize);
+        ++argIndex;
+      }
+
+      if (valSize != 1) {
+        argv[argIndex] = new char[valSize];
+        strncpy_s(argv[argIndex], valSize, val.c_str(), valSize);
+        ++argIndex;
+      }
+    }
+
+    // end of arguments sentinel is nullptr
+    argv[argIndex] = nullptr;
+
+    return std::make_tuple(argv, argIndex);
+  }
+};
+} // namespace maple
+#endif // MAPLE_DRIVER_INCLUDE_SAFE_EXE_H
diff --git a/src/mapleall/maple_driver/include/triple.h b/src/mapleall/maple_driver/include/triple.h
new file mode 100644
index 0000000000000000000000000000000000000000..601025136ede63b26021244186a9cb6dc7230ce2
--- /dev/null
+++ b/src/mapleall/maple_driver/include/triple.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_TRIPLE_H
+#define MAPLE_TRIPLE_H
+
+#include <string_utils.h>
+#include <utils.h>
+
+#include <string>
+#include <string_view>
+
+namespace maple {
+
+class Triple {
+ public:
+  /* Currently, only aarch64 is supported */
+  enum ArchType {
+    UnknownArch,
+    aarch64,
+    aarch64_be,
+    LastArchType
+  };
+
+  /* Currently, only ILP32 and LP64 are supported */
+  enum EnvironmentType {
+    UnknownEnvironment,
+    GNU,
+    GNUILP32,
+    LastEnvironmentType
+  };
+
+  ArchType GetArch() const { return arch; }
+  EnvironmentType GetEnvironment() const { return environment; }
+
+  bool IsBigEndian() const {
+    return (GetArch() == ArchType::aarch64_be);
+  }
+
+  std::string Str() const;
+  std::string GetArchName() const;
+  std::string GetEnvironmentName() const;
+
+  static Triple &GetTriple() {
+    static Triple triple;
+    return triple;
+  }
+  Triple(const Triple &) = delete;
+  Triple &operator=(const Triple &) = delete;
+
+  void Init(const std::string &target);
+  void Init();
+
+ private:
+  std::string data;
+  ArchType arch;
+  EnvironmentType environment;
+
+  Triple() : arch(UnknownArch), environment(UnknownEnvironment) {}
+
+  Triple::ArchType ParseArch(std::string_view archStr) const;
+  Triple::EnvironmentType ParseEnvironment(std::string_view archStr) const;
+};
+
+} // namespace maple
+
+#endif /* MAPLE_TRIPLE_H */
diff --git a/src/mapleall/maple_driver/src/as_compiler.cpp b/src/mapleall/maple_driver/src/as_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..599471adeebce3ecf23793b6f299e1c6766b6795
--- /dev/null
+++ b/src/mapleall/maple_driver/src/as_compiler.cpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler.h"
+#include "file_utils.h"
+#include "triple.h"
+#include "default_options.def"
+
+namespace maple {
+static const std::string kAarch64BeIlp32As = "aarch64_be-linux-gnuilp32-as";
+static const std::string kAarch64BeAs = "aarch64_be-linux-gnu-as";
+
+std::string AsCompilerBeILP32::GetBinPath(const MplOptions &mplOptions [[maybe_unused]]) const {
+  std::string gccPath = FileUtils::SafeGetenv(kGccBePathEnv) + "/";
+  const std::string &gccTool = Triple::GetTriple().GetEnvironment() == Triple::EnvironmentType::GNUILP32 ?
+                               kAarch64BeIlp32As : kAarch64BeAs;
+  std::string gccToolPath = gccPath + gccTool;
+
+  if (!FileUtils::IsFileExists(gccToolPath)) {
+    LogInfo::MapleLogger(kLlErr) << kGccBePathEnv << " environment variable must be set as the path to "
+                                 << gccTool << "\n";
+    CHECK_FATAL(false, "%s environment variable must be set as the path to %s\n",
+                kGccBePathEnv, gccTool.c_str());
+  }
+
+  return gccPath;
+}
+
+const std::string &AsCompilerBeILP32::GetBinName() const {
+  if (Triple::GetTriple().GetEnvironment() == Triple::EnvironmentType::GNUILP32) {
+    return kAarch64BeIlp32As;
+  } else {
+    return kAarch64BeAs;
+  }
+}
+
+DefaultOption AsCompilerBeILP32::GetDefaultOptions(const MplOptions &options, const Action &action) const {
+  auto &triple = Triple::GetTriple();
+  if (triple.GetArch() != Triple::ArchType::aarch64_be ||
+      triple.GetEnvironment() == Triple::EnvironmentType::UnknownEnvironment) {
+    CHECK_FATAL(false, "ClangCompilerBeILP32 supports only aarch64_be GNU/GNUILP32 targets\n");
+  }
+
+  uint32_t len = 1; // for -o option
+  if (triple.GetEnvironment() == Triple::EnvironmentType::GNUILP32) {
+    ++len; // for -mabi=ilp32
+  }
+  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
+
+  defaultOptions.mplOptions[0].SetKey("-o");
+  defaultOptions.mplOptions[0].SetValue(action.GetFullOutputName() + ".o");
+
+  if (triple.GetEnvironment() == Triple::EnvironmentType::GNUILP32) {
+    defaultOptions.mplOptions[1].SetKey("-mabi=ilp32");
+    defaultOptions.mplOptions[1].SetValue("");
+  }
+
+  return defaultOptions;
+}
+
+std::string AsCompiler::GetBinPath(const MplOptions &mplOptions [[maybe_unused]]) const {
+#ifdef ANDROID
+  return "prebuilts/gcc/linux-x86/aarch64/aarch64-linux-android-4.9/bin/";
+#else
+  return FileUtils::SafeGetenv(kMapleRoot) + "/tools/bin/";
+#endif
+}
+
+const std::string &AsCompiler::GetBinName() const {
+  return kBinNameAs;
+}
+
+/* the tool name must be the same as exeName field in Descriptor structure */
+const std::string &AsCompiler::GetTool() const {
+  return kAsFlag;
+}
+
+DefaultOption AsCompiler::GetDefaultOptions(const MplOptions &options, const Action &action) const {
+  uint32_t len = 1; // for -o option
+  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
+
+  defaultOptions.mplOptions[0].SetKey("-o");
+  defaultOptions.mplOptions[0].SetValue(action.GetFullOutputName() + ".o");
+
+  return defaultOptions;
+}
+
+std::string AsCompiler::GetInputFileName(const MplOptions &options [[maybe_unused]], const Action &action) const {
+  return action.GetFullOutputName() + ".s";
+}
+
+void AsCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions [[maybe_unused]], const Action &action,
+                                     std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".o");
+}
+
+std::unordered_set<std::string> AsCompiler::GetFinalOutputs(const MplOptions &mplOptions [[maybe_unused]],
+                                                            const Action &action) const {
+  auto finalOutputs = std::unordered_set<std::string>();
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".o");
+  return finalOutputs;
+}
+
+void AsCompiler::AppendOutputOption(std::vector<MplOption> &finalOptions,
+                                    const std::string &name) const {
+  (void)finalOptions.emplace_back("-o", name);
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/clang_compiler.cpp b/src/mapleall/maple_driver/src/clang_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dcc81219df10a073996f0f5e2a6930270758b579
--- /dev/null
+++ b/src/mapleall/maple_driver/src/clang_compiler.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <cstdint>
+#include <cstdlib>
+#include <memory>
+#include "compiler.h"
+#include "file_utils.h"
+#include "mpl_timer.h"
+#include "triple.h"
+#include "default_options.def"
+
+namespace maple {
+
+DefaultOption ClangCompilerBeILP32::GetDefaultOptions(const MplOptions &options,
+                                                      const Action &action) const {
+  auto &triple = Triple::GetTriple();
+  if (triple.GetArch() != Triple::ArchType::aarch64_be ||
+      triple.GetEnvironment() == Triple::EnvironmentType::UnknownEnvironment) {
+    CHECK_FATAL(false, "ClangCompilerBeILP32 supports only aarch64_be GNU/GNUILP32 targets\n");
+  }
+
+  uint32_t additionalLen = 4; // -o and --target
+  uint32_t fullLen = (sizeof(kClangDefaultOptions) / sizeof(MplOption)) + additionalLen;
+  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(fullLen), fullLen };
+
+  defaultOptions.mplOptions[0].SetKey("-o");
+  defaultOptions.mplOptions[0].SetValue(action.GetFullOutputName() + ".ast");
+
+  defaultOptions.mplOptions[1].SetKey("-target");
+  defaultOptions.mplOptions[1].SetValue(triple.Str());
+
+  if (triple.GetEnvironment() == Triple::EnvironmentType::GNUILP32) {
+    defaultOptions.mplOptions[2].SetKey("--sysroot=" + FileUtils::SafeGetenv(kGccBeIlp32SysrootPathEnv));
+  } else {
+    defaultOptions.mplOptions[2].SetKey("--sysroot=" + FileUtils::SafeGetenv(kGccBeSysrootPathEnv));
+  }
+  defaultOptions.mplOptions[2].SetValue("");
+
+  defaultOptions.mplOptions[3].SetKey("-U__SIZEOF_INT128__");
+  defaultOptions.mplOptions[3].SetValue("");
+
+  for (uint32_t i = additionalLen, j = 0; i < fullLen; ++i, ++j) {
+    defaultOptions.mplOptions[i] = kClangDefaultOptions[j];
+  }
+  for (uint32_t i = additionalLen; i < fullLen; ++i) {
+    defaultOptions.mplOptions[i].SetValue(
+        FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
+                                           defaultOptions.mplOptions[i].GetValue(),
+                                           options.GetExeFolder()));
+  }
+
+  return defaultOptions;
+}
+
+std::string ClangCompiler::GetBinPath(const MplOptions &mplOptions [[maybe_unused]]) const {
+  return FileUtils::SafeGetenv(kMapleRoot) + "/tools/bin/";
+}
+
+const std::string &ClangCompiler::GetBinName() const {
+  return kBinNameClang;
+}
+
+static uint32_t FillSpecialDefaulOpt(std::unique_ptr<MplOption[]> &opt,
+                                     const Action &action) {
+  uint32_t additionalLen = 1; // for -o option
+
+  auto &triple = Triple::GetTriple();
+  if (triple.GetArch() != Triple::ArchType::aarch64 ||
+      triple.GetEnvironment() != Triple::EnvironmentType::GNU) {
+    CHECK_FATAL(false, "Use -target option to select another toolchain\n");
+  }
+
+  additionalLen += 3; // 3 options are filled below
+  opt = std::make_unique<MplOption[]>(additionalLen);
+
+  opt[0].SetKey("-isystem");
+  opt[0].SetValue(FileUtils::SafeGetenv(kMapleRoot) +
+                  "/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include");
+
+  opt[1].SetKey("-isystem");
+  opt[1].SetValue(FileUtils::SafeGetenv(kMapleRoot) +
+                  "/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include");
+
+  opt[2].SetKey("-target");
+  opt[2].SetValue(triple.Str());
+
+  /* Set last option as -o option */
+  opt[additionalLen - 1].SetKey("-o");
+  opt[additionalLen - 1].SetValue(action.GetFullOutputName() + ".ast");
+
+  return additionalLen;
+}
+
+DefaultOption ClangCompiler::GetDefaultOptions(const MplOptions &options, const Action &action) const {
+  DefaultOption defaultOptions;
+  uint32_t fullLen = 0;
+  uint32_t defaultLen = 0;
+  uint32_t additionalLen = 0;
+  std::unique_ptr<MplOption[]> additionalOptions;
+
+  additionalLen = FillSpecialDefaulOpt(additionalOptions, action);
+  defaultLen = sizeof(kClangDefaultOptions) / sizeof(MplOption);
+  fullLen = defaultLen + additionalLen;
+
+  defaultOptions = { std::make_unique<MplOption[]>(fullLen), fullLen };
+
+  for (uint32_t i = 0; i < defaultLen; ++i) {
+    defaultOptions.mplOptions[i] = kClangDefaultOptions[i];
+  }
+  for (uint32_t defInd = defaultLen, additionalInd = 0;
+       additionalInd < additionalLen; ++additionalInd) {
+    defaultOptions.mplOptions[defInd++] = additionalOptions[additionalInd];
+  }
+
+  for (uint32_t i = 0; i < defaultOptions.length; ++i) {
+    defaultOptions.mplOptions[i].SetValue(
+        FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
+                                           defaultOptions.mplOptions[i].GetValue(),
+                                           options.GetExeFolder()));
+  }
+  return defaultOptions;
+}
+
+void ClangCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions [[maybe_unused]], const Action &action,
+                                        std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".ast");
+}
+
+std::unordered_set<std::string> ClangCompiler::GetFinalOutputs(const MplOptions &mplOptions [[maybe_unused]],
+                                                               const Action &action) const {
+  std::unordered_set<std::string> finalOutputs;
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".ast");
+  return finalOutputs;
+}
+
+void ClangCompiler::AppendOutputOption(std::vector<MplOption> &finalOptions,
+                                       const std::string &name) const {
+  (void)finalOptions.emplace_back("-o", name);
+}
+
+}
diff --git a/src/mapleall/maple_driver/src/compiler.cpp b/src/mapleall/maple_driver/src/compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1d7befe40713ced5c30ddc0ada227d48caa1efb9
--- /dev/null
+++ b/src/mapleall/maple_driver/src/compiler.cpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler.h"
+#include "driver_options.h"
+#include "file_utils.h"
+#include "safe_exe.h"
+#include "mpl_timer.h"
+
+namespace maple {
+
+int Compiler::Exe(const MplOptions &mplOptions,
+                  const std::vector<MplOption> &options) const {
+  std::ostringstream ostrStream;
+  ostrStream << GetBinPath(mplOptions) << GetBinName();
+  std::string binPath = ostrStream.str();
+  return SafeExe::Exe(binPath, options);
+}
+
+std::string Compiler::GetBinPath(const MplOptions &mplOptions) const {
+#ifdef MAPLE_PRODUCT_EXECUTABLE  // build flag -DMAPLE_PRODUCT_EXECUTABLE
+  std::string binPath = std::string(MAPLE_PRODUCT_EXECUTABLE);
+  if (binPath.empty()) {
+    binPath = mplOptions.GetExeFolder();
+  } else {
+    binPath = binPath + kFileSeperatorChar;
+  }
+#else
+  std::string binPath = mplOptions.GetExeFolder();
+#endif
+  return binPath;
+}
+
+ErrorCode Compiler::Compile(MplOptions &options, const Action &action,
+                            std::unique_ptr<MIRModule> &theModule [[maybe_unused]]) {
+  MPLTimer timer = MPLTimer();
+  LogInfo::MapleLogger() << "Starting " << GetName() << '\n';
+  timer.Start();
+
+  std::vector<MplOption> generatedOptions = MakeOption(options, action);
+  if (generatedOptions.empty()) {
+    return kErrorInvalidParameter;
+  }
+  if (Exe(options, generatedOptions) != 0) {
+    return kErrorCompileFail;
+  }
+  timer.Stop();
+  LogInfo::MapleLogger() << (GetName() + " consumed ") << timer.Elapsed() << "s\n";
+  return kErrorNoError;
+}
+
+std::vector<MplOption> Compiler::MakeOption(const MplOptions &options,
+                                            const Action &action) const {
+  std::vector<MplOption> finalOptions;
+  std::vector<MplOption> defaultOptions = MakeDefaultOptions(options, action);
+
+  AppendInputsAsOptions(finalOptions, options, action);
+  AppendDefaultOptions(finalOptions, defaultOptions, opts::debug);
+  AppendExtraOptions(finalOptions, options, opts::debug, action);
+
+  return finalOptions;
+}
+
+void Compiler::AppendDefaultOptions(std::vector<MplOption> &finalOptions,
+                                    const std::vector<MplOption> &defaultOptions,
+                                    bool isDebug) const {
+  for (const auto &defaultIt : defaultOptions) {
+    finalOptions.push_back(defaultIt);
+  }
+
+  if (isDebug) {
+    LogInfo::MapleLogger() << Compiler::GetName() << " Default Options: ";
+    for (const auto &defaultIt : defaultOptions) {
+      LogInfo::MapleLogger() << defaultIt.GetKey() << " "
+                             << defaultIt.GetValue();
+    }
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+void Compiler::AppendExtraOptions(std::vector<MplOption> &finalOptions, const MplOptions &options,
+                                  bool isDebug, const Action &action) const {
+  const std::string &binName = GetTool();
+
+  if (isDebug) {
+    LogInfo::MapleLogger() << Compiler::GetName() << " Extra Options: ";
+  }
+
+  /* Append options setting by: --run=binName --option="-opt1 -opt2" */
+  auto &exeOptions = options.GetExeOptions();
+  auto it = exeOptions.find(binName);
+  if (it != exeOptions.end()) {
+    for (auto &opt : it->second) {
+      (void)finalOptions.emplace_back(opt, "");
+      if (isDebug) {
+        LogInfo::MapleLogger() << opt << " ";
+      }
+    }
+  }
+
+  maplecl::OptionCategory *category = options.GetCategory(binName);
+  ASSERT(category != nullptr, "Undefined tool: %s", binName.data());
+
+  /* Append options setting directly for special category. Example: --verbose */
+  for (const auto &opt : category->GetEnabledOptions()) {
+    for (const auto &val : opt->GetRawValues()) {
+      if (opt->GetEqualType() == maplecl::EqualType::kWithEqual) {
+        (void)finalOptions.emplace_back(opt->GetName() + "=" + val, "");
+      } else {
+        (void)finalOptions.emplace_back(opt->GetName(), val);
+      }
+
+      if (isDebug) {
+        LogInfo::MapleLogger() << opt->GetName() << " " << val << " ";
+      }
+    }
+  }
+
+  /* output file can not be specified for several last actions. As exaple:
+   * If last actions are assembly tool for 2 files (to get file1.o, file2.o),
+   * we can not have one output name for them. */
+  if (opts::output.IsEnabledByUser() && options.GetActions().size() == 1) {
+    /* Set output file for last compilation tool */
+    if (&action == options.GetActions()[0].get()) {
+      /* the tool may not support "-o" for output option */
+      AppendOutputOption(finalOptions, opts::output.GetValue());
+    }
+  }
+
+  if (isDebug) {
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+void Compiler::ReplaceOrInsertOption(std::vector<MplOption> &finalOptions,
+                                     const std::string &key, const std::string &value) const {
+  bool wasFound = false;
+  for (auto &opt : finalOptions) {
+    if (opt.GetKey() == key) {
+      opt.SetValue(value);
+      wasFound = true;
+    }
+  }
+
+  if (!wasFound) {
+    (void)finalOptions.emplace_back(MplOption(key, value));
+  }
+}
+
+void Compiler::AppendInputsAsOptions(std::vector<MplOption> &finalOptions,
+                                     const MplOptions &mplOptions, const Action &action) const {
+  std::vector<std::string> splittedInputFileNames;
+  std::string inputFileNames = GetInputFileName(mplOptions, action);
+  StringUtils::Split(inputFileNames, splittedInputFileNames, ' ');
+
+  for (auto &inputFileName : splittedInputFileNames) {
+    finalOptions.emplace_back(MplOption(inputFileName, ""));
+  }
+}
+
+std::vector<MplOption> Compiler::MakeDefaultOptions(const MplOptions &options,
+                                                    const Action &action) const {
+  DefaultOption rawDefaultOptions = GetDefaultOptions(options, action);
+  std::vector<MplOption> defaultOptions;
+  if (rawDefaultOptions.mplOptions != nullptr) {
+    for (uint32_t i = 0; i < rawDefaultOptions.length; ++i) {
+      defaultOptions.push_back(rawDefaultOptions.mplOptions[i]);
+    }
+  }
+  return defaultOptions;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/compiler_factory.cpp b/src/mapleall/maple_driver/src/compiler_factory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1deec2920d56b6cb6adf4d18ee4a19910d6a6d3a
--- /dev/null
+++ b/src/mapleall/maple_driver/src/compiler_factory.cpp
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler_factory.h"
+#include <regex>
+#include "driver_options.h"
+#include "file_utils.h"
+#include "string_utils.h"
+#include "mpl_logging.h"
+
+using namespace maple;
+
+CompilerFactory &CompilerFactory::GetInstance() {
+  static CompilerFactory instance;
+  return instance;
+}
+
+ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions,
+                                          const std::vector<std::string> &tempFiles) const {
+  int ret = 0;
+  for (const std::string &tmpFile : tempFiles) {
+    bool isSave = false;
+    for (auto saveFile : mplOptions.GetSaveFiles()) {
+      if (!saveFile.empty() && std::regex_match(tmpFile, std::regex(StringUtils::Replace(saveFile, "*", ".*?")))) {
+        isSave = true;
+        break;
+      }
+    }
+
+    auto &inputs = mplOptions.GetInputFiles();
+    if (!isSave && (std::find(inputs.begin(), inputs.end(), tmpFile) == inputs.end())) {
+      bool isNeedRemove = true;
+      /* If we compile several files we can have several last Actions,
+       * so we need to NOT remove output files for each last Action.
+       */
+      for (auto &lastAction : mplOptions.GetActions()) {
+        auto finalOutputs = lastAction->GetCompiler()->GetFinalOutputs(mplOptions, *lastAction);
+        /* do not remove output files */
+        if (finalOutputs.find(tmpFile) != finalOutputs.end()) {
+          isNeedRemove = false;
+        }
+      }
+
+      if (isNeedRemove) {
+        (void)FileUtils::Remove(tmpFile);
+      }
+    }
+  }
+  return ret == 0 ? kErrorNoError : kErrorFileNotFound;
+}
+
+Toolchain *CompilerFactory::GetToolChain() {
+  if (toolchain == nullptr) {
+    if (maple::Triple::GetTriple().GetArch() == Triple::ArchType::aarch64_be) {
+      toolchain = std::make_unique<Aarch64BeILP32Toolchain>();
+    } else {
+      toolchain = std::make_unique<Aarch64Toolchain>();
+    }
+  }
+
+  return toolchain.get();
+}
+
+ErrorCode CompilerFactory::Select(Action &action, std::vector<Action*> &selectedActions) {
+  ErrorCode ret = kErrorNoError;
+
+  /* Traverse Action tree recursively and select compilers in
+   * "from leaf(clang) to root(ld)" order */
+  for (const std::unique_ptr<Action> &a : action.GetInputActions()) {
+    if (a == nullptr) {
+      LogInfo::MapleLogger(kLlErr) << "Action is not Initialized\n";
+      return kErrorToolNotFound;
+    }
+
+    ret = Select(*a, selectedActions);
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  }
+
+  Toolchain *toolChain = GetToolChain();
+  if (toolChain == nullptr) {
+    LogInfo::MapleLogger(kLlErr) << "Wrong ToolChain\n";
+    return kErrorToolNotFound;
+  }
+  Compiler *compiler = toolChain->Find(action.GetTool());
+
+  if (compiler == nullptr) {
+    if (action.GetTool() != "input") {
+      LogInfo::MapleLogger(kLlErr) << "Fatal error: " <<  action.GetTool()
+                                   << " tool is not supported" << "\n";
+      LogInfo::MapleLogger(kLlErr) << "Supported Tool: ";
+
+      auto print = [](const auto &supportedComp) { std::cout << " " << supportedComp.first; };
+      (void)std::for_each(toolChain->GetSupportedCompilers().begin(),
+                          toolChain->GetSupportedCompilers().end(), print);
+      LogInfo::MapleLogger(kLlErr) << "\n";
+
+      return kErrorToolNotFound;
+    }
+  } else {
+    action.SetCompiler(compiler);
+    selectedActions.push_back(&action);
+  }
+
+  return ret;
+}
+
+ErrorCode CompilerFactory::Select(const MplOptions &mplOptions, std::vector<Action*> &selectedActions) {
+  for (const std::unique_ptr<Action> &action : mplOptions.GetActions()) {
+    if (action == nullptr) {
+      LogInfo::MapleLogger(kLlErr) << "Action is not Initialized\n";
+      return kErrorToolNotFound;
+    }
+    ErrorCode ret = Select(*action, selectedActions);
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  }
+
+  return selectedActions.empty() ? kErrorToolNotFound : kErrorNoError;
+}
+
+ErrorCode CompilerFactory::Compile(MplOptions &mplOptions) {
+  if (compileFinished) {
+    LogInfo::MapleLogger() <<
+        "Failed! Compilation has been completed in previous time and multi-instance compilation is not supported\n";
+    return kErrorCompileFail;
+  }
+
+  /* Actions owner is MplOption, so while MplOption is alive we can use raw pointers here */
+  std::vector<Action*> actions;
+  ErrorCode ret = Select(mplOptions, actions);
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  for (auto *action : actions) {
+    if (action == nullptr) {
+      LogInfo::MapleLogger() << "Failed! Compiler is null." << "\n";
+      return kErrorCompileFail;
+    }
+
+    Compiler *compiler = action->GetCompiler();
+    if (compiler == nullptr) {
+      return kErrorToolNotFound;
+    }
+
+    ret = compiler->Compile(mplOptions, *action, this->theModule);
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  }
+  if (opts::debug) {
+    mplOptions.PrintDetailCommand(false);
+  }
+  // Compiler finished
+  compileFinished = true;
+
+  if (!opts::saveTempOpt.IsEnabledByUser() || !mplOptions.GetSaveFiles().empty()) {
+    std::vector<std::string> tmpFiles;
+
+    for (auto *action : actions) {
+      action->GetCompiler()->GetTmpFilesToDelete(mplOptions, *action, tmpFiles);
+    }
+
+    ret = DeleteTmpFiles(mplOptions, tmpFiles);
+  }
+  return ret;
+}
diff --git a/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp b/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..501e88a0b794f9548d515dadfd1767f1b88ee874
--- /dev/null
+++ b/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler.h"
+#include "file_utils.h"
+#include "mpl_logging.h"
+#include "default_options.def"
+
+namespace maple {
+std::string Cpp2MplCompiler::GetBinPath(const MplOptions &mplOptions [[maybe_unused]]) const{
+  return FileUtils::SafeGetenv(kMapleRoot) + "/output/" +
+      FileUtils::SafeGetenv("MAPLE_BUILD_TYPE") + "/bin/";
+}
+
+const std::string &Cpp2MplCompiler::GetBinName() const {
+  return kBinNameCpp2mpl;
+}
+
+std::string Cpp2MplCompiler::GetInputFileName(const MplOptions &options [[maybe_unused]], const Action &action) const {
+  if (action.IsItFirstRealAction()) {
+    return action.GetInputFile();
+  }
+  // Get base file name
+  auto idx = action.GetOutputName().find(".ast");
+  std::string outputName = action.GetOutputName();
+  if (idx != std::string::npos) {
+    outputName = action.GetOutputName().substr(0, idx);
+  }
+  return action.GetOutputFolder() + outputName + ".ast";
+}
+
+DefaultOption Cpp2MplCompiler::GetDefaultOptions(const MplOptions &options,
+                                                 const Action &action [[maybe_unused]]) const {
+  uint32_t len = sizeof(kCpp2MplDefaultOptionsForAst) / sizeof(MplOption);
+  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
+
+  for (uint32_t i = 0; i < len; ++i) {
+    defaultOptions.mplOptions[i] = kCpp2MplDefaultOptionsForAst[i];
+  }
+
+  for (uint32_t i = 0; i < defaultOptions.length; ++i) {
+    defaultOptions.mplOptions[i].SetValue(
+        FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
+                                           defaultOptions.mplOptions[i].GetValue(),
+                                           options.GetExeFolder()));
+    }
+    return defaultOptions;
+}
+
+void Cpp2MplCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions [[maybe_unused]], const Action &action,
+                                          std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".mpl");
+  tempFiles.push_back(action.GetFullOutputName() + ".mplt");
+}
+
+std::unordered_set<std::string> Cpp2MplCompiler::GetFinalOutputs(const MplOptions &mplOptions [[maybe_unused]],
+                                                                 const Action &action) const {
+  std::unordered_set<std::string> finalOutputs;
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mpl");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mplt");
+  return finalOutputs;
+}
+
+void Cpp2MplCompiler::AppendOutputOption(std::vector<MplOption> &finalOptions,
+                                         const std::string &name) const {
+  (void)finalOptions.emplace_back("-o", name);
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp b/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a9c7bf1536ed3ff7ce4ec97bf2fbecc52aa8397b
--- /dev/null
+++ b/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <memory>
+#include "compiler.h"
+#include "default_options.def"
+#ifdef INTERGRATE_DRIVER
+#include "dex2mpl_runner.h"
+#include "mir_function.h"
+#endif
+
+namespace maple {
+const std::string &Dex2MplCompiler::GetBinName() const {
+  return kBinNameDex2mpl;
+}
+
+DefaultOption Dex2MplCompiler::GetDefaultOptions(const MplOptions &options,
+                                                 const Action &action [[maybe_unused]]) const {
+  uint32_t len = 0;
+  MplOption *kDex2mplDefaultOptions = nullptr;
+
+  if (opts::o0) {
+    len = sizeof(kDex2mplDefaultOptionsO0) / sizeof(MplOption);
+    kDex2mplDefaultOptions = kDex2mplDefaultOptionsO0;
+  } else if (opts::o2) {
+    len = sizeof(kDex2mplDefaultOptionsO2) / sizeof(MplOption);
+    kDex2mplDefaultOptions = kDex2mplDefaultOptionsO2;
+  }
+
+  if (kDex2mplDefaultOptions == nullptr) {
+    return DefaultOption();
+  }
+
+  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
+  for (uint32_t i = 0; i < len; ++i) {
+    defaultOptions.mplOptions[i] = kDex2mplDefaultOptions[i];
+  }
+
+  for (unsigned int i = 0; i < defaultOptions.length; ++i) {
+    defaultOptions.mplOptions[i].SetValue(
+        FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
+                                           defaultOptions.mplOptions[i].GetValue(),
+                                           options.GetExeFolder()));
+  }
+  return defaultOptions;
+}
+
+void Dex2MplCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions [[maybe_unused]], const Action &action,
+                                          std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".mpl");
+  tempFiles.push_back(action.GetFullOutputName() + ".mplt");
+}
+
+std::unordered_set<std::string> Dex2MplCompiler::GetFinalOutputs(const MplOptions &mplOptions [[maybe_unused]],
+                                                                 const Action &action) const {
+  auto finalOutputs = std::unordered_set<std::string>();
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mpl");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mplt");
+  return finalOutputs;
+}
+
+#ifdef INTERGRATE_DRIVER
+void Dex2MplCompiler::PostDex2Mpl(std::unique_ptr<MIRModule> &theModule) const {
+  // for each function
+  for (auto *func : theModule->GetFunctionList()) {
+    if (func == nullptr) {
+      continue;
+    }
+
+    MIRSymbolTable *symTab = func->GetSymTab();
+    // for each symbol
+    for (size_t i = 0; i != symTab->GetSymbolTableSize(); ++i) {
+      MIRSymbol *currSymbol = symTab->GetSymbolFromStIdx(i);
+      if (currSymbol == nullptr) {
+        continue;
+      }
+      // (1) replace void ptr with void ref
+      if (theModule->IsJavaModule() && currSymbol->GetType() == GlobalTables::GetTypeTable().GetVoidPtr()) {
+        MIRType *voidRef = GlobalTables::GetTypeTable().GetOrCreatePointerType(
+            *GlobalTables::GetTypeTable().GetVoid(), PTY_ref);
+        currSymbol->SetTyIdx(voidRef->GetTypeIndex());
+      }
+      // (2) replace String ref with String ptr if symbol's name starts with "L_STR"
+      if (currSymbol->GetType()->GetKind() == kTypePointer && currSymbol->GetName().find("L_STR") == 0) {
+        MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(currSymbol->GetTyIdx());
+        auto *ptrTy = static_cast<MIRPtrType *>(ty->CopyMIRTypeNode());
+        ASSERT(ptrTy != nullptr, "null ptr check");
+        ptrTy->SetPrimType(PTY_ptr);
+        TyIdx newTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(ptrTy);
+        delete ptrTy;
+        currSymbol->SetTyIdx(newTyIdx);
+      }
+    }
+
+    // (3) reset pregIndex of pregTab if function has body
+    if (func->GetBody() != nullptr) {
+      uint32 maxPregNo = 0;
+      for (uint32 i = 0; i < func->GetFormalCount(); ++i) {
+        MIRSymbol *formalSt = func->GetFormal(i);
+        if (formalSt->IsPreg()) {
+          // no special register appears in the formals
+          uint32 pRegNo = static_cast<uint32>(formalSt->GetPreg()->GetPregNo());
+          if (pRegNo > maxPregNo) {
+            maxPregNo = pRegNo;
+          }
+        }
+      }
+      if (func->GetPregTab() == nullptr) {
+        continue;
+      }
+      func->GetPregTab()->SetIndex(maxPregNo + 1);
+    }
+  }
+
+  // (4) fix unmatched MIRConst type of global symbols
+  for (size_t i = 0; i != GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
+    if (symbol == nullptr || !symbol->IsConst()) {
+      continue;
+    }
+    TyIdx stTyIdx = symbol->GetTyIdx();
+    if (stTyIdx == 0) {
+      continue;
+    }
+    MIRType *stType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(stTyIdx);
+    MIRConst *mirConst = symbol->GetKonst();
+
+    if (mirConst == nullptr || mirConst->GetKind() != kConstInt) {
+      continue;
+    }
+    if (static_cast<MIRIntConst*>(mirConst)->GetValue() != 0) {
+      continue;
+    }
+    MIRType &valueType = mirConst->GetType();
+    if (valueType.GetTypeIndex() != stTyIdx) {
+      auto *newIntConst = theModule->GetMemPool()->New<MIRIntConst>(0, *stType);
+      symbol->SetValue({newIntConst});
+    }
+  }
+
+  // (5) remove type attr `rcunowned` of local symbol in rclocalunowned function specified by dex2mpl
+  for (auto *func : theModule->GetFunctionList()) {
+    if (func == nullptr || !func->GetAttr(FUNCATTR_rclocalunowned)) {
+      continue;
+    }
+    MIRSymbolTable *symTab = func->GetSymTab();
+    for (size_t i = 0; i != symTab->GetSymbolTableSize(); ++i) {
+      MIRSymbol *symbol = symTab->GetSymbolFromStIdx(i);
+      if (symbol == nullptr) {
+        continue;
+      }
+      if (symbol->GetAttr(ATTR_rcunowned)) {
+        symbol->ResetAttr(ATTR_rcunowned);
+      }
+    }
+  }
+
+  // 1: MIRStructType::isImported has different meaning for dex2mpl and binary mplt importer.
+  // for dex2mpl, `isImported` means whether a type is imported from mplt file instead of dex file, so all types from
+  // mplt are marked imported. But for binary mplt importer, `isImported` means whether a type is loaded successfully,
+  // so only complete types are marked imported.
+  // The workaround is to reset `isImported` according to the completeness of a type.
+  for (MIRType *type : GlobalTables::GetTypeTable().GetTypeTable()) {
+    if (type == nullptr) {
+      continue;
+    }
+    MIRTypeKind typeKind = type->GetKind();
+    if (typeKind == kTypeStructIncomplete || typeKind == kTypeClassIncomplete || typeKind == kTypeInterfaceIncomplete) {
+      auto *structType = static_cast<MIRStructType*>(type);
+      structType->SetIsImported(false);
+    } else if (typeKind == kTypeClass || typeKind == kTypeInterface) {
+      auto *structType = static_cast<MIRStructType*>(type);
+      structType->SetIsImported(true);
+    }
+  }
+}
+#endif
+
+void Dex2MplCompiler::PrintCommand(const MplOptions &options, const Action &action) const {
+  std::string runStr = "--run=";
+  std::string optionStr = "--option=\"";
+  std::string connectSym = "";
+  if (options.GetExeOptions().find(kBinNameDex2mpl) != options.GetExeOptions().end()) {
+    runStr += "dex2mpl";
+    auto inputDex2mplOptions = options.GetExeOptions().find(kBinNameDex2mpl);
+    for (auto &opt : inputDex2mplOptions->second) {
+      optionStr += " --" + opt;
+    }
+  }
+  optionStr += "\"";
+  LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " " << optionStr
+                         << " --infile " << GetInputFileName(options, action) << '\n';
+}
+
+#ifdef INTERGRATE_DRIVER
+bool Dex2MplCompiler::MakeDex2mplOptions(const MplOptions &options) {
+  Dex2mplOptions &dex2mplOptions = Dex2mplOptions::GetInstance();
+  dex2mplOptions.LoadDefault();
+  auto it = options.GetExeOptions().find(kBinNameDex2mpl);
+  if (it == options.GetExeOptions().end()) {
+    LogInfo::MapleLogger() << "no dex2mpl input options\n";
+    return false;
+  }
+  bool result = dex2mplOptions.SolveOptions(it->second, options.HasSetDebugFlag());
+  if (result == false) {
+    LogInfo::MapleLogger() << "Meet error dex2mpl options\n";
+    return false;
+  }
+  return true;
+}
+
+ErrorCode Dex2MplCompiler::Compile(MplOptions &options, const Action &action,
+                                   std::unique_ptr<MIRModule> &theModule) {
+  Dex2mplOptions &dex2mplOptions = Dex2mplOptions::GetInstance();
+  bool result = MakeDex2mplOptions(options);
+  if (!result) {
+    return ErrorCode::kErrorCompileFail;
+  }
+  // .dex
+  std::string dexFileName = action.GetInputFile();
+  theModule = std::make_unique<MIRModule>(dexFileName);
+
+  const auto &runningExes = options.GetRunningExes();
+  bool isDex2mplFinalExe = (runningExes[runningExes.size() - 1] == kBinNameDex2mpl);
+  std::unique_ptr<Dex2mplRunner> dex2mpl = std::make_unique<Dex2mplRunner>(dexFileName, dex2mplOptions,
+      std::move(theModule), options.HasSetSaveTmps(), isDex2mplFinalExe);
+  if (dex2mpl == nullptr) {
+    ERR(kLncErr, "new Dex2mplRunner failed.");
+    return ErrorCode::kErrorCompileFail;
+  }
+  LogInfo::MapleLogger() << "Starting dex2mpl" << '\n';
+  int ret = dex2mpl->Init();
+  if (ret != 0) {
+    return ErrorCode::kErrorCompileFail;
+  }
+  ret = dex2mpl->Run();
+  if (ret != 0) {
+    ERR(kLncErr, "(ToIDEUser)dex2mpl failed.");
+    return ErrorCode::kErrorCompileFail;
+  }
+  // Check that whether the kBinNameDex2mpl is the final compiler
+  // If not, we need to call PostDex2Mpl() to deal with some differences in theModule to
+  // adapt to the needs of maplecomb
+  if (runningExes[runningExes.size() - 1] != kBinNameDex2mpl) {
+    dex2mpl->MoveMirModule(theModule);
+    PostDex2Mpl(theModule);
+  }
+  PrintCommand(options, action);
+  return ErrorCode::kErrorNoError;
+}
+#endif
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/driver_options.cpp b/src/mapleall/maple_driver/src/driver_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1f035bc54bad20b2658233ac3e97edb44f40af0b
--- /dev/null
+++ b/src/mapleall/maple_driver/src/driver_options.cpp
@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "driver_options.h"
+#include "cl_option.h"
+
+namespace opts {
+
+/* ##################### BOOL Options ############################################################### */
+
+maplecl::Option<bool> version({"--version", "-v"},
+                         "  --version [command]         \tPrint version and exit.\n",
+                         {driverCategory});
+
+maplecl::Option<bool> ignoreUnkOpt({"--ignore-unknown-options"},
+                              "  --ignore-unknown-options    \tIgnore unknown compilation options\n",
+                              {driverCategory});
+
+maplecl::Option<bool> o0({"--O0", "-O0"},
+                    "  -O0                         \tNo optimization. (Default)\n",
+                    {driverCategory});
+
+maplecl::Option<bool> o1({"--O1", "-O1"},
+                    "  -O1                         \tDo some optimization.\n",
+                    {driverCategory});
+
+maplecl::Option<bool> o2({"--O2", "-O2"},
+                    "  -O2                         \tDo more optimization.\n",
+                    {driverCategory});
+
+maplecl::Option<bool> os({"--Os", "-Os"},
+                    "  -Os                         \tOptimize for size, based on O2.\n",
+                    {driverCategory, hir2mplCategory});
+
+maplecl::Option<bool> verify({"--verify"},
+                        "  --verify                    \tVerify mpl file\n",
+                        {driverCategory, dex2mplCategory, mpl2mplCategory});
+
+maplecl::Option<bool> decoupleStatic({"--decouple-static", "-decouple-static"},
+                                "  --decouple-static           \tDecouple the static method and field\n"
+                                "  --no-decouple-static        \tDon't decouple the static method and field\n",
+                                {driverCategory, dex2mplCategory, meCategory, mpl2mplCategory},
+                                maplecl::DisableWith("--no-decouple-static"));
+
+maplecl::Option<bool> gcOnly({"--gconly", "-gconly"},
+                        "  --gconly                     \tMake gconly is enable\n"
+                        "  --no-gconly                  \tDon't make gconly is enable\n",
+                        {driverCategory, dex2mplCategory, meCategory,
+                         mpl2mplCategory, cgCategory},
+                        maplecl::DisableWith("--no-gconly"));
+
+maplecl::Option<bool> timePhase({"-time-phases"},
+                           "  -time-phases                \tTiming phases and print percentages\n",
+                           {driverCategory});
+
+maplecl::Option<bool> genMeMpl({"--genmempl"},
+                          "  --genmempl                  \tGenerate me.mpl file\n",
+                          {driverCategory});
+
+maplecl::Option<bool> compileWOLink({"-c"},
+                               "  -c                          \tCompile the source files without linking\n",
+                               {driverCategory});
+
+maplecl::Option<bool> genVtable({"--genVtableImpl"},
+                           "  --genVtableImpl             \tGenerate VtableImpl.mpl file\n",
+                           {driverCategory});
+
+maplecl::Option<bool> verbose({"-verbose"},
+                         "  -verbose                    \tPrint informations\n",
+                         {driverCategory, jbc2mplCategory, hir2mplCategory,
+                          meCategory, mpl2mplCategory, cgCategory});
+
+maplecl::Option<bool> debug({"--debug"},
+                       "  --debug                     \tPrint debug info.\n",
+                       {driverCategory});
+
+maplecl::Option<bool> withDwarf({"-g"},
+                           "  --debug                     \tPrint debug info.\n",
+                           {driverCategory});
+
+maplecl::Option<bool> withIpa({"--with-ipa"},
+                          "  --with-ipa                  \tRun IPA when building\n"
+                          "  --no-with-ipa               \n",
+                          {driverCategory},
+                          maplecl::DisableWith("--no-with-ipa"));
+
+maplecl::Option<bool> npeNoCheck({"--no-npe-check"},
+                            "  --no-npe-check              \tDisable null pointer check (Default)\n",
+                            {driverCategory});
+
+maplecl::Option<bool> npeStaticCheck({"--npe-check-static"},
+                                "  --npe-check-static          \tEnable null pointer static check only\n",
+                                {driverCategory});
+
+maplecl::Option<bool> npeDynamicCheck({"--npe-check-dynamic"},
+                                 "  --npe-check-dynamic         \tEnable null "
+                                 "pointer dynamic check with static warning\n",
+                                 {driverCategory});
+
+maplecl::Option<bool> npeDynamicCheckSilent({"--npe-check-dynamic-silent"},
+                                       "  --npe-check-dynamic-silent  \tEnable null pointer dynamic "
+                                       "without static warning\n",
+                                       {driverCategory});
+
+maplecl::Option<bool> npeDynamicCheckAll({"--npe-check-dynamic-all"},
+                                    "  --npe-check-dynamic-all     \tKeep dynamic check before dereference, "
+                                    "used with --npe-check-dynamic* options\n",
+                                    {driverCategory});
+
+maplecl::Option<bool> boundaryNoCheck({"--no-boundary-check"},
+                                 "  --no-boundary-check         \tDisable boundary check (Default)\n",
+                                 {driverCategory});
+
+maplecl::Option<bool> boundaryStaticCheck({"--boundary-check-static"},
+                                     "  --boundary-check-static     \tEnable boundary static check\n",
+                                     {driverCategory});
+
+maplecl::Option<bool> boundaryDynamicCheck({"--boundary-check-dynamic"},
+                                      "  --boundary-check-dynamic    \tEnable boundary dynamic check "
+                                      "with static warning\n",
+                                      {driverCategory});
+
+maplecl::Option<bool> boundaryDynamicCheckSilent({"--boundary-check-dynamic-silent"},
+                                            "  --boundary-check-dynamic-silent  \tEnable boundary dynamic "
+                                            "check without static warning\n",
+                                            {driverCategory});
+
+maplecl::Option<bool> safeRegionOption({"--safe-region"},
+                                  "  --safe-region               \tEnable safe region\n",
+                                  {driverCategory});
+
+maplecl::Option<bool> printDriverPhases({"--print-driver-phases"},
+                                   "  --print-driver-phases       \tPrint Driver Phases\n",
+                                   {driverCategory});
+
+maplecl::Option<bool> ldStatic({"-static", "--static"},
+                          "  -static                     \tForce the linker to link a program statically\n",
+                          {driverCategory, ldCategory});
+
+maplecl::Option<bool> maplePhase({"--maple-phase"},
+                            "  --maple-phase               \tRun maple phase only\n  --no-maple-phase\n",
+                            {driverCategory},
+                            maplecl::DisableWith("--maple-toolchain"),
+                            maplecl::Init(true));
+
+maplecl::Option<bool> genMapleBC({"--genmaplebc"},
+                            "  --genmaplebc                \tGenerate .mbc file\n",
+                            {driverCategory});
+
+maplecl::Option<bool> genLMBC({"--genlmbc"},
+                         "  --genlmbc                \tGenerate .lmbc file\n",
+                         {driverCategory, mpl2mplCategory});
+
+maplecl::Option<bool> profileGen({"--profileGen"},
+                            "  --profileGen                \tGenerate profile data for static languages\n",
+                            {driverCategory, meCategory, mpl2mplCategory, cgCategory});
+
+maplecl::Option<bool> profileUse({"--profileUse"},
+                            "  --profileUse                \tOptimize static languages with profile data\n",
+                            {driverCategory, mpl2mplCategory});
+
+maplecl::Option<bool> stackProtectorStrong({"--stack-protector-strong"},
+                                           "  --stack-protector-strong        \tadd stack guard for some function\n",
+                                           {driverCategory, meCategory, cgCategory});
+
+maplecl::Option<bool> stackProtectorAll({"--stack-protector-all"},
+                                        "  --stack-protector-all        \tadd stack guard for all functions\n",
+                                        {driverCategory, meCategory, cgCategory});
+
+maplecl::Option<bool> inlineAsWeak({"-inline-as-weak", "--inline-as-weak"},
+                                   "  --inline-as-weak              \tSet inline functions as weak symbols"
+                                   " as it's in C++\n", {driverCategory, hir2mplCategory});
+
+/* ##################### STRING Options ############################################################### */
+maplecl::Option<std::string> help({"--help", "-h"},
+                             "  --help                   \tPrint help\n",
+                             {driverCategory},
+                             maplecl::optionalValue);
+
+maplecl::Option<std::string> infile({"--infile"},
+                               "  --infile file1,file2,file3  \tInput files.\n",
+                               {driverCategory});
+
+maplecl::Option<std::string> mplt({"--mplt", "-mplt"},
+                             "  --mplt=file1,file2,file3    \tImport mplt files.\n",
+                             {driverCategory, dex2mplCategory, jbc2mplCategory});
+
+maplecl::Option<std::string> partO2({"--partO2"},
+                               "  --partO2               \tSet func list for O2\n",
+                               {driverCategory});
+
+maplecl::List<std::string> jbc2mplOpt({"--jbc2mpl-opt"},
+                                 "  --jbc2mpl-opt               \tSet options for jbc2mpl\n",
+                                 {driverCategory});
+
+maplecl::List<std::string> hir2mplOpt({"--hir2mpl-opt"},
+                                 "  --hir2mpl-opt               \tSet options for hir2mpl\n",
+                                 {driverCategory});
+
+maplecl::List<std::string> clangOpt({"--clang-opt"},
+                               "  --clang-opt               \tSet options for clang as AST generator\n",
+                               {driverCategory});
+
+maplecl::List<std::string> asOpt({"--as-opt"},
+                            "  --as-opt                  \tSet options for as\n",
+                            {driverCategory});
+
+maplecl::List<std::string> ldOpt({"--ld-opt"},
+                            "  --ld-opt                  \tSet options for ld\n",
+                            {driverCategory});
+
+maplecl::List<std::string> dex2mplOpt({"--dex2mpl-opt"},
+                                 "  --dex2mpl-opt             \tSet options for dex2mpl\n",
+                                 {driverCategory});
+
+maplecl::List<std::string> mplipaOpt({"--mplipa-opt"},
+                                "  --mplipa-opt              \tSet options for mplipa\n",
+                                {driverCategory});
+
+maplecl::List<std::string> mplcgOpt({"--mplcg-opt"},
+                               "  --mplcg-opt               \tSet options for mplcg\n",
+                               {driverCategory});
+
+maplecl::List<std::string> meOpt({"--me-opt"},
+                            "  --me-opt                  \tSet options for me\n",
+                            {driverCategory});
+
+maplecl::List<std::string> mpl2mplOpt({"--mpl2mpl-opt"},
+                                 "  --mpl2mpl-opt             \tSet options for mpl2mpl\n",
+                                 {driverCategory});
+
+maplecl::Option<std::string> profile({"--profile"},
+                                "  --profile                   \tFor PGO optimization\n"
+                                "                              \t--profile=list_file\n",
+                                {driverCategory, dex2mplCategory, mpl2mplCategory, cgCategory});
+
+maplecl::Option<std::string> run({"--run"},
+                            "  --run=cmd1:cmd2             \tThe name of executables that are going\n"
+                            "                              \tto execute. IN SEQUENCE.\n"
+                            "                              \tSeparated by \":\".Available exe names:\n"
+                            "                              \tjbc2mpl, me, mpl2mpl, mplcg\n"
+                            "                              \tInput file must match the tool can\n"
+                            "                              \thandle\n",
+                            {driverCategory});
+
+maplecl::Option<std::string> optionOpt({"--option"},
+                                  "  --option=\"opt1:opt2\"      \tOptions for each executable,\n"
+                                  "                              \tseparated by \":\".\n"
+                                  "                              \tThe sequence must match the sequence in\n"
+                                  "                              \t--run.\n",
+                                  {driverCategory});
+
+maplecl::List<std::string> ldLib({"-l"},
+                            "  -l <lib>                    \tLinks with a library file\n",
+                            {driverCategory, ldCategory},
+                            maplecl::joinedValue);
+
+maplecl::List<std::string> ldLibPath({"-L"},
+                                "  -L <libpath>                \tAdd directory to library search path\n",
+                                {driverCategory, ldCategory},
+                                maplecl::joinedValue);
+
+maplecl::List<std::string> enableMacro({"-D"},
+                                  "  -D <macro>=<value>          \tDefine <macro> to <value> "
+                                  "(or 1 if <value> omitted)\n",
+                                  {driverCategory, clangCategory},
+                                  maplecl::joinedValue);
+
+maplecl::List<std::string> disableMacro({"-U"},
+                                   "  -U <macro>                  \tUndefine macro <macro>\n",
+                                   {driverCategory, clangCategory},
+                                   maplecl::joinedValue);
+
+maplecl::List<std::string> includeDir({"-I"},
+                                 "  -I <dir>                    \tAdd directory to include search path\n",
+                                 {driverCategory, clangCategory},
+                                 maplecl::joinedValue);
+
+maplecl::List<std::string> includeSystem({"--isystem"},
+                                    "  -isystem <dir>              \tAdd directory to SYSTEM include search path\n",
+                                    {driverCategory, clangCategory},
+                                    maplecl::joinedValue);
+
+maplecl::Option<std::string> output({"-o"},
+                               "  -o <outfile>                \tPlace the output into <file>\n",
+                               {driverCategory},
+                               maplecl::Init("a.out"));
+
+maplecl::Option<std::string> saveTempOpt({"--save-temps"},
+                                    "  --save-temps                \tDo not delete intermediate files.\n"
+                                    "                              \t--save-temps Save all intermediate files.\n"
+                                    "                              \t--save-temps=file1,file2,file3 Save the\n"
+                                    "                              \ttarget files.\n",
+                                    {driverCategory},
+                                    maplecl::optionalValue);
+
+maplecl::Option<std::string> target({"--target", "-target"},
+                               "  --target=<arch><abi>        \tDescribe target platform\n"
+                               "  \t\t\t\tExample: --target=aarch64-gnu or --target=aarch64_be-gnuilp32\n",
+                               {driverCategory, hir2mplCategory, dex2mplCategory, ipaCategory});
+
+/* ##################### DIGITAL Options ############################################################### */
+
+maplecl::Option<uint32_t> helpLevel({"--level"},
+                               "  --level=NUM                 \tPrint the help info of specified level.\n"
+                               "                              \tNUM=0: All options (Default)\n"
+                               "                              \tNUM=1: Product options\n"
+                               "                              \tNUM=2: Experimental options\n"
+                               "                              \tNUM=3: Debug options\n",
+                               {driverCategory});
+
+/* #################################################################################################### */
+
+} /* namespace opts */
diff --git a/src/mapleall/maple_driver/src/driver_runner.cpp b/src/mapleall/maple_driver/src/driver_runner.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3673d0047ba73b999fab831ecf268781f0480fbc
--- /dev/null
+++ b/src/mapleall/maple_driver/src/driver_runner.cpp
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "driver_runner.h"
+#include <iostream>
+#include "compiler.h"
+#include "mpl_timer.h"
+#include "mir_function.h"
+#include "mir_parser.h"
+#include "file_utils.h"
+#include "constantfold.h"
+#include "lower.h"
+#include "me_phase_manager.h"
+#include "lfo_loop_vec.h"
+#include "seqvec.h"
+
+using namespace maplebe;
+
+#define JAVALANG (theModule->IsJavaModule())
+#define CLANG (theModule->IsCModule())
+
+#define CHECK_MODULE(errorCode...)                                              \
+  do {                                                                          \
+    if (theModule == nullptr) {                                                 \
+      LogInfo::MapleLogger() << "Fatal error: the module is null" << '\n';      \
+      return errorCode;                                                         \
+    }                                                                           \
+  } while (0)
+
+#define RELEASE(pointer)      \
+  do {                        \
+    if (pointer != nullptr) { \
+      delete pointer;         \
+      pointer = nullptr;      \
+    }                         \
+  } while (0)
+
+#define ADD_PHASE(name, condition)       \
+  if ((condition)) {                     \
+    phases.push_back(std::string(name)); \
+  }
+
+#define ADD_EXTRA_PHASE(name, timephases, timeStart)                                                       \
+  if (timephases) {                                                                                        \
+    auto duration = std::chrono::system_clock::now() - (timeStart);                                        \
+    extraPhasesTime.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(duration).count()); \
+    extraPhasesName.emplace_back(name);                                                                    \
+  }
+
+namespace maple {
+const std::string kMplCg = "mplcg";
+const std::string kMpl2mpl = "mpl2mpl";
+const std::string kMplMe = "me";
+
+enum OptLevel {
+  kLevelO0,
+  kLevelO1,
+  kLevelO2
+};
+
+ErrorCode DriverRunner::Run() {
+  CHECK_MODULE(kErrorExit);
+
+  if (exeNames.empty()) {
+    LogInfo::MapleLogger() << "Fatal error: no exe specified" << '\n';
+    return kErrorExit;
+  }
+  std::string originBaseName = baseName;
+  outputFile = baseName;
+  (void)outputFile.append(GetPostfix());
+  if (mpl2mplOptions != nullptr || meOptions != nullptr) {
+    std::string vtableImplFile = originBaseName;
+    std::string postFix = "";
+    if (theModule->GetSrcLang() == kSrcLangC) {
+      postFix = ".me";
+    } else {
+      postFix = ".VtableImpl";
+    }
+    (void)vtableImplFile.append(postFix + ".mpl");
+    (void)originBaseName.append(postFix);
+    ProcessMpl2mplAndMePhases(outputFile, vtableImplFile);
+  }
+  return kErrorNoError;
+}
+
+std::string DriverRunner::GetPostfix() {
+  if (printOutExe == kMplMe) {
+    return ".me.mpl";
+  }
+  if (printOutExe == kMpl2mpl) {
+    return ".VtableImpl.mpl";
+  }
+  if (printOutExe == kMplCg) {
+    if (theModule->GetSrcLang() == kSrcLangC) {
+      return ".s";
+    } else {
+      return ".VtableImpl.s";
+    }
+  }
+  return "";
+}
+
+// trim both leading and trailing space and tab
+static void TrimString(std::string &str) {
+  size_t pos = str.find_first_not_of(kSpaceTabStr);
+  if (pos != std::string::npos) {
+    str = str.substr(pos);
+  } else {
+    str.clear();
+  }
+  pos = str.find_last_not_of(kSpaceTabStr);
+  if (pos != std::string::npos) {
+    str = str.substr(0, pos + 1);
+  }
+}
+
+void DriverRunner::SolveCrossModuleInJava(MIRParser &parser) const {
+  if (MeOption::optLevel < kLevelO2 || Options::lazyBinding ||
+      Options::skipPhase == "inline" || Options::buildApp != 0 ||
+      !Options::useInline || !Options::useCrossModuleInline) {
+    return;
+  }
+  std::string originBaseName = baseName;
+  // read in optimized mpl routines
+  const MapleVector<std::string> &inputMplt = theModule->GetImportedMplt();
+  auto it = inputMplt.cbegin();
+  for (++it; it != inputMplt.cend(); ++it) {
+    const std::string &curStr = *it;
+    auto lastDotInner = curStr.find_last_of(".");
+    std::string tmp = (lastDotInner == std::string::npos) ? curStr : curStr.substr(0, lastDotInner);
+    if (tmp.find("framework") != std::string::npos && originBaseName.find("framework") != std::string::npos) {
+      continue;
+    }
+    // Skip the import file
+    if (tmp.find(FileUtils::GetFileName(originBaseName, true)) != std::string::npos) {
+      continue;
+    }
+    size_t index = curStr.rfind(".");
+    CHECK_FATAL(index != std::string::npos, "can not find .");
+
+    std::string inputInline = curStr.substr(0, index + 1) + "mplt_inline";
+    std::ifstream optFile(inputInline);
+    if (!optFile.is_open()) {
+      continue;
+    }
+
+    LogInfo::MapleLogger() << "Starting parse " << inputInline << '\n';
+    bool parsed = parser.ParseInlineFuncBody(optFile);
+    if (!parsed) {
+      parser.EmitError(actualInput);
+    }
+    optFile.close();
+  }
+}
+
+void DriverRunner::SolveCrossModuleInC(MIRParser &parser) const {
+  if (MeOption::optLevel < kLevelO2 || !Options::useInline ||
+      !Options::useCrossModuleInline || Options::skipPhase == "inline" ||
+      Options::importFileList == "") {
+    return;
+  }
+  char absPath[PATH_MAX];
+  if (theModule->GetFileName().size() > PATH_MAX || realpath(theModule->GetFileName().c_str(), absPath) == nullptr) {
+    CHECK_FATAL(false, "invalid file path");
+  }
+  std::ifstream infile(Options::importFileList);
+  if (!infile.is_open()) {
+    LogInfo::MapleLogger(kLlErr) << "Cannot open importfilelist file " << Options::importFileList << '\n';
+  }
+  LogInfo::MapleLogger() << "[CROSS_MODULE] read importfile from list: " << Options::importFileList << '\n';
+  std::string input;
+  while (getline(infile, input)) {
+    TrimString(input);
+    if (input.empty() || input.find(absPath) != std::string::npos) {
+      continue;
+    }
+    std::ifstream optFile(input);
+    if (!optFile.is_open()) {
+      abort();
+    }
+    LogInfo::MapleLogger() << "Starting parse " << input << '\n';
+    bool parsed = parser.ParseInlineFuncBody(optFile);
+    if (!parsed) {
+      parser.EmitError(actualInput);
+    }
+    optFile.close();
+  }
+  infile.close();
+}
+
+ErrorCode DriverRunner::ParseInput() const {
+  CHECK_MODULE(kErrorExit);
+  LogInfo::MapleLogger() << "Starting parse input" << '\n';
+  MPLTimer timer;
+  timer.Start();
+  MIRParser parser(*theModule);
+  ErrorCode ret = kErrorNoError;
+  if (!fileParsed) {
+    if (inputFileType != kFileTypeBpl &&
+        inputFileType != kFileTypeMbc &&
+        inputFileType != kFileTypeLmbc) {
+      bool parsed = parser.ParseMIR(0, 0, false, true);
+      if (!parsed) {
+        ret = kErrorExit;
+        parser.EmitError(actualInput);
+      }
+    } else {
+      BinaryMplImport binMplt(*theModule);
+      binMplt.SetImported(false);
+      std::string modid = theModule->GetFileName();
+      bool imported = binMplt.Import(modid, true);
+      if (!imported) {
+        ret = kErrorExit;
+        LogInfo::MapleLogger() << "Cannot open .bpl file: %s" << modid << '\n';
+      }
+    }
+  }
+  if (CLANG) {
+    SolveCrossModuleInC(parser);
+  }
+  timer.Stop();
+  LogInfo::MapleLogger() << "Parse consumed " << timer.Elapsed() << "s" << '\n';
+  return ret;
+}
+
+ErrorCode DriverRunner::ParseSrcLang(MIRSrcLang &srcLang) const {
+  ErrorCode ret = kErrorNoError;
+  if (inputFileType != kFileTypeBpl &&
+      inputFileType != kFileTypeMbc &&
+      inputFileType != kFileTypeLmbc) {
+    MIRParser parser(*theModule);
+    bool parsed = parser.ParseSrcLang(srcLang);
+    if (!parsed) {
+      ret = kErrorExit;
+      parser.EmitError(actualInput);
+    }
+  } else {
+    BinaryMplImport binMplt(*theModule);
+    std::string modid = theModule->GetFileName();
+    bool imported = binMplt.ImportForSrcLang(modid, srcLang);
+    if (!imported) {
+      ret = kErrorExit;
+      LogInfo::MapleLogger() << "Cannot open .bpl file: %s" << modid << '\n';
+    }
+  }
+  return ret;
+}
+
+void DriverRunner::RunNewPM(const std::string &output, const std::string &vtableImplFile) {
+  LogInfo::MapleLogger() << "Processing maplecomb in new phasemanager" << '\n';
+  auto pmMemPool = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "PM module mempool");
+  const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(&MEBETopLevelManager::id);
+  auto *topLevelPhaseManager = static_cast<MEBETopLevelManager*>(curPhase->GetConstructor()(pmMemPool.get()));
+  topLevelPhaseManager->SetRunMpl2Mpl(mpl2mplOptions != nullptr);
+  topLevelPhaseManager->SetRunMe(meOptions != nullptr);
+  topLevelPhaseManager->SetQuiet(Options::quiet);
+  if (timePhases) {
+    topLevelPhaseManager->InitTimeHandler();
+  }
+  MeFuncPM::genMeMpl = genMeMpl;
+  MeFuncPM::genMapleBC = genMapleBC;
+  MeFuncPM::genLMBC = genLMBC;
+  MeFuncPM::timePhases = timePhases;
+  MPLTimer timer;
+  timer.Start();
+  topLevelPhaseManager->DoPhasesPopulate(*theModule);
+  topLevelPhaseManager->Run(*theModule);
+  if (timePhases) {
+    topLevelPhaseManager->DumpPhaseTime();
+  }
+  // emit after module phase
+  if (printOutExe == kMpl2mpl || printOutExe == kMplMe) {
+    theModule->Emit(output);
+  } else if (genVtableImpl || Options::emitVtableImpl) {
+    theModule->Emit(vtableImplFile);
+  }
+  pmMemPool.reset();
+  timer.Stop();
+  LogInfo::MapleLogger() << "maplecomb consumed " << timer.Elapsed() << "s" << '\n';
+  // dump vectorized loop counter here
+  {
+    LogInfo::MapleLogger() << "\n" << LoopVectorization::vectorizedLoop << " loop vectorized\n";
+    LogInfo::MapleLogger() << "\n" << SeqVectorize::seqVecStores << " sequencestores vectorized\n";
+    LogInfo::MapleLogger() << "\n" << LfoUnrollOneLoop::countOfLoopsUnrolled << " loops unrolled\n";
+  }
+}
+
+void DriverRunner::ProcessMpl2mplAndMePhases(const std::string &output, const std::string &vtableImplFile) {
+  CHECK_MODULE();
+  theMIRModule = theModule;
+  if (mpl2mplOptions != nullptr || meOptions != nullptr) {
+    // multi-thread is not supported for now.
+    MeOption::threads = 1;
+    // main entry of newpm for me&mpl2mpl
+    RunNewPM(output, vtableImplFile);
+  }
+}
+
+void DriverRunner::ProcessCGPhase(const std::string &output, const std::string &originBaseName) const {
+  CHECK_MODULE();
+  theMIRModule = theModule;
+  if (withDwarf && !theModule->IsWithDbgInfo()) {
+    LogInfo::MapleLogger() << "set up debug info " << '\n';
+    theMIRModule->GetDbgInfo()->BuildDebugInfo();
+#if DEBUG
+    if (cgOptions) {
+      cgOptions->SetOption(CGOptions::kVerboseAsm);
+    }
+#endif
+  }
+  if (cgOptions == nullptr) {
+    return;
+  }
+  LogInfo::MapleLogger() << "Processing mplcg in new phaseManager" << '\n';
+  MPLTimer timer;
+  timer.Start();
+  theModule->SetBaseName(originBaseName);
+  theModule->SetOutputFileName(output);
+  cgOptions->SetDefaultOptions(*theModule);
+  if (timePhases) {
+    CGOptions::EnableTimePhases();
+  }
+  Globals::GetInstance()->SetOptimLevel(cgOptions->GetOptimizeLevel());
+  MAD mad;
+  Globals::GetInstance()->SetMAD(mad);
+
+  auto cgPhaseManager = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "cg function phasemanager");
+  const MaplePhaseInfo *cgPMInfo = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(&CgFuncPM::id);
+  auto *cgfuncPhaseManager = static_cast<CgFuncPM*>(cgPMInfo->GetConstructor()(cgPhaseManager.get()));
+  cgfuncPhaseManager->SetQuiet(CGOptions::IsQuiet());
+  if (timePhases) {
+    cgfuncPhaseManager->InitTimeHandler();
+  }
+  /* It is a specifc work around  (need refactor) */
+  cgfuncPhaseManager->SetCGOptions(cgOptions);
+  (void) cgfuncPhaseManager->PhaseRun(*theModule);
+  if (timePhases) {
+    cgfuncPhaseManager->DumpPhaseTime();
+  }
+  timer.Stop();
+  if (theMIRModule->GetDbgInfo() != nullptr) {
+    theMIRModule->GetDbgInfo()->ClearDebugInfo();
+  }
+  theMIRModule->ReleasePragmaMemPool();
+  LogInfo::MapleLogger() << "Mplcg consumed " << timer.ElapsedMilliseconds() << "ms" << '\n';
+}
+
+void DriverRunner::InitProfile() const {
+  if (!cgOptions->IsProfileDataEmpty()) {
+    uint32 dexNameIdx = theModule->GetFileinfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_filename"));
+    const std::string &dexName = GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(dexNameIdx));
+    bool deCompressSucc = theModule->GetProfile().DeCompress(CGOptions::GetProfileData(), dexName);
+    if (!deCompressSucc) {
+      LogInfo::MapleLogger() << "WARN: DeCompress() " << CGOptions::GetProfileData() << "failed in mplcg()\n";
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/hided_options.cpp b/src/mapleall/maple_driver/src/hided_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..34eff7775df8deec2b99e654791fd8d832a2756f
--- /dev/null
+++ b/src/mapleall/maple_driver/src/hided_options.cpp
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "driver_options.h"
+#include "cl_option.h"
+#include <string>
+
+namespace opts {
+
+maplecl::Option<bool> MD({"-MD"},
+                    "  -MD                         \tWrite a depfile containing user and system headers\n",
+                    {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<std::string> MT({"-MT"},
+                           "  -MT<args>                   \tSpecify name of main file output in depfile\n",
+                           {driverCategory, clangCategory}, maplecl::hide, maplecl::joinedValue);
+
+maplecl::Option<std::string> MF({"-MF"},
+                           "  -MF<file>                   \tWrite depfile output from -MD, -M to <file>\n",
+                           {driverCategory, clangCategory}, maplecl::hide, maplecl::joinedValue);
+
+/* Should we use std option in hir2mpl ??? */
+maplecl::Option<std::string> std({"-std"},
+                            "  -std Ignonored\n",
+                            {driverCategory, clangCategory});
+
+/* ##################### Warnings Options ############################################################### */
+
+maplecl::Option<bool> wUnusedMacro({"-Wunused-macros"},
+                              "  -Wunused-macros             \twarning: macro is not used\n",
+                              {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wBadFunctionCast({"-Wbad-function-cast"},
+                                  "  -Wbad-function-cast         \twarning: "
+                                  "cast from function call of type A to non-matching type B\n",
+                                  {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wStrictPrototypes({"-Wstrict-prototypes"},
+                                   "  -Wstrict-prototypes         \twarning: "
+                                   "Warn if a function is declared or defined without specifying the argument types\n",
+                                   {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wUndef({"-Wundef"},
+                        "  -Wundef                     \twarning: "
+                        "Warn if an undefined identifier is evaluated in an #if directive. "
+                        "Such identifiers are replaced with zero\n",
+                        {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wCastQual({"-Wcast-qual"},
+                           "  -Wcast-qual                 \twarning: "
+                           "Warn whenever a pointer is cast so as to remove a type qualifier from the target type. "
+                           "For example, warn if a const char * is cast to an ordinary char *\n",
+                           {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wMissingFieldInitializers({"-Wmissing-field-initializers"},
+                                           "  -Wmissing-field-initializers\twarning: "
+                                           "Warn if a structure’s initializer has some fields missing\n",
+                                           {driverCategory, clangCategory}, maplecl::hide,
+                                           maplecl::DisableWith("-Wno-missing-field-initializers"));
+
+maplecl::Option<bool> wUnusedParameter({"-Wunused-parameter"},
+                                  "  -Wunused-parameter       \twarning: "
+                                  "Warn whenever a function parameter is unused aside from its declaration\n",
+                                  {driverCategory, clangCategory}, maplecl::hide,
+                                  maplecl::DisableWith("-Wno-unused-parameter"));
+
+maplecl::Option<bool> wAll({"-Wall"},
+                      "  -Wall                    \tThis enables all the warnings about constructions "
+                      "that some users consider questionable\n",
+                      {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wExtra({"-Wextra"},
+                        "  -Wextra                  \tEnable some extra warning flags that are not enabled by -Wall\n",
+                        {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wWriteStrings({"-Wwrite-strings"},
+                               "  -Wwrite-strings          \tWhen compiling C, give string constants the type "
+                               "const char[length] so that copying the address of one into "
+                               "a non-const char * pointer produces a warning\n",
+                               {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wVla({"-Wvla"},
+                      "  -Wvla                    \tWarn if a variable-length array is used in the code\n",
+                      {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wFormatSecurity({"-Wformat-security"},
+                                 "  -Wformat-security                    \tWwarn about uses of format "
+                                 "functions that represent possible security problems\n",
+                                 {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wShadow({"-Wshadow"},
+                         "  -Wshadow                             \tWarn whenever a local variable "
+                         "or type declaration shadows another variable\n",
+                         {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wTypeLimits({"-Wtype-limits"},
+                             "  -Wtype-limits                         \tWarn if a comparison is always true or always "
+                             "false due to the limited range of the data type\n",
+                             {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wSignCompare({"-Wsign-compare"},
+                              "  -Wsign-compare                         \tWarn when a comparison between signed and "
+                              " unsigned values could produce an incorrect result when the signed value is converted "
+                              "to unsigned\n",
+                              {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wShiftNegativeValue({"-Wshift-negative-value"},
+                                     "  -Wshift-negative-value                 \tWarn if left "
+                                     "shifting a negative value\n",
+                                     {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wPointerArith({"-Wpointer-arith"},
+                                "  -Wpointer-arith                        \tWarn about anything that depends on the "
+                                "“size of” a function type or of void\n",
+                               {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wIgnoredQualifiers({"-Wignored-qualifiers"},
+                                    "  -Wignored-qualifiers                   \tWarn if the return type of a "
+                                    "function has a type qualifier such as const\n",
+                                    {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wFormat({"-Wformat"},
+                         "  -Wformat                     \tCheck calls to printf and scanf, etc., "
+                         "to make sure that the arguments supplied have types appropriate "
+                         "to the format string specified\n",
+                         {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wFloatEqual({"-Wfloat-equal"},
+                             "  -Wfloat-equal                \tWarn if floating-point values are used "
+                             "in equality comparisons\n",
+                             {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wDateTime({"-Wdate-time"},
+                           "  -Wdate-time                  \tWarn when macros __TIME__, __DATE__ or __TIMESTAMP__ "
+                           "are encountered as they might prevent bit-wise-identical reproducible compilations\n",
+                           {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wImplicitFallthrough({"-Wimplicit-fallthrough"},
+                                      "  -Wimplicit-fallthrough       \tWarn when a switch case falls through\n",
+                                      {driverCategory, clangCategory}, maplecl::hide);
+
+maplecl::Option<bool> wShiftOverflow({"-Wshift-overflow"},
+                                "  -Wshift-overflow             \tWarn about left shift overflows\n",
+                                {driverCategory, clangCategory}, maplecl::hide,
+                                maplecl::DisableWith("-Wno-shift-overflow"));
+
+} /* namespace opts */
diff --git a/src/mapleall/maple_driver/src/ipa_compiler.cpp b/src/mapleall/maple_driver/src/ipa_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..86fbaacae4653e27460d090d8830138b428f93dc
--- /dev/null
+++ b/src/mapleall/maple_driver/src/ipa_compiler.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler.h"
+#include "default_options.def"
+
+namespace maple {
+const std::string &IpaCompiler::GetBinName() const {
+  return kBinNameMplipa;
+}
+
+DefaultOption IpaCompiler::GetDefaultOptions(const MplOptions &options, const Action &action [[maybe_unused]]) const {
+  uint32_t len = 0;
+  MplOption *kMplipaDefaultOptions = nullptr;
+
+  if (opts::o2) {
+    len = sizeof(kMplipaDefaultOptionsO2) / sizeof(MplOption);
+    kMplipaDefaultOptions = kMplipaDefaultOptionsO2;
+  }
+
+  if (kMplipaDefaultOptions == nullptr) {
+    return DefaultOption();
+  }
+
+  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
+  for (uint32_t i = 0; i < len; ++i) {
+    defaultOptions.mplOptions[i] = kMplipaDefaultOptions[i];
+  }
+
+  for (uint32_t i = 0; i < defaultOptions.length; ++i) {
+    defaultOptions.mplOptions[i].SetValue(
+        FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
+                                           defaultOptions.mplOptions[i].GetValue(),
+                                           options.GetExeFolder()));
+  }
+  return defaultOptions;
+}
+
+std::string IpaCompiler::GetInputFileName(const MplOptions &options [[maybe_unused]], const Action &action) const {
+  return action.GetFullOutputName() + ".mpl";
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp b/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bce6d2ec7dfa1e5db8862b196a663600ac47dbc0
--- /dev/null
+++ b/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler.h"
+#include "default_options.def"
+
+namespace maple {
+const std::string &Jbc2MplCompiler::GetBinName() const {
+  return kBinNameJbc2mpl;
+}
+
+DefaultOption Jbc2MplCompiler::GetDefaultOptions(const MplOptions &options [[maybe_unused]],
+                                                 const Action &action [[maybe_unused]]) const {
+  return DefaultOption();
+}
+
+void Jbc2MplCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions [[maybe_unused]], const Action &action,
+                                          std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".mpl");
+  tempFiles.push_back(action.GetFullOutputName() + ".mplt");
+}
+
+std::unordered_set<std::string> Jbc2MplCompiler::GetFinalOutputs(const MplOptions &mplOptions [[maybe_unused]],
+                                                                 const Action &action) const {
+  std::unordered_set<std::string> finalOutputs;
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mpl");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mplt");
+  return finalOutputs;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/ld_compiler.cpp b/src/mapleall/maple_driver/src/ld_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f77bad356b69738b5db00c9fe0da782c15e538ed
--- /dev/null
+++ b/src/mapleall/maple_driver/src/ld_compiler.cpp
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler.h"
+#include "file_utils.h"
+#include "triple.h"
+#include "default_options.def"
+
+namespace maple {
+
+static const std::string kAarch64BeIlp32Gcc = "aarch64_be-linux-gnuilp32-gcc";
+static const std::string kAarch64BeGcc = "aarch64_be-linux-gnu-gcc";
+
+std::string LdCompilerBeILP32::GetBinPath(const MplOptions &mplOptions [[maybe_unused]]) const {
+  std::string gccPath = FileUtils::SafeGetenv(kGccBePathEnv) + "/";
+  const std::string &gccTool = Triple::GetTriple().GetEnvironment() == Triple::EnvironmentType::GNUILP32 ?
+                               kAarch64BeIlp32Gcc : kAarch64BeGcc;
+  std::string gccToolPath = gccPath + gccTool;
+
+  if (!FileUtils::IsFileExists(gccToolPath)) {
+    LogInfo::MapleLogger(kLlErr) << kGccBePathEnv << " environment variable must be set as the path to "
+                                 << gccTool << "\n";
+    CHECK_FATAL(false, "%s environment variable must be set as the path to %s\n",
+                kGccBePathEnv, gccTool.c_str());
+  }
+
+  return gccPath;
+}
+
+const std::string &LdCompilerBeILP32::GetBinName() const {
+  if (Triple::GetTriple().GetEnvironment() == Triple::EnvironmentType::GNUILP32) {
+    return kAarch64BeIlp32Gcc;
+  } else {
+    return kAarch64BeGcc;
+  }
+}
+
+std::string LdCompiler::GetBinPath(const MplOptions &mplOptions [[maybe_unused]]) const {
+#ifdef ANDROID
+  return "prebuilts/gcc/linux-x86/aarch64/aarch64-linux-android-4.9/bin/";
+#else
+  return FileUtils::SafeGetenv(kMapleRoot) + "/tools/bin/";
+#endif
+}
+
+// Required to use ld instead of gcc; ld will be implemented later
+const std::string &LdCompiler::GetBinName() const {
+  return kBinNameGcc;
+}
+
+/* the tool name must be the same as exeName field in Descriptor structure */
+const std::string &LdCompiler::GetTool() const {
+  return kLdFlag;
+}
+
+DefaultOption LdCompiler::GetDefaultOptions(const MplOptions &options, const Action &action [[maybe_unused]]) const {
+  uint32_t len = sizeof(kLdDefaultOptions) / sizeof(MplOption);
+  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
+
+  for (uint32_t i = 0; i < len; ++i) {
+    defaultOptions.mplOptions[i] = kLdDefaultOptions[i];
+  }
+
+  for (uint32_t i = 0; i < defaultOptions.length; ++i) {
+    defaultOptions.mplOptions[i].SetValue(
+        FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
+                                           defaultOptions.mplOptions[i].GetValue(),
+                                           options.GetExeFolder()));
+  }
+  return defaultOptions;
+}
+
+std::string LdCompiler::GetInputFileName(const MplOptions &options [[maybe_unused]], const Action &action) const {
+    std::string files;
+
+    bool isFirstEntry = true;
+    for (const auto &file : action.GetLinkFiles()) {
+      /* Split Input files with " "; (except first entry) */
+      if (isFirstEntry) {
+        isFirstEntry = false;
+      } else {
+        files += " ";
+      }
+
+      files += StringUtils::GetStrBeforeLast(file, ".") + ".o";
+    }
+    return files;
+}
+
+void LdCompiler::AppendOutputOption(std::vector<MplOption> &finalOptions,
+                                    const std::string &name) const {
+  (void)finalOptions.emplace_back("-o", name);
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/maple.cpp b/src/mapleall/maple_driver/src/maple.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d969cfca7d52890952e69ad166dfaac1752535fb
--- /dev/null
+++ b/src/mapleall/maple_driver/src/maple.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler_factory.h"
+#include "error_code.h"
+#include "mpl_options.h"
+#include "mpl_sighandler.h"
+
+using namespace maple;
+
+int main(int argc, char **argv) {
+  SigHandler::EnableAll();
+
+  MplOptions mplOptions;
+  int ret = static_cast<int>(mplOptions.Parse(argc, argv));
+  if (ret == kErrorNoError) {
+    ret = CompilerFactory::GetInstance().Compile(mplOptions);
+  }
+  PrintErrorMessage(ret);
+  return ret;
+}
diff --git a/src/mapleall/maple_driver/src/maple_comb_compiler.cpp b/src/mapleall/maple_driver/src/maple_comb_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..73e5fb46c653a02785234ec987d2e3d0d9ad2a04
--- /dev/null
+++ b/src/mapleall/maple_driver/src/maple_comb_compiler.cpp
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler.h"
+#include "driver_options.h"
+#include "string_utils.h"
+#include "mpl_logging.h"
+#include "driver_runner.h"
+#include "inline.h"
+#include "me_phase_manager.h"
+#include "constantfold.h"
+
+namespace maple {
+
+std::string MapleCombCompiler::GetInputFileName(const MplOptions &options [[maybe_unused]],
+                                                const Action &action) const {
+  if (action.IsItFirstRealAction()) {
+    return action.GetInputFile();
+  }
+  if (action.GetInputFileType() == InputFileType::kFileTypeVtableImplMpl) {
+    return action.GetFullOutputName() + ".VtableImpl.mpl";
+  }
+  if (action.GetInputFileType() == InputFileType::kFileTypeBpl) {
+    return action.GetFullOutputName() + ".bpl";
+  }
+  if (action.GetInputFileType() == InputFileType::kFileTypeMbc) {
+    return action.GetFullOutputName() + ".mbc";
+  }
+  if (action.GetInputFileType() == InputFileType::kFileTypeLmbc) {
+    return action.GetFullOutputName() + ".lmbc";
+  }
+  return action.GetFullOutputName() + ".mpl";
+}
+
+void MapleCombCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions [[maybe_unused]], const Action &action,
+                                            std::vector<std::string> &tempFiles) const {
+  std::string filePath = action.GetFullOutputName() + ".data.muid";
+  tempFiles.push_back(filePath);
+  filePath = action.GetFullOutputName() + ".func.muid";
+  tempFiles.push_back(filePath);
+  for (auto iter = tempFiles.begin(); iter != tempFiles.end();) {
+    std::ifstream infile;
+    infile.open(*iter);
+    if (infile.fail()) {
+      iter = tempFiles.erase(iter);
+    } else {
+      ++iter;
+    }
+    infile.close();
+  }
+}
+
+std::unordered_set<std::string> MapleCombCompiler::GetFinalOutputs(const MplOptions &mplOptions [[maybe_unused]],
+                                                                   const Action &action) const {
+  std::unordered_set<std::string> finalOutputs;
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".VtableImpl.mpl");
+  return finalOutputs;
+}
+
+void MapleCombCompiler::PrintCommand(const MplOptions &options, const Action &action) const {
+  std::string runStr = "--run=";
+  std::ostringstream optionStr;
+  optionStr << "--option=\"";
+  std::string connectSym = "";
+  bool firstComb = false;
+  if (options.GetExeOptions().find(kBinNameMe) != options.GetExeOptions().end()) {
+    runStr += "me";
+    auto it = options.GetExeOptions().find(kBinNameMe);
+    for (auto &opt : it->second) {
+      optionStr << " " << opt;
+    }
+    firstComb = true;
+  }
+  if (options.GetExeOptions().find(kBinNameMpl2mpl) != options.GetExeOptions().end()) {
+    if (firstComb) {
+      runStr += ":mpl2mpl";
+      optionStr << ":";
+    } else {
+      runStr += "mpl2mpl";
+    }
+    auto it = options.GetExeOptions().find(kBinNameMpl2mpl);
+    for (auto &opt : it->second) {
+      optionStr << " " << opt;
+    }
+  }
+
+  std::string driverOptions = options.GetCommonOptionsStr();
+
+  optionStr << "\"";
+  LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " "
+                         << optionStr.str() << " " << driverOptions << GetInputFileName(options, action) << '\n';
+}
+
+std::string MapleCombCompiler::GetStringOfSafetyOption() const {
+  std::string safetyOptionStr = "";
+  if (MeOption::safeRegionMode) {
+    safetyOptionStr += "safe-region ";
+  }
+  if (MeOption::isNpeCheckAll) {
+    safetyOptionStr += "npe-check-dynamic-all ";
+  }
+  switch (MeOption::npeCheckMode) {
+    case kStaticCheck:
+      safetyOptionStr += "npe-check-static ";
+      break;
+    case kDynamicCheck:
+      safetyOptionStr += "npe-check-dynamic ";
+      break;
+    case kDynamicCheckSilent:
+      safetyOptionStr += "npe-check-dynamic-silent ";
+      break;
+    default:
+      break;
+  }
+  switch (MeOption::boundaryCheckMode) {
+    case kStaticCheck:
+      safetyOptionStr += "boundary-check-static ";
+      break;
+    case kDynamicCheck:
+      safetyOptionStr += "boundary-check-dynamic ";
+      break;
+    case kDynamicCheckSilent:
+      safetyOptionStr += "boundary-check-dynamic-silent ";
+      break;
+    default:
+      break;
+  }
+  return safetyOptionStr;
+}
+
+ErrorCode MapleCombCompiler::MakeMeOptions(const MplOptions &options, DriverRunner &runner) const {
+  auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMe);
+  if (it == options.GetRunningExes().end()) {
+    return kErrorNoError;
+  }
+
+  auto itOpt = options.GetExeOptions().find(kBinNameMe);
+  if (itOpt != options.GetExeOptions().end()) {
+    const auto &meExeOpts = itOpt->second;
+    const std::deque<std::string_view> strMeOptions(meExeOpts.begin(), meExeOpts.end());
+    (void)maplecl::CommandLine::GetCommandLine().HandleInputArgs(strMeOptions, meCategory);
+  }
+
+  bool result = MeOption::GetInstance().SolveOptions(opts::debug);
+  if (!result) {
+    LogInfo::MapleLogger() << "Meet error me options\n";
+    return kErrorCompileFail;
+  }
+  MeOption::generalRegOnly = options.HasSetGeneralRegOnly();
+  MeOption::npeCheckMode = options.GetNpeCheckMode();
+  MeOption::isNpeCheckAll = opts::npeDynamicCheckAll;
+  MeOption::boundaryCheckMode = options.GetBoundaryCheckMode();
+  MeOption::safeRegionMode = opts::safeRegionOption;
+  if (MeOption::optLevel == 0) {
+    std::string safetyOptionStr = GetStringOfSafetyOption();
+    if (!safetyOptionStr.empty()) {
+      (void)safetyOptionStr.erase(safetyOptionStr.cend() - 1);
+      WARN(kLncWarn, "warning: The safety option %s must be used in conjunction with O2 mode",
+           safetyOptionStr.c_str());
+    }
+  }
+
+  // Set me options for driver runner
+  runner.SetMeOptions(&MeOption::GetInstance());
+  return kErrorNoError;
+}
+
+ErrorCode MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, DriverRunner &runner) const {
+  auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMpl2mpl);
+  if (it == options.GetRunningExes().end()) {
+    return kErrorNoError;
+  }
+
+  auto itOpt = options.GetExeOptions().find(kBinNameMpl2mpl);
+  if (itOpt != options.GetExeOptions().end()) {
+    const auto &mpl2mplExeOpts = itOpt->second;
+    const std::deque<std::string_view> strMpl2mplOptions(mpl2mplExeOpts.begin(), mpl2mplExeOpts.end());
+    (void)maplecl::CommandLine::GetCommandLine().HandleInputArgs(strMpl2mplOptions, mpl2mplCategory);
+  }
+
+  auto &mpl2mplOption = Options::GetInstance();
+  bool result = mpl2mplOption.SolveOptions(opts::debug);
+  if (!result) {
+    LogInfo::MapleLogger() << "Meet error mpl2mpl options\n";
+    return kErrorCompileFail;
+  }
+  // Set mpl2mpl options for driver runner
+  runner.SetMpl2mplOptions(&Options::GetInstance());
+  return kErrorNoError;
+}
+
+std::string MapleCombCompiler::DecideOutExe(const MplOptions &options) const {
+  std::string printOutExe = "";
+  auto &selectExes = options.GetSelectedExes();
+  if (selectExes[selectExes.size() - 1] == kBinNameMapleComb) {
+    auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMpl2mpl);
+    if (it != options.GetRunningExes().end()) {
+      printOutExe = kBinNameMpl2mpl;
+      return printOutExe;
+    }
+    it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMe);
+    if (it != options.GetRunningExes().end()) {
+      printOutExe = kBinNameMe;
+      return printOutExe;
+    }
+  }
+  return selectExes[selectExes.size() - 1];
+}
+
+ErrorCode MapleCombCompiler::Compile(MplOptions &options, const Action &action,
+                                     std::unique_ptr<MIRModule> &theModule) {
+  std::string fileName = GetInputFileName(options, action);
+  bool fileParsed = true;
+  if (theModule == nullptr) {
+    theModule = std::make_unique<MIRModule>(fileName);
+    fileParsed = false;
+  }
+  options.PrintCommand(&action);
+  LogInfo::MapleLogger() << "Starting maplecomb\n";
+  theModule->InitPartO2List(opts::partO2);
+  DriverRunner runner(theModule.get(), options.GetSelectedExes(), action.GetInputFileType(), fileName,
+                      fileName, fileName, opts::withDwarf, fileParsed,
+                      opts::timePhase, opts::genVtable,
+                      opts::genMeMpl, opts::genMapleBC,
+                      opts::genLMBC);
+  ErrorCode ret = kErrorNoError;
+
+  MIRParser parser(*theModule);
+  MIRSrcLang srcLang = kSrcLangUnknown;
+  ret = runner.ParseSrcLang(srcLang);
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+  theModule->SetSrcLang(srcLang);
+
+  // Add running phases and default options according to the srcLang (only for auto mode)
+  ret = options.AppendCombOptions(theModule->GetSrcLang());
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  ret = MakeMeOptions(options, runner);
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+  ret = MakeMpl2MplOptions(options, runner);
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+  runner.SetPrintOutExe(DecideOutExe(options));
+
+  // Parse the input file
+  ret = runner.ParseInput();
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  if (opts::debug) {
+    PrintCommand(options, action);
+  }
+  ErrorCode nErr = runner.Run();
+  logInfo.PrintUserWarnMessages();
+  return nErr;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp b/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f20e1c04be7982c292f933dde5c0af3b86a9e1d3
--- /dev/null
+++ b/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <vector>
+#include "compiler.h"
+#include "types_def.h"
+
+namespace maple {
+
+// FixMe
+static const std::string kTmpBin = "maple";
+
+const std::string &MapleCombCompilerWrp::GetBinName() const {
+  return kTmpBin;
+}
+
+std::string MapleCombCompilerWrp::GetBinPath(const MplOptions &mplOptions [[maybe_unused]]) const {
+  return FileUtils::SafeGetenv(kMapleRoot) + "/output/" +
+      FileUtils::SafeGetenv("MAPLE_BUILD_TYPE") + "/bin/";
+}
+
+DefaultOption MapleCombCompilerWrp::GetDefaultOptions(const MplOptions &options [[maybe_unused]],
+                                                      const Action &action [[maybe_unused]]) const {
+  /* need to add --maple-phase option to run only maple phase.
+   * linker will be called as separated step (AsCompiler).
+   */
+  opts::maplePhase.SetValue(true);
+
+  /* opts::infile must be cleared because we should run compilation for each file separately.
+   * Separated input file are set in Actions.
+   */
+  opts::infile.Clear();
+
+  return DefaultOption();
+}
+
+std::string MapleCombCompilerWrp::GetInputFileName(const MplOptions &options [[maybe_unused]],
+                                                   const Action &action) const {
+  if (action.IsItFirstRealAction()) {
+    return action.GetInputFile();
+  }
+
+  InputFileType fileType = action.GetInputFileType();
+  auto fullOutput = action.GetFullOutputName();
+  if (fileType == InputFileType::kFileTypeVtableImplMpl) {
+    return fullOutput + ".VtableImpl.mpl";
+  }
+  if (fileType == InputFileType::kFileTypeBpl) {
+    return fullOutput + ".bpl";
+  }
+  return fullOutput + ".mpl";
+}
+
+void MapleCombCompilerWrp::GetTmpFilesToDelete(const MplOptions &mplOptions [[maybe_unused]], const Action &action,
+                                               std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".s");
+}
+
+std::unordered_set<std::string> MapleCombCompilerWrp::GetFinalOutputs(const MplOptions &mplOptions [[maybe_unused]],
+                                                                      const Action &action) const {
+  std::unordered_set<std::string> finalOutputs;
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".s");
+  return finalOutputs;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/mpl_options.cpp b/src/mapleall/maple_driver/src/mpl_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f7e810e38bd11282f35678c7a7be3f606e325d46
--- /dev/null
+++ b/src/mapleall/maple_driver/src/mpl_options.cpp
@@ -0,0 +1,899 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mpl_options.h"
+#include <memory>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include "compiler.h"
+#include "compiler_factory.h"
+#include "file_utils.h"
+#include "mpl_logging.h"
+#include "string_utils.h"
+#include "version.h"
+#include "default_options.def"
+#include "me_option.h"
+#include "option.h"
+#include "cg_option.h"
+#include "driver_options.h"
+#include "triple.h"
+
+
+namespace maple {
+using namespace maplebe;
+
+/* tool -> OptionCategory map: ld -> ldCategory, me -> meCategory and etc... */
+static std::unordered_map<std::string, maplecl::OptionCategory *> exeCategories = {
+    {"maple", &driverCategory},
+    {maple::kBinNameClang, &clangCategory},
+    {maple::kBinNameCpp2mpl, &hir2mplCategory},
+    {maple::kBinNameMpl2mpl, &mpl2mplCategory},
+    {maple::kBinNameMe, &meCategory},
+    {maple::kBinNameMplcg, &cgCategory},
+    {maple::kAsFlag, &asCategory},
+    {maple::kLdFlag, &ldCategory},
+    {maple::kBinNameDex2mpl, &dex2mplCategory},
+    {maple::kBinNameJbc2mpl, &jbc2mplCategory},
+    {maple::kBinNameMplipa, &ipaCategory}
+};
+
+#ifdef ANDROID
+const std::string kMapleDriverVersion = "MapleDriver " + std::to_string(Version::GetMajorVersion()) + "." +
+                                        std::to_string(Version::GetMinorVersion()) + " 20190929";
+#else
+const std::string kMapleDriverVersion = "Maple Version : " + Version::GetVersionStr();
+#endif
+
+const std::vector<std::string> kMapleCompilers = { "jbc2mpl", "hir2mpl",
+    "dex2mpl", "mplipa", "as", "ld",
+    "me", "mpl2mpl", "mplcg", "clang"};
+
+ErrorCode MplOptions::Parse(int argc, char **argv) {
+  (void)maplecl::CommandLine::GetCommandLine().Parse(argc, argv);
+  exeFolder = FileUtils::GetFileFolder(FileUtils::GetExecutable());
+
+  // We should recognize O0, O2 and run options firstly to decide the real options
+  ErrorCode ret = HandleEarlyOptions();
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  /* Check whether the input files were valid */
+  ret = CheckInputFiles();
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  // Decide runningExes for default options(O0, O2) by input files
+  if (runMode != RunMode::kCustomRun) {
+    ret = DecideRunningPhases();
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  } else { // kCustomRun
+    /* kCustomRun run mode is set if --run=tool1:tool2 option is used.
+     * This Option is parsed on DecideRunType step. DecideRunType fills runningExes vector.
+     * DecideRunningPhases(runningExes) creates ActionsTree in kCustomRun mode.
+     * Maybe we can create Actions tree in DecideRunType in order to not use runningExes?
+    */
+    ret = DecideRunningPhases(runningExes);
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  }
+
+  ret = HandleOptions();
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  return ret;
+}
+
+ErrorCode MplOptions::HandleOptions() {
+  if (opts::output.IsEnabledByUser() && GetActions().size() > 1) {
+    LogInfo::MapleLogger(kLlErr) << "Cannot specify -o when generating multiple output\n";
+    return kErrorInvalidParameter;
+  }
+
+  if (opts::saveTempOpt.IsEnabledByUser()) {
+    opts::genMeMpl.SetValue(true);
+    opts::genVtable.SetValue(true);
+    StringUtils::Split(opts::saveTempOpt, saveFiles, ',');
+  }
+
+  if (opts::target.IsEnabledByUser()) {
+    Triple::GetTriple().Init(opts::target.GetValue());
+  } else {
+    Triple::GetTriple().Init();
+  }
+
+  if (!opts::safeRegionOption) {
+    if (opts::npeNoCheck) {
+      npeCheckMode = SafetyCheckMode::kNoCheck;
+    }
+
+    if (opts::npeStaticCheck) {
+      npeCheckMode = SafetyCheckMode::kStaticCheck;
+    }
+
+    if (opts::boundaryNoCheck) {
+      boundaryCheckMode = SafetyCheckMode::kNoCheck;
+    }
+
+    if (opts::boundaryStaticCheck) {
+      boundaryCheckMode = SafetyCheckMode::kStaticCheck;
+    }
+  } else { /* safeRegionOption is eanbled */
+    npeCheckMode = SafetyCheckMode::kDynamicCheck;
+    boundaryCheckMode = SafetyCheckMode::kDynamicCheck;
+  }
+
+  if (opts::npeDynamicCheck) {
+    npeCheckMode = SafetyCheckMode::kDynamicCheck;
+  }
+
+  if (opts::npeDynamicCheckSilent) {
+    npeCheckMode = SafetyCheckMode::kDynamicCheckSilent;
+  }
+
+  if (opts::boundaryDynamicCheck) {
+    boundaryCheckMode = SafetyCheckMode::kDynamicCheck;
+  }
+
+  if (opts::boundaryDynamicCheckSilent) {
+    boundaryCheckMode = SafetyCheckMode::kDynamicCheckSilent;
+  }
+
+  HandleExtraOptions();
+
+  return kErrorNoError;
+}
+
+ErrorCode MplOptions::HandleEarlyOptions() {
+  if (opts::version) {
+    LogInfo::MapleLogger() << kMapleDriverVersion << "\n";
+
+    /* exit, if only one "version" option is set. Else: continue compilation */
+    if (driverCategory.GetEnabledOptions().size() == 1) {
+      return kErrorExitHelp;
+    }
+  }
+
+  if (opts::printDriverPhases) {
+    DumpActionTree();
+    return kErrorExitHelp;
+  }
+
+  if (opts::help.IsEnabledByUser()) {
+    if (auto it = exeCategories.find(opts::help.GetValue()); it != exeCategories.end()) {
+      maplecl::CommandLine::GetCommandLine().HelpPrinter(*it->second);
+    } else {
+      maple::LogInfo::MapleLogger() << "USAGE: maple [options]\n\n"
+        "  Example 1: <Maple bin path>/maple --run=me:mpl2mpl:mplcg "
+        "--option=\"[MEOPT]:[MPL2MPLOPT]:[MPLCGOPT]\"\n"
+        "                                    --mplt=MPLTPATH inputFile.mpl\n"
+        "  Example 2: <Maple bin path>/maple -O2 --mplt=mpltPath inputFile.dex\n\n"
+        "==============================\n"
+        "  Options:\n";
+      maplecl::CommandLine::GetCommandLine().HelpPrinter();
+    }
+    return kErrorExitHelp;
+  }
+
+  if (opts::o0.IsEnabledByUser() ||
+      opts::o1.IsEnabledByUser() ||
+      opts::o2.IsEnabledByUser() ||
+      opts::os.IsEnabledByUser()) {
+    if (opts::run.IsEnabledByUser()) {
+      /* -Ox and --run should not appear at the same time */
+      LogInfo::MapleLogger(kLlErr) << "Cannot set auto mode and run mode at the same time!\n";
+      return kErrorInvalidParameter;
+    } else {
+      runMode = RunMode::kAutoRun;
+    }
+  } else if (opts::run.IsEnabledByUser()) {
+    runMode = RunMode::kCustomRun;
+
+    UpdateRunningExe(opts::run);
+    if (!opts::optionOpt.GetValue().empty()) {
+      if (UpdateExeOptions(opts::optionOpt) != kErrorNoError) {
+        return kErrorInvalidParameter;
+      }
+    }
+  } else {
+    runMode = RunMode::kAutoRun;
+    opts::o0.SetValue(true); // enable default -O0
+  }
+
+  return kErrorNoError;
+}
+
+void MplOptions::HandleExtraOptions() {
+  for (const auto &val : opts::clangOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameClang);
+  }
+
+  for (const auto &val : opts::hir2mplOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameCpp2mpl);
+  }
+
+  for (const auto &val : opts::mpl2mplOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameMpl2mpl);
+    printExtraOptStr << " --mpl2mpl-opt=" << "\"" << val << "\"";
+  }
+
+  for (const auto &val : opts::meOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameMe);
+    printExtraOptStr << " --me-opt=" << "\"" << val << "\"";
+  }
+
+  for (const auto &val : opts::mplcgOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameMplcg);
+    printExtraOptStr << " --mplcg-opt=" << "\"" << val << "\"";
+  }
+
+  for (const auto &val : opts::asOpt.GetValues()) {
+    UpdateExeOptions(val, kAsFlag);
+  }
+
+  for (const auto &val : opts::ldOpt.GetValues()) {
+    UpdateExeOptions(val, kLdFlag);
+  }
+
+  for (const auto &val : opts::dex2mplOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameDex2mpl);
+  }
+
+  for (const auto &val : opts::jbc2mplOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameJbc2mpl);
+  }
+
+  for (const auto &val : opts::mplipaOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameMplipa);
+  }
+
+  // A workaround to pass --general-reg-only from the cg options to global options
+  auto it = exeOptions.find(kBinNameMplcg);
+  if (it != exeOptions.end()) {
+    for (auto &opt : std::as_const(it->second)) {
+      if (opt == "--general-reg-only") {
+        generalRegOnly = true;
+        break;
+      }
+    }
+  }
+}
+
+std::unique_ptr<Action> MplOptions::DecideRunningPhasesByType(const InputInfo *const inputInfo,
+                                                              bool isMultipleFiles) {
+  InputFileType inputFileType = inputInfo->GetInputFileType();
+  std::unique_ptr<Action> currentAction = std::make_unique<Action>(kInputPhase, inputInfo);
+  std::unique_ptr<Action> newAction;
+
+  bool isNeedMapleComb = true;
+  bool isNeedMplcg = true;
+  bool isNeedAs = true;
+  switch (inputFileType) {
+    case InputFileType::kFileTypeC:
+    case InputFileType::kFileTypeCpp:
+      UpdateRunningExe(kBinNameClang);
+      newAction = std::make_unique<Action>(kBinNameClang, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      [[clang::fallthrough]];
+    case InputFileType::kFileTypeAst:
+      UpdateRunningExe(kBinNameCpp2mpl);
+      newAction = std::make_unique<Action>(kBinNameCpp2mpl, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      break;
+    case InputFileType::kFileTypeJar:
+      // fall-through
+    case InputFileType::kFileTypeClass:
+      UpdateRunningExe(kBinNameJbc2mpl);
+      newAction = std::make_unique<Action>(kBinNameJbc2mpl, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      isNeedAs = false;
+      break;
+    case InputFileType::kFileTypeDex:
+      UpdateRunningExe(kBinNameDex2mpl);
+      newAction = std::make_unique<Action>(kBinNameDex2mpl, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      isNeedAs = false;
+      break;
+    case InputFileType::kFileTypeMpl:
+      break;
+    case InputFileType::kFileTypeMeMpl:
+    case InputFileType::kFileTypeVtableImplMpl:
+      isNeedMapleComb = false;
+      break;
+    case InputFileType::kFileTypeS:
+      isNeedMplcg = false;
+      isNeedMapleComb = false;
+      break;
+    case InputFileType::kFileTypeBpl:
+      break;
+    case InputFileType::kFileTypeObj:
+      isNeedMplcg = false;
+      isNeedMapleComb = false;
+      isNeedAs = false;
+      break;
+    case InputFileType::kFileTypeNone:
+      return nullptr;
+    default:
+      return nullptr;
+  }
+
+  if (opts::maplePhase == true) {
+    isNeedAs = false;
+  }
+
+  if (isNeedMapleComb) {
+    if (isMultipleFiles) {
+      selectedExes.push_back(kBinNameMapleCombWrp);
+      newAction = std::make_unique<Action>(kBinNameMapleCombWrp, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+    } else {
+      selectedExes.push_back(kBinNameMapleComb);
+      newAction = std::make_unique<Action>(kBinNameMapleComb, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+    }
+  }
+  if (isNeedMplcg && !isMultipleFiles) {
+    selectedExes.push_back(kBinNameMplcg);
+    runningExes.push_back(kBinNameMplcg);
+    newAction = std::make_unique<Action>(kBinNameMplcg, inputInfo, currentAction);
+    currentAction = std::move(newAction);
+  }
+
+  if (isNeedAs) {
+    UpdateRunningExe(kAsFlag);
+    newAction = std::make_unique<Action>(kAsFlag, inputInfo, currentAction);
+    currentAction = std::move(newAction);
+  }
+
+  if (!opts::compileWOLink) {
+    UpdateRunningExe(kLdFlag);
+    /* "Linking step" Action can have several inputActions.
+     * Each inputAction links to previous Actions to create the action tree.
+     * For linking step, inputActions are all assembly actions.
+     * Linking step Action is created outside this function because
+     * we must create all assembly actions (for all input files) before.
+     */
+  }
+
+  return currentAction;
+}
+
+ErrorCode MplOptions::DecideRunningPhases() {
+  ErrorCode ret = kErrorNoError;
+  std::vector<std::unique_ptr<Action>> linkActions;
+  std::unique_ptr<Action> lastAction;
+
+  bool isMultipleFiles = (inputInfos.size() > 1);
+
+  for (auto &inputInfo : inputInfos) {
+    CHECK_FATAL(inputInfo != nullptr, "InputInfo must be created!!");
+
+    lastAction = DecideRunningPhasesByType(inputInfo.get(), isMultipleFiles);
+
+    /* Add a message interface for correct exit with compilation error. And use it here instead of CHECK_FATAL. */
+    CHECK_FATAL(lastAction != nullptr, "Incorrect input file type: %s",
+                inputInfo->GetInputFile().c_str());
+
+    if ((lastAction->GetTool() == kAsFlag && !opts::compileWOLink) ||
+        lastAction->GetTool() == kInputPhase) {
+      /* 1. For linking step, inputActions are all assembly actions;
+       * 2. If we try to link with maple driver, inputActions are all kInputPhase objects;
+       */
+      linkActions.push_back(std::move(lastAction));
+    } else {
+      rootActions.push_back(std::move(lastAction));
+    }
+  }
+
+  if (!linkActions.empty()) {
+    /* "a.out" is the default output file name - fix if it's needed  */
+    auto currentAction = std::make_unique<Action>(kLdFlag, linkActions, AllocateInputInfo("a.out"));
+    rootActions.push_back(std::move(currentAction));
+  }
+
+  return ret;
+}
+
+ErrorCode MplOptions::MFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
+                                          const InputInfo *const inputInfo, bool &wasWrpCombCompilerCreated) const {
+  ErrorCode ret = kErrorNoError;
+
+  if (exe == kBinNameMe || exe == kBinNameMpl2mpl || exe == kBinNameMplcg) {
+    if (!wasWrpCombCompilerCreated) {
+      auto newAction = std::make_unique<Action>(kBinNameMapleCombWrp, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      wasWrpCombCompilerCreated = true;
+    } else {
+      return ret;
+    }
+  }
+
+  else {
+    auto newAction = std::make_unique<Action>(exe, inputInfo, currentAction);
+    currentAction = std::move(newAction);
+  }
+
+  return ret;
+}
+
+ErrorCode MplOptions::SFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
+                                          const InputInfo *const inputInfo, bool &isCombCompiler) const {
+  ErrorCode ret = kErrorNoError;
+
+  if (exe == kBinNameMe || exe == kBinNameMpl2mpl) {
+    if (!isCombCompiler) {
+      auto newAction = std::make_unique<Action>(kBinNameMapleComb, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      isCombCompiler = true;
+    } else {
+      return ret;
+    }
+  }
+
+  else {
+    auto newAction = std::make_unique<Action>(exe, inputInfo, currentAction);
+    currentAction = std::move(newAction);
+  }
+
+  return ret;
+}
+
+ErrorCode MplOptions::DecideRunningPhases(const std::vector<std::string> &runExes) {
+  ErrorCode ret = kErrorNoError;
+
+  bool isMultipleFiles = (inputInfos.size() > 1);
+
+  for (auto &inputInfo : inputInfos) {
+    CHECK_FATAL(inputInfo != nullptr, "InputInfo must be created!!");
+    /* MplOption is owner of all InputInfos. MplOption is alive during compilation,
+     * so we can use raw pointer inside an Action.
+     */
+    const InputInfo *const rawInputInfo = inputInfo.get();
+
+    bool isCombCompiler = false;
+    bool wasWrpCombCompilerCreated = false;
+
+    auto currentAction = std::make_unique<Action>(kInputPhase, inputInfo.get());
+
+    for (const auto &exe : runExes) {
+      if (isMultipleFiles) {
+        ret = MFCreateActionByExe(exe, currentAction, rawInputInfo, wasWrpCombCompilerCreated);
+        if (ret != kErrorNoError) {
+          return ret;
+        }
+      } else {
+        ret = SFCreateActionByExe(exe, currentAction, rawInputInfo, isCombCompiler);
+        if (ret != kErrorNoError) {
+          return ret;
+        }
+      }
+    }
+
+    rootActions.push_back(std::move(currentAction));
+  }
+
+  return ret;
+}
+
+void MplOptions::DumpActionTree() const {
+  for (auto &rNode : rootActions) {
+    DumpActionTree(*rNode, 0);
+  }
+}
+
+void MplOptions::DumpActionTree(const Action &action, int indents) const {
+  for (const std::unique_ptr<Action> &a : action.GetInputActions()) {
+    DumpActionTree(*a, indents + 1);
+  }
+
+  if (indents != 0) {
+    LogInfo::MapleLogger() << "|";
+    /* print indents */
+    for (int i = 0; i < indents; ++i) {
+      LogInfo::MapleLogger() << "-";
+    }
+  }
+
+  if (action.GetTool() == kInputPhase) {
+    LogInfo::MapleLogger() << action.GetTool() << " " << action.GetInputFile() << '\n';
+  } else {
+    LogInfo::MapleLogger() << action.GetTool() << '\n';
+  }
+}
+
+std::string MplOptions::GetCommonOptionsStr() const {
+  std::string driverOptions;
+  static const std::vector<maplecl::OptionInterface *> extraExclude = {
+      &opts::run, &opts::optionOpt, &opts::infile, &opts::mpl2mplOpt, &opts::meOpt,&opts::mplcgOpt,
+      &opts::o0, &opts::o1, &opts::o2, &opts::os
+  };
+
+  for (auto const &opt : driverCategory.GetEnabledOptions()) {
+    if (!(std::find(std::begin(extraExclude), std::end(extraExclude), opt) != std::end(extraExclude))) {
+      for (const auto &val : opt->GetRawValues()) {
+        if (!val.empty()) {
+          driverOptions += opt->GetName() + " " + val + " ";
+        } else {
+          driverOptions += opt->GetName() + " ";
+        }
+      }
+    }
+  }
+
+  return driverOptions;
+}
+
+InputInfo *MplOptions::AllocateInputInfo(const std::string &inputFile) {
+  auto inputInfo = std::make_unique<InputInfo>(inputFile);
+  InputInfo *ret = inputInfo.get();
+
+  inputInfos.push_back(std::move(inputInfo));
+
+  /* inputInfo continue to exist in inputInfos vector of unique_ptr so we can return raw pointer */
+  return ret;
+}
+
+ErrorCode MplOptions::CheckInputFiles() {
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+
+  /* Set input files with --infile="file1 file2" option */
+  if (opts::infile.IsEnabledByUser()) {
+    if (StringUtils::Trim(opts::infile).empty()) {
+      return kErrorFileNotFound;
+    }
+
+    std::vector<std::string> splitsInputFiles;
+    StringUtils::Split(opts::infile, splitsInputFiles, ',');
+
+    /* inputInfo describes each input file for driver */
+    for (auto &inFile : splitsInputFiles) {
+      if (FileUtils::IsFileExists(inFile)) {
+        inputFiles.push_back(inFile);
+        inputInfos.push_back(std::make_unique<InputInfo>(inFile));
+      } else {
+        LogInfo::MapleLogger(kLlErr) << "File does not exist: " << inFile << "\n";
+        return kErrorFileNotFound;
+      }
+    }
+  }
+
+  /* Set input files directly: maple file1 file2 */
+  for (auto &arg : badArgs) {
+    if (FileUtils::IsFileExists(arg.first)) {
+      inputFiles.push_back(arg.first);
+      inputInfos.push_back(std::make_unique<InputInfo>(arg.first));
+    } else {
+      LogInfo::MapleLogger(kLlErr) << "Unknown option or non-existent input file: " << arg.first << "\n";
+      if (!opts::ignoreUnkOpt) {
+        return kErrorInvalidParameter;
+      }
+    }
+  }
+
+  if (inputFiles.empty()) {
+    return kErrorFileNotFound;
+  }
+
+  return kErrorNoError;
+}
+
+ErrorCode MplOptions::AppendCombOptions(MIRSrcLang srcLang) {
+  ErrorCode ret = kErrorNoError;
+  if (runMode == RunMode::kCustomRun) {
+    return ret;
+  }
+
+  if (opts::o0) {
+    ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO0, sizeof(kMeDefaultOptionsO0) / sizeof(MplOption));
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+    if (srcLang != kSrcLangC) {
+      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0,
+                                 sizeof(kMpl2MplDefaultOptionsO0) / sizeof(MplOption));
+    } else {
+      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0ForC,
+                                 sizeof(kMpl2MplDefaultOptionsO0ForC) / sizeof(MplOption));
+    }
+  } else if (opts::o2) {
+    if (opts::withIpa) {
+      UpdateRunningExe(kBinNameMplipa);
+    }
+    if (srcLang != kSrcLangC) {
+      ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO2,
+                                 sizeof(kMeDefaultOptionsO2) / sizeof(MplOption));
+      if (ret != kErrorNoError) {
+        return ret;
+      }
+      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO2,
+                                 sizeof(kMpl2MplDefaultOptionsO2) / sizeof(MplOption));
+    } else {
+      ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO2ForC,
+                                 sizeof(kMeDefaultOptionsO2ForC) / sizeof(MplOption));
+      if (ret != kErrorNoError) {
+        return ret;
+      }
+      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO2ForC,
+                                 sizeof(kMpl2MplDefaultOptionsO2ForC) / sizeof(MplOption));
+    }
+  } else if (opts::os) {
+    if (srcLang == kSrcLangJava) {
+      return kErrorNotImplement;
+    }
+    ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsOs,
+                               sizeof(kMeDefaultOptionsOs) / sizeof(MplOption));
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+    ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsOs,
+                               sizeof(kMpl2MplDefaultOptionsOs) / sizeof(MplOption));
+  }
+
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  return ret;
+}
+
+ErrorCode MplOptions::AppendMplcgOptions(MIRSrcLang srcLang) {
+  ErrorCode ret = kErrorNoError;
+  if (runMode == RunMode::kCustomRun) {
+    return ret;
+  }
+  if (opts::o0) {
+    if (srcLang != kSrcLangC) {
+      ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsO0,
+                                 sizeof(kMplcgDefaultOptionsO0) / sizeof(MplOption));
+    } else {
+      ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsO0ForC,
+                                 sizeof(kMplcgDefaultOptionsO0ForC) / sizeof(MplOption));
+    }
+  } else if (opts::o2) {
+    if (srcLang != kSrcLangC) {
+      ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsO2,
+                                 sizeof(kMplcgDefaultOptionsO2) / sizeof(MplOption));
+    } else {
+      ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsO2ForC,
+                                 sizeof(kMplcgDefaultOptionsO2ForC) / sizeof(MplOption));
+    }
+  } else if (opts::os) {
+      if (srcLang == kSrcLangJava) {
+        return kErrorNotImplement;
+      }
+      ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsOs,
+                                 sizeof(kMplcgDefaultOptionsOs) / sizeof(MplOption));
+  }
+
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  return ret;
+}
+
+void MplOptions::DumpAppendedOptions(const std::string &exeName,
+                                     const MplOption mplOptions[], unsigned int length) const {
+  LogInfo::MapleLogger() << exeName << " Default Options: ";
+  for (size_t i = 0; i < length; ++i) {
+    LogInfo::MapleLogger() << mplOptions[i].GetKey() << " "
+                           << mplOptions[i].GetValue() << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+
+  LogInfo::MapleLogger() << exeName << " Extra Options: ";
+  auto it = exeOptions.find(exeName);
+  if (it != exeOptions.end()) {
+    for (auto &opt : it->second) {
+      LogInfo::MapleLogger() << opt << " ";
+    }
+  }
+
+  LogInfo::MapleLogger() << "\n";
+}
+
+ErrorCode MplOptions::AppendDefaultOptions(const std::string &exeName,
+                                           MplOption mplOptions[], unsigned int length) {
+  if (opts::debug) {
+    DumpAppendedOptions(exeName, mplOptions, length);
+  }
+
+  for (unsigned int i = 0; i < length; ++i) {
+    mplOptions[i].SetValue(FileUtils::AppendMapleRootIfNeeded(mplOptions[i].GetNeedRootPath(),
+                                                              mplOptions[i].GetValue(), GetExeFolder()));
+    auto &key = mplOptions[i].GetKey();
+    auto &val = mplOptions[i].GetValue();
+
+    if (!val.empty()) {
+      exeOptions[exeName].push_front(val);
+    }
+    if (!key.empty()) {
+      exeOptions[exeName].push_front(key);
+    }
+  }
+
+  auto iter = std::find(runningExes.begin(), runningExes.end(), exeName);
+  if (iter == runningExes.end()) {
+    runningExes.push_back(exeName);
+  }
+  return kErrorNoError;
+}
+
+void MplOptions::UpdateExeOptions(const std::string &options, const std::string &tool) {
+  std::vector<std::string> splittedOptions;
+  StringUtils::Split(options, splittedOptions, ' ');
+
+  auto &toolOptions = exeOptions[tool]; // generate empty entry, if it does not exist
+  for (auto &opt : splittedOptions) {
+    if (!opt.empty()) {
+      toolOptions.push_back(opt);
+    }
+  }
+}
+
+ErrorCode MplOptions::UpdateExeOptions(const std::string &args) {
+  std::vector<std::string> options;
+  StringUtils::Split(args, options, ':');
+
+  /* The number of a tools and options for them must be the same */
+  if (options.size() != runningExes.size()) {
+    LogInfo::MapleLogger(kLlErr) << "The --run and --option are not matched, please check them."
+                                 << "(Too many or too few)\n";
+    return kErrorInvalidParameter;
+  }
+
+  auto tool = runningExes.begin();
+  for (auto &opt : options) {
+    UpdateExeOptions(opt, *tool);
+    ++tool;
+  }
+
+  return kErrorNoError;
+}
+
+maplecl::OptionCategory *MplOptions::GetCategory(const std::string &tool) const {
+  auto it = exeCategories.find(tool);
+  if (it == exeCategories.end()) {
+    return nullptr;
+  }
+
+  return it->second;
+}
+
+void MplOptions::UpdateRunningExe(const std::string &args) {
+  std::vector<std::string> results;
+  StringUtils::Split(args, results, ':');
+  for (size_t i = 0; i < results.size(); ++i) {
+    auto iter = std::find(runningExes.begin(), runningExes.end(), results[i]);
+    if (iter == runningExes.end()) {
+      runningExes.push_back(results[i]);
+      selectedExes.push_back(results[i]);
+    }
+  }
+}
+
+std::string MplOptions::GetInputFileNameForPrint(const Action * const action) const {
+  auto genInputs = [](const auto &container) {
+    std::string inputs;
+    for (const auto &in : container) {
+      inputs += " " + in;
+    }
+    return inputs;
+  };
+
+  if (!runningExes.empty()) {
+    if (runningExes[0] == kBinNameMe || runningExes[0] == kBinNameMpl2mpl ||
+        runningExes[0] == kBinNameMplcg) {
+      return genInputs(GetInputFiles());
+    }
+  }
+
+  if (action == nullptr) {
+    return genInputs(GetInputFiles());
+  }
+
+  if (action->GetInputFileType() == InputFileType::kFileTypeVtableImplMpl) {
+    return action->GetFullOutputName() + ".VtableImpl.mpl";
+  }
+  if (action->GetInputFileType() == InputFileType::kFileTypeBpl) {
+    return action->GetFullOutputName() + ".bpl";
+  }
+  if (action->GetInputFileType() == InputFileType::kFileTypeMbc) {
+    return action->GetFullOutputName() + ".mbc";
+  }
+  if (action->GetInputFileType() == InputFileType::kFileTypeLmbc) {
+    return action->GetFullOutputName() + ".lmbc";
+  }
+  return action->GetFullOutputName() + ".mpl";
+}
+
+void MplOptions::PrintCommand(const Action * const action) {
+  if (hasPrinted) {
+    return;
+  }
+
+  std::ostringstream optionStr;
+  if (runMode == RunMode::kAutoRun) {
+    if (opts::o0) {
+      optionStr << " -O0";
+    } else if (opts::o1) {
+      optionStr << " -O1";
+    } else if (opts::o2) {
+      optionStr << " -O2";
+    } else if (opts::os) {
+      optionStr << " -Os";
+    }
+
+    std::string driverOptions = GetCommonOptionsStr();
+    auto inputs = GetInputFileNameForPrint(action);
+    LogInfo::MapleLogger() << "Starting:" << exeFolder << "maple" << optionStr.str()
+                           << printExtraOptStr.str() << " " << driverOptions << inputs << '\n';
+  }
+  if (runMode == RunMode::kCustomRun) {
+    PrintDetailCommand(action, true);
+  }
+  hasPrinted = true;
+}
+
+void MplOptions::ConnectOptStr(std::string &optionStr, const std::string &exeName, bool &firstComb,
+                               std::string &runStr) {
+  std::string connectSym = "";
+  if (exeOptions.find(exeName) != exeOptions.end()) {
+    if (!firstComb) {
+      runStr += (":" + exeName);
+      optionStr += ":";
+    } else {
+      runStr += exeName;
+      firstComb = false;
+    }
+    auto it = exeOptions.find(exeName);
+    for (auto &opt : std::as_const(it->second)) {
+      optionStr += (" " + opt);
+    }
+  }
+}
+
+void MplOptions::PrintDetailCommand(const Action * const action, bool isBeforeParse) {
+  if (exeOptions.find(kBinNameMe) == exeOptions.end() && exeOptions.find(kBinNameMpl2mpl) == exeOptions.end() &&
+      exeOptions.find(kBinNameMplcg) == exeOptions.end()) {
+    return;
+  }
+  std::string runStr = "--run=";
+  std::string optionStr;
+  optionStr += "--option=\"";
+  bool firstComb = true;
+  ConnectOptStr(optionStr, kBinNameMe, firstComb, runStr);
+  ConnectOptStr(optionStr, kBinNameMpl2mpl, firstComb, runStr);
+  ConnectOptStr(optionStr, kBinNameMplcg, firstComb, runStr);
+  optionStr += "\"";
+
+  std::string driverOptions = GetCommonOptionsStr();
+  auto inputs = GetInputFileNameForPrint(action);
+
+  if (isBeforeParse) {
+    LogInfo::MapleLogger() << "Starting:" << exeFolder << "maple " << runStr << " " << optionStr << " "
+                           << printExtraOptStr.str() << " " << driverOptions << inputs << '\n';
+  } else {
+    LogInfo::MapleLogger() << "Finished:" << exeFolder << "maple " << runStr << " " << optionStr << " "
+                           << driverOptions << inputs << '\n';
+  }
+}
+} // namespace maple
diff --git a/src/mapleall/maple_driver/src/mplcg_compiler.cpp b/src/mapleall/maple_driver/src/mplcg_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..61578109cefaa0d084db5307b2401c00e9b527ee
--- /dev/null
+++ b/src/mapleall/maple_driver/src/mplcg_compiler.cpp
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "compiler.h"
+#include "driver_options.h"
+#include "default_options.def"
+#include "mpl_logging.h"
+#include "mpl_timer.h"
+#include "driver_runner.h"
+
+namespace maple {
+using namespace maplebe;
+
+DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options,
+                                               const Action &action [[maybe_unused]]) const {
+  uint32_t len = 0;
+  MplOption *kMplcgDefaultOptions = nullptr;
+
+  if (opts::o0) {
+    len = sizeof(kMplcgDefaultOptionsO0) / sizeof(MplOption);
+    kMplcgDefaultOptions = kMplcgDefaultOptionsO0;
+  } else if (opts::o2) {
+    len = sizeof(kMplcgDefaultOptionsO2) / sizeof(MplOption);
+    kMplcgDefaultOptions = kMplcgDefaultOptionsO2;
+  }
+
+  if (kMplcgDefaultOptions == nullptr) {
+    return DefaultOption();
+  }
+
+  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
+  for (uint32_t i = 0; i < len; ++i) {
+    defaultOptions.mplOptions[i] = kMplcgDefaultOptions[i];
+  }
+
+  for (uint32_t i = 0; i < defaultOptions.length; ++i) {
+    defaultOptions.mplOptions[i].SetValue(
+        FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
+                                           defaultOptions.mplOptions[i].GetValue(),
+                                           options.GetExeFolder()));
+  }
+  return defaultOptions;
+}
+
+const std::string &MplcgCompiler::GetBinName() const {
+  return kBinNameMplcg;
+}
+
+std::string MplcgCompiler::GetInputFile(const MplOptions &options [[maybe_unused]], const Action &action,
+                                        const MIRModule *md) const {
+  if (action.IsItFirstRealAction()) {
+    return action.GetInputFile();
+  }
+  // Get base file name
+  auto idx = action.GetOutputName().find(".VtableImpl");
+  std::string outputName = action.GetOutputName();
+  if (idx != std::string::npos) {
+    outputName = action.GetOutputName().substr(0, idx);
+  }
+  if (md != nullptr && md->GetSrcLang() == kSrcLangC) {
+    return action.GetOutputFolder() + outputName + ".me.mpl";
+  }
+  return action.GetOutputFolder() + outputName + ".VtableImpl.mpl";
+}
+
+void MplcgCompiler::SetOutputFileName(const MplOptions &options, const Action &action, const MIRModule &md) {
+  if (md.GetSrcLang() == kSrcLangC) {
+    baseName = action.GetFullOutputName();
+  } else {
+    baseName = action.GetOutputFolder() + FileUtils::GetFileName(GetInputFile(options, action, &md), false);
+  }
+  outputFile = baseName + ".s";
+}
+
+void MplcgCompiler::PrintMplcgCommand(const MplOptions &options, const Action &action,
+                                      const MIRModule &md) const {
+  std::string runStr = "--run=";
+  std::string optionStr = "--option=\"";
+  std::string connectSym = "";
+  if (options.GetExeOptions().find(kBinNameMplcg) != options.GetExeOptions().end()) {
+    runStr += "mplcg";
+    auto it = options.GetExeOptions().find(kBinNameMplcg);
+    if (it == options.GetExeOptions().end()) {
+      return;
+    }
+    for (auto &opt : it->second) {
+      optionStr += (" " + opt);
+    }
+  }
+  optionStr += "\"";
+
+  std::string driverOptions = options.GetCommonOptionsStr();
+
+  LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " " << optionStr << " "
+                         << driverOptions << "--infile " << GetInputFile(options, action, &md) << '\n';
+}
+
+ErrorCode MplcgCompiler::MakeCGOptions(const MplOptions &options) const {
+  auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMplcg);
+  if (it == options.GetRunningExes().end()) {
+    return kErrorNoError;
+  }
+  CGOptions &cgOption = CGOptions::GetInstance();
+  cgOption.SetOption(CGOptions::kDefaultOptions);
+#if DEBUG
+  /* for convinence .loc is generated by default for debug maple compiler */
+  cgOption.SetOption(CGOptions::kWithLoc);
+#endif
+  /* use maple flags to set cg flags */
+  if (opts::withDwarf) {
+    cgOption.SetOption(CGOptions::kWithDwarf);
+#if DEBUG
+    cgOption.SetOption(CGOptions::kVerboseAsm);
+#endif
+  }
+  cgOption.SetGenerateFlags(CGOptions::kDefaultGflags);
+
+  auto itOpt = options.GetExeOptions().find(kBinNameMplcg);
+  if (itOpt != options.GetExeOptions().end()) {
+    const auto &cgExeOpts = itOpt->second;
+    const std::deque<std::string_view> strCgOptions(cgExeOpts.begin(), cgExeOpts.end());
+    (void)maplecl::CommandLine::GetCommandLine().HandleInputArgs(strCgOptions, cgCategory);
+  }
+
+  bool result = cgOption.SolveOptions(opts::debug);
+  if (!result) {
+    LogInfo::MapleLogger() << "Meet error mplcg options\n";
+    return kErrorCompileFail;
+  }
+  return kErrorNoError;
+}
+
+ErrorCode MplcgCompiler::GetMplcgOptions(MplOptions &options, const Action &action,
+                                         const MIRModule *theModule) const {
+  ErrorCode ret;
+  if (options.GetRunMode() == kAutoRun) {
+    if (theModule == nullptr) {
+      std::string fileName = GetInputFile(options, action, theModule);
+      MIRModule module(fileName);
+      std::unique_ptr<MIRParser> theParser;
+      theParser.reset(new MIRParser(module));
+      MIRSrcLang srcLang = kSrcLangUnknown;
+      bool parsed = theParser->ParseSrcLang(srcLang);
+      if (!parsed) {
+        return kErrorCompileFail;
+      }
+      ret = options.AppendMplcgOptions(srcLang);
+      if (ret != kErrorNoError) {
+        return kErrorCompileFail;
+      }
+    } else {
+      ret = options.AppendMplcgOptions(theModule->GetSrcLang());
+      if (ret != kErrorNoError) {
+        return kErrorCompileFail;
+      }
+    }
+  }
+
+  ret = MakeCGOptions(options);
+  return ret;
+}
+
+ErrorCode MplcgCompiler::Compile(MplOptions &options, const Action &action,
+                                 std::unique_ptr<MIRModule> &theModule) {
+  ErrorCode ret = GetMplcgOptions(options, action, theModule.get());
+  if (ret != kErrorNoError) {
+    return kErrorCompileFail;
+  }
+  CGOptions &cgOption = CGOptions::GetInstance();
+  std::string fileName = GetInputFile(options, action, theModule.get());
+  bool fileRead = true;
+  if (theModule == nullptr) {
+    MPLTimer timer;
+    timer.Start();
+    fileRead = false;
+    theModule = std::make_unique<MIRModule>(fileName);
+    theModule->SetWithMe(
+        std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(),
+                  kBinNameMe) != options.GetRunningExes().end());
+    if (action.GetInputFileType() != kFileTypeBpl &&
+        action.GetInputFileType() != kFileTypeMbc &&
+        action.GetInputFileType() != kFileTypeLmbc) {
+      std::unique_ptr<MIRParser> theParser;
+      theParser.reset(new MIRParser(*theModule));
+      bool parsed = theParser->ParseMIR(0, cgOption.GetParserOption());
+      if (parsed) {
+        if (!CGOptions::IsQuiet() && (theParser->GetWarning().size() != 0)) {
+          theParser->EmitWarning(fileName);
+        }
+      } else {
+        if (theParser != nullptr) {
+          theParser->EmitError(fileName);
+        }
+        return kErrorCompileFail;
+      }
+    } else {
+      BinaryMplImport binMplt(*theModule);
+      binMplt.SetImported(false);
+      std::string modid = theModule->GetFileName();
+      bool imported = binMplt.Import(modid, true);
+      if (!imported) {
+        return kErrorCompileFail;
+      }
+    }
+    timer.Stop();
+    LogInfo::MapleLogger() << "Mplcg Parser consumed " << timer.ElapsedMilliseconds() << "ms\n";
+  }
+  SetOutputFileName(options, action, *theModule);
+  theModule->SetInputFileName(fileName);
+  LogInfo::MapleLogger() << "Starting mplcg\n";
+  DriverRunner runner(theModule.get(), options.GetSelectedExes(), action.GetInputFileType(), fileName,
+                      opts::withDwarf, fileRead, opts::timePhase);
+  if (opts::debug) {
+    PrintMplcgCommand(options, action, *theModule);
+  }
+  runner.SetPrintOutExe(kBinNameMplcg);
+  runner.SetCGInfo(&cgOption, fileName);
+  runner.ProcessCGPhase(outputFile, baseName);
+  return kErrorNoError;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/triple.cpp b/src/mapleall/maple_driver/src/triple.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe206a8b4fd304141d0d3c4dee50fe9457d6f919
--- /dev/null
+++ b/src/mapleall/maple_driver/src/triple.cpp
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "triple.h"
+#include "driver_options.h"
+
+namespace opts {
+
+maplecl::Option<bool> bigendian({"-Be", "--Be", "--BigEndian", "-be", "--be", "-mbig-endian"},
+                           "  --BigEndian/-Be            \tUsing BigEndian\n"
+                           "  --no-BigEndian             \tUsing LittleEndian\n",
+                           {driverCategory, hir2mplCategory, dex2mplCategory, ipaCategory},
+                           maplecl::DisableWith("--no-BigEndian"));
+
+maplecl::Option<bool> ilp32({"--ilp32", "-ilp32", "--arm64-ilp32"},
+                       "  --ilp32                              \tarm64 with a 32-bit ABI instead of a 64bit ABI\n",
+                       {driverCategory, hir2mplCategory, dex2mplCategory, ipaCategory});
+
+maplecl::Option<std::string> mabi({"-mabi"},
+                             "  -mabi=<abi>                 \tSpecify integer and floating-point calling convention\n",
+                             {driverCategory, hir2mplCategory, dex2mplCategory, ipaCategory});
+
+}
+
+namespace maple {
+
+Triple::ArchType Triple::ParseArch(std::string_view archStr) const {
+  if (maple::utils::Contains({"aarch64", "aarch64_le"}, archStr)) {
+    return Triple::ArchType::aarch64;
+  } else if (maple::utils::Contains({"aarch64_be"}, archStr)) {
+    return Triple::ArchType::aarch64_be;
+  }
+
+  // Currently Triple support only aarch64
+  return Triple::UnknownArch;
+}
+
+Triple::EnvironmentType Triple::ParseEnvironment(std::string_view archStr) const {
+  if (maple::utils::Contains({"ilp32", "gnu_ilp32", "gnuilp32"}, archStr)) {
+    return Triple::EnvironmentType::GNUILP32;
+  } else if (maple::utils::Contains({"gnu"}, archStr)) {
+    return Triple::EnvironmentType::GNU;
+  }
+
+  // Currently Triple support only ilp32 and default gnu/LP64 ABI
+  return Triple::UnknownEnvironment;
+}
+
+void Triple::Init() {
+  /* Currently Triple is used only to configure aarch64: be/le, ILP32/LP64
+   * Other architectures (TARGX86_64, TARGX86, TARGARM32, TARGVM) are configured with compiler build config */
+#if TARGAARCH64
+  arch = (opts::bigendian) ? Triple::ArchType::aarch64_be : Triple::ArchType::aarch64;
+  environment = (opts::ilp32) ? Triple::EnvironmentType::GNUILP32 : Triple::EnvironmentType::GNU;
+
+  if (opts::mabi.IsEnabledByUser()) {
+    auto tmpEnvironment = ParseEnvironment(opts::mabi.GetValue());
+    if (tmpEnvironment != Triple::UnknownEnvironment) {
+      environment = tmpEnvironment;
+    }
+  }
+#endif
+}
+
+void Triple::Init(const std::string &target) {
+  data = target;
+
+  /* Currently Triple is used only to configure aarch64: be/le, ILP32/LP64.
+   * Other architectures (TARGX86_64, TARGX86, TARGARM32, TARGVM) are configured with compiler build config */
+#if TARGAARCH64
+  Init();
+
+  std::vector<std::string_view> components;
+  maple::StringUtils::SplitSV(data, components, '-');
+  if (components.size() == 0) { // as minimum 1 component must be
+    return;
+  }
+
+  auto tmpArch = ParseArch(components[0]); // to not overwrite arch seting by opts::bigendian
+  if (tmpArch == Triple::UnknownArch) {
+    return;
+  }
+  arch = tmpArch;
+
+  /* Try to check environment in option.
+   * As example, it can be: aarch64-none-linux-gnu or aarch64-linux-gnu or aarch64-gnu, where gnu is environment */
+  for (int i = 1; i < components.size(); ++i) {
+    auto tmpEnvironment = ParseEnvironment(components[i]);
+    if (tmpEnvironment != Triple::UnknownEnvironment) {
+      environment = tmpEnvironment;
+      break;
+    }
+  }
+#endif
+}
+
+std::string Triple::GetArchName() const {
+  switch (arch) {
+    case ArchType::aarch64_be: return "aarch64_be";
+    case ArchType::aarch64: return "aarch64";
+    default: ASSERT(false, "Unknown Architecture Type\n");
+  }
+  return "";
+}
+
+std::string Triple::GetEnvironmentName() const {
+  switch (environment) {
+    case EnvironmentType::GNUILP32: return "gnu_ilp32";
+    case EnvironmentType::GNU: return "gnu";
+    default: ASSERT(false, "Unknown Environment Type\n");
+  }
+  return "";
+}
+
+std::string Triple::Str() const {
+  if (!data.empty()) {
+    return data;
+  }
+
+  if (GetArch() != ArchType::UnknownArch &&
+      GetEnvironment() != Triple::EnvironmentType::UnknownEnvironment) {
+    /* only linux platform is supported, so "-linux-" is hardcoded */
+    return GetArchName() + "-linux-" + GetEnvironmentName();
+  }
+
+  CHECK_FATAL(false, "Only aarch64/aarch64_be GNU/GNUILP32 targets are supported\n");
+  return data;
+}
+
+} // namespace maple
diff --git a/src/mapleall/maple_ipa/BUILD.gn b/src/mapleall/maple_ipa/BUILD.gn
new file mode 100755
index 0000000000000000000000000000000000000000..bc10ad127092957797d10efd3684f245f269764b
--- /dev/null
+++ b/src/mapleall/maple_ipa/BUILD.gn
@@ -0,0 +1,48 @@
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+include_directories = [
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_me/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include/old",
+  "${MAPLEALL_ROOT}/mpl2mpl/include",
+  "${MAPLEALL_ROOT}/maple_phase/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+]
+
+src_libmplipa = [
+  "src/old/ipa_escape_analysis.cpp",
+  "src/old/do_ipa_escape_analysis.cpp",
+  "src/old/ea_connection_graph.cpp",
+  "src/old/ipa_option.cpp",
+  "src/ipa_side_effect.cpp",
+  "src/ipa_phase_manager.cpp",
+  "src/prop_return_null.cpp",
+  "src/prop_parameter_type.cpp",
+  "src/ipa_collect.cpp",
+  "src/ipa_clone.cpp",
+  "src/region_identify.cpp",
+]
+
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+
+static_library("libmplipa") {
+  sources = src_libmplipa
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
diff --git a/src/mapleall/maple_ipa/CMakeLists.txt b/src/mapleall/maple_ipa/CMakeLists.txt
new file mode 100755
index 0000000000000000000000000000000000000000..8737cfad45938602d35aaeefda5f3e6ab83f7fc7
--- /dev/null
+++ b/src/mapleall/maple_ipa/CMakeLists.txt
@@ -0,0 +1,46 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(src_libmplipa
+  src/old/ipa_escape_analysis.cpp
+  src/old/do_ipa_escape_analysis.cpp
+  src/old/ea_connection_graph.cpp
+  src/old/ipa_option.cpp
+  src/ipa_side_effect.cpp
+  src/ipa_phase_manager.cpp
+  src/prop_return_null.cpp
+  src/prop_parameter_type.cpp
+  src/ipa_collect.cpp
+  src/ipa_clone.cpp
+  src/region_identify.cpp
+)
+
+add_library(libmplipa STATIC ${src_libmplipa})
+target_include_directories(libmplipa PRIVATE
+  ${MAPLEALL_ROOT}/maple_ir/include
+  ${MAPLEALL_ROOT}/mempool/include
+  ${MAPLEALL_ROOT}/maple_util/include
+  ${MAPLEALL_ROOT}/maple_me/include
+  ${MAPLEALL_ROOT}/maple_ipa/include
+  ${MAPLEALL_ROOT}/maple_ipa/include/old
+  ${MAPLEALL_ROOT}/mpl2mpl/include
+  ${MAPLEALL_ROOT}/maple_phase/include
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+)
+
+set_target_properties(libmplipa PROPERTIES 
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
\ No newline at end of file
diff --git a/src/mapleall/maple_ipa/include/func_desc.def b/src/mapleall/maple_ipa/include/func_desc.def
new file mode 100644
index 0000000000000000000000000000000000000000..14c3641f3f165284f8d3dcc99f003d9880eb5b61
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/func_desc.def
@@ -0,0 +1,539 @@
+ /*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+//assert.h
+{"assert", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"static_assert", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+
+//fenv.h
+{"feclearexcept", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fetestexcept", {FI::kPure, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"feraiseexcept", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fegetexceptflag", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"fesetexceptflag", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"fesetround", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fegetround", {FI::kPure, RI::kNoAlias, {}}},
+{"fegetenv", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"fesetenv", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"feholdexcept", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"feupdateenv", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+
+//ctype.h
+{"isalnum", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isalpha", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"islower", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isupper", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isdigit", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isxdigit", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iscntrl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isgraph", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isspace", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isblank", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isprint", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ispunct", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tolower", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"toupper", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"atof", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"atoi", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"atol", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"atoll", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"strtol", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"strtoll", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"strtoul", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"strtoull", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"strtof", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"strtod", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"strtold", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"strtoimax", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"strtoumax", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"strcpy", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly}}},
+{"strcpy_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"strncpy", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strncpy_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strcat", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly}}},
+{"strcat_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"strncat", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strncat_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strxfrm", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strdup", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"strndup", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strlen", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"strnlen_s", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strcmp", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"strncmp", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strcoll", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"strchr", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strrchr", {FI::kPure, RI::kAliasParam0, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"strspn", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"strcspn", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"strpbrk", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"strstr", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"strtok", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"strtok_s", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"memchr", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"memcmp", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"memset", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"memset_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"memcpy", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"memcpy_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"memmove", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"memmove_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"memccpy", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"strerror", {FI::kPure, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"strerror_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"strerrorlen_s", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+
+//complex.h
+{"CMPLXF", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"CMPLX", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"CMPLXL", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"crealf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"creal", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"creall", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cimagf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cimag", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cimagl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cabsf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cabs", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cabsl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cargf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"carg", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cargl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"conjf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"conj", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"conjl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cprojf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cproj", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cprojl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"crealf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"creal", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"creall", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cexpf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cexp", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cexpl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"clogf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"clog", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"clogl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cpowf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"cpow", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"cpowl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"csqrtf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"csqrt", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"csqrtl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"csinf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"csin", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"csinl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ccosf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ccos", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ccosl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ctanf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ctan", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ctanl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"casinf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"casin", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"casinl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cacosf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cacos", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cacosl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"catanf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"catan", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"catanl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"csinhf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"csinh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"csinhl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ccoshf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ccosh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ccoshl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ctanhf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ctanh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ctanhl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"casinhf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"casinh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"casinhl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cacoshf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cacosh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cacoshl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"catanhf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"catanh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"catanhl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+
+//local.h
+{"setlocale", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"localeconv", {FI::kUnknown, RI::kNoAlias, {}}},
+
+//math.h
+{"abs", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"labs", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"llabs", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"imaxabs", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"div", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"ldiv", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"lldiv", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"imaxdiv", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fabs", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fabsf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fabsl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fabs32", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fabs64", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fabs128", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fmodf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fmod", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fmodl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"remainderf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"remainder", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"remainderl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"remquo", {FI::kUnknown, RI::kAliasParam2, {PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"remquof", {FI::kUnknown, RI::kAliasParam2, {PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"remquol", {FI::kUnknown, RI::kAliasParam2, {PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"fma", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fmaf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fmal", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fmaxf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fmax", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fmaxl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fminf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fmin", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fminl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fdimf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fdim", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fdiml", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"nanf", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"nan", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"nanl", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"nan32", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"nan64", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"nan128", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"exp", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"expf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"expl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"exp2", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"exp2f", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"exp2l", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"expm1", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"expm1f", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"expm1l", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"logf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"logl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log10", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log10f", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log10l", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log2", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log2f", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log2l", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log1p", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log1pf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"log1pl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"pow", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"powf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"powl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"sqrt", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"sqrtf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"sqrtl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cbrt", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cbrtf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cbrtl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"hypot", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"hypotf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"hypotl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"sin", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"sinf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"sinl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cos", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cosf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cosl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tan", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tanf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tanl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"asin", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"asinf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"asinl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"acos", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"acosf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"acosl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"atan", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"atanf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"atanl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"atan2", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"atan2f", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"atan2l", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"sinh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"sinhf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"sinhl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"cosh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"coshf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"coshl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tanh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tanhf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tanhl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"asinh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"asinhf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"asinhl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"acosh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"acoshf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"acoshl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"atanh", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"atanhf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"atanhl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"erf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"erff", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"erfl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"erfc", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"erfcf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"erfcl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tgamma", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tgammaf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"tgammal", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"lgamma", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"lgammaf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"lgammal", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ceil", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ceilf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ceill", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"floor", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"floorf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"floorl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"trunc", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"truncf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"truncl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"round", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"roundf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"roundl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"lround", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"lroundf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"lroundl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"llround", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"llroundf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"llroundl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"nearbyint", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"nearbyintf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"nearbyintl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"rint", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"rintf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"rintl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"lrint", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"lrintf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"lrintl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"llrint", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"llrintf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"llrintl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"frexp", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"frexpf", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"frexpl", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"ldexp", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"ldexpf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"ldexpl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"modf", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"modff", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"modfl", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"scalbn", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"scalbnf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"scalbnl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"scalbln", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"scalblnf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"scalblnl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"ilogb", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ilogbf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ilogbl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"logb", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"logbf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"logbl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"nextafter", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"nextafterf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"nextafterl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"nexttoward", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"nexttowardf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"nexttowardl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"copysign", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"copysignf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"copysignl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fpclassify", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isfinite", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isinf", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isnan", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isnormal", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"signbit", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"isgreater", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"isgreaterequal", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"isless", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"islessequal", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"islessgreater", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"isunordered", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+
+//setjmp.h
+{"abort", {FI::kConst, RI::kNoAlias, {}}},
+{"exit", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"quick_exit", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"_Exit", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"atexit", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"at_quick_exit", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"system", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"getenv", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"getenv_s", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"signal", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"raise", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"setjmp", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly}}},
+{"longjmp", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+
+//stdarg.h
+{"va_start", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"va_arg", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly}}},
+{"va_copy", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly}}},
+{"va_end", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly}}},
+
+//stdlib.h
+{"malloc", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"calloc", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"realloc", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"free", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly}}},
+{"aligned_alloc", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"mblen", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"mbtowc", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"wctomb", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"wctomb_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"mbstowcs", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"mbstowcs_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+{"mbsinit", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly}}},
+{"btowc", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"wctob", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"mbrlen", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"mbrtowc", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"wcrtomb", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"wcrtomb_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"mbsrtowcs", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadWriteMemory, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"mbsrtowcs_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"wcsrtombs", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadWriteMemory, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"wcsrtombs_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+
+//wctype.h
+{"iswalnum", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswalpha", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswlower", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswupper", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswdigit", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswxdigit", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswcntrl", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswgraph", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswspace", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswblank", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswprint", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswpunct", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"iswctype", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"towlower", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"towupper", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"towctrans", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+
+//time.h
+{"difftime", {FI::kConst, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"time", {FI::kPure, RI::kNoAlias, {PI::kWriteMemoryOnly}}},
+{"timespec_get", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"timespec_getes", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"asctime", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"asctime_r", {FI::kUnknown, RI::kAliasParam1, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"asctime_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"ctime", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"ctime_r", {FI::kUnknown, RI::kAliasParam1, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"ctime_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"strftime", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"wcsftime", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"gmtime", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"gmtime_r", {FI::kUnknown, RI::kAliasParam1, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"gmtime_s", {FI::kUnknown, RI::kAliasParam1, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"localtime", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"localtime_r", {FI::kUnknown, RI::kAliasParam1, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"localtime_s", {FI::kUnknown, RI::kAliasParam1, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"mktime", {FI::kUnknown, RI::kNoAlias, {PI::kUnknown}}},
+
+//stdalign.h
+{"offsetof", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly}}},
+
+//stdio.h
+{"fopen", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"fopen_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"freopen", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"freopen_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly}}},
+{"fclose", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"fflush", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"setbuf", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly}}},
+{"setvbuf", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fwide", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"fread", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"fwrite", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"fgetc", {FI::kPure, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"getc", {FI::kPure, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"fgets", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fputc", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"putc", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"fputs", {FI::kUnknown, RI::kAliasParam1, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"getchar", {FI::kUnknown, RI::kNoAlias, {}}},
+{"gets", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly}}},
+{"gets_s", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+{"putchar", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"puts", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"ungetc", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"fgetwc", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"getwc", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"fgetws", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadMemoryOnly}}},
+{"fputwc", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"putwc", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"fputws", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"getwchar", {FI::kUnknown, RI::kNoAlias, {}}},
+{"putwchar", {FI::kUnknown, RI::kNoAlias, {PI::kReadSelfOnly}}},
+{"ungetwc", {FI::kUnknown, RI::kAliasParam1, {PI::kReadSelfOnly, PI::kWriteMemoryOnly}}},
+{"scanf", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"fscanf", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"sscanf", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"scanf_s", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"fscanf_s", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"sscanf_s", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"printf", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"fprintf", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"sprintf", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"snprintf", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"printf_s", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"fprintf_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"sprintf_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"snprintf_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"wscanf", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"fwscanf", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"swscanf", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"wscanf_s", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"fwscanf_s", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"swscanf_s", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly, PI::kWriteMemoryOnly}}},
+{"wprintf", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"fwprintf", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"swprintf", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"wprintf_s", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"fwprintf_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"swprintf_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"snwprintf_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadWriteMemory, PI::kReadWriteMemory, PI::kReadWriteMemory}}},
+{"ftell", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"fgetpos", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"fseek", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}},
+{"fsetpos", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadMemoryOnly}}},
+{"rewind", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly}}},
+{"clearerr", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly}}},
+{"feof", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"ferror", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"perror", {FI::kPure, RI::kNoAlias, {PI::kReadMemoryOnly}}},
+{"remove", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly}}},
+{"rename", {FI::kUnknown, RI::kNoAlias, {PI::kReadMemoryOnly, PI::kWriteMemoryOnly}}},
+{"tmpnam", {FI::kUnknown, RI::kAliasParam0, {PI::kWriteMemoryOnly}}},
+{"tmpnam_s", {FI::kUnknown, RI::kNoAlias, {PI::kWriteMemoryOnly, PI::kReadSelfOnly}}},
+
+//for java
+{"MCC_GetOrInsertLiteral", {FI::kPure, RI::kUnknown, {PI::kReadMemoryOnly}}},
+
+// user config
+{"Hlog", {FI::kPure, RI::kNoAlias, {PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadSelfOnly, PI::kReadSelfOnly}}}
diff --git a/src/mapleall/maple_ipa/include/ipa_clone.h b/src/mapleall/maple_ipa/include/ipa_clone.h
new file mode 100644
index 0000000000000000000000000000000000000000..ccb3f4ac78a3a142f02e7b92c60a134d62034cda
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/ipa_clone.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IPA_INCLUDE_IPACLONE_H
+#define MAPLE_IPA_INCLUDE_IPACLONE_H
+#include "mir_module.h"
+#include "mir_function.h"
+#include "mir_builder.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "class_hierarchy_phase.h"
+#include "me_ir.h"
+#include "maple_phase_manager.h"
+namespace maple {
+constexpr uint32 kNumOfImpExprUpper = 64;
+class IpaClone : public AnalysisResult {
+ public:
+  IpaClone(MIRModule *mod, MemPool *memPool, MIRBuilder &builder)
+      : AnalysisResult(memPool), mirModule(mod), allocator(memPool), mirBuilder(builder), curFunc(nullptr) {}
+  ~IpaClone() override {
+    mirModule = nullptr;
+    curFunc = nullptr;
+  }
+
+  static MIRSymbol *IpaCloneLocalSymbol(const MIRSymbol &oldSym, const MIRFunction &newFunc);
+  static void IpaCloneSymbols(MIRFunction &newFunc, const MIRFunction &oldFunc);
+  static void IpaCloneLabels(MIRFunction &newFunc, const MIRFunction &oldFunc);
+  static void IpaClonePregTable(MIRFunction &newFunc, const MIRFunction &oldFunc);
+  MIRFunction *IpaCloneFunction(MIRFunction &originalFunction, const std::string &fullName) const;
+  MIRFunction *IpaCloneFunctionWithFreq(MIRFunction &originalFunction,
+                                        const std::string &fullName, uint64_t callSiteFreq) const;
+  bool IsBrCondOrIf(Opcode op) const;
+  void DoIpaClone();
+  void InitParams();
+  void CopyFuncInfo(MIRFunction &originalFunction, MIRFunction &newFunc) const;
+  void IpaCloneArgument(MIRFunction &originalFunction, ArgVector &argument) const;
+  void RemoveUnneedParameter(MIRFunction *newFunc, uint32 paramIndex, int64_t value) const;
+  void DecideCloneFunction(std::vector<ImpExpr> &result, uint32 paramIndex, std::map<uint32,
+                           std::vector<int64_t>> &evalMap) const;
+  void ReplaceIfCondtion(MIRFunction *newFunc, std::vector<ImpExpr> &result, uint64_t res) const;
+  void RemoveSwitchCase(MIRFunction &newFunc, SwitchNode &switchStmt, std::vector<int64_t> &calleeValue) const;
+  void RemoveUnneedSwitchCase(MIRFunction &newFunc, std::vector<ImpExpr> &result,
+                              std::vector<int64_t> &calleeValue) const;
+  bool CheckImportantExprHasBr(const std::vector<ImpExpr> &exprVec) const;
+  void EvalCompareResult(std::vector<ImpExpr> &result, std::map<uint32, std::vector<int64_t>> &evalMap,
+                         std::map<int64_t, std::vector<CallerSummary>> &summary, uint32 index) const;
+  void EvalImportantExpression(MIRFunction *func, std::vector<ImpExpr> &result);
+  bool CheckCostModel(uint32 paramIndex, std::vector<int64_t> &calleeValue, std::vector<ImpExpr> &result) const;
+  void ComupteValue(const IntVal& value, const IntVal& paramValue, const CompareNode &cond, uint64_t &bitRes) const;
+  void CloneNoImportantExpressFunction(MIRFunction *func, uint32 paramIndex) const;
+  void ModifyParameterSideEffect(MIRFunction *newFunc, uint32 paramIndex) const;
+
+ private:
+  MIRModule *mirModule;
+  MapleAllocator allocator;
+  MIRBuilder &mirBuilder;
+  MIRFunction *curFunc;
+  uint32 numOfCloneVersions = 0;
+  uint32 numOfImpExprLowBound = 0;
+  uint32 numOfImpExprHighBound = 0;
+  uint32 numOfCallSiteLowBound = 0;
+  uint32 numOfCallSiteUpBound = 0;
+  uint32 numOfConstpropValue = 0;
+};
+MAPLE_MODULE_PHASE_DECLARE_BEGIN(M2MIpaClone)
+  IpaClone *GetResult() {
+    return cl;
+  }
+  IpaClone *cl = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_MODULE_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_IPA_INCLUDE_IPACLONE_H
diff --git a/src/mapleall/maple_ipa/include/ipa_collect.h b/src/mapleall/maple_ipa/include/ipa_collect.h
new file mode 100644
index 0000000000000000000000000000000000000000..090b3bc5ebcf8a324de8cbc70f1be48f7560171a
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/ipa_collect.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IPA_INCLUDE_COLLECT_IPA_INFO_H
+#define MAPLE_IPA_INCLUDE_COLLECT_IPA_INFO_H
+#include "mir_nodes.h"
+#include "mir_builder.h"
+#include "call_graph.h"
+#include "me_ir.h"
+#include "me_irmap.h"
+#include "dominance.h"
+#include "class_hierarchy.h"
+#include "maple_phase.h"
+#include "mir_module.h"
+#include "stmt_identify.h"
+#include "maple_phase_manager.h"
+namespace maple {
+using StmtIndex = size_t;
+using StmtInfoId = size_t;
+
+union ParamValue {
+  bool valueBool;
+  int64_t valueInt;
+  float valueFloat;
+  double valueDouble;
+};
+
+enum ValueType {
+  kBool,
+  kInt,
+  kFloat,
+  kDouble,
+};
+
+class CollectIpaInfo {
+ public:
+  CollectIpaInfo(MIRModule &mod, MemPool &memPool)
+      : module(mod),
+        builder(*mod.GetMIRBuilder()),
+        curFunc(nullptr),
+        allocator(&memPool),
+        stmtInfoToIntegerMap(allocator.Adapter()),
+        integerString(allocator.Adapter()),
+        stmtInfoVector(allocator.Adapter()) {}
+  virtual ~CollectIpaInfo() = default;
+
+  void RunOnScc(SCCNode<CGNode> &scc);
+  void TraverseStmtInfo(size_t position);
+  void UpdateCaleeParaAboutFloat(MeStmt &meStmt, float paramValue, uint32 index, CallerSummary &summary);
+  void UpdateCaleeParaAboutDouble(MeStmt &meStmt, double paramValue, uint32 index, CallerSummary &summary);
+  void UpdateCaleeParaAboutInt(MeStmt &meStmt, int64_t paramValue, uint32 index, CallerSummary &summary);
+  bool IsConstKindValue(MeExpr *expr) const;
+  bool CheckImpExprStmt(const MeStmt &meStmt) const;
+  bool CollectBrImportantExpression(const MeStmt &meStmt, uint32 &index) const;
+  void TransformStmtToIntegerSeries(MeStmt &meStmt);
+  DefUsePositions &GetDefUsePositions(OriginalSt &ost, StmtInfoId position);
+  void CollectDefUsePosition(ScalarMeExpr &var, StmtInfoId position,
+      std::unordered_set<ScalarMeExpr*> &cycleCheck);
+  void CollectJumpInfo(MeStmt &meStmt);
+  void SetLabel(size_t currStmtInfoId, LabelIdx label);
+  StmtInfoId GetRealFirstStmtInfoId(BB &bb);
+  void TraverseMeExpr(MeExpr &meExpr, StmtInfoId position,
+      std::unordered_set<ScalarMeExpr*> &cycleCheck);
+  void TraverseMeStmt(MeStmt &meStmt);
+  bool CollectSwitchImportantExpression(const MeStmt &meStmt, uint32 &index) const;
+  bool CollectImportantExpression(const MeStmt &meStmt, uint32 &index) const;
+  bool IsParameterOrUseParameter(const VarMeExpr *varExpr, uint32 &index) const;
+  void ReplaceMeStmtWithStmtNode(StmtNode *stmt, StmtInfoId position);
+  void Perform(MeFunction &func);
+  void Dump();
+
+  void PushInvalidKeyBack(uint invalidKey) {
+    integerString.emplace_back(invalidKey);
+    stmtInfoVector.emplace_back(StmtInfo(nullptr, -1u, allocator));
+  }
+
+  MapleVector<size_t> &GetIntegerString() {
+    return integerString;
+  }
+
+  MapleVector<StmtInfo> &GetStmtInfo() {
+    return stmtInfoVector;
+  }
+
+  uint GetCurrNewStmtIndex() {
+    return ++currNewStmtIndex;
+  }
+
+  uint GetTotalStmtInfoCount() {
+    return currNewStmtIndex;
+  }
+
+  void SetDataMap(AnalysisDataManager *map) {
+    dataMap = map;
+  }
+
+  MapleAllocator &GetAllocator() {
+    return allocator;
+  }
+ private:
+  MIRModule &module;
+  MIRBuilder &builder;
+  MIRFunction *curFunc;
+  AnalysisDataManager *dataMap;
+  MapleAllocator allocator;
+  MapleUnorderedMap<StmtInfo, StmtIndex, StmtInfoHash> stmtInfoToIntegerMap;
+  MapleVector<StmtIndex> integerString;
+  MapleVector<StmtInfo> stmtInfoVector;
+  StmtIndex currNewStmtIndex = 0;
+};
+MAPLE_SCC_PHASE_DECLARE_BEGIN(SCCCollectIpaInfo, maple::SCCNode<CGNode>)
+OVERRIDE_DEPENDENCE
+MAPLE_SCC_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_IPA_INCLUDE_COLLECT_IPA_INFO_H
diff --git a/src/mapleall/maple_ipa/include/ipa_phase_manager.h b/src/mapleall/maple_ipa/include/ipa_phase_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..9c3d61f68af5b9b76b33871cd6a87c220728b98a
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/ipa_phase_manager.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IPA_INCLUDE_IPA_PHASE_MANAGER_H
+#define MAPLE_IPA_INCLUDE_IPA_PHASE_MANAGER_H
+#include <string>
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_module.h"
+#include "mir_function.h"
+#include "me_phase_manager.h"
+#include "ipa_collect.h"
+
+namespace maple {
+/* ==== new phase manager ==== */
+class IpaSccPM : public SccPM {
+ public:
+  explicit IpaSccPM(MemPool *memPool) : SccPM(memPool, &id) {}
+  void Init(MIRModule &m);
+  bool PhaseRun(MIRModule &m) override;
+  PHASECONSTRUCTOR(IpaSccPM);
+  ~IpaSccPM() override {}
+  std::string PhaseName() const override;
+  CollectIpaInfo *GetResult() {
+    return ipaInfo;
+  }
+ private:
+  CollectIpaInfo *ipaInfo = nullptr;
+  void GetAnalysisDependence(AnalysisDep &aDep) const override;
+  virtual void DoPhasesPopulate(const MIRModule &mirModule);
+};
+
+class SCCPrepare : public MapleSccPhase<SCCNode<CGNode>>, public MaplePhaseManager {
+ public:
+  explicit SCCPrepare(MemPool *mp) : MapleSccPhase<SCCNode<CGNode>>(&id, mp), MaplePhaseManager(*mp) {}
+  ~SCCPrepare() override = default;
+  std::string PhaseName() const override;
+  PHASECONSTRUCTOR(SCCPrepare);
+  bool PhaseRun(SCCNode<CGNode> &scc) override;
+  void Dump(const MeFunction &f, const std::string phaseName) const;
+  AnalysisDataManager *GetResult() {
+    return result;
+  }
+ private:
+  AnalysisDataManager *result = nullptr;
+};
+
+class SCCEmit : public MapleSccPhase<SCCNode<CGNode>>, public MaplePhaseManager {
+ public:
+  explicit SCCEmit(MemPool *mp) : MapleSccPhase<SCCNode<CGNode>>(&id, mp), MaplePhaseManager(*mp) {}
+  ~SCCEmit() override = default;
+  std::string PhaseName() const override;
+  PHASECONSTRUCTOR(SCCEmit);
+  bool PhaseRun(SCCNode<CGNode> &scc) override;
+  void Dump(MeFunction &f, const std::string phaseName) const;
+ private:
+  void GetAnalysisDependence(maple::AnalysisDep &aDep) const override;
+};
+
+class SCCProfile : public MapleSccPhase<SCCNode<CGNode>>, public MaplePhaseManager {
+ public:
+  explicit SCCProfile(MemPool *mp) : MapleSccPhase<SCCNode<CGNode>>(&id, mp), MaplePhaseManager(*mp) {}
+  ~SCCProfile() override {
+    result = nullptr;
+  }
+  std::string PhaseName() const override;
+  PHASECONSTRUCTOR(SCCProfile);
+  bool PhaseRun(SCCNode<CGNode> &scc) override;
+  AnalysisDataManager *GetResult() {
+    return result;
+  }
+ private:
+  AnalysisDataManager *result = nullptr;
+};
+}  // namespace maple
+#endif  // MAPLE_IPA_INCLUDE_IPA_PHASE_MANAGER_H
diff --git a/src/mapleall/maple_ipa/include/ipa_side_effect.h b/src/mapleall/maple_ipa/include/ipa_side_effect.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7f84be13fb80bb002f4f76fa9d5c1ed090e8e2c
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/ipa_side_effect.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IPA_INCLUDE_IPASIDEEFFECT_H
+#define MAPLE_IPA_INCLUDE_IPASIDEEFFECT_H
+#include "me_phase_manager.h"
+#include "ipa_phase_manager.h"
+
+namespace maple {
+class SideEffect {
+ public:
+  SideEffect(MeFunction *meFunc, Dominance *dom, AliasClass *alias, CallGraph *cg)
+      : meFunc(meFunc), dom(dom), alias(alias), callGraph(cg) {
+    defGlobal = false;
+    defArg = false;
+    useGlobal = false;
+    vstsValueAliasWithFormal.resize(std::min(meFunc->GetMirFunc()->GetFormalCount(), kMaxParamCount));
+  }
+  ~SideEffect() {
+    alias = nullptr;
+    dom = nullptr;
+    meFunc = nullptr;
+    curFuncDesc = nullptr;
+  }
+  bool Perform(MeFunction &f);
+  static const FuncDesc &GetFuncDesc(MeFunction &f);
+  static const FuncDesc &GetFuncDesc(MIRFunction &f);
+  static const std::map<std::string, FuncDesc> &GetWhiteList();
+
+ private:
+  void DealWithOperand(MeExpr *expr);
+  void DealWithOst(OStIdx ostIdx);
+  void DealWithStmt(MeStmt &stmt);
+  void PropAllInfoFromCallee(const MeStmt &call, MIRFunction &callee);
+  void PropParamInfoFromCallee(const MeStmt &call, MIRFunction &callee);
+  void PropInfoFromOpnd(MeExpr &opnd, const PI &calleeParamInfo);
+  void ParamInfoUpdater(size_t vstIdx, const PI &calleeParamInfo);
+  void DealWithOst(const OriginalSt *ost);
+  void DealWithReturn(const RetMeStmt &retMeStmt) const;
+  void AnalysisFormalOst();
+  void SolveVarArgs(MeFunction &f) const;
+  void CollectFormalOst(MeFunction &f);
+  void CollectAllLevelOst(size_t vstIdx, std::set<size_t> &result);
+
+  std::set<std::pair<OriginalSt*, size_t>> analysisLater;
+  std::vector<std::set<size_t>> vstsValueAliasWithFormal;
+  MeFunction *meFunc = nullptr;
+  FuncDesc *curFuncDesc = nullptr;
+  Dominance *dom = nullptr;
+  AliasClass *alias = nullptr;
+  CallGraph *callGraph = nullptr;
+
+  bool defGlobal = false;
+  bool defArg = false;
+  bool useGlobal = false;
+};
+
+MAPLE_SCC_PHASE_DECLARE_BEGIN(SCCSideEffect, SCCNode<CGNode>)
+OVERRIDE_DEPENDENCE
+MAPLE_SCC_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_IPA_INCLUDE_IPASIDEEFFECT_H
diff --git a/src/mapleall/maple_ipa/include/old/do_ipa_escape_analysis.h b/src/mapleall/maple_ipa/include/old/do_ipa_escape_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..615c79b024ccfd689a4542f7714305d5dfa462e5
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/old/do_ipa_escape_analysis.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef INCLUDE_MAPLEIPA_INCLUDE_IPAESCAPEANALYSIS_H
+#define INCLUDE_MAPLEIPA_INCLUDE_IPAESCAPEANALYSIS_H
+
+namespace maple {
+#ifdef NOT_USED
+class DoIpaEA : public MeFuncPhase {
+ public:
+  explicit DoIpaEA(MePhaseID id) : MeFuncPhase(id) {}
+  ~DoIpaEA() = default;
+  AnalysisResult *Run(MeFunction*, MeFuncResultMgr*, ModuleResultMgr*) override;
+  std::string PhaseName() const override {
+    return "ipaea";
+  }
+};
+
+class DoIpaEAOpt : public MeFuncPhase {
+ public:
+  explicit DoIpaEAOpt(MePhaseID id) : MeFuncPhase(id) {}
+  ~DoIpaEAOpt() = default;
+  AnalysisResult *Run(MeFunction*, MeFuncResultMgr*, ModuleResultMgr*) override;
+  std::string PhaseName() const override {
+    return "ipaeaopt";
+  }
+};
+#endif
+}
+#endif  // INCLUDE_MAPLEIPA_INCLUDE_IPAESCAPEANALYSIS_H
diff --git a/src/mapleall/maple_ipa/include/old/ea_connection_graph.h b/src/mapleall/maple_ipa/include/old/ea_connection_graph.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a4de2f388f11d13c0045bf655c03b8ef207b7ab
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/old/ea_connection_graph.h
@@ -0,0 +1,697 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEIPA_INCLUDE_ESCAPEANALYSIS_H
+#define MAPLEIPA_INCLUDE_ESCAPEANALYSIS_H
+#include <fstream>
+#include <iostream>
+#include <cstdlib>
+#include "call_graph.h"
+#include "me_ir.h"
+#include "irmap.h"
+
+namespace maple {
+enum NodeKind {
+  kObejectNode,
+  kReferenceNode,
+  kActualNode,
+  kFieldNode,
+  kPointerNode
+};
+
+enum EAStatus {
+  kNoEscape,
+  kReturnEscape,
+  kArgumentEscape,
+  kGlobalEscape
+};
+
+const inline std::string EscapeName(EAStatus esc) {
+  switch (esc) {
+    case kNoEscape:
+      return "NoEsc";
+    case kReturnEscape:
+      return "RetEsc";
+    case kArgumentEscape:
+      return "ArgEsc";
+    case kGlobalEscape:
+      return "GlobalEsc";
+    default:
+      return "";
+  }
+}
+
+class Location {
+ public:
+  Location(const std::string &modName, uint32 fileId, uint32 lineId)
+      : modName(modName),
+        fileId(fileId),
+        lineId(lineId) {};
+  ~Location() = default;
+
+  const std::string &GetModName() const {
+    return modName;
+  }
+
+  uint32 GetFileId() const {
+    return fileId;
+  }
+
+  uint32 GetLineId() const {
+    return lineId;
+  }
+
+ private:
+  std::string modName;
+  uint32 fileId;
+  uint32 lineId;
+};
+
+class EACGBaseNode;
+class EACGObjectNode;
+class EACGFieldNode;
+class EACGRefNode;
+class EACGActualNode;
+class EACGPointerNode;
+
+class EAConnectionGraph {
+ public:
+  friend class BinaryMplExport;
+  friend class BinaryMplImport;
+  friend class EACGBaseNode;
+  friend class EACGObjectNode;
+  friend class EACGFieldNode;
+  friend class EACGRefNode;
+  friend class EACGPointerNode;
+  // If import is false, need init globalNode.
+  EAConnectionGraph(MIRModule *m, MapleAllocator *allocator, const GStrIdx &funcName, bool import = false)
+      : mirModule(m),
+        alloc(allocator),
+        nodes(allocator->Adapter()),
+        expr2Nodes(allocator->Adapter()),
+        funcArgNodes(allocator->Adapter()),
+        callSite2Nodes(allocator->Adapter()),
+        funcStIdx(funcName),
+        hasUpdated(false),
+        needConv(false),
+        imported(import),
+        exprIdMax(0),
+        globalObj(nullptr),
+        globalRef(nullptr),
+        globalField(nullptr) {};
+  ~EAConnectionGraph() = default;
+
+  EACGObjectNode *CreateObjectNode(MeExpr *expr, EAStatus initialEas, bool isPh, TyIdx tyIdx);
+  EACGRefNode *CreateReferenceNode(MeExpr *expr, EAStatus initialEas, bool isStatic);
+  EACGActualNode *CreateActualNode(EAStatus initialEas, bool isReurtn, bool isPh, uint8 argIdx,
+                                   uint32 callSiteInfo);
+  EACGFieldNode *CreateFieldNode(MeExpr *expr, EAStatus initialEas, FieldID fId, EACGObjectNode *belongTo, bool isPh);
+  EACGPointerNode *CreatePointerNode(MeExpr *expr, EAStatus initialEas, int inderictL);
+  EACGBaseNode *GetCGNodeFromExpr(MeExpr *me);
+  EACGFieldNode *GetOrCreateFieldNodeFromIdx(EACGObjectNode &obj, int32 fieldID);
+  EACGActualNode *GetReturnNode() const;
+  const MapleVector<EACGBaseNode*> *GetFuncArgNodeVector() const;
+  void TouchCallSite(uint32 callSiteInfo);
+  MapleVector<EACGBaseNode*> *GetCallSiteArgNodeVector(uint32 callSite);
+  bool ExprCanBeOptimized(MeExpr &expr);
+
+  bool CGHasUpdated() const {
+    return hasUpdated;
+  }
+
+  void UnSetCGUpdateFlag() {
+    hasUpdated = false;
+  }
+
+  void SetCGHasUpdated() {
+    hasUpdated = true;
+  }
+
+  void SetExprIdMax(int max) {
+    exprIdMax = max;
+  }
+
+  void SetNeedConservation() {
+    needConv = true;
+  }
+
+  bool GetNeedConservation() const {
+    return needConv;
+  }
+
+  GStrIdx GetFuncNameStrIdx() const {
+    return funcStIdx;
+  }
+
+  EACGObjectNode *GetGlobalObject() {
+    return globalObj;
+  }
+
+  const EACGObjectNode *GetGlobalObject() const {
+    return globalObj;
+  }
+
+  EACGRefNode *GetGlobalReference() {
+    return globalRef;
+  }
+
+  const EACGRefNode *GetGlobalReference() const {
+    return globalRef;
+  }
+
+  const MapleVector<EACGBaseNode*> &GetNodes() const {
+    return nodes;
+  }
+
+  void ResizeNodes(size_t size, EACGBaseNode *val) {
+    nodes.resize(size, val);
+  }
+
+  EACGBaseNode *GetNode(uint32 idx) const {
+    CHECK_FATAL(idx < nodes.size(), "array check fail");
+    return nodes[idx];
+  }
+
+  void SetNodeAt(size_t index, EACGBaseNode *val) {
+    nodes[index] = val;
+  }
+
+  const MapleVector<EACGBaseNode*> &GetFuncArgNodes() const {
+    return funcArgNodes;
+  }
+
+  const MapleMap<uint32, MapleVector<EACGBaseNode*>*> &GetCallSite2Nodes() const {
+    return callSite2Nodes;
+  }
+
+  void InitGlobalNode();
+  void AddMaps2Object(EACGObjectNode *caller, EACGObjectNode *callee);
+  void UpdateExprOfNode(EACGBaseNode &node, MeExpr *me);
+  void UpdateExprOfGlobalRef(MeExpr *me);
+  void PropogateEAStatus();
+  bool MergeCG(MapleVector<EACGBaseNode*> &caller, const MapleVector<EACGBaseNode*> *callee);
+  void TrimGlobalNode() const;
+  void UpdateEACGFromCaller(const MapleVector<EACGBaseNode*> &callerCallSiteArg,
+                            const MapleVector<EACGBaseNode*> &calleeFuncArg);
+  void DumpDotFile(const IRMap *irMap, bool dumpPt, MapleVector<EACGBaseNode*> *dumpVec = nullptr);
+  void DeleteEACG() const;
+  void RestoreStatus(bool old);
+  void CountObjEAStatus() const;
+
+  const std::string &GetFunctionName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(funcStIdx);
+  }
+
+ private:
+  MIRModule *mirModule;
+  MapleAllocator *alloc;
+  MapleVector<EACGBaseNode*> nodes;
+  MapleMap<MeExpr*, MapleSet<EACGBaseNode*>*> expr2Nodes;
+  // this vector contain func arg nodes first in declaration order and the last is return node
+  MapleVector<EACGBaseNode*> funcArgNodes;
+  MapleMap<uint32, MapleVector<EACGBaseNode*>*> callSite2Nodes;
+  GStrIdx funcStIdx;
+  bool hasUpdated;
+  bool needConv;
+  bool imported;
+  int exprIdMax;
+  EACGObjectNode *globalObj;
+  EACGRefNode *globalRef;
+  EACGFieldNode *globalField;
+  // this is used as a tmp varible for merge cg
+  std::map<EACGObjectNode*, std::set<EACGObjectNode*>> callee2Caller;
+  void CheckArgNodeOrder(MapleVector<EACGBaseNode*> &funcArgV);
+  void UpdateCallerNodes(const MapleVector<EACGBaseNode*> &caller, const MapleVector<EACGBaseNode*> &callee);
+  void UpdateCallerRetNode(MapleVector<EACGBaseNode*> &caller, const MapleVector<EACGBaseNode*> &callee);
+  void UpdateCallerEdges();
+  void UpdateCallerEdgesInternal(EACGObjectNode *node1, int32 fieldID, EACGObjectNode *node2);
+  void UpdateNodes(const EACGBaseNode &actualInCallee, EACGBaseNode &actualInCaller, bool firstTime);
+  void UpdateCallerWithCallee(EACGObjectNode &objInCaller, const EACGObjectNode &objInCallee, bool firstTime);
+
+  void SetCGUpdateFlag() {
+    hasUpdated = true;
+  }
+};
+
+class EACGBaseNode {
+ public:
+  friend class BinaryMplExport;
+  friend class BinaryMplImport;
+  friend class EACGObjectNode;
+  friend class EACGFieldNode;
+  friend class EACGActualNode;
+  friend class EACGRefNode;
+  friend class EACGPointerNode;
+  friend class EAConnectionGraph;
+
+  EACGBaseNode(MIRModule *m, MapleAllocator *a, NodeKind nk, EAConnectionGraph *ec)
+      : locInfo(nullptr), mirModule(m), alloc(a), kind(nk), meExpr(nullptr), eaStatus(kNoEscape), id(0), eaCG(ec) {}
+
+  EACGBaseNode(MIRModule *m, MapleAllocator *a, NodeKind nk, EAConnectionGraph &ec, MeExpr *expr, EAStatus initialEas,
+               int i)
+      : locInfo(nullptr), mirModule(m), alloc(a), kind(nk), meExpr(expr), eaStatus(initialEas), id(i), eaCG(&ec) {
+    ec.SetCGUpdateFlag();
+  }
+
+  virtual ~EACGBaseNode() = default;
+
+  virtual bool IsFieldNode() const {
+    return kind == kFieldNode;
+  }
+
+  virtual bool IsObjectNode() const {
+    return kind == kObejectNode;
+  }
+
+  virtual bool IsReferenceNode() const {
+    return kind == kReferenceNode;
+  }
+
+  virtual bool IsActualNode() const {
+    return kind == kActualNode;
+  }
+
+  virtual bool IsPointerNode() const {
+    return kind == kPointerNode;
+  }
+
+  virtual const MeExpr *GetMeExpr() const {
+    return meExpr;
+  }
+
+  virtual void SetMeExpr(MeExpr &newExpr) {
+    if (IsFieldNode() && newExpr.GetMeOp() != kMeOpIvar && newExpr.GetMeOp() != kMeOpOp) {
+      CHECK_FATAL(false, "must be kMeOpIvar or kMeOpOp");
+    } else if (IsReferenceNode() && newExpr.GetMeOp() != kMeOpVar && newExpr.GetMeOp() != kMeOpReg &&
+               newExpr.GetMeOp() != kMeOpAddrof && newExpr.GetMeOp() != kMeOpConststr) {
+      CHECK_FATAL(false, "must be kMeOpVar, kMeOpReg, kMeOpAddrof or kMeOpConststr");
+    }
+    meExpr = &newExpr;
+  }
+
+  const std::set<EACGObjectNode*> &GetPointsToSet() const {
+    CHECK_FATAL(!IsPointerNode(), "must be pointer node");
+    return pointsTo;
+  };
+
+  virtual bool AddOutNode(EACGBaseNode &newOut);
+
+  virtual EAStatus GetEAStatus() const {
+    return eaStatus;
+  }
+
+  virtual const std::set<EACGBaseNode*> &GetInSet() const {
+    return in;
+  }
+
+  virtual void InsertInSet(EACGBaseNode *val) {
+    (void)in.insert(val);
+  }
+
+  virtual const std::set<EACGBaseNode*> &GetOutSet() const {
+    CHECK_FATAL(IsActualNode(), "must be actual node");
+    return out;
+  }
+
+  virtual void InsertOutSet(EACGBaseNode *val) {
+    (void)out.insert(val);
+  }
+
+  virtual bool UpdateEAStatus(EAStatus newEas) {
+    if (newEas > eaStatus) {
+      eaStatus = newEas;
+      PropagateEAStatusForNode(this);
+      eaCG->SetCGUpdateFlag();
+      return true;
+    }
+    return false;
+  }
+
+  bool IsBelongTo(const EAConnectionGraph *cg) const {
+    return this->eaCG == cg;
+  }
+
+  const EAConnectionGraph *GetEACG() const {
+    return eaCG;
+  }
+
+  EAConnectionGraph *GetEACG() {
+    return eaCG;
+  }
+
+  void SetEACG(EAConnectionGraph *cg) {
+    this->eaCG = cg;
+  }
+
+  void SetID(int setId) {
+    this->id = static_cast<size_t>(setId);
+  }
+
+  bool CanIgnoreRC() const;
+
+ protected:
+  Location *locInfo;
+  MIRModule *mirModule;
+  MapleAllocator *alloc;
+  NodeKind kind;
+  MeExpr *meExpr;
+  EAStatus eaStatus;
+  size_t id;
+  // OBJ<->Field will not in following Set
+  std::set<EACGBaseNode*> in;
+  std::set<EACGBaseNode*> out;
+  std::set<EACGObjectNode*> pointsTo;
+  EAConnectionGraph *eaCG;
+
+  virtual void CheckAllConnectionInNodes();
+  virtual std::string GetName(const IRMap *irMap) const;
+  virtual void DumpDotFile(std::ostream&, std::map<EACGBaseNode*, bool>&, bool, const IRMap *irMap = nullptr) = 0;
+  virtual void PropagateEAStatusForNode(const EACGBaseNode *subRoot) const;
+  virtual void GetNodeFormatInDot(std::string &label, std::string &color) const;
+  virtual bool UpdatePointsTo(const std::set<EACGObjectNode*> &cPointsTo);
+
+  virtual void SetEAStatus(EAStatus status) {
+    this->eaStatus = status;
+  }
+
+  virtual NodeKind GetNodeKind() const {
+    return kind;
+  }
+
+ private:
+  virtual bool ReplaceByGlobalNode() {
+    CHECK_FATAL(false, "impossible");
+    return false;
+  }
+};
+
+class EACGPointerNode : public EACGBaseNode {
+ public:
+  friend class BinaryMplExport;
+  friend class BinaryMplImport;
+  EACGPointerNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph *ec)
+      : EACGBaseNode(md, alloc, kPointerNode, ec), indirectLevel(0) {}
+
+  EACGPointerNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph &ec, MeExpr *expr, EAStatus initialEas, int i,
+                  int indirectL)
+      : EACGBaseNode(md, alloc, kPointerNode, ec, expr, initialEas, i), indirectLevel(indirectL) {};
+  ~EACGPointerNode() = default;
+
+  void SetLocation(Location *loc) {
+    this->locInfo = loc;
+  }
+
+  int GetIndirectLevel() const {
+    return indirectLevel;
+  }
+
+  bool AddOutNode(EACGBaseNode &newOut) override {
+    if (indirectLevel == 1) {
+      CHECK_FATAL(!newOut.IsPointerNode(), "must be pointer node");
+      (void)pointingTo.insert(&newOut);
+      (void)out.insert(&newOut);
+      (void)newOut.in.insert(this);
+    } else {
+      pointingTo.insert(&newOut);
+      CHECK_FATAL(pointingTo.size() == 1, "the size must be one");
+      CHECK_FATAL(newOut.IsPointerNode(), "must be pointer node");
+      CHECK_FATAL((indirectLevel - static_cast<EACGPointerNode&>(newOut).GetIndirectLevel()) == 1, "must be one");
+      (void)out.insert(&newOut);
+      (void)newOut.in.insert(this);
+    }
+    return false;
+  }
+
+  const std::set<EACGBaseNode*> &GetPointingTo() const {
+    return pointingTo;
+  }
+
+  bool UpdatePointsTo(const std::set<EACGObjectNode*>&) override {
+    CHECK_FATAL(false, "impossible to update PointsTo");
+    return true;
+  };
+
+  void PropagateEAStatusForNode(const EACGBaseNode*) const override {
+    CHECK_FATAL(false, "impossible to propagate EA status for node");
+  }
+
+  void DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                   const IRMap *irMap = nullptr) override;
+  void CheckAllConnectionInNodes() override {}
+
+ private:
+  int indirectLevel;
+  std::set<EACGBaseNode*> pointingTo;
+  bool ReplaceByGlobalNode() override {
+    CHECK_FATAL(false, "impossible to replace by global node");
+    return true;
+  }
+};
+
+class EACGObjectNode : public EACGBaseNode {
+ public:
+  friend class EACGFieldNode;
+  friend class BinaryMplExport;
+  friend class BinaryMplImport;
+  EACGObjectNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph *ec)
+      : EACGBaseNode(md, alloc, kObejectNode, ec), rcOperations(0), ignorRC(false), isPhantom(false) {}
+
+  EACGObjectNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph &ec, MeExpr *expr, EAStatus initialEas, int i,
+                 bool isPh)
+      : EACGBaseNode(md, alloc, kObejectNode, ec, expr, initialEas, i), rcOperations(0), ignorRC(false),
+        isPhantom(isPh) {
+    (void)pointsBy.insert(this);
+    (void)pointsTo.insert(this);
+  };
+  ~EACGObjectNode() = default;
+  bool IsPhantom() const {
+    return isPhantom;
+  };
+
+  void SetLocation(Location *loc) {
+    this->locInfo = loc;
+  }
+
+  const std::map<FieldID, EACGFieldNode*> &GetFieldNodeMap() const {
+    return fieldNodes;
+  }
+
+  EACGFieldNode *GetFieldNodeFromIdx(FieldID fId) {
+    if (fieldNodes.find(-1) != fieldNodes.end()) { // -1 expresses global
+      return fieldNodes[-1];
+    }
+    if (fieldNodes.find(fId) == fieldNodes.end()) {
+      return nullptr;
+    }
+    return fieldNodes[fId];
+  }
+
+  bool AddOutNode(EACGBaseNode &newOut) override;
+  bool UpdatePointsTo(const std::set<EACGObjectNode*>&) override {
+    CHECK_FATAL(false, "impossible");
+    return true;
+  };
+
+  bool IsPointedByFieldNode() const;
+  void PropagateEAStatusForNode(const EACGBaseNode *subRoot) const override;
+  void DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                   const IRMap *irMap = nullptr) override;
+  void CheckAllConnectionInNodes() override;
+
+  void Insert2PointsBy(EACGBaseNode *node) {
+    (void)pointsBy.insert(node);
+  }
+
+  void EraseNodeFromPointsBy(EACGBaseNode *node) {
+    pointsBy.erase(node);
+  }
+
+  void IncresRCOperations() {
+    ++rcOperations;
+  }
+
+  void IncresRCOperations(int num) {
+    rcOperations += num;
+  }
+
+  int GetRCOperations() const {
+    return rcOperations;
+  }
+
+  bool GetIgnorRC() const {
+    return ignorRC;
+  }
+
+  void SetIgnorRC(bool ignore) {
+    ignorRC = ignore;
+  }
+
+ private:
+  std::set<EACGBaseNode*> pointsBy;
+  int rcOperations;
+  bool ignorRC;
+  bool isPhantom;
+  std::map<FieldID, EACGFieldNode*> fieldNodes;
+  bool ReplaceByGlobalNode() override;
+};
+
+class EACGRefNode : public EACGBaseNode {
+ public:
+  friend class BinaryMplExport;
+  friend class BinaryMplImport;
+  EACGRefNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph *ec)
+      : EACGBaseNode(md, alloc, kReferenceNode, ec), isStaticField(false), sym(nullptr), version(0) {}
+
+  EACGRefNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph &ec, MeExpr *expr, EAStatus initialEas, int i,
+              bool isS = false)
+      : EACGBaseNode(md, alloc, kReferenceNode, ec, expr, initialEas, i),
+        isStaticField(isS),
+        sym(nullptr),
+        version(0) {};
+  ~EACGRefNode() = default;
+  bool IsStaticRef() const {
+    return isStaticField;
+  };
+  void SetSymbolAndVersion(MIRSymbol *mirSym, int versionIdx) {
+    if (sym != nullptr) {
+      CHECK_FATAL(sym == mirSym, "must be sym");
+      CHECK_FATAL(versionIdx == version, "must be version ");
+    }
+    sym = mirSym;
+    version = versionIdx;
+  };
+
+  void DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                   const IRMap *irMap = nullptr) override;
+
+ private:
+  bool isStaticField;
+  MIRSymbol *sym;
+  int version;
+  bool ReplaceByGlobalNode() override;
+};
+class EACGFieldNode : public EACGBaseNode {
+ public:
+  friend class BinaryMplExport;
+  friend class BinaryMplImport;
+  friend class EACGObjectNode;
+  EACGFieldNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph *ec)
+      : EACGBaseNode(md, alloc, kFieldNode, ec),
+        fieldID(0),
+        isPhantom(false),
+        sym(nullptr),
+        version(0),
+        mirFieldId(0) {}
+
+  EACGFieldNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph &ec, MeExpr *expr, EAStatus initialEas, int i,
+                FieldID fId, EACGObjectNode *bt, bool isPh)
+      : EACGBaseNode(md, alloc, kFieldNode, ec, expr, initialEas, i),
+        fieldID(fId),
+        isPhantom(isPh),
+        sym(nullptr),
+        version(0),
+        mirFieldId(0) {
+    bt->fieldNodes[fieldID] = this;
+    (void)belongsTo.insert(bt);
+  };
+
+  ~EACGFieldNode() = default;
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  };
+
+  void SetFieldID(FieldID id) {
+    fieldID = id;
+  }
+
+  bool IsPhantom() const {
+    return isPhantom;
+  }
+
+  const std::set<EACGObjectNode*> &GetBelongsToObj() const {
+    return belongsTo;
+  }
+
+  void AddBelongTo(EACGObjectNode *newObj) {
+    (void)belongsTo.insert(newObj);
+  }
+
+  void SetSymbolAndVersion(MIRSymbol *mirSym, int versionIdx, FieldID fID) {
+    if (sym != nullptr) {
+      CHECK_FATAL(sym == mirSym, "must be mirSym");
+      CHECK_FATAL(version == versionIdx, "must be version");
+      CHECK_FATAL(mirFieldId == fID, "must be  mir FieldId");
+    }
+    sym = mirSym;
+    version = versionIdx;
+    mirFieldId = fID;
+  };
+
+  void DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                   const IRMap *irMap = nullptr) override;
+
+ private:
+  FieldID fieldID;
+  std::set<EACGObjectNode*> belongsTo;
+  bool isPhantom;
+  MIRSymbol *sym;
+  int version;
+  FieldID mirFieldId;
+  bool ReplaceByGlobalNode() override;
+};
+
+class EACGActualNode : public EACGBaseNode {
+ public:
+  friend class BinaryMplExport;
+  friend class BinaryMplImport;
+  EACGActualNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph *ec)
+      : EACGBaseNode(md, alloc, kActualNode, ec), isReturn(false), isPhantom(false), argIdx(0), callSiteInfo(0) {};
+  EACGActualNode(MIRModule *md, MapleAllocator *alloc, EAConnectionGraph &ec, MeExpr *expr, EAStatus initialEas, int i,
+                 bool isR, bool isPh, uint8 aI, uint32 callSite)
+      : EACGBaseNode(md, alloc, kActualNode, ec, expr, initialEas, i),
+        isReturn(isR),
+        isPhantom(isPh),
+        argIdx(aI),
+        callSiteInfo(callSite) {};
+  ~EACGActualNode() = default;
+
+  bool IsReturn() const {
+    return isReturn;
+  };
+
+  bool IsPhantom() const {
+    return isPhantom;
+  };
+
+  uint32 GetArgIndex() const {
+    return argIdx;
+  };
+
+  uint32 GetCallSite() const {
+    return callSiteInfo;
+  }
+
+  void DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                   const IRMap *irMap = nullptr) override;
+
+ private:
+  bool isReturn;
+  bool isPhantom;
+  uint8 argIdx;
+  uint32 callSiteInfo;
+  bool ReplaceByGlobalNode() override;
+};
+} // namespace maple
+#endif
diff --git a/src/mapleall/maple_ipa/include/old/ipa_escape_analysis.h b/src/mapleall/maple_ipa/include/old/ipa_escape_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..dabf2ad9720f4189f55a41769199ac6480de787f
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/old/ipa_escape_analysis.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEIPA_INCLUDE_IPAESCAPEANALYSIS_H
+#define MAPLEIPA_INCLUDE_IPAESCAPEANALYSIS_H
+
+#include <vector>
+#include "class_hierarchy.h"
+#include "call_graph.h"
+#include "irmap.h"
+#include "me_function.h"
+#include "ea_connection_graph.h"
+#include "intrinsics.h"
+
+namespace maple {
+class IPAEscapeAnalysis {
+ public:
+  static constexpr int kCalleeCandidateLimit = 600;
+  static constexpr int kFuncInSCCLimit = 200000;
+  static constexpr int kSCCConvergenceLimit = 20;
+  static constexpr int kCalleeNodeLimit = 100000;
+  static constexpr int kRCOperLB = 0;
+  static constexpr bool kDebug = false;
+
+  IPAEscapeAnalysis(KlassHierarchy *khTmp, IRMap *irMapTmp, MeFunction *funcTmp, MemPool *mp, CallGraph *pcgTmp)
+      : kh(khTmp),
+        irMap(irMapTmp),
+        ssaTab(&irMap->GetSSATab()),
+        mirModule(&irMapTmp->GetMIRModule()),
+        func(funcTmp),
+        eaCG(func->GetMirFunc()->GetEACG()),
+        pcg(pcgTmp),
+        allocator(mp),
+        cgChangedInSCC(false),
+        tempCount(0),
+        retVar(nullptr) {}
+  ~IPAEscapeAnalysis() = default;
+  void ConstructConnGraph();
+  void DoOptimization();
+
+ private:
+  TyIdx GetAggElemType(const MIRType &aggregate) const;
+  bool IsSpecialEscapedObj(const MeExpr &alloc) const;
+  EACGRefNode *GetOrCreateCGRefNodeForVar(VarMeExpr &var, bool createObjNode = false);
+  EACGRefNode *GetOrCreateCGRefNodeForAddrof(AddrofMeExpr &var, bool createObjNode = false);
+  EACGRefNode *GetOrCreateCGRefNodeForReg(RegMeExpr &reg, bool createObjNode = false);
+  EACGRefNode *GetOrCreateCGRefNodeForVarOrReg(MeExpr &var, bool createObjNode = false);
+  void GetArrayBaseNodeForReg(std::vector<EACGBaseNode*> &nodes, RegMeExpr &regVar, MeStmt &stmt);
+  void GetOrCreateCGFieldNodeForIvar(std::vector<EACGBaseNode*> &fieldNodes, IvarMeExpr &ivar, MeStmt &stmt,
+                                     bool createObjNode);
+  void GetOrCreateCGFieldNodeForIAddrof(std::vector<EACGBaseNode*> &fieldNodes, OpMeExpr &expr, MeStmt &stmt,
+                                        bool createObjNode);
+  EACGObjectNode *GetOrCreateCGObjNode(MeExpr *expr, const MeStmt *stmt = nullptr, EAStatus easOfPhanObj = kNoEscape);
+  void GetCGNodeForMeExpr(std::vector<EACGBaseNode*> &nodes, MeExpr &expr, MeStmt &stmt, bool createObjNode);
+  void CollectDefStmtForReg(std::set<RegMeExpr*> &visited, std::set<AssignMeStmt*> &defStmts, RegMeExpr &regVar);
+  void UpdateEscConnGraphWithStmt(MeStmt &stmt);
+  void UpdateEscConnGraphWithPhi(const BB &bb);
+  void HandleParaAtFuncEntry();
+  void HandleParaAtCallSite(uint32 callInfo, CallMeStmt &call);
+  void HandleSingleCallee(CallMeStmt &callMeStmt);
+  bool HandleSpecialCallee(CallMeStmt *callMeStmt);
+  void HandleMultiCallees(const CallMeStmt &callMeStmt);
+  EAConnectionGraph *GetEAConnectionGraph(MIRFunction &function) const;
+  void ProcessNoAndRetEscObj();
+  void ProcessRetStmt();
+  VarMeExpr *CreateEATempVarWithName(const std::string &name) const;
+  VarMeExpr *CreateEATempVar();
+  VarMeExpr *GetOrCreateEARetTempVar();
+  VarMeExpr *CreateEATempVarMeExpr(OriginalSt &ost) const;
+  OriginalSt *CreateEATempOstWithName(const std::string &name) const;
+  OriginalSt *CreateEATempOst();
+  OriginalSt *CreateEARetTempOst() const;
+  VarMeExpr *GetOrCreateEARetTempVarMeExpr(OriginalSt &ost);
+  void CountObjRCOperations();
+  void DeleteRedundantRC();
+
+  KlassHierarchy *kh;
+  IRMap *irMap;
+  SSATab *ssaTab;
+  MIRModule *mirModule;
+  MeFunction *func;
+  EAConnectionGraph *eaCG;
+  CallGraph *pcg;
+  MapleAllocator allocator;
+  bool cgChangedInSCC;
+  uint32 tempCount;
+  std::vector<VarMeExpr*> noAndRetEscObj;
+  VarMeExpr *retVar;
+  std::vector<OriginalSt*> noAndRetEscOst;
+  std::vector<MeStmt*> gcStmts;
+};
+} // namespace maple
+#endif
diff --git a/src/mapleall/maple_ipa/include/old/ipa_option.h b/src/mapleall/maple_ipa/include/old/ipa_option.h
new file mode 100644
index 0000000000000000000000000000000000000000..5b44a8d24e3bc1d950132a069070910f48f254e4
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/old/ipa_option.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IPA_OPTION_H
+#define MAPLE_IPA_OPTION_H
+#include <iostream>
+#include "mir_parser.h"
+#include "opcode_info.h"
+#include "option.h"
+#include "bin_mpl_export.h"
+#include "me_phase_manager.h"
+
+namespace maple {
+class IpaOption {
+ public:
+  static IpaOption &GetInstance();
+
+  ~IpaOption() = default;
+
+  bool SolveOptions() const;
+
+  bool ParseCmdline(int argc, char **argv, std::vector<std::string> &fileNames) const;
+
+ private:
+  IpaOption() = default;
+};
+
+class MeFuncPM1 : public MeFuncPM {
+ public:
+  explicit MeFuncPM1(MemPool *memPool) : MeFuncPM(memPool) {
+    SetPhaseID(&MeFuncPM1::id);
+  }
+  PHASECONSTRUCTOR(MeFuncPM1);
+  std::string PhaseName() const override;
+  ~MeFuncPM1() override {}
+
+ private:
+  void GetAnalysisDependence(AnalysisDep &aDep) const override;
+  void DoPhasesPopulate(const MIRModule &m) override;
+};
+
+class MeFuncPM2 : public MeFuncPM {
+ public:
+  explicit MeFuncPM2(MemPool *memPool) : MeFuncPM(memPool) {
+    SetPhaseID(&MeFuncPM2::id);
+  }
+  PHASECONSTRUCTOR(MeFuncPM2);
+  std::string PhaseName() const override;
+  ~MeFuncPM2() override {}
+
+ private:
+  void GetAnalysisDependence(AnalysisDep &aDep) const override;
+  void DoPhasesPopulate(const MIRModule &m) override;
+};
+}  // namespace maple
+#endif // MAPLE_IPA_OPTION_H
diff --git a/src/mapleall/maple_ipa/include/old/mrt_info.def b/src/mapleall/maple_ipa/include/old/mrt_info.def
new file mode 100644
index 0000000000000000000000000000000000000000..e8bd87cf7da66941db95af8c79fab90745d78d47
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/old/mrt_info.def
@@ -0,0 +1,639 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// pure,  defArg,  defGlobal,  retGlobal,  throwEh,  retArg,     defPrivate,  name
+{  true,  false,   false,      false,      false,    false,      false,       "MCC_GetOrInsertLiteral"},
+{  true,  false,   false,      false,      false,    false,      false,       "MCC_StringAppend_StringString"},
+{  true,  false,   false,      false,      false,    false,      false,       "MCC_CStrToJStr"},
+{  true,  false,   false,      false,      false,    false,      false,       "MCC_String_Equals_NotallCompress"},
+{  true,  false,   false,      false,      false,    false,      false,       "MCC_StringAppend"},
+{  true,  false,   false,      false,      false,    false,      false,       "MCC_StringAppend_StringInt"},
+{  true,  false,   false,      false,      false,    false,      false,       "MCC_StringAppend_StringJcharString"},
+{  true,  false,   false,      false,      true,     false,      false,       "MCC_ThrowStringIndexOutOfBoundsException"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_String_charAt__I"},
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_String_getCharsNoCheck__II_3CI"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_String_toCharArray__"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_String_fastSubstring__II"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_String_compareTo__Ljava_lang_String_2"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_String_intern__"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_String_doReplace__CC"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_String_concat__Ljava_lang_String_2"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_String_fastIndexOf__II"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_Object_clone_Ljava_lang_Object__"},
+{  false, false,   false,      true,       true,     false,      false,       "Native_Thread_currentThread"},
+
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisProxy_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetName_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetTypeName_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7Ccast_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetPrimitiveClass_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetComponentType_7C_28_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredField_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2Freflect_2FField_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CtoString_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetGenericInterfaces_7C_28_29ALjava_2Flang_2Freflect_2FType_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisInstance_7C_28Ljava_2Flang_2FObject_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CforName_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CforName_7C_28Ljava_2Flang_2FString_3BZLjava_2Flang_2FClassLoader_3B_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisAssignableFrom_7C_28Ljava_2Flang_2FClass_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetModifiers_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisPrimitive_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisArray_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetInterfaces_7C_28_29ALjava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetSimpleName_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetSuperclass_7C_28_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredFields_7C_28_29ALjava_2Flang_2Freflect_2FField_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisInterface_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetCanonicalName_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisEnum_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetAnnotation_7C_28Ljava_2Flang_2FClass_3B_29Ljava_2Flang_2Fannotation_2FAnnotation_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetAnnotations_7C_28_29ALjava_2Flang_2Fannotation_2FAnnotation_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetAnnotationsByType_7C_28Ljava_2Flang_2FClass_3B_29ALjava_2Flang_2Fannotation_2FAnnotation_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredAnnotation_7C_28Ljava_2Flang_2FClass_3B_29Ljava_2Flang_2Fannotation_2FAnnotation_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredAnnotations_7C_28_29ALjava_2Flang_2Fannotation_2FAnnotation_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CcannotCastMsg_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CclassForName_7C_28Ljava_2Flang_2FString_3BZLjava_2Flang_2FClassLoader_3B_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CclassNameImpliesTopLevel_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CfindInterfaceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetPublicMethodRecursive_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetConstructor0_7C_28ALjava_2Flang_2FClass_3BI_29Ljava_2Flang_2Freflect_2FConstructor_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructorInternal_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructorsInternal_7C_28Z_29ALjava_2Flang_2Freflect_2FConstructor_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredMethodInternal_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetEnclosingConstructorNative_7C_28_29Ljava_2Flang_2Freflect_2FConstructor_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetEnclosingMethodNative_7C_28_29Ljava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetInnerClassFlags_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetInnerClassName_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetInterfacesInternal_7C_28_29ALjava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3BZ_29Ljava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetNameNative_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetPublicDeclaredFields_7C_28_29ALjava_2Flang_2Freflect_2FField_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetPublicFieldRecursive_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2Freflect_2FField_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetPublicFieldsRecursive_7C_28Ljava_2Futil_2FList_3B_29V"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetPublicMethodsInternal_7C_28Ljava_2Futil_2FList_3B_29V"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredMethodsUnchecked_7C_28Z_29ALjava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetSignatureAnnotation_7C_28_29ALjava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetSignatureAttribute_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisDeclaredAnnotationPresent_7C_28Ljava_2Flang_2FClass_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisLocalOrAnonymousClass_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisLocalClass_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisAnonymousClass_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CresolveName_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CasSubclass_7C_28Ljava_2Flang_2FClass_3B_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CdesiredAssertionStatus_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetAccessFlags_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetEnclosingClass_7C_28_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetClasses_7C_28_29ALjava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredClasses_7C_28_29ALjava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredFieldsUnchecked_7C_28Z_29ALjava_2Flang_2Freflect_2FField_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaringClass_7C_28_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetEnclosingConstructor_7C_28_29Ljava_2Flang_2Freflect_2FConstructor_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetEnclosingMethod_7C_28_29Ljava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetEnumConstants_7C_28_29ALjava_2Flang_2FObject_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetEnumConstantsShared_7C_28_29ALjava_2Flang_2FObject_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetField_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2Freflect_2FField_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetFields_7C_28_29ALjava_2Flang_2Freflect_2FField_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetGenericSuperclass_7C_28_29Ljava_2Flang_2Freflect_2FType_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetInstanceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetPackage_7C_28_29Ljava_2Flang_2FPackage_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetPackageName_24_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetProtectionDomain_7C_28_29Ljava_2Fsecurity_2FProtectionDomain_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetSigners_7C_28_29ALjava_2Flang_2FObject_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisMemberClass_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CgetTypeParameters_7C_28_29ALjava_2Flang_2Freflect_2FTypeVariable_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisAnnotation_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisAnnotationPresent_7C_28Ljava_2Flang_2FClass_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisFinalizable_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CisSynthetic_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7CtoGenericString_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FClass_3B_7ChashCode_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cmin_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cmax_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cmin_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cmax_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cabs_7C_28J_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cabs_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Clog10_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Csignum_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CaddExact_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CmultiplyExact_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CfloorDiv_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CfloorMod_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CsubtractExact_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CtoIntExact_7C_28J_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CmultiplyExact_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CaddExact_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CsubtractExact_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cmin_7C_28FF_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Csqrt_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cabs_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cmax_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cmin_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CcopySign_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CgetExponent_7C_28D_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cmax_7C_28FF_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cfloor_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Ctan_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cacos_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Ccos_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Csin_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Casin_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Catan_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Catan2_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cpow_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cround_7C_28D_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Clog_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cceil_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CpowerOfTwoD_7C_28I_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CIEEEremainder_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cabs_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Ccbrt_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CcopySign_7C_28FF_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Ccosh_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CdecrementExact_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CdecrementExact_7C_28J_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cexp_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cexpm1_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CfloorDiv_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CfloorMod_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CgetExponent_7C_28F_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Chypot_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CincrementExact_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CincrementExact_7C_28J_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Clog1p_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CnegateExact_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CnegateExact_7C_28J_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CnextAfter_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CnextAfter_7C_28FD_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CnextDown_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CnextDown_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CnextUp_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CnextUp_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CpowerOfTwoF_7C_28I_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Crint_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cround_7C_28F_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cscalb_7C_28DI_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Cscalb_7C_28FI_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Csignum_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Csinh_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Ctanh_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CtoDegrees_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7CtoRadians_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Culp_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FMath_3B_7Culp_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Clog_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Csqrt_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CIEEEremainder_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cabs_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cabs_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cabs_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cabs_7C_28J_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cacos_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CaddExact_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CaddExact_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Casin_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Catan_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Catan2_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Ccbrt_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cceil_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CfloorOrCeil_7C_28DDDD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CcopySign_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CcopySign_7C_28FF_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Ccos_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Ccosh_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cexp_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cexpm1_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cfloor_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CfloorDiv_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CfloorDiv_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CfloorMod_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CfloorMod_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CgetExponent_7C_28D_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CgetExponent_7C_28F_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Chypot_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Clog10_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Clog1p_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cmax_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cmax_7C_28FF_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cmax_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cmax_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cmin_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cmin_7C_28FF_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cmin_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cmin_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CmultiplyExact_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CmultiplyExact_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CnextAfter_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CnextAfter_7C_28FD_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CnextDown_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CnextDown_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CnextUp_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CnextUp_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cpow_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Crint_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cround_7C_28F_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cround_7C_28D_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cscalb_7C_28DI_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Cscalb_7C_28FI_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Csignum_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Csignum_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Csin_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Csinh_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CsubtractExact_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CsubtractExact_7C_28JJ_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Ctan_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Ctanh_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CtoDegrees_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CtoIntExact_7C_28J_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7CtoRadians_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Culp_7C_28D_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FStrictMath_3B_7Culp_7C_28F_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7Ccompare_7C_28DD_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CdoubleToLongBits_7C_28D_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7ChashCode_7C_28D_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CvalueOf_7C_28D_29Ljava_2Flang_2FDouble_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7ClongBitsToDouble_7C_28J_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CisNaN_7C_28D_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CisInfinite_7C_28D_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CtoString_7C_28D_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CdoubleValue_7C_28_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CparseDouble_7C_28Ljava_2Flang_2FString_3B_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CdoubleToRawLongBits_7C_28D_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CisFinite_7C_28D_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7Cmax_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7Cmin_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7Csum_7C_28DD_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CtoHexString_7C_28D_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CvalueOf_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FDouble_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CbyteValue_7C_28_29B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CcompareTo_7C_28Ljava_2Flang_2FDouble_3B_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CcompareTo_7C_28Ljava_2Flang_2FObject_3B_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CfloatValue_7C_28_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7ChashCode_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CintValue_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CisInfinite_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CisNaN_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7ClongValue_7C_28_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CshortValue_7C_28_29S"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FDouble_3B_7CtoString_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CfloatToIntBits_7C_28F_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CintBitsToFloat_7C_28I_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CisNaN_7C_28F_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CtoString_7C_28F_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CvalueOf_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FFloat_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CfloatValue_7C_28_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CfloatToRawIntBits_7C_28F_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CparseFloat_7C_28Ljava_2Flang_2FString_3B_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CisFinite_7C_28F_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CisInfinite_7C_28F_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CvalueOf_7C_28F_29Ljava_2Flang_2FFloat_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7Ccompare_7C_28FF_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7ChashCode_7C_28F_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7Cmax_7C_28FF_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7Cmin_7C_28FF_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7Csum_7C_28FF_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CtoHexString_7C_28F_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CbyteValue_7C_28_29B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CcompareTo_7C_28Ljava_2Flang_2FFloat_3B_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CcompareTo_7C_28Ljava_2Flang_2FObject_3B_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CdoubleValue_7C_28_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7ChashCode_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CintValue_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CisInfinite_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CisNaN_7C_28_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7ClongValue_7C_28_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CshortValue_7C_28_29S"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FFloat_3B_7CtoString_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7Cdigit_7C_28CI_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7Ccompare_7C_28CC_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CvalueOf_7C_28C_29Ljava_2Flang_2FCharacter_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcharCount_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointAt_7C_28Ljava_2Flang_2FCharSequence_3BI_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisHighSurrogate_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLowSurrogate_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoCodePoint_7C_28CC_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointAt_7C_28ACI_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointAtImpl_7C_28ACII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointAt_7C_28ACII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointBefore_7C_28Ljava_2Flang_2FCharSequence_3BI_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointBefore_7C_28ACI_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointBeforeImpl_7C_28ACII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointBefore_7C_28ACII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointCount_7C_28Ljava_2Flang_2FCharSequence_3BII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointCount_7C_28ACII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcodePointCountImpl_7C_28ACII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7Cdigit_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CdigitImpl_7C_28II_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CforDigit_7C_28II_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetDirectionality_7C_28C_29B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetDirectionality_7C_28I_29B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetType_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetDirectionalityImpl_7C_28I_29B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetName_7C_28I_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisValidCodePoint_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetNameImpl_7C_28I_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetNumericValue_7C_28C_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetNumericValue_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetNumericValueImpl_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetType_7C_28C_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CgetTypeImpl_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7ChashCode_7C_28C_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7ChighSurrogate_7C_28I_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisAlphabetic_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisAlphabeticImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisBmpCodePoint_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisDefined_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisDefined_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisDefinedImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisDigit_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisDigit_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisDigitImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisISOControl_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisISOControl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisIdentifierIgnorable_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisIdentifierIgnorable_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisIdentifierIgnorableImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisIdeographic_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisIdeographicImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisJavaIdentifierPart_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisJavaIdentifierPart_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisJavaIdentifierStart_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisJavaIdentifierStart_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisJavaLetter_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisJavaLetterOrDigit_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLetter_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLetter_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLetterImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLetterOrDigit_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLetterOrDigit_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLetterOrDigitImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLowerCase_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLowerCase_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisLowerCaseImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisMirrored_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisMirrored_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisMirroredImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisSpace_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisSpaceChar_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisSpaceChar_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisSpaceCharImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisSupplementaryCodePoint_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisSurrogate_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisSurrogatePair_7C_28CC_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisTitleCase_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisTitleCase_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisTitleCaseImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisUnicodeIdentifierPart_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisUnicodeIdentifierPart_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisUnicodeIdentifierPartImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisUnicodeIdentifierStart_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisUnicodeIdentifierStart_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisUnicodeIdentifierStartImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisUpperCase_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisUpperCase_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisUpperCaseImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisWhitespace_7C_28C_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisWhitespace_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CisWhitespaceImpl_7C_28I_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7ClowSurrogate_7C_28I_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CoffsetByCodePoints_7C_28Ljava_2Flang_2FCharSequence_3BII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CoffsetByCodePoints_7C_28ACIIII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CoffsetByCodePointsImpl_7C_28ACIIII_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CreverseBytes_7C_28C_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoChars_7C_28I_29AC"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoLowerCase_7C_28C_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoLowerCase_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoLowerCaseImpl_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoString_7C_28C_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoTitleCase_7C_28C_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoTitleCase_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoTitleCaseImpl_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoUpperCase_7C_28C_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoUpperCase_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoUpperCaseImpl_7C_28I_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcharValue_7C_28_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcompareTo_7C_28Ljava_2Flang_2FCharacter_3B_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CcompareTo_7C_28Ljava_2Flang_2FObject_3B_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7ChashCode_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FCharacter_3B_7CtoString_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Futil_2FDate_3B_7CgetCalendarSystem_7C_28I_29Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Futil_2FDate_3B_7CgetCalendarDate_7C_28_29Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Futil_2FDate_3B_7CgetCalendarSystem_7C_28J_29Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Futil_2FDate_3B_7CgetJulianCalendar_7C_28_29Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Futil_2FDate_3B_7CgetCalendarSystem_7C_28Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B_29Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Futil_2FDate_3B_7CgetMillisOf_7C_28Ljava_2Futil_2FDate_3B_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetAnnotationNative_7C_28Ljava_2Flang_2FClass_3B_29Ljava_2Flang_2Fannotation_2FAnnotation_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetNameInternal_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetSignatureAnnotation_7C_28_29ALjava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetSignatureAttribute_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetDeclaringClass_7C_28_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetName_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetType_7C_28_29Ljava_2Flang_2FClass_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7Cget_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetAnnotation_7C_28Ljava_2Flang_2FClass_3B_29Ljava_2Flang_2Fannotation_2FAnnotation_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetAnnotationsByType_7C_28Ljava_2Flang_2FClass_3B_29ALjava_2Flang_2Fannotation_2FAnnotation_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetArtField_7C_28_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetBoolean_7C_28Ljava_2Flang_2FObject_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetByte_7C_28Ljava_2Flang_2FObject_3B_29B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetChar_7C_28Ljava_2Flang_2FObject_3B_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetDeclaredAnnotations_7C_28_29ALjava_2Flang_2Fannotation_2FAnnotation_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetDexFieldIndex_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetDouble_7C_28Ljava_2Flang_2FObject_3B_29D"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetFloat_7C_28Ljava_2Flang_2FObject_3B_29F"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetGenericType_7C_28_29Ljava_2Flang_2Freflect_2FType_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetInt_7C_28Ljava_2Flang_2FObject_3B_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetLong_7C_28Ljava_2Flang_2FObject_3B_29J"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetModifiers_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetOffset_7C_28_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2Freflect_2FField_3B_7CgetShort_7C_28Ljava_2Flang_2FObject_3B_29S"},
+{  true,  false,   false,      false,      false,    false,      false,       "Landroid_2Ficu_2Futil_2FCalendar_3B_7CgetRegionForCalendar_7C_28Landroid_2Ficu_2Futil_2FULocale_3B_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Landroid_2Ficu_2Futil_2FCalendar_3B_7CgetType_7C_28_29Ljava_2Flang_2FString_3B"},
+
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_System_arraycopy__Ljava_lang_Object_2ILjava_lang_Object_2II"},
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_System_arraycopyByteUnchecked___3BI_3BII"},
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_System_arraycopyBooleanUnchecked___3ZI_3ZII"},
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_System_arraycopyShortUnchecked___3SI_3SII"},
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_System_arraycopyLongUnchecked___3JI_3JII"},
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_System_arraycopyIntUnchecked___3II_3III"},
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_System_arraycopyFloatUnchecked___3FI_3FII"},
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_System_arraycopyDoubleUnchecked___3DI_3DII"},
+{  false, true,    false,      false,      true,     false,      false,       "Native_java_lang_System_arraycopyCharUnchecked___3CI_3CII"},
+
+{  false, false,   false,      true,       true,     false,      false,       "Ljava_2Flang_2FThread_3B_7CcurrentThread_7C_28_29Ljava_2Flang_2FThread_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FStringFactory_3B_7CnewStringFromChars_7C_28IIAC_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FString_3B_7CfastSubstring_7C_28II_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FString_3B_7CcompareTo_7C_28Ljava_2Flang_2FString_3B_29I"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FString_3B_7CgetCharsNoCheck_7C_28IIACI_29V"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FStringFactory_3B_7CnewStringFromBytes_7C_28ABIII_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FStringFactory_3B_7CnewStringFromString_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FString_3B_7CtoCharArray_7C_28_29AC"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FString_3B_7Cconcat_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FString_3B_7CfastSubstring_7C_28II_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FString_3B_7Cintern_7C_28_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FString_3B_7CdoReplace_7C_28CC_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FString_3B_7CfastIndexOf_7C_28II_29I"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7Carraycopy_7C_28Ljava_2Flang_2FObject_3BILjava_2Flang_2FObject_3BII_29V"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CarraycopyCharUnchecked_7C_28ACIACII_29V"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CarraycopyByteUnchecked_7C_28ABIABII_29V"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CarraycopyShortUnchecked_7C_28ASIASII_29V"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CarraycopyIntUnchecked_7C_28AIIAIII_29V"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CarraycopyLongUnchecked_7C_28AJIAJII_29V"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CarraycopyFloatUnchecked_7C_28AFIAFII_29V"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CarraycopyDoubleUnchecked_7C_28ADIADII_29V"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CarraycopyBooleanUnchecked_7C_28AZIAZII_29V"},
+
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_StringFactory_newStringFromChars__II_3C"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_StringFactory_newStringFromString__Ljava_lang_String_2"},
+{  true,  false,   false,      false,      true,     false,      false,       "Native_java_lang_StringFactory_newStringFromBytes___3BIII"},
+
+{  false, false,   false,      true,       false,    false,      false,       "Ljava_2Flang_2FThrowable_3B_7CnativeFillInStackTrace_7C_28_29Ljava_2Flang_2FObject_3B"},
+
+{  false, true,    false,      false,      false,    false,      true,        "Ljava_2Futil_2FMap_3B_7Cput_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B"},
+{  false, true,    false,      false,      false,    false,      true,        "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapObject_7C_28Ljava_2Flang_2FObject_3BJLjava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FObject_3B_7CidentityHashCodeNative_7C_28Ljava_2Flang_2FObject_3B_29I"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FString_3B_7CcharAt_7C_28I_29C"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Futil_2FProperties_3B_7CgetProperty_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Futil_2FProperties_3B_7CgetProperty_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"},
+
+{  true,  false,   false,      false,      true,     false,      true,        "Lsun_2Fnet_2FNetProperties_3B_7Cget_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      true,     false,      true,        "Lsun_2Fnet_2FNetProperties_3B_7CgetBoolean_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FBoolean_3B"},
+{  true,  false,   false,      false,      true,     false,      true,        "Lsun_2Fnet_2FNetProperties_3B_7CgetInteger_7C_28Ljava_2Flang_2FString_3BI_29Ljava_2Flang_2FInteger_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2Fref_2FReference_3B_7CgetReferent_7C_28_29Ljava_2Flang_2FObject_3B", },
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CnanoTime_7C_28_29J"},
+{  true,  false,   false,      false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7Cgettid_7C_28_29I"},
+{  true,  false,   false,      false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7Cgetpid_7C_28_29I"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FSystem_3B_7CcurrentTimeMillis_7C_28_29J"},
+{  true,  false,   false,      false,      true,     false,      false,       "Lsun_2Futil_2Flocale_2FBaseLocale_24Cache_3B_7Cget_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Ljava_2Flang_2FString_3B_7Cformat_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FObject_3B_29Ljava_2Flang_2FString_3B"},
+{  true,  false,   false,      false,      false,    false,      false,       "Landroid_2Ficu_2Futil_2FCalendar_3B_7CisEquivalentTo_7C_28Landroid_2Ficu_2Futil_2FCalendar_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Landroid_2Ficu_2Futil_2FGregorianCalendar_3B_7CisEquivalentTo_7C_28Landroid_2Ficu_2Futil_2FCalendar_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Landroid_2Ficu_2Futil_2FAnnualTimeZoneRule_3B_7CisEquivalentTo_7C_28Landroid_2Ficu_2Futil_2FTimeZoneRule_3B_29Z"},
+{  true,  false,   false,      false,      false,    false,      false,       "Landroid_2Ficu_2Futil_2FGregorianCalendar_3B_7CisEquivalentTo_7C_28Landroid_2Ficu_2Futil_2FCalendar_3B_29Z"},
+
+{  true,  false,   false,      false,      true,     false,      false,       "Landroid_2Fview_2FSurface_3B_7CnativeIsValid_7C_28J_29Z"},
+{  true,  false,   false,      false,      true,     false,      false,       "Lsun_2Fmisc_2FUnsafe_3B_7CgetObjectVolatile_7C_28Ljava_2Flang_2FObject_3BJ_29Ljava_2Flang_2FObject_3B"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FThread_3B_7CnativeHoldsLock_7C_28Ljava_2Flang_2FObject_3B_29Z"},
+{  true,  false,   false,      false,      true,     false,      false,       "Landroid_2Futil_2FLog_3B_7Clogger__entry__max__payload__native_7C_28_29I"},
+{  true,  false,   false,      false,      true,     false,      false,       "Landroid_2Fos_2FSystemProperties_3B_7Cnative__get__int_7C_28Ljava_2Flang_2FString_3BI_29I"},
+{  true,  false,   false,      false,      true,     false,      false,       "Ljava_2Flang_2FThread_3B_7CnativeGetStatus_7C_28Z_29I"},
+{  false, true,    false,      false,      true,     false,      false,       "Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ReducedPrinterParser_3B_7Clambda_24setValue_240_24DateTimeFormatterBuilder_24ReducedPrinterParser_7C_28Ljava_2Ftime_2Fformat_2FDateTimeParseContext_3BJIILjava_2Ftime_2Fchrono_2FChronology_3B_29V"},
+
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FMessageQueue_3B_7CnativePollOnce_7C_28JI_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FTrace_3B_7CnativeTraceBegin_7C_28JLjava_2Flang_2FString_3B_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Futil_2FLog_3B_7Cprintln__native_7C_28IILjava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FSystemProperties_3B_7Cnative__add__change__callback_7C_28_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FProcess_3B_7CreadProcFile_7C_28Ljava_2Flang_2FString_3BAIALjava_2Flang_2FString_3BAJAF_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7Cstat_7C_28Ljava_2Flang_2FString_3B_29Landroid_2Fsystem_2FStructStat_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Fio_2FFileInputStream_3B_7Copen0_7C_28Ljava_2Flang_2FString_3B_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FProcess_3B_7CgetGidForName_7C_28Ljava_2Flang_2FString_3B_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Futil_2FEventLog_3B_7CwriteEvent_7C_28IALjava_2Flang_2FObject_3B_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FObject_3B_7CinternalClone_7C_28_29Ljava_2Flang_2FObject_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7CwriteBytes_7C_28Ljava_2Fio_2FFileDescriptor_3BLjava_2Flang_2FObject_3BII_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FProcess_3B_7CgetPidsForCommands_7C_28ALjava_2Flang_2FString_3B_29AI"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Fio_2FUnixFileSystem_3B_7CcreateFileExclusively0_7C_28Ljava_2Flang_2FString_3B_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Fio_2FUnixFileSystem_3B_7Clist0_7C_28Ljava_2Fio_2FFile_3B_29ALjava_2Flang_2FString_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7Cclose_7C_28Ljava_2Fio_2FFileDescriptor_3B_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FAsynchronousCloseMonitor_3B_7CsignalBlockedThreads_7C_28Ljava_2Fio_2FFileDescriptor_3B_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7CreadBytes_7C_28Ljava_2Fio_2FFileDescriptor_3BLjava_2Flang_2FObject_3BII_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FBinder_3B_7CsetThreadStrictModePolicy_7C_28I_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Futil_2Fregex_2FMatcher_3B_7CfindNextImpl_7C_28JAI_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Futil_2Fregex_2FMatcher_3B_7CsetInputImpl_7C_28JLjava_2Flang_2FString_3BII_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Ficu_2FNativeConverter_3B_7CsetCallbackDecode_7C_28JIILjava_2Flang_2FString_3B_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7Copen_7C_28Ljava_2Flang_2FString_3BII_29Ljava_2Fio_2FFileDescriptor_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FBinderProxy_3B_7CtransactNative_7C_28ILandroid_2Fos_2FParcel_3BLandroid_2Fos_2FParcel_3BI_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FBinder_3B_7CrestoreCallingIdentity_7C_28J_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fnet_2FLocalSocketImpl_3B_7Creadba__native_7C_28ABIILjava_2Fio_2FFileDescriptor_3B_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FProcess_3B_7CgetPids_7C_28Ljava_2Flang_2FString_3BAI_29AI"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FTrace_3B_7CnativeAsyncTraceBegin_7C_28JLjava_2Flang_2FString_3BI_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FTrace_3B_7CnativeAsyncTraceEnd_7C_28JLjava_2Flang_2FString_3BI_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeAppendFrom_7C_28JJII_29J"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Fio_2FFileDescriptor_3B_7CisSocket_7C_28I_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FProcess_3B_7CsetProcessGroup_7C_28II_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FProcess_3B_7CsetThreadPriority_7C_28I_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeWriteFloat_7C_28JF_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7CioctlInetAddress_7C_28Ljava_2Fio_2FFileDescriptor_3BILjava_2Flang_2FString_3B_29Ljava_2Fnet_2FInetAddress_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FObject_3B_7CidentityHashCodeNative_7C_28Ljava_2Flang_2FObject_3B_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FBinder_3B_7CgetCallingPid_7C_28_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FBinder_3B_7CflushPendingCommands_7C_28_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapLong_7C_28Ljava_2Flang_2FObject_3BJJJ_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FBinder_3B_7CgetCallingUid_7C_28_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeWriteFileDescriptor_7C_28JLjava_2Fio_2FFileDescriptor_3B_29J"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeReadStrongBinder_7C_28J_29Landroid_2Fos_2FIBinder_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FBinderProxy_3B_7ClinkToDeath_7C_28Landroid_2Fos_2FIBinder_24DeathRecipient_3BI_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeReadLong_7C_28J_29J"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeWriteLong_7C_28JJ_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Lsun_2Fmisc_2FUnsafe_3B_7CputObject_7C_28Ljava_2Flang_2FObject_3BJLjava_2Flang_2FObject_3B_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Lsun_2Fmisc_2FUnsafe_3B_7CputOrderedObject_7C_28Ljava_2Flang_2FObject_3BJLjava_2Flang_2FObject_3B_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeUnmarshall_7C_28JABII_29J"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fview_2FSurfaceControl_3B_7CnativeIsRogSupport_7C_28_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Fio_2FUnixFileSystem_3B_7CcheckAccess0_7C_28Ljava_2Fio_2FFile_3BI_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Futil_2FMemoryIntArray_3B_7CnativeGet_7C_28IJI_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FObject_3B_7CnotifyAll_7C_28_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Futil_2FEventLog_3B_7CwriteEvent_7C_28II_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7CgetsockoptLinger_7C_28Ljava_2Fio_2FFileDescriptor_3BII_29Landroid_2Fsystem_2FStructLinger_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Fio_2FUnixFileSystem_3B_7Ccanonicalize0_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fgraphics_2FRegion_3B_7CnativeOp_7C_28JJJI_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Futil_2FMemoryIntArray_3B_7CnativeSet_7C_28IJII_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Fio_2FUnixFileSystem_3B_7Crename0_7C_28Ljava_2Fio_2FFile_3BLjava_2Fio_2FFile_3B_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FClass_3B_7CclassForName_7C_28Ljava_2Flang_2FString_3BZLjava_2Flang_2FClassLoader_3B_29Ljava_2Flang_2FClass_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Ldalvik_2Fsystem_2FVMRuntime_3B_7CnewUnpaddedArray_7C_28Ljava_2Flang_2FClass_3BI_29Ljava_2Flang_2FObject_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7Cchmod_7C_28Ljava_2Flang_2FString_3BI_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FUEventObserver_3B_7CnativeSetup_7C_28_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fview_2FSurfaceControl_3B_7CnativeSetActiveConfig_7C_28Landroid_2Fos_2FIBinder_3BI_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Fio_2FFileDescriptor_3B_7Csync_7C_28_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fgraphics_2FMatrix_3B_7CnGetValues_7C_28JAF_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fgraphics_2FBaseCanvas_3B_7CnDrawColor_7C_28JII_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fgraphics_2FRegion_3B_7CnativeSetRect_7C_28JIIII_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FDebug_3B_7CgetPss_7C_28IAJAJ_29J"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fcontent_2Fres_2FXmlBlock_3B_7CnativeNext_7C_28J_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Lsun_2Fnio_2Fch_2FFileDispatcherImpl_3B_7Cread0_7C_28Ljava_2Fio_2FFileDescriptor_3BJI_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7Cfstat_7C_28Ljava_2Fio_2FFileDescriptor_3B_29Landroid_2Fsystem_2FStructStat_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Lsun_2Fnio_2Ffs_2FUnixNativeDispatcher_3B_7Copen0_7C_28JII_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Futil_2FNativeAllocationRegistry_3B_7CapplyFreeFunction_7C_28JJ_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Ldalvik_2Fsystem_2FVMRuntime_3B_7CregisterNativeFree_7C_28I_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FThread_3B_7Cinterrupted_7C_28_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FParcel_3B_7CnativeCreateByteArray_7C_28J_29AB"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FClass_3B_7CgetDeclaredFields_7C_28_29ALjava_2Flang_2Freflect_2FField_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fview_2FSurfaceControl_3B_7CnativeGetContentFrameStats_7C_28JLandroid_2Fview_2FWindowContentFrameStats_3B_29Z"},
+{  false, false,   true,       false,      true,     false,      false,       "Lsun_2Fnio_2Fch_2FFileDispatcherImpl_3B_7Cwrite0_7C_28Ljava_2Fio_2FFileDescriptor_3BJI_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FThread_3B_7CnativeInterrupt_7C_28_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FThread_3B_7CnativeSetPriority_7C_28I_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FRuntime_3B_7CnativeExit_7C_28I_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Fio_2FLinux_3B_7Cstrerror_7C_28I_29Ljava_2Flang_2FString_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fcontent_2Fres_2FXmlBlock_3B_7CnativeDestroy_7C_28J_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FProcess_3B_7CgetThreadPriority_7C_28I_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FFileObserver_24ObserverThread_3B_7Cinit_7C_28_29I"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fview_2FSurface_3B_7CnativeSyncFrameInfo_7C_28JJ_29V"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Ficu_2FICU_3B_7CgetCurrencyCode_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fos_2FSystemProperties_3B_7Cnative__get_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Ldalvik_2Fsystem_2FVMRuntime_3B_7Cproperties_7C_28_29ALjava_2Flang_2FString_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Futil_2Fregex_2FMatcher_3B_7CopenImpl_7C_28J_29J"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Futil_2Fregex_2FPattern_3B_7CcompileImpl_7C_28Ljava_2Flang_2FString_3BI_29J"},
+{  false, false,   true,       false,      true,     false,      false,       "Ljava_2Flang_2FThrowable_3B_7CnativeFillInStackTrace_7C_28_29Ljava_2Flang_2FObject_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Ficu_2FNativeConverter_3B_7CopenConverter_7C_28Ljava_2Flang_2FString_3B_29J"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fview_2FDisplayEventReceiver_3B_7CnativeInit_7C_28Ljava_2Flang_2Fref_2FWeakReference_3BLandroid_2Fos_2FMessageQueue_3BI_29J"},
+{  false, false,   true,       false,      true,     false,      false,       "Landroid_2Fcontent_2Fres_2FStringBlock_3B_7CnativeGetString_7C_28JI_29Ljava_2Flang_2FString_3B"},
+{  false, false,   true,       false,      true,     false,      false,       "Llibcore_2Futil_2FCharsetUtils_3B_7CtoUtf8Bytes_7C_28Ljava_2Flang_2FString_3BII_29AB"},
diff --git a/src/mapleall/maple_ipa/include/prop_parameter_type.h b/src/mapleall/maple_ipa/include/prop_parameter_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..e03811db6417aa519f69d8038dab0915de8cdcc3
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/prop_parameter_type.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IPA_INCLUDE_PROP_PARAM_TYPE_H
+#define MAPLE_IPA_INCLUDE_PROP_PARAM_TYPE_H
+#include "mir_nodes.h"
+#include "mir_builder.h"
+#include "call_graph.h"
+#include "me_ir.h"
+#include "me_irmap.h"
+#include "dominance.h"
+#include "class_hierarchy.h"
+#include "maple_phase.h"
+#include "ipa_phase_manager.h"
+namespace maple {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+
+class PropParamType {
+ public:
+  PropParamType(MemPool &memPool, MapleAllocator &alloc, MIRModule &mod, CallGraph &cg, AnalysisDataManager &dataMap)
+      : memPool(memPool), alloc(alloc), module(mod), builder(*mod.GetMIRBuilder()),
+        cg(cg), dataMap(dataMap), curFunc(nullptr), debug(false) {}
+  virtual ~PropParamType() = default;
+  bool CheckOpndZero(const MeExpr *expr) const;
+  void ResolveCallStmt(MeStmt &meStmt);
+  void InsertNullCheck(CallMeStmt &callStmt, const std::string &funcName, uint32 index, MeExpr &receiver);
+  bool CheckCondtionStmt(const MeStmt &meStmt) const;
+  void ResolveIreadExpr(MeExpr &expr);
+  void TraversalMeStmt(MeStmt &meStmt);
+  void RunOnScc(maple::SCCNode<CGNode> &scc);
+  void Prop(MIRFunction &func);
+
+ private:
+  MemPool &memPool;
+  MapleAllocator &alloc;
+  MIRModule &module;
+  MIRBuilder &builder;
+  CallGraph &cg;
+  AnalysisDataManager &dataMap;
+  std::map<MIRSymbol*, PointerAttr> formalMapLocal;
+  MIRFunction *curFunc;
+  bool debug;
+};
+#pragma clang diagnostic pop
+MAPLE_SCC_PHASE_DECLARE_BEGIN(SCCPropParamType, maple::SCCNode<CGNode>)
+OVERRIDE_DEPENDENCE
+MAPLE_SCC_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_IPA_INCLUDE_PROP_PARAM_TYPE_H
diff --git a/src/mapleall/maple_ipa/include/prop_return_null.h b/src/mapleall/maple_ipa/include/prop_return_null.h
new file mode 100644
index 0000000000000000000000000000000000000000..d900be109e660f24dce70cc23f7eba9159b7eb63
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/prop_return_null.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IPA_INCLUDE_PROP_RETURN_ATTR_H
+#define MAPLE_IPA_INCLUDE_PROP_RETURN_ATTR_H
+#include "mir_nodes.h"
+#include "mir_builder.h"
+#include "call_graph.h"
+#include "me_ir.h"
+#include "me_irmap.h"
+#include "dominance.h"
+#include "class_hierarchy.h"
+#include "maple_phase.h"
+#include "ipa_phase_manager.h"
+namespace maple {
+class PropReturnAttr {
+ public:
+  PropReturnAttr(MemPool &memPool, MapleAllocator &alloc, MIRModule &mod, CallGraph &cg, AnalysisDataManager &dataMap)
+      : memPool(memPool), alloc(alloc), module(mod), builder(*mod.GetMIRBuilder()),
+        cg(cg), dataMap(dataMap), inferredRetTyIdx(0),
+        retTy(kNotSeen), maybeNull(true), debug(false) {}
+  virtual ~PropReturnAttr() = default;
+  TyIdx GetInferredTyIdx(MeExpr &expr) const;
+  void InsertNullCheck(const CallMeStmt &callStmt, MeExpr &receiver) const;
+  void PropVarInferredType(VarMeExpr &varMeExpr) const;
+  void PropIvarInferredType(IvarMeExpr &ivar) const;
+  void VisitVarPhiNode(MePhiNode &varPhi) const;
+  void VisitMeExpr(MeExpr *meExpr) const;
+  void ReturnTyIdxInferring(const RetMeStmt &retMeStmt);
+  void TraversalMeStmt(MeStmt &meStmt);
+  void TraversalBB(BB *bb);
+  void Perform(MeFunction &func);
+  void Initialize(maple::SCCNode<CGNode> &scc) const;
+  void Prop(maple::SCCNode<CGNode> &scc);
+  bool PhaseRun(maple::SCCNode<CGNode> &scc);
+
+ private:
+  MemPool &memPool;
+  MapleAllocator &alloc;
+  MIRModule &module;
+  MIRBuilder &builder;
+  CallGraph &cg;
+  AnalysisDataManager &dataMap;
+  TyIdx inferredRetTyIdx;
+  enum TagRetTyIdx {
+    kNotSeen,
+    kSeen,
+    kFailed
+  } retTy;
+  bool maybeNull;
+  bool debug;
+};
+
+MAPLE_SCC_PHASE_DECLARE_BEGIN(SCCPropReturnAttr, maple::SCCNode<CGNode>)
+OVERRIDE_DEPENDENCE
+MAPLE_SCC_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_IPA_INCLUDE_PROP_RETURN_ATTR_H
diff --git a/src/mapleall/maple_ipa/include/region_identify.h b/src/mapleall/maple_ipa/include/region_identify.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ca4f169a3065b8f3c003bf980e5c6bec97f344d
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/region_identify.h
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IPA_INCLUDE_REGION_IDENTIFY_H
+#define MAPLE_IPA_INCLUDE_REGION_IDENTIFY_H
+
+#include <algorithm>
+#include <unordered_map>
+#include <unordered_set>
+#include "cfg_primitive_types.h"
+#include "ipa_collect.h"
+#include "mir_nodes.h"
+#include "opcodes.h"
+#include "ptr_list_ref.h"
+#include "stmt_identify.h"
+#include "suffix_array.h"
+
+namespace maple {
+constexpr size_t kGroupSizeLimit = 2;
+using GroupId = size_t;
+using StmtIterator = PtrListRefIterator<StmtNode>;
+using SymbolRegPair = std::pair<StIdx, PregIdx>;
+using RegionReturnVector = std::vector<SymbolRegPair>;
+
+class RegionCandidate {
+ public:
+  RegionCandidate(StmtInfoId startId, StmtInfoId endId, StmtInfo *start, StmtInfo *end, MIRFunction* function)
+      : startId(startId), endId(endId), start(start), end(end), function(function), length(endId - startId + 1) {}
+  virtual ~RegionCandidate() = default;
+  void CollectRegionInputAndOutput(StmtInfo &stmtInfo, CollectIpaInfo &ipaInfo);
+  const bool HasDefinitionOutofRegion(DefUsePositions &defUse) const;
+  bool HasJumpOutOfRegion(StmtInfo &stmtInfo, bool isStart);
+  bool IsLegal(CollectIpaInfo &ipaInfo);
+
+  static SymbolRegPair GetSymbolRegPair(BaseNode &node) {
+    switch (node.GetOpCode()) {
+      case OP_regread: {
+        return SymbolRegPair(StIdx(0), static_cast<RegreadNode&>(node).GetRegIdx());
+      }
+      case OP_regassign: {
+        return SymbolRegPair(StIdx(0), static_cast<RegassignNode&>(node).GetRegIdx());
+      }
+      case OP_addrof:
+      case OP_dread: {
+        return SymbolRegPair(static_cast<DreadNode&>(node).GetStIdx(), PregIdx(0));
+      }
+      case OP_dassign: {
+        return SymbolRegPair(static_cast<DassignNode&>(node).GetStIdx(), PregIdx(0));
+      }
+      case OP_asm:
+      case OP_callassigned:
+      case OP_icallassigned:
+      case OP_icallprotoassigned:
+      case OP_intrinsiccallassigned: {
+        auto *callReturnVector = node.GetCallReturnVector();
+        auto &pair = callReturnVector->front();
+        return callReturnVector->empty() ? SymbolRegPair(0, 0) : SymbolRegPair(pair.first, pair.second.GetPregIdx());
+      }
+      default: {
+        CHECK_FATAL(false, "unexpected op code");
+        return SymbolRegPair(StIdx(0), PregIdx(0));
+      }
+    }
+  }
+
+  StmtInfo *GetStart() {
+    return start;
+  }
+
+  StmtInfo *GetEnd() {
+    return end;
+  }
+
+  MIRFunction *GetFunction() {
+    return function;
+  }
+
+  void Dump() {
+    LogInfo::MapleLogger() << "range: " << startId << "->" << endId << "\n";
+    function->SetCurrentFunctionToThis();
+    for (auto &pair : regionOutputs) {
+      if (pair.second != 0) {
+        LogInfo::MapleLogger() << "output: reg %" << pair.second << "\n";
+      } else {
+        LogInfo::MapleLogger() << "output: var %" << function->GetSymbolTabItem(pair.first.Idx())->GetName() << "\n";
+      }
+    }
+    auto *currStmt = start->GetStmtNode();
+    auto endPosition = end->GetStmtNode()->GetStmtInfoId();
+    while (currStmt != nullptr && (currStmt->GetOpCode() == OP_label || currStmt->GetStmtInfoId() <= endPosition)) {
+      currStmt->Dump();
+      currStmt = currStmt->GetNext();
+    }
+  }
+
+  void SetGroupId(GroupId id) {
+    groupId = id;
+  }
+
+  GroupId GetGroupId() {
+    return groupId;
+  }
+
+  StmtInfoId GetStartId() {
+    return startId;
+  }
+
+  StmtInfoId GetEndId() {
+    return endId;
+  }
+
+  size_t GetLength() {
+    return length;
+  }
+
+  std::set<SymbolRegPair> &GetRegionInPuts() {
+    return regionInputs;
+  }
+
+  std::set<SymbolRegPair> &GetRegionOutPuts() {
+    return regionOutputs;
+  }
+
+  std::unordered_set<BaseNode*> &GetStmtJumpToEnd() {
+    return stmtJumpToEnd;
+  }
+
+  PrimType GetOutputPrimType() {
+    if (regionOutputs.empty()) {
+      return PTY_void;
+    }
+    auto stIdx = regionOutputs.begin()->first;
+    auto pregIdx = regionOutputs.begin()->second;
+    if (stIdx.Idx() != 0) {
+      return function->GetSymbolTabItem(stIdx.Idx())->GetType()->GetPrimType();
+    } else {
+      return function->GetPregItem(pregIdx)->GetPrimType();
+    }
+  }
+
+  bool IsOverlapWith(RegionCandidate &rhs) {
+    return (startId >= rhs.GetStartId() && startId <= rhs.GetEndId()) ||
+        (rhs.GetStartId() >= startId && rhs.GetStartId() <= endId);
+  }
+
+  bool IsRegionInput(BaseNode &node) {
+    auto pair = GetSymbolRegPair(node);
+    return regionInputs.find(pair) != regionInputs.end();
+  }
+
+  template<typename Functor>
+  void TraverseRegion(Functor processor) {
+    auto &stmtList = start->GetCurrBlock()->GetStmtNodes();
+    auto begin = StmtNodes::iterator(start->GetStmtNode());
+    for (auto it = begin; it != stmtList.end() && it->GetStmtInfoId() <= endId ; ++it) {
+      processor(it);
+    }
+  }
+
+ private:
+  StmtInfoId startId;
+  StmtInfoId endId;
+  StmtInfo* start;
+  StmtInfo* end;
+  MIRFunction *function;
+  size_t length;
+  GroupId groupId = kInvalidIndex;
+  std::set<SymbolRegPair> regionOutputs;
+  std::set<SymbolRegPair> regionInputs;
+  std::unordered_set<BaseNode*> stmtJumpToEnd;
+};
+
+class RegionGroup {
+ public:
+  RegionGroup() = default;
+
+  virtual ~RegionGroup() = default;
+
+  void Dump() {
+    LogInfo::MapleLogger() << "region group: " << groupId << "\n";
+    LogInfo::MapleLogger() << "region number: " << groups.size() << "\n";
+    if (groups.size() < kGroupSizeLimit) {
+      return;
+    }
+    for (auto &region : groups) {
+      LogInfo::MapleLogger() << "region candidates: " << region.GetStart()->GetStmtNode()->GetStmtInfoId() << "->"
+          << region.GetEnd()->GetStmtNode()->GetStmtInfoId() << "\n";
+      LogInfo::MapleLogger() << "origin range: " << region.GetStartId() << "->"
+          << region.GetEndId() << "\n";
+      region.Dump();
+    }
+  }
+
+  std::vector<RegionCandidate> &GetGroups() {
+    return groups;
+  }
+
+  uint32 GetGroupId() {
+    return groupId;
+  }
+
+  void SetGroupId(GroupId id) {
+    groupId = id;
+  }
+
+  int64 GetCost() {
+    return cost;
+  }
+
+  void SetCost(int64 newCost) {
+    cost = newCost;
+  }
+
+ private:
+  std::vector<RegionCandidate> groups;
+  uint32 groupId;
+  int64 cost = 0;
+};
+
+class RegionIdentify {
+ public:
+  explicit RegionIdentify(CollectIpaInfo *ipaInfo) : ipaInfo(ipaInfo) {}
+  virtual ~RegionIdentify() = default;
+  void RegionInit();
+  std::vector<RegionGroup> &GetRegionGroups() {
+    return regionGroups;
+  }
+
+ private:
+  void CreateRegionCandidates(SuffixArray &sa);
+  void CreateRegionGroups(std::vector<RegionCandidate> &regions);
+  void ClearSrcMappings();
+  bool CheckOverlapAmongGroupRegions(RegionGroup &group, RegionCandidate &region);
+  bool IsRegionLegal(uint startPosition, uint endPosition);
+  bool CheckCompatibilifyAmongRegionComponents(BaseNode &lhs, BaseNode& rhs);
+  bool CheckCompatibilifyBetweenSrcs(BaseNode &lhs, BaseNode& rhs);
+  bool HasSameStructure(RegionCandidate &lhs, RegionCandidate &rhs);
+  bool CompareSymbolStructure(const StIdx leftIdx, const StIdx rightIdx);
+  bool CompareRegStructure(const PregIdx leftIdx, const PregIdx rightIdx);
+  bool CompareConstStructure(const MIRConst *leftConst, const MIRConst *rightConst);
+  StmtInfo *GetNearestNonnullStmtInfo(StmtInfoId index, bool forward);
+
+  CollectIpaInfo *ipaInfo;
+  std::vector<RegionGroup> regionGroups;
+  std::unordered_map<StIdx, StIdx> symMap;
+  std::unordered_map<PregIdx, PregIdx> leftRegMap;
+  std::unordered_map<PregIdx, PregIdx> rightRegMap;
+  std::unordered_map<const MIRConst*, const MIRConst*> leftConstMap;
+  std::unordered_map<const MIRConst*, const MIRConst*> rightConstMap;
+};
+}
+#endif  // MAPLE_IPA_INCLUDE_REGION_IDENTIFY_H
diff --git a/src/mapleall/maple_ipa/include/stmt_identify.h b/src/mapleall/maple_ipa/include/stmt_identify.h
new file mode 100644
index 0000000000000000000000000000000000000000..b84a57d8a353dd838b6bbd41f4e71dbcbca9c4c9
--- /dev/null
+++ b/src/mapleall/maple_ipa/include/stmt_identify.h
@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IPA_INCLUDE_STMT_IDENTIFY_H
+#define MAPLE_IPA_INCLUDE_STMT_IDENTIFY_H
+
+#include <sys/types.h>
+#include <cstddef>
+#include <limits>
+#include <unordered_map>
+#include <vector>
+#include "irmap.h"
+#include "me_ir.h"
+#include "mir_nodes.h"
+#include "opcodes.h"
+#include "types_def.h"
+namespace maple {
+constexpr PUIdx kInvalidPuIdx = std::numeric_limits<PUIdx>::max();
+constexpr size_t kInvalidIndex = std::numeric_limits<size_t>::max();
+constexpr LabelIdx kInvalidLabelIdx = std::numeric_limits<LabelIdx>::max();
+
+struct DefUsePositions {
+  MapleVector<size_t> definePositions;
+  MapleVector<size_t> usePositions;
+  explicit DefUsePositions(MapleAllocator &alloc)
+      : definePositions(alloc.Adapter()),
+        usePositions(alloc.Adapter()) {}
+};
+
+class StmtInfo {
+ public:
+  StmtInfo(MeStmt *stmt, PUIdx puIdx, MapleAllocator &alloc)
+      : allocator(alloc),
+        meStmt(stmt),
+        puIdx(puIdx),
+        hashCandidate(allocator.Adapter()),
+        symbolDefUse(allocator.Adapter()),
+        regDefUse(allocator.Adapter()),
+        locationsJumpFrom(allocator.Adapter()),
+        locationsJumpTo(allocator.Adapter()) {
+    if (stmt) {
+      CreateHashCandidate();
+    }
+  }
+  virtual ~StmtInfo() = default;
+
+  bool IsValid() {
+    switch (hashCandidate[0]) {
+      case OP_switch:
+      case OP_return:
+      case OP_asm:
+        return false;
+      default:
+        return valid;
+    }
+  }
+
+  bool IsCall() {
+    switch (hashCandidate[0]) {
+      case OP_call:
+      case OP_callassigned:
+      case OP_icall:
+      case OP_icallassigned:
+      case OP_icallprotoassigned:{
+        return true;
+      }
+      default: {
+        return false;
+      }
+    }
+  }
+
+  void CreateHashCandidate() {
+    hashCandidate.emplace_back(meStmt->GetOp());
+    if (meStmt->GetOp() == OP_call || meStmt->GetOp() == OP_callassigned) {
+      hashCandidate.emplace_back(static_cast<CallMeStmt *>(meStmt)->GetPUIdx());
+    }
+    if (meStmt->GetOp() == OP_intrinsiccall ||
+        meStmt->GetOp() == OP_intrinsiccallassigned ||
+        meStmt->GetOp() == OP_intrinsiccallwithtypeassigned) {
+      hashCandidate.emplace_back(static_cast<IntrinsiccallMeStmt *>(meStmt)->GetIntrinsic());
+    }
+    if (meStmt->GetVarLHS() != nullptr) {
+      GetExprHashCandidate(*meStmt->GetVarLHS());
+    }
+    if (meStmt->GetOp() == OP_iassign) {
+      GetExprHashCandidate(*static_cast<IassignMeStmt *>(meStmt)->GetLHSVal());
+    }
+    hashCandidate.emplace_back(meStmt->NumMeStmtOpnds());
+    for (auto i = 0; i < meStmt->NumMeStmtOpnds(); ++i) {
+      GetExprHashCandidate(*meStmt->GetOpnd(i));
+    }
+  }
+
+  void GetExprHashCandidate(MeExpr &meExpr) {
+    hashCandidate.emplace_back(meExpr.GetOp());
+    hashCandidate.emplace_back(meExpr.GetPrimType());
+    if (meExpr.GetMeOp() == kMeOpIvar) {
+      auto &ivar = static_cast<IvarMeExpr &>(meExpr);
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx());
+      hashCandidate.emplace_back(static_cast<MIRPtrType*>(type)->GetPointedType()->GetPrimType());
+      hashCandidate.emplace_back(ivar.GetFieldID());
+      valid &= ivar.GetFieldID() == 0;
+    }
+    if (meExpr.GetMeOp() == kMeOpVar) {
+      auto &var = static_cast<VarMeExpr &>(meExpr);
+      hashCandidate.emplace_back(var.GetFieldID());
+      valid &= var.GetFieldID() == 0;
+    }
+    if (meExpr.GetMeOp() == kMeOpAddrof) {
+      auto &addr = static_cast<AddrofMeExpr &>(meExpr);
+      hashCandidate.emplace_back(addr.GetFieldID());
+      valid &= addr.GetFieldID() == 0;
+    }
+    if (meExpr.GetMeOp() == kMeOpOp) {
+      auto &opExpr = static_cast<OpMeExpr &>(meExpr);
+      hashCandidate.emplace_back(opExpr.GetFieldID());
+      valid &= opExpr.GetFieldID() == 0;
+    }
+    for (auto i = 0; i < meExpr.GetNumOpnds(); ++i) {
+      GetExprHashCandidate(*meExpr.GetOpnd(i));
+    }
+  }
+
+  void DumpMeStmt(const IRMap *irMap) const {
+    if (meStmt) {
+      meStmt->Dump(irMap);
+    }
+  }
+
+  void DumpStmtNode() const {
+    if (stmt) {
+      stmt->Dump(0);
+    }
+  }
+
+  void ClearMeStmt() {
+    meStmt = nullptr;
+  }
+
+  MeStmt *GetMeStmt() {
+    return meStmt;
+  }
+
+  void SetStmtNode(StmtNode *node) {
+    stmt = node;
+  }
+
+  StmtNode *GetStmtNode() {
+    return stmt;
+  }
+
+  void SetCurrBlock(BlockNode *block) {
+    currBlock = block;
+  }
+
+  BlockNode *GetCurrBlock() {
+    return currBlock;
+  }
+
+  const bool operator==(const StmtInfo &rhs) const {
+    if (hashCandidate.size() != rhs.hashCandidate.size()) {
+      return false;
+    }
+    for (auto i = 0; i < hashCandidate.size(); ++i) {
+      if (hashCandidate[i] != rhs.hashCandidate[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  const uint8 GetHashCandidateAt(uint index) const {
+    return hashCandidate[index];
+  }
+
+  const size_t GetHashCandidateSize() const {
+    return hashCandidate.size();
+  }
+
+  const PUIdx GetPuIdx() const {
+    return puIdx;
+  }
+
+  const uint64 GetFrequency() const {
+    return frequency;
+  }
+
+  void SetFrequency(uint64 freq) {
+    frequency = freq;
+  }
+
+  DefUsePositions &GetDefUsePositions(OriginalSt &ost) {
+    if (ost.IsPregOst()) {
+      return regDefUse.insert({ost.GetPregIdx(), DefUsePositions(allocator)}).first->second;
+    } else {
+      return symbolDefUse.insert(
+          {ost.GetMIRSymbol()->GetStIdx(), DefUsePositions(allocator)}).first->second;
+    }
+  }
+
+  MapleUnorderedMap<StIdx, DefUsePositions> &GetSymbolDefUse() {
+    return symbolDefUse;
+  }
+
+  MapleUnorderedMap<PregIdx, DefUsePositions> &GetRegDefUse() {
+    return regDefUse;
+  }
+
+  MapleVector<uint32> &GetLocationsJumpFrom() {
+    return locationsJumpFrom;
+  }
+
+  MapleVector<uint32> &GetLocationsJumpTo() {
+    return locationsJumpTo;
+  }
+
+ private:
+  MapleAllocator &allocator;
+  StmtNode *stmt = nullptr;
+  BlockNode *currBlock = nullptr;
+  MeStmt *meStmt = nullptr;
+  PUIdx puIdx = kInvalidPuIdx;
+  uint64 frequency = 0;
+  bool valid = true;
+  MapleVector<uint32> hashCandidate;
+  MapleUnorderedMap<StIdx, DefUsePositions> symbolDefUse;
+  MapleUnorderedMap<PregIdx, DefUsePositions> regDefUse;
+  MapleVector<uint32> locationsJumpFrom;
+  MapleVector<uint32> locationsJumpTo;
+};
+
+class StmtInfoHash {
+ public:
+  size_t operator()(const StmtInfo &stmtInfo) const {
+    auto hashCode = stmtInfo.GetHashCandidateAt(0);
+    for (auto i = 1; i < stmtInfo.GetHashCandidateSize(); ++i) {
+      hashCode ^= stmtInfo.GetHashCandidateAt(i);
+    }
+    return hashCode;
+  }
+};
+}
+#endif  // MAPLE_IPA_INCLUDE_STMT_IDENTIFY_H
diff --git a/src/mapleall/maple_ipa/src/ipa_clone.cpp b/src/mapleall/maple_ipa/src/ipa_clone.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f164000454a4a42c418812cf1115a872f0dfed4e
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/ipa_clone.cpp
@@ -0,0 +1,630 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ipa_clone.h"
+#include "clone.h"
+#include "mir_symbol.h"
+#include "func_desc.h"
+#include "inline.h"
+
+// For some funcs, when we can ignore their return-values, we clone a new func of
+// them without return-values. We configure a list to save these funcs and clone
+// at the very beginning so that clones can also enjoy the optimizations after.
+// This mainly contains the clone of funcbody(include labels, symbols, arguments,
+// etc.) and the update of the new func infomation.
+namespace maple {
+void IpaClone::InitParams() {
+  // the option for the clone parameter
+  if (Options::optForSize) {
+    numOfCloneVersions = 2;
+    numOfImpExprLowBound = 2;
+    numOfImpExprHighBound = 5;
+    numOfCallSiteLowBound = 2;
+    numOfCallSiteUpBound = 10;
+    numOfConstpropValue = 2;
+  } else {
+    numOfCloneVersions = Options::numOfCloneVersions;
+    numOfImpExprLowBound = Options::numOfImpExprLowBound;
+    numOfImpExprHighBound = Options::numOfImpExprHighBound;
+    numOfCallSiteLowBound = Options::numOfCallSiteLowBound;
+    numOfCallSiteUpBound = Options::numOfCallSiteUpBound;
+    numOfConstpropValue = Options::numOfConstpropValue;
+  }
+}
+
+bool IpaClone::IsBrCondOrIf(Opcode op) const {
+  return op == OP_brfalse || op == OP_brtrue || op == OP_if;
+}
+
+MIRSymbol *IpaClone::IpaCloneLocalSymbol(const MIRSymbol &oldSym, const MIRFunction &newFunc) {
+  MemPool *newMP = newFunc.GetDataMemPool();
+  MIRSymbol *newSym = newMP->New<MIRSymbol>(oldSym);
+  if (oldSym.GetSKind() == kStConst) {
+    newSym->SetKonst(oldSym.GetKonst()->Clone(*newMP));
+  } else if (oldSym.GetSKind() == kStPreg) {
+    newSym->SetPreg(newMP->New<MIRPreg>(*oldSym.GetPreg()));
+  } else if (oldSym.GetSKind() == kStFunc) {
+    CHECK_FATAL(false, "%s has unexpected local func symbol", oldSym.GetName().c_str());
+  }
+  return newSym;
+}
+
+void IpaClone::IpaCloneSymbols(MIRFunction &newFunc, const MIRFunction &oldFunc) {
+  size_t symTabSize = oldFunc.GetSymbolTabSize();
+  for (size_t i = oldFunc.GetFormalCount() + 1; i < symTabSize; ++i) {
+    MIRSymbol *sym = oldFunc.GetSymbolTabItem(static_cast<uint32>(i));
+    if (sym == nullptr) {
+      continue;
+    }
+    MIRSymbol *newSym = IpaCloneLocalSymbol(*sym, newFunc);
+    if (!newFunc.GetSymTab()->AddStOutside(newSym)) {
+      CHECK_FATAL(false, "%s already existed in func %s", sym->GetName().c_str(), newFunc.GetName().c_str());
+    }
+  }
+}
+
+void IpaClone::IpaCloneLabels(MIRFunction &newFunc, const MIRFunction &oldFunc) {
+  size_t labelTabSize = oldFunc.GetLabelTab()->GetLabelTableSize();
+  for (size_t i = 1; i < labelTabSize; ++i) {
+    GStrIdx strIdx = oldFunc.GetLabelTab()->GetSymbolFromStIdx(static_cast<uint32>(i));
+    (void)newFunc.GetLabelTab()->AddLabel(strIdx);
+  }
+}
+
+void IpaClone::IpaClonePregTable(MIRFunction &newFunc, const MIRFunction &oldFunc) {
+  newFunc.AllocPregTab();
+  size_t pregTableSize = oldFunc.GetPregTab()->Size();
+  MIRPregTable *newPregTable = newFunc.GetPregTab();
+  for (size_t i = 0; i < pregTableSize; ++i) {
+    MIRPreg *temp = const_cast<MIRPreg*>(oldFunc.GetPregTab()->GetPregTableItem(static_cast<uint32>(i)));
+    if (temp != nullptr) {
+      PregIdx id = newPregTable->CreatePreg(temp->GetPrimType(), temp->GetMIRType());
+      MIRPreg *newPreg = newPregTable->PregFromPregIdx(id);
+      if (newPreg == nullptr || newPreg->GetPregNo() != temp->GetPregNo()) {
+        ASSERT(false, "The cloned pregNo isn't consistent");
+      }
+    }
+  }
+}
+
+// IpaClone a function
+MIRFunction *IpaClone::IpaCloneFunction(MIRFunction &originalFunction, const std::string &fullName) const {
+  MapleAllocator cgAlloc(originalFunction.GetDataMemPool());
+  ArgVector argument(cgAlloc.Adapter());
+  IpaCloneArgument(originalFunction, argument);
+  MIRType *retType = originalFunction.GetReturnType();
+  MIRFunction *newFunc =
+      mirBuilder.CreateFunction(fullName, *retType, argument, false, originalFunction.GetBody() != nullptr);
+  CHECK_FATAL(newFunc != nullptr, "create cloned function failed");
+  mirBuilder.GetMirModule().AddFunction(newFunc);
+  newFunc->SetFlag(originalFunction.GetFlag());
+  newFunc->SetSrcPosition(originalFunction.GetSrcPosition());
+  newFunc->SetFuncAttrs(originalFunction.GetFuncAttrs());
+  newFunc->SetBaseClassFuncNames(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName));
+  newFunc->GetFuncSymbol()->SetAppearsInCode(true);
+  newFunc->SetPuidxOrigin(newFunc->GetPuidx());
+  if (originalFunction.GetBody() != nullptr) {
+    CopyFuncInfo(originalFunction, *newFunc);
+    newFunc->SetBody(
+        originalFunction.GetBody()->CloneTree(newFunc->GetCodeMempoolAllocator()));
+    IpaCloneSymbols(*newFunc, originalFunction);
+    IpaCloneLabels(*newFunc, originalFunction);
+    IpaClonePregTable(*newFunc, originalFunction);
+  }
+  newFunc->SetFuncDesc(originalFunction.GetFuncDesc());
+  // All the cloned functions cannot be accessed from other transform unit.
+  newFunc->SetAttr(FUNCATTR_static);
+  return newFunc;
+}
+
+MIRFunction *IpaClone::IpaCloneFunctionWithFreq(MIRFunction &originalFunction,
+                                                const std::string &fullName, uint64_t callSiteFreq) const {
+  MapleAllocator cgAlloc(originalFunction.GetDataMemPool());
+  ArgVector argument(cgAlloc.Adapter());
+  IpaCloneArgument(originalFunction, argument);
+  MIRType *retType = originalFunction.GetReturnType();
+  MIRFunction *newFunc =
+      mirBuilder.CreateFunction(fullName, *retType, argument, false, originalFunction.GetBody() != nullptr);
+  CHECK_FATAL(newFunc != nullptr, "create cloned function failed");
+  mirBuilder.GetMirModule().AddFunction(newFunc);
+  newFunc->SetFlag(originalFunction.GetFlag());
+  newFunc->SetSrcPosition(originalFunction.GetSrcPosition());
+  newFunc->SetFuncAttrs(originalFunction.GetFuncAttrs());
+  newFunc->SetBaseClassFuncNames(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName));
+  newFunc->GetFuncSymbol()->SetAppearsInCode(true);
+  newFunc->SetPuidxOrigin(newFunc->GetPuidx());
+  FuncProfInfo *origProfData = originalFunction.GetFuncProfData();
+  auto *moduleMp = mirBuilder.GetMirModule().GetMemPool();
+  FuncProfInfo *newProfData = moduleMp->New<FuncProfInfo>(&mirBuilder.GetMirModule().GetMPAllocator(),
+                                  newFunc->GetPuidx(), 0, 0); // skip checksum information
+  newFunc->SetFuncProfData(newProfData);
+  newProfData->SetFuncFrequency(callSiteFreq);
+  newProfData->SetFuncRealFrequency(callSiteFreq);
+  // original function need to update frequency by real entry value
+  // update real left frequency
+  origProfData->SetFuncRealFrequency(origProfData->GetFuncRealFrequency() - callSiteFreq);
+  if (originalFunction.GetBody() != nullptr) {
+    CopyFuncInfo(originalFunction, *newFunc);
+    BlockNode *newbody = originalFunction.GetBody()->CloneTreeWithFreqs(newFunc->GetCodeMempoolAllocator(),
+        newProfData->GetStmtFreqs(), origProfData->GetStmtFreqs(),
+        callSiteFreq, /* numer */
+        origProfData->GetFuncFrequency(), /* denom */
+        static_cast<uint32>(kKeepOrigFreq) | static_cast<uint32>(kUpdateFreqbyScale));
+    newFunc->SetBody(newbody);
+    IpaCloneSymbols(*newFunc, originalFunction);
+    IpaCloneLabels(*newFunc, originalFunction);
+    IpaClonePregTable(*newFunc, originalFunction);
+  }
+  newFunc->SetFuncDesc(originalFunction.GetFuncDesc());
+  // All the cloned functions cannot be accessed from other transform unit.
+  newFunc->SetAttr(FUNCATTR_static);
+  return newFunc;
+}
+
+void IpaClone::IpaCloneArgument(MIRFunction &originalFunction, ArgVector &argument) const {
+  for (size_t i = 0; i < originalFunction.GetFormalCount(); ++i) {
+    auto &formalName = originalFunction.GetFormalName(i);
+    argument.emplace_back(ArgPair(formalName, originalFunction.GetNthParamType(i)));
+  }
+}
+
+void IpaClone::CopyFuncInfo(MIRFunction &originalFunction, MIRFunction &newFunc) const {
+  const auto &funcNameIdx = newFunc.GetBaseFuncNameStrIdx();
+  const auto &fullNameIdx = newFunc.GetNameStrIdx();
+  const auto &classNameIdx = newFunc.GetBaseClassNameStrIdx();
+  const static auto &metaFullNameIdx = mirBuilder.GetOrCreateStringIndex(kFullNameStr);
+  const static auto &metaClassNameIdx = mirBuilder.GetOrCreateStringIndex(kClassNameStr);
+  const static auto &metaFuncNameIdx = mirBuilder.GetOrCreateStringIndex(kFuncNameStr);
+  MIRInfoVector &fnInfo = originalFunction.GetInfoVector();
+  const MapleVector<bool> &infoIsString = originalFunction.InfoIsString();
+  size_t size = fnInfo.size();
+  for (size_t i = 0; i < size; ++i) {
+    if (fnInfo[i].first == metaFullNameIdx) {
+      newFunc.PushbackMIRInfo(std::pair<GStrIdx, uint32>(fnInfo[i].first, fullNameIdx));
+    } else if (fnInfo[i].first == metaFuncNameIdx) {
+      newFunc.PushbackMIRInfo(std::pair<GStrIdx, uint32>(fnInfo[i].first, funcNameIdx));
+    } else if (fnInfo[i].first == metaClassNameIdx) {
+      newFunc.PushbackMIRInfo(std::pair<GStrIdx, uint32>(fnInfo[i].first, classNameIdx));
+    } else {
+      newFunc.PushbackMIRInfo(std::pair<GStrIdx, uint32>(fnInfo[i].first, fnInfo[i].second));
+    }
+    newFunc.PushbackIsString(infoIsString[i]);
+  }
+}
+
+bool IpaClone::CheckCostModel(uint32 paramIndex, std::vector<int64_t> &calleeValue,
+                              std::vector<ImpExpr> &result) const {
+  uint32 impSize = 0;
+  for (auto impExpr : result) {
+    if (curFunc->GetStmtNodeFromMeId(impExpr.GetStmtId()) == nullptr) {
+      continue;
+    }
+    if (curFunc->GetStmtNodeFromMeId(impExpr.GetStmtId())->IsCondBr() ||
+        curFunc->GetStmtNodeFromMeId(impExpr.GetStmtId())->GetOpCode() == OP_if) {
+      ++impSize;
+    }
+  }
+  if (impSize >= numOfImpExprHighBound) {
+    return true;
+  }
+  auto &calleeInfo = mirModule->GetCalleeParamAboutInt();
+  CalleePair keyPair(curFunc->GetPuidx(), paramIndex);
+  uint32 callSiteSize = 0;
+  for (auto &value : calleeValue) {
+    callSiteSize += static_cast<uint32>(calleeInfo[keyPair][value].size());
+  }
+  if (callSiteSize >= numOfCallSiteUpBound) {
+    return true;
+  }
+  if (callSiteSize < numOfCallSiteLowBound || impSize < numOfImpExprLowBound) {
+    return false;
+  }
+  // Later: we will consider the body size
+  return true;
+}
+
+void IpaClone::ReplaceIfCondtion(MIRFunction *newFunc, std::vector<ImpExpr> &result, uint64_t res) const {
+  ASSERT(newFunc != nullptr, "null ptr check");
+  MemPool *currentFunMp = newFunc->GetCodeMempool();
+  auto elemPrimType = PTY_u8;
+  MIRType *type = GlobalTables::GetTypeTable().GetPrimType(elemPrimType);
+  MIRConst *constVal = nullptr;
+  for (int32 index = static_cast<int32>(result.size()) - 1; index >= 0; --index) {
+    uint32 stmtId = result[static_cast<uint32>(index)].GetStmtId();
+    StmtNode *newReplace = newFunc->GetStmtNodeFromMeId(stmtId);
+    ASSERT(newReplace != nullptr, "null ptr check");
+    if (newReplace->GetOpCode() == OP_switch) {
+      continue;
+    }
+    if (newReplace->GetOpCode() != OP_if && newReplace->GetOpCode() != OP_brtrue &&
+        newReplace->GetOpCode() != OP_brfalse) {
+      ASSERT(false, "ERROR: cann't find the replace statement");
+    }
+    IfStmtNode *ifStmtNode = static_cast<IfStmtNode*>(newReplace);
+    constVal = GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(res & 0x1), *type);
+    res >>= 1;
+    ConstvalNode *constNode = currentFunMp->New<ConstvalNode>(constVal->GetType().GetPrimType(), constVal);
+    ifStmtNode->SetOpnd(constNode, 0);
+  }
+  return;
+}
+
+void IpaClone::RemoveSwitchCase(MIRFunction &newFunc, SwitchNode &switchStmt, std::vector<int64_t> &calleeValue) const {
+  auto iter = switchStmt.GetSwitchTable().begin();
+  while (iter < switchStmt.GetSwitchTable().end()) {
+    bool isNeed = false;
+    for (size_t j = 0; j < calleeValue.size(); ++j) {
+      int64_t value = calleeValue[j];
+      if (switchStmt.GetSwitchOpnd()->GetOpCode() == OP_neg) {
+        value = -value;
+      }
+      if (value == iter->first) {
+        isNeed = true;
+        break;
+      }
+    }
+    if (!isNeed) {
+      iter = switchStmt.GetSwitchTable().erase(iter);
+    } else {
+      ++iter;
+    }
+  }
+  if (switchStmt.GetSwitchTable().size() == calleeValue.size()) {
+    StmtNode *stmt = newFunc.GetBody()->GetFirst();
+    for (; stmt != newFunc.GetBody()->GetLast(); stmt = stmt->GetNext()) {
+      if (stmt->GetOpCode() == OP_label &&
+          static_cast<LabelNode*>(stmt)->GetLabelIdx() == switchStmt.GetDefaultLabel()) {
+        switchStmt.SetDefaultLabel(0);
+        newFunc.GetBody()->RemoveStmt(stmt);
+        break;
+      }
+    }
+  }
+}
+
+void IpaClone::RemoveUnneedSwitchCase(MIRFunction &newFunc, std::vector<ImpExpr> &result,
+                                      std::vector<int64_t> &calleeValue) const {
+  for (size_t i = 0; i < result.size(); ++i) {
+    uint32 stmtId = result[i].GetStmtId();
+    StmtNode *newSwitch = newFunc.GetStmtNodeFromMeId(stmtId);
+    if (newSwitch->GetOpCode() != OP_switch) {
+      continue;
+    }
+    SwitchNode *switchStmtNode = static_cast<SwitchNode*>(newSwitch);
+    RemoveSwitchCase(newFunc, *switchStmtNode, calleeValue);
+  }
+}
+
+void IpaClone::ModifyParameterSideEffect(MIRFunction *newFunc, uint32 paramIndex) const {
+  ASSERT(newFunc != nullptr, "null ptr check");
+  auto &desc = newFunc->GetFuncDesc();
+  if (paramIndex >= kMaxParamCount) {
+    return;
+  }
+  for (size_t idx = paramIndex; idx < kMaxParamCount - 1; ++idx) {
+    desc.SetParamInfo(idx, desc.GetParamInfo(idx + 1));
+  }
+  desc.SetParamInfo(kMaxParamCount - 1, PI::kUnknown);
+  return;
+}
+
+void IpaClone::RemoveUnneedParameter(MIRFunction *newFunc, uint32 paramIndex, int64_t value) const {
+  ASSERT(newFunc != nullptr, "null ptr check");
+  if (newFunc->GetBody() != nullptr) {
+    MemPool *newFuncMP = newFunc->GetCodeMempool();
+    // Create the const value
+    MIRType *type = GlobalTables::GetTypeTable().GetPrimType(PTY_i64);
+    MIRIntConst *constVal = GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<uint64_t>(value), *type);
+    ConstvalNode *constNode = newFuncMP->New<ConstvalNode>(constVal->GetType().GetPrimType(), constVal);
+    // Create the dassign statement.
+    DassignNode *dass = newFuncMP->New<DassignNode>();
+    MIRSymbol *sym = newFunc->GetFormal(paramIndex);
+    dass->SetStIdx(sym->GetStIdx());
+    dass->SetOpnd(constNode, 0);
+    dass->SetFieldID(0);
+    // Insert this dassign statment to the body.
+    newFunc->GetBody()->InsertFirst(dass);
+    // Remove the unneed function parameter.
+    auto &formalVec = newFunc->GetFormalDefVec();
+    for (size_t i = paramIndex; i < newFunc->GetFormalCount() - 1; ++i) {
+      formalVec[i] = formalVec[i + 1];
+    }
+    formalVec.resize(formalVec.size() - 1);
+    sym->SetStorageClass(kScAuto);
+    // fix the paramTypelist && paramTypeAttrs.
+    MIRFuncType *funcType = newFunc->GetMIRFuncType();
+    std::vector<TyIdx> paramTypeList;
+    std::vector<TypeAttrs> paramTypeAttrsList;
+    for (size_t i = 0; i < newFunc->GetParamTypes().size(); i++) {
+      if (i != paramIndex) {
+        paramTypeList.push_back(funcType->GetParamTypeList()[i]);
+        paramTypeAttrsList.push_back(funcType->GetParamAttrsList()[i]);
+      }
+    }
+    MIRSymbol *funcSymbol = newFunc->GetFuncSymbol();
+    ASSERT(funcSymbol != nullptr, "null ptr check");
+    funcSymbol->SetTyIdx(GlobalTables::GetTypeTable().GetOrCreateFunctionType(funcType->GetRetTyIdx(), paramTypeList,
+        paramTypeAttrsList, funcType->IsVarargs(), funcType->GetRetAttrs())->GetTypeIndex());
+    auto *newFuncType = static_cast<MIRFuncType*>(funcSymbol->GetType());
+    newFunc->SetMIRFuncType(newFuncType);
+    // Modify the parameter sideeffect
+    ModifyParameterSideEffect(newFunc, paramIndex);
+  }
+  return;
+}
+
+// Clone Function steps:
+// 1. clone Function && replace the condtion
+// 2. modify the callsite and update the call_graph
+void IpaClone::DecideCloneFunction(std::vector<ImpExpr> &result, uint32 paramIndex,
+                                   std::map<uint32, std::vector<int64_t>> &evalMap) const {
+  uint32 puidx = curFunc->GetPuidx();
+  CalleePair keyPair(puidx, paramIndex);
+  auto &calleeInfo = mirModule->GetCalleeParamAboutInt();
+  uint32 index = 0;
+  for (auto &eval : std::as_const(evalMap)) {
+    uint64_t evalValue = eval.first;
+    std::vector<int64_t> calleeValue = eval.second;
+    if (!CheckCostModel(paramIndex, calleeValue, result)) {
+      continue;
+    }
+    if (index > numOfCloneVersions) {
+      break;
+    }
+    std::string newFuncName = curFunc->GetName() + ".clone." + std::to_string(index++);
+    InlineTransformer::ConvertPStaticToFStatic(*curFunc);
+    MIRFunction *newFunc = nullptr;
+    if (Options::profileUse && curFunc->GetFuncProfData()) {
+      uint64_t clonedSiteFreqs = 0;
+      for (auto &value: calleeValue) {
+        for (auto &callSite : calleeInfo[keyPair][value]) {
+          MIRFunction *callerFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callSite.GetPuidx());
+          uint32 stmtId = callSite.GetStmtId();
+          CallNode *oldCallNode = static_cast<CallNode*>(callerFunc->GetStmtNodeFromMeId(stmtId));
+          if (oldCallNode == nullptr) {
+            continue;
+          }
+          uint64_t callsiteFreq = callerFunc->GetFuncProfData()->GetStmtFreq(stmtId);
+          clonedSiteFreqs += callsiteFreq;
+        }
+      }
+      newFunc = IpaCloneFunctionWithFreq(*curFunc, newFuncName, clonedSiteFreqs);
+    } else {
+      newFunc = IpaCloneFunction(*curFunc, newFuncName);
+    }
+    ReplaceIfCondtion(newFunc, result, evalValue);
+    RemoveUnneedSwitchCase(*newFunc, result, calleeValue);
+    for (auto &value: calleeValue) {
+      bool optCallerParam = false;
+      if (calleeValue.size() == 1) {
+        optCallerParam = true;
+        // If the callleeValue just have one value, it means we can add a dassign stmt.
+        RemoveUnneedParameter(newFunc, paramIndex, value);
+      }
+      for (auto &callSite : calleeInfo[keyPair][value]) {
+        MIRFunction *callerFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callSite.GetPuidx());
+        if (callerFunc == nullptr) {
+          CHECK_FATAL(callSite.GetPuidx() != 0, "something wrong in calleeInfo?");
+          continue;  // func has been removed from funcTable by CallGraph, see RemoveFileStaticRootNodes for details
+        }
+        uint32 stmtId = callSite.GetStmtId();
+        CallNode *oldCallNode = static_cast<CallNode*>(callerFunc->GetStmtNodeFromMeId(stmtId));
+        if (oldCallNode == nullptr) {
+          continue;
+        }
+        oldCallNode->SetPUIdx(newFunc->GetPuidx());
+        if (optCallerParam) {
+          for (size_t i = paramIndex; i < oldCallNode->GetNopndSize() - 1; ++i) {
+            oldCallNode->SetNOpndAt(i, oldCallNode->GetNopndAt(i + 1));
+          }
+          oldCallNode->GetNopnd().resize(static_cast<uint8>(oldCallNode->GetNumOpnds() - 1));
+          oldCallNode->SetNumOpnds(static_cast<uint8>(oldCallNode->GetNumOpnds() - 1));
+        }
+      }
+    }
+  }
+}
+
+void IpaClone::ComupteValue(const IntVal& value, const IntVal& paramValue,
+                            const CompareNode &cond, uint64_t &bitRes) const {
+  if (cond.GetOpCode() == OP_gt) {
+    bitRes = static_cast<uint64_t>(value > paramValue) | (bitRes << 1);
+  } else if (cond.GetOpCode() == OP_eq) {
+    bitRes = static_cast<uint64_t>(value == paramValue) | (bitRes << 1);
+  } else if (cond.GetOpCode() == OP_lt) {
+    bitRes = static_cast<uint64_t>(value < paramValue) | (bitRes << 1);
+  } else if (cond.GetOpCode() == OP_ge) {
+    bitRes = static_cast<uint64_t>(value >= paramValue) | (bitRes << 1);
+  } else if (cond.GetOpCode() == OP_le) {
+    bitRes = static_cast<uint64_t>(value <= paramValue) | (bitRes << 1);
+  } else if (cond.GetOpCode() == OP_ne) {
+    bitRes = static_cast<uint64_t>(value != paramValue) | (bitRes << 1);
+  }
+}
+
+void IpaClone::EvalCompareResult(std::vector<ImpExpr> &result, std::map<uint32, std::vector<int64_t>> &evalMap,
+                                 std::map<int64_t, std::vector<CallerSummary>> &summary, uint32 index) const {
+  for (auto &it: std::as_const(summary)) {
+    int64 value = it.first;
+    uint64_t bitRes = 0;
+    bool runFlag = false;
+    for (auto &expr : result) {
+      StmtNode *stmt  = curFunc->GetStmtNodeFromMeId(expr.GetStmtId());
+      if (stmt == nullptr || expr.GetParamIndex() != index) {
+        continue;
+      }
+      runFlag = true;
+      if (stmt->GetOpCode() == OP_switch) {
+        continue;
+      }
+      IfStmtNode* ifStmt = static_cast<IfStmtNode*>(stmt);
+      CompareNode *cond = static_cast<CompareNode*>(ifStmt->Opnd(0));
+      if (cond->Opnd(0)->GetOpCode() == OP_intrinsicop &&
+          static_cast<IntrinsicopNode*>(cond->Opnd(0))->GetIntrinsic() == INTRN_C___builtin_expect) {
+        cond = static_cast<CompareNode*>(static_cast<IntrinsicopNode*>(cond->Opnd(0))->Opnd(0));
+      }
+      PrimType primType = cond->GetOpndType();
+      BaseNode *opnd1 = cond->Opnd(0)->GetOpCode() == OP_constval ? cond->Opnd(0) : cond->Opnd(1);
+      ConstvalNode *constNode = static_cast<ConstvalNode*>(opnd1);
+      MIRIntConst *constVal = safe_cast<MIRIntConst>(constNode->GetConstVal());
+      ASSERT(constVal, "invalid const type");
+      if (primType != PTY_i64 && primType != PTY_u64 && primType != PTY_i32 && primType != PTY_u32 &&
+          primType != PTY_i16 && primType != PTY_u16 && primType != PTY_i8 && primType != PTY_u8) {
+        runFlag = false;
+        break;
+      }
+      IntVal paramValue = { constVal->GetValue(), primType };
+      IntVal newValue = { static_cast<uint64>(value), primType };
+      ComupteValue(newValue, paramValue, *cond, bitRes);
+    }
+    if (runFlag) {
+      (void)evalMap[bitRes].emplace_back(value);
+    }
+  }
+  return;
+}
+
+void IpaClone::EvalImportantExpression(MIRFunction *func, std::vector<ImpExpr> &result) {
+  int paramSize = static_cast<int>(func->GetFormalCount());
+  uint32 puidx = func->GetPuidx();
+  auto &calleeInfo = mirModule->GetCalleeParamAboutInt();
+  for (int index = 0; index < paramSize; ++index) {
+    CalleePair keyPair(puidx, index);
+    if (calleeInfo.find(keyPair) == calleeInfo.end()) {
+      continue;
+    }
+    std::map<uint32, std::vector<int64_t > > evalMap;
+    EvalCompareResult(result, evalMap, calleeInfo[keyPair], static_cast<uint32>(index));
+    // Later: Now we just the consider one parameter important expression
+    std::vector<ImpExpr> filterRes;
+    if (!evalMap.empty()) {
+      bool hasBrExpr = false;
+      for (auto &expr : result) {
+        if (expr.GetParamIndex() == static_cast<uint32>(index) &&
+            func->GetStmtNodeFromMeId(expr.GetStmtId()) != nullptr) {
+          hasBrExpr = IsBrCondOrIf(func->GetStmtNodeFromMeId(expr.GetStmtId())->GetOpCode()) || hasBrExpr;
+          (void)filterRes.emplace_back(expr);
+          // Resolve most numOfImpExprUpper important expression
+          if (filterRes.size() > kNumOfImpExprUpper) {
+            break;
+          }
+        }
+      }
+      if (hasBrExpr) {
+        DecideCloneFunction(filterRes, static_cast<uint32>(index), evalMap);
+        return;
+      }
+    }
+  }
+}
+
+void IpaClone::CloneNoImportantExpressFunction(MIRFunction *func, uint32 paramIndex) const {
+  uint32 puidx = curFunc->GetPuidx();
+  CalleePair keyPair(puidx, paramIndex);
+  auto &calleeInfo = mirModule->GetCalleeParamAboutInt();
+  std::string newFuncName = func->GetName() + ".constprop." + std::to_string(paramIndex);
+  InlineTransformer::ConvertPStaticToFStatic(*func);
+  MIRFunction *newFunc = nullptr;
+  if (Options::profileUse && func->GetFuncProfData()) {
+    uint64_t clonedSiteFreqs = 0;
+    int64_t value = calleeInfo[keyPair].cbegin()->first;
+    for (auto &callSite : std::as_const(calleeInfo[keyPair][value])) {
+      MIRFunction *callerFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callSite.GetPuidx());
+      uint32 stmtId = callSite.GetStmtId();
+      CallNode *oldCallNode = static_cast<CallNode*>(callerFunc->GetStmtNodeFromMeId(stmtId));
+      if (oldCallNode == nullptr) {
+        continue;
+      }
+      uint64_t callsiteFreq = callerFunc->GetFuncProfData()->GetStmtFreq(stmtId);
+      clonedSiteFreqs += callsiteFreq;
+    }
+    newFunc = IpaCloneFunctionWithFreq(*func, newFuncName, clonedSiteFreqs);
+  } else {
+    newFunc = IpaCloneFunction(*func, newFuncName);
+  }
+  int64_t value = calleeInfo[keyPair].begin()->first;
+  RemoveUnneedParameter(newFunc, paramIndex, value);
+  for (auto &callSite : calleeInfo[keyPair][value]) {
+    MIRFunction *callerFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callSite.GetPuidx());
+    if (callerFunc == nullptr) {
+      CHECK_FATAL(callSite.GetPuidx() != 0, "something wrong in calleeInfo?");
+      continue;  // func has been removed from funcTable by CallGraph, see RemoveFileStaticRootNodes for details
+    }
+    uint32 stmtId = callSite.GetStmtId();
+    CallNode *oldCallNode = static_cast<CallNode*>(callerFunc->GetStmtNodeFromMeId(stmtId));
+    if (oldCallNode == nullptr) {
+      continue;
+    }
+    oldCallNode->SetPUIdx(newFunc->GetPuidx());
+    for (size_t i = paramIndex; i < oldCallNode->GetNopndSize() - 1; ++i) {
+      oldCallNode->SetNOpndAt(i, oldCallNode->GetNopndAt(i + 1));
+    }
+    oldCallNode->GetNopnd().resize(static_cast<uint8>(oldCallNode->GetNumOpnds() - 1));
+    oldCallNode->SetNumOpnds(static_cast<uint8>(oldCallNode->GetNumOpnds() - 1));
+  }
+}
+
+bool IpaClone::CheckImportantExprHasBr(const std::vector<ImpExpr> &exprVec) const {
+  for (auto expr : exprVec) {
+    if (curFunc->GetStmtNodeFromMeId(expr.GetStmtId()) != nullptr &&
+        IsBrCondOrIf(curFunc->GetStmtNodeFromMeId(expr.GetStmtId())->GetOpCode())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void IpaClone::DoIpaClone() {
+  InitParams();
+  for (uint32 i = 0; i < GlobalTables::GetFunctionTable().GetFuncTable().size(); ++i) {
+    MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(i);
+    if (func == nullptr) {
+      continue;
+    }
+    if (Options::stackProtectorStrong && func->GetMayWriteToAddrofStack()) {
+      continue;
+    }
+    curFunc = func;
+    std::map<PUIdx, std::vector<ImpExpr>> &funcImportantExpr = mirModule->GetFuncImportantExpr();
+    if (funcImportantExpr.find(func->GetPuidx()) != funcImportantExpr.end() &&
+        CheckImportantExprHasBr(funcImportantExpr[func->GetPuidx()])) {
+      EvalImportantExpression(func, funcImportantExpr[func->GetPuidx()]);
+    } else {
+      auto &calleeInfo = mirModule->GetCalleeParamAboutInt();
+      for (uint index = 0; index < func->GetFormalCount(); ++index) {
+        CalleePair keyPair(func->GetPuidx(), index);
+        if (calleeInfo.find(keyPair) != calleeInfo.end() && calleeInfo[keyPair].size() == 1 &&
+            (calleeInfo[keyPair].begin())->second.size() > numOfConstpropValue) {
+          CloneNoImportantExpressFunction(func, index);
+          break;
+        }
+      }
+    }
+  }
+}
+
+void M2MIpaClone::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MCallGraph>();
+  aDep.PreservedAllExcept<M2MCallGraph>();
+}
+
+bool M2MIpaClone::PhaseRun(maple::MIRModule &m) {
+  maple::MIRBuilder dexMirBuilder(&m);
+  cl = GetPhaseAllocator()->New<IpaClone>(&m, GetPhaseMemPool(), dexMirBuilder);
+  cl->DoIpaClone();
+  GetAnalysisInfoHook()->ForceEraseAnalysisPhase(m.GetUniqueID(), &M2MCallGraph::id);
+  (void)GetAnalysisInfoHook()->ForceRunAnalysisPhase<MapleModulePhase, MIRModule>(&M2MCallGraph::id, m);
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ipa/src/ipa_collect.cpp b/src/mapleall/maple_ipa/src/ipa_collect.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4340bdc50564cd570ce31f766d127163b931ec43
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/ipa_collect.cpp
@@ -0,0 +1,384 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ipa_collect.h"
+#include "call_graph.h"
+#include "inline_analyzer.h"
+#include "maple_phase.h"
+#include "option.h"
+#include "string_utils.h"
+#include "inline_summary.h"
+#include "me_stack_protect.h"
+#include "ipa_phase_manager.h"
+
+namespace maple {
+void CollectIpaInfo::UpdateCaleeParaAboutFloat(MeStmt &meStmt, float paramValue, uint32 index, CallerSummary &summary) {
+  auto *callMeStmt = static_cast<CallMeStmt*>(&meStmt);
+  MIRFunction &called = callMeStmt->GetTargetFunction();
+  CalleePair calleeKey(called.GetPuidx(), index);
+  std::map<CalleePair, std::map<float, std::vector<CallerSummary>>> &calleeParamAboutFloat =
+      module.GetCalleeParamAboutFloat();
+  calleeParamAboutFloat[calleeKey][paramValue].emplace_back(summary);
+}
+
+void CollectIpaInfo::UpdateCaleeParaAboutDouble(MeStmt &meStmt, double paramValue, uint32 index,
+                                                CallerSummary &summary) {
+  auto *callMeStmt = static_cast<CallMeStmt*>(&meStmt);
+  MIRFunction &called = callMeStmt->GetTargetFunction();
+  CalleePair calleeKey(called.GetPuidx(), index);
+  std::map<CalleePair, std::map<double, std::vector<CallerSummary>>> &calleeParamAboutDouble =
+      module.GetCalleeParamAboutDouble();
+  calleeParamAboutDouble[calleeKey][paramValue].emplace_back(summary);
+}
+
+void CollectIpaInfo::UpdateCaleeParaAboutInt(MeStmt &meStmt, int64_t paramValue, uint32 index, CallerSummary &summary) {
+  auto *callMeStmt = static_cast<CallMeStmt*>(&meStmt);
+  MIRFunction &called = callMeStmt->GetTargetFunction();
+  CalleePair calleeKey(called.GetPuidx(), index);
+  std::map<CalleePair, std::map<int64_t, std::vector<CallerSummary>>> &calleeParamAboutInt =
+      module.GetCalleeParamAboutInt();
+  calleeParamAboutInt[calleeKey][paramValue].emplace_back(summary);
+}
+
+bool CollectIpaInfo::IsConstKindValue(MeExpr *expr) const {
+  if (expr->GetMeOp() != kMeOpConst) {
+    return false;
+  }
+  MIRConst *constV = static_cast<ConstMeExpr*>(expr)->GetConstVal();
+  return constV->GetKind() == kConstInt || constV->GetKind() == kConstFloatConst ||
+         constV->GetKind() == kConstDoubleConst;
+}
+
+bool CollectIpaInfo::CheckImpExprStmt(const MeStmt &meStmt) const {
+  auto *node = meStmt.GetOpnd(0);
+  return IsConstKindValue(node->GetOpnd(0)) || IsConstKindValue(node->GetOpnd(1));
+}
+
+bool CollectIpaInfo::IsParameterOrUseParameter(const VarMeExpr *varExpr, uint32 &index) const {
+  OriginalSt *sym = varExpr->GetOst();
+  MIRSymbol *paramSym = sym->GetMIRSymbol();
+  if (sym->IsFormal() && sym->GetIndirectLev() == 0 && varExpr->IsDefByNo() && !varExpr->IsVolatile()) {
+    for (uint32 i = 0; i < curFunc->GetFormalCount(); i++) {
+      MIRSymbol *formalSt = curFunc->GetFormal(i);
+      if (formalSt != nullptr && paramSym->GetNameStrIdx() == formalSt->GetNameStrIdx()) {
+        index = i;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// Now we just resolve two cases, we will collect more case in the future.
+bool CollectIpaInfo::CollectBrImportantExpression(const MeStmt &meStmt, uint32 &index) const {
+  auto *opnd = meStmt.GetOpnd(0);
+  if (opnd->GetOp() == OP_eq || opnd->GetOp() == OP_ne || opnd->GetOp() == OP_gt ||
+      opnd->GetOp() == OP_ge || opnd->GetOp() == OP_lt || opnd->GetOp() == OP_le) {
+    if (CheckImpExprStmt(meStmt)) {
+      auto subOpnd0 = opnd->GetOpnd(0);
+      auto subOpnd1 = opnd->GetOpnd(1);
+      MeExpr *expr = IsConstKindValue(subOpnd0) ? subOpnd1 : subOpnd0;
+      if (expr->GetOp() == OP_dread) {
+        if (IsParameterOrUseParameter(static_cast<VarMeExpr*>(expr), index)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+bool CollectIpaInfo::CollectSwitchImportantExpression(const MeStmt &meStmt, uint32 &index) const {
+  auto *expr = meStmt.GetOpnd(0);
+  if (expr->GetOp() == OP_neg) {
+    expr = expr->GetOpnd(0);
+  }
+  if (expr->GetOp() == OP_dread) {
+    return IsParameterOrUseParameter(static_cast<VarMeExpr*>(expr), index);
+  }
+  return false;
+}
+
+bool CollectIpaInfo::CollectImportantExpression(const MeStmt &meStmt, uint32 &index) const {
+  if (meStmt.GetOp() == OP_switch) {
+    return CollectSwitchImportantExpression(meStmt, index);
+  } else {
+    return CollectBrImportantExpression(meStmt, index);
+  }
+}
+
+void CollectIpaInfo::TraverseMeStmt(MeStmt &meStmt) {
+  if (Options::doOutline) {
+    TransformStmtToIntegerSeries(meStmt);
+  }
+  Opcode op = meStmt.GetOp();
+  if (meStmt.GetOp() == OP_brfalse || meStmt.GetOp() == OP_brtrue || meStmt.GetOp() == OP_switch) {
+    uint32 index = 0;
+    if (CollectImportantExpression(meStmt, index)) {
+      ImpExpr imp(meStmt.GetMeStmtId(), index);
+      module.GetFuncImportantExpr()[curFunc->GetPuidx()].emplace_back(imp);
+      return;
+    }
+  }
+  if (op != OP_callassigned && op != OP_call) {
+    return;
+  }
+  auto *callMeStmt = static_cast<CallMeStmt*>(&meStmt);
+  MIRFunction &called = callMeStmt->GetTargetFunction();
+  if (called.IsExtern() || called.IsVarargs()) {
+    return;
+  }
+  for (uint32 i = 0; i < callMeStmt->NumMeStmtOpnds() && i < called.GetFormalCount(); ++i) {
+    if (callMeStmt->GetOpnd(i)->GetMeOp() == kMeOpConst) {
+      ConstMeExpr *constExpr = static_cast<ConstMeExpr*>(callMeStmt->GetOpnd(i));
+      MIRSymbol *formalSt = called.GetFormal(i);
+      // Some vargs2 We cann't get the actual type
+      if (formalSt == nullptr) {
+        continue;
+      }
+      if (constExpr->GetConstVal()->GetKind() == kConstInt) {
+        if (IsPrimitiveInteger(formalSt->GetType()->GetPrimType())) {
+          CallerSummary summary(curFunc->GetPuidx(), callMeStmt->GetMeStmtId());
+          auto *intConst = safe_cast<MIRIntConst>(constExpr->GetConstVal());
+          IntVal value = { intConst->GetValue(), formalSt->GetType()->GetPrimType() };
+          UpdateCaleeParaAboutInt(meStmt, value.GetExtValue(), i, summary);
+        }
+      } else if (constExpr->GetConstVal()->GetKind() == kConstFloatConst) {
+        if (IsPrimitiveFloat(formalSt->GetType()->GetPrimType())) {
+          CallerSummary summary(curFunc->GetPuidx(), callMeStmt->GetMeStmtId());
+          auto *floatConst = safe_cast<MIRFloatConst>(constExpr->GetConstVal());
+          UpdateCaleeParaAboutFloat(meStmt, floatConst->GetValue(), i, summary);
+        }
+      } else if (constExpr->GetConstVal()->GetKind() == kConstDoubleConst) {
+        if (formalSt->GetType()->GetPrimType() == PTY_f64) {
+          CallerSummary summary(curFunc->GetPuidx(), callMeStmt->GetMeStmtId());
+          auto *doubleConst = safe_cast<MIRDoubleConst>(constExpr->GetConstVal());
+          UpdateCaleeParaAboutDouble(meStmt, doubleConst->GetValue(), i, summary);
+        }
+      }
+    }
+  }
+}
+
+void CollectIpaInfo::TransformStmtToIntegerSeries(MeStmt &meStmt) {
+  if (!Options::doOutline) {
+    return;
+  }
+  auto stmtInfo = StmtInfo(&meStmt, curFunc->GetPuidx(), allocator);
+  auto integerValue = stmtInfoToIntegerMap[stmtInfo];
+  if (integerValue == 0) {
+    integerValue = stmtInfoToIntegerMap[stmtInfo] = GetCurrNewStmtIndex();
+  }
+  meStmt.SetStmtInfoId(stmtInfoVector.size());
+  (void)integerString.emplace_back(integerValue);
+  (void)stmtInfoVector.emplace_back(std::move(stmtInfo));
+}
+
+void CollectIpaInfo::Perform(MeFunction &func) {
+  // Pre-order traverse the dominance tree, so that each def is traversed
+  // before its use
+  for (auto *bb : func.GetCfg()->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    // traversal on stmt
+    for (auto &meStmt : bb->GetMeStmts()) {
+      TraverseMeStmt(meStmt);
+    }
+  }
+  if (Options::enableGInline) {
+    auto dominancePhase = static_cast<MEDominance*>(
+        dataMap->GetVaildAnalysisPhase(func.GetUniqueID(), &MEDominance::id));
+    Dominance *dom = dominancePhase->GetDomResult();
+    CHECK_NULL_FATAL(dom);
+    Dominance *pdom = dominancePhase->GetPdomResult();
+    CHECK_NULL_FATAL(pdom);
+    auto *meLoop = static_cast<MELoopAnalysis*>(
+        dataMap->GetVaildAnalysisPhase(func.GetUniqueID(), &MELoopAnalysis::id))->GetResult();
+    InlineSummaryCollector collector(module.GetInlineSummaryAlloc(), func, *dom, *pdom, *meLoop);
+    collector.CollectInlineSummary();
+  }
+  if (Options::stackProtectorStrong) {
+    bool mayWriteStack = FuncMayWriteStack(func);
+    if (mayWriteStack) {
+      func.GetMirFunc()->SetMayWriteToAddrofStack();
+    }
+  }
+}
+
+void CollectIpaInfo::CollectDefUsePosition(ScalarMeExpr &scalar, StmtInfoId stmtInfoId,
+    std::unordered_set<ScalarMeExpr*> &cycleCheck) {
+  if (cycleCheck.find(&scalar) != cycleCheck.end()) {
+    return;
+  }
+  (void)cycleCheck.insert(&scalar);
+  auto *ost = scalar.GetOst();
+  if (!ost->IsLocal() || ost->GetIndirectLev() != 0) {
+    return;
+  }
+  auto &defUsePosition = stmtInfoVector[stmtInfoId].GetDefUsePositions(*ost);
+  switch (scalar.GetDefBy()) {
+    case kDefByNo: {
+      if (ost->IsFormal()) {
+        defUsePosition.definePositions.push_back(kInvalidIndex);
+      }
+      break;
+    }
+    case kDefByPhi: {
+      for (auto *scalarOpnd : scalar.GetDefPhi().GetOpnds()) {
+        CollectDefUsePosition(static_cast<ScalarMeExpr&>(*scalarOpnd), stmtInfoId, cycleCheck);
+      }
+      break;
+    }
+    default: {
+      auto defStmtInfoId = scalar.GetDefByMeStmt()->GetStmtInfoId();
+      defUsePosition.definePositions.push_back(defStmtInfoId);
+      if (scalar.GetDefBy() != kDefByChi) {
+        auto &defUsePositionOfDefStmt = stmtInfoVector[defStmtInfoId].GetDefUsePositions(*ost);
+        defUsePositionOfDefStmt.usePositions.push_back(stmtInfoId);
+        break;
+      }
+      CollectDefUsePosition(*scalar.GetDefChi().GetRHS(), stmtInfoId, cycleCheck);
+      break;
+    }
+  }
+}
+
+void CollectIpaInfo::TraverseMeExpr(MeExpr &meExpr, StmtInfoId stmtInfoId,
+    std::unordered_set<ScalarMeExpr*> &cycleCheck) {
+  if (meExpr.IsScalar()) {
+    CollectDefUsePosition(static_cast<ScalarMeExpr&>(meExpr), stmtInfoId, cycleCheck);
+    cycleCheck.clear();
+    return;
+  }
+  for (size_t i = 0; i < meExpr.GetNumOpnds(); ++i) {
+    TraverseMeExpr(*meExpr.GetOpnd(i), stmtInfoId, cycleCheck);
+  }
+}
+
+void CollectIpaInfo::SetLabel(size_t currStmtInfoId, LabelIdx label) {
+  auto *bb = curFunc->GetMeFunc()->GetCfg()->GetLabelBBAt(label);
+  CHECK_NULL_FATAL(bb);
+  auto jumpToStmtInfoId = GetRealFirstStmtInfoId(*bb);
+  (void)stmtInfoVector[currStmtInfoId].GetLocationsJumpTo().emplace_back(jumpToStmtInfoId);
+  (void)stmtInfoVector[jumpToStmtInfoId].GetLocationsJumpFrom().emplace_back(currStmtInfoId);
+}
+
+void CollectIpaInfo::CollectJumpInfo(MeStmt &meStmt) {
+  auto stmtInfoId = meStmt.GetStmtInfoId();
+  switch (meStmt.GetOp()) {
+    case OP_brtrue:
+    case OP_brfalse: {
+      auto label = static_cast<CondGotoMeStmt&>(meStmt).GetOffset();
+      SetLabel(stmtInfoId, label);
+      break;
+    }
+    case OP_goto: {
+      auto label = static_cast<GotoMeStmt&>(meStmt).GetOffset();
+      SetLabel(stmtInfoId, label);
+      break;
+    }
+    case OP_switch: {
+      auto &switchStmt = static_cast<SwitchMeStmt&>(meStmt);
+      SetLabel(stmtInfoId, switchStmt.GetDefaultLabel());
+      for (auto casePair : switchStmt.GetSwitchTable()) {
+        SetLabel(stmtInfoId, casePair.second);
+      }
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+
+StmtInfoId CollectIpaInfo::GetRealFirstStmtInfoId(BB &bb) {
+  if (!bb.IsMeStmtEmpty()) {
+    return bb.GetFirstMe()->GetStmtInfoId();
+  }
+  CHECK_FATAL(bb.GetSucc().size() == 1, "empty bb followed with illegal succ size");
+  return GetRealFirstStmtInfoId(*bb.GetSucc().front());
+}
+
+void CollectIpaInfo::TraverseStmtInfo(size_t position) {
+  std::unordered_set<ScalarMeExpr*> cycleCheck;
+  for (size_t i = position; i < stmtInfoVector.size(); ++i) {
+    auto *meStmt = stmtInfoVector[i].GetMeStmt();
+    if (meStmt == nullptr) {
+      continue;
+    }
+    CollectJumpInfo(*meStmt);
+    for (size_t opndIndex = 0; opndIndex < meStmt->NumMeStmtOpnds(); ++opndIndex) {
+      TraverseMeExpr(*meStmt->GetOpnd(opndIndex), i, cycleCheck);
+    }
+    if (meStmt->GetOp() == OP_iassign && static_cast<IassignMeStmt *>(meStmt)->GetLHSVal()->GetBase()) {
+      TraverseMeExpr(*static_cast<IassignMeStmt *>(meStmt)->GetLHSVal()->GetBase(), i, cycleCheck);
+    }
+    auto *muList = meStmt->GetMuList();
+    if (muList == nullptr) {
+      continue;
+    }
+    for (auto &mu : *muList) {
+      CollectDefUsePosition(*mu.second, i, cycleCheck);
+    }
+  }
+}
+
+void CollectIpaInfo::RunOnScc(SCCNode<CGNode> &scc) {
+  for (auto *cgNode : scc.GetNodes()) {
+    auto currStmtPosition = stmtInfoVector.size();
+    curFunc = cgNode->GetMIRFunction();
+    MeFunction *meFunc = curFunc->GetMeFunc();
+    Perform(*meFunc);
+    if (Options::doOutline) {
+      PushInvalidKeyBack(GetCurrNewStmtIndex());
+      TraverseStmtInfo(currStmtPosition);
+    }
+  }
+}
+
+void CollectIpaInfo::Dump() {
+  LogInfo::MapleLogger() << "integer string: ";
+  for (auto ele : integerString) {
+    LogInfo::MapleLogger() << ele << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+
+  LogInfo::MapleLogger() << "stmtnode";
+  for (size_t i = 0; i < stmtInfoVector.size(); ++i) {
+    LogInfo::MapleLogger() << i << ": " << "\n";
+    auto &stmtInfo = stmtInfoVector[i];
+    if (stmtInfo.GetPuIdx() != kInvalidPuIdx) {
+      auto *function = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmtInfo.GetPuIdx());
+      module.SetCurFunction(function);
+    }
+    stmtInfoVector[i].DumpStmtNode();
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void SCCCollectIpaInfo::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<SCCPrepare>();
+  aDep.SetPreservedAll();
+}
+
+bool SCCCollectIpaInfo::PhaseRun(maple::SCCNode<CGNode> &scc) {
+  AnalysisDataManager *dataMap = GET_ANALYSIS(SCCPrepare, scc);
+  auto *hook = GetAnalysisInfoHook();
+  auto *ipaInfo = static_cast<IpaSccPM*>(hook->GetBindingPM())->GetResult();
+  ipaInfo->SetDataMap(dataMap);
+  ipaInfo->RunOnScc(scc);
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ipa/src/ipa_phase_manager.cpp b/src/mapleall/maple_ipa/src/ipa_phase_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..073d9fd874ddf302978076cbbd1eb4cc7153ce31
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/ipa_phase_manager.cpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ipa_phase_manager.h"
+#include "pme_emit.h"
+#include "mpl_profdata_parser.h"
+#include "ipa_collect.h"
+#include "ipa_side_effect.h"
+#include "prop_return_null.h"
+#include "prop_parameter_type.h"
+
+#define JAVALANG (mirModule.IsJavaModule())
+#define CLANG (mirModule.IsCModule())
+
+namespace maple {
+void IpaSccPM::Init(MIRModule &m) {
+  SetQuiet(true);
+  m.SetInIPA(true);
+  MeOption::mergeStmts = false;
+  MeOption::propDuringBuild = false;
+  MeOption::layoutWithPredict = false;
+  ipaInfo = GetPhaseAllocator()->New<CollectIpaInfo>(m, *GetPhaseMemPool());
+  DoPhasesPopulate(m);
+}
+
+bool IpaSccPM::PhaseRun(MIRModule &m) {
+  if (theMIRModule->HasPartO2List()) {
+    return false;
+  }
+  bool oldProp = MeOption::propDuringBuild;
+  bool oldMerge = MeOption::mergeStmts;
+  bool oldLayout = MeOption::layoutWithPredict;
+  Init(m);
+  bool changed = false;
+  auto admMempool = AllocateMemPoolInPhaseManager("Ipa Phase Manager's Analysis Data Manager mempool");
+  auto *serialADM = GetManagerMemPool()->New<AnalysisDataManager>(*(admMempool.get()));
+  CallGraph *cg = GET_ANALYSIS(M2MCallGraph, m);
+  // Need reverse sccV
+  const MapleVector<SCCNode<CGNode>*> &topVec = cg->GetSCCTopVec();
+  for (MapleVector<SCCNode<CGNode>*>::const_reverse_iterator it = topVec.rbegin(); it != topVec.rend(); ++it) {
+    if (!IsQuiet()) {
+      LogInfo::MapleLogger() << ">>>>>>>>>>> Optimizing SCC ---\n";
+      (*it)->Dump();
+    }
+    auto meFuncMP = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "maple_ipa per-scc mempool");
+    auto meFuncStackMP = std::make_unique<StackMemPool>(memPoolCtrler, "");
+    bool runScc = false;
+    for (auto *cgNode : (*it)->GetNodes()) {
+      MIRFunction *func = cgNode->GetMIRFunction();
+      if (func->IsEmpty()) {
+        continue;
+      }
+      runScc = true;
+      m.SetCurFunction(func);
+      MemPool *versMP = new ThreadLocalMemPool(memPoolCtrler, "first verst mempool");
+      MeFunction &meFunc = *(meFuncMP->New<MeFunction>(&m, func, meFuncMP.get(), *meFuncStackMP, versMP, "unknown"));
+      func->SetMeFunc(&meFunc);
+      meFunc.PartialInit();
+      if (!IsQuiet()) {
+        LogInfo::MapleLogger() << "---Preparing Function for scc phase < " << func->GetName() << " > ---\n";
+      }
+      meFunc.IPAPrepare();
+    }
+    if (!runScc) {
+      continue;
+    }
+    for (size_t i = 0; i < phasesSequence.size(); ++i) {
+      const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+      if (!IsQuiet()) {
+        LogInfo::MapleLogger() << "---Run scc " << (curPhase->IsAnalysis() ? "analysis" : "transform")
+                               << " Phase [ " << curPhase->PhaseName() << " ]---\n";
+      }
+      changed |= RunAnalysisPhase<MapleSccPhase<SCCNode<CGNode>>, SCCNode<CGNode>>(*curPhase, *serialADM, **it);
+    }
+    serialADM->EraseAllAnalysisPhase();
+  }
+  MeOption::mergeStmts = oldMerge;
+  MeOption::propDuringBuild = oldProp;
+  MeOption::layoutWithPredict = oldLayout;
+  if (Options::dumpPhase == "outline") {
+    ipaInfo->Dump();
+  }
+  m.SetInIPA(false);
+  return changed;
+}
+
+void IpaSccPM::DoPhasesPopulate(const MIRModule &mirModule) {
+  (void)mirModule;
+  if (Options::profileGen) {
+    AddPhase("sccprofile", true);
+  } else {
+    AddPhase("sccprepare", true);
+    AddPhase("prop_param_type",  MeOption::npeCheckMode != SafetyCheckMode::kNoCheck);
+    AddPhase("prop_return_attr",  MeOption::npeCheckMode != SafetyCheckMode::kNoCheck);
+    AddPhase("collect_ipa_info", true);
+    AddPhase("sccsideeffect", Options::sideEffect);
+    AddPhase("sccemit", true);
+  }
+}
+
+void IpaSccPM::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MCallGraph>();
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.AddPreserved<M2MCallGraph>();
+  aDep.AddPreserved<M2MKlassHierarchy>();
+  if (Options::profileUse) {
+    aDep.AddRequired<MMplProfDataParser>();
+    aDep.AddPreserved<MMplProfDataParser>();
+  }
+}
+
+void SCCPrepare::Dump(const MeFunction &f, const std::string phaseName) const {
+  if (Options::dumpIPA && (Options::dumpFunc == f.GetName() || Options::dumpFunc == "*")) {
+    LogInfo::MapleLogger() << ">>>>> Dump after " << phaseName << " <<<<<\n";
+    f.Dump(false);
+    LogInfo::MapleLogger() << ">>>>> Dump after End <<<<<\n\n";
+  }
+}
+
+bool SCCPrepare::PhaseRun(SCCNode<CGNode> &scc) {
+  SetQuiet(true);
+  AddPhase("mecfgbuild", true);
+  if (Options::profileUse) {
+    AddPhase("splitcriticaledge", true);
+    AddPhase("profileUse", true);
+  }
+  AddPhase("ssatab", true);
+  AddPhase("aliasclass", true);
+  AddPhase("ssa", true);
+  AddPhase("irmapbuild", true);
+  AddPhase("objSize", true);
+  AddPhase("hprop", true);
+  AddPhase("identloops", Options::enableGInline);  // for me_predict when collecting inline summary
+
+  // Not like other phasemanager which use temp mempool to hold analysis results generated from the sub phases.
+  // Here we use GetManagerMemPool which lives longer than this phase(manager) itself to hold all the analysis result.
+  // So the following phase can access the result in this phase.
+  result = GetManagerMemPool()->New<AnalysisDataManager>(*GetPhaseMemPool());
+  for (auto *cgNode : scc.GetNodes()) {
+    MIRFunction *func = cgNode->GetMIRFunction();
+    if (func->IsEmpty()) {
+      continue;
+    }
+    MIRModule &m = *func->GetModule();
+    m.SetCurFunction(func);
+    MeFunction &meFunc = *func->GetMeFunc();
+    for (size_t i = 0; i < phasesSequence.size(); ++i) {
+      const MaplePhaseInfo *phase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+      if (!IsQuiet()) {
+        LogInfo::MapleLogger() << " >> Prepare " << (phase->IsAnalysis() ? "analysis" : "transform")
+                               << " Phase [ " << phase->PhaseName() << " ] <<\n";
+      }
+      if (phase->IsAnalysis()) {
+        (void)RunAnalysisPhase<MeFuncOptTy, MeFunction>(*phase, *result, meFunc, 1);
+      } else {
+        (void)RunTransformPhase<MeFuncOptTy, MeFunction>(*phase, *result, meFunc, 1);
+      }
+      Dump(meFunc, phase->PhaseName());
+    }
+  }
+  return false;
+}
+
+void SCCEmit::Dump(MeFunction &f, const std::string phaseName) const {
+  if (Options::dumpIPA && (f.GetName() == Options::dumpFunc || Options::dumpFunc == "*")) {
+    LogInfo::MapleLogger() << ">>>>> Dump after " << phaseName << " <<<<<\n";
+    f.GetMirFunc()->Dump();
+    LogInfo::MapleLogger() << ">>>>> Dump after End <<<<<\n\n";
+  }
+}
+
+bool SCCEmit::PhaseRun(SCCNode<CGNode> &scc) {
+  SetQuiet(true);
+  auto *map = GET_ANALYSIS(SCCPrepare, scc);
+  if (map == nullptr) {
+    return false;
+  }
+  auto admMempool = AllocateMemPoolInPhaseManager("Ipa Phase Manager's Analysis Data Manager mempool");
+  auto *serialADM = GetManagerMemPool()->New<AnalysisDataManager>(*(admMempool.get()));
+  serialADM->CopyAnalysisResultFrom(*map);
+  for (auto *cgNode : scc.GetNodes()) {
+    MIRFunction *func = cgNode->GetMIRFunction();
+    if (func->GetBody() == nullptr) {
+      continue;
+    }
+    MIRModule &m = *func->GetModule();
+    m.SetCurFunction(func);
+    const MaplePhaseInfo *phase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(&MEPreMeEmission::id);
+    if (!IsQuiet()) {
+      LogInfo::MapleLogger() << "  ---call " << (phase->IsAnalysis() ? "analysis" : "transform")
+                             << " Phase [ " << phase->PhaseName() << " ]---\n";
+    }
+    (void)RunAnalysisPhase<MeFuncOptTy, MeFunction>(*phase, *serialADM, *func->GetMeFunc());
+    Dump(*func->GetMeFunc(), phase->PhaseName());
+    delete func->GetMeFunc()->GetPmeMempool();
+    func->GetMeFunc()->SetPmeMempool(nullptr);
+  }
+  serialADM->EraseAllAnalysisPhase();
+  return false;
+}
+
+void SCCEmit::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<SCCPrepare>();
+}
+
+bool SCCProfile::PhaseRun(SCCNode<CGNode> &scc) {
+  SetQuiet(true);
+  AddPhase("mecfgbuild", true);
+  if (Options::profileGen) {
+    AddPhase("splitcriticaledge", true);
+    AddPhase("profileGen", true);
+  }
+  AddPhase("profgenEmit", true);
+  // Not like other phasemanager which use temp mempool to hold analysis results generated from the sub phases.
+  // Here we use GetManagerMemPool which lives longer than this phase(manager) itself to hold all the analysis result.
+  // So the following phase can access the result in this phase.
+  result = GetManagerMemPool()->New<AnalysisDataManager>(*GetPhaseMemPool());
+  for (auto *cgNode : scc.GetNodes()) {
+    MIRFunction *func = cgNode->GetMIRFunction();
+    if (func->IsEmpty()) {
+      continue;
+    }
+    MIRModule &m = *func->GetModule();
+    m.SetCurFunction(func);
+    MeFunction &meFunc = *func->GetMeFunc();
+    for (size_t i = 0; i < phasesSequence.size(); ++i) {
+      const MaplePhaseInfo *phase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+      if (!IsQuiet()) {
+        LogInfo::MapleLogger() << " >> Prepare " << (phase->IsAnalysis() ? "analysis" : "transform")
+                               << " Phase [ " << phase->PhaseName() << " ] <<\n";
+      }
+      if (phase->IsAnalysis()) {
+        (void)RunAnalysisPhase<MeFuncOptTy, MeFunction>(*phase, *result, meFunc, 1);
+      } else {
+        (void)RunTransformPhase<MeFuncOptTy, MeFunction>(*phase, *result, meFunc, 1);
+      }
+    }
+  }
+  return false;
+}
+
+MAPLE_ANALYSIS_PHASE_REGISTER(SCCPrepare, sccprepare)
+MAPLE_ANALYSIS_PHASE_REGISTER(SCCProfile, sccprofile)
+MAPLE_ANALYSIS_PHASE_REGISTER(SCCCollectIpaInfo, collect_ipa_info);
+MAPLE_ANALYSIS_PHASE_REGISTER(SCCPropReturnAttr, prop_return_attr);
+MAPLE_TRANSFORM_PHASE_REGISTER(SCCPropParamType, prop_param_type);
+MAPLE_ANALYSIS_PHASE_REGISTER(SCCSideEffect, sccsideeffect)
+MAPLE_ANALYSIS_PHASE_REGISTER(SCCEmit, sccemit)
+}  // namespace maple
diff --git a/src/mapleall/maple_ipa/src/ipa_side_effect.cpp b/src/mapleall/maple_ipa/src/ipa_side_effect.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d332332df698f956937220d31639e929de1e7b30
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/ipa_side_effect.cpp
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ipa_side_effect.h"
+#include "func_desc.h"
+#include "inline_analyzer.h"
+namespace maple {
+const std::map<std::string, FuncDesc> whiteList = {
+#include "func_desc.def"
+};
+
+const FuncDesc &SideEffect::GetFuncDesc(MeFunction &f) {
+  return SideEffect::GetFuncDesc(*f.GetMirFunc());
+}
+
+const FuncDesc &SideEffect::GetFuncDesc(MIRFunction &f) {
+  auto it = whiteList.find(f.GetName());
+  if (it != whiteList.end()) {
+    return it->second;
+  }
+  return f.GetFuncDesc();
+}
+
+const std::map<std::string, FuncDesc> &SideEffect::GetWhiteList() {
+  return whiteList;
+}
+
+void SideEffect::ParamInfoUpdater(size_t vstIdx, const PI &calleeParamInfo) {
+  for (size_t callerFormalIdx = 0; callerFormalIdx < vstsValueAliasWithFormal.size(); ++callerFormalIdx) {
+    auto &formalValueAlias = vstsValueAliasWithFormal[callerFormalIdx];
+    if (formalValueAlias.find(vstIdx) != formalValueAlias.end()) {
+      curFuncDesc->SetParamInfoNoBetterThan(callerFormalIdx, calleeParamInfo);
+    }
+  }
+}
+
+void SideEffect::PropInfoFromOpnd(MeExpr &opnd, const PI &calleeParamInfo) {
+  MeExpr &base = opnd.GetAddrExprBase();
+  OriginalSt *ost = nullptr;
+  switch (base.GetMeOp()) {
+    case kMeOpVar: {
+      auto &dread = static_cast<ScalarMeExpr&>(base);
+      ost = dread.GetOst();
+      for (auto vstIdx : ost->GetVersionsIndices()) {
+        ParamInfoUpdater(vstIdx, calleeParamInfo);
+      }
+      break;
+    }
+    case kMeOpAddrof: {
+      AddrofMeExpr &addrofMeExpr = static_cast<AddrofMeExpr&>(base);
+      // As in CollectFormalOst, this is conservative to make sure it's right.
+      // For example:
+      // void callee(int *p) : write memory that p points to.
+      // call callee(&x) : this will modify x but we prop info of 'write memory' to x.
+      ost = addrofMeExpr.GetOst();
+      ASSERT(ost != nullptr, "null ptr check");
+      for (auto vstIdx : ost->GetVersionsIndices()) {
+        ParamInfoUpdater(vstIdx, calleeParamInfo);
+      }
+      break;
+    }
+    case kMeOpOp: {
+      if (base.GetOp() == OP_select) {
+        PropInfoFromOpnd(*base.GetOpnd(kSecondOpnd), calleeParamInfo);
+        PropInfoFromOpnd(*base.GetOpnd(kThirdOpnd), calleeParamInfo);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void SideEffect::PropParamInfoFromCallee(const MeStmt &call, MIRFunction &callee) {
+  const FuncDesc &desc = callee.GetFuncDesc();
+  size_t skipFirstOpnd = kOpcodeInfo.IsICall(call.GetOp()) ? 1 : 0;
+  size_t actualParaCount = call.NumMeStmtOpnds() - skipFirstOpnd;
+  for (size_t formalIdx = 0; formalIdx < actualParaCount; ++formalIdx) {
+    MeExpr *opnd = call.GetOpnd(formalIdx + skipFirstOpnd);
+    PropInfoFromOpnd(*opnd, desc.GetParamInfo(formalIdx));
+  }
+}
+
+void SideEffect::PropAllInfoFromCallee(const MeStmt &call, MIRFunction &callee) {
+  const FuncDesc &desc = callee.GetFuncDesc();
+  if (!desc.IsPure() && !desc.IsConst()) {
+    curFuncDesc->SetFuncInfoNoBetterThan(FI::kUnknown);
+  }
+  if (desc.IsPure()) {
+    curFuncDesc->SetFuncInfoNoBetterThan(FI::kPure);
+  }
+  if (desc.IsConst()) {
+    curFuncDesc->SetFuncInfoNoBetterThan(FI::kConst);
+  }
+  PropParamInfoFromCallee(call, callee);
+}
+
+void SideEffect::DealWithStmt(MeStmt &stmt) {
+  for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+    DealWithOperand(stmt.GetOpnd(i));
+  }
+  RetMeStmt *ret = safe_cast<RetMeStmt>(&stmt);
+  if (ret != nullptr) {
+    DealWithReturn(*ret);
+  }
+  CallMeStmt *call = safe_cast<CallMeStmt>(&stmt);
+  if (call != nullptr) {
+    MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(call->GetPUIdx());
+    PropAllInfoFromCallee(*call, *calleeFunc);
+  }
+  IcallMeStmt *icall = safe_cast<IcallMeStmt>(&stmt);
+  if (icall != nullptr) {
+    MIRFunction *mirFunc = meFunc->GetMirFunc();
+    CGNode *icallCGNode = callGraph->GetCGNode(mirFunc);
+    CallInfo callInfo(stmt.GetMeStmtId());
+    CHECK_NULL_FATAL(icallCGNode);
+    auto &callees = icallCGNode->GetCallee();
+    auto it = callees.find(&callInfo);
+    if (it == callees.end() || it->second->empty()) {
+      // no candidates found, process conservatively
+      for (size_t formalIdx = 1; formalIdx < icall->NumMeStmtOpnds(); ++formalIdx) {
+        PropInfoFromOpnd(*icall->GetOpnd(formalIdx), PI::kUnknown);
+      }
+    } else {
+      for (auto *cgNode : *it->second) {
+        MIRFunction *calleeFunc = cgNode->GetMIRFunction();
+        PropAllInfoFromCallee(*icall, *calleeFunc);
+      }
+    }
+  }
+  if (stmt.GetMuList() == nullptr) {
+    return;
+  }
+  // this may cause some kWriteMemoryOnly regard as kReadWriteMemory.
+  // Example: {a.f = b} mulist in return stmt will regard param a as used.
+  for (auto &mu : std::as_const(*stmt.GetMuList())) {
+    DealWithOst(mu.first);
+  }
+}
+
+void SideEffect::DealWithOst(OStIdx ostIdx) {
+  OriginalSt *ost = meFunc->GetMeSSATab()->GetSymbolOriginalStFromID(ostIdx);
+  DealWithOst(ost);
+}
+
+void SideEffect::DealWithOst(const OriginalSt *ost) {
+  if (ost == nullptr) {
+    return;
+  }
+  for (auto &pair : analysisLater) {
+    if (pair.first == ost) {
+      curFuncDesc->SetParamInfoNoBetterThan(pair.second, PI::kReadWriteMemory);
+      return;
+    }
+  }
+}
+
+void SideEffect::DealWithOperand(MeExpr *expr) {
+  if (expr == nullptr) {
+    return;
+  }
+  for (uint32 i = 0; i < expr->GetNumOpnds(); ++i) {
+    DealWithOperand(expr->GetOpnd(i));
+  }
+  switch (expr->GetMeOp()) {
+    case kMeOpVar: {
+      ScalarMeExpr *dread = static_cast<ScalarMeExpr*>(expr);
+      OriginalSt *ost = dread->GetOst();
+      DealWithOst(ost);
+      break;
+    }
+    case kMeOpIvar: {
+      auto *base = static_cast<IvarMeExpr*>(expr)->GetBase();
+      if (base->GetMeOp() == kMeOpVar) {
+        ScalarMeExpr *dread = static_cast<ScalarMeExpr*>(base);
+        DealWithOst(dread->GetOst());
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return;
+}
+
+void SideEffect::DealWithReturn(const RetMeStmt &retMeStmt) const {
+  if (retMeStmt.NumMeStmtOpnds() == 0) {
+    return;
+  }
+  MeExpr *ret = retMeStmt.GetOpnd(0);
+  if (ret->GetPrimType() == PTY_agg) {
+    curFuncDesc->SetReturnInfo(RI::kUnknown);
+    return;
+  }
+  if (!IsAddress(ret->GetPrimType())) {
+    return;
+  }
+  if (ret->GetType() != nullptr && ret->GetType()->IsMIRPtrType()) {
+    auto *ptrType = static_cast<MIRPtrType*>(ret->GetType());
+    if (ptrType->GetPointedType()->GetPrimType() == PTY_agg) {
+      curFuncDesc->SetReturnInfo(RI::kUnknown);
+      return;
+    }
+  }
+  OriginalSt *retOst = nullptr;
+  size_t vstIdxOfRet = 0;
+  if (ret->IsScalar()) {
+    retOst = static_cast<ScalarMeExpr*>(ret)->GetOst();
+    vstIdxOfRet = static_cast<ScalarMeExpr*>(ret)->GetVstIdx();
+  } else if (ret->GetMeOp() == kMeOpIvar) {
+    auto *base = static_cast<IvarMeExpr*>(ret)->GetBase();
+    if (base->IsScalar()) {
+      retOst = static_cast<ScalarMeExpr*>(base)->GetOst();
+      vstIdxOfRet = static_cast<ScalarMeExpr*>(base)->GetVstIdx();
+    }
+  }
+  if (retOst == nullptr) {
+    return;
+  }
+  if (retOst->IsFormal()) {
+    curFuncDesc->SetReturnInfo(RI::kUnknown);
+    return;
+  }
+  std::set<size_t> result;
+  alias->GetValueAliasSetOfVst(vstIdxOfRet, result);
+  for (auto valueAliasVstIdx : result) {
+    auto *meExpr = meFunc->GetIRMap()->GetVerst2MeExprTableItem(static_cast<uint32>(valueAliasVstIdx));
+    // meExpr of valueAliasVstIdx not created in IRMap, it must not occured in hssa-mefunction
+    if (meExpr == nullptr) {
+      continue;
+    }
+    OriginalSt *aliasOst = nullptr;
+    if (meExpr->GetMeOp() == kMeOpAddrof) {
+      auto ostIdx = static_cast<AddrofMeExpr*>(meExpr)->GetOstIdx();
+      aliasOst = meFunc->GetMeSSATab()->GetOriginalStFromID(ostIdx);
+    } else if (meExpr->IsScalar()) {
+      aliasOst = static_cast<ScalarMeExpr*>(meExpr)->GetOst();
+    } else {
+      CHECK_FATAL(false, "not supported meExpr");
+    }
+    ASSERT(aliasOst != nullptr, "null ptr check");
+    if (aliasOst->IsFormal()) {
+      curFuncDesc->SetReturnInfo(RI::kUnknown);
+    }
+  }
+}
+
+void SideEffect::SolveVarArgs(MeFunction &f) const {
+  MIRFunction *func = f.GetMirFunc();
+  if (func->IsVarargs()) {
+    for (size_t i = func->GetFormalCount(); i < kMaxParamCount; ++i) {
+      curFuncDesc->SetParamInfoNoBetterThan(i, PI::kUnknown);
+    }
+    curFuncDesc->SetFuncInfoNoBetterThan(FI::kUnknown);
+  }
+}
+
+void SideEffect::CollectAllLevelOst(size_t vstIdx, std::set<size_t> &result) {
+  (void)result.insert(vstIdx);
+  auto *nextLevelOsts = meFunc->GetMeSSATab()->GetNextLevelOsts(vstIdx);
+  if (nextLevelOsts == nullptr) {
+    return;
+  }
+  for (auto *nlOst : *nextLevelOsts) {
+    for (auto vstIdOfNextLevelOst : nlOst->GetVersionsIndices()) {
+      CollectAllLevelOst(vstIdOfNextLevelOst, result);
+    }
+  }
+}
+
+void SideEffect::CollectFormalOst(MeFunction &f) {
+  MIRFunction *func = f.GetMirFunc();
+  for (auto *ost : f.GetMeSSATab()->GetOriginalStTable().GetOriginalStVector()) {
+    if (ost == nullptr) {
+      continue;
+    }
+    if (!ost->IsLocal()) {
+      curFuncDesc->SetFuncInfoNoBetterThan(FI::kPure);
+      if (ost->GetVersionsIndices().size() > 1) {
+        curFuncDesc->SetFuncInfoNoBetterThan(FI::kUnknown);
+      }
+    }
+    if (ost->IsFormal() && ost->GetIndirectLev() == 0) {
+      auto idx = func->GetFormalIndex(ost->GetMIRSymbol());
+      if (idx >= kMaxParamCount) {
+        continue;
+      }
+
+      // Put level -1 ost into it, so we can get a conservative result.
+      // Because when we solve all vstsValueAliasWithFormal we regard every ost in it as lev 0.
+
+      std::set<size_t> vstValueAliasFormal;
+      if (ost->IsAddressTaken()) {
+        CollectAllLevelOst(ost->GetPointerVstIdx(), vstsValueAliasWithFormal[idx]);
+        alias->GetValueAliasSetOfVst(ost->GetPointerVstIdx(), vstValueAliasFormal);
+      }
+      CollectAllLevelOst(ost->GetZeroVersionIndex(), vstsValueAliasWithFormal[idx]);
+      alias->GetValueAliasSetOfVst(ost->GetZeroVersionIndex(), vstValueAliasFormal);
+
+      for (size_t vstIdx: vstValueAliasFormal) {
+        auto *meExpr = meFunc->GetIRMap()->GetVerst2MeExprTableItem(static_cast<uint32>(vstIdx));
+        if (meExpr == nullptr || meExpr->GetMeOp() == kMeOpAddrof) {
+          // corresponding ScalarMeExpr has not been created in irmap for vstIdx.
+          CollectAllLevelOst(vstIdx, vstsValueAliasWithFormal[idx]);
+          continue;
+        }
+        CHECK_FATAL(meExpr->IsScalar(), "not supported MeExpr type");
+        CHECK_FATAL(static_cast<ScalarMeExpr*>(meExpr)->GetVstIdx() == vstIdx, "VersionSt index must be equal");
+        auto *aliasOst = static_cast<ScalarMeExpr*>(meExpr)->GetOst();
+        if (aliasOst != ost) {
+          for (auto vstIdxOfAliasOst : aliasOst->GetVersionsIndices()) {
+            CollectAllLevelOst(vstIdxOfAliasOst, vstsValueAliasWithFormal[idx]);
+          }
+        }
+      }
+    }
+  }
+}
+
+void SideEffect::AnalysisFormalOst() {
+  for (size_t formalIndex = 0; formalIndex < vstsValueAliasWithFormal.size(); ++formalIndex) {
+    for (size_t vstIdx : vstsValueAliasWithFormal[formalIndex]) {
+      curFuncDesc->SetParamInfoNoBetterThan(formalIndex, PI::kReadSelfOnly);
+      auto *meExpr = meFunc->GetIRMap()->GetVerst2MeExprTableItem(static_cast<uint32>(vstIdx));
+      if (meExpr == nullptr) {
+        continue;
+      }
+      if (meExpr->GetMeOp() == kMeOpAddrof) {
+        curFuncDesc->SetParamInfoNoBetterThan(formalIndex, PI::kUnknown);
+        curFuncDesc->SetFuncInfoNoBetterThan(FI::kUnknown);
+        continue;
+      }
+      CHECK_FATAL(meExpr->IsScalar(), "must be me scalar");
+      auto *ost = static_cast<ScalarMeExpr*>(meExpr)->GetOst();
+      if (ost->GetIndirectLev() == 0 && ost->GetVersionsIndices().size() == 1) {
+        curFuncDesc->SetParamInfoNoBetterThan(formalIndex, PI::kReadSelfOnly);
+        continue;
+      }
+      if (ost->GetIndirectLev() == 1) {
+        if (ost->GetVersionsIndices().size() == 1) {
+          curFuncDesc->SetParamInfoNoBetterThan(formalIndex, PI::kReadMemoryOnly);
+          curFuncDesc->SetFuncInfoNoBetterThan(FI::kPure);
+        } else {
+          analysisLater.insert(std::make_pair(ost, formalIndex));
+          curFuncDesc->SetParamInfoNoBetterThan(formalIndex, PI::kWriteMemoryOnly);
+          curFuncDesc->SetFuncInfoNoBetterThan(FI::kUnknown);
+        }
+        continue;
+      }
+      if (ost->GetIndirectLev() > 1) {
+        if (ost->GetVersionsIndices().size() == 1) {
+          curFuncDesc->SetParamInfoNoBetterThan(formalIndex, PI::kReadMemoryOnly);
+          curFuncDesc->SetFuncInfoNoBetterThan(FI::kPure);
+        } else {
+          curFuncDesc->SetParamInfoNoBetterThan(formalIndex, PI::kUnknown);
+          curFuncDesc->SetFuncInfoNoBetterThan(FI::kUnknown);
+        }
+      }
+    }
+  }
+}
+
+bool SideEffect::Perform(MeFunction &f) {
+  MIRFunction *func = f.GetMirFunc();
+  curFuncDesc = &func->GetFuncDesc();
+  FuncDesc oldDesc = *curFuncDesc;
+
+  if (func->GetFuncDesc().IsConfiged()) {
+    return false;
+  }
+  SolveVarArgs(f);
+  CollectFormalOst(f);
+  AnalysisFormalOst();
+  for (auto *node : dom->GetReversePostOrder()) {
+    auto bb = f.GetCfg()->GetBBFromID(BBId(node->GetID()));
+    for (auto &stmt : bb->GetMeStmts()) {
+      DealWithStmt(stmt);
+    }
+  }
+  return !curFuncDesc->Equals(oldDesc);
+}
+
+bool SCCSideEffect::PhaseRun(SCCNode<CGNode> &scc) {
+  for (CGNode *node : scc.GetNodes()) {
+    MIRFunction *func = node->GetMIRFunction();
+    if (func != nullptr && !func->GetFuncDesc().IsConfiged()) {
+      func->InitFuncDescToBest();
+      func->GetFuncDesc().SetReturnInfo(RI::kUnknown);
+      if (func->GetParamSize() > kMaxParamCount) {
+        func->GetFuncDesc().SetFuncInfoNoBetterThan(FI::kUnknown);
+      }
+    }
+  }
+  bool changed = true;
+  while (changed) {
+    changed = false;
+    auto *map = GET_ANALYSIS(SCCPrepare, scc);
+    for (CGNode *node : scc.GetNodes()) {
+      MIRFunction *func = node->GetMIRFunction();
+      if (func == nullptr) {
+        continue;
+      }
+      MeFunction *meFunc = func->GetMeFunc();
+      if (meFunc == nullptr || meFunc->GetCfg()->NumBBs() == 0) {
+        continue;
+      }
+      auto *phase = map->GetVaildAnalysisPhase(meFunc->GetUniqueID(), &MEDominance::id);
+      Dominance *dom = static_cast<MEDominance*>(phase)->GetDomResult();
+      phase = map->GetVaildAnalysisPhase(meFunc->GetUniqueID(), &MEAliasClass::id);
+      AliasClass *alias = static_cast<MEAliasClass*>(phase)->GetResult();
+
+      phase = map->GetVaildAnalysisPhase(meFunc->GetUniqueID(), &MESSATab::id);
+      SSATab *meSSATab = static_cast<MESSATab*>(phase)->GetResult();
+      CHECK_FATAL(meSSATab == meFunc->GetMeSSATab(), "IPA_PM may be wrong.");
+      MaplePhase *it = GetAnalysisInfoHook()->GetOverIRAnalyisData<M2MCallGraph, MIRModule>(*func->GetModule());
+      CallGraph *cg = static_cast<M2MCallGraph*>(it)->GetResult();
+      SideEffect se(meFunc, dom, alias, cg);
+      changed = changed || se.Perform(*meFunc);
+    }
+  }
+  if (Options::dumpIPA) {
+    for (CGNode *node : scc.GetNodes()) {
+      MIRFunction *func = node->GetMIRFunction();
+      FuncDesc &desc = func->GetFuncDesc();
+      LogInfo::MapleLogger() <<  "funcid: " << func->GetPuidx() << " funcName: " << func->GetName() << std::endl;
+      desc.Dump();
+    }
+  }
+  return false;
+}
+
+void SCCSideEffect::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<SCCPrepare>();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ipa/src/old/do_ipa_escape_analysis.cpp b/src/mapleall/maple_ipa/src/old/do_ipa_escape_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5fa3df4246586f998ef37e718dc9e3d703d8f050
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/old/do_ipa_escape_analysis.cpp
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "do_ipa_escape_analysis.h"
+
+namespace maple {
+#ifdef NOT_USED
+AnalysisResult *DoIpaEA::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) {
+  if (func == nullptr) {
+    return nullptr;
+  }
+  MIRFunction *mirFunc = func->GetMirFunc();
+  const std::map<GStrIdx, EAConnectionGraph*> &summaryMap = mirFunc->GetModule()->GetEASummary();
+  if (!mirFunc->GetModule()->IsInIPA() && summaryMap.size() == 0) {
+    return nullptr;
+  }
+  CHECK_FATAL(mrm != nullptr, "Needs module result manager for ipa");
+  KlassHierarchy *kh = static_cast<KlassHierarchy*>(mrm->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule()));
+  CHECK_FATAL(kh != nullptr, "KlassHierarchy phase has problem");
+  MeIRMap *irMap = static_cast<MeIRMap*>(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func));
+  CHECK_FATAL(irMap != nullptr, "irMap phase has problem");
+
+  CallGraph *pcg = nullptr;
+  if (mirFunc->GetModule()->IsInIPA()) {
+    pcg = static_cast<CallGraph*>(mrm->GetAnalysisResult(MoPhase_CALLGRAPH_ANALYSIS, &func->GetMIRModule()));
+  }
+  MemPool *eaMemPool = memPoolCtrler.NewMemPool(PhaseName(), false /* isLcalPool */);
+  mirFunc->GetModule()->SetCurFunction(mirFunc);
+
+  if (IPAEscapeAnalysis::kDebug) {
+    LogInfo::MapleLogger() << "=======IPAEA BEGIN======== " << mirFunc->GetName() << std::endl;
+  }
+
+  IPAEscapeAnalysis ipaEA(kh, irMap, func, eaMemPool, pcg);
+  ipaEA.ConstructConnGraph();
+  func->GetMirFunc()->GetEACG()->TrimGlobalNode();
+  if (!mirFunc->GetModule()->IsInIPA()) {
+    auto it = summaryMap.find(func->GetMirFunc()->GetNameStrIdx());
+    if (it != summaryMap.end() && it->second != nullptr) {
+      it->second->DeleteEACG();
+    }
+  }
+  if (!mirFunc->GetModule()->IsInIPA() && IPAEscapeAnalysis::kDebug) {
+    func->GetMirFunc()->GetEACG()->CountObjEAStatus();
+  }
+  if (IPAEscapeAnalysis::kDebug) {
+    LogInfo::MapleLogger() << "=======IPAEA END========" << mirFunc->GetName() << std::endl;
+  }
+
+  delete eaMemPool;
+  return nullptr;
+}
+
+AnalysisResult *DoIpaEAOpt::Run(MeFunction *func, MeFuncResultMgr *mgr, ModuleResultMgr *mrm) {
+  if (func == nullptr) {
+    return nullptr;
+  }
+  MIRFunction *mirFunc = func->GetMirFunc();
+  const std::map<GStrIdx, EAConnectionGraph*> &summaryMap = mirFunc->GetModule()->GetEASummary();
+  if (!mirFunc->GetModule()->IsInIPA() && summaryMap.size() == 0) {
+    return nullptr;
+  }
+  CHECK_FATAL(mrm != nullptr, "Needs module result manager for ipa");
+  KlassHierarchy *kh = static_cast<KlassHierarchy*>(mrm->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule()));
+  CHECK_FATAL(kh != nullptr, "KlassHierarchy phase has problem");
+  MeIRMap *irMap = static_cast<MeIRMap*>(mgr->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func));
+  CHECK_FATAL(irMap != nullptr, "irMap phase has problem");
+
+  mgr->InvalidAnalysisResult(MeFuncPhase_MELOOP, func);
+  IdentifyLoops *meLoop = static_cast<IdentifyLoops*>(mgr->GetAnalysisResult(MeFuncPhase_MELOOP, func));
+  CHECK_FATAL(meLoop != nullptr, "meLoop phase has problem");
+  meLoop->MarkBB();
+
+  CallGraph *pcg = nullptr;
+  if (mirFunc->GetModule()->IsInIPA()) {
+    pcg = static_cast<CallGraph*>(mrm->GetAnalysisResult(MoPhase_CALLGRAPH_ANALYSIS, &func->GetMIRModule()));
+  }
+  MemPool *eaMemPool = memPoolCtrler.NewMemPool(PhaseName(), false /* isLcalPool */);
+  mirFunc->GetModule()->SetCurFunction(mirFunc);
+
+  if (IPAEscapeAnalysis::kDebug) {
+    LogInfo::MapleLogger() << "=======IPAEAOPT BEGIN======== " << mirFunc->GetName() << std::endl;
+  }
+
+  IPAEscapeAnalysis ipaEA(kh, irMap, func, eaMemPool, pcg);
+  ipaEA.DoOptimization();
+  if (IPAEscapeAnalysis::kDebug) {
+    LogInfo::MapleLogger() << "=======IPAEAOPT END========" << mirFunc->GetName() << std::endl;
+  }
+
+  delete eaMemPool;
+  return nullptr;
+}
+#endif
+}
diff --git a/src/mapleall/maple_ipa/src/old/ea_connection_graph.cpp b/src/mapleall/maple_ipa/src/old/ea_connection_graph.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a313567e96d06b529f485775ed3c4df4b5a5ef16
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/old/ea_connection_graph.cpp
@@ -0,0 +1,1054 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ea_connection_graph.h"
+
+namespace maple {
+constexpr maple::uint32 kInvalid = 0xffffffff;
+void EACGBaseNode::CheckAllConnectionInNodes() {
+#ifdef DEBUG
+  for (EACGBaseNode *inNode : in) {
+    ASSERT_NOT_NULL(eaCG->nodes[inNode->id - 1]);
+    ASSERT(eaCG->nodes[inNode->id - 1] == inNode, "must be inNode");
+  }
+  for (EACGBaseNode *outNode : out) {
+    ASSERT_NOT_NULL(eaCG->nodes[outNode->id - 1]);
+    ASSERT(eaCG->nodes[outNode->id - 1] == outNode, "must be outNode");
+  }
+  for (EACGObjectNode *obj : pointsTo) {
+    ASSERT_NOT_NULL(eaCG->nodes[obj->id - 1]);
+    ASSERT(eaCG->nodes[obj->id - 1] == obj, "must be obj");
+  }
+  if (IsFieldNode()) {
+    for (EACGObjectNode *obj : static_cast<EACGFieldNode*>(this)->GetBelongsToObj()) {
+      ASSERT_NOT_NULL(eaCG->nodes[obj->id - 1]);
+      ASSERT(eaCG->nodes[obj->id - 1] == obj, "must be obj");
+    }
+  }
+#endif
+}
+
+bool EACGBaseNode::AddOutNode(EACGBaseNode &newOut) {
+  if (out.find(&newOut) != out.end()) {
+    return false;
+  }
+  bool newIsLocal = newOut.UpdateEAStatus(eaStatus);
+  if (eaStatus == kGlobalEscape && pointsTo.size() > 0) {
+    if (newIsLocal) {
+      eaCG->SetCGUpdateFlag();
+    }
+    return newIsLocal;
+  }
+  (void)out.insert(&newOut);
+  (void)newOut.in.insert(this);
+  ASSERT(newOut.pointsTo.size() != 0, "must be greater than zero");
+  bool hasChanged = UpdatePointsTo(newOut.pointsTo);
+  eaCG->SetCGUpdateFlag();
+  return hasChanged;
+}
+
+void EACGBaseNode::PropagateEAStatusForNode(const EACGBaseNode *subRoot [[maybe_unused]]) const {
+  for (EACGBaseNode *outNode : out) {
+    (void)outNode->UpdateEAStatus(eaStatus);
+  }
+}
+
+std::string EACGBaseNode::GetName(const IRMap *irMap) const {
+  std::string name;
+  if (irMap == nullptr || meExpr == nullptr) {
+    name += std::to_string(id);
+  } else {
+    name += std::to_string(id);
+    name += "\\n";
+    if (meExpr->GetMeOp() == kMeOpVar) {
+      VarMeExpr *varMeExpr = static_cast<VarMeExpr*>(meExpr);
+      const MIRSymbol *sym = varMeExpr->GetOst()->GetMIRSymbol();
+      name += ((sym->GetStIdx().IsGlobal() ? "$" : "%") + sym->GetName() + "\\nmx" +
+              std::to_string(meExpr->GetExprID()) + " (field)" + std::to_string(varMeExpr->GetFieldID()));
+    } else if (meExpr->GetMeOp() == kMeOpIvar) {
+      IvarMeExpr *ivarMeExpr = static_cast<IvarMeExpr*>(meExpr);
+      MeExpr *base = ivarMeExpr->GetBase();
+      VarMeExpr *varMeExpr = nullptr;
+      if (base->GetMeOp() == kMeOpVar) {
+        varMeExpr = static_cast<VarMeExpr*>(base);
+      } else {
+        name += std::to_string(id);
+        return name;
+      }
+      const MIRSymbol *sym = varMeExpr->GetOst()->GetMIRSymbol();
+      name += (std::string("base :") + (sym->GetStIdx().IsGlobal() ? "$" : "%") + sym->GetName() + "\\nmx" +
+              std::to_string(meExpr->GetExprID()) + " (field)" + std::to_string(ivarMeExpr->GetFieldID()));
+    } else if (meExpr->GetOp() == OP_gcmalloc || meExpr->GetOp() == OP_gcmallocjarray) {
+      name += "mx" + std::to_string(meExpr->GetExprID());
+    }
+  }
+  return name;
+}
+
+bool EACGBaseNode::UpdatePointsTo(const std::set<EACGObjectNode*> &cPointsTo) {
+  size_t oldPtSize = pointsTo.size();
+  pointsTo.insert(cPointsTo.cbegin(), cPointsTo.cend());
+  if (oldPtSize == pointsTo.size()) {
+    return false;
+  }
+  for (EACGObjectNode *pt : pointsTo) {
+    pt->Insert2PointsBy(this);
+  }
+  for (EACGBaseNode *pred : in) {
+    (void)pred->UpdatePointsTo(pointsTo);
+  }
+  return true;
+}
+
+void EACGBaseNode::GetNodeFormatInDot(std::string &label, std::string &color) const {
+  switch (GetEAStatus()) {
+    case kNoEscape:
+      label += "NoEscape";
+      color = "darkgreen";
+      break;
+    case kArgumentEscape:
+      label += "ArgEscape";
+      color = "brown";
+      break;
+    case kReturnEscape:
+      label += "RetEscape";
+      color = "orange";
+      break;
+    case kGlobalEscape:
+      label += "GlobalEscape";
+      color = "red";
+      break;
+  }
+}
+
+bool EACGBaseNode::CanIgnoreRC() const {
+  for (auto obj : pointsTo) {
+    if (!obj->GetIgnorRC()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void EACGObjectNode::CheckAllConnectionInNodes() {
+#ifdef DEBUG
+  for (EACGBaseNode *inNode : in) {
+    ASSERT_NOT_NULL(eaCG->nodes[inNode->id - 1]);
+    ASSERT(eaCG->nodes[inNode->id - 1] == inNode, "must be inNode");
+  }
+  for (EACGBaseNode *outNode : out) {
+    ASSERT_NOT_NULL(eaCG->nodes[outNode->id - 1]);
+    ASSERT(eaCG->nodes[outNode->id - 1] == outNode, "must be outNode");
+  }
+  for (EACGBaseNode *pBy : pointsBy) {
+    ASSERT_NOT_NULL(eaCG->nodes[pBy->id - 1]);
+    ASSERT(eaCG->nodes[pBy->id - 1] == pBy, "must be pBy");
+  }
+  for (auto fieldPair : fieldNodes) {
+    EACGFieldNode *field = fieldPair.second;
+    ASSERT(field->fieldID == fieldPair.first, "must be fieldPair.first");
+    ASSERT_NOT_NULL(eaCG->nodes[field->id - 1]);
+    ASSERT(eaCG->nodes[field->id - 1] == field, "must be filed");
+  }
+#endif
+}
+
+bool EACGObjectNode::IsPointedByFieldNode() const {
+  for (EACGBaseNode *pBy : pointsBy) {
+    if (pBy->IsFieldNode()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool EACGObjectNode::AddOutNode(EACGBaseNode &newOut) {
+  ASSERT(newOut.IsFieldNode(), "must be fieldNode");
+  EACGFieldNode *field = static_cast<EACGFieldNode*>(&newOut);
+  fieldNodes[field->GetFieldID()] = field;
+  (void)newOut.UpdateEAStatus(eaStatus);
+  field->AddBelongTo(this);
+  return true;
+}
+
+bool EACGObjectNode::ReplaceByGlobalNode() {
+  ASSERT(out.size() == 0, "must be zero");
+  for (EACGBaseNode *node : pointsBy) {
+    node->pointsTo.erase(this);
+    (void)node->pointsTo.insert(eaCG->GetGlobalObject());
+  }
+  pointsBy.clear();
+  for (EACGBaseNode *inNode : in) {
+    (void)inNode->out.erase(this);
+    (void)inNode->out.insert(eaCG->GetGlobalObject());
+  }
+  in.clear();
+  for (auto fieldPair : fieldNodes) {
+    EACGFieldNode *field = fieldPair.second;
+    field->belongsTo.erase(this);
+  }
+  fieldNodes.clear();
+  if (meExpr != nullptr) {
+    eaCG->expr2Nodes[meExpr]->clear();
+    eaCG->expr2Nodes[meExpr]->insert(eaCG->GetGlobalObject());
+  }
+  ASSERT(eaCG->nodes[id - 1] == this, "must be");
+  eaCG->nodes[id - 1] = nullptr;
+  return true;
+}
+
+void EACGObjectNode::PropagateEAStatusForNode(const EACGBaseNode *subRoot [[maybe_unused]]) const {
+  for (auto fieldNodePair : fieldNodes) {
+    EACGFieldNode *field = fieldNodePair.second;
+    (void)field->UpdateEAStatus(eaStatus);
+  }
+}
+
+void EACGObjectNode::DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                                 const IRMap *irMap) {
+  if (dumped[this]) {
+    return;
+  }
+  dumped[this] = true;
+
+  std::string name = GetName(nullptr);
+  std::string label = GetName(irMap) + " Object\\n";
+  std::string color;
+  GetNodeFormatInDot(label, color);
+  std::string style;
+  if (IsPhantom()) {
+    style = "dotted";
+  } else {
+    style = "bold";
+  }
+  fout << name << " [shape=box, label=\"" << label << "\", fontcolor=" << color << ", style=" << style << "];\n";
+  for (auto fieldPair : std::as_const(fieldNodes)) {
+    EACGBaseNode *field = fieldPair.second;
+    fout << name << "->" << field->GetName(nullptr) << ";" << "\n";
+  }
+  for (auto fieldPair : std::as_const(fieldNodes)) {
+    EACGBaseNode *field = fieldPair.second;
+    field->DumpDotFile(fout, dumped, dumpPt, irMap);
+  }
+}
+
+void EACGRefNode::DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                              const IRMap *irMap) {
+  if (dumped[this]) {
+    return;
+  }
+  dumped[this] = true;
+
+  std::string name = GetName(nullptr);
+  std::string label = GetName(irMap) + " Reference\\n";
+  if (IsStaticRef()) {
+    label += "Static\\n";
+  }
+  std::string color;
+  GetNodeFormatInDot(label, color);
+  fout << name << " [shape=ellipse, label=\"" << label << "\", fontcolor=" << color << "];" << "\n";
+  if (dumpPt) {
+    for (auto obj : pointsTo) {
+      fout << name << "->" << obj->GetName(nullptr) << ";" << "\n";
+    }
+    for (auto obj : pointsTo) {
+      obj->DumpDotFile(fout, dumped, dumpPt, irMap);
+    }
+  } else {
+    for (auto outNode : out) {
+      std::string edgeStyle;
+      if (!outNode->IsObjectNode()) {
+        edgeStyle = " [style =\"dotted\"]";
+      }
+      fout << name << "->" << outNode->GetName(nullptr) << edgeStyle << ";" << "\n";
+    }
+    for (auto outNode : out) {
+      outNode->DumpDotFile(fout, dumped, dumpPt, irMap);
+    }
+  }
+}
+
+bool EACGRefNode::ReplaceByGlobalNode() {
+  for (EACGBaseNode *inNode : in) {
+    ASSERT(inNode->id > 3, "must be greater than three"); // the least valid idx is 3
+    (void)inNode->out.erase(this);
+    (void)inNode->out.insert(eaCG->GetGlobalReference());
+  }
+  in.clear();
+  for (EACGBaseNode *outNode : out) {
+    (void)outNode->in.erase(this);
+  }
+  out.clear();
+  for (EACGObjectNode *base : pointsTo) {
+    base->EraseNodeFromPointsBy(this);
+  }
+  pointsTo.clear();
+  if (meExpr != nullptr) {
+    eaCG->expr2Nodes[meExpr]->clear();
+    eaCG->expr2Nodes[meExpr]->insert(eaCG->GetGlobalReference());
+  }
+  ASSERT(eaCG->nodes[id - 1] == this, "must be this");
+  eaCG->nodes[id - 1] = nullptr;
+  return true;
+}
+
+void EACGPointerNode::DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                                  const IRMap *irMap) {
+  if (dumped[this]) {
+    return;
+  }
+  dumped[this] = true;
+  std::string name = GetName(nullptr);
+  std::string label = GetName(irMap) + "\\nPointer Indirect Level : " + std::to_string(indirectLevel) + "\\n";
+  std::string color;
+  GetNodeFormatInDot(label, color);
+  fout << name << " [shape=ellipse, label=\"" << label << "\", fontcolor=" << color << "];" << "\n";
+  for (EACGBaseNode *outNode : out) {
+    fout << name << "->" << outNode->GetName(nullptr) << " [style =\"dotted\", color = \"blue\"];" << "\n";
+  }
+  for (auto outNode : out) {
+    outNode->DumpDotFile(fout, dumped, dumpPt, irMap);
+  }
+}
+
+void EACGActualNode::DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                                 const IRMap *irMap) {
+  if (dumped[this]) {
+    return;
+  }
+  dumped[this] = true;
+
+  std::string name = GetName(nullptr);
+  std::string label;
+  if (IsReturn()) {
+    label = GetName(irMap) + "\\nRet Idx : " + std::to_string(GetArgIndex()) + "\\n";
+  } else {
+    label = GetName(irMap) + "\\nArg Idx : " + std::to_string(GetArgIndex()) +
+            " Call Site : " + std::to_string(GetCallSite()) + "\\n";
+  }
+  std::string style;
+  if (IsPhantom()) {
+    style = "dotted";
+  } else {
+    style = "bold";
+  }
+  std::string color;
+  GetNodeFormatInDot(label, color);
+  fout << name << " [shape=ellipse, label=\"" << label << "\", fontcolor=" << color << ", style=" << style << "];\n";
+  if (dumpPt) {
+    for (auto obj : pointsTo) {
+      fout << name << "->" << obj->GetName(nullptr) << ";\n";
+    }
+    for (auto obj : pointsTo) {
+      obj->DumpDotFile(fout, dumped, dumpPt, irMap);
+    }
+  } else {
+    for (auto outNode : out) {
+      std::string edgeStyle;
+      if (!outNode->IsObjectNode()) {
+        edgeStyle = " [style =\"dotted\"]";
+      }
+      fout << name << "->" << outNode->GetName(nullptr) << edgeStyle << ";\n";
+    }
+    for (auto outNode : out) {
+      outNode->DumpDotFile(fout, dumped, dumpPt, irMap);
+    }
+  }
+}
+
+bool EACGActualNode::ReplaceByGlobalNode() {
+  ASSERT(callSiteInfo == kInvalid, "must be invalid");
+  ASSERT(out.size() == 1, "the size of out must be one");
+  ASSERT(pointsTo.size() == 1, "the size of pointsTo must be one");
+  for (EACGBaseNode *inNode : in) {
+    inNode->out.erase(this);
+  }
+  in.clear();
+  return false;
+}
+
+void EACGFieldNode::DumpDotFile(std::ostream &fout, std::map<EACGBaseNode*, bool> &dumped, bool dumpPt,
+                                const IRMap *irMap) {
+  if (dumped[this]) {
+    return;
+  }
+  dumped[this] = true;
+  std::string name = GetName(nullptr);
+  std::string label = GetName(irMap) + "\\nFIdx : " + std::to_string(GetFieldID()) + "\\n";
+  std::string color;
+  GetNodeFormatInDot(label, color);
+  std::string style;
+  if (IsPhantom()) {
+    style = "dotted";
+  } else {
+    style = "bold";
+  }
+  fout << name << " [shape=circle, label=\"" << label << "\", fontcolor=" << color << ", style=" << style <<
+      ", margin=0];\n";
+  if (dumpPt) {
+    for (auto obj : pointsTo) {
+      fout << name << "->" << obj->GetName(nullptr) << ";\n";
+    }
+    for (auto obj : pointsTo) {
+      obj->DumpDotFile(fout, dumped, dumpPt, irMap);
+    }
+  } else {
+    for (auto outNode : out) {
+      std::string edgeStyle;
+      if (!outNode->IsObjectNode()) {
+        edgeStyle = " [style =\"dotted\"]";
+      }
+      fout << name << "->" << outNode->GetName(nullptr) << edgeStyle << ";\n";
+    }
+    for (auto outNode : out) {
+      outNode->DumpDotFile(fout, dumped, dumpPt, irMap);
+    }
+  }
+}
+
+bool EACGFieldNode::ReplaceByGlobalNode() {
+  for (EACGObjectNode *obj : pointsTo) {
+    obj->pointsBy.erase(this);
+  }
+  pointsTo.clear();
+  (void)pointsTo.insert(eaCG->GetGlobalObject());
+  for (EACGBaseNode *outNode : out) {
+    outNode->in.erase(this);
+  }
+  out.clear();
+  (void)out.insert(eaCG->GetGlobalObject());
+  bool canDelete = true;
+  std::set<EACGObjectNode*> tmp = belongsTo;
+  for (EACGObjectNode *obj : tmp) {
+    if (obj->GetEAStatus() != kGlobalEscape) {
+      canDelete = false;
+    } else {
+      belongsTo.erase(obj);
+    }
+  }
+  if (canDelete) {
+    ASSERT(eaCG->nodes[id - 1] == this, "must be this");
+    eaCG->nodes[id - 1] = nullptr;
+    for (EACGBaseNode *inNode : in) {
+      ASSERT(!inNode->IsObjectNode(), "must be ObjectNode");
+      inNode->out.erase(this);
+      (void)inNode->out.insert(eaCG->globalField);
+    }
+    for (auto exprPair : eaCG->expr2Nodes) {
+      size_t eraseSize = exprPair.second->erase(this);
+      if (eraseSize != 0 && exprPair.first->GetMeOp() != kMeOpIvar && exprPair.first->GetMeOp() != kMeOpOp) {
+        ASSERT(false, "must be kMeOpIvar or kMeOpOp");
+      }
+      if (exprPair.second->size() == 0) {
+        exprPair.second->insert(eaCG->globalField);
+      }
+    }
+    in.clear();
+    return true;
+  }
+  return false;
+}
+
+void EAConnectionGraph::DeleteEACG() const {
+  for (EACGBaseNode *node : nodes) {
+    if (node == nullptr) {
+      continue;
+    }
+    delete node;
+    node = nullptr;
+  }
+}
+
+void EAConnectionGraph::TrimGlobalNode() const {
+  for (EACGBaseNode *node : nodes) {
+    if (node == nullptr) {
+      continue;
+    }
+    constexpr int leastIdx = 3;
+    if (node->id <= leastIdx) {
+      continue;
+    }
+    bool canDelete = false;
+    if (node->GetEAStatus() == kGlobalEscape) {
+      canDelete = node->ReplaceByGlobalNode();
+    }
+#ifdef DEBUG
+    node->CheckAllConnectionInNodes();
+#endif
+    if (canDelete) {
+      delete node;
+      node = nullptr;
+    }
+  }
+}
+
+void EAConnectionGraph::InitGlobalNode() {
+  globalObj = CreateObjectNode(nullptr, kNoEscape, true, TyIdx(0));
+  globalRef = CreateReferenceNode(nullptr, kNoEscape, true);
+  (void)globalRef->AddOutNode(*globalObj);
+  (void)globalRef->AddOutNode(*globalRef);
+  globalField = CreateFieldNode(nullptr, kNoEscape, -1, globalObj, true);  // -1 expresses global
+  (void)globalField->AddOutNode(*globalObj);
+  (void)globalField->AddOutNode(*globalRef);
+  (void)globalField->AddOutNode(*globalField);
+  (void)globalRef->AddOutNode(*globalField);
+  globalObj->eaStatus = kGlobalEscape;
+  globalField->eaStatus = kGlobalEscape;
+  globalRef->eaStatus = kGlobalEscape;
+}
+
+EACGObjectNode *EAConnectionGraph::CreateObjectNode(MeExpr *expr, EAStatus initialEas,
+                                                    bool isPh, TyIdx tyIdx [[maybe_unused]]) {
+  EACGObjectNode *newObjNode =
+      new (std::nothrow) EACGObjectNode(mirModule, alloc, *this, expr, initialEas, nodes.size() + 1, isPh);
+  ASSERT_NOT_NULL(newObjNode);
+  nodes.push_back(newObjNode);
+  if (expr != nullptr) {
+    if (expr2Nodes.find(expr) == expr2Nodes.end()) {
+      expr2Nodes[expr] = alloc->GetMemPool()->New<MapleSet<EACGBaseNode*>>(alloc->Adapter());
+      expr2Nodes[expr]->insert(newObjNode);
+    } else {
+      ASSERT(false, "must find expr");
+    }
+  }
+  return newObjNode;
+}
+
+EACGPointerNode *EAConnectionGraph::CreatePointerNode(MeExpr *expr, EAStatus initialEas, int inderictL) {
+  EACGPointerNode *newPointerNode =
+      new (std::nothrow) EACGPointerNode(mirModule, alloc, *this, expr, initialEas, nodes.size() + 1, inderictL);
+  ASSERT_NOT_NULL(newPointerNode);
+  nodes.push_back(newPointerNode);
+  if (expr != nullptr) {
+    if (expr2Nodes.find(expr) == expr2Nodes.end()) {
+      expr2Nodes[expr] = alloc->GetMemPool()->New<MapleSet<EACGBaseNode*>>(alloc->Adapter());
+      expr2Nodes[expr]->insert(newPointerNode);
+    } else {
+      ASSERT(false, "must find expr");
+    }
+  }
+  return newPointerNode;
+}
+
+EACGRefNode *EAConnectionGraph::CreateReferenceNode(MeExpr *expr, EAStatus initialEas, bool isStatic) {
+  EACGRefNode *newRefNode =
+      new (std::nothrow) EACGRefNode(mirModule, alloc, *this, expr, initialEas, nodes.size() + 1, isStatic);
+  ASSERT_NOT_NULL(newRefNode);
+  nodes.push_back(newRefNode);
+  if (expr != nullptr) {
+    if (expr2Nodes.find(expr) == expr2Nodes.end()) {
+      expr2Nodes[expr] = alloc->GetMemPool()->New<MapleSet<EACGBaseNode*>>(alloc->Adapter());
+      expr2Nodes[expr]->insert(newRefNode);
+    } else {
+      ASSERT(false, "must find expr");
+    }
+    if (expr->GetMeOp() != kMeOpVar && expr->GetMeOp() != kMeOpAddrof &&
+        expr->GetMeOp() != kMeOpReg && expr->GetMeOp() != kMeOpOp) {
+      ASSERT(false, "must be kMeOpVar, kMeOpAddrof, kMeOpReg or kMeOpOp");
+    }
+  }
+  return newRefNode;
+}
+
+void EAConnectionGraph::TouchCallSite(uint32 callSiteInfo) {
+  CHECK_FATAL(callSite2Nodes.find(callSiteInfo) != callSite2Nodes.end(), "find failed");
+  if (callSite2Nodes[callSiteInfo] == nullptr) {
+    MapleVector<EACGBaseNode*> *tmp = alloc->GetMemPool()->New<MapleVector<EACGBaseNode*>>(alloc->Adapter());
+    callSite2Nodes[callSiteInfo] = tmp;
+  }
+}
+
+EACGActualNode *EAConnectionGraph::CreateActualNode(EAStatus initialEas, bool isReurtn, bool isPh,
+                                                    uint8 argIdx, uint32 callSiteInfo) {
+  MeExpr *expr = nullptr;
+  ASSERT(isPh, "must be ph");
+  ASSERT(callSiteInfo != 0, "must not be zero");
+  EACGActualNode *newActNode = new (std::nothrow) EACGActualNode(
+      mirModule, alloc, *this, expr, initialEas, nodes.size() + 1, isReurtn, isPh, argIdx, callSiteInfo);
+  ASSERT_NOT_NULL(newActNode);
+  nodes.push_back(newActNode);
+  if (expr != nullptr) {
+    if (expr2Nodes.find(expr) == expr2Nodes.end()) {
+      expr2Nodes[expr] = alloc->GetMemPool()->New<MapleSet<EACGBaseNode*>>(alloc->Adapter());
+      expr2Nodes[expr]->insert(newActNode);
+    } else {
+      ASSERT(false, "must find expr");
+    }
+  }
+  if (callSiteInfo != kInvalid) {
+    ASSERT(callSite2Nodes[callSiteInfo] != nullptr, "must touched before");
+    callSite2Nodes[callSiteInfo]->push_back(newActNode);
+#ifdef DEBUG
+    CheckArgNodeOrder(*callSite2Nodes[callSiteInfo]);
+#endif
+  } else {
+    funcArgNodes.push_back(newActNode);
+  }
+  return newActNode;
+}
+
+EACGFieldNode *EAConnectionGraph::CreateFieldNode(MeExpr *expr, EAStatus initialEas, FieldID fId,
+                                                  EACGObjectNode *belongTo, bool isPh) {
+  EACGFieldNode *newFieldNode = new (std::nothrow) EACGFieldNode(
+      mirModule, alloc, *this, expr, initialEas, nodes.size() + 1, fId, belongTo, isPh);
+  ASSERT_NOT_NULL(newFieldNode);
+  nodes.push_back(newFieldNode);
+  if (expr != nullptr) {
+    if (expr2Nodes.find(expr) == expr2Nodes.end()) {
+      expr2Nodes[expr] = alloc->GetMemPool()->New<MapleSet<EACGBaseNode*>>(alloc->Adapter());
+      expr2Nodes[expr]->insert(newFieldNode);
+    } else {
+      expr2Nodes[expr]->insert(newFieldNode);
+    }
+    if (expr->GetMeOp() != kMeOpIvar && expr->GetMeOp() != kMeOpOp) {
+      ASSERT(false, "must be kMeOpIvar or kMeOpOp");
+    }
+  }
+  return newFieldNode;
+}
+
+EACGBaseNode *EAConnectionGraph::GetCGNodeFromExpr(MeExpr *me) {
+  if (expr2Nodes.find(me) == expr2Nodes.end()) {
+    return nullptr;
+  }
+  return *(expr2Nodes[me]->begin());
+}
+
+void EAConnectionGraph::UpdateExprOfNode(EACGBaseNode &node, MeExpr *me) {
+  if (expr2Nodes.find(me) == expr2Nodes.end()) {
+    expr2Nodes[me] = alloc->GetMemPool()->New<MapleSet<EACGBaseNode*>>(alloc->Adapter());
+    expr2Nodes[me]->insert(&node);
+  } else {
+    if (node.IsFieldNode()) {
+      expr2Nodes[me]->insert(&node);
+    } else {
+      if (expr2Nodes[me]->find(&node) == expr2Nodes[me]->end()) {
+        CHECK_FATAL(false, "must be filed node");
+      }
+    }
+  }
+  node.SetMeExpr(*me);
+}
+
+void EAConnectionGraph::UpdateExprOfGlobalRef(MeExpr *me) {
+  UpdateExprOfNode(*globalRef, me);
+}
+
+EACGActualNode *EAConnectionGraph::GetReturnNode() const {
+  if (funcArgNodes.size() == 0) {
+    return nullptr;
+  }
+  EACGActualNode *ret = static_cast<EACGActualNode*>(funcArgNodes[funcArgNodes.size() - 1]);
+  if (ret->IsReturn()) {
+    return ret;
+  }
+  return nullptr;
+}
+#ifdef DEBUG
+void EAConnectionGraph::CheckArgNodeOrder(MapleVector<EACGBaseNode*> &funcArgV) {
+  uint8 preIndex = 0;
+  for (size_t i = 0; i < funcArgV.size(); ++i) {
+    ASSERT(funcArgV[i]->IsActualNode(), "must be ActualNode");
+    EACGActualNode *actNode = static_cast<EACGActualNode*>(funcArgV[i]);
+    if (i == funcArgV.size() - 1) {
+      if (actNode->IsReturn()) {
+        continue;
+      } else {
+        ASSERT(actNode->GetArgIndex() >= preIndex, "must be greater than preIndex");
+      }
+    } else {
+      ASSERT(!actNode->IsReturn(), "must be return");
+      ASSERT(actNode->GetArgIndex() >= preIndex, "must be greater than preIndex");
+    }
+    preIndex = actNode->GetArgIndex();
+  }
+}
+#endif
+bool EAConnectionGraph::ExprCanBeOptimized(MeExpr &expr) {
+  if (expr2Nodes.find(&expr) == expr2Nodes.end()) {
+    MeExpr *rhs = nullptr;
+    if (expr.GetMeOp() == kMeOpVar) {
+      ASSERT(static_cast<VarMeExpr*>(&expr)->GetDefBy() == kDefByStmt, "must be kDefByStmt");
+      ASSERT(static_cast<VarMeExpr*>(&expr)->GetDefStmt()->GetOp() == OP_dassign, "must be OP_dassign");
+      MeStmt *defStmt = static_cast<VarMeExpr*>(&expr)->GetDefStmt();
+      DassignMeStmt *dassignStmt = static_cast<DassignMeStmt*>(defStmt);
+      rhs = dassignStmt->GetRHS();
+    } else if (expr.GetMeOp() == kMeOpReg) {
+      ASSERT(static_cast<RegMeExpr*>(&expr)->GetDefBy() == kDefByStmt, "must be kDefByStmt");
+      ASSERT(static_cast<RegMeExpr*>(&expr)->GetDefStmt()->GetOp() == OP_regassign, "must be OP_regassign");
+      MeStmt *defStmt = static_cast<RegMeExpr*>(&expr)->GetDefStmt();
+      AssignMeStmt *regassignStmt = static_cast<AssignMeStmt*>(defStmt);
+      rhs = regassignStmt->GetRHS();
+    } else {
+      CHECK_FATAL(false, "impossible");
+    }
+    ASSERT(expr2Nodes.find(rhs) != expr2Nodes.end(), "impossible");
+    expr = *rhs;
+  }
+  MapleSet<EACGBaseNode*> &nodesTmp = *expr2Nodes[&expr];
+
+  for (EACGBaseNode *node : nodesTmp) {
+    for (EACGObjectNode *obj : node->GetPointsToSet()) {
+      if (obj->GetEAStatus() != kNoEscape && obj->GetEAStatus() != kReturnEscape) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+MapleVector<EACGBaseNode*> *EAConnectionGraph::GetCallSiteArgNodeVector(uint32 callSite) {
+  CHECK_FATAL(callSite2Nodes.find(callSite) != callSite2Nodes.end(), "find failed");
+  ASSERT_NOT_NULL(callSite2Nodes[callSite]);
+  return callSite2Nodes[callSite];
+}
+
+// if we have scc of connection graph, it will be more efficient.
+void EAConnectionGraph::PropogateEAStatus() {
+  bool oldStatus = CGHasUpdated();
+  do {
+    UnSetCGUpdateFlag();
+    for (EACGBaseNode *node : nodes) {
+      if (node == nullptr) {
+        continue;
+      }
+      if (node->IsObjectNode()) {
+        EACGObjectNode *obj = static_cast<EACGObjectNode*>(node);
+        for (auto fieldPair : obj->GetFieldNodeMap()) {
+          EACGBaseNode *field = fieldPair.second;
+          (void)field->UpdateEAStatus(obj->GetEAStatus());
+        }
+      } else {
+        for (EACGBaseNode *pointsToNode : node->GetPointsToSet()) {
+          (void)pointsToNode->UpdateEAStatus(node->GetEAStatus());
+        }
+      }
+    }
+    ASSERT(!CGHasUpdated(), "must be Updated");
+  } while (CGHasUpdated());
+  RestoreStatus(oldStatus);
+}
+
+const MapleVector<EACGBaseNode*> *EAConnectionGraph::GetFuncArgNodeVector() const {
+  return &funcArgNodes;
+}
+
+// this func is called from callee context
+void EAConnectionGraph::UpdateEACGFromCaller(const MapleVector<EACGBaseNode*> &callerCallSiteArg,
+                                             const MapleVector<EACGBaseNode*> &calleeFuncArg) {
+  ASSERT(abs(static_cast<int>(callerCallSiteArg.size()) - static_cast<int>(calleeFuncArg.size())) <= 1, "greater than");
+
+  UnSetCGUpdateFlag();
+  for (uint32 i = 0; i < callerCallSiteArg.size(); ++i) {
+    EACGBaseNode *callerNode = callerCallSiteArg[i];
+    ASSERT_NOT_NULL(callerNode);
+    ASSERT(callerNode->IsActualNode(), "must be ActualNode");
+    if ((i == callerCallSiteArg.size() - 1) && static_cast<EACGActualNode*>(callerNode)->IsReturn()) {
+      continue;
+    }
+    bool hasGlobalEA = false;
+    for (EACGObjectNode *obj : callerNode->GetPointsToSet()) {
+      if (obj->GetEAStatus() == kGlobalEscape) {
+        hasGlobalEA = true;
+        break;
+      }
+    }
+    if (hasGlobalEA) {
+      EACGBaseNode *calleeNode = (calleeFuncArg)[i];
+      for (EACGObjectNode *obj : calleeNode->GetPointsToSet()) {
+        (void)obj->UpdateEAStatus(kGlobalEscape);
+      }
+    }
+  }
+  if (CGHasUpdated()) {
+    PropogateEAStatus();
+  }
+  TrimGlobalNode();
+}
+
+void EAConnectionGraph::DumpDotFile(const IRMap *irMap, bool dumpPt, MapleVector<EACGBaseNode*> *dumpVec) {
+  if (dumpVec == nullptr) {
+    dumpVec = &nodes;
+  }
+  std::filebuf fb;
+  std::string outFile = GlobalTables::GetStrTable().GetStringFromStrIdx(funcStIdx) + "-connectiongraph.dot";
+  fb.open(outFile, std::ios::trunc | std::ios::out);
+  CHECK_FATAL(fb.is_open(), "open file failed");
+  std::ostream cgDotFile(&fb);
+  cgDotFile << "digraph connectiongraph{\n";
+  std::map<EACGBaseNode*, bool> dumped;
+  for (auto node : nodes) {
+    dumped[node] = false;
+  }
+  for (EACGBaseNode *node : *dumpVec) {
+    if (node == nullptr) {
+      continue;
+    }
+    if (dumped[node]) {
+      continue;
+    }
+    node->DumpDotFile(cgDotFile, dumped, dumpPt, irMap);
+    dumped[node] = true;
+  }
+  cgDotFile << "}\n";
+  fb.close();
+}
+
+void EAConnectionGraph::CountObjEAStatus() const {
+  int sum = 0;
+  int eaCount[4]; // There are four EAStatus.
+  for (size_t i = 0; i < 4; ++i) {
+    eaCount[i] = 0;
+  }
+  for (EACGBaseNode *node : nodes) {
+    if (node == nullptr) {
+      continue;
+    }
+
+    if (node->IsObjectNode()) {
+      EACGObjectNode *objNode = static_cast<EACGObjectNode*>(node);
+      if (!objNode->IsPhantom()) {
+        CHECK_FATAL(objNode->locInfo != nullptr, "Impossible");
+        MIRType *type = nullptr;
+        const MeExpr *expr = objNode->GetMeExpr();
+        CHECK_FATAL(expr != nullptr, "Impossible");
+        if (expr->GetOp() == OP_gcmalloc || expr->GetOp() == OP_gcpermalloc) {
+          TyIdx tyIdx = static_cast<const GcmallocMeExpr*>(expr)->GetTyIdx();
+          type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+        } else {
+          TyIdx tyIdx = static_cast<const OpMeExpr*>(expr)->GetTyIdx();
+          type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+        }
+        LogInfo::MapleLogger() << "[LOCATION] [" << objNode->locInfo->GetModName() << " " <<
+            objNode->locInfo->GetFileId() << " " << objNode->locInfo->GetLineId() << " " <<
+            EscapeName(objNode->GetEAStatus()) << " " << expr->GetExprID() << " ";
+        type->Dump(0, false);
+        LogInfo::MapleLogger() << "]\n";
+        ++sum;
+        ++eaCount[node->GetEAStatus()];
+      }
+    }
+  }
+  LogInfo::MapleLogger() << "[gcmalloc object statistics]  " <<
+      GlobalTables::GetStrTable().GetStringFromStrIdx(funcStIdx) << " " <<
+      "Gcmallocs: " << sum << " " << "NoEscape: " << eaCount[kNoEscape] << " " <<
+      "RetEscape: " << eaCount[kReturnEscape] << " " << "ArgEscape: " << eaCount[kArgumentEscape] << " " <<
+      "GlobalEscape: " << eaCount[kGlobalEscape] << "\n";
+}
+
+void EAConnectionGraph::RestoreStatus(bool old) {
+  if (old) {
+    SetCGHasUpdated();
+  } else {
+    UnSetCGUpdateFlag();
+  }
+}
+
+// Update caller's ConnectionGraph using callee's summary information.
+// If the callee's summary is not found, we just mark all the pointsTo nodes of caller's actual node to GlobalEscape.
+// Otherwise, we do these steps:
+// 1, update caller nodes using callee's summary, new node might be added into caller's CG in this step.
+// 2, update caller edges using callee's summary, new points-to edge might be added into caller's CG in this step.
+bool EAConnectionGraph::MergeCG(MapleVector<EACGBaseNode*> &caller, const MapleVector<EACGBaseNode*> *callee) {
+  TrimGlobalNode();
+  bool cgChanged = false;
+  bool oldStatus = CGHasUpdated();
+  UnSetCGUpdateFlag();
+  if (callee == nullptr) {
+    for (EACGBaseNode *actualInCaller : caller) {
+      for (EACGObjectNode *p : actualInCaller->GetPointsToSet()) {
+        (void)p->UpdateEAStatus(EAStatus::kGlobalEscape);
+      }
+    }
+    cgChanged = CGHasUpdated();
+    if (!cgChanged) {
+      RestoreStatus(oldStatus);
+    }
+    TrimGlobalNode();
+    return cgChanged;
+  }
+  size_t callerSize = caller.size();
+  size_t calleeSize = callee->size();
+  if (callerSize > calleeSize) {
+    ASSERT((callerSize - calleeSize) <= 1, "must be one in EAConnectionGraph::MergeCG()");
+  } else {
+    ASSERT((calleeSize - callerSize) <= 1, "must be one in EAConnectionGraph::MergeCG()");
+  }
+  if (callerSize == 0 || calleeSize == 0) {
+    cgChanged = CGHasUpdated();
+    if (!cgChanged) {
+      RestoreStatus(oldStatus);
+    }
+    return cgChanged;
+  }
+  if ((callerSize != calleeSize) &&
+      (callerSize != calleeSize + 1 || static_cast<EACGActualNode*>(callee->back())->IsReturn()) &&
+      (callerSize != calleeSize - 1 || !static_cast<EACGActualNode*>(callee->back())->IsReturn())) {
+    ASSERT(false, "Impossible");
+  }
+
+  callee2Caller.clear();
+  UpdateCallerNodes(caller, *callee);
+  UpdateCallerEdges();
+  UpdateCallerRetNode(caller, *callee);
+  callee2Caller.clear();
+
+  cgChanged = CGHasUpdated();
+  if (!cgChanged) {
+    RestoreStatus(oldStatus);
+  }
+  TrimGlobalNode();
+  return cgChanged;
+}
+
+void EAConnectionGraph::AddMaps2Object(EACGObjectNode *caller, EACGObjectNode *callee) {
+  if (callee2Caller.find(callee) == callee2Caller.end()) {
+    std::set<EACGObjectNode*> callerSet;
+    callee2Caller[callee] = callerSet;
+  }
+  (void)callee2Caller[callee].insert(caller);
+}
+
+void EAConnectionGraph::UpdateCallerRetNode(MapleVector<EACGBaseNode*> &caller,
+                                            const MapleVector<EACGBaseNode*> &callee) {
+  EACGActualNode *lastInCaller = static_cast<EACGActualNode*>(caller.back());
+  EACGActualNode *lastInCallee = static_cast<EACGActualNode*>(callee.back());
+  if (!lastInCaller->IsReturn()) {
+    return;
+  }
+  CHECK_FATAL(lastInCaller->GetOutSet().size() == 1, "Impossible");
+  for (EACGBaseNode *callerRetNode : lastInCaller->GetOutSet()) {
+    for (EACGObjectNode *calleeRetNode : lastInCallee->GetPointsToSet()) {
+      for (EACGObjectNode *objInCaller : callee2Caller[calleeRetNode]) {
+        auto pointsToSet = callerRetNode->GetPointsToSet();
+        if (pointsToSet.find(objInCaller) == pointsToSet.end()) {
+          (void)callerRetNode->AddOutNode(*objInCaller);
+        }
+      }
+    }
+  }
+}
+
+// Update caller node by adding some nodes which are mapped from callee.
+void EAConnectionGraph::UpdateCallerNodes(const MapleVector<EACGBaseNode*> &caller,
+                                          const MapleVector<EACGBaseNode*> &callee) {
+  const size_t callerSize = caller.size();
+  const size_t calleeSize = callee.size();
+  const size_t actualCount = ((callerSize < calleeSize) ? callerSize : calleeSize);
+  bool firstTime = true;
+
+  for (size_t i = 0; i < actualCount; ++i) {
+    EACGBaseNode *actualInCaller = caller.at(i);
+    EACGBaseNode *actualInCallee = callee.at(i);
+    UpdateNodes(*actualInCallee, *actualInCaller, firstTime);
+  }
+}
+
+// Update caller edges using information from callee.
+void EAConnectionGraph::UpdateCallerEdges() {
+  std::set<EACGObjectNode*> set;
+  for (auto pair : std::as_const(callee2Caller)) {
+    (void)set.insert(pair.first);
+  }
+  for (EACGObjectNode *p : set) {
+    for (auto tempPair : p->GetFieldNodeMap()) {
+      int32 fieldID = tempPair.first;
+      EACGBaseNode *fieldNode = tempPair.second;
+      for (EACGObjectNode *q : fieldNode->GetPointsToSet()) {
+        UpdateCallerEdgesInternal(p, fieldID, q);
+      }
+    }
+  }
+}
+
+// Update caller edges using information of given ObjectNode from callee.
+void EAConnectionGraph::UpdateCallerEdgesInternal(EACGObjectNode *node1, int32 fieldID, EACGObjectNode *node2) {
+  CHECK_FATAL(callee2Caller.find(node1) != callee2Caller.end(), "find failed");
+  CHECK_FATAL(callee2Caller.find(node2) != callee2Caller.end(), "find failed");
+  for (EACGObjectNode *p1 : callee2Caller[node1]) {
+    for (EACGObjectNode *q1 : callee2Caller[node2]) {
+      EACGFieldNode *fieldNode = p1->GetFieldNodeFromIdx(fieldID);
+      if (fieldNode == nullptr) {
+        CHECK_NULL_FATAL(node1);
+        fieldNode = node1->GetFieldNodeFromIdx(fieldID);
+        CHECK_FATAL(fieldNode != nullptr, "fieldNode must not be nullptr because we have handled it before!");
+        CHECK_FATAL(fieldNode->IsBelongTo(this), "must be belong to this");
+        (void)p1->AddOutNode(*fieldNode);
+      }
+      (void)fieldNode->AddOutNode(*q1);
+    }
+  }
+}
+
+void EAConnectionGraph::UpdateNodes(const EACGBaseNode &actualInCallee, EACGBaseNode &actualInCaller, bool firstTime) {
+  ASSERT(actualInCallee.GetPointsToSet().size() > 0, "actualInCallee->GetPointsToSet().size() must gt 0!");
+  for (EACGObjectNode *objInCallee : actualInCallee.GetPointsToSet()) {
+    if (actualInCaller.GetPointsToSet().size() == 0) {
+      std::set<EACGObjectNode*> &mapsTo = callee2Caller[objInCallee];
+      if (mapsTo.size() > 0) {
+        for (EACGObjectNode *temp : mapsTo) {
+          (void)actualInCaller.AddOutNode(*temp);
+        }
+      } else if (objInCallee->IsBelongTo(this)) {
+        ASSERT(false, "must be belong to this");
+      } else {
+        EACGObjectNode *phantom = CreateObjectNode(nullptr, actualInCaller.GetEAStatus(), true, TyIdx(0));
+        (void)actualInCaller.AddOutNode(*phantom);
+        AddMaps2Object(phantom, objInCallee);
+        UpdateCallerWithCallee(*phantom, *objInCallee, firstTime);
+      }
+    } else {
+      for (EACGObjectNode *objInCaller : actualInCaller.GetPointsToSet()) {
+        std::set<EACGObjectNode*> &mapsTo = callee2Caller[objInCallee];
+        if (mapsTo.find(objInCaller) == mapsTo.end()) {
+          AddMaps2Object(objInCaller, objInCallee);
+          UpdateCallerWithCallee(*objInCaller, *objInCallee, firstTime);
+        }
+      }
+    }
+  }
+}
+
+// The escape state of the nodes in MapsTo(which is the object node in caller) is marked
+// GlobalEscape if the escape state of object node in callee is GlobalEscape.
+// Otherwise, the escape state of the caller nodes is not affected.
+void EAConnectionGraph::UpdateCallerWithCallee(EACGObjectNode &objInCaller, const EACGObjectNode &objInCallee,
+                                               bool firstTime) {
+  if (objInCallee.GetEAStatus() == EAStatus::kGlobalEscape) {
+    (void)objInCaller.UpdateEAStatus(EAStatus::kGlobalEscape);
+  }
+
+  // At this moment, a node in caller is mapped to the corresponding node in callee,
+  // we need make sure that all the field nodes also exist in caller. If not,
+  // we create both the field node and the phantom object node it should point to for the caller.
+  for (auto tempPair : objInCallee.GetFieldNodeMap()) {
+    EACGFieldNode *fieldInCaller = objInCaller.GetFieldNodeFromIdx(tempPair.first);
+    EACGFieldNode *fieldInCallee = tempPair.second;
+    if (fieldInCaller == nullptr && fieldInCallee->IsBelongTo(this)) {
+      (void)objInCaller.AddOutNode(*fieldInCallee);
+    }
+    fieldInCaller = GetOrCreateFieldNodeFromIdx(objInCaller, tempPair.first);
+    UpdateNodes(*fieldInCallee, *fieldInCaller, firstTime);
+  }
+}
+
+EACGFieldNode *EAConnectionGraph::GetOrCreateFieldNodeFromIdx(EACGObjectNode &obj, int32 fieldID) {
+  EACGFieldNode *ret = obj.GetFieldNodeFromIdx(fieldID);
+  if (ret == nullptr) {
+    // this node is always phantom
+    ret = CreateFieldNode(nullptr, obj.GetEAStatus(), fieldID, &obj, true);
+  }
+  return ret;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ipa/src/old/ipa_escape_analysis.cpp b/src/mapleall/maple_ipa/src/old/ipa_escape_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..440c97bc05b82ca803e6e7604f159b8dccd71626
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/old/ipa_escape_analysis.cpp
@@ -0,0 +1,1614 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ipa_escape_analysis.h"
+#include <algorithm>
+#include "me_cfg.h"
+
+namespace maple {
+constexpr maple::uint32 kInvalid = 0xffffffff;
+static bool IsExprRefOrPtr(const MeExpr &expr) {
+  return expr.GetPrimType() == PTY_ref || expr.GetPrimType() == PTY_ptr;
+}
+
+static bool IsTypeRefOrPtr(PrimType type) {
+  return type == PTY_ref || type == PTY_ptr;
+}
+
+static bool IsGlobal(const SSATab &ssaTab, const VarMeExpr &expr) {
+  const OriginalSt *symOst = ssaTab.GetOriginalStFromID(expr.GetOstIdx());
+  ASSERT(symOst != nullptr, "null ptr check");
+  if (symOst->GetMIRSymbol()->GetStIdx().IsGlobal()) {
+    return true;
+  }
+  return false;
+}
+
+static bool IsGlobal(const SSATab &ssaTab, const AddrofMeExpr &expr) {
+  const OriginalSt *symOst = ssaTab.GetOriginalStFromID(expr.GetOstIdx());
+  ASSERT(symOst != nullptr, "null ptr check");
+  if (symOst->GetMIRSymbol()->GetStIdx().IsGlobal()) {
+    return true;
+  }
+  return false;
+}
+
+static bool IsZeroConst(const VarMeExpr *expr) {
+  if (expr == nullptr) {
+    return false;
+  }
+  if (expr->GetDefBy() != kDefByStmt) {
+    return false;
+  }
+  MeStmt *stmt = expr->GetDefStmt();
+  if (stmt->GetOp() != OP_dassign) {
+    return false;
+  }
+  DassignMeStmt *dasgn = static_cast<DassignMeStmt*>(stmt);
+  if (dasgn->GetRHS()->GetMeOp() != kMeOpConst) {
+    return false;
+  }
+  ConstMeExpr *constExpr = static_cast<ConstMeExpr*>(dasgn->GetRHS());
+  if (constExpr->GetConstVal()->GetKind() == kConstInt && constExpr->GetConstVal()->IsZero()) {
+    return true;
+  }
+  return false;
+}
+
+static bool StartWith(const std::string &str, const std::string &head) {
+  return str.compare(0, head.size(), head) == 0;
+}
+
+static bool IsVirtualVar(const SSATab &ssaTab, const VarMeExpr &expr) {
+  const OriginalSt *ost = ssaTab.GetOriginalStFromID(expr.GetOstIdx());
+  ASSERT(ost != nullptr, "null ptr check");
+  return ost->GetIndirectLev() > 0;
+}
+
+static bool IsInWhiteList(const MIRFunction &func) {
+  std::vector<std::string> whiteList = {
+      "MCC_Reflect_Check_Casting_Array",
+      "MCC_Reflect_Check_Casting_NoArray",
+      "MCC_ThrowStringIndexOutOfBoundsException",
+      "MCC_ArrayMap_String_Int_clear",
+      "MCC_ArrayMap_String_Int_put",
+      "MCC_ArrayMap_String_Int_getOrDefault",
+      "MCC_ArrayMap_String_Int_size",
+      "MCC_ThrowSecurityException",
+      "MCC_String_Equals_NotallCompress",
+      "memcmpMpl",
+      "Native_java_lang_String_compareTo__Ljava_lang_String_2",
+      "Native_java_lang_String_getCharsNoCheck__II_3CI",
+      "Native_java_lang_String_toCharArray__",
+      "Native_java_lang_System_arraycopyBooleanUnchecked___3ZI_3ZII",
+      "Native_java_lang_System_arraycopyByteUnchecked___3BI_3BII",
+      "Native_java_lang_System_arraycopyCharUnchecked___3CI_3CII",
+      "Native_java_lang_System_arraycopyDoubleUnchecked___3DI_3DII",
+      "Native_java_lang_System_arraycopyFloatUnchecked___3FI_3FII",
+      "Native_java_lang_System_arraycopyIntUnchecked___3II_3III",
+      "Native_java_lang_System_arraycopy__Ljava_lang_Object_2ILjava_lang_Object_2II",
+      "Native_java_lang_System_arraycopyLongUnchecked___3JI_3JII",
+      "Native_java_lang_System_arraycopyShortUnchecked___3SI_3SII",
+      "getpriority",
+      "setpriority"
+  };
+  for (std::string name : whiteList) {
+    if (func.GetName() == name) {
+      // close all the whitelist
+      return false;
+    }
+  }
+  return false;
+}
+
+static bool IsNoSideEffect(CallMeStmt &call) {
+  CallMeStmt &callAssign = utils::ToRef(&call);
+  MIRFunction &mirFunc = callAssign.GetTargetFunction();
+  if (IsInWhiteList(mirFunc)) {
+    return true;
+  }
+  // Non-nullptr means it has return value
+  CHECK_FATAL(callAssign.GetMustDefList() != nullptr, "Impossible");
+  if (callAssign.GetMustDefList()->size() == 1) {
+    if (callAssign.GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpVar &&
+        callAssign.GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpReg) {
+      CHECK_FATAL(false, "NYI");
+    }
+    if (IsExprRefOrPtr(*callAssign.GetMustDefListItem(0).GetLHS())) {
+      return false;
+    }
+  }
+
+  const MapleVector<MeExpr*> &opnds = call.GetOpnds();
+  const size_t size = opnds.size();
+  for (size_t i = 0; i < size; ++i) {
+    if (IsExprRefOrPtr(*opnds[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool IsRegAssignStmtForClassMeta(const AssignMeStmt &regAssign) {
+  MeExpr &rhs = utils::ToRef(regAssign.GetRHS());
+  if (rhs.GetOp() == OP_add) {
+    return true;
+  }
+
+  if (instance_of<IvarMeExpr>(rhs)) {
+    IvarMeExpr &ivar = static_cast<IvarMeExpr&>(rhs);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx());
+    MIRPtrType &ptrType = utils::ToRef(safe_cast<MIRPtrType>(type));
+    if (ptrType.GetPointedType()->GetName() == "__class_meta__" ||
+        (ptrType.GetPointedType()->GetName() == "Ljava_2Flang_2FObject_3B" && ivar.GetFieldID() == 1)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+TyIdx IPAEscapeAnalysis::GetAggElemType(const MIRType &aggregate) const {
+  switch (aggregate.GetKind()) {
+    case kTypePointer: {
+      const MIRPtrType *pointType = static_cast<const MIRPtrType*>(&aggregate);
+      const MIRType *pointedType = pointType->GetPointedType();
+      switch (pointedType->GetKind()) {
+        case kTypeClass:
+        case kTypeScalar:
+          return pointedType->GetTypeIndex();
+        case kTypePointer:
+        case kTypeJArray:
+          return GetAggElemType(*pointedType);
+        default:
+          return TyIdx(0);
+      }
+    }
+    case kTypeJArray: {
+      const MIRJarrayType *arrType = static_cast<const MIRJarrayType*>(&aggregate);
+      const MIRType *elemType = arrType->GetElemType();
+      CHECK_NULL_FATAL(elemType);
+      switch (elemType->GetKind()) {
+        case kTypeScalar:
+          return elemType->GetTypeIndex();
+        case kTypePointer:
+        case kTypeJArray:
+          return GetAggElemType(*elemType);
+        default:  // Not sure what type is
+          return TyIdx(0);
+      }
+    }
+    default:
+      CHECK_FATAL(false, "Should not reach here");
+      return TyIdx(0);  // to eliminate compilation warning
+  }
+}
+
+// check whether the newly allocated object implements Runnable, Throwable, extends Reference or has a finalizer
+bool IPAEscapeAnalysis::IsSpecialEscapedObj(const MeExpr &alloc) const {
+  if (alloc.GetOp() == OP_gcpermalloc || alloc.GetOp() == OP_gcpermallocjarray) {
+    return true;
+  }
+  TyIdx tyIdx;
+  const static TyIdx runnableInterface = kh->GetKlassFromLiteral("Ljava_2Flang_2FRunnable_3B")->GetTypeIdx();
+  if (alloc.GetOp() == OP_gcmalloc) {
+    tyIdx = static_cast<const GcmallocMeExpr*>(&alloc)->GetTyIdx();
+  } else {
+    CHECK_FATAL(alloc.GetOp() == OP_gcmallocjarray, "must be OP_gcmallocjarray");
+    MIRType *arrType =
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<const OpMeExpr*>(&alloc)->GetTyIdx());
+    tyIdx = GetAggElemType(*arrType);
+    if (tyIdx == TyIdx(0)) {
+      return true;  // deal as escape
+    }
+  }
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  if (type->GetKind() == kTypeScalar) {
+    return false;
+  }
+  Klass *klass = kh->GetKlassFromTyIdx(tyIdx);
+  CHECK_FATAL(klass, "impossible");
+  for (Klass *inter : klass->GetImplInterfaces()) {
+    if (inter->GetTypeIdx() == runnableInterface) {
+      return true;
+    }
+  }
+  if (klass->HasFinalizer() || klass->IsExceptionKlass()) {
+    return true;
+  }
+
+  // check subclass of Reference class, such as WeakReference, PhantomReference, SoftReference and Cleaner
+  const static Klass *referenceKlass = kh->GetKlassFromLiteral("Ljava_2Flang_2Fref_2FReference_3B");
+  if (kh->IsSuperKlass(referenceKlass, klass)) {
+    return true;
+  }
+  return false;
+}
+
+EACGRefNode *IPAEscapeAnalysis::GetOrCreateCGRefNodeForReg(RegMeExpr &reg, bool createObjNode) {
+  EACGBaseNode *node = eaCG->GetCGNodeFromExpr(&reg);
+  EACGRefNode *refNode = nullptr;
+  if (node == nullptr) {
+    refNode = eaCG->CreateReferenceNode(&reg, kNoEscape, false);
+    cgChangedInSCC = true;
+  } else {
+    refNode = static_cast<EACGRefNode*>(node);
+  }
+  if (node == nullptr && createObjNode) {
+    EACGObjectNode *objNode = GetOrCreateCGObjNode(nullptr, nullptr, refNode->GetEAStatus());
+    (void)refNode->AddOutNode(*objNode);
+  }
+  return refNode;
+}
+
+EACGRefNode *IPAEscapeAnalysis::GetOrCreateCGRefNodeForAddrof(AddrofMeExpr &var, bool createObjNode) {
+  if (IsGlobal(*ssaTab, var)) {
+    eaCG->UpdateExprOfGlobalRef(&var);
+    return eaCG->GetGlobalReference();
+  }
+  EACGBaseNode *node = eaCG->GetCGNodeFromExpr(&var);
+  EACGRefNode *refNode = nullptr;
+  if (node == nullptr) {
+    refNode = eaCG->CreateReferenceNode(&var, kNoEscape, false);
+    cgChangedInSCC = true;
+  } else {
+    refNode = static_cast<EACGRefNode*>(node);
+  }
+  if (node == nullptr && createObjNode) {
+    EACGObjectNode *objNode = GetOrCreateCGObjNode(nullptr, nullptr, refNode->GetEAStatus());
+    (void)refNode->AddOutNode(*objNode);
+  }
+  return refNode;
+}
+
+EACGRefNode *IPAEscapeAnalysis::GetOrCreateCGRefNodeForVar(VarMeExpr &var, bool createObjNode) {
+  if (IsGlobal(*ssaTab, var)) {
+    eaCG->UpdateExprOfGlobalRef(&var);
+    return eaCG->GetGlobalReference();
+  }
+  EACGBaseNode *node = eaCG->GetCGNodeFromExpr(&var);
+  EACGRefNode *refNode = nullptr;
+  if (node == nullptr) {
+    refNode = eaCG->CreateReferenceNode(&var, kNoEscape, false);
+    cgChangedInSCC = true;
+  } else {
+    refNode = static_cast<EACGRefNode*>(node);
+  }
+  if (node == nullptr && createObjNode) {
+    EACGObjectNode *objNode = GetOrCreateCGObjNode(nullptr, nullptr, refNode->GetEAStatus());
+    (void)refNode->AddOutNode(*objNode);
+  }
+  return refNode;
+}
+
+EACGRefNode *IPAEscapeAnalysis::GetOrCreateCGRefNodeForVarOrReg(MeExpr &var, bool createObjNode) {
+  if (var.GetMeOp() == kMeOpVar) {
+    return GetOrCreateCGRefNodeForVar(static_cast<VarMeExpr&>(var), createObjNode);
+  } else if (var.GetMeOp() == kMeOpReg) {
+    return GetOrCreateCGRefNodeForReg(static_cast<RegMeExpr&>(var), createObjNode);
+  }
+  CHECK_FATAL(false, "Impossible");
+  return nullptr;
+}
+
+static FieldID GetBaseFieldId(const KlassHierarchy &kh, const TyIdx &tyIdx, FieldID fieldId) {
+  FieldID ret = fieldId;
+  Klass *klass = kh.GetKlassFromTyIdx(tyIdx);
+  CHECK_FATAL(klass != nullptr, "Impossible");
+  Klass *super = klass->GetSuperKlass();
+  if (super == nullptr) {
+    return ret;
+  }
+  MIRStructType *structType = super->GetMIRStructType();
+  TyIdx typeIdx = structType->GetFieldTyIdx(fieldId - 1);
+  while (typeIdx != 0u) {
+    --ret;
+    klass = super;
+    super = klass->GetSuperKlass();
+    if (super == nullptr) {
+      return ret;
+    }
+    structType = super->GetMIRStructType();
+    typeIdx = structType->GetFieldTyIdx(ret - 1);
+  }
+  return ret;
+}
+
+void IPAEscapeAnalysis::GetOrCreateCGFieldNodeForIvar(std::vector<EACGBaseNode*> &fieldNodes, IvarMeExpr &ivar,
+                                                      MeStmt &stmt, bool createObjNode) {
+  MeExpr *base = ivar.GetBase();
+  FieldID fieldId = ivar.GetFieldID();
+  std::vector<EACGBaseNode*> baseNodes;
+  if (base->GetMeOp() == kMeOpReg && fieldId == 0) {
+    GetArrayBaseNodeForReg(baseNodes, static_cast<RegMeExpr&>(*base), stmt);
+  } else {
+    GetCGNodeForMeExpr(baseNodes, *base, stmt, true);
+  }
+  bool ifHandled = (eaCG->GetCGNodeFromExpr(&ivar) != nullptr);
+  if (ivar.GetFieldID() != 0) {
+    MIRPtrType *ptrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx()));
+    TyIdx tyIdx = ptrType->GetPointedTyIdx();
+    fieldId = GetBaseFieldId(*kh, tyIdx, ivar.GetFieldID());
+  }
+  for (const auto &baseNode : baseNodes) {
+    for (const auto &objNode : baseNode->GetPointsToSet()) {
+      EACGFieldNode *fieldNode = objNode->GetFieldNodeFromIdx(fieldId);
+      if (!ifHandled && fieldNode != nullptr) {
+        eaCG->UpdateExprOfNode(*fieldNode, &ivar);
+      } else if (!ifHandled && fieldNode == nullptr) {
+        fieldNode = eaCG->CreateFieldNode(&ivar, objNode->GetEAStatus(), fieldId, objNode, false);
+        cgChangedInSCC = true;
+        if (createObjNode) {
+          EACGObjectNode *phanObjNode = GetOrCreateCGObjNode(nullptr);
+          (void)fieldNode->AddOutNode(*phanObjNode);
+        }
+      }
+      if (fieldNode != nullptr) {
+        fieldNodes.push_back(fieldNode);
+      }
+    }
+  }
+}
+
+void IPAEscapeAnalysis::GetOrCreateCGFieldNodeForIAddrof(std::vector<EACGBaseNode*> &fieldNodes, OpMeExpr &expr,
+                                                         MeStmt &stmt, bool createObjNode) {
+  MeExpr *base = expr.GetOpnd(0);
+  FieldID fieldId = expr.GetFieldID();
+  std::vector<EACGBaseNode*> baseNodes;
+  if (base->GetMeOp() == kMeOpReg && fieldId == 0) {
+    GetArrayBaseNodeForReg(baseNodes, static_cast<RegMeExpr&>(*base), stmt);
+  } else {
+    GetCGNodeForMeExpr(baseNodes, *base, stmt, true);
+  }
+  bool ifHandled = (eaCG->GetCGNodeFromExpr(&expr) != nullptr);
+  if (expr.GetFieldID() != 0) {
+    MIRPtrType *ptrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(expr.GetTyIdx()));
+    TyIdx tyIdx = ptrType->GetPointedTyIdx();
+    fieldId = GetBaseFieldId(*kh, tyIdx, expr.GetFieldID());
+  }
+  for (const auto &baseNode : baseNodes) {
+    for (const auto &objNode : baseNode->GetPointsToSet()) {
+      EACGFieldNode *fieldNode = objNode->GetFieldNodeFromIdx(fieldId);
+      if (!ifHandled && fieldNode != nullptr) {
+        eaCG->UpdateExprOfNode(*fieldNode, &expr);
+      } else if (!ifHandled && fieldNode == nullptr) {
+        fieldNode = eaCG->CreateFieldNode(&expr, objNode->GetEAStatus(), fieldId, objNode, false);
+        cgChangedInSCC = true;
+        if (createObjNode) {
+          EACGObjectNode *phanObjNode = GetOrCreateCGObjNode(nullptr);
+          (void)fieldNode->AddOutNode(*phanObjNode);
+        }
+      }
+      if (fieldNode != nullptr) {
+        fieldNodes.push_back(fieldNode);
+      }
+    }
+  }
+}
+
+EACGObjectNode *IPAEscapeAnalysis::GetOrCreateCGObjNode(MeExpr *expr, const MeStmt *stmt, EAStatus easOfPhanObj) {
+  EAStatus eas = kNoEscape;
+  TyIdx tyIdx;
+  Location *location = nullptr;
+  bool isPhantom;
+  if (expr != nullptr) {
+    EACGBaseNode *cgNode = eaCG->GetCGNodeFromExpr(expr);
+    if (cgNode != nullptr) {
+      CHECK_FATAL(cgNode->IsObjectNode(), "should be object");
+      EACGObjectNode *objNode = static_cast<EACGObjectNode*>(cgNode);
+      return objNode;
+    }
+    if (expr->IsGcmalloc()) {
+      CHECK_FATAL(stmt != nullptr, "Impossible");
+      location = mirModule->GetMemPool()->New<Location>(mirModule->GetFileName(), stmt->GetSrcPosition().FileNum(),
+                                                        stmt->GetSrcPosition().LineNum());
+      isPhantom = false;
+      if (IsSpecialEscapedObj(*expr)) {
+        eas = kGlobalEscape;
+      }
+      if (expr->GetOp() == OP_gcmalloc || expr->GetOp() == OP_gcpermalloc) {
+        tyIdx = static_cast<GcmallocMeExpr*>(expr)->GetTyIdx();
+      } else {
+        tyIdx = static_cast<OpMeExpr*>(expr)->GetTyIdx();
+      }
+    } else {
+      isPhantom = true;
+      eas = easOfPhanObj;
+      tyIdx = kInitTyIdx;
+    }
+  } else {  // null alloc means creating phantom object
+    isPhantom = true;
+    eas = easOfPhanObj;
+    tyIdx = kInitTyIdx;
+  }
+  if (eas == kGlobalEscape) {
+    eaCG->UpdateExprOfNode(*eaCG->GetGlobalObject(), expr);
+    return eaCG->GetGlobalObject();
+  }
+  cgChangedInSCC = true;
+  EACGObjectNode *objectNode = eaCG->CreateObjectNode(expr, eas, isPhantom, tyIdx);
+  if (location != nullptr) {
+    objectNode->SetLocation(location);
+  }
+  return objectNode;
+}
+
+void IPAEscapeAnalysis::CollectDefStmtForReg(std::set<RegMeExpr*> &visited, std::set<AssignMeStmt*> &defStmts,
+                                             RegMeExpr &regVar) {
+  if (regVar.GetDefBy() == kDefByStmt) {
+    AssignMeStmt *regAssignStmt = static_cast<AssignMeStmt*>(regVar.GetDefStmt());
+    (void)defStmts.insert(regAssignStmt);
+  } else if (regVar.GetDefBy() == kDefByPhi) {
+    if (visited.find(&regVar) == visited.end()) {
+      (void)visited.insert(&regVar);
+      MePhiNode &regPhiNode = regVar.GetDefPhi();
+      for (auto &reg : regPhiNode.GetOpnds()) {
+        CollectDefStmtForReg(visited, defStmts, static_cast<RegMeExpr&>(*reg));
+      }
+    }
+  } else {
+    CHECK_FATAL(false, "not kDefByStmt or kDefByPhi");
+  }
+}
+
+void IPAEscapeAnalysis::GetArrayBaseNodeForReg(std::vector<EACGBaseNode*> &nodes, RegMeExpr &regVar, MeStmt &stmt) {
+  std::set<AssignMeStmt*> defStmts;
+  std::set<RegMeExpr*> visited;
+  CollectDefStmtForReg(visited, defStmts, regVar);
+  for (auto &regAssignStmt : defStmts) {
+    MeExpr *rhs = regAssignStmt->GetRHS();
+    CHECK_FATAL(rhs != nullptr, "Impossible");
+    CHECK_FATAL(rhs->GetOp() == OP_array, "Impossible, funcName: %s", func->GetName().c_str());
+    NaryMeExpr *array = static_cast<NaryMeExpr*>(rhs);
+    CHECK_FATAL(array->GetOpnds().size() > 0, "access array->GetOpnds() failed");
+    MeExpr *base = array->GetOpnd(0);
+    std::vector<EACGBaseNode*> baseNodes;
+    GetCGNodeForMeExpr(baseNodes, *base, stmt, true);
+    for (auto baseNode : baseNodes) {
+      nodes.push_back(baseNode);
+    }
+  }
+}
+
+void IPAEscapeAnalysis::GetCGNodeForMeExpr(std::vector<EACGBaseNode*> &nodes, MeExpr &expr, MeStmt &stmt,
+                                           bool createObjNode) {
+  if (expr.GetMeOp() == kMeOpVar) {
+    VarMeExpr *var = static_cast<VarMeExpr*>(&expr);
+    EACGRefNode *refNode = GetOrCreateCGRefNodeForVar(*var, createObjNode);
+    nodes.push_back(refNode);
+  } else if (expr.GetMeOp() == kMeOpIvar) {
+    IvarMeExpr *ivar = static_cast<IvarMeExpr*>(&expr);
+    GetOrCreateCGFieldNodeForIvar(nodes, *ivar, stmt, createObjNode);
+  } else if (expr.IsGcmalloc()) {
+    EACGObjectNode *objNode = GetOrCreateCGObjNode(&expr, &stmt);
+    nodes.push_back(objNode);
+  } else if (expr.GetMeOp() == kMeOpReg) {
+    RegMeExpr *regVar = static_cast<RegMeExpr*>(&expr);
+    if (regVar->GetRegIdx() < 0) {
+      eaCG->UpdateExprOfNode(*eaCG->GetGlobalObject(), &expr);
+      EACGObjectNode *objNode = eaCG->GetGlobalObject();
+      nodes.push_back(objNode);
+    } else {
+      if (regVar->GetDefBy() != kDefByStmt && regVar->GetDefBy() != kDefByMustDef) {
+        CHECK_FATAL(false, "impossible");
+      }
+      EACGRefNode *refNode = GetOrCreateCGRefNodeForReg(*regVar, createObjNode);
+      nodes.push_back(refNode);
+    }
+  } else if (expr.GetMeOp() == kMeOpOp && (expr.GetOp() == OP_retype || expr.GetOp() == OP_cvt)) {
+    MeExpr *retypeRhs = (static_cast<OpMeExpr*>(&expr))->GetOpnd(0);
+    if (IsExprRefOrPtr(*retypeRhs)) {
+      GetCGNodeForMeExpr(nodes, *retypeRhs, stmt, createObjNode);
+    } else {
+      EACGObjectNode *objNode = nullptr;
+      VarMeExpr *var = static_cast<VarMeExpr*>(retypeRhs);
+      if (IsZeroConst(var)) {
+        objNode = GetOrCreateCGObjNode(&expr, nullptr, kNoEscape);
+      } else {
+        eaCG->UpdateExprOfNode(*eaCG->GetGlobalObject(), &expr);
+        objNode = eaCG->GetGlobalObject();
+      }
+      nodes.push_back(objNode);
+    }
+  } else if (expr.GetMeOp() == kMeOpOp && expr.GetOp() == OP_select) {
+    OpMeExpr *opMeExpr = static_cast<OpMeExpr*>(&expr);
+    EACGBaseNode *refNode = eaCG->GetCGNodeFromExpr(opMeExpr);
+    if (refNode == nullptr) {
+      refNode = eaCG->CreateReferenceNode(opMeExpr, kNoEscape, false);
+      for (size_t i = 1; i < 3; ++i) { // OP_select expr has three operands.
+        std::vector<EACGBaseNode*> opndNodes;
+        GetCGNodeForMeExpr(opndNodes, *opMeExpr->GetOpnd(i), stmt, true);
+        for (auto opndNode : opndNodes) {
+          (void)refNode->AddOutNode(*opndNode);
+        }
+      }
+    }
+    nodes.push_back(refNode);
+  } else if (expr.GetMeOp() == kMeOpAddrof && expr.GetOp() == OP_addrof) {
+    AddrofMeExpr *var = static_cast<AddrofMeExpr*>(&expr);
+    EACGRefNode *refNode = GetOrCreateCGRefNodeForAddrof(*var, createObjNode);
+    nodes.push_back(refNode);
+  } else if (expr.GetMeOp() == kMeOpOp && expr.GetOp() == OP_iaddrof) {
+    OpMeExpr *opExpr = static_cast<OpMeExpr*>(&expr);
+    GetOrCreateCGFieldNodeForIAddrof(nodes, *opExpr, stmt, createObjNode);
+  } else if (expr.GetMeOp() == kMeOpNary &&
+             (expr.GetOp() == OP_intrinsicopwithtype || expr.GetOp() == OP_intrinsicop)) {
+    NaryMeExpr *naryMeExpr = static_cast<NaryMeExpr*>(&expr);
+    if (naryMeExpr->GetIntrinsic() == INTRN_JAVA_CONST_CLASS) {
+      // get some class's "Class", metadata
+      eaCG->UpdateExprOfNode(*eaCG->GetGlobalObject(), &expr);
+      EACGObjectNode *objNode = eaCG->GetGlobalObject();
+      nodes.push_back(objNode);
+    } else if (naryMeExpr->GetIntrinsic() == INTRN_JAVA_MERGE) {
+      CHECK_FATAL(naryMeExpr->GetOpnds().size() == 1, "must have one opnd");
+      MeExpr *opnd = naryMeExpr->GetOpnd(0);
+      if (IsExprRefOrPtr(*opnd)) {
+        GetCGNodeForMeExpr(nodes, *opnd, stmt, createObjNode);
+      } else {
+        eaCG->UpdateExprOfNode(*eaCG->GetGlobalObject(), &expr);
+        EACGObjectNode *objNode = eaCG->GetGlobalObject();
+        nodes.push_back(objNode);
+      }
+    } else {
+      stmt.Dump(irMap);
+      CHECK_FATAL(false, "NYI");
+    }
+  } else if (expr.GetMeOp() == kMeOpNary && expr.GetOp() == OP_array) {
+    NaryMeExpr *array = static_cast<NaryMeExpr*>(&expr);
+    CHECK_FATAL(array->GetOpnds().size() > 0, "access array->GetOpnds() failed");
+    MeExpr *arrayBase = array->GetOpnd(0);
+    GetCGNodeForMeExpr(nodes, *arrayBase, stmt, createObjNode);
+  } else if (expr.GetMeOp() == kMeOpConst) {
+    ConstMeExpr *constExpr = static_cast<ConstMeExpr*>(&expr);
+    EACGObjectNode *objNode = nullptr;
+    if (constExpr->GetConstVal()->GetKind() == kConstInt && constExpr->IsZero()) {
+      objNode = GetOrCreateCGObjNode(&expr, nullptr, kNoEscape);
+    } else {
+      eaCG->UpdateExprOfNode(*eaCG->GetGlobalObject(), &expr);
+      objNode = eaCG->GetGlobalObject();
+    }
+    nodes.push_back(objNode);
+  } else if (expr.GetMeOp() == kMeOpConststr) {
+    nodes.push_back(eaCG->GetGlobalReference());
+    eaCG->UpdateExprOfGlobalRef(&expr);
+  } else {
+    stmt.Dump(irMap);
+    CHECK_FATAL(false, "NYI funcName: %s", func->GetName().c_str());
+  }
+}
+
+void IPAEscapeAnalysis::UpdateEscConnGraphWithStmt(MeStmt &stmt) {
+  switch (stmt.GetOp()) {
+    case OP_dassign: {
+      DassignMeStmt *dasgn = static_cast<DassignMeStmt*>(&stmt);
+      if (!IsExprRefOrPtr(*dasgn->GetLHS())) {
+        break;
+      }
+      CHECK_FATAL(IsExprRefOrPtr(*dasgn->GetRHS()), "type mis-match");
+      EACGRefNode *lhsNode = GetOrCreateCGRefNodeForVar(*static_cast<VarMeExpr*>(dasgn->GetVarLHS()), false);
+
+      std::vector<EACGBaseNode*> rhsNodes;
+      GetCGNodeForMeExpr(rhsNodes, *dasgn->GetRHS(), stmt, true);
+      for (const auto &rhsNode : rhsNodes) {
+        cgChangedInSCC = (lhsNode->AddOutNode(*rhsNode) ? true : cgChangedInSCC);
+      }
+      break;
+    }
+    case OP_iassign: {
+      IassignMeStmt *iasgn = static_cast<IassignMeStmt*>(&stmt);
+      if (!IsExprRefOrPtr(*iasgn->GetLHSVal())) {
+        break;
+      }
+      CHECK_FATAL(IsExprRefOrPtr(*iasgn->GetRHS()), "type mis-match");
+      // get or create field nodes for lhs (may need to create a phantom object node)
+      std::vector<EACGBaseNode*> lhsNodes;
+      GetOrCreateCGFieldNodeForIvar(lhsNodes, *iasgn->GetLHSVal(), stmt, false);
+      std::vector<EACGBaseNode*> rhsNodes;
+      GetCGNodeForMeExpr(rhsNodes, *iasgn->GetRHS(), stmt, true);
+      for (const auto &lhsNode : lhsNodes) {
+        for (const auto &rhsNode : rhsNodes) {
+          cgChangedInSCC = (lhsNode->AddOutNode(*rhsNode) ? true : cgChangedInSCC);
+        }
+      }
+      break;
+    }
+    case OP_maydassign: {
+      MaydassignMeStmt *mdass = static_cast<MaydassignMeStmt*>(&stmt);
+      CHECK_FATAL(mdass->GetChiList() != nullptr, "Impossible");
+      if (mdass->GetChiList()->empty() || !IsExprRefOrPtr(*mdass->GetRHS())) {
+        break;
+      }
+      for (auto &it : std::as_const(*mdass->GetChiList())) {
+        ChiMeNode *chi = it.second;
+        CHECK_FATAL(IsExprRefOrPtr(*chi->GetLHS()), "type mis-match");
+        EACGRefNode *lhsNode = GetOrCreateCGRefNodeForVar(*static_cast<VarMeExpr *>(chi->GetLHS()), false);
+        std::vector<EACGBaseNode*> rhsNodes;
+        GetCGNodeForMeExpr(rhsNodes, *mdass->GetRHS(), stmt, true);
+        for (const auto &rhsNode : rhsNodes) {
+          cgChangedInSCC = (lhsNode->AddOutNode(*rhsNode) ? true : cgChangedInSCC);
+        }
+      }
+      break;
+    }
+    case OP_regassign: {
+      AssignMeStmt *regasgn = static_cast<AssignMeStmt*>(&stmt);
+      CHECK_FATAL(regasgn->GetLHS() != nullptr, "Impossible");
+      CHECK_FATAL(regasgn->GetRHS() != nullptr, "Impossible");
+      if (!IsExprRefOrPtr(*regasgn->GetLHS())) {
+        break;
+      }
+      CHECK_FATAL(IsExprRefOrPtr(*regasgn->GetRHS()), "type mis-match");
+      if (IsRegAssignStmtForClassMeta(*regasgn) || regasgn->GetRHS()->GetOp() == OP_array) {
+        break;
+      }
+      EACGRefNode *lhsNode = GetOrCreateCGRefNodeForReg(*regasgn->GetLHS(), false);
+      std::vector<EACGBaseNode*> rhsNodes;
+      GetCGNodeForMeExpr(rhsNodes, *regasgn->GetRHS(), stmt, true);
+      for (const auto &rhsNode : rhsNodes) {
+        cgChangedInSCC = (lhsNode->AddOutNode(*rhsNode) ? true : cgChangedInSCC);
+      }
+      break;
+    }
+    case OP_throw: {
+      ThrowMeStmt *throwStmt = static_cast<ThrowMeStmt*>(&stmt);
+      std::vector<EACGBaseNode*> nodes;
+      GetCGNodeForMeExpr(nodes, *throwStmt->GetOpnd(), stmt, true);
+      for (const auto &node : nodes) {
+        for (const auto &objNode : node->GetPointsToSet()) {
+          if (objNode->GetEAStatus() != kGlobalEscape) {
+            (void)objNode->UpdateEAStatus(kGlobalEscape);
+            cgChangedInSCC = true;
+          }
+        }
+      }
+      break;
+    }
+    case OP_return: {
+      RetMeStmt *retMeStmt = static_cast<RetMeStmt*>(&stmt);
+      EACGActualNode *retNode = eaCG->GetReturnNode();
+      MIRFunction *mirFunc = func->GetMirFunc();
+      if (!IsTypeRefOrPtr(mirFunc->GetReturnType()->GetPrimType())) {
+        break;
+      }
+      if (retNode == nullptr && retMeStmt->GetOpnds().size() > 0) {
+        retNode = eaCG->CreateActualNode(kReturnEscape, true, true,
+                                         static_cast<uint8>(mirFunc->GetFormalCount()), kInvalid);
+        cgChangedInSCC = true;
+      }
+      for (const auto &expr : retMeStmt->GetOpnds()) {
+        if (!IsExprRefOrPtr(*expr)) {
+          continue;
+        }
+        if (expr->GetMeOp() != kMeOpVar && expr->GetMeOp() != kMeOpReg) {
+          CHECK_FATAL(false, "should be");
+        }
+        EACGRefNode *refNode = GetOrCreateCGRefNodeForVarOrReg(*expr, true);
+        cgChangedInSCC = (retNode->AddOutNode(*refNode) ? true : cgChangedInSCC);
+      }
+      break;
+    }
+    case OP_icall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_xintrinsiccall:
+    case OP_icallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_xintrinsiccallassigned: {
+      CHECK_FATAL(false, "NYI");
+      break;
+    }
+    case OP_intrinsiccall: {
+      IntrinsiccallMeStmt *intrn = static_cast<IntrinsiccallMeStmt*>(&stmt);
+      if (intrn->GetIntrinsic() != INTRN_MPL_CLEANUP_LOCALREFVARS &&
+          intrn->GetIntrinsic() != INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP &&
+          intrn->GetIntrinsic() != INTRN_MCCSetPermanent &&
+          intrn->GetIntrinsic() != INTRN_MCCIncRef &&
+          intrn->GetIntrinsic() != INTRN_MCCDecRef &&
+          intrn->GetIntrinsic() != INTRN_MCCIncDecRef &&
+          intrn->GetIntrinsic() != INTRN_MCCDecRefReset &&
+          intrn->GetIntrinsic() != INTRN_MCCIncDecRefReset &&
+          intrn->GetIntrinsic() != INTRN_MCCWrite &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteNoDec &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteNoInc &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteNoRC &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteReferent &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteS &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteSNoInc &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteSNoDec &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteSNoRC &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteSVol &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteSVolNoInc &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteSVolNoDec &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteSVolNoRC &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteVol &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteVolNoInc &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteVolNoDec &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteVolNoRC &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteVolWeak &&
+          intrn->GetIntrinsic() != INTRN_MCCWriteWeak &&
+          intrn->GetIntrinsic() != INTRN_MCCDecRefResetPair) {
+        CHECK_FATAL(false, "intrnId: %d in function: %s", intrn->GetIntrinsic(), func->GetName().c_str());
+      }
+
+      if (intrn->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS ||
+          intrn->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP ||
+          intrn->GetIntrinsic() == INTRN_MCCSetPermanent ||
+          intrn->GetIntrinsic() == INTRN_MCCIncRef ||
+          intrn->GetIntrinsic() == INTRN_MCCDecRef ||
+          intrn->GetIntrinsic() == INTRN_MCCIncDecRef ||
+          intrn->GetIntrinsic() == INTRN_MCCDecRefReset ||
+          intrn->GetIntrinsic() == INTRN_MCCIncDecRefReset ||
+          intrn->GetIntrinsic() == INTRN_MCCWriteReferent ||
+          intrn->GetIntrinsic() == INTRN_MCCDecRefResetPair) {
+        break;
+      }
+
+      CHECK_FATAL(intrn->GetOpnds().size() > 1, "must be");
+      const size_t opndIdx = 2;
+      MeExpr *lhs = intrn->GetOpnd(intrn->NumMeStmtOpnds() - opndIdx);
+      MeExpr *rhs = intrn->GetOpnds().back();
+      std::vector<EACGBaseNode*> lhsNodes;
+      GetCGNodeForMeExpr(lhsNodes, *lhs, stmt, false);
+      std::vector<EACGBaseNode*> rhsNodes;
+      GetCGNodeForMeExpr(rhsNodes, *rhs, stmt, true);
+      for (auto lhsNode : lhsNodes) {
+        for (auto rhsNode : rhsNodes) {
+          (void)lhsNode->AddOutNode(*rhsNode);
+        }
+      }
+      break;
+    }
+    case OP_call:
+    case OP_callassigned:
+    case OP_superclasscallassigned:
+    case OP_interfaceicallassigned:
+    case OP_interfacecallassigned:
+    case OP_virtualicallassigned:
+    case OP_virtualcallassigned: {
+      CallMeStmt *callMeStmt = static_cast<CallMeStmt*>(&stmt);
+      MIRFunction &mirFunc = callMeStmt->GetTargetFunction();
+      uint32 callInfo = callMeStmt->GetStmtID();
+      if (callInfo == 0) {
+        if (mirFunc.GetName() != "MCC_SetObjectPermanent" && mirFunc.GetName() != "MCC_DecRef_NaiveRCFast") {
+          CHECK_FATAL(false, "funcName: %s", mirFunc.GetName().c_str());
+        }
+        break;
+      }
+      eaCG->TouchCallSite(callInfo);
+
+      // If a function has no reference parameter or return value, then skip it.
+      if (IsNoSideEffect(*callMeStmt)) {
+        HandleParaAtCallSite(callInfo, *callMeStmt);
+        break;
+      }
+
+      HandleParaAtCallSite(callInfo, *callMeStmt);
+      if (stmt.GetOp() == OP_call || stmt.GetOp() == OP_callassigned || stmt.GetOp() == OP_superclasscallassigned) {
+        if (IPAEscapeAnalysis::kDebug) {
+          LogInfo::MapleLogger() << "[INVOKE] call func " << mirFunc.GetName() << "\n";
+        }
+        HandleSingleCallee(*callMeStmt);
+      } else {
+        if (IPAEscapeAnalysis::kDebug) {
+          LogInfo::MapleLogger() << "[INVOKE] vcall func " << mirFunc.GetName() << "\n";
+        }
+        HandleMultiCallees(*callMeStmt);
+      }
+      break;
+    }
+    // mainly for JAVA_CLINIT_CHECK
+    case OP_intrinsiccallwithtype: {
+      IntrinsiccallMeStmt *intrnMestmt = static_cast<IntrinsiccallMeStmt*>(&stmt);
+      if (intrnMestmt->GetIntrinsic() != INTRN_JAVA_CLINIT_CHECK &&
+          intrnMestmt->GetIntrinsic() != INTRN_JAVA_CHECK_CAST) {
+        CHECK_FATAL(false, "intrnId: %d in function: %s", intrnMestmt->GetIntrinsic(), func->GetName().c_str());
+      }
+      // 1. INTRN_JAVA_CLINIT_CHECK: Because all the operations in clinit are to initialize the static field
+      //    of the Class, this will not affect the escape status of any reference or object node.
+      // 2. INTRN_JAVA_CHECK_CAST: When mephase precheckcast is enabled, this will happen, we only hava to solve
+      //    the next dassign stmt.
+      break;
+    }
+    // mainly for JAVA_ARRAY_FILL and JAVA_POLYMORPHIC_CALL
+    case OP_intrinsiccallassigned: {
+      IntrinsiccallMeStmt *intrnMestmt = static_cast<IntrinsiccallMeStmt*>(&stmt);
+      if (intrnMestmt->GetIntrinsic() == INTRN_JAVA_POLYMORPHIC_CALL) {
+        // this intrinsiccall is MethodHandle.invoke, it is a native method.
+        const MapleVector<MeExpr*> &opnds = intrnMestmt->GetOpnds();
+        const size_t size = opnds.size();
+        for (size_t i = 0; i < size; ++i) {
+          MeExpr *var = opnds[i];
+          // we only solve reference node.
+          if (!IsExprRefOrPtr(*var)) {
+            continue;
+          }
+          std::vector<EACGBaseNode*> nodes;
+          GetCGNodeForMeExpr(nodes, *var, *intrnMestmt, true);
+          for (auto realArgNode : nodes) {
+            for (EACGObjectNode *obj : realArgNode->GetPointsToSet()) {
+              (void)obj->UpdateEAStatus(kGlobalEscape);
+            }
+          }
+        }
+        CHECK_FATAL(intrnMestmt->GetMustDefList()->size() <= 1, "Impossible");
+        if (intrnMestmt->GetMustDefList()->size() == 0) {
+          break;
+        }
+        if (intrnMestmt->GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpVar &&
+            intrnMestmt->GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpReg) {
+          CHECK_FATAL(false, "impossible");
+        }
+        if (!IsExprRefOrPtr(*intrnMestmt->GetMustDefListItem(0).GetLHS())) {
+          break;
+        }
+        EACGRefNode *realRetNode = GetOrCreateCGRefNodeForVarOrReg(*intrnMestmt->GetMustDefListItem(0).GetLHS(), true);
+        for (EACGObjectNode *obj : realRetNode->GetPointsToSet()) {
+          (void)obj->UpdateEAStatus(kGlobalEscape);
+        }
+        break;
+      } else if (intrnMestmt->GetIntrinsic() == INTRN_JAVA_ARRAY_FILL) {
+        // JAVA_ARRAY_FILL can be skipped.
+        break;
+      } else {
+        if (intrnMestmt->GetIntrinsic() != INTRN_MCCIncRef &&
+            intrnMestmt->GetIntrinsic() != INTRN_MCCLoadRef &&
+            intrnMestmt->GetIntrinsic() != INTRN_MCCLoadRefS &&
+            intrnMestmt->GetIntrinsic() != INTRN_MCCLoadRefSVol &&
+            intrnMestmt->GetIntrinsic() != INTRN_MCCLoadRefVol &&
+            intrnMestmt->GetIntrinsic() != INTRN_MCCLoadWeak &&
+            intrnMestmt->GetIntrinsic() != INTRN_MCCLoadWeakVol) {
+          CHECK_FATAL(false, "intrnId: %d in function: %s", intrnMestmt->GetIntrinsic(), func->GetName().c_str());
+        }
+
+        CHECK_FATAL(intrnMestmt->GetMustDefList()->size() == 1, "Impossible");
+        if (intrnMestmt->GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpVar &&
+            intrnMestmt->GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpReg) {
+          CHECK_FATAL(false, "impossible");
+        }
+
+        if (!IsExprRefOrPtr(*intrnMestmt->GetMustDefListItem(0).GetLHS())) {
+          break;
+        }
+        EACGRefNode *retNode = GetOrCreateCGRefNodeForVarOrReg(*intrnMestmt->GetMustDefListItem(0).GetLHS(), false);
+        MeExpr *rhs = intrnMestmt->GetOpnds().back();
+        std::vector<EACGBaseNode*> rhsNodes;
+        GetCGNodeForMeExpr(rhsNodes, *rhs, stmt, true);
+        for (auto rhsNode : rhsNodes) {
+          (void)retNode->AddOutNode(*rhsNode);
+        }
+        break;
+      }
+    }
+    // mainly for JAVA_CHECK_CAST and JAVA_FILL_NEW_ARRAY
+    case OP_intrinsiccallwithtypeassigned: {
+      IntrinsiccallMeStmt *intrnMestmt = static_cast<IntrinsiccallMeStmt*>(&stmt);
+      if (intrnMestmt->GetIntrinsic() == INTRN_JAVA_CHECK_CAST) {
+        // We regard this as dassign
+        CHECK_FATAL(intrnMestmt->GetMustDefList()->size() <= 1, "Impossible");
+        if (intrnMestmt->GetMustDefList()->size() == 0) {
+          break;
+        }
+        CHECK_FATAL(intrnMestmt->GetMustDefListItem(0).GetLHS()->GetMeOp() == kMeOpVar, "must be kMeOpVar");
+        VarMeExpr *lhs = static_cast<VarMeExpr*>(intrnMestmt->GetMustDefListItem(0).GetLHS());
+        if (!IsExprRefOrPtr(*lhs)) {
+          break;
+        }
+        CHECK_FATAL(intrnMestmt->GetOpnds().size() == 1, "Impossible");
+        CHECK_FATAL(intrnMestmt->GetOpnd(0)->GetMeOp() == kMeOpVar, "must be kMeOpVar");
+        VarMeExpr *rhs = static_cast<VarMeExpr*>(intrnMestmt->GetOpnd(0));
+        CHECK_FATAL(IsExprRefOrPtr(*rhs), "type mis-match");
+        EACGRefNode *lhsNode = GetOrCreateCGRefNodeForVar(*lhs, false);
+        EACGRefNode *rhsNode = GetOrCreateCGRefNodeForVar(*rhs, true);
+        (void)lhsNode->AddOutNode(*rhsNode);
+      } else if (intrnMestmt->GetIntrinsic() == INTRN_JAVA_FILL_NEW_ARRAY) {
+        CHECK_FATAL(intrnMestmt->GetMustDefList()->size() == 1, "Impossible");
+        CHECK_FATAL(intrnMestmt->GetMustDefListItem(0).GetLHS()->GetMeOp() == kMeOpVar, "must be kMeOpVar");
+        VarMeExpr *lhs = static_cast<VarMeExpr*>(intrnMestmt->GetMustDefListItem(0).GetLHS());
+        if (!IsExprRefOrPtr(*lhs)) {
+          break;
+        }
+        EACGRefNode *lhsNode = GetOrCreateCGRefNodeForVar(*lhs, true);
+        CHECK_FATAL(intrnMestmt->GetOpnds().size() >= 1, "Impossible");
+        for (MeExpr *expr : intrnMestmt->GetOpnds()) {
+          CHECK_FATAL(expr->GetMeOp() == kMeOpVar, "Impossible");
+          VarMeExpr *rhs = static_cast<VarMeExpr*>(expr);
+          if (!IsExprRefOrPtr(*rhs)) {
+            continue;
+          }
+          EACGRefNode *rhsNode = GetOrCreateCGRefNodeForVar(*rhs, true);
+          for (const auto &objNode : lhsNode->GetPointsToSet()) {
+            // for array case, only one field node represents all elements
+            EACGFieldNode *fieldNode = objNode->GetFieldNodeFromIdx(0);
+            if (fieldNode == nullptr) {
+              fieldNode = eaCG->CreateFieldNode(nullptr, objNode->GetEAStatus(), 0, objNode, true);
+            }
+            (void)fieldNode->AddOutNode(*rhsNode);
+          }
+        }
+      } else {
+        CHECK_FATAL(false, "intrnId: %d in function: %s", intrnMestmt->GetIntrinsic(), func->GetName().c_str());
+      }
+      break;
+    }
+
+    default:
+      break;
+  }
+}
+
+EAConnectionGraph *IPAEscapeAnalysis::GetEAConnectionGraph(MIRFunction &function) const {
+  if (function.GetEACG() != nullptr) {
+    return function.GetEACG();
+  }
+  const std::map<GStrIdx, EAConnectionGraph*> &summaryMap = mirModule->GetEASummary();
+  GStrIdx nameStrIdx = function.GetNameStrIdx();
+  auto it = summaryMap.find(nameStrIdx);
+  if (it != summaryMap.end() && it->second != nullptr) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+void IPAEscapeAnalysis::HandleParaAtCallSite(uint32 callInfo, CallMeStmt &call) {
+  MapleVector<EACGBaseNode*> *argVector = eaCG->GetCallSiteArgNodeVector(callInfo);
+  if (argVector != nullptr && argVector->size() > 0) {
+    // We have handled this callsite before, skip it.
+    return;
+  }
+  const MapleVector<MeExpr*> &opnds = call.GetOpnds();
+  const uint32 size = static_cast<uint32>(opnds.size());
+
+  bool isOptIcall = (call.GetOp() == OP_interfaceicallassigned || call.GetOp() == OP_virtualicallassigned);
+  uint32 firstParmIdx = (isOptIcall ? 1 : 0);
+
+  for (uint32 i = firstParmIdx; i < size; ++i) {
+    MeExpr *var = opnds[i];
+    // we only solve reference node.
+    if (!IsExprRefOrPtr(*var) || var->GetOp() == OP_add) {
+      continue;
+    }
+    // for func(u, v), we assume that there exists assignment: a1 = u; a2 = v;
+    // a1, a2 are phantomArgNode and u, v are realArgNode, we add edge from a1 to u, etc.
+    EACGActualNode *phantomArgNode =
+        eaCG->CreateActualNode(kNoEscape, false, true, static_cast<uint8>(i), callInfo);
+    // node for u, v.
+    std::vector<EACGBaseNode*> nodes;
+    GetCGNodeForMeExpr(nodes, *var, call, true);
+    for (auto realArgNode : nodes) {
+      (void)phantomArgNode->AddOutNode(*realArgNode);
+    }
+  }
+  // Non-nullptr means it has return value
+  CHECK_FATAL(call.GetMustDefList() != nullptr, "Impossible");
+  if (call.GetMustDefList()->size() == 1) {
+    if (call.GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpVar &&
+        call.GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpReg) {
+      CHECK_FATAL(false, "NYI");
+    }
+    if (!IsExprRefOrPtr(*call.GetMustDefListItem(0).GetLHS())) {
+      return;
+    }
+    // for x = func(u, v), we assume that there exists assignment: r = x;
+    // r is a phantom return node, and x is the real return node, we add edge from r to x.
+    EACGActualNode *phantomRetNode =
+        eaCG->CreateActualNode(kNoEscape, true, true, static_cast<uint8>(size), callInfo);
+    // node for x
+    EACGRefNode *realRetNode = GetOrCreateCGRefNodeForVarOrReg(*call.GetMustDefListItem(0).GetLHS(), true);
+    (void)phantomRetNode->AddOutNode(*realRetNode);
+  }
+}
+
+void IPAEscapeAnalysis::HandleSingleCallee(CallMeStmt &callMeStmt) {
+  uint32 callInfoId = callMeStmt.GetStmtID();
+  MIRFunction &calleeCandidate = callMeStmt.GetTargetFunction();
+  if (IPAEscapeAnalysis::kDebug) {
+    LogInfo::MapleLogger() << "[MERGECG] ready to merge func " << calleeCandidate.GetName() << "\n";
+  }
+  if (calleeCandidate.IsAbstract()) {
+    CHECK_FATAL(false, "Impossible");
+    if (IPAEscapeAnalysis::kDebug) {
+      LogInfo::MapleLogger() << "[MERGECG] skip to merge func because it is abstract." << "\n";
+    }
+    return;
+  }
+
+  EAConnectionGraph *calleeSummary = GetEAConnectionGraph(calleeCandidate);
+
+  if (!mirModule->IsInIPA()) {
+    // This phase is in maplecomb, we need handle single callee differently
+    if (calleeSummary == nullptr) {
+      if (!calleeCandidate.IsNative() && !calleeCandidate.IsEmpty()) {
+        CHECK_FATAL(false, "Impossible");
+      }
+      bool changedAfterMerge = eaCG->MergeCG(*eaCG->GetCallSiteArgNodeVector(callInfoId), nullptr);
+      if (changedAfterMerge) {
+        cgChangedInSCC = true;
+      }
+    } else {
+      MapleVector<EACGBaseNode*> *caller = eaCG->GetCallSiteArgNodeVector(callInfoId);
+      const MapleVector<EACGBaseNode*> *callee = calleeSummary->GetFuncArgNodeVector();
+      bool changedAfterMerge = eaCG->MergeCG(*caller, callee);
+      if (changedAfterMerge) {
+        cgChangedInSCC = true;
+      }
+    }
+    return;
+  }
+
+  CGNode *callerNode = pcg->GetCGNode(func->GetMirFunc());
+  CHECK_FATAL(callerNode != nullptr, "Impossible, funcName: %s", func->GetName().c_str());
+  CGNode *calleeNode = pcg->GetCGNode(&calleeCandidate);
+  CHECK_FATAL(calleeNode != nullptr, "Impossible, funcName: %s", calleeCandidate.GetName().c_str());
+  if (calleeNode->GetSCCNode() == callerNode->GetSCCNode() &&
+      (eaCG->GetNeedConservation() ||
+       callerNode->GetSCCNode()->GetNodes().size() > IPAEscapeAnalysis::kFuncInSCCLimit)) {
+    bool changedAfterMerge = eaCG->MergeCG(*eaCG->GetCallSiteArgNodeVector(callInfoId), nullptr);
+    if (changedAfterMerge) {
+      cgChangedInSCC = true;
+    }
+    if (IPAEscapeAnalysis::kDebug) {
+      LogInfo::MapleLogger() << "[MERGECG] skip to merge func because NeedConservation." << "\n";
+    }
+    return;
+  }
+  if (calleeSummary == nullptr && calleeCandidate.GetBody() != nullptr && !calleeCandidate.IsNative()) {
+    if (IPAEscapeAnalysis::kDebug) {
+      LogInfo::MapleLogger() << "[MERGECG] skip to merge func because this is first loop in scc." << "\n";
+    }
+    return;
+  }
+  if (calleeSummary == nullptr) {
+    bool changedAfterMerge = eaCG->MergeCG(*eaCG->GetCallSiteArgNodeVector(callInfoId), nullptr);
+    if (changedAfterMerge) {
+      cgChangedInSCC = true;
+    }
+  } else {
+    MapleVector<EACGBaseNode*> *caller = eaCG->GetCallSiteArgNodeVector(callInfoId);
+    const MapleVector<EACGBaseNode*> *callee = calleeSummary->GetFuncArgNodeVector();
+    bool changedAfterMerge = eaCG->MergeCG(*caller, callee);
+    if (changedAfterMerge) {
+      cgChangedInSCC = true;
+    }
+  }
+}
+
+void IPAEscapeAnalysis::HandleMultiCallees(const CallMeStmt &callMeStmt) {
+  uint32 callInfoId = callMeStmt.GetStmtID();
+  bool changedAfterMerge = eaCG->MergeCG(*eaCG->GetCallSiteArgNodeVector(callInfoId), nullptr);
+  if (changedAfterMerge) {
+    cgChangedInSCC = true;
+  }
+}
+
+void IPAEscapeAnalysis::UpdateEscConnGraphWithPhi(const BB &bb) {
+  const MapleMap<OStIdx, MePhiNode*> &mePhiList = bb.GetMePhiList();
+  for (auto it = mePhiList.begin(); it != mePhiList.end(); ++it) {
+    MePhiNode *phiNode = it->second;
+    auto *lhs = phiNode->GetLHS();
+    if (lhs->GetMeOp() != kMeOpVar) {
+      continue;
+    }
+    if (!IsExprRefOrPtr(*lhs) || phiNode->GetOpnds().empty() ||
+        IsVirtualVar(*ssaTab, static_cast<VarMeExpr&>(*lhs))) {
+      continue;
+    }
+    EACGRefNode *lhsNode = GetOrCreateCGRefNodeForVar(static_cast<VarMeExpr&>(*lhs), false);
+    for (auto itt = phiNode->GetOpnds().begin(); itt != phiNode->GetOpnds().end(); ++itt) {
+      auto *var = static_cast<VarMeExpr*>(*itt);
+      EACGRefNode *rhsNode = GetOrCreateCGRefNodeForVar(*var, true);
+      cgChangedInSCC = (lhsNode->AddOutNode(*rhsNode) ? true : cgChangedInSCC);
+    }
+  }
+}
+
+void IPAEscapeAnalysis::HandleParaAtFuncEntry() {
+  if (!mirModule->IsInIPA()) {
+    CHECK_FATAL(eaCG == nullptr, "Impossible");
+  }
+
+  if (eaCG != nullptr) {
+    return;
+  }
+  MIRFunction *mirFunc = func->GetMirFunc();
+  eaCG = mirModule->GetMemPool()->New<EAConnectionGraph>(
+      mirModule, &mirModule->GetMPAllocator(), mirFunc->GetNameStrIdx());
+  eaCG->InitGlobalNode();
+  OriginalStTable &ostTab = ssaTab->GetOriginalStTable();
+  // create actual node for formal parameter
+  for (size_t i = 0; i < mirFunc->GetFormalCount(); ++i) {
+    MIRSymbol *mirSt = mirFunc->GetFormal(i);
+    OriginalSt *ost = ostTab.FindOrCreateSymbolOriginalSt(*mirSt, mirFunc->GetPuidx(), 0);
+    VarMeExpr *formal = irMap->GetOrCreateZeroVersionVarMeExpr(*ost);
+    if (IsExprRefOrPtr(*formal)) {
+      EACGActualNode *actualNode =
+          eaCG->CreateActualNode(kArgumentEscape, false, true, static_cast<uint8>(i), kInvalid);
+      EACGObjectNode *objNode = eaCG->CreateObjectNode(nullptr, kNoEscape, true, kInitTyIdx);
+      (void)actualNode->AddOutNode(*objNode);
+      EACGRefNode *formalNode = eaCG->CreateReferenceNode(formal, kNoEscape, false);
+      (void)formalNode->AddOutNode(*actualNode);
+    }
+  }
+}
+
+void IPAEscapeAnalysis::ConstructConnGraph() {
+  HandleParaAtFuncEntry();
+  auto cfg = func->GetCfg();
+  cfg->BuildSCC();
+  const MapleVector<SCCOfBBs*> &sccTopologicalVec = cfg->GetSccTopologicalVec();
+  for (size_t i = 0; i < sccTopologicalVec.size(); ++i) {
+    SCCOfBBs *scc = sccTopologicalVec[i];
+    CHECK_FATAL(scc != nullptr, "nullptr check");
+    if (scc->GetBBs().size() > 1) {
+      cfg->BBTopologicalSort(*scc);
+    }
+    cgChangedInSCC = true;
+    bool analyzeAgain = true;
+    while (analyzeAgain) {
+      analyzeAgain = false;
+      cgChangedInSCC = false;
+      for (BB *bb : scc->GetBBs()) {
+        if (bb == cfg->GetCommonEntryBB() || bb == cfg->GetCommonExitBB()) {
+          continue;
+        }
+        UpdateEscConnGraphWithPhi(*bb);
+        for (MeStmt *stmt = to_ptr(bb->GetMeStmts().begin()); stmt != nullptr; stmt = stmt->GetNextMeStmt()) {
+          UpdateEscConnGraphWithStmt(*stmt);
+        }
+      }
+      if (scc->HasCycle() && cgChangedInSCC) {
+        analyzeAgain = true;
+      }
+    }
+  }
+  eaCG->PropogateEAStatus();
+  func->GetMirFunc()->SetEACG(eaCG);
+}
+
+void IPAEscapeAnalysis::DoOptimization() {
+  CountObjRCOperations();
+  ProcessNoAndRetEscObj();
+  ProcessRetStmt();
+  DeleteRedundantRC();
+}
+
+VarMeExpr *IPAEscapeAnalysis::CreateEATempVarWithName(const std::string &name) const {
+  const auto &strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  VarMeExpr *var = irMap->CreateNewVar(strIdx, PTY_ref, false);
+  return var;
+}
+
+OriginalSt *IPAEscapeAnalysis::CreateEATempOst() {
+  std::string name = std::string("__EATemp__").append(std::to_string(++tempCount));
+  return CreateEATempOstWithName(name);
+}
+
+OriginalSt *IPAEscapeAnalysis::CreateEARetTempOst() const {
+  std::string name = std::string("__EARetTemp__");
+  return CreateEATempOstWithName(name);
+}
+
+OriginalSt *IPAEscapeAnalysis::CreateEATempOstWithName(const std::string &name) const {
+  MIRSymbol *symbol = func->GetMIRModule().GetMIRBuilder()->CreateLocalDecl(name,
+                                                                            *GlobalTables::GetTypeTable().GetRef());
+  OriginalSt *ost = ssaTab->CreateSymbolOriginalSt(*symbol, func->GetMirFunc()->GetPuidx(), 0);
+  ost->SetZeroVersionIndex(irMap->GetVerst2MeExprTable().size());
+  irMap->GetVerst2MeExprTable().push_back(nullptr);
+  ost->PushbackVersionsIndices(ost->GetZeroVersionIndex());
+  return ost;
+}
+
+VarMeExpr *IPAEscapeAnalysis::CreateEATempVarMeExpr(OriginalSt &ost) const {
+  VarMeExpr *var = irMap->CreateVarMeExprVersion(&ost);
+  return var;
+}
+
+VarMeExpr *IPAEscapeAnalysis::GetOrCreateEARetTempVarMeExpr(OriginalSt &ost) {
+  if (retVar != nullptr) {
+    return retVar;
+  }
+  retVar = CreateEATempVarMeExpr(ost);
+  return retVar;
+}
+
+VarMeExpr *IPAEscapeAnalysis::CreateEATempVar() {
+  std::string name = std::string("__EATemp__").append(std::to_string(++tempCount));
+  return CreateEATempVarWithName(name);
+}
+
+VarMeExpr *IPAEscapeAnalysis::GetOrCreateEARetTempVar() {
+  if (retVar != nullptr) {
+    return retVar;
+  }
+  std::string name = std::string("__EARetTemp__");
+  retVar = CreateEATempVarWithName(name);
+  return retVar;
+}
+
+void IPAEscapeAnalysis::ProcessNoAndRetEscObj() {
+  MeCFG *cfg = func->GetCfg();
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == cfg->GetCommonEntryBB() || bb == cfg->GetCommonExitBB() || bb == nullptr ||
+        bb->GetAttributes(kBBAttrIsInLoopForEA)) {
+      continue;
+    }
+
+    for (MeStmt *stmt = to_ptr(bb->GetMeStmts().begin()); stmt != nullptr; stmt = stmt->GetNextMeStmt()) {
+      if (stmt->GetOp() == OP_dassign || stmt->GetOp() == OP_regassign || stmt->GetOp() == OP_iassign ||
+          stmt->GetOp() == OP_maydassign) {
+        MeExpr *rhs = stmt->GetRHS();
+        CHECK_FATAL(rhs != nullptr, "nullptr check");
+        if (!rhs->IsGcmalloc()) {
+          continue;
+        }
+        CHECK_FATAL(func->GetMirFunc()->GetEACG() != nullptr, "Impossible");
+        EACGBaseNode *node = func->GetMirFunc()->GetEACG()->GetCGNodeFromExpr(rhs);
+        CHECK_FATAL(node != nullptr, "nullptr check");
+        CHECK_FATAL(node->IsObjectNode(), "impossible");
+        EAStatus eaStatus = node->GetEAStatus();
+        if ((eaStatus == kNoEscape) && (!static_cast<EACGObjectNode*>(node)->IsPointedByFieldNode()) &&
+            (static_cast<EACGObjectNode*>(node)->GetRCOperations() >= kRCOperLB)) {
+          static_cast<EACGObjectNode*>(node)->SetIgnorRC(true);
+          gcStmts.push_back(stmt);
+          OriginalSt *ost = CreateEATempOst();
+          noAndRetEscOst.push_back(ost);
+        }
+      }
+    }
+  }
+  if (noAndRetEscOst.size() == 0) {
+    return;
+  }
+  BB *firstBB = cfg->GetFirstBB();
+  CHECK_FATAL(firstBB != nullptr, "Impossible");
+  for (size_t i = 0; i < noAndRetEscOst.size(); ++i) {
+    OriginalSt *ost = noAndRetEscOst[i];
+    MeStmt *stmt = gcStmts.at(i);
+    BB *curBB = stmt->GetBB();
+    VarMeExpr *initVar = CreateEATempVarMeExpr(*ost);
+    MeExpr *zeroExpr = irMap->CreateIntConstMeExpr(0, PTY_ref);
+    DassignMeStmt *initStmt = static_cast<DassignMeStmt *>(irMap->CreateAssignMeStmt(*initVar, *zeroExpr, *firstBB));
+    firstBB->AddMeStmtFirst(initStmt);
+
+    VarMeExpr *var = CreateEATempVarMeExpr(*ost);
+    noAndRetEscObj.push_back(var);
+    ScalarMeExpr *lhs = stmt->GetLHS();
+    CHECK_FATAL(lhs != nullptr, "nullptr check");
+    DassignMeStmt *newStmt = static_cast<DassignMeStmt *>(irMap->CreateAssignMeStmt(*var, *lhs, *curBB));
+    curBB->InsertMeStmtAfter(stmt, newStmt);
+    IntrinsiccallMeStmt *meStmt = irMap->NewInPool<IntrinsiccallMeStmt>(OP_intrinsiccall, INTRN_MCCSetObjectPermanent);
+    meStmt->PushBackOpnd(var);
+    curBB->InsertMeStmtAfter(newStmt, meStmt);
+  }
+}
+
+void IPAEscapeAnalysis::ProcessRetStmt() {
+  if (noAndRetEscObj.size() == 0) {
+    return;
+  }
+  MeCFG *cfg = func->GetCfg();
+  BB *firstBB = cfg->GetFirstBB();
+  OriginalSt *ost = CreateEARetTempOst();
+  VarMeExpr *initVar = CreateEATempVarMeExpr(*ost);
+  MeExpr *zeroExpr = irMap->CreateIntConstMeExpr(0, PTY_ref);
+  DassignMeStmt *newStmt = static_cast<DassignMeStmt *>(irMap->CreateAssignMeStmt(*initVar, *zeroExpr, *firstBB));
+  ASSERT(firstBB != nullptr, "null ptr check");
+  firstBB->AddMeStmtFirst(newStmt);
+
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == cfg->GetCommonEntryBB() || bb == cfg->GetCommonExitBB() || bb == nullptr) {
+      continue;
+    }
+    for (MeStmt *stmt = to_ptr(bb->GetMeStmts().begin()); stmt != nullptr; stmt = stmt->GetNextMeStmt()) {
+      if (stmt->GetOp() == OP_return) {
+        RetMeStmt *retMeStmt = static_cast<RetMeStmt *>(stmt);
+        CHECK_FATAL(retMeStmt->GetOpnds().size() <= 1, "must less than one");
+        VarMeExpr *var = GetOrCreateEARetTempVarMeExpr(*ost);
+        for (const auto &expr : retMeStmt->GetOpnds()) {
+          if (IsExprRefOrPtr(*expr)) {
+            DassignMeStmt *newStmtTmp = static_cast<DassignMeStmt *>(irMap->CreateAssignMeStmt(*var, *expr, *bb));
+            bb->InsertMeStmtBefore(stmt, newStmtTmp);
+          }
+        }
+        IntrinsiccallMeStmt *meStmt = irMap->NewInPool<IntrinsiccallMeStmt>(
+            OP_intrinsiccall, INTRN_MPL_CLEANUP_NORETESCOBJS);
+        meStmt->PushBackOpnd(var);
+        for (auto opnd : noAndRetEscObj) {
+          meStmt->PushBackOpnd(opnd);
+        }
+        bb->InsertMeStmtBefore(stmt, meStmt);
+      }
+    }
+  }
+}
+
+void IPAEscapeAnalysis::CountObjRCOperations() {
+  MeCFG *cfg = func->GetCfg();
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == cfg->GetCommonEntryBB() || bb == cfg->GetCommonExitBB() || bb == nullptr) {
+      continue;
+    }
+    for (MeStmt *stmt = to_ptr(bb->GetMeStmts().begin()); stmt != nullptr; stmt = stmt->GetNextMeStmt()) {
+      switch (stmt->GetOp()) {
+        case OP_intrinsiccall: {
+          IntrinsiccallMeStmt *intrn = static_cast<IntrinsiccallMeStmt*>(stmt);
+          switch (intrn->GetIntrinsic()) {
+            case INTRN_MCCIncRef:
+            case INTRN_MCCIncDecRef:
+            case INTRN_MCCIncDecRefReset: {
+              CHECK_FATAL(eaCG->GetCGNodeFromExpr(intrn->GetOpnd(0)) != nullptr, "nullptr check");
+              std::vector<EACGBaseNode*> nodes;
+              GetCGNodeForMeExpr(nodes, *intrn->GetOpnd(0), *intrn, false);
+              for (auto refNode : nodes) {
+                for (auto objNode : refNode->GetPointsToSet()) {
+                  objNode->IncresRCOperations();
+                }
+              }
+              break;
+            }
+            case INTRN_MCCWrite:
+            case INTRN_MCCWriteNoDec:
+            case INTRN_MCCWriteS:
+            case INTRN_MCCWriteSNoDec:
+            case INTRN_MCCWriteSVol:
+            case INTRN_MCCWriteSVolNoDec:
+            case INTRN_MCCWriteVol:
+            case INTRN_MCCWriteVolNoDec:
+            case INTRN_MCCWriteVolWeak:
+            case INTRN_MCCWriteWeak: {
+              CHECK_FATAL(eaCG->GetCGNodeFromExpr(intrn->GetOpnds().back()) != nullptr, "nullptr check");
+              std::vector<EACGBaseNode*> nodes;
+              GetCGNodeForMeExpr(nodes, *intrn->GetOpnds().back(), *intrn, false);
+              for (auto refNode : nodes) {
+                for (auto objNode : refNode->GetPointsToSet()) {
+                  objNode->IncresRCOperations();
+                }
+              }
+              break;
+            }
+            default:
+              break;
+          }
+          break;
+        }
+        case OP_intrinsiccallassigned: {
+          IntrinsiccallMeStmt *intrn = static_cast<IntrinsiccallMeStmt*>(stmt);
+          switch (intrn->GetIntrinsic()) {
+            case INTRN_MCCIncRef:
+            case INTRN_MCCLoadRef:
+            case INTRN_MCCLoadRefS:
+            case INTRN_MCCLoadRefSVol:
+            case INTRN_MCCLoadRefVol:
+            case INTRN_MCCLoadWeak:
+            case INTRN_MCCLoadWeakVol: {
+              CHECK_FATAL(intrn->GetMustDefList()->size() == 1, "Impossible");
+              if (intrn->GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpVar &&
+                  intrn->GetMustDefListItem(0).GetLHS()->GetMeOp() != kMeOpReg) {
+                CHECK_FATAL(false, "must be kMeOpVar or kMeOpReg");
+              }
+
+              if (!IsExprRefOrPtr(*intrn->GetMustDefListItem(0).GetLHS())) {
+                break;
+              }
+              EACGBaseNode *refNode = eaCG->GetCGNodeFromExpr(intrn->GetMustDefListItem(0).GetLHS());
+              CHECK_FATAL(refNode != nullptr, "nullptr check");
+              for (auto objNode : refNode->GetPointsToSet()) {
+                objNode->IncresRCOperations();
+              }
+              break;
+            }
+            default:
+              break;
+          }
+          break;
+        }
+        case OP_call:
+        case OP_callassigned:
+        case OP_superclasscallassigned: {
+          CallMeStmt *callMeStmt = static_cast<CallMeStmt*>(stmt);
+
+          // If a function has no reference parameter or return value, then skip it.
+          if (IsNoSideEffect(*callMeStmt)) {
+            break;
+          }
+          MIRFunction &calleeCandidate = callMeStmt->GetTargetFunction();
+          std::string fName = calleeCandidate.GetName();
+          if (fName == "MCC_GetOrInsertLiteral" ||
+              fName == "MCC_GetCurrentClassLoader" ||
+              fName == "Native_Thread_currentThread" ||
+              fName == "Native_java_lang_StringFactory_newStringFromBytes___3BIII" ||
+              fName == "Native_java_lang_StringFactory_newStringFromChars__II_3C" ||
+              fName == "Native_java_lang_StringFactory_newStringFromString__Ljava_lang_String_2" ||
+              fName == "Native_java_lang_String_intern__" ||
+              fName == "MCC_StringAppend" ||
+              fName == "MCC_StringAppend_StringInt" ||
+              fName == "MCC_StringAppend_StringJcharString" ||
+              fName == "MCC_StringAppend_StringString") {
+            break;
+          }
+          const MapleVector<MeExpr*> &opnds = callMeStmt->GetOpnds();
+          const size_t size = opnds.size();
+
+          bool isOptIcall =
+              (callMeStmt->GetOp() == OP_interfaceicallassigned || callMeStmt->GetOp() == OP_virtualicallassigned);
+          size_t firstParmIdx = (isOptIcall ? 1 : 0);
+
+          bool isSpecialCall = false;
+          if (fName == "Native_java_lang_Object_clone_Ljava_lang_Object__" ||
+              fName == "Native_java_lang_String_concat__Ljava_lang_String_2" ||
+              fName ==
+                  "Ljava_2Flang_2FAbstractStringBuilder_3B_7CappendCLONEDignoreret_7C_28Ljava_2Flang_2FString_3B_29V" ||
+              StartWith(fName, "Ljava_2Flang_2FAbstractStringBuilder_3B_7Cappend_7C") ||
+              StartWith(fName, "Ljava_2Flang_2FStringBuilder_3B_7Cappend_7C")) {
+            CallMeStmt *call = static_cast<CallMeStmt*>(callMeStmt);
+            CHECK_FATAL(call->GetMustDefList() != nullptr, "funcName: %s", fName.c_str());
+            CHECK_FATAL(call->GetMustDefList()->size() <= 1, "funcName: %s", fName.c_str());
+            if (call->GetMustDefList() != nullptr && call->GetMustDefList()->size() == 0) {
+              break;
+            }
+            isSpecialCall = true;
+          }
+
+          for (size_t i = firstParmIdx; i < size; ++i) {
+            MeExpr *var = opnds[i];
+            // we only solve reference node.
+            if (!IsExprRefOrPtr(*var) || var->GetOp() == OP_add) {
+              continue;
+            }
+            CHECK_NULL_FATAL(eaCG->GetCGNodeFromExpr(var));
+            std::vector<EACGBaseNode*> nodes;
+            GetCGNodeForMeExpr(nodes, *var, *callMeStmt, false);
+            CHECK_FATAL(nodes.size() > 0, "the size must not be zero");
+            for (EACGBaseNode *refNode : nodes) {
+              for (auto objNode : refNode->GetPointsToSet()) {
+                objNode->IncresRCOperations();
+              }
+            }
+            if (isSpecialCall) {
+              break;
+            }
+          }
+          break;
+        }
+        case OP_intrinsiccallwithtypeassigned: {
+          CHECK_FATAL(false, "must not be OP_intrinsiccallwithtypeassigned");
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+
+  for (EACGBaseNode *node : eaCG->GetNodes()) {
+    if (node == nullptr || !node->IsObjectNode()) {
+      continue;
+    }
+    EACGObjectNode *obj = static_cast<EACGObjectNode*>(node);
+    if (obj->IsPhantom()) {
+      continue;
+    }
+    if (obj->IsPointedByFieldNode()) {
+      obj->IncresRCOperations(kRCOperLB);
+    }
+  }
+}
+
+void IPAEscapeAnalysis::DeleteRedundantRC() {
+  MeCFG *cfg = func->GetCfg();
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == cfg->GetCommonEntryBB() || bb == cfg->GetCommonExitBB() || bb == nullptr) {
+      continue;
+    }
+    for (MeStmt *stmt = to_ptr(bb->GetMeStmts().begin()); stmt != nullptr; stmt = stmt->GetNextMeStmt()) {
+      if (stmt->GetOp() == OP_intrinsiccall) {
+        IntrinsiccallMeStmt *intrn = static_cast<IntrinsiccallMeStmt*>(stmt);
+        switch (intrn->GetIntrinsic()) {
+          case INTRN_MCCIncRef:
+          case INTRN_MCCDecRef:
+          case INTRN_MCCIncDecRef: {
+            bool canRemoveStmt = true;
+            for (auto expr : intrn->GetOpnds()) {
+              if (eaCG->GetCGNodeFromExpr(expr) == nullptr) {
+                canRemoveStmt = false;
+                break;
+              }
+              std::vector<EACGBaseNode*> nodes;
+              GetCGNodeForMeExpr(nodes, *expr, *intrn, false);
+              for (auto node : nodes) {
+                if (!node->CanIgnoreRC()) {
+                  canRemoveStmt = false;
+                  break;
+                }
+              }
+              if (!canRemoveStmt) {
+                break;
+              }
+            }
+            if (canRemoveStmt) {
+              bb->RemoveMeStmt(stmt);
+            }
+            break;
+          }
+          case INTRN_MCCIncDecRefReset:
+          case INTRN_MCCDecRefReset: {
+            bool canRemoveStmt = true;
+            for (auto expr : intrn->GetOpnds()) {
+              if (expr->GetMeOp() != kMeOpAddrof) {
+                if (eaCG->GetCGNodeFromExpr(expr) == nullptr) {
+                  canRemoveStmt = false;
+                  break;
+                }
+                std::vector<EACGBaseNode*> nodes;
+                GetCGNodeForMeExpr(nodes, *expr, *intrn, false);
+                for (auto node : nodes) {
+                  if (!node->CanIgnoreRC()) {
+                    canRemoveStmt = false;
+                    break;
+                  }
+                }
+                if (!canRemoveStmt) {
+                  break;
+                }
+              } else {
+                AddrofMeExpr *addrof = static_cast<AddrofMeExpr*>(expr);
+                const OriginalSt *ost = addrof->GetOst();
+                ASSERT(ost != nullptr, "null ptr check");
+                for (auto index : ost->GetVersionsIndices()) {
+                  if (ost->IsFormal()) {
+                    canRemoveStmt = false;
+                    break;
+                  }
+                  if (index == ost->GetZeroVersionIndex()) {
+                    continue;
+                  }
+                  MeExpr *var = irMap->GetMeExprByVerID(static_cast<uint32>(index));
+                  if (var == nullptr) {
+                    continue;
+                  }
+                  if (eaCG->GetCGNodeFromExpr(var) == nullptr) {
+                    canRemoveStmt = false;
+                    break;
+                  }
+                  std::vector<EACGBaseNode*> nodes;
+                  GetCGNodeForMeExpr(nodes, *var, *intrn, false);
+                  for (auto node : nodes) {
+                    if (!node->CanIgnoreRC()) {
+                      canRemoveStmt = false;
+                      break;
+                    }
+                  }
+                }
+                if (!canRemoveStmt) {
+                  break;
+                }
+              }
+            }
+            if (canRemoveStmt) {
+              bb->RemoveMeStmt(stmt);
+            }
+            break;
+          }
+          default:
+            break;
+        }
+      }
+    }
+  }
+}
+}
diff --git a/src/mapleall/maple_ipa/src/old/ipa_option.cpp b/src/mapleall/maple_ipa/src/old/ipa_option.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..410f0d9ad8bf1ecfeec10666fbf19a903b34e1d1
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/old/ipa_option.cpp
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ipa_option.h"
+#include "driver_options.h"
+#include "file_utils.h"
+#include "mpl_logging.h"
+#include "triple.h"
+
+namespace maple {
+
+namespace opts::ipa {
+  maplecl::Option<bool> help({"--help", "-h"},
+                        "  -h --help                   \tPrint usage and exit.Available command names:\n",
+                        {ipaCategory});
+
+  maplecl::Option<bool> o1({"--O1", "-O1"},
+                      "  --O1                        \tEnable basic inlining\n",
+                      {ipaCategory});
+
+  maplecl::Option<bool> o2({"--O2", "-O2"},
+                      "  --O2                        \tEnable greedy inlining\n",
+                      {ipaCategory});
+
+  maplecl::Option<bool> effectipa({"--effectipa", "-effectipa"},
+                             "  --effectipa                 \tEnable method side effect for ipa\n",
+                             {ipaCategory});
+
+  maplecl::Option<std::string> inlinefunclist({"--inlinefunclist", "-inlinefunclist"},
+                                         "  --inlinefunclist=           \tInlining related configuration\n",
+                                         {ipaCategory});
+
+  maplecl::Option<bool> quiet({"--quiet", "-quiet"},
+                         "  --quiet                     \tDisable out debug info\n",
+                         {ipaCategory});
+}
+
+IpaOption &IpaOption::GetInstance() {
+  static IpaOption instance;
+  return instance;
+}
+
+bool IpaOption::SolveOptions() const {
+  if (::opts::target.IsEnabledByUser()) {
+    Triple::GetTriple().Init(::opts::target.GetValue());
+  } else {
+    Triple::GetTriple().Init();
+  }
+
+  if (opts::ipa::help.IsEnabledByUser()) {
+    maplecl::CommandLine::GetCommandLine().HelpPrinter(ipaCategory);
+    return false;
+  }
+
+  if (opts::ipa::quiet.IsEnabledByUser()) {
+    MeOption::quiet = true;
+    Options::quiet = true;
+  }
+
+  maplecl::CopyIfEnabled(MeOption::inlineFuncList, opts::ipa::inlinefunclist);
+
+  return true;
+}
+
+bool IpaOption::ParseCmdline(int argc, char **argv, std::vector<std::string> &fileNames) const {
+  // Default value
+  MeOption::inlineFuncList = "";
+
+  (void)maplecl::CommandLine::GetCommandLine().Parse(argc, static_cast<char **>(argv), ipaCategory);
+  bool result = SolveOptions();
+  if (!result) {
+    return false;
+  }
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  for (auto &arg : badArgs) {
+    if (FileUtils::IsFileExists(arg.first)) {
+      fileNames.push_back(arg.first);
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+}  // namespace maple
+
diff --git a/src/mapleall/maple_ipa/src/prop_parameter_type.cpp b/src/mapleall/maple_ipa/src/prop_parameter_type.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b3dafdf149d526a9aecdc606be79895d9452b53b
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/prop_parameter_type.cpp
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "prop_parameter_type.h"
+#include "call_graph.h"
+#include "maple_phase.h"
+#include "maple_phase.h"
+#include "option.h"
+#include "string_utils.h"
+#include "mir_function.h"
+#include "me_dominance.h"
+
+namespace maple {
+bool PropParamType::CheckOpndZero(const MeExpr *expr) const {
+  if (expr->GetMeOp() == kMeOpConst &&
+      static_cast<const ConstMeExpr*>(expr)->IsZero()) {
+    return true;
+  }
+  return false;
+}
+
+bool PropParamType::CheckCondtionStmt(const MeStmt &meStmt) const {
+  auto *node = meStmt.GetOpnd(0);
+  auto subOpnd0 = node->GetOpnd(0);
+  auto subOpnd1 = node->GetOpnd(1);
+  return CheckOpndZero(subOpnd0) || CheckOpndZero(subOpnd1);
+}
+
+void PropParamType::ResolveIreadExpr(MeExpr &expr) {
+  switch (expr.GetMeOp()) {
+    case kMeOpIvar: {
+      auto *ivarMeExpr = static_cast<IvarMeExpr*>(&expr);
+      const MeExpr *base = ivarMeExpr->GetBase();
+      if (base->GetMeOp() == kMeOpNary && base->GetOp() == OP_array) {
+        base = base->GetOpnd(0);
+      }
+      if (base->GetMeOp() == kMeOpVar) {
+        const VarMeExpr *varMeExpr = static_cast<const VarMeExpr*>(base);
+        MIRSymbol *sym = varMeExpr->GetOst()->GetMIRSymbol();
+        if (sym->IsFormal() && formalMapLocal[sym] != PointerAttr::kPointerNull) {
+          formalMapLocal[sym] = PointerAttr::kPointerNoNull;
+        }
+      }
+      break;
+    }
+    default: {
+      for (uint32 i = 0; i < expr.GetNumOpnds(); ++i) {
+        auto *subExpr = expr.GetOpnd(i);
+        ResolveIreadExpr(*subExpr);
+      }
+    }
+  }
+}
+
+void PropParamType::InsertNullCheck(CallMeStmt &callStmt, const std::string &funcName,
+                                    uint32 index, MeExpr &receiver) {
+  auto *irMap = curFunc->GetMeFunc()->GetIRMap();
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  CallAssertNonnullMeStmt *nullCheck = irMap->New<CallAssertNonnullMeStmt>(OP_callassertnonnull,
+      stridx, index, builder.GetCurrentFunction()->GetNameStrIdx());
+  nullCheck->SetBB(callStmt.GetBB());
+  nullCheck->SetSrcPos(callStmt.GetSrcPosition());
+  nullCheck->SetMeStmtOpndValue(&receiver);
+  callStmt.GetBB()->InsertMeStmtBefore(&callStmt, nullCheck);
+}
+
+void PropParamType::ResolveCallStmt(MeStmt &meStmt) {
+  auto *callMeStmt = static_cast<CallMeStmt*>(&meStmt);
+  PUIdx puidx = callMeStmt->GetPUIdx();
+  MIRFunction *calledFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puidx);
+
+  // If the parameter is passed through the fucntion call, we think it maybe have a judge.
+  for (auto &map : std::as_const(*meStmt.GetMuList())) {
+    OStIdx idx = map.first;
+    SSATab *ssaTab = static_cast<MESSATab*>(dataMap.GetVaildAnalysisPhase(curFunc->GetMeFunc()->GetUniqueID(),
+                                                                          &MESSATab::id))->GetResult();
+    OriginalSt *ostTemp = ssaTab->GetSymbolOriginalStFromID(idx);
+    ASSERT(ostTemp != nullptr, "null ptr check");
+    MIRSymbol *tempSymbol = ostTemp->GetMIRSymbol();
+    if (tempSymbol != nullptr && tempSymbol->IsFormal() && curFunc->GetParamNonull(tempSymbol) !=
+                                                           PointerAttr::kPointerNoNull) {
+      formalMapLocal[tempSymbol] = PointerAttr::kPointerNull;
+    }
+  }
+  // Insert the assertstmt && analysis curFunc parameter
+  if (calledFunc->IsExtern() || calledFunc->IsEmpty()) {
+    return;
+  }
+  for (uint32 i = 0; i < calledFunc->GetFormalCount(); i++) {
+    MIRSymbol *formalSt = calledFunc->GetFormal(i);
+    if (formalSt->GetType()->GetKind() == kTypePointer) {
+      if (calledFunc->CheckParamNullType(formalSt) &&
+          calledFunc->GetParamNonull(formalSt) == PointerAttr::kPointerNoNull) {
+        InsertNullCheck(*callMeStmt, calledFunc->GetName(), i, *callMeStmt->GetOpnd(i));
+        MIRSymbol *calledFuncFormalSt = calledFunc->GetFormal(i);
+        if (calledFuncFormalSt->IsFormal() &&
+            curFunc->GetParamNonull(calledFuncFormalSt) != PointerAttr::kPointerNull) {
+          formalMapLocal[calledFuncFormalSt] = PointerAttr::kPointerNoNull;
+        }
+      }
+    }
+  }
+}
+
+void PropParamType::TraversalMeStmt(MeStmt &meStmt) {
+  if (meStmt.GetOp() == OP_brfalse || meStmt.GetOp() == OP_brtrue) {
+    auto *opnd = meStmt.GetOpnd(0);
+    if (opnd->GetOp() != OP_eq && opnd->GetOp() != OP_ne && opnd->GetOp() != OP_gt && opnd->GetOp() != OP_ge) {
+      for (uint32 i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        auto *expr = meStmt.GetOpnd(i);
+        ResolveIreadExpr(*expr);
+      }
+      return;
+    }
+    if (CheckCondtionStmt(meStmt)) {
+      auto subOpnd0 = opnd->GetOpnd(0);
+      auto subOpnd1 = opnd->GetOpnd(1);
+      MeExpr *expr = CheckOpndZero(subOpnd0) ? subOpnd1 : subOpnd0;
+      if (expr->GetOp() == OP_dread) {
+        VarMeExpr *varExpr = static_cast<VarMeExpr *>(expr);
+        MIRSymbol *sym = varExpr->GetOst()->GetMIRSymbol();
+        if (sym->IsFormal()) {
+          formalMapLocal[sym] = PointerAttr::kPointerNull;
+          return;
+        }
+        if (meStmt.GetMuList() == nullptr) {
+          return;
+        }
+        for (auto map : *meStmt.GetMuList()) {
+          OStIdx idx = map.first;
+          SSATab *ssaTab = static_cast<MESSATab*>(dataMap.GetVaildAnalysisPhase(curFunc->GetMeFunc()->GetUniqueID(),
+                                                                                &MESSATab::id))->GetResult();
+          ASSERT(ssaTab != nullptr, "null ptr check");
+          OriginalSt *ostTemp = ssaTab->GetSymbolOriginalStFromID(idx);
+          ASSERT(ostTemp != nullptr, "null ptr check");
+          MIRSymbol *tempSymbol = ostTemp->GetMIRSymbol();
+          if (tempSymbol->IsFormal()) {
+            formalMapLocal[tempSymbol] = PointerAttr::kPointerNull;
+            return;
+          }
+        }
+      }
+    }
+  } else if (meStmt.GetOp() == OP_callassigned || meStmt.GetOp() == OP_call) {
+    ResolveCallStmt(meStmt);
+  } else {
+    for (uint32 i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+      auto *expr = meStmt.GetOpnd(i);
+      ResolveIreadExpr(*expr);
+    }
+  }
+}
+
+void PropParamType::RunOnScc(maple::SCCNode<CGNode> &scc) {
+  for (auto *cgNode : scc.GetNodes()) {
+    MIRFunction *func = cgNode->GetMIRFunction();
+    if (func->IsEmpty()) {
+      continue;
+    }
+    formalMapLocal.clear();
+    curFunc = func;
+    for (uint32 i = 0; i < func->GetFormalCount(); i++) {
+      MIRSymbol *formalSt = func->GetFormal(i);
+      if (formalSt->GetType()->GetKind() != kTypePointer) {
+        continue;
+      }
+      if (formalSt->GetAttr(ATTR_nonnull)) {
+        func->SetParamNonull(formalSt, PointerAttr::kPointerNoNull);
+        formalMapLocal[formalSt] = PointerAttr::kPointerNoNull;
+      }
+    }
+    Prop(*func);
+    for (auto it = formalMapLocal.begin(); it != formalMapLocal.end(); ++it) {
+      func->SetParamNonull(it->first, it->second);
+      if (it->second == PointerAttr::kPointerNoNull) {
+        static_cast<MIRSymbol*>(it->first)->SetAttr(ATTR_nonnull);
+        uint32 index = func->GetFormalIndex(it->first);
+        if (index != 0xffffffff) {
+          FormalDef &formalDef = const_cast<FormalDef&>(func->GetFormalDefAt(index));
+          formalDef.formalAttrs.SetAttr(ATTR_nonnull);
+        }
+      }
+    }
+  }
+}
+
+void PropParamType::Prop(MIRFunction &func) {
+  for (uint32 i = 0; i < func.GetFormalCount(); i++) {
+    MIRSymbol *formalSt = func.GetFormal(i);
+    if (formalSt->GetType()->GetKind() == kTypePointer) {
+      formalMapLocal[formalSt] = PointerAttr::kPointerUndeiced;
+    }
+  }
+  auto dom = static_cast<MEDominance*>(
+      dataMap.GetVaildAnalysisPhase(curFunc->GetMeFunc()->GetUniqueID(), &MEDominance::id))->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  for (auto *node : dom->GetReversePostOrder()) {
+    if (node == nullptr) {
+      return;
+    }
+    auto bb = func.GetMeFunc()->GetCfg()->GetBBFromID(BBId(node->GetID()));
+    // traversal on stmt
+    for (auto &meStmt : bb->GetMeStmts()) {
+      TraversalMeStmt(meStmt);
+    }
+  }
+}
+
+void SCCPropParamType::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<SCCPrepare>();
+  aDep.SetPreservedAll();
+}
+
+bool SCCPropParamType::PhaseRun(maple::SCCNode<CGNode> &scc) {
+  MIRModule *m = ((scc.GetNodes()[0])->GetMIRFunction())->GetModule();
+  auto *memPool = GetPhaseMemPool();
+  MapleAllocator alloc = MapleAllocator(memPool);
+  MaplePhase *it = GetAnalysisInfoHook()->FindOverIRAnalyisData<M2MCallGraph, MIRModule>(*m);
+  CallGraph *cg = static_cast<M2MCallGraph*>(it)->GetResult();
+  CHECK_FATAL(cg != nullptr, "Expecting a valid CallGraph, found nullptr");
+  AnalysisDataManager *dataMap = GET_ANALYSIS(SCCPrepare, scc);
+  PropParamType prop(*memPool, alloc, *m, *cg, *dataMap);
+  prop.RunOnScc(scc);
+  return true;
+}
+}
diff --git a/src/mapleall/maple_ipa/src/prop_return_null.cpp b/src/mapleall/maple_ipa/src/prop_return_null.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9551775c64285b1b97874f3960a56d93cbaef083
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/prop_return_null.cpp
@@ -0,0 +1,486 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "prop_return_null.h"
+#include "call_graph.h"
+#include "maple_phase.h"
+#include "maple_phase.h"
+#include "option.h"
+#include "string_utils.h"
+#include "mir_function.h"
+#include "me_dominance.h"
+
+namespace maple {
+static bool MaybeNull(const MeExpr &expr) {
+  if (expr.GetMeOp() == kMeOpVar) {
+    return static_cast<const VarMeExpr*>(&expr)->GetMaybeNull();
+  } else if (expr.GetMeOp() == kMeOpIvar) {
+    return static_cast<const IvarMeExpr*>(&expr)->GetMaybeNull();
+  } else if (expr.GetOp() == OP_retype) {
+    MeExpr *retypeRHS = (static_cast<const OpMeExpr*>(&expr))->GetOpnd(0);
+    return MaybeNull(*retypeRHS);
+  }
+  return true;
+}
+
+TyIdx PropReturnAttr::GetInferredTyIdx(MeExpr &expr) const {
+  if (expr.GetMeOp() == kMeOpVar) {
+    auto *varMeExpr = static_cast<VarMeExpr*>(&expr);
+    if (varMeExpr->GetInferredTyIdx() == 0u) {
+      // If varMeExpr->inferredTyIdx has not been set, we can double check
+      // if it is coming from a static final field
+      const OriginalSt *ost = varMeExpr->GetOst();
+      const MIRSymbol *mirSym = ost->GetMIRSymbol();
+      if (mirSym->IsStatic() && mirSym->IsFinal() && mirSym->GetInferredTyIdx() != kInitTyIdx &&
+          mirSym->GetInferredTyIdx() != kNoneTyIdx) {
+        varMeExpr->SetInferredTyIdx(mirSym->GetInferredTyIdx());
+      }
+      if (mirSym->GetType()->GetKind() == kTypePointer) {
+        MIRType *pointedType = (static_cast<MIRPtrType*>(mirSym->GetType()))->GetPointedType();
+        if (pointedType->GetKind() == kTypeClass) {
+          if ((static_cast<MIRClassType*>(pointedType))->IsFinal()) {
+            varMeExpr->SetInferredTyIdx(pointedType->GetTypeIndex());
+          }
+        }
+      }
+    }
+    return varMeExpr->GetInferredTyIdx();
+  } else if (expr.GetMeOp() == kMeOpIvar) {
+    return static_cast<IvarMeExpr*>(&expr)->GetInferredTyIdx();
+  } else if (expr.GetOp() == OP_retype) {
+    MeExpr *retypeRHS = (static_cast<OpMeExpr*>(&expr))->GetOpnd(0);
+    return GetInferredTyIdx(*retypeRHS);
+  }
+  return TyIdx(0);
+}
+
+void PropReturnAttr::PropVarInferredType(VarMeExpr &varMeExpr) const {
+  if (varMeExpr.GetDefBy() == kDefByStmt) {
+    DassignMeStmt &defStmt = utils::ToRef(safe_cast<DassignMeStmt>(varMeExpr.GetDefStmt()));
+    MeExpr *rhs = defStmt.GetRHS();
+    if (rhs->GetOp() == OP_gcmalloc) {
+      varMeExpr.SetInferredTyIdx(static_cast<GcmallocMeExpr*>(rhs)->GetTyIdx());
+      varMeExpr.SetMaybeNull(false);
+      if (PropReturnAttr::debug) {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(varMeExpr.GetInferredTyIdx());
+        LogInfo::MapleLogger() << "[PROP-RETURN-ATTR] [TYPE-INFERRING] mx" << varMeExpr.GetExprID() << " ";
+        type->Dump(0, false);
+        LogInfo::MapleLogger() << '\n';
+      }
+    } else if (rhs->GetOp() == OP_gcmallocjarray) {
+      varMeExpr.SetInferredTyIdx(static_cast<OpMeExpr*>(rhs)->GetTyIdx());
+      varMeExpr.SetMaybeNull(false);
+      if (PropReturnAttr::debug) {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(varMeExpr.GetInferredTyIdx());
+        LogInfo::MapleLogger() << "[PROP-RETURN-ATTR] [TYPE-INFERRING] mx" << varMeExpr.GetExprID() << " ";
+        type->Dump(0, false);
+        LogInfo::MapleLogger() << '\n';
+      }
+    } else if (!MaybeNull(*rhs)) {
+      varMeExpr.SetMaybeNull(false);
+    } else {
+      TyIdx tyIdx = GetInferredTyIdx(*rhs);
+      if (tyIdx != 0u) {
+        varMeExpr.SetInferredTyIdx(tyIdx);
+        if (PropReturnAttr::debug) {
+          MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(varMeExpr.GetInferredTyIdx());
+          LogInfo::MapleLogger() << "[PROP-RETURN-ATTR] [TYPE-INFERRING] mx" << varMeExpr.GetExprID() << " ";
+          type->Dump(0, false);
+          LogInfo::MapleLogger() << '\n';
+        }
+      }
+    }
+  } else if (varMeExpr.GetDefBy() == kDefByPhi) {
+    if (PropReturnAttr::debug) {
+      LogInfo::MapleLogger() << "[PROP-RETURN-ATTR] [TYPE-INFERRING] " << "Def by phi " << '\n';
+    }
+  }
+}
+
+void PropReturnAttr::PropIvarInferredType(IvarMeExpr &ivar) const {
+  IassignMeStmt *defStmt = ivar.GetDefStmt();
+  if (defStmt == nullptr) {
+    return;
+  }
+  MeExpr *rhs = defStmt->GetRHS();
+  CHECK_NULL_FATAL(rhs);
+  if (rhs->GetOp() == OP_gcmalloc) {
+    ivar.GetInferredTyIdx() = static_cast<GcmallocMeExpr*>(rhs)->GetTyIdx();
+    ivar.SetMaybeNull(false);
+    if (PropReturnAttr::debug) {
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetInferredTyIdx());
+      LogInfo::MapleLogger() << "[PROP-RETURN-ATTR] [TYPE-INFERRING] mx" << ivar.GetExprID() << " ";
+      type->Dump(0, false);
+      LogInfo::MapleLogger() << '\n';
+    }
+  } else if (rhs->GetOp() == OP_gcmallocjarray) {
+    ivar.GetInferredTyIdx() = static_cast<OpMeExpr*>(rhs)->GetTyIdx();
+    ivar.SetMaybeNull(false);
+  } else if (!MaybeNull(*rhs)) {
+    ivar.SetMaybeNull(false);
+  } else {
+    TyIdx tyIdx = GetInferredTyIdx(*rhs);
+    if (tyIdx != 0u) {
+      ivar.SetInferredTyidx(tyIdx);
+      if (PropReturnAttr::debug) {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetInferredTyIdx());
+        LogInfo::MapleLogger() << "[PROP-RETURN-ATTR] [TYPE-INFERRING] mx" << ivar.GetExprID() << " ";
+        type->Dump(0, false);
+        LogInfo::MapleLogger() << '\n';
+      }
+    }
+  }
+}
+
+void PropReturnAttr::VisitVarPhiNode(MePhiNode &varPhi) const {
+  MapleVector<ScalarMeExpr*> opnds = varPhi.GetOpnds();
+  auto *lhs = varPhi.GetLHS();
+  // RegPhiNode cases NYI
+  if (lhs == nullptr || lhs->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  VarMeExpr *lhsVar = static_cast<VarMeExpr*>(varPhi.GetLHS());
+  for (size_t i = 0; i < opnds.size(); ++i) {
+    VarMeExpr *opnd = static_cast<VarMeExpr *>(opnds[i]);
+    PropVarInferredType(*opnd);
+    if (MaybeNull(*opnd)) {
+      return;
+    }
+  }
+  lhsVar->SetMaybeNull(false);
+  return;
+}
+
+void PropReturnAttr::VisitMeExpr(MeExpr *meExpr) const {
+  if (meExpr == nullptr) {
+    return;
+  }
+  MeExprOp meOp = meExpr->GetMeOp();
+  switch (meOp) {
+    case kMeOpVar: {
+      auto *varExpr = static_cast<VarMeExpr*>(meExpr);
+      PropVarInferredType(*varExpr);
+      break;
+    }
+    case kMeOpReg:
+      break;
+    case kMeOpIvar: {
+      auto *iVar = static_cast<IvarMeExpr*>(meExpr);
+      PropIvarInferredType(*iVar);
+      break;
+    }
+    case kMeOpOp: {
+      auto *meOpExpr = static_cast<OpMeExpr*>(meExpr);
+      for (uint32 i = 0; i < kOperandNumTernary; ++i) {
+        VisitMeExpr(meOpExpr->GetOpnd(i));
+      }
+      break;
+    }
+    case kMeOpNary: {
+      auto *naryMeExpr = static_cast<NaryMeExpr*>(meExpr);
+      for (MeExpr *opnd : naryMeExpr->GetOpnds()) {
+        VisitMeExpr(opnd);
+      }
+      break;
+    }
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpAddroflabel:
+    case kMeOpGcmalloc:
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpSizeoftype:
+    case kMeOpFieldsDist:
+      break;
+    default:
+      CHECK_FATAL(false, "MeOP NIY");
+      break;
+  }
+}
+
+void PropReturnAttr::ReturnTyIdxInferring(const RetMeStmt &retMeStmt) {
+  const MapleVector<MeExpr*> &opnds = retMeStmt.GetOpnds();
+  CHECK_FATAL(opnds.size() <= 1, "Assume at most one return value for now");
+  for (size_t i = 0; i < opnds.size(); ++i) {
+    MeExpr *opnd = opnds[i];
+    TyIdx tyIdx = GetInferredTyIdx(*opnd);
+    if (retTy == kNotSeen) {
+      // seen the first return stmt
+      retTy = kSeen;
+      inferredRetTyIdx = tyIdx;
+      if (!MaybeNull(*opnd)) {
+        maybeNull = false;
+      }
+    } else if (retTy == kSeen) {
+      // has seen an nonull before, check if they agreed
+      if (inferredRetTyIdx != tyIdx) {
+        retTy = kFailed;
+        inferredRetTyIdx = TyIdx(0);  // not agreed, cleared.
+      }
+      if (MaybeNull(*opnd) || maybeNull) {
+        maybeNull = true;  // not agreed, cleared.
+      }
+    }
+  }
+}
+
+void PropReturnAttr::TraversalMeStmt(MeStmt &meStmt) {
+  Opcode op = meStmt.GetOp();
+  switch (op) {
+    case OP_dassign: {
+      auto *varMeStmt = static_cast<DassignMeStmt*>(&meStmt);
+      VisitMeExpr(varMeStmt->GetRHS());
+      break;
+    }
+    case OP_regassign: {
+      auto *regMeStmt = static_cast<AssignMeStmt*>(&meStmt);
+      VisitMeExpr(regMeStmt->GetRHS());
+      break;
+    }
+    case OP_maydassign: {
+      auto *maydStmt = static_cast<MaydassignMeStmt*>(&meStmt);
+      VisitMeExpr(maydStmt->GetRHS());
+      break;
+    }
+    case OP_iassign: {
+      auto *ivarStmt = static_cast<IassignMeStmt*>(&meStmt);
+      VisitMeExpr(ivarStmt->GetRHS());
+      break;
+    }
+    case OP_syncenter:
+    case OP_syncexit: {
+      auto *syncMeStmt = static_cast<SyncMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = syncMeStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      break;
+    }
+    case OP_throw: {
+      auto *thrMeStmt = static_cast<ThrowMeStmt*>(&meStmt);
+      VisitMeExpr(thrMeStmt->GetOpnd());
+      break;
+    }
+    case OP_assertnonnull:
+    case OP_eval:
+    case OP_igoto:
+    case OP_free: {
+      auto *unaryStmt = static_cast<UnaryMeStmt*>(&meStmt);
+      VisitMeExpr(unaryStmt->GetOpnd());
+      break;
+    }
+    case OP_asm:
+    case OP_call:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned: {
+      auto *callMeStmt = static_cast<CallMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = callMeStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      break;
+    }
+    case OP_icall:
+    case OP_icallproto:
+    case OP_icallprotoassigned:
+    case OP_icallassigned: {
+      auto *icallMeStmt = static_cast<IcallMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = icallMeStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      break;
+    }
+    case OP_intrinsiccallwithtype:
+    case OP_intrinsiccall:
+    case OP_xintrinsiccall:
+    case OP_intrinsiccallwithtypeassigned:
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned: {
+      auto *intrinCallStmt = static_cast<IntrinsiccallMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = intrinCallStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      break;
+    }
+    case OP_brtrue:
+    case OP_brfalse: {
+      auto *condGotoStmt = static_cast<CondGotoMeStmt*>(&meStmt);
+      VisitMeExpr(condGotoStmt->GetOpnd());
+      break;
+    }
+    case OP_switch: {
+      auto *switchStmt = static_cast<SwitchMeStmt*>(&meStmt);
+      VisitMeExpr(switchStmt->GetOpnd());
+      break;
+    }
+    case OP_return: {
+      auto *retMeStmt = static_cast<RetMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = retMeStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      ReturnTyIdxInferring(*retMeStmt);
+      break;
+    }
+    CASE_OP_ASSERT_BOUNDARY {
+      auto *assMeStmt = static_cast<NaryMeStmt*>(&meStmt);
+      VisitMeExpr(assMeStmt->GetOpnd(0));
+      VisitMeExpr(assMeStmt->GetOpnd(1));
+      break;
+    }
+    case OP_jstry:
+    case OP_jscatch:
+    case OP_finally:
+    case OP_endtry:
+    case OP_cleanuptry:
+    case OP_try:
+    case OP_catch:
+    case OP_goto:
+    case OP_gosub:
+    case OP_retsub:
+    case OP_comment:
+    case OP_membaracquire:
+    case OP_membarrelease:
+    case OP_membarstoreload:
+    case OP_membarstorestore:
+    case OP_callassertnonnull:
+      break;
+    default:
+      CHECK_FATAL(false, "unexpected stmt or NYI");
+  }
+  if (meStmt.GetOp() != OP_callassigned) {
+    return;
+  }
+  MapleVector<MustDefMeNode> *mustDefList = meStmt.GetMustDefList();
+  if (mustDefList->empty()) {
+    return;
+  }
+  MeExpr *meLHS = mustDefList->front().GetLHS();
+  if (meLHS->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  auto *lhsVar = static_cast<VarMeExpr*>(meLHS);
+  auto *callMeStmt = static_cast<CallMeStmt*>(&meStmt);
+  MIRFunction &called = callMeStmt->GetTargetFunction();
+  if (called.GetAttr(FUNCATTR_nonnull)) {
+    lhsVar->SetMaybeNull(false);
+  }
+}
+
+void PropReturnAttr::TraversalBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+  // traversal var phi nodes
+  MapleMap<OStIdx, MePhiNode*> &mePhiList = bb->GetMePhiList();
+  for (auto it = mePhiList.cbegin(); it != mePhiList.cend(); ++it) {
+    MePhiNode *phiMeNode = it->second;
+    if (phiMeNode == nullptr || phiMeNode->GetLHS()->GetMeOp() != kMeOpVar) {
+      continue;
+    }
+    VisitVarPhiNode(*phiMeNode);
+  }
+  // traversal reg phi nodes (NYI)
+  // traversal on stmt
+  for (auto &meStmt : bb->GetMeStmts()) {
+    TraversalMeStmt(meStmt);
+  }
+}
+
+void PropReturnAttr::Perform(MeFunction &func) {
+  // Pre-order traverse the cominance tree, so that each def is traversed
+  // before its use
+  std::vector<bool> bbVisited(func.GetCfg()->GetAllBBs().size(), false);
+  Dominance *dom = static_cast<MEDominance*>(dataMap.GetVaildAnalysisPhase(func.GetUniqueID(),
+                                                                           &MEDominance::id))->GetDomResult();
+  for (auto *bb : dom->GetReversePostOrder()) {
+    TraversalBB(func.GetCfg()->GetBBFromID(BBId(bb->GetID())));
+  }
+  MIRFunction *mirFunc = func.GetMirFunc();
+  if (mirFunc == nullptr) {
+    return;
+  }
+  if (retTy == kSeen && !maybeNull) {
+    mirFunc->SetRetrunAttrKind(kPointerNoNull);
+    mirFunc->SetAttr(FUNCATTR_nonnull);
+  }
+}
+
+void PropReturnAttr::Initialize(maple::SCCNode<CGNode> &scc) const {
+  for (auto *cgNode : scc.GetNodes()) {
+    MIRFunction *func = cgNode->GetMIRFunction();
+    if (func->IsEmpty()) {
+      continue;
+    }
+    if (func->GetAttr(FUNCATTR_nonnull)) {
+      func->SetRetrunAttrKind(kPointerNoNull);
+    }
+  }
+}
+
+void PropReturnAttr::Prop(maple::SCCNode<CGNode> &scc) {
+  for (auto *cgNode : scc.GetNodes()) {
+    retTy = kNotSeen;
+    maybeNull = true;
+    MIRFunction *func = cgNode->GetMIRFunction();
+    if (func->IsEmpty() || func->GetReturnType()->GetKind() != kTypePointer) {
+      continue;
+    }
+    if (func->GetRetrunAttrKind() == PointerAttr::kPointerNoNull) {
+      continue;
+    }
+    MeFunction *meFunc = func->GetMeFunc();
+    Perform(*meFunc);
+  }
+}
+
+void SCCPropReturnAttr::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<SCCPrepare>();
+}
+
+bool SCCPropReturnAttr::PhaseRun(maple::SCCNode<CGNode> &scc) {
+  MIRModule *m = ((scc.GetNodes()[0])->GetMIRFunction())->GetModule();
+  auto *memPool = GetPhaseMemPool();
+  MapleAllocator alloc = MapleAllocator(memPool);
+  MaplePhase *it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MCallGraph, MIRModule>(*m);
+  CallGraph *cg = static_cast<M2MCallGraph*>(it)->GetResult();
+  CHECK_FATAL(cg != nullptr, "Expecting a valid CallGraph, found nullptr");
+  AnalysisDataManager *dataMap = GET_ANALYSIS(SCCPrepare, scc);
+  PropReturnAttr prop(*memPool, alloc, *m, *cg, *dataMap);
+  prop.Initialize(scc);
+  prop.Prop(scc);
+  return true;
+}
+}
diff --git a/src/mapleall/maple_ipa/src/region_identify.cpp b/src/mapleall/maple_ipa/src/region_identify.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..14a1bfce71321a71b9b1fc3eebbf74a0d073f600
--- /dev/null
+++ b/src/mapleall/maple_ipa/src/region_identify.cpp
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "region_identify.h"
+#include <sys/types.h>
+#include <vector>
+#include "ipa_collect.h"
+#include "opcodes.h"
+#include "stmt_identify.h"
+
+namespace {
+  constexpr size_t kRegionInputLimit = 8;
+  constexpr size_t kRegionOutputLimit = 1;
+  constexpr size_t kRegionMinInvalidStmtNumber = 4;
+}
+
+namespace maple {
+const bool RegionCandidate::HasDefinitionOutofRegion(DefUsePositions &defUse) const {
+  for (auto defPos : defUse.definePositions) {
+    if (defPos > endId || defPos < startId) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void RegionCandidate::CollectRegionInputAndOutput(StmtInfo &stmtInfo, CollectIpaInfo &ipaInfo) {
+  for (auto defUsePositions : stmtInfo.GetRegDefUse()) {
+    auto &regIdx = defUsePositions.first;
+    auto src = SymbolRegPair(StIdx(0), defUsePositions.first);
+    for (auto usePos : defUsePositions.second.usePositions) {
+      if (usePos >= startId && usePos <= endId) {
+        continue;
+      }
+      (void)regionOutputs.insert(src);
+      auto &useStmtInfo = ipaInfo.GetStmtInfo()[usePos];
+      auto iter = useStmtInfo.GetRegDefUse().find(regIdx);
+      if (iter != useStmtInfo.GetRegDefUse().end() &&
+          HasDefinitionOutofRegion(iter->second)) {
+        (void)regionInputs.insert(src);
+      }
+    }
+    if (HasDefinitionOutofRegion(defUsePositions.second)) {
+      (void)regionInputs.insert(src);
+    }
+  }
+  for (auto defUsePositions : stmtInfo.GetSymbolDefUse()) {
+    auto &stIdx = defUsePositions.first;
+    auto src = SymbolRegPair(stIdx, PregIdx(0));
+    for (auto usePos : defUsePositions.second.usePositions) {
+      if (usePos >= startId && usePos <= endId) {
+        continue;
+      }
+      (void)regionOutputs.insert(src);
+      auto &useStmtInfo = ipaInfo.GetStmtInfo()[usePos];
+      auto iter = useStmtInfo.GetSymbolDefUse().find(stIdx);
+      if (iter != useStmtInfo.GetSymbolDefUse().end() &&
+          HasDefinitionOutofRegion(iter->second)) {
+        (void)regionInputs.insert(src);
+      }
+    }
+    if (HasDefinitionOutofRegion(defUsePositions.second)) {
+      (void)regionInputs.insert(src);
+    }
+  }
+}
+
+bool RegionCandidate::HasJumpOutOfRegion(StmtInfo &stmtInfo, bool isStart) {
+  for (auto location : stmtInfo.GetLocationsJumpTo()) {
+    if (location == endId + 1) {
+      (void)stmtJumpToEnd.insert(stmtInfo.GetStmtNode());
+    }
+    if (location > endId + 1 || location < startId) {
+      return true;
+    }
+  }
+  if (isStart) {
+    return false;
+  }
+  for (auto location : stmtInfo.GetLocationsJumpFrom()) {
+    if (location < startId || location > endId) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool RegionCandidate::IsLegal(CollectIpaInfo &ipaInfo) {
+  std::unordered_set<Opcode> stmtTypes;
+  uint32 validStmts = 0;
+  bool hasCall = false;
+  for (auto i = startId; i <= endId; ++i) {
+    auto &stmtInfo = ipaInfo.GetStmtInfo()[i];
+    auto currOp = stmtInfo.GetHashCandidateAt(0);
+    if (!(currOp == OP_comment) && !(currOp == OP_label) && !(currOp == OP_eval)) {
+      if (currOp == OP_dassign || currOp == OP_iassign || currOp == OP_regassign) {
+        (void)stmtTypes.insert(OP_dassign);
+      } else {
+        (void)stmtTypes.insert(static_cast<Opcode>(currOp));
+      }
+      validStmts++;
+    }
+    if (HasJumpOutOfRegion(stmtInfo, i == startId)) {
+      return false;
+    }
+    if (!stmtInfo.IsValid()) {
+      return false;
+    }
+    if (stmtInfo.IsCall()) {
+      hasCall = true;
+    }
+    CollectRegionInputAndOutput(stmtInfo, ipaInfo);
+    if (regionInputs.size() > kRegionInputLimit || regionOutputs.size() > kRegionOutputLimit) {
+      return false;
+    }
+  }
+  return stmtTypes.size() > 1 && (validStmts > kRegionMinInvalidStmtNumber && hasCall);
+}
+
+void RegionIdentify::RegionInit() {
+  std::vector<size_t> integerString;
+  auto &rawString = ipaInfo->GetIntegerString();
+  integerString.assign(rawString.begin(), rawString.end());
+  if (integerString.empty()) {
+    return;
+  }
+  (void)integerString.emplace_back(0);
+  (void)ipaInfo->GetStmtInfo().emplace_back(
+      StmtInfo(nullptr, kInvalidPuIdx, ipaInfo->GetAllocator()));
+  SuffixArray sa(integerString, integerString.size(), ipaInfo->GetCurrNewStmtIndex());
+  sa.Run(true);
+  CreateRegionCandidates(sa);
+}
+
+void RegionIdentify::CreateRegionCandidates(SuffixArray &sa) {
+  for (auto *subStrings : sa.GetRepeatedSubStrings()) {
+    std::vector<RegionCandidate> candidates;
+    for (auto occurrence : subStrings->GetOccurrences()) {
+      auto startPosition = occurrence.first;
+      auto endPosition = occurrence.second;
+      auto *startStmtInfo = GetNearestNonnullStmtInfo(startPosition, true);
+      auto *endStmtInfo = GetNearestNonnullStmtInfo(endPosition, false);
+      auto *function = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(startStmtInfo->GetPuIdx());
+      auto currRegion = RegionCandidate(startPosition, endPosition, startStmtInfo, endStmtInfo, function);
+      if (currRegion.IsLegal(*ipaInfo)) {
+        (void)candidates.emplace_back(currRegion);
+      }
+    }
+    delete subStrings;
+    subStrings = nullptr;
+    if (!(candidates.size() > 1)) {
+      continue;
+    }
+    CreateRegionGroups(candidates);
+  }
+}
+
+void RegionIdentify::CreateRegionGroups(std::vector<RegionCandidate> &regions) {
+  for (size_t i = 0; i < regions.size(); ++i) {
+    auto &currRegion = regions[i];
+    if (currRegion.GetGroupId() != kInvalidIndex) {
+      continue;
+    }
+    auto currGroup = RegionGroup();
+    GroupId newGroupId = regionGroups.size();
+    currGroup.SetGroupId(newGroupId);
+    currRegion.SetGroupId(newGroupId);
+    (void)currGroup.GetGroups().emplace_back(currRegion);
+    for (size_t j = i + 1; j < regions.size(); ++j) {
+      auto &nextRegion = regions[j];
+      if (CheckOverlapAmongGroupRegions(currGroup, nextRegion)) {
+        continue;
+      }
+      if (HasSameStructure(currRegion, nextRegion)) {
+        nextRegion.SetGroupId(newGroupId);
+        (void)currGroup.GetGroups().emplace_back(nextRegion);
+      }
+      ClearSrcMappings();
+    }
+    if (currGroup.GetGroups().size() < kGroupSizeLimit) {
+      continue;
+    }
+    (void)regionGroups.emplace_back(currGroup);
+  }
+}
+
+void RegionIdentify::ClearSrcMappings() {
+  symMap.clear();
+  leftRegMap.clear();
+  rightRegMap.clear();
+  leftConstMap.clear();
+  rightConstMap.clear();
+}
+
+StmtInfo *RegionIdentify::GetNearestNonnullStmtInfo(StmtInfoId index, bool forward) {
+  auto &stmtInfoVector = ipaInfo->GetStmtInfo();
+  while (stmtInfoVector[index].GetStmtNode() == nullptr) {
+    index = forward ? index + 1 : index - 1;
+  }
+  return &stmtInfoVector[index];
+}
+
+bool RegionIdentify::CheckOverlapAmongGroupRegions(RegionGroup &group, RegionCandidate &region) {
+  for (auto &groupedRegion : group.GetGroups()) {
+    if (region.IsOverlapWith(groupedRegion)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool RegionIdentify::CheckCompatibilifyBetweenSrcs(BaseNode &lhs, BaseNode &rhs) {
+  switch (lhs.GetOpCode()) {
+    case OP_dassign: {
+      auto leftStIdx = static_cast<DassignNode&>(lhs).GetStIdx();
+      auto rightStIdx = static_cast<DassignNode&>(rhs).GetStIdx();
+      if (!CompareSymbolStructure(leftStIdx, rightStIdx)) {
+        return false;
+      }
+      break;
+    }
+    case OP_regassign: {
+      auto leftRegIdx = static_cast<RegassignNode&>(lhs).GetRegIdx();
+      auto rightRegIdx = static_cast<RegassignNode&>(rhs).GetRegIdx();
+      if (!CompareRegStructure(leftRegIdx, rightRegIdx)) {
+        return false;
+      }
+      break;
+    }
+    case OP_addrof:
+    case OP_dread: {
+      auto leftStIdx = static_cast<DreadNode&>(lhs).GetStIdx();
+      auto rightStIdx = static_cast<DreadNode&>(rhs).GetStIdx();
+      return CompareSymbolStructure(leftStIdx, rightStIdx);
+    }
+    case OP_regread: {
+      auto leftRegIdx = static_cast<RegreadNode&>(lhs).GetRegIdx();
+      auto rightRegIdx = static_cast<RegreadNode&>(rhs).GetRegIdx();
+      return CompareRegStructure(leftRegIdx, rightRegIdx);
+    }
+    case OP_constval: {
+      auto *leftVal = static_cast<ConstvalNode&>(lhs).GetConstVal();
+      auto *rightVal = static_cast<ConstvalNode&>(rhs).GetConstVal();
+      return CompareConstStructure(leftVal, rightVal);
+    }
+    default: {
+      break;
+    }
+  }
+  return true;
+}
+
+bool RegionIdentify::CheckCompatibilifyAmongRegionComponents(BaseNode &lhs, BaseNode &rhs) {
+  if (lhs.GetOpCode() != rhs.GetOpCode()) {
+    return false;
+  }
+
+  if (lhs.GetOpCode() == OP_block) {
+    auto *leftStmt = static_cast<BlockNode&>(lhs).GetFirst();
+    auto *rightStmt = static_cast<BlockNode&>(rhs).GetFirst();
+    while (leftStmt != nullptr && rightStmt != nullptr) {
+      if (!CheckCompatibilifyAmongRegionComponents(*leftStmt, *rightStmt)) {
+        return false;
+      }
+      leftStmt = leftStmt->GetNext();
+      rightStmt = rightStmt->GetNext();
+    }
+    return (leftStmt == nullptr) && (rightStmt == nullptr);
+  }
+
+  if (!CheckCompatibilifyBetweenSrcs(lhs, rhs)) {
+    return false;
+  }
+
+  if (lhs.GetNumOpnds() != rhs.GetNumOpnds()) {
+    return false;
+  }
+
+  for (size_t i = 0; i < lhs.GetNumOpnds(); ++i) {
+    if (!CheckCompatibilifyAmongRegionComponents(*lhs.Opnd(i), *rhs.Opnd(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool RegionIdentify::CompareConstStructure(const MIRConst *leftConst, const MIRConst *rightConst) {
+  if (leftConstMap.find(leftConst) != leftConstMap.end()) {
+    if (leftConstMap[leftConst] != rightConst) {
+      return false;
+    }
+  } else {
+    leftConstMap[leftConst] = rightConst;
+  }
+  if (rightConstMap.find(rightConst) != rightConstMap.end()) {
+    if (rightConstMap[rightConst] != leftConst) {
+      return false;
+    }
+  } else {
+    rightConstMap[rightConst] = leftConst;
+  }
+  return true;
+}
+
+bool RegionIdentify::CompareRegStructure(const PregIdx leftIdx, const PregIdx rightIdx) {
+  if (leftRegMap.find(leftIdx) != leftRegMap.end()) {
+    if (leftRegMap[leftIdx] != rightIdx) {
+      return false;
+    }
+  } else {
+    leftRegMap[leftIdx] = rightIdx;
+  }
+  if (rightRegMap.find(rightIdx) != rightRegMap.end()) {
+    if (rightRegMap[rightIdx] != leftIdx) {
+      return false;
+    }
+  } else {
+    rightRegMap[rightIdx] = leftIdx;
+  }
+  return true;
+}
+
+bool RegionIdentify::CompareSymbolStructure(const StIdx leftIdx, const StIdx rightIdx) {
+  if (leftIdx.IsGlobal() != rightIdx.IsGlobal()) {
+    return false;
+  }
+  if (leftIdx.IsGlobal() && rightIdx.IsGlobal()) {
+    return leftIdx == rightIdx;
+  }
+  if (symMap.find(leftIdx) != symMap.end()) {
+    if (symMap[leftIdx] != rightIdx) {
+      return false;
+    }
+  } else {
+    symMap[leftIdx] = rightIdx;
+  }
+  if (symMap.find(rightIdx) != symMap.end()) {
+    if (symMap[rightIdx] != leftIdx) {
+      return false;
+    }
+  } else {
+    symMap[rightIdx] = leftIdx;
+  }
+  return true;
+}
+
+bool RegionIdentify::HasSameStructure(RegionCandidate &lhs, RegionCandidate &rhs) {
+  if (lhs.GetRegionOutPuts().size() != rhs.GetRegionOutPuts().size()) {
+    return false;
+  }
+  auto *leftStmt = lhs.GetStart()->GetStmtNode();
+  auto *rightStmt = rhs.GetStart()->GetStmtNode();
+  while (leftStmt && rightStmt && leftStmt->GetStmtInfoId() <= lhs.GetEndId()) {
+    if (!CheckCompatibilifyAmongRegionComponents(*leftStmt, *rightStmt)) {
+      return false;
+    }
+    leftStmt = leftStmt->GetNext();
+    rightStmt = rightStmt->GetNext();
+  }
+  return true;
+}
+}
diff --git a/src/mapleall/maple_ir/BUILD.gn b/src/mapleall/maple_ir/BUILD.gn
new file mode 100755
index 0000000000000000000000000000000000000000..79155184d4f909a4ad848b8a783c71f17953a0fe
--- /dev/null
+++ b/src/mapleall/maple_ir/BUILD.gn
@@ -0,0 +1,109 @@
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+include_directories = [
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/mpl2mpl/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include/old",
+  "${MAPLEALL_ROOT}/maple_me/include",
+  "${MAPLEALL_ROOT}/maple_phase/include",
+  "${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat",
+]
+
+src_libmplir = [
+  "src/global_tables.cpp",
+  "src/intrinsics.cpp",
+  "src/lexer.cpp",
+  "src/mir_symbol_builder.cpp",
+  "src/mir_builder.cpp",
+  "src/mir_const.cpp",
+  "src/mir_scope.cpp",
+  "src/mir_function.cpp",
+  "src/mir_lower.cpp",
+  "src/mir_module.cpp",
+  "src/verification.cpp",
+  "src/verify_annotation.cpp",
+  "src/verify_mark.cpp",
+  "src/mir_nodes.cpp",
+  "src/mir_symbol.cpp",
+  "src/mir_type.cpp",
+  "src/mir_enum.cpp",
+  "src/opcode_info.cpp",
+  "src/option.cpp",
+  "src/mpl2mpl_options.cpp",
+  "src/parser.cpp",
+  "src/mir_parser.cpp",
+  "src/mir_pragma.cpp",
+  "src/printing.cpp",
+  "src/bin_func_import.cpp",
+  "src/bin_func_export.cpp",
+  "src/bin_mpl_import.cpp",
+  "src/bin_mpl_export.cpp",
+  "src/debug_info.cpp",
+  "src/debug_info_util.cpp",
+  "${MAPLEALL_ROOT}/maple_ipa/src/old/ea_connection_graph.cpp",
+]
+
+src_irbuild = [ "src/driver.cpp" ]
+
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+
+cflags_cc += [ "-DSTORE_BACK_VTABLE_REF_AFTER_LOAD=1" ]
+
+static_library("libmplir") {
+  sources = src_libmplir
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+  deps = [
+    "${MAPLEALL_ROOT}/maple_driver:libdriver_option",
+    "${MAPLEALL_ROOT}/maple_phase:libmplphase",
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/maple_util:libcommandline"
+  ]
+}
+
+executable("irbuild") {
+  sources = src_irbuild
+  include_dirs = include_directories
+  deps = [
+    ":libmplir",
+    "${MAPLEALL_ROOT}/maple_phase:libmplphase",
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/maple_util:libcommandline",
+    "${MAPLEALL_ROOT}/mempool:libmempool",
+    "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
+  ]
+}
+
+src_mpldbg = [ "src/mpl_dbg.cpp" ]
+
+executable("mpldbg") {
+  sources = src_mpldbg
+  include_dirs = include_directories
+  deps = [
+    ":libmplir",
+    "${MAPLEALL_ROOT}/maple_phase:libmplphase",
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/maple_util:libcommandline",
+    "${MAPLEALL_ROOT}/mempool:libmempool",
+    "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
+  ]
+}
diff --git a/src/mapleall/maple_ir/CMakeLists.txt b/src/mapleall/maple_ir/CMakeLists.txt
new file mode 100755
index 0000000000000000000000000000000000000000..24d556a4e6767de9a4f1c0a5ad40b85fe1265310
--- /dev/null
+++ b/src/mapleall/maple_ir/CMakeLists.txt
@@ -0,0 +1,115 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN AS IS BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(inc_libmplir
+  ${MAPLEALL_ROOT}/maple_ir/include
+  ${MAPLEALL_ROOT}/mpl2mpl/include
+  ${MAPLEALL_ROOT}/maple_util/include
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${MAPLEALL_ROOT}/mempool/include
+  ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+  ${MAPLEALL_ROOT}/maple_ipa/include
+  ${MAPLEALL_ROOT}/maple_ipa/include/old
+  ${MAPLEALL_ROOT}/maple_me/include
+  ${MAPLEALL_ROOT}/maple_phase/include
+  ${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat
+)
+
+set(src_libmplir
+  src/global_tables.cpp
+  src/intrinsics.cpp
+  src/lexer.cpp
+  src/mir_symbol_builder.cpp
+  src/mir_builder.cpp
+  src/mir_const.cpp
+  src/mir_scope.cpp
+  src/mir_function.cpp
+  src/mir_lower.cpp
+  src/mir_module.cpp
+  src/verification.cpp
+  src/verify_annotation.cpp
+  src/verify_mark.cpp
+  src/mir_nodes.cpp
+  src/mir_symbol.cpp
+  src/mir_type.cpp
+  src/mir_enum.cpp
+  src/opcode_info.cpp
+  src/option.cpp
+  src/mpl2mpl_options.cpp
+  src/parser.cpp
+  src/mir_parser.cpp
+  src/mir_pragma.cpp
+  src/printing.cpp
+  src/bin_func_import.cpp
+  src/bin_func_export.cpp
+  src/bin_mpl_import.cpp
+  src/bin_mpl_export.cpp
+  src/debug_info.cpp
+  src/debug_info_util.cpp
+  ${MAPLEALL_ROOT}/maple_ipa/src/old/ea_connection_graph.cpp
+)
+
+set(src_irbuild "src/driver.cpp")
+
+set(src_mpldbg "src/mpl_dbg.cpp")
+
+set(deps_libmplir
+    libdriver_option
+    libmplphase
+    libmplutil
+    libcommandline
+)
+
+set(deps_irbuild
+    libmplir
+    libmplphase
+    libmplutil
+    libcommandline
+    libmempool
+    libmpl2mpl
+    libHWSecureC
+    libdriver_option
+)
+
+set(CMAKE_CXX_FLAGS
+    "${CMAKE_CXX_FLAGS} -DSTORE_BACK_VTABLE_REF_AFTER_LOAD=1")
+
+#libmplir
+add_library(libmplir STATIC ${src_libmplir})
+set_target_properties(libmplir PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${inc_libmplir}"
+    LINK_LIBRARIES "${deps_libmplir}"
+    ARCHIVE_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}"
+)
+
+#irbuild
+add_executable(irbuild "${src_irbuild}")
+set_target_properties(irbuild PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${inc_libmplir}"
+    LINK_LIBRARIES "${deps_irbuild}"
+    RUNTIME_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/bin"
+)
+
+#mpldbg
+add_executable(mpldbg "${src_mpldbg}")
+set_target_properties(mpldbg PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${inc_libmplir}"
+    LINK_LIBRARIES "${deps_irbuild}"
+    RUNTIME_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/bin"
+)
+
diff --git a/src/mapleall/maple_ir/include/all_attributes.def b/src/mapleall/maple_ir/include/all_attributes.def
new file mode 100644
index 0000000000000000000000000000000000000000..61957ab1b6743221293f8ca73e918830844b9ad2
--- /dev/null
+++ b/src/mapleall/maple_ir/include/all_attributes.def
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+/* all possible attribute names from typeattrs.def, funcattrs.def and fieldattrs.def */
+  ATTR(const)
+  ATTR(final)
+  ATTR(generic)
+  ATTR(implicit)
+  ATTR(private)
+  ATTR(protected)
+  ATTR(public)
+  ATTR(static)
+  ATTR(synthetic)
+  ATTR(used)
+  ATTR(hiddenapiblack)
+  ATTR(hiddenapigrey)
+#ifdef FUNC_ATTR
+  ATTR(bridge)
+  ATTR(constructor)
+  ATTR(critical_native)
+  ATTR(declared_synchronized)
+  ATTR(default)
+  ATTR(destructor)
+  ATTR(delete)
+  ATTR(fast_native)
+  ATTR(inline)
+  ATTR(always_inline)
+  ATTR(gnu_inline)
+  ATTR(noinline)
+  ATTR(native)
+  ATTR(strict)
+  ATTR(varargs)
+  ATTR(virtual)
+  ATTR(nosideeffect)
+  ATTR(pure)
+  ATTR(noexcept)
+  ATTR(nodefargeffect)
+  ATTR(nodefeffect)
+  ATTR(noretglobal)
+  ATTR(nothrow_exception)
+  ATTR(noretarg)
+  ATTR(noprivate_defeffect)
+  ATTR(ipaseen)
+  ATTR(rclocalunowned)
+  ATTR(callersensitive)
+  ATTR(weakref)
+  ATTR(safed)
+  ATTR(unsafed)
+  ATTR(noreturn)
+#endif
+#if defined(FUNC_ATTR) || defined(TYPE_ATTR)
+  ATTR(abstract)
+  ATTR(extern)
+  ATTR(interface)
+  ATTR(local)
+  ATTR(optimized)
+  ATTR(synchronized)
+  ATTR(weak)
+#endif
+#if defined(TYPE_ATTR) || defined(FIELD_ATTR)
+#include "memory_order_attrs.def"
+  ATTR(enum)
+  ATTR(restrict)
+  ATTR(transient)
+  ATTR(volatile)
+  ATTR(rcunowned)
+  ATTR(rcweak)
+  ATTR(final_boundary_size)
+  ATTR(tls_static)
+  ATTR(tls_dynamic)
+#endif
+#ifdef TYPE_ATTR
+  ATTR(annotation)
+  ATTR(readonly)
+  ATTR(verified)
+  ATTR(localrefvar)
+  ATTR(rcunownedthis)
+  ATTR(incomplete_array)
+  ATTR(may_alias)
+  ATTR(static_init_zero)
+#endif
+#ifdef FUNC_ATTR
+  ATTR(firstarg_return)
+  ATTR(called_once)
+#endif
+#ifdef STMT_ATTR
+  ATTR(insaferegion)
+#endif
+  ATTR(oneelem_simd)
+  ATTR(nonnull)
+  ATTR(section)
+  ATTR(asmattr)
+#if defined(FUNC_ATTR) && !defined(NOCONTENT_ATTR)
+  ATTR(alias)
+  ATTR(constructor_priority)
+  ATTR(destructor_priority)
+#endif
+#if (defined(TYPE_ATTR) || defined(FIELD_ATTR)) && !defined(NOCONTENT_ATTR)
+  ATTR(pack)
+#endif
+#ifdef FUNC_ATTR
+  ATTR(initialization)
+  ATTR(termination)
+  ATTR(outlined)
+#endif
diff --git a/src/mapleall/maple_ir/include/bin_mir_file.h b/src/mapleall/maple_ir/include/bin_mir_file.h
new file mode 100644
index 0000000000000000000000000000000000000000..2cc010c8d37c9911083903289b6064051bda0507
--- /dev/null
+++ b/src/mapleall/maple_ir/include/bin_mir_file.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_BIN_MIR_FILE_H
+#define MAPLE_IR_INCLUDE_BIN_MIR_FILE_H
+#include <string>
+#include "types_def.h"
+
+namespace maple {
+const std::string kBinMirFileID = "HWCMPL";  // for magic in file header
+constexpr uint8 kVersionMajor = 0;           // experimental version
+constexpr uint8 kVersionMinor = 1;
+constexpr int kMagicSize = 7;
+
+enum BinMirFileType {
+  kMjsvmFileTypeCmplV1,
+  kMjsvmFileTypeCmpl,  // kCmpl v2 is the release version of
+  kMjsvmFileTypeUnknown
+};
+
+inline uint8 MakeVersionNum(uint8 major, uint8 minor) {
+  uint8 mj = major & 0x0Fu;
+  uint8 mn = minor & 0x0Fu;
+  constexpr uint8 shiftNum = 4;
+  return (mj << shiftNum) | mn;
+}
+
+// file header for binary format kMmpl, 8B in total
+// Note the header is different with the specification
+struct BinMIRFileHeader {
+  char magic[kMagicSize]; // “HWCMPL”, or "HWLOS_"
+  uint8 segNum;    // number of segments (e.g. one raw IR file is a segment unit)
+  uint8 type;      // enum of type of VM file (e.g. MapleIR, TE)
+  uint8 version;   // version of IR format (should be major.minor)
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_BIN_MIR_FILE_H
diff --git a/src/mapleall/maple_ir/include/bin_mpl_export.h b/src/mapleall/maple_ir/include/bin_mpl_export.h
new file mode 100644
index 0000000000000000000000000000000000000000..3f849583dd17eefcce0899245f2a6a02a159bd05
--- /dev/null
+++ b/src/mapleall/maple_ir/include/bin_mpl_export.h
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_BIN_MPL_EXPORT_H
+#define MAPLE_IR_INCLUDE_BIN_MPL_EXPORT_H
+#include "mir_module.h"
+#include "mir_nodes.h"
+#include "mir_function.h"
+#include "mir_preg.h"
+#include "mir_enum.h"
+#include "parser_opt.h"
+#include "ea_connection_graph.h"
+
+namespace maple {
+enum : uint8 {
+  kBinString = 1,
+  kBinUsrString = kBinString,
+  kBinInitConst = 2,
+  kBinSymbol = 3,
+  kBinFunction = 4,
+  kBinCallinfo = 5,
+  kBinKindTypeScalar = 6,
+  kBinKindTypeByName = 7,
+  kBinKindTypePointer = 8,
+  kBinKindTypeFArray = 9,
+  kBinKindTypeJarray = 10,
+  kBinKindTypeArray = 11,
+  kBinKindTypeFunction = 12,
+  kBinKindTypeParam = 13,
+  kBinKindTypeInstantVector = 14,
+  kBinKindTypeGenericInstant = 15,
+  kBinKindTypeBitField = 16,
+  kBinKindTypeStruct = 17,     // for kTypeStruct, kTypeStructIncomplete and kTypeUnion
+  kBinKindTypeClass = 18,      // for kTypeClass, and kTypeClassIncomplete
+  kBinKindTypeInterface = 19,  // for kTypeInterface, and kTypeInterfaceIncomplete
+  kBinKindConstInt = 20,
+  kBinKindConstAddrof = 21,
+  kBinKindConstAddrofFunc = 22,
+  kBinKindConstStr = 23,
+  kBinKindConstStr16 = 24,
+  kBinKindConstFloat = 25,
+  kBinKindConstDouble = 26,
+  kBinKindConstAgg = 27,
+  kBinKindConstSt = 28,
+  kBinContentStart = 29,
+  kBinStrStart = 30,
+  kBinTypeStart = 31,
+  kBinCgStart = 32,
+  kBinSeStart = 33,
+  kBinFinish = 34,
+  kStartMethod = 35,
+  kBinEaCgNode = 36,
+  kBinEaCgActNode = 37,
+  kBinEaCgFieldNode = 38,
+  kBinEaCgRefNode = 39,
+  kBinEaCgObjNode = 40,
+  kBinEaCgStart = 41,
+  kBinEaStart = 42,
+  kBinNodeBlock = 43,
+  kBinEnumeration = 44,
+  kBinEnumStart = 45,
+  kBinReturnvals = 46,
+  kBinTypeTabStart = 47,
+  kBinSymStart = 48,
+  kBinSymTabStart = 49,
+  kBinFuncIdInfoStart = 50,
+  kBinFormalStart = 51,
+  kBinPreg = 52,
+  kBinSpecialReg = 53,
+  kBinLabel = 54,
+  kBinTypenameStart = 55,
+  kBinHeaderStart = 56,
+  kBinAliasMapStart = 57,
+// kBinKindTypeViaTypename : 58,
+// kBinKindSymViaSymname : 59,
+// kBinKindFuncViaSymname : 60,
+  kBinFunctionBodyStart = 61,
+  kBinFormalWordsTypeTagged = 62,
+  kBinFormalWordsRefCounted = 63,
+  kBinLocalWordsTypeTagged = 64,
+  kBinLocalWordsRefCounter = 65,
+  kBinKindConstAddrofLabel = 66,
+  kBinKindConstAddrofLocal = 67,
+};
+
+// this value is used to check wether a file is a binary mplt file
+constexpr int32 kMpltMagicNumber = 0xC0FFEE;
+class BinaryMplExport {
+ public:
+  explicit BinaryMplExport(MIRModule &md);
+  virtual ~BinaryMplExport() = default;
+
+  void Export(const std::string &fname, std::unordered_set<std::string> *dumpFuncSet);
+  void WriteNum(int64 x);
+  void Write(uint8 b);
+  void OutputType(const TyIdx &tyIdx);
+  void WriteFunctionBodyField(uint64 contentIdx, std::unordered_set<std::string> *dumpFuncSet);
+  void OutputConst(MIRConst *constVal);
+  void OutputConstBase(const MIRConst &constVal);
+  void OutputTypeBase(const MIRType &type);
+  void OutputTypePairs(const MIRInstantVectorType &type);
+  void OutputStr(const GStrIdx &gstr);
+  void OutputUsrStr(UStrIdx ustr);
+  void OutputTypeAttrs(const TypeAttrs &ta);
+  void OutputPragmaElement(const MIRPragmaElement &e);
+  void OutputPragma(const MIRPragma &p);
+  void OutputFieldPair(const FieldPair &fp);
+  void OutputMethodPair(const MethodPair &memPool);
+  void OutputFieldsOfStruct(const FieldVector &fields);
+  void OutputMethodsOfStruct(const MethodVector &methods);
+  void OutputStructTypeData(const MIRStructType &type);
+  void OutputImplementedInterfaces(const std::vector<TyIdx> &interfaces);
+  void OutputInfoIsString(const std::vector<bool> &infoIsString);
+  void OutputInfo(const std::vector<MIRInfoPair> &info, const std::vector<bool> &infoIsString);
+  void OutputPragmaVec(const std::vector<MIRPragma*> &pragmaVec);
+  void OutputClassTypeData(const MIRClassType &type);
+  void OutputSymbol(MIRSymbol *sym);
+  void OutputEnumeration(MIREnum *mirEnum);
+  void OutputFunction(PUIdx puIdx);
+  void OutputInterfaceTypeData(const MIRInterfaceType &type);
+  void OutputSrcPos(const SrcPosition &pos);
+  void OutputAliasMap(MapleMap<GStrIdx, MIRAliasVars> &aliasVarMap);
+  void OutputInfoVector(const MIRInfoVector &infoVector, const MapleVector<bool> &infoVectorIsString);
+  void OutputFuncIdInfo(MIRFunction *func);
+  void OutputLocalSymbol(MIRSymbol *sym);
+  void OutputPreg(MIRPreg *preg);
+  void OutputLabel(LabelIdx lidx);
+  void OutputLocalTypeNameTab(const MIRTypeNameTable *typeNameTab);
+  void OutputFormalsStIdx(MIRFunction *func);
+  void OutputFuncViaSym(PUIdx puIdx);
+  void OutputExpression(BaseNode *e);
+  void OutputBaseNode(const BaseNode *b);
+  void OutputReturnValues(const CallReturnVector *retv);
+  void OutputBlockNode(BlockNode *block);
+
+  const MIRModule &GetMIRModule() const {
+    return mod;
+  }
+
+  bool not2mplt;  // this export is not to an mplt file
+  MIRFunction *curFunc = nullptr;
+
+ private:
+  using CallSite = std::pair<CallInfo*, PUIdx>;
+  void WriteEaField(const CallGraph &cg);
+  void WriteEaCgField(EAConnectionGraph *eaCg);
+  void OutEaCgNode(EACGBaseNode &node);
+  void OutEaCgBaseNode(const EACGBaseNode &node, bool firstPart);
+  void OutEaCgFieldNode(EACGFieldNode &field);
+  void OutEaCgRefNode(const EACGRefNode &ref);
+  void OutEaCgActNode(const EACGActualNode &act);
+  void OutEaCgObjNode(EACGObjectNode &obj);
+  void WriteCgField(uint64 contentIdx, const CallGraph *cg);
+  void WriteSeField();
+  void OutputCallInfo(CallInfo &callInfo);
+  void WriteContentField4mplt(int fieldNum, uint64 *fieldStartP);
+  void WriteContentField4nonmplt(int fieldNum, uint64 *fieldStartP);
+  void WriteContentField4nonJava(int fieldNum, uint64 *fieldStartP);
+  void WriteStrField(uint64 contentIdx);
+  void WriteHeaderField(uint64 contentIdx);
+  void WriteTypeField(uint64 contentIdx, bool useClassList = true);
+  void Init();
+  void WriteSymField(uint64 contentIdx);
+  void WriteInt(int32 x);
+  uint8 Read();
+  int32 ReadInt();
+  void WriteInt64(int64 x);
+  void WriteAsciiStr(const std::string &str);
+  void Fixup(size_t i, uint32 x);
+  void DumpBuf(const std::string &name);
+  void AppendAt(const std::string &name, int32 offset);
+  void ExpandFourBuffSize();
+  void WriteEnumField(uint64 contentIdx);
+
+  MIRModule &mod;
+  size_t bufI = 0;
+  std::vector<uint8> buf;
+  std::unordered_map<GStrIdx, int64, GStrIdxHash> gStrMark;
+  std::unordered_map<MIRFunction*, int64> funcMark;
+  std::string importFileName;
+  std::unordered_map<UStrIdx, int64, UStrIdxHash> uStrMark;
+  std::unordered_map<const MIRSymbol*, int64> symMark;
+  std::unordered_map<MIRType*, int64> typMark;
+  std::unordered_map<const MIRSymbol*, int64> localSymMark;
+  std::unordered_map<const MIRPreg*, int64> localPregMark;
+  std::unordered_map<LabelIdx, int64> labelMark;
+  friend class UpdateMplt;
+  std::unordered_map<uint32, int64> callInfoMark;
+  std::map<GStrIdx, uint8> *func2SEMap = nullptr;
+  std::unordered_map<EACGBaseNode*, int64> eaNodeMark;
+  bool inIPA = false;
+  static int typeMarkOffset;  // offset of mark (tag in binmplimport) resulting from duplicated function
+};
+
+class UpdateMplt  {
+ public:
+  UpdateMplt() = default;
+  ~UpdateMplt() = default;
+  class ManualSideEffect {
+   public:
+    ManualSideEffect(std::string name, bool p, bool u, bool d, bool o, bool e)
+        : funcName(name), pure(p), defArg(u), def(d), object(o), exception(e) {};
+    virtual ~ManualSideEffect() = default;
+
+    const std::string &GetFuncName() const {
+      return funcName;
+    }
+
+    bool GetPure() const {
+      return pure;
+    }
+
+    bool GetDefArg() const {
+      return defArg;
+    }
+
+    bool GetDef() const {
+      return def;
+    }
+
+    bool GetObject() const {
+      return object;
+    }
+
+    bool GetException() const {
+      return exception;
+    }
+
+    bool GetPrivateUse() const {
+      return privateUse;
+    }
+
+    bool GetPrivateDef() const {
+      return privateDef;
+    }
+
+   private:
+    std::string funcName;
+    bool pure;
+    bool defArg;
+    bool def;
+    bool object;
+    bool exception;
+    bool privateUse = false;
+    bool privateDef = false;
+  };
+  void UpdateCgField(BinaryMplt &binMplt, const CallGraph &cg) const;
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_BIN_MPL_EXPORT_H
diff --git a/src/mapleall/maple_ir/include/bin_mpl_import.h b/src/mapleall/maple_ir/include/bin_mpl_import.h
new file mode 100644
index 0000000000000000000000000000000000000000..bc3ba10fb8fbe9c3e4ae0330c8c438e3eee64e03
--- /dev/null
+++ b/src/mapleall/maple_ir/include/bin_mpl_import.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_BIN_MPL_IMPORT_H
+#define MAPLE_IR_INCLUDE_BIN_MPL_IMPORT_H
+#include "mir_module.h"
+#include "mir_nodes.h"
+#include "mir_preg.h"
+#include "parser_opt.h"
+#include "mir_builder.h"
+#include "ea_connection_graph.h"
+namespace maple {
+class BinaryMplImport {
+ public:
+  explicit BinaryMplImport(MIRModule &md) : mod(md), mirBuilder(&md) {}
+  BinaryMplImport &operator=(const BinaryMplImport&) = delete;
+  BinaryMplImport(const BinaryMplImport&) = delete;
+
+  virtual ~BinaryMplImport() {
+    for (MIRStructType *structPtr : tmpStruct) {
+      delete structPtr;
+    }
+    for (MIRClassType *classPtr : tmpClass) {
+      delete classPtr;
+    }
+    for (MIRInterfaceType *interfacePtr : tmpInterface) {
+      delete interfacePtr;
+    }
+  }
+
+  uint64 GetBufI() const {
+    return bufI;
+  }
+  void SetBufI(uint64 bufIVal) {
+    bufI = bufIVal;
+  }
+
+  bool IsBufEmpty() const {
+    return buf.empty();
+  }
+  size_t GetBufSize() const {
+    return buf.size();
+  }
+
+  int32 GetContent(int64 key) const {
+    return content.at(key);
+  }
+
+  void SetImported(bool importedVal) {
+    imported = importedVal;
+  }
+
+  bool Import(const std::string &fname, bool readSymbols = false, bool readSe = false);
+  bool ImportForSrcLang(const std::string &fname, MIRSrcLang &srcLang);
+  MIRSymbol *GetOrCreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mclass, MIRStorageClass sclass,
+                               MIRFunction *func, uint8 scpID);
+  int32 ReadInt();
+  int64 ReadNum();
+ private:
+  void ReadContentField();
+  void ReadStrField();
+  void ReadHeaderField();
+  void ReadTypeField();
+  void ReadSymField();
+  void ReadSymTabField();
+  void ReadCgField();
+  EAConnectionGraph *ReadEaCgField();
+  void ReadEaField();
+  EACGBaseNode &InEaCgNode(EAConnectionGraph &newEaCg);
+  void InEaCgBaseNode(EACGBaseNode &base, EAConnectionGraph &newEaCg, bool firstPart);
+  void InEaCgActNode(EACGActualNode &actual);
+  void InEaCgFieldNode(EACGFieldNode &field, EAConnectionGraph &newEaCg);
+  void InEaCgObjNode(EACGObjectNode &obj, EAConnectionGraph &newEaCg);
+  void InEaCgRefNode(EACGRefNode &ref);
+  CallInfo *ImportCallInfo();
+  void MergeDuplicated(PUIdx methodPuidx, std::vector<CallInfo*> &targetSet, std::vector<CallInfo*> &newSet);
+  void ReadSeField();
+  void Jump2NextField();
+  void Reset();
+  void SkipTotalSize();
+  void ImportFieldsOfStructType(FieldVector &fields, uint32 methodSize);
+  MIRType &InsertInTypeTables(MIRType &ptype);
+  void InsertInHashTable(MIRType &type);
+  void SetupEHRootType();
+  void UpdateMethodSymbols();
+  void ImportConstBase(MIRConstKind &kind, MIRTypePtr &type);
+  MIRConst *ImportConst(MIRFunction *func);
+  GStrIdx ImportStr();
+  UStrIdx ImportUsrStr();
+  MIRType *CreateMirType(MIRTypeKind kind, GStrIdx strIdx, int64 tag) const;
+  MIRGenericInstantType *CreateMirGenericInstantType(GStrIdx strIdx) const;
+  MIRBitFieldType *CreateBitFieldType(uint8 fieldsize, PrimType pt, GStrIdx strIdx) const;
+  void CompleteAggInfo(TyIdx tyIdx);
+  TyIdx ImportType(bool forPointedType = false);
+  TyIdx ImportTypeNonJava();
+  void ImportTypeBase(PrimType &primType, GStrIdx &strIdx, bool &nameIsLocal);
+  void InSymTypeTable();
+  void ImportTypePairs(std::vector<TypePair> &insVecType);
+  TypeAttrs ImportTypeAttrs();
+  MIRPragmaElement *ImportPragmaElement();
+  MIRPragma *ImportPragma();
+  void ImportFieldPair(FieldPair &fp);
+  void ImportMethodPair(MethodPair &memPool);
+  void ImportMethodsOfStructType(MethodVector &methods);
+  void ImportStructTypeData(MIRStructType &type);
+  void ImportInterfacesOfClassType(std::vector<TyIdx> &interfaces);
+  void ImportInfoIsStringOfStructType(MIRStructType &type);
+  void ImportInfoOfStructType(MIRStructType &type);
+  void ImportPragmaOfStructType(MIRStructType &type);
+  void SetClassTyidxOfMethods(MIRStructType &type) const;
+  void ImportClassTypeData(MIRClassType &type);
+  void ImportInterfaceTypeData(MIRInterfaceType &type);
+  PUIdx ImportFunction();
+  MIRSymbol *InSymbol(MIRFunction *func);
+  void ImportInfoVector(MIRInfoVector &infoVector, MapleVector<bool> &infoVectorIsString);
+  void ImportLocalTypeNameTable(MIRTypeNameTable *typeNameTab);
+  void ImportFuncIdInfo(MIRFunction *func);
+  void ImportEnumeration();
+  MIRSymbol *ImportLocalSymbol(MIRFunction *func);
+  PregIdx ImportPreg(MIRFunction *func);
+  LabelIdx ImportLabel(MIRFunction *func);
+  void ImportFormalsStIdx(MIRFunction *func);
+  void ImportAliasMap(MIRFunction *func);
+  void ImportSrcPos(SrcPosition &pos);
+  void ImportBaseNode(Opcode &o, PrimType &typ);
+  PUIdx ImportFuncViaSym(MIRFunction *func);
+  BaseNode *ImportExpression(MIRFunction *func);
+  void ImportReturnValues(MIRFunction *func, CallReturnVector *retv);
+  BlockNode *ImportBlockNode(MIRFunction *func);
+  void ReadFunctionBodyField();
+  void ReadEnumField();
+  void ReadFileAt(const std::string &name, int32 offset);
+  uint8 Read();
+  int64 ReadInt64();
+  void ReadAsciiStr(std::string &str);
+  int32 GetIPAFileIndex(std::string &name);
+
+  bool inCG = false;
+  bool inIPA = false;
+  bool imported = true;  // used only by irbuild to convert to ascii
+  bool importingFromMplt = false;  // decided based on magic number
+  uint64 bufI = 0;
+  std::vector<uint8> buf;
+  std::map<int64, int32> content;
+  MIRModule &mod;
+  MIRBuilder mirBuilder;
+  std::vector<GStrIdx> gStrTab;
+  std::vector<UStrIdx> uStrTab;
+  std::vector<MIRStructType*> tmpStruct;
+  std::vector<MIRClassType*> tmpClass;
+  std::vector<MIRInterfaceType*> tmpInterface;
+  std::vector<TyIdx> typTab;
+  std::vector<MIRFunction*> funcTab;
+  std::vector<MIRSymbol*> symTab;
+  std::vector<MIRSymbol*> localSymTab;
+  std::vector<PregIdx> localPregTab;
+  std::vector<LabelIdx> localLabelTab;
+  std::vector<CallInfo*> callInfoTab;
+  std::vector<EACGBaseNode*> eaCgTab;
+  std::vector<MIRSymbol*> methodSymbols;
+  std::vector<bool> definedLabels;
+  std::string importFileName;
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_BIN_MPL_IMPORT_H
diff --git a/src/mapleall/maple_ir/include/bin_mplt.h b/src/mapleall/maple_ir/include/bin_mplt.h
new file mode 100644
index 0000000000000000000000000000000000000000..e3e8359c1f9280775c68c1ae3c8b657172afdc7a
--- /dev/null
+++ b/src/mapleall/maple_ir/include/bin_mplt.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_BIN_MPLT_H
+#define MAPLE_IR_INCLUDE_BIN_MPLT_H
+#include "mir_module.h"
+#include "mir_nodes.h"
+#include "mir_preg.h"
+#include "parser_opt.h"
+#include "bin_mpl_export.h"
+#include "bin_mpl_import.h"
+
+namespace maple {
+class BinaryMplt {
+ public:
+
+  explicit BinaryMplt(MIRModule &md) : mirModule(md), binImport(md), binExport(md) {}
+
+  virtual ~BinaryMplt() = default;
+
+  void Export(const std::string &suffix, std::unordered_set<std::string> *dumpFuncSet = nullptr) {
+    binExport.Export(suffix, dumpFuncSet);
+  }
+
+  bool Import(const std::string &modID, bool readCG = false, bool readSE = false) {
+    importFileName = modID;
+    return binImport.Import(modID, readCG, readSE);
+  }
+
+  const MIRModule &GetMod() const {
+    return mirModule;
+  }
+
+  BinaryMplImport &GetBinImport() {
+    return binImport;
+  }
+
+  BinaryMplExport &GetBinExport() {
+    return binExport;
+  }
+
+  std::string &GetImportFileName() {
+    return importFileName;
+  }
+
+  void SetImportFileName(const std::string &fileName) {
+    importFileName = fileName;
+  }
+
+ private:
+  MIRModule &mirModule;
+  BinaryMplImport binImport;
+  BinaryMplExport binExport;
+  std::string importFileName;
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_BIN_MPLT_H
diff --git a/src/mapleall/maple_ir/include/binary_op.def b/src/mapleall/maple_ir/include/binary_op.def
new file mode 100644
index 0000000000000000000000000000000000000000..a4a3104c76aab3caf44328daab5f90844877eff4
--- /dev/null
+++ b/src/mapleall/maple_ir/include/binary_op.def
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+BINARYOP(add)
+BINARYOP(ashr)
+BINARYOP(band)
+BINARYOP(bior)
+BINARYOP(bxor)
+BINARYOP(cand)
+BINARYOP(cior)
+BINARYOP(cmp)
+BINARYOP(cmpl)
+BINARYOP(cmpg)
+BINARYOP(div)
+BINARYOP(eq)
+BINARYOP(gt)
+BINARYOP(land)
+BINARYOP(lior)
+BINARYOP(le)
+BINARYOP(lshr)
+BINARYOP(lt)
+BINARYOP(max)
+BINARYOP(min)
+BINARYOP(mul)
+BINARYOP(ne)
+BINARYOP(ge)
+BINARYOP(rem)
+BINARYOP(shl)
+BINARYOP(ror)
+BINARYOP(sub)
+BINARYOP(CG_array_elem_add)
+
diff --git a/src/mapleall/maple_ir/include/cfg_primitive_types.h b/src/mapleall/maple_ir/include/cfg_primitive_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..65f9ba78c5551e326e96d80244cf00ecac74d6f0
--- /dev/null
+++ b/src/mapleall/maple_ir/include/cfg_primitive_types.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_CFG_PRIMITIVE_TYPES_H
+#define MAPLE_IR_INCLUDE_CFG_PRIMITIVE_TYPES_H
+
+#include "types_def.h"
+
+namespace maple {
+uint8 GetPointerSize(); // Circular include dependency with mir_type.h
+
+// Declaration of enum PrimType
+#define LOAD_ALGO_PRIMARY_TYPE
+enum PrimType {
+  PTY_begin,            // PrimType begin
+#define PRIMTYPE(P) PTY_##P,
+#include "prim_types.def"
+  PTY_end,              // PrimType end
+#undef PRIMTYPE
+};
+
+constexpr PrimType kPtyInvalid = PTY_begin;
+// just for test, no primitive type for derived SIMD types to be defined
+constexpr PrimType kPtyDerived = PTY_end;
+
+struct PrimitiveTypeProperty {
+  PrimType type;
+
+  PrimitiveTypeProperty(PrimType type, bool isInteger, bool isUnsigned,
+                        bool isAddress, bool isFloat, bool isPointer,
+                        bool isSimple, bool isDynamic, bool isDynamicAny,
+                        bool isDynamicNone, bool isVector) :
+                        type(type), isInteger(isInteger), isUnsigned(isUnsigned),
+                        isAddress(isAddress), isFloat(isFloat), isPointer(isPointer),
+                        isSimple(isSimple), isDynamic(isDynamic), isDynamicAny(isDynamicAny),
+                        isDynamicNone(isDynamicNone), isVector(isVector) {}
+
+  bool IsInteger() const { return isInteger; }
+  bool IsUnsigned() const { return isUnsigned; }
+
+  bool IsAddress() const {
+    if (type == PTY_u64 || type == PTY_u32) {
+      if ((type == PTY_u64 && GetPointerSize() == 8) ||
+          (type == PTY_u32 && GetPointerSize() == 4)) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return isAddress;
+    }
+  }
+
+  bool IsFloat() const { return isFloat; }
+
+  bool IsPointer() const {
+    if (type == PTY_u64 || type == PTY_u32) {
+      if ((type == PTY_u64 && GetPointerSize() == 8) ||
+          (type == PTY_u32 && GetPointerSize() == 4)) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return isPointer;
+    }
+  }
+
+  bool IsSimple() const { return isSimple; }
+  bool IsDynamic() const { return isDynamic; }
+  bool IsDynamicAny() const { return isDynamicAny; }
+  bool IsDynamicNone() const { return isDynamicNone; }
+  bool IsVector() const { return isVector; }
+
+private:
+  bool isInteger;
+  bool isUnsigned;
+  bool isAddress;
+  bool isFloat;
+  bool isPointer;
+  bool isSimple;
+  bool isDynamic;
+  bool isDynamicAny;
+  bool isDynamicNone;
+  bool isVector;
+};
+
+const PrimitiveTypeProperty &GetPrimitiveTypeProperty(PrimType pType);
+} // namespace maple
+#endif  // MAPLE_IR_INCLUDE_CFG_PRIMITIVE_TYPES_H
diff --git a/src/mapleall/maple_ir/include/cmpl.h b/src/mapleall/maple_ir/include/cmpl.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f3a80c36db1c55fc21b88ce40244936c46f807a
--- /dev/null
+++ b/src/mapleall/maple_ir/include/cmpl.h
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// This define the lowest level MAPLE IR data structures that are compatible
+// with both the C++ and C coding environments of MAPLE
+#ifndef MAPLE_INCLUDE_VM_CMPL_V2
+#define MAPLE_INCLUDE_VM_CMPL_V2
+// Still need constant value from MIR
+#include <cstdint>
+#include "mir_config.h"
+#include "types_def.h"
+#include "opcodes.h"
+#include "prim_types.h"
+#include "intrinsics.h"
+#include "mir_module.h"
+
+namespace maple {
+extern char appArray[];
+constexpr uint32 kTwoBitVectors = 2;
+struct MirFuncT {  // 28B
+  uint16 frameSize;
+  uint16 upFormalSize;
+  uint16 moduleID;
+  uint32 funcSize;               // size of code in words
+  uint8 *formalWordsTypetagged;  // bit vector where the Nth bit tells whether
+  // the Nth word in the formal parameters area
+  // addressed upward from %%FP (that means
+  // the word at location (%%FP + N*4)) has
+  // typetag; if yes, the typetag is the word
+  // at (%%FP + N*4 + 4); the bitvector's size
+  // is given by BlockSize2BitvectorSize(upFormalSize)
+  uint8 *localWordsTypetagged;  // bit vector where the Nth bit tells whether
+  // the Nth word in the local stack frame
+  // addressed downward from %%FP (that means
+  // the word at location (%%FP - N*4)) has
+  // typetag; if yes, the typetag is the word
+  // at (%%FP - N*4 + 4); the bitvector's size
+  // is given by BlockSize2BitvectorSize(frameSize)
+  uint8 *formalWordsRefCounted;  // bit vector where the Nth bit tells whether
+  // the Nth word in the formal parameters area
+  // addressed upward from %%FP (that means
+  // the word at location (%%FP + N*4)) points to
+  // a dynamic memory block that needs reference
+  // count; the bitvector's size is given by
+  // BlockSize2BitvectorSize(upFormalSize)
+  uint8 *localWordsRefCounted;  // bit vector where the Nth bit tells whether
+  // the Nth word in the local stack frame
+  // addressed downward from %%FP (that means
+  // the word at location (%%FP - N*4)) points to
+  // a dynamic memory block that needs reference
+  // count; the bitvector's size is given by
+  // BlockSize2BitvectorSize(frameSize)
+  // removed. label table size
+  // lbl2stmt table, removed;
+  // the first statement immediately follow MirFuncT
+  // since it starts with expression, BaseNodeT* is returned
+  void *FirstInst() const {
+    return reinterpret_cast<uint8*>(const_cast<MirFuncT*>(this)) + sizeof(MirFuncT);
+  }
+
+  // there are 4 bitvectors that follow the function code
+  uint32 FuncCodeSize() const {
+    return funcSize - (kTwoBitVectors * BlockSize2BitVectorSize(upFormalSize)) -
+           (kTwoBitVectors * BlockSize2BitVectorSize(frameSize));
+  }
+};
+
+struct MirModuleT {
+ public:
+  MIRFlavor flavor;    // should be kCmpl
+  MIRSrcLang srcLang;  // the source language
+  uint16 id;
+  uint32 globalMemSize;  // size of storage space for all global variables
+  uint8 *globalBlkMap;   // the memory map of the block containing all the
+  // globals, for specifying static initializations
+  uint8 *globalWordsTypetagged;  // bit vector where the Nth bit tells whether
+  // the Nth word in globalBlkMap has typetag;
+  // if yes, the typetag is the N+1th word; the
+  // bitvector's size is given by
+  // BlockSize2BitvectorSize(globalMemSize)
+  uint8 *globalWordsRefCounted;  // bit vector where the Nth bit tells whether
+  // the Nth word points to a reference-counted
+  // dynamic memory block; the bitvector's size
+  // is given by BlockSize2BitvectorSize(globalMemSize)
+  PUIdx mainFuncID;           // the entry function; 0 if no main function
+  uint32 numFuncs;            // because puIdx 0 is reserved, numFuncs is also the highest puIdx
+  MirFuncT **funcs;           // list of all funcs in the module.
+#if 1                         // the js2mpl buld always set HAVE_MMAP to 1 // binmir file mmap info
+  int binMirImageFd;          // file handle for mmap
+#endif                        // HAVE_MMAP
+  void *binMirImageStart;     // binimage memory start
+  uint32 binMirImageLength;   // binimage memory size
+  MirFuncT *FuncFromPuIdx(PUIdx puIdx) const {
+    MIR_ASSERT(puIdx <= numFuncs);  // puIdx starts from 1
+    return funcs[puIdx - 1];
+  }
+
+  MirModuleT() = default;
+  ~MirModuleT() = default;
+  MirFuncT *MainFunc() const {
+    return (mainFuncID == 0) ? static_cast<MirFuncT*>(nullptr) : FuncFromPuIdx(mainFuncID);
+  }
+
+  void SetCurFunction(MirFuncT *f) {
+    curFunction = f;
+  }
+
+  MirFuncT *GetCurFunction() const {
+    return curFunction;
+  }
+
+  MIRSrcLang GetSrcLang() const {
+    return srcLang;
+  }
+
+ private:
+  MirFuncT *curFunction = nullptr;
+};
+
+// At this stage, MirConstT don't need all information in MIRConst
+// Note: only be used within Constval node:
+// Warning: it's different from full feature MIR.
+// only support 32bit int const (lower 32bit). higher 32bit are tags
+union MirIntConstT {
+  int64 value;
+  uint32 val[2];  // ARM target load/store 2 32bit val instead of 1 64bit
+};
+
+// currently in VM, only intconst are used.
+using MirConstT = MirIntConstT;
+//
+// It's a stacking of POD data structure to allow precise memory layout
+// control and emulate the inheritance relationship of corresponding C++
+// data structures to keep the interface consistent (as much as possible).
+//
+// Rule:
+// 1. base struct should be the first member (to allow safe pointer casting)
+// 2. each node (just ops, no data) should be of either 4B or 8B.
+// 3. casting the node to proper base type to access base type's fields.
+//
+// Current memory layout of nodes follows the postfix notation:
+// Each operand instruction is positioned immediately before its parent or
+// next operand. Memory layout of sub-expressions tree is done recursively.
+// E.g. the code for (a + b) contains 3 instructions, starting with the READ a,
+// READ b, and then followed by ADD.
+// For (a + (b - c)), it is:
+//
+// READ a
+// READ b
+// READ c
+// SUB
+// ADD
+//
+// BaseNodeT is an abstraction of expression.
+struct BaseNodeT {  // 4B
+  Opcode op;
+  PrimType ptyp;
+  uint8 typeFlag;  // a flag to speed up type related operations in the VM
+  uint8 numOpnds;  // only used for N-ary operators, switch and rangegoto
+  // operands immediately before each node
+  virtual size_t NumOpnds() const {
+    if (op == OP_switch || op == OP_rangegoto) {
+      return 1;
+    }
+    return numOpnds;
+  }
+
+  virtual uint8 GetNumOpnds() const {
+    return numOpnds;
+  }
+  virtual void SetNumOpnds(uint8 num) {
+    numOpnds = num;
+  }
+
+  virtual Opcode GetOpCode() const {
+    return op;
+  }
+
+  virtual void SetOpCode(Opcode o) {
+    op = o;
+  }
+
+  virtual PrimType GetPrimType() const {
+    return ptyp;
+  }
+
+  virtual void SetPrimType(PrimType type) {
+    ptyp = type;
+  }
+
+  BaseNodeT() : op(OP_undef), ptyp(kPtyInvalid), typeFlag(0), numOpnds(0) {}
+
+  virtual ~BaseNodeT() = default;
+};
+
+// typeFlag is a 8bit flag to provide short-cut information for its
+// associated PrimType, because many type related information extraction
+// is not very lightweight.
+// Here is the convention:
+// |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0  |
+//   dyn    f     i     sc    c     (log2(size))
+//
+// bit 0 - bit 3 is for type size information. (now not used in VM?)
+//   bit 0-2 represents the size of concrete types (not void/aggregate)
+//   it's the result of log2 operation on the real size to fit in 3 bits.
+//   which has the following correspondence:
+//   | 2 | 1 | 0 |              type size (in Bytes)
+//     0   0   0                      1
+//     0   0   1                      2
+//     0   1   0                      4
+//     0   1   1                      8
+//     1   0   0                     16
+//
+// bit 3 is the flag of "concrete types", i.e., types we know the type
+// details.
+// when it's 1, the bit0-2 size are valid
+// when it's 0, the size of the type is 0, and bit0-2 are meaningless.
+//
+// bit 4 is for scalar types (1 if it's a scalar type)
+// bit 5 is for integer types (1 if it's an integer type)
+// bit 6 is for floating types (1 if it's a floating type)
+// bit 7 is for dynamic types (1 if it's a dynamic type)
+//
+// refer to mirtypes.h/mirtypes.cpp in maple_ir directory for more information.
+const int32 kTypeflagZero = 0x00;
+const int32 kTypeflagDynMask = 0x80;
+const int32 kTypeflagFloatMask = 0x40;
+const int32 kTypeflagIntergerMask = 0x20;
+const int32 kTypeflagScalarMask = 0x10;
+const int32 kTypeflagConcreteMask = 0x08;
+const int32 kTypeflagSizeMask = 0x07;
+const int32 kTypeflagDynFloatMask = (kTypeflagDynMask | kTypeflagFloatMask);
+const int32 kTypeflagDynIntergerMask = (kTypeflagDynMask | kTypeflagIntergerMask);
+inline bool IsDynType(uint8 typeFlag) {
+  return ((typeFlag & kTypeflagDynMask) != kTypeflagZero);
+}
+
+inline bool IsDynFloat(uint8 typeFlag) {
+  return ((typeFlag & kTypeflagDynFloatMask) == kTypeflagDynFloatMask);
+}
+
+inline bool IsDynInteger(uint8 typeFlag) {
+  return ((typeFlag & kTypeflagDynIntergerMask) == kTypeflagDynIntergerMask);
+}
+
+// IsFloat means "is statically floating types", i.e., float, but not dynamic
+inline bool IsFloat(uint8 typeFlag) {
+  return ((typeFlag & kTypeflagDynFloatMask) == kTypeflagFloatMask);
+}
+
+inline bool IsScalarType(uint8 typeFlag) {
+  return ((typeFlag & kTypeflagScalarMask) != kTypeflagZero);
+}
+
+inline Opcode GetOpcode(const BaseNodeT &nodePtr) {
+  return nodePtr.op;
+}
+
+inline PrimType GetPrimType(const BaseNodeT &nodePtr) {
+  return nodePtr.ptyp;
+}
+
+inline uint32 GetOperandsNum(const BaseNodeT &nodePtr) {
+  return nodePtr.numOpnds;
+}
+
+using UnaryNodeT = BaseNodeT;             // alias
+struct TypecvtNodeT : public BaseNodeT {  // 8B
+  PrimType fromPTyp;
+  uint8 fromTypeFlag;  // a flag to speed up type related operations
+  uint8 padding[2];
+  PrimType FromType() const {
+    return fromPTyp;
+  }
+};
+
+struct ExtractbitsNodeT : public BaseNodeT {  // 8B
+  uint8 bOffset;
+  uint8 bSize;
+  uint16 padding;
+};
+
+struct IreadoffNodeT : public BaseNodeT {  // 8B
+  int32 offset;
+};
+
+using BinaryNodeT = BaseNodeT;
+// Add expression types to compare node, to
+// facilitate the evaluation of postorder stored kCmpl
+// Note: the two operands should have the same type if they're
+//       not dynamic types
+struct CompareNodeT : public BaseNodeT {  // 8B
+  PrimType opndType;                      // type of operands.
+  uint8 opndTypeFlag;                     // typeFlag of opntype.
+  uint8 padding[2];                       // every compare node has two opnds.
+};
+
+using TernaryNodeT = BaseNodeT;
+using NaryNodeT = BaseNodeT;
+// need to guarantee MIRIntrinsicID is 4B
+// Note: this is not supported by c++0x
+struct IntrinsicopNodeT : public BaseNodeT {  // 8B
+  MIRIntrinsicID intrinsic;
+};
+
+struct ConstvalNodeT : public BaseNodeT {  // 4B + 8B const value
+  MirConstT *Constval() const {
+    auto *tempPtr = const_cast<ConstvalNodeT*>(this);
+    return (reinterpret_cast<MirConstT*>(reinterpret_cast<uint8*>(tempPtr) + sizeof(ConstvalNodeT)));
+  }
+};
+
+// full MIR exported a pointer to MirConstT
+inline MirConstT *GetConstval(const ConstvalNodeT &node) {
+  return node.Constval();
+}
+
+// SizeoftypeNode shouldn't be seen here
+// ArrayNode shouldn't be seen here
+struct AddrofNodeT : public BaseNodeT {  // 12B
+  StIdx stIdx;
+  FieldID fieldID;
+};
+
+using DreadNodeT = AddrofNodeT;              // same shape.
+struct AddroffuncNodeT : public BaseNodeT {  // 8B
+  PUIdx puIdx;                               // 32bit now
+};
+
+struct RegreadNodeT : public BaseNodeT {  // 8B
+  PregIdx regIdx;                         // 32bit, negative if special register
+};
+
+struct AddroflabelNodeT : public BaseNodeT {  // 8B
+  uint32 offset;
+};
+}  // namespace maple
+#endif  // MAPLE_INCLUDE_VM_CMPL_V2
diff --git a/src/mapleall/maple_ir/include/debug_info.h b/src/mapleall/maple_ir/include/debug_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..937d18a2131423ab886ff7e2f9640d8524851075
--- /dev/null
+++ b/src/mapleall/maple_ir/include/debug_info.h
@@ -0,0 +1,857 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_IR_INCLUDE_DBG_INFO_H
+#define MAPLE_IR_INCLUDE_DBG_INFO_H
+#include <iostream>
+
+#include "mpl_logging.h"
+#include "types_def.h"
+#include "prim_types.h"
+#include "mir_nodes.h"
+#include "mir_scope.h"
+#include "namemangler.h"
+#include "lexer.h"
+#include "Dwarf.h"
+
+namespace maple {
+// for more color code: http://ascii-table.com/ansi-escape-sequences.php
+#define RESET "\x1B[0m"
+#define BOLD "\x1B[1m"
+#define RED "\x1B[31m"
+#define GRN "\x1B[32m"
+#define YEL "\x1B[33m"
+
+const uint32 kDbgDefaultVal = 0xdeadbeef;
+#define HEX(val) std::hex << "0x" << (val) << std::dec
+
+class MIRModule;
+class MIRType;
+class MIRSymbol;
+class MIRSymbolTable;
+class MIRTypeNameTable;
+class DBGBuilder;
+class DBGCompileMsgInfo;
+class MIRLexer;
+class MIREnum;
+
+// for compiletime warnings
+class DBGLine {
+ public:
+  DBGLine(uint32 lnum, const char *l) : lineNum(lnum), codeLine(l) {}
+  virtual ~DBGLine() {}
+
+  void Dump() const {
+    LogInfo::MapleLogger() << "LINE: " << lineNum << " " << codeLine << std::endl;
+  }
+
+ private:
+  uint32 lineNum;
+  const char *codeLine;
+};
+
+#define MAXLINELEN 4096
+
+class DBGCompileMsgInfo {
+ public:
+  DBGCompileMsgInfo();
+  virtual ~DBGCompileMsgInfo() {}
+  void ClearLine(uint32 n);
+  void SetErrPos(uint32 lnum, uint32 cnum);
+  void UpdateMsg(uint32 lnum, const char *line);
+  void EmitMsg();
+
+ private:
+  uint32 startLine;  // mod 3
+  uint32 errLNum;
+  uint32 errCNum;
+  uint32 errPos;
+  uint32 lineNum[3];
+  uint8 codeLine[3][MAXLINELEN];  // 3 round-robin line buffers
+};
+
+enum DBGDieKind { kDwTag, kDwAt, kDwOp, kDwAte, kDwForm, kDwCfa };
+
+using DwTag = uint32;   // for DW_TAG_*
+using DwAt = uint32;    // for DW_AT_*
+using DwOp = uint32;    // for DW_OP_*
+using DwAte = uint32;   // for DW_ATE_*
+using DwForm = uint32;  // for DW_FORM_*
+using DwCfa = uint32;   // for DW_CFA_*
+
+class DBGDieAttr;
+
+class DBGExpr {
+ public:
+  explicit DBGExpr(MIRModule *m) : dwOp(0), value(kDbgDefaultVal), opnds(m->GetMPAllocator().Adapter()) {}
+
+  DBGExpr(MIRModule *m, DwOp op) : dwOp(op), value(kDbgDefaultVal), opnds(m->GetMPAllocator().Adapter()) {}
+
+  virtual ~DBGExpr() {}
+
+  void AddOpnd(uint64 val) {
+    opnds.push_back(val);
+  }
+
+  int GetVal() const {
+    return value;
+  }
+
+  void SetVal(int v) {
+    value = v;
+  }
+
+  DwOp GetDwOp() const {
+    return dwOp;
+  }
+
+  void SetDwOp(DwOp op) {
+    dwOp = op;
+  }
+
+  MapleVector<uint64> &GetOpnd() {
+    return opnds;
+  }
+
+  size_t GetOpndSize() const {
+    return opnds.size();
+  }
+
+  void Clear() {
+    return opnds.clear();
+  }
+
+ private:
+  DwOp dwOp;
+  // for local var fboffset, global var strIdx
+  int value;
+  MapleVector<uint64> opnds;
+};
+
+class DBGExprLoc {
+ public:
+  explicit DBGExprLoc(MIRModule *m) : module(m), exprVec(m->GetMPAllocator().Adapter()), symLoc(nullptr) {
+    simpLoc = m->GetMemPool()->New<DBGExpr>(module);
+  }
+
+  DBGExprLoc(MIRModule *m, DwOp op) : module(m), exprVec(m->GetMPAllocator().Adapter()), symLoc(nullptr) {
+    simpLoc = m->GetMemPool()->New<DBGExpr>(module, op);
+  }
+
+  virtual ~DBGExprLoc() {}
+
+  bool IsSimp() const {
+    return (exprVec.size() == 0 && simpLoc->GetVal() != static_cast<int>(kDbgDefaultVal));
+  }
+
+  int GetFboffset() const {
+    return simpLoc->GetVal();
+  }
+
+  void SetFboffset(int offset) {
+    simpLoc->SetVal(offset);
+  }
+
+  int GetGvarStridx() const {
+    return simpLoc->GetVal();
+  }
+
+  void SetGvarStridx(int idx) {
+    simpLoc->SetVal(idx);
+  }
+
+  DwOp GetOp() const {
+    return simpLoc->GetDwOp();
+  }
+
+  uint32 GetSize() const {
+    return static_cast<uint32>(simpLoc->GetOpndSize());
+  }
+
+  void ClearOpnd() {
+    simpLoc->Clear();
+  }
+
+  void AddSimpLocOpnd(uint64 val) {
+    simpLoc->AddOpnd(val);
+  }
+
+  DBGExpr *GetSimpLoc() const {
+    return simpLoc;
+  }
+
+  void *GetSymLoc() {
+    return symLoc;
+  }
+
+  void SetSymLoc(void *loc) {
+    symLoc = loc;
+  }
+
+  void Dump() const;
+
+ private:
+  MIRModule *module;
+  DBGExpr *simpLoc;
+  MapleVector<DBGExpr> exprVec;
+  void *symLoc;
+};
+
+class DBGDieAttr {
+ public:
+  explicit DBGDieAttr(DBGDieKind k) : dieKind(k), dwAttr(DW_AT_deleted), dwForm(DW_FORM_GNU_strp_alt) {
+    value.u = kDbgDefaultVal;
+  }
+
+  virtual ~DBGDieAttr() = default;
+
+  size_t SizeOf(DBGDieAttr *attr) const;
+
+  void AddSimpLocOpnd(uint64 val) {
+    value.ptr->AddSimpLocOpnd(val);
+  }
+
+  void ClearSimpLocOpnd() {
+    value.ptr->ClearOpnd();
+  }
+
+  void Dump(int indent);
+
+  DBGDieKind GetKind() const {
+    return dieKind;
+  }
+
+  void SetKind(DBGDieKind kind) {
+    dieKind = kind;
+  }
+
+  DwAt GetDwAt() const {
+    return dwAttr;
+  }
+
+  void SetDwAt(DwAt at) {
+    dwAttr = at;
+  }
+
+  DwForm GetDwForm() const {
+    return dwForm;
+  }
+
+  void SetDwForm(DwForm form) {
+    dwForm = form;
+  }
+
+  int32 GetI() const {
+    return value.i;
+  }
+
+  void SetI(int32 val) {
+    value.i = val;
+  }
+
+  uint32 GetId() const {
+    return value.id;
+  }
+
+  void SetId(uint32 val) {
+    value.id = val;
+  }
+
+  int64 GetJ() const {
+    return value.j;
+  }
+
+  void SetJ(int64 val) {
+    value.j = val;
+  }
+
+  uint64 GetU() const {
+    return value.u;
+  }
+
+  void SetU(uint64 val) {
+    value.u = val;
+  }
+
+  float GetF() const {
+    return value.f;
+  }
+
+  void SetF(float val) {
+    value.f = val;
+  }
+
+  double GetD() const {
+    return value.d;
+  }
+
+  void SetD(double val) {
+    value.d = val;
+  }
+
+  DBGExprLoc *GetPtr() {
+    return value.ptr;
+  }
+
+  void SetPtr(DBGExprLoc *val) {
+    value.ptr = val;
+  }
+
+  void SetKeep(bool flag) {
+    keep = flag;
+  }
+
+  bool GetKeep() const {
+    return keep;
+  }
+
+ private:
+  DBGDieKind dieKind;
+  DwAt dwAttr;
+  DwForm dwForm;  // type for the attribute value
+  union {
+    int32 i;
+    uint32 id;    // dieId when dwForm is of DW_FORM_ref
+                  // strIdx when dwForm is of DW_FORM_string
+    int64 j;
+    uint64 u;
+    float f;
+    double d;
+
+    DBGExprLoc *ptr;
+  } value;
+  bool keep = true;
+};
+
+class DBGDie {
+ public:
+  DBGDie(MIRModule *m, DwTag tag);
+  virtual ~DBGDie() {}
+  void AddSubVec(DBGDie *die);
+  void AddAttr(DBGDieAttr *attr);
+  void AddAttr(DwAt at, DwForm form, uint64 val, bool keep = true);
+  void AddSimpLocAttr(DwAt at, DwForm form, DwOp op, uint64 val);
+  void AddGlobalLocAttr(DwAt at, DwForm form, uint64 val);
+  void AddFrmBaseAttr(DwAt at, DwForm form);
+  DBGExprLoc *GetExprLoc();
+  bool SetAttr(DwAt attr, uint64 val);
+  bool SetAttr(DwAt attr, int64 val);
+  bool SetAttr(DwAt attr, uint32 val);
+  bool SetAttr(DwAt attr, int32 val);
+  bool SetAttr(DwAt attr, float val);
+  bool SetAttr(DwAt attr, double val);
+  bool SetAttr(DwAt attr, DBGExprLoc *ptr);
+  bool SetSimpLocAttr(DwAt attr, int64 val);
+  void ResetParentDie() const;
+  void Dump(int indent);
+
+  uint32 GetId() const {
+    return id;
+  }
+
+  void SetId(uint32 val) {
+    id = val;
+  }
+
+  DwTag GetTag() const {
+    return tag;
+  }
+
+  void SetTag(DwTag val) {
+    tag = val;
+  }
+
+  bool GetWithChildren() const {
+    return withChildren;
+  }
+
+  void SetWithChildren(bool val) {
+    withChildren = val;
+  }
+
+  bool GetKeep() const {
+    return keep;
+  }
+
+  void SetKeep(bool val) {
+    keep = val;
+  }
+
+  DBGDie *GetParent() const {
+    return parent;
+  }
+
+  void SetParent(DBGDie *val) {
+    parent = val;
+  }
+
+  DBGDie *GetSibling() const {
+    return sibling;
+  }
+
+  void SetSibling(DBGDie *val) {
+    sibling = val;
+  }
+
+  DBGDie *GetFirstChild() const {
+    return firstChild;
+  }
+
+  void SetFirstChild(DBGDie *val) {
+    firstChild = val;
+  }
+
+  uint32 GetAbbrevId() const {
+    return abbrevId;
+  }
+
+  void SetAbbrevId(uint32 val) {
+    abbrevId = val;
+  }
+
+  uint32 GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(uint32 val) {
+    tyIdx = val;
+  }
+
+  uint32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(uint32 val) {
+    offset = val;
+  }
+
+  uint32 GetSize() const {
+    return size;
+  }
+
+  void SetSize(uint32 val) {
+    size = val;
+  }
+
+  const MapleVector<DBGDieAttr *> &GetAttrVec() const {
+    return attrVec;
+  }
+
+  MapleVector<DBGDieAttr *> &GetAttrVec() {
+    return attrVec;
+  }
+
+  const MapleVector<DBGDie *> &GetSubDieVec() const {
+    return subDieVec;
+  }
+
+  MapleVector<DBGDie *> &GetSubDieVec() {
+    return subDieVec;
+  }
+
+  uint32 GetSubDieVecSize() const {
+    return static_cast<uint32>(subDieVec.size());
+  }
+
+  DBGDie *GetSubDieVecAt(uint32 i) const {
+    return subDieVec[i];
+  }
+
+  // link ExprLoc to die's
+  void LinkExprLoc(DBGDie *die) {
+    for (auto &at : attrVec) {
+      if (at->GetDwAt() == DW_AT_location) {
+        DBGExprLoc *loc = die->GetExprLoc();
+        at->SetPtr(loc);
+      }
+    }
+  }
+
+ private:
+  MIRModule *module;
+  DwTag tag;
+  uint32 id;         // starts from 1 which is root die compUnit
+  bool withChildren;
+  bool keep;         // whether emit into .s
+  DBGDie *parent;
+  DBGDie *sibling;
+  DBGDie *firstChild;
+  uint32 abbrevId;   // id in .debug_abbrev
+  uint32 tyIdx;      // for type TAG
+  uint32 offset;     // Dwarf CU relative offset
+  uint32 size;       // DIE Size in .debug_info
+  MapleVector<DBGDieAttr *> attrVec;
+  MapleVector<DBGDie *> subDieVec;
+};
+
+class DBGAbbrevEntry {
+ public:
+  DBGAbbrevEntry(MIRModule *m, DBGDie *die);
+  virtual ~DBGAbbrevEntry() {}
+  bool Equalto(DBGAbbrevEntry *entry);
+  void Dump(int indent);
+
+  DwTag GetTag() const {
+    return tag;
+  }
+
+  void SetTag(DwTag val) {
+    tag = val;
+  }
+
+  uint32 GetAbbrevId() const {
+    return abbrevId;
+  }
+
+  void SetAbbrevId(uint32 val) {
+    abbrevId = val;
+  }
+
+  bool GetWithChildren() const {
+    return withChildren;
+  }
+
+  void SetWithChildren(bool val) {
+    withChildren = val;
+  }
+
+  MapleVector<uint32> &GetAttrPairs() {
+    return attrPairs;
+  }
+
+ private:
+  DwTag tag;
+  uint32 abbrevId;
+  bool withChildren;
+  MapleVector<uint32> attrPairs;  // kDwAt kDwForm pairs
+};
+
+class DBGAbbrevEntryVec {
+ public:
+  DBGAbbrevEntryVec(MIRModule *m, DwTag tag) : tag(tag), entryVec(m->GetMPAllocator().Adapter()) {}
+
+  virtual ~DBGAbbrevEntryVec() {}
+
+  uint32 GetId(MapleVector<uint32> &attrs);
+  void Dump(int indent);
+
+  DwTag GetTag() const {
+    return tag;
+  }
+
+  void SetTag(DwTag val) {
+    tag = val;
+  }
+
+  const MapleVector<DBGAbbrevEntry *> &GetEntryvec() const {
+    return entryVec;
+  }
+
+  MapleVector<DBGAbbrevEntry *> &GetEntryvec() {
+    return entryVec;
+  }
+
+ private:
+  DwTag tag;
+  MapleVector<DBGAbbrevEntry *> entryVec;
+};
+
+struct ScopePos {
+  uint32 id;
+  SrcPosition pos;
+};
+
+enum EmitStatus : uint8 {
+  kBeginEmited = 0,
+  kEndEmited = 1,
+};
+constexpr uint8 kAllEmited = 3;
+
+class DebugInfo {
+ public:
+  explicit DebugInfo(MIRModule *m)
+      : module(m),
+        compUnit(nullptr),
+        dummyTypeDie(nullptr),
+        lexer(nullptr),
+        maxId(1),
+        mplSrcIdx(0),
+        debugInfoLength(0),
+        curFunction(nullptr),
+        compileMsg(nullptr),
+        parentDieStack(m->GetMPAllocator().Adapter()),
+        idDieMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        abbrevVec(m->GetMPAllocator().Adapter()),
+        tagAbbrevMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        baseTypeMap(std::less<GStrIdx>(), m->GetMPAllocator().Adapter()),
+        tyIdxDieIdMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        stridxDieIdMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        globalStridxDieIdMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        funcDefStrIdxDieIdMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        typeDefTyIdxMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        pointedPointerMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        funcLstrIdxDieIdMap(std::less<MIRFunction *>(), m->GetMPAllocator().Adapter()),
+        funcLstrIdxLabIdxMap(std::less<MIRFunction *>(), m->GetMPAllocator().Adapter()),
+        funcScopeLows(std::less<MIRFunction *>(), m->GetMPAllocator().Adapter()),
+        funcScopeHighs(std::less<MIRFunction *>(), m->GetMPAllocator().Adapter()),
+        funcScopeIdStatus(std::less<MIRFunction *>(), m->GetMPAllocator().Adapter()),
+        globalTypeAliasMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        constTypeDieMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        volatileTypeDieMap(std::less<uint32>(), m->GetMPAllocator().Adapter()),
+        strps(std::less<uint32>(), m->GetMPAllocator().Adapter()) {
+    /* valid entry starting from index 1 as abbrevid starting from 1 as well */
+    abbrevVec.push_back(nullptr);
+    InitMsg();
+    varPtrPrefix = std::string(namemangler::kPtrPrefixStr);
+  }
+
+  virtual ~DebugInfo() {}
+
+  void BuildDebugInfo();
+  void ClearDebugInfo();
+  void Dump(int indent);
+
+  DBGDie *GetDie(const MIRFunction *func);
+  DBGDie *GetLocalDie(MIRFunction *func, GStrIdx strIdx);
+  DBGDieAttr *CreateAttr(DwAt at, DwForm form, uint64 val) const;
+
+  bool IsScopeIdEmited(MIRFunction *func, uint32 scopeId);
+
+  void GetCrossScopeId(MIRFunction *func,
+                       std::unordered_set<uint32> &idSet,
+                       bool isLow,
+                       const SrcPosition &oldSrcPos,
+                       const SrcPosition &newSrcPos);
+
+  void ComputeSizeAndOffsets();
+
+  DBGDie *GetDie(uint32 id) {
+    return idDieMap[id];
+  }
+
+  void SetIdDieMap(uint32 i, DBGDie *die) {
+    idDieMap[i] = die;
+  }
+
+  DBGDie *GetDummyTypeDie() {
+    return dummyTypeDie;
+  }
+
+  DBGDie *GetParentDie() {
+    return parentDieStack.top();
+  }
+
+  void ResetParentDie() {
+    parentDieStack.clear();
+    parentDieStack.push(compUnit);
+  }
+
+  uint32 GetDebugInfoLength() const {
+    return debugInfoLength;
+  }
+
+  void SetFuncScopeIdStatus(MIRFunction *func, uint32 scopeId, EmitStatus status) {
+    if (funcScopeIdStatus[func].find(scopeId) == funcScopeIdStatus[func].end()) {
+      funcScopeIdStatus[func][scopeId] = 0;
+    }
+    funcScopeIdStatus[func][scopeId] |= (1U << status);
+  }
+
+  MapleVector<DBGAbbrevEntry *> &GetAbbrevVec() {
+    return abbrevVec;
+  }
+
+  void AddStrps(uint32 val) {
+    strps.insert(val);
+  }
+
+  MapleSet<uint32> &GetStrps() {
+    return strps;
+  }
+
+  uint32 GetMaxId() const {
+    return maxId;
+  }
+
+  uint32 GetIncMaxId() {
+    return maxId++;
+  }
+
+  DBGDie *GetCompUnit() const {
+    return compUnit;
+  }
+
+  size_t GetParentDieSize() const {
+    return parentDieStack.size();
+  }
+
+  void SetErrPos(uint32 lnum, uint32 cnum) {
+    compileMsg->SetErrPos(lnum, cnum);
+  }
+
+  void UpdateMsg(uint32 lnum, const char *line) {
+    compileMsg->UpdateMsg(lnum, line);
+  }
+
+  void EmitMsg() {
+    compileMsg->EmitMsg();
+  }
+
+ private:
+  MIRModule *module;
+  DBGDie *compUnit;      // root die: compilation unit
+  DBGDie *dummyTypeDie;  // workaround for unknown types
+  MIRLexer *lexer;
+  uint32 maxId;
+  GStrIdx mplSrcIdx;
+  uint32 debugInfoLength;
+  MIRFunction *curFunction;
+
+  // for compilation messages
+  DBGCompileMsgInfo *compileMsg;
+
+  MapleStack<DBGDie *> parentDieStack;
+  MapleMap<uint32, DBGDie *> idDieMap;
+  MapleVector<DBGAbbrevEntry *> abbrevVec;  // valid entry starting from index 1
+  MapleMap<uint32, DBGAbbrevEntryVec *> tagAbbrevMap;
+  MapleMap<GStrIdx, std::pair<GStrIdx, PrimType>> baseTypeMap;  // baseTypeMap: <InputName, OutputName, PrimType>
+
+  // to be used when derived type references a base type die
+  MapleMap<uint32, uint32> tyIdxDieIdMap;
+  MapleMap<uint32, uint32> stridxDieIdMap;
+  // save global var die, global var string idx to die id
+  MapleMap<uint32, uint32> globalStridxDieIdMap;
+  MapleMap<uint32, uint32> funcDefStrIdxDieIdMap;
+  MapleMap<uint32, uint32> typeDefTyIdxMap;  // prevtyIdxtypidx_map
+  MapleMap<uint32, uint32> pointedPointerMap;
+  MapleMap<MIRFunction *, std::map<uint32, uint32>> funcLstrIdxDieIdMap;
+  MapleMap<MIRFunction *, std::map<uint32, LabelIdx>> funcLstrIdxLabIdxMap;
+
+  MapleMap<MIRFunction *, std::vector<ScopePos>> funcScopeLows;
+  MapleMap<MIRFunction *, std::vector<ScopePos>> funcScopeHighs;
+
+  /* save functions's scope id that has been emited */
+  MapleMap<MIRFunction *, std::map<uint32, uint8>> funcScopeIdStatus;
+
+  /* alias type */
+  MapleMap<uint32, uint32> globalTypeAliasMap;
+  MapleMap<uint32, uint32> constTypeDieMap;
+  MapleMap<uint32, uint32> volatileTypeDieMap;
+
+  MapleSet<uint32> strps;
+  std::string varPtrPrefix;
+
+  void InitMsg() {
+    compileMsg = module->GetMemPool()->New<DBGCompileMsgInfo>();
+  }
+
+  void Init();
+  void InitBaseTypeMap();
+  void Finish();
+  void SetupCU();
+
+  void BuildDebugInfoEnums();
+  void BuildDebugInfoContainers();
+  void BuildDebugInfoGlobalSymbols();
+  void BuildDebugInfoFunctions();
+
+  // build tree to populate withChildren, sibling, firstChild
+  // also insert DW_AT_sibling attributes when needed
+  void BuildDieTree();
+
+  void BuildAbbrev();
+
+  uint32 GetAbbrevId(DBGAbbrevEntryVec *vec, DBGAbbrevEntry *entry) const;
+
+  DBGDie *GetGlobalDie(const GStrIdx &strIdx);
+
+  void SetLocalDie(GStrIdx strIdx, const DBGDie *die);
+  void SetLocalDie(MIRFunction *func, GStrIdx strIdx, const DBGDie *die);
+  DBGDie *GetLocalDie(GStrIdx strIdx);
+
+  LabelIdx GetLabelIdx(GStrIdx strIdx);
+  LabelIdx GetLabelIdx(MIRFunction *func, GStrIdx strIdx);
+  void SetLabelIdx(const GStrIdx &strIdx, LabelIdx labIdx);
+  void SetLabelIdx(MIRFunction *func, const GStrIdx &strIdx, LabelIdx labIdx);
+  void InsertBaseTypeMap(const std::string &inputName, const std::string &outpuName, PrimType type);
+
+  DBGDie *GetIdDieMapAt(uint32 i) {
+    return idDieMap[i];
+  }
+
+  void PushParentDie(DBGDie *die) {
+    parentDieStack.push(die);
+  }
+
+  void PopParentDie() {
+    parentDieStack.pop();
+  }
+
+  MIRFunction *GetCurFunction() {
+    return curFunction;
+  }
+
+  void SetCurFunction(MIRFunction *func) {
+    curFunction = func;
+  }
+
+  void SetTyidxDieIdMap(const TyIdx tyIdx, const DBGDie *die) {
+    tyIdxDieIdMap[tyIdx.GetIdx()] = die->GetId();
+  }
+
+  DBGDie *CreateVarDie(MIRSymbol *sym);
+  DBGDie *CreateVarDie(MIRSymbol *sym, const GStrIdx &strIdx); // use alt name
+  DBGDie *CreateFormalParaDie(MIRFunction *func, uint32 idx, bool isDef);
+  DBGDie *CreateFieldDie(maple::FieldPair pair);
+  DBGDie *CreateBitfieldDie(const MIRBitFieldType *type, const GStrIdx &sidx, uint32 &prevBits);
+  void CreateStructTypeFieldsDies(const MIRStructType *structType, DBGDie *die);
+  void CreateStructTypeParentFieldsDies(const MIRStructType *structType, DBGDie *die);
+  void CreateStructTypeMethodsDies(const MIRStructType *structType, DBGDie *die);
+  DBGDie *CreateStructTypeDie(GStrIdx strIdx, const MIRStructType *structType, bool update = false);
+  DBGDie *CreateClassTypeDie(const GStrIdx &strIdx, const MIRClassType *classType);
+  DBGDie *CreateInterfaceTypeDie(const GStrIdx &strIdx, const MIRInterfaceType *interfaceType);
+  DBGDie *CreatePointedFuncTypeDie(MIRFuncType *fType);
+  void CreateFuncLocalSymbolsDies(MIRFunction *func, DBGDie *die);
+
+  DBGDie *GetOrCreateLabelDie(LabelIdx labid);
+  DBGDie *GetOrCreateFuncDeclDie(MIRFunction *func);
+  DBGDie *GetOrCreateFuncDefDie(MIRFunction *func);
+  DBGDie *GetOrCreatePrimTypeDie(MIRType *ty);
+  DBGDie *GetOrCreateBaseTypeDie(const MIRType *type);
+  DBGDie *GetOrCreateTypeDie(TyIdx tyidx);
+  DBGDie *GetOrCreateTypeDie(MIRType *type);
+  DBGDie *GetOrCreateTypeDieWithAttr(AttrKind attr, DBGDie *typeDie);
+  DBGDie *GetOrCreateTypeDieWithAttr(TypeAttrs attrs, DBGDie *typeDie);
+  DBGDie *GetOrCreatePointTypeDie(const MIRPtrType *ptrType);
+  DBGDie *GetOrCreateArrayTypeDie(const MIRArrayType *arrayType);
+  DBGDie *GetOrCreateStructTypeDie(const MIRType *type);
+  DBGDie *GetOrCreateTypedefDie(GStrIdx stridx, TyIdx tyidx);
+  DBGDie *GetOrCreateEnumTypeDie(uint32 idx);
+  DBGDie *GetOrCreateEnumTypeDie(MIREnum *mirEnum);
+  DBGDie *GetOrCreateTypeByNameDie(const MIRType &type);
+
+  GStrIdx GetPrimTypeCName(PrimType pty);
+
+  void AddScopeDie(MIRScope *scope);
+  DBGDie *GetAliasVarTypeDie(const MIRAliasVars &aliasVar, TyIdx tyidx);
+  void HandleTypeAlias(MIRScope &scope);
+  void AddAliasDies(MIRScope &scope, bool isLocal);
+  void CollectScopePos(MIRFunction *func, MIRScope *scope);
+
+  // Functions for calculating the size and offset of each DW_TAG_xxx and DW_AT_xxx
+  void ComputeSizeAndOffset(DBGDie *die, uint32 &cuOffset);
+};
+} // namespace maple
+#endif // MAPLE_IR_INCLUDE_DBG_INFO_H
diff --git a/src/mapleall/maple_ir/include/dex2mpl/dexintrinsic.def b/src/mapleall/maple_ir/include/dex2mpl/dexintrinsic.def
new file mode 100644
index 0000000000000000000000000000000000000000..cfa6016f0c175e433a07da9b661bfd3c28911ad6
--- /dev/null
+++ b/src/mapleall/maple_ir/include/dex2mpl/dexintrinsic.def
@@ -0,0 +1,17 @@
+DEF_MIR_INTRINSIC(JAVA_INTERFACE_CALL,\
+                  "__dex_interface_call", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_PRINT,\
+                  "printf", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyVoid, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_CLINIT_CHECK_SGET,\
+                  "__dex_clinit_check_sget", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyVoid, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_CLINIT_CHECK_SPUT,\
+                  "__dex__clinit_check_sput", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyVoid, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_CLINIT_CHECK_NEW,\
+                  "__dex_clinit_check_new", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyVoid, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_STR_TO_JSTR,\
+                  "__dex_str_to_jstr", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyPtr, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+// __dex_random is used to generate a random value used in callback cfg
+DEF_MIR_INTRINSIC(JAVA_RANDOM,\
+                  "__dex_random", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_THROW_CLASSCAST,\
+                  "MCC_ThrowClassCastException", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNEVERRETURN, kArgTyVoid, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
diff --git a/src/mapleall/maple_ir/include/func_desc.h b/src/mapleall/maple_ir/include/func_desc.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cea54fb68613884d45569e81d82b9c785f3e5cf
--- /dev/null
+++ b/src/mapleall/maple_ir/include/func_desc.h
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_FUNC_DESC_H
+#define MAPLE_IR_INCLUDE_FUNC_DESC_H
+#include "mpl_logging.h"
+namespace maple {
+
+enum class FI {
+  kUnknown = 0,
+  kPure,      // means this function will not modify any global memory.
+  kConst,     // means this function will not read/modify any global memory.
+};
+
+static std::string kFIStr[] = {
+    "kUnknown", "kPure", "kConst"
+};
+
+enum class RI {
+  kUnknown = 0,   // for ptr value, don't know anything.
+  kNoAlias,       // for ptr value, no alias with any other ptr when this method is returned. As in malloc.
+  kAliasParam0,   // for ptr value, it may alias with first param. As in memcpy.
+  kAliasParam1,
+  kAliasParam2,
+  kAliasParam3,
+  kAliasParam4,
+  kAliasParam5,
+};
+
+static std::string kRIStr[] = {
+    "kUnknown",
+    "kNoAlias",
+    "kAliasParam0",
+    "kAliasParam1",
+    "kAliasParam2",
+    "kAliasParam3",
+    "kAliasParam4",
+    "kAliasParam5"
+};
+
+enum class PI {
+  kUnknown = 0,       // for ptr param, may read/write every level memory.
+  kReadWriteMemory,   // for ptr param, only read & write the memory it points to.
+  kWriteMemoryOnly,   // for ptr param, only write the memory it points to.
+  kReadMemoryOnly,    // for ptr param, only read the memory it points to.
+  kReadSelfOnly,      // for ptr param, only read the ptr itself, do not dereference.
+  kUnused,            // this param is not used in this function.
+};
+
+static std::string kPIStr[] = {
+    "kUnknown",
+    "kReadWriteMemory",
+    "kWriteMemoryOnly",
+    "kReadMemoryOnly",
+    "kReadSelfOnly",
+    "kUnused"
+};
+
+// most function has less than 6 parameters.
+const size_t kMaxParamCount = 6;
+struct FuncDesc {
+  FI funcInfo{};
+  RI returnInfo{};
+  PI paramInfo[kMaxParamCount]{};
+  bool configed = false;
+
+  void InitToBest() {
+    funcInfo = FI::kConst;
+    returnInfo = RI::kNoAlias;
+    for (size_t idx = 0; idx < kMaxParamCount; ++idx) {
+      paramInfo[idx] = PI::kUnused;
+    }
+  }
+
+  bool Equals(const FuncDesc &desc) const {
+    if (funcInfo != desc.funcInfo) {
+      return false;
+    }
+    if (returnInfo != desc.returnInfo) {
+      return false;
+    }
+    for (size_t idx = 0; idx < kMaxParamCount; ++idx) {
+      if (paramInfo[idx] != desc.paramInfo[idx]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool IsConfiged() const {
+    return configed;
+  }
+
+  void SetConfiged() {
+    configed = true;
+  }
+
+  bool IsConst() const {
+    return funcInfo == FI::kConst;
+  }
+
+  bool IsPure() const {
+    return funcInfo == FI::kPure;
+  }
+
+  bool IsReturnNoAlias() const {
+    return returnInfo == RI::kNoAlias;
+  }
+  bool IsReturnAlias() const {
+    return returnInfo >= RI::kAliasParam0;
+  }
+
+  void CheckReturnInfo() const {
+    CHECK_FATAL(returnInfo >= RI::kAliasParam0, "Impossible.");
+  }
+
+  const PI GetParamInfo(size_t index) const {
+    if (index >= kMaxParamCount) {
+      return PI::kUnknown;
+    }
+    return paramInfo[index];
+  }
+
+  bool IsArgReadSelfOnly(size_t index) const {
+    if (index >= kMaxParamCount) {
+      return false;
+    }
+    return paramInfo[index] == PI::kReadSelfOnly;
+  }
+
+  bool IsArgReadMemoryOnly(size_t index) const {
+    if (index >= kMaxParamCount) {
+      return false;
+    }
+    return paramInfo[index] == PI::kReadMemoryOnly;
+  }
+
+  bool IsArgWriteMemoryOnly(size_t index) const {
+    if (index >= kMaxParamCount) {
+      return false;
+    }
+    return paramInfo[index] == PI::kWriteMemoryOnly;
+  }
+
+  bool IsArgUnused(size_t index) const {
+    if (index >= kMaxParamCount) {
+      return false;
+    }
+    return paramInfo[index] == PI::kUnused;
+  }
+
+  void SetFuncInfo(const FI fi) {
+    funcInfo = fi;
+  }
+
+  void SetFuncInfoNoBetterThan(const FI fi) {
+    auto oldValue = static_cast<size_t>(funcInfo);
+    auto newValue = static_cast<size_t>(fi);
+    if (newValue < oldValue) {
+      SetFuncInfo(static_cast<FI>(newValue));
+    }
+  }
+
+  void SetReturnInfo(const RI ri) {
+    returnInfo = ri;
+  }
+
+  void SetParamInfo(const size_t idx, const PI pi) {
+    if (idx >= kMaxParamCount) {
+      return;
+    }
+    paramInfo[idx] = pi;
+  }
+
+  void SetParamInfoNoBetterThan(const size_t idx, const PI pi) {
+    size_t oldValue = static_cast<size_t>(paramInfo[idx]);
+    size_t newValue = static_cast<size_t>(pi);
+    if (newValue < oldValue) {
+      SetParamInfo(idx, static_cast<PI>(newValue));
+    }
+  }
+
+  void Dump(size_t numParam = kMaxParamCount) {
+    auto dumpCount = numParam > kMaxParamCount ? kMaxParamCount : numParam;
+    LogInfo::MapleLogger() << kFIStr[static_cast<size_t>(funcInfo)]
+                           << " " << kRIStr[static_cast<size_t>(returnInfo)];
+    for (size_t i = 0; i < dumpCount; ++i) {
+      LogInfo::MapleLogger() << " " << kPIStr[static_cast<size_t>(paramInfo[i])];
+    }
+    LogInfo::MapleLogger() << "\n";
+  }
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_FUNC_DESC_H
diff --git a/src/mapleall/maple_ir/include/global_tables.h b/src/mapleall/maple_ir/include/global_tables.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b7250be474ffde0493176f40b1dc25cbca2fd30
--- /dev/null
+++ b/src/mapleall/maple_ir/include/global_tables.h
@@ -0,0 +1,878 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_GLOBAL_TABLES_H
+#define MAPLE_IR_INCLUDE_GLOBAL_TABLES_H
+#include <iostream>
+#include <memory>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include "thread_env.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "types_def.h"
+#include "prim_types.h"
+#include "mir_module.h"
+#include "namemangler.h"
+#include "mir_type.h"
+#include "mir_const.h"
+#include "mir_enum.h"
+
+namespace maple {
+using TyIdxFieldAttrPair = std::pair<TyIdx, FieldAttrs>;
+using FieldPair = std::pair<GStrIdx, TyIdxFieldAttrPair>;
+using FieldVector = std::vector<FieldPair>;
+
+class BinaryMplImport; // circular dependency exists, no other choice
+
+// to facilitate the use of unordered_map
+class TyIdxHash {
+ public:
+  std::size_t operator()(const TyIdx &tyIdx) const {
+    return std::hash<uint32>{}(tyIdx);
+  }
+};
+
+// to facilitate the use of unordered_map
+class GStrIdxHash {
+ public:
+  std::size_t operator()(const GStrIdx &gStrIdx) const {
+    return std::hash<uint32>{}(gStrIdx);
+  }
+};
+
+// to facilitate the use of unordered_map
+class UStrIdxHash {
+ public:
+  std::size_t operator()(const UStrIdx &uStrIdx) const {
+    return std::hash<uint32>{}(uStrIdx);
+  }
+};
+
+class IntConstKey {
+  friend class IntConstHash;
+  friend class IntConstCmp;
+ public:
+  IntConstKey(int64 v, TyIdx tyIdx) : val(v), tyIdx(tyIdx) {}
+  virtual ~IntConstKey() {}
+ private:
+  int64 val;
+  TyIdx tyIdx;
+};
+
+class IntConstHash {
+ public:
+  std::size_t operator() (const IntConstKey &key) const {
+    return std::hash<int64>{}(key.val) ^ (std::hash<uint64>{}(static_cast<uint64>(key.tyIdx)) << 1);
+  }
+};
+
+class IntConstCmp {
+ public:
+  bool operator() (const IntConstKey &lkey, const IntConstKey &rkey) const {
+    return lkey.val == rkey.val && lkey.tyIdx == rkey.tyIdx;
+  }
+};
+
+class TypeTable {
+  friend BinaryMplImport;
+ public:
+  static MIRType *voidPtrType;
+
+  TypeTable();
+  TypeTable(const TypeTable&) = delete;
+  TypeTable &operator=(const TypeTable&) = delete;
+  ~TypeTable();
+
+  std::vector<MIRType*> &GetTypeTable() {
+    return typeTable;
+  }
+
+  const std::vector<MIRType*> &GetTypeTable() const {
+    return typeTable;
+  }
+
+  auto &GetTypeHashTable() const {
+    return typeHashTable;
+  }
+
+  auto &GetPtrTypeMap() const {
+    return ptrTypeMap;
+  }
+
+  auto &GetRefTypeMap() const {
+    return refTypeMap;
+  }
+
+  MIRType *GetTypeFromTyIdx(TyIdx tyIdx) {
+    return const_cast<MIRType*>(const_cast<const TypeTable*>(this)->GetTypeFromTyIdx(tyIdx));
+  }
+  const MIRType *GetTypeFromTyIdx(TyIdx tyIdx) const {
+    CHECK_FATAL(tyIdx < typeTable.size(), "array index out of range");
+    return typeTable.at(tyIdx);
+  }
+
+  MIRType *GetTypeFromTyIdx(uint32 index) const {
+    CHECK_FATAL(index < typeTable.size(), "array index out of range");
+    return typeTable.at(index);
+  }
+
+  PrimType GetPrimTypeFromTyIdx(const TyIdx &tyIdx) const {
+    CHECK_FATAL(tyIdx < typeTable.size(), "array index out of range");
+    return typeTable.at(tyIdx)->GetPrimType();
+  }
+
+  void SetTypeWithTyIdx(const TyIdx &tyIdx, MIRType &type);
+  MIRType *GetOrCreateMIRTypeNode(MIRType &pType);
+
+  TyIdx GetOrCreateMIRType(MIRType *pType) {
+    return GetOrCreateMIRTypeNode(*pType)->GetTypeIndex();
+  }
+
+  uint32 GetTypeTableSize() const {
+    return static_cast<uint32>(typeTable.size());
+  }
+
+  // Get primtive types.
+  MIRType *GetPrimType(PrimType primType) const {
+    ASSERT(primType < typeTable.size(), "array index out of range");
+    return typeTable.at(primType);
+  }
+
+  MIRType *GetFloat() const {
+    ASSERT(PTY_f32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_f32);
+  }
+
+  MIRType *GetDouble() const {
+    ASSERT(PTY_f64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_f64);
+  }
+
+  MIRType *GetFloat128() const {
+    ASSERT(PTY_f128 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_f128);
+  }
+
+  MIRType *GetUInt1() const {
+    ASSERT(PTY_u1 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u1);
+  }
+
+  MIRType *GetUInt8() const {
+    ASSERT(PTY_u8 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u8);
+  }
+
+  MIRType *GetInt8() const {
+    ASSERT(PTY_i8 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_i8);
+  }
+
+  MIRType *GetUInt16() const {
+    ASSERT(PTY_u16 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u16);
+  }
+
+  MIRType *GetInt16() const {
+    ASSERT(PTY_i16 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_i16);
+  }
+
+  MIRType *GetInt32() const {
+    ASSERT(PTY_i32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_i32);
+  }
+
+  MIRType *GetUInt32() const {
+    ASSERT(PTY_u32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u32);
+  }
+
+  MIRType *GetInt64() const {
+    ASSERT(PTY_i64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_i64);
+  }
+
+  MIRType *GetUInt64() const {
+    ASSERT(PTY_u64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u64);
+  }
+
+  MIRType *GetPtr() const {
+    ASSERT(PTY_ptr < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_ptr);
+  }
+
+#ifdef USE_ARM32_MACRO
+  MIRType *GetUIntType() const {
+    ASSERT(PTY_u32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u32);
+  }
+
+  MIRType *GetPtrType() const {
+    ASSERT(PTY_u32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u32);
+  }
+#else
+  MIRType *GetUIntType() const {
+    ASSERT(PTY_u64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u64);
+  }
+
+  MIRType *GetPtrType() const {
+    ASSERT(PTY_ptr < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_ptr);
+  }
+#endif
+
+#ifdef USE_32BIT_REF
+  MIRType *GetCompactPtr() const {
+    ASSERT(PTY_u32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u32);
+  }
+
+#else
+  MIRType *GetCompactPtr() const {
+    ASSERT(PTY_u64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_u64);
+  }
+
+#endif
+  MIRType *GetRef() const {
+    ASSERT(PTY_ref < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_ref);
+  }
+
+  MIRType *GetAddr32() const {
+    ASSERT(PTY_a32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_a32);
+  }
+
+  MIRType *GetAddr64() const {
+    ASSERT(PTY_a64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_a64);
+  }
+
+  MIRType *GetVoid() const {
+    ASSERT(PTY_void < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_void);
+  }
+
+#ifdef DYNAMICLANG
+  MIRType *GetDynundef() const {
+    ASSERT(PTY_dynundef < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_dynundef);
+  }
+
+  MIRType *GetDynany() const {
+    ASSERT(PTY_dynany < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_dynany);
+  }
+
+  MIRType *GetDyni32() const {
+    ASSERT(PTY_dyni32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_dyni32);
+  }
+
+  MIRType *GetDynf64() const {
+    ASSERT(PTY_dynf64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_dynf64);
+  }
+
+  MIRType *GetDynf32() const {
+    ASSERT(PTY_dynf32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_dynf32);
+  }
+
+  MIRType *GetDynstr() const {
+    ASSERT(PTY_dynstr < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_dynstr);
+  }
+
+  MIRType *GetDynobj() const {
+    ASSERT(PTY_dynobj < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_dynobj);
+  }
+
+  MIRType *GetDynbool() const {
+    ASSERT(PTY_dynbool < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_dynbool);
+  }
+
+#endif
+  MIRType *GetUnknown() const {
+    ASSERT(PTY_unknown < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_unknown);
+  }
+  // vector type
+  MIRType *GetV4Int32() const {
+    ASSERT(PTY_v4i32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v4i32);
+  }
+
+  MIRType *GetV2Int32() const {
+    ASSERT(PTY_v2i32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v2i32);
+  }
+
+  MIRType *GetV4UInt32() const {
+    ASSERT(PTY_v4u32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v4u32);
+  }
+  MIRType *GetV2UInt32() const {
+    ASSERT(PTY_v2u32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v2u32);
+  }
+
+  MIRType *GetV4Int16() const {
+    ASSERT(PTY_v4i16 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v4i16);
+  }
+  MIRType *GetV8Int16() const {
+    ASSERT(PTY_v8i16 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v8i16);
+  }
+
+  MIRType *GetV4UInt16() const {
+    ASSERT(PTY_v4u16 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v4u16);
+  }
+  MIRType *GetV8UInt16() const {
+    ASSERT(PTY_v8u16 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v8u16);
+  }
+
+  MIRType *GetV8Int8() const {
+    ASSERT(PTY_v8i8 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v8i8);
+  }
+  MIRType *GetV16Int8() const {
+    ASSERT(PTY_v16i8 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v16i8);
+  }
+
+  MIRType *GetV8UInt8() const {
+    ASSERT(PTY_v8u8 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v8u8);
+  }
+  MIRType *GetV16UInt8() const {
+    ASSERT(PTY_v16u8 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v16u8);
+  }
+  MIRType *GetV2Int64() const {
+    ASSERT(PTY_v2i64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v2i64);
+  }
+  MIRType *GetV2UInt64() const {
+    ASSERT(PTY_v2u64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v2u64);
+  }
+
+  MIRType *GetV2Float32() const {
+    ASSERT(PTY_v2f32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v2f32);
+  }
+  MIRType *GetV4Float32() const {
+    ASSERT(PTY_v4f32 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v4f32);
+  }
+  MIRType *GetV2Float64() const {
+    ASSERT(PTY_v2f64 < typeTable.size(), "array index out of range");
+    return typeTable.at(PTY_v2f64);
+  }
+
+  // Get or Create derived types.
+  MIRType *GetOrCreatePointerType(const TyIdx &pointedTyIdx, PrimType primType = PTY_ptr,
+                                  const TypeAttrs &attrs = TypeAttrs());
+  MIRType *GetOrCreatePointerType(const MIRType &pointTo, PrimType primType = PTY_ptr,
+                                  const TypeAttrs &attrs = TypeAttrs());
+  const MIRType *GetPointedTypeIfApplicable(MIRType &type) const;
+  MIRType *GetPointedTypeIfApplicable(MIRType &type);
+  MIRType *GetVoidPtr() const {
+    ASSERT(voidPtrType != nullptr, "voidPtrType should not be null");
+    return voidPtrType;
+  }
+
+  void UpdateMIRType(const MIRType &pType, const TyIdx tyIdx);
+  MIRArrayType *GetOrCreateArrayType(const MIRType &elem, uint8 dim, const uint32 *sizeArray,
+                                     const TypeAttrs &attrs = TypeAttrs());
+  // For one dimention array
+  MIRArrayType *GetOrCreateArrayType(const MIRType &elem, uint32 size, const TypeAttrs &attrs = TypeAttrs());
+  MIRType *GetOrCreateFarrayType(const MIRType &elem);
+  MIRType *GetOrCreateJarrayType(const MIRType &elem);
+  MIRType *GetOrCreateFunctionType(const TyIdx &retTyIdx, const std::vector<TyIdx> &vecType,
+                                   const std::vector<TypeAttrs> &vecAttrs, bool isVarg = false,
+                                   const TypeAttrs &retAttrs = TypeAttrs());
+  MIRType *GetOrCreateStructType(const std::string &name, const FieldVector &fields, const FieldVector &prntFields,
+                                 MIRModule &module) {
+    return GetOrCreateStructOrUnion(name, fields, prntFields, module);
+  }
+
+  MIRType *GetOrCreateUnionType(const std::string &name, const FieldVector &fields, const FieldVector &parentFields,
+                                MIRModule &module) {
+    return GetOrCreateStructOrUnion(name, fields, parentFields, module, false);
+  }
+
+  MIRType *GetOrCreateClassType(const std::string &name, MIRModule &module) {
+    return GetOrCreateClassOrInterface(name, module, true);
+  }
+
+  MIRType *GetOrCreateInterfaceType(const std::string &name, MIRModule &module) {
+    return GetOrCreateClassOrInterface(name, module, false);
+  }
+
+  void PushIntoFieldVector(FieldVector &fields, const std::string &name, const MIRType &type) const;
+  void AddFieldToStructType(MIRStructType &structType, const std::string &fieldName, const MIRType &fieldType) const;
+
+  TyIdx lastDefaultTyIdx;
+ private:
+  using MIRTypePtr = MIRType*;
+  struct Hash {
+    size_t operator()(const MIRTypePtr &ty) const {
+      return ty->GetHashIndex();
+    }
+  };
+
+  struct Equal {
+    bool operator()(const MIRTypePtr &tx, const MIRTypePtr &ty) const {
+      return tx->EqualTo(*ty);
+    }
+  };
+
+  // create an entry in typeTable for the type node
+  MIRType *CreateType(const MIRType &oldType) {
+    MIRType *newType = oldType.CopyMIRTypeNode();
+    newType->SetTypeIndex(TyIdx(typeTable.size()));
+    typeTable.push_back(newType);
+    return newType;
+  }
+
+  void PushNull() { typeTable.push_back(nullptr); }
+  void PopBack() { typeTable.pop_back(); }
+
+  void CreateMirTypeNodeAt(MIRType &pType, TyIdx tyIdxUsed, MIRModule *module, bool isObject, bool isIncomplete);
+  MIRType *CreateAndUpdateMirTypeNode(MIRType &pType);
+  MIRType *GetOrCreateStructOrUnion(const std::string &name, const FieldVector &fields, const FieldVector &printFields,
+                                    MIRModule &module, bool forStruct = true,
+                                    const TypeAttrs &attrs = TypeAttrs());
+  MIRType *GetOrCreateClassOrInterface(const std::string &name, MIRModule &module, bool forClass);
+
+  MIRType *CreateMirType(uint32 primTypeIdx) const;
+  void PutToHashTable(MIRType *mirType);
+
+  std::unordered_set<MIRTypePtr, Hash, Equal> typeHashTable;
+  std::unordered_map<TyIdx, TyIdx, TyIdxHash> ptrTypeMap;
+  std::unordered_map<TyIdx, TyIdx, TyIdxHash> refTypeMap;
+  std::vector<MIRType*> typeTable;
+  mutable std::shared_timed_mutex mtx;
+};
+
+class StrPtrHash {
+ public:
+  size_t operator()(const std::string *str) const {
+    return std::hash<std::string>{}(*str);
+  }
+
+  size_t operator()(const std::u16string *str) const {
+    return std::hash<std::u16string>{}(*str);
+  }
+};
+
+class StrPtrEqual {
+ public:
+  bool operator()(const std::string *str1, const std::string *str2) const {
+    return *str1 == *str2;
+  }
+
+  bool operator()(const std::u16string *str1, const std::u16string *str2) const {
+    return *str1 == *str2;
+  }
+};
+
+// T can be std::string or std::u16string
+// U can be GStrIdx, UStrIdx, or U16StrIdx
+template <typename T, typename U>
+class StringTable {
+ public:
+  StringTable() = default;
+  StringTable(const StringTable&) = delete;
+  StringTable &operator=(const StringTable&) = delete;
+
+  ~StringTable() {
+    stringTableMap.clear();
+    for (auto it : stringTable) {
+      delete it;
+    }
+  }
+
+  void Init() {
+    // initialize 0th entry of stringTable with an empty string
+    T *ptr = new T;
+    stringTable.push_back(ptr);
+  }
+
+  U GetStrIdxFromName(const T &str) const {
+    if (ThreadEnv::IsMeParallel()) {
+      std::shared_lock<std::shared_timed_mutex> lock(mtx);
+      auto it = stringTableMap.find(&str);
+      if (it == stringTableMap.end()) {
+        return U(0);
+      }
+      return it->second;
+    }
+    auto it = stringTableMap.find(&str);
+    if (it == stringTableMap.end()) {
+      return U(0);
+    }
+    return it->second;
+  }
+
+  U GetOrCreateStrIdxFromName(const T &str) {
+    U strIdx = GetStrIdxFromName(str);
+    if (strIdx == 0u) {
+      if (ThreadEnv::IsMeParallel()) {
+        std::unique_lock<std::shared_timed_mutex> lock(mtx);
+        strIdx.reset(stringTable.size());
+        T *newStr = new T(str);
+        stringTable.push_back(newStr);
+        stringTableMap[newStr] = strIdx;
+        return strIdx;
+      }
+      strIdx.reset(stringTable.size());
+      T *newStr = new T(str);
+      stringTable.push_back(newStr);
+      stringTableMap[newStr] = strIdx;
+    }
+    return strIdx;
+  }
+
+  size_t StringTableSize() const {
+    if (ThreadEnv::IsMeParallel()) {
+      std::shared_lock<std::shared_timed_mutex> lock(mtx);
+      return stringTable.size();
+    }
+    return stringTable.size();
+  }
+
+  const T &GetStringFromStrIdx(U strIdx) const {
+    if (ThreadEnv::IsMeParallel()) {
+      std::shared_lock<std::shared_timed_mutex> lock(mtx);
+      ASSERT(strIdx < stringTable.size(), "array index out of range");
+      return *stringTable[strIdx];
+    }
+    ASSERT(strIdx < stringTable.size(), "array index out of range");
+    return *stringTable[strIdx];
+  }
+
+  const T &GetStringFromStrIdx(uint32 idx) const {
+    ASSERT(idx < stringTable.size(), "array index out of range");
+    return *stringTable[idx];
+  }
+
+ private:
+  std::vector<const T*> stringTable;  // index is uint32
+  std::unordered_map<const T*, U, StrPtrHash, StrPtrEqual> stringTableMap;
+  mutable std::shared_timed_mutex mtx;
+};
+
+class FPConstTable {
+ public:
+  FPConstTable(const FPConstTable &p) = delete;
+  FPConstTable &operator=(const FPConstTable &p) = delete;
+  ~FPConstTable();
+
+  // get the const from floatConstTable or create a new one
+  MIRFloatConst *GetOrCreateFloatConst(float floatVal);
+  // get the const from doubleConstTable or create a new one
+  MIRDoubleConst *GetOrCreateDoubleConst(double doubleVal);
+
+  static std::unique_ptr<FPConstTable> Create() {
+    auto p = std::unique_ptr<FPConstTable>(new FPConstTable());
+    p->PostInit();
+    return p;
+  }
+
+ private:
+  FPConstTable() : floatConstTable(), doubleConstTable() {}
+  void PostInit();
+  MIRFloatConst *DoGetOrCreateFloatConst(float floatVal);
+  MIRDoubleConst *DoGetOrCreateDoubleConst(double doubleVal);
+  MIRFloatConst *DoGetOrCreateFloatConstThreadSafe(float floatVal);
+  MIRDoubleConst *DoGetOrCreateDoubleConstThreadSafe(double doubleVal);
+  std::shared_timed_mutex floatMtx;
+  std::shared_timed_mutex doubleMtx;
+  std::unordered_map<float, MIRFloatConst*> floatConstTable;     // map float const value to the table;
+  std::unordered_map<double, MIRDoubleConst*> doubleConstTable;  // map double const value to the table;
+  MIRFloatConst *nanFloatConst = nullptr;
+  MIRFloatConst *infFloatConst = nullptr;
+  MIRFloatConst *minusInfFloatConst = nullptr;
+  MIRFloatConst *minusZeroFloatConst = nullptr;
+  MIRDoubleConst *nanDoubleConst = nullptr;
+  MIRDoubleConst *infDoubleConst = nullptr;
+  MIRDoubleConst *minusInfDoubleConst = nullptr;
+  MIRDoubleConst *minusZeroDoubleConst = nullptr;
+};
+
+class IntConstTable {
+ public:
+  IntConstTable(const IntConstTable &p) = delete;
+  IntConstTable &operator=(const IntConstTable &p) = delete;
+  ~IntConstTable();
+
+  MIRIntConst *GetOrCreateIntConst(const IntVal &val, MIRType &type);
+  MIRIntConst *GetOrCreateIntConst(uint64 val, MIRType &type);
+
+  static std::unique_ptr<IntConstTable> Create() {
+    auto p = std::unique_ptr<IntConstTable>(new IntConstTable());
+    return p;
+  }
+
+ private:
+  IntConstTable() = default;
+  MIRIntConst *DoGetOrCreateIntConst(uint64 val, MIRType &type);
+  MIRIntConst *DoGetOrCreateIntConstTreadSafe(uint64 val, MIRType &type);
+  std::shared_timed_mutex mtx;
+  std::unordered_map<IntConstKey, MIRIntConst*, IntConstHash, IntConstCmp> intConstTable;
+};
+
+// STypeNameTable is only used to store class and interface types.
+// Each module maintains its own MIRTypeNameTable.
+class STypeNameTable {
+ public:
+  STypeNameTable() = default;
+  virtual ~STypeNameTable() = default;
+
+  const std::unordered_map<GStrIdx, TyIdx, GStrIdxHash> &GetGStridxToTyidxMap() const {
+    return gStrIdxToTyIdxMap;
+  }
+
+  TyIdx GetTyIdxFromGStrIdx(GStrIdx idx) const {
+    const auto it = gStrIdxToTyIdxMap.find(idx);
+    if (it == gStrIdxToTyIdxMap.cend()) {
+      return TyIdx(0);
+    }
+    return it->second;
+  }
+
+  void SetGStrIdxToTyIdx(GStrIdx gStrIdx, TyIdx tyIdx) {
+    gStrIdxToTyIdxMap[gStrIdx] = tyIdx;
+  }
+
+ private:
+  std::unordered_map<GStrIdx, TyIdx, GStrIdxHash> gStrIdxToTyIdxMap;
+};
+
+class FunctionTable {
+ public:
+  FunctionTable() {
+    funcTable.push_back(nullptr);
+  }  // puIdx 0 is reserved
+
+  virtual ~FunctionTable() = default;
+
+  std::vector<MIRFunction*> &GetFuncTable() {
+    return funcTable;
+  }
+
+  MIRFunction *GetFunctionFromPuidx(PUIdx pIdx) const {
+    CHECK_FATAL(pIdx < funcTable.size(), "Invalid puIdx");
+    return funcTable.at(pIdx);
+  }
+
+  void SetFunctionItem(uint32 pIdx, MIRFunction *func) {
+    CHECK_FATAL(pIdx < funcTable.size(), "Invalid puIdx");
+    funcTable[pIdx] = func;
+  }
+
+ private:
+  std::vector<MIRFunction*> funcTable;  // index is PUIdx
+};
+
+class GSymbolTable {
+ public:
+  GSymbolTable();
+  GSymbolTable(const GSymbolTable&) = delete;
+  GSymbolTable &operator=(const GSymbolTable&) = delete;
+  ~GSymbolTable();
+
+  MIRModule *GetModule() {
+    return module;
+  }
+
+  void SetModule(MIRModule *m) {
+    module = m;
+  }
+
+  bool IsValidIdx(size_t idx) const {
+    return idx < symbolTable.size();
+  }
+
+  MIRSymbol *GetSymbolFromStidx(uint32 idx, bool checkFirst = false) const {
+    if (checkFirst && idx >= symbolTable.size()) {
+      return nullptr;
+    }
+    ASSERT(IsValidIdx(idx), "symbol table index out of range");
+    return symbolTable[idx];
+  }
+
+  void SetStrIdxStIdxMap(GStrIdx strIdx, StIdx stIdx) {
+    strIdxToStIdxMap[strIdx] = stIdx;
+  }
+
+  StIdx GetStIdxFromStrIdx(GStrIdx idx) const {
+    const auto it = strIdxToStIdxMap.find(idx);
+    if (it == strIdxToStIdxMap.cend()) {
+      return StIdx();
+    }
+    return it->second;
+  }
+
+  MIRSymbol *GetSymbolFromStrIdx(GStrIdx idx, bool checkFirst = false) const {
+    return GetSymbolFromStidx(GetStIdxFromStrIdx(idx).Idx(), checkFirst);
+  }
+
+  size_t GetSymbolTableSize() const {
+    return symbolTable.size();
+  }
+
+  MIRSymbol *GetSymbol(uint32 idx) const {
+    ASSERT(idx < symbolTable.size(), "array index out of range");
+    return symbolTable.at(idx);
+  }
+
+  MIRSymbol *CreateSymbol(uint8 scopeID);
+  bool AddToStringSymbolMap(const MIRSymbol &st);
+  bool RemoveFromStringSymbolMap(const MIRSymbol &st);
+  void Dump(bool isLocal, int32 indent = 0) const;
+
+ private:
+  MIRModule *module = nullptr;
+  // hash table mapping string index to st index
+  std::unordered_map<GStrIdx, StIdx, GStrIdxHash> strIdxToStIdxMap;
+  std::vector<MIRSymbol*> symbolTable;  // map symbol idx to symbol node
+};
+
+class ConstPool {
+ public:
+  std::unordered_map<std::u16string, MIRSymbol*> &GetConstU16StringPool() {
+    return constU16StringPool;
+  }
+
+  void InsertConstPool(GStrIdx strIdx, MIRConst *cst) {
+    (void)constMap.emplace(strIdx, cst);
+  }
+
+  MIRConst *GetConstFromPool(GStrIdx strIdx) {
+    return constMap[strIdx];
+  }
+
+  void PutLiteralNameAsImported(GStrIdx gIdx) {
+    (void)importedLiteralNames.insert(gIdx);
+  }
+
+  bool LookUpLiteralNameFromImported(GStrIdx gIdx) {
+    return importedLiteralNames.find(gIdx) != importedLiteralNames.end();
+  }
+
+ protected:
+  std::unordered_map<GStrIdx, MIRConst*, GStrIdxHash> constMap;
+  std::set<GStrIdx> importedLiteralNames;
+
+ private:
+  std::unordered_map<std::u16string, MIRSymbol*> constU16StringPool;
+};
+
+class GlobalTables {
+ public:
+  static GlobalTables &GetGlobalTables();
+
+  static StringTable<std::string, GStrIdx> &GetStrTable() {
+    return globalTables.gStringTable;
+  }
+
+  static StringTable<std::string, UStrIdx> &GetUStrTable() {
+    return globalTables.uStrTable;
+  }
+
+  static StringTable<std::u16string, U16StrIdx> &GetU16StrTable() {
+    return globalTables.u16StringTable;
+  }
+
+  static TypeTable &GetTypeTable() {
+    return globalTables.typeTable;
+  }
+
+  static FPConstTable &GetFpConstTable() {
+    return *(globalTables.fpConstTablePtr);
+  }
+
+  static STypeNameTable &GetTypeNameTable() {
+    return globalTables.typeNameTable;
+  }
+
+  static FunctionTable &GetFunctionTable() {
+    return globalTables.functionTable;
+  }
+
+  static GSymbolTable &GetGsymTable() {
+    return globalTables.gSymbolTable;
+  }
+
+  static ConstPool &GetConstPool() {
+    return globalTables.constPool;
+  }
+
+  static IntConstTable &GetIntConstTable() {
+    return *(globalTables.intConstTablePtr);
+  }
+
+  static EnumTable &GetEnumTable() {
+    return globalTables.enumTable;
+  }
+
+  GlobalTables(const GlobalTables &globalTables) = delete;
+  GlobalTables(const GlobalTables &&globalTables) = delete;
+  GlobalTables &operator=(const GlobalTables &globalTables) = delete;
+  GlobalTables &operator=(const GlobalTables &&globalTables) = delete;
+
+ private:
+  GlobalTables() : fpConstTablePtr(FPConstTable::Create()),
+                   intConstTablePtr(IntConstTable::Create()) {
+    gStringTable.Init();
+    uStrTable.Init();
+    u16StringTable.Init();
+  }
+  virtual ~GlobalTables() = default;
+  static GlobalTables globalTables;
+
+  TypeTable typeTable;
+  STypeNameTable typeNameTable;
+  FunctionTable functionTable;
+  GSymbolTable gSymbolTable;
+  ConstPool constPool;
+  std::unique_ptr<FPConstTable> fpConstTablePtr;
+  std::unique_ptr<IntConstTable> intConstTablePtr;
+  StringTable<std::string, GStrIdx> gStringTable;
+  StringTable<std::string, UStrIdx> uStrTable;
+  StringTable<std::u16string, U16StrIdx> u16StringTable;
+  EnumTable enumTable;
+};
+
+inline MIRType &GetTypeFromTyIdx(TyIdx idx) {
+  return *(GlobalTables::GetTypeTable().GetTypeFromTyIdx(idx));
+}
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_GLOBAL_TABLES_H
diff --git a/src/mapleall/maple_ir/include/intrinsic_c.def b/src/mapleall/maple_ir/include/intrinsic_c.def
new file mode 100644
index 0000000000000000000000000000000000000000..cc34f9b8f75ec0480bb989ac659df702b24da445
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_c.def
@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+// DEF_MIR_INTRINSIC(STR, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5)
+DEF_MIR_INTRINSIC(C_strcmp,\
+                  "strcmp", 1, INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyI32, kArgTyPtr, kArgTyPtr)
+DEF_MIR_INTRINSIC(C_strncmp,\
+                  "strncmp", 1, INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyI32, kArgTyPtr, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C_strcpy,\
+                  "strcpy", 1, INTRNWRITEFIRSTOPND | INTRNREADSECONDOPND, \
+                  kArgTyPtr, kArgTyPtr, kArgTyPtr)
+DEF_MIR_INTRINSIC(C_strncpy,\
+                  "strncpy", 1, INTRNWRITEFIRSTOPND | INTRNREADSECONDOPND | INTRNREADTHIRDOPND, \
+                  kArgTyPtr, kArgTyPtr, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_strlen,\
+                  "strlen", 1, INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyU64, kArgTyPtr)
+DEF_MIR_INTRINSIC(C_strchr,\
+                  "strchr", 1, INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyPtr, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C_strrchr,\
+                  "strrchr", 1, INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyPtr, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C_memcmp,\
+                  "memcmp", 1, INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyI32, kArgTyPtr, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_memcpy,\
+                  "memcpy", 1, INTRNWRITEFIRSTOPND | INTRNREADSECONDOPND | INTRNREADTHIRDOPND, \
+                  kArgTyPtr, kArgTyPtr, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_memmove,\
+                  "memmove", 1, 0, kArgTyPtr, kArgTyPtr, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_memset,\
+                  "memset", 1, INTRNWRITEFIRSTOPND | INTRNREADSECONDOPND | INTRNREADTHIRDOPND, \
+                  kArgTyPtr, kArgTyPtr, kArgTyI32, kArgTyU64)
+DEF_MIR_INTRINSIC(C_acosf,\
+                  "acosf", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_asinf,\
+                  "asinf", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_atanf,\
+                  "atanf", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_cosf,\
+                  "cosf", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_coshf,\
+                  "coshf", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_expf,\
+                  "expf", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_logf,\
+                  "logf", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_log10f,\
+                  "log10f", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_sinf,\
+                  "sinf", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_sinhf,\
+                  "sinhf", 1, INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_acos,\
+                  "acos", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_asin,\
+                  "asin", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_atan,\
+                  "atan", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_cos,\
+                  "cos", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_cosh,\
+                  "cosh", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_exp,\
+                  "exp", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_log,\
+                  "log", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_log10,\
+                  "log10", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_sin,\
+                  "sin", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_sinh,\
+                  "sinh", 1, INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_ffs,\
+                  "ffs", 4, INTRNISPURE, kArgTyI32, kArgTyI32)
+DEF_MIR_INTRINSIC(C_va_start,\
+                  "va_start", 10,\
+                  INTRNISPURE | INTRNISSPECIAL | INTRNWRITEFIRSTOPND | INTRNREADSECONDOPND, \
+                  kArgTyVoid, kArgTyPtr, kArgTyI32)
+DEF_MIR_INTRINSIC(C_constant_p,\
+                  "constant_p", 0, 0, kArgTyI32, kArgTyDynany)
+DEF_MIR_INTRINSIC(C_clz32,\
+                  "clz32", 1, INTRNISPURE, kArgTyI32, kArgTyU32)
+DEF_MIR_INTRINSIC(C_clz64,\
+                  "clz64", 1, INTRNISPURE, kArgTyI32, kArgTyU64)
+DEF_MIR_INTRINSIC(C_ctz32,\
+                  "ctz32", 2, INTRNISPURE, kArgTyI32, kArgTyU32)
+DEF_MIR_INTRINSIC(C_ctz64,\
+                  "ctz64", 2, INTRNISPURE, kArgTyI32, kArgTyU64)
+DEF_MIR_INTRINSIC(C_popcount32,\
+                  "popcount32", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyI32, kArgTyU32)
+DEF_MIR_INTRINSIC(C_popcount64,\
+                  "popcount64", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyI32, kArgTyU64)
+DEF_MIR_INTRINSIC(C_parity32,\
+                  "parity32", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyI32, kArgTyU32)
+DEF_MIR_INTRINSIC(C_parity64,\
+                  "parity64", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyI32, kArgTyU64)
+DEF_MIR_INTRINSIC(C_clrsb32,\
+                  "clrsb32", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyI32, kArgTyU32)
+DEF_MIR_INTRINSIC(C_clrsb64,\
+                  "clrsb64", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyI32, kArgTyU64)
+DEF_MIR_INTRINSIC(C_isaligned,\
+                  "isaligned", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyU1, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_alignup,\
+                  "alignup", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyU1, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_aligndown,\
+                  "aligndown", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyU1, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_rev16_2,\
+                  "rev16", DEFAULT_NUM_INSN, INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI16, kArgTyI16)
+DEF_MIR_INTRINSIC(C_rev_4,\
+                  "rev", DEFAULT_NUM_INSN, INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyI32)
+DEF_MIR_INTRINSIC(C_rev_8,\
+                  "rev", DEFAULT_NUM_INSN, INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI64, kArgTyI64)
+DEF_MIR_INTRINSIC(C_bswap16,\
+                  "rev16", DEFAULT_NUM_INSN, INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI16, kArgTyI16)
+DEF_MIR_INTRINSIC(C_bswap32,\
+                  "rev", DEFAULT_NUM_INSN, INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyI32)
+DEF_MIR_INTRINSIC(C_bswap64,\
+                  "rev", DEFAULT_NUM_INSN, INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI64, kArgTyI64)
+DEF_MIR_INTRINSIC(C_stack_save,\
+                  "stack_save", DEFAULT_NUM_INSN, INTRNISPURE | INTRNISSPECIAL, kArgTyPtr)
+DEF_MIR_INTRINSIC(C_stack_restore,\
+                  "stack_restore", DEFAULT_NUM_INSN, INTRNISPURE | INTRNISSPECIAL, kArgTyPtr)
+// sync
+DEF_MIR_INTRINSIC(C___sync_add_and_fetch_1,\
+                  "__sync_add_and_fetch_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_add_and_fetch_2,\
+                  "__sync_add_and_fetch_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_add_and_fetch_4,\
+                  "__sync_add_and_fetch_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_add_and_fetch_8,\
+                  "__sync_add_and_fetch_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_sub_and_fetch_1,\
+                  "__sync_sub_and_fetch_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_sub_and_fetch_2,\
+                  "__sync_sub_and_fetch_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_sub_and_fetch_4,\
+                  "__sync_sub_and_fetch_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_sub_and_fetch_8,\
+                  "__sync_sub_and_fetch_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_add_1,\
+                  "__sync_fetch_and_add_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_add_2,\
+                  "__sync_fetch_and_add_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_add_4,\
+                  "__sync_fetch_and_add_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_add_8,\
+                  "__sync_fetch_and_add_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_sub_1,\
+                  "__sync_fetch_and_sub_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_sub_2,\
+                  "__sync_fetch_and_sub_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_sub_4,\
+                  "__sync_fetch_and_sub_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_sub_8,\
+                  "__sync_fetch_and_sub_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_bool_compare_and_swap_1,\
+                  "__sync_bool_compare_and_swap_1", 5, INTRNATOMIC, kArgTyU1, kArgTyPtr, kArgTyU8, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_bool_compare_and_swap_2,\
+                  "__sync_bool_compare_and_swap_2", 5, INTRNATOMIC, kArgTyU1, kArgTyPtr, kArgTyU16, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_bool_compare_and_swap_4,\
+                  "__sync_bool_compare_and_swap_4", 5, INTRNATOMIC, kArgTyU1, kArgTyPtr, kArgTyU32, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_bool_compare_and_swap_8,\
+                  "__sync_bool_compare_and_swap_8", 5, INTRNATOMIC, kArgTyU1, kArgTyPtr, kArgTyU64, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_val_compare_and_swap_1,\
+                  "__sync_val_compare_and_swap_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_val_compare_and_swap_2,\
+                  "__sync_val_compare_and_swap_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_val_compare_and_swap_4,\
+                  "__sync_val_compare_and_swap_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_val_compare_and_swap_8,\
+                  "__sync_val_compare_and_swap_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_lock_test_and_set_1,\
+                  "__sync_lock_test_and_set_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_lock_test_and_set_2,\
+                  "__sync_lock_test_and_set_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_lock_test_and_set_4,\
+                  "__sync_lock_test_and_set_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_lock_test_and_set_8,\
+                  "__sync_lock_test_and_set_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_lock_release_8,\
+                  "__sync_lock_release_8", 1, INTRNATOMIC, kArgTyVoid, kArgTyPtr)
+DEF_MIR_INTRINSIC(C___sync_lock_release_4,\
+                  "__sync_lock_release_4", 1, INTRNATOMIC, kArgTyVoid, kArgTyPtr)
+DEF_MIR_INTRINSIC(C___sync_lock_release_2,\
+                  "__sync_lock_release_2", 1, INTRNATOMIC, kArgTyVoid, kArgTyPtr)
+DEF_MIR_INTRINSIC(C___sync_lock_release_1,\
+                  "__sync_lock_release_1", 1, INTRNATOMIC, kArgTyVoid, kArgTyPtr)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_and_1,\
+                  "__sync_fetch_and_and_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_and_2,\
+                  "__sync_fetch_and_and_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_and_4,\
+                  "__sync_fetch_and_and_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_and_8,\
+                  "__sync_fetch_and_and_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_or_1,\
+                  "__sync_fetch_and_or_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_or_2,\
+                  "__sync_fetch_and_or_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_or_4,\
+                  "__sync_fetch_and_or_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_or_8,\
+                  "__sync_fetch_and_or_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_xor_1,\
+                  "__sync_fetch_and_xor_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_xor_2,\
+                  "__sync_fetch_and_xor_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_xor_4,\
+                  "__sync_fetch_and_xor_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_xor_8,\
+                  "__sync_fetch_and_xor_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_nand_1,\
+                  "__sync_fetch_and_nand_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_nand_2,\
+                  "__sync_fetch_and_nand_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_nand_4,\
+                  "__sync_fetch_and_nand_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_fetch_and_nand_8,\
+                  "__sync_fetch_and_nand_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_and_and_fetch_1,\
+                  "__sync_and_and_fetch_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_and_and_fetch_2,\
+                  "__sync_and_and_fetch_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_and_and_fetch_4,\
+                  "__sync_and_and_fetch_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_and_and_fetch_8,\
+                  "__sync_and_and_fetch_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_or_and_fetch_1,\
+                  "__sync_or_and_fetch_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_or_and_fetch_2,\
+                  "__sync_or_and_fetch_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_or_and_fetch_4,\
+                  "__sync_or_and_fetch_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_or_and_fetch_8,\
+                  "__sync_or_and_fetch_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_xor_and_fetch_1,\
+                  "__sync_xor_and_fetch_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_xor_and_fetch_2,\
+                  "__sync_xor_and_fetch_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_xor_and_fetch_4,\
+                  "__sync_xor_and_fetch_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_xor_and_fetch_8,\
+                  "__sync_xor_and_fetch_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_nand_and_fetch_1,\
+                  "__sync_nand_and_fetch_1", 5, INTRNATOMIC, kArgTyU8, kArgTyPtr, kArgTyU8)
+DEF_MIR_INTRINSIC(C___sync_nand_and_fetch_2,\
+                  "__sync_nand_and_fetch_2", 5, INTRNATOMIC, kArgTyU16, kArgTyPtr, kArgTyU16)
+DEF_MIR_INTRINSIC(C___sync_nand_and_fetch_4,\
+                  "__sync_nand_and_fetch_4", 5, INTRNATOMIC, kArgTyU32, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C___sync_nand_and_fetch_8,\
+                  "__sync_nand_and_fetch_8", 5, INTRNATOMIC, kArgTyU64, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C___sync_synchronize,\
+                  "__sync_synchronize", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyUndef)
+
+DEF_MIR_INTRINSIC(C__builtin_return_address,\
+                  "__builtin_return_address", 1, INTRNISPURE, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C__builtin_extract_return_addr,\
+                  "__builtin_extract_return_addr", 1, INTRNISPURE, kArgTyPtr, kArgTyPtr)
+DEF_MIR_INTRINSIC(C___builtin_expect,\
+                  "__builtin_expect", 0, INTRNISPURE, kArgTyI32, kArgTyI32, kArgTyI32)
+DEF_MIR_INTRINSIC(C___builtin_object_size,\
+                  "__builtin_object_size", 0, INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyU64, kArgTyPtr, kArgTyI32)
+// atomic
+DEF_MIR_INTRINSIC(C___atomic_load_n,\
+                  "__atomic_load_n", 1, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_load,\
+                  "__atomic_load", 1, INTRNATOMIC, kArgTyVoid, kArgTyPtr, kArgTyPtr, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_store_n,\
+                  "__atomic_store_n", 1, INTRNATOMIC, kArgTyVoid, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_store,\
+                  "__atomic_store", 1, INTRNATOMIC, kArgTyVoid, kArgTyPtr, kArgTyPtr, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_exchange_n,\
+                  "__atomic_exchange_n", 2, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_exchange,\
+                  "__atomic_exchange", 1, INTRNATOMIC, kArgTyVoid, kArgTyPtr, kArgTyPtr, kArgTyPtr, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_add_fetch,\
+                  "__atomic_add_fetch", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_sub_fetch,\
+                  "__atomic_sub_fetch", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_and_fetch,\
+                  "__atomic_and_fetch", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_xor_fetch,\
+                  "__atomic_xor_fetch", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_or_fetch,\
+                  "__atomic_or_fetch", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_nand_fetch,\
+                  "__atomic_nand_fetch", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_fetch_add,\
+                  "__atomic_fetch_add", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_fetch_sub,\
+                  "__atomic_fetch_sub", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_fetch_and,\
+                  "__atomic_fetch_and", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_fetch_xor,\
+                  "__atomic_fetch_xor", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_fetch_or,\
+                  "__atomic_fetch_or", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_fetch_nand,\
+                  "__atomic_fetch_nand", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyDynany, kArgTyPtr, kArgTyDynany, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_test_and_set,\
+                  "__atomic_test_and_set", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyU1, kArgTyPtr, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_clear,\
+                  "__atomic_clear", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyVoid, kArgTyPtr, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_thread_fence,\
+                  "__atomic_thread_fence", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyVoid, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_signal_fence,\
+                  "__atomic_signal_fence", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyVoid, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_always_lock_free,\
+                  "__atomic_always_lock_free", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyU1, kArgTyU64, kArgTyPtr)
+DEF_MIR_INTRINSIC(C___atomic_is_lock_free,\
+                  "__atomic_is_lock_free", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyU1, kArgTyU64, kArgTyPtr)
+DEF_MIR_INTRINSIC(C___atomic_compare_exchange_n,\
+                  "__atomic_compare_exchange_n", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyU1, kArgTyPtr, kArgTyPtr, kArgTyDynany, kArgTyU1, kArgTyI32, kArgTyI32)
+DEF_MIR_INTRINSIC(C___atomic_compare_exchange,\
+                  "__atomic_compare_exchange", DEFAULT_NUM_INSN, INTRNATOMIC, kArgTyU1, kArgTyPtr, kArgTyPtr, kArgTyPtr, kArgTyU1, kArgTyI32, kArgTyI32)
diff --git a/src/mapleall/maple_ir/include/intrinsic_dai.def b/src/mapleall/maple_ir/include/intrinsic_dai.def
new file mode 100644
index 0000000000000000000000000000000000000000..b1c398a7a5f8058fef5c6a3861c8de2e10c3ff3a
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_dai.def
@@ -0,0 +1,20 @@
+DEF_MIR_INTRINSIC(MCC_DeferredConstClass,\
+                  "MCC_DeferredConstClass", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCC_DeferredInstanceOf,\
+                  "MCC_DeferredInstanceOf", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyU1, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCC_DeferredCheckCast,\
+                  "MCC_DeferredCheckCast", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCC_DeferredNewInstance,\
+                  "MCC_DeferredNewInstance", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCC_DeferredNewArray,\
+                  "MCC_DeferredNewArray", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyI32)
+DEF_MIR_INTRINSIC(MCC_DeferredFillNewArray,\
+                  "MCC_DeferredFillNewArray", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyI32, kArgTyDynany, kArgTyDynany)
+DEF_MIR_INTRINSIC(MCC_DeferredLoadField,\
+                  "MCC_DeferredLoadField", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyDynany, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCC_DeferredStoreField,\
+                  "MCC_DeferredStoreField", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCC_DeferredInvoke,\
+                  "MCC_DeferredInvoke", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyDynany, kArgTyRef, kArgTyI32, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCC_DeferredClinitCheck,\
+                  "MCC_DeferredClinitCheck", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
diff --git a/src/mapleall/maple_ir/include/intrinsic_java.def b/src/mapleall/maple_ir/include/intrinsic_java.def
new file mode 100644
index 0000000000000000000000000000000000000000..f49b138b40bff8a70ddf640cdad7cbe9f423d8d4
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_java.def
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// DEF_MIR_INTRINSIC(STR, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5)
+DEF_MIR_INTRINSIC(JAVA_ARRAY_LENGTH,\
+                  "__java_array_length", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyI32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_ARRAY_FILL,\
+                  "__java_array_fill", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyVoid, kArgTyDynany, kArgTyDynany, kArgTyI32, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_FILL_NEW_ARRAY,\
+                  "__java_fill_new_array", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyRef, kArgTyI32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_CHECK_CAST,\
+                  "__java_check_cast", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_CONST_CLASS,\
+                  "__java_const_class", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_INSTANCE_OF,\
+                  "__java_instance_of", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_ISASSIGNABLEFROM,\
+                  "__java_isAssignableFrom", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_MERGE,\
+                  "__java_merge", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyPtr, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_CLINIT_CHECK,\
+                  "__java_clinit_check", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_POLYMORPHIC_CALL,\
+                  "__java_polymorphic_call", DEFAULT_NUM_INSN, INTRNISJAVA, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_THROW_ARITHMETIC,\
+                  "MCC_ThrowArithmeticException", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNEVERRETURN, kArgTyVoid, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_GET_CLASS,\
+                 "MCC_GetClass", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyPtr, kArgTyPtr, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
\ No newline at end of file
diff --git a/src/mapleall/maple_ir/include/intrinsic_js.def b/src/mapleall/maple_ir/include/intrinsic_js.def
new file mode 100644
index 0000000000000000000000000000000000000000..e366aff88e14264b1c82d10ceb1cc9f1c04ecaf6
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_js.def
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+// DEF_MIR_INTRINSIC(STR, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5)
+DEF_MIR_INTRINSIC(JS_INIT_CONTEXT,\
+                  "__js_init_context", DEFAULT_NUM_INSN, INTRNISJS, kArgTyVoid, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_REQUIRE,\
+                  "__js_require", DEFAULT_NUM_INSN, INTRNISJS | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_BIOBJECT,\
+                  "__jsobj_get_or_create_builtin", DEFAULT_NUM_INSN, INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_BISTRING,\
+                  "__jsstr_get_builtin", DEFAULT_NUM_INSN, INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTySimplestr, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_THIS,\
+                  "__jsop_this", DEFAULT_NUM_INSN, INTRNISJS | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_ADD,\
+                  "__jsop_add", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_CONCAT,\
+                  "__jsstr_concat_2", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTySimplestr, kArgTySimplestr, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_STRICTEQ,\
+                  "__jsop_stricteq", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSSTR_STRICTEQ,\
+                  "__jsstr_equal", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTySimplestr, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_STRICTNE,\
+                  "__jsop_strictne", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSSTR_STRICTNE,\
+                  "__jsstr_ne", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTySimplestr, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_INSTANCEOF,\
+                  "__jsop_instanceof", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_IN,\
+                  "__jsop_in", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_OR,\
+                  "__jsop_or", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_AND,\
+                  "__jsop_and", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_TYPEOF,\
+                  "__jsop_typeof", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSUNARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW,\
+                  "__js_new", DEFAULT_NUM_INSN, INTRNISJS | INTRNNOSIDEEFFECT, kArgTyPtr, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_STRING,\
+                  "__js_ToString", DEFAULT_NUM_INSN, INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTySimplestr, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSSTR_LENGTH,\
+                  "__jsstr_get_length", DEFAULT_NUM_INSN, INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU32, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_BOOLEAN,\
+                  "__js_ToBoolean", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSUNARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NUMBER,\
+                  "__js_ToNumber", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSUNARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_INT32,\
+                  "__js_ToInt32", DEFAULT_NUM_INSN, INTRNISJS | INTRNISJSUNARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_PRINT,\
+                  "__jsop_print", DEFAULT_NUM_INSN, INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_ERROR,\
+                  "__js_error", DEFAULT_NUM_INSN, INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT | INTRNNEVERRETURN, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_EVAL,\
+                  "__js_eval", DEFAULT_NUM_INSN, kIntrnUndef, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_ICALL,\
+                  "__js_icall", DEFAULT_NUM_INSN, INTRNISJS | INTRNRETURNSTRUCT, kArgTyDynany, kArgTyA32, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_CALL,
+                  "__jsop_call", DEFAULT_NUM_INSN, INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_CCALL,\
+                  "__jsop_ccall", DEFAULT_NUM_INSN, INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_NEW,
+                  "__jsop_new", DEFAULT_NUM_INSN, INTRNISJS | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_SETTIMEOUT,
+                  "__js_setTimeout", DEFAULT_NUM_INSN, INTRNISJS | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyI32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_SETCYCLEHEADER,\
+                  "__js_setCycleHeader", DEFAULT_NUM_INSN, INTRNISJS, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_OBJECT_0,\
+                  "__js_new_obj_obj_0", DEFAULT_NUM_INSN, INTRNISJS | INTRNNOSIDEEFFECT, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_OBJECT_1,\
+                  "__js_new_obj_obj_1", DEFAULT_NUM_INSN, INTRNISJS | INTRNNOSIDEEFFECT, kArgTySimpleobj, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_SETPROP,\
+                  "__jsop_setprop", DEFAULT_NUM_INSN, INTRNISJS, kArgTyVoid, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_GETPROP,\
+                  "__jsop_getprop", DEFAULT_NUM_INSN, INTRNISJS | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_DELPROP,\
+                  "__jsop_delprop", DEFAULT_NUM_INSN, INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_SETPROP_BY_NAME,\
+                  "__jsop_setprop_by_name", DEFAULT_NUM_INSN, INTRNISJS, kArgTyVoid, kArgTyDynany, kArgTySimplestr, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_GETPROP_BY_NAME,\
+                  "__jsop_getprop_by_name", DEFAULT_NUM_INSN, INTRNISJS | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_SETPROP_BY_INDEX,\
+                  "__jsop_setprop_by_index", DEFAULT_NUM_INSN, INTRNISJS, kArgTyVoid, kArgTyDynany, kArgTyU32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_GETPROP_BY_INDEX,\
+                  "__jsop_getprop_by_index", DEFAULT_NUM_INSN, INTRNISJS | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_INITPROP_BY_NAME,\
+                  "__jsop_initprop", DEFAULT_NUM_INSN, INTRNISJS, kArgTyVoid, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_INITPROP_GETTER,\
+                  "__jsop_initprop_getter", DEFAULT_NUM_INSN, INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_INITPROP_SETTER,\
+                  "__jsop_initprop_setter", DEFAULT_NUM_INSN, INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_FUNCTION,\
+                  "__js_new_function", DEFAULT_NUM_INSN, INTRNISJS, kArgTyDynany, kArgTyPtr, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_ARR_ELEMS,\
+                  "__js_new_arr_elems", DEFAULT_NUM_INSN, INTRNISJS | INTRNNOSIDEEFFECT, kArgTySimpleobj, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_ARR_LENGTH,\
+                  "__js_new_arr_length", DEFAULT_NUM_INSN, INTRNISJS | INTRNNOSIDEEFFECT, kArgTySimpleobj, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_LENGTH,\
+                  "__jsop_length", DEFAULT_NUM_INSN, INTRNISJS | INTRNLOADMEM | INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyI32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_NEW_ITERATOR,\
+                  "__jsop_valueto_iterator", DEFAULT_NUM_INSN, INTRNISJS, kArgTyPtr, kArgTyDynany, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_NEXT_ITERATOR,\
+                  "__jsop_iterator_next", DEFAULT_NUM_INSN, INTRNISJS, kArgTyDynany, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_MORE_ITERATOR,\
+                  "__jsop_more_iterator", DEFAULT_NUM_INSN, INTRNISJS, kArgTyU32, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_ADDSYSEVENTLISTENER,\
+                  "__js_add_sysevent_listener", DEFAULT_NUM_INSN, INTRNISJS, kArgTyU32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
\ No newline at end of file
diff --git a/src/mapleall/maple_ir/include/intrinsic_js_eng.def b/src/mapleall/maple_ir/include/intrinsic_js_eng.def
new file mode 100644
index 0000000000000000000000000000000000000000..f21cda4431815f7e09e1c8d50c04dd45e69ec3a9
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_js_eng.def
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+// DEF_MIR_INTRINSIC(STR, NAME, INTRN_CLASS, RETURN_TYPE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5)
+DEF_MIR_INTRINSIC(JS_GET_ARGUMENTOBJECT,\
+                  "__jsobj_get_or_create_argument", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_ERROR_OBJECT,\
+                  "__jsobj_get_or_create_error", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_EVALERROR_OBJECT,\
+                  "__jsobj_get_or_create_evalError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_RANGEERROR_OBJECT,\
+                  "__jsobj_get_or_create_rangeError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_REFERENCEERROR_OBJECT,\
+                  "__jsobj_get_or_create_referenceError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_SYNTAXERROR_OBJECT,\
+                  "__jsobj_get_or_create_syntaxError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_TYPEERROR_OBJECT,\
+                  "__jsobj_get_or_create_typeError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_URIERROR_OBJECT,\
+                  "__jsobj_get_or_create_uriError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_ASSERTVALUE,
+                  "__jsop_assert_value", INTRNISJS, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
\ No newline at end of file
diff --git a/src/mapleall/maple_ir/include/intrinsic_op.h b/src/mapleall/maple_ir/include/intrinsic_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..b929c1692a33591340b77ee34867a1e27107d769
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_op.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_INTRINSIC_OP_H
+#define MAPLE_IR_INCLUDE_INTRINSIC_OP_H
+
+namespace maple {
+enum MIRIntrinsicID {
+#define DEF_MIR_INTRINSIC(STR, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ...) INTRN_##STR,
+#include "intrinsics.def"
+#undef DEF_MIR_INTRINSIC
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_INTRINSIC_OP_H
diff --git a/src/mapleall/maple_ir/include/intrinsic_vector.def b/src/mapleall/maple_ir/include/intrinsic_vector.def
new file mode 100644
index 0000000000000000000000000000000000000000..d49c968021f787f611eec2e43e92307586451752
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_vector.def
@@ -0,0 +1,1244 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies, Inc.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the
+ * MulanPSL - 2.0. You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. See the
+ * MulanPSL - 2.0 for more details.
+ */
+
+// DEF_MIR_INTRINSIC(STR, NAME, INTRN_CLASS, RETURN_TYPE,
+//                   ARG0, ARG1, ARG2, ARG3, ARG4, ARG5)
+
+// vecTy vector_abs(vecTy src)
+//     Create a vector by getting the absolute value of the elements in src.
+DEF_MIR_INTRINSIC(vector_abs_v8i8, "vector_abs_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_abs_v4i16, "vector_abs_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_abs_v2i32, "vector_abs_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_abs_v1i64, "vector_abs_v1i64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyV1I64)
+DEF_MIR_INTRINSIC(vector_abs_v2f32, "vector_abs_v2f32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F32,
+                  kArgTyV2F32)
+DEF_MIR_INTRINSIC(vector_abs_v1f64, "vector_abs_v1f64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1F64,
+                  kArgTyV1F64)
+DEF_MIR_INTRINSIC(vector_abs_v16i8, "vector_abs_v16i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_abs_v8i16, "vector_abs_v8i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_abs_v4i32, "vector_abs_v4i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_abs_v2i64, "vector_abs_v2i64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64)
+DEF_MIR_INTRINSIC(vector_abs_v4f32, "vector_abs_v4f32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4F32,
+                  kArgTyV4F32)
+DEF_MIR_INTRINSIC(vector_abs_v2f64, "vector_abs_v2f64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F64,
+                  kArgTyV2F64)
+
+// vecTy vector_mov_narrow(vecTy src)
+//     copies each element of the operand vector to the corresponding element of the destination vector.
+//     The result element is half the width of the operand element, and values are saturated to the result width.
+//     The results are the same type as the operands.
+DEF_MIR_INTRINSIC(vector_mov_narrow_v8u16, "vector_mov_narrow_v8u16", 1,
+                  INTRNISVECTOR | INTRNISPURE |INTRNNOSIDEEFFECT, kArgTyV8U8, kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_mov_narrow_v4u32, "vector_mov_narrow_v4u32", 1,
+                  INTRNISVECTOR | INTRNISPURE |INTRNNOSIDEEFFECT, kArgTyV4U16, kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_mov_narrow_v2u64, "vector_mov_narrow_v2u64", 1,
+                  INTRNISVECTOR | INTRNISPURE |INTRNNOSIDEEFFECT, kArgTyV2U32, kArgTyV2U64)
+DEF_MIR_INTRINSIC(vector_mov_narrow_v8i16, "vector_mov_narrow_v8i16", 1,
+                  INTRNISVECTOR | INTRNISPURE |INTRNNOSIDEEFFECT, kArgTyV8I8, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_mov_narrow_v4i32, "vector_mov_narrow_v4i32", 1,
+                  INTRNISVECTOR | INTRNISPURE |INTRNNOSIDEEFFECT, kArgTyV4I16, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_mov_narrow_v2i64, "vector_mov_narrow_v2i64", 1,
+                  INTRNISVECTOR | INTRNISPURE |INTRNNOSIDEEFFECT, kArgTyV2I32, kArgTyV2I64)
+
+// vecTy vector_addl_low(vecTy src1, vecTy src2)
+//      Add each element of the source vector to second source
+//      put the result into the destination vector.
+DEF_MIR_INTRINSIC(vector_addl_low_v8i8, "vector_addl_low_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I8, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_addl_low_v4i16, "vector_addl_low_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I16, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_addl_low_v2i32, "vector_addl_low_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I32, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_addl_low_v8u8, "vector_addl_low_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U8, kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_addl_low_v4u16, "vector_addl_low_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U16, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_addl_low_v2u32, "vector_addl_low_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U32, kArgTyV2U32)
+
+// vecTy vector_addl_high(vecTy src1, vecTy src2)
+//     Add each element of the source vector to upper half of second source
+//     put the result into the destination vector.
+DEF_MIR_INTRINSIC(vector_addl_high_v8i8, "vector_addl_high_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV16I8, kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_addl_high_v4i16, "vector_addl_high_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV8I16, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_addl_high_v2i32, "vector_addl_high_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV4I32, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_addl_high_v8u8, "vector_addl_high_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV16U8, kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_addl_high_v4u16, "vector_addl_high_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV8U16, kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_addl_high_v2u32, "vector_addl_high_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV4U32, kArgTyV4U32)
+
+// vecTy vector_addw_low(vecTy src1, vecTy src2)
+//      Add each element of the source vector to second source
+//     widen the result into the destination vector.
+DEF_MIR_INTRINSIC(vector_addw_low_v8i8, "vector_addw_low_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_addw_low_v4i16, "vector_addw_low_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_addw_low_v2i32, "vector_addw_low_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_addw_low_v8u8, "vector_addw_low_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16, kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_addw_low_v4u16, "vector_addw_low_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_addw_low_v2u32, "vector_addw_low_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U64, kArgTyV2U32)
+
+// vecTy vector_addw_high(vecTy src1, vecTy src2)
+//     Add each element of the source vector to upper half of second source
+//     widen the result into the destination vector.
+DEF_MIR_INTRINSIC(vector_addw_high_v8i8, "vector_addw_high_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16, kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_addw_high_v4i16, "vector_addw_high_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_addw_high_v2i32, "vector_addw_high_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_addw_high_v8u8, "vector_addw_high_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16, kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_addw_high_v4u16, "vector_addw_high_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32, kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_addw_high_v2u32, "vector_addw_high_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U64, kArgTyV4U32)
+
+// vecTy vector_from_scalar(scalarTy value)
+//     Create a vector by repeating the scalar value for each element in the
+//     vector.
+DEF_MIR_INTRINSIC(vector_from_scalar_v2i64, "vector_from_scalar_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyI64)
+DEF_MIR_INTRINSIC(vector_from_scalar_v4i32, "vector_from_scalar_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyI32)
+DEF_MIR_INTRINSIC(vector_from_scalar_v8i16, "vector_from_scalar_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyI16)
+DEF_MIR_INTRINSIC(vector_from_scalar_v16i8, "vector_from_scalar_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyI8)
+DEF_MIR_INTRINSIC(vector_from_scalar_v2u64, "vector_from_scalar_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyU64)
+DEF_MIR_INTRINSIC(vector_from_scalar_v4u32, "vector_from_scalar_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyU32)
+DEF_MIR_INTRINSIC(vector_from_scalar_v8u16, "vector_from_scalar_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyU16)
+DEF_MIR_INTRINSIC(vector_from_scalar_v16u8, "vector_from_scalar_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16U8,
+                  kArgTyU8)
+DEF_MIR_INTRINSIC(vector_from_scalar_v2f64, "vector_from_scalar_v2f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F64,
+                  kArgTyF64)
+DEF_MIR_INTRINSIC(vector_from_scalar_v4f32, "vector_from_scalar_v4f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4F32,
+                  kArgTyF32)
+DEF_MIR_INTRINSIC(vector_from_scalar_v1i64, "vector_from_scalar_v1i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyI64)
+DEF_MIR_INTRINSIC(vector_from_scalar_v2i32, "vector_from_scalar_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyI32)
+DEF_MIR_INTRINSIC(vector_from_scalar_v4i16, "vector_from_scalar_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyI16)
+DEF_MIR_INTRINSIC(vector_from_scalar_v8i8, "vector_from_scalar_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyI8)
+DEF_MIR_INTRINSIC(vector_from_scalar_v1u64, "vector_from_scalar_v1u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyU64)
+DEF_MIR_INTRINSIC(vector_from_scalar_v2u32, "vector_from_scalar_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyU32)
+DEF_MIR_INTRINSIC(vector_from_scalar_v4u16, "vector_from_scalar_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyU16)
+DEF_MIR_INTRINSIC(vector_from_scalar_v8u8, "vector_from_scalar_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyU8)
+DEF_MIR_INTRINSIC(vector_from_scalar_v1f64, "vector_from_scalar_v1f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1F64,
+                  kArgTyF64)
+DEF_MIR_INTRINSIC(vector_from_scalar_v2f32, "vector_from_scalar_v2f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F32,
+                  kArgTyF32)
+
+// vecTy2 vector_labssub(vectTy1 src2, vectTy2 src2)
+//     Create a widened vector by getting the abs value of subtracted arguments.
+DEF_MIR_INTRINSIC(vector_labssub_low_v8i8, "vector_labssub_low_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I8, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_labssub_low_v4i16, "vector_labssub_low_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I16, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_labssub_low_v2i32, "vector_labssub_low_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I32, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_labssub_low_v8u8, "vector_labssub_low_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U8, kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_labssub_low_v4u16, "vector_labssub_low_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U16, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_labssub_low_v2u32, "vector_labssub_low_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U32, kArgTyV2U32)
+
+// vecTy2 vector_labssub_high(vectTy1 src2, vectTy2 src2)
+//     Create a widened vector by getting the abs value of subtracted high args.
+DEF_MIR_INTRINSIC(vector_labssub_high_v8i8, "vector_labssub_high_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV16I8, kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_labssub_high_v4i16, "vector_labssub_high_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV8I16, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_labssub_high_v2i32, "vector_labssub_high_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV4I32, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_labssub_high_v8u8, "vector_labssub_high_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV16U8, kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_labssub_high_v4u16, "vector_labssub_high_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV8U16, kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_labssub_high_v2u32, "vector_labssub_high_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV4U32, kArgTyV4U32)
+
+// vecTy2 vector_madd(vecTy2 accum, vecTy1 src1, vecTy1 src2)
+//      Multiply the elements of src1 and src2, then accumulate into accum.
+//      Elements of vecTy2 are twice as long as elements of vecTy1.
+DEF_MIR_INTRINSIC(vector_madd_v2i32, "vector_madd_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64, kArgTyV2I32, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_madd_v4i16, "vector_madd_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32, kArgTyV4I16, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_madd_v8i8, "vector_madd_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16, kArgTyV8I8, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_madd_v2u32, "vector_madd_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U64, kArgTyV2U32, kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_madd_v4u16, "vector_madd_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32, kArgTyV4U16, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_madd_v8u8, "vector_madd_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16, kArgTyV8U8, kArgTyV8U8)
+
+// vecTy2 vector_mull_low(vecTy1 src1, vecTy1 src2)
+//      Multiply the elements of src1 and src2. Elements of vecTy2 are twice as
+//      long as elements of vecTy1.
+DEF_MIR_INTRINSIC(vector_mull_low_v2i32, "vector_mull_low_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I32, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_mull_low_v4i16, "vector_mull_low_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I16, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_mull_low_v8i8, "vector_mull_low_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I8, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_mull_low_v2u32, "vector_mull_low_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U32, kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_mull_low_v4u16, "vector_mull_low_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U16, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_mull_low_v8u8, "vector_mull_low_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U8, kArgTyV8U8)
+
+// vecTy2 vector_mull_high(vecTy1 src1, vecTy1 src2)
+//      Multiply the upper elements of src1 and src2. Elements of vecTy2 are twice
+//      as long as elements of vecTy1.
+DEF_MIR_INTRINSIC(vector_mull_high_v2i32, "vector_mull_high_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I32, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_mull_high_v4i16, "vector_mull_high_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I16, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_mull_high_v8i8, "vector_mull_high_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I8, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_mull_high_v2u32, "vector_mull_high_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U32, kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_mull_high_v4u16, "vector_mull_high_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U16, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_mull_high_v8u8, "vector_mull_high_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U8, kArgTyV8U8)
+
+// vecTy vector_merge(vecTy src1, vecTy src2, int n)
+//     Create a vector by concatenating the high elements of src1, starting
+//     with the nth element, followed by the low elements of src2.
+DEF_MIR_INTRINSIC(vector_merge_v2i64, "vector_merge_v2i64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64, kArgTyV2I64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v4i32, "vector_merge_v4i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32, kArgTyV4I32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v8i16, "vector_merge_v8i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16, kArgTyV8I16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v16i8, "vector_merge_v16i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyV16I8, kArgTyV16I8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v2u64, "vector_merge_v2u64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U64, kArgTyV2U64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v4u32, "vector_merge_v4u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32, kArgTyV4U32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v8u16, "vector_merge_v8u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16, kArgTyV8U16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v16u8, "vector_merge_v16u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16U8,
+                  kArgTyV16U8, kArgTyV16U8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v2f64, "vector_merge_v2f64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F64,
+                  kArgTyV2F64, kArgTyV2F64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v4f32, "vector_merge_v4f32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4F32,
+                  kArgTyV4F32, kArgTyV4F32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v1i64, "vector_merge_v1i64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyV1I64, kArgTyV1I64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v2i32, "vector_merge_v2i32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV2I32, kArgTyV2I32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v4i16, "vector_merge_v4i16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV4I16, kArgTyV4I16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v8i8, "vector_merge_v8i8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV8I8, kArgTyV8I8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v1u64, "vector_merge_v1u64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyV1U64, kArgTyV1U64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v2u32, "vector_merge_v2u32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV2U32, kArgTyV2U32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v4u16, "vector_merge_v4u16",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV4U16, kArgTyV4U16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v8u8, "vector_merge_v8u8",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyV8U8, kArgTyV8U8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v1f64, "vector_merge_v1f64",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1F64,
+                  kArgTyV1F64, kArgTyV1F64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_merge_v2f32, "vector_merge_v2f32",
+                  1, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F32,
+                  kArgTyV2F32, kArgTyV2F32, kArgTyI32)
+
+// vecTy2 vector_get_low(vecTy1 src)
+//     Create a vector from the low part of the source vector.
+DEF_MIR_INTRINSIC(vector_get_low_v2i64, "vector_get_low_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyV2I64)
+DEF_MIR_INTRINSIC(vector_get_low_v4i32, "vector_get_low_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_get_low_v8i16, "vector_get_low_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_get_low_v16i8, "vector_get_low_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_get_low_v2u64, "vector_get_low_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyV2U64)
+DEF_MIR_INTRINSIC(vector_get_low_v4u32, "vector_get_low_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_get_low_v8u16, "vector_get_low_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_get_low_v16u8, "vector_get_low_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_get_low_v2f64, "vector_get_low_v2f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1F64,
+                  kArgTyV2F64)
+DEF_MIR_INTRINSIC(vector_get_low_v4f32, "vector_get_low_v4f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F32,
+                  kArgTyV4F32)
+
+// vecTy2 vector_get_low(vecTy1 src)
+//     Create a vector from the high part of the source vector.
+DEF_MIR_INTRINSIC(vector_get_high_v2i64, "vector_get_high_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyV2I64)
+DEF_MIR_INTRINSIC(vector_get_high_v4i32, "vector_get_high_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_get_high_v8i16, "vector_get_high_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_get_high_v16i8, "vector_get_high_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_get_high_v2u64, "vector_get_high_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyV2U64)
+DEF_MIR_INTRINSIC(vector_get_high_v4u32, "vector_get_high_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_get_high_v8u16, "vector_get_high_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_get_high_v16u8, "vector_get_high_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_get_high_v2f64, "vector_get_high_v2f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1F64,
+                  kArgTyV2F64)
+DEF_MIR_INTRINSIC(vector_get_high_v4f32, "vector_get_high_v4f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F32,
+                  kArgTyV4F32)
+
+// scalarTy vector_get_element(vecTy src, int n)
+//     Get the nth element of the source vector.
+DEF_MIR_INTRINSIC(vector_get_element_v2i64, "vector_get_element_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI64,
+                  kArgTyV2I64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v4i32, "vector_get_element_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32,
+                  kArgTyV4I32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v8i16, "vector_get_element_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI16,
+                  kArgTyV8I16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v16i8, "vector_get_element_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI8,
+                  kArgTyV16I8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v2u64, "vector_get_element_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU64,
+                  kArgTyV2U64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v4u32, "vector_get_element_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU32,
+                  kArgTyV4U32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v8u16, "vector_get_element_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU16,
+                  kArgTyV8U16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v16u8, "vector_get_element_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU8,
+                  kArgTyV16U8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v2f64, "vector_get_element_v2f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyF64,
+                  kArgTyV2F64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v4f32, "vector_get_element_v4f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyF32,
+                  kArgTyV4F32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v1i64, "vector_get_element_v1i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI64,
+                  kArgTyV1I64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v2i32, "vector_get_element_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32,
+                  kArgTyV2I32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v4i16, "vector_get_element_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI16,
+                  kArgTyV4I16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v8i8, "vector_get_element_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI8,
+                  kArgTyV8I8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v1u64, "vector_get_element_v1u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU64,
+                  kArgTyV1U64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v2u32, "vector_get_element_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU32,
+                  kArgTyV2U32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v4u16, "vector_get_element_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU16,
+                  kArgTyV4U16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v8u8, "vector_get_element_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU8,
+                  kArgTyV8U8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v1f64, "vector_get_element_v1f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyF64,
+                  kArgTyV1F64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_get_element_v2f32, "vector_get_element_v2f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyF32,
+                  kArgTyV2F32, kArgTyI32)
+
+// vecTy vector_set_element(ScalarTy value, VecTy vec, int n)
+//     Set the nth element of the source vector to value.
+DEF_MIR_INTRINSIC(vector_set_element_v2i64, "vector_set_element_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyI64, kArgTyV2I64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v4i32, "vector_set_element_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyI32, kArgTyV4I32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v8i16, "vector_set_element_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyI16, kArgTyV8I16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v16i8, "vector_set_element_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyI8, kArgTyV16I8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v2u64, "vector_set_element_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyU64, kArgTyV2U64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v4u32, "vector_set_element_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyU32, kArgTyV4U32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v8u16, "vector_set_element_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyU16, kArgTyV8U16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v16u8, "vector_set_element_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16U8,
+                  kArgTyU8, kArgTyV16U8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v2f64, "vector_set_element_v2f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F64,
+                  kArgTyF64, kArgTyV2F64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v4f32, "vector_set_element_v4f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4F32,
+                  kArgTyF32, kArgTyV4F32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v1i64, "vector_set_element_v1i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyI64, kArgTyV1I64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v2i32, "vector_set_element_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyI32, kArgTyV2I32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v4i16, "vector_set_element_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyI16, kArgTyV4I16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v8i8, "vector_set_element_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyI8, kArgTyV8I8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v1u64, "vector_set_element_v1u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyU64, kArgTyV1U64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v2u32, "vector_set_element_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyU32, kArgTyV2U32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v4u16, "vector_set_element_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyU16, kArgTyV4U16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v8u8, "vector_set_element_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyU8, kArgTyV8U8, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v1f64, "vector_set_element_v1f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1F64,
+                  kArgTyF64, kArgTyV1F64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_set_element_v2f32, "vector_set_element_v2f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F32,
+                  kArgTyF32, kArgTyV2F32, kArgTyI32)
+
+// vecTy2 vector_widen_low(vecTy1 src)
+//     Widen each element of the 64-bit argument to double size of the
+//     original width to a 128-bit destination vector.
+DEF_MIR_INTRINSIC(vector_widen_low_v2i32, "vector_widen_low_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_widen_low_v4i16, "vector_widen_low_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_widen_low_v8i8, "vector_widen_low_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_widen_low_v2u32, "vector_widen_low_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_widen_low_v4u16, "vector_widen_low_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_widen_low_v8u8, "vector_widen_low_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U8)
+
+// vecTy2 vector_widen_high(vecTy1 src)
+//     Widen each upper element of the 128-bit source vector to double size of
+//     the original width into a 128-bit destination vector.
+DEF_MIR_INTRINSIC(vector_widen_high_v2i32, "vector_widen_high_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_widen_high_v4i16, "vector_widen_high_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_widen_high_v8i8, "vector_widen_high_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_widen_high_v2u32, "vector_widen_high_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_widen_high_v4u16, "vector_widen_high_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_widen_high_v8u8, "vector_widen_high_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV16U8)
+
+// vecTy2 vector_narrow_low(vecTy1 src)
+//     Narrow each element of the 128-bit source vector to half of the original width,
+//     then write it to the lower half of the destination vector.
+DEF_MIR_INTRINSIC(vector_narrow_low_v2i64, "vector_narrow_low_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV2I64)
+DEF_MIR_INTRINSIC(vector_narrow_low_v4i32, "vector_narrow_low_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_narrow_low_v8i16, "vector_narrow_low_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_narrow_low_v2u64, "vector_narrow_low_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV2U64)
+DEF_MIR_INTRINSIC(vector_narrow_low_v4u32, "vector_narrow_low_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_narrow_low_v8u16, "vector_narrow_low_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyV8U16)
+
+// vecTy2 vector_narrow_high(vecTy1 src)
+//     Narrow each element of the upper source vector to half of the original width,
+//     concatenate with the first 64-bit arg into a 128-bit destination vector.
+DEF_MIR_INTRINSIC(vector_narrow_high_v2i64, "vector_narrow_high_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV2I32, kArgTyV2I64)
+DEF_MIR_INTRINSIC(vector_narrow_high_v4i32, "vector_narrow_high_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV4I16, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_narrow_high_v8i16, "vector_narrow_high_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyV8I8, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_narrow_high_v2u64, "vector_narrow_high_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV2U32, kArgTyV2U64)
+DEF_MIR_INTRINSIC(vector_narrow_high_v4u32, "vector_narrow_high_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV4U16, kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_narrow_high_v8u16, "vector_narrow_high_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16U8,
+                  kArgTyV8U8, kArgTyV8U16)
+
+// vecTy vector_pairwise_adalp(vecTy src1, vecTy2 src2)
+//     Pairwise add of src2 then accumulate into src1 as dest
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v8i8, "vector_pairwise_adalp_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV4I16, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v4i16, "vector_pairwise_adalp_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV2I32, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v2i32, "vector_pairwise_adalp_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyV1I64, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v8u8, "vector_pairwise_adalp_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV4U16, kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v4u16, "vector_pairwise_adalp_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV2U32, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v2u32, "vector_pairwise_adalp_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyV1U64, kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v16i8, "vector_pairwise_adalp_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16, kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v8i16, "vector_pairwise_adalp_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v4i32, "vector_pairwise_adalp_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v16u8, "vector_pairwise_adalp_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16, kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v8u16, "vector_pairwise_adalp_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32, kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_pairwise_adalp_v4u32, "vector_pairwise_adalp_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U64, kArgTyV4U32)
+
+// vecTy2 vector_pairwise_add(vecTy1 src)
+//     Add pairs of elements from the source vector and put the result into the
+//     destination vector, whose element size is twice and the number of
+//     elements is half of the source vector type.
+DEF_MIR_INTRINSIC(vector_pairwise_add_v4i32, "vector_pairwise_add_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v8i16, "vector_pairwise_add_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v16i8, "vector_pairwise_add_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v4u32, "vector_pairwise_add_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v8u16, "vector_pairwise_add_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v16u8, "vector_pairwise_add_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v2i32, "vector_pairwise_add_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v4i16, "vector_pairwise_add_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v8i8, "vector_pairwise_add_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v2u32, "vector_pairwise_add_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v4u16, "vector_pairwise_add_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_pairwise_add_v8u8, "vector_pairwise_add_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV8U8)
+
+// vecTy vector_reverse(vecTy src)
+//     Create a vector by reversing the order of the elements in src.
+DEF_MIR_INTRINSIC(vector_reverse_v2i64, "vector_reverse_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64)
+DEF_MIR_INTRINSIC(vector_reverse_v4i32, "vector_reverse_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_reverse_v8i16, "vector_reverse_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_reverse_v16i8, "vector_reverse_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_reverse_v2u64, "vector_reverse_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U64)
+DEF_MIR_INTRINSIC(vector_reverse_v4u32, "vector_reverse_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_reverse_v8u16, "vector_reverse_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_reverse_v16u8, "vector_reverse_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16U8,
+                  kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_reverse_v2f64, "vector_reverse_v2f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F64,
+                  kArgTyV2F64)
+DEF_MIR_INTRINSIC(vector_reverse_v4f32, "vector_reverse_v4f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4F32,
+                  kArgTyV4F32)
+DEF_MIR_INTRINSIC(vector_reverse_v1i64, "vector_reverse_v1i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyV1I64)
+DEF_MIR_INTRINSIC(vector_reverse_v2i32, "vector_reverse_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_reverse_v4i16, "vector_reverse_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_reverse_v8i8, "vector_reverse_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_reverse_v1u64, "vector_reverse_v1u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyV1U64)
+DEF_MIR_INTRINSIC(vector_reverse_v2u32, "vector_reverse_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_reverse_v4u16, "vector_reverse_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_reverse_v8u8, "vector_reverse_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_reverse_v1f64, "vector_reverse_v1f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1F64,
+                  kArgTyV1F64)
+DEF_MIR_INTRINSIC(vector_reverse_v2f32, "vector_reverse_v2f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F32,
+                  kArgTyV2F32)
+
+// vector_reverse16 with 8-bit elements
+DEF_MIR_INTRINSIC(vector_reverse16_v16u8, "vector_reverse16_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16U8,
+                  kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_reverse16_v16i8, "vector_reverse16_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_reverse16_v8u8, "vector_reverse16_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_reverse16_v8i8, "vector_reverse16_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV8I8)
+
+// vector_reverse64 with 8-bit elements
+DEF_MIR_INTRINSIC(vector_reverse64_v16u8, "vector_reverse64_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16U8,
+                  kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_reverse64_v16i8, "vector_reverse64_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_reverse64_v8u8, "vector_reverse64_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_reverse64_v8i8, "vector_reverse64_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV8I8)
+
+// vector_reverse64 with 16-bit elements
+DEF_MIR_INTRINSIC(vector_reverse64_v8u16, "vector_reverse64_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_reverse64_v8i16, "vector_reverse64_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_reverse64_v4u16, "vector_reverse64_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_reverse64_v4i16, "vector_reverse64_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV4I16)
+
+// vector_reverse64 with 32-bit elements
+DEF_MIR_INTRINSIC(vector_reverse64_v4u32, "vector_reverse64_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_reverse64_v4i32, "vector_reverse64_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_reverse64_v2u32, "vector_reverse64_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_reverse64_v2i32, "vector_reverse64_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV2I32)
+
+// vecTy2 vector_shift_narrow_low(vecTy1 src, const int n)
+//     Shift each element in the vector right by n, narrow each element to half
+//     of the original width (truncating), then write the result to the lower
+//     half of the destination vector.
+DEF_MIR_INTRINSIC(vector_shr_narrow_low_v2i64, "vector_shr_narrow_low_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV2I64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_shr_narrow_low_v4i32, "vector_shr_narrow_low_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV4I32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_shr_narrow_low_v8i16, "vector_shr_narrow_low_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV8I16, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_shr_narrow_low_v2u64, "vector_shr_narrow_low_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV2U64, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_shr_narrow_low_v4u32, "vector_shr_narrow_low_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV4U32, kArgTyI32)
+DEF_MIR_INTRINSIC(vector_shr_narrow_low_v8u16, "vector_shr_narrow_low_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyV8U16, kArgTyI32)
+
+// scalarTy vector_sum(vecTy src)
+//     Sum all of the elements in the vector into a scalar.
+DEF_MIR_INTRINSIC(vector_sum_v2i64, "vector_sum_v2i64",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI64,
+                  kArgTyV2I64)
+DEF_MIR_INTRINSIC(vector_sum_v4i32, "vector_sum_v4i32",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32,
+                  kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_sum_v8i16, "vector_sum_v8i16",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI16,
+                  kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_sum_v16i8, "vector_sum_v16i8",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI8,
+                  kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_sum_v2u64, "vector_sum_v2u64",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU64,
+                  kArgTyV2U64)
+DEF_MIR_INTRINSIC(vector_sum_v4u32, "vector_sum_v4u32",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU32,
+                  kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_sum_v8u16, "vector_sum_v8u16",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU16,
+                  kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_sum_v16u8, "vector_sum_v16u8",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU8,
+                  kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_sum_v2f64, "vector_sum_v2f64",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyF64,
+                  kArgTyV2F64)
+DEF_MIR_INTRINSIC(vector_sum_v4f32, "vector_sum_v4f32",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyF32,
+                  kArgTyV4F32)
+DEF_MIR_INTRINSIC(vector_sum_v1i64, "vector_sum_v1i64",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI64,
+                  kArgTyV1I64)
+DEF_MIR_INTRINSIC(vector_sum_v2i32, "vector_sum_v2i32",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32,
+                  kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_sum_v4i16, "vector_sum_v4i16",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI16,
+                  kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_sum_v8i8, "vector_sum_v8i8",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI8,
+                  kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_sum_v1u64, "vector_sum_v1u64",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU64,
+                  kArgTyV1U64)
+DEF_MIR_INTRINSIC(vector_sum_v2u32, "vector_sum_v2u32",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU32,
+                  kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_sum_v4u16, "vector_sum_v4u16",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU16,
+                  kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_sum_v8u8, "vector_sum_v8u8",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU8,
+                  kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_sum_v1f64, "vector_sum_v1f64",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyF64,
+                  kArgTyV1F64)
+DEF_MIR_INTRINSIC(vector_sum_v2f32, "vector_sum_v2f32",
+                  2, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyF32,
+                  kArgTyV2F32)
+
+// vecTy table_lookup(vecTy tbl, vecTy idx)
+//     Performs a table vector lookup.
+DEF_MIR_INTRINSIC(vector_table_lookup_v2i64, "vector_table_lookup_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64, kArgTyV2I64)
+DEF_MIR_INTRINSIC(vector_table_lookup_v4i32, "vector_table_lookup_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_table_lookup_v8i16, "vector_table_lookup_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_table_lookup_v16i8, "vector_table_lookup_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyV16I8, kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_table_lookup_v2u64, "vector_table_lookup_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U64, kArgTyV2U64)
+DEF_MIR_INTRINSIC(vector_table_lookup_v4u32, "vector_table_lookup_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32, kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_table_lookup_v8u16, "vector_table_lookup_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16, kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_table_lookup_v16u8, "vector_table_lookup_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV16U8,
+                  kArgTyV16U8, kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_table_lookup_v2f64, "vector_table_lookup_v2f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F64,
+                  kArgTyV2F64, kArgTyV2F64)
+DEF_MIR_INTRINSIC(vector_table_lookup_v4f32, "vector_table_lookup_v4f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4F32,
+                  kArgTyV4F32, kArgTyV4F32)
+DEF_MIR_INTRINSIC(vector_table_lookup_v1i64, "vector_table_lookup_v1i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyV1I64, kArgTyV1I64)
+DEF_MIR_INTRINSIC(vector_table_lookup_v2i32, "vector_table_lookup_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyV2I32, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_table_lookup_v4i16, "vector_table_lookup_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyV4I16, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_table_lookup_v8i8, "vector_table_lookup_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyV8I8, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_table_lookup_v1u64, "vector_table_lookup_v1u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyV1U64, kArgTyV1U64)
+DEF_MIR_INTRINSIC(vector_table_lookup_v2u32, "vector_table_lookup_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyV2U32, kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_table_lookup_v4u16, "vector_table_lookup_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyV4U16, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_table_lookup_v8u8, "vector_table_lookup_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyV8U8, kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_table_lookup_v1f64, "vector_table_lookup_v1f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV1F64,
+                  kArgTyV1F64, kArgTyV1F64)
+DEF_MIR_INTRINSIC(vector_table_lookup_v2f32, "vector_table_lookup_v2f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2F32,
+                  kArgTyV2F32, kArgTyV2F32)
+
+// vecArrTy vector_zip(vecTy a, vecTy b)
+//     Interleave the upper half of elements from a and b into the destination
+//     vector.
+DEF_MIR_INTRINSIC(vector_zip_v2i32, "vector_zip_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT | INTRNISSPECIAL,
+                  kArgTyAgg, kArgTyV2I32, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_zip_v4i16, "vector_zip_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT | INTRNISSPECIAL,
+                  kArgTyAgg, kArgTyV4I16, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_zip_v8i8, "vector_zip_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT | INTRNISSPECIAL,
+                  kArgTyAgg, kArgTyV8I8, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_zip_v2u32, "vector_zip_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT | INTRNISSPECIAL,
+                  kArgTyAgg, kArgTyV2U32, kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_zip_v4u16, "vector_zip_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT | INTRNISSPECIAL,
+                  kArgTyAgg, kArgTyV4U16, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_zip_v8u8, "vector_zip_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT | INTRNISSPECIAL,
+                  kArgTyAgg, kArgTyV8U8, kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_zip_v2f32, "vector_zip_v2f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT | INTRNISSPECIAL,
+                  kArgTyAgg, kArgTyV2F32, kArgTyV2F32)
+
+// vecTy vector_load(scalarTy *ptr)
+//     Load the elements pointed to by ptr into a vector.
+DEF_MIR_INTRINSIC(vector_load_v2i64, "vector_load_v2i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v4i32, "vector_load_v4i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v8i16, "vector_load_v8i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v16i8, "vector_load_v16i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV16I8,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v2u64, "vector_load_v2u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v4u32, "vector_load_v4u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v8u16, "vector_load_v8u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v16u8, "vector_load_v16u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV16U8,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v2f64, "vector_load_v2f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV2F64,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v4f32, "vector_load_v4f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV4F32,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v1i64, "vector_load_v1i64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV1I64,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v2i32, "vector_load_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV2I32,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v4i16, "vector_load_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV4I16,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v8i8, "vector_load_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV8I8,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v1u64, "vector_load_v1u64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV1U64,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v2u32, "vector_load_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV2U32,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v4u16, "vector_load_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV4U16,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v8u8, "vector_load_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV8U8,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v1f64, "vector_load_v1f64",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV1F64,
+                  kArgTyPtr)
+DEF_MIR_INTRINSIC(vector_load_v2f32, "vector_load_v2f32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyV2F32,
+                  kArgTyPtr)
+
+// void vector_store(scalarTy *ptr, vecTy src)
+//     Store the elements from src into the memory pointed to by ptr.
+DEF_MIR_INTRINSIC(vector_store_v2i64, "vector_store_v2i64", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV2I64)
+DEF_MIR_INTRINSIC(vector_store_v4i32, "vector_store_v4i32", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_store_v8i16, "vector_store_v8i16", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_store_v16i8, "vector_store_v16i8", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_store_v2u64, "vector_store_v2u64", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV2U64)
+DEF_MIR_INTRINSIC(vector_store_v4u32, "vector_store_v4u32", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV4U32)
+DEF_MIR_INTRINSIC(vector_store_v8u16, "vector_store_v8u16", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_store_v16u8, "vector_store_v16u8", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_store_v2f64, "vector_store_v2f64", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV2F64)
+DEF_MIR_INTRINSIC(vector_store_v4f32, "vector_store_v4f32", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV4F32)
+DEF_MIR_INTRINSIC(vector_store_v1i64, "vector_store_v1i64", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV1I64)
+DEF_MIR_INTRINSIC(vector_store_v2i32, "vector_store_v2i32", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_store_v4i16, "vector_store_v4i16", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_store_v8i8, "vector_store_v8i8", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_store_v1u64, "vector_store_v1u64", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV1U64)
+DEF_MIR_INTRINSIC(vector_store_v2u32, "vector_store_v2u32", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV2U32)
+DEF_MIR_INTRINSIC(vector_store_v4u16, "vector_store_v4u16", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_store_v8u8, "vector_store_v8u8", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_store_v1f64, "vector_store_v1f64", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV1F64)
+DEF_MIR_INTRINSIC(vector_store_v2f32, "vector_store_v2f32", DEFAULT_NUM_INSN, INTRNISVECTOR,
+                  kArgTyVoid, kArgTyPtr, kArgTyV2F32)
+
+// vecTy vector_subl_low(vecTy src1, vecTy src2)
+//     Subtract each element of the source vector to second source
+//     widen the result into the destination vector.
+DEF_MIR_INTRINSIC(vector_subl_low_v8i8, "vector_subl_low_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I8, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_subl_low_v4i16, "vector_subl_low_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I16, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_subl_low_v2i32, "vector_subl_low_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I32, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_subl_low_v8u8, "vector_subl_low_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U8, kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_subl_low_v4u16, "vector_subl_low_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U16, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_subl_low_v2u32, "vector_subl_low_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U32, kArgTyV2U32)
+
+// vecTy vector_subl_high(vecTy src1, vecTy src2)
+//     Subtract each element of the source vector to upper half of second source
+//     widen the result into the destination vector.
+DEF_MIR_INTRINSIC(vector_subl_high_v8i8, "vector_subl_high_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV16I8, kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_subl_high_v4i16, "vector_subl_high_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV8I16, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_subl_high_v2i32, "vector_subl_high_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV4I32, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_subl_high_v8u8, "vector_subl_high_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV16U8, kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_subl_high_v4u16, "vector_subl_high_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV8U16, kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_subl_high_v2u32, "vector_subl_high_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV4U32, kArgTyV4U32)
+
+// vecTy vector_subw_low(vecTy src1, vecTy src2)
+//     Subtract each element of the source vector to second source
+//     widen the result into the destination vector.
+DEF_MIR_INTRINSIC(vector_subw_low_v8i8, "vector_subw_low_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16, kArgTyV8I8)
+DEF_MIR_INTRINSIC(vector_subw_low_v4i16, "vector_subw_low_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32, kArgTyV4I16)
+DEF_MIR_INTRINSIC(vector_subw_low_v2i32, "vector_subw_low_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64, kArgTyV2I32)
+DEF_MIR_INTRINSIC(vector_subw_low_v8u8, "vector_subw_low_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16, kArgTyV8U8)
+DEF_MIR_INTRINSIC(vector_subw_low_v4u16, "vector_subw_low_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32, kArgTyV4U16)
+DEF_MIR_INTRINSIC(vector_subw_low_v2u32, "vector_subw_low_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U64, kArgTyV2U32)
+
+// vecTy vector_subw_high(vecTy src1, vecTy src2)
+//     Subtract each element of the source vector to upper half of second source
+//     widen the result into the destination vector.
+DEF_MIR_INTRINSIC(vector_subw_high_v8i8, "vector_subw_high_v8i8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8I16,
+                  kArgTyV8I16, kArgTyV16I8)
+DEF_MIR_INTRINSIC(vector_subw_high_v4i16, "vector_subw_high_v4i16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4I32,
+                  kArgTyV4I32, kArgTyV8I16)
+DEF_MIR_INTRINSIC(vector_subw_high_v2i32, "vector_subw_high_v2i32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2I64,
+                  kArgTyV2I64, kArgTyV4I32)
+DEF_MIR_INTRINSIC(vector_subw_high_v8u8, "vector_subw_high_v8u8",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV8U16,
+                  kArgTyV8U16, kArgTyV16U8)
+DEF_MIR_INTRINSIC(vector_subw_high_v4u16, "vector_subw_high_v4u16",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV4U32,
+                  kArgTyV4U32, kArgTyV8U16)
+DEF_MIR_INTRINSIC(vector_subw_high_v2u32, "vector_subw_high_v2u32",
+                  DEFAULT_NUM_INSN, INTRNISVECTOR | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyV2U64,
+                  kArgTyV2U64, kArgTyV4U32)
diff --git a/src/mapleall/maple_ir/include/intrinsics.def b/src/mapleall/maple_ir/include/intrinsics.def
new file mode 100644
index 0000000000000000000000000000000000000000..097769a147d8e1dc949adb1537d114da1ccdc4ed
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsics.def
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// DEF_MIR_INTRINSIC(STR, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5)
+#define DEFAULT_NUM_INSN 3
+DEF_MIR_INTRINSIC(UNDEFINED,\
+                  nullptr, DEFAULT_NUM_INSN, kIntrnUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(DEX_ATOMIC_INC,\
+                  "__dex_ainc", DEFAULT_NUM_INSN, kIntrnIsAtomic, kArgTyI32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(DEX_ATOMIC_DEC,\
+                  "__dex_adec", DEFAULT_NUM_INSN, kIntrnIsAtomic, kArgTyI32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_ATOMIC_EXCHANGE_PTR,\
+                  "__mpl_atomic_exchange_ptr", DEFAULT_NUM_INSN, kIntrnIsAtomic, kArgTyPtr, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_CLINIT_CHECK,\
+                  "__mpl_clinit_check", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyVoid, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_PROF_COUNTER_INC,\
+                  "__mpl_prof_counter_inc", DEFAULT_NUM_INSN, INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyVoid, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_CLEAR_STACK,\
+                  "__mpl_clear_stack", DEFAULT_NUM_INSN, kIntrnUndef, kArgTyVoid, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_GET_VTAB_FUNC,\
+                  "MCC_getFuncPtrFromVtab", DEFAULT_NUM_INSN, kIntrnUndef, kArgTyA64, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_READ_STATIC_OFFSET_TAB,\
+                  "__mpl_read_static_offset", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY,\
+                  "__mpl_const_offset", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyA32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY2,\
+                  "__mpl_const_offset2", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyA32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY_LAZY,\
+                  "__mpl_const_offset_lazy", DEFAULT_NUM_INSN, INTRNNOSIDEEFFECT, kArgTyA32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY_VTAB_LAZY,\
+                  "__mpl_const_offset_vtab_lazy", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY_FIELD_LAZY,\
+                  "__mpl_const_offset_field_lazy", DEFAULT_NUM_INSN, INTRNISPURE, kArgTyA32, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_BOUNDARY_CHECK,\
+                  "", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyU1, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_READ_ARRAYCLASS_CACHE_ENTRY,\
+                  "__mpl_const_arrayclass_cache", DEFAULT_NUM_INSN, kIntrnUndef, kArgTyPtr, kArgTyU32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+
+// start of RC Intrinsics with one parameters
+DEF_MIR_INTRINSIC(MCCSetPermanent,\
+                  "MCC_SetObjectPermanent", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCIncRef,\
+                  "MCC_IncRef_NaiveRCFast", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCDecRef,\
+                  "MCC_DecRef_NaiveRCFast", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCDecRefReset,\
+                  "MCC_ClearLocalStackRef", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyPtr)
+DEF_MIR_INTRINSIC(MCCLoadRefSVol,\
+                  "MCC_LoadVolatileStaticField", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCLoadRefS,\
+                  "MCC_LoadRefStatic", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCSetObjectPermanent,\
+                  "MCC_SetObjectPermanent", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef)
+
+// start of RC Intrinsics with two parameters
+DEF_MIR_INTRINSIC(MCCCheck,\
+                  "MCC_CheckRefCount", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyU32)
+DEF_MIR_INTRINSIC(MCCCheckArrayStore,\
+                  "MCC_Reflect_Check_Arraystore", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCIncDecRef,\
+                  "MCC_IncDecRef_NaiveRCFast", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCIncDecRefReset,\
+                  "MCC_IncDecRefReset", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyPtr)
+DEF_MIR_INTRINSIC(MCCDecRefResetPair,\
+                  "MCC_DecRefResetPair", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyPtr, kArgTyPtr)
+DEF_MIR_INTRINSIC(MCCLoadWeakVol,\
+                  "MCC_LoadVolatileWeakField", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCLoadWeak,\
+                  "MCC_LoadWeakField", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCLoadRef,\
+                  "MCC_LoadRefField_NaiveRCFast", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCLoadRefVol,\
+                  "MCC_LoadVolatileField", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteReferent,\
+                  "MCC_WriteReferent", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteSVolNoInc,\
+                  "MCC_WriteVolatileStaticFieldNoInc", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteSVolNoDec,\
+                  "MCC_WriteVolatileStaticFieldNoDec", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteSVolNoRC,\
+                  "MCC_WriteVolatileStaticFieldNoRC", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteSVol,\
+                  "MCC_WriteVolatileStaticField", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteSNoInc,\
+                  "MCC_WriteRefFieldStaticNoInc", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteSNoDec,\
+                  "MCC_WriteRefFieldStaticNoDec", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteSNoRC,\
+                  "MCC_WriteRefFieldStaticNoRC", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteS,\
+                  "MCC_WriteRefFieldStatic", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef)
+
+// start of RC intrinsics with three parameters
+DEF_MIR_INTRINSIC(MCCWriteVolNoInc,\
+                  "MCC_WriteVolatileFieldNoInc", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteVolNoDec,\
+                  "MCC_WriteVolatileFieldNoDec", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteVolNoRC,\
+                  "MCC_WriteVolatileFieldNoRC", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteVol,\
+                  "MCC_WriteVolatileField", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteNoInc,\
+                  "MCC_WriteRefFieldNoInc", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteNoDec,\
+                  "MCC_WriteRefFieldNoDec", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteNoRC,\
+                  "MCC_WriteRefFieldNoRC", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWrite,\
+                  "MCC_WriteRefField", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteVolWeak,\
+                  "MCC_WriteVolatileWeakField", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MCCWriteWeak,\
+                  "MCC_WriteWeakField", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef)
+
+DEF_MIR_INTRINSIC(MPL_CLEANUP_LOCALREFVARS,\
+                  "__mpl_cleanup_localrefvars", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyUndef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MPL_CLEANUP_LOCALREFVARS_SKIP,\
+                  "__mpl_cleanup_localrefvars_skip", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyUndef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+DEF_MIR_INTRINSIC(MPL_MEMSET_LOCALVAR,\
+                  "", DEFAULT_NUM_INSN, kIntrnUndef, kArgTyPtr, kArgTyU32, kArgTyU8, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_SET_CLASS,\
+                  "", DEFAULT_NUM_INSN, kIntrnUndef, kArgTyPtr, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_CLEANUP_NORETESCOBJS,\
+                  "__mpl_cleanup_noretescobjs", DEFAULT_NUM_INSN, INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyUndef, kArgTyRef, kArgTyRef,\
+                  kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef)
+
+// start of GC Intrinsics
+DEF_MIR_INTRINSIC(MCCGCCheck,\
+                  "MCC_CheckObjAllocated", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef)
+
+// start of Profile Intrinsics
+DEF_MIR_INTRINSIC(MCCSaveProf,\
+                  "MCC_SaveProfile", DEFAULT_NUM_INSN, INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef)
+
+#include "intrinsic_java.def"
+#include "simplifyintrinsics.def"
+#include "intrinsic_c.def"
+#include "intrinsic_js.def"
+#include "intrinsic_js_eng.def"
+#include "dex2mpl/dexintrinsic.def"
+#include "intrinsic_dai.def"
+#include "intrinsic_vector.def"
+DEF_MIR_INTRINSIC(LAST,\
+                  nullptr, DEFAULT_NUM_INSN, kIntrnUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
diff --git a/src/mapleall/maple_ir/include/intrinsics.h b/src/mapleall/maple_ir/include/intrinsics.h
new file mode 100644
index 0000000000000000000000000000000000000000..91e4249dbe6dabdc4fa8cd6b68f9d7d0faef0032
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsics.h
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_INTRINSICS_H
+#define MAPLE_IR_INCLUDE_INTRINSICS_H
+#include "prim_types.h"
+#include "intrinsic_op.h"
+
+namespace maple {
+enum IntrinProperty {
+  kIntrnUndef,
+  kIntrnIsJs,
+  kIntrnIsJsUnary,
+  kIntrnIsJsBinary,
+  kIntrnIsJava,
+  kIntrnIsJavaUnary,
+  kIntrnIsJavaBinary,
+  kIntrnIsReturnStruct,
+  kIntrnNoSideEffect, // read only
+  kIntrnIsLoadMem,
+  kIntrnIsPure,
+  kIntrnNeverReturn,
+  kIntrnIsAtomic,
+  kIntrnIsRC,
+  kIntrnIsSpecial,
+  kIntrnIsVector,
+  // the opnd is marked as "WRITE" but not "READ" => write only
+  // the opnd is marked as "READ" but not "WRITE" => read only
+  // the opnd is marked with nothing but has side effect => write & read
+  // the opnd is marked as "WRITE" and "READ" => write & read
+  kIntrnWriteFirstOpnd,
+  kIntrnWriteSecondOpnd,
+  kIntrnWriteThirdOpnd,
+  kIntrnWriteFourthOpnd,
+  kIntrnWriteFifthOpnd,
+  kIntrnWriteSixthOpnd,
+  kIntrnReadFirstOpnd,
+  kIntrnReadSecondOpnd,
+  kIntrnReadThirdOpnd,
+  kIntrnReadFourthOpnd,
+  kIntrnReadFifthOpnd,
+  kIntrnReadSixthOpnd,
+};
+
+enum IntrinArgType {
+  kArgTyUndef,
+  kArgTyVoid,
+  kArgTyI8,
+  kArgTyI16,
+  kArgTyI32,
+  kArgTyI64,
+  kArgTyU8,
+  kArgTyU16,
+  kArgTyU32,
+  kArgTyU64,
+  kArgTyU1,
+  kArgTyPtr,
+  kArgTyRef,
+  kArgTyA32,
+  kArgTyA64,
+  kArgTyF32,
+  kArgTyF64,
+  kArgTyF128,
+  kArgTyC64,
+  kArgTyC128,
+  kArgTyAgg,
+  kArgTyV2I64,
+  kArgTyV4I32,
+  kArgTyV8I16,
+  kArgTyV16I8,
+  kArgTyV2U64,
+  kArgTyV4U32,
+  kArgTyV8U16,
+  kArgTyV16U8,
+  kArgTyV2F64,
+  kArgTyV4F32,
+  kArgTyV1I64,
+  kArgTyV2I32,
+  kArgTyV4I16,
+  kArgTyV8I8,
+  kArgTyV1U64,
+  kArgTyV2U32,
+  kArgTyV4U16,
+  kArgTyV8U8,
+  kArgTyV1F64,
+  kArgTyV2F32,
+#ifdef DYNAMICLANG
+  kArgTyDynany,
+  kArgTyDynu32,
+  kArgTyDyni32,
+  kArgTyDynundef,
+  kArgTyDynnull,
+  kArgTyDynhole,
+  kArgTyDynbool,
+  kArgTyDynf64,
+  kArgTyDynf32,
+  kArgTySimplestr,
+  kArgTyDynstr,
+  kArgTySimpleobj,
+  kArgTyDynobj
+#endif
+};
+
+constexpr uint32 INTRNISJS = 1U << kIntrnIsJs;
+constexpr uint32 INTRNISJSUNARY = 1U << kIntrnIsJsUnary;
+constexpr uint32 INTRNISJSBINARY = 1U << kIntrnIsJsBinary;
+constexpr uint32 INTRNISJAVA = 1U << kIntrnIsJava;
+constexpr uint32 INTRNNOSIDEEFFECT = 1U << kIntrnNoSideEffect;
+constexpr uint32 INTRNRETURNSTRUCT = 1U << kIntrnIsReturnStruct;
+constexpr uint32 INTRNLOADMEM = 1U << kIntrnIsLoadMem;
+constexpr uint32 INTRNISPURE = 1U << kIntrnIsPure;
+constexpr uint32 INTRNNEVERRETURN = 1U << kIntrnNeverReturn;
+constexpr uint32 INTRNATOMIC = 1U << kIntrnIsAtomic;
+constexpr uint32 INTRNISRC = 1U << kIntrnIsRC;
+constexpr uint32 INTRNISSPECIAL = 1U << kIntrnIsSpecial;
+constexpr uint32 INTRNISVECTOR = 1U << kIntrnIsVector;
+constexpr uint32 INTRNWRITEFIRSTOPND = 1U << kIntrnWriteFirstOpnd;
+constexpr uint32 INTRNWRITESECONDOPND = 1U << kIntrnWriteSecondOpnd;
+constexpr uint32 INTRNWRITETHIRDOPND = 1U << kIntrnWriteThirdOpnd;
+constexpr uint32 INTRNWRITEFOURTHOPND = 1U << kIntrnWriteFourthOpnd;
+constexpr uint32 INTRNWRITEFIFTHOPND = 1U << kIntrnWriteFifthOpnd;
+constexpr uint32 INTRNWRITESIXTHOPND = 1U << kIntrnWriteSixthOpnd;
+constexpr uint32 INTRNREADFIRSTOPND = 1U << kIntrnReadFirstOpnd;
+constexpr uint32 INTRNREADSECONDOPND = 1U << kIntrnReadSecondOpnd;
+constexpr uint32 INTRNREADTHIRDOPND = 1U << kIntrnReadThirdOpnd;
+constexpr uint32 INTRNREADFOURTHOPND = 1U << kIntrnReadFourthOpnd;
+constexpr uint32 INTRNREADFIFTHOPND = 1U << kIntrnReadFifthOpnd;
+constexpr uint32 INTRNREADSIXTHOPND = 1U << kIntrnReadSixthOpnd;
+class MIRType;    // circular dependency exists, no other choice
+class MIRModule;  // circular dependency exists, no other choice
+struct IntrinDesc {
+  static constexpr int kMaxArgsNum = 7;
+  const char *name;
+  size_t numInsn;
+  uint32 properties;
+  IntrinArgType argTypes[1 + kMaxArgsNum];  // argTypes[0] is the return type
+  bool IsJS() const {
+    return static_cast<bool>(properties & INTRNISJS);
+  }
+
+  bool IsJava() const {
+    return static_cast<bool>(properties & INTRNISJAVA);
+  }
+
+  bool IsJsUnary() const {
+    return static_cast<bool>(properties & INTRNISJSUNARY);
+  }
+
+  bool IsJsBinary() const {
+    return static_cast<bool>(properties & INTRNISJSBINARY);
+  }
+
+  bool IsJsOp() const {
+    return static_cast<bool>(properties & INTRNISJSUNARY) || static_cast<bool>(properties & INTRNISJSBINARY);
+  }
+
+  bool IsLoadMem() const {
+    return static_cast<bool>(properties & INTRNLOADMEM);
+  }
+
+  bool IsJsReturnStruct() const {
+    return static_cast<bool>(properties & INTRNRETURNSTRUCT);
+  }
+
+  bool IsPure() const {
+    return static_cast<bool>(properties & INTRNISPURE);
+  }
+
+  bool IsNeverReturn() const {
+    return static_cast<bool>(properties & INTRNNEVERRETURN);
+  }
+
+  bool IsAtomic() const {
+    return static_cast<bool>(properties & INTRNATOMIC);
+  }
+
+  bool IsRC() const {
+    return static_cast<bool>(properties & INTRNISRC);
+  }
+
+  bool IsSpecial() const {
+    return static_cast<bool>(properties & INTRNISSPECIAL);
+  }
+
+  bool HasNoSideEffect() const {
+    return static_cast<bool>(properties & INTRNNOSIDEEFFECT);
+  }
+
+  bool IsVectorOp() const {
+    return static_cast<bool>(properties & INTRNISVECTOR);
+  }
+
+  size_t GetNumInsn() const {
+    return numInsn;
+  }
+
+  bool IsNthOpndMarkedToWrite(uint32 opndIdx) const;
+  bool IsNthOpndMarkedToRead(uint32 opndIdx) const;
+  bool ReadNthOpnd(uint32 opndIdx) const;
+  bool WriteNthOpnd(uint32 opndIdx) const;
+  MIRType *GetReturnType() const;
+  MIRType *GetArgType(uint32 index) const;
+  MIRType *GetTypeFromArgTy(IntrinArgType argType) const;
+  static MIRType *jsValueType;
+  static MIRModule *mirModule;
+  static void InitMIRModule(MIRModule *mod);
+  static MIRType *GetOrCreateJSValueType();
+  static IntrinDesc intrinTable[INTRN_LAST + 1];
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_INTRINSICS_H
diff --git a/src/mapleall/maple_ir/include/ir_safe_cast_traits.def b/src/mapleall/maple_ir/include/ir_safe_cast_traits.def
new file mode 100644
index 0000000000000000000000000000000000000000..14ed1a367b4ea5f8b738103b6412af97f7ae2988
--- /dev/null
+++ b/src/mapleall/maple_ir/include/ir_safe_cast_traits.def
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <safe_cast.h>
+#include "opcode_info.h"
+
+namespace maple {
+#ifdef LOAD_SAFE_CAST_FOR_MIR_CONST
+#undef LOAD_SAFE_CAST_FOR_MIR_CONST
+REGISTER_SAFE_CAST(MIRIntConst, from.GetKind() == kConstInt);
+REGISTER_SAFE_CAST(MIRAddrofConst, from.GetKind() == kConstAddrof);
+REGISTER_SAFE_CAST(MIRAddroffuncConst, from.GetKind() == kConstAddrofFunc);
+REGISTER_SAFE_CAST(MIRLblConst, from.GetKind() == kConstLblConst);
+REGISTER_SAFE_CAST(MIRStrConst, from.GetKind() == kConstStrConst);
+REGISTER_SAFE_CAST(MIRStr16Const, from.GetKind() == kConstStr16Const);
+REGISTER_SAFE_CAST(MIRFloatConst, from.GetKind() == kConstFloatConst);
+REGISTER_SAFE_CAST(MIRDoubleConst, from.GetKind() == kConstDoubleConst);
+REGISTER_SAFE_CAST(MIRFloat128Const, from.GetKind() == kConstFloat128Const);
+REGISTER_SAFE_CAST(MIRAggConst, from.GetKind() == kConstAggConst);
+REGISTER_SAFE_CAST(MIRStConst, from.GetKind() == kConstStConst);
+#endif
+
+#ifdef LOAD_SAFE_CAST_FOR_MIR_TYPE
+#undef LOAD_SAFE_CAST_FOR_MIR_TYPE
+REGISTER_SAFE_CAST(MIRPtrType, from.GetKind() == kTypePointer);
+REGISTER_SAFE_CAST(MIRArrayType, from.GetKind() == kTypeArray);
+REGISTER_SAFE_CAST(MIRFarrayType, from.GetKind() == kTypeFArray ||
+                                  instance_of<MIRJarrayType>(from));
+REGISTER_SAFE_CAST(MIRStructType, from.GetKind() == kTypeStruct ||
+                                  from.GetKind() == kTypeStructIncomplete ||
+                                  from.GetKind() == kTypeUnion ||
+                                  instance_of<MIRClassType>(from) ||
+                                  instance_of<MIRInterfaceType>(from));
+REGISTER_SAFE_CAST(MIRJarrayType, from.GetKind() == kTypeJArray);
+REGISTER_SAFE_CAST(MIRClassType, from.GetKind() == kTypeClass ||
+                                 from.GetKind() == kTypeClassIncomplete);
+REGISTER_SAFE_CAST(MIRInterfaceType, from.GetKind() == kTypeInterface ||
+                                     from.GetKind() == kTypeInterfaceIncomplete);
+REGISTER_SAFE_CAST(MIRBitFieldType, from.GetKind() == kTypeBitField);
+REGISTER_SAFE_CAST(MIRFuncType, from.GetKind() == kTypeFunction);
+REGISTER_SAFE_CAST(MIRTypeByName, from.GetKind() == kTypeByName);
+REGISTER_SAFE_CAST(MIRTypeParam, from.GetKind() == kTypeParam);
+REGISTER_SAFE_CAST(MIRInstantVectorType, from.GetKind() == kTypeInstantVector);
+REGISTER_SAFE_CAST(MIRGenericInstantType, from.GetKind() == kTypeGenericInstant);
+#endif
+
+#ifdef LOAD_SAFE_CAST_FOR_MIR_NODE
+#undef LOAD_SAFE_CAST_FOR_MIR_NODE
+REGISTER_SAFE_CAST(UnaryNode, from.GetOpCode() == OP_abs ||
+                              from.GetOpCode() == OP_bnot ||
+                              from.GetOpCode() == OP_lnot ||
+                              from.GetOpCode() == OP_neg ||
+                              from.GetOpCode() == OP_recip ||
+                              from.GetOpCode() == OP_sqrt ||
+                              from.GetOpCode() == OP_alloca ||
+                              from.GetOpCode() == OP_malloc ||
+                              instance_of<TypeCvtNode>(from) ||
+                              instance_of<ExtractbitsNode>(from) ||
+                              instance_of<JarrayMallocNode>(from) ||
+                              instance_of<IreadNode>(from) ||
+                              instance_of<IreadoffNode>(from));
+REGISTER_SAFE_CAST(TypeCvtNode, from.GetOpCode() == OP_ceil ||
+                                from.GetOpCode() == OP_cvt ||
+                                from.GetOpCode() == OP_floor ||
+                                from.GetOpCode() == OP_round ||
+                                from.GetOpCode() == OP_trunc ||
+                                instance_of<RetypeNode>(from));
+REGISTER_SAFE_CAST(RetypeNode, from.GetOpCode() == OP_retype);
+REGISTER_SAFE_CAST(ExtractbitsNode, from.GetOpCode() == OP_extractbits ||
+                                    from.GetOpCode() == OP_sext ||
+                                    from.GetOpCode() == OP_zext);
+REGISTER_SAFE_CAST(GCMallocNode, from.GetOpCode() == OP_gcmalloc ||
+                                 from.GetOpCode() = OP_gcpermalloc);
+REGISTER_SAFE_CAST(JarrayMallocNode, from.GetOpCode() == OP_gcmallocjarray ||
+                                     from.GetOpCode() = OP_gcpermallocjarray);
+REGISTER_SAFE_CAST(IreadNode, from.GetOpCode() == OP_iread ||
+                              from.GetOpCode() = OP_iaddrof);
+REGISTER_SAFE_CAST(IreadoffNode, from.GetOpCode() == OP_ireadoff);
+REGISTER_SAFE_CAST(IreadFPoffNode, from.GetOpCode() == OP_ireadfpoff);
+REGISTER_SAFE_CAST(BinaryNode, from.GetOpCode() == OP_add ||
+                               from.GetOpCode() == OP_sub ||
+                               from.GetOpCode() == OP_mul ||
+                               from.GetOpCode() == OP_div ||
+                               from.GetOpCode() == OP_rem ||
+                               from.GetOpCode() == OP_ashr ||
+                               from.GetOpCode() == OP_lshr ||
+                               from.GetOpCode() == OP_shl ||
+                               from.GetOpCode() == OP_max ||
+                               from.GetOpCode() == OP_min ||
+                               from.GetOpCode() == OP_band ||
+                               from.GetOpCode() == OP_bior ||
+                               from.GetOpCode() == OP_bxor ||
+                               from.GetOpCode() == OP_CG_array_elem_add ||
+                               from.GetOpCode() == OP_land ||
+                               from.GetOpCode() == OP_lior ||
+                               from.GetOpCode() == OP_cand ||
+                               from.GetOpCode() == OP_cior ||
+                               instance_of<CompareNode>(from) ||
+                               instance_of<DepositbitsNode>(from) ||
+                               instance_of<ResolveFuncNode>(from));
+REGISTER_SAFE_CAST(CompareNode, from.GetOpCode() == OP_eq ||
+                                from.GetOpCode() = OP_ge ||
+                                from.GetOpCode() = OP_gt ||
+                                from.GetOpCode() = OP_le ||
+                                from.GetOpCode() = OP_lt ||
+                                from.GetOpCode() = OP_ne ||
+                                from.GetOpCode() = OP_cmp ||
+                                from.GetOpCode() = OP_cmpl ||
+                                from.GetOpCode() = OP_cmpg);
+REGISTER_SAFE_CAST(DepositbitsNode, from.GetOpCode() == OP_depositbits);
+REGISTER_SAFE_CAST(ResolveFuncNode, from.GetOpCode() == OP_resolveinterfacefunc ||
+                                    from.GetOpCode() == OP_resolvevirtualfunc);
+REGISTER_SAFE_CAST(TernaryNode, from.GetOpCode() == OP_select);
+REGISTER_SAFE_CAST(NaryNode, instance_of<IntrinsicopNode>(from) ||
+                             instance_of<ArrayNode>(from));
+REGISTER_SAFE_CAST(IntrinsicopNode, from.GetOpCode() == OP_intrinsicop ||
+                                    from.GetOpCode() == OP_intrinsicopwithtype);
+REGISTER_SAFE_CAST(ConstvalNode, from.GetOpCode() == OP_constval);
+REGISTER_SAFE_CAST(ConststrNode, from.GetOpCode() == OP_conststr);
+REGISTER_SAFE_CAST(Conststr16Node, from.GetOpCode() == OP_conststr16);
+REGISTER_SAFE_CAST(SizeoftypeNode, from.GetOpCode() == OP_sizeoftype);
+REGISTER_SAFE_CAST(FieldsDistNode, from.GetOpCode() == OP_fieldsdist);
+REGISTER_SAFE_CAST(ArrayNode, from.GetOpCode() == OP_array);
+REGISTER_SAFE_CAST(AddrofNode, from.GetOpCode() == OP_dread ||
+                               from.GetOpCode() == OP_addrof);
+REGISTER_SAFE_CAST(RegreadNode, from.GetOpCode() == OP_regread);
+REGISTER_SAFE_CAST(AddroffuncNode, from.GetOpCode() == OP_addroffunc);
+REGISTER_SAFE_CAST(AddroflabelNode, from.GetOpCode() == OP_addroflabel);
+REGISTER_SAFE_CAST(StmtNode, from.GetOpCode() == OP_finally ||
+                             from.GetOpCode() == OP_cleanuptry ||
+                             from.GetOpCode() == OP_endtry ||
+                             from.GetOpCode() == OP_retsub ||
+                             from.GetOpCode() == OP_membaracquire ||
+                             from.GetOpCode() == OP_membarrelease ||
+                             from.GetOpCode() == OP_membarstoreload ||
+                             from.GetOpCode() == OP_membarstorestore ||
+                             instance_of<IassignNode>(from) ||
+                             instance_of<GotoNode>(from) ||
+                             instance_of<JsTryNode>(from) ||
+                             instance_of<TryNode>(from) ||
+                             instance_of<CatchNode>(from) ||
+                             instance_of<SwitchNode>(from) ||
+                             instance_of<MultiwayNode>(from) ||
+                             instance_of<UnaryStmtNode>(from) ||
+                             instance_of<BlockNode>(from) ||
+                             instance_of<DoloopNode>(from) ||
+                             instance_of<ForeachelemNode>(from) ||
+                             instance_of<NaryStmtNode>(from) ||
+                             instance_of<LabelNode>(from) ||
+                             instance_of<CommentNode>(from));
+REGISTER_SAFE_CAST(IassignNode, from.GetOpCode() == OP_iassign);
+REGISTER_SAFE_CAST(GotoNode, from.GetOpCode() == OP_goto ||
+                             from.GetOpCode() == OP_gosub);
+REGISTER_SAFE_CAST(JsTryNode, from.GetOpCode() == OP_jstry);
+REGISTER_SAFE_CAST(TryNode, from.GetOpCode() == OP_try);
+REGISTER_SAFE_CAST(CatchNode, from.GetOpCode() == OP_catch);
+REGISTER_SAFE_CAST(SwitchNode, from.GetOpCode() == OP_switch);
+REGISTER_SAFE_CAST(MultiwayNode, from.GetOpCode() == OP_multiway);
+REGISTER_SAFE_CAST(UnaryStmtNode, from.GetOpCode() == OP_eval ||
+                                  from.GetOpCode() == OP_throw ||
+                                  from.GetOpCode() == OP_free ||
+                                  from.GetOpCode() == OP_decref ||
+                                  from.GetOpCode() == OP_incref ||
+                                  from.GetOpCode() == OP_decrefreset ||
+                                  (kOpcodeInfo.IsAssertNonnull(from.GetOpCode()) &&
+                                   !kOpcodeInfo.IsCallAssertNonnull(from.GetOpCode())) ||
+                                  instance_of<DassignNode>(from) ||
+                                  instance_of<RegassignNode>(from) ||
+                                  instance_of<CondGotoNode>(from) ||
+                                  instance_of<RangeGotoNode>(from) ||
+                                  instance_of<IfStmtNode>(from) ||
+                                  instance_of<WhileStmtNode>(from) ||
+                                  instance_of<IassignFPoffNode>(from));
+REGISTER_SAFE_CAST(CallAssertNonnullStmtNode, from.GetOpCode() == OP_callassertnonnull);
+REGISTER_SAFE_CAST(DassignNode, from.GetOpCode() == OP_dassign ||
+                                from.GetOpCode() == OP_maydassign);
+REGISTER_SAFE_CAST(RegassignNode, from.GetOpCode() == OP_regassign);
+REGISTER_SAFE_CAST(CondGotoNode, from.GetOpCode() == OP_brtrue ||
+                                 from.GetOpCode() == OP_brfalse);
+REGISTER_SAFE_CAST(RangeGotoNode, from.GetOpCode() == OP_rangegoto);
+REGISTER_SAFE_CAST(BlockNode, from.GetOpCode() == OP_block);
+REGISTER_SAFE_CAST(IfStmtNode, from.GetOpCode() == OP_if);
+REGISTER_SAFE_CAST(WhileStmtNode, from.GetOpCode() == OP_while ||
+                                  from.GetOpCode() == OP_dowhile);
+REGISTER_SAFE_CAST(DoloopNode, from.GetOpCode() == OP_doloop);
+REGISTER_SAFE_CAST(ForeachelemNode, from.GetOpCode() == OP_foreachelem);
+REGISTER_SAFE_CAST(BinaryStmtNode, from.GetOpCode() == OP_assertge ||
+                                   from.GetOpCode() == OP_assertlt ||
+                                   instance_of<IassignoffNode>(from));
+REGISTER_SAFE_CAST(IassignoffNode, from.GetOpCode() == OP_iassignoff);
+REGISTER_SAFE_CAST(IassignFPoffNode, from.GetOpCode() == OP_iassignfpoff);
+REGISTER_SAFE_CAST(NaryStmtNode, from.GetOpCode() == OP_return ||
+                                 from.GetOpCode() == OP_syncenter ||
+                                 from.GetOpCode() == OP_syncexit ||
+                                 instance_of<CallNode>(from) ||
+                                 instance_of<IcallNode>(from) ||
+                                 instance_of<IntrinsiccallNode>(from));
+REGISTER_SAFE_CAST(CallNode, from.GetOpCode() == OP_call ||
+                             from.GetOpCode() == OP_virtualcall ||
+                             from.GetOpCode() == OP_superclasscall ||
+                             from.GetOpCode() == OP_interfacecall ||
+                             from.GetOpCode() == OP_customcall ||
+                             from.GetOpCode() == OP_polymorphiccall ||
+                             from.GetOpCode() == OP_interfaceicall ||
+                             from.GetOpCode() == OP_virtualicall ||
+                             from.GetOpCode() == OP_callassigned ||
+                             from.GetOpCode() == OP_virtualcallassigned ||
+                             from.GetOpCode() == OP_superclasscallassigned ||
+                             from.GetOpCode() == OP_interfacecallassigned ||
+                             from.GetOpCode() == OP_customcallassigned ||
+                             from.GetOpCode() == OP_polymorphiccallassigned ||
+                             from.GetOpCode() == OP_interfaceicallassigned ||
+                             from.GetOpCode() == OP_virtualicallassigned ||
+                             instance_of<CallinstantNode>(from));
+REGISTER_SAFE_CAST(IcallNode, from.GetOpCode() == OP_icall ||
+                              from.GetOpCode() == OP_icallassigned ||
+                              from.GetOpCode() == OP_icallproto ||
+                              from.GetOpCode() == OP_icallprotoassigned);
+REGISTER_SAFE_CAST(IntrinsiccallNode, from.GetOpCode() == OP_intrinsiccall ||
+                                      from.GetOpCode() == OP_intrinsiccallwithtype ||
+                                      from.GetOpCode() == OP_xintrinsiccall ||
+                                      from.GetOpCode() == OP_intrinsiccallassigned ||
+                                      from.GetOpCode() == OP_intrinsiccallwithtypeassigned ||
+                                      from.GetOpCode() == OP_xintrinsiccallassigned);
+REGISTER_SAFE_CAST(CallinstantNode, from.GetOpCode() == OP_callinstant ||
+                                    from.GetOpCode() == OP_virtualcallinstant ||
+                                    from.GetOpCode() == OP_superclasscallinstant ||
+                                    from.GetOpCode() == OP_interfacecallinstant ||
+                                    from.GetOpCode() == OP_callinstantassigned ||
+                                    from.GetOpCode() == OP_virtualcallinstantassigned ||
+                                    from.GetOpCode() == OP_superclasscallinstantassigned ||
+                                    from.GetOpCode() == OP_interfacecallinstantassigned);
+REGISTER_SAFE_CAST(LabelNode, from.GetOpCode() == OP_label);
+REGISTER_SAFE_CAST(CommentNode, from.GetOpCode() == OP_comment);
+#endif
+}
diff --git a/src/mapleall/maple_ir/include/java_eh_lower.h b/src/mapleall/maple_ir/include/java_eh_lower.h
new file mode 100644
index 0000000000000000000000000000000000000000..5462ea04b899ef303bcfcf1495712a9df7c9fe8a
--- /dev/null
+++ b/src/mapleall/maple_ir/include/java_eh_lower.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_JAVA_EH_LOWER_H
+#define MAPLE_IR_INCLUDE_JAVA_EH_LOWER_H
+#include "phase_impl.h"
+#include "class_hierarchy.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+class JavaEHLowerer : public FuncOptimizeImpl {
+ public:
+  JavaEHLowerer(MIRModule &mod, KlassHierarchy *kh, bool dump) : FuncOptimizeImpl(mod, kh, dump) {}
+  ~JavaEHLowerer() = default;
+
+  FuncOptimizeImpl *Clone() override {
+    return new JavaEHLowerer(*this);
+  }
+
+  void ProcessFunc(MIRFunction *func) override;
+
+ private:
+  BlockNode *DoLowerBlock(BlockNode&);
+  BaseNode *DoLowerExpr(BaseNode&, BlockNode&);
+  BaseNode *DoLowerDiv(BinaryNode&, BlockNode&);
+  void DoLowerBoundaryCheck(IntrinsiccallNode&, BlockNode&);
+  BaseNode *DoLowerRem(BinaryNode &expr, BlockNode &blkNode) {
+    return DoLowerDiv(expr, blkNode);
+  }
+
+  uint32 divSTIndex = 0;                 // The index of divide operand and result.
+  bool useRegTmp = Options::usePreg;     // Use register to save temp variable or not.
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MJavaEHLowerer)
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_JAVA_EH_LOWER_H
diff --git a/src/mapleall/maple_ir/include/keywords.def b/src/mapleall/maple_ir/include/keywords.def
new file mode 100644
index 0000000000000000000000000000000000000000..14c906656fa9038ba5477726b305ce102dd1773d
--- /dev/null
+++ b/src/mapleall/maple_ir/include/keywords.def
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+  // opcode keywords
+#define OPCODE(X, Y, Z, S) KEYWORD(X)
+#include "opcodes.def"
+#undef OPCODE
+  // primitive types
+#define LOAD_ALGO_PRIMARY_TYPE
+#define PRIMTYPE(P) KEYWORD(P)
+#include "prim_types.def"
+#undef PRIMTYPE
+  // intrinsic names
+#undef DEF_MIR_INTRINSIC
+#define DEF_MIR_INTRINSIC(X, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ...)  KEYWORD(X)
+#include "intrinsics.def"
+#undef DEF_MIR_INTRINSIC
+  KEYWORD(else)
+  // declaration keywords
+  KEYWORD(var)
+  KEYWORD(tempvar)
+  KEYWORD(reg)
+  KEYWORD(type)
+  KEYWORD(func)
+  KEYWORD(struct)
+  KEYWORD(structincomplete)
+  KEYWORD(union)
+  KEYWORD(class)
+  KEYWORD(classincomplete)
+  KEYWORD(interfaceincomplete)
+  KEYWORD(javaclass)
+  KEYWORD(javainterface)
+  // type attribute keywords
+#define FUNC_ATTR
+#define TYPE_ATTR
+#define FIELD_ATTR
+#define ATTR(X) KEYWORD(X)
+#include "all_attributes.def"
+#undef ATTR
+#undef FUNC_ATTR
+#undef TYPE_ATTR
+#undef FIELD_ATTR
+  KEYWORD(align)
+  // per-function declaration keywords
+  KEYWORD(framesize)
+  KEYWORD(upformalsize)
+  KEYWORD(moduleid)
+  KEYWORD(funcsize)
+  KEYWORD(funcid)
+  KEYWORD(formalwordstypetagged)
+  KEYWORD(localwordstypetagged)
+  KEYWORD(formalwordsrefcounted)
+  KEYWORD(localwordsrefcounted)
+  // per-module declaration keywords
+  KEYWORD(flavor)
+  KEYWORD(srclang)
+  KEYWORD(globalmemsize)
+  KEYWORD(globalmemmap)
+  KEYWORD(globalwordstypetagged)
+  KEYWORD(globalwordsrefcounted)
+  KEYWORD(id)
+  KEYWORD(numfuncs)
+  KEYWORD(entryfunc)
+  // file related declaration keywords
+  KEYWORD(fileinfo)
+  KEYWORD(filedata)
+  KEYWORD(srcfileinfo)
+  KEYWORD(funcinfo)
+  // special float constants
+  KEYWORD(nanf)
+  KEYWORD(nan)
+  KEYWORD(inff)
+  KEYWORD(inf)
+  // pragma
+  KEYWORD(pragma)
+  KEYWORD(param)
+  KEYWORD(func_ex)
+  KEYWORD(func_var)
+  // staticvalue
+  KEYWORD(staticvalue)
+  // import
+  KEYWORD(import)
+  KEYWORD(importpath)
+  // source position information
+  KEYWORD(LOC)
+  // dwarf related
+  KEYWORD(SCOPE)
+  KEYWORD(ALIAS)
+  KEYWORD(ENUMERATION)
+  KEYWORD(TYPEALIAS)
+  // storage class
+  KEYWORD(pstatic)
+  KEYWORD(fstatic)
+  // file-scope asm
+  KEYWORD(asmdecl)
diff --git a/src/mapleall/maple_ir/include/lexer.h b/src/mapleall/maple_ir/include/lexer.h
new file mode 100644
index 0000000000000000000000000000000000000000..0752b34c558d66c1a0a5042b92825d7c9085d223
--- /dev/null
+++ b/src/mapleall/maple_ir/include/lexer.h
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_LEXER_H
+#define MAPLE_IR_INCLUDE_LEXER_H
+#include <fstream>
+#include "cstdio"
+#include "types_def.h"
+#include "tokens.h"
+#include "mempool_allocator.h"
+#include "mir_module.h"
+
+namespace maple {
+class MIRParser;  // circular dependency exists, no other choice
+class MIRLexer {
+  friend MIRParser;
+
+ public:
+  explicit MIRLexer(MIRModule &mod);
+  ~MIRLexer() {
+    airFile = nullptr;
+    if (airFileInternal.is_open()) {
+      airFileInternal.close();
+    }
+  }
+
+  void PrepareForFile(const std::string &filename);
+  void PrepareForString(const std::string &src);
+  TokenKind NextToken();
+  TokenKind LexToken();
+  TokenKind GetTokenKind() const {
+    return kind;
+  }
+
+  uint32 GetLineNum() const {
+    return lineNum;
+  }
+
+  uint32 GetCurIdx() const {
+    return curIdx;
+  }
+
+  // get the identifier name after the % or $ prefix
+  const std::string &GetName() const {
+    return name;
+  }
+
+  uint64 GetTheIntVal() const {
+    return theIntVal;
+  }
+
+  float GetTheFloatVal() const {
+    return theFloatVal;
+  }
+
+  double GetTheDoubleVal() const {
+    return theDoubleVal;
+  }
+
+  std::string GetTokenString() const;  // for error reporting purpose
+
+ private:
+  MIRModule &module;
+  // for storing the different types of constant values
+  uint64 theIntVal = 0;  // also indicates preg number under TK_preg
+  float theFloatVal = 0.0;
+  double theDoubleVal = 0.0;
+  MapleVector<std::string> seenComments;
+  std::ifstream *airFile = nullptr;
+  std::ifstream airFileInternal;
+  std::string line;
+  size_t lineBufSize = 0;  // the allocated size of line(buffer).
+  uint32 currentLineSize = 0;
+  uint32 curIdx = 0;
+  uint32 lineNum = 0;
+  TokenKind kind = TK_invalid;
+  std::string name = "";  // store the name token without the % or $ prefix
+  MapleUnorderedMap<std::string, TokenKind> keywordMap;
+
+  void RemoveReturnInline(std::string &removeLine) const {
+    if (removeLine.empty()) {
+      return;
+    }
+    if (removeLine.back() == '\n') {
+      removeLine.pop_back();
+    }
+    if (removeLine.back() == '\r') {
+      removeLine.pop_back();
+    }
+  }
+
+  int ReadALine();  // read a line from MIR (text) file.
+  void GenName();
+  TokenKind GetConstVal();
+  TokenKind GetSpecialFloatConst();
+  TokenKind GetHexConst(uint32 valStart, bool negative);
+  TokenKind GetIntConst(uint32 valStart, bool negative);
+  TokenKind GetFloatConst(uint32 valStart, uint32 startIdx, bool negative);
+  TokenKind GetSpecialTokenUsingOneCharacter(char c);
+  TokenKind GetTokenWithPrefixDollar();
+  TokenKind GetTokenWithPrefixPercent();
+  TokenKind GetTokenWithPrefixAmpersand();
+  TokenKind GetTokenWithPrefixAtOrCircumflex(char prefix);
+  TokenKind GetTokenWithPrefixExclamation();
+  TokenKind GetTokenWithPrefixQuotation();
+  TokenKind GetTokenWithPrefixDoubleQuotation();
+  TokenKind GetTokenSpecial();
+
+  char GetCharAt(uint32 idx) const {
+    return line[idx];
+  }
+
+  char GetCharAtWithUpperCheck(uint32 idx) const {
+    return idx < currentLineSize ? line[idx] : 0;
+  }
+
+  char GetCharAtWithLowerCheck(uint32 idx) const {
+    return idx >= 0 ? line[idx] : 0;
+  }
+
+  char GetCurrentCharWithUpperCheck() {
+    return curIdx < currentLineSize ? line[curIdx] : 0;
+  }
+
+  char GetNextCurrentCharWithUpperCheck() {
+    ++curIdx;
+    return curIdx < currentLineSize ? line[curIdx] : 0;
+  }
+
+  void SetFile(std::ifstream &file) {
+    airFile = &file;
+  }
+
+  std::ifstream *GetFile() const {
+    return airFile;
+  }
+};
+
+inline bool IsPrimitiveType(TokenKind tk) {
+  return (tk >= TK_void) && (tk < TK_unknown);
+}
+
+inline bool IsVarName(TokenKind tk) {
+  return (tk == TK_lname) || (tk == TK_gname);
+}
+
+inline bool IsExprBinary(TokenKind tk) {
+  return (tk >= TK_add) && (tk <= TK_sub);
+}
+
+inline bool IsConstValue(TokenKind tk) {
+  return (tk >= TK_intconst) && (tk <= TK_doubleconst);
+}
+
+inline bool IsConstAddrExpr(TokenKind tk) {
+  return (tk == TK_addrof) || (tk == TK_addroffunc) || (tk == TK_addroflabel) ||
+         (tk == TK_conststr) || (tk == TK_conststr16);
+}
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_LEXER_H
diff --git a/src/mapleall/maple_ir/include/memory_order_attrs.def b/src/mapleall/maple_ir/include/memory_order_attrs.def
new file mode 100644
index 0000000000000000000000000000000000000000..e7a241ad03b3c953400f2d9bebc97c690b9cba50
--- /dev/null
+++ b/src/mapleall/maple_ir/include/memory_order_attrs.def
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+  ATTR(memory_order_relaxed)
+  ATTR(memory_order_consume)
+  ATTR(memory_order_acquire)
+  ATTR(memory_order_release)
+  ATTR(memory_order_acq_rel)
+  ATTR(memory_order_seq_cst)
diff --git a/src/mapleall/maple_ir/include/metadata_layout.h b/src/mapleall/maple_ir/include/metadata_layout.h
new file mode 100644
index 0000000000000000000000000000000000000000..86b975177a1a4d1174f28ac721e4783d70d274a7
--- /dev/null
+++ b/src/mapleall/maple_ir/include/metadata_layout.h
@@ -0,0 +1,352 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef METADATA_LAYOUT_H
+#define METADATA_LAYOUT_H
+#include <cstdlib>
+
+// metadata layout is shared between maple compiler and runtime, thus not in namespace maplert
+// some of the reference field of metadata is stored as relative offset
+// for example, declaring class of Fields/Methods
+// which can be negative
+#ifdef USE_32BIT_REF
+using MetaRef = uint32_t;      // consistent with reffield_t in address.h
+#else
+using MetaRef = uintptr_t;     // consistent iwth reffield_t in address.h
+#endif // USE_32BIT_REF
+
+// DataRefOffset aims to represent a reference to data in maple file, which is already an offset.
+// DataRefOffset is meant to have pointer size.
+// All Xx32 data types defined in this file aim to use 32 bits to save 64-bit address, and thus are
+// specific for 64-bit platforms.
+struct DataRefOffset32 {
+  int32_t refOffset;
+  template<typename T>
+  inline void SetDataRef(T ref);
+  template<typename T>
+  inline T GetDataRef() const;
+  inline int32_t GetRawValue() const;
+  inline void SetRawValue(int32_t value);
+};
+
+struct DataRefOffsetPtr {
+  intptr_t refOffset;
+  template<typename T>
+  inline void SetDataRef(T ref);
+  template<typename T>
+  inline T GetDataRef() const;
+  inline intptr_t GetRawValue() const;
+  inline void SetRawValue(intptr_t value);
+};
+
+struct DataRefOffset {
+#ifdef USE_32BIT_REF
+  DataRefOffset32 refOffset;
+#else
+  DataRefOffsetPtr refOffset;
+#endif
+  template<typename T>
+  inline void SetDataRef(T ref);
+  template<typename T>
+  inline T GetDataRef() const;
+  inline intptr_t GetRawValue() const;
+  inline void SetRawValue(intptr_t value);
+};
+
+struct MethodFieldRef {
+  // MethodFieldRef aims to represent a reference to fields/methods in maple file, which is already an offset.
+  // also, offset LSB may set 1, to indicate that it is compact fields/methods.
+  enum MethodFieldRefFormat {
+    kMethodFieldRefIsCompact = 1,
+  };
+  DataRefOffsetPtr refOffset;
+  template<typename T>
+  inline void SetDataRef(T ref);
+  template<typename T>
+  inline T GetDataRef() const;
+  inline bool IsCompact() const;
+  template<typename T>
+  inline T GetCompactData() const;
+  inline intptr_t GetRawValue() const;
+  inline void SetRawValue(intptr_t value);
+};
+
+// DataRef aims for reference to data in maple file (generated by maple compiler) and is aligned to at least 4 bytes.
+// Perhaps MDataRef is more fit, still DataRef is chosen to make it common.
+// DataRef allows 4 formats of value:
+// 0. "label_name" for direct reference
+// 1. "label_name - . + 1" for padding unused
+// 2. "label_name - . + 2" for reference in offset format
+// 3. "indirect.label_name - . + 3" for indirect reference
+//    this format aims to support lld which does not support expression "global_symbol - ."
+// DataRef is self-decoded by also encoding the format and is defined for binary compatibility.
+// If no compatibility problem is involved, DataRefOffsetPtr is preferred.
+enum DataRefFormat {
+  kDataRefIsDirect   = 0, // must be 0
+  kDataRefPadding    = 1, // unused
+  kDataRefIsOffset   = 2,
+  kDataRefIsIndirect = 3, // read-only
+  kDataRefBitMask    = 3,
+};
+
+struct DataRef32 {
+  // be careful when *refVal* is treated as an offset which is a signed integer actually.
+  uint32_t refVal;
+  template<typename T>
+  inline T GetDataRef() const;
+  template<typename T>
+  inline void SetDataRef(T ref, DataRefFormat format = kDataRefIsDirect);
+  template<typename T>
+  inline T GetRawValue() const;
+};
+
+struct DataRef {
+  uintptr_t refVal;
+  template<typename T>
+  inline T GetDataRef() const;
+  template<typename T>
+  inline void SetDataRef(const T ref, const DataRefFormat format = kDataRefIsDirect);
+  template<typename T>
+  inline T GetRawValue() const;
+};
+// GctibRef aims to represent a reference to gctib in maple file, which is an offset by default.
+// GctibRef is meant to have pointer size and aligned to at least 4 bytes.
+// GctibRef allows 2 formats of value:
+// 0. "label_name - . + 0" for reference in offset format
+// 1. "indirect.label_name - . + 1" for indirect reference
+//    this format aims to support lld which does not support expression "global_symbol - ."
+// GctibRef is self-decoded by also encoding the format and is defined for binary compatibility.
+// If no compatibility problem is involved, DataRef is preferred.
+enum GctibRefFormat {
+  kGctibRefIsOffset = 0, // default
+  kGctibRefIsIndirect = 1,
+  kGctibRefBitMask = 3
+};
+
+struct GctibRef32 {
+  // be careful when *refVal* is treated as an offset which is a signed integer actually.
+  uint32_t refVal;
+  template<typename T>
+  inline T GetGctibRef() const;
+  template<typename T>
+  inline void SetGctibRef(T ref, GctibRefFormat format = kGctibRefIsOffset);
+};
+
+struct GctibRef {
+  uintptr_t refVal;
+  template<typename T>
+  inline T GetGctibRef() const;
+  template<typename T>
+  inline void SetGctibRef(const T ref, const GctibRefFormat format = kGctibRefIsOffset);
+};
+
+// MByteRef is meant to represent a reference to data defined in maple file. It is a direct reference or an offset.
+// MByteRef is self-encoded/decoded and aligned to 1 byte.
+// Unlike DataRef, the format of MByteRef is determined by its value.
+struct MByteRef {
+  uintptr_t refVal; // initializer prefers this field to be a pointer
+
+#if defined(__arm__) || defined(USE_ARM32_MACRO)
+  // assume address range 0 ~ 256MB is unused in arm runtime
+  // kEncodedOffsetMin ~ kEncodedOffsetMax is the value range of encoded offset
+  static constexpr intptr_t kOffsetBound = 128 * 1024 * 1024;
+  static constexpr intptr_t kOffsetMin = -kOffsetBound;
+  static constexpr intptr_t kOffsetMax = kOffsetBound;
+
+  static constexpr intptr_t kPositiveOffsetBias = 128 * 1024 * 1024;
+  static constexpr intptr_t kEncodedOffsetMin = kPositiveOffsetBias + kOffsetMin;
+  static constexpr intptr_t kEncodedOffsetMax = kPositiveOffsetBias + kOffsetMax;
+#else
+  enum {
+    kBiasBitPosition = sizeof(refVal) * 8 - 4, // the most significant 4 bits
+  };
+
+  static constexpr uintptr_t kOffsetBound = 256 * 1024 * 1024; // according to kDsoLoadedAddessEnd = 0xF0000000
+  static constexpr uintptr_t kPositiveOffsetMin = 0;
+  static constexpr uintptr_t kPositiveOffsetMax = kOffsetBound;
+
+  static constexpr uintptr_t kPositiveOffsetBias = static_cast<uintptr_t>(6) << kBiasBitPosition;
+  static constexpr uintptr_t kEncodedPosOffsetMin = kPositiveOffsetMin + kPositiveOffsetBias;
+  static constexpr uintptr_t kEncodedPosOffsetMax = kPositiveOffsetMax + kPositiveOffsetBias;
+#endif
+
+  template<typename T>
+  inline T GetRef() const;
+  template<typename T>
+  inline void SetRef(const T ref);
+  inline bool IsOffset() const;
+};
+
+struct MByteRef32 {
+  uint32_t refVal;
+  static constexpr uint32_t kOffsetBound = 256 * 1024 * 1024; // according to kDsoLoadedAddessEnd = 0xF0000000
+  static constexpr uint32_t kPositiveOffsetMin = 0;
+  static constexpr uint32_t kPositiveOffsetMax = kOffsetBound;
+
+  static constexpr uint32_t kPositiveOffsetBias = 0x60000000; // the most significant 4 bits 0110
+  static constexpr uint32_t kEncodedPosOffsetMin = kPositiveOffsetMin + kPositiveOffsetBias;
+  static constexpr uint32_t kEncodedPosOffsetMax = kPositiveOffsetMax + kPositiveOffsetBias;
+
+  static constexpr uint32_t kDirectRefMin = 0xC0000000; // according to kDsoLoadedAddessStart = 0xC0000000
+  static constexpr uint32_t kDirectRefMax = 0xF0000000; // according to kDsoLoadedAddessEnd = 0xF0000000
+
+  static constexpr int32_t kNegativeOffsetMin = -(256 * 1024 * 1024); // -kOffsetBound
+  static constexpr int32_t kNegativeOffsetMax = 0;
+
+  template<typename T>
+  inline T GetRef() const;
+  template<typename T>
+  inline void SetRef(T ref);
+  inline bool IsOffset() const;
+  inline bool IsPositiveOffset() const;
+  inline bool IsNegativeOffset() const;
+};
+
+// MethodMeta defined in methodmeta.h
+// FieldMeta  defined in fieldmeta.h
+// MethodDesc contains MethodMetadata and stack map
+struct MethodDesc {
+  // relative offset for method metadata relative to current PC.
+  // method metadata is in compact format if this offset is odd.
+  uint32_t metadataOffset;
+
+  int16_t localRefOffset;
+  uint16_t localRefNumber;
+
+  // stack map for a methed might be placed here
+};
+
+// Note: class init in maplebe and cg is highly dependent on this type.
+// update aarch64rtsupport.h if you modify this definition.
+struct ClassMetadataRO {
+  MByteRef className;
+  MethodFieldRef fields;  // point to info of fields
+  MethodFieldRef methods; // point to info of methods
+  union {  // Element classinfo of array, others parent classinfo
+    DataRef superclass;
+    DataRef componentClass;
+  };
+
+  uint16_t numOfFields;
+  uint16_t numOfMethods;
+
+#ifndef USE_32BIT_REF
+  uint16_t flag;
+  uint16_t numOfSuperclasses;
+  uint32_t padding;
+#endif // !USE_32BIT_REF
+
+  uint32_t mod;
+  DataRefOffset32 annotation;
+  DataRefOffset32 clinitAddr;
+};
+
+static constexpr size_t kPageSize = 4096;
+static constexpr size_t kCacheLine = 64;
+
+// according to kSpaceAnchor and kFireBreak defined in bp_allocator.cpp
+// the address of this readable page is set as kProtectedMemoryStart for java class
+static constexpr uintptr_t kClInitStateAddrBase = 0xc0000000 - (1u << 20) * 2;
+
+// In Kirin 980, 2 mmap memory address with odd number of page distances may have unreasonable L1&L2 cache conflict.
+// kClassInitializedState is used as the init state for class that has no <clinit> method, it's will be loaded in many
+// place for Decouple build App. if we set the value to kClInitStateAddrBase(0xbfe00000), it may conflict with the
+// yieldpoind test address globalPollingPage which is defined in yieldpoint.cpp.
+// Hence we add 1 cache line (64 byte) offset here to avoid such conflict
+static constexpr uintptr_t kClassInitializedState = kClInitStateAddrBase + kCacheLine;
+
+extern "C" uint8_t classInitProtectRegion[];
+
+// Note there is no state to indicate a class is already initialized.
+// Any state beyond listed below is treated as initialized.
+enum ClassInitState {
+  kClassInitStateMin = 0,
+  kClassUninitialized = 1,
+  kClassInitializing = 2,
+  kClassInitFailed = 3,
+  kClassInitialized = 4,
+  kClassInitStateMax = 4,
+};
+
+enum SEGVAddr {
+  kSEGVAddrRangeStart = kPageSize + 0,
+
+  // Note any readable address is treated as Initialized.
+  kSEGVAddrForClassInitStateMin = kSEGVAddrRangeStart + kClassInitStateMin,
+  kSEGVAddrForClassUninitialized = kSEGVAddrForClassInitStateMin + kClassUninitialized,
+  kSEGVAddrForClassInitializing = kSEGVAddrForClassInitStateMin + kClassInitializing,
+  kSEGVAddrForClassInitFailed = kSEGVAddrForClassInitStateMin + kClassInitFailed,
+  kSEGVAddrFoClassInitStateMax  = kSEGVAddrForClassInitStateMin + kClassInitStateMax,
+
+  kSEGVAddrRangeEnd,
+};
+
+struct ClassMetadata {
+  // object common fields
+  MetaRef shadow;  // point to classinfo of java/lang/Class
+  int32_t monitor;
+
+  // other fields
+  uint16_t clIndex; // 8bit ClassLoader index, used for querying the address of related ClassLoader instance.
+  union {
+    uint16_t objSize;
+    uint16_t componentSize;
+  } sizeInfo;
+
+#ifdef USE_32BIT_REF // for alignment purpose
+  uint16_t flag;
+  uint16_t numOfSuperclasses;
+#endif // USE_32BIT_REF
+
+  DataRef iTable;  // iTable of current class, used for interface call, will insert the content into classinfo
+  DataRef vTable;  // vTable of current class, used for virtual call, will insert the content into classinfo
+  GctibRef gctib;  // for rc
+
+#ifdef USE_32BIT_REF
+  DataRef32 classInfoRo;
+  DataRef32 cacheFalseClass;
+#else
+  DataRef classInfoRo;
+#endif
+
+  union {
+    uintptr_t initState; // a readable address for initState means initialized
+    DataRef cacheTrueClass;
+  };
+
+ public:
+  static inline intptr_t OffsetOfInitState() {
+    ClassMetadata *base = nullptr;
+    return reinterpret_cast<intptr_t>(&(base->initState));
+  }
+
+  uintptr_t GetInitStateRawValue() const {
+    return __atomic_load_n(&initState, __ATOMIC_ACQUIRE);
+  }
+
+  template<typename T>
+  void SetInitStateRawValue(T val) {
+    __atomic_store_n(&initState, reinterpret_cast<uintptr_t>(val), __ATOMIC_RELEASE);
+  }
+};
+
+// function to set Class/Field/Method metadata's shadow field to avoid type conversion
+// Note 1: here we don't do NULL-check and type-compatibility check
+// NOte 2: C should be of jclass/ClassMetata* type
+template<typename M, typename C>
+static inline void MRTSetMetadataShadow(M *meta, C cls) {
+  meta->shadow = static_cast<MetaRef>(reinterpret_cast<uintptr_t>(cls));
+}
+
+#endif // METADATA_LAYOUT_H
diff --git a/src/mapleall/maple_ir/include/mir_builder.h b/src/mapleall/maple_ir/include/mir_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..5fa1c63502ec240651f6a8a446c7d9816ba521e7
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_builder.h
@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_BUILDER_H
+#define MAPLE_IR_INCLUDE_MIR_BUILDER_H
+#include <string>
+#include <utility>
+#include <vector>
+#include <map>
+#ifdef _WIN32
+#include <pthread.h>
+#endif
+#include "opcodes.h"
+#include "prim_types.h"
+#include "mir_type.h"
+#include "mir_const.h"
+#include "mir_symbol.h"
+#include "mir_nodes.h"
+#include "mir_module.h"
+#include "mir_preg.h"
+#include "mir_function.h"
+#include "printing.h"
+#include "intrinsic_op.h"
+#include "opcode_info.h"
+#include "global_tables.h"
+
+namespace maple {
+using ArgPair = std::pair<std::string, MIRType*>;
+using ArgVector = MapleVector<ArgPair>;
+class MIRBuilder {
+ public:
+  enum MatchStyle {
+    kUpdateFieldID = 0,  // do not match but traverse to update fieldID
+    kMatchTopField = 1,  // match top level field only
+    kMatchAnyField = 2,  // match any field
+    kParentFirst = 4,    // traverse parent first
+    kFoundInChild = 8,   // found in child
+  };
+
+  explicit MIRBuilder(MIRModule *module)
+      : mirModule(module),
+        incompleteTypeRefedSet(mirModule->GetMPAllocator().Adapter()) {}
+
+  virtual ~MIRBuilder() = default;
+
+  virtual void SetCurrentFunction(MIRFunction &fun) {
+    mirModule->SetCurFunction(&fun);
+  }
+
+  virtual MIRFunction *GetCurrentFunction() const {
+    return mirModule->CurFunction();
+  }
+  MIRFunction *GetCurrentFunctionNotNull() const {
+    MIRFunction *func = GetCurrentFunction();
+    CHECK_FATAL(func != nullptr, "nullptr check");
+    return func;
+  }
+
+  MIRModule &GetMirModule() const {
+    return *mirModule;
+  }
+
+  const MapleSet<TyIdx> &GetIncompleteTypeRefedSet() const {
+    return incompleteTypeRefedSet;
+  }
+
+  std::vector<std::tuple<uint32, uint32, uint32, uint32>> &GetExtraFieldsTuples() {
+    return extraFieldsTuples;
+  }
+
+  unsigned int GetLineNum() const {
+    return lineNum;
+  }
+  void SetLineNum(unsigned int num) {
+    lineNum = num;
+  }
+
+  GStrIdx GetOrCreateStringIndex(const std::string &str) const {
+    return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
+  }
+
+  GStrIdx GetOrCreateStringIndex(GStrIdx strIdx, const std::string &str) const {
+    std::string firstString(GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx));
+    firstString.append(str);
+    return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(firstString);
+  }
+
+  GStrIdx GetStringIndex(const std::string &str) const {
+    return GlobalTables::GetStrTable().GetStrIdxFromName(str);
+  }
+
+  MIRFunction *GetOrCreateFunction(const std::string &str, TyIdx retTyIdx);
+  MIRFunction *GetFunctionFromSymbol(const MIRSymbol &funcSymbol) const;
+  MIRFunction *GetFunctionFromStidx(StIdx stIdx);
+  MIRFunction *GetFunctionFromName(const std::string &str);
+  // For compiler-generated metadata struct
+  void AddIntFieldConst(const MIRStructType &sType, MIRAggConst &newConst, uint32 fieldID, int64 constValue) const;
+  void AddAddrofFieldConst(const MIRStructType &structType, MIRAggConst &newConst, uint32 fieldID,
+                           const MIRSymbol &fieldSymbol);
+  void AddAddroffuncFieldConst(const MIRStructType &structType, MIRAggConst &newConst, uint32 fieldID,
+                               const MIRSymbol &funcSymbol);
+
+  bool TraverseToNamedField(MIRStructType &structType, GStrIdx nameIdx, uint32 &fieldID);
+  bool TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx,
+                                                 uint32 &fieldID, unsigned int matchStyle);
+  void TraverseToNamedFieldWithType(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx, uint32 &fieldID,
+                                    uint32 &idx);
+
+  FieldID GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx, unsigned int matchStyle);
+  FieldID GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx);
+  FieldID GetStructFieldIDFromNameAndTypeParentFirst(MIRType &type, const std::string &name, TyIdx idx);
+  FieldID GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(MIRType &type, const std::string &name, TyIdx idx);
+
+  FieldID GetStructFieldIDFromFieldName(MIRType &type, const std::string &name);
+  FieldID GetStructFieldIDFromFieldNameParentFirst(MIRType *type, const std::string &name);
+
+  void SetStructFieldIDFromFieldName(MIRStructType &structType, const std::string &name, GStrIdx newStrIdx,
+                                     const MIRType &newFieldType) const;
+  // for creating Function.
+  MIRSymbol *GetFunctionArgument(MIRFunction &fun, uint32 index) const {
+    CHECK(index < fun.GetFormalCount(), "index out of range in GetFunctionArgument");
+    return fun.GetFormal(index);
+  }
+
+  MIRFunction *CreateFunction(const std::string &name, const MIRType &returnType, const ArgVector &arguments,
+                              bool isVarg = false, bool createBody = true) const;
+  MIRFunction *CreateFunction(StIdx stIdx, bool addToTable = true) const;
+  virtual void UpdateFunction(MIRFunction&, const MIRType*, const ArgVector&) {}
+
+  MIRSymbol *GetSymbolFromEnclosingScope(StIdx stIdx) const;
+  virtual MIRSymbol *GetOrCreateLocalDecl(const std::string &str, const MIRType &type);
+  MIRSymbol *GetLocalDecl(const std::string &str) const;
+  MIRSymbol *CreateLocalDecl(const std::string &str, const MIRType &type) const;
+  MIRSymbol *GetOrCreateGlobalDecl(const std::string &str, const MIRType &type) const;
+  MIRSymbol *GetGlobalDecl(const std::string &str) const;
+  MIRSymbol *GetDecl(const std::string &str) const;
+  MIRSymbol *CreateGlobalDecl(const std::string &str,
+                              const MIRType &type,
+                              MIRStorageClass sc = kScGlobal) const;
+  MIRSymbol *GetOrCreateDeclInFunc(const std::string &str, const MIRType &type, MIRFunction &func) const;
+  // for creating Expression
+  ConstvalNode *CreateConstval(MIRConst *mirConst);
+  ConstvalNode *CreateIntConst(uint64 val, PrimType pty);
+  ConstvalNode *CreateFloatConst(float val);
+  ConstvalNode *CreateDoubleConst(double val);
+  ConstvalNode *CreateFloat128Const(const uint64 *val);
+  ConstvalNode *GetConstInt(MemPool &memPool, int val) const;
+  ConstvalNode *GetConstInt(int val) {
+    return CreateIntConst(static_cast<uint64_t>(static_cast<int64_t>(val)), PTY_i32);
+  }
+
+  ConstvalNode *GetConstUInt1(bool val) {
+    return CreateIntConst(val, PTY_u1);
+  }
+
+  ConstvalNode *GetConstUInt8(uint8 val) {
+    return CreateIntConst(val, PTY_u8);
+  }
+
+  ConstvalNode *GetConstUInt16(uint16 val) {
+    return CreateIntConst(val, PTY_u16);
+  }
+
+  ConstvalNode *GetConstUInt32(uint32 val) {
+    return CreateIntConst(val, PTY_u32);
+  }
+
+  ConstvalNode *GetConstUInt64(uint64 val) {
+    return CreateIntConst(val, PTY_u64);
+  }
+
+  ConstvalNode *CreateAddrofConst(BaseNode &node);
+  ConstvalNode *CreateAddroffuncConst(const BaseNode &node);
+  ConstvalNode *CreateStrConst(const BaseNode &node);
+  ConstvalNode *CreateStr16Const(const BaseNode &node);
+  SizeoftypeNode *CreateExprSizeoftype(const MIRType &type);
+  FieldsDistNode *CreateExprFieldsDist(const MIRType &type, FieldID field1, FieldID field2);
+  AddrofNode *CreateExprAddrof(FieldID fieldID, const MIRSymbol &symbol, MemPool *memPool = nullptr);
+  AddrofNode *CreateExprAddrof(FieldID fieldID, StIdx symbolStIdx, MemPool *memPool = nullptr);
+  AddroffuncNode *CreateExprAddroffunc(PUIdx puIdx, MemPool *memPool = nullptr);
+  AddrofNode *CreateExprDread(const MIRType &type, FieldID fieldID, const MIRSymbol &symbol);
+  AddrofNode *CreateExprDread(PrimType ptyp, FieldID fieldID, const MIRSymbol &symbol);
+  virtual AddrofNode *CreateExprDread(MIRType &type, MIRSymbol &symbol);
+  virtual AddrofNode *CreateExprDread(MIRSymbol &symbol);
+  AddrofNode *CreateExprDread(PregIdx pregID, PrimType pty);
+  AddrofNode *CreateExprDread(MIRSymbol &symbol, uint16 fieldID);
+  DreadoffNode *CreateExprDreadoff(Opcode op, PrimType pty, const MIRSymbol &symbol, int32 offset);
+  RegreadNode *CreateExprRegread(PrimType pty, PregIdx regIdx);
+  IreadNode *CreateExprIread(PrimType primType, TyIdx ptrTypeIdx, FieldID fieldID, BaseNode *addr);
+  IreadNode *CreateExprIread(const MIRType &returnType, const MIRType &ptrType, FieldID fieldID, BaseNode *addr);
+  IreadoffNode *CreateExprIreadoff(PrimType pty, int32 offset, BaseNode *opnd0);
+  IreadFPoffNode *CreateExprIreadFPoff(PrimType pty, int32 offset);
+  IaddrofNode *CreateExprIaddrof(const MIRType &returnType, const MIRType &ptrType, FieldID fieldID, BaseNode *addr);
+  IaddrofNode *CreateExprIaddrof(PrimType returnTypePty, TyIdx ptrTypeIdx, FieldID fieldID, BaseNode *addr);
+  BinaryNode *CreateExprBinary(Opcode opcode, const MIRType &type, BaseNode *opnd0, BaseNode *opnd1);
+  BinaryNode *CreateExprBinary(Opcode opcode, PrimType pty, BaseNode *opnd0, BaseNode *opnd1) {
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(pty));
+    return CreateExprBinary(opcode, *ty, opnd0, opnd1);
+  }
+  TernaryNode *CreateExprTernary(Opcode opcode, const MIRType &type, BaseNode *opnd0, BaseNode *opnd1, BaseNode *opnd2);
+  CompareNode *CreateExprCompare(Opcode opcode, const MIRType &type, const MIRType &opndType, BaseNode *opnd0,
+                                 BaseNode *opnd1);
+  UnaryNode *CreateExprUnary(Opcode opcode, const MIRType &type, BaseNode *opnd);
+  GCMallocNode *CreateExprGCMalloc(Opcode opcode, const MIRType &pType, const MIRType &type);
+  JarrayMallocNode *CreateExprJarrayMalloc(Opcode opcode, const MIRType &pType, const MIRType &type, BaseNode *opnd);
+  TypeCvtNode *CreateExprTypeCvt(Opcode o, PrimType toPrimType, PrimType fromPrimType, BaseNode &opnd);
+  TypeCvtNode *CreateExprTypeCvt(Opcode o, const MIRType &type, const MIRType &fromType, BaseNode *opnd);
+  ExtractbitsNode *CreateExprExtractbits(Opcode o, const MIRType &type, uint32 bOffset, uint32 bSize, BaseNode *opnd);
+  ExtractbitsNode *CreateExprExtractbits(Opcode o, PrimType type, uint32 bOffset, uint32 bSize, BaseNode *opnd);
+  DepositbitsNode *CreateExprDepositbits(Opcode o, PrimType type, uint32 bOffset, uint32 bSize,
+                                         BaseNode *leftOpnd, BaseNode* rightOpnd);
+  RetypeNode *CreateExprRetype(const MIRType &type, const MIRType &fromType, BaseNode *opnd);
+  RetypeNode *CreateExprRetype(const MIRType &type, PrimType fromType, BaseNode *opnd);
+  ArrayNode *CreateExprArray(const MIRType &arrayType);
+  ArrayNode *CreateExprArray(const MIRType &arrayType, BaseNode *op);
+  ArrayNode *CreateExprArray(const MIRType &arrayType, BaseNode *op1, BaseNode *op2);
+  ArrayNode *CreateExprArray(const MIRType &arrayType, std::vector<BaseNode *> ops);
+  IntrinsicopNode *CreateExprIntrinsicop(MIRIntrinsicID id, Opcode op, PrimType primType, const TyIdx &tyIdx,
+                                         const MapleVector<BaseNode*> &ops);
+  IntrinsicopNode *CreateExprIntrinsicop(MIRIntrinsicID idx, Opcode opCode, const MIRType &type,
+                                         const MapleVector<BaseNode*> &ops);
+  // for creating Statement.
+  NaryStmtNode *CreateStmtReturn(BaseNode *rVal);
+  NaryStmtNode *CreateStmtNary(Opcode op, BaseNode *rVal);
+  NaryStmtNode *CreateStmtNary(Opcode op, const MapleVector<BaseNode*> &rVals);
+  AssertNonnullStmtNode *CreateStmtAssertNonnull(Opcode op, BaseNode *rVal, GStrIdx funcNameIdx);
+  CallAssertNonnullStmtNode *CreateStmtCallAssertNonnull(Opcode op, BaseNode *rVal, GStrIdx callFuncNameIdx,
+                                                         size_t paramIndex, GStrIdx stmtFuncNameIdx);
+  CallAssertBoundaryStmtNode *CreateStmtCallAssertBoundary(Opcode op, const MapleVector<BaseNode*> &rVals,
+                                                           GStrIdx funcNameIdx, size_t paramIndex,
+                                                           GStrIdx stmtFuncNameIdx);
+  AssertBoundaryStmtNode *CreateStmtAssertBoundary(Opcode op, const MapleVector<BaseNode*> &rVals, GStrIdx funcNameIdx);
+  UnaryStmtNode *CreateStmtUnary(Opcode op, BaseNode *rVal);
+  UnaryStmtNode *CreateStmtThrow(BaseNode *rVal);
+  DassignNode *CreateStmtDassign(const MIRSymbol &symbol, FieldID fieldID, BaseNode *src);
+  DassignNode *CreateStmtDassign(StIdx sIdx, FieldID fieldID, BaseNode *src);
+  RegassignNode *CreateStmtRegassign(PrimType pty, PregIdx regIdx, BaseNode *src);
+  IassignNode *CreateStmtIassign(const MIRType &type, FieldID fieldID, BaseNode *addr, BaseNode *src);
+  IassignoffNode *CreateStmtIassignoff(PrimType pty, int32 offset, BaseNode *addr, BaseNode *src);
+  IassignFPoffNode *CreateStmtIassignFPoff(Opcode op, PrimType pty, int32 offset, BaseNode *src);
+  CallNode *CreateStmtCall(PUIdx puIdx, const MapleVector<BaseNode*> &args, Opcode opCode = OP_call);
+  CallNode *CreateStmtCall(const std::string &callee, const MapleVector<BaseNode*> &args);
+  CallNode *CreateStmtVirtualCall(PUIdx puIdx, const MapleVector<BaseNode*> &args) {
+    return CreateStmtCall(puIdx, args, OP_virtualcall);
+  }
+
+  CallNode *CreateStmtSuperclassCall(PUIdx puIdx, const MapleVector<BaseNode*> &args) {
+    return CreateStmtCall(puIdx, args, OP_superclasscall);
+  }
+
+  CallNode *CreateStmtInterfaceCall(PUIdx puIdx, const MapleVector<BaseNode*> &args) {
+    return CreateStmtCall(puIdx, args, OP_interfacecall);
+  }
+
+  IcallNode *CreateStmtIcall(const MapleVector<BaseNode*> &args);
+  IcallNode *CreateStmtIcallAssigned(const MapleVector<BaseNode*> &args, const MIRSymbol &ret);
+  IcallNode *CreateStmtIcallproto(const MapleVector<BaseNode*> &args, const TyIdx &prototypeIdx);
+  IcallNode *CreateStmtIcallprotoAssigned(const MapleVector<BaseNode*> &args, const MIRSymbol &ret,
+                                          const TyIdx &prototypeIdx);
+  // For Call, VirtualCall, SuperclassCall, InterfaceCall
+  IntrinsiccallNode *CreateStmtIntrinsicCall(MIRIntrinsicID idx, const MapleVector<BaseNode*> &arguments,
+                                             TyIdx tyIdx = TyIdx());
+  IntrinsiccallNode *CreateStmtXintrinsicCall(MIRIntrinsicID idx, const MapleVector<BaseNode*> &arguments);
+  CallNode *CreateStmtCallAssigned(PUIdx puIdx, const MIRSymbol *ret, Opcode op = OP_callassigned);
+  CallNode *CreateStmtCallAssigned(PUIdx puIdx, const MapleVector<BaseNode*> &args, const MIRSymbol *ret,
+                                   Opcode opcode = OP_callassigned, TyIdx tyIdx = TyIdx());
+  CallNode *CreateStmtCallRegassigned(PUIdx, PregIdx, Opcode);
+  CallNode *CreateStmtCallRegassigned(PUIdx puIdx, PregIdx pRegIdx, Opcode opcode, BaseNode *arg);
+  CallNode *CreateStmtCallRegassigned(PUIdx puIdx, const MapleVector<BaseNode*> &args, PregIdx pRegIdx, Opcode opcode);
+  IntrinsiccallNode *CreateStmtIntrinsicCallAssigned(MIRIntrinsicID idx, const MapleVector<BaseNode*> &args,
+                                                     PregIdx retPregIdx);
+  IntrinsiccallNode *CreateStmtIntrinsicCallAssigned(MIRIntrinsicID idx, const MapleVector<BaseNode*> &args,
+                                                     const MIRSymbol *ret, TyIdx tyIdx = TyIdx());
+  IntrinsiccallNode *CreateStmtXintrinsicCallAssigned(MIRIntrinsicID idx, const MapleVector<BaseNode*> &args,
+                                                      const MIRSymbol *ret);
+  IfStmtNode *CreateStmtIf(BaseNode *cond);
+  IfStmtNode *CreateStmtIfThenElse(BaseNode *cond);
+  DoloopNode *CreateStmtDoloop(StIdx doVarStIdx, bool isPReg, BaseNode *startExp, BaseNode *contExp,
+                               BaseNode *incrExp);
+  SwitchNode *CreateStmtSwitch(BaseNode *opnd, LabelIdx defaultLabel, const CaseVector &switchTable);
+  GotoNode *CreateStmtGoto(Opcode o, LabelIdx labIdx);
+  JsTryNode *CreateStmtJsTry(LabelIdx cLabIdx, LabelIdx fLabIdx);
+  TryNode *CreateStmtTry(const MapleVector<LabelIdx> &cLabIdxs);
+  CatchNode *CreateStmtCatch(const MapleVector<TyIdx> &tyIdxVec);
+  LabelIdx GetOrCreateMIRLabel(const std::string &name) const;
+  LabelIdx CreateLabIdx(MIRFunction &mirFunc) const;
+  LabelNode *CreateStmtLabel(LabelIdx labIdx);
+  StmtNode *CreateStmtComment(const std::string &cmnt);
+  CondGotoNode *CreateStmtCondGoto(BaseNode *cond, Opcode op, LabelIdx labIdx);
+  void AddStmtInCurrentFunctionBody(StmtNode &stmt) const;
+  MIRSymbol *GetSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass, MIRStorageClass sClass,
+                       uint8 scpID, bool sameType) const;
+  MIRSymbol *GetSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                       uint8 scpID, bool sameType) const;
+  MIRSymbol *GetOrCreateSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass, MIRStorageClass sClass,
+                               MIRFunction *func, uint8 scpID, bool sametype) const;
+  MIRSymbol *GetOrCreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                               MIRFunction *func, uint8 scpID, bool sameType) const;
+  MIRSymbol *CreatePregFormalSymbol(TyIdx tyIdx, PregIdx pRegIdx, MIRFunction &func) const;
+  // for creating symbol
+  MIRSymbol *CreateSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass, MIRStorageClass sClass,
+                          MIRFunction *func, uint8 scpID) const;
+  MIRSymbol *CreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                          MIRFunction *func, uint8 scpID) const;
+  MIRSymbol *CreateConstStringSymbol(const std::string &symbolName, const std::string &content);
+  MIRSymbol *GetOrCreateLocalDecl(const std::string &str, TyIdx tyIdx, MIRSymbolTable &symbolTable,
+                                  bool &created) const;
+  // for creating nodes
+  AddrofNode *CreateAddrof(const MIRSymbol &st, PrimType pty = PTY_ptr);
+  AddrofNode *CreateDread(const MIRSymbol &st, PrimType pty);
+  virtual MemPool *GetCurrentFuncCodeMp();
+  virtual MapleAllocator *GetCurrentFuncCodeMpAllocator();
+  virtual MemPool *GetCurrentFuncDataMp();
+
+  virtual void GlobalLock() {}
+  virtual void GlobalUnlock() {}
+
+ private:
+  MIRSymbol *GetOrCreateGlobalDecl(const std::string &str, TyIdx tyIdx, bool &created) const;
+
+  MIRModule *mirModule;
+  MapleSet<TyIdx> incompleteTypeRefedSet;
+  // <className strIdx, fieldname strIdx, typename strIdx, attr list strIdx>
+  std::vector<std::tuple<uint32, uint32, uint32, uint32>> extraFieldsTuples;
+  unsigned int lineNum = 0;
+};
+
+class MIRBuilderExt : public MIRBuilder {
+ public:
+  explicit MIRBuilderExt(MIRModule *module, pthread_mutex_t *mutex = nullptr);
+  virtual ~MIRBuilderExt() = default;
+
+  void SetCurrentFunction(MIRFunction &func) override {
+    curFunction = &func;
+  }
+
+  MIRFunction *GetCurrentFunction() const override {
+    return curFunction;
+  }
+
+  MemPool *GetCurrentFuncCodeMp() override;
+  MapleAllocator *GetCurrentFuncCodeMpAllocator() override;
+  void GlobalLock() override;
+  void GlobalUnlock() override;
+
+ private:
+  MIRFunction *curFunction = nullptr;
+  pthread_mutex_t *mutex = nullptr;
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_BUILDER_H
diff --git a/src/mapleall/maple_ir/include/mir_config.h b/src/mapleall/maple_ir/include/mir_config.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e753473baf5325cecb344cf0f87bc2db2c0e35e
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_config.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// configuration definition for code in maple_ir namespace
+#ifndef MAPLE_IR_INCLUDE_MIR_CONFIG_H
+#define MAPLE_IR_INCLUDE_MIR_CONFIG_H
+
+// MIR_FEATURE_FULL = 1 : for host/server size building, by default.
+// MIR_FEATURE_FULL = 0 : for resource-constrained devices. optimized for memory size
+#if !defined(MIR_FEATURE_FULL)
+#define MIR_FEATURE_FULL 1  // default to full feature building, for debugging
+#endif                      // MIR_FEATURE_FULL define
+
+// MIR_DEBUG = 0 : for release building.
+// MIR_DEBUG = 1 : for debug building.
+#ifndef MIR_DEBUG
+#define MIR_DEBUG 0  // currently default to none. turn it on explicitly
+#endif               // MIR_DEBUG
+
+// MIR_DEBUG_LEVEL = 0: no debuging information at all.
+//                   1: with error information.
+//                   2: with severe warning information
+//                   3: with normal warning information
+//                   4: with normal information
+//                   5: with everything
+//
+#ifndef MIR_DEBUG_LEVEL
+#define MIR_DEBUG_LEVEL 0
+#endif  // MIR_DEBUG_LEVEL
+// assertion
+#if !MIR_FEATURE_FULL
+#define MIR_ASSERT(...) \
+  do {                  \
+  } while (0)
+#define MIR_PRINTF(...) \
+  do {                  \
+  } while (0)
+#define MIR_INFO(...) \
+  do {                \
+  } while (0)
+#define MIR_ERROR(...) \
+  do {                 \
+  } while (0)
+#define MIR_WARNING(...) \
+  do {                   \
+  } while (0)
+#define MIR_CAST_TO(var, totype) ((totype)(var))
+#include <stdlib.h>
+#if DEBUG
+#include <stdio.h>
+#define MIR_FATAL(...)                                   \
+  do {                                                   \
+    printf("FATAL ERROR: (%s:%d) ", __FILE__, __LINE__); \
+    printf(__VA_ARGS__);                                 \
+    exit(1);                                             \
+  } while (0)
+#else
+#define MIR_FATAL(...) \
+  do {                 \
+    exit(1);           \
+  } while (0)
+#endif  // DEBUG
+#else   // MIR_FEATURE_FULL
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+
+namespace maple {
+#define MIR_ASSERT(...) assert(__VA_ARGS__)
+#define MIR_FATAL(...)                                            \
+  do {                                                            \
+    fprintf(stderr, "FATAL ERROR: (%s:%d) ", __FILE__, __LINE__); \
+    fprintf(stderr, __VA_ARGS__);                                 \
+    exit(EXIT_FAILURE);                                           \
+  } while (0)
+#define MIR_ERROR(...)                                      \
+  do {                                                      \
+    fprintf(stderr, "ERROR: (%s:%d) ", __FILE__, __LINE__); \
+    fprintf(stderr, __VA_ARGS__);                           \
+  } while (0)
+#define MIR_WARNING(...)                                      \
+  do {                                                        \
+    fprintf(stderr, "WARNING: (%s:%d) ", __FILE__, __LINE__); \
+    fprintf(stderr, __VA_ARGS__);                             \
+  } while (0)
+#define MIR_PRINTF(...) printf(__VA_ARGS__)
+#define MIR_INFO(...) printf(__VA_ARGS__)
+#define MIR_CAST_TO(var, totype) static_cast<totype>(var)
+#endif  // !MIR_FEATURE_FULL
+#if MIR_DEBUG
+#else
+#endif  // MIR_DEBUG
+
+// MIR specific configurations.
+// Note: fix size definition cannot handle arbitary long MIR lines, such
+// as those array initialization lines.
+constexpr int kMirMaxLineSize = 3072;  // a max of 3K characters per line initially
+// LIBRARY API availability
+#if MIR_FEATURE_FULL
+#define HAVE_STRTOD 1  // strtod
+#define HAVE_MALLOC 1  // malloc/free
+#else                  // compact VM
+#define HAVE_STRTOD 1  // strtod in current libc
+#define HAVE_MALLOC 0  // no malloc/free in current libc
+#endif                 // MIR_FEATURE_FULL
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_CONFIG_H
diff --git a/src/mapleall/maple_ir/include/mir_const.h b/src/mapleall/maple_ir/include/mir_const.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd1f0f9460671e5514a504f26983ded753753955
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_const.h
@@ -0,0 +1,618 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_CONST_H
+#define MAPLE_IR_INCLUDE_MIR_CONST_H
+#include <math.h>
+#include "mir_type.h"
+#include "mpl_int_val.h"
+
+namespace maple {
+class MIRConst;  // circular dependency exists, no other choice
+using MIRConstPtr = MIRConst*;
+#if MIR_FEATURE_FULL
+class MIRSymbol;  // circular dependency exists, no other choice
+enum MIRConstKind {
+  kConstInvalid,
+  kConstInt,
+  kConstAddrof,
+  kConstAddrofFunc,
+  kConstLblConst,
+  kConstStrConst,
+  kConstStr16Const,
+  kConstFloatConst,
+  kConstDoubleConst,
+  kConstFloat128Const,
+  kConstAggConst,
+  kConstStConst
+};
+
+class MIRConst {
+ public:
+  explicit MIRConst(MIRType &type, MIRConstKind constKind = kConstInvalid)
+      : type(&type), kind(constKind) {}
+
+  virtual ~MIRConst() = default;
+
+  virtual void Dump(const MIRSymbolTable *localSymTab = nullptr) const {
+    (void)localSymTab;
+  }
+
+  virtual bool IsZero() const {
+    return false;
+  }
+
+  virtual bool IsOne() const {
+    return false;
+  }
+
+  virtual bool IsMagicNum() const {
+    return false;
+  }
+
+  // NO OP
+  virtual void Neg() {}
+
+  virtual bool operator==(const MIRConst &rhs) const {
+    return &rhs == this;
+  }
+
+  virtual MIRConst *Clone(MemPool &memPool) const = 0;
+
+  MIRConstKind GetKind() const {
+    return kind;
+  }
+
+  MIRType &GetType() {
+    return *type;
+  }
+
+  const MIRType &GetType() const {
+    return *type;
+  }
+
+  void SetType(MIRType &t) {
+    type = &t;
+  }
+
+ private:
+  MIRType *type;
+  MIRConstKind kind;
+};
+
+class MIRIntConst : public MIRConst {
+ public:
+  MIRIntConst(uint64 val, MIRType &type)
+      : MIRConst(type, kConstInt), value(val, type.GetPrimType()) {}
+
+  MIRIntConst(const IntVal &val, MIRType &type) : MIRConst(type, kConstInt), value(val) {
+    [[maybe_unused]] PrimType pType = type.GetPrimType();
+    ASSERT(IsPrimitiveInteger(pType) && GetPrimTypeActualBitSize(pType) <= value.GetBitWidth(),
+           "Constant is tried to be constructed with non-integral type or bit-width is not appropriate for it");
+  }
+
+  /// @return number of used bits in the value
+  uint8 GetActualBitWidth() const;
+
+  void Trunc(uint8 width) {
+    value.TruncInPlace(width);
+  }
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+
+  bool IsNegative() const {
+    return value.IsSigned() && value.GetSignBit();
+  }
+
+  bool IsPositive() const {
+    return !IsNegative() && value != 0;
+  }
+
+  bool IsZero() const override {
+    return value == 0;
+  }
+
+  bool IsOne() const override {
+    return value == 1;
+  }
+
+  void Neg() override {
+    value = -value;
+  }
+
+  const IntVal &GetValue() const {
+    return value;
+  }
+
+  int64 GetExtValue(uint8 size = 0) const {
+    return value.GetExtValue(size);
+  }
+
+  int64 GetSXTValue(uint8 size = 0) const {
+    return value.GetSXTValue(size);
+  }
+
+  uint64 GetZXTValue(uint8 size = 0) const {
+    return value.GetZXTValue(size);
+  }
+
+  void SetValue(int64 val) const {
+    (void)val;
+    CHECK_FATAL(false, "Can't Use This Interface in This Object");
+  }
+
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRIntConst *Clone(MemPool &memPool [[maybe_unused]]) const override {
+    CHECK_FATAL(false, "Can't Use This Interface in This Object");
+  }
+
+ private:
+  IntVal value;
+};
+
+class MIRAddrofConst : public MIRConst {
+ public:
+  MIRAddrofConst(StIdx sy, FieldID fi, MIRType &ty)
+      : MIRConst(ty, kConstAddrof), stIdx(sy), fldID(fi), offset(0) {}
+
+  MIRAddrofConst(StIdx sy, FieldID fi, MIRType &ty, int32 ofst)
+      : MIRConst(ty, kConstAddrof), stIdx(sy), fldID(fi), offset(ofst) {}
+
+  ~MIRAddrofConst() = default;
+
+  StIdx GetSymbolIndex() const {
+    return stIdx;
+  }
+
+  void SetSymbolIndex(StIdx idx) {
+    stIdx = idx;
+  }
+
+  FieldID GetFieldID() const {
+    return fldID;
+  }
+
+  int32 GetOffset() const {
+    return offset;
+  }
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRAddrofConst *Clone(MemPool &memPool) const override {
+    return memPool.New<MIRAddrofConst>(*this);
+  }
+
+ private:
+  StIdx stIdx;
+  FieldID fldID;
+  int32 offset;
+};
+
+class MIRAddroffuncConst : public MIRConst {
+ public:
+  MIRAddroffuncConst(PUIdx idx, MIRType &ty)
+      : MIRConst(ty, kConstAddrofFunc), puIdx(idx) {}
+
+  ~MIRAddroffuncConst() = default;
+
+  PUIdx GetValue() const {
+    return puIdx;
+  }
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRAddroffuncConst *Clone(MemPool &memPool) const override {
+    return memPool.New<MIRAddroffuncConst>(*this);
+  }
+
+ private:
+  PUIdx puIdx;
+};
+
+class MIRLblConst : public MIRConst {
+ public:
+  MIRLblConst(LabelIdx val, PUIdx pidx, MIRType &type)
+      : MIRConst(type, kConstLblConst), value(val), puIdx(pidx) {}
+
+  ~MIRLblConst() = default;
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRLblConst *Clone(MemPool &memPool) const override {
+    return memPool.New<MIRLblConst>(*this);
+  }
+
+  LabelIdx GetValue() const {
+    return value;
+  }
+
+  PUIdx GetPUIdx() const {
+    return puIdx;
+  }
+
+ private:
+  LabelIdx value;
+  PUIdx puIdx;
+};
+
+class MIRStrConst : public MIRConst {
+ public:
+  MIRStrConst(UStrIdx val, MIRType &type) : MIRConst(type, kConstStrConst), value(val) {}
+
+  MIRStrConst(const std::string &str, MIRType &type);
+
+  ~MIRStrConst() = default;
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRStrConst *Clone(MemPool &memPool) const override {
+    return memPool.New<MIRStrConst>(*this);
+  }
+
+  UStrIdx GetValue() const {
+    return value;
+  }
+
+  static PrimType GetPrimType() {
+    return kPrimType;
+  }
+
+ private:
+  UStrIdx value;
+  static const PrimType kPrimType = PTY_ptr;
+};
+
+class MIRStr16Const : public MIRConst {
+ public:
+  MIRStr16Const(const U16StrIdx &val, MIRType &type) : MIRConst(type, kConstStr16Const), value(val) {}
+
+  MIRStr16Const(const std::u16string &str, MIRType &type);
+  ~MIRStr16Const() = default;
+
+  static PrimType GetPrimType() {
+    return kPrimType;
+  }
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRStr16Const *Clone(MemPool &memPool) const override {
+    return memPool.New<MIRStr16Const>(*this);
+  }
+
+  U16StrIdx GetValue() const {
+    return value;
+  }
+
+ private:
+  static const PrimType kPrimType = PTY_ptr;
+  U16StrIdx value;
+};
+
+class MIRFloatConst : public MIRConst {
+ public:
+  using value_type = float;
+  MIRFloatConst(float val, MIRType &type) : MIRConst(type, kConstFloatConst) {
+    value.floatValue = val;
+  }
+
+  ~MIRFloatConst() = default;
+
+  void SetFloatValue(float fvalue) {
+    value.floatValue = fvalue;
+  }
+
+  value_type GetFloatValue() const {
+    return value.floatValue;
+  }
+
+  static PrimType GetPrimType() {
+    return kPrimType;
+  }
+
+  int32 GetIntValue() const {
+    return value.intValue;
+  }
+
+  value_type GetValue() const {
+    return GetFloatValue();
+  }
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+  bool IsZero() const override {
+    return fabs(value.floatValue) <= 1e-6;
+  }
+
+  bool IsGeZero() const {
+    return value.floatValue >= 0;
+  }
+
+  bool IsNeg() const {
+    return ((static_cast<uint32>(value.intValue) & 0x80000000) == 0x80000000);
+  }
+
+  bool IsOne() const override {
+    return fabs(value.floatValue - 1) <= 1e-6;
+  };
+  bool IsAllBitsOne() const {
+    return fabs(value.floatValue + 1) <= 1e-6;
+  };
+  void Neg() override {
+    value.floatValue = -value.floatValue;
+  }
+
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRFloatConst *Clone(MemPool &memPool) const override {
+    return memPool.New<MIRFloatConst>(*this);
+  }
+
+ private:
+  static const PrimType kPrimType = PTY_f32;
+  union {
+    value_type floatValue;
+    int32 intValue;
+  } value;
+};
+
+class MIRDoubleConst : public MIRConst {
+ public:
+  using value_type = double;
+  MIRDoubleConst(double val, MIRType &type) : MIRConst(type, kConstDoubleConst) {
+    value.dValue = val;
+  }
+
+  ~MIRDoubleConst() = default;
+
+  uint32 GetIntLow32() const {
+    auto unsignVal = static_cast<uint64>(value.intValue);
+    return static_cast<uint32>(unsignVal & 0xffffffff);
+  }
+
+  uint32 GetIntHigh32() const {
+    auto unsignVal = static_cast<uint64>(value.intValue);
+    return static_cast<uint32>((unsignVal & 0xffffffff00000000) >> 32);
+  }
+
+  int64 GetIntValue() const {
+    return value.intValue;
+  }
+
+  value_type GetValue() const {
+    return value.dValue;
+  }
+
+  static PrimType GetPrimType() {
+    return kPrimType;
+  }
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+  bool IsZero() const override {
+    return fabs(value.dValue) <= 1e-15;
+  }
+
+  bool IsGeZero() const {
+    return value.dValue >= 0;
+  }
+
+  bool IsNeg() const {
+    return ((static_cast<uint64>(value.intValue) & 0x8000000000000000LL) == 0x8000000000000000LL);
+  }
+
+  bool IsOne() const override {
+    return fabs(value.dValue - 1) <= 1e-15;
+  };
+  bool IsAllBitsOne() const {
+    return fabs(value.dValue + 1) <= 1e-15;
+  };
+  void Neg() override {
+    value.dValue = -value.dValue;
+  }
+
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRDoubleConst *Clone(MemPool &memPool) const override {
+    return memPool.New<MIRDoubleConst>(*this);
+  }
+
+ private:
+  static const PrimType kPrimType = PTY_f64;
+  union {
+    value_type dValue;
+    int64 intValue;
+  } value;
+};
+
+class MIRFloat128Const : public MIRConst {
+ public:
+  MIRFloat128Const(const uint64 &val, MIRType &type) : MIRConst(type, kConstFloat128Const) {
+    value = &val;
+  }
+
+  ~MIRFloat128Const() = default;
+
+  const uint64 *GetIntValue() const {
+    return value;
+  }
+
+  static PrimType GetPrimType() {
+    return kPrimType;
+  }
+
+  bool IsZero() const override {
+    MIR_ASSERT(value && "value must not be nullptr!");
+    return value[0] == 0 && value[1] == 0;
+  }
+
+  bool IsOne() const override {
+    MIR_ASSERT(value && "value must not be nullptr!");
+    return value[0] == 0 && value[1] == 0x3FFF000000000000;
+  };
+  bool IsAllBitsOne() const {
+    MIR_ASSERT(value && "value must not be nullptr!");
+    return (value[0] == 0xffffffffffffffff && value[1] == 0xffffffffffffffff);
+  };
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRFloat128Const *Clone(MemPool &memPool) const override {
+    auto *res = memPool.New<MIRFloat128Const>(*this);
+    return res;
+  }
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+
+ private:
+  static const PrimType kPrimType = PTY_f128;
+  // value[0]: Low 64 bits; value[1]: High 64 bits.
+  const uint64 *value;
+};
+
+class MIRAggConst : public MIRConst {
+ public:
+  MIRAggConst(MIRModule &mod, MIRType &type)
+      : MIRConst(type, kConstAggConst),
+        constVec(mod.GetMPAllocator().Adapter()),
+        fieldIdVec(mod.GetMPAllocator().Adapter()) {}
+
+  ~MIRAggConst() = default;
+
+  MIRConst *GetAggConstElement(unsigned int fieldId) {
+    for (size_t i = 0; i < fieldIdVec.size(); ++i) {
+      if (fieldId == fieldIdVec[i]) {
+        return constVec[i];
+      }
+    }
+    return nullptr;
+  }
+
+  void SetFieldIdOfElement(uint32 index, uint32 fieldId) {
+    ASSERT(index < fieldIdVec.size(), "index out of range");
+    fieldIdVec[index] = fieldId;
+  }
+
+  const MapleVector<MIRConst*> &GetConstVec() const {
+    return constVec;
+  }
+
+  MapleVector<MIRConst*> &GetConstVec() {
+    return constVec;
+  }
+
+  const MIRConstPtr &GetConstVecItem(size_t index) const {
+    CHECK_FATAL(index < constVec.size(), "index out of range");
+    return constVec[index];
+  }
+
+  MIRConstPtr &GetConstVecItem(size_t index) {
+    CHECK_FATAL(index < constVec.size(), "index out of range");
+    return constVec[index];
+  }
+
+  void SetConstVecItem(size_t index, MIRConst& st) {
+    CHECK_FATAL(index < constVec.size(), "index out of range");
+    constVec[index] = &st;
+  }
+
+  uint32 GetFieldIdItem(size_t index) const {
+    ASSERT(index < fieldIdVec.size(), "index out of range");
+    return fieldIdVec[index];
+  }
+
+  void SetItem(uint32 index, MIRConst *mirConst, uint32 fieldId) {
+    CHECK_FATAL(index < constVec.size(), "index out of range");
+    constVec[index] = mirConst;
+    fieldIdVec[index] = fieldId;
+  }
+
+  void AddItem(MIRConst *mirConst, uint32 fieldId) {
+    constVec.push_back(mirConst);
+    fieldIdVec.push_back(fieldId);
+  }
+
+  void PushBack(MIRConst *elem) {
+    AddItem(elem, 0);
+  }
+
+  void Dump(const MIRSymbolTable *localSymTab) const override;
+  bool operator==(const MIRConst &rhs) const override;
+
+  MIRAggConst *Clone(MemPool &memPool) const override {
+    return memPool.New<MIRAggConst>(*this);
+  }
+
+ private:
+  MapleVector<MIRConst*> constVec;
+  MapleVector<uint32> fieldIdVec;
+};
+
+// the const has one or more symbols
+class MIRStConst : public MIRConst {
+ public:
+  MIRStConst(MIRModule &mod, MIRType &type)
+      : MIRConst(type, kConstStConst),
+        stVec(mod.GetMPAllocator().Adapter()),
+        stOffsetVec(mod.GetMPAllocator().Adapter()) {}
+
+  const MapleVector<MIRSymbol*> &GetStVec() const {
+    return stVec;
+  }
+  void PushbackSymbolToSt(MIRSymbol *sym) {
+    stVec.push_back(sym);
+  }
+
+  MIRSymbol *GetStVecItem(size_t index) {
+    CHECK_FATAL(index < stVec.size(), "array index out of range");
+    return stVec[index];
+  }
+
+  const MapleVector<uint32> &GetStOffsetVec() const {
+    return stOffsetVec;
+  }
+  void PushbackOffsetToSt(uint32 offset) {
+    stOffsetVec.push_back(offset);
+  }
+
+  uint32 GetStOffsetVecItem(size_t index) const {
+    CHECK_FATAL(index < stOffsetVec.size(), "array index out of range");
+    return stOffsetVec[index];
+  }
+
+  MIRStConst *Clone(MemPool &memPool) const override {
+    auto *res = memPool.New<MIRStConst>(*this);
+    return res;
+  }
+
+  ~MIRStConst() = default;
+
+ private:
+  MapleVector<MIRSymbol*> stVec;    // symbols that in the st const
+  MapleVector<uint32> stOffsetVec;  // symbols offset
+};
+#endif  // MIR_FEATURE_FULL
+
+bool IsDivSafe(const MIRIntConst& dividend, const MIRIntConst& divisor, PrimType pType);
+
+}  // namespace maple
+
+#define LOAD_SAFE_CAST_FOR_MIR_CONST
+#include "ir_safe_cast_traits.def"
+
+#endif  // MAPLE_IR_INCLUDE_MIR_CONST_H
diff --git a/src/mapleall/maple_ir/include/mir_enum.h b/src/mapleall/maple_ir/include/mir_enum.h
new file mode 100644
index 0000000000000000000000000000000000000000..92f7fb9368415955b615d1ba610e976a3cc799d2
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_enum.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLEIR_INCLUDE_MIR_ENUMERATION_H
+#define MAPLEIR_INCLUDE_MIR_ENUMERATION_H
+
+namespace maple {
+
+using EnumElem = std::pair<GStrIdx, IntVal>;
+class MIREnum {
+ public:
+  explicit MIREnum(PrimType ptyp, GStrIdx stridx)
+      : primType(ptyp), nameStrIdx(stridx) {}
+  ~MIREnum() = default;
+
+  void NewElement(GStrIdx sidx, IntVal value) {
+    elements.push_back(EnumElem(sidx, value));
+  }
+
+  void AddNextElement(GStrIdx sidx) {
+    if (elements.empty()) {
+      elements.push_back(EnumElem(sidx, IntVal(0, primType)));
+      return;
+    }
+    IntVal newValue = elements.back().second + 1;
+    elements.push_back(EnumElem(sidx, newValue));
+  }
+
+  void SetPrimType(PrimType pt) {
+    primType = pt;
+  }
+
+  PrimType GetPrimType() const {
+    return primType;
+  }
+
+  const std::vector<EnumElem> &GetElements() const {
+    return elements;
+  }
+
+  GStrIdx GetNameIdx() const {
+    return nameStrIdx;
+  }
+
+  const std::string &GetName() const;
+  void Dump() const;
+
+ private:
+  PrimType primType = PTY_i32;  // must be integer primtype
+  GStrIdx nameStrIdx{ 0 };      // name of this enum in global string table
+  std::vector<EnumElem> elements{};
+};
+
+struct EnumTable {
+  std::vector<MIREnum*> enumTable;
+
+  ~EnumTable() {
+    for (MIREnum *mirEnum : enumTable) {
+      if (mirEnum == nullptr) {
+        continue;
+      }
+      delete mirEnum;
+      mirEnum = nullptr;
+    }
+  }
+
+  void Dump() {
+    for (MIREnum *mirEnum : enumTable) {
+      mirEnum->Dump();
+    }
+  }
+};
+
+}  /* namespace maple */
+
+#endif  /* MAPLEIR_INCLUDE_MIR_ENUMERATION_H */
diff --git a/src/mapleall/maple_ir/include/mir_function.h b/src/mapleall/maple_ir/include/mir_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..2363180fa4fd458e6c613cfa682bb1ae3d5fe1c0
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_function.h
@@ -0,0 +1,1423 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_FUNCTION_H
+#define MAPLE_IR_INCLUDE_MIR_FUNCTION_H
+#include <string>
+#include "mir_module.h"
+#include "mir_const.h"
+#include "mir_symbol.h"
+#include "mir_preg.h"
+#include "intrinsics.h"
+#include "file_layout.h"
+#include "mir_nodes.h"
+#include "mir_type.h"
+#include "mir_scope.h"
+#include "profile.h"
+#include "func_desc.h"
+
+#define DEBUGME true
+
+namespace maple {
+enum PointerAttr: uint32_t {
+  kPointerUndeiced = 0x1,
+  kPointerNull = 0x2,
+  kPointerNoNull = 0x3
+};
+
+enum FuncAttrProp : uint32_t {
+  kNoThrowException = 0x1,
+  kNoRetNewlyAllocObj = 0x2,
+  kNoDefEffect = 0x4,
+  kNoDefArgEffect = 0x8,
+  kPureFunc = 0x10,
+  kIpaSeen = 0x20,
+  kUseEffect = 0x40,
+  kDefEffect = 0x80
+};
+
+// describe a formal definition in a function declaration
+class FormalDef {
+ public:
+  GStrIdx formalStrIdx = GStrIdx(0);    // used when processing the prototype
+  MIRSymbol *formalSym = nullptr;       // used in the function definition
+  TyIdx formalTyIdx = TyIdx();
+  TypeAttrs formalAttrs = TypeAttrs();  // the formal's type attributes
+
+  FormalDef() {};
+  virtual ~FormalDef() {}
+  FormalDef(MIRSymbol *s, const TyIdx &tidx, const TypeAttrs &at) : formalSym(s), formalTyIdx(tidx), formalAttrs(at) {}
+  FormalDef(const GStrIdx &sidx, MIRSymbol *s, const TyIdx &tidx, const TypeAttrs &at)
+      : formalStrIdx(sidx), formalSym(s), formalTyIdx(tidx), formalAttrs(at) {}
+};
+
+class InlineSummary;  // circular dependency exists, no other choice
+class MeFunction;  // circular dependency exists, no other choice
+class EAConnectionGraph;  // circular dependency exists, no other choice
+class MIRFunction {
+ public:
+  MIRFunction(MIRModule *mod, StIdx idx)
+      : module(mod),
+        symbolTableIdx(idx) {}
+
+  ~MIRFunction() = default;
+
+  void Dump(bool withoutBody = false);
+  void DumpUpFormal(int32 indent) const;
+  void DumpFrame(int32 indent) const;
+  void DumpFuncBody(int32 indent);
+  void DumpScope() const;
+  const MIRSymbol *GetFuncSymbol() const;
+  MIRSymbol *GetFuncSymbol();
+
+  void SetBaseClassFuncNames(GStrIdx strIdx);
+  void SetMemPool(MemPool *memPool) {
+    SetCodeMemPool(memPool);
+    codeMemPoolAllocator.SetMemPool(codeMemPool);
+  }
+
+  /// update signature_strIdx, basefunc_strIdx, baseclass_strIdx, basefunc_withtype_strIdx
+  /// without considering baseclass_strIdx, basefunc_strIdx's original non-zero values
+  /// \param strIdx full_name strIdx of the new function name
+  void OverrideBaseClassFuncNames(GStrIdx strIdx);
+  const std::string &GetName() const;
+
+  GStrIdx GetNameStrIdx() const;
+
+  const std::string &GetBaseClassName() const;
+
+  const std::string &GetBaseFuncName() const;
+
+  const std::string &GetBaseFuncNameWithType() const;
+
+  const std::string &GetBaseFuncSig() const;
+
+  const std::string &GetSignature() const;
+
+  GStrIdx GetBaseClassNameStrIdx() const {
+    return baseClassStrIdx;
+  }
+
+  GStrIdx GetBaseFuncNameStrIdx() const {
+    return baseFuncStrIdx;
+  }
+
+  GStrIdx GetBaseFuncNameWithTypeStrIdx() const {
+    return baseFuncWithTypeStrIdx;
+  }
+
+  GStrIdx GetBaseFuncSigStrIdx() const {
+    return baseFuncSigStrIdx;
+  }
+
+  void SetBaseClassNameStrIdx(GStrIdx id) {
+    baseClassStrIdx = id;
+  }
+
+  void SetBaseFuncNameStrIdx(GStrIdx id) {
+    baseFuncStrIdx = id;
+  }
+
+  void SetBaseFuncNameWithTypeStrIdx(GStrIdx id) {
+    baseFuncWithTypeStrIdx = id;
+  }
+
+  const MIRType *GetReturnType() const;
+  MIRType *GetReturnType();
+  bool IsReturnVoid() const {
+    return GetReturnType()->GetPrimType() == PTY_void;
+  }
+  TyIdx GetReturnTyIdx() const {
+    CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
+    return funcType->GetRetTyIdx();
+  }
+  void SetReturnTyIdx(TyIdx tyidx) {
+    CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
+    funcType->SetRetTyIdx(tyidx);
+  }
+
+  const MIRType *GetClassType() const;
+  TyIdx GetClassTyIdx() const {
+    return classTyIdx;
+  }
+  void SetClassTyIdx(TyIdx tyIdx) {
+    classTyIdx = tyIdx;
+  }
+  void SetClassTyIdx(uint32 idx) {
+    classTyIdx.reset(idx);
+  }
+
+  void AddArgument(MIRSymbol *st) {
+    ASSERT(st != nullptr, "null ptr check");
+    FormalDef formalDef(st->GetNameStrIdx(), st, st->GetTyIdx(), st->GetAttrs());
+    formalDefVec.push_back(formalDef);
+  }
+
+  void AddFormalDef(const FormalDef &formalDef) {
+    formalDefVec.push_back(formalDef);
+  }
+
+  size_t GetParamSize() const {
+    CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
+    return funcType->GetParamTypeList().size();
+  }
+
+  auto &GetParamTypes() const {
+    CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
+    return funcType->GetParamTypeList();
+  }
+
+  TyIdx GetNthParamTyIdx(size_t i) const {
+    ASSERT(i < funcType->GetParamTypeList().size(), "array index out of range");
+    return funcType->GetParamTypeList()[i];
+  }
+
+  const MIRType *GetNthParamType(size_t i) const;
+  MIRType *GetNthParamType(size_t i);
+
+  const TypeAttrs &GetNthParamAttr(size_t i) const {
+    ASSERT(i < formalDefVec.size(), "array index out of range");
+    ASSERT(formalDefVec[i].formalSym != nullptr, "null ptr check");
+    return formalDefVec[i].formalSym->GetAttrs();
+  }
+
+  void UpdateFuncTypeAndFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs = false);
+  void UpdateFuncTypeAndFormalsAndReturnType(const std::vector<MIRSymbol*> &symbols, const TyIdx &retTyIdx,
+                                             bool clearOldArgs = false);
+  LabelIdx GetOrCreateLableIdxFromName(const std::string &name);
+  GStrIdx GetLabelStringIndex(LabelIdx labelIdx) const {
+    CHECK_FATAL(labelTab != nullptr, "labelTab is nullptr");
+    ASSERT(labelIdx < labelTab->Size(), "index out of range in GetLabelStringIndex");
+    return labelTab->GetSymbolFromStIdx(labelIdx);
+  }
+  const std::string &GetLabelName(LabelIdx labelIdx) const {
+    GStrIdx strIdx = GetLabelStringIndex(labelIdx);
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+  }
+
+  const MIRSymbol *GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst = false) const;
+  MIRSymbol *GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst = false);
+
+  void SetAttrsFromSe(uint8 specialEffect);
+
+  const FuncAttrs &GetAttrs() const {
+    return funcAttrs;
+  }
+
+  void SetAttrs(FuncAttrs attr) {
+    funcAttrs = attr;
+  }
+
+  bool GetAttr(FuncAttrKind attrKind) const {
+    return funcAttrs.GetAttr(attrKind);
+  }
+
+  void SetAttr(FuncAttrKind attrKind) {
+    funcAttrs.SetAttr(attrKind);
+  }
+
+  void UnSetAttr(FuncAttrKind attrKind) {
+    funcAttrs.SetAttr(attrKind, true);
+  }
+
+  bool IsVarargs() const {
+    return funcAttrs.GetAttr(FUNCATTR_varargs);
+  }
+
+  bool IsWeak() const {
+    return funcAttrs.GetAttr(FUNCATTR_weak);
+  }
+
+  bool IsStatic() const {
+    return funcAttrs.GetAttr(FUNCATTR_static);
+  }
+
+  bool IsInline() const {
+    return funcAttrs.GetAttr(FUNCATTR_inline);
+  }
+
+  bool IsExtern() const {
+    return funcAttrs.GetAttr(FUNCATTR_extern);
+  }
+
+  bool IsNative() const {
+    return funcAttrs.GetAttr(FUNCATTR_native);
+  }
+
+  bool IsFinal() const {
+    return funcAttrs.GetAttr(FUNCATTR_final);
+  }
+
+  bool IsAbstract() const {
+    return funcAttrs.GetAttr(FUNCATTR_abstract);
+  }
+
+  bool IsPublic() const {
+    return funcAttrs.GetAttr(FUNCATTR_public);
+  }
+
+  bool IsPrivate() const {
+    return funcAttrs.GetAttr(FUNCATTR_private);
+  }
+
+  bool IsProtected() const {
+    return funcAttrs.GetAttr(FUNCATTR_protected);
+  }
+
+  bool IsConstructor() const {
+    return funcAttrs.GetAttr(FUNCATTR_constructor);
+  }
+
+  bool IsLocal() const {
+    return funcAttrs.GetAttr(FUNCATTR_local);
+  }
+
+  bool IsNoDefArgEffect() const {
+    return funcAttrs.GetAttr(FUNCATTR_nodefargeffect);
+  }
+
+  bool IsNoDefEffect() const {
+    return funcAttrs.GetAttr(FUNCATTR_nodefeffect);
+  }
+
+  bool IsNoRetGlobal() const {
+    return funcAttrs.GetAttr(FUNCATTR_noretglobal);
+  }
+
+  bool IsNoThrowException() const {
+    return funcAttrs.GetAttr(FUNCATTR_nothrow_exception);
+  }
+
+  bool IsNoRetArg() const {
+    return funcAttrs.GetAttr(FUNCATTR_noretarg);
+  }
+
+  bool IsNoPrivateDefEffect() const {
+    return funcAttrs.GetAttr(FUNCATTR_noprivate_defeffect);
+  }
+
+  bool IsIpaSeen() const {
+    return funcAttrs.GetAttr(FUNCATTR_ipaseen);
+  }
+
+  bool IsPure() const {
+    return funcAttrs.GetAttr(FUNCATTR_pure);
+  }
+
+  bool IsFirstArgReturn() const {
+    return funcAttrs.GetAttr(FUNCATTR_firstarg_return);
+  }
+
+  bool IsUnSafe() const {
+    return !funcAttrs.GetAttr(FUNCATTR_safed) || funcAttrs.GetAttr(FUNCATTR_unsafed);
+  }
+
+  bool IsSafe() const {
+    return funcAttrs.GetAttr(FUNCATTR_safed);
+  }
+
+  void SetVarArgs() {
+    funcAttrs.SetAttr(FUNCATTR_varargs);
+  }
+
+  void SetNoDefArgEffect() {
+    funcAttrs.SetAttr(FUNCATTR_nodefargeffect);
+  }
+
+  void SetNoDefEffect() {
+    funcAttrs.SetAttr(FUNCATTR_nodefeffect);
+  }
+
+  void SetNoRetGlobal() {
+    funcAttrs.SetAttr(FUNCATTR_noretglobal);
+  }
+
+  void SetNoThrowException() {
+    funcAttrs.SetAttr(FUNCATTR_nothrow_exception);
+  }
+
+  void SetNoRetArg() {
+    funcAttrs.SetAttr(FUNCATTR_noretarg);
+  }
+
+  void SetNoPrivateDefEffect() {
+    funcAttrs.SetAttr(FUNCATTR_noprivate_defeffect);
+  }
+
+  void SetIpaSeen() {
+    funcAttrs.SetAttr(FUNCATTR_ipaseen);
+  }
+
+  void SetPure() {
+    funcAttrs.SetAttr(FUNCATTR_pure);
+  }
+
+  void SetFirstArgReturn() {
+    funcAttrs.SetAttr(FUNCATTR_firstarg_return);
+  }
+
+  void UnsetNoDefArgEffect() {
+    funcAttrs.SetAttr(FUNCATTR_nodefargeffect, true);
+  }
+
+  void UnsetNoDefEffect() {
+    funcAttrs.SetAttr(FUNCATTR_nodefeffect, true);
+  }
+
+  void UnsetNoRetGlobal() {
+    funcAttrs.SetAttr(FUNCATTR_noretglobal, true);
+  }
+
+  void UnsetNoThrowException() {
+    funcAttrs.SetAttr(FUNCATTR_nothrow_exception, true);
+  }
+
+  void UnsetPure() {
+    funcAttrs.SetAttr(FUNCATTR_pure, true);
+  }
+
+  void UnsetNoRetArg() {
+    funcAttrs.SetAttr(FUNCATTR_noretarg, true);
+  }
+
+  void UnsetNoPrivateDefEffect() {
+    funcAttrs.SetAttr(FUNCATTR_noprivate_defeffect, true);
+  }
+
+  bool HasCall() const;
+  void SetHasCall();
+
+  bool IsReturnStruct() const;
+  void SetReturnStruct();
+  void SetReturnStruct(const MIRType &retType);
+
+  bool IsUserFunc() const;
+  void SetUserFunc();
+
+  bool IsInfoPrinted() const;
+  void SetInfoPrinted();
+  void ResetInfoPrinted();
+
+  void SetNoReturn();
+  bool NeverReturns() const;
+
+  void SetHasSetjmp();
+  bool HasSetjmp() const;
+
+  void SetHasAsm();
+  bool HasAsm() const;
+
+  void SetStructReturnedInRegs();
+  bool StructReturnedInRegs() const;
+
+  void SetReturnStruct(const MIRType *retType);
+
+  bool IsEmpty() const;
+  bool IsClinit() const;
+  uint32 GetInfo(GStrIdx strIdx) const;
+  uint32 GetInfo(const std::string &string) const;
+  bool IsAFormal(const MIRSymbol *st) const {
+    for (const auto &formalDef : formalDefVec) {
+      if (st == formalDef.formalSym) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  uint32 GetFormalIndex(const MIRSymbol *symbol) const {
+    for (size_t i = 0; i < formalDefVec.size(); ++i) {
+      if (formalDefVec[i].formalSym == symbol) {
+        return i;
+      }
+    }
+    return 0xffffffff;
+  }
+
+  FormalDef &GetFormalDefFromMIRSymbol(const MIRSymbol *symbol) {
+    for (auto &formalDef : formalDefVec) {
+      if (formalDef.formalSym == symbol) {
+        return formalDef;
+      }
+    }
+    CHECK_FATAL(false, "Impossible.");
+  }
+
+  bool IsAFormalName(const GStrIdx idx) const {
+    for (const auto &formalDef : formalDefVec) {
+      if (idx == formalDef.formalStrIdx) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const FormalDef GetFormalFromName(const GStrIdx idx) const {
+    for (size_t i = 0; i < formalDefVec.size(); ++i) {
+      if (formalDefVec[i].formalStrIdx == idx) {
+        return formalDefVec[i];
+      }
+    }
+    return FormalDef();
+  }
+
+  // tell whether this function is a Java method
+  bool IsJava() const {
+    return classTyIdx != 0u;
+  }
+
+  const MIRType *GetNodeType(const BaseNode &node) const;
+
+#ifdef DEBUGME
+  void SetUpGDBEnv();
+  void ResetGDBEnv();
+#endif
+  void ReleaseMemory() {
+    if (codeMemPoolTmp != nullptr) {
+      delete codeMemPoolTmp;
+      codeMemPoolTmp = nullptr;
+    }
+  }
+
+  void ReleaseCodeMemory() {
+    if (codeMemPool != nullptr) {
+      codeMemPoolAllocator.SetMemPool(nullptr);
+      delete codeMemPool;
+      SetMemPool(nullptr);
+    }
+  }
+
+  MemPool *GetCodeMempool() {
+    if (useTmpMemPool) {
+      if (codeMemPoolTmp == nullptr) {
+        codeMemPoolTmp = new ThreadLocalMemPool(memPoolCtrler, "func code mempool");
+        codeMemPoolTmpAllocator.SetMemPool(codeMemPoolTmp);
+      }
+      return codeMemPoolTmp;
+    }
+    if (codeMemPool == nullptr) {
+      codeMemPool = new ThreadLocalMemPool(memPoolCtrler, "func code mempool");
+      codeMemPoolAllocator.SetMemPool(codeMemPool);
+    }
+    return codeMemPool;
+  }
+
+  MapleAllocator &GetCodeMemPoolAllocator() {
+    GetCodeMempool();
+    if (useTmpMemPool) {
+      return codeMemPoolTmpAllocator;
+    }
+    return codeMemPoolAllocator;
+  }
+
+  MapleAllocator &GetCodeMempoolAllocator() {
+    if (codeMemPool == nullptr) {
+      codeMemPool = new ThreadLocalMemPool(memPoolCtrler, "func code mempool");
+      codeMemPoolAllocator.SetMemPool(codeMemPool);
+    }
+    return codeMemPoolAllocator;
+  }
+
+  TyIdx GetFuncRetStructTyIdx() {
+    TyIdx tyIdx = GetFormalDefAt(0).formalTyIdx;
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    CHECK_FATAL(ty->GetKind() == kTypePointer, "Fake param not a pointer");
+    MIRPtrType *pType = static_cast<MIRPtrType*>(ty);
+    tyIdx = pType->GetPointedTyIdx();
+    CHECK_FATAL(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->IsStructType(),
+                "Must be struct return type");
+    return tyIdx;
+  }
+
+  void EnterFormals();
+  void NewBody();
+
+  MIRModule *GetModule() {
+    return module;
+  }
+
+  void SetCurrentFunctionToThis() {
+    module->SetCurFunction(this);
+  }
+
+  PUIdx GetPuidx() const {
+    return puIdx;
+  }
+  void SetPuidx(PUIdx idx) {
+    puIdx = idx;
+  }
+
+  PUIdx GetPuidxOrigin() const {
+    return puIdxOrigin;
+  }
+  void SetPuidxOrigin(PUIdx idx) {
+    puIdxOrigin = idx;
+  }
+
+  StIdx GetStIdx() const {
+    return symbolTableIdx;
+  }
+  void SetStIdx(StIdx stIdx) {
+    symbolTableIdx = stIdx;
+  }
+
+  int32 GetSCCId() const {
+    return sccID;
+  }
+  void SetSCCId(int32 id) {
+    sccID = id;
+  }
+
+  MIRFuncType *GetMIRFuncType() {
+    return funcType;
+  }
+  void SetMIRFuncType(MIRFuncType *type) {
+    funcType = type;
+  }
+
+  TyIdx GetInferredReturnTyIdx() const {
+    return inferredReturnTyIdx;
+  }
+
+  void SetInferredReturnTyIdx(TyIdx tyIdx) {
+    inferredReturnTyIdx = tyIdx;
+  }
+
+  MIRTypeNameTable *GetTypeNameTab() const {
+    return typeNameTab;
+  }
+
+  void AllocTypeNameTab() {
+    if (typeNameTab == nullptr) {
+      typeNameTab = module->GetMemPool()->New<MIRTypeNameTable>(module->GetMPAllocator());
+    }
+  }
+  bool HaveTypeNameTab() const {
+    return typeNameTab != nullptr;
+  }
+  const MapleMap<GStrIdx, TyIdx> &GetGStrIdxToTyIdxMap() const {
+    CHECK_FATAL(typeNameTab != nullptr, "typeNameTab is nullptr");
+    return typeNameTab->GetGStrIdxToTyIdxMap();
+  }
+  TyIdx GetTyIdxFromGStrIdx(GStrIdx idx) const {
+    CHECK_FATAL(typeNameTab != nullptr, "typeNameTab is nullptr");
+    return typeNameTab->GetTyIdxFromGStrIdx(idx);
+  }
+  void SetGStrIdxToTyIdx(GStrIdx gStrIdx, TyIdx tyIdx) {
+    CHECK_FATAL(typeNameTab != nullptr, "typeNameTab is nullptr");
+    typeNameTab->SetGStrIdxToTyIdx(gStrIdx, tyIdx);
+  }
+
+  const std::string &GetLabelTabItem(LabelIdx labelIdx) const {
+    CHECK_FATAL(labelTab != nullptr, "labelTab is nullptr");
+    return labelTab->GetName(labelIdx);
+  }
+
+  void AllocLabelTab() {
+    if (labelTab == nullptr) {
+      labelTab = module->GetMemPool()->New<MIRLabelTable>(module->GetMPAllocator());
+    }
+  }
+
+  MIRPregTable *GetPregTab() const {
+    return pregTab;
+  }
+
+  void SetPregTab(MIRPregTable *tab) {
+    pregTab = tab;
+  }
+  void AllocPregTab() {
+    if (pregTab == nullptr) {
+      pregTab = module->GetMemPool()->New<MIRPregTable>(&module->GetMPAllocator());
+    }
+  }
+  MIRPreg *GetPregItem(PregIdx idx) {
+    return const_cast<MIRPreg*>(const_cast<const MIRFunction*>(this)->GetPregItem(idx));
+  }
+  const MIRPreg *GetPregItem(PregIdx idx) const {
+    return pregTab->PregFromPregIdx(idx);
+  }
+
+  BlockNode *GetBody() {
+    return body;
+  }
+  const BlockNode *GetBody() const {
+    return body;
+  }
+  void SetBody(BlockNode *node) {
+    body = node;
+  }
+
+  SrcPosition &GetSrcPosition() {
+    ASSERT(GetFuncSymbol() != nullptr, "null ptr check");
+    return GetFuncSymbol()->GetSrcPosition();
+  }
+
+  void SetSrcPosition(const SrcPosition &position) {
+    ASSERT(GetFuncSymbol() != nullptr, "null ptr check");
+    GetFuncSymbol()->SetSrcPosition(position);
+  }
+
+  const FuncAttrs &GetFuncAttrs() const {
+    return funcAttrs;
+  }
+  FuncAttrs &GetFuncAttrs() {
+    return funcAttrs;
+  }
+
+  void SetFuncAttrs(const FuncAttrs &attrs) {
+    funcAttrs = attrs;
+  }
+  void SetFuncAttrs(uint64 attrFlag) {
+    funcAttrs.SetAttrFlag(attrFlag);
+  }
+
+  uint32 GetFlag() const {
+    return flag;
+  }
+  void SetFlag(uint32 newFlag) {
+    flag = newFlag;
+  }
+
+  uint16 GetHashCode() const {
+    return hashCode;
+  }
+  void SetHashCode(uint16 newHashCode) {
+    hashCode = newHashCode;
+  }
+
+  void SetFileIndex(uint32 newFileIndex) {
+    fileIndex = newFileIndex;
+  }
+
+  MIRInfoVector &GetInfoVector() {
+    return info;
+  }
+
+  const MIRInfoPair &GetInfoPair(size_t i) const {
+    return info.at(i);
+  }
+
+  void PushbackMIRInfo(const MIRInfoPair &pair) {
+    info.push_back(pair);
+  }
+
+  void SetMIRInfoNum(size_t idx, uint32 num) {
+    info[idx].second = num;
+  }
+
+  MapleVector<bool> &InfoIsString() {
+    return infoIsString;
+  }
+
+  void PushbackIsString(bool isString) {
+    infoIsString.push_back(isString);
+  }
+
+  void SetupScope() {
+    if (!scope) {
+      scope = module->GetMemPool()->New<MIRScope>(module, this);
+    }
+  }
+
+  MIRScope *GetScope() {
+    SetupScope();
+    return scope;
+  }
+
+  void SetScope(MIRScope *scp) {
+    scope = scp;
+  }
+
+  bool NeedEmitAliasInfo() const {
+    return scope && !scope->IsEmpty();
+  }
+
+  MapleMap<GStrIdx, MIRAliasVars> &GetAliasVarMap() {
+    SetupScope();
+    return scope->GetAliasVarMap();
+  }
+
+  void SetAliasVarMap(GStrIdx idx, const MIRAliasVars &vars) {
+    SetupScope();
+    scope->SetAliasVarMap(idx, vars);
+  }
+
+  bool HasVlaOrAlloca() const {
+    return hasVlaOrAlloca;
+  }
+
+  void SetVlaOrAlloca(bool has) {
+    hasVlaOrAlloca = has;
+  }
+
+  // Default freq is the lastStmtFreq
+  bool HasFreqMap() const {
+    return freqLastMap != nullptr;
+  }
+
+  bool HasFirstFreqMap() const {
+    return freqFirstMap != nullptr;
+  }
+
+  const MapleMap<uint32, uint64> &GetFirstFreqMap() const {
+    return *freqFirstMap;
+  }
+
+  void SetFirstFreqMap(uint32 stmtID, uint64 freq) {
+    if (freqFirstMap == nullptr) {
+      freqFirstMap = module->GetMemPool()->New<MapleMap<uint32, uint64>>(module->GetMPAllocator().Adapter());
+    }
+    (*freqFirstMap)[stmtID] = freq;
+  }
+
+  const MapleMap<uint32, uint64> &GetLastFreqMap() const {
+    return *freqLastMap;
+  }
+
+  int64 GetFreqFromLastStmt(uint32 stmtId) const {
+    if (freqLastMap == nullptr) {
+      return -1;
+    }
+    if ((*freqLastMap).find(stmtId) == (*freqLastMap).end()) {
+      return -1;
+    }
+    return (*freqLastMap)[stmtId];
+  }
+
+  int64 GetFreqFromFirstStmt(uint32 stmtId) const {
+    if (freqFirstMap == nullptr) {
+      return -1;
+    }
+    if ((*freqFirstMap).find(stmtId) == (*freqFirstMap).end()) {
+      return -1;
+    }
+    return (*freqFirstMap)[stmtId];
+  }
+
+  void SetLastFreqMap(uint32 stmtID, uint64 freq) {
+    if (freqLastMap == nullptr) {
+      freqLastMap = module->GetMemPool()->New<MapleMap<uint32, uint64>>(module->GetMPAllocator().Adapter());
+    }
+    (*freqLastMap)[stmtID] = freq;
+  }
+
+  bool WithLocInfo() const {
+    return withLocInfo;
+  }
+  void SetWithLocInfo(bool withInfo) {
+    withLocInfo = withInfo;
+  }
+
+  bool IsDirty() const {
+    return isDirty;
+  }
+  void SetDirty(bool dirty) {
+    isDirty = dirty;
+  }
+
+  bool IsFromMpltInline() const {
+    return fromMpltInline;
+  }
+  void SetFromMpltInline(bool isInline) {
+    fromMpltInline = isInline;
+  }
+
+  uint8 GetLayoutType() const {
+    return layoutType;
+  }
+  void SetLayoutType(uint8 type) {
+    layoutType = type;
+  }
+
+  uint32 GetCallTimes() const {
+    return callTimes;
+  }
+  void SetCallTimes(uint32 times) {
+    callTimes = times;
+  }
+
+  uint32 GetFrameSize() const {
+    return frameSize;
+  }
+  void SetFrameSize(uint32 size) {
+    frameSize = size;
+  }
+
+  uint32 GetUpFormalSize() const {
+    return upFormalSize;
+  }
+  void SetUpFormalSize(uint32 size) {
+    upFormalSize = size;
+  }
+
+  uint32 GetOutParmSize() const {
+    return outParmSize;
+  }
+  void SetOutParmSize(uint32 size) {
+    outParmSize = size;
+  }
+
+  uint16 GetModuleId() const {
+    return moduleID;
+  }
+  void SetModuleID(uint16 id) {
+    moduleID = id;
+  }
+
+  uint32 GetFuncSize() const {
+    return funcSize;
+  }
+  void SetFuncSize(uint32 size) {
+    funcSize = size;
+  }
+
+  uint32 GetTempCount() const {
+    return tempCount;
+  }
+  void IncTempCount() {
+    ++tempCount;
+  }
+
+  uint8 *GetFormalWordsTypeTagged() const {
+    return formalWordsTypeTagged;
+  }
+  void SetFormalWordsTypeTagged(uint8 *tagged) {
+    formalWordsTypeTagged = tagged;
+  }
+  uint8 **GetFwtAddress() {
+    return &formalWordsTypeTagged;
+  }
+
+  uint8 *GetLocalWordsTypeTagged() const {
+    return localWordsTypeTagged;
+  }
+  void SetLocalWordsTypeTagged(uint8 *tagged) {
+    localWordsTypeTagged = tagged;
+  }
+  uint8 **GetLwtAddress() {
+    return &localWordsTypeTagged;
+  }
+
+  uint8 *GetFormalWordsRefCounted() const {
+    return formalWordsRefCounted;
+  }
+  void SetFormalWordsRefCounted(uint8 *counted) {
+    formalWordsRefCounted = counted;
+  }
+  uint8 **GetFwrAddress() {
+    return &formalWordsRefCounted;
+  }
+
+  uint8 *GetLocalWordsRefCounted() const {
+    return localWordsRefCounted;
+  }
+  void SetLocalWordsRefCounted(uint8 *counted) {
+    localWordsRefCounted = counted;
+  }
+
+  MeFunction *GetMeFunc() {
+    return meFunc;
+  }
+
+  void SetMeFunc(MeFunction *func) {
+    meFunc = func;
+  }
+
+  EAConnectionGraph *GetEACG() {
+    return eacg;
+  }
+  void SetEACG(EAConnectionGraph *eacgVal) {
+    eacg = eacgVal;
+  }
+
+  void SetFormalDefVec(const MapleVector<FormalDef> &currFormals) {
+    formalDefVec = currFormals;
+  }
+
+  MapleVector<FormalDef> &GetFormalDefVec() {
+    return formalDefVec;
+  }
+
+  const FormalDef &GetFormalDefAt(size_t i) const {
+    return formalDefVec[i];
+  }
+
+  FormalDef &GetFormalDefAt(size_t i) {
+    return formalDefVec[i];
+  }
+
+  const MIRSymbol *GetFormal(size_t i) const {
+    return formalDefVec[i].formalSym;
+  }
+
+  MIRSymbol *GetFormal(size_t i) {
+    return formalDefVec[i].formalSym;
+  }
+
+  const std::string &GetFormalName(size_t i) const {
+    auto *formal = formalDefVec[i].formalSym;
+    if (formal != nullptr) {
+      return formal->GetName();
+    }
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(formalDefVec[i].formalStrIdx);
+  }
+
+  size_t GetFormalCount() const {
+    return formalDefVec.size();
+  }
+
+  void ClearFormals() {
+    formalDefVec.clear();
+  }
+
+  void ClearArguments() {
+    formalDefVec.clear();
+    funcType->GetParamTypeList().clear();
+    funcType->GetParamAttrsList().clear();
+  }
+
+  size_t GetSymbolTabSize() const {
+    ASSERT(symTab != nullptr, "symTab is nullptr");
+    return symTab->GetSymbolTableSize();
+  }
+  MIRSymbol *GetSymbolTabItem(uint32 idx, bool checkFirst = false) const {
+    return symTab->GetSymbolFromStIdx(idx, checkFirst);
+  }
+  const MIRSymbolTable *GetSymTab() const {
+    return symTab;
+  }
+  MIRSymbolTable *GetSymTab() {
+    return symTab;
+  }
+  void AllocSymTab() {
+    if (symTab == nullptr) {
+      symTab = module->GetMemPool()->New<MIRSymbolTable>(module->GetMPAllocator());
+    }
+  }
+  MIRLabelTable *GetLabelTab() const {
+    CHECK_FATAL(labelTab != nullptr, "must be");
+    return labelTab;
+  }
+  MIRLabelTable *GetLabelTab() {
+    if (labelTab == nullptr) {
+      labelTab = module->GetMemPool()->New<MIRLabelTable>(module->GetMPAllocator());
+    }
+    return labelTab;
+  }
+  void SetLabelTab(MIRLabelTable *currLabelTab) {
+    labelTab = currLabelTab;
+  }
+
+  const MapleSet<MIRSymbol*> &GetRetRefSym() const {
+    return retRefSym;
+  }
+  void InsertMIRSymbol(MIRSymbol *sym) {
+    (void)retRefSym.insert(sym);
+  }
+
+  MemPool *GetDataMemPool() const {
+    return module->GetMemPool();
+  }
+
+  MemPool *GetCodeMemPool() {
+    if (codeMemPool == nullptr) {
+      codeMemPool = new ThreadLocalMemPool(memPoolCtrler, "func code mempool");
+      codeMemPoolAllocator.SetMemPool(codeMemPool);
+    }
+    return codeMemPool;
+  }
+
+  void SetCodeMemPool(MemPool *currCodeMemPool) {
+    codeMemPool = currCodeMemPool;
+  }
+
+  MapleAllocator &GetCodeMPAllocator() {
+    GetCodeMemPool();
+    return codeMemPoolAllocator;
+  }
+
+  void AddFuncGenericDeclare(GenericDeclare *g) {
+    genericDeclare.push_back(g);
+  }
+
+  void AddFuncGenericArg(AnnotationType *a) {
+    genericArg.push_back(a);
+  }
+
+  void AddFuncGenericRet(AnnotationType *r) {
+    genericRet = r;
+  }
+
+  void AddFuncLocalGenericVar(const GStrIdx &str, AnnotationType *at) {
+    genericLocalVar[str] = at;
+  }
+
+  MapleVector<GenericDeclare*> &GetFuncGenericDeclare() {
+    return genericDeclare;
+  }
+
+  MapleVector<AnnotationType*> &GetFuncGenericArg() {
+    return genericArg;
+  }
+
+  void SetRetrunAttrKind(const PointerAttr kind) {
+    returnKind = kind;
+  }
+
+  PointerAttr GetRetrunAttrKind() const {
+    return returnKind;
+  }
+
+  AnnotationType *GetFuncGenericRet() {
+    return genericRet;
+  }
+
+  AnnotationType *GetFuncLocalGenericVar(const GStrIdx &str) {
+    if (genericLocalVar.find(str) == genericLocalVar.end()) {
+      return nullptr;
+    }
+    return genericLocalVar[str];
+  }
+
+  StmtNode *FindStmtWithId(StmtNode *stmt, uint32 stmtId) {
+    while (stmt != nullptr) {
+      StmtNode *next = stmt->GetNext();
+      switch (stmt->GetOpCode()) {
+        case OP_dowhile:
+        case OP_while: {
+          WhileStmtNode *wnode = static_cast<WhileStmtNode*>(stmt);
+          if (wnode->GetBody() != nullptr && wnode->GetBody()->GetFirst() != nullptr) {
+            StmtNode *res = FindStmtWithId(wnode->GetBody()->GetFirst(), stmtId);
+            if (res != nullptr) {
+              return res;
+            }
+          }
+          break;
+        }
+        case OP_if: {
+          if (stmt->GetMeStmtID() == stmtId) {
+            return stmt;
+          }
+          IfStmtNode *inode = static_cast<IfStmtNode*>(stmt);
+          if (inode->GetThenPart() != nullptr && inode->GetThenPart()->GetFirst() != nullptr) {
+            StmtNode *res = FindStmtWithId(inode->GetThenPart()->GetFirst(), stmtId);
+            if (res != nullptr) {
+              return res;
+            }
+          }
+          if (inode->GetElsePart() != nullptr && inode->GetElsePart()->GetFirst() != nullptr) {
+            StmtNode *res = FindStmtWithId(inode->GetElsePart()->GetFirst(), stmtId);
+            if (res != nullptr) {
+              return res;
+            }
+          }
+          break;
+        }
+        case OP_callassigned:
+        case OP_call:
+        case OP_switch:
+        case OP_brtrue:
+        case OP_brfalse: {
+          if (stmt->GetMeStmtID() == stmtId) {
+            return stmt;
+          }
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+      stmt = next;
+    }
+    return nullptr;
+  }
+
+  StmtNode *GetStmtNodeFromMeId(uint32 stmtId) {
+    if (GetBody() == nullptr) {
+      return nullptr;
+    }
+    StmtNode *stmt = GetBody()->GetFirst();
+    return FindStmtWithId(stmt, stmtId);
+  }
+
+  MemPool *GetCodeMemPoolTmp() {
+    if (codeMemPoolTmp == nullptr) {
+      codeMemPoolTmp = new ThreadLocalMemPool(memPoolCtrler, "func code mempool");
+      codeMemPoolTmpAllocator.SetMemPool(codeMemPoolTmp);
+    }
+    return codeMemPoolTmp;
+  }
+
+  bool CheckParamNullType(MIRSymbol *sym) {
+    return paramNonullTypeMap.find(sym) != paramNonullTypeMap.end();
+  }
+
+  PointerAttr GetParamNonull(MIRSymbol *sym) {
+    return paramNonullTypeMap[sym];
+  }
+
+  void SetParamNonull(MIRSymbol *sym, PointerAttr type) {
+    paramNonullTypeMap[sym] = type;
+  }
+
+  void CopyReferedRegs(std::set<uint32> regs) {
+    for (auto reg : regs) {
+      referedPregs.insert(reg);
+    }
+  }
+
+  MapleSet<uint32> GetReferedRegs() const {
+    return referedPregs;
+  }
+
+  bool IsReferedRegsValid() const {
+    return referedRegsValid;
+  }
+
+  void SetReferedRegsValid(bool val) {
+    referedRegsValid = val;
+  }
+
+  FuncDesc &GetFuncDesc() {
+    return funcDesc;
+  }
+
+  void SetFuncDesc(const FuncDesc &value) {
+    funcDesc = value;
+  }
+
+  void SetProfCtrTbl(MIRSymbol *pct) {
+    CHECK_FATAL(Options::profileGen, "This is only for profileGen");
+    profCtrTbl = pct;
+  }
+
+  MIRSymbol *GetProfCtrTbl() {
+    return profCtrTbl;
+  }
+
+  void SetNumCtrs(uint32 num) {
+    CHECK_FATAL(Options::profileGen, "This is only for profileGen");
+    nCtrs = num;
+  }
+
+  uint32 GetNumCtrs() const {
+    return nCtrs;
+  }
+
+  void SetFileLineNoChksum(uint64 chksum) {
+    CHECK_FATAL(Options::profileGen, "This is only for profileGen");
+    fileLinenoChksum = chksum;
+  }
+
+  uint64 GetFileLineNoChksum() const {
+    return fileLinenoChksum;
+  }
+
+  void SetCFGChksum(uint64 chksum) {
+    CHECK_FATAL(Options::profileGen, "This is only for profileGen");
+    cfgChksum = chksum;
+  }
+
+  uint64 GetCFGChksum() const {
+    return cfgChksum;
+  }
+
+  void InitFuncDescToBest() {
+    funcDesc.InitToBest();
+  }
+
+  const FuncDesc &GetFuncDesc() const {
+    return funcDesc;
+  }
+
+  void AddProfileDesc(uint64 hash, uint32 start, uint32 end) {
+    profileDesc = module->GetMemPool()->New<IRProfileDesc>(hash, start, end);
+  }
+
+  const IRProfileDesc *GetProfInf() {
+    if (profileDesc == nullptr) {
+      // return profileDesc with default value
+      profileDesc = module->GetMemPool()->New<IRProfileDesc>();
+    }
+    return profileDesc;
+  }
+
+  bool IsVisited() const {
+    return isVisited;
+  }
+  void SetIsVisited() {
+    isVisited = true;
+  }
+
+  InlineSummary *GetInlineSummary() {
+    return inlineSummary;
+  }
+
+  const InlineSummary *GetInlineSummary() const {
+    return inlineSummary;
+  }
+
+  void DiscardInlineSummary() {
+    inlineSummary = nullptr;
+  }
+
+  InlineSummary *GetOrCreateInlineSummary();
+
+  void SetFuncProfData(FuncProfInfo *data) {
+    funcProfData = data;
+  }
+  FuncProfInfo* GetFuncProfData() {
+    return funcProfData;
+  }
+  FuncProfInfo* GetFuncProfData() const {
+    return funcProfData;
+  }
+  void SetStmtFreq(uint32_t stmtID, uint64_t freq) {
+    ASSERT((funcProfData != nullptr && freq > 0), "nullptr check");
+    funcProfData->SetStmtFreq(stmtID, static_cast<int64_t>(freq));
+  }
+
+  void SetMayWriteToAddrofStack() {
+    mayWriteToAddrofStack = true;
+  }
+
+  void UnsetMayWriteToAddrofStack() {
+    mayWriteToAddrofStack = false;
+  }
+
+  bool GetMayWriteToAddrofStack() const {
+    return mayWriteToAddrofStack;
+  }
+
+  void CheckMayWriteToAddrofStack() {
+    checkedMayWriteToAddrofStack = true;
+  }
+
+  bool IsMayWriteToAddrofStackChecked() const {
+    // record the info about whether writing to address of stack is checked in me
+    return checkedMayWriteToAddrofStack;
+  }
+
+  MIRFunction *GetFuncAlias();
+
+ private:
+  MIRModule *module;     // the module that owns this function
+  PUIdx puIdx = 0;           // the PU index of this function
+  PUIdx puIdxOrigin = 0;     // the original puIdx when initial generation
+  StIdx symbolTableIdx;  // the symbol table index of this function
+  int32 sccID = -1;  // the scc id of this function, for mplipa
+  MIRFuncType *funcType = nullptr;
+  TyIdx inferredReturnTyIdx{0};     // the actual return type of of this function (may be a
+                                    // subclass of the above). 0 means can not be inferred.
+  TyIdx classTyIdx{0};              // class/interface type this function belongs to
+  MapleVector<FormalDef> formalDefVec{module->GetMPAllocator().Adapter()};  // the formals in function definition
+  MapleSet<MIRSymbol*> retRefSym{module->GetMPAllocator().Adapter()};
+
+  MapleVector<GenericDeclare*> genericDeclare{module->GetMPAllocator().Adapter()};
+  MapleVector<AnnotationType*> genericArg{module->GetMPAllocator().Adapter()};
+  MapleMap<GStrIdx, AnnotationType*> genericLocalVar{module->GetMPAllocator().Adapter()};
+  AnnotationType *genericRet = nullptr;
+
+  MIRSymbolTable *symTab = nullptr;
+  MIRTypeNameTable *typeNameTab = nullptr;
+  MIRLabelTable *labelTab = nullptr;
+  MIRPregTable *pregTab = nullptr;
+  MemPool *codeMemPool = nullptr;
+  MapleAllocator codeMemPoolAllocator{nullptr};
+  uint32 callTimes = 0;
+  BlockNode *body = nullptr;
+  FuncAttrs funcAttrs{};
+  uint32 flag = 0;
+  uint16 hashCode = 0;   // for methodmetadata order
+  uint32 fileIndex = 0;  // this function belongs to which file, used by VM for plugin manager
+  MIRInfoVector info{module->GetMPAllocator().Adapter()};
+  MapleVector<bool> infoIsString{module->GetMPAllocator().Adapter()};  // tells if an entry has string value
+  MIRScope *scope = nullptr;
+  MapleMap<uint32, uint64> *freqFirstMap = nullptr;  // save bb frequency in its first_stmt, key is stmtId
+  MapleMap<uint32, uint64> *freqLastMap = nullptr;  // save bb frequency in its last_stmt, key is stmtId
+  MapleSet<uint32> referedPregs{module->GetMPAllocator().Adapter()};
+  bool referedRegsValid = false;
+  bool hasVlaOrAlloca = false;
+  bool withLocInfo = true;
+  bool isVisited = false;   // only used in inline phase.
+  bool isDirty = false;
+  bool fromMpltInline = false;  // Whether this function is imported from mplt_inline file or not.
+  uint8_t layoutType = kLayoutUnused;
+  uint32 frameSize = 0;
+  uint32 upFormalSize = 0;
+  uint32 outParmSize = 0;
+  uint16 moduleID = 0;
+  uint32 funcSize = 0;                         // size of code in words
+  uint32 tempCount = 0;
+  uint8 *formalWordsTypeTagged = nullptr;  // bit vector where the Nth bit tells whether
+  // the Nth word in the formal parameters area
+  // addressed upward from %%FP (that means
+  // the word at location (%%FP + N*4)) has
+  // typetag; if yes, the typetag is the word
+  // at (%%FP + N*4 + 4); the bitvector's size
+  // is given by BlockSize2BitvectorSize(upFormalSize)
+  uint8 *localWordsTypeTagged = nullptr;  // bit vector where the Nth bit tells whether
+  // the Nth word in the local stack frame
+  // addressed downward from %%FP (that means
+  // the word at location (%%FP - N*4)) has
+  // typetag; if yes, the typetag is the word
+  // at (%%FP - N*4 + 4); the bitvector's size
+  // is given by BlockSize2BitvectorSize(frameSize)
+  uint8 *formalWordsRefCounted = nullptr;  // bit vector where the Nth bit tells whether
+  // the Nth word in the formal parameters area
+  // addressed upward from %%FP (that means
+  // the word at location (%%FP + N*4)) points to
+  // a dynamic memory block that needs reference
+  // count; the bitvector's size is given by
+  // BlockSize2BitvectorSize(upFormalSize)
+  uint8 *localWordsRefCounted = nullptr;  // bit vector where the Nth bit tells whether
+  // the Nth word in the local stack frame
+  // addressed downward from %%FP (that means
+  // the word at location (%%FP - N*4)) points to
+  // a dynamic memory block that needs reference
+  // count; the bitvector's size is given by
+  // BlockSize2BitvectorSize(frameSize)
+  // removed. label table size
+  // lbl2stmt table, removed;
+  // to hold unmangled class and function names
+  MeFunction *meFunc = nullptr;
+  EAConnectionGraph *eacg = nullptr;
+  IRProfileDesc *profileDesc = nullptr;
+  GStrIdx baseClassStrIdx{0};  // the string table index of base class name
+  GStrIdx baseFuncStrIdx{0};   // the string table index of base function name
+  // the string table index of base function name mangled with type info
+  GStrIdx baseFuncWithTypeStrIdx{0};
+  // funcname + types of args, no type of retv
+  GStrIdx baseFuncSigStrIdx{0};
+  GStrIdx signatureStrIdx{0};
+  MemPool *codeMemPoolTmp{nullptr};
+  MapleAllocator codeMemPoolTmpAllocator{nullptr};
+  bool useTmpMemPool = false;
+  PointerAttr returnKind = PointerAttr::kPointerUndeiced;
+  MapleMap<MIRSymbol*, PointerAttr> paramNonullTypeMap{module->GetMPAllocator().Adapter()};
+  FuncDesc funcDesc{};
+  MIRSymbol *profCtrTbl = nullptr;
+  uint32 nCtrs = 0; // number of counters
+  uint64 fileLinenoChksum = 0;
+  uint64 cfgChksum = 0;
+  FuncProfInfo *funcProfData = nullptr;
+  InlineSummary *inlineSummary = nullptr;
+  void DumpFlavorLoweredThanMmpl() const;
+  MIRFuncType *ReconstructFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs);
+  bool mayWriteToAddrofStack = false;
+  bool checkedMayWriteToAddrofStack = false;
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_FUNCTION_H
diff --git a/src/mapleall/maple_ir/include/mir_lower.h b/src/mapleall/maple_ir/include/mir_lower.h
new file mode 100644
index 0000000000000000000000000000000000000000..104a0a932aed185e70955c2aab803e6f2e5ba0c7
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_lower.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_LOWER_H
+#define MAPLE_IR_INCLUDE_MIR_LOWER_H
+#include <iostream>
+
+#include "mir_builder.h"
+#include "opcodes.h"
+
+namespace maple {
+// The base value for branch probability notes and edge probabilities.
+static constexpr int32 kProbAll = 10000;
+static constexpr int32 kProbLikely = 9000;
+static constexpr int32 kProbUnlikely = kProbAll - kProbLikely;
+constexpr uint32 kNodeFirstOpnd = 0;
+constexpr uint32 kNodeSecondOpnd = 1;
+constexpr uint32 kNodeThirdOpnd = 2;
+enum MirLowerPhase : uint8 {
+  kLowerUnder,
+  kLowerMe,
+  kLowerExpandArray,
+  kLowerBe,
+  kLowerCG,
+  kLowerLNO
+};
+
+constexpr uint32 kShiftLowerMe = 1U << kLowerMe;
+constexpr uint32 kShiftLowerExpandArray = 1U << kLowerExpandArray;
+constexpr uint32 kShiftLowerBe = 1U << kLowerBe;
+constexpr uint32 kShiftLowerCG = 1U << kLowerCG;
+constexpr uint32 kShiftLowerLNO = 1U << kLowerLNO;
+// check if a block node ends with an unconditional jump
+inline bool OpCodeNoFallThrough(Opcode opCode) {
+  return opCode == OP_goto || opCode == OP_return || opCode == OP_switch || opCode == OP_throw || opCode == OP_gosub ||
+         opCode == OP_retsub;
+}
+
+inline bool IfStmtNoFallThrough(const IfStmtNode &ifStmt) {
+  return OpCodeNoFallThrough(ifStmt.GetThenPart()->GetLast()->GetOpCode());
+}
+
+class MIRLower {
+ public:
+  static const std::set<std::string> kSetArrayHotFunc;
+
+  MIRLower(MIRModule &mod, MIRFunction *f) : mirModule(mod), mirFunc(f) {}
+
+  virtual ~MIRLower() = default;
+
+  const MIRFunction *GetMirFunc() const {
+    return mirFunc;
+  }
+
+  void SetMirFunc(MIRFunction *f) {
+    mirFunc = f;
+  }
+
+  void Init() {
+    mirBuilder = mirModule.GetMemPool()->New<MIRBuilder>(&mirModule);
+  }
+
+  virtual BlockNode *LowerIfStmt(IfStmtNode &ifStmt, bool recursive);
+  BlockNode *LowerSwitchStmt(SwitchNode *switchNode);
+  virtual BlockNode *LowerWhileStmt(WhileStmtNode &whileStmt);
+  BlockNode *LowerDowhileStmt(WhileStmtNode &doWhileStmt);
+  BlockNode *LowerDoloopStmt(DoloopNode &doloop);
+  BlockNode *LowerBlock(BlockNode &block);
+  BaseNode *LowerEmbeddedCandCior(BaseNode *x, StmtNode *curstmt, BlockNode *blk);
+  void LowerCandCior(BlockNode &block);
+  void LowerBuiltinExpect(BlockNode &block) const;
+  void LowerFunc(MIRFunction &func);
+  BaseNode *LowerFarray(ArrayNode *array);
+  BaseNode *LowerCArray(ArrayNode *array);
+  void ExpandArrayMrt(MIRFunction &func);
+  IfStmtNode *ExpandArrayMrtIfBlock(IfStmtNode &node);
+  WhileStmtNode *ExpandArrayMrtWhileBlock(WhileStmtNode &node);
+  DoloopNode *ExpandArrayMrtDoloopBlock(DoloopNode &node);
+  ForeachelemNode *ExpandArrayMrtForeachelemBlock(ForeachelemNode &node);
+  BlockNode *ExpandArrayMrtBlock(BlockNode &block);
+  void AddArrayMrtMpl(BaseNode &exp, BlockNode &newBlock);
+  MIRFuncType *FuncTypeFromFuncPtrExpr(BaseNode *x);
+  void SetLowerME() {
+    lowerPhase |= kShiftLowerMe;
+  }
+
+  void SetLowerLNO() {
+    lowerPhase |= kShiftLowerLNO;
+  }
+
+  void SetLowerExpandArray() {
+    lowerPhase |= kShiftLowerExpandArray;
+  }
+
+  void SetLowerBE() {
+    lowerPhase |= kShiftLowerBe;
+  }
+
+  void SetLowerCG() {
+    lowerPhase |= kShiftLowerCG;
+  }
+
+  uint8 GetOptLevel() const {
+    return optLevel;
+  }
+
+  void SetOptLevel(uint8 optlvl) {
+    optLevel = optlvl;
+  }
+
+  bool IsLowerME() const {
+    return lowerPhase & kShiftLowerMe;
+  }
+
+  bool IsLowerLNO() const {
+    return lowerPhase & kShiftLowerLNO;
+  }
+
+  bool IsLowerExpandArray() const {
+    return lowerPhase & kShiftLowerExpandArray;
+  }
+
+  bool IsLowerBE() const {
+    return lowerPhase & kShiftLowerBe;
+  }
+
+  bool IsLowerCG() const {
+    return lowerPhase & kShiftLowerCG;
+  }
+
+  static bool ShouldOptArrayMrt(const MIRFunction &func);
+
+  virtual bool InLFO() const {
+    return false;
+  }
+
+  FuncProfInfo *GetFuncProfData() const {
+    return mirFunc->GetFuncProfData();
+  }
+  void CopyStmtFrequency(StmtNode *newStmt, StmtNode *oldStmt) {
+    ASSERT(GetFuncProfData() != nullptr, "nullptr check");
+    if (newStmt == oldStmt) {
+      return;
+    }
+    uint64_t freq = GetFuncProfData()->GetStmtFreq(oldStmt->GetStmtID());
+    GetFuncProfData()->SetStmtFreq(newStmt->GetStmtID(), freq);
+  }
+
+ protected:
+  MIRModule &mirModule;
+
+ private:
+  MIRFunction *mirFunc;
+  MIRBuilder *mirBuilder = nullptr;
+  uint32 lowerPhase = 0;
+  uint8 optLevel = 0;
+  LabelIdx CreateCondGotoStmt(Opcode op, BlockNode &blk, const IfStmtNode &ifStmt);
+  void CreateBrFalseStmt(BlockNode &blk, const IfStmtNode &ifStmt);
+  void CreateBrTrueStmt(BlockNode &blk, const IfStmtNode &ifStmt);
+  void CreateBrFalseAndGotoStmt(BlockNode &blk, const IfStmtNode &ifStmt);
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_LOWER_H
diff --git a/src/mapleall/maple_ir/include/mir_module.h b/src/mapleall/maple_ir/include/mir_module.h
new file mode 100644
index 0000000000000000000000000000000000000000..83eae82df72adaab66a74afa3ebb10212d8d045c
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_module.h
@@ -0,0 +1,803 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_MODULE_H
+#define MAPLE_IR_INCLUDE_MIR_MODULE_H
+#include "intrinsics.h"
+#include "mpl_logging.h"
+#include "mpl_profdata.h"
+#include "muid.h"
+#include "namemangler.h"
+#include "prim_types.h"
+#include "profile.h"
+#include "types_def.h"
+#if MIR_FEATURE_FULL
+#include <map>
+#include <mutex>
+#include <shared_mutex>
+#include <string>
+#include <thread>
+#include <unordered_set>
+
+#include "maple_string.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "thread_env.h"
+#endif  // MIR_FEATURE_FULL
+
+namespace maple {
+class CallInfo;    // circular dependency exists, no other choice
+class MIRModule;   // circular dependency exists, no other choice
+class MIRBuilder;  // circular dependency exists, no other choice
+class MIRScope;
+using MIRModulePtr = MIRModule *;
+using MIRBuilderPtr = MIRBuilder *;
+
+enum MIRFlavor {
+  kFlavorUnknown,
+  kFeProduced,
+  kMeProduced,
+  kBeLowered,
+  kFlavorMbc,
+  kMmpl,
+  kCmplV1,
+  kCmpl,  // == CMPLv2
+  kFlavorLmbc,
+};
+
+enum MIRSrcLang {
+  kSrcLangUnknown,
+  kSrcLangC,
+  kSrcLangJs,
+  kSrcLangCPlusPlus,
+  kSrcLangJava,
+  kSrcLangChar,
+  // SrcLangSwift : when clang adds support for Swift.
+};
+
+class CalleePair {
+ public:
+  CalleePair(PUIdx id, int32_t index) : id(id), index(index) {}
+  bool operator<(const CalleePair &func) const {
+    if (id < func.id) {
+      return true;
+    } else if (id == func.id && index < func.index) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+ private:
+  PUIdx id;
+  int32_t index;
+};
+
+class CallerSummary {
+ public:
+  CallerSummary(PUIdx id, uint32 stmtId) : id(id), stmtId(stmtId) {}
+  PUIdx GetPuidx() const {
+    return id;
+  };
+  uint32 GetStmtId() const {
+    return stmtId;
+  }
+
+ private:
+  PUIdx id;
+  uint32 stmtId;
+};
+
+// This data structure is for the ipa-cp. Important expresstion is about the condtion statement.
+class ImpExpr {
+ public:
+  ImpExpr(uint32 stmtId, uint32 paramIndex) : stmtId(stmtId), paramIndex(paramIndex) {}
+  uint32 GetStmtId() const {
+    return stmtId;
+  }
+  uint32 GetParamIndex() const {
+    return paramIndex;
+  }
+
+ private:
+  uint32 stmtId;
+  uint32 paramIndex;
+};
+
+// blksize gives the size of the memory block in bytes; there are (blksize+3)/4
+// words; 1 bit for each word, so the bit vector's length in bytes is
+// ((blksize+3)/4+7)/8
+static inline uint32 BlockSize2BitVectorSize(uint32 blkSize) {
+  uint32 bitVectorLen = ((blkSize + 3) / 4 + 7) / 8;
+  return ((bitVectorLen + 3) >> 2) << 2;  // round up to word boundary
+}
+
+#if MIR_FEATURE_FULL
+class MIRType;            // circular dependency exists, no other choice
+class MIRFunction;        // circular dependency exists, no other choice
+class MIRSymbol;          // circular dependency exists, no other choice
+class MIRSymbolTable;     // circular dependency exists, no other choice
+class MIRFloatConst;      // circular dependency exists, no other choice
+class MIRDoubleConst;     // circular dependency exists, no other choice
+class MIRBuilder;         // circular dependency exists, no other choice
+class DebugInfo;          // circular dependency exists, no other choice
+class BinaryMplt;         // circular dependency exists, no other choice
+class EAConnectionGraph;  // circular dependency exists, no other choice
+using MIRInfoPair = std::pair<GStrIdx, uint32>;
+using MIRInfoVector = MapleVector<MIRInfoPair>;
+using MIRDataPair = std::pair<GStrIdx, std::vector<uint8>>;
+using MIRDataVector = MapleVector<MIRDataPair>;
+constexpr int kMaxEncodedValueLen = 10;
+struct EncodedValue {
+  uint8 encodedValue[kMaxEncodedValueLen] = {0};
+};
+
+class MIRTypeNameTable {
+ public:
+  explicit MIRTypeNameTable(MapleAllocator &allocator) : gStrIdxToTyIdxMap(std::less<GStrIdx>(), allocator.Adapter()) {}
+
+  ~MIRTypeNameTable() = default;
+
+  const MapleMap<GStrIdx, TyIdx> &GetGStrIdxToTyIdxMap() const {
+    return gStrIdxToTyIdxMap;
+  }
+
+  TyIdx GetTyIdxFromGStrIdx(GStrIdx idx) const {
+    auto it = gStrIdxToTyIdxMap.find(idx);
+    if (it == gStrIdxToTyIdxMap.end()) {
+      return TyIdx(0);
+    }
+    return it->second;
+  }
+
+  void SetGStrIdxToTyIdx(GStrIdx gStrIdx, TyIdx tyIdx) {
+    gStrIdxToTyIdxMap[gStrIdx] = tyIdx;
+  }
+
+  size_t Size() const {
+    return gStrIdxToTyIdxMap.size();
+  }
+
+ private:
+  MapleMap<GStrIdx, TyIdx> gStrIdxToTyIdxMap;
+};
+
+class MIRModule {
+ public:
+  bool firstInline = true;
+  using CallSite = std::pair<CallInfo*, PUIdx>;
+
+  explicit MIRModule(const std::string &fn = "");
+  MIRModule(MIRModule &p) = delete;
+  MIRModule &operator=(const MIRModule &module) = delete;
+  ~MIRModule();
+
+  MemPool *GetMemPool() const {
+    return memPool;
+  }
+  MemPool *GetPragmaMemPool() {
+    return pragmaMemPool;
+  }
+  MapleAllocator &GetPragmaMPAllocator() {
+    return pragmaMemPoolAllocator;
+  }
+  const MapleAllocator &GetMPAllocator() const {
+    return memPoolAllocator;
+  }
+
+  MapleAllocator &GetInlineSummaryAlloc() {
+    return inlineSummaryAlloc;
+  }
+
+  void ReleaseInlineSummaryAlloc() noexcept {
+    if (inlineSummaryAlloc.GetMemPool() != nullptr) {
+      delete inlineSummaryAlloc.GetMemPool();
+      inlineSummaryAlloc.SetMemPool(nullptr);
+    }
+  }
+
+  void ReleasePragmaMemPool() {
+    if (pragmaMemPool) {
+      memPoolCtrler.DeleteMemPool(pragmaMemPool);
+    }
+    pragmaMemPool = nullptr;
+  }
+
+  MapleAllocator &GetMPAllocator() {
+    return memPoolAllocator;
+  }
+
+  const auto &GetFunctionList() const {
+    return functionList;
+  }
+  auto &GetFunctionList() {
+    return functionList;
+  }
+
+  const MapleVector<std::string> &GetImportedMplt() const {
+    return importedMplt;
+  }
+  void PushbackImportedMplt(const std::string &importFileName) {
+    importedMplt.push_back(importFileName);
+  }
+
+  MIRTypeNameTable *GetTypeNameTab() {
+    return typeNameTab;
+  }
+
+  const MapleVector<GStrIdx> &GetTypeDefOrder() const {
+    return typeDefOrder;
+  }
+  void PushbackTypeDefOrder(GStrIdx gstrIdx) {
+    typeDefOrder.push_back(gstrIdx);
+  }
+
+  void AddClass(TyIdx tyIdx);
+  void RemoveClass(TyIdx tyIdx);
+
+  void SetCurFunction(MIRFunction *f) {
+    if (ThreadEnv::IsMeParallel()) {
+      std::lock_guard<std::mutex> guard(curFunctionMutex);
+      auto tid = std::this_thread::get_id();
+      curFunctionMap[tid] = f;
+      return;  // DO NOT delete the return statement
+    }
+    curFunction = f;
+  }
+
+  MIRSrcLang GetSrcLang() const {
+    return srcLang;
+  }
+
+  const MapleSet<StIdx> &GetSymbolSet() const {
+    return symbolSet;
+  }
+
+  const MapleVector<StIdx> &GetSymbolDefOrder() const {
+    return symbolDefOrder;
+  }
+
+  Profile &GetProfile() {
+    return profile;
+  }
+
+  MplProfileData *GetMapleProfile() {
+    return mplProfile;
+  }
+  void SetMapleProfile(MplProfileData *info) {
+    mplProfile = info;
+  }
+
+  LiteProfile &GetLiteProfile() {
+    return liteProfile;
+  }
+
+  void SetSomeSymbolNeedForDecl(bool s) {
+    someSymbolNeedForwDecl = s;
+  }
+
+  MIRFunction *CurFunction() const {
+    if (ThreadEnv::IsMeParallel()) {
+      std::lock_guard<std::mutex> guard(curFunctionMutex);
+      auto tid = std::this_thread::get_id();
+      auto pair = curFunctionMap.find(tid);
+      return pair->second;
+    }
+    return curFunction;
+  }
+
+  MemPool *CurFuncCodeMemPool() const;
+  MapleAllocator *CurFuncCodeMemPoolAllocator() const;
+  MapleAllocator &GetCurFuncCodeMPAllocator() const;
+  void AddExternStructType(TyIdx tyIdx);
+  void AddExternStructType(const MIRType *t);
+  void AddSymbol(StIdx stIdx);
+  void AddSymbol(const MIRSymbol *s);
+  void AddFunction(MIRFunction *pf) {
+    functionList.push_back(pf);
+  }
+
+  void DumpGlobals(bool emitStructureType = true) const;
+  void Dump(bool emitStructureType = true, const std::unordered_set<std::string> *dumpFuncSet = nullptr) const;
+  void DumpToFile(const std::string &fileNameStr, bool emitStructureType = true) const;
+  void DumpInlineCandidateToFile(const std::string &fileNameStr);
+  void DumpDefType();
+  const std::string &GetFileNameFromFileNum(uint32 fileNum) const;
+
+  void DumpToHeaderFile(bool binaryMplt, const std::string &outputName = "");
+  void DumpToCxxHeaderFile(std::set<std::string> &leafClasses, const std::string &pathToOutf) const;
+  void DumpClassToFile(const std::string &path) const;
+  void DumpFunctionList(const std::unordered_set<std::string> *dumpFuncSet) const;
+  void DumpGlobalArraySymbol() const;
+  void Emit(const std::string &outFileName) const;
+  uint32 GetAndIncFloatNum() {
+    return floatNum++;
+  }
+
+  void SetEntryFunction(MIRFunction *f) {
+    entryFunc = f;
+  }
+
+  MIRFunction *GetEntryFunction() const {
+    return entryFunc;
+  }
+
+  MIRFunction *FindEntryFunction();
+  uint32 GetFileinfo(GStrIdx strIdx) const;
+  void OutputAsciiMpl(const char *phaseName, const char *suffix,
+                      const std::unordered_set<std::string> *dumpFuncSet = nullptr, bool emitStructureType = true,
+                      bool binaryform = false);
+  void OutputFunctionListAsciiMpl(const std::string &phaseName);
+  const std::string &GetFileName() const {
+    return fileName;
+  }
+
+  std::string GetFileNameAsPostfix() const;
+  void SetFileName(const std::string &name) {
+    fileName = name;
+  }
+
+  std::string GetProfileDataFileName() const {
+    std::string profileDataFileName = GetFileName().substr(0, GetFileName().find_last_of("."));
+    const char *gcovPath = std::getenv("GCOV_PREFIX");
+    std::string gcovPrefix = gcovPath ? gcovPath : "";
+    if (!gcovPrefix.empty() && (gcovPrefix.back() != '/')) {
+      gcovPrefix.append("/");
+    }
+    profileDataFileName = gcovPrefix + profileDataFileName;
+    return profileDataFileName;
+  }
+
+  bool IsJavaModule() const {
+    return srcLang == kSrcLangJava;
+  }
+
+  bool IsCModule() const {
+    return srcLang == kSrcLangC || srcLang == kSrcLangCPlusPlus;
+  }
+
+  bool IsCPlusPlusModule() const {
+    return srcLang == kSrcLangCPlusPlus;
+  }
+
+  bool IsCharModule() const {
+    return srcLang == kSrcLangChar;
+  }
+
+  void AddSuperCall(const std::string &func) {
+    (void)superCallSet.insert(func);
+  }
+
+  bool FindSuperCall(const std::string &func) const {
+    return superCallSet.find(func) != superCallSet.end();
+  }
+
+  void ReleaseCurFuncMemPoolTmp() const;
+  void SetUseFuncCodeMemPoolTmp() {
+    useFuncCodeMemPoolTmp = true;
+  }
+
+  void ResetUseFuncCodeMemPoolTmp() {
+    useFuncCodeMemPoolTmp = false;
+  }
+
+  void SetFuncInfoPrinted() const;
+  size_t GetOptFuncsSize() const {
+    return optimizedFuncs.size();
+  }
+
+  void AddOptFuncs(MIRFunction *func) {
+    optimizedFuncs.emplace(func);
+  }
+
+  const MapleSet<MIRFunction*> &GetOptFuncs() const {
+    return optimizedFuncs;
+  }
+
+  bool IsOptFunc(MIRFunction *func) const {
+    if (std::find(optimizedFuncs.begin(), optimizedFuncs.end(), func) != optimizedFuncs.end()) {
+      return true;
+    }
+    return false;
+  }
+
+  void AddOptFuncsType(MIRType *type) {
+    optimizedFuncsType.emplace(type);
+  }
+
+  const MapleMap<PUIdx, MapleSet<FieldID>*> &GetPuIdxFieldInitializedMap() const {
+    std::shared_lock<std::shared_timed_mutex> lock(fieldMapMutex);
+    return puIdxFieldInitializedMap;
+  }
+  void SetPuIdxFieldSet(PUIdx puIdx, MapleSet<FieldID> *fieldIDSet) {
+    std::unique_lock<std::shared_timed_mutex> lock(fieldMapMutex);
+    puIdxFieldInitializedMap[puIdx] = fieldIDSet;
+  }
+
+  std::map<CalleePair, std::map<int64_t, std::vector<CallerSummary>>> &GetCalleeParamAboutInt() {
+    return calleeParamAboutInt;
+  }
+
+  std::map<CalleePair, std::map<float, std::vector<CallerSummary>>> &GetCalleeParamAboutFloat() {
+    return calleeParamAboutFloat;
+  }
+
+  std::map<CalleePair, std::map<double, std::vector<CallerSummary>>> &GetCalleeParamAboutDouble() {
+    return calleeParamAboutDouble;
+  }
+
+  std::map<PUIdx, std::vector<ImpExpr>> &GetFuncImportantExpr() {
+    return funcImportantExpr;
+  }
+
+  const MapleSet<uint32_t> &GetInlineGlobals() const {
+    return inliningGlobals;
+  }
+  void InsertInlineGlobal(uint32_t global) {
+    (void)inliningGlobals.insert(global);
+  }
+
+  const MapleSet<FieldID> *GetPUIdxFieldInitializedMapItem(PUIdx key) const {
+    std::shared_lock<std::shared_timed_mutex> lock(fieldMapMutex);
+    auto it = puIdxFieldInitializedMap.find(key);
+    if (it != puIdxFieldInitializedMap.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+
+  std::ostream &GetOut() const {
+    return out;
+  }
+
+  const MIRBuilderPtr &GetMIRBuilder() const {
+    return mirBuilder;
+  }
+
+  const std::string &GetEntryFuncName() const {
+    return entryFuncName;
+  }
+  void SetEntryFuncName(const std::string &entryFunctionName) {
+    entryFuncName = entryFunctionName;
+  }
+
+  TyIdx GetThrowableTyIdx() const {
+    return throwableTyIdx;
+  }
+  void SetThrowableTyIdx(TyIdx throwableTypeIndex) {
+    throwableTyIdx = throwableTypeIndex;
+  }
+
+  bool GetWithProfileInfo() const {
+    return withProfileInfo;
+  }
+  void SetWithProfileInfo(bool withProfInfo) {
+    withProfileInfo = withProfInfo;
+  }
+
+  BinaryMplt *GetBinMplt() {
+    return binMplt;
+  }
+  void SetBinMplt(BinaryMplt *binaryMplt) {
+    binMplt = binaryMplt;
+  }
+
+  bool IsInIPA() const {
+    return inIPA;
+  }
+  bool IsWithMe() const {
+    return withMe;
+  }
+  void SetWithMe(bool isWithMe) {
+    withMe = isWithMe;
+  }
+  void SetInIPA(bool isInIPA) {
+    inIPA = isInIPA;
+  }
+
+  MIRInfoVector &GetFileInfo() {
+    return fileInfo;
+  }
+  void PushFileInfoPair(MIRInfoPair pair) {
+    fileInfo.push_back(pair);
+  }
+  void SetFileInfo(const MIRInfoVector &fileInf) {
+    fileInfo = fileInf;
+  }
+
+  MapleVector<bool> &GetFileInfoIsString() {
+    return fileInfoIsString;
+  }
+  void SetFileInfoIsString(const MapleVector<bool> &fileInfoIsStr) {
+    fileInfoIsString = fileInfoIsStr;
+  }
+  void PushFileInfoIsString(bool isString) {
+    fileInfoIsString.push_back(isString);
+  }
+
+  const MIRDataVector &GetFileData() const {
+    return fileData;
+  }
+  void PushbackFileData(const MIRDataPair &pair) {
+    fileData.push_back(pair);
+  }
+
+  const MIRInfoVector &GetSrcFileInfo() const {
+    return srcFileInfo;
+  }
+  void PushbackFileInfo(const MIRInfoPair &pair) {
+    srcFileInfo.push_back(pair);
+  }
+
+  const MIRFlavor &GetFlavor() const {
+    return flavor;
+  }
+  void SetFlavor(MIRFlavor flv) {
+    flavor = flv;
+  }
+
+  void SetSrcLang(MIRSrcLang sourceLanguage) {
+    srcLang = sourceLanguage;
+  }
+
+  uint16 GetID() const {
+    return id;
+  }
+
+  void SetID(uint16 num) {
+    id = num;
+  }
+
+  uint32 GetGlobalMemSize() const {
+    return globalMemSize;
+  }
+  void SetGlobalMemSize(uint32 globalMemberSize) {
+    globalMemSize = globalMemberSize;
+  }
+
+  uint8 *GetGlobalBlockMap() {
+    return globalBlkMap;
+  }
+  void SetGlobalBlockMap(uint8 *globalBlockMap) {
+    globalBlkMap = globalBlockMap;
+  }
+
+  uint8 *GetGlobalWordsTypeTagged() {
+    return globalWordsTypeTagged;
+  }
+  void SetGlobalWordsTypeTagged(uint8 *globalWordsTyTagged) {
+    globalWordsTypeTagged = globalWordsTyTagged;
+  }
+
+  uint8 *GetGlobalWordsRefCounted() {
+    return globalWordsRefCounted;
+  }
+  void SetGlobalWordsRefCounted(uint8 *counted) {
+    globalWordsRefCounted = counted;
+  }
+
+  uint32 GetNumFuncs() const {
+    return numFuncs;
+  }
+
+  void SetNumFuncs(uint32 numFunc) {
+    numFuncs = numFunc;
+  }
+
+  MapleVector<GStrIdx> &GetImportFiles() {
+    return importFiles;
+  }
+
+  void PushbackImportPath(GStrIdx path) {
+    importPaths.push_back(path);
+  }
+
+  MapleVector<MapleString> &GetAsmDecls() {
+    return asmDecls;
+  }
+
+  const MapleSet<uint32> &GetClassList() const {
+    return classList;
+  }
+
+  const std::map<PUIdx, std::vector<CallInfo*>> &GetMethod2TargetMap() const {
+    return method2TargetMap;
+  }
+
+  std::vector<CallInfo*> &GetMemFromMethod2TargetMap(PUIdx methodPuIdx) {
+    return method2TargetMap[methodPuIdx];
+  }
+
+  void SetMethod2TargetMap(const std::map<PUIdx, std::vector<CallInfo*>> &map) {
+    method2TargetMap = map;
+  }
+
+  void AddMemToMethod2TargetMap(PUIdx idx, const std::vector<CallInfo*> &callSite) {
+    method2TargetMap[idx] = callSite;
+  }
+
+  bool HasTargetHash(PUIdx idx, uint32 key) const {
+    auto it = method2TargetHash.find(idx);
+    if (it == method2TargetHash.end()) {
+      return false;
+    }
+    return it->second.find(key) != it->second.end();
+  }
+  void InsertTargetHash(PUIdx idx, uint32 key) {
+    (void)method2TargetHash[idx].insert(key);
+  }
+  void AddValueToMethod2TargetHash(PUIdx idx, const std::unordered_set<uint32> &value) {
+    method2TargetHash[idx] = value;
+  }
+
+  const std::map<GStrIdx, EAConnectionGraph*> &GetEASummary() const {
+    return eaSummary;
+  }
+  void SetEAConnectionGraph(GStrIdx funcNameIdx, EAConnectionGraph *eaCg) {
+    eaSummary[funcNameIdx] = eaCg;
+  }
+
+  DebugInfo *GetDbgInfo() const {
+    return dbgInfo;
+  }
+
+  MIRScope *GetScope() const {
+    return scope;
+  }
+
+  void SetWithDbgInfo(bool v) {
+    withDbgInfo = v;
+  }
+
+  bool IsWithDbgInfo() const {
+    return withDbgInfo;
+  }
+
+  bool HasPartO2List() const {
+    return hasPartO2List;
+  }
+
+  void SetHasPartO2List(bool value) {
+    hasPartO2List = value;
+  }
+
+  void InitPartO2List(const std::string &list);
+  bool IsInPartO2List(const GStrIdx &idx) const {
+    return partO2FuncList.count(idx) > 0;
+  }
+
+  void SetBaseName(const std::string &curbaseName) {
+    baseName = curbaseName;
+  }
+  const std::string &GetBaseName() const {
+    return baseName;
+  }
+  void SetOutputFileName(const std::string &curOFileName) {
+    outputFileName = curOFileName;
+  }
+  const std::string &GetOutputFileName() const {
+    return outputFileName;
+  }
+  void SetInputFileName(const std::string &curInFileName) {
+    inputFileName = curInFileName;
+  }
+  const std::string &GetInputFileName() const {
+    return inputFileName;
+  }
+
+  uint32 GetUniqueID() const {
+    return UINT_MAX;
+  }
+
+  bool HasNotWarned(uint32 position, uint32 stmtOriginalID);
+
+ private:
+  void DumpTypeTreeToCxxHeaderFile(MIRType &ty, std::unordered_set<MIRType*> &dumpedClasses) const;
+
+  MemPool *memPool;
+  MemPool *pragmaMemPool;
+  MapleAllocator memPoolAllocator;
+  MapleAllocator pragmaMemPoolAllocator;
+  MapleAllocator inlineSummaryAlloc;      // For allocating function inline summary
+  MapleList<MIRFunction*> functionList;  // function table in the order of the appearance of function bodies; it
+  // excludes prototype-only functions
+  MapleVector<std::string> importedMplt;
+  MIRTypeNameTable *typeNameTab;
+  MapleVector<GStrIdx> typeDefOrder;
+
+  MapleSet<TyIdx> externStructTypeSet;
+  MapleSet<StIdx> symbolSet;
+  MapleVector<StIdx> symbolDefOrder;
+  Profile profile;
+  MplProfileData *mplProfile;
+  LiteProfile liteProfile;
+  bool someSymbolNeedForwDecl = false;  // some symbols' addressses used in initialization
+
+  std::ostream &out;
+  MIRBuilder *mirBuilder;
+  std::string entryFuncName = "";  // name of the entry function
+  std::string fileName;
+  TyIdx throwableTyIdx{0};  // a special type that is the base of java exception type. only used for java
+  bool withProfileInfo = false;
+
+  DebugInfo *dbgInfo = nullptr;
+  bool withDbgInfo = false;
+  MIRScope *scope = nullptr;
+
+  // for cg in mplt
+  BinaryMplt *binMplt = nullptr;
+  bool inIPA = false;
+  bool withMe = true;
+  MIRInfoVector fileInfo;              // store info provided under fileInfo keyword
+  MapleVector<bool> fileInfoIsString;  // tells if an entry has string value
+  MIRDataVector fileData;
+  MIRInfoVector srcFileInfo;  // store info provided under srcFileInfo keyword
+  MIRFlavor flavor = kFlavorUnknown;
+  MIRSrcLang srcLang = kSrcLangUnknown;  // the source language
+  uint16 id = 0xffff;
+  uint32 globalMemSize = 0;       // size of storage space for all global variables
+  uint8 *globalBlkMap = nullptr;  // the memory map of the block containing all the
+  // globals, for specifying static initializations
+  uint8 *globalWordsTypeTagged = nullptr;  // bit vector where the Nth bit tells whether
+  // the Nth word in globalBlkMap has typetag;
+  // if yes, the typetag is the N+1th word; the
+  // bitvector's size is given by
+  // BlockSize2BitvectorSize(globalMemSize)
+  uint8 *globalWordsRefCounted = nullptr;  // bit vector where the Nth bit tells whether
+  // the Nth word points to a reference-counted
+  // dynamic memory block; the bitvector's size
+  // is given by BlockSize2BitvectorSize(globalMemSize)
+  uint32 numFuncs = 0;  // because puIdx 0 is reserved, numFuncs is also the highest puIdx
+  MapleVector<GStrIdx> importFiles;
+  MapleVector<GStrIdx> importPaths;
+  MapleVector<MapleString> asmDecls;
+  MapleSet<uint32> classList;
+
+  std::map<PUIdx, std::vector<CallInfo*>> method2TargetMap;
+  std::map<PUIdx, std::unordered_set<uint32>> method2TargetHash;
+  std::map<GStrIdx, EAConnectionGraph*> eaSummary;
+
+  bool useFuncCodeMemPoolTmp = false;
+  MIRFunction *entryFunc = nullptr;
+  uint32 floatNum = 0;
+  // curFunction for single thread, curFunctionMap for multiple threads
+  std::map<std::thread::id, MIRFunction*> curFunctionMap;
+  mutable std::mutex curFunctionMutex;
+  MIRFunction *curFunction;
+  MapleSet<MIRFunction*> optimizedFuncs;
+  MapleSet<MIRType*> optimizedFuncsType;
+  // Add the field for decouple optimization
+  std::unordered_set<std::string> superCallSet;
+  // record all the fields that are initialized in the constructor. module scope,
+  // if puIdx doesn't appear in this map, it writes to all field id
+  // if puIdx appears in the map, but it's corresponding MapleSet is nullptr, it writes nothing fieldID
+  // if puIdx appears in the map, and the value of first corresponding MapleSet is 0, the puIdx appears in this module
+  // and writes to all field id otherwise, it writes the field ids in MapleSet
+  MapleMap<PUIdx, MapleSet<FieldID>*> puIdxFieldInitializedMap;
+  mutable std::shared_timed_mutex fieldMapMutex;
+  MapleSet<uint32_t> inliningGlobals;  // global symbols accessed, used for inlining
+  bool hasPartO2List = false;
+  MapleSet<GStrIdx> partO2FuncList;
+  std::string inputFileName = "";
+  std::string baseName = "";
+  std::string outputFileName = "";
+  MapleMap<uint32, MapleSet<uint32>> safetyWarningMap;  // <postion, stmt original id> indexed map for large module.
+  std::map<CalleePair, std::map<int64_t, std::vector<CallerSummary>>> calleeParamAboutInt;
+  std::map<CalleePair, std::map<double, std::vector<CallerSummary>>> calleeParamAboutDouble;
+  std::map<CalleePair, std::map<float, std::vector<CallerSummary>>> calleeParamAboutFloat;
+  std::map<PUIdx, std::vector<ImpExpr>> funcImportantExpr;
+};
+#endif  // MIR_FEATURE_FULL
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_MODULE_H
diff --git a/src/mapleall/maple_ir/include/mir_nodes.h b/src/mapleall/maple_ir/include/mir_nodes.h
new file mode 100644
index 0000000000000000000000000000000000000000..4457509c6c8c1a1e5980c8f65cced68ed3952ef1
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_nodes.h
@@ -0,0 +1,3791 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_NODES_H
+#define MAPLE_IR_INCLUDE_MIR_NODES_H
+#include <atomic>
+#include <sstream>
+#include <utility>
+
+#include "cmpl.h"
+#include "maple_string.h"
+#include "mir_const.h"
+#include "mir_module.h"
+#include "mir_type.h"
+#include "opcode_info.h"
+#include "opcodes.h"
+#include "ptr_list_ref.h"
+#include "src_position.h"
+
+namespace maple {
+constexpr size_t kFirstOpnd = 0;
+constexpr size_t kSecondOpnd = 1;
+constexpr size_t kThirdOpnd = 2;
+
+extern MIRModule *theMIRModule;
+extern void EmitStr(const MapleString &mplStr);
+
+class MIRPregTable;  // circular dependency exists, no other choice
+class TypeTable;     // circular dependency exists, no other choice
+class VerifyResult;  // circular dependency exists, no other choice
+class CallNode;
+
+struct RegFieldPair {
+ public:
+  RegFieldPair() = default;
+
+  RegFieldPair(FieldID fidx, PregIdx pidx) : fieldID(fidx), pregIdx(pidx) {}
+
+  bool IsReg() const {
+    return pregIdx > 0;
+  }
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  PregIdx GetPregIdx() const {
+    return pregIdx;
+  }
+
+  void SetFieldID(FieldID fld) {
+    fieldID = fld;
+  }
+
+  void SetPregIdx(PregIdx idx) {
+    pregIdx = idx;
+  }
+
+ private:
+  FieldID fieldID = 0;
+  PregIdx pregIdx = 0;
+};
+
+using CallReturnPair = std::pair<StIdx, RegFieldPair>;
+using CallReturnVector = MapleVector<CallReturnPair>;
+// Made public so that other modules (such as maplebe) can print intrinsic names
+// in debug information or comments in assembly files.
+const char *GetIntrinsicName(MIRIntrinsicID intrn);
+class BaseNode : public BaseNodeT {
+ public:
+  explicit BaseNode(Opcode o) {
+    op = o;
+    ptyp = kPtyInvalid;
+    typeFlag = 0;
+    numOpnds = 0;
+  }
+
+  BaseNode(Opcode o, uint8 numOpr) {
+    op = o;
+    ptyp = kPtyInvalid;
+    typeFlag = 0;
+    numOpnds = numOpr;
+  }
+
+  BaseNode(const Opcode o, const PrimType typ, uint8 numOpr) {
+    op = o;
+    ptyp = typ;
+    typeFlag = 0;
+    numOpnds = numOpr;
+  }
+
+  virtual ~BaseNode() = default;
+
+  virtual BaseNode *CloneTree(MapleAllocator &allocator) const {
+    return allocator.GetMemPool()->New<BaseNode>(*this);
+  }
+
+  virtual void DumpBase(int32 indent) const;
+
+  virtual void Dump(int32 indent) const {
+    DumpBase(indent);
+  }
+
+  void Dump() const {
+    Dump(0);
+    LogInfo::MapleLogger() << '\n';
+  }
+
+  virtual uint8 SizeOfInstr() const {
+    return kOpcodeInfo.GetTableItemAt(GetOpCode()).instrucSize;
+  }
+
+  const char *GetOpName() const;
+  bool MayThrowException() const;
+  size_t NumOpnds() const override {
+    return numOpnds;
+  }
+
+  virtual BaseNode *Opnd(size_t) const {
+    ASSERT(0, "override needed");
+    return nullptr;
+  }
+
+  virtual void SetOpnd(BaseNode*, size_t) {
+    ASSERT(0, "This should not happen");
+  }
+
+  virtual bool IsLeaf() const {
+    return true;
+  }
+
+  virtual CallReturnVector *GetCallReturnVector() {
+    return nullptr;
+  }
+
+  virtual MIRType *GetCallReturnType() {
+    return nullptr;
+  }
+
+  virtual bool IsUnaryNode() const {
+    return false;
+  }
+
+  virtual bool IsBinaryNode() const {
+    return false;
+  }
+
+  virtual bool IsTernaryNode() const {
+    return false;
+  }
+
+  virtual bool IsNaryNode() const {
+    return false;
+  }
+
+  bool IsCondBr() const {
+    return kOpcodeInfo.IsCondBr(GetOpCode());
+  }
+
+  bool IsConstval() const {
+    return op == OP_constval;
+  }
+
+  bool IsConstExpr() const {
+    return op == OP_constval || op == OP_conststr || op == OP_conststr16;
+  }
+
+  virtual bool Verify() const {
+    return true;
+  }
+
+  virtual bool Verify(VerifyResult&) const {
+    return Verify();
+  }
+
+  virtual bool IsSSANode() const {
+    return false;
+  }
+
+  virtual bool IsSameContent(const BaseNode *node) const {
+    return false;
+  }
+};
+
+class UnaryNode : public BaseNode {
+ public:
+  explicit UnaryNode(Opcode o) : BaseNode(o, 1) {}
+
+  UnaryNode(Opcode o, PrimType typ) : BaseNode(o, typ, 1) {}
+
+  UnaryNode(Opcode o, PrimType typ, BaseNode *expr) : BaseNode(o, typ, 1), uOpnd(expr) {}
+
+  virtual ~UnaryNode() override = default;
+
+  void DumpOpnd(const MIRModule &mod, int32 indent) const;
+  void DumpOpnd(int32 indent) const;
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  bool Verify(VerifyResult&) const override {
+    return Verify();
+  }
+
+  UnaryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<UnaryNode>(*this);
+    node->SetOpnd(uOpnd->CloneTree(allocator), 0);
+    return node;
+  }
+
+  BaseNode *Opnd(size_t) const override {
+    return uOpnd;
+  }
+
+  size_t NumOpnds() const override {
+    return 1;
+  }
+
+  void SetOpnd(BaseNode *node, size_t) override {
+    uOpnd = node;
+  }
+
+  bool IsLeaf() const override {
+    return false;
+  }
+
+  bool IsUnaryNode() const override {
+    return true;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+ private:
+  BaseNode *uOpnd = nullptr;
+};
+
+class TypeCvtNode : public UnaryNode {
+ public:
+  explicit TypeCvtNode(Opcode o) : UnaryNode(o) {}
+
+  TypeCvtNode(Opcode o, PrimType typ) : UnaryNode(o, typ) {}
+
+  TypeCvtNode(Opcode o, PrimType typ, PrimType fromtyp, BaseNode *expr)
+      : UnaryNode(o, typ, expr), fromPrimType(fromtyp) {}
+
+  virtual ~TypeCvtNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  bool Verify(VerifyResult&) const override {
+    return Verify();
+  }
+
+  TypeCvtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<TypeCvtNode>(*this);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  PrimType FromType() const {
+    return fromPrimType;
+  }
+
+  void SetFromType(PrimType from) {
+    fromPrimType = from;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+ private:
+  PrimType fromPrimType = kPtyInvalid;
+};
+
+// used for retype
+class RetypeNode : public TypeCvtNode {
+ public:
+  RetypeNode() : TypeCvtNode(OP_retype) {}
+
+  explicit RetypeNode(PrimType typ) : TypeCvtNode(OP_retype, typ) {}
+
+  RetypeNode(PrimType typ, PrimType fromtyp, TyIdx idx, BaseNode *expr)
+      : TypeCvtNode(OP_retype, typ, fromtyp, expr), tyIdx(idx) {}
+
+  virtual ~RetypeNode() = default;
+  void Dump(int32 indent) const override;
+  bool Verify(VerifyResult &verifyResult) const override;
+
+  RetypeNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<RetypeNode>(*this);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  const TyIdx &GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(const TyIdx tyIdxVal) {
+    tyIdx = tyIdxVal;
+  }
+
+ private:
+  bool VerifyPrimTypesAndOpnd() const;
+  bool CheckFromJarray(const MIRType &from, const MIRType &to, VerifyResult &verifyResult) const;
+  bool VerifyCompleteMIRType(const MIRType &from, const MIRType &to, bool isJavaRefType,
+                             VerifyResult &verifyResult) const;
+  bool VerifyJarrayDimention(const MIRJarrayType &from, const MIRJarrayType &to, VerifyResult &verifyResult) const;
+  bool IsJavaAssignable(const MIRType &from, const MIRType &to, VerifyResult &verifyResult) const;
+
+  bool BothPointerOrJarray(const MIRType &from, const MIRType &to) const {
+    if (from.GetKind() != to.GetKind()) {
+      return false;
+    }
+    return from.IsMIRPtrType() || from.IsMIRJarrayType();
+  }
+
+  bool IsInterfaceOrClass(const MIRType &mirType) const {
+    return mirType.IsMIRClassType() || mirType.IsMIRInterfaceType();
+  }
+
+  bool IsJavaRefType(const MIRType &mirType) const {
+    return mirType.IsMIRJarrayType() || mirType.IsMIRClassType() || mirType.IsMIRInterfaceType();
+  }
+
+  TyIdx tyIdx = TyIdx(0);
+};
+
+// used for extractbits, sext, zext
+class ExtractbitsNode : public UnaryNode {
+ public:
+  explicit ExtractbitsNode(Opcode o) : UnaryNode(o) {}
+
+  ExtractbitsNode(Opcode o, PrimType typ) : UnaryNode(o, typ) {}
+
+  ExtractbitsNode(Opcode o, PrimType typ, uint8 offset, uint8 size)
+      : UnaryNode(o, typ), bitsOffset(offset), bitsSize(size) {}
+
+  ExtractbitsNode(Opcode o, PrimType typ, uint8 offset, uint8 size, BaseNode *expr)
+      : UnaryNode(o, typ, expr), bitsOffset(offset), bitsSize(size) {}
+
+  virtual ~ExtractbitsNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  ExtractbitsNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<ExtractbitsNode>(*this);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  uint8 GetBitsOffset() const {
+    return bitsOffset;
+  }
+
+  void SetBitsOffset(uint8 offset) {
+    bitsOffset = offset;
+  }
+
+  uint8 GetBitsSize() const {
+    return bitsSize;
+  }
+
+  void SetBitsSize(uint8 size) {
+    bitsSize = size;
+  }
+
+ private:
+  uint8 bitsOffset = 0;
+  uint8 bitsSize = 0;
+};
+
+class GCMallocNode : public BaseNode {
+ public:
+  explicit GCMallocNode(Opcode o) : BaseNode(o) {}
+
+  GCMallocNode(Opcode o, PrimType typ, TyIdx tIdx) : BaseNode(o, typ, 0), tyIdx(tIdx) {}
+
+  virtual ~GCMallocNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  GCMallocNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<GCMallocNode>(*this);
+    return node;
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  void SetOrigPType(PrimType type) {
+    origPrimType = type;
+  }
+
+ private:
+  TyIdx tyIdx = TyIdx(0);
+  PrimType origPrimType = kPtyInvalid;
+};
+
+class JarrayMallocNode : public UnaryNode {
+ public:
+  explicit JarrayMallocNode(Opcode o) : UnaryNode(o) {}
+
+  JarrayMallocNode(Opcode o, PrimType typ) : UnaryNode(o, typ) {}
+
+  JarrayMallocNode(Opcode o, PrimType typ, TyIdx typeIdx) : UnaryNode(o, typ), tyIdx(typeIdx) {}
+
+  JarrayMallocNode(Opcode o, PrimType typ, TyIdx typeIdx, BaseNode *opnd) : UnaryNode(o, typ, opnd), tyIdx(typeIdx) {}
+
+  virtual ~JarrayMallocNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  JarrayMallocNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<JarrayMallocNode>(*this);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+ private:
+  TyIdx tyIdx = TyIdx(0);
+};
+
+// iaddrof also use this node
+class IreadNode : public UnaryNode {
+ public:
+  explicit IreadNode(Opcode o) : UnaryNode(o) {}
+
+  IreadNode(Opcode o, PrimType typ) : UnaryNode(o, typ) {}
+
+  IreadNode(Opcode o, PrimType typ, TyIdx typeIdx, FieldID fid) : UnaryNode(o, typ), tyIdx(typeIdx), fieldID(fid) {}
+
+  IreadNode(Opcode o, PrimType typ, TyIdx typeIdx, FieldID fid, BaseNode *expr)
+      : UnaryNode(o, typ, expr), tyIdx(typeIdx), fieldID(fid) {}
+
+  virtual ~IreadNode() = default;
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  IreadNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<IreadNode>(*this);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  const TyIdx &GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(const TyIdx tyIdxVal) {
+    tyIdx = tyIdxVal;
+  }
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(FieldID fieldIDVal) {
+    fieldID = fieldIDVal;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+  // the base of an address expr is either a leaf or an iread
+  BaseNode &GetAddrExprBase() const {
+    BaseNode *base = Opnd(0);
+    while (base->NumOpnds() != 0 && base->GetOpCode() != OP_iread) {
+      base = base->Opnd(0);
+    }
+    return *base;
+  }
+
+  bool IsVolatile() const;
+
+  MIRType *GetType() const;
+
+ protected:
+  TyIdx tyIdx = TyIdx(0);
+  FieldID fieldID = 0;
+};
+
+// IaddrofNode has the same member fields and member methods as IreadNode
+using IaddrofNode = IreadNode;
+
+class IreadoffNode : public UnaryNode {
+ public:
+  IreadoffNode() : UnaryNode(OP_ireadoff) {}
+
+  IreadoffNode(PrimType ptyp, int32 ofst) : UnaryNode(OP_ireadoff, ptyp), offset(ofst) {}
+
+  IreadoffNode(PrimType ptyp, BaseNode *opnd, int32 ofst) : UnaryNode(OP_ireadoff, ptyp, opnd), offset(ofst) {}
+
+  virtual ~IreadoffNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  IreadoffNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<IreadoffNode>(*this);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  int32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(int32 offsetValue) {
+    offset = offsetValue;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+ private:
+  int32 offset = 0;
+};
+
+class IreadFPoffNode : public BaseNode {
+ public:
+  IreadFPoffNode() : BaseNode(OP_ireadfpoff) {}
+
+  IreadFPoffNode(PrimType ptyp, int32 ofst) : BaseNode(OP_ireadfpoff, ptyp, 0), offset(ofst) {}
+
+  virtual ~IreadFPoffNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  IreadFPoffNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<IreadFPoffNode>(*this);
+    return node;
+  }
+
+  int32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(int32 offsetValue) {
+    offset = offsetValue;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+ private:
+  int32 offset = 0;
+};
+
+class IreadPCoffNode : public IreadFPoffNode {
+ public:
+  IreadPCoffNode(Opcode o, PrimType typ, uint8 numopns) {
+    op = o;
+    ptyp = typ;
+    numOpnds = numopns;
+  }
+  ~IreadPCoffNode() override {}
+};
+
+using AddroffPCNode = IreadPCoffNode;
+
+class BinaryOpnds {
+ public:
+  virtual ~BinaryOpnds() = default;
+
+  virtual void Dump(int32 indent) const;
+
+  BaseNode *GetBOpnd(size_t i) const {
+    CHECK_FATAL(i < kOperandNumBinary, "Invalid operand idx in BinaryOpnds");
+    return bOpnd[i];
+  }
+
+  void SetBOpnd(BaseNode *node, size_t i) {
+    CHECK_FATAL(i < kOperandNumBinary, "Invalid operand idx in BinaryOpnds");
+    bOpnd[i] = node;
+  }
+
+  virtual bool IsSameContent(const BaseNode *node) const;
+
+ private:
+  BaseNode *bOpnd[kOperandNumBinary];
+};
+
+class BinaryNode : public BaseNode, public BinaryOpnds {
+ public:
+  explicit BinaryNode(Opcode o) : BaseNode(o, kOperandNumBinary) {}
+
+  BinaryNode(Opcode o, PrimType typ) : BaseNode(o, typ, kOperandNumBinary) {}
+
+  BinaryNode(Opcode o, PrimType typ, BaseNode *l, BaseNode *r) : BaseNode(o, typ, kOperandNumBinary) {
+    SetBOpnd(l, 0);
+    SetBOpnd(r, 1);
+  }
+
+  virtual ~BinaryNode() = default;
+
+  using BaseNode::Dump;
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  BinaryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<BinaryNode>(*this);
+    node->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
+    node->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
+    return node;
+  }
+
+  bool IsCommutative() const {
+    switch (GetOpCode()) {
+      case OP_add:
+      case OP_mul:
+      case OP_band:
+      case OP_bior:
+      case OP_bxor:
+      case OP_land:
+      case OP_lior:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  BaseNode *Opnd(size_t i) const override {
+    ASSERT(i < kOperandNumBinary, "invalid operand idx in BinaryNode");
+    ASSERT(i >= 0, "invalid operand idx in BinaryNode");
+    return GetBOpnd(i);
+  }
+
+  size_t NumOpnds() const override {
+    return kOperandNumBinary;
+  }
+
+  void SetOpnd(BaseNode *node, size_t i = 0) override {
+    SetBOpnd(node, i);
+  }
+
+  bool IsLeaf() const override {
+    return false;
+  }
+
+  bool IsBinaryNode() const override {
+    return true;
+  }
+  bool IsSameContent(const BaseNode *node) const override;
+};
+
+class CompareNode : public BinaryNode {
+ public:
+  explicit CompareNode(Opcode o) : BinaryNode(o) {}
+
+  CompareNode(Opcode o, PrimType typ) : BinaryNode(o, typ) {}
+
+  CompareNode(Opcode o, PrimType typ, PrimType otype, BaseNode *l, BaseNode *r)
+      : BinaryNode(o, typ, l, r), opndType(otype) {}
+
+  virtual ~CompareNode() = default;
+
+  using BinaryNode::Dump;
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  CompareNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<CompareNode>(*this);
+    node->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
+    node->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
+    return node;
+  }
+
+  PrimType GetOpndType() const {
+    return opndType;
+  }
+
+  void SetOpndType(PrimType type) {
+    opndType = type;
+  }
+
+ private:
+  PrimType opndType = kPtyInvalid;  // type of operands.
+};
+
+class DepositbitsNode : public BinaryNode {
+ public:
+  DepositbitsNode() : BinaryNode(OP_depositbits) {}
+
+  DepositbitsNode(Opcode o, PrimType typ) : BinaryNode(o, typ) {}
+
+  DepositbitsNode(Opcode o, PrimType typ, uint8 offset, uint8 size, BaseNode *l, BaseNode *r)
+      : BinaryNode(o, typ, l, r), bitsOffset(offset), bitsSize(size) {}
+
+  virtual ~DepositbitsNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  DepositbitsNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<DepositbitsNode>(*this);
+    node->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
+    node->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
+    return node;
+  }
+
+  uint8 GetBitsOffset() const {
+    return bitsOffset;
+  }
+
+  void SetBitsOffset(uint8 offset) {
+    bitsOffset = offset;
+  }
+
+  uint8 GetBitsSize() const {
+    return bitsSize;
+  }
+
+  void SetBitsSize(uint8 size) {
+    bitsSize = size;
+  }
+
+ private:
+  uint8 bitsOffset = 0;
+  uint8 bitsSize = 0;
+};
+
+// used for resolveinterfacefunc, resolvevirtualfunc
+// bOpnd[0] stores base vtab/itab address
+// bOpnd[1] stores offset
+class ResolveFuncNode : public BinaryNode {
+ public:
+  explicit ResolveFuncNode(Opcode o) : BinaryNode(o) {}
+
+  ResolveFuncNode(Opcode o, PrimType typ) : BinaryNode(o, typ) {}
+
+  ResolveFuncNode(Opcode o, PrimType typ, PUIdx idx) : BinaryNode(o, typ), puIdx(idx) {}
+
+  ResolveFuncNode(Opcode o, PrimType typ, PUIdx pIdx, BaseNode *opnd0, BaseNode *opnd1)
+      : BinaryNode(o, typ, opnd0, opnd1), puIdx(pIdx) {}
+
+  virtual ~ResolveFuncNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  ResolveFuncNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<ResolveFuncNode>(*this);
+    node->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
+    node->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
+    return node;
+  }
+
+  BaseNode *GetTabBaseAddr() const {
+    return GetBOpnd(0);
+  }
+
+  BaseNode *GetOffset() const {
+    return GetBOpnd(1);
+  }
+
+  PUIdx GetPuIdx() const {
+    return puIdx;
+  }
+
+  void SetPUIdx(PUIdx idx) {
+    puIdx = idx;
+  }
+
+ private:
+  PUIdx puIdx = 0;
+};
+
+class TernaryNode : public BaseNode {
+ public:
+  explicit TernaryNode(Opcode o) : BaseNode(o, kOperandNumTernary) {}
+
+  TernaryNode(Opcode o, PrimType typ) : BaseNode(o, typ, kOperandNumTernary) {}
+
+  TernaryNode(Opcode o, PrimType typ, BaseNode *e0, BaseNode *e1, BaseNode *e2) : BaseNode(o, typ, kOperandNumTernary) {
+    topnd[0] = e0;
+    topnd[1] = e1;
+    topnd[2] = e2;
+  }
+
+  virtual ~TernaryNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  TernaryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<TernaryNode>(*this);
+    node->topnd[0] = topnd[0]->CloneTree(allocator);
+    node->topnd[1] = topnd[1]->CloneTree(allocator);
+    node->topnd[2] = topnd[2]->CloneTree(allocator);
+    return node;
+  }
+
+  BaseNode *Opnd(size_t i) const override {
+    CHECK_FATAL(i < kOperandNumTernary, "array index out of range");
+    return topnd[i];
+  }
+
+  size_t NumOpnds() const override {
+    return kOperandNumTernary;
+  }
+
+  void SetOpnd(BaseNode *node, size_t i = 0) override {
+    CHECK_FATAL(i < kOperandNumTernary, "array index out of range");
+    topnd[i] = node;
+  }
+
+  bool IsLeaf() const override {
+    return false;
+  }
+
+  bool IsTernaryNode() const override {
+    return true;
+  }
+
+ private:
+  BaseNode *topnd[kOperandNumTernary] = {nullptr, nullptr, nullptr};
+};
+
+class NaryOpnds {
+ public:
+  explicit NaryOpnds(MapleAllocator &mpallocter) : nOpnd(mpallocter.Adapter()) {}
+
+  virtual ~NaryOpnds() = default;
+
+  virtual void Dump(int32 indent) const;
+  bool VerifyOpnds() const;
+
+  const MapleVector<BaseNode*> &GetNopnd() const {
+    return nOpnd;
+  }
+
+  MapleVector<BaseNode*> &GetNopnd() {
+    return nOpnd;
+  }
+
+  size_t GetNopndSize() const {
+    return nOpnd.size();
+  }
+
+  BaseNode *GetNopndAt(size_t i) const {
+    CHECK_FATAL(i < nOpnd.size(), "array index out of range");
+    return nOpnd[i];
+  }
+
+  void SetNOpndAt(size_t i, BaseNode *opnd) {
+    CHECK_FATAL(i < nOpnd.size(), "array index out of range");
+    nOpnd[i] = opnd;
+  }
+
+  void SetNOpnd(const MapleVector<BaseNode*> &val) {
+    nOpnd = val;
+  }
+
+ private:
+  MapleVector<BaseNode*> nOpnd;
+};
+
+class NaryNode : public BaseNode, public NaryOpnds {
+ public:
+  NaryNode(MapleAllocator &allocator, Opcode o) : BaseNode(o), NaryOpnds(allocator) {}
+
+  NaryNode(const MIRModule &mod, Opcode o) : NaryNode(mod.GetCurFuncCodeMPAllocator(), o) {}
+
+  NaryNode(MapleAllocator &allocator, Opcode o, PrimType typ) : BaseNode(o, typ, 0), NaryOpnds(allocator) {}
+
+  NaryNode(const MIRModule &mod, Opcode o, PrimType typ) : NaryNode(mod.GetCurFuncCodeMPAllocator(), o, typ) {}
+
+  NaryNode(MapleAllocator &allocator, const NaryNode &node)
+      : BaseNode(node.GetOpCode(), node.GetPrimType(), node.numOpnds), NaryOpnds(allocator) {}
+
+  NaryNode(const MIRModule &mod, const NaryNode &node) : NaryNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  NaryNode(NaryNode &node) = delete;
+  NaryNode &operator=(const NaryNode &node) = delete;
+  virtual ~NaryNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  NaryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<NaryNode>(allocator, *this);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    return node;
+  }
+
+  BaseNode *Opnd(size_t i) const override {
+    return GetNopndAt(i);
+  }
+
+  size_t NumOpnds() const override {
+    ASSERT(numOpnds == GetNopndSize(), "NaryNode has wrong numOpnds field");
+    return GetNopndSize();
+  }
+
+  void SetOpnd(BaseNode *node, size_t i = 0) override {
+    ASSERT(i < GetNopnd().size(), "array index out of range");
+    SetNOpndAt(i, node);
+  }
+
+  bool IsLeaf() const override {
+    return false;
+  }
+
+  bool Verify() const override {
+    return true;
+  }
+
+  bool IsNaryNode() const override {
+    return true;
+  }
+};
+
+class IntrinsicopNode : public NaryNode {
+ public:
+  IntrinsicopNode(MapleAllocator &allocator, Opcode o, TyIdx typeIdx = TyIdx())
+      : NaryNode(allocator, o), intrinsic(INTRN_UNDEFINED), tyIdx(typeIdx) {}
+
+  IntrinsicopNode(const MIRModule &mod, Opcode o, TyIdx typeIdx = TyIdx())
+      : IntrinsicopNode(mod.GetCurFuncCodeMPAllocator(), o, typeIdx) {}
+
+  IntrinsicopNode(MapleAllocator &allocator, Opcode o, PrimType typ, TyIdx typeIdx = TyIdx())
+      : NaryNode(allocator, o, typ), intrinsic(INTRN_UNDEFINED), tyIdx(typeIdx) {}
+
+  IntrinsicopNode(const MIRModule &mod, Opcode o, PrimType typ, TyIdx typeIdx = TyIdx())
+      : IntrinsicopNode(mod.GetCurFuncCodeMPAllocator(), o, typ, typeIdx) {}
+
+  IntrinsicopNode(MapleAllocator &allocator, const IntrinsicopNode &node)
+      : NaryNode(allocator, node), intrinsic(node.GetIntrinsic()), tyIdx(node.GetTyIdx()) {}
+
+  IntrinsicopNode(const MIRModule &mod, const IntrinsicopNode &node)
+      : IntrinsicopNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  IntrinsicopNode(IntrinsicopNode &node) = delete;
+  IntrinsicopNode &operator=(const IntrinsicopNode &node) = delete;
+  virtual ~IntrinsicopNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+  bool Verify(VerifyResult &verifyResult) const override;
+
+  IntrinsicopNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<IntrinsicopNode>(allocator, *this);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    node->SetNumOpnds(GetNopndSize());
+    return node;
+  }
+
+  MIRIntrinsicID GetIntrinsic() const {
+    return intrinsic;
+  }
+
+  void SetIntrinsic(MIRIntrinsicID intrinsicID) {
+    intrinsic = intrinsicID;
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  // IntrinDesc query
+  const IntrinDesc &GetIntrinDesc() const {
+    return IntrinDesc::intrinTable[intrinsic];
+  }
+
+  bool VerifyJArrayLength(VerifyResult &verifyResult) const;
+
+ private:
+  MIRIntrinsicID intrinsic;
+  TyIdx tyIdx;
+};
+
+class ConstvalNode : public BaseNode {
+ public:
+  ConstvalNode() : BaseNode(OP_constval) {}
+
+  explicit ConstvalNode(PrimType typ) : BaseNode(OP_constval, typ, 0) {}
+
+  explicit ConstvalNode(MIRConst *constv) : BaseNode(OP_constval), constVal(constv) {}
+
+  ConstvalNode(PrimType typ, MIRConst *constv) : BaseNode(OP_constval, typ, 0), constVal(constv) {}
+  virtual ~ConstvalNode() = default;
+  void Dump(int32 indent) const override;
+
+  ConstvalNode *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<ConstvalNode>(*this);
+  }
+
+  const MIRConst *GetConstVal() const {
+    return constVal;
+  }
+
+  MIRConst *GetConstVal() {
+    return constVal;
+  }
+
+  void SetConstVal(MIRConst *val) {
+    constVal = val;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+ private:
+  MIRConst *constVal = nullptr;
+};
+
+class ConststrNode : public BaseNode {
+ public:
+  ConststrNode() : BaseNode(OP_conststr) {}
+
+  explicit ConststrNode(UStrIdx i) : BaseNode(OP_conststr), strIdx(i) {}
+
+  ConststrNode(PrimType typ, UStrIdx i) : BaseNode(OP_conststr, typ, 0), strIdx(i) {}
+
+  virtual ~ConststrNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool IsSameContent(const BaseNode *node) const override;
+
+  ConststrNode *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<ConststrNode>(*this);
+  }
+
+  UStrIdx GetStrIdx() const {
+    return strIdx;
+  }
+
+  void SetStrIdx(UStrIdx idx) {
+    strIdx = idx;
+  }
+
+ private:
+  UStrIdx strIdx = UStrIdx(0);
+};
+
+class Conststr16Node : public BaseNode {
+ public:
+  Conststr16Node() : BaseNode(OP_conststr16) {}
+
+  explicit Conststr16Node(U16StrIdx i) : BaseNode(OP_conststr16), strIdx(i) {}
+
+  Conststr16Node(PrimType typ, U16StrIdx i) : BaseNode(OP_conststr16, typ, 0), strIdx(i) {}
+
+  virtual ~Conststr16Node() = default;
+
+  void Dump(int32 indent) const override;
+  bool IsSameContent(const BaseNode *node) const override;
+
+  Conststr16Node *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<Conststr16Node>(*this);
+  }
+
+  U16StrIdx GetStrIdx() const {
+    return strIdx;
+  }
+
+  void SetStrIdx(U16StrIdx idx) {
+    strIdx = idx;
+  }
+
+ private:
+  U16StrIdx strIdx = U16StrIdx(0);
+};
+
+class SizeoftypeNode : public BaseNode {
+ public:
+  SizeoftypeNode() : BaseNode(OP_sizeoftype) {}
+
+  explicit SizeoftypeNode(TyIdx t) : BaseNode(OP_sizeoftype), tyIdx(t) {}
+
+  SizeoftypeNode(PrimType type, TyIdx t) : BaseNode(OP_sizeoftype, type, 0), tyIdx(t) {}
+
+  virtual ~SizeoftypeNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  SizeoftypeNode *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<SizeoftypeNode>(*this);
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+ private:
+  TyIdx tyIdx = TyIdx(0);
+};
+
+class FieldsDistNode : public BaseNode {
+ public:
+  FieldsDistNode() : BaseNode(OP_fieldsdist) {}
+
+  FieldsDistNode(TyIdx t, FieldID f1, FieldID f2) : BaseNode(OP_fieldsdist), tyIdx(t), fieldID1(f1), fieldID2(f2) {}
+
+  FieldsDistNode(PrimType typ, TyIdx t, FieldID f1, FieldID f2)
+      : BaseNode(OP_fieldsdist, typ, 0), tyIdx(t), fieldID1(f1), fieldID2(f2) {}
+
+  virtual ~FieldsDistNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  FieldsDistNode *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<FieldsDistNode>(*this);
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  FieldID GetFiledID1() const {
+    return fieldID1;
+  }
+
+  void SetFiledID1(FieldID id) {
+    fieldID1 = id;
+  }
+
+  FieldID GetFiledID2() const {
+    return fieldID2;
+  }
+
+  void SetFiledID2(FieldID id) {
+    fieldID2 = id;
+  }
+
+ private:
+  TyIdx tyIdx = TyIdx(0);
+  FieldID fieldID1 = 0;
+  FieldID fieldID2 = 0;
+};
+
+class ArrayNode : public NaryNode {
+ public:
+  explicit ArrayNode(MapleAllocator &allocator) : NaryNode(allocator, OP_array) {}
+
+  explicit ArrayNode(const MIRModule &mod) : ArrayNode(mod.GetCurFuncCodeMPAllocator()) {}
+
+  ArrayNode(MapleAllocator &allocator, PrimType typ, TyIdx idx) : NaryNode(allocator, OP_array, typ), tyIdx(idx) {}
+
+  ArrayNode(const MIRModule &mod, PrimType typ, TyIdx idx) : ArrayNode(mod.GetCurFuncCodeMPAllocator(), typ, idx) {}
+
+  ArrayNode(MapleAllocator &allocator, PrimType typ, TyIdx idx, bool bcheck)
+      : NaryNode(allocator, OP_array, typ), tyIdx(idx), boundsCheck(bcheck) {}
+
+  ArrayNode(const MIRModule &mod, PrimType typ, TyIdx idx, bool bcheck)
+      : ArrayNode(mod.GetCurFuncCodeMPAllocator(), typ, idx, bcheck) {}
+
+  ArrayNode(MapleAllocator &allocator, const ArrayNode &node)
+      : NaryNode(allocator, node), tyIdx(node.tyIdx), boundsCheck(node.boundsCheck) {}
+
+  ArrayNode(const MIRModule &mod, const ArrayNode &node) : ArrayNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  ArrayNode(ArrayNode &node) = delete;
+  ArrayNode &operator=(const ArrayNode &node) = delete;
+  virtual ~ArrayNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+  bool IsSameBase(ArrayNode *arry);
+
+  size_t NumOpnds() const override {
+    ASSERT(numOpnds == GetNopndSize(), "ArrayNode has wrong numOpnds field");
+    return GetNopndSize();
+  }
+
+  ArrayNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<ArrayNode>(allocator, *this);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    node->boundsCheck = boundsCheck;
+    node->SetNumOpnds(GetNopndSize());
+    return node;
+  }
+
+  const MIRType *GetArrayType(const TypeTable &tt) const;
+  MIRType *GetArrayType(const TypeTable &tt);
+
+  BaseNode *GetIndex(size_t i) const {
+    return Opnd(i + 1);
+  }
+
+  const BaseNode *GetDim(const MIRModule &mod, TypeTable &tt, int i) const;
+  BaseNode *GetDim(const MIRModule &mod, TypeTable &tt, int i);
+
+  BaseNode *GetBase() const {
+    return Opnd(0);
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  bool GetBoundsCheck() const {
+    return boundsCheck;
+  }
+
+  void SetBoundsCheck(bool check) {
+    boundsCheck = check;
+  }
+
+ private:
+  TyIdx tyIdx;
+  bool boundsCheck = true;
+};
+
+class AddrofNode : public BaseNode {
+ public:
+  explicit AddrofNode(Opcode o) : BaseNode(o), stIdx() {}
+
+  AddrofNode(Opcode o, PrimType typ) : AddrofNode(o, typ, StIdx(), 0) {}
+
+  AddrofNode(Opcode o, PrimType typ, StIdx sIdx, FieldID fid) : BaseNode(o, typ, 0), stIdx(sIdx), fieldID(fid) {}
+
+  virtual ~AddrofNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+  bool CheckNode(const MIRModule &mod) const;
+
+  AddrofNode *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<AddrofNode>(*this);
+  }
+
+  StIdx GetStIdx() const {
+    return stIdx;
+  }
+
+  void SetStIdx(StIdx idx) {
+    stIdx = idx;
+  }
+
+  void SetStFullIdx(uint32 idx) {
+    stIdx.SetFullIdx(idx);
+  }
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(FieldID fieldIDVal) {
+    fieldID = fieldIDVal;
+  }
+
+  bool IsVolatile(const MIRModule &mod) const;
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+  bool MayAccessSameMemory(const BaseNode *node) const;
+ private:
+  StIdx stIdx;
+  FieldID fieldID = 0;
+};
+
+// DreadNode has the same member fields and member methods as AddrofNode
+using DreadNode = AddrofNode;
+
+class DreadoffNode : public BaseNode {
+ public:
+  explicit DreadoffNode(Opcode o) : BaseNode(o), stIdx() {}
+
+  DreadoffNode(Opcode o, PrimType typ) : BaseNode(o, typ, 0), stIdx() {}
+
+  virtual ~DreadoffNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  DreadoffNode *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<DreadoffNode>(*this);
+  }
+
+  bool IsVolatile(const MIRModule &mod) const;
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+ public:
+  StIdx stIdx;
+  int32 offset = 0;
+};
+
+// AddrofoffNode has the same member fields and member methods as DreadoffNode
+using AddrofoffNode = DreadoffNode;
+
+class RegreadNode : public BaseNode {
+ public:
+  RegreadNode() : BaseNode(OP_regread) {}
+
+  explicit RegreadNode(PregIdx pIdx) : BaseNode(OP_regread), regIdx(pIdx) {}
+
+  RegreadNode(PrimType primType, PregIdx pIdx) : RegreadNode(pIdx) {
+    ptyp = primType;
+  }
+
+  virtual ~RegreadNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  RegreadNode *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<RegreadNode>(*this);
+  }
+
+  PregIdx GetRegIdx() const {
+    return regIdx;
+  }
+  void SetRegIdx(PregIdx reg) {
+    regIdx = reg;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+ private:
+  PregIdx regIdx = 0;  // 32bit, negative if special register
+};
+
+class AddroffuncNode : public BaseNode {
+ public:
+  AddroffuncNode() : BaseNode(OP_addroffunc) {}
+
+  AddroffuncNode(PrimType typ, PUIdx pIdx) : BaseNode(OP_addroffunc, typ, 0), puIdx(pIdx) {}
+
+  virtual ~AddroffuncNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  AddroffuncNode *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<AddroffuncNode>(*this);
+  }
+
+  PUIdx GetPUIdx() const {
+    return puIdx;
+  }
+
+  void SetPUIdx(PUIdx puIdxValue) {
+    puIdx = puIdxValue;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+ private:
+  PUIdx puIdx = 0;  // 32bit now
+};
+
+class AddroflabelNode : public BaseNode {
+ public:
+  AddroflabelNode() : BaseNode(OP_addroflabel) {}
+
+  explicit AddroflabelNode(uint32 ofst) : BaseNode(OP_addroflabel), offset(ofst) {}
+
+  virtual ~AddroflabelNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  AddroflabelNode *CloneTree(MapleAllocator &allocator) const override {
+    return allocator.GetMemPool()->New<AddroflabelNode>(*this);
+  }
+
+  uint32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(uint32 offsetValue) {
+    offset = offsetValue;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+
+ private:
+  LabelIdx offset = 0;
+};
+
+// for cleanuptry, jscatch, finally, retsub, endtry, membaracquire, membarrelease,
+// membarstoreload, membarstorestore
+class StmtNode : public BaseNode, public PtrListNodeBase<StmtNode> {
+ public:
+  static std::atomic<uint32> stmtIDNext;  // for assigning stmtID, initialized to 1; 0 is reserved
+  static uint32 lastPrintedLineNum;       // used during printing ascii output
+  static uint16 lastPrintedColumnNum;
+
+  explicit StmtNode(Opcode o) : BaseNode(o), PtrListNodeBase(), stmtID(stmtIDNext), stmtOriginalID(stmtIDNext) {
+    ++stmtIDNext;
+  }
+
+  StmtNode(Opcode o, uint8 numOpr)
+      : BaseNode(o, numOpr), PtrListNodeBase(), stmtID(stmtIDNext), stmtOriginalID(stmtIDNext) {
+    ++stmtIDNext;
+  }
+
+  StmtNode(Opcode o, PrimType typ, uint8 numOpr)
+      : BaseNode(o, typ, numOpr), PtrListNodeBase(), stmtID(stmtIDNext), stmtOriginalID(stmtIDNext) {
+    ++stmtIDNext;
+  }
+
+  // used for NaryStmtNode when clone
+  StmtNode(Opcode o, PrimType typ, uint8 numOpr, const SrcPosition &srcPosition, uint32 stmtOriginalID, StmtAttrs attrs)
+      : BaseNode(o, typ, numOpr),
+        PtrListNodeBase(),
+        srcPosition(srcPosition),
+        stmtID(stmtIDNext),
+        stmtOriginalID(stmtOriginalID),
+        stmtAttrs(attrs) {
+    ++stmtIDNext;
+  }
+
+  virtual ~StmtNode() = default;
+
+  using BaseNode::Dump;
+  void DumpBase(int32 indent) const override;
+  void Dump(int32 indent) const override;
+  void InsertAfterThis(StmtNode &pos);
+  void InsertBeforeThis(StmtNode &pos);
+
+  StmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *s = allocator.GetMemPool()->New<StmtNode>(*this);
+    s->SetStmtID(stmtIDNext++);
+    s->SetMeStmtID(meStmtID);
+    return s;
+  }
+
+  bool Verify() const override {
+    return true;
+  }
+
+  bool Verify(VerifyResult&) const override {
+    return Verify();
+  }
+  // ISO/IEC 9899:1999 7.21
+  // stmt is expanded from ArrayOfChar func defined in <string.h>
+  virtual void SetExpandFromArrayOfCharFunc(bool) {}
+
+  virtual bool IsExpandedFromArrayOfCharFunc() const {
+    return false;
+  }
+
+  const SrcPosition &GetSrcPos() const {
+    return srcPosition;
+  }
+
+  SrcPosition &GetSrcPos() {
+    return srcPosition;
+  }
+
+  void SetSrcPos(SrcPosition pos) {
+    srcPosition = pos;
+  }
+
+  void SetInlinedSrcPos(uint32 lineNum, uint32 fileNum, const GStrIdx &idx) {
+    srcPosition.SetInlinedFuncStrIdx(idx);
+    srcPosition.SetInlinedLineNum(lineNum);
+    srcPosition.SetInlinedFileNum(fileNum);
+  }
+
+  uint32 GetStmtID() const {
+    return stmtID;
+  }
+
+  void SetStmtID(uint32 id) {
+    stmtID = id;
+  }
+
+  uint32 GetOriginalID() const {
+    return stmtOriginalID;
+  }
+
+  void SetOriginalID(uint32 id) {
+    stmtOriginalID = id;
+  }
+
+  uint32 GetMeStmtID() const {
+    return meStmtID;
+  }
+
+  void SetMeStmtID(uint32 id) {
+    meStmtID = id;
+  }
+
+  StmtNode *GetRealNext() const;
+
+  virtual BaseNode *GetRHS() const {
+    return nullptr;
+  }
+
+  bool GetIsLive() const {
+    return isLive;
+  }
+
+  void SetIsLive(bool live) const {
+    isLive = live;
+  }
+
+  bool IsInSafeRegion() const {
+    return stmtAttrs.GetAttr(STMTATTR_insaferegion);
+  }
+
+  void SetInSafeRegion() {
+    stmtAttrs.SetAttr(STMTATTR_insaferegion);
+  }
+
+  void CopySafeRegionAttr(const StmtAttrs &stmtAttr) {
+    this->stmtAttrs.AppendAttr(stmtAttr.GetTargetAttrFlag(STMTATTR_insaferegion));
+  }
+
+  const StmtAttrs &GetStmtAttrs() const {
+    return stmtAttrs;
+  }
+
+  void SetStmtInfoId(size_t index) {
+    stmtInfoId = index;
+  }
+
+  const uint32 GetStmtInfoId() const {
+    return stmtInfoId;
+  }
+
+  bool operator==(const StmtNode &rhs) {
+    return this == &rhs;
+  }
+
+ protected:
+  SrcPosition srcPosition;
+
+ private:
+  uint32 stmtID;          // a unique ID assigned to it
+  uint32 stmtOriginalID;  // first define id, no change when clone, need copy when emit from MeStmt
+  uint32 meStmtID = 0;    // Need copy when emit from MeStmt, attention:this just for two stmt(if && call)
+  uint32 stmtInfoId = -1u;
+  mutable bool isLive = false;  // only used for dse to save compile time
+                                // mutable to keep const-ness at most situation
+  StmtAttrs stmtAttrs;
+};
+
+class IassignNode : public StmtNode {
+ public:
+  IassignNode() : IassignNode(TyIdx(0), 0, nullptr, nullptr) {}
+
+  IassignNode(TyIdx tyIdx, FieldID fieldID, BaseNode *addrOpnd, BaseNode *rhsOpnd)
+      : StmtNode(OP_iassign), tyIdx(tyIdx), fieldID(fieldID), addrExpr(addrOpnd), rhs(rhsOpnd) {
+    BaseNodeT::SetNumOpnds(kOperandNumBinary);
+  }
+
+  virtual ~IassignNode() = default;
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  MIRType *GetLHSType() const;
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(FieldID fid) {
+    fieldID = fid;
+  }
+
+  BaseNode *Opnd(size_t i) const override {
+    if (i == 0) {
+      return addrExpr;
+    }
+    return rhs;
+  }
+
+  size_t NumOpnds() const override {
+    return kOperandNumBinary;
+  }
+
+  void SetOpnd(BaseNode *node, size_t i) override {
+    if (i == 0) {
+      addrExpr = node;
+    } else {
+      rhs = node;
+    }
+  }
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  IassignNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *bn = allocator.GetMemPool()->New<IassignNode>(*this);
+    bn->SetStmtID(stmtIDNext++);
+    bn->SetOpnd(addrExpr->CloneTree(allocator), 0);
+    bn->SetRHS(rhs->CloneTree(allocator));
+    bn->SetExpandFromArrayOfCharFunc(fromAoCFunc);
+    return bn;
+  }
+
+  // the base of an address expr is either a leaf or an iread
+  BaseNode &GetAddrExprBase() const {
+    BaseNode *base = addrExpr;
+    while (base->NumOpnds() != 0 && base->GetOpCode() != OP_iread) {
+      base = base->Opnd(0);
+    }
+    return *base;
+  }
+
+  void SetAddrExpr(BaseNode *exp) {
+    addrExpr = exp;
+  }
+
+  BaseNode *GetRHS() const override {
+    return rhs;
+  }
+
+  void SetRHS(BaseNode *node) {
+    rhs = node;
+  }
+
+  bool AssigningVolatile() const;
+
+  bool IsExpandedFromArrayOfCharFunc() const override {
+    return fromAoCFunc;
+  }
+
+  void SetExpandFromArrayOfCharFunc(bool flag) override {
+    fromAoCFunc = flag;
+  }
+
+ private:
+  TyIdx tyIdx;
+  FieldID fieldID;
+  bool fromAoCFunc = false;  // Array of char func, defined in <string.h>
+ public:
+  BaseNode *addrExpr;
+  BaseNode *rhs;
+};
+
+// goto and gosub
+class GotoNode : public StmtNode {
+ public:
+  explicit GotoNode(Opcode o) : StmtNode(o) {}
+
+  GotoNode(Opcode o, uint32 ofst) : StmtNode(o), offset(ofst) {}
+
+  virtual ~GotoNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  GotoNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *g = allocator.GetMemPool()->New<GotoNode>(*this);
+    g->SetStmtID(stmtIDNext++);
+    return g;
+  }
+
+  uint32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(uint32 o) {
+    offset = o;
+  }
+
+ private:
+  uint32 offset = 0;
+};
+
+// jstry
+class JsTryNode : public StmtNode {
+ public:
+  JsTryNode() : StmtNode(OP_jstry) {}
+
+  JsTryNode(uint16 catchofst, uint16 finallyofset)
+      : StmtNode(OP_jstry), catchOffset(catchofst), finallyOffset(finallyofset) {}
+
+  virtual ~JsTryNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  JsTryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *t = allocator.GetMemPool()->New<JsTryNode>(*this);
+    t->SetStmtID(stmtIDNext++);
+    return t;
+  }
+
+  uint16 GetCatchOffset() const {
+    return catchOffset;
+  }
+
+  void SetCatchOffset(uint32 offset) {
+    catchOffset = offset;
+  }
+
+  uint16 GetFinallyOffset() const {
+    return finallyOffset;
+  }
+
+  void SetFinallyOffset(uint32 offset) {
+    finallyOffset = offset;
+  }
+
+ private:
+  uint16 catchOffset = 0;
+  uint16 finallyOffset = 0;
+};
+
+// try, cpptry
+class TryNode : public StmtNode {
+ public:
+  explicit TryNode(MapleAllocator &allocator) : StmtNode(OP_try), offsets(allocator.Adapter()) {}
+
+  explicit TryNode(const MapleVector<LabelIdx> &offsets) : StmtNode(OP_try), offsets(offsets) {}
+
+  explicit TryNode(const MIRModule &mod) : TryNode(mod.GetCurFuncCodeMPAllocator()) {}
+
+  TryNode(TryNode &node) = delete;
+  TryNode &operator=(const TryNode &node) = delete;
+  virtual ~TryNode() = default;
+
+  using StmtNode::Dump;
+  void Dump(int32 indent) const override;
+
+  MapleVector<LabelIdx> &GetOffsets() {
+    return offsets;
+  }
+
+  LabelIdx GetOffset(size_t i) const {
+    ASSERT(i < offsets.size(), "array index out of range");
+    return offsets.at(i);
+  }
+
+  void SetOffset(LabelIdx offsetValue, size_t i) {
+    ASSERT(i < offsets.size(), "array index out of range");
+    offsets[i] = offsetValue;
+  }
+
+  void AddOffset(LabelIdx offsetValue) {
+    offsets.push_back(offsetValue);
+  }
+
+  void ResizeOffsets(size_t offsetSize) {
+    offsets.resize(offsetSize);
+  }
+
+  void SetOffsets(const MapleVector<LabelIdx> &offsetsValue) {
+    offsets = offsetsValue;
+  }
+
+  size_t GetOffsetsCount() const {
+    return offsets.size();
+  }
+
+  MapleVector<LabelIdx>::iterator GetOffsetsBegin() {
+    return offsets.begin();
+  }
+
+  MapleVector<LabelIdx>::iterator GetOffsetsEnd() {
+    return offsets.end();
+  }
+
+  void OffsetsInsert(MapleVector<LabelIdx>::iterator a, MapleVector<LabelIdx>::iterator b,
+                     MapleVector<LabelIdx>::iterator c) {
+    (void)offsets.insert(a, b, c);
+  }
+
+  TryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<TryNode>(allocator);
+    node->SetStmtID(stmtIDNext++);
+    for (size_t i = 0; i < offsets.size(); ++i) {
+      node->AddOffset(offsets[i]);
+    }
+    return node;
+  }
+
+ private:
+  MapleVector<LabelIdx> offsets;
+};
+
+// catch
+class CatchNode : public StmtNode {
+ public:
+  explicit CatchNode(MapleAllocator &allocator) : StmtNode(OP_catch), exceptionTyIdxVec(allocator.Adapter()) {}
+
+  explicit CatchNode(const MapleVector<TyIdx> &tyIdxVec) : StmtNode(OP_catch), exceptionTyIdxVec(tyIdxVec) {}
+
+  explicit CatchNode(const MIRModule &mod) : CatchNode(mod.GetCurFuncCodeMPAllocator()) {}
+
+  CatchNode(CatchNode &node) = delete;
+  CatchNode &operator=(const CatchNode &node) = delete;
+  virtual ~CatchNode() = default;
+
+  using StmtNode::Dump;
+  void Dump(int32 indent) const override;
+
+  TyIdx GetExceptionTyIdxVecElement(size_t i) const {
+    CHECK_FATAL(i < exceptionTyIdxVec.size(), "array index out of range");
+    return exceptionTyIdxVec[i];
+  }
+
+  const MapleVector<TyIdx> &GetExceptionTyIdxVec() const {
+    return exceptionTyIdxVec;
+  }
+
+  size_t Size() const {
+    return exceptionTyIdxVec.size();
+  }
+
+  void SetExceptionTyIdxVecElement(TyIdx idx, size_t i) {
+    CHECK_FATAL(i < exceptionTyIdxVec.size(), "array index out of range");
+    exceptionTyIdxVec[i] = idx;
+  }
+
+  void SetExceptionTyIdxVec(MapleVector<TyIdx> vec) {
+    exceptionTyIdxVec = vec;
+  }
+
+  void PushBack(TyIdx idx) {
+    exceptionTyIdxVec.push_back(idx);
+  }
+
+  CatchNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<CatchNode>(allocator);
+    node->SetStmtID(stmtIDNext++);
+    for (size_t i = 0; i < Size(); ++i) {
+      node->PushBack(GetExceptionTyIdxVecElement(i));
+    }
+    return node;
+  }
+
+ private:
+  MapleVector<TyIdx> exceptionTyIdxVec;
+};
+
+// cppcatch
+class CppCatchNode : public StmtNode {
+ public:
+  explicit CppCatchNode(const TyIdx &idx) : StmtNode(OP_cppcatch), exceptionTyIdx(idx) {}
+  explicit CppCatchNode() : CppCatchNode(TyIdx(0)) {}
+
+  explicit CppCatchNode(const CppCatchNode &node) = delete;
+  CppCatchNode &operator=(const CppCatchNode &node) = delete;
+  ~CppCatchNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  CppCatchNode *CloneTree(MapleAllocator &allocator) const override {
+    CppCatchNode *node = allocator.GetMemPool()->New<CppCatchNode>();
+    node->SetStmtID(stmtIDNext++);
+    node->exceptionTyIdx = exceptionTyIdx;
+    return node;
+  }
+
+  CppCatchNode *CloneTree(const MIRModule &mod) const {
+    return CppCatchNode::CloneTree(*mod.CurFuncCodeMemPoolAllocator());
+  }
+
+ public:
+  TyIdx exceptionTyIdx;
+};
+
+using CasePair = std::pair<int64, LabelIdx>;
+using CaseVector = MapleVector<CasePair>;
+class SwitchNode : public StmtNode {
+ public:
+  explicit SwitchNode(MapleAllocator &allocator) : StmtNode(OP_switch, 1), switchTable(allocator.Adapter()) {}
+
+  explicit SwitchNode(const MIRModule &mod) : SwitchNode(mod.GetCurFuncCodeMPAllocator()) {}
+
+  SwitchNode(MapleAllocator &allocator, LabelIdx label) : SwitchNode(allocator, label, nullptr) {}
+
+  SwitchNode(MapleAllocator &allocator, LabelIdx label, BaseNode *opnd)
+      : StmtNode(OP_switch, 1), switchOpnd(opnd), defaultLabel(label), switchTable(allocator.Adapter()) {}
+
+  SwitchNode(const MIRModule &mod, LabelIdx label) : SwitchNode(mod.GetCurFuncCodeMPAllocator(), label) {}
+
+  SwitchNode(MapleAllocator &allocator, const SwitchNode &node)
+      : StmtNode(node.GetOpCode(), node.GetPrimType(), node.numOpnds),
+        defaultLabel(node.GetDefaultLabel()),
+        switchTable(allocator.Adapter()) {}
+
+  SwitchNode(const MIRModule &mod, const SwitchNode &node) : SwitchNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  SwitchNode(SwitchNode &node) = delete;
+  SwitchNode &operator=(const SwitchNode &node) = delete;
+  virtual ~SwitchNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  SwitchNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<SwitchNode>(allocator, *this);
+    node->SetSwitchOpnd(switchOpnd->CloneTree(allocator));
+    for (size_t i = 0; i < switchTable.size(); ++i) {
+      node->InsertCasePair(switchTable[i]);
+    }
+    return node;
+  }
+
+  BaseNode *Opnd(size_t) const override {
+    return switchOpnd;
+  }
+
+  void SetOpnd(BaseNode *node, size_t) override {
+    switchOpnd = node;
+  }
+
+  BaseNode *GetSwitchOpnd() const {
+    return switchOpnd;
+  }
+
+  void SetSwitchOpnd(BaseNode *node) {
+    switchOpnd = node;
+  }
+
+  LabelIdx GetDefaultLabel() const {
+    return defaultLabel;
+  }
+
+  void SetDefaultLabel(LabelIdx idx) {
+    defaultLabel = idx;
+  }
+
+  const CaseVector &GetSwitchTable() const {
+    return switchTable;
+  }
+
+  CaseVector &GetSwitchTable() {
+    return switchTable;
+  }
+
+  CasePair GetCasePair(size_t idx) const {
+    ASSERT(idx < switchTable.size(), "out of range in SwitchNode::GetCasePair");
+    return switchTable.at(idx);
+  }
+
+  void SetSwitchTable(CaseVector vec) {
+    switchTable = vec;
+  }
+
+  void InsertCasePair(CasePair pair) {
+    switchTable.push_back(pair);
+  }
+
+  void UpdateCaseLabelAt(size_t i, LabelIdx idx) {
+    switchTable[i] = std::make_pair(switchTable[i].first, idx);
+  }
+
+  void SortCasePair(bool func(const CasePair&, const CasePair&)) {
+    std::sort(switchTable.begin(), switchTable.end(), func);
+  }
+
+ private:
+  BaseNode *switchOpnd = nullptr;
+  LabelIdx defaultLabel = 0;
+  CaseVector switchTable;
+};
+
+using MCasePair = std::pair<BaseNode*, LabelIdx>;
+using MCaseVector = MapleVector<MCasePair>;
+class MultiwayNode : public StmtNode {
+ public:
+  explicit MultiwayNode(MapleAllocator &allocator) : StmtNode(OP_multiway, 1), multiWayTable(allocator.Adapter()) {}
+
+  explicit MultiwayNode(const MIRModule &mod) : MultiwayNode(mod.GetCurFuncCodeMPAllocator()) {}
+
+  MultiwayNode(MapleAllocator &allocator, LabelIdx label)
+      : StmtNode(OP_multiway, 1), defaultLabel(label), multiWayTable(allocator.Adapter()) {}
+
+  MultiwayNode(const MIRModule &mod, LabelIdx label) : MultiwayNode(mod.GetCurFuncCodeMPAllocator(), label) {}
+
+  MultiwayNode(MapleAllocator &allocator, const MultiwayNode &node)
+      : StmtNode(node.GetOpCode(), node.GetPrimType(), node.numOpnds, node.GetSrcPos(), node.GetOriginalID(),
+                 node.GetStmtAttrs()),
+        defaultLabel(node.defaultLabel),
+        multiWayTable(allocator.Adapter()) {}
+
+  MultiwayNode(const MIRModule &mod, const MultiwayNode &node) : MultiwayNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  MultiwayNode(MultiwayNode &node) = delete;
+  MultiwayNode &operator=(const MultiwayNode &node) = delete;
+  virtual ~MultiwayNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  MultiwayNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<MultiwayNode>(allocator, *this);
+    nd->multiWayOpnd = static_cast<BaseNode*>(multiWayOpnd->CloneTree(allocator));
+    for (size_t i = 0; i < multiWayTable.size(); ++i) {
+      BaseNode *node = multiWayTable[i].first->CloneTree(allocator);
+      MCasePair pair(static_cast<BaseNode*>(node), multiWayTable[i].second);
+      nd->multiWayTable.push_back(pair);
+    }
+    return nd;
+  }
+
+  BaseNode *Opnd(size_t i) const override {
+    return *(&multiWayOpnd + static_cast<uint32>(i));
+  }
+
+  const BaseNode *GetMultiWayOpnd() const {
+    return multiWayOpnd;
+  }
+
+  void SetMultiWayOpnd(BaseNode *multiwayOpndPara) {
+    multiWayOpnd = multiwayOpndPara;
+  }
+
+  void SetDefaultlabel(LabelIdx defaultLabelPara) {
+    defaultLabel = defaultLabelPara;
+  }
+
+  void AppendElemToMultiWayTable(const MCasePair &mCasrPair) {
+    multiWayTable.push_back(mCasrPair);
+  }
+
+  const MCaseVector &GetMultiWayTable() const {
+    return multiWayTable;
+  }
+
+ private:
+  BaseNode *multiWayOpnd = nullptr;
+  LabelIdx defaultLabel = 0;
+  MCaseVector multiWayTable;
+};
+
+// eval, throw, free, decref, incref, decrefreset, assertnonnull, igoto
+class UnaryStmtNode : public StmtNode {
+ public:
+  explicit UnaryStmtNode(Opcode o) : StmtNode(o, 1) {}
+
+  UnaryStmtNode(Opcode o, PrimType typ) : StmtNode(o, typ, 1) {}
+
+  UnaryStmtNode(Opcode o, PrimType typ, BaseNode *opnd) : StmtNode(o, typ, 1), uOpnd(opnd) {}
+
+  virtual ~UnaryStmtNode() = default;
+
+  using StmtNode::Dump;
+  void Dump(int32 indent) const override;
+  void DumpOpnd(const MIRModule &mod, int32 indent) const;
+  void DumpOpnd(int32 indent) const;
+
+  bool Verify() const override {
+    return uOpnd->Verify();
+  }
+
+  bool Verify(VerifyResult &verifyResult) const override {
+    if (GetOpCode() == OP_throw && !VerifyThrowable(verifyResult)) {
+      return false;
+    }
+    return uOpnd->Verify(verifyResult);
+  }
+
+  UnaryStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<UnaryStmtNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(uOpnd->CloneTree(allocator), 0);
+    return node;
+  }
+
+  bool IsLeaf() const override {
+    return false;
+  }
+
+  BaseNode *GetRHS() const override {
+    return Opnd(0);
+  }
+
+  virtual void SetRHS(BaseNode *rhs) {
+    this->SetOpnd(rhs, 0);
+  }
+
+  BaseNode *Opnd(size_t i = 0) const override {
+    (void)i;
+    return uOpnd;
+  }
+
+  void SetOpnd(BaseNode *node, size_t) override {
+    uOpnd = node;
+  }
+
+ private:
+  bool VerifyThrowable(VerifyResult &verifyResult) const;
+  BaseNode *uOpnd = nullptr;
+};
+
+// dassign, maydassign
+class DassignNode : public UnaryStmtNode {
+ public:
+  DassignNode() : UnaryStmtNode(OP_dassign), stIdx() {}
+
+  explicit DassignNode(PrimType typ) : UnaryStmtNode(OP_dassign, typ), stIdx() {}
+
+  DassignNode(PrimType typ, BaseNode *opnd) : UnaryStmtNode(OP_dassign, typ, opnd), stIdx() {}
+
+  DassignNode(PrimType typ, BaseNode *opnd, StIdx idx, FieldID fieldID)
+      : UnaryStmtNode(OP_dassign, typ, opnd), stIdx(idx), fieldID(fieldID) {}
+
+  DassignNode(BaseNode *opnd, StIdx idx, FieldID fieldID) : DassignNode(kPtyInvalid, opnd, idx, fieldID) {}
+
+  virtual ~DassignNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  DassignNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<DassignNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  size_t NumOpnds() const override {
+    return 1;
+  }
+
+  bool IsIdentityDassign() const {
+    BaseNode *rhs = GetRHS();
+    if (rhs->GetOpCode() != OP_dread) {
+      return false;
+    }
+    auto *dread = static_cast<AddrofNode*>(rhs);
+    return (stIdx == dread->GetStIdx());
+  }
+
+  BaseNode *GetRHS() const override {
+    return UnaryStmtNode::GetRHS();
+  }
+
+  void SetRHS(BaseNode *rhs) override {
+    UnaryStmtNode::SetOpnd(rhs, 0);
+  }
+
+  StIdx GetStIdx() const {
+    return stIdx;
+  }
+  void SetStIdx(StIdx s) {
+    stIdx = s;
+  }
+
+  const FieldID &GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(FieldID f) {
+    fieldID = f;
+  }
+
+  bool AssigningVolatile(const MIRModule &mod) const;
+
+ private:
+  StIdx stIdx;
+  FieldID fieldID = 0;
+};
+
+class DassignoffNode : public UnaryStmtNode {
+ public:
+  DassignoffNode() : UnaryStmtNode(OP_dassignoff), stIdx() {}
+
+  explicit DassignoffNode(PrimType typ) : UnaryStmtNode(OP_dassignoff, typ), stIdx() {}
+
+  DassignoffNode(PrimType typ, BaseNode *opnd) : UnaryStmtNode(OP_dassignoff, typ, opnd), stIdx() {}
+
+  DassignoffNode(const StIdx &lhsStIdx, int32 dOffset, PrimType rhsType, BaseNode *rhsNode)
+      : DassignoffNode(rhsType, rhsNode) {
+    stIdx = lhsStIdx;
+    offset = dOffset;
+  }
+  virtual ~DassignoffNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  DassignoffNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<DassignoffNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  size_t NumOpnds() const override {
+    return 1;
+  }
+
+  BaseNode *GetRHS() const override {
+    return UnaryStmtNode::GetRHS();
+  }
+
+  void SetRHS(BaseNode *rhs) override {
+    UnaryStmtNode::SetOpnd(rhs, 0);
+  }
+
+ public:
+  StIdx stIdx;
+  int32 offset = 0;
+};
+
+class RegassignNode : public UnaryStmtNode {
+ public:
+  RegassignNode() : UnaryStmtNode(OP_regassign) {}
+
+  RegassignNode(PrimType primType, PregIdx idx, BaseNode *opnd)
+      : UnaryStmtNode(OP_regassign, primType, opnd), regIdx(idx) {}
+
+  virtual ~RegassignNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  RegassignNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<RegassignNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  BaseNode *GetRHS() const override {
+    return UnaryStmtNode::GetRHS();
+  }
+
+  void SetRHS(BaseNode *rhs) override {
+    UnaryStmtNode::SetOpnd(rhs, 0);
+  }
+
+  PregIdx GetRegIdx() const {
+    return regIdx;
+  }
+  void SetRegIdx(PregIdx idx) {
+    regIdx = idx;
+  }
+
+ private:
+  PregIdx regIdx = 0;  // 32bit, negative if special register
+};
+
+// brtrue and brfalse
+class CondGotoNode : public UnaryStmtNode {
+ public:
+  static const int32 probAll;
+  explicit CondGotoNode(Opcode o) : CondGotoNode(o, 0, nullptr) {}
+
+  CondGotoNode(Opcode o, uint32 offset, BaseNode *opnd) : UnaryStmtNode(o, kPtyInvalid, opnd), offset(offset) {
+    BaseNodeT::SetNumOpnds(kOperandNumUnary);
+  }
+
+  virtual ~CondGotoNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  uint32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(uint32 offsetValue) {
+    offset = offsetValue;
+  }
+
+  bool IsBranchProbValid() const {
+    return branchProb > 0 && branchProb < probAll;
+  }
+
+  int32 GetBranchProb() const {
+    return branchProb;
+  }
+
+  void SetBranchProb(int32 prob) {
+    branchProb = prob;
+  }
+
+  void ReverseBranchProb() {
+    if (IsBranchProbValid()) {
+      branchProb = probAll - branchProb;
+    }
+  }
+
+  void InvalidateBranchProb() {
+    if (IsBranchProbValid()) {
+      branchProb = -1;
+    }
+  }
+
+  CondGotoNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<CondGotoNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+ private:
+  uint32 offset;
+  int32 branchProb = -1;  // branch probability, a negative number indicates that the probability is invalid
+};
+
+using SmallCasePair = std::pair<uint16, uint32>;
+using SmallCaseVector = MapleVector<SmallCasePair>;
+class RangeGotoNode : public UnaryStmtNode {
+ public:
+  explicit RangeGotoNode(MapleAllocator &allocator)
+      : UnaryStmtNode(OP_rangegoto), rangegotoTable(allocator.Adapter()) {}
+
+  explicit RangeGotoNode(const MIRModule &mod) : RangeGotoNode(mod.GetCurFuncCodeMPAllocator()) {}
+
+  RangeGotoNode(MapleAllocator &allocator, const RangeGotoNode &node)
+      : UnaryStmtNode(node), tagOffset(node.tagOffset), rangegotoTable(allocator.Adapter()) {}
+
+  RangeGotoNode(const MIRModule &mod, const RangeGotoNode &node)
+      : RangeGotoNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  RangeGotoNode(RangeGotoNode &node) = delete;
+  RangeGotoNode &operator=(const RangeGotoNode &node) = delete;
+  virtual ~RangeGotoNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+  RangeGotoNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<RangeGotoNode>(allocator, *this);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    for (size_t i = 0; i < rangegotoTable.size(); ++i) {
+      node->rangegotoTable.push_back(rangegotoTable[i]);
+    }
+    return node;
+  }
+
+  const SmallCaseVector &GetRangeGotoTable() const {
+    return rangegotoTable;
+  }
+
+  const SmallCasePair &GetRangeGotoTableItem(size_t i) const {
+    return rangegotoTable.at(i);
+  }
+
+  void SetRangeGotoTable(SmallCaseVector rt) {
+    rangegotoTable = rt;
+  }
+
+  void AddRangeGoto(uint32 tag, LabelIdx idx) {
+    rangegotoTable.push_back(SmallCasePair(tag, idx));
+  }
+
+  int32 GetTagOffset() const {
+    return tagOffset;
+  }
+
+  void SetTagOffset(int32 offset) {
+    tagOffset = offset;
+  }
+
+ private:
+  int32 tagOffset = 0;
+  // add each tag to tagOffset field to get the actual tag values
+  SmallCaseVector rangegotoTable;
+};
+
+class BlockNode : public StmtNode {
+ public:
+  using StmtNodes = PtrListRef<StmtNode>;
+
+  BlockNode() : StmtNode(OP_block) {}
+
+  ~BlockNode() override {
+    stmtNodeList.clear();
+  }
+
+  void AddStatement(StmtNode *stmt);
+  void AppendStatementsFromBlock(BlockNode &blk);
+  void InsertFirst(StmtNode *stmt);  // Insert stmt as the first
+  void InsertLast(StmtNode *stmt);   // Insert stmt as the last
+  void ReplaceStmtWithBlock(StmtNode &stmtNode, BlockNode &blk);
+  void ReplaceStmt1WithStmt2(const StmtNode *stmtNode1, StmtNode *stmtNode2);
+  void RemoveStmt(const StmtNode *stmtNode1);
+  void InsertBefore(const StmtNode *stmtNode1, StmtNode *stmtNode2);  // Insert ss2 before ss1 in current block.
+  void InsertAfter(const StmtNode *stmtNode1, StmtNode *stmtNode2);   // Insert ss2 after ss1 in current block.
+  // insert all the stmts in inblock to the current block after stmt1
+  void InsertBlockAfter(BlockNode &inblock, const StmtNode *stmt1);
+  void Dump(int32 indent, const MIRSymbolTable *theSymTab, MIRPregTable *thePregTab, bool withInfo, bool isFuncbody,
+            MIRFlavor flavor) const;
+  bool Verify() const override;
+  bool Verify(VerifyResult &verifyResult) const override;
+
+  void Dump(int32 indent) const override {
+    Dump(indent, nullptr, nullptr, false, false, kFlavorUnknown);
+  }
+
+  BlockNode *CloneTree(MapleAllocator &allocator) const override;
+
+  BlockNode *CloneTreeWithSrcPosition(const MIRModule &mod, const GStrIdx &idx = GStrIdx(), bool setInlinedPos = false,
+                                      const SrcPosition &inlinedPosition = SrcPosition());
+
+  BlockNode *CloneTreeWithFreqs(MapleAllocator &allocator, std::unordered_map<uint32_t, uint64_t> &toFreqs,
+                                std::unordered_map<uint32_t, uint64_t> &fromFreqs, uint64_t numer, uint64_t denom,
+                                uint32_t updateOp);
+
+  bool IsEmpty() const {
+    return stmtNodeList.empty();
+  }
+
+  void ResetBlock() {
+    stmtNodeList.clear();
+  }
+
+  StmtNode *GetFirst() {
+    return &(stmtNodeList.front());
+  }
+
+  const StmtNode *GetFirst() const {
+    return &(stmtNodeList.front());
+  }
+
+  void SetFirst(StmtNode *node) {
+    stmtNodeList.update_front(node);
+  }
+
+  StmtNode *GetLast() {
+    return &(stmtNodeList.back());
+  }
+
+  const StmtNode *GetLast() const {
+    return &(stmtNodeList.back());
+  }
+
+  void SetLast(StmtNode *node) {
+    stmtNodeList.update_back(node);
+  }
+
+  StmtNodes &GetStmtNodes() {
+    return stmtNodeList;
+  }
+
+  const StmtNodes &GetStmtNodes() const {
+    return stmtNodeList;
+  }
+
+ private:
+  StmtNodes stmtNodeList;
+};
+
+struct CallBackData {
+ public:
+  virtual ~CallBackData() {}
+  virtual void Free() {}
+};
+
+using CallBack = void (*)(const BlockNode &oldBlock, BlockNode &newBlock,
+                          const StmtNode &oldStmt, StmtNode &newStmt, CallBackData *data);
+
+class BlockCallBack {
+ public:
+  BlockCallBack(CallBack hook, CallBackData *callBackData) : callBack(hook), data(callBackData) {}
+
+  ~BlockCallBack() {
+    if (data != nullptr) {
+      data->Free();
+    }
+  }
+
+  void Invoke(const BlockNode &oldBlock, BlockNode &newBlock,
+      const StmtNode &oldStmt, StmtNode &newStmt) {
+    if (callBack != nullptr) {
+      callBack(oldBlock, newBlock, oldStmt, newStmt, data);
+    }
+  }
+
+  CallBack GetCallBack() const {
+    return callBack;
+  }
+
+ private:
+  CallBack callBack;
+  CallBackData *data = nullptr;
+};
+
+class BlockCallBackMgr {
+ public:
+  static void AddCallBack(CallBack hook, CallBackData *data) {
+    auto *node = new BlockCallBack(hook, data);
+    callBackList.push_back(node);
+  }
+
+  static void RemoveCallBack(CallBack hook) {
+    for (auto it = callBackList.begin(); it != callBackList.end(); ++it) {
+      auto *node = *it;
+      if (node->GetCallBack() == hook) {
+        delete node;
+        callBackList.erase(it);
+        return;
+      }
+    }
+  }
+
+  static void ClearCallBacks() {
+    for (auto *node : callBackList) {
+      delete node;
+    }
+    callBackList.clear();
+  }
+
+  static void InvokeCallBacks(const BlockNode &oldBlock, BlockNode &newBlock,
+      const StmtNode &oldStmt, StmtNode &newStmt) {
+    for (auto *node : callBackList) {
+      node->Invoke(oldBlock, newBlock, oldStmt, newStmt);
+    }
+  }
+
+ private:
+  static std::list<BlockCallBack*> callBackList;
+};
+
+class IfStmtNode : public UnaryStmtNode {
+ public:
+  IfStmtNode() : UnaryStmtNode(OP_if) {
+    numOpnds = kOperandNumTernary;
+  }
+
+  virtual ~IfStmtNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  IfStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<IfStmtNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd()->CloneTree(allocator), 0);
+    node->thenPart = thenPart->CloneTree(allocator);
+    if (elsePart != nullptr) {
+      node->elsePart = elsePart->CloneTree(allocator);
+    }
+    node->SetMeStmtID(GetMeStmtID());
+    return node;
+  }
+
+  IfStmtNode *CloneTreeWithFreqs(MapleAllocator &allocator, std::unordered_map<uint32_t, uint64_t> &toFreqs,
+                                 std::unordered_map<uint32_t, uint64_t> &fromFreqs, uint64_t numer, uint64_t denom,
+                                 uint32_t updateOp) {
+    auto *node = allocator.GetMemPool()->New<IfStmtNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd()->CloneTree(allocator), 0);
+    if (fromFreqs.count(GetStmtID()) > 0) {
+      uint64_t oldFreq = fromFreqs[GetStmtID()];
+      uint64_t newFreq = numer == 0 ? 0 : (denom > 0 ? (oldFreq * numer / denom) : oldFreq);
+      toFreqs[node->GetStmtID()] = (newFreq > 0 || numer == 0) ? newFreq : 1;
+      if (updateOp & kUpdateOrigFreq) {
+        uint64_t left = ((oldFreq - newFreq) > 0 || oldFreq == 0) ? (oldFreq - newFreq) : 1;
+        fromFreqs[GetStmtID()] = left;
+      }
+    }
+    node->thenPart = thenPart->CloneTreeWithFreqs(allocator, toFreqs, fromFreqs, numer, denom, updateOp);
+    if (elsePart != nullptr) {
+      node->elsePart = elsePart->CloneTreeWithFreqs(allocator, toFreqs, fromFreqs, numer, denom, updateOp);
+    }
+    node->SetMeStmtID(GetMeStmtID());
+    return node;
+  }
+
+  BaseNode *Opnd(size_t i = 0) const override {
+    if (i == 0) {
+      return UnaryStmtNode::Opnd(0);
+    } else if (i == 1) {
+      return thenPart;
+    } else if (i == 2) {
+      ASSERT(elsePart != nullptr, "IfStmtNode has wrong numOpnds field, the elsePart is nullptr");
+      ASSERT(numOpnds == kOperandNumTernary, "IfStmtNode has wrong numOpnds field, the elsePart is nullptr");
+      return elsePart;
+    }
+    ASSERT(false, "IfStmtNode has wrong numOpnds field: %u", NumOpnds());
+    return nullptr;
+  }
+
+  BlockNode *GetThenPart() const {
+    return thenPart;
+  }
+
+  void SetThenPart(BlockNode *node) {
+    thenPart = node;
+  }
+
+  BlockNode *GetElsePart() const {
+    return elsePart;
+  }
+
+  void SetElsePart(BlockNode *node) {
+    elsePart = node;
+  }
+
+  size_t NumOpnds() const override {
+    if (elsePart == nullptr) {
+      return kOperandNumBinary;
+    }
+    return kOperandNumTernary;
+  }
+
+ private:
+  BlockNode *thenPart = nullptr;
+  BlockNode *elsePart = nullptr;
+};
+
+// for both while and dowhile
+class WhileStmtNode : public UnaryStmtNode {
+ public:
+  explicit WhileStmtNode(Opcode o) : UnaryStmtNode(o) {
+    BaseNodeT::SetNumOpnds(kOperandNumBinary);
+  }
+
+  virtual ~WhileStmtNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  WhileStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<WhileStmtNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    node->body = body->CloneTree(allocator);
+    return node;
+  }
+
+  WhileStmtNode *CloneTreeWithFreqs(MapleAllocator &allocator, std::unordered_map<uint32_t, uint64_t> &toFreqs,
+                                    std::unordered_map<uint32_t, uint64_t> &fromFreqs, uint64_t numer, uint64_t denom,
+                                    uint32_t updateOp) {
+    auto *node = allocator.GetMemPool()->New<WhileStmtNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    if (fromFreqs.count(GetStmtID()) > 0) {
+      int64_t oldFreq = fromFreqs[GetStmtID()];
+      int64_t newFreq =
+          numer == 0 ? 0 : (denom > 0 ? static_cast<int64_t>(static_cast<uint64_t>(oldFreq) * numer / denom) : oldFreq);
+      toFreqs[node->GetStmtID()] = (newFreq > 0 || numer == 0) ? static_cast<uint64_t>(newFreq) : 1;
+      if (updateOp & kUpdateOrigFreq) {
+        int64_t left = (oldFreq - newFreq) > 0 ? (oldFreq - newFreq) : 1;
+        fromFreqs[GetStmtID()] = static_cast<uint64_t>(left);
+      }
+    }
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    node->body = body->CloneTreeWithFreqs(allocator, toFreqs, fromFreqs, numer, denom, updateOp);
+    return node;
+  }
+
+  void SetBody(BlockNode *node) {
+    body = node;
+  }
+
+  BlockNode *GetBody() const {
+    return body;
+  }
+
+  BaseNode *Opnd(size_t i = 0) const override {
+    if (i == 0) {
+      return UnaryStmtNode::Opnd();
+    } else if (i == 1) {
+      return body;
+    }
+    ASSERT(false, "WhileStmtNode has wrong numOpnds field: %u", NumOpnds());
+    return nullptr;
+  }
+
+ private:
+  BlockNode *body = nullptr;
+};
+
+class DoloopNode : public StmtNode {
+ public:
+  DoloopNode() : DoloopNode(StIdx(), false, nullptr, nullptr, nullptr, nullptr) {}
+
+  DoloopNode(StIdx doVarStIdx, bool isPReg, BaseNode *startExp, BaseNode *contExp, BaseNode *incrExp, BlockNode *doBody)
+      : StmtNode(OP_doloop, kOperandNumDoloop),
+        doVarStIdx(doVarStIdx),
+        isPreg(isPReg),
+        startExpr(startExp),
+        condExpr(contExp),
+        incrExpr(incrExp),
+        doBody(doBody) {}
+
+  virtual ~DoloopNode() = default;
+
+  void DumpDoVar(const MIRModule &mod) const;
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  DoloopNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<DoloopNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetStartExpr(startExpr->CloneTree(allocator));
+    node->SetContExpr(GetCondExpr()->CloneTree(allocator));
+    node->SetIncrExpr(GetIncrExpr()->CloneTree(allocator));
+    node->SetDoBody(GetDoBody()->CloneTree(allocator));
+    return node;
+  }
+
+  DoloopNode *CloneTreeWithFreqs(MapleAllocator &allocator, std::unordered_map<uint32_t, uint64_t> &toFreqs,
+                                 std::unordered_map<uint32_t, uint64_t> &fromFreqs, uint64_t numer, uint64_t denom,
+                                 uint32_t updateOp) {
+    auto *node = allocator.GetMemPool()->New<DoloopNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    if (fromFreqs.count(GetStmtID()) > 0) {
+      uint64_t oldFreq = fromFreqs[GetStmtID()];
+      uint64_t newFreq = oldFreq;
+      if ((updateOp & kUpdateFreqbyScale) != 0) {  // used in inline/clone
+        newFreq = numer == 0 ? 0 : (denom > 0 ? (oldFreq * numer / denom) : oldFreq);
+      } else if ((updateOp & kUpdateUnrolledFreq) != 0) {  // used in unrolled part
+        uint64_t bodyFreq = fromFreqs[GetDoBody()->GetStmtID()];
+        newFreq = denom > 0 ? (bodyFreq * numer / denom + (oldFreq - bodyFreq)) : oldFreq;
+      } else if ((updateOp & kUpdateUnrollRemainderFreq) != 0) {  // used in unrolled remainder
+        uint64_t bodyFreq = fromFreqs[GetDoBody()->GetStmtID()];
+        newFreq = denom > 0 ? (((bodyFreq * numer) % denom) + (oldFreq - bodyFreq)) : oldFreq;
+      }
+      toFreqs[node->GetStmtID()] = static_cast<uint64_t>(newFreq);
+      ASSERT(oldFreq >= newFreq, "sanity check");
+      if ((updateOp & kUpdateOrigFreq) != 0) {
+        uint64_t left = oldFreq - newFreq;
+        fromFreqs[GetStmtID()] = left;
+      }
+    }
+    node->SetStartExpr(startExpr->CloneTree(allocator));
+    node->SetContExpr(GetCondExpr()->CloneTree(allocator));
+    node->SetIncrExpr(GetIncrExpr()->CloneTree(allocator));
+    node->SetDoBody(GetDoBody()->CloneTreeWithFreqs(allocator, toFreqs, fromFreqs, numer, denom, updateOp));
+    return node;
+  }
+
+  void SetDoVarStIdx(StIdx idx) {
+    doVarStIdx = idx;
+  }
+
+  PregIdx GetDoVarPregIdx() const {
+    return static_cast<PregIdx>(doVarStIdx.FullIdx());
+  }
+
+  const StIdx &GetDoVarStIdx() const {
+    return doVarStIdx;
+  }
+
+  void SetDoVarStFullIdx(uint32 idx) {
+    doVarStIdx.SetFullIdx(idx);
+  }
+
+  void SetIsPreg(bool isPregVal) {
+    isPreg = isPregVal;
+  }
+
+  bool IsPreg() const {
+    return isPreg;
+  }
+
+  void SetStartExpr(BaseNode *node) {
+    startExpr = node;
+  }
+
+  BaseNode *GetStartExpr() const {
+    return startExpr;
+  }
+
+  void SetContExpr(BaseNode *node) {
+    condExpr = node;
+  }
+
+  BaseNode *GetCondExpr() const {
+    return condExpr;
+  }
+
+  void SetIncrExpr(BaseNode *node) {
+    incrExpr = node;
+  }
+
+  BaseNode *GetIncrExpr() const {
+    return incrExpr;
+  }
+
+  void SetDoBody(BlockNode *node) {
+    doBody = node;
+  }
+
+  BlockNode *GetDoBody() const {
+    return doBody;
+  }
+
+  BaseNode *Opnd(size_t i) const override {
+    if (i == 0) {
+      return startExpr;
+    }
+    if (i == 1) {
+      return condExpr;
+    }
+    if (i == 2) {
+      return incrExpr;
+    }
+    return *(&doBody + i - 3);
+  }
+
+  size_t NumOpnds() const override {
+    return kOperandNumDoloop;
+  }
+
+  void SetOpnd(BaseNode *node, size_t i) override {
+    if (i == 0) {
+      startExpr = node;
+    }
+    if (i == 1) {
+      SetContExpr(node);
+    }
+    if (i == 2) {
+      incrExpr = node;
+    } else {
+      *(&doBody + i - 3) = static_cast<BlockNode*>(node);
+    }
+  }
+
+ private:
+  static constexpr int kOperandNumDoloop = 4;
+  StIdx doVarStIdx;  // must be local; cast to PregIdx for preg
+  bool isPreg;
+  BaseNode *startExpr;
+  BaseNode *condExpr;
+  BaseNode *incrExpr;
+  BlockNode *doBody;
+};
+
+class ForeachelemNode : public StmtNode {
+ public:
+  ForeachelemNode() : StmtNode(OP_foreachelem) {
+    BaseNodeT::SetNumOpnds(kOperandNumUnary);
+  }
+
+  virtual ~ForeachelemNode() = default;
+
+  const StIdx &GetElemStIdx() const {
+    return elemStIdx;
+  }
+
+  void SetElemStIdx(StIdx elemStIdxValue) {
+    elemStIdx = elemStIdxValue;
+  }
+
+  const StIdx &GetArrayStIdx() const {
+    return arrayStIdx;
+  }
+
+  void SetArrayStIdx(StIdx arrayStIdxValue) {
+    arrayStIdx = arrayStIdxValue;
+  }
+
+  BlockNode *GetLoopBody() const {
+    return loopBody;
+  }
+
+  void SetLoopBody(BlockNode *loopBodyValue) {
+    loopBody = loopBodyValue;
+  }
+
+  BaseNode *Opnd(size_t) const override {
+    return loopBody;
+  }
+
+  size_t NumOpnds() const override {
+    return numOpnds;
+  }
+
+  void Dump(int32 indent) const override;
+
+  ForeachelemNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<ForeachelemNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetLoopBody(loopBody->CloneTree(allocator));
+    return node;
+  }
+
+ private:
+  StIdx elemStIdx;   // must be local symbol
+  StIdx arrayStIdx;  // symbol table entry of the array/collection variable
+  BlockNode *loopBody = nullptr;
+};
+
+// used by assertge, assertlt
+class BinaryStmtNode : public StmtNode, public BinaryOpnds {
+ public:
+  explicit BinaryStmtNode(Opcode o) : StmtNode(o, kOperandNumBinary) {}
+
+  virtual ~BinaryStmtNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+  BinaryStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<BinaryStmtNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
+    node->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
+    return node;
+  }
+
+  BaseNode *Opnd(size_t i) const override {
+    ASSERT(i < kOperandNumBinary, "Invalid operand idx in BinaryStmtNode");
+    ASSERT(i >= 0, "Invalid operand idx in BinaryStmtNode");
+    return GetBOpnd(i);
+  }
+
+  size_t NumOpnds() const override {
+    return kOperandNumBinary;
+  }
+
+  void SetOpnd(BaseNode *node, size_t i) override {
+    SetBOpnd(node, i);
+  }
+
+  bool IsLeaf() const override {
+    return false;
+  }
+};
+
+class IassignoffNode : public BinaryStmtNode {
+ public:
+  IassignoffNode() : BinaryStmtNode(OP_iassignoff) {}
+
+  explicit IassignoffNode(int32 ofst) : BinaryStmtNode(OP_iassignoff), offset(ofst) {}
+
+  IassignoffNode(PrimType primType, int32 offset, BaseNode *addrOpnd, BaseNode *srcOpnd) : IassignoffNode(offset) {
+    BaseNodeT::SetPrimType(primType);
+    SetBOpnd(addrOpnd, 0);
+    SetBOpnd(srcOpnd, 1);
+  }
+
+  virtual ~IassignoffNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  IassignoffNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<IassignoffNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
+    node->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
+    return node;
+  }
+
+  int32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(int32 newOffset) {
+    offset = newOffset;
+  }
+
+ private:
+  int32 offset = 0;
+};
+
+// for iassignfpoff, iassignspoff, iassignpcoff
+class IassignFPoffNode : public UnaryStmtNode {
+ public:
+  explicit IassignFPoffNode(Opcode o) : UnaryStmtNode(o) {}
+
+  explicit IassignFPoffNode(Opcode o, int32 ofst) : UnaryStmtNode(o), offset(ofst) {}
+
+  IassignFPoffNode(Opcode o, PrimType primType, int32 offset, BaseNode *src) : IassignFPoffNode(o, offset) {
+    BaseNodeT::SetPrimType(primType);
+    UnaryStmtNode::SetOpnd(src, 0);
+  }
+
+  virtual ~IassignFPoffNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  IassignFPoffNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<IassignFPoffNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
+    return node;
+  }
+
+  void SetOffset(int32 ofst) {
+    offset = ofst;
+  }
+
+  int32 GetOffset() const {
+    return offset;
+  }
+
+ private:
+  int32 offset = 0;
+};
+
+using IassignPCoffNode = IassignFPoffNode;
+
+class BlkassignoffNode : public BinaryStmtNode {
+ public:
+  BlkassignoffNode() : BinaryStmtNode(OP_blkassignoff) {
+    ptyp = PTY_agg;
+    ptyp = PTY_agg;
+    alignLog2 = 0;
+    offset = 0;
+  }
+  explicit BlkassignoffNode(int32 ofst, int32 bsize) : BinaryStmtNode(OP_blkassignoff), offset(ofst), blockSize(bsize) {
+    ptyp = PTY_agg;
+    alignLog2 = 0;
+  }
+  explicit BlkassignoffNode(int32 ofst, int32 bsize, BaseNode *dest, BaseNode *src)
+      : BinaryStmtNode(OP_blkassignoff), offset(ofst), blockSize(bsize) {
+    ptyp = PTY_agg;
+    alignLog2 = 0;
+    SetBOpnd(dest, 0);
+    SetBOpnd(src, 1);
+  }
+  ~BlkassignoffNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  BlkassignoffNode *CloneTree(MapleAllocator &allocator) const override {
+    BlkassignoffNode *node = allocator.GetMemPool()->New<BlkassignoffNode>(offset, blockSize);
+    node->SetStmtID(stmtIDNext++);
+    node->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
+    node->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
+    return node;
+  }
+
+  uint32 GetAlign() const {
+    uint32 res = 1;
+    for (uint32 i = 0; i < alignLog2; i++) {
+      res *= 2;
+    }
+    return res;
+  }
+
+  void SetAlign(uint32 x) {
+    if (x == 0) {
+      alignLog2 = 0;
+      return;
+    }
+    ASSERT((~(x - 1) & x) == x, "SetAlign called with non power of 2");
+    uint32 res = 0;
+    while (x != 1) {
+      x >>= 1;
+      ++res;
+    }
+    alignLog2 = res;
+  }
+
+  uint32 alignLog2 : 4;
+  int32 offset : 28;
+  int32 blockSize = 0;
+};
+
+// used by return, syncenter, syncexit
+class NaryStmtNode : public StmtNode, public NaryOpnds {
+ public:
+  NaryStmtNode(MapleAllocator &allocator, Opcode o) : StmtNode(o), NaryOpnds(allocator) {}
+
+  NaryStmtNode(const MIRModule &mod, Opcode o) : NaryStmtNode(mod.GetCurFuncCodeMPAllocator(), o) {}
+
+  NaryStmtNode(MapleAllocator &allocator, const NaryStmtNode &node)
+      // do not use stmt copy constructor
+      : StmtNode(node.GetOpCode(), node.GetPrimType(), node.numOpnds, node.GetSrcPos(), node.GetOriginalID(),
+                 node.GetStmtAttrs()),
+        NaryOpnds(allocator) {}
+
+  NaryStmtNode(const MIRModule &mod, const NaryStmtNode &node) : NaryStmtNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  explicit NaryStmtNode(const NaryStmtNode &node) = delete;
+  NaryStmtNode &operator=(const NaryStmtNode &node) = delete;
+  virtual ~NaryStmtNode() = default;
+
+  void Dump(int32 indent) const override;
+  bool Verify() const override;
+
+  NaryStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<NaryStmtNode>(allocator, *this);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    node->SetNumOpnds(GetNopndSize());
+    return node;
+  }
+
+  BaseNode *Opnd(size_t i) const override {
+    return GetNopndAt(i);
+  }
+
+  void SetOpnd(BaseNode *node, size_t i) override {
+    ASSERT(i < GetNopnd().size(), "array index out of range");
+    SetNOpndAt(i, node);
+  }
+
+  size_t NumOpnds() const override {
+    ASSERT(numOpnds == GetNopndSize(), "NaryStmtNode has wrong numOpnds field");
+    return GetNopndSize();
+  }
+
+  void SetOpnds(const MapleVector<BaseNode*> &arguments) {
+    SetNOpnd(arguments);
+    SetNumOpnds(arguments.size());
+  }
+
+  void PushOpnd(BaseNode *node) {
+    if (node != nullptr) {
+      GetNopnd().push_back(node);
+    }
+    SetNumOpnds(GetNopndSize());
+  }
+
+  void InsertOpnd(BaseNode *node, size_t idx) {
+    if (node == nullptr || idx > GetNopndSize()) {
+      return;
+    }
+    auto begin = GetNopnd().begin();
+    for (size_t i = 0; i < idx; ++i) {
+      ++begin;
+    }
+    (void)GetNopnd().insert(begin, node);
+    SetNumOpnds(GetNopndSize());
+  }
+};
+
+class SafetyCheckStmtNode {
+ public:
+  explicit SafetyCheckStmtNode(GStrIdx funcNameIdx) : funcNameIdx(funcNameIdx) {}
+  SafetyCheckStmtNode(const SafetyCheckStmtNode &stmtNode) : funcNameIdx(stmtNode.GetFuncNameIdx()) {}
+  SafetyCheckStmtNode &operator=(const SafetyCheckStmtNode &stmtNode) {
+    funcNameIdx = stmtNode.GetFuncNameIdx();
+    return *this;
+  }
+
+  virtual ~SafetyCheckStmtNode() = default;
+
+  std::string GetFuncName() const;
+
+  GStrIdx GetFuncNameIdx() const {
+    return funcNameIdx;
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << " <&" << GetFuncName() << ">";
+  }
+
+ private:
+  GStrIdx funcNameIdx;
+};
+
+// used by callassertnonnull, callassertle
+class SafetyCallCheckStmtNode {
+ public:
+  SafetyCallCheckStmtNode(GStrIdx callFuncNameIdx, size_t paramIndex, GStrIdx stmtFuncNameIdx)
+      : callFuncNameIdx(callFuncNameIdx), paramIndex(paramIndex), stmtFuncNameIdx(stmtFuncNameIdx) {}
+  explicit SafetyCallCheckStmtNode(const SafetyCallCheckStmtNode &stmtNode)
+      : callFuncNameIdx(stmtNode.GetFuncNameIdx()),
+        paramIndex(stmtNode.GetParamIndex()),
+        stmtFuncNameIdx(stmtNode.GetStmtFuncNameIdx()) {}
+
+  virtual ~SafetyCallCheckStmtNode() = default;
+
+  std::string GetFuncName() const;
+  GStrIdx GetFuncNameIdx() const {
+    return callFuncNameIdx;
+  }
+  std::string GetStmtFuncName() const;
+  size_t GetParamIndex() const {
+    return paramIndex;
+  }
+
+  GStrIdx GetStmtFuncNameIdx() const {
+    return stmtFuncNameIdx;
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << " <&" << GetFuncName() << ", " << paramIndex << ", &" << GetStmtFuncName() << ">";
+  }
+
+ private:
+  GStrIdx callFuncNameIdx;
+  size_t paramIndex;
+  GStrIdx stmtFuncNameIdx;
+};
+
+// used by callassertnonnull
+class CallAssertNonnullStmtNode : public UnaryStmtNode, public SafetyCallCheckStmtNode {
+ public:
+  CallAssertNonnullStmtNode(Opcode o, GStrIdx callFuncNameIdx, size_t paramIndex, GStrIdx stmtFuncNameIdx)
+      : UnaryStmtNode(o), SafetyCallCheckStmtNode(callFuncNameIdx, paramIndex, stmtFuncNameIdx) {}
+  ~CallAssertNonnullStmtNode() override {}
+
+  void Dump(int32 indent) const override;
+
+  CallAssertNonnullStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<CallAssertNonnullStmtNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd()->CloneTree(allocator), 0);
+    return node;
+  }
+};
+
+// used by assertnonnull
+class AssertNonnullStmtNode : public UnaryStmtNode, public SafetyCheckStmtNode {
+ public:
+  AssertNonnullStmtNode(Opcode o, GStrIdx funcNameIdx) : UnaryStmtNode(o), SafetyCheckStmtNode(funcNameIdx) {}
+  ~AssertNonnullStmtNode() override {}
+
+  void Dump(int32 indent) const override;
+
+  AssertNonnullStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<AssertNonnullStmtNode>(*this);
+    node->SetStmtID(stmtIDNext++);
+    node->SetOpnd(Opnd()->CloneTree(allocator), 0);
+    return node;
+  }
+};
+
+// used by assertle
+class AssertBoundaryStmtNode : public NaryStmtNode, public SafetyCheckStmtNode {
+ public:
+  AssertBoundaryStmtNode(MapleAllocator &allocator, Opcode o, GStrIdx funcNameIdx)
+      : NaryStmtNode(allocator, o), SafetyCheckStmtNode(funcNameIdx) {}
+  ~AssertBoundaryStmtNode() override {}
+
+  AssertBoundaryStmtNode(MapleAllocator &allocator, const AssertBoundaryStmtNode &stmtNode)
+      : NaryStmtNode(allocator, stmtNode), SafetyCheckStmtNode(stmtNode) {}
+
+  AssertBoundaryStmtNode(const MIRModule &mod, Opcode o, GStrIdx funcNameIdx)
+      : AssertBoundaryStmtNode(mod.GetCurFuncCodeMPAllocator(), o, funcNameIdx) {}
+
+  void Dump(int32 indent) const override;
+
+  AssertBoundaryStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<AssertBoundaryStmtNode>(allocator, *this);
+    node->SetStmtID(stmtIDNext++);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    node->SetNumOpnds(GetNopndSize());
+    return node;
+  }
+};
+
+// used by callassertle
+class CallAssertBoundaryStmtNode : public NaryStmtNode, public SafetyCallCheckStmtNode {
+ public:
+  CallAssertBoundaryStmtNode(MapleAllocator &allocator, Opcode o, GStrIdx funcNameIdx, size_t paramIndex,
+                             GStrIdx stmtFuncNameIdx)
+      : NaryStmtNode(allocator, o), SafetyCallCheckStmtNode(funcNameIdx, paramIndex, stmtFuncNameIdx) {}
+  ~CallAssertBoundaryStmtNode() override {}
+
+  CallAssertBoundaryStmtNode(MapleAllocator &allocator, const CallAssertBoundaryStmtNode &stmtNode)
+      : NaryStmtNode(allocator, stmtNode), SafetyCallCheckStmtNode(stmtNode) {}
+
+  CallAssertBoundaryStmtNode(const MIRModule &mod, Opcode o, GStrIdx funcNameIdx, size_t paramIndex,
+                             GStrIdx stmtFuncNameIdx)
+      : CallAssertBoundaryStmtNode(mod.GetCurFuncCodeMPAllocator(), o, funcNameIdx, paramIndex, stmtFuncNameIdx) {}
+
+  void Dump(int32 indent) const override;
+
+  CallAssertBoundaryStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<CallAssertBoundaryStmtNode>(allocator, *this);
+    node->SetStmtID(stmtIDNext++);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    node->SetNumOpnds(GetNopndSize());
+    return node;
+  }
+};
+
+// used by call, virtualcall, virtualicall, superclasscall, interfacecall,
+// interfaceicall, customcall
+// polymorphiccall
+// callassigned, virtualcallassigned, virtualicallassigned,
+// superclasscallassigned, interfacecallassigned, interfaceicallassigned,
+// customcallassigned
+// polymorphiccallassigned
+class CallNode : public NaryStmtNode {
+ public:
+  CallNode(MapleAllocator &allocator, Opcode o) : NaryStmtNode(allocator, o), returnValues(allocator.Adapter()) {}
+
+  CallNode(MapleAllocator &allocator, Opcode o, PUIdx idx) : CallNode(allocator, o, idx, TyIdx()) {}
+
+  CallNode(MapleAllocator &allocator, Opcode o, PUIdx idx, TyIdx tdx)
+      : NaryStmtNode(allocator, o), puIdx(idx), tyIdx(tdx), returnValues(allocator.Adapter()) {}
+
+  CallNode(const MIRModule &mod, Opcode o) : CallNode(mod.GetCurFuncCodeMPAllocator(), o) {}
+
+  CallNode(const MIRModule &mod, Opcode o, PUIdx idx, TyIdx tdx)
+      : CallNode(mod.GetCurFuncCodeMPAllocator(), o, idx, tdx) {}
+
+  CallNode(MapleAllocator &allocator, const CallNode &node)
+      : NaryStmtNode(allocator, node), puIdx(node.GetPUIdx()), tyIdx(node.tyIdx), returnValues(allocator.Adapter()) {}
+
+  CallNode(const MIRModule &mod, const CallNode &node) : CallNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  CallNode(CallNode &node) = delete;
+  CallNode &operator=(const CallNode &node) = delete;
+  virtual ~CallNode() = default;
+  virtual void Dump(int32 indent, bool newline) const;
+  bool Verify() const override;
+  MIRType *GetCallReturnType() override;
+  const MIRSymbol *GetCallReturnSymbol(const MIRModule &mod) const;
+
+  CallNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<CallNode>(allocator, *this);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    for (size_t i = 0; i < returnValues.size(); ++i) {
+      node->GetReturnVec().push_back(returnValues[i]);
+    }
+    node->SetNumOpnds(GetNopndSize());
+    return node;
+  }
+
+  PUIdx GetPUIdx() const {
+    return puIdx;
+  }
+
+  void SetPUIdx(const PUIdx idx) {
+    puIdx = idx;
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  CallReturnVector &GetReturnVec() {
+    return returnValues;
+  }
+
+  CallReturnPair GetReturnPair(size_t idx) const {
+    ASSERT(idx < returnValues.size(), "out of range in CallNode::GetReturnPair");
+    return returnValues.at(idx);
+  }
+
+  void SetReturnPair(CallReturnPair retVal, size_t idx) {
+    ASSERT(idx < returnValues.size(), "out of range in CallNode::GetReturnPair");
+    returnValues.at(idx) = retVal;
+  }
+
+  const CallReturnVector &GetReturnVec() const {
+    return returnValues;
+  }
+
+  CallReturnPair GetNthReturnVec(size_t i) const {
+    ASSERT(i < returnValues.size(), "array index out of range");
+    return returnValues[i];
+  }
+
+  void SetReturnVec(const CallReturnVector &vec) {
+    returnValues = vec;
+  }
+
+  size_t NumOpnds() const override {
+    ASSERT(numOpnds == GetNopndSize(), "CallNode has wrong numOpnds field");
+    return GetNopndSize();
+  }
+
+  void Dump(int32 indent) const override {
+    Dump(indent, true);
+  }
+
+  CallReturnVector *GetCallReturnVector() override {
+    return &returnValues;
+  }
+
+  void SetCallReturnVector(const CallReturnVector &value) {
+    returnValues = value;
+  }
+
+  void SetEnclosingBlock(BlockNode *value) {
+    enclosingBlk = value;
+  }
+
+  BlockNode *GetEnclosingBlock() {
+    return enclosingBlk;
+  }
+
+ private:
+  PUIdx puIdx = 0;
+  TyIdx tyIdx = TyIdx(0);
+  CallReturnVector returnValues;
+  BlockNode *enclosingBlk = nullptr;
+};
+
+// icall, icallassigned, icallproto and icallprotoassigned
+class IcallNode : public NaryStmtNode {
+ public:
+  IcallNode(MapleAllocator &allocator, Opcode o)
+      : NaryStmtNode(allocator, o), retTyIdx(0), returnValues(allocator.Adapter()) {
+    BaseNodeT::SetNumOpnds(kOperandNumUnary);
+  }
+
+  IcallNode(MapleAllocator &allocator, Opcode o, TyIdx idx)
+      : NaryStmtNode(allocator, o), retTyIdx(idx), returnValues(allocator.Adapter()) {
+    BaseNodeT::SetNumOpnds(kOperandNumUnary);
+  }
+
+  IcallNode(const MIRModule &mod, Opcode o) : IcallNode(mod.GetCurFuncCodeMPAllocator(), o) {}
+
+  IcallNode(const MIRModule &mod, Opcode o, TyIdx idx) : IcallNode(mod.GetCurFuncCodeMPAllocator(), o, idx) {}
+
+  IcallNode(MapleAllocator &allocator, const IcallNode &node)
+      : NaryStmtNode(allocator, node), retTyIdx(node.retTyIdx), returnValues(allocator.Adapter()) {}
+
+  IcallNode(const MIRModule &mod, const IcallNode &node) : IcallNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  IcallNode(IcallNode &node) = delete;
+  IcallNode &operator=(const IcallNode &node) = delete;
+  virtual ~IcallNode() = default;
+
+  virtual void Dump(int32 indent, bool newline) const;
+  bool Verify() const override;
+  MIRType *GetCallReturnType() override;
+  const MIRSymbol *GetCallReturnSymbol(const MIRModule &mod) const;
+  IcallNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<IcallNode>(allocator, *this);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    for (size_t i = 0; i < returnValues.size(); ++i) {
+      node->returnValues.push_back(returnValues[i]);
+    }
+    node->SetNumOpnds(GetNopndSize());
+    return node;
+  }
+
+  TyIdx GetRetTyIdx() const {
+    return retTyIdx;
+  }
+
+  void SetRetTyIdx(TyIdx idx) {
+    retTyIdx = idx;
+  }
+
+  const CallReturnVector &GetReturnVec() const {
+    return returnValues;
+  }
+
+  CallReturnVector &GetReturnVec() {
+    return returnValues;
+  }
+
+  void SetReturnVec(const CallReturnVector &vec) {
+    returnValues = vec;
+  }
+
+  size_t NumOpnds() const override {
+    ASSERT(numOpnds == GetNopndSize(), "IcallNode has wrong numOpnds field");
+    return GetNopndSize();
+  }
+
+  void Dump(int32 indent) const override {
+    Dump(indent, true);
+  }
+
+  CallReturnVector *GetCallReturnVector() override {
+    return &returnValues;
+  }
+
+ private:
+  TyIdx retTyIdx;
+  // for icall: return type for callee;
+  // for icallproto: return ptr for callee function type
+  // the 0th operand is the function pointer
+  CallReturnVector returnValues;
+};
+
+// used by intrinsiccall and xintrinsiccall
+class IntrinsiccallNode : public NaryStmtNode {
+ public:
+  IntrinsiccallNode(MapleAllocator &allocator, Opcode o)
+      : NaryStmtNode(allocator, o), intrinsic(INTRN_UNDEFINED), tyIdx(0), returnValues(allocator.Adapter()) {}
+
+  IntrinsiccallNode(MapleAllocator &allocator, Opcode o, MIRIntrinsicID id)
+      : NaryStmtNode(allocator, o), intrinsic(id), tyIdx(0), returnValues(allocator.Adapter()) {}
+
+  IntrinsiccallNode(const MIRModule &mod, Opcode o) : IntrinsiccallNode(mod.GetCurFuncCodeMPAllocator(), o) {}
+
+  IntrinsiccallNode(const MIRModule &mod, Opcode o, MIRIntrinsicID id)
+      : IntrinsiccallNode(mod.GetCurFuncCodeMPAllocator(), o, id) {}
+
+  IntrinsiccallNode(MapleAllocator &allocator, const IntrinsiccallNode &node)
+      : NaryStmtNode(allocator, node),
+        intrinsic(node.GetIntrinsic()),
+        tyIdx(node.tyIdx),
+        returnValues(allocator.Adapter()) {}
+
+  IntrinsiccallNode(const MIRModule &mod, const IntrinsiccallNode &node)
+      : IntrinsiccallNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  IntrinsiccallNode(IntrinsiccallNode &node) = delete;
+  IntrinsiccallNode &operator=(const IntrinsiccallNode &node) = delete;
+  virtual ~IntrinsiccallNode() = default;
+
+  virtual void Dump(int32 indent, bool newline) const;
+  bool Verify() const override;
+  MIRType *GetCallReturnType() override;
+
+  IntrinsiccallNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<IntrinsiccallNode>(allocator, *this);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    for (size_t i = 0; i < returnValues.size(); ++i) {
+      node->GetReturnVec().push_back(returnValues[i]);
+    }
+    node->SetNumOpnds(GetNopndSize());
+    return node;
+  }
+
+  MIRIntrinsicID GetIntrinsic() const {
+    return intrinsic;
+  }
+
+  void SetIntrinsic(MIRIntrinsicID id) {
+    intrinsic = id;
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  CallReturnVector &GetReturnVec() {
+    return returnValues;
+  }
+
+  const CallReturnVector &GetReturnVec() const {
+    return returnValues;
+  }
+
+  void SetReturnVec(const CallReturnVector &vec) {
+    returnValues = vec;
+  }
+
+  size_t NumOpnds() const override {
+    ASSERT(numOpnds == GetNopndSize(), "IntrinsiccallNode has wrong numOpnds field");
+    return GetNopndSize();
+  }
+
+  void Dump(int32 indent) const override {
+    Dump(indent, true);
+  }
+
+  CallReturnVector *GetCallReturnVector() override {
+    return &returnValues;
+  }
+
+  CallReturnPair &GetCallReturnPair(uint32 i) {
+    ASSERT(i < returnValues.size(), "array index out of range");
+    return returnValues.at(i);
+  }
+
+ private:
+  MIRIntrinsicID intrinsic;
+  TyIdx tyIdx;
+  CallReturnVector returnValues;
+};
+
+// used by callinstant, virtualcallinstant, superclasscallinstant and
+// interfacecallinstant, callinstantassigned, virtualcallinstantassigned,
+// superclasscallinstantassigned and interfacecallinstantassigned
+class CallinstantNode : public CallNode {
+ public:
+  CallinstantNode(MapleAllocator &allocator, Opcode o, TyIdx tIdx) : CallNode(allocator, o), instVecTyIdx(tIdx) {}
+
+  CallinstantNode(const MIRModule &mod, Opcode o, TyIdx tIdx)
+      : CallinstantNode(mod.GetCurFuncCodeMPAllocator(), o, tIdx) {}
+
+  CallinstantNode(MapleAllocator &allocator, const CallinstantNode &node)
+      : CallNode(allocator, node), instVecTyIdx(node.instVecTyIdx) {}
+
+  CallinstantNode(const MIRModule &mod, const CallinstantNode &node)
+      : CallinstantNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  CallinstantNode(CallinstantNode &node) = delete;
+  CallinstantNode &operator=(const CallinstantNode &node) = delete;
+  virtual ~CallinstantNode() = default;
+
+  void Dump(int32 indent, bool newline) const override;
+  void Dump(int32 indent) const override {
+    Dump(indent, true);
+  }
+
+  CallinstantNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.GetMemPool()->New<CallinstantNode>(allocator, *this);
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+    }
+    for (size_t i = 0; i < GetReturnVec().size(); ++i) {
+      node->GetReturnVec().push_back(GetNthReturnVec(i));
+    }
+    node->SetNumOpnds(GetNopndSize());
+    return node;
+  }
+
+  CallReturnVector *GetCallReturnVector() override {
+    return &GetReturnVec();
+  }
+
+ private:
+  TyIdx instVecTyIdx;
+};
+
+class LabelNode : public StmtNode {
+ public:
+  LabelNode() : StmtNode(OP_label) {}
+
+  explicit LabelNode(LabelIdx idx) : StmtNode(OP_label), labelIdx(idx) {}
+
+  virtual ~LabelNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  LabelNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *l = allocator.GetMemPool()->New<LabelNode>(*this);
+    l->SetStmtID(stmtIDNext++);
+    return l;
+  }
+
+  LabelIdx GetLabelIdx() const {
+    return labelIdx;
+  }
+
+  void SetLabelIdx(LabelIdx idx) {
+    labelIdx = idx;
+  }
+
+ private:
+  LabelIdx labelIdx = 0;
+};
+
+class CommentNode : public StmtNode {
+ public:
+  explicit CommentNode(const MapleAllocator &allocator) : StmtNode(OP_comment), comment(allocator.GetMemPool()) {}
+
+  explicit CommentNode(const MIRModule &mod) : CommentNode(mod.GetCurFuncCodeMPAllocator()) {}
+
+  CommentNode(const MapleAllocator &allocator, const std::string &cmt)
+      : StmtNode(OP_comment), comment(cmt, allocator.GetMemPool()) {}
+
+  CommentNode(const MIRModule &mod, const std::string &cmt) : CommentNode(mod.GetCurFuncCodeMPAllocator(), cmt) {}
+
+  CommentNode(const MapleAllocator &allocator, const CommentNode &node)
+      : StmtNode(node.GetOpCode(), node.GetPrimType()), comment(node.comment, allocator.GetMemPool()) {}
+
+  CommentNode(const MIRModule &mod, const CommentNode &node) : CommentNode(mod.GetCurFuncCodeMPAllocator(), node) {}
+
+  CommentNode(CommentNode &node) = delete;
+  CommentNode &operator=(const CommentNode &node) = delete;
+  virtual ~CommentNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  CommentNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *c = allocator.GetMemPool()->New<CommentNode>(allocator, *this);
+    return c;
+  }
+
+  const MapleString &GetComment() const {
+    return comment;
+  }
+
+  void SetComment(MapleString com) {
+    comment = com;
+  }
+
+  void SetComment(const std::string &str) {
+    comment = str;
+  }
+
+  void SetComment(const char *str) {
+    comment = str;
+  }
+
+  void Append(const std::string &str) {
+    comment.append(str);
+  }
+
+ private:
+  MapleString comment;
+};
+
+enum AsmQualifierKind : unsigned {  // they are alreadgy Maple IR keywords
+  kASMvolatile,
+  kASMinline,
+  kASMgoto,
+};
+
+class AsmNode : public NaryStmtNode {
+ public:
+  explicit AsmNode(MapleAllocator *alloc)
+      : NaryStmtNode(*alloc, OP_asm),
+        asmString(alloc->GetMemPool()),
+        inputConstraints(alloc->Adapter()),
+        asmOutputs(alloc->Adapter()),
+        outputConstraints(alloc->Adapter()),
+        clobberList(alloc->Adapter()),
+        gotoLabels(alloc->Adapter()),
+        qualifiers(0) {}
+
+  AsmNode(MapleAllocator &allocator, const AsmNode &node)
+      : NaryStmtNode(allocator, node),
+        asmString(node.asmString, allocator.GetMemPool()),
+        inputConstraints(allocator.Adapter()),
+        asmOutputs(allocator.Adapter()),
+        outputConstraints(allocator.Adapter()),
+        clobberList(allocator.Adapter()),
+        gotoLabels(allocator.Adapter()),
+        qualifiers(node.qualifiers) {}
+
+  virtual ~AsmNode() = default;
+
+  AsmNode *CloneTree(MapleAllocator &allocator) const override;
+
+  void SetQualifier(AsmQualifierKind x) {
+    qualifiers |= (1U << static_cast<uint32>(x));
+  }
+
+  bool GetQualifier(AsmQualifierKind x) const {
+    return (qualifiers & (1U << static_cast<uint32>(x))) != 0;
+  }
+
+  CallReturnVector *GetCallReturnVector() override {
+    return &asmOutputs;
+  }
+
+  void SetHasWriteInputs() {
+    hasWriteInputs = true;
+  }
+
+  bool HasWriteInputs() const {
+    return hasWriteInputs;
+  }
+
+  bool IsSameContent(const BaseNode *node) const override;
+  void DumpOutputs(int32 indent, std::string &uStr) const;
+  void DumpInputOperands(int32 indent, std::string &uStr) const;
+  void Dump(int32 indent) const override;
+
+  MapleString asmString;
+  MapleVector<UStrIdx> inputConstraints;  // length is numOpnds
+  CallReturnVector asmOutputs;
+  MapleVector<UStrIdx> outputConstraints;  // length is returnValues.size()
+  MapleVector<UStrIdx> clobberList;
+  MapleVector<LabelIdx> gotoLabels;
+  uint32 qualifiers;
+
+ private:
+  bool hasWriteInputs = false;
+};
+
+void DumpCallReturns(const MIRModule &mod, CallReturnVector nrets, int32 indent);
+bool HasIreadExpr(const BaseNode *expr);
+size_t MaxDepth(const BaseNode *expr);
+}  // namespace maple
+
+#define LOAD_SAFE_CAST_FOR_MIR_NODE
+#include "ir_safe_cast_traits.def"
+
+#endif  // MAPLE_IR_INCLUDE_MIR_NODES_H
diff --git a/src/mapleall/maple_ir/include/mir_parser.h b/src/mapleall/maple_ir/include/mir_parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8a2897d8d4a179aa35376ed63ac65f7745b1b17
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_parser.h
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_PARSER_H
+#define MAPLE_IR_INCLUDE_MIR_PARSER_H
+#include "mir_module.h"
+#include "lexer.h"
+#include "mir_nodes.h"
+#include "mir_preg.h"
+#include "mir_scope.h"
+#include "parser_opt.h"
+
+namespace maple {
+using BaseNodePtr = BaseNode*;
+using StmtNodePtr = StmtNode*;
+using BlockNodePtr = BlockNode*;
+
+class FormalDef;
+
+class MIRParser {
+ public:
+  explicit MIRParser(MIRModule &md)
+      : lexer(md),
+        mod(md),
+        definedLabels(mod.GetMPAllocator().Adapter()) {
+    safeRegionFlag.push(false);
+  }
+
+  ~MIRParser() = default;
+
+  MIRFunction *CreateDummyFunction();
+  void ResetCurrentFunction() {
+    mod.SetCurFunction(dummyFunction);
+  }
+
+  bool ParseLoc();
+  bool ParseLocStmt(StmtNodePtr &stmt);
+  bool ParsePosition(SrcPosition &pos);
+  bool ParseOneScope(MIRScope &scope);
+  bool ParseScope();
+  bool ParseScopeStmt(StmtNodePtr &stmt);
+  bool ParseOneAlias(GStrIdx &strIdx, MIRAliasVars &aliasVar);
+  bool ParseAlias();
+  bool ParseAliasStmt(StmtNodePtr &stmt);
+  bool ParseTypeAlias(MIRScope &scope);
+  uint8 *ParseWordsInfo(uint32 size);
+  bool ParseSwitchCase(int64&, LabelIdx&);
+  bool ParseExprOneOperand(BaseNodePtr &expr);
+  bool ParseExprTwoOperand(BaseNodePtr &opnd0, BaseNodePtr &opnd1);
+  bool ParseExprNaryOperand(MapleVector<BaseNode*> &opndVec);
+  bool IsDelimitationTK(TokenKind tk) const;
+  Opcode GetOpFromToken(TokenKind tk) const;
+  bool IsStatement(TokenKind tk) const;
+  PrimType GetPrimitiveType(TokenKind tk) const;
+  MIRIntrinsicID GetIntrinsicID(TokenKind tk) const;
+  bool ParseScalarValue(MIRConstPtr &stype, MIRType &type);
+  bool ParseConstAddrLeafExpr(MIRConstPtr &cexpr);
+  bool ParseInitValue(MIRConstPtr &theConst, TyIdx tyIdx, bool allowEmpty = false);
+  bool ParseDeclaredSt(StIdx &stidx);
+  void CreateFuncMIRSymbol(PUIdx &puidx, GStrIdx strIdx);
+  bool ParseDeclaredFunc(PUIdx &puidx);
+  bool ParseTypeAttrs(TypeAttrs &attrs);
+  bool ParseVarTypeAttrs(MIRSymbol &st);
+  bool CheckAlignTk();
+  bool ParseAlignAttrs(TypeAttrs &tA);
+  bool ParsePackAttrs();
+  bool ParseFieldAttrs(FieldAttrs &attrs);
+  bool ParseFuncAttrs(FuncAttrs &attrs);
+  void SetAttrContent(FuncAttrs &attrs, FuncAttrKind x, const MIRLexer &lexer) const;
+  bool CheckPrimAndDerivedType(TokenKind tokenKind, TyIdx &tyIdx);
+  bool ParsePrimType(TyIdx &tyIdx);
+  bool ParseFarrayType(TyIdx &arrayTyIdx);
+  bool ParseArrayType(TyIdx &arrayTyIdx);
+  bool ParseBitFieldType(TyIdx &fieldTyIdx);
+  bool ParsePragmaElement(MIRPragmaElement &elem);
+  bool ParsePragmaElementForArray(MIRPragmaElement &elem);
+  bool ParsePragmaElementForAnnotation(MIRPragmaElement &elem);
+  bool ParsePragma(MIRStructType &type);
+  bool ParseFields(MIRStructType &type);
+  bool ParseStructType(TyIdx &styIdx, const GStrIdx &strIdx = GStrIdx(0));
+  bool ParseClassType(TyIdx &styidx, const GStrIdx &strIdx = GStrIdx(0));
+  bool ParseInterfaceType(TyIdx &sTyIdx, const GStrIdx &strIdx = GStrIdx(0));
+  bool ParseDefinedTypename(TyIdx &definedTyIdx, MIRTypeKind kind = kTypeUnknown);
+  bool ParseTypeParam(TyIdx &definedTyIdx);
+  bool ParsePointType(TyIdx &tyIdx);
+  bool ParseFuncType(TyIdx &tyIdx);
+  bool ParseGenericInstantVector(MIRInstantVectorType &insVecType);
+  bool ParseDerivedType(TyIdx &tyIdx, MIRTypeKind kind = kTypeUnknown, const GStrIdx &strIdx = GStrIdx(0));
+  bool ParseType(TyIdx &tyIdx);
+  bool ParseEnumeration();
+  bool ParseStatement(StmtNodePtr &stmt);
+  bool ParseSpecialReg(PregIdx &pRegIdx);
+  bool ParsePseudoReg(PrimType primType, PregIdx &pRegIdx);
+  bool ParseStmtBlock(BlockNodePtr &blk);
+  bool ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &funcTyIdx);
+  bool ParseFunction(uint32 fileIdx = 0);
+  bool ParseStorageClass(MIRSymbol &symbol) const;
+  bool ParseDeclareVarInitValue(MIRSymbol &symbol);
+  bool ParseDeclareVar(MIRSymbol&);
+  bool ParseDeclareReg(MIRSymbol &symbol, const MIRFunction &func);
+  bool ParseDeclareFormal(FormalDef &formalDef);
+  bool ParsePrototypeRemaining(MIRFunction &func, std::vector<TyIdx> &vecTyIdx,
+                               std::vector<TypeAttrs> &vecAttrs, bool &varArgs);
+
+  // Stmt Parser
+  bool ParseStmtDassign(StmtNodePtr &stmt);
+  bool ParseStmtDassignoff(StmtNodePtr &stmt);
+  bool ParseStmtRegassign(StmtNodePtr &stmt);
+  bool ParseStmtIassign(StmtNodePtr &stmt);
+  bool ParseStmtIassignoff(StmtNodePtr &stmt);
+  bool ParseStmtIassignFPoff(StmtNodePtr &stmt);
+  bool ParseStmtBlkassignoff(StmtNodePtr &stmt);
+  bool ParseStmtDoloop(StmtNodePtr &stmt);
+  bool ParseStmtForeachelem(StmtNodePtr &stmt);
+  bool ParseStmtDowhile(StmtNodePtr &stmt);
+  bool ParseStmtIf(StmtNodePtr &stmt);
+  bool ParseStmtWhile(StmtNodePtr &stmt);
+  bool ParseStmtLabel(StmtNodePtr &stmt);
+  bool ParseStmtGoto(StmtNodePtr &stmt);
+  bool ParseStmtBr(StmtNodePtr &stmt);
+  bool ParseStmtSwitch(StmtNodePtr &stmt);
+  bool ParseStmtRangegoto(StmtNodePtr &stmt);
+  bool ParseStmtMultiway(StmtNodePtr &stmt);
+  PUIdx EnterUndeclaredFunction(bool isMcount = false);  // for -pg in order to add "void _mcount()"
+  bool ParseStmtCall(StmtNodePtr &stmt);
+  bool ParseStmtCallMcount(StmtNodePtr &stmt);  // for -pg in order to add "void _mcount()" to all the functions
+  bool ParseStmtIcall(StmtNodePtr &stmt, Opcode op);
+  bool ParseStmtIcall(StmtNodePtr &stmt);
+  bool ParseStmtIcallassigned(StmtNodePtr &stmt);
+  bool ParseStmtIcallproto(StmtNodePtr &stmt);
+  bool ParseStmtIcallprotoassigned(StmtNodePtr &stmt);
+  bool ParseStmtIntrinsiccall(StmtNodePtr &stmt, bool isAssigned);
+  bool ParseStmtIntrinsiccall(StmtNodePtr &stmt);
+  bool ParseStmtIntrinsiccallassigned(StmtNodePtr &stmt);
+  bool ParseStmtIntrinsiccallwithtype(StmtNodePtr &stmt, bool isAssigned);
+  bool ParseStmtIntrinsiccallwithtype(StmtNodePtr &stmt);
+  bool ParseStmtIntrinsiccallwithtypeassigned(StmtNodePtr &stmt);
+  bool ParseCallReturnPair(CallReturnPair &retpair);
+  bool ParseCallReturns(CallReturnVector &retsvec);
+  bool ParseBinaryStmt(StmtNodePtr &stmt, Opcode op);
+  bool ParseNaryStmtAssert(StmtNodePtr &stmt, Opcode op);
+  bool ParseNaryStmtAssertGE(StmtNodePtr &stmt);
+  bool ParseNaryStmtAssertLT(StmtNodePtr &stmt);
+  bool ParseNaryStmtCalcassertGE(StmtNodePtr &stmt);
+  bool ParseNaryStmtCalcassertLT(StmtNodePtr &stmt);
+  bool ParseNaryStmtCallAssertLE(StmtNodePtr &stmt);
+  bool ParseNaryStmtReturnAssertLE(StmtNodePtr &stmt);
+  bool ParseNaryStmtAssignAssertLE(StmtNodePtr &stmt);
+  bool ParseNaryStmt(StmtNodePtr &stmt, Opcode op);
+  bool ParseNaryStmtReturn(StmtNodePtr &stmt);
+  bool ParseNaryStmtSyncEnter(StmtNodePtr &stmt);
+  bool ParseNaryStmtSyncExit(StmtNodePtr &stmt);
+  bool ParseStmtJsTry(StmtNodePtr &stmt);
+  bool ParseStmtTry(StmtNodePtr &stmt);
+  bool ParseStmtCatch(StmtNodePtr &stmt);
+  bool ParseUnaryStmt(Opcode op, StmtNodePtr &stmt);
+  bool ParseUnaryStmtThrow(StmtNodePtr &stmt);
+  bool ParseUnaryStmtDecRef(StmtNodePtr &stmt);
+  bool ParseUnaryStmtIncRef(StmtNodePtr &stmt);
+  bool ParseUnaryStmtDecRefReset(StmtNodePtr &stmt);
+  bool ParseUnaryStmtIGoto(StmtNodePtr &stmt);
+  bool ParseUnaryStmtEval(StmtNodePtr &stmt);
+  bool ParseUnaryStmtFree(StmtNodePtr &stmt);
+  bool ParseUnaryStmtAssertNonNullCheck(Opcode op, StmtNodePtr &stmt);
+  bool ParseUnaryStmtAssertNonNull(StmtNodePtr &stmt);
+  bool ParseUnaryStmtCallAssertNonNull(StmtNodePtr &stmt);
+  bool ParseUnaryStmtAssignAssertNonNull(StmtNodePtr &stmt);
+  bool ParseUnaryStmtReturnAssertNonNull(StmtNodePtr &stmt);
+  bool ParseStmtMarker(StmtNodePtr &stmt);
+  bool ParseStmtGosub(StmtNodePtr &stmt);
+  bool ParseStmtAsm(StmtNodePtr &stmt);
+  bool ParseStmtSafeRegion(StmtNodePtr &stmt);
+
+  // Expression Parser
+  bool ParseExpression(BaseNodePtr &expr);
+  bool ParseExprDread(BaseNodePtr &expr);
+  bool ParseExprDreadoff(BaseNodePtr &expr);
+  bool ParseExprRegread(BaseNodePtr &expr);
+  bool ParseExprBinary(BaseNodePtr &expr);
+  bool ParseExprCompare(BaseNodePtr &expr);
+  bool ParseExprDepositbits(BaseNodePtr &expr);
+  bool ParseExprConstval(BaseNodePtr &expr);
+  bool ParseExprConststr(BaseNodePtr &expr);
+  bool ParseExprConststr16(BaseNodePtr &expr);
+  bool ParseExprSizeoftype(BaseNodePtr &expr);
+  bool ParseExprFieldsDist(BaseNodePtr &expr);
+  bool ParseExprIreadIaddrof(IreadNode &expr);
+  bool ParseExprIread(BaseNodePtr &expr);
+  bool ParseExprIreadoff(BaseNodePtr &expr);
+  bool ParseExprIreadFPoff(BaseNodePtr &expr);
+  bool ParseExprIaddrof(BaseNodePtr &expr);
+  bool ParseExprAddrof(BaseNodePtr &expr);
+  bool ParseExprAddrofoff(BaseNodePtr &expr);
+  bool ParseExprAddroffunc(BaseNodePtr &expr);
+  bool ParseExprAddroflabel(BaseNodePtr &expr);
+  bool ParseExprUnary(BaseNodePtr &expr);
+  bool ParseExprJarray(BaseNodePtr &expr);
+  bool ParseExprSTACKJarray(BaseNodePtr &expr);
+  bool ParseExprGCMalloc(BaseNodePtr &expr);
+  bool ParseExprExtractbits(BaseNodePtr &expr);
+  bool ParseExprTyconvert(BaseNodePtr &expr);
+  bool ParseExprRetype(BaseNodePtr &expr);
+  bool ParseExprTernary(BaseNodePtr &expr);
+  bool ParseExprArray(BaseNodePtr &expr);
+  bool ParseExprIntrinsicop(BaseNodePtr &expr);
+  bool ParseNaryExpr(NaryStmtNode &stmtNode);
+
+  // funcName and paramIndex is out parameter
+  bool ParseCallAssertInfo(std::string &funcName, int *paramIndex, std::string &stmtFuncName);
+  bool ParseAssertInfo(std::string &funcName);
+  bool ParseTypeDefine();
+  bool ParseJavaClassInterface(MIRSymbol &symbol, bool isClass);
+  bool ParseIntrinsicId(IntrinsicopNode &intrnOpNode);
+  void Error(const std::string &str);
+  void Warning(const std::string &str);
+  void FixForwardReferencedTypeForOneAgg(MIRType *type);
+  void FixupForwardReferencedTypeByMap();
+
+  const std::string &GetError();
+  const std::string &GetWarning() const;
+  bool ParseFuncInfo(void);
+  void PrepareParsingMIR();
+  void PrepareParsingMplt();
+  bool ParseSrcLang(MIRSrcLang &srcLang);
+  bool ParseMIR(uint32 fileIdx = 0, uint32 option = 0, bool isIPA = false, bool isComb = false);
+  bool ParseMIR(std::ifstream &mplFile);  // the main entry point
+  bool ParseInlineFuncBody(std::ifstream &mplFile);
+  bool ParseMPLT(std::ifstream &mpltFile, const std::string &importFileName);
+  bool ParseMPLTStandalone(std::ifstream &mpltFile, const std::string &importFileName);
+  bool ParseTypeFromString(const std::string &src, TyIdx &tyIdx);
+  void EmitError(const std::string &fileName);
+  void EmitWarning(const std::string &fileName) const;
+  uint32 GetOptions() const {
+    return options;
+  }
+
+ private:
+  // func ptr map for ParseMIR()
+  using FuncPtrParseMIRForElem = bool (MIRParser::*)();
+  static std::map<TokenKind, FuncPtrParseMIRForElem> funcPtrMapForParseMIR;
+  static std::map<TokenKind, FuncPtrParseMIRForElem> InitFuncPtrMapForParseMIR();
+
+  bool TypeCompatible(const TyIdx &typeIdx1, const TyIdx &typeIdx2) const;
+  bool IsTypeIncomplete(MIRType *type) const;
+
+  // func for ParseMIR
+  bool ParseMIRForFunc();
+  bool ParseMIRForVar();
+  bool ParseMIRForClass();
+  bool ParseMIRForInterface();
+  bool ParseMIRForFlavor();
+  bool ParseMIRForSrcLang();
+  bool ParseMIRForGlobalMemSize();
+  bool ParseMIRForGlobalMemMap();
+  bool ParseMIRForGlobalWordsTypeTagged();
+  bool ParseMIRForGlobalWordsRefCounted();
+  bool ParseMIRForID();
+  bool ParseMIRForNumFuncs();
+  bool ParseMIRForEntryFunc();
+  bool ParseMIRForFileInfo();
+  bool ParseMIRForFileData();
+  bool ParseMIRForSrcFileInfo();
+  bool ParseMIRForImport();
+  bool ParseMIRForImportPath();
+  bool ParseMIRForAsmdecl();
+
+  // func for ParseExpr
+  using FuncPtrParseExpr = bool (MIRParser::*)(BaseNodePtr &ptr);
+  static std::map<TokenKind, FuncPtrParseExpr> funcPtrMapForParseExpr;
+  static std::map<TokenKind, FuncPtrParseExpr> InitFuncPtrMapForParseExpr();
+
+  // func and param for ParseStmt
+  using FuncPtrParseStmt = bool (MIRParser::*)(StmtNodePtr &stmt);
+  static std::map<TokenKind, FuncPtrParseStmt> funcPtrMapForParseStmt;
+  static std::map<TokenKind, FuncPtrParseStmt> InitFuncPtrMapForParseStmt();
+
+  // func and param for ParseStmtBlock
+  using FuncPtrParseStmtBlock = bool (MIRParser::*)();
+  static std::map<TokenKind, FuncPtrParseStmtBlock> funcPtrMapForParseStmtBlock;
+  static std::map<TokenKind, FuncPtrParseStmtBlock> InitFuncPtrMapForParseStmtBlock();
+  void ParseStmtBlockForSeenComment(BlockNodePtr blk, uint32 mplNum);
+  bool ParseStmtBlockForVar(TokenKind stmtTK);
+  bool ParseStmtBlockForVar();
+  bool ParseStmtBlockForTempVar();
+  bool ParseStmtBlockForReg();
+  bool ParseStmtBlockForType();
+  bool ParseStmtBlockForFrameSize();
+  bool ParseStmtBlockForUpformalSize();
+  bool ParseStmtBlockForModuleID();
+  bool ParseStmtBlockForFuncSize();
+  bool ParseStmtBlockForFuncID();
+  bool ParseStmtBlockForFormalWordsTypeTagged();
+  bool ParseStmtBlockForLocalWordsTypeTagged();
+  bool ParseStmtBlockForFormalWordsRefCounted();
+  bool ParseStmtBlockForLocalWordsRefCounted();
+  bool ParseStmtBlockForFuncInfo();
+
+  // common func
+  void SetSrcPos(SrcPosition &srcPosition, uint32 mplNum) const;
+
+  // func for ParseExpr
+  Opcode paramOpForStmt = OP_undef;
+  TokenKind paramTokenKindForStmt = TK_invalid;
+  // func and param for ParseStmtBlock
+  MIRFunction *paramCurrFuncForParseStmtBlock = nullptr;
+  MIRLexer lexer;
+  MIRModule &mod;
+  std::string message;
+  std::string warningMessage;
+  uint32 options = kKeepFirst;
+  MapleVector<bool> definedLabels;           // true if label at labidx is defined
+  MIRFunction *dummyFunction = nullptr;
+  MIRFunction *curFunc = nullptr;
+  uint16 lastFileNum = 0;                    // to remember first number after LOC
+  uint32 lastLineNum = 0;                    // to remember second number after LOC
+  uint16 lastColumnNum = 0;                  // to remember third number after LOC
+  uint32 firstLineNum = 0;                   // to track function starting line
+  std::map<TyIdx, TyIdx> typeDefIdxMap;      // map previous declared tyIdx
+  bool firstImport = true;                   // Mark the first imported mplt file
+  bool paramParseLocalType = false;          // param for ParseTypeDefine
+  uint32 paramFileIdx = 0;                   // param for ParseMIR()
+  bool paramIsIPA = false;
+  bool paramIsComb = false;
+  TokenKind paramTokenKind = TK_invalid;
+  std::vector<std::string> paramImportFileList;
+  std::stack<bool> safeRegionFlag;
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_PARSER_H
diff --git a/src/mapleall/maple_ir/include/mir_pragma.h b/src/mapleall/maple_ir/include/mir_pragma.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac0c8566a8df296280b816d24671a70015c5ce61
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_pragma.h
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_PRAGMA_H
+#define MAPLE_IR_INCLUDE_MIR_PRAGMA_H
+#include "types_def.h"
+#include "prim_types.h"
+#include "mir_module.h"
+#include "mpl_logging.h"
+#include "mempool_allocator.h"
+
+namespace maple {
+class MIRModule;         // circular dependency exists, no other choice
+class MIRType;           // circular dependency exists, no other choice
+class MIRFunction;       // circular dependency exists, no other choice
+class MIRSymbol;         // circular dependency exists, no other choice
+class MIRSymbolTable;    // circular dependency exists, no other choice
+class MIRTypeNameTable;  // circular dependency exists, no other choice
+enum PragmaKind {
+  kPragmaUnknown,
+  kPragmaClass,
+  kPragmaFunc,
+  kPragmaField,
+  kPragmaParam,
+  kPragmaPkg,
+  kPragmaVar,
+  kPragmaGlbvar,
+  kPragmaFuncExecptioni,
+  kPragmaFuncVar
+};
+
+enum PragmaVisibility {
+  kVisBuild,
+  kVisRuntime,
+  kVisSystem,
+  kVisMaple
+};
+
+enum PragmaValueType {
+  kValueByte = 0x00,          // (none; must be 0)  ubyte[1]
+  kValueShort = 0x02,         // size - 1 (0…1)  ubyte[size]
+  kValueChar = 0x03,          // size - 1 (0…1)  ubyte[size]
+  kValueInt = 0x04,           // size - 1 (0…3)  ubyte[size]
+  kValueLong = 0x06,          // size - 1 (0…7)  ubyte[size]
+  kValueFloat = 0x10,         // size - 1 (0…3)  ubyte[size]
+  kValueDouble = 0x11,        // size - 1 (0…7)  ubyte[size]
+  kValueMethodType = 0x15,    // size - 1 (0…3)  ubyte[size]
+  kValueMethodHandle = 0x16,  // size - 1 (0…3)  ubyte[size]
+  kValueString = 0x17,        // size - 1 (0…3)  ubyte[size]
+  kValueType = 0x18,          // size - 1 (0…3)  ubyte[size]
+  kValueField = 0x19,         // size - 1 (0…3)  ubyte[size]
+  kValueMethod = 0x1a,        // size - 1 (0…3)  ubyte[size]
+  kValueEnum = 0x1b,          // size - 1 (0…3)  ubyte[size]
+  kValueArray = 0x1c,         // (none; must be 0) encoded_array
+  kValueAnnotation = 0x1d,    // (none; must be 0) encoded_annotation
+  kValueNull = 0x1e,          // (none; must be 0) (none)
+  kValueBoolean = 0x1f        // boolean (0…1)   (none)
+};
+
+class MIRPragmaElement {
+ public:
+  explicit MIRPragmaElement(MIRModule &m) : MIRPragmaElement(m.GetPragmaMPAllocator()) {
+    val.d = 0;
+  }
+
+  explicit MIRPragmaElement(MapleAllocator &subElemAllocator)
+      : subElemVec(subElemAllocator.Adapter()) {
+    subElemVec.clear();
+    val.d = 0;
+  }
+
+  ~MIRPragmaElement() = default;
+  void Dump(int indent) const;
+  void SubElemVecPushBack(MIRPragmaElement *elem) {
+    subElemVec.push_back(elem);
+  }
+
+  const MapleVector<MIRPragmaElement*> &GetSubElemVec() const {
+    return subElemVec;
+  }
+
+  const MIRPragmaElement *GetSubElement(uint64 i) const {
+    return subElemVec[i];
+  }
+
+  MapleVector<MIRPragmaElement*> &GetSubElemVec() {
+    return subElemVec;
+  }
+
+  const GStrIdx GetNameStrIdx() const {
+    return nameStrIdx;
+  }
+
+  const GStrIdx GetTypeStrIdx() const {
+    return typeStrIdx;
+  }
+
+  PragmaValueType GetType() const {
+    return valueType;
+  }
+
+  int32 GetI32Val() const {
+    return val.i;
+  }
+
+  int64 GetI64Val() const {
+    return val.j;
+  }
+
+  uint64 GetU64Val() const {
+    return val.u;
+  }
+
+  float GetFloatVal() const {
+    return val.f;
+  }
+
+  double GetDoubleVal() const {
+    return val.d;
+  }
+
+  void SetTypeStrIdx(GStrIdx strIdx) {
+    typeStrIdx = strIdx;
+  }
+
+  void SetNameStrIdx(GStrIdx strIdx) {
+    nameStrIdx = strIdx;
+  }
+
+  void SetType(PragmaValueType type) {
+    valueType = type;
+  }
+
+  void SetI32Val(int32 valI) {
+    this->val.i = valI;
+  }
+
+  void SetI64Val(int64 valJ) {
+    this->val.j = valJ;
+  }
+
+  void SetU64Val(uint64 valU) {
+    this->val.u = valU;
+  }
+
+  void SetFloatVal(float valF) {
+    this->val.f = valF;
+  }
+
+  void SetDoubleVal(double valD) {
+    this->val.d = valD;
+  }
+
+ private:
+  GStrIdx nameStrIdx{ 0 };
+  GStrIdx typeStrIdx{ 0 };
+  PragmaValueType valueType = kValueNull;
+  union {
+    int32 i;
+    int64 j;
+    uint64 u;
+    float f;
+    double d;
+  } val;
+  MapleVector<MIRPragmaElement*> subElemVec;
+};
+
+class MIRPragma {
+ public:
+  explicit MIRPragma(MIRModule &m) : MIRPragma(m, m.GetPragmaMPAllocator()) {}
+
+  MIRPragma(MIRModule &m, MapleAllocator &elemAllocator)
+      : mod(&m),
+        elementVec(elemAllocator.Adapter()) {}
+
+  ~MIRPragma() = default;
+  MIRPragmaElement *GetPragmaElemFromSignature(const std::string &signature);
+  void Dump(int indent) const;
+  void PushElementVector(MIRPragmaElement *elem) {
+    elementVec.push_back(elem);
+  }
+
+  void ClearElementVector() {
+    elementVec.clear();
+  }
+
+  PragmaKind GetKind() const {
+    return pragmaKind;
+  }
+
+  uint8 GetVisibility() const {
+    return visibility;
+  }
+
+  const GStrIdx GetStrIdx() const {
+    return strIdx;
+  }
+
+  const TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  const TyIdx GetTyIdxEx() const {
+    return tyIdxEx;
+  }
+
+  int32 GetParamNum() const {
+    return paramNum;
+  }
+
+  const MapleVector<MIRPragmaElement*> &GetElementVector() const {
+    return elementVec;
+  }
+
+  const MIRPragmaElement *GetNthElement(uint32 i) const {
+    return elementVec[i];
+  }
+
+  void ElementVecPushBack(MIRPragmaElement *elem) {
+    elementVec.push_back(elem);
+  }
+
+  void SetKind(PragmaKind kind) {
+    pragmaKind = kind;
+  }
+
+  void SetVisibility(uint8 visValue) {
+    visibility = visValue;
+  }
+
+  void SetStrIdx(GStrIdx idx) {
+    strIdx = idx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  void SetTyIdxEx(TyIdx idx) {
+    tyIdxEx = idx;
+  }
+
+  void SetParamNum(int32 num) {
+    paramNum = num;
+  }
+
+ private:
+  MIRModule *mod;
+  PragmaKind pragmaKind = kPragmaUnknown;
+  uint8 visibility = 0;
+  GStrIdx strIdx{ 0 };
+  TyIdx tyIdx{ 0 };
+  TyIdx tyIdxEx{ 0 };
+  int32 paramNum = -1;  // paramNum th param in function, -1 not for param annotation
+  MapleVector<MIRPragmaElement*> elementVec;
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_PRAGMA_H
diff --git a/src/mapleall/maple_ir/include/mir_preg.h b/src/mapleall/maple_ir/include/mir_preg.h
new file mode 100644
index 0000000000000000000000000000000000000000..12d22eaa0bde5e6c0e58835b921ea58fae08ca6e
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_preg.h
@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_PREG_H
+#define MAPLE_IR_INCLUDE_MIR_PREG_H
+#if MIR_FEATURE_FULL
+#include <climits>
+#include "mir_module.h"
+#include "global_tables.h"
+#endif  // MIR_FEATURE_FULL
+
+namespace maple {
+extern void PrintIndentation(int32 indent);
+
+// these special registers are encoded by negating the enumeration
+enum SpecialReg : signed int {
+  kSregSp = 1,
+  kSregFp = 2,
+  kSregGp = 3,
+  kSregThrownval = 4,
+  kSregMethodhdl = 5,
+  kSregRetval0 = 6,
+  kSregRetval1 = 7,
+  kSregLast = 8,
+};
+#if MIR_FEATURE_FULL
+class MIRPreg {
+ public:
+  explicit MIRPreg(uint32 n = 0) : MIRPreg(n, kPtyInvalid, nullptr) {}
+
+  MIRPreg(uint32 n, PrimType ptyp) : primType(ptyp), pregNo(n) {}
+
+  MIRPreg(uint32 n, PrimType ptyp, MIRType *mType) : primType(ptyp), pregNo(n), mirType(mType) {}
+
+  ~MIRPreg() = default;
+  void SetNeedRC(bool newNeedRC = true) {
+    this->needRC = newNeedRC;
+  }
+
+  bool NeedRC() const {
+    return needRC;
+  }
+
+  bool IsRef() const {
+    return mirType != nullptr && primType == PTY_ref;
+  }
+
+  PrimType GetPrimType() const {
+    return primType;
+  }
+
+  void SetPrimType(PrimType pty) {
+    primType = pty;
+  }
+
+  Opcode GetOp() const {
+    return op;
+  }
+
+  void SetOp(Opcode o) {
+    this->op = o;
+  }
+
+  int32 GetPregNo() const {
+    return pregNo;
+  }
+
+  void SetPregNo(int32 newPregNo) {
+    this->pregNo = newPregNo;
+  }
+
+  MIRType *GetMIRType() const {
+    return mirType;
+  }
+
+  void SetMIRType(MIRType *newMirType) {
+    this->mirType = newMirType;
+  }
+  union RematInfo {
+    const MIRConst *mirConst; // used only when op is OP_constval
+    const MIRSymbol *sym;     // used only when op is OP_addrof or OP_dread
+  } rematInfo;
+  FieldID fieldID = 0;  // used only when op is OP_addrof or OP_dread
+  bool addrUpper = false;  // used only when op is OP_addrof to indicate upper bits of address
+
+ private:
+  PrimType primType = kPtyInvalid;
+  bool needRC = false;
+  Opcode op = OP_undef; // OP_constval, OP_addrof or OP_dread if rematerializable
+  int32 pregNo;  // the number in maple IR after the %
+  MIRType *mirType = nullptr;
+};
+
+class MIRPregTable {
+ public:
+  explicit MIRPregTable(MapleAllocator *allocator)
+      : pregNoToPregIdxMap(allocator->Adapter()),
+        pregTable(allocator->Adapter()),
+        mAllocator(allocator) {
+    pregTable.push_back(nullptr);
+    specPregTable[0].SetPregNo(0);
+    specPregTable[kSregSp].SetPregNo(-kSregSp);
+    specPregTable[kSregFp].SetPregNo(-kSregFp);
+    specPregTable[kSregGp].SetPregNo(-kSregGp);
+    specPregTable[kSregThrownval].SetPregNo(-kSregThrownval);
+    specPregTable[kSregMethodhdl].SetPregNo(-kSregMethodhdl);
+    specPregTable[kSregRetval0].SetPregNo(-kSregRetval0);
+    specPregTable[kSregRetval1].SetPregNo(-kSregRetval1);
+    for (uint32 i = 0; i < kSregLast; ++i) {
+      specPregTable[i].SetPrimType(PTY_unknown);
+    }
+  }
+
+  ~MIRPregTable();
+
+  PregIdx CreatePreg(PrimType primType, MIRType *mtype = nullptr) {
+    ASSERT(!mtype || mtype->GetPrimType() == PTY_ref || mtype->GetPrimType() == PTY_ptr, "ref or ptr type");
+    uint32 index = ++maxPregNo;
+    auto *preg = mAllocator->GetMemPool()->New<MIRPreg>(index, primType, mtype);
+    return AddPreg(*preg);
+  }
+
+  PregIdx ClonePreg(const MIRPreg &rfpreg) {
+    PregIdx idx = CreatePreg(rfpreg.GetPrimType(), rfpreg.GetMIRType());
+    MIRPreg *preg = pregTable[static_cast<uint32>(idx)];
+    preg->SetNeedRC(rfpreg.NeedRC());
+    return idx;
+  }
+
+  MIRPreg *PregFromPregIdx(PregIdx pregidx) {
+    if (pregidx < 0) {  // special register
+      return &specPregTable[-pregidx];
+    } else {
+      return pregTable.at(static_cast<uint32>(pregidx));
+    }
+  }
+
+  PregIdx GetPregIdxFromPregno(uint32 pregNo) {
+    auto it = pregNoToPregIdxMap.find(pregNo);
+    return (it == pregNoToPregIdxMap.end()) ? PregIdx(0) : it->second;
+  }
+
+  void DumpPregsWithTypes(int32 indent) {
+    MapleVector<MIRPreg *> &pregtable = pregTable;
+    for (uint32 i = 1; i < pregtable.size(); i++) {
+      MIRPreg *mirpreg = pregtable[i];
+      if (mirpreg->GetMIRType() == nullptr) {
+        continue;
+      }
+      PrintIndentation(indent);
+      LogInfo::MapleLogger() << "reg ";
+      LogInfo::MapleLogger() << "%" << mirpreg->GetPregNo();
+      LogInfo::MapleLogger() << " ";
+      mirpreg->GetMIRType()->Dump(0);
+      LogInfo::MapleLogger() << " " << (mirpreg->NeedRC() ? 1 : 0);
+      LogInfo::MapleLogger() << "\n";
+    }
+  }
+
+  size_t Size() const {
+    return pregTable.size();
+  }
+
+  PregIdx AddPreg(MIRPreg &preg) {
+    PregIdx idx = static_cast<PregIdx>(pregTable.size());
+    pregTable.push_back(&preg);
+    ASSERT(pregNoToPregIdxMap.find(preg.GetPregNo()) == pregNoToPregIdxMap.end(), "The same pregno is already taken");
+    pregNoToPregIdxMap[preg.GetPregNo()] = idx;
+    return idx;
+  }
+
+  PregIdx EnterPregNo(uint32 pregNo, PrimType ptyp, MIRType *ty = nullptr) {
+    PregIdx idx = GetPregIdxFromPregno(pregNo);
+    if (idx == 0) {
+      if (pregNo > maxPregNo) {
+        maxPregNo = pregNo;
+      }
+      MIRPreg *preg = mAllocator->GetMemPool()->New<MIRPreg>(pregNo, ptyp, ty);
+      return AddPreg(*preg);
+    }
+    return idx;
+  }
+
+  MapleVector<MIRPreg*> &GetPregTable() {
+    return pregTable;
+  }
+
+  const MapleVector<MIRPreg*> &GetPregTable() const {
+    return pregTable;
+  }
+
+  const MIRPreg *GetPregTableItem(const uint32 index) const {
+    CHECK_FATAL(index < pregTable.size(), "array index out of range");
+    return pregTable[index];
+  }
+
+  void SetPregNoToPregIdxMapItem(uint32 key, PregIdx value) {
+    pregNoToPregIdxMap[key] = value;
+  }
+
+  uint32 GetMaxPregNo() const {
+    return maxPregNo;
+  }
+
+  void SetMaxPregNo(uint32 index) {
+    maxPregNo = index;
+  }
+
+ private:
+  uint32 maxPregNo = 0;  //  the max pregNo that has been allocated
+  MapleMap<uint32, PregIdx> pregNoToPregIdxMap;  // for quick lookup based on pregno
+  MapleVector<MIRPreg*> pregTable;
+  MIRPreg specPregTable[kSregLast];  // for the MIRPreg nodes corresponding to special registers
+  MapleAllocator *mAllocator;
+};
+
+#endif  // MIR_FEATURE_FULL
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_PREG_H
diff --git a/src/mapleall/maple_ir/include/mir_scope.h b/src/mapleall/maple_ir/include/mir_scope.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d404f42efa0d12ab44369aefbdab2866f6ddf5c
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_scope.h
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_SCOPE_H
+#define MAPLE_IR_INCLUDE_MIR_SCOPE_H
+#include <tuple>
+#include "mir_module.h"
+#include "mir_type.h"
+#include "src_position.h"
+
+namespace maple {
+// mapping src variable to mpl variables to display debug info
+enum AliasTypeKind : uint8 {
+  kATKType,
+  kATKString,
+  kATKEnum,
+};
+
+struct MIRAliasVars {
+  GStrIdx mplStrIdx;      // maple varialbe name
+  AliasTypeKind atk;
+  unsigned index;
+  bool isLocal;
+  GStrIdx sigStrIdx;
+  TypeAttrs attrs;
+};
+
+class MIRAlias {
+ public:
+  explicit MIRAlias(MIRModule *mod) : module(mod) {}
+  ~MIRAlias() = default;
+
+  bool IsEmpty() const {
+    return aliasVarMap.size() == 0;
+  }
+
+  void SetAliasVarMap(GStrIdx idx, const MIRAliasVars &vars) {
+    aliasVarMap[idx] = vars;
+  }
+
+  MapleMap<GStrIdx, MIRAliasVars> &GetAliasVarMap() {
+    return aliasVarMap;
+  }
+
+  void Dump(int32 indent, bool isLocal = true) const;
+
+ private:
+  MIRModule *module;
+  // source to maple variable alias
+  MapleMap<GStrIdx, MIRAliasVars> aliasVarMap { module->GetMPAllocator().Adapter() };
+};
+
+class MIRTypeAlias {
+ public:
+  explicit MIRTypeAlias(MIRModule *mod) : module(mod) {}
+  virtual ~MIRTypeAlias() = default;
+
+  bool IsEmpty() const {
+    return typeAliasMap.size() == 0;
+  }
+
+  bool Exist(GStrIdx idx) const {
+    return typeAliasMap.find(idx) != typeAliasMap.end();
+  }
+
+  const MapleMap<GStrIdx, TyIdx> &GetTypeAliasMap() const {
+    return typeAliasMap;
+  }
+
+  TyIdx GetTyIdxFromMap(GStrIdx idx) const {
+    auto it = typeAliasMap.find(idx);
+    if (it == typeAliasMap.cend()) {
+      return TyIdx(0);
+    }
+    return it->second;
+  }
+
+  void SetTypeAliasMap(GStrIdx gStrIdx, TyIdx tyIdx) {
+    typeAliasMap[gStrIdx] = tyIdx;
+  }
+
+  void Dump(int32 indent) const;
+
+ private:
+  MIRModule *module;
+  MapleMap<GStrIdx, TyIdx> typeAliasMap { module->GetMPAllocator().Adapter() };
+};
+
+class MIRScope {
+ public:
+  explicit MIRScope(MIRModule *mod, MIRFunction *f = nullptr);
+  ~MIRScope() = default;
+
+  bool IsEmpty() const {
+    return (alias == nullptr || alias->IsEmpty()) &&
+           (typeAlias == nullptr || typeAlias->IsEmpty()) &&
+           subScopes.size() == 0;
+  }
+
+  bool IsSubScope(const MIRScope *scp) const;
+  bool HasJoinScope(const MIRScope *scp1, const MIRScope *scp2) const;
+  bool HasSameRange(const MIRScope *s1, const MIRScope *s2) const;
+
+  unsigned GetId() const {
+    return id;
+  }
+
+  void SetId(unsigned i) {
+    id = i;
+  }
+
+  const SrcPosition &GetRangeLow() const {
+    return range.first;
+  }
+
+  const SrcPosition &GetRangeHigh() const {
+    return range.second;
+  }
+
+  void SetRange(SrcPosition low, SrcPosition high) {
+    // The two positions that were changed by the #line directive may be not in the same file.
+    ASSERT(!low.IsSameFile(high) || low.IsBfOrEq(high), "wrong order of low and high");
+    range.first = low;
+    range.second = high;
+  }
+
+  void SetAliasVarMap(GStrIdx idx, const MIRAliasVars &vars) {
+    alias->SetAliasVarMap(idx, vars);
+  }
+
+  MapleMap<GStrIdx, MIRAliasVars> &GetAliasVarMap() {
+    return alias->GetAliasVarMap();
+  }
+
+  MapleVector<MIRScope*> &GetSubScopes() {
+    return subScopes;
+  }
+
+  void AddTuple(SrcPosition pos, SrcPosition posB, SrcPosition posE) {
+    if (pos.LineNum() == 0 || posB.LineNum() == 0 || posE.LineNum() == 0) {
+      return;
+    }
+    std::tuple<SrcPosition, SrcPosition, SrcPosition> srcPos(pos, posB, posE);
+    blkSrcPos.push_back(srcPos);
+  }
+
+  SrcPosition GetScopeEndPos(const SrcPosition &pos);
+  bool AddScope(MIRScope *scope);
+
+  void SetTypeAliasMap(GStrIdx gStrIdx, TyIdx tyIdx) {
+    typeAlias->SetTypeAliasMap(gStrIdx, tyIdx);
+  }
+
+  MIRTypeAlias *GetTypeAlias() {
+    return typeAlias;
+  }
+
+  const MIRTypeAlias *GetTypeAlias() const {
+    return typeAlias;
+  }
+
+  void SetIsLocal(bool b) {
+    isLocal = b;
+  }
+
+  bool IsLocal() const {
+    return isLocal;
+  }
+
+  void DumpTypedef(int32 indent) const;
+  void Dump(int32 indent) const;
+  void Dump() const;
+
+ private:
+  MIRModule *module;
+  MIRFunction *func;
+  unsigned id;
+  bool isLocal;
+  std::pair<SrcPosition, SrcPosition> range;
+  MIRAlias *alias = nullptr;
+  MIRTypeAlias *typeAlias = nullptr;
+  // subscopes' range should be disjoint
+  MapleVector<MIRScope*> subScopes { module->GetMPAllocator().Adapter() };
+  MapleVector<std::tuple<SrcPosition, SrcPosition, SrcPosition>> blkSrcPos { module->GetMPAllocator().Adapter() };
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_SCOPE_H
diff --git a/src/mapleall/maple_ir/include/mir_symbol.h b/src/mapleall/maple_ir/include/mir_symbol.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c6324ac53b80c1b602b474e2ee61f6e01462679
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_symbol.h
@@ -0,0 +1,718 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_SYMBOL_H
+#define MAPLE_IR_INCLUDE_MIR_SYMBOL_H
+#include <sstream>
+#include "mir_const.h"
+#include "mir_preg.h"
+#include "src_position.h"
+
+constexpr int kScopeLocal = 2;   // the default scope level for function variables
+constexpr int kScopeGlobal = 1;  // the scope level for global variables
+
+namespace maple {
+enum MIRSymKind {
+  kStInvalid,
+  kStVar,
+  kStFunc,
+  kStConst,
+  kStJavaClass,
+  kStJavaInterface,
+  kStPreg
+};
+
+enum MIRStorageClass : uint8 {
+  kScInvalid,
+  kScAuto,
+  kScAliased,
+  kScFormal,
+  kScExtern,
+  kScGlobal,
+  kScPstatic,  // PU-static
+  kScFstatic,  // file-static
+  kScText,
+  kScTypeInfo,      // used for eh type st
+  kScTypeInfoName,  // used for eh type st name
+  kScTypeCxxAbi,    // used for eh inherited from c++ __cxxabiv1
+  kScEHRegionSupp,  // used for tables that control C++ exception handling
+  kScUnused
+};
+
+// to represent a single symbol
+class MIRSymbol {
+ public:
+  union SymbolType {  // a symbol can either be a const or a function or a preg which currently used for formal
+    MIRConst *konst;
+    MIRFunction *mirFunc;
+    MIRPreg *preg;  // the MIRSymKind must be kStPreg
+  };
+
+  MIRSymbol() = default;
+  MIRSymbol(uint32 idx, uint8 scp) : stIdx(scp, idx) {}
+  ~MIRSymbol() = default;
+
+  void SetIsTmp(bool temp) {
+    isTmp = temp;
+  }
+
+  bool GetIsTmp() const {
+    return isTmp;
+  }
+
+  void SetNeedForwDecl() {
+    needForwDecl = true;
+  }
+
+  bool IsNeedForwDecl() const {
+    return needForwDecl;
+  }
+
+  void SetInstrumented() {
+    instrumented = true;
+  }
+
+  bool IsInstrumented() const {
+    return instrumented;
+  }
+
+  void SetIsImported(bool imported) {
+    isImported = imported;
+  }
+
+  bool GetIsImported() const {
+    return isImported;
+  }
+
+  void SetWPOFakeParm() {
+    wpoFakeParam = true;
+  }
+
+  bool IsWpoFakeParm() const {
+    return wpoFakeParam;
+  }
+
+  bool IsWpoFakeRet() const {
+    return wpoFakeRet;
+  }
+
+  void SetWPOFakeRet() {
+    wpoFakeRet = true;
+  }
+
+  void SetIsTmpUnused(bool unused) {
+    isTmpUnused = unused;
+  }
+
+  void SetIsImportedDecl(bool imported) {
+    isImportedDecl = imported;
+  }
+
+  bool GetIsImportedDecl() const {
+    return isImportedDecl;
+  }
+
+  bool IsTmpUnused() const {
+    return isTmpUnused;
+  }
+
+  void SetAppearsInCode(bool appears) {
+    appearsInCode = appears;
+  }
+
+  bool GetAppearsInCode() const {
+    return appearsInCode;
+  }
+
+  void SetTyIdx(const TyIdx &newTyIdx) {
+    this->tyIdx = newTyIdx;
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetInferredTyIdx(const TyIdx &newInferredTyIdx) {
+    this->inferredTyIdx = newInferredTyIdx;
+  }
+
+  TyIdx GetInferredTyIdx() const {
+    return inferredTyIdx;
+  }
+
+  void SetStIdx(const StIdx &newStIdx) {
+    this->stIdx = newStIdx;
+  }
+
+  StIdx GetStIdx() const {
+    return stIdx;
+  }
+
+  void SetSKind(MIRSymKind m) {
+    sKind = m;
+  }
+
+  MIRSymKind GetSKind() const {
+    return sKind;
+  }
+
+  uint32 GetScopeIdx() const {
+    return stIdx.Scope();
+  }
+
+  uint32 GetStIndex() const {
+    return stIdx.Idx();
+  }
+
+  bool IsLocal() const {
+    return stIdx.Islocal();
+  }
+
+  bool IsGlobal() const {
+    return stIdx.IsGlobal();
+  }
+
+  const TypeAttrs &GetAttrs() const {
+    return typeAttrs;
+  }
+
+  TypeAttrs &GetAttrs() {
+    return typeAttrs;
+  }
+
+  void SetAttrs(TypeAttrs attr) {
+    typeAttrs = attr;
+  }
+
+  // AddAttrs adds more attributes instead of overrides the current one
+  void AddAttrs(TypeAttrs attr) {
+    typeAttrs.SetAttrFlag(typeAttrs.GetAttrFlag() | attr.GetAttrFlag());
+    typeAttrs.AddAttrBoundary(attr.GetAttrBoundary());
+  }
+
+  bool GetAttr(AttrKind attrKind) const {
+    return typeAttrs.GetAttr(attrKind);
+  }
+
+  void SetAttr(AttrKind attrKind) {
+    typeAttrs.SetAttr(attrKind);
+  }
+
+  void ResetAttr(AttrKind attrKind) {
+    typeAttrs.ResetAttr(attrKind);
+  }
+
+  bool IsVolatile() const {
+    return typeAttrs.GetAttr(ATTR_volatile);
+  }
+
+  bool IsTypeVolatile(int fieldID) const;
+
+  bool NeedPIC() const;
+
+  bool IsThreadLocal() const {
+    return typeAttrs.GetAttr(ATTR_tls_static) || typeAttrs.GetAttr(ATTR_tls_dynamic);
+  }
+
+  bool IsStatic() const {
+    return typeAttrs.GetAttr(ATTR_static);
+  }
+
+  bool IsPUStatic() const {
+    return GetStorageClass() == kScPstatic;
+  }
+
+  bool IsFinal() const {
+    return ((typeAttrs.GetAttr(ATTR_final) || typeAttrs.GetAttr(ATTR_readonly)) &&
+            staticFinalBlackList.find(GetName()) == staticFinalBlackList.end()) ||
+           IsLiteral() || IsLiteralPtr();
+  }
+
+  bool IsWeak() const {
+    return typeAttrs.GetAttr(ATTR_weak);
+  }
+
+  bool IsPrivate() const {
+    return typeAttrs.GetAttr(ATTR_private);
+  }
+
+  bool IsRefType() const {
+    return typeAttrs.GetAttr(ATTR_localrefvar);
+  }
+
+  void SetNameStrIdx(GStrIdx strIdx) {
+    nameStrIdx = strIdx;
+  }
+
+  void SetNameStrIdx(const std::string &name);
+
+  GStrIdx GetNameStrIdx() const {
+    return nameStrIdx;
+  }
+
+  MIRStorageClass GetStorageClass() const {
+    return storageClass;
+  }
+
+  void SetStorageClass(MIRStorageClass cl) {
+    storageClass = cl;
+  }
+
+  bool IsReadOnly() const {
+    return kScFstatic == storageClass && kStConst == sKind;
+  }
+
+  bool IsConst() const {
+    return sKind == kStConst || (sKind == kStVar && value.konst != nullptr);
+  }
+
+  MIRType *GetType() const;
+
+  const std::string &GetName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(nameStrIdx);
+  }
+
+  MIRConst *GetKonst() const {
+    ASSERT((sKind == kStConst || sKind == kStVar), "must be const symbol");
+    return value.konst;
+  }
+
+  void SetKonst(MIRConst *mirconst) {
+    ASSERT((sKind == kStConst || sKind == kStVar), "must be const symbol");
+    value.konst = mirconst;
+  }
+
+  void SetIsDeleted() {
+    isDeleted = true;
+  }
+
+  void ResetIsDeleted() {
+    isDeleted = false;
+  }
+
+  bool IsDeleted() const {
+    return isDeleted;
+  }
+
+  bool IsVar() const {
+    return sKind == kStVar;
+  }
+
+  bool IsFunction() const {
+    return sKind == kStFunc;
+  }
+
+  bool IsPreg() const {
+    return sKind == kStPreg;
+  }
+
+  bool IsJavaClassInterface() const {
+    return sKind == kStJavaClass || sKind == kStJavaInterface;
+  }
+
+  SymbolType GetValue() const {
+    return value;
+  }
+
+  void SetValue(SymbolType newValue) {
+    this->value = newValue;
+  }
+
+  SrcPosition &GetSrcPosition() {
+    return srcPosition;
+  }
+
+  const SrcPosition &GetSrcPosition() const {
+    return srcPosition;
+  }
+
+  void SetSrcPosition(const SrcPosition &position) {
+    srcPosition = position;
+  }
+
+  MIRPreg *GetPreg() {
+    ASSERT(IsPreg(), "must be Preg");
+    return value.preg;
+  }
+
+  const MIRPreg *GetPreg() const {
+    CHECK_FATAL(IsPreg(), "must be Preg");
+    return value.preg;
+  }
+
+  void SetPreg(MIRPreg *preg) {
+    CHECK_FATAL(IsPreg(), "must be Preg");
+    value.preg = preg;
+  }
+
+  bool CanBeIgnored() const {
+    return isDeleted;
+  }
+
+  void SetLocalRefVar() {
+    SetAttr(ATTR_localrefvar);
+  }
+
+  void ResetLocalRefVar() {
+    ResetAttr(ATTR_localrefvar);
+  }
+
+  MIRFunction *GetFunction() const {
+    ASSERT(sKind == kStFunc, "must be function symbol");
+    return value.mirFunc;
+  }
+
+  void SetFunction(MIRFunction *func) {
+    ASSERT(sKind == kStFunc, "must be function symbol");
+    value.mirFunc = func;
+  }
+
+  bool IsEhIndex() const {
+    return GetName() == "__eh_index__";
+  }
+
+  bool HasAddrOfValues() const;
+  bool IsLiteral() const;
+  bool IsLiteralPtr() const;
+  bool PointsToConstString() const;
+  bool IsConstString() const;
+  bool IsClassInitBridge() const;
+  bool IsReflectionStrTab() const;
+  bool IsReflectionHashTabBucket() const;
+  bool IsReflectionInfo() const;
+  bool IsReflectionFieldsInfo() const;
+  bool IsReflectionFieldsInfoCompact() const;
+  bool IsReflectionSuperclassInfo() const;
+  bool IsReflectionFieldOffsetData() const;
+  bool IsReflectionMethodAddrData() const;
+  bool IsReflectionMethodSignature() const;
+  bool IsReflectionClassInfo() const;
+  bool IsReflectionArrayClassInfo() const;
+  bool IsReflectionClassInfoPtr() const;
+  bool IsReflectionClassInfoRO() const;
+  bool IsITabConflictInfo() const;
+  bool IsVTabInfo() const;
+  bool IsITabInfo() const;
+  bool IsReflectionPrimitiveClassInfo() const;
+  bool IsReflectionMethodsInfo() const;
+  bool IsReflectionMethodsInfoCompact() const;
+  bool IsRegJNITab() const;
+  bool IsRegJNIFuncTab() const;
+  bool IsMuidTab() const;
+  bool IsMuidRoTab() const;
+  bool IsCodeLayoutInfo() const;
+  std::string GetMuidTabName() const;
+  bool IsMuidFuncDefTab() const;
+  bool IsMuidFuncDefOrigTab() const;
+  bool IsMuidFuncInfTab() const;
+  bool IsMuidFuncUndefTab() const;
+  bool IsMuidDataDefTab() const;
+  bool IsMuidDataDefOrigTab() const;
+  bool IsMuidDataUndefTab() const;
+  bool IsMuidFuncDefMuidTab() const;
+  bool IsMuidFuncUndefMuidTab() const;
+  bool IsMuidDataDefMuidTab() const;
+  bool IsMuidDataUndefMuidTab() const;
+  bool IsMuidFuncMuidIdxMuidTab() const;
+  bool IsMuidRangeTab() const;
+  bool IsArrayClassCache() const;
+  bool IsArrayClassCacheName() const;
+  bool IsForcedGlobalFunc() const;
+  bool IsForcedGlobalClassinfo() const;
+  bool IsGctibSym() const;
+  bool IsPrimordialObject() const;
+  bool IgnoreRC() const;
+  void Dump(bool isLocal, int32 indent, bool suppressInit = false, const MIRSymbolTable *localsymtab = nullptr) const;
+  void DumpAsLiteralVar() const;
+  bool operator==(const MIRSymbol &msym) const {
+    return nameStrIdx == msym.nameStrIdx;
+  }
+
+  bool operator!=(const MIRSymbol &msym) const {
+    return nameStrIdx != msym.nameStrIdx;
+  }
+
+  bool operator<(const MIRSymbol &msym) const {
+    return nameStrIdx < msym.nameStrIdx;
+  }
+
+  static uint32 &LastPrintedLineNumRef() {
+    return lastPrintedLineNum;
+  }
+
+  static uint16 &LastPrintedColumnNumRef() {
+    return lastPrintedColumnNum;
+  }
+
+  bool HasPotentialAssignment() const {
+    return hasPotentialAssignment;
+  }
+
+  void SetHasPotentialAssignment() {
+    hasPotentialAssignment = true;
+  }
+
+  void SetAsmAttr(const UStrIdx &idx) {
+    asmAttr = idx;
+  }
+
+  const UStrIdx &GetAsmAttr() const {
+    return asmAttr;
+  }
+
+  void SetWeakrefAttr(const std::pair<bool, UStrIdx> &idx) {
+    weakrefAttr = idx;
+  }
+
+  const std::pair<bool, UStrIdx> &GetWeakrefAttr() const {
+    return weakrefAttr;
+  }
+
+  bool IsFormal() const {
+    return storageClass == kScFormal;
+  }
+
+  bool LMBCAllocateOffSpecialReg() const {
+    if (isDeleted) {
+      return false;
+    }
+    switch (storageClass) {
+      case kScAuto:
+        return true;
+      case kScPstatic:
+      case kScFstatic:
+        return value.konst == nullptr && !hasPotentialAssignment;
+      default:
+        return false;
+    }
+  }
+  UStrIdx asmAttr { 0 }; // if not 0, the string for the name in C's asm attribute
+  UStrIdx sectionAttr { 0 }; // if not 0, the string for the name in C's section attribute
+
+  // Please keep order of the fields, avoid paddings.
+ private:
+  TyIdx tyIdx{ 0 };
+  TyIdx inferredTyIdx{ kInitTyIdx };
+  MIRStorageClass storageClass{ kScInvalid };
+  MIRSymKind sKind{ kStInvalid };
+  bool isTmp = false;
+  bool needForwDecl = false;  // addrof of this symbol used in initialization, NOT serialized
+  bool wpoFakeParam = false;  // fake symbol introduced in wpo phase for a parameter, NOT serialized
+  bool wpoFakeRet = false;    // fake symbol introduced in wpo phase for return value, NOT serialized
+  bool isDeleted = false;     // tell if it is deleted, NOT serialized
+  bool instrumented = false;  // a local ref pointer instrumented by RC opt, NOT serialized
+  bool isImported = false;
+  bool isImportedDecl = false;
+  bool isTmpUnused = false;  // when parse the mplt_inline file, mark all the new symbol as tmpunused
+  bool appearsInCode = false;  // only used for kStFunc
+  bool hasPotentialAssignment = false; // for global static vars, init as false and will be set true
+                                       // if assigned by stmt or the address of itself is taken
+  StIdx stIdx { 0, 0 };
+  TypeAttrs typeAttrs;
+  GStrIdx nameStrIdx{ 0 };
+  std::pair<bool, UStrIdx> weakrefAttr { false, 0 };
+  SymbolType value = { nullptr };
+  SrcPosition srcPosition;      // where the symbol is defined
+  // following cannot be assumed final even though they are declared final
+  static const std::set<std::string> staticFinalBlackList;
+  static GStrIdx reflectClassNameIdx;
+  static GStrIdx reflectMethodNameIdx;
+  static GStrIdx reflectFieldNameIdx;
+  static uint32 lastPrintedLineNum;     // used during printing ascii output
+  static uint16 lastPrintedColumnNum;
+};
+
+class MIRSymbolTable {
+ public:
+  explicit MIRSymbolTable(const MapleAllocator &allocator)
+      : mAllocator(allocator),
+        strIdxToStIdxMap(mAllocator.Adapter()),
+        symbolTable({ nullptr }, mAllocator.Adapter()) {}
+
+  ~MIRSymbolTable() = default;
+
+  bool IsValidIdx(uint32 idx) const {
+    return idx < symbolTable.size();
+  }
+
+  MIRSymbol *GetSymbolFromStIdx(uint32 idx, bool checkFirst = false) const {
+    if (checkFirst && idx >= symbolTable.size()) {
+      return nullptr;
+    }
+    CHECK_FATAL(IsValidIdx(idx), "symbol table index out of range");
+    return symbolTable[idx];
+  }
+
+  MIRSymbol *CreateSymbol(uint8 scopeID) {
+    auto *st = mAllocator.GetMemPool()->New<MIRSymbol>(symbolTable.size(), scopeID);
+    symbolTable.push_back(st);
+    return st;
+  }
+
+  void PushNullSymbol() {
+    symbolTable.push_back(nullptr);
+  }
+
+  // add sym from other symbol table, happens in inline
+  bool AddStOutside(MIRSymbol *sym) {
+    if (sym == nullptr) {
+      return false;
+    }
+    sym->SetStIdx(StIdx(sym->GetScopeIdx(), symbolTable.size()));
+    symbolTable.push_back(sym);
+    return AddToStringSymbolMap(*sym);
+  }
+
+  bool AddToStringSymbolMap(const MIRSymbol &st) {
+    GStrIdx strIdx = st.GetNameStrIdx();
+    if (strIdxToStIdxMap[strIdx].FullIdx() != 0) {
+      return false;
+    }
+    strIdxToStIdxMap[strIdx] = st.GetStIdx();
+    return true;
+  }
+
+  StIdx GetStIdxFromStrIdx(GStrIdx idx) const {
+    auto it = strIdxToStIdxMap.find(idx);
+    return (it == strIdxToStIdxMap.end()) ? StIdx() : it->second;
+  }
+
+  MIRSymbol *GetSymbolFromStrIdx(const GStrIdx &idx, bool checkFirst = false) const {
+    return GetSymbolFromStIdx(GetStIdxFromStrIdx(idx).Idx(), checkFirst);
+  }
+
+  void Dump(bool isLocal, int32 indent = 0, bool printDeleted = false,
+            MIRFlavor flavor = kFlavorUnknown) const;
+  size_t GetSymbolTableSize() const {
+    return symbolTable.size();
+  }
+
+  void Clear() {
+    symbolTable.clear();
+    strIdxToStIdxMap.clear();
+  }
+
+  MIRSymbol *CloneLocalSymbol(const MIRSymbol &oldSym) const {
+    auto *memPool = mAllocator.GetMemPool();
+    auto *newSym = memPool->New<MIRSymbol>(oldSym);
+    if (oldSym.GetSKind() == kStConst) {
+      newSym->SetKonst(oldSym.GetKonst()->Clone(*memPool));
+    } else if (oldSym.GetSKind() == kStPreg) {
+      newSym->SetPreg(memPool->New<MIRPreg>(*oldSym.GetPreg()));
+    } else if (oldSym.GetSKind() == kStFunc) {
+      CHECK_FATAL(false, "%s has unexpected local func symbol", oldSym.GetName().c_str());
+    }
+    return newSym;
+  }
+
+ private:
+  MapleAllocator mAllocator;
+  // hash table mapping string index to st index
+  MapleMap<GStrIdx, StIdx> strIdxToStIdxMap;
+  // map symbol idx to symbol node
+  MapleVector<MIRSymbol*> symbolTable;
+};
+
+class MIRLabelTable {
+ public:
+  explicit MIRLabelTable(MapleAllocator &allocator)
+      : addrTakenLabels(allocator.Adapter()),
+        caseLabelSet(allocator.Adapter()),
+        mAllocator(allocator),
+        strIdxToLabIdxMap(std::less<GStrIdx>(), mAllocator.Adapter()),
+        labelTable(mAllocator.Adapter()) {
+    labelTable.push_back(GStrIdx(kDummyLabel));  // push dummy label index 0
+  }
+
+  ~MIRLabelTable() = default;
+
+  LabelIdx CreateLabel() {
+    LabelIdx labelIdx = labelTable.size();
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(std::to_string(labelIdx));
+    labelTable.push_back(strIdx);
+    return labelIdx;
+  }
+
+  LabelIdx CreateLabelWithPrefix(char c);
+
+  LabelIdx AddLabel(GStrIdx nameIdx) {
+    LabelIdx labelIdx = labelTable.size();
+    labelTable.push_back(nameIdx);
+    strIdxToLabIdxMap[nameIdx] = labelIdx;
+    return labelIdx;
+  }
+
+  LabelIdx GetLabelIdxFromStrIdx(GStrIdx idx) const {
+    auto it = strIdxToLabIdxMap.find(idx);
+    if (it == strIdxToLabIdxMap.end()) {
+      return LabelIdx();
+    }
+    return it->second;
+  }
+
+  void AddToStringLabelMap(LabelIdx labelIdx);
+  size_t GetLabelTableSize() const {
+    return labelTable.size();
+  }
+
+  const std::string &GetName(LabelIdx labelIdx) const;
+
+  size_t Size() const {
+    return labelTable.size();
+  }
+
+  static uint32 GetDummyLabel() {
+    return kDummyLabel;
+  }
+
+  GStrIdx GetSymbolFromStIdx(LabelIdx idx) const {
+    CHECK_FATAL(idx < labelTable.size(), "label table index out of range");
+    return labelTable[idx];
+  }
+
+  void SetSymbolFromStIdx(LabelIdx idx, GStrIdx strIdx) {
+    CHECK_FATAL(idx < labelTable.size(), "label table index out of range");
+    labelTable[idx] = strIdx;
+  }
+
+  MapleVector<GStrIdx> GetLabelTable() {
+    return labelTable;
+  }
+
+  const MapleUnorderedSet<LabelIdx> &GetAddrTakenLabels() const {
+    return addrTakenLabels;
+  }
+
+  MapleUnorderedSet<LabelIdx> &GetAddrTakenLabels() {
+    return addrTakenLabels;
+  }
+
+  const MapleMap<GStrIdx, LabelIdx> &GetStrIdxToLabelIdxMap() const {
+    return strIdxToLabIdxMap;
+  }
+  void EraseStrIdxToLabelIdxElem(GStrIdx idx) {
+    strIdxToLabIdxMap.erase(idx);
+  }
+
+  MapleUnorderedSet<LabelIdx> addrTakenLabels; // those appeared in addroflabel or MIRLblConst
+  MapleUnorderedSet<LabelIdx> caseLabelSet;    // labels marking starts of switch cases
+
+ private:
+  static constexpr uint32 kDummyLabel = 0;
+  MapleAllocator mAllocator;
+  MapleMap<GStrIdx, LabelIdx> strIdxToLabIdxMap;
+  MapleVector<GStrIdx> labelTable;  // map label idx to label name
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_MIR_SYMBOL_H
diff --git a/src/mapleall/maple_ir/include/mir_symbol_builder.h b/src/mapleall/maple_ir/include/mir_symbol_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..866d2e2e3090f581b8d0bb3a2e714d3613b083ef
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_symbol_builder.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEIR_INCLUDE_MIRSYMBOLBUILDER_H
+#define MAPLEIR_INCLUDE_MIRSYMBOLBUILDER_H
+#include <string>
+#include <utility>
+#include <vector>
+#include <map>
+#include "opcodes.h"
+#include "prim_types.h"
+#include "mir_type.h"
+#include "mir_const.h"
+#include "mir_symbol.h"
+#include "mir_nodes.h"
+#include "mir_module.h"
+#include "mir_preg.h"
+#include "mir_function.h"
+#include "printing.h"
+#include "intrinsic_op.h"
+#include "opcode_info.h"
+#include "global_tables.h"
+
+namespace maple {
+class MIRSymbolBuilder {
+ public:
+  static MIRSymbolBuilder &Instance() {
+    static MIRSymbolBuilder builder;
+    return builder;
+  }
+
+  MIRSymbol *GetLocalDecl(const MIRSymbolTable &symbolTable, const GStrIdx &strIdx) const;
+  MIRSymbol *CreateLocalDecl(MIRSymbolTable &symbolTable, GStrIdx strIdx, const MIRType &type) const;
+  MIRSymbol *GetGlobalDecl(GStrIdx strIdx) const;
+  MIRSymbol *CreateGlobalDecl(GStrIdx strIdx, const MIRType &type, MIRStorageClass sc) const;
+  MIRSymbol *GetSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                       bool sameType = false) const;
+  MIRSymbol *CreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                          MIRFunction *func, uint8 scpID) const;
+  MIRSymbol *CreatePregFormalSymbol(TyIdx tyIdx, PregIdx pRegIdx, MIRFunction &func) const;
+  size_t GetSymbolTableSize(const MIRFunction *func = nullptr) const;
+  const MIRSymbol *GetSymbolFromStIdx(uint32 idx, const MIRFunction *func = nullptr) const;
+
+ private:
+  MIRSymbolBuilder() = default;
+  ~MIRSymbolBuilder() = default;
+  MIRSymbolBuilder(const MIRSymbolBuilder&) = delete;
+  MIRSymbolBuilder(const MIRSymbolBuilder&&) = delete;
+  MIRSymbolBuilder &operator=(const MIRSymbolBuilder&) = delete;
+  MIRSymbolBuilder &operator=(const MIRSymbolBuilder&&) = delete;
+};
+} // maple
+#endif // MAPLEIR_INCLUDE_MIRSYMBOLBUILDER_H
diff --git a/src/mapleall/maple_ir/include/mir_type.h b/src/mapleall/maple_ir/include/mir_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..048d56b4c2a18cc5d6fc7b917adcc4a216f2c883
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mir_type.h
@@ -0,0 +1,2184 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_MIR_TYPE_H
+#define MAPLE_IR_INCLUDE_MIR_TYPE_H
+#include <algorithm>
+#include <array>
+#include "prim_types.h"
+#include "mir_pragma.h"
+#include "mpl_logging.h"
+#if MIR_FEATURE_FULL
+#include "mempool.h"
+#include "mempool_allocator.h"
+#endif  // MIR_FEATURE_FULL
+
+namespace maple {
+constexpr uint32 kTypeHashLength = 12289;  // hash length for mirtype, ref: planetmath.org/goodhashtableprimes
+const std::string kRenameKeyWord = "_MNO";  // A static symbol name will be renamed as oriname_MNOxxx.
+
+class FieldAttrs;  // circular dependency exists, no other choice
+class MIRAlias;
+using TyIdxFieldAttrPair = std::pair<TyIdx, FieldAttrs>;
+using FieldPair = std::pair<GStrIdx, TyIdxFieldAttrPair>;
+using FieldVector = std::vector<FieldPair>;
+using MIRTypePtr = MIRType*;
+
+constexpr size_t kMaxArrayDim = 20;
+const std::string kJstrTypeName = "constStr";
+constexpr uint32 kInvalidFieldNum = UINT32_MAX;
+constexpr size_t kInvalidSize = UINT64_MAX;
+#if MIR_FEATURE_FULL
+extern bool VerifyPrimType(PrimType primType1, PrimType primType2);       // verify if primType1 and primType2 match
+extern PrimType GetExactPtrPrimType();  // return either PTY_a64 or PTY_a32
+extern uint32 GetPrimTypeSize(PrimType primType);                         // answer in bytes; 0 if unknown
+extern uint32 GetPrimTypeP2Size(PrimType primType);                       // answer in bytes in power-of-two.
+extern PrimType GetSignedPrimType(PrimType pty);                     // return signed version
+extern PrimType GetUnsignedPrimType(PrimType pty);                   // return unsigned version
+extern uint32 GetVecEleSize(PrimType primType);                           // element size of each lane in vector
+extern uint32 GetVecLanes(PrimType primType);                             // lane size if vector
+extern const char *GetPrimTypeName(PrimType primType);
+extern const char *GetPrimTypeJavaName(PrimType primType);
+extern int64 MinValOfSignedInteger(PrimType primType);
+extern PrimType GetVecElemPrimType(PrimType primType);
+constexpr uint32 k0BitSize = 0;
+constexpr uint32 k1BitSize = 1;
+constexpr uint32 k2BitSize = 2;
+constexpr uint32 k3BitSize = 3;
+constexpr uint32 k4BitSize = 4;
+constexpr uint32 k5BitSize = 5;
+constexpr uint32 k8BitSize = 8;
+constexpr uint32 k9BitSize = 9;
+constexpr uint32 k10BitSize = 10;
+constexpr uint32 k16BitSize = 16;
+constexpr uint32 k32BitSize = 32;
+constexpr uint32 k64BitSize = 64;
+
+inline const std::string kDbgLong = "long.";
+inline const std::string kDbgULong = "Ulong.";
+inline const std::string kDbgLongDouble = "LongDouble.";
+
+inline uint32 GetPrimTypeBitSize(PrimType primType) {
+  // 1 byte = 8 bits = 2^3 bits
+  return GetPrimTypeSize(primType) << 3;
+}
+
+inline uint32 GetAlignedPrimTypeBitSize(PrimType primType) {
+  auto size = GetPrimTypeBitSize(primType);
+  return size <= k32BitSize ? k32BitSize : k64BitSize;
+}
+
+inline uint32 GetPrimTypeActualBitSize(PrimType primType) {
+  // GetPrimTypeSize(PTY_u1) will return 1, so we take it as a special case
+  if (primType == PTY_u1) {
+    return 1;
+  }
+  // 1 byte = 8 bits = 2^3 bits
+  return GetPrimTypeSize(primType) << 3;
+}
+
+#endif  // MIR_FEATURE_FULL
+// return the same type with size increased to register size
+PrimType GetRegPrimType(PrimType primType);
+PrimType GetDynType(PrimType primType);
+PrimType GetReg64PrimType(PrimType primType);
+PrimType GetNonDynType(PrimType primType);
+PrimType GetIntegerPrimTypeBySizeAndSign(size_t sizeBit, bool isSign);
+
+inline bool IsAddress(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsAddress();
+}
+
+inline bool IsPossible64BitAddress(PrimType tp) {
+  return (tp == PTY_ptr || tp == PTY_ref || tp == PTY_u64 || tp == PTY_a64);
+}
+
+inline bool IsPossible32BitAddress(PrimType tp) {
+  return (tp == PTY_ptr || tp == PTY_ref || tp == PTY_u32 || tp == PTY_a32);
+}
+
+inline bool MustBeAddress(PrimType tp) {
+  return (tp == PTY_ptr || tp == PTY_ref || tp == PTY_a64 || tp == PTY_a32);
+}
+
+inline bool IsPrimitivePureScalar(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsInteger() && !primitiveType.IsAddress() &&
+         !primitiveType.IsDynamic() && !primitiveType.IsVector();
+}
+
+inline bool IsPrimitiveUnsigned(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsUnsigned();
+}
+
+inline bool IsUnsignedInteger(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return IsPrimitiveUnsigned(type) && primitiveType.IsInteger() && !primitiveType.IsDynamic();
+}
+
+inline bool IsSignedInteger(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return !primitiveType.IsUnsigned() && primitiveType.IsInteger() && !primitiveType.IsDynamic();
+}
+
+inline bool IsPrimitiveInteger(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsInteger() && !primitiveType.IsDynamic() && !primitiveType.IsVector();
+}
+
+inline bool IsPrimitiveDynType(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsDynamic();
+}
+
+inline bool IsPrimitiveDynInteger(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsDynamic() && primitiveType.IsInteger();
+}
+
+inline bool IsPrimitiveDynFloat(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsDynamic() && primitiveType.IsFloat();
+}
+
+inline bool IsPrimitiveFloat(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsFloat() && !primitiveType.IsDynamic() && !primitiveType.IsVector();
+}
+
+inline bool IsPrimitiveScalar(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsInteger() || primitiveType.IsFloat() ||
+         (primitiveType.IsDynamic() && !primitiveType.IsDynamicNone()) ||
+         primitiveType.IsSimple();
+}
+
+inline bool IsPrimitiveValid(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return IsPrimitiveScalar(type) && !primitiveType.IsDynamicAny();
+}
+
+inline bool IsPrimitivePoint(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsPointer();
+}
+
+inline bool IsPrimitiveVector(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsVector();
+}
+
+inline bool IsPrimitiveVectorFloat(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsVector() && primitiveType.IsFloat();
+}
+
+inline bool IsPrimitiveVectorInteger(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsVector() && primitiveType.IsInteger();
+}
+
+inline bool IsPrimitiveUnSignedVector(PrimType type) {
+  PrimitiveType primitiveType(type);
+  return primitiveType.IsUnsigned() && primitiveType.IsVector();
+}
+
+bool IsNoCvtNeeded(PrimType toType, PrimType fromType);
+bool NeedCvtOrRetype(PrimType origin, PrimType compared);
+
+uint8 GetPointerSize();
+uint8 GetP2Size();
+PrimType GetLoweredPtrType();
+
+inline bool IsRefOrPtrAssign(PrimType toType, PrimType fromType) {
+  return (toType == PTY_ref && fromType == PTY_ptr) || (toType == PTY_ptr && fromType == PTY_ref);
+}
+
+enum MIRTypeKind : std::uint8_t {
+  kTypeInvalid,
+  kTypeUnknown,
+  kTypeScalar,
+  kTypeBitField,
+  kTypeArray,
+  kTypeFArray,
+  kTypeJArray,
+  kTypeStruct,
+  kTypeUnion,
+  kTypeClass,
+  kTypeInterface,
+  kTypeStructIncomplete,
+  kTypeClassIncomplete,
+  kTypeConstString,
+  kTypeInterfaceIncomplete,
+  kTypePointer,
+  kTypeFunction,
+  kTypeVoid,
+  kTypeByName,          // type definition not yet seen
+  kTypeParam,           // to support java generics
+  kTypeInstantVector,   // represent a vector of instantiation pairs
+  kTypeGenericInstant,  // type to be formed by instantiation of a generic type
+};
+
+enum AttrKind : unsigned {
+#define TYPE_ATTR
+#define ATTR(STR) ATTR_##STR,
+#include "all_attributes.def"
+#undef ATTR
+#undef TYPE_ATTR
+};
+
+class AttrBoundary {
+ public:
+  AttrBoundary() = default;
+  ~AttrBoundary() = default;
+
+  bool operator==(const AttrBoundary &tA) const {
+    return lenExprHash == tA.lenExprHash && lenParamIdx == tA.lenParamIdx && isBytedLen == tA.isBytedLen;
+  }
+
+  bool operator!=(const AttrBoundary &tA) const {
+    return !(*this == tA);
+  }
+
+  bool operator<(const AttrBoundary &tA) const {
+    return lenExprHash < tA.lenExprHash && lenParamIdx < tA.lenParamIdx &&
+        static_cast<int>(isBytedLen) < static_cast<int>(tA.isBytedLen);
+  }
+
+  void SetLenExprHash(uint32 val) {
+    lenExprHash = val;
+  }
+
+  uint32 GetLenExprHash() const {
+    return lenExprHash;
+  }
+
+  void SetLenParamIdx(int8 idx) {
+    lenParamIdx = idx;
+  }
+
+  int8 GetLenParamIdx() const {
+    return lenParamIdx;
+  }
+
+  void SetIsBytedLen(bool flag) {
+    isBytedLen = flag;
+  }
+
+  bool IsBytedLen() const {
+    return isBytedLen;
+  }
+
+  void Clear() {
+    lenExprHash = 0;
+    lenParamIdx = -1;
+    isBytedLen = false;
+  }
+
+ private:
+  bool isBytedLen = false;
+  int8 lenParamIdx = -1;
+  uint32 lenExprHash = 0;
+};
+
+class TypeAttrs {
+ public:
+  TypeAttrs() = default;
+  TypeAttrs(const TypeAttrs &ta) = default;
+  TypeAttrs &operator=(const TypeAttrs &t) = default;
+  ~TypeAttrs() = default;
+
+  void SetAlignValue(uint8 align) {
+    attrAlign = align;
+  }
+
+  uint8 GetAlignValue() const {
+    return attrAlign;
+  }
+
+  void SetAttrFlag(uint64 flag) {
+    attrFlag = flag;
+  }
+
+  uint64 GetAttrFlag() const {
+    return attrFlag;
+  }
+
+  void SetAttr(AttrKind x) {
+    attrFlag |= (1ULL << static_cast<unsigned int>(x));
+  }
+
+  void ResetAttr(AttrKind x) {
+    attrFlag &= ~(1ULL << static_cast<unsigned int>(x));
+  }
+
+  bool GetAttr(AttrKind x) const {
+    return (attrFlag & (1ULL << static_cast<unsigned int>(x))) != 0;
+  }
+
+  void SetAlign(uint32 x) {
+    ASSERT((~(x - 1) & x) == x, "SetAlign called with non-power-of-2");
+    attrAlign = 0;
+    while (x != 1) {
+      x >>= 1;
+      ++attrAlign;
+    }
+  }
+
+  uint32 GetAlign() const {
+    if (attrAlign == 0) {
+      return 1;
+    }
+    uint32 res = 1;
+    uint32 exp = attrAlign;
+    do {
+      --exp;
+      res *= 2;
+    } while (exp != 0);
+    return res;
+  }
+
+  bool operator==(const TypeAttrs &tA) const {
+    return attrFlag == tA.attrFlag && attrAlign == tA.attrAlign && attrBoundary == tA.attrBoundary;
+  }
+
+  bool operator!=(const TypeAttrs &tA) const {
+    return !(*this == tA);
+  }
+
+  void DumpAttributes() const;
+
+  const AttrBoundary &GetAttrBoundary() const {
+    return attrBoundary;
+  }
+
+  AttrBoundary &GetAttrBoundary() {
+    return attrBoundary;
+  }
+
+  void AddAttrBoundary(const AttrBoundary &attr) {
+    if (attr.GetLenExprHash() != 0) {
+      attrBoundary.SetLenExprHash(attr.GetLenExprHash());
+    }
+    if (attr.GetLenParamIdx() != -1) {
+      attrBoundary.SetLenParamIdx(attr.GetLenParamIdx());
+    }
+    if (attr.IsBytedLen()) {
+      attrBoundary.SetIsBytedLen(attr.IsBytedLen());
+    }
+  }
+
+  void SetPack(uint32 pack) {
+    attrPack = pack;
+  }
+
+  uint32 GetPack() const {
+    return attrPack;
+  }
+
+  bool IsPacked() const {
+    return GetAttr(ATTR_pack);
+  }
+
+ private:
+  uint64 attrFlag = 0;
+  uint8 attrAlign = 0;  // alignment in bytes is 2 to the power of attrAlign
+  uint32 attrPack = -1;  // -1 means inactive
+  AttrBoundary attrBoundary;  // boundary attr for EnhanceC
+};
+
+enum FieldAttrKind {
+#define FIELD_ATTR
+#define ATTR(STR) FLDATTR_##STR,
+#include "all_attributes.def"
+#undef ATTR
+#undef FIELD_ATTR
+};
+
+class FieldAttrs {
+ public:
+  FieldAttrs() = default;
+  FieldAttrs(const FieldAttrs &ta) = default;
+  FieldAttrs &operator=(const FieldAttrs &p) = default;
+  ~FieldAttrs() = default;
+
+  void SetAlignValue(uint8 align) {
+    attrAlign = align;
+  }
+
+  uint8 GetAlignValue() const {
+    return attrAlign;
+  }
+
+  void SetAttrFlag(uint32 flag) {
+    attrFlag = flag;
+  }
+
+  uint32 GetAttrFlag() const {
+    return attrFlag;
+  }
+
+  void SetAttr(FieldAttrKind x) {
+    attrFlag |= (1u << static_cast<unsigned int>(x));
+  }
+
+  bool GetAttr(FieldAttrKind x) const {
+    return (attrFlag & (1u << static_cast<unsigned int>(x))) != 0;
+  }
+
+  void SetAlign(uint32 x) {
+    ASSERT((~(x - 1) & x) == x, "SetAlign called with non-power-of-2");
+    attrAlign = 0;
+    while (x != 1) {
+      x >>= 1;
+      ++attrAlign;
+    }
+  }
+
+  uint32 GetAlign() const {
+    return 1U << attrAlign;
+  }
+
+  bool operator==(const FieldAttrs &tA) const {
+    return attrFlag == tA.attrFlag && attrAlign == tA.attrAlign && attrBoundary == tA.attrBoundary;
+  }
+
+  bool operator!=(const FieldAttrs &tA) const {
+    return !(*this == tA);
+  }
+
+  bool operator<(const FieldAttrs &tA) const {
+    return attrFlag < tA.attrFlag && attrAlign < tA.attrAlign && attrBoundary < tA.attrBoundary;
+  }
+
+  void Clear() {
+    attrFlag = 0;
+    attrAlign = 0;
+    attrBoundary.Clear();
+  }
+
+  void DumpAttributes() const;
+  TypeAttrs ConvertToTypeAttrs() const;
+
+  const AttrBoundary &GetAttrBoundary() const {
+    return attrBoundary;
+  }
+
+  AttrBoundary &GetAttrBoundary() {
+    return attrBoundary;
+  }
+
+  bool IsPacked() const {
+    return GetAttr(FLDATTR_pack);
+  }
+
+ private:
+  uint8 attrAlign = 0;  // alignment in bytes is 2 to the power of attrAlign
+  uint32 attrFlag = 0;
+  AttrBoundary attrBoundary;
+};
+
+enum StmtAttrKind : unsigned {
+#define STMT_ATTR
+#define ATTR(STR) STMTATTR_##STR,
+#include "all_attributes.def"
+#undef ATTR
+#undef STMT_ATTR
+};
+
+class StmtAttrs {
+ public:
+  StmtAttrs() = default;
+  StmtAttrs(const StmtAttrs &ta) = default;
+  StmtAttrs &operator=(const StmtAttrs &p) = default;
+  ~StmtAttrs() = default;
+
+  void SetAttr(StmtAttrKind x) {
+    attrFlag |= (1u << static_cast<unsigned int>(x));
+  }
+
+  bool GetAttr(StmtAttrKind x) const {
+    return (attrFlag & (1u << static_cast<unsigned int>(x))) != 0;
+  }
+
+  uint32 GetTargetAttrFlag(StmtAttrKind x) const {
+    return attrFlag & (1u << static_cast<unsigned int>(x));
+  }
+
+  uint32 GetAttrFlag() const {
+    return attrFlag;
+  }
+
+  void AppendAttr(uint32 flag) {
+    attrFlag |= flag;
+  }
+
+  void Clear() {
+    attrFlag = 0;
+  }
+
+  void DumpAttributes() const;
+
+ private:
+  uint32 attrFlag = 0;
+};
+
+enum FuncAttrKind : unsigned {
+#define FUNC_ATTR
+#define ATTR(STR) FUNCATTR_##STR,
+#include "all_attributes.def"
+#undef ATTR
+#undef FUNC_ATTR
+};
+
+class FuncAttrs {
+ public:
+  FuncAttrs() = default;
+  FuncAttrs(const FuncAttrs &ta) = default;
+  FuncAttrs &operator=(const FuncAttrs &p) = default;
+  ~FuncAttrs() = default;
+
+  void SetAttr(FuncAttrKind x, bool unSet = false) {
+    if (!unSet) {
+      attrFlag |= (1ULL << x);
+    } else {
+      attrFlag &= ~(1ULL << x);
+    }
+  }
+
+  void SetAliasFuncName(const std::string &name) {
+    aliasFuncName = name;
+  }
+
+  const std::string &GetAliasFuncName() const {
+    return aliasFuncName;
+  }
+
+  void SetPrefixSectionName(const std::string &name) {
+    prefixSectionName = name;
+  }
+
+  const std::string &GetPrefixSectionName() const {
+    return prefixSectionName;
+  }
+
+  void SetAttrFlag(uint64 flag) {
+    attrFlag = flag;
+  }
+
+  uint64 GetAttrFlag() const {
+    return attrFlag;
+  }
+
+  bool GetAttr(FuncAttrKind x) const {
+    return (attrFlag & (1ULL << x)) != 0;
+  }
+
+  bool operator==(const FuncAttrs &tA) const {
+    return attrFlag == tA.attrFlag;
+  }
+
+  bool operator!=(const FuncAttrs &tA) const {
+    return !(*this == tA);
+  }
+
+  void DumpAttributes() const;
+
+  const AttrBoundary &GetAttrBoundary() const {
+    return attrBoundary;
+  }
+
+  AttrBoundary &GetAttrBoundary() {
+    return attrBoundary;
+  }
+
+  void SetConstructorPriority(int priority) {
+    constructorPriority = priority;
+  }
+
+  int GetConstructorPriority() const {
+    return constructorPriority;
+  }
+
+  void SetDestructorPriority(int priority) {
+    destructorPriority = priority;
+  }
+
+  int GetDestructorPriority() const {
+    return destructorPriority;
+  }
+
+ private:
+  uint64 attrFlag = 0;
+  std::string aliasFuncName;
+  std::string prefixSectionName;
+  AttrBoundary attrBoundary;  // ret boundary for EnhanceC
+  int constructorPriority = -1;  // 0~65535, -1 means inactive
+  int destructorPriority = -1;  // 0~65535, -1 means inactive
+};
+
+#if MIR_FEATURE_FULL
+constexpr size_t kShiftNumOfTypeKind = 8;
+constexpr size_t kShiftNumOfNameStrIdx = 6;
+constexpr int32 kOffsetUnknown = INT_MAX;
+constexpr int32 kOffsetMax = (INT_MAX - 1);
+constexpr int32 kOffsetMin = INT_MIN;
+struct OffsetType {
+  explicit OffsetType(int64 offset) {
+    Set(offset);
+  }
+
+  OffsetType(const OffsetType &other) : val(other.val) {}
+
+  ~OffsetType() = default;
+
+  void Set(int64 offsetVal) {
+    val = (offsetVal >= kOffsetMin && offsetVal <= kOffsetMax) ? static_cast<int32>(offsetVal)
+                                                               : kOffsetUnknown;
+  }
+
+  bool IsInvalid() const {
+    return val == kOffsetUnknown;
+  }
+
+  OffsetType &operator=(const OffsetType &other) {
+    val = other.val;
+    return *this;
+  }
+
+  OffsetType operator+(int64 offset) const {
+    if (this->IsInvalid() || OffsetType(offset).IsInvalid()) {
+      return InvalidOffset();
+    }
+    return OffsetType(val + offset);
+  }
+
+  OffsetType operator+(OffsetType other) const {
+    return other + val;
+  }
+
+  void operator+=(int64 offset) {
+    if (this->IsInvalid() || OffsetType(offset).IsInvalid()) {
+      val = kOffsetUnknown;
+      return;
+    }
+    Set(offset + val);
+  }
+
+  void operator+=(OffsetType other) {
+    this->operator+=(other.val);
+  }
+
+  OffsetType operator-() const {
+    if (this->IsInvalid()) {
+      return *this;
+    }
+    return OffsetType(-val);
+  }
+
+  bool operator<(OffsetType other) const {
+    return val < other.val;
+  }
+
+  bool operator==(OffsetType other) const {
+    return val == other.val;
+  }
+
+  bool operator!=(OffsetType other) const {
+    return val != other.val;
+  }
+
+  static OffsetType InvalidOffset() {
+    return OffsetType(kOffsetUnknown);
+  }
+
+  int32 val = kOffsetUnknown;
+};
+
+class MIRStructType; // circular dependency exists, no other choice
+class MIRFuncType;
+
+class MIRType {
+ public:
+  MIRType(MIRTypeKind kind, PrimType pType) : typeKind(kind), primType(pType) {}
+
+  MIRType(MIRTypeKind kind, PrimType pType, GStrIdx strIdx)
+      : typeKind(kind), primType(pType), nameStrIdx(strIdx) {}
+
+  virtual ~MIRType() = default;
+
+  virtual void Dump(int indent, bool dontUseName = false) const;
+  virtual void DumpAsCxx(int indent) const;
+  virtual bool EqualTo(const MIRType &mirType) const;
+  virtual bool IsStructType() const {
+    return false;
+  }
+
+  virtual MIRType *CopyMIRTypeNode() const {
+    return new MIRType(*this);
+  }
+
+  PrimType GetPrimType() const {
+    return primType;
+  }
+  void SetPrimType(const PrimType pt) {
+    primType = pt;
+  }
+
+  TyIdx GetTypeIndex() const {
+    return tyIdx;
+  }
+  void SetTypeIndex(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  MIRTypeKind GetKind() const {
+    return typeKind;
+  }
+  void SetMIRTypeKind(MIRTypeKind kind) {
+    typeKind = kind;
+  }
+
+  bool IsNameIsLocal() const {
+    return nameIsLocal;
+  }
+  void SetNameIsLocal(bool flag) {
+    nameIsLocal = flag;
+  }
+
+  GStrIdx GetNameStrIdx() const {
+    return nameStrIdx;
+  }
+  void SetNameStrIdx(GStrIdx strIdx) {
+    nameStrIdx = strIdx;
+  }
+  void SetNameStrIdxItem(uint32 idx) {
+    nameStrIdx.reset(idx);
+  }
+
+  virtual size_t GetSize() const {
+    return GetPrimTypeSize(primType);
+  }
+
+  virtual uint32 GetAlign() const {
+    return GetPrimTypeSize(primType);
+  }
+
+  virtual bool HasVolatileField() const {
+    return false;
+  }
+
+  virtual bool HasTypeParam() const {
+    return false;
+  }
+
+  virtual bool IsIncomplete() const {
+    return typeKind == kTypeStructIncomplete || typeKind == kTypeClassIncomplete ||
+           typeKind == kTypeInterfaceIncomplete;
+  }
+
+  bool IsVolatile(int fieldID) const;
+
+  bool IsMIRPtrType() const {
+    return typeKind == kTypePointer;
+  }
+
+  bool IsMIRStructType() const {
+    return (typeKind == kTypeStruct) || (typeKind == kTypeStructIncomplete);
+  }
+
+  bool IsMIRIncompleteStructType() const {
+    return typeKind == kTypeStructIncomplete;
+  }
+
+  bool IsMIRUnionType() const {
+    return typeKind == kTypeUnion;
+  }
+
+  bool IsMIRClassType() const {
+    return (typeKind == kTypeClass) || (typeKind == kTypeClassIncomplete);
+  }
+
+  bool IsMIRInterfaceType() const {
+    return (typeKind == kTypeInterface) || (typeKind == kTypeInterfaceIncomplete);
+  }
+
+  bool IsInstanceOfMIRStructType() const {
+    return IsMIRStructType() || IsMIRClassType() || IsMIRInterfaceType();
+  }
+
+  bool IsMIRJarrayType() const {
+    return typeKind == kTypeJArray;
+  }
+
+  bool IsMIRArrayType() const {
+    return typeKind == kTypeArray;
+  }
+
+  bool IsMIRFuncType() const {
+    return typeKind == kTypeFunction;
+  }
+
+  bool IsScalarType() const {
+    return typeKind == kTypeScalar;
+  }
+
+  bool IsMIRTypeByName() const {
+    return typeKind == kTypeByName;
+  }
+
+  bool IsMIRBitFieldType() const {
+    return typeKind == kTypeBitField;
+  }
+
+  virtual bool IsUnsafeType() const {
+    return false;
+  }
+  virtual bool IsVoidPointer() const {
+    return false;
+  }
+
+  bool ValidateClassOrInterface(const std::string &className, bool noWarning) const;
+  bool IsOfSameType(MIRType &type);
+  const std::string &GetName() const;
+  virtual std::string GetMplTypeName() const;
+  virtual std::string GetCompactMplTypeName() const;
+  virtual bool PointsToConstString() const;
+  virtual size_t GetHashIndex() const {
+    constexpr uint8 idxShift = 2;
+    return ((static_cast<uint32>(primType) << idxShift) + (typeKind << kShiftNumOfTypeKind)) % kTypeHashLength;
+  }
+
+  virtual bool HasFields() const { return false; }
+  // total number of field IDs the type is consisted of, excluding its own field ID
+  virtual uint32 NumberOfFieldIDs() const { return 0; }
+  // return any struct type directly embedded in this type
+  virtual MIRStructType *EmbeddedStructType() { return nullptr; }
+
+  virtual int64 GetBitOffsetFromBaseAddr(FieldID fieldID) const {
+    (void)fieldID;
+    return 0;
+  }
+
+ protected:
+  MIRTypeKind typeKind;
+  PrimType primType;
+  bool nameIsLocal = false;  // needed when printing the type name
+  TyIdx tyIdx{ 0 };
+  GStrIdx nameStrIdx{ 0 };  // name in global string table
+};
+
+class MIRPtrType : public MIRType {
+ public:
+  explicit MIRPtrType(TyIdx pTyIdx) : MIRType(kTypePointer, PTY_ptr), pointedTyIdx(pTyIdx) {}
+
+  MIRPtrType(TyIdx pTyIdx, PrimType pty) : MIRType(kTypePointer, pty), pointedTyIdx(pTyIdx) {}
+
+  MIRPtrType(PrimType primType, GStrIdx strIdx) : MIRType(kTypePointer, primType, strIdx), pointedTyIdx(0) {}
+
+  ~MIRPtrType() override = default;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRPtrType(*this);
+  }
+
+  MIRType *GetPointedType() const;
+
+  TyIdx GetPointedTyIdx() const {
+    return pointedTyIdx;
+  }
+  void SetPointedTyIdx(TyIdx idx) {
+    pointedTyIdx = idx;
+  }
+
+  TypeAttrs &GetTypeAttrs() {
+    return typeAttrs;
+  }
+
+  const TypeAttrs &GetTypeAttrs() const {
+    return typeAttrs;
+  }
+
+  void SetTypeAttrs(const TypeAttrs &attrs) {
+    typeAttrs = attrs;
+  }
+
+  bool EqualTo(const MIRType &type) const override;
+
+  bool HasTypeParam() const override;
+  bool IsPointedTypeVolatile(int fieldID) const;
+  bool IsUnsafeType() const override;
+  bool IsVoidPointer() const override;
+
+  void Dump(int indent, bool dontUseName = false) const override;
+  size_t GetSize() const override;
+  uint32 GetAlign() const override;
+  TyIdxFieldAttrPair GetPointedTyIdxFldAttrPairWithFieldID(FieldID fldId) const;
+  TyIdx GetPointedTyIdxWithFieldID(FieldID fieldID) const;
+  size_t GetHashIndex() const override {
+    constexpr uint8 idxShift = 4;
+    constexpr uint8 attrShift = 3;
+    size_t hIdx = (static_cast<size_t>(pointedTyIdx) << idxShift) + (typeKind << kShiftNumOfTypeKind);
+    hIdx += (typeAttrs.GetAttrFlag() << attrShift) + typeAttrs.GetAlignValue();
+    return hIdx % kTypeHashLength;
+  }
+  bool IsFunctionPtr() const {
+    MIRType *pointedType = GetPointedType();
+    if (pointedType->GetKind() == kTypeFunction) {
+      return true;
+    }
+    if (pointedType->GetKind() == kTypePointer) {
+      MIRPtrType *pointedPtrType = static_cast<MIRPtrType *>(pointedType);
+      return pointedPtrType->GetPointedType()->GetKind() == kTypeFunction;
+    }
+    return false;
+  }
+
+  MIRFuncType *GetPointedFuncType() const;
+
+  bool PointsToConstString() const override;
+
+  std::string GetMplTypeName() const override;
+
+  std::string GetCompactMplTypeName() const override;
+ private:
+  TyIdx pointedTyIdx;
+  TypeAttrs typeAttrs;
+};
+
+class MIRArrayType : public MIRType {
+ public:
+  MIRArrayType() : MIRType(kTypeArray, PTY_agg) {}
+  explicit MIRArrayType(GStrIdx strIdx) : MIRType(kTypeArray, PTY_agg, strIdx) {}
+
+  MIRArrayType(TyIdx eTyIdx, const std::vector<uint32> &sizeArray)
+      : MIRType(kTypeArray, PTY_agg),
+        eTyIdx(eTyIdx),
+        dim(sizeArray.size()) {
+    for (size_t i = 0; i < kMaxArrayDim; ++i) {
+      this->sizeArray[i] = (i < dim) ? sizeArray[i] : 0;
+    }
+  }
+
+  MIRArrayType(const MIRArrayType &pat) = default;
+  MIRArrayType &operator=(const MIRArrayType &p) = default;
+  ~MIRArrayType() override = default;
+
+  TyIdx GetElemTyIdx() const {
+    return eTyIdx;
+  }
+  void SetElemTyIdx(TyIdx idx) {
+    eTyIdx = idx;
+  }
+
+  uint32 GetSizeArrayItem(uint32 n) const {
+    CHECK_FATAL((n >= 0 && n < kMaxArrayDim), "out of bound of array!");
+    return sizeArray[n];
+  }
+  void SetSizeArrayItem(uint32 idx, uint32 value) {
+    CHECK_FATAL((idx >= 0 && idx < kMaxArrayDim), "out of bound of array!");
+    sizeArray[idx] = value;
+  }
+
+  bool IsIncompleteArray() const {
+    return typeAttrs.GetAttr(ATTR_incomplete_array);
+  }
+
+  bool EqualTo(const MIRType &type) const override;
+
+  uint16 GetDim() const {
+    return dim;
+  }
+  void SetDim(uint16 newDim) {
+    this->dim = newDim;
+  }
+
+  const TypeAttrs &GetTypeAttrs() const {
+    return typeAttrs;
+  }
+
+  TypeAttrs &GetTypeAttrs() {
+    return typeAttrs;
+  }
+
+  void SetTypeAttrs(const TypeAttrs &attrs) {
+    typeAttrs = attrs;
+  }
+
+  MIRType *GetElemType() const;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRArrayType(*this);
+  }
+
+  bool HasTypeParam() const override {
+    return GetElemType()->HasTypeParam();
+  }
+
+  void Dump(int indent, bool dontUseName) const override;
+
+  size_t GetSize() const override;
+  uint32 GetAlign() const override;
+
+  size_t GetHashIndex() const override {
+    constexpr uint8 idxShift = 2;
+    size_t hIdx = (static_cast<size_t>(eTyIdx) << idxShift) + (typeKind << kShiftNumOfTypeKind);
+    for (size_t i = 0; i < dim; ++i) {
+      CHECK_FATAL(i < kMaxArrayDim, "array index out of range");
+      hIdx += (sizeArray[i] << i);
+    }
+    constexpr uint8 attrShift = 3;
+    hIdx += (typeAttrs.GetAttrFlag() << attrShift) + typeAttrs.GetAlignValue();
+    return hIdx % kTypeHashLength;
+  }
+
+  int64 GetBitOffsetFromBaseAddr(FieldID fieldID) const override {
+    (void)fieldID;
+    return kOffsetUnknown;
+  }
+  int64 GetBitOffsetFromArrayAddress(std::vector<int64> &indexArray);
+
+  std::string GetMplTypeName() const override;
+  std::string GetCompactMplTypeName() const override;
+  bool HasFields() const override;
+  uint32 NumberOfFieldIDs() const override;
+  MIRStructType *EmbeddedStructType() override;
+  size_t ElemNumber();
+
+ private:
+  TyIdx eTyIdx{ 0 };
+  uint16 dim = 0;
+  std::array<uint32, kMaxArrayDim> sizeArray{ {0} };
+  TypeAttrs typeAttrs;
+  mutable uint32 fieldsNum = kInvalidFieldNum;
+  mutable size_t size = kInvalidSize;
+};
+
+// flexible array type, must be last field of a top-level struct
+class MIRFarrayType : public MIRType {
+ public:
+  MIRFarrayType() : MIRType(kTypeFArray, PTY_agg), elemTyIdx(TyIdx(0)) {}
+
+  explicit MIRFarrayType(TyIdx elemTyIdx) : MIRType(kTypeFArray, PTY_agg), elemTyIdx(elemTyIdx) {}
+
+  explicit MIRFarrayType(GStrIdx strIdx) : MIRType(kTypeFArray, PTY_agg, strIdx), elemTyIdx(TyIdx(0)) {}
+
+  ~MIRFarrayType() override = default;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRFarrayType(*this);
+  };
+
+  MIRType *GetElemType() const;
+
+  bool HasTypeParam() const override {
+    return GetElemType()->HasTypeParam();
+  }
+
+  TyIdx GetElemTyIdx() const {
+    return elemTyIdx;
+  }
+  void SetElemtTyIdx(TyIdx idx) {
+    elemTyIdx = idx;
+  }
+
+  bool EqualTo(const MIRType &type) const override;
+  void Dump(int indent, bool dontUseName = false) const override;
+
+  size_t GetHashIndex() const override {
+    constexpr uint8 idxShift = 5;
+    return ((static_cast<size_t>(elemTyIdx) << idxShift) + (typeKind << kShiftNumOfTypeKind)) % kTypeHashLength;
+  }
+
+  std::string GetMplTypeName() const override;
+  std::string GetCompactMplTypeName() const override;
+
+  bool HasFields() const override;
+  uint32 NumberOfFieldIDs() const override;
+  MIRStructType *EmbeddedStructType() override;
+
+  int64 GetBitOffsetFromBaseAddr(FieldID fieldID) const override {
+    (void)fieldID;
+    return kOffsetUnknown;
+  }
+
+  int64 GetBitOffsetFromArrayAddress(int64 arrayIndex) const;
+
+ private:
+  TyIdx elemTyIdx;
+  mutable uint32 fieldsNum = kInvalidFieldNum;
+};
+
+using TyidxFuncAttrPair = std::pair<TyIdx, FuncAttrs>;
+using MethodPair = std::pair<StIdx, TyidxFuncAttrPair>;
+using MethodVector = std::vector<MethodPair>;
+using MethodPtrVector = std::vector<MethodPair*>;
+using MIREncodedArray = std::vector<EncodedValue>;
+class GenericDeclare;
+class AnnotationType;
+class GenericType;
+// used by kTypeStruct, kTypeStructIncomplete, kTypeUnion
+class MIRStructType : public MIRType {
+ public:
+  explicit MIRStructType(MIRTypeKind typeKind) : MIRType(typeKind, PTY_agg) {}
+
+  MIRStructType(MIRTypeKind typeKind, GStrIdx strIdx) : MIRType(typeKind, PTY_agg, strIdx) {}
+
+  ~MIRStructType() override = default;
+
+  bool IsStructType() const override {
+    return true;
+  }
+
+  FieldVector &GetFields() {
+    return fields;
+  }
+  const FieldVector &GetFields() const {
+    return fields;
+  }
+  void SetFields(const FieldVector &newFields) {
+    this->fields = newFields;
+  }
+
+  const FieldPair &GetFieldsElemt(size_t n) const {
+    ASSERT(n < fields.size(), "array index out of range");
+    return fields.at(n);
+  }
+
+  FieldPair &GetFieldsElemt(size_t n) {
+    ASSERT(n < fields.size(), "array index out of range");
+    return fields.at(n);
+  }
+
+  size_t GetFieldsSize() const {
+    return fields.size();
+  }
+
+  const std::vector<TyIdx> &GetFieldInferredTyIdx() const {
+    return fieldInferredTyIdx;
+  }
+
+  FieldVector &GetStaticFields() {
+    return staticFields;
+  }
+  const FieldVector &GetStaticFields() const {
+    return staticFields;
+  }
+
+  const FieldPair &GetStaticFieldsPair(size_t i) const {
+    return staticFields.at(i);
+  }
+
+  GStrIdx GetStaticFieldsGStrIdx(size_t i) const {
+    return staticFields.at(i).first;
+  }
+
+  FieldVector &GetParentFields() {
+    return parentFields;
+  }
+  void SetParentFields(const FieldVector &newParentFields) {
+    this->parentFields = newParentFields;
+  }
+  const FieldVector &GetParentFields() const {
+    return parentFields;
+  }
+  const FieldPair &GetParentFieldsElemt(size_t n) const {
+    ASSERT(n < parentFields.size(), "array index out of range");
+    return parentFields.at(n);
+  }
+  size_t GetParentFieldsSize() const {
+    return parentFields.size();
+  }
+
+  MethodVector &GetMethods() {
+    return methods;
+  }
+  const MethodVector &GetMethods() const {
+    return methods;
+  }
+
+  const MethodPair &GetMethodsElement(size_t n) const {
+    ASSERT(n < methods.size(), "array index out of range");
+    return methods.at(n);
+  }
+
+  MethodPtrVector &GetVTableMethods() {
+    return vTableMethods;
+  }
+
+  const MethodPair *GetVTableMethodsElemt(size_t n) const {
+    ASSERT(n < vTableMethods.size(), "array index out of range");
+    return vTableMethods.at(n);
+  }
+
+  size_t GetVTableMethodsSize() const {
+    return vTableMethods.size();
+  }
+
+  const MethodPtrVector &GetItableMethods() const {
+    return iTableMethods;
+  }
+
+  bool IsImported() const {
+    return isImported;
+  }
+
+  void SetIsImported(bool flag) {
+    isImported = flag;
+  }
+
+  bool IsUsed() const {
+    return isUsed;
+  }
+
+  void SetIsUsed(bool flag) {
+    isUsed = flag;
+  }
+
+  bool IsCPlusPlus() const {
+    return isCPlusPlus;
+  }
+
+  void SetIsCPlusPlus(bool flag) {
+    isCPlusPlus = flag;
+  }
+
+  GStrIdx GetFieldGStrIdx(FieldID id) const {
+    const FieldPair &fieldPair = TraverseToField(id);
+    return fieldPair.first;
+  }
+
+  const TyIdxFieldAttrPair GetFieldTyIdxAttrPair(FieldID id) const {
+    return TraverseToField(id).second;
+  }
+
+  TyIdxFieldAttrPair GetTyidxFieldAttrPair(size_t n) const {
+    return fields.at(n).second;
+  }
+
+  TyIdx GetFieldTyIdx(FieldID id) const {
+    const FieldPair &fieldPair = TraverseToField(id);
+    return fieldPair.second.first;
+  }
+
+  FieldAttrs GetFieldAttrs(FieldID id) const {
+    const FieldPair &fieldPair = TraverseToField(id);
+    return fieldPair.second.second;
+  }
+
+  FieldAttrs GetFieldAttrs(GStrIdx fieldStrIdx) const {
+    const FieldPair &fieldPair = TraverseToField(fieldStrIdx);
+    return fieldPair.second.second;
+  }
+
+  bool IsFieldVolatile(FieldID id) const {
+    const FieldPair &fieldPair = TraverseToField(id);
+    return fieldPair.second.second.GetAttr(FLDATTR_volatile);
+  }
+
+  bool IsFieldFinal(FieldID id) const {
+    const FieldPair &fieldPair = TraverseToField(id);
+    return fieldPair.second.second.GetAttr(FLDATTR_final);
+  }
+
+  bool IsFieldRCUnownedRef(FieldID id) const {
+    const FieldPair &fieldPair = TraverseToField(id);
+    return fieldPair.second.second.GetAttr(FLDATTR_rcunowned);
+  }
+
+  bool IsFieldRCWeak(FieldID id) const {
+    const FieldPair &fieldPair = TraverseToField(id);
+    return fieldPair.second.second.GetAttr(FLDATTR_rcweak);
+  }
+
+  bool IsFieldRestrict(FieldID id) const {
+    const FieldPair &fieldPair = TraverseToField(id);
+    return fieldPair.second.second.GetAttr(FLDATTR_restrict);
+  }
+
+  bool IsOwnField(FieldID id) const {
+    const FieldPair &fieldPair = TraverseToField(id);
+    return std::find(fields.begin(), fields.end(), fieldPair) != fields.end();
+  }
+
+  TypeAttrs &GetTypeAttrs() {
+    return typeAttrs;
+  }
+
+  const TypeAttrs &GetTypeAttrs() const {
+    return typeAttrs;
+  }
+
+  void SetTypeAttrs(const TypeAttrs &attrs) {
+    typeAttrs = attrs;
+  }
+
+  bool HasVolatileField() const override;
+  bool HasTypeParam() const override;
+  bool EqualTo(const MIRType &type) const override;
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRStructType(*this);
+  }
+
+  TyIdx GetElemTyIdx(size_t n) const {
+    ASSERT(n < fields.size(), "array index out of range");
+    return fields.at(n).second.first;
+  }
+
+  void SetElemtTyIdxSimple(size_t n, TyIdx tyIdx) {
+    ASSERT(n < fields.size(), "array index out of range");
+    fields.at(n).second.first = tyIdx;
+  }
+
+  TyIdx GetStaticElemtTyIdx(size_t n) const {
+    ASSERT(n < staticFields.size(), "array index out of range");
+    return staticFields.at(n).second.first;
+  }
+
+  void SetStaticElemtTyIdx(size_t n, TyIdx tyIdx) {
+    staticFields.at(n).second.first = tyIdx;
+  }
+
+  void SetMethodTyIdx(size_t n, TyIdx tyIdx) {
+    ASSERT(n < methods.size(), "array index out of range");
+    methods.at(n).second.first = tyIdx;
+  }
+
+  MIRType *GetElemType(uint32 n) const;
+
+  MIRType *GetFieldType(FieldID fieldID);
+
+  void SetElemtTyIdx(size_t n, TyIdx tyIdx) {
+    ASSERT(n < fields.size(), "array index out of range");
+    fields.at(n).second = TyIdxFieldAttrPair(tyIdx, FieldAttrs());
+  }
+
+  GStrIdx GetElemStrIdx(size_t n) const {
+    ASSERT(n < fields.size(), "array index out of range");
+    return fields.at(n).first;
+  }
+
+  void SetElemStrIdx(size_t n, GStrIdx idx) {
+    ASSERT(n < fields.size(), "array index out of range");
+    fields.at(n).first = idx;
+  }
+
+  void SetElemInferredTyIdx(size_t n, TyIdx tyIdx) {
+    if (n >= fieldInferredTyIdx.size()) {
+      (void)fieldInferredTyIdx.insert(fieldInferredTyIdx.end(), n + 1 - fieldInferredTyIdx.size(), kInitTyIdx);
+    }
+    ASSERT(n < fieldInferredTyIdx.size(), "array index out of range");
+    fieldInferredTyIdx.at(n) = tyIdx;
+  }
+
+  TyIdx GetElemInferredTyIdx(size_t n) {
+    if (n >= fieldInferredTyIdx.size()) {
+      (void)fieldInferredTyIdx.insert(fieldInferredTyIdx.end(), n + 1 - fieldInferredTyIdx.size(), kInitTyIdx);
+    }
+    ASSERT(n < fieldInferredTyIdx.size(), "array index out of range");
+    return fieldInferredTyIdx.at(n);
+  }
+
+  void DumpFieldsAndMethods(int indent, bool hasMethod) const;
+  void Dump(int indent, bool dontUseName = false) const override;
+
+  virtual void SetComplete() {
+    typeKind = (typeKind == kTypeUnion) ? typeKind : kTypeStruct;
+  }
+
+  // only meaningful for MIRClassType and MIRInterface types
+  bool IsLocal() const;
+
+  size_t GetSize() const override;
+  uint32 GetAlign() const override;
+
+  size_t GetHashIndex() const override {
+    constexpr uint8 attrShift = 3;
+    return ((static_cast<size_t>(nameStrIdx) << kShiftNumOfNameStrIdx) + (typeKind << kShiftNumOfTypeKind) +
+            ((typeAttrs.GetAttrFlag() << attrShift) + typeAttrs.GetAlignValue())) % kTypeHashLength;
+  }
+
+  virtual void ClearContents() {
+    fields.clear();
+    staticFields.clear();
+    parentFields.clear();
+    methods.clear();
+    vTableMethods.clear();
+    iTableMethods.clear();
+    isImported = false;
+    isUsed = false;
+    hasVolatileField = false;
+    hasVolatileFieldSet = false;
+  }
+
+  virtual const std::vector<MIRInfoPair> &GetInfo() const {
+    CHECK_FATAL(false, "can not use GetInfo");
+  }
+
+  virtual const MIRInfoPair &GetInfoElemt(size_t) const {
+    CHECK_FATAL(false, "can not use GetInfoElemt");
+  }
+
+  virtual const std::vector<bool> &GetInfoIsString() const {
+    CHECK_FATAL(false, "can not use GetInfoIsString");
+  }
+
+  virtual bool GetInfoIsStringElemt(size_t) const {
+    CHECK_FATAL(false, "can not use GetInfoIsStringElemt");
+  }
+
+  virtual const std::vector<MIRPragma*> &GetPragmaVec() const {
+    CHECK_FATAL(false, "can not use GetPragmaVec");
+  }
+
+  virtual std::vector<MIRPragma*> &GetPragmaVec() {
+    CHECK_FATAL(false, "can not use GetPragmaVec");
+  }
+
+  std::vector<GenericDeclare*>& GetGenericDeclare() {
+    return genericDeclare;
+  }
+
+  void AddClassGenericDeclare(GenericDeclare *gd) {
+    genericDeclare.push_back(gd);
+  }
+
+  void AddFieldGenericDeclare(const GStrIdx &g, AnnotationType *a) {
+    if (fieldGenericDeclare.find(g) != fieldGenericDeclare.end()) {
+      CHECK_FATAL(fieldGenericDeclare[g] == a, "MUST BE");
+    }
+    fieldGenericDeclare[g] = a;
+  }
+
+  AnnotationType *GetFieldGenericDeclare(const GStrIdx &g) {
+    if (fieldGenericDeclare.find(g) == fieldGenericDeclare.end()) {
+      return nullptr;
+    }
+    return fieldGenericDeclare[g];
+  }
+
+  void AddInheritaceGeneric(GenericType *a) {
+    inheritanceGeneric.push_back(a);
+  }
+
+  std::vector<GenericType*> &GetInheritanceGeneric() {
+    return inheritanceGeneric;
+  }
+
+  virtual const MIREncodedArray &GetStaticValue() const {
+    CHECK_FATAL(false, "can not use GetStaticValue");
+  }
+
+  virtual void PushbackMIRInfo(const MIRInfoPair&) {
+    CHECK_FATAL(false, "can not use PushbackMIRInfo");
+  }
+
+  virtual void PushbackPragma(MIRPragma*) {
+    CHECK_FATAL(false, "can not use PushbackPragma");
+  }
+
+  virtual void PushbackStaticValue(EncodedValue&) {
+    CHECK_FATAL(false, "can not use PushbackStaticValue");
+  }
+
+  virtual void PushbackIsString(bool) {
+    CHECK_FATAL(false, "can not use PushbackIsString");
+  }
+
+  bool HasFields() const override { return true; }
+  uint32 NumberOfFieldIDs() const override;
+  MIRStructType *EmbeddedStructType() override { return this; }
+
+  virtual FieldPair TraverseToFieldRef(FieldID &fieldID) const;
+  std::string GetMplTypeName() const override;
+  std::string GetCompactMplTypeName() const override;
+  FieldPair TraverseToField(FieldID fieldID) const ;
+
+  int64 GetBitOffsetFromBaseAddr(FieldID fieldID) const override;
+
+  bool HasPadding() const;
+
+  void SetAlias(MIRAlias *mirAlias) {
+    alias = mirAlias;
+  }
+  MIRAlias *GetAlias() const {
+    return alias;
+  }
+
+ protected:
+  FieldVector fields{};
+  std::vector<TyIdx> fieldInferredTyIdx{};
+  FieldVector staticFields{};
+  FieldVector parentFields{};       // fields belong to the ancestors not fully defined
+  MethodVector methods{};           // for the list of member function prototypes
+  MethodPtrVector vTableMethods{};  // the list of implmentation for all virtual functions for this type
+  MethodPtrVector iTableMethods{};  // the list of all interface functions for this type; For classes, they are
+  // implementation functions, For interfaces, they are abstact functions.
+  // Weak indicates the actual definition is in another module.
+  bool isImported = false;
+  bool isUsed = false;
+  bool isCPlusPlus = false;        // empty struct in C++ has size 1 byte
+  mutable bool hasVolatileField = false;     // for caching computed value
+  mutable bool hasVolatileFieldSet = false;  // if true, just read hasVolatileField;
+                                             // otherwise compute to initialize hasVolatileField
+  std::vector<GenericDeclare*> genericDeclare;
+  std::map<GStrIdx, AnnotationType*> fieldGenericDeclare;
+  std::vector<GenericType*> inheritanceGeneric;
+  TypeAttrs typeAttrs;
+  mutable uint32 fieldsNum = kInvalidFieldNum;
+  mutable size_t size = kInvalidSize;
+
+ private:
+  FieldPair TraverseToField(GStrIdx fieldStrIdx) const ;
+  bool HasVolatileFieldInFields(const FieldVector &fieldsOfStruct) const;
+  bool HasTypeParamInFields(const FieldVector &fieldsOfStruct) const;
+  int64 GetBitOffsetFromUnionBaseAddr(FieldID fieldID) const;
+  int64 GetBitOffsetFromStructBaseAddr(FieldID fieldID) const;
+  MIRAlias *alias = nullptr;
+};
+
+// java array type, must not be nested inside another aggregate
+class MIRJarrayType : public MIRFarrayType {
+ public:
+  MIRJarrayType() {
+    typeKind = kTypeJArray;
+  };
+
+  explicit MIRJarrayType(TyIdx elemTyIdx) : MIRFarrayType(elemTyIdx) {
+    typeKind = kTypeJArray;
+  }
+
+  explicit MIRJarrayType(GStrIdx strIdx) : MIRFarrayType(strIdx) {
+    typeKind = kTypeJArray;
+  }
+
+  ~MIRJarrayType() override = default;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRJarrayType(*this);
+  }
+
+  MIRStructType *GetParentType();
+  const std::string &GetJavaName();
+
+  bool IsPrimitiveArray() {
+    if (javaNameStrIdx == 0u) {
+      DetermineName();
+    }
+    return fromPrimitive;
+  }
+
+  int GetDim() {
+    if (javaNameStrIdx == 0u) {
+      DetermineName();
+    }
+    return dim;
+  }
+
+  size_t GetHashIndex() const override {
+    constexpr uint8 idxShift = 5;
+    return ((static_cast<size_t>(GetElemTyIdx()) << idxShift) + (typeKind << kShiftNumOfTypeKind)) % kTypeHashLength;
+  }
+
+ private:
+  void DetermineName();    // determine the internal name of this type
+  TyIdx parentTyIdx{ 0 };       // since Jarray is also an object, this is java.lang.Object
+  GStrIdx javaNameStrIdx{ 0 };  // for internal java name of Jarray. nameStrIdx is used for other purpose
+  bool fromPrimitive = false;      // the lowest dimension is primitive type
+  int dim = 0;                 // the dimension if decidable at compile time. otherwise 0
+};
+
+// used by kTypeClass, kTypeClassIncomplete
+class MIRClassType : public MIRStructType {
+ public:
+  explicit MIRClassType(MIRTypeKind tKind) : MIRStructType(tKind) {}
+  MIRClassType(MIRTypeKind tKind, GStrIdx strIdx) : MIRStructType(tKind, strIdx) {}
+  ~MIRClassType() override = default;
+
+  bool EqualTo(const MIRType &type) const override;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRClassType(*this);
+  }
+
+  const std::vector<MIRInfoPair> &GetInfo() const override {
+    return info;
+  }
+  void PushbackMIRInfo(const MIRInfoPair &pair) override {
+    info.push_back(pair);
+  }
+  uint32 GetInfo(const std::string &infoStr) const;
+  uint32 GetInfo(GStrIdx strIdx) const;
+  size_t GetInfoSize() const {
+    return info.size();
+  }
+
+  const MIRInfoPair &GetInfoElemt(size_t n) const override {
+    ASSERT(n < info.size(), "array index out of range");
+    return info.at(n);
+  }
+
+  const std::vector<bool> &GetInfoIsString() const override {
+    return infoIsString;
+  }
+
+  void PushbackIsString(bool isString) override {
+    infoIsString.push_back(isString);
+  }
+
+  size_t GetInfoIsStringSize() const {
+    return infoIsString.size();
+  }
+
+  bool GetInfoIsStringElemt(size_t n) const override {
+    ASSERT(n < infoIsString.size(), "array index out of range");
+    return infoIsString.at(n);
+  }
+
+  std::vector<MIRPragma*> &GetPragmaVec() override {
+    return pragmaVec;
+  }
+  const std::vector<MIRPragma*> &GetPragmaVec() const override {
+    return pragmaVec;
+  }
+  void PushbackPragma(MIRPragma *pragma) override {
+    pragmaVec.push_back(pragma);
+  }
+
+  const MIREncodedArray &GetStaticValue() const override {
+    return staticValue;
+  }
+  void PushbackStaticValue(EncodedValue &encodedValue) override {
+    staticValue.push_back(encodedValue);
+  }
+
+  TyIdx GetParentTyIdx() const {
+    return parentTyIdx;
+  }
+  void SetParentTyIdx(TyIdx idx) {
+    parentTyIdx = idx;
+  }
+
+  std::vector<TyIdx> &GetInterfaceImplemented() {
+    return interfacesImplemented;
+  }
+  const std::vector<TyIdx> &GetInterfaceImplemented() const {
+    return interfacesImplemented;
+  }
+  TyIdx GetNthInterfaceImplemented(size_t i) const {
+    ASSERT(i < interfacesImplemented.size(), "array index out of range");
+    return interfacesImplemented.at(i);
+  }
+
+  void SetNthInterfaceImplemented(size_t i, TyIdx tyIdx) {
+    ASSERT(i < interfacesImplemented.size(), "array index out of range");
+    interfacesImplemented.at(i) = tyIdx;
+  }
+  void PushbackInterfaceImplemented(TyIdx idx) {
+    interfacesImplemented.push_back(idx);
+  }
+
+  void Dump(int indent, bool dontUseName = false) const override;
+  void DumpAsCxx(int indent) const override;
+  void SetComplete() override {
+    typeKind = kTypeClass;
+  }
+
+  bool IsFinal() const;
+  bool IsAbstract() const;
+  bool IsInner() const;
+  bool HasVolatileField() const override;
+  bool HasTypeParam() const override;
+  FieldPair TraverseToFieldRef(FieldID &fieldID) const override;
+  size_t GetSize() const override;
+
+  FieldID GetLastFieldID() const;
+  FieldID GetFirstFieldID() const {
+    return GetLastFieldID() - fields.size() + 1;
+  }
+
+  FieldID GetFirstLocalFieldID() const;
+  // return class id or superclass id accroding to input string
+  MIRClassType *GetExceptionRootType();
+  const MIRClassType *GetExceptionRootType() const;
+  bool IsExceptionType() const;
+  void AddImplementedInterface(TyIdx interfaceTyIdx) {
+    if (std::find(interfacesImplemented.begin(), interfacesImplemented.end(), interfaceTyIdx) ==
+        interfacesImplemented.end()) {
+      interfacesImplemented.push_back(interfaceTyIdx);
+    }
+  }
+
+  void ClearContents() override {
+    MIRStructType::ClearContents();
+    parentTyIdx = TyIdx(0);
+    interfacesImplemented.clear();  // for the list of interfaces the class implements
+    info.clear();
+    infoIsString.clear();
+    pragmaVec.clear();
+    staticValue.clear();
+  }
+
+  size_t GetHashIndex() const override {
+    return ((static_cast<size_t>(nameStrIdx) << kShiftNumOfNameStrIdx) + (typeKind << kShiftNumOfTypeKind)) %
+           kTypeHashLength;
+  }
+
+  uint32 NumberOfFieldIDs() const override;
+
+ private:
+  TyIdx parentTyIdx{ 0 };
+  std::vector<TyIdx> interfacesImplemented{};  // for the list of interfaces the class implements
+  std::vector<MIRInfoPair> info{};
+  std::vector<bool> infoIsString{};
+  std::vector<MIRPragma*> pragmaVec{};
+  MIREncodedArray staticValue{};  // DELETE THIS
+};
+
+// used by kTypeInterface, kTypeInterfaceIncomplete
+class MIRInterfaceType : public MIRStructType {
+ public:
+  explicit MIRInterfaceType(MIRTypeKind tKind) : MIRStructType(tKind) {}
+  MIRInterfaceType(MIRTypeKind tKind, GStrIdx strIdx) : MIRStructType(tKind, strIdx) {}
+  ~MIRInterfaceType() override = default;
+
+  bool EqualTo(const MIRType &type) const override;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRInterfaceType(*this);
+  }
+
+  const std::vector<MIRInfoPair> &GetInfo() const override {
+    return info;
+  }
+  void PushbackMIRInfo(const MIRInfoPair &pair) override {
+    info.push_back(pair);
+  }
+  uint32 GetInfo(const std::string &infoStr) const;
+  uint32 GetInfo(GStrIdx strIdx) const;
+  size_t GetInfoSize() const {
+    return info.size();
+  }
+
+  const MIRInfoPair &GetInfoElemt(size_t n) const override {
+    ASSERT(n < info.size(), "array index out of range");
+    return info.at(n);
+  }
+
+  const std::vector<bool> &GetInfoIsString() const override {
+    return infoIsString;
+  }
+  void PushbackIsString(bool isString) override {
+    infoIsString.push_back(isString);
+  }
+  size_t GetInfoIsStringSize() const {
+    return infoIsString.size();
+  }
+  bool GetInfoIsStringElemt(size_t n) const override {
+    ASSERT(n < infoIsString.size(), "array index out of range");
+    return infoIsString.at(n);
+  }
+
+  std::vector<MIRPragma*> &GetPragmaVec() override {
+    return pragmaVec;
+  }
+  const std::vector<MIRPragma*> &GetPragmaVec() const override {
+    return pragmaVec;
+  }
+  void PushbackPragma(MIRPragma *pragma) override {
+    pragmaVec.push_back(pragma);
+  }
+
+  const MIREncodedArray &GetStaticValue() const override {
+    return staticValue;
+  }
+  void PushbackStaticValue(EncodedValue &encodedValue) override {
+    staticValue.push_back(encodedValue);
+  }
+
+  std::vector<TyIdx> &GetParentsTyIdx() {
+    return parentsTyIdx;
+  }
+  void SetParentsTyIdx(const std::vector<TyIdx> &parents) {
+    parentsTyIdx = parents;
+  }
+  const std::vector<TyIdx> &GetParentsTyIdx() const {
+    return parentsTyIdx;
+  }
+
+  TyIdx GetParentsElementTyIdx(size_t i) const {
+    ASSERT(i < parentsTyIdx.size(), "array index out of range");
+    return parentsTyIdx[i];
+  }
+
+  void SetParentsElementTyIdx(size_t i, TyIdx tyIdx) {
+    ASSERT(i < parentsTyIdx.size(), "array index out of range");
+    parentsTyIdx[i] = tyIdx;
+  }
+
+  void Dump(int indent, bool dontUseName = false) const override;
+  bool HasVolatileField() const override;
+  bool HasTypeParam() const override;
+  FieldPair TraverseToFieldRef(FieldID &fieldID) const override;
+  void SetComplete() override {
+    typeKind = kTypeInterface;
+  }
+
+  size_t GetSize() const override;
+
+  void ClearContents() override {
+    MIRStructType::ClearContents();
+    parentsTyIdx.clear();
+    info.clear();
+    infoIsString.clear();
+    pragmaVec.clear();
+    staticValue.clear();
+  }
+
+  size_t GetHashIndex() const override {
+    return ((static_cast<size_t>(nameStrIdx) << kShiftNumOfNameStrIdx) + (typeKind << kShiftNumOfTypeKind)) %
+           kTypeHashLength;
+  }
+
+  bool HasFields() const override { return false; }
+  uint32 NumberOfFieldIDs() const override { return 0; }
+  MIRStructType *EmbeddedStructType() override { return nullptr; }
+
+ private:
+  std::vector<TyIdx> parentsTyIdx{};  // multiple inheritence
+  std::vector<MIRInfoPair> info{};
+  std::vector<bool> infoIsString{};
+  std::vector<MIRPragma*> pragmaVec{};
+  MIREncodedArray staticValue{};  // DELETE THIS
+};
+
+
+class MIRBitFieldType : public MIRType {
+ public:
+  MIRBitFieldType(uint8 field, PrimType pt) : MIRType(kTypeBitField, pt), fieldSize(field) {}
+  MIRBitFieldType(uint8 field, PrimType pt, GStrIdx strIdx) : MIRType(kTypeBitField, pt, strIdx), fieldSize(field) {}
+  ~MIRBitFieldType() override = default;
+
+  uint8 GetFieldSize() const {
+    return fieldSize;
+  }
+
+  bool EqualTo(const MIRType &type) const override;
+  void Dump(int indent, bool dontUseName = false) const override;
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRBitFieldType(*this);
+  }
+
+  size_t GetSize() const override {
+    if (fieldSize == 0) {
+      return 0;
+    } else if (fieldSize <= 8) {
+      return 1;
+    } else {
+      return (fieldSize + 7) / 8;
+    }
+  }  // size not be in bytes
+
+  uint32 GetAlign() const override {
+    return 0;
+  }  // align not be in bytes
+
+  size_t GetHashIndex() const override {
+    return ((static_cast<uint32>(primType) << fieldSize) + (typeKind << kShiftNumOfTypeKind)) % kTypeHashLength;
+  }
+
+ private:
+  uint8 fieldSize;
+};
+
+class MIRFuncType : public MIRType {
+ public:
+  MIRFuncType() : MIRType(kTypeFunction, PTY_ptr) {}
+
+  explicit MIRFuncType(const GStrIdx &strIdx)
+      : MIRType(kTypeFunction, PTY_ptr, strIdx) {}
+
+  MIRFuncType(const TyIdx &retTyIdx, const std::vector<TyIdx> &vecTy, const std::vector<TypeAttrs> &vecAt,
+              const TypeAttrs &retAttrsIn)
+      : MIRType(kTypeFunction, PTY_ptr),
+        retTyIdx(retTyIdx),
+        paramTypeList(vecTy),
+        paramAttrsList(vecAt),
+        retAttrs(retAttrsIn) {}
+
+  ~MIRFuncType() override = default;
+
+  bool EqualTo(const MIRType &type) const override;
+  bool CompatibleWith(const MIRType &type) const;
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRFuncType(*this);
+  }
+
+  void Dump(int indent, bool dontUseName = false) const override;
+  size_t GetSize() const override {
+    return 0;
+  }  // size unknown
+
+  TyIdx GetRetTyIdx() const {
+    return retTyIdx;
+  }
+
+  void SetRetTyIdx(TyIdx idx) {
+    retTyIdx = idx;
+  }
+
+  const std::vector<TyIdx> &GetParamTypeList() const {
+    return paramTypeList;
+  }
+
+  std::vector<TyIdx> &GetParamTypeList() {
+    return paramTypeList;
+  }
+
+  TyIdx GetNthParamType(size_t i) const {
+    ASSERT(i < paramTypeList.size(), "array index out of range");
+    return paramTypeList[i];
+  }
+
+  void SetParamTypeList(const std::vector<TyIdx> &list) {
+    paramTypeList.clear();
+    (void)paramTypeList.insert(paramTypeList.begin(), list.begin(), list.end());
+  }
+
+  const std::vector<TypeAttrs> &GetParamAttrsList() const {
+    return paramAttrsList;
+  }
+
+  std::vector<TypeAttrs> &GetParamAttrsList() {
+    return paramAttrsList;
+  }
+
+  const TypeAttrs &GetNthParamAttrs(size_t i) const {
+    ASSERT(i < paramAttrsList.size(), "array index out of range");
+    return paramAttrsList[i];
+  }
+
+  TypeAttrs &GetNthParamAttrs(size_t i) {
+    ASSERT(i < paramAttrsList.size(), "array index out of range");
+    return paramAttrsList[i];
+  }
+
+  void SetParamAttrsList(const std::vector<TypeAttrs> &list) {
+    paramAttrsList.clear();
+    (void)paramAttrsList.insert(paramAttrsList.begin(), list.begin(), list.end());
+  }
+
+  void SetNthParamAttrs(size_t i, const TypeAttrs &attrs) {
+    ASSERT(i < paramAttrsList.size(), "array index out of range");
+    paramAttrsList[i] = attrs;
+  }
+
+  bool IsVarargs() const {
+    return funcAttrs.GetAttr(FUNCATTR_varargs);
+  }
+
+  void SetVarArgs() {
+    funcAttrs.SetAttr(FUNCATTR_varargs);
+  }
+
+  bool FirstArgReturn() const {
+    return funcAttrs.GetAttr(FUNCATTR_firstarg_return);
+  }
+
+  void SetFirstArgReturn() {
+    funcAttrs.SetAttr(FUNCATTR_firstarg_return);
+  }
+
+  const TypeAttrs &GetRetAttrs() const {
+    return retAttrs;
+  }
+
+  TypeAttrs &GetRetAttrs() {
+    return retAttrs;
+  }
+
+  void SetRetAttrs(const TypeAttrs &attrs) {
+    retAttrs = attrs;
+  }
+
+  size_t GetHashIndex() const override {
+    constexpr uint8 idxShift = 6;
+    size_t hIdx = (static_cast<size_t>(retTyIdx) << idxShift) + (typeKind << kShiftNumOfTypeKind);
+    size_t size = paramTypeList.size();
+    hIdx += (size != 0 ? (static_cast<size_t>(paramTypeList[0]) + size) : 0) << 4; // shift bit is 4
+    return hIdx % kTypeHashLength;
+  }
+  FuncAttrs funcAttrs;
+ private:
+  TyIdx retTyIdx{ 0 };
+  std::vector<TyIdx> paramTypeList;
+  std::vector<TypeAttrs> paramAttrsList;
+  TypeAttrs retAttrs;
+};
+
+class MIRTypeByName : public MIRType {
+  // use nameStrIdx to store the name for both local and global
+ public:
+  explicit MIRTypeByName(GStrIdx gStrIdx) : MIRType(kTypeByName, PTY_void) {
+    nameStrIdx = gStrIdx;
+  }
+
+  ~MIRTypeByName() override = default;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRTypeByName(*this);
+  }
+
+  bool EqualTo(const MIRType &type) const override;
+
+  void Dump(int indent, bool dontUseName = false) const override;
+  size_t GetSize() const override {
+    return 0;
+  }  // size unknown
+
+  size_t GetHashIndex() const override {
+    constexpr uint8 idxShift = 2;
+    uint8 nameIsLocalValue = nameIsLocal ? 1 : 0;
+    return ((static_cast<size_t>(nameStrIdx) << idxShift) + nameIsLocalValue + (typeKind << kShiftNumOfTypeKind)) %
+           kTypeHashLength;
+  }
+};
+
+class MIRTypeParam : public MIRType {
+  // use nameStrIdx to store the name
+ public:
+  explicit MIRTypeParam(GStrIdx gStrIdx) : MIRType(kTypeParam, PTY_gen) {
+    nameStrIdx = gStrIdx;
+  }
+
+  ~MIRTypeParam() override = default;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRTypeParam(*this);
+  }
+
+  bool EqualTo(const MIRType &type) const override;
+  void Dump(int indent, bool dontUseName = false) const override;
+  size_t GetSize() const override {
+    return 0;
+  }  // size unknown
+
+  bool HasTypeParam() const override {
+    return true;
+  }
+
+  size_t GetHashIndex() const override {
+    constexpr uint8 idxShift = 3;
+    return ((static_cast<size_t>(nameStrIdx) << idxShift) + (typeKind << kShiftNumOfTypeKind)) % kTypeHashLength;
+  }
+};
+
+using TypePair = std::pair<TyIdx, TyIdx>;
+using GenericInstantVector = std::vector<TypePair>;
+class MIRInstantVectorType : public MIRType {
+ public:
+  MIRInstantVectorType() : MIRType(kTypeInstantVector, PTY_agg) {}
+
+  explicit MIRInstantVectorType(MIRTypeKind kind) : MIRType(kind, PTY_agg) {}
+
+  MIRInstantVectorType(MIRTypeKind kind, GStrIdx strIdx) : MIRType(kind, PTY_agg, strIdx) {}
+
+  ~MIRInstantVectorType() override = default;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRInstantVectorType(*this);
+  }
+
+  bool EqualTo(const MIRType &type) const override;
+  void Dump(int indent, bool dontUseName = false) const override;
+  size_t GetSize() const override {
+    return 0;
+  }  // size unknown
+
+  const GenericInstantVector &GetInstantVec() const {
+    return instantVec;
+  }
+
+  GenericInstantVector &GetInstantVec() {
+    return instantVec;
+  }
+
+  void AddInstant(TypePair typePair) {
+    instantVec.push_back(typePair);
+  }
+
+  size_t GetHashIndex() const override {
+    constexpr uint8 idxShift = 3;
+    uint32 hIdx = typeKind << kShiftNumOfTypeKind;
+    for (const TypePair &typePair : instantVec) {
+      hIdx += static_cast<uint32>(typePair.first + typePair.second) << idxShift;
+    }
+    return hIdx % kTypeHashLength;
+  }
+
+ protected:
+  GenericInstantVector instantVec{};  // in each pair, first is generic type, second is real type
+};
+
+class MIRGenericInstantType : public MIRInstantVectorType {
+ public:
+  explicit MIRGenericInstantType(TyIdx genTyIdx)
+      : MIRInstantVectorType(kTypeGenericInstant), genericTyIdx(genTyIdx) {}
+
+  explicit MIRGenericInstantType(GStrIdx strIdx)
+      : MIRInstantVectorType(kTypeGenericInstant, strIdx), genericTyIdx(0) {}
+
+  ~MIRGenericInstantType() override = default;
+
+  MIRType *CopyMIRTypeNode() const override {
+    return new MIRGenericInstantType(*this);
+  }
+
+  bool EqualTo(const MIRType &type) const override;
+  void Dump(int indent, bool dontUseName = false) const override;
+
+  size_t GetSize() const override {
+    return 0;
+  }  // size unknown
+
+  TyIdx GetGenericTyIdx() const {
+    return genericTyIdx;
+  }
+  void SetGenericTyIdx(TyIdx idx) {
+    genericTyIdx = idx;
+  }
+
+  size_t GetHashIndex() const override {
+    constexpr uint8 idxShift = 2;
+    uint32 hIdx = (static_cast<uint32>(genericTyIdx) << idxShift) + (typeKind << kShiftNumOfTypeKind);
+    for (const TypePair &typePair : instantVec) {
+      hIdx += static_cast<uint32>(typePair.first + typePair.second) << 3; // shift bit is 3
+    }
+    return hIdx % kTypeHashLength;
+  }
+
+ private:
+  TyIdx genericTyIdx;  // the generic type to be instantiated
+};
+
+MIRType *GetElemType(const MIRType &arrayType);
+#endif  // MIR_FEATURE_FULL
+}  // namespace maple
+
+#define LOAD_SAFE_CAST_FOR_MIR_TYPE
+#include "ir_safe_cast_traits.def"
+
+#endif  // MAPLE_IR_INCLUDE_MIR_TYPE_H
diff --git a/src/mapleall/maple_ir/include/mpl2mpl_options.h b/src/mapleall/maple_ir/include/mpl2mpl_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..9615ec85f9a99e49cf7f5cf3b691020242419c0c
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mpl2mpl_options.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_IR_INCLUDE_MPL2MPL_OPTION_H
+#define MAPLE_IR_INCLUDE_MPL2MPL_OPTION_H
+
+#include "cl_option.h"
+#include "cl_parser.h"
+
+#include <bits/stdint-uintn.h>
+#include <cstdint>
+#include <string>
+
+namespace opts::mpl2mpl {
+
+extern maplecl::Option<std::string> dumpPhase;
+extern maplecl::Option<std::string> skipPhase;
+extern maplecl::Option<std::string> skipFrom;
+extern maplecl::Option<std::string> skipAfter;
+extern maplecl::Option<std::string> dumpFunc;
+extern maplecl::Option<bool> quiet;
+extern maplecl::Option<bool> mapleLinker;
+extern maplecl::Option<bool> regNativeFunc;
+
+extern maplecl::Option<bool> inlineWithProfile;
+extern maplecl::Option<bool> inlineOpt;
+extern maplecl::Option<bool> ipaClone;
+extern maplecl::Option<bool> ginlineOpt;
+extern maplecl::Option<std::string> noInlineFunc;
+extern maplecl::Option<std::string> importFileList;
+extern maplecl::Option<bool> crossModuleInline;
+extern maplecl::Option<uint32_t> inlineSmallFunctionThreshold;
+extern maplecl::Option<uint32_t> inlineHotFunctionThreshold;
+extern maplecl::Option<uint32_t> inlineRecursiveFunctionThreshold;
+extern maplecl::Option<uint32_t> inlineDepth;
+extern maplecl::Option<uint32_t> inlineModuleGrow;
+extern maplecl::Option<uint32_t> inlineColdFuncThresh;
+extern maplecl::Option<bool> respectAlwaysInline;
+extern maplecl::Option<uint32_t> ginlineMaxNondeclaredInlineCallee;
+extern maplecl::Option<uint32_t> ginlineMaxDepthIgnoreGrowthLimit;
+extern maplecl::Option<uint32_t> ginlineSmallFunc;
+extern maplecl::Option<uint32_t> ginlineRelaxSmallFuncDecalredInline;
+extern maplecl::Option<uint32_t> ginlineRelaxSmallFuncCanbeRemoved;
+extern maplecl::Option<std::string> callsiteProfilePath;
+extern maplecl::Option<bool> inlineToAllCallers;
+extern maplecl::Option<bool> ginlineAllowNondeclaredInlineSizeGrow;
+extern maplecl::Option<bool> ginlineAllowIgnoreGrowthLimit;
+
+extern maplecl::Option<uint32_t> profileHotCount;
+extern maplecl::Option<uint32_t> profileColdCount;
+extern maplecl::Option<uint32_t> profileHotRate;
+extern maplecl::Option<uint32_t> profileColdRate;
+extern maplecl::Option<bool> nativeWrapper;
+extern maplecl::Option<bool> regNativeDynamicOnly;
+extern maplecl::Option<std::string> staticBindingList;
+extern maplecl::Option<bool> dumpBefore;
+extern maplecl::Option<bool> dumpAfter;
+extern maplecl::Option<bool> dumpMuid;
+extern maplecl::Option<bool> emitVtableImpl;
+
+#if MIR_JAVA
+extern maplecl::Option<bool> skipVirtual;
+#endif
+
+extern maplecl::Option<bool> userc;
+extern maplecl::Option<bool> strictNaiveRc;
+extern maplecl::Option<bool> rcOpt1;
+extern maplecl::Option<bool> nativeOpt;
+extern maplecl::Option<bool> o0;
+extern maplecl::Option<bool> o2;
+extern maplecl::Option<bool> os;
+extern maplecl::Option<std::string> criticalNative;
+extern maplecl::Option<std::string> fastNative;
+extern maplecl::Option<bool> noDot;
+extern maplecl::Option<bool> genIrProfile;
+extern maplecl::Option<bool> proFileTest;
+extern maplecl::Option<bool> barrier;
+extern maplecl::Option<std::string> nativeFuncPropertyFile;
+extern maplecl::Option<bool> mapleLinkerNolocal;
+extern maplecl::Option<uint32_t> buildApp;
+extern maplecl::Option<bool> partialAot;
+extern maplecl::Option<uint32_t> decoupleInit;
+extern maplecl::Option<std::string> sourceMuid;
+extern maplecl::Option<bool> deferredVisit;
+extern maplecl::Option<bool> deferredVisit2;
+extern maplecl::Option<bool> decoupleSuper;
+extern maplecl::Option<bool> genDecoupleVtab;
+extern maplecl::Option<bool> profileFunc;
+extern maplecl::Option<std::string> dumpDevirtual;
+extern maplecl::Option<std::string> readDevirtual;
+extern maplecl::Option<bool> useWhiteClass;
+extern maplecl::Option<std::string> appPackageName;
+extern maplecl::Option<std::string> checkClInvocation;
+extern maplecl::Option<bool> dumpClInvocation;
+extern maplecl::Option<uint32_t> warning;
+extern maplecl::Option<bool> lazyBinding;
+extern maplecl::Option<bool> hotFix;
+extern maplecl::Option<bool> compactMeta;
+extern maplecl::Option<bool> genPGOReport;
+extern maplecl::Option<uint32_t> inlineCache;
+extern maplecl::Option<bool> noComment;
+extern maplecl::Option<bool> rmNouseFunc;
+extern maplecl::Option<bool> sideEffect;
+extern maplecl::Option<bool> dumpIPA;
+extern maplecl::Option<bool> wpaa;
+extern maplecl::Option<uint32_t> numOfCloneVersions;
+extern maplecl::Option<uint32_t> numOfImpExprLowBound;
+extern maplecl::Option<uint32_t> numOfImpExprHighBound;
+extern maplecl::Option<uint32_t> numOfCallSiteLowBound;
+extern maplecl::Option<uint32_t> numOfCallSiteUpBound;
+extern maplecl::Option<uint32_t> numOfConstpropValue;
+extern maplecl::Option<size_t> outlineThreshold;
+}
+
+#endif /* MAPLE_IR_INCLUDE_MPL2MPL_OPTION_H */
diff --git a/src/mapleall/maple_ir/include/opcode_info.h b/src/mapleall/maple_ir/include/opcode_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..5a82646b11d295cbece3c26f3b1a8c4c44c1f09c
--- /dev/null
+++ b/src/mapleall/maple_ir/include/opcode_info.h
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_OPCODE_INFO_H
+#define MAPLE_IR_INCLUDE_OPCODE_INFO_H
+#include "types_def.h"
+#include "opcodes.h"
+#include "mpl_logging.h"
+
+namespace maple {
+enum OpcodeProp {
+  kOpcodePropNone,
+  kOpcodePropIsStmt,          // The instruction is a stmt, so has 2 stmt pointers
+  kOpcodePropIsVarSize,       // The instruction size is not fixed
+  kOpcodePropNotMMPL,         // The instruction is not allowed in Machine Maple IR
+  kOpcodePropIsCompare,       // The instruction is one of the 6 comparison ops
+  kOpcodePropIsTypeCvt,       // The instruction is a type conversion op
+  kOpcodePropHasSSAUse,       // The instruction may incur a use in SSA form
+  kOpcodePropHasSSADef,       // The instruction may incur a def in SSA form
+  kOpcodePropIsCall,          // The instruction is among the call instructions
+  kOpcodePropIsCallAssigned,  // The instruction is among the call instructions with implicit assignments of the
+  // returned values
+  kOpcodePropNotPure,         // The operation does not return same result with idential operands
+  kOpcodePropMayThrowException,
+  kOpcodePropIsAssertNonnull,       // The operation check nonnnull
+  kOpcodePropIsAssertUpperBoundary, // The operation check upper boundary
+  kOpcodePropIsAssertLowerBoundary, // The operation check lower boundary
+};
+
+constexpr unsigned long OPCODEISSTMT = 1ULL << kOpcodePropIsStmt;
+constexpr unsigned long OPCODEISVARSIZE = 1ULL << kOpcodePropIsVarSize;
+constexpr unsigned long OPCODENOTMMPL = 1ULL << kOpcodePropNotMMPL;
+constexpr unsigned long OPCODEISCOMPARE = 1ULL << kOpcodePropIsCompare;
+constexpr unsigned long OPCODEISTYPECVT = 1ULL << kOpcodePropIsTypeCvt;
+constexpr unsigned long OPCODEHASSSAUSE = 1ULL << kOpcodePropHasSSAUse;
+constexpr unsigned long OPCODEHASSSADEF = 1ULL << kOpcodePropHasSSADef;
+constexpr unsigned long OPCODEISCALL = 1ULL << kOpcodePropIsCall;
+constexpr unsigned long OPCODEISCALLASSIGNED = 1ULL << kOpcodePropIsCallAssigned;
+constexpr unsigned long OPCODENOTPURE = 1ULL << kOpcodePropNotPure;
+constexpr unsigned long OPCODEMAYTHROWEXCEPTION = 1ULL << kOpcodePropMayThrowException;
+constexpr unsigned long OPCODEASSERTNONNULL = 1ULL << kOpcodePropIsAssertNonnull;
+constexpr unsigned long OPCODEASSERTUPPERBOUNDARY = 1ULL << kOpcodePropIsAssertUpperBoundary;
+constexpr unsigned long OPCODEASSERTLOWERBOUNDARY = 1ULL << kOpcodePropIsAssertLowerBoundary;
+
+struct OpcodeDesc {
+  uint8 instrucSize;  // size of instruction in bytes
+  uint16 flag;        // stores the opcode property flags
+  std::string name;
+};
+
+class OpcodeTable {
+ public:
+  OpcodeTable();
+  ~OpcodeTable() = default;
+
+  OpcodeDesc GetTableItemAt(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o];
+  }
+
+  bool IsStmt(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEISSTMT;
+  }
+
+  bool IsVarSize(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEISVARSIZE;
+  }
+
+  bool NotMMPL(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODENOTMMPL;
+  }
+
+  bool IsCompare(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEISCOMPARE;
+  }
+
+  bool IsTypeCvt(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEISTYPECVT;
+  }
+
+  bool HasSSAUse(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEHASSSAUSE;
+  }
+
+  bool HasSSADef(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEHASSSADEF;
+  }
+
+  bool IsCall(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEISCALL;
+  }
+
+  bool IsCallAssigned(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEISCALLASSIGNED;
+  }
+
+  bool IsICall(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return o == OP_icall || o == OP_icallassigned ||
+           o == OP_icallproto || o == OP_icallprotoassigned ||
+           o == OP_virtualicall || o == OP_virtualicallassigned ||
+           o == OP_interfaceicall || o == OP_interfaceicallassigned;
+  }
+
+  bool NotPure(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODENOTPURE;
+  }
+
+  bool MayThrowException(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEMAYTHROWEXCEPTION;
+  }
+
+  bool HasSideEffect(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return MayThrowException(o);
+  }
+
+  const std::string &GetName(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].name;
+  }
+
+  bool IsCondBr(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return o == OP_brtrue || o == OP_brfalse;
+  }
+
+  bool AssignActualVar(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return o == OP_dassign || o == OP_regassign;
+  }
+
+  bool IsAssertNonnull(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEASSERTNONNULL;
+  }
+
+  bool IsCallAssertNonnull(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return o == OP_callassertnonnull;
+  }
+
+  bool IsAssertBoundary(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & (OPCODEASSERTUPPERBOUNDARY | OPCODEASSERTLOWERBOUNDARY);
+  }
+
+  bool IsAssertUpperBoundary(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEASSERTUPPERBOUNDARY;
+  }
+
+  bool IsAssertLowerBoundary(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return table[o].flag & OPCODEASSERTLOWERBOUNDARY;
+  }
+
+  bool IsCallAssertBoundary(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return o == OP_callassertle;
+  }
+
+  bool IsAssertLeBoundary(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return (o == OP_callassertle || o == OP_returnassertle || o == OP_assignassertle);
+  }
+
+  bool IsCalcAssertBoundary(Opcode o) const {
+    ASSERT(o < OP_last, "invalid opcode");
+    return (o == OP_calcassertlt || o == OP_calcassertge);
+  }
+
+ private:
+  OpcodeDesc table[OP_last];
+};
+extern const OpcodeTable kOpcodeInfo;
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_OPCODE_INFO_H
diff --git a/src/mapleall/maple_ir/include/opcodes.def b/src/mapleall/maple_ir/include/opcodes.def
new file mode 100644
index 0000000000000000000000000000000000000000..a038adf61f3e68795299ea30db04d79d08c5b76e
--- /dev/null
+++ b/src/mapleall/maple_ir/include/opcodes.def
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+// Stmt & Notmmpl
+  // storage access opcodes
+  OPCODE(dassign, DassignNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEHASSSADEF), 8)
+  OPCODE(piassign, PiassignNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEHASSSADEF), 8)
+  OPCODE(maydassign, DassignNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEHASSSADEF), 8)
+  OPCODE(iassign, IassignNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEHASSSADEF), 12)
+  // hierarchical control flow opcodes
+  OPCODE(block, BlockNode, (OPCODEISSTMT | OPCODENOTMMPL), 0)
+  OPCODE(doloop, DoloopNode, (OPCODEISSTMT | OPCODENOTMMPL), 0)
+  OPCODE(dowhile, WhileStmtNode, (OPCODEISSTMT | OPCODENOTMMPL), 0)
+  OPCODE(if, IfStmtNode, (OPCODEISSTMT | OPCODENOTMMPL), 0)
+  OPCODE(while, WhileStmtNode, (OPCODEISSTMT | OPCODENOTMMPL), 0)
+  OPCODE(switch, SwitchNode, (OPCODEISSTMT | OPCODENOTMMPL), 8)
+  OPCODE(multiway, MultiwayNode, (OPCODEISSTMT | OPCODENOTMMPL), 8)
+  OPCODE(foreachelem, ForeachelemNode, (OPCODEISSTMT | OPCODENOTMMPL), 0)
+  // other opcodes
+  OPCODE(comment, CommentNode, (OPCODEISSTMT | OPCODENOTMMPL), 0)
+  OPCODE(eval, UnaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL), 8)
+  OPCODE(free, UnaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL), 8)
+  OPCODE(calcassertge, BinaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTLOWERBOUNDARY), 8)
+  OPCODE(calcassertlt, BinaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTUPPERBOUNDARY), 8)
+  OPCODE(assertge, AssertBoundaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTLOWERBOUNDARY), 8)
+  OPCODE(assertlt, AssertBoundaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTUPPERBOUNDARY), 8)
+  OPCODE(callassertle, CallAssertBoundaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTUPPERBOUNDARY), 8)
+  OPCODE(returnassertle, AssertBoundaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTUPPERBOUNDARY), 8)
+  OPCODE(assignassertle, AssertBoundaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTUPPERBOUNDARY), 8)
+  OPCODE(abort, UnaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL), 8)
+  OPCODE(assertnonnull, UnaryStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTNONNULL), 8)
+  OPCODE(assignassertnonnull, AssignAssertNonnullStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTNONNULL), 8)
+  OPCODE(callassertnonnull, CallAssertNonnullStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTNONNULL), 8)
+  OPCODE(returnassertnonnull, ReturnAssertNonnullStmtNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEASSERTNONNULL), 8)
+// Expr & Notmmpl
+  // storage access opcodes
+  OPCODE(dread, AddrofNode, (OPCODENOTMMPL | OPCODEHASSSAUSE), 12)
+  OPCODE(iread, IreadNode, (OPCODENOTMMPL | OPCODEHASSSAUSE), 12)
+  // leaf opcodes
+  OPCODE(addrof, AddrofNode, OPCODENOTMMPL, 12)
+  OPCODE(iaddrof, IreadNode, OPCODENOTMMPL, 12)
+  OPCODE(sizeoftype, SizeoftypeNode, OPCODENOTMMPL, 8)
+  OPCODE(fieldsdist, FieldsDistNode, OPCODENOTMMPL, 8)
+  // N-ary expression opcodes
+  OPCODE(array, ArrayNode, (OPCODEISVARSIZE | OPCODENOTMMPL | OPCODEMAYTHROWEXCEPTION), 8)
+// Stmt
+  // storage access opcodes
+  OPCODE(iassignoff, IassignoffNode, OPCODEISSTMT, 8)
+  OPCODE(iassignfpoff, IassignFPoffNode, OPCODEISSTMT, 8)
+  OPCODE(regassign, RegassignNode, (OPCODEISSTMT | OPCODEHASSSADEF), 8)
+  // flat control flow opcodes
+  OPCODE(goto, GotoNode, OPCODEISSTMT, 8)
+  OPCODE(brfalse, CondGotoNode, OPCODEISSTMT, 8)
+  OPCODE(brtrue, CondGotoNode, OPCODEISSTMT, 8)
+  OPCODE(return, NaryStmtNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE), 0)
+  OPCODE(rangegoto, RangeGotoNode, OPCODEISSTMT, 8)
+  // call opcodes
+  OPCODE(call, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(virtualcall, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(superclasscall, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(interfacecall, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(customcall, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(polymorphiccall, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 12)
+  OPCODE(icall, IcallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(interfaceicall, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(virtualicall, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(intrinsiccall, IntrinsiccallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(intrinsiccallwithtype, IntrinsiccallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 12)
+  OPCODE(xintrinsiccall, IntrinsiccallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(callassigned, CallNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(virtualcallassigned, CallNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(superclasscallassigned, CallNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(interfacecallassigned, CallNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(customcallassigned, CallNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(polymorphiccallassigned, CallNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(icallassigned, IcallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(interfaceicallassigned, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(virtualicallassigned, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(intrinsiccallassigned, IntrinsiccallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(intrinsiccallwithtypeassigned, IntrinsiccallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(xintrinsiccallassigned, IntrinsiccallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  // call with generic instantiation opcodes
+  OPCODE(callinstant, CallinstantNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 0)
+  OPCODE(callinstantassigned, CallinstantNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(virtualcallinstant, CallinstantNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 0)
+  OPCODE(virtualcallinstantassigned, CallinstantNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(superclasscallinstant, CallinstantNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 0)
+  OPCODE(superclasscallinstantassigned, CallinstantNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  OPCODE(interfacecallinstant, CallinstantNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 0)
+  OPCODE(interfacecallinstantassigned, CallinstantNode,  (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 0)
+  // exception handling
+  OPCODE(jstry, JsTryNode, OPCODEISSTMT, 8)
+  OPCODE(try, TryNode, (OPCODEISSTMT | OPCODENOTMMPL), 8)
+  OPCODE(cpptry, TryNode, (OPCODEISSTMT | OPCODENOTMMPL), 8)
+
+  OPCODE(throw, UnaryStmtNode, (OPCODEISSTMT | OPCODEHASSSAUSE), 0)
+
+  OPCODE(jscatch, StmtNode, OPCODEISSTMT, 4)
+  OPCODE(catch, CatchNode, OPCODEISSTMT, 8)
+  OPCODE(cppcatch, CppCatchNode, OPCODEISSTMT, 8)
+
+  OPCODE(finally, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(cleanuptry, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(endtry, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(safe, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(endsafe, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(unsafe, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(endunsafe, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(gosub, GotoNode, (OPCODEISSTMT | OPCODEHASSSAUSE), 8)
+  OPCODE(retsub, StmtNode, (OPCODEISSTMT | OPCODEHASSSAUSE), 6)
+  // synchronizaion
+  OPCODE(syncenter, NaryStmtNode, (OPCODEISSTMT | OPCODEHASSSADEF | OPCODEHASSSAUSE), 0)
+  OPCODE(syncexit, NaryStmtNode, (OPCODEISSTMT | OPCODEHASSSADEF | OPCODEHASSSAUSE), 0)
+  OPCODE(decref, UnaryStmtNode, (OPCODEISSTMT | OPCODEHASSSAUSE | OPCODENOTMMPL), 0)
+  OPCODE(incref, UnaryStmtNode, (OPCODEISSTMT | OPCODEHASSSAUSE | OPCODENOTMMPL), 0)
+  OPCODE(decrefreset, UnaryStmtNode, (OPCODEISSTMT | OPCODEHASSSAUSE | OPCODENOTMMPL), 0)
+  // barriers
+  OPCODE(membaracquire, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(membarrelease, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(membarstoreload, StmtNode, OPCODEISSTMT, 6)
+  OPCODE(membarstorestore, StmtNode, OPCODEISSTMT, 6)
+  // other opcodes
+  OPCODE(label, LabelNode, OPCODEISSTMT, 8)
+// Expr
+  // storage access opcodes
+  OPCODE(ireadoff, IreadoffNode, 0, 8)
+  OPCODE(ireadfpoff, IreadFPoffNode, 0, 8)
+  OPCODE(regread, RegreadNode, OPCODEHASSSAUSE, 8)
+  // leaf opcodes
+  OPCODE(addroffunc, AddroffuncNode, 0, 8)
+  OPCODE(addroflabel, AddroflabelNode, 0, 8)
+  OPCODE(constval, ConstvalNode, 0, 8)
+  OPCODE(conststr, ConststrNode, OPCODENOTMMPL, 8)
+  OPCODE(conststr16, Conststr16Node, OPCODENOTMMPL, 8)
+  // type conversion expression opcodes
+  OPCODE(ceil, TypeCvtNode, OPCODEISTYPECVT, 8)
+  OPCODE(cvt, TypeCvtNode, OPCODEISTYPECVT, 8)
+  OPCODE(floor, TypeCvtNode, OPCODEISTYPECVT, 8)
+  OPCODE(retype, RetypeNode, OPCODEISTYPECVT, 8)
+  OPCODE(round, TypeCvtNode, OPCODEISTYPECVT, 8)
+  OPCODE(trunc, TypeCvtNode, OPCODEISTYPECVT, 8)
+  // unary expression opcodes
+  OPCODE(abs, UnaryNode, 0, 0)
+  OPCODE(bnot, UnaryNode, 0, 0)
+  OPCODE(lnot, UnaryNode, 0, 0)
+  OPCODE(neg, UnaryNode, 0, 0)
+  OPCODE(recip, UnaryNode, 0, 0)
+  OPCODE(sqrt, UnaryNode, 0, 0)
+  OPCODE(sext, ExtractbitsNode, 0, 8)
+  OPCODE(zext, ExtractbitsNode, 0, 8)
+  OPCODE(alloca, UnaryNode, OPCODENOTPURE, 0)
+  OPCODE(malloc, UnaryNode, OPCODENOTPURE, 0)
+  OPCODE(gcmalloc, GCMallocNode, OPCODENOTPURE, 8)
+  OPCODE(gcpermalloc, GCMallocNode, OPCODENOTPURE, 8)
+  OPCODE(stackmalloc, GCMallocNode, OPCODENOTPURE, 8)
+  OPCODE(gcmallocjarray, JarrayMallocNode, OPCODENOTPURE, 12)
+  OPCODE(gcpermallocjarray, JarrayMallocNode, OPCODENOTPURE, 12)
+  OPCODE(stackmallocjarray, JarrayMallocNode, OPCODENOTPURE, 12)
+  OPCODE(resolveinterfacefunc, ResolveFuncNode, 0, 8)
+  OPCODE(resolvevirtualfunc, ResolveFuncNode, 0, 8)
+  // binary expression opcodes
+  OPCODE(add, BinaryNode, 0, 0)
+  OPCODE(sub, BinaryNode, 0, 0)
+  OPCODE(mul, BinaryNode, 0, 0)
+  OPCODE(div, BinaryNode, OPCODEMAYTHROWEXCEPTION, 0)
+  OPCODE(rem, BinaryNode, OPCODEMAYTHROWEXCEPTION, 0)
+  OPCODE(ashr, BinaryNode, 0, 0)
+  OPCODE(lshr, BinaryNode, 0, 0)
+  OPCODE(shl, BinaryNode, 0, 0)
+  OPCODE(ror, BinaryNode, 0, 0)
+  OPCODE(max, BinaryNode, 0, 0)
+  OPCODE(min, BinaryNode, 0, 0)
+  OPCODE(band, BinaryNode, 0, 0)
+  OPCODE(bior, BinaryNode, 0, 0)
+  OPCODE(bxor, BinaryNode, 0, 0)
+  OPCODE(CG_array_elem_add, BinaryNode, 0, 0)
+  OPCODE(eq, CompareNode, OPCODEISCOMPARE, 8)
+  OPCODE(ge, CompareNode, OPCODEISCOMPARE, 8)
+  OPCODE(gt, CompareNode, OPCODEISCOMPARE, 8)
+  OPCODE(le, CompareNode, OPCODEISCOMPARE, 8)
+  OPCODE(lt, CompareNode, OPCODEISCOMPARE, 8)
+  OPCODE(ne, CompareNode, OPCODEISCOMPARE, 8)
+  OPCODE(cmp, CompareNode, OPCODEISCOMPARE, 8)
+  OPCODE(cmpl, CompareNode, OPCODEISCOMPARE, 8)
+  OPCODE(cmpg, CompareNode, OPCODEISCOMPARE, 8)
+  OPCODE(land, BinaryNode, 0, 0)
+  OPCODE(lior, BinaryNode, 0, 0)
+  OPCODE(cand, BinaryNode, OPCODENOTMMPL, 0)
+  OPCODE(cior, BinaryNode, OPCODENOTMMPL, 0)
+  // ternary expression opcodes
+  OPCODE(select, TernaryNode, 0, 0)
+  // N-ary expression opcodes
+  OPCODE(intrinsicop, IntrinsicopNode, OPCODEISVARSIZE, 8)
+  OPCODE(intrinsicopwithtype, IntrinsicopNode, OPCODEISVARSIZE, 12)
+  // Other expression opcodes
+  OPCODE(extractbits, ExtractbitsNode, 0, 8)
+  OPCODE(depositbits, DepositbitsNode, 0, 8)
+  // storage access
+  OPCODE(iassignpcoff, IassignPCoffNode, OPCODEISSTMT, 0)
+  OPCODE(ireadpcoff, IreadPCoffNode, 0, 0)
+  // barrier
+  OPCODE(checkpoint, StmtNode, OPCODEISSTMT, 0)
+  // leaf node
+  OPCODE(addroffpc, AddroffPCNode, 0, 0)
+  OPCODE(igoto, UnaryStmtNode, OPCODEISSTMT, 0)
+  OPCODE(asm, AsmNode, (OPCODEISSTMT | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALLASSIGNED), 0)
+  OPCODE(dreadoff, dreadoffNode, OPCODEHASSSAUSE, 12)
+  OPCODE(addrofoff, addrofoffNode, 0, 12)
+  OPCODE(dassignoff, DassignoffNode, (OPCODEISSTMT | OPCODEHASSSADEF), 8)
+  OPCODE(iassignspoff, IassignFPoffNode, OPCODEISSTMT, 8)
+  OPCODE(blkassignoff, BlkassignoffNode, OPCODEISSTMT, 8)
+  OPCODE(icallproto, IcallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8)
+  OPCODE(icallprotoassigned, IcallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL | OPCODEISCALLASSIGNED), 8)
diff --git a/src/mapleall/maple_ir/include/opcodes.h b/src/mapleall/maple_ir/include/opcodes.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1186234a0da79e731816aaafe20c34b8911e77c
--- /dev/null
+++ b/src/mapleall/maple_ir/include/opcodes.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_OPCODES_H
+#define MAPLE_IR_INCLUDE_OPCODES_H
+#include "types_def.h"
+#include "mpl_logging.h"
+
+namespace maple {
+enum Opcode : uint8 {
+  OP_undef,
+#define OPCODE(STR, YY, ZZ, SS) OP_##STR,
+#include "opcodes.def"
+#undef OPCODE
+  OP_last,
+};
+
+#define CASE_OP_ASSERT_NONNULL \
+  case OP_assertnonnull:       \
+  case OP_assignassertnonnull: \
+  case OP_callassertnonnull:   \
+  case OP_returnassertnonnull:
+
+#define CASE_OP_ASSERT_BOUNDARY \
+  case OP_assertge:            \
+  case OP_assertlt:            \
+  case OP_calcassertge:        \
+  case OP_calcassertlt:        \
+  case OP_callassertle:        \
+  case OP_returnassertle:      \
+  case OP_assignassertle:
+
+inline constexpr bool IsDAssign(Opcode code) {
+  return (code == OP_dassign || code == OP_maydassign);
+}
+
+inline constexpr bool IsCallAssigned(Opcode code) {
+  return (code == OP_callassigned || code == OP_virtualcallassigned ||
+          code == OP_virtualicallassigned || code == OP_superclasscallassigned ||
+          code == OP_interfacecallassigned || code == OP_interfaceicallassigned ||
+          code == OP_customcallassigned || code == OP_polymorphiccallassigned ||
+          code == OP_icallassigned || code == OP_icallprotoassigned || code == OP_intrinsiccallassigned ||
+          code == OP_xintrinsiccallassigned || code == OP_intrinsiccallwithtypeassigned);
+}
+
+inline constexpr bool IsBranch(Opcode opcode) {
+  return (opcode == OP_goto || opcode == OP_brtrue || opcode == OP_brfalse || opcode == OP_switch ||
+          opcode == OP_igoto);
+}
+
+inline constexpr bool IsLogicalShift(Opcode opcode) {
+  return (opcode == OP_lshr || opcode == OP_shl);
+}
+
+constexpr bool IsCommutative(Opcode opcode) {
+  switch (opcode) {
+    case OP_add:
+    case OP_mul:
+    case OP_max:
+    case OP_min:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_eq:
+    case OP_ne:
+    case OP_land:
+    case OP_lior:
+      return true;
+    default:
+      return false;
+  }
+}
+
+constexpr bool IsStmtMustRequire(Opcode opcode) {
+  switch (opcode) {
+    case OP_jstry:
+    case OP_throw:
+    case OP_try:
+    case OP_catch:
+    case OP_jscatch:
+    case OP_finally:
+    case OP_endtry:
+    case OP_cleanuptry:
+    case OP_gosub:
+    case OP_retsub:
+    case OP_return:
+    case OP_call:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_icall:
+    case OP_icallassigned:
+    case OP_icallproto:
+    case OP_icallprotoassigned:
+    case OP_xintrinsiccall:
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned:
+    case OP_intrinsiccallwithtype:
+    case OP_intrinsiccallwithtypeassigned:
+    case OP_asm:
+    case OP_syncenter:
+    case OP_syncexit:
+    case OP_membaracquire:
+    case OP_membarrelease:
+    case OP_membarstoreload:
+    case OP_membarstorestore:
+    CASE_OP_ASSERT_NONNULL
+    CASE_OP_ASSERT_BOUNDARY
+    case OP_free:
+    case OP_incref:
+    case OP_decref:
+    case OP_decrefreset: {
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+// the result of these op is actually u1(may be set as other type, but its return value can only be zero or one)
+// different from kOpcodeInfo.IsCompare(op) : cmp/cmpg/cmpl have no reverse op, and may return -1/0/1
+constexpr bool IsCompareHasReverseOp(Opcode op) {
+  if (op == OP_eq || op == OP_ne || op == OP_ge || op == OP_gt || op == OP_le || op == OP_lt) {
+    return true;
+  }
+  return false;
+}
+
+constexpr Opcode GetSwapCmpOp(Opcode op) {
+  switch (op) {
+    case OP_eq:
+      return OP_eq;
+    case OP_ne:
+      return OP_ne;
+    case OP_ge:
+      return OP_le;
+    case OP_gt:
+      return OP_lt;
+    case OP_le:
+      return OP_ge;
+    case OP_lt:
+      return OP_gt;
+    default:
+      CHECK_FATAL(false, "can't swap op");
+      return op;
+  }
+}
+
+constexpr Opcode GetReverseCmpOp(Opcode op) {
+  switch (op) {
+    case OP_eq:
+      return OP_ne;
+    case OP_ne:
+      return OP_eq;
+    case OP_ge:
+      return OP_lt;
+    case OP_gt:
+      return OP_le;
+    case OP_le:
+      return OP_gt;
+    case OP_lt:
+      return OP_ge;
+    default:
+      CHECK_FATAL(false, "opcode has no reverse op");
+      return op;
+  }
+}
+
+constexpr bool IsSupportedOpForCopyInPhasesLoopUnrollAndVRP(Opcode op, bool supportSwitch = false) {
+  switch (op) {
+    case OP_return:
+    case OP_comment:
+    case OP_goto:
+    case OP_dassign:
+    case OP_regassign:
+    case OP_brfalse:
+    case OP_brtrue:
+    case OP_maydassign:
+    case OP_iassign:
+    CASE_OP_ASSERT_NONNULL
+    CASE_OP_ASSERT_BOUNDARY
+    case OP_call:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_interfaceicallassigned:
+    case OP_interfacecallassigned:
+    case OP_intrinsiccall:
+    case OP_intrinsiccallassigned:
+    case OP_intrinsiccallwithtype:
+    case OP_intrinsiccallwithtypeassigned:
+    case OP_membaracquire:
+    case OP_membarstorestore:
+    case OP_membarstoreload:
+    case OP_membarrelease:
+    case OP_icall:
+    case OP_icallassigned:
+    case OP_icallproto:
+    case OP_icallprotoassigned:
+    case OP_asm:
+    case OP_eval:
+    case OP_incref:
+    case OP_decref:
+    case OP_decrefreset:
+      return true;
+    case OP_switch:
+      return supportSwitch;
+    default:
+      return false;
+  }
+}
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_OPCODES_H
diff --git a/src/mapleall/maple_ir/include/option.h b/src/mapleall/maple_ir/include/option.h
new file mode 100644
index 0000000000000000000000000000000000000000..e31b36d0c5f11c10a0e43e84a77c71cd3d253c70
--- /dev/null
+++ b/src/mapleall/maple_ir/include/option.h
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_OPTION_H
+#define MAPLE_IR_INCLUDE_OPTION_H
+#include <string>
+#include <vector>
+
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "parser_opt.h"
+#include "types_def.h"
+
+namespace maple {
+class Options {
+ public:
+  static Options &GetInstance();
+
+  bool ParseOptions(int argc, char **argv, std::string &fileName) const;
+
+  bool SolveOptions(bool isDebug) const;
+  ~Options() = default;
+
+  void DumpOptions() const;
+  const std::vector<std::string> &GetSequence() const {
+    return phaseSeq;
+  }
+
+  std::string LastPhaseName() const {
+    return phaseSeq.empty() ? "noopt" : phaseSeq[phaseSeq.size() - 1];
+  }
+
+  enum Level {
+    kMpl2MplLevelZero = 0,
+    kMpl2MplLevelOne = 1,
+    kMpl2MplLevelTwo = 2
+  };
+  enum DecoupleLevel {
+    kNoDecouple = 0,
+    kConservativeDecouple = 1,
+    kAggressiveDecouple = 2,
+    kDecoupleAndLazy = 3
+  };
+
+  static bool DumpPhase(const std::string &phase) {
+    if (phase == "") {
+      return false;
+    }
+    return dumpPhase == "*" || dumpPhase == phase;
+  }
+
+  static bool IsSkipPhase(const std::string &phaseName) {
+    return skipPhase == phaseName;
+  }
+
+  static bool DumpFunc() {
+    return dumpFunc != "*" && dumpFunc != "";
+  }
+  static bool IsBigEndian() {
+    return bigEndian;
+  }
+
+  static bool dumpBefore;
+  static bool dumpAfter;
+  static std::string dumpPhase;
+  static std::string skipPhase;
+  static std::string skipFrom;
+  static std::string skipAfter;
+  static std::string dumpFunc;
+  static bool quiet;
+  static bool regNativeFunc;
+  static bool regNativeDynamicOnly;
+  static bool nativeWrapper;
+  static bool inlineWithProfile;
+  static bool useInline;
+  static bool enableIPAClone;
+  static bool enableGInline;
+  static std::string noInlineFuncList;
+  static std::string importFileList;
+  static bool useCrossModuleInline;
+  static uint32 numOfCloneVersions;
+  static uint32 numOfImpExprLowBound;
+  static uint32 numOfImpExprHighBound;
+  static uint32 numOfCallSiteLowBound;
+  static uint32 numOfCallSiteUpBound;
+  static uint32 numOfConstpropValue;
+  static uint32 inlineSmallFunctionThreshold;
+  static uint32 inlineHotFunctionThreshold;
+  static uint32 inlineRecursiveFunctionThreshold;
+  static uint32 inlineDepth;
+  static uint32 inlineModuleGrowth;
+  static uint32 inlineColdFunctionThreshold;
+  static bool respectAlwaysInline;
+  static bool inlineToAllCallers;
+  static uint32 ginlineMaxNondeclaredInlineCallee;
+  static bool ginlineAllowNondeclaredInlineSizeGrow;
+  static bool ginlineAllowIgnoreGrowthLimit;
+  static uint32 ginlineMaxDepthIgnoreGrowthLimit;
+  static uint32 ginlineSmallFunc;
+  static uint32 ginlineRelaxSmallFuncDecalredInline;
+  static uint32 ginlineRelaxSmallFuncCanbeRemoved;
+  static std::string callsiteProfilePath;
+
+  static uint32 profileHotCount;
+  static uint32 profileColdCount;
+  static bool profileHotCountSeted;
+  static bool profileColdCountSeted;
+  static uint32 profileHotRate;
+  static uint32 profileColdRate;
+  static std::string staticBindingList;
+  static bool usePreg;
+  static bool mapleLinker;
+  static bool dumpMuidFile;
+  static bool emitVtableImpl;
+#if MIR_JAVA
+  static bool skipVirtualMethod;
+#endif
+  // Ready to be deleted.
+  static bool noRC;
+  static bool analyzeCtor;
+  static bool strictNaiveRC;
+  static bool gcOnly;
+  static bool bigEndian;
+  static bool rcOpt1;
+  static std::string classMetaProFile;
+  static std::string methodMetaProfile;
+  static std::string fieldMetaProFile;
+  static std::string reflectStringProFile;
+  static bool nativeOpt;
+  static bool optForSize;
+  static bool O2;
+  static bool noDot;
+  static bool decoupleStatic;
+  static std::string criticalNativeFile;
+  static std::string fastNativeFile;
+  static bool barrier;
+  static std::string nativeFuncPropertyFile;
+  static bool mapleLinkerTransformLocal;
+  static uint32 buildApp;
+  static bool partialAot;
+  static uint32 decoupleInit;
+  static std::string sourceMuid;
+  static bool decoupleSuper;
+  static bool deferredVisit;
+  static bool deferredVisit2;
+  static bool genVtabAndItabForDecouple;
+  static bool profileFunc;
+  static uint32 parserOpt;
+  static std::string dumpDevirtualList;
+  static std::string readDevirtualList;
+  static bool usePreloadedClass;
+  static std::string profile;
+  static bool profileGen;
+  static bool profileUse;
+  static bool stackProtectorStrong;
+  static bool stackProtectorAll;
+  static std::string appPackageName;
+  static std::string proFileData;
+  static std::string proFileFuncData;
+  static std::string proFileClassData;
+  static bool profileStaticFields;
+  static bool genIRProfile;
+  static bool profileTest;
+  static std::string classLoaderInvocationList;
+  static bool dumpClassLoaderInvocation;
+  static unsigned int warningLevel;
+  static bool lazyBinding;
+  static bool hotFix;
+  static bool compactMeta;
+  static bool genPGOReport;
+  static bool verify;
+  static uint32 inlineCache;
+  static bool checkArrayStore;
+  static bool noComment;
+  static bool rmNoUseFunc;
+  static bool sideEffect;
+  static bool dumpIPA;
+  static bool wpaa;
+  static bool genLMBC;
+  static bool doOutline;
+  static size_t outlineThreshold;
+
+ private:
+  void DecideMpl2MplRealLevel() const;
+  std::vector<std::string> phaseSeq;
+};
+}  // namespace maple
+#ifndef TRACE_PHASE
+#define TRACE_PHASE (Options::dumpPhase.compare(PhaseName()) == 0)
+#endif
+
+#ifndef TRACE_MAPLE_PHASE
+#define TRACE_MAPLE_PHASE (Options::dumpPhase.compare(PhaseName()) == 0)
+#endif
+#endif  // MAPLE_IR_INCLUDE_OPTION_H
diff --git a/src/mapleall/maple_ir/include/parser_opt.h b/src/mapleall/maple_ir/include/parser_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa470b82d0a8932d93e9ab57b8cf2122e64fb1d6
--- /dev/null
+++ b/src/mapleall/maple_ir/include/parser_opt.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_PARSER_OPT_H
+#define MAPLE_IR_INCLUDE_PARSER_OPT_H
+#include "types_def.h"
+
+namespace maple {
+// option bits passed into ParseMIR
+enum ParserOptions : uint8 {
+  kInvalidOption = 0x0,
+  kWithDbgInfo = 0x1,    // collect dbginfo
+  kKeepFirst = 0x2,    // ignore second type def, not emit error
+  kWithProfileInfo = 0x4,
+  kParseOptFunc = 0x08,    // parse optimized function mpl file
+  kParseInlineFuncBody = 0x10    // parse to-be-inlined function bodies
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_PARSER_OPT_H
diff --git a/src/mapleall/maple_ir/include/prim_types.def b/src/mapleall/maple_ir/include/prim_types.def
new file mode 100644
index 0000000000000000000000000000000000000000..09f95fa2fbfe5cb50284f6ffdabd72513426b607
--- /dev/null
+++ b/src/mapleall/maple_ir/include/prim_types.def
@@ -0,0 +1,490 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifdef LOAD_ALGO_PRIMARY_TYPE
+#undef LOAD_ALGO_PRIMARY_TYPE
+// NOTE: this ordering needs to be in sync with ptypesizetable[] in maplevm/src/vmfunc.cpp
+  PRIMTYPE(void)
+  PRIMTYPE(i8)
+  PRIMTYPE(i16)
+  PRIMTYPE(i32)
+  PRIMTYPE(i64)
+  PRIMTYPE(i128)
+  PRIMTYPE(u8)
+  PRIMTYPE(u16)
+  PRIMTYPE(u32)
+  PRIMTYPE(u64)
+  PRIMTYPE(u128)
+  PRIMTYPE(u1)
+  PRIMTYPE(ptr)
+  PRIMTYPE(ref)
+  PRIMTYPE(a32)
+  PRIMTYPE(a64)
+  PRIMTYPE(f32)
+  PRIMTYPE(f64)
+  PRIMTYPE(f128)
+  PRIMTYPE(c64)
+  PRIMTYPE(c128)
+#ifdef DYNAMICLANG
+  PRIMTYPE(simplestr)
+  PRIMTYPE(simpleobj)
+  PRIMTYPE(dynany)
+  PRIMTYPE(dynundef)
+  PRIMTYPE(dynnull)
+  PRIMTYPE(dynbool)
+  PRIMTYPE(dyni32)
+  PRIMTYPE(dynstr)
+  PRIMTYPE(dynobj)
+  PRIMTYPE(dynf64)
+  PRIMTYPE(dynf32)
+  PRIMTYPE(dynnone)
+#endif
+  PRIMTYPE(constStr)
+  PRIMTYPE(gen)
+  PRIMTYPE(agg)
+  PRIMTYPE(v2i64)
+  PRIMTYPE(v4i32)
+  PRIMTYPE(v8i16)
+  PRIMTYPE(v16i8)
+  PRIMTYPE(v2u64)
+  PRIMTYPE(v4u32)
+  PRIMTYPE(v8u16)
+  PRIMTYPE(v16u8)
+  PRIMTYPE(v2f64)
+  PRIMTYPE(v4f32)
+  PRIMTYPE(v2i32)
+  PRIMTYPE(v4i16)
+  PRIMTYPE(v8i8)
+  PRIMTYPE(v2u32)
+  PRIMTYPE(v4u16)
+  PRIMTYPE(v8u8)
+  PRIMTYPE(v2f32)
+  PRIMTYPE(reservedpty1)
+  PRIMTYPE(reservedpty2)
+  PRIMTYPE(reservedpty3)
+  PRIMTYPE(reservedpty4)
+  PRIMTYPE(reservedpty5)
+  PRIMTYPE(reservedpty6)
+  PRIMTYPE(reservedpty7)
+  PRIMTYPE(reservedpty8)
+  PRIMTYPE(reservedpty9)
+  PRIMTYPE(reservedpty10)
+  PRIMTYPE(unknown)
+#endif // ~LOAD_ALGO_PRIMARY_TYPE
+
+
+#ifdef LOAD_PRIMARY_TYPE_PROPERTY
+#undef LOAD_PRIMARY_TYPE_PROPERTY
+
+static const PrimitiveTypeProperty PTProperty_begin = {
+  /*type=*/PTY_begin, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_void = {
+  /*type=*/PTY_void, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_i8 = {
+  /*type=*/PTY_i8, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_i16 = {
+  /*type=*/PTY_i16, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_i32 = {
+  /*type=*/PTY_i32, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_i64 = {
+  /*type=*/PTY_i64, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_i128 = {
+  /*type=*/PTY_i128, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_u8 = {
+  /*type=*/PTY_u8, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_u16 = {
+  /*type=*/PTY_u16, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+/* isAddress and isPointer are overloaded in getter method for PTProperty_u32 */
+static const PrimitiveTypeProperty PTProperty_u32 = {
+  /*type=*/PTY_u32, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+/* isAddress and isPointer are overloaded in getter method for PTProperty_64 */
+static const PrimitiveTypeProperty PTProperty_u64 = {
+  /*type=*/PTY_u64, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/true, /*isFloat=*/false,
+  /*isPointer=*/true, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_u128 = {
+  /*type=*/PTY_u128, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_u1 = {
+  /*type=*/PTY_u1, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_ptr = {
+  /*type=*/PTY_ptr, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/true, /*isFloat=*/false,
+  /*isPointer=*/true, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_ref = {
+  /*type=*/PTY_ref, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/true, /*isFloat=*/false,
+  /*isPointer=*/true, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_a32 = {
+  /*type=*/PTY_a32, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/true, /*isFloat=*/false,
+  /*isPointer=*/true, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_a64 = {
+  /*type=*/PTY_a64, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/true, /*isFloat=*/false,
+  /*isPointer=*/true, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_f32 = {
+  /*type=*/PTY_f32, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/true,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_f64 = {
+  /*type=*/PTY_f64, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/true,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_f128 = {
+  /*type=*/PTY_f128, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/true,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_c64 = {
+  /*type=*/PTY_c64, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_c128 = {
+  /*type=*/PTY_c128, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+#ifdef DYNAMICLANG
+static const PrimitiveTypeProperty PTProperty_simplestr = {
+  /*type=*/PTY_simplestr, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/true, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/true, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_simpleobj = {
+  /*type=*/PTY_simpleobj, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/true, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/true, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dynany = {
+  /*type=*/PTY_dynany, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/true, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dynundef = {
+  /*type=*/PTY_dynundef, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dynnull = {
+  /*type=*/PTY_dynnull, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dynbool = {
+  /*type=*/PTY_dynbool, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dyni32 = {
+  /*type=*/PTY_dyni32, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dynstr = {
+  /*type=*/PTY_dynstr, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dynobj = {
+  /*type=*/PTY_dynobj, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dynf64 = {
+  /*type=*/PTY_dynf64, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/true,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dynf32 = {
+  /*type=*/PTY_dynf32, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/true,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_dynnone = {
+  /*type=*/PTY_dynnone, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/true, /*isDynamicAny=*/false, /*isDynamicNone=*/true,
+  /*isVector*/false
+};
+#endif // ~DYNAMICLANG
+
+static const PrimitiveTypeProperty PTProperty_constStr = {
+  /*type=*/PTY_constStr, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/true, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_gen = {
+  /*type=*/PTY_gen, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_agg = {
+  /*type=*/PTY_agg, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_v2i64 = {
+  /*type=*/PTY_v2i64, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v4i32 = {
+  /*type=*/PTY_v4i32, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v8i16 = {
+  /*type=*/PTY_v8i16, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v16i8 = {
+  /*type=*/PTY_v16i8, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v2u64 = {
+  /*type=*/PTY_v2u64, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v4u32 = {
+  /*type=*/PTY_v4u32, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v8u16 = {
+  /*type=*/PTY_v8u16, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v16u8 = {
+  /*type=*/PTY_v16u8, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v2f64 = {
+  /*type=*/PTY_v2f64, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/true,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v4f32 = {
+  /*type=*/PTY_v4f32, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/true,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v2i32 = {
+  /*type=*/PTY_v2i32, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v4i16 = {
+  /*type=*/PTY_v4i16, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v8i8 = {
+  /*type=*/PTY_v8i8, /*isInteger=*/true, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v2u32 = {
+  /*type=*/PTY_v2u32, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v4u16 = {
+  /*type=*/PTY_v4u16, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v8u8 = {
+  /*type=*/PTY_v8u8, /*isInteger=*/true, /*isUnsigned=*/true, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_v2f32 = {
+  /*type=*/PTY_v2f32, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/true,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty1 = {
+  /*type=*/PTY_reservedpty1, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty2 = {
+  /*type=*/PTY_reservedpty2, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty3 = {
+  /*type=*/PTY_reservedpty3, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty4 = {
+  /*type=*/PTY_reservedpty4, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty5 = {
+  /*type=*/PTY_reservedpty5, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty6 = {
+  /*type=*/PTY_reservedpty6, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty7 = {
+  /*type=*/PTY_reservedpty7, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty8 = {
+  /*type=*/PTY_reservedpty8, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty9 = {
+  /*type=*/PTY_reservedpty9, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_reservedpty10 = {
+  /*type=*/PTY_reservedpty10, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_unknown = {
+  /*type=*/PTY_unknown, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/false
+};
+
+static const PrimitiveTypeProperty PTProperty_end = {
+  /*type=*/PTY_end, /*isInteger=*/false, /*isUnsigned=*/false, /*isAddress=*/false, /*isFloat=*/false,
+  /*isPointer=*/false, /*isSimple=*/false, /*isDynamic=*/false, /*isDynamicAny=*/false, /*isDynamicNone=*/false,
+  /*isVector*/true
+};
+
+#endif // ~LOAD_PRIMARY_TYPE_PROPERTY
diff --git a/src/mapleall/maple_ir/include/prim_types.h b/src/mapleall/maple_ir/include/prim_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5cb29bbc7a1665c38ed350d45457be19b408acd
--- /dev/null
+++ b/src/mapleall/maple_ir/include/prim_types.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_PRIM_TYPES_H
+#define MAPLE_IR_INCLUDE_PRIM_TYPES_H
+#include "types_def.h"
+#include "cfg_primitive_types.h"
+
+namespace maple {
+class PrimitiveType {
+ public:
+  explicit PrimitiveType(PrimType type) : property(GetPrimitiveTypeProperty(type)) {}
+  ~PrimitiveType() = default;
+
+  PrimType GetType() const {
+    return property.type;
+  }
+
+  bool IsInteger() const {
+    return property.IsInteger();
+  }
+  bool IsUnsigned() const {
+    return property.IsUnsigned();
+  }
+  bool IsAddress() const {
+    return property.IsAddress();
+  }
+  bool IsFloat() const {
+    return property.IsFloat();
+  }
+  bool IsPointer() const {
+    return property.IsPointer();
+  }
+  bool IsDynamic() const {
+    return property.IsDynamic();
+  }
+  bool IsSimple() const {
+    return property.IsSimple();
+  }
+  bool IsDynamicAny() const {
+    return property.IsDynamicAny();
+  }
+  bool IsDynamicNone() const {
+    return property.IsDynamicNone();
+  }
+  bool IsVector() const {
+    return property.IsVector();
+  }
+
+ private:
+  const PrimitiveTypeProperty &property;
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_PRIM_TYPES_H
diff --git a/src/mapleall/maple_ir/include/printing.h b/src/mapleall/maple_ir/include/printing.h
new file mode 100644
index 0000000000000000000000000000000000000000..305932b74732e6c3ace2a2df665d169b65d216e5
--- /dev/null
+++ b/src/mapleall/maple_ir/include/printing.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_PRINTING_H
+#define MAPLE_IR_INCLUDE_PRINTING_H
+#include <string>
+#include "types_def.h"
+
+namespace maple {
+void PrintIndentation(int32 indent);
+void PrintString(const std::string &str);
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_PRINTING_H
diff --git a/src/mapleall/maple_ir/include/simplifyintrinsics.def b/src/mapleall/maple_ir/include/simplifyintrinsics.def
new file mode 100644
index 0000000000000000000000000000000000000000..f6078c25fb2e7d2bbf5a742d020d0b6c3899c79b
--- /dev/null
+++ b/src/mapleall/maple_ir/include/simplifyintrinsics.def
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+/* INTRINSIC(STR, NAME) */
+DEF_MIR_INTRINSIC(GET_AND_ADDI, "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndAddInt_7C_28Ljava_2Flang_2FObject_3BJI_29I",\
+                  DEFAULT_NUM_INSN, INTRNISJAVA | INTRNISSPECIAL, kArgTyI32, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI32)
+DEF_MIR_INTRINSIC(GET_AND_ADDL, "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndAddLong_7C_28Ljava_2Flang_2FObject_3BJJ_29J",\
+                  DEFAULT_NUM_INSN, INTRNISJAVA | INTRNISSPECIAL, kArgTyI64, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI64)
+DEF_MIR_INTRINSIC(GET_AND_SETI, "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndSetInt_7C_28Ljava_2Flang_2FObject_3BJI_29I",\
+                  DEFAULT_NUM_INSN, INTRNISJAVA | INTRNISSPECIAL, kArgTyI32, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI32)
+DEF_MIR_INTRINSIC(GET_AND_SETL, "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndSetLong_7C_28Ljava_2Flang_2FObject_3BJJ_29J",\
+                  DEFAULT_NUM_INSN, INTRNISJAVA | INTRNISSPECIAL, kArgTyI64, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI64)
+DEF_MIR_INTRINSIC(COMP_AND_SWAPI, "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapInt_7C_28Ljava_2Flang_2FObject_3BJII_29Z",\
+                  DEFAULT_NUM_INSN, INTRNISJAVA | INTRNISSPECIAL, kArgTyU1, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI32, kArgTyI32)
+DEF_MIR_INTRINSIC(COMP_AND_SWAPL, "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapLong_7C_28Ljava_2Flang_2FObject_3BJJJ_29Z",\
+                  DEFAULT_NUM_INSN, INTRNISJAVA | INTRNISSPECIAL, kArgTyU1, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI64, kArgTyI64)
+DEF_MIR_INTRINSIC(STR_INDEXOF, "Ljava_2Flang_2FString_3B_7CindexOf_7C_28Ljava_2Flang_2FString_3B_29I",\
+                  DEFAULT_NUM_INSN, INTRNISJAVA | INTRNISSPECIAL, kArgTyI32, kArgTyRef, kArgTyRef)
+
diff --git a/src/mapleall/maple_ir/include/src_position.h b/src/mapleall/maple_ir/include/src_position.h
new file mode 100644
index 0000000000000000000000000000000000000000..49804960bba4f8f24c545f6d98689949d61925d7
--- /dev/null
+++ b/src/mapleall/maple_ir/include/src_position.h
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_SRC_POSITION_H
+#define MAPLE_IR_INCLUDE_SRC_POSITION_H
+#include "mpl_logging.h"
+
+namespace maple {
+// to store source position information
+class SrcPosition {
+ public:
+  SrcPosition() : lineNum(0), mplLineNum(0) {
+    u.fileColumn.fileNum = 0;
+    u.fileColumn.column = 0;
+    u.word0 = 0;
+  }
+  SrcPosition(uint16 fnum, uint32 lnum, uint16 cnum, uint32 mlnum)
+      : lineNum(lnum),
+        mplLineNum(mlnum) {
+    u.fileColumn.fileNum = fnum;
+    u.fileColumn.column = cnum;
+  }
+
+  virtual ~SrcPosition() = default;
+
+  uint32 RawData() const {
+    return u.word0;
+  }
+
+  uint16 FileNum() const {
+    return u.fileColumn.fileNum;
+  }
+
+  uint16 Column() const {
+    return u.fileColumn.column;
+  }
+
+  uint32 LineNum() const {
+    return lineNum;
+  }
+
+  uint32 MplLineNum() const {
+    return mplLineNum;
+  }
+
+  void SetFileNum(uint16 n) {
+    u.fileColumn.fileNum = n;
+  }
+
+  void SetColumn(uint16 n) {
+    u.fileColumn.column = n;
+  }
+
+  void SetLineNum(uint32 n) {
+    lineNum = n;
+  }
+
+  void SetRawData(uint32 n) {
+    u.word0 = n;
+  }
+
+  void SetMplLineNum(uint32 n) {
+    mplLineNum = n;
+  }
+
+  void CondSetLineNum(uint32 n) {
+    lineNum = lineNum != 0 ? lineNum : n;
+  }
+
+  void CondSetFileNum(uint16 n) {
+    uint16 i = u.fileColumn.fileNum;
+    u.fileColumn.fileNum = i != 0 ? i : n;
+  }
+
+  void UpdateWith(const SrcPosition pos) {
+    u.fileColumn.fileNum = pos.FileNum();
+    u.fileColumn.column = pos.Column();
+    lineNum = pos.LineNum();
+    mplLineNum = pos.MplLineNum();
+  }
+
+  bool IsSameFile(const SrcPosition &pos) const {
+    return pos.FileNum() == FileNum();
+  }
+
+  // as you read: pos0->IsBf(pos) "pos0 Is Before pos"
+  bool IsBf(const SrcPosition &pos) const {
+    return (pos.FileNum() == FileNum() &&
+           ((LineNum() < pos.LineNum()) ||
+            ((LineNum() == pos.LineNum()) && (Column() < pos.Column()))));
+  }
+
+  bool IsBfMpl(const SrcPosition &pos) const {
+    return (pos.FileNum() == FileNum() &&
+           ((MplLineNum() < pos.MplLineNum()) ||
+            ((MplLineNum() == pos.MplLineNum()) && (Column() < pos.Column()))));
+  }
+
+  bool IsEq(const SrcPosition &pos) const {
+    return FileNum() == pos.FileNum() && LineNum() == pos.LineNum() && Column() == pos.Column();
+  }
+
+  bool IsBfOrEq(const SrcPosition &pos) const {
+    return IsBf(pos) || IsEq(pos);
+  }
+
+  bool IsEqMpl(const SrcPosition &pos) const {
+    return MplLineNum() == pos.MplLineNum();
+  }
+
+  bool IsValid() const {
+    return FileNum() != 0;
+  }
+
+  void DumpLoc(uint32 &lastLineNum, uint16 &lastColumnNum) const {
+    if (FileNum() != 0 && LineNum() != 0) {
+      if (Column() != 0 && (LineNum() != lastLineNum || Column() != lastColumnNum)) {
+        Dump();
+        lastLineNum = LineNum();
+        lastColumnNum = Column();
+      } else if (LineNum() != lastLineNum) {
+        DumpLine();
+        lastLineNum = LineNum();
+      }
+    }
+  }
+
+  void DumpLine() const {
+    LogInfo::MapleLogger() << "LOC " << FileNum() << " " << LineNum() << '\n';
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << "LOC " << FileNum() << " " << LineNum() << " " << Column() << '\n';
+  }
+
+  std::string DumpLocWithColToString() const {
+    std::stringstream ss;
+    ss << "LOC " << FileNum() << " " << LineNum() << " " << Column();
+    return ss.str();
+  }
+
+  Loc GetSrcLoc() const {
+    Loc loc(static_cast<uint32>(FileNum()), static_cast<uint32>(LineNum()), static_cast<uint32>(Column()));
+    return loc;
+  }
+
+  void SetInlinedLineNum(uint32 line) {
+    inlinedLineNum = line;
+  }
+
+  void SetInlinedFileNum(uint32 line) {
+    inlinedFileNum = line;
+  }
+
+  void SetInlinedFuncStrIdx(const GStrIdx &idx) {
+    strIdx = idx;
+  }
+
+  uint32 GetInlinedLineNum() const {
+    return inlinedLineNum;
+  }
+
+  uint32 GetInlinedFileNum() const {
+    return inlinedFileNum;
+  }
+
+  const GStrIdx &GetInlinedFuncStrIdx() const {
+    return strIdx;
+  }
+
+ private:
+  union {
+    struct {
+      uint16 fileNum;
+      uint16 column : 12;
+      uint16 stmtBegin : 1;
+      uint16 bbBegin : 1;
+      uint16 unused : 2;
+    } fileColumn;
+    uint32 word0;
+  } u;
+  uint32 lineNum;     // line number of original src file, like foo.java
+  uint32 mplLineNum;  // line number of mpl file
+  uint32 inlinedLineNum = 0;
+  uint32 inlinedFileNum = 0;
+  GStrIdx strIdx;
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_SRC_POSITION_H
diff --git a/src/mapleall/maple_ir/include/tokens.h b/src/mapleall/maple_ir/include/tokens.h
new file mode 100644
index 0000000000000000000000000000000000000000..f78767e13b7191c58815a085a0e9d38f4d4ab251
--- /dev/null
+++ b/src/mapleall/maple_ir/include/tokens.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_TOKENS_H
+#define MAPLE_IR_INCLUDE_TOKENS_H
+
+namespace maple {
+enum TokenKind {
+  TK_invalid,
+// keywords from this file
+#define KEYWORD(STR) TK_##STR,
+#include "keywords.def"
+#undef KEYWORD
+  // non-keywords starting here
+  // constants
+  TK_intconst,
+  TK_floatconst,
+  TK_doubleconst,
+  // local name
+  TK_lname,
+  // global name
+  TK_gname,
+  // function name
+  TK_fname,
+  // pseudo register
+  TK_preg,
+  // special register
+  TK_specialreg,
+  // parent field
+  TK_prntfield,
+  // type parameter name
+  TK_typeparam,
+  // misc.
+  TK_newline,
+  TK_lparen,     // (
+  TK_rparen,     // )
+  TK_lbrace,     // {
+  TK_rbrace,     // }
+  TK_lbrack,     // [
+  TK_rbrack,     // ]
+  TK_langle,     // <
+  TK_rangle,     // >
+  TK_eqsign,     // =
+  TK_coma,       // ,
+  TK_dotdotdot,  // ...
+  TK_colon,      // :
+  TK_asterisk,   // *
+  TK_string,     // a literal string enclosed between "
+  TK_eof
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_TOKENS_H
diff --git a/src/mapleall/maple_ir/include/types_def.h b/src/mapleall/maple_ir/include/types_def.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa5f01ade2afd3bbc4272ecf4e21c636cd15393d
--- /dev/null
+++ b/src/mapleall/maple_ir/include/types_def.h
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_IR_INCLUDE_TYPES_DEF_H
+#define MAPLE_IR_INCLUDE_TYPES_DEF_H
+
+// NOTE: Since we already committed to -std=c++0x, we should eventually use the
+// standard definitions in the <cstdint> and <limits> headers rather than
+// reinventing our own primitive types.
+#include <cstdint>
+#include <cstddef>
+#include <functional>
+#include "mpl_number.h"
+
+namespace maple {
+// Let's keep the following definitions so that existing code will continue to work.
+using int8 = std::int8_t;
+using int16 = std::int16_t;
+using int32 = std::int32_t;
+using int64 = std::int64_t;
+using uint8 = std::uint8_t;
+using uint16 = std::uint16_t;
+using uint32 = std::uint32_t;
+using uint64 = std::uint64_t;
+class StIdx {  // scope nesting level + symbol table index
+ public:
+  union un {
+    struct {
+      uint32 idx : 24;
+      uint8 scope;  // scope level, with the global scope is at level 1
+    } scopeIdx;
+
+    uint32 fullIdx;
+  };
+
+  StIdx() {
+    u.fullIdx = 0;
+  }
+
+  StIdx(uint32 level, uint32 i) {
+    u.scopeIdx.scope = level;
+    u.scopeIdx.idx = i;
+  }
+
+  explicit StIdx(uint32 fidx) {
+    u.fullIdx = fidx;
+  }
+
+  ~StIdx() = default;
+
+  uint32 Idx() const {
+    return u.scopeIdx.idx;
+  }
+
+  void SetIdx(uint32 idx) {
+    u.scopeIdx.idx = idx;
+  }
+
+  uint32 Scope() const {
+    return u.scopeIdx.scope;
+  }
+
+  void SetScope(uint32 scpe) {
+    u.scopeIdx.scope = static_cast<uint8>(scpe);
+  }
+
+  uint32 FullIdx() const {
+    return u.fullIdx;
+  }
+
+  void SetFullIdx(uint32 idx) {
+    u.fullIdx = idx;
+  }
+
+  bool Islocal() const {
+    return u.scopeIdx.scope > 1;
+  }
+
+  bool IsGlobal() const {
+    return u.scopeIdx.scope == 1;
+  }
+
+  bool operator==(const StIdx &x) const {
+    return u.fullIdx == x.u.fullIdx;
+  }
+
+  bool operator!=(const StIdx &x) const {
+    return !(*this == x);
+  }
+
+  bool operator<(const StIdx &x) const {
+    return u.fullIdx < x.u.fullIdx;
+  }
+
+ private:
+  un u;
+};
+
+using LabelIdx = uint32;
+using phyRegIdx = uint64;
+using OfstRegIdx = uint64;
+using LabelIDOrder = uint32;
+using PUIdx = uint32;
+using PregIdx = int32;
+using ExprIdx = int32;
+using FieldID = int32;
+
+class TypeTag;
+using TyIdx = utils::Index<TypeTag, uint32>;        // global type table index
+
+class GStrTag;
+using GStrIdx = utils::Index<GStrTag, uint32>;      // global string table index
+
+class UStrTag;
+using UStrIdx = utils::Index<UStrTag, uint32>;      // user string table index (from the conststr opcode)
+
+class U16StrTag;
+using U16StrIdx = utils::Index<U16StrTag, uint32>;  // user string table index (from the conststr opcode)
+
+const TyIdx kInitTyIdx = TyIdx(0);
+const TyIdx kNoneTyIdx = TyIdx(UINT32_MAX);
+
+enum SSALevel : uint8 {
+  kSSAInvalid = 0x00,
+  kSSATopLevel = 0x01,                          // ssa only for local top-level is valid
+  kSSAAddrTaken = 0x02,                         // ssa only for addr-taken is valid
+  kSSAMemory = kSSATopLevel | kSSAAddrTaken,    // ssa for both top-level and addr-taken is valid
+  kSSAHSSA = 0x04,                              // hssa is valid
+};
+
+constexpr uint8 kOperandNumUnary = 1;
+constexpr uint8 kOperandNumBinary = 2;
+constexpr uint8 kOperandNumTernary = 3;
+}  // namespace maple
+namespace std {
+template<> // function-template-specialization
+class hash<maple::StIdx> {
+ public:
+  size_t operator()(const maple::StIdx &x) const {
+    std::size_t seed = 0;
+    hash_combine(seed, x.Scope());
+    hash_combine(seed, x.Idx());
+    return seed;
+  }
+};
+}
+#endif  // MAPLE_IR_INCLUDE_TYPES_DEF_H
diff --git a/src/mapleall/maple_ir/include/unary_op.def b/src/mapleall/maple_ir/include/unary_op.def
new file mode 100644
index 0000000000000000000000000000000000000000..7c7b072e1c4d86b6fa8e5a48320f2fb7592d09bf
--- /dev/null
+++ b/src/mapleall/maple_ir/include/unary_op.def
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+UNARYOP(abs)
+UNARYOP(bnot)
+UNARYOP(lnot)
+UNARYOP(neg)
+UNARYOP(recip)
+UNARYOP(sqrt)
+UNARYOP(sext)
+UNARYOP(zext)
+UNARYOP(extractbits)
+UNARYOP(alloca)
+UNARYOP(malloc)
+UNARYOP(gcmallocjarray)
+UNARYOP(gcpermallocjarray)
diff --git a/src/mapleall/maple_ir/include/verification.h b/src/mapleall/maple_ir/include/verification.h
new file mode 100644
index 0000000000000000000000000000000000000000..3c0c3eff813f5c1d566bbe389455942e8f623535
--- /dev/null
+++ b/src/mapleall/maple_ir/include/verification.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEIR_VERIFICATION_PHASE_H
+#define MAPLEIR_VERIFICATION_PHASE_H
+#include "class_hierarchy.h"
+#include "verify_pragma_info.h"
+
+namespace maple {
+using ClassVerifyPragmas = MapleUnorderedMap<std::string, std::vector<const VerifyPragmaInfo*>>;
+
+class VerifyResult {
+ public:
+  VerifyResult(const MIRModule &module, const KlassHierarchy &klassHierarchy, MemPool &memPool)
+      : module(module),
+        klassHierarchy(klassHierarchy),
+        allocator(&memPool),
+        classesCorrectness(allocator.Adapter()),
+        classesPragma(allocator.Adapter()) {}
+
+  ~VerifyResult() = default;
+
+  const KlassHierarchy &GetKlassHierarchy() const {
+    return klassHierarchy;
+  }
+
+  const MIRModule &GetMIRModule() const {
+    return module;
+  }
+
+  const MIRFunction *GetCurrentFunction() const {
+    return module.GetFunctionList().front();
+  }
+
+  const std::string &GetCurrentClassName() const {
+    return GetCurrentFunction()->GetClassType()->GetName();
+  }
+
+  const ClassVerifyPragmas &GetDeferredClassesPragma() const {
+    return classesPragma;
+  }
+
+  void AddPragmaVerifyError(const std::string &className, std::string errMsg);
+  void AddPragmaAssignableCheck(const std::string &className, std::string fromType, std::string toType);
+  void AddPragmaExtendFinalCheck(const std::string &className);
+  void AddPragmaOverrideFinalCheck(const std::string &className);
+
+  const MapleUnorderedMap<std::string, bool> &GetResultMap() const {
+    return classesCorrectness;
+  }
+  void SetClassCorrectness(const std::string &className, bool result) {
+    classesCorrectness[className] = result;
+  }
+
+  bool HasErrorNotDeferred() const {
+    for (auto &classResult : classesCorrectness) {
+      if (!classResult.second) {
+        if (classesPragma.find(classResult.first) == classesPragma.end()) {
+          // Verify result is not OK, but has no deferred check or verify error in runtime
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+ private:
+  bool HasVerifyError(const std::vector<const VerifyPragmaInfo*> &pragmaInfoPtrVec) const;
+  bool HasSamePragmaInfo(const std::vector<const VerifyPragmaInfo*> &pragmaInfoPtrVec,
+                         const VerifyPragmaInfo &verifyPragmaInfo) const;
+
+  const MIRModule &module;
+  const KlassHierarchy &klassHierarchy;
+  MapleAllocator allocator;
+  // classesCorrectness<key: className, value: correctness>, correctness is true only if the class is verified OK
+  MapleUnorderedMap<std::string, bool> classesCorrectness;
+  // classesPragma<key: className, value: PragmaInfo for deferred check>
+  ClassVerifyPragmas classesPragma;
+};
+
+class VerificationPhaseResult : public AnalysisResult {
+ public:
+  VerificationPhaseResult(MemPool &mp, const VerifyResult &verifyResult)
+      : AnalysisResult(&mp), verifyResult(verifyResult) {}
+  ~VerificationPhaseResult() = default;
+
+  const ClassVerifyPragmas &GetDeferredClassesPragma() const {
+    return verifyResult.GetDeferredClassesPragma();
+  }
+
+ private:
+  const VerifyResult &verifyResult;
+};
+
+#ifdef NOT_USED
+class DoVerification : public ModulePhase {
+ public:
+  explicit DoVerification(ModulePhaseID id) : ModulePhase(id) {}
+
+  AnalysisResult *Run(MIRModule *module, ModuleResultMgr *mgr) override;
+  std::string PhaseName() const override {
+    return "verification";
+  }
+
+  ~DoVerification() = default;
+
+ private:
+  void VerifyModule(MIRModule &module, VerifyResult &result) const;
+  void DeferredCheckFinalClassAndMethod(VerifyResult &result) const;
+  bool IsLazyBindingOrDecouple(const KlassHierarchy &klassHierarchy) const;
+  bool NeedRuntimeFinalCheck(const KlassHierarchy &klassHierarchy, const std::string &className) const;
+  void CheckExtendFinalClass(VerifyResult &result) const;
+};
+#endif
+}  // namespace maple
+#endif  // MAPLEIR_VERIFICATION_PHASE_H
diff --git a/src/mapleall/maple_ir/include/verify_annotation.h b/src/mapleall/maple_ir/include/verify_annotation.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac19180d4801351b8255db63885113742cecda2a
--- /dev/null
+++ b/src/mapleall/maple_ir/include/verify_annotation.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEIR_VERIFY_ANNOTATION_H
+#define MAPLEIR_VERIFY_ANNOTATION_H
+#include "mir_module.h"
+#include "mir_type.h"
+#include "verify_pragma_info.h"
+
+namespace maple {
+void AddVerfAnnoThrowVerifyError(MIRModule &md, const ThrowVerifyErrorPragma &info, MIRStructType &clsType);
+void AddVerfAnnoAssignableCheck(MIRModule &md,
+                                std::vector<const AssignableCheckPragma*> &info,
+                                MIRStructType &clsType);
+void AddVerfAnnoExtendFinalCheck(MIRModule &md, MIRStructType &clsType);
+void AddVerfAnnoOverrideFinalCheck(MIRModule &md, MIRStructType &clsType);
+} // namespace maple
+#endif // MAPLEALL_VERIFY_ANNOTATION_H
\ No newline at end of file
diff --git a/src/mapleall/maple_ir/include/verify_mark.h b/src/mapleall/maple_ir/include/verify_mark.h
new file mode 100644
index 0000000000000000000000000000000000000000..6fb72a498e3f0cb0b53c52faf056f53e526d8c72
--- /dev/null
+++ b/src/mapleall/maple_ir/include/verify_mark.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEALL_VERIFY_MARK_H
+#define MAPLEALL_VERIFY_MARK_H
+#include "class_hierarchy.h"
+#include "verify_pragma_info.h"
+
+namespace maple {
+#ifdef NOT_USED
+class DoVerifyMark : public ModulePhase {
+ public:
+  explicit DoVerifyMark(ModulePhaseID id) : ModulePhase(id) {}
+
+  AnalysisResult *Run(MIRModule *module, ModuleResultMgr *mgr) override;
+
+  std::string PhaseName() const override {
+    return "verifymark";
+  }
+
+  ~DoVerifyMark() override = default;
+
+ private:
+  void AddAnnotations(MIRModule &module, const Klass &klass, const std::vector<const VerifyPragmaInfo*> &pragmaInfoVec);
+};
+#endif
+} // namespace maple
+#endif // MAPLEALL_VERIFY_MARK_H
\ No newline at end of file
diff --git a/src/mapleall/maple_ir/include/verify_pragma_info.h b/src/mapleall/maple_ir/include/verify_pragma_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..7fe43caf005d35f8f0457cc1e62b944ab2f7f9c8
--- /dev/null
+++ b/src/mapleall/maple_ir/include/verify_pragma_info.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEIR_VERIFY_PRAGMA_INFO_H
+#define MAPLEIR_VERIFY_PRAGMA_INFO_H
+#include <string>
+#include <utility>
+
+namespace maple {
+enum PragmaInfoType {
+  kThrowVerifyError,
+  kAssignableCheck,
+  kExtendFinalCheck,
+  kOverrideFinalCheck
+};
+
+class VerifyPragmaInfo {
+ public:
+  VerifyPragmaInfo() = default;;
+  virtual ~VerifyPragmaInfo() = default;
+
+  virtual PragmaInfoType GetPragmaType() const = 0;
+  bool IsEqualTo(const VerifyPragmaInfo &pragmaInfo) const {
+    return GetPragmaType() == pragmaInfo.GetPragmaType();
+  }
+  bool IsVerifyError() const {
+    return GetPragmaType() == kThrowVerifyError;
+  }
+  bool IsAssignableCheck() const {
+    return GetPragmaType() == kAssignableCheck;
+  }
+  bool IsExtendFinalCheck() const {
+    return GetPragmaType() == kExtendFinalCheck;
+  }
+  bool IsOverrideFinalCheck() const {
+    return GetPragmaType() == kOverrideFinalCheck;
+  }
+};
+
+class ThrowVerifyErrorPragma : public VerifyPragmaInfo {
+ public:
+  explicit ThrowVerifyErrorPragma(std::string errorMessage)
+      : VerifyPragmaInfo(),
+        errorMessage(std::move(errorMessage)) {}
+  ~ThrowVerifyErrorPragma() = default;
+
+  PragmaInfoType GetPragmaType() const override {
+    return kThrowVerifyError;
+  }
+
+  const std::string &GetMessage() const {
+    return errorMessage;
+  }
+
+ private:
+  std::string errorMessage;
+};
+
+class AssignableCheckPragma : public VerifyPragmaInfo {
+ public:
+  AssignableCheckPragma(std::string fromType, std::string toType)
+      : VerifyPragmaInfo(),
+        fromType(std::move(fromType)),
+        toType(std::move(toType)) {}
+  ~AssignableCheckPragma() = default;
+
+  PragmaInfoType GetPragmaType() const override {
+    return kAssignableCheck;
+  }
+
+  bool IsEqualTo(const AssignableCheckPragma &pragma) const {
+    return fromType == pragma.GetFromType() && toType == pragma.GetToType();
+  }
+
+  const std::string &GetFromType() const {
+    return fromType;
+  }
+
+  const std::string &GetToType() const {
+    return toType;
+  }
+
+ private:
+  std::string fromType;
+  std::string toType;
+};
+
+class ExtendFinalCheckPragma : public VerifyPragmaInfo {
+ public:
+  ExtendFinalCheckPragma() : VerifyPragmaInfo() {}
+  ~ExtendFinalCheckPragma() = default;
+
+  PragmaInfoType GetPragmaType() const override {
+    return kExtendFinalCheck;
+  }
+};
+
+class OverrideFinalCheckPragma : public VerifyPragmaInfo {
+ public:
+  OverrideFinalCheckPragma() : VerifyPragmaInfo() {}
+  ~OverrideFinalCheckPragma() = default;
+
+  PragmaInfoType GetPragmaType() const override {
+    return kOverrideFinalCheck;
+  }
+};
+}  // namespace maple
+#endif // MAPLEIR_VERIFY_PRAGMA_INFO_H
diff --git a/src/mapleall/maple_ir/src/bin_func_export.cpp b/src/mapleall/maple_ir/src/bin_func_export.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7e7f10620275cf6d8e3a07a865444f7bb70dff5a
--- /dev/null
+++ b/src/mapleall/maple_ir/src/bin_func_export.cpp
@@ -0,0 +1,744 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <sstream>
+#include <vector>
+#include "mir_function.h"
+#include "opcode_info.h"
+#include "mir_pragma.h"
+#include "mir_builder.h"
+#include "bin_mplt.h"
+
+using namespace std;
+namespace maple {
+void BinaryMplExport::OutputInfoVector(const MIRInfoVector &infoVector, const MapleVector<bool> &infoVectorIsString) {
+  if (!mod.IsWithDbgInfo()) {
+    Write(0);
+    return;
+  }
+  WriteNum(infoVector.size());
+  for (uint32 i = 0; i < infoVector.size(); i++) {
+    OutputStr(infoVector[i].first);
+    WriteNum(infoVectorIsString[i] ? 1 : 0);
+    if (!infoVectorIsString[i]) {
+      WriteNum(infoVector[i].second);
+    } else {
+      OutputStr(GStrIdx(infoVector[i].second));
+    }
+  }
+}
+
+void BinaryMplExport::OutputFuncIdInfo(MIRFunction *func) {
+  WriteNum(kBinFuncIdInfoStart);
+  WriteNum(func->GetPuidxOrigin());  // the funcid
+  OutputInfoVector(func->GetInfoVector(), func->InfoIsString());
+  if (mod.GetFlavor() == kFlavorLmbc) {
+    WriteNum(func->GetFrameSize());
+  }
+}
+
+void BinaryMplExport::OutputBaseNode(const BaseNode *b) {
+  Write(static_cast<uint8>(b->GetOpCode()));
+  Write(static_cast<uint8>(b->GetPrimType()));
+}
+
+void BinaryMplExport::OutputLocalSymbol(MIRSymbol *sym) {
+  std::unordered_map<const MIRSymbol*, int64>::iterator it = localSymMark.find(sym);
+  if (it != localSymMark.end()) {
+    WriteNum(-(it->second));
+    return;
+  }
+
+  CHECK_NULL_FATAL(sym);
+  WriteNum(kBinSymbol);
+  OutputStr(sym->GetNameStrIdx());
+  WriteNum(sym->GetSKind());
+  WriteNum(sym->GetStorageClass());
+  size_t mark = localSymMark.size();
+  localSymMark[sym] = static_cast<int64_t>(mark);
+  OutputTypeAttrs(sym->GetAttrs());
+  WriteNum(static_cast<int64>(sym->GetIsTmp()));
+  if (sym->GetSKind() == kStVar || sym->GetSKind() == kStFunc) {
+    OutputSrcPos(sym->GetSrcPosition());
+  }
+  OutputType(sym->GetTyIdx());
+  if (sym->GetSKind() == kStPreg) {
+    OutputPreg(sym->GetPreg());
+  } else if (sym->GetSKind() == kStConst || sym->GetSKind() == kStVar) {
+    OutputConst(sym->GetKonst());
+  } else if (sym->GetSKind() == kStFunc) {
+    OutputFuncViaSym(sym->GetFunction()->GetPuidx());
+  } else {
+    CHECK_FATAL(false, "should not used");
+  }
+}
+
+void BinaryMplExport::OutputPreg(MIRPreg *preg) {
+  if (preg->GetPregNo() < 0) {
+    WriteNum(kBinSpecialReg);
+    Write(static_cast<uint8>(-preg->GetPregNo()));
+    return;
+  }
+  std::unordered_map<const MIRPreg*, int64>::iterator it = localPregMark.find(preg);
+  if (it != localPregMark.end()) {
+    WriteNum(-(it->second));
+    return;
+  }
+
+  WriteNum(kBinPreg);
+  Write(static_cast<uint8>(preg->GetPrimType()));
+  size_t mark = localPregMark.size();
+  localPregMark[preg] = static_cast<int64_t>(mark);
+}
+
+void BinaryMplExport::OutputLabel(LabelIdx lidx) {
+  std::unordered_map<LabelIdx, int64>::iterator it = labelMark.find(lidx);
+  if (it != labelMark.end()) {
+    WriteNum(-(it->second));
+    return;
+  }
+
+  WriteNum(kBinLabel);
+  size_t mark = labelMark.size();
+  labelMark[lidx] = static_cast<int64_t>(mark);
+}
+
+void BinaryMplExport::OutputLocalTypeNameTab(const MIRTypeNameTable *typeNameTab) {
+  WriteNum(kBinTypenameStart);
+  WriteNum(static_cast<int64>(typeNameTab->Size()));
+  for (std::pair<GStrIdx, TyIdx> it : typeNameTab->GetGStrIdxToTyIdxMap()) {
+    OutputStr(it.first);
+    OutputType(it.second);
+  }
+}
+
+void BinaryMplExport::OutputFormalsStIdx(MIRFunction *func) {
+  WriteNum(kBinFormalStart);
+  WriteNum(func->GetFormalDefVec().size());
+  for (FormalDef formalDef : func->GetFormalDefVec()) {
+    OutputLocalSymbol(formalDef.formalSym);
+  }
+}
+
+void BinaryMplExport::OutputAliasMap(MapleMap<GStrIdx, MIRAliasVars> &aliasVarMap) {
+  WriteNum(kBinAliasMapStart);
+  WriteInt(static_cast<int32>(aliasVarMap.size()));
+  for (std::pair<GStrIdx, MIRAliasVars> it : aliasVarMap) {
+    OutputStr(it.first);
+    OutputStr(it.second.mplStrIdx);
+    WriteNum(static_cast<uint32>(it.second.atk));
+    WriteNum(it.second.index);
+    OutputStr(it.second.sigStrIdx);
+  }
+}
+
+void BinaryMplExport::OutputFuncViaSym(PUIdx puIdx) {
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
+  OutputSymbol(funcSt);
+}
+
+void BinaryMplExport::OutputExpression(BaseNode *e) {
+  OutputBaseNode(e);
+  switch (e->GetOpCode()) {
+    // leaf
+    case OP_constval: {
+      MIRConst *constVal = static_cast<ConstvalNode *>(e)->GetConstVal();
+      OutputConst(constVal);
+      return;
+    }
+    case OP_conststr: {
+      UStrIdx strIdx = static_cast<ConststrNode *>(e)->GetStrIdx();
+      OutputUsrStr(strIdx);
+      return;
+    }
+    case OP_addroflabel: {
+      AddroflabelNode *lNode = static_cast<AddroflabelNode *>(e);
+      OutputLabel(lNode->GetOffset());
+      return;
+    }
+    case OP_addroffunc: {
+      AddroffuncNode *addrNode = static_cast<AddroffuncNode *>(e);
+      OutputFuncViaSym(addrNode->GetPUIdx());
+      return;
+    }
+    case OP_sizeoftype: {
+      SizeoftypeNode *sot = static_cast<SizeoftypeNode *>(e);
+      OutputType(sot->GetTyIdx());
+      return;
+    }
+    case OP_addrof:
+    case OP_addrofoff:
+    case OP_dread:
+    case OP_dreadoff: {
+      StIdx stIdx;
+      if (e->GetOpCode() == OP_addrof || e->GetOpCode() == OP_dread) {
+        AddrofNode *drNode = static_cast<AddrofNode *>(e);
+        WriteNum(drNode->GetFieldID());
+        stIdx = drNode->GetStIdx();
+      } else {
+        DreadoffNode *droff = static_cast<DreadoffNode *>(e);
+        WriteNum(droff->offset);
+        stIdx = droff->stIdx;
+      }
+      WriteNum(stIdx.Scope());
+      if (stIdx.Islocal()) {
+        OutputLocalSymbol(curFunc->GetLocalOrGlobalSymbol(stIdx));
+      } else {
+        OutputSymbol(curFunc->GetLocalOrGlobalSymbol(stIdx));
+      }
+      return;
+    }
+    case OP_regread: {
+      RegreadNode *regreadNode = static_cast<RegreadNode *>(e);
+      MIRPreg *preg = curFunc->GetPregTab()->PregFromPregIdx(regreadNode->GetRegIdx());
+      OutputPreg(preg);
+      return;
+    }
+    case OP_gcmalloc:
+    case OP_gcpermalloc:
+    case OP_stackmalloc: {
+      GCMallocNode *gcNode = static_cast<GCMallocNode *>(e);
+      OutputType(gcNode->GetTyIdx());
+      return;
+    }
+    // unary
+    case OP_ceil:
+    case OP_cvt:
+    case OP_floor:
+    case OP_trunc: {
+      TypeCvtNode *typecvtNode = static_cast<TypeCvtNode *>(e);
+      Write(static_cast<uint8>(typecvtNode->FromType()));
+      break;
+    }
+    case OP_retype: {
+      RetypeNode *retypeNode = static_cast<RetypeNode *>(e);
+      OutputType(retypeNode->GetTyIdx());
+      break;
+    }
+    case OP_iread:
+    case OP_iaddrof: {
+      IreadNode *irNode = static_cast<IreadNode *>(e);
+      OutputType(irNode->GetTyIdx());
+      WriteNum(irNode->GetFieldID());
+      break;
+    }
+    case OP_ireadoff: {
+      IreadoffNode *irNode = static_cast<IreadoffNode *>(e);
+      WriteNum(irNode->GetOffset());
+      break;
+    }
+    case OP_ireadfpoff: {
+      IreadFPoffNode *irNode = static_cast<IreadFPoffNode *>(e);
+      WriteNum(irNode->GetOffset());
+      break;
+    }
+    case OP_sext:
+    case OP_zext:
+    case OP_extractbits: {
+      ExtractbitsNode *extNode = static_cast<ExtractbitsNode *>(e);
+      Write(extNode->GetBitsOffset());
+      Write(extNode->GetBitsSize());
+      break;
+    }
+    case OP_depositbits: {
+      DepositbitsNode *dbNode = static_cast<DepositbitsNode *>(e);
+      Write(dbNode->GetBitsOffset());
+      Write(dbNode->GetBitsSize());
+      break;
+    }
+    case OP_gcmallocjarray:
+    case OP_gcpermallocjarray: {
+      JarrayMallocNode *gcNode = static_cast<JarrayMallocNode *>(e);
+      OutputType(gcNode->GetTyIdx());
+      break;
+    }
+    // binary
+    case OP_sub:
+    case OP_mul:
+    case OP_div:
+    case OP_rem:
+    case OP_ashr:
+    case OP_lshr:
+    case OP_shl:
+    case OP_max:
+    case OP_min:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_cand:
+    case OP_cior:
+    case OP_land:
+    case OP_lior:
+    case OP_add: {
+      break;
+    }
+    case OP_eq:
+    case OP_ne:
+    case OP_lt:
+    case OP_gt:
+    case OP_le:
+    case OP_ge:
+    case OP_cmpg:
+    case OP_cmpl:
+    case OP_cmp: {
+      CompareNode *cmpNode = static_cast<CompareNode *>(e);
+      Write(static_cast<uint8>(cmpNode->GetOpndType()));
+      break;
+    }
+    case OP_resolveinterfacefunc:
+    case OP_resolvevirtualfunc: {
+      ResolveFuncNode *rsNode = static_cast<ResolveFuncNode *>(e);
+      OutputFuncViaSym(rsNode->GetPuIdx());
+      break;
+    }
+    // ternary
+    case OP_select: {
+      break;
+    }
+    // nary
+    case OP_array: {
+      ArrayNode *arrNode = static_cast<ArrayNode *>(e);
+      OutputType(arrNode->GetTyIdx());
+      Write(static_cast<uint8>(arrNode->GetBoundsCheck()));
+      WriteNum(static_cast<int64>(arrNode->NumOpnds()));
+      break;
+    }
+    case OP_intrinsicop: {
+      IntrinsicopNode *intrnNode = static_cast<IntrinsicopNode *>(e);
+      WriteNum(intrnNode->GetIntrinsic());
+      WriteNum(static_cast<int64>(intrnNode->NumOpnds()));
+      break;
+    }
+    case OP_intrinsicopwithtype: {
+      IntrinsicopNode *intrnNode = static_cast<IntrinsicopNode *>(e);
+      WriteNum(intrnNode->GetIntrinsic());
+      OutputType(intrnNode->GetTyIdx());
+      WriteNum(static_cast<int64>(intrnNode->NumOpnds()));
+      break;
+    }
+    default:
+      break;
+  }
+  for (uint32 i = 0; i < e->NumOpnds(); ++i) {
+    OutputExpression(e->Opnd(i));
+  }
+}
+
+static SrcPosition lastOutputSrcPosition;
+
+void BinaryMplExport::OutputSrcPos(const SrcPosition &pos) {
+  if (!mod.IsWithDbgInfo()) {
+    return;
+  }
+  if (pos.FileNum() == 0 || pos.LineNum() == 0) {  // error case, so output 0
+    WriteNum(lastOutputSrcPosition.RawData());
+    WriteNum(lastOutputSrcPosition.LineNum());
+    return;
+  }
+  WriteNum(pos.RawData());
+  WriteNum(pos.LineNum());
+  lastOutputSrcPosition = pos;
+}
+
+void BinaryMplExport::OutputReturnValues(const CallReturnVector *retv) {
+  WriteNum(kBinReturnvals);
+  WriteNum(static_cast<int64>(retv->size()));
+  for (uint32 i = 0; i < retv->size(); i++) {
+    RegFieldPair rfp = (*retv)[i].second;
+    if (rfp.IsReg()) {
+      MIRPreg *preg = curFunc->GetPregTab()->PregFromPregIdx(rfp.GetPregIdx());
+      OutputPreg(preg);
+    } else {
+      WriteNum(0);
+      WriteNum((rfp.GetFieldID()));
+      OutputLocalSymbol(curFunc->GetLocalOrGlobalSymbol((*retv)[i].first));
+    }
+  }
+}
+
+void BinaryMplExport::OutputBlockNode(BlockNode *block) {
+  WriteNum(kBinNodeBlock);
+  if (!block->GetStmtNodes().empty()) {
+    OutputSrcPos(block->GetSrcPos());
+  } else {
+    OutputSrcPos(SrcPosition());  // output 0
+  }
+  uint32 num = 0;
+  uint64 idx = buf.size();
+  ExpandFourBuffSize();  // place holder, Fixup later
+  for (StmtNode *s = block->GetFirst(); s; s = s->GetNext()) {
+    bool doneWithOpnds = false;
+    OutputSrcPos(s->GetSrcPos());
+    WriteNum(s->GetOpCode());
+    switch (s->GetOpCode()) {
+      case OP_dassign:
+      case OP_dassignoff: {
+        StIdx stIdx;
+        if (s->GetOpCode() == OP_dassign) {
+          DassignNode *dass = static_cast<DassignNode *>(s);
+          WriteNum(dass->GetFieldID());
+          stIdx = dass->GetStIdx();
+        } else {
+          DassignoffNode *dassoff = static_cast<DassignoffNode *>(s);
+          WriteNum(dassoff->GetPrimType());
+          WriteNum(dassoff->offset);
+          stIdx = dassoff->stIdx;
+        }
+        WriteNum(stIdx.Scope());
+        if (stIdx.Islocal()) {
+          OutputLocalSymbol(curFunc->GetLocalOrGlobalSymbol(stIdx));
+        } else {
+          OutputSymbol(curFunc->GetLocalOrGlobalSymbol(stIdx));
+        }
+        break;
+      }
+      case OP_regassign: {
+        RegassignNode *rass = static_cast<RegassignNode *>(s);
+        Write(static_cast<uint8>(rass->GetPrimType()));
+        MIRPreg *preg = curFunc->GetPregTab()->PregFromPregIdx(rass->GetRegIdx());
+        OutputPreg(preg);
+        break;
+      }
+      case OP_iassign: {
+        IassignNode *iass = static_cast<IassignNode *>(s);
+        OutputType(iass->GetTyIdx());
+        WriteNum(iass->GetFieldID());
+        break;
+      }
+      case OP_iassignoff: {
+        IassignoffNode *iassoff = static_cast<IassignoffNode *>(s);
+        Write(static_cast<uint8>(iassoff->GetPrimType()));
+        WriteNum(iassoff->GetOffset());
+        break;
+      }
+      case OP_iassignspoff:
+      case OP_iassignfpoff: {
+        IassignFPoffNode *iassfpoff = static_cast<IassignFPoffNode *>(s);
+        Write(static_cast<uint8>(iassfpoff->GetPrimType()));
+        WriteNum(iassfpoff->GetOffset());
+        break;
+      }
+      case OP_blkassignoff: {
+        BlkassignoffNode *bass = static_cast<BlkassignoffNode *>(s);
+        int32 offsetAlign = (bass->offset << 4) | bass->alignLog2;
+        WriteNum(offsetAlign);
+        WriteNum(bass->blockSize);
+        break;
+      }
+      case OP_call:
+      case OP_virtualcall:
+      case OP_virtualicall:
+      case OP_superclasscall:
+      case OP_interfacecall:
+      case OP_interfaceicall:
+      case OP_customcall:
+      case OP_polymorphiccall: {
+        CallNode *callnode = static_cast<CallNode *>(s);
+        OutputFuncViaSym(callnode->GetPUIdx());
+        if (s->GetOpCode() == OP_polymorphiccall) {
+          OutputType(static_cast<CallNode *>(callnode)->GetTyIdx());
+        }
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_callassigned:
+      case OP_virtualcallassigned:
+      case OP_virtualicallassigned:
+      case OP_superclasscallassigned:
+      case OP_interfacecallassigned:
+      case OP_interfaceicallassigned:
+      case OP_customcallassigned: {
+        CallNode *callnode = static_cast<CallNode *>(s);
+        OutputFuncViaSym(callnode->GetPUIdx());
+        OutputReturnValues(&callnode->GetReturnVec());
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_polymorphiccallassigned: {
+        CallNode *callnode = static_cast<CallNode *>(s);
+        OutputFuncViaSym(callnode->GetPUIdx());
+        OutputType(callnode->GetTyIdx());
+        OutputReturnValues(&callnode->GetReturnVec());
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_icallproto:
+      case OP_icall: {
+        IcallNode *icallnode = static_cast<IcallNode *>(s);
+        OutputType(icallnode->GetRetTyIdx());
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_icallprotoassigned:
+      case OP_icallassigned: {
+        IcallNode *icallnode = static_cast<IcallNode *>(s);
+        OutputType(icallnode->GetRetTyIdx());
+        OutputReturnValues(&icallnode->GetReturnVec());
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_intrinsiccall:
+      case OP_xintrinsiccall: {
+        IntrinsiccallNode *intrnNode = static_cast<IntrinsiccallNode *>(s);
+        WriteNum(intrnNode->GetIntrinsic());
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_intrinsiccallassigned:
+      case OP_xintrinsiccallassigned: {
+        IntrinsiccallNode *intrnNode = static_cast<IntrinsiccallNode *>(s);
+        WriteNum(intrnNode->GetIntrinsic());
+        OutputReturnValues(&intrnNode->GetReturnVec());
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_intrinsiccallwithtype: {
+        IntrinsiccallNode *intrnNode = static_cast<IntrinsiccallNode *>(s);
+        WriteNum(intrnNode->GetIntrinsic());
+        OutputType(intrnNode->GetTyIdx());
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_intrinsiccallwithtypeassigned: {
+        IntrinsiccallNode *intrnNode = static_cast<IntrinsiccallNode *>(s);
+        WriteNum(intrnNode->GetIntrinsic());
+        OutputType(intrnNode->GetTyIdx());
+        OutputReturnValues(&intrnNode->GetReturnVec());
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_syncenter:
+      case OP_syncexit:
+      case OP_return: {
+        WriteNum(static_cast<int64>(s->NumOpnds()));
+        break;
+      }
+      case OP_jscatch:
+      case OP_cppcatch:
+      case OP_finally:
+      case OP_endtry:
+      case OP_cleanuptry:
+      case OP_retsub:
+      case OP_membaracquire:
+      case OP_membarrelease:
+      case OP_membarstorestore:
+      case OP_membarstoreload: {
+        break;
+      }
+      case OP_eval:
+      case OP_throw:
+      case OP_free:
+      case OP_decref:
+      case OP_incref:
+      case OP_decrefreset:
+      CASE_OP_ASSERT_NONNULL
+      case OP_igoto: {
+        break;
+      }
+      case OP_label: {
+        LabelNode *lNode = static_cast<LabelNode *>(s);
+        OutputLabel(lNode->GetLabelIdx());
+        break;
+      }
+      case OP_goto:
+      case OP_gosub: {
+        GotoNode *gtoNode = static_cast<GotoNode *>(s);
+        OutputLabel(gtoNode->GetOffset());
+        break;
+      }
+      case OP_brfalse:
+      case OP_brtrue: {
+        CondGotoNode *cgotoNode = static_cast<CondGotoNode *>(s);
+        OutputLabel(cgotoNode->GetOffset());
+        break;
+      }
+      case OP_switch: {
+        SwitchNode *swNode = static_cast<SwitchNode *>(s);
+        OutputLabel(swNode->GetDefaultLabel());
+        WriteNum(static_cast<int64>(swNode->GetSwitchTable().size()));
+        for (CasePair cpair : swNode->GetSwitchTable()) {
+          WriteNum(cpair.first);
+          OutputLabel(cpair.second);
+        }
+        break;
+      }
+      case OP_rangegoto: {
+        RangeGotoNode *rgoto = static_cast<RangeGotoNode *>(s);
+        WriteNum(rgoto->GetTagOffset());
+        WriteNum(static_cast<int64>(rgoto->GetRangeGotoTable().size()));
+        for (SmallCasePair cpair : rgoto->GetRangeGotoTable()) {
+          WriteNum(cpair.first);
+          OutputLabel(cpair.second);
+        }
+        break;
+      }
+      case OP_jstry: {
+        JsTryNode *tryNode = static_cast<JsTryNode *>(s);
+        OutputLabel(tryNode->GetCatchOffset());
+        OutputLabel(tryNode->GetFinallyOffset());
+        break;
+      }
+      case OP_cpptry:
+      case OP_try: {
+        TryNode *tryNode = static_cast<TryNode *>(s);
+        WriteNum(static_cast<int64>(tryNode->GetOffsetsCount()));
+        for (LabelIdx lidx : tryNode->GetOffsets()) {
+          OutputLabel(lidx);
+        }
+        break;
+      }
+      case OP_catch: {
+        CatchNode *catchNode = static_cast<CatchNode *>(s);
+        WriteNum(static_cast<int64>(catchNode->GetExceptionTyIdxVec().size()));
+        for (TyIdx tidx : catchNode->GetExceptionTyIdxVec()) {
+          OutputType(tidx);
+        }
+        break;
+      }
+      case OP_comment: {
+        string str(static_cast<CommentNode *>(s)->GetComment().c_str());
+        WriteAsciiStr(str);
+        break;
+      }
+      case OP_dowhile:
+      case OP_while: {
+        WhileStmtNode *whileNode = static_cast<WhileStmtNode *>(s);
+        OutputBlockNode(whileNode->GetBody());
+        OutputExpression(whileNode->Opnd());
+        doneWithOpnds = true;
+        break;
+      }
+      case OP_if: {
+        IfStmtNode *ifNode = static_cast<IfStmtNode *>(s);
+        bool hasElsePart = ifNode->GetElsePart() != nullptr;
+        WriteNum(static_cast<int64>(hasElsePart));
+        OutputBlockNode(ifNode->GetThenPart());
+        if (hasElsePart) {
+          OutputBlockNode(ifNode->GetElsePart());
+        }
+        OutputExpression(ifNode->Opnd());
+        doneWithOpnds = true;
+        break;
+      }
+      case OP_block: {
+        BlockNode *blockNode = static_cast<BlockNode *>(s);
+        OutputBlockNode(blockNode);
+        doneWithOpnds = true;
+        break;
+      }
+      case OP_asm: {
+        AsmNode *asmNode = static_cast<AsmNode *>(s);
+        WriteNum(asmNode->qualifiers);
+        string str(asmNode->asmString.c_str());
+        WriteAsciiStr(str);
+        // the outputs
+        size_t count = asmNode->asmOutputs.size();
+        WriteNum(static_cast<int64>(count));
+        for (size_t i = 0; i < count; ++i) {
+          OutputUsrStr(asmNode->outputConstraints[i]);
+        }
+        OutputReturnValues(&asmNode->asmOutputs);
+        // the clobber list
+        count = asmNode->clobberList.size();
+        WriteNum(static_cast<int64>(count));
+        for (size_t i = 0; i < count; ++i) {
+          OutputUsrStr(asmNode->clobberList[i]);
+        }
+        // the labels
+        count = asmNode->gotoLabels.size();
+        WriteNum(static_cast<int64>(count));
+        for (size_t i = 0; i < count; ++i) {
+          OutputLabel(asmNode->gotoLabels[i]);
+        }
+        // the inputs
+        WriteNum(asmNode->NumOpnds());
+        for (uint8 i = 0; i < asmNode->numOpnds; ++i) {
+          OutputUsrStr(asmNode->inputConstraints[i]);
+        }
+        break;
+      }
+      default:
+        CHECK_FATAL(false, "Unhandled opcode %d", s->GetOpCode());
+        break;
+    }
+    num++;
+    if (!doneWithOpnds) {
+      for (uint32 i = 0; i < s->NumOpnds(); ++i) {
+        OutputExpression(s->Opnd(i));
+      }
+    }
+  }
+  Fixup(idx, num);
+}
+
+void BinaryMplExport::WriteFunctionBodyField(uint64 contentIdx, std::unordered_set<std::string> *dumpFuncSet) {
+  Fixup(contentIdx, static_cast<uint32>(buf.size()));
+  // LogInfo::MapleLogger() << "Write FunctionBody Field " << std::endl;
+  WriteNum(kBinFunctionBodyStart);
+  uint64 totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  /// total size of this field to ~BIN_FUNCTIONBODY_START
+  uint64 outFunctionBodySizeIdx = buf.size();
+  ExpandFourBuffSize();  /// size of outFunctionBody
+  uint32 size = 0;
+
+  if (not2mplt) {
+    for (MIRFunction *func : GetMIRModule().GetFunctionList()) {
+      curFunc = func;
+      if (func->GetAttr(FUNCATTR_optimized)) {
+        continue;
+      }
+      if (func->GetCodeMemPool() == nullptr || func->GetBody() == nullptr) {
+        continue;
+      }
+      if (dumpFuncSet != nullptr && !dumpFuncSet->empty()) {
+        // output only if this func matches any name in *dumpFuncSet
+        const std::string &name = func->GetName();
+        bool matched = false;
+        for (std::string elem : *dumpFuncSet) {
+          if (name.find(elem.c_str()) != string::npos) {
+            matched = true;
+            break;
+          }
+        }
+        if (!matched) {
+          continue;
+        }
+      }
+      localSymMark.clear();
+      localSymMark[nullptr] = 0;
+      localPregMark.clear();
+      localPregMark[nullptr] = 0;
+      labelMark.clear();
+      labelMark[0] = 0;
+      OutputFunction(func->GetPuidx());
+      CHECK_FATAL(func->GetBody() != nullptr, "WriteFunctionBodyField: no function body");
+      OutputFuncIdInfo(func);
+      OutputLocalTypeNameTab(func->GetTypeNameTab());
+      OutputFormalsStIdx(func);
+      if (mod.GetFlavor() < kMmpl) {
+        OutputAliasMap(func->GetAliasVarMap());
+      }
+      lastOutputSrcPosition = SrcPosition();
+      OutputBlockNode(func->GetBody());
+      size++;
+    }
+  }
+
+  Fixup(totalSizeIdx, static_cast<uint32>(buf.size() - totalSizeIdx));
+  Fixup(outFunctionBodySizeIdx, size);
+  return;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/bin_func_import.cpp b/src/mapleall/maple_ir/src/bin_func_import.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58f792bfa4d714d0a03dbfc1f537c7267823224f
--- /dev/null
+++ b/src/mapleall/maple_ir/src/bin_func_import.cpp
@@ -0,0 +1,947 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "bin_mpl_export.h"
+#include "bin_mpl_import.h"
+#include "mir_function.h"
+#include "opcode_info.h"
+#include "mir_pragma.h"
+#include "mir_builder.h"
+using namespace std;
+
+namespace maple {
+constexpr uint32 kOffset4bit = 4;
+void BinaryMplImport::ImportInfoVector(MIRInfoVector &infoVector, MapleVector<bool> &infoVectorIsString) {
+  int64 size = ReadNum();
+  for (int64 i = 0; i < size; ++i) {
+    GStrIdx gStrIdx = ImportStr();
+    bool isstring = (ReadNum() != 0);
+    infoVectorIsString.push_back(isstring);
+    if (isstring) {
+      GStrIdx fieldval = ImportStr();
+      infoVector.emplace_back(MIRInfoPair(gStrIdx, fieldval.GetIdx()));
+    } else {
+      auto fieldval = static_cast<uint32>(ReadNum());
+      infoVector.emplace_back(MIRInfoPair(gStrIdx, fieldval));
+    }
+  }
+}
+
+void BinaryMplImport::ImportFuncIdInfo(MIRFunction *func) {
+  int64 tag = ReadNum();
+  CHECK_FATAL(tag == kBinFuncIdInfoStart, "kBinFuncIdInfoStart expected");
+  func->SetPuidxOrigin(static_cast<PUIdx>(ReadNum()));
+  ImportInfoVector(func->GetInfoVector(), func->InfoIsString());
+  if (mod.GetFlavor() == kFlavorLmbc) {
+    func->SetFrameSize(static_cast<uint32>(ReadNum()));
+  }
+}
+
+void BinaryMplImport::ImportBaseNode(Opcode &o, PrimType &typ) {
+  o = static_cast<Opcode>(Read());
+  typ = static_cast<PrimType>(Read());
+}
+
+MIRSymbol *BinaryMplImport::ImportLocalSymbol(MIRFunction *func) {
+  int64 tag = ReadNum();
+  if (tag == 0) {
+    return nullptr;
+  }
+  if (tag < 0) {
+    CHECK_FATAL(static_cast<size_t>(-tag) < localSymTab.size(), "index out of bounds");
+    return localSymTab.at(static_cast<size_t>(-tag));
+  }
+  CHECK_FATAL(tag == kBinSymbol, "expecting kBinSymbol in ImportLocalSymbol()");
+  MIRSymbol *sym = func->GetSymTab()->CreateSymbol(kScopeLocal);
+  localSymTab.push_back(sym);
+  sym->SetNameStrIdx(ImportStr());
+  (void)func->GetSymTab()->AddToStringSymbolMap(*sym);
+  sym->SetSKind(static_cast<MIRSymKind>(ReadNum()));
+  sym->SetStorageClass(static_cast<MIRStorageClass>(ReadNum()));
+  sym->SetAttrs(ImportTypeAttrs());
+  sym->SetIsTmp(ReadNum() != 0);
+  if (sym->GetSKind() == kStVar || sym->GetSKind() == kStFunc) {
+    ImportSrcPos(sym->GetSrcPosition());
+  }
+  sym->SetTyIdx(ImportType());
+  if (sym->GetSKind() == kStPreg) {
+    PregIdx pregidx = ImportPreg(func);
+    MIRPreg *preg = func->GetPregTab()->PregFromPregIdx(pregidx);
+    sym->SetPreg(preg);
+  } else if (sym->GetSKind() == kStConst || sym->GetSKind() == kStVar) {
+    sym->SetKonst(ImportConst(func));
+  } else if (sym->GetSKind() == kStFunc) {
+    PUIdx puIdx = ImportFuncViaSym(func);
+    sym->SetFunction(GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx));
+  }
+  return sym;
+}
+
+PregIdx BinaryMplImport::ImportPreg(MIRFunction *func) {
+  int64 tag = ReadNum();
+  if (tag == 0) {
+    return 0;
+  }
+  if (tag == kBinSpecialReg) {
+    return -Read();
+  }
+  if (tag < 0) {
+    CHECK_FATAL(static_cast<size_t>(-tag) < localPregTab.size(), "index out of bounds");
+    return localPregTab.at(static_cast<size_t>(-tag));
+  }
+  CHECK_FATAL(tag == kBinPreg, "expecting kBinPreg in ImportPreg()");
+
+  PrimType primType = static_cast<PrimType>(Read());
+  PregIdx pidx = func->GetPregTab()->CreatePreg(primType);
+  localPregTab.push_back(pidx);
+  return pidx;
+}
+
+LabelIdx BinaryMplImport::ImportLabel(MIRFunction *func) {
+  int64 tag = ReadNum();
+  if (tag == 0) {
+    return 0;
+  }
+  if (tag < 0) {
+    CHECK_FATAL(static_cast<size_t>(-tag) < localLabelTab.size(), "index out of bounds");
+    return localLabelTab.at(static_cast<size_t>(-tag));
+  }
+  CHECK_FATAL(tag == kBinLabel, "kBinLabel expected in ImportLabel()");
+
+  LabelIdx lidx = func->GetLabelTab()->CreateLabel();
+  localLabelTab.push_back(lidx);
+  return lidx;
+}
+
+void BinaryMplImport::ImportLocalTypeNameTable(MIRTypeNameTable *typeNameTab) {
+  int64 tag = ReadNum();
+  CHECK_FATAL(tag == kBinTypenameStart, "kBinTypenameStart expected in ImportLocalTypeNameTable()");
+  int64 size = ReadNum();
+  for (int64 i = 0; i < size; ++i) {
+    GStrIdx strIdx = ImportStr();
+    TyIdx tyIdx = ImportType();
+    typeNameTab->SetGStrIdxToTyIdx(strIdx, tyIdx);
+  }
+}
+
+void BinaryMplImport::ImportFormalsStIdx(MIRFunction *func) {
+  auto tag = ReadNum();
+  CHECK_FATAL(tag == kBinFormalStart, "kBinFormalStart expected in ImportFormalsStIdx()");
+  auto size = ReadNum();
+  for (int64 i = 0; i < size; ++i) {
+    func->GetFormalDefVec()[static_cast<uint64>(i)].formalSym = ImportLocalSymbol(func);
+  }
+}
+
+void BinaryMplImport::ImportAliasMap(MIRFunction *func) {
+  int64 tag = ReadNum();
+  CHECK_FATAL(tag == kBinAliasMapStart, "kBinAliasMapStart expected in ImportAliasMap()");
+  int32 size = ReadInt();
+  for (int32 i = 0; i < size; ++i) {
+    MIRAliasVars aliasvars;
+    GStrIdx strIdx = ImportStr();
+    aliasvars.mplStrIdx = ImportStr();
+    aliasvars.atk = static_cast<AliasTypeKind>(ReadNum());
+    aliasvars.index = static_cast<uint32>(ReadNum());
+    (void)ImportStr();  // not assigning to mimic parser
+    func->GetAliasVarMap()[strIdx] = aliasvars;
+  }
+}
+
+PUIdx BinaryMplImport::ImportFuncViaSym(MIRFunction *func) {
+  MIRSymbol *sym = InSymbol(func);
+  MIRFunction *f = sym->GetFunction();
+  return f->GetPuidx();
+}
+
+BaseNode *BinaryMplImport::ImportExpression(MIRFunction *func) {
+  Opcode op;
+  PrimType typ;
+  ImportBaseNode(op, typ);
+  switch (op) {
+    // leaf
+    case OP_constval: {
+      MIRConst *constv = ImportConst(func);
+      ConstvalNode *constNode = mod.CurFuncCodeMemPool()->New<ConstvalNode>(constv);
+      constNode->SetPrimType(typ);
+      return constNode;
+    }
+    case OP_conststr: {
+      UStrIdx strIdx = ImportUsrStr();
+      ConststrNode *constNode = mod.CurFuncCodeMemPool()->New<ConststrNode>(typ, strIdx);
+      constNode->SetPrimType(typ);
+      return constNode;
+    }
+    case OP_addroflabel: {
+      AddroflabelNode *alabNode = mod.CurFuncCodeMemPool()->New<AddroflabelNode>();
+      alabNode->SetOffset(ImportLabel(func));
+      alabNode->SetPrimType(typ);
+      (void)func->GetLabelTab()->addrTakenLabels.insert(alabNode->GetOffset());
+      return alabNode;
+    }
+    case OP_addroffunc: {
+      PUIdx puIdx = ImportFuncViaSym(func);
+      MIRFunction *f = GlobalTables::GetFunctionTable().GetFuncTable()[puIdx];
+      CHECK_NULL_FATAL(f);
+      f->GetFuncSymbol()->SetAppearsInCode(true);
+      AddroffuncNode *addrNode = mod.CurFuncCodeMemPool()->New<AddroffuncNode>(typ, puIdx);
+      return addrNode;
+    }
+    case OP_sizeoftype: {
+      TyIdx tidx = ImportType();
+      SizeoftypeNode *sot = mod.CurFuncCodeMemPool()->New<SizeoftypeNode>(tidx);
+      return sot;
+    }
+    case OP_addrof:
+    case OP_addrofoff:
+    case OP_dread:
+    case OP_dreadoff: {
+      int32 num = static_cast<int32>(ReadNum());
+      StIdx stIdx;
+      stIdx.SetScope(static_cast<uint32>(ReadNum()));
+      MIRSymbol *sym = nullptr;
+      if (stIdx.Islocal()) {
+        sym = ImportLocalSymbol(func);
+        CHECK_FATAL(sym != nullptr, "null ptr check");
+      } else {
+        sym = InSymbol(nullptr);
+        CHECK_FATAL(sym != nullptr, "null ptr check");
+        if (op == OP_addrof) {
+          sym->SetHasPotentialAssignment();
+        }
+      }
+      stIdx.SetIdx(sym->GetStIdx().Idx());
+      if (op == OP_addrof || op == OP_dread) {
+        AddrofNode *drNode = mod.CurFuncCodeMemPool()->New<AddrofNode>(op);
+        drNode->SetPrimType(typ);
+        drNode->SetStIdx(stIdx);
+        drNode->SetFieldID(num);
+        return drNode;
+      } else {
+        DreadoffNode *dreadoff = mod.CurFuncCodeMemPool()->New<DreadoffNode>(op);
+        dreadoff->SetPrimType(typ);
+        dreadoff->stIdx = stIdx;
+        dreadoff->offset = num;
+        return dreadoff;
+      }
+    }
+    case OP_regread: {
+      RegreadNode *regreadNode = mod.CurFuncCodeMemPool()->New<RegreadNode>();
+      regreadNode->SetRegIdx(ImportPreg(func));
+      regreadNode->SetPrimType(typ);
+      return regreadNode;
+    }
+    case OP_gcmalloc:
+    case OP_gcpermalloc:
+    case OP_stackmalloc: {
+      TyIdx tyIdx = ImportType();
+      GCMallocNode *gcNode = mod.CurFuncCodeMemPool()->New<GCMallocNode>(op, typ, tyIdx);
+      return gcNode;
+    }
+    // unary
+    case OP_abs:
+    case OP_bnot:
+    case OP_lnot:
+    case OP_neg:
+    case OP_recip:
+    case OP_sqrt:
+    case OP_alloca:
+    case OP_malloc: {
+      UnaryNode *unNode = mod.CurFuncCodeMemPool()->New<UnaryNode>(op, typ);
+      unNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      return unNode;
+    }
+    case OP_ceil:
+    case OP_cvt:
+    case OP_floor:
+    case OP_trunc: {
+      TypeCvtNode *typecvtNode = mod.CurFuncCodeMemPool()->New<TypeCvtNode>(op, typ);
+      typecvtNode->SetFromType(static_cast<PrimType>(Read()));
+      typecvtNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      return typecvtNode;
+    }
+    case OP_retype: {
+      RetypeNode *retypeNode = mod.CurFuncCodeMemPool()->New<RetypeNode>(typ);
+      retypeNode->SetTyIdx(ImportType());
+      retypeNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      return retypeNode;
+    }
+    case OP_iread:
+    case OP_iaddrof: {
+      IreadNode *irNode = mod.CurFuncCodeMemPool()->New<IreadNode>(op, typ);
+      irNode->SetTyIdx(ImportType());
+      irNode->SetFieldID(static_cast<FieldID>(ReadNum()));
+      irNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      return irNode;
+    }
+    case OP_ireadoff: {
+      int32 ofst = static_cast<int32>(ReadNum());
+      IreadoffNode *irNode = mod.CurFuncCodeMemPool()->New<IreadoffNode>(typ, ofst);
+      irNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      return irNode;
+    }
+    case OP_ireadfpoff: {
+      int32 ofst = static_cast<int32>(ReadNum());
+      IreadFPoffNode *irNode = mod.CurFuncCodeMemPool()->New<IreadFPoffNode>(typ, ofst);
+      return irNode;
+    }
+    case OP_sext:
+    case OP_zext:
+    case OP_extractbits: {
+      ExtractbitsNode *extNode = mod.CurFuncCodeMemPool()->New<ExtractbitsNode>(op, typ);
+      extNode->SetBitsOffset(Read());
+      extNode->SetBitsSize(Read());
+      extNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      return extNode;
+    }
+    case OP_depositbits: {
+      DepositbitsNode *dbNode = mod.CurFuncCodeMemPool()->New<DepositbitsNode>(op, typ);
+      dbNode->SetBitsOffset(static_cast<uint8>(ReadNum()));
+      dbNode->SetBitsSize(static_cast<uint8>(ReadNum()));
+      dbNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      dbNode->SetOpnd(ImportExpression(func), kSecondOpnd);
+      return dbNode;
+    }
+    case OP_gcmallocjarray:
+    case OP_gcpermallocjarray: {
+      JarrayMallocNode *gcNode = mod.CurFuncCodeMemPool()->New<JarrayMallocNode>(op, typ);
+      gcNode->SetTyIdx(ImportType());
+      gcNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      return gcNode;
+    }
+    // binary
+    case OP_sub:
+    case OP_mul:
+    case OP_div:
+    case OP_rem:
+    case OP_ashr:
+    case OP_lshr:
+    case OP_shl:
+    case OP_max:
+    case OP_min:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_cand:
+    case OP_cior:
+    case OP_land:
+    case OP_lior:
+    case OP_add: {
+      BinaryNode *binNode = mod.CurFuncCodeMemPool()->New<BinaryNode>(op, typ);
+      binNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      binNode->SetOpnd(ImportExpression(func), kSecondOpnd);
+      return binNode;
+    }
+    case OP_eq:
+    case OP_ne:
+    case OP_lt:
+    case OP_gt:
+    case OP_le:
+    case OP_ge:
+    case OP_cmpg:
+    case OP_cmpl:
+    case OP_cmp: {
+      CompareNode *cmpNode = mod.CurFuncCodeMemPool()->New<CompareNode>(op, typ);
+      cmpNode->SetOpndType(static_cast<PrimType>(Read()));
+      cmpNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      cmpNode->SetOpnd(ImportExpression(func), kSecondOpnd);
+      return cmpNode;
+    }
+    case OP_resolveinterfacefunc:
+    case OP_resolvevirtualfunc: {
+      ResolveFuncNode *rsNode = mod.CurFuncCodeMemPool()->New<ResolveFuncNode>(op, typ);
+      rsNode->SetPUIdx(ImportFuncViaSym(func));
+      rsNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      rsNode->SetOpnd(ImportExpression(func), kSecondOpnd);
+      return rsNode;
+    }
+    // ternary
+    case OP_select: {
+      TernaryNode *tNode = mod.CurFuncCodeMemPool()->New<TernaryNode>(op, typ);
+      tNode->SetOpnd(ImportExpression(func), kFirstOpnd);
+      tNode->SetOpnd(ImportExpression(func), kSecondOpnd);
+      tNode->SetOpnd(ImportExpression(func), kThirdOpnd);
+      return tNode;
+    }
+    // nary
+    case OP_array: {
+      TyIdx tidx = ImportType();
+      bool boundsCheck = static_cast<bool>(Read());
+      ArrayNode *arrNode =
+          mod.CurFuncCodeMemPool()->New<ArrayNode>(func->GetCodeMPAllocator(), typ, tidx, boundsCheck);
+      auto n = static_cast<uint32>(ReadNum());
+      for (uint32 i = 0; i < n; ++i) {
+        arrNode->GetNopnd().push_back(ImportExpression(func));
+      }
+      arrNode->SetNumOpnds(static_cast<uint8>(arrNode->GetNopnd().size()));
+      return arrNode;
+    }
+    case OP_intrinsicop: {
+      IntrinsicopNode *intrnNode = mod.CurFuncCodeMemPool()->New<IntrinsicopNode>(func->GetCodeMPAllocator(), op, typ);
+      intrnNode->SetIntrinsic(static_cast<MIRIntrinsicID>(ReadNum()));
+      auto n = static_cast<uint32>(ReadNum());
+      for (uint32 i = 0; i < n; ++i) {
+        intrnNode->GetNopnd().push_back(ImportExpression(func));
+      }
+      intrnNode->SetNumOpnds(static_cast<uint8>(intrnNode->GetNopnd().size()));
+      return intrnNode;
+    }
+    case OP_intrinsicopwithtype: {
+      IntrinsicopNode *intrnNode =
+          mod.CurFuncCodeMemPool()->New<IntrinsicopNode>(func->GetCodeMPAllocator(), OP_intrinsicopwithtype, typ);
+      intrnNode->SetIntrinsic((MIRIntrinsicID)ReadNum());
+      intrnNode->SetTyIdx(ImportType());
+      auto n = static_cast<uint32>(ReadNum());
+      for (uint32 i = 0; i < n; ++i) {
+        intrnNode->GetNopnd().push_back(ImportExpression(func));
+      }
+      intrnNode->SetNumOpnds(static_cast<uint8>(intrnNode->GetNopnd().size()));
+      return intrnNode;
+    }
+    default:
+      CHECK_FATAL(false, "Unhandled op %d", op);
+      break;
+  }
+}
+
+void BinaryMplImport::ImportSrcPos(SrcPosition &pos) {
+  if (!mod.IsWithDbgInfo()) {
+    return;
+  }
+  pos.SetRawData(static_cast<uint32>(ReadNum()));
+  pos.SetLineNum(static_cast<uint32>(ReadNum()));
+}
+
+void BinaryMplImport::ImportReturnValues(MIRFunction *func, CallReturnVector *retv) {
+  int64 tag = ReadNum();
+  CHECK_FATAL(tag == kBinReturnvals, "expecting return values");
+  auto size = static_cast<uint32>(ReadNum());
+  for (uint32 i = 0; i < size; ++i) {
+    RegFieldPair rfp;
+    rfp.SetPregIdx(ImportPreg(func));
+    if (rfp.IsReg()) {
+      retv->push_back(std::make_pair(StIdx(), rfp));
+      continue;
+    }
+    rfp.SetFieldID(static_cast<FieldID>(ReadNum()));
+    MIRSymbol *lsym = ImportLocalSymbol(func);
+    CHECK_FATAL(lsym != nullptr, "null ptr check");
+    retv->push_back(std::make_pair(lsym->GetStIdx(), rfp));
+    if (lsym->GetName().find("L_STR") == 0) {
+      MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lsym->GetTyIdx());
+      CHECK_FATAL(ty->GetKind() == kTypePointer, "Pointer type expected for L_STR prefix");
+      MIRPtrType tempType(static_cast<MIRPtrType *>(ty)->GetPointedTyIdx(), PTY_ptr);
+      TyIdx newTyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&tempType);
+      lsym->SetTyIdx(newTyidx);
+    }
+  }
+}
+
+BlockNode *BinaryMplImport::ImportBlockNode(MIRFunction *func) {
+  int64 tag = ReadNum();
+  ASSERT(tag == kBinNodeBlock, "expecting a BlockNode");
+
+  BlockNode *block = func->GetCodeMemPool()->New<BlockNode>();
+  Opcode op;
+  uint8 numOpr;
+  ImportSrcPos(block->GetSrcPos());
+  int32 size = ReadInt();
+  for (int32 k = 0; k < size; ++k) {
+    SrcPosition thesrcPosition;
+    ImportSrcPos(thesrcPosition);
+    op = static_cast<Opcode>(ReadNum());
+    StmtNode *stmt = nullptr;
+    switch (op) {
+      case OP_dassign:
+      case OP_dassignoff: {
+        PrimType primType = PTY_void;
+        if (op == OP_dassignoff) {
+          primType = static_cast<PrimType>(ReadNum());
+        }
+        int32 num = static_cast<int32>(ReadNum());
+        StIdx stIdx;
+        stIdx.SetScope(static_cast<uint32>(ReadNum()));
+        MIRSymbol *sym = nullptr;
+        if (stIdx.Islocal()) {
+          sym = ImportLocalSymbol(func);
+          CHECK_FATAL(sym != nullptr, "null ptr check");
+        } else {
+          sym = InSymbol(nullptr);
+          CHECK_FATAL(sym != nullptr, "null ptr check");
+          sym->SetHasPotentialAssignment();
+        }
+        stIdx.SetIdx(sym->GetStIdx().Idx());
+        if (op == OP_dassign) {
+          DassignNode *s = func->GetCodeMemPool()->New<DassignNode>();
+          s->SetStIdx(stIdx);
+          s->SetFieldID(num);
+          s->SetOpnd(ImportExpression(func), kFirstOpnd);
+          stmt = s;
+        } else {
+          DassignoffNode *s = func->GetCodeMemPool()->New<DassignoffNode>();
+          s->SetPrimType(primType);
+          s->stIdx = stIdx;
+          s->offset = num;
+          s->SetOpnd(ImportExpression(func), kFirstOpnd);
+          stmt = s;
+        }
+        break;
+      }
+      case OP_regassign: {
+        RegassignNode *s = func->GetCodeMemPool()->New<RegassignNode>();
+        s->SetPrimType(static_cast<PrimType>(Read()));
+        s->SetRegIdx(ImportPreg(func));
+        s->SetOpnd(ImportExpression(func), kFirstOpnd);
+        stmt = s;
+        break;
+      }
+      case OP_iassign: {
+        IassignNode *s = func->GetCodeMemPool()->New<IassignNode>();
+        s->SetTyIdx(ImportType());
+        s->SetFieldID(static_cast<FieldID>(ReadNum()));
+        s->SetAddrExpr(ImportExpression(func));
+        s->SetRHS(ImportExpression(func));
+        stmt = s;
+        break;
+      }
+      case OP_iassignoff: {
+        IassignoffNode *s = func->GetCodeMemPool()->New<IassignoffNode>();
+        s->SetPrimType((PrimType)Read());
+        s->SetOffset(static_cast<int32>(ReadNum()));
+        s->SetOpnd(ImportExpression(func), kFirstOpnd);
+        s->SetOpnd(ImportExpression(func), kSecondOpnd);
+        stmt = s;
+        break;
+      }
+      case OP_iassignspoff:
+      case OP_iassignfpoff: {
+        IassignFPoffNode *s = func->GetCodeMemPool()->New<IassignFPoffNode>(op);
+        s->SetPrimType(static_cast<PrimType>(Read()));
+        s->SetOffset(static_cast<int32>(ReadNum()));
+        s->SetOpnd(ImportExpression(func), kFirstOpnd);
+        stmt = s;
+        break;
+      }
+      case OP_blkassignoff: {
+        BlkassignoffNode *s = func->GetCodeMemPool()->New<BlkassignoffNode>();
+        int32 offsetAlign = static_cast<int32>(ReadNum());
+        s->offset = offsetAlign >> kOffset4bit;
+        s->alignLog2 = offsetAlign & 0xf;
+        s->blockSize = static_cast<int32>(ReadNum());
+        s->SetOpnd(ImportExpression(func), kFirstOpnd);
+        s->SetOpnd(ImportExpression(func), kSecondOpnd);
+        stmt = s;
+        break;
+      }
+      case OP_call:
+      case OP_virtualcall:
+      case OP_virtualicall:
+      case OP_superclasscall:
+      case OP_interfacecall:
+      case OP_interfaceicall:
+      case OP_customcall: {
+        CallNode *s = func->GetCodeMemPool()->New<CallNode>(mod, op);
+        CHECK_NULL_FATAL(s);
+        s->SetPUIdx(ImportFuncViaSym(func));
+        MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(s->GetPUIdx());
+        CHECK_NULL_FATAL(f);
+        f->GetFuncSymbol()->SetAppearsInCode(true);
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_callassigned:
+      case OP_virtualcallassigned:
+      case OP_virtualicallassigned:
+      case OP_superclasscallassigned:
+      case OP_interfacecallassigned:
+      case OP_interfaceicallassigned:
+      case OP_customcallassigned: {
+        CallNode *s = func->GetCodeMemPool()->New<CallNode>(mod, op);
+        s->SetPUIdx(ImportFuncViaSym(func));
+        MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(s->GetPUIdx());
+        CHECK_NULL_FATAL(f);
+        f->GetFuncSymbol()->SetAppearsInCode(true);
+        ImportReturnValues(func, &s->GetReturnVec());
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        const auto &calleeName = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(s->GetPUIdx())->GetName();
+        if (calleeName == "setjmp") {
+          func->SetHasSetjmp();
+        }
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_polymorphiccall: {
+        CallNode *s = func->GetCodeMemPool()->New<CallNode>(mod, op);
+        CHECK_NULL_FATAL(s);
+        s->SetPUIdx(ImportFuncViaSym(func));
+        MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(s->GetPUIdx());
+        CHECK_NULL_FATAL(f);
+        f->GetFuncSymbol()->SetAppearsInCode(true);
+        s->SetTyIdx(ImportType());
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_polymorphiccallassigned: {
+        CallNode *s = func->GetCodeMemPool()->New<CallNode>(mod, op);
+        CHECK_NULL_FATAL(s);
+        s->SetPUIdx(ImportFuncViaSym(func));
+        MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(s->GetPUIdx());
+        CHECK_NULL_FATAL(f);
+        f->GetFuncSymbol()->SetAppearsInCode(true);
+        s->SetTyIdx(ImportType());
+        ImportReturnValues(func, &s->GetReturnVec());
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_icallproto:
+      case OP_icall: {
+        IcallNode *s = func->GetCodeMemPool()->New<IcallNode>(mod, op);
+        s->SetRetTyIdx(ImportType());
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_icallprotoassigned:
+      case OP_icallassigned: {
+        IcallNode *s = func->GetCodeMemPool()->New<IcallNode>(mod, op);
+        s->SetRetTyIdx(ImportType());
+        ImportReturnValues(func, &s->GetReturnVec());
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_intrinsiccall:
+      case OP_xintrinsiccall: {
+        IntrinsiccallNode *s = func->GetCodeMemPool()->New<IntrinsiccallNode>(mod, op);
+        s->SetIntrinsic(static_cast<MIRIntrinsicID>(ReadNum()));
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_intrinsiccallassigned:
+      case OP_xintrinsiccallassigned: {
+        IntrinsiccallNode *s = func->GetCodeMemPool()->New<IntrinsiccallNode>(mod, op);
+        s->SetIntrinsic((MIRIntrinsicID)ReadNum());
+        ImportReturnValues(func, &s->GetReturnVec());
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        if (s->GetReturnVec().size() == 1 && s->GetReturnVec()[0].first.Idx() != 0) {
+          MIRSymbol *retsymbol = func->GetSymTab()->GetSymbolFromStIdx(s->GetReturnVec()[0].first.Idx());
+          MIRType *rettype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retsymbol->GetTyIdx());
+          CHECK_FATAL(rettype != nullptr, "rettype is null in MIRParser::ParseStmtIntrinsiccallAssigned");
+          s->SetPrimType(rettype->GetPrimType());
+        }
+        stmt = s;
+        break;
+      }
+      case OP_intrinsiccallwithtype: {
+        IntrinsiccallNode *s = func->GetCodeMemPool()->New<IntrinsiccallNode>(mod, op);
+        s->SetIntrinsic((MIRIntrinsicID)ReadNum());
+        s->SetTyIdx(ImportType());
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_intrinsiccallwithtypeassigned: {
+        IntrinsiccallNode *s = func->GetCodeMemPool()->New<IntrinsiccallNode>(mod, op);
+        s->SetIntrinsic((MIRIntrinsicID)ReadNum());
+        s->SetTyIdx(ImportType());
+        ImportReturnValues(func, &s->GetReturnVec());
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        if (s->GetReturnVec().size() == 1 && s->GetReturnVec()[0].first.Idx() != 0) {
+          MIRSymbol *retsymbol = func->GetSymTab()->GetSymbolFromStIdx(s->GetReturnVec()[0].first.Idx());
+          MIRType *rettype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retsymbol->GetTyIdx());
+          CHECK_FATAL(rettype != nullptr, "rettype is null in MIRParser::ParseStmtIntrinsiccallAssigned");
+          s->SetPrimType(rettype->GetPrimType());
+        }
+        stmt = s;
+        break;
+      }
+      case OP_syncenter:
+      case OP_syncexit:
+      case OP_return: {
+        NaryStmtNode *s = func->GetCodeMemPool()->New<NaryStmtNode>(mod, op);
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_jscatch:
+      case OP_cppcatch:
+      case OP_finally:
+      case OP_endtry:
+      case OP_cleanuptry:
+      case OP_retsub:
+      case OP_membaracquire:
+      case OP_membarrelease:
+      case OP_membarstorestore:
+      case OP_membarstoreload: {
+        stmt = mod.CurFuncCodeMemPool()->New<StmtNode>(op);
+        break;
+      }
+      case OP_eval:
+      case OP_throw:
+      case OP_free:
+      case OP_decref:
+      case OP_incref:
+      case OP_decrefreset:
+      CASE_OP_ASSERT_NONNULL
+      case OP_igoto: {
+        UnaryStmtNode *s = mod.CurFuncCodeMemPool()->New<UnaryStmtNode>(op);
+        s->SetOpnd(ImportExpression(func), kFirstOpnd);
+        stmt = s;
+        break;
+      }
+      case OP_label: {
+        LabelNode *s = mod.CurFuncCodeMemPool()->New<LabelNode>();
+        s->SetLabelIdx(ImportLabel(func));
+        stmt = s;
+        break;
+      }
+      case OP_goto:
+      case OP_gosub: {
+        GotoNode *s = mod.CurFuncCodeMemPool()->New<GotoNode>(op);
+        s->SetOffset(ImportLabel(func));
+        stmt = s;
+        break;
+      }
+      case OP_brfalse:
+      case OP_brtrue: {
+        CondGotoNode *s = mod.CurFuncCodeMemPool()->New<CondGotoNode>(op);
+        s->SetOffset(ImportLabel(func));
+        s->SetOpnd(ImportExpression(func), kFirstOpnd);
+        stmt = s;
+        break;
+      }
+      case OP_switch: {
+        SwitchNode *s = mod.CurFuncCodeMemPool()->New<SwitchNode>(mod);
+        s->SetDefaultLabel(ImportLabel(func));
+        auto tagSize = static_cast<uint32>(ReadNum());
+        for (uint32 i = 0; i < tagSize; ++i) {
+          int64 casetag = ReadNum();
+          LabelIdx lidx = ImportLabel(func);
+          CasePair cpair = std::make_pair(casetag, lidx);
+          s->GetSwitchTable().push_back(cpair);
+        }
+        s->SetSwitchOpnd(ImportExpression(func));
+        stmt = s;
+        break;
+      }
+      case OP_rangegoto: {
+        RangeGotoNode *s = mod.CurFuncCodeMemPool()->New<RangeGotoNode>(mod);
+        s->SetTagOffset(static_cast<int32>(ReadNum()));
+        uint32 tagSize = static_cast<uint32>(ReadNum());
+        for (uint32 i = 0; i < tagSize; ++i) {
+          uint16 casetag = static_cast<uint16>(ReadNum());
+          LabelIdx lidx = ImportLabel(func);
+          s->AddRangeGoto(casetag, lidx);
+        }
+        s->SetOpnd(ImportExpression(func), kFirstOpnd);
+        stmt = s;
+        break;
+      }
+      case OP_jstry: {
+        JsTryNode *s = mod.CurFuncCodeMemPool()->New<JsTryNode>();
+        s->SetCatchOffset(ImportLabel(func));
+        s->SetFinallyOffset(ImportLabel(func));
+        stmt = s;
+        break;
+      }
+      case OP_cpptry:
+      case OP_try: {
+        TryNode *s = mod.CurFuncCodeMemPool()->New<TryNode>(mod);
+        auto numLabels = static_cast<uint32>(ReadNum());
+        for (uint32 i = 0; i < numLabels; ++i) {
+          s->GetOffsets().push_back(ImportLabel(func));
+        }
+        stmt = s;
+        break;
+      }
+      case OP_catch: {
+        CatchNode *s = mod.CurFuncCodeMemPool()->New<CatchNode>(mod);
+        auto numTys = static_cast<uint32>(ReadNum());
+        for (uint32 i = 0; i < numTys; ++i) {
+          s->PushBack(ImportType());
+        }
+        stmt = s;
+        break;
+      }
+      case OP_comment: {
+        CommentNode *s = mod.CurFuncCodeMemPool()->New<CommentNode>(mod);
+        string str;
+        ReadAsciiStr(str);
+        s->SetComment(str);
+        stmt = s;
+        break;
+      }
+      case OP_dowhile:
+      case OP_while: {
+        WhileStmtNode *s = mod.CurFuncCodeMemPool()->New<WhileStmtNode>(op);
+        s->SetBody(ImportBlockNode(func));
+        s->SetOpnd(ImportExpression(func), kFirstOpnd);
+        stmt = s;
+        break;
+      }
+      case OP_if: {
+        IfStmtNode *s = mod.CurFuncCodeMemPool()->New<IfStmtNode>();
+        bool hasElsePart = (static_cast<size_t>(ReadNum()) != kFirstOpnd);
+        s->SetThenPart(ImportBlockNode(func));
+        if (hasElsePart) {
+          s->SetElsePart(ImportBlockNode(func));
+          s->SetNumOpnds(kOperandNumTernary);
+        }
+        s->SetOpnd(ImportExpression(func), kFirstOpnd);
+        stmt = s;
+        break;
+      }
+      case OP_block: {
+        stmt = ImportBlockNode(func);
+        break;
+      }
+      case OP_asm: {
+        AsmNode *s = mod.CurFuncCodeMemPool()->New<AsmNode>(&mod.GetCurFuncCodeMPAllocator());
+        mod.CurFunction()->SetHasAsm();
+        s->qualifiers = static_cast<uint32>(ReadNum());
+        string str;
+        ReadAsciiStr(str);
+        s->asmString = str;
+        // the outputs
+        auto count = static_cast<size_t>(ReadNum());
+        UStrIdx strIdx;
+        for (size_t i = 0; i < count; ++i) {
+          strIdx = ImportUsrStr();
+          s->outputConstraints.push_back(strIdx);
+        }
+        ImportReturnValues(func, &s->asmOutputs);
+        // the clobber list
+        count = static_cast<size_t>(ReadNum());
+        for (size_t i = 0; i < count; ++i) {
+          strIdx = ImportUsrStr();
+          s->clobberList.push_back(strIdx);
+        }
+        // the labels
+        count = static_cast<size_t>(ReadNum());
+        for (size_t i = 0; i < count; ++i) {
+          LabelIdx lidx = ImportLabel(func);
+          s->gotoLabels.push_back(lidx);
+        }
+        // the inputs
+        numOpr = static_cast<uint8>(ReadNum());
+        s->SetNumOpnds(numOpr);
+        for (int32 i = 0; i < numOpr; ++i) {
+          strIdx = ImportUsrStr();
+          s->inputConstraints.push_back(strIdx);
+          const std::string &inStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(strIdx);
+          if (inStr[0] == '+') {
+            s->SetHasWriteInputs();
+          }
+        }
+        for (int32 i = 0; i < numOpr; ++i) {
+          s->GetNopnd().push_back(ImportExpression(func));
+        }
+        stmt = s;
+        break;
+      }
+      default:
+        CHECK_FATAL(false, "Unhandled opcode tag %d", tag);
+        break;
+    }
+    stmt->SetSrcPos(thesrcPosition);
+    block->AddStatement(stmt);
+  }
+  if (func != nullptr) {
+    func->SetBody(block);
+  }
+  return block;
+}
+
+void BinaryMplImport::ReadFunctionBodyField() {
+  (void)ReadInt();  /// skip total size
+  int32 size = ReadInt();
+  for (int64 i = 0; i < size; ++i) {
+    PUIdx puIdx = ImportFunction();
+    MIRFunction *fn = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+    CHECK_NULL_FATAL(fn);
+    mod.SetCurFunction(fn);
+    fn->GetFuncSymbol()->SetAppearsInCode(true);
+    localSymTab.clear();
+    localSymTab.push_back(nullptr);
+    localPregTab.clear();
+    localPregTab.push_back(0);
+    localLabelTab.clear();
+    localLabelTab.push_back(0);
+
+    fn->AllocSymTab();
+    fn->AllocPregTab();
+    fn->AllocTypeNameTab();
+    fn->AllocLabelTab();
+
+    ImportFuncIdInfo(fn);
+    ImportLocalTypeNameTable(fn->GetTypeNameTab());
+    ImportFormalsStIdx(fn);
+    if (mod.GetFlavor() < kMmpl) {
+      ImportAliasMap(fn);
+    }
+    (void)ImportBlockNode(fn);
+    mod.AddFunction(fn);
+  }
+  return;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/bin_mpl_export.cpp b/src/mapleall/maple_ir/src/bin_mpl_export.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0054948e965286fba38cee355b3b93e81e8f2c40
--- /dev/null
+++ b/src/mapleall/maple_ir/src/bin_mpl_export.cpp
@@ -0,0 +1,1368 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bin_mpl_export.h"
+#include <sstream>
+#include <vector>
+#include "mir_function.h"
+#include "namemangler.h"
+#include "opcode_info.h"
+#include "mir_pragma.h"
+#include "bin_mplt.h"
+#include "factory.h"
+
+namespace {
+using namespace maple;
+/* Storage location of field  */
+constexpr uint32 kFirstField = 0;
+constexpr uint32 kSecondField = 1;
+constexpr uint32 kThirdField = 2;
+constexpr uint32 kFourthField = 3;
+constexpr int32 kFourthFieldInt = 3;
+constexpr uint32 kFifthField = 4;
+constexpr int32 kSixthFieldInt = 5;
+
+using OutputConstFactory = FunctionFactory<MIRConstKind, void, MIRConst&, BinaryMplExport&>;
+using OutputTypeFactory = FunctionFactory<MIRTypeKind, void, MIRType&, BinaryMplExport&>;
+
+void OutputConstInt(const MIRConst &constVal, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindConstInt);
+  mplExport.OutputConstBase(constVal);
+  mplExport.WriteNum(static_cast<const MIRIntConst&>(constVal).GetExtValue());
+}
+
+void OutputConstAddrof(const MIRConst &constVal, BinaryMplExport &mplExport) {
+  const MIRAddrofConst &addrof = static_cast<const MIRAddrofConst&>(constVal);
+  if (addrof.GetSymbolIndex().IsGlobal()) {
+    mplExport.WriteNum(kBinKindConstAddrof);
+  } else {
+    mplExport.WriteNum(kBinKindConstAddrofLocal);
+  }
+  mplExport.OutputConstBase(constVal);
+  if (addrof.GetSymbolIndex().IsGlobal()) {
+    mplExport.OutputSymbol(mplExport.GetMIRModule().CurFunction()->GetLocalOrGlobalSymbol(addrof.GetSymbolIndex()));
+  } else {
+    mplExport.OutputLocalSymbol(mplExport.curFunc->GetLocalOrGlobalSymbol(addrof.GetSymbolIndex()));
+  }
+  mplExport.WriteNum(addrof.GetFieldID());
+  mplExport.WriteNum(addrof.GetOffset());
+}
+
+void OutputConstAddrofFunc(const MIRConst &constVal, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindConstAddrofFunc);
+  mplExport.OutputConstBase(constVal);
+  const auto &newConst = static_cast<const MIRAddroffuncConst&>(constVal);
+  mplExport.OutputFunction(newConst.GetValue());
+}
+
+void OutputConstLbl(const MIRConst &constVal, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindConstAddrofLabel);
+  mplExport.OutputConstBase(constVal);
+  const MIRLblConst &lblConst = static_cast<const MIRLblConst &>(constVal);
+  mplExport.OutputLabel(lblConst.GetValue());
+}
+
+void OutputConstStr(const MIRConst &constVal, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindConstStr);
+  mplExport.OutputConstBase(constVal);
+  const auto &newConst = static_cast<const MIRStrConst&>(constVal);
+  mplExport.OutputUsrStr(newConst.GetValue());
+}
+
+void OutputConstStr16(const MIRConst &constVal, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindConstStr16);
+  mplExport.OutputConstBase(constVal);
+  const auto &mirStr16 = static_cast<const MIRStr16Const&>(constVal);
+  std::u16string str16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(mirStr16.GetValue());
+  std::string str;
+  (void)namemangler::UTF16ToUTF8(str, str16);
+  mplExport.WriteNum(str.length());
+  for (char c : str) {
+    mplExport.Write(static_cast<uint8>(c));
+  }
+}
+
+void OutputConstFloat(const MIRConst &constVal, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindConstFloat);
+  mplExport.OutputConstBase(constVal);
+  const auto &newConst = static_cast<const MIRFloatConst&>(constVal);
+  mplExport.WriteNum(newConst.GetIntValue());
+}
+
+void OutputConstDouble(const MIRConst &constVal, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindConstDouble);
+  mplExport.OutputConstBase(constVal);
+  const auto &newConst = static_cast<const MIRDoubleConst&>(constVal);
+  mplExport.WriteNum(newConst.GetIntValue());
+}
+
+void OutputConstAgg(const MIRConst &constVal, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindConstAgg);
+  mplExport.OutputConstBase(constVal);
+  const auto &aggConst = static_cast<const MIRAggConst&>(constVal);
+  size_t size = aggConst.GetConstVec().size();
+  mplExport.WriteNum(size);
+  for (size_t i = 0; i < size; ++i) {
+    mplExport.WriteNum(aggConst.GetFieldIdItem(i));
+    mplExport.OutputConst(aggConst.GetConstVecItem(i));
+  }
+}
+
+void OutputConstSt(MIRConst &constVal, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindConstSt);
+  mplExport.OutputConstBase(constVal);
+  auto &stConst = static_cast<MIRStConst&>(constVal);
+  size_t size = stConst.GetStVec().size();
+  mplExport.WriteNum(size);
+  for (size_t i = 0; i < size; ++i) {
+    mplExport.OutputSymbol(stConst.GetStVecItem(i));
+  }
+  size = stConst.GetStOffsetVec().size();
+  mplExport.WriteNum(size);
+  for (size_t i = 0; i < size; ++i) {
+    mplExport.WriteNum(stConst.GetStOffsetVecItem(i));
+  }
+}
+
+static bool InitOutputConstFactory() {
+  RegisterFactoryFunction<OutputConstFactory>(kConstInt, OutputConstInt);
+  RegisterFactoryFunction<OutputConstFactory>(kConstAddrof, OutputConstAddrof);
+  RegisterFactoryFunction<OutputConstFactory>(kConstAddrofFunc, OutputConstAddrofFunc);
+  RegisterFactoryFunction<OutputConstFactory>(kConstLblConst, OutputConstLbl);
+  RegisterFactoryFunction<OutputConstFactory>(kConstStrConst, OutputConstStr);
+  RegisterFactoryFunction<OutputConstFactory>(kConstStr16Const, OutputConstStr16);
+  RegisterFactoryFunction<OutputConstFactory>(kConstFloatConst, OutputConstFloat);
+  RegisterFactoryFunction<OutputConstFactory>(kConstDoubleConst, OutputConstDouble);
+  RegisterFactoryFunction<OutputConstFactory>(kConstAggConst, OutputConstAgg);
+  RegisterFactoryFunction<OutputConstFactory>(kConstStConst, OutputConstSt);
+  return true;
+}
+
+void OutputTypeScalar(const MIRType &ty, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindTypeScalar);
+  mplExport.OutputTypeBase(ty);
+}
+
+void OutputTypePointer(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRPtrType&>(ty);
+  mplExport.WriteNum(kBinKindTypePointer);
+  mplExport.OutputTypeBase(type);
+  mplExport.OutputTypeAttrs(type.GetTypeAttrs());
+  mplExport.OutputType(type.GetPointedTyIdx());
+}
+
+void OutputTypeByName(const MIRType &ty, BinaryMplExport &mplExport) {
+  mplExport.WriteNum(kBinKindTypeByName);
+  mplExport.OutputTypeBase(ty);
+}
+
+void OutputTypeFArray(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRFarrayType&>(ty);
+  mplExport.WriteNum(kBinKindTypeFArray);
+  mplExport.OutputTypeBase(type);
+  mplExport.OutputType(type.GetElemTyIdx());
+}
+
+void OutputTypeJArray(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRJarrayType&>(ty);
+  mplExport.WriteNum(kBinKindTypeJarray);
+  mplExport.OutputTypeBase(type);
+  mplExport.OutputType(type.GetElemTyIdx());
+}
+
+void OutputTypeArray(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRArrayType&>(ty);
+  mplExport.WriteNum(kBinKindTypeArray);
+  mplExport.OutputTypeBase(type);
+  mplExport.WriteNum(type.GetDim());
+  for (uint16 i = 0; i < type.GetDim(); ++i) {
+    mplExport.WriteNum(type.GetSizeArrayItem(i));
+  }
+  mplExport.OutputType(type.GetElemTyIdx());
+  mplExport.OutputTypeAttrs(type.GetTypeAttrs());
+}
+
+void OutputTypeFunction(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRFuncType&>(ty);
+  mplExport.WriteNum(kBinKindTypeFunction);
+  mplExport.OutputTypeBase(type);
+  mplExport.OutputType(type.GetRetTyIdx());
+  mplExport.WriteNum(static_cast<int64_t>(type.funcAttrs.GetAttrFlag()));
+  size_t size = type.GetParamTypeList().size();
+  mplExport.WriteNum(size);
+  for (size_t i = 0; i < size; ++i) {
+    mplExport.OutputType(type.GetNthParamType(i));
+  }
+  size = type.GetParamAttrsList().size();
+  mplExport.WriteNum(size);
+  for (size_t i = 0; i < size; ++i) {
+    mplExport.OutputTypeAttrs(type.GetNthParamAttrs(i));
+  }
+}
+
+void OutputTypeParam(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRTypeParam&>(ty);
+  mplExport.WriteNum(kBinKindTypeParam);
+  mplExport.OutputTypeBase(type);
+}
+
+void OutputTypeInstantVector(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRInstantVectorType&>(ty);
+  mplExport.WriteNum(kBinKindTypeInstantVector);
+  mplExport.OutputTypeBase(type);
+  mplExport.WriteNum(ty.GetKind());
+  mplExport.OutputTypePairs(type);
+}
+
+void OutputTypeGenericInstant(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRGenericInstantType&>(ty);
+  mplExport.WriteNum(kBinKindTypeGenericInstant);
+  mplExport.OutputTypeBase(type);
+  mplExport.OutputTypePairs(type);
+  mplExport.OutputType(type.GetGenericTyIdx());
+}
+
+void OutputTypeBitField(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRBitFieldType&>(ty);
+  mplExport.WriteNum(kBinKindTypeBitField);
+  mplExport.OutputTypeBase(type);
+  mplExport.WriteNum(type.GetFieldSize());
+}
+
+// for Struct/StructIncomplete/Union
+void OutputTypeStruct(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRStructType&>(ty);
+  mplExport.WriteNum(kBinKindTypeStruct);
+  mplExport.OutputTypeBase(type);
+  MIRTypeKind kind = ty.GetKind();
+  if (type.IsImported()) {
+    CHECK_FATAL(ty.GetKind() != kTypeUnion, "Must be.");
+    kind = kTypeStructIncomplete;
+  }
+  mplExport.WriteNum(kind);
+  mplExport.OutputTypeAttrs(type.GetTypeAttrs());
+  if (kind != kTypeStructIncomplete) {
+    mplExport.OutputStructTypeData(type);
+  }
+}
+
+void OutputTypeClass(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRClassType&>(ty);
+  mplExport.WriteNum(kBinKindTypeClass);
+  mplExport.OutputTypeBase(type);
+  MIRTypeKind kind = ty.GetKind();
+  if (type.IsImported()) {
+    kind = kTypeClassIncomplete;
+  }
+  mplExport.WriteNum(kind);
+  if (kind != kTypeClassIncomplete) {
+    mplExport.OutputStructTypeData(type);
+    mplExport.OutputClassTypeData(type);
+  }
+}
+
+void OutputTypeInterface(const MIRType &ty, BinaryMplExport &mplExport) {
+  const auto &type = static_cast<const MIRInterfaceType&>(ty);
+  mplExport.WriteNum(kBinKindTypeInterface);
+  mplExport.OutputTypeBase(type);
+  MIRTypeKind kind = ty.GetKind();
+  if (type.IsImported()) {
+    kind = kTypeInterfaceIncomplete;
+  }
+  mplExport.WriteNum(kind);
+  if (kind != kTypeInterfaceIncomplete) {
+    mplExport.OutputStructTypeData(type);
+    mplExport.OutputInterfaceTypeData(type);
+  }
+}
+
+void OutputTypeConstString(const MIRType &ty, BinaryMplExport&) {
+  ASSERT(false, "Type's kind not yet implemented: %d", ty.GetKind());
+  (void)ty;
+}
+
+static bool InitOutputTypeFactory() {
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeScalar, OutputTypeScalar);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypePointer, OutputTypePointer);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeByName, OutputTypeByName);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeFArray, OutputTypeFArray);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeJArray, OutputTypeJArray);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeArray, OutputTypeArray);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeFunction, OutputTypeFunction);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeParam, OutputTypeParam);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeInstantVector, OutputTypeInstantVector);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeGenericInstant, OutputTypeGenericInstant);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeBitField, OutputTypeBitField);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeStruct, OutputTypeStruct);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeStructIncomplete, OutputTypeStruct);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeUnion, OutputTypeStruct);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeClass, OutputTypeClass);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeClassIncomplete, OutputTypeClass);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeInterface, OutputTypeInterface);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeInterfaceIncomplete, OutputTypeInterface);
+  RegisterFactoryFunction<OutputTypeFactory>(kTypeConstString, OutputTypeConstString);
+  return true;
+}
+};  // namespace
+
+namespace maple {
+int BinaryMplExport::typeMarkOffset = 0;
+
+BinaryMplExport::BinaryMplExport(MIRModule &md) : mod(md) {
+  bufI = 0;
+  Init();
+  (void)InitOutputConstFactory();
+  (void)InitOutputTypeFactory();
+  not2mplt = false;
+}
+
+uint8 BinaryMplExport::Read() {
+  CHECK_FATAL(bufI < buf.size(), "Index out of bound in BinaryMplImport::Read()");
+  return buf[bufI++];
+}
+
+// Little endian
+int32 BinaryMplExport::ReadInt() {
+  uint32 x0 = static_cast<uint32>(Read());
+  uint32 x1 = static_cast<uint32>(Read());
+  uint32 x2 = static_cast<uint32>(Read());
+  uint32 x3 = static_cast<uint32>(Read());
+  int32 x = static_cast<int32>((((((x3 << 8) + x2) << 8) + x1) << 8) + x0);
+  return x;
+}
+
+void BinaryMplExport::Write(uint8 b) {
+  buf.push_back(b);
+}
+
+// Little endian
+void BinaryMplExport::WriteInt(int32 x) {
+  Write(static_cast<uint8>(static_cast<uint32>(x) & 0xFF));
+  Write(static_cast<uint8>((static_cast<uint32>(x) >> 8) & 0xFF));
+  Write(static_cast<uint8>((static_cast<uint32>(x) >> 16) & 0xFF));
+  Write(static_cast<uint8>((static_cast<uint32>(x) >> 24) & 0xFF));
+}
+
+void BinaryMplExport::ExpandFourBuffSize() {
+  WriteInt(0);
+}
+
+void BinaryMplExport::Fixup(size_t i, uint32 x) {
+  constexpr int fixupCount = 4;
+  CHECK(i <= buf.size() - fixupCount, "Index out of bound in BinaryMplImport::Fixup()");
+  buf[i] = static_cast<uint8>(x & 0xFF);
+  buf[i + 1] = static_cast<uint8>((x >> 8) & 0xFF);
+  buf[i + 2] = static_cast<uint8>((x >> 16) & 0xFF);
+  buf[i + 3] = static_cast<uint8>((x >> 24) & 0xFF);
+}
+
+void BinaryMplExport::WriteInt64(int64 x) {
+  WriteInt(static_cast<int32>(static_cast<uint64>(x) & 0xFFFFFFFF));
+  WriteInt(static_cast<int32>((static_cast<uint64>(x) >> 32) & 0xFFFFFFFF));
+}
+
+// LEB128
+void BinaryMplExport::WriteNum(int64 x) {
+  while (x < -0x40 || x >= 0x40) {
+    Write(static_cast<uint8>((static_cast<uint64>(x) & 0x7F) + 0x80));
+    x = x >> 7; // This is a compress algorithm, do not cast int64 to uint64. If do so, small negtivate number like -3
+                // will occupy 9 bits and we will not get the compressed benefit.
+  }
+  Write(static_cast<uint8>(static_cast<uint64>(x) & 0x7F));
+}
+
+void BinaryMplExport::WriteAsciiStr(const std::string &str) {
+  WriteNum(static_cast<int64>(str.size()));
+  for (size_t i = 0; i < str.size(); ++i) {
+    Write(static_cast<uint8>(str[i]));
+  }
+}
+
+void BinaryMplExport::DumpBuf(const std::string &name) {
+  FILE *f = fopen(name.c_str(), "wb");
+  if (f == nullptr) {
+    LogInfo::MapleLogger(kLlErr) << "Error while creating the binary file: " << name << '\n';
+    FATAL(kLncFatal, "Error while creating the binary file: %s\n", name.c_str());
+  }
+  size_t size = buf.size();
+  size_t k = fwrite(&buf[0], sizeof(uint8), size, f);
+  fclose(f);
+  if (k != size) {
+    LogInfo::MapleLogger(kLlErr) << "Error while writing the binary file: " << name << '\n';
+  }
+}
+
+void BinaryMplExport::OutputConstBase(const MIRConst &constVal) {
+  WriteNum(constVal.GetKind());
+  OutputType(constVal.GetType().GetTypeIndex());
+}
+
+void BinaryMplExport::OutputConst(MIRConst *constVal) {
+  if (constVal == nullptr) {
+    WriteNum(0);
+  } else {
+    auto func = CreateProductFunction<OutputConstFactory>(constVal->GetKind());
+    if (func != nullptr) {
+      func(*constVal, *this);
+    }
+  }
+}
+
+void BinaryMplExport::OutputStr(const GStrIdx &gstr) {
+  if (gstr == 0u) {
+    WriteNum(0);
+    return;
+  }
+
+  auto it = gStrMark.find(gstr);
+  if (it != gStrMark.end()) {
+    WriteNum(-(it->second));
+    return;
+  }
+
+  size_t mark = gStrMark.size();
+  gStrMark[gstr] = mark;
+  WriteNum(kBinString);
+  ASSERT(GlobalTables::GetStrTable().StringTableSize() != 0, "Container check");
+  WriteAsciiStr(GlobalTables::GetStrTable().GetStringFromStrIdx(gstr));
+}
+
+void BinaryMplExport::OutputUsrStr(UStrIdx ustr) {
+  if (ustr == 0u) {
+    WriteNum(0);
+    return;
+  }
+
+  auto it = uStrMark.find(ustr);
+  if (it != uStrMark.end()) {
+    WriteNum(-(it->second));
+    return;
+  }
+
+  size_t mark = uStrMark.size();
+  uStrMark[ustr] = mark;
+  WriteNum(kBinUsrString);
+  WriteAsciiStr(GlobalTables::GetUStrTable().GetStringFromStrIdx(ustr));
+}
+
+void BinaryMplExport::OutputPragmaElement(const MIRPragmaElement &e) {
+  OutputStr(e.GetNameStrIdx());
+  OutputStr(e.GetTypeStrIdx());
+  WriteNum(e.GetType());
+
+  if (e.GetType() == kValueString || e.GetType() == kValueType || e.GetType() == kValueField ||
+      e.GetType() == kValueMethod || e.GetType() == kValueEnum) {
+    OutputStr(GStrIdx(e.GetI32Val()));
+  } else {
+    WriteInt64(e.GetU64Val());
+  }
+  size_t size = e.GetSubElemVec().size();
+  WriteNum(size);
+  for (size_t i = 0; i < size; ++i) {
+    OutputPragmaElement(*(e.GetSubElement(i)));
+  }
+}
+
+void BinaryMplExport::OutputPragma(const MIRPragma &p) {
+  WriteNum(p.GetKind());
+  WriteNum(p.GetVisibility());
+  OutputStr(p.GetStrIdx());
+  OutputType(p.GetTyIdx());
+  OutputType(p.GetTyIdxEx());
+  WriteNum(p.GetParamNum());
+  size_t size = p.GetElementVector().size();
+  WriteNum(size);
+  for (size_t i = 0; i < size; ++i) {
+    OutputPragmaElement(*(p.GetNthElement(i)));
+  }
+}
+
+void BinaryMplExport::OutputTypeBase(const MIRType &type) {
+  WriteNum(type.GetPrimType());
+  OutputStr(type.GetNameStrIdx());
+  WriteNum(type.IsNameIsLocal());
+}
+
+void BinaryMplExport::OutputFieldPair(const FieldPair &fp) {
+  OutputStr(fp.first);          // GStrIdx
+  OutputType(fp.second.first);  // TyIdx
+  FieldAttrs fa = fp.second.second;
+  WriteNum(fa.GetAttrFlag());
+  WriteNum(fa.GetAlignValue());
+  if (fa.GetAttr(FLDATTR_static) && fa.GetAttr(FLDATTR_final) &&
+      (fa.GetAttr(FLDATTR_public) || fa.GetAttr(FLDATTR_protected))) {
+    const std::string &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fp.first);
+    MIRSymbol *fieldVar = mod.GetMIRBuilder()->GetGlobalDecl(fieldName);
+    if ((fieldVar != nullptr) && (fieldVar->GetKonst() != nullptr) &&
+        (fieldVar->GetKonst()->GetKind() == kConstStr16Const)) {
+      WriteNum(kBinInitConst);
+      OutputConst(fieldVar->GetKonst());
+    } else {
+      WriteNum(0);
+    }
+  }
+}
+
+void BinaryMplExport::OutputMethodPair(const MethodPair &memPool) {
+  // use GStrIdx instead, StIdx will be created by ImportMethodPair
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(memPool.first.Idx());
+  CHECK_FATAL(funcSt != nullptr, "Pointer funcSt is nullptr, can't get symbol! Check it!");
+  WriteAsciiStr(GlobalTables::GetStrTable().GetStringFromStrIdx(funcSt->GetNameStrIdx()));
+  OutputType(memPool.second.first);               // TyIdx
+  WriteNum(memPool.second.second.GetAttrFlag());  // FuncAttrs
+}
+
+void BinaryMplExport::OutputFieldsOfStruct(const FieldVector &fields) {
+  WriteNum(fields.size());
+  for (const FieldPair &fp : fields) {
+    OutputFieldPair(fp);
+  }
+}
+
+void BinaryMplExport::OutputMethodsOfStruct(const MethodVector &methods) {
+  WriteNum(methods.size());
+  for (const MethodPair &memPool : methods) {
+    OutputMethodPair(memPool);
+  }
+}
+
+void BinaryMplExport::OutputStructTypeData(const MIRStructType &type) {
+  OutputFieldsOfStruct(type.GetFields());
+  OutputFieldsOfStruct(type.GetStaticFields());
+  OutputFieldsOfStruct(type.GetParentFields());
+  OutputMethodsOfStruct(type.GetMethods());
+}
+
+void BinaryMplExport::OutputImplementedInterfaces(const std::vector<TyIdx> &interfaces) {
+  WriteNum(interfaces.size());
+  for (const TyIdx &tyIdx : interfaces) {
+    OutputType(tyIdx);
+  }
+}
+
+void BinaryMplExport::OutputInfoIsString(const std::vector<bool> &infoIsString) {
+  WriteNum(infoIsString.size());
+  for (bool isString : infoIsString) {
+    WriteNum(static_cast<int64>(isString));
+  }
+}
+
+void BinaryMplExport::OutputInfo(const std::vector<MIRInfoPair> &info, const std::vector<bool> &infoIsString) {
+  size_t size = info.size();
+  WriteNum(size);
+  for (size_t i = 0; i < size; ++i) {
+    OutputStr(info[i].first);  // GStrIdx
+    if (infoIsString[i]) {
+      OutputStr(GStrIdx(info[i].second));
+    } else {
+      WriteNum(info[i].second);
+    }
+  }
+}
+
+void BinaryMplExport::OutputPragmaVec(const std::vector<MIRPragma*> &pragmaVec) {
+  WriteNum(pragmaVec.size());
+  for (MIRPragma *pragma : pragmaVec) {
+    OutputPragma(*pragma);
+  }
+}
+
+void BinaryMplExport::OutputClassTypeData(const MIRClassType &type) {
+  OutputType(type.GetParentTyIdx());
+  OutputImplementedInterfaces(type.GetInterfaceImplemented());
+  OutputInfoIsString(type.GetInfoIsString());
+  if (!inIPA) {
+    OutputInfo(type.GetInfo(), type.GetInfoIsString());
+    OutputPragmaVec(type.GetPragmaVec());
+  }
+}
+
+void BinaryMplExport::OutputInterfaceTypeData(const MIRInterfaceType &type) {
+  OutputImplementedInterfaces(type.GetParentsTyIdx());
+  OutputInfoIsString(type.GetInfoIsString());
+  if (!inIPA) {
+    OutputInfo(type.GetInfo(), type.GetInfoIsString());
+    OutputPragmaVec(type.GetPragmaVec());
+  }
+}
+
+void BinaryMplExport::Init() {
+  BinaryMplExport::typeMarkOffset = 0;
+  gStrMark.clear();
+  uStrMark.clear();
+  symMark.clear();
+  funcMark.clear();
+  typMark.clear();
+  gStrMark[GStrIdx(0)] = 0;
+  uStrMark[UStrIdx(0)] = 0;
+  symMark[nullptr] = 0;
+  funcMark[nullptr] = 0;
+  eaNodeMark[nullptr] = 0;
+  curFunc = nullptr;
+  for (uint32 pti = static_cast<int32>(PTY_begin); pti < static_cast<uint32>(PTY_end); ++pti) {
+    typMark[GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(pti))] = pti;
+  }
+}
+
+void BinaryMplExport::OutputSymbol(MIRSymbol *sym) {
+  if (sym == nullptr) {
+    WriteNum(0);
+    return;
+  }
+
+  std::unordered_map<const MIRSymbol*, int64>::iterator it = symMark.find(sym);
+  if (it != symMark.end()) {
+    WriteNum(-(it->second));
+    return;
+  }
+
+  WriteNum(kBinSymbol);
+  WriteNum(sym->GetScopeIdx());
+  OutputStr(sym->GetNameStrIdx());
+  OutputUsrStr(sym->sectionAttr);
+  OutputUsrStr(sym->GetAsmAttr());
+  WriteNum(sym->GetSKind());
+  WriteNum(sym->GetStorageClass());
+  size_t mark = symMark.size();
+  symMark[sym] = mark;
+  OutputTypeAttrs(sym->GetAttrs());
+  WriteNum(sym->GetIsTmp() ? 1 : 0);
+  if (sym->GetSKind() == kStPreg) {
+    WriteNum(sym->GetPreg()->GetPregNo());
+  } else if (sym->GetSKind() == kStConst || sym->GetSKind() == kStVar) {
+    if (sym->GetKonst() != nullptr) {
+      sym->GetKonst()->SetType(*sym->GetType());
+    }
+    OutputConst(sym->GetKonst());
+  } else if (sym->GetSKind() == kStFunc) {
+    OutputFunction(sym->GetFunction()->GetPuidx());
+  } else if (sym->GetSKind() == kStJavaClass || sym->GetSKind() == kStJavaInterface) {
+  } else {
+    CHECK_FATAL(false, "should not used");
+  }
+  if (sym->GetSKind() == kStVar || sym->GetSKind() == kStFunc) {
+    OutputSrcPos(sym->GetSrcPosition());
+  }
+  OutputType(sym->GetTyIdx());
+}
+
+void BinaryMplExport::OutputFunction(PUIdx puIdx) {
+  if (puIdx == 0) {
+    WriteNum(0);
+    mod.SetCurFunction(nullptr);
+    return;
+  }
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  CHECK_FATAL(func != nullptr, "Cannot get MIRFunction.");
+  auto it = funcMark.find(func);
+  if (it != funcMark.end()) {
+    WriteNum(-it->second);
+    mod.SetCurFunction(func);
+    return;
+  }
+  size_t mark = funcMark.size();
+  funcMark[func] = mark;
+  MIRFunction *savedFunc = mod.CurFunction();
+  mod.SetCurFunction(func);
+
+  WriteNum(kBinFunction);
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
+  CHECK_FATAL(funcSt != nullptr, "Pointer funcSt is nullptr, cannot get symbol! Check it!");
+  OutputSymbol(funcSt);
+  OutputType(func->GetMIRFuncType()->GetTypeIndex());
+  WriteNum(func->GetFuncAttrs().GetAttrFlag());
+
+  auto &attributes = func->GetFuncAttrs();
+  if (attributes.GetAttr(FUNCATTR_constructor_priority)) {
+    WriteNum(attributes.GetConstructorPriority());
+  }
+
+  if (attributes.GetAttr(FUNCATTR_destructor_priority)) {
+    WriteNum(attributes.GetDestructorPriority());
+  }
+
+  WriteNum(func->GetFlag());
+  OutputType(func->GetClassTyIdx());
+  // output formal parameter information
+  WriteNum(static_cast<int64>(func->GetFormalDefVec().size()));
+  for (FormalDef formalDef : func->GetFormalDefVec()) {
+    OutputStr(formalDef.formalStrIdx);
+    OutputType(formalDef.formalTyIdx);
+    WriteNum(static_cast<int64>(formalDef.formalAttrs.GetAttrFlag()));
+  }
+  //  store Side Effect for each func
+  if (func2SEMap) {
+    uint32 isSee = func->IsIpaSeen() == true ? 1 : 0;
+    uint32 isPure = func->IsPure() == true ? 1 : 0;
+    uint32 noDefArg = func->IsNoDefArgEffect() == true ? 1 : 0;
+    uint32 noDef = func->IsNoDefEffect() == true ? 1 : 0;
+    uint32 noRetGlobal = func->IsNoRetGlobal() == true ? 1 : 0;
+    uint32 noThr = func->IsNoThrowException() == true ? 1 : 0;
+    uint32 noRetArg = func->IsNoRetArg() == true ? 1 : 0;
+    uint32 noPriDef = func->IsNoPrivateDefEffect() == true ? 1 : 0;
+    uint32 i = 0;
+    uint8 se = noThr << i++;
+    se |= noRetGlobal << i++;
+    se |= noDef << i++;
+    se |= noDefArg << i++;
+    se |= isPure << i++;
+    se |= isSee << i++;
+    se |= noRetArg << i++;
+    se |= noPriDef << i;
+    if ((*func2SEMap).find(func->GetNameStrIdx()) == (*func2SEMap).end()) {
+      (*func2SEMap)[func->GetNameStrIdx()] = se;
+    } else if ((*func2SEMap)[func->GetNameStrIdx()] != se) {
+      FATAL(kLncFatal, "It is a bug.");
+    }
+  }
+  mod.SetCurFunction(savedFunc);
+}
+
+void BinaryMplExport::WriteStrField(uint64 contentIdx) {
+  Fixup(contentIdx, buf.size());
+  WriteNum(kBinStrStart);
+  size_t totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  // total size of this field to ~BIN_STR_START
+  size_t outStrSizeIdx = buf.size();
+  ExpandFourBuffSize();  // size of OutputStr
+
+  uint32 size = 0;
+  for (const auto &entity : GlobalTables::GetConstPool().GetConstU16StringPool()) {
+    MIRSymbol *sym = entity.second;
+    if (sym->IsLiteral()) {
+      OutputStr(sym->GetNameStrIdx());
+      ++size;
+    }
+  }
+  Fixup(totalSizeIdx, static_cast<uint32>(buf.size() - totalSizeIdx));
+  Fixup(outStrSizeIdx, size);
+  WriteNum(~kBinStrStart);
+}
+
+void BinaryMplExport::WriteHeaderField(uint64 contentIdx) {
+  Fixup(contentIdx, buf.size());
+  WriteNum(kBinHeaderStart);
+  size_t totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  // total size of this field to ~BIN_IMPORT_START
+  WriteNum(mod.GetFlavor());
+  WriteNum(mod.GetSrcLang());
+  WriteNum(mod.GetID());
+  if (mod.GetFlavor() == kFlavorLmbc) {
+    WriteNum(mod.GetGlobalMemSize());
+    int64 dbgInfo = mod.IsWithDbgInfo() ? 1 : 0;
+    WriteNum(dbgInfo);
+  }
+  WriteNum(mod.GetNumFuncs());
+  WriteAsciiStr(mod.GetEntryFuncName());
+  OutputInfoVector(mod.GetFileInfo(), mod.GetFileInfoIsString());
+
+  if (mod.IsWithDbgInfo()) {
+    WriteNum(static_cast<int64>(mod.GetSrcFileInfo().size()));
+    for (uint32 i = 0; i < mod.GetSrcFileInfo().size(); i++) {
+      OutputStr(mod.GetSrcFileInfo()[i].first);
+      WriteNum(mod.GetSrcFileInfo()[i].second);
+    }
+  } else {
+    Write(0);
+  }
+
+  WriteNum(static_cast<int64>(mod.GetImportFiles().size()));
+  for (GStrIdx strIdx : mod.GetImportFiles()) {
+    OutputStr(strIdx);
+  }
+
+  WriteNum(static_cast<int64>(mod.GetAsmDecls().size()));
+  for (MapleString mapleStr : mod.GetAsmDecls()) {
+    std::string str(mapleStr.c_str());
+    WriteAsciiStr(str);
+  }
+
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  WriteNum(~kBinHeaderStart);
+  return;
+}
+
+void BinaryMplExport::WriteTypeField(uint64 contentIdx, bool useClassList) {
+  Fixup(contentIdx, buf.size());
+  WriteNum(kBinTypeStart);
+  size_t totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  // total size of this field to ~BIN_TYPE_START
+  size_t outTypeSizeIdx = buf.size();
+  ExpandFourBuffSize();  // size of OutputType
+  uint32 size = 0;
+  if (useClassList) {
+    for (uint32 tyIdx : mod.GetClassList()) {
+      TyIdx curTyidx(tyIdx);
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(curTyidx);
+      CHECK_FATAL(type != nullptr, "Pointer type is nullptr, cannot get type, check it!");
+      if (type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface) {
+        auto *structType = static_cast<MIRStructType*>(type);
+        // skip imported class/interface and incomplete types
+        if (!structType->IsImported() && !structType->IsIncomplete()) {
+          OutputType(curTyidx);
+          ++size;
+        }
+      }
+    }
+  } else {
+    uint32 idx = GlobalTables::GetTypeTable().lastDefaultTyIdx.GetIdx();
+    for (idx = idx + 1; idx < GlobalTables::GetTypeTable().GetTypeTableSize(); idx++) {
+      OutputType(TyIdx(idx));
+      size++;
+    }
+  }
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  Fixup(outTypeSizeIdx, size);
+  WriteNum(~kBinTypeStart);
+}
+
+void BinaryMplExport::OutputCallInfo(CallInfo &callInfo) {
+  auto it = callInfoMark.find(callInfo.GetID());
+  if (it != callInfoMark.end()) {
+    WriteNum(-(it->second));
+    return;
+  }
+  WriteNum(kBinCallinfo);
+  size_t mark = callInfoMark.size();
+  callInfoMark[callInfo.GetID()] = mark;
+  WriteNum(callInfo.GetCallType());  // call type
+  WriteInt(callInfo.GetLoopDepth());
+  WriteInt(callInfo.GetID());
+  callInfo.AreAllArgsLocal() ? Write(1) : Write(0); // All args are local variables or not.
+  OutputSymbol(callInfo.GetFunc()->GetFuncSymbol());
+}
+
+void BinaryMplExport::WriteCgField(uint64 contentIdx, const CallGraph *cg) {
+  if (contentIdx != 0) {
+    Fixup(contentIdx, buf.size());
+  }
+  WriteNum(kBinCgStart);
+  size_t totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  // total size of this field to ~BIN_CG_START
+  size_t outcgSizeIdx = buf.size();
+  ExpandFourBuffSize();  // size of OutCG
+  uint32 size = 0;
+  if (cg != nullptr) {
+    for (auto entry : cg->GetNodesMap()) {
+      MIRSymbol *methodSym = entry.first->GetFuncSymbol();
+      WriteNum(kStartMethod);
+      OutputSymbol(methodSym);
+      size_t targetTyIdx = buf.size();
+      ExpandFourBuffSize();
+      int32 targSize = 0;
+      callInfoMark.clear();
+      callInfoMark[0xffffffff] = 0;
+      for (const auto &callSite : entry.second->GetCallee()) {
+        OutputCallInfo(*(callSite.first));
+        ++targSize;
+      }
+      Fixup(targetTyIdx, static_cast<uint32>(targSize));
+      WriteNum(~kStartMethod);
+      ++size;
+    }
+  }
+
+  ASSERT((buf.size() - totalSizeIdx) <= 0xffffffff, "Integer overflow.");
+  Fixup(totalSizeIdx, static_cast<uint32>(buf.size() - totalSizeIdx));
+  Fixup(outcgSizeIdx, size);
+  WriteNum(~kBinCgStart);
+}
+
+void BinaryMplExport::WriteSeField() {
+  ASSERT(func2SEMap != nullptr, "Expecting a func2SE map");
+  WriteNum(kBinSeStart);
+  size_t totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  // total size of this field to ~BIN_SYM_START
+  size_t outseSizeIdx = buf.size();
+  ExpandFourBuffSize();  // size of OutSym
+  uint32 size = 0;
+
+  for (const auto &func2SE : *func2SEMap) {
+    uint8 se = func2SE.second;
+    if (se != 0) {
+      OutputStr(func2SE.first);
+      Write(se);
+      if ((se & kPureFunc) == kPureFunc) {
+        const std::string &funcStr = GlobalTables::GetStrTable().GetStringFromStrIdx(func2SE.first);
+        auto *funcSymbol =
+            GlobalTables::GetGsymTable().GetSymbolFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(funcStr));
+        MIRFunction *func = (funcSymbol != nullptr) ? GetMIRModule().GetMIRBuilder()->GetFunctionFromSymbol(*funcSymbol)
+                                                    : nullptr;
+        OutputType(func->GetReturnTyIdx());
+      }
+      ++size;
+    }
+  }
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  Fixup(outseSizeIdx, size);
+  WriteNum(~kBinSeStart);
+}
+
+void BinaryMplExport::OutEaCgBaseNode(const EACGBaseNode &node, bool firstPart) {
+  if (firstPart) {
+    WriteNum(node.eaStatus);
+    WriteInt(static_cast<int32>(node.id));
+  } else {
+    // in and out set in base node is not necessary to be outed
+    // start to out point-to set
+    size_t outP2SizeIdx = buf.size();
+    WriteInt(0);
+    uint32 size = 0;
+    for (EACGBaseNode *outNode : node.GetPointsToSet()) {
+      OutEaCgNode(*outNode);
+      ++size;
+    }
+    Fixup(outP2SizeIdx, size);
+    // start to out in set
+    outP2SizeIdx = buf.size();
+    WriteInt(0);
+    size = 0;
+    for (EACGBaseNode *outNode : node.GetInSet()) {
+      OutEaCgNode(*outNode);
+      ++size;
+    }
+    Fixup(outP2SizeIdx, size);
+    // start to out out set
+    outP2SizeIdx = buf.size();
+    WriteInt(0);
+    size = 0;
+    for (EACGBaseNode *outNode : node.GetOutSet()) {
+      OutEaCgNode(*outNode);
+      ++size;
+    }
+    Fixup(outP2SizeIdx, size);
+  }
+}
+
+void BinaryMplExport::OutEaCgObjNode(EACGObjectNode &obj) {
+  Write(uint8(obj.isPhantom));
+  size_t outFieldSizeIdx = buf.size();
+  WriteInt(0);
+  uint32 size = 0;
+  for (const auto &fieldNodePair : obj.fieldNodes) {
+    EACGBaseNode *fieldNode = fieldNodePair.second;
+    ASSERT(fieldNodePair.first == static_cast<EACGFieldNode*>(fieldNode)->GetFieldID(), "Must be.");
+    OutEaCgNode(*fieldNode);
+    ++size;
+  }
+  Fixup(outFieldSizeIdx, size);
+  // start to out point by
+  outFieldSizeIdx = buf.size();
+  WriteInt(0);
+  size = 0;
+  for (EACGBaseNode *node : obj.pointsBy) {
+    OutEaCgNode(*node);
+    ++size;
+  }
+  Fixup(outFieldSizeIdx, size);
+}
+
+void BinaryMplExport::OutEaCgRefNode(const EACGRefNode &ref) {
+  Write(uint8(ref.isStaticField));
+}
+
+void BinaryMplExport::OutEaCgFieldNode(EACGFieldNode &field) {
+  WriteInt(field.GetFieldID());
+  uint32 size = 0;
+  size_t outFieldSizeIdx = buf.size();
+  WriteInt(0);
+  for (EACGBaseNode *obj : field.belongsTo) {
+    OutEaCgNode(*obj);
+    ++size;
+  }
+  Fixup(outFieldSizeIdx, size);
+  Write(uint8(field.isPhantom));
+}
+
+void BinaryMplExport::OutEaCgActNode(const EACGActualNode &act) {
+  Write(uint8(act.isPhantom));
+  Write(uint8(act.isReturn));
+  Write(act.argIdx);
+  WriteInt(act.callSiteInfo);
+}
+
+void BinaryMplExport::OutEaCgNode(EACGBaseNode &node) {
+  auto it = eaNodeMark.find(&node);
+  if (it != eaNodeMark.end()) {
+    WriteNum(-it->second);
+    return;
+  }
+  size_t mark = eaNodeMark.size();
+  eaNodeMark[&node] = mark;
+  WriteNum(kBinEaCgNode);
+  WriteNum(node.kind);
+  OutEaCgBaseNode(node, true);
+  if (node.IsActualNode()) {
+    WriteNum(kBinEaCgActNode);
+    OutEaCgActNode(static_cast<EACGActualNode&>(node));
+  } else if (node.IsFieldNode()) {
+    WriteNum(kBinEaCgFieldNode);
+    OutEaCgFieldNode(static_cast<EACGFieldNode&>(node));
+  } else if (node.IsObjectNode()) {
+    WriteNum(kBinEaCgObjNode);
+    OutEaCgObjNode(static_cast<EACGObjectNode&>(node));
+  } else if (node.IsReferenceNode()) {
+    WriteNum(kBinEaCgRefNode);
+    OutEaCgRefNode(static_cast<EACGRefNode&>(node));
+  } else {
+    ASSERT(false, "Must be.");
+  }
+  OutEaCgBaseNode(node, false);
+  WriteNum(~kBinEaCgNode);
+}
+
+void BinaryMplExport::WriteEaField(const CallGraph &cg) {
+  WriteNum(kBinEaStart);
+  uint64 totalSizeIdx = buf.size();
+  WriteInt(0);
+  uint64 outeaSizeIdx = buf.size();
+  WriteInt(0);
+  uint32 size = 0;
+  for (auto cgNodePair : cg.GetNodesMap()) {
+    MIRFunction *func = cgNodePair.first;
+    if (func->GetEACG() == nullptr) {
+      continue;
+    }
+    EAConnectionGraph *eacg = func->GetEACG();
+    ASSERT(eacg != nullptr, "Must be.");
+    OutputStr(eacg->GetFuncNameStrIdx());
+    WriteInt(eacg->GetNodes().size());
+    OutEaCgNode(*eacg->GetGlobalObject());
+    uint64 outFunceaIdx = buf.size();
+    WriteInt(0);
+    size_t funceaSize = 0;
+    for (EACGBaseNode *node : eacg->GetFuncArgNodes()) {
+      OutEaCgNode(*node);
+      ++funceaSize;
+    }
+    Fixup(outFunceaIdx, funceaSize);
+    ++size;
+  }
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  Fixup(outeaSizeIdx, size);
+  WriteNum(~kBinEaStart);
+}
+
+void BinaryMplExport::WriteEaCgField(EAConnectionGraph *eaCg) {
+  if (eaCg == nullptr) {
+    WriteNum(~kBinEaCgStart);
+    return;
+  }
+  WriteNum(kBinEaCgStart);
+  size_t totalSizeIdx = buf.size();
+  WriteInt(0);
+  // out this function's arg list
+  OutputStr(eaCg->GetFuncNameStrIdx());
+  WriteInt(static_cast<int32>(eaCg->GetNodes().size()));
+  OutEaCgNode(*eaCg->GetGlobalObject());
+  size_t outNodeSizeIdx = buf.size();
+  WriteInt(0);
+  size_t argNodeSize = 0;
+  for (EACGBaseNode *node : eaCg->GetFuncArgNodes()) {
+    OutEaCgNode(*node);
+    ++argNodeSize;
+  }
+  Fixup(outNodeSizeIdx, argNodeSize);
+  // out this function's call site's arg list
+  outNodeSizeIdx = buf.size();
+  WriteInt(0);
+  size_t callSiteSize = 0;
+  for (auto nodePair : eaCg->GetCallSite2Nodes()) {
+    uint32 id = nodePair.first;
+    MapleVector<EACGBaseNode*> *calleeArgNode = nodePair.second;
+    WriteInt(id);
+    size_t outCalleeArgSizeIdx = buf.size();
+    WriteInt(0);
+    size_t calleeArgSize = 0;
+    for (EACGBaseNode *node : *calleeArgNode) {
+      OutEaCgNode(*node);
+      ++calleeArgSize;
+    }
+    Fixup(outCalleeArgSizeIdx, calleeArgSize);
+    ++callSiteSize;
+  }
+  Fixup(outNodeSizeIdx, callSiteSize);
+
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  WriteNum(~kBinEaCgStart);
+}
+
+void BinaryMplExport::WriteEnumField(uint64 contentIdx) {
+  if (GlobalTables::GetEnumTable().enumTable.empty()) {
+    return;
+  }
+  Fixup(contentIdx, static_cast<uint32>(buf.size()));
+  WriteNum(kBinEnumStart);
+  uint64 totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  // total size of this field to ~BIN_SYM_START
+  uint64 outEnumSizeIdx = buf.size();
+  ExpandFourBuffSize();  // size of OutEnum
+  uint32 size = 0;
+  for (MIREnum *mirEnum : GlobalTables::GetEnumTable().enumTable) {
+    OutputEnumeration(mirEnum);
+    size++;
+  }
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  Fixup(outEnumSizeIdx, size);
+  WriteNum(~kBinEnumStart);
+  return;
+}
+
+void BinaryMplExport::WriteSymField(uint64 contentIdx) {
+  Fixup(contentIdx, buf.size());
+  WriteNum(kBinSymStart);
+  uint64 totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  // total size of this field to ~BIN_SYM_START
+  uint64 outsymSizeIdx = buf.size();
+  ExpandFourBuffSize();  // size of OutSym
+  uint32 size = 0;
+
+  if (not2mplt) {
+    for (auto sit = GetMIRModule().GetSymbolDefOrder().begin();
+         sit != GetMIRModule().GetSymbolDefOrder().end(); ++sit) {
+      MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx(sit->Idx());
+      ASSERT(s != nullptr, "null ptr check");
+      // Verify: all wpofake variables should have been deleted from globaltable
+      ASSERT(!(s->IsWpoFakeParm() || s->IsWpoFakeRet()) || s->IsDeleted(), "wpofake var not deleted");
+      MIRStorageClass storageClass = s->GetStorageClass();
+      MIRSymKind sKind = s->GetSKind();
+      if (s->IsDeleted() || storageClass == kScUnused ||
+          (s->GetIsImported() && !s->GetAppearsInCode()) ||
+          (sKind == kStFunc &&
+           ((storageClass == kScExtern && !s->GetFunction()->GetAttr(FUNCATTR_used)) ||
+            !s->GetAppearsInCode()))) {
+        continue;
+      }
+      OutputSymbol(s);
+      size++;
+    }
+  }
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  Fixup(outsymSizeIdx, size);
+  WriteNum(~kBinSymStart);
+  return;
+}
+
+void BinaryMplExport::WriteContentField4mplt(int fieldNum, uint64 *fieldStartP) {
+  WriteNum(kBinContentStart);
+  size_t totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  // total size of this field to ~BIN_SYM_START
+
+  WriteInt(fieldNum);  // size of Content item
+
+  WriteNum(kBinStrStart);
+  fieldStartP[0] = buf.size();
+  ExpandFourBuffSize();
+
+  WriteNum(kBinTypeStart);
+  fieldStartP[1] = buf.size();
+  ExpandFourBuffSize();
+
+  WriteNum(kBinCgStart);
+  fieldStartP[2] = buf.size();
+  ExpandFourBuffSize();
+
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  WriteNum(~kBinContentStart);
+}
+
+void BinaryMplExport::WriteContentField4nonmplt(int fieldNum, uint64 *fieldStartP) {
+  CHECK_FATAL(fieldStartP != nullptr, "fieldStartP is null.");
+  WriteNum(kBinContentStart);
+  size_t totalSizeIdx = buf.size();
+  ExpandFourBuffSize(); // total size of this field to ~BIN_SYM_START
+
+  WriteInt(fieldNum);  // size of Content item
+
+  WriteNum(kBinHeaderStart);
+  fieldStartP[kFirstField] = buf.size();
+  ExpandFourBuffSize();
+
+  WriteNum(kBinSymStart);
+  fieldStartP[kSecondField] = buf.size();
+  ExpandFourBuffSize();
+
+  WriteNum(kBinFunctionBodyStart);
+  fieldStartP[kThirdField] = buf.size();
+  ExpandFourBuffSize();
+
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  WriteNum(~kBinContentStart);
+}
+
+void BinaryMplExport::WriteContentField4nonJava(int fieldNum, uint64 *fieldStartP) {
+  CHECK_FATAL(fieldStartP != nullptr, "fieldStartP is null.");
+  WriteNum(kBinContentStart);
+  size_t totalSizeIdx = buf.size();
+  ExpandFourBuffSize();  // total size of this field to ~BIN_SYM_START
+
+  WriteInt(fieldNum);  // size of Content item
+
+  WriteNum(kBinHeaderStart);
+  fieldStartP[kFirstField] = buf.size();
+  ExpandFourBuffSize();
+
+  WriteNum(kBinStrStart);
+  fieldStartP[kSecondField] = buf.size();
+  ExpandFourBuffSize();
+
+  WriteNum(kBinEnumStart);
+  fieldStartP[kThirdField] = buf.size();
+  ExpandFourBuffSize();
+
+  WriteNum(kBinSymStart);
+  fieldStartP[kFourthField] = buf.size();
+  ExpandFourBuffSize();
+
+  WriteNum(kBinFunctionBodyStart);
+  fieldStartP[kFifthField] = buf.size();
+  ExpandFourBuffSize();
+
+  Fixup(totalSizeIdx, buf.size() - totalSizeIdx);
+  WriteNum(~kBinContentStart);
+}
+
+void BinaryMplExport::Export(const std::string &fname, std::unordered_set<std::string> *dumpFuncSet) {
+  uint64 fieldStartPoint[5];
+  if (!not2mplt) {
+    WriteInt(kMpltMagicNumber);
+    WriteContentField4mplt(kFourthFieldInt, fieldStartPoint);
+    WriteStrField(fieldStartPoint[kFirstField]);
+    WriteTypeField(fieldStartPoint[kSecondField]);
+    WriteCgField(fieldStartPoint[kThirdField], nullptr);
+    importFileName = fname;
+  } else {
+    WriteInt(kMpltMagicNumber + 0x10);
+    if (mod.IsJavaModule()) {
+      WriteContentField4nonmplt(kFourthFieldInt, fieldStartPoint);
+      WriteHeaderField(fieldStartPoint[kFirstField]);
+      WriteSymField(fieldStartPoint[kSecondField]);
+      WriteFunctionBodyField(fieldStartPoint[kThirdField], dumpFuncSet);
+    } else {
+      WriteContentField4nonJava(kSixthFieldInt, fieldStartPoint);
+      WriteHeaderField(fieldStartPoint[kFirstField]);
+      WriteEnumField(fieldStartPoint[kThirdField]);
+      WriteSymField(fieldStartPoint[kFourthField]);
+      WriteFunctionBodyField(fieldStartPoint[kFifthField], dumpFuncSet);
+    }
+  }
+  WriteNum(kBinFinish);
+  DumpBuf(fname);
+}
+
+void BinaryMplExport::AppendAt(const std::string &name, int32 offset) {
+  FILE *f = fopen(name.c_str(), "r+b");
+  if (f == nullptr) {
+    LogInfo::MapleLogger(kLlErr) << "Error while opening the binary file: " << name << '\n';
+    FATAL(kLncFatal, "Error while creating the binary file: %s\n", name.c_str());
+  }
+  int seekRet = fseek(f, static_cast<long int>(offset), SEEK_SET);
+  CHECK_FATAL(seekRet == 0, "Call fseek failed.");
+  size_t size = buf.size();
+  size_t k = fwrite(&buf[0], sizeof(uint8), size, f);
+  fclose(f);
+  if (k != size) {
+    LogInfo::MapleLogger(kLlErr) << "Error while writing the binary file: " << name << '\n';
+  }
+}
+
+void BinaryMplExport::OutputTypePairs(const MIRInstantVectorType &type) {
+  size_t size = type.GetInstantVec().size();
+  WriteNum(size);
+  for (const TypePair &typePair : type.GetInstantVec()) {
+    OutputType(typePair.first);
+    OutputType(typePair.second);
+  }
+}
+
+void BinaryMplExport::OutputTypeAttrs(const TypeAttrs &ta) {
+  WriteNum(ta.GetAttrFlag());
+  WriteNum(ta.GetAlignValue());
+  WriteNum(ta.GetPack());
+}
+
+void BinaryMplExport::OutputType(const TyIdx &tyIdx) {
+  if (tyIdx == 0u) {
+    WriteNum(0);
+    return;
+  }
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  CHECK_FATAL(ty != nullptr, "If gets nulltype, should have been returned!");
+  auto it = typMark.find(ty);
+  if (it != typMark.end()) {
+    if (ty->GetKind() != kTypeFunction) {
+      WriteNum(-(it->second));
+      return;
+    }
+    ++BinaryMplExport::typeMarkOffset;
+  } else {
+    size_t mark = typMark.size() + BinaryMplExport::typeMarkOffset;
+    typMark[ty] = mark;
+  }
+
+  auto func = CreateProductFunction<OutputTypeFactory>(ty->GetKind());
+  if (func != nullptr) {
+    func(*ty, *this);
+  } else {
+    ASSERT(false, "Type's kind not yet implemented: %d", ty->GetKind());
+  }
+}
+
+void BinaryMplExport::OutputEnumeration(MIREnum *mirEnum) {
+  WriteNum(kBinEnumeration);
+  Write(static_cast<uint8>(mirEnum->GetPrimType()));
+  OutputStr(mirEnum->GetNameIdx());
+  WriteNum(static_cast<int64>(mirEnum->GetElements().size()));
+  for (size_t i = 0; i < mirEnum->GetElements().size(); ++i) {
+    OutputStr(mirEnum->GetElements()[i].first);
+    WriteNum(mirEnum->GetElements()[i].second.GetSXTValue());
+  }
+}
+
+void UpdateMplt::UpdateCgField(BinaryMplt &binMplt, const CallGraph &cg) const {
+  BinaryMplImport &binImport = binMplt.GetBinImport();
+  BinaryMplExport &binExport = binMplt.GetBinExport();
+  binImport.SetBufI(0);
+  if (binImport.IsBufEmpty() || binImport.ReadInt() != kMpltMagicNumber) {
+    INFO(kLncInfo, " This Module depends on nothing");
+    return;
+  }
+  int64 cgStart = binImport.GetContent(kBinCgStart);
+  ASSERT(cgStart != 0, "Should be updated in import processing.");
+  binImport.SetBufI(cgStart);
+  int64 checkReadNum = binImport.ReadNum();
+  ASSERT(checkReadNum == kBinCgStart, "Should be cg start point.");
+  int32 totalSize = binImport.ReadInt();
+  constexpr int32 headLen = 4;
+  binImport.SetBufI(binImport.GetBufI() + totalSize - headLen);
+  checkReadNum = binImport.ReadNum();
+  ASSERT(checkReadNum == ~kBinCgStart, "Should be end of cg.");
+  binExport.Init();
+  std::map<GStrIdx, uint8> tmp;
+  binExport.func2SEMap = &tmp;
+  binExport.inIPA = true;
+  binExport.WriteCgField(0, &cg);
+  binExport.Init();
+  binExport.WriteSeField();
+  binExport.eaNodeMark.clear();
+  binExport.eaNodeMark[nullptr] = 0;
+  binExport.gStrMark.clear();
+  binExport.gStrMark[GStrIdx(0)] = 0;
+  binExport.WriteEaField(cg);
+  binExport.WriteNum(kBinFinish);
+  std::string filename(binMplt.GetImportFileName());
+  binExport.AppendAt(filename, cgStart);
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/bin_mpl_import.cpp b/src/mapleall/maple_ir/src/bin_mpl_import.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7cf1827eb5b4dc800e2f9063c38d2b86fb02ca40
--- /dev/null
+++ b/src/mapleall/maple_ir/src/bin_mpl_import.cpp
@@ -0,0 +1,1700 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bin_mpl_import.h"
+#include <sstream>
+#include <vector>
+#include <unordered_set>
+#include <limits>
+#include "bin_mplt.h"
+#include "mir_function.h"
+#include "namemangler.h"
+#include "opcode_info.h"
+#include "mir_pragma.h"
+#include "mir_builder.h"
+
+namespace maple {
+uint8 BinaryMplImport::Read() {
+  CHECK_FATAL(bufI < buf.size(), "Index out of bound in BinaryMplImport::Read()");
+  return buf[bufI++];
+}
+
+// Little endian
+int32 BinaryMplImport::ReadInt() {
+  uint32 x0 = static_cast<uint32>(Read());
+  uint32 x1 = static_cast<uint32>(Read());
+  uint32 x2 = static_cast<uint32>(Read());
+  uint32 x3 = static_cast<uint32>(Read());
+  return (((((x3 << 8u) + x2) << 8u) + x1) << 8u) + x0;
+}
+
+int64 BinaryMplImport::ReadInt64() {
+  // casts to avoid sign extension
+  uint32 x0 = static_cast<uint32>(ReadInt());
+  uint64 x1 = static_cast<uint32>(ReadInt());
+  return static_cast<int64>((x1 << 32) + x0);
+}
+
+// LEB128
+int64 BinaryMplImport::ReadNum() {
+  uint64 n = 0;
+  int64 y = 0;
+  uint64 b = static_cast<uint64>(Read());
+  while (b >= 0x80) {
+    y += ((b - 0x80) << n);
+    n += 7;
+    b = static_cast<uint64>(Read());
+  }
+  b = (b & 0x3F) - (b & 0x40);
+  return y + (b << n);
+}
+
+void BinaryMplImport::ReadAsciiStr(std::string &str) {
+  int64 n = ReadNum();
+  for (int64 i = 0; i < n; i++) {
+    uint8 ch = Read();
+    str.push_back(static_cast<char>(ch));
+  }
+}
+
+void BinaryMplImport::ReadFileAt(const std::string &name, int32 offset) {
+  FILE *f = fopen(name.c_str(), "rb");
+  CHECK_FATAL(f != nullptr, "Error while reading the binary file: %s", name.c_str());
+
+  int seekRet = fseek(f, 0, SEEK_END);
+  CHECK_FATAL(seekRet == 0, "call fseek failed");
+
+  long size = ftell(f);
+  size -= offset;
+
+  CHECK_FATAL(size >= 0, "should not be negative");
+
+  seekRet = fseek(f, offset, SEEK_SET);
+  CHECK_FATAL(seekRet == 0, "call fseek failed");
+  buf.resize(size);
+
+  size_t result = fread(&buf[0], sizeof(uint8), static_cast<size_t>(size), f);
+  fclose(f);
+  CHECK_FATAL(result == static_cast<size_t>(size), "Error while reading the binary file: %s", name.c_str());
+}
+
+void BinaryMplImport::ImportConstBase(MIRConstKind &kind, MIRTypePtr &type) {
+  kind = static_cast<MIRConstKind>(ReadNum());
+  TyIdx tyidx = mod.IsJavaModule() ? ImportType() : ImportTypeNonJava();
+  type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx);
+}
+
+MIRConst *BinaryMplImport::ImportConst(MIRFunction *func) {
+  int64 tag = ReadNum();
+  if (tag == 0) {
+    return nullptr;
+  }
+
+  MIRConstKind kind;
+  MIRType *type = nullptr;
+  MemPool *memPool = mod.GetMemPool();
+
+  ImportConstBase(kind, type);
+  switch (tag) {
+    case kBinKindConstInt:
+      return GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<uint64_t>(ReadNum()), *type);
+    case kBinKindConstAddrof: {
+      MIRSymbol *sym = InSymbol(func);
+      CHECK_FATAL(sym != nullptr, "null ptr check");
+      FieldID fi = ReadNum();
+      int32 ofst = static_cast<int32>(ReadNum());
+      // do not use "type"; instead, get exprTy from sym
+      TyIdx ptyIdx = sym->GetTyIdx();
+      MIRPtrType ptrType(ptyIdx, (mod.IsJavaModule() ? PTY_ref : GetExactPtrPrimType()));
+      ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+      MIRType *exprTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
+      return memPool->New<MIRAddrofConst>(sym->GetStIdx(), fi, *exprTy, ofst);
+    }
+    case kBinKindConstAddrofLocal: {
+      MIRSymbol *sym = ImportLocalSymbol(func);
+      FieldID fi = static_cast<FieldID>(ReadNum());
+      int32 ofst = static_cast<int32>(ReadNum());
+      return memPool->New<MIRAddrofConst>(sym->GetStIdx(), fi, *type, ofst);
+    }
+    case kBinKindConstAddrofFunc: {
+      PUIdx puIdx = ImportFunction();
+      MIRFunction *f = GlobalTables::GetFunctionTable().GetFuncTable()[puIdx];
+      CHECK_NULL_FATAL(f);
+      f->GetFuncSymbol()->SetAppearsInCode(true);
+      mod.SetCurFunction(func);
+      return memPool->New<MIRAddroffuncConst>(puIdx, *type);
+    }
+    case kBinKindConstAddrofLabel: {
+      LabelIdx lidx = ImportLabel(func);
+      PUIdx puIdx = func->GetPuidx();
+      MIRLblConst *lblConst = memPool->New<MIRLblConst>(lidx, puIdx, *type);
+      (void)func->GetLabelTab()->addrTakenLabels.insert(lidx);
+      return lblConst;
+    }
+    case kBinKindConstStr: {
+      UStrIdx ustr = ImportUsrStr();
+      return memPool->New<MIRStrConst>(ustr, *type);
+    }
+    case kBinKindConstStr16: {
+      Conststr16Node *cs = memPool->New<Conststr16Node>();
+      cs->SetPrimType(type->GetPrimType());
+      int64 len = ReadNum();
+      std::ostringstream ostr;
+      for (int64 i = 0; i < len; ++i) {
+        ostr << Read();
+      }
+      std::u16string str16;
+      (void)namemangler::UTF8ToUTF16(str16, ostr.str());
+      cs->SetStrIdx(GlobalTables::GetU16StrTable().GetOrCreateStrIdxFromName(str16));
+      return memPool->New<MIRStr16Const>(cs->GetStrIdx(), *type);
+    }
+    case kBinKindConstFloat: {
+      union {
+        float fvalue;
+        int32 ivalue;
+      } value;
+
+      value.ivalue = ReadNum();
+      return GlobalTables::GetFpConstTable().GetOrCreateFloatConst(value.fvalue);
+    }
+    case kBinKindConstDouble: {
+      union {
+        double dvalue;
+        int64 ivalue;
+      } value;
+
+      value.ivalue = ReadNum();
+      return GlobalTables::GetFpConstTable().GetOrCreateDoubleConst(value.dvalue);
+    }
+    case kBinKindConstAgg: {
+      MIRAggConst *aggConst = mod.GetMemPool()->New<MIRAggConst>(mod, *type);
+      int64 size = ReadNum();
+      for (int64 i = 0; i < size; ++i) {
+        auto fieldId = static_cast<uint32>(ReadNum());
+        auto fieldConst = ImportConst(func);
+        aggConst->AddItem(fieldConst, fieldId);
+      }
+      return aggConst;
+    }
+    case kBinKindConstSt: {
+      MIRStConst *stConst = mod.GetMemPool()->New<MIRStConst>(mod, *type);
+      int64 size = ReadNum();
+      for (int64 i = 0; i < size; ++i) {
+        stConst->PushbackSymbolToSt(InSymbol(func));
+      }
+      size = ReadNum();
+      for (int64 i = 0; i < size; ++i) {
+        stConst->PushbackOffsetToSt(ReadNum());
+      }
+      return stConst;
+    }
+    default:
+      CHECK_FATAL(false, "Unhandled const type");
+  }
+}
+
+GStrIdx BinaryMplImport::ImportStr() {
+  int64 tag = ReadNum();
+  if (tag == 0) {
+    return GStrIdx(0);
+  }
+  if (tag < 0) {
+    CHECK_FATAL(-tag < static_cast<int64>(gStrTab.size()), "index out of range in BinaryMplt::ImportStr");
+    return gStrTab[-tag];
+  }
+  CHECK_FATAL(tag == kBinString, "expecting kBinString");
+  std::string str;
+  ReadAsciiStr(str);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
+  gStrTab.push_back(strIdx);
+  return strIdx;
+}
+
+UStrIdx BinaryMplImport::ImportUsrStr() {
+  int64 tag = ReadNum();
+  if (tag == 0) {
+    return UStrIdx(0);
+  }
+  if (tag < 0) {
+    CHECK_FATAL(-tag < static_cast<int64>(uStrTab.size()), "index out of range in BinaryMplt::InUsrStr");
+    return uStrTab[-tag];
+  }
+  CHECK_FATAL(tag == kBinUsrString, "expecting kBinUsrString");
+  std::string str;
+  ReadAsciiStr(str);
+  UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str);
+  uStrTab.push_back(strIdx);
+  return strIdx;
+}
+
+MIRPragmaElement *BinaryMplImport::ImportPragmaElement() {
+  MIRPragmaElement *element = mod.GetPragmaMemPool()->New<MIRPragmaElement>(mod);
+  element->SetNameStrIdx(ImportStr());
+  element->SetTypeStrIdx(ImportStr());
+  element->SetType(static_cast<PragmaValueType>(ReadNum()));
+  if (element->GetType() == kValueString || element->GetType() == kValueType || element->GetType() == kValueField ||
+      element->GetType() == kValueMethod || element->GetType() == kValueEnum) {
+    element->SetI32Val(static_cast<int32>(ImportStr()));
+  } else {
+    element->SetU64Val(static_cast<uint64>(ReadInt64()));
+  }
+  int64 size = ReadNum();
+  for (int64 i = 0; i < size; ++i) {
+    element->SubElemVecPushBack(ImportPragmaElement());
+  }
+  return element;
+}
+
+MIRPragma *BinaryMplImport::ImportPragma() {
+  MIRPragma *p = mod.GetPragmaMemPool()->New<MIRPragma>(mod);
+  p->SetKind(static_cast<PragmaKind>(ReadNum()));
+  p->SetVisibility(ReadNum());
+  p->SetStrIdx(ImportStr());
+  if (mod.IsJavaModule()) {
+    p->SetTyIdx(ImportType());
+    p->SetTyIdxEx(ImportType());
+  } else {
+    p->SetTyIdx(ImportTypeNonJava());
+    p->SetTyIdxEx(ImportTypeNonJava());
+  }
+  p->SetParamNum(ReadNum());
+  int64 size = ReadNum();
+  for (int64 i = 0; i < size; ++i) {
+    p->PushElementVector(ImportPragmaElement());
+  }
+  return p;
+}
+
+void BinaryMplImport::ImportFieldPair(FieldPair &fp) {
+  fp.first = ImportStr();
+  fp.second.first = mod.IsJavaModule() ? ImportType() : ImportTypeNonJava();
+  fp.second.second.SetAttrFlag(ReadNum());
+  fp.second.second.SetAlignValue(ReadNum());
+  FieldAttrs fa = fp.second.second;
+  if (fa.GetAttr(FLDATTR_static) && fa.GetAttr(FLDATTR_final) &&
+      (fa.GetAttr(FLDATTR_public) || fa.GetAttr(FLDATTR_protected))) {
+    int64 tag = ReadNum();
+    if (tag == kBinInitConst) {
+      GlobalTables::GetConstPool().InsertConstPool(fp.first, ImportConst(nullptr));
+    }
+  }
+}
+
+void BinaryMplImport::ImportMethodPair(MethodPair &memPool) {
+  std::string funcName;
+  ReadAsciiStr(funcName);
+  TyIdx funcTyIdx = ImportType();
+  int64 x = ReadNum();
+  CHECK_FATAL(x >= 0, "ReadNum error, x: %d", x);
+  auto attrFlag = static_cast<uint64>(x);
+
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  MIRSymbol *prevFuncSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+  MIRSymbol *funcSt = nullptr;
+  MIRFunction *fn = nullptr;
+
+  if (prevFuncSt != nullptr && (prevFuncSt->GetStorageClass() == kScText && prevFuncSt->GetSKind() == kStFunc)) {
+    funcSt = prevFuncSt;
+    fn = funcSt->GetFunction();
+  } else {
+    funcSt = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+    funcSt->SetNameStrIdx(strIdx);
+    GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcSt);
+    funcSt->SetStorageClass(kScText);
+    funcSt->SetSKind(kStFunc);
+    funcSt->SetTyIdx(funcTyIdx);
+    funcSt->SetIsImported(imported);
+    funcSt->SetIsImportedDecl(imported);
+    methodSymbols.push_back(funcSt);
+
+    fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSt->GetStIdx());
+    fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
+    GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
+    funcSt->SetFunction(fn);
+    auto *funcType = static_cast<MIRFuncType*>(funcSt->GetType());
+    fn->SetMIRFuncType(funcType);
+    fn->SetFileIndex(0);
+    fn->SetBaseClassFuncNames(funcSt->GetNameStrIdx());
+    fn->SetFuncAttrs(attrFlag);
+  }
+  memPool.first.SetFullIdx(funcSt->GetStIdx().FullIdx());
+  memPool.second.first.reset(funcTyIdx);
+  memPool.second.second.SetAttrFlag(attrFlag);
+}
+
+void BinaryMplImport::UpdateMethodSymbols() {
+  for (auto sym : methodSymbols) {
+    MIRFunction *fn = sym->GetFunction();
+    CHECK_FATAL(fn != nullptr, "fn is null");
+    auto *funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx()));
+    fn->SetMIRFuncType(funcType);
+    fn->SetReturnStruct(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()));
+    if (fn->GetFormalDefVec().size() != 0) {
+      continue;  // already updated in ImportFunction()
+    }
+    for (size_t i = 0; i < funcType->GetParamTypeList().size(); ++i) {
+      FormalDef formalDef(nullptr, funcType->GetParamTypeList()[i], funcType->GetParamAttrsList()[i]);
+      fn->GetFormalDefVec().push_back(formalDef);
+    }
+  }
+}
+
+void BinaryMplImport::ImportFieldsOfStructType(FieldVector &fields, uint32 methodSize) {
+  int64 size = ReadNum();
+  int64 initSize = fields.size() + methodSize;
+  for (int64 i = 0; i < size; ++i) {
+    FieldPair fp;
+    ImportFieldPair(fp);
+    if (initSize == 0) {
+      fields.push_back(fp);
+    }
+  }
+}
+
+void BinaryMplImport::ImportMethodsOfStructType(MethodVector &methods) {
+  int64 size = ReadNum();
+  bool isEmpty = methods.empty();
+  for (int64 i = 0; i < size; ++i) {
+    MethodPair memPool;
+    ImportMethodPair(memPool);
+    if (isEmpty) {
+      methods.push_back(memPool);
+    }
+  }
+}
+
+void BinaryMplImport::ImportStructTypeData(MIRStructType &type) {
+  uint32 methodSize = type.GetMethods().size();
+  ImportFieldsOfStructType(type.GetFields(), methodSize);
+  ImportFieldsOfStructType(type.GetStaticFields(), methodSize);
+  ImportFieldsOfStructType(type.GetParentFields(), methodSize);
+  ImportMethodsOfStructType(type.GetMethods());
+  type.SetIsImported(imported);
+}
+
+void BinaryMplImport::ImportInterfacesOfClassType(std::vector<TyIdx> &interfaces) {
+  int64 size = ReadNum();
+  bool isEmpty = interfaces.empty();
+  for (int64 i = 0; i < size; ++i) {
+    TyIdx idx = ImportType();
+    if (isEmpty) {
+      interfaces.push_back(idx);
+    }
+  }
+}
+
+void BinaryMplImport::ImportInfoIsStringOfStructType(MIRStructType &type) {
+  int64 size = ReadNum();
+  bool isEmpty = type.GetInfoIsString().empty();
+
+  for (int64 i = 0; i < size; ++i) {
+    auto isString = static_cast<bool>(ReadNum());
+
+    if (isEmpty) {
+      type.PushbackIsString(isString);
+    }
+  }
+}
+
+void BinaryMplImport::ImportInfoOfStructType(MIRStructType &type) {
+  uint64 size = static_cast<uint64>(ReadNum());
+  bool isEmpty = type.GetInfo().empty();
+  for (size_t i = 0; i < size; ++i) {
+    GStrIdx idx = ImportStr();
+    int64 x = (type.GetInfoIsStringElemt(i)) ? static_cast<int64>(ImportStr()) : ReadNum();
+    CHECK_FATAL(x >= 0, "ReadNum nagative, x: %d", x);
+    CHECK_FATAL(x <= std::numeric_limits<uint32_t>::max(), "ReadNum too large, x: %d", x);
+    if (isEmpty) {
+      type.PushbackMIRInfo(MIRInfoPair(idx, static_cast<uint32>(x)));
+    }
+  }
+}
+
+void BinaryMplImport::ImportPragmaOfStructType(MIRStructType &type) {
+  int64 size = ReadNum();
+  bool isEmpty = type.GetPragmaVec().empty();
+  for (int64 i = 0; i < size; ++i) {
+    MIRPragma *pragma = ImportPragma();
+    if (isEmpty) {
+      type.PushbackPragma(pragma);
+    }
+  }
+}
+
+void BinaryMplImport::SetClassTyidxOfMethods(MIRStructType &type) const {
+  if (type.GetTypeIndex() != 0u) {
+    // set up classTyIdx for methods
+    for (size_t i = 0; i < type.GetMethods().size(); ++i) {
+      StIdx stidx = type.GetMethodsElement(i).first;
+      MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx());
+      CHECK_FATAL(st != nullptr, "st is null");
+      CHECK_FATAL(st->GetSKind() == kStFunc, "unexpected st->sKind");
+      st->GetFunction()->SetClassTyIdx(type.GetTypeIndex());
+    }
+  }
+}
+
+void BinaryMplImport::ImportClassTypeData(MIRClassType &type) {
+  TyIdx tempType = ImportType();
+  // Keep the parent_tyidx we first met.
+  if (type.GetParentTyIdx() == 0u) {
+    type.SetParentTyIdx(tempType);
+  }
+  ImportInterfacesOfClassType(type.GetInterfaceImplemented());
+  ImportInfoIsStringOfStructType(type);
+  if (!inIPA) {
+    ImportInfoOfStructType(type);
+    ImportPragmaOfStructType(type);
+  }
+  SetClassTyidxOfMethods(type);
+}
+
+void BinaryMplImport::ImportInterfaceTypeData(MIRInterfaceType &type) {
+  ImportInterfacesOfClassType(type.GetParentsTyIdx());
+  ImportInfoIsStringOfStructType(type);
+  if (!inIPA) {
+    ImportInfoOfStructType(type);
+    ImportPragmaOfStructType(type);
+  }
+  SetClassTyidxOfMethods(type);
+}
+
+void BinaryMplImport::Reset() {
+  buf.clear();
+  bufI = 0;
+  gStrTab.clear();
+  uStrTab.clear();
+  typTab.clear();
+  funcTab.clear();
+  symTab.clear();
+  methodSymbols.clear();
+  definedLabels.clear();
+  gStrTab.push_back(GStrIdx(0));  // Dummy
+  uStrTab.push_back(UStrIdx(0));  // Dummy
+  symTab.push_back(nullptr);      // Dummy
+  funcTab.push_back(nullptr);     // Dummy
+  eaCgTab.push_back(nullptr);
+  for (int32 pti = static_cast<int32>(PTY_begin); pti < static_cast<int32>(PTY_end); ++pti) {
+    typTab.push_back(TyIdx(pti));
+  }
+}
+
+TypeAttrs BinaryMplImport::ImportTypeAttrs() {
+  TypeAttrs ta;
+  ta.SetAttrFlag(static_cast<uint64>(ReadNum()));
+  ta.SetAlignValue(static_cast<uint8>(ReadNum()));
+  ta.SetPack(static_cast<uint32>(ReadNum()));
+  return ta;
+}
+
+void BinaryMplImport::ImportTypePairs(std::vector<TypePair> &insVecType) {
+  int64 size = ReadNum();
+  for (int64 i = 0; i < size; ++i) {
+    TyIdx t0 = ImportType();
+    TyIdx t1 = ImportType();
+    TypePair tp(t0, t1);
+    insVecType.push_back(tp);
+  }
+}
+
+void BinaryMplImport::CompleteAggInfo(TyIdx tyIdx) {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  CHECK_FATAL(type != nullptr, "MIRType is null");
+  if (type->GetKind() == kTypeInterface) {
+    auto *interfaceType = static_cast<MIRInterfaceType*>(type);
+    ImportStructTypeData(*interfaceType);
+    ImportInterfaceTypeData(*interfaceType);
+  } else if (type->GetKind() == kTypeClass) {
+    auto *classType = static_cast<MIRClassType*>(type);
+    ImportStructTypeData(*classType);
+    ImportClassTypeData(*classType);
+  } else if (type->GetKind() == kTypeStruct || type->GetKind() == kTypeUnion) {
+    auto *structType = static_cast<MIRStructType*>(type);
+    ImportStructTypeData(*structType);
+  } else {
+    ERR(kLncErr, "in BinaryMplImport::CompleteAggInfo, MIRType error");
+  }
+}
+
+inline static bool IsIncomplete(const MIRType &type) {
+  return (type.GetKind() == kTypeInterfaceIncomplete || type.GetKind() == kTypeClassIncomplete ||
+          type.GetKind() == kTypeStructIncomplete);
+}
+
+TyIdx BinaryMplImport::ImportType(bool forPointedType) {
+  int64 tag = ReadNum();
+  static MIRType *typeNeedsComplete = nullptr;
+  static int ptrLev = 0;
+  if (tag == 0) {
+    return TyIdx(0);
+  }
+  if (tag < 0) {
+    CHECK_FATAL(static_cast<size_t>(-tag) < typTab.size(), "index out of bounds");
+    return typTab.at(static_cast<uint64>(-tag));
+  }
+  PrimType primType = static_cast<PrimType>(0);
+  GStrIdx strIdx(0);
+  bool nameIsLocal = false;
+  ImportTypeBase(primType, strIdx, nameIsLocal);
+
+  switch (tag) {
+    case kBinKindTypeScalar:
+      return TyIdx(primType);
+    case kBinKindTypePointer: {
+      MIRPtrType type(primType, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      size_t idx = typTab.size();
+      typTab.push_back(TyIdx(0));
+      type.SetTypeAttrs(ImportTypeAttrs());
+      ++ptrLev;
+      type.SetPointedTyIdx(ImportType(true));
+      --ptrLev;
+      MIRType *origType = &InsertInTypeTables(type);
+      typTab[idx] = origType->GetTypeIndex();
+      if (typeNeedsComplete != nullptr && ptrLev == 0) {
+        TyIdx tyIdxNeedsComplete = typeNeedsComplete->GetTypeIndex();
+        typeNeedsComplete = nullptr;
+        CompleteAggInfo(tyIdxNeedsComplete);
+      }
+      return origType->GetTypeIndex();
+    }
+    case kBinKindTypeFArray: {
+      MIRFarrayType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      size_t idx = typTab.size();
+      typTab.push_back(TyIdx(0));
+      type.SetElemtTyIdx(ImportType(forPointedType));
+      MIRType *origType = &InsertInTypeTables(type);
+      typTab[idx] = origType->GetTypeIndex();
+      return origType->GetTypeIndex();
+    }
+    case kBinKindTypeJarray: {
+      MIRJarrayType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      size_t idx = typTab.size();
+      typTab.push_back(TyIdx(0));
+      type.SetElemtTyIdx(ImportType(forPointedType));
+      MIRType *origType = &InsertInTypeTables(type);
+      typTab[idx] = origType->GetTypeIndex();
+      return origType->GetTypeIndex();
+    }
+    case kBinKindTypeArray: {
+      MIRArrayType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      type.SetDim(ReadNum());
+      CHECK_FATAL(type.GetDim() < kMaxArrayDim, "array index out of range");
+      for (uint16 i = 0; i < type.GetDim(); ++i) {
+        type.SetSizeArrayItem(i, ReadNum());
+      }
+      size_t idx = typTab.size();
+      typTab.push_back(TyIdx(0));
+      type.SetElemTyIdx(ImportType(forPointedType));
+      type.SetTypeAttrs(ImportTypeAttrs());
+      MIRType *origType = &InsertInTypeTables(type);
+      typTab[idx] = origType->GetTypeIndex();
+      return origType->GetTypeIndex();
+    }
+    case kBinKindTypeFunction: {
+      MIRFuncType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      size_t idx = typTab.size();
+      typTab.push_back(TyIdx(0));
+      type.SetRetTyIdx(ImportType());
+      type.funcAttrs.SetAttrFlag(static_cast<uint64_t>(ReadNum()));
+      int64 size = ReadNum();
+      for (int64 i = 0; i < size; ++i) {
+        type.GetParamTypeList().push_back(ImportType());
+      }
+      size = ReadNum();
+      for (int64 i = 0; i < size; ++i) {
+        type.GetParamAttrsList().push_back(ImportTypeAttrs());
+      }
+      MIRType *origType = &InsertInTypeTables(type);
+      typTab[idx] = origType->GetTypeIndex();
+      return origType->GetTypeIndex();
+    }
+    case kBinKindTypeParam: {
+      MIRTypeParam type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      MIRType *origType = &InsertInTypeTables(type);
+      typTab.push_back(origType->GetTypeIndex());
+      return origType->GetTypeIndex();
+    }
+    case kBinKindTypeInstantVector: {
+      auto kind = static_cast<MIRTypeKind>(ReadNum());
+      MIRInstantVectorType type(kind, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      auto *origType = static_cast<MIRInstantVectorType*>(&InsertInTypeTables(type));
+      typTab.push_back(origType->GetTypeIndex());
+      ImportTypePairs(origType->GetInstantVec());
+      return origType->GetTypeIndex();
+    }
+    case kBinKindTypeGenericInstant: {
+      MIRGenericInstantType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      auto *origType = static_cast<MIRGenericInstantType*>(&InsertInTypeTables(type));
+      typTab.push_back(origType->GetTypeIndex());
+      ImportTypePairs(origType->GetInstantVec());
+      origType->SetGenericTyIdx(ImportType());
+      return origType->GetTypeIndex();
+    }
+    case kBinKindTypeBitField: {
+      uint8 fieldSize = ReadNum();
+      MIRBitFieldType type(fieldSize, primType, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      MIRType *origType = &InsertInTypeTables(type);
+      typTab.push_back(origType->GetTypeIndex());
+      return origType->GetTypeIndex();
+    }
+    case kBinKindTypeStruct: {
+      auto kind = static_cast<MIRTypeKind>(ReadNum());
+      MIRStructType type(kind, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      type.SetTypeAttrs(ImportTypeAttrs());
+      MIRStructType &origType = static_cast<MIRStructType&>(InsertInTypeTables(type));
+      typTab.push_back(origType.GetTypeIndex());
+      if (kind != kTypeStructIncomplete) {
+        if (forPointedType) {
+          typeNeedsComplete = &origType;
+        } else {
+          ImportStructTypeData(origType);
+        }
+      }
+      return origType.GetTypeIndex();
+    }
+    case kBinKindTypeClass: {
+      auto kind = static_cast<MIRTypeKind>(ReadNum());
+      MIRClassType type(kind, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      auto &origType = static_cast<MIRClassType&>(InsertInTypeTables(type));
+      typTab.push_back(origType.GetTypeIndex());
+      if (kind != kTypeClassIncomplete) {
+        if (forPointedType) {
+          typeNeedsComplete = &origType;
+        } else {
+          ImportStructTypeData(origType);
+          ImportClassTypeData(origType);
+        }
+      }
+      return origType.GetTypeIndex();
+    }
+    case kBinKindTypeInterface: {
+      auto kind = static_cast<MIRTypeKind>(ReadNum());
+      MIRInterfaceType type(kind, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      auto &origType = static_cast<MIRInterfaceType&>(InsertInTypeTables(type));
+      typTab.push_back(origType.GetTypeIndex());
+      if (kind != kTypeInterfaceIncomplete) {
+        if (forPointedType) {
+          typeNeedsComplete = &origType;
+        } else {
+          ImportStructTypeData(origType);
+          ImportInterfaceTypeData(origType);
+        }
+      }
+      return origType.GetTypeIndex();
+    }
+    default:
+      CHECK_FATAL(false, "Unexpected binary kind");
+  }
+}
+
+TyIdx BinaryMplImport::ImportTypeNonJava() {
+  int64 tag = ReadNum();
+  if (tag == 0) {
+    return TyIdx(0);
+  }
+  if (tag < 0) {
+    CHECK_FATAL(static_cast<size_t>(-tag) < typTab.size(), "index out of bounds");
+    return typTab[static_cast<uint64>(-tag)];
+  }
+  PrimType primType = static_cast<PrimType>(0);
+  GStrIdx strIdx(0);
+  bool nameIsLocal = false;
+  ImportTypeBase(primType, strIdx, nameIsLocal);
+  TyIdx tyIdxUsed(GlobalTables::GetTypeTable().GetTypeTableSize());
+  if (tag != kBinKindTypeScalar) {
+    GlobalTables::GetTypeTable().PushNull();
+    typTab.push_back(tyIdxUsed);
+  }
+
+  switch (tag) {
+    case kBinKindTypeScalar:
+      return TyIdx(primType);
+    case kBinKindTypePointer: {
+      MIRPtrType type(primType, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      type.SetTypeAttrs(ImportTypeAttrs());
+      type.SetPointedTyIdx(ImportTypeNonJava());
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, false);
+      return tyIdxUsed;
+    }
+    case kBinKindTypeFArray: {
+      MIRFarrayType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      type.SetElemtTyIdx(ImportTypeNonJava());
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, false);
+      return tyIdxUsed;
+    }
+    case kBinKindTypeJarray: {
+      MIRJarrayType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      type.SetElemtTyIdx(ImportTypeNonJava());
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, false);
+      return tyIdxUsed;
+    }
+    case kBinKindTypeArray: {
+      MIRArrayType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      type.SetDim(ReadNum());
+      CHECK_FATAL(type.GetDim() < kMaxArrayDim, "array index out of range");
+      for (uint16 i = 0; i < type.GetDim(); ++i) {
+        type.SetSizeArrayItem(i, ReadNum());
+      }
+      type.SetElemTyIdx(ImportTypeNonJava());
+      type.SetTypeAttrs(ImportTypeAttrs());
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, false);
+      return tyIdxUsed;
+    }
+    case kBinKindTypeFunction: {
+      MIRFuncType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      type.SetRetTyIdx(ImportTypeNonJava());
+      type.funcAttrs.SetAttrFlag(static_cast<uint64_t>(ReadNum()));
+      int64 size = ReadNum();
+      for (int64 i = 0; i < size; ++i) {
+        type.GetParamTypeList().push_back(ImportTypeNonJava());
+      }
+      size = ReadNum();
+      for (int64 i = 0; i < size; ++i) {
+        type.GetParamAttrsList().push_back(ImportTypeAttrs());
+      }
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, false);
+      return tyIdxUsed;
+    }
+    case kBinKindTypeParam: {
+      MIRTypeParam type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, false);
+      return tyIdxUsed;
+    }
+    case kBinKindTypeInstantVector: {
+      auto kind = static_cast<MIRTypeKind>(ReadNum());
+      MIRInstantVectorType type(kind, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      ImportTypePairs(type.GetInstantVec());
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, false);
+      return tyIdxUsed;
+    }
+    case kBinKindTypeGenericInstant: {
+      MIRGenericInstantType type(strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      ImportTypePairs(type.GetInstantVec());
+      type.SetGenericTyIdx(ImportTypeNonJava());
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, false);
+      return tyIdxUsed;
+    }
+    case kBinKindTypeBitField: {
+      uint8 fieldSize = ReadNum();
+      MIRBitFieldType type(fieldSize, primType, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, false);
+      return tyIdxUsed;
+    }
+    case kBinKindTypeStruct: {
+      auto kind = static_cast<MIRTypeKind>(ReadNum());
+      MIRStructType type(kind, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      type.SetTypeAttrs(ImportTypeAttrs());
+      if (kind != kTypeStructIncomplete) {
+        ImportStructTypeData(type);
+      }
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, false, IsIncomplete(type));
+      return tyIdxUsed;
+    }
+    case kBinKindTypeClass: {
+      auto kind = static_cast<MIRTypeKind>(ReadNum());
+      MIRClassType type(kind, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      if (kind != kTypeClassIncomplete) {
+        ImportStructTypeData(type);
+        ImportClassTypeData(type);
+      }
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, true, IsIncomplete(type));
+      return tyIdxUsed;
+    }
+    case kBinKindTypeInterface: {
+      auto kind = static_cast<MIRTypeKind>(ReadNum());
+      MIRInterfaceType type(kind, strIdx);
+      type.SetNameIsLocal(nameIsLocal);
+      if (kind != kTypeInterfaceIncomplete) {
+        ImportStructTypeData(type);
+        ImportInterfaceTypeData(type);
+      }
+      GlobalTables::GetTypeTable().CreateMirTypeNodeAt(type, tyIdxUsed, &mod, true, IsIncomplete(type));
+      return tyIdxUsed;
+    }
+    default:
+      CHECK_FATAL(false, "Unexpected binary kind");
+  }
+}
+
+void BinaryMplImport::ImportTypeBase(PrimType &primType, GStrIdx &strIdx, bool &nameIsLocal) {
+  primType = static_cast<PrimType>(ReadNum());
+  strIdx = ImportStr();
+  nameIsLocal = ReadNum();
+}
+
+inline static bool IsObject(const MIRType &type) {
+  return (type.GetKind() == kTypeClass || type.GetKind() == kTypeClassIncomplete ||
+          type.GetKind() == kTypeInterface || type.GetKind() == kTypeInterfaceIncomplete);
+}
+
+MIRType &BinaryMplImport::InsertInTypeTables(MIRType &type) {
+  MIRType *resultTypePtr = &type;
+  TyIdx prevTyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(type.GetNameStrIdx());
+  if (prevTyIdx != 0u && !type.IsNameIsLocal()) {
+    MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prevTyIdx);
+    if (!prevType->IsMIRTypeByName() &&
+        ((IsIncomplete(*prevType) && IsIncomplete(type)) ||
+         (!IsIncomplete(*prevType) && !IsIncomplete(type)) ||
+         (!IsIncomplete(*prevType) && IsIncomplete(type)))) {
+      resultTypePtr = prevType->CopyMIRTypeNode();
+      if (resultTypePtr->GetKind() == kTypeStruct || resultTypePtr->GetKind() == kTypeUnion ||
+          resultTypePtr->GetKind() == kTypeStructIncomplete) {
+        tmpStruct.push_back(static_cast<MIRStructType*>(resultTypePtr));
+      } else if (resultTypePtr->GetKind() == kTypeClass || resultTypePtr->GetKind() == kTypeClassIncomplete) {
+        tmpClass.push_back(static_cast<MIRClassType*>(resultTypePtr));
+      } else if (resultTypePtr->GetKind() == kTypeInterface || resultTypePtr->GetKind() == kTypeInterfaceIncomplete) {
+        tmpInterface.push_back(static_cast<MIRInterfaceType*>(resultTypePtr));
+      }
+    } else {
+      // New definition wins
+      type.SetTypeIndex(prevTyIdx);
+      CHECK_FATAL(GlobalTables::GetTypeTable().GetTypeTable().empty() == false, "container check");
+      GlobalTables::GetTypeTable().SetTypeWithTyIdx(prevTyIdx, *type.CopyMIRTypeNode());
+      resultTypePtr = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prevTyIdx);
+      if (!IsIncomplete(*resultTypePtr)) {
+        GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(resultTypePtr->GetNameStrIdx(),
+                                                           resultTypePtr->GetTypeIndex());
+      }
+    }
+  } else {
+    // New type, no previous definition or anonymous type
+    TyIdx tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&type);
+    resultTypePtr = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    if (tyIdx + 1 == GlobalTables::GetTypeTable().GetTypeTable().size() && !resultTypePtr->IsNameIsLocal()) {
+      GStrIdx stridx = resultTypePtr->GetNameStrIdx();
+      if (stridx != 0) {
+        mod.GetTypeNameTab()->SetGStrIdxToTyIdx(stridx, tyIdx);
+        mod.PushbackTypeDefOrder(stridx);
+        if (IsObject(*resultTypePtr)) {
+          mod.AddClass(tyIdx);
+          if (!IsIncomplete(*resultTypePtr)) {
+            GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(stridx, tyIdx);
+          }
+        }
+      }
+    }
+  }
+  return *resultTypePtr;
+}
+
+void BinaryMplImport::SetupEHRootType() {
+  // setup eh root type with most recent Ljava_2Flang_2FObject_3B
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kJavaLangObjectStr);
+  if (gStrIdx == 0u) {
+    return;
+  }
+
+  TyIdx tyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(gStrIdx);
+  if (tyIdx != 0u) {
+    mod.SetThrowableTyIdx(tyIdx);
+  }
+}
+
+MIRSymbol *BinaryMplImport::GetOrCreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mclass,
+                                              MIRStorageClass sclass, MIRFunction *func, uint8 scpID) {
+  MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+  if (st != nullptr && st->GetStorageClass() == sclass && st->GetSKind() == mclass && scpID == kScopeGlobal) {
+    return st;
+  }
+  return mirBuilder.CreateSymbol(tyIdx, strIdx, mclass, sclass, func, scpID);
+}
+
+MIRSymbol *BinaryMplImport::InSymbol(MIRFunction *func) {
+  int64 tag = ReadNum();
+  if (tag == 0) {
+    return nullptr;
+  } else if (tag < 0) {
+    CHECK_FATAL(static_cast<size_t>(-tag) < symTab.size(), "index out of bounds");
+    return symTab.at(-tag);
+  } else {
+    CHECK_FATAL(tag == kBinSymbol, "expecting kBinSymbol");
+    int64 scope = ReadNum();
+    GStrIdx stridx = ImportStr();
+    UStrIdx secAttr = ImportUsrStr();
+    UStrIdx asmAttr = ImportUsrStr();
+    auto skind = static_cast<MIRSymKind>(ReadNum());
+    auto sclass = static_cast<MIRStorageClass>(ReadNum());
+    TyIdx tyTmp(0);
+    MIRSymbol *sym = GetOrCreateSymbol(tyTmp, stridx, skind, sclass, func, scope);
+    if (secAttr != 0) {
+      sym->sectionAttr = secAttr;
+    }
+    if (asmAttr != 0) {
+      sym->SetAsmAttr(asmAttr);
+    }
+    symTab.push_back(sym);
+    sym->SetAttrs(ImportTypeAttrs());
+    sym->SetIsTmp(ReadNum() != 0);
+    sym->SetIsImported(imported);
+    uint32 thepregno = 0;
+    if (skind == kStPreg) {
+      CHECK_FATAL(scope == kScopeLocal && func != nullptr, "Expecting kScopeLocal");
+      thepregno = static_cast<uint32>(ReadNum());
+    } else if (skind == kStConst || skind == kStVar) {
+      sym->SetKonst(ImportConst(func));
+    } else if (skind == kStFunc) {
+      PUIdx puidx = ImportFunction();
+      mod.SetCurFunction(func);
+      if (puidx != 0) {
+        sym->SetFunction(GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puidx));
+      }
+    }
+    if (skind == kStVar || skind == kStFunc) {
+      ImportSrcPos(sym->GetSrcPosition());
+    }
+    TyIdx tyIdx = mod.IsJavaModule() ? ImportType() : ImportTypeNonJava();
+    sym->SetTyIdx(tyIdx);
+    if (skind == kStPreg) {
+      MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx());
+      PregIdx pregidx = func->GetPregTab()->EnterPregNo(thepregno, mirType->GetPrimType(), mirType);
+      MIRPregTable *pregTab = func->GetPregTab();
+      MIRPreg *preg = pregTab->PregFromPregIdx(pregidx);
+      preg->SetPrimType(mirType->GetPrimType());
+      sym->SetPreg(preg);
+    }
+    return sym;
+  }
+}
+
+PUIdx BinaryMplImport::ImportFunction() {
+  int64 tag = ReadNum();
+  if (tag == 0) {
+    mod.SetCurFunction(nullptr);
+    return 0;
+  } else if (tag < 0) {
+    CHECK_FATAL(static_cast<uint64>(-tag) <= funcTab.size(), "index out of bounds");
+    if (static_cast<uint64>(-tag) == funcTab.size()) { // function was exported before its symbol
+      return static_cast<PUIdx>(0);
+    }
+    PUIdx puIdx =  funcTab[static_cast<uint64>(-tag)]->GetPuidx();
+    mod.SetCurFunction(GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx));
+    return puIdx;
+  }
+  CHECK_FATAL(tag == kBinFunction, "expecting kBinFunction");
+  MIRSymbol *funcSt = InSymbol(nullptr);
+  CHECK_FATAL(funcSt != nullptr, "null ptr check");
+  MIRFunction *func = nullptr;
+  if (funcSt->GetFunction() == nullptr) {
+    maple::MIRBuilder builder(&mod);
+    func = builder.CreateFunction(funcSt->GetStIdx());
+    funcTab.push_back(func);
+  } else {
+    func = funcSt->GetFunction();
+    funcTab.push_back(func);
+  }
+  funcSt->SetFunction(func);
+  methodSymbols.push_back(funcSt);
+  if (mod.IsJavaModule()) {
+    func->SetBaseClassFuncNames(funcSt->GetNameStrIdx());
+  }
+  TyIdx funcTyIdx = mod.IsJavaModule() ? ImportType() : ImportTypeNonJava();
+  func->SetMIRFuncType(static_cast<MIRFuncType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcTyIdx)));
+
+  func->SetStIdx(funcSt->GetStIdx());
+  if (!inCG) {
+    func->SetFuncAttrs(ReadNum());  // merge side effect
+  } else {
+    if (!func->IsDirty()) {
+      func->SetDirty(true);
+      func->SetFuncAttrs(ReadNum());  // merge side effect
+    } else {
+      FuncAttrs tmp;
+      tmp.SetAttrFlag(ReadNum());
+      if (func->IsNoDefArgEffect() != tmp.GetAttr(FUNCATTR_nodefargeffect)) {
+        tmp.SetAttr(FUNCATTR_nodefargeffect, true);
+      }
+      if (func->IsNoDefEffect() != tmp.GetAttr(FUNCATTR_nodefeffect)) {
+        tmp.SetAttr(FUNCATTR_nodefeffect, true);
+      }
+      if (func->IsNoRetGlobal() != tmp.GetAttr(FUNCATTR_noretglobal)) {
+        tmp.SetAttr(FUNCATTR_noretglobal, true);
+      }
+      if (func->IsNoThrowException() != tmp.GetAttr(FUNCATTR_nothrow_exception)) {
+        tmp.SetAttr(FUNCATTR_nothrow_exception, true);
+      }
+      if (func->IsIpaSeen() != tmp.GetAttr(FUNCATTR_ipaseen)) {
+        tmp.SetAttr(FUNCATTR_ipaseen);
+      }
+      if (func->IsPure() != tmp.GetAttr(FUNCATTR_pure)) {
+        tmp.SetAttr(FUNCATTR_pure, true);
+      }
+      if (func->IsNoRetArg() != tmp.GetAttr(FUNCATTR_noretarg)) {
+        tmp.SetAttr(FUNCATTR_noretarg, true);
+      }
+      if (func->IsNoPrivateDefEffect() != tmp.GetAttr(FUNCATTR_noprivate_defeffect)) {
+        tmp.SetAttr(FUNCATTR_noprivate_defeffect, true);
+      }
+      func->SetFuncAttrs(tmp);
+    }
+  }
+
+  auto &attributes = func->GetFuncAttrs();
+  if (attributes.GetAttr(FUNCATTR_constructor_priority)) {
+    attributes.SetConstructorPriority(static_cast<int>(ReadNum()));
+  }
+  if (attributes.GetAttr(FUNCATTR_destructor_priority)) {
+    attributes.SetDestructorPriority(static_cast<int>(ReadNum()));
+  }
+
+  func->SetFlag(ReadNum());
+  if (mod.IsJavaModule()) {
+    (void)ImportType();  // not set the field to mimic parser
+  } else {
+    (void)ImportTypeNonJava();  // not set the field to mimic parser
+  }
+  size_t size = static_cast<size_t>(ReadNum());
+  if (func->GetFormalDefVec().size() == 0) {
+    for (size_t i = 0; i < size; i++) {
+      GStrIdx strIdx = ImportStr();
+      TyIdx tyIdx = mod.IsJavaModule() ? ImportType() : ImportTypeNonJava();
+      FormalDef formalDef(strIdx, nullptr, tyIdx, TypeAttrs());
+      formalDef.formalAttrs.SetAttrFlag(static_cast<uint64>(ReadNum()));
+      func->GetFormalDefVec().push_back(formalDef);
+    }
+  } else {
+    CHECK_FATAL(func->GetFormalDefVec().size() >= size, "ImportFunction: inconsistent number of formals");
+    for (size_t i = 0; i < size; i++) {
+      func->GetFormalDefVec()[i].formalStrIdx = ImportStr();
+      func->GetFormalDefVec()[i].formalTyIdx = mod.IsJavaModule() ? ImportType() : ImportTypeNonJava();
+      func->GetFormalDefVec()[i].formalAttrs.SetAttrFlag(static_cast<uint64>(ReadNum()));
+    }
+  }
+
+  mod.SetCurFunction(func);
+  return func->GetPuidx();
+}
+
+inline void BinaryMplImport::SkipTotalSize() {
+  ReadInt();
+}
+
+void BinaryMplImport::ReadStrField() {
+  SkipTotalSize();
+
+  int32 size = ReadInt();
+  for (int64 i = 0; i < size; ++i) {
+    GStrIdx stridx = ImportStr();
+    GlobalTables::GetConstPool().PutLiteralNameAsImported(stridx);
+  }
+  int64 tag = 0;
+  tag = ReadNum();
+  CHECK_FATAL(tag == ~kBinStrStart, "pattern mismatch in Read STR");
+}
+
+void BinaryMplImport::ReadHeaderField() {
+  SkipTotalSize();
+  mod.SetFlavor(static_cast<MIRFlavor>(ReadNum()));
+  mod.SetSrcLang(static_cast<MIRSrcLang>(ReadNum()));
+  mod.SetID(static_cast<uint16>(ReadNum()));
+  if (mod.GetFlavor() == kFlavorLmbc) {
+    mod.SetGlobalMemSize(static_cast<uint32>(ReadNum()));
+    mod.SetWithDbgInfo(ReadNum() != 0);
+  }
+  mod.SetNumFuncs(static_cast<uint32>(ReadNum()));
+  std::string inStr;
+  ReadAsciiStr(inStr);
+  mod.SetEntryFuncName(inStr);
+  ImportInfoVector(mod.GetFileInfo(), mod.GetFileInfoIsString());
+
+  int32 size = static_cast<int32>(ReadNum());
+  MIRInfoPair infopair;
+  for (int32 i = 0; i < size; i++) {
+    infopair.first = ImportStr();
+    infopair.second = static_cast<uint32>(ReadNum());
+    mod.PushbackFileInfo(infopair);
+  }
+
+  size = static_cast<int32>(ReadNum());
+  for (int32 i = 0; i < size; i++) {
+    GStrIdx gStrIdx  = ImportStr();
+    mod.GetImportFiles().push_back(gStrIdx);
+    std::string importfilename = GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx);
+    // record the imported file for later reading summary info, if exists
+    mod.PushbackImportedMplt(importfilename);
+    BinaryMplt *binMplt = new BinaryMplt(mod);
+    binMplt->GetBinImport().imported = true;
+
+    INFO(kLncInfo, "importing %s", importfilename.c_str());
+    if (!binMplt->GetBinImport().Import(importfilename, false)) {  // not a binary mplt
+      FATAL(kLncFatal, "cannot open binary MPLT file: %s\n", importfilename.c_str());
+    } else {
+      INFO(kLncInfo, "finished import of %s", importfilename.c_str());
+    }
+    if (i == 0) {
+      binMplt->SetImportFileName(importfilename);
+      mod.SetBinMplt(binMplt);
+    } else {
+      delete binMplt;
+    }
+  }
+
+  size = static_cast<int32>(ReadNum());
+  for (int32 i = 0; i < size; i++) {
+    std::string str;
+    ReadAsciiStr(str);
+    mod.GetAsmDecls().emplace_back(MapleString(str, mod.GetMemPool()));
+  }
+
+  int32 tag = static_cast<int32>(ReadNum());
+  CHECK_FATAL(tag == ~kBinHeaderStart, "pattern mismatch in Read Import");
+  return;
+}
+
+void BinaryMplImport::ReadTypeField() {
+  SkipTotalSize();
+
+  int32 size = ReadInt();
+  if (mod.IsJavaModule()) {
+    for (int64 i = 0; i < size; ++i) {
+      ImportType();
+    }
+  } else {
+    for (int64 i = 0; i < size; ++i) {
+      (void)ImportTypeNonJava();
+    }
+  }
+  int64 tag = 0;
+  tag = ReadNum();
+  CHECK_FATAL(tag == ~kBinTypeStart, "pattern mismatch in Read TYPE");
+}
+
+void BinaryMplImport::ImportEnumeration() {
+  int64 tag = ReadNum();
+  CHECK_FATAL(tag == kBinEnumeration, "expecting kBinEnumeration");
+  PrimType ptyp = static_cast<PrimType>(Read());
+  GStrIdx gStrIdx = ImportStr();
+  MIREnum *mirEnum = new MIREnum(ptyp, gStrIdx);
+  size_t siz = static_cast<size_t>(ReadNum());
+  for (size_t i = 0; i < siz; i++) {
+    gStrIdx = ImportStr();
+    IntVal intVal(ReadNum(), ptyp);
+    mirEnum->NewElement(gStrIdx, intVal);
+  }
+  GlobalTables::GetEnumTable().enumTable.push_back(mirEnum);
+}
+
+void BinaryMplImport::ReadEnumField() {
+  SkipTotalSize();
+
+  int32 size = ReadInt();
+  for (int64 i = 0; i < size; ++i) {
+    ImportEnumeration();
+  }
+  int64 tag = ReadNum();
+  CHECK_FATAL(tag == ~kBinEnumStart, "pattern mismatch in Reading ENUM");
+}
+
+CallInfo *BinaryMplImport::ImportCallInfo() {
+  int64 tag = ReadNum();
+  if (tag < 0) {
+    CHECK_FATAL(static_cast<size_t>(-tag) < callInfoTab.size(), "index out of bounds");
+    return callInfoTab.at(-tag);
+  }
+  CHECK_FATAL(tag == kBinCallinfo, "expecting kBinCallinfo");
+  CallType ctype = static_cast<CallType>(ReadNum());  // call type
+  uint32 loopDepth = static_cast<uint32>(ReadInt());
+  uint32 id = static_cast<uint32>(ReadInt());
+  bool argLocal = Read() == 1;
+  MIRSymbol *funcSym = InSymbol(nullptr);
+  CHECK_FATAL(funcSym != nullptr, "func_sym is null in BinaryMplImport::InCallInfo");
+  CallInfo *ret = mod.GetMemPool()->New<CallInfo>(ctype, funcSym->GetFunction(),
+                                                  static_cast<StmtNode*>(nullptr), loopDepth, id, argLocal);
+  callInfoTab.push_back(ret);
+  return ret;
+}
+
+void BinaryMplImport::MergeDuplicated(PUIdx methodPuidx, std::vector<CallInfo*> &targetSet,
+                                      std::vector<CallInfo*> &newSet) {
+  if (targetSet.empty()) {
+    (void)targetSet.insert(targetSet.begin(), newSet.begin(), newSet.end());
+    std::unordered_set<uint32> tmp;
+    mod.AddValueToMethod2TargetHash(methodPuidx, tmp);
+    for (size_t i = 0; i < newSet.size(); ++i) {
+      mod.InsertTargetHash(methodPuidx, newSet[i]->GetID());
+    }
+  } else {
+    for (size_t i = 0; i < newSet.size(); ++i) {
+      CallInfo *newItem = newSet[i];
+      if (!mod.HasTargetHash(methodPuidx, newItem->GetID())) {
+        targetSet.push_back(newItem);
+        mod.InsertTargetHash(methodPuidx, newItem->GetID());
+      }
+    }
+  }
+}
+
+void BinaryMplImport::ReadCgField() {
+  SkipTotalSize();
+
+  int32 size = ReadInt();
+  int64 tag = 0;
+
+  for (int i = 0; i < size; ++i) {
+    tag = ReadNum();
+    CHECK_FATAL(tag == kStartMethod, " should be start point of method");
+    MIRSymbol *tmpInSymbol = InSymbol(nullptr);
+    CHECK_FATAL(tmpInSymbol != nullptr, "null ptr check");
+    PUIdx methodPuidx = tmpInSymbol->GetFunction()->GetPuidx();
+    CHECK_FATAL(methodPuidx, "should not be 0");
+    if (mod.GetMethod2TargetMap().find(methodPuidx) == mod.GetMethod2TargetMap().end()) {
+      std::vector<CallInfo*> targetSetTmp;
+      mod.AddMemToMethod2TargetMap(methodPuidx, targetSetTmp);
+    }
+    int32 targSize = ReadInt();
+    std::vector<CallInfo*> targetSet;
+    callInfoTab.clear();
+    callInfoTab.push_back(nullptr);
+    for (int32 j = 0; j < targSize; ++j) {
+      CallInfo *callInfo = ImportCallInfo();
+      targetSet.push_back(callInfo);
+    }
+    MergeDuplicated(methodPuidx, mod.GetMemFromMethod2TargetMap(methodPuidx), targetSet);
+    tag = ReadNum();
+    CHECK_FATAL(tag == ~kStartMethod, " should be start point of method");
+  }
+  tag = ReadNum();
+  CHECK_FATAL(tag == ~kBinCgStart, "pattern mismatch in Read CG");
+}
+
+void BinaryMplImport::ReadEaField() {
+  ReadInt();
+  int size = ReadInt();
+  for (int i = 0; i < size; ++i) {
+    GStrIdx funcName = ImportStr();
+    int nodesSize = ReadInt();
+    EAConnectionGraph *newEaCg = mod.GetMemPool()->New<EAConnectionGraph>(&mod, &mod.GetMPAllocator(), funcName, true);
+    newEaCg->ResizeNodes(nodesSize, nullptr);
+    InEaCgNode(*newEaCg);
+    int eaSize = ReadInt();
+    for (int j = 0; j < eaSize; ++j) {
+      EACGBaseNode *node = &InEaCgNode(*newEaCg);
+      newEaCg->funcArgNodes.push_back(node);
+    }
+    mod.SetEAConnectionGraph(funcName, newEaCg);
+  }
+  CHECK_FATAL(ReadNum() == ~kBinEaStart, "pattern mismatch in Read EA");
+}
+
+void BinaryMplImport::ReadSeField() {
+  SkipTotalSize();
+
+  int32 size = ReadInt();
+#ifdef MPLT_DEBUG
+  LogInfo::MapleLogger() << "SE SIZE : " << size << '\n';
+#endif
+  for (int32 i = 0; i < size; ++i) {
+    GStrIdx funcName = ImportStr();
+    uint8 specialEffect = Read();
+    TyIdx tyIdx = kInitTyIdx;
+    if ((specialEffect & kPureFunc) == kPureFunc) {
+      tyIdx = ImportType();
+    }
+    const std::string &funcStr = GlobalTables::GetStrTable().GetStringFromStrIdx(funcName);
+    if (funcStr == "Ljava_2Flang_2FObject_3B_7Cwait_7C_28_29V") {
+      specialEffect = 0;
+    }
+    auto *funcSymbol =
+        GlobalTables::GetGsymTable().GetSymbolFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(funcStr));
+    MIRFunction *func = funcSymbol != nullptr ? mirBuilder.GetFunctionFromSymbol(*funcSymbol) : nullptr;
+    if (func != nullptr) {
+      func->SetAttrsFromSe(specialEffect);
+    } else if ((specialEffect & kPureFunc) == kPureFunc) {
+      func = mirBuilder.GetOrCreateFunction(funcStr, tyIdx);
+      func->SetAttrsFromSe(specialEffect);
+    }
+  }
+  int64 tag = ReadNum();
+  CHECK_FATAL(tag == ~kBinSeStart, "pattern mismatch in Read TYPE");
+}
+
+void BinaryMplImport::InEaCgBaseNode(EACGBaseNode &base, EAConnectionGraph &newEaCg, bool firstPart) {
+  if (firstPart) {
+    base.SetEAStatus(static_cast<EAStatus>(ReadNum()));
+    base.SetID(ReadInt());
+  } else {
+    // start to in points to
+    int size = ReadInt();
+    for (int i = 0; i < size; ++i) {
+      EACGBaseNode *point2Node = &InEaCgNode(newEaCg);
+      CHECK_FATAL(point2Node->IsObjectNode(), "must be");
+      (void)base.pointsTo.insert(static_cast<EACGObjectNode*>(point2Node));
+    }
+    // start to in in
+    size = ReadInt();
+    for (int i = 0; i < size; ++i) {
+      EACGBaseNode *point2Node = &InEaCgNode(newEaCg);
+      base.InsertInSet(point2Node);
+    }
+    // start to in out
+    size = ReadInt();
+    for (int i = 0; i < size; ++i) {
+      EACGBaseNode *point2Node = &InEaCgNode(newEaCg);
+      base.InsertOutSet(point2Node);
+    }
+  }
+}
+
+void BinaryMplImport::InEaCgActNode(EACGActualNode &actual) {
+  actual.isPhantom = Read() == 1;
+  actual.isReturn = Read() == 1;
+  actual.argIdx = Read();
+  actual.callSiteInfo = static_cast<uint32>(ReadInt());
+}
+
+void BinaryMplImport::InEaCgFieldNode(EACGFieldNode &field, EAConnectionGraph &newEaCg) {
+  field.SetFieldID(ReadInt());
+  int size = ReadInt();
+  for (int i = 0; i < size; ++i) {
+    EACGBaseNode* node = &InEaCgNode(newEaCg);
+    CHECK_FATAL(node->IsObjectNode(), "must be");
+    (void)field.belongsTo.insert(static_cast<EACGObjectNode*>(node));
+  }
+  field.isPhantom = Read() == 1;
+}
+
+void BinaryMplImport::InEaCgObjNode(EACGObjectNode &obj, EAConnectionGraph &newEaCg) {
+  Read();
+  obj.isPhantom = true;
+  int size = ReadInt();
+  for (int i = 0; i < size; ++i) {
+    EACGBaseNode *node = &InEaCgNode(newEaCg);
+    CHECK_FATAL(node->IsFieldNode(), "must be");
+    auto *field = static_cast<EACGFieldNode*>(node);
+    obj.fieldNodes[static_cast<EACGFieldNode*>(field)->GetFieldID()] = field;
+  }
+  // start to in point by
+  size = ReadInt();
+  for (int i = 0; i < size; ++i) {
+    EACGBaseNode *point2Node = &InEaCgNode(newEaCg);
+    (void)obj.pointsBy.insert(point2Node);
+  }
+}
+
+void BinaryMplImport::InEaCgRefNode(EACGRefNode &ref) {
+  ref.isStaticField = Read() == 1 ? true : false;
+}
+
+EACGBaseNode &BinaryMplImport::InEaCgNode(EAConnectionGraph &newEaCg) {
+  int64 tag = ReadNum();
+  if (tag < 0) {
+    CHECK_FATAL(static_cast<uint64>(-tag) < eaCgTab.size(), "index out of bounds");
+    return *eaCgTab[-tag];
+  }
+  CHECK_FATAL(tag == kBinEaCgNode, "must be");
+  NodeKind kind = static_cast<NodeKind>(ReadNum());
+  EACGBaseNode *node = nullptr;
+  switch (kind) {
+    case kObejectNode:
+      node = new EACGObjectNode(&mod, &mod.GetMPAllocator(), &newEaCg);
+      break;
+    case kReferenceNode:
+      node = new EACGRefNode(&mod, &mod.GetMPAllocator(), &newEaCg);
+      break;
+    case kFieldNode:
+      node = new EACGFieldNode(&mod, &mod.GetMPAllocator(), &newEaCg);
+      break;
+    case kActualNode:
+      node = new EACGActualNode(&mod, &mod.GetMPAllocator(), &newEaCg);
+      break;
+    default:
+      CHECK_FATAL(false, "impossible");
+  }
+  node->SetEACG(&newEaCg);
+  eaCgTab.push_back(node);
+  InEaCgBaseNode(*node, newEaCg, true);
+  newEaCg.SetNodeAt(node->id - 1, node);
+  if (node->IsActualNode()) {
+    CHECK_FATAL(ReadNum() == kBinEaCgActNode, "must be");
+    InEaCgActNode(static_cast<EACGActualNode&>(*node));
+  } else if (node->IsFieldNode()) {
+    CHECK_FATAL(ReadNum() == kBinEaCgFieldNode, "must be");
+    InEaCgFieldNode(static_cast<EACGFieldNode&>(*node), newEaCg);
+  } else if (node->IsObjectNode()) {
+    CHECK_FATAL(ReadNum() == kBinEaCgObjNode, "must be");
+    InEaCgObjNode(static_cast<EACGObjectNode&>(*node), newEaCg);
+  } else if (node->IsReferenceNode()) {
+    CHECK_FATAL(ReadNum() == kBinEaCgRefNode, "must be");
+    InEaCgRefNode(static_cast<EACGRefNode&>(*node));
+  }
+  InEaCgBaseNode(*node, newEaCg, false);
+  CHECK_FATAL(ReadNum() == ~kBinEaCgNode, "must be");
+  return *node;
+}
+
+EAConnectionGraph* BinaryMplImport::ReadEaCgField() {
+  if (ReadNum() == ~kBinEaCgStart) {
+    return nullptr;
+  }
+  ReadInt();
+  GStrIdx funcStr = ImportStr();
+  int nodesSize = ReadInt();
+  EAConnectionGraph *newEaCg = mod.GetMemPool()->New<EAConnectionGraph>(&mod, &mod.GetMPAllocator(), funcStr, true);
+  newEaCg->ResizeNodes(nodesSize, nullptr);
+  InEaCgNode(*newEaCg);
+  CHECK_FATAL(newEaCg->GetNode(0)->IsObjectNode(), "must be");
+  CHECK_FATAL(newEaCg->GetNode(1)->IsReferenceNode(), "must be");
+  CHECK_FATAL(newEaCg->GetNode(2)->IsFieldNode(), "must be");
+  newEaCg->globalField = static_cast<EACGFieldNode*>(newEaCg->GetNode(2));
+  newEaCg->globalObj = static_cast<EACGObjectNode*>(newEaCg->GetNode(0));
+  newEaCg->globalRef = static_cast<EACGRefNode*>(newEaCg->GetNode(1));
+  CHECK_FATAL(newEaCg->globalField && newEaCg->globalObj && newEaCg->globalRef, "must be");
+  int32 nodeSize = ReadInt();
+  for (int j = 0; j < nodeSize; ++j) {
+    EACGBaseNode *node = &InEaCgNode(*newEaCg);
+    newEaCg->funcArgNodes.push_back(node);
+  }
+
+  int32 callSitesize = ReadInt();
+  for (int i = 0; i < callSitesize; ++i) {
+    uint32 id = static_cast<uint32>(ReadInt());
+    newEaCg->callSite2Nodes[id] = mod.GetMemPool()->New<MapleVector<EACGBaseNode*>>(mod.GetMPAllocator().Adapter());
+    int32 calleeArgSize = ReadInt();
+    for (int j = 0; j < calleeArgSize; ++j) {
+      EACGBaseNode *node = &InEaCgNode(*newEaCg);
+      newEaCg->callSite2Nodes[id]->push_back(node);
+    }
+  }
+
+#ifdef DEBUG
+  for (EACGBaseNode *node : newEaCg->GetNodes()) {
+    if (node == nullptr) {
+      continue;
+    }
+    node->CheckAllConnectionInNodes();
+  }
+#endif
+  CHECK_FATAL(ReadNum() == ~kBinEaCgStart, "pattern mismatch in Read EACG");
+  return newEaCg;
+}
+
+void BinaryMplImport::ReadSymField() {
+  SkipTotalSize();
+  int32 size = ReadInt();
+  for (int64 i = 0; i < size; i++) {
+    (void)InSymbol(nullptr);
+  }
+  int64 tag = ReadNum();
+  CHECK_FATAL(tag == ~kBinSymStart, "pattern mismatch in Read SYM");
+  return;
+}
+
+void BinaryMplImport::ReadSymTabField() {
+  SkipTotalSize();
+  int32 size = ReadInt();
+  for (int64 i = 0; i < size; i++) {
+    std::string str;
+    ReadAsciiStr(str);
+  }
+  int64 tag = ReadNum();
+  CHECK_FATAL(tag == ~kBinSymTabStart, "pattern mismatch in Read TYPE");
+  return;
+}
+
+void BinaryMplImport::ReadContentField() {
+  SkipTotalSize();
+
+  int32 size = ReadInt();
+  int64 item;
+  int32 offset;
+  for (int32 i = 0; i < size; ++i) {
+    item = ReadNum();
+    offset = ReadInt();
+    content[item] = offset;
+  }
+  CHECK_FATAL(ReadNum() == ~kBinContentStart, "pattern mismatch in Read CONTENT");
+}
+
+void BinaryMplImport::Jump2NextField() {
+  uint32 totalSize = static_cast<uint32>(ReadInt());
+  bufI += (totalSize - sizeof(uint32));
+  ReadNum();  // skip end tag for this field
+}
+
+bool BinaryMplImport::ImportForSrcLang(const std::string &fname, MIRSrcLang &srcLang) {
+  Reset();
+  ReadFileAt(fname, 0);
+  int32 magic = ReadInt();
+  if (kMpltMagicNumber != magic && (kMpltMagicNumber + 0x10) != magic) {
+    buf.clear();
+    return false;
+  }
+  importingFromMplt = kMpltMagicNumber == magic;
+  int64 fieldID = ReadNum();
+  while (fieldID != kBinFinish) {
+    switch (fieldID) {
+      case kBinHeaderStart: {
+        SkipTotalSize();
+        (void)ReadNum();  // skip flavor
+        srcLang = static_cast<MIRSrcLang>(ReadNum());
+        return true;
+      }
+      default: {
+        Jump2NextField();
+        break;
+      }
+    }
+    fieldID = ReadNum();
+  }
+  return false;
+}
+
+bool BinaryMplImport::Import(const std::string &fname, bool readSymbols, bool readSe) {
+  Reset();
+  ReadFileAt(fname, 0);
+  int32 magic = ReadInt();
+  if (kMpltMagicNumber != magic && (kMpltMagicNumber + 0x10) != magic) {
+    buf.clear();
+    return false;
+  }
+  importingFromMplt = kMpltMagicNumber == magic;
+  int64 fieldID = ReadNum();
+  if (readSe) {
+    while (fieldID != kBinFinish) {
+      if (fieldID == kBinSeStart) {
+#ifdef MPLT_DEBUG
+        LogInfo::MapleLogger() << "read SE of : " << fname << '\n';
+#endif
+        BinaryMplImport tmp(mod);
+        tmp.Reset();
+        tmp.buf = buf;
+        tmp.bufI = bufI;
+        tmp.importFileName = fname;
+        tmp.ReadSeField();
+        Jump2NextField();
+      } else if (fieldID == kBinEaStart) {
+        BinaryMplImport tmp(mod);
+        tmp.Reset();
+        tmp.buf = buf;
+        tmp.bufI = bufI;
+        tmp.importFileName = fname;
+        tmp.ReadEaField();
+        Jump2NextField();
+      } else {
+        Jump2NextField();
+      }
+      fieldID = ReadNum();
+    }
+    return true;
+  }
+  while (fieldID != kBinFinish) {
+    switch (fieldID) {
+      case kBinContentStart: {
+        ReadContentField();
+        break;
+      }
+      case kBinStrStart: {
+        ReadStrField();
+        break;
+      }
+      case kBinHeaderStart: {
+        ReadHeaderField();
+        break;
+      }
+      case kBinTypeStart: {
+        ReadTypeField();
+        break;
+      }
+      case kBinSymStart: {
+        if (readSymbols) {
+          ReadSymField();
+        } else {
+          Jump2NextField();
+        }
+        break;
+      }
+      case kBinSymTabStart: {
+        ReadSymTabField();
+        break;
+      }
+      case kBinCgStart: {
+        if (readSymbols) {
+#ifdef MPLT_DEBUG
+          LogInfo::MapleLogger() << "read CG of : " << fname << '\n';
+#endif
+          BinaryMplImport tmp(mod);
+          tmp.Reset();
+          tmp.inIPA = true;
+          tmp.buf = buf;
+          tmp.bufI = bufI;
+          tmp.importFileName = fname;
+          tmp.ReadCgField();
+          tmp.UpdateMethodSymbols();
+          Jump2NextField();
+        } else {
+          Jump2NextField();
+        }
+        break;
+      }
+      case kBinSeStart: {
+        Jump2NextField();
+        break;
+      }
+      case kBinEaStart: {
+        if (readSymbols) {
+#ifdef MPLT_DEBUG
+          LogInfo::MapleLogger() << "read EA of : " << fname << '\n';
+#endif
+          BinaryMplImport tmp(mod);
+          tmp.Reset();
+          tmp.buf = buf;
+          tmp.bufI = bufI;
+          tmp.importFileName = fname;
+          tmp.ReadEaField();
+          Jump2NextField();
+        } else {
+          Jump2NextField();
+        }
+        break;
+      }
+      case kBinFunctionBodyStart: {
+        ReadFunctionBodyField();
+        break;
+      }
+      case kBinEnumStart: {
+        ReadEnumField();
+        break;
+      }
+      default:
+        CHECK_FATAL(false, "should not run here");
+    }
+    fieldID = ReadNum();
+  }
+  UpdateMethodSymbols();
+  SetupEHRootType();
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/debug_info.cpp b/src/mapleall/maple_ir/src/debug_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..91857a69482951655fc1344e2217ec8c43d3c4a3
--- /dev/null
+++ b/src/mapleall/maple_ir/src/debug_info.cpp
@@ -0,0 +1,1972 @@
+/*
+ * Copyright (C) [2021-2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#include "debug_info.h"
+#include <cstring>
+#include "mir_builder.h"
+#include "printing.h"
+#include "maple_string.h"
+#include "global_tables.h"
+#include "mir_type.h"
+#include "securec.h"
+#include "mpl_logging.h"
+#include "version.h"
+#include "triple.h"
+
+namespace maple {
+extern const char *GetDwTagName(unsigned n);
+extern const char *GetDwFormName(unsigned n);
+extern const char *GetDwAtName(unsigned n);
+extern const char *GetDwOpName(unsigned n);
+extern const char *GetDwAteName(unsigned n);
+extern const char *GetDwCfaName(unsigned n);
+extern DwAte GetAteFromPTY(PrimType pty);
+
+constexpr uint32 kIndx2 = 2;
+constexpr uint32 kStructDBGSize = 8888;
+
+// DBGDie methods
+DBGDie::DBGDie(MIRModule *m, DwTag tag)
+    : module(m),
+      tag(tag),
+      id(m->GetDbgInfo()->GetMaxId()),
+      withChildren(false),
+      keep(true),
+      sibling(nullptr),
+      firstChild(nullptr),
+      abbrevId(0),
+      tyIdx(0),
+      offset(0),
+      size(0),
+      attrVec(m->GetMPAllocator().Adapter()),
+      subDieVec(m->GetMPAllocator().Adapter()) {
+  if (module->GetDbgInfo()->GetParentDieSize() != 0) {
+    parent = module->GetDbgInfo()->GetParentDie();
+  } else {
+    parent = nullptr;
+  }
+  m->GetDbgInfo()->SetIdDieMap(m->GetDbgInfo()->GetIncMaxId(), this);
+  attrVec.clear();
+  subDieVec.clear();
+}
+
+void DBGDie::ResetParentDie() const {
+  module->GetDbgInfo()->ResetParentDie();
+}
+
+void DBGDie::AddAttr(DwAt at, DwForm form, uint64 val, bool keepFlag) {
+  // collect strps which need label
+  if (form == DW_FORM_strp) {
+    module->GetDbgInfo()->AddStrps(static_cast<uint32>(val));
+  }
+  DBGDieAttr *attr = module->GetDbgInfo()->CreateAttr(at, form, val);
+  attr->SetKeep(keepFlag);
+  AddAttr(attr);
+}
+
+void DBGDie::AddSimpLocAttr(DwAt at, DwForm form, DwOp op, uint64 val) {
+  DBGExprLoc *p = module->GetMemPool()->New<DBGExprLoc>(module, op);
+  if (val != kDbgDefaultVal) {
+    p->AddSimpLocOpnd(val);
+  }
+  DBGDieAttr *attr = module->GetDbgInfo()->CreateAttr(at, form, reinterpret_cast<uint64>(p));
+  AddAttr(attr);
+}
+
+void DBGDie::AddGlobalLocAttr(DwAt at, DwForm form, uint64 val) {
+  DBGExprLoc *p = module->GetMemPool()->New<DBGExprLoc>(module, DW_OP_addr);
+  p->SetGvarStridx(static_cast<int>(val));
+  DBGDieAttr *attr = module->GetDbgInfo()->CreateAttr(at, form, reinterpret_cast<uint64>(p));
+  AddAttr(attr);
+}
+
+void DBGDie::AddFrmBaseAttr(DwAt at, DwForm form) {
+  DBGExprLoc *p = module->GetMemPool()->New<DBGExprLoc>(module, DW_OP_call_frame_cfa);
+  DBGDieAttr *attr = module->GetDbgInfo()->CreateAttr(at, form, reinterpret_cast<uint64>(p));
+  AddAttr(attr);
+}
+
+DBGExprLoc *DBGDie::GetExprLoc() {
+  for (auto it : attrVec) {
+    if (it->GetDwAt() == DW_AT_location) {
+      return it->GetPtr();
+    }
+  }
+  return nullptr;
+}
+
+bool DBGDie::SetAttr(DwAt attr, uint64 val) {
+  for (auto it : attrVec) {
+    if (it->GetDwAt() == attr) {
+      it->SetU(val);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool DBGDie::SetAttr(DwAt attr, int32 val) {
+  for (auto it : attrVec) {
+    if (it->GetDwAt() == attr) {
+      it->SetI(val);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool DBGDie::SetAttr(DwAt attr, uint32 val) {
+  for (auto it : attrVec) {
+    if (it->GetDwAt() == attr) {
+      it->SetId(val);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool DBGDie::SetAttr(DwAt attr, int64 val) {
+  for (auto it : attrVec) {
+    if (it->GetDwAt() == attr) {
+      it->SetJ(val);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool DBGDie::SetAttr(DwAt attr, float val) {
+  for (auto it : attrVec) {
+    if (it->GetDwAt() == attr) {
+      it->SetF(val);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool DBGDie::SetAttr(DwAt attr, double val) {
+  for (auto it : attrVec) {
+    if (it->GetDwAt() == attr) {
+      it->SetD(val);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool DBGDie::SetAttr(DwAt attr, DBGExprLoc *ptr) {
+  for (auto it : attrVec) {
+    if (it->GetDwAt() == attr) {
+      it->SetPtr(ptr);
+      return true;
+    }
+  }
+  return false;
+}
+
+void DBGDie::AddAttr(DBGDieAttr *attr) {
+  for (auto it : attrVec) {
+    if (it->GetDwAt() == attr->GetDwAt()) {
+      return;
+    }
+  }
+  attrVec.push_back(attr);
+}
+
+void DBGDie::AddSubVec(DBGDie *die) {
+  if (!die) {
+    return;
+  }
+  for (auto it : subDieVec) {
+    if (it->GetId() == die->GetId()) {
+      return;
+    }
+  }
+  subDieVec.push_back(die);
+  die->parent = this;
+}
+
+// DBGAbbrevEntry methods
+DBGAbbrevEntry::DBGAbbrevEntry(MIRModule *m, DBGDie *die) : attrPairs(m->GetMPAllocator().Adapter()) {
+  tag = die->GetTag();
+  abbrevId = 0;
+  withChildren = die->GetWithChildren();
+  for (auto it : die->GetAttrVec()) {
+    if (!it->GetKeep()) {
+      continue;
+    }
+    attrPairs.push_back(it->GetDwAt());
+    attrPairs.push_back(it->GetDwForm());
+  }
+}
+
+bool DBGAbbrevEntry::Equalto(DBGAbbrevEntry *entry) {
+  if (attrPairs.size() != entry->attrPairs.size()) {
+    return false;
+  }
+  if (withChildren != entry->GetWithChildren()) {
+    return false;
+  }
+  for (uint32 i = 0; i < attrPairs.size(); i++) {
+    if (attrPairs[i] != entry->attrPairs[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// DebugInfo methods
+void DebugInfo::Init() {
+  mplSrcIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(module->GetFileName());
+  compUnit = module->GetMemPool()->New<DBGDie>(module, DW_TAG_compile_unit);
+  module->SetWithDbgInfo(true);
+  ResetParentDie();
+  if (module->GetSrcLang() == kSrcLangC) {
+    varPtrPrefix = "";
+  }
+  InitBaseTypeMap();
+}
+
+GStrIdx DebugInfo::GetPrimTypeCName(PrimType pty) {
+  GStrIdx strIdx = GStrIdx(0);
+  switch (pty) {
+#define TYPECNAME(p, n) \
+    case PTY_##p: \
+      strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(n); \
+      break
+
+    TYPECNAME(i8,   "char");
+    TYPECNAME(i16,  "short");
+    TYPECNAME(i32,  "int");
+    TYPECNAME(i64,  "long long");
+    TYPECNAME(i128, "int128");
+    TYPECNAME(u8,   "unsigned char");
+    TYPECNAME(u16,  "unsigned short");
+    TYPECNAME(u32,  "unsigned int");
+    TYPECNAME(u64,  "unsigned long long");
+    TYPECNAME(u128, "uint128");
+    TYPECNAME(u1,   "bool");
+    TYPECNAME(f32,  "float");
+    TYPECNAME(f64,  "double");
+    TYPECNAME(f128, "float128");
+    TYPECNAME(c64,  "complex");
+    TYPECNAME(c128, "double complex");
+    default:
+      break;
+  }
+  return strIdx;
+}
+
+void DebugInfo::InsertBaseTypeMap(const std::string &inputName, const std::string &outpuName, PrimType type) {
+  baseTypeMap[GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(inputName)] = std::make_pair(
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(outpuName), type);
+}
+
+void DebugInfo::InitBaseTypeMap() {
+  InsertBaseTypeMap(kDbgLong, "long", Triple::GetTriple().GetEnvironment() == Triple::GNUILP32 ? PTY_i32 : PTY_i64);
+  InsertBaseTypeMap(kDbgULong, "unsigned long",
+                    Triple::GetTriple().GetEnvironment() == Triple::GNUILP32 ? PTY_u32 : PTY_u64);
+  InsertBaseTypeMap(kDbgLongDouble, "long double", PTY_f64);
+}
+
+void DebugInfo::SetupCU() {
+  compUnit->SetWithChildren(true);
+  /* Add the Producer (Compiler) Information */
+  const char *producer = strdup((std::string("Maple Version ") + Version::GetVersionStr()).c_str());
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(producer);
+  delete producer;
+  producer = nullptr;
+  compUnit->AddAttr(DW_AT_producer, DW_FORM_strp, strIdx.GetIdx());
+
+  /* Source Languate  */
+  compUnit->AddAttr(DW_AT_language, DW_FORM_data4, DW_LANG_C99);
+
+  /* Add the compiled source file information */
+  compUnit->AddAttr(DW_AT_name, DW_FORM_strp, mplSrcIdx.GetIdx());
+  compUnit->AddAttr(DW_AT_comp_dir, DW_FORM_strp, 0);
+
+  compUnit->AddAttr(DW_AT_low_pc, DW_FORM_addr, kDbgDefaultVal);
+  compUnit->AddAttr(DW_AT_high_pc, DW_FORM_data8, kDbgDefaultVal);
+
+  compUnit->AddAttr(DW_AT_stmt_list, DW_FORM_sec_offset, kDbgDefaultVal);
+}
+
+void DebugInfo::AddScopeDie(MIRScope *scope) {
+  if (!scope || scope->IsEmpty()) {
+    return;
+  }
+
+  bool isLocal = scope->IsLocal();
+  MIRFunction *func = GetCurFunction();
+  // for non-function local scope, add a lexical block
+  bool createBlock = isLocal && (scope != func->GetScope());
+  if (createBlock) {
+    DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_lexical_block);
+    die->AddAttr(DW_AT_low_pc, DW_FORM_addr, scope->GetId());
+    die->AddAttr(DW_AT_high_pc, DW_FORM_data8, scope->GetId());
+
+    // add die to parent
+    GetParentDie()->AddSubVec(die);
+
+    PushParentDie(die);
+  }
+
+  // process type alias
+  HandleTypeAlias(*scope);
+
+  // process alias
+  AddAliasDies(*scope, isLocal);
+
+  if (scope->GetSubScopes().size() > 0) {
+    // process subScopes
+    for (auto it : scope->GetSubScopes()) {
+      AddScopeDie(it);
+    }
+  }
+
+  if (createBlock) {
+    PopParentDie();
+  }
+}
+
+DBGDie *DebugInfo::GetAliasVarTypeDie(const MIRAliasVars &aliasVar, TyIdx tyidx) {
+  DBGDie *typeDie = nullptr;
+  uint32 index = aliasVar.index;
+  switch (aliasVar.atk) {
+    case kATKType:
+      typeDie = GetOrCreateTypeDie(TyIdx(index));
+      break;
+    case kATKString:
+      typeDie = GetOrCreateTypedefDie(GStrIdx(index), tyidx);
+      break;
+    case kATKEnum:
+      typeDie = GetOrCreateEnumTypeDie(index);
+      break;
+    default:
+      ASSERT(false, "unknown alias type kind");
+      break;
+  }
+
+  ASSERT(typeDie, "null alias type DIE");
+  return GetOrCreateTypeDieWithAttr(aliasVar.attrs, typeDie);
+}
+
+DBGDie *DebugInfo::GetOrCreateTypeByNameDie(const MIRType &type) {
+  ASSERT(type.GetKind() == kTypeByName, "must be a typename");
+  DBGDie *die = GetOrCreateBaseTypeDie(&type);
+  if (die != nullptr) {
+    return die;
+  }
+  // look for the enum first
+  for (auto &it : GlobalTables::GetEnumTable().enumTable) {
+    if (it->GetNameIdx() == type.GetNameStrIdx()) {
+      die = GetOrCreateEnumTypeDie(it);
+      break;
+    }
+  }
+  if (!die) {
+    // look for the typedef
+    TyIdx undlyingTypeIdx = module->GetScope()->GetTypeAlias()->GetTyIdxFromMap(type.GetNameStrIdx());
+    CHECK_FATAL(undlyingTypeIdx != TyIdx(0), "typedef not found in TypeAliasTable");
+    die = GetOrCreateTypedefDie(type.GetNameStrIdx(), undlyingTypeIdx);
+  }
+  return die;
+}
+
+void DebugInfo::HandleTypeAlias(MIRScope &scope) {
+  const MIRTypeAlias *typeAlias = scope.GetTypeAlias();
+  if (typeAlias == nullptr) {
+    return;
+  }
+
+  if (scope.IsLocal()) {
+    for (auto &i : typeAlias->GetTypeAliasMap()) {
+      uint32 tid = i.second.GetIdx();
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tid);
+      CHECK_NULL_FATAL(type);
+      DBGDie *die = nullptr;
+      if (type->GetKind() == kTypeByName) {
+        die = GetOrCreateTypeByNameDie(*type);
+      } else if (tyIdxDieIdMap.find(tid) != tyIdxDieIdMap.end()) {
+        uint32 id = tyIdxDieIdMap[tid];
+        die = idDieMap[id];
+      } else {
+        ASSERT(false, "type alias type not in tyIdxDieIdMap");
+        continue;
+      }
+      (void)die->SetAttr(DW_AT_name, i.first.GetIdx());
+      AddStrps(i.first.GetIdx());
+    }
+  } else {
+    for (auto it : typeAlias->GetTypeAliasMap()) {
+      globalTypeAliasMap[it.first.GetIdx()] = it.second.GetIdx();
+    }
+
+    for (auto it : globalTypeAliasMap) {
+      (void)GetOrCreateTypeDie(TyIdx(it.second));
+      DBGDie *die = GetOrCreateTypedefDie(GStrIdx(it.first), TyIdx(it.second));
+      compUnit->AddSubVec(die);
+      // associate typedef's type with die
+      for (auto i : module->GetTypeNameTab()->GetGStrIdxToTyIdxMap()) {
+        if (i.first.GetIdx() == it.first) {
+          tyIdxDieIdMap[i.second.GetIdx()] = die->GetId();
+          break;
+        }
+      }
+    }
+  }
+}
+
+void DebugInfo::AddAliasDies(MIRScope &scope, bool isLocal) {
+  MIRFunction *func = GetCurFunction();
+  for (auto &i : scope.GetAliasVarMap()) {
+    // maple var and die
+    MIRSymbol *mplVar = nullptr;
+    DBGDie *mplDie = nullptr;
+    GStrIdx mplIdx = i.second.mplStrIdx;
+    if (i.second.isLocal) {
+      mplVar = func->GetSymTab()->GetSymbolFromStrIdx(mplIdx);
+      mplDie = GetLocalDie(mplIdx);
+    } else {
+      mplVar = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(mplIdx);
+      mplDie = GetGlobalDie(mplIdx);
+    }
+    // some global vars are introduced by system, and
+    // some local vars are discarded in O2, skip them
+    if (mplVar == nullptr || mplDie == nullptr) {
+      continue;
+    }
+
+    // for local scope, create alias die using maple var except name and type
+    // for global scope, update type only if needed
+    bool updateOnly = (isLocal == i.second.isLocal && i.first == mplIdx);
+    DBGDie *vdie = updateOnly ? mplDie : CreateVarDie(mplVar, i.first);
+
+    // get type from alias
+    DBGDie *typeDie = GetAliasVarTypeDie(i.second, mplVar->GetTyIdx());
+    vdie->SetAttr(DW_AT_type, typeDie->GetId());
+
+    // for new var
+    if (!updateOnly) {
+      // link vdie's ExprLoc to mplDie's
+      vdie->LinkExprLoc(mplDie);
+
+      GetParentDie()->AddSubVec(vdie);
+
+      // add alias var name to debug_str section
+      strps.insert(i.first.GetIdx());
+    }
+  }
+}
+
+void DebugInfo::CollectScopePos(MIRFunction *func, MIRScope *scope) {
+  if (scope != func->GetScope()) {
+    ScopePos plow;
+    plow.id = scope->GetId();
+    plow.pos = scope->GetRangeLow();
+    funcScopeLows[func].push_back(plow);
+
+    ScopePos phigh;
+    phigh.id = scope->GetId();
+    phigh.pos = scope->GetRangeHigh();
+    funcScopeHighs[func].push_back(phigh);
+  }
+
+  if (scope->GetSubScopes().size() > 0) {
+    for (auto it : scope->GetSubScopes()) {
+      CollectScopePos(func, it);
+    }
+  }
+}
+
+// result is in idSet,
+// a set of scope ids which are crossed from oldSrcPos to newSrcPos
+void DebugInfo::GetCrossScopeId(MIRFunction *func,
+                                std::unordered_set<uint32> &idSet,
+                                bool isLow,
+                                const SrcPosition &oldSrcPos,
+                                const SrcPosition &newSrcPos) {
+  if (isLow) {
+    for (auto &it : funcScopeLows[func]) {
+      if (oldSrcPos.IsBf(it.pos) && (it.pos).IsBfOrEq(newSrcPos)) {
+        idSet.insert(it.id);
+      }
+    }
+  } else {
+    if (oldSrcPos.IsEq(newSrcPos)) {
+      return;
+    }
+    for (auto &it : funcScopeHighs[func]) {
+      if (oldSrcPos.IsBfOrEq(it.pos) && (it.pos).IsBf(newSrcPos)) {
+        idSet.insert(it.id);
+      }
+    }
+  }
+}
+
+void DebugInfo::Finish() {
+  SetupCU();
+  // build tree from root DIE compUnit
+  BuildDieTree();
+  BuildAbbrev();
+  ComputeSizeAndOffsets();
+}
+
+void DebugInfo::BuildDebugInfoEnums() {
+  auto size = GlobalTables::GetEnumTable().enumTable.size();
+  for (size_t i = 0; i < size; ++i) {
+    DBGDie *die = GetOrCreateEnumTypeDie(i);
+    compUnit->AddSubVec(die);
+  }
+}
+
+void DebugInfo::BuildDebugInfoContainers() {
+  for (auto it : module->GetTypeNameTab()->GetGStrIdxToTyIdxMap()) {
+    TyIdx tyIdx = it.second;
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx.GetIdx());
+
+    switch (type->GetKind()) {
+      case kTypeClass:
+      case kTypeClassIncomplete:
+      case kTypeInterface:
+      case kTypeInterfaceIncomplete:
+      case kTypeStruct:
+      case kTypeStructIncomplete:
+      case kTypeUnion:
+        (void)GetOrCreateStructTypeDie(type);
+        break;
+      case kTypeByName:
+        if (globalTypeAliasMap.find(it.first.GetIdx()) == globalTypeAliasMap.end()) {
+#ifdef DEBUG
+          // not typedef
+          LogInfo::MapleLogger() << "named type "
+                                 << GlobalTables::GetStrTable().GetStringFromStrIdx(it.first).c_str()
+                                 << "\n";
+#endif /* DEBUG */
+        }
+        break;
+      default:
+        ASSERT(false, "unknown case in BuildDebugInfoContainers()");
+        break;
+    }
+  }
+}
+
+void DebugInfo::BuildDebugInfoGlobalSymbols() {
+  for (size_t i = 0; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
+    MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(static_cast<uint32>(i));
+    if (mirSymbol == nullptr || mirSymbol->IsDeleted() || mirSymbol->GetStorageClass() == kScUnused ||
+        mirSymbol->GetStorageClass() == kScExtern) {
+      continue;
+    }
+    if (module->IsCModule() && mirSymbol->IsGlobal() && mirSymbol->IsVar()) {
+      DBGDie *vdie = CreateVarDie(mirSymbol);
+      compUnit->AddSubVec(vdie);
+    }
+  }
+}
+
+void DebugInfo::BuildDebugInfoFunctions() {
+  for (auto func : GlobalTables::GetFunctionTable().GetFuncTable()) {
+    // the first one in funcTable is nullptr
+    if (!func) {
+      continue;
+    }
+    SetCurFunction(func);
+    // function decl
+    if (stridxDieIdMap.find(func->GetNameStrIdx().GetIdx()) == stridxDieIdMap.end()) {
+      DBGDie *funcDie = GetOrCreateFuncDeclDie(func);
+      if (!func->GetClassTyIdx().GetIdx() && func->GetBody()) {
+        compUnit->AddSubVec(funcDie);
+      }
+    }
+    // function def
+    unsigned idx = func->GetNameStrIdx().GetIdx();
+    if (func->GetBody() && funcDefStrIdxDieIdMap.find(idx) == funcDefStrIdxDieIdMap.end()) {
+      DBGDie *funcDie = GetOrCreateFuncDefDie(func);
+      if (!func->GetClassTyIdx().GetIdx()) {
+        compUnit->AddSubVec(funcDie);
+      }
+    }
+  }
+}
+
+void DebugInfo::BuildDebugInfo() {
+  ASSERT(module->GetDbgInfo(), "null dbgInfo");
+
+  Init();
+
+  // setup debug info for enum types
+  BuildDebugInfoEnums();
+
+  // setup debug info for global type alias
+  HandleTypeAlias(*module->GetScope());
+
+  // containner types
+  BuildDebugInfoContainers();
+
+  // setup debug info for global symbols
+  BuildDebugInfoGlobalSymbols();
+
+  // handle global scope
+  AddScopeDie(module->GetScope());
+
+  // setup debug info for functions
+  BuildDebugInfoFunctions();
+
+  // finalize debug info
+  Finish();
+}
+
+DBGDieAttr *DebugInfo::CreateAttr(DwAt at, DwForm form, uint64 val) const {
+  DBGDieAttr *attr = module->GetMemPool()->New<DBGDieAttr>(kDwAt);
+  attr->SetDwAt(at);
+  attr->SetDwForm(form);
+  attr->SetU(val);
+  return attr;
+}
+
+void DebugInfo::SetLocalDie(MIRFunction *func, GStrIdx strIdx, const DBGDie *die) {
+  (funcLstrIdxDieIdMap[func])[strIdx.GetIdx()] = die->GetId();
+}
+
+DBGDie *DebugInfo::GetGlobalDie(const GStrIdx &strIdx) {
+  unsigned idx = strIdx.GetIdx();
+  auto it = globalStridxDieIdMap.find(idx);
+  if (it != globalStridxDieIdMap.end()) {
+    return idDieMap[it->second];
+  }
+  return nullptr;
+}
+
+DBGDie *DebugInfo::GetLocalDie(MIRFunction *func, GStrIdx strIdx) {
+  uint32 id = (funcLstrIdxDieIdMap[func])[strIdx.GetIdx()];
+  auto it = idDieMap.find(id);
+  if (it != idDieMap.end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+void DebugInfo::SetLocalDie(GStrIdx strIdx, const DBGDie *die) {
+  (funcLstrIdxDieIdMap[GetCurFunction()])[strIdx.GetIdx()] = die->GetId();
+}
+
+DBGDie *DebugInfo::GetLocalDie(GStrIdx strIdx) {
+  return GetLocalDie(GetCurFunction(), strIdx);
+}
+
+void DebugInfo::SetLabelIdx(MIRFunction *func, const GStrIdx &strIdx, LabelIdx labIdx) {
+  (funcLstrIdxLabIdxMap[func])[strIdx.GetIdx()] = labIdx;
+}
+
+LabelIdx DebugInfo::GetLabelIdx(MIRFunction *func, GStrIdx strIdx) {
+  LabelIdx labidx = (funcLstrIdxLabIdxMap[func])[strIdx.GetIdx()];
+  return labidx;
+}
+
+void DebugInfo::SetLabelIdx(const GStrIdx &strIdx, LabelIdx labIdx) {
+  (funcLstrIdxLabIdxMap[GetCurFunction()])[strIdx.GetIdx()] = labIdx;
+}
+
+LabelIdx DebugInfo::GetLabelIdx(GStrIdx strIdx) {
+  LabelIdx labidx = (funcLstrIdxLabIdxMap[GetCurFunction()])[strIdx.GetIdx()];
+  return labidx;
+}
+
+static DwOp GetBreg(unsigned i) {
+  constexpr DwOp baseOpRegs[] = {
+      DW_OP_breg0,
+      DW_OP_breg1,
+      DW_OP_breg2,
+      DW_OP_breg3,
+      DW_OP_breg4,
+      DW_OP_breg5,
+      DW_OP_breg6,
+      DW_OP_breg7,
+  };
+
+  // struct parameters size larger than 8 are converted into pointers
+  constexpr uint32 struct2PtrSize = 8;
+  if (i < struct2PtrSize) {
+    return baseOpRegs[i];
+  }
+  return DW_OP_breg0;
+}
+
+DBGDie *DebugInfo::CreateFormalParaDie(MIRFunction *func, uint32 idx, bool isDef) {
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_formal_parameter);
+
+  TyIdx tyIdx = func->GetFormalDefAt(idx).formalTyIdx;
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  DBGDie *typeDie = GetOrCreateTypeDie(type);
+  die->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+
+  /* var */
+  MIRSymbol *sym = func->GetFormalDefAt(idx).formalSym;
+  if (isDef && sym) {
+    die->AddAttr(DW_AT_name, DW_FORM_strp, sym->GetNameStrIdx().GetIdx());
+    die->AddAttr(DW_AT_decl_file, DW_FORM_data4, sym->GetSrcPosition().FileNum());
+    die->AddAttr(DW_AT_decl_line, DW_FORM_data4, sym->GetSrcPosition().LineNum());
+    die->AddAttr(DW_AT_decl_column, DW_FORM_data4, sym->GetSrcPosition().Column());
+    DwOp op = DW_OP_fbreg;
+    if (type->IsStructType() && (static_cast<MIRStructType *>(type)->GetSize() > k64BitSize)) {
+      op = GetBreg(idx);
+    }
+    die->AddSimpLocAttr(DW_AT_location, DW_FORM_exprloc, op, kDbgDefaultVal);
+    SetLocalDie(func, sym->GetNameStrIdx(), die);
+  }
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreateLabelDie(LabelIdx labid) {
+  MIRFunction *func = GetCurFunction();
+  CHECK(labid < func->GetLabelTab()->GetLabelTableSize(), "index out of range in DebugInfo::GetOrCreateLabelDie");
+  GStrIdx strid = func->GetLabelTab()->GetSymbolFromStIdx(labid);
+  if ((funcLstrIdxDieIdMap[func]).size() &&
+      (funcLstrIdxDieIdMap[func]).find(strid.GetIdx()) != (funcLstrIdxDieIdMap[func]).end()) {
+    return GetLocalDie(strid);
+  }
+
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_label);
+  die->AddAttr(DW_AT_name, DW_FORM_strp, strid.GetIdx());
+  die->AddAttr(DW_AT_decl_file, DW_FORM_data4, mplSrcIdx.GetIdx());
+  die->AddAttr(DW_AT_decl_line, DW_FORM_data4, lexer->GetLineNum());
+  die->AddAttr(DW_AT_low_pc, DW_FORM_addr, kDbgDefaultVal);
+  GetParentDie()->AddSubVec(die);
+  SetLocalDie(strid, die);
+  SetLabelIdx(strid, labid);
+  return die;
+}
+
+DBGDie *DebugInfo::CreateVarDie(MIRSymbol *sym) {
+  // filter vtab
+  if (sym->GetName().find(VTAB_PREFIX_STR) == 0) {
+    return nullptr;
+  }
+
+  if (sym->GetName().find(GCTIB_PREFIX_STR) == 0) {
+    return nullptr;
+  }
+
+  if (sym->GetStorageClass() == kScFormal) {
+    return nullptr;
+  }
+
+  bool isLocal = sym->IsLocal();
+  GStrIdx strIdx = sym->GetNameStrIdx();
+
+  if (isLocal) {
+    MIRFunction *func = GetCurFunction();
+    if ((funcLstrIdxDieIdMap[func]).size() &&
+        (funcLstrIdxDieIdMap[func]).find(strIdx.GetIdx()) != (funcLstrIdxDieIdMap[func]).end()) {
+      return GetLocalDie(strIdx);
+    }
+  } else {
+    if (globalStridxDieIdMap.find(strIdx.GetIdx()) != globalStridxDieIdMap.end()) {
+      uint32 id = globalStridxDieIdMap[strIdx.GetIdx()];
+      return idDieMap[id];
+    }
+  }
+
+  DBGDie *die = CreateVarDie(sym, strIdx);
+
+  GetParentDie()->AddSubVec(die);
+  if (isLocal) {
+    SetLocalDie(strIdx, die);
+  } else {
+    globalStridxDieIdMap[strIdx.GetIdx()] = die->GetId();
+  }
+
+  return die;
+}
+
+DBGDie *DebugInfo::CreateVarDie(MIRSymbol *sym, const GStrIdx &strIdx) {
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_variable);
+
+  /* var Name */
+  die->AddAttr(DW_AT_name, DW_FORM_strp, strIdx.GetIdx());
+  die->AddAttr(DW_AT_decl_file, DW_FORM_data4, sym->GetSrcPosition().FileNum());
+  die->AddAttr(DW_AT_decl_line, DW_FORM_data4, sym->GetSrcPosition().LineNum());
+  die->AddAttr(DW_AT_decl_column, DW_FORM_data4, sym->GetSrcPosition().Column());
+
+  bool isLocal = sym->IsLocal();
+  if (isLocal) {
+    if (sym->IsPUStatic()) {
+      // Use actual internal sym by cg
+      PUIdx pIdx = GetCurFunction()->GetPuidx();
+      std::string ptrName = sym->GetName() + std::to_string(pIdx);
+      uint64 idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(ptrName).GetIdx();
+      die->AddGlobalLocAttr(DW_AT_location, DW_FORM_exprloc, idx);
+    } else {
+      die->AddSimpLocAttr(DW_AT_location, DW_FORM_exprloc, DW_OP_fbreg, kDbgDefaultVal);
+    }
+  } else {
+    // global var just use its name as address in .s
+    uint64 idx = strIdx.GetIdx();
+    if ((sym->IsReflectionClassInfo() && !sym->IsReflectionArrayClassInfo()) || sym->IsStatic()) {
+      std::string ptrName = varPtrPrefix + sym->GetName();
+      idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(ptrName).GetIdx();
+    }
+    die->AddGlobalLocAttr(DW_AT_location, DW_FORM_exprloc, idx);
+  }
+
+  MIRType *type = sym->GetType();
+  DBGDie *typeDie = GetOrCreateTypeDie(type);
+  DBGDie *newDie = GetOrCreateTypeDieWithAttr(sym->GetAttrs(), typeDie);
+  die->AddAttr(DW_AT_type, DW_FORM_ref4, newDie->GetId());
+
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreateFuncDeclDie(MIRFunction *func) {
+  uint32 funcnameidx = func->GetNameStrIdx().GetIdx();
+  if (stridxDieIdMap.find(funcnameidx) != stridxDieIdMap.end()) {
+    uint32 id = stridxDieIdMap[funcnameidx];
+    return idDieMap[id];
+  }
+
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_subprogram);
+  stridxDieIdMap[funcnameidx] = die->GetId();
+
+  die->AddAttr(DW_AT_external, DW_FORM_flag_present, 1);
+
+  // Function Name
+  MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
+
+  die->AddAttr(DW_AT_name, DW_FORM_strp, funcnameidx);
+  die->AddAttr(DW_AT_decl_file, DW_FORM_data4, sym->GetSrcPosition().FileNum());
+  die->AddAttr(DW_AT_decl_line, DW_FORM_data4, sym->GetSrcPosition().LineNum());
+  die->AddAttr(DW_AT_decl_column, DW_FORM_data4, sym->GetSrcPosition().Column());
+
+  // Attributes for DW_AT_accessibility
+  uint32 access = 0;
+  if (func->IsPublic()) {
+    access = DW_ACCESS_public;
+  } else if (func->IsPrivate()) {
+    access = DW_ACCESS_private;
+  } else if (func->IsProtected()) {
+    access = DW_ACCESS_protected;
+  }
+  if (access != 0) {
+    die->AddAttr(DW_AT_accessibility, DW_FORM_data4, access);
+  }
+
+  die->AddAttr(DW_AT_GNU_all_tail_call_sites, DW_FORM_flag_present, kDbgDefaultVal);
+
+  PushParentDie(die);
+
+  // formal parameter
+  for (uint32 i = 0; i < func->GetFormalCount(); i++) {
+    DBGDie *param = CreateFormalParaDie(func, i, false);
+    die->AddSubVec(param);
+  }
+
+  if (func->IsVarargs()) {
+    DBGDie *varargDie = module->GetMemPool()->New<DBGDie>(module, DW_TAG_unspecified_parameters);
+    die->AddSubVec(varargDie);
+  }
+
+  PopParentDie();
+
+  return die;
+}
+
+bool LIsCompilerGenerated(const MIRFunction *func) {
+  return ((func->GetName().c_str())[0] != 'L');
+}
+
+void DebugInfo::CreateFuncLocalSymbolsDies(MIRFunction *func, DBGDie *die) {
+  if (func->GetSymTab()) {
+    // local variables, start from 1
+    for (uint32 i = 1; i < func->GetSymTab()->GetSymbolTableSize(); i++) {
+      MIRSymbol *var = func->GetSymTab()->GetSymbolFromStIdx(i);
+      DBGDie *vdie = CreateVarDie(var);
+      if (vdie == nullptr) {
+        continue;
+      }
+      die->AddSubVec(vdie);
+      // for C, source variable names will be used instead of mangloed maple variables
+      if (module->IsCModule()) {
+        vdie->SetKeep(false);
+      }
+    }
+  }
+}
+
+DBGDie *DebugInfo::GetOrCreateFuncDefDie(MIRFunction *func) {
+  uint32 funcnameidx = func->GetNameStrIdx().GetIdx();
+  if (funcDefStrIdxDieIdMap.find(funcnameidx) != funcDefStrIdxDieIdMap.end()) {
+    uint32 id = funcDefStrIdxDieIdMap[funcnameidx];
+    return idDieMap[id];
+  }
+
+  DBGDie *funcdecldie = GetOrCreateFuncDeclDie(func);
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_subprogram);
+  // update funcDefStrIdxDieIdMap and leave stridxDieIdMap for the func decl
+  funcDefStrIdxDieIdMap[funcnameidx] = die->GetId();
+
+  die->AddAttr(DW_AT_specification, DW_FORM_ref4, funcdecldie->GetId());
+  MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
+  die->AddAttr(DW_AT_decl_line, DW_FORM_data4, sym->GetSrcPosition().LineNum());
+
+  if (!func->IsReturnVoid()) {
+    auto returnType = func->GetReturnType();
+    DBGDie *typeDie = GetOrCreateTypeDie(returnType);
+    die->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+  }
+
+  die->AddAttr(DW_AT_low_pc, DW_FORM_addr, kDbgDefaultVal);
+  die->AddAttr(DW_AT_high_pc, DW_FORM_data8, kDbgDefaultVal);
+  die->AddFrmBaseAttr(DW_AT_frame_base, DW_FORM_exprloc);
+  if (!func->IsStatic() && !LIsCompilerGenerated(func)) {
+    die->AddAttr(DW_AT_object_pointer, DW_FORM_ref4, kDbgDefaultVal);
+  }
+  die->AddAttr(DW_AT_GNU_all_tail_call_sites, DW_FORM_flag_present, kDbgDefaultVal);
+
+  PushParentDie(die);
+
+  // formal parameter
+  for (uint32 i = 0; i < func->GetFormalCount(); i++) {
+    DBGDie *pdie = CreateFormalParaDie(func, i, true);
+    die->AddSubVec(pdie);
+  }
+
+  CreateFuncLocalSymbolsDies(func, die);
+
+  // add scope die
+  AddScopeDie(func->GetScope());
+  CollectScopePos(func, func->GetScope());
+
+  PopParentDie();
+
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreatePrimTypeDie(MIRType *ty) {
+  PrimType pty = ty->GetPrimType();
+  uint32 tid = static_cast<uint32>(pty);
+  if (tyIdxDieIdMap.find(tid) != tyIdxDieIdMap.end()) {
+    uint32 id = tyIdxDieIdMap[tid];
+    return idDieMap[id];
+  }
+
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_base_type);
+  die->SetTyIdx(static_cast<uint32>(pty));
+
+  GStrIdx strIdx = ty->GetNameStrIdx();
+  if (strIdx.GetIdx() == 0) {
+    std::string pname = std::string(GetPrimTypeName(ty->GetPrimType()));
+    strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(pname);
+    ty->SetNameStrIdx(strIdx);
+  }
+
+  die->AddAttr(DW_AT_byte_size, DW_FORM_data4, GetPrimTypeSize(pty));
+  die->AddAttr(DW_AT_encoding, DW_FORM_data4, GetAteFromPTY(pty));
+
+  // use C type name, int for i32 etc
+  if (module->IsCModule()) {
+    GStrIdx idx = GetPrimTypeCName(ty->GetPrimType());
+    if (idx.GetIdx() != 0) {
+      strIdx = idx;
+    }
+  }
+  die->AddAttr(DW_AT_name, DW_FORM_strp, strIdx.GetIdx());
+
+  compUnit->AddSubVec(die);
+  tyIdxDieIdMap[static_cast<uint32>(pty)] = die->GetId();
+  return die;
+}
+
+// At present, in order to solve the inaccurate expression of GetOrCreatePrimTypeDie for base types,
+// e.g. long or long long. We can consider using this interface uniformly for base types in the future.
+DBGDie *DebugInfo::GetOrCreateBaseTypeDie(const MIRType *type) {
+  uint32 tid = type->GetTypeIndex().GetIdx();
+  if (tyIdxDieIdMap.find(tid) != tyIdxDieIdMap.end()) {
+    uint32 id = tyIdxDieIdMap[tid];
+    return idDieMap[id];
+  }
+
+  auto iter = baseTypeMap.find(type->GetNameStrIdx());
+  if (iter == baseTypeMap.cend()) {
+    return nullptr;
+  }
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_base_type);
+  die->AddAttr(DW_AT_name, DW_FORM_strp, iter->second.first.GetIdx());
+  die->AddAttr(DW_AT_byte_size, DW_FORM_data4, GetPrimTypeSize(iter->second.second));
+  die->AddAttr(DW_AT_encoding, DW_FORM_data4, GetAteFromPTY(iter->second.second));
+
+  compUnit->AddSubVec(die);
+  tyIdxDieIdMap[type->GetTypeIndex().GetIdx()] = die->GetId();
+  return die;
+}
+
+DBGDie *DebugInfo::CreatePointedFuncTypeDie(MIRFuncType *fType) {
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_subroutine_type);
+
+  die->AddAttr(DW_AT_prototyped, DW_FORM_data4, static_cast<int>(fType->GetParamTypeList().size() > 0));
+  MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fType->GetRetTyIdx());
+  DBGDie *retTypeDie = GetOrCreateTypeDie(retType);
+  retTypeDie = GetOrCreateTypeDieWithAttr(fType->GetRetAttrs(), retTypeDie);
+  die->AddAttr(DW_AT_type, DW_FORM_ref4, retTypeDie->GetId());
+
+  compUnit->AddSubVec(die);
+
+  for (uint32 i = 0; i < fType->GetParamTypeList().size(); i++) {
+    DBGDie *paramDie = module->GetMemPool()->New<DBGDie>(module, DW_TAG_formal_parameter);
+    MIRType *paramType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fType->GetNthParamType(i));
+    DBGDie *paramTypeDie = GetOrCreateTypeDie(paramType);
+    paramDie->AddAttr(DW_AT_type, DW_FORM_ref4, paramTypeDie->GetId());
+    die->AddSubVec(paramDie);
+  }
+
+  tyIdxDieIdMap[fType->GetTypeIndex().GetIdx()] = die->GetId();
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreateTypeDieWithAttr(AttrKind attr, DBGDie *typeDie) {
+  DBGDie *die = typeDie;
+  uint32 dieId = typeDie->GetId();
+  uint32 newId = 0;
+  switch (attr) {
+    case ATTR_const:
+      if (constTypeDieMap.find(dieId) != constTypeDieMap.end()) {
+        newId = constTypeDieMap[dieId];
+        die = idDieMap[newId];
+      } else {
+        die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_const_type);
+        die->AddAttr(DW_AT_type, DW_FORM_ref4, dieId);
+        compUnit->AddSubVec(die);
+        newId = die->GetId();
+        constTypeDieMap[dieId] = newId;
+      }
+      break;
+    case ATTR_volatile:
+      if (volatileTypeDieMap.find(dieId) != volatileTypeDieMap.end()) {
+        newId = volatileTypeDieMap[dieId];
+        die = idDieMap[newId];
+      } else {
+        die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_volatile_type);
+        die->AddAttr(DW_AT_type, DW_FORM_ref4, dieId);
+        compUnit->AddSubVec(die);
+        newId = die->GetId();
+        volatileTypeDieMap[dieId] = newId;
+      }
+      break;
+    default:
+      break;
+  }
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreateTypeDieWithAttr(TypeAttrs attrs, DBGDie *typeDie) {
+  if (attrs.GetAttr(ATTR_const)) {
+    typeDie = GetOrCreateTypeDieWithAttr(ATTR_const, typeDie);
+  }
+  if (attrs.GetAttr(ATTR_volatile)) {
+    typeDie = GetOrCreateTypeDieWithAttr(ATTR_volatile, typeDie);
+  }
+  return typeDie;
+}
+
+DBGDie *DebugInfo::GetOrCreateTypeDie(TyIdx tyidx) {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx);
+  return GetOrCreateTypeDie(type);
+}
+
+DBGDie *DebugInfo::GetOrCreateTypeDie(MIRType *type) {
+  if (type == nullptr) {
+    return nullptr;
+  }
+
+  uint32 tid = type->GetTypeIndex().GetIdx();
+  if (tyIdxDieIdMap.find(tid) != tyIdxDieIdMap.end()) {
+    uint32 id = tyIdxDieIdMap[tid];
+    return idDieMap[id];
+  }
+
+  uint32 sid = type->GetNameStrIdx().GetIdx();
+  if (sid != 0 && stridxDieIdMap.find(sid) != stridxDieIdMap.end()) {
+    uint32 id = stridxDieIdMap[sid];
+    return idDieMap[id];
+  }
+
+  if (type->GetTypeIndex() == static_cast<uint32>(type->GetPrimType())) {
+    return GetOrCreatePrimTypeDie(type);
+  }
+
+  DBGDie *die = nullptr;
+  switch (type->GetKind()) {
+    case kTypePointer:
+      die = GetOrCreatePointTypeDie(static_cast<MIRPtrType *>(type));
+      break;
+    case kTypeFunction:
+      die = CreatePointedFuncTypeDie(static_cast<MIRFuncType *>(type));
+      break;
+    case kTypeArray:
+    case kTypeFArray:
+    case kTypeJArray:
+      die = GetOrCreateArrayTypeDie(static_cast<MIRArrayType *>(type));
+      break;
+    case kTypeUnion:
+    case kTypeStruct:
+    case kTypeStructIncomplete:
+    case kTypeClass:
+    case kTypeClassIncomplete:
+    case kTypeInterface:
+    case kTypeInterfaceIncomplete: {
+      die = GetOrCreateStructTypeDie(type);
+      break;
+    }
+    case kTypeBitField:
+      break;
+    case kTypeByName: {
+      die = GetOrCreateTypeByNameDie(*type);
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "TODO: support type");
+      break;
+  }
+
+  if (die) {
+    tyIdxDieIdMap[tid] = die->GetId();
+  }
+
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreateTypedefDie(GStrIdx stridx, TyIdx tyidx) {
+  uint32 sid = stridx.GetIdx();
+  auto it = stridxDieIdMap.find(sid);
+  if (it != stridxDieIdMap.end()) {
+    return idDieMap[it->second];
+  }
+
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_typedef);
+  compUnit->AddSubVec(die);
+
+  die->AddAttr(DW_AT_name, DW_FORM_strp, sid);
+  die->AddAttr(DW_AT_decl_file, DW_FORM_data1, 0);
+  die->AddAttr(DW_AT_decl_line, DW_FORM_data1, 0);
+  die->AddAttr(DW_AT_decl_column, DW_FORM_data1, 0);
+
+  DBGDie *typeDie = GetOrCreateTypeDie(tyidx);
+  die->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+
+  stridxDieIdMap[sid] = die->GetId();
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreateEnumTypeDie(unsigned idx) {
+  MIREnum *mirEnum = GlobalTables::GetEnumTable().enumTable[idx];
+  return GetOrCreateEnumTypeDie(mirEnum);
+}
+
+DBGDie *DebugInfo::GetOrCreateEnumTypeDie(MIREnum *mirEnum) {
+  uint32 sid = mirEnum->GetNameIdx().GetIdx();
+  auto it = stridxDieIdMap.find(sid);
+  if (it != stridxDieIdMap.end()) {
+    return idDieMap[it->second];
+  }
+
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_enumeration_type);
+
+  PrimType pty = mirEnum->GetPrimType();
+  // check if it is an anonymous enum
+  const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(mirEnum->GetNameIdx());
+  bool keep = (name.find("unnamed.") == std::string::npos);
+
+  die->AddAttr(DW_AT_name, DW_FORM_strp, sid, keep);
+  die->AddAttr(DW_AT_encoding, DW_FORM_data4, GetAteFromPTY(pty));
+  die->AddAttr(DW_AT_byte_size, DW_FORM_data1, GetPrimTypeSize(pty));
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pty);
+  DBGDie *typeDie = GetOrCreateTypeDie(type);
+  die->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+
+  for (auto &elemIt : mirEnum->GetElements()) {
+    DBGDie *elem = module->GetMemPool()->New<DBGDie>(module, DW_TAG_enumerator);
+    elem->AddAttr(DW_AT_name, DW_FORM_strp, elemIt.first.GetIdx());
+    elem->AddAttr(DW_AT_const_value, DW_FORM_data8, elemIt.second.GetExtValue());
+    die->AddSubVec(elem);
+  }
+
+  stridxDieIdMap[sid] = die->GetId();
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreatePointTypeDie(const MIRPtrType *ptrType) {
+  uint32 tid = ptrType->GetTypeIndex().GetIdx();
+  if (tyIdxDieIdMap.find(tid) != tyIdxDieIdMap.end()) {
+    uint32 id = tyIdxDieIdMap[tid];
+    return idDieMap[id];
+  }
+
+  MIRType *type = ptrType->GetPointedType();
+  DBGDie *typeDie = GetOrCreateTypeDie(type);
+  typeDie = GetOrCreateTypeDieWithAttr(ptrType->GetTypeAttrs(), typeDie);
+  // for <* void> and <func >
+  if ((type != nullptr) &&
+      (type->GetPrimType() == PTY_void || type->GetKind() == kTypeFunction)) {
+    DBGDie *die = nullptr;
+    if (type->GetKind() == kTypeFunction) {
+      // for maple's function pointer type, function type should be used in dwarf
+      die = typeDie;
+      tyIdxDieIdMap[type->GetTypeIndex().GetIdx()] = die->GetId();
+    } else {
+      die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_pointer_type);
+      die->AddAttr(DW_AT_byte_size, DW_FORM_data4, k8BitSize);
+    }
+    die->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+    tyIdxDieIdMap[ptrType->GetTypeIndex().GetIdx()] = die->GetId();
+    compUnit->AddSubVec(die);
+    return die;
+  }
+
+  if (typeDefTyIdxMap.find(type->GetTypeIndex().GetIdx()) != typeDefTyIdxMap.end()) {
+    uint32 tyIdx = typeDefTyIdxMap[type->GetTypeIndex().GetIdx()];
+    if (pointedPointerMap.find(tyIdx) != pointedPointerMap.end()) {
+      uint32 tyid = pointedPointerMap[tyIdx];
+      if (tyIdxDieIdMap.find(tyid) != tyIdxDieIdMap.end()) {
+        uint32 dieid = tyIdxDieIdMap[tyid];
+        DBGDie *die = idDieMap[dieid];
+        return die;
+      }
+    }
+  }
+
+  // update incomplete type from stridxDieIdMap to tyIdxDieIdMap
+  MIRStructType *stype = static_cast<MIRStructType*>(type);
+  if ((stype != nullptr) && stype->IsIncomplete()) {
+    uint32 sid = stype->GetNameStrIdx().GetIdx();
+    if (stridxDieIdMap.find(sid) != stridxDieIdMap.end()) {
+      uint32 dieid = stridxDieIdMap[sid];
+      if (dieid != 0) {
+        tyIdxDieIdMap[stype->GetTypeIndex().GetIdx()] = dieid;
+      }
+    }
+  }
+
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_pointer_type);
+  die->AddAttr(DW_AT_byte_size, DW_FORM_data4, k8BitSize);
+  die->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+  tyIdxDieIdMap[ptrType->GetTypeIndex().GetIdx()] = die->GetId();
+
+  compUnit->AddSubVec(die);
+
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreateArrayTypeDie(const MIRArrayType *arrayType) {
+  uint32 tid = arrayType->GetTypeIndex().GetIdx();
+  if (tyIdxDieIdMap.find(tid) != tyIdxDieIdMap.end()) {
+    uint32 id = tyIdxDieIdMap[tid];
+    return idDieMap[id];
+  }
+
+  MIRType *type = arrayType->GetElemType();
+  DBGDie *typeDie = GetOrCreateTypeDie(type);
+  typeDie = GetOrCreateTypeDieWithAttr(arrayType->GetTypeAttrs(), typeDie);
+
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_array_type);
+  die->AddAttr(DW_AT_byte_size, DW_FORM_data4, k8BitSize);
+  die->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+  tyIdxDieIdMap[arrayType->GetTypeIndex().GetIdx()] = die->GetId();
+
+  compUnit->AddSubVec(die);
+
+  // maple uses array of 1D array to represent 2D array
+  // so only one DW_TAG_subrange_type entry is needed default
+  uint16 dim = 1;
+  if (theMIRModule->IsCModule() || theMIRModule->IsJavaModule()) {
+    dim = arrayType->GetDim();
+  }
+  typeDie = GetOrCreateTypeDie(TyIdx(PTY_u32));
+  bool keep = !arrayType->IsIncompleteArray();
+  for (auto i = 0; i < dim; ++i) {
+    DBGDie *rangeDie = module->GetMemPool()->New<DBGDie>(module, DW_TAG_subrange_type);
+    rangeDie->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId(), keep);
+    // The default lower bound value for C, C++, or Java is 0
+    rangeDie->AddAttr(DW_AT_upper_bound, DW_FORM_data4, arrayType->GetSizeArrayItem(i) - 1, keep);
+    die->AddSubVec(rangeDie);
+  }
+
+  return die;
+}
+
+DBGDie *DebugInfo::CreateFieldDie(maple::FieldPair pair) {
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_member);
+
+  const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(pair.first);
+  bool keep = (name.find("unnamed.") == std::string::npos);
+  die->AddAttr(DW_AT_name, DW_FORM_strp, pair.first.GetIdx(), keep);
+  die->AddAttr(DW_AT_decl_file, DW_FORM_data4, mplSrcIdx.GetIdx(), keep);
+
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pair.second.first);
+  DBGDie *typeDie = GetOrCreateTypeDie(type);
+  die->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+
+  die->AddAttr(DW_AT_data_member_location, DW_FORM_data4, kDbgDefaultVal);
+
+  return die;
+}
+
+DBGDie *DebugInfo::CreateBitfieldDie(const MIRBitFieldType *type, const GStrIdx &sidx, uint32 &prevBits) {
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_member);
+
+  die->AddAttr(DW_AT_name, DW_FORM_strp, sidx.GetIdx());
+  die->AddAttr(DW_AT_decl_file, DW_FORM_data4, mplSrcIdx.GetIdx());
+
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(type->GetPrimType());
+  DBGDie *typeDie = GetOrCreateTypeDie(ty);
+  die->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+
+  die->AddAttr(DW_AT_byte_size, DW_FORM_data4, GetPrimTypeSize(type->GetPrimType()));
+  die->AddAttr(DW_AT_bit_size, DW_FORM_data4, type->GetFieldSize());
+
+  uint32 typeSize = GetPrimTypeSize(type->GetPrimType()) * k8BitSize;
+  prevBits = type->GetFieldSize() + prevBits > typeSize ? type->GetFieldSize() : type->GetFieldSize() + prevBits;
+  uint32 offset = typeSize - prevBits;
+
+  die->AddAttr(DW_AT_bit_offset, DW_FORM_data4, offset);
+  die->AddAttr(DW_AT_data_member_location, DW_FORM_data4, 0);
+
+  return die;
+}
+
+DBGDie *DebugInfo::GetOrCreateStructTypeDie(const MIRType *type) {
+  ASSERT(type, "null struture type");
+  GStrIdx strIdx = type->GetNameStrIdx();
+  ASSERT(strIdx.GetIdx(), "struture type missing name");
+
+  uint32 tid = type->GetTypeIndex().GetIdx();
+  if (tyIdxDieIdMap.find(tid) != tyIdxDieIdMap.end()) {
+    uint32 id = tyIdxDieIdMap[tid];
+    return idDieMap[id];
+  }
+
+  DBGDie *die = nullptr;
+  switch (type->GetKind()) {
+    case kTypeClass:
+    case kTypeClassIncomplete:
+      die = CreateClassTypeDie(strIdx, static_cast<const MIRClassType *>(type));
+      break;
+    case kTypeInterface:
+    case kTypeInterfaceIncomplete:
+      die = CreateInterfaceTypeDie(strIdx, static_cast<const MIRInterfaceType *>(type));
+      break;
+    case kTypeStruct:
+    case kTypeStructIncomplete:
+    case kTypeUnion:
+      die = CreateStructTypeDie(strIdx, static_cast<const MIRStructType *>(type), false);
+      break;
+    default:
+#ifdef DEBUG
+      LogInfo::MapleLogger() << "named type "
+                             << GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx).c_str()
+                             << "\n";
+#endif /* DEBUG */
+      break;
+  }
+
+  GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(strIdx, type->GetTypeIndex());
+
+  if (die) {
+    tyIdxDieIdMap[type->GetTypeIndex().GetIdx()] = die->GetId();
+  }
+  return die;
+}
+
+void DebugInfo::CreateStructTypeFieldsDies(const MIRStructType *structType, DBGDie *die) {
+  uint32 prevBits = 0;
+  for (size_t i = 0; i < structType->GetFieldsSize(); i++) {
+    MIRType *elemType = structType->GetElemType(static_cast<uint32>(i));
+    FieldPair fp = structType->GetFieldsElemt(i);
+    if (elemType->IsMIRBitFieldType()) {
+      if (die->GetTag() == DW_TAG_union_type) {
+        prevBits = 0;
+      }
+      MIRBitFieldType *bitFieldType = static_cast<MIRBitFieldType*>(elemType);
+      DBGDie *bfDie = CreateBitfieldDie(bitFieldType, fp.first, prevBits);
+      die->AddSubVec(bfDie);
+    } else {
+      if (die->GetTag() != DW_TAG_union_type) {
+        prevBits = GetPrimTypeSize(elemType->GetPrimType()) * k8BitSize;
+      }
+      DBGDie *fieldDie = CreateFieldDie(fp);
+      die->AddSubVec(fieldDie);
+
+      // update field type with alias info
+      MIRAlias *alias = structType->GetAlias();
+      if (!alias) {
+        continue;
+      }
+
+      for (auto &aliasVar : alias->GetAliasVarMap()) {
+        if (aliasVar.first == fp.first) {
+          DBGDie *typeDie = GetAliasVarTypeDie(aliasVar.second, fp.second.first);
+          fieldDie->SetAttr(DW_AT_type, typeDie->GetId());
+          break;
+        }
+      }
+    }
+  }
+}
+
+void DebugInfo::CreateStructTypeParentFieldsDies(const MIRStructType *structType, DBGDie *die) {
+  for (size_t i = 0; i < structType->GetParentFieldsSize(); i++) {
+    FieldPair fp = structType->GetParentFieldsElemt(i);
+    DBGDie *fieldDie = CreateFieldDie(fp);
+    die->AddSubVec(fieldDie);
+  }
+}
+
+void DebugInfo::CreateStructTypeMethodsDies(const MIRStructType *structType, DBGDie *die) {
+  // member functions decl
+  for (auto fp : structType->GetMethods()) {
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(fp.first.Idx());
+    ASSERT((symbol != nullptr) && symbol->GetSKind() == kStFunc, "member function symbol not exist");
+    MIRFunction *func = symbol->GetValue().mirFunc;
+    ASSERT(func, "member function not exist");
+    DBGDie *funDeclDie = GetOrCreateFuncDeclDie(func);
+    die->AddSubVec(funDeclDie);
+    if (func->GetBody()) {
+      // member functions defination, these die are global
+      DBGDie *funDefDie = GetOrCreateFuncDefDie(func);
+      compUnit->AddSubVec(funDefDie);
+    }
+  }
+}
+
+// shared between struct and union, also used as part by class and interface
+DBGDie *DebugInfo::CreateStructTypeDie(GStrIdx strIdx, const MIRStructType *structType, bool update) {
+  DBGDie *die = nullptr;
+  uint32 tid = structType->GetTypeIndex().GetIdx();
+
+  if (update) {
+    ASSERT(tyIdxDieIdMap.find(tid) != tyIdxDieIdMap.end(), "update type die not exist");
+    uint32 id = tyIdxDieIdMap[tid];
+    die = idDieMap[id];
+    ASSERT(die, "update type die not exist");
+  } else {
+    DwTag tag = structType->GetKind() == kTypeStruct ? DW_TAG_structure_type : DW_TAG_union_type;
+    die = module->GetMemPool()->New<DBGDie>(module, tag);
+    tyIdxDieIdMap[tid] = die->GetId();
+  }
+  die = GetOrCreateTypeDieWithAttr(structType->GetTypeAttrs(), die);
+
+  if (strIdx.GetIdx() != 0) {
+    stridxDieIdMap[strIdx.GetIdx()] = die->GetId();
+  }
+
+  compUnit->AddSubVec(die);
+
+  const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+  bool keep = (name.find("unnamed.") == std::string::npos);
+
+  die->AddAttr(DW_AT_decl_line, DW_FORM_data4, kStructDBGSize);
+  die->AddAttr(DW_AT_name, DW_FORM_strp, strIdx.GetIdx(), keep);
+  die->AddAttr(DW_AT_byte_size, DW_FORM_data4, kDbgDefaultVal);
+  die->AddAttr(DW_AT_decl_file, DW_FORM_data4, mplSrcIdx.GetIdx());
+  // store tid for cg emitter
+  die->AddAttr(DW_AT_type, DW_FORM_data4, tid, false);
+
+  PushParentDie(die);
+
+  // fields
+  CreateStructTypeFieldsDies(structType, die);
+
+  // parentFields
+  CreateStructTypeParentFieldsDies(structType, die);
+
+  // member functions
+  CreateStructTypeMethodsDies(structType, die);
+
+  PopParentDie();
+
+  return die;
+}
+
+DBGDie *DebugInfo::CreateClassTypeDie(const GStrIdx &strIdx, const MIRClassType *classType) {
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_class_type);
+
+  PushParentDie(die);
+
+  // parent
+  uint32 ptid = classType->GetParentTyIdx().GetIdx();
+  if (ptid != 0) {
+    MIRType *parenttype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType->GetParentTyIdx());
+    DBGDie *parentDie = GetOrCreateTypeDie(parenttype);
+    if (parentDie) {
+      parentDie = module->GetMemPool()->New<DBGDie>(module, DW_TAG_inheritance);
+      parentDie->AddAttr(DW_AT_name, DW_FORM_strp, parenttype->GetNameStrIdx().GetIdx());
+      DBGDie *typeDie = GetOrCreateStructTypeDie(classType);
+      parentDie->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+
+      // set to DW_ACCESS_public for now
+      parentDie->AddAttr(DW_AT_accessibility, DW_FORM_data4, DW_ACCESS_public);
+      die->AddSubVec(parentDie);
+    }
+  }
+
+  PopParentDie();
+
+  // update common fields
+  tyIdxDieIdMap[classType->GetTypeIndex().GetIdx()] = die->GetId();
+  DBGDie *die1 = CreateStructTypeDie(strIdx, classType, true);
+  ASSERT(die == die1, "ClassTypeDie update wrong die");
+
+  return die1;
+}
+
+DBGDie *DebugInfo::CreateInterfaceTypeDie(const GStrIdx &strIdx, const MIRInterfaceType *interfaceType) {
+  DBGDie *die = module->GetMemPool()->New<DBGDie>(module, DW_TAG_interface_type);
+
+  PushParentDie(die);
+
+  // parents
+  for (auto it : interfaceType->GetParentsTyIdx()) {
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(it);
+    DBGDie *parentDie = GetOrCreateTypeDie(type);
+    if (parentDie) {
+      continue;
+    }
+    parentDie = module->GetMemPool()->New<DBGDie>(module, DW_TAG_inheritance);
+    parentDie->AddAttr(DW_AT_name, DW_FORM_strp, type->GetNameStrIdx().GetIdx());
+    DBGDie *typeDie = GetOrCreateStructTypeDie(interfaceType);
+    parentDie->AddAttr(DW_AT_type, DW_FORM_ref4, typeDie->GetId());
+    parentDie->AddAttr(DW_AT_data_member_location, DW_FORM_data4, kDbgDefaultVal);
+
+    // set to DW_ACCESS_public for now
+    parentDie->AddAttr(DW_AT_accessibility, DW_FORM_data4, DW_ACCESS_public);
+    die->AddSubVec(parentDie);
+  }
+
+  PopParentDie();
+
+  // update common fields
+  tyIdxDieIdMap[interfaceType->GetTypeIndex().GetIdx()] = die->GetId();
+  DBGDie *die1 = CreateStructTypeDie(strIdx, interfaceType, true);
+  ASSERT(die == die1, "InterfaceTypeDie update wrong die");
+
+  return die1;
+}
+
+uint32 DebugInfo::GetAbbrevId(DBGAbbrevEntryVec *vec, DBGAbbrevEntry *entry) const {
+  for (auto it : vec->GetEntryvec()) {
+    if (it->Equalto(entry)) {
+      return it->GetAbbrevId();
+    }
+  }
+  return 0;
+}
+
+void DebugInfo::BuildAbbrev() {
+  uint32 abbrevid = 1;
+  for (uint32 i = 1; i < maxId; i++) {
+    DBGDie *die = idDieMap[i];
+    DBGAbbrevEntry *entry = module->GetMemPool()->New<DBGAbbrevEntry>(module, die);
+
+    if (!tagAbbrevMap[die->GetTag()]) {
+      tagAbbrevMap[die->GetTag()] = module->GetMemPool()->New<DBGAbbrevEntryVec>(module, die->GetTag());
+    }
+
+    uint32 id = GetAbbrevId(tagAbbrevMap[die->GetTag()], entry);
+    if (id != 0) {
+      // using existing abbrev id
+      die->SetAbbrevId(id);
+    } else {
+      // add entry to vector
+      entry->SetAbbrevId(abbrevid++);
+      tagAbbrevMap[die->GetTag()]->GetEntryvec().push_back(entry);
+      abbrevVec.push_back(entry);
+      // update abbrevid in die
+      die->SetAbbrevId(entry->GetAbbrevId());
+    }
+  }
+  for (uint32 i = 1; i < maxId; i++) {
+    DBGDie *die = idDieMap[i];
+    if (die->GetAbbrevId() == 0) {
+      LogInfo::MapleLogger() << "0 abbrevId i = " << i << " die->id = " << die->GetId() << std::endl;
+    }
+  }
+}
+
+void DebugInfo::BuildDieTree() {
+  for (auto it : idDieMap) {
+    if (!it.first) {
+      continue;
+    }
+    DBGDie *die = it.second;
+    uint32 size = die->GetSubDieVecSize();
+    die->SetWithChildren(size > 0);
+    if (size != 0) {
+      die->SetFirstChild(die->GetSubDieVecAt(0));
+      for (uint32 i = 0; i < size - 1; i++) {
+        DBGDie *it0 = die->GetSubDieVecAt(i);
+        DBGDie *it1 = die->GetSubDieVecAt(i + 1);
+        if (it0->GetSubDieVecSize() != 0) {
+          it0->SetSibling(it1);
+          it0->AddAttr(DW_AT_sibling, DW_FORM_ref4, it1->GetId());
+        }
+      }
+    }
+  }
+}
+
+DBGDie *DebugInfo::GetDie(const MIRFunction *func) {
+  uint32 id = stridxDieIdMap[func->GetNameStrIdx().GetIdx()];
+  if (id != 0) {
+    return idDieMap[id];
+  }
+  return nullptr;
+}
+
+// Methods for calculating Offset and Size of DW_AT_xxx
+size_t DBGDieAttr::SizeOf(DBGDieAttr *attr) const {
+  DwForm form = attr->dwForm;
+  switch (form) {
+    // case DW_FORM_implicitconst:
+    case DW_FORM_flag_present:
+      return 0;  // Not handled yet.
+    case DW_FORM_flag:
+    case DW_FORM_ref1:
+    case DW_FORM_data1:
+      return sizeof(int8);
+    case DW_FORM_ref2:
+    case DW_FORM_data2:
+      return sizeof(int16);
+    case DW_FORM_ref4:
+    case DW_FORM_data4:
+      return sizeof(int32);
+    case DW_FORM_ref8:
+    case DW_FORM_ref_sig8:
+    case DW_FORM_data8:
+      return sizeof(int64);
+    case DW_FORM_addr:
+      return sizeof(int64);
+    case DW_FORM_sec_offset:
+    case DW_FORM_ref_addr:
+    case DW_FORM_strp:
+    case DW_FORM_GNU_ref_alt:
+      // case DW_FORM_codeLinestrp:
+      // case DW_FORM_strp_sup:
+      // case DW_FORM_ref_sup:
+      return k4BitSize;  // DWARF32, 8 if DWARF64
+
+    case DW_FORM_string: {
+      GStrIdx stridx(attr->value.id);
+      const std::string &str = GlobalTables::GetStrTable().GetStringFromStrIdx(stridx);
+      return str.length() + 1; /* terminal null byte */
+    }
+    case DW_FORM_exprloc: {
+      DBGExprLoc *ptr = attr->value.ptr;
+      CHECK_FATAL(ptr != (DBGExprLoc*)(0xdeadbeef), "wrong ptr");
+      switch (ptr->GetOp()) {
+        case DW_OP_call_frame_cfa:
+          return k2BitSize;  // size 1 byte + DW_OP_call_frame_cfa 1 byte
+        case DW_OP_fbreg: {
+          // DW_OP_fbreg 1 byte
+          size_t size = 1 + namemangler::GetSleb128Size(ptr->GetFboffset());
+          return size + namemangler::GetUleb128Size(size);
+        }
+        case DW_OP_breg0:
+        case DW_OP_breg1:
+        case DW_OP_breg2:
+        case DW_OP_breg3:
+        case DW_OP_breg4:
+        case DW_OP_breg5:
+        case DW_OP_breg6:
+        case DW_OP_breg7:
+          return k3BitSize;
+        case DW_OP_addr: {
+          return namemangler::GetUleb128Size(k9BitSize) + k9BitSize;
+        }
+        default:
+          return k4BitSize;
+      }
+    }
+    default:
+      LogInfo::MapleLogger() << "unhandled SizeOf: " << maple::GetDwFormName(form) << std::endl;
+      CHECK_FATAL(maple::GetDwFormName(form) != nullptr, "null GetDwFormName(form)");
+      return 0;
+  }
+}
+
+void DebugInfo::ComputeSizeAndOffsets() {
+  // CU-relative offset is reset to 0 here.
+  uint32 cuOffset = sizeof(int32_t) +  // Length of Unit Info
+                    sizeof(int16) +  // DWARF version number      : 0x0004
+                    sizeof(int32) +  // Offset into Abbrev. Section : 0x0000
+                    sizeof(int8);  // Pointer Size (in bytes)       : 0x08
+
+  // After returning from this function, the length value is the size
+  // of the .debug_info section
+  ComputeSizeAndOffset(compUnit, cuOffset);
+  debugInfoLength = cuOffset - sizeof(int32_t);
+}
+
+// Compute the size and offset of a DIE. The Offset is relative to start of the CU.
+// It returns the offset after laying out the DIE.
+void DebugInfo::ComputeSizeAndOffset(DBGDie *die, uint32 &cuOffset) {
+  if (!die->GetKeep()) {
+    return;
+  }
+  uint32 cuOffsetOrg = cuOffset;
+  die->SetOffset(cuOffset);
+
+  // Add the byte size of the abbreviation code
+  cuOffset += static_cast<uint32>(namemangler::GetUleb128Size(uint64_t(die->GetAbbrevId())));
+
+  // Add the byte size of all the DIE attributes.
+  for (const auto &attr : die->GetAttrVec()) {
+    if (!attr->GetKeep()) {
+      continue;
+    }
+    cuOffset += static_cast<uint32>(attr->SizeOf(attr));
+  }
+
+  die->SetSize(cuOffset - cuOffsetOrg);
+
+  // Let the children compute their offsets.
+  if (die->GetWithChildren()) {
+    uint32 size = die->GetSubDieVecSize();
+
+    for (uint32 i = 0; i < size; i++) {
+      DBGDie *childDie = die->GetSubDieVecAt(i);
+      ComputeSizeAndOffset(childDie, cuOffset);
+    }
+
+    // Each child chain is terminated with a zero byte, adjust the offset.
+    cuOffset += sizeof(int8);
+  }
+}
+
+bool DebugInfo::IsScopeIdEmited(MIRFunction *func, uint32 scopeId) {
+  auto it = funcScopeIdStatus.find(func);
+  if (it == funcScopeIdStatus.end()) {
+    return false;
+  }
+
+  auto scopeIdIt = it->second.find(scopeId);
+  if (scopeIdIt == it->second.end()) {
+    return false;
+  }
+
+  if (scopeIdIt->second != kAllEmited) {
+    return false;
+  }
+  return true;
+}
+
+void DebugInfo::ClearDebugInfo() {
+  for (auto &funcLstrIdxDieId : funcLstrIdxDieIdMap) {
+    funcLstrIdxDieId.second.clear();
+  }
+  for (auto &funcLstrIdxLabIdx : funcLstrIdxLabIdxMap) {
+    funcLstrIdxLabIdx.second.clear();
+  }
+  for (auto &funcScopeLow : funcScopeLows) {
+    funcScopeLow.second.clear();
+    funcScopeLow.second.shrink_to_fit();
+  }
+  for (auto &funcScopeHigh : funcScopeHighs) {
+    funcScopeHigh.second.clear();
+    funcScopeHigh.second.shrink_to_fit();
+  }
+  for (auto &status : funcScopeIdStatus) {
+    status.second.clear();
+  }
+}
+
+/* ///////////////
+ * Dumps
+ * ///////////////
+ */
+void DebugInfo::Dump(int indent) {
+  LogInfo::MapleLogger() << "\n" << std::endl;
+  LogInfo::MapleLogger() << "maple_debug_information {"
+             << "  Length: " << HEX(debugInfoLength) << std::endl;
+  compUnit->Dump(indent + 1);
+  LogInfo::MapleLogger() << "}\n" << std::endl;
+  LogInfo::MapleLogger() << "maple_debug_abbrev {" << std::endl;
+  for (uint32 i = 1; i < abbrevVec.size(); i++) {
+    abbrevVec[i]->Dump(indent + 1);
+  }
+  LogInfo::MapleLogger() << "}" << std::endl;
+  return;
+}
+
+void DBGExprLoc::Dump() const {
+  LogInfo::MapleLogger() << " " << HEX(GetOp());
+  for (auto it : simpLoc->GetOpnd()) {
+    LogInfo::MapleLogger() << " " << HEX(it);
+  }
+}
+
+void DBGDieAttr::Dump(int indent) {
+  PrintIndentation(indent);
+  CHECK_FATAL(GetDwFormName(dwForm) && GetDwAtName(dwAttr), "null ptr check");
+  LogInfo::MapleLogger() << GetDwAtName(dwAttr) << " " << GetDwFormName(dwForm);
+  if (dwForm == DW_FORM_string || dwForm == DW_FORM_strp) {
+    GStrIdx idx(value.id);
+    LogInfo::MapleLogger() << " 0x" << std::hex << value.u << std::dec;
+    LogInfo::MapleLogger() << " \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(idx).c_str() << "\"";
+  } else if (dwForm == DW_FORM_ref4) {
+    LogInfo::MapleLogger() << " <" << HEX(value.id) << ">";
+  } else if (dwAttr == DW_AT_encoding) {
+    CHECK_FATAL(GetDwAteName(static_cast<uint32>(value.u)), "null ptr check");
+    LogInfo::MapleLogger() << " " << GetDwAteName(static_cast<uint32>(value.u));
+  } else if (dwAttr == DW_AT_location) {
+    value.ptr->Dump();
+  } else {
+    LogInfo::MapleLogger() << " 0x" << std::hex << value.u << std::dec;
+  }
+  LogInfo::MapleLogger() << std::endl;
+}
+
+void DBGDie::Dump(int indent) {
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "<" << HEX(id) << "><" << HEX(offset);
+  LogInfo::MapleLogger() << "><" << HEX(size) << "><"
+             << "> abbrev id: " << HEX(abbrevId);
+  CHECK_FATAL(GetDwTagName(tag), "null ptr check");
+  LogInfo::MapleLogger() << " (" << GetDwTagName(tag) << ") ";
+  if (parent) {
+    LogInfo::MapleLogger() << "parent <" << HEX(parent->GetId());
+  }
+  LogInfo::MapleLogger() << "> {";
+  if (tyIdx != 0) {
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(tyIdx));
+    if (type->GetKind() == kTypeStruct || type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface) {
+      MIRStructType *stype = static_cast<MIRStructType *>(type);
+      LogInfo::MapleLogger() << "           # " << stype->GetName();
+    } else {
+      LogInfo::MapleLogger() << "           # " << GetPrimTypeName(type->GetPrimType());
+    }
+  }
+  LogInfo::MapleLogger() << std::endl;
+  for (auto it : attrVec) {
+    it->Dump(indent + 1);
+  }
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "} ";
+  if (subDieVec.size() != 0) {
+    LogInfo::MapleLogger() << " {" << std::endl;
+    for (auto it : subDieVec) {
+      it->Dump(indent + 1);
+    }
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << "}";
+  }
+  LogInfo::MapleLogger() << std::endl;
+  return;
+}
+
+void DBGAbbrevEntry::Dump(int indent) {
+  PrintIndentation(indent);
+  CHECK_FATAL(GetDwTagName(tag), "null ptr check ");
+  LogInfo::MapleLogger() << "<" << HEX(abbrevId) << "> " << GetDwTagName(tag);
+  if (GetWithChildren()) {
+    LogInfo::MapleLogger() << " [with children] {" << std::endl;
+  } else {
+    LogInfo::MapleLogger() << " [no children] {" << std::endl;
+  }
+  for (uint32 i = 0; i < attrPairs.size(); i += k2BitSize) {
+    PrintIndentation(indent + 1);
+    CHECK_FATAL(GetDwAtName(attrPairs[i]) && GetDwFormName(attrPairs[i + 1]), "NULLPTR CHECK");
+
+    LogInfo::MapleLogger() << " " << GetDwAtName(attrPairs[i]) << " " << GetDwFormName(attrPairs[i + 1])
+        << " " << std::endl;
+  }
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "}" << std::endl;
+  return;
+}
+
+void DBGAbbrevEntryVec::Dump(int indent) {
+  for (auto it : entryVec) {
+    PrintIndentation(indent);
+    it->Dump(indent);
+  }
+  return;
+}
+
+// DBGCompileMsgInfo methods
+void DBGCompileMsgInfo::ClearLine(uint32 n) {
+  errno_t eNum = memset_s(codeLine[n], MAXLINELEN, 0, MAXLINELEN);
+  if (eNum != 0) {
+    FATAL(kLncFatal, "memset_s failed");
+  }
+}
+
+DBGCompileMsgInfo::DBGCompileMsgInfo() : startLine(0), errPos(0) {
+  lineNum[0] = 0;
+  lineNum[1] = 0;
+  lineNum[kIndx2] = 0;
+  ClearLine(0);
+  ClearLine(1);
+  ClearLine(kIndx2);
+  errLNum = 0;
+  errCNum = 0;
+}
+
+void DBGCompileMsgInfo::SetErrPos(uint32 lnum, uint32 cnum) {
+  errLNum = lnum;
+  errCNum = cnum;
+}
+
+void DBGCompileMsgInfo::UpdateMsg(uint32 lnum, const char *line) {
+  size_t size = strlen(line);
+  if (size > MAXLINELEN - 1) {
+    size = MAXLINELEN - 1;
+  }
+  startLine = (startLine + k2BitSize) % k3BitSize;
+  ClearLine(startLine);
+  errno_t eNum = memcpy_s(codeLine[startLine], MAXLINELEN, line, size);
+  if (eNum != 0) {
+    FATAL(kLncFatal, "memcpy_s failed");
+  }
+  codeLine[startLine][size] = '\0';
+  lineNum[startLine] = lnum;
+}
+
+void DBGCompileMsgInfo::EmitMsg() {
+  char str[MAXLINELEN + 1];
+
+  errPos = errCNum;
+  errPos = (errPos < k2BitSize) ? k2BitSize : errPos;
+  errPos = (errPos > MAXLINELEN) ? MAXLINELEN : errPos;
+  for (uint32 i = 0; i < errPos - 1; i++) {
+    str[i] = ' ';
+  }
+  str[errPos - 1] = '^';
+  str[errPos] = '\0';
+
+  fprintf(stderr, "\n===================================================================\n");
+  fprintf(stderr, "==================");
+  fprintf(stderr, BOLD YEL "  Compilation Error Diagnosis  " RESET);
+  fprintf(stderr, "==================\n");
+  fprintf(stderr, "===================================================================\n");
+  fprintf(stderr, "line %4u %s\n", lineNum[(startLine + k2BitSize) % k3BitSize],
+          reinterpret_cast<char *>(codeLine[(startLine + k2BitSize) % k3BitSize]));
+  fprintf(stderr, "line %4u %s\n", lineNum[(startLine + 1) % k3BitSize],
+          reinterpret_cast<char *>(codeLine[(startLine + 1) % k3BitSize]));
+  fprintf(stderr, "line %4u %s\n", lineNum[(startLine) % k3BitSize],
+          reinterpret_cast<char *>(codeLine[(startLine) % k3BitSize]));
+  fprintf(stderr, BOLD RED "          %s\n" RESET, str);
+  fprintf(stderr, "===================================================================\n");
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/debug_info_util.cpp b/src/mapleall/maple_ir/src/debug_info_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3fa5d7bc1cb3067d87445bac5ea5999a7b4146e2
--- /dev/null
+++ b/src/mapleall/maple_ir/src/debug_info_util.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <cstring>
+#include "mir_builder.h"
+#include "printing.h"
+#include "maple_string.h"
+#include "namemangler.h"
+#include "debug_info.h"
+#include "global_tables.h"
+#include "mir_type.h"
+#include "securec.h"
+#include "mpl_logging.h"
+
+namespace maple {
+#define TOSTR(s) #s
+// utility functions to get the string from tag value etc.
+// GetDwTagName(unsigned n)
+const char *GetDwTagName(unsigned n) {
+  switch (n) {
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) case DW_TAG_##NAME: return TOSTR(DW_TAG_##NAME);
+#include "Dwarf.def"
+    case DW_TAG_lo_user: return "DW_TAG_lo_user";
+    case DW_TAG_hi_user: return "DW_TAG_hi_user";
+    case DW_TAG_user_base: return "DW_TAG_user_base";
+    default: return nullptr;
+  }
+}
+
+// GetDwFormName(unsigned n)
+const char *GetDwFormName(unsigned n) {
+  switch (n) {
+#define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) case DW_FORM_##NAME: return TOSTR(DW_FORM_##NAME);
+#include "Dwarf.def"
+    case DW_FORM_lo_user: return "DW_FORM_lo_user";
+    default: return nullptr;
+  }
+}
+
+// GetDwAtName(unsigned n)
+const char *GetDwAtName(unsigned n) {
+  switch (n) {
+#define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR)  case DW_AT_##NAME: return TOSTR(DW_AT_##NAME);
+#include "Dwarf.def"
+    case DW_AT_lo_user: return "DW_AT_lo_user";
+    default: return nullptr;
+  }
+}
+
+// GetDwOpName(unsigned n)
+const char *GetDwOpName(unsigned n) {
+  switch (n) {
+#define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) case DW_OP_##NAME: return TOSTR(DW_OP_##NAME);
+#include "Dwarf.def"
+    case DW_OP_hi_user: return "DW_OP_hi_user";
+    case DW_OP_LLVM_fragment: return "DW_OP_LLVM_fragment";
+    case DW_OP_LLVM_convert: return "DW_OP_LLVM_convert";
+    case DW_OP_LLVM_tag_offset: return "DW_OP_LLVM_tag_offset";
+    case DW_OP_LLVM_entry_value: return "DW_OP_LLVM_entry_value";
+    default: return nullptr;
+  }
+}
+
+#define DW_ATE_void 0x20
+// GetDwAteName(unsigned n)
+const char *GetDwAteName(unsigned n) {
+  switch (n) {
+#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) case DW_ATE_##NAME: return TOSTR(DW_ATE_##NAME);
+#include "Dwarf.def"
+    case DW_ATE_lo_user: return "DW_ATE_lo_user";
+    case DW_ATE_hi_user: return "DW_ATE_hi_user";
+    case DW_ATE_void: return "DW_ATE_void";
+    default: return nullptr;
+  }
+}
+
+// GetDwCfaName(unsigned n)
+const char *GetDwCfaName(unsigned n) {
+  switch (n) {
+#define HANDLE_DW_CFA(ID, NAME) case DW_CFA_##NAME: return TOSTR(DW_CFA_##NAME);
+#define HANDLE_DW_CFA_PRED(ID, NAME, ARCH) case DW_CFA_##NAME: return TOSTR(DW_CFA_##NAME);
+#include "Dwarf.def"
+    case DW_CFA_lo_user: return "DW_CFA_lo_user";
+    case DW_CFA_hi_user: return "DW_CFA_hi_user";
+    default: return nullptr;
+  }
+}
+
+DwAte GetAteFromPTY(PrimType pty) {
+  switch (pty) {
+    case PTY_u1:
+      return DW_ATE_boolean;
+    case PTY_u8:
+      return DW_ATE_unsigned_char;
+    case PTY_u16:
+    case PTY_u32:
+    case PTY_u64:
+      return DW_ATE_unsigned;
+    case PTY_i8:
+      return DW_ATE_signed_char;
+    case PTY_i16:
+    case PTY_i32:
+    case PTY_i64:
+      return DW_ATE_signed;
+    case PTY_f32:
+    case PTY_f64:
+    case PTY_f128:
+      return DW_ATE_float;
+    case PTY_agg:
+    case PTY_ref:
+    case PTY_ptr:
+    case PTY_a32:
+    case PTY_a64:
+      return DW_ATE_address;
+    case PTY_c64:
+    case PTY_c128:
+      return DW_ATE_complex_float;
+    case PTY_void:
+      return DW_ATE_void;
+    default:
+      return DW_ATE_void;
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/driver.cpp b/src/mapleall/maple_ir/src/driver.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6f0c33f4b3a7e2ae4c8e1e1b2fb18ad186c01331
--- /dev/null
+++ b/src/mapleall/maple_ir/src/driver.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+
+#include "bin_mplt.h"
+#include "constantfold.h"
+#include "mir_function.h"
+#include "mir_parser.h"
+#include "mir_type.h"
+#include "mpl_sighandler.h"
+#include "opcode_info.h"
+
+using namespace maple;
+
+std::unordered_set<std::string> dumpFuncSet = {};
+
+#if MIR_FEATURE_FULL
+
+int main(int argc, char **argv) {
+  SigHandler::EnableAll();
+
+  constexpr int judgeNumber = 2;
+  constexpr uint32 k2Argv = 2;
+  constexpr uint32 k10Argv = 10;
+  constexpr uint32 kNlSize = 5;
+  if (argc < judgeNumber) {
+    (void)MIR_PRINTF(
+        "usage: ./irbuild [-b] [-dumpfunc=<string>] [-srclang=<string>] <any number of .mplt, .mpl, .bpl, .mbc, "
+        ".lmbc or .tmpl files>\n"
+        "    By default, the files are converted to corresponding ascii format.\n"
+        "    If -b is specified, output is binary format instead.\n"
+        "    If -dumpfunc= is specified, only functions with name containing the string is output.\n"
+        "    -dumpfunc= can be specified multiple times to give multiple strings.\n"
+        "    -srclang specifies the source language that produces the mpl file. \n"
+        "    Each output file has .irb added after its file stem.\n");
+    exit(1);
+  }
+
+  std::vector<maple::MIRModule *> themodule(argc, nullptr);
+  bool useBinary = false;
+  MIRSrcLang srcLang = kSrcLangUnknown;
+  // process the options which must come first
+  maple::uint32 i = 1;
+  while (argv[i][0] == '-') {
+    if (argv[i][1] == 'b' && argv[i][k2Argv] == '\0') {
+      useBinary = true;
+    } else if (strncmp(argv[i], "-dumpfunc=", k10Argv) == 0 && strlen(argv[i]) > k10Argv) {
+      std::string funcName(&argv[i][k10Argv]);
+      dumpFuncSet.insert(funcName);
+    } else if (strcmp(argv[i], "-srclang=java") == 0) {
+      srcLang = kSrcLangJava;
+    } else if (strcmp(argv[i], "-srclang=c") == 0) {
+      srcLang = kSrcLangC;
+    } else if (strcmp(argv[i], "-srclang=c++") == 0) {
+      srcLang = kSrcLangCPlusPlus;
+    } else {
+      ERR(kLncErr, "irbuild: unrecognized command line option");
+      return 1;
+    }
+    ++i;
+  }
+  // process the input files
+  while (i < static_cast<uint32>(argc)) {
+    themodule[i] = new maple::MIRModule(argv[i]);
+    themodule[i]->SetSrcLang(srcLang);
+    std::string::size_type lastdot = themodule[i]->GetFileName().find_last_of(".");
+    bool ismplt = themodule[i]->GetFileName().compare(lastdot, kNlSize, ".mplt") == 0;
+    bool istmpl = themodule[i]->GetFileName().compare(lastdot, kNlSize, ".tmpl") == 0;
+    bool ismpl = themodule[i]->GetFileName().compare(lastdot, kNlSize, ".mpl") == 0;
+    bool isbpl = themodule[i]->GetFileName().compare(lastdot, kNlSize, ".bpl") == 0;
+    bool ismbc = themodule[i]->GetFileName().compare(lastdot, kNlSize, ".mbc") == 0;
+    bool islmbc = themodule[i]->GetFileName().compare(lastdot, kNlSize, ".lmbc") == 0;
+    if (!ismplt && !istmpl && !ismpl && !isbpl && !ismbc && !islmbc) {
+      ERR(kLncErr, "irbuild: input must be .mplt or .mpl or .bpl or .mbc or .lmbc or .tmpl file");
+      return 1;
+    }
+    // input the file
+    if (ismpl || istmpl) {
+      maple::MIRParser theparser(*themodule[i]);
+      if (!theparser.ParseMIR()) {
+        theparser.EmitError(themodule[i]->GetFileName().c_str());
+        return 1;
+      }
+    } else {
+      BinaryMplImport binMplt(*themodule[i]);
+      binMplt.SetImported(false);
+      std::string modid = themodule[i]->GetFileName();
+      if (!binMplt.Import(modid, true)) {
+        ERR(kLncErr, "irbuild: cannot open .mplt or .bpl or .mbc or .lmbc file: %s", modid.c_str());
+        return 1;
+      }
+    }
+
+    // output the file
+    if (!useBinary) {
+      themodule[i]->OutputAsciiMpl(
+          ".irb", (ismpl || isbpl || ismbc || islmbc) ? ".mpl" : ".tmpl", &dumpFuncSet, true, false);
+    } else {
+      BinaryMplt binMplt(*themodule[i]);
+      std::string modid = themodule[i]->GetFileName();
+      binMplt.GetBinExport().not2mplt = ismpl || isbpl || ismbc || islmbc;
+      std::string filestem = modid.substr(0, lastdot);
+      binMplt.Export(filestem + ((ismpl || isbpl || ismbc || islmbc) ? ".irb.bpl" : ".irb.mplt"), &dumpFuncSet);
+    }
+    ++i;
+  }
+  return 0;
+}
+#else
+#warning "this module is compiled without MIR_FEATURE_FULL=1 defined"
+#endif  // MIR_FEATURE_FULL
diff --git a/src/mapleall/maple_ir/src/global_tables.cpp b/src/mapleall/maple_ir/src/global_tables.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a519918ce4db559f45493c7d5a5566a18dc1142b
--- /dev/null
+++ b/src/mapleall/maple_ir/src/global_tables.cpp
@@ -0,0 +1,496 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "global_tables.h"
+#include "mir_type.h"
+#include "mir_symbol.h"
+
+#if MIR_FEATURE_FULL
+namespace maple {
+MIRType *TypeTable::CreateMirType(uint32 primTypeIdx) const {
+  MIRTypeKind defaultKind = (primTypeIdx == PTY_constStr ? kTypeConstString : kTypeScalar);
+  auto primType = static_cast<PrimType>(primTypeIdx);
+  auto *mirType = new MIRType(defaultKind, primType);
+  return mirType;
+}
+
+TypeTable::TypeTable() {
+  // enter the primitve types in type_table_
+  typeTable.push_back(static_cast<MIRType*>(nullptr));
+  ASSERT(typeTable.size() == static_cast<size_t>(PTY_void), "use PTY_void as the first index to type table");
+  uint32 primTypeIdx;
+  for (primTypeIdx = static_cast<uint32>(PTY_begin) + 1; primTypeIdx <= static_cast<uint32>(PTY_end); ++primTypeIdx) {
+    MIRType *type = CreateMirType(primTypeIdx);
+    type->SetTypeIndex(TyIdx{ primTypeIdx });
+    typeTable.push_back(type);
+    PutToHashTable(type);
+  }
+  if (voidPtrType == nullptr) {
+    voidPtrType = GetOrCreatePointerType(*GetVoid(), PTY_ptr);
+  }
+  lastDefaultTyIdx.SetIdx(primTypeIdx);
+}
+
+void TypeTable::SetTypeWithTyIdx(const TyIdx &tyIdx, MIRType &type) {
+  CHECK_FATAL(tyIdx < typeTable.size(), "array index out of range");
+  MIRType *oldType = typeTable.at(tyIdx);
+  typeTable.at(tyIdx) = &type;
+  if (oldType != nullptr && oldType != &type) {
+    (void)typeHashTable.erase(oldType);
+    (void)typeHashTable.insert(&type);
+    delete oldType;
+  }
+}
+
+TypeTable::~TypeTable() {
+  for (auto index = static_cast<uint32>(PTY_void); index < typeTable.size(); ++index) {
+    delete typeTable[index];
+    typeTable[index] = nullptr;
+  }
+}
+
+void TypeTable::PutToHashTable(MIRType *mirType) {
+  (void)typeHashTable.insert(mirType);
+}
+
+void TypeTable::UpdateMIRType(const MIRType &pType, const TyIdx tyIdx) {
+  MIRType *nType = pType.CopyMIRTypeNode();
+  nType->SetTypeIndex(tyIdx);
+  SetTypeWithTyIdx(tyIdx, *nType);
+}
+
+// used only by bin_mpl_import
+void TypeTable::CreateMirTypeNodeAt(MIRType &pType, TyIdx tyIdxUsed, MIRModule *module,
+                                    bool isObject, bool isIncomplete) {
+  MIRType *nType = pType.CopyMIRTypeNode();
+  nType->SetTypeIndex(tyIdxUsed);
+  typeTable[tyIdxUsed] = nType;
+
+  if (pType.IsMIRPtrType()) {
+    auto &pty = static_cast<MIRPtrType&>(pType);
+    if (pty.GetTypeAttrs() == TypeAttrs()) {
+      if (pty.GetPrimType() != PTY_ref) {
+        ptrTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
+      } else {
+        refTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
+      }
+    } else {
+      (void)typeHashTable.insert(nType);
+    }
+  } else {
+    (void)typeHashTable.insert(nType);
+  }
+
+  GStrIdx stridx = pType.GetNameStrIdx();
+  if (stridx != 0) {
+    module->GetTypeNameTab()->SetGStrIdxToTyIdx(stridx, tyIdxUsed);
+    module->PushbackTypeDefOrder(stridx);
+    if (isObject) {
+      module->AddClass(tyIdxUsed);
+      if (!isIncomplete) {
+        GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(stridx, tyIdxUsed);
+      }
+    }
+  }
+}
+
+MIRType *TypeTable::CreateAndUpdateMirTypeNode(MIRType &pType) {
+  MIRType *nType = pType.CopyMIRTypeNode();
+  nType->SetTypeIndex(TyIdx(typeTable.size()));
+  typeTable.push_back(nType);
+
+  if (pType.IsMIRPtrType()) {
+    auto &pty = static_cast<MIRPtrType&>(pType);
+    if (pty.GetTypeAttrs() == TypeAttrs()) {
+      if (pty.GetPrimType() != PTY_ref) {
+        ptrTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
+      } else {
+        refTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
+      }
+    } else {
+      (void)typeHashTable.insert(nType);
+    }
+  } else {
+    (void)typeHashTable.insert(nType);
+  }
+  return nType;
+}
+
+MIRType* TypeTable::GetOrCreateMIRTypeNode(MIRType &pType) {
+  if (pType.IsMIRPtrType()) {
+    auto &type = static_cast<MIRPtrType&>(pType);
+    if (type.GetTypeAttrs() == TypeAttrs()) {
+      auto *pMap = (type.GetPrimType() != PTY_ref ? &ptrTypeMap : &refTypeMap);
+      auto *otherPMap = (type.GetPrimType() == PTY_ref ? &ptrTypeMap : &refTypeMap);
+      {
+        std::shared_lock<std::shared_timed_mutex> lock(mtx);
+        const auto it = pMap->find(type.GetPointedTyIdx());
+        if (it != pMap->end()) {
+          return GetTypeFromTyIdx(it->second);
+        }
+      }
+      std::unique_lock<std::shared_timed_mutex> lock(mtx);
+      CHECK_FATAL(!(type.GetPointedTyIdx().GetIdx() >= kPtyDerived && type.GetPrimType() == PTY_ref &&
+                    otherPMap->find(type.GetPointedTyIdx()) != otherPMap->end()),
+                  "GetOrCreateMIRType: ref pointed-to type %d has previous ptr occurrence",
+                  type.GetPointedTyIdx().GetIdx());
+      return CreateAndUpdateMirTypeNode(pType);
+    }
+  }
+  {
+    std::shared_lock<std::shared_timed_mutex> lock(mtx);
+    const auto it = typeHashTable.find(&pType);
+    if (it != typeHashTable.end()) {
+      return *it;
+    }
+  }
+  std::unique_lock<std::shared_timed_mutex> lock(mtx);
+  return CreateAndUpdateMirTypeNode(pType);
+}
+
+MIRType *TypeTable::voidPtrType = nullptr;
+// get or create a type that pointing to pointedTyIdx
+MIRType *TypeTable::GetOrCreatePointerType(const TyIdx &pointedTyIdx, PrimType primType, const TypeAttrs &attrs) {
+  MIRPtrType type(pointedTyIdx, primType);
+  type.SetTypeAttrs(attrs);
+  TyIdx tyIdx = GetOrCreateMIRType(&type);
+  ASSERT(tyIdx < typeTable.size(), "index out of range in TypeTable::GetOrCreatePointerType");
+  return typeTable.at(tyIdx);
+}
+
+MIRType *TypeTable::GetOrCreatePointerType(const MIRType &pointTo, PrimType primType, const TypeAttrs &attrs) {
+  if (pointTo.GetPrimType() == PTY_constStr) {
+    primType = PTY_ptr;
+  }
+  return GetOrCreatePointerType(pointTo.GetTypeIndex(), primType, attrs);
+}
+
+const MIRType *TypeTable::GetPointedTypeIfApplicable(MIRType &type) const {
+  if (type.GetKind() != kTypePointer) {
+    return &type;
+  }
+  auto &ptrType = static_cast<MIRPtrType&>(type);
+  return GetTypeFromTyIdx(ptrType.GetPointedTyIdx());
+}
+MIRType *TypeTable::GetPointedTypeIfApplicable(MIRType &type) {
+  return const_cast<MIRType*>(const_cast<const TypeTable*>(this)->GetPointedTypeIfApplicable(type));
+}
+
+MIRArrayType *TypeTable::GetOrCreateArrayType(const MIRType &elem, uint8 dim, const uint32 *sizeArray,
+                                              const TypeAttrs &attrs) {
+  std::vector<uint32> sizeVector;
+  for (size_t i = 0; i < dim; ++i) {
+    sizeVector.push_back(sizeArray != nullptr ? sizeArray[i] : 0);
+  }
+  MIRArrayType arrayType(elem.GetTypeIndex(), sizeVector);
+  arrayType.SetTypeAttrs(attrs);
+  TyIdx tyIdx = GetOrCreateMIRType(&arrayType);
+  return static_cast<MIRArrayType*>(typeTable[tyIdx]);
+}
+
+// For one dimension array
+MIRArrayType *TypeTable::GetOrCreateArrayType(const MIRType &elem, uint32 size, const TypeAttrs &attrs) {
+  return GetOrCreateArrayType(elem, 1, &size, attrs);
+}
+
+MIRType *TypeTable::GetOrCreateFarrayType(const MIRType &elem) {
+  MIRFarrayType type;
+  type.SetElemtTyIdx(elem.GetTypeIndex());
+  TyIdx tyIdx = GetOrCreateMIRType(&type);
+  ASSERT(tyIdx < typeTable.size(), "index out of range in TypeTable::GetOrCreateFarrayType");
+  return typeTable.at(tyIdx);
+}
+
+MIRType *TypeTable::GetOrCreateJarrayType(const MIRType &elem) {
+  MIRJarrayType type;
+  type.SetElemtTyIdx(elem.GetTypeIndex());
+  TyIdx tyIdx = GetOrCreateMIRType(&type);
+  ASSERT(tyIdx < typeTable.size(), "index out of range in TypeTable::GetOrCreateJarrayType");
+  return typeTable.at(tyIdx);
+}
+
+MIRType *TypeTable::GetOrCreateFunctionType(const TyIdx &retTyIdx, const std::vector<TyIdx> &vecType,
+                                            const std::vector<TypeAttrs> &vecAttrs, bool isVarg,
+                                            const TypeAttrs &retAttrs) {
+  MIRFuncType funcType(retTyIdx, vecType, vecAttrs, retAttrs);
+  if (isVarg) {
+    funcType.SetVarArgs();
+  }
+  TyIdx tyIdx = GetOrCreateMIRType(&funcType);
+  ASSERT(tyIdx < typeTable.size(), "index out of range in TypeTable::GetOrCreateFunctionType");
+  return typeTable.at(tyIdx);
+}
+
+MIRType *TypeTable::GetOrCreateStructOrUnion(const std::string &name, const FieldVector &fields,
+                                             const FieldVector &parentFields, MIRModule &module, bool forStruct,
+                                             const TypeAttrs &attrs) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  MIRStructType type(forStruct ? kTypeStruct : kTypeUnion, strIdx);
+  type.SetFields(fields);
+  type.SetParentFields(parentFields);
+  type.SetTypeAttrs(attrs);
+
+  TyIdx tyIdx = GetOrCreateMIRType(&type);
+  // Global?
+  module.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx);
+  module.PushbackTypeDefOrder(strIdx);
+  ASSERT(tyIdx < typeTable.size(), "index out of range in TypeTable::GetOrCreateStructOrUnion");
+  return typeTable.at(tyIdx);
+}
+
+void TypeTable::PushIntoFieldVector(FieldVector &fields, const std::string &name, const MIRType &type) const {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  fields.push_back(FieldPair(strIdx, TyIdxFieldAttrPair(type.GetTypeIndex(), FieldAttrs())));
+}
+
+MIRType *TypeTable::GetOrCreateClassOrInterface(const std::string &name, MIRModule &module, bool forClass) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  TyIdx tyIdx = module.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
+  if (!tyIdx) {
+    if (forClass) {
+      MIRClassType type(kTypeClassIncomplete, strIdx);  // for class type
+      tyIdx = GetOrCreateMIRType(&type);
+    } else {
+      MIRInterfaceType type(kTypeInterfaceIncomplete, strIdx);  // for interface type
+      tyIdx = GetOrCreateMIRType(&type);
+    }
+    module.PushbackTypeDefOrder(strIdx);
+    module.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx);
+    if (typeTable[tyIdx]->GetNameStrIdx() == 0u) {
+      typeTable[tyIdx]->SetNameStrIdx(strIdx);
+    }
+  }
+  ASSERT(tyIdx < typeTable.size(), "index out of range in TypeTable::GetOrCreateClassOrInterface");
+  return typeTable.at(tyIdx);
+}
+
+void TypeTable::AddFieldToStructType(MIRStructType &structType, const std::string &fieldName,
+                                     const MIRType &fieldType) const {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fieldName);
+  FieldAttrs fieldAttrs;
+  fieldAttrs.SetAttr(FLDATTR_final);  // Mark compiler-generated struct fields as final to improve AliasAnalysis
+  structType.GetFields().push_back(FieldPair(strIdx, TyIdxFieldAttrPair(fieldType.GetTypeIndex(), fieldAttrs)));
+}
+
+void FPConstTable::PostInit() {
+  MIRType &typeFloat = *GlobalTables::GetTypeTable().GetPrimType(PTY_f32);
+  nanFloatConst = new MIRFloatConst(NAN, typeFloat);
+  infFloatConst = new MIRFloatConst(INFINITY, typeFloat);
+  minusInfFloatConst = new MIRFloatConst(-INFINITY, typeFloat);
+  minusZeroFloatConst = new MIRFloatConst(-0.0, typeFloat);
+  MIRType &typeDouble = *GlobalTables::GetTypeTable().GetPrimType(PTY_f64);
+  nanDoubleConst = new MIRDoubleConst(NAN, typeDouble);
+  infDoubleConst = new MIRDoubleConst(INFINITY, typeDouble);
+  minusInfDoubleConst = new MIRDoubleConst(-INFINITY, typeDouble);
+  minusZeroDoubleConst = new MIRDoubleConst(-0.0, typeDouble);
+}
+
+MIRIntConst *IntConstTable::GetOrCreateIntConst(const IntVal &val, MIRType &type) {
+  if (ThreadEnv::IsMeParallel()) {
+    return DoGetOrCreateIntConstTreadSafe(static_cast<uint64>(val.GetExtValue()), type);
+  }
+  return DoGetOrCreateIntConst(static_cast<uint64>(val.GetExtValue()), type);
+}
+
+MIRIntConst *IntConstTable::GetOrCreateIntConst(uint64 val, MIRType &type) {
+  if (ThreadEnv::IsMeParallel()) {
+    return DoGetOrCreateIntConstTreadSafe(val, type);
+  }
+  return DoGetOrCreateIntConst(val, type);
+}
+
+MIRIntConst *IntConstTable::DoGetOrCreateIntConst(uint64 val, MIRType &type) {
+  IntConstKey key(val, type.GetTypeIndex());
+  if (intConstTable.find(key) != intConstTable.end()) {
+    return intConstTable[key];
+  }
+  intConstTable[key] = new MIRIntConst(val, type);
+  return intConstTable[key];
+}
+
+MIRIntConst *IntConstTable::DoGetOrCreateIntConstTreadSafe(uint64 val, MIRType &type) {
+  IntConstKey key(val, type.GetTypeIndex());
+  {
+    std::shared_lock<std::shared_timed_mutex> lock(mtx);
+    if (intConstTable.find(key) != intConstTable.end()) {
+      return intConstTable[key];
+    }
+  }
+  std::unique_lock<std::shared_timed_mutex> lock(mtx);
+  intConstTable[key] = new MIRIntConst(val, type);
+  return intConstTable[key];
+}
+
+IntConstTable::~IntConstTable() {
+  for (auto pair : intConstTable) {
+    delete pair.second;
+  }
+}
+
+MIRFloatConst *FPConstTable::GetOrCreateFloatConst(float floatVal) {
+  if (std::isnan(floatVal)) {
+    return nanFloatConst;
+  }
+  if (std::isinf(floatVal)) {
+    return (floatVal < 0) ? minusInfFloatConst : infFloatConst;
+  }
+  if (floatVal == 0.0 && std::signbit(floatVal)) {
+    return minusZeroFloatConst;
+  }
+  if (ThreadEnv::IsMeParallel()) {
+    return DoGetOrCreateFloatConstThreadSafe(floatVal);
+  }
+  return DoGetOrCreateFloatConst(floatVal);
+}
+
+MIRFloatConst *FPConstTable::DoGetOrCreateFloatConst(float floatVal) {
+  const auto it = floatConstTable.find(floatVal);
+  if (it != floatConstTable.cend()) {
+    return it->second;
+  }
+  // create a new one
+  auto *floatConst =
+      new MIRFloatConst(floatVal, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx{ PTY_f32 }));
+  floatConstTable[floatVal] = floatConst;
+  return floatConst;
+}
+
+MIRFloatConst *FPConstTable::DoGetOrCreateFloatConstThreadSafe(float floatVal) {
+  {
+    std::shared_lock<std::shared_timed_mutex> lock(floatMtx);
+    const auto it = floatConstTable.find(floatVal);
+    if (it != floatConstTable.cend()) {
+      return it->second;
+    }
+  }
+  // create a new one
+  std::unique_lock<std::shared_timed_mutex> lock(floatMtx);
+  auto *floatConst =
+      new MIRFloatConst(floatVal, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx{ PTY_f32 }));
+  floatConstTable[floatVal] = floatConst;
+  return floatConst;
+}
+
+MIRDoubleConst *FPConstTable::GetOrCreateDoubleConst(double doubleVal) {
+  if (std::isnan(doubleVal)) {
+    return nanDoubleConst;
+  }
+  if (std::isinf(doubleVal)) {
+    return (doubleVal < 0) ? minusInfDoubleConst : infDoubleConst;
+  }
+  if (doubleVal == 0.0 && std::signbit(doubleVal)) {
+    return minusZeroDoubleConst;
+  }
+  if (ThreadEnv::IsMeParallel()) {
+    return DoGetOrCreateDoubleConstThreadSafe(doubleVal);
+  }
+  return DoGetOrCreateDoubleConst(doubleVal);
+}
+
+MIRDoubleConst *FPConstTable::DoGetOrCreateDoubleConst(double doubleVal) {
+  const auto it = doubleConstTable.find(doubleVal);
+  if (it != doubleConstTable.cend()) {
+    return it->second;
+  }
+  // create a new one
+  auto *doubleConst = new MIRDoubleConst(
+      doubleVal, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_f64)));
+  doubleConstTable[doubleVal] = doubleConst;
+  return doubleConst;
+}
+
+MIRDoubleConst *FPConstTable::DoGetOrCreateDoubleConstThreadSafe(double doubleVal) {
+  {
+    std::shared_lock<std::shared_timed_mutex> lock(doubleMtx);
+    const auto it = doubleConstTable.find(doubleVal);
+    if (it != doubleConstTable.cend()) {
+      return it->second;
+    }
+  }
+  // create a new one
+  std::unique_lock<std::shared_timed_mutex> lock(doubleMtx);
+  auto *doubleConst = new MIRDoubleConst(
+      doubleVal, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_f64)));
+  doubleConstTable[doubleVal] = doubleConst;
+  return doubleConst;
+}
+
+FPConstTable::~FPConstTable() {
+  delete nanFloatConst;
+  delete infFloatConst;
+  delete minusInfFloatConst;
+  delete minusZeroFloatConst;
+  delete nanDoubleConst;
+  delete infDoubleConst;
+  delete minusInfDoubleConst;
+  delete minusZeroDoubleConst;
+  for (const auto &floatConst : floatConstTable) {
+    delete floatConst.second;
+  }
+  for (const auto &doubleConst : doubleConstTable) {
+    delete doubleConst.second;
+  }
+}
+
+GSymbolTable::GSymbolTable() {
+  symbolTable.push_back(static_cast<MIRSymbol*>(nullptr));
+}
+
+GSymbolTable::~GSymbolTable() {
+  for (MIRSymbol *symbol : symbolTable) {
+    delete symbol;
+  }
+}
+
+MIRSymbol *GSymbolTable::CreateSymbol(uint8 scopeID) {
+  auto *st = new MIRSymbol(symbolTable.size(), scopeID);
+  CHECK_FATAL(st != nullptr, "CreateSymbol failure");
+  symbolTable.push_back(st);
+  module->AddSymbol(st);
+  return st;
+}
+
+bool GSymbolTable::AddToStringSymbolMap(const MIRSymbol &st) {
+  GStrIdx strIdx = st.GetNameStrIdx();
+  if (strIdxToStIdxMap[strIdx].FullIdx() != 0) {
+    return false;
+  }
+  strIdxToStIdxMap[strIdx] = st.GetStIdx();
+  return true;
+}
+
+bool GSymbolTable::RemoveFromStringSymbolMap(const MIRSymbol &st) {
+  const auto it = strIdxToStIdxMap.find(st.GetNameStrIdx());
+  if (it != strIdxToStIdxMap.cend()) {
+    strIdxToStIdxMap.erase(it);
+    return true;
+  }
+  return false;
+}
+
+void GSymbolTable::Dump(bool isLocal, int32 indent) const {
+  for (size_t i = 1; i < symbolTable.size(); ++i) {
+    const MIRSymbol *symbol = symbolTable[i];
+    if (symbol != nullptr) {
+      symbol->Dump(isLocal, indent);
+    }
+  }
+}
+
+GlobalTables GlobalTables::globalTables;
+GlobalTables &GlobalTables::GetGlobalTables() {
+  return globalTables;
+}
+}  // namespace maple
+#endif  // MIR_FEATURE_FULL
diff --git a/src/mapleall/maple_ir/src/intrinsics.cpp b/src/mapleall/maple_ir/src/intrinsics.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..65d95165957ab1b7cca77c0ccee8c354f86b3724
--- /dev/null
+++ b/src/mapleall/maple_ir/src/intrinsics.cpp
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "intrinsics.h"
+#include "mir_module.h"
+#include "mir_type.h"
+#include "mir_builder.h"
+
+namespace maple {
+MIRType *IntrinDesc::jsValueType = nullptr;
+MIRModule *IntrinDesc::mirModule = nullptr;
+IntrinDesc IntrinDesc::intrinTable[INTRN_LAST + 1] = {
+#define DEF_MIR_INTRINSIC(X, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ...) \
+  { (NAME), (NUM_INSN), (INTRN_CLASS), { (RETURN_TYPE), ##__VA_ARGS__ } },
+#include "intrinsics.def"
+#undef DEF_MIR_INTRINSIC
+};
+MIRType *IntrinDesc::GetOrCreateJSValueType() {
+  if (jsValueType != nullptr) {
+    return jsValueType;
+  }
+  MIRBuilder *jsBuilder = mirModule->GetMIRBuilder();
+  FieldVector payloadFields;
+  GStrIdx i32 = jsBuilder->GetOrCreateStringIndex("i32");
+  GStrIdx u32 = jsBuilder->GetOrCreateStringIndex("u32");
+  GStrIdx boo = jsBuilder->GetOrCreateStringIndex("boo");
+  GStrIdx ptr = jsBuilder->GetOrCreateStringIndex("ptr");
+  payloadFields.push_back(
+      FieldPair(i32, TyIdxFieldAttrPair(GlobalTables::GetTypeTable().GetInt32()->GetTypeIndex(), FieldAttrs())));
+  payloadFields.push_back(
+      FieldPair(u32, TyIdxFieldAttrPair(GlobalTables::GetTypeTable().GetUInt32()->GetTypeIndex(), FieldAttrs())));
+  payloadFields.push_back(
+      FieldPair(boo, TyIdxFieldAttrPair(GlobalTables::GetTypeTable().GetUInt32()->GetTypeIndex(), FieldAttrs())));
+  payloadFields.push_back(
+      FieldPair(ptr, TyIdxFieldAttrPair(GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex(), FieldAttrs())));
+  FieldVector parentFields;
+  MIRType *payloadType = GlobalTables::GetTypeTable().GetOrCreateUnionType("payload_type", payloadFields,
+                                                                           parentFields, *mirModule);
+  FieldVector sFields;
+  GStrIdx payload = jsBuilder->GetOrCreateStringIndex("payload");
+  GStrIdx tag = jsBuilder->GetOrCreateStringIndex("tag");
+  sFields.push_back(FieldPair(payload, TyIdxFieldAttrPair(payloadType->GetTypeIndex(), FieldAttrs())));
+  sFields.push_back(
+      FieldPair(tag, TyIdxFieldAttrPair(GlobalTables::GetTypeTable().GetUInt32()->GetTypeIndex(), FieldAttrs())));
+  MIRType *sType = GlobalTables::GetTypeTable().GetOrCreateStructType("s_type", sFields, parentFields, *mirModule);
+  CHECK_FATAL(sType != nullptr, "can't get struct type, check it!");
+  FieldVector jsValLayoutFields;
+  GStrIdx asBits = jsBuilder->GetOrCreateStringIndex("asBits");
+  GStrIdx s = jsBuilder->GetOrCreateStringIndex("s");
+  GStrIdx asDouble = jsBuilder->GetOrCreateStringIndex("asDouble");
+  GStrIdx asPtr = jsBuilder->GetOrCreateStringIndex("asPtr");
+  jsValLayoutFields.push_back(
+      FieldPair(asBits, TyIdxFieldAttrPair(GlobalTables::GetTypeTable().GetUInt64()->GetTypeIndex(), FieldAttrs())));
+  jsValLayoutFields.push_back(FieldPair(s, TyIdxFieldAttrPair(sType->GetTypeIndex(), FieldAttrs())));
+  jsValLayoutFields.push_back(
+      FieldPair(asDouble, TyIdxFieldAttrPair(GlobalTables::GetTypeTable().GetDouble()->GetTypeIndex(), FieldAttrs())));
+  jsValLayoutFields.push_back(
+      FieldPair(asPtr, TyIdxFieldAttrPair(GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex(), FieldAttrs())));
+  MIRType *jsValLayoutType = GlobalTables::GetTypeTable().GetOrCreateUnionType("jsval_layout_type",
+                                                                               jsValLayoutFields,
+                                                                               parentFields, *mirModule);
+  return jsValLayoutType;
+}
+
+void IntrinDesc::InitMIRModule(MIRModule *mod) {
+  mirModule = mod;
+}
+
+MIRType *IntrinDesc::GetTypeFromArgTy(IntrinArgType argType) const {
+  switch (argType) {
+    case kArgTyVoid:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_void));
+    case kArgTyI8:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_i8));
+    case kArgTyI16:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_i16));
+    case kArgTyI32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_i32));
+    case kArgTyI64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_i64));
+    case kArgTyU8:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_u8));
+    case kArgTyU16:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_u16));
+    case kArgTyU32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_u32));
+    case kArgTyU64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_u64));
+    case kArgTyU1:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_u1));
+    case kArgTyPtr:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_ptr));
+    case kArgTyRef:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_ref));
+    case kArgTyA32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_a32));
+    case kArgTyA64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_a64));
+    case kArgTyF32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_f32));
+    case kArgTyF64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_f64));
+    case kArgTyF128:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_f128));
+    case kArgTyC64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_c64));
+    case kArgTyC128:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_c128));
+    case kArgTyAgg:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_agg));
+    case kArgTyV2I64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v2i64));
+    case kArgTyV4I32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v4i32));
+    case kArgTyV8I16:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v8i16));
+    case kArgTyV16I8:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v16i8));
+    case kArgTyV2U64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v2u64));
+    case kArgTyV4U32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v4u32));
+    case kArgTyV8U16:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v8u16));
+    case kArgTyV16U8:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v16u8));
+    case kArgTyV2F64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v2f64));
+    case kArgTyV4F32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v4f32));
+    case kArgTyV1I64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_i64));
+    case kArgTyV2I32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v2i32));
+    case kArgTyV4I16:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v4i16));
+    case kArgTyV8I8:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v8i8));
+    case kArgTyV1U64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_u64));
+    case kArgTyV2U32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v2u32));
+    case kArgTyV4U16:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v4u16));
+    case kArgTyV8U8:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v8u8));
+    case kArgTyV1F64:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_f64));
+    case kArgTyV2F32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_v2f32));
+#ifdef DYNAMICLANG
+    case kArgTySimplestr:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_simplestr));
+    case kArgTySimpleobj:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_simpleobj));
+    case kArgTyDynany:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_dynany));
+    case kArgTyDyni32:
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_dyni32));
+#endif
+    default:
+      return nullptr;
+  }
+}
+
+MIRType *IntrinDesc::GetArgType(uint32 index) const {
+  // 0 is the arg of return type
+  CHECK_FATAL(index < kMaxArgsNum, "index out of range");
+  return GetTypeFromArgTy(argTypes[index + 1]);
+}
+
+MIRType *IntrinDesc::GetReturnType() const {
+  return GetTypeFromArgTy(argTypes[0]);
+}
+
+bool IntrinDesc::IsNthOpndMarkedToWrite(uint32 opndIdx) const {
+  CHECK_FATAL(opndIdx < 6, "intrinsic has <= 6 arguments.");
+  constexpr uint32 kIntrnWriteFlags[] = {
+      INTRNWRITEFIRSTOPND, INTRNWRITESECONDOPND, INTRNWRITETHIRDOPND,
+      INTRNWRITEFOURTHOPND, INTRNWRITEFIFTHOPND, INTRNWRITESIXTHOPND
+  };
+  return (properties & kIntrnWriteFlags[opndIdx]) != 0;
+}
+
+bool IntrinDesc::IsNthOpndMarkedToRead(uint32 opndIdx) const {
+  CHECK_FATAL(opndIdx < 6, "intrinsic has <= 6 arguments.");
+  constexpr uint32 kIntrnReadFlags[] = {
+      INTRNREADFIRSTOPND, INTRNREADSECONDOPND, INTRNREADTHIRDOPND,
+      INTRNREADFOURTHOPND, INTRNREADFIFTHOPND, INTRNREADSIXTHOPND
+  };
+  return (properties & kIntrnReadFlags[opndIdx]) != 0;
+}
+
+bool IntrinDesc::WriteNthOpnd(uint32 opndIdx) const {
+  // when to write the argument:
+  // 1. has side effect, and
+  // 2. marked with WRITE or marked with nothing
+  if (HasNoSideEffect()) {
+    return false; // read only
+  }
+  if (IsNthOpndMarkedToWrite(opndIdx)) {
+    return true;
+  }
+  // marked with nothing --> by default: write the argument
+  return !IsNthOpndMarkedToRead(opndIdx);
+}
+
+bool IntrinDesc::ReadNthOpnd(uint32 opndIdx) const {
+  // when to read the argument:
+  // 1. has no side effect, or
+  // 2. has side effect but marked with READ, or
+  // 3. has side effect but marked with nothing
+  if (HasNoSideEffect()) {
+    return true;
+  }
+  if (IsNthOpndMarkedToRead(opndIdx)) {
+    return true;
+  }
+  // marked with nothing --> by default: read the argument
+  return !IsNthOpndMarkedToWrite(opndIdx);
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/lexer.cpp b/src/mapleall/maple_ir/src/lexer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..719bb349c604afad93f8e5309ee1dbe3923e0c17
--- /dev/null
+++ b/src/mapleall/maple_ir/src/lexer.cpp
@@ -0,0 +1,736 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "lexer.h"
+#include <cmath>
+#include <climits>
+#include <cstdlib>
+#include "mpl_logging.h"
+#include "debug_info.h"
+#include "mir_module.h"
+#include "securec.h"
+#include "utils.h"
+
+namespace maple {
+int32 HexCharToDigit(char c) {
+  int32 ret = utils::ToDigit<16, int32>(c);
+  return (ret != INT32_MAX ? ret : 0);
+}
+
+static uint8 Char2num(char c) {
+  uint8 ret = utils::ToDigit<16>(c);
+  ASSERT(ret != UINT8_MAX, "not a hex value");
+  return ret;
+}
+
+// Read (next) line from the MIR (text) file, and return the read
+// number of chars.
+// if the line is empty (nothing but a newline), returns 0.
+// if EOF, return -1.
+// The trailing new-line character has been removed.
+int MIRLexer::ReadALine() {
+  if (airFile == nullptr) {
+    line = "";
+    return -1;
+  }
+
+  curIdx = 0;
+  if (!std::getline(*airFile, line)) {  // EOF
+    line = "";
+    airFile = nullptr;
+    currentLineSize = 0;
+    return -1;
+  }
+
+  RemoveReturnInline(line);
+  currentLineSize = line.length();
+  return currentLineSize;
+}
+
+MIRLexer::MIRLexer(MIRModule &mod)
+    : module(mod),
+      seenComments(mod.GetMPAllocator().Adapter()),
+      keywordMap(mod.GetMPAllocator().Adapter()) {
+  // initialize keywordMap
+  keywordMap.clear();
+#define KEYWORD(STR)            \
+  {                             \
+    std::string str;            \
+    str = #STR;                 \
+    keywordMap[str] = TK_##STR; \
+  }
+#include "keywords.def"
+#undef KEYWORD
+}
+
+void MIRLexer::PrepareForFile(const std::string &filename) {
+  // open MIR file
+  airFileInternal.open(filename);
+  CHECK_FATAL(airFileInternal.is_open(), "cannot open MIR file %s\n", &filename);
+
+  airFile = &airFileInternal;
+  // try to read the first line
+  if (ReadALine() < 0) {
+    lineNum = 0;
+  } else {
+    lineNum = 1;
+  }
+  module.GetDbgInfo()->UpdateMsg(lineNum, line.c_str());
+  kind = TK_invalid;
+}
+
+void MIRLexer::PrepareForString(const std::string &src) {
+  line = src;
+  RemoveReturnInline(line);
+  currentLineSize = line.size();
+  curIdx = 0;
+  NextToken();
+}
+
+void MIRLexer::GenName() {
+  uint32 startIdx = curIdx;
+  char c = GetNextCurrentCharWithUpperCheck();
+  char cp = GetCharAt(curIdx - 1);
+  if (c == '@' && (cp == 'h' || cp == 'f')) {
+    // special pattern for exception handling labels: catch or finally
+    c = GetNextCurrentCharWithUpperCheck();
+  }
+  while (utils::IsAlnum(c) || c < 0 || c == '_' || c == '$' || c == ';' ||
+         c == '/' || c == '|' || c == '.' || c == '?' ||
+         c == '@') {
+    c = GetNextCurrentCharWithUpperCheck();
+  }
+  name = line.substr(startIdx, curIdx - startIdx);
+}
+
+// get the constant value
+TokenKind MIRLexer::GetConstVal() {
+  bool negative = false;
+  int valStart = curIdx;
+  char c = GetCharAtWithUpperCheck(curIdx);
+  if (c == '-') {
+    c = GetNextCurrentCharWithUpperCheck();
+    TokenKind tk = GetSpecialFloatConst();
+    if (tk != TK_invalid) {
+      return tk;
+    }
+    negative = true;
+  }
+  const uint32 lenHexPrefix = 2;
+  if (line.compare(curIdx, lenHexPrefix, "0x") == 0) {
+    curIdx += lenHexPrefix;
+    return GetHexConst(valStart, negative);
+  }
+  uint32 startIdx = curIdx;
+  while (isdigit(c)) {
+    c = GetNextCurrentCharWithUpperCheck();
+  }
+  char cs = GetCharAtWithUpperCheck(startIdx);
+  if (!isdigit(cs) && c != '.') {
+    return TK_invalid;
+  }
+  if (c != '.' && c != 'f' && c != 'F' && c != 'e' && c != 'E') {
+    curIdx = startIdx;
+    return GetIntConst(valStart, negative);
+  }
+  return GetFloatConst(valStart, startIdx, negative);
+}
+
+TokenKind MIRLexer::GetSpecialFloatConst() {
+  constexpr uint32 lenSpecFloat = 4;
+  constexpr uint32 lenSpecDouble = 3;
+  if (line.compare(curIdx, lenSpecFloat, "inff") == 0 &&
+      !utils::IsAlnum(GetCharAtWithUpperCheck(curIdx + lenSpecFloat))) {
+    curIdx += lenSpecFloat;
+    theFloatVal = -INFINITY;
+    return TK_floatconst;
+  }
+  if (line.compare(curIdx, lenSpecDouble, "inf") == 0 &&
+      !utils::IsAlnum(GetCharAtWithUpperCheck(curIdx + lenSpecDouble))) {
+    curIdx += lenSpecDouble;
+    theDoubleVal = -INFINITY;
+    return TK_doubleconst;
+  }
+  if (line.compare(curIdx, lenSpecFloat, "nanf") == 0 &&
+      !utils::IsAlnum(GetCharAtWithUpperCheck(curIdx + lenSpecFloat))) {
+    curIdx += lenSpecFloat;
+    theFloatVal = -NAN;
+    return TK_floatconst;
+  }
+  if (line.compare(curIdx, lenSpecDouble, "nan") == 0 &&
+      !utils::IsAlnum(GetCharAtWithUpperCheck(curIdx + lenSpecDouble))) {
+    curIdx += lenSpecDouble;
+    theDoubleVal = -NAN;
+    return TK_doubleconst;
+  }
+  return TK_invalid;
+}
+
+TokenKind MIRLexer::GetHexConst(uint32 valStart, bool negative) {
+  char c = GetCharAtWithUpperCheck(curIdx);
+  if (!isxdigit(c)) {
+    name = line.substr(valStart, curIdx - valStart);
+    return TK_invalid;
+  }
+  uint64 tmp = static_cast<uint32>(HexCharToDigit(c));
+  c = GetNextCurrentCharWithUpperCheck();
+  while (isxdigit(c)) {
+    tmp = (tmp << 4) + static_cast<uint32>(HexCharToDigit(c));
+    c = GetNextCurrentCharWithUpperCheck();
+  }
+  theIntVal = tmp;
+  if (negative) {
+    theIntVal = -theIntVal;
+  }
+  theFloatVal = static_cast<float>(theIntVal);
+  theDoubleVal = static_cast<double>(theIntVal);
+  if (negative && theIntVal == 0) {
+    theFloatVal = -theFloatVal;
+    theDoubleVal = -theDoubleVal;
+  }
+  name = line.substr(valStart, curIdx - valStart);
+  return TK_intconst;
+}
+
+TokenKind MIRLexer::GetIntConst(uint32 valStart, bool negative) {
+  auto negOrSelf = [negative](uint64 val) { return negative ? ~val + 1 : val; };
+
+  theIntVal = static_cast<uint64_t>(HexCharToDigit(GetCharAtWithUpperCheck(curIdx)));
+
+  uint64 radix = theIntVal == 0 ? 8 : 10;
+
+  char c = GetNextCurrentCharWithUpperCheck();
+
+  for (theIntVal = negOrSelf(theIntVal); isdigit(c); c = GetNextCurrentCharWithUpperCheck()) {
+    theIntVal = (theIntVal * radix) + negOrSelf(static_cast<uint64_t>(HexCharToDigit(c)));
+  }
+
+  if (c == 'u' || c == 'U') {  // skip 'u' or 'U'
+    c = GetNextCurrentCharWithUpperCheck();
+    if (c == 'l' || c == 'L') {
+      c = GetNextCurrentCharWithUpperCheck();
+    }
+  }
+
+  if (c == 'l' || c == 'L') {
+    c = GetNextCurrentCharWithUpperCheck();
+    if (c == 'l' || c == 'L' || c == 'u' || c == 'U') {
+      ++curIdx;
+    }
+  }
+
+  name = line.substr(valStart, curIdx - valStart);
+
+  if (negative) {
+    theFloatVal = static_cast<float>(static_cast<int64>(theIntVal));
+    theDoubleVal = static_cast<double>(static_cast<int64>(theIntVal));
+
+    if (theIntVal == 0) {
+      theFloatVal = -theFloatVal;
+      theDoubleVal = -theDoubleVal;
+    }
+  } else {
+    theFloatVal = static_cast<float>(theIntVal);
+    theDoubleVal = static_cast<double>(theIntVal);
+  }
+
+  return TK_intconst;
+}
+
+TokenKind MIRLexer::GetFloatConst(uint32 valStart, uint32 startIdx, bool negative) {
+  char c = GetCharAtWithUpperCheck(curIdx);
+  if (c == '.') {
+    c = GetNextCurrentCharWithUpperCheck();
+  }
+  while (isdigit(c)) {
+    c = GetNextCurrentCharWithUpperCheck();
+  }
+  bool doublePrec = true;
+  if (c == 'e' || c == 'E') {
+    c = GetNextCurrentCharWithUpperCheck();
+    if (!isdigit(c) && c != '-' && c != '+') {
+      name = line.substr(valStart, curIdx - valStart);
+      return TK_invalid;
+    }
+    if (c == '-' || c == '+') {
+      c = GetNextCurrentCharWithUpperCheck();
+    }
+    while (isdigit(c)) {
+      c = GetNextCurrentCharWithUpperCheck();
+    }
+  }
+  if (c == 'f' || c == 'F') {
+    doublePrec = false;
+    c = GetNextCurrentCharWithUpperCheck();
+  }
+  if (c == 'l' || c == 'L') {
+    MIR_ERROR("warning: not yet support long double\n");
+    ++curIdx;
+  }
+
+  std::string floatStr = line.substr(startIdx, curIdx - startIdx);
+  // get the float constant value
+  if (!doublePrec) {
+    int eNum = sscanf_s(floatStr.c_str(), "%e", &theFloatVal);
+    CHECK_FATAL(eNum == 1, "sscanf_s failed");
+
+    if (negative) {
+      theFloatVal = -theFloatVal;
+    }
+    theIntVal = static_cast<uint64>(theFloatVal);
+    theDoubleVal = static_cast<double>(theFloatVal);
+    if (negative && fabs(theFloatVal) <= 1e-6) {
+      theDoubleVal = -theDoubleVal;
+    }
+    name = line.substr(valStart, curIdx - valStart);
+    return TK_floatconst;
+  } else {
+    int eNum = sscanf_s(floatStr.c_str(), "%le", &theDoubleVal);
+    CHECK_FATAL(eNum == 1, "sscanf_s failed");
+
+    if (negative) {
+      theDoubleVal = -theDoubleVal;
+    }
+    theIntVal = static_cast<uint64>(theDoubleVal);
+    theFloatVal = static_cast<float>(theDoubleVal);
+    if (negative && fabs(theDoubleVal) <= 1e-15) {
+      theFloatVal = -theFloatVal;
+    }
+    name = line.substr(valStart, curIdx - valStart);
+    return TK_doubleconst;
+  }
+}
+
+TokenKind MIRLexer::GetTokenWithPrefixDollar() {
+  // token with prefix '$'
+  char c = GetCharAtWithUpperCheck(curIdx);
+  if (utils::IsAlpha(c) || c == '_' || c == '$') {
+    GenName();
+    return TK_gname;
+  } else {
+    // for error reporting.
+    const uint32 printLength = 2;
+    name = line.substr(curIdx - 1, printLength);
+    return TK_invalid;
+  }
+}
+
+TokenKind MIRLexer::GetTokenWithPrefixPercent() {
+  // token with prefix '%'
+  char c = GetCharAtWithUpperCheck(curIdx);
+  if (isdigit(c)) {
+    int valStart = curIdx - 1;
+    theIntVal = static_cast<uint64_t>(HexCharToDigit(c));
+    c = GetNextCurrentCharWithUpperCheck();
+    while (isdigit(c)) {
+      theIntVal = (theIntVal * 10) + static_cast<uint64_t>(HexCharToDigit(c));
+      ASSERT(theIntVal >= 0, "int value overflow");
+      c = GetNextCurrentCharWithUpperCheck();
+    }
+    name = line.substr(valStart, curIdx - valStart);
+    return TK_preg;
+  }
+  if (utils::IsAlpha(c) || c == '_' || c == '$') {
+    GenName();
+    return TK_lname;
+  }
+  if (c == '%' && utils::IsAlpha(GetCharAtWithUpperCheck(curIdx + 1))) {
+    ++curIdx;
+    GenName();
+    return TK_specialreg;
+  }
+  return TK_invalid;
+}
+
+TokenKind MIRLexer::GetTokenWithPrefixAmpersand() {
+  // token with prefix '&'
+  char c = GetCurrentCharWithUpperCheck();
+  if (utils::IsAlpha(c) || c == '_') {
+    GenName();
+    return TK_fname;
+  }
+  // for error reporting.
+  constexpr uint32 printLength = 2;
+  name = line.substr(curIdx - 1, printLength);
+  return TK_invalid;
+}
+
+TokenKind MIRLexer::GetTokenWithPrefixAtOrCircumflex(char prefix) {
+  // token with prefix '@' or `^`
+  char c = GetCurrentCharWithUpperCheck();
+  if (utils::IsAlnum(c) || c < 0 || c == '_' || c == '@' || c == '$' || c == '|') {
+    GenName();
+    if (prefix == '@') {
+      return TK_label;
+    }
+    return TK_prntfield;
+  }
+  return TK_invalid;
+}
+
+TokenKind MIRLexer::GetTokenWithPrefixExclamation() {
+  // token with prefix '!'
+  char c = GetCurrentCharWithUpperCheck();
+  if (utils::IsAlpha(c)) {
+    GenName();
+    return TK_typeparam;
+  }
+  // for error reporting.
+  const uint32 printLength = 2;
+  name = line.substr(curIdx - 1, printLength);
+  return TK_invalid;
+}
+
+TokenKind MIRLexer::GetTokenWithPrefixQuotation() {
+  if (GetCharAtWithUpperCheck(curIdx + 1) == '\'') {
+    theIntVal = static_cast<uint64_t>(GetCharAtWithUpperCheck(curIdx));
+    curIdx += 2;
+    return TK_intconst;
+  }
+  return TK_invalid;
+}
+
+TokenKind MIRLexer::GetTokenWithPrefixDoubleQuotation() {
+  uint32 startIdx = curIdx;
+  uint32 shift = 0;
+  // for \", skip the \ to leave " only internally
+  // and also for the pair of chars \ and n become '\n' etc.
+  char c = GetCurrentCharWithUpperCheck();
+  while ((c != 0) && (c != '\"' || GetCharAtWithLowerCheck(curIdx - 1) == '\\')) {
+    if (GetCharAtWithLowerCheck(curIdx - 1) == '\\') {
+      shift++;
+      switch (c) {
+        case '"':
+          line[curIdx - shift] = c;
+          break;
+        case '\\':
+          line[curIdx - shift] = c;
+          // avoid 3rd \ in \\\ being treated as an escaped one
+          line[curIdx] = 0;
+          break;
+        case 'a':
+          line[curIdx - shift] = '\a';
+          break;
+        case 'b':
+          line[curIdx - shift] = '\b';
+          break;
+        case 't':
+          line[curIdx - shift] = '\t';
+          break;
+        case 'n':
+          line[curIdx - shift] = '\n';
+          break;
+        case 'v':
+          line[curIdx - shift] = '\v';
+          break;
+        case 'f':
+          line[curIdx - shift] = '\f';
+          break;
+        case 'r':
+          line[curIdx - shift] = '\r';
+          break;
+        // support hex value \xNN
+        case 'x': {
+          const uint32 hexShift = 4;
+          const uint32 hexLength = 2;
+          uint8 c1 = Char2num(GetCharAtWithLowerCheck(curIdx + 1));
+          uint8 c2 = Char2num(GetCharAtWithLowerCheck(curIdx + 2));
+          uint32 cNew = static_cast<uint8_t>(c1 << hexShift) + c2;
+          line[curIdx - shift] = cNew;
+          curIdx += hexLength;
+          shift += hexLength;
+          break;
+        }
+        // support oct value \NNN
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9': {
+          const uint32 octShift1 = 3;
+          const uint32 octShift2 = 6;
+          const uint32 octLength = 3;
+          ASSERT(curIdx + octLength < line.size(), "index out of range");
+          uint32 cNew =
+              static_cast<uint8>(static_cast<uint8>(GetCharAtWithLowerCheck(curIdx + 1) - '0') << octShift2) +
+              static_cast<uint8>(static_cast<uint8>(GetCharAtWithLowerCheck(curIdx + 2) - '0') << octShift1) +
+              static_cast<uint8>(GetCharAtWithLowerCheck(curIdx + 3) - '0');
+          line[curIdx - shift] = cNew;
+          curIdx += octLength;
+          shift += octLength;
+          break;
+        }
+        default:
+          line[curIdx - shift] = '\\';
+          --shift;
+          line[curIdx - shift] = c;
+          break;
+      }
+    } else if (shift != 0) {
+      line[curIdx - shift] = c;
+    }
+    c = GetNextCurrentCharWithUpperCheck();
+  }
+  if (c != '\"') {
+    return TK_invalid;
+  }
+  // for empty string
+  if (startIdx == curIdx) {
+    name = "";
+  } else {
+    name = line.substr(startIdx, curIdx - startIdx - shift);
+  }
+  ++curIdx;
+  return TK_string;
+}
+
+TokenKind MIRLexer::GetTokenSpecial() {
+  --curIdx;
+  char c = GetCharAtWithLowerCheck(curIdx);
+  if (utils::IsAlpha(c) || c < 0 || c == '_') {
+    GenName();
+    TokenKind tk = keywordMap[name];
+    switch (tk) {
+      case TK_nanf:
+        theFloatVal = NAN;
+        return TK_floatconst;
+      case TK_nan:
+        theDoubleVal = NAN;
+        return TK_doubleconst;
+      case TK_inff:
+        theFloatVal = INFINITY;
+        return TK_floatconst;
+      case TK_inf:
+        theDoubleVal = INFINITY;
+        return TK_doubleconst;
+      default:
+        return tk;
+    }
+  }
+  MIR_ERROR("error in input file\n");
+  return TK_eof;
+}
+
+TokenKind MIRLexer::LexToken() {
+  // skip spaces
+  char c = GetCurrentCharWithUpperCheck();
+  while (c == ' ' || c == '\t') {
+    c = GetNextCurrentCharWithUpperCheck();
+  }
+  // check end of line
+  while (c == 0 || c == '#') {
+    if (c == '#') {  // process comment contents
+      seenComments.push_back(line.substr(curIdx + 1, currentLineSize - curIdx - 1));
+    }
+    if (ReadALine() < 0) {
+      return TK_eof;
+    }
+    ++lineNum;  // a new line read.
+    module.GetDbgInfo()->UpdateMsg(lineNum, line.c_str());
+    // skip spaces
+    c = GetCurrentCharWithUpperCheck();
+    while (c == ' ' || c == '\t') {
+      c = GetNextCurrentCharWithUpperCheck();
+    }
+  }
+  char curChar = c;
+  ++curIdx;
+  switch (curChar) {
+    case '\n':
+      return TK_newline;
+    case '(':
+      return TK_lparen;
+    case ')':
+      return TK_rparen;
+    case '{':
+      return TK_lbrace;
+    case '}':
+      return TK_rbrace;
+    case '[':
+      return TK_lbrack;
+    case ']':
+      return TK_rbrack;
+    case '<':
+      return TK_langle;
+    case '>':
+      return TK_rangle;
+    case '=':
+      return TK_eqsign;
+    case ',':
+      return TK_coma;
+    case ':':
+      return TK_colon;
+    case '*':
+      return TK_asterisk;
+    case '.':
+      if (GetCharAtWithUpperCheck(curIdx) == '.') {
+        const uint32 lenDotdot = 2;
+        curIdx += lenDotdot;
+        return TK_dotdotdot;
+      }
+    // fall thru for .9100 == 0.9100
+    [[clang::fallthrough]];
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '-':
+      --curIdx;
+      return GetConstVal();
+    case '$':
+      return GetTokenWithPrefixDollar();
+    case '%':
+      return GetTokenWithPrefixPercent();
+    case '&':
+      return GetTokenWithPrefixAmpersand();
+    case '@':
+    case '^':
+      return GetTokenWithPrefixAtOrCircumflex(curChar);
+    case '!':
+      return GetTokenWithPrefixExclamation();
+    case '\'':
+      return GetTokenWithPrefixQuotation();
+    case '\"':
+      return GetTokenWithPrefixDoubleQuotation();
+    default:
+      return GetTokenSpecial();
+  }
+}
+
+TokenKind MIRLexer::NextToken() {
+  kind = LexToken();
+  return kind;
+}
+
+std::string MIRLexer::GetTokenString() const {
+  std::string temp;
+  switch (kind) {
+    case TK_gname: {
+      temp = "$";
+      temp.append(name);
+      return temp;
+    }
+    case TK_lname:
+    case TK_preg: {
+      temp = "%";
+      temp.append(name);
+      return temp;
+    }
+    case TK_specialreg: {
+      temp = "%%";
+      temp.append(name);
+      return temp;
+    }
+    case TK_label: {
+      temp = "@";
+      temp.append(name);
+      return temp;
+    }
+    case TK_prntfield: {
+      temp = "^";
+      temp.append(name);
+      return temp;
+    }
+    case TK_intconst: {
+      temp = std::to_string(theIntVal);
+      return temp;
+    }
+    case TK_floatconst: {
+      temp = std::to_string(theFloatVal);
+      return temp;
+    }
+    case TK_doubleconst: {
+      temp = std::to_string(theDoubleVal);
+      return temp;
+    }
+    // misc.
+    case TK_newline: {
+      temp = "\\n";
+      return temp;
+    }
+    case TK_lparen: {
+      temp = "(";
+      return temp;
+    }
+    case TK_rparen: {
+      temp = ")";
+      return temp;
+    }
+    case TK_lbrace: {
+      temp = "{";
+      return temp;
+    }
+    case TK_rbrace: {
+      temp = "}";
+      return temp;
+    }
+    case TK_lbrack: {
+      temp = "[";
+      return temp;
+    }
+    case TK_rbrack: {
+      temp = "]";
+      return temp;
+    }
+    case TK_langle: {
+      temp = "<";
+      return temp;
+    }
+    case TK_rangle: {
+      temp = ">";
+      return temp;
+    }
+    case TK_eqsign: {
+      temp = "=";
+      return temp;
+    }
+    case TK_coma: {
+      temp = ",";
+      return temp;
+    }
+    case TK_dotdotdot: {
+      temp = "...";
+      return temp;
+    }
+    case TK_colon: {
+      temp = ":";
+      return temp;
+    }
+    case TK_asterisk: {
+      temp = "*";
+      return temp;
+    }
+    case TK_string: {
+      temp = "\"";
+      temp.append(name);
+      temp.append("\"");
+      return temp;
+    }
+    default:
+      temp = "invalid token";
+      return temp;
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_builder.cpp b/src/mapleall/maple_ir/src/mir_builder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bff9422280f5b92488226783dac4a095de9c3429
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_builder.cpp
@@ -0,0 +1,1182 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_builder.h"
+#include "mir_symbol_builder.h"
+
+namespace maple {
+// This is for compiler-generated metadata 1-level struct
+void MIRBuilder::AddIntFieldConst(const MIRStructType &sType, MIRAggConst &newConst,
+                                  uint32 fieldID, int64 constValue) const {
+  auto *fieldConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+      static_cast<uint64_t>(constValue), *sType.GetElemType(fieldID - 1));
+  newConst.AddItem(fieldConst, fieldID);
+}
+
+// This is for compiler-generated metadata 1-level struct
+void MIRBuilder::AddAddrofFieldConst(const MIRStructType &structType, MIRAggConst &newConst, uint32 fieldID,
+                                     const MIRSymbol &fieldSymbol) {
+  AddrofNode *fieldExpr = CreateExprAddrof(0, fieldSymbol, mirModule->GetMemPool());
+  auto *fieldConst = mirModule->GetMemPool()->New<MIRAddrofConst>(fieldExpr->GetStIdx(), fieldExpr->GetFieldID(),
+                                                                  *structType.GetElemType(fieldID - 1));
+  newConst.AddItem(fieldConst, fieldID);
+}
+
+// This is for compiler-generated metadata 1-level struct
+void MIRBuilder::AddAddroffuncFieldConst(const MIRStructType &structType, MIRAggConst &newConst, uint32 fieldID,
+                                         const MIRSymbol &funcSymbol) {
+  MIRConst *fieldConst = nullptr;
+  MIRFunction *vMethod = funcSymbol.GetFunction();
+  if (vMethod->IsAbstract()) {
+    fieldConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *structType.GetElemType(fieldID - 1));
+  } else {
+    AddroffuncNode *addrofFuncExpr =
+        CreateExprAddroffunc(funcSymbol.GetFunction()->GetPuidx(), mirModule->GetMemPool());
+    fieldConst = mirModule->GetMemPool()->New<MIRAddroffuncConst>(addrofFuncExpr->GetPUIdx(),
+                                                                  *structType.GetElemType(fieldID - 1));
+  }
+  newConst.AddItem(fieldConst, fieldID);
+}
+
+// fieldID is continuously being updated during traversal;
+// when the field is found, its field id is returned via fieldID
+bool MIRBuilder::TraverseToNamedField(MIRStructType &structType, GStrIdx nameIdx, uint32 &fieldID) {
+  TyIdx tid(0);
+  return TraverseToNamedFieldWithTypeAndMatchStyle(structType, nameIdx, tid, fieldID, kMatchAnyField);
+}
+
+// traverse parent first but match self first.
+void MIRBuilder::TraverseToNamedFieldWithType(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx,
+                                              uint32 &fieldID, uint32 &idx) {
+  if (structType.IsIncomplete()) {
+    (void)incompleteTypeRefedSet.insert(structType.GetTypeIndex());
+  }
+  // process parent
+  if (structType.GetKind() == kTypeClass || structType.GetKind() == kTypeClassIncomplete) {
+    auto &classType = static_cast<MIRClassType&>(structType);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType.GetParentTyIdx());
+    auto *parentType = static_cast<MIRStructType*>(type);
+    if (parentType != nullptr) {
+      ++fieldID;
+      TraverseToNamedFieldWithType(*parentType, nameIdx, typeIdx, fieldID, idx);
+    }
+  }
+  for (uint32 fieldIdx = 0; fieldIdx < structType.GetFieldsSize(); ++fieldIdx) {
+    ++fieldID;
+    TyIdx fieldTyIdx = structType.GetFieldsElemt(fieldIdx).second.first;
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    if (structType.GetFieldsElemt(fieldIdx).first == nameIdx) {
+      if (typeIdx == 0u || fieldTyIdx == typeIdx) {
+        idx = fieldID;
+        continue;
+      }
+      // for pointer type, check their pointed type
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx);
+      if (type->IsOfSameType(*fieldType)) {
+        idx = fieldID;
+      }
+    }
+
+    if (fieldType->IsStructType()) {
+      auto *subStructType = static_cast<MIRStructType*>(fieldType);
+      TraverseToNamedFieldWithType(*subStructType, nameIdx, typeIdx, fieldID, idx);
+    }
+  }
+}
+
+// fieldID is continuously being updated during traversal;
+// when the field is found, its field id is returned via fieldID
+// typeidx: TyIdx(0) means do not check types.
+// matchstyle: 0: do not match but traverse to update fieldID
+//             1: match top level field only
+//             2: match any field
+//             4: traverse parent first
+//          0xc: do not match but traverse to update fieldID, traverse parent first, found in child
+bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx,
+                                                           uint32 &fieldID, unsigned int matchStyle) {
+  if (structType.IsIncomplete()) {
+    (void)incompleteTypeRefedSet.insert(structType.GetTypeIndex());
+  }
+  if ((matchStyle & kParentFirst) != 0) {
+    // process parent
+    if ((structType.GetKind() != kTypeClass) && (structType.GetKind() != kTypeClassIncomplete)) {
+      return false;
+    }
+
+    auto &classType = static_cast<MIRClassType&>(structType);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType.GetParentTyIdx());
+    auto *parentType = static_cast<MIRStructType*>(type);
+    if (parentType != nullptr) {
+      ++fieldID;
+      if (matchStyle == (kFoundInChild | kParentFirst | kUpdateFieldID)) {
+        matchStyle = kParentFirst;
+        uint32 idxBackup = nameIdx;
+        nameIdx.reset();
+        // do not match but traverse to update fieldID, traverse parent first
+        TraverseToNamedFieldWithTypeAndMatchStyle(*parentType, nameIdx, typeIdx, fieldID, matchStyle);
+        nameIdx.reset(idxBackup);
+      } else if (TraverseToNamedFieldWithTypeAndMatchStyle(*parentType, nameIdx, typeIdx, fieldID, matchStyle)) {
+        return true;
+      }
+    }
+  }
+  for (uint32 fieldIdx = 0; fieldIdx < structType.GetFieldsSize(); ++fieldIdx) {
+    ++fieldID;
+    TyIdx fieldTyIdx = structType.GetFieldsElemt(fieldIdx).second.first;
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    ASSERT(fieldType != nullptr, "fieldType is null");
+    if (matchStyle && structType.GetFieldsElemt(fieldIdx).first == nameIdx) {
+      if (typeIdx == 0u || fieldTyIdx == typeIdx ||
+          fieldType->IsOfSameType(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx))) {
+        return true;
+      }
+    }
+    unsigned int style = matchStyle & kMatchAnyField;
+    if (fieldType->IsStructType()) {
+      auto *subStructType = static_cast<MIRStructType*>(fieldType);
+      if (TraverseToNamedFieldWithTypeAndMatchStyle(*subStructType, nameIdx, typeIdx, fieldID, style)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+FieldID MIRBuilder::GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx,
+                                                    unsigned int matchStyle) {
+  auto &structType = static_cast<MIRStructType&>(type);
+  uint32 fieldID = 0;
+  GStrIdx strIdx = GetStringIndex(name);
+  if (TraverseToNamedFieldWithTypeAndMatchStyle(structType, strIdx, idx, fieldID, matchStyle)) {
+    return fieldID;
+  }
+  return 0;
+}
+
+FieldID MIRBuilder::GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx) {
+  return GetStructFieldIDFromNameAndType(type, name, idx, kMatchAnyField);
+}
+
+FieldID MIRBuilder::GetStructFieldIDFromNameAndTypeParentFirst(MIRType &type, const std::string &name, TyIdx idx) {
+  return GetStructFieldIDFromNameAndType(type, name, idx, kParentFirst);
+}
+
+FieldID MIRBuilder::GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(MIRType &type, const std::string &name,
+                                                                           TyIdx idx) {
+  // do not match but traverse to update fieldID, traverse parent first, found in child
+  return GetStructFieldIDFromNameAndType(type, name, idx, kFoundInChild | kParentFirst | kUpdateFieldID);
+}
+
+FieldID MIRBuilder::GetStructFieldIDFromFieldName(MIRType &type, const std::string &name) {
+  return GetStructFieldIDFromNameAndType(type, name, TyIdx(0), kMatchAnyField);
+}
+
+FieldID MIRBuilder::GetStructFieldIDFromFieldNameParentFirst(MIRType *type, const std::string &name) {
+  if (type == nullptr) {
+    return 0;
+  }
+  return GetStructFieldIDFromNameAndType(*type, name, TyIdx(0), kParentFirst);
+}
+
+void MIRBuilder::SetStructFieldIDFromFieldName(MIRStructType &structType, const std::string &name, GStrIdx newStrIdx,
+                                               const MIRType &newFieldType) const {
+  uint32 fieldID = 0;
+  GStrIdx strIdx = GetStringIndex(name);
+  while (true) {
+    if (structType.GetElemStrIdx(fieldID) == strIdx) {
+      if (newStrIdx != 0u) {
+        structType.SetElemStrIdx(fieldID, newStrIdx);
+      }
+      structType.SetElemtTyIdx(fieldID, newFieldType.GetTypeIndex());
+      return;
+    }
+    ++fieldID;
+  }
+}
+
+// create a function named str
+MIRFunction *MIRBuilder::GetOrCreateFunction(const std::string &str, TyIdx retTyIdx) {
+  GStrIdx strIdx = GetStringIndex(str);
+  MIRSymbol *funcSt = nullptr;
+  if (strIdx != 0u) {
+    funcSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+    if (funcSt == nullptr) {
+      funcSt = CreateSymbol(TyIdx(0), strIdx, kStFunc, kScText, nullptr, kScopeGlobal);
+    } else {
+      ASSERT(funcSt->GetSKind() == kStFunc, "runtime check error");
+      return funcSt->GetFunction();
+    }
+  } else {
+    strIdx = GetOrCreateStringIndex(str);
+    funcSt = CreateSymbol(TyIdx(0), strIdx, kStFunc, kScText, nullptr, kScopeGlobal);
+  }
+  auto *fn = mirModule->GetMemPool()->New<MIRFunction>(mirModule, funcSt->GetStIdx());
+  fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
+  MIRFuncType funcType;
+  funcType.SetRetTyIdx(retTyIdx);
+  auto funcTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&funcType);
+  auto *funcTypeInTypeTable = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcTyIdx));
+  fn->SetMIRFuncType(funcTypeInTypeTable);
+  fn->SetReturnTyIdx(retTyIdx);
+  GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
+  funcSt->SetFunction(fn);
+  funcSt->SetTyIdx(funcTyIdx);
+  return fn;
+}
+
+MIRFunction *MIRBuilder::GetFunctionFromSymbol(const MIRSymbol &funcSymbol) const {
+  ASSERT(funcSymbol.GetSKind() == kStFunc, "Symbol %s is not a function symbol", funcSymbol.GetName().c_str());
+  return funcSymbol.GetFunction();
+}
+
+MIRFunction *MIRBuilder::GetFunctionFromName(const std::string &str) {
+  auto *funcSymbol =
+      GlobalTables::GetGsymTable().GetSymbolFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(str));
+  return funcSymbol != nullptr ? GetFunctionFromSymbol(*funcSymbol) : nullptr;
+}
+
+MIRFunction *MIRBuilder::GetFunctionFromStidx(StIdx stIdx) {
+  auto *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+  return funcSymbol != nullptr ? GetFunctionFromSymbol(*funcSymbol) : nullptr;
+}
+
+MIRFunction *MIRBuilder::CreateFunction(const std::string &name, const MIRType &returnType, const ArgVector &arguments,
+                                        bool isVarg, bool createBody) const {
+  MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  GStrIdx strIdx = GetOrCreateStringIndex(name);
+  funcSymbol->SetNameStrIdx(strIdx);
+  if (!GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcSymbol)) {
+    return nullptr;
+  }
+  funcSymbol->SetStorageClass(kScText);
+  funcSymbol->SetSKind(kStFunc);
+  auto *fn = mirModule->GetMemPool()->New<MIRFunction>(mirModule, funcSymbol->GetStIdx());
+  fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
+  GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
+  std::vector<TyIdx> funcVecType;
+  std::vector<TypeAttrs> funcVecAttrs;
+  for (size_t i = 0; i < arguments.size(); ++i) {
+    MIRType *ty = arguments[i].second;
+    FormalDef formalDef(GetOrCreateStringIndex(arguments[i].first.c_str()), nullptr, ty->GetTypeIndex(), TypeAttrs());
+    fn->GetFormalDefVec().push_back(formalDef);
+    funcVecType.push_back(ty->GetTypeIndex());
+    funcVecAttrs.push_back(TypeAttrs());
+    if (fn->GetSymTab() != nullptr && formalDef.formalSym != nullptr) {
+      (void)fn->GetSymTab()->AddToStringSymbolMap(*formalDef.formalSym);
+    }
+  }
+  funcSymbol->SetTyIdx(GlobalTables::GetTypeTable().GetOrCreateFunctionType(
+      returnType.GetTypeIndex(), funcVecType, funcVecAttrs, isVarg)->GetTypeIndex());
+  auto *funcType = static_cast<MIRFuncType*>(funcSymbol->GetType());
+  fn->SetMIRFuncType(funcType);
+  funcSymbol->SetFunction(fn);
+  if (createBody) {
+    fn->NewBody();
+  }
+  return fn;
+}
+
+MIRFunction *MIRBuilder::CreateFunction(StIdx stIdx, bool addToTable) const {
+  auto *fn = mirModule->GetMemPool()->New<MIRFunction>(mirModule, stIdx);
+  fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
+  if (addToTable) {
+    GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
+  }
+
+  auto *funcType = mirModule->GetMemPool()->New<MIRFuncType>();
+  fn->SetMIRFuncType(funcType);
+  return fn;
+}
+
+MIRSymbol *MIRBuilder::GetOrCreateGlobalDecl(const std::string &str, TyIdx tyIdx, bool &created) const {
+  GStrIdx strIdx = GetStringIndex(str);
+  if (strIdx != 0u) {
+    StIdx stIdx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(strIdx);
+    if (stIdx.Idx() != 0) {
+      created = false;
+      return GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+    }
+  }
+  created = true;
+  strIdx = GetOrCreateStringIndex(str);
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  st->SetNameStrIdx(strIdx);
+  st->SetTyIdx(tyIdx);
+  (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*st);
+  return st;
+}
+
+MIRSymbol *MIRBuilder::GetOrCreateLocalDecl(const std::string &str, TyIdx tyIdx, MIRSymbolTable &symbolTable,
+                                            bool &created) const {
+  GStrIdx strIdx = GetStringIndex(str);
+  if (strIdx != 0u) {
+    StIdx stIdx = symbolTable.GetStIdxFromStrIdx(strIdx);
+    if (stIdx.Idx() != 0) {
+      created = false;
+      return symbolTable.GetSymbolFromStIdx(stIdx.Idx());
+    }
+  }
+  created = true;
+  strIdx = GetOrCreateStringIndex(str);
+  MIRSymbol *st = symbolTable.CreateSymbol(kScopeLocal);
+  ASSERT(st != nullptr, "null ptr check");
+  st->SetNameStrIdx(strIdx);
+  st->SetTyIdx(tyIdx);
+  (void)symbolTable.AddToStringSymbolMap(*st);
+  return st;
+}
+
+MIRSymbol *MIRBuilder::GetOrCreateDeclInFunc(const std::string &str, const MIRType &type, MIRFunction &func) const {
+  MIRSymbolTable *symbolTable = func.GetSymTab();
+  ASSERT(symbolTable != nullptr, "symbol_table is null");
+  bool isCreated = false;
+  MIRSymbol *st = GetOrCreateLocalDecl(str, type.GetTypeIndex(), *symbolTable, isCreated);
+  if (isCreated) {
+    st->SetStorageClass(kScAuto);
+    st->SetSKind(kStVar);
+  }
+  return st;
+}
+
+MIRSymbol *MIRBuilder::GetOrCreateLocalDecl(const std::string &str, const MIRType &type) {
+  MIRFunction *currentFunc = GetCurrentFunction();
+  CHECK_FATAL(currentFunc != nullptr, "null ptr check");
+  return GetOrCreateDeclInFunc(str, type, *currentFunc);
+}
+
+MIRSymbol *MIRBuilder::CreateLocalDecl(const std::string &str, const MIRType &type) const {
+  MIRFunction *currentFunctionInner = GetCurrentFunctionNotNull();
+  return MIRSymbolBuilder::Instance().CreateLocalDecl(*currentFunctionInner->GetSymTab(),
+                                                      GetOrCreateStringIndex(str), type);
+}
+
+MIRSymbol *MIRBuilder::GetGlobalDecl(const std::string &str) const {
+  return MIRSymbolBuilder::Instance().GetGlobalDecl(GetStringIndex(str));
+}
+
+MIRSymbol *MIRBuilder::GetLocalDecl(const std::string &str) const {
+  MIRFunction *currentFunctionInner = GetCurrentFunctionNotNull();
+  return MIRSymbolBuilder::Instance().GetLocalDecl(*currentFunctionInner->GetSymTab(), GetStringIndex(str));
+}
+
+// search the scope hierarchy
+MIRSymbol *MIRBuilder::GetDecl(const std::string &str) const {
+  GStrIdx strIdx = GetStringIndex(str);
+  MIRSymbol *sym = nullptr;
+  if (strIdx != 0u) {
+    // try to find the decl in local scope first
+    MIRFunction *currentFunctionInner = GetCurrentFunction();
+    if (currentFunctionInner != nullptr) {
+      sym = currentFunctionInner->GetSymTab()->GetSymbolFromStrIdx(strIdx);
+    }
+    if (sym == nullptr) {
+      sym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+    }
+  }
+  return sym;
+}
+
+MIRSymbol *MIRBuilder::CreateGlobalDecl(const std::string &str, const MIRType &type, MIRStorageClass sc) const {
+  return MIRSymbolBuilder::Instance().CreateGlobalDecl(GetOrCreateStringIndex(str), type, sc);
+}
+
+MIRSymbol *MIRBuilder::GetOrCreateGlobalDecl(const std::string &str, const MIRType &type) const {
+  bool isCreated = false;
+  MIRSymbol *st = GetOrCreateGlobalDecl(str, type.GetTypeIndex(), isCreated);
+  ASSERT(st != nullptr, "null ptr check");
+  if (isCreated) {
+    st->SetStorageClass(kScGlobal);
+    st->SetSKind(kStVar);
+  } else {
+    // Existing symbol may come from anther module. We need to register it
+    // in the current module so that per-module mpl file is self-sustained.
+    mirModule->AddSymbol(st);
+  }
+  MIRConst *cst = GlobalTables::GetConstPool().GetConstFromPool(st->GetNameStrIdx());
+  if (cst != nullptr) {
+    st->SetKonst(cst);
+  }
+  return st;
+}
+
+MIRSymbol *MIRBuilder::GetSymbolFromEnclosingScope(StIdx stIdx) const {
+  if (stIdx.FullIdx() == 0) {
+    return nullptr;
+  }
+  if (stIdx.Islocal()) {
+    MIRFunction *fun = GetCurrentFunctionNotNull();
+    MIRSymbol *st = fun->GetSymTab()->GetSymbolFromStIdx(stIdx.Idx());
+    if (st != nullptr) {
+      return st;
+    }
+  }
+  return GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+}
+
+MIRSymbol *MIRBuilder::GetSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass, MIRStorageClass sClass,
+                                 uint8 scpID, bool sameType = false) const {
+  return GetSymbol(tyIdx, GetOrCreateStringIndex(name), mClass, sClass, scpID, sameType);
+}
+
+// when sametype is true, it means match everything the of the symbol
+MIRSymbol *MIRBuilder::GetSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                                 uint8 scpID, bool sameType = false) const {
+  if (scpID != kScopeGlobal) {
+    ERR(kLncErr, "not yet implemented");
+    return nullptr;
+  }
+  return MIRSymbolBuilder::Instance().GetSymbol(tyIdx, strIdx, mClass, sClass, sameType);
+}
+
+MIRSymbol *MIRBuilder::GetOrCreateSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass,
+                                         MIRStorageClass sClass, MIRFunction *func, uint8 scpID,
+                                         bool sametype = false) const {
+  return GetOrCreateSymbol(tyIdx, GetOrCreateStringIndex(name), mClass, sClass, func, scpID, sametype);
+}
+
+MIRSymbol *MIRBuilder::GetOrCreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                                         MIRFunction *func, uint8 scpID, bool sameType = false) const {
+  if (MIRSymbol *st = GetSymbol(tyIdx, strIdx, mClass, sClass, scpID, sameType)) {
+    return st;
+  }
+  return CreateSymbol(tyIdx, strIdx, mClass, sClass, func, scpID);
+}
+
+// when func is null, create global symbol, otherwise create local symbol
+MIRSymbol *MIRBuilder::CreateSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass, MIRStorageClass sClass,
+                                    MIRFunction *func, uint8 scpID) const {
+  return CreateSymbol(tyIdx, GetOrCreateStringIndex(name), mClass, sClass, func, scpID);
+}
+
+// when func is null, create global symbol, otherwise create local symbol
+MIRSymbol *MIRBuilder::CreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                                    MIRFunction *func, uint8 scpID) const {
+  return MIRSymbolBuilder::Instance().CreateSymbol(tyIdx, strIdx, mClass, sClass, func, scpID);
+}
+
+MIRSymbol *MIRBuilder::CreateConstStringSymbol(const std::string &symbolName, const std::string &content) {
+  auto elemPrimType = PTY_u8;
+  MIRType *type = GlobalTables::GetTypeTable().GetPrimType(elemPrimType);
+  uint32 sizeIn = static_cast<uint32>(content.length());
+  MIRType *arrayTypeWithSize = GlobalTables::GetTypeTable().GetOrCreateArrayType(
+      *GlobalTables::GetTypeTable().GetPrimType(elemPrimType), 1, &sizeIn);
+
+  if (GetLocalDecl(symbolName)) {
+    return GetLocalDecl(symbolName);
+  }
+  MIRSymbol *arrayVar = GetOrCreateGlobalDecl(symbolName, *arrayTypeWithSize);
+  arrayVar->SetAttr(ATTR_readonly);
+  arrayVar->SetStorageClass(kScFstatic);
+  MIRAggConst *val = mirModule->GetMemPool()->New<MIRAggConst>(*mirModule, *arrayTypeWithSize);
+  for (uint32 i = 0; i < sizeIn; ++i) {
+    MIRConst *cst = mirModule->GetMemPool()->New<MIRIntConst>(content[i], *type);
+    val->PushBack(cst);
+  }
+  // This interface is only for string literal, 0 is added to the end of the string.
+  MIRConst *cst0 = mirModule->GetMemPool()->New<MIRIntConst>(0, *type);
+  val->PushBack(cst0);
+  arrayVar->SetKonst(val);
+  return arrayVar;
+}
+
+MIRSymbol *MIRBuilder::CreatePregFormalSymbol(TyIdx tyIdx, PregIdx pRegIdx, MIRFunction &func) const {
+  return MIRSymbolBuilder::Instance().CreatePregFormalSymbol(tyIdx, pRegIdx, func);
+}
+
+ConstvalNode *MIRBuilder::CreateConstval(MIRConst *mirConst) {
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(mirConst->GetType().GetPrimType(), mirConst);
+}
+
+ConstvalNode *MIRBuilder::CreateIntConst(uint64 val, PrimType pty) {
+  auto *mirConst =
+      GlobalTables::GetIntConstTable().GetOrCreateIntConst(val, *GlobalTables::GetTypeTable().GetPrimType(pty));
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(pty, mirConst);
+}
+
+ConstvalNode *MIRBuilder::CreateFloatConst(float val) {
+  auto *mirConst = GetCurrentFuncDataMp()->New<MIRFloatConst>(
+      val, *GlobalTables::GetTypeTable().GetPrimType(PTY_f32));
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_f32, mirConst);
+}
+
+ConstvalNode *MIRBuilder::CreateDoubleConst(double val) {
+  auto *mirConst = GetCurrentFuncDataMp()->New<MIRDoubleConst>(
+      val, *GlobalTables::GetTypeTable().GetPrimType(PTY_f64));
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_f64, mirConst);
+}
+
+ConstvalNode *MIRBuilder::CreateFloat128Const(const uint64 *val) {
+  auto *mirConst = GetCurrentFuncDataMp()->New<MIRFloat128Const>(
+      *val, *GlobalTables::GetTypeTable().GetPrimType(PTY_f128));
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_f128, mirConst);
+}
+
+ConstvalNode *MIRBuilder::GetConstInt(MemPool &memPool, int val) const {
+  auto *mirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+      static_cast<uint64_t>(val), *GlobalTables::GetTypeTable().GetInt64());
+  return memPool.New<ConstvalNode>(PTY_i32, mirConst);
+}
+
+ConstvalNode *MIRBuilder::CreateAddrofConst(BaseNode &node) {
+  ASSERT(node.GetOpCode() == OP_addrof, "illegal op for addrof const");
+  MIRFunction *currentFunctionInner = GetCurrentFunctionNotNull();
+
+  // determine the type of 'node' and create a pointer type, accordingly
+  auto &aNode = static_cast<AddrofNode&>(node);
+  const MIRSymbol *var = currentFunctionInner->GetLocalOrGlobalSymbol(aNode.GetStIdx());
+  TyIdx ptyIdx = var->GetTyIdx();
+  MIRPtrType ptrType(ptyIdx);
+  ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+  MIRType &exprType = *GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
+  auto *temp = mirModule->GetMemPool()->New<MIRAddrofConst>(aNode.GetStIdx(), aNode.GetFieldID(), exprType);
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_ptr, temp);
+}
+
+ConstvalNode *MIRBuilder::CreateAddroffuncConst(const BaseNode &node) {
+  ASSERT(node.GetOpCode() == OP_addroffunc, "illegal op for addroffunc const");
+
+  const auto &aNode = static_cast<const AddroffuncNode&>(node);
+  MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(aNode.GetPUIdx());
+  TyIdx ptyIdx = f->GetFuncSymbol()->GetTyIdx();
+  MIRPtrType ptrType(ptyIdx);
+  ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+  MIRType *exprType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
+  auto *mirConst = mirModule->GetMemPool()->New<MIRAddroffuncConst>(aNode.GetPUIdx(), *exprType);
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_ptr, mirConst);
+}
+
+ConstvalNode *MIRBuilder::CreateStrConst(const BaseNode &node) {
+  ASSERT(node.GetOpCode() == OP_conststr, "illegal op for conststr const");
+  UStrIdx strIdx = static_cast<const ConststrNode&>(node).GetStrIdx();
+  CHECK_FATAL(PTY_u8 < GlobalTables::GetTypeTable().GetTypeTable().size(),
+              "index is out of range in MIRBuilder::CreateStrConst");
+  TyIdx tyIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_u8))->GetTypeIndex();
+  MIRPtrType ptrType(tyIdx);
+  tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+  MIRType *exprType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  auto *mirConst = mirModule->GetMemPool()->New<MIRStrConst>(strIdx, *exprType);
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_ptr, mirConst);
+}
+
+ConstvalNode *MIRBuilder::CreateStr16Const(const BaseNode &node) {
+  ASSERT(node.GetOpCode() == OP_conststr16, "illegal op for conststr16 const");
+  U16StrIdx strIdx = static_cast<const Conststr16Node&>(node).GetStrIdx();
+  CHECK_FATAL(PTY_u16 < GlobalTables::GetTypeTable().GetTypeTable().size(),
+              "index out of range in MIRBuilder::CreateStr16Const");
+  TyIdx ptyIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_u16))->GetTypeIndex();
+  MIRPtrType ptrType(ptyIdx);
+  ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+  MIRType *exprType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
+  auto *mirConst = mirModule->GetMemPool()->New<MIRStr16Const>(strIdx, *exprType);
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_ptr, mirConst);
+}
+
+SizeoftypeNode *MIRBuilder::CreateExprSizeoftype(const MIRType &type) {
+  return GetCurrentFuncCodeMp()->New<SizeoftypeNode>(PTY_u32, type.GetTypeIndex());
+}
+
+FieldsDistNode *MIRBuilder::CreateExprFieldsDist(const MIRType &type, FieldID field1, FieldID field2) {
+  return GetCurrentFuncCodeMp()->New<FieldsDistNode>(PTY_i32, type.GetTypeIndex(), field1, field2);
+}
+
+AddrofNode *MIRBuilder::CreateExprAddrof(FieldID fieldID, const MIRSymbol &symbol, MemPool *memPool) {
+  return CreateExprAddrof(fieldID, symbol.GetStIdx(), memPool);
+}
+
+AddrofNode *MIRBuilder::CreateExprAddrof(FieldID fieldID, StIdx symbolStIdx, MemPool *memPool) {
+  if (memPool == nullptr) {
+    memPool = GetCurrentFuncCodeMp();
+  }
+  return memPool->New<AddrofNode>(OP_addrof, PTY_ptr, symbolStIdx, fieldID);
+}
+
+AddroffuncNode *MIRBuilder::CreateExprAddroffunc(PUIdx puIdx, MemPool *memPool) {
+  if (memPool == nullptr) {
+    memPool = GetCurrentFuncCodeMp();
+  }
+  return memPool->New<AddroffuncNode>(PTY_ptr, puIdx);
+}
+
+AddrofNode *MIRBuilder::CreateExprDread(const MIRType &type, FieldID fieldID, const MIRSymbol &symbol) {
+  return CreateExprDread(type.GetPrimType(), fieldID, symbol);
+}
+
+AddrofNode *MIRBuilder::CreateExprDread(PrimType ptyp, FieldID fieldID, const MIRSymbol &symbol) {
+  auto *node = GetCurrentFuncCodeMp()->New<AddrofNode>(OP_dread, kPtyInvalid, symbol.GetStIdx(), fieldID);
+  node->SetPrimType(GetRegPrimType(ptyp));
+  return node;
+}
+
+RegreadNode *MIRBuilder::CreateExprRegread(PrimType pty, PregIdx regIdx) {
+  return GetCurrentFuncCodeMp()->New<RegreadNode>(pty, regIdx);
+}
+
+AddrofNode *MIRBuilder::CreateExprDread(MIRType &type, MIRSymbol &symbol) {
+  return CreateExprDread(type, 0, symbol);
+}
+
+AddrofNode *MIRBuilder::CreateExprDread(MIRSymbol &symbol, uint16 fieldID) {
+  if (fieldID == 0) {
+    return CreateExprDread(symbol);
+  }
+  ASSERT(false, "NYI");
+  return nullptr;
+}
+
+AddrofNode *MIRBuilder::CreateExprDread(MIRSymbol &symbol) {
+  return CreateExprDread(*symbol.GetType(), 0, symbol);
+}
+
+AddrofNode *MIRBuilder::CreateExprDread(PregIdx pregID, PrimType pty) {
+  auto *dread = GetCurrentFuncCodeMp()->New<AddrofNode>(OP_dread, pty);
+  dread->SetStFullIdx(pregID);
+  return dread;
+}
+
+DreadoffNode *MIRBuilder::CreateExprDreadoff(Opcode op, PrimType pty, const MIRSymbol &symbol, int32 offset) {
+  DreadoffNode *node = GetCurrentFuncCodeMp()->New<DreadoffNode>(op, pty);
+  node->stIdx = symbol.GetStIdx();
+  node->offset = offset;
+  return node;
+}
+
+IreadNode *MIRBuilder::CreateExprIread(PrimType primType, TyIdx ptrTypeIdx, FieldID fieldID, BaseNode *addr) {
+  return GetCurrentFuncCodeMp()->New<IreadNode>(OP_iread, GetRegPrimType(primType), ptrTypeIdx, fieldID, addr);
+}
+
+IreadNode *MIRBuilder::CreateExprIread(const MIRType &returnType, const MIRType &ptrType, FieldID fieldID,
+                                       BaseNode *addr) {
+  TyIdx returnTypeIdx = returnType.GetTypeIndex();
+  CHECK(returnTypeIdx < GlobalTables::GetTypeTable().GetTypeTable().size(),
+        "index out of range in MIRBuilder::CreateExprIread");
+  ASSERT(fieldID != 0 || ptrType.GetPrimType() != PTY_agg,
+         "Error: Fieldid should not be 0 when trying to iread a field from type ");
+  return CreateExprIread(returnType.GetPrimType(), ptrType.GetTypeIndex(), fieldID, addr);
+}
+
+IreadoffNode *MIRBuilder::CreateExprIreadoff(PrimType pty, int32 offset, BaseNode *opnd0) {
+  return GetCurrentFuncCodeMp()->New<IreadoffNode>(pty, opnd0, offset);
+}
+
+IreadFPoffNode *MIRBuilder::CreateExprIreadFPoff(PrimType pty, int32 offset) {
+  return GetCurrentFuncCodeMp()->New<IreadFPoffNode>(pty, offset);
+}
+
+IaddrofNode *MIRBuilder::CreateExprIaddrof(const MIRType &returnType, const MIRType &ptrType, FieldID fieldID,
+                                           BaseNode *addr) {
+  IaddrofNode *iAddrOfNode = CreateExprIread(returnType, ptrType, fieldID, addr);
+  iAddrOfNode->SetOpCode(OP_iaddrof);
+  return iAddrOfNode;
+}
+
+IaddrofNode *MIRBuilder::CreateExprIaddrof(PrimType returnTypePty, TyIdx ptrTypeIdx, FieldID fieldID, BaseNode *addr) {
+  return GetCurrentFuncCodeMp()->New<IreadNode>(OP_iaddrof, returnTypePty, ptrTypeIdx, fieldID, addr);
+}
+
+UnaryNode *MIRBuilder::CreateExprUnary(Opcode opcode, const MIRType &type, BaseNode *opnd) {
+  return GetCurrentFuncCodeMp()->New<UnaryNode>(opcode, type.GetPrimType(), opnd);
+}
+
+GCMallocNode *MIRBuilder::CreateExprGCMalloc(Opcode opcode, const MIRType &pType, const MIRType &type) {
+  return GetCurrentFuncCodeMp()->New<GCMallocNode>(opcode, pType.GetPrimType(), type.GetTypeIndex());
+}
+
+JarrayMallocNode *MIRBuilder::CreateExprJarrayMalloc(Opcode opcode, const MIRType &pType, const MIRType &type,
+                                                     BaseNode *opnd) {
+  return GetCurrentFuncCodeMp()->New<JarrayMallocNode>(opcode, pType.GetPrimType(), type.GetTypeIndex(), opnd);
+}
+
+TypeCvtNode *MIRBuilder::CreateExprTypeCvt(Opcode o, PrimType  toPrimType, PrimType fromPrimType, BaseNode &opnd) {
+  return GetCurrentFuncCodeMp()->New<TypeCvtNode>(o, toPrimType, fromPrimType, &opnd);
+}
+
+TypeCvtNode *MIRBuilder::CreateExprTypeCvt(Opcode o, const MIRType &type, const MIRType &fromType, BaseNode *opnd) {
+  return CreateExprTypeCvt(o, type.GetPrimType(), fromType.GetPrimType(), *opnd);
+}
+
+ExtractbitsNode *MIRBuilder::CreateExprExtractbits(Opcode o, const MIRType &type, uint32 bOffset, uint32 bSize,
+                                                   BaseNode *opnd) {
+  return CreateExprExtractbits(o, type.GetPrimType(), bOffset, bSize, opnd);
+}
+
+ExtractbitsNode *MIRBuilder::CreateExprExtractbits(Opcode o, PrimType type, uint32 bOffset, uint32 bSize,
+                                                   BaseNode *opnd) {
+  return GetCurrentFuncCodeMp()->New<ExtractbitsNode>(o, type, bOffset, bSize, opnd);
+}
+
+DepositbitsNode *MIRBuilder::CreateExprDepositbits(Opcode o, PrimType type, uint32 bOffset, uint32 bSize,
+                                                   BaseNode *leftOpnd, BaseNode* rightOpnd) {
+  return GetCurrentFuncCodeMp()->New<DepositbitsNode>(o, type, bOffset, bSize, leftOpnd, rightOpnd);
+}
+
+RetypeNode *MIRBuilder::CreateExprRetype(const MIRType &type, const MIRType &fromType, BaseNode *opnd) {
+  return CreateExprRetype(type, fromType.GetPrimType(), opnd);
+}
+
+RetypeNode *MIRBuilder::CreateExprRetype(const MIRType &type, PrimType fromType, BaseNode *opnd) {
+  return GetCurrentFuncCodeMp()->New<RetypeNode>(type.GetPrimType(), fromType, type.GetTypeIndex(), opnd);
+}
+
+BinaryNode *MIRBuilder::CreateExprBinary(Opcode opcode, const MIRType &type, BaseNode *opnd0, BaseNode *opnd1) {
+  return GetCurrentFuncCodeMp()->New<BinaryNode>(opcode, type.GetPrimType(), opnd0, opnd1);
+}
+
+TernaryNode *MIRBuilder::CreateExprTernary(Opcode opcode, const MIRType &type, BaseNode *opnd0, BaseNode *opnd1,
+                                           BaseNode *opnd2) {
+  return GetCurrentFuncCodeMp()->New<TernaryNode>(opcode, type.GetPrimType(), opnd0, opnd1, opnd2);
+}
+
+CompareNode *MIRBuilder::CreateExprCompare(Opcode opcode, const MIRType &type, const MIRType &opndType, BaseNode *opnd0,
+                                           BaseNode *opnd1) {
+  return GetCurrentFuncCodeMp()->New<CompareNode>(opcode, type.GetPrimType(), opndType.GetPrimType(), opnd0, opnd1);
+}
+
+ArrayNode *MIRBuilder::CreateExprArray(const MIRType &arrayType) {
+  MIRType *addrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(arrayType);
+  ASSERT(addrType != nullptr, "addrType is null");
+  auto *arrayNode = GetCurrentFuncCodeMp()->New<ArrayNode>(*GetCurrentFuncCodeMpAllocator(),
+                                                           addrType->GetPrimType(), addrType->GetTypeIndex());
+  arrayNode->SetNumOpnds(0);
+  return arrayNode;
+}
+
+ArrayNode *MIRBuilder::CreateExprArray(const MIRType &arrayType, BaseNode *op) {
+  ArrayNode *arrayNode = CreateExprArray(arrayType);
+  arrayNode->GetNopnd().push_back(op);
+  arrayNode->SetNumOpnds(1);
+  return arrayNode;
+}
+
+ArrayNode *MIRBuilder::CreateExprArray(const MIRType &arrayType, BaseNode *op1, BaseNode *op2) {
+  ArrayNode *arrayNode = CreateExprArray(arrayType, op1);
+  arrayNode->GetNopnd().push_back(op2);
+  arrayNode->SetNumOpnds(2);
+  return arrayNode;
+}
+
+ArrayNode *MIRBuilder::CreateExprArray(const MIRType &arrayType, std::vector<BaseNode *> ops) {
+  MIRType *addrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(arrayType);
+  ASSERT(addrType != nullptr, "addrType is null");
+  auto *arrayNode = GetCurrentFuncCodeMp()->New<ArrayNode>(*GetCurrentFuncCodeMpAllocator(),
+                                                           addrType->GetPrimType(), addrType->GetTypeIndex());
+  arrayNode->GetNopnd().insert(arrayNode->GetNopnd().begin(), ops.begin(), ops.end());
+  arrayNode->SetNumOpnds(static_cast<uint8>(ops.size()));
+  return arrayNode;
+}
+
+IntrinsicopNode *MIRBuilder::CreateExprIntrinsicop(MIRIntrinsicID id, Opcode op, PrimType primType, const TyIdx &tyIdx,
+                                                   const MapleVector<BaseNode*> &ops) {
+  auto *expr = GetCurrentFuncCodeMp()->New<IntrinsicopNode>(*GetCurrentFuncCodeMpAllocator(), op, primType);
+  expr->SetIntrinsic(id);
+  expr->SetNOpnd(ops);
+  expr->SetNumOpnds(ops.size());
+  if (op == OP_intrinsicopwithtype) {
+    expr->SetTyIdx(tyIdx);
+  }
+  return expr;
+}
+
+IntrinsicopNode *MIRBuilder::CreateExprIntrinsicop(MIRIntrinsicID idx, Opcode opCode, const MIRType &type,
+                                                   const MapleVector<BaseNode*> &ops) {
+  return CreateExprIntrinsicop(idx, opCode, type.GetPrimType(), type.GetTypeIndex(), ops);
+}
+
+DassignNode *MIRBuilder::CreateStmtDassign(const MIRSymbol &symbol, FieldID fieldID, BaseNode *src) {
+  return GetCurrentFuncCodeMp()->New<DassignNode>(src, symbol.GetStIdx(), fieldID);
+}
+
+RegassignNode *MIRBuilder::CreateStmtRegassign(PrimType pty, PregIdx regIdx, BaseNode *src) {
+  return GetCurrentFuncCodeMp()->New<RegassignNode>(pty, regIdx, src);
+}
+
+DassignNode *MIRBuilder::CreateStmtDassign(StIdx sIdx, FieldID fieldID, BaseNode *src) {
+  return GetCurrentFuncCodeMp()->New<DassignNode>(src, sIdx, fieldID);
+}
+
+IassignNode *MIRBuilder::CreateStmtIassign(const MIRType &type, FieldID fieldID, BaseNode *addr, BaseNode *src) {
+  return GetCurrentFuncCodeMp()->New<IassignNode>(type.GetTypeIndex(), fieldID, addr, src);
+}
+
+IassignoffNode *MIRBuilder::CreateStmtIassignoff(PrimType pty, int32 offset, BaseNode *addr, BaseNode *src) {
+  return GetCurrentFuncCodeMp()->New<IassignoffNode>(pty, offset, addr, src);
+}
+
+IassignFPoffNode *MIRBuilder::CreateStmtIassignFPoff(Opcode op, PrimType pty,
+                                                     int32 offset, BaseNode *src) {
+  return GetCurrentFuncCodeMp()->New<IassignFPoffNode>(op, pty, offset, src);
+}
+
+CallNode *MIRBuilder::CreateStmtCall(PUIdx puIdx, const MapleVector<BaseNode*> &args, Opcode opCode) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<CallNode>(*GetCurrentFuncCodeMpAllocator(), opCode, puIdx, TyIdx());
+  stmt->SetNOpnd(args);
+  stmt->SetNumOpnds(args.size());
+  return stmt;
+}
+
+CallNode *MIRBuilder::CreateStmtCall(const std::string &callee, const MapleVector<BaseNode*> &args) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(callee);
+  StIdx stIdx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(strIdx);
+  MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+  ASSERT(st != nullptr, "MIRSymbol st is null");
+  MIRFunction *func = st->GetFunction();
+  return CreateStmtCall(func->GetPuidx(), args, OP_call);
+}
+
+IcallNode *MIRBuilder::CreateStmtIcall(const MapleVector<BaseNode*> &args) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<IcallNode>(*GetCurrentFuncCodeMpAllocator(), OP_icall);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
+  return stmt;
+}
+
+IcallNode *MIRBuilder::CreateStmtIcallproto(const MapleVector<BaseNode*> &args, const TyIdx &prototypeIdx) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<IcallNode>(*GetCurrentFuncCodeMpAllocator(), OP_icallproto);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
+  stmt->SetRetTyIdx(prototypeIdx);
+  return stmt;
+}
+
+IcallNode *MIRBuilder::CreateStmtIcallAssigned(const MapleVector<BaseNode*> &args, const MIRSymbol &ret) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<IcallNode>(*GetCurrentFuncCodeMpAllocator(), OP_icallassigned);
+  CallReturnVector nrets(GetCurrentFuncCodeMpAllocator()->Adapter());
+  CHECK_FATAL((ret.GetStorageClass() == kScAuto || ret.GetStorageClass() == kScFormal ||
+               ret.GetStorageClass() == kScExtern || ret.GetStorageClass() == kScGlobal),
+              "unknown classtype! check it!");
+  nrets.emplace_back(CallReturnPair(ret.GetStIdx(), RegFieldPair(0, 0)));
+  stmt->SetNumOpnds(args.size());
+  stmt->GetNopnd().resize(stmt->GetNumOpnds());
+  stmt->SetReturnVec(nrets);
+  for (size_t i = 0; i < stmt->GetNopndSize(); ++i) {
+    stmt->SetNOpndAt(i, args.at(i));
+  }
+  stmt->SetRetTyIdx(ret.GetTyIdx());
+  return stmt;
+}
+
+IcallNode *MIRBuilder::CreateStmtIcallprotoAssigned(const MapleVector<BaseNode*> &args, const MIRSymbol &ret,
+                                                    const TyIdx &prototypeIdx) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<IcallNode>(*GetCurrentFuncCodeMpAllocator(), OP_icallprotoassigned);
+  CallReturnVector nrets(GetCurrentFuncCodeMpAllocator()->Adapter());
+  CHECK_FATAL((ret.GetStorageClass() == kScAuto || ret.GetStorageClass() == kScFormal ||
+               ret.GetStorageClass() == kScExtern || ret.GetStorageClass() == kScGlobal),
+              "unknown classtype! check it!");
+  nrets.emplace_back(CallReturnPair(ret.GetStIdx(), RegFieldPair(0, 0)));
+  stmt->SetNumOpnds(args.size());
+  stmt->GetNopnd().resize(stmt->GetNumOpnds());
+  stmt->SetReturnVec(nrets);
+  for (size_t i = 0; i < stmt->GetNopndSize(); ++i) {
+    stmt->SetNOpndAt(i, args.at(i));
+  }
+  stmt->SetRetTyIdx(prototypeIdx);
+  return stmt;
+}
+
+IntrinsiccallNode *MIRBuilder::CreateStmtIntrinsicCall(MIRIntrinsicID idx, const MapleVector<BaseNode*> &arguments,
+                                                       TyIdx tyIdx) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(
+      *GetCurrentFuncCodeMpAllocator(), tyIdx == 0u ? OP_intrinsiccall : OP_intrinsiccallwithtype, idx);
+  stmt->SetTyIdx(tyIdx);
+  stmt->SetOpnds(arguments);
+  return stmt;
+}
+
+IntrinsiccallNode *MIRBuilder::CreateStmtXintrinsicCall(MIRIntrinsicID idx, const MapleVector<BaseNode*> &arguments) {
+  auto *stmt =
+      GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(*GetCurrentFuncCodeMpAllocator(), OP_xintrinsiccall, idx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(arguments);
+  return stmt;
+}
+
+CallNode *MIRBuilder::CreateStmtCallAssigned(PUIdx puIdx, const MIRSymbol *ret, Opcode op) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<CallNode>(*GetCurrentFuncCodeMpAllocator(), op, puIdx);
+  if (ret) {
+    ASSERT(ret->IsLocal(), "Not Excepted ret");
+    stmt->GetReturnVec().push_back(CallReturnPair(ret->GetStIdx(), RegFieldPair(0, 0)));
+  }
+  return stmt;
+}
+
+CallNode *MIRBuilder::CreateStmtCallAssigned(PUIdx puIdx, const MapleVector<BaseNode*> &args, const MIRSymbol *ret,
+                                             Opcode opcode, TyIdx tyIdx) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<CallNode>(*GetCurrentFuncCodeMpAllocator(), opcode, puIdx, tyIdx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
+  if (ret != nullptr) {
+    ASSERT(ret->IsLocal(), "Not Excepted ret");
+    stmt->GetReturnVec().push_back(CallReturnPair(ret->GetStIdx(), RegFieldPair(0, 0)));
+  }
+  return stmt;
+}
+
+CallNode *MIRBuilder::CreateStmtCallRegassigned(PUIdx puIdx, PregIdx pRegIdx, Opcode opcode, BaseNode *arg) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<CallNode>(*GetCurrentFuncCodeMpAllocator(), opcode, puIdx);
+  stmt->GetNopnd().push_back(arg);
+  stmt->SetNumOpnds(stmt->GetNopndSize());
+  if (pRegIdx > 0) {
+    stmt->GetReturnVec().push_back(CallReturnPair(StIdx(), RegFieldPair(0, pRegIdx)));
+  }
+  return stmt;
+}
+
+CallNode *MIRBuilder::CreateStmtCallRegassigned(PUIdx puIdx, const MapleVector<BaseNode*> &args, PregIdx pRegIdx,
+                                                Opcode opcode) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<CallNode>(*GetCurrentFuncCodeMpAllocator(), opcode, puIdx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
+  if (pRegIdx > 0) {
+    stmt->GetReturnVec().push_back(CallReturnPair(StIdx(), RegFieldPair(0, pRegIdx)));
+  }
+  return stmt;
+}
+
+IntrinsiccallNode *MIRBuilder::CreateStmtIntrinsicCallAssigned(MIRIntrinsicID idx, const MapleVector<BaseNode*> &args,
+                                                               PregIdx retPregIdx) {
+  auto *stmt =
+      GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(*GetCurrentFuncCodeMpAllocator(), OP_intrinsiccallassigned, idx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
+  if (retPregIdx > 0) {
+    stmt->GetReturnVec().push_back(CallReturnPair(StIdx(), RegFieldPair(0, retPregIdx)));
+  }
+  return stmt;
+}
+
+IntrinsiccallNode *MIRBuilder::CreateStmtIntrinsicCallAssigned(MIRIntrinsicID idx, const MapleVector<BaseNode*> &args,
+                                                               const MIRSymbol *ret, TyIdx tyIdx) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(
+      *GetCurrentFuncCodeMpAllocator(), tyIdx == 0u ? OP_intrinsiccallassigned : OP_intrinsiccallwithtypeassigned, idx);
+  stmt->SetTyIdx(tyIdx);
+  stmt->SetOpnds(args);
+  CallReturnVector nrets(GetCurrentFuncCodeMpAllocator()->Adapter());
+  if (ret != nullptr) {
+    ASSERT(ret->IsLocal(), "Not Excepted ret");
+    nrets.push_back(CallReturnPair(ret->GetStIdx(), RegFieldPair(0, 0)));
+  }
+  stmt->SetReturnVec(nrets);
+  return stmt;
+}
+
+IntrinsiccallNode *MIRBuilder::CreateStmtXintrinsicCallAssigned(MIRIntrinsicID idx, const MapleVector<BaseNode*> &args,
+                                                                const MIRSymbol *ret) {
+  auto *stmt =
+      GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(*GetCurrentFuncCodeMpAllocator(), OP_xintrinsiccallassigned, idx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
+  CallReturnVector nrets(GetCurrentFuncCodeMpAllocator()->Adapter());
+  if (ret != nullptr) {
+    ASSERT(ret->IsLocal(), "Not Excepted ret");
+    nrets.push_back(CallReturnPair(ret->GetStIdx(), RegFieldPair(0, 0)));
+  }
+  stmt->SetReturnVec(nrets);
+  return stmt;
+}
+
+NaryStmtNode *MIRBuilder::CreateStmtReturn(BaseNode *rVal) {
+  return CreateStmtNary(OP_return, rVal);
+}
+
+NaryStmtNode *MIRBuilder::CreateStmtNary(Opcode op, const MapleVector<BaseNode*> &rVals) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<NaryStmtNode>(*GetCurrentFuncCodeMpAllocator(), op);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(rVals);
+  return stmt;
+}
+
+CallAssertBoundaryStmtNode *MIRBuilder::CreateStmtCallAssertBoundary(Opcode op, const MapleVector<BaseNode*> &rVals,
+                                                                     GStrIdx funcNameIdx, size_t paramIndex,
+                                                                     GStrIdx stmtFuncNameIdx) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<CallAssertBoundaryStmtNode>(*GetCurrentFuncCodeMpAllocator(), op,
+                                                                       funcNameIdx, paramIndex, stmtFuncNameIdx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(rVals);
+  return stmt;
+}
+
+NaryStmtNode *MIRBuilder::CreateStmtNary(Opcode op, BaseNode *rVal) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<NaryStmtNode>(*GetCurrentFuncCodeMpAllocator(), op);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->PushOpnd(rVal);
+  return stmt;
+}
+
+AssertNonnullStmtNode *MIRBuilder::CreateStmtAssertNonnull(Opcode op, BaseNode* rVal, GStrIdx funcNameIdx) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<AssertNonnullStmtNode>(op, funcNameIdx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetRHS(rVal);
+  return stmt;
+}
+
+AssertBoundaryStmtNode *MIRBuilder::CreateStmtAssertBoundary(Opcode op, const MapleVector<BaseNode*> &rVals,
+                                                             GStrIdx funcNameIdx) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<AssertBoundaryStmtNode>(*GetCurrentFuncCodeMpAllocator(), op, funcNameIdx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(rVals);
+  return stmt;
+}
+
+CallAssertNonnullStmtNode *MIRBuilder::CreateStmtCallAssertNonnull(Opcode op, BaseNode* rVal, GStrIdx callFuncNameIdx,
+                                                                   size_t paramIndex, GStrIdx stmtFuncNameIdx) {
+  auto *stmt = GetCurrentFuncCodeMp()->New<CallAssertNonnullStmtNode>(op, callFuncNameIdx, paramIndex, stmtFuncNameIdx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetRHS(rVal);
+  return stmt;
+}
+
+UnaryStmtNode *MIRBuilder::CreateStmtUnary(Opcode op, BaseNode *rVal) {
+  return GetCurrentFuncCodeMp()->New<UnaryStmtNode>(op, kPtyInvalid, rVal);
+}
+
+UnaryStmtNode *MIRBuilder::CreateStmtThrow(BaseNode *rVal) {
+  return CreateStmtUnary(OP_throw, rVal);
+}
+
+IfStmtNode *MIRBuilder::CreateStmtIf(BaseNode *cond) {
+  auto *ifStmt = GetCurrentFuncCodeMp()->New<IfStmtNode>();
+  ifStmt->SetOpnd(cond, 0);
+  BlockNode *thenBlock = GetCurrentFuncCodeMp()->New<BlockNode>();
+  ifStmt->SetThenPart(thenBlock);
+  return ifStmt;
+}
+
+IfStmtNode *MIRBuilder::CreateStmtIfThenElse(BaseNode *cond) {
+  auto *ifStmt = GetCurrentFuncCodeMp()->New<IfStmtNode>();
+  ifStmt->SetOpnd(cond, 0);
+  auto *thenBlock = GetCurrentFuncCodeMp()->New<BlockNode>();
+  ifStmt->SetThenPart(thenBlock);
+  auto *elseBlock = GetCurrentFuncCodeMp()->New<BlockNode>();
+  ifStmt->SetElsePart(elseBlock);
+  ifStmt->SetNumOpnds(3);
+  return ifStmt;
+}
+
+DoloopNode *MIRBuilder::CreateStmtDoloop(StIdx doVarStIdx, bool isPReg, BaseNode *startExp, BaseNode *contExp,
+                                         BaseNode *incrExp) {
+  return GetCurrentFuncCodeMp()->New<DoloopNode>(doVarStIdx, isPReg, startExp, contExp, incrExp,
+                                                 GetCurrentFuncCodeMp()->New<BlockNode>());
+}
+
+SwitchNode *MIRBuilder::CreateStmtSwitch(BaseNode *opnd, LabelIdx defaultLabel, const CaseVector &switchTable) {
+  auto *switchNode = GetCurrentFuncCodeMp()->New<SwitchNode>(*GetCurrentFuncCodeMpAllocator(),
+                                                             defaultLabel, opnd);
+  switchNode->SetSwitchTable(switchTable);
+  return switchNode;
+}
+
+GotoNode *MIRBuilder::CreateStmtGoto(Opcode o, LabelIdx labIdx) {
+  return GetCurrentFuncCodeMp()->New<GotoNode>(o, labIdx);
+}
+
+JsTryNode *MIRBuilder::CreateStmtJsTry(LabelIdx cLabIdx, LabelIdx fLabIdx) {
+  return GetCurrentFuncCodeMp()->New<JsTryNode>(static_cast<uint16>(cLabIdx), static_cast<uint16>(fLabIdx));
+}
+
+TryNode *MIRBuilder::CreateStmtTry(const MapleVector<LabelIdx> &cLabIdxs) {
+  return GetCurrentFuncCodeMp()->New<TryNode>(cLabIdxs);
+}
+
+CatchNode *MIRBuilder::CreateStmtCatch(const MapleVector<TyIdx> &tyIdxVec) {
+  return GetCurrentFuncCodeMp()->New<CatchNode>(tyIdxVec);
+}
+
+LabelNode *MIRBuilder::CreateStmtLabel(LabelIdx labIdx) {
+  return GetCurrentFuncCodeMp()->New<LabelNode>(labIdx);
+}
+
+StmtNode *MIRBuilder::CreateStmtComment(const std::string &cmnt) {
+  return GetCurrentFuncCodeMp()->New<CommentNode>(*GetCurrentFuncCodeMpAllocator(), cmnt);
+}
+
+AddrofNode *MIRBuilder::CreateAddrof(const MIRSymbol &st, PrimType pty) {
+  return GetCurrentFuncCodeMp()->New<AddrofNode>(OP_addrof, pty, st.GetStIdx(), 0);
+}
+
+AddrofNode *MIRBuilder::CreateDread(const MIRSymbol &st, PrimType pty) {
+  return GetCurrentFuncCodeMp()->New<AddrofNode>(OP_dread, pty, st.GetStIdx(), 0);
+}
+
+CondGotoNode *MIRBuilder::CreateStmtCondGoto(BaseNode *cond, Opcode op, LabelIdx labIdx) {
+  return GetCurrentFuncCodeMp()->New<CondGotoNode>(op, labIdx, cond);
+}
+
+LabelIdx MIRBuilder::GetOrCreateMIRLabel(const std::string &name) const {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  MIRFunction *currentFunctionInner = GetCurrentFunctionNotNull();
+  LabelIdx lableIdx = currentFunctionInner->GetLabelTab()->GetLabelIdxFromStrIdx(strIdx);
+  if (lableIdx == 0) {
+    lableIdx = currentFunctionInner->GetLabelTab()->CreateLabel();
+    currentFunctionInner->GetLabelTab()->SetSymbolFromStIdx(lableIdx, strIdx);
+    currentFunctionInner->GetLabelTab()->AddToStringLabelMap(lableIdx);
+  }
+  return lableIdx;
+}
+
+LabelIdx MIRBuilder::CreateLabIdx(MIRFunction &mirFunc) const {
+  LabelIdx lableIdx = mirFunc.GetLabelTab()->CreateLabel();
+  mirFunc.GetLabelTab()->AddToStringLabelMap(lableIdx);
+  return lableIdx;
+}
+
+void MIRBuilder::AddStmtInCurrentFunctionBody(StmtNode &stmt) const {
+  MIRFunction *fun = GetCurrentFunctionNotNull();
+  stmt.GetSrcPos().CondSetLineNum(lineNum);
+  fun->GetBody()->AddStatement(&stmt);
+}
+
+MemPool *MIRBuilder::GetCurrentFuncCodeMp() {
+  if (MIRFunction *curFunction = GetCurrentFunction()) {
+    return curFunction->GetCodeMemPool();
+  }
+  return mirModule->GetMemPool();
+}
+
+MapleAllocator *MIRBuilder::GetCurrentFuncCodeMpAllocator() {
+  if (MIRFunction *curFunction = GetCurrentFunction()) {
+    return &curFunction->GetCodeMPAllocator();
+  }
+  return &mirModule->GetMPAllocator();
+}
+
+MemPool *MIRBuilder::GetCurrentFuncDataMp() {
+  if (MIRFunction *curFunction = GetCurrentFunction()) {
+    return curFunction->GetDataMemPool();
+  }
+  return mirModule->GetMemPool();
+}
+
+MIRBuilderExt::MIRBuilderExt(MIRModule *module, pthread_mutex_t *mutex) : MIRBuilder(module), mutex(mutex) {}
+
+MemPool *MIRBuilderExt::GetCurrentFuncCodeMp() {
+  ASSERT(curFunction, "curFunction is null");
+  return curFunction->GetCodeMemPool();
+}
+
+MapleAllocator *MIRBuilderExt::GetCurrentFuncCodeMpAllocator() {
+  ASSERT(curFunction, "curFunction is null");
+  return &curFunction->GetCodeMemPoolAllocator();
+}
+
+void MIRBuilderExt::GlobalLock() {
+  if (mutex) {
+    ASSERT(pthread_mutex_lock(mutex) == 0, "lock failed");
+  }
+}
+
+void MIRBuilderExt::GlobalUnlock() {
+  if (mutex) {
+    ASSERT(pthread_mutex_unlock(mutex) == 0, "unlock failed");
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_const.cpp b/src/mapleall/maple_ir/src/mir_const.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53724ffaa59087ad7c72dcc40353022cec6d56d6
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_const.cpp
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_const.h"
+#include "mir_function.h"
+#include "global_tables.h"
+#include "printing.h"
+#if MIR_FEATURE_FULL
+
+namespace maple {
+void MIRIntConst::Dump(const MIRSymbolTable *localSymTab [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << value;
+}
+
+bool MIRIntConst::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &intConst = static_cast<const MIRIntConst&>(rhs);
+  return ((&intConst.GetType() == &GetType()) && (intConst.value == value));
+}
+
+uint8 MIRIntConst::GetActualBitWidth() const {
+  if (value == 0) {
+    return 1;
+  }
+
+  int64 val = GetExtValue();
+  uint64 tmp = static_cast<uint64_t>(val < 0 ? -(val + 1) : val);
+
+  uint8 width = 0;
+  while (tmp != 0) {
+    ++width;
+    tmp = tmp >> 1u;
+  }
+
+  return width;
+}
+
+void MIRAddrofConst::Dump(const MIRSymbolTable *localSymTab) const {
+  LogInfo::MapleLogger() << "addrof " << GetPrimTypeName(PTY_ptr);
+  const MIRSymbol *sym = stIdx.IsGlobal() ? GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx())
+                                          : localSymTab->GetSymbolFromStIdx(stIdx.Idx());
+  CHECK_NULL_FATAL(sym);
+  ASSERT(stIdx.IsGlobal() || sym->GetStorageClass() == kScPstatic || sym->GetStorageClass() == kScFstatic,
+         "MIRAddrofConst can only point to a global symbol");
+  LogInfo::MapleLogger() << (stIdx.IsGlobal() ? " $" : " %") << sym->GetName();
+  if (fldID > 0) {
+    LogInfo::MapleLogger() << " " << fldID;
+  }
+  if (offset != 0) {
+    LogInfo::MapleLogger() << " (" << offset << ")";
+  }
+}
+
+bool MIRAddrofConst::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &rhsA = static_cast<const MIRAddrofConst&>(rhs);
+  if (&GetType() != &rhs.GetType()) {
+    return false;
+  }
+  return (stIdx == rhsA.stIdx) && (fldID == rhsA.fldID);
+}
+
+void MIRAddroffuncConst::Dump(const MIRSymbolTable *localSymTab [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << "addroffunc " << GetPrimTypeName(PTY_ptr);
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  CHECK_NULL_FATAL(func);
+  MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
+  CHECK_NULL_FATAL(sym);
+  LogInfo::MapleLogger() << " &" << sym->GetName();
+}
+
+bool MIRAddroffuncConst::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &rhsAf = static_cast<const MIRAddroffuncConst&>(rhs);
+  return (&GetType() == &rhs.GetType()) && (puIdx == rhsAf.puIdx);
+}
+
+void MIRLblConst::Dump(const MIRSymbolTable *localSymTab [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << "addroflabel " << GetPrimTypeName(PTY_ptr);
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  LogInfo::MapleLogger() << " @" << func->GetLabelName(value);
+}
+
+bool MIRLblConst::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &lblConst = static_cast<const MIRLblConst&>(rhs);
+  return (lblConst.value == value);
+}
+
+bool MIRFloatConst::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &floatConst = static_cast<const MIRFloatConst&>(rhs);
+  if (std::isnan(floatConst.value.floatValue)) {
+    return std::isnan(value.floatValue);
+  }
+  if (std::isnan(value.floatValue)) {
+    return std::isnan(floatConst.value.floatValue);
+  }
+  if (floatConst.value.floatValue == 0.0 && value.floatValue == 0.0) {
+    return floatConst.IsNeg() == IsNeg();
+  }
+  // Use bitwise comparison instead of approximate comparison for FP to avoid treating 0.0 and FLT_MIN as equal
+  return (floatConst.value.intValue == value.intValue);
+}
+
+bool MIRDoubleConst::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &floatConst = static_cast<const MIRDoubleConst&>(rhs);
+  if (std::isnan(floatConst.value.dValue)) {
+    return std::isnan(value.dValue);
+  }
+  if (std::isnan(value.dValue)) {
+    return std::isnan(floatConst.value.dValue);
+  }
+  if (floatConst.value.dValue == 0.0 && value.dValue == 0.0) {
+    return floatConst.IsNeg() == IsNeg();
+  }
+  // Use bitwise comparison instead of approximate comparison for FP to avoid treating 0.0 and DBL_MIN as equal
+  return (floatConst.value.intValue == value.intValue);
+}
+
+bool MIRFloat128Const::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &floatConst = static_cast<const MIRFloat128Const&>(rhs);
+  if ((value[0] == floatConst.value[0]) && (value[1] == floatConst.value[1])) {
+    return true;
+  }
+  return false;
+}
+
+bool MIRAggConst::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &aggregateConst = static_cast<const MIRAggConst&>(rhs);
+  if (aggregateConst.constVec.size() != constVec.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < constVec.size(); ++i) {
+    if (!(*aggregateConst.constVec[i] == *constVec[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void MIRFloatConst::Dump(const MIRSymbolTable *localSymTab [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << std::setprecision(std::numeric_limits<float>::max_digits10) << value.floatValue << "f";
+}
+
+void MIRDoubleConst::Dump(const MIRSymbolTable *localSymTab [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << std::setprecision(std::numeric_limits<double>::max_digits10) << value.dValue;
+}
+
+void MIRFloat128Const::Dump(const MIRSymbolTable *localSymTab [[maybe_unused]]) const {
+  constexpr int fieldWidth = 16;
+  std::ios::fmtflags f(LogInfo::MapleLogger().flags());
+  LogInfo::MapleLogger().setf(std::ios::uppercase);
+  LogInfo::MapleLogger() << "0xL" << std::hex << std::setfill('0') << std::setw(fieldWidth) << value[0]
+                         << std::setfill('0') << std::setw(fieldWidth) << value[1];
+  LogInfo::MapleLogger().flags(f);
+}
+
+void MIRAggConst::Dump(const MIRSymbolTable *localSymTab) const {
+  LogInfo::MapleLogger() << "[";
+  size_t size = constVec.size();
+  for (size_t i = 0; i < size; ++i) {
+    if (fieldIdVec[i] != 0) {
+      LogInfo::MapleLogger() << fieldIdVec[i] << "= ";
+    }
+    constVec[i]->Dump(localSymTab);
+    if (i != size - 1) {
+      LogInfo::MapleLogger() << ", ";
+    }
+  }
+  LogInfo::MapleLogger() << "]";
+}
+
+MIRStrConst::MIRStrConst(const std::string &str, MIRType &type)
+    : MIRConst(type, kConstStrConst), value(GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str)) {}
+
+void MIRStrConst::Dump(const MIRSymbolTable *localSymTab [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << "conststr " << GetPrimTypeName(GetType().GetPrimType());
+  const std::string &dumpStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(value);
+  PrintString(dumpStr);
+}
+
+bool MIRStrConst::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &rhsCs = static_cast<const MIRStrConst&>(rhs);
+  return (&rhs.GetType() == &GetType()) && (value == rhsCs.value);
+}
+
+MIRStr16Const::MIRStr16Const(const std::u16string &str, MIRType &type)
+    : MIRConst(type, kConstStr16Const),
+      value(GlobalTables::GetU16StrTable().GetOrCreateStrIdxFromName(str)) {}
+
+void MIRStr16Const::Dump(const MIRSymbolTable *localSymTab [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << "conststr16 " << GetPrimTypeName(GetType().GetPrimType());
+  std::u16string str16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(value);
+  // UTF-16 string are dumped as UTF-8 string in mpl to keep the printable chars in ascii form
+  std::string str;
+  (void)namemangler::UTF16ToUTF8(str, str16);
+  PrintString(str);
+}
+
+bool MIRStr16Const::operator==(const MIRConst &rhs) const {
+  if (&rhs == this) {
+    return true;
+  }
+  if (GetKind() != rhs.GetKind()) {
+    return false;
+  }
+  const auto &rhsCs = static_cast<const MIRStr16Const&>(rhs);
+  return (&GetType() == &rhs.GetType()) && (value == rhsCs.value);
+}
+
+bool IsDivSafe(const MIRIntConst &dividend, const MIRIntConst &divisor, PrimType pType) {
+  if (IsUnsignedInteger(pType)) {
+    return divisor.GetValue() != 0;
+  }
+
+  return divisor.GetValue() != 0 && (!dividend.GetValue().IsMinValue() || !divisor.GetValue().AreAllBitsOne());
+}
+
+}  // namespace maple
+#endif  // MIR_FEATURE_FULL
diff --git a/src/mapleall/maple_ir/src/mir_enum.cpp b/src/mapleall/maple_ir/src/mir_enum.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2fc4bb915d9bc1ba609bef6eed050a19bc08d6c3
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_enum.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "global_tables.h"
+#include "printing.h"
+#include "mir_enum.h"
+
+// The syntax of enumerated type in Maple IR is:
+//    ENUMERATION <enum-name> <prim-type> { <value-name> = <int-const>, ... }
+// If '=' is not specified, <int-const> will adopt the last value plus 1.
+// The default starting <int-const> is 0.
+
+namespace maple {
+
+const std::string &MIREnum::GetName() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(nameStrIdx);
+}
+
+void MIREnum::Dump() const {
+  LogInfo::MapleLogger() << "ENUMERATION $" << GetName() << " " << GetPrimTypeName(primType) << " {";
+  if (elements.empty()) {
+    LogInfo::MapleLogger() << " }\n";
+    return;
+  }
+  IntVal lastValue(elements.front().second - k9BitSize, primType); // so as to fail first check
+  for (size_t i = 0; i < elements.size(); ++i) {
+    EnumElem curElem = elements[i];
+    LogInfo::MapleLogger() << " $" << GlobalTables::GetStrTable().GetStringFromStrIdx(curElem.first);
+    if (curElem.second != lastValue + 1) {
+      LogInfo::MapleLogger() << " = " << curElem.second;
+    }
+    lastValue = curElem.second;
+    if (i + 1 != elements.size()) {
+      LogInfo::MapleLogger() << ",";
+    }
+  }
+  LogInfo::MapleLogger() << " }\n";
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_function.cpp b/src/mapleall/maple_ir/src/mir_function.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e97aac7e0c762a6d12c56e0640b12cac23a836a4
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_function.cpp
@@ -0,0 +1,751 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_function.h"
+#include <cstdio>
+#include <iostream>
+#include "mir_nodes.h"
+#include "printing.h"
+#include "string_utils.h"
+#include "ipa_side_effect.h"
+#include "inline_summary.h"
+
+namespace {
+using namespace maple;
+enum FuncProp : uint32_t {
+  kFuncPropHasCall = 1U,           // the function has call
+  kFuncPropRetStruct = 1U << 1,    // the function returns struct
+  kFuncPropUserFunc = 1U << 2,     // the function is a user func
+  kFuncPropInfoPrinted = 1U << 3,  // to avoid printing frameSize/moduleid/funcSize info more
+                                   // than once per function since they
+                                   // can only be printed at the beginning of a block
+  kFuncPropNeverReturn = 1U << 4,  // the function when called never returns
+  kFuncPropHasSetjmp = 1U << 5,    // the function contains call to setjmp
+  kFuncPropHasAsm = 1U << 6,       // the function has use of inline asm
+  kFuncPropStructReturnedInRegs = 1U << 7, // the function returns struct in registers
+};
+}  // namespace
+
+namespace maple {
+const MIRSymbol *MIRFunction::GetFuncSymbol() const {
+  return GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx());
+}
+MIRSymbol *MIRFunction::GetFuncSymbol() {
+  const MIRFunction *mirFunc = const_cast<const MIRFunction*>(this);
+  ASSERT(mirFunc != nullptr, "null ptr check");
+  return const_cast<MIRSymbol*>(mirFunc->GetFuncSymbol());
+}
+
+const std::string &MIRFunction::GetName() const {
+  MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx());
+  ASSERT(mirSymbol != nullptr, "null ptr check");
+  return mirSymbol->GetName();
+}
+
+GStrIdx MIRFunction::GetNameStrIdx() const {
+  MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx());
+  ASSERT(mirSymbol != nullptr, "null ptr check");
+  return mirSymbol->GetNameStrIdx();
+}
+
+const std::string &MIRFunction::GetBaseClassName() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(baseClassStrIdx);
+}
+
+const std::string &MIRFunction::GetBaseFuncName() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(baseFuncStrIdx);
+}
+
+const std::string &MIRFunction::GetBaseFuncNameWithType() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(baseFuncWithTypeStrIdx);
+}
+
+const std::string &MIRFunction::GetBaseFuncSig() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(baseFuncSigStrIdx);
+}
+
+const std::string &MIRFunction::GetSignature() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(signatureStrIdx);
+}
+
+const MIRType *MIRFunction::GetReturnType() const {
+  CHECK_FATAL(funcType != nullptr, "funcType should not be nullptr");
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx());
+}
+MIRType *MIRFunction::GetReturnType() {
+  return const_cast<MIRType*>(const_cast<const MIRFunction*>(this)->GetReturnType());
+}
+const MIRType *MIRFunction::GetClassType() const {
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(classTyIdx);
+}
+const MIRType *MIRFunction::GetNthParamType(size_t i) const {
+  CHECK_FATAL(funcType != nullptr, "funcType should not be nullptr");
+  ASSERT(i < funcType->GetParamTypeList().size(), "array index out of range");
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetParamTypeList()[i]);
+}
+MIRType *MIRFunction::GetNthParamType(size_t i) {
+  return const_cast<MIRType*>(const_cast<const MIRFunction*>(this)->GetNthParamType(i));
+}
+
+// reconstruct formals, and return a new MIRFuncType
+MIRFuncType *MIRFunction::ReconstructFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs) {
+  auto *newFuncType = static_cast<MIRFuncType*>(funcType->CopyMIRTypeNode());
+  if (clearOldArgs) {
+    formalDefVec.clear();
+    newFuncType->GetParamTypeList().clear();
+    newFuncType->GetParamAttrsList().clear();
+  }
+  for (auto *symbol : symbols) {
+    FormalDef formalDef(symbol->GetNameStrIdx(), symbol, symbol->GetTyIdx(), symbol->GetAttrs());
+    formalDefVec.push_back(formalDef);
+    newFuncType->GetParamTypeList().push_back(symbol->GetTyIdx());
+    newFuncType->GetParamAttrsList().push_back(symbol->GetAttrs());
+  }
+  return newFuncType;
+}
+
+void MIRFunction::UpdateFuncTypeAndFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs) {
+  auto *newFuncType = ReconstructFormals(symbols, clearOldArgs);
+  auto newFuncTypeIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(newFuncType);
+  funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(newFuncTypeIdx));
+  delete newFuncType;
+}
+
+void MIRFunction::UpdateFuncTypeAndFormalsAndReturnType(const std::vector<MIRSymbol*> &symbols, const TyIdx &retTyIdx,
+                                                        bool clearOldArgs) {
+  auto *newFuncType = ReconstructFormals(symbols, clearOldArgs);
+  newFuncType->SetRetTyIdx(retTyIdx);
+  auto newFuncTypeIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(newFuncType);
+  funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(newFuncTypeIdx));
+  delete newFuncType;
+}
+
+LabelIdx MIRFunction::GetOrCreateLableIdxFromName(const std::string &name) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  LabelIdx labelIdx = GetLabelTab()->GetLabelIdxFromStrIdx(strIdx);
+  if (labelIdx == 0) {
+    labelIdx = GetLabelTab()->CreateLabel();
+    GetLabelTab()->SetSymbolFromStIdx(labelIdx, strIdx);
+    GetLabelTab()->AddToStringLabelMap(labelIdx);
+  }
+  return labelIdx;
+}
+
+bool MIRFunction::HasCall() const {
+  return flag & kFuncPropHasCall;
+}
+void MIRFunction::SetHasCall() {
+  flag |= kFuncPropHasCall;
+}
+
+bool MIRFunction::IsReturnStruct() const {
+  return flag & kFuncPropRetStruct;
+}
+void MIRFunction::SetReturnStruct() {
+  flag |= kFuncPropRetStruct;
+}
+void MIRFunction::SetReturnStruct(const MIRType &retType) {
+  if (retType.IsStructType()) {
+    flag |= kFuncPropRetStruct;
+  }
+}
+void MIRFunction::SetReturnStruct(const MIRType *retType) {
+  switch (retType->GetKind()) {
+    case kTypeUnion:
+    case kTypeStruct:
+    case kTypeStructIncomplete:
+    case kTypeClass:
+    case kTypeClassIncomplete:
+    case kTypeInterface:
+    case kTypeInterfaceIncomplete:
+      flag |= kFuncPropRetStruct;
+      break;
+    default:;
+  }
+}
+
+bool MIRFunction::IsUserFunc() const {
+  return flag & kFuncPropUserFunc;
+}
+void MIRFunction::SetUserFunc() {
+  flag |= kFuncPropUserFunc;
+}
+
+bool MIRFunction::IsInfoPrinted() const {
+  return flag & kFuncPropInfoPrinted;
+}
+void MIRFunction::SetInfoPrinted() {
+  flag |= kFuncPropInfoPrinted;
+}
+void MIRFunction::ResetInfoPrinted() {
+  flag &= ~kFuncPropInfoPrinted;
+}
+
+void MIRFunction::SetNoReturn() {
+  flag |= kFuncPropNeverReturn;
+}
+bool MIRFunction::NeverReturns() const {
+  return flag & kFuncPropNeverReturn;
+}
+
+void MIRFunction::SetHasSetjmp() {
+  flag |= kFuncPropHasSetjmp;
+}
+
+bool MIRFunction::HasSetjmp() const {
+  return ((flag & kFuncPropHasSetjmp) != kTypeflagZero);
+}
+
+void MIRFunction::SetHasAsm() {
+  flag |= kFuncPropHasAsm;
+}
+
+bool MIRFunction::HasAsm() const {
+  return ((flag & kFuncPropHasAsm) != kTypeflagZero);
+}
+
+void MIRFunction::SetStructReturnedInRegs() {
+  flag |= kFuncPropStructReturnedInRegs;
+}
+
+bool MIRFunction::StructReturnedInRegs() const {
+  return ((flag & kFuncPropStructReturnedInRegs) != kTypeflagZero);
+}
+
+void MIRFunction::SetAttrsFromSe(uint8 specialEffect) {
+  // NoPrivateDefEffect
+  if ((specialEffect & kDefEffect) == kDefEffect) {
+    funcAttrs.SetAttr(FUNCATTR_noprivate_defeffect);
+  }
+  // NoPrivateUseEffect
+  if ((specialEffect & kUseEffect) == kUseEffect) {
+    funcAttrs.SetAttr(FUNCATTR_noretarg);
+  }
+  // IpaSeen
+  if ((specialEffect & kIpaSeen) == kIpaSeen) {
+    funcAttrs.SetAttr(FUNCATTR_ipaseen);
+  }
+  // Pure
+  if ((specialEffect & kPureFunc) == kPureFunc) {
+    funcAttrs.SetAttr(FUNCATTR_pure);
+  }
+  // NoDefArgEffect
+  if ((specialEffect & kNoDefArgEffect) == kNoDefArgEffect) {
+    funcAttrs.SetAttr(FUNCATTR_nodefargeffect);
+  }
+  // NoDefEffect
+  if ((specialEffect & kNoDefEffect) == kNoDefEffect) {
+    funcAttrs.SetAttr(FUNCATTR_nodefeffect);
+  }
+  // NoRetNewlyAllocObj
+  if ((specialEffect & kNoRetNewlyAllocObj) == kNoRetNewlyAllocObj) {
+    funcAttrs.SetAttr(FUNCATTR_noretglobal);
+  }
+  // NoThrowException
+  if ((specialEffect & kNoThrowException) == kNoThrowException) {
+    funcAttrs.SetAttr(FUNCATTR_nothrow_exception);
+  }
+}
+
+void FuncAttrs::DumpAttributes() const {
+// parse no content of attr
+#define STRING(s) #s
+#define FUNC_ATTR
+#define NOCONTENT_ATTR
+#define ATTR(AT)                                                       \
+  if (GetAttr(FUNCATTR_##AT)) {                                        \
+    LogInfo::MapleLogger() << " " << STRING(AT);                       \
+  }
+#include "all_attributes.def"
+#undef ATTR
+#undef NOCONTENT_ATTR
+#undef FUNC_ATTR
+// parse content of attr
+  if (GetAttr(FUNCATTR_alias) && !GetAliasFuncName().empty()) {
+    LogInfo::MapleLogger() << " alias ( \"" << GetAliasFuncName() << "\" )";
+  }
+  if (GetAttr(FUNCATTR_constructor_priority) && GetConstructorPriority() != -1) {
+    LogInfo::MapleLogger() << " constructor_priority ( " << GetConstructorPriority() << " )";
+  }
+  if (GetAttr(FUNCATTR_destructor_priority) && GetDestructorPriority() != -1) {
+    LogInfo::MapleLogger() << " destructor_priority ( " << GetDestructorPriority() << " )";
+  }
+}
+
+void MIRFunction::DumpFlavorLoweredThanMmpl() const {
+  LogInfo::MapleLogger() << " (";
+
+  // Dump arguments
+  bool hasPrintedFormal = false;
+  for (uint32 i = 0; i < formalDefVec.size(); i++) {
+    MIRSymbol *symbol = formalDefVec[i].formalSym;
+    if (symbol == nullptr &&
+        (formalDefVec[i].formalStrIdx.GetIdx() == 0 ||
+         GlobalTables::GetStrTable().GetStringFromStrIdx(formalDefVec[i].formalStrIdx).empty())) {
+      break;
+    }
+    hasPrintedFormal = true;
+    if (symbol == nullptr) {
+      LogInfo::MapleLogger() << "var %"
+                             << GlobalTables::GetStrTable().GetStringFromStrIdx(formalDefVec[i].formalStrIdx)
+                             << " ";
+    } else {
+      if (symbol->GetSKind() != kStPreg) {
+        LogInfo::MapleLogger() << "var %" << symbol->GetName() << " ";
+      } else {
+        LogInfo::MapleLogger() << "reg %" << symbol->GetPreg()->GetPregNo() << " ";
+      }
+    }
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(formalDefVec[i].formalTyIdx);
+    constexpr uint8 indent = 2;
+    ty->Dump(indent);
+    if (symbol != nullptr) {
+      symbol->GetAttrs().DumpAttributes();
+    } else {
+      formalDefVec[i].formalAttrs.DumpAttributes();
+    }
+    if (i != (formalDefVec.size() - 1)) {
+      LogInfo::MapleLogger() << ", ";
+    }
+  }
+  if (IsVarargs()) {
+    if (!hasPrintedFormal) {
+      LogInfo::MapleLogger() << "...";
+    } else {
+      LogInfo::MapleLogger() << ", ...";
+    }
+  }
+
+  LogInfo::MapleLogger() << ") ";
+  GetReturnType()->Dump(1);
+}
+
+void MIRFunction::Dump(bool withoutBody) {
+  // skip the functions that are added during process methods in
+  // class and interface decls.  these has nothing in formals
+  // they do have paramtypelist_. this can not skip ones without args
+  // but for them at least the func decls are valid
+  if ((module->IsJavaModule() && GetParamSize() != formalDefVec.size()) ||
+      GetAttr(FUNCATTR_optimized)) {
+    return;
+  }
+
+  // save the module's curFunction and set it to the one currently Dump()ing
+  MIRFunction *savedFunc = module->CurFunction();
+  module->SetCurFunction(this);
+
+  MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx());
+  ASSERT(symbol != nullptr, "symbol MIRSymbol is null");
+  if (!withoutBody) {
+    symbol->GetSrcPosition().DumpLoc(MIRSymbol::LastPrintedLineNumRef(), MIRSymbol::LastPrintedColumnNumRef());
+  }
+  LogInfo::MapleLogger() << "func " << "&" << symbol->GetName();
+  theMIRModule = module;
+  funcAttrs.DumpAttributes();
+
+  if (symbol->GetWeakrefAttr().first) {
+    LogInfo::MapleLogger() << " weakref";
+    if (symbol->GetWeakrefAttr().second != UStrIdx(0)) {
+      LogInfo::MapleLogger() << " (";
+      PrintString(GlobalTables::GetUStrTable().GetStringFromStrIdx(symbol->GetWeakrefAttr().second));
+      LogInfo::MapleLogger() << " )";
+    }
+  }
+
+  if (symbol->sectionAttr != UStrIdx(0)) {
+    LogInfo::MapleLogger() << " section (";
+    PrintString(GlobalTables::GetUStrTable().GetStringFromStrIdx(symbol->sectionAttr));
+    LogInfo::MapleLogger() << " )";
+  }
+
+  if (module->GetFlavor() != kMmpl) {
+    DumpFlavorLoweredThanMmpl();
+  }
+
+  // codeMemPool is nullptr, means maple_ir has been released for memory's sake
+  if (codeMemPool == nullptr) {
+    LogInfo::MapleLogger() << '\n';
+  } else if (GetBody() != nullptr && !withoutBody && symbol->GetStorageClass() != kScExtern) {
+    StmtNode::lastPrintedLineNum = 0;
+    StmtNode::lastPrintedColumnNum = 0;
+    ResetInfoPrinted();  // this ensures funcinfo will be printed
+    GetBody()->Dump(0, module->GetFlavor() == kMmpl ? nullptr : GetSymTab(),
+                    module->GetFlavor() < kMmpl ? GetPregTab() : nullptr, false,
+                    true, module->GetFlavor());  // Dump body
+  } else {
+    LogInfo::MapleLogger() << '\n';
+  }
+
+  // restore the curFunction
+  module->SetCurFunction(savedFunc);
+}
+
+void MIRFunction::DumpUpFormal(int32 indent) const {
+  PrintIndentation(indent + 1);
+
+  LogInfo::MapleLogger() << "upformalsize " << GetUpFormalSize() << '\n';
+  if (localWordsTypeTagged != nullptr) {
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << "formalWordsTypeTagged = [ ";
+    const auto *p = reinterpret_cast<const uint32*>(localWordsTypeTagged);
+    LogInfo::MapleLogger() << std::hex;
+    while (p < reinterpret_cast<const uint32*>(localWordsTypeTagged + BlockSize2BitVectorSize(GetUpFormalSize()))) {
+      LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
+      ++p;
+    }
+    LogInfo::MapleLogger() << std::dec << "]\n";
+  }
+
+  if (formalWordsRefCounted != nullptr) {
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << "formalWordsRefCounted = [ ";
+    const uint32 *p = reinterpret_cast<const uint32*>(formalWordsRefCounted);
+    LogInfo::MapleLogger() << std::hex;
+    while (p < reinterpret_cast<const uint32*>(formalWordsRefCounted + BlockSize2BitVectorSize(GetUpFormalSize()))) {
+      LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
+      ++p;
+    }
+    LogInfo::MapleLogger() << std::dec << "]\n";
+  }
+}
+
+void MIRFunction::DumpFrame(int32 indent) const {
+  PrintIndentation(indent + 1);
+
+  LogInfo::MapleLogger() << "framesize " << static_cast<uint32>(GetFrameSize()) << '\n';
+  if (localWordsTypeTagged != nullptr) {
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << "localWordsTypeTagged = [ ";
+    const uint32 *p = reinterpret_cast<const uint32*>(localWordsTypeTagged);
+    LogInfo::MapleLogger() << std::hex;
+    while (p < reinterpret_cast<const uint32*>(localWordsTypeTagged + BlockSize2BitVectorSize(GetFrameSize()))) {
+      LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
+      ++p;
+    }
+    LogInfo::MapleLogger() << std::dec << "]\n";
+  }
+
+  if (localWordsRefCounted != nullptr) {
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << "localWordsRefCounted = [ ";
+    const uint32 *p = reinterpret_cast<const uint32*>(localWordsRefCounted);
+    LogInfo::MapleLogger() << std::hex;
+    while (p < reinterpret_cast<const uint32*>(localWordsRefCounted + BlockSize2BitVectorSize(GetFrameSize()))) {
+      LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
+      ++p;
+    }
+    LogInfo::MapleLogger() << std::dec << "]\n";
+  }
+}
+
+void MIRFunction::DumpScope() const {
+  scope->Dump(0);
+}
+
+void MIRFunction::DumpFuncBody(int32 indent) {
+  LogInfo::MapleLogger() << "  funcid " << GetPuidxOrigin() << '\n';
+
+  if (IsInfoPrinted()) {
+    return;
+  }
+
+  SetInfoPrinted();
+
+  if (GetUpFormalSize() > 0) {
+    DumpUpFormal(indent);
+  }
+
+  if (GetFrameSize() > 0) {
+    DumpFrame(indent);
+  }
+
+  if (GetOutParmSize() > 0) {
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << "outparmsize " << GetOutParmSize() << '\n';
+  }
+
+  if (GetModuleId() > 0) {
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << "moduleID " << static_cast<uint32>(GetModuleId()) << '\n';
+  }
+
+  if (GetFuncSize() > 0) {
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << "funcSize " << GetFuncSize() << '\n';
+  }
+
+  if (GetInfoVector().empty()) {
+    return;
+  }
+
+  const MIRInfoVector &funcInfo = GetInfoVector();
+  const MapleVector<bool> &funcInfoIsString = InfoIsString();
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << "funcinfo {\n";
+  size_t size = funcInfo.size();
+  constexpr int kIndentOffset = 2;
+  for (size_t i = 0; i < size; ++i) {
+    PrintIndentation(indent + kIndentOffset);
+    LogInfo::MapleLogger() << "@" << GlobalTables::GetStrTable().GetStringFromStrIdx(funcInfo[i].first) << " ";
+    if (!funcInfoIsString[i]) {
+      LogInfo::MapleLogger() << funcInfo[i].second;
+    } else {
+      LogInfo::MapleLogger() << "\""
+                             << GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(funcInfo[i].second))
+                             << "\"";
+    }
+    if (i < size - 1) {
+      LogInfo::MapleLogger() << ",\n";
+    } else {
+      LogInfo::MapleLogger() << "}\n";
+    }
+  }
+  LogInfo::MapleLogger() << '\n';
+}
+
+bool MIRFunction::IsEmpty() const {
+  return (body == nullptr || body->IsEmpty());
+}
+
+bool MIRFunction::IsClinit() const {
+  const std::string clinitPostfix = "_7C_3Cclinit_3E_7C_28_29V";
+  const std::string &funcName = this->GetName();
+  // this does not work for smali files like art/test/511-clinit-interface/smali/BogusInterface.smali,
+  // which is decorated without "constructor".
+  return StringUtils::EndsWith(funcName, clinitPostfix);
+}
+
+uint32 MIRFunction::GetInfo(GStrIdx strIdx) const {
+  for (const auto &item : info) {
+    if (item.first == strIdx) {
+      return item.second;
+    }
+  }
+  ASSERT(false, "get info error");
+  return 0;
+}
+
+uint32 MIRFunction::GetInfo(const std::string &string) const {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(string);
+  return GetInfo(strIdx);
+}
+
+void MIRFunction::OverrideBaseClassFuncNames(GStrIdx strIdx) {
+  baseClassStrIdx.reset();
+  baseFuncStrIdx.reset();
+  SetBaseClassFuncNames(strIdx);
+}
+
+// there are two ways to represent the delimiter: '|' or "_7C"
+// where 7C is the ascii value of char '|' in hex
+void MIRFunction::SetBaseClassFuncNames(GStrIdx strIdx) {
+  if (baseClassStrIdx != 0u || baseFuncStrIdx != 0u) {
+    return;
+  }
+  const std::string name = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+  std::string delimiter = "|";
+  uint32 width = 1;  // delimiter width
+  size_t pos = name.find(delimiter);
+  if (pos == std::string::npos) {
+    delimiter = namemangler::kNameSplitterStr;
+    width = 3;  // delimiter width
+    pos = name.find(delimiter);
+    // make sure it is not __7C, but ___7C ok
+    while (pos != std::string::npos && (name[pos - 1] == '_' && name[pos - 2] != '_')) {
+      pos = name.find(delimiter, pos + width);
+    }
+  }
+  if (pos != std::string::npos && pos > 0) {
+    const std::string className = name.substr(0, pos);
+    baseClassStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(className);
+    std::string funcNameWithType = name.substr(pos + width, name.length() - pos - width);
+    baseFuncWithTypeStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcNameWithType);
+    size_t index = name.find(namemangler::kRightBracketStr);
+    if (index != std::string::npos) {
+      size_t posEnd = index + (std::string(namemangler::kRightBracketStr)).length();
+      funcNameWithType = name.substr(pos + width, posEnd - pos - width);
+    }
+    baseFuncSigStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcNameWithType);
+    size_t newPos = name.find(delimiter, pos + width);
+    while (newPos != std::string::npos && (name[newPos - 1] == '_' && name[newPos - 2] != '_')) {
+      newPos = name.find(delimiter, newPos + width);
+    }
+    if (newPos != 0) {
+      std::string funcName = name.substr(pos + width, newPos - pos - width);
+      baseFuncStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+      std::string signature = name.substr(newPos + width, name.length() - newPos - width);
+      signatureStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(signature);
+    }
+    return;
+  }
+  baseFuncStrIdx = strIdx;
+}
+
+const MIRSymbol *MIRFunction::GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst) const {
+  return idx.Islocal() ? GetSymbolTabItem(idx.Idx(), checkFirst)
+                       : GlobalTables::GetGsymTable().GetSymbolFromStidx(idx.Idx(), checkFirst);
+}
+MIRSymbol *MIRFunction::GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst) {
+  return const_cast<MIRSymbol*>(const_cast<const MIRFunction*>(this)->GetLocalOrGlobalSymbol(idx, checkFirst));
+}
+
+const MIRType *MIRFunction::GetNodeType(const BaseNode &node) const {
+  if (node.GetOpCode() == OP_dread) {
+    const MIRSymbol *sym = GetLocalOrGlobalSymbol(static_cast<const DreadNode&>(node).GetStIdx());
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx());
+  }
+  if (node.GetOpCode() == OP_regread) {
+    const auto &nodeReg = static_cast<const RegreadNode&>(node);
+    const MIRPreg *pReg = GetPregTab()->PregFromPregIdx(nodeReg.GetRegIdx());
+    if (pReg->GetPrimType() == PTY_ref) {
+      return pReg->GetMIRType();
+    }
+  }
+  return nullptr;
+}
+
+void MIRFunction::EnterFormals() {
+  for (auto &formalDef : formalDefVec) {
+    formalDef.formalSym = symTab->CreateSymbol(kScopeLocal);
+    formalDef.formalSym->SetStorageClass(kScFormal);
+    formalDef.formalSym->SetNameStrIdx(formalDef.formalStrIdx);
+    formalDef.formalSym->SetTyIdx(formalDef.formalTyIdx);
+    formalDef.formalSym->SetAttrs(formalDef.formalAttrs);
+    const std::string &formalName = GlobalTables::GetStrTable().GetStringFromStrIdx(formalDef.formalStrIdx);
+    if (!isdigit(formalName.front())) {
+      formalDef.formalSym->SetSKind(kStVar);
+      (void)symTab->AddToStringSymbolMap(*formalDef.formalSym);
+    } else {
+      formalDef.formalSym->SetSKind(kStPreg);
+      uint32 thepregno = static_cast<uint32>(std::stoi(formalName));
+      MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(formalDef.formalTyIdx);
+      PrimType pType = mirType->GetPrimType();
+      // if mirType info is not needed, set mirType to nullptr
+      if (pType != PTY_ref && pType != PTY_ptr) {
+        mirType = nullptr;
+      } else if (pType == PTY_ptr && mirType->IsMIRPtrType()) {
+        MIRType *pointedType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+        if (pointedType == nullptr || pointedType->GetKind() != kTypeFunction) {
+          mirType = nullptr;
+        }
+      }
+      PregIdx pregIdx = pregTab->EnterPregNo(thepregno, pType, mirType);
+      MIRPreg *preg = pregTab->PregFromPregIdx(pregIdx);
+      formalDef.formalSym->SetPreg(preg);
+    }
+  }
+}
+
+// InlineSummary constructor is dependent on the following Predicate static member functions and it
+// will be called by MIRFunction::GetOrCreateInlineSummary(). So we put the implemetation code here.
+// True predicate asserts: { 0 }
+// TruePredicate object is globally unique, so we allocate it in inlineSummaryAlloc.
+// DO NOT call this function after inlineSummaryAlloc is released.
+const Predicate *Predicate::TruePredicate() {
+  auto &summaryAlloc = theMIRModule->GetInlineSummaryAlloc();
+  static const auto * const truePredicate =
+      summaryAlloc.New<Predicate>(std::initializer_list<Assert>{ 0 }, summaryAlloc);
+  return truePredicate;
+}
+
+// False predicate asserts: { 1 }
+// FalsePredicate object is globally unique, so we allocate it in inlineSummaryAlloc.
+// DO NOT call this function after inlineSummaryAlloc is released.
+const Predicate *Predicate::FalsePredicate() {
+  auto &summaryAlloc = theMIRModule->GetInlineSummaryAlloc();
+  static const auto * const falsePredicate =
+      summaryAlloc.New<Predicate>(std::initializer_list<Assert>{ 1 }, summaryAlloc);
+  return falsePredicate;
+}
+
+// NotInline predicate asserts: { 2 }
+// NotInlinePredicate object is globally unique, so we allocate it in inlineSummaryAlloc.
+// DO NOT call this function after inlineSummaryAlloc is released.
+const Predicate *Predicate::NotInlinePredicate() {
+  auto &summaryAlloc = theMIRModule->GetInlineSummaryAlloc();
+  static const auto * const notInlinePredicate =
+      summaryAlloc.New<Predicate>(std::initializer_list<Assert>{ 2 }, summaryAlloc);
+  return notInlinePredicate;
+}
+
+InlineSummary *MIRFunction::GetOrCreateInlineSummary() {
+  if (inlineSummary == nullptr) {
+    auto &inlineSummaryAlloc = module->GetInlineSummaryAlloc();
+    CHECK_FATAL(inlineSummaryAlloc.GetMemPool() != nullptr, "inline summary alloc has been released?");
+    inlineSummary = inlineSummaryAlloc.New<InlineSummary>(inlineSummaryAlloc, this);
+  }
+  return GetInlineSummary();
+}
+
+void MIRFunction::NewBody() {
+  SetBody(GetCodeMemPool()->New<BlockNode>());
+  // If mir_function.has been seen as a declaration, its symtab has to be moved
+  // from module mempool to function mempool.
+  MIRSymbolTable *oldSymTable = GetSymTab();
+  MIRPregTable *oldPregTable = GetPregTab();
+  MIRTypeNameTable *oldTypeNameTable = typeNameTab;
+  MIRLabelTable *oldLabelTable = GetLabelTab();
+  symTab = module->GetMemPool()->New<MIRSymbolTable>(module->GetMPAllocator());
+  pregTab = module->GetMemPool()->New<MIRPregTable>(&module->GetMPAllocator());
+  typeNameTab = module->GetMemPool()->New<MIRTypeNameTable>(module->GetMPAllocator());
+  labelTab = module->GetMemPool()->New<MIRLabelTable>(module->GetMPAllocator());
+
+  if (oldSymTable == nullptr) {
+    // formals not yet entered into symTab; enter them now
+    EnterFormals();
+  } else {
+    for (size_t i = 1; i < oldSymTable->GetSymbolTableSize(); ++i) {
+      (void)GetSymTab()->AddStOutside(oldSymTable->GetSymbolFromStIdx(i));
+    }
+  }
+  if (oldPregTable != nullptr) {
+    for (size_t i = 1; i < oldPregTable->Size(); ++i) {
+      (void)GetPregTab()->AddPreg(*oldPregTable->PregFromPregIdx(static_cast<PregIdx>(i)));
+    }
+  }
+  if (oldTypeNameTable != nullptr) {
+    ASSERT(oldTypeNameTable->Size() == typeNameTab->Size(),
+           "Does not expect to process typeNameTab in MIRFunction::NewBody");
+  }
+  if (oldLabelTable != nullptr) {
+    ASSERT(oldLabelTable->Size() == GetLabelTab()->Size(),
+           "Does not expect to process labelTab in MIRFunction::NewBody");
+  }
+}
+
+MIRFunction *MIRFunction::GetFuncAlias() {
+  if (GetAttr(FUNCATTR_weakref)) {
+    auto aliasFunc = funcAttrs.GetAliasFuncName();
+    auto builder =  module->GetMIRBuilder();
+    return builder->GetOrCreateFunction(aliasFunc, funcType->GetRetTyIdx());
+  } else {
+    return this;
+  }
+}
+
+#ifdef DEBUGME
+void MIRFunction::SetUpGDBEnv() {
+  if (codeMemPool != nullptr) {
+    delete codeMemPool;
+  }
+  codeMemPool = new ThreadLocalMemPool(memPoolCtrler, "tmp debug");
+  codeMemPoolAllocator.SetMemPool(codeMemPool);
+}
+
+void MIRFunction::ResetGDBEnv() {
+  delete codeMemPool;
+  codeMemPool = nullptr;
+}
+#endif
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_lower.cpp b/src/mapleall/maple_ir/src/mir_lower.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..389dc6fc87adbacd1a42a9d3e5263498649c2fbc
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_lower.cpp
@@ -0,0 +1,1122 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_lower.h"
+#include "constantfold.h"
+#include "ext_constantfold.h"
+
+#define DO_LT_0_CHECK 1
+
+namespace maple {
+
+static constexpr uint64 RoundUpConst(uint64 offset, uint32 align) {
+  return (-align) & (offset + align - 1);
+}
+
+static inline uint64 RoundUp(uint64 offset, uint32 align) {
+  if (align == 0) {
+    return offset;
+  }
+  return RoundUpConst(offset, align);
+}
+
+// Remove intrinsicop __builtin_expect and record likely info to brStmt
+// Target condExpr example:
+//  ne u1 i64 (
+//    intrinsicop i64 C___builtin_expect (
+//     cvt i64 i32 (dread i32 %levVar_9354), cvt i64 i32 (constval i32 0)),
+//    constval i64 0)
+void LowerCondGotoStmtWithBuiltinExpect(CondGotoNode &brStmt) {
+  BaseNode *condExpr = brStmt.Opnd(0);
+  // Poke ne for dread shortCircuit
+  // Example:
+  //  dassign %shortCircuit 0 (ne u1 i64 (
+  //    intrinsicop i64 C___builtin_expect (
+  //      cvt i64 i32 (dread i32 %levVar_32349),
+  //      cvt i64 i32 (constval i32 0)),
+  //    constval i64 0))
+  //  dassign %shortCircuit 0 (ne u1 u32 (dread u32 %shortCircuit, constval u1 0))
+  if (condExpr->GetOpCode() == OP_ne && condExpr->Opnd(0)->GetOpCode() == OP_dread &&
+      condExpr->Opnd(1)->GetOpCode() == OP_constval) {
+    auto *constVal = static_cast<ConstvalNode*>(condExpr->Opnd(1))->GetConstVal();
+    if (constVal->GetKind() == kConstInt && static_cast<MIRIntConst*>(constVal)->GetValue() == 0) {
+      condExpr = condExpr->Opnd(0);
+    }
+  }
+  if (condExpr->GetOpCode() == OP_dread) {
+    // Example:
+    //    dassign %shortCircuit 0 (ne u1 i64 (
+    //      intrinsicop i64 C___builtin_expect (
+    //        cvt i64 i32 (dread i32 %levVar_9488),
+    //        cvt i64 i32 (constval i32 1)),
+    //      constval i64 0))
+    //    brfalse @shortCircuit_label_13351 (dread u32 %shortCircuit)
+    StIdx stIdx = static_cast<DreadNode*>(condExpr)->GetStIdx();
+    FieldID fieldId = static_cast<DreadNode*>(condExpr)->GetFieldID();
+    if (fieldId != 0) {
+      return;
+    }
+    if (brStmt.GetPrev() == nullptr || brStmt.GetPrev()->GetOpCode() != OP_dassign) {
+      return;  // prev stmt may be a label, we skip it too
+    }
+    auto *dassign = static_cast<DassignNode*>(brStmt.GetPrev());
+    if (stIdx != dassign->GetStIdx() || dassign->GetFieldID() != 0) {
+      return;
+    }
+    condExpr = dassign->GetRHS();
+  }
+  if (condExpr->GetOpCode() == OP_ne) {
+    // opnd1 must be int const 0
+    BaseNode *opnd1 = condExpr->Opnd(1);
+    if (opnd1->GetOpCode() != OP_constval) {
+      return;
+    }
+    auto *constVal = static_cast<ConstvalNode*>(opnd1)->GetConstVal();
+    if (constVal->GetKind() != kConstInt || static_cast<MIRIntConst*>(constVal)->GetValue() != 0) {
+      return;
+    }
+    // opnd0 must be intrinsicop C___builtin_expect
+    BaseNode *opnd0 = condExpr->Opnd(0);
+    if (opnd0->GetOpCode() != OP_intrinsicop ||
+        static_cast<IntrinsicopNode*>(opnd0)->GetIntrinsic() != INTRN_C___builtin_expect) {
+      return;
+    }
+    // We trust constant fold
+    auto *expectedConstExpr = opnd0->Opnd(1);
+    if (expectedConstExpr->GetOpCode() == OP_cvt) {
+      expectedConstExpr = expectedConstExpr->Opnd(0);
+    }
+    if (expectedConstExpr->GetOpCode() != OP_constval) {
+      return;
+    }
+    auto *expectedConstNode = static_cast<ConstvalNode*>(expectedConstExpr)->GetConstVal();
+    CHECK_FATAL(expectedConstNode->GetKind() == kConstInt, "must be");
+    auto expectedVal = static_cast<MIRIntConst*>(expectedConstNode)->GetValue();
+    if (expectedVal != 0 && expectedVal != 1) {
+      return;
+    }
+    bool likelyTrue = (expectedVal == 1);  // The condition is likely to be true
+    bool likelyBranch = (brStmt.GetOpCode() == OP_brtrue ? likelyTrue : !likelyTrue);  // High probability jump
+    if (likelyBranch) {
+      brStmt.SetBranchProb(kProbLikely);
+    } else {
+      brStmt.SetBranchProb(kProbUnlikely);
+    }
+    // Remove __builtin_expect
+    condExpr->SetOpnd(opnd0->Opnd(0), 0);
+  }
+}
+
+void MIRLower::LowerBuiltinExpect(BlockNode &block) const {
+  auto *stmt = block.GetFirst();
+  auto *last = block.GetLast();
+  while (stmt != last) {
+    if (stmt->GetOpCode() == OP_brtrue || stmt->GetOpCode() == OP_brfalse) {
+      LowerCondGotoStmtWithBuiltinExpect(*static_cast<CondGotoNode*>(stmt));
+    }
+    stmt = stmt->GetNext();
+  }
+}
+
+LabelIdx MIRLower::CreateCondGotoStmt(Opcode op, BlockNode &blk, const IfStmtNode &ifStmt) {
+  auto *brStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(op);
+  brStmt->SetOpnd(ifStmt.Opnd(), 0);
+  brStmt->SetSrcPos(ifStmt.GetSrcPos());
+  LabelIdx lableIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(lableIdx);
+  brStmt->SetOffset(lableIdx);
+  blk.AddStatement(brStmt);
+  if (GetFuncProfData()) {
+    GetFuncProfData()->CopyStmtFreq(brStmt->GetStmtID(), ifStmt.GetStmtID());
+  }
+  bool thenEmpty = (ifStmt.GetThenPart() == nullptr) || (ifStmt.GetThenPart()->GetFirst() == nullptr);
+  if (thenEmpty) {
+    blk.AppendStatementsFromBlock(*ifStmt.GetElsePart());
+  } else {
+    blk.AppendStatementsFromBlock(*ifStmt.GetThenPart());
+  }
+  return lableIdx;
+}
+
+void MIRLower::CreateBrFalseStmt(BlockNode &blk, const IfStmtNode &ifStmt) {
+  LabelIdx labelIdx = CreateCondGotoStmt(OP_brfalse, blk, ifStmt);
+  auto *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  lableStmt->SetLabelIdx(labelIdx);
+  blk.AddStatement(lableStmt);
+  // set stmtfreqs
+  if (GetFuncProfData()) {
+    ASSERT(GetFuncProfData()->GetStmtFreq(ifStmt.GetThenPart()->GetStmtID()) >= 0, "sanity check");
+    int64_t freq = static_cast<int64_t>(GetFuncProfData()->GetStmtFreq(ifStmt.GetStmtID()) -
+        GetFuncProfData()->GetStmtFreq(ifStmt.GetThenPart()->GetStmtID()));
+    GetFuncProfData()->SetStmtFreq(lableStmt->GetStmtID(), static_cast<uint64_t>(freq));
+  }
+}
+
+void MIRLower::CreateBrTrueStmt(BlockNode &blk, const IfStmtNode &ifStmt) {
+  LabelIdx labelIdx = CreateCondGotoStmt(OP_brtrue, blk, ifStmt);
+  auto *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  lableStmt->SetLabelIdx(labelIdx);
+  blk.AddStatement(lableStmt);
+  // set stmtfreqs
+  if (GetFuncProfData()) {
+    ASSERT(GetFuncProfData()->GetStmtFreq(ifStmt.GetElsePart()->GetStmtID()) >= 0, "sanity check");
+    int64_t freq = static_cast<int64_t>(GetFuncProfData()->GetStmtFreq(ifStmt.GetStmtID()) -
+        GetFuncProfData()->GetStmtFreq(ifStmt.GetElsePart()->GetStmtID()));
+    GetFuncProfData()->SetStmtFreq(lableStmt->GetStmtID(), static_cast<uint64_t>(freq));
+  }
+}
+
+
+void MIRLower::CreateBrFalseAndGotoStmt(BlockNode &blk, const IfStmtNode &ifStmt) {
+  LabelIdx labelIdx = CreateCondGotoStmt(OP_brfalse, blk, ifStmt);
+  bool fallThroughFromThen = !IfStmtNoFallThrough(ifStmt);
+  LabelIdx gotoLableIdx = 0;
+  if (fallThroughFromThen) {
+    auto *gotoStmt = mirModule.CurFuncCodeMemPool()->New<GotoNode>(OP_goto);
+    gotoLableIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+    mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(gotoLableIdx);
+    gotoStmt->SetOffset(gotoLableIdx);
+    blk.AddStatement(gotoStmt);
+    // set stmtfreqs
+    if (GetFuncProfData()) {
+      GetFuncProfData()->CopyStmtFreq(gotoStmt->GetStmtID(), ifStmt.GetThenPart()->GetStmtID());
+    }
+  }
+  auto *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  lableStmt->SetLabelIdx(labelIdx);
+  blk.AddStatement(lableStmt);
+  blk.AppendStatementsFromBlock(*ifStmt.GetElsePart());
+  // set stmtfreqs
+  if (GetFuncProfData()) {
+    GetFuncProfData()->CopyStmtFreq(lableStmt->GetStmtID(), ifStmt.GetElsePart()->GetStmtID());
+  }
+  if (fallThroughFromThen) {
+    lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+    lableStmt->SetLabelIdx(gotoLableIdx);
+    blk.AddStatement(lableStmt);
+    // set endlabel stmtfreqs
+    if (GetFuncProfData()) {
+      GetFuncProfData()->CopyStmtFreq(lableStmt->GetStmtID(), ifStmt.GetStmtID());
+    }
+  }
+}
+
+BlockNode *MIRLower::LowerIfStmt(IfStmtNode &ifStmt, bool recursive) {
+  bool thenEmpty = (ifStmt.GetThenPart() == nullptr) || (ifStmt.GetThenPart()->GetFirst() == nullptr);
+  bool elseEmpty = (ifStmt.GetElsePart() == nullptr) || (ifStmt.GetElsePart()->GetFirst() == nullptr);
+  if (recursive) {
+    if (!thenEmpty) {
+      ifStmt.SetThenPart(LowerBlock(*ifStmt.GetThenPart()));
+    }
+    if (!elseEmpty) {
+      ifStmt.SetElsePart(LowerBlock(*ifStmt.GetElsePart()));
+    }
+  }
+  auto *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  if (thenEmpty && elseEmpty) {
+    // generate EVAL <cond> statement
+    auto *evalStmt = mirModule.CurFuncCodeMemPool()->New<UnaryStmtNode>(OP_eval);
+    evalStmt->SetOpnd(ifStmt.Opnd(), 0);
+    evalStmt->SetSrcPos(ifStmt.GetSrcPos());
+    blk->AddStatement(evalStmt);
+    if (GetFuncProfData()) {
+      GetFuncProfData()->CopyStmtFreq(evalStmt->GetStmtID(), ifStmt.GetStmtID());
+    }
+  } else if (elseEmpty) {
+    // brfalse <cond> <endlabel>
+    // <thenPart>
+    // label <endlabel>
+    CreateBrFalseStmt(*blk, ifStmt);
+  } else if (thenEmpty) {
+    // brtrue <cond> <endlabel>
+    // <elsePart>
+    // label <endlabel>
+    CreateBrTrueStmt(*blk, ifStmt);
+  } else {
+    // brfalse <cond> <elselabel>
+    // <thenPart>
+    // goto <endlabel>
+    // label <elselabel>
+    // <elsePart>
+    // label <endlabel>
+    CreateBrFalseAndGotoStmt(*blk, ifStmt);
+  }
+  return blk;
+}
+
+static bool ConsecutiveCaseValsAndSameTarget(const CaseVector *switchTable) {
+  size_t caseNum = switchTable->size();
+  int lastVal = static_cast<int>((*switchTable)[0].first);
+  LabelIdx lblIdx = (*switchTable)[0].second;
+  for (size_t id = 1; id < caseNum; id++) {
+    lastVal++;
+    if (lastVal != (*switchTable)[id].first) {
+      return false;
+    }
+    if (lblIdx != (*switchTable)[id].second) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// if there is only 1 case branch, replace with conditional branch(es) and
+// return the optimized multiple statements; otherwise, return nullptr
+BlockNode *MIRLower::LowerSwitchStmt(SwitchNode *switchNode) {
+  CaseVector *switchTable = &switchNode->GetSwitchTable();
+  if (switchNode->GetDefaultLabel() == 0) {
+    return nullptr;
+  }
+  if (switchTable->empty()) {  // goto @defaultLabel
+    BlockNode *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+    LabelIdx defaultLabel = switchNode->GetDefaultLabel();
+    MIRBuilder *builder = mirModule.GetMIRBuilder();
+    GotoNode *gotoStmt = builder->CreateStmtGoto(OP_goto, defaultLabel);
+    blk->AddStatement(gotoStmt);
+    return blk;
+  }
+  if (!ConsecutiveCaseValsAndSameTarget(switchTable)) {
+    return nullptr;
+  }
+  BlockNode *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  LabelIdx caseGotoLabel = switchTable->front().second;
+  LabelIdx defaultLabel = switchNode->GetDefaultLabel();
+  int64 minCaseVal = switchTable->front().first;
+  int64 maxCaseVal = switchTable->back().first;
+  BaseNode *switchOpnd = switchNode->Opnd(0);
+  MIRBuilder *builder = mirModule.GetMIRBuilder();
+  ConstvalNode *minCaseNode = builder->CreateIntConst(static_cast<uint64>(minCaseVal), switchOpnd->GetPrimType());
+  ConstvalNode *maxCaseNode = builder->CreateIntConst(static_cast<uint64>(maxCaseVal), switchOpnd->GetPrimType());
+  if (minCaseVal == maxCaseVal) {
+    // brtrue (x == minCaseVal) @case_goto_label
+    // goto @default_label
+    CompareNode *eqNode = builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetInt32(),
+        *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(switchOpnd->GetPrimType())), switchOpnd, minCaseNode);
+    CondGotoNode *condGoto = builder->CreateStmtCondGoto(eqNode, OP_brtrue, caseGotoLabel);
+    blk->AddStatement(condGoto);
+    GotoNode *gotoStmt = builder->CreateStmtGoto(OP_goto, defaultLabel);
+    blk->AddStatement(gotoStmt);
+  } else {
+    // brtrue (x < minCaseVal) @default_label
+    // brtrue (x > maxCaseVal) @default_label
+    // goto @case_goto_label
+    CompareNode *ltNode = builder->CreateExprCompare(OP_lt, *GlobalTables::GetTypeTable().GetInt32(),
+        *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(switchOpnd->GetPrimType())), switchOpnd, minCaseNode);
+    CondGotoNode *condGoto = builder->CreateStmtCondGoto(ltNode, OP_brtrue, defaultLabel);
+    blk->AddStatement(condGoto);
+    CompareNode *gtNode = builder->CreateExprCompare(OP_gt, *GlobalTables::GetTypeTable().GetInt32(),
+        *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(switchOpnd->GetPrimType())), switchOpnd, maxCaseNode);
+    condGoto = builder->CreateStmtCondGoto(gtNode, OP_brtrue, defaultLabel);
+    blk->AddStatement(condGoto);
+    GotoNode *gotoStmt = builder->CreateStmtGoto(OP_goto, caseGotoLabel);
+    blk->AddStatement(gotoStmt);
+  }
+  return blk;
+}
+
+//     while <cond> <body>
+// is lowered to:
+//     brfalse <cond> <endlabel>
+//   label <bodylabel>
+//     <body>
+//     brtrue <cond> <bodylabel>
+//   label <endlabel>
+BlockNode *MIRLower::LowerWhileStmt(WhileStmtNode &whileStmt) {
+  ASSERT(whileStmt.GetBody() != nullptr, "nullptr check");
+  whileStmt.SetBody(LowerBlock(*whileStmt.GetBody()));
+  auto *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  auto *brFalseStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brfalse);
+  brFalseStmt->SetOpnd(whileStmt.Opnd(0), 0);
+  brFalseStmt->SetSrcPos(whileStmt.GetSrcPos());
+  LabelIdx lalbeIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(lalbeIdx);
+  brFalseStmt->SetOffset(lalbeIdx);
+  blk->AddStatement(brFalseStmt);
+  blk->AppendStatementsFromBlock(*whileStmt.GetBody());
+  if (MeOption::optForSize) {
+    // still keep while-do format to avoid coping too much condition-related stmt
+    LabelIdx whileLalbeIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+    mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(whileLalbeIdx);
+    auto *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+    lableStmt->SetLabelIdx(whileLalbeIdx);
+    blk->InsertBefore(brFalseStmt, lableStmt);
+    auto *whilegotonode = mirModule.CurFuncCodeMemPool()->New<GotoNode>(OP_goto, whileLalbeIdx);
+    if (GetFuncProfData() && blk->GetLast()) {
+      GetFuncProfData()->CopyStmtFreq(whilegotonode->GetStmtID(), blk->GetLast()->GetStmtID());
+    }
+    blk->AddStatement(whilegotonode);
+  } else {
+    LabelIdx bodyLableIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+    mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(bodyLableIdx);
+    auto *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+    lableStmt->SetLabelIdx(bodyLableIdx);
+    blk->InsertAfter(brFalseStmt, lableStmt);
+    // update frequency
+    if (GetFuncProfData()) {
+      GetFuncProfData()->CopyStmtFreq(lableStmt->GetStmtID(), whileStmt.GetStmtID());
+      GetFuncProfData()->CopyStmtFreq(brFalseStmt->GetStmtID(), whileStmt.GetStmtID());
+    }
+    auto *brTrueStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brtrue);
+    brTrueStmt->SetOpnd(whileStmt.Opnd(0)->CloneTree(mirModule.GetCurFuncCodeMPAllocator()), 0);
+    brTrueStmt->SetOffset(bodyLableIdx);
+    if (GetFuncProfData() && blk->GetLast()) {
+      GetFuncProfData()->CopyStmtFreq(brTrueStmt->GetStmtID(), whileStmt.GetBody()->GetStmtID());
+    }
+    blk->AddStatement(brTrueStmt);
+  }
+  auto *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  lableStmt->SetLabelIdx(lalbeIdx);
+  blk->AddStatement(lableStmt);
+  if (GetFuncProfData()) {
+    int64_t freq = static_cast<int64_t>(GetFuncProfData()->GetStmtFreq(whileStmt.GetStmtID()) -
+        GetFuncProfData()->GetStmtFreq(blk->GetLast()->GetStmtID()));
+    ASSERT(freq >= 0, "sanity check");
+    GetFuncProfData()->SetStmtFreq(lableStmt->GetStmtID(), static_cast<uint64_t>(freq));
+  }
+  return blk;
+}
+
+//    doloop <do-var>(<start-expr>,<cont-expr>,<incr-amt>) {<body-stmts>}
+// is lowered to:
+//     dassign <do-var> (<start-expr>)
+//     brfalse <cond-expr> <endlabel>
+//   label <bodylabel>
+//     <body-stmts>
+//     dassign <do-var> (<incr-amt>)
+//     brtrue <cond-expr>  <bodylabel>
+//   label <endlabel>
+BlockNode *MIRLower::LowerDoloopStmt(DoloopNode &doloop) {
+  ASSERT(doloop.GetDoBody() != nullptr, "nullptr check");
+  doloop.SetDoBody(LowerBlock(*doloop.GetDoBody()));
+  int64_t doloopnodeFreq = 0;
+  int64_t bodynodeFreq = 0;
+  if (GetFuncProfData()) {
+    doloopnodeFreq = static_cast<int64_t>(GetFuncProfData()->GetStmtFreq(doloop.GetStmtID()));
+    bodynodeFreq = static_cast<int64_t>(GetFuncProfData()->GetStmtFreq(doloop.GetDoBody()->GetStmtID()));
+  }
+  auto *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  if (doloop.IsPreg()) {
+    PregIdx regIdx = static_cast<PregIdx>(doloop.GetDoVarStIdx().FullIdx());
+    MIRPreg *mirPreg = mirModule.CurFunction()->GetPregTab()->PregFromPregIdx(regIdx);
+    PrimType primType = mirPreg->GetPrimType();
+    ASSERT(primType != kPtyInvalid, "runtime check error");
+    auto *startRegassign = mirModule.CurFuncCodeMemPool()->New<RegassignNode>();
+    startRegassign->SetRegIdx(regIdx);
+    startRegassign->SetPrimType(primType);
+    startRegassign->SetOpnd(doloop.GetStartExpr(), 0);
+    startRegassign->SetSrcPos(doloop.GetSrcPos());
+    blk->AddStatement(startRegassign);
+  } else {
+    auto *startDassign = mirModule.CurFuncCodeMemPool()->New<DassignNode>();
+    startDassign->SetStIdx(doloop.GetDoVarStIdx());
+    startDassign->SetRHS(doloop.GetStartExpr());
+    startDassign->SetSrcPos(doloop.GetSrcPos());
+    blk->AddStatement(startDassign);
+  }
+  if (GetFuncProfData()) {
+    GetFuncProfData()->SetStmtFreq(blk->GetLast()->GetStmtID(), static_cast<uint64_t>(doloopnodeFreq - bodynodeFreq));
+  }
+  auto *brFalseStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brfalse);
+  brFalseStmt->SetOpnd(doloop.GetCondExpr(), 0);
+  LabelIdx lIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(lIdx);
+  brFalseStmt->SetOffset(lIdx);
+  blk->AddStatement(brFalseStmt);
+  // udpate stmtFreq
+  if (GetFuncProfData()) {
+    GetFuncProfData()->SetStmtFreq(brFalseStmt->GetStmtID(), static_cast<uint64_t>(doloopnodeFreq - bodynodeFreq));
+  }
+  LabelIdx bodyLabelIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(bodyLabelIdx);
+  auto *labelStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  labelStmt->SetLabelIdx(bodyLabelIdx);
+  blk->AddStatement(labelStmt);
+  // udpate stmtFreq
+  if (GetFuncProfData()) {
+    GetFuncProfData()->SetStmtFreq(labelStmt->GetStmtID(), static_cast<uint64_t>(bodynodeFreq));
+  }
+  blk->AppendStatementsFromBlock(*doloop.GetDoBody());
+  if (doloop.IsPreg()) {
+    PregIdx regIdx = (PregIdx)doloop.GetDoVarStIdx().FullIdx();
+    MIRPreg *mirPreg = mirModule.CurFunction()->GetPregTab()->PregFromPregIdx(regIdx);
+    PrimType doVarPType = mirPreg->GetPrimType();
+    ASSERT(doVarPType != kPtyInvalid, "runtime check error");
+    auto *readDoVar = mirModule.CurFuncCodeMemPool()->New<RegreadNode>();
+    readDoVar->SetRegIdx(regIdx);
+    readDoVar->SetPrimType(doVarPType);
+    auto *add =
+        mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add, doVarPType, doloop.GetIncrExpr(), readDoVar);
+    auto *endRegassign = mirModule.CurFuncCodeMemPool()->New<RegassignNode>();
+    endRegassign->SetRegIdx(regIdx);
+    endRegassign->SetPrimType(doVarPType);
+    endRegassign->SetOpnd(add, 0);
+    blk->AddStatement(endRegassign);
+  } else {
+    const MIRSymbol *doVarSym = mirModule.CurFunction()->GetLocalOrGlobalSymbol(doloop.GetDoVarStIdx());
+    PrimType doVarPType = doVarSym->GetType()->GetPrimType();
+    auto *readDovar =
+        mirModule.CurFuncCodeMemPool()->New<DreadNode>(OP_dread, doVarPType, doloop.GetDoVarStIdx(), 0);
+    auto *add =
+        mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add, doVarPType, readDovar, doloop.GetIncrExpr());
+    auto *endDassign = mirModule.CurFuncCodeMemPool()->New<DassignNode>();
+    endDassign->SetStIdx(doloop.GetDoVarStIdx());
+    endDassign->SetRHS(add);
+    blk->AddStatement(endDassign);
+  }
+  auto *brTrueStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brtrue);
+  brTrueStmt->SetOpnd(doloop.GetCondExpr()->CloneTree(mirModule.GetCurFuncCodeMPAllocator()), 0);
+  brTrueStmt->SetOffset(bodyLabelIdx);
+  blk->AddStatement(brTrueStmt);
+  // udpate stmtFreq
+  if (GetFuncProfData()) {
+    GetFuncProfData()->SetStmtFreq(brTrueStmt->GetStmtID(), static_cast<uint64_t>(bodynodeFreq));
+  }
+  labelStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  labelStmt->SetLabelIdx(lIdx);
+  blk->AddStatement(labelStmt);
+  // udpate stmtFreq
+  if (GetFuncProfData()) {
+    GetFuncProfData()->SetStmtFreq(labelStmt->GetStmtID(), static_cast<uint64_t>(doloopnodeFreq - bodynodeFreq));
+  }
+  return blk;
+}
+
+//     dowhile <body> <cond>
+// is lowered to:
+//   label <bodylabel>
+//     <body>
+//     brtrue <cond> <bodylabel>
+BlockNode *MIRLower::LowerDowhileStmt(WhileStmtNode &doWhileStmt) {
+  ASSERT(doWhileStmt.GetBody() != nullptr, "nullptr check");
+  doWhileStmt.SetBody(LowerBlock(*doWhileStmt.GetBody()));
+  auto *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  LabelIdx lIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(lIdx);
+  auto *labelStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  labelStmt->SetLabelIdx(lIdx);
+  blk->AddStatement(labelStmt);
+  blk->AppendStatementsFromBlock(*doWhileStmt.GetBody());
+  auto *brTrueStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brtrue);
+  brTrueStmt->SetOpnd(doWhileStmt.Opnd(0), 0);
+  brTrueStmt->SetOffset(lIdx);
+  blk->AddStatement(brTrueStmt);
+  return blk;
+}
+
+BlockNode *MIRLower::LowerBlock(BlockNode &block) {
+  auto *newBlock = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  newBlock->SetSrcPos(block.GetSrcPos());
+  BlockNode *tmp = nullptr;
+  if (block.GetFirst() == nullptr) {
+    newBlock->SetStmtID(block.GetStmtID()); // keep original block stmtid
+    return newBlock;
+  }
+  StmtNode *nextStmt = block.GetFirst();
+  ASSERT(nextStmt != nullptr, "nullptr check");
+  do {
+    StmtNode *stmt = nextStmt;
+    nextStmt = stmt->GetNext();
+    switch (stmt->GetOpCode()) {
+      case OP_if:
+        tmp = LowerIfStmt(static_cast<IfStmtNode&>(*stmt), true);
+        newBlock->AppendStatementsFromBlock(*tmp);
+        break;
+      case OP_switch:
+        tmp = LowerSwitchStmt(static_cast<SwitchNode *>(stmt));
+        if (tmp != nullptr) {
+          newBlock->AppendStatementsFromBlock(*tmp);
+        } else {
+          newBlock->AddStatement(stmt);
+        }
+        break;
+      case OP_while:
+        newBlock->AppendStatementsFromBlock(*LowerWhileStmt(static_cast<WhileStmtNode&>(*stmt)));
+        break;
+      case OP_dowhile:
+        newBlock->AppendStatementsFromBlock(*LowerDowhileStmt(static_cast<WhileStmtNode&>(*stmt)));
+        break;
+      case OP_doloop:
+        newBlock->AppendStatementsFromBlock(*LowerDoloopStmt(static_cast<DoloopNode&>(*stmt)));
+        break;
+      case OP_icallassigned:
+      case OP_icall: {
+        if (mirModule.IsCModule()) {
+          // convert to icallproto/icallprotoassigned
+          IcallNode *ic = static_cast<IcallNode *>(stmt);
+          ic->SetOpCode(stmt->GetOpCode() == OP_icall ? OP_icallproto : OP_icallprotoassigned);
+          MIRFuncType *funcType = FuncTypeFromFuncPtrExpr(stmt->Opnd(0));
+          CHECK_FATAL(funcType != nullptr, "MIRLower::LowerBlock: cannot find prototype for icall");
+          ic->SetRetTyIdx(funcType->GetTypeIndex());
+          MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx());
+          if (retType->GetPrimType() == PTY_agg && retType->GetSize() > k16BitSize) {
+            funcType->funcAttrs.SetAttr(FUNCATTR_firstarg_return);
+          }
+        }
+        newBlock->AddStatement(stmt);
+        break;
+      }
+      case OP_block:
+        tmp = LowerBlock(static_cast<BlockNode&>(*stmt));
+        newBlock->AppendStatementsFromBlock(*tmp);
+        break;
+      default:
+        newBlock->AddStatement(stmt);
+        break;
+    }
+  } while (nextStmt != nullptr);
+  newBlock->SetStmtID(block.GetStmtID()); // keep original block stmtid
+  return newBlock;
+}
+
+// for lowering OP_cand and OP_cior embedded in the expression x which belongs
+// to curstmt
+BaseNode* MIRLower::LowerEmbeddedCandCior(BaseNode *x, StmtNode *curstmt, BlockNode *blk) {
+  if (x->GetOpCode() == OP_cand || x->GetOpCode() == OP_cior) {
+    MIRBuilder *builder = mirModule.GetMIRBuilder();
+    BinaryNode *bnode = static_cast<BinaryNode *>(x);
+    bnode->SetOpnd(LowerEmbeddedCandCior(bnode->Opnd(0), curstmt, blk), 0);
+    PregIdx pregIdx = mirFunc->GetPregTab()->CreatePreg(x->GetPrimType());
+    RegassignNode *regass = builder->CreateStmtRegassign(x->GetPrimType(), pregIdx, bnode->Opnd(0));
+    blk->InsertBefore(curstmt, regass);
+    LabelIdx labIdx = mirFunc->GetLabelTab()->CreateLabel();
+    mirFunc->GetLabelTab()->AddToStringLabelMap(labIdx);
+    BaseNode *cond = builder->CreateExprRegread(x->GetPrimType(), pregIdx);
+    CondGotoNode *cgoto = mirFunc->GetCodeMempool()->New<CondGotoNode>(
+        x->GetOpCode() == OP_cior ? OP_brtrue : OP_brfalse);
+    cgoto->SetOpnd(cond, 0);
+    cgoto->SetOffset(labIdx);
+    blk->InsertBefore(curstmt, cgoto);
+
+    bnode->SetOpnd(LowerEmbeddedCandCior(bnode->Opnd(1), curstmt, blk), 1);
+    regass = builder->CreateStmtRegassign(x->GetPrimType(), pregIdx, bnode->Opnd(1));
+    blk->InsertBefore(curstmt, regass);
+    LabelNode *lbl = mirFunc->GetCodeMempool()->New<LabelNode>();
+    lbl->SetLabelIdx(labIdx);
+    blk->InsertBefore(curstmt, lbl);
+    return builder->CreateExprRegread(x->GetPrimType(), pregIdx);
+  } else {
+    for (size_t i = 0; i < x->GetNumOpnds(); i++) {
+      x->SetOpnd(LowerEmbeddedCandCior(x->Opnd(i), curstmt, blk), i);
+    }
+    return x;
+  }
+}
+
+// for lowering all appearances of OP_cand and OP_cior associated with condional
+// branches in the block
+void MIRLower::LowerCandCior(BlockNode &block) {
+if (block.GetFirst() == nullptr) {
+  return;
+}
+StmtNode *nextStmt = block.GetFirst();
+do {
+  StmtNode *stmt = nextStmt;
+  nextStmt = stmt->GetNext();
+  if (stmt->IsCondBr() &&
+      (stmt->Opnd(0)->GetOpCode() == OP_cand || stmt->Opnd(0)->GetOpCode() == OP_cior)) {
+    CondGotoNode *condGoto = static_cast<CondGotoNode*>(stmt);
+    BinaryNode *cond = static_cast<BinaryNode*>(condGoto->Opnd(0));
+    if ((stmt->GetOpCode() == OP_brfalse && cond->GetOpCode() == OP_cand) ||
+        (stmt->GetOpCode() == OP_brtrue && cond->GetOpCode() == OP_cior)) {
+      // short-circuit target label is same as original condGoto stmt
+        condGoto->SetOpnd(cond->GetBOpnd(0), 0);
+        auto *newCondGoto = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(Opcode(stmt->GetOpCode()));
+        newCondGoto->SetOpnd(cond->GetBOpnd(1), 0);
+        newCondGoto->SetOffset(condGoto->GetOffset());
+        block.InsertAfter(condGoto, newCondGoto);
+        nextStmt = stmt;  // so it will be re-processed if another cand/cior
+      } else {            // short-circuit target is next statement
+        LabelIdx lIdx;
+        LabelNode *labelStmt = nullptr;
+        if (nextStmt->GetOpCode() == OP_label) {
+          labelStmt = static_cast<LabelNode*>(nextStmt);
+          lIdx = labelStmt->GetLabelIdx();
+        } else {
+          lIdx = mirModule.CurFunction()->GetLabelTab()->CreateLabel();
+          mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(lIdx);
+          labelStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+          labelStmt->SetLabelIdx(lIdx);
+          block.InsertAfter(condGoto, labelStmt);
+        }
+        auto *newCondGoto = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(
+            stmt->GetOpCode() == OP_brfalse ? OP_brtrue : OP_brfalse);
+        newCondGoto->SetOpnd(cond->GetBOpnd(0), 0);
+        newCondGoto->SetOffset(lIdx);
+        block.InsertBefore(condGoto, newCondGoto);
+        condGoto->SetOpnd(cond->GetBOpnd(1), 0);
+        nextStmt = newCondGoto;  // so it will be re-processed if another cand/cior
+      }
+    } else {  // call LowerEmbeddedCandCior() for all the expression operands
+      for (size_t i = 0; i < stmt->GetNumOpnds(); i++) {
+        stmt->SetOpnd(LowerEmbeddedCandCior(stmt->Opnd(i), stmt, &block), i);
+      }
+    }
+  } while (nextStmt != nullptr);
+}
+
+void MIRLower::LowerFunc(MIRFunction &func) {
+  if (GetOptLevel() > 0) {
+    ExtConstantFold ecf(func.GetModule());
+    (void)ecf.ExtSimplify(func.GetBody());
+  }
+
+  mirModule.SetCurFunction(&func);
+  if (IsLowerExpandArray()) {
+    ExpandArrayMrt(func);
+  }
+  BlockNode *origBody = func.GetBody();
+  ASSERT(origBody != nullptr, "nullptr check");
+  BlockNode *newBody = LowerBlock(*origBody);
+  ASSERT(newBody != nullptr, "nullptr check");
+  LowerBuiltinExpect(*newBody);
+  if (!InLFO()) {
+    LowerCandCior(*newBody);
+  }
+  func.SetBody(newBody);
+}
+
+BaseNode *MIRLower::LowerFarray(ArrayNode *array) {
+  auto *farrayType = static_cast<MIRFarrayType*>(array->GetArrayType(GlobalTables::GetTypeTable()));
+  size_t eSize = GlobalTables::GetTypeTable().GetTypeFromTyIdx(farrayType->GetElemTyIdx())->GetSize();
+  MIRType &arrayType = *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array->GetPrimType()));
+  /* how about multi-dimension array? */
+  if (array->GetIndex(0)->GetOpCode() == OP_constval) {
+    const ConstvalNode *constvalNode = static_cast<const ConstvalNode*>(array->GetIndex(0));
+    if (constvalNode->GetConstVal()->GetKind() == kConstInt) {
+      const MIRIntConst *pIntConst = static_cast<const MIRIntConst*>(constvalNode->GetConstVal());
+      CHECK_FATAL(mirModule.IsJavaModule() || !pIntConst->IsNegative(), "Array index should >= 0.");
+      int64 eleOffset = pIntConst->GetExtValue() * static_cast<int64_t>(eSize);
+
+      BaseNode *baseNode = array->GetBase();
+      if (eleOffset == 0) {
+        return baseNode;
+      }
+
+      MIRIntConst *eleConst =
+          GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<uint64_t>(eleOffset), arrayType);
+      BaseNode *offsetNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(eleConst);
+      offsetNode->SetPrimType(array->GetPrimType());
+
+      BaseNode *rAdd = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add);
+      rAdd->SetPrimType(array->GetPrimType());
+      rAdd->SetOpnd(baseNode, 0);
+      rAdd->SetOpnd(offsetNode, 1);
+      return rAdd;
+    }
+  }
+
+  BaseNode *rMul = nullptr;
+
+  BaseNode *baseNode = array->GetBase();
+
+  BaseNode *rAdd = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add);
+  rAdd->SetPrimType(array->GetPrimType());
+  rAdd->SetOpnd(baseNode, 0);
+  rAdd->SetOpnd(rMul, 1);
+  auto *newAdd = ConstantFold(mirModule).Fold(rAdd);
+  rAdd = (newAdd != nullptr ? newAdd : rAdd);
+  return rAdd;
+}
+
+BaseNode *MIRLower::LowerCArray(ArrayNode *array) {
+  MIRType *aType = array->GetArrayType(GlobalTables::GetTypeTable());
+  if (aType->GetKind() == kTypeJArray) {
+    return array;
+  }
+  if (aType->GetKind() == kTypeFArray) {
+    return LowerFarray(array);
+  }
+
+  MIRArrayType *arrayType = static_cast<MIRArrayType *>(aType);
+  /* There are two cases where dimension > 1.
+   * 1) arrayType->dim > 1.  Process the current arrayType. (nestedArray = false)
+   * 2) arrayType->dim == 1, but arraytype->eTyIdx is another array. (nestedArray = true)
+   * Assume at this time 1) and 2) cannot mix.
+   * Along with the array dimension, there is the array indexing.
+   * It is allowed to index arrays less than the dimension.
+   * This is dictated by the number of indexes.
+   */
+  bool nestedArray = false;
+  uint64 dim = arrayType->GetDim();
+  MIRType *innerType = nullptr;
+  MIRArrayType *innerArrayType = nullptr;
+  uint64 elemSize = 0;
+  if (dim == 1) {
+    innerType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrayType->GetElemTyIdx());
+    if (innerType->GetKind() == kTypeArray) {
+      nestedArray = true;
+      do {
+        innerArrayType = static_cast<MIRArrayType *>(innerType);
+        elemSize = RoundUp(innerArrayType->GetElemType()->GetSize(),
+                           arrayType->GetElemType()->GetAlign());
+        dim++;
+        innerType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(innerArrayType->GetElemTyIdx());
+      } while (innerType->GetKind() == kTypeArray);
+    }
+  }
+
+  size_t numIndex = array->NumOpnds() - 1;
+  MIRArrayType *curArrayType = arrayType;
+  BaseNode *resNode = array->GetIndex(0);
+  if (dim > 1) {
+    BaseNode *prevNode = nullptr;
+    for (size_t i = 0; (i < dim) && (i < numIndex); ++i) {
+      uint32 mpyDim = 1;
+      if (nestedArray) {
+        CHECK_FATAL(arrayType->GetSizeArrayItem(0) > 0, "Zero size array dimension");
+        innerType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(curArrayType->GetElemTyIdx());
+        curArrayType = static_cast<MIRArrayType *>(innerType);
+        while (innerType->GetKind() == kTypeArray) {
+          innerArrayType = static_cast<MIRArrayType *>(innerType);
+          mpyDim *= innerArrayType->GetSizeArrayItem(0);
+          innerType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(innerArrayType->GetElemTyIdx());
+        }
+      } else {
+        CHECK_FATAL(arrayType->GetSizeArrayItem(static_cast<uint32>(i)) > 0, "Zero size array dimension");
+        for (size_t j = i + 1; j < dim; ++j) {
+          mpyDim *= arrayType->GetSizeArrayItem(static_cast<uint32>(j));
+        }
+      }
+
+      BaseNode *index = static_cast<ConstvalNode *>(array->GetIndex(i));
+      bool isConst = false;
+      uint64 indexVal = 0;
+      if (index->op == OP_constval) {
+        ConstvalNode *constNode = static_cast<ConstvalNode *>(index);
+        indexVal = static_cast<uint64>((static_cast<MIRIntConst *>(constNode->GetConstVal()))->GetExtValue());
+        isConst = true;
+        MIRIntConst *newConstNode = mirModule.GetMemPool()->New<MIRIntConst>(
+            indexVal * mpyDim, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array->GetPrimType())));
+        BaseNode *newValNode = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(newConstNode);
+        newValNode->SetPrimType(array->GetPrimType());
+        if (i == 0) {
+          prevNode = newValNode;
+          continue;
+        } else {
+          resNode = newValNode;
+        }
+      }
+      if (i > 0 && isConst == false) {
+        resNode = array->GetIndex(i);
+      }
+
+      BaseNode *mpyNode;
+      if (isConst) {
+        MIRIntConst *mulConst = mirModule.GetMemPool()->New<MIRIntConst>(
+            static_cast<int64>(mpyDim) * indexVal,
+            *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array->GetPrimType())));
+        BaseNode *mulSize = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(mulConst);
+        mulSize->SetPrimType(array->GetPrimType());
+        mpyNode = mulSize;
+      } else if (mpyDim == 1 && prevNode) {
+        mpyNode = prevNode;
+        prevNode = resNode;
+      } else {
+        mpyNode = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_mul);
+        mpyNode->SetPrimType(array->GetPrimType());
+        MIRIntConst *mulConst = mirModule.GetMemPool()->New<MIRIntConst>(
+            mpyDim, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array->GetPrimType())));
+        BaseNode *mulSize = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(mulConst);
+        mulSize->SetPrimType(array->GetPrimType());
+        mpyNode->SetOpnd(mulSize, 1);
+        PrimType signedInt4AddressCompute = GetSignedPrimType(array->GetPrimType());
+        if (!IsPrimitiveInteger(resNode->GetPrimType())) {
+          resNode = mirModule.CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, signedInt4AddressCompute,
+              resNode->GetPrimType(), resNode);
+        } else if (GetPrimTypeSize(resNode->GetPrimType()) != GetPrimTypeSize(array->GetPrimType())) {
+          resNode = mirModule.CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, array->GetPrimType(),
+              GetRegPrimType(resNode->GetPrimType()), resNode);
+        }
+        mpyNode->SetOpnd(resNode, 0);
+      }
+      if (i == 0) {
+        prevNode = mpyNode;
+        continue;
+      }
+      BaseNode *newResNode = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_add);
+      newResNode->SetPrimType(array->GetPrimType());
+      newResNode->SetOpnd(mpyNode, 0);
+      if (NeedCvtOrRetype(prevNode->GetPrimType(), array->GetPrimType())) {
+        prevNode = mirModule.CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, array->GetPrimType(),
+            GetRegPrimType(prevNode->GetPrimType()), prevNode);
+      }
+      newResNode->SetOpnd(prevNode, 1);
+      prevNode = newResNode;
+    }
+    resNode = prevNode;
+  }
+
+  BaseNode *rMul = nullptr;
+  // esize is the size of the array element (eg. int = 4 long = 8)
+  uint64 esize;
+  if (nestedArray) {
+    esize = elemSize;
+  } else {
+    esize = arrayType->GetElemType()->GetSize();
+  }
+  Opcode opadd = OP_add;
+  MIRIntConst *econst = mirModule.GetMemPool()->New<MIRIntConst>(esize,
+      *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(array->GetPrimType())));
+  BaseNode *eSize = mirModule.CurFuncCodeMemPool()->New<ConstvalNode>(econst);
+  eSize->SetPrimType(array->GetPrimType());
+  rMul = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_mul);
+  PrimType signedInt4AddressCompute = GetSignedPrimType(array->GetPrimType());
+  if (!IsPrimitiveInteger(resNode->GetPrimType())) {
+    resNode = mirModule.CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, signedInt4AddressCompute,
+        resNode->GetPrimType(), resNode);
+  } else if (GetPrimTypeSize(resNode->GetPrimType()) != GetPrimTypeSize(array->GetPrimType())) {
+    resNode = mirModule.CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, array->GetPrimType(),
+        GetRegPrimType(resNode->GetPrimType()), resNode);
+  }
+  rMul->SetPrimType(resNode->GetPrimType());
+  rMul->SetOpnd(resNode, 0);
+  rMul->SetOpnd(eSize, 1);
+  BaseNode *baseNode = array->GetBase();
+  BaseNode *rAdd = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(opadd);
+  rAdd->SetPrimType(array->GetPrimType());
+  rAdd->SetOpnd(baseNode, 0);
+  rAdd->SetOpnd(rMul, 1);
+  auto *newAdd = ConstantFold(mirModule).Fold(rAdd);
+  rAdd = (newAdd != nullptr ? newAdd : rAdd);
+  return rAdd;
+}
+
+IfStmtNode *MIRLower::ExpandArrayMrtIfBlock(IfStmtNode &node) {
+  if (node.GetThenPart() != nullptr) {
+    node.SetThenPart(ExpandArrayMrtBlock(*node.GetThenPart()));
+  }
+  if (node.GetElsePart() != nullptr) {
+    node.SetElsePart(ExpandArrayMrtBlock(*node.GetElsePart()));
+  }
+  return &node;
+}
+
+WhileStmtNode *MIRLower::ExpandArrayMrtWhileBlock(WhileStmtNode &node) {
+  if (node.GetBody() != nullptr) {
+    node.SetBody(ExpandArrayMrtBlock(*node.GetBody()));
+  }
+  return &node;
+}
+
+DoloopNode *MIRLower::ExpandArrayMrtDoloopBlock(DoloopNode &node) {
+  if (node.GetDoBody() != nullptr) {
+    node.SetDoBody(ExpandArrayMrtBlock(*node.GetDoBody()));
+  }
+  return &node;
+}
+
+ForeachelemNode *MIRLower::ExpandArrayMrtForeachelemBlock(ForeachelemNode &node) {
+  if (node.GetLoopBody() != nullptr) {
+    node.SetLoopBody(ExpandArrayMrtBlock(*node.GetLoopBody()));
+  }
+  return &node;
+}
+
+void MIRLower::AddArrayMrtMpl(BaseNode &exp, BlockNode &newBlock) {
+  MIRModule &mod = mirModule;
+  MIRBuilder *builder = mod.GetMIRBuilder();
+  for (size_t i = 0; i < exp.NumOpnds(); ++i) {
+    ASSERT(exp.Opnd(i) != nullptr, "nullptr check");
+    AddArrayMrtMpl(*exp.Opnd(i), newBlock);
+  }
+  if (exp.GetOpCode() == OP_array) {
+    auto &arrayNode = static_cast<ArrayNode&>(exp);
+    if (arrayNode.GetBoundsCheck()) {
+      BaseNode *arrAddr = arrayNode.Opnd(0);
+      BaseNode *index = arrayNode.Opnd(1);
+      ASSERT(index != nullptr, "null ptr check");
+      MIRType *indexType = GlobalTables::GetTypeTable().GetPrimType(index->GetPrimType());
+      UnaryStmtNode *nullCheck = builder->CreateStmtUnary(OP_assertnonnull, arrAddr);
+      newBlock.AddStatement(nullCheck);
+#if DO_LT_0_CHECK
+      ConstvalNode *indexZero = builder->GetConstUInt32(0);
+      CompareNode *lessZero = builder->CreateExprCompare(OP_lt, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                         *GlobalTables::GetTypeTable().GetUInt32(), index, indexZero);
+#endif
+      MIRType *infoLenType = GlobalTables::GetTypeTable().GetInt32();
+      MapleVector<BaseNode*> arguments(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+      arguments.push_back(arrAddr);
+      BaseNode *arrLen = builder->CreateExprIntrinsicop(INTRN_JAVA_ARRAY_LENGTH, OP_intrinsicop,
+                                                        *infoLenType, arguments);
+      BaseNode *cpmIndex = index;
+      if (arrLen->GetPrimType() != index->GetPrimType()) {
+        cpmIndex = builder->CreateExprTypeCvt(OP_cvt, *infoLenType, *indexType, index);
+      }
+      CompareNode *largeLen = builder->CreateExprCompare(OP_ge, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                         *GlobalTables::GetTypeTable().GetUInt32(), cpmIndex, arrLen);
+      // maybe should use cior
+#if DO_LT_0_CHECK
+      BinaryNode *indexCon =
+          builder->CreateExprBinary(OP_lior, *GlobalTables::GetTypeTable().GetUInt1(), lessZero, largeLen);
+#endif
+      MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+#if DO_LT_0_CHECK
+      args.push_back(indexCon);
+      IntrinsiccallNode *boundaryTrinsicCall = builder->CreateStmtIntrinsicCall(INTRN_MPL_BOUNDARY_CHECK, args);
+#else
+      args.push_back(largeLen);
+      IntrinsiccallNode *boundaryTrinsicCall = builder->CreateStmtIntrinsicCall(INTRN_MPL_BOUNDARY_CHECK, args);
+#endif
+      newBlock.AddStatement(boundaryTrinsicCall);
+    }
+  }
+}
+
+BlockNode *MIRLower::ExpandArrayMrtBlock(BlockNode &block) {
+  auto *newBlock = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  if (block.GetFirst() == nullptr) {
+    return newBlock;
+  }
+  StmtNode *nextStmt = block.GetFirst();
+  do {
+    StmtNode *stmt = nextStmt;
+    ASSERT(stmt != nullptr, "nullptr check");
+    nextStmt = stmt->GetNext();
+    switch (stmt->GetOpCode()) {
+      case OP_if:
+        newBlock->AddStatement(ExpandArrayMrtIfBlock(static_cast<IfStmtNode&>(*stmt)));
+        break;
+      case OP_while:
+        newBlock->AddStatement(ExpandArrayMrtWhileBlock(static_cast<WhileStmtNode&>(*stmt)));
+        break;
+      case OP_dowhile:
+        newBlock->AddStatement(ExpandArrayMrtWhileBlock(static_cast<WhileStmtNode&>(*stmt)));
+        break;
+      case OP_doloop:
+        newBlock->AddStatement(ExpandArrayMrtDoloopBlock(static_cast<DoloopNode&>(*stmt)));
+        break;
+      case OP_foreachelem:
+        newBlock->AddStatement(ExpandArrayMrtForeachelemBlock(static_cast<ForeachelemNode&>(*stmt)));
+        break;
+      case OP_block:
+        newBlock->AddStatement(ExpandArrayMrtBlock(static_cast<BlockNode&>(*stmt)));
+        break;
+      default:
+        AddArrayMrtMpl(*stmt, *newBlock);
+        newBlock->AddStatement(stmt);
+        break;
+    }
+  } while (nextStmt != nullptr);
+  return newBlock;
+}
+
+void MIRLower::ExpandArrayMrt(MIRFunction &func) {
+  if (ShouldOptArrayMrt(func)) {
+    BlockNode *origBody = func.GetBody();
+    ASSERT(origBody != nullptr, "nullptr check");
+    BlockNode *newBody = ExpandArrayMrtBlock(*origBody);
+    func.SetBody(newBody);
+  }
+}
+
+MIRFuncType *MIRLower::FuncTypeFromFuncPtrExpr(BaseNode *x) {
+  MIRFuncType *res = nullptr;
+  MIRFunction *func = mirModule.CurFunction();
+  switch (x->GetOpCode()) {
+    case OP_regread: {
+      RegreadNode *regread = static_cast<RegreadNode *>(x);
+      MIRPreg *preg = func->GetPregTab()->PregFromPregIdx(regread->GetRegIdx());
+      // see if it is promoted from a symbol
+      if (preg->GetOp() == OP_dread) {
+        const MIRSymbol *symbol = preg->rematInfo.sym;
+        MIRType *mirType = symbol->GetType();
+        if (preg->fieldID != 0) {
+          MIRStructType *structty = static_cast<MIRStructType *>(mirType);
+          FieldPair thepair = structty->TraverseToField(preg->fieldID);
+          mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(thepair.second.first);
+        }
+
+        if (mirType->GetKind() == kTypePointer) {
+          res = static_cast<MIRPtrType *>(mirType)->GetPointedFuncType();
+        }
+        if (res != nullptr) {
+          break;
+        }
+      }
+      // check if a formal promoted to preg
+      for (FormalDef &formalDef : func->GetFormalDefVec()) {
+        if (!formalDef.formalSym->IsPreg()) {
+          continue;
+        }
+        if (formalDef.formalSym->GetPreg() == preg) {
+          MIRType *mirType = formalDef.formalSym->GetType();
+          if (mirType->GetKind() == kTypePointer) {
+            res = static_cast<MIRPtrType *>(mirType)->GetPointedFuncType();
+          }
+          break;
+        }
+      }
+      break;
+    }
+    case OP_dread: {
+      DreadNode *dread = static_cast<DreadNode *>(x);
+      MIRSymbol *symbol = func->GetLocalOrGlobalSymbol(dread->GetStIdx());
+      MIRType *mirType = symbol->GetType();
+      if (dread->GetFieldID() != 0) {
+        MIRStructType *structty = static_cast<MIRStructType *>(mirType);
+        FieldPair thepair = structty->TraverseToField(dread->GetFieldID());
+        mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(thepair.second.first);
+      }
+      if (mirType->GetKind() == kTypePointer) {
+        res = static_cast<MIRPtrType *>(mirType)->GetPointedFuncType();
+      }
+      break;
+    }
+    case OP_iread: {
+      IreadNode *iread = static_cast<IreadNode *>(x);
+      MIRPtrType *ptrType = static_cast<MIRPtrType *>(iread->GetType());
+      MIRType *mirType = ptrType->GetPointedType();
+      if (mirType->GetKind() == kTypeFunction) {
+        res = static_cast<MIRFuncType *>(mirType);
+      } else if (mirType->GetKind() == kTypePointer) {
+        res = static_cast<MIRPtrType *>(mirType)->GetPointedFuncType();
+      }
+      break;
+    }
+    case OP_addroffunc: {
+      AddroffuncNode *addrofFunc = static_cast<AddroffuncNode *>(x);
+      PUIdx puIdx = addrofFunc->GetPUIdx();
+      MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+      res = f->GetMIRFuncType();
+      break;
+    }
+    case OP_retype: {
+      MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(
+          static_cast<RetypeNode*>(x)->GetTyIdx());
+      if (mirType->GetKind() == kTypePointer) {
+        res = static_cast<MIRPtrType *>(mirType)->GetPointedFuncType();
+      }
+      if (res == nullptr) {
+        res = FuncTypeFromFuncPtrExpr(x->Opnd(kNodeFirstOpnd));
+      }
+      break;
+    }
+    case OP_select: {
+      res = FuncTypeFromFuncPtrExpr(x->Opnd(kNodeSecondOpnd));
+      if (res == nullptr) {
+        res = FuncTypeFromFuncPtrExpr(x->Opnd(kNodeThirdOpnd));
+      }
+      break;
+    }
+    default: CHECK_FATAL(false, "LMBCLowerer::FuncTypeFromFuncPtrExpr: NYI");
+  }
+  return res;
+}
+
+const std::set<std::string> MIRLower::kSetArrayHotFunc = {};
+
+bool MIRLower::ShouldOptArrayMrt(const MIRFunction &func) {
+  return (MIRLower::kSetArrayHotFunc.find(func.GetName()) != MIRLower::kSetArrayHotFunc.end());
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_module.cpp b/src/mapleall/maple_ir/src/mir_module.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..334216779e569324ef8089266952982f60ae6564
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_module.cpp
@@ -0,0 +1,803 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_module.h"
+#include "mir_const.h"
+#include "mir_preg.h"
+#include "mir_function.h"
+#include "mir_builder.h"
+#include "debug_info.h"
+#include "intrinsics.h"
+#include "bin_mplt.h"
+
+namespace maple {
+#if MIR_FEATURE_FULL  // to avoid compilation error when MIR_FEATURE_FULL=0
+MIRModule::MIRModule(const std::string &fn)
+    : memPool(new ThreadShareMemPool(memPoolCtrler, "maple_ir mempool")),
+      pragmaMemPool(memPoolCtrler.NewMemPool("pragma mempool", false /* isLcalPool */)),
+      memPoolAllocator(memPool),
+      pragmaMemPoolAllocator(pragmaMemPool),
+      inlineSummaryAlloc(memPoolCtrler.NewMemPool("inline summary mempool", false)),
+      functionList(memPoolAllocator.Adapter()),
+      importedMplt(memPoolAllocator.Adapter()),
+      typeDefOrder(memPoolAllocator.Adapter()),
+      externStructTypeSet(std::less<TyIdx>(), memPoolAllocator.Adapter()),
+      symbolSet(std::less<StIdx>(), memPoolAllocator.Adapter()),
+      symbolDefOrder(memPoolAllocator.Adapter()),
+      out(LogInfo::MapleLogger()),
+      fileName(fn),
+      fileInfo(memPoolAllocator.Adapter()),
+      fileInfoIsString(memPoolAllocator.Adapter()),
+      fileData(memPoolAllocator.Adapter()),
+      srcFileInfo(memPoolAllocator.Adapter()),
+      importFiles(memPoolAllocator.Adapter()),
+      importPaths(memPoolAllocator.Adapter()),
+      asmDecls(memPoolAllocator.Adapter()),
+      classList(memPoolAllocator.Adapter()),
+      optimizedFuncs(memPoolAllocator.Adapter()),
+      optimizedFuncsType(memPoolAllocator.Adapter()),
+      puIdxFieldInitializedMap(std::less<PUIdx>(), memPoolAllocator.Adapter()),
+      inliningGlobals(memPoolAllocator.Adapter()),
+      partO2FuncList(memPoolAllocator.Adapter()),
+      safetyWarningMap(memPoolAllocator.Adapter()) {
+  GlobalTables::GetGsymTable().SetModule(this);
+  typeNameTab = memPool->New<MIRTypeNameTable>(memPoolAllocator);
+  mirBuilder = memPool->New<MIRBuilder>(this);
+  dbgInfo = memPool->New<DebugInfo>(this);
+  scope = memPool->New<MIRScope>(this, nullptr);
+  scope->SetIsLocal(false);
+  IntrinDesc::InitMIRModule(this);
+}
+
+MIRModule::~MIRModule() {
+  for (MIRFunction *mirFunc : functionList) {
+    mirFunc->ReleaseCodeMemory();
+  }
+  ReleasePragmaMemPool();
+  delete memPool;
+  delete binMplt;
+
+  // inlineSummaryAlloc is supposed to be released just after inlining.
+  // The following code is to ensure unexpected memory leak.
+  ReleaseInlineSummaryAlloc();
+}
+
+MemPool *MIRModule::CurFuncCodeMemPool() const {
+  if (useFuncCodeMemPoolTmp) {
+    return CurFunction()->GetCodeMemPoolTmp();
+  }
+  return CurFunction()->GetCodeMemPool();
+}
+
+MapleAllocator *MIRModule::CurFuncCodeMemPoolAllocator() const {
+  MIRFunction *curFunc = CurFunction();
+  CHECK_FATAL(curFunc != nullptr, "curFunction is null");
+  return &curFunc->GetCodeMempoolAllocator();
+}
+
+MapleAllocator &MIRModule::GetCurFuncCodeMPAllocator() const {
+  MIRFunction *curFunc = CurFunction();
+  CHECK_FATAL(curFunc != nullptr, "curFunction is null");
+  return curFunc->GetCodeMPAllocator();
+}
+
+void MIRModule::AddExternStructType(TyIdx tyIdx) {
+  (void)externStructTypeSet.insert(tyIdx);
+}
+
+void MIRModule::AddExternStructType(const MIRType *t) {
+  ASSERT(t != nullptr, "MIRType is null");
+  (void)externStructTypeSet.insert(t->GetTypeIndex());
+}
+
+void MIRModule::AddSymbol(StIdx stIdx) {
+  auto it = symbolSet.find(stIdx);
+  if (it == symbolSet.end()) {
+    symbolDefOrder.push_back(stIdx);
+  }
+  (void)symbolSet.insert(stIdx);
+}
+
+void MIRModule::AddSymbol(const MIRSymbol *s) {
+  ASSERT(s != nullptr, "s is null");
+  AddSymbol(s->GetStIdx());
+}
+
+void MIRModule::DumpGlobals(bool emitStructureType) const {
+  if (flavor != kFlavorUnknown) {
+    LogInfo::MapleLogger() << "flavor " << flavor << '\n';
+  }
+  if (srcLang != kSrcLangUnknown) {
+    LogInfo::MapleLogger() << "srclang " << srcLang << '\n';
+  }
+  LogInfo::MapleLogger() << "id " << id << '\n';
+  if (globalMemSize != 0) {
+    LogInfo::MapleLogger() << "globalmemsize " << globalMemSize << '\n';
+  }
+  if (globalBlkMap != nullptr) {
+    LogInfo::MapleLogger() << "globalmemmap = [ ";
+    auto *p = reinterpret_cast<uint32*>(globalBlkMap);
+    LogInfo::MapleLogger() << std::hex;
+    while (p < reinterpret_cast<uint32*>(globalBlkMap + globalMemSize)) {
+      LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
+      p++;
+    }
+    LogInfo::MapleLogger() << std::dec << "]\n";
+  }
+  if (globalWordsTypeTagged != nullptr) {
+    LogInfo::MapleLogger() << "globalwordstypetagged = [ ";
+    auto *p = reinterpret_cast<uint32*>(globalWordsTypeTagged);
+    LogInfo::MapleLogger() << std::hex;
+    while (p < reinterpret_cast<uint32*>(globalWordsTypeTagged + BlockSize2BitVectorSize(globalMemSize))) {
+      LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
+      ++p;
+    }
+    LogInfo::MapleLogger() << std::dec << "]\n";
+  }
+  if (globalWordsRefCounted != nullptr) {
+    LogInfo::MapleLogger() << "globalwordsrefcounted = [ ";
+    auto *p = reinterpret_cast<uint32*>(globalWordsRefCounted);
+    LogInfo::MapleLogger() << std::hex;
+    while (p < reinterpret_cast<uint32*>(globalWordsRefCounted + BlockSize2BitVectorSize(globalMemSize))) {
+      LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
+      ++p;
+    }
+    LogInfo::MapleLogger() << std::dec << "]\n";
+  }
+  LogInfo::MapleLogger() << "numfuncs " << numFuncs << '\n';
+  if (!importFiles.empty()) {
+    // Output current module's mplt on top, imported ones at below
+    for (auto it = importFiles.rbegin(); it != importFiles.rend(); ++it) {
+      LogInfo::MapleLogger() << "import \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(*it) << "\"\n";
+    }
+  }
+  if (!importPaths.empty()) {
+    size_t size = importPaths.size();
+    for (size_t i = 0; i < size; ++i) {
+      LogInfo::MapleLogger() << "importpath \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(importPaths[i])
+                             << "\"\n";
+    }
+  }
+  if (!asmDecls.empty()) {
+    size_t size = asmDecls.size();
+    for (size_t i = 0; i < size; ++i) {
+      LogInfo::MapleLogger() << "asmdecl ";
+      EmitStr(asmDecls[i]);
+    }
+  }
+  if (entryFuncName.length() != 0) {
+    LogInfo::MapleLogger() << "entryfunc &" << entryFuncName << '\n';
+  }
+  if (!fileInfo.empty()) {
+    LogInfo::MapleLogger() << "fileinfo {\n";
+    size_t size = fileInfo.size();
+    for (size_t i = 0; i < size; ++i) {
+      LogInfo::MapleLogger() << "  @" << GlobalTables::GetStrTable().GetStringFromStrIdx(fileInfo[i].first) << " ";
+      if (!fileInfoIsString[i]) {
+        LogInfo::MapleLogger() << "0x" << std::hex << fileInfo[i].second;
+      } else {
+        LogInfo::MapleLogger() << "\"" << GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(fileInfo[i].second))
+                               << "\"";
+      }
+      if (i < size - 1) {
+        LogInfo::MapleLogger() << ",\n";
+      } else {
+        LogInfo::MapleLogger() << "}\n";
+      }
+    }
+    LogInfo::MapleLogger() << std::dec;
+  }
+  if (!srcFileInfo.empty()) {
+    LogInfo::MapleLogger() << "srcfileinfo {\n";
+    size_t size = srcFileInfo.size();
+    size_t i = 0;
+    for (auto infoElem : srcFileInfo) {
+      LogInfo::MapleLogger() << "  " << infoElem.second;
+      LogInfo::MapleLogger() << " \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(infoElem.first) << "\"";
+      if (i++ < size - 1) {
+        LogInfo::MapleLogger() << ",\n";
+      } else {
+        LogInfo::MapleLogger() << "}\n";
+      }
+    }
+  }
+  if (!fileData.empty()) {
+    LogInfo::MapleLogger() << "filedata {\n";
+    size_t size = fileData.size();
+    for (size_t i = 0; i < size; ++i) {
+      LogInfo::MapleLogger() << "  @" << GlobalTables::GetStrTable().GetStringFromStrIdx(fileData[i].first) << " ";
+      size_t dataSize = fileData[i].second.size();
+      for (size_t j = 0; j < dataSize; ++j) {
+        uint8 data = fileData[i].second[j];
+        LogInfo::MapleLogger() << "0x" << std::hex << static_cast<uint32>(data);
+        if (j < dataSize - 1) {
+          LogInfo::MapleLogger() << ' ';
+        }
+      }
+      if (i < size - 1) {
+        LogInfo::MapleLogger() << ",\n";
+      } else {
+        LogInfo::MapleLogger() << "}\n";
+      }
+    }
+    LogInfo::MapleLogger() << std::dec;
+  }
+  GlobalTables::GetEnumTable().Dump();
+  if (flavor < kMmpl || flavor == kFlavorLmbc) {
+    for (auto it = typeDefOrder.begin(); it != typeDefOrder.end(); ++it) {
+      TyIdx tyIdx = typeNameTab->GetTyIdxFromGStrIdx(*it);
+      const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(*it);
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+      ASSERT(type != nullptr, "type should not be nullptr here");
+      bool isStructType = type->IsStructType();
+      if (isStructType) {
+        auto *structType = static_cast<MIRStructType*>(type);
+        // still emit what in extern_structtype_set_
+        if (!emitStructureType && externStructTypeSet.find(structType->GetTypeIndex()) == externStructTypeSet.end()) {
+          continue;
+        }
+        if (structType->IsImported()) {
+          continue;
+        }
+      }
+
+      LogInfo::MapleLogger() << "type $" << name << " ";
+      if (type->GetKind() == kTypeByName) {
+        LogInfo::MapleLogger() << "void";
+      } else if (type->GetNameStrIdx() == *it) {
+        type->Dump(1, true);
+      } else {
+        type->Dump(1);
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+    if (someSymbolNeedForwDecl) {
+      // an extra pass thru the global symbol table to print forward decl
+      for (auto sit = symbolSet.begin(); sit != symbolSet.end(); ++sit) {
+        MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx((*sit).Idx());
+        if (s->IsNeedForwDecl()) {
+          s->Dump(false, 0, true);
+        }
+      }
+    }
+    // dump javaclass and javainterface first
+    for (auto sit = symbolDefOrder.begin(); sit != symbolDefOrder.end(); ++sit) {
+      MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx((*sit).Idx());
+      ASSERT(s != nullptr, "null ptr check");
+      if (!s->IsJavaClassInterface()) {
+        continue;
+      }
+      // Verify: all wpofake variables should have been deleted from globaltable
+      if (!s->IsDeleted()) {
+        s->Dump(false, 0);
+      }
+    }
+    for (auto sit = symbolDefOrder.begin(); sit != symbolDefOrder.end(); ++sit) {
+      MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx((*sit).Idx());
+      CHECK_FATAL(s != nullptr, "nullptr check");
+      if (s->IsJavaClassInterface()) {
+        continue;
+      }
+      if (!s->IsDeleted() && !s->GetIsImported() && !s->GetIsImportedDecl()) {
+        s->Dump(false, 0);
+      }
+    }
+    if (scope && !scope->IsEmpty()) {
+      scope->Dump(0);
+    }
+  }
+}
+
+void MIRModule::Dump(bool emitStructureType, const std::unordered_set<std::string> *dumpFuncSet) const {
+  DumpGlobals(emitStructureType);
+  DumpFunctionList(dumpFuncSet);
+}
+
+void MIRModule::DumpGlobalArraySymbol() const {
+  for (StIdx stIdx : symbolSet) {
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+    ASSERT(symbol != nullptr, "null ptr check");
+    MIRType *symbolType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(symbol->GetTyIdx());
+    ASSERT(symbolType != nullptr, "null ptr check");
+    if (symbolType == nullptr || symbolType->GetKind() != kTypeArray) {
+      continue;
+    }
+    symbol->Dump(false, 0);
+  }
+}
+
+void MIRModule::Emit(const std::string &outFileName) const {
+  std::ofstream file;
+  // Change cout's buffer to file.
+  std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+  LogInfo::MapleLogger().rdbuf(file.rdbuf());
+  file.open(outFileName, std::ios::trunc);
+  DumpGlobals();
+  for (MIRFunction *mirFunc : functionList) {
+    mirFunc->Dump();
+  }
+  // Restore cout's buffer.
+  LogInfo::MapleLogger().rdbuf(backup);
+  file.close();
+}
+
+void MIRModule::DumpFunctionList(const std::unordered_set<std::string> *dumpFuncSet) const {
+  MIRSymbol::LastPrintedLineNumRef() = 0;
+  MIRSymbol::LastPrintedColumnNumRef() = 0;
+  for (MIRFunction *mirFunc : functionList) {
+    if (dumpFuncSet == nullptr || dumpFuncSet->empty()) {
+      mirFunc->Dump();
+    } else {  // dump only if this func matches any name in *dumpFuncSet
+      const std::string &name = mirFunc->GetName();
+      bool matched = false;
+      for (std::string elem : *dumpFuncSet) {
+        if (name.find(elem.c_str()) != std::string::npos) {
+          matched = true;
+          break;
+        }
+      }
+      if (matched) {
+        mirFunc->Dump();
+      }
+    }
+  }
+}
+
+void MIRModule::OutputFunctionListAsciiMpl(const std::string &phaseName) {
+  std::string fileStem;
+  std::string::size_type lastDot = fileName.find_last_of('.');
+  if (lastDot == std::string::npos) {
+    fileStem = fileName.append(phaseName);
+  } else {
+    fileStem = fileName.substr(0, lastDot).append(phaseName);
+  }
+  std::string outfileName;
+  if (flavor >= kMmpl) {
+    outfileName = fileStem.append(".mmpl");
+  } else {
+    outfileName = fileStem.append(".mpl");
+  }
+  std::ofstream mplFile;
+  mplFile.open(outfileName, std::ios::app);
+  std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+  LogInfo::MapleLogger().rdbuf(mplFile.rdbuf());  // change cout's buffer to that of file
+  DumpGlobalArraySymbol();
+  DumpFunctionList(nullptr);
+  LogInfo::MapleLogger().rdbuf(backup);  // restore cout's buffer
+  mplFile.close();
+}
+
+void MIRModule::DumpToFile(const std::string &fileNameStr, bool emitStructureType) const {
+  std::ofstream file;
+  file.open(fileNameStr, std::ios::trunc);
+  if (!file.is_open()) {
+    ERR(kLncErr, "Cannot open %s", fileNameStr.c_str());
+    return;
+  }
+  // Change cout's buffer to file.
+  std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+  LogInfo::MapleLogger().rdbuf(file.rdbuf());
+  Dump(emitStructureType);
+  // Restore cout's buffer.
+  LogInfo::MapleLogger().rdbuf(backup);
+  file.close();
+}
+
+void MIRModule::DumpDefType() {
+  for (auto it = typeDefOrder.begin(); it != typeDefOrder.end(); ++it) {
+    TyIdx tyIdx = typeNameTab->GetTyIdxFromGStrIdx(*it);
+    const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(*it);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    ASSERT(type != nullptr, "type should not be nullptr here");
+    bool isStructType = type->IsStructType();
+    if (isStructType) {
+      auto *structType = static_cast<MIRStructType*>(type);
+      if (structType->IsImported()) {
+        continue;
+      }
+    }
+    LogInfo::MapleLogger() << "type $" << name << " ";
+    if (type->GetKind() == kTypeByName) {
+      LogInfo::MapleLogger() << "void";
+    } else if (type->GetNameStrIdx() == *it) {
+      type->Dump(1, true);
+    } else {
+      type->Dump(1);
+    }
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+void MIRModule::DumpInlineCandidateToFile(const std::string &fileNameStr) {
+  if (optimizedFuncs.empty()) {
+    return;
+  }
+  std::ofstream file;
+  // Change cout's buffer to file.
+  std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+  LogInfo::MapleLogger().rdbuf(file.rdbuf());
+  file.open(fileNameStr, std::ios::trunc);
+  if (IsCModule()) {
+    DumpDefType();
+  }
+  // dump global variables needed for inlining file
+  for (auto symbolIdx : inliningGlobals) {
+    MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolIdx);
+    ASSERT(s != nullptr, "null ptr check");
+    if (s->GetStorageClass() == kScFstatic) {
+      if (s->IsNeedForwDecl()) {
+        // const string, including initialization
+        s->Dump(false, 0, false);
+      }
+    }
+  }
+  for (auto symbolIdx : inliningGlobals) {
+    MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolIdx);
+    ASSERT(s != nullptr, "null ptr check");
+    MIRStorageClass sc = s->GetStorageClass();
+    if (s->GetStorageClass() == kScFstatic) {
+      if (!s->IsNeedForwDecl()) {
+        // const string, including initialization
+        s->Dump(false, 0, false);
+      }
+    } else if (s->GetSKind() == kStFunc) {
+      s->GetFunction()->Dump(true);
+    } else {
+      // static fields as extern
+      s->SetStorageClass(kScExtern);
+      s->Dump(false, 0, true);
+    }
+    s->SetStorageClass(sc);
+  }
+  for (auto *func : optimizedFuncs) {
+    func->SetWithLocInfo(false);
+    func->Dump();
+  }
+  // Restore cout's buffer.
+  LogInfo::MapleLogger().rdbuf(backup);
+  file.close();
+}
+
+// This is not efficient. Only used in debug mode for now.
+const std::string &MIRModule::GetFileNameFromFileNum(uint32 fileNum) const {
+  GStrIdx nameIdx(0);
+  for (auto &info : srcFileInfo) {
+    if (info.second == fileNum) {
+      nameIdx = info.first;
+      break;
+    }
+  }
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(nameIdx);
+}
+
+void MIRModule::DumpToHeaderFile(bool binaryMplt, const std::string &outputName) {
+  std::string outfileName;
+  std::string fileNameLocal = !outputName.empty() ? outputName : fileName;
+  std::string::size_type lastDot = fileNameLocal.find_last_of('.');
+  if (lastDot == std::string::npos) {
+    outfileName = fileNameLocal.append(".mplt");
+  } else {
+    outfileName = fileNameLocal.substr(0, lastDot).append(".mplt");
+  }
+  if (binaryMplt) {
+    BinaryMplt binaryMpltTmp(*this);
+    binaryMpltTmp.Export(outfileName);
+  } else {
+    std::ofstream mpltFile;
+    mpltFile.open(outfileName, std::ios::trunc);
+    std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+    LogInfo::MapleLogger().rdbuf(mpltFile.rdbuf());  // change cout's buffer to that of file
+    for (std::pair<std::u16string, MIRSymbol*> entity : GlobalTables::GetConstPool().GetConstU16StringPool()) {
+      LogInfo::MapleLogger() << "var $";
+      entity.second->DumpAsLiteralVar();
+      LogInfo::MapleLogger() << '\n';
+    }
+    for (auto it = classList.begin(); it != classList.end(); ++it) {
+      TyIdx curTyIdx(*it);
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(curTyIdx);
+      const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(type->GetNameStrIdx());
+      if (type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface) {
+        auto *structType = static_cast<MIRStructType*>(type);
+        // skip imported class/interface and incomplete types
+        if (!structType->IsImported() && !structType->IsIncomplete()) {
+          LogInfo::MapleLogger() << "type $" << name << " ";
+          type->Dump(1, true);
+          LogInfo::MapleLogger() << '\n';
+        }
+      }
+    }
+    /* restore cout */
+    LogInfo::MapleLogger().rdbuf(backup);
+    mpltFile.close();
+  }
+}
+
+/*
+    We use MIRStructType (kTypeStruct) to represent C/C++ structs
+    as well as C++ classes.
+
+    We use MIRClassType (kTypeClass) to represent Java classes, specifically.
+    MIRClassType has parents which encode Java class's parent (exploiting
+    the fact Java classes have at most one parent class.
+ */
+void MIRModule::DumpTypeTreeToCxxHeaderFile(MIRType &ty, std::unordered_set<MIRType*> &dumpedClasses) const {
+  if (dumpedClasses.find(&ty) != dumpedClasses.end()) {
+    return;
+  }
+  // first, insert ty to the dumped_classes to prevent infinite recursion
+  (void)dumpedClasses.insert(&ty);
+  ASSERT(ty.GetKind() == kTypeClass || ty.GetKind() == kTypeStruct || ty.GetKind() == kTypeUnion ||
+             ty.GetKind() == kTypeInterface,
+         "Unexpected MIRType.");
+  /* No need to emit interfaces; because "interface variables are
+     final and static by default and methods are public and abstract"
+   */
+  if (ty.GetKind() == kTypeInterface) {
+    return;
+  }
+  // dump all of its parents
+  if (IsJavaModule()) {
+    ASSERT(ty.GetKind() != kTypeStruct, "type is not supposed to be struct");
+    ASSERT(ty.GetKind() != kTypeUnion, "type is not supposed to be union");
+    ASSERT(ty.GetKind() != kTypeInterface, "type is not supposed to be interface");
+  } else if (srcLang == kSrcLangC || srcLang == kSrcLangCPlusPlus) {
+    ASSERT((ty.GetKind() == kTypeStruct || ty.GetKind() == kTypeUnion), "type should be either struct or union");
+  } else {
+    ASSERT(false, "source languages other than DEX/C/C++ are not supported yet");
+  }
+  const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(ty.GetNameStrIdx());
+  if (IsJavaModule()) {
+    // Java class has at most one parent
+    auto &classType = static_cast<MIRClassType&>(ty);
+    MIRClassType *parentType = nullptr;
+    // find parent and generate its type as well as those of its ancestors
+    if (classType.GetParentTyIdx() != 0u /* invalid type idx */) {
+      parentType = static_cast<MIRClassType*>(
+          GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType.GetParentTyIdx()));
+      CHECK_FATAL(parentType != nullptr, "nullptr check");
+      DumpTypeTreeToCxxHeaderFile(*parentType, dumpedClasses);
+    }
+    LogInfo::MapleLogger() << "struct " << name << " ";
+    if (parentType != nullptr) {
+      LogInfo::MapleLogger() << ": " << parentType->GetName() << " ";
+    }
+    if (!classType.IsIncomplete()) {
+      /* dump class type; it will dump as '{ ... }' */
+      classType.DumpAsCxx(1);
+      LogInfo::MapleLogger() << ";\n";
+    } else {
+      LogInfo::MapleLogger() << "  /* incomplete type */\n";
+    }
+  } else if (srcLang == kSrcLangC || srcLang == kSrcLangCPlusPlus) {
+    // how to access parent fields????
+    ASSERT(false, "not yet implemented");
+  }
+}
+
+void MIRModule::DumpToCxxHeaderFile(std::set<std::string> &leafClasses, const std::string &pathToOutf) const {
+  std::ofstream mpltFile;
+  mpltFile.open(pathToOutf, std::ios::trunc);
+  std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+  LogInfo::MapleLogger().rdbuf(mpltFile.rdbuf());  // change cout's buffer to that of file
+  char *headerGuard = strdup(pathToOutf.c_str());
+  CHECK_FATAL(headerGuard != nullptr, "strdup failed");
+  for (char *p = headerGuard; p != nullptr && *p != 0; ++p) {
+    if (!isalnum(*p)) {
+      *p = '_';
+    } else if (isalpha(*p) && islower(*p)) {
+      *p = toupper(*p);
+    }
+  }
+  // define a hash table
+  std::unordered_set<MIRType*> dumpedClasses;
+  const char *prefix = "__SRCLANG_UNKNOWN_";
+  if (IsJavaModule()) {
+    prefix = "__SRCLANG_JAVA_";
+  } else if (srcLang == kSrcLangC || srcLang == kSrcLangCPlusPlus) {
+    prefix = "__SRCLANG_CXX_";
+  }
+  LogInfo::MapleLogger() << "#ifndef " << prefix << headerGuard << "__\n";
+  LogInfo::MapleLogger() << "#define " << prefix << headerGuard << "__\n";
+  LogInfo::MapleLogger() << "/* this file is compiler-generated; do not edit */\n\n";
+  LogInfo::MapleLogger() << "#include <stdint.h>\n";
+  LogInfo::MapleLogger() << "#include <complex.h>\n";
+  for (auto &s : leafClasses) {
+    CHECK_FATAL(!s.empty(), "string is null");
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(s);
+    TyIdx tyIdx = typeNameTab->GetTyIdxFromGStrIdx(strIdx);
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    if (ty == nullptr) {
+      continue;
+    }
+    ASSERT(ty->GetKind() == kTypeClass || ty->GetKind() == kTypeStruct || ty->GetKind() == kTypeUnion ||
+               ty->GetKind() == kTypeInterface,
+           "");
+    DumpTypeTreeToCxxHeaderFile(*ty, dumpedClasses);
+  }
+  LogInfo::MapleLogger() << "#endif /* " << prefix << headerGuard << "__ */\n";
+  /* restore cout */
+  LogInfo::MapleLogger().rdbuf(backup);
+  free(headerGuard);
+  headerGuard = nullptr;
+  mpltFile.close();
+}
+
+void MIRModule::DumpClassToFile(const std::string &path) const {
+  std::string strPath(path);
+  strPath.append("/");
+  for (auto it : typeNameTab->GetGStrIdxToTyIdxMap()) {
+    const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(it.first);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(it.second);
+    std::string outClassFile(name);
+    /* replace class name / with - */
+    std::replace(outClassFile.begin(), outClassFile.end(), '/', '-');
+    (void)outClassFile.insert(0, strPath);
+    outClassFile.append(".mpl");
+    std::ofstream mplFile;
+    mplFile.open(outClassFile, std::ios::trunc);
+    std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+    LogInfo::MapleLogger().rdbuf(mplFile.rdbuf());
+    /* dump class type */
+    LogInfo::MapleLogger() << "type $" << name << " ";
+    if (type->GetNameStrIdx() == it.first && type->GetKind() != kTypeByName) {
+      type->Dump(1, true);
+    } else {
+      type->Dump(1);
+    }
+    LogInfo::MapleLogger() << '\n';
+    /* restore cout */
+    LogInfo::MapleLogger().rdbuf(backup);
+    mplFile.close();;
+  }
+}
+
+MIRFunction *MIRModule::FindEntryFunction() {
+  for (MIRFunction *currFunc : functionList) {
+    if (currFunc->GetName() == entryFuncName) {
+      entryFunc = currFunc;
+      return currFunc;
+    }
+  }
+  return nullptr;
+}
+
+// given the phase name (including '.' at beginning), output the program in the
+// module to the file with given file suffix, and file stem from
+// this->fileName appended with phaseName
+void MIRModule::OutputAsciiMpl(const char *phaseName, const char *suffix,
+                               const std::unordered_set<std::string> *dumpFuncSet,
+                               bool emitStructureType, bool binaryform) {
+  ASSERT(!(emitStructureType && binaryform), "Cannot emit type info in .bpl");
+  std::string fileStem;
+  std::string::size_type lastDot = fileName.find_last_of('.');
+  if (lastDot == std::string::npos) {
+    fileStem = fileName.append(phaseName);
+  } else {
+    fileStem = fileName.substr(0, lastDot).append(phaseName);
+  }
+  std::string outfileName = fileStem + suffix;
+  if (!binaryform) {
+    std::ofstream mplFile;
+    mplFile.open(outfileName, std::ios::trunc);
+    std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+    LogInfo::MapleLogger().rdbuf(mplFile.rdbuf());  // change LogInfo::MapleLogger()'s buffer to that of file
+    Dump(emitStructureType, dumpFuncSet);
+    LogInfo::MapleLogger().rdbuf(backup);  // restore LogInfo::MapleLogger()'s buffer
+    mplFile.close();
+  } else {
+    BinaryMplt binaryMplt(*this);
+    binaryMplt.GetBinExport().not2mplt = true;
+    binaryMplt.Export(outfileName);
+  }
+  std::ofstream mplFile;
+  mplFile.open(outfileName, std::ios::trunc);
+  std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+  LogInfo::MapleLogger().rdbuf(mplFile.rdbuf());  // change cout's buffer to that of file
+  Dump(emitStructureType);
+  if (withDbgInfo) {
+    dbgInfo->Dump(0);
+  }
+  LogInfo::MapleLogger().rdbuf(backup);  // restore cout's buffer
+  mplFile.close();
+}
+
+uint32 MIRModule::GetFileinfo(GStrIdx strIdx) const {
+  for (auto &infoElem : fileInfo) {
+    if (infoElem.first == strIdx) {
+      return infoElem.second;
+    }
+  }
+  ASSERT(false, "should not be here");
+  return 0;
+}
+
+std::string MIRModule::GetFileNameAsPostfix() const {
+  std::string fileNameStr = namemangler::kFileNameSplitterStr;
+  if (!fileInfo.empty()) {
+    // option 1: file name in INFO
+    uint32 fileNameIdx = GetFileinfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_filename"));
+    fileNameStr += GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(fileNameIdx));
+  } else {
+    // option 2: src file name removing ext name.
+    if (GetSrcFileInfo().size() != 0) {
+      GStrIdx idx = GetSrcFileInfo()[0].first;
+      const std::string kStr = GlobalTables::GetStrTable().GetStringFromStrIdx(idx);
+      ASSERT(kStr.find_last_of('.') != kStr.npos, "not found .");
+      fileNameStr += kStr.substr(0, kStr.find_last_of('.'));
+    } else {
+      ASSERT(0, "No fileinfo and no srcfileinfo in mpl file");
+    }
+  }
+  for (char &c : fileNameStr) {
+    if (!isalpha(c) && !isdigit(c) && c != '_' && c != '$') {
+      c = '_';
+    }
+  }
+  return fileNameStr;
+}
+
+void MIRModule::AddClass(TyIdx tyIdx) {
+  (void)classList.insert(tyIdx);
+}
+
+void MIRModule::RemoveClass(TyIdx tyIdx) {
+  (void)classList.erase(tyIdx);
+}
+
+#endif  // MIR_FEATURE_FULL
+void MIRModule::ReleaseCurFuncMemPoolTmp() const {
+  CurFunction()->ReleaseMemory();
+}
+
+void MIRModule::SetFuncInfoPrinted() const {
+  CurFunction()->SetInfoPrinted();
+}
+
+void MIRModule::InitPartO2List(const std::string &list) {
+  if (list.empty()) {
+    return;
+  }
+  SetHasPartO2List(true);
+  std::ifstream infile(list);
+  if (!infile.is_open()) {
+    LogInfo::MapleLogger(kLlErr) << "Cannot open partO2 function list file " << list << '\n';
+    return;
+  }
+  std::string str;
+
+  while (getline(infile, str)) {
+    if (str.empty()) {
+      continue;
+    }
+    GStrIdx funcStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
+    partO2FuncList.insert(funcStrIdx);
+  }
+  infile.close();
+}
+
+bool MIRModule::HasNotWarned(uint32 position, uint32 stmtOriginalID) {
+  auto warnedOp = safetyWarningMap.find(position);
+  if (warnedOp == safetyWarningMap.end()) {
+    MapleSet<uint32> opSet(memPoolAllocator.Adapter());
+    opSet.emplace(stmtOriginalID);
+    safetyWarningMap.emplace(std::pair<uint32, MapleSet<uint32>>(position, std::move(opSet)));
+    return true;
+  }
+  if (warnedOp->second.find(stmtOriginalID) == warnedOp->second.end()) {
+    warnedOp->second.emplace(stmtOriginalID);
+    return true;
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_nodes.cpp b/src/mapleall/maple_ir/src/mir_nodes.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7a03023d8561fdb8f4ec9c78a7b808a8b74e3a5b
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_nodes.cpp
@@ -0,0 +1,2698 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_nodes.h"
+
+#include <algorithm>
+#include <stack>
+
+#include "maple_string.h"
+#include "mir_function.h"
+#include "namemangler.h"
+#include "opcode_info.h"
+#include "printing.h"
+#include "utils.h"
+#include "verification.h"
+
+namespace maple {
+MIRModule *theMIRModule = nullptr;
+std::list<BlockCallBack*> BlockCallBackMgr::callBackList;
+std::atomic<uint32> StmtNode::stmtIDNext(1);  // 0 is reserved
+uint32 StmtNode::lastPrintedLineNum = 0;
+uint16 StmtNode::lastPrintedColumnNum = 0;
+const int32 CondGotoNode::probAll = 10000;
+
+const char *GetIntrinsicName(MIRIntrinsicID intrn) {
+  switch (intrn) {
+    default:
+#define DEF_MIR_INTRINSIC(STR, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ...) \
+  case INTRN_##STR:                                                           \
+    return #STR;
+#include "intrinsics.def"
+#undef DEF_MIR_INTRINSIC
+  }
+}
+
+const char *BaseNode::GetOpName() const {
+  return kOpcodeInfo.GetTableItemAt(GetOpCode()).name.c_str();
+}
+
+bool BaseNode::MayThrowException() const {
+  if (kOpcodeInfo.MayThrowException(GetOpCode())) {
+    if (GetOpCode() != OP_array) {
+      return true;
+    }
+    const ArrayNode *arry = static_cast<const ArrayNode*>(this);
+    if (arry->GetBoundsCheck()) {
+      return true;
+    }
+  } else if (GetOpCode() == OP_intrinsicop) {
+    const IntrinsicopNode *inNode = static_cast<const IntrinsicopNode*>(this);
+    if (inNode->GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH) {
+      return true;
+    }
+  }
+  for (size_t i = 0; i < NumOpnds(); ++i) {
+    if (Opnd(i)->MayThrowException()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AddrofNode::CheckNode(const MIRModule &mod) const {
+  const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(GetStIdx());
+  ASSERT(st != nullptr, "null ptr check");
+  MIRType *ty = st->GetType();
+  switch (ty->GetKind()) {
+    case kTypeScalar: {
+#ifdef DYNAMICLANG
+      if (GetPrimType() == PTY_dynany) {
+        return true;
+      }
+      return IsPrimitiveScalar(GetPrimType());
+#else
+      return IsPrimitiveScalar(GetPrimType());
+#endif
+    }
+    case kTypeArray: {
+      return GetPrimType() == PTY_agg;
+    }
+    case kTypeUnion:
+    case kTypeStruct:
+    case kTypeStructIncomplete: {
+      if (GetFieldID() == 0) {
+        return GetPrimType() == PTY_agg;
+      }
+      auto *structType = static_cast<MIRStructType*>(ty);
+      TyIdx fTyIdx = structType->GetFieldTyIdx(fieldID);
+      MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fTyIdx);
+      MIRTypeKind subKind = subType->GetKind();
+      return (subKind == kTypeBitField && VerifyPrimType(subType->GetPrimType(), GetPrimType())) ||
+             (subKind == kTypeScalar && IsPrimitiveScalar(GetPrimType())) ||
+             (subKind == kTypePointer && IsPrimitivePoint(GetPrimType())) ||
+             (subKind == kTypeStruct && GetPrimType() == PTY_agg) || (fTyIdx != 0u && GetPrimType() == PTY_agg);
+    }
+    case kTypeClass:
+    case kTypeClassIncomplete: {
+      if (fieldID == 0) {
+        return GetPrimType() == PTY_agg;
+      }
+      auto *classType = static_cast<MIRClassType*>(ty);
+      MIRType *subType = classType->GetFieldType(fieldID);
+      MIRTypeKind subKind = subType->GetKind();
+      return (subKind == kTypeBitField && VerifyPrimType(subType->GetPrimType(), GetPrimType())) ||
+             (subKind == kTypeScalar && IsPrimitiveScalar(GetPrimType())) ||
+             (subKind == kTypePointer && IsPrimitivePoint(GetPrimType())) ||
+             (subKind == kTypeStruct && GetPrimType() == PTY_agg);
+    }
+    case kTypeInterface:
+    case kTypeInterfaceIncomplete: {
+      if (fieldID == 0) {
+        return GetPrimType() == PTY_agg;
+      }
+      auto *interfaceType = static_cast<MIRInterfaceType*>(ty);
+      MIRType *subType = interfaceType->GetFieldType(fieldID);
+      MIRTypeKind subKind = subType->GetKind();
+      return (subKind == kTypeBitField && VerifyPrimType(subType->GetPrimType(), GetPrimType())) ||
+             (subKind == kTypeScalar && IsPrimitiveScalar(GetPrimType())) ||
+             (subKind == kTypePointer && IsPrimitivePoint(GetPrimType())) ||
+             (subKind == kTypeStruct && GetPrimType() == PTY_agg);
+    }
+    case kTypePointer:
+      return IsPrimitivePoint(GetPrimType());
+    case kTypeParam:
+    case kTypeGenericInstant:
+      return true;
+    default:
+      return false;
+  }
+}
+
+MIRType *IreadNode::GetType() const {
+  MIRPtrType *ptrtype = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx));
+  if (fieldID == 0) {
+    return ptrtype->GetPointedType();
+  }
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrtype->GetPointedTyIdxWithFieldID(fieldID));
+}
+
+bool IreadNode::IsVolatile() const {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  ASSERT(type != nullptr, "null ptr check");
+  ASSERT(type->IsMIRPtrType(), "type of iread should be pointer type");
+  return static_cast<MIRPtrType*>(type)->IsPointedTypeVolatile(fieldID);
+}
+
+bool AddrofNode::IsVolatile(const MIRModule &mod) const {
+  auto *symbol = mod.CurFunction()->GetLocalOrGlobalSymbol(stIdx);
+  ASSERT(symbol != nullptr, "null ptr check on symbol");
+  return symbol->IsVolatile();
+}
+
+bool DreadoffNode::IsVolatile(const MIRModule &mod) const {
+  auto *symbol = mod.CurFunction()->GetLocalOrGlobalSymbol(stIdx);
+  ASSERT(symbol != nullptr, "null ptr check on symbol");
+  return symbol->IsVolatile();
+}
+
+bool DassignNode::AssigningVolatile(const MIRModule &mod) const {
+  auto *symbol = mod.CurFunction()->GetLocalOrGlobalSymbol(stIdx);
+  ASSERT(symbol != nullptr, "null ptr check on symbol");
+  return symbol->IsVolatile();
+}
+
+bool IassignNode::AssigningVolatile() const {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  ASSERT(type != nullptr, "null ptr check");
+  ASSERT(type->IsMIRPtrType(), "type of iassign should be pointer type");
+  return static_cast<MIRPtrType*>(type)->IsPointedTypeVolatile(fieldID);
+}
+
+void BlockNode::AddStatement(StmtNode *stmt) {
+  ASSERT(stmt != nullptr, "null ptr check");
+  stmtNodeList.push_back(stmt);
+}
+
+void BlockNode::AppendStatementsFromBlock(BlockNode &blk) {
+  if (blk.GetStmtNodes().empty()) {
+    return;
+  }
+  stmtNodeList.splice(stmtNodeList.end(), blk.GetStmtNodes());
+}
+
+/// Insert stmt as the first
+void BlockNode::InsertFirst(StmtNode *stmt) {
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmtNodeList.push_front(stmt);
+}
+
+/// Insert stmt as the last
+void BlockNode::InsertLast(StmtNode *stmt) {
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmtNodeList.push_back(stmt);
+}
+
+void BlockNode::ReplaceStmtWithBlock(StmtNode &stmtNode, BlockNode &blk) {
+  stmtNodeList.splice(&stmtNode, blk.GetStmtNodes());
+  stmtNodeList.erase(&stmtNode);
+  stmtNode.SetNext(blk.GetLast()->GetNext());
+}
+
+void BlockNode::ReplaceStmt1WithStmt2(const StmtNode *stmtNode1, StmtNode *stmtNode2) {
+  if (stmtNode2 == stmtNode1) {
+    // do nothing
+  } else if (stmtNode2 == nullptr) {
+    // delete stmtNode1
+    stmtNodeList.erase(stmtNode1);
+  } else {
+    // replace stmtNode1 with stmtNode2
+    stmtNodeList.insert(stmtNode1, stmtNode2);
+    (void)stmtNodeList.erase(stmtNode1);
+  }
+}
+
+// remove sstmtNode1 from block
+void BlockNode::RemoveStmt(const StmtNode *stmtNode1) {
+  ASSERT(stmtNode1 != nullptr, "delete a null stmtment");
+  (void)stmtNodeList.erase(stmtNode1);
+}
+
+/// Insert stmtNode2 before stmtNode1 in current block.
+void BlockNode::InsertBefore(const StmtNode *stmtNode1, StmtNode *stmtNode2) {
+  stmtNodeList.insert(stmtNode1, stmtNode2);
+}
+
+/// Insert stmtNode2 after stmtNode1 in current block.
+void BlockNode::InsertAfter(const StmtNode *stmtNode1, StmtNode *stmtNode2) {
+  stmtNodeList.insertAfter(stmtNode1, stmtNode2);
+}
+
+// insert all the stmts in inblock to the current block after stmt1
+void BlockNode::InsertBlockAfter(BlockNode &inblock, const StmtNode *stmt1) {
+  ASSERT(stmt1 != nullptr, "null ptr check");
+  ASSERT(!inblock.IsEmpty(), "NYI");
+  stmtNodeList.splice(stmt1, inblock.GetStmtNodes());
+}
+
+BlockNode *BlockNode::CloneTree(MapleAllocator &allocator) const {
+  auto *blk = allocator.GetMemPool()->New<BlockNode>();
+  blk->SetStmtID(stmtIDNext++);
+  for (auto &stmt : stmtNodeList) {
+    StmtNode *newStmt = stmt.CloneTree(allocator);
+    ASSERT(newStmt != nullptr, "null ptr check");
+    newStmt->SetMeStmtID(stmt.GetMeStmtID());
+    newStmt->SetPrev(nullptr);
+    newStmt->SetNext(nullptr);
+    blk->AddStatement(newStmt);
+    BlockCallBackMgr::InvokeCallBacks(*this, *blk, stmt, *newStmt);
+  }
+  return blk;
+}
+
+BlockNode *BlockNode::CloneTreeWithSrcPosition(const MIRModule &mod, const GStrIdx &idx, bool setInlinedPos,
+                                               const SrcPosition & inlinedPosition) {
+  MapleAllocator &allocator = mod.GetCurFuncCodeMPAllocator();
+  auto *blk = allocator.GetMemPool()->New<BlockNode>();
+  blk->SetStmtID(stmtIDNext++);
+  for (auto &stmt : stmtNodeList) {
+    StmtNode *newStmt = stmt.CloneTree(allocator);
+    ASSERT(newStmt != nullptr, "null ptr check");
+    newStmt->SetSrcPos(stmt.GetSrcPos());
+    if (setInlinedPos) {
+      newStmt->SetInlinedSrcPos(inlinedPosition.LineNum(), inlinedPosition.FileNum(), idx);
+    }
+    newStmt->SetPrev(nullptr);
+    newStmt->SetNext(nullptr);
+    blk->AddStatement(newStmt);
+    BlockCallBackMgr::InvokeCallBacks(*this, *blk, stmt, *newStmt);
+  }
+  return blk;
+}
+
+BlockNode *BlockNode::CloneTreeWithFreqs(MapleAllocator &allocator,
+    std::unordered_map<uint32_t, uint64_t>& toFreqs,
+    std::unordered_map<uint32_t, uint64_t>& fromFreqs,
+    uint64_t numer, uint64_t denom, uint32_t updateOp) {
+  auto *nnode = allocator.GetMemPool()->New<BlockNode>();
+  nnode->SetStmtID(stmtIDNext++);
+  if (fromFreqs.count(GetStmtID()) > 0) {
+    uint64_t oldFreq = fromFreqs[GetStmtID()];
+    uint64_t newFreq;
+    if (updateOp & kUpdateUnrollRemainderFreq) {
+      newFreq = denom > 0 ? (oldFreq * numer % denom) : oldFreq;
+    } else {
+      newFreq = numer == 0 ? 0 : (denom > 0 ? (oldFreq * numer / denom) : oldFreq);
+    }
+    toFreqs[nnode->GetStmtID()] = (newFreq > 0 || (numer == 0)) ? newFreq : 1;
+    if ((updateOp & kUpdateOrigFreq) != 0) {  // upateOp & 1 : update from
+      int64_t left = static_cast<int64_t>(((oldFreq - newFreq) > 0 || (oldFreq == 0)) ? (oldFreq - newFreq) : 1);
+      fromFreqs[GetStmtID()] = static_cast<uint64_t>(left);
+    }
+  }
+  for (auto &stmt : stmtNodeList) {
+    StmtNode *newStmt;
+    if (stmt.GetOpCode() == OP_block) {
+      newStmt = static_cast<StmtNode*>(
+          (static_cast<BlockNode*>(&stmt))->CloneTreeWithFreqs(allocator, toFreqs, fromFreqs, numer, denom, updateOp));
+    } else if (stmt.GetOpCode() == OP_if) {
+      newStmt = static_cast<StmtNode*>(
+          (static_cast<IfStmtNode*>(&stmt))->CloneTreeWithFreqs(allocator, toFreqs, fromFreqs, numer, denom, updateOp));
+    } else if (stmt.GetOpCode() == OP_while) {
+      newStmt = static_cast<StmtNode*>(
+          (static_cast<WhileStmtNode*>(&stmt))->CloneTreeWithFreqs(allocator,
+                                                                   toFreqs, fromFreqs, numer, denom, updateOp));
+    } else if (stmt.GetOpCode() == OP_doloop) {
+      newStmt = static_cast<StmtNode*>(
+          (static_cast<DoloopNode*>(&stmt))->CloneTreeWithFreqs(allocator, toFreqs, fromFreqs, numer, denom, updateOp));
+    } else {
+      newStmt = static_cast<StmtNode*>(stmt.CloneTree(allocator));
+      if (fromFreqs.count(stmt.GetStmtID()) > 0) {
+        uint64_t oldFreq = fromFreqs[stmt.GetStmtID()];
+        uint64_t newFreq;
+        if ((updateOp & kUpdateUnrollRemainderFreq) != 0) {
+          newFreq = denom > 0 ? (oldFreq * numer % denom) : oldFreq;
+        } else {
+          newFreq = numer == 0 ? 0 : (denom > 0 ? (oldFreq * numer / denom) : oldFreq);
+        }
+        toFreqs[newStmt->GetStmtID()] =
+            (newFreq > 0 || oldFreq == 0 || numer == 0) ? static_cast<uint64_t>(newFreq) : 1;
+        if ((updateOp & kUpdateOrigFreq) != 0) {
+          int64_t left = static_cast<int64_t>(((oldFreq - newFreq) > 0 || oldFreq == 0) ? (oldFreq - newFreq) : 1);
+          fromFreqs[stmt.GetStmtID()] = static_cast<uint64_t>(left);
+        }
+      }
+    }
+    ASSERT(newStmt != nullptr, "null ptr check");
+    newStmt->SetSrcPos(stmt.GetSrcPos());
+    newStmt->SetMeStmtID(stmt.GetMeStmtID());
+    newStmt->SetPrev(nullptr);
+    newStmt->SetNext(nullptr);
+    nnode->AddStatement(newStmt);
+    BlockCallBackMgr::InvokeCallBacks(*this, *nnode, stmt, *newStmt);
+  }
+  return nnode;
+}
+
+void BaseNode::DumpBase(int32 indent) const {
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+}
+
+void CatchNode::Dump(int32 indent) const {
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " {";
+  size_t size = exceptionTyIdxVec.size();
+  for (size_t i = 0; i < size; ++i) {
+    LogInfo::MapleLogger() << " ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(exceptionTyIdxVec[i])->Dump(indent + 1);
+  }
+  LogInfo::MapleLogger() << " }\n";
+}
+
+void CppCatchNode::Dump(int32 indent) const {
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << kOpcodeInfo.GetName(op);
+  if (exceptionTyIdx.GetIdx() != 0) {
+    LogInfo::MapleLogger() << " { ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(exceptionTyIdx)->Dump(indent + 1);
+    LogInfo::MapleLogger() << " }";
+  }
+  LogInfo::MapleLogger() << std::endl;
+}
+
+void UnaryNode::DumpOpnd(const MIRModule &mod [[maybe_unused]], int32 indent) const {
+  DumpOpnd(indent);
+}
+
+void UnaryNode::DumpOpnd(int32 indent) const {
+  LogInfo::MapleLogger() << " (";
+  if (uOpnd != nullptr) {
+    uOpnd->Dump(indent);
+  }
+  LogInfo::MapleLogger() << ")";
+}
+
+void UnaryNode::Dump(int32 indent) const {
+  BaseNode::DumpBase(0);
+  DumpOpnd(*theMIRModule, indent);
+}
+
+void TypeCvtNode::Dump(int32 indent) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " ";
+  LogInfo::MapleLogger() << GetPrimTypeName(GetPrimType()) << " " << GetPrimTypeName(FromType());
+  DumpOpnd(*theMIRModule, indent);
+}
+
+void RetypeNode::Dump(int32 indent) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " ";
+  LogInfo::MapleLogger() << GetPrimTypeName(GetPrimType()) << " ";
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  if (ty->GetKind() == kTypeScalar) {
+    LogInfo::MapleLogger() << "<";
+    ty->Dump(indent + 1);
+    LogInfo::MapleLogger() << ">";
+  } else {
+    ty->Dump(indent + 1);
+  }
+  DumpOpnd(*theMIRModule, indent);
+}
+
+void ExtractbitsNode::Dump(int32 indent) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  if (GetOpCode() == OP_extractbits) {
+    LogInfo::MapleLogger() << " " << static_cast<int32>(bitsOffset) << " " << static_cast<int32>(bitsSize);
+  } else {
+    LogInfo::MapleLogger() << " " << static_cast<int32>(bitsSize);
+  }
+  DumpOpnd(*theMIRModule, indent);
+}
+
+void IreadNode::Dump(int32 indent) const {
+  BaseNode::DumpBase(0);
+  LogInfo::MapleLogger() << " ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(0);
+  LogInfo::MapleLogger() << " " << fieldID;
+  DumpOpnd(*theMIRModule, indent);
+}
+
+void IreadoffNode::Dump(int32 indent) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger() << " " << offset;
+  DumpOpnd(*theMIRModule, indent);
+}
+
+void IreadFPoffNode::Dump(int32 indent [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger() << " " << offset;
+}
+
+void BinaryNode::Dump(int32 indent) const {
+  BaseNode::DumpBase(0);
+  BinaryOpnds::Dump(indent);
+}
+
+void BinaryOpnds::Dump(int32 indent) const {
+  LogInfo::MapleLogger() << " (";
+  if (bOpnd[0]->IsLeaf() && bOpnd[1]->IsLeaf()) {
+    bOpnd[0]->Dump(0);
+    LogInfo::MapleLogger() << ", ";
+    bOpnd[1]->Dump(0);
+  } else {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent + 1);
+    bOpnd[0]->Dump(indent + 1);
+    LogInfo::MapleLogger() << ",\n";
+    PrintIndentation(indent + 1);
+    bOpnd[1]->Dump(indent + 1);
+  }
+  LogInfo::MapleLogger() << ")";
+}
+
+void ResolveFuncNode::Dump(int32 indent) const {
+  BaseNode::DumpBase(0);
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  LogInfo::MapleLogger() << " &" << func->GetName();
+  BinaryOpnds::Dump(indent);
+}
+
+void CompareNode::Dump(int32 indent) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger() << " " << GetPrimTypeName(opndType);
+  BinaryOpnds::Dump(indent);
+}
+
+void DepositbitsNode::Dump(int32 indent) const {
+  BaseNode::DumpBase(0);
+  LogInfo::MapleLogger() << " " << static_cast<int32>(bitsOffset) << " " << static_cast<int32>(bitsSize) << " (";
+  if (GetBOpnd(0)->IsLeaf() && GetBOpnd(1)->IsLeaf()) {
+    GetBOpnd(0)->Dump(0);
+    LogInfo::MapleLogger() << ", ";
+    GetBOpnd(1)->Dump(0);
+  } else {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent + 1);
+    GetBOpnd(0)->Dump(indent + 1);
+    LogInfo::MapleLogger() << ",\n";
+    PrintIndentation(indent + 1);
+    GetBOpnd(1)->Dump(indent + 1);
+  }
+  LogInfo::MapleLogger() << ")";
+}
+
+void TernaryNode::Dump(int32 indent) const {
+  BaseNode::DumpBase(0);
+  LogInfo::MapleLogger() << " (";
+  if (topnd[kFirstOpnd]->IsLeaf() && topnd[kSecondOpnd]->IsLeaf() && topnd[kThirdOpnd]->IsLeaf()) {
+    topnd[kFirstOpnd]->Dump(0);
+    LogInfo::MapleLogger() << ", ";
+    topnd[kSecondOpnd]->Dump(0);
+    LogInfo::MapleLogger() << ", ";
+    topnd[kThirdOpnd]->Dump(0);
+  } else {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent + 1);
+    topnd[kFirstOpnd]->Dump(indent + 1);
+    LogInfo::MapleLogger() << ",\n";
+    PrintIndentation(indent + 1);
+    topnd[kSecondOpnd]->Dump(indent + 1);
+    LogInfo::MapleLogger() << ",\n";
+    PrintIndentation(indent + 1);
+    topnd[kThirdOpnd]->Dump(indent + 1);
+  }
+  LogInfo::MapleLogger() << ")";
+}
+
+void NaryOpnds::Dump(int32 indent) const {
+  LogInfo::MapleLogger() << " (";
+  if (GetNopndSize() == 0) {
+    LogInfo::MapleLogger() << ")";
+    return;
+  }
+  if (GetNopndSize() == 1) {
+    GetNopndAt(0)->Dump(indent);
+  } else {
+    bool allisLeaf = true;
+    for (size_t i = 0; i < GetNopndSize(); ++i) {
+      if (!GetNopndAt(i)->IsLeaf()) {
+        allisLeaf = false;
+        break;
+      }
+    }
+    if (allisLeaf) {
+      GetNopndAt(0)->Dump(0);
+      for (size_t i = 1; i < GetNopndSize(); ++i) {
+        LogInfo::MapleLogger() << ", ";
+        GetNopndAt(i)->Dump(0);
+      }
+    } else {
+      LogInfo::MapleLogger() << '\n';
+      PrintIndentation(indent + 1);
+      GetNopndAt(0)->Dump(indent + 1);
+      for (size_t i = 1; i < GetNopndSize(); ++i) {
+        LogInfo::MapleLogger() << ",\n";
+        PrintIndentation(indent + 1);
+        GetNopndAt(i)->Dump(indent + 1);
+      }
+    }
+  }
+  LogInfo::MapleLogger() << ")";
+}
+
+bool NaryOpnds::VerifyOpnds() const {
+  bool nOpndsVerify = true;
+  for (size_t i = 0; i < GetNopndSize(); ++i) {
+    if (!GetNopndAt(i)->Verify()) {
+      nOpndsVerify = false;
+      break;
+    }
+  }
+  return nOpndsVerify;
+}
+
+void NaryNode::Dump(int32 indent) const {
+  BaseNode::DumpBase(0);
+  NaryOpnds::Dump(indent);
+}
+
+const MIRType *ArrayNode::GetArrayType(const TypeTable &tt) const {
+  const MIRType *type = tt.GetTypeFromTyIdx(tyIdx);
+  CHECK_FATAL(type->GetKind() == kTypePointer, "expect array type pointer");
+  const auto *pointType = static_cast<const MIRPtrType*>(type);
+  return tt.GetTypeFromTyIdx(pointType->GetPointedTyIdx());
+}
+MIRType *ArrayNode::GetArrayType(const TypeTable &tt) {
+  return const_cast<MIRType*>(const_cast<const ArrayNode*>(this)->GetArrayType(tt));
+}
+
+const BaseNode *ArrayNode::GetDim(const MIRModule &mod, TypeTable &tt, int i) const {
+  const auto *arrayType = static_cast<const MIRArrayType*>(GetArrayType(tt));
+  auto *mirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+      static_cast<uint64>(i), *tt.GetTypeFromTyIdx(arrayType->GetElemTyIdx()));
+  return mod.CurFuncCodeMemPool()->New<ConstvalNode>(mirConst);
+}
+BaseNode *ArrayNode::GetDim(const MIRModule &mod, TypeTable &tt, int i) {
+  return const_cast<BaseNode*>(const_cast<const ArrayNode*>(this)->GetDim(mod, tt, i));
+}
+
+void ArrayNode::Dump(int32 indent) const {
+  PrintIndentation(0);
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " ";
+  if (boundsCheck) {
+    LogInfo::MapleLogger() << "1 ";
+  } else {
+    LogInfo::MapleLogger() << "0 ";
+  }
+  LogInfo::MapleLogger() << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger() << " ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(0);
+  NaryOpnds::Dump(indent);
+}
+
+bool ArrayNode::IsSameBase(ArrayNode *arry) {
+  ASSERT(arry != nullptr, "null ptr check");
+  if (arry == this) {
+    return true;
+  }
+  BaseNode *curBase = this->GetBase();
+  BaseNode *otherBase = arry->GetBase();
+  if (curBase->GetOpCode() != OP_addrof || otherBase->GetOpCode() != OP_addrof) {
+    return false;
+  }
+  return static_cast<AddrofNode*>(curBase)->GetStIdx() == static_cast<AddrofNode*>(otherBase)->GetStIdx();
+}
+
+void IntrinsicopNode::Dump(int32 indent) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  if (GetOpCode() == OP_intrinsicopwithtype) {
+    LogInfo::MapleLogger() << " ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(indent + 1);
+  }
+  LogInfo::MapleLogger() << " " << GetIntrinsicName(GetIntrinsic());
+  NaryOpnds::Dump(indent);
+}
+
+void ConstvalNode::Dump(int32 indent [[maybe_unused]]) const {
+  if (GetConstVal()->GetType().GetKind() != kTypePointer) {
+    BaseNode::DumpBase(0);
+    LogInfo::MapleLogger() << " ";
+  }
+  GetConstVal()->Dump();
+}
+
+void ConststrNode::Dump(int32 indent [[maybe_unused]]) const {
+  BaseNode::DumpBase(0);
+  const std::string kStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(UStrIdx(strIdx));
+  PrintString(kStr);
+}
+
+void Conststr16Node::Dump(int32 indent [[maybe_unused]]) const {
+  BaseNode::DumpBase(0);
+  const std::u16string kStr16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(U16StrIdx(strIdx));
+  // UTF-16 string are dumped as UTF-8 string in mpl to keep the printable chars in ascii form
+  std::string str;
+  (void)namemangler::UTF16ToUTF8(str, kStr16);
+  PrintString(str);
+}
+
+void SizeoftypeNode::Dump(int32 indent [[maybe_unused]]) const {
+  BaseNode::DumpBase(0);
+  LogInfo::MapleLogger() << " ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(0);
+}
+
+void FieldsDistNode::Dump(int32 indent [[maybe_unused]]) const {
+  BaseNode::DumpBase(0);
+  LogInfo::MapleLogger() << " ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(0);
+  LogInfo::MapleLogger() << " " << fieldID1 << " " << fieldID2;
+}
+
+void AddrofNode::Dump(int32 indent [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  const MIRSymbol *st = theMIRModule->CurFunction()->GetLocalOrGlobalSymbol(GetStIdx());
+  LogInfo::MapleLogger() << (GetStIdx().Islocal() ? " %" : " $");
+  ASSERT(st != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << st->GetName();
+  if (fieldID != 0) {
+    LogInfo::MapleLogger() << " " << fieldID;
+  }
+}
+
+void DreadoffNode::Dump(int32 indent [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  const MIRSymbol *st = theMIRModule->CurFunction()->GetLocalOrGlobalSymbol(stIdx);
+  LogInfo::MapleLogger() << (stIdx.Islocal() ? " %" : " $");
+  ASSERT(st != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << st->GetName();
+  LogInfo::MapleLogger() << " " << offset;
+}
+
+void RegreadNode::Dump(int32 indent [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  if (regIdx >= 0) {
+    LogInfo::MapleLogger() << " %" << theMIRModule->CurFunction()->GetPregTab()->PregFromPregIdx(regIdx)->GetPregNo();
+    return;
+  }
+  LogInfo::MapleLogger() << " %%";
+  switch (regIdx) {
+    case -kSregSp:
+      LogInfo::MapleLogger() << "SP";
+      break;
+    case -kSregFp:
+      LogInfo::MapleLogger() << "FP";
+      break;
+    case -kSregGp:
+      LogInfo::MapleLogger() << "GP";
+      break;
+    case -kSregThrownval:
+      LogInfo::MapleLogger() << "thrownval";
+      break;
+    case -kSregMethodhdl:
+      LogInfo::MapleLogger() << "methodhdl";
+      break;
+    default:
+      int32 retValIdx = (-regIdx) - kSregRetval0;
+      LogInfo::MapleLogger() << "retval" << retValIdx;
+      break;
+  }
+}
+
+void AddroffuncNode::Dump(int32 indent [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  CHECK_NULL_FATAL(func);
+  MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
+  CHECK_NULL_FATAL(sym);
+  LogInfo::MapleLogger() << " &" << sym->GetName();
+}
+
+void AddroflabelNode::Dump(int32 indent [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger() << " @" << theMIRModule->CurFunction()->GetLabelName(static_cast<LabelIdx>(offset));
+}
+
+void StmtNode::DumpBase(int32 indent) const {
+  srcPosition.DumpLoc(lastPrintedLineNum, lastPrintedColumnNum);
+  // dump stmtFreqs
+  if (Options::profileUse && theMIRModule->CurFunction()->GetFuncProfData()) {
+    int64_t freq = static_cast<int64_t>(theMIRModule->CurFunction()->GetFuncProfData()->GetStmtFreq(GetStmtID()));
+    if (freq >= 0) {
+      LogInfo::MapleLogger() << "stmtID " << GetStmtID() << "  freq " << freq << "\n";
+    }
+  }
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name;
+}
+
+void StmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << '\n';
+}
+
+// Get the next stmt skip the comment stmt.
+StmtNode *StmtNode::GetRealNext() const {
+  StmtNode *stmt = this->GetNext();
+  while (stmt != nullptr) {
+    if (stmt->GetOpCode() != OP_comment) {
+      break;
+    }
+    stmt = stmt->GetNext();
+  }
+  return stmt;
+}
+
+// insert this before pos
+void StmtNode::InsertAfterThis(StmtNode &pos) {
+  this->SetNext(&pos);
+  if (pos.GetPrev()) {
+    this->SetPrev(pos.GetPrev());
+    pos.GetPrev()->SetNext(this);
+  }
+  pos.SetPrev(this);
+}
+
+// insert stmtnode after pos
+void StmtNode::InsertBeforeThis(StmtNode &pos) {
+  this->SetPrev(&pos);
+  if (pos.GetNext()) {
+    this->SetNext(pos.GetNext());
+    pos.GetNext()->SetPrev(this);
+  }
+  pos.SetNext(this);
+}
+
+void DassignNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  const MIRSymbol *st = theMIRModule->CurFunction()->GetLocalOrGlobalSymbol(stIdx);
+  ASSERT(st != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << (st->IsLocal() ? " %" : " $");
+  LogInfo::MapleLogger() << st->GetName() << " " << fieldID;
+  LogInfo::MapleLogger() << " (";
+  if (GetRHS() != nullptr) {
+    GetRHS()->Dump(indent + 1);
+  } else {
+    LogInfo::MapleLogger() << "/*empty-rhs*/";
+  }
+  LogInfo::MapleLogger() << ")\n";
+}
+
+void DassignoffNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " " << GetPrimTypeName(GetPrimType());
+  const MIRSymbol *st = theMIRModule->CurFunction()->GetLocalOrGlobalSymbol(stIdx);
+  ASSERT(st != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << (st->IsLocal() ? " %" : " $");
+  LogInfo::MapleLogger() << st->GetName() << " " << offset;
+  LogInfo::MapleLogger() << " (";
+  if (GetRHS() != nullptr) {
+    GetRHS()->Dump(indent + 1);
+  } else {
+    LogInfo::MapleLogger() << "/*empty-rhs*/";
+  }
+  LogInfo::MapleLogger() << ")\n";
+}
+
+void RegassignNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " " << GetPrimTypeName(GetPrimType());
+  if (regIdx >= 0) {
+    LogInfo::MapleLogger() << " %" << theMIRModule->CurFunction()->GetPregTab()->PregFromPregIdx(regIdx)->GetPregNo();
+  } else {
+    LogInfo::MapleLogger() << " %%";
+    switch (regIdx) {
+      case -kSregSp:
+        LogInfo::MapleLogger() << "SP";
+        break;
+      case -kSregFp:
+        LogInfo::MapleLogger() << "FP";
+        break;
+      case -kSregGp:
+        LogInfo::MapleLogger() << "GP";
+        break;
+      case -kSregThrownval:
+        LogInfo::MapleLogger() << "thrownval";
+        break;
+      case -kSregMethodhdl:
+        LogInfo::MapleLogger() << "methodhdl";
+        break;
+      case -kSregRetval0:
+        LogInfo::MapleLogger() << "retval0";
+        break;
+      // no default
+      default:
+        break;
+    }
+  }
+  LogInfo::MapleLogger() << " (";
+  UnaryStmtNode::Opnd(0)->Dump(indent + 1);
+  LogInfo::MapleLogger() << ")\n";
+}
+
+void IassignNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(0);
+  LogInfo::MapleLogger() << " " << fieldID;
+  LogInfo::MapleLogger() << " (";
+  if (addrExpr->IsLeaf() && rhs->IsLeaf()) {
+    addrExpr->Dump(0);
+    LogInfo::MapleLogger() << ", ";
+    rhs->Dump(0);
+  } else {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent + 1);
+    addrExpr->Dump(indent + 1);
+    LogInfo::MapleLogger() << ", \n";
+    PrintIndentation(indent + 1);
+    rhs->Dump(indent + 1);
+  }
+  LogInfo::MapleLogger() << ")\n";
+}
+
+void IassignoffNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " " << GetPrimTypeName(GetPrimType()) << " " << offset;
+  BinaryOpnds::Dump(indent);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void IassignFPoffNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " " << GetPrimTypeName(GetPrimType()) << " " << offset;
+  DumpOpnd(*theMIRModule, indent);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void BlkassignoffNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " " << offset << " " << GetAlign() << " " << blockSize;
+  BinaryOpnds::Dump(indent);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void GotoNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  if (offset == 0) {
+    LogInfo::MapleLogger() << '\n';
+  } else {
+    LogInfo::MapleLogger() << " @" << theMIRModule->CurFunction()->GetLabelName(static_cast<LabelIdx>(offset)) << '\n';
+  }
+}
+
+void JsTryNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  if (catchOffset == 0) {
+    LogInfo::MapleLogger() << " 0";
+  } else {
+    LogInfo::MapleLogger() << " @" << theMIRModule->CurFunction()->GetLabelName(static_cast<LabelIdx>(catchOffset));
+  }
+  if (finallyOffset == 0) {
+    LogInfo::MapleLogger() << " 0\n";
+  } else {
+    LogInfo::MapleLogger() << " @" << theMIRModule->CurFunction()->GetLabelName(static_cast<LabelIdx>(finallyOffset))
+                           << '\n';
+  }
+}
+
+void TryNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " {";
+  for (size_t i = 0; i < offsets.size(); ++i) {
+    uint32 offset = offsets[i];
+    LogInfo::MapleLogger() << " @" << theMIRModule->CurFunction()->GetLabelName((LabelIdx)offset);
+  }
+  LogInfo::MapleLogger() << " }\n";
+}
+
+void CondGotoNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " @" << theMIRModule->CurFunction()->GetLabelName(static_cast<LabelIdx>(offset));
+  LogInfo::MapleLogger() << " (";
+  Opnd(0)->Dump(indent);
+  LogInfo::MapleLogger() << ")\n";
+}
+
+void SwitchNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " (";
+  switchOpnd->Dump(indent);
+  if (defaultLabel == 0) {
+    LogInfo::MapleLogger() << ") 0 {";
+  } else {
+    LogInfo::MapleLogger() << ") @" << theMIRModule->CurFunction()->GetLabelName(defaultLabel) << " {";
+  }
+  for (auto it = switchTable.begin(); it != switchTable.end(); it++) {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << std::hex << "0x" << it->first << std::dec;
+    LogInfo::MapleLogger() << ": goto @" << theMIRModule->CurFunction()->GetLabelName(it->second);
+  }
+  LogInfo::MapleLogger() << " }\n";
+}
+
+void RangeGotoNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " (";
+  Opnd(0)->Dump(indent);
+  LogInfo::MapleLogger() << ") " << tagOffset << " {";
+  for (auto it = rangegotoTable.begin(); it != rangegotoTable.end(); it++) {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << std::hex << "0x" << it->first << std::dec;
+    LogInfo::MapleLogger() << ": goto @" << theMIRModule->CurFunction()->GetLabelName(it->second);
+  }
+  LogInfo::MapleLogger() << " }\n";
+}
+
+void MultiwayNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " (";
+  multiWayOpnd->Dump(indent);
+  if (defaultLabel == 0) {
+    LogInfo::MapleLogger() << ") 0 {";
+  } else {
+    LogInfo::MapleLogger() << ") @" << theMIRModule->CurFunction()->GetLabelName(defaultLabel) << " {";
+  }
+  for (auto it = multiWayTable.begin(); it != multiWayTable.end(); it++) {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << " (";
+    it->first->Dump(indent + 1);
+    LogInfo::MapleLogger() << "): goto @" << theMIRModule->CurFunction()->GetLabelName(it->second);
+  }
+  LogInfo::MapleLogger() << " }\n";
+}
+
+void UnaryStmtNode::DumpOpnd(const MIRModule &mod [[maybe_unused]], int32 indent) const {
+  DumpOpnd(indent);
+}
+
+void UnaryStmtNode::DumpOpnd(int32 indent) const {
+  LogInfo::MapleLogger() << " (";
+  if (uOpnd != nullptr) {
+    uOpnd->Dump(indent);
+  }
+  LogInfo::MapleLogger() << ")\n";
+}
+
+void UnaryStmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  DumpOpnd(indent);
+}
+
+void GCMallocNode::Dump(int32 indent [[maybe_unused]]) const {
+  BaseNode::DumpBase(0);
+  LogInfo::MapleLogger() << " ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(0);
+}
+
+void JarrayMallocNode::Dump(int32 indent) const {
+  BaseNode::DumpBase(0);
+  LogInfo::MapleLogger() << " ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(0, false);
+  DumpOpnd(*theMIRModule, indent);
+}
+
+void IfStmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  LogInfo::MapleLogger() << " (";
+  Opnd()->Dump(indent);
+  LogInfo::MapleLogger() << ")";
+  thenPart->Dump(indent);
+  if (elsePart) {
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << "else {\n";
+    for (auto &stmt : elsePart->GetStmtNodes()) {
+      stmt.Dump(indent + 1);
+    }
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << "}\n";
+  }
+}
+
+void WhileStmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  if (GetOpCode() == OP_while) {
+    LogInfo::MapleLogger() << " (";
+    Opnd(0)->Dump(indent);
+    LogInfo::MapleLogger() << ")";
+    body->Dump(indent);
+  } else {  // OP_dowhile
+    LogInfo::MapleLogger() << " {\n";
+    for (auto &stmt : body->GetStmtNodes()) {
+      stmt.Dump(indent + 1);
+    }
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << "} (";
+    Opnd(0)->Dump(indent);
+    LogInfo::MapleLogger() << ")\n";
+  }
+}
+
+void DoloopNode::DumpDoVar(const MIRModule &mod) const {
+  if (isPreg) {
+    LogInfo::MapleLogger() << " %"
+                           << mod.CurFunction()->GetPregTab()->PregFromPregIdx(doVarStIdx.FullIdx())->GetPregNo()
+                           << " (\n";
+  } else {
+    const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(doVarStIdx);
+    CHECK_NULL_FATAL(st);
+    LogInfo::MapleLogger() << " %" << st->GetName() << " (\n";
+  }
+}
+
+void DoloopNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  DumpDoVar(*theMIRModule);
+  PrintIndentation(indent + 1);
+  startExpr->Dump(indent + 1);
+  LogInfo::MapleLogger() << ",\n";
+  PrintIndentation(indent + 1);
+  condExpr->Dump(indent + 1);
+  LogInfo::MapleLogger() << ",\n";
+  PrintIndentation(indent + 1);
+  incrExpr->Dump(indent + 1);
+  LogInfo::MapleLogger() << ")";
+  doBody->Dump(indent + 1);
+}
+
+void ForeachelemNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  const MIRSymbol *st = theMIRModule->CurFunction()->GetLocalOrGlobalSymbol(elemStIdx);
+  ASSERT(st != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << " %" << st->GetName();
+  st = theMIRModule->CurFunction()->GetLocalOrGlobalSymbol(arrayStIdx);
+  ASSERT(st != nullptr, "null ptr check");
+  LogInfo::MapleLogger() << (arrayStIdx.Islocal() ? " %" : " $");
+  LogInfo::MapleLogger() << st->GetName();
+  loopBody->Dump(indent + 1);
+}
+
+void BinaryStmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  BinaryOpnds::Dump(indent);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void NaryStmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  NaryOpnds::Dump(indent);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void CallAssertNonnullStmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  SafetyCallCheckStmtNode::Dump();
+  UnaryStmtNode::DumpOpnd(indent);
+}
+
+void AssertNonnullStmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  if (theMIRModule->IsCModule()) {
+    SafetyCheckStmtNode::Dump();
+  }
+  UnaryStmtNode::DumpOpnd(indent);
+}
+
+void AssertBoundaryStmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  SafetyCheckStmtNode::Dump();
+  NaryOpnds::Dump(indent);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void CallAssertBoundaryStmtNode::Dump(int32 indent) const {
+  StmtNode::DumpBase(indent);
+  SafetyCallCheckStmtNode::Dump();
+  NaryOpnds::Dump(indent);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void DumpCallReturns(const MIRModule &mod, CallReturnVector nrets, int32 indent) {
+  const MIRFunction *mirFunc = mod.CurFunction();
+  if (nrets.empty()) {
+    LogInfo::MapleLogger() << " {}\n";
+    return;
+  } else if (nrets.size() == 1) {
+    StIdx stIdx = nrets.begin()->first;
+    RegFieldPair regFieldPair = nrets.begin()->second;
+    if (!regFieldPair.IsReg()) {
+      const MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx);
+      ASSERT(st != nullptr, "st is null");
+      FieldID fieldID = regFieldPair.GetFieldID();
+      LogInfo::MapleLogger() << " { dassign ";
+      LogInfo::MapleLogger() << (stIdx.Islocal() ? "%" : "$");
+      LogInfo::MapleLogger() << st->GetName() << " " << fieldID << " }\n";
+      return;
+    } else {
+      PregIdx regIdx = regFieldPair.GetPregIdx();
+      const MIRPreg *mirPreg = mirFunc->GetPregItem(static_cast<PregIdx>(regIdx));
+      ASSERT(mirPreg != nullptr, "mirPreg is null");
+      LogInfo::MapleLogger() << " { regassign";
+      LogInfo::MapleLogger() << " " << GetPrimTypeName(mirPreg->GetPrimType());
+      LogInfo::MapleLogger() << " %" << mirPreg->GetPregNo() << "}\n";
+      return;
+    }
+  }
+  LogInfo::MapleLogger() << " {\n";
+  for (auto it = nrets.begin(); it != nrets.end(); it++) {
+    PrintIndentation(indent + 2);
+    StIdx stIdx = (it)->first;
+    RegFieldPair regFieldPair = it->second;
+    if (!regFieldPair.IsReg()) {
+      FieldID fieldID = regFieldPair.GetFieldID();
+      LogInfo::MapleLogger() << "dassign";
+      const MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx);
+      ASSERT(st != nullptr, "st is null");
+      LogInfo::MapleLogger() << (stIdx.Islocal() ? " %" : " $");
+      LogInfo::MapleLogger() << st->GetName() << " " << fieldID << '\n';
+    } else {
+      PregIdx regIdx = regFieldPair.GetPregIdx();
+      const MIRPreg *mirPreg = mirFunc->GetPregItem(static_cast<PregIdx>(regIdx));
+      ASSERT(mirPreg != nullptr, "mirPreg is null");
+      LogInfo::MapleLogger() << "regassign"
+                             << " " << GetPrimTypeName(mirPreg->GetPrimType());
+      LogInfo::MapleLogger() << " %" << mirPreg->GetPregNo() << '\n';
+    }
+  }
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << "}\n";
+}
+
+// iread expr has sideeffect, may cause derefference error
+bool HasIreadExpr(const BaseNode *expr) {
+  if (expr->GetOpCode() == OP_iread) {
+    return true;
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    if (HasIreadExpr(expr->Opnd(i))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// layer to leaf node
+size_t MaxDepth(const BaseNode *expr) {
+  if (expr->IsLeaf()) {
+    return 1;
+  }
+  size_t maxSubDepth = 0;
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    size_t depth = MaxDepth(expr->Opnd(i));
+    maxSubDepth = (depth > maxSubDepth) ? depth : maxSubDepth;
+  }
+  return maxSubDepth + 1;  // expr itself
+}
+
+MIRType *CallNode::GetCallReturnType() {
+  if (!kOpcodeInfo.IsCallAssigned(GetOpCode())) {
+    return nullptr;
+  }
+  ASSERT(GlobalTables::GetFunctionTable().GetFuncTable().empty() == false, "container check");
+  MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  return mirFunc->GetReturnType();
+}
+
+const MIRSymbol *CallNode::GetCallReturnSymbol(const MIRModule &mod) const {
+  if (!kOpcodeInfo.IsCallAssigned(GetOpCode())) {
+    return nullptr;
+  }
+  const CallReturnVector &nRets = this->GetReturnVec();
+  if (nRets.size() == 1) {
+    StIdx stIdx = nRets.begin()->first;
+    RegFieldPair regFieldPair = nRets.begin()->second;
+    if (!regFieldPair.IsReg()) {
+      const MIRFunction *mirFunc = mod.CurFunction();
+      const MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx);
+      return st;
+    }
+  }
+  return nullptr;
+}
+
+void CallNode::Dump(int32 indent, bool newline) const {
+  StmtNode::DumpBase(indent);
+  if (tyIdx != 0u) {
+    LogInfo::MapleLogger() << " ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(indent + 1);
+  }
+  CHECK(puIdx < GlobalTables::GetFunctionTable().GetFuncTable().size(), "index out of range in CallNode::Dump");
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  LogInfo::MapleLogger() << " &" << func->GetName();
+  NaryOpnds::Dump(indent);
+  if (kOpcodeInfo.IsCallAssigned(GetOpCode())) {
+    DumpCallReturns(*theMIRModule, this->GetReturnVec(), indent);
+  } else if (newline) {
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+MIRType *IcallNode::GetCallReturnType() {
+  if (op == OP_icall || op == OP_icallassigned) {
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(retTyIdx);
+  }
+  // icallproto or icallprotoassigned
+  MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retTyIdx);
+  MIRFuncType *funcType = nullptr;
+  if (retType->IsMIRPtrType()) {
+    funcType = static_cast<MIRPtrType*>(retType)->GetPointedFuncType();
+  } else if (retType->IsMIRFuncType()) {
+    funcType = static_cast<MIRFuncType*>(retType);
+  }
+  CHECK_FATAL(funcType != nullptr, "cannot find prototype for icall");
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx());
+}
+
+const MIRSymbol *IcallNode::GetCallReturnSymbol(const MIRModule &mod) const {
+  if (!kOpcodeInfo.IsCallAssigned(GetOpCode())) {
+    return nullptr;
+  }
+  const CallReturnVector &nRets = this->GetReturnVec();
+  if (nRets.size() == 1) {
+    StIdx stIdx = nRets.begin()->first;
+    RegFieldPair regFieldPair = nRets.begin()->second;
+    if (!regFieldPair.IsReg()) {
+      const MIRFunction *mirFunc = mod.CurFunction();
+      const MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx);
+      return st;
+    }
+  }
+  return nullptr;
+}
+
+void IcallNode::Dump(int32 indent, bool newline) const {
+  StmtNode::DumpBase(indent);
+  if (op == OP_icallproto || op == OP_icallprotoassigned) {
+    LogInfo::MapleLogger() << " ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(retTyIdx)->Dump(indent + 1);
+  }
+  NaryOpnds::Dump(indent);
+  if (kOpcodeInfo.IsCallAssigned(GetOpCode())) {
+    DumpCallReturns(*theMIRModule, this->returnValues, indent);
+  } else if (newline) {
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+MIRType *IntrinsiccallNode::GetCallReturnType() {
+  CHECK_FATAL(intrinsic < INTRN_LAST, "Index out of bound in IntrinsiccallNode::GetCallReturnType");
+  IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrinsic];
+  return intrinDesc->GetReturnType();
+}
+
+void IntrinsiccallNode::Dump(int32 indent, bool newline) const {
+  StmtNode::DumpBase(indent);
+  if (tyIdx != 0u) {
+    LogInfo::MapleLogger() << " ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(indent + 1);
+  }
+  if (GetOpCode() == OP_intrinsiccall || GetOpCode() == OP_intrinsiccallassigned ||
+      GetOpCode() == OP_intrinsiccallwithtype || GetOpCode() == OP_intrinsiccallwithtypeassigned) {
+    LogInfo::MapleLogger() << " " << GetIntrinsicName(intrinsic);
+  } else {
+    LogInfo::MapleLogger() << " " << intrinsic;
+  }
+  NaryOpnds::Dump(indent);
+  if (kOpcodeInfo.IsCallAssigned(GetOpCode())) {
+    DumpCallReturns(*theMIRModule, this->GetReturnVec(), indent);
+  } else if (newline) {
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+void CallinstantNode::Dump(int32 indent, bool newline) const {
+  StmtNode::DumpBase(indent);
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(GetPUIdx());
+  LogInfo::MapleLogger() << " &" << func->GetName();
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(instVecTyIdx);
+  LogInfo::MapleLogger() << "<";
+  auto *instVecType = static_cast<MIRInstantVectorType*>(ty);
+  instVecType->Dump(indent);
+  LogInfo::MapleLogger() << ">";
+  NaryOpnds::Dump(indent);
+  if (kOpcodeInfo.IsCallAssigned(GetOpCode())) {
+    DumpCallReturns(*theMIRModule, this->GetReturnVec(), indent);
+  } else if (newline) {
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+void BlockNode::Dump(int32 indent, const MIRSymbolTable *theSymTab, MIRPregTable *thePregTab, bool withInfo,
+                     bool isFuncbody, MIRFlavor flavor) const {
+  if (!withInfo) {
+    LogInfo::MapleLogger() << " {\n";
+  }
+  // output puid for debugging purpose
+  if (isFuncbody) {
+    theMIRModule->CurFunction()->DumpFuncBody(indent);
+    if (theSymTab != nullptr || thePregTab != nullptr) {
+      // print the locally declared type names
+      if (theMIRModule->CurFunction()->HaveTypeNameTab()) {
+        for (auto it : theMIRModule->CurFunction()->GetGStrIdxToTyIdxMap()) {
+          const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(it.first);
+          MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(it.second);
+          PrintIndentation(indent + 1);
+          LogInfo::MapleLogger() << "type %" << name << " ";
+          if (type->GetKind() != kTypeByName) {
+            type->Dump(indent + 2, true);
+          } else {
+            type->Dump(indent + 2);
+          }
+          LogInfo::MapleLogger() << '\n';
+        }
+      }
+      // print the locally declared variables
+      theSymTab->Dump(true, indent + 1, false, flavor); /* first:isLocal, third:printDeleted */
+      if (thePregTab != nullptr) {
+        thePregTab->DumpPregsWithTypes(indent + 1);
+      }
+    }
+    LogInfo::MapleLogger() << '\n';
+    if (theMIRModule->CurFunction()->NeedEmitAliasInfo()) {
+      theMIRModule->CurFunction()->DumpScope();
+    }
+  }
+  srcPosition.DumpLoc(lastPrintedLineNum, lastPrintedColumnNum);
+  // dump stmtFreqs
+  if (Options::profileUse && theMIRModule->CurFunction()->GetFuncProfData()) {
+    int64_t freq = static_cast<int64_t>(theMIRModule->CurFunction()->GetFuncProfData()->GetStmtFreq(GetStmtID()));
+    if (freq >= 0) {
+      LogInfo::MapleLogger() << "stmtID " << GetStmtID() << "  freq " << freq << "\n";
+    }
+  }
+  for (auto &stmt : GetStmtNodes()) {
+    stmt.Dump(indent + 1);
+  }
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "}\n";
+}
+
+void LabelNode::Dump(int32 indent [[maybe_unused]]) const {
+  if (theMIRModule->CurFunction()->WithLocInfo()) {
+    srcPosition.DumpLoc(lastPrintedLineNum, lastPrintedColumnNum);
+  }
+  // dump stmtFreqs
+  if (Options::profileUse && theMIRModule->CurFunction()->GetFuncProfData()) {
+    int64_t freq = static_cast<int64_t>(theMIRModule->CurFunction()->GetFuncProfData()->GetStmtFreq(GetStmtID()));
+    if (freq >= 0) {
+      LogInfo::MapleLogger() << "stmtID " << GetStmtID() << "  freq " << freq << "\n";
+    }
+  }
+  LogInfo::MapleLogger() << "@" << theMIRModule->CurFunction()->GetLabelName(labelIdx) << " ";
+}
+
+void CommentNode::Dump(int32 indent) const {
+  srcPosition.DumpLoc(lastPrintedLineNum, lastPrintedColumnNum);
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "#" << comment << '\n';
+}
+
+void EmitStr(const MapleString &mplStr) {
+  const char *str = mplStr.c_str();
+  size_t len = mplStr.length();
+  LogInfo::MapleLogger() << "\"";
+
+  // don't expand special character; convert all \s to \\s in string
+  for (size_t i = 0; i < len; ++i) {
+    /* Referred to GNU AS: 3.6.1.1 Strings */
+    constexpr int kBufSize = 5;
+    constexpr int kFirstChar = 0;
+    constexpr int kSecondChar = 1;
+    constexpr int kThirdChar = 2;
+    constexpr int kLastChar = 4;
+    char buf[kBufSize];
+    if (isprint(*str)) {
+      buf[kFirstChar] = *str;
+      buf[kSecondChar] = 0;
+      if (*str == '\\' || *str == '\"') {
+        buf[kFirstChar] = '\\';
+        buf[kSecondChar] = *str;
+        buf[kThirdChar] = 0;
+      }
+      LogInfo::MapleLogger() << buf;
+    } else if (*str == '\b') {
+      LogInfo::MapleLogger() << "\\b";
+    } else if (*str == '\n') {
+      LogInfo::MapleLogger() << "\\n";
+    } else if (*str == '\r') {
+      LogInfo::MapleLogger() << "\\r";
+    } else if (*str == '\t') {
+      LogInfo::MapleLogger() << "\\t";
+    } else if (*str == '\0') {
+      buf[kFirstChar] = '\\';
+      buf[kSecondChar] = '0';
+      buf[kThirdChar] = 0;
+      LogInfo::MapleLogger() << buf;
+    } else {
+      /* all others, print as number */
+      int ret = snprintf_s(buf, sizeof(buf), kBufSize - 1, "\\%03o", static_cast<uint8>(*str) & 0xFF);
+      if (ret < 0) {
+        FATAL(kLncFatal, "snprintf_s failed");
+      }
+      buf[kLastChar] = '\0';
+      LogInfo::MapleLogger() << buf;
+    }
+    str++;
+  }
+
+  LogInfo::MapleLogger() << "\"\n";
+}
+
+bool AsmNode::IsSameContent(const BaseNode *node) const {
+  if (node->GetOpCode() != GetOpCode()) {
+    return false;
+  }
+  auto *asmNode = static_cast<const AsmNode*>(node);
+  if (asmNode->NumOpnds() != NumOpnds()) {
+    return false;
+  }
+  if (asmNode->asmString != asmString) {
+    return false;
+  }
+  for (size_t i = 0; i < inputConstraints.size(); ++i) {
+    if (asmNode->inputConstraints[i] != inputConstraints[i]) {
+      return false;
+    }
+  }
+  for (size_t i = 0; i < outputConstraints.size(); ++i) {
+    if (asmNode->outputConstraints[i] != outputConstraints[i]) {
+      return false;
+    }
+  }
+  for (size_t i = 0; i < clobberList.size(); ++i) {
+    if (asmNode->clobberList[i] != clobberList[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+AsmNode *AsmNode::CloneTree(MapleAllocator &allocator) const {
+  auto *node = allocator.GetMemPool()->New<AsmNode>(allocator, *this);
+  for (size_t i = 0; i < GetNopndSize(); ++i) {
+    node->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
+  }
+  for (size_t i = 0; i < inputConstraints.size(); ++i) {
+    node->inputConstraints.push_back(inputConstraints[i]);
+  }
+  for (size_t i = 0; i < asmOutputs.size(); ++i) {
+    node->asmOutputs.push_back(asmOutputs[i]);
+  }
+  for (size_t i = 0; i < outputConstraints.size(); ++i) {
+    node->outputConstraints.push_back(outputConstraints[i]);
+  }
+  for (size_t i = 0; i < clobberList.size(); ++i) {
+    node->clobberList.push_back(clobberList[i]);
+  }
+  for (size_t i = 0; i < gotoLabels.size(); ++i) {
+    node->gotoLabels.push_back(gotoLabels[i]);
+  }
+  node->SetNumOpnds(static_cast<uint8>(GetNopndSize()));
+  return node;
+}
+
+void AsmNode::DumpOutputs(int32 indent, std::string &uStr) const {
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << " :";
+  size_t numOutputs = asmOutputs.size();
+
+  const MIRFunction *mirFunc = theMIRModule->CurFunction();
+  if (numOutputs == 0) {
+    LogInfo::MapleLogger() << '\n';
+  } else {
+    for (size_t i = 0; i < numOutputs; i++) {
+      if (i != 0) {
+        PrintIndentation(indent + 2);  // Increase the indent by 2 bytes.
+      }
+      uStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(outputConstraints[i]);
+      PrintString(uStr);
+      LogInfo::MapleLogger() << " ";
+      StIdx stIdx = asmOutputs[i].first;
+      RegFieldPair regFieldPair = asmOutputs[i].second;
+      if (!regFieldPair.IsReg()) {
+        FieldID fieldID = regFieldPair.GetFieldID();
+        LogInfo::MapleLogger() << "dassign";
+        const MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx);
+        ASSERT(st != nullptr, "st is null");
+        LogInfo::MapleLogger() << (stIdx.Islocal() ? " %" : " $");
+        LogInfo::MapleLogger() << st->GetName() << " " << fieldID;
+      } else {
+        PregIdx regIdx = regFieldPair.GetPregIdx();
+        const MIRPreg *mirPreg = mirFunc->GetPregItem(static_cast<PregIdx>(regIdx));
+        ASSERT(mirPreg != nullptr, "mirPreg is null");
+        LogInfo::MapleLogger() << "regassign"
+                               << " " << GetPrimTypeName(mirPreg->GetPrimType());
+        LogInfo::MapleLogger() << " %" << mirPreg->GetPregNo();
+      }
+      if (i != numOutputs - 1) {
+        LogInfo::MapleLogger() << ',';
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+void AsmNode::DumpInputOperands(int32 indent, std::string &uStr) const {
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << " :";
+  if (numOpnds == 0) {
+    LogInfo::MapleLogger() << '\n';
+  } else {
+    for (size_t i = 0; i < numOpnds; i++) {
+      if (i != 0) {
+        PrintIndentation(indent + 2);  // Increase the indent by 2 bytes.
+      }
+      uStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(inputConstraints[i]);
+      PrintString(uStr);
+      LogInfo::MapleLogger() << " (";
+      GetNopndAt(i)->Dump(indent + 4);  // Increase the indent by 4 bytes.
+      LogInfo::MapleLogger() << ")";
+      if (i != static_cast<size_t>(static_cast<int64>(numOpnds - 1))) {
+        LogInfo::MapleLogger() << ',';
+      }
+      LogInfo::MapleLogger() << "\n";
+    }
+  }
+}
+
+void AsmNode::Dump(int32 indent) const {
+  srcPosition.DumpLoc(lastPrintedLineNum, lastPrintedColumnNum);
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << kOpcodeInfo.GetName(op);
+  if (GetQualifier(kASMvolatile)) {
+    LogInfo::MapleLogger() << " volatile";
+  }
+  if (GetQualifier(kASMinline)) {
+    LogInfo::MapleLogger() << " inline";
+  }
+  if (GetQualifier(kASMgoto)) {
+    LogInfo::MapleLogger() << " goto";
+  }
+  LogInfo::MapleLogger() << " { ";
+  EmitStr(asmString);
+  // print outputs
+  std::string uStr;
+  DumpOutputs(indent, uStr);
+  // print input operands
+  DumpInputOperands(indent, uStr);
+  // print clobber list
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << " :";
+  for (size_t i = 0; i < clobberList.size(); i++) {
+    uStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(clobberList[i]);
+    PrintString(uStr);
+    if (i != clobberList.size() - 1) {
+      LogInfo::MapleLogger() << ',';
+    }
+  }
+  LogInfo::MapleLogger() << '\n';
+  // print labels
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << " :";
+  for (size_t i = 0; i < gotoLabels.size(); i++) {
+    LabelIdx offset = gotoLabels[i];
+    LogInfo::MapleLogger() << " @" << theMIRModule->CurFunction()->GetLabelName(offset);
+    if (i != gotoLabels.size() - 1) {
+      LogInfo::MapleLogger() << ',';
+    }
+  }
+  LogInfo::MapleLogger() << " }\n";
+}
+
+inline bool IntTypeVerify(PrimType pTyp) {
+  return pTyp == PTY_i32 || pTyp == PTY_u32 || pTyp == PTY_i64 || pTyp == PTY_u64;
+}
+
+inline bool UnaryTypeVerify0(PrimType pTyp) {
+  bool verifyResult = IntTypeVerify(pTyp);
+  if (!verifyResult) {
+    LogInfo::MapleLogger() << "\n#Error:result type of bnot,extractbits,sext,zext must be in [i32,u32,i64,u64]\n";
+  }
+  return verifyResult;
+}
+
+bool ArithResTypeVerify(PrimType pTyp) {
+  switch (pTyp) {
+    case PTY_i32:
+    case PTY_u32:
+    case PTY_i64:
+    case PTY_u64:
+    case PTY_f32:
+    case PTY_f64:
+      return true;
+    case PTY_a32:
+    case PTY_a64:
+    case PTY_ptr:
+      return theMIRModule->IsCModule();
+    default:
+      break;
+  }
+
+  // Arithmetic operations on all vector types are allowed
+  PrimitiveType pt(pTyp);
+  if (pt.IsVector()) {
+    return true;
+  }
+  return false;
+}
+
+inline bool UnaryTypeVerify1(PrimType pType) {
+  bool verifyResult = ArithResTypeVerify(pType);
+  if (!verifyResult) {
+    LogInfo::MapleLogger() << "\n#Error:result type of abs,neg must be in [i32,u32,i64,u64,f32,f64]\n";
+  }
+  return verifyResult;
+}
+
+inline bool UnaryTypeVerify2(PrimType pType) {
+  bool verifyResult = IsPrimitiveFloat(pType);
+  if (!verifyResult) {
+    LogInfo::MapleLogger() << "\n#Error:result-type of recip,sqrt must be in [f32,f64]\n";
+  }
+  return verifyResult;
+}
+
+inline bool BinaryTypeVerify(PrimType pType) {
+  return ArithResTypeVerify(pType) || IsPrimitiveDynType(pType);
+}
+
+inline bool BinaryGenericVerify(const BaseNode &bOpnd0, const BaseNode &bOpnd1) {
+  return bOpnd0.Verify() && bOpnd1.Verify();
+}
+
+inline bool CompareTypeVerify(PrimType pType) {
+  bool verifyResult = IsPrimitiveInteger(pType);
+  if (!verifyResult) {
+    LogInfo::MapleLogger() << "\n#Error:result type of eq,ge,gt,le,lt,ne must be primitive integer\n";
+  }
+  return verifyResult;
+}
+
+enum PTYGroup {
+  kPTYGi32u32a32,
+  kPTYGi32u32a32PtrRef,
+  kPTYGi64u64a64,
+  kPTYGPtrRef,
+  kPTYGDynall,
+  kPTYGu1,
+  kPTYGSimpleObj,
+  kPTYGSimpleStr,
+  kPTYGOthers
+};
+
+uint8 GetPTYGroup(PrimType primType) {
+  switch (primType) {
+    case PTY_i32:
+    case PTY_u32:
+    case PTY_a32:
+      return kPTYGi32u32a32;
+    case PTY_i64:
+    case PTY_u64:
+    case PTY_a64:
+      return kPTYGi64u64a64;
+    case PTY_ref:
+    case PTY_ptr:
+      return kPTYGPtrRef;
+    case PTY_dynany:
+    case PTY_dyni32:
+    case PTY_dynf64:
+    case PTY_dynstr:
+    case PTY_dynobj:
+    case PTY_dynundef:
+    case PTY_dynbool:
+    case PTY_dynf32:
+    case PTY_dynnone:
+    case PTY_dynnull:
+      return kPTYGDynall;
+    case PTY_u1:
+      return kPTYGu1;
+    case PTY_simpleobj:
+      return kPTYGSimpleObj;
+    case PTY_simplestr:
+      return kPTYGSimpleStr;
+    default:
+      return kPTYGOthers;
+  }
+}
+
+uint8 GetCompGroupID(const BaseNode &opnd) {
+  return GetPTYGroup(opnd.GetPrimType());
+}
+
+/*
+  Refer to C11 Language Specification.
+  $ 6.3.1.8 Usual arithmetic conversions
+ */
+bool CompatibleTypeVerify(const BaseNode &opnd1, const BaseNode &opnd2) {
+  uint8 groupID1 = GetCompGroupID(opnd1);
+  uint8 groupID2 = GetCompGroupID(opnd2);
+  Opcode opCode2 = opnd2.GetOpCode();
+  bool verifyResult = (groupID1 == groupID2);
+  if (opCode2 == OP_gcmallocjarray || opCode2 == OP_gcpermallocjarray) {
+    verifyResult = (groupID1 == kPTYGi32u32a32);
+  }
+  if (!verifyResult) {
+    LogInfo::MapleLogger() << "\n#Error:incompatible operand types :\n";
+    opnd1.Dump();
+    opnd2.Dump();
+  }
+  return verifyResult;
+}
+
+bool FloatIntCvtTypeVerify(PrimType resPType, PrimType opndPType) {
+  bool resTypeVerf = resPType == PTY_i32 || resPType == PTY_u32 || resPType == PTY_i64 || resPType == PTY_u64;
+  if (!resTypeVerf) {
+    LogInfo::MapleLogger() << "\n#Error:result-type of ceil,floor,round,trunc must be in [i32,u32,i64,u64]\n";
+  }
+  bool opndTypeVerf = opndPType == PTY_f32 || opndPType == PTY_f64;
+  if (!opndTypeVerf) {
+    LogInfo::MapleLogger() << "\n#Error:oerand-type of ceil,floor,round,trunc must be in [f32,f64]\n";
+  }
+  return resTypeVerf && opndTypeVerf;
+}
+
+inline MIRTypeKind GetTypeKind(StIdx stIdx) {
+  const MIRSymbol *var = theMIRModule->CurFunction()->GetLocalOrGlobalSymbol(stIdx);
+  ASSERT(var != nullptr, "null ptr check");
+  MIRType *type = var->GetType();
+  ASSERT(type != nullptr, "null ptr check");
+  return type->GetKind();
+}
+
+inline MIRTypeKind GetTypeKind(TyIdx tyIdx) {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  ASSERT(type != nullptr, "null ptr check");
+  return type->GetKind();
+}
+
+inline MIRType *GetPointedMIRType(TyIdx tyIdx) {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  CHECK_FATAL(type->GetKind() == kTypePointer, "TyIdx: %d is not pointer type", static_cast<uint32>(tyIdx));
+  auto *ptrType = static_cast<MIRPtrType*>(type);
+  return ptrType->GetPointedType();
+}
+
+inline MIRTypeKind GetPointedTypeKind(TyIdx tyIdx) {
+  MIRType *pointedType = GetPointedMIRType(tyIdx);
+  ASSERT(pointedType != nullptr, "null ptr check");
+  return pointedType->GetKind();
+}
+
+MIRTypeKind GetFieldTypeKind(MIRStructType *structType, FieldID fieldId) {
+  TyIdx fieldTyIdx;
+  if (fieldId > 0) {
+    MIRType *mirType = structType->GetFieldType(fieldId);
+    fieldTyIdx = mirType->GetTypeIndex();
+  } else {
+    ASSERT(static_cast<unsigned>(-fieldId) < structType->GetParentFieldsSize() + 1, "array index out of range");
+    fieldTyIdx = structType->GetParentFieldsElemt(-fieldId - 1).second.first;
+  }
+  return GetTypeKind(fieldTyIdx);
+}
+
+inline bool IsStructureTypeKind(MIRTypeKind kind) {
+  return kind == kTypeStruct || kind == kTypeStructIncomplete || kind == kTypeUnion || kind == kTypeClass ||
+         kind == kTypeClassIncomplete || kind == kTypeInterface || kind == kTypeInterfaceIncomplete;
+}
+
+inline bool IsStructureVerify(FieldID fieldID, StIdx stIdx) {
+  if ((fieldID != 0) && (!IsStructureTypeKind(GetTypeKind(stIdx)))) {
+    LogInfo::MapleLogger() << "\n#Error:if fieldID is not 0, the variable must be a structure\n";
+    return false;
+  }
+  return true;
+}
+
+inline bool IsStructureVerify(FieldID fieldID, TyIdx tyIdx) {
+  if ((fieldID != 0) && (!IsStructureTypeKind(GetTypeKind(tyIdx)))) {
+    LogInfo::MapleLogger() << "\n#Error:if fieldID is not 0, the variable must be a structure\n";
+    return false;
+  }
+  return true;
+}
+
+bool IsSignedType(const BaseNode *opnd) {
+  switch (opnd->GetPrimType()) {
+    case PTY_i32:
+    case PTY_i64:
+    case PTY_f32:
+    case PTY_f64:
+    case PTY_dyni32:
+    case PTY_dynf32:
+    case PTY_dynf64:
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
+inline bool BinaryStrictSignVerify0(const BaseNode *bOpnd0, const BaseNode *bOpnd1) {
+  ASSERT(bOpnd0 != nullptr, "bOpnd0 is null");
+  ASSERT(bOpnd1 != nullptr, "bOpnd1 is null");
+  bool isDynany = (bOpnd0->GetPrimType() == PTY_dynany || bOpnd1->GetPrimType() == PTY_dynany);
+  return isDynany || (IsSignedType(bOpnd0) && IsSignedType(bOpnd1)) || (!IsSignedType(bOpnd0) && !IsSignedType(bOpnd1));
+}
+
+bool BinaryStrictSignVerify1(const BaseNode *bOpnd0, const BaseNode *bOpnd1, const BaseNode *res) {
+  if (GetCompGroupID(*res) == kPTYGDynall) {
+    return BinaryStrictSignVerify0(bOpnd0, res) && BinaryStrictSignVerify0(bOpnd1, res) &&
+           BinaryStrictSignVerify0(bOpnd0, bOpnd1);
+  }
+  return (IsSignedType(bOpnd0) && IsSignedType(bOpnd1) && IsSignedType(res)) ||
+         (!IsSignedType(bOpnd0) && !IsSignedType(bOpnd1) && !IsSignedType(res));
+}
+
+bool UnaryNode::Verify() const {
+  bool resTypeVerf = true;
+  if (GetOpCode() == OP_bnot) {
+    resTypeVerf = UnaryTypeVerify0(GetPrimType());
+  } else if (GetOpCode() == OP_lnot) {
+    if (!IsPrimitiveInteger(GetPrimType())) {
+      resTypeVerf = false;
+      LogInfo::MapleLogger() << "\n#Error:result-type of lnot must be primitive integer\n";
+    }
+  } else if (GetOpCode() == OP_abs || GetOpCode() == OP_neg) {
+    resTypeVerf = UnaryTypeVerify1(GetPrimType());
+  } else if (GetOpCode() == OP_recip || GetOpCode() == OP_sqrt) {
+    resTypeVerf = UnaryTypeVerify2(GetPrimType());
+  }
+
+  // When an opcode only specifies one type, check for compatibility
+  // between the operands and the result-type.
+  bool compVerf = true;
+  // op_alloca : return type is not compatible with operand, skip
+  if (GetOpCode() != OP_alloca) {
+    compVerf = CompatibleTypeVerify(*uOpnd, *this);
+  }
+  bool opndExprVerf = uOpnd->Verify();
+  return resTypeVerf && compVerf && opndExprVerf;
+}
+
+bool TypeCvtNode::Verify() const {
+  bool opndTypeVerf = true;
+  bool opndSizeVerf = true;
+  if (GetOpCode() == OP_ceil || GetOpCode() == OP_floor || GetOpCode() == OP_round || GetOpCode() == OP_trunc) {
+    opndTypeVerf = FloatIntCvtTypeVerify(GetPrimType(), Opnd(0)->GetPrimType());
+  } else if (GetOpCode() == OP_retype) {
+    if (GetPrimTypeSize(GetPrimType()) != GetPrimTypeSize(Opnd(0)->GetPrimType())) {
+      opndSizeVerf = false;
+      LogInfo::MapleLogger() << "\n#Error:The size of opnd0 and prim-type must be the same\n";
+    }
+  }
+  bool opndExprVerf = Opnd(0)->Verify();
+  return opndTypeVerf && opndSizeVerf && opndExprVerf;
+}
+
+void AddRuntimeVerifyError(std::string errMsg, VerifyResult &verifyResult) {
+  LogInfo::MapleLogger() << "\n#Error: " << errMsg << '\n';
+  // Throw Verify Error
+  verifyResult.AddPragmaVerifyError(verifyResult.GetCurrentClassName(), std::move(errMsg));
+}
+
+bool RetypeNode::VerifyPrimTypesAndOpnd() const {
+  PrimType toPrimType = GetPrimType();
+  PrimType fromPrimType = Opnd(0)->GetPrimType();
+  if (GetPrimTypeSize(toPrimType) != GetPrimTypeSize(fromPrimType)) {
+    LogInfo::MapleLogger() << "\n#Error: The size of opnd0 and prim-type must be the same\n";
+    return false;
+  }
+
+  if (!IsPrimitivePoint(toPrimType) || !IsPrimitivePoint(fromPrimType)) {
+    LogInfo::MapleLogger() << "\n#Error: Wrong prim-type in retype node, should be ref or ptr\n";
+    return false;
+  }
+  return Opnd(0)->Verify();
+}
+
+bool RetypeNode::CheckFromJarray(const MIRType &from, const MIRType &to, VerifyResult &verifyResult) const {
+  // Array types are subtypes of Object.
+  // The intent is also that array types are subtypes of Cloneable and java.io.Serializable.
+  if (IsInterfaceOrClass(to)) {
+    Klass &toKlass = utils::ToRef(verifyResult.GetKlassHierarchy().GetKlassFromStrIdx(to.GetNameStrIdx()));
+    const std::string &toKlassName = toKlass.GetKlassName();
+    const std::string &javaLangObject = namemangler::kJavaLangObjectStr;
+    const std::string javaLangCloneable = "Ljava_2Flang_2FCloneable_3B";
+    const std::string javaIoSerializable = "Ljava_2Fio_2FSerializable_3B";
+    if (toKlassName == javaLangObject || toKlassName == javaIoSerializable || toKlassName == javaLangCloneable) {
+      return true;
+    }
+  }
+
+  AddRuntimeVerifyError("Java array " + from.GetName() + " is not assignable to " + to.GetName(), verifyResult);
+  return false;
+}
+
+bool RetypeNode::IsJavaAssignable(const MIRType &from, const MIRType &to, VerifyResult &verifyResult) const {
+  // isJavaAssignable(arrayOf(X), arrayOf(Y)) :- compound(X), compound(Y), isJavaAssignable(X, Y).
+  // arrayOf(X), arrayOf(Y) should already be X, Y here
+  if (from.IsMIRJarrayType()) {
+    return CheckFromJarray(from, to, verifyResult);
+  }
+  // isJavaAssignable(arrayOf(X), arrayOf(Y)) :- atom(X), atom(Y), X = Y.
+  // This rule is not applicable to Maple IR
+  if (from.IsScalarType() && to.IsScalarType()) {
+    return true;
+  }
+
+  if (IsInterfaceOrClass(from) && IsInterfaceOrClass(to)) {
+    const KlassHierarchy &klassHierarchy = verifyResult.GetKlassHierarchy();
+    const std::string javaLangObject = namemangler::kJavaLangObjectStr;
+    Klass &fromKlass = utils::ToRef(klassHierarchy.GetKlassFromStrIdx(from.GetNameStrIdx()));
+    Klass &toKlass = utils::ToRef(klassHierarchy.GetKlassFromStrIdx(to.GetNameStrIdx()));
+    // We can cast everything to java.lang.Object, but interface isn't subclass of that, so we need this branch
+    if (toKlass.GetKlassName() == javaLangObject) {
+      return true;
+    }
+    // isJavaAssignable(class(_, _), class(To, L)) :- loadedClass(To, L, ToClass), classIsInterface(ToClass).
+    // isJavaAssignable(From, To) :- isJavaSubclassOf(From, To).
+    bool isAssignableKlass = klassHierarchy.IsSuperKlass(&toKlass, &fromKlass) ||
+                             klassHierarchy.IsSuperKlassForInterface(&toKlass, &fromKlass) ||
+                             klassHierarchy.IsInterfaceImplemented(&toKlass, &fromKlass);
+    if (isAssignableKlass) {
+      return true;
+    }
+    AddRuntimeVerifyError("Java type " + fromKlass.GetKlassName() + " is NOT assignable to " + toKlass.GetKlassName(),
+                          verifyResult);
+    return false;
+  }
+  AddRuntimeVerifyError(from.GetName() + " is NOT assignable to " + to.GetName(), verifyResult);
+  return false;
+}
+
+bool RetypeNode::VerifyCompleteMIRType(const MIRType &from, const MIRType &to, bool isJavaRefType,
+                                       VerifyResult &verifyResult) const {
+  if (from.IsScalarType() && to.IsScalarType() && !isJavaRefType) {
+    if (GetPTYGroup(from.GetPrimType()) == GetPTYGroup(to.GetPrimType())) {
+      return true;
+    }
+    LogInfo::MapleLogger() << "\n#Error: retype scalar type failed\n";
+    return false;
+  }
+  if (!verifyResult.GetMIRModule().IsJavaModule()) {
+    return true;
+  }
+  isJavaRefType = (IsJavaRefType(from) && IsJavaRefType(to)) || isJavaRefType;
+  if (isJavaRefType) {
+    return IsJavaAssignable(from, to, verifyResult);
+  }
+
+  if (from.GetKind() != to.GetKind()) {
+    if (from.GetPrimType() == PTY_void || to.GetPrimType() == PTY_void) {
+      return true;
+    }
+    LogInfo::MapleLogger() << "\n#Error: Retype different kind: from " << from.GetKind() << " to " << to.GetKind()
+                           << "\n";
+    return false;
+  }
+  return true;
+}
+
+bool RetypeNode::VerifyJarrayDimention(const MIRJarrayType &from, const MIRJarrayType &to,
+                                       VerifyResult &verifyResult) const {
+  int fromDim = const_cast<MIRJarrayType&>(from).GetDim();
+  int toDim = const_cast<MIRJarrayType&>(to).GetDim();
+  if (fromDim == toDim) {
+    return true;
+  } else if (fromDim > toDim) {
+    const MIRType *toElemType = to.GetElemType();
+    while (toElemType != nullptr && (toElemType->IsMIRJarrayType() || toElemType->IsMIRPtrType())) {
+      toElemType = toElemType->IsMIRJarrayType() ? static_cast<const MIRJarrayType*>(toElemType)->GetElemType()
+                                                 : static_cast<const MIRPtrType*>(toElemType)->GetPointedType();
+    }
+    if (toElemType != nullptr && CheckFromJarray(from, *toElemType, verifyResult)) {
+      return true;
+    }
+  }
+  Dump(0);
+  std::string errorMsg =
+      "Arrays have different dimentions: from " + std::to_string(fromDim) + " to " + std::to_string(toDim);
+  AddRuntimeVerifyError(std::move(errorMsg), verifyResult);
+  return false;
+}
+
+bool RetypeNode::Verify(VerifyResult &verifyResult) const {
+  // If RetypeNode::Verify return false, Dump this node to show the wrong IR
+  if (!VerifyPrimTypesAndOpnd()) {
+    Dump(0);
+    LogInfo::MapleLogger() << "\n#Error: Verify PrimTypes and Opnd failed in retype node\n";
+    return false;
+  }
+  bool isJavaRefType = false;
+  const MIRType *fromMIRType = verifyResult.GetCurrentFunction()->GetNodeType(*Opnd(0));
+  const MIRType *toMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  while (fromMIRType != nullptr && toMIRType != nullptr && BothPointerOrJarray(*fromMIRType, *toMIRType)) {
+    if (fromMIRType->IsMIRJarrayType()) {
+      isJavaRefType = true;
+      if (!VerifyJarrayDimention(static_cast<const MIRJarrayType&>(*fromMIRType),
+                                 static_cast<const MIRJarrayType&>(*toMIRType), verifyResult)) {
+        return false;
+      }
+      fromMIRType = static_cast<const MIRJarrayType*>(fromMIRType)->GetElemType();
+      toMIRType = static_cast<const MIRJarrayType*>(toMIRType)->GetElemType();
+    } else {
+      fromMIRType = static_cast<const MIRPtrType*>(fromMIRType)->GetPointedType();
+      toMIRType = static_cast<const MIRPtrType*>(toMIRType)->GetPointedType();
+    }
+  }
+  if (fromMIRType == nullptr || toMIRType == nullptr) {
+    Dump(0);
+    LogInfo::MapleLogger() << "\n#Error: MIRType is nullptr in retype node\n";
+    return false;
+  }
+
+  if (fromMIRType->IsIncomplete() || toMIRType->IsIncomplete()) {
+    // Add Deferred Check
+    const std::string &currentClassName = verifyResult.GetCurrentClassName();
+    LogInfo::MapleLogger(kLlDbg) << "Add AssignableCheck from " << fromMIRType->GetName() << " to "
+                                 << toMIRType->GetName() << " in class " << currentClassName << '\n';
+    verifyResult.AddPragmaAssignableCheck(currentClassName, fromMIRType->GetName(), toMIRType->GetName());
+    // Deferred Assignable Check returns true because we should collect all the deferred checks for runtime
+    return true;
+  }
+
+  if (VerifyCompleteMIRType(*fromMIRType, *toMIRType, isJavaRefType, verifyResult)) {
+    return true;
+  }
+  Dump(0);
+  LogInfo::MapleLogger() << "\n#Error: Verify Complete MIRType failed in retype node\n";
+  return false;
+}
+
+bool UnaryStmtNode::VerifyThrowable(VerifyResult &verifyResult) const {
+  const BaseNode *rhs = GetRHS();
+  if (rhs == nullptr) {
+    return true;
+  }
+
+  const MIRType *mirType = verifyResult.GetCurrentFunction()->GetNodeType(*rhs);
+  if (mirType != nullptr && mirType->IsMIRPtrType()) {
+    mirType = static_cast<const MIRPtrType*>(mirType)->GetPointedType();
+  }
+  if (mirType != nullptr) {
+    if (mirType->GetPrimType() == PTY_void) {
+      return true;
+    }
+    if (mirType->IsIncomplete()) {
+      // Add Deferred Check
+      const std::string &currentClassName = verifyResult.GetCurrentClassName();
+      std::string throwableName = "Ljava_2Flang_2FThrowable_3B";
+      LogInfo::MapleLogger(kLlDbg) << "Add AssignableCheck from " << mirType->GetName() << " to " << throwableName
+                                   << " in class " << currentClassName << '\n';
+      verifyResult.AddPragmaAssignableCheck(currentClassName, mirType->GetName(), std::move(throwableName));
+      // Deferred Assignable Check returns true because we should collect all the deferred checks for runtime
+      return true;
+    }
+    if (mirType->IsMIRClassType() && static_cast<const MIRClassType*>(mirType)->IsExceptionType()) {
+      return true;
+    }
+  }
+  Dump(0);
+  std::string errMsg = (mirType == nullptr ? "nullptr" : mirType->GetName());
+  errMsg += " is NOT throwable.";
+  AddRuntimeVerifyError(std::move(errMsg), verifyResult);
+  return false;
+}
+
+bool IntrinsicopNode::Verify(VerifyResult &verifyResult) const {
+  if (GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH && !VerifyJArrayLength(verifyResult)) {
+    return false;
+  }
+  return VerifyOpnds();
+}
+
+bool IntrinsicopNode::VerifyJArrayLength(VerifyResult &verifyResult) const {
+  BaseNode &val = utils::ToRef(Opnd(0));
+  const MIRType *valType = verifyResult.GetCurrentFunction()->GetNodeType(val);
+  if (valType != nullptr && valType->IsMIRPtrType()) {
+    valType = static_cast<const MIRPtrType*>(valType)->GetPointedType();
+    if (valType != nullptr && !valType->IsMIRJarrayType()) {
+      Dump(0);
+      AddRuntimeVerifyError("Operand of array length is not array", verifyResult);
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IreadNode::Verify() const {
+  bool addrExprVerf = Opnd(0)->Verify();
+  bool pTypeVerf = true;
+  bool structVerf = true;
+  if (GetTypeKind(tyIdx) != kTypePointer) {
+    LogInfo::MapleLogger() << "\n#Error:<type> must be a pointer type\n";
+    return false;
+  }
+  if (GetOpCode() == OP_iaddrof) {
+    pTypeVerf = IsAddress(GetPrimType());
+    if (!pTypeVerf) {
+      LogInfo::MapleLogger() << "\n#Error:prim-type must be either ptr, ref, a32 or a64\n";
+    }
+  } else {
+    if (fieldID == 0 && IsStructureTypeKind(GetPointedTypeKind(tyIdx))) {
+      if (GetPrimType() != PTY_agg) {
+        pTypeVerf = false;
+        LogInfo::MapleLogger()
+            << "\n#Error:If the content dereferenced is a structure, then <prim-type> should specify agg\n";
+      }
+    }
+  }
+  if (fieldID != 0) {
+    if (!IsStructureTypeKind(GetPointedTypeKind(tyIdx))) {
+      structVerf = false;
+      LogInfo::MapleLogger() << "\n#Error:If field-id is not 0, then type must specify pointer to a structure\n";
+    } else {
+      MIRType *type = GetPointedMIRType(tyIdx);
+      auto *stTy = static_cast<MIRStructType*>(type);
+      if (GetOpCode() == OP_iread && stTy->GetFieldsSize() != 0) {
+        if (IsStructureTypeKind(GetFieldTypeKind(stTy, fieldID))) {
+          if (GetPrimType() != PTY_agg) {
+            pTypeVerf = false;
+            LogInfo::MapleLogger() << "\n#Error:If the field itself is a structure, prim-type should specify agg\n";
+          }
+        }
+      }
+    }
+  }
+  return addrExprVerf && pTypeVerf && structVerf;
+}
+
+bool RegreadNode::Verify() const {
+  return true;
+}
+
+bool IreadoffNode::Verify() const {
+  return true;
+}
+
+bool IreadFPoffNode::Verify() const {
+  return true;
+}
+
+bool ExtractbitsNode::Verify() const {
+  bool opndExprVerf = Opnd(0)->Verify();
+  bool compVerf = CompatibleTypeVerify(*Opnd(0), *this);
+  bool resTypeVerf = UnaryTypeVerify0(GetPrimType());
+  constexpr int numBitsInByte = 8;
+  bool opnd0SizeVerf = (numBitsInByte * GetPrimTypeSize(Opnd(0)->GetPrimType()) >= bitsSize);
+  if (!opnd0SizeVerf) {
+    LogInfo::MapleLogger()
+        << "\n#Error: The operand of extractbits must be large enough to contain the specified bitfield\n";
+  }
+  return opndExprVerf && compVerf && resTypeVerf && opnd0SizeVerf;
+}
+
+bool BinaryNode::Verify() const {
+  bool opndsVerf = BinaryGenericVerify(*GetBOpnd(0), *GetBOpnd(1));
+  bool resTypeVerf = BinaryTypeVerify(GetPrimType());
+  if (!resTypeVerf && theMIRModule->IsCModule()) {
+    if ((IsAddress(GetBOpnd(0)->GetPrimType()) && !IsAddress(GetBOpnd(1)->GetPrimType())) ||
+        (!IsAddress(GetBOpnd(0)->GetPrimType()) && IsAddress(GetBOpnd(1)->GetPrimType()))) {
+      resTypeVerf = true;  // don't print the same kind of error message twice
+      if (GetOpCode() != OP_add && GetOpCode() != OP_sub && GetOpCode() != OP_CG_array_elem_add) {
+        LogInfo::MapleLogger() << "\n#Error: Only add and sub are allowed for pointer arithemetic\n";
+        this->Dump();
+      } else if (!IsAddress(GetPrimType())) {
+        LogInfo::MapleLogger()
+            << "\n#Error: Adding an offset to a pointer or subtracting one from a pointer should result in a pointer "
+               "value\n";
+        this->Dump();
+      }
+    }
+  }
+  if (!resTypeVerf) {
+    LogInfo::MapleLogger()
+        << "\n#Error:result type of [add,div,sub,mul,max,min] and [ashr,band,bior,bxor,land,lior,lshr,shl,rem] must "
+           "be in [i32,u32,i64,u64,f32,f64,dynamic-type]\n";
+    this->Dump();
+  }
+  bool comp0Verf = CompatibleTypeVerify(*GetBOpnd(0), *this);
+  bool comp1Verf = true;
+  // Shift operations do not require same-type operands
+  if (GetOpCode() < OP_ashr || GetOpCode() > OP_shl) {
+    comp1Verf = CompatibleTypeVerify(*GetBOpnd(1), *this);
+  }
+  bool signVerf = true;
+  bool typeVerf = resTypeVerf && comp0Verf && comp1Verf;
+  if (typeVerf) {
+    if (GetOpCode() == OP_div || GetOpCode() == OP_mul || GetOpCode() == OP_rem || GetOpCode() == OP_max ||
+        GetOpCode() == OP_min) {
+      signVerf = BinaryStrictSignVerify1(GetBOpnd(0), GetBOpnd(1), this);
+      if (!signVerf) {
+        LogInfo::MapleLogger()
+            << "\n#Error:the result and operands of [div,mul,rem,max,min] must be of the same sign\n";
+      }
+    }
+  }
+  return opndsVerf && typeVerf && signVerf;
+}
+
+bool CompareNode::Verify() const {
+  bool opndsVerf = BinaryGenericVerify(*GetBOpnd(0), *GetBOpnd(1));
+  bool compVerf = CompatibleTypeVerify(*GetBOpnd(0), *GetBOpnd(1));
+  bool resTypeVerf = CompareTypeVerify(GetPrimType());
+  if (!resTypeVerf) {
+    this->Dump();
+  }
+  bool signVerf = true;
+  bool typeVerf = compVerf && resTypeVerf;
+  if (typeVerf && GetOpCode() != OP_eq && GetOpCode() != OP_ne) {
+    signVerf = BinaryStrictSignVerify0(GetBOpnd(0), GetBOpnd(1));
+    if (!signVerf) {
+      LogInfo::MapleLogger() << "\n#Error:the operands of [ge,gt,le,lt] must be of the same sign\n";
+    }
+  }
+  return opndsVerf && typeVerf && signVerf;
+}
+
+bool DepositbitsNode::Verify() const {
+  bool opndsVerf = BinaryGenericVerify(*GetBOpnd(0), *GetBOpnd(1));
+  bool resTypeVerf = IntTypeVerify(GetPrimType());
+  constexpr int numBitsInByte = 8;
+  bool opnd0SizeVerf = (numBitsInByte * GetPrimTypeSize(GetBOpnd(0)->GetPrimType()) >= bitsSize);
+  if (!opnd0SizeVerf) {
+    LogInfo::MapleLogger() << "\n#Error:opnd0 of depositbits must be large enough to contain the specified bitfield\n";
+  }
+  return opndsVerf && resTypeVerf && opnd0SizeVerf;
+}
+
+bool IntrinsicopNode::Verify() const {
+  return VerifyOpnds();
+}
+
+bool TernaryNode::Verify() const {
+  bool comp1Verf = CompatibleTypeVerify(*topnd[kSecondOpnd], *this);
+  bool comp2Verf = CompatibleTypeVerify(*topnd[kThirdOpnd], *this);
+  bool opnd0TypeVerf = IsPrimitiveInteger(topnd[kFirstOpnd]->GetPrimType());
+  if (!opnd0TypeVerf) {
+    LogInfo::MapleLogger() << "\n#Error:select-opnd0 must be of integer type\n";
+  }
+  return comp1Verf && comp2Verf && opnd0TypeVerf;
+}
+
+bool SizeoftypeNode::Verify() const {
+  return true;
+}
+
+bool ArrayNode::Verify() const {
+  bool opndsVerf = VerifyOpnds();
+  bool resTypeVerf = IsAddress(GetPrimType());
+  bool opndsTypeVerf = true;
+  if (!resTypeVerf) {
+    LogInfo::MapleLogger() << "\n#Error:result-type of array must be in [ptr,ref,a32,a64]\n";
+  }
+  bool opnd0TypeVerf = IsAddress(GetNopndAt(0)->GetPrimType());
+  if (!opnd0TypeVerf) {
+    LogInfo::MapleLogger() << "\n#Error:result-type of array-opnd0 must be in [ptr,ref,a32,a64]\n";
+  }
+  for (size_t i = 1; i < NumOpnds(); ++i) {
+    if (!IntTypeVerify(GetNopndAt(i)->GetPrimType())) {
+      opndsTypeVerf = false;
+      LogInfo::MapleLogger() << "\n#Error:result of the array index operands must be in [i32,u32,i64,u64]\n";
+    }
+  }
+  return opndsVerf && resTypeVerf && opnd0TypeVerf && opndsTypeVerf;
+}
+
+bool DassignNode::Verify() const {
+  bool structVerf = IsStructureVerify(fieldID, stIdx);
+  bool rhsVerf = GetRHS()->Verify();
+  return structVerf && rhsVerf;
+}
+
+bool AddrofNode::Verify() const {
+  bool pTypeVerf = true;
+  bool structVerf = IsStructureVerify(fieldID, GetStIdx());
+  if (GetOpCode() == OP_dread) {
+    if (fieldID == 0 && IsStructureTypeKind(GetTypeKind(GetStIdx()))) {
+      if (GetPrimType() != PTY_agg) {
+        pTypeVerf = false;
+        LogInfo::MapleLogger() << "\n#Error:if variable is a structure, prim-type should specify agg\n";
+      }
+    }
+    if (fieldID != 0 && structVerf) {
+      const MIRSymbol *var = theMIRModule->CurFunction()->GetLocalOrGlobalSymbol(GetStIdx());
+      ASSERT(var != nullptr, "null ptr check");
+      MIRType *type = var->GetType();
+      auto *stTy = static_cast<MIRStructType*>(type);
+      if (IsStructureTypeKind(GetFieldTypeKind(stTy, fieldID))) {
+        if (GetPrimType() != PTY_agg) {
+          pTypeVerf = false;
+          LogInfo::MapleLogger() << "\n#Error:if the field itself is a structure, prim-type should specify agg\n";
+        }
+      }
+    }
+  } else {
+    pTypeVerf = IsAddress(GetPrimType());
+    if (!pTypeVerf) {
+      LogInfo::MapleLogger()
+          << "\n#Error:result-type of addrof,addroflabel,addroffunc,iaddrof must be in [ptr,ref,a32,a64]\n";
+    }
+  }
+  return pTypeVerf && structVerf;
+}
+
+bool AddroffuncNode::Verify() const {
+  bool addrTypeVerf = IsAddress(GetPrimType());
+  if (!addrTypeVerf) {
+    LogInfo::MapleLogger()
+        << "\n#Error:result-type of addrof,addroflabel,addroffunc,iaddrof must be in [ptr,ref,a32,a64]\n";
+  }
+  return addrTypeVerf;
+}
+
+bool AddroflabelNode::Verify() const {
+  bool addrTypeVerf = IsAddress(GetPrimType());
+  if (!addrTypeVerf) {
+    LogInfo::MapleLogger()
+        << "\n#Error:result-type of addrof,addroflabel,addroffunc,iaddrof must be in [ptr,ref,a32,a64]\n";
+  }
+  return addrTypeVerf;
+}
+
+bool IassignNode::Verify() const {
+  bool addrExpVerf = addrExpr->Verify();
+  bool rhsVerf = rhs->Verify();
+  bool structVerf = true;
+  if (GetTypeKind(tyIdx) != kTypePointer) {
+    LogInfo::MapleLogger() << "\n#Error:<type> must be a pointer type\n";
+    return false;
+  }
+  if (fieldID != 0) {
+    if (!IsStructureTypeKind(GetPointedTypeKind(tyIdx))) {
+      structVerf = false;
+      LogInfo::MapleLogger() << "\n#Error:If field-id is not 0, the computed address must correspond to a structure\n";
+    }
+  }
+  return addrExpVerf && rhsVerf && structVerf;
+}
+
+bool IassignoffNode::Verify() const {
+  bool addrVerf = GetBOpnd(0)->Verify();
+  bool rhsVerf = GetBOpnd(1)->Verify();
+  bool compVerf = CompatibleTypeVerify(*this, *GetBOpnd(1));
+  return addrVerf && rhsVerf && compVerf;
+}
+
+bool IassignFPoffNode::Verify() const {
+  bool rhsVerf = Opnd(0)->Verify();
+  bool compVerf = CompatibleTypeVerify(*this, *Opnd(0));
+  return rhsVerf && compVerf;
+}
+
+bool RegassignNode::Verify() const {
+  bool rhsVerf = Opnd(0)->Verify();
+  bool compVerf = CompatibleTypeVerify(*this, *Opnd(0));
+  return rhsVerf && compVerf;
+}
+
+bool CondGotoNode::Verify() const {
+  bool opndExprVerf = UnaryStmtNode::Opnd(0)->Verify();
+  bool opndTypeVerf = true;
+  if (!IsPrimitiveInteger(UnaryStmtNode::Opnd(0)->GetPrimType())) {
+    opndTypeVerf = false;
+    LogInfo::MapleLogger() << "\n#Error:the operand of brfalse and trfalse must be primitive integer\n";
+  }
+  return opndExprVerf && opndTypeVerf;
+}
+
+bool SwitchNode::Verify() const {
+  bool opndExprVerf = switchOpnd->Verify();
+  bool opndTypeVerf = IntTypeVerify(switchOpnd->GetPrimType());
+  if (!opndTypeVerf) {
+    LogInfo::MapleLogger() << "\n#Error: the operand of switch must be in [i32,u32,i64,u64]\n";
+  }
+  return opndExprVerf && opndTypeVerf;
+}
+
+bool BinaryStmtNode::Verify() const {
+  return GetBOpnd(0)->Verify() && GetBOpnd(1)->Verify() && CompatibleTypeVerify(*GetBOpnd(0), *GetBOpnd(1)) &&
+         BinaryStrictSignVerify0(GetBOpnd(0), GetBOpnd(1));
+}
+
+bool RangeGotoNode::Verify() const {
+  bool opndExprVerf = Opnd(0)->Verify();
+  bool opndTypeVerf = IntTypeVerify(Opnd(0)->GetPrimType());
+  if (!opndTypeVerf) {
+    LogInfo::MapleLogger() << "\n#Error: the operand of rangegoto must be in [i32,u32,i64,u64]\n";
+  }
+  return opndExprVerf && opndTypeVerf;
+}
+
+bool BlockNode::Verify() const {
+  for (auto &stmt : GetStmtNodes()) {
+    if (!stmt.Verify()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool BlockNode::Verify(VerifyResult &verifyResult) const {
+  auto &nodes = GetStmtNodes();
+  return !std::any_of(nodes.begin(), nodes.end(), [&verifyResult](auto &stmt) { return !stmt.Verify(verifyResult); });
+}
+
+bool DoloopNode::Verify() const {
+  bool startVerf = startExpr->Verify();
+  bool contVerf = condExpr->Verify();
+  bool incrVerf = incrExpr->Verify();
+  bool doBodyVerf = true;
+  if (doBody) {
+    doBodyVerf = doBody->Verify();
+  }
+  return startVerf && contVerf && incrVerf && doBodyVerf;
+}
+
+bool IfStmtNode::Verify() const {
+  bool condVerf = Opnd()->Verify();
+  bool thenVerf = true;
+  bool elseVerf = true;
+  if (thenPart != nullptr) {
+    thenVerf = thenPart->Verify();
+  }
+  if (elsePart != nullptr) {
+    elseVerf = elsePart->Verify();
+  }
+  return condVerf && thenVerf && elseVerf;
+}
+
+bool WhileStmtNode::Verify() const {
+  bool condVerf = Opnd(0)->Verify();
+  bool bodyVerf = true;
+  if (body != nullptr) {
+    bodyVerf = body->Verify();
+  }
+  return condVerf && bodyVerf;
+}
+
+bool NaryStmtNode::Verify() const {
+  return VerifyOpnds();
+}
+
+bool CallNode::Verify() const {
+  return VerifyOpnds();
+}
+
+bool IcallNode::Verify() const {
+  bool nOpndsVerf = true;
+  for (size_t i = 0; i < NumOpnds(); ++i) {
+    if (!GetNopndAt(i)->Verify()) {
+      nOpndsVerf = false;
+      break;
+    }
+  }
+  return nOpndsVerf;
+}
+
+bool IntrinsiccallNode::Verify() const {
+  return VerifyOpnds();
+}
+
+std::string SafetyCallCheckStmtNode::GetFuncName() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(callFuncNameIdx);
+}
+
+std::string SafetyCallCheckStmtNode::GetStmtFuncName() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(stmtFuncNameIdx);
+}
+
+std::string SafetyCheckStmtNode::GetFuncName() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(funcNameIdx);
+}
+
+bool UnaryNode::IsSameContent(const BaseNode *node) const {
+  auto *unaryNode = dynamic_cast<const UnaryNode*>(node);
+  if ((this == unaryNode) ||
+      (unaryNode != nullptr && (GetOpCode() == unaryNode->GetOpCode()) && (GetPrimType() == unaryNode->GetPrimType()) &&
+       (uOpnd && unaryNode->Opnd(0) && uOpnd->IsSameContent(unaryNode->Opnd(0))))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool TypeCvtNode::IsSameContent(const BaseNode *node) const {
+  auto *tyCvtNode = dynamic_cast<const TypeCvtNode*>(node);
+  if ((this == tyCvtNode) ||
+      (tyCvtNode != nullptr && (fromPrimType == tyCvtNode->FromType()) && UnaryNode::IsSameContent(tyCvtNode))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool IreadNode::IsSameContent(const BaseNode *node) const {
+  auto *ireadNode = dynamic_cast<const IreadNode*>(node);
+  if ((this == ireadNode) || (ireadNode != nullptr && (tyIdx == ireadNode->GetTyIdx()) &&
+                              (fieldID == ireadNode->GetFieldID()) && UnaryNode::IsSameContent(ireadNode))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool IreadoffNode::IsSameContent(const BaseNode *node) const {
+  auto *ireadoffNode = dynamic_cast<const IreadoffNode*>(node);
+  if ((this == ireadoffNode) || (ireadoffNode != nullptr && (GetOffset() == ireadoffNode->GetOffset()) &&
+                                 UnaryNode::IsSameContent(ireadoffNode))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool IreadFPoffNode::IsSameContent(const BaseNode *node) const {
+  auto *ireadFPoffNode = dynamic_cast<const IreadFPoffNode*>(node);
+  if ((this == ireadFPoffNode) ||
+      (ireadFPoffNode != nullptr && (GetOpCode() == ireadFPoffNode->GetOpCode()) &&
+       (GetPrimType() == ireadFPoffNode->GetPrimType()) && (GetOffset() == ireadFPoffNode->GetOffset()))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool BinaryOpnds::IsSameContent(const BaseNode *node) const {
+  auto *binaryOpnds = dynamic_cast<const BinaryOpnds*>(node);
+  if ((this == binaryOpnds) || (binaryOpnds != nullptr && GetBOpnd(0)->IsSameContent(binaryOpnds->GetBOpnd(0)) &&
+                                GetBOpnd(1)->IsSameContent(binaryOpnds->GetBOpnd(1)))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool BinaryNode::IsSameContent(const BaseNode *node) const {
+  auto *binaryNode = dynamic_cast<const BinaryNode*>(node);
+  if ((this == binaryNode) ||
+      (binaryNode != nullptr && (GetOpCode() == binaryNode->GetOpCode()) &&
+       (GetPrimType() == binaryNode->GetPrimType()) && BinaryOpnds::IsSameContent(binaryNode))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool ConstvalNode::IsSameContent(const BaseNode *node) const {
+  auto *constvalNode = dynamic_cast<const ConstvalNode*>(node);
+  if (this == constvalNode) {
+    return true;
+  }
+  if (constvalNode == nullptr) {
+    return false;
+  }
+  const MIRConst *mirConst = constvalNode->GetConstVal();
+  if (constVal == mirConst) {
+    return true;
+  }
+  if (constVal->GetKind() != mirConst->GetKind()) {
+    return false;
+  }
+  if (constVal->GetKind() == kConstInt) {
+    // integer may differ in primtype, and they may be different MIRIntConst Node
+    auto &thisValue = static_cast<MIRIntConst*>(constVal)->GetValue();
+    auto &rightValue = static_cast<const MIRIntConst*>(mirConst)->GetValue();
+    return thisValue.Equal(rightValue, GetPrimType()) && thisValue.Equal(rightValue, node->GetPrimType());
+  } else {
+    return false;
+  }
+}
+
+bool ConststrNode::IsSameContent(const BaseNode *node) const {
+  if (node->GetOpCode() != OP_conststr) {
+    return false;
+  }
+  auto *cstrNode = static_cast<const ConststrNode*>(node);
+  return strIdx == cstrNode->strIdx;
+}
+
+bool Conststr16Node::IsSameContent(const BaseNode *node) const {
+  if (node->GetOpCode() != OP_conststr16) {
+    return false;
+  }
+  auto *cstr16Node = static_cast<const Conststr16Node*>(node);
+  return strIdx == cstr16Node->strIdx;
+}
+
+bool AddrofNode::IsSameContent(const BaseNode *node) const {
+  return (GetOpCode() == node->GetOpCode()) && (GetPrimType() == node->GetPrimType()) && MayAccessSameMemory(node);
+}
+
+// identify dread and address of nodes that may use same memory localtion
+bool AddrofNode::MayAccessSameMemory(const BaseNode *node) const {
+  auto *addrofNode = dynamic_cast<const AddrofNode*>(node);
+  if ((this == addrofNode) ||
+      (addrofNode != nullptr && (GetNumOpnds() == addrofNode->GetNumOpnds()) &&
+      (stIdx.FullIdx() == addrofNode->GetStIdx().FullIdx()) && (fieldID == addrofNode->GetFieldID()))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool DreadoffNode::IsSameContent(const BaseNode *node) const {
+  auto *dreaddoffNode = dynamic_cast<const DreadoffNode*>(node);
+  if ((this == dreaddoffNode) || (dreaddoffNode != nullptr && (GetOpCode() == dreaddoffNode->GetOpCode()) &&
+                                  (GetPrimType() == dreaddoffNode->GetPrimType()) && (stIdx == dreaddoffNode->stIdx) &&
+                                  (offset == dreaddoffNode->offset))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool RegreadNode::IsSameContent(const BaseNode *node) const {
+  auto *regreadNode = dynamic_cast<const RegreadNode*>(node);
+  if ((this == regreadNode) ||
+      (regreadNode != nullptr && (GetOpCode() == regreadNode->GetOpCode()) &&
+       (GetPrimType() == regreadNode->GetPrimType()) && (regIdx == regreadNode->GetRegIdx()))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool AddroffuncNode::IsSameContent(const BaseNode *node) const {
+  auto *addroffuncNode = dynamic_cast<const AddroffuncNode*>(node);
+  if ((this == addroffuncNode) ||
+      (addroffuncNode != nullptr && (GetOpCode() == addroffuncNode->GetOpCode()) &&
+       (GetPrimType() == addroffuncNode->GetPrimType()) && (puIdx == addroffuncNode->GetPUIdx()))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool AddroflabelNode::IsSameContent(const BaseNode *node) const {
+  auto *addroflabelNode = dynamic_cast<const AddroflabelNode*>(node);
+  if ((this == addroflabelNode) ||
+      (addroflabelNode != nullptr && (GetOpCode() == addroflabelNode->GetOpCode()) &&
+       (GetPrimType() == addroflabelNode->GetPrimType()) && (offset == addroflabelNode->GetOffset()))) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+MIRType *IassignNode::GetLHSType() const {
+  MIRPtrType *ptrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx));
+  if (fieldID == 0) {
+    return ptrType->GetPointedType();
+  }
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrType->GetPointedTyIdxWithFieldID(fieldID));
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_parser.cpp b/src/mapleall/maple_ir/src/mir_parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a422fccbb02aa06772de86e0feb200dadde1c13e
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_parser.cpp
@@ -0,0 +1,3519 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_parser.h"
+#include "mir_function.h"
+#include "opcode_info.h"
+
+namespace maple {
+std::map<TokenKind, MIRParser::FuncPtrParseExpr> MIRParser::funcPtrMapForParseExpr =
+    MIRParser::InitFuncPtrMapForParseExpr();
+std::map<TokenKind, MIRParser::FuncPtrParseStmt> MIRParser::funcPtrMapForParseStmt =
+    MIRParser::InitFuncPtrMapForParseStmt();
+std::map<TokenKind, MIRParser::FuncPtrParseStmtBlock> MIRParser::funcPtrMapForParseStmtBlock =
+    MIRParser::InitFuncPtrMapForParseStmtBlock();
+
+bool MIRParser::ParseStmtDassign(StmtNodePtr &stmt) {
+  if (lexer.GetTokenKind() != TK_dassign) {
+    Error("expect dassign but get ");
+    return false;
+  }
+  // parse %i
+  lexer.NextToken();
+  StIdx stidx;
+  if (!ParseDeclaredSt(stidx)) {
+    return false;
+  }
+  if (stidx.FullIdx() == 0) {
+    Error("expect a symbol parsing ParseStmtDassign");
+    return false;
+  }
+  if (stidx.IsGlobal()) {
+    MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx());
+    ASSERT(sym != nullptr, "null ptr check");
+    sym->SetHasPotentialAssignment();
+  }
+  auto *assignStmt = mod.CurFuncCodeMemPool()->New<DassignNode>();
+  assignStmt->SetStIdx(stidx);
+  TokenKind nextToken = lexer.NextToken();
+  // parse field id
+  if (nextToken == TK_intconst) {  // may be a field id
+    assignStmt->SetFieldID(lexer.GetTheIntVal());
+    (void)lexer.NextToken();
+  }
+  // parse expression like (constval i32 0)
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  assignStmt->SetRHS(expr);
+  stmt = assignStmt;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtDassignoff(StmtNodePtr &stmt) {
+  if (lexer.GetTokenKind() != TK_dassignoff) {
+    Error("expect dassignoff but get ");
+    return false;
+  }
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  PrimType primType = GetPrimitiveType(lexer.GetTokenKind());
+  // parse %i
+  lexer.NextToken();
+  StIdx stidx;
+  if (!ParseDeclaredSt(stidx)) {
+    return false;
+  }
+  if (stidx.FullIdx() == 0) {
+    Error("expect a symbol parsing ParseStmtDassign");
+    return false;
+  }
+  if (stidx.IsGlobal()) {
+    MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx());
+    ASSERT(sym != nullptr, "null ptr check");
+    sym->SetHasPotentialAssignment();
+  }
+  DassignoffNode *assignStmt = mod.CurFuncCodeMemPool()->New<DassignoffNode>();
+  assignStmt->SetPrimType(primType);
+  assignStmt->stIdx = stidx;
+  TokenKind nextToken = lexer.NextToken();
+  // parse offset
+  if (nextToken == TK_intconst) {
+    assignStmt->offset = static_cast<int32>(lexer.GetTheIntVal());
+    (void)lexer.NextToken();
+  } else {
+    Error("expect integer offset but get ");
+    return false;
+  }
+  // parse expression like (constval i32 0)
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  assignStmt->SetRHS(expr);
+  stmt = assignStmt;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtRegassign(StmtNodePtr &stmt) {
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect type parsing binary operator but get ");
+    return false;
+  }
+  auto *regAssign = mod.CurFuncCodeMemPool()->New<RegassignNode>();
+  regAssign->SetPrimType(GetPrimitiveType(lexer.GetTokenKind()));
+  lexer.NextToken();
+  if (lexer.GetTokenKind() == TK_specialreg) {
+    PregIdx tempPregIdx = regAssign->GetRegIdx();
+    bool isSuccess = ParseSpecialReg(tempPregIdx);
+    regAssign->SetRegIdx(tempPregIdx);
+    if (!isSuccess) {
+      return false;
+    }
+  } else if (lexer.GetTokenKind() == TK_preg) {
+    PregIdx tempPregIdx = regAssign->GetRegIdx();
+    bool isSuccess = ParsePseudoReg(regAssign->GetPrimType(), tempPregIdx);
+    regAssign->SetRegIdx(tempPregIdx);
+    if (!isSuccess) {
+      return false;
+    }
+  } else {
+    Error("expect special or pseudo register but get ");
+    return false;
+  }
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  regAssign->SetOpnd(expr, 0);
+  if (regAssign->GetRegIdx() > 0) {  // check type consistenency for the preg
+    MIRPreg *preg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(regAssign->GetRegIdx());
+    if (preg->GetPrimType() == kPtyInvalid) {
+      preg->SetPrimType(expr->GetPrimType());
+    } else if (preg->GetPrimType() == PTY_dynany) {
+      if (!IsPrimitiveDynType(expr->GetPrimType())) {
+        Error("inconsistent preg primitive dynamic type at ");
+        return false;
+      }
+    }
+  }
+  stmt = regAssign;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtIassign(StmtNodePtr &stmt) {
+  // iAssign <* [10] int> ()
+  if (lexer.GetTokenKind() != TK_iassign) {
+    Error("expect iassign but get ");
+    return false;
+  }
+  // expect <> derived type
+  lexer.NextToken();
+  TyIdx tyIdx(0);
+  if (!ParseDerivedType(tyIdx)) {
+    Error("ParseStmtIassign failed when parsing derived type");
+    return false;
+  }
+  auto *iAssign = mod.CurFuncCodeMemPool()->New<IassignNode>();
+  iAssign->SetTyIdx(tyIdx);
+  if (lexer.GetTokenKind() == TK_intconst) {
+    iAssign->SetFieldID(lexer.theIntVal);
+    lexer.NextToken();
+  }
+  BaseNode *addr = nullptr;
+  BaseNode *rhs = nullptr;
+  // parse 2 operands then, #1 is address, the other would be value
+  if (!ParseExprTwoOperand(addr, rhs)) {
+    return false;
+  }
+  iAssign->SetOpnd(addr, 0);
+  iAssign->SetRHS(rhs);
+  lexer.NextToken();
+  stmt = iAssign;
+  return true;
+}
+
+bool MIRParser::ParseStmtIassignoff(StmtNodePtr &stmt) {
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect type parsing binary operator but get ");
+    return false;
+  }
+  // iassign <prim-type> <offset> ( <addr-expr>, <rhs-expr> )
+  auto *iAssignOff = mod.CurFuncCodeMemPool()->New<IassignoffNode>();
+  iAssignOff->SetPrimType(GetPrimitiveType(lexer.GetTokenKind()));
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect offset but get ");
+    return false;
+  }
+  iAssignOff->SetOffset(lexer.GetTheIntVal());
+  lexer.NextToken();
+  BaseNode *addr = nullptr;
+  BaseNode *rhs = nullptr;
+  if (!ParseExprTwoOperand(addr, rhs)) {
+    return false;
+  }
+  iAssignOff->SetBOpnd(addr, 0);
+  iAssignOff->SetBOpnd(rhs, 1);
+  lexer.NextToken();
+  stmt = iAssignOff;
+  return true;
+}
+
+bool MIRParser::ParseStmtIassignFPoff(StmtNodePtr &stmt) {
+  Opcode op = lexer.GetTokenKind() == TK_iassignfpoff ? OP_iassignfpoff : OP_iassignspoff;
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect type parsing binary operator but get ");
+    return false;
+  }
+  // iassignfpoff <prim-type> <offset> (<rhs-expr> )
+  auto *iAssignOff = mod.CurFuncCodeMemPool()->New<IassignFPoffNode>(op);
+  iAssignOff->SetPrimType(GetPrimitiveType(lexer.GetTokenKind()));
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect offset but get ");
+    return false;
+  }
+  iAssignOff->SetOffset(lexer.GetTheIntVal());
+  lexer.NextToken();
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  iAssignOff->SetOpnd(expr, 0);
+  lexer.NextToken();
+  stmt = iAssignOff;
+  return true;
+}
+
+bool MIRParser::ParseStmtBlkassignoff(StmtNodePtr &stmt) {
+  // blkassignoff <dest-offset> <size> (<dest-addr-expr>, <src-addr-expr>)
+  BlkassignoffNode *bassignoff = mod.CurFuncCodeMemPool()->New<BlkassignoffNode>();
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect offset but get ");
+    return false;
+  }
+  bassignoff->offset = static_cast<int32>(lexer.GetTheIntVal());
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect align but get ");
+    return false;
+  }
+  bassignoff->SetAlign(static_cast<uint32>(lexer.GetTheIntVal()));
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect size but get ");
+    return false;
+  }
+  bassignoff->blockSize = static_cast<int32>(lexer.GetTheIntVal());
+  lexer.NextToken();
+  BaseNode *destAddr = nullptr;
+  BaseNode *srcAddr = nullptr;
+  // parse 2 operands, the dest address followed by src address
+  if (!ParseExprTwoOperand(destAddr, srcAddr)) {
+    return false;
+  }
+  bassignoff->SetOpnd(destAddr, 0);
+  bassignoff->SetOpnd(srcAddr, 1);
+  lexer.NextToken();
+  stmt = bassignoff;
+  return true;
+}
+
+bool MIRParser::ParseStmtDoloop(StmtNodePtr &stmt) {
+  // syntax: doloop <do-var> (<start-expr>, <cont-expr>, <incr-amt>) {
+  //              <body-stmts> }
+  auto *doLoopNode = mod.CurFuncCodeMemPool()->New<DoloopNode>();
+  stmt = doLoopNode;
+  lexer.NextToken();
+  if (lexer.GetTokenKind() == TK_preg) {
+    uint32 pregNo = static_cast<uint32>(lexer.GetTheIntVal());
+    MIRFunction *mirFunc = mod.CurFunction();
+    PregIdx pregIdx = mirFunc->GetPregTab()->EnterPregNo(pregNo, kPtyInvalid);
+    doLoopNode->SetIsPreg(true);
+    doLoopNode->SetDoVarStFullIdx(pregIdx);
+    // let other appearances handle the preg primitive type
+  } else {
+    StIdx stIdx;
+    if (!ParseDeclaredSt(stIdx)) {
+      return false;
+    }
+    if (stIdx.FullIdx() == 0) {
+      Error("expect a symbol parsing ParseStmtDoloop");
+      return false;
+    }
+    if (stIdx.IsGlobal()) {
+      Error("expect local variable for doloop var but get ");
+      return false;
+    }
+    doLoopNode->SetDoVarStIdx(stIdx);
+  }
+  // parse (
+  if (lexer.NextToken() != TK_lparen) {
+    Error("expect ( but get ");
+    return false;
+  }
+  // parse start expression
+  lexer.NextToken();
+  BaseNode *start = nullptr;
+  if (!ParseExpression(start)) {
+    Error("ParseStmtDoloop when parsing start expression");
+    return false;
+  }
+  if (doLoopNode->IsPreg()) {
+    auto regIdx = static_cast<PregIdx>(doLoopNode->GetDoVarStIdx().FullIdx());
+    MIRPreg *mpReg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(regIdx);
+    if (mpReg->GetPrimType() == kPtyInvalid) {
+      CHECK_FATAL(start != nullptr, "null ptr check");
+      mpReg->SetPrimType(start->GetPrimType());
+    }
+  }
+  if (lexer.GetTokenKind() != TK_coma) {
+    Error("expect , after start expression but get ");
+    return false;
+  }
+  doLoopNode->SetStartExpr(start);
+  // parse end expression
+  lexer.NextToken();
+  BaseNode *end = nullptr;
+  if (!ParseExpression(end)) {  // here should be a compare expression
+    Error("ParseStmtDoloop when parsing end expression");
+    return false;
+  }
+  if (lexer.GetTokenKind() != TK_coma) {
+    Error("expect , after condition expression but get ");
+    return false;
+  }
+  doLoopNode->SetContExpr(end);
+  // parse renew induction expression
+  lexer.NextToken();
+  BaseNode *induction = nullptr;
+  if (!ParseExpression(induction)) {
+    Error("ParseStmtDoloop when parsing induction");
+    return false;
+  }
+  // parse )
+  if (lexer.GetTokenKind() != TK_rparen) {
+    Error("expect ) parsing doloop but get ");
+    return false;
+  }
+  doLoopNode->SetIncrExpr(induction);
+  // parse body of the loop
+  lexer.NextToken();
+  BlockNode *bodyStmt = nullptr;
+  if (!ParseStmtBlock(bodyStmt)) {
+    Error("ParseStmtDoloop when parsing body of the loop");
+    return false;
+  }
+  doLoopNode->SetDoBody(bodyStmt);
+  return true;
+}
+
+bool MIRParser::ParseStmtForeachelem(StmtNodePtr &stmt) {
+  // syntax: foreachelem <elemvar> <arrayvar> {
+  //              <body-stmts> }
+  auto *forNode = mod.CurFuncCodeMemPool()->New<ForeachelemNode>();
+  stmt = forNode;
+  lexer.NextToken();  // skip foreachelem token
+  StIdx stidx;
+  if (!ParseDeclaredSt(stidx)) {
+    return false;
+  }
+  if (stidx.FullIdx() == 0) {
+    Error("error parsing element variable of foreachelem in ");
+    return false;
+  }
+  if (stidx.IsGlobal()) {
+    Error("illegal global scope for element variable for foreachelem in ");
+    return false;
+  }
+  forNode->SetElemStIdx(stidx);
+  lexer.NextToken();
+  if (!ParseDeclaredSt(stidx)) {
+    return false;
+  }
+  if (stidx.FullIdx() == 0) {
+    Error("error parsing array/collection variable of foreachelem in ");
+    return false;
+  }
+  forNode->SetArrayStIdx(stidx);
+  lexer.NextToken();
+  // parse body of the loop
+  BlockNode *bodyStmt = nullptr;
+  if (!ParseStmtBlock(bodyStmt)) {
+    Error("error when parsing body of foreachelem loop in ");
+    return false;
+  }
+  forNode->SetLoopBody(bodyStmt);
+  return true;
+}
+
+bool MIRParser::ParseStmtIf(StmtNodePtr &stmt) {
+  if (lexer.GetTokenKind() != TK_if) {
+    Error("expect if but get ");
+    return false;
+  }
+  auto *ifStmt = mod.CurFuncCodeMemPool()->New<IfStmtNode>();
+  lexer.NextToken();
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  ifStmt->SetOpnd(expr, 0);
+  if (lexer.NextToken() != TK_lbrace) {
+    Error("expect { begin if body but get ");
+    return false;
+  }
+  BlockNode *thenBlock = nullptr;
+  if (!ParseStmtBlock(thenBlock)) {
+    Error("ParseStmtIf failed when parsing then block");
+    return false;
+  }
+  ifStmt->SetThenPart(thenBlock);
+
+  BlockNode *elseBlock = nullptr;
+  if (lexer.GetTokenKind() == TK_else) {
+    // has else part
+    if (lexer.NextToken() != TK_lbrace) {
+      Error("expect { begin if body but get ");
+      return false;
+    }
+    if (!ParseStmtBlock(elseBlock)) {
+      Error("ParseStmtIf failed when parsing else block");
+      return false;
+    }
+    ifStmt->SetElsePart(elseBlock);
+  }
+  stmt = ifStmt;
+  return true;
+}
+
+bool MIRParser::ParseStmtWhile(StmtNodePtr &stmt) {
+  if (lexer.GetTokenKind() != TK_while) {
+    Error("expect while but get ");
+    return false;
+  }
+  auto *whileStmt = mod.CurFuncCodeMemPool()->New<WhileStmtNode>(OP_while);
+  lexer.NextToken();
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  whileStmt->SetOpnd(expr, 0);
+  if (lexer.NextToken() != TK_lbrace) {
+    Error("expect { begin if body but get ");
+    return false;
+  }
+  BlockNode *whileBody = nullptr;
+  if (!ParseStmtBlock(whileBody)) {
+    Error("ParseStmtWhile failed when parse while body");
+    return false;
+  }
+  whileStmt->SetBody(whileBody);
+  stmt = whileStmt;
+  return true;
+}
+
+bool MIRParser::ParseStmtDowhile(StmtNodePtr &stmt) {
+  if (lexer.GetTokenKind() != TK_dowhile) {
+    Error("expect while but get ");
+    return false;
+  }
+  auto *whileStmt = mod.CurFuncCodeMemPool()->New<WhileStmtNode>(OP_dowhile);
+  if (lexer.NextToken() != TK_lbrace) {
+    Error("expect { begin if body but get ");
+    return false;
+  }
+  BlockNode *doWhileBody = nullptr;
+  if (!ParseStmtBlock(doWhileBody)) {
+    Error("ParseStmtDowhile failed when trying to parsing do while body");
+    return false;
+  }
+  whileStmt->SetBody(doWhileBody);
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  whileStmt->SetOpnd(expr, 0);
+  lexer.NextToken();
+  stmt = whileStmt;
+  return true;
+}
+
+bool MIRParser::ParseStmtLabel(StmtNodePtr &stmt) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  LabelIdx labIdx = mod.CurFunction()->GetLabelTab()->GetLabelIdxFromStrIdx(strIdx);
+  if (labIdx == 0) {
+    labIdx = mod.CurFunction()->GetLabelTab()->CreateLabel();
+    mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labIdx, strIdx);
+    mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labIdx);
+  } else {
+    if (definedLabels.size() > labIdx && definedLabels[labIdx]) {
+      Error("label multiply declared ");
+      return false;
+    }
+  }
+  if (definedLabels.size() <= labIdx) {
+    definedLabels.resize(labIdx + 1);
+  }
+  definedLabels[labIdx] = true;
+  auto *labNode = mod.CurFuncCodeMemPool()->New<LabelNode>();
+  labNode->SetLabelIdx(labIdx);
+  stmt = labNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtGoto(StmtNodePtr &stmt) {
+  if (lexer.GetTokenKind() != TK_goto) {
+    Error("expect goto but get ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_label) {
+    Error("expect label in goto but get ");
+    return false;
+  }
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  LabelIdx labIdx = mod.CurFunction()->GetLabelTab()->GetLabelIdxFromStrIdx(strIdx);
+  if (labIdx == 0) {
+    labIdx = mod.CurFunction()->GetLabelTab()->CreateLabel();
+    mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labIdx, strIdx);
+    mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labIdx);
+  }
+  auto *gotoNode = mod.CurFuncCodeMemPool()->New<GotoNode>(OP_goto);
+  gotoNode->SetOffset(labIdx);
+  stmt = gotoNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtBr(StmtNodePtr &stmt) {
+  TokenKind tk = lexer.GetTokenKind();
+  if (tk != TK_brtrue && tk != TK_brfalse) {
+    Error("expect brtrue/brfalse but get ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_label) {
+    Error("expect label in goto but get ");
+    return false;
+  }
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  LabelIdx labIdx = mod.CurFunction()->GetLabelTab()->GetLabelIdxFromStrIdx(strIdx);
+  if (labIdx == 0) {
+    labIdx = mod.CurFunction()->GetLabelTab()->CreateLabel();
+    mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labIdx, strIdx);
+    mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labIdx);
+  }
+  auto *condGoto = mod.CurFuncCodeMemPool()->New<CondGotoNode>(tk == TK_brtrue ? OP_brtrue : OP_brfalse);
+  condGoto->SetOffset(labIdx);
+  lexer.NextToken();
+  // parse (<expr>)
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  condGoto->SetOpnd(expr, 0);
+  stmt = condGoto;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseSwitchCase(int64 &constVal, LabelIdx &lblIdx) {
+  // syntax <intconst0>: goto <label0>
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect intconst in switch but get ");
+    return false;
+  }
+  constVal = static_cast<int64>(lexer.GetTheIntVal());
+  if (lexer.NextToken() != TK_colon) {
+    Error("expect : in switch but get ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_goto) {
+    Error("expect goto in switch case but get ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_label) {
+    Error("expect label in switch but get ");
+    return false;
+  }
+  lblIdx = mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtSwitch(StmtNodePtr &stmt) {
+  auto *switchNode = mod.CurFuncCodeMemPool()->New<SwitchNode>(mod);
+  stmt = switchNode;
+  lexer.NextToken();
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  switchNode->SetSwitchOpnd(expr);
+  if (!IsPrimitiveInteger(expr->GetPrimType())) {
+    Error("expect expression return integer but get ");
+    return false;
+  }
+  if (lexer.NextToken() == TK_label) {
+    switchNode->SetDefaultLabel(mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName()));
+  } else if (lexer.GetTokenKind() == TK_intconst && lexer.GetTheIntVal() == 0) {
+    switchNode->SetDefaultLabel(0);
+  } else {
+    Error("expect label in switch but get ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_lbrace) {
+    Error("expect { in switch but get ");
+    return false;
+  }
+  // <intconst0>: goto <label0>
+  // <intconst1>: goto <label1>
+  // ...
+  // <intconstn>: goto <labeln>
+  TokenKind tk = lexer.NextToken();
+  std::set<int64> casesSet;
+  while (tk != TK_rbrace) {
+    int64 constVal = 0;
+    LabelIdx lbl = 0;
+    if (!ParseSwitchCase(constVal, lbl)) {
+      Error("parse switch case failed ");
+      return false;
+    }
+    if (casesSet.find(constVal) != casesSet.end()) {
+      Error("duplicated switch case ");
+      return false;
+    }
+    switchNode->InsertCasePair(CasePair(constVal, lbl));
+    (void)casesSet.insert(constVal);
+    tk = lexer.GetTokenKind();
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtRangegoto(StmtNodePtr &stmt) {
+  auto *rangeGotoNode = mod.CurFuncCodeMemPool()->New<RangeGotoNode>(mod);
+  stmt = rangeGotoNode;
+  lexer.NextToken();
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  if (!IsPrimitiveInteger(expr->GetPrimType())) {
+    Error("expect expression return integer but get ");
+    return false;
+  }
+  rangeGotoNode->SetOpnd(expr, 0);
+  if (lexer.NextToken() == TK_intconst) {
+    rangeGotoNode->SetTagOffset(static_cast<int32>(lexer.GetTheIntVal()));
+  } else {
+    Error("expect tag offset in rangegoto but get ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_lbrace) {
+    Error("expect { in switch but get ");
+    return false;
+  }
+  // <intconst0>: goto <label0>
+  // <intconst1>: goto <label1>
+  // ...
+  // <intconstn>: goto <labeln>
+  TokenKind tk = lexer.NextToken();
+  std::set<uint16> casesSet;
+  int32 minIdx = UINT16_MAX;
+  int32 maxIdx = 0;
+  while (tk != TK_rbrace) {
+    int64 constVal = 0;
+    LabelIdx lbl = 0;
+    if (!ParseSwitchCase(constVal, lbl)) {
+      Error("parse switch case failed ");
+      return false;
+    }
+    if (constVal > UINT16_MAX || constVal < 0) {
+      Error("rangegoto case tag not within unsigned 16 bits range ");
+      return false;
+    }
+    if (casesSet.find(constVal) != casesSet.end()) {
+      Error("duplicated switch case ");
+      return false;
+    }
+    if (constVal < minIdx) {
+      minIdx = static_cast<int32>(constVal);
+    }
+    if (constVal > maxIdx) {
+      maxIdx = static_cast<int32>(constVal);
+    }
+    rangeGotoNode->AddRangeGoto(static_cast<uint32>(constVal), static_cast<uint32>(lbl));
+    (void)casesSet.insert(constVal);
+    tk = lexer.GetTokenKind();
+  }
+  ASSERT(rangeGotoNode->GetNumOpnds() == 1, "Rangegoto is a UnaryOpnd; numOpnds must be 1");
+  // check there is no gap
+  if (static_cast<size_t>(static_cast<uint32>(maxIdx - minIdx) + 1) != casesSet.size()) {
+    Error("gap not allowed in rangegoto case tags ");
+    return false;
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtMultiway(StmtNodePtr &stmt) {
+  auto *multiwayNode = mod.CurFuncCodeMemPool()->New<MultiwayNode>(mod);
+  stmt = multiwayNode;
+  lexer.NextToken();
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  multiwayNode->SetMultiWayOpnd(expr);
+  if (lexer.NextToken() == TK_label) {
+    multiwayNode->SetDefaultlabel(mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName()));
+  } else {
+    Error("expect label in multiway but get ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_lbrace) {
+    Error("expect { in switch but get ");
+    return false;
+  }
+  // (<expr0>): goto <label0>
+  // (<expr1>): goto <label1>
+  // ...
+  // (<exprn>): goto <labeln>
+  TokenKind tk = lexer.NextToken();
+  while (tk != TK_rbrace) {
+    BaseNode *x = nullptr;
+    if (!ParseExprOneOperand(x)) {
+      return false;
+    }
+    if (lexer.NextToken() != TK_colon) {
+      Error("expect : parsing multiway case tag specification but get ");
+      return false;
+    }
+    if (lexer.NextToken() != TK_goto) {
+      Error("expect goto in multiway case expression but get ");
+      return false;
+    }
+    if (lexer.NextToken() != TK_label) {
+      Error("expect goto label after multiway case expression but get ");
+      return false;
+    }
+    LabelIdx lblIdx = mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName());
+    lexer.NextToken();
+    multiwayNode->AppendElemToMultiWayTable(MCasePair(static_cast<BaseNode*>(x), lblIdx));
+    tk = lexer.GetTokenKind();
+  }
+  const MapleVector<MCasePair> &multiWayTable = multiwayNode->GetMultiWayTable();
+  multiwayNode->SetNumOpnds(multiWayTable.size());
+  lexer.NextToken();
+  return true;
+}
+
+// used only when parsing mmpl
+PUIdx MIRParser::EnterUndeclaredFunction(bool isMcount) {
+  std::string funcName;
+  if (isMcount) {
+    funcName = "_mcount";
+  } else {
+    funcName = lexer.GetName();
+  }
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  funcSt->SetNameStrIdx(strIdx);
+  (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcSt);
+  funcSt->SetStorageClass(kScText);
+  funcSt->SetSKind(kStFunc);
+  auto *fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSt->GetStIdx());
+  fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
+  GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
+  funcSt->SetFunction(fn);
+  auto *funcType = mod.GetMemPool()->New<MIRFuncType>();
+  fn->SetMIRFuncType(funcType);
+  if (isMcount) {
+    MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_void));
+    fn->SetReturnTyIdx(retType->GetTypeIndex());
+  }
+  return fn->GetPuidx();
+}
+
+bool MIRParser::ParseStmtCallMcount(StmtNodePtr &stmt) {
+  // syntax: call <PU-name> (<opnd0>, ..., <opndn>)
+  Opcode o = OP_call;
+  PUIdx pIdx = EnterUndeclaredFunction(true);
+  auto *callStmt = mod.CurFuncCodeMemPool()->New<CallNode>(mod, o);
+  callStmt->SetPUIdx(pIdx);
+  MapleVector<BaseNode*> opndsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+  callStmt->SetNOpnd(opndsvec);
+  callStmt->SetNumOpnds(opndsvec.size());
+  stmt = callStmt;
+  return true;
+}
+
+bool MIRParser::ParseStmtCall(StmtNodePtr &stmt) {
+  // syntax: call <PU-name> (<opnd0>, ..., <opndn>)
+  TokenKind tk = lexer.GetTokenKind();
+  Opcode o = GetOpFromToken(tk);
+  ASSERT(kOpcodeInfo.IsCall(o), "ParseStmtCall: not a call opcode");
+  bool hasAssigned = kOpcodeInfo.IsCallAssigned(o);
+  bool hasInstant = false;
+  bool withType = false;
+  switch (tk) {
+    case TK_polymorphiccall:
+    case TK_polymorphiccallassigned:
+      withType = true;
+      break;
+    case TK_callinstant:
+    case TK_virtualcallinstant:
+    case TK_superclasscallinstant:
+    case TK_interfacecallinstant:
+    case TK_callinstantassigned:
+    case TK_virtualcallinstantassigned:
+    case TK_superclasscallinstantassigned:
+    case TK_interfacecallinstantassigned:
+      hasInstant = true;
+      break;
+    default:
+      break;
+  }
+  TyIdx polymophicTyidx(0);
+  if (o == OP_polymorphiccallassigned || o == OP_polymorphiccall) {
+    TokenKind nextTk = lexer.NextToken();
+    if (nextTk == TK_langle) {
+      nextTk = lexer.NextToken();
+      if (nextTk == TK_func) {
+        lexer.NextToken();
+        if (!ParseFuncType(polymophicTyidx)) {
+          Error("error parsing functype in ParseStmtCall for polymorphiccallassigned at ");
+          return false;
+        }
+      } else {
+        Error("expect func in functype but get ");
+        return false;
+      }
+    } else {
+      Error("expect < in functype but get ");
+      return false;
+    }
+  }
+  TokenKind funcTk = lexer.NextToken();
+  if (funcTk != TK_fname) {
+    Error("expect func name in call but get ");
+    return false;
+  }
+  PUIdx pIdx;
+  if (!ParseDeclaredFunc(pIdx)) {
+    if (mod.GetFlavor() < kMmpl) {
+      Error("expect .mmpl");
+      return false;
+    }
+    pIdx = EnterUndeclaredFunction();
+  }
+  lexer.NextToken();
+  CallNode *callStmt = nullptr;
+  CallinstantNode *callInstantStmt = nullptr;
+  if (withType) {
+    callStmt = mod.CurFuncCodeMemPool()->New<CallNode>(mod, o);
+    callStmt->SetTyIdx(polymophicTyidx);
+  } else if (hasInstant) {
+    TokenKind langleTk = lexer.GetTokenKind();
+    if (langleTk != TK_langle) {
+      Error("missing < in generic method instantiation at ");
+      return false;
+    }
+    TokenKind lbraceTk = lexer.NextToken();
+    if (lbraceTk != TK_lbrace) {
+      Error("missing { in generic method instantiation at ");
+      return false;
+    }
+    MIRInstantVectorType instVecTy;
+    if (!ParseGenericInstantVector(instVecTy)) {
+      Error("error parsing generic method instantiation at ");
+      return false;
+    }
+    TokenKind rangleTk = lexer.GetTokenKind();
+    if (rangleTk != TK_rangle) {
+      Error("missing > in generic method instantiation at ");
+      return false;
+    }
+    TyIdx tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&instVecTy);
+    callInstantStmt = mod.CurFuncCodeMemPool()->New<CallinstantNode>(mod, o, tyIdx);
+    callStmt = callInstantStmt;
+    lexer.NextToken();  // skip the >
+  } else {
+    callStmt = mod.CurFuncCodeMemPool()->New<CallNode>(mod, o);
+  }
+  callStmt->SetPUIdx(pIdx);
+
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFuncTable()[pIdx];
+  CHECK_NULL_FATAL(callee);
+  callee->GetFuncSymbol()->SetAppearsInCode(true);
+  if (callee->GetName() == "setjmp") {
+    mod.CurFunction()->SetHasSetjmp();
+  }
+
+  MapleVector<BaseNode*> opndsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+  if (!ParseExprNaryOperand(opndsVec)) {
+    return false;
+  }
+  callStmt->SetNOpnd(opndsVec);
+  callStmt->SetNumOpnds(opndsVec.size());
+  if (hasAssigned) {
+    CallReturnVector retsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+    if (!ParseCallReturns(retsVec)) {
+      return false;
+    }
+    if (!hasInstant) {
+      ASSERT(callStmt != nullptr, "callstmt is null in MIRParser::ParseStmtCall");
+      callStmt->SetReturnVec(retsVec);
+    } else {
+      ASSERT(callInstantStmt != nullptr, "callinstantstmt is null in MIRParser::ParseStmtCall");
+      callInstantStmt->SetReturnVec(retsVec);
+    }
+  }
+  lexer.NextToken();
+  stmt = callStmt;
+  return true;
+}
+
+bool MIRParser::ParseStmtIcall(StmtNodePtr &stmt, Opcode op) {
+  // syntax: icall (<PU-ptr>, <opnd0>, ..., <opndn>)
+  //         icallassigned <PU-ptr> (<opnd0>, ..., <opndn>) {
+  //              dassign <var-name0> <field-id0>
+  //              dassign <var-name1> <field-id1>
+  //               . . .
+  //              dassign <var-namen> <field-idn> }
+  //         icallproto <funcType> (<PU-ptr>, <opnd0>, ..., <opndn>)
+  //         icallprotoassigned <funcType> (<PU-ptr>, <opnd0>, ..., <opndn>) {
+  //              dassign <var-name0> <field-id0>
+  //              dassign <var-name1> <field-id1>
+  //               . . .
+  //              dassign <var-namen> <field-idn> }
+  IcallNode *iCallStmt = mod.CurFuncCodeMemPool()->New<IcallNode>(mod, op);
+  lexer.NextToken();
+  if (op == OP_icallproto || op == OP_icallprotoassigned) {
+    TyIdx tyIdx(0);
+    if (!ParseDerivedType(tyIdx)) {
+      Error("error parsing type in ParseStmtIcall for icallproto at ");
+      return false;
+    }
+    iCallStmt->SetRetTyIdx(tyIdx);
+  }
+  MapleVector<BaseNode*> opndsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+  if (!ParseExprNaryOperand(opndsVec)) {
+    return false;
+  }
+  iCallStmt->SetNOpnd(opndsVec);
+  iCallStmt->SetNumOpnds(opndsVec.size());
+  if (op == OP_icallassigned || op == OP_icallprotoassigned) {
+    CallReturnVector retsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+    if (!ParseCallReturns(retsVec)) {
+      return false;
+    }
+    iCallStmt->SetReturnVec(retsVec);
+  }
+  lexer.NextToken();
+  stmt = iCallStmt;
+  return true;
+}
+
+bool MIRParser::ParseStmtIcall(StmtNodePtr &stmt) {
+  return ParseStmtIcall(stmt, OP_icall);
+}
+
+bool MIRParser::ParseStmtIcallassigned(StmtNodePtr &stmt) {
+  return ParseStmtIcall(stmt, OP_icallassigned);
+}
+
+bool MIRParser::ParseStmtIcallproto(StmtNodePtr &stmt) {
+  return ParseStmtIcall(stmt, OP_icallproto);
+}
+
+bool MIRParser::ParseStmtIcallprotoassigned(StmtNodePtr &stmt) {
+  return ParseStmtIcall(stmt, OP_icallprotoassigned);
+}
+
+bool MIRParser::ParseStmtIntrinsiccall(StmtNodePtr &stmt, bool isAssigned) {
+  Opcode o = !isAssigned ? (lexer.GetTokenKind() == TK_intrinsiccall ? OP_intrinsiccall : OP_xintrinsiccall)
+                         : (lexer.GetTokenKind() == TK_intrinsiccallassigned ? OP_intrinsiccallassigned
+                                                                             : OP_xintrinsiccallassigned);
+  auto *intrnCallNode = mod.CurFuncCodeMemPool()->New<IntrinsiccallNode>(mod, o);
+  lexer.NextToken();
+  if (o == (!isAssigned) ? OP_intrinsiccall : OP_intrinsiccallassigned) {
+    intrnCallNode->SetIntrinsic(GetIntrinsicID(lexer.GetTokenKind()));
+  } else {
+    intrnCallNode->SetIntrinsic(static_cast<MIRIntrinsicID>(lexer.GetTheIntVal()));
+  }
+  lexer.NextToken();
+  MapleVector<BaseNode*> opndsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+  if (!ParseExprNaryOperand(opndsVec)) {
+    return false;
+  }
+  intrnCallNode->SetNOpnd(opndsVec);
+  intrnCallNode->SetNumOpnds(opndsVec.size());
+  if (isAssigned) {
+    CallReturnVector retsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+    if (!ParseCallReturns(retsVec)) {
+      return false;
+    }
+    // store return type of IntrinsiccallNode
+    if (retsVec.size() == 1 && retsVec[0].first.Idx() != 0) {
+      MIRSymbol *retSymbol = curFunc->GetSymTab()->GetSymbolFromStIdx(retsVec[0].first.Idx());
+      MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retSymbol->GetTyIdx());
+      CHECK_FATAL(retType != nullptr, "rettype is null in MIRParser::ParseStmtIntrinsiccallAssigned");
+      intrnCallNode->SetPrimType(retType->GetPrimType());
+    }
+    intrnCallNode->SetReturnVec(retsVec);
+  }
+  stmt = intrnCallNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtIntrinsiccall(StmtNodePtr &stmt) {
+  return ParseStmtIntrinsiccall(stmt, false);
+}
+
+bool MIRParser::ParseStmtIntrinsiccallassigned(StmtNodePtr &stmt) {
+  return ParseStmtIntrinsiccall(stmt, true);
+}
+
+bool MIRParser::ParseStmtIntrinsiccallwithtype(StmtNodePtr &stmt, bool isAssigned) {
+  Opcode o = (!isAssigned) ? OP_intrinsiccallwithtype : OP_intrinsiccallwithtypeassigned;
+  IntrinsiccallNode *intrnCallNode = mod.CurFuncCodeMemPool()->New<IntrinsiccallNode>(mod, o);
+  TokenKind tk = lexer.NextToken();
+  TyIdx tyIdx(0);
+  if (IsPrimitiveType(tk)) {
+    if (!ParsePrimType(tyIdx)) {
+      Error("expect primitive type in ParseStmtIntrinsiccallwithtype but get ");
+      return false;
+    }
+  } else if (!ParseDerivedType(tyIdx)) {
+    Error("error parsing type in ParseStmtIntrinsiccallwithtype at ");
+    return false;
+  }
+  intrnCallNode->SetTyIdx(tyIdx);
+  intrnCallNode->SetIntrinsic(GetIntrinsicID(lexer.GetTokenKind()));
+  lexer.NextToken();
+  MapleVector<BaseNode*> opndsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+  if (!ParseExprNaryOperand(opndsVec)) {
+    return false;
+  }
+  intrnCallNode->SetNOpnd(opndsVec);
+  intrnCallNode->SetNumOpnds(opndsVec.size());
+  if (isAssigned) {
+    CallReturnVector retsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+    if (!ParseCallReturns(retsVec)) {
+      return false;
+    }
+    // store return type of IntrinsiccallNode
+    if (retsVec.size() == 1 && retsVec[0].first.Idx() != 0) {
+      MIRSymbol *retSymbol = curFunc->GetSymTab()->GetSymbolFromStIdx(retsVec[0].first.Idx());
+      MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retSymbol->GetTyIdx());
+      CHECK_FATAL(retType != nullptr, "rettype is null in MIRParser::ParseStmtIntrinsiccallwithtypeAssigned");
+      intrnCallNode->SetPrimType(retType->GetPrimType());
+    }
+    intrnCallNode->SetReturnVec(retsVec);
+  }
+  stmt = intrnCallNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtIntrinsiccallwithtype(StmtNodePtr &stmt) {
+  return ParseStmtIntrinsiccallwithtype(stmt, false);
+}
+
+bool MIRParser::ParseStmtIntrinsiccallwithtypeassigned(StmtNodePtr &stmt) {
+  return ParseStmtIntrinsiccallwithtype(stmt, true);
+}
+
+bool MIRParser::ParseCallReturnPair(CallReturnPair &retpair) {
+  bool isst = (lexer.GetTokenKind() == TK_dassign);
+  if (isst) {
+    // parse %i
+    lexer.NextToken();
+    StIdx stidx;
+    // How to use islocal??
+    if (!ParseDeclaredSt(stidx)) {
+      return false;
+    }
+    if (lexer.GetTokenKind() == TK_lname) {
+      MIRSymbolTable *lSymTab = mod.CurFunction()->GetSymTab();
+      MIRSymbol *lSym = lSymTab->GetSymbolFromStIdx(stidx.Idx(), 0);
+      ASSERT(lSym != nullptr, "lsym MIRSymbol is null");
+      if (lSym->GetName().find("L_STR") == 0) {
+        MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lSym->GetTyIdx());
+        auto *ptrTy = static_cast<MIRPtrType*>(ty->CopyMIRTypeNode());
+        ASSERT(ptrTy != nullptr, "null ptr check");
+        ptrTy->SetPrimType(GetExactPtrPrimType());
+        TyIdx newTyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(ptrTy);
+        delete ptrTy;
+        lSym->SetTyIdx(newTyidx);
+      }
+    }
+    if (stidx.FullIdx() == 0) {
+      Error("expect a symbol parsing call return assignment but get");
+      return false;
+    }
+    uint16 fieldId = 0;
+    TokenKind nextToken = lexer.NextToken();
+    // parse field id
+    if (nextToken == TK_intconst) {
+      fieldId = lexer.GetTheIntVal();
+      lexer.NextToken();
+    }
+    RegFieldPair regFieldPair;
+    regFieldPair.SetFieldID(fieldId);
+    retpair = CallReturnPair(stidx, regFieldPair);
+  } else {
+    // parse type
+    lexer.NextToken();
+    TyIdx tyidx(0);
+    // RegreadNode regreadexpr;
+    bool ret = ParsePrimType(tyidx);
+    if (ret != true) {
+      Error("call ParsePrimType failed in ParseCallReturns");
+      return false;
+    }
+    if (tyidx == 0u) {
+      Error("expect primitive type but get ");
+      return false;
+    }
+    PrimType ptype = GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx);
+    PregIdx pregIdx;
+    if (lexer.GetTokenKind() == TK_specialreg) {
+      if (!ParseSpecialReg(pregIdx)) {
+        Error("expect specialreg parsing callassign CallReturnVector");
+        return false;
+      }
+    } else if (lexer.GetTokenKind() == TK_preg) {
+      if (!ParsePseudoReg(ptype, pregIdx)) {
+        Error("expect pseudoreg parsing callassign CallReturnVector");
+        return false;
+      }
+    } else {
+      Error("expect special or pseudo register but get ");
+      return false;
+    }
+    ASSERT(pregIdx > 0, "register number is zero");
+    ASSERT(pregIdx <= 0xffff, "register number is over 16 bits");
+    RegFieldPair regFieldPair;
+    regFieldPair.SetPregIdx(pregIdx);
+    retpair = CallReturnPair(StIdx(), regFieldPair);
+  }
+  return true;
+}
+
+bool MIRParser::ParseCallReturns(CallReturnVector &retsvec) {
+  //             {
+  //              dassign <var-name0> <field-id0>
+  //              dassign <var-name1> <field-id1>
+  //               . . .
+  //              dassign <var-namen> <field-idn> }
+  //              OR
+  //             {
+  //               regassign <type> <reg1>
+  //               regassign <type> <reg2>
+  //               regassign <type> <reg3>
+  //             }
+  if (lexer.NextToken() != TK_lbrace) {
+    Error("expect { parsing call return values. ");
+    return false;
+  }
+  TokenKind tk = lexer.NextToken();
+  CallReturnPair retpair;
+  while (tk != TK_rbrace) {
+    if (lexer.GetTokenKind() != TK_dassign && lexer.GetTokenKind() != TK_regassign) {
+      Error("expect dassign/regassign but get ");
+      return false;
+    }
+    if (!ParseCallReturnPair(retpair)) {
+      Error("error parsing call returns. ");
+      return false;
+    }
+    retsvec.push_back(retpair);
+    tk = lexer.GetTokenKind();
+  }
+  return true;
+}
+
+bool MIRParser::ParseStmtAsm(StmtNodePtr &stmt) {
+  AsmNode *asmNode = mod.CurFuncCodeMemPool()->New<AsmNode>(&mod.GetCurFuncCodeMPAllocator());
+  mod.CurFunction()->SetHasAsm();
+  lexer.NextToken();
+  // parse qualifiers
+  while (lexer.GetTokenKind() == TK_volatile ||
+         lexer.GetTokenKind() == TK_inline ||
+         lexer.GetTokenKind() == TK_goto) {
+    AsmQualifierKind qual;
+    switch (lexer.GetTokenKind()) {
+      case TK_volatile: {
+        qual = kASMvolatile;
+        break;
+      }
+      case TK_inline: {
+        qual = kASMinline;
+        break;
+      }
+      case TK_goto:
+      default: {
+        qual = kASMgoto;
+        break;
+      }
+    }
+    asmNode->SetQualifier(qual);
+    lexer.NextToken();
+  }
+  // parse open brace
+  if (lexer.GetTokenKind() != TK_lbrace) {
+    Error("Open brace not found parsing asm statement.");
+    return false;
+  }
+  lexer.NextToken();
+  // parse asm string
+  if (lexer.GetTokenKind() != TK_string) {
+    Error("asm string not found parsing asm statement.");
+    return false;
+  }
+  asmNode->asmString = lexer.GetName();
+  lexer.NextToken();
+  // parse first colon
+  if (lexer.GetTokenKind() != TK_colon) {
+    Error("first colon not found parsing asm statement.");
+    return false;
+  }
+  lexer.NextToken();
+  // parse outputs
+  UStrIdx uStrIdx;
+  CallReturnPair retpair;
+  while (lexer.GetTokenKind() == TK_string) {
+    // parse an output constraint string
+    uStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    lexer.NextToken();
+    if (!ParseCallReturnPair(retpair)) {
+      Error("error parsing call returns. ");
+      return false;
+    }
+    asmNode->outputConstraints.push_back(uStrIdx);
+    asmNode->asmOutputs.push_back(retpair);
+    if (lexer.GetTokenKind() == TK_coma) {
+      lexer.NextToken();
+    }
+  }
+  // parse second colon
+  if (lexer.GetTokenKind() != TK_colon) {
+    Error("second colon not found parsing asm statement.");
+    return false;
+  }
+  lexer.NextToken();
+  // parse inputs
+  while (lexer.GetTokenKind() == TK_string) {
+    // parse an input constraint string
+    uStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    if (lexer.GetName()[0] == '+') {
+      asmNode->SetHasWriteInputs();
+    }
+    if (lexer.NextToken() != TK_lparen) {
+      Error("expect ( but get ");
+      return false;
+    }
+    lexer.NextToken();
+    BaseNode *expr = nullptr;
+    if (!ParseExpression(expr)) {
+      Error("ParseExpression failed");
+      return false;
+    }
+    if (lexer.GetTokenKind() != TK_rparen) {
+      Error("expect ) but get ");
+      return false;
+    }
+    asmNode->inputConstraints.push_back(uStrIdx);
+    asmNode->GetNopnd().push_back(expr);
+    if (lexer.NextToken() == TK_coma) {
+      lexer.NextToken();
+    }
+  }
+  asmNode->SetNumOpnds(static_cast<uint8>(asmNode->GetNopndSize()));
+  // parse third colon
+  if (lexer.GetTokenKind() != TK_colon) {
+    Error("third colon not found parsing asm statement.");
+    return false;
+  }
+  lexer.NextToken();
+  // parse clobber list
+  while (lexer.GetTokenKind() == TK_string) {
+    // parse an input constraint string
+    uStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    asmNode->clobberList.push_back(uStrIdx);
+    if (lexer.NextToken() == TK_coma) {
+      lexer.NextToken();
+    }
+  }
+  // parse fourth colon
+  if (lexer.GetTokenKind() != TK_colon) {
+    Error("fourth colon not found parsing asm statement.");
+    return false;
+  }
+  lexer.NextToken();
+  // parse labels
+  while (lexer.GetTokenKind() == TK_label) {
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    LabelIdx labIdx = mod.CurFunction()->GetLabelTab()->GetLabelIdxFromStrIdx(strIdx);
+    if (labIdx == 0) {
+      labIdx = mod.CurFunction()->GetLabelTab()->CreateLabel();
+      mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labIdx, strIdx);
+      mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labIdx);
+    }
+    asmNode->gotoLabels.push_back(labIdx);
+    if (lexer.NextToken() == TK_coma) {
+      lexer.NextToken();
+    }
+  }
+  // parse closing brace
+  if (lexer.GetTokenKind() != TK_rbrace) {
+    Error("Closing brace not found parsing asm statement.");
+    return false;
+  }
+  stmt = asmNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtSafeRegion(StmtNodePtr &stmt) {
+  switch (lexer.GetTokenKind()) {
+    case TK_safe:
+      safeRegionFlag.push(true);
+      break;
+    case TK_unsafe:
+      safeRegionFlag.push(false);
+      break;
+    case TK_endsafe:
+    case TK_endunsafe:
+      safeRegionFlag.pop();
+      break;
+    default:
+      Error("Only support safe/unsafe/endsafe/endunsafe.");
+      return false;
+  }
+  (void)stmt;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtJsTry(StmtNodePtr &stmt) {
+  auto *tryNode = mod.CurFuncCodeMemPool()->New<JsTryNode>();
+  lexer.NextToken();
+  // parse handler label
+  if (lexer.GetTokenKind() == TK_intconst && lexer.GetTheIntVal() == 0) {
+    tryNode->SetCatchOffset(0);
+  } else {
+    if (lexer.GetTokenKind() != TK_label) {
+      Error("expect handler label in try but get ");
+      return false;
+    }
+    GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    LabelIdx labidx = mod.CurFunction()->GetLabelTab()->GetLabelIdxFromStrIdx(stridx);
+    if (labidx == 0) {
+      labidx = mod.CurFunction()->GetLabelTab()->CreateLabel();
+      mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx);
+      mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx);
+    }
+    tryNode->SetCatchOffset(labidx);
+  }
+  lexer.NextToken();
+  // parse finally label
+  if (lexer.GetTokenKind() == TK_intconst && lexer.GetTheIntVal() == 0) {
+    tryNode->SetFinallyOffset(0);
+  } else {
+    if (lexer.GetTokenKind() != TK_label) {
+      Error("expect finally label in try but get ");
+      return false;
+    }
+    GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    LabelIdx labidx = mod.CurFunction()->GetLabelTab()->GetLabelIdxFromStrIdx(stridx);
+    if (labidx == 0) {
+      labidx = mod.CurFunction()->GetLabelTab()->CreateLabel();
+      mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx);
+      mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx);
+    }
+    tryNode->SetFinallyOffset(labidx);
+  }
+  stmt = tryNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtTry(StmtNodePtr &stmt) {
+  auto *tryNode = mod.CurFuncCodeMemPool()->New<TryNode>(mod);
+  lexer.NextToken();
+  ASSERT(lexer.GetTokenKind() == TK_lbrace, "expect left brace in try but get ");
+  lexer.NextToken();
+  // parse handler label
+  while (lexer.GetTokenKind() != TK_rbrace) {
+    if (lexer.GetTokenKind() != TK_label) {
+      Error("expect handler label in try but get ");
+      return false;
+    }
+    GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    LabelIdx labidx = mod.CurFunction()->GetLabelTab()->GetLabelIdxFromStrIdx(stridx);
+    if (labidx == 0) {
+      labidx = mod.CurFunction()->GetLabelTab()->CreateLabel();
+      mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx);
+      mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx);
+    }
+    tryNode->AddOffset(labidx);
+    lexer.NextToken();
+  }
+  stmt = tryNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtCatch(StmtNodePtr &stmt) {
+  auto *catchNode = mod.CurFuncCodeMemPool()->New<CatchNode>(mod);
+  lexer.NextToken();
+  ASSERT(lexer.GetTokenKind() == TK_lbrace, "expect left brace in catch but get ");
+  lexer.NextToken();
+  while (lexer.GetTokenKind() != TK_rbrace) {
+    TyIdx tyidx(0);
+    if (!ParseType(tyidx)) {
+      Error("expect type parsing java catch statement");
+      return false;
+    }
+    catchNode->PushBack(tyidx);
+  }
+  catchNode->SetNumOpnds(0);
+  stmt = catchNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseUnaryStmt(Opcode op, StmtNodePtr &stmt) {
+  lexer.NextToken();
+  auto *throwStmt = mod.CurFuncCodeMemPool()->New<UnaryStmtNode>(op);
+  stmt = throwStmt;
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  throwStmt->SetOpnd(expr, 0);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseUnaryStmtThrow(StmtNodePtr &stmt) {
+  return ParseUnaryStmt(OP_throw, stmt);
+}
+
+bool MIRParser::ParseUnaryStmtDecRef(StmtNodePtr &stmt) {
+  return ParseUnaryStmt(OP_decref, stmt);
+}
+
+bool MIRParser::ParseUnaryStmtIncRef(StmtNodePtr &stmt) {
+  return ParseUnaryStmt(OP_incref, stmt);
+}
+
+bool MIRParser::ParseUnaryStmtDecRefReset(StmtNodePtr &stmt) {
+  return ParseUnaryStmt(OP_decrefreset, stmt);
+}
+
+bool MIRParser::ParseUnaryStmtIGoto(StmtNodePtr &stmt) {
+  return ParseUnaryStmt(OP_igoto, stmt);
+}
+
+bool MIRParser::ParseUnaryStmtEval(StmtNodePtr &stmt) {
+  return ParseUnaryStmt(OP_eval, stmt);
+}
+
+bool MIRParser::ParseUnaryStmtFree(StmtNodePtr &stmt) {
+  return ParseUnaryStmt(OP_free, stmt);
+}
+
+bool MIRParser::ParseUnaryStmtCallAssertNonNull(StmtNodePtr &stmt) {
+  std::string funcName;
+  std::string stmtFuncName;
+  int index = 0;
+  if (!ParseCallAssertInfo(funcName, &index, stmtFuncName)) {
+    Error("ParseCallAssertInfo failed");
+    return false;
+  }
+  lexer.NextToken();
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  GStrIdx stmtstridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(stmtFuncName);
+  stmt = mod.CurFuncCodeMemPool()->New<CallAssertNonnullStmtNode>(OP_callassertnonnull, stridx, index, stmtstridx);
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  stmt->SetOpnd(expr, 0);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseAssertInfo(std::string &funcName) {
+  if (lexer.NextToken() != TK_langle) {
+    Error("expect < parsing safey assert check ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_fname) {
+    Error("expect &funcname parsing parsing safey assert check ");
+    return false;
+  }
+  funcName = lexer.GetName();
+  if (lexer.NextToken() != TK_rangle) {
+    Error("expect > parsing safey assert check ");
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseUnaryStmtAssertNonNullCheck(Opcode op, StmtNodePtr &stmt) {
+  std::string funcName;
+  if (!ParseAssertInfo(funcName)) {
+    Error("ParseAssertInfo failed");
+    return false;
+  }
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  lexer.NextToken();
+  stmt = mod.CurFuncCodeMemPool()->New<AssertNonnullStmtNode>(op, stridx);
+  BaseNode *expr = nullptr;
+  if (!ParseExprOneOperand(expr)) {
+    return false;
+  }
+  stmt->SetOpnd(expr, 0);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseUnaryStmtAssertNonNull(StmtNodePtr &stmt) {
+  if (mod.IsCModule()) {
+    return ParseUnaryStmtAssertNonNullCheck(OP_assertnonnull, stmt);
+  } else {
+    return ParseUnaryStmt(OP_assertnonnull, stmt);
+  }
+}
+
+bool MIRParser::ParseUnaryStmtAssignAssertNonNull(StmtNodePtr &stmt) {
+  return ParseUnaryStmtAssertNonNullCheck(OP_assignassertnonnull, stmt);
+}
+
+bool MIRParser::ParseUnaryStmtReturnAssertNonNull(StmtNodePtr &stmt) {
+  return ParseUnaryStmtAssertNonNullCheck(OP_returnassertnonnull, stmt);
+}
+
+bool MIRParser::ParseStmtMarker(StmtNodePtr &stmt) {
+  Opcode op;
+  switch (paramTokenKindForStmt) {
+    case TK_jscatch:
+      op = OP_jscatch;
+      break;
+    case TK_finally:
+      op = OP_finally;
+      break;
+    case TK_cleanuptry:
+      op = OP_cleanuptry;
+      break;
+    case TK_endtry:
+      op = OP_endtry;
+      break;
+    case TK_retsub:
+      op = OP_retsub;
+      break;
+    case TK_membaracquire:
+      op = OP_membaracquire;
+      break;
+    case TK_membarrelease:
+      op = OP_membarrelease;
+      break;
+    case TK_membarstoreload:
+      op = OP_membarstoreload;
+      break;
+    case TK_membarstorestore:
+      op = OP_membarstorestore;
+      break;
+    default:
+      return false;
+  }
+  auto *stmtNode = mod.CurFuncCodeMemPool()->New<StmtNode>(op);
+  stmt = stmtNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtGosub(StmtNodePtr &stmt) {
+  if (lexer.NextToken() != TK_label) {
+    Error("expect finally label in gosub but get ");
+    return false;
+  }
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  LabelIdx labidx = mod.CurFunction()->GetLabelTab()->GetLabelIdxFromStrIdx(stridx);
+  if (labidx == 0) {
+    labidx = mod.CurFunction()->GetLabelTab()->CreateLabel();
+    mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx);
+    mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx);
+  }
+  auto *goSubNode = mod.CurFuncCodeMemPool()->New<GotoNode>(OP_gosub);
+  goSubNode->SetOffset(labidx);
+  stmt = goSubNode;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseBinaryStmt(StmtNodePtr &stmt, Opcode op) {
+  auto *assStmt = mod.CurFuncCodeMemPool()->New<BinaryStmtNode>(op);
+  lexer.NextToken();
+  BaseNode *opnd0 = nullptr;
+  BaseNode *opnd1 = nullptr;
+  if (!ParseExprTwoOperand(opnd0, opnd1)) {
+    return false;
+  }
+  assStmt->SetBOpnd(opnd0, 0);
+  assStmt->SetBOpnd(opnd1, 1);
+  stmt = assStmt;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseNaryStmtAssert(StmtNodePtr &stmt, Opcode op) {
+  std::string funcName;
+  if (!ParseAssertInfo(funcName)) {
+    Error("ParseAssertInfo failed");
+    return false;
+  }
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  auto *assStmt = mod.CurFuncCodeMemPool()->New<AssertBoundaryStmtNode>(mod, op, stridx);
+  if (!ParseNaryExpr(*assStmt)) {
+    Error("ParseNaryStmtAssert failed");
+    return false;
+  }
+  assStmt->SetNumOpnds(static_cast<uint8>(assStmt->GetNopndSize()));
+  stmt = assStmt;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseNaryStmtAssertGE(StmtNodePtr &stmt) {
+  return ParseNaryStmtAssert(stmt, OP_assertge);
+}
+
+bool MIRParser::ParseNaryStmtAssertLT(StmtNodePtr &stmt) {
+  return ParseNaryStmtAssert(stmt, OP_assertlt);
+}
+
+bool MIRParser::ParseNaryStmtReturnAssertLE(StmtNodePtr &stmt) {
+  return ParseNaryStmtAssert(stmt, OP_returnassertle);
+}
+
+bool MIRParser::ParseNaryStmtAssignAssertLE(StmtNodePtr &stmt) {
+  return ParseNaryStmtAssert(stmt, OP_assignassertle);
+}
+
+bool MIRParser::ParseNaryStmtCalcassertGE(StmtNodePtr &stmt) {
+  return ParseNaryStmtAssert(stmt, OP_calcassertge);
+}
+
+bool MIRParser::ParseNaryStmtCalcassertLT(StmtNodePtr &stmt) {
+  return ParseNaryStmtAssert(stmt, OP_calcassertlt);
+}
+
+bool MIRParser::ParseCallAssertInfo(std::string &funcName, int *paramIndex, std::string &stmtFuncName) {
+  if (lexer.NextToken() != TK_langle) {
+    Error("expect < parsing safey call check ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_fname) {
+    Error("expect &funcname parsing parsing safey call check ");
+    return false;
+  }
+  funcName = lexer.GetName();
+  if (lexer.NextToken() != TK_coma) {
+    Error("expect , parsing parsing safey call check ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect intconst parsing parsing safey call check ");
+    return false;
+  }
+  *paramIndex = static_cast<int>(lexer.GetTheIntVal());
+  if (lexer.NextToken() != TK_coma) {
+    Error("expect , parsing parsing safey call check ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_fname) {
+    Error("expect &stmtfuncname parsing parsing safey call check ");
+    return false;
+  }
+  stmtFuncName = lexer.GetName();
+  if (lexer.NextToken() != TK_rangle) {
+    Error("expect > parsing parsing safey call check ");
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseNaryStmtCallAssertLE(StmtNodePtr &stmt) {
+  std::string funcName;
+  std::string stmtFuncName;
+  int index = 0;
+  if (!ParseCallAssertInfo(funcName, &index, stmtFuncName)) {
+    Error("ParseCallAssertInfo failed");
+    return false;
+  }
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  GStrIdx stmtstridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(stmtFuncName);
+  auto *assStmt = mod.CurFuncCodeMemPool()->New<CallAssertBoundaryStmtNode>(mod, OP_callassertle, stridx, index,
+                                                                            stmtstridx);
+  if (!ParseNaryExpr(*assStmt)) {
+    Error("ParseNaryExpr failed");
+    return false;
+  }
+  assStmt->SetNumOpnds(static_cast<uint8>(assStmt->GetNopndSize()));
+  stmt = assStmt;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseNaryExpr(NaryStmtNode &stmtNode) {
+  if (lexer.NextToken() != TK_lparen) {
+    Error("expect ( parsing NaryExpr ");
+    return false;
+  }
+  (void)lexer.NextToken(); // skip TK_lparen
+  while (lexer.GetTokenKind() != TK_rparen) {
+    BaseNode *expr = nullptr;
+    if (!ParseExpression(expr)) {
+      Error("ParseStmtReturn failed");
+      return false;
+    }
+    stmtNode.GetNopnd().push_back(expr);
+    if (lexer.GetTokenKind() != TK_coma && lexer.GetTokenKind() != TK_rparen) {
+      Error("expect , or ) parsing NaryStmt");
+      return false;
+    }
+    if (lexer.GetTokenKind() == TK_coma) {
+      lexer.NextToken();
+    }
+  }
+  return true;
+}
+
+bool MIRParser::ParseNaryStmt(StmtNodePtr &stmt, Opcode op) {
+  auto *stmtReturn = mod.CurFuncCodeMemPool()->New<NaryStmtNode>(mod, op);
+  if (op == OP_syncenter) { // old code reconstruct later
+    if (lexer.NextToken() != TK_lparen) {
+      Error("expect return with ( but get ");
+      return false;
+    }
+    lexer.NextToken();
+    BaseNode *expr = nullptr;
+    if (!ParseExpression(expr)) {
+      Error("ParseStmtReturn failed");
+      return false;
+    }
+    stmtReturn->GetNopnd().push_back(expr);
+    if (lexer.GetTokenKind() == TK_coma) {
+      lexer.NextToken();
+      BaseNode *exprSync = nullptr;
+      if (!ParseExpression(exprSync)) {
+        Error("ParseStmtReturn failed");
+        return false;
+      }
+      stmtReturn->GetNopnd().push_back(exprSync);
+    } else {
+      MIRType *intType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<TyIdx>(PTY_i32));
+      // default 2 for __sync_enter_fast()
+      MIRIntConst *intConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(2, *intType);
+      ConstvalNode *exprConst = mod.GetMemPool()->New<ConstvalNode>();
+      exprConst->SetPrimType(PTY_i32);
+      exprConst->SetConstVal(intConst);
+      stmtReturn->GetNopnd().push_back(exprConst);
+      stmtReturn->SetNumOpnds(stmtReturn->GetNopndSize());
+    }
+
+    if (lexer.GetTokenKind() != TK_rparen) {
+      Error("expect ) parsing NaryStmt");
+      return false;
+    }
+  } else if (!ParseNaryExpr(*stmtReturn)) {
+    Error("ParseNaryExpr failed");
+    return false;
+  }
+  stmtReturn->SetNumOpnds(stmtReturn->GetNopndSize());
+  stmt = stmtReturn;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseNaryStmtReturn(StmtNodePtr &stmt) {
+  return ParseNaryStmt(stmt, OP_return);
+}
+
+bool MIRParser::ParseNaryStmtSyncEnter(StmtNodePtr &stmt) {
+  return ParseNaryStmt(stmt, OP_syncenter);
+}
+
+bool MIRParser::ParseNaryStmtSyncExit(StmtNodePtr &stmt) {
+  return ParseNaryStmt(stmt, OP_syncexit);
+}
+
+bool MIRParser::ParseLoc() {
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect intconst in LOC but get ");
+    return false;
+  }
+  lastFileNum = lexer.GetTheIntVal();
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect intconst in LOC but get ");
+    return false;
+  }
+  lastLineNum = lexer.GetTheIntVal();
+  if (firstLineNum == 0) {
+    firstLineNum = lastLineNum;
+  }
+  if (lexer.NextToken() == TK_intconst) {  // optional column number
+    lastColumnNum = static_cast<uint16>(lexer.GetTheIntVal());
+    lexer.NextToken();
+  }
+  return true;
+}
+
+bool MIRParser::ParseLocStmt(StmtNodePtr&) {
+  return ParseLoc();
+}
+
+bool MIRParser::ParseStatement(StmtNodePtr &stmt) {
+  paramTokenKindForStmt = lexer.GetTokenKind();
+  uint32 mplNum = lexer.GetLineNum();
+  uint32 lnum = lastLineNum;
+  uint32 fnum = lastFileNum;
+  uint16 cnum = lastColumnNum;
+  std::map<TokenKind, FuncPtrParseStmt>::iterator itFuncPtr = funcPtrMapForParseStmt.find(paramTokenKindForStmt);
+  if (itFuncPtr != funcPtrMapForParseStmt.end()) {
+    if (!(this->*(itFuncPtr->second))(stmt)) {
+      return false;
+    }
+  } else {
+    return false;
+  }
+  if (stmt && stmt->GetSrcPos().MplLineNum() == 0) {
+    stmt->GetSrcPos().SetFileNum(fnum);
+    stmt->GetSrcPos().SetLineNum(lnum);
+    stmt->GetSrcPos().SetColumn(cnum);
+    stmt->GetSrcPos().SetMplLineNum(mplNum);
+    if (safeRegionFlag.top()) {
+      stmt->SetInSafeRegion();
+    }
+  }
+  return true;
+}
+
+/* parse the statements enclosed by { and }
+ */
+bool MIRParser::ParseStmtBlock(BlockNodePtr &blk) {
+  bool retval = false;
+  if (lexer.GetTokenKind() != TK_lbrace) {
+    Error("expect { for func body but get ");
+    return false;
+  }
+  SrcPosition posB(lastFileNum, lastLineNum, lastColumnNum, lexer.GetLineNum());
+  blk = mod.CurFuncCodeMemPool()->New<BlockNode>();
+  MIRFunction *fn = mod.CurFunction();
+  paramCurrFuncForParseStmtBlock = fn;
+  lexer.NextToken();
+  bool first = true;
+  // Insert _mcount for PI.
+  if (mod.GetWithProfileInfo()) {
+    StmtNode *stmtt = nullptr;
+    if (!ParseStmtCallMcount(stmtt)) {
+      SrcPosition posE(lastFileNum, lastLineNum, lastColumnNum, lexer.GetLineNum());
+      mod.CurFunction()->GetScope()->AddTuple(blk->GetSrcPos(), posB, posE);
+      return retval;
+    }
+    blk->AddStatement(stmtt);
+  }
+  while (true) {
+    TokenKind stmtTk = lexer.GetTokenKind();
+    // calculate the mpl file line number mplNum here to get accurate result
+    uint32 mplNum = lexer.GetLineNum();
+    if (IsStatement(stmtTk)) {
+      ParseStmtBlockForSeenComment(blk, mplNum);
+      StmtNode *stmt = nullptr;
+      if (!ParseStatement(stmt)) {
+        Error("ParseStmtBlock failed when parsing a statement");
+        break;
+      }
+      if (stmt == nullptr) {  // stmt is nullptr if it is a LOC
+        continue;
+      }
+
+      blk->AddStatement(stmt);
+      // set blk src position
+      if (first) {
+        blk->SetSrcPos(stmt->GetSrcPos());
+        first = false;
+      }
+    } else {
+      std::map<TokenKind, FuncPtrParseStmtBlock>::iterator itFuncPtr = funcPtrMapForParseStmtBlock.find(stmtTk);
+      if (itFuncPtr == funcPtrMapForParseStmtBlock.end()) {
+        if (stmtTk == TK_rbrace) {
+          ParseStmtBlockForSeenComment(blk, mplNum);
+          lexer.NextToken();
+          retval = true;
+        } else {
+          Error("expect } or var or statement for func body but get ");
+        }
+        break;
+      } else {
+        if (!(this->*(itFuncPtr->second))()) {
+          break;
+        }
+      }
+    }
+  }
+
+  SrcPosition posE(lastFileNum, lastLineNum, lastColumnNum, lexer.GetLineNum());
+  mod.CurFunction()->GetScope()->AddTuple(blk->GetSrcPos(), posB, posE);
+  return retval;
+}
+
+void MIRParser::ParseStmtBlockForSeenComment(BlockNodePtr blk, uint32 mplNum) {
+  if (Options::noComment) {
+    lexer.seenComments.clear();
+    return;
+  }
+  // collect accumulated comments into comment statement nodes
+  if (!lexer.seenComments.empty()) {
+    for (size_t i = 0; i < lexer.seenComments.size(); ++i) {
+      auto *cmnt = mod.CurFuncCodeMemPool()->New<CommentNode>(mod);
+      cmnt->SetComment(lexer.seenComments[i]);
+      SetSrcPos(cmnt->GetSrcPos(), mplNum);
+      blk->AddStatement(cmnt);
+    }
+    lexer.seenComments.clear();
+  }
+}
+
+bool MIRParser::ParseStmtBlockForVar(TokenKind stmtTK) {
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  MIRSymbol *st = fn->GetSymTab()->CreateSymbol(kScopeLocal);
+  st->SetStorageClass(kScAuto);
+  st->SetSKind(kStVar);
+  SetSrcPos(st->GetSrcPosition(), lexer.GetLineNum());
+  if (stmtTK == TK_tempvar) {
+    st->SetIsTmp(true);
+  }
+  if (!ParseDeclareVar(*st)) {
+    return false;
+  }
+  if (!fn->GetSymTab()->AddToStringSymbolMap(*st)) {
+    Error("duplicate declare symbol parse function ");
+    return false;
+  }
+  if (!ParseDeclareVarInitValue(*st)) {
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForVar() {
+  return ParseStmtBlockForVar(TK_var);
+}
+
+bool MIRParser::ParseStmtBlockForTempVar() {
+  return ParseStmtBlockForVar(TK_tempvar);
+}
+
+bool MIRParser::ParseStmtBlockForReg() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_preg) {
+    Error("expect %%preg after reg");
+    return false;
+  }
+  PregIdx pregIdx;
+  if (!ParsePseudoReg(PTY_ref, pregIdx)) {
+    return false;
+  }
+  MIRPreg *preg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(pregIdx);
+  TyIdx tyidx(0);
+  if (!ParseType(tyidx)) {
+    Error("ParseDeclareVar failed when parsing the type");
+    return false;
+  }
+  ASSERT(tyidx > 0, "parse declare var failed ");
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx);
+  preg->SetMIRType(mirType);
+  if (lexer.GetTokenKind() == TK_intconst) {
+    int64 theIntVal = static_cast<int64>(lexer.GetTheIntVal());
+    if (theIntVal != 0 && theIntVal != 1) {
+      Error("parseDeclareReg failed");
+      return false;
+    }
+    preg->SetNeedRC(theIntVal == 0 ? false : true);
+  } else {
+    Error("parseDeclareReg failed");
+    return false;
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForType() {
+  paramParseLocalType = true;
+  if (!ParseTypeDefine()) {
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForFrameSize() {
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after frameSize but get ");
+    return false;
+  }
+  fn->SetFrameSize(static_cast<uint32>(lexer.GetTheIntVal()));
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForUpformalSize() {
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after upFormalSize but get ");
+    return false;
+  }
+  fn->SetUpFormalSize(static_cast<uint32>(lexer.GetTheIntVal()));
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForModuleID() {
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after moduleid but get ");
+    return false;
+  }
+  fn->SetModuleID(lexer.GetTheIntVal());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForFuncSize() {
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after funcSize but get ");
+    return false;
+  }
+  fn->SetFuncSize(lexer.GetTheIntVal());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForFuncID() {
+  // funcid is for debugging purpose
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after funcid but get ");
+    return false;
+  }
+  fn->SetPuidxOrigin(lexer.GetTheIntVal());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForFormalWordsTypeTagged() {
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  uint8 *addr = ParseWordsInfo(fn->GetUpFormalSize());
+  if (addr == nullptr) {
+    Error("parser error for formalwordstypetagged");
+    return false;
+  }
+  fn->SetFormalWordsTypeTagged(addr);
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForLocalWordsTypeTagged() {
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  uint8 *addr = ParseWordsInfo(fn->GetFrameSize());
+  if (addr == nullptr) {
+    Error("parser error for localWordsTypeTagged");
+    return false;
+  }
+  fn->SetLocalWordsTypeTagged(addr);
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForFormalWordsRefCounted() {
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  uint8 *addr = ParseWordsInfo(fn->GetUpFormalSize());
+  if (addr == nullptr) {
+    Error("parser error for formalwordsrefcounted");
+    return false;
+  }
+  fn->SetFormalWordsRefCounted(addr);
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForLocalWordsRefCounted() {
+  MIRFunction *fn = paramCurrFuncForParseStmtBlock;
+  uint8 *addr = ParseWordsInfo(fn->GetFrameSize());
+  if (addr == nullptr) {
+    Error("parser error for localwordsrefcounted");
+    return false;
+  }
+  fn->SetLocalWordsRefCounted(addr);
+  return true;
+}
+
+bool MIRParser::ParseStmtBlockForFuncInfo() {
+  lexer.NextToken();
+  if (!ParseFuncInfo()) {
+    return false;
+  }
+  return true;
+}
+
+/* exprparser */
+static Opcode GetUnaryOp(TokenKind tk) {
+  switch (tk) {
+#define UNARYOP(P) \
+  case TK_##P:     \
+    return OP_##P;
+#include "unary_op.def"
+#undef UNARYOP
+    default:
+      return OP_undef;
+  }
+}
+
+static Opcode GetBinaryOp(TokenKind tk) {
+  switch (tk) {
+#define BINARYOP(P) \
+  case TK_##P:      \
+    return OP_##P;
+#include "binary_op.def"
+#undef BINARYOP
+    default:
+      return OP_undef;
+  }
+}
+
+static Opcode GetConvertOp(TokenKind tk) {
+  switch (tk) {
+    case TK_ceil:
+      return OP_ceil;
+    case TK_cvt:
+      return OP_cvt;
+    case TK_floor:
+      return OP_floor;
+    case TK_round:
+      return OP_round;
+    case TK_trunc:
+      return OP_trunc;
+    default:
+      return OP_undef;
+  }
+}
+
+bool MIRParser::ParseExprOneOperand(BaseNodePtr &expr) {
+  if (lexer.GetTokenKind() != TK_lparen) {
+    Error("expect ( parsing operand parsing unary ");
+    return false;
+  }
+  lexer.NextToken();
+  if (!ParseExpression(expr)) {
+    Error("expect expression as openrand of unary expression ");
+    return false;
+  }
+  if (lexer.GetTokenKind() != TK_rparen) {
+    Error("expect ) parsing operand parsing unary ");
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseExprTwoOperand(BaseNodePtr &opnd0, BaseNodePtr &opnd1) {
+  if (lexer.GetTokenKind() != TK_lparen) {
+    Error("expect ( parsing operand parsing unary ");
+    return false;
+  }
+  lexer.NextToken();
+  if (!ParseExpression(opnd0)) {
+    return false;
+  }
+  if (lexer.GetTokenKind() != TK_coma) {
+    Error("expect , between two operands but get ");
+    return false;
+  }
+  lexer.NextToken();
+  if (!ParseExpression(opnd1)) {
+    return false;
+  }
+  if (lexer.GetTokenKind() != TK_rparen) {
+    Error("expect ) parsing operand parsing unary ");
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseExprNaryOperand(MapleVector<BaseNode*> &opndVec) {
+  if (lexer.GetTokenKind() != TK_lparen) {
+    Error("expect ( parsing operand parsing nary operands ");
+    return false;
+  }
+  TokenKind tk = lexer.NextToken();
+  while (tk != TK_rparen) {
+    BaseNode *opnd = nullptr;
+    if (!ParseExpression(opnd)) {
+      Error("expect expression parsing nary operands ");
+      return false;
+    }
+    opndVec.push_back(opnd);
+    tk = lexer.GetTokenKind();
+    if (tk == TK_coma) {
+      tk = lexer.NextToken();
+    }
+  }
+  return true;
+}
+
+bool MIRParser::ParseDeclaredSt(StIdx &stidx) {
+  TokenKind varTk = lexer.GetTokenKind();
+  stidx.SetFullIdx(0);
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  if (varTk == TK_gname) {
+    stidx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(stridx);
+    if (stidx.FullIdx() == 0) {
+      MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+      st->SetNameStrIdx(stridx);
+      st->SetSKind(kStVar);
+      (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*st);
+      stidx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(stridx);
+      return true;
+    }
+  } else if (varTk == TK_lname) {
+    stidx = mod.CurFunction()->GetSymTab()->GetStIdxFromStrIdx(stridx);
+    if (stidx.FullIdx() == 0) {
+      Error("local symbol not declared ");
+      return false;
+    }
+  } else {
+    Error("expect global/local name but get ");
+    return false;
+  }
+  return true;
+}
+
+void MIRParser::CreateFuncMIRSymbol(PUIdx &puidx, GStrIdx strIdx) {
+  MIRSymbol *funcSt = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  funcSt->SetNameStrIdx(strIdx);
+  (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcSt);
+  funcSt->SetStorageClass(kScText);
+  funcSt->SetSKind(kStFunc);
+  funcSt->SetNeedForwDecl();
+  auto *fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSt->GetStIdx());
+  puidx = static_cast<PUIdx>(GlobalTables::GetFunctionTable().GetFuncTable().size());
+  fn->SetPuidx(puidx);
+  GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
+  funcSt->SetFunction(fn);
+  if ((options & kParseInlineFuncBody) != 0) {
+    funcSt->SetIsTmpUnused(true);
+  }
+}
+
+bool MIRParser::ParseDeclaredFunc(PUIdx &puidx) {
+  GStrIdx stridx = GlobalTables::GetStrTable().GetStrIdxFromName(lexer.GetName());
+  if (stridx == 0u) {
+    stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  }
+  StIdx stidx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(stridx);
+  if (stidx.FullIdx() == 0) {
+    CreateFuncMIRSymbol(puidx, stridx);
+    return true;
+  }
+  MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx());
+  ASSERT(st != nullptr, "null ptr check");
+  if (st->GetSKind() != kStFunc) {
+    Error("function name not declared as function");
+    return false;
+  }
+  MIRFunction *func = st->GetFunction();
+  CHECK_NULL_FATAL(func);
+  puidx = func->GetPuidx();
+  st->SetAppearsInCode(true);
+  return true;
+}
+
+bool MIRParser::ParseExprDread(BaseNodePtr &expr) {
+  if (lexer.GetTokenKind() != TK_dread) {
+    Error("expect dread but get ");
+    return false;
+  }
+  AddrofNode *dexpr = mod.CurFuncCodeMemPool()->New<AddrofNode>(OP_dread);
+  expr = dexpr;
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  bool parseRet = ParsePrimType(tyidx);
+  if (tyidx == 0u || !parseRet) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  expr->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  StIdx stidx;
+  if (!ParseDeclaredSt(stidx)) {
+    return false;
+  }
+  if (stidx.FullIdx() == 0) {
+    Error("expect a symbol ParseExprDread failed");
+    return false;
+  }
+  dexpr->SetStIdx(stidx);
+  TokenKind endtk = lexer.NextToken();
+  if (endtk == TK_intconst) {
+    dexpr->SetFieldID(lexer.GetTheIntVal());
+    lexer.NextToken();
+  } else if (!IsDelimitationTK(endtk)) {
+    Error("expect , or ) delimitation token but get ");
+    return false;
+  } else {
+    dexpr->SetFieldID(0);
+  }
+  if (!dexpr->CheckNode(mod)) {
+    Error("dread is not legal");
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseExprDreadoff(BaseNodePtr &expr) {
+  if (lexer.GetTokenKind() != TK_dreadoff) {
+    Error("expect dreadoff but get ");
+    return false;
+  }
+  DreadoffNode *dexpr = mod.CurFuncCodeMemPool()->New<DreadoffNode>(OP_dreadoff);
+  expr = dexpr;
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  bool parseRet = ParsePrimType(tyidx);
+  if (tyidx == 0u || !parseRet) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  expr->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  StIdx stidx;
+  if (!ParseDeclaredSt(stidx)) {
+    return false;
+  }
+  if (stidx.FullIdx() == 0) {
+    Error("expect a symbol ParseExprDread failed");
+    return false;
+  }
+  dexpr->stIdx = stidx;
+  TokenKind endtk = lexer.NextToken();
+  if (endtk == TK_intconst) {
+    dexpr->offset = static_cast<int32>(lexer.GetTheIntVal());
+    lexer.NextToken();
+  } else {
+    Error("expect integer offset but get ");
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseExprRegread(BaseNodePtr &expr) {
+  auto *regRead = mod.CurFuncCodeMemPool()->New<RegreadNode>();
+  expr = regRead;
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    return false;
+  }
+  if (tyidx == 0u) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  expr->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  if (lexer.GetTokenKind() == TK_specialreg) {
+    PregIdx tempPregIdx = regRead->GetRegIdx();
+    bool isSuccess = ParseSpecialReg(tempPregIdx);
+    regRead->SetRegIdx(tempPregIdx);
+    return isSuccess;
+  }
+  if (lexer.GetTokenKind() == TK_preg) {
+    PregIdx tempPregIdx = regRead->GetRegIdx();
+    bool isSuccess = ParsePseudoReg(regRead->GetPrimType(), tempPregIdx);
+    regRead->SetRegIdx(tempPregIdx);
+    return isSuccess;
+  }
+  Error("expect special or pseudo register but get ");
+  return false;
+}
+
+bool MIRParser::ParseExprConstval(BaseNodePtr &expr) {
+  auto *exprConst = mod.CurFuncCodeMemPool()->New<ConstvalNode>();
+  TokenKind typeTk = lexer.NextToken();
+  if (!IsPrimitiveType(typeTk)) {
+    Error("expect type for GetConstVal but get ");
+    return false;
+  }
+  exprConst->SetPrimType(GetPrimitiveType(typeTk));
+  lexer.NextToken();
+  MIRConst *constVal = nullptr;
+  if (!ParseScalarValue(constVal, *GlobalTables::GetTypeTable().GetPrimType(exprConst->GetPrimType()))) {
+    Error("expect scalar type but get ");
+    return false;
+  }
+  exprConst->SetConstVal(constVal);
+  expr = exprConst;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprConststr(BaseNodePtr &expr) {
+  auto *strConst = mod.CurFuncCodeMemPool()->New<ConststrNode>();
+  TokenKind tk = lexer.NextToken();
+  if (!IsPrimitiveType(tk)) {
+    Error("expect primitive type for conststr but get ");
+    return false;
+  }
+  strConst->SetPrimType(GetPrimitiveType(tk));
+  if (!IsAddress(strConst->GetPrimType())) {
+    Error("expect primitive type for conststr but get ");
+    return false;
+  }
+  tk = lexer.NextToken();
+  if (tk != TK_string) {
+    Error("expect string literal for conststr but get ");
+    return false;
+  }
+  strConst->SetStrIdx(GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(lexer.GetName()));
+  expr = strConst;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprConststr16(BaseNodePtr &expr) {
+  auto *str16Const = mod.CurFuncCodeMemPool()->New<Conststr16Node>();
+  TokenKind tk = lexer.NextToken();
+  if (!IsPrimitiveType(tk)) {
+    Error("expect primitive type for conststr16 but get ");
+    return false;
+  }
+  str16Const->SetPrimType(GetPrimitiveType(tk));
+  if (!IsAddress(str16Const->GetPrimType())) {
+    Error("expect primitive type for conststr16 but get ");
+    return false;
+  }
+  tk = lexer.NextToken();
+  if (tk != TK_string) {
+    Error("expect string literal for conststr16 but get ");
+    return false;
+  }
+  // UTF-16 strings in mpl files are presented as UTF-8 strings
+  // to keep the printable chars in ascii form
+  // so we need to do a UTF8ToUTF16 conversion
+  std::string str = lexer.GetName();
+  std::u16string str16;
+  (void)namemangler::UTF8ToUTF16(str16, str);
+  str16Const->SetStrIdx(GlobalTables::GetU16StrTable().GetOrCreateStrIdxFromName(str16));
+  expr = str16Const;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprSizeoftype(BaseNodePtr &expr) {
+  auto *exprSizeOfType = mod.CurFuncCodeMemPool()->New<SizeoftypeNode>();
+  TokenKind typeTk = lexer.NextToken();
+  if (!IsPrimitiveType(typeTk)) {
+    Error("expect type for GetConstVal but get ");
+    return false;
+  }
+  exprSizeOfType->SetPrimType(GetPrimitiveType(typeTk));
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  if (!ParseType(tyidx)) {
+    Error("expect type parsing array but get ");
+    return false;
+  }
+  exprSizeOfType->SetTyIdx(tyidx);
+  expr = exprSizeOfType;
+  return true;
+}
+
+bool MIRParser::ParseExprFieldsDist(BaseNodePtr &expr) {
+  TokenKind typeTk = lexer.NextToken();
+  if (!IsPrimitiveType(typeTk)) {
+    Error("expect type for GetConstVal but get ");
+    return false;
+  }
+  auto *node = mod.CurFuncCodeMemPool()->New<FieldsDistNode>();
+  node->SetPrimType(GetPrimitiveType(typeTk));
+  lexer.NextToken();
+  TyIdx tyIdx(0);
+  if (!ParseType(tyIdx)) {
+    Error("expect type parsing array but get ");
+    return false;
+  }
+  node->SetTyIdx(tyIdx);
+  TokenKind tk = lexer.GetTokenKind();
+  if (tk != TK_intconst) {
+    Error("expect type int but get");
+    return false;
+  }
+  node->SetFiledID1(lexer.GetTheIntVal());
+  tk = lexer.NextToken();
+  if (tk != TK_intconst) {
+    Error("expect type int but get");
+    return false;
+  }
+  node->SetFiledID2(lexer.GetTheIntVal());
+  lexer.NextToken();
+  expr = node;
+  return true;
+}
+
+bool MIRParser::ParseExprBinary(BaseNodePtr &expr) {
+  Opcode opcode = GetBinaryOp(lexer.GetTokenKind());
+  if (opcode == OP_undef) {
+    Error("expect add operator but get ");
+    return false;
+  }
+  auto *addExpr = mod.CurFuncCodeMemPool()->New<BinaryNode>(opcode);
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect type parsing binary operator but get ");
+    return false;
+  }
+  addExpr->SetPrimType(GetPrimitiveType(lexer.GetTokenKind()));
+  lexer.NextToken();
+  BaseNode *opnd0 = nullptr;
+  BaseNode *opnd1 = nullptr;
+  if (!ParseExprTwoOperand(opnd0, opnd1)) {
+    return false;
+  }
+  addExpr->SetBOpnd(opnd0, 0);
+  addExpr->SetBOpnd(opnd1, 1);
+  expr = addExpr;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprCompare(BaseNodePtr &expr) {
+  Opcode opcode = GetBinaryOp(lexer.GetTokenKind());
+  auto *addExpr = mod.CurFuncCodeMemPool()->New<CompareNode>(opcode);
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect type parsing compare operator but get ");
+    return false;
+  }
+  addExpr->SetPrimType(GetPrimitiveType(lexer.GetTokenKind()));
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect operand type parsing compare operator but get ");
+    return false;
+  }
+  addExpr->SetOpndType(GetPrimitiveType(lexer.GetTokenKind()));
+  lexer.NextToken();
+  BaseNode *opnd0 = nullptr;
+  BaseNode *opnd1 = nullptr;
+  if (!ParseExprTwoOperand(opnd0, opnd1)) {
+    return false;
+  }
+  addExpr->SetBOpnd(opnd0, 0);
+  addExpr->SetBOpnd(opnd1, 1);
+  expr = addExpr;
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprDepositbits(BaseNodePtr &expr) {
+  // syntax: depositbits <int-type> <bOffset> <bSize> (<opnd0>, <opnd1>)
+  if (lexer.GetTokenKind() != TK_depositbits) {
+    Error("expect depositbits but get ");
+    return false;
+  }
+  auto *dpsbNode = mod.CurFuncCodeMemPool()->New<DepositbitsNode>();
+  expr = dpsbNode;
+  PrimType ptyp = GetPrimitiveType(lexer.NextToken());
+  if (!IsPrimitiveInteger(ptyp)) {
+    Error("expect <int-type> but get ");
+    return false;
+  }
+  dpsbNode->SetPrimType(ptyp);
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect bOffset but get ");
+    return false;
+  }
+  dpsbNode->SetBitsOffset(lexer.GetTheIntVal());
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect bSize but get ");
+    return false;
+  }
+  dpsbNode->SetBitsSize(lexer.GetTheIntVal());
+  lexer.NextToken();
+  BaseNode *opnd0 = nullptr;
+  BaseNode *opnd1 = nullptr;
+  if (!ParseExprTwoOperand(opnd0, opnd1)) {
+    Error("ParseExprDepositbits when parsing two operand");
+    return false;
+  }
+  dpsbNode->SetBOpnd(opnd0, 0);
+  dpsbNode->SetBOpnd(opnd1, 1);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprIreadIaddrof(IreadNode &expr) {
+  // syntax : iread/iaddrof <prim-type> <type> <field-id> (<addr-expr>)
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    return false;
+  }
+  expr.SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  tyidx = TyIdx(0);
+  if (!ParseDerivedType(tyidx)) {
+    Error("ParseExprIreadIaddrof failed when paring derived type");
+    return false;
+  }
+  expr.SetTyIdx(tyidx);
+  if (lexer.GetTokenKind() == TK_intconst) {
+    expr.SetFieldID(lexer.theIntVal);
+    lexer.NextToken();
+  }
+  BaseNode *opnd0 = nullptr;
+  if (!ParseExprOneOperand(opnd0)) {
+    return false;
+  }
+  expr.SetOpnd(opnd0, 0);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprIread(BaseNodePtr &expr) {
+  // syntax : iread <prim-type> <type> <field-id> (<addr-expr>)
+  auto *iExpr = mod.CurFuncCodeMemPool()->New<IreadNode>(OP_iread);
+  if (!ParseExprIreadIaddrof(*iExpr)) {
+    Error("ParseExprIread failed when trying to parse addof");
+    return false;
+  }
+  expr = iExpr;
+  return true;
+}
+
+bool MIRParser::ParseExprIaddrof(BaseNodePtr &expr) {
+  // syntax : iaddrof <prim-type> <type> <field-id> (<addr-expr>)
+  auto *iExpr = mod.CurFuncCodeMemPool()->New<IreadNode>(OP_iaddrof);
+  if (!ParseExprIreadIaddrof(*iExpr)) {
+    Error("ParseExprIaddrof failed when trying to parse addof");
+    return false;
+  }
+  expr = iExpr;
+  return true;
+}
+
+bool MIRParser::ParseExprIreadoff(BaseNodePtr &expr) {
+  // syntax : iread <prim-type> <offset> (<addr-expr>)
+  auto *iReadOff = mod.CurFuncCodeMemPool()->New<IreadoffNode>();
+  expr = iReadOff;
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    return false;
+  }
+  iReadOff->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  if (!IsPrimitiveScalar(iReadOff->GetPrimType())) {
+    Error("only scalar types allowed for ireadoff");
+    return false;
+  }
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect offset but get ");
+    return false;
+  }
+  iReadOff->SetOffset(lexer.GetTheIntVal());
+  lexer.NextToken();
+  BaseNode *opnd = nullptr;
+  if (!ParseExprOneOperand(opnd)) {
+    Error("ParseExprIreadoff when paring one operand");
+    return false;
+  }
+  iReadOff->SetOpnd(opnd, 0);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprIreadFPoff(BaseNodePtr &expr) {
+  // syntax : iread <prim-type> <offset>
+  auto *iReadOff = mod.CurFuncCodeMemPool()->New<IreadFPoffNode>();
+  expr = iReadOff;
+  if (!IsPrimitiveType(lexer.NextToken())) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    return false;
+  }
+  iReadOff->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect offset but get ");
+    return false;
+  }
+  iReadOff->SetOffset(lexer.GetTheIntVal());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprAddrof(BaseNodePtr &expr) {
+  // syntax: addrof <prim-type> <var-name> <field-id>
+  auto *addrofNode = mod.CurFuncCodeMemPool()->New<AddrofNode>(OP_addrof);
+  expr = addrofNode;
+  if (lexer.GetTokenKind() != TK_addrof) {
+    Error("expect addrof but get ");
+    return false;
+  }
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  addrofNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  StIdx stidx;
+  if (!ParseDeclaredSt(stidx)) {
+    return false;
+  }
+  if (stidx.FullIdx() == 0) {
+    Error("expect symbol ParseExprAddroffunc");
+    return false;
+  }
+  if (stidx.IsGlobal()) {
+    MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx());
+    ASSERT(sym != nullptr, "null ptr check");
+    sym->SetHasPotentialAssignment();
+  }
+  addrofNode->SetStIdx(stidx);
+  TokenKind tk = lexer.NextToken();
+  if (IsDelimitationTK(tk)) {
+    addrofNode->SetFieldID(0);
+  } else if (tk == TK_intconst) {
+    addrofNode->SetFieldID(lexer.GetTheIntVal());
+    lexer.NextToken();
+  } else {
+    addrofNode->SetFieldID(0);
+  }
+  return true;
+}
+
+bool MIRParser::ParseExprAddrofoff(BaseNodePtr &expr) {
+  // syntax: addrofoff <prim-type> <var-name> <offset>
+  AddrofoffNode *addrofoffNode = mod.CurFuncCodeMemPool()->New<AddrofoffNode>(OP_addrofoff);
+  expr = addrofoffNode;
+  if (lexer.GetTokenKind() != TK_addrofoff) {
+    Error("expect addrofoff but get ");
+    return false;
+  }
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  addrofoffNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  StIdx stidx;
+  if (!ParseDeclaredSt(stidx)) {
+    return false;
+  }
+  if (stidx.FullIdx() == 0) {
+    Error("expect symbol ParseExprAddroffunc");
+    return false;
+  }
+  if (stidx.IsGlobal()) {
+    MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx());
+    ASSERT(sym != nullptr, "null ptr check");
+    sym->SetHasPotentialAssignment();
+  }
+  addrofoffNode->stIdx = stidx;
+  TokenKind tk = lexer.NextToken();
+  if (tk == TK_intconst) {
+    addrofoffNode->offset = static_cast<int32>(lexer.GetTheIntVal());
+    lexer.NextToken();
+  } else {
+    Error("expect integer offset but get ");
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseExprAddroffunc(BaseNodePtr &expr) {
+  auto *addrOfFuncNode = mod.CurFuncCodeMemPool()->New<AddroffuncNode>();
+  expr = addrOfFuncNode;
+  TokenKind tk = lexer.NextToken();
+  if (tk != TK_a32 && tk != TK_a64 && tk != TK_ptr) {
+    Error("expect address primitive type but get ");
+    return false;
+  }
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    Error("ParseExprAddroffunc failed when parsing primitive type");
+    return false;
+  }
+  addrOfFuncNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  if (lexer.GetTokenKind() != TK_fname) {
+    Error("expect function name but get ");
+    return false;
+  }
+  PUIdx pidx;
+  if (!ParseDeclaredFunc(pidx)) {
+    if (mod.GetFlavor() < kMmpl) {
+      Error("expect .mmpl file");
+      return false;
+    }
+    pidx = EnterUndeclaredFunction();
+  }
+  addrOfFuncNode->SetPUIdx(pidx);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprAddroflabel(BaseNodePtr &expr) {
+  // syntax: addroflabel <prim-type> <label>
+  auto *addrOfLabelNode = mod.CurFuncCodeMemPool()->New<AddroflabelNode>();
+  expr = addrOfLabelNode;
+  TokenKind tk = lexer.NextToken();
+  if (tk != TK_a32 && tk != TK_a64 && tk != TK_ptr) {
+    Error("expect address primitive type but get ");
+    return false;
+  }
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    Error("ParseExprAddroflabel failed");
+    return false;
+  }
+  addrOfLabelNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  if (lexer.GetTokenKind() != TK_label) {
+    Error("expect label but get ");
+    return false;
+  }
+  LabelIdx lblIdx = mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName());
+  addrOfLabelNode->SetOffset(lblIdx);
+  (void)mod.CurFunction()->GetLabelTab()->GetAddrTakenLabels().insert(lblIdx);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprUnary(BaseNodePtr &expr) {
+  // syntax op <prim-type> <label>
+  Opcode op = GetUnaryOp(lexer.GetTokenKind());
+  if (op == OP_undef) {
+    Error("expect unary op but get ");
+    return false;
+  }
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    Error("expect primitive parsing unary operator ");
+    return false;
+  }
+  auto *unaryNode = mod.CurFuncCodeMemPool()->New<UnaryNode>(op);
+  expr = unaryNode;
+  unaryNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  BaseNode *opnd = nullptr;
+  if (!ParseExprOneOperand(opnd)) {
+    Error("parsing unary wrong ");
+    return false;
+  }
+  unaryNode->SetOpnd(opnd, 0);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprGCMalloc(BaseNodePtr &expr) {
+  // syntax op <prim-type> <type>
+  TokenKind tk = lexer.GetTokenKind();
+  if (tk != TK_gcmalloc && tk != TK_gcpermalloc) {
+    Error("expect gcmalloc or gcpermalloc but get ");
+    return false;
+  }
+  Opcode op = (tk == TK_gcmalloc) ? OP_gcmalloc : OP_gcpermalloc;
+  lexer.NextToken();
+  TyIdx ptyidx(0);
+  if (IsPrimitiveType(lexer.GetTokenKind())) {
+    if (!ParsePrimType(ptyidx)) {
+      return false;
+    }
+  }
+  TyIdx tyidx(0);
+  if (!ParseType(tyidx)) {
+    Error("expect type parsing unary operator ");
+    return false;
+  }
+  auto *mallocNode = mod.CurFuncCodeMemPool()->New<GCMallocNode>(op);
+  expr = mallocNode;
+  mallocNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(ptyidx));
+  mallocNode->SetOrigPType(mallocNode->GetPrimType());
+  mallocNode->SetTyIdx(tyidx);
+  return true;
+}
+
+bool MIRParser::ParseExprJarray(BaseNodePtr &expr) {
+  // syntax op <prim-type> <java-array-type> <label>
+  Opcode op = GetUnaryOp(lexer.GetTokenKind());
+  if (op != OP_gcmallocjarray && op != OP_gcpermallocjarray) {
+    Error("expect gcmallocjarray or gcpermallocjarray but get ");
+    return false;
+  }
+  TyIdx ptyidx(0);
+  lexer.NextToken();
+  if (IsPrimitiveType(lexer.GetTokenKind())) {
+    if (!ParsePrimType(ptyidx)) {
+      return false;
+    }
+  }
+  TyIdx tyidx(0);
+  if (!ParseType(tyidx)) {
+    Error("expect primitive parsing unary operator ");
+    return false;
+  }
+  auto *jarrayNode = mod.CurFuncCodeMemPool()->New<JarrayMallocNode>(op);
+  expr = jarrayNode;
+  jarrayNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(ptyidx));
+  jarrayNode->SetTyIdx(tyidx);
+  BaseNode *opnd = nullptr;
+  if (!ParseExprOneOperand(opnd)) {
+    Error("parsing unary wrong ");
+    return false;
+  }
+  jarrayNode->SetOpnd(opnd, 0);
+  lexer.NextToken();
+  return true;
+}
+
+// parse extractbits, sext, zext
+bool MIRParser::ParseExprExtractbits(BaseNodePtr &expr) {
+  // extractbits <int-type> <bOffset> <bSize> (<opnd0>)
+  Opcode op = GetUnaryOp(lexer.GetTokenKind());
+  if (op == OP_undef) {
+    Error("expect unary op but get ");
+    return false;
+  }
+  auto *extrctNode = mod.CurFuncCodeMemPool()->New<ExtractbitsNode>(op);
+  expr = extrctNode;
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    Error("expect int type after extractbits after");
+    return false;
+  }
+  PrimType ptyp = GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx);
+  if (!IsPrimitiveInteger(ptyp)) {
+    Error("sematical error expect int type for extractbits");
+    return false;
+  }
+  extrctNode->SetPrimType(ptyp);
+  if (op == OP_extractbits) {
+    if (lexer.GetTokenKind() != TK_intconst) {
+      Error("expect bOffset but get ");
+      return false;
+    }
+    extrctNode->SetBitsOffset(lexer.GetTheIntVal());
+    lexer.NextToken();
+  }
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect bSize but get ");
+    return false;
+  }
+  extrctNode->SetBitsSize(lexer.GetTheIntVal());
+  lexer.NextToken();
+  BaseNode *opnd = nullptr;
+  if (!ParseExprOneOperand(opnd)) {
+    Error("ParseExprExtractbits failed");
+    return false;
+  }
+  extrctNode->SetOpnd(opnd, 0);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprTyconvert(BaseNodePtr &expr) {
+  Opcode op = GetConvertOp(lexer.GetTokenKind());
+  if (op == OP_undef) {
+    Error("expect covertion operator but get ");
+    return false;
+  }
+  auto *cvtNode = mod.CurFuncCodeMemPool()->New<TypeCvtNode>(op);
+  expr = static_cast<BaseNode*>(cvtNode);
+  PrimType toType = GetPrimitiveType(lexer.NextToken());
+  if (toType == kPtyInvalid) {
+    Error("expect to-type parsing conversion");
+    return false;
+  }
+  cvtNode->SetPrimType(toType);
+  lexer.NextToken();
+  PrimType fromType = GetPrimitiveType(lexer.GetTokenKind());
+  if (fromType == kPtyInvalid) {
+    Error("expect type parsing conversion ");
+    return false;
+  }
+  cvtNode->SetFromType(fromType);
+  lexer.NextToken();
+  BaseNode *opnd = nullptr;
+  if (!ParseExprOneOperand(opnd)) {
+    return false;
+  }
+  cvtNode->SetOpnd(opnd, 0);
+  if (op == OP_retype) {
+    cvtNode->SetFromType(opnd->GetPrimType());
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprRetype(BaseNodePtr &expr) {
+  auto *cvtNode = mod.CurFuncCodeMemPool()->New<RetypeNode>();
+  expr = static_cast<BaseNode*>(cvtNode);
+  PrimType toType = GetPrimitiveType(lexer.NextToken());
+  if (toType == kPtyInvalid) {
+    Error("expect to-type parsing conversion");
+    return false;
+  }
+  cvtNode->SetPrimType(toType);
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  if (!ParseDerivedType(tyidx)) {
+    Error("ParseExprRetype failed when parsing derived type ");
+    return false;
+  }
+  cvtNode->SetTyIdx(tyidx);
+  BaseNode *opnd = nullptr;
+  if (!ParseExprOneOperand(opnd)) {
+    return false;
+  }
+  cvtNode->SetOpnd(opnd, 0);
+  cvtNode->SetFromType(opnd->GetPrimType());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprTernary(BaseNodePtr &expr) {
+  if (lexer.GetTokenKind() != TK_select) {
+    Error("expect select but get ");
+    return false;
+  }
+  TernaryNode *ternaryNode = mod.CurFuncCodeMemPool()->New<TernaryNode>(OP_select);
+  expr = ternaryNode;
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  if (!ParsePrimType(tyidx)) {
+    Error("expect primtype type but get ");
+    return false;
+  }
+  ternaryNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
+  MapleVector<BaseNode*> opndVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+  if (!ParseExprNaryOperand(opndVec)) {
+    Error("ParseExprTernary failed");
+    return false;
+  }
+  if (opndVec.size() != 3) {  // expect number of operands to be 3
+    Error("expect 3 operands for ternary operator ");
+    return false;
+  }
+  ternaryNode->SetOpnd(opndVec[0], 0);
+  ternaryNode->SetOpnd(opndVec[1], 1);
+  ternaryNode->SetOpnd(opndVec[2], 2);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseExprArray(BaseNodePtr &expr) {
+  // syntax: array <addr-type> <array-type> (<opnd0>, <opnd1>, . . . , <opndn>)
+  auto *arrayNode = mod.CurFuncCodeMemPool()->New<ArrayNode>(mod);
+  expr = arrayNode;
+  if (lexer.GetTokenKind() != TK_array) {
+    Error("expect array but get ");
+    return false;
+  }
+  lexer.NextToken();
+  if (lexer.GetTokenKind() == TK_intconst) {
+    if (lexer.GetTheIntVal() == 1) {
+      arrayNode->SetBoundsCheck(true);
+    } else if (lexer.GetTheIntVal() == 0) {
+      arrayNode->SetBoundsCheck(false);
+    } else {
+      Error("expect bounds_check(0/1) but get ");
+      return false;
+    }
+  }
+  lexer.NextToken();
+  TyIdx tyidx;
+  if (!ParsePrimType(tyidx)) {
+    Error("expect address type but get ");
+    return false;
+  }
+  auto arrayPtyp = GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx);
+  arrayPtyp = arrayPtyp == PTY_ptr ? GetExactPtrPrimType() : arrayPtyp;
+  arrayNode->SetPrimType(arrayPtyp);
+  tyidx = TyIdx(0);
+  if (!ParseType(tyidx)) {
+    Error("expect type parsing array but get ");
+    return false;
+  }
+  arrayNode->SetTyIdx(tyidx);
+  // number of operand can not be zero
+  MapleVector<BaseNode*> opndVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+  if (!ParseExprNaryOperand(opndVec)) {
+    Error("ParseExprArray failed");
+    return false;
+  }
+  if (opndVec.empty()) {
+    Error("sematic error operands number of array expression is 0 ");
+    return false;
+  }
+  arrayNode->SetNOpnd(opndVec);
+  arrayNode->SetNumOpnds(opndVec.size());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseIntrinsicId(IntrinsicopNode &intrnOpNode) {
+  MIRIntrinsicID intrinId = GetIntrinsicID(lexer.GetTokenKind());
+  if (intrinId <= INTRN_UNDEFINED || intrinId >= INTRN_LAST) {
+    Error("wrong intrinsic id ");
+    return false;
+  }
+  intrnOpNode.SetIntrinsic(intrinId);
+  return true;
+}
+
+bool MIRParser::ParseExprIntrinsicop(BaseNodePtr &expr) {
+  // syntax: intrinsicop <prim-type> <intrinsic> (<opnd0>, ..., <opndn>)
+  // syntax: intrinsicopwithtype <prim-type> <intrinsic> (<opnd0>, ..., <opndn>)
+  Opcode opCode = OP_intrinsicopwithtype;
+  TokenKind kind = lexer.GetTokenKind();
+  if (kind == TK_intrinsicop) {
+    opCode = OP_intrinsicop;
+  } else if (kind != TK_intrinsicopwithtype) {
+    Error("expect intrinsicop(withtype) but get ");
+    return false;
+  }
+  lexer.NextToken();
+  TyIdx pTyIdx(0);
+  if (!ParsePrimType(pTyIdx)) {
+    Error("ParseExprIntrinsicop(withtype) failed when parsing type");
+    return false;
+  }
+
+  TyIdx tyIdx(0);
+  if (opCode == OP_intrinsicopwithtype && !ParseDerivedType(tyIdx)) {
+    Error("ParseExprIntrinsicop(withtype) failed when parsing derived type ");
+    return false;
+  }
+  auto *intrnOpNode = mod.CurFuncCodeMemPool()->New<IntrinsicopNode>(
+      mod, opCode, GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(pTyIdx), tyIdx);
+  expr = intrnOpNode;
+  if (!ParseIntrinsicId(*intrnOpNode)) {
+    return false;
+  }
+  // number of operand can not be zero
+  lexer.NextToken();
+  MapleVector<BaseNode*> opndVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
+  if (!ParseExprNaryOperand(opndVec)) {
+    Error("ParseExprIntrinsicop(withtype) failed");
+    return false;
+  }
+  intrnOpNode->SetNOpnd(opndVec);
+  intrnOpNode->SetNumOpnds(opndVec.size());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseScalarValue(MIRConstPtr &stype, MIRType &type) {
+  PrimType ptp = type.GetPrimType();
+  if (IsPrimitiveInteger(ptp) || IsPrimitiveDynType(ptp) || ptp == PTY_gen) {
+    if (lexer.GetTokenKind() != TK_intconst) {
+      Error("constant value incompatible with integer type at ");
+      return false;
+    }
+    stype = GlobalTables::GetIntConstTable().GetOrCreateIntConst(lexer.GetTheIntVal(), type);
+  } else if (ptp == PTY_f32) {
+    if (lexer.GetTokenKind() != TK_floatconst) {
+      Error("constant value incompatible with single-precision float type at ");
+      return false;
+    }
+    MIRFloatConst *fConst = GlobalTables::GetFpConstTable().GetOrCreateFloatConst(lexer.GetTheFloatVal());
+    stype = fConst;
+  } else if (ptp == PTY_f64) {
+    if (lexer.GetTokenKind() != TK_doubleconst && lexer.GetTokenKind() != TK_intconst) {
+      Error("constant value incompatible with double-precision float type at ");
+      return false;
+    }
+    MIRDoubleConst *dconst = GlobalTables::GetFpConstTable().GetOrCreateDoubleConst(lexer.GetTheDoubleVal());
+    stype = dconst;
+  } else {
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseConstAddrLeafExpr(MIRConstPtr &cexpr) {
+  BaseNode *expr = nullptr;
+  if (!ParseExpression(expr)) {
+    return false;
+  }
+  CHECK_FATAL(expr != nullptr, "null ptr check");
+  if (expr->GetOpCode() != OP_addrof && expr->GetOpCode() != OP_addroffunc && expr->GetOpCode() != OP_addroflabel &&
+      expr->GetOpCode() != OP_conststr && expr->GetOpCode() != OP_conststr16) {
+    Error("ParseConstAddrLeafExpr expects one of OP_addrof, OP_addroffunc, OP_conststr and OP_conststr16");
+    return false;
+  }
+  if (expr->GetOpCode() == OP_addrof) {
+    auto *anode = static_cast<AddrofNode*>(expr);
+    auto *currFn = static_cast<MIRFunction*>(mod.CurFunction());
+    MIRSymbol *var = currFn->GetLocalOrGlobalSymbol(anode->GetStIdx());
+    ASSERT(var != nullptr, "null ptr check");
+    var->SetNeedForwDecl();
+    mod.SetSomeSymbolNeedForDecl(true);
+    TyIdx ptyIdx = var->GetTyIdx();
+    MIRPtrType ptrType(ptyIdx, (mod.IsJavaModule() ? PTY_ref : GetExactPtrPrimType()));
+    ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+    MIRType *exprTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
+    uint32 ofst = 0;
+    if (lexer.GetTokenKind() == TK_lparen) {
+      lexer.NextToken();
+      if (lexer.GetTokenKind() != TK_intconst) {
+        Error("ParseConstAddrLeafExpr: wrong offset specification for addrof");
+        return false;
+      } else {
+        ofst = static_cast<uint32>(lexer.GetTheIntVal());
+      }
+      lexer.NextToken();
+      if (lexer.GetTokenKind() != TK_rparen) {
+        Error("ParseConstAddrLeafExpr expects closing paren after offset value for addrof");
+        return false;
+      }
+      lexer.NextToken();
+    }
+    cexpr = mod.CurFunction()->GetDataMemPool()->New<MIRAddrofConst>(
+        anode->GetStIdx(), anode->GetFieldID(), *exprTy, ofst);
+  } else if (expr->GetOpCode() == OP_addroffunc) {
+    auto *aof = static_cast<AddroffuncNode*>(expr);
+    CHECK_NULL_FATAL(aof);
+    MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(aof->GetPUIdx());
+    CHECK_NULL_FATAL(f);
+    MIRSymbol *fName = f->GetFuncSymbol();
+    CHECK_NULL_FATAL(fName);
+    fName->SetAppearsInCode(true);
+    TyIdx ptyIdx = fName->GetTyIdx();
+    MIRPtrType ptrType(ptyIdx);
+    ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+    MIRType *exprTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
+    cexpr = mod.CurFunction()->GetDataMemPool()->New<MIRAddroffuncConst>(aof->GetPUIdx(), *exprTy);
+  } else if (expr->op == OP_addroflabel) {
+    AddroflabelNode *aol = static_cast<AddroflabelNode *>(expr);
+    MIRType *mirtype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(GetExactPtrPrimType()));
+    // func code mempool will be released after irmap, but MIRLblConst won't be passed to me ir.
+    // So MIRLblConst can NOT be allocated in func code mempool.
+    cexpr = mod.CurFunction()->GetDataMemPool()->New<MIRLblConst>(
+        aol->GetOffset(), mod.CurFunction()->GetPuidx(), *mirtype);
+  } else if (expr->GetOpCode() == OP_conststr) {
+    auto *cs = static_cast<ConststrNode*>(expr);
+    UStrIdx stridx = cs->GetStrIdx();
+    TyIdx ptyIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_u8))->GetTypeIndex();
+    MIRPtrType ptrtype(ptyIdx);
+    ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrtype);
+    MIRType *exprty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
+    // func code mempool will be released after irmap, but MIRStrConst won't be passed to me ir.
+    // So MIRStrConst can NOT be allocated in func code mempool.
+    cexpr = mod.CurFunction()->GetDataMemPool()->New<MIRStrConst>(stridx, *exprty);
+  } else {
+    auto *cs = static_cast<Conststr16Node*>(expr);
+    U16StrIdx stridx = cs->GetStrIdx();
+    TyIdx ptyIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_u16))->GetTypeIndex();
+    MIRPtrType ptrType(ptyIdx);
+    ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+    MIRType *exprTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
+    // func code mempool will be released after irmap, but MIRStr16Const won't be passed to me ir.
+    // So MIRStr16Const can NOT be allocated in func code mempool.
+    cexpr = mod.CurFunction()->GetDataMemPool()->New<MIRStr16Const>(stridx, *exprTy);
+  }
+  return true;
+}
+
+bool MIRParser::ParseExpression(BaseNodePtr &expr) {
+  TokenKind tk = lexer.GetTokenKind();
+  std::map<TokenKind, MIRParser::FuncPtrParseExpr>::iterator itFuncPtr = funcPtrMapForParseExpr.find(tk);
+  if (itFuncPtr == funcPtrMapForParseExpr.end()) {
+    Error("expect expression but get ");
+    return false;
+  } else {
+    if (!(this->*(itFuncPtr->second))(expr)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+std::map<TokenKind, MIRParser::FuncPtrParseExpr> MIRParser::InitFuncPtrMapForParseExpr() {
+  std::map<TokenKind, MIRParser::FuncPtrParseExpr> funcPtrMap;
+  funcPtrMap[TK_addrof] = &MIRParser::ParseExprAddrof;
+  funcPtrMap[TK_addrofoff] = &MIRParser::ParseExprAddrofoff;
+  funcPtrMap[TK_addroffunc] = &MIRParser::ParseExprAddroffunc;
+  funcPtrMap[TK_addroflabel] = &MIRParser::ParseExprAddroflabel;
+  funcPtrMap[TK_abs] = &MIRParser::ParseExprUnary;
+  funcPtrMap[TK_bnot] = &MIRParser::ParseExprUnary;
+  funcPtrMap[TK_lnot] = &MIRParser::ParseExprUnary;
+  funcPtrMap[TK_neg] = &MIRParser::ParseExprUnary;
+  funcPtrMap[TK_recip] = &MIRParser::ParseExprUnary;
+  funcPtrMap[TK_sqrt] = &MIRParser::ParseExprUnary;
+  funcPtrMap[TK_alloca] = &MIRParser::ParseExprUnary;
+  funcPtrMap[TK_malloc] = &MIRParser::ParseExprUnary;
+  funcPtrMap[TK_gcmalloc] = &MIRParser::ParseExprGCMalloc;
+  funcPtrMap[TK_gcpermalloc] = &MIRParser::ParseExprGCMalloc;
+  funcPtrMap[TK_gcmallocjarray] = &MIRParser::ParseExprJarray;
+  funcPtrMap[TK_gcpermallocjarray] = &MIRParser::ParseExprJarray;
+  funcPtrMap[TK_sext] = &MIRParser::ParseExprExtractbits;
+  funcPtrMap[TK_zext] = &MIRParser::ParseExprExtractbits;
+  funcPtrMap[TK_extractbits] = &MIRParser::ParseExprExtractbits;
+  funcPtrMap[TK_ceil] = &MIRParser::ParseExprTyconvert;
+  funcPtrMap[TK_cvt] = &MIRParser::ParseExprTyconvert;
+  funcPtrMap[TK_floor] = &MIRParser::ParseExprTyconvert;
+  funcPtrMap[TK_round] = &MIRParser::ParseExprTyconvert;
+  funcPtrMap[TK_trunc] = &MIRParser::ParseExprTyconvert;
+  funcPtrMap[TK_retype] = &MIRParser::ParseExprRetype;
+  funcPtrMap[TK_select] = &MIRParser::ParseExprTernary;
+  funcPtrMap[TK_array] = &MIRParser::ParseExprArray;
+  funcPtrMap[TK_intrinsicop] = &MIRParser::ParseExprIntrinsicop;
+  funcPtrMap[TK_intrinsicopwithtype] = &MIRParser::ParseExprIntrinsicop;
+  funcPtrMap[TK_constval] = &MIRParser::ParseExprConstval;
+  funcPtrMap[TK_conststr] = &MIRParser::ParseExprConststr;
+  funcPtrMap[TK_conststr16] = &MIRParser::ParseExprConststr16;
+  funcPtrMap[TK_sizeoftype] = &MIRParser::ParseExprSizeoftype;
+  funcPtrMap[TK_fieldsdist] = &MIRParser::ParseExprFieldsDist;
+  funcPtrMap[TK_iaddrof] = &MIRParser::ParseExprIaddrof;
+  funcPtrMap[TK_iread] = &MIRParser::ParseExprIread;
+  funcPtrMap[TK_ireadoff] = &MIRParser::ParseExprIreadoff;
+  funcPtrMap[TK_ireadfpoff] = &MIRParser::ParseExprIreadFPoff;
+  funcPtrMap[TK_dread] = &MIRParser::ParseExprDread;
+  funcPtrMap[TK_dreadoff] = &MIRParser::ParseExprDreadoff;
+  funcPtrMap[TK_regread] = &MIRParser::ParseExprRegread;
+  funcPtrMap[TK_add] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_ashr] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_band] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_bior] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_bxor] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_cand] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_cior] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_div] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_land] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_lior] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_lshr] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_max] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_min] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_mul] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_rem] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_shl] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_ror] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_sub] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_CG_array_elem_add] = &MIRParser::ParseExprBinary;
+  funcPtrMap[TK_cmp] = &MIRParser::ParseExprCompare;
+  funcPtrMap[TK_cmpl] = &MIRParser::ParseExprCompare;
+  funcPtrMap[TK_cmpg] = &MIRParser::ParseExprCompare;
+  funcPtrMap[TK_eq] = &MIRParser::ParseExprCompare;
+  funcPtrMap[TK_ge] = &MIRParser::ParseExprCompare;
+  funcPtrMap[TK_gt] = &MIRParser::ParseExprCompare;
+  funcPtrMap[TK_le] = &MIRParser::ParseExprCompare;
+  funcPtrMap[TK_lt] = &MIRParser::ParseExprCompare;
+  funcPtrMap[TK_ne] = &MIRParser::ParseExprCompare;
+  funcPtrMap[TK_depositbits] = &MIRParser::ParseExprDepositbits;
+  return funcPtrMap;
+}
+
+std::map<TokenKind, MIRParser::FuncPtrParseStmt> MIRParser::InitFuncPtrMapForParseStmt() {
+  std::map<TokenKind, MIRParser::FuncPtrParseStmt> funcPtrMap;
+  funcPtrMap[TK_dassign] = &MIRParser::ParseStmtDassign;
+  funcPtrMap[TK_dassignoff] = &MIRParser::ParseStmtDassignoff;
+  funcPtrMap[TK_iassign] = &MIRParser::ParseStmtIassign;
+  funcPtrMap[TK_iassignoff] = &MIRParser::ParseStmtIassignoff;
+  funcPtrMap[TK_iassignfpoff] = &MIRParser::ParseStmtIassignFPoff;
+  funcPtrMap[TK_iassignspoff] = &MIRParser::ParseStmtIassignFPoff;
+  funcPtrMap[TK_blkassignoff] = &MIRParser::ParseStmtBlkassignoff;
+  funcPtrMap[TK_regassign] = &MIRParser::ParseStmtRegassign;
+  funcPtrMap[TK_doloop] = &MIRParser::ParseStmtDoloop;
+  funcPtrMap[TK_foreachelem] = &MIRParser::ParseStmtForeachelem;
+  funcPtrMap[TK_dowhile] = &MIRParser::ParseStmtDowhile;
+  funcPtrMap[TK_if] = &MIRParser::ParseStmtIf;
+  funcPtrMap[TK_while] = &MIRParser::ParseStmtWhile;
+  funcPtrMap[TK_goto] = &MIRParser::ParseStmtGoto;
+  funcPtrMap[TK_brfalse] = &MIRParser::ParseStmtBr;
+  funcPtrMap[TK_brtrue] = &MIRParser::ParseStmtBr;
+  funcPtrMap[TK_switch] = &MIRParser::ParseStmtSwitch;
+  funcPtrMap[TK_rangegoto] = &MIRParser::ParseStmtRangegoto;
+  funcPtrMap[TK_multiway] = &MIRParser::ParseStmtMultiway;
+  funcPtrMap[TK_call] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_virtualcall] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_virtualicall] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_superclasscall] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_interfacecall] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_interfaceicall] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_customcall] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_polymorphiccall] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_callinstant] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_virtualcallinstant] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_superclasscallinstant] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_interfacecallinstant] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_callassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_virtualcallassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_virtualicallassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_superclasscallassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_interfacecallassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_interfaceicallassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_customcallassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_polymorphiccallassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_callinstantassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_virtualcallinstantassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_superclasscallinstantassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_interfacecallinstantassigned] = &MIRParser::ParseStmtCall;
+  funcPtrMap[TK_icall] = &MIRParser::ParseStmtIcall;
+  funcPtrMap[TK_icallassigned] = &MIRParser::ParseStmtIcallassigned;
+  funcPtrMap[TK_icallproto] = &MIRParser::ParseStmtIcallproto;
+  funcPtrMap[TK_icallprotoassigned] = &MIRParser::ParseStmtIcallprotoassigned;
+  funcPtrMap[TK_intrinsiccall] = &MIRParser::ParseStmtIntrinsiccall;
+  funcPtrMap[TK_intrinsiccallassigned] = &MIRParser::ParseStmtIntrinsiccallassigned;
+  funcPtrMap[TK_xintrinsiccall] = &MIRParser::ParseStmtIntrinsiccall;
+  funcPtrMap[TK_xintrinsiccallassigned] = &MIRParser::ParseStmtIntrinsiccallassigned;
+  funcPtrMap[TK_intrinsiccallwithtype] = &MIRParser::ParseStmtIntrinsiccallwithtype;
+  funcPtrMap[TK_intrinsiccallwithtypeassigned] = &MIRParser::ParseStmtIntrinsiccallwithtypeassigned;
+  funcPtrMap[TK_return] = &MIRParser::ParseNaryStmtReturn;
+  funcPtrMap[TK_jstry] = &MIRParser::ParseStmtJsTry;
+  funcPtrMap[TK_try] = &MIRParser::ParseStmtTry;
+  funcPtrMap[TK_catch] = &MIRParser::ParseStmtCatch;
+  funcPtrMap[TK_syncenter] = &MIRParser::ParseNaryStmtSyncEnter;
+  funcPtrMap[TK_syncexit] = &MIRParser::ParseNaryStmtSyncExit;
+  funcPtrMap[TK_throw] = &MIRParser::ParseUnaryStmtThrow;
+  funcPtrMap[TK_decref] = &MIRParser::ParseUnaryStmtDecRef;
+  funcPtrMap[TK_incref] = &MIRParser::ParseUnaryStmtIncRef;
+  funcPtrMap[TK_decrefreset] = &MIRParser::ParseUnaryStmtDecRefReset;
+  funcPtrMap[TK_igoto] = &MIRParser::ParseUnaryStmtIGoto;
+  funcPtrMap[TK_jscatch] = &MIRParser::ParseStmtMarker;
+  funcPtrMap[TK_finally] = &MIRParser::ParseStmtMarker;
+  funcPtrMap[TK_cleanuptry] = &MIRParser::ParseStmtMarker;
+  funcPtrMap[TK_endtry] = &MIRParser::ParseStmtMarker;
+  funcPtrMap[TK_retsub] = &MIRParser::ParseStmtMarker;
+  funcPtrMap[TK_membaracquire] = &MIRParser::ParseStmtMarker;
+  funcPtrMap[TK_membarrelease] = &MIRParser::ParseStmtMarker;
+  funcPtrMap[TK_membarstoreload] = &MIRParser::ParseStmtMarker;
+  funcPtrMap[TK_membarstorestore] = &MIRParser::ParseStmtMarker;
+  funcPtrMap[TK_gosub] = &MIRParser::ParseStmtGosub;
+  funcPtrMap[TK_eval] = &MIRParser::ParseUnaryStmtEval;
+  funcPtrMap[TK_free] = &MIRParser::ParseUnaryStmtFree;
+  funcPtrMap[TK_assertnonnull] = &MIRParser::ParseUnaryStmtAssertNonNull;
+  funcPtrMap[TK_callassertnonnull] = &MIRParser::ParseUnaryStmtCallAssertNonNull;
+  funcPtrMap[TK_assignassertnonnull] = &MIRParser::ParseUnaryStmtAssignAssertNonNull;
+  funcPtrMap[TK_returnassertnonnull] = &MIRParser::ParseUnaryStmtReturnAssertNonNull;
+  funcPtrMap[TK_assertge] = &MIRParser::ParseNaryStmtAssertGE;
+  funcPtrMap[TK_assertlt] = &MIRParser::ParseNaryStmtAssertLT;
+  funcPtrMap[TK_calcassertge] = &MIRParser::ParseNaryStmtCalcassertGE;
+  funcPtrMap[TK_calcassertlt] = &MIRParser::ParseNaryStmtCalcassertLT;
+  funcPtrMap[TK_returnassertle] = &MIRParser::ParseNaryStmtReturnAssertLE;
+  funcPtrMap[TK_callassertle] = &MIRParser::ParseNaryStmtCallAssertLE;
+  funcPtrMap[TK_assignassertle] = &MIRParser::ParseNaryStmtAssignAssertLE;
+  funcPtrMap[TK_label] = &MIRParser::ParseStmtLabel;
+  funcPtrMap[TK_LOC] = &MIRParser::ParseLocStmt;
+  funcPtrMap[TK_ALIAS] = &MIRParser::ParseAliasStmt;
+  funcPtrMap[TK_SCOPE] = &MIRParser::ParseScopeStmt;
+  funcPtrMap[TK_asm] = &MIRParser::ParseStmtAsm;
+  funcPtrMap[TK_safe] = &MIRParser::ParseStmtSafeRegion;
+  funcPtrMap[TK_endsafe] = &MIRParser::ParseStmtSafeRegion;
+  funcPtrMap[TK_unsafe] = &MIRParser::ParseStmtSafeRegion;
+  funcPtrMap[TK_endunsafe] = &MIRParser::ParseStmtSafeRegion;
+  return funcPtrMap;
+}
+
+std::map<TokenKind, MIRParser::FuncPtrParseStmtBlock> MIRParser::InitFuncPtrMapForParseStmtBlock() {
+  std::map<TokenKind, MIRParser::FuncPtrParseStmtBlock> funcPtrMap;
+  funcPtrMap[TK_var] = &MIRParser::ParseStmtBlockForVar;
+  funcPtrMap[TK_tempvar] = &MIRParser::ParseStmtBlockForTempVar;
+  funcPtrMap[TK_reg] = &MIRParser::ParseStmtBlockForReg;
+  funcPtrMap[TK_type] = &MIRParser::ParseStmtBlockForType;
+  funcPtrMap[TK_framesize] = &MIRParser::ParseStmtBlockForFrameSize;
+  funcPtrMap[TK_upformalsize] = &MIRParser::ParseStmtBlockForUpformalSize;
+  funcPtrMap[TK_moduleid] = &MIRParser::ParseStmtBlockForModuleID;
+  funcPtrMap[TK_funcsize] = &MIRParser::ParseStmtBlockForFuncSize;
+  funcPtrMap[TK_funcid] = &MIRParser::ParseStmtBlockForFuncID;
+  funcPtrMap[TK_formalwordstypetagged] = &MIRParser::ParseStmtBlockForFormalWordsTypeTagged;
+  funcPtrMap[TK_localwordstypetagged] = &MIRParser::ParseStmtBlockForLocalWordsTypeTagged;
+  funcPtrMap[TK_formalwordsrefcounted] = &MIRParser::ParseStmtBlockForFormalWordsRefCounted;
+  funcPtrMap[TK_localwordsrefcounted] = &MIRParser::ParseStmtBlockForLocalWordsRefCounted;
+  funcPtrMap[TK_funcinfo] = &MIRParser::ParseStmtBlockForFuncInfo;
+  return funcPtrMap;
+}
+
+void MIRParser::SetSrcPos(SrcPosition &srcPosition, uint32 mplNum) const {
+  srcPosition.SetFileNum(lastFileNum);
+  srcPosition.SetLineNum(lastLineNum);
+  srcPosition.SetColumn(lastColumnNum);
+  srcPosition.SetMplLineNum(mplNum);
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_pragma.cpp b/src/mapleall/maple_ir/src/mir_pragma.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ce2678dcb9ea58b8a0c171d40dc5c51f496040fd
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_pragma.cpp
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_pragma.h"
+#include "mir_nodes.h"
+#include "mir_function.h"
+#include "printing.h"
+#include "maple_string.h"
+
+namespace  {
+enum Status {
+  kStop = 0,
+  kStartWithSubvec = 1,
+  kNormalTypeStrEndWithSemicolon = 2,
+  kNormalTypeStrEndWithSubvecNeedsSemicolon = 3,
+  kEndWithSubvec = 4,
+  kIgnoreAndContinue = 5
+};
+}
+
+namespace maple {
+static std::string GetKind(PragmaValueType kind) {
+  switch (kind) {
+    case kValueByte:
+      return "i8";
+    case kValueShort:
+      return "i16";
+    case kValueChar:
+      return "u16";
+    case kValueInt:
+      return "i32";
+    case kValueLong:
+      return "i64";
+    case kValueFloat:
+      return "f32";
+    case kValueDouble:
+      return "f64";
+    case kValueMethodType:
+      return "retype";
+    case kValueMethodHandle:
+      return "ref";
+    case kValueString:
+      return "ptr";
+    case kValueType:
+      return "type";
+    case kValueField:
+      return "var";
+    case kValueMethod:
+      return "func";
+    case kValueEnum:
+      return "enum";
+    case kValueArray:
+      return "array";
+    case kValueAnnotation:
+      return "annotation";
+    case kValueNull:
+      return "const";
+    case kValueBoolean:
+      return "u1";
+    default:
+      return "unknown";
+  }
+}
+
+// status: 0 : unexpected char, stop
+//         1 : < start subvec
+//         2 : normal type str end with ';'
+//         3 : normal type str end with '<' -- need append ';'
+//         4 : > end subvec
+//         5 : ; ignore and continue
+//  2: Lfoofoofoofoo;xx  3: Lfoofoofoofoo<
+//     |             |      |            |
+//     start         end    start        end
+static void GetTypeStr(const std::string &str, uint32 &start, uint32 &end, uint32 &status) {
+  uint32 i = start;
+  status = kStop;
+  while (str[i] == '[') {
+    ++i;
+  }
+  start = i;
+  end = i;
+  switch (str[i]) {
+    case 'Z':
+    case 'B':
+    case 'S':
+    case 'C':
+    case 'I':
+    case 'J':
+    case 'F':
+    case 'D':
+    case 'V':
+      status = kNormalTypeStrEndWithSemicolon;
+      end = i + 1;
+      break;
+    case 'L':
+    case 'T':
+      // Lfoo; or Lfoo<...>;
+      while (i < str.length()) {
+        if (str[i] == ';') {
+          status = kNormalTypeStrEndWithSemicolon;
+          end = i + 1;
+          break;
+        } else if (str[i] == '<') {
+          status = kNormalTypeStrEndWithSubvecNeedsSemicolon;
+          end = i;
+          break;
+        } else {
+          ++i;
+        }
+      }
+      break;
+    case '<':
+      status = kStartWithSubvec;
+      end = i + 1;
+      break;
+    case '>':
+      status = kEndWithSubvec;
+      end = i + 1;
+      break;
+    case ';':
+      // continue cases
+      status = kIgnoreAndContinue;
+      end = i + 1;
+      break;
+    default:
+      // termination - reached unexpected char
+      end = i;
+      break;
+  }
+}
+
+MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signature) {
+  if (signature.empty()) {
+    return nullptr;
+  }
+  std::stack<MIRPragmaElement*> elemStack;
+  MIRPragmaElement *elem = mod->GetMemPool()->New<MIRPragmaElement>(*mod);
+  elem->SetType(kValueArray);
+  elemStack.push(elem);
+  uint32 status = 0;
+  uint32 start = 0;
+  uint32 end = 0;
+  while (1) {
+    if (signature.size() <= start) {
+      break;
+    }
+    GetTypeStr(signature, start, end, status);
+    // status: 0:stop/1:start_subvec/2:normal/3:normal+';'/4:end_subvec/5:ignore_and_continue
+    switch (status) {
+      case kStop:
+        return elem;
+      case kStartWithSubvec: {
+        MIRPragmaElement *etmp = mod->GetMemPool()->New<MIRPragmaElement>(*mod);
+        etmp->SetType(kValueArray);
+        elemStack.top()->SubElemVecPushBack(etmp);
+        elemStack.push(etmp);
+        break;
+      }
+      case kNormalTypeStrEndWithSemicolon: {
+        MIRPragmaElement *etmp = mod->GetMemPool()->New<MIRPragmaElement>(*mod);
+        etmp->SetType(kValueType);
+        std::string typeStr = signature.substr(start, end - start);
+        etmp->SetU64Val(static_cast<uint64>(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr)));
+        elemStack.top()->SubElemVecPushBack(etmp);
+        break;
+      }
+      case kNormalTypeStrEndWithSubvecNeedsSemicolon: {
+        MIRPragmaElement *etmp = mod->GetMemPool()->New<MIRPragmaElement>(*mod);
+        etmp->SetType(kValueType);
+        std::string typeStr = signature.substr(start, end - start) + ";";
+        etmp->SetU64Val(static_cast<uint64>(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr)));
+        elemStack.top()->SubElemVecPushBack(etmp);
+        break;
+      }
+      case kEndWithSubvec:
+        if (elemStack.empty()) {  // Invalid annotation signature format
+          return nullptr;
+        }
+        elemStack.pop();
+        break;
+      case kIgnoreAndContinue:
+        break;
+      default:
+        ASSERT(false, "unexpected status");
+        break;
+    }
+    start = end;
+  }
+  return elem;
+}
+
+void MIRPragmaElement::Dump(int indent) const {
+  constexpr int indentOffset = 2;
+  constexpr int floatPrec = 7;
+  constexpr int doublePrec = 16;
+  GStrIdx gStrIdx;
+  std::string str = GetKind(valueType);
+  switch (valueType) {
+    case kValueByte:
+      LogInfo::MapleLogger() << str << " " << val.i;
+      break;
+    case kValueShort:
+      LogInfo::MapleLogger() << str << " " << val.i;
+      break;
+    case kValueChar:
+      LogInfo::MapleLogger() << str << " " << val.u;
+      break;
+    case kValueInt:
+      LogInfo::MapleLogger() << str << " " << val.i;
+      break;
+    case kValueLong:
+      LogInfo::MapleLogger() << str << " " << val.j;
+      break;
+    case kValueFloat:
+      LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str << " "
+                             << std::setprecision(floatPrec) << val.f << "f";
+      break;
+    case kValueDouble:
+      LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str << " "
+                             << std::setprecision(doublePrec) << val.d;
+      break;
+    case kValueMethodType:
+      LogInfo::MapleLogger() << str << " $" << std::hex << "0x" << val.u << std::dec;
+      break;
+    case kValueMethodHandle:
+      LogInfo::MapleLogger() << str << " " << std::hex << "0x" << val.u << std::dec;
+      break;
+    case kValueString:
+      gStrIdx.reset(val.u);
+      LogInfo::MapleLogger() << str << " \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx)
+                             << "\"";
+      break;
+    case kValueType:
+      gStrIdx.reset(val.u);
+      LogInfo::MapleLogger() << str << " <$" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx)
+                             << ">";
+      break;
+    case kValueField:
+      gStrIdx.reset(val.u);
+      LogInfo::MapleLogger() << str << " @" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx);
+      break;
+    case kValueMethod:
+      gStrIdx.reset(val.u);
+      LogInfo::MapleLogger() << str << " &" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx);
+      break;
+    case kValueEnum:
+      gStrIdx.reset(val.u);
+      LogInfo::MapleLogger() << str << " " << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx);
+      break;
+    case kValueArray: {
+      size_t num = subElemVec.size();
+      LogInfo::MapleLogger() << "array [" << num;
+      if (num != 0) {
+        if (num > 1) {
+          LogInfo::MapleLogger() << ",\n";
+        } else {
+          LogInfo::MapleLogger() << ", ";
+        }
+        size_t i = 0;
+        while (i < num) {
+          if (num > 1) {
+            PrintIndentation(indent + indentOffset);
+          }
+          subElemVec[i]->Dump(indent + indentOffset);
+          if (i != num - 1) {
+            LogInfo::MapleLogger() << ",\n";
+          }
+          ++i;
+        }
+      }
+      LogInfo::MapleLogger() << "]";
+      break;
+    }
+    case kValueAnnotation: {
+      size_t num = subElemVec.size();
+      LogInfo::MapleLogger() << "annotation <$";
+      LogInfo::MapleLogger() << GlobalTables::GetStrTable().GetStringFromStrIdx(typeStrIdx) << "> [" << num;
+      if (num != 0) {
+        if (num > 1) {
+          LogInfo::MapleLogger() << ",\n";
+        } else {
+          LogInfo::MapleLogger() << ", ";
+        }
+        size_t i = 0;
+        while (i < num) {
+          if (num > 1) {
+            PrintIndentation(indent + indentOffset);
+          }
+          LogInfo::MapleLogger() << "@"
+                                 << GlobalTables::GetStrTable().GetStringFromStrIdx(subElemVec[i]->nameStrIdx)
+                                 << " ";
+          subElemVec[i]->Dump(indent + indentOffset);
+          if (i != num - 1) {
+            LogInfo::MapleLogger() << ",\n";
+          }
+          ++i;
+        }
+      }
+      LogInfo::MapleLogger() << "]";
+      break;
+    }
+    case kValueNull:
+      LogInfo::MapleLogger() << str << " nullptr";
+      break;
+    case kValueBoolean:
+      LogInfo::MapleLogger() << str << " " << val.u;
+      break;
+  }
+}
+
+void MIRPragma::Dump(int indent) const {
+  LogInfo::MapleLogger() << '\n';
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "pragma " << static_cast<int>(visibility) << " ";
+  switch (pragmaKind) {
+    case kPragmaClass:
+      LogInfo::MapleLogger() << "class $";
+      break;
+    case kPragmaFunc:
+      LogInfo::MapleLogger() << "func &";
+      break;
+    case kPragmaField:
+      LogInfo::MapleLogger() << "var @";
+      break;
+    case kPragmaVar:
+      LogInfo::MapleLogger() << "var %";
+      break;
+    case kPragmaParam:
+      LogInfo::MapleLogger() << "param " << paramNum << " &";
+      break;
+    case kPragmaFuncExecptioni:
+      LogInfo::MapleLogger() << "func_ex &";
+      break;
+    case kPragmaFuncVar:
+      LogInfo::MapleLogger() << "func_var &";
+      break;
+    default:
+      ASSERT(false, "unexpected func kind");
+      break;
+  }
+  LogInfo::MapleLogger() << GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx) << " ";
+  GStrIdx gStrIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->GetNameStrIdx();
+  LogInfo::MapleLogger() << "<$" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx) << "> ";
+  if (tyIdxEx != 0u) {
+    MIRType *typeEx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdxEx);
+    LogInfo::MapleLogger() << " " << typeEx->GetMplTypeName() << " ";
+  }
+  LogInfo::MapleLogger() << "{";
+  for (size_t j = 0; j < elementVec.size(); ++j) {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent + 1);
+    MIRPragmaElement *e = elementVec[j];
+    gStrIdx = e->GetNameStrIdx();
+    LogInfo::MapleLogger() << "@" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx) << " ";
+    e->Dump(indent);
+    if (j != elementVec.size() - 1) {
+      LogInfo::MapleLogger() << ",";
+    }
+  }
+  LogInfo::MapleLogger() << "}";
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_scope.cpp b/src/mapleall/maple_ir/src/mir_scope.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2efa616d5b2f0f1e701e03384787ccd4e300cd08
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_scope.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_scope.h"
+#include "mir_function.h"
+#include "printing.h"
+
+namespace maple {
+
+static unsigned scopeId = 1;
+
+MIRScope::MIRScope(MIRModule *mod,  MIRFunction *f)
+    : module(mod), func(f), id(scopeId++), isLocal(true) {
+  alias = module->GetMemPool()->New<MIRAlias>(module);
+  typeAlias = module->GetMemPool()->New<MIRTypeAlias>(module);
+}
+
+void MIRAlias::Dump(int32 indent, bool isLocal) const {
+  bool first = true;
+  for (auto it : aliasVarMap) {
+    if (first) {
+      first = false;
+      LogInfo::MapleLogger() << '\n';
+    } else {
+      LogInfo::MapleLogger() << ",\n";
+    }
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << "ALIAS "
+                           << (isLocal ? "%" : "$")
+                           << GlobalTables::GetStrTable().GetStringFromStrIdx(it.first)
+                           << ((it.second.isLocal) ? " %" : " $")
+                           << GlobalTables::GetStrTable().GetStringFromStrIdx(it.second.mplStrIdx) << " ";
+    switch (it.second.atk) {
+      case kATKType: {
+        TyIdx idx(it.second.index);
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(idx))->Dump(0);
+        break;
+      }
+      case kATKString: {
+        GStrIdx idx(it.second.index);
+        LogInfo::MapleLogger() << "\"" << GlobalTables::GetStrTable().GetStringFromStrIdx(idx)
+                               << "\"";
+        break;
+      }
+      case kATKEnum: {
+        MIREnum *mirEnum = GlobalTables::GetEnumTable().enumTable[it.second.index];
+        CHECK_NULL_FATAL(mirEnum);
+        LogInfo::MapleLogger() << "$" << GlobalTables::GetStrTable().GetStringFromStrIdx(mirEnum->GetNameIdx());
+        break;
+      }
+      default :
+        break;
+    }
+    it.second.attrs.DumpAttributes();
+    if (it.second.sigStrIdx) {
+      LogInfo::MapleLogger() << " \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(it.second.sigStrIdx) << "\"";
+    }
+  }
+}
+
+void MIRTypeAlias::Dump(int32 indent) const {
+  bool first = true;
+  for (auto it = typeAliasMap.cbegin(); it != typeAliasMap.cend(); ++it) {
+    if (first) {
+      first = false;
+      LogInfo::MapleLogger() << '\n';
+    } else {
+      LogInfo::MapleLogger() << ",\n";
+    }
+    PrintIndentation(indent);
+    const std::string name = GlobalTables::GetStrTable().GetStringFromStrIdx(it->first);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(it->second);
+    CHECK_NULL_FATAL(type);
+    LogInfo::MapleLogger() << "TYPEALIAS $" << name << " ";
+    type->Dump(1);
+  }
+}
+
+// scp is a sub scope
+// (low (scp.low, scp.high] high]
+bool MIRScope::IsSubScope(const MIRScope *scp) const {
+  auto &l = GetRangeLow();
+  auto &l1 = scp->GetRangeLow();
+  // allow included file
+  if (l.FileNum() != l1.FileNum()) {
+    return true;
+  }
+  auto &h = GetRangeHigh();
+  auto &h1 = scp->GetRangeHigh();
+  return l.IsBfOrEq(l1) && h1.IsBfOrEq(h);
+}
+
+// s1 and s2 has join
+// (s1.low (s2.low s1.high] s2.high]
+// (s2.low (s1.low s2.high] s1.high]
+bool MIRScope::HasJoinScope(const MIRScope *scp1, const MIRScope *scp2) const {
+  auto &l1 = scp1->GetRangeLow();
+  auto &h1 = scp1->GetRangeHigh();
+  auto &l2 = scp2->GetRangeLow();
+  auto &h2 = scp2->GetRangeHigh();
+  return (l1.IsBfOrEq(l2) && l2.IsBfOrEq(h1)) || (l2.IsBfOrEq(l1) && l1.IsBfOrEq(h2));
+}
+
+// scope range of s1 and s2 may be completly same when macro calling macro expand
+bool MIRScope::HasSameRange(const MIRScope *scp1, const MIRScope *scp2) const {
+  auto &l1 = scp1->GetRangeLow();
+  auto &h1 = scp1->GetRangeHigh();
+  auto &l2 = scp2->GetRangeLow();
+  auto &h2 = scp2->GetRangeHigh();
+  return l1.IsEq(l2) && h1.IsEq(h2);
+}
+
+SrcPosition MIRScope::GetScopeEndPos(const SrcPosition &pos) {
+  SrcPosition low  = GetRangeLow();
+  SrcPosition high = GetRangeHigh();
+  if (pos.IsEq(low)) {
+    return high;
+  }
+  for (auto it : func->GetScope()->blkSrcPos) {
+    SrcPosition p  = std::get<0>(it);
+    SrcPosition pB = std::get<1>(it);
+    SrcPosition pE = std::get<2>(it);
+    if (pos.IsEq(p)) {
+      // pB < low < p < pE < high
+      if (pB.IsBfOrEq(low) &&
+          low.IsBfOrEq(p) &&
+          pE.IsBfOrEq(high)) {
+        return high;
+      }
+    }
+  }
+
+  SrcPosition result = SrcPosition();
+  for (auto *scope : subScopes) {
+    result = scope->GetScopeEndPos(pos);
+    if (result.IsValid()) {
+      return result;
+    }
+  }
+  return result;
+}
+
+bool MIRScope::AddScope(MIRScope *scope) {
+  // check first if it is valid with parent scope and sibling sub scopes
+  CHECK_FATAL(IsSubScope(scope), "<%s %s> is not a subscope of scope <%s %s>",
+              scope->GetRangeLow().DumpLocWithColToString().c_str(),
+              scope->GetRangeHigh().DumpLocWithColToString().c_str(),
+              GetRangeLow().DumpLocWithColToString().c_str(),
+              GetRangeHigh().DumpLocWithColToString().c_str());
+  for (auto *s : subScopes) {
+    if (!HasSameRange(s, scope) && HasJoinScope(s, scope)) {
+      CHECK_FATAL(false, "<%s %s> has join range with another subscope <%s %s>",
+                  scope->GetRangeLow().DumpLocWithColToString().c_str(),
+                  scope->GetRangeHigh().DumpLocWithColToString().c_str(),
+                  s->GetRangeLow().DumpLocWithColToString().c_str(),
+                  s->GetRangeHigh().DumpLocWithColToString().c_str());
+    }
+  }
+  subScopes.push_back(scope);
+  return true;
+}
+
+void MIRScope::Dump(int32 indent) const {
+  LogInfo::MapleLogger() << '\n';
+  SrcPosition low = range.first;
+  SrcPosition high = range.second;
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "SCOPE " <<
+    id << " <(" <<
+    low.FileNum() << ", " <<
+    low.LineNum() << ", " <<
+    low.Column() << "), (" <<
+    high.FileNum() << ", " <<
+    high.LineNum() << ", " <<
+    high.Column() << ")> {";
+
+  typeAlias->Dump(indent + 1);
+  if (!typeAlias->IsEmpty() && !alias->IsEmpty()) {
+    LogInfo::MapleLogger() << ",";
+  }
+  alias->Dump(indent + 1, isLocal);
+  if (subScopes.size() == 0) {
+    LogInfo::MapleLogger() << "\n";
+  }
+  for (auto it : subScopes) {
+    if (!it->IsEmpty()) {
+      it->Dump(indent + 1);
+    }
+  }
+
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "}\n";
+}
+
+void MIRScope::Dump() const {
+  Dump(0);
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_symbol.cpp b/src/mapleall/maple_ir/src/mir_symbol.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3f0d8d2ede9e30e02a81a3fbc5459d39b1ad3c95
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_symbol.cpp
@@ -0,0 +1,437 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_symbol.h"
+#include "mir_function.h"
+#include "class_init.h"
+#include "vtable_analysis.h"
+#include "reflection_analysis.h"
+#include "printing.h"
+#include "native_stub_func.h"
+#include "literalstrname.h"
+#include "string_utils.h"
+
+namespace maple {
+using namespace namemangler;
+
+uint32 MIRSymbol::lastPrintedLineNum = 0;
+uint16 MIRSymbol::lastPrintedColumnNum = 0;
+
+bool MIRSymbol::NeedPIC() const {
+  return (storageClass == kScGlobal) ||
+         (storageClass == kScExtern) ||
+         (sKind == kStFunc && !GetFunction()->GetFuncAlias()->IsStatic());
+}
+
+bool MIRSymbol::IsTypeVolatile(int fieldID) const {
+  const MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetTyIdx());
+  return ty->IsVolatile(fieldID);
+}
+
+void MIRSymbol::SetNameStrIdx(const std::string &name) {
+  nameStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+}
+
+bool MIRSymbol::HasAddrOfValues() const {
+  return  StringUtils::StartsWith(GetName(), VTAB_PREFIX_STR) ||
+          StringUtils::StartsWith(GetName(), ITAB_PREFIX_STR) ||
+          StringUtils::StartsWith(GetName(), kVtabOffsetTabStr) ||
+          StringUtils::StartsWith(GetName(), kDecoupleStaticKeyStr) ||
+          IsClassInitBridge() || IsReflectionInfo() || IsReflectionHashTabBucket() ||
+          IsReflectionStrTab() || IsITabConflictInfo() || IsRegJNITab() ||
+          IsRegJNIFuncTab() || IsLiteral();
+}
+
+bool MIRSymbol::IsLiteral() const {
+  return StringUtils::StartsWith(GetName(), kConstString);
+}
+
+bool MIRSymbol::IsLiteralPtr() const {
+  return StringUtils::StartsWith(GetName(), kConstStringPtr);
+}
+
+MIRType *MIRSymbol::GetType() const {
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+}
+
+bool MIRSymbol::PointsToConstString() const {
+  MIRType *origType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  if (origType->GetKind() == kTypePointer) {
+    return static_cast<MIRPtrType*>(origType)->PointsToConstString();
+  }
+  return false;
+}
+
+bool MIRSymbol::IsConstString() const {
+  return typeAttrs.GetAttr(ATTR_static) && typeAttrs.GetAttr(ATTR_final) && PointsToConstString();
+}
+
+bool MIRSymbol::IsReflectionStrTab() const {
+  return StringUtils::StartsWith(GetName(), kReflectionStrtabPrefixStr) ||
+         StringUtils::StartsWith(GetName(), kReflectionStartHotStrtabPrefixStr) ||
+         StringUtils::StartsWith(GetName(), kReflectionBothHotStrTabPrefixStr) ||
+         StringUtils::StartsWith(GetName(), kReflectionRunHotStrtabPrefixStr) ||
+         StringUtils::StartsWith(GetName(), kReflectionNoEmitStrtabPrefixStr);
+}
+
+bool MIRSymbol::IsRegJNITab() const {
+  return StringUtils::StartsWith(GetName(), kRegJNITabPrefixStr);
+}
+
+bool MIRSymbol::IsRegJNIFuncTab() const {
+  return StringUtils::StartsWith(GetName(), kRegJNIFuncTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidPrefixStr);
+}
+
+bool MIRSymbol::IsMuidRoTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidRoPrefixStr);
+}
+
+bool MIRSymbol::IsCodeLayoutInfo() const {
+  return StringUtils::StartsWith(GetName(), kFunctionLayoutStr);
+}
+
+std::string MIRSymbol::GetMuidTabName() const {
+  if (!IsMuidTab()) {
+    return "";
+  }
+  size_t idx = GetName().find(kFileNameSplitterStr);
+  return (idx != std::string::npos) ? GetName().substr(0, idx) : "";
+}
+
+bool MIRSymbol::IsMuidFuncDefTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidFuncDefTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidFuncDefOrigTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidFuncDefOrigTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidFuncInfTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidFuncInfTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidFuncUndefTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidFuncUndefTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidDataDefTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidDataDefTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidDataDefOrigTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidDataDefOrigTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidDataUndefTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidDataUndefTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidFuncDefMuidTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidFuncDefMuidTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidFuncUndefMuidTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidFuncUndefMuidTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidDataDefMuidTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidDataDefMuidTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidDataUndefMuidTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidDataUndefMuidTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidFuncMuidIdxMuidTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidFuncMuidIdxTabPrefixStr);
+}
+
+bool MIRSymbol::IsMuidRangeTab() const {
+  return StringUtils::StartsWith(GetName(), kMuidRangeTabPrefixStr);
+}
+
+bool MIRSymbol::IsArrayClassCache() const {
+  return StringUtils::StartsWith(GetName(), kArrayClassCacheTable);
+}
+
+bool MIRSymbol::IsArrayClassCacheName() const {
+  return StringUtils::StartsWith(GetName(), kArrayClassCacheNameTable);
+}
+
+bool MIRSymbol::IsForcedGlobalFunc() const {
+  return StringUtils::StartsWith(GetName(), kJavaLangClassStr) ||
+         StringUtils::StartsWith(GetName(), kReflectionClassesPrefixStr) ||
+         StringUtils::StartsWith(GetName(), "Ljava_2Fnio_2FDirectByteBuffer_3B_7C_3Cinit_3E_7C_28JI_29V");
+}
+
+// mrt/maplert/include/mrt_classinfo.h
+bool MIRSymbol::IsForcedGlobalClassinfo() const {
+  std::unordered_set<std::string> mrtUse {
+#include "mrt_direct_classinfo_list.def"
+  };
+  return std::find(mrtUse.begin(), mrtUse.end(), GetName()) != mrtUse.end() ||
+         StringUtils::StartsWith(GetName(), "__cinf_Llibcore_2Freflect_2FGenericSignatureParser_3B");
+}
+
+bool MIRSymbol::IsClassInitBridge() const {
+  return StringUtils::StartsWith(GetName(), CLASS_INIT_BRIDGE_PREFIX_STR);
+}
+
+bool MIRSymbol::IsReflectionHashTabBucket() const {
+  return StringUtils::StartsWith(GetName(), kMuidClassMetadataBucketPrefixStr);
+}
+
+bool MIRSymbol::IsReflectionInfo() const {
+  return IsReflectionClassInfo() || IsReflectionClassInfoRO() || IsReflectionFieldsInfo() ||
+         IsReflectionFieldsInfoCompact() || IsReflectionMethodsInfo() || IsReflectionPrimitiveClassInfo() ||
+         IsReflectionSuperclassInfo() || IsReflectionMethodsInfoCompact();
+}
+
+bool MIRSymbol::IsReflectionFieldsInfo() const {
+  return StringUtils::StartsWith(GetName(), kFieldsInfoPrefixStr);
+}
+
+bool MIRSymbol::IsReflectionFieldsInfoCompact() const {
+  return StringUtils::StartsWith(GetName(), kFieldsInfoCompactPrefixStr);
+}
+
+bool MIRSymbol::IsReflectionSuperclassInfo() const {
+  return StringUtils::StartsWith(GetName(), SUPERCLASSINFO_PREFIX_STR);
+}
+
+bool MIRSymbol::IsReflectionFieldOffsetData() const {
+  return StringUtils::StartsWith(GetName(), kFieldOffsetDataPrefixStr);
+}
+
+bool MIRSymbol::IsReflectionMethodAddrData() const {
+  return (GetName().find(kMethodAddrDataPrefixStr) == 0);
+}
+
+bool MIRSymbol::IsReflectionMethodSignature() const {
+  return (GetName().find(kMethodSignaturePrefixStr) == 0);
+}
+
+bool MIRSymbol::IsReflectionClassInfo() const {
+  return StringUtils::StartsWith(GetName(), CLASSINFO_PREFIX_STR);
+}
+
+bool MIRSymbol::IsReflectionArrayClassInfo() const {
+  return StringUtils::StartsWith(GetName(), kArrayClassInfoPrefixStr);
+}
+
+bool MIRSymbol::IsReflectionClassInfoPtr() const {
+  return StringUtils::StartsWith(GetName(), kClassINfoPtrPrefixStr);
+}
+
+bool MIRSymbol::IsReflectionClassInfoRO() const {
+  return StringUtils::StartsWith(GetName(), CLASSINFO_RO_PREFIX_STR);
+}
+
+bool MIRSymbol::IsITabConflictInfo() const {
+  return StringUtils::StartsWith(GetName(), ITAB_CONFLICT_PREFIX_STR);
+}
+
+bool MIRSymbol::IsVTabInfo() const {
+  return StringUtils::StartsWith(GetName(), VTAB_PREFIX_STR);
+}
+
+bool MIRSymbol::IsITabInfo() const {
+  return StringUtils::StartsWith(GetName(), ITAB_PREFIX_STR);
+}
+
+bool MIRSymbol::IsReflectionPrimitiveClassInfo() const {
+  return StringUtils::StartsWith(GetName(), PRIMITIVECLASSINFO_PREFIX_STR);
+}
+
+bool MIRSymbol::IsReflectionMethodsInfo() const {
+  return StringUtils::StartsWith(GetName(), kMethodsInfoPrefixStr);
+}
+
+bool MIRSymbol::IsReflectionMethodsInfoCompact() const {
+  return StringUtils::StartsWith(GetName(), kMethodsInfoCompactPrefixStr);
+}
+
+bool MIRSymbol::IsPrimordialObject() const {
+  return IsReflectionClassInfo() || IsReflectionPrimitiveClassInfo();
+}
+
+bool MIRSymbol::IsGctibSym() const {
+  return StringUtils::StartsWith(GetName(), GCTIB_PREFIX_STR);
+}
+
+// [Note]
+// Some symbols are ignored by reference counting as they represent objects not managed by us. These include
+// string-based exact comparison for "current_vptr", "vtabptr", "itabptr", "funcptr", "env_ptr", "retvar_stubfunc".
+GStrIdx MIRSymbol::reflectClassNameIdx;
+GStrIdx MIRSymbol::reflectMethodNameIdx;
+GStrIdx MIRSymbol::reflectFieldNameIdx;
+bool MIRSymbol::IgnoreRC() const {
+  if (isDeleted || GetAttr(ATTR_rcunowned)) {
+    return true;
+  }
+  const std::string &name = GetName();
+  // ignore %current_vptr, %vtabptr, %itabptr, %funcptr, %env_ptr
+  if (name == "current_vptr" || name == "vtabptr" || name == "itabptr" || name == "funcptr" || name == "env_ptr" ||
+      name == "retvar_stubfunc" || name == "_dummy_stub_object_retval") {
+    return true;
+  }
+  if (IsReflectionInfo() || IsRegJNITab() || IsRegJNIFuncTab()) {
+    return true;
+  }
+  MIRType *type = GetType();
+  // only consider reference
+  if (type == nullptr || type->GetPrimType() != PTY_ref) {
+    return true;
+  }
+  if ((type->GetKind() == kTypeScalar) && (name != "__mapleRC__")) {
+    return true;
+  }
+  // ignore ptr to types Ljava_2Flang_2FClass_3B,
+  // Ljava_2Flang_2Freflect_2FMethod_3B
+  const auto *pType = static_cast<MIRPtrType*>(type);
+  GStrIdx strIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pType->GetPointedTyIdx())->GetNameStrIdx();
+  if (reflectClassNameIdx == 0u) {
+    reflectClassNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::GetInternalNameLiteral("Ljava_2Flang_2FClass_3B"));
+  }
+  return strIdx == reflectClassNameIdx;
+}
+
+void MIRSymbol::Dump(bool isLocal, int32 indent, bool suppressInit, const MIRSymbolTable *localsymtab) const {
+  if (sKind == kStVar || sKind == kStFunc) {
+    srcPosition.DumpLoc(lastPrintedLineNum, lastPrintedColumnNum);
+  }
+  // exclude unused symbols, formal symbols and extern functions
+  if (GetStorageClass() == kScUnused || GetStorageClass() == kScFormal ||
+      (GetStorageClass() == kScExtern && sKind == kStFunc && !GetFunction()->GetAttr(FUNCATTR_used))) {
+    return;
+  }
+  if (GetIsImported() && !GetAppearsInCode()) {
+    return;
+  }
+  if (GetTyIdx() >= GlobalTables::GetTypeTable().GetTypeTable().size()) {
+    FATAL(kLncFatal, "valid maple_ir with illegal type");
+  }
+  if (GetStorageClass() == kScText && GetFunction() != nullptr) {
+    // without body
+    GetFunction()->Dump(true);
+    return;
+  }
+  const char *ids = isLocal ? "%" : "$";
+  PrintIndentation(indent);
+  if (sKind == kStJavaClass) {
+    LogInfo::MapleLogger() << "javaclass ";
+  } else if (sKind == kStJavaInterface) {
+    LogInfo::MapleLogger() << "javainterface ";
+  } else if (isTmp) {
+    LogInfo::MapleLogger() << "tempvar ";
+  } else {
+    LogInfo::MapleLogger() << "var ";
+  }
+  LogInfo::MapleLogger() << ids << GetName() << " ";
+  if (GetStorageClass() == kScFstatic) {
+    LogInfo::MapleLogger() << "fstatic ";
+  } else if (GetStorageClass() == kScPstatic) {
+    LogInfo::MapleLogger() << "pstatic ";
+  } else if (GetStorageClass() == kScExtern) {
+    LogInfo::MapleLogger() << "extern ";
+  }
+  if (GetTyIdx() != 0u) {
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetTyIdx())->Dump(indent + 1);
+  }
+  if (sectionAttr != UStrIdx(0)) {
+    LogInfo::MapleLogger() << " section (";
+    PrintString(GlobalTables::GetUStrTable().GetStringFromStrIdx(sectionAttr));
+    LogInfo::MapleLogger() << " )";
+  }
+  if (asmAttr != UStrIdx(0)) {
+    LogInfo::MapleLogger() << " asmattr (";
+    PrintString(GlobalTables::GetUStrTable().GetStringFromStrIdx(asmAttr));
+    LogInfo::MapleLogger() << " )";
+  }
+  typeAttrs.DumpAttributes();
+  if (sKind == kStJavaClass || sKind == kStJavaInterface || GetStorageClass() == kScTypeInfoName ||
+      GetStorageClass() == kScTypeInfo || GetStorageClass() == kScTypeCxxAbi) {
+    LogInfo::MapleLogger() << '\n';
+    return;
+  }
+  if (IsConst() && !suppressInit && !(IsLiteral() && GetStorageClass() == kScExtern)) {
+    LogInfo::MapleLogger() << " = ";
+    GetKonst()->Dump(localsymtab);
+  }
+  LogInfo::MapleLogger() << '\n';
+}
+
+void MIRSymbol::DumpAsLiteralVar() const {
+  if (IsLiteral()) {
+    LogInfo::MapleLogger() << GetName();
+  }
+}
+
+const std::set<std::string> MIRSymbol::staticFinalBlackList{
+    "Ljava_2Flang_2FSystem_3B_7Cout",
+    "Ljava_2Flang_2FSystem_3B_7Cerr",
+    "Ljava_2Flang_2FSystem_3B_7Cin",
+};
+
+void MIRSymbolTable::Dump(bool isLocal, int32 indent, bool printDeleted, MIRFlavor flavor) const {
+  size_t size = symbolTable.size();
+  for (size_t i = 0; i < size; ++i) {
+    MIRSymbol *symbol = symbolTable[i];
+    if (symbol == nullptr) {
+      continue;
+    }
+    if (!printDeleted && symbol->IsDeleted()) {
+      continue;
+    }
+    if (flavor == kFlavorLmbc && symbol->LMBCAllocateOffSpecialReg()) {
+      continue;
+    }
+    symbol->Dump(isLocal, indent, false /* suppressinit */, this);
+  }
+}
+
+LabelIdx MIRLabelTable::CreateLabelWithPrefix(char c) {
+  LabelIdx labelIdx = labelTable.size();
+  std::ostringstream labelNameStream;
+  labelNameStream << "@" << c << labelIdx;
+  std::string labelName = labelNameStream.str();
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(labelName);
+  labelTable.push_back(nameIdx);
+  strIdxToLabIdxMap[nameIdx] = labelIdx;
+  return labelIdx;
+}
+
+const std::string &MIRLabelTable::GetName(LabelIdx labelIdx) const {
+  CHECK_FATAL(labelIdx < labelTable.size(), "index out of range in MIRLabelTable::GetName");
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(labelTable[labelIdx]);
+}
+
+void MIRLabelTable::AddToStringLabelMap(LabelIdx labelIdx) {
+  CHECK_FATAL(labelIdx < labelTable.size(), "index out of range in MIRLabelTable::AddToStringLabelMap");
+  if (labelTable[labelIdx] == 0u) {
+    // generate a label name based on lab_idx
+    std::ostringstream labelNameStream;
+    labelNameStream << "@" << labelIdx;
+    std::string labelName = labelNameStream.str();
+    labelTable[labelIdx] = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(labelName);
+  }
+  GStrIdx strIdx = labelTable[labelIdx];
+  strIdxToLabIdxMap[strIdx] = labelIdx;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_symbol_builder.cpp b/src/mapleall/maple_ir/src/mir_symbol_builder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..84e536372b4880ae51ffd0789e8c03fc2e315efb
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_symbol_builder.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_symbol_builder.h"
+
+namespace maple {
+MIRSymbol *MIRSymbolBuilder::GetLocalDecl(const MIRSymbolTable &symbolTable, const GStrIdx &strIdx) const {
+  if (strIdx != 0u) {
+    const StIdx stIdx = symbolTable.GetStIdxFromStrIdx(strIdx);
+    if (stIdx.FullIdx() != 0) {
+      return symbolTable.GetSymbolFromStIdx(stIdx.Idx());
+    }
+  }
+  return nullptr;
+}
+
+MIRSymbol *MIRSymbolBuilder::CreateLocalDecl(MIRSymbolTable &symbolTable, GStrIdx strIdx,
+                                             const MIRType &type) const {
+  MIRSymbol *st = symbolTable.CreateSymbol(kScopeLocal);
+  st->SetNameStrIdx(strIdx);
+  st->SetTyIdx(type.GetTypeIndex());
+  (void)symbolTable.AddToStringSymbolMap(*st);
+  st->SetStorageClass(kScAuto);
+  st->SetSKind(kStVar);
+  return st;
+}
+
+MIRSymbol *MIRSymbolBuilder::GetGlobalDecl(GStrIdx strIdx) const {
+  if (strIdx != 0u) {
+    const StIdx stIdx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(strIdx);
+    if (stIdx.FullIdx() != 0) {
+      return GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+    }
+  }
+  return nullptr;
+}
+
+MIRSymbol *MIRSymbolBuilder::CreateGlobalDecl(GStrIdx strIdx, const MIRType &type, MIRStorageClass sc) const {
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  st->SetNameStrIdx(strIdx);
+  st->SetTyIdx(type.GetTypeIndex());
+  (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*st);
+  st->SetStorageClass(sc);
+  st->SetSKind(kStVar);
+  return st;
+}
+
+// when sametype is true, it means match everything the of the symbol
+MIRSymbol *MIRSymbolBuilder::GetSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                                       bool sameType) const {
+  MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+  if (st == nullptr || st->GetTyIdx() != tyIdx) {
+    return nullptr;
+  }
+
+  if (sameType) {
+    if (st->GetStorageClass() == sClass && st->GetSKind() == mClass) {
+      return st;
+    }
+    return nullptr;
+  }
+  ASSERT(mClass == st->GetSKind(),
+         "trying to create a new symbol that has the same name and GtyIdx. might cause problem");
+  ASSERT(sClass == st->GetStorageClass(),
+         "trying to create a new symbol that has the same name and tyIdx. might cause problem");
+  return st;
+}
+
+// when func is null, create global symbol, otherwise create local symbol
+MIRSymbol *MIRSymbolBuilder::CreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
+                                          MIRFunction *func, uint8 scpID) const {
+  MIRSymbol *st =
+      (func != nullptr) ? func->GetSymTab()->CreateSymbol(scpID) : GlobalTables::GetGsymTable().CreateSymbol(scpID);
+  CHECK_FATAL(st != nullptr, "Failed to create MIRSymbol");
+  st->SetStorageClass(sClass);
+  st->SetSKind(mClass);
+  st->SetNameStrIdx(strIdx);
+  st->SetTyIdx(tyIdx);
+  if (func != nullptr) {
+    (void)func->GetSymTab()->AddToStringSymbolMap(*st);
+  } else {
+    (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*st);
+  }
+  return st;
+}
+
+MIRSymbol *MIRSymbolBuilder::CreatePregFormalSymbol(TyIdx tyIdx, PregIdx pRegIdx, MIRFunction &func) const {
+  MIRSymbol *st = func.GetSymTab()->CreateSymbol(kScopeLocal);
+  CHECK_FATAL(st != nullptr, "Failed to create MIRSymbol");
+  st->SetStorageClass(kScFormal);
+  st->SetSKind(kStPreg);
+  st->SetTyIdx(tyIdx);
+  MIRPregTable *pregTab = func.GetPregTab();
+  st->SetPreg(pregTab->PregFromPregIdx(pRegIdx));
+  return st;
+}
+
+size_t MIRSymbolBuilder::GetSymbolTableSize(const MIRFunction *func) const {
+  return (func == nullptr) ? GlobalTables::GetGsymTable().GetSymbolTableSize() :
+      func->GetSymTab()->GetSymbolTableSize();
+}
+
+const MIRSymbol *MIRSymbolBuilder::GetSymbolFromStIdx(uint32 idx, const MIRFunction *func) const {
+  if (func == nullptr) {
+    auto &symTab = GlobalTables::GetGsymTable();
+    return symTab.GetSymbolFromStidx(idx);
+  } else {
+    auto &symTab = *func->GetSymTab();
+    return symTab.GetSymbolFromStIdx(idx);
+  }
+}
+} // maple
diff --git a/src/mapleall/maple_ir/src/mir_type.cpp b/src/mapleall/maple_ir/src/mir_type.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3e4b090307a089958cf74abaebd47d8318870669
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mir_type.cpp
@@ -0,0 +1,2389 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mir_type.h"
+#include "mir_symbol.h"
+#include "mir_scope.h"
+#include "printing.h"
+#include "namemangler.h"
+#include "global_tables.h"
+#include "mir_builder.h"
+#include "cfg_primitive_types.h"
+#include "string_utils.h"
+#include "triple.h"
+#if MIR_FEATURE_FULL
+
+namespace maple {
+#define LOAD_PRIMARY_TYPE_PROPERTY
+#include "prim_types.def"
+
+#define LOAD_ALGO_PRIMARY_TYPE
+const PrimitiveTypeProperty &GetPrimitiveTypeProperty(PrimType pType) {
+  switch (pType) {
+    case PTY_begin:
+      return PTProperty_begin;
+#define PRIMTYPE(P) \
+    case PTY_##P:   \
+      return PTProperty_##P;
+#include "prim_types.def"
+#undef PRIMTYPE
+    case PTY_end:
+    default:
+      return PTProperty_end;
+  }
+}
+
+PrimType GetRegPrimType(PrimType primType) {
+  switch (primType) {
+    case PTY_i8:
+    case PTY_i16:
+      return PTY_i32;
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_u16:
+      return PTY_u32;
+    default:
+      return primType;
+  }
+}
+
+PrimType GetReg64PrimType(PrimType primType) {
+  switch (primType) {
+    case PTY_i8:
+    case PTY_i16:
+    case PTY_i32:
+      return PTY_i64;
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_u16:
+    case PTY_u32:
+      return PTY_u64;
+    default:
+      return primType;
+  }
+}
+
+bool VerifyPrimType(PrimType primType1, PrimType primType2) {
+  switch (primType1) {
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_u16:
+    case PTY_u32:
+    case PTY_a32:
+      return IsUnsignedInteger(primType2);
+    case PTY_i8:
+    case PTY_i16:
+    case PTY_i32:
+      return IsSignedInteger(primType2);
+    default:
+      return primType1 == primType2;
+  }
+}
+
+PrimType GetDynType(PrimType primType) {
+#ifdef DYNAMICLANG
+  switch (primType) {
+    case PTY_u1:
+      return PTY_dynbool;
+    case PTY_i32:
+      return PTY_dyni32;
+    case PTY_simplestr:
+      return PTY_dynstr;
+    case PTY_simpleobj:
+      return PTY_dynobj;
+    case PTY_f32:
+      return PTY_dynf32;
+    case PTY_f64:
+      return PTY_dynf64;
+    default:
+      return primType;
+  }
+#else
+  return primType;
+#endif
+}
+
+PrimType GetNonDynType(PrimType primType) {
+#ifdef DYNAMICLANG
+  switch (primType) {
+    case PTY_dynbool:
+      return PTY_u1;
+    case PTY_dyni32:
+      return PTY_i32;
+    case PTY_dynstr:
+      return PTY_simplestr;
+    case PTY_dynobj:
+      return PTY_simpleobj;
+    case PTY_dynf32:
+      return PTY_f32;
+    case PTY_dynf64:
+      return PTY_f64;
+    default:
+      return primType;
+  }
+#else
+  return primType;
+#endif
+}
+
+PrimType GetIntegerPrimTypeBySizeAndSign(size_t sizeBit, bool isSign) {
+  switch (sizeBit) {
+    case k1BitSize: {
+      if (isSign) {
+        return PTY_begin;  // There is no 'i1' type
+      }
+      return PTY_u1;
+    }
+    case k8BitSize: {
+      return isSign ? PTY_i8 : PTY_u8;
+    }
+    case k16BitSize: {
+      return isSign ? PTY_i16 : PTY_u16;
+    }
+    case k32BitSize: {
+      return isSign ? PTY_i32 : PTY_u32;
+    }
+    case k64BitSize: {
+      return isSign ? PTY_i64 : PTY_u64;
+    }
+    default: {
+      return PTY_begin;  // Invalid integer type
+    }
+  }
+}
+
+bool IsNoCvtNeeded(PrimType toType, PrimType fromType) {
+  if (toType == fromType) {
+    return true;
+  }
+  switch (toType) {
+    case PTY_i32:
+      return fromType == PTY_i16 || fromType == PTY_i8;
+    case PTY_u32:
+      return fromType == PTY_u16 || fromType == PTY_u8;
+    case PTY_u1:
+    case PTY_u8:
+    case PTY_u16:
+      return fromType == PTY_u32;
+    case PTY_i8:
+    case PTY_i16:
+      return fromType == PTY_i32;
+    case PTY_i64:
+    case PTY_u64:
+    case PTY_a64:
+    case PTY_ptr:
+      return fromType == PTY_ptr || fromType == PTY_u64 || fromType == PTY_a64 || fromType == PTY_i64;
+    default:
+      return false;
+  }
+}
+
+bool NeedCvtOrRetype(PrimType origin, PrimType compared) {
+  return GetPrimTypeSize(origin) != GetPrimTypeSize(compared) ||
+         IsSignedInteger(origin) != IsSignedInteger(compared);
+}
+
+uint8 GetPointerSize() {
+#if TARGX86 || TARGARM32 || TARGVM
+  return 4;
+#elif TARGX86_64
+  return 8;
+#elif TARGAARCH64
+  ASSERT(Triple::GetTriple().GetEnvironment() != Triple::UnknownEnvironment,
+         "Triple must be initialized before using");
+  uint8 size = (Triple::GetTriple().GetEnvironment() == Triple::GNUILP32) ? 4 : 8;
+  return size;
+#else
+  #error "Unsupported target"
+#endif
+}
+
+uint8 GetP2Size() {
+#if TARGX86 || TARGARM32 || TARGVM
+  return 2;
+#elif TARGX86_64
+  return 3;
+#elif TARGAARCH64
+  ASSERT(Triple::GetTriple().GetEnvironment() != Triple::UnknownEnvironment,
+         "Triple must be initialized before using");
+  uint8 size = (Triple::GetTriple().GetEnvironment() == Triple::GNUILP32) ? 2 : 3;
+  return size;
+#else
+  #error "Unsupported target"
+#endif
+}
+
+PrimType GetLoweredPtrType() {
+#if TARGX86 || TARGARM32 || TARGVM
+  return PTY_a32;
+#elif TARGX86_64
+  return PTY_a64;
+#elif TARGAARCH64
+  ASSERT(Triple::GetTriple().GetEnvironment() != Triple::UnknownEnvironment,
+         "Triple must be initialized before using");
+  auto pty = (Triple::GetTriple().GetEnvironment() == Triple::GNUILP32) ? PTY_a32 : PTY_a64;
+  return pty;
+#else
+  #error "Unsupported target"
+#endif
+}
+
+PrimType GetExactPtrPrimType() {
+  return (GetPointerSize() == 8) ? PTY_a64 : PTY_a32;
+}
+
+// answer in bytes; 0 if unknown
+uint32 GetPrimTypeSize(PrimType primType) {
+  switch (primType) {
+    case PTY_void:
+    case PTY_agg:
+      return k0BitSize;
+    case PTY_ptr:
+    case PTY_ref:
+      return GetPointerSize();
+    case PTY_u1:
+    case PTY_i8:
+    case PTY_u8:
+      return k1BitSize;
+    case PTY_i16:
+    case PTY_u16:
+      return k2BitSize;
+    case PTY_a32:
+    case PTY_f32:
+    case PTY_i32:
+    case PTY_u32:
+    case PTY_simplestr:
+    case PTY_simpleobj:
+      return k4BitSize;
+    case PTY_a64:
+    case PTY_c64:
+    case PTY_f64:
+    case PTY_i64:
+    case PTY_u64:
+    case PTY_v2i32:
+    case PTY_v4i16:
+    case PTY_v8i8:
+    case PTY_v2u32:
+    case PTY_v4u16:
+    case PTY_v8u8:
+    case PTY_v2f32:
+      return k8BitSize;
+    case PTY_u128:
+    case PTY_i128:
+    case PTY_c128:
+    case PTY_f128:
+    case PTY_v2i64:
+    case PTY_v4i32:
+    case PTY_v8i16:
+    case PTY_v16i8:
+    case PTY_v2u64:
+    case PTY_v4u32:
+    case PTY_v8u16:
+    case PTY_v16u8:
+    case PTY_v2f64:
+    case PTY_v4f32:
+      return k16BitSize;
+#ifdef DYNAMICLANG
+    case PTY_dynf32:
+    case PTY_dyni32:
+    case PTY_dynstr:
+    case PTY_dynobj:
+    case PTY_dynundef:
+    case PTY_dynnull:
+    case PTY_dynbool:
+      return k8BitSize;
+    case PTY_dynany:
+    case PTY_dynf64:
+      return k8BitSize;
+#endif
+    default:
+      return k0BitSize;
+  }
+}
+
+// answer is n if size in byte is (1<<n) (0: 1B; 1: 2B, 2: 4B, 3: 8B, 4:16B)
+uint32 GetPrimTypeP2Size(PrimType primType) {
+  switch (primType) {
+    case PTY_ptr:
+    case PTY_ref:
+      return GetP2Size();
+    case PTY_u1:
+    case PTY_i8:
+    case PTY_u8:
+      return k0BitSize;
+    case PTY_i16:
+    case PTY_u16:
+      return k1BitSize;
+    case PTY_a32:
+    case PTY_f32:
+    case PTY_i32:
+    case PTY_u32:
+    case PTY_simplestr:
+    case PTY_simpleobj:
+      return k2BitSize;
+    case PTY_a64:
+    case PTY_c64:
+    case PTY_f64:
+    case PTY_i64:
+    case PTY_u64:
+    case PTY_v2i32:
+    case PTY_v4i16:
+    case PTY_v8i8:
+    case PTY_v2u32:
+    case PTY_v4u16:
+    case PTY_v8u8:
+    case PTY_v2f32:
+      return k3BitSize;
+    case PTY_c128:
+    case PTY_f128:
+    case PTY_v2i64:
+    case PTY_v4i32:
+    case PTY_v8i16:
+    case PTY_v16i8:
+    case PTY_v2u64:
+    case PTY_v4u32:
+    case PTY_v8u16:
+    case PTY_v16u8:
+    case PTY_v2f64:
+    case PTY_v4f32:
+      return k4BitSize;
+#ifdef DYNAMICLANG
+    case PTY_dynf32:
+    case PTY_dyni32:
+    case PTY_dynstr:
+    case PTY_dynobj:
+    case PTY_dynundef:
+    case PTY_dynnull:
+    case PTY_dynbool:
+    case PTY_dynany:
+    case PTY_dynf64:
+      return k3BitSize;
+#endif
+    default:
+      ASSERT(false, "Power-of-2 size only applicable to sizes of 1, 2, 4, 8 or 16 bytes.");
+      return k10BitSize;
+  }
+}
+
+uint32 GetVecEleSize(PrimType primType) {
+  switch (primType) {
+    case PTY_v2i64:
+    case PTY_v2u64:
+    case PTY_v2f64:
+    case PTY_i64:
+    case PTY_u64:
+    case PTY_f64:
+      return k64BitSize;
+    case PTY_v2i32:
+    case PTY_v2u32:
+    case PTY_v2f32:
+    case PTY_v4i32:
+    case PTY_v4u32:
+    case PTY_v4f32:
+      return k32BitSize;
+    case PTY_v4i16:
+    case PTY_v4u16:
+    case PTY_v8i16:
+    case PTY_v8u16:
+      return k16BitSize;
+    case PTY_v8i8:
+    case PTY_v8u8:
+    case PTY_v16i8:
+    case PTY_v16u8:
+      return k8BitSize;
+    default:
+      CHECK_FATAL(false, "unexpected primtType for vector");
+  }
+}
+
+uint32 GetVecLanes(PrimType primType) {
+  switch (primType) {
+    case PTY_v2i32:
+    case PTY_v2u32:
+    case PTY_v2f32:
+    case PTY_v2i64:
+    case PTY_v2u64:
+    case PTY_v2f64:
+      return k2BitSize;
+    case PTY_v4i16:
+    case PTY_v4u16:
+    case PTY_v4i32:
+    case PTY_v4u32:
+    case PTY_v4f32:
+      return k4BitSize;
+    case PTY_v8i8:
+    case PTY_v8u8:
+    case PTY_v8i16:
+    case PTY_v8u16:
+      return k8BitSize;
+    case PTY_v16i8:
+    case PTY_v16u8:
+      return k16BitSize;
+    default:
+      return 0;
+  }
+}
+
+PrimType GetVecElemPrimType(PrimType primType) {
+  switch (primType) {
+    case PTY_v2i32:
+    case PTY_v4i32:
+      return PTY_i32;
+    case PTY_v2u32:
+    case PTY_v4u32:
+      return PTY_u32;
+    case PTY_v2i64:
+      return PTY_i64;
+    case PTY_v2u64:
+      return PTY_u64;
+    case PTY_v16i8:
+    case PTY_v8i8:
+      return PTY_i8;
+    case PTY_v16u8:
+    case PTY_v8u8:
+      return PTY_u8;
+    case PTY_v8i16:
+    case PTY_v4i16:
+      return PTY_i16;
+    case PTY_v8u16:
+    case PTY_v4u16:
+      return PTY_u16;
+    case PTY_v2f32:
+    case PTY_v4f32:
+      return PTY_f32;
+    case PTY_v2f64:
+      return PTY_f64;
+    default:
+      return PTY_begin; // not a vector type
+  }
+}
+
+// return the signed version that has the same size
+PrimType GetSignedPrimType(PrimType pty) {
+  switch (pty) {
+    case PTY_ptr:
+    case PTY_ref:
+    case PTY_a64:
+    case PTY_u64:
+      return PTY_i64;
+    case PTY_u8:
+      return PTY_i8;
+    case PTY_u16:
+      return PTY_i16;
+    case PTY_a32:
+    case PTY_u32:
+      return PTY_i32;
+    default: ;
+  }
+  return pty;
+}
+
+// return the unsigned version that has the same size
+PrimType GetUnsignedPrimType(PrimType pty) {
+  switch (pty) {
+    case PTY_i64:
+      return PTY_u64;
+    case PTY_i8:
+      return PTY_u8;
+    case PTY_i16:
+      return PTY_u16;
+    case PTY_i32:
+      return PTY_u32;
+    default: ;
+  }
+  return pty;
+}
+
+int64 MinValOfSignedInteger(PrimType primType) {
+  switch (primType) {
+    case PTY_i8:
+      return INT8_MIN;
+    case PTY_i16:
+      return INT16_MIN;
+    case PTY_i32:
+      return INT32_MIN;
+    case PTY_i64:
+      return INT64_MIN;
+    default:
+      CHECK_FATAL(false, "NIY");
+      return 0;
+  }
+}
+
+const char *GetPrimTypeName(PrimType primType) {
+#define LOAD_ALGO_PRIMARY_TYPE
+  switch (primType) {
+    case kPtyInvalid:
+      return "kPtyInvalid";
+#define PRIMTYPE(P) \
+    case PTY_##P:   \
+      return #P;
+#include "prim_types.def"
+#undef PRIMTYPE
+    case kPtyDerived:
+      return "derived";  // just for test: no primitive type for derived
+    default:
+      return "kPtyInvalid";
+  }
+  // SIMD types to be defined
+}
+
+const char *GetPrimTypeJavaName(PrimType primType) {
+  switch (primType) {
+    case PTY_u1:
+      return "Z";
+    case PTY_i8:
+      return "B";
+    case PTY_i16:
+      return "S";
+    case PTY_u16:
+      return "C";
+    case PTY_i32:
+      return "I";
+    case PTY_i64:
+      return "J";
+    case PTY_f32:
+      return "F";
+    case PTY_f64:
+      return "D";
+    case PTY_void:
+      return "V";
+    case PTY_constStr:
+      return kJstrTypeName.c_str();
+    case kPtyInvalid:
+      return "invalid";
+    default:
+      return "invalid";
+  }
+}
+
+void StmtAttrs::DumpAttributes() const {
+#define STMT_ATTR
+#define STRING(s) #s
+#define ATTR(AT)          \
+  if (GetAttr(STMTATTR_##AT)) \
+    LogInfo::MapleLogger() << STRING(AT);
+#include "all_attributes.def"
+#undef ATTR
+#undef STMT_ATTR
+}
+
+void TypeAttrs::DumpAttributes() const {
+// dump attr without content
+#define TYPE_ATTR
+#define NOCONTENT_ATTR
+#define STRING(s) #s
+#define ATTR(AT)          \
+  if (GetAttr(ATTR_##AT)) \
+    LogInfo::MapleLogger() << " " << STRING(AT);
+#include "all_attributes.def"
+#undef ATTR
+#undef NOCONTENT_ATTR
+#undef TYPE_ATTR
+// dump attr with content
+  if (attrAlign != 0) {
+    LogInfo::MapleLogger() << " align(" << GetAlign() << ")";
+  }
+  if (GetAttr(ATTR_pack) && GetPack() != 0) {
+    LogInfo::MapleLogger() << " pack(" << GetPack() << ")";
+  }
+}
+
+void FieldAttrs::DumpAttributes() const {
+// dump attr without content
+#define FIELD_ATTR
+#define NOCONTENT_ATTR
+#define STRING(s) #s
+#define ATTR(AT)             \
+  if (GetAttr(FLDATTR_##AT)) \
+    LogInfo::MapleLogger() << " " << STRING(AT);
+#include "all_attributes.def"
+#undef ATTR
+#undef NOCONTENT_ATTR
+#undef FIELD_ATTR
+// dump attr with content
+  if (attrAlign != 0) {
+    LogInfo::MapleLogger() << " align(" << GetAlign() << ")";
+  }
+  if (IsPacked()) {
+    LogInfo::MapleLogger() << " pack(1)";
+  }
+}
+
+const std::string &MIRType::GetName() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(nameStrIdx);
+}
+
+bool MIRType::ValidateClassOrInterface(const std::string &className, bool noWarning) const {
+  if (primType == maple::PTY_agg && (typeKind == maple::kTypeClass || typeKind == maple::kTypeInterface) &&
+      nameStrIdx != 0u) {
+    return true;
+  }
+  if (!noWarning) {
+    size_t len = className.size();
+    constexpr int minClassNameLen = 4;
+    constexpr char suffix[] = "_3B";
+    size_t suffixLen = std::strlen(suffix);
+    if (len > minClassNameLen && strncmp(className.c_str() + len - suffixLen, suffix, suffixLen) == 0) {
+      LogInfo::MapleLogger(kLlErr) << "error: missing proper mplt file for " << className << '\n';
+    } else {
+      LogInfo::MapleLogger(kLlErr) << "internal error: type is not java class or interface " << className << '\n';
+    }
+  }
+  return false;
+}
+
+bool MIRType::PointsToConstString() const {
+  return (typeKind == kTypePointer) ? static_cast<const MIRPtrType*>(this)->PointsToConstString() : false;
+}
+
+std::string MIRType::GetMplTypeName() const {
+  if (typeKind == kTypeScalar) {
+    return GetPrimTypeName(primType);
+  }
+  return "";
+}
+
+std::string MIRType::GetCompactMplTypeName() const {
+  if (typeKind == kTypeScalar) {
+    return GetPrimTypeJavaName(primType);
+  }
+  return "";
+}
+
+void MIRType::Dump(int indent [[maybe_unused]], bool dontUseName [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << GetPrimTypeName(primType);
+}
+
+void MIRType::DumpAsCxx(int indent [[maybe_unused]]) const {
+  switch (primType) {
+    case PTY_void:
+      LogInfo::MapleLogger() << "void";
+      break;
+    case PTY_i8:
+      LogInfo::MapleLogger() << "int8 ";
+      break;
+    case PTY_i16:
+      LogInfo::MapleLogger() << "int16";
+      break;
+    case PTY_i32:
+      LogInfo::MapleLogger() << "int32";
+      break;
+    case PTY_i64:
+      LogInfo::MapleLogger() << "int64";
+      break;
+    case PTY_u8:
+      LogInfo::MapleLogger() << "uint8";
+      break;
+    case PTY_u16:
+      LogInfo::MapleLogger() << "uint16";
+      break;
+    case PTY_u32:
+      LogInfo::MapleLogger() << "uint32";
+      break;
+    case PTY_u64:
+      LogInfo::MapleLogger() << "uint64";
+      break;
+    case PTY_u1:
+      LogInfo::MapleLogger() << "bool  ";
+      break;
+    case PTY_ptr:
+      LogInfo::MapleLogger() << "void* ";
+      break;
+    case PTY_ref:
+      LogInfo::MapleLogger() << "void* ";
+      break;
+    case PTY_a32:
+      LogInfo::MapleLogger() << "int32";
+      break;
+    case PTY_a64:
+      LogInfo::MapleLogger() << "void* ";
+      break;
+    case PTY_f32:
+      LogInfo::MapleLogger() << "float ";
+      break;
+    case PTY_f64:
+      LogInfo::MapleLogger() << "double";
+      break;
+    case PTY_c64:
+      LogInfo::MapleLogger() << "float complex";
+      break;
+    case PTY_c128:
+      LogInfo::MapleLogger() << "double complex";
+      break;
+    default:
+      ASSERT(false, "not yet implemented");
+  }
+}
+
+bool MIRType::IsOfSameType(MIRType &type) {
+  if (typeKind != type.typeKind) {
+    return false;
+  }
+
+  if (typeKind == kTypePointer) {
+    const auto &ptrType = static_cast<const MIRPtrType&>(*this);
+    const auto &ptrTypeIt = static_cast<const MIRPtrType&>(type);
+    if (ptrType.GetPointedTyIdx() == ptrTypeIt.GetPointedTyIdx()) {
+      return true;
+    } else {
+      MIRType &mirTypeIt = *GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTypeIt.GetPointedTyIdx());
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrType.GetPointedTyIdx())->IsOfSameType(mirTypeIt);
+    }
+  } else if (typeKind == kTypeJArray) {
+    auto &arrType1 = static_cast<MIRJarrayType&>(*this);
+    auto &arrType2 = static_cast<MIRJarrayType&>(type);
+    if (arrType1.GetDim() != arrType2.GetDim()) {
+      return false;
+    }
+    return arrType1.GetElemType()->IsOfSameType(*arrType2.GetElemType());
+  } else {
+    return tyIdx == type.tyIdx;
+  }
+}
+
+inline void DumpTypeName(GStrIdx strIdx, bool isLocal) {
+  LogInfo::MapleLogger() << ((isLocal) ? "%" : "$") << GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+}
+
+static bool CheckAndDumpTypeName(GStrIdx strIdx, bool isLocal) {
+  if (strIdx == 0u) {
+    return false;
+  }
+  LogInfo::MapleLogger() << "<";
+  DumpTypeName(strIdx, isLocal);
+  LogInfo::MapleLogger() << ">";
+  return true;
+}
+
+void MIRFuncType::Dump(int indent, bool dontUseName) const {
+  if (!dontUseName && CheckAndDumpTypeName(nameStrIdx, nameIsLocal)) {
+    return;
+  }
+  LogInfo::MapleLogger() << "<func";
+  funcAttrs.DumpAttributes();
+  LogInfo::MapleLogger() << " (";
+  size_t size = paramTypeList.size();
+  for (size_t i = 0; i < size; ++i) {
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(paramTypeList[i])->Dump(indent + 1);
+    if (i < paramAttrsList.size()) {
+      paramAttrsList[i].DumpAttributes();
+    }
+    if (size - 1 != i) {
+      LogInfo::MapleLogger() << ",";
+    }
+  }
+  if (IsVarargs()) {
+    LogInfo::MapleLogger() << ", ...";
+  }
+  LogInfo::MapleLogger() << ") ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(retTyIdx)->Dump(indent + 1);
+  retAttrs.DumpAttributes();
+  LogInfo::MapleLogger() << ">";
+}
+
+static constexpr uint64 RoundUpConst(uint64 offset, uint32 align) {
+  uint64 tempFirst = static_cast<uint64>(-align);
+  uint64 tempSecond = static_cast<uint64>(offset + align - 1);
+  return tempFirst & tempSecond;
+}
+
+static inline uint64 RoundUp(uint64 offset, uint32 align) {
+  if (align == 0) {
+    return offset;
+  }
+  return RoundUpConst(offset, align);
+}
+
+static constexpr uint64 RoundDownConst(uint64 offset, uint32 align) {
+  uint64 temp = static_cast<uint64>(-align);
+  return temp & offset;
+}
+
+static inline uint64 RoundDown(uint64 offset, uint32 align) {
+  if (align == 0) {
+    return offset;
+  }
+  return RoundDownConst(offset, align);
+}
+
+size_t MIRArrayType::GetSize() const {
+  if (size != kInvalidSize) {
+    return size;
+  }
+  size_t elemsize = GetElemType()->GetSize();
+  if (elemsize == 0) {
+    return 0;
+  }
+  elemsize = RoundUp(elemsize, typeAttrs.GetAlign());
+  size_t numelems = sizeArray[0];
+  for (uint16 i = 1; i < dim; i++) {
+    numelems *= sizeArray[i];
+  }
+  size = elemsize * numelems;
+  return size;
+}
+
+uint32 MIRArrayType::GetAlign() const {
+  if (GetSize() == 0) {
+    return typeAttrs.GetAlign();
+  }
+  return std::max(GetElemType()->GetAlign(), typeAttrs.GetAlign());
+}
+
+void MIRArrayType::Dump(int indent, bool dontUseName) const {
+  if (!dontUseName && CheckAndDumpTypeName(nameStrIdx, nameIsLocal)) {
+    return;
+  }
+  LogInfo::MapleLogger() << "<";
+  for (uint16 i = 0; i < dim; ++i) {
+    LogInfo::MapleLogger() << "[" << GetSizeArrayItem(i) << "]";
+  }
+  LogInfo::MapleLogger() << " ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(eTyIdx)->Dump(indent + 1);
+  GetTypeAttrs().DumpAttributes();
+  LogInfo::MapleLogger() << ">";
+}
+
+std::string MIRArrayType::GetCompactMplTypeName() const {
+  std::stringstream ss;
+  ss << "A";
+  MIRType *elemType = GetElemType();
+  ss << elemType->GetCompactMplTypeName();
+  return ss.str();
+}
+
+void MIRFarrayType::Dump(int indent, bool dontUseName) const {
+  if (!dontUseName && CheckAndDumpTypeName(nameStrIdx, nameIsLocal)) {
+    return;
+  }
+  LogInfo::MapleLogger() << "<[] ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(elemTyIdx)->Dump(indent + 1);
+  LogInfo::MapleLogger() << ">";
+}
+
+std::string MIRFarrayType::GetCompactMplTypeName() const {
+  std::stringstream ss;
+  ss << "A";
+  MIRType *elemType = GetElemType();
+  ss << elemType->GetCompactMplTypeName();
+  return ss.str();
+}
+
+const std::string &MIRJarrayType::GetJavaName() {
+  if (javaNameStrIdx == 0u) {
+    DetermineName();
+  }
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(javaNameStrIdx);
+}
+
+MIRStructType *MIRJarrayType::GetParentType() {
+  if (parentTyIdx == 0u) {
+    GStrIdx jloStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(
+        namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr));
+    parentTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(jloStrIdx);
+    ASSERT((parentTyIdx != 0u), "cannot find type for java.lang.Object");
+  }
+  return static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx));
+}
+
+void MIRJarrayType::DetermineName() {
+  if (javaNameStrIdx != 0u) {
+    return;  // already determined
+  }
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetElemTyIdx());
+  dim = 1;
+  std::string baseName;
+  while (true) {
+    if (elemType->GetKind() == kTypeScalar) {
+      baseName = GetPrimTypeJavaName(elemType->GetPrimType());
+      fromPrimitive = true;
+      break;
+    } else if (elemType->GetKind() == kTypePointer) {
+      auto *pType = static_cast<MIRPtrType*>(elemType)->GetPointedType();
+      ASSERT(pType != nullptr, "pType is null in MIRJarrayType::DetermineName");
+      if (pType->GetKind() == kTypeByName || pType->GetKind() == kTypeClass || pType->GetKind() == kTypeInterface ||
+          pType->GetKind() == kTypeClassIncomplete || pType->GetKind() == kTypeInterfaceIncomplete) {
+        baseName = static_cast<MIRStructType*>(pType)->GetName();
+        fromPrimitive = false;
+        break;
+      } else if (pType->GetKind() == kTypeJArray) {
+        auto *tmpPtype = static_cast<MIRJarrayType*>(pType);
+        elemType = tmpPtype->GetElemType();
+        ASSERT(elemType != nullptr, "elemType is null in MIRJarrayType::DetermineName");
+        ++dim;
+      } else {
+        ASSERT(false, "unexpected type!");
+      }
+    } else {
+      ASSERT(false, "unexpected type!");
+    }
+  }
+  std::string name;
+  for (int i = dim; i > 0; --i) {
+    name += JARRAY_PREFIX_STR;
+  }
+  name += baseName;
+  javaNameStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+}
+
+MIRType *MIRPtrType::GetPointedType() const {
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointedTyIdx);
+}
+
+bool MIRType::IsVolatile(int fieldID) const {
+  if (fieldID == 0) {
+    return HasVolatileField();
+  }
+  return static_cast<const MIRStructType*>(this)->IsFieldVolatile(fieldID);
+}
+
+bool MIRPtrType::HasTypeParam() const {
+  return GetPointedType()->HasTypeParam();
+}
+
+bool MIRPtrType::PointsToConstString() const {
+  GStrIdx typeNameIdx = GetPointedType()->GetNameStrIdx();
+  std::string typeName = GlobalTables::GetStrTable().GetStringFromStrIdx(typeNameIdx);
+  return typeName == "Ljava_2Flang_2FString_3B";
+}
+
+void MIRPtrType::Dump(int indent, bool dontUseName) const {
+  if (!dontUseName && CheckAndDumpTypeName(nameStrIdx, nameIsLocal)) {
+    return;
+  }
+  MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointedTyIdx);
+  if (pointedType->GetKind() == kTypeFunction) {  // no * for function pointer
+    pointedType->Dump(indent);
+  } else {
+    LogInfo::MapleLogger() << "<* ";
+    pointedType->Dump(indent + 1);
+    typeAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << ">";
+  }
+}
+
+void MIRBitFieldType::Dump(int indent [[maybe_unused]], bool dontUseName [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << ":" << static_cast<int>(fieldSize) << " " << GetPrimTypeName(primType);
+}
+
+size_t MIRClassType::GetSize() const {
+  if (parentTyIdx == 0u) {
+    return MIRStructType::GetSize();
+  }
+  if (size != kInvalidSize) {
+    return size;
+  }
+  const auto *parentType = static_cast<const MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx));
+  size_t parentSize = parentType->GetSize();
+  if (parentSize == 0) {
+    return 0;
+  }
+  size_t structSize = MIRStructType::GetSize();
+  if (structSize == 0) {
+    return 0;
+  }
+  size = parentSize + structSize;
+  return size;
+}
+
+FieldID MIRClassType::GetFirstLocalFieldID() const {
+  if (!IsLocal()) {
+    return 0;
+  }
+  if (parentTyIdx == 0u) {
+    return 1;
+  }
+
+  constexpr uint8 lastFieldIDOffset = 2;
+  constexpr uint8 firstLocalFieldIDOffset = 1;
+  const auto *parentClassType =
+      static_cast<const MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx));
+  return !parentClassType->IsLocal() ? parentClassType->GetLastFieldID() + lastFieldIDOffset
+                                     : parentClassType->GetFirstLocalFieldID() + firstLocalFieldIDOffset;
+}
+
+const MIRClassType *MIRClassType::GetExceptionRootType() const {
+  GStrIdx ehTypeNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kJavaLangObjectStr);
+  const MIRClassType *subClassType = this;
+  while (subClassType != nullptr && subClassType->nameStrIdx != ehTypeNameIdx) {
+    subClassType =
+        static_cast<const MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(subClassType->parentTyIdx));
+  }
+  return subClassType;
+}
+
+MIRClassType *MIRClassType::GetExceptionRootType() {
+  return const_cast<MIRClassType*>(const_cast<const MIRClassType*>(this)->GetExceptionRootType());
+}
+
+bool MIRClassType::IsExceptionType() const {
+  GStrIdx ehTypeNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName("Ljava_2Flang_2FThrowable_3B");
+  const MIRClassType *parentClassType = this;
+  while (parentClassType != nullptr && parentClassType->nameStrIdx != ehTypeNameIdx) {
+    parentClassType =
+        static_cast<MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentClassType->parentTyIdx));
+  }
+  return parentClassType != nullptr;
+}
+
+FieldID MIRClassType::GetLastFieldID() const {
+  FieldID fieldID = fields.size();
+  if (parentTyIdx != 0u) {
+    const auto *parentClassType =
+        static_cast<const MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx));
+    if (parentClassType != nullptr) {
+      fieldID += parentClassType->GetLastFieldID() + 1;
+    }
+  }
+  return fieldID;
+}
+
+static void DumpClassOrInterfaceInfo(const MIRStructType &type, int indent) {
+  const std::vector<MIRInfoPair> &info = type.GetInfo();
+  std::vector<bool> infoIsString = type.GetInfoIsString();
+  size_t size = info.size();
+  for (size_t i = 0; i < size; ++i) {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << "@" << GlobalTables::GetStrTable().GetStringFromStrIdx(info[i].first) << " ";
+    if (!infoIsString[i]) {
+      LogInfo::MapleLogger() << info[i].second;
+    } else {
+      LogInfo::MapleLogger() << "\"" << GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(info[i].second))
+                             << "\"";
+    }
+    if (i != size - 1) {
+      LogInfo::MapleLogger() << ",";
+    }
+  }
+}
+
+static uint32 GetInfoFromStrIdx(const std::vector<MIRInfoPair> &info, const GStrIdx &strIdx) {
+  for (MIRInfoPair infoPair : info) {
+    if (infoPair.first == strIdx) {
+      return infoPair.second;
+    }
+  }
+  return 0;
+}
+
+uint32 MIRInterfaceType::GetInfo(GStrIdx strIdx) const {
+  return GetInfoFromStrIdx(info, strIdx);
+}
+
+// return class id or superclass id accroding to input string
+uint32 MIRInterfaceType::GetInfo(const std::string &infoStr) const {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(infoStr);
+  return GetInfo(strIdx);
+}
+size_t MIRInterfaceType::GetSize() const {
+  if (size != kInvalidSize) {
+    return size;
+  }
+  size = MIRStructType::GetSize();
+  if (parentsTyIdx.empty()) {
+    return size;
+  }
+  if (size == 0) {
+    return 0;
+  }
+  for (size_t i = 0; i < parentsTyIdx.size(); ++i) {
+    const auto *parentType =
+        static_cast<const MIRInterfaceType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentsTyIdx[i]));
+    size_t parentSize = parentType->GetSize();
+    if (parentSize == 0) {
+      return 0;
+    }
+    size += parentSize;
+  }
+  return size;
+}
+
+static void DumpStaticValue(const MIREncodedArray &staticValue, int indent) {
+  if (staticValue.empty()) {
+    return;
+  }
+  LogInfo::MapleLogger() << '\n';
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "@staticvalue";
+  constexpr uint32 typeLen = 5;
+  constexpr uint32 typeMask = 0x1f;
+  for (const auto &value : staticValue) {
+    LogInfo::MapleLogger() << " [";
+    uint8 valueArg = static_cast<uint32>(value.encodedValue[0]) >> typeLen;
+    uint8 valueType = static_cast<uint32>(value.encodedValue[0]) & typeMask;
+    // kValueNull kValueBoolean
+    constexpr uint32 simpleOffset = 1;
+    constexpr uint32 aggOffSet = 2;
+    valueArg = (valueType == kValueNull || valueType == kValueBoolean) ? simpleOffset : valueArg + aggOffSet;
+    for (uint32 k = 0; k < valueArg; ++k) {
+      LogInfo::MapleLogger() << static_cast<uint32>(value.encodedValue[k]);
+      if (k != static_cast<uint32>(valueArg - 1)) {
+        LogInfo::MapleLogger() << " ";
+      }
+    }
+    LogInfo::MapleLogger() << "]";
+  }
+}
+
+static void DumpFields(FieldVector fields, int indent, bool otherFields = false) {
+  size_t size = fields.size();
+  for (size_t i = 0; i < size; ++i) {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << ((!otherFields) ? "@" : "^")
+                           << GlobalTables::GetStrTable().GetStringFromStrIdx(fields[i].first) << " ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(fields[i].second.first)->Dump(indent + 1);
+    FieldAttrs &fa = fields[i].second.second;
+    fa.DumpAttributes();
+    if (fa.GetAttr(FLDATTR_static) && fa.GetAttr(FLDATTR_final) &&
+        (fa.GetAttr(FLDATTR_public) || fa.GetAttr(FLDATTR_protected))) {
+      const char *fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fields[i].first).c_str();
+      MIRSymbol *fieldVar =
+          GlobalTables::GetGsymTable().GetSymbolFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(fieldName));
+      if (fieldVar != nullptr && fieldVar->GetKonst() != nullptr &&
+          fieldVar->GetKonst()->GetKind() == kConstStr16Const) {
+        LogInfo::MapleLogger() << " = ";
+        fieldVar->GetKonst()->Dump();
+      }
+    }
+    if (i != size - 1) {
+      LogInfo::MapleLogger() << ",";
+    }
+  }
+}
+
+static void DumpFieldsAsCxx(const FieldVector &fields, int indent) {
+  for (auto &f : fields) {
+    PrintIndentation(indent);
+    const FieldAttrs &fa = f.second.second;
+    if (fa.GetAttr(FLDATTR_static)) {
+      LogInfo::MapleLogger() << "// ";
+    }
+    LogInfo::MapleLogger() << "/* ";
+    fa.DumpAttributes();
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(f.second.first)->Dump(indent + 1);
+    LogInfo::MapleLogger() << " */ ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(f.second.first)->DumpAsCxx(indent + 1);
+    LogInfo::MapleLogger() << " " << GlobalTables::GetStrTable().GetStringFromStrIdx(f.first) << ";" << '\n';
+  }
+}
+
+static void DumpMethods(MethodVector methods, int indent) {
+  size_t size = methods.size();
+  for (size_t i = 0; i < size; ++i) {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent);
+    MIRSymbol *mFirstSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(methods[i].first.Idx());
+    ASSERT(mFirstSymbol != nullptr, "null ptr check");
+    LogInfo::MapleLogger() << "&" << mFirstSymbol->GetName();
+    methods[i].second.second.DumpAttributes();
+    LogInfo::MapleLogger() << " (";
+    auto *funcType =
+        static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(methods[i].second.first));
+    size_t parmListSize = funcType->GetParamTypeList().size();
+    for (size_t j = 0; j < parmListSize; ++j) {
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetNthParamType(j))->Dump(indent + 1);
+      if (j != parmListSize - 1) {
+        LogInfo::MapleLogger() << ",";
+      }
+    }
+    if (funcType->IsVarargs()) {
+      LogInfo::MapleLogger() << ", ...";
+    }
+    LogInfo::MapleLogger() << ") ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx())->Dump(indent + 1);
+    if (i != size - 1) {
+      LogInfo::MapleLogger() << ",";
+    }
+  }
+}
+
+static void DumpConstructorsAsCxx(MethodVector methods, int indent) {
+  unsigned int i = 0;
+  for (auto &m : methods) {
+    FuncAttrs &fa = m.second.second;
+    if (!fa.GetAttr(FUNCATTR_constructor) || !fa.GetAttr(FUNCATTR_public)) {
+      continue;
+    }
+    auto *funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(m.second.first));
+    PrintIndentation(indent);
+    MIRSymbol *mFirstSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(m.first.Idx());
+    ASSERT(mFirstSymbol != nullptr, "null ptr check");
+    LogInfo::MapleLogger() << "/* &" << mFirstSymbol->GetName();
+    fa.DumpAttributes();
+    LogInfo::MapleLogger() << " (";
+    unsigned int j = 0;
+    size_t paramTypeListSize = funcType->GetParamTypeList().size();
+    for (auto &p : funcType->GetParamTypeList()) {
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(p)->Dump(indent + 1);
+      if (j != paramTypeListSize - 1) {
+        LogInfo::MapleLogger() << ", ";
+      }
+      ++j;
+    }
+    if (funcType->IsVarargs()) {
+      LogInfo::MapleLogger() << ", ...";
+    }
+    LogInfo::MapleLogger() << ") ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx())->Dump(indent + 1);
+    LogInfo::MapleLogger() << " */" << '\n';
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << "/* ";
+    LogInfo::MapleLogger() << namemangler::DecodeName(mFirstSymbol->GetName());
+    LogInfo::MapleLogger() << " */" << '\n';
+    PrintIndentation(indent);
+    LogInfo::MapleLogger() << "extern \"C\" ";
+    // return type
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx())->DumpAsCxx(0);
+    LogInfo::MapleLogger() << " " << mFirstSymbol->GetName() << "( ";
+    j = 0;
+    for (auto &p : funcType->GetParamTypeList()) {
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(p)->DumpAsCxx(indent + 1);
+      if (j != paramTypeListSize - 1) {
+        LogInfo::MapleLogger() << ", ";
+      }
+      ++j;
+    }
+    if (funcType->IsVarargs()) {
+      LogInfo::MapleLogger() << ", ...";
+    }
+    LogInfo::MapleLogger() << ")";
+    if (methods.size() - 1 != i++) {
+      LogInfo::MapleLogger() << ";" << '\n';
+    }
+  }
+}
+
+static void DumpInterfaces(std::vector<TyIdx> interfaces, int indent) {
+  size_t size = interfaces.size();
+  for (size_t i = 0; i < size; ++i) {
+    LogInfo::MapleLogger() << '\n';
+    PrintIndentation(indent);
+    GStrIdx stridx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(interfaces[i])->GetNameStrIdx();
+    LogInfo::MapleLogger() << "$" << GlobalTables::GetStrTable().GetStringFromStrIdx(stridx);
+    if (i != size - 1) {
+      LogInfo::MapleLogger() << ",";
+    }
+  }
+}
+
+size_t MIRStructType::GetSize() const {
+  if (size != kInvalidSize) {
+    return size;
+  }
+  if (typeKind == kTypeUnion) {
+    if (fields.size() == 0) {
+      return isCPlusPlus ? 1 : 0;
+    }
+    size = 0;
+    for (size_t i = 0; i < fields.size(); ++i) {
+      TyIdxFieldAttrPair tfap = GetTyidxFieldAttrPair(i);
+      MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tfap.first);
+      size_t fldSize = RoundUp(fieldType->GetSize(), tfap.second.GetAlign());
+      if (size < fldSize) {
+        size = fldSize;
+      }
+    }
+    return size;
+  }
+  // since there may be bitfields, perform a layout process for the fields
+  size_t byteOfst = 0;
+  size_t bitOfst = 0;
+  constexpr uint32 shiftNum = 3;
+  for (size_t i = 0; i < fields.size(); ++i) {
+    TyIdxFieldAttrPair tfap = GetTyidxFieldAttrPair(i);
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tfap.first);
+    if (fieldType->GetKind() != kTypeBitField) {
+      if (byteOfst * k8BitSize < bitOfst) {
+        byteOfst = (bitOfst >> shiftNum) + 1;
+      }
+      uint32 fieldAlignBytes = std::max(fieldType->GetAlign(), tfap.second.GetAlign());
+      if (GetTypeAttrs().IsPacked() || tfap.second.IsPacked()) {
+        uint32 packBytes = tfap.second.IsPacked() ? 1 : GetTypeAttrs().GetPack();
+        fieldAlignBytes = std::min(fieldAlignBytes, packBytes);
+      }
+      byteOfst = RoundUp(byteOfst, fieldAlignBytes);
+      byteOfst += fieldType->GetSize();
+      bitOfst = byteOfst * k8BitSize;
+    } else {
+      MIRBitFieldType *bitfType = static_cast<MIRBitFieldType *>(fieldType);
+      if (bitfType->GetFieldSize() == 0) {  // special case, for aligning purpose
+        bitOfst = RoundUp(bitOfst, GetPrimTypeBitSize(bitfType->GetPrimType()));
+        byteOfst = bitOfst >> shiftNum;
+      } else {
+        // If current bitfield is packed, add bits of bitfield directly and finally consider to align by pack
+        // until when handling non-bitfield
+        if ((!GetTypeAttrs().IsPacked() && !tfap.second.IsPacked()) &&
+            (RoundDown(bitOfst + bitfType->GetFieldSize() - 1, GetPrimTypeBitSize(bitfType->GetPrimType())) !=
+            RoundDown(bitOfst, GetPrimTypeBitSize(bitfType->GetPrimType())))) {
+          bitOfst = RoundUp(bitOfst, GetPrimTypeBitSize(bitfType->GetPrimType()));
+        }
+        bitOfst += bitfType->GetFieldSize();
+        byteOfst = bitOfst >> shiftNum;
+      }
+    }
+  }
+  if (byteOfst * 8 < bitOfst) {
+    byteOfst = (bitOfst >> shiftNum) + 1;
+  }
+  byteOfst = RoundUp(byteOfst, GetAlign());
+  if (byteOfst == 0 && isCPlusPlus) {
+    size = 1;
+    return 1;  // empty struct in C++ has size 1
+  }
+  size = byteOfst;
+  return size;
+}
+
+uint32 MIRStructType::GetAlign() const {
+  if (fields.size() == 0) {
+    return 0;
+  }
+  uint32 maxAlign = 1;
+  for (size_t i = 0; i < fields.size(); ++i) {
+    TyIdxFieldAttrPair tfap = GetTyidxFieldAttrPair(i);
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tfap.first);
+    uint32 algn = fieldType->GetAlign();
+    if (fieldType->GetKind() == kTypeBitField) {
+      algn = GetPrimTypeSize(fieldType->GetPrimType());
+    } else {
+      algn = std::max(algn, tfap.second.GetAlign());
+    }
+    if (maxAlign < algn) {
+      maxAlign = algn;
+    }
+  }
+  return std::min(maxAlign, GetTypeAttrs().GetPack());
+}
+
+void MIRStructType::DumpFieldsAndMethods(int indent, bool hasMethod) const {
+  DumpFields(fields, indent);
+  bool hasField = !fields.empty();
+  bool hasStaticField = !staticFields.empty();
+  if (hasField && hasStaticField) {
+    LogInfo::MapleLogger() << ",";
+  }
+  DumpFields(staticFields, indent, true);
+  bool hasFieldOrStaticField = hasField || hasStaticField;
+  bool hasParentField = !parentFields.empty();
+  if (hasFieldOrStaticField && hasParentField) {
+    LogInfo::MapleLogger() << ",";
+  }
+  DumpFields(parentFields, indent, true);
+  if ((hasFieldOrStaticField || hasParentField) && hasMethod) {
+    LogInfo::MapleLogger() << ",";
+  }
+  DumpMethods(methods, indent);
+  if (alias && !alias->IsEmpty()) {
+    LogInfo::MapleLogger() << ",";
+    alias->Dump(indent, true);
+  }
+}
+
+void MIRStructType::Dump(int indent, bool dontUseName) const {
+  if (!dontUseName && CheckAndDumpTypeName(nameStrIdx, nameIsLocal)) {
+    return;
+  }
+  LogInfo::MapleLogger() << ((typeKind == kTypeStruct) ? "<struct"
+                                                       : ((typeKind == kTypeUnion) ? "<union"
+                                                                                   : "<structincomplete"));
+  typeAttrs.DumpAttributes();
+  LogInfo::MapleLogger() << " {";
+  DumpFieldsAndMethods(indent, !methods.empty());
+  LogInfo::MapleLogger() << "}>";
+}
+
+uint32 MIRClassType::GetInfo(GStrIdx strIdx) const {
+  return GetInfoFromStrIdx(info, strIdx);
+}
+
+// return class id or superclass id accroding to input string
+uint32 MIRClassType::GetInfo(const std::string &infoStr) const {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(infoStr);
+  return GetInfo(strIdx);
+}
+
+bool MIRClassType::IsFinal() const {
+  if (!IsStructType()) {
+    return false;
+  }
+  uint32 attrStrIdx = GetInfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_attribute_string"));
+  CHECK(attrStrIdx < GlobalTables::GetStrTable().StringTableSize(), "out of range of vector");
+  const std::string &kAttrString = GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(attrStrIdx));
+  return kAttrString.find(" final ") != std::string::npos;
+}
+
+bool MIRClassType::IsAbstract() const {
+  uint32 attrStrIdx = GetInfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_attribute_string"));
+  CHECK(attrStrIdx < GlobalTables::GetStrTable().StringTableSize(), "out of range of vector");
+  const std::string &kAttrString = GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(attrStrIdx));
+  return kAttrString.find(" abstract ") != std::string::npos;
+}
+
+bool MIRClassType::IsInner() const {
+  const std::string &name = GetName();
+  return name.find("_24") != std::string::npos;
+}
+
+static void DumpInfoPragmaStaticValue(const std::vector<MIRInfoPair> &info, const std::vector<MIRPragma*> &pragmaVec,
+                                      const MIREncodedArray &staticValue, int indent, bool hasFieldMethodOrInterface) {
+  bool hasPragma = pragmaVec.size();
+  bool hasStaticValue = staticValue.size();
+  if (!info.empty() && (hasPragma || hasStaticValue || hasFieldMethodOrInterface)) {
+    LogInfo::MapleLogger() << ",";
+  }
+  size_t size = pragmaVec.size();
+  for (size_t i = 0; i < size; ++i) {
+    pragmaVec[i]->Dump(indent);
+    if (i != size - 1) {
+      LogInfo::MapleLogger() << ",";
+    }
+  }
+  if (hasPragma && (hasStaticValue || hasFieldMethodOrInterface)) {
+    LogInfo::MapleLogger() << ",";
+  }
+  DumpStaticValue(staticValue, indent);
+  if (hasStaticValue && hasFieldMethodOrInterface) {
+    LogInfo::MapleLogger() << ",";
+  }
+}
+
+void MIRClassType::Dump(int indent, bool dontUseName) const {
+  if (!dontUseName && CheckAndDumpTypeName(nameStrIdx, nameIsLocal)) {
+    return;
+  }
+  LogInfo::MapleLogger() << ((typeKind == kTypeClass) ? "<class " : "<classincomplete ");
+  if (parentTyIdx != 0u) {
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx)->Dump(indent + 1);
+    LogInfo::MapleLogger() << " ";
+  }
+  LogInfo::MapleLogger() << "{";
+  DumpClassOrInterfaceInfo(*this, indent);
+  bool hasFieldMethodOrInterface = !(fields.empty() && parentFields.empty() && staticFields.empty() &&
+                                     methods.empty() && interfacesImplemented.empty());
+  DumpInfoPragmaStaticValue(info, pragmaVec, staticValue, indent, hasFieldMethodOrInterface);
+
+  bool hasMethod = !methods.empty();
+  bool hasImplementedInterface = !interfacesImplemented.empty();
+  DumpFieldsAndMethods(indent, hasMethod || hasImplementedInterface);
+  if (hasMethod && hasImplementedInterface) {
+    LogInfo::MapleLogger() << ",";
+  }
+  DumpInterfaces(interfacesImplemented, indent);
+  LogInfo::MapleLogger() << "}>";
+}
+
+void MIRClassType::DumpAsCxx(int indent) const {
+  LogInfo::MapleLogger() << "{\n";
+  DumpFieldsAsCxx(fields, indent);
+  LogInfo::MapleLogger() << "};\n";
+  DumpConstructorsAsCxx(methods, 0);
+}
+
+void MIRInterfaceType::Dump(int indent, bool dontUseName) const {
+  if (!dontUseName && CheckAndDumpTypeName(nameStrIdx, nameIsLocal)) {
+    return;
+  }
+  LogInfo::MapleLogger() << ((typeKind == kTypeInterface) ? "<interface " : "<interfaceincomplete ");
+  for (TyIdx idx : parentsTyIdx) {
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(idx)->Dump(0);
+    LogInfo::MapleLogger() << " ";
+  }
+  LogInfo::MapleLogger() << " {";
+  DumpClassOrInterfaceInfo(*this, indent);
+  bool hasFieldOrMethod = !(fields.empty() && staticFields.empty() && parentFields.empty() && methods.empty());
+  DumpInfoPragmaStaticValue(info, pragmaVec, staticValue, indent, hasFieldOrMethod);
+  DumpFieldsAndMethods(indent, !methods.empty());
+  LogInfo::MapleLogger() << "}>";
+}
+
+void MIRTypeByName::Dump(int indent [[maybe_unused]], bool dontUseName [[maybe_unused]]) const {
+  const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(nameStrIdx);
+  LogInfo::MapleLogger() << (nameIsLocal ? "<%" : "<$") << name << ">";
+}
+
+void MIRTypeParam::Dump(int indent [[maybe_unused]], bool dontUseName [[maybe_unused]]) const {
+  const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(nameStrIdx);
+  LogInfo::MapleLogger() << "<!" << name << ">";
+}
+
+void MIRInstantVectorType::Dump(int indent [[maybe_unused]], bool dontUseName [[maybe_unused]]) const {
+  LogInfo::MapleLogger() << "{";
+  for (size_t i = 0; i < instantVec.size(); ++i) {
+    TypePair typePair = instantVec[i];
+    if (i != 0) {
+      LogInfo::MapleLogger() << ", ";
+    }
+    MIRType *typeParmType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typePair.first);
+    const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(typeParmType->GetNameStrIdx());
+    LogInfo::MapleLogger() << "!" << name << "=";
+    MIRType *realty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typePair.second);
+    realty->Dump(0);
+  }
+  LogInfo::MapleLogger() << "}";
+}
+
+void MIRGenericInstantType::Dump(int indent, bool dontUseName) const {
+  LogInfo::MapleLogger() << "<";
+  const MIRType *genericType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(genericTyIdx);
+  DumpTypeName(genericType->GetNameStrIdx(), genericType->IsNameIsLocal());
+  MIRInstantVectorType::Dump(indent, dontUseName);
+  LogInfo::MapleLogger() << ">";
+}
+
+bool MIRType::EqualTo(const MIRType &mirType) const {
+  return typeKind == mirType.typeKind && primType == mirType.primType;
+}
+
+bool MIRPtrType::EqualTo(const MIRType &type) const {
+  if (typeKind != type.GetKind() || GetPrimType() != type.GetPrimType()) {
+    return false;
+  }
+  const auto &pType = static_cast<const MIRPtrType&>(type);
+  return pointedTyIdx == pType.GetPointedTyIdx() && typeAttrs == pType.GetTypeAttrs();
+}
+
+bool MIRArrayType::EqualTo(const MIRType &type) const {
+  if (type.GetKind() != typeKind) {
+    return false;
+  }
+  const auto &pType = static_cast<const MIRArrayType&>(type);
+  if (dim != pType.GetDim() || eTyIdx != pType.GetElemTyIdx() || typeAttrs != pType.GetTypeAttrs()) {
+    return false;
+  }
+  for (size_t i = 0; i < dim; ++i) {
+    if (GetSizeArrayItem(i) != pType.GetSizeArrayItem(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+MIRType *MIRArrayType::GetElemType() const {
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(eTyIdx);
+}
+
+std::string MIRArrayType::GetMplTypeName() const {
+  std::stringstream ss;
+  ss << "<[] ";
+  MIRType *elemType = GetElemType();
+  ss << elemType->GetMplTypeName();
+  ss << ">";
+  return ss.str();
+}
+
+bool MIRArrayType::HasFields() const {
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(eTyIdx);
+  return elemType->HasFields();
+}
+
+uint32 MIRArrayType::NumberOfFieldIDs() const {
+  if (fieldsNum != kInvalidFieldNum) {
+    return fieldsNum;
+  }
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(eTyIdx);
+  fieldsNum = elemType->NumberOfFieldIDs();
+  return fieldsNum;
+}
+
+MIRStructType *MIRArrayType::EmbeddedStructType() {
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(eTyIdx);
+  return elemType->EmbeddedStructType();
+}
+
+int64 MIRArrayType::GetBitOffsetFromArrayAddress(std::vector<int64> &indexArray) {
+  // for cases that num of dimension-operand is less than array's dimension
+  // e.g. array 1 ptr <* <[d1][d2][d3] type>> (array_base_addr, dim1_opnd)
+  // array's dimension is 3, and dimension-opnd's num is 1;
+  if (indexArray.size() < dim) {
+    indexArray.insert(indexArray.end(), dim - indexArray.size(), 0);
+  }
+  if (GetElemType()->GetKind() == kTypeArray) {
+    // for cases that array's dimension is less than num of dimension-opnd
+    // e.g array 1 ptr <* <[d1] <[d2] type>>> (array_base_addr, dim1_opnd, dim2_opnd)
+    // array's dimension is 1 (its element type is <[d2] type>), and dimension-opnd-num is 2
+    CHECK_FATAL(indexArray.size() >= dim, "dimension mismatch!");
+  } else {
+    CHECK_FATAL(indexArray.size() == dim, "dimension mismatch!");
+  }
+  int64 sum = 0; // element numbers before the specified element
+  uint32 numberOfElemInLowerDim = 1;
+  for (uint32 id = 1; id <= dim; ++id) {
+    sum += indexArray[dim - id] * numberOfElemInLowerDim;
+    numberOfElemInLowerDim *= sizeArray[dim - id];
+  }
+  size_t elemsize = GetElemType()->GetSize();
+  if (elemsize == 0 || sum == 0) {
+    return 0;
+  }
+  elemsize = RoundUp(elemsize, typeAttrs.GetAlign());
+  constexpr int64 bitsPerByte = 8;
+  int64 offset = static_cast<uint64>(sum) * elemsize * static_cast<uint64>(bitsPerByte);
+  if (GetElemType()->GetKind() == kTypeArray && indexArray.size() > dim) {
+    std::vector<int64> subIndexArray(indexArray.begin() + dim, indexArray.end());
+    offset += static_cast<MIRArrayType*>(GetElemType())->GetBitOffsetFromArrayAddress(subIndexArray);
+  }
+  return offset;
+}
+
+size_t MIRArrayType::ElemNumber() {
+  size_t elemNum = 1;
+  for (uint16 id = 0; id < dim; ++id) {
+    elemNum *= sizeArray[id];
+  }
+
+  auto elemType = GetElemType();
+  if (elemType->GetKind() == kTypeArray) {
+    elemNum *= static_cast<MIRArrayType*>(elemType)->ElemNumber();
+  }
+  return elemNum;
+}
+
+MIRType *MIRFarrayType::GetElemType() const {
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(elemTyIdx);
+}
+
+bool MIRFarrayType::EqualTo(const MIRType &type) const {
+  if (type.GetKind() != typeKind) {
+    return false;
+  }
+  const auto &pType = static_cast<const MIRFarrayType&>(type);
+  return elemTyIdx == pType.GetElemTyIdx();
+}
+
+std::string MIRFarrayType::GetMplTypeName() const {
+  std::stringstream ss;
+  ss << "<[] ";
+  MIRType *elemType = GetElemType();
+  ss << elemType->GetMplTypeName();
+  ss << ">";
+  return ss.str();
+}
+
+bool MIRFarrayType::HasFields() const {
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(elemTyIdx);
+  return elemType->HasFields();
+}
+
+uint32 MIRFarrayType::NumberOfFieldIDs() const {
+  if (fieldsNum != kInvalidFieldNum) {
+    return fieldsNum;
+  }
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(elemTyIdx);
+  fieldsNum = elemType->NumberOfFieldIDs();
+  return fieldsNum;
+}
+
+MIRStructType *MIRFarrayType::EmbeddedStructType() {
+  MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(elemTyIdx);
+  return elemType->EmbeddedStructType();
+}
+
+int64 MIRFarrayType::GetBitOffsetFromArrayAddress(int64 arrayIndex) const {
+  size_t elemsize = GetElemType()->GetSize();
+  if (elemsize == 0 || arrayIndex == 0) {
+    return 0;
+  }
+  uint32 elemAlign = GetElemType()->GetAlign();
+  elemsize = RoundUp(elemsize, elemAlign);
+  constexpr int64 bitsPerByte = 8;
+  return arrayIndex * static_cast<int64>(elemsize) * bitsPerByte;
+}
+
+bool MIRFuncType::EqualTo(const MIRType &type) const {
+  if (type.GetKind() != typeKind) {
+    return false;
+  }
+  const auto &pType = static_cast<const MIRFuncType&>(type);
+  return (pType.retTyIdx == retTyIdx && pType.paramTypeList == paramTypeList &&
+          pType.funcAttrs == funcAttrs && pType.paramAttrsList == paramAttrsList &&
+          pType.retAttrs == retAttrs);
+}
+
+static bool TypeCompatible(const TyIdx &typeIdx1, const TyIdx &typeIdx2) {
+  if (typeIdx1 == typeIdx2) {
+    return true;
+  }
+  MIRType *type1 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx1);
+  MIRType *type2 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx2);
+  if (type1 == nullptr || type2 == nullptr) {
+    // this means we saw the use of this symbol before def.
+    return false;
+  }
+  while (type1->IsMIRPtrType() || type1->IsMIRArrayType()) {
+    if (type1->IsMIRPtrType()) {
+      if (!type2->IsMIRPtrType()) {
+        return false;
+      }
+      type1 = static_cast<MIRPtrType *>(type1)->GetPointedType();
+      type2 = static_cast<MIRPtrType *>(type2)->GetPointedType();
+    } else {
+      if (!type2->IsMIRArrayType()) {
+        return false;
+      }
+      type1 = static_cast<MIRArrayType *>(type1)->GetElemType();
+      type2 = static_cast<MIRArrayType *>(type2)->GetElemType();
+    }
+  }
+  if (type1 == type2) {
+    return true;
+  }
+  if (type1->GetPrimType() == PTY_void || type2->GetPrimType() == PTY_void) {
+    return true;
+  }
+  if (type1->IsIncomplete() || type2->IsIncomplete()) {
+    return true;
+  }
+  return false;
+}
+
+bool MIRFuncType::CompatibleWith(const MIRType &type) const {
+  if (type.GetKind() != typeKind) {
+    return false;
+  }
+  const auto &pType = static_cast<const MIRFuncType&>(type);
+  if (!TypeCompatible(pType.retTyIdx, retTyIdx)) {
+    return false;
+  }
+  if (pType.paramTypeList.size() != paramTypeList.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < paramTypeList.size(); i++) {
+    if (!TypeCompatible(pType.GetNthParamType(i), GetNthParamType(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MIRBitFieldType::EqualTo(const MIRType &type) const {
+  if (type.GetKind() != typeKind || type.GetPrimType() != primType) {
+    return false;
+  }
+  const auto &pType = static_cast<const MIRBitFieldType&>(type);
+  return pType.fieldSize == fieldSize;
+}
+
+bool MIRStructType::EqualTo(const MIRType &type) const {
+  if (type.GetKind() != typeKind) {
+    return false;
+  }
+  if (type.GetNameStrIdx() != nameStrIdx) {
+    return false;
+  }
+
+  ASSERT(type.IsStructType(), "p is null in MIRStructType::EqualTo");
+  const MIRStructType *p = static_cast<const MIRStructType*>(&type);
+  if (typeAttrs != p->typeAttrs) {
+    return false;
+  }
+  if (fields != p->fields) {
+    return false;
+  }
+  if (staticFields != p->staticFields) {
+    return false;
+  }
+  if (parentFields != p->parentFields) {
+    return false;
+  }
+  if (methods != p->methods) {
+    return false;
+  }
+  return true;
+}
+
+std::string MIRStructType::GetCompactMplTypeName() const {
+  return GlobalTables::GetStrTable().GetStringFromStrIdx(nameStrIdx);
+}
+
+MIRType *MIRStructType::GetElemType(uint32 n) const {
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetElemTyIdx(n));
+}
+
+MIRType *MIRStructType::GetFieldType(FieldID fieldID) {
+  if (fieldID == 0) {
+    return this;
+  }
+  const FieldPair &fieldPair = TraverseToFieldRef(fieldID);
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+}
+
+bool MIRStructType::IsLocal() const {
+  return GlobalTables::GetGsymTable().GetStIdxFromStrIdx(nameStrIdx).Idx() != 0;
+}
+
+std::string MIRStructType::GetMplTypeName() const {
+  std::stringstream ss;
+  ss << "<$";
+  ss << GlobalTables::GetStrTable().GetStringFromStrIdx(nameStrIdx);
+  ss << ">";
+  return ss.str();
+}
+
+bool MIRClassType::EqualTo(const MIRType &type) const {
+  if (type.GetKind() != typeKind) {
+    return false;
+  }
+  bool structeq = MIRStructType::EqualTo(type);
+  if (!structeq) {
+    return false;
+  }
+
+  const MIRClassType &classty = static_cast<const MIRClassType &>(type);
+  // classes have parent except empty/thirdparty classes
+  if (parentTyIdx != classty.parentTyIdx) {
+    return false;
+  }
+
+  if (interfacesImplemented != classty.interfacesImplemented) {
+    return false;
+  }
+  if (info != classty.info) {
+    return false;
+  }
+  if (infoIsString != classty.infoIsString) {
+    return false;
+  }
+  return true;
+}
+
+bool MIRInterfaceType::EqualTo(const MIRType &type) const {
+  if (type.GetKind() != typeKind) {
+    return false;
+  }
+  bool structeq = MIRStructType::EqualTo(type);
+  if (!structeq) {
+    return false;
+  }
+
+  const MIRInterfaceType &interfacety = static_cast<const MIRInterfaceType &>(type);
+  if (parentsTyIdx != interfacety.parentsTyIdx) {
+    return false;
+  }
+  if (info != interfacety.info) {
+    return false;
+  }
+  if (infoIsString != interfacety.infoIsString) {
+    return false;
+  }
+  return true;
+}
+
+bool MIRTypeByName::EqualTo(const MIRType &type) const {
+  return type.GetKind() == typeKind && type.GetNameStrIdx() == nameStrIdx && type.IsNameIsLocal() == nameIsLocal;
+}
+
+bool MIRTypeParam::EqualTo(const MIRType &type) const {
+  return type.GetKind() == typeKind && type.GetNameStrIdx() == nameStrIdx;
+}
+
+bool MIRInstantVectorType::EqualTo(const MIRType &type) const {
+  if (type.GetKind() != typeKind) {
+    return false;
+  }
+  const auto &pty = static_cast<const MIRInstantVectorType&>(type);
+  return (instantVec == pty.GetInstantVec());
+}
+
+bool MIRGenericInstantType::EqualTo(const MIRType &type) const {
+  if (!MIRInstantVectorType::EqualTo(type)) {
+    return false;
+  }
+  const auto &pType = static_cast<const MIRGenericInstantType&>(type);
+  return genericTyIdx == pType.GetGenericTyIdx();
+}
+
+// in the search, curfieldid is being decremented until it reaches 1
+FieldPair MIRStructType::TraverseToFieldRef(FieldID &fieldID) const {
+  if (!fields.size()) {
+    return FieldPair(GStrIdx(0), TyIdxFieldAttrPair(TyIdx(0), FieldAttrs()));
+  }
+
+  uint32 fieldIdx = 0;
+  FieldPair curPair = fields[0];
+  while (fieldID > 1) {
+    --fieldID;
+    MIRType *curFieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(curPair.second.first);
+    MIRStructType *subStructTy = curFieldType->EmbeddedStructType();
+    if (subStructTy != nullptr) {
+      curPair = subStructTy->TraverseToFieldRef(fieldID);
+      if (fieldID == 1 && curPair.second.first != TyIdx(0)) {
+        return curPair;
+      }
+    }
+    ++fieldIdx;
+    if (fieldIdx == fields.size()) {
+      return FieldPair(GStrIdx(0), TyIdxFieldAttrPair(TyIdx(0), FieldAttrs()));
+    }
+    curPair = fields[fieldIdx];
+  }
+  return curPair;
+}
+
+FieldPair MIRStructType::TraverseToField(FieldID fieldID) const {
+  if (fieldID >= 0) {
+    return TraverseToFieldRef(fieldID);
+  }
+  // in parentfields
+  uint32 parentFieldIdx = -fieldID;
+  if (parentFields.empty() || parentFieldIdx > parentFields.size()) {
+    return { GStrIdx(0), TyIdxFieldAttrPair(TyIdx(0), FieldAttrs()) };
+  }
+  return parentFields[parentFieldIdx - 1];
+}
+
+static bool TraverseToFieldInFields(const FieldVector &fields, const GStrIdx &fieldStrIdx, FieldPair &field) {
+  for (auto &fp : fields) {
+    if (fp.first == fieldStrIdx) {
+      field = fp;
+      return true;
+    }
+  }
+  return false;
+}
+
+FieldPair MIRStructType::TraverseToField(GStrIdx fieldStrIdx) const {
+  FieldPair fieldPair;
+  if ((!fields.empty() && TraverseToFieldInFields(fields, fieldStrIdx, fieldPair)) ||
+      (!staticFields.empty() && TraverseToFieldInFields(staticFields, fieldStrIdx, fieldPair)) ||
+      TraverseToFieldInFields(parentFields, fieldStrIdx, fieldPair)) {
+    return fieldPair;
+  }
+  return { GStrIdx(0), TyIdxFieldAttrPair(TyIdx(0), FieldAttrs()) };
+}
+
+bool MIRStructType::HasVolatileFieldInFields(const FieldVector &fieldsOfStruct) const {
+  for (const auto &field : fieldsOfStruct) {
+    if (field.second.second.GetAttr(FLDATTR_volatile) ||
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(field.second.first)->HasVolatileField()) {
+      hasVolatileField = true;
+      return true;
+    }
+  }
+  hasVolatileField = false;
+  return false;
+}
+
+// go through all the fields to check if there is volatile attribute set;
+bool MIRStructType::HasVolatileField() const {
+  if (hasVolatileFieldSet) {
+    return hasVolatileField;
+  }
+  hasVolatileFieldSet = true;
+  return HasVolatileFieldInFields(fields) || HasVolatileFieldInFields(parentFields);
+}
+
+int64 MIRStructType::GetBitOffsetFromUnionBaseAddr(FieldID fieldID) const {
+  CHECK_FATAL(fieldID <= static_cast<FieldID>(NumberOfFieldIDs()), "GetBitOffsetFromUnionBaseAddr: fieldID too large");
+  if (fieldID == 0) {
+    return 0;
+  }
+
+  FieldID curFieldID = 1;
+  FieldVector fieldPairs = GetFields();
+  // for unions, bitfields are treated as non-bitfields
+  for (FieldPair field : fieldPairs) {
+    TyIdx fieldTyIdx = field.second.first;
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    if (curFieldID == fieldID) {
+      // target field id is found
+      // offset of field in union direcly(i.e. not embedded in other struct) is zero.
+      return 0;
+    } else {
+      MIRStructType *subStructType = fieldType->EmbeddedStructType();
+      if (subStructType == nullptr) {
+        // field is not a complex structure, no extra field id in it, just inc and continue to next field
+        curFieldID++;
+      } else {
+        // if target field id is in the embedded structure, we should go into it by recursively call
+        // otherwise, just add the field-id number of the embedded structure, and continue to next field
+        if ((curFieldID + static_cast<FieldID>(subStructType->NumberOfFieldIDs())) < fieldID) {
+          // 1 represents subStructType itself
+          curFieldID += static_cast<FieldID>(subStructType->NumberOfFieldIDs()) + 1;
+        } else {
+          return subStructType->GetBitOffsetFromBaseAddr(fieldID - curFieldID);
+        }
+      }
+    }
+  }
+  CHECK_FATAL(false, "GetBitOffsetFromUnionBaseAddr() fails to find field");
+  return kOffsetUnknown;
+}
+
+int64 MIRStructType::GetBitOffsetFromStructBaseAddr(FieldID fieldID) const {
+  CHECK_FATAL(fieldID <= static_cast<FieldID>(NumberOfFieldIDs()), "GetBitOffsetFromUnionBaseAddr: fieldID too large");
+  if (fieldID == 0) {
+    return 0;
+  }
+
+  uint64 allocedSize = 0; // space need for all fields before currentField
+  uint64 allocedBitSize = 0;
+  FieldID curFieldID = 1;
+  constexpr uint32 bitsPerByte = 8; // 8 bits per byte
+  FieldVector fieldPairs = GetFields();
+  // process the struct fields
+  // There are 3 possible kinds of field in a MIRStructureType:
+  //  case 1 : bitfield (including zero-width bitfield);
+  //  case 2 : primtive field;
+  //  case 3 : normal (empty/non-empty) structure(struct/union) field;
+  for (FieldPair field : fieldPairs) {
+    TyIdx fieldTyIdx = field.second.first;
+    auto fieldAttr = field.second.second;
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    uint32 fieldBitSize = static_cast<MIRBitFieldType*>(fieldType)->GetFieldSize();
+    size_t fieldTypeSize = fieldType->GetSize();
+    uint32 fieldTypeSizeBits = static_cast<uint32>(fieldTypeSize) * bitsPerByte;
+    auto originAlign = fieldType->GetAlign();
+    uint32 fieldAlign = fieldAttr.IsPacked() ? 1 : std::min(GetTypeAttrs().GetPack(), originAlign);
+    auto fieldAlignBits = fieldAlign * bitsPerByte;
+    // case 1 : bitfield (including zero-width bitfield);
+    if (fieldType->GetKind() == kTypeBitField) {
+      fieldTypeSizeBits = static_cast<uint32>(GetPrimTypeSize(fieldType->GetPrimType())) * bitsPerByte;
+      // Is this field is crossing the align boundary of its base type?
+      // for example:
+      // struct Expamle {
+      //      int32 fld1 : 30;
+      //      int32 fld2 : 3;  // 30 + 3 > 32(= int32 align), cross the align boundary, start from next int32 boundary
+      // }
+      //
+      // Is field a zero-width bit field?
+      // Refer to C99 standard (§6.7.2.1) :
+      // > As a special case, a bit-field structure member with a width of 0 indicates that no further
+      // > bit-field is to be packed into the unit in which the previous bit-field, if any, was placed.
+      //
+      // We know that A zero-width bit field can cause the next field to be aligned on the next container
+      // boundary where the container is the same size as the underlying type of the bit field.
+      // for example:
+      // struct Example {
+      //     int32 fld1 : 5;
+      //     int32      : 0; // force the next field to be aligned on int32 align boundary
+      //     int32 fld3 : 4;
+      // }
+      if ((!GetTypeAttrs().IsPacked() && ((allocedBitSize / fieldTypeSizeBits) !=
+          ((allocedBitSize + fieldBitSize - 1u) / fieldTypeSizeBits))) ||
+          fieldBitSize == 0) {
+        // the field is crossing the align boundary of its base type;
+        // align alloced_size_in_bits to fieldAlign
+        allocedBitSize = RoundUp(allocedBitSize, fieldTypeSizeBits);
+      }
+
+      // target field id is found
+      if (curFieldID == fieldID) {
+        return static_cast<int64>(allocedBitSize);
+      } else {
+        ++curFieldID;
+      }
+      allocedBitSize += fieldBitSize;
+      fieldAlignBits = (fieldAlignBits) != 0 ? fieldAlignBits : fieldTypeSizeBits;
+      allocedSize = std::max(allocedSize, RoundUp(allocedBitSize, fieldAlignBits) / bitsPerByte);
+      continue;
+    } // case 1 end
+
+    bool leftOverBits = false;
+    uint64 offset = 0;
+    // no bit field before current field
+    if (allocedBitSize == allocedSize * bitsPerByte) {
+      allocedSize = RoundUp(allocedSize, fieldAlign);
+      offset = allocedSize;
+    } else {
+      // still some leftover bits on allocated words, we calculate things based on bits then.
+      if (allocedBitSize / fieldAlignBits != (allocedBitSize + fieldTypeSizeBits - 1) / fieldAlignBits) {
+        // the field is crossing the align boundary of its base type
+        allocedBitSize = RoundUp(allocedBitSize, static_cast<uint32>(fieldAlignBits));
+      }
+      allocedSize = RoundUp(allocedSize, fieldAlign);
+      offset = (allocedBitSize / fieldAlignBits) * fieldAlign;
+      leftOverBits = true;
+    }
+    // target field id is found
+    if (curFieldID == fieldID) {
+      return static_cast<int64>(offset * bitsPerByte);
+    }
+    MIRStructType *subStructType = fieldType->EmbeddedStructType();
+    // case 2 : primtive field;
+    if (subStructType == nullptr) {
+      ++curFieldID;
+    } else {
+      // case 3 : normal (empty/non-empty) structure(struct/union) field;
+      // if target field id is in the embedded structure, we should go into it by recursively call
+      // otherwise, just add the field-id number of the embedded structure, and continue to next field
+      if ((curFieldID + static_cast<FieldID>(subStructType->NumberOfFieldIDs())) < fieldID) {
+        curFieldID += static_cast<FieldID>(subStructType->NumberOfFieldIDs()) + 1; // 1 represents subStructType itself
+      } else {
+        int64 result = subStructType->GetBitOffsetFromBaseAddr(fieldID - curFieldID);
+        return result + static_cast<int64>(allocedSize * bitsPerByte);
+      }
+    }
+
+    if (leftOverBits) {
+      allocedBitSize += fieldTypeSizeBits;
+      allocedSize = std::max(allocedSize, RoundUp(allocedBitSize, static_cast<uint32>(fieldAlignBits)) / bitsPerByte);
+    } else {
+      allocedSize += fieldTypeSize;
+      allocedBitSize = allocedSize * bitsPerByte;
+    }
+  }
+  CHECK_FATAL(false, "GetBitOffsetFromStructBaseAddr() fails to find field");
+  return kOffsetUnknown;
+}
+
+int64 MIRStructType::GetBitOffsetFromBaseAddr(FieldID fieldID) const {
+  CHECK_FATAL(fieldID <= static_cast<FieldID>(NumberOfFieldIDs()), "GetBitOffsetFromBaseAddr: fieldID too large");
+  if (fieldID == 0) {
+    return 0;
+  }
+  switch (GetKind()) {
+    case kTypeClass: {
+      // NYI: should know class layout, for different language, the result is different
+      return kOffsetUnknown; // Invalid offset
+    }
+    case kTypeUnion: {
+      return GetBitOffsetFromUnionBaseAddr(fieldID);
+    }
+    case kTypeStruct: {
+      return GetBitOffsetFromStructBaseAddr(fieldID);
+    }
+    default: {
+      CHECK_FATAL(false, "Wrong type kind for MIRStructType!");
+    }
+  }
+  CHECK_FATAL(false, "Should never reach here!");
+  return kOffsetUnknown;
+}
+
+// Whether the memory layout of struct has paddings
+bool MIRStructType::HasPadding() const {
+  size_t sumValidSize = 0;
+  for (uint32 i = 0; i < fields.size(); ++i) {
+    TyIdxFieldAttrPair pair = GetTyidxFieldAttrPair(i);
+    MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pair.first);
+    if (fieldType->IsStructType() && static_cast<MIRStructType*>(fieldType)->HasPadding()) {
+      return true;
+    }
+    sumValidSize += fieldType->GetSize();
+  }
+  if (sumValidSize < this->GetSize()) {
+    return true;
+  }
+  return false;
+}
+
+// set hasVolatileField to true if parent type has volatile field, otherwise flase.
+static bool ParentTypeHasVolatileField(const TyIdx parentTyIdx, bool &hasVolatileField) {
+  hasVolatileField = (GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx)->HasVolatileField());
+  return hasVolatileField;
+}
+
+// go through all the fields to check if there is volatile attribute set;
+bool MIRClassType::HasVolatileField() const {
+  return MIRStructType::HasVolatileField() ||
+         (parentTyIdx != 0u && ParentTypeHasVolatileField(parentTyIdx, hasVolatileField));
+}
+
+// go through all the fields to check if there is volatile attribute set;
+bool MIRInterfaceType::HasVolatileField() const {
+  if (MIRStructType::HasVolatileField()) {
+    return true;
+  }
+  for (TyIdx parentTypeIdx : parentsTyIdx) {
+    if (ParentTypeHasVolatileField(parentTypeIdx, hasVolatileField)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MIRStructType::HasTypeParamInFields(const FieldVector &fieldsOfStruct) const {
+  for (const FieldPair &field : fieldsOfStruct) {
+    if (field.second.second.GetAttr(FLDATTR_generic)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// go through all the fields to check if there is generic attribute set;
+bool MIRStructType::HasTypeParam() const {
+  return HasTypeParamInFields(fields) || HasTypeParamInFields(parentFields);
+}
+
+bool MIRClassType::HasTypeParam() const {
+  return MIRStructType::HasTypeParam() ||
+         (parentTyIdx != 0u && GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx)->HasTypeParam());
+}
+
+bool MIRInterfaceType::HasTypeParam() const {
+  if (MIRStructType::HasTypeParam()) {
+    return true;
+  }
+  // check if the parent classes have type parameter
+  for (TyIdx parentTypeIdx : parentsTyIdx) {
+    if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTypeIdx)->HasTypeParam()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+uint32 MIRClassType::NumberOfFieldIDs() const {
+  if (fieldsNum != kInvalidFieldNum) {
+    return fieldsNum;
+  }
+  size_t parentFieldIDs = 0;
+  if (parentTyIdx != TyIdx(0)) {
+    MIRType *parentty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx);
+    parentFieldIDs = parentty->NumberOfFieldIDs();
+  }
+  fieldsNum = parentFieldIDs + MIRStructType::NumberOfFieldIDs();
+  return fieldsNum;
+}
+
+FieldPair MIRClassType::TraverseToFieldRef(FieldID &fieldID) const {
+  if (parentTyIdx != 0u) {
+    auto *parentClassType =
+        static_cast<MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx));
+    if (parentClassType != nullptr) {
+      --fieldID;
+      const FieldPair &curPair = parentClassType->TraverseToFieldRef(fieldID);
+      if (fieldID == 1 && curPair.second.first != 0u) {
+        return curPair;
+      }
+    }
+  }
+  return MIRStructType::TraverseToFieldRef(fieldID);
+}
+
+// fields in interface are all static and are global, won't be accessed through fields
+FieldPair MIRInterfaceType::TraverseToFieldRef(FieldID &fieldID [[maybe_unused]]) const {
+  return { GStrIdx(0), TyIdxFieldAttrPair(TyIdx(0), FieldAttrs()) };
+}
+
+bool MIRPtrType::IsPointedTypeVolatile(int fieldID) const {
+  if (typeAttrs.GetAttr(ATTR_volatile)) {
+    return true;
+  }
+  MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetPointedTyIdx());
+  return pointedTy->IsVolatile(fieldID);
+}
+
+bool MIRPtrType::IsUnsafeType() const {
+  return GetTypeAttrs().GetAttr(ATTR_may_alias);
+}
+
+bool MIRPtrType::IsVoidPointer() const {
+  return pointedTyIdx == PTY_void;
+}
+
+size_t MIRPtrType::GetSize() const { return GetPointerSize(); }
+uint32 MIRPtrType::GetAlign() const { return GetPointerSize(); }
+
+TyIdxFieldAttrPair MIRPtrType::GetPointedTyIdxFldAttrPairWithFieldID(FieldID fldId) const {
+  if (fldId == 0) {
+    return TyIdxFieldAttrPair(pointedTyIdx, FieldAttrs());
+  }
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointedTyIdx);
+  MIRStructType *structTy = ty->EmbeddedStructType();
+  if (structTy == nullptr) {
+    // this can happen due to casting in C; just return the pointed to type
+    return TyIdxFieldAttrPair(pointedTyIdx, FieldAttrs());
+  }
+  return structTy->TraverseToField(fldId).second;
+}
+
+TyIdx MIRPtrType::GetPointedTyIdxWithFieldID(FieldID fieldID) const {
+  return GetPointedTyIdxFldAttrPairWithFieldID(fieldID).first;
+}
+
+std::string MIRPtrType::GetMplTypeName() const {
+  std::stringstream ss;
+  ss << "<* ";
+  MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointedTyIdx);
+  CHECK_FATAL(pointedType != nullptr, "invalid ptr type");
+  ss << pointedType->GetMplTypeName();
+  ss << ">";
+  return ss.str();
+}
+
+std::string MIRPtrType::GetCompactMplTypeName() const {
+  MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointedTyIdx);
+  CHECK_FATAL(pointedType != nullptr, "invalid ptr type");
+  return pointedType->GetCompactMplTypeName();
+}
+
+MIRFuncType *MIRPtrType::GetPointedFuncType() const {
+  MIRType *pointedType = GetPointedType();
+  if (pointedType->GetKind() == kTypeFunction) {
+    return static_cast<MIRFuncType *>(pointedType);
+  }
+  if (pointedType->GetKind() == kTypePointer) {
+    MIRPtrType *pointedPtrType = static_cast<MIRPtrType *>(pointedType);
+    if (pointedPtrType->GetPointedType()->GetKind() == kTypeFunction) {
+      return static_cast<MIRFuncType *>(pointedPtrType->GetPointedType());
+    }
+  }
+  return nullptr;
+}
+
+uint32 MIRStructType::NumberOfFieldIDs() const {
+  if (fieldsNum != kInvalidFieldNum) {
+    return fieldsNum;
+  }
+  fieldsNum = 0;
+  for (FieldPair curpair : fields) {
+    ++fieldsNum;
+    MIRType *curfieldtype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(curpair.second.first);
+    fieldsNum += curfieldtype->NumberOfFieldIDs();
+  }
+  return fieldsNum;
+}
+
+TypeAttrs FieldAttrs::ConvertToTypeAttrs() const {
+  TypeAttrs attr;
+  constexpr uint32 maxAttrNum = 64;
+  for (uint32 i = 0; i < maxAttrNum; ++i) {
+    if ((attrFlag & (1ULL << i)) == 0) {
+      continue;
+    }
+    auto attrKind = static_cast<FieldAttrKind>(i);
+    switch (attrKind) {
+#define FIELD_ATTR
+#define ATTR(STR)               \
+    case FLDATTR_##STR:         \
+      attr.SetAttr(ATTR_##STR); \
+      break;
+#include "all_attributes.def"
+#undef ATTR
+#undef FIELD_ATTR
+      default:
+        ASSERT(false, "unknown TypeAttrs");
+        break;
+    }
+  }
+  return attr;
+}
+
+MIRType *GetElemType(const MIRType &arrayType) {
+  if (arrayType.GetKind() == kTypeArray) {
+    return static_cast<const MIRArrayType &>(arrayType).GetElemType();
+  } else if (arrayType.GetKind() == kTypeFArray) {
+    return static_cast<const MIRFarrayType &>(arrayType).GetElemType();
+  } else if (arrayType.GetKind() == kTypeJArray) {
+    return static_cast<const MIRJarrayType &>(arrayType).GetElemType();
+  }
+  return nullptr;
+}
+}  // namespace maple
+#endif  // MIR_FEATURE_FULL
diff --git a/src/mapleall/maple_ir/src/mpl2mpl_options.cpp b/src/mapleall/maple_ir/src/mpl2mpl_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..615baa61d0d70f7a68c96d6e298476ccac136be9
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mpl2mpl_options.cpp
@@ -0,0 +1,523 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <string>
+#include "driver_options.h"
+
+namespace opts::mpl2mpl {
+
+maplecl::Option<std::string> dumpPhase({"--dump-phase"},
+                                  "  --dump-phase                \tEnable debug trace for"
+                                  " specified phase (can only specify once)\n"
+                                  "                              \t--dump-phase=PHASENAME\n",
+                                  {mpl2mplCategory});
+
+maplecl::Option<std::string> skipPhase({"--skip-phase"},
+                                  "  --skip-phase                \tSkip the phase when adding it to phase manager\n"
+                                  "                              \t--skip-phase=PHASENAME\n",
+                                  {mpl2mplCategory});
+
+maplecl::Option<std::string> skipFrom({"--skip-from"},
+                                 "  --skip-from                 \tSkip all remaining phases including PHASENAME\n"
+                                 "                              \t--skip-from=PHASENAME\n",
+                                 {mpl2mplCategory});
+
+maplecl::Option<std::string> skipAfter({"--skip-after"},
+                                  "  --skip-after                \tSkip all remaining phases after PHASENAME\n"
+                                  "                              \t--skip-after=PHASENAME\n",
+                                  {mpl2mplCategory});
+
+maplecl::Option<std::string> dumpFunc({"--dump-func"},
+                                 "  --dump-func                 \tDump/trace only for functions"
+                                 " whose names contain FUNCNAME as substring\n"
+                                 "                              \t(can only specify once)\n"
+                                 "                              \t--dump-func=FUNCNAME\n",
+                                 {mpl2mplCategory});
+
+maplecl::Option<bool> quiet({"--quiet"},
+                       "  --quiet                     \tDisable brief trace messages with phase/function names\n"
+                       "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
+                       {mpl2mplCategory},
+                       maplecl::DisableWith("--no-quiet"));
+
+maplecl::Option<bool> mapleLinker({"--maplelinker"},
+                             "  --maplelinker               \tGenerate MUID symbol tables and references\n"
+                             "  --no-maplelinker            \tDon't Generate MUID symbol tables and references\n",
+                             {mpl2mplCategory},
+                             maplecl::DisableWith("--no-maplelinker"));
+
+maplecl::Option<bool> regNativeFunc({"--regnativefunc"},
+                               "  --regnativefunc             \tGenerate native stub function"
+                               " to support JNI registration and calling\n"
+                               "  --no-regnativefunc          \tDisable regnativefunc\n",
+                               {mpl2mplCategory},
+                               maplecl::DisableWith("--no-regnativefunc"));
+
+maplecl::Option<bool> inlineWithProfile({"--inline-with-profile"},
+                                   "  --inline-with-profile       \tEnable profile-based inlining\n"
+                                   "  --no-inline-with-profile    \tDisable profile-based inlining\n",
+                                   {mpl2mplCategory},
+                                   maplecl::DisableWith("--no-inline-with-profile"));
+
+maplecl::Option<bool> inlineOpt({"--inline"},
+                           "  --inline                    \tEnable function inlining\n"
+                           "  --no-inline                 \tDisable function inlining\n",
+                           {mpl2mplCategory},
+                           maplecl::DisableWith("--no-inline"));
+
+maplecl::Option<bool> ipaClone({"--ipa-clone"},
+                          "  --ipa-clone                 \tEnable ipa constant_prop and clone\n"
+                          "  --no-ipa-clone              \tDisable ipa constant_prop and clone\n",
+                          {mpl2mplCategory},
+                           maplecl::DisableWith("--no-ipa-clone"));
+
+maplecl::Option<bool> ginlineOpt({"--ginline"},
+                          "  --ginline                  \tEnable greedy inline\n"
+                          "  --no-ginline               \tDisable greedy inline\n",
+                          {mpl2mplCategory},
+                           maplecl::DisableWith("--no-ginline"));
+
+maplecl::Option<std::string> noInlineFunc({"--no-inlinefunclist"},
+                                     "  --no-inlinefunclist=list    \tDo not inline function in this list\n",
+                                     {mpl2mplCategory});
+
+maplecl::Option<std::string> importFileList({"--importfilelist"},
+                                       "  --importfilelist=list    \tImport there files to do cross module analysis\n",
+                                       {mpl2mplCategory});
+
+maplecl::Option<bool> crossModuleInline({"--cross-module-inline"},
+                                   "  --cross-module-inline       \tEnable cross-module inlining\n"
+                                   "  --no-cross-module-inline    \tDisable cross-module inlining\n",
+                                   {mpl2mplCategory},
+                                   maplecl::DisableWith("--no-cross-module-inline"));
+
+maplecl::Option<uint32_t> inlineSmallFunctionThreshold({"--inline-small-function-threshold"},
+                                                  "  --inline-small-function-threshold=15"
+                                                  "            \tThreshold for inlining small function\n",
+                                                  {mpl2mplCategory});
+
+maplecl::Option<uint32_t> inlineHotFunctionThreshold({"--inline-hot-function-threshold"},
+                                                "  --inline-hot-function-threshold=30"
+                                                "              \tThreshold for inlining hot function\n",
+                                                {mpl2mplCategory});
+
+maplecl::Option<uint32_t> inlineRecursiveFunctionThreshold({"--inline-recursive-function-threshold"},
+                                                      "  --inline-recursive-function-threshold=15"
+                                                      "              \tThreshold for inlining recursive function\n",
+                                                      {mpl2mplCategory});
+
+maplecl::Option<uint32_t> inlineDepth({"--inline-depth"},
+                                 "  --inline-depth=8              \tMax call graph depth for inlining\n",
+                                 {mpl2mplCategory});
+
+maplecl::Option<uint32_t> inlineModuleGrow({"--inline-module-growth"},
+                                      "  --inline-module-growth=100000"
+                                      "                   \tThreshold for maxmium code size growth rate (10%)\n",
+                                      {mpl2mplCategory});
+
+maplecl::Option<uint32_t> inlineColdFuncThresh({"--inline-cold-function-threshold"},
+                                          "  --inline-cold-function-threshold=3"
+                                          "              \tThreshold for inlining hot function\n",
+                                          {mpl2mplCategory});
+
+maplecl::Option<bool> respectAlwaysInline({"--respect-always-inline"},
+                          "  --respect-always-inline                 \tEnable always_inline\n"
+                          "  --no-respect-always-inline              \tDisable always_inline\n",
+                          {mpl2mplCategory},
+                           maplecl::DisableWith("--no-respect-always-inline"));
+
+maplecl::Option<uint32_t> ginlineMaxNondeclaredInlineCallee({"--ginline-max-nondeclared-inline-callee"},
+                                      ""
+                                      "",
+                                     {mpl2mplCategory});
+
+maplecl::Option<uint32_t> ginlineMaxDepthIgnoreGrowthLimit({"--ginline-max-depth-ignore-growth-limit"},
+                                      ""
+                                      "",
+                                     {mpl2mplCategory});
+
+maplecl::Option<uint32_t> ginlineSmallFunc({"--ginline-small-func"},
+                                      ""
+                                      "",
+                                     {mpl2mplCategory});
+
+maplecl::Option<uint32_t> ginlineRelaxSmallFuncDecalredInline({"--ginline-relax-small-func-declared-inline"},
+                                      ""
+                                      "",
+                                     {mpl2mplCategory});
+
+maplecl::Option<uint32_t> ginlineRelaxSmallFuncCanbeRemoved({"--ginline-relax-small-func-canbe-removed"},
+                                      ""
+                                      "",
+                                     {mpl2mplCategory});
+
+maplecl::Option<std::string> callsiteProfilePath({"--callsite-profile-path"},
+                                      ""
+                                      "",
+                                     {mpl2mplCategory});
+
+maplecl::Option<bool> inlineToAllCallers({"--inline-to-all-callers"},
+                          "  --inline-to-all-callers                 \tEnable inline to all callers\n"
+                          "  --no-inline-to-all-callers              \tDisable inline to all callers\n",
+                          {mpl2mplCategory},
+                           maplecl::DisableWith("--no-inline-to-all-callers"));
+
+maplecl::Option<bool> ginlineAllowNondeclaredInlineSizeGrow({"--ginline-allow-nondeclared-inline-size-grow"},
+                          ""
+                          "",
+                          {mpl2mplCategory},
+                           maplecl::DisableWith("--no-ginline-allow-nondeclared-inline-size-grow"));
+
+maplecl::Option<bool> ginlineAllowIgnoreGrowthLimit({"--ginline-allow-ignore-growth-limit"},
+                          ""
+                          "",
+                          {mpl2mplCategory},
+                           maplecl::DisableWith("--no-ginline-allow-ignore-growth-limit"));
+
+maplecl::Option<uint32_t> profileHotCount({"--profile-hot-count"},
+                                     "  --profile-hot-count=1000"
+                                     "    \tA count is regarded as hot if it exceeds this number\n",
+                                     {mpl2mplCategory});
+
+maplecl::Option<uint32_t> profileColdCount({"--profile-cold-count"},
+                                      "  --profile-cold-count=10"
+                                      "     \tA count is regarded as cold if it is below this number\n",
+                                      {mpl2mplCategory});
+
+maplecl::Option<uint32_t> profileHotRate({"--profile-hot-rate"},
+                                    "  --profile-hot-rate=500000"
+                                    "   \tA count is regarded as hot if it is in the largest 50%\n",
+                                    {mpl2mplCategory});
+
+maplecl::Option<uint32_t> profileColdRate({"--profile-cold-rate"},
+                                     "  --profile-cold-rate=900000"
+                                     "  \tA count is regarded as cold if it is in the smallest 10%\n",
+                                     {mpl2mplCategory});
+
+maplecl::Option<bool> nativeWrapper({"--nativewrapper"},
+                               "  --nativewrapper             \tGenerate native wrappers [default]\n",
+                               {mpl2mplCategory},
+                               maplecl::DisableWith("--no-nativewrapper"));
+
+maplecl::Option<bool> regNativeDynamicOnly({"--regnative-dynamic-only"},
+                                      "  --regnative-dynamic-only    \tOnly Generate dynamic register code,"
+                                      " Report Fatal Msg if no implemented\n"
+                                      "  --no-regnative-dynamic-only \tDisable regnative-dynamic-only\n",
+                                      {mpl2mplCategory},
+                                      maplecl::DisableWith("--no-regnative-dynamic-only"));
+
+maplecl::Option<std::string> staticBindingList({"--static-binding-list"},
+                                          "  --static-bindig-list        \tOnly Generate static binding"
+                                          " function in file configure list\n"
+                                          "                              \t--static-bindig-list=file\n",
+                                          {mpl2mplCategory});
+
+maplecl::Option<bool> dumpBefore({"--dump-before"},
+                            "  --dump-before               \tDo extra IR dump before the specified phase\n"
+                            "  --no-dump-before            \tDon't extra IR dump before the specified phase\n",
+                            {mpl2mplCategory},
+                            maplecl::DisableWith("--no-dump-before"));
+
+maplecl::Option<bool> dumpAfter({"--dump-after"},
+                           "  --dump-after                \tDo extra IR dump after the specified phase\n"
+                           "  --no-dump-after             \tDon't extra IR dump after the specified phase\n",
+                           {mpl2mplCategory},
+                           maplecl::DisableWith("--no-dump-after"));
+
+maplecl::Option<bool> dumpMuid({"--dump-muid"},
+                          "  --dump-muid                 \tDump MUID def information into a .muid file\n"
+                          "  --no-dump-muid              \tDon't dump MUID def information into a .muid file\n",
+                          {mpl2mplCategory},
+                          maplecl::DisableWith("--no-dump-muid"));
+
+maplecl::Option<bool> emitVtableImpl({"--emitVtableImpl"},
+                                "  --emitVtableImpl            \tgenerate VtableImpl file\n"
+                                "  --no-emitVtableImpl         \tDon't generate VtableImpl file\n",
+                                {mpl2mplCategory},
+                                maplecl::DisableWith("--no-emitVtableImpl"));
+
+#if MIR_JAVA
+maplecl::Option<bool> skipVirtual({"--skipvirtual"},
+                             "  --skipvirtual\n"
+                             "  --no-skipvirtual\n",
+                             {mpl2mplCategory},
+                             maplecl::DisableWith("--no-skipvirtual"));
+#endif
+
+maplecl::Option<bool> userc({"--userc"},
+                       "  --userc                     \tEnable reference counting [default]\n"
+                       "  --no-userc                  \tDisable reference counting [default]\n",
+                       {mpl2mplCategory},
+                       maplecl::DisableWith("--no-userc"));
+
+maplecl::Option<bool> strictNaiveRc({"--strict-naiverc"},
+                               "  --strict-naiverc            \tStrict Naive RC mode,"
+                               " assume no unsafe multi-thread read/write racing\n"
+                               "  --no-strict-naiverc         \tDisable strict-naiverc\n",
+                               {mpl2mplCategory},
+                               maplecl::DisableWith("--no-strict-naiverc"));
+
+maplecl::Option<bool> rcOpt1({"--rc-opt1"},
+                        "  --rc-opt1                   \tEnable RC optimization1 [default]\n",
+                        {mpl2mplCategory},
+                        maplecl::DisableWith("--no-rc-opt1"));
+
+maplecl::Option<bool> nativeOpt({"--nativeopt"},
+                           "  --nativeopt                 \tEnable native opt\n"
+                           "  --no-nativeopt              \tDisable native opt\n",
+                           {mpl2mplCategory},
+                           maplecl::DisableWith("--no-nativeopt"));
+
+maplecl::Option<bool> o0({"-O0", "--O0"},
+                    "  -O0                         \tDo some optimization.\n",
+                    {mpl2mplCategory});
+
+maplecl::Option<bool> o2({"-O2", "--O2"},
+                    "  -O2                         \tDo some optimization.\n",
+                    {mpl2mplCategory});
+
+maplecl::Option<bool> os({"-Os", "--Os"},
+                    "  -Os                         \tOptimize for size, based on O2.\n",
+                    {mpl2mplCategory});
+
+maplecl::Option<std::string> criticalNative({"--CriticalNative"},
+                                       "  --CriticalNative            \tFor CriticalNative optimization\n"
+                                       "                              \t--CriticalNative=list_file\n",
+                                       {mpl2mplCategory});
+
+maplecl::Option<std::string> fastNative({"--FastNative"},
+                                   "  --FastNative                \tFor FastNative optimization\n"
+                                   "                              \t--FastNative=list_file\n",
+                                   {mpl2mplCategory});
+
+maplecl::Option<bool> noDot({"--nodot"},
+                       "  --nodot                     \tDisable dot file generation from cfg\n"
+                       "  --no-nodot                  \tEnable dot file generation from cfg\n",
+                       {mpl2mplCategory},
+                       maplecl::DisableWith("--no-nodot"));
+
+maplecl::Option<bool> genIrProfile({"--ir-profile-gen"},
+                              "  --ir-profile-gen              \tGen IR level Profile\n"
+                              "  --no-ir-profile-gen           \tDisable Gen IR level Profile\n",
+                              {mpl2mplCategory},
+                              maplecl::DisableWith("--no-ir-profile-gen"));
+
+maplecl::Option<bool> proFileTest({"--profile-test"},
+                             "  --profile-test              \tprofile test\n"
+                             "  --no-profile-test           \tDisable profile test\n",
+                             {mpl2mplCategory},
+                             maplecl::DisableWith("--no-profile-test"));
+
+maplecl::Option<bool> barrier({"--barrier"},
+                         "  --barrier                   \tEnable barrier insertion instead of RC insertion\n"
+                         "  --no-barrier                \tDisable barrier insertion instead of RC insertion\n",
+                         {mpl2mplCategory},
+                         maplecl::DisableWith("--no-barrier"));
+
+maplecl::Option<std::string> nativeFuncPropertyFile({"--nativefunc-property-list"},
+                                               "  --nativefunc-property-list"
+                                               "  \tGenerate native binding function stub\n"
+                                               "                              \t--nativefunc-property-list=file\n",
+                                               {mpl2mplCategory});
+
+maplecl::Option<bool> mapleLinkerNolocal({"--maplelinker-nolocal"},
+                                    "  --maplelinker-nolocal       \tDo not turn functions"
+                                    " into local when maple linker is on\n"
+                                    "  --no-maplelinker-nolocal\n",
+                                    {mpl2mplCategory},
+                                    maplecl::DisableWith("--no-maplelinker-nolocal"));
+
+maplecl::Option<uint32_t> buildApp({"--build-app"},
+                              "  --build-app[=0,1,2]         \tbuild the app dex"
+                              " 0:off, 1:method1, 2:method2, ignore:method1\n",
+                              {mpl2mplCategory},
+                              maplecl::optionalValue, maplecl::Init(1));
+
+maplecl::Option<bool> partialAot({"--partialAot"},
+                            "  --partialAot               \tenerate the detailed information for the partialAot\n",
+                            {mpl2mplCategory},
+                            maplecl::optionalValue);
+
+maplecl::Option<uint32_t> decoupleInit({"--decouple-init"},
+                                  "  --decouple-init          \tdecouple the constructor method\n",
+                                  {mpl2mplCategory},
+                                  maplecl::optionalValue, maplecl::Init(1));
+
+maplecl::Option<std::string> sourceMuid({"--source-muid"},
+                                   "  --source-muid=""            \tWrite the source file muid into the mpl file\n",
+                                   {mpl2mplCategory},
+                                   maplecl::optionalValue);
+
+maplecl::Option<bool> deferredVisit({"--deferred-visit"},
+                               "  --deferred-visit            \tGenerate deferred MCC call for undefined type\n"
+                               "  --no-deferred-visit         \tDont't generate"
+                               " deferred MCC call for undefined type\n",
+                               {mpl2mplCategory},
+                               maplecl::DisableWith("--no-deferred-visit"));
+
+maplecl::Option<bool> deferredVisit2({"--deferred-visit2"},
+                                "  --deferred-visit2"
+                                "           \tGenerate deferred MCC call(DAI2.0) for undefined type\n"
+                                "  --no-deferred-visit2"
+                                "        \tDon't generate deferred MCC call(DAI2.0) for undefined type\n",
+                                {mpl2mplCategory},
+                                maplecl::DisableWith("--no-deferred-visit2"));
+
+maplecl::Option<bool> decoupleSuper({"--decouple-super"},
+                               "  --decouple-super            \tGenerate deferred MCC call for undefined type\n"
+                               "  --no-decouple-super         \tDon't generate deferred MCC call for undefined type\n",
+                               {mpl2mplCategory},
+                               maplecl::DisableWith("--no-decouple-super"));
+
+maplecl::Option<bool> genDecoupleVtab({"--gen-decouple-vtab"},
+                                 "  --gen-decouple-vtab         \tGenerate the whole and complete vtab and itab\n"
+                                 "  --no-gen-decouple-vtab"
+                                 "      \tDon't generate the whole and complete vtab and itab\n",
+                                 {mpl2mplCategory},
+                                 maplecl::DisableWith("--no-gen-decouple-vtab"));
+
+maplecl::Option<bool> profileFunc({"--profile-func"},
+                             "  --profile-func              \tProfile function usage\n"
+                             "  --no-profile-func           \tDisable profile function usage\n",
+                             {mpl2mplCategory},
+                             maplecl::DisableWith("--no-profile-func"));
+
+maplecl::Option<std::string> dumpDevirtual({"--dump-devirtual-list"},
+                                      "  --dump-devirtual-list"
+                                      "       \tDump candidates of devirtualization into a specified file\n"
+                                      "                              \t--dump-devirtual-list=\n",
+                                      {mpl2mplCategory});
+
+maplecl::Option<std::string> readDevirtual({"--read-devirtual-list"},
+                                      "  --read-devirtual-list       \tRead in candidates of devirtualization from\n"
+                                      "                              \t a specified file and perform devirtualizatin\n"
+                                      "                              \t--read-devirtual-list=\n",
+                                      {mpl2mplCategory});
+
+maplecl::Option<bool> useWhiteClass({"--usewhiteclass"},
+                               "  --usewhiteclass"
+                               "             \tEnable use preloaded class list to reducing clinit check\n"
+                               "  --no-usewhiteclass"
+                               "          \tDisable use preloaded class list to reducing clinit check\n",
+                               {mpl2mplCategory},
+                               maplecl::DisableWith("--no-usewhiteclass"));
+
+maplecl::Option<std::string> appPackageName({"--app-package-name"},
+                                       "  --app-package-name          \tSet APP package name\n"
+                                       "                              \t--app-package-name=package_name\n",
+                                       {mpl2mplCategory},
+                                       maplecl::optionalValue);
+
+maplecl::Option<std::string> checkClInvocation({"--check_cl_invocation"},
+                                          "  --check_cl_invocation       \tFor classloader invocation checking\n"
+                                          "                              \t--check_cl_invocation=list_file\n",
+                                          {mpl2mplCategory});
+
+maplecl::Option<bool> dumpClInvocation({"--dump_cl_invocation"},
+                                  "  --dump_cl_invocation        \tFor classloader invocation dumping.\n"
+                                  "                              \tWork only if already set --check_cl_invocation\n"
+                                  "  --no-dump_cl_invocation     \tDisable dump_cl_invocation\n",
+                                  {mpl2mplCategory},
+                                  maplecl::DisableWith("--no-dump_cl_invocation"));
+
+maplecl::Option<uint32_t> warning({"--warning"},
+                             "  --warning=level             \t--warning=level\n",
+                             {mpl2mplCategory});
+
+maplecl::Option<bool> lazyBinding({"--lazy-binding"},
+                             "  --lazy-binding              \tBind class symbols lazily[default off]\n"
+                             "  --no-lazy-binding           \tDon't bind class symbols lazily\n",
+                             {mpl2mplCategory},
+                             maplecl::DisableWith("--no-lazy-binding"));
+
+maplecl::Option<bool> hotFix({"--hot-fix"},
+                        "  --hot-fix                   \tOpen for App hot fix[default off]\n"
+                        "  --no-hot-fix                \tDon't open for App hot fix\n",
+                        {mpl2mplCategory},
+                        maplecl::DisableWith("--no-hot-fix"));
+
+maplecl::Option<bool> compactMeta({"--compact-meta"},
+                             "  --compact-meta              \tEnable compact method and field meta\n"
+                             "  --no-compact-meta           \tDisable compact method and field meta\n",
+                             {mpl2mplCategory},
+                             maplecl::DisableWith("--no-compact-meta"));
+
+maplecl::Option<bool> genPGOReport({"--gen-pgo-report"},
+                              "  --gen-pgo-report            \tDisplay pgo report\n"
+                              "  --no-gen-pgo-report\n",
+                              {mpl2mplCategory},
+                              maplecl::DisableWith("--no-gen-pgo-report"));
+
+maplecl::Option<uint32_t> inlineCache({"--inlineCache"},
+                                 "  --inlineCache            \tbuild inlineCache 0,1,2,3\n",
+                                 {mpl2mplCategory},
+                                 maplecl::optionalValue, maplecl::Init(0));
+
+maplecl::Option<bool> noComment({"--no-comment"},
+                           "  --no-comment             \tbuild inlineCache 0:off, 1:open\n",
+                           {mpl2mplCategory});
+
+maplecl::Option<bool> rmNouseFunc({"--rmnousefunc"},
+                             "  --rmnousefunc            \tEnable remove no-used file-static function\n"
+                             "  --no-rmnousefunc         \tDisable remove no-used file-static function\n",
+                             {mpl2mplCategory},
+                             maplecl::DisableWith("--no-rmnousefunc"));
+
+maplecl::Option<bool> sideEffect({"--sideeffect"},
+                            "  --sideeffect      \tIPA: analysis sideeffect\n"
+                            "  --no-sideeffect          \n",
+                            {mpl2mplCategory},
+                            maplecl::DisableWith("--no-sideeffect"));
+
+maplecl::Option<bool> dumpIPA({"--dump-ipa"},
+                         "  --dump-ipa      \tIPA: dump\n"
+                         "  --no-dump-ipa          \n",
+                         {mpl2mplCategory},
+                         maplecl::DisableWith("--no-dump-ipa"));
+
+maplecl::Option<bool> wpaa({"--wpaa"},
+                      "  --wpaa      \tWhole Program Alias Analysis\n"
+                      "  --no-wpaa          \n",
+                      {mpl2mplCategory},
+                      maplecl::DisableWith("--no-wpaa"));
+
+maplecl::Option<uint32_t> numOfCloneVersions({"--num-of-clone-versions"},
+                                        "  --num-of-clone-versions=3        \tnum of clone versions\n",
+                                        {mpl2mplCategory});
+
+maplecl::Option<uint32_t> numOfImpExprLowBound({"--num-of-ImpExpr-LowBound"},
+                                          "  --num-of-ImpExpr-LowBound=3        \tnum of ImpExpr LowBound\n",
+                                          {mpl2mplCategory});
+
+maplecl::Option<uint32_t> numOfImpExprHighBound({"--num-of-ImpExpr-HighBound"},
+                                           "  --num-of-ImpExpr-LowBound=3        \tnum of ImpExpr LowBound\n",
+                                           {mpl2mplCategory});
+
+maplecl::Option<uint32_t> numOfCallSiteLowBound({"--num-of-CallSite-LowBound"},
+                                           "  --num-of-CallSite-LowBound=3        \tnum of CallSite LowBound\n",
+                                           {mpl2mplCategory});
+
+maplecl::Option<uint32_t> numOfCallSiteUpBound({"--num-of-CallSite-HighBound"},
+                                          "  --num-of-CallSite-HighBound=3        \tnum of CallSite HighBound\n",
+                                          {mpl2mplCategory});
+
+maplecl::Option<uint32_t> numOfConstpropValue({"--num-of-ConstProp-value"},
+                                         "  --num-of-CallSite-HighBound=3        \tnum of CallSite HighBound\n",
+                                         {mpl2mplCategory});
+
+maplecl::Option<size_t> outlineThreshold({"--outline-threshold"},
+                                         "  --outline-threshold=128     \tminimal insn profit number for outline \n",
+                                         {mpl2mplCategory});
+}
diff --git a/src/mapleall/maple_ir/src/mpl_dbg.cpp b/src/mapleall/maple_ir/src/mpl_dbg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7676ba3600e6e972173215480a0b43493bcd7654
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mpl_dbg.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+
+#include "bin_mplt.h"
+#include "debug_info.h"
+#include "mir_function.h"
+#include "mir_parser.h"
+#include "mir_type.h"
+#include "mpl_sighandler.h"
+#include "opcode_info.h"
+
+using namespace maple;
+
+std::unordered_set<std::string> dumpFuncSet = {};
+
+int main(int argc, char **argv) {
+  SigHandler::EnableAll();
+
+  if (argc < k2BitSize) {
+    MIR_PRINTF("usage: mpldbg foo.mpl\n");
+    exit(1);
+  }
+  std::vector<maple::MIRModule *> themodule(argc, nullptr);
+  bool useBinary = false;
+  MIRSrcLang srcLang = kSrcLangUnknown;
+  // process the options which must come first
+  maple::int32 i = 1;
+  while (argv[i][0] == '-') {
+    if (argv[i][1] == 'b' && argv[i][k2BitSize] == '\0') {
+      useBinary = true;
+    } else if (strncmp(argv[i], "-dumpfunc=", k10BitSize) == 0 && strlen(argv[i]) > k10BitSize) {
+      std::string funcName(&argv[i][k10BitSize]);
+      dumpFuncSet.insert(funcName);
+    } else if (strcmp(argv[i], "-srclang=java") == 0) {
+      srcLang = kSrcLangJava;
+    } else if (strcmp(argv[i], "-srclang=c") == 0) {
+      srcLang = kSrcLangC;
+    } else if (strcmp(argv[i], "-srclang=c++") == 0) {
+      srcLang = kSrcLangCPlusPlus;
+    } else {
+      ERR(kLncErr, "mpldbg: unrecognized command line option");
+      return 1;
+    }
+    i++;
+  }
+  // process the input files
+  while (i < argc) {
+    themodule[i] = new maple::MIRModule(argv[i]);
+    themodule[i]->SetSrcLang(srcLang);
+    std::string::size_type lastdot = themodule[i]->GetFileName().find_last_of(".");
+    bool ismplt = themodule[i]->GetFileName().compare(lastdot, k5BitSize, ".mplt") == 0;
+    bool istmpl = themodule[i]->GetFileName().compare(lastdot, k5BitSize, ".tmpl") == 0;
+    bool ismpl = themodule[i]->GetFileName().compare(lastdot, k5BitSize, ".mpl\0") == 0;
+    bool isbpl = themodule[i]->GetFileName().compare(lastdot, k5BitSize, ".bpl\0") == 0;
+    if (!ismplt && !istmpl && !ismpl && !isbpl) {
+      ERR(kLncErr, "mpldbg: input must be .mplt or .mpl or .bpl or .tmpl file");
+      return 1;
+    }
+    // input the file
+    if (ismpl || istmpl) {
+      maple::MIRParser theparser(*themodule[i]);
+      if (!theparser.ParseMIR()) {
+        theparser.EmitError(themodule[i]->GetFileName().c_str());
+        return 1;
+      }
+    } else {
+      BinaryMplImport binMplt(*themodule[i]);
+      binMplt.SetImported(false);
+      std::string modid = themodule[i]->GetFileName();
+      if (!binMplt.Import(modid, true)) {
+        ERR(kLncErr, "mpldbg: cannot open .mplt or .bpl file: %s", modid.c_str());
+        return 1;
+      }
+    }
+
+    themodule[i]->GetDbgInfo()->BuildDebugInfo();
+    themodule[i]->SetWithDbgInfo(true);
+
+    // output the file
+    themodule[i]->OutputAsciiMpl(".dbg", (ismpl || isbpl) ? ".mpl" : ".tmpl");
+    i++;
+  }
+  return 0;
+}
diff --git a/src/mapleall/maple_ir/src/opcode_info.cpp b/src/mapleall/maple_ir/src/opcode_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..688cbfc033ac11949e340184c46c7955d1849cb5
--- /dev/null
+++ b/src/mapleall/maple_ir/src/opcode_info.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "opcode_info.h"
+
+namespace maple {
+OpcodeTable::OpcodeTable() {
+#define STR(s) #s
+#define OPCODE(O, P, F, S)     \
+  table[OP_##O].flag = F;      \
+  table[OP_##O].name = STR(O); \
+  table[OP_##O].instrucSize = S;
+#include "opcodes.def"
+#undef OPCODE
+  table[OP_maydassign].name = "dassign";  // maydassign is printed dassign
+}
+const OpcodeTable kOpcodeInfo;
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/option.cpp b/src/mapleall/maple_ir/src/option.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d29982a6f75bf099d862cf1c8e992b35cd905dad
--- /dev/null
+++ b/src/mapleall/maple_ir/src/option.cpp
@@ -0,0 +1,412 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "option.h"
+#include <iostream>
+#include <cstring>
+#include <cctype>
+#include "driver_options.h"
+#include "file_utils.h"
+#include "mpl_logging.h"
+#include "mpl2mpl_options.h"
+#include "triple.h"
+
+namespace maple {
+
+bool Options::dumpBefore = false;
+bool Options::dumpAfter = false;
+std::string Options::dumpPhase = "";
+std::string Options::dumpFunc = "*";
+std::string Options::skipPhase;
+std::string Options::skipFrom;
+std::string Options::skipAfter;
+bool Options::quiet = false;
+bool Options::regNativeFunc = false;
+bool Options::nativeWrapper = true;         // Enabled by default
+bool Options::enableIPAClone = true;
+
+// Options for inlining (einline and ginline)
+bool Options::inlineWithProfile = false;
+bool Options::useInline = true;             // Enabled by default
+bool Options::enableGInline = true;
+bool Options::useCrossModuleInline = true;  // Enabled by default
+std::string Options::noInlineFuncList = "";
+std::string Options::importFileList = "";
+// These two thresholds will be scaled down if new cost module was used
+uint32 Options::inlineSmallFunctionThreshold = 80;  // Only for srcLangC, value will be reset later for other srcLang
+uint32 Options::inlineHotFunctionThreshold = 100;   // Only for srcLangC, value will be reset later for other srcLang
+uint32 Options::inlineRecursiveFunctionThreshold = 15;
+uint32 Options::inlineDepth = 8;
+uint32 Options::inlineModuleGrowth = 10;
+uint32 Options::inlineColdFunctionThreshold = 3;
+bool Options::respectAlwaysInline = false;
+bool Options::inlineToAllCallers = true;
+uint32 Options::ginlineMaxNondeclaredInlineCallee = 400;
+bool Options::ginlineAllowNondeclaredInlineSizeGrow = false;
+bool Options::ginlineAllowIgnoreGrowthLimit = true;
+uint32 Options::ginlineMaxDepthIgnoreGrowthLimit = 3;
+uint32 Options::ginlineSmallFunc = 29;
+uint32 Options::ginlineRelaxSmallFuncDecalredInline = 4;
+uint32 Options::ginlineRelaxSmallFuncCanbeRemoved = 32;
+std::string Options::callsiteProfilePath = "";
+
+uint32 Options::profileHotCount = 1000;
+uint32 Options::profileColdCount = 10;
+uint32 Options::numOfCloneVersions = 2;
+uint32 Options::numOfImpExprLowBound = 2;
+uint32 Options::numOfImpExprHighBound = 5;
+uint32 Options::numOfCallSiteLowBound = 2;
+uint32 Options::numOfCallSiteUpBound = 10;
+uint32 Options::numOfConstpropValue = 2;
+bool Options::profileHotCountSeted = false;
+bool Options::profileColdCountSeted = false;
+uint32 Options::profileHotRate = 500000;
+uint32 Options::profileColdRate = 900000;
+bool Options::regNativeDynamicOnly = false;
+std::string Options::staticBindingList;
+bool Options::usePreg = false;
+bool Options::mapleLinker = false;
+bool Options::dumpMuidFile = false;
+bool Options::emitVtableImpl = false;
+#if MIR_JAVA
+bool Options::skipVirtualMethod = false;
+#endif
+bool Options::profileGen = false;
+bool Options::profileUse = false;
+bool Options::stackProtectorStrong = false;
+bool Options::stackProtectorAll = false;
+bool Options::genLMBC = false;
+
+// Ready to be deleted.
+bool Options::noRC = false;
+bool Options::analyzeCtor = true;
+bool Options::strictNaiveRC = false;
+bool Options::gcOnly = false;
+bool Options::bigEndian = false;
+bool Options::rcOpt1 = true;
+bool Options::nativeOpt = true;
+bool Options::optForSize = false;
+bool Options::O2 = false;
+bool Options::noDot = false;
+bool Options::genIRProfile = false;
+bool Options::profileTest = false;
+std::string Options::criticalNativeFile = "maple/mrt/codetricks/profile.pv/criticalNative.list";
+std::string Options::fastNativeFile = "maple/mrt/codetricks/profile.pv/fastNative.list";
+bool Options::barrier = false;
+std::string Options::nativeFuncPropertyFile = "maple/mrt/codetricks/native_binding/native_func_property.list";
+bool Options::mapleLinkerTransformLocal = true;
+bool Options::decoupleStatic = false;
+bool Options::partialAot = false;
+uint32 Options::decoupleInit = 0;
+uint32 Options::buildApp = kNoDecouple;
+std::string Options::sourceMuid = "";
+bool Options::decoupleSuper = false;
+bool Options::deferredVisit = false;
+bool Options::deferredVisit2 = false;
+bool Options::genVtabAndItabForDecouple = false;
+bool Options::profileFunc = false;
+uint32 Options::parserOpt = 0;
+std::string Options::dumpDevirtualList = "";
+std::string Options::readDevirtualList = "";
+bool Options::usePreloadedClass = false;
+std::string Options::profile = "";
+std::string Options::appPackageName = "";
+bool Options::profileStaticFields = false;
+std::string Options::proFileData = "";
+std::string Options::proFileFuncData = "";
+std::string Options::proFileClassData = "";
+std::string Options::classLoaderInvocationList = "";  // maple/mrt/codetricks/profile.pv/classloaderInvocation.list
+bool Options::dumpClassLoaderInvocation = false;
+unsigned int Options::warningLevel = 0;
+bool Options::lazyBinding = false;
+bool Options::hotFix = false;
+bool Options::compactMeta = false;
+bool Options::genPGOReport = false;
+bool Options::verify = false;
+uint32 Options::inlineCache = 0;
+bool Options::checkArrayStore = false;
+bool Options::noComment = false;
+bool Options::rmNoUseFunc = true; // default remove no-used static function
+bool Options::sideEffect = true;
+bool Options::dumpIPA = false;
+bool Options::wpaa = false;  // whole program alias analysis
+bool Options::doOutline = false;
+size_t Options::outlineThreshold = 12800;
+
+Options &Options::GetInstance() {
+  static Options instance;
+  return instance;
+}
+
+void Options::DecideMpl2MplRealLevel() const {
+  if (opts::mpl2mpl::o2 || opts::mpl2mpl::os) {
+    if (opts::mpl2mpl::os) {
+      optForSize = true;
+      doOutline = true;
+    }
+    O2 = true;
+    usePreg = true;
+  }
+}
+
+bool Options::SolveOptions(bool isDebug) const {
+  DecideMpl2MplRealLevel();
+
+  for (const auto &opt : mpl2mplCategory.GetEnabledOptions()) {
+    std::string printOpt;
+    if (isDebug) {
+      for (const auto &val : opt->GetRawValues()) {
+        printOpt += opt->GetName() + " " + val + " ";
+      }
+      LogInfo::MapleLogger() << "mpl2mpl options: " << printOpt << '\n';
+    }
+  }
+
+  maplecl::CopyIfEnabled(dumpBefore, opts::mpl2mpl::dumpBefore);
+  maplecl::CopyIfEnabled(dumpAfter, opts::mpl2mpl::dumpAfter);
+  maplecl::CopyIfEnabled(dumpFunc, opts::mpl2mpl::dumpFunc);
+
+  // quiet can be set by verbose option in driver
+  maplecl::CopyIfEnabled(quiet, !opts::verbose, opts::verbose);
+  maplecl::CopyIfEnabled(quiet, opts::mpl2mpl::quiet);
+
+  maplecl::CopyIfEnabled(dumpPhase, opts::mpl2mpl::dumpPhase);
+  maplecl::CopyIfEnabled(skipPhase, opts::mpl2mpl::skipPhase);
+  maplecl::CopyIfEnabled(skipFrom, opts::mpl2mpl::skipFrom);
+  maplecl::CopyIfEnabled(skipAfter, opts::mpl2mpl::skipAfter);
+  maplecl::CopyIfEnabled(regNativeDynamicOnly, opts::mpl2mpl::regNativeDynamicOnly);
+  maplecl::CopyIfEnabled(staticBindingList, opts::mpl2mpl::staticBindingList);
+  maplecl::CopyIfEnabled(regNativeFunc, opts::mpl2mpl::regNativeFunc);
+  maplecl::CopyIfEnabled(nativeWrapper, opts::mpl2mpl::nativeWrapper);
+  maplecl::CopyIfEnabled(inlineWithProfile, opts::mpl2mpl::inlineWithProfile);
+  maplecl::CopyIfEnabled(useInline, opts::mpl2mpl::inlineOpt);
+  maplecl::CopyIfEnabled(enableIPAClone, opts::mpl2mpl::ipaClone);
+  maplecl::CopyIfEnabled(enableGInline, opts::mpl2mpl::ginlineOpt);
+  maplecl::CopyIfEnabled(noInlineFuncList, opts::mpl2mpl::noInlineFunc);
+  maplecl::CopyIfEnabled(importFileList, opts::mpl2mpl::importFileList);
+  maplecl::CopyIfEnabled(numOfCloneVersions, opts::mpl2mpl::numOfCloneVersions);
+  maplecl::CopyIfEnabled(numOfImpExprLowBound, opts::mpl2mpl::numOfImpExprLowBound);
+  maplecl::CopyIfEnabled(numOfImpExprHighBound, opts::mpl2mpl::numOfImpExprHighBound);
+  maplecl::CopyIfEnabled(numOfCallSiteLowBound, opts::mpl2mpl::numOfCallSiteLowBound);
+  maplecl::CopyIfEnabled(numOfCallSiteUpBound, opts::mpl2mpl::numOfCallSiteUpBound);
+  maplecl::CopyIfEnabled(numOfConstpropValue, opts::mpl2mpl::numOfConstpropValue);
+  maplecl::CopyIfEnabled(useCrossModuleInline, opts::mpl2mpl::crossModuleInline);
+  maplecl::CopyIfEnabled(inlineSmallFunctionThreshold, opts::mpl2mpl::inlineSmallFunctionThreshold);
+  maplecl::CopyIfEnabled(inlineHotFunctionThreshold, opts::mpl2mpl::inlineHotFunctionThreshold);
+  maplecl::CopyIfEnabled(inlineRecursiveFunctionThreshold, opts::mpl2mpl::inlineRecursiveFunctionThreshold);
+  maplecl::CopyIfEnabled(inlineDepth, opts::mpl2mpl::inlineDepth);
+  maplecl::CopyIfEnabled(inlineModuleGrowth, opts::mpl2mpl::inlineModuleGrow);
+  maplecl::CopyIfEnabled(inlineColdFunctionThreshold, opts::mpl2mpl::inlineColdFuncThresh);
+  maplecl::CopyIfEnabled(respectAlwaysInline, opts::mpl2mpl::respectAlwaysInline);
+
+  maplecl::CopyIfEnabled(inlineToAllCallers, opts::mpl2mpl::inlineToAllCallers);
+  maplecl::CopyIfEnabled(ginlineMaxNondeclaredInlineCallee, opts::mpl2mpl::ginlineMaxNondeclaredInlineCallee);
+  maplecl::CopyIfEnabled(ginlineAllowNondeclaredInlineSizeGrow, opts::mpl2mpl::ginlineAllowNondeclaredInlineSizeGrow);
+  maplecl::CopyIfEnabled(ginlineAllowIgnoreGrowthLimit, opts::mpl2mpl::ginlineAllowIgnoreGrowthLimit);
+  maplecl::CopyIfEnabled(ginlineMaxDepthIgnoreGrowthLimit, opts::mpl2mpl::ginlineMaxDepthIgnoreGrowthLimit);
+  maplecl::CopyIfEnabled(ginlineSmallFunc, opts::mpl2mpl::ginlineSmallFunc);
+  maplecl::CopyIfEnabled(ginlineRelaxSmallFuncDecalredInline, opts::mpl2mpl::ginlineRelaxSmallFuncDecalredInline);
+  maplecl::CopyIfEnabled(ginlineRelaxSmallFuncCanbeRemoved, opts::mpl2mpl::ginlineRelaxSmallFuncCanbeRemoved);
+  maplecl::CopyIfEnabled(callsiteProfilePath, opts::mpl2mpl::callsiteProfilePath);
+
+  maplecl::CopyIfEnabled(profileHotCount, opts::mpl2mpl::profileHotCount);
+  maplecl::CopyIfEnabled(profileColdCount, opts::mpl2mpl::profileColdCount);
+  maplecl::CopyIfEnabled(profileHotRate, opts::mpl2mpl::profileHotRate);
+  maplecl::CopyIfEnabled(profileColdRate, opts::mpl2mpl::profileColdRate);
+  maplecl::CopyIfEnabled(outlineThreshold, opts::mpl2mpl::outlineThreshold);
+
+  if (opts::mpl2mpl::mapleLinker) {
+    mapleLinker = opts::mpl2mpl::mapleLinker;
+    dumpMuidFile = mapleLinker; // quiet is overwrited by maplelinker option
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: dumpMuidFile " << dumpMuidFile << '\n';
+    }
+  }
+
+  maplecl::CopyIfEnabled(dumpMuidFile, opts::mpl2mpl::dumpMuid);
+  maplecl::CopyIfEnabled(emitVtableImpl, opts::mpl2mpl::emitVtableImpl);
+
+#if MIR_JAVA
+  maplecl::CopyIfEnabled(skipVirtualMethod, opts::mpl2mpl::skipVirtual);
+#endif
+
+  maplecl::CopyIfEnabled(noRC, !opts::mpl2mpl::userc, opts::mpl2mpl::userc);
+  maplecl::CopyIfEnabled(strictNaiveRC, opts::mpl2mpl::strictNaiveRc);
+  maplecl::CopyIfEnabled(gcOnly, opts::gcOnly);
+
+  /* big endian can be set with several options: --target, -Be.
+   * Triple takes to account all these options and allows to detect big endian with IsBigEndian() interface */
+  if (Triple::GetTriple().IsBigEndian()) {
+    bigEndian = true;
+  }
+
+  maplecl::CopyIfEnabled(rcOpt1, opts::mpl2mpl::rcOpt1);
+  maplecl::CopyIfEnabled(nativeOpt, opts::mpl2mpl::nativeOpt);
+  maplecl::CopyIfEnabled(criticalNativeFile, opts::mpl2mpl::criticalNative);
+  maplecl::CopyIfEnabled(fastNativeFile, opts::mpl2mpl::fastNative);
+  maplecl::CopyIfEnabled(noDot, opts::mpl2mpl::noDot);
+  maplecl::CopyIfEnabled(genIRProfile, opts::mpl2mpl::genIrProfile);
+  maplecl::CopyIfEnabled(profileTest, opts::mpl2mpl::proFileTest);
+  maplecl::CopyIfEnabled(barrier, opts::mpl2mpl::barrier);
+  maplecl::CopyIfEnabled(nativeFuncPropertyFile, opts::mpl2mpl::nativeFuncPropertyFile);
+
+  maplecl::CopyIfEnabled(mapleLinkerTransformLocal, !opts::mpl2mpl::mapleLinkerNolocal,
+                         opts::mpl2mpl::mapleLinkerNolocal);
+  maplecl::CopyIfEnabled(deferredVisit, opts::mpl2mpl::deferredVisit);
+
+  if (opts::mpl2mpl::deferredVisit.IsEnabledByUser()) {
+    deferredVisit = true;
+    deferredVisit2 = true;
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: deferredVisit " << deferredVisit << '\n';
+      LogInfo::MapleLogger() << "--sub options: deferredVisit2 " << deferredVisit2 << '\n';
+    }
+  }
+
+  maplecl::CopyIfEnabled(decoupleSuper, opts::mpl2mpl::decoupleSuper);
+
+  if (opts::mpl2mpl::buildApp.IsEnabledByUser()) {
+    if (opts::mpl2mpl::buildApp != kMpl2MplLevelZero &&
+        opts::mpl2mpl::buildApp != kMpl2MplLevelOne &&
+        opts::mpl2mpl::buildApp != kMpl2MplLevelTwo) {
+      LogInfo::MapleLogger(kLlErr) << "expecting 0,1,2 or empty for --build-app\n";
+      return false;
+    }
+    /* Default buildApp value is 1, so if an User does not select buildApp (with --buildApp=2), it will be 1 */
+    buildApp = opts::mpl2mpl::buildApp;
+  }
+
+  maplecl::CopyIfEnabled(sourceMuid, opts::mpl2mpl::sourceMuid);
+  if (opts::decoupleStatic.IsEnabledByUser()) {
+    decoupleStatic = opts::decoupleStatic;
+    buildApp = (opts::decoupleStatic == true) ? 1 : 0;
+  }
+
+  maplecl::CopyIfEnabled(partialAot, opts::mpl2mpl::partialAot);
+
+  if (opts::mpl2mpl::decoupleInit.IsEnabledByUser()) {
+    if (opts::mpl2mpl::decoupleInit != kNoDecouple &&
+        opts::mpl2mpl::decoupleInit != kConservativeDecouple &&
+        opts::mpl2mpl::decoupleInit != kAggressiveDecouple) {
+      std::cerr << "expecting 0,1,2 or empty for --decouple-init\n";
+      return false;
+    }
+
+    /* Default opts::mpl2mpl::decoupleInit value is Options::kConservativeDecouple==1
+     * so if an User does not select buildApp (with --decouple-init=2), it will be 1.
+     */
+    decoupleInit = opts::mpl2mpl::decoupleInit;
+    decoupleStatic = true;
+    buildApp = Options::kConservativeDecouple;
+  }
+
+  maplecl::CopyIfEnabled(genVtabAndItabForDecouple, opts::mpl2mpl::genDecoupleVtab);
+  maplecl::CopyIfEnabled(profileFunc, opts::mpl2mpl::profileFunc);
+  maplecl::CopyIfEnabled(dumpDevirtualList, opts::mpl2mpl::dumpDevirtual);
+  maplecl::CopyIfEnabled(readDevirtualList, opts::mpl2mpl::readDevirtual);
+  maplecl::CopyIfEnabled(usePreloadedClass, opts::mpl2mpl::useWhiteClass);
+  maplecl::CopyIfEnabled(profile, opts::profile);
+
+  if (opts::profileGen.IsEnabledByUser()) {
+    if (O2) {
+      LogInfo::MapleLogger(kLlErr) << "profileGen requires no optimization\n";
+      return false;
+    } else {
+      profileGen = true;
+    }
+  }
+
+  maplecl::CopyIfEnabled(profileUse, opts::profileUse);
+  maplecl::CopyIfEnabled(stackProtectorStrong, opts::stackProtectorStrong);
+  maplecl::CopyIfEnabled(stackProtectorAll, opts::stackProtectorAll);
+  maplecl::CopyIfEnabled(genLMBC, opts::genLMBC);
+  maplecl::CopyIfEnabled(appPackageName, opts::mpl2mpl::appPackageName);
+  maplecl::CopyIfEnabled(classLoaderInvocationList, opts::mpl2mpl::checkClInvocation);
+  maplecl::CopyIfEnabled(dumpClassLoaderInvocation, opts::mpl2mpl::dumpClInvocation);
+  maplecl::CopyIfEnabled(warningLevel, opts::mpl2mpl::warning);
+  maplecl::CopyIfEnabled(lazyBinding, opts::mpl2mpl::lazyBinding);
+  maplecl::CopyIfEnabled(hotFix, opts::mpl2mpl::hotFix);
+  maplecl::CopyIfEnabled(compactMeta, opts::mpl2mpl::compactMeta);
+  maplecl::CopyIfEnabled(genPGOReport, opts::mpl2mpl::genPGOReport);
+  maplecl::CopyIfEnabled(verify, opts::verify);
+
+  if (opts::mpl2mpl::inlineCache.IsEnabledByUser()) {
+    if (opts::mpl2mpl::inlineCache != 0 &&
+        opts::mpl2mpl::inlineCache != 1 &&
+        opts::mpl2mpl::inlineCache != 2 &&
+        opts::mpl2mpl::inlineCache != 3) {
+      LogInfo::MapleLogger(kLlErr) << "expecting 0,1,2,3 or empty for --inlineCache\n";
+      return false;
+    }
+
+    inlineCache = opts::mpl2mpl::inlineCache;
+  }
+
+  maplecl::CopyIfEnabled(noComment, opts::mpl2mpl::noComment);
+  maplecl::CopyIfEnabled(rmNoUseFunc, opts::mpl2mpl::rmNouseFunc);
+  maplecl::CopyIfEnabled(sideEffect, opts::mpl2mpl::sideEffect);
+  maplecl::CopyIfEnabled(dumpIPA, opts::mpl2mpl::dumpIPA);
+  maplecl::CopyIfEnabled(wpaa, opts::mpl2mpl::wpaa);
+
+  return true;
+}
+
+bool Options::ParseOptions(int argc, char **argv, std::string &fileName) const {
+  (void)maplecl::CommandLine::GetCommandLine().Parse(argc, static_cast<char **>(argv), mpl2mplCategory);
+  bool result = SolveOptions(false);
+  if (!result) {
+    return result;
+  }
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  int inputFileCount = 0;
+  for (auto &arg : badArgs) {
+    if (FileUtils::IsFileExists(arg.first)) {
+      inputFileCount++;
+      fileName = arg.first;
+    } else {
+      LogInfo::MapleLogger(kLlErr) << "Unknown Option: " << arg.first;
+      return false;
+    }
+  }
+
+  if (inputFileCount != 1) {
+    LogInfo::MapleLogger(kLlErr) << "expecting one .mpl file as last argument, found: ";
+    for (const auto &optionArg : badArgs) {
+      LogInfo::MapleLogger(kLlErr) << optionArg.first << " ";
+    }
+    LogInfo::MapleLogger(kLlErr) << "\n";
+    return false;
+  }
+
+#ifdef DEBUG_OPTION
+    LogInfo::MapleLogger() << "mpl file : " << fileName << "\t";
+    DumpOptions();
+#endif
+
+  return true;
+}
+
+void Options::DumpOptions() const {
+  LogInfo::MapleLogger() << "phase sequence : \t";
+  if (phaseSeq.empty()) {
+    LogInfo::MapleLogger() << "default phase sequence\n";
+  } else {
+    for (size_t i = 0; i < phaseSeq.size(); ++i) {
+      LogInfo::MapleLogger() << " " << phaseSeq[i];
+    }
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+};  // namespace maple
diff --git a/src/mapleall/maple_ir/src/parser.cpp b/src/mapleall/maple_ir/src/parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c60b5a9b7f1fc61312ee64ed1a4c33fdc457a02
--- /dev/null
+++ b/src/mapleall/maple_ir/src/parser.cpp
@@ -0,0 +1,3522 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <climits>
+#include <cstdlib>
+#include <sstream>
+#include <fstream>
+#include "mir_parser.h"
+#include "mir_scope.h"
+#include "mir_function.h"
+#include "namemangler.h"
+#include "opcode_info.h"
+#include "mir_pragma.h"
+#include "bin_mplt.h"
+#include "option.h"
+#include "clone.h"
+#include "string_utils.h"
+#include "debug_info.h"
+#include "mir_enum.h"
+
+namespace {
+using namespace maple;
+constexpr char kLexerStringSp[] = "SP";
+constexpr char kLexerStringFp[] = "FP";
+constexpr char kLexerStringGp[] = "GP";
+constexpr char kLexerStringThrownval[] = "thrownval";
+constexpr char kLexerStringRetval[] = "retval";
+const std::map<std::string, SpecialReg> pregMapIdx = { { kLexerStringSp, kSregSp },
+                                                       { kLexerStringFp, kSregFp },
+                                                       { kLexerStringGp, kSregGp },
+                                                       { kLexerStringThrownval, kSregThrownval },
+                                                       { kLexerStringRetval, kSregRetval0 } };
+
+const std::map<TokenKind, PragmaKind> tkPragmaKind = { { TK_class, kPragmaClass },
+                                                       { TK_func, kPragmaFunc },
+                                                       { TK_var, kPragmaVar },
+                                                       { TK_param, kPragmaParam },
+                                                       { TK_func_ex, kPragmaFuncExecptioni },
+                                                       { TK_func_var, kPragmaFuncVar } };
+const std::map<TokenKind, PragmaValueType> tkPragmaValType = { { TK_i8, kValueByte },
+                                                               { TK_i16, kValueShort },
+                                                               { TK_u16, kValueChar },
+                                                               { TK_i32, kValueInt },
+                                                               { TK_i64, kValueLong },
+                                                               { TK_f32, kValueFloat },
+                                                               { TK_f64, kValueDouble },
+                                                               { TK_retype, kValueMethodType },
+                                                               { TK_ref, kValueMethodHandle },
+                                                               { TK_ptr, kValueString },
+                                                               { TK_type, kValueType },
+                                                               { TK_var, kValueField },
+                                                               { TK_func, kValueMethod },
+                                                               { TK_enum, kValueEnum },
+                                                               { TK_array, kValueArray },
+                                                               { TK_annotation, kValueAnnotation },
+                                                               { TK_const, kValueNull },
+                                                               { TK_u1, kValueBoolean } };
+}  // namespace
+
+namespace maple {
+std::map<TokenKind, MIRParser::FuncPtrParseMIRForElem> MIRParser::funcPtrMapForParseMIR =
+    MIRParser::InitFuncPtrMapForParseMIR();
+
+MIRFunction *MIRParser::CreateDummyFunction() {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("__$$__");
+  MIRBuilder mirBuilder(&mod);
+  MIRSymbol *funcSt = mirBuilder.CreateSymbol(TyIdx(0), strIdx, kStFunc, kScUnused, nullptr, kScopeGlobal);
+  CHECK_FATAL(funcSt != nullptr, "Failed to create MIRSymbol");
+  // Don't add the function to the function table.
+  // It appears Storage class kScUnused is not honored.
+  MIRFunction *func = mirBuilder.CreateFunction(funcSt->GetStIdx(), false);
+  CHECK_FATAL(func != nullptr, "Failed to create MIRFunction");
+  func->SetPuidxOrigin(func->GetPuidx());
+  MIRType *returnType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_void));
+  func->SetReturnTyIdx(returnType->GetTypeIndex());
+  func->SetClassTyIdx(0U);
+  func->SetBaseClassFuncNames(strIdx);
+  funcSt->SetFunction(func);
+  return func;
+}
+
+bool MIRParser::IsDelimitationTK(TokenKind tk) const {
+  switch (tk) {
+    case TK_rparen:
+    case TK_coma:
+      return true;
+    default:
+      return false;
+  }
+}
+
+inline bool IsPowerOf2(uint64 num) {
+  if (num == 0) {
+    return false;
+  }
+  return (~(num - 1) & num) == num;
+}
+
+Opcode MIRParser::GetOpFromToken(TokenKind tk) const {
+  switch (tk) {
+#define OPCODE(X, Y, Z, S) \
+    case TK_##X:             \
+      return OP_##X;
+#include "opcodes.def"
+#undef OPCODE
+    default:
+      return OP_undef;
+  }
+}
+
+static bool IsClassInterfaceTypeName(const std::string &nameStr) {
+  return (!nameStr.empty() && nameStr.front() == 'L' && StringUtils::EndsWith(nameStr, "_3B"));
+}
+
+bool MIRParser::IsStatement(TokenKind tk) const {
+  if (tk == TK_LOC || tk == TK_ALIAS || tk == TK_SCOPE) {
+    return true;
+  }
+  Opcode op = GetOpFromToken(tk);
+  return kOpcodeInfo.IsStmt(op);
+}
+
+PrimType MIRParser::GetPrimitiveType(TokenKind tk) const {
+#define LOAD_ALGO_PRIMARY_TYPE
+  switch (tk) {
+#define PRIMTYPE(P)                      \
+    case TK_##P: {                       \
+      if (tk == TK_ptr) {                \
+        return GetExactPtrPrimType();    \
+      }                                  \
+      return PTY_##P;                    \
+    }
+#include "prim_types.def"
+#undef PRIMTYPE
+    default:
+      return kPtyInvalid;
+  }
+}
+
+MIRIntrinsicID MIRParser::GetIntrinsicID(TokenKind tk) const {
+  switch (tk) {
+    default:
+#define DEF_MIR_INTRINSIC(P, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ...) \
+    case TK_##P:                                                  \
+      return INTRN_##P;
+#include "intrinsics.def"
+#undef DEF_MIR_INTRINSIC
+  }
+}
+
+void MIRParser::Error(const std::string &str) {
+  std::stringstream strStream;
+  const std::string &lexName = lexer.GetName();
+  int curIdx = lexer.GetCurIdx() - lexName.length() + 1;
+  strStream << "line: " << lexer.GetLineNum() << ":" << curIdx << ":";
+  message += strStream.str();
+  message += str;
+  message += ": ";
+  message += lexer.GetTokenString();
+  message += "\n";
+  mod.GetDbgInfo()->SetErrPos(lexer.GetLineNum(), lexer.GetCurIdx());
+}
+
+const std::string &MIRParser::GetError() {
+  if (lexer.GetTokenKind() == TK_invalid) {
+    std::stringstream strStream;
+    strStream << "line: " << lexer.GetLineNum() << ":" << lexer.GetCurIdx() << ":";
+    message += strStream.str();
+    message += " invalid token\n";
+  }
+  return message;
+}
+
+void MIRParser::Warning(const std::string &str) {
+  std::stringstream strStream;
+  const std::string &lexName = lexer.GetName();
+  int curIdx = lexer.GetCurIdx() - lexName.length() + 1;
+  strStream << "  >> warning line: " << lexer.GetLineNum() << ":" << curIdx << ":";
+  warningMessage += strStream.str();
+  warningMessage += str;
+  warningMessage += "\n";
+}
+
+const std::string &MIRParser::GetWarning() const {
+  return warningMessage;
+}
+
+bool MIRParser::ParseSpecialReg(PregIdx &pRegIdx) {
+  const std::string &lexName = lexer.GetName();
+  size_t lexSize = lexName.size();
+  size_t retValSize = strlen(kLexerStringRetval);
+  if (strncmp(lexName.c_str(), kLexerStringRetval, retValSize) == 0 && (lexSize > retValSize) &&
+      isdigit(lexName[retValSize])) {
+    int32 retValNo = lexName[retValSize] - '0';
+    for (size_t i = retValSize + 1; (i < lexSize) && isdigit(lexName[i]); ++i) {
+      retValNo = retValNo * 10 + lexName[i] - '0';
+    }
+    pRegIdx = -kSregRetval0 - retValNo;
+    lexer.NextToken();
+    return true;
+  }
+
+  auto it = pregMapIdx.find(lexName);
+  if (it != pregMapIdx.end()) {
+    pRegIdx = -(it->second);
+    lexer.NextToken();
+    return true;
+  }
+
+  Error("unrecognized special register ");
+  return false;
+}
+
+bool MIRParser::ParsePseudoReg(PrimType primType, PregIdx &pRegIdx) {
+  uint32 pregNo = static_cast<uint32>(lexer.GetTheIntVal());
+  ASSERT(pregNo <= 0xffff, "preg number must be 16 bits");
+  MIRFunction *curfunc = mod.CurFunction();
+  pRegIdx = curfunc->GetPregTab()->EnterPregNo(pregNo, primType);
+  MIRPreg *preg = curfunc->GetPregTab()->PregFromPregIdx(pRegIdx);
+  if (primType != kPtyInvalid) {
+    if (preg->GetPrimType() != primType) {
+      if (IsAddress(preg->GetPrimType()) && IsAddress(primType)) {
+      } else {
+        Error("inconsistent preg primitive type at ");
+        return false;
+      }
+    }
+  }
+
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::CheckPrimAndDerivedType(TokenKind tokenKind, TyIdx &tyIdx) {
+  if (IsPrimitiveType(tokenKind)) {
+    return ParsePrimType(tyIdx);
+  }
+  if (tokenKind == TK_langle) {
+    return ParseDerivedType(tyIdx);
+  }
+  return false;
+}
+
+bool MIRParser::ParseType(TyIdx &tyIdx) {
+  TokenKind tk = lexer.GetTokenKind();
+  if (IsVarName(tk)) {
+    return ParseDefinedTypename(tyIdx);
+  }
+  if (CheckPrimAndDerivedType(tk, tyIdx)) {
+    return true;
+  }
+  Error("token is not a type ");
+  return false;
+}
+
+bool MIRParser::ParseFarrayType(TyIdx &arrayTyIdx) {
+  TokenKind tokenKind = lexer.NextToken();
+  TyIdx tyIdx;
+  if (!CheckPrimAndDerivedType(tokenKind, tyIdx)) {
+    Error("unexpect token parsing flexible array element type ");
+    return false;
+  }
+  ASSERT(tyIdx != 0u, "error encountered parsing flexible array element type ");
+  if (mod.IsJavaModule() || mod.IsCharModule()) {
+    MIRJarrayType jarrayType(tyIdx);
+    arrayTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&jarrayType);
+  } else {
+    MIRFarrayType farrayType(tyIdx);
+    arrayTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&farrayType);
+  }
+  return true;
+}
+
+bool MIRParser::ParseArrayType(TyIdx &arrayTyIdx) {
+  TokenKind tokenKind = lexer.GetTokenKind();
+  if (tokenKind != TK_lbrack) {
+    Error("expect [ for array type but get ");
+    return false;
+  }
+  std::vector<uint32> vec;
+  while (tokenKind == TK_lbrack) {
+    tokenKind = lexer.NextToken();
+    if (tokenKind == TK_rbrack && vec.empty()) {
+      break;
+    }
+    if (tokenKind != TK_intconst) {
+      Error("expect int value parsing array type after [ but get ");
+      return false;
+    }
+    int64 val = static_cast<int64>(lexer.GetTheIntVal());
+    if (val < 0) {
+      Error("expect array value >= 0 ");
+      return false;
+    }
+    vec.push_back(val);
+    if (lexer.NextToken() != TK_rbrack) {
+      Error("expect ] after int value parsing array type but get ");
+      return false;
+    }
+    tokenKind = lexer.NextToken();
+  }
+  if (tokenKind == TK_rbrack && vec.empty()) {
+    return ParseFarrayType(arrayTyIdx);
+  }
+  TyIdx tyIdx;
+  if (!CheckPrimAndDerivedType(tokenKind, tyIdx)) {
+    Error("unexpect token parsing array type after ] ");
+    return false;
+  }
+  ASSERT(tyIdx != 0u, "something wrong with parsing element type ");
+  MIRArrayType arrayType(tyIdx, vec);
+  if (!ParseTypeAttrs(arrayType.GetTypeAttrs())) {
+    Error("bad type attribute in pointer type specification");
+    return false;
+  }
+  arrayTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&arrayType);
+  return true;
+}
+
+bool MIRParser::ParseBitFieldType(TyIdx &fieldTyIdx) {
+  if (lexer.GetTokenKind() != TK_colon) {
+    Error("expect : parsing field type but get ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_intconst) {
+    Error("expect int const val parsing field type but get ");
+    return false;
+  }
+  ASSERT(lexer.GetTheIntVal() <= 0xFFU, "lexer.theIntVal is larger than max uint8 bitsize value.");
+  uint8 bitSize = static_cast<uint8>(lexer.GetTheIntVal()) & 0xFFU;
+  PrimType primType = GetPrimitiveType(lexer.NextToken());
+  if (primType == kPtyInvalid) {
+    Error("expect primitive type but get ");
+    return false;
+  }
+  if (!IsPrimitiveInteger(primType)) {
+    Error("syntax error bit field should be integer type but get ");
+    return false;
+  }
+  MIRBitFieldType bitFieldType(bitSize, primType);
+  fieldTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&bitFieldType);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParsePragmaElement(MIRPragmaElement &elem) {
+  TokenKind tk = lexer.GetTokenKind();
+  lexer.NextToken();
+  auto it = tkPragmaValType.find(tk);
+  if (it == tkPragmaValType.end()) {
+    Error("parsing pragma error: wrong element type");
+    return false;
+  }
+  elem.SetType(it->second);
+
+  switch (tk) {
+    case TK_i8:
+    case TK_i16:
+    case TK_i32:
+      elem.SetI32Val(static_cast<int32>(lexer.GetTheIntVal()));
+      break;
+    case TK_u16:
+    case TK_ref:
+      elem.SetU64Val(static_cast<uint64>(lexer.GetTheIntVal()));
+      break;
+    case TK_i64:
+    case TK_retype:
+    case TK_const:
+    case TK_u1:
+      elem.SetI64Val(static_cast<int64>(lexer.GetTheIntVal()));
+      break;
+    case TK_f32:
+      elem.SetFloatVal(lexer.GetTheFloatVal());
+      break;
+    case TK_f64:
+      elem.SetDoubleVal(lexer.GetTheDoubleVal());
+      break;
+    case TK_ptr:
+    case TK_var:
+    case TK_func:
+    case TK_enum:
+      elem.SetI32Val(static_cast<int32>(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName())));
+      break;
+    case TK_type:
+      lexer.NextToken();
+      elem.SetI32Val(static_cast<int32>(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName())));
+      lexer.NextToken();
+      break;
+    case TK_array:
+      if (!ParsePragmaElementForArray(elem)) {
+        return false;
+      }
+      break;
+    case TK_annotation:
+      if (!ParsePragmaElementForAnnotation(elem)) {
+        return false;
+      }
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParsePragmaElementForArray(MIRPragmaElement &elem) {
+  TokenKind tk = lexer.GetTokenKind();
+  if (tk != TK_lbrack) {
+    Error("parsing pragma error: expecting [ but get ");
+    return false;
+  }
+  tk = lexer.NextToken();
+  if (tk != TK_intconst) {
+    Error("parsing pragma error: expecting int but get ");
+    return false;
+  }
+  int64 size = static_cast<int64>(lexer.GetTheIntVal());
+  tk = lexer.NextToken();
+  if (tk != TK_coma && size) {
+    Error("parsing pragma error: expecting , but get ");
+    return false;
+  }
+  for (int64 i = 0; i < size; ++i) {
+    auto *e0 = mod.GetMemPool()->New<MIRPragmaElement>(mod);
+    tk = lexer.NextToken();
+    if (!ParsePragmaElement(*e0)) {
+      Error("parsing pragma error type ");
+      return false;
+    }
+    elem.SubElemVecPushBack(e0);
+    tk = lexer.NextToken();
+    if (tk != TK_coma && tk != TK_rbrack) {
+      Error("parsing pragma error: expecting , or ] but get ");
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MIRParser::ParsePragmaElementForAnnotation(MIRPragmaElement &elem) {
+  TokenKind tk = lexer.GetTokenKind();
+  if (tk != TK_langle) {
+    Error("parsing pragma error: expecting < but get ");
+    return false;
+  }
+  tk = lexer.NextToken();
+  elem.SetTypeStrIdx(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()));
+  tk = lexer.NextToken();
+  if (tk != TK_rangle) {
+    Error("parsing pragma error: expecting > but get ");
+    return false;
+  }
+  tk = lexer.NextToken();
+  if (tk != TK_lbrack) {
+    Error("parsing pragma error: expecting [ but get ");
+    return false;
+  }
+  tk = lexer.NextToken();
+  if (tk != TK_intconst) {
+    Error("parsing pragma error: expecting int but get ");
+    return false;
+  }
+  int64 size = static_cast<int64>(lexer.GetTheIntVal());
+  tk = lexer.NextToken();
+  if (tk != TK_coma && size) {
+    Error("parsing pragma error: expecting , but get ");
+    return false;
+  }
+  for (int64 i = 0; i < size; ++i) {
+    auto *e0 = mod.GetMemPool()->New<MIRPragmaElement>(mod);
+    tk = lexer.NextToken();
+    if (tk != TK_label) {
+      Error("parsing pragma error: expecting @ but get ");
+      return false;
+    }
+    e0->SetNameStrIdx(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()));
+    tk = lexer.NextToken();
+    if (!ParsePragmaElement(*e0)) {
+      Error("parsing pragma error type ");
+      return false;
+    }
+    elem.SubElemVecPushBack(e0);
+    tk = lexer.NextToken();
+    if (tk != TK_coma && tk != TK_rbrack) {
+      Error("parsing pragma error: expecting , or ] but get ");
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MIRParser::ParsePragma(MIRStructType &type) {
+  auto *p = mod.GetMemPool()->New<MIRPragma>(mod);
+  p->SetVisibility(lexer.GetTheIntVal());
+  TokenKind tk = lexer.NextToken();
+
+  auto it = tkPragmaKind.find(tk);
+  if (it == tkPragmaKind.end()) {
+    Error("parsing pragma error: wrong kind ");
+    return false;
+  }
+  p->SetKind(it->second);
+
+  if (tk == TK_param) {
+    lexer.NextToken();
+    p->SetParamNum(lexer.GetTheIntVal());
+  }
+  tk = lexer.NextToken();
+  if (tk != TK_gname && tk != TK_lname && tk != TK_fname) {
+    Error("expect global or local token parsing pragma but get ");
+    return false;
+  }
+  p->SetStrIdx(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()));
+  lexer.NextToken();
+  TyIdx tyIdx;
+  if (!ParseType(tyIdx)) {
+    Error("parsing pragma error: wrong type ");
+    return false;
+  }
+  p->SetTyIdx(tyIdx);
+
+  tk = lexer.GetTokenKind();
+  if (tk != TK_lbrace) {
+    TyIdx tyIdxEx;
+    if (!ParseType(tyIdxEx)) {
+      Error("parsing pragma error: wrong type ");
+      return false;
+    }
+    p->SetTyIdxEx(tyIdxEx);
+  }
+
+  tk = lexer.NextToken();
+  while (tk != TK_rbrace) {
+    auto *e = mod.GetMemPool()->New<MIRPragmaElement>(mod);
+    e->SetNameStrIdx(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()));
+    tk = lexer.NextToken();
+    if (!ParsePragmaElement(*e)) {
+      Error("parsing pragma error type ");
+      return false;
+    }
+    p->PushElementVector(e);
+    tk = lexer.NextToken();
+    if (tk != TK_rbrace && tk != TK_coma) {
+      Error("parsing pragma error syntax ");
+      return false;
+    }
+    if (tk == TK_coma) {
+      lexer.NextToken();
+    }
+  }
+  lexer.NextToken();
+  type.PushbackPragma(p);
+  return true;
+}
+
+// lexer.GetTokenKind() assumed to be the TK_lbrace that starts the fields
+bool MIRParser::ParseFields(MIRStructType &type) {
+  if (type.IsIncomplete()) {
+    Warning("incomplete class/interface type");
+  }
+  TokenKind tk = lexer.NextToken();
+  MIRTypeKind tyKind = type.GetKind();
+  while (tk == TK_label || tk == TK_prntfield || tk == TK_pragma) {
+    bool isPragma = (tk == TK_pragma);
+    bool notaType = false;
+    TyIdx fieldTyIdx(0);
+    bool isParentField = false;
+    if (tk == TK_prntfield) {
+      isParentField = true;
+    }
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    tk = lexer.NextToken();
+    if (isPragma) {
+      if (tyKind == kTypeClass || tyKind == kTypeClassIncomplete || tyKind == kTypeInterface ||
+          tyKind == kTypeInterfaceIncomplete) {
+        if (!ParsePragma(type)) {
+          Error("parsing pragma error ");
+          return false;
+        }
+      } else {
+        Error("parsing pragma error ");
+        return false;
+      }
+      notaType = true;
+    } else if ((tk == TK_lbrack) && (GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx) == "staticvalue")) {
+      while (tk != TK_coma) {
+        EncodedValue elem;
+        if (tk != TK_lbrack) {
+          Error("parsing staticvalue error ");
+          return false;
+        }
+        tk = lexer.NextToken();
+        uint32 i = 0;
+        while (tk != TK_rbrack) {
+          if (tk != TK_intconst) {
+            Error("parsing staticvalue error ");
+            return false;
+          }
+          elem.encodedValue[i++] = lexer.GetTheIntVal();
+          tk = lexer.NextToken();
+        }
+        tk = lexer.NextToken();
+        if (tyKind == kTypeClass || tyKind == kTypeClassIncomplete ||
+            tyKind == kTypeInterface || tyKind == kTypeInterfaceIncomplete) {
+          type.PushbackStaticValue(elem);
+        } else {
+          Error("parsing staticvalue error ");
+          return false;
+        }
+      }
+      notaType = true;
+    } else if (tk == TK_colon) {  // a bitfield
+      if (!ParseBitFieldType(fieldTyIdx)) {
+        Error("parsing struct type error ");
+        return false;
+      }
+    } else if (tk == TK_langle) {
+      if (!ParseDerivedType(fieldTyIdx)) {
+        Error("parsing struct type error ");
+        return false;
+      }
+    } else if ((IsPrimitiveType(tk))) {
+      if (!ParsePrimType(fieldTyIdx)) {
+        Error("expect :<val> or primitive type or derived type parsing struct type ");
+        return false;
+      }
+    } else if ((tk == TK_intconst || tk == TK_string) && !isParentField &&
+               (tyKind == kTypeClass || tyKind == kTypeClassIncomplete ||
+                tyKind == kTypeInterface || tyKind == kTypeInterfaceIncomplete)) {
+      uint32 infoVal = (tk == TK_intconst) ? static_cast<uint32>(lexer.GetTheIntVal()) :
+          static_cast<uint32>(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()));
+      type.PushbackMIRInfo(MIRInfoPair(strIdx, infoVal));
+      type.PushbackIsString(tk != TK_intconst);
+      notaType = true;
+      lexer.NextToken();
+    } else {
+      Error("unexpected type parsing struct type at ");
+      return false;
+    }
+    ASSERT((fieldTyIdx != 0u || notaType), "something wrong parsing struct type");
+    if (!notaType) {
+      FieldAttrs tA;
+      if (!ParseFieldAttrs(tA)) {
+        Error("bad type attribute in struct field at ");
+        return false;
+      }
+      if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx)->HasTypeParam()) {
+        tA.SetAttr(FLDATTR_generic);
+      }
+      FieldPair p = FieldPair(strIdx, TyIdxFieldAttrPair(fieldTyIdx, tA));
+      bool isStaticField = false;
+      if (tA.GetAttr(FLDATTR_static)) {
+        // static and parent share the same ^ token
+        isStaticField = true;
+        isParentField = false;
+      }
+      if (isParentField) {
+        type.GetParentFields().push_back(p);
+      } else if (isStaticField) {
+        type.GetStaticFields().push_back(p);
+      } else {
+        type.GetFields().push_back(p);
+      }
+      tk = lexer.GetTokenKind();
+      bool isConst = tA.GetAttr(FLDATTR_static) && tA.GetAttr(FLDATTR_final) &&
+                     (tA.GetAttr(FLDATTR_public) || tA.GetAttr(FLDATTR_protected));
+      if (isConst && tk == TK_eqsign) {
+        tk = lexer.NextToken();
+        MIRConst *mirConst = nullptr;
+        if (!ParseInitValue(mirConst, fieldTyIdx)) {
+          Error("wrong initialization value at ");
+          return false;
+        }
+        GlobalTables::GetConstPool().InsertConstPool(p.first, mirConst);
+        tk = lexer.GetTokenKind();
+      }
+    } else {
+      tk = lexer.GetTokenKind();
+    }
+    tk = lexer.GetTokenKind();
+    if (tk == TK_rbrace) {
+      return true;
+    }
+    if (tk != TK_coma) {
+      Error(", missing after ");
+      return false;
+    }
+    tk = lexer.NextToken();
+    if (tk == TK_rbrace) {
+      Error(",} is not legal, expect another field type after ,");
+      return false;
+    }
+  }
+  while (tk == TK_fname) {
+    const std::string &funcName = lexer.GetName();
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+    MIRSymbol *prevFuncSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+    if (prevFuncSymbol && (prevFuncSymbol->GetStorageClass() != kScText || prevFuncSymbol->GetSKind() != kStFunc)) {
+      // Based on the current maple format, a previous declaration at this
+      // point can only come from another module. Check consistency.
+      Error("redeclaration of name as func in ");
+      return false;
+    }
+    // Always create a new symbol because we can not reuse symbol from other module
+    maple::MIRBuilder mirBuilder(&mod);
+    MIRSymbol *funcSymbol = mirBuilder.CreateSymbol(TyIdx(0), strIdx, kStFunc, kScText, nullptr, kScopeGlobal);
+    ASSERT(funcSymbol != nullptr, "Failed to create MIRSymbol");
+    SetSrcPos(funcSymbol->GetSrcPosition(), lexer.GetLineNum());
+
+    MIRFunction *fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSymbol->GetStIdx());
+    fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
+    GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
+    funcSymbol->SetFunction(fn);
+    fn->SetFileIndex(0);
+    fn->SetBaseClassFuncNames(funcSymbol->GetNameStrIdx());
+    FuncAttrs tA;
+    if (lexer.NextToken() != TK_lparen) {
+      if (!ParseFuncAttrs(tA)) {
+        return false;
+      }
+      // Skip attribute checking
+      fn->SetFuncAttrs(tA);
+    }
+    TyIdx funcTyIdx;
+    if (!ParseFuncType(funcTyIdx)) {
+      return false;
+    }
+    // tyIdx does not work. Calling EqualTo does not work either.
+    auto *funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcTyIdx));
+    fn->SetMIRFuncType(funcType);
+    fn->SetReturnStruct(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()));
+    funcSymbol->SetTyIdx(funcTyIdx);
+
+    for (size_t i = 0; i < funcType->GetParamTypeList().size(); i++) {
+      FormalDef formalDef(nullptr, funcType->GetParamTypeList()[i], funcType->GetParamAttrsList()[i]);
+      fn->GetFormalDefVec().push_back(formalDef);
+    }
+
+    MethodPair p = MethodPair(funcSymbol->GetStIdx(), TyidxFuncAttrPair(funcTyIdx, FuncAttrs(tA)));
+    type.GetMethods().push_back(p);
+    tk = lexer.GetTokenKind();
+    if (tk == TK_coma) {
+      tk = lexer.NextToken();
+      if (tk == TK_rbrace) {
+        Error(",} is not legal, expect another field type after ,");
+        return false;
+      }
+    } else if (tk != TK_rbrace) {
+      Error(", missing after ");
+      return false;
+    } else {
+      return true;
+    }
+  }
+  // interfaces_implemented
+  while (tk == TK_gname) {
+    tk = lexer.NextToken();
+    if ((tk == TK_coma || tk == TK_rbrace) && (tyKind == kTypeClass || tyKind == kTypeClassIncomplete)) {
+      auto *classType = static_cast<MIRClassType*>(&type);
+      std::string nameStr = lexer.GetName();
+      GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(nameStr);
+      TyIdx tyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
+      if (tyIdx == 0u) {
+        MIRInterfaceType interfaceType(kTypeInterfaceIncomplete);
+        interfaceType.SetNameStrIdx(strIdx);
+        tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&interfaceType);
+        mod.AddClass(tyIdx);
+        mod.AddExternStructType(tyIdx);
+        mod.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx);
+      }
+      classType->GetInterfaceImplemented().push_back(tyIdx);
+    }
+    if (tk == TK_coma) {
+      tk = lexer.NextToken();
+    }
+  }
+  // alias
+  while (tk == TK_ALIAS) {
+    MIRAlias *alias = type.GetAlias();
+    if (!alias) {
+      alias = mod.GetMemPool()->New<MIRAlias>(&mod);
+      type.SetAlias(alias);
+    }
+    GStrIdx strIdx;
+    MIRAliasVars aliasVar;
+    bool status = ParseOneAlias(strIdx, aliasVar);
+    if (status) {
+      alias->SetAliasVarMap(strIdx, aliasVar);
+    }
+    tk = lexer.GetTokenKind();
+    if (tk == TK_coma) {
+      tk = lexer.NextToken();
+    }
+  }
+  // allow empty class for third party classes we do not have info
+  if (tk == TK_rbrace) {
+    return true;
+  }
+  Error("expect field or member function name in struct/class body but get ");
+  return false;
+}
+
+bool MIRParser::ParseStructType(TyIdx &styIdx, const GStrIdx &strIdx) {
+  MIRTypeKind tkind = kTypeInvalid;
+  switch (lexer.GetTokenKind()) {
+    case TK_struct:
+      tkind = kTypeStruct;
+      break;
+    case TK_structincomplete:
+      tkind = kTypeStructIncomplete;
+      break;
+    case TK_union:
+      tkind = kTypeUnion;
+      break;
+    default:
+      break;
+  }
+  MIRStructType structType(tkind, strIdx);
+  if (lexer.NextToken() != TK_lbrace) {
+    if (!ParseTypeAttrs(structType.GetTypeAttrs())) {
+      Error("bad type attribute in struct type specification");
+      return false;
+    }
+  }
+  if (lexer.GetTokenKind() != TK_lbrace) {
+    Error("expect { parsing struct body");
+    return false;
+  }
+  if (mod.GetSrcLang() == kSrcLangCPlusPlus) {
+    structType.SetIsCPlusPlus(true);
+  }
+  if (!ParseFields(structType)) {
+    return false;
+  }
+  // Dex file create a struct type with name, but do not check the type field.
+  if (styIdx != 0u) {
+    MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(styIdx);
+    ASSERT(prevType->GetKind() == kTypeStruct || prevType->IsIncomplete(), "type kind should be consistent.");
+    if (static_cast<MIRStructType*>(prevType)->IsIncomplete() && !(structType.IsIncomplete())) {
+      structType.SetNameStrIdx(prevType->GetNameStrIdx());
+      structType.SetTypeIndex(styIdx);
+      GlobalTables::GetTypeTable().SetTypeWithTyIdx(styIdx, *structType.CopyMIRTypeNode());
+    }
+  } else {
+    TyIdx prevTypeIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
+    if (prevTypeIdx != 0) {
+      // if the MIRStructType has been created by name or incompletely, refresh the prev created type
+      MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prevTypeIdx);
+      if (prevType->GetKind() == kTypeByName ||
+          (prevType->GetKind() == kTypeStructIncomplete && tkind == kTypeStruct)) {
+        structType.SetTypeIndex(prevTypeIdx);
+        GlobalTables::GetTypeTable().SetTypeWithTyIdx(prevTypeIdx, *structType.CopyMIRTypeNode());
+      }
+      styIdx = prevTypeIdx;
+    } else {
+      styIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&structType);
+    }
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseClassType(TyIdx &styidx, const GStrIdx &strIdx) {
+  MIRTypeKind tkind = (lexer.GetTokenKind() == TK_class) ? kTypeClass : kTypeClassIncomplete;
+  TyIdx parentTypeIdx(0);
+  if (lexer.NextToken() == TK_langle) {
+    // parsing parent as class
+    if (!ParseDerivedType(parentTypeIdx, kTypeClass)) {
+      Error("parsing class parent type error ");
+      return false;
+    }
+  }
+  MIRClassType classType(tkind, strIdx);
+  classType.SetParentTyIdx(parentTypeIdx);
+  if (!ParseFields(classType)) {
+    return false;
+  }
+  // Dex file create a strtuct type with name, but donot check the type field.
+  MIRType *prevType = nullptr;
+  if (styidx != 0u) {
+    prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(styidx);
+  }
+  if (prevType != nullptr && prevType->GetKind() != kTypeByName) {
+    ASSERT(prevType->GetKind() == kTypeClass || prevType->IsIncomplete(),
+           "type kind should be consistent.");
+    if (static_cast<MIRClassType*>(prevType)->IsIncomplete() && !(classType.IsIncomplete())) {
+      classType.SetNameStrIdx(prevType->GetNameStrIdx());
+      classType.SetTypeIndex(styidx);
+      GlobalTables::GetTypeTable().SetTypeWithTyIdx(styidx, *classType.CopyMIRTypeNode());
+    }
+  } else {
+    styidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&classType);
+    // set up classTyIdx for methods
+    for (size_t i = 0; i < classType.GetMethods().size(); ++i) {
+      StIdx stIdx = classType.GetMethodsElement(i).first;
+      MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+      ASSERT(st->GetSKind() == kStFunc, "unexpected st->sKind");
+      st->GetFunction()->SetClassTyIdx(styidx);
+    }
+    mod.AddClass(styidx);
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseInterfaceType(TyIdx &sTyIdx, const GStrIdx &strIdx) {
+  MIRTypeKind tkind = (lexer.GetTokenKind() == TK_interface) ? kTypeInterface : kTypeInterfaceIncomplete;
+  std::vector<TyIdx> parents;
+  TokenKind tk = lexer.NextToken();
+  while (tk == TK_langle) {
+    TyIdx parentTypeIdx(0);
+    // parsing parents as interfaces
+    if (!ParseDerivedType(parentTypeIdx, kTypeInterface)) {
+      Error("parsing interface parent type error ");
+      return false;
+    }
+    parents.push_back(parentTypeIdx);
+    tk = lexer.GetTokenKind();
+  }
+  MIRInterfaceType interfaceType(tkind, strIdx);
+  interfaceType.SetParentsTyIdx(parents);
+  if (!ParseFields(interfaceType)) {
+    return false;
+  }
+  // Dex file create a strtuct type with name, but donot check the type field.
+  if (sTyIdx != 0u) {
+    MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(sTyIdx);
+    ASSERT(prevType->GetKind() == kTypeInterface || prevType->IsIncomplete(),
+           "type kind should be consistent.");
+    if (static_cast<MIRInterfaceType*>(prevType)->IsIncomplete() && !(interfaceType.IsIncomplete())) {
+      interfaceType.SetNameStrIdx(prevType->GetNameStrIdx());
+      interfaceType.SetTypeIndex(sTyIdx);
+      GlobalTables::GetTypeTable().SetTypeWithTyIdx(sTyIdx, *interfaceType.CopyMIRTypeNode());
+    }
+  } else {
+    sTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&interfaceType);
+    // set up classTyIdx for methods
+    for (size_t i = 0; i < interfaceType.GetMethods().size(); ++i) {
+      StIdx stIdx = interfaceType.GetMethodsElement(i).first;
+      MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+      ASSERT(st != nullptr, "st is null");
+      ASSERT(st->GetSKind() == kStFunc, "unexpected st->sKind");
+      st->GetFunction()->SetClassTyIdx(sTyIdx);
+    }
+    mod.AddClass(sTyIdx);
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::CheckAlignTk() {
+  if (lexer.NextToken() != TK_lparen) {
+    Error("unexpected token in alignment specification after ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_intconst) {
+    Error("unexpected token in alignment specification after ");
+    return false;
+  }
+  if (!IsPowerOf2(lexer.GetTheIntVal())) {
+    Error("specified alignment must be power of 2 instead of ");
+    return false;
+  }
+  if (lexer.NextToken() != TK_rparen) {
+    Error("unexpected token in alignment specification after ");
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParseAlignAttrs(TypeAttrs &tA) {
+  if (lexer.GetTokenKind() != TK_align) {
+    Error("wrong TK kind taken from file");
+    return false;
+  }
+  if (!CheckAlignTk()) {
+    return false;
+  }
+  tA.SetAlign(lexer.GetTheIntVal());
+  return true;
+}
+
+bool MIRParser::ParsePackAttrs() {
+  if (lexer.GetTokenKind() != TK_pack) {
+    Error("wrong TK kind taken from file");
+    return false;
+  }
+  if (!CheckAlignTk()) {
+    return false;
+  }
+  return true;
+}
+
+// for variable declaration type attribute specification
+// it has also storage-class qualifier.
+bool MIRParser::ParseVarTypeAttrs(MIRSymbol &st) {
+  do {
+    switch (lexer.GetTokenKind()) {
+// parse attr without no content
+#define TYPE_ATTR
+#define NOCONTENT_ATTR
+#define ATTR(X)            \
+      case TK_##X:             \
+        st.SetAttr(ATTR_##X); \
+        break;
+#include "all_attributes.def"
+#undef ATTR
+#undef TYPE_ATTR
+#undef NOCONTENT_ATTR
+// parse attr with no content
+      case TK_align: {
+        if (!ParseAlignAttrs(st.GetAttrs())) {
+          return false;
+        }
+        break;
+      }
+      default:
+        return true;
+    }  // switch
+    lexer.NextToken();
+  } while (true);
+}
+
+// for non-variable type attribute specification.
+bool MIRParser::ParseTypeAttrs(TypeAttrs &attrs) {
+  do {
+    switch (lexer.GetTokenKind()) {
+// parse attr without no content
+#define TYPE_ATTR
+#define NOCONTENT_ATTR
+#define ATTR(X)            \
+      case TK_##X:             \
+        attrs.SetAttr(ATTR_##X); \
+        break;
+#include "all_attributes.def"
+#undef ATTR
+#undef TYPE_ATTR
+#undef NOCONTENT_ATTR
+// parse attr with no content
+      case TK_align: {
+        if (!ParseAlignAttrs(attrs)) {
+          return false;
+        }
+        break;
+      }
+      case TK_pack: {
+        attrs.SetAttr(ATTR_pack);
+        if (!ParsePackAttrs()) {
+          return false;
+        }
+        attrs.SetPack(static_cast<uint32>(lexer.GetTheIntVal()));
+        break;
+      }
+      default:
+        return true;
+    }  // switch
+    lexer.NextToken();
+  } while (true);
+}
+
+bool MIRParser::ParseFieldAttrs(FieldAttrs &attrs) {
+  do {
+    switch (lexer.GetTokenKind()) {
+// parse attr without no content
+#define FIELD_ATTR
+#define NOCONTENT_ATTR
+#define ATTR(X)               \
+      case TK_##X:                \
+        attrs.SetAttr(FLDATTR_##X); \
+        break;
+#include "all_attributes.def"
+#undef ATTR
+#undef NOCONTENT_ATTR
+#undef FIELD_ATTR
+// parse attr with no content
+      case TK_align: {
+        if (!CheckAlignTk()) {
+          return false;
+        }
+        attrs.SetAlign(lexer.GetTheIntVal());
+        break;
+      }
+      case TK_pack: {
+        attrs.SetAttr(FLDATTR_pack);
+        if (!ParsePackAttrs()) {
+          return false;
+        }
+        break;
+      }
+      default:
+        return true;
+    }  // switch
+    lexer.NextToken();
+  } while (true);
+}
+
+bool MIRParser::ParseFuncAttrs(FuncAttrs &attrs) {
+  do {
+    FuncAttrKind attrKind;
+    TokenKind currentToken = lexer.GetTokenKind();
+    switch (currentToken) {
+#define FUNC_ATTR
+#define ATTR(X)                       \
+      case TK_##X: {                  \
+        attrKind = FUNCATTR_##X;      \
+        attrs.SetAttr(attrKind);      \
+        break;                        \
+      }
+#include "all_attributes.def"
+#undef ATTR
+#undef FUNC_ATTR
+      default:
+        return true;
+    }  // switch
+    if (currentToken != TK_alias && currentToken != TK_section &&
+        currentToken != TK_constructor_priority && currentToken != TK_destructor_priority) {
+      lexer.NextToken();
+      continue;
+    }
+    if (lexer.NextToken() != TK_lparen) {
+      return false;
+    }
+    lexer.NextToken();
+    SetAttrContent(attrs, attrKind, lexer);
+    if (lexer.NextToken() != TK_rparen) {
+      return false;
+    }
+    lexer.NextToken();
+  } while (true);
+}
+
+void MIRParser::SetAttrContent(FuncAttrs &attrs, FuncAttrKind x, const MIRLexer &mirLexer) const {
+  switch (x) {
+    case FUNCATTR_alias: {
+      attrs.SetAliasFuncName(mirLexer.GetName());
+      break;
+    }
+    case FUNCATTR_section: {
+      attrs.SetPrefixSectionName(mirLexer.GetName());
+      break;
+    }
+    case FUNCATTR_constructor_priority: {
+      attrs.SetConstructorPriority(static_cast<int32>(mirLexer.GetTheIntVal()));
+      break;
+    }
+    case FUNCATTR_destructor_priority: {
+      attrs.SetDestructorPriority(static_cast<int32>(mirLexer.GetTheIntVal()));
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+bool MIRParser::ParsePrimType(TyIdx &tyIdx) {
+  PrimType primType = GetPrimitiveType(lexer.GetTokenKind());
+  if (primType == kPtyInvalid) {
+    tyIdx = TyIdx(0);
+    Error("ParsePrimType failed, invalid token");
+    return false;
+  }
+  lexer.NextToken();
+  tyIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(primType))->GetTypeIndex();
+  return true;
+}
+
+bool MIRParser::ParseTypeParam(TyIdx &definedTyIdx) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  MIRTypeParam typeParm(strIdx);
+  definedTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&typeParm);
+  lexer.NextToken();
+  return true;
+}
+
+// LB not handled in binary format
+bool MIRParser::ParseDefinedTypename(TyIdx &definedTyIdx, MIRTypeKind kind) {
+  TokenKind tk = lexer.GetTokenKind();
+  if (!IsVarName(tk)) {
+    Error("expect global or local token parsing typedef type but get ");
+    return false;
+  }
+  std::string nameStr = lexer.GetName();
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(nameStr);
+  // check if type already exist
+  definedTyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
+  TyIdx prevTypeIdx(0);
+  if (definedTyIdx) {
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(definedTyIdx);
+    if (type->IsStructType()) {
+      auto *stype = static_cast<MIRStructType*>(type);
+      // check whether need to update from incomplete class to interface
+      if (stype->GetKind() == kind) {
+        lexer.NextToken();
+        return true;
+      }
+      prevTypeIdx = definedTyIdx;
+    }
+  }
+  if (tk == TK_gname) {
+    definedTyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
+    if (definedTyIdx == 0u) {
+      if (kind == kTypeInterface || kind == kTypeInterfaceIncomplete) {
+        MIRInterfaceType interfaceType(kTypeInterfaceIncomplete);
+        interfaceType.SetNameStrIdx(strIdx);
+        definedTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&interfaceType);
+        mod.AddClass(definedTyIdx);
+        mod.AddExternStructType(definedTyIdx);
+        mod.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, definedTyIdx);
+      } else if (kind == kTypeClass || kind == kTypeClassIncomplete || IsClassInterfaceTypeName(nameStr)) {
+        MIRClassType classType(kTypeClassIncomplete);
+        classType.SetNameStrIdx(strIdx);
+        definedTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&classType);
+        mod.AddClass(definedTyIdx);
+        mod.AddExternStructType(definedTyIdx);
+        mod.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, definedTyIdx);
+      } else {
+        MIRTypeByName nameType(strIdx);
+        definedTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&nameType);
+        mod.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, definedTyIdx);
+      }
+    }
+  } else {
+    definedTyIdx = mod.CurFunction()->GetTyIdxFromGStrIdx(strIdx);
+    if (definedTyIdx == 0u) {
+      MIRTypeByName nameType(strIdx);
+      definedTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&nameType);
+      mod.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, definedTyIdx);
+    }
+  }
+  // replace prevTypeIdx with definedTyIdx
+  if (prevTypeIdx != 0u && prevTypeIdx != definedTyIdx) {
+    // replace all uses of prevTypeIdx by tyIdx in type_table_
+    typeDefIdxMap[prevTypeIdx] = definedTyIdx;
+    // remove prevTypeIdx from classlist
+    mod.RemoveClass(prevTypeIdx);
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParsePointType(TyIdx &tyIdx) {
+  TokenKind pdtk;
+  if (lexer.GetTokenKind() == TK_func) {  // a function pointer
+    pdtk = TK_func;
+  } else if (lexer.GetTokenKind() != TK_asterisk) {
+    Error("expect * for point type but get ");
+    return false;
+  } else {
+    pdtk = lexer.NextToken();
+  }
+  TyIdx pointTypeIdx(0);
+  if (IsPrimitiveType(pdtk)) {
+    if (!ParsePrimType(pointTypeIdx)) {
+      return false;
+    }
+  } else if (pdtk == TK_asterisk) {  // a point type
+    if (!ParsePointType(pointTypeIdx)) {
+      return false;
+    }
+  } else if (pdtk == TK_lbrack) {  // a array type
+    if (!ParseArrayType(pointTypeIdx)) {
+      return false;
+    }
+  } else if (pdtk == TK_struct || pdtk == TK_union || pdtk == TK_structincomplete) {
+    if (!ParseStructType(pointTypeIdx)) {
+      return false;
+    }
+  } else if (pdtk == TK_class || pdtk == TK_classincomplete) {
+    if (!ParseClassType(pointTypeIdx)) {
+      return false;
+    }
+  } else if (pdtk == TK_gname) {
+    if (!ParseDefinedTypename(pointTypeIdx)) {
+      return false;
+    }
+  } else if (pdtk == TK_langle) {
+    if (!ParseDerivedType(pointTypeIdx)) {
+      return false;
+    }
+  } else if (pdtk == TK_func) {
+    lexer.NextToken();
+    if (!ParseFuncType(pointTypeIdx)) {
+      return false;
+    }
+  } else {
+    Error("unexpect type ");
+    return false;
+  }
+  ASSERT(pointTypeIdx != 0u, "something wrong with parsing element type ");
+  PrimType pty = mod.IsJavaModule() ? PTY_ref : GetExactPtrPrimType();
+  if (pdtk == maple::TK_constStr) {
+    pty = GetExactPtrPrimType();
+  }
+  MIRPtrType pointType(pointTypeIdx, pty);  // use reference type here
+  if (!ParseTypeAttrs(pointType.GetTypeAttrs())) {
+    Error("bad type attribute in pointer type specification");
+    return false;
+  }
+  tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&pointType);
+  return true;
+}
+
+// used in parsing the parameter list (types only, without parameter names)
+// in function pointer specification and member function prototypes inside
+// structs and classes
+bool MIRParser::ParseFuncType(TyIdx &tyIdx) {
+  // parse function attributes
+  FuncAttrs fAttrs;
+  if (lexer.GetTokenKind() != TK_lparen) {
+    if (!ParseFuncAttrs(fAttrs)) {
+      Error("bad function attribute specification in function type at ");
+      return false;
+    }
+  }
+
+  // parse parameters
+  if (lexer.GetTokenKind() != TK_lparen) {
+    Error("expect ( parse function type parameters but get ");
+    return false;
+  }
+  std::vector<TyIdx> vecTyIdx;
+  std::vector<TypeAttrs> vecAttrs;
+  TokenKind tokenKind = lexer.NextToken();
+  bool varargs = false;
+  while (tokenKind != TK_rparen) {
+    if (tokenKind == TK_dotdotdot) {
+      if (vecTyIdx.size() == 0) {
+        Error("variable arguments can only appear after fixed parameters ");
+        return false;
+      }
+      varargs = true;
+      tokenKind = lexer.NextToken();
+      if (tokenKind != TK_rparen) {
+        Error("expect ) after ... but get");
+        return false;
+      }
+      break;
+    }
+    TyIdx tyIdxTmp(0);
+    if (!ParseType(tyIdxTmp)) {
+      Error("expect type parsing function parameters ");
+      return false;
+    }
+    TypeAttrs typeAttrs;
+    if (!ParseTypeAttrs(typeAttrs)) {
+      Error("bad attribute in function parameter type at ");
+      return false;
+    }
+    tokenKind = lexer.GetTokenKind();
+    if (tokenKind == TK_coma) {
+      tokenKind = lexer.NextToken();
+      if (tokenKind == TK_rparen) {
+        Error("syntax error, meeting ,) expect another type after , or ) without , ");
+        return false;
+      }
+    }
+    if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdxTmp)->HasTypeParam()) {
+      typeAttrs.SetAttr(ATTR_generic);
+    }
+    vecTyIdx.push_back(tyIdxTmp);
+    vecAttrs.push_back(typeAttrs);
+  }
+  // parse return type
+  lexer.NextToken();
+  TyIdx retTyIdx(0);
+  if (!ParseType(retTyIdx)) {
+    Error("expect return type for function type but get ");
+    return false;
+  }
+  TypeAttrs retTypeAttrs;
+  if (!ParseTypeAttrs(retTypeAttrs)) {
+    Error("bad attribute in function ret type at ");
+    return false;
+  }
+  MIRFuncType functype(retTyIdx, vecTyIdx, vecAttrs, retTypeAttrs);
+  functype.funcAttrs = fAttrs;
+  if (varargs) {
+    functype.SetVarArgs();
+  }
+  tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&functype);
+  return true;
+}
+
+// parse the generic type instantiation vector enclosed inside braces; syntax
+// is: { <type-param> = <real-type> [, <type-param> = <real-type>] }
+// where the contents enclosed in [ and ] can occur 0 or more times
+bool MIRParser::ParseGenericInstantVector(MIRInstantVectorType &insVecType) {
+  TokenKind tokenKind;
+  TyIdx typeParmIdx;
+  do {
+    tokenKind = lexer.NextToken();  // skip the lbrace or comma
+    if (!ParseTypeParam(typeParmIdx)) {
+      Error("type parameter incorrectly specified in generic type/function instantiation at ");
+      return false;
+    }
+    tokenKind = lexer.GetTokenKind();
+    if (tokenKind != TK_eqsign) {
+      Error("missing = in generic type/function instantiation at ");
+      return false;
+    }
+    tokenKind = lexer.NextToken();  // skip the =
+    TyIdx realTyIdx;
+    if (!ParseType(realTyIdx)) {
+      Error("error parsing type in generic type/function instantiation at ");
+      return false;
+    }
+    insVecType.AddInstant(TypePair(typeParmIdx, realTyIdx));
+    tokenKind = lexer.GetTokenKind();
+    if (tokenKind == TK_rbrace) {
+      lexer.NextToken();  // skip the rbrace
+      return true;
+    }
+  } while (tokenKind == TK_coma);
+  Error("error parsing generic type/function instantiation at ");
+  return false;
+}
+
+bool MIRParser::ParseDerivedType(TyIdx &tyIdx, MIRTypeKind kind, const GStrIdx &strIdx) {
+  if (lexer.GetTokenKind() != TK_langle) {
+    Error("expect langle but get ");
+    return false;
+  }
+  TokenKind ltk = lexer.NextToken();
+  if (IsPrimitiveType(ltk)) {
+    if (!ParsePrimType(tyIdx)) {
+      Error("ParseDerivedType failed when parsing tyIdx at ");
+      return false;
+    }
+  } else {
+    switch (ltk) {
+      case TK_asterisk:  // point type
+      case TK_func:
+        if (!ParsePointType(tyIdx)) {
+          Error("point type wrong when parsing derived type at ");
+          return false;
+        }
+        break;
+      case TK_lbrack:  // array type
+        if (!ParseArrayType(tyIdx)) {
+          Error("array type wrong when parsing derived type at ");
+          return false;
+        }
+        break;
+      case TK_struct:            // struct type
+      case TK_structincomplete:  // structincomplete type
+      case TK_union:             // union type
+        if (!ParseStructType(tyIdx, strIdx)) {
+          Error("struct/union type wrong when parsing derived type at ");
+          return false;
+        }
+        break;
+      case TK_class:  // class type
+      case TK_classincomplete:
+        if (!ParseClassType(tyIdx, strIdx)) {
+          Error("class type wrong when parsing derived type at ");
+          return false;
+        }
+        break;
+      case TK_interface:  // interface type
+      case TK_interfaceincomplete:
+        if (!ParseInterfaceType(tyIdx, strIdx)) {
+          Error("interface type wrong when parsing derived type at ");
+          return false;
+        }
+        break;
+      case TK_lname:  // local type
+      case TK_gname:  // global type
+        if (!ParseDefinedTypename(tyIdx, kind)) {
+          Error("type name wrong when parsing derived type at ");
+          return false;
+        }
+        if (lexer.GetTokenKind() == TK_lbrace) {
+          MIRGenericInstantType genericinstty(tyIdx);
+          if (!ParseGenericInstantVector(genericinstty)) {
+            Error("error parsing generic type instantiation at ");
+            return false;
+          }
+          tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&genericinstty);
+        }
+        break;
+      case TK_typeparam:
+        if (!ParseTypeParam(tyIdx)) {
+          Error("type parameter wrong when parsing derived type at ");
+          return false;
+        }
+        break;
+      default:
+        Error("expect type token but get ");
+        return false;
+    }
+  }
+  // parse >
+  if (lexer.GetTokenKind() != TK_rangle) {
+    Error("expect > parse derived type but get ");
+    return false;
+  }
+  lexer.NextToken();
+  return true;
+}
+
+void MIRParser::FixForwardReferencedTypeForOneAgg(MIRType *type) {
+  if (type->GetKind() == kTypePointer) {
+    auto *ptrType = static_cast<MIRPtrType*>(type);
+    std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(ptrType->GetPointedTyIdx());
+    if (it != typeDefIdxMap.end()) {
+      ptrType->SetPointedTyIdx(it->second);
+    }
+  } else if (type->GetKind() == kTypeArray) {
+    MIRArrayType *arrayType = static_cast<MIRArrayType *>(type);
+    std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(arrayType->GetElemTyIdx());
+    if (it != typeDefIdxMap.end()) {
+      arrayType->SetElemTyIdx(it->second);
+    }
+  } else if (type->GetKind() == kTypeFArray || type->GetKind() == kTypeJArray) {
+    MIRFarrayType *arrayType = static_cast<MIRFarrayType *>(type);
+    std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(arrayType->GetElemTyIdx());
+    if (it != typeDefIdxMap.end()) {
+      arrayType->SetElemtTyIdx(it->second);
+    }
+  } else if (type->GetKind() == kTypeStruct || type->GetKind() == kTypeStructIncomplete ||
+             type->GetKind() == kTypeUnion || type->GetKind() == kTypeClass ||
+             type->GetKind() == kTypeClassIncomplete || type->GetKind() == kTypeInterface ||
+             type->GetKind() == kTypeInterfaceIncomplete) {
+    if (type->GetKind() == kTypeClass || type->GetKind() == kTypeClassIncomplete) {
+      auto *classType = static_cast<MIRClassType*>(type);
+      std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(classType->GetParentTyIdx());
+      if (it != typeDefIdxMap.end()) {
+        classType->SetParentTyIdx(it->second);
+      }
+      for (size_t j = 0; j < classType->GetInterfaceImplemented().size(); ++j) {
+        std::map<TyIdx, TyIdx>::iterator it2 = typeDefIdxMap.find(classType->GetNthInterfaceImplemented(j));
+        if (it2 != typeDefIdxMap.end()) {
+          classType->SetNthInterfaceImplemented(j, it2->second);
+        }
+      }
+    } else if (type->GetKind() == kTypeInterface || type->GetKind() == kTypeInterfaceIncomplete) {
+      auto *interfaceType = static_cast<MIRInterfaceType*>(type);
+      for (uint32 j = 0; j < interfaceType->GetParentsTyIdx().size(); ++j) {
+        std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(interfaceType->GetParentsElementTyIdx(j));
+        if (it != typeDefIdxMap.end()) {
+          interfaceType->SetParentsElementTyIdx(j, it->second);
+        }
+      }
+    }
+    auto *structType = static_cast<MIRStructType*>(type);
+    for (uint32 j = 0; j < structType->GetFieldsSize(); ++j) {
+      TyIdx fieldTyIdx = structType->GetElemTyIdx(j);
+      std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(fieldTyIdx);
+      if (it != typeDefIdxMap.end()) {
+        structType->SetElemtTyIdx(j, it->second);
+      }
+    }
+    for (size_t j = 0; j < structType->GetStaticFields().size(); ++j) {
+      TyIdx fieldTyIdx = structType->GetStaticElemtTyIdx(j);
+      std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(fieldTyIdx);
+      if (it != typeDefIdxMap.end()) {
+        structType->SetStaticElemtTyIdx(j, it->second);
+      }
+    }
+    for (size_t j = 0; j < structType->GetMethods().size(); ++j) {
+      TyIdx methodTyIdx = structType->GetMethodsElement(j).second.first;
+      std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(methodTyIdx);
+      if (it != typeDefIdxMap.end()) {
+        structType->SetMethodTyIdx(j, it->second);
+      }
+    }
+  }
+}
+
+void MIRParser::FixupForwardReferencedTypeByMap() {
+  for (size_t i = 1; i < GlobalTables::GetTypeTable().GetTypeTable().size(); ++i) {
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(i));
+    FixForwardReferencedTypeForOneAgg(type);
+  }
+}
+
+bool MIRParser::ParseTypeDefine() {
+  bool isLocal = paramParseLocalType;
+  if (lexer.GetTokenKind() != TK_type) {
+    Error("expect type but get ");
+    return false;
+  }
+  TokenKind tokenKind = lexer.NextToken();
+  if (tokenKind != TK_gname && tokenKind != TK_lname) {
+    Error("expect type name but get ");
+    return false;
+  }
+  const std::string &name = lexer.GetName();
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  TyIdx prevTyIdx;
+  TyIdx tyIdx(0);
+  if (tokenKind == TK_gname) {
+    if (isLocal) {
+      Error("A local type must use local type name ");
+      return false;
+    }
+    prevTyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
+    if (prevTyIdx != 0u) {
+      MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prevTyIdx);
+      if (!mod.IsCModule()) {
+        CHECK_FATAL(prevType->IsStructType(), "type error");
+      }
+      if ((prevType->GetKind() != kTypeByName) && !prevType->IsIncomplete()) {
+        // allow duplicated type def if kKeepFirst is set which is the default
+        if ((options & kKeepFirst) != 0) {
+          lexer.NextToken();
+          Warning("redefined global type");
+          if (!ParseDerivedType(tyIdx, kTypeUnknown)) {
+            Error("error passing derived type at ");
+            return false;
+          }
+          return true;
+        } else {
+          Error("redefined global type");
+          return false;
+        }
+      }
+    }
+  } else {
+    if (!isLocal) {
+      Error("A global type must use global type name ");
+      return false;
+    }
+    prevTyIdx = mod.CurFunction()->GetTyIdxFromGStrIdx(strIdx);
+    if (prevTyIdx != 0u) {
+      MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prevTyIdx);
+      if ((prevType->GetKind() != kTypeByName) && !prevType->IsIncomplete()) {
+        Error("redefined local type name ");
+        return false;
+      }
+    }
+  }
+  // at this point,if prev_tyidx is not zero, this type name has been
+  // forward-referenced
+  tokenKind = lexer.NextToken();
+  tyIdx = kInitTyIdx;
+  if (IsPrimitiveType(tokenKind)) {
+    if (!ParsePrimType(tyIdx)) {
+      Error("expect primitive type after typedef but get ");
+      return false;
+    }
+  } else if (!ParseDerivedType(tyIdx, kTypeUnknown, strIdx)) {
+    Error("error passing derived type at ");
+    return false;
+  }
+  // for class/interface types, prev_tyidx could also be set during processing
+  // so we check again right before SetGStrIdxToTyIdx
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  if (isLocal) {
+    prevTyIdx = mod.CurFunction()->GetTyIdxFromGStrIdx(strIdx);
+    mod.CurFunction()->SetGStrIdxToTyIdx(strIdx, tyIdx);
+    ASSERT(GlobalTables::GetTypeTable().GetTypeTable().empty() == false, "container check");
+    if (type->GetNameStrIdx() == 0u) {
+      type->SetNameIsLocal(true);
+    }
+  } else {
+    prevTyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
+    mod.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx);
+    mod.PushbackTypeDefOrder(strIdx);
+  }
+
+  if (prevTyIdx != TyIdx(0) && prevTyIdx != tyIdx) {
+    // replace all uses of prev_tyidx by tyIdx in typeTable
+    typeDefIdxMap[prevTyIdx] = tyIdx; // record the real tydix
+    // remove prev_tyidx from classlist
+    mod.RemoveClass(prevTyIdx);
+  }
+
+  // Merge class or interface type at the cross-module level
+  ASSERT(GlobalTables::GetTypeTable().GetTypeTable().empty() == false, "container check");
+  if (!isLocal && (type->GetKind() == kTypeClass || type->GetKind() == kTypeClassIncomplete ||
+                   type->GetKind() == kTypeInterface || type->GetKind() == kTypeInterfaceIncomplete)) {
+    prevTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(strIdx);
+    if (prevTyIdx == 0u) {
+      GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(strIdx, tyIdx);
+    }
+    // setup eh root type
+    MIRType *ehType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    if (mod.GetThrowableTyIdx() == 0u &&
+        (ehType->GetKind() == kTypeClass || ehType->GetKind() == kTypeClassIncomplete)) {
+      GStrIdx ehTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr));
+      if (ehTypeNameIdx == ehType->GetNameStrIdx()) {
+        mod.SetThrowableTyIdx(tyIdx);
+      }
+    }
+  }
+  return true;
+}
+
+bool MIRParser::ParseEnumeration() {
+  if (lexer.GetTokenKind() != TK_ENUMERATION) {
+    Error("expect enum but get ");
+    return false;
+  }
+  TokenKind tokenKind = lexer.NextToken();
+  if (tokenKind != TK_gname) {
+    Error("expect global type name but get ");
+    return false;
+  }
+  const std::string &name = lexer.GetName();
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  lexer.NextToken();
+  TyIdx tyIdx(0);
+  if (!ParsePrimType(tyIdx)) {
+    Error("expect primitive type name but get ");
+    return false;
+  }
+  PrimType ptyp = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->GetPrimType();
+  if (!IsPrimitiveInteger(ptyp)) {
+    Error("base type of enum cannot be non-integer");
+    return false;
+  }
+  if (lexer.GetTokenKind() != TK_lbrace) {
+    Error("expect left brace but get ");
+    return false;
+  }
+  tokenKind = lexer.NextToken();
+  if (tokenKind != TK_gname) {
+    Error("expect global enum value name but get ");
+    return false;
+  }
+  MIREnum *mirEnum = new MIREnum(ptyp, strIdx);
+  strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  tokenKind = lexer.NextToken();
+  if (tokenKind == TK_eqsign) {
+    tokenKind = lexer.NextToken();
+    if (tokenKind != TK_intconst) {
+      Error("expect integer constant but get ");
+      return false;
+    }
+    mirEnum->NewElement(strIdx, IntVal(lexer.GetTheIntVal(), ptyp));
+    tokenKind = lexer.NextToken();
+  } else {
+    mirEnum->AddNextElement(strIdx);
+  }
+  while (tokenKind == TK_coma) {
+    tokenKind = lexer.NextToken();
+    if (tokenKind != TK_gname) {
+      Error("expect global enum value name but get ");
+      return false;
+    }
+    strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+    tokenKind = lexer.NextToken();
+    if (tokenKind == TK_eqsign) {
+      tokenKind = lexer.NextToken();
+      if (tokenKind != TK_intconst) {
+        Error("expect integer constant but get ");
+        return false;
+      }
+      mirEnum->NewElement(strIdx, IntVal(lexer.GetTheIntVal(), ptyp));
+      tokenKind = lexer.NextToken();
+    } else {
+      mirEnum->AddNextElement(strIdx);
+    }
+  }
+  if (tokenKind != TK_rbrace) {
+    Error("expect right brace but get ");
+    return false;
+  }
+  (void)lexer.NextToken();
+  GlobalTables::GetEnumTable().enumTable.push_back(mirEnum);
+  return true;
+}
+
+bool MIRParser::ParseJavaClassInterface(MIRSymbol &symbol, bool isClass) {
+  TokenKind tk = lexer.NextToken();
+  if (tk != TK_gname) {
+    Error("expect global name for javaclass but get ");
+    return false;
+  }
+  symbol.SetNameStrIdx(lexer.GetName());
+  if (!GlobalTables::GetGsymTable().AddToStringSymbolMap(symbol)) {
+    Error("duplicate symbol name used in javainterface at ");
+    return false;
+  }
+  lexer.NextToken();
+  TyIdx tyidx(0);
+  if (!ParseType(tyidx)) {
+    Error("ParseType failed trying parsing the type");
+    return false;
+  }
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx);
+  if (isClass && type->GetKind() != kTypeClass && type->GetKind() != kTypeClassIncomplete) {
+    Error("type in javaclass declaration must be of class type at ");
+    return false;
+  } else if (!isClass && type->GetKind() != kTypeInterface && type->GetKind() != kTypeInterfaceIncomplete) {
+    Error("type in javainterface declaration must be of interface type at ");
+    return false;
+  }
+  symbol.SetTyIdx(tyidx);
+  if (!ParseTypeAttrs(symbol.GetAttrs())) {
+    Error("bad type attribute in variable declaration at ");
+    return false;
+  }
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx)->HasTypeParam()) {
+    symbol.SetAttr(ATTR_generic);
+  }
+  return true;
+}
+
+bool MIRParser::ParseStorageClass(MIRSymbol &symbol) const {
+  TokenKind tk = lexer.GetTokenKind();
+  switch (tk) {
+    case TK_fstatic:
+      symbol.SetStorageClass(kScFstatic);
+      return true;
+    case TK_pstatic:
+      symbol.SetStorageClass(kScPstatic);
+      return true;
+    case TK_extern:
+      symbol.SetStorageClass(kScExtern);
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
+bool MIRParser::ParseDeclareReg(MIRSymbol &symbol, const MIRFunction &func) {
+  TokenKind tk = lexer.GetTokenKind();
+  // i.e, reg %1 u1
+  if (tk != TK_reg) {  // reg
+    Error("expect reg bug get ");
+    return false;
+  }
+  TokenKind regNumTK = lexer.NextToken();
+  if (regNumTK != TK_preg) {
+    Error("expect preg but get");
+    return false;
+  }
+  uint32 thePRegNO = static_cast<uint32>(lexer.GetTheIntVal());
+  lexer.NextToken();
+  // parse ty
+  TyIdx tyIdx(0);
+  if (!ParseType(tyIdx)) {
+    Error("ParseDeclarePreg failed while parsing the type");
+    return false;
+  }
+  ASSERT(tyIdx > 0, "parse declare preg failed");
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->GetKind() == kTypeByName) {
+    Error("type in var declaration cannot be forward-referenced at ");
+    return false;
+  }
+  symbol.SetTyIdx(tyIdx);
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  PregIdx pRegIdx = func.GetPregTab()->EnterPregNo(thePRegNO, mirType->GetPrimType(), mirType);
+  MIRPregTable *pRegTab = func.GetPregTab();
+  MIRPreg *preg = pRegTab->PregFromPregIdx(pRegIdx);
+  preg->SetPrimType(mirType->GetPrimType());
+  symbol.SetPreg(preg);
+  if (!ParseVarTypeAttrs(symbol)) {
+    Error("bad type attribute in variable declaration at ");
+    return false;
+  }
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->HasTypeParam()) {
+    symbol.SetAttr(ATTR_generic);
+    mod.CurFunction()->SetAttr(FUNCATTR_generic);
+  }
+  return true;
+}
+
+bool MIRParser::ParseDeclareVarInitValue(MIRSymbol &symbol) {
+  TokenKind tk = lexer.GetTokenKind();
+  // take a look if there are any initialized values
+  if (tk == TK_eqsign) {
+    // parse initialized values
+    MIRConst *mirConst = nullptr;
+    lexer.NextToken();
+    if (!ParseInitValue(mirConst, symbol.GetTyIdx(), mod.IsCModule())) {
+      Error("wrong initialization value at ");
+      return false;
+    }
+    symbol.SetKonst(mirConst);
+  }
+  return true;
+}
+
+bool MIRParser::ParseDeclareVar(MIRSymbol &symbol) {
+  TokenKind tk = lexer.GetTokenKind();
+  // i.e, var %i i32
+  if (tk != TK_var && tk != TK_tempvar) {  // var
+    Error("expect var but get ");
+    return false;
+  }
+  bool isLocal = symbol.IsLocal();
+  // %i
+  TokenKind nameTk = lexer.NextToken();
+  if (isLocal) {
+    if (nameTk == TK_static) {
+      symbol.SetStorageClass(kScPstatic);
+      nameTk = lexer.NextToken();
+    }
+    if (nameTk != TK_lname) {
+      Error("expect local name but get ");
+      return false;
+    }
+  } else {
+    if (nameTk != TK_gname) {
+      Error("expect global name but get ");
+      return false;
+    }
+  }
+  std::string symbolStrName = lexer.GetName();
+  GStrIdx symbolStrID = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(symbolStrName);
+  symbol.SetNameStrIdx(symbolStrID);
+  tk = lexer.NextToken();
+  if (ParseStorageClass(symbol)) {
+    lexer.NextToken();
+  }
+  // i32
+  TyIdx tyIdx(0);
+  if (!ParseType(tyIdx)) {
+    Error("ParseDeclareVar failed when parsing the type");
+    return false;
+  }
+  ASSERT(tyIdx > 0, "parse declare var failed ");
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->GetKind() == kTypeByName) {
+    Error("type in var declaration cannot be forward-referenced at ");
+    return false;
+  }
+  symbol.SetTyIdx(tyIdx);
+  /* parse section/register attribute from inline assembly */
+  if (lexer.GetTokenKind() == TK_section) {
+    lexer.NextToken();
+    if (lexer.GetTokenKind() != TK_lparen) {
+      Error("expect ( for section attribute but get ");
+      return false;
+    }
+    lexer.NextToken();
+    if (lexer.GetTokenKind() != TK_string) {
+      Error("expect string literal for section attribute but get ");
+      return false;
+    }
+    UStrIdx literalStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    symbol.sectionAttr = literalStrIdx;
+    lexer.NextToken();
+    if (lexer.GetTokenKind() != TK_rparen) {
+      Error("expect ) for section attribute but get ");
+      return false;
+    }
+    lexer.NextToken();
+  } else if (lexer.GetTokenKind() == TK_asmattr) { /* Specifying Registers for Local Variables */
+    lexer.NextToken();
+    if (lexer.GetTokenKind() != TK_lparen) {
+      Error("expect ( for register inline-asm attribute but get ");
+      return false;
+    }
+    lexer.NextToken();
+    if (lexer.GetTokenKind() != TK_string) {
+      Error("expect string literal for section attribute but get ");
+      return false;
+    }
+    UStrIdx literalStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    symbol.asmAttr = literalStrIdx;
+
+    lexer.NextToken();
+    if (lexer.GetTokenKind() != TK_rparen) {
+      Error("expect ) for section attribute but get ");
+      return false;
+    }
+    lexer.NextToken();
+  }
+  if (!ParseVarTypeAttrs(symbol)) {
+    Error("bad type attribute in variable declaration at ");
+    return false;
+  }
+  if (symbol.GetStorageClass() == kScExtern && symbol.IsStatic()) {
+    const std::string &staticFieldName = symbol.GetName();
+    constexpr int kPosOffset = 3;
+    size_t pos = staticFieldName.find(namemangler::kClassNameSplitterStr) + kPosOffset;
+    if (pos != 0 && pos != std::string::npos) {
+      std::string className = staticFieldName.substr(0, pos);
+      MIRSymbol *classSt =
+          GlobalTables::GetGsymTable().GetSymbolFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(className));
+      if (classSt != nullptr) {
+        symbol.SetStorageClass(kScGlobal);
+      }
+    }
+  }
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->HasTypeParam()) {
+    symbol.SetAttr(ATTR_generic);
+    if (isLocal) {
+      mod.CurFunction()->SetAttr(FUNCATTR_generic);
+    }
+  }
+  return true;
+}
+
+bool MIRParser::ParseDeclareFormal(FormalDef &formalDef) {
+  TokenKind tk = lexer.GetTokenKind();
+  if (tk != TK_var && tk != TK_reg) {
+    return false;
+  }
+  TokenKind nameTk = lexer.NextToken();
+  if (tk == TK_var) {
+    if (nameTk != TK_lname) {
+      Error("expect local name but get ");
+      return false;
+    }
+    formalDef.formalStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  } else {  // tk == TK_reg
+    if (nameTk != TK_preg) {
+      Error("expect preg but get ");
+      return false;
+    }
+    formalDef.formalStrIdx =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(std::to_string(lexer.GetTheIntVal()));
+  }
+  (void)lexer.NextToken();
+  if (!ParseType(formalDef.formalTyIdx)) {
+    Error("ParseDeclareFormal failed when parsing the type");
+    return false;
+  }
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(formalDef.formalTyIdx)->GetKind() == kTypeByName) {
+    Error("type in var declaration cannot be forward-referenced at ");
+    return false;
+  }
+  if (!ParseTypeAttrs(formalDef.formalAttrs)) {
+    Error("ParseDeclareFormal failed when parsing type attributes");
+    return false;
+  }
+  return true;
+}
+
+bool MIRParser::ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &funcTyIdx) {
+  if (lexer.GetTokenKind() == TK_lbrace) {
+    if (mod.GetFlavor() < kMmpl) {
+      Error("funcion prototype missing for non-MMPL flavor of Maple IR");
+      return false;
+    }
+    // mmpl flavor has no prototype declaration, return normally
+    return true;
+  }
+  std::vector<TyIdx> vecTy;       // for storing the parameter types
+  std::vector<TypeAttrs> vecAt;  // for storing the parameter type attributes
+  // this part for parsing the argument list and return type
+  if (lexer.GetTokenKind() != TK_lparen) {
+    Error("expect ( for func but get ");
+    return false;
+  }
+  // parse parameters
+  bool varArgs = false;
+  TokenKind pmTk = lexer.NextToken();
+  while (pmTk != TK_rparen) {
+    if (pmTk == TK_dotdotdot) {
+      varArgs = true;
+      func.SetVarArgs();
+      pmTk = lexer.NextToken();
+      if (pmTk != TK_rparen) {
+        Error("expect ) after ... but get");
+        return false;
+      }
+      break;
+    } else {
+      FormalDef formalDef;
+      if (!ParseDeclareFormal(formalDef)) {
+        Error("ParsePrototype expects formal parameter declaration");
+        return false;
+      }
+      func.GetFormalDefVec().push_back(formalDef);
+      vecTy.push_back(formalDef.formalTyIdx);
+      vecAt.push_back(formalDef.formalAttrs);
+      pmTk = lexer.GetTokenKind();
+      if (pmTk == TK_coma) {
+        pmTk = lexer.NextToken();
+        if (pmTk == TK_rparen) {
+          Error("\',\' cannot be followed by");
+          return false;
+        }
+      }
+    }
+  }
+
+  // parse return type
+  lexer.NextToken();
+  TyIdx tyIdx(0);
+  if (!ParseType(tyIdx)) {
+    return false;
+  }
+  MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  func.SetReturnStruct(*retType);
+  MIRType *funcType =
+      GlobalTables::GetTypeTable().GetOrCreateFunctionType(tyIdx, vecTy, vecAt, varArgs);
+  funcTyIdx = funcType->GetTypeIndex();
+  funcSymbol.SetTyIdx(funcTyIdx);
+  func.SetMIRFuncType(static_cast<MIRFuncType*>(funcType));
+  return true;
+}
+
+// if prototype declaration, only create the symbol and type;
+// if a redeclaration, re-process the symbol and type declaration;
+// if function declaration, link MIRFunction to ->mod in addition
+bool MIRParser::ParseFunction(uint32 fileIdx) {
+  TokenKind tokenKind = lexer.GetTokenKind();
+  if (tokenKind != TK_func) {
+    Error("expect func but get ");
+    return false;
+  }
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_gname && lexer.GetTokenKind() != TK_fname) {
+    Error("expect function name for func but get ");
+    return false;
+  }
+  const std::string &funcName = lexer.GetName();
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+  MIRFunction *func = nullptr;
+  lexer.NextToken();
+  FuncAttrs funcAttrs;
+  if (!ParseFuncAttrs(funcAttrs)) {
+    Error("bad function attribute in function declaration at ");
+    return false;
+  }
+  if (funcSymbol != nullptr && funcSymbol->GetSKind() == kStFunc &&
+      funcSymbol->IsNeedForwDecl() == true && !funcSymbol->GetFunction()->GetBody()) {
+    SetSrcPos(funcSymbol->GetSrcPosition(), lexer.GetLineNum());
+  }
+  if (funcSymbol != nullptr) {
+    // there has been an earlier forward declaration, so check consistency
+    if (funcSymbol->GetStorageClass() != kScText || funcSymbol->GetSKind() != kStFunc) {
+      Error("redeclaration of name as func in ");
+      return false;
+    }
+    if (funcSymbol->GetFunction()->GetBody()) {
+      // Function definition has been processed. Here it may be
+      // another declaration due to multi-mpl merge. If this
+      // is indeed another definition, we will throw error.
+      MIRSymbol *tmpSymbol = mod.GetMemPool()->New<MIRSymbol>();
+      tmpSymbol->SetStorageClass(kScText);
+      tmpSymbol->SetAppearsInCode(true);
+      tmpSymbol->SetSKind(kStFunc);
+      MIRFunction *tmpFunc = mod.GetMemPool()->New<MIRFunction>(&mod, tmpSymbol->GetStIdx());
+      tmpSymbol->SetFunction(tmpFunc);
+      TyIdx tmpTyIdx;
+      if (!ParsePrototype(*tmpFunc, *tmpSymbol, tmpTyIdx)) {
+        return false;
+      }
+      if (lexer.GetTokenKind() == TK_lbrace) {
+        Error("function body defined second time in ");
+        return false;
+      }
+      return true;
+    }
+    // Skip attribute checking
+    func = funcSymbol->GetFunction();
+    func->ClearFormals();
+
+    // update with current attr
+    if (funcAttrs.GetAttrFlag() != 0) {
+      if (func->IsIpaSeen()) {
+        funcAttrs.SetAttr(FUNCATTR_ipaseen);
+      }
+      if (func->IsNoDefEffect()) {
+        funcAttrs.SetAttr(FUNCATTR_nodefeffect);
+      }
+      if (func->IsNoRetGlobal()) {
+        funcAttrs.SetAttr(FUNCATTR_noretglobal);
+      }
+      if (func->IsPure()) {
+        funcAttrs.SetAttr(FUNCATTR_pure);
+      }
+      if (func->IsNoThrowException()) {
+        funcAttrs.SetAttr(FUNCATTR_nothrow_exception);
+      }
+      if (func->IsNoDefArgEffect()) {
+        funcAttrs.SetAttr(FUNCATTR_nodefargeffect);
+      }
+      if (func->IsNoRetArg()) {
+        funcAttrs.SetAttr(FUNCATTR_noretarg);
+      }
+      if (func->IsNoPrivateDefEffect()) {
+        funcAttrs.SetAttr(FUNCATTR_noprivate_defeffect);
+      }
+      func->SetFuncAttrs(funcAttrs);
+    }
+  } else {
+    maple::MIRBuilder mirBuilder(&mod);
+    funcSymbol = mirBuilder.CreateSymbol(TyIdx(0), strIdx, kStFunc, kScText, nullptr, kScopeGlobal);
+    SetSrcPos(funcSymbol->GetSrcPosition(), lexer.GetLineNum());
+    func = mod.GetMemPool()->New<MIRFunction>(&mod, funcSymbol->GetStIdx());
+    func->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
+    GlobalTables::GetFunctionTable().GetFuncTable().push_back(func);
+    funcSymbol->SetFunction(func);
+    func->SetFuncAttrs(funcAttrs);
+  }
+  func->SetFileIndex(fileIdx);
+  curFunc = func;
+  if (mod.IsJavaModule()) {
+    func->SetBaseClassFuncNames(funcSymbol->GetNameStrIdx());
+  }
+  TyIdx funcTyidx;
+  if (!ParsePrototype(*func, *funcSymbol, funcTyidx)) {
+    return false;
+  }
+  if (lexer.GetTokenKind() == TK_lbrace) {  // #2 parse Function body
+    funcSymbol->SetAppearsInCode(true);
+    // when parsing func in mplt_inline file, set it as tmpunused.
+    if ((options & kParseInlineFuncBody) != 0) {
+      funcSymbol->SetIsTmpUnused(true);
+    }
+    definedLabels.clear();
+    mod.SetCurFunction(func);
+    mod.AddFunction(func);
+    // set line number for function
+    SetSrcPos(funcSymbol->GetSrcPosition(), lexer.GetLineNum());
+    // initialize source line number to be 0
+    // to avoid carrying over info from previous function
+    firstLineNum = 0;
+    lastLineNum = 0;
+    lastColumnNum = 0;
+    func->NewBody();
+    BlockNode *block = nullptr;
+    safeRegionFlag.push(curFunc->IsSafe());
+    auto isParseSucc = ParseStmtBlock(block);
+    safeRegionFlag.pop();
+    if (!isParseSucc) {
+      Error("ParseFunction failed when parsing stmt block");
+      ResetCurrentFunction();
+      return false;
+    }
+    func->SetBody(block);
+    // check if any local type name is undefined
+    for (auto it : func->GetGStrIdxToTyIdxMap()) {
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(it.second);
+      if (type->GetKind() == kTypeByName) {
+        std::string strStream;
+        const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(it.first);
+        strStream += "type %";
+        strStream += name;
+        strStream += " used but not defined\n";
+        message += strStream;
+        ResetCurrentFunction();
+        return false;
+      }
+    }
+  }
+  ResetCurrentFunction();
+  return true;
+}
+
+bool MIRParser::ParseInitValue(MIRConstPtr &theConst, TyIdx tyIdx, bool allowEmpty) {
+  TokenKind tokenKind = lexer.GetTokenKind();
+  MIRType &type = *GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  if (tokenKind != TK_lbrack) {  // scalar
+    MIRConst *mirConst = nullptr;
+    if (IsConstValue(tokenKind)) {
+      if (!ParseScalarValue(mirConst, type)) {
+        Error("ParseInitValue expect scalar value");
+        return false;
+      }
+      lexer.NextToken();
+    } else if (IsConstAddrExpr(tokenKind)) {
+      if (!ParseConstAddrLeafExpr(mirConst)) {
+        Error("ParseInitValue expect const addr expr");
+        return false;
+      }
+    } else {
+      Error("initialiation value expected but get ");
+      return false;
+    }
+    theConst = mirConst;
+  } else {  // aggregates
+    FixForwardReferencedTypeForOneAgg(&type);
+    if (type.GetKind() == kTypeArray) {
+      auto &arrayType = static_cast<MIRArrayType&>(type);
+      MIRType *elemType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrayType.GetElemTyIdx());
+      MIRAggConst *newConst = mod.GetMemPool()->New<MIRAggConst>(mod, type);
+      theConst = newConst;
+      tokenKind = lexer.NextToken();
+      if (tokenKind == TK_rbrack) {
+        if (allowEmpty) {
+          lexer.NextToken();
+          return true;
+        } else {
+          Error("illegal empty initialization for array at ");
+          return false;
+        }
+      }
+      do {
+        // parse single const or another dimension array
+        MIRConst *subConst = nullptr;
+        if (IsConstValue(tokenKind)) {
+          if (!ParseScalarValue(subConst, *elemType)) {
+            Error("ParseInitValue expect scalar value");
+            return false;
+          }
+          lexer.NextToken();
+        } else if (IsConstAddrExpr(tokenKind)) {
+          if (!ParseConstAddrLeafExpr(subConst)) {
+            Error("ParseInitValue expect const addr expr");
+            return false;
+          }
+        } else if (tokenKind == TK_lbrack) {
+          if (elemType->GetKind() == kTypeStruct && arrayType.GetDim() == 1) {
+            if (!ParseInitValue(subConst, arrayType.GetElemTyIdx(), allowEmpty)) {
+              Error("initializaton value wrong when parsing structure array ");
+              return false;
+            }
+          } else {
+            TyIdx elemTyIdx;
+            if (arrayType.GetDim() == 1) {
+              elemTyIdx = elemType->GetTypeIndex();
+            } else {
+              std::vector<uint32> sizeSubArray;
+              for (uint16 i = 1; i < arrayType.GetDim(); ++i) {
+                sizeSubArray.push_back(arrayType.GetSizeArrayItem(i));
+              }
+              MIRArrayType subArrayType(elemType->GetTypeIndex(), sizeSubArray);
+              elemTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&subArrayType);
+            }
+            if (!ParseInitValue(subConst, elemTyIdx, allowEmpty)) {
+              Error("initializaton value wrong when parsing sub array ");
+              return false;
+            }
+          }
+        } else {
+          Error("expect const value or group of const values but get ");
+          return false;
+        }
+        newConst->AddItem(subConst, 0);
+        // parse comma or rbrack
+        tokenKind = lexer.GetTokenKind();
+        if (tokenKind == TK_coma) {
+          tokenKind = lexer.NextToken();
+          if (tokenKind == TK_rbrack) {
+            Error("not expect, followed by ] ");
+            return false;
+          }
+        }
+      } while (tokenKind != TK_rbrack);
+      lexer.NextToken();
+    } else if (type.GetKind() == kTypeStruct || type.GetKind() == kTypeUnion) {
+      MIRAggConst *newConst = mod.GetMemPool()->New<MIRAggConst>(mod, type);
+      uint32 theFieldIdx;
+      TyIdx fieldTyIdx;
+      theConst = newConst;
+      tokenKind = lexer.NextToken();
+      if (tokenKind == TK_rbrack) {
+        if (allowEmpty) {
+          lexer.NextToken();
+          return true;
+        } else {
+          Error("illegal empty initialization for struct at ");
+          return false;
+        }
+      }
+      do {
+        if (lexer.GetTokenKind() != TK_intconst) {
+          Error("expect field ID in struct initialization but get ");
+          return false;
+        }
+        theFieldIdx = static_cast<uint32>(lexer.GetTheIntVal());
+        if (lexer.NextToken() != TK_eqsign) {
+          Error("expect = after field ID in struct initialization but get ");
+          return false;
+        }
+        FieldPair thepair = static_cast<MIRStructType &>(type).GetFields()[theFieldIdx - 1];
+        fieldTyIdx = thepair.second.first;
+        if (fieldTyIdx == 0u) {
+          Error("field ID out of range at struct initialization at ");
+          return false;
+        }
+        tokenKind = lexer.NextToken();
+        MIRConst *subConst = nullptr;
+        if (IsConstValue(tokenKind)) {
+          if (!ParseScalarValue(subConst, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx))) {
+            Error("ParseInitValue expect scalar value");
+            return false;
+          }
+          lexer.NextToken();
+        } else if (IsConstAddrExpr(tokenKind)) {
+          if (!ParseConstAddrLeafExpr(subConst)) {
+            Error("ParseInitValue expect const addr expr");
+            return false;
+          }
+        } else if (tokenKind == TK_lbrack) {
+          if (!ParseInitValue(subConst, fieldTyIdx, allowEmpty)) {
+            Error("parse init value wrong when parse sub struct ");
+            return false;
+          }
+        } else {
+          Error("expect const value or group of const values but get ");
+          return false;
+        }
+        ASSERT(subConst != nullptr, "subConst is null in MIRParser::ParseInitValue");
+        newConst->AddItem(subConst, theFieldIdx);
+        tokenKind = lexer.GetTokenKind();
+        // parse comma or rbrack
+        if (tokenKind == TK_coma) {
+          tokenKind = lexer.NextToken();
+          if (tokenKind == TK_rbrack) {
+            Error("not expect \',\' followed by ] ");
+            return false;
+          }
+        }
+      } while (tokenKind != TK_rbrack);
+      lexer.NextToken();
+    } else {
+      Error("non-struct should not have aggregate initialization in ");
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MIRParser::ParseFuncInfo() {
+  if (lexer.GetTokenKind() != TK_lbrace) {
+    Error("expect left brace after funcinfo but get ");
+    return false;
+  }
+  MIRFunction *func = mod.CurFunction();
+  TokenKind tokenKind = lexer.NextToken();
+  while (tokenKind == TK_label) {
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    tokenKind = lexer.NextToken();
+    if (tokenKind == TK_intconst) {
+      uint32 fieldVal = lexer.GetTheIntVal();
+      func->PushbackMIRInfo(MIRInfoPair(strIdx, fieldVal));
+      func->PushbackIsString(false);
+    } else if (tokenKind == TK_string) {
+      GStrIdx literalStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+      func->PushbackMIRInfo(MIRInfoPair(strIdx, literalStrIdx));
+      func->PushbackIsString(true);
+    } else {
+      Error("illegal value after funcinfo field name at ");
+      return false;
+    }
+    tokenKind = lexer.NextToken();
+    if (tokenKind == TK_rbrace) {
+      lexer.NextToken();
+      return true;
+    }
+    if (tokenKind == TK_coma) {
+      tokenKind = lexer.NextToken();
+    } else {
+      Error("expect comma after funcinfo field value but get ");
+      return false;
+    }
+  }
+  Error("expect field name in funcinfo but get ");
+  return false;
+}
+
+bool MIRParser::ParsePosition(SrcPosition &pos) {
+  TokenKind nameTk = lexer.NextToken();
+  if (nameTk != TK_lparen) {
+    Error("expect ( in SrcPos but get ");
+    return false;
+  }
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_intconst) {
+    Error("expect int in SrcPos but get ");
+    return false;
+  }
+  uint32 i = static_cast<uint32>(lexer.GetTheIntVal());
+  pos.SetFileNum(static_cast<uint16>(i));
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_coma) {
+    Error("expect comma in SrcPos but get ");
+    return false;
+  }
+
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_intconst) {
+    Error("expect int in SrcPos but get ");
+    return false;
+  }
+  i = static_cast<uint32>(lexer.GetTheIntVal());
+  pos.SetLineNum(i);
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_coma) {
+    Error("expect comma in SrcPos but get ");
+    return false;
+  }
+
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_intconst) {
+    Error("expect int in SrcPos but get ");
+    return false;
+  }
+  i = static_cast<uint32>(lexer.GetTheIntVal());
+  pos.SetColumn(static_cast<uint16>(i));
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_rparen) {
+    Error("expect ) in SrcPos but get ");
+    return false;
+  }
+
+  return true;
+}
+
+bool MIRParser::ParseOneScope(MIRScope &scope) {
+  TokenKind nameTk = lexer.GetTokenKind();
+  if (nameTk != TK_SCOPE) {
+    Error("expect SCOPE but get ");
+    return false;
+  }
+  nameTk = lexer.NextToken();
+  if (nameTk == TK_intconst) {
+    uint32 i = static_cast<uint32>(lexer.GetTheIntVal());
+    scope.SetId(i);
+    nameTk = lexer.NextToken();
+  }
+  if (nameTk != TK_langle) {
+    Error("expect < in SCOPE but get ");
+    return false;
+  }
+  SrcPosition low;
+  if (!ParsePosition(low)) {
+    Error("parsePosition low failed when parsing SCOPE ");
+    return false;
+  }
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_coma) {
+    Error("expect comma in SCOPE but get ");
+    return false;
+  }
+  SrcPosition high;
+  if (!ParsePosition(high)) {
+    Error("parsePosition high failed when parsing SCOPE ");
+    return false;
+  }
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_rangle) {
+    Error("expect > in SCOPE but get ");
+    return false;
+  }
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_lbrace) {
+    Error("expect { in SCOPE but get ");
+    return false;
+  }
+  scope.SetRange(low, high);
+  nameTk = lexer.NextToken();
+  while (1) {
+    bool status = false;
+    switch (lexer.GetTokenKind()) {
+      case TK_ALIAS: {
+        GStrIdx strIdx;
+        MIRAliasVars aliasVar;
+        status = ParseOneAlias(strIdx, aliasVar);
+        if (status) {
+          scope.SetAliasVarMap(strIdx, aliasVar);
+        }
+        break;
+      }
+      case TK_TYPEALIAS: {
+        status = ParseTypeAlias(scope);
+        break;
+      }
+      case TK_SCOPE: {
+        MIRScope *scp = mod.GetMemPool()->New<MIRScope>(&mod, mod.CurFunction());
+        status = ParseOneScope(*scp);
+        if (status && !scp->IsEmpty()) {
+          if (scope.GetRangeLow().IsEq(scp->GetRangeLow()) &&
+              scope.GetRangeHigh().IsEq(scp->GetRangeHigh())) {
+            for (auto it : scp->GetAliasVarMap()) {
+              scope.SetAliasVarMap(it.first, it.second);
+            }
+            for (auto it : scp->GetSubScopes()) {
+              (void)scope.AddScope(it);
+            }
+          } else {
+            scope.AddScope(scp);
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    if (!status) {
+      break;
+    }
+  }
+  nameTk = lexer.GetTokenKind();
+  if (nameTk != TK_rbrace) {
+    Error("expect } in SCOPE but get ");
+    return false;
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseScope() {
+  MIRScope *scp = nullptr;
+  MIRFunction *func = mod.CurFunction();
+  CHECK_NULL_FATAL(func);
+  if (func->GetBody()) {
+    scp = func->GetScope();
+  } else {
+    scp = mod.GetScope();
+  }
+  bool status = ParseOneScope(*scp);
+  return status;
+}
+
+bool MIRParser::ParseScopeStmt(StmtNodePtr&) {
+  return ParseScope();
+}
+
+bool MIRParser::ParseOneAlias(GStrIdx &strIdx, MIRAliasVars &aliasVar) {
+  TokenKind nameTk = lexer.GetTokenKind();
+  if (nameTk != TK_ALIAS) {
+    Error("expect ALIAS but get ");
+    return false;
+  }
+  nameTk = lexer.NextToken();
+  if (nameTk != TK_lname && nameTk != TK_gname) {
+    Error("expect local or global in ALIAS but get ");
+    return false;
+  }
+  strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  nameTk = lexer.NextToken();
+  if (nameTk == TK_lname) {
+    aliasVar.isLocal = true;
+  } else if (nameTk == TK_gname) {
+    aliasVar.isLocal = false;
+  } else {
+    Error("expect name in ALIAS but get ");
+    return false;
+  }
+  GStrIdx mplStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  aliasVar.mplStrIdx = mplStrIdx;
+  lexer.NextToken();
+  TokenKind tk = lexer.GetTokenKind();
+  TyIdx tyIdx(0);
+  if (tk == TK_string) {
+    // original type name from source code
+    std::string typeName = lexer.GetName();
+    GStrIdx srcTypeStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+    aliasVar.atk = kATKString;
+    aliasVar.index = srcTypeStrIdx.GetIdx();
+    lexer.NextToken();
+  } else if (tk == TK_gname) {
+    // type name or enum name
+    std::string typeName = lexer.GetName();
+    GStrIdx typeStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeName);
+    tyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(typeStrIdx);
+    if (tyIdx.GetIdx() != 0) {
+      aliasVar.atk = kATKType;
+      aliasVar.index = tyIdx.GetIdx();
+    } else {
+      auto size = GlobalTables::GetEnumTable().enumTable.size();
+      for (size_t i = 0; i < size; ++i) {
+        MIREnum *mirEnum = GlobalTables::GetEnumTable().enumTable[i];
+        if (typeStrIdx == mirEnum->GetNameIdx()) {
+          aliasVar.atk = kATKEnum;
+          aliasVar.index = i;
+        }
+      }
+    }
+    lexer.NextToken();
+  } else if (ParseType(tyIdx)) {
+    aliasVar.atk = kATKType;
+    aliasVar.index = tyIdx.GetIdx();
+  } else {
+    Error("parseType failed when parsing ALIAS ");
+    return false;
+  }
+  // parse type attributes
+  if (!ParseTypeAttrs(aliasVar.attrs)) {
+    Error("bad type attribute for alias at ");
+    return false;
+  }
+  GStrIdx signStrIdx(0);
+  if (lexer.GetTokenKind() == TK_string) {
+    signStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    lexer.NextToken();
+  }
+  aliasVar.sigStrIdx = signStrIdx;
+  tk = lexer.GetTokenKind();
+  if (tk == TK_coma) {
+    (void)lexer.NextToken();
+  }
+  return true;
+}
+
+bool MIRParser::ParseAlias() {
+  GStrIdx strIdx;
+  MIRAliasVars aliasVar;
+
+  ParseOneAlias(strIdx, aliasVar);
+
+  mod.CurFunction()->SetAliasVarMap(strIdx, aliasVar);
+  return true;
+}
+
+bool MIRParser::ParseAliasStmt(StmtNodePtr&) {
+  return ParseAlias();
+}
+
+bool MIRParser::ParseTypeAlias(MIRScope &scope) {
+  if (lexer.GetTokenKind() != TK_TYPEALIAS) {
+    Error("expect typealias but get ");
+    return false;
+  }
+  TokenKind tokenKind = lexer.NextToken();
+  if (tokenKind != TK_gname) {
+    Error("expect typealias name but get ");
+    return false;
+  }
+  const std::string &name = lexer.GetName();
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  lexer.NextToken();
+  TyIdx tyIdx(0);
+  if (!ParseType(tyIdx)) {
+    Error("expect underlying type name but get ");
+    return false;
+  }
+  scope.SetTypeAliasMap(strIdx, tyIdx);
+  if (!scope.IsLocal()) {
+    mod.GetScope()->GetTypeAlias()->SetTypeAliasMap(strIdx, tyIdx);
+  }
+  TokenKind tk = lexer.GetTokenKind();
+  if (tk == TK_coma) {
+    (void)lexer.NextToken();
+  }
+  return true;
+}
+
+uint8 *MIRParser::ParseWordsInfo(uint32 size) {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_eqsign) {
+    Error("expect = after it but get ");
+    return nullptr;
+  }
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_lbrack) {
+    Error("expect [ for it but get ");
+    return nullptr;
+  }
+  uint8 *origp = static_cast<uint8*>(mod.GetMemPool()->Malloc(BlockSize2BitVectorSize(size)));
+  // initialize it based on the input
+  for (uint32 *p = reinterpret_cast<uint32*>(origp); lexer.NextToken() == TK_intconst; ++p) {
+    *p = static_cast<uint32>(lexer.GetTheIntVal());
+  }
+  if (lexer.GetTokenKind() != TK_rbrack) {
+    Error("expect ] at end of globalwordstypetagged but get ");
+    return nullptr;
+  }
+  lexer.NextToken();
+  return origp;
+}
+
+static void GenJStringType(MIRModule &module) {
+  MIRStructType metaClassType(kTypeStructIncomplete);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("dummy");
+  metaClassType.GetFields().push_back(FieldPair(strIdx, TyIdxFieldAttrPair(TyIdx(PTY_ref), FieldAttrs())));
+  strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("__class_meta__");
+  metaClassType.SetNameStrIdx(strIdx);
+  TyIdx tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&metaClassType);
+  // Global
+  module.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx);
+  ASSERT(GlobalTables::GetTypeTable().GetTypeTable().empty() == false, "container check");
+}
+
+bool MIRParser::ParseMIR(std::ifstream &mplFile) {
+  std::ifstream *origFile = lexer.GetFile();
+  // parse mplfile
+  lexer.SetFile(mplFile);
+  // try to read the first line
+  if (lexer.ReadALine() < 0) {
+    lexer.lineNum = 0;
+  } else {
+    lexer.lineNum = 1;
+  }
+  // for optimized functions file
+  bool status = ParseMIR(0, kParseOptFunc);
+  // restore airFile
+  lexer.SetFile(*origFile);
+  return status;
+}
+
+bool MIRParser::ParseInlineFuncBody(std::ifstream &mplFile) {
+  std::ifstream *origFile = lexer.GetFile();
+  lexer.SetFile(mplFile);
+  // try to read the first line
+  if (lexer.ReadALine() < 0) {
+    lexer.lineNum = 0;
+  } else {
+    lexer.lineNum = 1;
+  }
+  // parse mplFile
+  bool status = ParseMIR(0, kParseOptFunc | kParseInlineFuncBody);
+  // restore airFile
+  lexer.SetFile(*origFile);
+  return status;
+}
+
+bool MIRParser::ParseSrcLang(MIRSrcLang &srcLang) {
+  PrepareParsingMIR();
+  bool atEof = false;
+  lexer.NextToken();
+  while (!atEof) {
+    paramTokenKind = lexer.GetTokenKind();
+    if (paramTokenKind == TK_eof) {
+      atEof = true;
+    } else if (paramTokenKind == TK_srclang) {
+      lexer.NextToken();
+      if (lexer.GetTokenKind() != TK_intconst) {
+        Error("expect integer after srclang but get ");
+        return false;
+      }
+      srcLang = static_cast<MIRSrcLang>(lexer.GetTheIntVal());
+      return true;
+    } else {
+      lexer.NextToken();
+    }
+  }
+  return false;
+}
+
+bool MIRParser::ParseMIR(uint32 fileIdx, uint32 option, bool isIPA, bool isComb) {
+  if ((option & kParseOptFunc) == 0) {
+    PrepareParsingMIR();
+  }
+  if (option != 0) {
+    this->options |= option;
+  }
+  // profiling setup
+  mod.SetWithProfileInfo(((this->options & kWithProfileInfo) != 0));
+  bool atEof = false;
+  paramFileIdx = fileIdx;
+  paramIsIPA = isIPA;
+  paramIsComb = isComb;
+  lexer.NextToken();
+  while (!atEof) {
+    paramTokenKind = lexer.GetTokenKind();
+    std::map<TokenKind, FuncPtrParseMIRForElem>::iterator itFuncPtr = funcPtrMapForParseMIR.find(paramTokenKind);
+    if (itFuncPtr == funcPtrMapForParseMIR.end()) {
+      if (paramTokenKind == TK_eof) {
+        atEof = true;
+      } else {
+        Error("expect func or var but get ");
+        return false;
+      }
+    } else {
+      if (!(this->*(itFuncPtr->second))()) {
+        return false;
+      }
+    }
+  }
+  // fix the typedef type
+  FixupForwardReferencedTypeByMap();
+  // check if any global type name is undefined
+  if (!opts::withDwarf) {
+    for (auto it = mod.GetTypeNameTab()->GetGStrIdxToTyIdxMap().begin();
+         it != mod.GetTypeNameTab()->GetGStrIdxToTyIdxMap().end(); ++it) {
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(it->second);
+      CHECK_FATAL(type != nullptr, "type is null");
+      if (type->GetKind() == kTypeByName) {
+        TyIdx tyIdx = mod.GetScope()->GetTypeAlias()->GetTyIdxFromMap(it->first);
+        if (tyIdx.GetIdx() != 0) {
+          continue;
+        }
+        std::string strStream;
+        const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(it->first);
+        strStream += "type $";
+        strStream += name;
+        strStream += " used but not defined\n";
+        message += strStream;
+        return false;
+      }
+    }
+  }
+  if (!isIPA && isComb) {
+    for (auto it = paramImportFileList.begin(); it != paramImportFileList.end(); ++it) {
+      BinaryMplt binMplt(mod);
+      std::string importFilename = *it;
+      if (!binMplt.Import(importFilename, false, true)) {  // not a binary mplt
+        std::ifstream mpltFile(importFilename);
+        if (!mpltFile.is_open()) {
+          FATAL(kLncFatal, "cannot open MPLT file: %s\n", importFilename.c_str());
+        }
+        bool failedParse = !ParseMPLT(mpltFile, importFilename);
+        mpltFile.close();
+        if (failedParse) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+std::map<TokenKind, MIRParser::FuncPtrParseMIRForElem> MIRParser::InitFuncPtrMapForParseMIR() {
+  std::map<TokenKind, MIRParser::FuncPtrParseMIRForElem> funcPtrMap;
+  funcPtrMap[TK_func] = &MIRParser::ParseMIRForFunc;
+  funcPtrMap[TK_tempvar] = &MIRParser::ParseMIRForVar;
+  funcPtrMap[TK_var] = &MIRParser::ParseMIRForVar;
+  funcPtrMap[TK_javaclass] = &MIRParser::ParseMIRForClass;
+  funcPtrMap[TK_javainterface] = &MIRParser::ParseMIRForInterface;
+  funcPtrMap[TK_type] = &MIRParser::ParseTypeDefine;
+  funcPtrMap[TK_flavor] = &MIRParser::ParseMIRForFlavor;
+  funcPtrMap[TK_srclang] = &MIRParser::ParseMIRForSrcLang;
+  funcPtrMap[TK_globalmemsize] = &MIRParser::ParseMIRForGlobalMemSize;
+  funcPtrMap[TK_globalmemmap] = &MIRParser::ParseMIRForGlobalMemMap;
+  funcPtrMap[TK_globalwordstypetagged] = &MIRParser::ParseMIRForGlobalWordsTypeTagged;
+  funcPtrMap[TK_globalwordsrefcounted] = &MIRParser::ParseMIRForGlobalWordsRefCounted;
+  funcPtrMap[TK_id] = &MIRParser::ParseMIRForID;
+  funcPtrMap[TK_numfuncs] = &MIRParser::ParseMIRForNumFuncs;
+  funcPtrMap[TK_entryfunc] = &MIRParser::ParseMIRForEntryFunc;
+  funcPtrMap[TK_fileinfo] = &MIRParser::ParseMIRForFileInfo;
+  funcPtrMap[TK_filedata] = &MIRParser::ParseMIRForFileData;
+  funcPtrMap[TK_srcfileinfo] = &MIRParser::ParseMIRForSrcFileInfo;
+  funcPtrMap[TK_import] = &MIRParser::ParseMIRForImport;
+  funcPtrMap[TK_importpath] = &MIRParser::ParseMIRForImportPath;
+  funcPtrMap[TK_asmdecl] = &MIRParser::ParseMIRForAsmdecl;
+  funcPtrMap[TK_LOC] = &MIRParser::ParseLoc;
+  funcPtrMap[TK_ALIAS] = &MIRParser::ParseAlias;
+  funcPtrMap[TK_SCOPE] = &MIRParser::ParseScope;
+  funcPtrMap[TK_ENUMERATION] = &MIRParser::ParseEnumeration;
+  return funcPtrMap;
+}
+
+bool MIRParser::ParseMIRForFunc() {
+  curFunc = nullptr;
+  if (!ParseFunction(paramFileIdx)) {
+    return false;
+  }
+  // when parsing function in mplt_inline file, set fromMpltInline as true.
+  if ((this->options & kParseInlineFuncBody) && curFunc) {
+    curFunc->SetFromMpltInline(true);
+    return true;
+  }
+  if ((this->options & kParseOptFunc) && curFunc) {
+    curFunc->SetAttr(FUNCATTR_optimized);
+    mod.AddOptFuncs(curFunc);
+  }
+  return true;
+}
+
+bool MIRParser::TypeCompatible(const TyIdx &typeIdx1, const TyIdx &typeIdx2) const {
+  if (typeIdx1 == typeIdx2) {
+    return true;
+  }
+  MIRType *type1 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx1);
+  MIRType *type2 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx2);
+  if (type1 == nullptr || type2 == nullptr) {
+    // this means we saw the use of this symbol before def.
+    return false;
+  }
+  while (type1->IsMIRPtrType() || type1->IsMIRArrayType()) {
+    if (type1->IsMIRPtrType()) {
+      CHECK_FATAL(type2->IsMIRPtrType(), "Error");
+      type1 = static_cast<MIRPtrType *>(type1)->GetPointedType();
+      type2 = static_cast<MIRPtrType *>(type2)->GetPointedType();
+    } else {
+      CHECK_FATAL(type2->IsMIRArrayType(), "Error");
+      auto *arrayType1 = static_cast<MIRArrayType *>(type1);
+      auto *arrayType2 = static_cast<MIRArrayType *>(type2);
+      if (arrayType1->IsIncompleteArray() || arrayType2->IsIncompleteArray()) {
+        return true;
+      }
+      type1 = static_cast<MIRArrayType *>(type1)->GetElemType();
+      type2 = static_cast<MIRArrayType *>(type2)->GetElemType();
+    }
+  }
+  if (type1 == type2) {
+    return true;
+  }
+  if (type1->IsIncomplete() || type2->IsIncomplete()) {
+    return true;
+  }
+  return false;
+}
+
+bool MIRParser::IsTypeIncomplete(MIRType *type) const {
+  if (type->IsIncomplete()) {
+    return true;
+  }
+  while (type->IsMIRPtrType() || type->IsMIRArrayType()) {
+    if (type->IsMIRPtrType()) {
+      type = static_cast<MIRPtrType *>(type)->GetPointedType();
+    } else {
+      auto *arrayType = static_cast<MIRArrayType *>(type);
+      if (arrayType->IsIncompleteArray()) {
+        return true;
+      }
+      type = static_cast<MIRArrayType *>(type)->GetElemType();
+    }
+  }
+  return type->IsIncomplete();
+}
+
+bool MIRParser::ParseMIRForVar() {
+  MIRSymbol st(0, kScopeGlobal);
+  st.SetStorageClass(kScGlobal);
+  st.SetSKind(kStVar);
+  if (paramTokenKind == TK_tempvar) {
+    st.SetIsTmp(true);
+  }
+  if (!ParseDeclareVar(st)) {
+    return false;
+  }
+  MIRSymbol *prevSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(st.GetNameStrIdx());
+  if (prevSt != nullptr) {
+    bool ret = TypeCompatible(prevSt->GetTyIdx(), st.GetTyIdx());
+#ifdef DEBUG
+    if (!ret) {
+      LogInfo::MapleLogger() << "\n=====prevSymbol===== \n";
+      prevSt->Dump(false, 0);
+      LogInfo::MapleLogger() << "\n=====curSymbol===== \n";
+      st.Dump(false, 0);
+      LogInfo::MapleLogger() << "\n=====   end   ===== \n";
+    }
+#endif
+    if (ret &&
+        (prevSt->GetStorageClass() == st.GetStorageClass() || prevSt->GetStorageClass() == kScExtern ||
+         st.GetStorageClass() == kScExtern) &&
+        prevSt->GetSKind() == st.GetSKind() && (prevSt->GetKonst() == nullptr || st.GetKonst() == nullptr)) {
+      // previously declared: accumulate new information to the symbol
+      prevSt->GetAttrs().SetAttrFlag(prevSt->GetAttrs().GetAttrFlag() | st.GetAttrs().GetAttrFlag());
+      if (prevSt->GetKonst() == nullptr) {
+        prevSt->SetKonst(st.GetKonst());
+      }
+      if (prevSt->GetStorageClass() == kScExtern) {
+        prevSt->SetStorageClass(st.GetStorageClass());
+      }
+      if (prevSt->sectionAttr == UStrIdx(0)) {
+        prevSt->sectionAttr = st.sectionAttr;
+      }
+      if (IsTypeIncomplete(prevSt->GetType())) {
+        prevSt->SetTyIdx(st.GetTyIdx());
+      }
+    } else if (prevSt->GetSKind() == maple::kStVar && prevSt->GetStorageClass() ==  maple::kScInvalid) {
+      prevSt->SetStorageClass(kScGlobal);
+      prevSt->SetAttrs(st.GetAttrs());
+      prevSt->SetNameStrIdx(st.GetNameStrIdx());
+      prevSt->sectionAttr = st.sectionAttr;
+      prevSt->SetValue(st.GetValue());
+      prevSt->SetTyIdx(st.GetTyIdx());
+      SetSrcPos(prevSt->GetSrcPosition(), lexer.GetLineNum());
+    }
+    if (!ParseDeclareVarInitValue(*prevSt)) {
+      return false;
+    }
+  } else {  // seeing the first time
+    maple::MIRBuilder mirBuilder(&mod);
+    MIRSymbol *newst = mirBuilder.CreateSymbol(st.GetTyIdx(), st.GetNameStrIdx(), st.GetSKind(), st.GetStorageClass(),
+                                               nullptr, kScopeGlobal);
+    // when parsing var in mplt_inline file, set it as tmpunused.
+    if ((this->options & kParseInlineFuncBody) != 0) {
+      newst->SetIsTmpUnused(true);
+    }
+    newst->SetAttrs(st.GetAttrs());
+    newst->SetNameStrIdx(st.GetNameStrIdx());
+    newst->sectionAttr = st.sectionAttr;
+    newst->SetValue(st.GetValue());
+    SetSrcPos(newst->GetSrcPosition(), lexer.GetLineNum());
+    if (!ParseDeclareVarInitValue(*newst)) {
+      return false;
+    }
+  }
+  if (mod.CurFunction() && mod.GetFunctionList().empty()) {
+    mod.CurFunction()->ReleaseCodeMemory();
+  }
+  return true;
+}
+
+bool MIRParser::ParseMIRForClass() {
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  ASSERT(st != nullptr, "st nullptr check");
+  st->SetStorageClass(kScInvalid);
+  st->SetSKind(kStJavaClass);
+  return ParseJavaClassInterface(*st, true);
+}
+
+bool MIRParser::ParseMIRForInterface() {
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  ASSERT(st != nullptr, "st nullptr check");
+  st->SetStorageClass(kScInvalid);
+  st->SetSKind(kStJavaInterface);
+  return ParseJavaClassInterface(*st, false);
+}
+
+bool MIRParser::ParseMIRForFlavor() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after flavor but get ");
+    return false;
+  }
+  mod.SetFlavor(static_cast<MIRFlavor>(lexer.GetTheIntVal()));
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseMIRForSrcLang() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after srclang but get ");
+    return false;
+  }
+  mod.SetSrcLang(static_cast<MIRSrcLang>(lexer.GetTheIntVal()));
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseMIRForGlobalMemSize() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after globalmemsize but get ");
+    return false;
+  }
+  mod.SetGlobalMemSize(lexer.GetTheIntVal());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseMIRForGlobalMemMap() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_eqsign) {
+    Error("expect = after globalmemmap but get ");
+    return false;
+  }
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_lbrack) {
+    Error("expect [ for globalmemmap but get ");
+    return false;
+  }
+  mod.SetGlobalBlockMap(static_cast<uint8*>(mod.GetMemPool()->Malloc(mod.GetGlobalMemSize())));
+  // initialize globalblkmap based on the input
+  for (uint32 *p = reinterpret_cast<uint32*>(mod.GetGlobalBlockMap()); lexer.NextToken() == TK_intconst; ++p) {
+    *p = static_cast<uint32>(lexer.GetTheIntVal());
+  }
+  if (lexer.GetTokenKind() != TK_rbrack) {
+    Error("expect ] at end of globalmemmap but get ");
+    return false;
+  }
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseMIRForGlobalWordsTypeTagged() {
+  uint8 *typeAddr = ParseWordsInfo(mod.GetGlobalMemSize());
+  if (typeAddr == nullptr) {
+    Error("parser error for globalwordstypetagged");
+    return false;
+  }
+  mod.SetGlobalWordsTypeTagged(typeAddr);
+  return true;
+}
+
+bool MIRParser::ParseMIRForGlobalWordsRefCounted() {
+  uint8 *refAddr = ParseWordsInfo(mod.GetGlobalMemSize());
+  if (refAddr == nullptr) {
+    Error("parser error for globalwordsrefcounted");
+    return false;
+  }
+  mod.SetGlobalWordsRefCounted(refAddr);
+  return true;
+}
+
+bool MIRParser::ParseMIRForID() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after id but get ");
+    return false;
+  }
+  mod.SetID(static_cast<uint16>(lexer.GetTheIntVal()));
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseMIRForNumFuncs() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_intconst) {
+    Error("expect integer after numfuncs but get ");
+    return false;
+  }
+  mod.SetNumFuncs(lexer.GetTheIntVal());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseMIRForEntryFunc() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_fname) {
+    Error("expect function name for func but get ");
+    return false;
+  }
+  mod.SetEntryFuncName(lexer.GetName());
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseMIRForFileInfo() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_lbrace) {
+    Error("expect left brace after fileInfo but get ");
+    return false;
+  }
+  TokenKind tk = lexer.NextToken();
+  while (tk == TK_label) {
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    tk = lexer.NextToken();
+    if (tk == TK_intconst) {
+      uint32 fieldVal = lexer.GetTheIntVal();
+      mod.PushFileInfoPair(MIRInfoPair(strIdx, fieldVal));
+      mod.PushFileInfoIsString(false);
+    } else if (tk == TK_string) {
+      GStrIdx litStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+      mod.PushFileInfoPair(MIRInfoPair(strIdx, litStrIdx));
+      mod.PushFileInfoIsString(true);
+    } else {
+      Error("illegal value after fileInfo field name at ");
+      return false;
+    }
+    tk = lexer.NextToken();
+    if (tk == TK_rbrace) {
+      lexer.NextToken();
+      return true;
+    }
+    if (tk == TK_coma) {
+      tk = lexer.NextToken();
+    } else {
+      Error("expect comma after fileInfo field value but get ");
+      return false;
+    }
+  }
+  Error("expect field name in fileInfo but get ");
+  return false;
+}
+
+bool MIRParser::ParseMIRForFileData() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_lbrace) {
+    Error("expect left brace after fileData but get ");
+    return false;
+  }
+  TokenKind tk = lexer.NextToken();
+  while (tk == TK_label) {
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    tk = lexer.NextToken();
+    std::vector<uint8> data;
+    while (tk == TK_intconst) {
+      uint32 fieldVal = lexer.GetTheIntVal();
+      data.push_back(fieldVal);
+      tk = lexer.NextToken();
+    }
+    mod.PushbackFileData(MIRDataPair(strIdx, data));
+    if (tk == TK_coma) {
+      tk = lexer.NextToken();
+    } else if (tk == TK_rbrace) {
+      lexer.NextToken();
+      return true;
+    } else {
+      Error("expect comma after fileData field value but get ");
+      return false;
+    }
+  }
+  Error("expect field name in fileData but get ");
+  return false;
+}
+
+bool MIRParser::ParseMIRForSrcFileInfo() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_lbrace) {
+    Error("expect left brace after fileInfo but get ");
+    return false;
+  }
+  TokenKind tk = lexer.NextToken();
+  while (tk == TK_intconst) {
+    uint32 fieldVal = lexer.GetTheIntVal();
+    tk = lexer.NextToken();
+    if (tk == TK_string) {
+      GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+      mod.PushbackFileInfo(MIRInfoPair(strIdx, fieldVal));
+    } else {
+      Error("illegal value after srcfileinfo field name at ");
+      return false;
+    }
+    tk = lexer.NextToken();
+    if (tk == TK_rbrace) {
+      lexer.NextToken();
+      return true;
+    }
+    if (tk == TK_coma) {
+      tk = lexer.NextToken();
+    } else {
+      Error("expect comma after srcfileinfo field value but get ");
+      return false;
+    }
+  }
+  Error("expect field name in srcfileinfo but get ");
+  return false;
+}
+
+bool MIRParser::ParseMIRForImport() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_string) {
+    Error("expect file name string after import but get ");
+    return false;
+  }
+  std::string importFileName = lexer.GetName();
+  paramImportFileList.push_back(importFileName);
+  // check illegal file name for the .mplt file
+  std::string::size_type lastDot = importFileName.find_last_of(".");
+  if (lastDot == std::string::npos || lastDot != importFileName.length() - strlen(".mplt")) {
+    FATAL(kLncFatal, "MPLT file has no or wrong suffix: %s\n", importFileName.c_str());
+  }
+  if (importFileName.compare(lastDot, strlen(".mplt"), ".mplt") != 0) {
+    FATAL(kLncFatal, "MPLT file has wrong suffix: %s\n", importFileName.c_str());
+  }
+  if (paramIsIPA && firstImport) {
+    BinaryMplt *binMplt = new BinaryMplt(mod);
+    mod.SetBinMplt(binMplt);
+    if (!(*binMplt).Import(importFileName, paramIsIPA && !firstImport, paramIsComb)) {  // not a binary mplt
+      std::ifstream mpltFile(importFileName);
+      if (!mpltFile.is_open()) {
+        FATAL(kLncFatal, "cannot open MPLT file: %s\n", importFileName.c_str());
+      }
+      bool failedParse = !ParseMPLT(mpltFile, importFileName);
+      mpltFile.close();
+      if (failedParse) {  // parse the mplt file
+        return false;
+      }
+    }
+    firstImport = false;
+  } else {
+    BinaryMplt binMplt(mod);
+    if (!binMplt.Import(importFileName, paramIsIPA, false)) {  // not a binary mplt
+      std::ifstream mpltFile(importFileName);
+      if (!mpltFile.is_open()) {
+        FATAL(kLncFatal, "cannot open MPLT file: %s\n", importFileName.c_str());
+      }
+      bool failedParse = !ParseMPLT(mpltFile, importFileName);
+      mpltFile.close();
+      if (failedParse) {  // parse the mplt file
+        return false;
+      }
+    }
+  }
+  if (GlobalTables::GetStrTable().GetStrIdxFromName("__class_meta__") == 0u) {
+    GenJStringType(mod);
+  }
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(importFileName);
+  auto it = mod.GetImportFiles().begin();
+  (void)mod.GetImportFiles().insert(it, strIdx);
+  // record the imported file for later reading summary info, if exists
+  mod.PushbackImportedMplt(importFileName);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseMIRForImportPath() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_string) {
+    Error("expect path string after importpath but get ");
+    return false;
+  }
+  GStrIdx litStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  mod.PushbackImportPath(litStrIdx);
+  lexer.NextToken();
+  return true;
+}
+
+bool MIRParser::ParseMIRForAsmdecl() {
+  lexer.NextToken();
+  if (lexer.GetTokenKind() != TK_string) {
+    Error("expect asm string after iasm but get ");
+    return false;
+  }
+  mod.GetAsmDecls().emplace_back(MapleString(lexer.GetName(), mod.GetMemPool()));
+  lexer.NextToken();
+  return true;
+}
+
+void MIRParser::PrepareParsingMIR() {
+  dummyFunction = CreateDummyFunction();
+  mod.SetCurFunction(dummyFunction);
+  lexer.PrepareForFile(mod.GetFileName());
+}
+
+void MIRParser::PrepareParsingMplt() {
+  lexer.PrepareForFile(mod.GetFileName());
+}
+
+bool MIRParser::ParseTypeFromString(const std::string &src, TyIdx &tyIdx) {
+  lexer.PrepareForString(src);
+  return ParseType(tyIdx);
+}
+
+bool MIRParser::ParseMPLT(std::ifstream &mpltFile, const std::string &importFileName) {
+  // save relevant values for the main input file
+  std::ifstream *airFileSave = lexer.GetFile();
+  int lineNumSave = lexer.lineNum;
+  std::string modFileNameSave = mod.GetFileName();
+  // set up to read next line from the import file
+  lexer.curIdx = 0;
+  lexer.currentLineSize = 0;
+  lexer.SetFile(mpltFile);
+  lexer.lineNum = 0;
+  mod.SetFileName(importFileName);
+  bool atEof = false;
+  lexer.NextToken();
+  while (!atEof) {
+    TokenKind tokenKind = lexer.GetTokenKind();
+    switch (tokenKind) {
+      default: {
+        Error("expect func or var but get ");
+        return false;
+      }
+      case TK_eof:
+        atEof = true;
+        break;
+      case TK_type:
+        paramParseLocalType = false;
+        if (!ParseTypeDefine()) {
+          return false;
+        }
+        break;
+      case TK_var: {
+        tokenKind = lexer.NextToken();
+        if (tokenKind == TK_gname) {
+          std::string literalName = lexer.GetName();
+          GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(literalName);
+          GlobalTables::GetConstPool().PutLiteralNameAsImported(strIdx);
+          lexer.NextToken();
+        } else {
+          return false;
+        }
+        break;
+      }
+    }
+  }
+  // restore old values to continue reading from the main input file
+  lexer.curIdx = 0;  // to force reading new line
+  lexer.currentLineSize = 0;
+  lexer.lineNum = lineNumSave;
+  lexer.SetFile(*airFileSave);
+  mod.SetFileName(modFileNameSave);
+  return true;
+}
+
+bool MIRParser::ParseMPLTStandalone(std::ifstream &mpltFile, const std::string &importFileName) {
+  PrepareParsingMIR();
+  if (!ParseMPLT(mpltFile, importFileName)) {
+    return false;
+  }
+  lexer.lineNum = 0;
+  // fix the typedef type
+  FixupForwardReferencedTypeByMap();
+  return true;
+}
+
+bool MIRParser::ParsePrototypeRemaining(MIRFunction &func, std::vector<TyIdx> &vecTyIdx,
+                                        std::vector<TypeAttrs> &vecAttrs, bool &varArgs) {
+  TokenKind pmTk = lexer.GetTokenKind();
+  while (pmTk != TK_rparen) {
+    // parse ","
+    if (pmTk != TK_coma) {
+      Error("expect , after a declare var/preg but get");
+      return false;
+    }
+    pmTk = lexer.NextToken();
+    if (pmTk == TK_dotdotdot) {
+      varArgs = true;
+      func.SetVarArgs();
+      pmTk = lexer.NextToken();
+      if (pmTk != TK_rparen) {
+        Error("expect ) after ... but get");
+        return false;
+      }
+      break;
+    }
+    MIRSymbol *symbol = func.GetSymTab()->CreateSymbol(kScopeLocal);
+    ASSERT(symbol != nullptr, "symbol nullptr check");
+    symbol->SetStorageClass(kScFormal);
+    TokenKind loopStTK = lexer.GetTokenKind();
+    if (loopStTK == TK_reg) {
+      symbol->SetSKind(kStPreg);
+      if (!ParseDeclareReg(*symbol, func)) {
+        Error("ParseFunction expect scalar value");
+        return false;
+      }
+    } else {
+      symbol->SetSKind(kStVar);
+      if (!ParseDeclareVar(*symbol)) {
+        Error("ParseFunction expect scalar value");
+        return false;
+      }
+      (void)func.GetSymTab()->AddToStringSymbolMap(*symbol);
+      if (!ParseDeclareVarInitValue(*symbol)) {
+        return false;
+      }
+    }
+    func.AddArgument(symbol);
+    vecTyIdx.push_back(symbol->GetTyIdx());
+    vecAttrs.push_back(symbol->GetAttrs());
+    pmTk = lexer.GetTokenKind();
+  }
+  return true;
+}
+
+void MIRParser::EmitError(const std::string &fileName) {
+  if (!strlen(GetError().c_str())) {
+    return;
+  }
+  mod.GetDbgInfo()->EmitMsg();
+  ERR(kLncErr, "%s \n%s", fileName.c_str(), GetError().c_str());
+}
+
+void MIRParser::EmitWarning(const std::string &fileName) const {
+  if (!strlen(GetWarning().c_str())) {
+    return;
+  }
+  WARN(kLncWarn, "%s \n%s\n", fileName.c_str(), GetWarning().c_str());
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/printing.cpp b/src/mapleall/maple_ir/src/printing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c6d33aa4c45b86d605429324684f4bde40678b65
--- /dev/null
+++ b/src/mapleall/maple_ir/src/printing.cpp
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "printing.h"
+#include "mir_module.h"
+#include "types_def.h"
+
+namespace maple {
+const std::string kBlankString = "                                                                                ";
+constexpr int kIndentunit = 2;  // number of blank chars of each indentation
+
+void PrintIndentation(int32 indent) {
+  int64 indentAmount = static_cast<int64>(indent) * kIndentunit;
+  do {
+    LogInfo::MapleLogger() << kBlankString.substr(0, indentAmount);
+    indentAmount -= kBlankString.length();
+  } while (indentAmount > 0);
+}
+
+void PrintString(const std::string &str) {
+  size_t i = 0;
+  LogInfo::MapleLogger() << " \"";
+  while (i < str.length()) {
+    unsigned char c = str[i++];
+    // differentiate printable and non-printable charactors
+    if (c >= 0x20 && c <= 0x7e) {
+      // escape "
+      switch (c) {
+        case '"':
+          LogInfo::MapleLogger() << "\\\"";
+          break;
+        case '\\':
+          LogInfo::MapleLogger() << "\\\\";
+          break;
+        default:
+          LogInfo::MapleLogger() << c;
+          break;
+      }
+    } else {
+      constexpr int kFieldWidth = 2;
+      LogInfo::MapleLogger() << "\\x" << std::hex << std::setfill('0') << std::setw(kFieldWidth)
+                             << static_cast<unsigned int>(c) << std::dec;
+    }
+  }
+  LogInfo::MapleLogger() << "\"";
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_ir/src/verification.cpp b/src/mapleall/maple_ir/src/verification.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..abf090b522befb9be75d140cd4987d04e297e8b1
--- /dev/null
+++ b/src/mapleall/maple_ir/src/verification.cpp
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "verification.h"
+#include "mir_nodes.h"
+#include "class_hierarchy.h"
+#include "utils.h"
+
+namespace maple {
+#ifdef NOT_USED
+AnalysisResult *DoVerification::Run(MIRModule *module, ModuleResultMgr *mgr) {
+  LogInfo::MapleLogger() << "========== Starting Verify Module =====================" << '\n';
+  CHECK_FATAL(module != nullptr, "Module should be not null");
+  LogInfo::MapleLogger() << "Current module = " << module->GetFileName() << std::endl;
+
+  auto chaAnalysis = mgr->GetAnalysisResult(MoPhase_CHA, module);
+  if (chaAnalysis == nullptr) {
+    LogInfo::MapleLogger() << "Can't find class hierarchy result" << '\n';
+    return nullptr;
+  }
+  KlassHierarchy *klassHierarchy = static_cast<KlassHierarchy*>(chaAnalysis);
+
+  MemPool *memPool = NewMemPool();
+  auto *verifyResult = memPool->New<VerifyResult>(*module, *klassHierarchy, *memPool);
+  VerifyModule(*module, *verifyResult);
+  if (verifyResult->HasErrorNotDeferred()) {
+    LogInfo::MapleLogger() << "Warning: Verify MIR failed!  " << '\n';
+  }
+
+  CheckExtendFinalClass(*verifyResult);
+  if (IsLazyBindingOrDecouple(*klassHierarchy)) {
+    DeferredCheckFinalClassAndMethod(*verifyResult);
+  }
+
+  auto *result = memPool->New<VerificationPhaseResult>(*memPool, *verifyResult);
+  mgr->AddResult(GetPhaseID(), *module, *result);
+  LogInfo::MapleLogger() << "========== Finished Verify Module =====================" << '\n';
+  return result;
+}
+
+void DoVerification::CheckExtendFinalClass(VerifyResult &result) const {
+  const KlassHierarchy &klassHierarchy = result.GetKlassHierarchy();
+  std::stack<const Klass*> classesToMark;
+  for (auto klass : klassHierarchy.GetTopoSortedKlasses()) {
+    if (klass == nullptr || !klass->HasSubKlass()) {
+      continue;
+    }
+    const MIRStructType *mirStructType = klass->GetMIRStructType();
+    if ((mirStructType == nullptr) || (!mirStructType->IsMIRClassType()) ||
+        (!static_cast<const MIRClassType*>(mirStructType)->IsFinal())) {
+      continue;
+    }
+    classesToMark.push(klass);
+    while (!classesToMark.empty()) {
+      const auto &subKlasses = classesToMark.top()->GetSubKlasses();
+      classesToMark.pop();
+      for (auto subKlass : subKlasses) {
+        if (subKlass == nullptr) {
+          continue;
+        }
+        std::string errMsg = "Class " + subKlass->GetKlassName() +
+                             " cannot inherit from final class " + klass->GetKlassName();
+        result.AddPragmaVerifyError(subKlass->GetKlassName(), std::move(errMsg));
+        if (subKlass->HasSubKlass()) {
+          classesToMark.push(subKlass);
+        }
+      }
+    }
+  }
+}
+
+bool DoVerification::IsLazyBindingOrDecouple(const KlassHierarchy &klassHierarchy) const {
+  if (Options::buildApp != 0) {
+    return true;
+  }
+  const Klass *objectKlass = klassHierarchy.GetKlassFromLiteral(namemangler::kJavaLangObjectStr);
+  bool isLibCore = ((objectKlass != nullptr) && (objectKlass->GetMIRStructType()->IsLocal()));
+  return !isLibCore;
+}
+
+bool DoVerification::NeedRuntimeFinalCheck(const KlassHierarchy &klassHierarchy, const std::string &className) const {
+  const Klass *klass = klassHierarchy.GetKlassFromName(className);
+  if (klass == nullptr || klass->GetMIRStructType() == nullptr || !klass->HasSuperKlass()) {
+    return false;
+  }
+  return klass->GetMIRStructType()->IsLocal();
+}
+
+void DoVerification::DeferredCheckFinalClassAndMethod(VerifyResult &result) const {
+  const auto &functionList = result.GetMIRModule().GetFunctionList();
+  std::set<std::string> classesAdded;
+  for (size_t index = 0; index < functionList.size(); ++index) {
+    result.SetCurrentFunction(index);
+    const auto &className = result.GetCurrentClassName();
+    if (classesAdded.find(className) != classesAdded.end()) {
+      continue;
+    }
+
+    if (!NeedRuntimeFinalCheck(result.GetKlassHierarchy(), className)) {
+      continue;
+    }
+    // do not extend final parent class
+    result.AddPragmaExtendFinalCheck(className);
+    // do not override final method
+    result.AddPragmaOverrideFinalCheck(className);
+    LogInfo::MapleLogger() << "Check Final class and method for class " << className << '\n';
+    (void)classesAdded.insert(className);
+  }
+}
+
+void DoVerification::VerifyModule(MIRModule &module, VerifyResult &result) const {
+  const auto &resultMap = result.GetResultMap();
+
+  // theModule is needed by verify() functions in mir_nodes.cpp
+  theMIRModule = &module;
+  const auto &functionList = result.GetMIRModule().GetFunctionList();
+  for (size_t index = 0; index < functionList.size(); ++index) {
+    result.SetCurrentFunction(index);
+    MIRFunction *currentFunction = functionList[index];
+    const BlockNode *block = currentFunction->GetBody();
+
+    // For verify() functions compatibility
+    theMIRModule->SetCurFunction(currentFunction);
+
+    if (block == nullptr) {
+      continue;
+    }
+    bool blockResult = block->Verify(result);
+
+    const auto &className = result.GetCurrentClassName();
+    auto iter = resultMap.find(className);
+    if (iter == resultMap.end()) {
+      result.SetClassCorrectness(className, blockResult);
+    } else {
+      result.SetClassCorrectness(className, iter->second && blockResult);
+    }
+  }
+}
+#endif
+
+bool VerifyResult::HasVerifyError(const std::vector<const VerifyPragmaInfo*> &pragmaInfoPtrVec) const {
+  if (pragmaInfoPtrVec.empty()) {
+    return false;
+  }
+  return (utils::ToRef(pragmaInfoPtrVec.front()).IsVerifyError());
+}
+
+bool VerifyResult::HasSamePragmaInfo(const std::vector<const VerifyPragmaInfo*> &pragmaInfoPtrVec,
+                                     const VerifyPragmaInfo &verifyPragmaInfo) const {
+  for (auto &pragmaInfoPtr : pragmaInfoPtrVec) {
+    const VerifyPragmaInfo &pragmaInfoRef = utils::ToRef(pragmaInfoPtr);
+    if (!verifyPragmaInfo.IsEqualTo(pragmaInfoRef)) {
+      continue;
+    }
+    if (!verifyPragmaInfo.IsAssignableCheck()) {
+      return true;
+    }
+    if (static_cast<const AssignableCheckPragma&>(verifyPragmaInfo).IsEqualTo(
+        static_cast<const AssignableCheckPragma&>(pragmaInfoRef))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void VerifyResult::AddPragmaVerifyError(const std::string &className, std::string errMsg) {
+  classesCorrectness[className] = false;
+  auto classIter = classesPragma.find(className);
+  if (classIter != classesPragma.end() && HasVerifyError(classIter->second)) {
+    return;
+  }
+  const VerifyPragmaInfo *verifyError = allocator.GetMemPool()->New<ThrowVerifyErrorPragma>(std::move(errMsg));
+  if (classIter == classesPragma.end()) {
+    classesPragma[className].push_back(verifyError);
+    return;
+  }
+  std::vector<const VerifyPragmaInfo*> &pragmaInfoPtrVec = classIter->second;
+  pragmaInfoPtrVec.clear();
+  pragmaInfoPtrVec.push_back(verifyError);
+}
+
+void VerifyResult::AddPragmaAssignableCheck(const std::string &className, std::string fromType, std::string toType) {
+  classesCorrectness[className] = false;
+  auto classIter = classesPragma.find(className);
+  if (classIter != classesPragma.end() && HasVerifyError(classIter->second)) {
+    return;
+  }
+  const VerifyPragmaInfo *assignableCheck = allocator.GetMemPool()->New<AssignableCheckPragma>(std::move(fromType),
+                                                                                               std::move(toType));
+  if (classIter == classesPragma.end()) {
+    classesPragma[className].push_back(assignableCheck);
+    return;
+  }
+  std::vector<const VerifyPragmaInfo*> &pragmaInfoPtrVec = classIter->second;
+  if (HasSamePragmaInfo(pragmaInfoPtrVec, *assignableCheck)) {
+    return;
+  }
+  pragmaInfoPtrVec.push_back(assignableCheck);
+}
+
+void VerifyResult::AddPragmaExtendFinalCheck(const std::string &className) {
+  classesCorrectness[className] = false;
+  auto classIter = classesPragma.find(className);
+  if (classIter != classesPragma.end() && HasVerifyError(classIter->second)) {
+    return;
+  }
+
+  const VerifyPragmaInfo *extendFinalCheck = allocator.GetMemPool()->New<ExtendFinalCheckPragma>();
+  if (classIter == classesPragma.end()) {
+    classesPragma[className].push_back(extendFinalCheck);
+    return;
+  }
+  std::vector<const VerifyPragmaInfo*> &pragmaInfoPtrVec = classIter->second;
+  if (HasSamePragmaInfo(pragmaInfoPtrVec, *extendFinalCheck)) {
+    return;
+  }
+  pragmaInfoPtrVec.push_back(extendFinalCheck);
+}
+
+void VerifyResult::AddPragmaOverrideFinalCheck(const std::string &className) {
+  classesCorrectness[className] = false;
+  auto classIter = classesPragma.find(className);
+  if (classIter != classesPragma.end() && HasVerifyError(classIter->second)) {
+    return;
+  }
+
+  const VerifyPragmaInfo *overrideFinalCheck = allocator.GetMemPool()->New<OverrideFinalCheckPragma>();
+  if (classIter == classesPragma.end()) {
+    classesPragma[className].push_back(overrideFinalCheck);
+    return;
+  }
+  std::vector<const VerifyPragmaInfo*> &pragmaInfoPtrVec = classIter->second;
+  if (HasSamePragmaInfo(pragmaInfoPtrVec, *overrideFinalCheck)) {
+    return;
+  }
+  pragmaInfoPtrVec.push_back(overrideFinalCheck);
+}
+} // namespace maple
diff --git a/src/mapleall/maple_ir/src/verify_annotation.cpp b/src/mapleall/maple_ir/src/verify_annotation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aaf7e5ab88fa1db1771d4414775107d9bbe1fafa
--- /dev/null
+++ b/src/mapleall/maple_ir/src/verify_annotation.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights isCorrecterved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPisCorrectS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "verify_annotation.h"
+#include "global_tables.h"
+#include "reflection_analysis.h"
+
+namespace maple {
+namespace verifyanno {
+constexpr char kDeferredThrowVerifyError[] =
+    "Lcom_2Fhuawei_2Fark_2Fannotation_2Fverify_2FVerfAnnoThrowVerifyError_3B";
+constexpr char kDeferredExtendFinalCheck[] =
+    "Lcom_2Fhuawei_2Fark_2Fannotation_2Fverify_2FVerfAnnoDeferredExtendFinalCheck_3B";
+constexpr char kDeferredOverrideFinalCheck[] =
+    "Lcom_2Fhuawei_2Fark_2Fannotation_2Fverify_2FVerfAnnoDeferredOverrideFinalCheck_3B";
+constexpr char kDeferredAssignableCheck[] =
+    "Lcom_2Fhuawei_2Fark_2Fannotation_2Fverify_2FVerfAnnoDeferredAssignableCheck_3B";
+constexpr char kAssignableChecksContainer[] =
+    "Lcom_2Fhuawei_2Fark_2Fannotation_2Fverify_2FVerfAnnoDeferredAssignableChecks_3B";
+}
+
+// Convert from Ljava_2Flang_2FStringBuilder_3B to Ljava_2Flang_2FStringBuilder;
+inline std::string SimplifyClassName(const std::string &name) {
+  const std::string postFix = "_3B";
+  if (name.rfind(postFix) == (name.size() - postFix.size())) {
+    std::string shortName = name.substr(0, name.size() - postFix.size());
+    return shortName.append(";");
+  }
+  return name;
+}
+
+inline MIRStructType *GetOrCreateStructType(const std::string &name, MIRModule &md) {
+  return static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetOrCreateClassType(name, md));
+}
+
+MIRPragmaElement *NewAnnotationElement(MIRModule &md, const GStrIdx &nameIdx, PragmaValueType type) {
+  auto *elem = md.GetMemPool()->New<MIRPragmaElement>(md.GetMPAllocator());
+  elem->SetType(type);
+  elem->SetNameStrIdx(nameIdx);
+  return elem;
+}
+
+MIRPragmaElement *NewAnnotationElement(MIRModule &md, const std::string &name, PragmaValueType type) {
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  return NewAnnotationElement(md, nameIdx, type);
+}
+
+MIRPragmaElement *NewAnnotationStringElement(MIRModule &md, const std::string &name, const std::string &value) {
+  MIRPragmaElement *elem = NewAnnotationElement(md, name, kValueString);
+  if (!value.empty()) {
+    elem->SetU64Val(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(value).GetIdx());
+  }
+  return elem;
+}
+
+MIRPragma *NewPragmaRTAnnotation(MIRModule &md, const MIRStructType &clsType,
+                                 const MIRStructType &aType, PragmaKind kind) {
+  auto *pragma = md.GetMemPool()->New<MIRPragma>(md, md.GetMPAllocator());
+  pragma->SetStrIdx(clsType.GetNameStrIdx());
+  pragma->SetTyIdx(aType.GetTypeIndex());
+  pragma->SetKind(kind);
+  pragma->SetVisibility(kVisRuntime);
+  return pragma;
+}
+
+MIRPragma *NewPragmaRTClassAnnotation(MIRModule &md, const MIRStructType &clsType, const std::string &aTypeName) {
+  MIRStructType *aType = GetOrCreateStructType(aTypeName, md);
+  if (aType->GetPragmaVec().empty()) {
+    // not enough to set kVisRuntime,
+    // do annotate with Retention(RUNTIME) (see ReflectionAnalysis::RtRetentionPolicyCheck)
+    // kJavaLangAnnotationRetentionStr is the same to the one in RtRetentionPolicyCheck in reflection_analysis.cpp
+    const std::string kJavaLangAnnotationRetentionStr = "Ljava_2Flang_2Fannotation_2FRetention_3B";
+    MIRStructType *retentionType = GetOrCreateStructType(kJavaLangAnnotationRetentionStr, md);
+    MIRPragma *pragmaRetention = NewPragmaRTAnnotation(md, *aType, *retentionType, kPragmaClass);
+    pragmaRetention->PushElementVector(NewAnnotationStringElement(md, "value", "RUNTIME"));
+    aType->PushbackPragma(pragmaRetention);
+  }
+  return NewPragmaRTAnnotation(md, clsType, *aType, kPragmaClass);
+}
+
+// creates pragma not inserted into clsType pragmaVec
+MIRPragma *NewAssignableCheckAnno(MIRModule &md, const MIRStructType &clsType, const AssignableCheckPragma &info) {
+  MIRPragma *pr = NewPragmaRTClassAnnotation(md, clsType, verifyanno::kDeferredAssignableCheck);
+  pr->PushElementVector(NewAnnotationStringElement(md, "dst", SimplifyClassName(info.GetToType())));
+  pr->PushElementVector(NewAnnotationStringElement(md, "src", SimplifyClassName(info.GetFromType())));
+  return pr;
+}
+
+void AddVerfAnnoThrowVerifyError(MIRModule &md, const ThrowVerifyErrorPragma &info, MIRStructType &clsType) {
+  const auto &pragmaVec = clsType.GetPragmaVec();
+  for (auto pragmaPtr : pragmaVec) {
+    if (pragmaPtr == nullptr) {
+      continue;
+    }
+    MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pragmaPtr->GetTyIdx());
+    if (mirType != nullptr && mirType->GetName().compare(verifyanno::kDeferredThrowVerifyError) == 0) {
+      return;
+    }
+  }
+  MIRPragma *pr = NewPragmaRTClassAnnotation(md, clsType, verifyanno::kDeferredThrowVerifyError);
+  pr->PushElementVector(NewAnnotationStringElement(md, "msg", info.GetMessage()));
+  clsType.PushbackPragma(pr);
+}
+
+void AddVerfAnnoAssignableCheck(MIRModule &md, std::vector<const AssignableCheckPragma*> &info,
+                                MIRStructType &clsType) {
+  if (info.empty()) {
+    return;
+  }
+
+  if (info.size() == 1) {
+    MIRPragma *pr = NewAssignableCheckAnno(md, clsType, *info.front());
+    clsType.PushbackPragma(pr);
+    return;
+  }
+
+  // container pragma
+  MIRPragma *prContainer = NewPragmaRTClassAnnotation(md, clsType, verifyanno::kAssignableChecksContainer);
+  MIRPragmaElement *elemContainer = NewAnnotationElement(md, "value", kValueArray);
+
+  GStrIdx singleAnnoTypeName = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+      verifyanno::kDeferredAssignableCheck);
+  for (auto *singleInfo : info) {
+    MIRPragmaElement *elem = NewAnnotationElement(md, singleAnnoTypeName, kValueAnnotation);
+    elem->SetTypeStrIdx(singleAnnoTypeName);
+    elem->SubElemVecPushBack(NewAnnotationStringElement(md, "dst", SimplifyClassName(singleInfo->GetToType())));
+    elem->SubElemVecPushBack(NewAnnotationStringElement(md, "src", SimplifyClassName(singleInfo->GetFromType())));
+    elemContainer->SubElemVecPushBack(elem);
+  }
+
+  prContainer->PushElementVector(elemContainer);
+  clsType.PushbackPragma(prContainer);
+}
+
+void AddVerfAnnoExtendFinalCheck(MIRModule &md, MIRStructType &clsType) {
+  MIRPragma *pr = NewPragmaRTClassAnnotation(md, clsType, verifyanno::kDeferredExtendFinalCheck);
+  clsType.PushbackPragma(pr);
+}
+
+void AddVerfAnnoOverrideFinalCheck(MIRModule &md, MIRStructType &clsType) {
+  MIRPragma *pr = NewPragmaRTClassAnnotation(md, clsType, verifyanno::kDeferredOverrideFinalCheck);
+  clsType.PushbackPragma(pr);
+}
+} // namespace maple
diff --git a/src/mapleall/maple_ir/src/verify_mark.cpp b/src/mapleall/maple_ir/src/verify_mark.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fa7898615351c7eea2d5cba57d219eb6bbb4bd78
--- /dev/null
+++ b/src/mapleall/maple_ir/src/verify_mark.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "verify_mark.h"
+#include "verification.h"
+#include "verify_annotation.h"
+#include "class_hierarchy.h"
+#include "utils.h"
+
+namespace maple {
+#ifdef NOT_USED
+AnalysisResult *DoVerifyMark::Run(MIRModule *module, ModuleResultMgr *mgr) {
+  LogInfo::MapleLogger() << "Start marking verification result" << '\n';
+
+  CHECK_FATAL(module != nullptr, "Module should not be null");
+
+  auto chaAnalysis = mgr->GetAnalysisResult(MoPhase_CHA, module);
+  if (chaAnalysis == nullptr) {
+    LogInfo::MapleLogger() << "Can't find class hierarchy result" << '\n';
+    return nullptr;
+  }
+  auto verifyAnalysis = mgr->GetAnalysisResult(MoPhase_VERIFICATION, module);
+  if (verifyAnalysis == nullptr) {
+    LogInfo::MapleLogger() << "Can't find verification result" << '\n';
+    return nullptr;
+  }
+
+  auto klassHierarchy = static_cast<KlassHierarchy*>(chaAnalysis);
+  const auto *verifyResult = static_cast<VerificationPhaseResult*>(verifyAnalysis);
+  const auto &verifyResultMap = verifyResult->GetDeferredClassesPragma();
+  for (auto &classResult : verifyResultMap) {
+    if (IsSystemPreloadedClass(classResult.first)) {
+      continue;
+    }
+    Klass &klass = utils::ToRef(klassHierarchy->GetKlassFromName(classResult.first));
+    klass.SetFlag(kClassRuntimeVerify);
+    LogInfo::MapleLogger() << "class " << klass.GetKlassName() << " is Set as NOT VERIFIED\n";
+    AddAnnotations(*module, klass, classResult.second);
+  }
+
+  LogInfo::MapleLogger() << "Finished marking verification result" << '\n';
+  return nullptr;
+}
+
+void DoVerifyMark::AddAnnotations(MIRModule &module, const Klass &klass,
+                                  const std::vector<const VerifyPragmaInfo*> &pragmaInfoVec) {
+  MIRStructType *mirStructType = klass.GetMIRStructType();
+  if (mirStructType == nullptr || pragmaInfoVec.empty()) {
+    return;
+  }
+  const auto &className = klass.GetKlassName();
+  std::vector<const AssignableCheckPragma*> assignableCheckPragmaVec;
+  for (auto *pragmaItem : pragmaInfoVec) {
+    switch (pragmaItem->GetPragmaType()) {
+      case kThrowVerifyError: {
+        auto *pragma = static_cast<const ThrowVerifyErrorPragma*>(pragmaItem);
+        AddVerfAnnoThrowVerifyError(module, *pragma, *mirStructType);
+        LogInfo::MapleLogger() << "\tInserted throw verify error annotation for class " << className << std::endl;
+        LogInfo::MapleLogger() << "\tError: " << pragma->GetMessage() << std::endl;
+        break;
+      }
+      case kAssignableCheck: {
+        auto *pragma = static_cast<const AssignableCheckPragma*>(pragmaItem);
+        assignableCheckPragmaVec.push_back(pragma);
+        LogInfo::MapleLogger() << "\tInserted deferred assignable check from " << pragma->GetFromType() <<
+            " to " << pragma->GetToType() << " in class " << className << '\n';
+        break;
+      }
+      case kExtendFinalCheck: {
+        AddVerfAnnoExtendFinalCheck(module, *mirStructType);
+        break;
+      }
+      case kOverrideFinalCheck: {
+        AddVerfAnnoOverrideFinalCheck(module, *mirStructType);
+        break;
+      }
+      default:
+        CHECK_FATAL(false, "\nError: Unknown Verify PragmaInfoType");
+    }
+  }
+  AddVerfAnnoAssignableCheck(module, assignableCheckPragmaVec, *mirStructType);
+}
+#endif
+} // namespace maple
diff --git a/src/mapleall/maple_me/BUILD.gn b/src/mapleall/maple_me/BUILD.gn
new file mode 100755
index 0000000000000000000000000000000000000000..f8bd053ab50292e8e7becac2d31bdfbb598aced0
--- /dev/null
+++ b/src/mapleall/maple_me/BUILD.gn
@@ -0,0 +1,164 @@
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+include_directories = [
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+  "${MAPLEALL_ROOT}/maple_me/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include/old",
+  "${MAPLEALL_ROOT}/mpl2mpl/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/maple_phase/include",
+  "${MAPLEALL_ROOT}/maple_be/include/be",
+  "${MAPLEALL_ROOT}/maple_be/include/cg",
+  "${MAPLEALL_ROOT}/maple_be/include/ad",
+  "${MAPLEALL_ROOT}/maple_be/include/ad/target",
+  "${MAPLE_BUILD_OUTPUT}/common/target",
+  "${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat",
+]
+
+src_libmplme = [
+  "src/dse.cpp",
+  "src/hdse.cpp",
+  "src/meexpr_use_info.cpp",
+  "src/vst_use_info.cpp",
+  "src/me_sink.cpp",
+  "src/prop.cpp",
+  "src/me_alias_class.cpp",
+  "src/me_critical_edge.cpp",
+  "src/me_bb_layout.cpp",
+  "src/me_bypath_eh.cpp",
+  "src/me_profile_gen.cpp",
+  "src/me_profile_use.cpp",
+  "src/me_cfg.cpp",
+  "src/me_dse.cpp",
+  "src/me_hdse.cpp",
+  "src/me_dominance.cpp",
+  "src/me_emit.cpp",
+  "src/me_ssa_devirtual.cpp",
+  "src/ssa_devirtual.cpp",
+  "src/me_function.cpp",
+  "src/me_loop_analysis.cpp",
+  "src/me_irmap.cpp",
+  "src/me_irmap_build.cpp",
+  "src/me_analyzector.cpp",
+  "src/me_loop_canon.cpp",
+  "src/me_loop_inversion.cpp",
+  "src/me_scalar_analysis.cpp",
+  "src/me_loop_unrolling.cpp",
+  "src/me_option.cpp",
+  "src/me_options.cpp",
+  "src/me_phase_manager.cpp",
+  "src/me_prop.cpp",
+  "src/copy_prop.cpp",
+  "src/me_ssa_prop.cpp",
+  "src/me_placement_rc.cpp",
+  "src/me_analyze_rc.cpp",
+  "src/me_delegate_rc.cpp",
+  "src/me_cond_based_opt.cpp",
+  "src/me_rc_lowering.cpp",
+  "src/me_lower_globals.cpp",
+  "src/me_may2dassign.cpp",
+  "src/preg_renamer.cpp",
+  "src/me_rename2preg.cpp",
+  "src/me_ssa.cpp",
+  "src/me_toplevel_ssa.cpp",
+  "src/me_ssa_tab.cpp",
+  "src/me_ssa_update.cpp",
+  "src/me_stmt_fre.cpp",
+  "src/me_stmt_pre.cpp",
+  "src/me_store_pre.cpp",
+  "src/me_stack_protect.cpp",
+  "src/me_ssa_epre.cpp",
+  "src/me_ssa_lpre.cpp",
+  "src/me_ssu_pre.cpp",
+  "src/ssa_epre.cpp",
+  "src/ssa_pre.cpp",
+  "src/ssa_epre_for_sr.cpp",
+  "src/ssa_epre_for_lftr.cpp",
+  "src/ssa_pre_for_hoist.cpp",
+  "src/occur.cpp",
+  "src/me_inequality_graph.cpp",
+  "src/me_abco.cpp",
+  "src/me_ssi.cpp",
+  "src/me_cfg_opt.cpp",
+  "src/me_predict.cpp",
+  "src/me_check_cast.cpp",
+  "src/me_side_effect.cpp",
+  "src/me_bb_analyze.cpp",
+  "src/meconstprop.cpp",
+  "src/sync_select.cpp",
+  "src/me_gc_lowering.cpp",
+  "src/me_gc_write_barrier_opt.cpp",
+  "src/me_subsum_rc.cpp",
+  "src/me_func_opt.cpp",
+  "src/me_verify.cpp",
+  "src/cast_opt.cpp",
+  "src/me_merge_stmts.cpp",
+  "src/me_fsaa.cpp",
+  "src/pme_mir_lower.cpp",
+  "src/lfo_inject_iv.cpp",
+  "src/pme_emit.cpp",
+  "src/lfo_iv_canon.cpp",
+  "src/lfo_dep_test.cpp",
+  "src/lfo_loop_vec.cpp",
+  "src/me_value_range_prop.cpp",
+  "src/me_jump_threading.cpp",
+  "src/me_obj_size.cpp",
+  "src/cfg_opt.cpp",
+  "src/optimizeCFG.cpp",
+  "src/me_ivopts.cpp",
+  "src/seqvec.cpp",
+  "src/me_autovec.cpp",
+  "src/me_safety_warning.cpp",
+  "src/lfo_unroll.cpp",
+  "src/code_factoring.cpp",
+  "src/me_slp.cpp",
+  "src/lmbc_memlayout.cpp",
+  "src/lmbc_lower.cpp",
+]
+
+src_libmplmewpo = [
+  "src/alias_class.cpp",
+  "src/demand_driven_alias_analysis.cpp",
+  "src/type_based_alias_analysis.cpp",
+  "src/bb.cpp",
+  "src/func_emit.cpp",
+  "src/irmap.cpp",
+  "src/irmap_build.cpp",
+  "src/irmap_emit.cpp",
+  "src/me_ir.cpp",
+  "src/orig_symbol.cpp",
+  "src/ssa.cpp",
+  "src/ssa_mir_nodes.cpp",
+  "src/ssa_tab.cpp",
+  "src/ver_symbol.cpp",
+]
+
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+
+static_library("libmplme") {
+  sources = src_libmplme
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
+
+static_library("libmplmewpo") {
+  sources = src_libmplmewpo
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
diff --git a/src/mapleall/maple_me/CMakeLists.txt b/src/mapleall/maple_me/CMakeLists.txt
new file mode 100755
index 0000000000000000000000000000000000000000..1aa112d633456ad76b93e65e0699ef0cf2cbfcbe
--- /dev/null
+++ b/src/mapleall/maple_me/CMakeLists.txt
@@ -0,0 +1,169 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(inc_dir
+  ${MAPLEALL_ROOT}/maple_ir/include
+  ${MAPLEALL_ROOT}/mempool/include
+  ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+  ${MAPLEALL_ROOT}/maple_me/include
+  ${MAPLEALL_ROOT}/maple_ipa/include
+  ${MAPLEALL_ROOT}/maple_ipa/include/old
+  ${MAPLEALL_ROOT}/mpl2mpl/include
+  ${MAPLEALL_ROOT}/maple_util/include
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${MAPLEALL_ROOT}/maple_phase/include
+  ${MAPLEALL_ROOT}/maple_be/include/be
+  ${MAPLEALL_ROOT}/maple_be/include/cg
+  ${MAPLEALL_ROOT}/maple_be/include/ad
+  ${MAPLEALL_ROOT}/maple_be/include/ad/target
+  ${MAPLE_BUILD_OUTPUT}/common/target
+  ${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat
+)
+
+set(src_libmplme
+  src/dse.cpp
+  src/hdse.cpp
+  src/meexpr_use_info.cpp
+  src/vst_use_info.cpp
+  src/me_sink.cpp
+  src/prop.cpp
+  src/me_alias_class.cpp
+  src/me_critical_edge.cpp
+  src/me_bb_layout.cpp
+  src/me_bypath_eh.cpp
+  src/me_profile_gen.cpp
+  src/me_profile_use.cpp
+  src/me_cfg.cpp
+  src/me_dse.cpp
+  src/me_hdse.cpp
+  src/me_dominance.cpp
+  src/me_emit.cpp
+  src/me_ssa_devirtual.cpp
+  src/ssa_devirtual.cpp
+  src/me_function.cpp
+  src/me_loop_analysis.cpp
+  src/me_irmap.cpp
+  src/me_irmap_build.cpp
+  src/me_analyzector.cpp
+  src/me_loop_canon.cpp
+  src/me_loop_inversion.cpp
+  src/me_scalar_analysis.cpp
+  src/me_loop_unrolling.cpp
+  src/me_option.cpp
+  src/me_options.cpp
+  src/me_phase_manager.cpp
+  src/me_prop.cpp
+  src/copy_prop.cpp
+  src/me_ssa_prop.cpp
+  src/me_placement_rc.cpp
+  src/me_analyze_rc.cpp
+  src/me_delegate_rc.cpp
+  src/me_cond_based_opt.cpp
+  src/me_rc_lowering.cpp
+  src/me_lower_globals.cpp
+  src/me_may2dassign.cpp
+  src/preg_renamer.cpp
+  src/me_rename2preg.cpp
+  src/me_ssa.cpp
+  src/me_toplevel_ssa.cpp
+  src/me_ssa_tab.cpp
+  src/me_ssa_update.cpp
+  src/me_stmt_fre.cpp
+  src/me_stmt_pre.cpp
+  src/me_store_pre.cpp
+  src/me_stack_protect.cpp
+  src/me_ssa_epre.cpp
+  src/me_ssa_lpre.cpp
+  src/me_ssu_pre.cpp
+  src/ssa_epre.cpp
+  src/ssa_pre.cpp
+  src/ssa_epre_for_sr.cpp
+  src/ssa_epre_for_lftr.cpp
+  src/ssa_pre_for_hoist.cpp
+  src/occur.cpp
+  src/me_inequality_graph.cpp
+  src/me_abco.cpp
+  src/me_ssi.cpp
+  src/me_cfg_opt.cpp
+  src/me_predict.cpp
+  src/me_check_cast.cpp
+  src/me_side_effect.cpp
+  src/me_bb_analyze.cpp
+  src/meconstprop.cpp
+  src/sync_select.cpp
+  src/me_gc_lowering.cpp
+  src/me_gc_write_barrier_opt.cpp
+  src/me_subsum_rc.cpp
+  src/me_func_opt.cpp
+  src/me_verify.cpp
+  src/cast_opt.cpp
+  src/me_merge_stmts.cpp
+  src/me_fsaa.cpp
+  src/pme_mir_lower.cpp
+  src/lfo_inject_iv.cpp
+  src/pme_emit.cpp
+  src/lfo_iv_canon.cpp
+  src/lfo_dep_test.cpp
+  src/lfo_loop_vec.cpp
+  src/me_value_range_prop.cpp
+  src/me_jump_threading.cpp
+  src/me_obj_size.cpp
+  src/cfg_opt.cpp
+  src/optimizeCFG.cpp
+  src/me_ivopts.cpp
+  src/seqvec.cpp
+  src/me_autovec.cpp
+  src/me_safety_warning.cpp
+  src/lfo_unroll.cpp
+  src/code_factoring.cpp
+  src/me_slp.cpp
+  src/lmbc_memlayout.cpp
+  src/lmbc_lower.cpp
+)
+
+set(src_libmplmewpo
+  src/alias_class.cpp
+  src/demand_driven_alias_analysis.cpp
+  src/type_based_alias_analysis.cpp
+  src/bb.cpp
+  src/func_emit.cpp
+  src/irmap.cpp
+  src/irmap_build.cpp
+  src/irmap_emit.cpp
+  src/me_ir.cpp
+  src/orig_symbol.cpp
+  src/ssa.cpp
+  src/ssa_mir_nodes.cpp
+  src/ssa_tab.cpp
+  src/ver_symbol.cpp
+)
+
+#libmplme
+add_library(libmplme STATIC ${src_libmplme})
+set_target_properties(libmplme PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${inc_dir}"
+  LINK_LIBRARIES ""
+  ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
+
+#libmplmewpo
+add_library(libmplmewpo STATIC ${src_libmplmewpo})
+set_target_properties(libmplmewpo PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${inc_dir}"
+  LINK_LIBRARIES ""
+  ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
diff --git a/src/mapleall/maple_me/include/alias_class.h b/src/mapleall/maple_me/include/alias_class.h
new file mode 100644
index 0000000000000000000000000000000000000000..80e0d200e7a26a8f63c8e869c4c9b3b4b0e317b7
--- /dev/null
+++ b/src/mapleall/maple_me/include/alias_class.h
@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ALIAS_CLASS_H
+#define MAPLE_ME_INCLUDE_ALIAS_CLASS_H
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "ssa_tab.h"
+#include "union_find.h"
+
+namespace maple {
+constexpr int64 bitsPerByte = 8;
+
+inline int64 GetTypeBitSize(const MIRType *type) {
+  ASSERT(type != nullptr, "type is wrong.");
+  if (type->GetKind() == kTypeBitField) {
+    return static_cast<const MIRBitFieldType*>(type)->GetFieldSize();
+  } else {
+    return static_cast<int64>(type->GetSize()) * bitsPerByte;
+  }
+}
+
+inline bool IsMemoryOverlap(OffsetType startA, int64 sizeA, OffsetType startB, int64 sizeB) {
+  // A : |---------|
+  // B :   |----------|
+  if (startA.IsInvalid() || startB.IsInvalid()) {
+    return true; // process conservatively
+  }
+  return startA < (startB + sizeB) &&
+         startB < (startA + sizeA);
+}
+
+class AliasElem {
+  friend class AliasClass;
+ public:
+  AliasElem(uint32 i, OriginalSt &origst)
+      : id(i),
+        ost(origst) {}
+
+  ~AliasElem() = default;
+
+  void Dump() const;
+
+  uint32 GetClassID() const {
+    return id;
+  }
+
+  OriginalSt &GetOriginalSt() {
+    return ost;
+  }
+  const OriginalSt &GetOriginalSt() const {
+    return ost;
+  }
+
+  OriginalSt *GetOst() {
+    return &ost;
+  }
+
+  bool IsNotAllDefsSeen() const {
+    return notAllDefsSeen;
+  }
+  void SetNotAllDefsSeen(bool allDefsSeen) {
+    notAllDefsSeen = allDefsSeen;
+  }
+
+  bool IsNextLevNotAllDefsSeen() const {
+    return nextLevNotAllDefsSeen;
+  }
+  void SetNextLevNotAllDefsSeen(bool allDefsSeen) {
+    nextLevNotAllDefsSeen = allDefsSeen;
+  }
+
+  const MapleSet<unsigned int> *GetClassSet() const {
+    return classSet;
+  }
+
+  void AddClassToSet(unsigned int classId) {
+    (void)classSet->emplace(classId);
+  }
+
+  void SetClassSet(MapleSet<unsigned int> *newClassSet) {
+    classSet = newClassSet;
+  }
+
+  const MapleSet<unsigned int> *GetAssignSet() const {
+    return assignSet;
+  }
+
+  void AddAssignToSet(unsigned int classId) {
+    (void)assignSet->emplace(classId);
+  }
+
+ private:
+  uint32 id;  // the original alias class id, before any union; start from 0
+  OriginalSt &ost;
+  bool notAllDefsSeen = false;         // applied to current level; unused for lev -1
+  bool nextLevNotAllDefsSeen = false;  // remember that next level's elements need to be made notAllDefsSeen
+  MapleSet<unsigned int> *classSet = nullptr;    // points to the set of members of its class; nullptr for
+                                                 // single-member classes
+  MapleSet<unsigned int> *assignSet = nullptr;   // points to the set of members that have assignments among themselves
+};
+
+// this is only for use as return value of CreateAliasInfoExpr()
+class AliasInfo {
+ public:
+  VersionSt *vst;
+  FieldID fieldID; // corresponds to fieldID in OP-addrof/OP_iaddrof
+  OffsetType offset; // corresponds to offset of array-element and offset from add/sub
+
+  AliasInfo() : vst(nullptr), fieldID(0), offset(kOffsetUnknown) {}
+  AliasInfo(VersionSt *vst0, FieldID fld) : vst(vst0), fieldID(fld), offset(kOffsetUnknown) {}
+  AliasInfo(VersionSt *vst0, FieldID fld, const OffsetType &offset) : vst(vst0), fieldID(fld), offset(offset) {}
+  ~AliasInfo() {}
+};
+
+class AliasClass : public AnalysisResult {
+ public:
+  AliasClass(MemPool &memPool, MIRModule &mod, SSATab &ssaTabParam, bool lessThrowAliasParam, bool ignoreIPA,
+             bool setCalleeHasSideEffect = false, KlassHierarchy *kh = nullptr)
+      : AnalysisResult(&memPool),
+        mirModule(mod),
+        acMemPool(memPool),
+        acAlloc(&memPool),
+        ssaTab(ssaTabParam),
+        unionFind(memPool, ssaTabParam.GetVersionStTableSize()),
+        globalsAffectedByCalls(acAlloc.Adapter()),
+        globalsMayAffectedByClinitCheck(acAlloc.Adapter()),
+        aggsToUnion(acAlloc.Adapter()),
+        nadsOsts(acAlloc.Adapter()),
+        assignSetOfVst(acAlloc.Adapter()),
+        aliasSetOfOst(acAlloc.Adapter()),
+        vstNextLevNotAllDefsSeen(acAlloc.Adapter()),
+        ostNotAllDefsSeen(acAlloc.Adapter()),
+        lessThrowAlias(lessThrowAliasParam),
+        ignoreIPA(ignoreIPA),
+        calleeHasSideEffect(setCalleeHasSideEffect),
+        klassHierarchy(kh) {}
+
+  ~AliasClass() override = default;
+
+  using AssignSet = MapleSet<unsigned>; // value is VersionSt index
+  using VstIdx2AssignSet = MapleVector<AssignSet*>; // index is VersionSt index
+  using AliasSet = MapleSet<unsigned>; // value is OStIdx
+  using OstIdx2AliasSet = MapleVector<AliasSet*>; // index is OStIdx
+  using Vst2AliasElem = MapleVector<AliasElem*>; // index is VersionSt index
+  using AliasAttrVec = MapleVector<bool>; // index is OStIdx/VersionSt index
+
+  void SetAnalyzedOstNum(size_t num) {
+    analyzedOstNum = num;
+  }
+
+  bool OstAnalyzed(const OStIdx &ostIdx) const {
+    return ostIdx < analyzedOstNum;
+  }
+
+  void ReinitUnionFind() {
+    unionFind.Reinit();
+  }
+
+  const UnionFind &GetUnionFind() const {
+    return unionFind;
+  }
+
+  void ApplyUnionForPhi(const PhiNode &phi);
+  void ApplyUnionForIntrinsicCall(const IntrinsiccallNode &intrinsicCall);
+  void ApplyUnionForCopies(StmtNode &stmt);
+  void ApplyUnionForFieldsInCopiedAgg();
+  bool IsGlobalOstTypeUnsafe(const OriginalSt &ost) const;
+  void PropagateTypeUnsafe();
+  void PropagateTypeUnsafeVertically(const VersionSt &vst) const;
+  MIRType *GetAliasInfoRealType(const AliasInfo &ai, const BaseNode &expr);
+  bool IsAddrTypeConsistent(MIRType *typeA, MIRType *typeB) const;
+  void SetTypeUnsafeForAddrofUnion(const VersionSt *vst) const;
+  void SetTypeUnsafeForTypeConversion(const VersionSt *lhsVst, BaseNode *rhsExpr);
+  void CreateAssignSets();
+  void DumpAssignSets();
+  void GetValueAliasSetOfVst(size_t vstIdx, std::set<size_t> &result);
+  void UnionAllPointedTos();
+  void ApplyUnionForPointedTos();
+  void CollectRootIDOfNextLevelNodes(const MapleVector<OriginalSt*> *nextLevelOsts,
+                                     std::set<unsigned int> &rootIDOfNADSs);
+  void UnionForNotAllDefsSeen();
+  void UnionForNotAllDefsSeenCLang();
+  void ApplyUnionForStorageOverlaps();
+  void UnionForAggAndFields();
+  void CollectAliasGroups(std::map<unsigned int, std::set<unsigned int>> &aliasGroups);
+  bool AliasAccordingToType(TyIdx tyIdxA, TyIdx tyIdxB);
+  bool AliasAccordingToFieldID(const OriginalSt &ostA, const OriginalSt &ostB) const;
+  void ReconstructAliasGroups();
+  void CollectNotAllDefsSeenAes();
+  void CreateClassSets();
+  void DumpClassSets(bool onlyDumpRoot = true);
+  void InsertMayDefUseCall(StmtNode &stmt, BBId bbid, bool isDirectCall);
+  void GenericInsertMayDefUse(StmtNode &stmt, BBId bbID);
+
+  static bool MayAliasBasicAA(const OriginalSt *ostA, const OriginalSt *ostB);
+  bool MayAlias(const OriginalSt *ostA, const OriginalSt *ostB) const;
+
+  static OffsetType OffsetInBitOfArrayElement(const ArrayNode *arrayNode);
+  static OriginalSt *FindOrCreateExtraLevOst(SSATab *ssaTable, const VersionSt *pointerVst, const TyIdx &tyIdx,
+                                             FieldID fld, OffsetType offset);
+
+  MapleAllocator &GetMapleAllocator() {
+    return acAlloc;
+  }
+
+  static inline bool IreadedMemInconsistentWithPointedType(PrimType ireadedPrimType, PrimType pointedPrimType) {
+    if (IsPrimitiveVector(ireadedPrimType) || IsPrimitiveVector(pointedPrimType)) {
+      return (GetPrimTypeSize(ireadedPrimType) != GetPrimTypeSize(pointedPrimType));
+    }
+    return false;
+  }
+
+  AliasSet *GetAliasSet(const OStIdx &ostIdx) const {
+    if (ostIdx >= aliasSetOfOst.size()) {
+      return nullptr;
+    }
+    return aliasSetOfOst[ostIdx];
+  }
+
+  AliasSet *GetAliasSet(const OriginalSt &ost) const {
+    return GetAliasSet(ost.GetIndex());
+  }
+
+ protected:
+  virtual bool InConstructorLikeFunc() const {
+    return true;
+  }
+
+  void SetAliasSet(const OStIdx &ostIdx, AliasSet *aliasSet) {
+    if (aliasSetOfOst.size() <= ostIdx) {
+      constexpr size_t bufferSize = 10;
+      size_t incNum = ostIdx - aliasSetOfOst.size() + bufferSize;
+      (void)aliasSetOfOst.insert(aliasSetOfOst.end(), incNum, nullptr);
+    }
+    aliasSetOfOst[ostIdx] = aliasSet;
+  }
+
+  MIRModule &mirModule;
+
+ private:
+  bool CallHasNoSideEffectOrPrivateDefEffect(const CallNode &stmt, FuncAttrKind attrKind) const;
+  const FuncDesc &GetFuncDescFromCallStmt(const CallNode &stmt) const;
+  bool CallHasNoPrivateDefEffect(StmtNode *stmt) const;
+  void RecordAliasAnalysisInfo(const VersionSt &vst);
+  VersionSt *FindOrCreateVstOfExtraLevOst(BaseNode &expr, const TyIdx &tyIdx, FieldID fieldId, bool typeHasBeenCasted);
+  AliasInfo CreateAliasInfoExpr(BaseNode &expr);
+  void SetNotAllDefsSeenForMustDefs(const StmtNode &callas);
+  void SetPtrOpndNextLevNADS(const BaseNode &opnd, VersionSt *vst, bool hasNoPrivateDefEffect);
+  void SetPtrOpndsNextLevNADS(unsigned int start, unsigned int end, MapleVector<BaseNode*> &opnds,
+                              bool hasNoPrivateDefEffect);
+  void SetAggPtrFieldsNextLevNADS(const OriginalSt &ost);
+  void SetPtrFieldsOfAggNextLevNADS(const BaseNode *opnd, const VersionSt *vst);
+  void SetAggOpndPtrFieldsNextLevNADS(MapleVector<BaseNode*> &opnds);
+  void ApplyUnionForDassignCopy(VersionSt &lhsVst, VersionSt *rhsVst, BaseNode &rhs);
+  bool SetNextLevNADSForEscapePtr(const VersionSt &lhsVst, BaseNode &rhs);
+  void UnionNextLevelOfAliasOst(OstPtrSet &ostsToUnionNextLev);
+  VersionSt *FindOrCreateDummyNADSVst();
+  VersionSt &FindOrCreateVstOfAddrofOSt(OriginalSt &oSt);
+  void CollectMayDefForMustDefs(const StmtNode &stmt, OstPtrSet &mayDefOsts);
+  void CollectMayUseForNextLevel(const VersionSt &vst, OstPtrSet &mayUseOsts,
+                                 const StmtNode &stmt, bool isFirstOpnd);
+  void CollectMayUseForIntrnCallOpnd(const StmtNode &stmt, OstPtrSet &mayDefOsts, OstPtrSet &mayUseOsts);
+  void CollectMayDefUseForIthOpnd(const VersionSt &vst, OstPtrSet &mayUseOsts,
+                                  const StmtNode &stmt, bool isFirstOpnd);
+  void CollectMayDefUseForCallOpnd(const StmtNode &stmt,
+                                   OstPtrSet &mayDefOsts, OstPtrSet &mayUseOsts,
+                                   OstPtrSet &mustNotDefOsts, OstPtrSet &mustNotUseOsts);
+  void InsertMayDefNodeForCall(OstPtrSet &mayDefOsts, AccessSSANodes *ssaPart,
+                               StmtNode &stmt, BBId bbid, bool hasNoPrivateDefEffect);
+  void InsertMayUseExpr(BaseNode &expr);
+  void CollectMayUseFromFormals(OstPtrSet &mayUseOsts, bool needToBeRestrict);
+  void CollectMayUseFromGlobalsAffectedByCalls(OstPtrSet &mayUseOsts);
+  void CollectMayUseFromDefinedFinalField(OstPtrSet &mayUseOsts);
+  void InsertMayUseNode(OstPtrSet &mayUseOsts, AccessSSANodes *ssaPart);
+  void InsertMayUseReturn(const StmtNode &stmt);
+  void CollectPtsToOfReturnOpnd(const VersionSt &vst, OstPtrSet &mayUseOsts);
+  void InsertReturnOpndMayUse(const StmtNode &stmt);
+  void InsertMayUseAll(const StmtNode &stmt);
+  void CollectMayDefForDassign(const StmtNode &stmt, OstPtrSet &mayDefOsts);
+  void InsertMayDefNode(OstPtrSet &mayDefOsts, AccessSSANodes *ssaPart, StmtNode &stmt, BBId bbid);
+  void InsertMayDefDassign(StmtNode &stmt, BBId bbid);
+  bool IsEquivalentField(TyIdx tyIdxA, FieldID fldA, TyIdx tyIdxB, FieldID fldB) const;
+  bool IsAliasInfoEquivalentToExpr(const AliasInfo &ai, const BaseNode *expr);
+  void CollectMayDefForIassign(StmtNode &stmt, OstPtrSet &mayDefOsts);
+  void InsertMayDefNodeExcludeFinalOst(OstPtrSet &mayDefOsts, AccessSSANodes *ssaPart,
+                                       StmtNode &stmt, BBId bbid);
+  void InsertMayDefIassign(StmtNode &stmt, BBId bbid);
+  void InsertMayDefUseSyncOps(StmtNode &stmt, BBId bbid);
+  void InsertMayUseNodeExcludeFinalOst(const OstPtrSet &mayUseOsts, AccessSSANodes *ssaPart);
+  void InsertMayDefUseIntrncall(StmtNode &stmt, BBId bbid);
+  void InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt, BBId bbid);
+  void InsertMayDefUseAsm(StmtNode &stmt, const BBId bbid);
+  virtual BB *GetBB(BBId id) = 0;
+  void ProcessIdsAliasWithRoot(const std::set<unsigned int> &idsAliasWithRoot, std::vector<unsigned int> &newGroups);
+  int GetOffset(const Klass &super, const Klass &base) const;
+  void UnionAllNodes(MapleVector<OriginalSt *> *nextLevOsts);
+
+  AssignSet *GetAssignSet(size_t vstIdx) {
+    if (vstIdx >= assignSetOfVst.size()) {
+      return nullptr;
+    }
+    return assignSetOfVst[vstIdx];
+  }
+
+  AssignSet *GetAssignSet(const VersionSt &vst) {
+    return GetAssignSet(vst.GetIndex());
+  }
+
+  bool IsNextLevNotAllDefsSeen(size_t vstIdx) {
+    if (vstIdx >= vstNextLevNotAllDefsSeen.size()) {
+      return false;
+    }
+    return vstNextLevNotAllDefsSeen[vstIdx];
+  }
+
+  void SetNextLevNotAllDefsSeen(size_t vstIdx) {
+    if (vstIdx >= vstNextLevNotAllDefsSeen.size()) {
+      size_t bufferSize = 5;
+      size_t incNum = vstIdx + bufferSize - vstNextLevNotAllDefsSeen.size();
+      vstNextLevNotAllDefsSeen.insert(vstNextLevNotAllDefsSeen.end(), incNum, false);
+    }
+    vstNextLevNotAllDefsSeen[vstIdx] = true;
+  }
+
+  bool IsNotAllDefsSeen(const OStIdx &ostIdx) {
+    if (ostIdx >= ostNotAllDefsSeen.size()) {
+      return false;
+    }
+    return ostNotAllDefsSeen[ostIdx];
+  }
+
+  void SetNotAllDefsSeen(const OStIdx &ostIdx) {
+    if (ostIdx >= ostNotAllDefsSeen.size()) {
+      size_t bufferSize = 5;
+      size_t incNum = ostIdx + bufferSize - ostNotAllDefsSeen.size();
+      ostNotAllDefsSeen.insert(ostNotAllDefsSeen.end(), incNum, false);
+    }
+    ostNotAllDefsSeen[ostIdx] = true;
+  }
+
+  MemPool &acMemPool;
+  MapleAllocator acAlloc;
+  SSATab &ssaTab;
+  UnionFind unionFind;
+  // set of class ids of globals
+  MapleSet<OriginalSt*, OriginalSt::OriginalStPtrComparator> globalsAffectedByCalls;
+  // aliased at calls; needed only when wholeProgramScope is true
+  MapleSet<OStIdx> globalsMayAffectedByClinitCheck;
+  MapleMap<OriginalSt*, OriginalSt*> aggsToUnion; // aggs are copied, their fields should be unioned
+  MapleSet<OriginalSt*, OriginalSt::OriginalStPtrComparator> nadsOsts;
+  VstIdx2AssignSet assignSetOfVst;
+  OstIdx2AliasSet aliasSetOfOst;
+  AliasAttrVec vstNextLevNotAllDefsSeen;
+  AliasAttrVec ostNotAllDefsSeen;
+
+  bool lessThrowAlias;
+  bool ignoreIPA;        // whether to ignore information provided by IPA
+  bool calleeHasSideEffect;
+  KlassHierarchy *klassHierarchy;
+  size_t analyzedOstNum = 0;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ALIAS_CLASS_H
diff --git a/src/mapleall/maple_me/include/bb.h b/src/mapleall/maple_me/include/bb.h
new file mode 100644
index 0000000000000000000000000000000000000000..ed14b265bb2ed18d97b098a5bb41c61a8b9cf4b3
--- /dev/null
+++ b/src/mapleall/maple_me/include/bb.h
@@ -0,0 +1,649 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_BB_H
+#define MAPLE_ME_INCLUDE_BB_H
+#include "mpl_number.h"
+#include "orig_symbol.h"
+#include "ptr_list_ref.h"
+#include "ssa.h"
+#include "utils.h"
+#include "ver_symbol.h"
+#include "base_graph_node.h"
+namespace maple {
+class MeStmt;          // circular dependency exists, no other choice
+class MePhiNode;       // circular dependency exists, no other choice
+class PiassignMeStmt;  // circular dependency exists, no other choice
+class IRMap;           // circular dependency exists, no other choice
+enum BBKind {
+  kBBUnknown,  // uninitialized
+  kBBCondGoto,
+  kBBGoto,  // unconditional branch
+  kBBFallthru,
+  kBBReturn,
+  kBBNoReturn, // exit func without return
+  kBBAfterGosub,  // the BB that follows a gosub, as it is an entry point
+  kBBSwitch,
+  kBBIgoto,
+  kBBInvalid
+};
+
+enum BBAttr : uint32 {
+  kBBAttrIsEntry = utils::bit_field_v<1>,
+  kBBAttrIsExit = utils::bit_field_v<2>,
+  kBBAttrWontExit = utils::bit_field_v<3>,
+  kBBAttrIsTry = utils::bit_field_v<4>,
+  kBBAttrIsTryEnd = utils::bit_field_v<5>,
+  kBBAttrIsJSCatch = utils::bit_field_v<6>,
+  kBBAttrIsJSFinally = utils::bit_field_v<7>,
+  kBBAttrIsCatch = utils::bit_field_v<8>,
+  kBBAttrIsJavaFinally = utils::bit_field_v<9>,
+  kBBAttrArtificial = utils::bit_field_v<10>,
+  kBBAttrIsInLoop = utils::bit_field_v<11>,
+  kBBAttrIsInLoopForEA = utils::bit_field_v<12>,
+  kBBAttrIsInstrument = utils::bit_field_v<13>
+};
+
+constexpr uint32 kBBVectorInitialSize = 2;
+using StmtNodes = PtrListRef<StmtNode>;
+using MeStmts = PtrListRef<MeStmt>;
+
+class BB : public BaseGraphNode {
+ public:
+  using BBId = utils::Index<BB>;
+
+  BB(MapleAllocator *alloc, MapleAllocator *versAlloc, BBId id)
+      : BaseGraphNode(id.GetIdx()),
+        pred(kBBVectorInitialSize, nullptr, alloc->Adapter()),
+        succ(kBBVectorInitialSize, nullptr, alloc->Adapter()),
+        succFreq(alloc->Adapter()),
+        phiList(versAlloc->Adapter()),
+        mePhiList(alloc->Adapter()),
+        meVarPiList(alloc->Adapter()),
+        group(this) {
+    pred.pop_back();
+    pred.pop_back();
+    succ.pop_back();
+    succ.pop_back();
+  }
+
+  BB(MapleAllocator *alloc, MapleAllocator *versAlloc, BBId id, StmtNode *firstStmt, StmtNode *lastStmt)
+      : BaseGraphNode(id.GetIdx()),
+        pred(kBBVectorInitialSize, nullptr, alloc->Adapter()),
+        succ(kBBVectorInitialSize, nullptr, alloc->Adapter()),
+        succFreq(alloc->Adapter()),
+        phiList(versAlloc->Adapter()),
+        mePhiList(alloc->Adapter()),
+        meVarPiList(alloc->Adapter()),
+        stmtNodeList(firstStmt, lastStmt),
+        group(this) {
+    pred.pop_back();
+    pred.pop_back();
+    succ.pop_back();
+    succ.pop_back();
+  }
+
+  virtual ~BB() = default;
+
+  const std::string GetIdentity() final {
+    return "BBId: " + std::to_string(GetID());
+  }
+
+  void GetOutNodes(std::vector<BaseGraphNode*> &outNodes) final {
+    for (auto &bb : succ) {
+      outNodes.emplace_back(bb);
+    }
+  }
+
+  void GetOutNodes(std::vector<BaseGraphNode*> &outNodes) const final {
+    for (auto &bb : succ) {
+      outNodes.emplace_back(bb);
+    }
+  }
+
+  void GetInNodes(std::vector<BaseGraphNode*> &outNodes) final {
+    for (auto &bb : pred) {
+      outNodes.emplace_back(bb);
+    }
+  }
+
+  void GetInNodes(std::vector<BaseGraphNode*> &outNodes) const final {
+    for (auto &bb : pred) {
+      outNodes.emplace_back(bb);
+    }
+  }
+
+  bool GetAttributes(uint32 attrKind) const {
+    return (attributes & attrKind) != 0;
+  }
+
+  uint32 GetAttributes() const {
+    return attributes;
+  }
+
+  void SetAttributes(uint32 attrKind) {
+    attributes |= attrKind;
+  }
+
+  void ClearAttributes(uint32 attrKind) {
+    attributes &= (~attrKind);
+  }
+
+  virtual bool IsGoto() const {
+    return kind == kBBGoto;
+  }
+
+  virtual bool AddBackEndTry() const {
+    return GetAttributes(kBBAttrIsTryEnd);
+  }
+
+  void Dump(const MIRModule *mod);
+  void DumpHeader(const MIRModule *mod) const;
+  void DumpPhi();
+  void DumpBBAttribute(const MIRModule *mod) const;
+  std::string StrAttribute() const;
+
+  // Only use for common entry bb
+  void AddEntry(BB &bb) {
+    succ.push_back(&bb);
+  }
+
+  // Only use for common entry bb
+  void RemoveEntry(const BB &bb) {
+    (void)bb.RemoveBBFromVector(succ);
+  }
+
+  // Only use for common exit bb
+  void AddExit(BB &bb) {
+    pred.push_back(&bb);
+  }
+
+  // Only use for common exit bb
+  void RemoveExit(const BB &bb) {
+    (void)bb.RemoveBBFromVector(pred);
+  }
+
+  void AddPred(BB &predBB, size_t pos = UINT32_MAX) {
+    ASSERT((pos <= pred.size() || pos == UINT32_MAX), "Invalid position.");
+    ASSERT((!predBB.IsInList(pred) && !IsInList(predBB.succ)), "BB already has been Added.");
+    ASSERT((GetBBId() != 0 && GetBBId() != 1), "CommonEntry or CommonExit should not be here.");
+    ASSERT((predBB.GetBBId() != 0 && predBB.GetBBId() != 1), "CommonEntry or CommonExit should not be here.");
+    if (pos == UINT32_MAX) {
+      pred.push_back(&predBB);
+    } else {
+      pred.insert(pred.begin() + pos, &predBB);
+    }
+    predBB.succ.push_back(this);
+  }
+
+  void AddSucc(BB &succBB, size_t pos = UINT32_MAX) {
+    ASSERT((pos <= succ.size() || pos == UINT32_MAX), "Invalid position.");
+    ASSERT((!succBB.IsInList(succ) && !IsInList(succBB.pred)), "BB already has been Added.");
+    ASSERT((GetBBId() != 0 && GetBBId() != 1), "CommonEntry or CommonExit should not be here.");
+    ASSERT((succBB.GetBBId() != 0 && succBB.GetBBId() != 1), "CommonEntry or CommonExit should not be here.");
+    if (pos == UINT32_MAX) {
+      succ.push_back(&succBB);
+    } else {
+      succ.insert(succ.begin() + pos, &succBB);
+    }
+    succBB.pred.push_back(this);
+  }
+
+  // This is to help new bb to keep some flags from original bb after logically splitting.
+  void CopyFlagsAfterSplit(const BB &bb) {
+    bb.GetAttributes(kBBAttrIsTry) ? SetAttributes(kBBAttrIsTry) : ClearAttributes(kBBAttrIsTry);
+    bb.GetAttributes(kBBAttrIsTryEnd) ? SetAttributes(kBBAttrIsTryEnd) : ClearAttributes(kBBAttrIsTryEnd);
+    bb.GetAttributes(kBBAttrIsExit) ? SetAttributes(kBBAttrIsExit) : ClearAttributes(kBBAttrIsExit);
+    bb.GetAttributes(kBBAttrWontExit) ? SetAttributes(kBBAttrWontExit) : ClearAttributes(kBBAttrWontExit);
+  }
+
+  BBId GetBBId() const {
+    return BBId(GetID());
+  }
+
+  void SetBBId(BBId idx) {
+    SetID(idx.GetIdx());
+  }
+
+  uint32 UintID() const {
+    return GetID();
+  }
+
+  StmtNode *GetTheOnlyStmtNode();
+  bool IsEmpty() const {
+    return stmtNodeList.empty();
+  }
+
+  void SetFirst(StmtNode *stmt) {
+    stmtNodeList.update_front(stmt);
+  }
+
+  void SetLast(StmtNode *stmt) {
+    stmtNodeList.update_back(stmt);
+  }
+
+  // should test IsEmpty first
+  StmtNode &GetFirst() {
+    return stmtNodeList.front();
+  }
+  // should test IsEmpty first
+  const StmtNode &GetFirst() const {
+    return stmtNodeList.front();
+  }
+
+  // should test IsEmpty first
+  StmtNode &GetLast() {
+    return stmtNodeList.back();
+  }
+  // should test IsEmpty first
+  const StmtNode &GetLast() const {
+    return stmtNodeList.back();
+  }
+
+  void SetFirstMe(MeStmt *stmt);
+  void SetLastMe(MeStmt *stmt);
+  MeStmt *GetLastMe();
+  const MeStmt *GetLastMe() const;
+  MeStmt *GetFirstMe();
+  const MeStmt *GetFirstMe() const;
+  bool IsPredBB(const BB &bb) const {
+    // if this is a pred of bb return true;
+    // otherwise return false;
+    return IsInList(bb.pred);
+  }
+
+  bool IsSuccBB(const BB &bb) const {
+    return IsInList(bb.succ);
+  }
+  void DumpMeBB(const IRMap &irMap);
+  void ReplacePred(const BB *old, BB *newPred);
+  void MoveAllPredToSucc(BB *newSucc, BB *commonEntry);
+  void ReplaceSucc(const BB *old, BB *newSucc, bool updatePhi = false);
+  void MoveAllSuccToPred(BB *newPred, BB *commonExit);
+  void AddStmtNode(StmtNode *stmt);
+  void PrependStmtNode(StmtNode *stmt);
+  void RemoveStmtNode(StmtNode *stmt);
+  void RemoveLastStmt();
+  void InsertStmtBefore(const StmtNode *stmt, StmtNode *newStmt);
+  void ReplaceStmt(StmtNode *stmt, StmtNode *newStmt);
+
+  void RemovePred(BB &predBB, bool updatePhi = true) {
+    ASSERT((GetBBId() != 0 && GetBBId() != 1), "CommonEntry or CommonExit should not be here.");
+    ASSERT((predBB.GetBBId() != 0 && predBB.GetBBId() != 1), "CommonEntry or CommonExit should not be here.");
+    RemoveBBFromPred(predBB, updatePhi);
+    predBB.RemoveBBFromSucc(*this);
+  }
+
+  void RemoveSucc(BB &succBB, bool updatePhi = true) {
+    ASSERT((GetBBId() != 0 && GetBBId() != 1), "CommonEntry or CommonExit should not be here.");
+    ASSERT((succBB.GetBBId() != 0 && succBB.GetBBId() != 1), "CommonEntry or CommonExit should not be here.");
+    succBB.RemoveBBFromPred(*this, updatePhi);
+    RemoveBBFromSucc(succBB);
+  }
+
+  void RemoveAllPred() {
+    while (!pred.empty()) {
+      RemovePred(*pred.back());
+    }
+  }
+
+  void RemoveAllSucc() {
+    while (!succ.empty()) {
+      RemoveSucc(*succ.back());
+    }
+    succFreq.clear();
+  }
+
+  void InsertPi(BB &bb, PiassignMeStmt &s) {
+    if (meVarPiList.find(&bb) == meVarPiList.end()) {
+      std::vector<PiassignMeStmt*> tmp;
+      meVarPiList[&bb] = tmp;
+    }
+    meVarPiList[&bb].push_back(&s);
+  }
+
+  MapleMap<BB*, std::vector<PiassignMeStmt*>> &GetPiList() {
+    return meVarPiList;
+  }
+
+  bool IsMeStmtEmpty() const {
+    return meStmtList.empty();
+  }
+
+  bool IsReturnBB() const {
+    return kind == kBBReturn && !stmtNodeList.empty() && stmtNodeList.back().GetOpCode() == OP_return;
+  }
+
+  void FindReachableBBs(std::vector<bool> &visitedBBs) const;
+  void FindWillExitBBs(std::vector<bool> &visitedBBs) const;
+  const PhiNode *PhiofVerStInserted(const VersionSt &versionSt) const;
+  bool InsertPhi(MapleAllocator *alloc, VersionSt *versionSt);
+  void PrependMeStmt(MeStmt *meStmt);
+  void RemoveMeStmt(MeStmt *meStmt);
+  void AddMeStmtFirst(MeStmt *meStmt);
+  void AddMeStmtLast(MeStmt *meStmt);
+  void InsertMeStmtBefore(const MeStmt *meStmt, MeStmt *inStmt);
+  void InsertMeStmtAfter(const MeStmt *meStmt, MeStmt *inStmt);
+  void InsertMeStmtLastBr(MeStmt *inStmt);
+  void ReplaceMeStmt(MeStmt *stmt, MeStmt *newStmt);
+  void RemoveLastMeStmt();
+  void DumpMePhiList(const IRMap *irMap);
+  void DumpMeVarPiList(const IRMap *irMap);
+  void EmitBB(BlockNode &curblk, bool needAnotherPass);
+  StmtNodes &GetStmtNodes() {
+    return stmtNodeList;
+  }
+
+  const StmtNodes &GetStmtNodes() const {
+    return stmtNodeList;
+  }
+
+  MeStmts &GetMeStmts() {
+    return meStmtList;
+  }
+
+  const MeStmts &GetMeStmts() const {
+    return meStmtList;
+  }
+
+  LabelIdx GetBBLabel() const {
+    return bbLabel;
+  }
+
+  void SetBBLabel(LabelIdx idx) {
+    bbLabel = idx;
+  }
+
+  uint64 GetFrequency() const {
+    return frequency;
+  }
+
+  void SetFrequency(uint64 f) {
+    frequency = f;
+  }
+
+  BBKind GetKind() const {
+    return kind;
+  }
+
+  void SetKind(BBKind bbKind) {
+    kind = bbKind;
+  }
+
+  void SetKindReturn() {
+    SetKind(kBBReturn);
+    SetAttributes(kBBAttrIsExit);
+  }
+
+  const MapleVector<BB*> &GetPred() const {
+    return pred;
+  }
+
+  MapleVector<BB*> &GetPred() {
+    return pred;
+  }
+
+  BB *GetUniquePred() const {
+    if (pred.empty()) {
+      return nullptr;
+    }
+    if (pred.size() == 1) {
+      return pred.front();
+    }
+    for (size_t i = 0; i < pred.size(); ++i) {
+      if (pred.at(i) != pred.at(0)) {
+        return nullptr;
+      }
+    }
+    return pred.front();
+  }
+
+  const BB *GetPred(size_t cnt) const {
+    ASSERT(cnt < pred.size(), "out of range in BB::GetPred");
+    return pred.at(cnt);
+  }
+
+  BB *GetPred(size_t cnt) {
+    ASSERT(cnt < pred.size(), "out of range in BB::GetPred");
+    return pred.at(cnt);
+  }
+
+  void SetPred(size_t cnt, BB *pp) {
+    CHECK_FATAL(cnt < pred.size(), "out of range in BB::SetPred");
+    pred[cnt] = pp;
+  }
+
+  void PushBackSuccFreq(uint64 freq) {
+    return succFreq.push_back(freq);
+  }
+
+  MapleVector<uint64> &GetSuccFreq() {
+    return succFreq;
+  }
+  void SetSuccFreq(int idx, uint64 freq) {
+    ASSERT(idx >= 0 && idx <= succFreq.size(), "sanity check");
+    succFreq[static_cast<size_t>(idx)] = freq;
+  }
+  void AddSuccFreq(uint64 freq, size_t pos = UINT32_MAX) {
+    ASSERT((pos <= succFreq.size() || pos == UINT32_MAX), "Invalid position.");
+    if (pos == UINT32_MAX) {
+      succFreq.push_back(freq);
+    } else {
+      succFreq.insert(succFreq.begin() + pos, freq);
+    }
+  }
+
+  // update edge frequency
+  void UpdateEdgeFreqs(bool updateSuccFreq = true);
+
+  const MapleVector<BB*> &GetSucc() const {
+    return succ;
+  }
+
+  MapleVector<BB*> &GetSucc() {
+    return succ;
+  }
+
+  BB *GetUniqueSucc() {
+    if (succ.empty()) {
+      return nullptr;
+    }
+    if (succ.size() == 1) {
+      return succ.front();
+    }
+    for (size_t i = 0; i < succ.size(); ++i) {
+      if (succ.at(i) != succ.at(0)) {
+        return nullptr;
+      }
+    }
+    return succ.front();
+  }
+
+  const BB *GetSucc(size_t cnt) const {
+    ASSERT(cnt < succ.size(), "out of range in BB::GetSucc");
+    return succ.at(cnt);
+  }
+
+  BB *GetSucc(size_t cnt) {
+    ASSERT(cnt < succ.size(), "out of range in BB::GetSucc");
+    return succ.at(cnt);
+  }
+
+  void SetSucc(size_t cnt, BB *ss) {
+    CHECK_FATAL(cnt < succ.size(), "out of range in BB::SetSucc");
+    succ[cnt] = ss;
+  }
+
+  const MapleMap<OStIdx, PhiNode> &GetPhiList() const {
+    return phiList;
+  }
+  MapleMap<OStIdx, PhiNode> &GetPhiList() {
+    return phiList;
+  }
+  void ClearPhiList() {
+    phiList.clear();
+  }
+
+  MapleMap<OStIdx, MePhiNode*> &GetMePhiList() {
+    return mePhiList;
+  }
+
+  const MapleMap<OStIdx, MePhiNode*> &GetMePhiList() const {
+    return mePhiList;
+  }
+
+  void ClearMePhiList() {
+    mePhiList.clear();
+  }
+
+  uint64 GetEdgeFreq(const BB *bb) const {
+    auto iter = std::find(succ.begin(), succ.end(), bb);
+    CHECK_FATAL(iter != std::end(succ), "%d is not the successor of %d", bb->UintID(), this->UintID());
+    CHECK_FATAL(succ.size() == succFreq.size(), "succfreq size doesn't match succ size");
+    const size_t idx = static_cast<size_t>(std::distance(succ.begin(), iter));
+    return succFreq[idx];
+  }
+
+  uint64 GetEdgeFreq(size_t idx) const {
+    CHECK_FATAL(idx < succFreq.size(), "out of range in BB::GetEdgeFreq");
+    CHECK_FATAL(succ.size() == succFreq.size(), "succfreq size doesn't match succ size");
+    return succFreq[idx];
+  }
+
+  void SetEdgeFreq(const BB *bb, uint64 freq) {
+    auto iter = std::find(succ.begin(), succ.end(), bb);
+    CHECK_FATAL(iter != std::end(succ), "%d is not the successor of %d", bb->UintID(), this->UintID());
+    CHECK_FATAL(succ.size() == succFreq.size(), "succfreq size %d doesn't match succ size %d", succFreq.size(),
+                succ.size());
+    const size_t idx = static_cast<size_t>(std::distance(succ.begin(), iter));
+    succFreq[idx] = freq;
+  }
+
+  void InitEdgeFreq() {
+    succFreq.resize(succ.size());
+  }
+
+  BB *GetGroup() const {
+    return group;
+  }
+
+  void SetGroup(BB *g) {
+    group = g;
+  }
+
+  void ClearGroup() {
+    group = this;
+  }
+
+  void GetTrueAndFalseBranch(Opcode op, BB *&trueBranch, BB *&falseBranch) const {
+    if (op == OP_brtrue) {
+      trueBranch = succ[1];
+      falseBranch = succ[0];
+    } else {
+      ASSERT(op == OP_brfalse, "must be brfalse");
+      trueBranch = succ[0];
+      falseBranch = succ[1];
+    }
+  }
+
+  void RemoveBBFromPred(const BB &bb, bool updatePhi);
+  void RemoveBBFromSucc(const BB &bb);
+  int GetPredIndex(const BB &predBB) const;
+  int GetSuccIndex(const BB &succBB) const;
+  void RemovePhiOpnd(int index);
+
+ private:
+  bool IsInList(const MapleVector<BB*> &bbList) const;
+  int RemoveBBFromVector(MapleVector<BB*> &bbVec) const;
+
+  LabelIdx bbLabel = 0;    // the BB's label
+  MapleVector<BB*> pred;  // predecessor list
+  MapleVector<BB*> succ;  // successor list
+  // record the edge freq from curBB to succ BB
+  MapleVector<uint64> succFreq;
+  MapleMap<OStIdx, PhiNode> phiList;
+  MapleMap<OStIdx, MePhiNode*> mePhiList;
+  MapleMap<BB*, std::vector<PiassignMeStmt*>> meVarPiList;
+  uint64 frequency = 0;
+  BBKind kind = kBBUnknown;
+  uint32 attributes = 0;
+
+ public:
+  StmtNodes stmtNodeList;
+
+ private:
+  MeStmts meStmtList;
+  BB *group;
+};
+
+using BBId = BB::BBId;
+
+class SCCOfBBs {
+ public:
+  SCCOfBBs(uint32 index, BB *bb, MapleAllocator *alloc)
+      : id(index),
+        entry(bb),
+        bbs(alloc->Adapter()),
+        predSCC(std::less<SCCOfBBs*>(), alloc->Adapter()),
+        succSCC(std::less<SCCOfBBs*>(), alloc->Adapter()) {}
+  ~SCCOfBBs() = default;
+  void Dump();
+  void Verify(MapleVector<SCCOfBBs*> &sccOfBB);
+  void SetUp(MapleVector<SCCOfBBs*> &sccOfBB);
+  bool HasCycle() const;
+  void AddBBNode(BB *bb) {
+    bbs.push_back(bb);
+  }
+  void Clear() {
+    bbs.clear();
+  }
+  uint32 GetID() const {
+    return id;
+  }
+  const MapleVector<BB*> &GetBBs() const {
+    return bbs;
+  }
+  const MapleSet<SCCOfBBs*> &GetSucc() const {
+    return succSCC;
+  }
+  const MapleSet<SCCOfBBs*> &GetPred() const {
+    return predSCC;
+  }
+  bool HasPred() const {
+    return !predSCC.empty();
+  }
+  BB *GetEntry() {
+    return entry;
+  }
+
+ private:
+  uint32 id;
+  BB *entry;
+  MapleVector<BB*> bbs;
+  MapleSet<SCCOfBBs*> predSCC;
+  MapleSet<SCCOfBBs*> succSCC;
+};
+
+bool ControlFlowInInfiniteLoop(const BB &bb, Opcode opcode);
+}  // namespace maple
+
+namespace std {
+template <>
+struct hash<maple::BBId> {
+  size_t operator()(const maple::BBId &x) const {
+    return x;
+  }
+};
+}  // namespace std
+#endif  // MAPLE_ME_INCLUDE_BB_H
diff --git a/src/mapleall/maple_me/include/cast_opt.h b/src/mapleall/maple_me/include/cast_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f975ae9281601425130df1b4d9aa6c41095c996
--- /dev/null
+++ b/src/mapleall/maple_me/include/cast_opt.h
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_CAST_OPT_H
+#define MAPLE_ME_INCLUDE_CAST_OPT_H
+#include "mir_nodes.h"
+#include "me_ir.h"
+
+namespace maple {
+// The order matters
+enum CastKind {
+  CAST_intTrunc = 0,
+  CAST_zext = 1,
+  CAST_sext = 2,
+  CAST_int2fp = 3,
+  CAST_fp2int = 4,
+  CAST_fpTrunc = 5,
+  CAST_fpExt = 6,
+  CAST_retype = 7,
+  CAST_unknown = 8
+};
+
+template <typename T, std::enable_if_t<std::is_base_of<MeExpr, T>::value ||
+    std::is_base_of<BaseNode, T>::value, bool> = true>
+class CastInfo {
+ public:
+  explicit CastInfo(T *expr) : expr(expr) {}
+  virtual ~CastInfo() = default;
+  virtual Opcode GetOp() {
+    CHECK_FATAL(false, "NYI");
+  }
+  PrimType GetPrimType() const {
+    return expr->GetPrimType();
+  }
+  virtual size_t GetBitsSize() {
+    CHECK_FATAL(false, "NYI");
+  }
+  virtual T* GetOpnd(size_t index __attribute__((unused))) {
+    CHECK_FATAL(false, "NYI");
+  }
+  virtual PrimType GetOpndType() {
+    CHECK_FATAL(false, "NYI");
+  }
+
+  bool IsInvalid() const {
+    return kind == CAST_unknown;
+  }
+  CastKind kind = CAST_unknown;  // CastInfo is invalid if kind is CAST_unknown
+  PrimType srcType = PTY_begin;
+  PrimType dstType = PTY_end;
+  T *expr = nullptr;  // expr's type must be MeExpr* or BaseNode*
+};
+
+class MeExprCastInfo : public CastInfo<MeExpr> {
+ public:
+  explicit MeExprCastInfo(MeExpr *expr) : CastInfo(expr) {}
+  ~MeExprCastInfo() = default;
+
+  Opcode GetOp() override {
+    return expr->GetOp();
+  }
+
+  size_t GetBitsSize() override {
+    switch (GetOp()) {
+      case OP_zext:
+      case OP_sext:
+        return static_cast<const OpMeExpr*>(expr)->GetBitsSize();
+      default:
+        CHECK_FATAL(false, "NYI");
+        break;
+    }
+  }
+
+  MeExpr* GetOpnd(size_t index) override {
+    return expr->GetOpnd(index);
+  }
+
+  PrimType GetOpndType() override {
+    switch (GetOp()) {
+      case OP_cvt:
+      case OP_retype:
+        return static_cast<const OpMeExpr*>(expr)->GetOpndType();
+      case OP_regread: {
+        const auto *scalarExpr = static_cast<const ScalarMeExpr*>(expr);
+        return scalarExpr->GetOst()->GetType()->GetPrimType();
+      }
+      case OP_iread: {
+        const auto *ivarExpr = static_cast<const IvarMeExpr*>(expr);
+        return ivarExpr->GetType()->GetPrimType();
+      }
+      default:
+        CHECK_FATAL(false, "NYI");
+        break;
+    }
+  }
+};
+
+class BaseNodeCastInfo : public CastInfo<BaseNode> {
+ public:
+  explicit BaseNodeCastInfo(BaseNode *expr) : CastInfo(expr) {}
+  ~BaseNodeCastInfo() = default;
+
+  Opcode GetOp() override {
+    return expr->GetOpCode();
+  }
+
+  size_t GetBitsSize() override {
+    switch (GetOp()) {
+      case OP_zext:
+      case OP_sext:
+        return static_cast<const ExtractbitsNode*>(expr)->GetBitsSize();
+      default:
+        CHECK_FATAL(false, "NYI");
+        break;
+    }
+  }
+
+  BaseNode* GetOpnd(size_t index) override {
+    return expr->Opnd(index);
+  }
+
+  PrimType GetOpndType() override {
+    switch (GetOp()) {
+      case OP_retype: {
+        return GetOpnd(0)->GetPrimType();
+      }
+      case OP_cvt:
+        return static_cast<const TypeCvtNode*>(expr)->FromType();
+      case OP_regread: {
+        const auto *regread = static_cast<const RegreadNode*>(expr);
+        PregIdx regIdx = regread->GetRegIdx();
+        MIRPreg *preg = theMIRModule->CurFunction()->GetPregItem(regIdx);
+        return preg->GetPrimType();
+      }
+      case OP_iread: {
+        const auto *iread = static_cast<const IreadNode*>(expr);
+        return iread->GetType()->GetPrimType();
+      }
+      case OP_dread: {
+        const auto *dread = static_cast<const DreadNode*>(expr);
+        StIdx stIdx = dread->GetStIdx();
+        MIRSymbol *symbol = theMIRModule->CurFunction()->GetLocalOrGlobalSymbol(stIdx);
+        CHECK_NULL_FATAL(symbol);
+        return symbol->GetType()->GetPrimType();
+      }
+      default:
+        CHECK_FATAL(false, "NYI");
+        break;
+    }
+  }
+};
+
+class CastOpt {
+ public:
+  static int IsEliminableCastPair(CastKind firstCastKind, CastKind secondCastKind,
+                                  PrimType dstType, PrimType midType2, PrimType midType1, PrimType &srcType);
+  template <typename T>
+  static void DoComputeCastInfo(CastInfo<T> &castInfo, bool isMeExpr);
+  static bool IsExplicitCastOp(Opcode op);
+  static bool IsImplicitCastOp(Opcode op);
+  static bool IsCompareOp(Opcode op);
+};
+
+class MeCastOpt : public CastOpt {
+ public:
+  static MeExpr *SimplifyCast(IRMap &irMap, MeExpr *expr);
+  static void SimplifyCastForAssign(MeStmt *assignStmt);
+  static void ComputeCastInfo(MeExprCastInfo &castInfo);
+  static MeExpr *CreateMeExprByCastKind(IRMap &irMap, CastKind castKind, PrimType srcType, PrimType dstType,
+                                        MeExpr *opnd, TyIdx dstTyIdx = TyIdx(0));
+  static MeExpr *SimplifyCastPair(IRMap &irMap, const MeExprCastInfo &firstCastInfo,
+                                  const MeExprCastInfo &secondCastInfo);
+  static MeExpr *SimplifyCastSingle(IRMap &irMap, const MeExprCastInfo &castInfo);
+  static MeExpr *TransformCvtU1ToNe(IRMap &irMap, OpMeExpr *cvtExpr);
+};
+
+class MapleCastOpt : public CastOpt {
+ public:
+  static void ComputeCastInfo(BaseNodeCastInfo &castInfo);
+  static BaseNode *CreateMapleExprByCastKind(MIRBuilder &mirBuilder, CastKind castKind, PrimType srcType,
+                                             PrimType dstType, BaseNode *opnd, TyIdx dstTyIdx = TyIdx(0));
+  static BaseNode *SimplifyCast(MIRBuilder &mirBuilder, BaseNode *expr);
+  static BaseNode *SimplifyCastPair(MIRBuilder &mirBuidler, const BaseNodeCastInfo &firstCastInfo,
+                                    const BaseNodeCastInfo &secondCastInfo);
+  static BaseNode *SimplifyCastSingle(MIRBuilder &mirBuilder, const BaseNodeCastInfo &castInfo);
+  static BaseNode *TransformCvtU1ToNe(MIRBuilder &mirBuilder, const TypeCvtNode *cvtExpr);
+};
+}
+#endif
diff --git a/src/mapleall/maple_me/include/cfg_opt.h b/src/mapleall/maple_me/include/cfg_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..0dac35d8180a7120917d59418d6ab2edcfb570eb
--- /dev/null
+++ b/src/mapleall/maple_me/include/cfg_opt.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_CFG_OPT_H
+#define MAPLE_ME_INCLUDE_CFG_OPT_H
+#include "bb.h"
+#include "me_cfg.h"
+#include "me_option.h"
+#include "dominance.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+class CfgOpt {
+ public:
+  CfgOpt(MeFunction &meFunc, MeCFG &cfg) : meFunc(meFunc), cfg(cfg) {}
+  ~CfgOpt() = default;
+  bool IsShortCircuitBB(LabelIdx labelIdx);
+  bool IsShortCircuitStIdx(StIdx stIdx);
+  bool IsAssignToShortCircuit(const StmtNode &stmt);
+  bool IsCompareShortCiruit(StmtNode &stmt);
+  void SimplifyCondGotoStmt(CondGotoNode &condGoto) const;
+  void SplitCondGotoBB(BB &bb);
+  void PropagateBB(BB &bb, BB *trueBranchBB, BB *falseBranchBB);
+  void PropagateOuterBBInfo();
+  void OptimizeShortCircuitBranch();
+  void Run();
+  bool IsCfgChanged() const {
+    return cfgChanged;
+  }
+ private:
+  MeFunction &meFunc;
+  MeCFG &cfg;
+  std::vector<std::pair<BB*, BB*>> changedShortCircuit;
+  bool cfgChanged = false;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MECFGOPT, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_CFG_OPT_H
\ No newline at end of file
diff --git a/src/mapleall/maple_me/include/code_factoring.h b/src/mapleall/maple_me/include/code_factoring.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa2772dbf68c166ad1ba081044c3c28c63296d0e
--- /dev/null
+++ b/src/mapleall/maple_me/include/code_factoring.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_CODE_FACTORING_H
+#define MAPLE_ME_INCLUDE_CODE_FACTORING_H
+#include "maple_phase_manager.h"
+
+namespace maple {
+MAPLE_FUNC_PHASE_DECLARE(MECodeFactoring, MeFunction)
+}  // namespace maple
+#endif // MAPLE_ME_INCLUDE_CODE_FACTORING_H
diff --git a/src/mapleall/maple_me/include/copy_prop.h b/src/mapleall/maple_me/include/copy_prop.h
new file mode 100644
index 0000000000000000000000000000000000000000..a607a09f9f2b1704706a61a93841735ba7a3f63a
--- /dev/null
+++ b/src/mapleall/maple_me/include/copy_prop.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_COPY_PROP_H
+#define MAPLE_ME_INCLUDE_COPY_PROP_H
+#include "prop.h"
+#include "me_irmap_build.h"
+#include "me_dominance.h"
+#include "me_loop_analysis.h"
+
+namespace maple {
+class CopyProp : public Prop {
+ public:
+  CopyProp(MeFunction *meFunc, MeExprUseInfo &ui, IdentifyLoops *loops, IRMap &irMap, Dominance &dom, Dominance &pdom,
+           MemPool &memPool, uint32 bbVecSize, const PropConfig &config)
+      : Prop(irMap, dom, pdom, memPool, bbVecSize, config),
+        func(meFunc), useInfo(ui), loopInfo(loops) {}
+  virtual ~CopyProp() = default;
+
+  void ReplaceSelfAssign();
+ private:
+  MeExpr &PropMeExpr(MeExpr &meExpr, bool &isproped, bool atParm) override;
+  void TraversalMeStmt(MeStmt &meStmt) override;
+  bool IsSingleUse(const MeExpr *expr);
+  void CheckLiveRange(const MeExpr &expr, int32 &badPropCnt);
+  bool CanPropSingleUse(const ScalarMeExpr &lhs, const MeExpr &rhs);
+
+  BB *GetBB(BBId id) override {
+    return func->GetCfg()->GetAllBBs()[id];
+  }
+
+  MeFunction *func;
+  uint32 cntOfPropedStmt = 0;
+  MeExprUseInfo &useInfo;
+  IdentifyLoops *loopInfo;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MECopyProp, MeFunction)
+} // namespace maple
+#endif  // MAPLE_ME_INCLUDE_COPY_PROP_H
diff --git a/src/mapleall/maple_me/include/demand_driven_alias_analysis.h b/src/mapleall/maple_me/include/demand_driven_alias_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0b70c329d5b082572a82fbff46504a9c863b590
--- /dev/null
+++ b/src/mapleall/maple_me/include/demand_driven_alias_analysis.h
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_DEMAND_DRIVEN_ALIAS_ANALYSIS_H
+#define MAPLE_ME_INCLUDE_DEMAND_DRIVEN_ALIAS_ANALYSIS_H
+#include <map>
+#include <vector>
+#include <bitset>
+#include <array>
+#include "me_function.h"
+#include "fstream"
+
+namespace maple {
+enum AliasAttribute {
+  kAliasAttrNotAllDefsSeen = 0, // var pointed to by ptr with unknown value
+  kAliasAttrGlobal = 1, // global var
+  kAliasAttrNextLevNotAllDefsSeen = 2, // ptr with unknown value
+  kAliasAttrFormal = 3, // ptr from formal
+  kAliasAttrEscaped = 4, // may val alias with unknown var
+  kEndOfAliasAttr
+};
+
+class PEGNode; // circular dependency exists, no other choice
+class PtrValueNode {
+ public:
+  PtrValueNode(PEGNode *node, OffsetType offset) : pegNode(node), offset(offset) {}
+  PtrValueNode() = default;
+  ~PtrValueNode() = default;
+
+  bool operator==(const PtrValueNode &other) const {
+    return pegNode == other.pegNode && offset == other.offset;
+  }
+
+  PEGNode *pegNode = nullptr;
+  OffsetType offset = OffsetType(0);
+};
+
+// node of program expresion graph
+using AliasAttr = std::bitset<kEndOfAliasAttr>;
+class PEGNode {
+ public:
+  explicit PEGNode(const VersionSt *vst) : vst(vst) {
+    if (vst->GetOst()->GetPrevLevelOst() != nullptr) {
+      multiDefed = true;
+    }
+  }
+  ~PEGNode() {
+    vst = nullptr;
+    prevLevNode = nullptr;
+  }
+
+  void SetPrevLevelNode(PEGNode *node) {
+    prevLevNode = node;
+  }
+
+  void AddNextLevelNode(PEGNode *node) {
+    const auto &it = std::find(nextLevNodes.begin(), nextLevNodes.end(), node);
+    if (it == nextLevNodes.end()) {
+      nextLevNodes.emplace_back(node);
+    }
+  }
+
+  void AddAssignFromNode(PEGNode *node, OffsetType offset) {
+    PtrValueNode assignFromNode(node, offset);
+    const auto &it = std::find(assignFrom.begin(), assignFrom.end(), assignFromNode);
+    if (it == assignFrom.end()) {
+      assignFrom.emplace_back(assignFromNode);
+    }
+  }
+
+  void AddAssignToNode(PEGNode *node, OffsetType offset) {
+    PtrValueNode assignToNode(node, offset);
+    const auto &it = std::find(assignTo.begin(), assignTo.end(), assignToNode);
+    if (it == assignTo.end()) {
+      assignTo.emplace_back(assignToNode);
+    }
+  }
+
+  void CopyAttrFromValueAliasedNode(const PEGNode *other) {
+    attr[kAliasAttrNextLevNotAllDefsSeen] =
+        attr[kAliasAttrNextLevNotAllDefsSeen] || other->attr[kAliasAttrNextLevNotAllDefsSeen];
+    attr[kAliasAttrEscaped] = attr[kAliasAttrEscaped] || other->attr[kAliasAttrEscaped];
+  }
+
+  void SetMultiDefined() {
+    multiDefed = true;
+  }
+
+  void Dump();
+
+  const VersionSt *vst;
+  AliasAttr attr = {0};
+  std::vector<PtrValueNode> assignFrom;
+  std::vector<PtrValueNode> assignTo;
+  PEGNode *prevLevNode = nullptr;
+  std::vector<PEGNode*> nextLevNodes;
+  bool multiDefed = false;
+  bool processed = false;
+};
+
+class ProgramExprGraph {
+ public:
+  ProgramExprGraph() = default;
+  ~ProgramExprGraph() {
+    allNodes.clear();
+  }
+
+  void AddAssignEdge(PEGNode *lhs, PEGNode *rhs, const OffsetType &offset) const {
+    lhs->AddAssignFromNode(rhs, offset);
+    rhs->AddAssignToNode(lhs, offset);
+  }
+
+  std::vector<std::unique_ptr<PEGNode>> &GetAllNodes() {
+    return allNodes;
+  }
+
+  PEGNode *GetOrCreateNodeOf(const VersionSt *vst);
+  PEGNode *GetNodeOf(const VersionSt *vst) const;
+  PEGNode *GetNodeOf(const OriginalSt *ost) const;
+  void Dump() const;
+
+ private:
+  std::vector<std::unique_ptr<PEGNode>> allNodes; // index is VersionSt index
+};
+
+class PEGBuilder {
+ public:
+  PEGBuilder(MeFunction *func, ProgramExprGraph *programExprGraph, SSATab *ssaTab)
+      : func(func), ssaTab(ssaTab), peg(programExprGraph) {}
+
+  ~PEGBuilder() {}
+
+  class PtrValueRecorder {
+   public:
+    PtrValueRecorder(PEGNode *node, FieldID id, OffsetType offset = OffsetType(0))
+        : pegNode(node), fieldId(id), offset(offset) {}
+    ~PtrValueRecorder() = default;
+
+    PEGNode *pegNode;
+    FieldID fieldId;
+    OffsetType offset;
+  };
+
+  PtrValueRecorder BuildPEGNodeOfExpr(const BaseNode *expr);
+  void AddAssignEdge(const StmtNode *stmt, PEGNode *lhsNode, PEGNode *rhsNode, OffsetType offset);
+  void BuildPEGNodeInStmt(const StmtNode *stmt);
+  void BuildPEGNodeInPhi(const PhiNode &phi);
+  void BuildPEG();
+
+ private:
+  void UpdateAttributes();
+  PtrValueRecorder BuildPEGNodeOfDread(const AddrofSSANode *dread);
+  PtrValueRecorder BuildPEGNodeOfAddrof(const AddrofSSANode *dread);
+  PtrValueRecorder BuildPEGNodeOfRegread(const RegreadSSANode *regread);
+  PtrValueRecorder BuildPEGNodeOfIread(const IreadSSANode *iread);
+  PtrValueRecorder BuildPEGNodeOfIaddrof(const IreadNode *iaddrof);
+  PtrValueRecorder BuildPEGNodeOfAdd(const BinaryNode *binaryNode);
+  PtrValueRecorder BuildPEGNodeOfArray(const ArrayNode *arrayNode);
+  PtrValueRecorder BuildPEGNodeOfSelect(const  TernaryNode* selectNode);
+  PtrValueRecorder BuildPEGNodeOfIntrisic(const IntrinsicopNode* intrinsicNode);
+
+  void BuildPEGNodeInAssign(const StmtNode *stmt);
+  void BuildPEGNodeInIassign(const IassignNode *iassign);
+  void BuildPEGNodeInDirectCall(const CallNode *call);
+  void BuildPEGNodeInIcall(const IcallNode *icall);
+  void BuildPEGNodeInVirtualcall(const NaryStmtNode *virtualCall);
+  void BuildPEGNodeInIntrinsicCall(const IntrinsiccallNode *intrinsiccall);
+
+  MeFunction *func;
+  SSATab *ssaTab = nullptr;
+  ProgramExprGraph *peg;
+};
+
+enum ReachState {
+  S1 = 0,
+  S2 = 1,
+  S3 = 2,
+  S4 = 3,
+};
+
+class ReachItem {
+ public:
+  ReachItem(PEGNode *src, ReachState state, OffsetType offset = OffsetType(0))
+      : src(src), state(state), offset(offset) {}
+  virtual ~ReachItem() = default;
+  bool operator<(const ReachItem &other) const {
+    return (src < other.src) && (state < other.state) && (offset < other.offset);
+  }
+
+  bool operator==(const ReachItem &other) const {
+    return (src == other.src) && (state == other.state) && (offset == other.offset);
+  }
+
+  PEGNode *src;
+  ReachState state;
+  OffsetType offset;
+};
+
+struct ReachItemComparator {
+  bool operator()(const ReachItem *itemA, const ReachItem *itemB) const {
+    if (itemA->src->vst->GetIndex() < itemB->src->vst->GetIndex()) {
+      return true;
+    } else if (itemA->src->vst->GetIndex() > itemB->src->vst->GetIndex()) {
+      return false;
+    }
+    return (itemA->state < itemB->state);
+  }
+};
+
+class WorkListItem {
+ public:
+  WorkListItem(PEGNode *to, PEGNode *src, ReachState state, OffsetType offset = OffsetType(0))
+      : to(to), srcItem(src, state, offset) {}
+  virtual ~WorkListItem() = default;
+  PEGNode *to;
+  ReachItem srcItem;
+};
+
+class DemandDrivenAliasAnalysis {
+ public:
+  DemandDrivenAliasAnalysis(MeFunction *fn, SSATab *ssaTab, MemPool *mp, bool debugDDAA)
+      : func(fn),
+        ssaTab(ssaTab),
+        tmpMP(mp),
+        tmpAlloc(tmpMP),
+        reachNodes(tmpAlloc.Adapter()),
+        aliasSets(tmpAlloc.Adapter()),
+        enableDebug(debugDDAA) {
+    BuildPEG();
+  }
+
+  ~DemandDrivenAliasAnalysis() = default;
+
+  using WorkListType = std::list<WorkListItem>;
+  bool MayAlias(PEGNode *to, PEGNode *src);
+  bool MayAlias(OriginalSt *ostA, OriginalSt *ostB);
+
+  void BuildPEG() {
+    PEGBuilder builder(func, &peg, ssaTab);
+    builder.BuildPEG();
+    if (enableDebug) {
+      peg.Dump();
+    }
+  }
+
+ private:
+  MapleSet<ReachItem*, ReachItemComparator> *ReachSetOf(PEGNode *node);
+  std::pair<bool, ReachItem*> AddReachNode(PEGNode *to, PEGNode *src, ReachState state, OffsetType offset);
+  void Propagate(WorkListType &workList, PEGNode *to, const ReachItem &reachItem, bool selfProp = false);
+  void UpdateAliasInfoOfPegNode(PEGNode *pegNode);
+  MapleSet<OriginalSt*> *AliasSetOf(OriginalSt *ost);
+  void AddAlias(OriginalSt *ostA, OriginalSt *ostB) {
+    AliasSetOf(ostA)->insert(ostB);
+    AliasSetOf(ostB)->insert(ostA);
+  }
+
+  bool AliasBasedOnAliasAttr(PEGNode *to, PEGNode *src) const;
+  PEGNode *GetPrevLevPEGNode(PEGNode *pegNode) const {
+    CHECK_FATAL(pegNode != nullptr, "null ptr check");
+    return pegNode->prevLevNode;
+  }
+
+  MeFunction *func;
+  SSATab *ssaTab;
+  MemPool *tmpMP;
+  MapleAllocator tmpAlloc;
+  MapleMap<PEGNode *, MapleSet<ReachItem *, ReachItemComparator> *> reachNodes;
+  MapleMap<OriginalSt *, MapleSet<OriginalSt *> *> aliasSets; // ost in MapleSet memory-alias with the key ost
+  ProgramExprGraph peg;
+  bool enableDebug;
+};
+} // namespace maple
+#endif // MAPLE_ME_INCLUDE_DEMAND_DRIVEN_ALIAS_ANALYSIS_H
diff --git a/src/mapleall/maple_me/include/dse.h b/src/mapleall/maple_me/include/dse.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6ccc18eb8d5258d17e3ade776079a86f647ea47
--- /dev/null
+++ b/src/mapleall/maple_me/include/dse.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_DSE_H
+#define MAPLE_ME_INCLUDE_DSE_H
+#include <unordered_set>
+#include "bb.h"
+#include "dominance.h"
+#include "ssa_mir_nodes.h"
+#include "me_ir.h"
+#include "safe_ptr.h"
+#include "ssa_tab.h"
+#include "mir_module.h"
+#include "alias_class.h"
+
+namespace maple {
+class DSE {
+ public:
+  DSE(std::vector<BB*> &&bbVec, BB &commonEntryBB, BB &commonExitBB, SSATab &ssaTab, Dominance &dom, Dominance &postDom,
+      const AliasClass *aliasClass, bool enableDebug = false, bool decouple = false, bool islfo = false)
+      : enableDebug(enableDebug),
+        bbVec(bbVec), commonEntryBB(commonEntryBB),
+        commonExitBB(commonExitBB), ssaTab(ssaTab),
+        dom(dom),
+        postDom(postDom),
+        aliasInfo(aliasClass),
+        bbRequired(bbVec.size(), false),
+        exprRequired(ssaTab.GetVersionStTableSize(), false),
+        decoupleStatic(decouple), isLfo(islfo) {}
+
+  ~DSE() = default;
+
+  void DoDSE();
+  bool UpdatedCfg() const {
+    return cfgUpdated;
+  }
+
+ protected:
+  bool enableDebug = false;
+  bool IsSymbolLived(const VersionSt &symbol) const {
+    return exprRequired[symbol.GetIndex()];
+  }
+
+ private:
+  // step 1: init, all stmts are not needed, all symbols are not alive
+  void Init();
+
+  // step 2: mark special stmt required
+  void MarkSpecialStmtRequired();
+  void MarkStmtRequired(const StmtNode &stmt, const BB &bb);
+  void MarkControlDependenceLive(const BB &bb);
+  void MarkLastBranchStmtInBBRequired(const BB &bb);
+  void MarkLastBranchStmtInPDomBBRequired(const BB &bb);
+  void MarkLastBranchStmtInPredBBRequired(const BB &bb);
+
+  // step 3: mark stmt use live
+  void MarkStmtUseLive(const StmtNode &stmt);
+  void MarkSingleUseLive(const BaseNode &mirNode);
+
+  // step 4: propagate live
+  void PropagateLive() {
+    while (!workList.empty()) {
+      auto vst = workList.front();
+      workList.pop_front();
+      PropagateUseLive(*vst);
+    }
+  }
+  void PropagateUseLive(const VersionSt &vst);
+
+  // step 5: remove not requried stmts
+  void RemoveNotRequiredStmts() {
+    for (auto bIt = bbVec.begin(); bIt != bbVec.end(); ++bIt) {
+      auto *bb = *bIt;
+      if (bb == nullptr) {
+        continue;
+      }
+      RemoveNotRequiredStmtsInBB(*bb);
+    }
+  }
+
+  void RemoveNotRequiredStmtsInBB(BB &bb);
+  void OnRemoveBranchStmt(BB &bb, const StmtNode &stmt);
+  bool IsCallReturnRemovable(const StmtNode &stmt);
+  void CheckRemoveCallAssignedReturn(StmtNode &stmt);
+
+  bool IsStmtRequired(const StmtNode &stmt) const {
+    return stmt.GetIsLive();
+  }
+  void SetStmtRequired(const StmtNode &stmt) const {
+    stmt.SetIsLive(true);
+  }
+
+  void SetSymbolLived(const VersionSt &symbol) {
+    exprRequired[symbol.GetIndex()] = true;
+  }
+
+  void AddToWorkList(const VersionSt *symbol) {
+    workList.push_front(symbol);
+  }
+
+  bool ExprHasSideEffect(const BaseNode &expr) const;
+  bool ExprNonDeletable(const BaseNode &expr) const;
+  bool HasNonDeletableExpr(const StmtNode &stmt) const;
+  bool StmtMustRequired(const StmtNode &stmt, const BB &bb) const;
+  void DumpStmt(const StmtNode &stmt, const std::string &msg) const;
+  void CollectNotNullNode(StmtNode &stmt, BB &bb);
+  // NotNullNode means it is impossible value of the node is nullptr after go through this stmt.
+  // nodeType must be one kind of kNodeTypeNormal、kNodeTypeIvar、kNodeTypeNotNull
+  void CollectNotNullNode(StmtNode &stmt, BaseNode &node, BB &bb, uint8 nodeType = 0);
+  bool NeedNotNullCheck(BaseNode &node, const BB &bb);
+
+  std::vector<BB*> bbVec;
+  BB &commonEntryBB;
+  BB &commonExitBB;
+  SSATab &ssaTab;
+  Dominance &dom;
+  Dominance &postDom;
+  const AliasClass *aliasInfo;
+  std::vector<bool> bbRequired;
+  std::vector<bool> exprRequired;
+  std::forward_list<const VersionSt*> workList{};
+  std::unordered_map<StmtNode*, std::vector<BaseNode*>> stmt2NotNullExpr;
+  std::unordered_map<BaseNode*, std::vector<std::pair<StmtNode*, BB*>>> notNullExpr2Stmt;
+  bool cfgUpdated = false;
+  // Initial type of all nodes
+  static const uint8 kNodeTypeNormal = 0;
+  // IreadNode
+  static const uint8 kNodeTypeIvar = 1;
+  // NPE will be throw if the value of this node is nullptr when stmt is executed
+  // Or the node is opnd of a same type node
+  static const uint8 kNodeTypeNotNull = 2;
+  bool decoupleStatic = false;
+  bool isLfo = false;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_DSE_H
diff --git a/src/mapleall/maple_me/include/func_emit.h b/src/mapleall/maple_me/include/func_emit.h
new file mode 100644
index 0000000000000000000000000000000000000000..97936806031c92a7ac535acbb625e5a90b5a09ef
--- /dev/null
+++ b/src/mapleall/maple_me/include/func_emit.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_FUNC_EMIT_H
+#define MAPLE_ME_INCLUDE_FUNC_EMIT_H
+#include "bb.h"
+
+// Provide emit service for both MeFunction and WpoFunction.
+namespace maple {
+class FuncEmit {
+ public:
+  void EmitBeforeHSSA(MIRFunction &func, const MapleVector<BB*> &bbList) const;
+  virtual ~FuncEmit() = default;
+
+ private:
+  void EmitLabelForBB(MIRFunction &func, BB &bb) const;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_FUNC_EMIT_H
diff --git a/src/mapleall/maple_me/include/hdse.h b/src/mapleall/maple_me/include/hdse.h
new file mode 100644
index 0000000000000000000000000000000000000000..f19dc0ab78fff1375e838214765fecba980ac534
--- /dev/null
+++ b/src/mapleall/maple_me/include/hdse.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_HDSE_H
+#define MAPLE_ME_INCLUDE_HDSE_H
+#include "alias_class.h"
+#include "bb.h"
+#include "dominance.h"
+#include "irmap.h"
+
+namespace maple {
+class MeIRMap;
+class HDSE {
+ public:
+  HDSE(MIRModule &mod, const MapleVector<BB*> &bbVec, BB &commonEntryBB, BB &commonExitBB, Dominance &dom,
+       Dominance &pdom, IRMap &map, const AliasClass *aliasClass, bool enabledDebug = false, bool decouple = false)
+      : hdseDebug(enabledDebug),
+        mirModule(mod),
+        bbVec(bbVec),
+        commonEntryBB(commonEntryBB),
+        commonExitBB(commonExitBB),
+        dom(dom),
+        postDom(pdom),
+        irMap(map),
+        aliasInfo(aliasClass),
+        bbRequired(bbVec.size(), false, irMap.GetIRMapAlloc().Adapter()),
+        exprLive(irMap.GetIRMapAlloc().Adapter()),
+        decoupleStatic(decouple),
+        verstUseCounts(irMap.GetIRMapAlloc().Adapter()) {}
+
+  virtual ~HDSE() = default;
+
+  void DoHDSE();
+  void InvokeHDSEUpdateLive();
+  bool NeedUNClean() const {
+    return needUNClean;
+  }
+  void SetRemoveRedefine(bool val) {
+    removeRedefine = val;
+  }
+  void SetUpdateFreq(bool update) {
+    updateFreq = update;
+  }
+  bool UpdateFreq() {
+    return updateFreq;
+  }
+
+  bool hdseDebug;
+  bool hdseKeepRef = false;
+
+ protected:
+  MIRModule &mirModule;
+  MapleVector<BB*> bbVec;
+  BB &commonEntryBB;
+  BB &commonExitBB;
+  Dominance &dom;
+  Dominance &postDom;
+  IRMap &irMap;
+  const AliasClass *aliasInfo;
+  MapleVector<bool> bbRequired;
+  MapleVector<bool> exprLive;
+  std::forward_list<MeExpr*> workList;
+  std::unordered_map<MeStmt*, std::vector<MeExpr*>> stmt2NotNullExpr;
+  std::unordered_map<MeExpr*, std::vector<MeStmt*>> notNullExpr2Stmt;
+  // Initial type of all meExpr
+  static const uint8 kExprTypeNormal = 0;
+  // IreadMeExpr
+  static const uint8 kExprTypeIvar = 1;
+  // NPE will be throw if the value of this meExpr is nullptr when stmt is executed
+  // Or the meExpr is opnd of a same type meExpr
+  static const uint8 kExprTypeNotNull = 2;
+  bool decoupleStatic = false;
+  bool needUNClean = false;     // used to record if there's unreachable BB
+  bool removeRedefine = false;  // used to control if run ResolveContinuousRedefine()
+  bool updateFreq = false;
+  MapleVector<uint32> verstUseCounts;                // index is vstIdx
+  std::forward_list<DassignMeStmt*> backSubsCands;  // backward substitution candidates
+
+ private:
+  void DseInit();
+  void MarkSpecialStmtRequired();
+  void PropagateUseLive(MeExpr &meExpr);
+  void DetermineUseCounts(MeExpr *x);
+  void CheckBackSubsCandidacy(DassignMeStmt *dass);
+  void UpdateChiUse(MeStmt *stmt);
+  void RemoveNotRequiredStmtsInBB(BB &bb);
+  template <class VarOrRegPhiNode>
+  void MarkPhiRequired(VarOrRegPhiNode &mePhiNode);
+  void MarkMuListRequired(MapleMap<OStIdx, ScalarMeExpr*> &muList);
+  void MarkChiNodeRequired(ChiMeNode &chiNode);
+  void TraverseChiNodeKilled(ChiMeNode &chiNode);
+  bool ExprHasSideEffect(const MeExpr &meExpr) const;
+  bool ExprNonDeletable(const MeExpr &meExpr) const;
+  bool StmtMustRequired(const MeStmt &meStmt, const BB &bb) const;
+  void MarkStmtRequired(MeStmt &meStmt);
+  bool HasNonDeletableExpr(const MeStmt &meStmt) const;
+  void MarkStmtUseLive(MeStmt &meStmt);
+  void MarkSingleUseLive(MeExpr &meExpr);
+  void MarkControlDependenceLive(BB &bb);
+  void MarkLastBranchStmtInBBRequired(BB &bb);
+  void MarkLastStmtInPDomBBRequired(const BB &bb);
+  void MarkLastBranchStmtInPredBBRequired(const BB &bb);
+  void MarkVarDefByStmt(VarMeExpr &varMeExpr);
+  void MarkRegDefByStmt(RegMeExpr &regMeExpr);
+  bool RealUse(MeExpr &expr, MeStmt &assign);
+  void ResolveReassign(MeStmt &assign);
+  void ResolveContinuousRedefine();
+  void CollectNotNullExpr(MeStmt &stmt);
+  // NotNullExpr means it is impossible value of the expr is nullptr after go through this stmt.
+  // exprType must be one kind of NODE_TYPE_NORMAL、NODE_TYPE_IVAR、NODE_TYPE_NOTNULL
+  void CollectNotNullExpr(MeStmt &stmt, MeExpr &meExpr, uint8 exprType = 0);
+  bool NeedNotNullCheck(MeExpr &meExpr, const BB &bb);
+
+  bool IsExprNeeded(const MeExpr &meExpr) const {
+    return exprLive.at(static_cast<size_t>(static_cast<uint32>(meExpr.GetExprID())));
+  }
+  void SetExprNeeded(const MeExpr &meExpr) {
+    exprLive.at(static_cast<size_t>(static_cast<uint32>(meExpr.GetExprID()))) = true;
+  }
+
+  void PropagateLive() {
+    while (!workList.empty()) {
+      MeExpr *meExpr = workList.front();
+      workList.pop_front();
+      PropagateUseLive(*meExpr);
+    }
+  }
+
+  void RemoveNotRequiredStmts() {
+    for (auto *bb : bbVec) {
+      if (bb == nullptr) {
+        continue;
+      }
+      RemoveNotRequiredStmtsInBB(*bb);
+    }
+  }
+  virtual bool IsLfo() {
+    return false;
+  }
+  virtual void ProcessWhileInfos() {}
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_HDSE_H
diff --git a/src/mapleall/maple_me/include/irmap.h b/src/mapleall/maple_me/include/irmap.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ea8b8c694bab0e387d5a509f32acf3deb80adb3
--- /dev/null
+++ b/src/mapleall/maple_me/include/irmap.h
@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_IRMAP_H
+#define MAPLE_ME_INCLUDE_IRMAP_H
+#include "bb.h"
+#include "ver_symbol.h"
+#include "ssa_tab.h"
+#include "me_ir.h"
+#include "meexpr_use_info.h"
+
+namespace maple {
+class IRMapBuild; // circular dependency exists, no other choice
+
+class IRMap : public AnalysisResult {
+  friend IRMapBuild;
+ public:
+  IRMap(SSATab &ssaTab, MemPool &memPool, uint32 hashTableSize)
+      : AnalysisResult(&memPool),
+        ssaTab(ssaTab),
+        mirModule(ssaTab.GetModule()),
+        irMapAlloc(&memPool),
+        mapHashLength(hashTableSize),
+        hashTable(mapHashLength, nullptr, irMapAlloc.Adapter()),
+        verst2MeExprTable(ssaTab.GetVersionStTableSize(), nullptr, irMapAlloc.Adapter()),
+        lpreTmps(irMapAlloc.Adapter()),
+        vst2Decrefs(irMapAlloc.Adapter()),
+        exprUseInfo(&memPool) {}
+
+  virtual ~IRMap() = default;
+  virtual BB *GetBB(BBId id) = 0;
+  virtual BB *GetBBForLabIdx(LabelIdx lidx, PUIdx pidx = 0) = 0;
+  MeExpr *HashMeExpr(MeExpr &meExpr);
+  IvarMeExpr *BuildLHSIvarFromIassMeStmt(IassignMeStmt &iassignMeStmt);
+  IvarMeExpr *BuildLHSIvar(MeExpr &baseAddr, PrimType primType, const TyIdx &tyIdx, FieldID fieldID);
+  IvarMeExpr *BuildLHSIvar(MeExpr &baseAddr, IassignMeStmt &iassignMeStmt, FieldID fieldID);
+  MeExpr *CreateAddrofMeExpr(MeExpr&);
+  MeExpr *CreateAddroffuncMeExpr(PUIdx);
+  MeExpr *CreateAddrofMeExprFromSymbol(MIRSymbol& sym, PUIdx  puIdx);
+  MeExpr *CreateIaddrofMeExpr(FieldID fieldId, TyIdx tyIdx, MeExpr *base);
+  MeExpr *CreateIvarMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base);
+  NaryMeExpr *CreateNaryMeExpr(const NaryMeExpr &nMeExpr);
+
+  // for creating VarMeExpr
+  VarMeExpr *CreateVarMeExprVersion(OriginalSt *ost);
+  VarMeExpr *CreateVarMeExprVersion(const VarMeExpr &varx) {
+    return CreateVarMeExprVersion(varx.GetOst());
+  }
+  RegMeExpr *CreateRegRefMeExpr(const MeExpr &meExpr);
+  VarMeExpr *GetOrCreateZeroVersionVarMeExpr(OriginalSt &ost);
+  VarMeExpr *CreateNewVar(GStrIdx strIdx, PrimType primType, bool isGlobal);
+  VarMeExpr *CreateNewLocalRefVarTmp(GStrIdx strIdx, TyIdx tIdx);
+
+  // for creating RegMeExpr
+  RegMeExpr *CreateRegMeExprVersion(OriginalSt&);
+  RegMeExpr *CreateRegMeExprVersion(const RegMeExpr &regx) {
+    return CreateRegMeExprVersion(*regx.GetOst());
+  }
+
+  ScalarMeExpr *CreateRegOrVarMeExprVersion(OStIdx ostIdx);
+  RegMeExpr *CreateRegMeExpr(PrimType);
+  RegMeExpr *CreateRegMeExpr(MIRType&);
+  RegMeExpr *CreateRegMeExpr(const MeExpr &meexpr) {
+    MIRType *mirType = meexpr.GetType();
+    if (mirType == nullptr || mirType->GetPrimType() == PTY_agg) {
+      return CreateRegMeExpr(meexpr.GetPrimType());
+    }
+    if (meexpr.GetMeOp() == kMeOpIvar && mirType->GetPrimType() != PTY_ref) {
+      return CreateRegMeExpr(meexpr.GetPrimType());
+    }
+    return CreateRegMeExpr(*mirType);
+  }
+
+  MeExpr *ReplaceMeExprExpr(MeExpr&, const MeExpr&, MeExpr&);
+  bool ReplaceMeExprStmt(MeStmt&, const MeExpr&, MeExpr&);
+  MeExpr *GetMeExprByVerID(uint32 verid) const {
+    return verst2MeExprTable[verid];
+  }
+
+  MeExpr *GetMeExpr(size_t index) {
+    ASSERT(index < verst2MeExprTable.size(), "index out of range");
+    MeExpr *meExpr = verst2MeExprTable.at(index);
+    if (meExpr == nullptr || !meExpr->IsScalar()) {
+      return nullptr;
+    }
+    return meExpr;
+  }
+
+  IassignMeStmt *CreateIassignMeStmt(TyIdx, IvarMeExpr&, MeExpr&, const MapleMap<OStIdx, ChiMeNode*>&);
+  AssignMeStmt *CreateAssignMeStmt(ScalarMeExpr&, MeExpr&, BB&);
+  void InsertMeStmtBefore(BB&, MeStmt&, MeStmt&);
+  MePhiNode *CreateMePhi(ScalarMeExpr&);
+
+  void DumpBB(const BB &bb) {
+    int i = 0;
+    for (const auto &meStmt : bb.GetMeStmts()) {
+      if (GetDumpStmtNum()) {
+        LogInfo::MapleLogger() << "(" << i++ << ") ";
+      }
+      meStmt.Dump(this);
+    }
+  }
+
+  virtual void Dump() = 0;
+  virtual void SetCurFunction(const BB&) {}
+
+  MeExpr *CreateIntConstMeExpr(const IntVal &value, PrimType pType);
+  MeExpr *CreateIntConstMeExpr(int64, PrimType);
+  MeExpr *CreateConstMeExpr(PrimType, MIRConst&);
+  MeExpr *CreateMeExprUnary(Opcode, PrimType, MeExpr&);
+  MeExpr *CreateMeExprBinary(Opcode, PrimType, MeExpr&, MeExpr&);
+  MeExpr *CreateMeExprCompare(Opcode, PrimType, PrimType, MeExpr&, MeExpr&);
+  MeExpr *CreateMeExprSelect(PrimType, MeExpr&, MeExpr&, MeExpr&);
+  MeExpr *CreateMeExprTypeCvt(PrimType, PrimType, MeExpr&);
+  MeExpr *CreateMeExprRetype(PrimType, TyIdx, MeExpr&);
+  MeExpr *CreateMeExprExt(Opcode, PrimType, uint32, MeExpr&);
+  UnaryMeStmt *CreateUnaryMeStmt(Opcode op, MeExpr *opnd);
+  UnaryMeStmt *CreateUnaryMeStmt(Opcode op, MeExpr *opnd, BB *bb, const SrcPosition *src);
+  RetMeStmt *CreateRetMeStmt(MeExpr *opnd);
+  GotoMeStmt *CreateGotoMeStmt(uint32 offset, BB *bb, const SrcPosition *src = nullptr);
+  IntrinsiccallMeStmt *CreateIntrinsicCallMeStmt(MIRIntrinsicID idx, std::vector<MeExpr*> &opnds,
+                                                 TyIdx tyIdx = TyIdx());
+  IntrinsiccallMeStmt *CreateIntrinsicCallAssignedMeStmt(MIRIntrinsicID idx, std::vector<MeExpr*> &opnds,
+                                                         ScalarMeExpr *ret, TyIdx tyIdx = TyIdx());
+  MeExpr *CreateCanonicalizedMeExpr(PrimType primType, Opcode opA,  Opcode opB,
+                                    MeExpr *opndA, MeExpr *opndB, MeExpr *opndC);
+  MeExpr *CreateCanonicalizedMeExpr(PrimType primType, Opcode opA, MeExpr *opndA,
+                                    Opcode opB, MeExpr *opndB, MeExpr *opndC);
+  MeExpr *CreateCanonicalizedMeExpr(PrimType primType, Opcode opA, Opcode opB, MeExpr *opndA, MeExpr *opndB,
+                                    Opcode opC, MeExpr *opndC, MeExpr *opndD);
+  MeExpr *FoldConstExprBinary(PrimType primType, Opcode op, ConstMeExpr &opndA, ConstMeExpr &opndB);
+  MeExpr *FoldConstExprUnary(PrimType primType, Opcode op, ConstMeExpr &opnd);
+  MeExpr *SimplifyBandExpr(const OpMeExpr *bandExpr);
+  MeExpr *SimplifyLshrExpr(const OpMeExpr *shrExpr);
+  MeExpr *SimplifyShlExpr(const OpMeExpr *shrExpr);
+  MeExpr *SimplifySubExpr(const OpMeExpr *subExpr);
+  MeExpr *SimplifyAddExpr(const OpMeExpr *addExpr);
+  MeExpr *SimplifyMulExpr(const OpMeExpr *mulExpr);
+  MeExpr *SimplifyCmpExpr(OpMeExpr *cmpExpr);
+  MeExpr *SimplifySelExpr(OpMeExpr *selExpr);
+  MeExpr *SimplifyOpMeExpr(OpMeExpr *opmeexpr);
+  MeExpr *SimplifyOrMeExpr(OpMeExpr *opmeexpr);
+  MeExpr *SimplifyAshrMeExpr(OpMeExpr *opmeexpr);
+  MeExpr *SimplifyXorMeExpr(OpMeExpr *opmeexpr);
+  MeExpr *SimplifyDepositbits(const OpMeExpr &opmeexpr);
+  MeExpr *SimplifyExtractbits(const OpMeExpr &opmeexpr);
+  MeExpr *SimplifyMeExpr(MeExpr *x);
+  void SimplifyCastForAssign(MeStmt *assignStmt);
+  void SimplifyAssign(AssignMeStmt *assignStmt);
+  MeExpr *SimplifyCast(MeExpr *expr);
+  MeExpr* SimplifyIvarWithConstOffset(IvarMeExpr *ivar, bool lhsIvar);
+  MeExpr *SimplifyIvarWithAddrofBase(IvarMeExpr *ivar);
+  MeExpr *GetSimplifiedVarForIvarWithAddrofBase(OriginalSt &ost, IvarMeExpr &ivar);
+  MeExpr *SimplifyIvarWithIaddrofBase(IvarMeExpr *ivar, bool lhsIvar);
+  MeExpr *SimplifyIvar(IvarMeExpr *ivar, bool lhsIvar);
+  void UpdateIncDecAttr(MeStmt &meStmt);
+  static MIRType *GetArrayElemType(const MeExpr &opnd);
+
+  template <class T, typename... Arguments>
+  T *NewInPool(Arguments&&... args) {
+    return irMapAlloc.GetMemPool()->New<T>(&irMapAlloc, std::forward<Arguments>(args)...);
+  }
+
+  template <class T, typename... Arguments>
+  T *New(Arguments&&... args) {
+    return irMapAlloc.GetMemPool()->New<T>(std::forward<Arguments>(args)...);
+  }
+
+  SSATab &GetSSATab() {
+    return ssaTab;
+  }
+
+  const SSATab &GetSSATab() const {
+    return ssaTab;
+  }
+
+  MIRModule &GetMIRModule() {
+    return mirModule;
+  }
+
+  const MIRModule &GetMIRModule() const {
+    return mirModule;
+  }
+
+  MapleAllocator &GetIRMapAlloc() {
+    return irMapAlloc;
+  }
+
+  int32 GetExprID() const {
+    return exprID;
+  }
+
+  void SetExprID(int32 id) {
+    exprID = id;
+  }
+
+  MapleVector<MeExpr*> &GetVerst2MeExprTable() {
+    return verst2MeExprTable;
+  }
+
+  MeExpr *GetVerst2MeExprTableItem(uint32 i) const {
+    if (i >= verst2MeExprTable.size()) {
+      return nullptr;
+    }
+    return verst2MeExprTable[i];
+  }
+
+  void SetVerst2MeExprTableItem(uint32 i, MeExpr *expr) {
+    verst2MeExprTable[i] = expr;
+  }
+
+  MapleUnorderedMap<OStIdx, RegMeExpr*>::iterator GetLpreTmpsEnd() {
+    return lpreTmps.end();
+  }
+
+  MapleUnorderedMap<OStIdx, RegMeExpr*>::iterator FindLpreTmpsItem(OStIdx idx) {
+    return lpreTmps.find(idx);
+  }
+
+  void SetLpreTmps(OStIdx idx, RegMeExpr &expr) {
+    lpreTmps[idx] = &expr;
+  }
+
+  MapleUnorderedMap<VarMeExpr*, MapleSet<MeStmt*>*> &GetVerst2DecrefsMap() {
+    return vst2Decrefs;
+  }
+
+  MapleUnorderedMap<VarMeExpr*, MapleSet<MeStmt*>*>::iterator GetDecrefsEnd() {
+    return vst2Decrefs.end();
+  }
+
+  MapleUnorderedMap<VarMeExpr*, MapleSet<MeStmt*>*>::iterator FindDecrefItem(VarMeExpr &var) {
+    return vst2Decrefs.find(&var);
+  }
+
+  void SetDecrefs(VarMeExpr &var, MapleSet<MeStmt*> &set) {
+    vst2Decrefs[&var] = &set;
+  }
+
+  void SetNeedAnotherPass(bool need) {
+    needAnotherPass = need;
+  }
+
+  bool GetNeedAnotherPass() const {
+    return needAnotherPass;
+  }
+
+  bool GetDumpStmtNum() const {
+    return dumpStmtNum;
+  }
+
+  void SetDumpStmtNum(bool num) {
+    dumpStmtNum = num;
+  }
+  const MeExprUseInfo &GetExprUseInfo() const {
+    return exprUseInfo;
+  }
+
+  MeExprUseInfo &GetExprUseInfo() {
+    return exprUseInfo;
+  }
+
+ private:
+  SSATab &ssaTab;
+  MIRModule &mirModule;
+  MapleAllocator irMapAlloc;
+  int32 exprID = 0;                                // for allocating exprid_ in MeExpr
+  uint32 mapHashLength;                            // size of hashTable
+  MapleVector<MeExpr*> hashTable;                  // the value number hash table
+  MapleVector<MeExpr*> verst2MeExprTable;          // map versionst to MeExpr.
+  MapleUnorderedMap<OStIdx, RegMeExpr*> lpreTmps;  // for passing LPRE's temp usage to SPRE
+  MapleUnorderedMap<VarMeExpr*, MapleSet<MeStmt*>*> vst2Decrefs;  // map versionst to decrefreset.
+  MeExprUseInfo exprUseInfo;
+  bool needAnotherPass = false;                    // set to true if CFG has changed
+  bool dumpStmtNum = false;
+  BB *curBB = nullptr;  // current maple_me::BB being visited
+
+  bool ReplaceMeExprStmtOpnd(uint32, MeStmt&, const MeExpr&, MeExpr&);
+  void PutToBucket(uint32, MeExpr&);
+  const BB *GetFalseBrBB(const CondGotoMeStmt&);
+  MeExpr *ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize, const MeExpr &meExpr, MeExpr &repExpr);
+  MeExpr *SimplifyCompareSameExpr(OpMeExpr *opmeexpr);
+  bool IfMeExprIsU1Type(const MeExpr *expr) const;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_IRMAP_H
diff --git a/src/mapleall/maple_me/include/irmap_build.h b/src/mapleall/maple_me/include/irmap_build.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d300b8c56762027bfc53f3ebe4870d5c3039a74
--- /dev/null
+++ b/src/mapleall/maple_me/include/irmap_build.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_IRMAP_BUILD_H
+#define MAPLE_ME_INCLUDE_IRMAP_BUILD_H
+#include "irmap.h"
+#include "dominance.h"
+
+namespace maple {
+class Prop; // circular dependency exists, no other choice
+
+// This class contains methods to convert Maple IR to MeIR.
+class IRMapBuild {
+ public:
+  IRMapBuild(IRMap *hmap, Dominance *dom, Prop *prop)
+      : irMap(hmap),
+        mirModule(hmap->GetMIRModule()),
+        ssaTab(irMap->GetSSATab()),
+        dominance(*dom),
+        curBB(nullptr),
+        propagater(prop) {
+    InitMeExprBuildFactory();
+    InitMeStmtFactory();
+  }
+  ~IRMapBuild() {}
+  void BuildBB(BB &bb, std::vector<bool> &bbIRMapProcessed);
+
+ private:
+  VarMeExpr *GetOrCreateVarFromVerSt(const VersionSt &vst);
+  RegMeExpr *GetOrCreateRegFromVerSt(const VersionSt &vst);
+
+  MeExpr *BuildLHSVar(const VersionSt &vst, DassignMeStmt &defMeStmt);
+  MeExpr *BuildLHSReg(const VersionSt &vst, AssignMeStmt &defMeStmt, const RegassignNode &regassign);
+  void BuildChiList(MeStmt&, TypeOfMayDefList&, MapleMap<OStIdx, ChiMeNode*>&);
+  void BuildMustDefList(MeStmt &meStmt, TypeOfMustDefList&, MapleVector<MustDefMeNode>&);
+  void BuildMuList(TypeOfMayUseList&, MapleMap<OStIdx, ScalarMeExpr*>&);
+  void BuildPhiMeNode(BB&);
+  void SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode, bool atparm, bool noProp);
+
+  std::unique_ptr<OpMeExpr> BuildOpMeExpr(const BaseNode &mirNode) const {
+    auto meExpr = std::make_unique<OpMeExpr>(kInvalidExprID, mirNode.GetOpCode(),
+                                             mirNode.GetPrimType(), mirNode.GetNumOpnds());
+    return meExpr;
+  }
+
+  std::unique_ptr<MeExpr> BuildAddrofMeExpr(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildAddroffuncMeExpr(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildAddroflabelMeExpr(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildGCMallocMeExpr(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildSizeoftypeMeExpr(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildFieldsDistMeExpr(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildIvarMeExpr(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildConstMeExpr(BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildConststrMeExpr(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildConststr16MeExpr(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildOpMeExprForCompare(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildOpMeExprForTypeCvt(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildOpMeExprForRetype(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildOpMeExprForIread(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildOpMeExprForExtractbits(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildOpMeExprForDepositbits(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildOpMeExprForJarrayMalloc(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildOpMeExprForResolveFunc(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildNaryMeExprForArray(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildNaryMeExprForIntrinsicop(const BaseNode &mirNode) const;
+  std::unique_ptr<MeExpr> BuildNaryMeExprForIntrinsicWithType(const BaseNode &mirNode) const;
+  MeExpr *BuildExpr(BaseNode&, bool atParm, bool noProp);
+  static void InitMeExprBuildFactory();
+
+  MeStmt *BuildMeStmtWithNoSSAPart(StmtNode &stmt);
+  MeStmt *BuildDassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildAssignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildMaydassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildCallMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildNaryMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildRetMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildWithMuMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildAsmMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart);
+  MeStmt *BuildMeStmt(StmtNode&);
+  static void InitMeStmtFactory();
+
+  IRMap *irMap;
+  MIRModule &mirModule;
+  SSATab &ssaTab;
+  Dominance &dominance;
+  BB *curBB;  // current mapleme::BB being visited
+  Prop *propagater;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_IRMAP_BUILD_H
diff --git a/src/mapleall/maple_me/include/lfo_dep_test.h b/src/mapleall/maple_me/include/lfo_dep_test.h
new file mode 100644
index 0000000000000000000000000000000000000000..38f5e941666c00a47a9f0ba74fe4f9464df31809
--- /dev/null
+++ b/src/mapleall/maple_me/include/lfo_dep_test.h
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_LFO_DEP_TETS_H
+#define MAPLE_ME_INCLUDE_LFO_DEP_TETS_H
+
+#include "pme_function.h"
+#include "pme_emit.h"
+#include "orig_symbol.h"
+#include "maple_phase.h"
+#include "me_ir.h"
+#include "me_dominance.h"
+
+namespace maple {
+class LfoDepInfo;
+
+class SubscriptDesc {
+ public:
+  MeExpr *subscriptX;
+  DreadNode *iv = nullptr;      // the induction variable
+  int64 coeff = 1;              // coefficient of the variable
+  int64 additiveConst = 0;
+  BaseNode *additiveLoopInvar = nullptr;
+  bool tooMessy = false;;       // too complicated to analyze
+  bool loopInvariant = false;   // loop invariant w.r.t. closest nesting loop
+
+  explicit SubscriptDesc(MeExpr *x) : subscriptX(x) {}
+  virtual ~SubscriptDesc() = default;
+};
+
+class ArrayAccessDesc {
+ public:
+  ArrayNode *theArray;
+  MapleSet<OStIdx> *arrayOstIdxSet = nullptr; // if null, array base is an invariant expression
+  MapleVector<SubscriptDesc *> subscriptVec;  // describe the subscript of each array dimension
+
+  ArrayAccessDesc(MapleAllocator *alloc, ArrayNode *arr, MapleSet<OStIdx> *arryOstSet)
+      : theArray(arr),
+        arrayOstIdxSet(arryOstSet),
+        subscriptVec(alloc->Adapter()) {}
+  virtual ~ArrayAccessDesc() = default;
+};
+
+class DepTestPair {
+ public:
+  std::pair<size_t, size_t> depTestPair;        // based on indices in lhsArrays and rhsArrays
+  bool dependent = false;
+  bool unknownDist = false;                     // if dependent
+  int64 depDist = 0;                            // if unknownDist is false
+
+  DepTestPair(size_t i, size_t j) : depTestPair(i, j) {}
+  virtual ~DepTestPair() = default;
+};
+
+class DoloopInfo {
+ public:
+  MapleAllocator *alloc;
+  LfoDepInfo *depInfo;
+  DoloopNode *doloop;
+  DoloopInfo *parent;
+  MapleVector<DoloopInfo *> children;           // for the nested doloops in program order
+  MapleVector<ArrayAccessDesc *> lhsArrays;     // each element represents an array assign
+  MapleVector<ArrayAccessDesc *> rhsArrays;     // each element represents an array read
+  BB *doloopBB = nullptr;                       // the start BB for the doloop body
+  bool hasOtherCtrlFlow = false;                // give up dep testing if true
+  bool hasPtrAccess = false;                    // give up dep testing if true
+  bool hasScalarAssign = false;                 // give up dep testing if true
+  bool hasMayDef = false;                       // give up dep testing if true
+  bool hasBeenVectorized = false;               // set by loopvec phase
+  bool hasLabels = false;                       // needed by lfounroll phase
+  MapleVector<DepTestPair> outputDepTestList;   // output dependence only
+  MapleVector<DepTestPair> flowDepTestList;     // include both true and anti dependences
+  MapleSet<StIdx>          redVars;             // reduction variables
+
+  DoloopInfo(MapleAllocator *allc, LfoDepInfo *depinfo, DoloopNode *doloop, DoloopInfo *prnt)
+      : alloc(allc),
+        depInfo(depinfo),
+        doloop(doloop),
+        parent(prnt),
+        children(alloc->Adapter()),
+        lhsArrays(alloc->Adapter()),
+        rhsArrays(alloc->Adapter()),
+        outputDepTestList(alloc->Adapter()),
+        flowDepTestList(alloc->Adapter()),
+        redVars(alloc->Adapter()) {}
+  ~DoloopInfo() = default;
+  bool IsLoopInvariant(MeExpr *x);
+  bool IsLoopInvariant2(BaseNode *x);
+  bool IsLoopIVNode(const BaseNode*) const;
+  bool OnlyInvariantScalars(MeExpr *x);
+  SubscriptDesc *BuildOneSubscriptDesc(BaseNode *subsX);
+  ArrayAccessDesc *BuildOneArrayAccessDesc(ArrayNode *arr, BaseNode *parent);
+  void CreateRHSArrayAccessDesc(BaseNode *x, BaseNode *parent);
+  void CreateArrayAccessDesc(BlockNode *block);
+  void CreateDepTestLists();
+  void TestDependences(MapleVector<DepTestPair> *depTestList, bool bothLHS);
+  bool Parallelizable();
+  bool CheckReductionLoop();
+  ArrayAccessDesc* GetArrayAccessDesc(const ArrayNode *node, bool isRHS);
+  bool IsReductionVar(StIdx stidx) const { return (redVars.count(stidx) > 0); }
+  int HasTrueDepOnly(); // return min flow-dep distance
+  int HasAntiDepOnly(); // return max anti-dep distance
+  bool HasOutputDep();
+  bool NotParallel();   // return true if doloop has complex issue we dont handle now
+};
+
+class LfoDepInfo : public AnalysisResult {
+ public:
+  MapleAllocator alloc;
+  PreMeFunction *preMeFunc;
+  Dominance *dom;
+  PreMeEmitter *preEmit;
+  MapleVector<DoloopInfo *> outermostDoloopInfoVec;  // outermost doloops' DoloopInfo in program order
+  MapleMap<DoloopNode *, DoloopInfo *> doloopInfoMap;
+
+  LfoDepInfo(MemPool *mempool, PreMeFunction *f, Dominance *dm, PreMeEmitter *preemit)
+      : AnalysisResult(mempool),
+        alloc(mempool),
+        preMeFunc(f),
+        dom(dm),
+        preEmit(preemit),
+        outermostDoloopInfoVec(alloc.Adapter()),
+        doloopInfoMap(alloc.Adapter()) {}
+  ~LfoDepInfo() = default;
+  void CreateDoloopInfo(BlockNode *block, DoloopInfo *parent);
+  void PerformDepTest();
+  std::string PhaseName() const { return "deptest"; }
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MELfoDepTest, MeFunction)
+  LfoDepInfo *GetResult() {
+    return depInfo;
+  }
+  LfoDepInfo *depInfo = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_FUNC_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_LFO_DEP_TEST_H
diff --git a/src/mapleall/maple_me/include/lfo_inject_iv.h b/src/mapleall/maple_me/include/lfo_inject_iv.h
new file mode 100644
index 0000000000000000000000000000000000000000..7bda54d00000976e174fb28a0d0d52437357cc1b
--- /dev/null
+++ b/src/mapleall/maple_me/include/lfo_inject_iv.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_LFO_INJECT_IV_H
+#define MAPLE_ME_INCLUDE_LFO_INJECT_IV_H
+#include "maple_phase_manager.h"
+
+namespace maple {
+/* emit ir to specified file */
+MAPLE_FUNC_PHASE_DECLARE(MELfoInjectIV, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_LFO_INJECT_IV_H
diff --git a/src/mapleall/maple_me/include/lfo_iv_canon.h b/src/mapleall/maple_me/include/lfo_iv_canon.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb7cd9b4ba92f409c04d86877a8062b62bb10b31
--- /dev/null
+++ b/src/mapleall/maple_me/include/lfo_iv_canon.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_LFO_IV_CANON_H
+#define MAPLE_ME_INCLUDE_LFO_IV_CANON_H
+
+#include "pme_function.h"
+#include "me_loop_analysis.h"
+#include "me_irmap_build.h"
+#include "maple_phase.h"
+
+namespace maple {
+// describe characteristics of one IV
+class IVDesc {
+ public:
+  OriginalSt *ost;
+  PrimType primType;
+  MeExpr *initExpr = nullptr;
+  int32 stepValue = 0;
+  bool canBePrimary = true;
+
+  explicit IVDesc(OriginalSt *o) : ost(o) {
+    MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx());
+    primType = mirType->GetPrimType();
+  }
+  virtual ~IVDesc() = default;
+};
+
+// this is for processing a single loop
+class IVCanon {
+ public:
+  MemPool *mp;
+  MapleAllocator alloc;
+  MeFunction *func;
+  Dominance *dominance;
+  SSATab *ssatab;
+  LoopDesc *aloop;
+  uint32 loopID;
+  PreMeWhileInfo *whileInfo;
+  MapleVector<IVDesc *> ivvec;
+  int32 idxPrimaryIV = -1;      // the index in ivvec of the primary IV
+  MeExpr *tripCount = nullptr;
+
+  IVCanon(MemPool *m, MeFunction *f, Dominance *dom, LoopDesc *ldesc, uint32 id, PreMeWhileInfo *winfo)
+      : mp(m), alloc(m), func(f), dominance(dom), ssatab(f->GetMeSSATab()),
+        aloop(ldesc), loopID(id), whileInfo(winfo), ivvec(alloc.Adapter()) {}
+  virtual ~IVCanon() = default;
+  bool ResolveExprValue(MeExpr *x, ScalarMeExpr *phiLHS);
+  int32 ComputeIncrAmt(MeExpr *x, ScalarMeExpr *phiLHS, int32 *appearances, bool &canBePrimary);
+  void CharacterizeIV(ScalarMeExpr *initversion, ScalarMeExpr *loopbackversion, ScalarMeExpr *philhs);
+  void FindPrimaryIV();
+  bool IsLoopInvariant(MeExpr *x);
+  void CanonEntryValues();
+  bool CheckPostIncDecFixUp(CondGotoMeStmt *condbr);
+  void ComputeTripCount();
+  void CanonExitValues();
+  void ReplaceSecondaryIVPhis();
+  void PerformIVCanon();
+  std::string PhaseName() const { return "ivcanon"; }
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MELfoIVCanon, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_LFO_IV_CANON_H
diff --git a/src/mapleall/maple_me/include/lfo_loop_vec.h b/src/mapleall/maple_me/include/lfo_loop_vec.h
new file mode 100644
index 0000000000000000000000000000000000000000..a23905db4ae28985cb5d6975cbac2ce4568a09be
--- /dev/null
+++ b/src/mapleall/maple_me/include/lfo_loop_vec.h
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) [2021-2022] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_LOOP_VEC_H
+#define MAPLE_ME_INCLUDE_LOOP_VEC_H
+#include "me_function.h"
+#include "me_irmap.h"
+#include "me_ir.h"
+#include "pme_emit.h"
+#include "lfo_dep_test.h"
+
+namespace maple {
+class LoopBound {
+ public:
+  LoopBound() : lowNode(nullptr), upperNode(nullptr), incrNode(nullptr) {};
+  LoopBound(BaseNode *nlow, BaseNode *nup, BaseNode *nincr) : lowNode(nlow), upperNode(nup), incrNode(nincr) {}
+  virtual ~LoopBound() = default;
+  BaseNode *lowNode;   // low bound node
+  BaseNode *upperNode; // uppder bound node
+  BaseNode *incrNode;  // incr node
+};
+
+class LoopVecInfo {
+ public:
+  explicit LoopVecInfo(MapleAllocator &alloc)
+      : vecStmtIDs(alloc.Adapter()),
+        uniformNodes(alloc.Adapter()),
+        uniformVecNodes(alloc.Adapter()),
+        constvalTypes(alloc.Adapter()),
+        redVecNodes(alloc.Adapter()),
+        reductionStmts(alloc.Adapter()),
+        ivNodes(alloc.Adapter()),
+        ivVecNodes(alloc.Adapter()),
+        beforeLoopStmts(alloc.Adapter()),
+        afterLoopStmts(alloc.Adapter()) {
+    largestTypeSize = 8; // type bit size
+    smallestTypeSize = 64; // i64 bit size
+    currentRHSTypeSize = 0;
+    currentLHSTypeSize = 0;
+    widenop = 0;
+    minTrueDepDist = 0;
+    maxAntiDepDist = 0;
+    ivConstArraySym = nullptr;
+    ivvecIncrStmt = nullptr;
+  }
+  virtual ~LoopVecInfo() {
+    ivConstArraySym = nullptr;
+    ivvecIncrStmt = nullptr;
+  }
+  void UpdateWidestTypeSize(uint32_t newTypesize);
+  void ResetStmtRHSTypeSize() { currentRHSTypeSize = 0; }
+  bool UpdateRHSTypeSize(PrimType ptype); // record rhs node typesize
+  // used when profileUse is true
+  void UpdateDoloopProfData(MIRFunction *mirFunc, DoloopNode *doLoop, int32_t vecLanes, bool isRemainder = false);
+  uint32_t largestTypeSize;  // largest size type in vectorizable stmtnodes
+  uint32_t smallestTypeSize;  // smallest size type in vectorizable stmtnodes
+  uint32_t currentRHSTypeSize; // largest size of current stmt's RHS, this is temp value and update for each stmt
+  uint32_t currentLHSTypeSize; // record current stmt lhs type in vectorize phase
+  uint32_t widenop;          // can't handle t * t which t need widen operation
+  int16_t  minTrueDepDist;
+  int16_t  maxAntiDepDist;   // negative value
+  // list of vectorizable stmtnodes in current loop, others can't be vectorized
+  MapleSet<uint32_t> vecStmtIDs;
+  MapleSet<BaseNode *> uniformNodes; // loop invariable scalar set
+  MapleMap<BaseNode *, BaseNode *> uniformVecNodes; // new generated vector node
+  // constval node need to adjust with new PrimType
+  MapleMap<BaseNode *, PrimType>  constvalTypes;
+  MapleMap<StmtNode *, BaseNode *> redVecNodes; // new generate vector node
+  MapleSet<StmtNode *> reductionStmts; // loop invariable scalar set
+  MapleSet<BaseNode *> ivNodes; // induction variable used in stmt
+  MapleMap<BaseNode *, BaseNode *> ivVecNodes; // induction variable used in stmt
+  MapleVector<StmtNode *> beforeLoopStmts;
+  MapleVector<StmtNode *> afterLoopStmts;
+  MIRSymbol *ivConstArraySym;
+  StmtNode *ivvecIncrStmt;
+};
+
+// tranform plan for current loop
+class LoopTransPlan {
+ public:
+  LoopTransPlan(MemPool *mp, MemPool *localmp, LoopVecInfo *info)
+      : vBound(nullptr), eBound(nullptr), codeMP(mp), localMP(localmp), vecInfo(info) {
+    vecFactor = 1;
+  }
+  ~LoopTransPlan() = default;
+  LoopBound *vBound = nullptr;   // bound of vectorized part
+  // list of vectorizable stmtnodes in current loop, others can't be vectorized
+  uint8_t  vecLanes = 0;   // number of lanes of vector type in current loop
+  uint8_t  vecFactor = 0;  // number of loop iterations combined to one vectorized loop iteration
+  // generate epilog if eBound is not null
+  LoopBound *eBound = nullptr;   // bound of Epilog part
+  MemPool *codeMP = nullptr;     // use to generate new bound node
+  MemPool *localMP = nullptr;    // use to generate local info
+  LoopVecInfo *vecInfo = nullptr; // collect loop information
+  // function
+  bool Generate(const DoloopNode *doLoop, const DoloopInfo *li, bool enableDebug);
+  void GenerateBoundInfo(const DoloopNode *doLoop, const DoloopInfo *li);
+};
+
+class LoopVectorization {
+ public:
+  LoopVectorization(MemPool *localmp, PreMeEmitter *lfoEmit, LfoDepInfo *depinfo, bool debug = false)
+      : localAlloc(localmp), vecPlans(localAlloc.Adapter()) {
+    mirFunc = lfoEmit->GetMirFunction();
+    PreMeStmtExtensionMap = lfoEmit->GetPreMeStmtExtensionMap();
+    PreMeExprExtensionMap = lfoEmit->GetPreMeExprExtensionMap();
+    depInfo = depinfo;
+    codeMP = lfoEmit->GetCodeMP();
+    codeMPAlloc = lfoEmit->GetCodeMPAlloc();
+    localMP = localmp;
+    const0Node = nullptr;
+    initIVv4Sym = nullptr;
+    initIVv8Sym = nullptr;
+    initIVv2Sym = nullptr;
+    isArraySub = false;
+    enableDebug = debug;
+  }
+  ~LoopVectorization() = default;
+
+  void Perform();
+  void TransformLoop();
+  void VectorizeDoLoop(DoloopNode *, LoopTransPlan*);
+  void VectorizeStmt(BaseNode *, LoopTransPlan *);
+  void VectorizeExpr(BaseNode *, LoopTransPlan *, MapleVector<BaseNode *>&, uint32_t);
+  MIRType *GenVecType(PrimType sPrimType, uint8_t lanes) const;
+  IntrinsicopNode *GenDupScalarExpr(BaseNode *scalar, PrimType vecPrimType);
+  bool ExprVectorizable(DoloopInfo *doloopInfo, LoopVecInfo*, BaseNode *x);
+  bool Vectorizable(DoloopInfo *doloopInfo, LoopVecInfo*, BlockNode *block);
+  void widenDoloop(DoloopNode *doloop, LoopTransPlan *);
+  DoloopNode *PrepareDoloop(DoloopNode *, LoopTransPlan *);
+  DoloopNode *GenEpilog(DoloopNode *) const;
+  const MemPool *GetLocalMp() const { return localMP; }
+  const MapleMap<DoloopNode *, LoopTransPlan *> *GetVecPlans() const { return &vecPlans; }
+  std::string PhaseName() const { return "lfoloopvec"; }
+  bool CanConvert(uint32_t, uint32_t) const;
+  bool CanAdjustRhsConstType(PrimType, ConstvalNode *);
+  bool IsReductionOp(Opcode op) const;
+  bool CanWidenOpcode(const BaseNode *target, PrimType opndType) const;
+  IntrinsicopNode *GenSumVecStmt(BaseNode *vecTemp, PrimType vecPrimType);
+  IntrinsicopNode *GenVectorGetLow(BaseNode *vecNode, PrimType vecPrimType);
+  IntrinsicopNode *GenVectorAddw(BaseNode *oper0, BaseNode *oper1, PrimType op1Type, bool highPart);
+  IntrinsicopNode *GenVectorSubl(BaseNode *oper0, BaseNode *oper1, PrimType op1Type, bool highPart);
+  IntrinsicopNode *GenVectorWidenIntrn(BaseNode *oper0,
+                                       BaseNode *oper1, PrimType opndType, bool highPart, Opcode op);
+  IntrinsicopNode *GenVectorWidenOpnd(BaseNode *opnd, PrimType vecPrimType, bool highPart);
+  IntrinsicopNode *GenVectorMull(BaseNode *oper0, BaseNode *oper1, PrimType op1Type, bool highPart);
+  IntrinsicopNode *GenVectorAbsSubl(BaseNode *oper0, BaseNode *oper1, PrimType op1Type, bool highPart);
+  IntrinsicopNode *GenVectorPairWiseAccumulate(BaseNode *oper0, BaseNode *oper1, PrimType oper1Type);
+  IntrinsicopNode *GenVectorAddl(BaseNode *oper0, BaseNode *oper1, PrimType op1Type, bool highPart);
+  IntrinsicopNode *GenVectorNarrowLowNode(BaseNode *opnd, PrimType opndPrimType);
+  void GenWidenBinaryExpr(Opcode binOp, MapleVector<BaseNode *>& opnd0Vec,
+                          MapleVector<BaseNode *>& opnd1Vec, MapleVector<BaseNode *>& vectorizedNode);
+  BaseNode* ConvertNodeType(bool cvtSigned, BaseNode *n);
+  MIRIntrinsicID GenVectorAbsSublID(MIRIntrinsicID intrnID) const;
+  static uint32_t vectorizedLoop;
+ private:
+  RegreadNode *GenVectorReductionVar(StmtNode *stmt, LoopTransPlan *tp);
+  bool IassignIsReduction(IassignNode *iassign, LoopVecInfo* vecInfo);
+  RegreadNode *GetorNewVectorReductionVar(StmtNode *stmt, LoopTransPlan *tp);
+  MIRType *VectorizeIassignLhs(IassignNode *iassign, LoopTransPlan *tp);
+  void VectorizeReductionStmt(StmtNode *stmt, LoopTransPlan *tp);
+  void GenConstVar(LoopVecInfo *vecInfo, uint8_t vecLanes);
+
+  MIRFunction *mirFunc;
+  // point to PreMeStmtExtensionMap of PreMeEmitter, key is stmtID
+  MapleMap<uint32_t, PreMeMIRExtension *>  *PreMeStmtExtensionMap;
+  // point to PreMeExprExtensionMap of PreMeEmitter, key is mirnode
+  MapleMap<BaseNode *, PreMeMIRExtension *> *PreMeExprExtensionMap;
+  LfoDepInfo *depInfo;
+  MemPool *codeMP;    // point to mirfunction codeMp
+  MapleAllocator *codeMPAlloc;
+  MemPool *localMP;   // local mempool
+  MapleAllocator localAlloc;
+  MapleMap<DoloopNode *, LoopTransPlan *> vecPlans; // each loopnode has its best vectorization plan
+  BaseNode *const0Node = nullptr;   // zero const used in reduction variable
+  MIRSymbol *initIVv4Sym = nullptr; // constant array symbol used by vectorizing induction variable
+  MIRSymbol *initIVv8Sym = nullptr;
+  MIRSymbol *initIVv2Sym = nullptr;
+  bool isArraySub; // current expression is used in array subscript
+  bool enableDebug;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_LOOP_VEC_H
diff --git a/src/mapleall/maple_me/include/lfo_unroll.h b/src/mapleall/maple_me/include/lfo_unroll.h
new file mode 100644
index 0000000000000000000000000000000000000000..d72da9d8ab33f7bbdad3a7ea8e46ae26fba63be8
--- /dev/null
+++ b/src/mapleall/maple_me/include/lfo_unroll.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_LFO_UNROLL_H
+#define MAPLE_ME_INCLUDE_LFO_UNROLL_H
+
+#include "pme_function.h"
+#include "pme_emit.h"
+#include "lfo_dep_test.h"
+#include "orig_symbol.h"
+#include "me_ir.h"
+
+namespace maple {
+
+class LfoUnrollOneLoop {
+ public:
+  LfoUnrollOneLoop(PreMeFunction *f, PreMeEmitter *preEm, DoloopInfo *doinfo)
+      : preMeFunc(f), preEmit(preEm), doloopInfo(doinfo), doloop(doinfo->doloop),
+        mirModule(&f->meFunc->GetMIRModule()), codeMP(preEm->GetCodeMP()),
+        mirBuilder(mirModule->GetMIRBuilder()) {}
+  ~LfoUnrollOneLoop() = default;
+  BaseNode *CloneIVNode();
+  void ReplaceIV(BaseNode *x, BaseNode *repNode);
+  BlockNode *DoFullUnroll(size_t tripCount);
+  BlockNode *DoUnroll(size_t times, size_t tripCount);
+  void Process();
+
+  PreMeFunction *preMeFunc;
+  PreMeEmitter *preEmit;
+  DoloopInfo *doloopInfo;
+  DoloopNode *doloop;
+  MIRModule *mirModule;
+  MemPool *codeMP;     // to generate new code
+  MIRBuilder *mirBuilder;
+  int64 stepAmount = 0;
+  PrimType ivPrimType = PTY_unknown;
+  static uint32 countOfLoopsUnrolled;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MELfoUnroll, MeFunction)
+
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_LFO_UNROLL_H
diff --git a/src/mapleall/maple_me/include/lmbc_lower.h b/src/mapleall/maple_me/include/lmbc_lower.h
new file mode 100644
index 0000000000000000000000000000000000000000..0641d0b4ccc8985d96680f0933c7712839ac165a
--- /dev/null
+++ b/src/mapleall/maple_me/include/lmbc_lower.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLEME_INCLUDE_LMBC_LOWER_H_
+#define MAPLEME_INCLUDE_LMBC_LOWER_H_
+#include "mir_builder.h"
+#include "lmbc_memlayout.h"
+
+namespace maple {
+
+class LMBCLowerer {
+ public:
+  explicit LMBCLowerer(MIRModule *mod, maplebe::BECommon *becmmn, MIRFunction *f,
+                       GlobalMemLayout *gmemlayout, LMBCMemLayout *lmemlayout)
+      : mirModule(mod), func(f), becommon(becmmn), mirBuilder(mod->GetMIRBuilder()),
+        globmemlayout(gmemlayout), memlayout(lmemlayout) {}
+
+  PregIdx GetSpecialRegFromSt(const MIRSymbol *);
+  BaseNode *LowerAddrof(AddrofNode *);
+  BaseNode *LowerDread(AddrofNode *);
+  BaseNode *LowerDreadoff(DreadoffNode *);
+  BaseNode *LowerIread(IreadNode *);
+  BaseNode *LowerIaddrof(IreadNode *);
+  BaseNode *LowerExpr(BaseNode *expr);
+  void LowerAggDassign(const DassignNode *, MIRType *lhsty, int32 offset, BlockNode *);
+  void LowerDassign(DassignNode *, BlockNode *);
+  void LowerDassignoff(DassignoffNode *, BlockNode *);
+  void LowerIassign(IassignNode *, BlockNode *);
+  void LowerAggIassign(IassignNode *, MIRType *type, int32 offset, BlockNode *);
+  void LowerReturn(NaryStmtNode *retNode, BlockNode *newblk);
+  void LowerCall(NaryStmtNode *stmt, BlockNode *newblk);
+  BlockNode *LowerBlock(BlockNode *);
+  void FixPrototype4FirstArgReturn(IcallNode *icall);
+  void LowerFunction();
+
+  MIRModule *mirModule;
+  MIRFunction *func;
+  maplebe::BECommon *becommon;
+  MIRBuilder *mirBuilder;
+  GlobalMemLayout *globmemlayout;
+  LMBCMemLayout *memlayout;
+};
+
+}  // namespace maple
+
+#endif  // MAPLEME_INCLUDE_LMBC_LOWER_H_
diff --git a/src/mapleall/maple_me/include/lmbc_memlayout.h b/src/mapleall/maple_me/include/lmbc_memlayout.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc7b532f695aba7adf4c76b97573781aa8493150
--- /dev/null
+++ b/src/mapleall/maple_me/include/lmbc_memlayout.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#ifndef MAPLEME_INCLUDE_LMBC_MEMLAYOUT_H
+#define MAPLEME_INCLUDE_LMBC_MEMLAYOUT_H
+
+#include "mir_module.h"
+#include "mir_type.h"
+#include "mir_const.h"
+#include "mir_symbol.h"
+#include "mir_function.h"
+#include "becommon.h"
+
+namespace maple {
+
+typedef enum {
+  MS_unknown,
+  MS_upformal,  // for the incoming parameters that are passed on the caller's stack
+  MS_formal,    // for the incoming parameters that are passed in registers
+  MS_actual,    // for the outgoing parameters
+  MS_local,     // for all local variables and temporaries
+  MS_FPbased,   // addressed via offset from the frame pointer
+  MS_GPbased,   // addressed via offset from the global pointer
+  MS_largeStructActual, // for storing large struct actuals passed by value for ARM CPU
+} MemSegmentKind;
+
+class MemSegment;
+
+// describes where a symbol is allocated
+struct SymbolAlloc {
+  MemSegment *mem_segment = nullptr;
+  int32 offset = 0;
+};  // class SymbolAlloc
+
+// keeps track of the allocation of a memory segment
+class MemSegment {
+ public:
+  explicit MemSegment(MemSegmentKind k) : kind(k), size(0) {}
+
+  MemSegment(MemSegmentKind k, int32 sz) : kind(k), size(sz) {}
+
+  ~MemSegment() {}
+
+  MemSegmentKind kind;
+  int32 size;             // size is negative if allocated offsets are negative
+};  // class MemSegment
+
+class LMBCMemLayout {
+ public:
+  LMBCMemLayout(MIRFunction *f, MemSegment *segGP, MapleAllocator *mallocator)
+      : func(f),
+        seg_GPbased(segGP),
+        seg_FPbased(MS_FPbased),
+        sym_alloc_table(mallocator->Adapter()) {
+    sym_alloc_table.resize(f->GetSymTab()->GetSymbolTableSize());
+  }
+
+  ~LMBCMemLayout() = default;
+
+  void LayoutStackFrame(void);
+  int32 StackFrameSize(void) const {
+    return -seg_FPbased.size;
+  }
+
+  MIRFunction *func;
+  MemSegment *seg_GPbased;
+  MemSegment seg_FPbased;
+  MapleVector<SymbolAlloc> sym_alloc_table;  // index is StIdx
+};
+
+class GlobalMemLayout {
+ public:
+  GlobalMemLayout(MIRModule *mod, MapleAllocator *mallocator);
+  ~GlobalMemLayout() {}
+
+  MemSegment seg_GPbased;
+  MapleVector<SymbolAlloc> sym_alloc_table;  // index is StIdx
+  MIRModule *mirModule;
+};
+
+}  /* namespace maple */
+
+#endif  /* MAPLEME_INCLUDE_LMBC_MEMLAYOUT_H */
diff --git a/src/mapleall/maple_me/include/me_abco.h b/src/mapleall/maple_me/include/me_abco.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd7c710b6710e8720bc49d3e8887f12b787b8fe0
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_abco.h
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEME_INCLUDE_ME_ABCOPT
+#define MAPLEME_INCLUDE_ME_ABCOPT
+#include "me_function.h"
+#include "me_irmap_build.h"
+#include "me_ir.h"
+#include "me_inequality_graph.h"
+#include "me_cfg.h"
+#include "me_dominance.h"
+#include "mir_module.h"
+#include "mir_builder.h"
+#include "me_ssi.h"
+
+namespace maple {
+class CarePoint {
+ public:
+  enum CareKind {
+    kMeStmt,
+    kMePhi
+  };
+
+  explicit CarePoint(CareKind ck) : careKind(ck) {}
+  ~CarePoint() = default;
+
+  bool IsCareMeStmt() const {
+    return careKind == kMeStmt;
+  }
+
+  MeStmt *GetMeStmt() {
+    CHECK_FATAL(careKind == kMeStmt, "must be");
+    return value.meStmt;
+  }
+
+  const MeStmt *GetMeStmt() const {
+    CHECK_FATAL(careKind == kMeStmt, "must be");
+    return value.meStmt;
+  }
+
+  MePhiNode *GetMePhi() {
+    CHECK_FATAL(careKind == kMePhi, "must be");
+    return value.phiNode;
+  }
+
+  const MePhiNode *GetMePhi() const {
+    CHECK_FATAL(careKind == kMePhi, "must be");
+    return value.phiNode;
+  }
+
+  void SetMeStmt(MeStmt &meStmt) {
+    CHECK_FATAL(careKind == kMeStmt, "must be");
+    value.meStmt = &meStmt;
+  }
+
+  void SetMePhi(MePhiNode &phi) {
+    CHECK_FATAL(careKind == kMePhi, "must be");
+    value.phiNode = &phi;
+  }
+
+ private:
+  CareKind careKind;
+  union CareStmt {
+    MeStmt *meStmt;
+    MePhiNode *phiNode;
+  };
+  CareStmt value;
+};
+
+
+class MeABC {
+ public:
+  static bool isDebug;
+  MeABC(MeFunction &meFunction, Dominance &dom, MeIRMap &map, MemPool &pool)
+      : meFunc(&meFunction),
+        dom(&dom),
+        irMap(&map),
+        memPool(&pool),
+        allocator(&pool),
+        inequalityGraph(nullptr),
+        prove(nullptr),
+        currentCheck(nullptr) {
+          ssi = std::make_unique<MeSSI>(meFunction, dom, map, pool, &arrayChecks, &containsBB);
+          ssi->SetSSIType(kArrayBoundsCheckOpt);
+        }
+  ~MeABC() = default;
+  void ExecuteABCO();
+
+ private:
+  bool CollectABC();
+  void ABCCollectArrayExpr(MeStmt &meStmt, MeExpr &meExpr, bool isUpdate = false);
+  void CollectCareInsns();
+  bool IsVirtualVar(const VarMeExpr &var) const;
+  ESSABaseNode *GetOrCreateRHSNode(MeExpr &expr);
+  void BuildPhiInGraph(MePhiNode &phi);
+  void BuildSoloPiInGraph(const PiassignMeStmt &piMeStmt);
+  bool PiExecuteBeforeCurrentCheck(const PiassignMeStmt &piMeStmt);
+  void AddEdgePair(ESSABaseNode &from, ESSABaseNode &to, int64 value, EdgeType type);
+  bool BuildArrayCheckInGraph(MeStmt &meStmt);
+  bool BuildBrMeStmtInGraph(MeStmt &meStmt);
+  bool BuildAssignInGraph(const MeStmt &meStmt);
+  MeExpr *TryToResolveVar(MeExpr &expr, bool isConst);
+  MeExpr *TryToResolveVar(MeExpr &expr, std::set<MePhiNode*> &visitedPhi, MeExpr &dummyExpr, bool isConst);
+  bool BuildStmtInGraph(MeStmt &meStmt);
+  void AddUseDef(MeExpr &meExpr);
+  void AddCareInsn(MeStmt &defS);
+  void AddCarePhi(MePhiNode &defP);
+  void BuildInequalityGraph();
+  bool IsLessOrEuqal(const MeExpr &opnd1, const MeExpr &opnd2);
+  void ProcessCallParameters(CallMeStmt &callNode);
+  void FindRedundantABC(MeStmt &meStmt, const NaryMeExpr &naryMeExpr);
+  void InitNewStartPoint(MeStmt &meStmt, MeExpr &opnd1, MeExpr &opnd2, bool clearGraph = true);
+  void DeleteABC();
+  bool CleanABCInStmt(MeStmt &meStmt, NaryMeExpr &naryMeExpr);
+  MeExpr *ReplaceArrayExpr(MeExpr &rhs, MeExpr &naryMeExpr, MeStmt *ivarStmt);
+  bool HasRelativeWithLength(MeExpr &meExpr);
+  bool ProveGreaterZ(const MeExpr &weight);
+  void ReSolveEdge();
+  Dominance *GetDominace() {
+    return dom;
+  }
+
+  MemPool *GetMemPool() {
+    return memPool;
+  }
+
+  MapleAllocator &GetAllocator() {
+    return allocator;
+  }
+
+  const MeIRMap *GetIRMap() const {
+    return irMap;
+  }
+
+  MeFunction *meFunc;
+  Dominance *dom;
+  MeIRMap *irMap;
+  MemPool *memPool;
+  MapleAllocator allocator;
+  std::unique_ptr<InequalityGraph> inequalityGraph;
+  std::unique_ptr<ABCD> prove;
+  MeStmt *currentCheck;
+  std::unique_ptr<MeSSI> ssi;
+  std::map<MeStmt*, NaryMeExpr*> arrayChecks;
+  std::map<MeStmt*, NaryMeExpr*> arrayNewChecks;
+  std::set<MeStmt*> careMeStmts;
+  std::set<MePhiNode*> careMePhis;
+  std::map<BB*, std::vector<MeStmt*>> containsBB;
+  std::vector<CarePoint*> carePoints;
+  std::set<MeStmt*> targetMeStmt;
+  std::set<MePhiNode*> visited;
+  // map<std::pair<a, b>, c>; a = b + c  b is relative with length, c is var weight
+  std::map<std::pair<MeExpr*, MeExpr*>, MeExpr*> unresolveEdge;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEABCOpt, MeFunction)
+}
+#endif
diff --git a/src/mapleall/maple_me/include/me_alias_class.h b/src/mapleall/maple_me/include/me_alias_class.h
new file mode 100644
index 0000000000000000000000000000000000000000..9f16175de358d6653fb6b590eec933ea6ef77dc2
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_alias_class.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_ALIAS_CLASS_H
+#define MAPLE_ME_INCLUDE_ME_ALIAS_CLASS_H
+#include "alias_class.h"
+#include "me_function.h"
+#include "me_cfg.h"
+#include "maple_phase.h"
+
+namespace maple {
+class MeAliasClass : public AliasClass {
+ public:
+  MeAliasClass(MemPool &memPool, MemPool &localMemPool, MIRModule &mod, SSATab &ssaTab, MeFunction &func,
+               bool lessAliasAtThrow, bool ignoreIPA, bool debug, bool setCalleeHasSideEffect, KlassHierarchy *kh)
+      : AliasClass(memPool, mod, ssaTab, lessAliasAtThrow, ignoreIPA, setCalleeHasSideEffect, kh),
+        func(func), cfg(func.GetCfg()), localMemPool(&localMemPool), enabledDebug(debug) {}
+
+  virtual ~MeAliasClass() = default;
+
+  void DoAliasAnalysis();
+
+ private:
+  BB *GetBB(BBId id) override {
+    if (cfg->GetAllBBs().size() < id) {
+      return nullptr;
+    }
+    return cfg->GetBBFromID(id);
+  }
+
+  bool InConstructorLikeFunc() const override {
+    return func.GetMirFunc()->IsConstructor() || HasWriteToStaticFinal();
+  }
+
+  bool HasWriteToStaticFinal() const;
+  void PerformDemandDrivenAliasAnalysis();
+  void PerformTBAAForC();
+
+  MeFunction &func;
+  MeCFG *cfg;
+  MemPool *localMemPool;
+  bool enabledDebug;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MEAliasClass, MeFunction)
+  MeAliasClass *GetResult() {
+    return aliasClass;
+  }
+  MeAliasClass *aliasClass = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_FUNC_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_ALIAS_CLASS_H
diff --git a/src/mapleall/maple_me/include/me_analyze_rc.h b/src/mapleall/maple_me/include/me_analyze_rc.h
new file mode 100644
index 0000000000000000000000000000000000000000..8fbbad7b582910371db4c671efbd4c7a70a6a622
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_analyze_rc.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEANALYZERC_H
+#define MAPLE_ME_INCLUDE_MEANALYZERC_H
+#include "me_function.h"
+#include "me_alias_class.h"
+#include "me_irmap.h"
+
+namespace maple {
+class RCItem {
+ public:
+  RCItem(OriginalSt &o, MapleAllocator &alloc)
+      : ost(o),
+        noAlias(false),
+        nonLocal(false),
+        isFormal(false),
+        needSomeRC(false),
+        versionStack(alloc.Adapter()),
+        occurBBs(std::less<BBId>(), alloc.Adapter()) {}
+
+  virtual ~RCItem() = default;
+
+  void Dump();
+ private:
+  friend class AnalyzeRC;
+  OriginalSt &ost;
+  bool noAlias;
+  bool nonLocal;            // need to do placement optimization if (!nonLocal)
+  bool isFormal;            // is an incoming formal parameter
+  bool needSomeRC;          // true if any definition has rhs that needs RC
+  MapleStack<MeExpr*> versionStack;
+  MapleSet<BBId> occurBBs;  // set of BBs where the pointer occurs; only for local ref pointers
+};
+
+class AnalyzeRC {
+ public:
+  AnalyzeRC(MeFunction &f, Dominance &dom, AliasClass &ac, MemPool *memPool)
+      : func(f),
+        cfg(f.GetCfg()),
+        irMap(*f.GetIRMap()),
+        ssaTab(*f.GetMeSSATab()),
+        dominance(dom),
+        aliasClass(ac),
+        analyzeRCMp(memPool),
+        analyzeRCAllocator(memPool),
+        rcItemsMap(std::less<OStIdx>(), analyzeRCAllocator.Adapter()),
+        skipLocalRefVars(false) {}
+
+  virtual ~AnalyzeRC() = default;
+  void Run();
+
+ private:
+  void IdentifyRCStmts();
+  void CreateCleanupIntrinsics();
+  void RenameRefPtrs(BB *bb);
+  void OptimizeRC();
+  void RemoveUnneededCleanups();
+  void RenameUses(MeStmt &meStmt);
+  RCItem *FindOrCreateRCItem(OriginalSt &ost);
+  OriginalSt *GetOriginalSt(const MeExpr &refLHS) const;
+  VarMeExpr *GetZeroVersionVarMeExpr(const VarMeExpr &var);
+  bool NeedIncref(const MeStmt &stmt) const;
+  UnaryMeStmt *CreateIncrefZeroVersion(OriginalSt &ost);
+  DassignMeStmt *CreateDassignInit(OriginalSt &ost, BB &bb);
+  void TraverseStmt(BB &bb);
+  bool NeedDecRef(const RCItem &rcItem, MeExpr &expr) const;
+  bool NeedDecRef(IvarMeExpr &ivar) const;
+  bool NeedDecRef(const VarMeExpr &var) const;
+
+  friend class MeDoAnalyzeRC;
+  MeFunction &func;
+  MeCFG *cfg;
+  IRMap &irMap;
+  SSATab &ssaTab;
+  Dominance &dominance;
+  AliasClass &aliasClass;
+  MemPool *analyzeRCMp;
+  MapleAllocator analyzeRCAllocator;
+  MapleMap<OStIdx, RCItem*> rcItemsMap;
+  bool skipLocalRefVars;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEAnalyzeRC, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MEANALYZERC_H
diff --git a/src/mapleall/maple_me/include/me_analyzector.h b/src/mapleall/maple_me/include/me_analyzector.h
new file mode 100644
index 0000000000000000000000000000000000000000..668163764dab2ccf7328cf989564f3f774476533
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_analyzector.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEME_INCLUDE_ANALYZECTOR_H
+#define MAPLEME_INCLUDE_ANALYZECTOR_H
+
+#include "me_function.h"
+#include "class_hierarchy_phase.h"
+#include "me_dominance.h"
+#include "me_irmap_build.h"
+
+namespace maple {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+
+class AnalyzeCtor {
+ public:
+  AnalyzeCtor(MeFunction &func, Dominance &dom, KlassHierarchy &kh) : func(&func), dominance(&dom), klassh(&kh) {}
+  virtual ~AnalyzeCtor() = default;
+
+  virtual void ProcessFunc();
+  void ProcessStmt(MeStmt &stmt);
+
+ private:
+  bool hasSideEffect = false;
+  std::unordered_set<FieldID> fieldSet;
+  MeFunction *func;
+  Dominance *dominance;
+  KlassHierarchy *klassh;
+
+};
+#pragma clang diagnostic pop
+
+MAPLE_FUNC_PHASE_DECLARE(MEAnalyzeCtor, MeFunction)
+}  // namespace maple
+#endif  // MAPLEME_INCLUDE_ANALYZECTOR_H
diff --git a/src/mapleall/maple_me/include/me_autovec.h b/src/mapleall/maple_me/include/me_autovec.h
new file mode 100644
index 0000000000000000000000000000000000000000..537dea2e1098315b1802dfc9245c2fc0c99e66b2
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_autovec.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_AUTOVEC_H
+#define MAPLE_ME_INCLUDE_AUTOVEC_H
+#include "me_function.h"
+namespace maple {
+MAPLE_FUNC_PHASE_DECLARE(MEAutoVectorization, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_AUTOVEC_H
diff --git a/src/mapleall/maple_me/include/me_bb_analyze.h b/src/mapleall/maple_me/include/me_bb_analyze.h
new file mode 100644
index 0000000000000000000000000000000000000000..26f1d3e2e385ae9d444af13c358abc4c49c1115f
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_bb_analyze.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_ANALYZE_H
+#define MAPLE_ME_INCLUDE_ME_ANALYZE_H
+#include <vector>
+#include "bb.h"
+#include "me_function.h"
+#include "me_option.h"
+#include "me_cfg.h"
+
+namespace maple {
+const uint32 kPrecision = 100;
+class BBAnalyze : public AnalysisResult {
+ public:
+  BBAnalyze(MemPool &memPool, const MeFunction &f) : AnalysisResult(&memPool), meBBAlloc(&memPool), cfg(f.GetCfg()) {}
+
+  virtual ~BBAnalyze() = default;
+
+  void SetHotAndColdBBCountThreshold();
+  bool CheckBBHot(const BBId bbId) const;
+  bool CheckBBCold(const BBId bbId) const;
+  uint32 getHotBBCountThreshold() const;
+  uint32 getColdBBCountThreshold() const;
+
+ private:
+  MapleAllocator meBBAlloc;
+  MeCFG *cfg;
+  uint32 hotBBCountThreshold = 0;
+  uint32 coldBBCountThreshold = 0;
+};
+
+#ifdef NOT_USED
+class MeDoBBAnalyze : public MeFuncPhase {
+ public:
+  explicit MeDoBBAnalyze(MePhaseID id) : MeFuncPhase(id) {}
+
+  virtual ~MeDoBBAnalyze() = default;
+  AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) override;
+  std::string PhaseName() const override {
+    return "bbanalyze";
+  }
+};
+#endif
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_ANALYZE_H
diff --git a/src/mapleall/maple_me/include/me_bb_layout.h b/src/mapleall/maple_me/include/me_bb_layout.h
new file mode 100644
index 0000000000000000000000000000000000000000..da5d463b81c058c51b9001bfce98f2cb35fd959c
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_bb_layout.h
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_BB_LAYOUT_H
+#define MAPLE_ME_INCLUDE_ME_BB_LAYOUT_H
+#include "me_function.h"
+#include "me_pgo_instrument.h"
+#include "maple_phase_manager.h"
+#include "me_dominance.h"
+#include "me_loop_analysis.h"
+
+namespace maple {
+class BBChain {
+ public:
+  using iterator = MapleVector<BB*>::iterator;
+  using const_iterator = MapleVector<BB*>::const_iterator;
+  BBChain(MapleAllocator &alloc, MapleVector<BBChain*> &bb2chain, BB *bb, uint32 inputId)
+      : id(inputId), bbVec(1, bb, alloc.Adapter()), bb2chain(bb2chain) {
+    bb2chain[bb->GetBBId()] = this;
+  }
+
+  iterator begin() {
+    return bbVec.begin();
+  }
+  const_iterator begin() const {
+    return bbVec.begin();
+  }
+  iterator end() {
+    return bbVec.end();
+  }
+  const_iterator end() const {
+    return bbVec.end();
+  }
+
+  bool empty() const {
+    return bbVec.empty();
+  }
+
+  size_t size() const {
+    return bbVec.size();
+  }
+
+  uint32 GetId() const {
+    return id;
+  }
+
+  BB *GetHeader() {
+    CHECK_FATAL(!bbVec.empty(), "cannot get header from a empty bb chain");
+    return bbVec.front();
+  }
+  BB *GetTail() {
+    CHECK_FATAL(!bbVec.empty(), "cannot get tail from a empty bb chain");
+    return bbVec.back();
+  }
+
+  // update unlaidPredCnt if needed. The chain is ready to layout only if unlaidPredCnt == 0
+  bool IsReadyToLayout(const MapleVector<bool> *context) {
+    MayRecalculateUnlaidPredCnt(context);
+    return (unlaidPredCnt == 0);
+  }
+
+  // Merge src chain to this one
+  void MergeFrom(BBChain *srcChain) {
+    CHECK_FATAL(this != srcChain, "merge same chain?");
+    ASSERT_NOT_NULL(srcChain);
+    if (srcChain->empty()) {
+      return;
+    }
+    for (BB *bb : *srcChain) {
+      bbVec.push_back(bb);
+      bb2chain[bb->GetBBId()] = this;
+    }
+    srcChain->bbVec.clear();
+    srcChain->unlaidPredCnt = 0;
+    srcChain->isCacheValid = false;
+    isCacheValid = false;  // is this necessary?
+  }
+
+  void UpdateSuccChainBeforeMerged(const BBChain &destChain, const MapleVector<bool> *context,
+                                   MapleSet<BBChain*> &readyToLayoutChains) {
+    for (BB *bb : bbVec) {
+      for (BB *succ : bb->GetSucc()) {
+        if (context != nullptr && !(*context)[succ->GetBBId()]) {
+          continue;
+        }
+        if (bb2chain[succ->GetBBId()] == this || bb2chain[succ->GetBBId()] == &destChain) {
+          continue;
+        }
+        BBChain *succChain = bb2chain[succ->GetBBId()];
+        succChain->MayRecalculateUnlaidPredCnt(context);
+        if (succChain->unlaidPredCnt != 0) {
+          --succChain->unlaidPredCnt;
+        }
+        if (succChain->unlaidPredCnt == 0) {
+          readyToLayoutChains.insert(succChain);
+        }
+      }
+    }
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << "bb chain with " << bbVec.size() << " blocks: ";
+    for (BB *bb : bbVec) {
+      LogInfo::MapleLogger() << bb->GetBBId() << " ";
+    }
+    LogInfo::MapleLogger() << std::endl;
+  }
+
+  void DumpOneLine() const {
+    for (BB *bb : bbVec) {
+      LogInfo::MapleLogger() << bb->GetBBId() << " ";
+    }
+  }
+
+ private:
+  void MayRecalculateUnlaidPredCnt(const MapleVector<bool> *context) {
+    if (isCacheValid) {
+      return;  // If cache is trustable, no need to recalculate
+    }
+    unlaidPredCnt = 0;
+    for (BB *bb : bbVec) {
+      for (BB *pred : bb->GetPred()) {
+        // exclude blocks out of context
+        if (context != nullptr && !(*context)[pred->GetBBId()]) {
+          continue;
+        }
+        // exclude blocks within the same chain
+        if (bb2chain[pred->GetBBId()] == this) {
+          continue;
+        }
+        ++unlaidPredCnt;
+      }
+    }
+    isCacheValid = true;
+  }
+
+  uint32 id = 0;
+  MapleVector<BB*> bbVec;
+  MapleVector<BBChain*> &bb2chain;
+  uint32 unlaidPredCnt = 0;   // how many predecessors are not laid out
+  bool isCacheValid = false;  // whether unlaidPredCnt is trustable
+};
+
+class BBLayout {
+ public:
+  BBLayout(MemPool &memPool, MeFunction &f, bool enabledDebug, MaplePhase *phase)
+      : func(f),
+        layoutAlloc(&memPool),
+        layoutBBs(layoutAlloc.Adapter()),
+        startTryBBVec(func.GetCfg()->GetAllBBs().size(), false, layoutAlloc.Adapter()),
+        bbVisited(func.GetCfg()->GetAllBBs().size(), false, layoutAlloc.Adapter()),
+        allEdges(layoutAlloc.Adapter()),
+        bb2chain(layoutAlloc.Adapter()),
+        readyToLayoutChains(layoutAlloc.Adapter()),
+        laidOut(func.GetCfg()->GetAllBBs().size(), false, layoutAlloc.Adapter()),
+        enabledDebug(enabledDebug),
+        profValid(func.IsIRProfValid()),
+        cfg(f.GetCfg()),
+        phase(phase) {
+    laidOut[func.GetCfg()->GetCommonEntryBB()->GetBBId()] = true;
+    laidOut[func.GetCfg()->GetCommonExitBB()->GetBBId()] = true;
+  }
+
+  ~BBLayout() = default;
+  BB *NextBB() {
+    // return the next BB following strictly program input order
+    ++curBBId;
+    while (curBBId < func.GetCfg()->GetAllBBs().size()) {
+      BB *nextBB = func.GetCfg()->GetBBFromID(curBBId);
+      if (nextBB != nullptr && !laidOut[nextBB->GetBBId()]) {
+        return nextBB;
+      }
+      ++curBBId;
+    }
+    return nullptr;
+  }
+
+  bool BBIsEmpty(const BB *bb);
+  void OptimizeCaseTargets(BB *switchBB, CaseVector *swTable);
+  void OptimizeBranchTarget(BB &bb);
+  bool BBEmptyAndFallthru(const BB &bb);
+  bool BBContainsOnlyGoto(const BB &bb) const;
+  bool BBContainsOnlyCondGoto(const BB &bb) const;
+  bool HasSameBranchCond(BB &bb1, BB &bb2) const;
+  bool BBCanBeMoved(const BB &fromBB, const BB &toAfterBB) const;
+  bool BBCanBeMovedBasedProf(const BB &fromBB, const BB &toAfterBB) const;
+  void AddBB(BB &bb);
+  void AddBBProf(BB &bb);
+  void BuildEdges();
+  BB *GetFallThruBBSkippingEmpty(BB &bb);
+  void ResolveUnconditionalFallThru(BB &bb, BB &nextBB);
+  void ChangeToFallthruFromGoto(BB &bb);
+  void RemoveUnreachable(BB &bb);
+  BB *CreateGotoBBAfterCondBB(BB &bb, BB &fallthru);
+  bool ChooseTargetAsFallthru(const BB &bb, const BB &targetBB, const BB &oldFallThru,
+                              const BB &fallThru) const;
+  void ChangeToFallthruFromCondGoto(BB &bb);
+  void OptimizeEmptyFallThruBB(BB &bb);
+  const MapleVector<BB*> &GetBBs() const {
+    return layoutBBs;
+  }
+
+  bool IsNewBBInLayout() const {
+    return bbCreated;
+  }
+
+  void SetNewBBInLayout() {
+    bbCreated = true;
+  }
+
+  bool GetTryOutstanding() const {
+    return tryOutstanding;
+  }
+
+  void SetTryOutstanding(bool val) {
+    tryOutstanding = val;
+  }
+
+  bool IsBBLaidOut(BBId bbid) const {
+    return laidOut.at(bbid);
+  }
+
+  void AddLaidOut(bool val) {
+    return laidOut.push_back(val);
+  }
+  void OptimiseCFG();
+  BB *NextBBProf(BB &bb);
+  BB *GetBBFromEdges();
+  void LayoutWithProf(bool useChainLayout);
+  void LayoutWithoutProf();
+  void RunLayout();
+  void DumpBBPhyOrder() const;
+  void VerifyBB();
+
+ private:
+  void FixEndTryBB(BB &bb);
+  void FixTryBB(BB &startTryBB, BB &nextBB);
+  void DealWithStartTryBB();
+  void UpdateNewBBWithAttrTry(const BB &bb, BB &fallthru) const;
+  void SetAttrTryForTheCanBeMovedBB(BB &bb, BB &canBeMovedBB) const;
+  void RebuildFreq();
+  bool IsBBInCurrContext(const BB &bb, const MapleVector<bool> *context) const;
+  void InitBBChains();
+  void BuildChainForFunc();
+  void BuildChainForLoops();
+  void BuildChainForLoop(LoopDesc *loop, MapleVector<bool> *context);
+  BB *FindBestStartBBForLoop(LoopDesc *loop, const MapleVector<bool> *context);
+  void DoBuildChain(const BB &header, BBChain &chain, const MapleVector<bool> *context);
+  BB *GetBestSucc(BB &bb, const BBChain &chain, const MapleVector<bool> *context, bool considerBetterPredForSucc);
+  bool IsCandidateSucc(const BB &bb, const BB &succ, const MapleVector<bool> *context);
+  bool HasBetterLayoutPred(const BB &bb, BB &succ);
+
+  MeFunction &func;
+  MapleAllocator layoutAlloc;
+  MapleVector<BB*> layoutBBs;  // gives the determined layout order
+  MapleVector<bool> startTryBBVec;  // record the try BB to fix the try&endtry map
+  MapleVector<bool> bbVisited; // mark the bb as visited when accessed
+  MapleVector<BBEdge*> allEdges;
+  MapleVector<BBChain*> bb2chain;   // mapping bb id to the chain that bb belongs to
+  MapleSet<BBChain*> readyToLayoutChains;
+  IdentifyLoops *meLoop = nullptr;
+  Dominance *dom = nullptr;
+  uint32 rpoSearchPos = 0;   // reverse post order search beginning position
+  bool debugChainLayout = false;
+  bool needDealWithTryBB = false;
+  BBId curBBId { 0 };          // to index into func.bb_vec_ to return the next BB
+  bool bbCreated = false;      // new create bb will change mefunction::bb_vec_ and
+  // related analysis result
+  MapleVector<bool> laidOut;   // indexed by bbid to tell if has been laid out
+  bool tryOutstanding = false; // true if a try laid out but not its endtry
+  bool enabledDebug;
+  bool profValid = false;
+  size_t edgeIdx = 0;
+  MeCFG *cfg;
+  MaplePhase *phase;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEBBLayout, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_BB_LAYOUT_H
diff --git a/src/mapleall/maple_me/include/me_bypath_eh.h b/src/mapleall/maple_me/include/me_bypath_eh.h
new file mode 100644
index 0000000000000000000000000000000000000000..994f0dedbeb330bd3d9db402f44bb6fbb663c893
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_bypath_eh.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEME_INCLUDE_MEBYPATHEH_H
+#define MAPLEME_INCLUDE_MEBYPATHEH_H
+
+#include "bb.h"
+#include "class_hierarchy_phase.h"
+#include "mir_builder.h"
+
+namespace maple {
+class MeBypathEH {
+ public:
+  void BypathException(MeFunction &func, const KlassHierarchy &kh) const;
+ private:
+  StmtNode *IsSyncExit(BB &syncBB, const MeFunction &func, LabelIdx secondLabel) const;
+  bool DoBypathException(BB *tryBB, BB *catchBB, const Klass *catchClass, const StIdx &stIdx,
+                         const KlassHierarchy &kh, MeFunction &func, const StmtNode *syncExitStmt) const;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEBypathEH, MeFunction)
+}  // namespace maple
+#endif
diff --git a/src/mapleall/maple_me/include/me_cfg.h b/src/mapleall/maple_me/include/me_cfg.h
new file mode 100644
index 0000000000000000000000000000000000000000..380f5a2a58b042b9f3702dd2da3e3aab72dd18b8
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_cfg.h
@@ -0,0 +1,367 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_CFG_H
+#define MAPLE_ME_INCLUDE_ME_CFG_H
+#include "maple_phase.h"
+#include "me_function.h"
+
+namespace maple {
+class MeCFG : public AnalysisResult {
+  using BBPtrHolder = MapleVector<BB*>;
+
+ public:
+  using value_type = BBPtrHolder::value_type;
+  using size_type = BBPtrHolder::size_type;
+  using difference_type = BBPtrHolder::difference_type;
+  using pointer = BBPtrHolder::pointer;
+  using const_pointer = BBPtrHolder::const_pointer;
+  using reference = BBPtrHolder::reference;
+  using const_reference = BBPtrHolder::const_reference;
+  using iterator = BBPtrHolder::iterator;
+  using const_iterator = BBPtrHolder::const_iterator;
+  using reverse_iterator = BBPtrHolder::reverse_iterator;
+  using const_reverse_iterator = BBPtrHolder::const_reverse_iterator;
+
+  MeCFG(MemPool *memPool, MeFunction &f)
+      : AnalysisResult(memPool),
+        mecfgAlloc(memPool),
+        func(f),
+        patternSet(mecfgAlloc.Adapter()),
+        bbVec(mecfgAlloc.Adapter()),
+        labelBBIdMap(mecfgAlloc.Adapter()),
+        bbTryNodeMap(mecfgAlloc.Adapter()),
+        endTryBB2TryBB(mecfgAlloc.Adapter()),
+        sccTopologicalVec(mecfgAlloc.Adapter()),
+        sccOfBB(mecfgAlloc.Adapter()),
+        backEdges(mecfgAlloc.Adapter()) {
+      if (MeOption::dumpCfgOfPhases) {
+        dumpIRProfileFile = true;
+      }
+    }
+
+  ~MeCFG() = default;
+
+  bool IfReplaceWithAssertNonNull(const BB &bb) const;
+  void ReplaceWithAssertnonnull();
+  void BuildMirCFG();
+  void FixMirCFG();
+  void ConvertPhis2IdentityAssigns(BB &meBB) const;
+  bool UnreachCodeAnalysis(bool updatePhi = false);
+  void WontExitAnalysis();
+  void Verify() const;
+  void VerifyLabels() const;
+  void Dump() const;
+  void DumpToFile(const std::string &prefix, bool dumpInStrs = false, bool dumpEdgeFreq = false,
+                  const MapleVector<BB*> *laidOut = nullptr) const;
+  bool FindExprUse(const BaseNode &expr, StIdx stIdx) const;
+  bool FindUse(const StmtNode &stmt, StIdx stIdx) const;
+  bool FindDef(const StmtNode &stmt, StIdx stIdx) const;
+  bool HasNoOccBetween(StmtNode &from, const StmtNode &to, StIdx stIdx) const;
+  BB *NewBasicBlock();
+  BB &InsertNewBasicBlock(const BB &position, bool isInsertBefore = true);
+  void DeleteBasicBlock(const BB &bb);
+  BB *NextBB(const BB *bb);
+  BB *PrevBB(const BB *bb);
+  void CloneBasicBlock(BB &newBB, const BB &orig);
+  BB &SplitBB(BB &bb, StmtNode &splitPoint, BB *newBB = nullptr);
+  bool UnifyRetBBs();
+  void SplitBBPhysically(BB &bb, StmtNode &splitPoint, BB &newBB);
+
+  const MeFunction &GetFunc() const {
+    return func;
+  }
+
+  bool GetHasDoWhile() const {
+    return hasDoWhile;
+  }
+
+  void SetHasDoWhile(bool hdw) {
+    hasDoWhile = hdw;
+  }
+
+  MapleAllocator &GetAlloc() {
+    return mecfgAlloc;
+  }
+
+  void SetNextBBId(uint32 currNextBBId) {
+    nextBBId = currNextBBId;
+  }
+  uint32 GetNextBBId() const {
+    return nextBBId;
+  }
+  void DecNextBBId() {
+    --nextBBId;
+  }
+
+  MapleVector<BB*> &GetAllBBs() {
+    return bbVec;
+  }
+
+  iterator begin() {
+    return bbVec.begin();
+  }
+  const_iterator begin() const {
+    return bbVec.begin();
+  }
+  const_iterator cbegin() const {
+    return bbVec.cbegin();
+  }
+
+  iterator end() {
+    return bbVec.end();
+  }
+  const_iterator end() const {
+    return bbVec.end();
+  }
+  const_iterator cend() const {
+    return bbVec.cend();
+  }
+
+  reverse_iterator rbegin() {
+    return bbVec.rbegin();
+  }
+  const_reverse_iterator rbegin() const {
+    return bbVec.rbegin();
+  }
+  const_reverse_iterator crbegin() const {
+    return bbVec.crbegin();
+  }
+
+  reverse_iterator rend() {
+    return bbVec.rend();
+  }
+  const_reverse_iterator rend() const {
+    return bbVec.rend();
+  }
+  const_reverse_iterator crend() const {
+    return bbVec.crend();
+  }
+
+  reference front() {
+    return bbVec.front();
+  }
+
+  reference back() {
+    return bbVec.back();
+  }
+
+  const_reference front() const {
+    return bbVec.front();
+  }
+
+  const_reference back() const {
+    return bbVec.back();
+  }
+
+  bool empty() const {
+    return bbVec.empty();
+  }
+
+  size_t size() const {
+    return bbVec.size();
+  }
+  FilterIterator<const_iterator> valid_begin() const {
+    return build_filter_iterator(begin(), std::bind(FilterNullPtr<const_iterator>, std::placeholders::_1, end()));
+  }
+
+  FilterIterator<const_iterator> valid_end() const {
+    return build_filter_iterator(end());
+  }
+
+  FilterIterator<const_reverse_iterator> valid_rbegin() const {
+    return build_filter_iterator(rbegin(),
+                                 std::bind(FilterNullPtr<const_reverse_iterator>, std::placeholders::_1, rend()));
+  }
+
+  FilterIterator<const_reverse_iterator> valid_rend() const {
+    return build_filter_iterator(rend());
+  }
+
+  const_iterator common_entry() const {
+    return begin();
+  }
+
+  const_iterator context_begin() const {
+    return ++(++begin());
+  }
+
+  const_iterator context_end() const {
+    return end();
+  }
+
+  const_iterator common_exit() const {
+    return ++begin();
+  }
+
+  uint32 NumBBs() const {
+    return nextBBId;
+  }
+
+  uint32 ValidBBNum() const {
+    uint32 num = 0;
+    for (auto bbit = valid_begin(); bbit != valid_end(); ++bbit) {
+      ++num;
+    }
+    return num;
+  }
+
+  const MapleUnorderedMap<LabelIdx, BB*> &GetLabelBBIdMap() const {
+    return labelBBIdMap;
+  }
+  BB *GetLabelBBAt(LabelIdx idx) const {
+    auto it = labelBBIdMap.find(idx);
+    if (it != labelBBIdMap.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+
+  void SetLabelBBAt(LabelIdx idx, BB *bb) {
+    labelBBIdMap[idx] = bb;
+  }
+  void EraseLabelBBAt(LabelIdx idx) {
+    labelBBIdMap.erase(idx);
+  }
+
+  BB *GetBBFromID(BBId bbID) const {
+    ASSERT(bbID < bbVec.size(), "array index out of range");
+    return bbVec.at(bbID);
+  }
+
+  void NullifyBBByID(BBId bbID) {
+    ASSERT(bbID < bbVec.size(), "array index out of range");
+    bbVec.at(bbID) = nullptr;
+  }
+
+  BB *GetCommonEntryBB() const {
+    return *common_entry();
+  }
+
+  BB *GetCommonExitBB() const {
+    return *common_exit();
+  }
+
+  BB *GetFirstBB() const {
+    if (GetCommonEntryBB()->GetUniqueSucc()) {
+      return GetCommonEntryBB()->GetUniqueSucc();
+    }
+    return *(++(++valid_begin()));
+  }
+
+  BB *GetLastBB() const {
+    return *valid_rbegin();
+  }
+
+  void SetBBTryNodeMap(BB &bb, StmtNode &tryStmt) {
+    bbTryNodeMap[&bb] = &tryStmt;
+  }
+
+  const MapleUnorderedMap<BB*, StmtNode*> &GetBBTryNodeMap() const {
+    return bbTryNodeMap;
+  }
+
+  const MapleUnorderedMap<BB*, BB*> &GetEndTryBB2TryBB() const {
+    return endTryBB2TryBB;
+  }
+
+  const BB *GetTryBBFromEndTryBB(BB *endTryBB) const {
+    auto it = endTryBB2TryBB.find(endTryBB);
+    return it == endTryBB2TryBB.end() ? nullptr : it->second;
+  }
+
+  BB *GetTryBBFromEndTryBB(BB *endTryBB) {
+    auto it = endTryBB2TryBB.find(endTryBB);
+    return it == endTryBB2TryBB.end() ? nullptr : it->second;
+  }
+
+  void SetBBTryBBMap(BB *currBB, BB *tryBB) {
+    endTryBB2TryBB[currBB] = tryBB;
+  }
+  void SetTryBBByOtherEndTryBB(BB *endTryBB, BB *otherTryBB) {
+    endTryBB2TryBB[endTryBB] = endTryBB2TryBB[otherTryBB];
+  }
+
+  void CreateBasicBlocks();
+
+  const MapleVector<SCCOfBBs*> &GetSccTopologicalVec() const {
+    return sccTopologicalVec;
+  }
+  void BBTopologicalSort(SCCOfBBs &scc);
+  void BuildSCC();
+  void UpdateBranchTarget(BB &currBB, const BB &oldTarget, BB &newTarget, MeFunction &meFunc);
+  void SwapBBId(BB &bb1, BB &bb2);
+  void ConstructBBFreqFromStmtFreq();
+  void ConstructStmtFreq();
+  void ConstructEdgeFreqFromBBFreq();
+  void UpdateEdgeFreqWithBBFreq();
+  int VerifyBBFreq(bool checkFatal = false);
+  void SetUpdateCFGFreq(bool b) {
+    updateFreq = b;
+  }
+  bool UpdateCFGFreq() const {
+    return updateFreq;
+  }
+  bool DumpIRProfileFile() const {
+    return dumpIRProfileFile;
+  }
+  void ClearFuncFreqInfo();
+
+ private:
+  void AddCatchHandlerForTryBB(BB &bb, MapleVector<BB*> &exitBlocks);
+  std::string ConstructFileNameToDump(const std::string &prefix) const;
+  void DumpToFileInStrs(std::ofstream &cfgFile) const;
+  void ConvertPhiList2IdentityAssigns(BB &meBB) const;
+  void ConvertMePhiList2IdentityAssigns(BB &meBB) const;
+  bool IsStartTryBB(BB &meBB) const;
+  void FixTryBB(BB &startBB, BB &nextBB);
+  void SetTryBlockInfo(const StmtNode *nextStmt, StmtNode *tryStmt, BB *lastTryBB, BB *curBB, BB *newBB);
+
+  void VerifySCC();
+  void SCCTopologicalSort(std::vector<SCCOfBBs*> &sccNodes);
+  void BuildSCCDFS(BB &bb, uint32 &visitIndex, std::vector<SCCOfBBs*> &sccNodes, std::vector<uint32> &visitedOrder,
+                   std::vector<uint32> &lowestOrder, std::vector<bool> &inStack, std::stack<uint32> &visitStack);
+
+  MapleAllocator mecfgAlloc;
+  MeFunction &func;
+  MapleSet<LabelIdx> patternSet;
+  BBPtrHolder bbVec;
+  MapleUnorderedMap<LabelIdx, BB*> labelBBIdMap;
+  MapleUnorderedMap<BB*, StmtNode*> bbTryNodeMap;  // maps isTry bb to its try stmt
+  MapleUnorderedMap<BB*, BB*> endTryBB2TryBB;      // maps endtry bb to its try bb
+  bool hasDoWhile = false;
+  // following 2 variable are used in profileUse
+  bool updateFreq = false;         // true to maintain cfg frequency in transform phase
+  bool dumpIRProfileFile = false;  // true to dump cfg to files
+  uint32 nextBBId = 0;
+
+  // BB SCC
+  MapleVector<SCCOfBBs*> sccTopologicalVec;
+  uint32 numOfSCCs = 0;
+  MapleVector<SCCOfBBs*> sccOfBB;
+  MapleSet<std::pair<uint32, uint32>> backEdges;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MEMeCfg, MeFunction)
+MeCFG *GetResult() {
+  return theCFG;
+}
+MeCFG *theCFG = nullptr;
+MAPLE_MODULE_PHASE_DECLARE_END
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MECfgVerifyFrequency, MeFunction)
+MAPLE_FUNC_PHASE_DECLARE_END
+
+void GdbDumpToFile(MeCFG *cfg, bool dumpEdgeFreq);
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_CFG_H
diff --git a/src/mapleall/maple_me/include/me_cfg_mst.h b/src/mapleall/maple_me/include/me_cfg_mst.h
new file mode 100644
index 0000000000000000000000000000000000000000..caf356e9a8b5234713c69dd99cdb3a60f8e2052c
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_cfg_mst.h
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_CFGMST_H
+#define MAPLE_ME_INCLUDE_CFGMST_H
+#include "me_function.h"
+#include "bb.h"
+#include "me_cfg.h"
+
+namespace maple {
+template <class Edge>
+class CFGMST {
+ public:
+  CFGMST(MeFunction &func, MemPool &mp, bool dump) : func(&func), mp(&mp), dump(dump) {}
+  virtual ~CFGMST() = default;
+  BB *FindGroup(BB *bb);
+  bool UnionGroups(BB *src, BB *dest);
+  void ComputeMST();
+  void SortEdges();
+  void AddEdge(BB *src, BB *dest, uint64 w, bool isCritical = false, bool isFake = false);
+  bool IsCritialEdge(const BB *src, const BB *dest) const {
+    return src->GetSucc().size() > 1 && dest->GetPred().size() > 1;
+  }
+  const std::vector<Edge*> &GetAllEdges() const {
+    return allEdges;
+  }
+
+  size_t GetAllEdgesSize() const {
+    return allEdges.size();
+  }
+
+  uint32 GetAllBBs() const {
+    return totalBB;
+  }
+
+  void GetInstrumentEdges(std::vector<Edge*> &instrumentEdges) const {
+    for (const auto &e : allEdges) {
+      if (!e->IsInMST()) {
+        instrumentEdges.push_back(e);
+      }
+    }
+  }
+
+  void BuildEdges();
+  void DumpEdgesInfo() const;
+ private:
+  static constexpr int normalEdgeWeight = 2;
+  static constexpr int exitEdgeWeight = 3;
+  static constexpr int fakeExitEdgeWeight = 4;
+  static constexpr int criticalEdgeWeight = 4;
+  std::vector<Edge*> allEdges;
+  MeFunction *func;
+  MemPool *mp;
+  bool dump;
+  uint32 totalBB = 0;
+};
+
+template <class Edge>
+void CFGMST<Edge>::DumpEdgesInfo() const {
+  for (auto &edge : allEdges) {
+    BB *src = edge->GetSrcBB();
+    BB *dest = edge->GetDestBB();
+    LogInfo::MapleLogger() << "BB" << src->GetBBId() << "->"
+                           << "BB" << dest->GetBBId() << " weight " << edge->GetWeight();
+    if (edge->IsInMST()) {
+      LogInfo::MapleLogger() << " in Mst\n";
+    } else {
+      LogInfo::MapleLogger() << " not in  Mst\n";
+    }
+  }
+}
+
+template <class Edge>
+BB *CFGMST<Edge>::FindGroup(BB *bb) {
+  if (bb->GetGroup() != bb) {
+    BB *group = bb->GetGroup();
+    bb->SetGroup(FindGroup(group));
+  }
+  return bb->GetGroup();
+}
+
+template <class Edge>
+bool CFGMST<Edge>::UnionGroups(BB *src, BB *dest) {
+  BB *srcGroup = FindGroup(src);
+  BB *destGroup = FindGroup(dest);
+  if (srcGroup == destGroup) {
+    return false;
+  }
+  srcGroup->SetGroup(destGroup);
+  return true;
+}
+
+template <class Edge>
+void CFGMST<Edge>::ComputeMST() {
+  BuildEdges();
+  SortEdges();
+  /* only one edge means only one bb */
+  if (allEdges.size() == 1) {
+    if (dump) {
+      LogInfo::MapleLogger() << "only one edge in " << func->GetMirFunc()->GetName() << std::endl;
+    }
+    return;
+  }
+  // first,put all critial edge,with destBB is eh-handle
+  // in mst,because current doesn't support split that edge
+  for (auto &e : allEdges) {
+    if (e->IsCritical()) {
+      auto destBB = e->GetDestBB();
+      if (destBB->GetAttributes(kBBAttrIsCatch) && UnionGroups(e->GetSrcBB(), e->GetDestBB())) {
+        e->SetInMST();
+      }
+    }
+  }
+  for (auto &e : allEdges) {
+    if (UnionGroups(e->GetSrcBB(), e->GetDestBB())) {
+      e->SetInMST();
+    }
+  }
+}
+
+template <class Edge>
+void CFGMST<Edge>::AddEdge(BB *src, BB *dest, uint64 w, bool isCritical, bool isFake) {
+  if (src == nullptr || dest == nullptr) {
+    return;
+  }
+  bool found = false;
+  for (auto &edge : allEdges) {
+    if (edge->GetSrcBB() == src && edge->GetDestBB() == dest) {
+      uint64 weight = edge->GetWeight();
+      weight++;
+      edge->SetWeight(weight);
+      found = true;
+    }
+  }
+  if (!found) {
+    allEdges.emplace_back(mp->New<Edge>(src, dest, w, isCritical, isFake));
+  }
+}
+
+template <class Edge>
+void CFGMST<Edge>::SortEdges() {
+  std::stable_sort(allEdges.begin(), allEdges.end(),
+                   [](const Edge *edge1, const Edge *edge2) { return edge1->GetWeight() > edge2->GetWeight(); });
+}
+
+template <class Edge>
+void CFGMST<Edge>::BuildEdges() {
+  BB *entry = func->GetCfg()->GetCommonEntryBB();
+  BB *exit = nullptr;
+  auto eIt = func->GetCfg()->valid_end();
+  for (auto bIt = func->GetCfg()->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    if (bIt == func->GetCfg()->common_exit()) {
+      exit = *bIt;
+      continue;
+    }
+    totalBB++;
+    for (auto *succBB : bb->GetSucc()) {
+      /* exitBB incoming edge allocate high weight */
+      if (succBB->GetKind() == BBKind::kBBReturn) {
+        AddEdge(bb, succBB, exitEdgeWeight);
+        continue;
+      }
+      if (IsCritialEdge(bb, succBB)) {
+        AddEdge(bb, succBB, criticalEdgeWeight, true);
+        continue;
+      }
+      AddEdge(bb, succBB, normalEdgeWeight);
+    }
+  }
+
+  for (BB *bb : func->GetCfg()->GetCommonExitBB()->GetPred()) {
+    AddEdge(bb, exit, fakeExitEdgeWeight, false, true);
+  }
+  /* insert fake edge to keep consistent */
+  AddEdge(exit, entry, UINT64_MAX, false, true);
+}
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_CFGMST_H
diff --git a/src/mapleall/maple_me/include/me_cfg_opt.h b/src/mapleall/maple_me/include/me_cfg_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..4eca13fe7688e0e97ad1feb9b4d95bd90e284bc9
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_cfg_opt.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEME_INCLUDE_ME_CFGOPT
+#define MAPLEME_INCLUDE_ME_CFGOPT
+#include "me_function.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+class MeCfgOpt {
+ public:
+  explicit MeCfgOpt(MeIRMap *irMap) : meIrMap(irMap) {}
+
+  ~MeCfgOpt() = default;
+  bool Run(MeCFG &cfg);
+
+ private:
+  bool PreCheck(const MeCFG &cfg) const;
+  bool IsOk2Select(const MeExpr &expr0, const MeExpr &expr1) const;
+  // collect expensive ops and if there is reference, return true
+  static bool IsExpensiveOp(Opcode op);
+  bool CollectExpensiveOps(const MeExpr &meExpr, std::set<int32> &exprSet) const {
+    if (IsExpensiveOp(meExpr.GetOp())) {
+      (void)exprSet.insert(meExpr.GetExprID());
+    }
+    PrimType primType = meExpr.GetPrimType();
+    bool isRef = (primType == PTY_ref || primType == PTY_f64 || primType == PTY_f32);
+    if (isRef) {
+      return true;
+    }
+    for (size_t i = 0; i < meExpr.GetNumOpnds(); ++i) {
+      if (!CollectExpensiveOps(*meExpr.GetOpnd(i), exprSet)) {
+        isRef = false;
+      }
+    }
+    return isRef;
+  }
+
+  bool HasFloatCmp(const MeExpr &meExpr) const;
+  MeStmt *GetCondBrStmtFromBB(BB &bb) const;
+  MeStmt *GetTheOnlyMeStmtFromBB(BB &bb) const;
+  MeStmt *GetTheOnlyMeStmtWithGotoFromBB(BB &bb) const;
+  MeIRMap *meIrMap;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MECfgOpt, MeFunction)
+}  // namespace maple
+#endif  // MAPLEME_INCLUDE_ME_CFGOPT
diff --git a/src/mapleall/maple_me/include/me_check_cast.h b/src/mapleall/maple_me/include/me_check_cast.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb53a586ff729e37f6d56d3b88066e3fb4391725
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_check_cast.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEME_INCLUDE_MECHECKCAST_H
+#define MAPLEME_INCLUDE_MECHECKCAST_H
+#include "me_function.h"
+#include "me_irmap_build.h"
+#include "me_dominance.h"
+#include "me_ssi.h"
+#include "annotation_analysis.h"
+
+namespace maple {
+struct GenericNode {
+  AnnotationType *aType = nullptr;
+  GenericNode *next = nullptr;
+  bool multiOutput = false;
+};
+
+enum ProveRes {
+  kT,
+  kF,
+  kIgnore,
+};
+
+class CheckCast {
+ public:
+  CheckCast(MeFunction &func, KlassHierarchy &kh, MeSSI &ms)
+      : func(&func), klassh(&kh), meSSI(&ms) {}
+  ~CheckCast() = default;
+
+  void DoCheckCastOpt();
+  void FindRedundantChecks();
+  void DeleteRedundants();
+  void ReleaseMemory() {
+    if (graphTempMem != nullptr) {
+      delete graphTempMem;
+      graphTempAllocator.SetMemPool(nullptr);
+      graphTempMem = nullptr;
+    }
+  }
+ private:
+  void RemoveRedundantCheckCast(MeStmt &stmt, BB &bb);
+  bool ProvedByAnnotationInfo(const IntrinsiccallMeStmt &callNode);
+  void TryToResolveCall(MeStmt &meStmt);
+  bool TryToResolveVar(VarMeExpr &var, MIRStructType *callStruct = nullptr, bool checkFirst = false);
+  void TryToResolveDassign(MeStmt &meStmt);
+  GenericNode *GetOrCreateGenericNode(AnnotationType *annoType);
+  void BuildGenericGraph(AnnotationType *annoType);
+  MIRType *TryToResolveType(GenericNode &retNode);
+  bool TryToResolveStaticVar(const VarMeExpr &var);
+  void TryToResolveIvar(IvarMeExpr &ivar, MIRStructType *callStruct = nullptr);
+  void TryToResolveFuncArg(MeExpr &expr, AnnotationType &at);
+  void TryToResolveFuncGeneric(MIRFunction &callee, const CallMeStmt &callMeStmt, size_t thisIdx);
+  void AddClassInheritanceInfo(MIRType &mirType);
+  bool NeedChangeVarType(MIRStructType *varStruct, MIRStructType *callStruct);
+  bool ExactlyMatch(MIRStructType &varStruct, MIRStructType &callStruct);
+  AnnotationType *CloneNewAnnotationType(AnnotationType *at, MIRStructType *callStruct);
+  void AddNextNode(GenericNode &from, GenericNode &to) const;
+  bool RetIsGenericRelative(MIRFunction &callee);
+  void DumpGenericGraph();
+  void DumpGenericNode(GenericNode &node, std::ostream &out);
+
+  bool ProvedBySSI(const IntrinsiccallMeStmt &callNode);
+  ProveRes TraverseBackProve(MeExpr &expr, MIRType &targetType, std::set<MePhiNode*> &visitedPhi);
+  std::map<AnnotationType*, GenericNode*> created;
+  std::set<GenericNode*> visited;
+  MeFunction *func;
+  KlassHierarchy *klassh;
+  MeSSI *meSSI;
+  MemPool *graphTempMem { new ThreadLocalMemPool(memPoolCtrler, "graph mempool tmp") };
+  MapleAllocator graphTempAllocator { graphTempMem };
+  MIRType *curCheckCastType { nullptr };
+  std::vector<MeStmt*> redundantChecks;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MECheckCastOpt, MeFunction)
+}  // namespace maple
+#endif  // MAPLEME_INCLUDE_MECONDBASEDNPC_H
diff --git a/src/mapleall/maple_me/include/me_cond_based.h b/src/mapleall/maple_me/include/me_cond_based.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbdfce29f6b35beb8f039a85adce19663df9a063
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_cond_based.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MECONDBASED_H
+#define MAPLE_ME_INCLUDE_MECONDBASED_H
+
+#include "me_function.h"
+#include "maple_phase_manager.h"
+#include "me_irmap_build.h"
+
+namespace maple {
+class MeCondBased {
+ public:
+  MeCondBased(MeFunction &func, Dominance &dom, Dominance &pdom) : func(&func), dominance(&dom), postDominance(&pdom) {}
+
+  ~MeCondBased() = default;
+  bool NullValueFromTestCond(const VarMeExpr&, const BB&, bool) const;
+  bool IsNotNullValue(const VarMeExpr&, const UnaryMeStmt&, const BB&) const;
+
+  const MeFunction *GetFunc() const {
+    return func;
+  }
+
+ private:
+  bool NullValueFromOneTestCond(const VarMeExpr&, const BB&, const BB&, bool) const;
+  bool PointerWasDereferencedBefore(const VarMeExpr&, const UnaryMeStmt&, const BB&) const;
+  bool PointerWasDereferencedRightAfter(const VarMeExpr&, const UnaryMeStmt&) const;
+  bool IsIreadWithTheBase(const VarMeExpr&, const MeExpr&) const;
+  bool StmtHasDereferencedBase(const MeStmt&, const VarMeExpr&) const;
+
+  MeFunction *func;
+  Dominance *dominance;
+  Dominance *postDominance;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MECONDBASED_H
diff --git a/src/mapleall/maple_me/include/me_cond_based_npc.h b/src/mapleall/maple_me/include/me_cond_based_npc.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ab741cddc3224e294d19c63db02ac5c1ab35c8e
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_cond_based_npc.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MECONDBASEDNPC_H
+#define MAPLE_ME_INCLUDE_MECONDBASEDNPC_H
+#include "me_cond_based.h"
+
+namespace maple {
+class CondBasedNPC : public MeCondBased {
+ public:
+  CondBasedNPC(MeFunction &func, Dominance &dom, Dominance &pdom) : MeCondBased(func, dom, pdom) {}
+
+  ~CondBasedNPC() = default;
+  void DoCondBasedNPC() const;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MECondBasedNPC, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MECONDBASEDNPC_H
diff --git a/src/mapleall/maple_me/include/me_cond_based_rc.h b/src/mapleall/maple_me/include/me_cond_based_rc.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad7518baf05badbc16ef29fc26bcf04d0407d883
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_cond_based_rc.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MECONDBASEDRC_H
+#define MAPLE_ME_INCLUDE_MECONDBASEDRC_H
+#include "me_cond_based.h"
+
+namespace maple {
+class CondBasedRC : public MeCondBased {
+ public:
+  CondBasedRC(MeFunction &f, Dominance &dom, Dominance &pdom) : MeCondBased(f, dom, pdom) {}
+
+  virtual ~CondBasedRC() = default;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MECondBasedRC, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MECONDBASEDRC_H
diff --git a/src/mapleall/maple_me/include/me_const.h b/src/mapleall/maple_me/include/me_const.h
new file mode 100644
index 0000000000000000000000000000000000000000..ada8a38fe322926b732ccbada5bfa00cc0578834
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_const.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_ME_CONST_H
+#define MAPLE_ME_INCLUDE_ME_CONST_H
+#include <string>
+
+// define consts used by maple_me
+namespace maple {
+const std::string kStrThisPointer = "_this";
+}
+#endif  // MAPLE_ME_INCLUDE_ME_CONST_H
diff --git a/src/mapleall/maple_me/include/me_critical_edge.h b/src/mapleall/maple_me/include/me_critical_edge.h
new file mode 100644
index 0000000000000000000000000000000000000000..979c6f4c54282ddc479633bf88e982aaa144a98b
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_critical_edge.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MECRITICALEDGE_H
+#define MAPLE_ME_INCLUDE_MECRITICALEDGE_H
+
+#include "bb.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+// Split critical edge
+class MeSplitCEdge {
+ public:
+  explicit MeSplitCEdge(bool enableDebug) : isDebugFunc(enableDebug) {}
+  virtual ~MeSplitCEdge() = default;
+  void BreakCriticalEdge(MeFunction &func, BB &pred, BB &succ) const;
+  static bool IsCriticalEdgeBB(const BB &bb); // Is a critical edge cut by bb
+  bool SplitCriticalEdgeForMeFunc(MeFunction &func) const; // find all critical edge in func and split
+  bool SplitCriticalEdgeForBB(MeFunction &func, BB &bb) const; // find critical edge around bb
+ private:
+  void UpdateGotoLabel(BB &newBB, MeFunction &func, BB &pred, BB &succ) const;
+  void UpdateCaseLabel(BB &newBB, MeFunction &func, BB &pred, BB &succ) const;
+  void UpdateNewBBInTry(const MeFunction &func, BB &newBB, const BB &pred) const;
+  void DealWithTryBB(const MeFunction &func, BB &pred, BB &succ, BB *&newBB, bool &isInsertAfterPred) const;
+
+  bool isDebugFunc = false;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MESplitCEdge, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MECRITICALEDGE_H
diff --git a/src/mapleall/maple_me/include/me_delegate_rc.h b/src/mapleall/maple_me/include/me_delegate_rc.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbecf65d7827cc5b83c0418e0a6ab506c3b7f650
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_delegate_rc.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEDELEGATERC_H
+#define MAPLE_ME_INCLUDE_MEDELEGATERC_H
+#include "me_function.h"
+#include "me_irmap.h"
+
+namespace maple {
+class DelegateRC {
+ public:
+  DelegateRC(MeFunction &func, Dominance &dom, MemPool *memPool, bool enabledDebug)
+      : func(func),
+        irMap(*func.GetIRMap()),
+        ssaTab(*func.GetMeSSATab()),
+        dominance(dom),
+        delegateRCAllocator(memPool),
+        verStCantDelegate(irMap.GetVerst2MeExprTable().size(), false, delegateRCAllocator.Adapter()),
+        verStUseCounts(irMap.GetVerst2MeExprTable().size(), 0, delegateRCAllocator.Adapter()),
+        refVar2RegMap(delegateRCAllocator.Adapter()),
+        verStDerefedCopied(irMap.GetVerst2MeExprTable().size(), false, delegateRCAllocator.Adapter()),
+        verStCantDecrefEarly(irMap.GetVerst2MeExprTable().size(), false, delegateRCAllocator.Adapter()),
+        enabledDebug(enabledDebug) {}
+
+  virtual ~DelegateRC() = default;
+
+  void SetCantDelegateAndCountUses();
+  void DelegateStmtRC();
+  std::set<OStIdx> RenameAndGetLiveLocalRefVar();
+  void CleanUpDeadLocalRefVar(const std::set<OStIdx> &liveLocalrefvars);
+
+ private:
+  bool IsCopiedOrDerefedOp(Opcode op) const;
+  void CollectVstCantDecrefEarly(MeExpr &opnd0, MeExpr &opnd1);
+  void CollectUseCounts(const MeExpr &expr);
+  void FindAndDecrUseCount(const VarMeExpr &rhsVar, const MeExpr &expr, int32 &remainingUses) const;
+  bool MayThrowException(const MeStmt &stmt) const;
+  bool ContainAllTheUses(const VarMeExpr &rhsVar, const MeStmt &fromStmt, const MeStmt &toStmt) const;
+  RegMeExpr *RHSTempDelegated(MeExpr &rhs, const MeStmt &useStmt);
+  bool FinalRefNoRC(const MeExpr &expr) const;
+  void SetCantDelegate(const MapleMap<OStIdx, MePhiNode*> &meVarPhiList);
+  void SaveDerefedOrCopiedVst(const MeExpr *expr);
+  void CollectDerefedOrCopied(const MeStmt &stmt);
+  void CollectDerefedOrCopied(const MeExpr &expr);
+  void CollectUsesInfo(const MeExpr &expr);
+  bool CanOmitRC4LHSVar(const MeStmt &stmt, bool &onlyWithDecref) const;
+  void DelegateHandleNoRCStmt(MeStmt &stmt, bool addDecref);
+  void DelegateRCTemp(MeStmt &stmt);
+  void RenameDelegatedRefVarUses(MeStmt &meStmt, MeExpr &meExpr);
+
+  MeFunction &func;
+  IRMap &irMap;
+  SSATab &ssaTab;
+  Dominance &dominance;
+  MapleAllocator delegateRCAllocator;
+  MapleVector<bool> verStCantDelegate;             // true if it has appearance as phi opnd
+  MapleVector<uint32> verStUseCounts;              // use counts of each SSA version
+  MapleMap<VarMeExpr*, RegMeExpr*> refVar2RegMap;  // map to the replacement preg
+  MapleVector<bool> verStDerefedCopied;            // true if it is dereferenced or copied or passed as parameter
+  MapleVector<bool> verStCantDecrefEarly;          // true if it is unsafe to insert early decref in form B1 delegation
+  bool enabledDebug;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEDelegateRC, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MEDELEGATERC_H
diff --git a/src/mapleall/maple_me/include/me_dominance.h b/src/mapleall/maple_me/include/me_dominance.h
new file mode 100644
index 0000000000000000000000000000000000000000..6592d50e8cd2c08f6605130f5e76a8a113de1ea0
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_dominance.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_DOMINANCE_H
+#define MAPLE_ME_INCLUDE_ME_DOMINANCE_H
+#include "dominance.h"
+#include "me_function.h"
+#include "maple_phase.h"
+
+namespace maple {
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MEDominance, MeFunction)
+  Dominance *GetDomResult() {
+    return dom;
+  }
+
+  Dominance *GetPdomResult() {
+    return pdom;
+  }
+ private:
+  Dominance *dom = nullptr;
+  Dominance *pdom = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_MODULE_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_DOMINANCE_H
diff --git a/src/mapleall/maple_me/include/me_dse.h b/src/mapleall/maple_me/include/me_dse.h
new file mode 100644
index 0000000000000000000000000000000000000000..aaeb129f3c607925c2ab69619d854bfa086bfd78
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_dse.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEDSE_H
+#define MAPLE_ME_INCLUDE_MEDSE_H
+#include "bb.h"
+#include "dse.h"
+
+namespace maple {
+class MeDSE : public DSE {
+ public:
+  MeDSE(MeFunction &func, Dominance *dom, Dominance *pdom, const AliasClass *aliasClass, bool enabledDebug);
+  virtual ~MeDSE() = default;
+
+  void RunDSE();
+
+ private:
+  MeFunction &func;
+  MeCFG *cfg;
+  void VerifyPhi() const;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEDse, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MEDSE_H
diff --git a/src/mapleall/maple_me/include/me_emit.h b/src/mapleall/maple_me/include/me_emit.h
new file mode 100644
index 0000000000000000000000000000000000000000..4775981f4a97b38a6ed6f7987acd2fec62738a89
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_emit.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_EMIT_H
+#define MAPLE_ME_INCLUDE_ME_EMIT_H
+#include "me_function.h"
+#include "maple_phase.h"
+
+// emit ir to specified file
+namespace maple {
+MAPLE_FUNC_PHASE_DECLARE(MEEmit, MeFunction)
+MAPLE_FUNC_PHASE_DECLARE(ProfileGenEmit, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_EMIT_H
diff --git a/src/mapleall/maple_me/include/me_fsaa.h b/src/mapleall/maple_me/include/me_fsaa.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6343b3c6f24e64e14bdaddbc8b2f7eafaaeb740
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_fsaa.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_FSAA_H
+#define MAPLE_ME_INCLUDE_ME_FSAA_H
+#include "me_option.h"
+#include "me_function.h"
+#include "me_dominance.h"
+#include "me_ssa_tab.h"
+#include "maple_phase.h"
+
+namespace maple {
+class FSAA {
+ public:
+  FSAA(MeFunction *f, Dominance *dm)
+      : func(f), mirModule(&f->GetMIRModule()), ssaTab(f->GetMeSSATab()), dom(dm) {}
+  ~FSAA() {}
+
+  BB *FindUniquePointerValueDefBB(VersionSt *vst);
+  void ProcessBB(BB *bb);
+
+  bool needUpdateSSA = false;
+ private:
+  bool IfChiSameAsRHS(const VersionSt &chiOpnd, const VersionSt &rhsVst, const BaseNode &rhsOrigSrc);
+  void RemoveMayDefIfSameAsRHS(const IassignNode &stmt);
+  void RemoveMayDefByIreadRHS(const IreadSSANode &rhs, TypeOfMayDefList &mayDefNodes);
+  void RemoveMayDefByDreadRHS(const AddrofSSANode &rhs, TypeOfMayDefList &mayDefNodes);
+  void EraseMayDefItem(TypeOfMayDefList &mayDefNodes, MapleMap<OStIdx, MayDefNode>::iterator &it, bool canBeErased);
+
+  MeFunction *func;
+  MIRModule *mirModule;
+  SSATab *ssaTab;
+  Dominance *dom;
+
+  std::string PhaseName() const {
+    return "fsaa";
+  }
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEFSAA, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_FSAA_H
diff --git a/src/mapleall/maple_me/include/me_func_opt.h b/src/mapleall/maple_me/include/me_func_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..488576aa41840280ece09dfb1b8ed07a9f8d5ace
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_func_opt.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_FUNC_OPT_H
+#define MAPLE_ME_INCLUDE_ME_FUNC_OPT_H
+#include <memory>
+#include "mpl_scheduler.h"
+#include "me_phase_manager.h"
+
+namespace maple {
+#ifdef NOT_USED
+class MeFuncOptTask : public MplTask {
+ public:
+  MeFuncOptTask(MIRModule &mod, MIRFunction &func, size_t rangeNum, const std::string &meInput)
+      : module(mod), mirFunc(func), rangeNum(rangeNum), meInput(meInput) {}
+  ~MeFuncOptTask() override = default;
+  int RunImpl(MplTaskParam *param) override;
+
+ private:
+  MIRModule &module;
+  MIRFunction &mirFunc;
+  size_t rangeNum;
+  const std::string &meInput;
+};
+
+class MeFuncOptExecutor : public MplTaskParam {
+ public:
+  MeFuncOptExecutor(std::unique_ptr<MemPoolCtrler> mpCtrler, MeFuncPhaseManager &fpm)
+      : mpCtrler(std::move(mpCtrler)), fpm(fpm) {}
+
+  ~MeFuncOptExecutor() = default;
+
+  std::unique_ptr<MeFuncOptExecutor> Clone() const;
+  void ProcessRun(MIRFunction &mirFunc, size_t rangeNum, const std::string &meInput);
+
+ private:
+  std::unique_ptr<MemPoolCtrler> mpCtrler;
+  MeFuncPhaseManager &fpm;
+};
+
+class MeFuncOptScheduler : public MplScheduler {
+ public:
+  MeFuncOptScheduler(const std::string &name, std::unique_ptr<MeFuncOptExecutor> funcOpt)
+      : MplScheduler(name), funcOpt(std::move(funcOpt)) {}
+
+  ~MeFuncOptScheduler() override {}
+
+  void CallbackThreadMainStart() override;
+  void CallbackThreadMainEnd() override;
+  void AddFuncOptTask(MIRModule &module, MIRFunction &mirFunc, size_t rangeNum, const std::string &meInput);
+
+ protected:
+  MplTaskParam *CallbackGetTaskRunParam() const override;
+  MplTaskParam *CallbackGetTaskFinishParam() const override;
+
+ private:
+  thread_local static std::unique_ptr<MeFuncOptExecutor> funcOptLocal;
+  std::unique_ptr<MeFuncOptExecutor> funcOpt;
+  std::vector<std::unique_ptr<MplTask>> tasksUniquePtr;
+};
+#endif
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_FUNC_OPT_H
diff --git a/src/mapleall/maple_me/include/me_function.h b/src/mapleall/maple_me/include/me_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..33169261da8028613b68a25000c34a94cc35955e
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_function.h
@@ -0,0 +1,412 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_FUNCTION_H
+#define MAPLE_ME_INCLUDE_ME_FUNCTION_H
+#include "mir_parser.h"
+#include "mir_function.h"
+#include "opcode_info.h"
+#include "me_option.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "ver_symbol.h"
+#include "bb.h"
+#include "ssa_tab.h"
+#include "func_emit.h"
+#include "me_ir.h"
+#include "profile.h"
+#include "pme_function.h"
+
+namespace maple {
+class MeCFG;  // circular dependency exists, no other choice
+class MeIRMap;  // circular dependency exists, no other choice
+#if DEBUG
+extern MIRModule *globalMIRModule;
+extern MeFunction *globalFunc;
+extern MeIRMap *globalIRMap;
+extern SSATab *globalSSATab;
+#endif
+
+template <typename Iterator>
+class FilterIterator {
+ public:
+  using FilterFunc = std::function<bool(Iterator)>;
+  using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
+  using value_type = typename std::iterator_traits<Iterator>::value_type;
+  using difference_type = typename std::iterator_traits<Iterator>::difference_type;
+  using pointer = typename std::iterator_traits<Iterator>::pointer;
+  using reference = typename std::iterator_traits<Iterator>::reference;
+  using const_pointer = typename std::add_const<pointer>::type;
+  using const_reference = typename std::add_const<reference>::type;
+
+  explicit FilterIterator(Iterator it) : iterator(it) {}
+
+  FilterIterator(Iterator it, FilterFunc func) : iterator(it), func(func) {
+    while (!func(iterator)) {
+      ++iterator;
+    }
+  }
+
+  ~FilterIterator() = default;
+
+  Iterator base() const {
+    return iterator;
+  }
+
+  reference operator*() const {
+    return *iterator;
+  }
+
+  pointer operator->() const {
+    return iterator.operator->();
+  }
+
+  FilterIterator &operator++() {
+    ++iterator;
+    return func(iterator) ? *this : ++(*this);
+  }
+
+  FilterIterator &operator--() {
+    --iterator;
+    return func(iterator) ? *this : --(*this);
+  }
+
+  const FilterIterator operator++(int) {
+    FilterIterator it = *this;
+    ++(*this);
+    return it;
+  }
+
+  const FilterIterator operator--(int) {
+    FilterIterator it = *this;
+    --(*this);
+    return it;
+  }
+
+  bool operator==(const FilterIterator &it) const {
+    return this->iterator == it.iterator;
+  }
+
+  bool operator!=(const FilterIterator &it) const {
+    return !(*this == it);
+  }
+
+  bool operator==(const Iterator &it) const {
+    return this->iterator == it;
+  }
+
+  bool operator!=(const Iterator &it) const {
+    return !(*this == it);
+  }
+
+ private:
+  static bool FilterNone(Iterator) {
+    return true;
+  }
+  Iterator iterator;
+  FilterFunc func = FilterIterator::FilterNone;
+};
+
+template <typename Iterator>
+inline auto build_filter_iterator(Iterator it) -> FilterIterator<Iterator> {
+  return FilterIterator<Iterator>(it);
+}
+
+template <typename Iterator, typename _Func>
+inline auto build_filter_iterator(Iterator it, _Func func) -> FilterIterator<Iterator> {
+  return FilterIterator<Iterator>(it, std::function<bool(Iterator)>(func));
+}
+
+template <typename Iterator>
+inline auto build_filter_iterator(Iterator it, std::function<bool(Iterator)> func) -> FilterIterator<Iterator> {
+  return FilterIterator<Iterator>(it, func);
+}
+
+template <typename Iterator>
+bool FilterNullPtr(Iterator it, Iterator endIt) {
+  return it == endIt || *it != nullptr;
+}
+
+enum MeFuncHint {
+    kReserved      = 0x00,       // reserved
+    kPlacementRCed = 0x01,       // method processed by placementrc
+    kAnalyzeRCed   = 0x02,       // method processed by analyzerc
+    kRcLowered     = 0x04,       // method lowered by rclowering
+};
+
+class MeFunction : public FuncEmit {
+ public:
+  MeFunction(MIRModule *mod, MIRFunction *func, MemPool *memPool, StackMemPool &funcStackMP, MemPool *versMemPool,
+             const std::string &fileName)
+      : memPool(memPool),
+        stackMP(funcStackMP),
+        alloc(memPool),
+        versMemPool(versMemPool),
+        versAlloc(versMemPool),
+        mirModule(*mod),
+        mirFunc(func),
+        laidOutBBVec(alloc.Adapter()),
+        fileName(fileName, memPool),
+        preMeFunc(nullptr),
+        preMeMp(nullptr) {}
+
+  ~MeFunction() override = default;
+  void DumpFunction() const;
+  void DumpFunctionNoSSA() const;
+  void DumpMayDUFunction() const;
+  void Dump(bool DumpSimpIr = false) const;
+  void IPAPrepare();
+  virtual void Prepare();
+  void Verify() const;
+  const std::string &GetName() const {
+    return mirFunc->GetName();
+  }
+
+  VersionSt *GetVerSt(size_t veridx) const {
+    return meSSATab->GetVerSt(veridx);
+  }
+
+  /* get or create label for bb */
+  LabelIdx GetOrCreateBBLabel(BB &bb);
+
+  bool IsEmpty() const { return mirFunc->IsEmpty(); }
+
+  bool HasException() const {
+    return hasEH;
+  }
+
+  MapleAllocator &GetAlloc() {
+    return alloc;
+  }
+  MapleAllocator &GetVersAlloc() {
+    return versAlloc;
+  }
+  MemPool *GetVersMp() {
+    // version mempool may be release if invalid
+    if (versMemPool == nullptr) {
+      versMemPool = new ThreadLocalMemPool(memPoolCtrler, "verst mempool");
+      versAlloc.SetMemPool(versMemPool);
+    }
+    return versMemPool;
+  }
+
+  void ReleaseVersMemory() {
+    if (versMemPool) {
+      memPoolCtrler.DeleteMemPool(versMemPool);
+      versMemPool = nullptr;
+      versAlloc.SetMemPool(nullptr);
+    }
+  }
+
+  const MapleVector<BB*> &GetLaidOutBBs() const {
+    return laidOutBBVec;
+  }
+
+  void SetLaidOutBBs(const MapleVector<BB*> &laidout) {
+    laidOutBBVec = laidout;
+  }
+
+  bool HasLaidOut() const {
+    return !laidOutBBVec.empty();
+  }
+
+  void ClearLayout() {
+    if (laidOutBBVec.empty()) {
+      return;
+    }
+    laidOutBBVec.clear();
+  }
+
+  SSATab *GetMeSSATab() {
+    return meSSATab;
+  }
+  void SetMeSSATab(SSATab *currMessaTab) {
+    meSSATab = currMessaTab;
+  }
+
+  MIRFunction *GetMirFunc() {
+    return mirFunc;
+  }
+
+  MIRModule &GetMIRModule() const {
+    return mirModule;
+  }
+
+  MeIRMap *GetIRMap() {
+    return irmap;
+  }
+
+  void SetIRMap(MeIRMap *currIRMap) {
+    irmap = currIRMap;
+  }
+
+  MeCFG *GetCfg() const {
+    return theCFG;
+  }
+
+  void SetTheCfg(MeCFG *currTheCfg) {
+    theCFG = currTheCfg;
+  }
+
+  uint32 GetRegNum() const {
+    return regNum;
+  }
+
+  void SetRegNum(uint32 num) {
+    regNum = num;
+  }
+
+  uint32 GetHints() const {
+    return hints;
+  }
+
+  void SetHints(uint32 num) {
+    hints = num;
+  }
+
+  MemPool *GetMemPool() {
+    return memPool;
+  }
+
+  StackMemPool &GetStackMemPool() {
+    return stackMP;
+  }
+
+  void AddProfileDesc(uint64 hash, uint32 start, uint32 end) {
+    mirFunc->AddProfileDesc(hash, start, end);
+  }
+
+  const IRProfileDesc *GetProfInf() {
+    if (profileDesc == nullptr) {
+      // return profileDesc with default value
+      profileDesc = memPool->New<IRProfileDesc>();
+    }
+    return profileDesc;
+  }
+  bool IsIRProfValid() const {
+    return profValid;
+  }
+
+  void SetProfValid(bool val) {
+    profValid = val;
+  }
+
+  uint64 GetFrequency() const {
+    return frequency;
+  }
+
+  void SetFrequency(uint64 f) {
+    frequency = f;
+  }
+
+  void SetHasWriteInputAsmNode() {
+    hasWriteInputAsmNode = true;
+  };
+
+  bool HasWriteInputAsmNode() const {
+    return hasWriteInputAsmNode;
+  }
+
+  uint32 GetUniqueID() const {
+    return mirFunc->GetPuidx();
+  }
+
+  bool IsUnSafe() const {
+    return !mirFunc->GetAttr(FUNCATTR_safed) || mirFunc->GetAttr(FUNCATTR_unsafed);
+  }
+
+  bool IsSafe() const {
+    return mirFunc->GetAttr(FUNCATTR_safed);
+  }
+
+  void PartialInit();
+
+  void Release();
+
+  MIRFunction *CurFunction() const {
+    return mirModule.CurFunction();
+  }
+  void SetPreMeFunc(PreMeFunction *lfoF) { preMeFunc = lfoF; }
+  PreMeFunction *GetPreMeFunc() { return preMeFunc; }
+  void SetPmeMempool(MemPool *mp) { preMeMp = mp; }
+  MemPool *GetPmeMempool() { return preMeMp; }
+  bool IsLfo() const { return isLfo; }
+  void SetLfo(bool islfo) { isLfo = islfo; }
+  bool IsPme() const { return isPme; }
+  void SetPme(bool set) { isPme = set; }
+  void CloneBBMeStmts(BB &srcBB, BB &destBB, std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *ssaCands = nullptr,
+                      bool copyWithoutLastMe = false);
+  bool IsTopLevelSSAValid() const {
+    return static_cast<bool>(state & kSSATopLevel);
+  }
+  bool IsAddrTakenSSAValid() const {
+    return static_cast<bool>(state & kSSAAddrTaken);
+  }
+  bool IsMemSSAValid() const {
+    return IsTopLevelSSAValid() && IsAddrTakenSSAValid();
+  }
+  bool IsMeIRAvailable() const {
+    return static_cast<bool>(state & kSSAHSSA);
+  }
+  bool IsMplIRAvailable() const {
+    return !static_cast<bool>(state & kSSAHSSA);
+  }
+
+  void ResetMeFuncState(uint8 s) {
+    state &= static_cast<uint8_t>(~s);
+  }
+
+  void SetMeFuncState(uint8 s) {
+    state |= s;
+  }
+
+  uint32 dseRuns = 0;   // number of times dse phase has been run
+  uint32 hdseRuns = 0;  // number of times hdse phase has been run
+  uint32 hpropRuns = 0; // number of times hprop phase has been run
+  uint32 vrpRuns = 0; // number of times vrp phase has been run
+  uint32 jumpThreadingRuns = 0; // number of times jump threading phase has been run
+  bool genLMBC = false; // whether outputing lmbc (low maple bytecode)
+
+ private:
+  MemPool *memPool;
+  StackMemPool &stackMP;
+  MapleAllocator alloc;
+  MemPool *versMemPool;
+  MapleAllocator versAlloc;
+  MIRModule &mirModule;
+  MIRFunction *mirFunc;
+  /* mempool */
+  MapleVector<BB*> laidOutBBVec;
+  MeCFG *theCFG = nullptr;
+  SSATab *meSSATab = nullptr;
+  MeIRMap *irmap = nullptr;
+  /* input */
+  MapleString fileName;
+  uint32 regNum = 0;    // count virtual registers
+  uint32 hints = 0;
+  bool hasEH = false;       /* current has try statement */
+  bool hasWriteInputAsmNode = false; /* set when ssa tab build */
+  bool profValid = false;
+  IRProfileDesc *profileDesc = nullptr;
+  uint64 frequency = 0;
+  // lfo
+  bool isLfo = false;
+  // during pme processing
+  bool isPme = false;
+  PreMeFunction *preMeFunc;
+  MemPool *preMeMp; // used for lfo function
+  uint8 state = 0;  // current state : ssa level and ir flavor
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_FUNCTION_H
diff --git a/src/mapleall/maple_me/include/me_gc_lowering.h b/src/mapleall/maple_me/include/me_gc_lowering.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7bdbf4bb50f267580ce8f70d1a41fe851b44ea1
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_gc_lowering.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_GC_LOWERING_H
+#define MAPLE_ME_INCLUDE_ME_GC_LOWERING_H
+#include "me_function.h"
+#include "me_irmap.h"
+#include "mir_builder.h"
+#include "me_cfg.h"
+#include "me_irmap_build.h"
+
+namespace maple {
+class GCLowering {
+ public:
+  GCLowering(MeFunction &f, bool enabledDebug)
+      : func(f),
+        mirModule(f.GetMIRModule()),
+        cfg(f.GetCfg()),
+        irMap(*f.GetIRMap()),
+        ssaTab(*f.GetMeSSATab()),
+        enabledDebug(enabledDebug) {}
+
+  ~GCLowering() = default;
+
+  void Prepare();
+  void GCLower();
+  void Finish();
+
+ private:
+  void GCLower(BB &bb);
+  void HandleAssignMeStmt(MeStmt &stmt);
+  void HandleVarAssignMeStmt(MeStmt &stmt);
+  void HandleIvarAssignMeStmt(MeStmt &stmt);
+  MeExpr *GetBase(IvarMeExpr &ivar);
+  MIRIntrinsicID SelectWriteBarrier(const MeStmt &stmt);
+  MIRIntrinsicID PrepareVolatileCall(const MeStmt &stmt, MIRIntrinsicID intrnId);
+  void HandleWriteReferent(IassignMeStmt &stmt);
+  void CheckRefs();
+  void ParseCheckFlag();
+  void CheckFormals();
+  void CheckRefsInAssignStmt(BB &bb);
+  void CheckRefReturn(BB &bb);
+
+  MeFunction &func;
+  MIRModule &mirModule;
+  MeCFG *cfg;
+  IRMap &irMap;
+  SSATab &ssaTab;
+  bool isReferent = false;
+  bool enabledDebug;
+  bool checkRefFormal = false;
+  bool checkRefAssign = false;
+  bool checkRefReturn = false;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEGCLowering, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_GC_LOWERING_H
diff --git a/src/mapleall/maple_me/include/me_gc_write_barrier_opt.h b/src/mapleall/maple_me/include/me_gc_write_barrier_opt.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab6e658c8d220b7ce71bce3cd40bb574a44db5ce
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_gc_write_barrier_opt.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_GC_WRITE_BARRIER_OPT_H
+#define MAPLE_ME_INCLUDE_ME_GC_WRITE_BARRIER_OPT_H
+#include "me_function.h"
+#include "me_irmap.h"
+
+namespace maple {
+class GCWriteBarrierOpt {
+ public:
+  GCWriteBarrierOpt(MeFunction &f, Dominance &dom, Dominance &pdom, bool enabledDebug)
+      : func(f),
+        mirModule(f.GetMIRModule()),
+        irMap(*f.GetIRMap()),
+        ssaTab(*f.GetMeSSATab()),
+        dominance(dom),
+        postDominance(pdom),
+        callBBs(0, false),
+        visited(0, false),
+        enabledDebug(enabledDebug) {}
+
+  ~GCWriteBarrierOpt() = default;
+
+  void Prepare();
+  void GCLower(BB &bb, std::map<OStIdx, std::vector<MeStmt*>> &writeBarrierMap);
+  void Finish();
+
+ private:
+  bool IsWriteBarrier(const MeStmt &stmt) const;
+  void ResetMeStmt(IntrinsiccallMeStmt &stmt);
+  OStIdx GetOStIdx(MeExpr &meExpr);
+  bool IsCall(const MeStmt &stmt) const;
+  bool HasYieldPoint(const MeStmt &start, const MeStmt &end);
+  bool HasCallAfterStmt(const MeStmt &stmt);
+  bool HasCallBeforeStmt(const MeStmt &stmt);
+  bool HasCallBetweenStmt(const MeStmt &start, const MeStmt &end);
+  bool IsBackEdgeDest(const BB &bb);
+  bool HasCallInBB(const BB &bb);
+
+  MeFunction &func;
+  MIRModule &mirModule;
+  IRMap &irMap;
+  SSATab &ssaTab;
+  Dominance &dominance;
+  Dominance &postDominance;
+  std::vector<bool> callBBs;
+  std::vector<bool> visited;
+  bool enabledDebug;
+};
+
+#ifdef NOT_USED
+class MeDoGCWriteBarrierOpt : public MeFuncPhase {
+ public:
+  explicit MeDoGCWriteBarrierOpt(MePhaseID id) : MeFuncPhase(id) {}
+
+  virtual ~MeDoGCWriteBarrierOpt() = default;
+  AnalysisResult *Run(MeFunction*, MeFuncResultMgr*, ModuleResultMgr*) override;
+  std::string PhaseName() const override {
+    return "GCWriteBarrierOpt";
+  }
+};
+#endif
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_GC_WRITE_BARRIER_OPT_H
diff --git a/src/mapleall/maple_me/include/me_hdse.h b/src/mapleall/maple_me/include/me_hdse.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8172ba09295ed0362eaa5ac76e96b42e7f453a3
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_hdse.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEHDSE_H
+#define MAPLE_ME_INCLUDE_MEHDSE_H
+#include <iostream>
+#include "bb.h"
+#include "me_cfg.h"
+#include "me_option.h"
+#include "me_dominance.h"
+#include "me_alias_class.h"
+#include "me_irmap_build.h"
+#include "hdse.h"
+
+namespace maple {
+class MeHDSE : public HDSE {
+ public:
+  MeHDSE(MeFunction &f, Dominance &dom, Dominance &pdom, IRMap &map, const AliasClass *aliasClass, bool enabledDebug)
+      : HDSE(f.GetMIRModule(), f.GetCfg()->GetAllBBs(), *f.GetCfg()->GetCommonEntryBB(), *f.GetCfg()->GetCommonExitBB(),
+             dom, pdom, map, aliasClass, enabledDebug, MeOption::decoupleStatic), func(f) {}
+
+  virtual ~MeHDSE() = default;
+  void BackwardSubstitution();
+  std::string PhaseName() const {
+    return "hdse";
+  }
+ private:
+  bool IsLfo() override {
+    return func.IsLfo();
+  }
+  void ProcessWhileInfos() override;
+  MeFunction &func;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEHdse, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MEHDSE_H
diff --git a/src/mapleall/maple_me/include/me_inequality_graph.h b/src/mapleall/maple_me/include/me_inequality_graph.h
new file mode 100644
index 0000000000000000000000000000000000000000..35b7e398d76a2383444564e9dcda2985fdecc77b
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_inequality_graph.h
@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEME_INCLUDE_ME_INEQUALITY_GRAPH_H
+#define MAPLEME_INCLUDE_ME_INEQUALITY_GRAPH_H
+#include <iostream>
+#include <fstream>
+#include <irmap.h>
+#include <me_function.h>
+
+namespace maple {
+enum ESSANodeKind : std::uint8_t {
+  kVarNode,
+  kPhiNode,
+  kConstNode,
+  kArrayNode
+};
+
+enum ProveResult : std::uint8_t {
+  kFalse,
+  kReduced,
+  kTrue
+};
+
+enum EdgeType : std::uint8_t {
+  kUpper,
+  kLower,
+  kNone,
+  kUpperInvalid,
+  kLowerInvalid,
+  kNoneInvalid
+};
+
+enum DumpType : std::uint8_t {
+  kDumpUpperAndNone,
+  kDumpLowerAndNone,
+  kDumpNone
+};
+
+class VarValue {
+ public:
+  VarValue(MeExpr &expr, bool pos) : meExpr(&expr), isPositive(pos) {}
+  ~VarValue() = default;
+
+  bool IsPositive() const {
+    return isPositive;
+  }
+
+  const MeExpr &GetVarMeExpr() const {
+    return *meExpr;
+  }
+
+ private:
+  MeExpr *meExpr;
+  bool isPositive;
+};
+
+class InequalEdge {
+ public:
+  InequalEdge(int64 v, EdgeType t) : edgeType(t), isVarValue(false), pairEdge(nullptr) {
+    value.constValue = v;
+  }
+
+  InequalEdge(MeExpr &expr, bool positive, EdgeType t) : edgeType(t), isVarValue(true), pairEdge(nullptr) {
+    value.varValue = new (std::nothrow)VarValue(expr, positive);
+    CHECK_FATAL(value.varValue != nullptr, "New fail in InequalEdge ctor!");
+  }
+
+  InequalEdge(const InequalEdge &edge, const InequalEdge &nextEdge)
+      : edgeType(edge.GetEdgeType()),
+        isVarValue(false),
+        pairEdge(nullptr) {
+    if (edge.GetEdgeType() == kLower) {
+      value.constValue = edge.value.constValue + nextEdge.GetConstValue();
+    } else {
+      value.constValue = edge.value.constValue - nextEdge.GetConstValue();
+    }
+  }
+
+  ~InequalEdge() {
+    if (isVarValue) {
+      delete(value.varValue);
+      value.varValue = nullptr;
+    }
+  }
+
+  void SetEdgeTypeInValid() {
+    CHECK_FATAL(edgeType == kLower || edgeType == kUpper || edgeType == kNone, "must be");
+    edgeType = edgeType == kLower ? kLowerInvalid : (edgeType == kUpper ? kUpperInvalid : kNoneInvalid);
+  }
+
+  void SetEdgeTypeValid() {
+    CHECK_FATAL(edgeType == kLowerInvalid || edgeType == kUpperInvalid || edgeType == kNoneInvalid, "must be");
+    edgeType = edgeType == kLowerInvalid ? kLower : (edgeType == kUpperInvalid ? kUpper : kNone);
+  }
+
+  EdgeType GetEdgeType() const {
+    return edgeType;
+  }
+
+  int64 GetConstValue() const {
+    return value.constValue;
+  }
+
+  const VarValue &GetVarValue() const {
+    return *(value.varValue);
+  }
+
+  bool IsVarValue() const {
+    return isVarValue;
+  }
+  void SetPairEdge(InequalEdge &pe) {
+    CHECK_FATAL(pairEdge == nullptr || pairEdge == &pe, "must be");
+    pairEdge = &pe;
+  }
+  InequalEdge *GetPairEdge() {
+    return pairEdge;
+  }
+
+  const InequalEdge *GetPairEdge() const {
+    return pairEdge;
+  }
+
+  bool LessEqual(const InequalEdge &edge) const {
+    ASSERT(edgeType == edge.GetEdgeType(), "two edges must have the same type: upper or lower");
+    return edgeType == kUpper ? value.constValue <= edge.GetConstValue() : value.constValue >= edge.GetConstValue();
+  }
+
+  bool GreaterEqual(int64 val) const {
+    return edgeType == kUpper ? value.constValue >= val : value.constValue <= val;
+  }
+
+  bool IsSame(const InequalEdge &e) const {
+    if (edgeType != e.GetEdgeType()) {
+      return false;
+    }
+    if (isVarValue != e.IsVarValue()) {
+      return false;
+    }
+    if (isVarValue) {
+      return value.varValue->IsPositive() == e.GetVarValue().IsPositive() &&
+             &value.varValue->GetVarMeExpr() == &e.GetVarValue().GetVarMeExpr();
+    } else {
+      return value.constValue == e.GetConstValue();
+    }
+  }
+
+ private:
+  union {
+    int64 constValue;
+    VarValue *varValue;
+  } value;
+  EdgeType edgeType;
+  bool isVarValue;
+  InequalEdge *pairEdge;
+};
+
+class ESSABaseNode {
+ public:
+  struct ESSABaseNodeComparator {
+    bool operator()(const ESSABaseNode *lhs, const ESSABaseNode *rhs) const {
+      ASSERT_NOT_NULL(lhs);
+      ASSERT_NOT_NULL(rhs);
+      return lhs->GetID() < rhs->GetID();
+    }
+  };
+  ESSABaseNode(int64 i, MeExpr *expr, ESSANodeKind k) : id(i), meExpr(expr), kind(k) {}
+  virtual ~ESSABaseNode() = default;
+
+  virtual const MeExpr &GetMeExpr() const {
+    return *meExpr;
+  }
+
+  virtual ESSANodeKind GetKind() const {
+    return kind;
+  }
+
+  virtual const std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> &GetOutWithConstEdgeMap() const {
+    return outWithConstEdge;
+  }
+
+  virtual const std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> &GetOutWithVarEdgeMap() const {
+    return outWithVarEdge;
+  }
+
+  virtual const std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> &GetInWithConstEdgeMap() const {
+    return inWithConstEdge;
+  }
+
+  virtual const std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> &GetInWithVarEdgeMap() const {
+    return inWithVarEdge;
+  }
+
+  virtual void InsertOutWithConstEdgeMap(ESSABaseNode &node, InequalEdge &e) {
+    (void)outWithConstEdge.emplace(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+  }
+
+  virtual void InsertOutWithVarEdgeMap(ESSABaseNode &node, InequalEdge &e) {
+    (void)outWithVarEdge.emplace(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+  }
+
+  virtual void InsertInWithConstEdgeMap(ESSABaseNode &node, InequalEdge &e) {
+    (void)inWithConstEdge.emplace(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+  }
+
+  virtual void InsertInWithVarEdgeMap(ESSABaseNode &node, InequalEdge &e) {
+    (void)inWithVarEdge.emplace(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+  }
+
+  virtual void InsertEdges(std::unique_ptr<InequalEdge> e) {
+    edges.push_back(std::move(e));
+  }
+
+  virtual std::string GetExprID() const {
+    CHECK_FATAL(meExpr != nullptr, "must be");
+    return std::to_string(meExpr->GetExprID());
+  }
+
+  int64 GetID() const {
+    return id;
+  }
+
+ protected:
+  int64 id;
+  MeExpr *meExpr;
+  ESSANodeKind kind;
+  std::vector<std::unique_ptr<InequalEdge>> edges;
+  std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> outWithConstEdge;
+  std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> outWithVarEdge;
+  std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> inWithConstEdge;
+  std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> inWithVarEdge;
+};
+
+class ESSAVarNode : public ESSABaseNode {
+ public:
+  ESSAVarNode(int64 i, MeExpr &e) : ESSABaseNode(i, &e, kVarNode) {}
+  ~ESSAVarNode() = default;
+};
+
+class ESSAConstNode : public ESSABaseNode {
+ public:
+  ESSAConstNode(int64 i, int64 v) : ESSABaseNode(i, nullptr, kConstNode), value(v) {}
+  ~ESSAConstNode() = default;
+
+  int64 GetValue() const {
+    return value;
+  }
+
+  virtual std::string GetExprID() const override {
+    return std::to_string(GetValue()) + " Const";
+  }
+
+ private:
+  int64 value;
+};
+
+class ESSAArrayNode : public ESSABaseNode {
+ public:
+  ESSAArrayNode(int64 i, MeExpr &e) : ESSABaseNode(i, &e, kArrayNode) {}
+  ~ESSAArrayNode() = default;
+};
+
+class ESSAPhiNode : public ESSABaseNode {
+ public:
+  ESSAPhiNode(int64 i, MeExpr &e) : ESSABaseNode(i, &e, kPhiNode) {}
+  ~ESSAPhiNode() = default;
+
+  const std::vector<VarMeExpr*> &GetPhiOpnds() const {
+    return phiOpnds;
+  }
+
+  void SetPhiOpnds(MapleVector<ScalarMeExpr*> &nodes) {
+    for (auto iter = nodes.begin(); iter != nodes.end(); ++iter) {
+      phiOpnds.push_back(static_cast<VarMeExpr*>(*iter));
+    }
+  }
+  const std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> &GetInPhiEdgeMap() const {
+    return inPhiNodes;
+  }
+
+  const std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> &GetOutPhiEdgeMap() const {
+    return outPhiNodes;
+  }
+  void InsertInPhiEdgeMap(ESSABaseNode &node, InequalEdge &e) {
+    (void)inPhiNodes.emplace(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+  }
+  void InsertOutPhiEdgeMap(ESSABaseNode &node, InequalEdge &e) {
+    (void)outPhiNodes.emplace(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+  }
+
+ private:
+  std::vector<VarMeExpr*> phiOpnds;
+  std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> inPhiNodes;
+  std::multimap<ESSABaseNode*, InequalEdge*, ESSABaseNodeComparator> outPhiNodes;
+};
+
+class InequalityGraph {
+ public:
+  explicit InequalityGraph(MeFunction &func) : meFunction(&func) {
+    nodeCount = 0;
+    constNodes[0] = std::make_unique<ESSAConstNode>(GetValidID(), 0);
+  }
+  ~InequalityGraph() = default;
+
+  ESSAConstNode *GetOrCreateConstNode(int64 value);
+  ESSAVarNode *GetOrCreateVarNode(MeExpr &meExpr);
+  ESSAPhiNode *GetOrCreatePhiNode(MePhiNode &phiNode);
+  ESSAArrayNode *GetOrCreateArrayNode(MeExpr &meExpr);
+  InequalEdge *AddEdge(ESSABaseNode &from, ESSABaseNode &to, int64 value, EdgeType type);
+  void AddPhiEdge(ESSABaseNode &from, ESSABaseNode &to, EdgeType type);
+  void AddEdge(ESSABaseNode &from, ESSABaseNode &to, MeExpr &value, bool positive, EdgeType type);
+  void ConnectTrivalEdge();
+  void DumpDotFile(DumpType dumpType) const;
+  ESSABaseNode &GetNode(const MeExpr &meExpr);
+  ESSABaseNode &GetNode(int64 value);
+  bool HasNode(const MeExpr &meExpr) const;
+  int GetValidID() {
+    ++nodeCount;
+    return nodeCount;
+  }
+
+ private:
+  std::string GetColor(EdgeType type) const;
+  bool HasNode(int64 value) const;
+  InequalEdge *HasEdge(const ESSABaseNode &from, ESSABaseNode &to, const InequalEdge &type) const;
+  std::string GetName(const ESSABaseNode &node) const;
+  std::string GetName(const MeExpr &meExpr) const;
+  void DumpDotNodes(std::ostream &out, DumpType dumpType,
+                    const std::map<int64, std::unique_ptr<ESSABaseNode>> &nodes) const;
+  void DumpDotEdges(const std::pair<ESSABaseNode*, InequalEdge*> &map,
+                    std::ostream &out, const std::string &from) const;
+
+  MeFunction *meFunction;
+  std::map<int64, std::unique_ptr<ESSABaseNode>> varNodes;
+  std::map<int64, std::unique_ptr<ESSABaseNode>> constNodes;
+  int nodeCount;
+};
+
+class ABCD {
+ public:
+  static constexpr int kDFSLimit = 100000;
+  explicit ABCD(InequalityGraph &graph) : inequalityGraph(&graph), recursiveCount(0) {}
+  ~ABCD() = default;
+  bool IsLessOrEqual(const MeExpr &arrayNode, const MeExpr &idx);
+  bool DemandProve(const MeExpr &arrayNode, const MeExpr &idx);
+  bool DemandProve(ESSABaseNode &firstNode, ESSABaseNode &secondNode, EdgeType edgeType);
+
+ private:
+  using MeetFunction = ProveResult (*)(ProveResult, ProveResult);
+  static ProveResult Max(ProveResult res1, ProveResult res2) {
+    if (res1 == kTrue || res2 == kTrue) {
+      return kTrue;
+    }
+    if (res1 == kReduced || res2 == kReduced) {
+      return kReduced;
+    }
+    return kFalse;
+  }
+
+  static ProveResult Min(ProveResult res1, ProveResult res2) {
+    if (res1 == kFalse || res2 == kFalse) {
+      return kFalse;
+    }
+    if (res1 == kTrue || res2 == kTrue) {
+      return kTrue;
+    }
+    return kReduced;
+  }
+
+  ProveResult Prove(ESSABaseNode &aNode, ESSABaseNode &bNode, InequalEdge &edge);
+  ProveResult UpdateCacheResult(ESSABaseNode &aNode, ESSABaseNode &bNode, const InequalEdge &edge,
+                                MeetFunction meet);
+  void PrintTracing() const;
+  InequalityGraph *inequalityGraph;
+  std::map<ESSABaseNode*, InequalEdge*> active;
+  std::vector<ESSABaseNode*> tracing;
+  int recursiveCount;
+};
+} // namespace maple
+#endif
diff --git a/src/mapleall/maple_me/include/me_ir.h b/src/mapleall/maple_me/include/me_ir.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d2b366369e1700d8b664d68f85b6e8b45370be9
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ir.h
@@ -0,0 +1,3164 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_IR_H
+#define MAPLE_ME_INCLUDE_ME_IR_H
+#include <array>
+#include "orig_symbol.h"
+#include "bb.h"
+
+namespace maple {
+class PhiNode;    // circular dependency exists, no other choice
+class MeStmt;     // circular dependency exists, no other choice
+class IRMap;      // circular dependency exists, no other choice
+class SSATab;     // circular dependency exists, no other choice
+class VarMeExpr;  // circular dependency exists, no other choice
+class Dominance;  // circular dependency exists, no other choice
+using MeStmtPtr = MeStmt*;
+enum MeExprOp : uint8 {
+  kMeOpUnknown,
+  kMeOpVar,
+  kMeOpIvar,
+  kMeOpAddrof,
+  kMeOpAddroffunc,
+  kMeOpAddroflabel,
+  kMeOpGcmalloc,
+  kMeOpReg,
+  kMeOpConst,
+  kMeOpConststr,
+  kMeOpConststr16,
+  kMeOpSizeoftype,
+  kMeOpFieldsDist,
+  kMeOpOp,
+  kMeOpNary
+};  // cache the op to avoid dynamic cast
+
+constexpr int kInvalidExprID = -1;
+class MeExpr {
+ public:
+  MeExpr(int32 exprId, MeExprOp meop, Opcode op, PrimType t, size_t n)
+      : op(op), primType(t), numOpnds(n), meOp(meop), exprID(exprId) {}
+
+  virtual ~MeExpr() = default;
+
+  void SetOp(Opcode opcode) {
+    op = opcode;
+  }
+
+  void SetPtyp(PrimType primTypeVal) {
+    primType = primTypeVal;
+  }
+
+  void SetNumOpnds(uint8 val) {
+    numOpnds = val;
+  }
+
+  void SetTreeID(uint32 val) {
+    treeID = val;
+  }
+
+  void SetNext(MeExpr *nextPara) {
+    next = nextPara;
+  }
+
+  Opcode GetOp() const {
+    return op;
+  }
+
+  PrimType GetPrimType() const {
+    return primType;
+  }
+
+  uint8 GetNumOpnds() const {
+    return numOpnds;
+  }
+
+  MeExprOp GetMeOp() const {
+    return meOp;
+  }
+
+  int32 GetExprID() const {
+    return exprID;
+  }
+
+  uint32 GetTreeID() const {
+    return treeID;
+  }
+
+  MeExpr *GetNext() const {
+    return next;
+  }
+
+  virtual void Dump(const IRMap*, int32 indent = 0) const {
+    (void)indent;
+  }
+
+  virtual uint8 GetDepth() const {
+    return 0;
+  }
+
+  virtual bool IsZero() const {
+    return false;
+  }
+
+  virtual bool IsIntZero() const {
+    return false;
+  }
+
+  virtual bool IsUseSameSymbol(const MeExpr &expr) const {
+    return exprID == expr.exprID;
+  }
+
+  virtual BaseNode &EmitExpr(MapleAllocator&) = 0;
+  bool IsLeaf() const {
+    return numOpnds == 0;
+  }
+
+  bool IsScalar() const {
+    return meOp == kMeOpVar || meOp == kMeOpReg;
+  }
+
+  bool IsGcmalloc() const {
+    return op == OP_gcmalloc || op == OP_gcmallocjarray || op == OP_gcpermalloc || op == OP_gcpermallocjarray;
+  }
+
+  virtual bool IsVolatile() const {
+    return false;
+  }
+
+  bool ContainsVolatile() const;
+
+  bool IsTheSameWorkcand(const MeExpr&) const;
+  virtual void SetDefByStmt(MeStmt&) {}
+
+  virtual MeExpr *GetOpnd(size_t) const {
+    return nullptr;
+  }
+
+  virtual void SetOpnd(size_t, MeExpr*) {
+    ASSERT(false, "Should not reach here");
+  }
+
+  virtual MeExpr *GetIdenticalExpr(MeExpr&, bool) const {
+    ASSERT(false, "Should not reach here");
+    return nullptr;
+  }
+
+  virtual MIRType *GetType() const { return nullptr; }
+
+  MeExpr &GetAddrExprBase();               // get the base of the address expression
+  // in the expression; nullptr otherwise
+  bool SymAppears(OStIdx oidx);  // check if symbol appears in the expression
+  bool HasIvar() const;          // whether there is any iread node in the expression
+  bool Pure() const {
+    return !kOpcodeInfo.NotPure(op);
+  }
+
+  virtual bool IsSameVariableValue(const VarMeExpr&) const;
+  MeExpr *ResolveMeExprValue();
+  bool CouldThrowException() const;
+  bool IsAllOpndsIdentical(const MeExpr &meExpr) const;
+  bool PointsToSomethingThatNeedsIncRef();
+  virtual uint32 GetHashIndex() const {
+    return 0;
+  }
+  virtual bool HasAddressValue() { return false; }
+  virtual bool StrengthReducible() { return false; }
+  virtual int64 SRMultiplier(OriginalSt *ost) {
+    (void)ost;
+    return 1;
+  }
+
+  virtual bool IsOpMeExpr() const {
+    return false;
+  }
+
+ protected:
+  MeExpr *FindSymAppearance(OStIdx oidx);  // find the appearance of the symbol
+  bool IsDexMerge() const;
+
+  Opcode op;
+  PrimType primType;
+  uint8 numOpnds;
+  MeExprOp meOp;
+  int32 exprID;
+  uint32 treeID = 0;  // for bookkeeping purpose during SSAPRE
+  MeExpr *next = nullptr;
+};
+
+enum MeDefBy {
+  kDefByNo,
+  kDefByStmt,
+  kDefByPhi,
+  kDefByChi,
+  kDefByMustDef  // only applies to callassigned and its siblings
+};
+
+class ChiMeNode;      // circular dependency exists, no other choice
+class MustDefMeNode;  // circular dependency exists, no other choice
+class IassignMeStmt;  // circular dependency exists, no other choice
+
+// base class for VarMeExpr and RegMeExpr
+class ScalarMeExpr : public MeExpr {
+ public:
+  ScalarMeExpr(int32 exprid, OriginalSt *origSt, uint32 vidx, MeExprOp meop, Opcode o, PrimType ptyp)
+      : MeExpr(exprid, meop, o, ptyp, 0),
+        ost(origSt),
+        vstIdx(vidx),
+        defBy(kDefByNo) {
+    def.defStmt = nullptr;
+  }
+
+  ~ScalarMeExpr() = default;
+
+  bool IsIdentical(MeExpr&) const {
+    CHECK_FATAL(false, "ScalarMeExpr::IsIdentical() should not be called");
+    return true;
+  }
+
+  bool IsUseSameSymbol(const MeExpr&) const override;
+
+  void SetDefByStmt(MeStmt &defStmt) override {
+    defBy = kDefByStmt;
+    def.defStmt = &defStmt;
+  }
+
+  MePhiNode *GetMePhiDef() const {
+    return IsDefByPhi() ? def.defPhi : nullptr;
+  }
+
+  bool IsDefByNo() const {
+    return defBy == kDefByNo;
+  }
+
+  bool IsDefByPhi() const {
+    return defBy == kDefByPhi;
+  }
+
+  bool IsDefByChi() const {
+    return defBy == kDefByChi;
+  }
+
+  bool IsDefByStmt() const {
+    return defBy == kDefByStmt;
+  }
+
+  bool IsDefByMustDef() const {
+    return defBy == kDefByMustDef;
+  }
+
+  BB *DefByBB() const;
+
+  OriginalSt *GetOst() const {
+    return ost;
+  }
+
+  void SetOst(OriginalSt *o) {
+    ost = o;
+  }
+
+  OStIdx GetOstIdx() const {
+    return ost->GetIndex();
+  }
+
+  size_t GetVstIdx() const {
+    return vstIdx;
+  }
+
+  void SetVstIdx(size_t vstIdxVal) {
+    vstIdx = static_cast<uint32>(vstIdxVal);
+  }
+
+  MeDefBy GetDefBy() const {
+    return defBy;
+  }
+
+  void SetDefBy(MeDefBy defByVal) {
+    defBy = defByVal;
+  }
+
+  MeStmt *GetDefStmt() const {
+    return def.defStmt;
+  }
+
+  void SetDefStmt(MeStmt *defStmt) {
+    def.defStmt = defStmt;
+  }
+
+  MePhiNode &GetDefPhi() {
+    return *def.defPhi;
+  }
+
+  const MePhiNode &GetDefPhi() const {
+    return *def.defPhi;
+  }
+
+  void SetDefPhi(MePhiNode &defPhi) {
+    def.defPhi = &defPhi;
+  }
+
+  ChiMeNode &GetDefChi() {
+    return *def.defChi;
+  }
+
+  const ChiMeNode &GetDefChi() const {
+    return *def.defChi;
+  }
+
+  void SetDefChi(ChiMeNode &defChi) {
+    def.defChi = &defChi;
+  }
+
+  MustDefMeNode &GetDefMustDef() {
+    return *def.defMustDef;
+  }
+
+  const MustDefMeNode &GetDefMustDef() const {
+    return *def.defMustDef;
+  }
+
+  void SetDefMustDef(MustDefMeNode &defMustDef) {
+    def.defMustDef = &defMustDef;
+  }
+
+  PregIdx GetRegIdx() const {
+    ASSERT(ost->IsPregOst(), "GetPregIdx: not a preg");
+    return ost->GetPregIdx();
+  }
+
+  bool IsNormalReg() const {
+    ASSERT(ost->IsPregOst(), "GetPregIdx: not a preg");
+    return ost->GetPregIdx() >= 0;
+  }
+
+  MeStmt *GetDefByMeStmt() const;
+  BB *GetDefByBBMeStmt(const MeCFG &cfg, MeStmtPtr &defMeStmt) const;
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  bool IsSameVariableValue(const VarMeExpr&) const override;
+  ScalarMeExpr *FindDefByStmt(std::set<ScalarMeExpr*> &visited);
+  bool IsZeroVersion() const;
+
+ protected:
+  OriginalSt *ost;
+  uint32 vstIdx;    // the index in MEOptimizer's VersionStTable, 0 if not in VersionStTable
+  MeDefBy defBy : 3;
+  union {
+    MeStmt *defStmt;  // definition stmt of this var
+    MePhiNode *defPhi;
+    ChiMeNode *defChi;          // definition node by Chi
+    MustDefMeNode *defMustDef;  // definition by callassigned
+  } def;
+};
+
+using RegMeExpr = ScalarMeExpr;
+
+// represant dread
+class VarMeExpr final : public ScalarMeExpr {
+ public:
+  VarMeExpr(int32 exprid, OriginalSt *ost, size_t vidx, PrimType ptyp)
+      : ScalarMeExpr(exprid, ost, vidx, kMeOpVar, OP_dread, ptyp) {}
+
+  ~VarMeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  bool IsValidVerIdx() const;
+
+  bool IsVolatile() const override;
+  // indicate if the variable is local variable but not a function formal variable
+  bool IsPureLocal(const MIRFunction&) const;
+  bool IsSameVariableValue(const VarMeExpr&) const override;
+  VarMeExpr &ResolveVarMeValue();
+  bool PointsToStringLiteral();
+
+  FieldID GetFieldID() const {
+    return GetOst()->GetFieldID();
+  }
+
+  TyIdx GetInferredTyIdx() const {
+    return inferredTyIdx;
+  }
+
+  void SetInferredTyIdx(TyIdx inferredTyIdxVal) {
+    inferredTyIdx = inferredTyIdxVal;
+  }
+  bool GetMaybeNull() const {
+    return maybeNull;
+  }
+
+  void SetMaybeNull(bool maybeNullVal) {
+    maybeNull = maybeNullVal;
+  }
+
+  bool GetNoDelegateRC() const {
+    return noDelegateRC;
+  }
+
+  void SetNoDelegateRC(bool noDelegateRCVal) {
+    noDelegateRC = noDelegateRCVal;
+  }
+
+  bool GetNoSubsumeRC() const {
+    return noSubsumeRC;
+  }
+
+  void SetNoSubsumeRC(bool noSubsumeRCVal) {
+    noSubsumeRC = noSubsumeRCVal;
+  }
+
+  MIRType *GetType() const override {
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx());
+  }
+
+  bool HasAddressValue() override { return MustBeAddress(GetPrimType()) || GetType()->GetKind() == kTypePointer; }
+
+ private:
+  bool noDelegateRC = false;  // true if this cannot be optimized by delegaterc
+  bool noSubsumeRC = false;   // true if this cannot be optimized by subsumrc
+  TyIdx inferredTyIdx{ 0 }; /* Non zero if it has a known type (allocation type is seen). */
+  bool maybeNull = true;  // false if definitely not null
+};
+
+class MePhiNode {
+ public:
+  explicit MePhiNode(MapleAllocator *alloc)
+      : opnds(kOperandNumBinary, nullptr, alloc->Adapter()) {
+    opnds.pop_back();
+    opnds.pop_back();
+  }
+
+  MePhiNode(ScalarMeExpr *expr, MapleAllocator *alloc)
+      : lhs(expr), opnds(kOperandNumBinary, nullptr, alloc->Adapter()) {
+    expr->SetDefPhi(*this);
+    expr->SetDefBy(kDefByPhi);
+    opnds.pop_back();
+    opnds.pop_back();
+  }
+
+  ~MePhiNode() = default;
+
+  void UpdateLHS(ScalarMeExpr &expr) {
+    lhs = &expr;
+    expr.SetDefBy(kDefByPhi);
+    expr.SetDefPhi(*this);
+  }
+
+  void Dump(const IRMap *irMap) const;
+
+  ScalarMeExpr *GetOpnd(size_t idx) const {
+    ASSERT(idx < opnds.size(), "out of range in MeVarPhiNode::GetOpnd");
+    return opnds.at(idx);
+  }
+
+  void SetOpnd(size_t idx, ScalarMeExpr *opnd) {
+    CHECK_FATAL(idx < opnds.size(), "out of range in MePhiNode::SetOpnd");
+    opnds[idx] = opnd;
+  }
+
+  const MapleVector<ScalarMeExpr*> &GetOpnds() const {
+    return opnds;
+  }
+
+  MapleVector<ScalarMeExpr*> &GetOpnds() {
+    return opnds;
+  }
+
+  void SetIsLive(bool isLiveVal) {
+    isLive = isLiveVal;
+  }
+
+  bool GetIsLive() const {
+    return isLive;
+  }
+
+  void SetDefBB(BB *defBBVal) {
+    defBB = defBBVal;
+  }
+
+  BB *GetDefBB() {
+    return defBB;
+  }
+
+  const BB *GetDefBB() const {
+    return defBB;
+  }
+
+  ScalarMeExpr *GetLHS() const {
+    return lhs;
+  }
+
+  void SetLHS(ScalarMeExpr *value) {
+    value->SetDefBy(kDefByPhi);
+    value->SetDefPhi(*this);
+    lhs = value;
+  }
+
+  void SetPiAdded() {
+    isPiAdded = true;
+  }
+
+  bool IsPiAdded() const {
+    return isPiAdded;
+  }
+
+  bool UseReg() const {
+    return lhs->GetMeOp() == kMeOpReg;
+  }
+
+ private:
+  ScalarMeExpr *lhs = nullptr;
+  MapleVector<ScalarMeExpr*> opnds;
+  bool isLive = true;
+  BB *defBB = nullptr;  // the bb that defines this phi
+  bool isPiAdded = false;
+};
+
+class ConstMeExpr : public MeExpr {
+ public:
+  ConstMeExpr(int32 exprID, MIRConst *constValParam, PrimType t)
+      : MeExpr(exprID, kMeOpConst, OP_constval, t, 0), constVal(constValParam) {}
+
+  ~ConstMeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  bool GeZero() const;
+  bool GtZero() const;
+  bool IsZero() const override;
+  bool IsIntZero() const override;
+  bool IsOne() const;
+  // Get int value represented by IntVal class
+  IntVal GetIntValue() const;
+  // Get value extended by its sign
+  int64 GetExtIntValue() const;
+  // Get zero extended value
+  uint64 GetZXTIntValue() const;
+  // Get sign extended value
+  int64 GetSXTIntValue() const;
+
+  MIRConst *GetConstVal() {
+    return constVal;
+  }
+
+  const MIRConst *GetConstVal() const {
+    return constVal;
+  }
+
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+
+  uint32 GetHashIndex() const override {
+    CHECK_FATAL(constVal != nullptr, "constVal is null");
+    if (constVal->GetKind() == kConstInt) {
+      auto *intConst = safe_cast<MIRIntConst>(constVal);
+      CHECK_NULL_FATAL(intConst);
+      return static_cast<uint32>(intConst->GetExtValue());
+    }
+    if (constVal->GetKind() == kConstFloatConst) {
+      auto *floatConst = safe_cast<MIRFloatConst>(constVal);
+      CHECK_NULL_FATAL(floatConst);
+      return floatConst->GetIntValue();
+    }
+    if (constVal->GetKind() == kConstDoubleConst) {
+      auto *doubleConst = safe_cast<MIRDoubleConst>(constVal);
+      CHECK_NULL_FATAL(doubleConst);
+      return doubleConst->GetIntValue();
+    }
+    if (constVal->GetKind() == kConstLblConst) {
+      auto *lblConst = safe_cast<MIRLblConst>(constVal);
+      CHECK_NULL_FATAL(lblConst);
+      return lblConst->GetValue();
+    }
+    ASSERT(false, "ComputeHash: const type not yet implemented");
+    return 0;
+  }
+
+ private:
+  MIRConst *constVal;
+};
+
+class ConststrMeExpr : public MeExpr {
+ public:
+  ConststrMeExpr(int32 exprID, UStrIdx idx, PrimType t)
+      : MeExpr(exprID, kMeOpConststr, OP_conststr, t, 0), strIdx(idx) {}
+
+  ~ConststrMeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+
+  UStrIdx GetStrIdx() const {
+    return strIdx;
+  }
+
+  uint32 GetHashIndex() const override {
+    constexpr uint32 kConststrHashShift = 6;
+    return static_cast<uint32>(strIdx) << kConststrHashShift;
+  }
+
+ private:
+  UStrIdx strIdx;
+};
+
+class Conststr16MeExpr : public MeExpr {
+ public:
+  Conststr16MeExpr(int32 exprID, U16StrIdx idx, PrimType t)
+      : MeExpr(exprID, kMeOpConststr16, OP_conststr16, t, 0), strIdx(idx) {}
+
+  ~Conststr16MeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+
+  U16StrIdx GetStrIdx() {
+    return strIdx;
+  }
+
+  uint32 GetHashIndex() const override {
+    constexpr uint32 kConststr16HashShift = 6;
+    return static_cast<uint32>(strIdx) << kConststr16HashShift;
+  }
+
+ private:
+  U16StrIdx strIdx;
+};
+
+class SizeoftypeMeExpr : public MeExpr {
+ public:
+  SizeoftypeMeExpr(int32 exprid, PrimType t, TyIdx idx)
+      : MeExpr(exprid, kMeOpSizeoftype, OP_sizeoftype, t, 0), tyIdx(idx) {}
+
+  ~SizeoftypeMeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  uint32 GetHashIndex() const override {
+    constexpr uint32 sizeoftypeHashShift = 5;
+    return static_cast<uint32>(tyIdx) << sizeoftypeHashShift;
+  }
+
+ private:
+  TyIdx tyIdx;
+};
+
+class FieldsDistMeExpr : public MeExpr {
+ public:
+  FieldsDistMeExpr(int32 exprid, PrimType t, TyIdx idx, FieldID f1, FieldID f2)
+      : MeExpr(exprid, kMeOpFieldsDist, OP_fieldsdist, t, 0), tyIdx(idx), fieldID1(f1), fieldID2(f2) {}
+
+  ~FieldsDistMeExpr() = default;
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  FieldID GetFieldID1() const {
+    return fieldID1;
+  }
+
+  FieldID GetFieldID2() const {
+    return fieldID2;
+  }
+
+  uint32 GetHashIndex() const override {
+    constexpr uint32 kFieldsDistHashShift = 5;
+    constexpr uint32 kTyIdxShiftFactor = 10;
+    return (static_cast<uint32>(tyIdx) << kTyIdxShiftFactor) +
+           (static_cast<uint32>(fieldID1) << kFieldsDistHashShift) + fieldID2;
+  }
+
+ private:
+  TyIdx tyIdx;
+  FieldID fieldID1;
+  FieldID fieldID2;
+};
+
+class AddrofMeExpr : public MeExpr {
+ public:
+  AddrofMeExpr(int32 exprid, PrimType t, OriginalSt *ost)
+      : MeExpr(exprid, kMeOpAddrof, OP_addrof, t, 0), ost(ost) {}
+
+  ~AddrofMeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  bool IsUseSameSymbol(const MeExpr&) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+
+  OStIdx GetOstIdx() const {
+    return ost->GetIndex();
+  }
+
+  OriginalSt *GetOst() const {
+    return ost;
+  }
+
+  FieldID GetFieldID() const {
+    return ost->GetFieldID();
+  }
+
+  uint32 GetHashIndex() const override {
+    constexpr uint32 addrofHashShift = 4;
+    return static_cast<uint32>(GetOstIdx()) << addrofHashShift;
+  }
+
+  bool HasAddressValue() override { return true; }
+
+ private:
+  OriginalSt *ost;
+};
+
+class AddroffuncMeExpr : public MeExpr {
+ public:
+  AddroffuncMeExpr(int32 exprID, PUIdx puIdx)
+      : MeExpr(exprID, kMeOpAddroffunc, OP_addroffunc, PTY_ptr, 0), puIdx(puIdx) {}
+
+  ~AddroffuncMeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+
+  PUIdx GetPuIdx() const {
+    return puIdx;
+  }
+
+  uint32 GetHashIndex() const override {
+    constexpr uint32 addroffuncHashShift = 5;
+    return puIdx << addroffuncHashShift;
+  }
+
+  MIRType *GetType() const override {
+    MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+    return GlobalTables::GetTypeTable().GetOrCreatePointerType(*func->GetMIRFuncType(), PTY_ptr);
+  }
+
+ private:
+  PUIdx puIdx;
+};
+
+class AddroflabelMeExpr : public MeExpr {
+ public:
+  LabelIdx labelIdx;
+
+  AddroflabelMeExpr(int32 exprid, LabelIdx lidx)
+      : MeExpr(exprid, kMeOpAddroflabel, OP_addroflabel, PTY_ptr, 0), labelIdx(lidx) {}
+
+  ~AddroflabelMeExpr() override {}
+
+  void Dump(const IRMap *, int32 indent = 0) const override;
+  bool IsIdentical(const MeExpr *meexpr) const {
+    if (meexpr->GetOp() != GetOp()) {
+      return false;
+    }
+    const AddroflabelMeExpr *x = static_cast<const AddroflabelMeExpr*>(meexpr);
+    if (labelIdx != x->labelIdx) {
+      return false;
+    }
+    return true;
+  }
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+
+  uint32 GetHashIndex() const override {
+    constexpr uint32 shiftNum = 4;
+    return labelIdx << shiftNum;
+  }
+};
+
+class GcmallocMeExpr : public MeExpr {
+ public:
+  GcmallocMeExpr(int32 exprid, Opcode o, PrimType t, TyIdx tyid)
+      : MeExpr(exprid, kMeOpGcmalloc, o, t, 0), tyIdx(tyid) {}
+
+  ~GcmallocMeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  uint32 GetHashIndex() const override {
+    constexpr uint32 kGcmallocHashShift = 4;
+    return static_cast<uint32>(tyIdx) << kGcmallocHashShift;
+  }
+
+ private:
+  TyIdx tyIdx;
+};
+
+class OpMeExpr : public MeExpr {
+ public:
+  OpMeExpr(int32 exprID, Opcode o, PrimType t, size_t n)
+      : MeExpr(exprID, kMeOpOp, o, t, n), tyIdx(TyIdx(0)) {}
+
+  // unary
+  OpMeExpr(int32 exprID, Opcode o, PrimType t, MeExpr *opnd0)
+      : MeExpr(exprID, kMeOpOp, o, t, 1), tyIdx(TyIdx(0)) {
+    SetOpndCheck(0, opnd0);
+  }
+
+  // binary
+  OpMeExpr(int32 exprID, Opcode o, PrimType t, MeExpr *opnd0, MeExpr *opnd1, bool order = true)
+      : MeExpr(exprID, kMeOpOp, o, t, 2), tyIdx(TyIdx(0)) {
+    if (order == true) {
+      SetOpndCheck(0, opnd0);
+      SetOpndCheck(1, opnd1);
+    } else {
+      SetOpndCheck(0, opnd1);
+      SetOpndCheck(1, opnd0);
+    }
+    hasAddressValue = opnd0->HasAddressValue() || opnd1->HasAddressValue();
+  }
+
+  OpMeExpr(const OpMeExpr &opMeExpr, int32 exprID)
+      : MeExpr(exprID, kMeOpOp, opMeExpr.GetOp(), opMeExpr.GetPrimType(), opMeExpr.GetNumOpnds()),
+        opnds(opMeExpr.opnds),
+        opndType(opMeExpr.opndType),
+        bitsOffset(opMeExpr.bitsOffset),
+        bitsSize(opMeExpr.bitsSize),
+        depth(opMeExpr.depth),
+        tyIdx(opMeExpr.tyIdx),
+        fieldID(opMeExpr.fieldID),
+        hasAddressValue(opMeExpr.hasAddressValue) {}
+
+  ~OpMeExpr() = default;
+
+  OpMeExpr(const OpMeExpr&) = delete;
+  OpMeExpr &operator=(const OpMeExpr&) = delete;
+
+  bool IsIdentical(const OpMeExpr &meexpr) const;
+  bool IsAllOpndsIdentical(const OpMeExpr &meExpr) const;
+  bool IsCompareIdentical(const OpMeExpr &meExpr) const;
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  bool IsUseSameSymbol(const MeExpr&) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  uint8 GetDepth() const override {
+    return depth;
+  }
+  MeExpr *GetOpnd(size_t i) const override {
+    CHECK_FATAL(i < kOperandNumTernary, "OpMeExpr cannot have more than 3 operands");
+    return opnds[i];
+  }
+
+  void SetOpndCheck(size_t idx, MeExpr *x)  {
+    CHECK_FATAL(idx < kOperandNumTernary, "out of range in  OpMeExpr::SetOpnd");
+    opnds[idx] = x;
+    if (depth <= x->GetDepth()) {
+      depth = x->GetDepth();
+      if (depth != UINT8_MAX) {
+        depth++;
+      }
+    }
+  }
+
+  void SetOpnd(size_t idx, MeExpr *x) override {
+    SetOpndCheck(idx, x);
+  }
+
+  PrimType GetOpndType() {
+    return opndType;
+  }
+
+  PrimType GetOpndType() const {
+    return opndType;
+  }
+
+  void SetOpndType(PrimType opndTypeVal) {
+    opndType = opndTypeVal;
+  }
+
+  uint8 GetBitsOffSet() const {
+    return bitsOffset;
+  }
+
+  void SetBitsOffSet(uint8 bitsOffSetVal) {
+    bitsOffset = bitsOffSetVal;
+  }
+
+  uint8 GetBitsSize() const {
+    return bitsSize;
+  }
+
+  void SetBitsSize(uint8 bitsSizeVal) {
+    bitsSize = bitsSizeVal;
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx tyIdxVal) {
+    tyIdx = tyIdxVal;
+  }
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(FieldID fieldIDVal) {
+    fieldID = fieldIDVal;
+  }
+
+  uint32 GetHashIndex() const override {
+    uint32 hashIdx = static_cast<uint32>(GetOp());
+    constexpr uint32 kOpMeHashShift = 3;
+    for (const auto &opnd : opnds) {
+      if (opnd == nullptr) {
+        break;
+      }
+      hashIdx += static_cast<uint32>(opnd->GetExprID()) << kOpMeHashShift;
+    }
+    return hashIdx;
+  }
+
+  MIRType *GetType() const override {
+    if (tyIdx != TyIdx(0)) {
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    }
+    return nullptr;
+  }
+  void SetHasAddressValue() {
+    if (hasAddressValue) {
+      return;
+    }
+    if (op != OP_select) {
+      hasAddressValue = opnds[0]->HasAddressValue();
+      if (!hasAddressValue && numOpnds > 1) {
+        hasAddressValue = opnds[1]->HasAddressValue();
+      }
+    } else {
+      hasAddressValue = opnds[1]->HasAddressValue() || opnds[2]->HasAddressValue();
+    }
+  }
+  bool HasAddressValue() override { return hasAddressValue || op == OP_iaddrof; }
+  bool StrengthReducible() override;
+  int64 SRMultiplier(OriginalSt *ost) override;
+
+  bool IsOpMeExpr() const override {
+    return true;
+  }
+
+ private:
+  std::array<MeExpr*, kOperandNumTernary> opnds = { nullptr };  // kid
+  PrimType opndType = kPtyInvalid;  // from type
+  uint8 bitsOffset = 0;
+  uint8 bitsSize = 0;
+  uint8 depth = 0;
+  TyIdx tyIdx;
+  FieldID fieldID = 0;  // this is also used to store puIdx
+ public:
+  bool hasAddressValue = false;    // used only when op is ADD or SUB
+};
+
+class IvarMeExpr : public MeExpr {
+ public:
+  IvarMeExpr(MapleAllocator *alloc, int32 exprid, PrimType t, const TyIdx &tidx, FieldID fid, Opcode op)
+      : MeExpr(exprid, kMeOpIvar, op, t, 1), tyIdx(tidx), fieldID(fid), muList(1, nullptr, alloc->Adapter()) {}
+
+  IvarMeExpr(MapleAllocator *alloc, int32 exprid, PrimType t, const TyIdx &tidx, FieldID fid)
+      : IvarMeExpr(alloc, exprid, t, tidx, fid, OP_iread) {}
+
+  IvarMeExpr(MapleAllocator *alloc, int32 exprid, const IvarMeExpr &ivarme)
+      : MeExpr(exprid, kMeOpIvar, ivarme.op, ivarme.GetPrimType(), 1),
+        defStmt(ivarme.defStmt),
+        base(ivarme.base),
+        tyIdx(ivarme.tyIdx),
+        fieldID(ivarme.fieldID),
+        offset(ivarme.offset),
+        volatileFromBaseSymbol(ivarme.volatileFromBaseSymbol),
+        muList(ivarme.muList, alloc->Adapter()) {}
+
+  IvarMeExpr() = delete;  // Disable default ctor
+
+  ~IvarMeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  uint8 GetDepth() const override {
+    return base->GetDepth() + 1;
+  }
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  bool IsVolatile() const override;
+  bool IsFinal();
+  bool IsRCWeak() const;
+  bool IsUseSameSymbol(const MeExpr&) const override;
+  bool IsIdentical(IvarMeExpr &expr, bool inConstructor) const;
+  bool IsMuListIdentical(IvarMeExpr &expr) const;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool inConstructor) const override;
+  MeExpr *GetOpnd(size_t) const override {
+    return base;
+  }
+
+  IassignMeStmt *GetDefStmt() const {
+    return defStmt;
+  }
+
+  void SetDefStmt(IassignMeStmt *defStmtPara) {
+    defStmt = defStmtPara;
+  }
+
+  const MeExpr *GetBase() const {
+    return base;
+  }
+
+  MeExpr *GetBase() {
+    return base;
+  }
+
+  void SetBase(MeExpr *value) {
+    base = value;
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx tyIdxVal) {
+    tyIdx = tyIdxVal;
+  }
+
+  TyIdx GetInferredTyIdx() const {
+    return inferredTyIdx;
+  }
+
+  void SetInferredTyidx(TyIdx inferredTyIdxVal) {
+    inferredTyIdx = inferredTyIdxVal;
+  }
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(FieldID fieldIDVal) {
+    fieldID = fieldIDVal;
+  }
+
+  int32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(int32 val) {
+    offset = val;
+  }
+
+  bool GetMaybeNull() const {
+    return maybeNull;
+  }
+
+  void SetMaybeNull(bool maybeNullVal) {
+    maybeNull = maybeNullVal;
+  }
+
+  bool GetVolatileFromBaseSymbol() const {
+    return volatileFromBaseSymbol;
+  }
+
+  void SetVolatileFromBaseSymbol(bool value) {
+    volatileFromBaseSymbol = value;
+  }
+
+  MapleVector<ScalarMeExpr*> &GetMuList() {
+    return muList;
+  }
+
+  const MapleVector<ScalarMeExpr*> &GetMuList() const {
+    return muList;
+  }
+
+  ScalarMeExpr *GetUniqueMu() {
+    CHECK_FATAL(muList.size() == 1, "scalar ivar should has only 1 mu");
+    return muList[0];
+  }
+
+  const ScalarMeExpr *GetUniqueMu() const {
+    CHECK_FATAL(muList.size() == 1, "scalar ivar should has only 1 mu");
+    return muList[0];
+  }
+
+  void SetMuItem(size_t i, ScalarMeExpr *muVal) {
+    CHECK_FATAL(i < muList.size(), "container check");
+    muList[i] = muVal;
+  }
+
+  void SetMuList(const MapleVector<ScalarMeExpr*> &inputMuList) {
+    size_t len = inputMuList.size();
+    if (muList.size() != len) {
+      muList.resize(len, nullptr);
+    }
+    for (size_t i = 0; i < len; ++i) {
+      muList[i] = inputMuList[i];
+    }
+  }
+
+  void SetMuList(const std::vector<ScalarMeExpr*> &inputMuList) {
+    size_t len = inputMuList.size();
+    if (muList.size() != len) {
+      muList.resize(len, nullptr);
+    }
+    for (size_t i = 0; i < len; ++i) {
+      muList[i] = inputMuList[i];
+    }
+  }
+
+  uint32 GetMuCount() const {
+    return static_cast<uint32>(muList.size());
+  }
+
+  bool HasMultipleMu() const {
+    return muList.size() > 1;
+  }
+
+  uint32 GetHashIndex() const override {
+    constexpr uint32 kIvarHashShift = 4;
+    return static_cast<uint32>(op) + static_cast<uint32>(fieldID) + static_cast<uint32>(offset) +
+           (static_cast<uint32>(base->GetExprID()) << kIvarHashShift);
+  }
+
+  MIRType *GetType() const override {
+    MIRPtrType *ptrtype = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx));
+    if (fieldID == 0) {
+      return ptrtype->GetPointedType();
+    }
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrtype->GetPointedTyIdxWithFieldID(fieldID));
+  }
+
+  bool HasAddressValue() override { return GetType()->GetKind() == kTypePointer; }
+  bool simplifiedWithConstOffset = false;
+
+ private:
+  IassignMeStmt *defStmt = nullptr;
+  MeExpr *base = nullptr;
+  TyIdx tyIdx{ 0 };
+  TyIdx inferredTyIdx{ 0 };  // may be a subclass of above tyIdx
+  FieldID fieldID = 0;
+  int32 offset = 0;
+  bool maybeNull = true;  // false if definitely not null
+  bool volatileFromBaseSymbol = false;  // volatile due to its base symbol being volatile
+  // muList size must be >= 1, can not be empty
+  MapleVector<ScalarMeExpr*> muList;  // vector type ivar may have multiple mu, non-vector type ivar has only 1 mu
+};
+
+// for array, intrinsicop and intrinsicopwithtype
+class NaryMeExpr : public MeExpr {
+ public:
+  NaryMeExpr(MapleAllocator *alloc, int32 expID, Opcode o, PrimType t,
+             size_t n, TyIdx tyIdx, MIRIntrinsicID intrinID, bool bCheck)
+      : MeExpr(expID, kMeOpNary, o, t, n),
+        tyIdx(tyIdx),
+        intrinsic(intrinID),
+        opnds(alloc->Adapter()),
+        boundCheck(bCheck) {}
+
+  NaryMeExpr(MapleAllocator *alloc, int32 expID, const NaryMeExpr &meExpr)
+      : MeExpr(expID, kMeOpNary, meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()),
+        tyIdx(meExpr.tyIdx),
+        intrinsic(meExpr.intrinsic),
+        opnds(alloc->Adapter()),
+        depth(meExpr.depth),
+        boundCheck(meExpr.boundCheck) {
+    for (size_t i = 0; i < meExpr.opnds.size(); ++i) {
+      opnds.push_back(meExpr.opnds[i]);
+    }
+  }
+
+  ~NaryMeExpr() = default;
+
+  void Dump(const IRMap*, int32 indent = 0) const override;
+  uint8 GetDepth() const override {
+    return depth;
+  }
+  bool IsIdentical(const NaryMeExpr&) const;
+  bool IsUseSameSymbol(const MeExpr&) const override;
+  BaseNode &EmitExpr(MapleAllocator&) override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
+  MeExpr *GetOpnd(size_t idx) const override {
+    ASSERT(idx < opnds.size(), "NaryMeExpr operand out of bounds");
+    return opnds[idx];
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  MIRIntrinsicID GetIntrinsic() const {
+    return intrinsic;
+  }
+
+  const MapleVector<MeExpr*> &GetOpnds() const {
+    return opnds;
+  }
+
+  MapleVector<MeExpr*> &GetOpnds() {
+    return opnds;
+  }
+
+  void SetOpnd(size_t idx, MeExpr *val) override {
+    ASSERT(idx < opnds.size(), "out of range in NaryMeStmt::GetOpnd");
+    opnds[idx] = val;
+    if (depth <= val->GetDepth()) {
+      depth = val->GetDepth();
+      if (depth != UINT8_MAX) {
+        depth++;
+      }
+    }
+  }
+
+  void PushOpnd(MeExpr *x) {
+    opnds.push_back(x);
+    if (depth <= x->GetDepth()) {
+      depth = x->GetDepth();
+      if (depth != UINT8_MAX) {
+        depth++;
+      }
+    }
+  }
+
+  bool GetBoundCheck() {
+    return boundCheck;
+  }
+
+  bool GetBoundCheck() const {
+    return boundCheck;
+  }
+
+  void SetBoundCheck(bool ch) {
+    boundCheck = ch;
+  }
+
+  uint32 GetHashIndex() const override {
+    auto hashIdx = static_cast<uint32>(GetOp());
+    constexpr uint32 kNaryHashShift = 3;
+    for (uint32 i = 0; i < GetNumOpnds(); ++i) {
+      hashIdx += static_cast<uint32>(opnds[i]->GetExprID()) << kNaryHashShift;
+    }
+    hashIdx += static_cast<uint32>(boundCheck);
+    return hashIdx;
+  }
+
+  bool HasAddressValue() override { return op == OP_array; }
+
+ private:
+  TyIdx tyIdx;
+  MIRIntrinsicID intrinsic;
+  MapleVector<MeExpr*> opnds;
+  uint8 depth = 0;
+  bool boundCheck;
+};
+
+class MeStmt {
+ public:
+  explicit MeStmt(const StmtNode *sst) {
+    ASSERT(sst != nullptr, "StmtNode nullptr check");
+    op = sst->GetOpCode();
+    srcPos = sst->GetSrcPos();
+    originalId = sst->GetOriginalID();
+    meStmtId = sst->GetStmtID();
+    if (sst->IsInSafeRegion()) {
+      SetInSafeRegion();
+    }
+  }
+
+  explicit MeStmt(Opcode op1) : meStmtId(StmtNode::stmtIDNext), op(op1) {
+    ++StmtNode::stmtIDNext;
+  }
+
+  virtual ~MeStmt() = default;
+
+  bool GetIsLive() const {
+    return isLive;
+  }
+
+  void SetIsLive(bool value) {
+    isLive = value;
+  }
+
+  virtual void Dump(const IRMap*) const;
+  MeStmt *GetNextMeStmt() const;
+  virtual size_t NumMeStmtOpnds() const {
+    return 0;
+  }
+
+  virtual MeExpr *GetOpnd(size_t) const {
+    return nullptr;
+  }
+
+  virtual void SetOpnd(size_t, MeExpr*) {}
+
+  bool IsReturn() const {
+    return op == OP_gosub || op == OP_retsub || op == OP_throw || op == OP_return;
+  }
+
+  bool IsCondBr() const {
+    return op == OP_brtrue || op == OP_brfalse;
+  }
+
+  bool IsAssign() const {
+    return op == OP_dassign || op == OP_maydassign || op == OP_iassign || op == OP_regassign || op == OP_piassign;
+  }
+
+  virtual MIRType *GetReturnType() const {
+    return nullptr;
+  }
+
+  void EmitCallReturnVector(CallReturnVector &nRets);
+  virtual MapleVector<MustDefMeNode> *GetMustDefList() {
+    return nullptr;
+  }
+
+  const virtual MapleVector<MustDefMeNode> &GetMustDefList() const {
+    CHECK_FATAL(false, "should be implemented");
+  }
+
+  const virtual ScalarMeExpr *GetAssignedLHS() const {
+    return nullptr;
+  }
+
+  virtual ScalarMeExpr *GetAssignedLHS() {
+    return nullptr;
+  }
+
+  virtual MapleMap<OStIdx, ChiMeNode*> *GetChiList() {
+    return nullptr;
+  }
+
+  virtual const MapleMap<OStIdx, ChiMeNode*> *GetChiList() const {
+    return nullptr;
+  }
+
+  virtual MapleMap<OStIdx, ScalarMeExpr*> *GetMuList() {
+    return nullptr;
+  }
+
+  void CopyBase(const MeStmt &meStmt) {
+    bb = meStmt.bb;
+    srcPos = meStmt.srcPos;
+    isLive = meStmt.isLive;
+    originalId = meStmt.originalId;
+    meStmtId = meStmt.meStmtId;
+    stmtAttrs = meStmt.stmtAttrs;
+  }
+
+  bool IsTheSameWorkcand(const MeStmt&) const;
+  virtual bool NeedDecref() const {
+    return false;
+  }
+
+  virtual void EnableNeedDecref() {}
+
+  virtual void DisableNeedDecref() {}
+
+  virtual bool NeedIncref() const {
+    return false;
+  }
+
+  virtual void SetNeedIncref(bool value = true) {}
+
+  virtual void EnableNeedIncref() {}
+
+  virtual void DisableNeedIncref() {}
+
+  virtual ScalarMeExpr *GetLHS() const {
+    return nullptr;
+  }
+
+  virtual MeExpr *GetRHS() const {
+    return nullptr;
+  }
+
+  virtual ScalarMeExpr *GetVarLHS() const {
+    return nullptr;
+  }
+
+  virtual ScalarMeExpr *GetVarLHS() {
+    return nullptr;
+  }
+
+  virtual MeExpr *GetLHSRef(bool) {
+    return nullptr;
+  }
+
+  virtual StmtNode &EmitStmt(MapleAllocator &alloc);
+
+  void RemoveNode() {
+    // remove this node from the double link list
+    if (prev != nullptr) {
+      prev->next = next;
+    }
+    if (next != nullptr) {
+      next->prev = prev;
+    }
+  }
+
+  void AddNext(MeStmt *node) {
+    // add node to the next of this list
+    node->next = next;
+    node->prev = this;
+    if (next != nullptr) {
+      next->prev = node;
+    }
+    next = node;
+  }
+
+  void AddPrev(MeStmt *node) {
+    // add node to the prev of this list
+    node->prev = prev;
+    node->next = this;
+    if (prev != nullptr) {
+      prev->next = node;
+    }
+    prev = node;
+  }
+
+  const BB *GetBB() const { return bb; }
+  BB *GetBB() { return bb; }
+
+  void SetBB(BB *curBB) {
+    bb = curBB;
+  }
+
+  const SrcPosition &GetSrcPosition() const {
+    return srcPos;
+  }
+
+  void SetSrcPos(SrcPosition pos) {
+    srcPos = pos;
+  }
+
+  void CopyInfo(const MeStmt &stmt) {
+    this->srcPos = stmt.srcPos;
+    this->originalId = stmt.originalId;
+    this->stmtAttrs = stmt.stmtAttrs;
+  }
+
+  void SetPrev(MeStmt *v) {
+    prev = v;
+  }
+
+  void SetNext(MeStmt *n) {
+    next = n;
+  }
+
+  MeStmt *GetPrev() const {
+    return prev;
+  }
+
+  MeStmt *GetNext() const {
+    return next;
+  }
+
+  Opcode GetOp() const {
+    return op;
+  }
+
+  void SetOp(Opcode currOp) {
+    op = currOp;
+  }
+
+  void SetStmtInfoId(size_t index) {
+    stmtInfoId = index;
+  }
+
+  const size_t GetStmtInfoId() const {
+    return stmtInfoId;
+  }
+
+  uint32 GetOriginalId() const {
+    return originalId;
+  }
+
+  void SetOriginalId(uint32 id) {
+    originalId = id;
+  }
+
+  uint32 GetMeStmtId() const {
+    return meStmtId;
+  }
+
+  void SetMeStmtId(uint32 id) {
+    meStmtId = id;
+  }
+
+  bool IsInSafeRegion() const {
+    return stmtAttrs.GetAttr(STMTATTR_insaferegion);
+  }
+
+  void SetInSafeRegion() {
+    stmtAttrs.SetAttr(STMTATTR_insaferegion);
+  }
+
+  void CopySafeRegionAttr(const StmtAttrs &stmtAttr) {
+    this->stmtAttrs.AppendAttr(stmtAttr.GetTargetAttrFlag(STMTATTR_insaferegion));
+  }
+
+  const StmtAttrs &GetStmtAttr() const {
+    return stmtAttrs;
+  }
+
+ protected:
+  StmtAttrs stmtAttrs;
+
+ private:
+  uint32 originalId = 0xdeadbeef;
+  uint32 meStmtId = 0xdeadbeef;
+  size_t stmtInfoId = -1u;
+  Opcode op;
+  bool isLive = true;
+  BB *bb = nullptr;
+  SrcPosition srcPos;
+  MeStmt *prev = nullptr;
+  MeStmt *next = nullptr;
+};
+
+class ChiMeNode {
+ public:
+  explicit ChiMeNode(MeStmt *meStmt) : base(meStmt) {}
+
+  ~ChiMeNode() = default;
+
+  bool GetIsLive() const {
+    return isLive;
+  }
+
+  void SetIsLive(bool value) {
+    isLive = value;
+  }
+
+  ScalarMeExpr *GetRHS() {
+    return rhs;
+  }
+
+  const ScalarMeExpr *GetRHS() const {
+    return rhs;
+  }
+
+  void SetRHS(ScalarMeExpr *value) {
+    rhs = value;
+  }
+
+  ScalarMeExpr *GetLHS() const {
+    return lhs;
+  }
+
+  void SetLHS(ScalarMeExpr *value) {
+    lhs = value;
+  }
+
+  void Dump(const IRMap *irMap) const;
+
+  MeStmt *GetBase() const {
+    return base;
+  }
+
+  void SetBase(MeStmt *value) {
+    base = value;
+  }
+
+ private:
+  ScalarMeExpr *rhs = nullptr;
+  ScalarMeExpr *lhs = nullptr;
+  MeStmt *base;
+  bool isLive = true;
+};
+
+class MustDefMeNode {
+ public:
+  MustDefMeNode(ScalarMeExpr *x, MeStmt *meStmt) : lhs(x), base(meStmt) {
+    x->SetDefBy(kDefByMustDef);
+    x->SetDefMustDef(*this);
+  }
+
+  const ScalarMeExpr *GetLHS() const {
+    return lhs;
+  }
+
+  ScalarMeExpr *GetLHS() {
+    return lhs;
+  }
+
+  void SetLHS(ScalarMeExpr *value) {
+    lhs = value;
+  }
+
+  const MeStmt *GetBase() const {
+    return base;
+  }
+
+  MeStmt *GetBase() {
+    return base;
+  }
+
+  void SetBase(MeStmt *value) {
+    base = value;
+  }
+
+  bool GetIsLive() const {
+    return isLive;
+  }
+
+  void SetIsLive(bool value) {
+    isLive = value;
+  }
+
+  MustDefMeNode(const MustDefMeNode &mustDef) {
+    lhs = mustDef.lhs;
+    base = mustDef.base;
+    isLive = mustDef.isLive;
+    UpdateLHS(*lhs);
+  }
+
+  MustDefMeNode &operator=(const MustDefMeNode &mustDef) {
+    if (&mustDef != this) {
+      lhs = mustDef.lhs;
+      base = mustDef.base;
+      isLive = mustDef.isLive;
+      UpdateLHS(*lhs);
+    }
+    return *this;
+  }
+
+  void UpdateLHS(ScalarMeExpr &x) {
+    lhs = &x;
+    x.SetDefBy(kDefByMustDef);
+    x.SetDefMustDef(*this);
+  }
+
+  ~MustDefMeNode() = default;
+
+  void Dump(const IRMap*) const;
+
+ private:
+  ScalarMeExpr *lhs;  // could be var or register, can we make this private?
+  MeStmt *base;
+  bool isLive = true;
+};
+
+class PiassignMeStmt : public MeStmt {
+ public:
+  explicit PiassignMeStmt(MapleAllocator*)
+      : MeStmt(OP_piassign) {
+  }
+  ~PiassignMeStmt() = default;
+
+  void SetLHS(VarMeExpr &l) {
+    lhs = &l;
+  }
+
+  void SetRHS(VarMeExpr &r) {
+    rhs = &r;
+  }
+
+  void SetGeneratedBy(MeStmt &meStmt) {
+    generatedBy = &meStmt;
+  }
+
+  VarMeExpr *GetLHS() const override {
+    return lhs;
+  }
+
+  VarMeExpr *GetRHS() const override {
+    return rhs;
+  }
+
+  MeStmt *GetGeneratedBy() const {
+    return generatedBy;
+  }
+
+  void SetIsToken(bool t) {
+    isToken = t;
+  }
+
+  bool GetIsToken() const {
+    return isToken;
+  }
+
+  void Dump(const IRMap*) const override;
+
+ private:
+  VarMeExpr *rhs = nullptr;
+  VarMeExpr *lhs = nullptr;
+  MeStmt *generatedBy = nullptr;
+  bool isToken = false;
+};
+
+class AssignMeStmt : public MeStmt {
+ public:
+  explicit AssignMeStmt(const StmtNode *stt) : MeStmt(stt) {}
+
+  AssignMeStmt(Opcode op, ScalarMeExpr *theLhs, MeExpr *rhsVal) : MeStmt(op), rhs(rhsVal), lhs(theLhs) {}
+
+  ~AssignMeStmt() = default;
+
+  size_t NumMeStmtOpnds() const override {
+    return kOperandNumUnary;
+  }
+
+  MeExpr *GetOpnd(size_t) const override {
+    return rhs;
+  }
+
+  void SetOpnd(size_t, MeExpr *val) override {
+    rhs = val;
+  }
+
+  void Dump(const IRMap*) const override;
+
+  bool NeedIncref() const override {
+    return needIncref;
+  }
+
+  void SetNeedIncref(bool value = true) override {
+    needIncref = value;
+  }
+
+  void EnableNeedIncref() override {
+    needIncref = true;
+  }
+
+  void DisableNeedIncref() override {
+    needIncref = false;
+  }
+
+  bool NeedDecref() const override {
+    return needDecref;
+  }
+
+  void SetNeedDecref(bool value) {
+    needDecref = value;
+  }
+
+  void EnableNeedDecref() override {
+    needDecref = true;
+  }
+
+  void DisableNeedDecref() override {
+    needDecref = false;
+  }
+
+  ScalarMeExpr *GetLHS() const override {
+    return lhs;
+  }
+
+  MeExpr *GetRHS() const override {
+    return rhs;
+  }
+
+  void SetRHS(MeExpr *value) {
+    rhs = value;
+  }
+
+  void SetLHS(ScalarMeExpr *value) {
+    lhs = value;
+  }
+
+  void UpdateLhs(ScalarMeExpr *var) {
+    lhs = var;
+    var->SetDefBy(kDefByStmt);
+    var->SetDefStmt(this);
+  }
+
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+ protected:
+  MeExpr *rhs = nullptr;
+  ScalarMeExpr *lhs = nullptr;
+  bool needIncref = false;  // to be determined by analyzerc phase
+  bool needDecref = false;  // to be determined by analyzerc phase
+ public:
+  bool isIncDecStmt = false;  // has the form of an increment or decrement stmt
+};
+
+class DassignMeStmt : public AssignMeStmt {
+ public:
+  DassignMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : AssignMeStmt(stt),
+        chiList(std::less<OStIdx>(), alloc->Adapter()) {}
+
+  DassignMeStmt(MapleAllocator *alloc, VarMeExpr *theLhs, MeExpr *rhsVal)
+      : AssignMeStmt(OP_dassign, theLhs, rhsVal),
+        chiList(std::less<OStIdx>(), alloc->Adapter()) {}
+
+  DassignMeStmt(MapleAllocator *alloc, const DassignMeStmt *dass)
+      : AssignMeStmt(dass->GetOp(), dass->GetLHS(), dass->GetRHS()),
+        chiList(std::less<OStIdx>(), alloc->Adapter()) {}
+
+  ~DassignMeStmt() = default;
+
+  const MapleMap<OStIdx, ChiMeNode *> *GetChiList() const override {
+    return &chiList;
+  }
+
+  MapleMap<OStIdx, ChiMeNode *> *GetChiList() override {
+    return &chiList;
+  }
+
+  void SetChiList(const MapleMap<OStIdx, ChiMeNode*> &value) {
+    chiList = value;
+  }
+
+  bool Propagated() const {
+    return propagated;
+  }
+
+  void SetPropagated(bool value) {
+    propagated = value;
+  }
+
+  bool GetWasMayDassign() const {
+    return wasMayDassign;
+  }
+
+  void SetWasMayDassign(bool value) {
+    wasMayDassign = value;
+  }
+
+  void Dump(const IRMap*) const override;
+
+  ScalarMeExpr *GetVarLHS() const override {
+    return static_cast<VarMeExpr *>(lhs);
+  }
+
+  ScalarMeExpr *GetVarLHS() override {
+    return static_cast<VarMeExpr *>(lhs);
+  }
+
+  bool GetOmitEmit() const {
+    return omitEmit;
+  }
+
+  void SetOmitEmit(bool val) {
+    omitEmit = val;
+  }
+
+  bool GetEmitDassignoff() const {
+    return emitDassignoff;
+  }
+
+  void SetEmitDassignoff(bool val) {
+    emitDassignoff = val;
+  }
+
+  MeExpr *GetLHSRef(bool excludeLocalRefVar) override;
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+ private:
+  MapleMap<OStIdx, ChiMeNode*> chiList;
+  bool propagated = false;     // the RHS has been propagated forward
+  bool wasMayDassign = false;  // was converted back to dassign by may2dassign phase
+  bool emitDassignoff = false; // Emit Iassignoff instead
+  bool omitEmit = false;       // Skip this stmt instead
+};
+
+class MaydassignMeStmt : public MeStmt {
+ public:
+  MaydassignMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : MeStmt(stt),
+        chiList(std::less<OStIdx>(), alloc->Adapter()) {}
+
+  MaydassignMeStmt(MapleAllocator *alloc, MaydassignMeStmt &maydass)
+      : MeStmt(maydass.GetOp()), rhs(maydass.GetRHS()), mayDSSym(maydass.GetMayDassignSym()),
+        fieldID(maydass.GetFieldID()), chiList(std::less<OStIdx>(), alloc->Adapter()),
+        needDecref(maydass.NeedDecref()), needIncref(maydass.NeedIncref()) {}
+
+  ~MaydassignMeStmt() = default;
+
+  size_t NumMeStmtOpnds() const override {
+    return kOperandNumUnary;
+  }
+
+  MeExpr *GetOpnd(size_t) const override {
+    return rhs;
+  }
+
+  void SetOpnd(size_t, MeExpr *val) override {
+    rhs = val;
+  }
+
+  const MapleMap<OStIdx, ChiMeNode *> *GetChiList() const override {
+    return &chiList;
+  }
+
+  MapleMap<OStIdx, ChiMeNode *> *GetChiList() override {
+    return &chiList;
+  }
+
+  void SetChiList(const MapleMap<OStIdx, ChiMeNode*> &value) {
+    chiList = value;
+  }
+
+  bool NeedDecref() const override {
+    return needDecref;
+  }
+
+  void EnableNeedDecref() override {
+    needDecref = true;
+  }
+
+  void DisableNeedDecref() override {
+    needDecref = false;
+  }
+
+  bool NeedIncref() const override {
+    return needIncref;
+  }
+
+  void SetNeedIncref(bool val = true) override {
+    needIncref = val;
+  }
+
+  void EnableNeedIncref() override {
+    needIncref = true;
+  }
+
+  void DisableNeedIncref() override {
+    needIncref = false;
+  }
+
+  OriginalSt *GetMayDassignSym() {
+    return mayDSSym;
+  }
+
+  const OriginalSt *GetMayDassignSym() const {
+    return mayDSSym;
+  }
+
+  void SetMayDassignSym(OriginalSt *sym) {
+    mayDSSym = sym;
+  }
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(FieldID fieldIDVal) {
+    fieldID = fieldIDVal;
+  }
+
+  void Dump(const IRMap*) const override;
+  ScalarMeExpr *GetLHS() const override {
+    return chiList.find(mayDSSym->GetIndex())->second->GetLHS();
+  }
+
+  MeExpr *GetRHS() const override {
+    return rhs;
+  }
+
+  void SetRHS(MeExpr *value) {
+    rhs = value;
+  }
+
+  ScalarMeExpr *GetVarLHS() const override {
+    return chiList.find(mayDSSym->GetIndex())->second->GetLHS();
+  }
+
+  ScalarMeExpr *GetVarLHS() override {
+    return chiList.find(mayDSSym->GetIndex())->second->GetLHS();
+  }
+
+  MeExpr *GetLHSRef(bool excludeLocalRefVar) override;
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+ private:
+  MeExpr *rhs = nullptr;
+  OriginalSt *mayDSSym = nullptr;
+  FieldID fieldID = 0;
+  MapleMap<OStIdx, ChiMeNode*> chiList;
+  bool needDecref = false;  // to be determined by analyzerc phase
+  bool needIncref = false;  // to be determined by analyzerc phase
+};
+
+class IassignMeStmt : public MeStmt {
+ public:
+  IassignMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : MeStmt(stt),
+        chiList(std::less<OStIdx>(), alloc->Adapter()) {}
+
+  IassignMeStmt(MapleAllocator*, const IassignMeStmt &iss)
+      : MeStmt(iss),
+        tyIdx(iss.tyIdx),
+        lhsVar(iss.lhsVar),
+        rhs(iss.rhs),
+        chiList(iss.chiList) {
+  }
+
+  IassignMeStmt(MapleAllocator*, TyIdx tidx, IvarMeExpr *l, MeExpr *r, const MapleMap<OStIdx, ChiMeNode*> *clist)
+      : MeStmt(OP_iassign), tyIdx(tidx), lhsVar(l), rhs(r), chiList(*clist) {
+    l->SetDefStmt(this);
+  }
+
+  IassignMeStmt(MapleAllocator *alloc, TyIdx tidx, IvarMeExpr &l, MeExpr &r)
+      : MeStmt(OP_iassign), tyIdx(tidx), lhsVar(&l), rhs(&r), chiList(std::less<OStIdx>(), alloc->Adapter()) {
+    l.SetDefStmt(this);
+  }
+
+  ~IassignMeStmt() = default;
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx idx) {
+    tyIdx = idx;
+  }
+
+  size_t NumMeStmtOpnds() const override {
+    return kOperandNumBinary;
+  }
+
+  MeExpr *GetOpnd(size_t idx) const override {
+    return idx == 0 ? lhsVar->GetBase() : rhs;
+  }
+
+  void SetOpnd(size_t idx, MeExpr *val) override {
+    if (idx == 0) {
+      lhsVar->SetBase(val);
+    } else {
+      rhs = val;
+    }
+  }
+
+  const MapleMap<OStIdx, ChiMeNode*> *GetChiList() const override {
+    return &chiList;
+  }
+
+  MapleMap<OStIdx, ChiMeNode*> *GetChiList() override{
+    return &chiList;
+  }
+
+  void SetChiList(const MapleMap<OStIdx, ChiMeNode*> &value) {
+    chiList = value;
+  }
+
+  MeExpr *GetLHSRef(bool excludeLocalRefVar) override;
+  bool NeedDecref() const override {
+    return needDecref;
+  }
+
+  void EnableNeedDecref() override {
+    needDecref = true;
+  }
+
+  void DisableNeedDecref() override {
+    needDecref = false;
+  }
+
+  bool NeedIncref() const override {
+    return needIncref;
+  }
+
+  void SetNeedIncref(bool val = true) override {
+    needIncref = val;
+  }
+
+  void EnableNeedIncref() override {
+    needIncref = true;
+  }
+
+  void DisableNeedIncref() override {
+    needIncref = false;
+  }
+
+  void Dump(const IRMap*) const override;
+  MeExpr *GetRHS() const override {
+    return rhs;
+  }
+
+  void SetRHS(MeExpr *val) {
+    rhs = val;
+  }
+
+  IvarMeExpr *GetLHSVal() const {
+    return lhsVar;
+  }
+
+  void SetLHSVal(IvarMeExpr *val) {
+    lhsVar = val;
+    tyIdx = val->GetTyIdx();
+  }
+
+  bool GetOmitEmit() const {
+    return omitEmit;
+  }
+
+  void SetOmitEmit(bool val) {
+    omitEmit = val;
+  }
+
+  bool GetEmitIassignoff() const {
+    return emitIassignoff;
+  }
+
+  void SetEmitIassignoff(bool val) {
+    emitIassignoff = val;
+  }
+
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+  void SetExpandFromArrayOfCharFunc(bool flag = true) {
+    fromAoCFunc = flag;
+  }
+
+  bool IsExpandedFromArrayOfCharFunc() const {
+    return fromAoCFunc;
+  }
+
+ private:
+  TyIdx tyIdx{ 0 };
+  IvarMeExpr *lhsVar = nullptr;
+  MeExpr *rhs = nullptr;
+  MapleMap<OStIdx, ChiMeNode*> chiList;
+  bool needDecref = false;  // to be determined by analyzerc phase
+  bool needIncref = false;  // to be determined by analyzerc phase
+  bool emitIassignoff = false; // Emit Iassignoff instead
+  bool omitEmit = false;       // Skip this stmt instead
+  bool fromAoCFunc = false;    // Array of char func, defined in <string.h>
+};
+
+class NaryMeStmt : public MeStmt {
+ public:
+  NaryMeStmt(MapleAllocator *alloc, const StmtNode *stt) : MeStmt(stt), opnds(alloc->Adapter()) {}
+
+  NaryMeStmt(MapleAllocator *alloc, Opcode op) : MeStmt(op), opnds(alloc->Adapter()) {}
+
+  NaryMeStmt(MapleAllocator *alloc, const NaryMeStmt *nstmt) : MeStmt(nstmt->GetOp()), opnds(alloc->Adapter()) {
+    for (MeExpr *o : nstmt->opnds) {
+      opnds.push_back(o);
+    }
+  }
+
+  virtual ~NaryMeStmt() = default;
+
+  size_t NumMeStmtOpnds() const override {
+    return opnds.size();
+  }
+
+  MeExpr *GetOpnd(size_t idx) const override {
+    ASSERT(idx < opnds.size(), "out of range in NaryMeStmt::GetOpnd");
+    return opnds.at(idx);
+  }
+
+  void SetOpnd(size_t idx, MeExpr *val) override {
+    opnds[idx] = val;
+  }
+
+  const MapleVector<MeExpr*> &GetOpnds() const {
+    return opnds;
+  }
+
+  void PushBackOpnd(MeExpr *val) {
+    opnds.push_back(val);
+  }
+
+  void PopBackOpnd() {
+    opnds.pop_back();
+  }
+
+  void SetOpnds(const MapleVector<MeExpr*> &opndsVal) {
+    opnds = opndsVal;
+  }
+
+  void EraseOpnds(const MapleVector<MeExpr*>::const_iterator begin, const MapleVector<MeExpr*>::const_iterator end) {
+    (void)opnds.erase(begin, end);
+  }
+
+  void EraseOpnds(const MapleVector<MeExpr *>::const_iterator it) {
+    (void)opnds.erase(it);
+  }
+
+  void InsertOpnds(const MapleVector<MeExpr*>::const_iterator begin, MeExpr *expr) {
+    (void)opnds.insert(begin, expr);
+  }
+
+  void DumpOpnds(const IRMap*) const;
+  void Dump(const IRMap*) const override;
+  MapleMap<OStIdx, ScalarMeExpr*> *GetMuList() override {
+    return nullptr;
+  }
+
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+ private:
+  MapleVector<MeExpr*> opnds;
+};
+
+class MuChiMePart {
+ public:
+  explicit MuChiMePart(MapleAllocator *alloc)
+      : muList(std::less<OStIdx>(), alloc->Adapter()), chiList(std::less<OStIdx>(), alloc->Adapter()) {}
+
+  virtual MapleMap<OStIdx, ChiMeNode*> *GetChiList() {
+    return &chiList;
+  }
+
+  void SetChiList(const MapleMap<OStIdx, ChiMeNode*> &value) {
+    chiList = value;
+  }
+
+  virtual ~MuChiMePart() = default;
+
+ protected:
+  MapleMap<OStIdx, ScalarMeExpr*> muList;
+  MapleMap<OStIdx, ChiMeNode*> chiList;
+};
+
+class AssignedPart {
+ public:
+  explicit AssignedPart(MapleAllocator *alloc) : mustDefList(alloc->Adapter()) {}
+
+  AssignedPart(MapleAllocator *alloc, MeStmt *defStmt, const MapleVector<MustDefMeNode> &mustDefList)
+      : mustDefList(alloc->Adapter()) {
+    for (auto &mustDef : mustDefList) {
+      auto newMustDefNode = alloc->GetMemPool()->New<MustDefMeNode>(mustDef);
+      newMustDefNode->SetBase(defStmt);
+      this->mustDefList.push_back(*newMustDefNode);
+    }
+  }
+
+  virtual ~AssignedPart() = default;
+
+  void DumpAssignedPart(const IRMap *irMap) const;
+  VarMeExpr *GetAssignedPartLHSRef(bool excludeLocalRefVar);
+
+ protected:
+  MapleVector<MustDefMeNode> mustDefList;
+  bool needDecref = false;  // to be determined by analyzerc phase
+  bool needIncref = false;  // to be determined by analyzerc phase
+};
+
+class CallMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart {
+ public:
+  CallMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : NaryMeStmt(alloc, stt),
+        MuChiMePart(alloc),
+        AssignedPart(alloc),
+        puIdx(static_cast<const CallNode*>(stt)->GetPUIdx()),
+        stmtID(stt->GetStmtID()),
+        tyIdx(static_cast<const CallNode*>(stt)->GetTyIdx()) {}
+
+  CallMeStmt(MapleAllocator *alloc, Opcode op)
+      : NaryMeStmt(alloc, op), MuChiMePart(alloc), AssignedPart(alloc) {}
+
+  CallMeStmt(MapleAllocator *alloc, const NaryMeStmt *cstmt, PUIdx idx)
+      : NaryMeStmt(alloc, cstmt),
+        MuChiMePart(alloc),
+        AssignedPart(alloc),
+        puIdx(idx) {}
+
+  CallMeStmt(MapleAllocator *alloc, const CallMeStmt *cstmt)
+      : NaryMeStmt(alloc, cstmt),
+        MuChiMePart(alloc),
+        AssignedPart(alloc, this, cstmt->mustDefList),
+        puIdx(cstmt->GetPUIdx()) {}
+
+  virtual ~CallMeStmt() = default;
+
+  PUIdx GetPUIdx() const {
+    return puIdx;
+  }
+
+  void SetPUIdx(PUIdx idx) {
+    puIdx = idx;
+  }
+
+  TyIdx GetTyIdx() const { return tyIdx; }
+
+  uint32 GetStmtID() const {
+    return stmtID;
+  }
+
+  void Dump(const IRMap*) const override;
+  MapleMap<OStIdx, ScalarMeExpr*> *GetMuList() override {
+    return &muList;
+  }
+
+  const MapleMap<OStIdx, ChiMeNode*> *GetChiList() const override {
+    return &chiList;
+  }
+
+  MapleMap<OStIdx, ChiMeNode *> *GetChiList() override {
+    return &chiList;
+  }
+
+  void SetChiList(MapleMap<OStIdx, ChiMeNode *> &list) {
+    chiList = list;
+  }
+
+  MapleVector<MustDefMeNode> *GetMustDefList() override {
+    return &mustDefList;
+  }
+
+  const MapleVector<MustDefMeNode> &GetMustDefList() const override {
+    return mustDefList;
+  }
+
+  void SetMustDefList(MapleVector<MustDefMeNode> &list) {
+    mustDefList = list;
+  }
+
+  MustDefMeNode &GetMustDefListItem(int i) {
+    return mustDefList[i];
+  }
+
+  size_t MustDefListSize() const {
+    return mustDefList.size();
+  }
+
+  const ScalarMeExpr *GetAssignedLHS() const override {
+    return mustDefList.empty() ? nullptr : mustDefList.front().GetLHS();
+  }
+
+  ScalarMeExpr *GetAssignedLHS() override {
+    return mustDefList.empty() ? nullptr : mustDefList.front().GetLHS();
+  }
+
+  MeExpr *GetLHSRef(bool excludeLocalRefVar) override {
+    return GetAssignedPartLHSRef(excludeLocalRefVar);
+  }
+
+  ScalarMeExpr *GetVarLHS() override {
+    if (mustDefList.empty() || mustDefList.front().GetLHS()->GetMeOp() != kMeOpVar) {
+      return nullptr;
+    }
+    return static_cast<VarMeExpr*>(mustDefList.front().GetLHS());
+  }
+
+  bool NeedDecref() const override {
+    return needDecref;
+  }
+
+  void EnableNeedDecref() override {
+    needDecref = true;
+  }
+
+  void DisableNeedDecref() override {
+    needDecref = false;
+  }
+
+  bool NeedIncref() const override {
+    return needIncref;
+  }
+
+  void EnableNeedIncref() override {
+    needIncref = true;
+  }
+
+  void DisableNeedIncref() override {
+    needIncref = false;
+  }
+
+  MIRType *GetReturnType() const override {
+    MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+    return callee->GetReturnType();
+  }
+
+  const MIRFunction &GetTargetFunction() const;
+  MIRFunction &GetTargetFunction();
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+  void SetCallReturn(ScalarMeExpr&);
+
+ private:
+  PUIdx puIdx = 0;
+  // Used in trim call graph
+  uint32 stmtID = 0;
+  TyIdx tyIdx;
+};
+
+class IcallMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart {
+ public:
+  IcallMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : NaryMeStmt(alloc, stt),
+        MuChiMePart(alloc),
+        AssignedPart(alloc),
+        retTyIdx(static_cast<const IcallNode*>(stt)->GetRetTyIdx()),
+        stmtID(stt->GetStmtID()) {}
+
+  IcallMeStmt(MapleAllocator *alloc, Opcode op)
+      : NaryMeStmt(alloc, op), MuChiMePart(alloc), AssignedPart(alloc) {}
+
+  IcallMeStmt(MapleAllocator *alloc, const IcallMeStmt *cstmt)
+      : NaryMeStmt(alloc, cstmt),
+        MuChiMePart(alloc),
+        AssignedPart(alloc, this, cstmt->mustDefList),
+        retTyIdx(cstmt->retTyIdx),
+        stmtID(cstmt->stmtID) {}
+
+  IcallMeStmt(MapleAllocator *alloc, const NaryMeStmt *nary, TyIdx idx, uint32 id)
+      : NaryMeStmt(alloc, nary),
+        MuChiMePart(alloc),
+        AssignedPart(alloc),
+        retTyIdx(idx),
+        stmtID(id) {}
+
+  virtual ~IcallMeStmt() = default;
+
+  void Dump(const IRMap*) const override;
+  MapleMap<OStIdx, ScalarMeExpr*> *GetMuList() override {
+    return &muList;
+  }
+
+  const MapleMap<OStIdx, ChiMeNode*> *GetChiList() const override {
+    return &chiList;
+  }
+
+  MapleMap<OStIdx, ChiMeNode *> *GetChiList() override {
+    return &chiList;
+  }
+
+  MapleVector<MustDefMeNode> *GetMustDefList() override {
+    return &mustDefList;
+  }
+
+  const MapleVector<MustDefMeNode> &GetMustDefList() const override {
+    return mustDefList;
+  }
+
+  const ScalarMeExpr *GetAssignedLHS() const override {
+    return mustDefList.empty() ? nullptr : mustDefList.front().GetLHS();
+  }
+
+  ScalarMeExpr *GetAssignedLHS() override {
+    return mustDefList.empty() ? nullptr : mustDefList.front().GetLHS();
+  }
+
+  ScalarMeExpr *GetVarLHS() override {
+    if (mustDefList.empty() || mustDefList.front().GetLHS()->GetMeOp() != kMeOpVar) {
+      return nullptr;
+    }
+    return static_cast<VarMeExpr*>(mustDefList.front().GetLHS());
+  }
+
+  MeExpr *GetLHSRef(bool excludeLocalRefVar) override {
+    return GetAssignedPartLHSRef(excludeLocalRefVar);
+  }
+
+  bool NeedDecref() const override {
+    return needDecref;
+  }
+
+  void EnableNeedDecref() override {
+    needDecref = true;
+  }
+
+  void DisableNeedDecref() override {
+    needDecref = false;
+  }
+
+  bool NeedIncref() const override {
+    return needIncref;
+  }
+
+  void EnableNeedIncref() override {
+    needIncref = true;
+  }
+
+  void DisableNeedIncref() override {
+    needIncref = false;
+  }
+
+  MIRType *GetReturnType() const override {
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(retTyIdx);
+  }
+
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+  TyIdx GetRetTyIdx() const {
+    return retTyIdx;
+  }
+
+  void SetRetTyIdx(TyIdx idx) {
+    retTyIdx = idx;
+  }
+
+  uint32 GetStmtID() const {
+    return stmtID;
+  }
+
+ private:
+  // return type for callee
+  TyIdx retTyIdx{ 0 };
+  // Used in trim call graph
+  uint32 stmtID = 0;
+};
+
+class IntrinsiccallMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart {
+ public:
+  IntrinsiccallMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : NaryMeStmt(alloc, stt),
+        MuChiMePart(alloc),
+        AssignedPart(alloc),
+        intrinsic(static_cast<const IntrinsiccallNode*>(stt)->GetIntrinsic()),
+        tyIdx(static_cast<const IntrinsiccallNode*>(stt)->GetTyIdx()),
+        retPType(stt->GetPrimType()) {}
+
+  IntrinsiccallMeStmt(MapleAllocator *alloc, Opcode op, MIRIntrinsicID id, TyIdx tyid = TyIdx())
+      : NaryMeStmt(alloc, op),
+        MuChiMePart(alloc),
+        AssignedPart(alloc),
+        intrinsic(id),
+        tyIdx(tyid) {}
+
+  IntrinsiccallMeStmt(MapleAllocator *alloc, const IntrinsiccallMeStmt *intrn)
+      : NaryMeStmt(alloc, intrn),
+        MuChiMePart(alloc),
+        AssignedPart(alloc, this, intrn->mustDefList),
+        intrinsic(intrn->GetIntrinsic()),
+        tyIdx(intrn->tyIdx),
+        retPType(intrn->retPType) {}
+
+  IntrinsiccallMeStmt(MapleAllocator *alloc, const NaryMeStmt *nary, MIRIntrinsicID id, TyIdx idx, PrimType type)
+      : NaryMeStmt(alloc, nary),
+        MuChiMePart(alloc),
+        AssignedPart(alloc),
+        intrinsic(id),
+        tyIdx(idx),
+        retPType(type) {}
+
+  virtual ~IntrinsiccallMeStmt() = default;
+
+  void Dump(const IRMap*) const override;
+  MapleMap<OStIdx, ScalarMeExpr*> *GetMuList() override {
+    return &muList;
+  }
+
+  const MapleMap<OStIdx, ChiMeNode*> *GetChiList() const override {
+    return &chiList;
+  }
+
+  MapleMap<OStIdx, ChiMeNode *> *GetChiList() override {
+    return &chiList;
+  }
+
+  MIRType *GetReturnType() const override {
+    if (!mustDefList.empty()) {
+      return GlobalTables::GetTypeTable().GetPrimType(mustDefList.front().GetLHS()->GetPrimType());
+    }
+    return GlobalTables::GetTypeTable().GetPrimType(retPType);
+  }
+
+  MapleVector<MustDefMeNode> *GetMustDefList() override {
+    return &mustDefList;
+  }
+
+  const MapleVector<MustDefMeNode> &GetMustDefList() const override {
+    return mustDefList;
+  }
+
+  MustDefMeNode &GetMustDefListItem(int i) {
+    return mustDefList[i];
+  }
+
+  const ScalarMeExpr *GetAssignedLHS() const override {
+    return mustDefList.empty() ? nullptr : mustDefList.front().GetLHS();
+  }
+
+  ScalarMeExpr *GetAssignedLHS() override {
+    return mustDefList.empty() ? nullptr : mustDefList.front().GetLHS();
+  }
+
+  MeExpr *GetLHSRef(bool excludeLocalRefVar) override {
+    return GetAssignedPartLHSRef(excludeLocalRefVar);
+  }
+
+  bool NeedDecref() const override {
+    return needDecref;
+  }
+
+  void EnableNeedDecref() override {
+    needDecref = true;
+  }
+
+  void DisableNeedDecref() override {
+    needDecref = false;
+  }
+
+  bool NeedIncref() const  override{
+    return needIncref;
+  }
+
+  void EnableNeedIncref() override {
+    needIncref = true;
+  }
+
+  void DisableNeedIncref() override {
+    needIncref = false;
+  }
+
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+  MIRIntrinsicID GetIntrinsic() const {
+    return intrinsic;
+  }
+
+  void SetIntrinsic(MIRIntrinsicID id) {
+    intrinsic = id;
+  }
+
+  TyIdx GetTyIdx() const {
+    return tyIdx;
+  }
+
+  PrimType GetReturnPrimType() const {
+    return retPType;
+  }
+
+ private:
+  MIRIntrinsicID intrinsic;
+  TyIdx tyIdx;
+  // Used to store return value type
+  PrimType retPType = kPtyInvalid;
+};
+
+class AsmMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart {
+ public:
+  AsmMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : NaryMeStmt(alloc, stt),
+        MuChiMePart(alloc),
+        AssignedPart(alloc),
+        asmString(alloc->GetMemPool()),
+        inputConstraints(alloc->Adapter()),
+        outputConstraints(alloc->Adapter()),
+        clobberList(alloc->Adapter()),
+        gotoLabels(alloc->Adapter()),
+        qualifiers(static_cast<const AsmNode *>(stt)->qualifiers) {
+            asmString = static_cast<const AsmNode *>(stt)->asmString;
+            inputConstraints = static_cast<const AsmNode *>(stt)->inputConstraints;
+            outputConstraints = static_cast<const AsmNode *>(stt)->outputConstraints;
+            clobberList = static_cast<const AsmNode *>(stt)->clobberList;
+            gotoLabels = static_cast<const AsmNode *>(stt)->gotoLabels;
+        }
+
+  AsmMeStmt(MapleAllocator *alloc, const AsmMeStmt *stt)
+      : NaryMeStmt(alloc, stt),
+        MuChiMePart(alloc),
+        AssignedPart(alloc),
+        asmString(alloc->GetMemPool()),
+        inputConstraints(alloc->Adapter()),
+        outputConstraints(alloc->Adapter()),
+        clobberList(alloc->Adapter()),
+        gotoLabels(alloc->Adapter()),
+        qualifiers(stt->qualifiers) {
+    asmString = stt->asmString;
+    inputConstraints = stt->inputConstraints;
+    outputConstraints = stt->outputConstraints;
+    clobberList = stt->clobberList;
+    gotoLabels = stt->gotoLabels;
+  }
+
+  virtual ~AsmMeStmt() = default;
+  void Dump(const IRMap*) const override;
+  MapleMap<OStIdx, ScalarMeExpr *> *GetMuList() override {
+    return &muList;
+  }
+  const MapleMap<OStIdx, ChiMeNode*> *GetChiList() const override {
+    return &chiList;
+  }
+  MapleMap<OStIdx, ChiMeNode *> *GetChiList() override {
+    return &chiList;
+  }
+  MapleVector<MustDefMeNode> *GetMustDefList() override {
+    return &mustDefList;
+  }
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+  MapleString asmString;
+  MapleVector<UStrIdx> inputConstraints;  // length is numOpnds
+  MapleVector<UStrIdx> outputConstraints; // length is returnValues.size()
+  MapleVector<UStrIdx> clobberList;
+  MapleVector<LabelIdx> gotoLabels;
+  uint32 qualifiers;
+};
+
+class RetMeStmt : public NaryMeStmt {
+ public:
+  RetMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : NaryMeStmt(alloc, stt), muList(std::less<OStIdx>(), alloc->Adapter()) {}
+
+  ~RetMeStmt() = default;
+
+  void Dump(const IRMap*) const override;
+  MapleMap<OStIdx, ScalarMeExpr*> *GetMuList() override {
+    return &muList;
+  }
+
+ private:
+  MapleMap<OStIdx, ScalarMeExpr*> muList;
+};
+
+// eval, free, decref, incref, decrefreset, assertnonnull, igoto
+class UnaryMeStmt : public MeStmt {
+ public:
+  explicit UnaryMeStmt(const StmtNode *stt) : MeStmt(stt) {}
+
+  explicit UnaryMeStmt(Opcode o) : MeStmt(o) {}
+
+  explicit UnaryMeStmt(const UnaryMeStmt *umestmt) : MeStmt(umestmt->GetOp()), opnd(umestmt->opnd) {}
+
+  virtual ~UnaryMeStmt() = default;
+
+  size_t NumMeStmtOpnds() const override {
+    return kOperandNumUnary;
+  }
+
+  MeExpr *GetOpnd(size_t) const override {
+    return opnd;
+  }
+
+  void SetOpnd(size_t, MeExpr *val) override {
+    opnd = val;
+  }
+
+  MeExpr *GetOpnd() const {
+    return opnd;
+  }
+
+  void SetMeStmtOpndValue(MeExpr *val) {
+    opnd = val;
+  }
+
+  void Dump(const IRMap*) const override;
+
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+ private:
+  MeExpr *opnd = nullptr;
+};
+
+class SafetyCallCheckMeStmt {
+ public:
+  SafetyCallCheckMeStmt(GStrIdx funcNameIdx, size_t paramIndex, GStrIdx stmtFuncNameIdx)
+      : funcNameIdx(funcNameIdx), paramIndex(paramIndex), stmtFuncNameIdx(stmtFuncNameIdx) {}
+  explicit SafetyCallCheckMeStmt(const SafetyCallCheckMeStmt& stmt)
+      : funcNameIdx(stmt.GetFuncNameIdx()), paramIndex(stmt.GetParamIndex()),
+        stmtFuncNameIdx(stmt.GetStmtFuncNameIdx()) {}
+
+  virtual ~SafetyCallCheckMeStmt() = default;
+
+  const std::string& GetFuncName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(funcNameIdx);
+  }
+
+  const std::string& GetStmtFuncName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(stmtFuncNameIdx);
+  }
+
+  GStrIdx GetFuncNameIdx() const {
+    return funcNameIdx;
+  }
+
+  size_t GetParamIndex() const {
+    return paramIndex;
+  }
+
+  GStrIdx GetStmtFuncNameIdx() const {
+    return stmtFuncNameIdx;
+  }
+
+ private:
+  GStrIdx funcNameIdx;
+  size_t paramIndex;
+  GStrIdx stmtFuncNameIdx;
+};
+
+class SafetyCheckMeStmt {
+ public:
+  virtual ~SafetyCheckMeStmt() = default;
+
+  const std::string& GetFuncName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(funcNameIdx);
+  }
+
+  GStrIdx GetFuncNameIdx() const {
+    return funcNameIdx;
+  }
+
+ protected:
+  explicit SafetyCheckMeStmt(GStrIdx funcNameIdx)
+      : funcNameIdx(funcNameIdx) {}
+  explicit SafetyCheckMeStmt(const SafetyCheckMeStmt& stmt)
+      : funcNameIdx(stmt.GetFuncNameIdx()) {}
+  SafetyCheckMeStmt() {}
+
+ private:
+  GStrIdx funcNameIdx;
+};
+
+class AssertNonnullMeStmt : public UnaryMeStmt, public SafetyCheckMeStmt {
+ public:
+  explicit AssertNonnullMeStmt(const AssertNonnullStmtNode *stt)
+      : UnaryMeStmt(stt), SafetyCheckMeStmt(stt->GetFuncNameIdx()) {}
+  explicit AssertNonnullMeStmt(const UnaryStmtNode *stt)
+      : UnaryMeStmt(stt), SafetyCheckMeStmt() {}
+  explicit AssertNonnullMeStmt(const AssertNonnullMeStmt &stt)
+      : UnaryMeStmt(&stt), SafetyCheckMeStmt(static_cast<const SafetyCheckMeStmt&>(stt)) {}
+  ~AssertNonnullMeStmt() = default;
+  StmtNode &EmitStmt(MapleAllocator &alloc);
+};
+
+class CallAssertNonnullMeStmt : public UnaryMeStmt, public SafetyCallCheckMeStmt {
+ public:
+  explicit CallAssertNonnullMeStmt(const CallAssertNonnullStmtNode *stt)
+      : UnaryMeStmt(stt), SafetyCallCheckMeStmt(stt->GetFuncNameIdx(), stt->GetParamIndex(),
+                                                stt->GetStmtFuncNameIdx()) {}
+  CallAssertNonnullMeStmt(Opcode o, GStrIdx funcNameIdx, size_t paramIndex, GStrIdx stmtFuncNameIdx)
+      : UnaryMeStmt(o), SafetyCallCheckMeStmt(funcNameIdx, paramIndex, stmtFuncNameIdx) {}
+  explicit CallAssertNonnullMeStmt(const CallAssertNonnullMeStmt &stt)
+      : UnaryMeStmt(stt), SafetyCallCheckMeStmt(static_cast<const SafetyCallCheckMeStmt&>(stt)) {}
+  explicit CallAssertNonnullMeStmt(const CallAssertNonnullMeStmt *stt)
+      : UnaryMeStmt(*stt), SafetyCallCheckMeStmt(static_cast<const SafetyCallCheckMeStmt&>(*stt)) {}
+  ~CallAssertNonnullMeStmt() = default;
+  StmtNode &EmitStmt(MapleAllocator &alloc);
+};
+
+class AssertBoundaryMeStmt : public NaryMeStmt, public SafetyCheckMeStmt {
+ public:
+  AssertBoundaryMeStmt(MapleAllocator *alloc, const AssertBoundaryStmtNode *stt)
+      : NaryMeStmt(alloc, stt), SafetyCheckMeStmt(stt->GetFuncNameIdx()) {}
+  AssertBoundaryMeStmt(MapleAllocator *alloc, const AssertBoundaryMeStmt &stt)
+      : NaryMeStmt(alloc, static_cast<const NaryMeStmt*>(&stt)),
+        SafetyCheckMeStmt(static_cast<const SafetyCheckMeStmt&>(stt)) {}
+  ~AssertBoundaryMeStmt() = default;
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+};
+
+class CallAssertBoundaryMeStmt : public NaryMeStmt, public SafetyCallCheckMeStmt {
+ public:
+  CallAssertBoundaryMeStmt(MapleAllocator *alloc, const CallAssertBoundaryStmtNode *stt)
+      : NaryMeStmt(alloc, stt), SafetyCallCheckMeStmt(stt->GetFuncNameIdx(), stt->GetParamIndex(),
+                                                      stt->GetStmtFuncNameIdx()) {}
+  CallAssertBoundaryMeStmt(MapleAllocator *alloc, const CallAssertBoundaryMeStmt &stt)
+      : NaryMeStmt(alloc, static_cast<const NaryMeStmt*>(&stt)),
+        SafetyCallCheckMeStmt(static_cast<const SafetyCallCheckMeStmt&>(stt)) {}
+  ~CallAssertBoundaryMeStmt() = default;
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+};
+
+class GotoMeStmt : public MeStmt {
+ public:
+  explicit GotoMeStmt(const StmtNode *stt) : MeStmt(stt), offset(static_cast<const GotoNode*>(stt)->GetOffset()) {}
+  explicit GotoMeStmt(const GotoMeStmt &condGoto) : MeStmt(MeStmt(condGoto.GetOp())), offset(condGoto.GetOffset()) {}
+  explicit GotoMeStmt(uint32 o) : MeStmt(OP_goto), offset(o) {}
+
+  ~GotoMeStmt() = default;
+
+  uint32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(uint32 o) {
+    offset = o;
+  }
+
+  StmtNode &EmitStmt(MapleAllocator &alloc);
+
+ private:
+  uint32 offset;  // the label
+};
+
+class CondGotoMeStmt : public UnaryMeStmt {
+ public:
+  explicit CondGotoMeStmt(const StmtNode *stt)
+      : UnaryMeStmt(stt), offset(static_cast<const CondGotoNode*>(stt)->GetOffset()),
+        branchProb(static_cast<const CondGotoNode*>(stt)->GetBranchProb()) {}
+
+  explicit CondGotoMeStmt(const CondGotoMeStmt &condGoto)
+      : UnaryMeStmt(static_cast<const UnaryMeStmt*>(&condGoto)), offset(condGoto.GetOffset()),
+        branchProb(condGoto.branchProb) {}
+
+  CondGotoMeStmt(const UnaryMeStmt &unaryMeStmt, uint32 o)
+      : UnaryMeStmt(&unaryMeStmt), offset(o) {}
+
+  ~CondGotoMeStmt() = default;
+
+  uint32 GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(uint32 currOffset) {
+    offset = currOffset;
+  }
+
+  bool IsBranchProbValid() const {
+    return branchProb > 0 && branchProb < CondGotoNode::probAll;
+  }
+
+  int32 GetBranchProb() const {
+    return branchProb;
+  }
+
+  void SetBranchProb(int32 prob) {
+    branchProb = prob;
+  }
+
+  void ReverseBranchProb() {
+    if (IsBranchProbValid()) {
+      branchProb = CondGotoNode::probAll - branchProb;
+    }
+  }
+
+  void InvalidateBranchProb() {
+    if (IsBranchProbValid()) {
+      branchProb = -1;
+    }
+  }
+
+  void Dump(const IRMap*) const override;
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+ private:
+  uint32 offset;  // the label
+  int32 branchProb = -1;  // branch probability, a negative number indicates that the probability is invalid
+};
+
+class JsTryMeStmt : public MeStmt {
+ public:
+  explicit JsTryMeStmt(const StmtNode *stt)
+      : MeStmt(stt),
+        catchOffset(static_cast<const JsTryNode*>(stt)->GetCatchOffset()),
+        finallyOffset(static_cast<const JsTryNode*>(stt)->GetFinallyOffset()) {}
+
+  ~JsTryMeStmt() = default;
+
+  StmtNode &EmitStmt(MapleAllocator &alloc);
+
+ private:
+  uint16 catchOffset;
+  uint16 finallyOffset;
+};
+
+class TryMeStmt : public MeStmt {
+ public:
+  TryMeStmt(MapleAllocator *alloc, const StmtNode *stt) : MeStmt(stt), offsets(alloc->Adapter()) {}
+
+  ~TryMeStmt() = default;
+
+  void OffsetsPushBack(LabelIdx curr) {
+    offsets.push_back(curr);
+  }
+
+  const MapleVector<LabelIdx> &GetOffsets() const {
+    return offsets;
+  }
+
+  StmtNode &EmitStmt(MapleAllocator &alloc);
+
+ private:
+  MapleVector<LabelIdx> offsets;
+};
+
+class CatchMeStmt : public MeStmt {
+ public:
+  CatchMeStmt(MapleAllocator *alloc, const StmtNode *stt) : MeStmt(stt), exceptionTyIdxVec(alloc->Adapter()) {
+    for (auto it : static_cast<const CatchNode*>(stt)->GetExceptionTyIdxVec()) {
+      exceptionTyIdxVec.push_back(it);
+    }
+  }
+
+  ~CatchMeStmt() = default;
+
+  StmtNode &EmitStmt(MapleAllocator &alloc);
+  const MapleVector<TyIdx> &GetExceptionTyIdxVec() const {
+    return exceptionTyIdxVec;
+  }
+ private:
+  MapleVector<TyIdx> exceptionTyIdxVec;
+};
+
+class CppCatchMeStmt : public MeStmt {
+ public:
+  TyIdx exceptionTyIdx;
+
+  CppCatchMeStmt(const MapleAllocator *alloc, const StmtNode *stt) : MeStmt(stt) {
+    (void)alloc;
+  }
+
+  ~CppCatchMeStmt() = default;
+  StmtNode &EmitStmt(MapleAllocator &alloc);
+};
+
+class SwitchMeStmt : public UnaryMeStmt {
+ public:
+  SwitchMeStmt(MapleAllocator *alloc, StmtNode *stt)
+      : UnaryMeStmt(stt),
+        defaultLabel(static_cast<SwitchNode*>(stt)->GetDefaultLabel()),
+        switchTable(alloc->Adapter()) {
+    switchTable = static_cast<SwitchNode*>(stt)->GetSwitchTable();
+  }
+
+  ~SwitchMeStmt() = default;
+
+  LabelIdx GetDefaultLabel() const {
+    return defaultLabel;
+  }
+
+  void SetDefaultLabel(LabelIdx curr) {
+    defaultLabel = curr;
+  }
+
+  void SetCaseLabel(size_t caseIdx, LabelIdx label) {
+    switchTable[caseIdx].second = label;
+  }
+
+  CaseVector &GetSwitchTable() {
+    return switchTable;
+  }
+
+  const CaseVector &GetSwitchTable() const {
+    return switchTable;
+  }
+
+  void Dump(const IRMap*) const override;
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+ private:
+  LabelIdx defaultLabel;
+  CaseVector switchTable;
+};
+
+class CommentMeStmt : public MeStmt {
+ public:
+  CommentMeStmt(const MapleAllocator *alloc, const StmtNode *stt) : MeStmt(stt), comment(alloc->GetMemPool()) {
+    comment = static_cast<const CommentNode*>(stt)->GetComment();
+  }
+
+  ~CommentMeStmt() = default;
+
+  StmtNode &EmitStmt(MapleAllocator &alloc);
+  const MapleString& GetComment() { return comment; }
+  const MapleString& GetComment() const { return comment; }
+ private:
+  MapleString comment;
+};
+
+class WithMuMeStmt : public MeStmt {
+ public:
+  WithMuMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : MeStmt(stt), muList(std::less<OStIdx>(), alloc->Adapter()) {}
+
+  virtual ~WithMuMeStmt() = default;
+
+  MapleMap<OStIdx, ScalarMeExpr*> *GetMuList() override {
+    return &muList;
+  }
+
+  const MapleMap<OStIdx, ScalarMeExpr*> *GetMuList() const {
+    return &muList;
+  }
+
+ private:
+  MapleMap<OStIdx, ScalarMeExpr*> muList;
+};
+
+class GosubMeStmt : public WithMuMeStmt {
+ public:
+  GosubMeStmt(MapleAllocator *alloc, const StmtNode *stt)
+      : WithMuMeStmt(alloc, stt), offset(static_cast<const GotoNode*>(stt)->GetOffset()) {}
+
+  ~GosubMeStmt() = default;
+
+  void Dump(const IRMap*) const override;
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+ private:
+  uint32 offset;  // the label
+};
+
+class ThrowMeStmt : public WithMuMeStmt {
+ public:
+  ThrowMeStmt(MapleAllocator *alloc, const StmtNode *stt) : WithMuMeStmt(alloc, stt) {}
+
+  ~ThrowMeStmt() = default;
+
+  size_t NumMeStmtOpnds() const override {
+    return kOperandNumUnary;
+  }
+
+  MeExpr *GetOpnd(size_t) const override {
+    return opnd;
+  }
+
+  void SetOpnd(size_t, MeExpr *val) override {
+    opnd = val;
+  }
+
+  MeExpr *GetOpnd() const {
+    return opnd;
+  }
+
+  void SetMeStmtOpndValue(MeExpr *val) {
+    opnd = val;
+  }
+
+  void Dump(const IRMap*) const override;
+  StmtNode &EmitStmt(MapleAllocator &alloc) override;
+
+ private:
+  MeExpr *opnd = nullptr;
+};
+
+class SyncMeStmt : public NaryMeStmt, public MuChiMePart {
+ public:
+  SyncMeStmt(MapleAllocator *alloc, const StmtNode *stt) : NaryMeStmt(alloc, stt), MuChiMePart(alloc) {}
+
+  ~SyncMeStmt() = default;
+
+  void Dump(const IRMap*) const override;
+  MapleMap<OStIdx, ScalarMeExpr *> *GetMuList() override {
+    return &muList;
+  }
+
+  const MapleMap<OStIdx, ChiMeNode*> *GetChiList() const override {
+    return &chiList;
+  }
+
+  MapleMap<OStIdx, ChiMeNode *> *GetChiList() override {
+    return &chiList;
+  }
+};
+
+MapleMap<OStIdx, ChiMeNode*> *GenericGetChiListFromVarMeExpr(ScalarMeExpr &expr);
+void DumpMuList(const IRMap *irMap, const MapleMap<OStIdx, ScalarMeExpr*> &muList);
+void DumpChiList(const IRMap *irMap, const MapleMap<OStIdx, ChiMeNode*> &chiList);
+class DumpOptions {
+ public:
+  static bool GetSimpleDump() {
+    return simpleDump;
+  }
+
+  static int GetDumpVsyNum() {
+    return dumpVsymNum;
+  }
+
+ private:
+  static bool simpleDump;
+  static int dumpVsymNum;
+};
+}  // namespace maple
+#define LOAD_SAFE_CAST_FOR_ME_EXPR
+#define LOAD_SAFE_CAST_FOR_ME_STMT
+#include "me_safe_cast_traits.def"
+#endif  // MAPLE_ME_INCLUDE_ME_IR_H
diff --git a/src/mapleall/maple_me/include/me_irmap.h b/src/mapleall/maple_me/include/me_irmap.h
new file mode 100644
index 0000000000000000000000000000000000000000..ffd3da8c9cd30b9a5cac66aea502206d4e835a18
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_irmap.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_IRMAP_H
+#define MAPLE_ME_INCLUDE_ME_IRMAP_H
+#include "me_option.h"
+#include "ssa_tab.h"
+#include "me_function.h"
+#include "irmap.h"
+#include "me_cfg.h"
+
+namespace maple {
+class MeIRMap : public IRMap {
+ public:
+  static const uint32 kHmapHashLength = 5107;
+  MeIRMap(MeFunction &f, MemPool &memPool)
+      : IRMap(*f.GetMeSSATab(), memPool, kHmapHashLength), func(f), cfg(f.GetCfg()) {
+    SetDumpStmtNum(MeOption::stmtNum);
+  }
+
+  ~MeIRMap() = default;
+
+  BB *GetBB(BBId id) override {
+    return cfg->GetBBFromID(id);
+  }
+
+  BB *GetBBForLabIdx(LabelIdx lidx, PUIdx) override {
+    return cfg->GetLabelBBAt(lidx);
+  }
+
+  void Dump() override;
+
+  MeFunction &GetFunc() const {
+    return func;
+  }
+
+ private:
+  MeFunction &func;
+  MeCFG *cfg;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_IRMAP_H
diff --git a/src/mapleall/maple_me/include/me_irmap_build.h b/src/mapleall/maple_me/include/me_irmap_build.h
new file mode 100644
index 0000000000000000000000000000000000000000..b5586a1cc5abc2b5bc392803d96c248fa344d17a
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_irmap_build.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_ME_IRMAP_BUILD_H
+#define MAPLE_ME_INCLUDE_ME_IRMAP_BUILD_H
+#include "me_function.h"
+#include "me_irmap.h"
+#include "irmap_build.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MEIRMapBuild, MeFunction)
+  MeIRMap *GetResult() {
+    return irMap;
+  }
+  MeIRMap *irMap = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_FUNC_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_IRMAP_BUILD_H
diff --git a/src/mapleall/maple_me/include/me_ivopts.h b/src/mapleall/maple_me/include/me_ivopts.h
new file mode 100644
index 0000000000000000000000000000000000000000..25da0d8eb57f38a55fce52bce94c1e1c7aa1d70b
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ivopts.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_IVOPTS
+#define MAPLE_ME_INCLUDE_ME_IVOPTS
+#include "me_function.h"
+#include "maple_phase_manager.h"
+#include "me_dominance.h"
+#include "me_loop_analysis.h"
+
+namespace maple {
+MAPLE_FUNC_PHASE_DECLARE(MEIVOpts, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_IVOPTS
diff --git a/src/mapleall/maple_me/include/me_jump_threading.h b/src/mapleall/maple_me/include/me_jump_threading.h
new file mode 100644
index 0000000000000000000000000000000000000000..ebd95a4b2f7902d7994784fcbc2b61581a76c110
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_jump_threading.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_JUMP_THREADING_H
+#define MAPLE_ME_INCLUDE_ME_JUMP_THREADING_H
+
+#include "me_ir.h"
+#include "me_function.h"
+#include "me_cfg.h"
+#include "me_dominance.h"
+#include "stmt_cost_analyzer.h"
+#include "me_loop_analysis.h"
+#include "me_value_range_prop.h"
+
+namespace maple {
+using CompareOpnds = std::pair<MeExpr*, MeExpr*>;
+class JumpThreading {
+ public:
+  static bool isDebug;
+
+  JumpThreading(MeFunction &meFunc, Dominance &argDom, IdentifyLoops *argLoops,
+                ValueRangePropagation &valueRangePropagation, StmtCostAnalyzer &costAnalyzer,
+                std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &candsTem)
+      : func(meFunc), dom(argDom), loops(argLoops), valueRanges(valueRangePropagation),
+        stmtCostAnalyzer(costAnalyzer), cands(candsTem) {
+    path = std::make_unique<std::vector<BB*>>();
+  }
+  ~JumpThreading() = default;
+
+  void Execute();
+
+  bool IsCFGChange() const {
+    return isCFGChange;
+  }
+
+ private:
+  void ExecuteJumpThreading();
+  void DealWithCondGoto(BB &bb);
+  void DealWithSwitch(BB &bb);
+  void FindPath(BB &bb, CompareOpnds &cmpOpnds);
+  void FindPathWithTwoOperandsAreScalarMeExpr(BB &bb, BB &pred, CompareOpnds &cmpOpnds, size_t i);
+  void RegisterPath(BB &srcBB, BB &dstBB);
+  void ResizePath(size_t lengthOfSubPath);
+  bool PreCopyAndConnectPath(std::vector<BB*> &currPath);
+  bool PushSubPath2Path(BB &defBB, BB &useBB, size_t &lengthOfSubPath);
+  bool FindSubPathFromUseToDefOfExpr(BB &defBB, BB &useBB, std::vector<BB*> &subPath, std::set<BB*> &visited);
+  bool CanJumpThreading(BB &bb, MeExpr &opnd0, MeExpr *opnd1 = nullptr);
+  bool CanJumpThreadingWithSwitch(BB &bb, ValueRange *vrOfOpnd0);
+  bool CanJumpThreadingWithCondGoto(BB &bb, MeExpr *opnd1, ValueRange *vrOfOpnd0);
+  void FindPathWhenDefPointInCurrBB(BB &defBB, BB &predBB, MeExpr &opnd0, MeExpr *opnd1 = nullptr);
+  void FindPathWhenDefPointIsNotInCurrBB(BB &defBB, BB &useBB, MeExpr &opnd0, MeExpr *opnd1 = nullptr);
+  void FindPathWhenDefByIsNotStmtAndPhi(BB &defBB, BB &predBB, CompareOpnds &cmpOpnds);
+  void FindPathFromUse2DefWhenOneOpndIsDefByPhi(BB &bb, BB &pred, CompareOpnds &cmpOpnds,
+                                                size_t i, bool theFirstCmpOpndIsDefByPhi);
+  void FindPathWhenDefByStmt(BB &useBB, CompareOpnds &cmpOpnds, bool theFirstCmpOpndIsDefByPhi);
+  bool CanJump2SuccOfCurrBB(BB &bb, ValueRange *vrOfOpnd0, ValueRange *vrOfOpnd1, BB &toBeJumpedBB, Opcode op);
+  void PreFindPath(BB &bb, MeExpr &opnd0, MeExpr *opnd1 = nullptr);
+  BB *CopyBB(BB &bb, bool copyWithoutLastStmt = false);
+  void CopyAndConnectPath(std::vector<BB *> &currPath);
+  void ConnectNewPath(std::vector<BB*> &currPath, std::vector<std::pair<BB*, BB*>> &old2NewBB,
+      size_t thePosOfSec2LastBB);
+  void SetNewOffsetOfLastMeStmtForNewBB(const BB &oldBB, BB &newBB, const BB &oldSucc, BB &newSucc);
+  void InsertOstOfPhi2Cands(BB &bb, size_t i);
+  void PrepareForSSAUpdateWhenPredBBIsRemoved(const BB &pred, BB &bb);
+  bool TraverseBBsOfPath(std::vector<BB*> &currPath, int64 &currSize, bool &optSwitchBB,
+                         bool &multiBranchInPath, bool &pathThroughLatch);
+
+  MeFunction &func;
+  Dominance &dom;
+  IdentifyLoops *loops;
+  ValueRangePropagation &valueRanges;
+  StmtCostAnalyzer &stmtCostAnalyzer;
+  std::vector<std::unique_ptr<std::vector<BB*>>> paths;
+  std::unique_ptr<std::vector<BB*>> path;
+  std::set<BB*> visitedBBs;
+  BB *currBB = nullptr;
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &cands;
+  bool isCFGChange = false;
+  LoopDesc *currLoop = nullptr;
+  static int64 codeSizeOfCopy;
+  static size_t pathSize;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEJumpThreading, MeFunction)
+}  // namespace maple
+#endif
diff --git a/src/mapleall/maple_me/include/me_loop_analysis.h b/src/mapleall/maple_me/include/me_loop_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d0663cfb80d162f0895f712627b15b3a99a2ec5
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_loop_analysis.h
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEIDENTLOOPS_H
+#define MAPLE_ME_INCLUDE_MEIDENTLOOPS_H
+#include <algorithm>
+#include "me_function.h"
+#include "bb.h"
+#include "dominance.h"
+#include "me_cfg.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+class IdentifyLoops;
+// describes a specific loop, including the loop head, tail and sets of bb.
+struct LoopDesc {
+  MapleAllocator *alloc;
+  BB *head;
+  BB *tail;
+  BB *preheader;
+  BB *latch;
+  BB *exitBB;
+  MapleMap<BBId, MapleVector<BB*>*> inloopBB2exitBBs;
+  MapleSet<BBId> loopBBs;
+  LoopDesc *parent;  // points to its closest nesting loop
+  uint32 nestDepth;  // the nesting depth
+  bool hasTryBB = false;
+  bool hasIgotoBB = false; // backedge is construted by igoto
+  bool isCanonicalLoop = false;
+  LoopDesc(MapleAllocator &mapleAllocator, BB *headBB, BB *tailBB)
+      : alloc(&mapleAllocator), head(headBB), tail(tailBB), preheader(nullptr), latch(nullptr), exitBB(nullptr),
+        inloopBB2exitBBs(alloc->Adapter()), loopBBs(alloc->Adapter()), parent(nullptr), nestDepth(0), hasTryBB(false),
+        hasIgotoBB(false) {}
+
+  bool Has(const BB &bb) const {
+    return loopBBs.find(bb.GetBBId()) != loopBBs.end();
+  }
+
+  bool IsNormalizationLoop() const {
+    if (!hasTryBB && !hasIgotoBB && preheader != nullptr && !inloopBB2exitBBs.empty()) {
+      return true;
+    }
+    return false;
+  }
+
+  void InsertInloopBB2exitBBs(const BB &bb, BB &value) {
+    BBId key = bb.GetBBId();
+    if (inloopBB2exitBBs.find(key) == inloopBB2exitBBs.end()) {
+      inloopBB2exitBBs[key] = alloc->GetMemPool()->New<MapleVector<BB*>>(alloc->Adapter());
+      inloopBB2exitBBs[key]->push_back(&value);
+    } else {
+      auto it = find(inloopBB2exitBBs[key]->begin(), inloopBB2exitBBs[key]->end(), &value);
+      if (it == inloopBB2exitBBs[key]->end()) {
+        inloopBB2exitBBs[key]->push_back(&value);
+      }
+    }
+  }
+
+  void ReplaceInloopBB2exitBBs(const BB &bb, BB &oldValue, BB &value) {
+    BBId key = bb.GetBBId();
+    CHECK_FATAL(inloopBB2exitBBs.find(key) != inloopBB2exitBBs.end(), "key must exits");
+    auto mapIt = inloopBB2exitBBs[key];
+    auto it = find(mapIt->begin(), mapIt->end(), &oldValue);
+    CHECK_FATAL(it != inloopBB2exitBBs[key]->end(), "old Vvalue must exits");
+    *it = &value;
+    CHECK_FATAL(find(inloopBB2exitBBs[key]->begin(), inloopBB2exitBBs[key]->end(), &value) !=
+                inloopBB2exitBBs[key]->end(), "replace fail");
+    CHECK_FATAL(find(inloopBB2exitBBs[key]->begin(), inloopBB2exitBBs[key]->end(), &oldValue) ==
+                inloopBB2exitBBs[key]->end(), "replace fail");
+  }
+
+  void SetHasTryBB(bool has) {
+    hasTryBB = has;
+  }
+
+  bool HasTryBB() const {
+    return hasTryBB;
+  }
+
+  void SetHasIGotoBB(bool has) {
+    hasIgotoBB = has;
+  }
+
+  bool HasIGotoBB() const {
+    return hasIgotoBB;
+  }
+
+  void SetIsCanonicalLoop(bool is) {
+    isCanonicalLoop = is;
+  }
+
+  bool IsCanonicalLoop() const {
+    return isCanonicalLoop;
+  }
+
+  bool IsCanonicalAndOnlyHasOneExitBBLoop() const {
+    return IsCanonicalLoop() && inloopBB2exitBBs.size() == 1 && inloopBB2exitBBs.begin()->second != nullptr &&
+        inloopBB2exitBBs.begin()->second->size() == 1;
+  }
+};
+
+// IdentifyLoop records all the loops in a MeFunction.
+class IdentifyLoops : public AnalysisResult {
+ public:
+  IdentifyLoops(MemPool *memPool, MeFunction &mf, Dominance *dm)
+      : AnalysisResult(memPool),
+        meLoopMemPool(memPool),
+        meLoopAlloc(memPool),
+        func(mf),
+        cfg(mf.GetCfg()),
+        dominance(dm),
+        meLoops(meLoopAlloc.Adapter()),
+        bbLoopParent(func.GetCfg()->GetAllBBs().size(), nullptr, meLoopAlloc.Adapter()) {}
+
+  virtual ~IdentifyLoops() = default;
+
+  const MapleVector<LoopDesc*> &GetMeLoops() const {
+    return meLoops;
+  }
+
+  MapleVector<LoopDesc*> &GetMeLoops() {
+    return meLoops;
+  }
+
+  LoopDesc *GetBBLoopParent(BBId bbID) const {
+    if (bbID >= bbLoopParent.size()) {
+      return nullptr;
+    }
+    return bbLoopParent.at(bbID);
+  }
+
+  LoopDesc *CreateLoopDesc(BB &hd, BB &tail);
+  void SetLoopParent4BB(const BB &bb, LoopDesc &loopDesc);
+  void SetExitBB(LoopDesc &loop);
+  void ProcessBB(BB *bb);
+  void Dump() const;
+  void ProcessPreheaderAndLatch(LoopDesc &loop);
+
+ private:
+  MemPool *meLoopMemPool;
+  MapleAllocator meLoopAlloc;
+  MeFunction &func;
+  MeCFG *cfg;
+  Dominance *dominance;
+  MapleVector<LoopDesc*> meLoops;
+  MapleVector<LoopDesc*> bbLoopParent;  // gives closest nesting loop for each bb
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MELoopAnalysis, MeFunction)
+  IdentifyLoops *GetResult() {
+    return identLoops;
+  }
+  IdentifyLoops *identLoops = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_MODULE_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MEIDENTLOOPS_H
diff --git a/src/mapleall/maple_me/include/me_loop_canon.h b/src/mapleall/maple_me/include/me_loop_canon.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd76626574418ac867b2d89ddbd7d4e173f48a0f
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_loop_canon.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MELOOPCANON_H
+#define MAPLE_ME_INCLUDE_MELOOPCANON_H
+#include "me_function.h"
+#include "me_loop_analysis.h"
+
+namespace maple {
+// convert loop to do-while format
+class MeLoopCanon {
+ public:
+  MeLoopCanon(MeFunction &f, bool enableDebugFunc, bool updateFreq)
+      : func(f), isDebugFunc(enableDebugFunc), updateFreqs(updateFreq) {}
+  virtual ~MeLoopCanon() = default;
+  void NormalizationExitOfLoop(IdentifyLoops &meLoop);
+  void NormalizationHeadAndPreHeaderOfLoop(Dominance &dom);
+
+  bool IsCFGChange() const {
+    return isCFGChange;
+  }
+
+  void ResetIsCFGChange() {
+    isCFGChange = false;
+  }
+
+ private:
+  void FindHeadBBs(Dominance &dom, const BB *bb, std::map<BBId, std::vector<BB*>> &heads) const;
+  void SplitPreds(const std::vector<BB*> &splitList, BB *splittedBB, BB *mergedBB);
+  void Merge(const std::map<BBId, std::vector<BB*>> &heads);
+  void AddPreheader(const std::map<BBId, std::vector<BB*>> &heads);
+  void InsertExitBB(LoopDesc &loop);
+  void UpdateTheOffsetOfStmtWhenTargetBBIsChange(BB &curBB, const BB &oldSuccBB, BB &newSuccBB) const;
+
+  MeFunction &func;
+  bool isDebugFunc;
+  bool isCFGChange = false;
+  bool updateFreqs = false;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MELoopCanon, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MELOOPCANON_H
diff --git a/src/mapleall/maple_me/include/me_loop_inversion.h b/src/mapleall/maple_me/include/me_loop_inversion.h
new file mode 100644
index 0000000000000000000000000000000000000000..984b819e5d1b762399b665b100e5baff508230c5
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_loop_inversion.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MELOOPINVERSION_H
+#define MAPLE_ME_INCLUDE_MELOOPINVERSION_H
+#include "me_function.h"
+#include "me_loop_analysis.h"
+
+namespace maple {
+// convert loop to do-while format
+class MeLoopInversion {
+ public:
+  MeLoopInversion(bool enableDebugFunc, MemPool &givenMp) : isDebugFunc(enableDebugFunc), innerMp(&givenMp) {}
+  ~MeLoopInversion() = default;
+  void ExecuteLoopInversion(MeFunction &func, const Dominance &dom);
+
+  bool IsCFGChange() const {
+    return isCFGChange;
+  }
+
+ private:
+  using Key = std::pair<BB*, BB*>;
+  void Convert(MeFunction &func, BB &bb, BB &pred, MapleMap<Key, bool> &swapSuccs);
+  bool NeedConvert(MeFunction *func, BB &bb, BB &pred,
+                   MapleAllocator &localAlloc, MapleMap<Key, bool> &swapSuccs) const;
+
+  bool isDebugFunc;
+  MemPool *innerMp;
+  bool isCFGChange = false;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MELoopInversion, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MELOOPINVERSION_H
diff --git a/src/mapleall/maple_me/include/me_loop_unrolling.h b/src/mapleall/maple_me/include/me_loop_unrolling.h
new file mode 100644
index 0000000000000000000000000000000000000000..d28667d9a8c74bb6788fed97b7dc449f1422da2c
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_loop_unrolling.h
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_LOOP_UNROLLING_H
+#define MAPLE_ME_INCLUDE_LOOP_UNROLLING_H
+#include "me_cfg.h"
+#include "me_dominance.h"
+#include "me_function.h"
+#include "me_ir.h"
+#include "me_irmap_build.h"
+#include "me_loop_analysis.h"
+#include "me_scalar_analysis.h"
+#include "me_ssa_update.h"
+#include "profile.h"
+
+namespace maple {
+constexpr uint32 kMaxCost = 100;
+constexpr uint8 unrollTimes[3] = {8, 4, 2};  // unrollTimes
+class LoopUnrolling {
+ public:
+  enum ReturnKindOfFullyUnroll {
+    kCanFullyUnroll,
+    kCanNotSplitCondGoto,
+    kCanNotFullyUnroll,
+  };
+
+  LoopUnrolling(MeFunction &f, LoopDesc &l, MeIRMap &map, const MapleAllocator &alloc,
+                std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &candsTemp)
+      : func(&f),
+        cfg(f.GetCfg()),
+        loop(&l),
+        irMap(&map),
+        mpAllocator(alloc),
+        cands(candsTemp),
+        lastNew2OldBB(mpAllocator.Adapter()),
+        profValid(func->IsIRProfValid()) {}
+  ~LoopUnrolling() = default;
+  ReturnKindOfFullyUnroll LoopFullyUnroll(int64 tripCount);
+  bool LoopPartialUnrollWithConst(uint64 tripCount);
+  bool LoopPartialUnrollWithVar(CR &cr, CRNode &varNode, uint32 j);
+  bool LoopUnrollingWithConst(uint64 tripCount, bool onlyFully = false);
+  void SetInstrumentProf(bool useInstrument) {
+    instrumentProf = useInstrument;
+    profValid = useInstrument;
+  }
+  bool GetInstrumentProf() const {
+    return instrumentProf;
+  }
+
+ private:
+  bool SplitCondGotoBB();
+  VarMeExpr *CreateIndVarOrTripCountWithName(const std::string &name);
+  void RemoveCondGoto();
+
+  void SetLabelWithCondGotoOrGotoBB(BB &bb, std::unordered_map<BB*, BB*> &old2NewBB, const BB &exitBB,
+                                    LabelIdx oldlabIdx);
+  void ResetOldLabel2NewLabel(std::unordered_map<BB*, BB*> &old2NewBB, BB &bb, const BB &exitBB, BB &newHeadBB);
+  void ResetOldLabel2NewLabel2(std::unordered_map<BB*, BB*> &old2NewBB, BB &bb, const BB &exitBB, BB &newHeadBB);
+  void CopyLoopBody(BB &newHeadBB, std::unordered_map<BB*, BB*> &old2NewBB, std::set<BB*> &labelBBs,
+                    const BB &exitBB, bool copyAllLoop);
+  void CopyLoopBodyForProfile(BB &newHeadBB, std::unordered_map<BB*, BB*> &old2NewBB, std::set<BB*> &labelBBs,
+                              const BB &exitBB, bool copyAllLoop);
+  void UpdateCondGotoBB(BB &bb, VarMeExpr &indVar, MeExpr &tripCount, MeExpr &unrollTimeExpr);
+  void UpdateCondGotoStmt(BB &bb, VarMeExpr &indVar, MeExpr &tripCount, MeExpr &unrollTimeExpr, uint32 offset);
+  void CreateIndVarAndCondGotoStmt(CR &cr, CRNode &varNode, BB &preCondGoto, uint32 unrollTime, uint32 i);
+  void CopyLoopForPartial(BB &partialCondGoto, BB &exitedBB, BB &exitingBB);
+  void CopyLoopForPartial(CR &cr, CRNode &varNode, uint32 j, uint32 unrollTime);
+  void AddPreHeader(BB *oldPreHeader, BB *head);
+  MeExpr *CreateExprWithCRNode(CRNode &crNode);
+  void InsertCondGotoBB();
+  void ResetFrequency(BB &bb);
+  void ResetFrequency(BB &newCondGotoBB, BB &exitingBB, const BB &exitedBB, uint64 headFreq);
+  void ResetFrequency();
+  void ResetFrequency(const BB &curBB, const BB &succ, const BB &exitBB, BB &curCopyBB, bool copyAllLoop);
+  BB *CopyBB(BB &bb, bool isInLoop);
+  void CopyLoopForPartialAndPre(BB *&newHead, BB *&newExiting);
+  void CopyAndInsertBB(bool isPartial);
+  void ComputeCodeSize(const MeStmt &meStmt, uint32 &cost);
+  bool DetermineUnrollTimes(uint32 &index, bool isConst);
+  void CreateLableAndInsertLabelBB(BB &newHeadBB, std::set<BB*> &labelBBs);
+  void AddEdgeForExitBBLastNew2OldBBEmpty(BB &exitBB, std::unordered_map<BB*, BB*> &old2NewBB, BB &newHeadBB);
+  void AddEdgeForExitBB(BB &exitBB, std::unordered_map<BB*, BB*> &old2NewBB, BB &newHeadBB);
+  void ExchangeSucc(BB &partialExit);
+
+  bool canUnroll = true;
+  MeFunction *func;
+  MeCFG *cfg;
+  LoopDesc *loop;
+  MeIRMap *irMap;
+  MapleAllocator mpAllocator;
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &cands;
+  MapleMap<BB*, BB*> lastNew2OldBB;
+  BB *partialSuccHead = nullptr;
+  uint64 replicatedLoopNum = 0;
+  uint64 partialCount = 0;
+  bool needUpdateInitLoopFreq = true;
+  bool profValid;
+  bool resetFreqForAfterInsertGoto = false;
+  bool firstResetForAfterInsertGoto = true;
+  bool resetFreqForUnrollWithVar = false;
+  bool isUnrollWithVar = false;
+  bool instrumentProf = false;  // use instrumented profiling
+};
+
+class LoopUnrollingExecutor {
+ public:
+  explicit LoopUnrollingExecutor(MemPool &mp) : innerMp(&mp) {}
+  virtual ~LoopUnrollingExecutor() = default;
+  static bool enableDebug;
+  static bool enableDump;
+
+  void ExecuteLoopUnrolling(MeFunction &func, MeIRMap &irMap, std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &cands,
+                            IdentifyLoops &meLoop, const MapleAllocator &alloc);
+  bool IsCFGChange() const {
+    return isCFGChange;
+  }
+
+ private:
+  void SetNestedLoop(const IdentifyLoops &meLoop, std::unordered_map<LoopDesc*, std::set<LoopDesc*>> &parentLoop) const;
+  void VerifyCondGotoBB(BB &exitBB) const;
+  bool IsDoWhileLoop(const MeFunction &func, LoopDesc &loop) const;
+  bool PredIsOutOfLoopBB(const MeFunction &func, LoopDesc &loop) const;
+  bool IsCanonicalAndOnlyOneExitLoop(const MeFunction &func, LoopDesc &loop,
+                                     const std::unordered_map<LoopDesc*, std::set<LoopDesc*>> &parentLoop) const;
+  MemPool *innerMp;
+  bool isCFGChange = false;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MELoopUnrolling, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_LOOP_UNROLLING_H
diff --git a/src/mapleall/maple_me/include/me_lower_globals.h b/src/mapleall/maple_me/include/me_lower_globals.h
new file mode 100644
index 0000000000000000000000000000000000000000..402c4d9c6b141e76dfdeead4ae07e76261c96453
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_lower_globals.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MELOWERGLOBALS_H
+#define MAPLE_ME_INCLUDE_MELOWERGLOBALS_H
+#include "me_function.h"
+#include "me_irmap.h"
+
+namespace maple {
+class MeLowerGlobals {
+ public:
+  MeLowerGlobals(MeFunction &func, SSATab *ssaTab) : func(func), irMap(func.GetIRMap()), ssaTable(ssaTab) {}
+  ~MeLowerGlobals() = default;
+  void Run();
+
+ private:
+  MeFunction &func;
+  IRMap *irMap;
+  SSATab *ssaTable;
+  void LowerGlobalDreads(MeStmt &stmt, MeExpr &expr);
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MELOWERGLOBALS_H
diff --git a/src/mapleall/maple_me/include/me_may2dassign.h b/src/mapleall/maple_me/include/me_may2dassign.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b8fa4e256fdd33361ae07cf8618334c98a4b9fe
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_may2dassign.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEMAY2DASSIGN_H
+#define MAPLE_ME_INCLUDE_MEMAY2DASSIGN_H
+#include "me_function.h"
+#include "me_irmap_build.h"
+
+namespace maple {
+class May2Dassign {
+ public:
+  explicit May2Dassign(MeFunction &func) : func(func), irMap(func.GetIRMap()) {}
+
+  ~May2Dassign() = default;
+  void DoIt();
+
+ private:
+  MeFunction &func;
+  IRMap *irMap;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEMay2Dassign, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MEMAY2DASSIGN_H
diff --git a/src/mapleall/maple_me/include/me_merge_stmts.h b/src/mapleall/maple_me/include/me_merge_stmts.h
new file mode 100644
index 0000000000000000000000000000000000000000..50cee8dd02039c753a4d57fd7934355504d928f1
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_merge_stmts.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_MERGE_STMTS_H
+#define MAPLE_ME_INCLUDE_ME_MERGE_STMTS_H
+#include "me_function.h"
+
+// 1. Merge smaller stores into larger one
+// 2. Simdize intrinsic
+
+namespace maple {
+class MergeStmts {
+ public:
+  explicit MergeStmts(MeFunction &func) : func(func) {}
+  ~MergeStmts() = default;
+
+  using vOffsetStmt = std::vector<std::pair<int32, MeStmt*> >;
+  void MergeMeStmts();
+
+ private:
+  int32 GetStructFieldBitSize(const MIRStructType *structType, FieldID fieldID);
+  void mergeIassigns(vOffsetStmt& iassignCandidates);
+  void mergeDassigns(vOffsetStmt& dassignCandidates);
+  int32 GetPointedTypeBitSize(TyIdx ptrTypeIdx);
+  IassignMeStmt *genSimdIassign(int32 offset, IvarMeExpr iVar1, IvarMeExpr iVar2,
+                                const MapleMap<OStIdx, ChiMeNode *> &stmtChi, TyIdx ptrTypeIdx);
+  IassignMeStmt *genSimdIassign(int32 offset, IvarMeExpr iVar, MeExpr &valMeExpr,
+                                const MapleMap<OStIdx, ChiMeNode *> &stmtChi, TyIdx ptrTypeIdx);
+  void genShortSet(MeExpr *dstMeExpr, uint32 offset, const MIRType *uXTgtMirType, RegMeExpr *srcRegMeExpr,
+                   IntrinsiccallMeStmt* memsetCallStmt,
+                   const MapleMap<OStIdx, ChiMeNode *> &memsetCallStmtChi);
+  void simdMemcpy(IntrinsiccallMeStmt* memcpyCallStmt);
+  void simdMemset(IntrinsiccallMeStmt* memsetCallStmt);
+
+  MeFunction &func;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_MERGE_STMTS_H
+
diff --git a/src/mapleall/maple_me/include/me_obj_size.h b/src/mapleall/maple_me/include/me_obj_size.h
new file mode 100644
index 0000000000000000000000000000000000000000..e58128357824ab9f321cad4ec7db89c1dfe027af
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_obj_size.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_OBJ_SIZE_H
+#define MAPLE_ME_INCLUDE_ME_OBJ_SIZE_H
+
+#include "me_ir.h"
+#include "me_function.h"
+#include "meexpr_use_info.h"
+
+namespace maple {
+enum ObjSizeType : std::uint8_t {
+  kTypeZero,
+  kTypeOne,
+  kTypeTwo,
+  kTypeThree
+};
+
+class OBJSize {
+ public:
+  OBJSize(MeFunction &meFunc, MeIRMap &map) : func(meFunc), irMap(map) {}
+  ~OBJSize() = default;
+  void Execute();
+
+ private:
+  size_t InvalidSize(bool getMaxSizeOfObjs) const {
+    return getMaxSizeOfObjs ? 0 : -1;
+  }
+
+  size_t IsInvalidSize(size_t size) const {
+    return size == static_cast<uint64>(-1);
+  }
+
+  bool IsConstIntExpr(const MeExpr &expr) const {
+    return expr.GetOp() == OP_constval && static_cast<const ConstMeExpr&>(expr).GetConstVal()->GetKind() == kConstInt;
+  }
+
+  MeExpr *GetStrMeExpr(MeExpr &expr);
+  void ComputeObjectSize(MeStmt &meStmt);
+  void ERRWhenSizeTypeIsInvalid(const MeStmt &meStmt) const;
+  void DealWithBuiltinObjectSize(BB &bb, MeStmt &meStmt);
+  size_t ComputeObjectSizeWithType(MeExpr &opnd, int64 type) const;
+  void ReplaceStmt(CallMeStmt &callMeStmt, const std::string &str);
+  size_t DealWithSprintfAndVsprintf(const CallMeStmt &callMeStmt, const MIRFunction &calleeFunc);
+  size_t DealWithArray(const MeExpr &opnd, int64 type) const;
+  size_t DealWithAddrof(const MeExpr &opnd, bool getSizeOfWholeVar) const;
+  size_t DealWithDread(const MeExpr &opnd, int64 type, bool getMaxSizeOfObjs) const;
+  size_t DealWithIaddrof(const MeExpr &opnd, int64 type, bool getSizeOfWholeVar) const;
+
+  MeFunction &func;
+  MeIRMap &irMap;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEOBJSize, MeFunction)
+}  // namespace maple
+#endif
\ No newline at end of file
diff --git a/src/mapleall/maple_me/include/me_option.h b/src/mapleall/maple_me/include/me_option.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e43e1e05ee3d0633387a685ff83c26582dc813d
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_option.h
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_OPTION_H
+#define MAPLE_ME_INCLUDE_ME_OPTION_H
+#include <vector>
+#include <string>
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mpl_options.h"
+#include "types_def.h"
+
+namespace maple {
+class MeOption {
+ public:
+  static MeOption &GetInstance();
+
+  ~MeOption() = default;
+
+  bool SolveOptions(bool isDebug);
+
+  void ParseOptions(int argc, char **argv, std::string &fileName);
+
+  void SplitPhases(const std::string &str, std::unordered_set<std::string> &set) const;
+  void SplitSkipPhases(const std::string &str) const {
+    SplitPhases(str, skipPhases);
+  }
+  bool GetRange(const std::string &str) const;
+
+  const std::unordered_set<std::string> &GetSkipPhases() const {
+    return skipPhases;
+  }
+
+  static bool IsSkipFromPhase(const std::string &phaseName) {
+    return skipFrom.compare(phaseName) == 0;
+  }
+
+  static const std::string GetSkipFromPhase() {
+    return skipFrom;
+  }
+
+  static void SetSkipFrom(const std::string &phaseName) {
+    skipFrom = phaseName;
+  }
+
+  static bool IsSkipAfterPhase(const std::string &phaseName) {
+    return skipAfter.compare(phaseName) == 0;
+  }
+
+  static const std::string GetSkipAfterPhase() {
+    return skipAfter;
+  }
+
+  static void SetSkipAfter(const std::string &phaseName) {
+    skipAfter = phaseName;
+  }
+
+  static bool IsSkipPhase(const std::string &phaseName) {
+    return !(skipPhases.find(phaseName) == skipPhases.end());
+  }
+
+  static bool IsBigEndian() {
+    return isBigEndian;
+  }
+
+  static bool DumpPhase(const std::string &phase);
+  static bool DumpFunc(const std::string &func);
+  static std::unordered_set<std::string> dumpPhases;
+  static std::unordered_set<std::string> skipPhases;
+
+  static bool isBigEndian;
+  static bool dumpBefore;
+  static bool dumpAfter;
+  static constexpr int kRangeArrayLen = 2;
+  static unsigned long range[kRangeArrayLen];
+  static bool useRange;
+  static std::string dumpFunc;
+  static std::string skipFrom;
+  static std::string skipAfter;
+  static bool quiet;
+  static bool setCalleeHasSideEffect;
+  static bool unionBasedAA;
+  static bool tbaa;
+  static bool ddaa;
+  static uint8 aliasAnalysisLevel;
+  static bool noDot;
+  static bool stmtNum;
+  static bool rcLowering;
+  static bool noRC;
+  static bool strictNaiveRC;
+  static std::unordered_set<std::string> checkRefUsedInFuncs;
+  static bool gcOnly;
+  static bool gcOnlyOpt;
+  static bool noGCBar;
+  static bool noReflection;
+  static bool realCheckCast;
+  static bool regNativeFunc;
+  static bool warnNativeFunc;
+  static bool lazyDecouple;
+  static bool optForSize;
+  static uint8 optLevel;
+  static uint32 stmtprePULimit;
+  static uint32 epreLimit;
+  static uint32 eprePULimit;
+  static uint32 lpreLimit;
+  static uint32 lprePULimit;
+  static uint32 parserOpt;
+  static uint32 threads;
+  static bool ignoreInferredRetType;
+  static uint32 pregRenameLimit;
+  static uint32 rename2pregLimit;
+  static uint32 propLimit;
+  static uint32 copyPropLimit;
+  static uint32 delRcPULimit;
+  static uint32 profileBBHotRate;
+  static uint32 profileBBColdRate;
+  static bool ignoreIPA;
+  static bool enableHotColdSplit;
+  static bool aggressiveABCO;
+  static bool commonABCO;
+  static bool conservativeABCO;
+  static bool epreIncludeRef;
+  static bool epreLocalRefVar;
+  static bool epreLHSIvar;
+  static bool dseKeepRef;
+  static bool lessThrowAlias;
+  static bool noDelegateRC;
+  static bool noCondBasedRC;
+  static bool enableEA;
+  static bool checkCastOpt;
+  static bool parmToPtr;
+  static bool nullCheckPre;
+  static bool assign2FinalPre;
+  static bool clinitPre;
+  static bool dassignPre;
+  static bool mergeStmts;
+  static bool generalRegOnly;
+  static bool regreadAtReturn;
+  static bool propBase;
+  static bool propIloadRef;
+  static bool propGlobalRef;
+  static bool propFinaliLoadRef;
+  static bool propIloadRefNonParm;
+  static bool propAtPhi;
+  static bool propDuringBuild;
+  static bool propWithInverse;
+  static bool lpreSpeculate;
+  static bool lpre4Address;
+  static bool lpre4LargeInt;
+  static bool spillAtCatch;
+  static bool optDirectCall;
+  static bool decoupleStatic;
+  static bool nativeOpt;
+  static bool placementRC;
+  static bool subsumRC;
+  static bool performFSAA;
+  static bool strengthReduction;
+  static bool srForAdd;
+  static bool doLFTR;
+  static bool ivopts;
+  static std::string inlineFuncList;
+  static bool meVerify;
+  static uint32 dseRunsLimit;
+  static uint32 hdseRunsLimit;
+  static uint32 hpropRunsLimit;
+  static uint32 sinkLimit;
+  static uint32 sinkPULimit;
+  static uint32 vecLoopLimit;
+  static uint32 ivoptsLimit;
+  static bool loopVec;
+  static bool seqVec;
+  static bool enableLFO;
+  static uint8 rematLevel;
+  static bool layoutWithPredict;
+  static bool unifyRets;
+  static bool dumpCfgOfPhases;
+// safety check option begin
+  static SafetyCheckMode npeCheckMode;
+  static bool isNpeCheckAll;
+  static SafetyCheckMode boundaryCheckMode;
+  static bool safeRegionMode;
+// safety check option end
+#if MIR_JAVA
+  static std::string acquireFuncName;
+  static std::string releaseFuncName;
+  static unsigned int warningLevel;
+  static bool mplToolOnly;
+  static bool mplToolStrict;
+  static bool skipVirtualMethod;
+#endif
+ private:
+  void DecideMeRealLevel() const;
+};
+
+#ifndef DEBUGFUNC
+#define DEBUGFUNC(f)                                                       \
+  (MeOption::dumpPhases.find(PhaseName()) != MeOption::dumpPhases.end() && \
+   (MeOption::dumpFunc.compare("*") == 0 || (f)->GetName() == MeOption::dumpFunc))
+#endif
+
+#ifndef DEBUGFUNC_NEWPM
+#define DEBUGFUNC_NEWPM(f)                                                                                  \
+  (!MeOption::dumpPhases.empty() && MeOption::dumpPhases.find(PhaseName()) != MeOption::dumpPhases.end() && \
+   (MeOption::dumpFunc.compare("*") == 0 || (f).GetName() == MeOption::dumpFunc))
+#endif
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_OPTION_H
diff --git a/src/mapleall/maple_me/include/me_options.h b/src/mapleall/maple_me/include/me_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..da127b6d3d45a753f4c16c9f54c752d5bdfdd902
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_options.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_ME_OPTIONS_H
+#define MAPLE_ME_INCLUDE_ME_OPTIONS_H
+
+#include "cl_option.h"
+#include "cl_parser.h"
+#include "types_def.h"
+
+#include <cstdint>
+#include <string>
+
+namespace opts::me {
+
+extern maplecl::Option<bool> help;
+extern maplecl::Option<bool> o1;
+extern maplecl::Option<bool> o2;
+extern maplecl::Option<bool> os;
+extern maplecl::Option<bool> o3;
+extern maplecl::Option<std::string> refusedcheck;
+extern maplecl::Option<std::string> range;
+extern maplecl::Option<std::string> dumpPhases;
+extern maplecl::Option<std::string> skipPhases;
+extern maplecl::Option<std::string> dumpFunc;
+extern maplecl::Option<bool> quiet;
+extern maplecl::Option<bool> nodot;
+extern maplecl::Option<bool> userc;
+extern maplecl::Option<bool> strictNaiverc;
+extern maplecl::Option<std::string> skipFrom;
+extern maplecl::Option<std::string> skipAfter;
+extern maplecl::Option<bool> calleeHasSideEffect;
+extern maplecl::Option<bool> ubaa;
+extern maplecl::Option<bool> tbaa;
+extern maplecl::Option<bool> ddaa;
+extern maplecl::Option<uint8_t> aliasAnalysisLevel;
+extern maplecl::Option<bool> stmtnum;
+extern maplecl::Option<bool> rclower;
+extern maplecl::Option<bool> gconlyopt;
+extern maplecl::Option<bool> usegcbar;
+extern maplecl::Option<bool> regnativefunc;
+extern maplecl::Option<bool> warnemptynative;
+extern maplecl::Option<bool> dumpBefore;
+extern maplecl::Option<bool> dumpAfter;
+extern maplecl::Option<bool> realcheckcast;
+extern maplecl::Option<uint32_t> eprelimit;
+extern maplecl::Option<uint32_t> eprepulimit;
+extern maplecl::Option<uint32_t> stmtprepulimit;
+extern maplecl::Option<uint32_t> lprelimit;
+extern maplecl::Option<uint32_t> lprepulimit;
+extern maplecl::Option<uint32_t> pregrenamelimit;
+extern maplecl::Option<uint32_t> rename2preglimit;
+extern maplecl::Option<uint32_t> proplimit;
+extern maplecl::Option<uint32_t> copyproplimit;
+extern maplecl::Option<uint32_t> delrcpulimit;
+extern maplecl::Option<uint32_t> profileBbHotRate;
+extern maplecl::Option<uint32_t> profileBbColdRate;
+extern maplecl::Option<bool> ignoreipa;
+extern maplecl::Option<bool> enableHotColdSplit;
+extern maplecl::Option<bool> aggressiveABCO;
+extern maplecl::Option<bool> commonABCO;
+extern maplecl::Option<bool> conservativeABCO;
+extern maplecl::Option<bool> epreincluderef;
+extern maplecl::Option<bool> eprelocalrefvar;
+extern maplecl::Option<bool> eprelhsivar;
+extern maplecl::Option<bool> dsekeepref;
+extern maplecl::Option<bool> propbase;
+extern maplecl::Option<bool> propiloadref;
+extern maplecl::Option<bool> propglobalref;
+extern maplecl::Option<bool> propfinaliloadref;
+extern maplecl::Option<bool> propiloadrefnonparm;
+extern maplecl::Option<bool> lessthrowalias;
+extern maplecl::Option<bool> nodelegaterc;
+extern maplecl::Option<bool> nocondbasedrc;
+extern maplecl::Option<bool> subsumrc;
+extern maplecl::Option<bool> performFSAA;
+extern maplecl::Option<bool> strengthreduction;
+extern maplecl::Option<bool> sradd;
+extern maplecl::Option<bool> lftr;
+extern maplecl::Option<bool> ivopts;
+extern maplecl::Option<bool> checkcastopt;
+extern maplecl::Option<bool> parmtoptr;
+extern maplecl::Option<bool> nullcheckpre;
+extern maplecl::Option<bool> clinitpre;
+extern maplecl::Option<bool> dassignpre;
+extern maplecl::Option<bool> assign2finalpre;
+extern maplecl::Option<bool> regreadatreturn;
+extern maplecl::Option<bool> propatphi;
+extern maplecl::Option<bool> propduringbuild;
+extern maplecl::Option<bool> propwithinverse;
+extern maplecl::Option<bool> nativeopt;
+extern maplecl::Option<bool> optdirectcall;
+extern maplecl::Option<bool> enableEa;
+extern maplecl::Option<bool> lprespeculate;
+extern maplecl::Option<bool> lpre4address;
+extern maplecl::Option<bool> lpre4largeint;
+extern maplecl::Option<bool> spillatcatch;
+extern maplecl::Option<bool> placementrc;
+extern maplecl::Option<bool> lazydecouple;
+extern maplecl::Option<bool> mergestmts;
+extern maplecl::Option<bool> generalRegOnly;
+extern maplecl::Option<std::string> inlinefunclist;
+extern maplecl::Option<uint32_t> threads;
+extern maplecl::Option<bool> ignoreInferredRetType;
+extern maplecl::Option<bool> meverify;
+extern maplecl::Option<uint32_t> dserunslimit;
+extern maplecl::Option<uint32_t> hdserunslimit;
+extern maplecl::Option<uint32_t> hproprunslimit;
+extern maplecl::Option<uint32_t> sinklimit;
+extern maplecl::Option<uint32_t> sinkPUlimit;
+extern maplecl::Option<bool> loopvec;
+extern maplecl::Option<bool> seqvec;
+extern maplecl::Option<bool> layoutwithpredict;
+extern maplecl::Option<uint32_t> veclooplimit;
+extern maplecl::Option<uint32_t> ivoptslimit;
+extern maplecl::Option<std::string> acquireFunc;
+extern maplecl::Option<std::string> releaseFunc;
+extern maplecl::Option<bool> toolonly;
+extern maplecl::Option<bool> toolstrict;
+extern maplecl::Option<bool> skipvirtual;
+extern maplecl::Option<uint32_t> warning;
+extern maplecl::Option<uint8_t> remat;
+extern maplecl::Option<bool> unifyrets;
+extern maplecl::Option<bool> lfo;
+extern maplecl::Option<bool> dumpCfgOfPhases;
+
+}
+
+#endif /* MAPLE_ME_INCLUDE_ME_OPTIONS_H */
diff --git a/src/mapleall/maple_me/include/me_pgo_instrument.h b/src/mapleall/maple_me/include/me_pgo_instrument.h
new file mode 100644
index 0000000000000000000000000000000000000000..b1bc3d97864f5534b47e0d65ff494eaffd91a894
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_pgo_instrument.h
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_PGOINSTRUMENT_H
+#define MAPLE_ME_INCLUDE_PGOINSTRUMENT_H
+
+#include "bb.h"
+#include "me_cfg_mst.h"
+#include "me_cfg.h"
+#include "itab_util.h"
+
+namespace maple {
+class BBEdge {
+ public:
+  BBEdge(BB *src, BB *dest, uint64 w = 1, bool isCritical = false, bool isFake = false)
+      : srcBB(src), destBB(dest), weight(w), inMST(false), isCritical(isCritical), isFake(isFake) {}
+
+  ~BBEdge() = default;
+
+  BB *GetSrcBB() const {
+    return srcBB;
+  }
+
+  BB *GetDestBB() const {
+    return destBB;
+  }
+
+  uint64 GetWeight() const {
+    return weight;
+  }
+
+  void SetWeight(uint64 w) {
+    weight = w;
+  }
+
+  bool IsCritical() const {
+    return isCritical;
+  }
+
+  bool IsFake() const {
+    return isFake;
+  }
+
+  bool IsInMST() const {
+    return inMST;
+  }
+
+  void SetInMST() {
+    inMST = true;
+  }
+
+ private:
+  BB *srcBB;
+  BB *destBB;
+  uint64 weight;
+  bool inMST;
+  bool isCritical;
+  bool isFake;
+};
+
+template <class Edge>
+class PGOInstrument {
+ public:
+  PGOInstrument(MeFunction &func, MemPool &mp, bool dump) : dump(dump), mst(func, mp, dump), func(&func), mp(&mp) {}
+
+  void FindInstrumentEdges() {
+    mst.ComputeMST();
+  }
+
+  ~PGOInstrument() {
+    ClearBBGroupInfo();
+  }
+
+  const std::vector<Edge*> &GetAllEdges() {
+    return mst.GetAllEdges();
+  }
+
+  uint32 GetAllBBs() {
+    return mst.GetAllBBs();
+  }
+
+  void GetInstrumentBBs(std::vector<BB*> &bbs) const {
+    std::vector<Edge*> instrumentEdges;
+    mst.GetInstrumentEdges(instrumentEdges);
+    std::unordered_set<BB*> visitedBBs;
+
+    for (auto &edge : instrumentEdges) {
+      BB *src = edge->GetSrcBB();
+      BB *dest = edge->GetDestBB();
+      /* instrument the srcbb if it has a single succ */
+      if (src->GetSucc().size() <= 1) {
+        if (src == func->GetCfg()->GetCommonEntryBB()) {
+          bbs.push_back(dest);
+        } else {
+          bbs.push_back(src);
+        }
+      } else if (!edge->IsCritical()) {
+        bbs.push_back(dest);
+      } else {
+        if (func->GetMIRModule().IsCModule()) {
+          if (src->GetKind() == kBBIgoto || src->GetKind() == kBBGoto) {
+            if (visitedBBs.find(dest) == visitedBBs.end()) {
+              // In this case, we have to instrument it anyway
+              bbs.push_back(dest);
+              (void)visitedBBs.insert(dest);
+            }
+          } else {
+            func->GetCfg()->DumpToFile("profGenErrorForCModule", false);
+            CHECK_FATAL(false, "Unexpected case %d -> %d", src->UintID(), dest->UintID());
+          }
+        } else {
+          func->GetCfg()->DumpToFile("profGenError", false);
+          CHECK_FATAL(false, "impossible critial edge %d -> %d", src->UintID(), dest->UintID());
+        }
+      }
+    }
+  }
+
+  void DumpEdgeInfo() const {
+    mst.DumpEdgesInfo();
+  }
+
+  uint64 ComputeFuncHash() {
+    uint64 allEdgeSize = mst.GetAllEdgesSize();
+    std::ostringstream ss;
+    auto eIt = func->GetCfg()->valid_end();
+    // compute func CFG hash,used to verify function IR change
+    for (auto bIt = func->GetCfg()->valid_begin(); bIt != eIt; ++bIt) {
+      auto *bb = *bIt;
+      if (bIt == func->GetCfg()->common_exit()) {
+        continue;
+      }
+      for (auto *succBB : bb->GetSucc()) {
+        ss << succBB->GetBBId() << " ";
+      }
+    }
+    uint32 hashCode = DJBHash(ss.str().c_str());
+    return (allEdgeSize << edgeSizeInfoShift) | hashCode;
+  }
+
+  uint64 ComputeLinenoHash() {
+    const std::string& fileName = func->GetMIRModule().GetFileName();
+    uint64 fileNameHash = DJBHash(fileName.c_str());
+    std::string lineNo = std::to_string(func->GetMirFunc()->GetSrcPosition().LineNum());
+    uint64 linenoHash = fileNameHash << 32 | DJBHash(lineNo.c_str());
+    return linenoHash;
+  }
+
+  void ClearBBGroupInfo() {
+    auto eIt = func->GetCfg()->valid_end();
+    for (auto bIt = func->GetCfg()->valid_begin(); bIt != eIt; ++bIt) {
+      auto *bb = *bIt;
+      bb->ClearGroup();
+    }
+  }
+
+ protected:
+  bool dump;
+ private:
+  static constexpr uint32 edgeSizeInfoShift = 32;
+  CFGMST<Edge> mst;
+  MeFunction *func;
+  MemPool *mp;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_PGOINSTRUMENT_H
diff --git a/src/mapleall/maple_me/include/me_phase_manager.h b/src/mapleall/maple_me/include/me_phase_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..cdcaa56e10e73336751ed5236acf75971d1080f1
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_phase_manager.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_PHASE_MANAGER_H
+#define MAPLE_ME_INCLUDE_ME_PHASE_MANAGER_H
+#include <vector>
+#include <string>
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_module.h"
+#include "mir_function.h"
+#include "maple_phase_manager.h"
+#include "me_dominance.h"
+#include "me_cfg.h"
+#include "me_alias_class.h"
+#include "me_bypath_eh.h"
+#include "me_critical_edge.h"
+#include "me_profile_gen.h"
+#include "me_profile_use.h"
+#include "me_loop_canon.h"
+#include "me_loop_inversion.h"
+#include "me_analyzector.h"
+#include "me_value_range_prop.h"
+#include "me_jump_threading.h"
+#include "me_obj_size.h"
+#include "me_abco.h"
+#include "me_dse.h"
+#include "me_hdse.h"
+#include "me_prop.h"
+#include "copy_prop.h"
+#include "me_ssa_prop.h"
+#include "me_rename2preg.h"
+#include "me_loop_unrolling.h"
+#include "me_cfg_opt.h"
+#include "meconstprop.h"
+#include "me_bb_analyze.h"
+#include "me_ssa_lpre.h"
+#include "me_ssa_epre.h"
+#include "me_stmt_pre.h"
+#include "me_store_pre.h"
+#include "me_cond_based_rc.h"
+#include "me_cond_based_npc.h"
+#include "me_check_cast.h"
+#include "me_placement_rc.h"
+#include "me_subsum_rc.h"
+#include "me_predict.h"
+#include "me_side_effect.h"
+#include "do_ipa_escape_analysis.h"
+#include "me_gc_lowering.h"
+#include "me_gc_write_barrier_opt.h"
+#include "preg_renamer.h"
+#include "me_ssa_devirtual.h"
+#include "me_delegate_rc.h"
+#include "me_analyze_rc.h"
+#include "me_may2dassign.h"
+#include "me_loop_analysis.h"
+#include "me_ssa.h"
+#include "me_toplevel_ssa.h"
+#include "me_irmap_build.h"
+#include "me_bb_layout.h"
+#include "me_emit.h"
+#include "me_rc_lowering.h"
+#include "gen_check_cast.h"
+#include "me_fsaa.h"
+#include "optimizeCFG.h"
+#include "me_ivopts.h"
+#include "code_factoring.h"
+#include "me_slp.h"
+#if MIR_JAVA
+#include "sync_select.h"
+#endif  // MIR_JAVA
+#include "me_ssa_tab.h"
+#include "mpl_timer.h"
+#include "constantfold.h"
+#include "me_verify.h"
+#include "lfo_inject_iv.h"
+#include "pme_emit.h"
+#include "lfo_iv_canon.h"
+#include "cfg_opt.h"
+#include "lfo_dep_test.h"
+#include "me_autovec.h"
+#include "lfo_unroll.h"
+#include "me_safety_warning.h"
+#include "me_sink.h"
+
+namespace maple {
+using MeFuncOptTy = MapleFunctionPhase<MeFunction>;
+
+/* ==== new phase manager ==== */
+class MeFuncPM : public FunctionPM {
+ public:
+  explicit MeFuncPM(MemPool *memPool) : FunctionPM(memPool, &id) {}
+  PHASECONSTRUCTOR(MeFuncPM);
+  std::string PhaseName() const override;
+  ~MeFuncPM() override {}
+  static bool genMeMpl;
+  static bool timePhases;
+  static bool genMapleBC;
+  static bool genLMBC;
+
+  void SetMeInput(const std::string &str) {
+    meInput = str;
+  }
+
+  bool PhaseRun(MIRModule &m) override;
+ private:
+  bool SkipFuncForMe(const MIRFunction &func, uint64 range);
+  bool FuncLevelRun(MeFunction &meFunc, AnalysisDataManager &serialADM);
+  void GetAnalysisDependence(AnalysisDep &aDep) const override;
+  void DumpMEIR(const MeFunction &f, const std::string phaseName, bool isBefore);
+  virtual void DoPhasesPopulate(const MIRModule &mirModule);
+
+  std::string meInput = "";
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_PHASE_MANAGER_H
diff --git a/src/mapleall/maple_me/include/me_placement_rc.h b/src/mapleall/maple_me/include/me_placement_rc.h
new file mode 100644
index 0000000000000000000000000000000000000000..9c72c8fcfaf1041d976c3df345ef57f7e1a7a27d
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_placement_rc.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEPLACEMENTRC_H
+#define MAPLE_ME_INCLUDE_MEPLACEMENTRC_H
+#include "me_ssu_pre.h"
+
+namespace maple {
+class PlacementRC : public MeSSUPre {
+ public:
+  PlacementRC(MeFunction &f, Dominance &dom, Dominance &pdom, MemPool &memPool, bool enabledDebug)
+      : MeSSUPre(f, dom, pdom, memPool, kDecrefPre, enabledDebug), placementRCTemp(nullptr),
+        bbHasReal(f.GetCfg()->GetAllBBs().size(), false, spreAllocator.Adapter()) {}
+
+  virtual ~PlacementRC() = default;
+
+ private:
+  // Step 6 methods
+  UnaryMeStmt *GenIncrefAtEntry(OriginalSt &ost) const;
+  UnaryMeStmt *GenerateDecrefreset(OStIdx ostIdx, BB &bb) const;
+  void CollectDecref(VarMeExpr *var, MeStmt *decrefStmt);
+  void HandleThrowOperand(SRealOcc &realOcc, ThrowMeStmt &thwStmt);
+  void CheckAndInsert(BB &bb, SOcc *occ);
+  bool GoStraightToThrow(const BB &bb) const;
+  void FindRealPredBB(const BB &bb, std::vector<bool> &visitedBBs, std::set<BBId> &lambdaRealSet) const;
+  SOcc *FindLambdaReal(const SLambdaOcc &occ) const;
+  void CodeMotion() override;
+  // Step 0 methods
+  void CreateEmptyCleanupIntrinsics() override;
+  void GenEntryOcc4Formals();
+  void CreatePhiOcc(const OStIdx &ostIdx, BB &bb, MePhiNode &phi, VarMeExpr &var);
+  void CreateRealOcc(const OStIdx &ostIdx, MeStmt *meStmt, VarMeExpr &var, bool causedByDef = false);
+  void CreateUseOcc(const OStIdx &ostIdx, BB &bb, VarMeExpr &var);
+  void FindLocalrefvarUses(MeExpr &meExpr, MeStmt *meStmt);
+  void BuildWorkListBB(BB *bb) override;
+  void ResetHasReal();
+  void UpdateHasRealWithRealOccs(const MapleVector<SOcc*> &realOccs);
+  void SetFormalParamsAttr(MIRFunction &mirFunc) const;
+  void DeleteEntryIncref(SRealOcc &realOcc, UnaryMeStmt *entryIncref) const;
+  void UpdateCatchBlocks2Insert(const BB &lastUseBB);
+  void ReplaceOpndWithReg(MeExpr &opnd, BB &lastUseBB, const SRealOcc &realOcc, uint32 idx) const;
+  void HandleCanInsertAfterStmt(const SRealOcc &realOcc, UnaryMeStmt &decrefStmt, BB &lastUseBB);
+  void HandleCannotInsertAfterStmt(const SRealOcc &realOcc, UnaryMeStmt &decrefStmt, BB &lastUseBB);
+  void CodeMotionForSLambdares(SLambdaResOcc &lambdaResOcc);
+  void CodeMotionForReal(SOcc &occ, UnaryMeStmt *entryIncref);
+  void SetNeedIncref(MeStmt &stmt) const;
+  void ReplaceRHSWithPregForDassign(MeStmt &stmt, BB &bb) const;
+  bool DoesDassignInsertedForCallAssigned(MeStmt &stmt, BB &bb) const;
+  void LookForRealOccOfStores(MeStmt &stmt, BB &bb);
+  void LookForUseOccOfLocalRefVars(MeStmt &stmt);
+  void TraverseStatementsBackwards(BB &bb);
+  void AddCleanupArg();
+  MeStmt *GetDefStmt(BB &bb);
+
+  void PerCandInit() override {
+    catchBlocks2Insert.clear();
+  }
+
+  // Step 6 variables
+  VarMeExpr *placementRCTemp;  // localrefvar temp created to handle throw operand (always zero version)
+  MapleVector<bool> bbHasReal;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEPlacementRC, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MEPLACEMENTRC_H
diff --git a/src/mapleall/maple_me/include/me_predict.def b/src/mapleall/maple_me/include/me_predict.def
new file mode 100644
index 0000000000000000000000000000000000000000..eaaf9a71a97524e0a5b206680ae1a64ee9214bbd
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_predict.def
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+// (id, name, probability)
+
+// A value used as final outcome of all heuristics.
+DEF_PREDICTOR (kPredCombined, "combined", kProbAlways)
+
+// No heuristic applying.
+DEF_PREDICTOR (kPredNoPrediction, "no prediction", kProbAlways)
+
+// Branch causing function to terminate is probably not taken.
+DEF_PREDICTOR (kPredEarlyReturn, "early return", HITRATE (67))
+
+// Edge causing loop to terminate is probably not taken.
+DEF_PREDICTOR (kPredLoopExit, "loop exit", HITRATE (89))
+
+// Pointers are usually not nullptr.
+DEF_PREDICTOR (kPredPointer, "pointer", HITRATE (70))
+
+// NE is probable, EQ not etc...
+DEF_PREDICTOR (kPredOpcodePositive, "opcode values positive", HITRATE (59))
+DEF_PREDICTOR (kPredOpcodeNonEqual, "opcode values nonequal", HITRATE (66))
+DEF_PREDICTOR (kPredFPOpcode, "fp_opcode", HITRATE (90))
+
+// Branch containing call is probably taken.
+DEF_PREDICTOR (kPredCall, "call", HITRATE (67))
+
+// Branch ending with return constant is probably not taken.
+DEF_PREDICTOR (kPredConstReturn, "const return", HITRATE (69))
+
+// Branch ending with return negative constant is probably not taken.
+DEF_PREDICTOR (kPredNegativeReturn, "negative return", HITRATE (98))
+
+// Branch ending with return null is probably not taken
+DEF_PREDICTOR (kPredNullReturn, "null return", HITRATE (71))
+
+// Java try fallthru is almost taken
+DEF_PREDICTOR (kPredTry, "try start label", HITRATE (98))
+
+// For __builtin_expect
+DEF_PREDICTOR(kPredBuiltinExpect, "__builtin_expect", HITRATE (90))
+
+// Branch with wont exit attr is probably not taken
+DEF_PREDICTOR(kPredWontExit, "wont exit", HITRATE (98))
diff --git a/src/mapleall/maple_me/include/me_predict.h b/src/mapleall/maple_me/include/me_predict.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a5640273d43511d6f456be7632cc56b00e70f63
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_predict.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEPREDICT_H
+#define MAPLE_ME_INCLUDE_MEPREDICT_H
+#include "me_function.h"
+#include "bb.h"
+#include "dominance.h"
+#include "me_loop_analysis.h"
+
+namespace maple {
+// The base value for branch probability notes and edge probabilities.
+constexpr int kProbBase = 10000;
+// The base value for BB frequency.
+constexpr uint64 kFreqBase = 100000;
+
+// Information about each branch predictor.
+struct PredictorInfo {
+  const char *name;   // Name used in the debugging dumps.
+  const int hitRate; // Expected hitrate used by PredictDef call.
+};
+
+#define DEF_PREDICTOR(ENUM, NAME, HITRATE) ENUM,
+enum Predictor {
+#include "me_predict.def"
+  kEndPrediction
+};
+#undef DEF_PREDICTOR
+enum Prediction { kNotTaken, kTaken };
+
+// Indicate the edge from src to dest.
+struct Edge {
+  BB &src;
+  BB &dest;
+  Edge *next = nullptr;  // the edge with the same src
+  uint32 probability = 0;
+  uint32 frequency = 0;
+  Edge(BB &bb1, BB &bb2) : src(bb1), dest(bb2) {}
+  void Dump(bool dumpNext = false) const;
+};
+
+// Represents predictions on edge.
+struct EdgePrediction {
+  Edge &epEdge;
+  EdgePrediction *epNext = nullptr;
+  Predictor epPredictor = kPredNoPrediction;
+  int32 epProbability = -1;
+  explicit EdgePrediction(Edge &edge) : epEdge(edge) {}
+};
+
+using BuiltinExpectInfo = std::vector<std::pair<CondGotoMeStmt*, int32>>;
+
+// Emistimate frequency for MeFunction.
+class MePrediction : public AnalysisResult {
+ public:
+  static const PredictorInfo predictorInfo[kEndPrediction + 1];
+  static void VerifyFreq(const MeFunction &meFunc);
+  static void RebuildFreq(MeFunction &meFunc, Dominance &newDom, Dominance &newPdom, IdentifyLoops &newMeLoop,
+      BuiltinExpectInfo *expectInfo = nullptr);
+  static void RecoverBuiltinExpectInfo(const BuiltinExpectInfo &expectInfo);
+  MePrediction(MemPool &memPool, MemPool &tmpPool, MeFunction &mf, Dominance &dom, Dominance &pdom,
+               IdentifyLoops &loops, MeIRMap &map)
+      : AnalysisResult(&memPool),
+        mePredAlloc(&memPool),
+        tmpAlloc(&tmpPool),
+        func(&mf),
+        cfg(mf.GetCfg()),
+        dom(&dom),
+        pdom(&pdom),
+        meLoop(&loops),
+        sccVec(tmpAlloc.Adapter()),
+        hMap(&map),
+        bbPredictions(tmpAlloc.Adapter()),
+        edges(tmpAlloc.Adapter()),
+        backEdgeProb(tmpAlloc.Adapter()),
+        bbVisited(tmpAlloc.Adapter()),
+        backEdges(tmpAlloc.Adapter()),
+        predictDebug(false) {}
+
+  virtual ~MePrediction() = default;
+  Edge *FindEdge(const BB &src, const BB &dest) const;
+  bool IsBackEdge(const Edge &edge) const;
+  Predictor ReturnPrediction(const MeExpr *meExpr, Prediction &prediction) const;
+  void PredictEdge(Edge &edge, Predictor predictor, int probability);
+  void PredEdgeDef(Edge &edge, Predictor predictor, Prediction taken);
+  bool HasEdgePredictedBy(const Edge &edge, Predictor predictor);
+  void PredictForPostDomFrontier(const BB &bb, Predictor predictor, Prediction direction);
+  void BBLevelPredictions();
+  void Init();
+  bool PredictedByLoopHeuristic(const BB &bb) const;
+  void SortLoops();
+  void PredictLoops();
+  void PredictByOpcode(BB *bb);
+  void EstimateBBProb(BB &bb);
+  void ClearBBPredictions(const BB &bb);
+  void CombinePredForBB(const BB &bb);
+  bool DoPropFreq(const BB *head, std::vector<BB*> *headers, BB &bb);
+  void PropFreqInLoops();
+  void PropFreqInIrreducibleSCCs();
+  bool PropFreqInFunc();
+  void ComputeBBFreq();
+  void EstimateBranchProb();
+  void Run();
+  void SetPredictDebug(bool val);
+  void SavePredictResultIntoCfg();
+  void BuildSCC();
+  void FindSCCHeaders(const SCCOfBBs &scc, std::vector<BB*> &headers);
+
+  void SetBuiltinExpectInfo(BuiltinExpectInfo &expectInfo) {
+    builtinExpectInfo = &expectInfo;
+  }
+
+  const BuiltinExpectInfo *GetBuiltinExpectInfo() const {
+    return builtinExpectInfo;
+  }
+
+ protected:
+  MapleAllocator mePredAlloc;
+  MapleAllocator tmpAlloc;
+  MeFunction *func;
+  MeCFG      *cfg;
+  Dominance *dom;
+  Dominance *pdom;
+  IdentifyLoops *meLoop;
+  MapleVector<SCCOfBBs*> sccVec;
+  MapleVector<std::pair<bool, uint32>> *inSCCPtr = nullptr;   // entry format: <isInSucc, rpoIdx>
+  MeIRMap *hMap;
+  MapleVector<EdgePrediction*> bbPredictions;  // indexed by edge src bb id
+  MapleVector<Edge*> edges;
+  MapleMap<Edge*, double> backEdgeProb;  // used in EstimateBBFrequency
+  MapleVector<bool> bbVisited;
+  MapleVector<Edge*> backEdges;  // all backedges of loops
+  // used to save and recover builtin expect branchProb of condgoto stmt
+  BuiltinExpectInfo *builtinExpectInfo = nullptr;
+  bool predictDebug;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEPredict, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MEPREDICT_H
diff --git a/src/mapleall/maple_me/include/me_profile_gen.h b/src/mapleall/maple_me/include/me_profile_gen.h
new file mode 100644
index 0000000000000000000000000000000000000000..207d080fa35bbf7f4695cb3424ff5d1169ad57b2
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_profile_gen.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_PROFILEGEN_H
+#define MAPLE_ME_INCLUDE_PROFILEGEN_H
+
+#include "me_pgo_instrument.h"
+#include "bb.h"
+#include "me_irmap.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+class BBEdge;
+class MeProfGen : public PGOInstrument<BBEdge> {
+ public:
+  MeProfGen(MeFunction &func, MemPool &mp, MeIRMap &hMap, bool dump)
+      : PGOInstrument(func, mp, dump), func(&func), hMap(&hMap) {
+    Init();
+  }
+  virtual ~MeProfGen() = default;
+  bool CanInstrument() const;
+  void InstrumentFunc();
+  static void DumpSummary();
+  static void IncTotalFunc();
+ private:
+  void Init();
+  void InstrumentBB(BB &bb);
+  void SaveProfile();
+  MeFunction *func;
+  MeIRMap *hMap;
+  static uint64 counterIdx;
+  static uint64 totalBB;
+  static uint64 instrumentBB;
+  static uint64 totalFunc;
+  static uint64 instrumentFunc;
+  static MIRSymbol *bbCounterTabSym;
+  static bool firstRun;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEProfGen, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_PROFILEGEN_H
diff --git a/src/mapleall/maple_me/include/me_profile_use.h b/src/mapleall/maple_me/include/me_profile_use.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5d1de857cbf3e41a4354bd2a4a4bccc99a87c62
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_profile_use.h
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_PROFILEUSE_H
+#define MAPLE_ME_INCLUDE_PROFILEUSE_H
+
+#include "me_pgo_instrument.h"
+#include "bb.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+class BBUseEdge : public BBEdge {
+ public:
+  BBUseEdge(BB *src, BB *dest, uint64 w = 1, bool isCritical = false, bool isFake = false)
+      : BBEdge(src, dest, w, isCritical, isFake) {}
+  virtual ~BBUseEdge() = default;
+
+  void SetCount(uint64 value) {
+    countValue = value;
+    valid = true;
+  }
+
+  uint64 GetCount() const {
+    return countValue;
+  }
+
+  bool GetStatus() const {
+    return valid;
+  }
+ private:
+  bool valid = false;
+  uint64 countValue = 0;
+};
+
+
+class BBUseInfo {
+ public:
+  explicit BBUseInfo(MemPool &tmpPool)
+      : tmpAlloc(&tmpPool), inEdges(tmpAlloc.Adapter()), outEdges(tmpAlloc.Adapter()) {}
+  virtual ~BBUseInfo() = default;
+
+  void SetCount(uint64 value) {
+    countValue = value;
+    valid = true;
+  }
+  uint64 GetCount() const {
+    return countValue;
+  }
+
+  bool GetStatus() const {
+    return valid;
+  }
+
+  void AddOutEdge(BBUseEdge *e) {
+    outEdges.push_back(e);
+    if (!e->GetStatus()) {
+      unknownOutEdges++;
+    }
+  }
+
+  void AddInEdge(BBUseEdge *e) {
+    inEdges.push_back(e);
+    if (!e->GetStatus()) {
+      unknownInEdges++;
+    }
+  }
+
+  const MapleVector<BBUseEdge*> &GetInEdges() const {
+    return inEdges;
+  }
+
+  MapleVector<BBUseEdge*> &GetInEdges() {
+    return inEdges;
+  }
+
+  size_t GetInEdgeSize() const {
+    return inEdges.size();
+  }
+
+  const MapleVector<BBUseEdge*> &GetOutEdges() const {
+    return outEdges;
+  }
+
+  MapleVector<BBUseEdge*> &GetOutEdges() {
+    return outEdges;
+  }
+
+  size_t GetOutEdgeSize() const {
+    return outEdges.size();
+  }
+
+  void DecreaseUnKnownOutEdges() {
+    unknownOutEdges--;
+  }
+
+  void DecreaseUnKnownInEdges() {
+    unknownInEdges--;
+  }
+
+  uint32 GetUnknownOutEdges() const {
+    return unknownOutEdges;
+  }
+
+  uint32 GetUnknownInEdges() const {
+    return unknownInEdges;
+  }
+
+ private:
+  bool valid = false;
+  uint64 countValue = 0;
+  uint32 unknownInEdges = 0;
+  uint32 unknownOutEdges = 0;
+  MapleAllocator tmpAlloc;
+  MapleVector<BBUseEdge*> inEdges;
+  MapleVector<BBUseEdge*> outEdges;
+};
+
+class MeProfUse : public PGOInstrument<BBUseEdge> {
+ public:
+  MeProfUse(MeFunction &func, MemPool &mp, bool dump) : PGOInstrument(func, mp, dump), func(&func), mp(&mp) {}
+  virtual ~MeProfUse() = default;
+  bool BuildEdgeCount();
+  void SetFuncEdgeInfo();
+  void DumpFuncCFGEdgeFreq() const;
+  bool Run();
+  bool IsSuccUseProf() const {
+    return succCalcuAllEdgeFreq;
+  }
+  bool MapleProfRun();
+  void CheckSumFail(const uint64 hash, const uint32 expectedCheckSum, const std::string &tag);
+ private:
+  bool IsAllZero(Profile::BBInfo &result) const;
+  void SetEdgeCount(BBUseEdge &edge, size_t value);
+  void SetEdgeCount(MapleVector<BBUseEdge*> &edges, uint64 value);
+  void ComputeEdgeFreq();
+  void InitBBEdgeInfo();
+  void ComputeBBFreq(BBUseInfo &bbInfo, bool &changed);
+  FuncProfInfo *GetFuncData();
+
+  uint64 SumEdgesCount(const MapleVector<BBUseEdge*> &edges) const;
+  BBUseInfo *GetBBUseInfo(const BB &bb) const;
+  BBUseInfo *GetOrCreateBBUseInfo(const BB &bb) ;
+  MeFunction *func;
+  MemPool *mp;
+  bool succCalcuAllEdgeFreq = false;
+  std::unordered_map<const BB*, BBUseInfo*> bbProfileInfo;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEProfUse, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_PROFILEUSE_H
diff --git a/src/mapleall/maple_me/include/me_prop.h b/src/mapleall/maple_me/include/me_prop.h
new file mode 100644
index 0000000000000000000000000000000000000000..45ed6ab6ae092bb160cce0cdc90ac555b7ed3f33
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_prop.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEPROP_H
+#define MAPLE_ME_INCLUDE_MEPROP_H
+#include "me_irmap_build.h"
+#include "bb.h"
+#include "prop.h"
+
+namespace maple {
+class MeProp : public Prop {
+ public:
+  MeProp(MeIRMap &irMap, Dominance &dom, Dominance &pdom, MemPool &memPool, const PropConfig &config,
+         uint32 limit = UINT32_MAX)
+      : Prop(irMap, dom, pdom, memPool, irMap.GetFunc().GetCfg()->GetAllBBs().size(), config, limit),
+        func(&irMap.GetFunc()) {}
+
+  virtual ~MeProp() = default;
+ private:
+  MeFunction *func;
+
+  BB *GetBB(BBId id) override {
+    return func->GetCfg()->GetAllBBs()[id];
+  }
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEMeProp, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MEPROP_H
diff --git a/src/mapleall/maple_me/include/me_rc_lowering.h b/src/mapleall/maple_me/include/me_rc_lowering.h
new file mode 100644
index 0000000000000000000000000000000000000000..e319b2fc484e5a2faef82264ef9022749da3ff2f
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_rc_lowering.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_RC_LOWERING_H
+#define MAPLE_ME_INCLUDE_ME_RC_LOWERING_H
+#include "class_hierarchy_phase.h"
+#include "me_function.h"
+#include "me_irmap_build.h"
+#include "mir_builder.h"
+#include "me_cfg.h"
+
+namespace maple {
+class RCLowering {
+ public:
+  RCLowering(MeFunction &f, KlassHierarchy &kh, bool enabledDebug)
+      : func(f),
+        mirModule(f.GetMIRModule()),
+        cfg(f.GetCfg()),
+        irMap(*f.GetIRMap()),
+        ssaTab(*f.GetMeSSATab()),
+        klassHierarchy(kh),
+        enabledDebug(enabledDebug) {}
+
+  virtual ~RCLowering() = default;
+
+  void Prepare();
+  void PreRCLower();
+  void RCLower();
+  void PostRCLower();
+  void Finish();
+  void FastBBLower(BB &bb);
+  void SetDominance(Dominance &domin) {
+    dominance = &domin;
+  }
+  bool GetIsAnalyzed() const {
+    return isAnalyzed;
+  }
+
+ private:
+  void MarkLocalRefVar();
+  void MarkAllRefOpnds();
+  void UpdateRefVarVersions(BB &bb);
+  void RecordVarPhiVersions(std::map<OStIdx, size_t> &savedStackSize, const BB &bb);
+  void TraverseAllStmts(BB &bb);
+  void RestoreVersionRecords(std::map<OStIdx, size_t> &savedStackSize);
+  void UnmarkNotNeedDecRefOpnds();
+  void EpreFixup(BB &bb);
+  void BBLower(BB &bb);
+  void CreateCleanupIntrinsics();
+  void HandleArguments();
+  void CompactRC(BB &bb);
+  void CompactIncAndDec(MeStmt &incStmt, MeStmt &decStmt);
+  void CompactIncAndDecReset(MeStmt &incStmt, MeStmt &resetStmt);
+  void ReplaceDecResetWithDec(MeStmt &prevStmt, MeStmt &stmt);
+  void CompactAdjacentDecReset(MeStmt &prevStmt, MeStmt &stmt);
+  // create new symbol from name and return its ost
+  OriginalSt *RetrieveOSt(const std::string &name, bool isLocalrefvar) const;
+  // create new symbol from temp name and return its VarMeExpr
+  // new symbols are stored in a set
+  VarMeExpr *CreateNewTmpVarMeExpr(bool isLocalrefvar);
+  VarMeExpr *CreateVarMeExprFromSym(MIRSymbol &sym) const;
+  // return true if the rhs is simple so we can adjust RC count before assignments
+  bool RCFirst(MeExpr &rhs);
+  IntrinsiccallMeStmt *GetVarRHSHandleStmt(const MeStmt &stmt);
+  IntrinsiccallMeStmt *GetIvarRHSHandleStmt(const MeStmt &stmt);
+  MIRIntrinsicID PrepareVolatileCall(const MeStmt &stmt, MIRIntrinsicID index = INTRN_UNDEFINED);
+  IntrinsiccallMeStmt *CreateRCIntrinsic(MIRIntrinsicID intrnID, const MeStmt &stmt, std::vector<MeExpr*> &opnds,
+                                         bool assigned = false);
+  MeExpr *HandleIncRefAndDecRefStmt(MeStmt &stmt);
+  void InitializedObjectFields(MeStmt &stmt);
+  bool IsInitialized(IvarMeExpr &ivar);
+  void PreprocessAssignMeStmt(MeStmt &stmt);
+  void HandleAssignMeStmtRHS(MeStmt &stmt);
+  void HandleAssignMeStmtRegLHS(MeStmt &stmt);
+  void HandleAssignToGlobalVar(MeStmt &stmt);
+  void HandleAssignToLocalVar(MeStmt &stmt, MeExpr *pendingDec);
+  void HandleAssignMeStmtVarLHS(MeStmt &stmt, MeExpr *pendingDec);
+  void HandleAssignMeStmtIvarLHS(MeStmt &stmt);
+  void HandleCallAssignedMeStmt(MeStmt &stmt, MeExpr *pendingDec);
+  void IntroduceRegRetIntoCallAssigned(MeStmt &stmt);
+  void HandleRetOfCallAssignedMeStmt(MeStmt &stmt, MeExpr &pendingDec);
+  void HandleReturnVar(RetMeStmt &ret);
+  void HandleReturnGlobal(RetMeStmt &ret);
+  void HandleReturnRegread(RetMeStmt &ret);
+  void HandleReturnFormal(RetMeStmt &ret);
+  void HandleReturnIvar(RetMeStmt &ret);
+  void HandleReturnReg(RetMeStmt &ret);
+  void HandleReturnWithCleanup();
+  void HandleReturnNeedBackup();
+  void HandleReturnStmt();
+  void HandleAssignMeStmt(MeStmt &stmt, MeExpr *pendingDec);
+  void HandlePerManent(MeStmt &stmt);
+  bool HasCallOrBranch(const MeStmt &from, const MeStmt &to) const;
+  MIRIntrinsicID SelectWriteBarrier(const MeStmt &stmt);
+  MIRType *GetArrayNodeType(const VarMeExpr &var);
+  void CheckArrayStore(IntrinsiccallMeStmt &writeRefCall);
+  void FastLowerThrowStmt(MeStmt &stmt, MapleMap<uint32, MeStmt*> &exceptionAllocsites);
+  void FastLowerRetStmt(MeStmt &stmt);
+  void FastLowerRetVar(RetMeStmt &stmt);
+  void FastLowerRetIvar(RetMeStmt &stmt);
+  void FastLowerRetReg(RetMeStmt &stmt);
+  void FastLowerAssignToVar(MeStmt &stmt, MapleMap<uint32, MeStmt*> &exceptionAllocsites);
+  void FastLowerAssignToIvar(MeStmt &stmt);
+  void FastLowerCallAssignedStmt(MeStmt &stmt);
+  void CheckRefs();
+  void ParseCheckFlag();
+  void CheckFormals();
+  void CheckRefsInAssignStmt(BB &bb);
+  void CheckRefReturn(BB &bb);
+  MeFunction &func;
+  MIRModule &mirModule;
+  MeCFG *cfg;
+  IRMap &irMap;
+  SSATab &ssaTab;
+  KlassHierarchy &klassHierarchy;
+  std::vector<MeStmt*> rets{};  // std::vector of return statement
+  unsigned int tmpCount = 0;
+  uint32_t checkRCIndex = 0;
+  bool needSpecialHandleException = false;
+  bool isAnalyzed = false;
+  bool rcCheckReferent = false;
+  Dominance *dominance = nullptr;
+  std::set<const MIRSymbol*> assignedPtrSym;
+  std::set<VarMeExpr*> tmpLocalRefVars;
+  std::set<MeExpr*> gcMallocObjects{};
+  std::map<OStIdx, VarMeExpr*> cleanUpVars{};
+  std::map<OStIdx, OriginalSt*> varOStMap{};
+  // used to store initialized map, help to optimize dec ref in first assignment
+  std::unordered_map<MeExpr*, std::set<FieldID>> initializedFields{};
+  std::map<MeStmt*, MeExpr*> decOpnds{};
+  std::map<OStIdx, std::vector<MeExpr*>> varVersions{};
+  bool checkRefFormal = false;
+  bool checkRefAssign = false;
+  bool checkRefReturn = false;
+  bool enabledDebug;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MERCLowering, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_RC_LOWERING_H
diff --git a/src/mapleall/maple_me/include/me_rename2preg.h b/src/mapleall/maple_me/include/me_rename2preg.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f2a7dc6b332318f306121762883c6a7a1c2e187
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_rename2preg.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MERENAME2PREG_H
+#define MAPLE_ME_INCLUDE_MERENAME2PREG_H
+#include "me_function.h"
+#include "maple_phase.h"
+#include "me_alias_class.h"
+
+namespace maple {
+class SSARename2Preg {
+ public:
+  SSARename2Preg(MemPool *mp, MeFunction *f, MeIRMap *hmap, Dominance *domTree, AliasClass *alias)
+      : alloc(mp),
+        func(f),
+        meirmap(hmap),
+        dom(domTree),
+        ssaTab(f->GetMeSSATab()),
+        mirModule(&f->GetMIRModule()),
+        aliasclass(alias),
+        sym2reg_map(std::less<OStIdx>(), alloc.Adapter()),
+        vstidx2reg_map(alloc.Adapter()),
+        parm_used_vec(alloc.Adapter()),
+        reg_formal_vec(alloc.Adapter()),
+        ostDefedByChi(ssaTab->GetOriginalStTableSize(), false, alloc.Adapter()),
+        ostDefedByDassign(ssaTab->GetOriginalStTableSize(), false, alloc.Adapter()),
+        ostUsedByDread(ssaTab->GetOriginalStTableSize(), false, alloc.Adapter()),
+        candsForSSAUpdate() {}
+
+  virtual ~SSARename2Preg() = default;
+  void RunSelf();
+  void PromoteEmptyFunction();
+  uint32 rename2pregCount = 0;
+
+ private:
+  const AliasClass::AliasSet *GetAliasSet(const OriginalSt *ost) const {
+    return aliasclass->GetAliasSet(ost->GetIndex());
+  }
+
+  void Rename2PregStmt(MeStmt *);
+  void Rename2PregExpr(MeStmt *, MeExpr *);
+  void Rename2PregLeafRHS(MeStmt *, const VarMeExpr *);
+  void Rename2PregLeafLHS(MeStmt *, const VarMeExpr *);
+  RegMeExpr *CreatePregForVar(const VarMeExpr *varMeExpr);
+  RegMeExpr *FindOrCreatePregForVarPhiOpnd(const VarMeExpr *varMeExpr);
+  bool Rename2PregPhi(MePhiNode *, MapleMap<OStIdx, MePhiNode *> &);
+  void UpdateRegPhi(MePhiNode *, MePhiNode *, const VarMeExpr *);
+  void Rename2PregCallReturn(MapleVector<MustDefMeNode> &);
+  bool VarMeExprIsRenameCandidate(const VarMeExpr &varMeExpr) const;
+  RegMeExpr *RenameVar(const VarMeExpr *);
+  void UpdateMirFunctionFormal();
+  void SetupParmUsed(const VarMeExpr *);
+  void Init();
+  void CollectUsedOst(const MeExpr *meExpr);
+  void CollectDefUseInfoOfOst();
+  std::string PhaseName() const {
+    return "rename2preg";
+  }
+
+  MapleAllocator alloc;
+  MeFunction *func;
+  MeIRMap *meirmap;
+  Dominance *dom;
+  SSATab *ssaTab;
+  MIRModule *mirModule;
+  AliasClass *aliasclass;
+  MapleMap<OStIdx, OriginalSt *> sym2reg_map;      // map var to reg in original symbol
+  MapleUnorderedMap<int32, RegMeExpr *> vstidx2reg_map;  // maps the VarMeExpr's exprID to RegMeExpr
+  MapleVector<bool> parm_used_vec;                       // if parameter is not used, it's false, otherwise true
+  // if the parameter got promoted, the nth of func->mirFunc->_formal is the nth of reg_formal_vec, otherwise nullptr;
+  MapleVector<RegMeExpr *> reg_formal_vec;
+  MapleVector<bool> ostDefedByChi;
+  MapleVector<bool> ostDefedByDassign;
+  MapleVector<bool> ostUsedByDread;
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> candsForSSAUpdate;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MESSARename2Preg, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MERENAME2PREG_H
diff --git a/src/mapleall/maple_me/include/me_safe_cast_traits.def b/src/mapleall/maple_me/include/me_safe_cast_traits.def
new file mode 100644
index 0000000000000000000000000000000000000000..a1fba4c8182968041043e5ed126a4482e61929a0
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_safe_cast_traits.def
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <safe_cast.h>
+#include "opcode_info.h"
+
+namespace maple {
+#ifdef LOAD_SAFE_CAST_FOR_ME_EXPR
+#undef LOAD_SAFE_CAST_FOR_ME_EXPR
+REGISTER_SAFE_CAST(VarMeExpr, from.GetMeOp() == kMeOpVar);
+REGISTER_SAFE_CAST(RegMeExpr, from.GetMeOp() == kMeOpReg);
+REGISTER_SAFE_CAST(ConstMeExpr, from.GetMeOp() == kMeOpConst);
+REGISTER_SAFE_CAST(ConststrMeExpr, from.GetMeOp() == kMeOpConststr);
+REGISTER_SAFE_CAST(Conststr16MeExpr, from.GetMeOp() == kMeOpConststr16);
+REGISTER_SAFE_CAST(SizeoftypeMeExpr, from.GetMeOp() == kMeOpSizeoftype);
+REGISTER_SAFE_CAST(FieldsDistMeExpr, from.GetMeOp() == kMeOpFieldsDist);
+REGISTER_SAFE_CAST(AddrofMeExpr, from.GetMeOp() == kMeOpAddrof);
+REGISTER_SAFE_CAST(AddroffuncMeExpr, from.GetMeOp() == kMeOpAddroffunc);
+REGISTER_SAFE_CAST(GcmallocMeExpr, from.GetMeOp() == kMeOpGcmalloc);
+REGISTER_SAFE_CAST(OpMeExpr, from.GetMeOp() == kMeOpOp);
+REGISTER_SAFE_CAST(IvarMeExpr, from.GetMeOp() == kMeOpIvar);
+REGISTER_SAFE_CAST(NaryMeExpr, from.GetMeOp() == kMeOpNary);
+#endif
+
+#ifdef LOAD_SAFE_CAST_FOR_ME_STMT
+#undef LOAD_SAFE_CAST_FOR_ME_STMT
+REGISTER_SAFE_CAST(PiassignMeStmt, from.GetOp() == OP_piassign);
+REGISTER_SAFE_CAST(DassignMeStmt, from.GetOp() == OP_dassign);
+REGISTER_SAFE_CAST(AssignMeStmt, from.GetOp() == OP_regassign);
+REGISTER_SAFE_CAST(MaydassignMeStmt, from.GetOp() == OP_maydassign);
+REGISTER_SAFE_CAST(IassignMeStmt, from.GetOp() == OP_iassign);
+REGISTER_SAFE_CAST(NaryMeStmt, instance_of<CallMeStmt>(from) ||
+                               instance_of<IcallMeStmt>(from) ||
+                               instance_of<IntrinsiccallMeStmt>(from) ||
+                               instance_of<RetMeStmt>(from) ||
+                               instance_of<SyncMeStmt>(from));
+REGISTER_SAFE_CAST(CallMeStmt, from.GetOp() == OP_call ||
+                               from.GetOp() == OP_virtualcall ||
+                               from.GetOp() == OP_superclasscall ||
+                               from.GetOp() == OP_interfacecall ||
+                               from.GetOp() == OP_customcall ||
+                               from.GetOp() == OP_polymorphiccall ||
+                               from.GetOp() == OP_interfaceicall ||
+                               from.GetOp() == OP_virtualicall ||
+                               from.GetOp() == OP_callassigned ||
+                               from.GetOp() == OP_virtualcallassigned ||
+                               from.GetOp() == OP_superclasscallassigned ||
+                               from.GetOp() == OP_interfacecallassigned ||
+                               from.GetOp() == OP_customcallassigned ||
+                               from.GetOp() == OP_polymorphiccallassigned ||
+                               from.GetOp() == OP_interfaceicallassigned ||
+                               from.GetOp() == OP_virtualicallassigned);
+REGISTER_SAFE_CAST(IcallMeStmt, from.GetOp() == OP_icall ||
+                                from.GetOp() == OP_icallassigned);
+REGISTER_SAFE_CAST(IntrinsiccallMeStmt, from.GetOp() == OP_intrinsiccall ||
+                                        from.GetOp() == OP_intrinsiccallwithtype ||
+                                        from.GetOp() == OP_xintrinsiccall ||
+                                        from.GetOp() == OP_intrinsiccallassigned ||
+                                        from.GetOp() == OP_intrinsiccallwithtypeassigned ||
+                                        from.GetOp() == OP_xintrinsiccallassigned);
+REGISTER_SAFE_CAST(RetMeStmt, from.GetOp() == OP_return);
+REGISTER_SAFE_CAST(UnaryMeStmt, instance_of<CondGotoMeStmt>(from) ||
+                                instance_of<SwitchMeStmt>(from) ||
+                                instance_of<CondGotoMeStmt>(from) ||
+                                from.GetOp() == OP_eval ||
+                                from.GetOp() == OP_free ||
+                                (kOpcodeInfo.IsAssertNonnull(from.GetOpCode()) &&
+                                 !kOpcodeInfo.IsCallAssertNonnull(from.GetOpCode())) ||
+                                from.GetOp() == OP_incref ||
+                                from.GetOp() == OP_decref ||
+                                from.GetOp() == OP_decrefreset);
+REGISTER_SAFE_CAST(SafetyCallCheckMeStmt, from.GetOpCode() == OP_callassertnonnull);
+REGISTER_SAFE_CAST(GotoMeStmt, from.GetOp() == OP_goto);
+REGISTER_SAFE_CAST(CondGotoMeStmt, from.GetOp() == OP_brtrue ||
+                                   from.GetOp() == OP_brfalse);
+REGISTER_SAFE_CAST(JsTryMeStmt, from.GetOp() == OP_jstry);
+REGISTER_SAFE_CAST(TryMeStmt, from.GetOp() == OP_try);
+REGISTER_SAFE_CAST(CatchMeStmt, from.GetOp() == OP_catch);
+REGISTER_SAFE_CAST(SwitchMeStmt, from.GetOp() == OP_switch);
+REGISTER_SAFE_CAST(CommentMeStmt, from.GetOp() == OP_comment);
+REGISTER_SAFE_CAST(WithMuMeStmt, instance_of<GosubMeStmt>(from) ||
+                                 instance_of<ThrowMeStmt>(from) ||
+                                 from.GetOp() == OP_retsub);
+REGISTER_SAFE_CAST(GosubMeStmt, from.GetOp() == OP_gosub);
+REGISTER_SAFE_CAST(ThrowMeStmt, from.GetOp() == OP_throw);
+REGISTER_SAFE_CAST(SyncMeStmt, from.GetOp() == OP_syncenter ||
+                               from.GetOp() == OP_syncexit);
+#endif
+}
diff --git a/src/mapleall/maple_me/include/me_safety_warning.h b/src/mapleall/maple_me/include/me_safety_warning.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e5f55273709176f86ce5d2f8098d075fcc5542f
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_safety_warning.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_SAFETY_WARNING_H
+#define MAPLE_ME_INCLUDE_ME_SAFETY_WARNING_H
+#include "me_function.h"
+#include "opcodes.h"
+namespace maple {
+std::string GetNthStr(size_t index);
+// param: assert stmt, mir module, caller function
+// return True --- delete assert stmt.
+using SafetyWarningHandler = std::function<bool(const MeStmt&, const MIRModule&, const MeFunction&)>;
+using SafetyWarningHandlers = std::map<Opcode, SafetyWarningHandler>;
+class MESafetyWarning : public MapleFunctionPhase<MeFunction> {
+ public:
+  explicit MESafetyWarning(MemPool *mp) : MapleFunctionPhase<MeFunction>(&id, mp) {
+    realNpeHandleMap =
+        (MeOption::npeCheckMode == SafetyCheckMode::kDynamicCheckSilent) ? &npeSilentHandleMap : &npeHandleMap;
+    realBoundaryHandleMap = (MeOption::boundaryCheckMode == SafetyCheckMode::kDynamicCheckSilent)
+                                ? &boundarySilentHandleMap
+                                : &boundaryHandleMap;
+  }
+
+  ~MESafetyWarning() override = default;
+  static unsigned int id;
+  static MaplePhase *CreatePhase(MemPool *createMP) {
+    return createMP->New<MESafetyWarning>(createMP);
+  }
+
+  bool PhaseRun(MeFunction &f) override;
+  std::string PhaseName() const override;
+
+ private:
+  void GetAnalysisDependence(maple::AnalysisDep &aDep) const override;
+  bool IsStaticModeForOp(Opcode op) const;
+  SafetyWarningHandler *FindHandler(Opcode op);
+
+  SafetyWarningHandlers *realNpeHandleMap;
+  SafetyWarningHandlers *realBoundaryHandleMap;
+  static SafetyWarningHandlers npeHandleMap;
+  static SafetyWarningHandlers boundaryHandleMap;
+  static SafetyWarningHandlers npeSilentHandleMap;
+  static SafetyWarningHandlers boundarySilentHandleMap;
+};
+}  // namespace maple
+#endif /* MAPLE_ME_INCLUDE_ME_SAFETY_WARNING_H */
diff --git a/src/mapleall/maple_me/include/me_scalar_analysis.h b/src/mapleall/maple_me/include/me_scalar_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..87516cf655391f65ef8d4aceb6301a2172a58405
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_scalar_analysis.h
@@ -0,0 +1,350 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_SCALAR_ANALYSIS_H
+#define MAPLE_ME_INCLUDE_SCALAR_ANALYSIS_H
+#include "me_function.h"
+#include "me_irmap.h"
+#include "me_loop_analysis.h"
+#include "me_ir.h"
+
+namespace maple {
+constexpr uint64 kInvalidTripCount = ULLONG_MAX;
+class LoopScalarAnalysisResult;
+
+enum CRNodeType {
+  kCRConstNode,
+  kCRVarNode,
+  kCRAddNode,
+  kCRMulNode,
+  kCRDivNode,
+  kCRNode,
+  kCRUnKnown
+};
+
+class CRNode {
+ public:
+  CRNode(MeExpr *e, CRNodeType t) : expr(e), crType(t) {}
+  virtual ~CRNode() = default;
+
+  CRNodeType GetCRType() const {
+    return crType;
+  }
+
+  MeExpr *GetExpr() {
+    return expr;
+  }
+
+  const MeExpr *GetExpr() const {
+    return expr;
+  }
+
+  virtual size_t SizeOfOperand() const {
+    CHECK_FATAL(false, "can not be here");
+  }
+
+  virtual std::vector<CRNode*> &GetOpnds() {
+    CHECK_FATAL(false, "can not be here");
+  }
+
+  virtual const std::vector<CRNode*> &GetOpnds() const {
+    CHECK_FATAL(false, "can not be here");
+  }
+
+  bool IsEqual(const CRNode &crNode) const;
+  void PutTheSubNode2Vector(std::vector<CRNode*> &curVector);
+  void GetTheUnequalSubNodesOfIndexAndBound(
+      CRNode &boundCRNode, std::vector<CRNode*> &indexVector, std::vector<CRNode*> &boundVector);
+
+ private:
+  MeExpr *expr;
+  CRNodeType crType;
+};
+
+class CRUnKnownNode : public CRNode {
+ public:
+  explicit CRUnKnownNode(MeExpr *e) : CRNode(e, kCRUnKnown) {}
+  ~CRUnKnownNode() = default;
+};
+
+class CRConstNode : public CRNode {
+ public:
+  CRConstNode(MeExpr *e, int64 v) : CRNode(e, kCRConstNode), value(v) {}
+  ~CRConstNode() = default;
+
+  int64 GetConstValue() const {
+    return value;
+  }
+
+  size_t SizeOfOperand() const {
+    return 1;
+  }
+
+ private:
+  int64 value;
+};
+
+class CRVarNode : public CRNode {
+ public:
+  explicit CRVarNode(MeExpr *e) : CRNode(e, kCRVarNode) {}
+  ~CRVarNode() = default;
+
+  size_t SizeOfOperand() const {
+    return 1;
+  }
+};
+
+struct CRNodeComparator {
+  bool operator()(const CRNode *lhs, const CRNode *rhs) const {
+    ASSERT_NOT_NULL(lhs);
+    ASSERT_NOT_NULL(rhs);
+    return lhs->GetExpr()->GetExprID() < rhs->GetExpr()->GetExprID();
+  }
+};
+
+class CRAddNode : public CRNode {
+ public:
+  explicit CRAddNode(MeExpr *e) : CRNode(e, kCRAddNode) {}
+  ~CRAddNode() = default;
+
+  void SetOpnds(const std::vector<CRNode*> &o) {
+    opnds = o;
+  }
+
+  CRNode *GetOpnd(size_t i) const {
+    return opnds.at(i);
+  }
+
+  std::vector<CRNode*> &GetOpnds() override {
+    return opnds;
+  }
+
+  const std::vector<CRNode*> &GetOpnds() const override {
+    return opnds;
+  }
+
+  size_t GetOpndsSize() const {
+    return opnds.size();
+  }
+
+  size_t SizeOfOperand() const override {
+    return opnds.size();
+  }
+
+ private:
+  std::vector<CRNode*> opnds;
+};
+
+class CRMulNode : public CRNode {
+ public:
+  explicit CRMulNode(MeExpr *e) : CRNode(e, kCRMulNode) {}
+  ~CRMulNode() = default;
+
+  const CRNode *GetOpnd(size_t i) const {
+    return opnds.at(i);
+  }
+
+  CRNode *GetOpnd(size_t i) {
+    return opnds.at(i);
+  }
+
+  size_t GetOpndsSize() const {
+    return opnds.size();
+  }
+
+  void SetOpnds(const std::vector<CRNode*> &o) {
+    opnds = o;
+  }
+
+  std::vector<CRNode*> &GetOpnds() override {
+    return opnds;
+  }
+
+  const std::vector<CRNode*> &GetOpnds() const override {
+    return opnds;
+  }
+
+  size_t SizeOfOperand() const override {
+    return opnds.size();
+  }
+
+ private:
+  std::vector<CRNode*> opnds;
+};
+
+class CRDivNode : public CRNode {
+ public:
+  CRDivNode(MeExpr *e, CRNode &l, CRNode &r) : CRNode(e, kCRDivNode), lhs(&l), rhs(&r) {}
+  ~CRDivNode() = default;
+
+  const CRNode *GetLHS() const {
+    return lhs;
+  }
+
+  CRNode *GetLHS() {
+    return lhs;
+  }
+
+  const CRNode *GetRHS() const {
+    return rhs;
+  }
+
+  CRNode *GetRHS() {
+    return rhs;
+  }
+
+ private:
+  CRNode *lhs;
+  CRNode *rhs;
+};
+
+class CR : public CRNode {
+ public:
+  explicit CR(MeExpr *e) : CRNode(e, kCRNode) {}
+  ~CR() = default;
+
+  void SetOpnds(const std::vector<CRNode*> &o) {
+    opnds = o;
+  }
+
+  const CRNode *GetOpnd(size_t i) const {
+    return opnds.at(i);
+  }
+
+  CRNode *GetOpnd(size_t i) {
+    return opnds.at(i);
+  }
+
+  void PushOpnds(CRNode &crNode) {
+    opnds.push_back(&crNode);
+  }
+
+  void InsertOpnds(const std::vector<CRNode*>::iterator begin, const std::vector<CRNode*>::iterator end) {
+    (void)opnds.insert(opnds.end(), begin, end);
+  }
+
+  size_t GetOpndsSize() const {
+    return opnds.size();
+  }
+
+  std::vector<CRNode*> &GetOpnds() override {
+    return opnds;
+  }
+
+  const std::vector<CRNode*> &GetOpnds() const override {
+    return opnds;
+  }
+
+  CRNode *GetPolynomialsValueAtITerm(CRNode &iterCRNode, size_t num, LoopScalarAnalysisResult &scalarAnalysis) const;
+  CRNode *ComputeValueAtIteration(uint32 i, LoopScalarAnalysisResult &scalarAnalysis) const;
+
+ private:
+  std::vector<CRNode*> opnds;
+};
+
+struct CompareCRNodeWithCRType {
+  bool operator()(const CRNode *a, const CRNode *b) const {
+    return a->GetCRType() < b->GetCRType();
+  }
+};
+
+// var > add > mul > div
+struct CompareCRNodeWithReverseOrderOfCRType {
+  bool operator()(const CRNode *a, const CRNode *b) const {
+    if (a->GetCRType() == kCRVarNode) {
+      return true;
+    }
+    if (b->GetCRType() == kCRVarNode) {
+      return false;
+    }
+    return a->GetCRType() > b->GetCRType();
+  }
+};
+
+enum TripCountType {
+  kConstCR,
+  kVarCR,
+  kVarCondition,
+  kCouldNotUnroll,
+  kCouldNotComputeCR
+};
+
+class LoopScalarAnalysisResult {
+ public:
+  static bool enableDebug;
+  LoopScalarAnalysisResult(MeIRMap &map, LoopDesc *l) : irMap(&map), loop(l) {}
+  ~LoopScalarAnalysisResult() = default;
+
+  bool IsAnalysised(MeExpr &expr) const {
+    return expr2CR.find(&expr) != expr2CR.end();
+  }
+
+  CRNode *GetExpr2CR(MeExpr &expr) {
+    CHECK_FATAL(expr2CR.find(&expr) != expr2CR.end(), "computedCR must exit");
+    return expr2CR[&expr];
+  }
+
+  void InsertExpr2CR(MeExpr &expr, CRNode *cr) {
+    if ((expr2CR.find(&expr) != expr2CR.end()) && (expr2CR[&expr]->GetCRType() != kCRUnKnown)) {
+      CHECK_FATAL(false, "computedCR must not exit or kCRUnKnown");
+    }
+    expr2CR[&expr] = cr;
+  }
+
+  void SetComputeTripCountForLoopUnroll(bool set) {
+    computeTripCountForLoopUnroll = set;
+  }
+
+  void Dump(const CRNode &crNode);
+  void VerifyCR(const CRNode &crNode);
+  bool HasUnknownCRNode(CRNode &crNode, CRNode *&result);
+  CR *AddCRWithCR(CR &lhsCR, CR &rhsCR);
+  CR *MulCRWithCR(const CR &lhsCR, const CR &rhsCR) const;
+  MeExpr *TryToResolveScalar(MeExpr &expr, std::set<MePhiNode*> &visitedPhi, MeExpr &dummyExpr);
+  CRNode *GetCRAddNode(MeExpr *expr, std::vector<CRNode*> &crAddOpnds);
+  CRNode *GetCRMulNode(MeExpr *expr, std::vector<CRNode*> &crMulOpnds);
+  CRNode *GetOrCreateCR(MeExpr &expr, CRNode &start, CRNode &stride);
+  CRNode *GetOrCreateCR(MeExpr *expr, const std::vector<CRNode*> &crNodes);
+  CRNode *GetOrCreateLoopInvariantCR(MeExpr &expr);
+  CRNode *ChangeNegative2MulCRNode(CRNode &crNode);
+  CRNode *GetOrCreateCRConstNode(MeExpr *expr, int64 value);
+  CRNode *GetOrCreateCRVarNode(MeExpr &expr);
+  CRNode *GetOrCreateCRAddNode(MeExpr *expr, const std::vector<CRNode*> &crAddNodes);
+  CRNode *GetOrCreateCRMulNode(MeExpr *expr, const std::vector<CRNode*> &crMulNodes);
+  CRNode *GetOrCreateCRDivNode(MeExpr *expr, CRNode &lhsCRNode, CRNode &rhsCRNode);
+  CRNode *ComputeCRNodeWithOperator(MeExpr &expr, CRNode &lhsCRNode, CRNode &rhsCRNode, Opcode op);
+  CRNode *CreateSimpleCRForPhi(MePhiNode &phiNode, VarMeExpr &startExpr, const VarMeExpr &backEdgeExpr);
+  CRNode *CreateCRForPhi(MePhiNode &phiNode);
+  CRNode *GetOrCreateCRNode(MeExpr &expr);
+  CRNode *DealWithMeOpOp(MeExpr &currOpMeExpr, MeExpr &expr);
+  TripCountType ComputeTripCount(const MeFunction &func, uint64 &tripCountResult, CRNode *&conditionCRNode, CR *&itCR);
+  void PutTheAddrExprAtTheFirstOfVector(std::vector<CRNode*> &crNodeOperands, const MeExpr &addrExpr);
+  CRNode &SortCROperand(CRNode &crNode, MeExpr &expr);
+  void SortOperatorCRNode(std::vector<CRNode*> &crNodeOperands, MeExpr &addrExpr);
+  bool NormalizationWithByteCount(std::vector<CRNode*> &crNodeVector, uint8 byteSize);
+  uint8 GetByteSize(std::vector<CRNode*> &crNodeVector);
+  PrimType GetPrimType(std::vector<CRNode*> &crNodeVector);
+
+ private:
+  MeIRMap *irMap;
+  LoopDesc *loop;
+  std::map<MeExpr*, CRNode*> expr2CR;
+  std::set<std::unique_ptr<CRNode>> allCRNodes;
+  void DumpTripCount(const CR &cr, int32 value, const MeExpr *expr);
+  uint32 ComputeTripCountWithCR(const CR &cr, const OpMeExpr &opMeExpr, int32 value);
+  uint64 ComputeTripCountWithSimpleConstCR(Opcode op, bool isSigned, int64 value, int64 start, int64 stride) const;
+  bool computeTripCountForLoopUnroll = true;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_SCALAR_ANALYSIS_H
diff --git a/src/mapleall/maple_me/include/me_side_effect.h b/src/mapleall/maple_me/include/me_side_effect.h
new file mode 100644
index 0000000000000000000000000000000000000000..252aecb341b048584cc5886be83ed2d3fc6228b0
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_side_effect.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MESIDEEFFECT_H
+#define MAPLE_ME_INCLUDE_MESIDEEFFECT_H
+#include "call_graph.h"
+#include "mir_nodes.h"
+#include "mir_builder.h"
+#include "me_ir.h"
+#include "me_dominance.h"
+#include "me_function.h"
+
+namespace maple {
+class BB;
+class VersionSt;
+// Sideeffect summary
+class FuncWithSideEffect {
+ public:
+  FuncWithSideEffect(bool pureArg, bool def, bool defArg, bool retGlobalArg,
+                     bool exceptionArg, bool ret, bool privateDefArg, const std::string &name)
+      : funcName(name), pure(pureArg), defArg(def), def(defArg), retGlobal(retGlobalArg),
+        exception(exceptionArg), retArg(ret), privateDef(privateDefArg) {}
+
+  std::string GetFuncName() const {
+    return funcName;
+  }
+
+  virtual ~FuncWithSideEffect() = default;
+  bool GetPure() const {
+    return pure;
+  }
+
+  bool GetDefArg() const {
+    return defArg;
+  }
+
+  bool GetDef() const {
+    return def;
+  }
+
+  bool GetRetGlobal() const {
+    return retGlobal;
+  }
+
+  bool GetException() const {
+    return exception;
+  }
+
+  bool GetRetArg() const {
+    return retArg;
+  }
+
+  bool GetPrivateDef() const {
+    return privateDef;
+  }
+
+ private:
+  std::string funcName;
+  bool pure;
+  bool defArg;
+  bool def;
+  bool retGlobal;
+  bool exception;
+  bool retArg;
+  bool privateDef;
+};
+
+// SCC side effects mask position
+enum SCCEffectPosition : uint8 {
+  kHasThrow = 0x01,
+  kHasRetGlobal = 0x02,
+  kHasDef = 0x04,
+  kHasDefArg = 0x08,
+  kPure = 0x10,
+  kNotPure = kPure,  // Same position as kPure, depending on usage.
+  kHasRetArg = 0x20,
+  kHasPrivateDef = 0x40
+};
+
+class IpaSideEffect {
+ public:
+  IpaSideEffect(MeFunction &mf, MemPool *memPool, CallGraph &callGraph, Dominance &dom);
+  virtual ~IpaSideEffect() = default;
+  void DoAnalysis();
+
+ private:
+  bool IsIgnoreMethod(const MIRFunction &func);
+  void AnalyzeUseThrowEhExpr(MeExpr &expr);
+  bool AnalyzeReturnAllocObj(MeExpr &expr, const std::vector<MeExpr*>&);
+  void SideEffectAnalyzeBB(BB&, std::vector<bool>&);
+  void GetEffectFromAllCallees(MIRFunction &baseFunc);
+  bool AnalyzeReturnAllocObjVst(MeExpr&, const std::vector<MeExpr*>&);
+  bool MatchPuidxAndSetSideEffects(PUIdx idx);
+  void ReadSummary();
+  void SetEffectsTrue();
+  void CopySccSideEffectToAllFunctions(SCCNode<CGNode> &scc, uint8 seMask);
+  void GetEffectFromCallee(MIRFunction &callee, const MIRFunction &caller);
+  void DumpFuncInfo(const std::string &msg, const std::string &name);
+  uint32 GetOrSetSCCNodeId(MIRFunction &func);
+  bool IsCallingIntoSCC(uint32 sccID) const;
+  void UpdateExternalFuncSideEffects(MIRFunction &externCaller);
+  bool AnalyzeDefExpr(VersionSt &baseVar, std::vector<VersionSt*> &varVector);
+  bool MEAnalyzeDefExpr(MeExpr &baseExprMe, std::vector<MeExpr*> &varVector);
+  bool UpdateSideEffectWithStmt(MeStmt &meStmt,
+                                std::set<VarMeExpr*> &globalExprs, std::set<VarMeExpr*> &argExprs,
+                                std::set<VarMeExpr*> &nextLevelGlobalExprs,
+                                std::set<VarMeExpr*> &nextLevelArgExprs);
+  void AnalyzeExpr(MeExpr &expr,
+                   std::set<VarMeExpr*> &globalExprs, std::set<VarMeExpr*> &argExprs,
+                   std::set<VarMeExpr*> &nextLevelGlobalExprs, std::set<VarMeExpr*> &nextLevelArgExprs);
+  bool IsPureFromSummary(const MIRFunction &func) const;
+
+  void SetHasDef() {
+    hasDef = true;
+  }
+
+  bool isSeen;           // This module is compiled and the effects are valid
+  bool notPure;          // Does module produce result purely based on the inputs
+  bool hasDefArg;
+  bool hasDef;           // Has a definition of a field of any pre-existing object
+  bool hasRetGlobal;     // Returns freshly allocated object
+  bool hasThrException;  // throws an exception
+  bool hasRetArg;        // access field is use and private
+  bool hasPrivateDef;    // access field is def and private
+  bool isGlobal;
+  bool isArg;
+  MeFunction &meFunc;
+  MapleAllocator alloc;
+  CallGraph &callGraph;
+  uint32 sccId;
+  Dominance &dominance;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MESideEffect, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MESIDEEFFECT_H
diff --git a/src/mapleall/maple_me/include/me_sink.h b/src/mapleall/maple_me/include/me_sink.h
new file mode 100644
index 0000000000000000000000000000000000000000..9fa8558e3225c5dd900efc3edc3fa4fe096ae695
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_sink.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MEMeSink_H
+#define MAPLE_ME_INCLUDE_MEMeSink_H
+#include "maple_phase_manager.h"
+
+namespace maple {
+MAPLE_FUNC_PHASE_DECLARE(MEMeSink, MeFunction)
+}  // namespace maple
+
+#endif // MAPLE_ME_INCLUDE_MEMeSink_H
\ No newline at end of file
diff --git a/src/mapleall/maple_me/include/me_slp.h b/src/mapleall/maple_me/include/me_slp.h
new file mode 100644
index 0000000000000000000000000000000000000000..1002fdc39808b349359da4d920c34a40db98d64c
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_slp.h
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_SLP
+#define MAPLE_ME_INCLUDE_ME_SLP
+#include <optional>
+#include "me_function.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+MIRType* GenVecType(PrimType sPrimType, uint8 lanes);
+MIRType *GetScalarUnsignedTypeBySize(uint32 typeSize);
+ScalarMeExpr* FindPreVersionByAlias(ScalarMeExpr &aliasPreVersion, ScalarMeExpr &curVersion);
+
+// ----------------- //
+//  Memory Location  //
+// ----------------- //
+class MemBasePtr {
+ public:
+  bool IsFromIvar() const {
+    return addends != nullptr;
+  }
+
+  void PushAddendExpr(MapleAllocator &alloc, const MeExpr &expr, bool isNeg) {
+    if (addends == nullptr) {
+      addends = alloc.New<MapleVector<int32>>(alloc.Adapter());
+    }
+    int32 id = expr.GetExprID();
+    addends->push_back(isNeg ? -id : id);
+  }
+
+  // Get sum of all signed exprId, we generally use the sum as key
+  int32 GetHashKey() const {
+    if (!IsFromIvar()) {
+      return baseOstIdx;
+    }
+    int32 sum = 0;
+    for (auto id : *addends) {
+      sum += id;
+    }
+    return sum;
+  }
+
+  // Descending sort
+  void Sort() {
+    if (addends == nullptr) {
+      return;
+    }
+    std::stable_sort(addends->begin(), addends->end(), std::greater<int32>{});
+  }
+
+  // Make sure `addends` is sorted before calling operator==
+  bool operator==(const MemBasePtr &rhs) const {
+    if (static_cast<uint32>(IsFromIvar()) ^ static_cast<uint32>(rhs.IsFromIvar())) {
+      return false;
+    }
+    if (IsFromIvar()) {
+      return *addends == *rhs.addends;
+    }
+    return baseOstIdx == rhs.baseOstIdx;
+  }
+
+  void SetBaseOstIdx(int32 idx) {
+    baseOstIdx = idx;
+  }
+
+  // Dump example:
+  // for ivar: (mx4 mx3 -mx5)
+  // for  var: (ost42)
+  void Dump() const {
+    if (!IsFromIvar()) {
+      LogInfo::MapleLogger() << "(ost" << baseOstIdx << ")";
+      return;
+    }
+    LogInfo::MapleLogger() << "(";
+    size_t sz = addends->size();
+    for (size_t i = 0; i < sz; ++i) {
+      int32 id = (*addends)[i];
+      if (id >= 0) {
+        LogInfo::MapleLogger() << "mx" << id;
+      } else {
+        LogInfo::MapleLogger() << "-mx" << (-id);
+      }
+      if (i != sz - 1) {
+        LogInfo::MapleLogger() << " ";
+      }
+    }
+    LogInfo::MapleLogger() << ")";
+  }
+ private:
+  // vector of signed exprId, a negative exprId means we should substract this expr
+  MapleVector<int32> *addends = nullptr;  // for ivar
+  int32 baseOstIdx = 0;                   // for var
+};
+
+struct MemBasePtrCmp {
+  bool operator()(const MemBasePtr *a, const MemBasePtr *b) const {
+    return a->GetHashKey() < b->GetHashKey();
+  }
+};
+
+// Representation for Memory Location
+// Each pointer MeExpr can be divided into two parts:
+// (1) base pointer part: the sum of a set of addend expr
+// (2) const offset part: a constant offset
+// Example:
+// For pointer expr `add (add (mx3, sub (mx4, mx5)), 10)`, we get the following MemLoc object:
+//   base : -mx5, mx3, mx4
+//   offset : 10
+// A negative expr means we should substract this expr
+struct MemLoc {
+  MemBasePtr *base = nullptr; // base part
+  MIRType *type = nullptr;    // memory type, we can get memory size from the type
+  MeExpr *rawExpr = nullptr;  // [for emit] such as ivar
+  int32 offset = 0;           // total offset part (in byte)
+  int32 extraOffset = 0;      // [for emit] extra offset from places besides rawExpr such as ivar.fieldId, ivar.offset
+
+  void DumpWithoutEndl() const;
+  void Dump() const;
+  // emit MemLoc to MeExpr
+  MeExpr *Emit() const;
+};
+
+class MemoryHelper {
+ public:
+  explicit MemoryHelper(MemPool &memPool) : alloc(&memPool) {}
+  // return true if mem1 and mem2 have same base pointer
+  static bool HaveSameBase(const MemLoc &mem1, const MemLoc &mem2);
+  // return distance (in byte) from the first memLoc to the second memLoc if they have same base pointer,
+  // return none otherwise.
+  static std::optional<int32> Distance(const MemLoc &from, const MemLoc &to);
+  static bool IsSame(const MemLoc &mem1, const MemLoc &mem2);
+  static bool IsConsecutive(const MemLoc &mem1, const MemLoc &mem2, bool mustSameType);
+  static bool IsConsecutive(const IvarMeExpr &ivar1, const IvarMeExpr &ivar2, bool mustSameType);
+  static bool MustHaveNoOverlap(const MemLoc &mem1, const MemLoc &mem2);
+
+  // Get or create MemLoc object from ivar
+  // We can support more overloaded GetMemLoc if needed
+  MemLoc *GetMemLoc(IvarMeExpr &ivar);
+  MemLoc *GetMemLoc(VarMeExpr &var);
+  MemLoc *GetMemLoc(MeExpr &meExpr);  // Only support ivar and var
+
+  bool IsAllIvarConsecutive(const std::vector<MeExpr*> &ivarVec, bool mustSameType);
+
+ private:
+  void ExtractAddendOffset(const MeExpr &expr, bool isNeg, MemLoc &memLoc);
+  // Each MemBasePtr object must be unique, just like MIRType object.
+  // Because we may use the address of MemBasePtr objects as the key of map containers
+  void UniqueMemLocBase(MemLoc &memLoc);
+
+  MapleAllocator alloc;  // for allocating MemLoc objects
+  std::unordered_map<MeExpr*, MemLoc*> cache;  // for accelerating GetMemLoc
+  // To unique repeated MemBasePtr objects because we use their address as key
+  std::map<int32, std::vector<MemBasePtr*>> basePtrSet; // key is sum of addends
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MESLPVectorizer, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_SLP
+
diff --git a/src/mapleall/maple_me/include/me_ssa.h b/src/mapleall/maple_me/include/me_ssa.h
new file mode 100644
index 0000000000000000000000000000000000000000..442fb7e18df34fe8652f02d0c0746264b0322e0e
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ssa.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_SSA_H
+#define MAPLE_ME_INCLUDE_ME_SSA_H
+#include "mir_module.h"
+#include "mir_nodes.h"
+#include "me_function.h"
+#include "me_cfg.h"
+#include "ssa.h"
+#include "me_dominance.h"
+#include "me_loop_analysis.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+// if local ssa has been built, only addr-taken ost will be processed in this phase;
+// Otherwise, both top-level and addr-taken ost will be handled.
+class MeSSA : public SSA, public AnalysisResult {
+ public:
+  MeSSA(MeFunction &func, SSATab *stab, Dominance &dom, MemPool &memPool, bool enabledDebug = false)
+      : SSA(*stab, func.GetCfg()->GetAllBBs(), &dom, func.IsTopLevelSSAValid() ? kSSAAddrTaken : kSSAMemory),
+        AnalysisResult(&memPool),
+        func(&func), eDebug(enabledDebug) {}
+
+  ~MeSSA() = default;
+
+  void VerifySSA() const;
+  void InsertIdentifyAssignments(IdentifyLoops *identloops);
+
+ private:
+  void VerifySSAOpnd(const BaseNode &node) const;
+  MeFunction *func;
+  bool eDebug = false;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MESSA, MeFunction)
+  MeSSA *GetResult() {
+    return ssa;
+  }
+  MeSSA *ssa = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_FUNC_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_SSA_H
diff --git a/src/mapleall/maple_me/include/me_ssa_devirtual.h b/src/mapleall/maple_me/include/me_ssa_devirtual.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5407e7d5c1eeee7afab52ae438c9753a11b5303
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ssa_devirtual.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MESSADEVIRTUAL_H
+#define MAPLE_ME_INCLUDE_MESSADEVIRTUAL_H
+
+#include "ssa_devirtual.h"
+#include "clone.h"
+
+namespace maple {
+class MeSSADevirtual : public SSADevirtual {
+ public:
+  MeSSADevirtual(MemPool &memPool, MIRModule &mod, MeFunction &func, IRMap &irMap, KlassHierarchy &kh, Dominance &dom,
+                 bool skipReturnTypeOpt)
+      : SSADevirtual(memPool, mod, irMap, kh, dom, func.GetCfg()->GetAllBBs().size(), skipReturnTypeOpt),
+        func(&func) {}
+  MeSSADevirtual(MemPool &memPool, MIRModule &mod, MeFunction &func, IRMap &irMap, KlassHierarchy &kh, Dominance &dom,
+                 Clone &clone, bool skipReturnTypeOpt)
+      : SSADevirtual(memPool, mod, irMap, kh, dom, func.GetCfg()->GetAllBBs().size(), clone, skipReturnTypeOpt),
+        func(&func) {}
+
+  ~MeSSADevirtual() = default;
+
+ protected:
+  BB *GetBB(BBId id) const override {
+    return func->GetCfg()->GetAllBBs().at(id);
+  }
+
+  MIRFunction *GetMIRFunction() const override {
+    return func->GetMirFunc();
+  }
+
+ private:
+  MeFunction *func;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MESSADevirtual, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MESSADEVIRTUAL_H
diff --git a/src/mapleall/maple_me/include/me_ssa_epre.h b/src/mapleall/maple_me/include/me_ssa_epre.h
new file mode 100644
index 0000000000000000000000000000000000000000..04f5dab2c86e7a82b4750e894637cb27858995e4
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ssa_epre.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MESSAEPRE_H
+#define MAPLE_ME_INCLUDE_MESSAEPRE_H
+
+#include "me_function.h"
+#include "me_irmap.h"
+#include "me_cfg.h"
+#include "ssa_epre.h"
+#include "class_hierarchy_phase.h"
+#include "me_ssa_update.h"
+
+namespace maple {
+class MeSSAEPre : public SSAEPre {
+ public:
+  // a symbol is a candidate for ssaupdate if its ostidx key exists in the map;
+  // the mapped set gives bbs where dassign's are inserted by ssa_epre for the symbol
+  explicit MeSSAEPre(MeFunction &func, IRMap &map, Dominance &dom, Dominance &pdom, KlassHierarchy *kh,
+                     MemPool &memPool, MemPool &mp2, uint32 limit, bool includeRef, bool epreLocalRefVar, bool lhsIvar)
+      : SSAEPre(map, dom, pdom, memPool, mp2, kExprPre, limit, includeRef, lhsIvar),
+        candsForSSAUpdate(std::less<OStIdx>()),
+        func(&func),
+        epreLocalRefVar(epreLocalRefVar),
+        klassHierarchy(kh) {}
+
+  virtual ~MeSSAEPre() = default;
+  bool ScreenPhiBB(BBId) const override {
+    return true;
+  }
+
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &GetCandsForSSAUpdate() {
+    return candsForSSAUpdate;
+  }
+
+ protected:
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> candsForSSAUpdate;
+  MeFunction *func;
+  bool epreLocalRefVar;
+  KlassHierarchy *klassHierarchy;
+
+ private:
+  void BuildWorkList() override;
+  bool IsThreadObjField(const IvarMeExpr &expr) const override;
+  BB *GetBB(BBId id) const override {
+    return func->GetCfg()->GetBBFromID(id);
+  }
+
+  PUIdx GetPUIdx() const override {
+    return func->GetMirFunc()->GetPuidx();
+  }
+
+  bool CfgHasDoWhile() const override {
+    return func->GetCfg()->GetHasDoWhile();
+  }
+
+  bool EpreLocalRefVar() const override {
+    return epreLocalRefVar;
+  }
+
+  void EnterCandsForSSAUpdate(OStIdx ostIdx, const BB &bb) override {
+    MeSSAUpdate::InsertOstToSSACands(ostIdx, bb, &candsForSSAUpdate);
+  }
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MESSAEPre, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MESSAEPRE_H
diff --git a/src/mapleall/maple_me/include/me_ssa_lpre.h b/src/mapleall/maple_me/include/me_ssa_lpre.h
new file mode 100644
index 0000000000000000000000000000000000000000..3228d5a586b6708df606448d739b2ab9c4362d07
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ssa_lpre.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_SSA_LPRE_H
+#define MAPLE_ME_INCLUDE_ME_SSA_LPRE_H
+#include "ssa_pre.h"
+#include "me_irmap.h"
+#include "me_loop_analysis.h"
+#include "me_ssa_update.h"
+
+namespace maple {
+constexpr size_t kDoLpreBBsLimit = 0x7fffff;
+class MeSSALPre : public SSAPre {
+ public:
+  MeSSALPre(MeFunction &f, MeIRMap &hMap, Dominance &dom, Dominance &pdom, MemPool &memPool, MemPool &mp2, PreKind kind,
+            uint32 limit)
+      : SSAPre(hMap, dom, pdom, memPool, mp2, kind, limit),
+        irMap(&hMap),
+        func(&f),
+        assignedFormals(ssaPreAllocator.Adapter()),
+        loopHeadBBs(ssaPreAllocator.Adapter()),
+        candsForSSAUpdate() {}
+
+  virtual ~MeSSALPre() = default;
+  void FindLoopHeadBBs(const IdentifyLoops &identLoops);
+
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &GetCandsForSSAUpdate() {
+    return candsForSSAUpdate;
+  }
+
+  void EnterCandsForSSAUpdate(OStIdx ostIdx, const BB &bb) override {
+    MeSSAUpdate::InsertOstToSSACands(ostIdx, bb, &candsForSSAUpdate);
+  }
+ private:
+  void GenerateSaveRealOcc(MeRealOcc&) override;
+  MeExpr *GetTruncExpr(const VarMeExpr &theLHS, MeExpr &savedRHS);
+  void GenerateReloadRealOcc(MeRealOcc&) override;
+  MeExpr *PhiOpndFromRes(MeRealOcc&, size_t) const override;
+  void ComputeVarAndDfPhis() override;
+  bool ScreenPhiBB(BBId) const override {
+    return true;
+  }
+
+  void CollectVarForMeExpr(MeExpr &meExpr, std::vector<MeExpr*> &varVec) const override {
+    if (meExpr.GetMeOp() == kMeOpAddrof ||
+        meExpr.GetMeOp() == kMeOpAddroffunc ||
+        meExpr.GetMeOp() == kMeOpConst) {
+      return;
+    }
+    varVec.push_back(&meExpr);
+  }
+
+  void CollectVarForCand(MeRealOcc &realOcc, std::vector<MeExpr*> &varVec) const override {
+    if (realOcc.GetMeExpr()->GetMeOp() == kMeOpAddrof ||
+        realOcc.GetMeExpr()->GetMeOp() == kMeOpAddroffunc ||
+        realOcc.GetMeExpr()->GetMeOp() == kMeOpConst) {
+      return;
+    }
+    varVec.push_back(realOcc.GetMeExpr());
+  }
+
+  void BuildEntryLHSOcc4Formals() const override;
+  void BuildWorkListLHSOcc(MeStmt &meStmt, int32 seqStmt) override;
+  void CreateMembarOccAtCatch(BB &bb) override;
+  void BuildWorkListExpr(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool isRebuild, MeExpr *tmpVar,
+                         bool isRootExpr, bool insertSorted) override;
+  void BuildWorkList() override;
+  BB *GetBB(BBId id) const override {
+    return func->GetCfg()->GetBBFromID(id);
+  }
+
+  PUIdx GetPUIdx() const override {
+    return func->GetMirFunc()->GetPuidx();
+  }
+
+  bool IsLoopHeadBB(BBId bbId) const override {
+    return loopHeadBBs.find(bbId) != loopHeadBBs.end();
+  }
+
+  MeIRMap *irMap;
+  MeFunction *func;
+  MapleSet<OStIdx> assignedFormals;  // set of formals that are assigned
+  MapleSet<BBId> loopHeadBBs;
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> candsForSSAUpdate;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MESSALPre, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_SSA_LPRE_H
diff --git a/src/mapleall/maple_me/include/me_ssa_prop.h b/src/mapleall/maple_me/include/me_ssa_prop.h
new file mode 100644
index 0000000000000000000000000000000000000000..3bd37a36a563db1d7abcb0235568060ecfc94fdb
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ssa_prop.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_PROP_LOCAL_H
+#define MAPLE_ME_INCLUDE_ME_PROP_LOCAL_H
+#include "maple_phase_manager.h"
+#include "me_toplevel_ssa.h"
+namespace maple {
+class SSAProp {
+ public:
+  SSAProp(MeFunction *f, Dominance *d);
+  ~SSAProp() = default;
+  void TraverseStmt(StmtNode *stmt, BB *currBB);
+  void TraversalBB(BB &bb);
+  void PropInFunc();
+
+ private:
+  void UpdateDef(VersionSt *vst);
+  void UpdateDefOfMayDef(const StmtNode &stmt);
+  BaseNode *CheckTruncation(BaseNode *lhs, BaseNode *rhs) const;
+  bool CanOstProped(OriginalSt *ost) const;
+  bool Propagatable(BaseNode *rhs) const;
+  BaseNode *PropPhi(PhiNode *phi);
+  BaseNode *PropVst(VersionSt *vst, bool checkPhi);
+  BaseNode *PropExpr(BaseNode *expr, bool &subProp);
+
+  BaseNode *SimplifyIreadAddrof(IreadSSANode *ireadSSA) const;
+  BaseNode *SimplifyExpr(BaseNode *expr) const;
+  StmtNode *SimplifyIassignAddrof(IassignNode *iassign, BB *bb) const;
+  StmtNode *SimplifyStmt(StmtNode *stmt, BB *bb) const;
+  MeFunction *func = nullptr;
+  Dominance *dom = nullptr;
+  SSATab *ssaTab = nullptr;
+  std::vector<std::stack<VersionSt*>> vstLiveStack;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MESSAProp, MeFunction)
+} // namespace maple
+#endif // MAPLE_ME_INCLUDE_ME_PROP_LOCAL_H
diff --git a/src/mapleall/maple_me/include/me_ssa_tab.h b/src/mapleall/maple_me/include/me_ssa_tab.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e5fac89cff0ace5988f11904a168e5c33a1e594
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ssa_tab.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_SSA_TAB_H
+#define MAPLE_ME_INCLUDE_ME_SSA_TAB_H
+#include "me_function.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MESSATab, MeFunction)
+  SSATab *GetResult() {
+    return ssaTab;
+  }
+  SSATab *ssaTab = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_MODULE_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_SSA_TAB_H
diff --git a/src/mapleall/maple_me/include/me_ssa_update.h b/src/mapleall/maple_me/include/me_ssa_update.h
new file mode 100644
index 0000000000000000000000000000000000000000..b46fdc54b337515e8774d42bc7997b9119d4fe2a
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ssa_update.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_SSA_UPDATE_H
+#define MAPLE_ME_INCLUDE_ME_SSA_UPDATE_H
+#include "me_function.h"
+#include "me_dominance.h"
+#include "me_irmap.h"
+
+namespace maple {
+// When the number of osts is greater than kOstLimitSize, use RenameWithVectorStack object to update ssa, otherwise,
+// use RenameWithMapStack object to update ssa
+constexpr size_t kOstLimitSize = 5000;
+
+class VersionStacks {
+ public:
+  VersionStacks() = default;
+  virtual ~VersionStacks() = default;
+
+  virtual std::stack<ScalarMeExpr*> *GetRenameStack(OStIdx idx) {
+    (void)idx;
+    ASSERT(false, "can not be here");
+    return nullptr;
+  }
+
+  virtual void InsertZeroVersion2RenameStack(SSATab &ssaTab, IRMap &irMap) {
+    (void)ssaTab;
+    (void)irMap;
+    ASSERT(false, "can not be here");
+  }
+
+  virtual void InitRenameStack(OStIdx idx) {
+    (void)idx;
+    ASSERT(false, "can not be here");
+  }
+
+  virtual void RecordCurrentStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) {
+    (void)origStackSize;
+    ASSERT(false, "can not be here");
+  }
+
+  virtual void RecoverStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) {
+    (void)origStackSize;
+    ASSERT(false, "can not be here");
+  }
+};
+
+class VectorVersionStacks : public VersionStacks {
+ public:
+  VectorVersionStacks() = default;
+  virtual ~VectorVersionStacks() = default;
+
+  std::stack<ScalarMeExpr*> *GetRenameStack(OStIdx idx) override;
+  void InsertZeroVersion2RenameStack(SSATab &ssaTab, IRMap &irMap) override;
+  void InitRenameStack(OStIdx idx) override;
+  void RecordCurrentStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) override;
+  void RecoverStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) override;
+
+  void ResizeRenameStack(size_t size) {
+    renameWithVectorStacks.resize(size);
+  }
+
+ private:
+  std::vector<std::unique_ptr<std::stack<ScalarMeExpr*>>> renameWithVectorStacks;
+};
+
+class MapVersionStacks : public VersionStacks {
+ public:
+  MapVersionStacks()
+      : renameWithMapStacks(std::less<OStIdx>()) {}
+  virtual ~MapVersionStacks() = default;
+
+  std::stack<ScalarMeExpr*> *GetRenameStack(OStIdx idx) override;
+  void InsertZeroVersion2RenameStack(SSATab &ssaTab, IRMap &irMap) override;
+  void InitRenameStack(OStIdx idx) override;
+  void RecordCurrentStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) override;
+  void RecoverStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) override;
+
+ private:
+  std::map<OStIdx, std::unique_ptr<std::stack<ScalarMeExpr*>>> renameWithMapStacks;
+};
+
+class MeSSAUpdate {
+ public:
+  MeSSAUpdate(MeFunction &f, SSATab &stab, Dominance &d,
+              std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &cands)
+      : func(f),
+        irMap(*f.GetIRMap()),
+        ssaTab(stab),
+        dom(d),
+        updateCands(cands) {}
+
+  ~MeSSAUpdate() = default;
+
+  void Run();
+  // tool function - insert ost defined in defBB to ssaCands, if ssaCands is nullptr, do not insert.
+  static void InsertOstToSSACands(OStIdx ostIdx, const BB &defBB,
+                                  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *ssaCands = nullptr);
+  // tool function - insert ost defined in defBB to ssaCands after traverse philist and all statements.
+  static void InsertDefPointsOfBBToSSACands(BB &defBB, std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &ssaCands,
+      const OStIdx updateSSAExceptTheOstIdx = OStIdx(0));
+
+ private:
+  void InsertPhis();
+  void RenamePhi(const BB &bb);
+  MeExpr *RenameExpr(MeExpr &meExpr, bool &changed);
+  void RenameStmts(BB &bb);
+  void RenamePhiOpndsInSucc(const BB &bb);
+  void RenameBB(BB &bb);
+  MeFunction &func;
+  IRMap &irMap;
+  SSATab &ssaTab;
+  Dominance &dom;
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &updateCands;
+  VersionStacks *rename = nullptr;
+};
+
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_SSA_UPDATE_H
diff --git a/src/mapleall/maple_me/include/me_ssi.h b/src/mapleall/maple_me/include/me_ssi.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa83b62ade45cd35704bf1a7a9986b40952ecec2
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ssi.h
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MESSI_H
+#define MAPLE_ME_INCLUDE_MESSI_H
+#include "me_function.h"
+#include "me_irmap.h"
+#include "me_ir.h"
+#include "dominance.h"
+
+namespace maple {
+struct StmtComparator {
+  bool operator()(const std::pair<MeStmt*, size_t> &lhs, const std::pair<MeStmt*, size_t> &rhs) const {
+    if (lhs.first != rhs.first) {
+      return lhs.first < rhs.first;
+    } else {
+      return lhs.second < rhs.second;
+    }
+  }
+};
+
+class DefPoint {
+ public:
+  enum DefineKind {
+    kDefByPi,
+    kDefByPhi
+  };
+
+  explicit DefPoint(DefineKind dk) : defKind(dk) {}
+  ~DefPoint() = default;
+
+  void SetDefPi(PiassignMeStmt &s) {
+    CHECK_FATAL(defKind == kDefByPi, "must be");
+    value.pi = &s;
+  }
+
+  PiassignMeStmt *GetPiStmt() {
+    CHECK_FATAL(defKind == kDefByPi, "must be");
+    return value.pi;
+  }
+
+  const PiassignMeStmt *GetPiStmt() const {
+    CHECK_FATAL(defKind == kDefByPi, "must be");
+    return value.pi;
+  }
+
+  void SetDefPhi(MePhiNode &s) {
+    CHECK_FATAL(defKind == kDefByPhi, "must be");
+    value.phi = &s;
+  }
+
+  BB *GetBB() const {
+    if (defKind == kDefByPi) {
+      return value.pi->GetBB();
+    } else {
+      return value.phi->GetDefBB();
+    }
+  }
+
+  BB *GetGeneratedByBB() const {
+    CHECK_FATAL(defKind == kDefByPi, "must be");
+    return value.pi->GetGeneratedBy()->GetBB();
+  }
+
+  VarMeExpr *GetRHS() const {
+    if (defKind == kDefByPi) {
+      return value.pi->GetRHS();
+    } else {
+      return static_cast<VarMeExpr*>(value.phi->GetOpnd(0));
+    }
+  }
+
+  VarMeExpr *GetLHS() const {
+    if (defKind == kDefByPi) {
+      return value.pi->GetLHS();
+    } else {
+      return  static_cast<VarMeExpr*>(value.phi->GetLHS());
+    }
+  }
+
+  const OStIdx GetOStIdx() const {
+    if (defKind == kDefByPi) {
+      return value.pi->GetRHS()->GetOstIdx();
+    } else {
+      return value.phi->GetOpnd(0)->GetOstIdx();
+    }
+  }
+
+  bool IsPiStmt() const {
+    return defKind == kDefByPi;
+  }
+
+  bool IsGeneratedByBr() const {
+    CHECK_FATAL(defKind == kDefByPi, "must be");
+    MeStmt *stmt = value.pi->GetGeneratedBy();
+    if (stmt->GetOp() == OP_brtrue || stmt->GetOp() == OP_brfalse) {
+      return true;
+    }
+    return false;
+  }
+
+  void RemoveFromBB() {
+    if (defKind == kDefByPi) {
+      if (IsGeneratedByBr()) {
+        GetBB()->GetPiList().clear();
+      } else {
+        GetBB()->RemoveMeStmt(value.pi);
+      }
+    } else {
+      GetBB()->GetMePhiList().erase(GetOStIdx());
+    }
+  }
+
+  void Dump(const IRMap &irMap) {
+    LogInfo::MapleLogger() << "New Def : " << '\n';
+    if (defKind == kDefByPi) {
+      value.pi->Dump(&irMap);
+    } else {
+      value.phi->Dump(&irMap);
+    }
+    LogInfo::MapleLogger() << '\n';
+  }
+
+ private:
+  DefineKind defKind;
+  union DefStmt {
+    PiassignMeStmt *pi;
+    MePhiNode *phi;
+  };
+  DefStmt value;
+};
+
+enum SSIOptType : uint8_t {
+  kNullPointerCheckOpt = 0x1,
+  kCheckCastOpt = 0x2,
+  kCondBaseRCOpt = 0x4,
+  kArrayBoundsCheckOpt = 0x8,
+  kCondBasePropOpt = 0x10,
+  kBranchResolve = 0x20,
+};
+
+class SSIType {
+ public:
+  SSIType() = default;
+  ~SSIType() = default;
+
+  void SetOptType(uint8_t t) {
+    optType = t;
+  }
+
+  uint8_t GetOptType() const {
+    return optType;
+  }
+
+  bool GetOptKindType(SSIOptType x) const {
+    return (optType & static_cast<uint32>(x)) != 0;
+  }
+
+  void DumpOptType() const;
+
+ private:
+  uint8_t optType = 0;
+};
+
+class MeSSI {
+ public:
+  static bool isDebug;
+  MeSSI(const MeFunction &meFunction, Dominance &dom, MeIRMap &map, MemPool &pool,
+        std::map<MeStmt*, NaryMeExpr*>* acs = nullptr,
+        std::map<BB*, std::vector<MeStmt*>>* cBB = nullptr)
+      : cfg(meFunction.GetCfg()),
+        dom(&dom),
+        irMap(&map),
+        memPool(&pool),
+        allocator(&pool),
+        arrayChecks(acs),
+        containsBB(cBB) {}
+  ~MeSSI() = default;
+  void ConvertToSSI();
+  void ConvertToSSA();
+  void SetSSIType(uint8_t opt) {
+    ssiType.SetOptType(opt);
+  }
+  MIRType *GetInferredType(MeExpr *expr);
+ private:
+  NaryMeExpr *GetInstanceOfType(MeExpr &e);
+  void AddPiForABCOpt(BB &bb);
+  void AddNullPointerInfoForVar() const;
+  uint8_t AnalysisBranch(MeStmt &meStmt);
+  void RemoveExtraNodes();
+  void InsertPiNodes();
+  bool ExistedPhiNode(BB &bb, const VarMeExpr &rhs);
+  void InsertPhiNodes();
+  void Rename();
+  void RenameStartPiBr(DefPoint &newDefPoint);
+  void RenameStartPiArray(DefPoint &newDefPoint);
+  void RenameStartPhi(DefPoint &newDefPoint);
+  void ReplacePiPhiInSuccs(BB &bb, VarMeExpr &newVar);
+  bool ReplaceStmt(MeStmt &meStmt, VarMeExpr &newVar, VarMeExpr &oldVar);
+  void ReplaceBB(BB &bb, BB &parentBB, DefPoint &newDefPoint);
+  bool ExistedPiNode(BB &bb, BB &parentBB, const VarMeExpr &rhs);
+  void CreatePhi(VarMeExpr &rhs, BB &dfBB);
+  VarMeExpr *CreateNewPiExpr(const MeExpr &opnd);
+  void CreateNewPiStmt(VarMeExpr *lhs, MeExpr &rhs, BB &bb, MeStmt &generatedBy, bool isToken);
+  void CreateNewPiStmt(VarMeExpr *lhs, MeExpr &rhs, MeStmt &generatedBy);
+  MeExpr *ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &oldVar, MeExpr &repExpr);
+  MeExpr *NewMeExpr(MeExpr &meExpr);
+  bool ReplaceMeExprStmtOpnd(uint32 opndID, MeStmt &meStmt, MeExpr &oldVar, MeExpr &newVar, bool update);
+  bool ReplaceStmtWithNewVar(MeStmt &meStmt, MeExpr &oldVar, MeExpr &newVar, bool update);
+
+  Dominance *GetDominace() {
+    return dom;
+  }
+
+  MemPool *GetMemPool() {
+    return memPool;
+  }
+
+  MapleAllocator &GetAllocator() {
+    return allocator;
+  }
+
+  const MeIRMap *GetIRMap() const {
+    return irMap;
+  }
+
+  MeCFG      *cfg;
+  Dominance *dom;
+  MeIRMap *irMap;
+  MemPool *memPool;
+  MapleAllocator allocator;
+  SSIType ssiType{};
+  std::vector<DefPoint*> newDefPoints;
+  std::map<DefPoint*, VarMeExpr*> newDef2Old;
+  std::map<std::pair<MeStmt*, size_t>, MeExpr*, StmtComparator> modifiedStmt;
+  std::map<MePhiNode*, std::vector<ScalarMeExpr*>> modifiedPhi;
+  std::set<BB*> visitedBBs;
+  // used for ABC opt
+  std::map<MeStmt*, NaryMeExpr*>* arrayChecks;
+  std::map<BB*, std::vector<MeStmt*>>* containsBB;
+  // used for check cast opt
+  std::map<MeExpr*, MIRType*> inferredType;
+};
+}
+#endif
diff --git a/src/mapleall/maple_me/include/me_ssu_pre.h b/src/mapleall/maple_me/include/me_ssu_pre.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ffdcaf4711b7cbe7cbdde9484e6fedf62e85b5d
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_ssu_pre.h
@@ -0,0 +1,437 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MESSUPRE_H
+#define MAPLE_ME_INCLUDE_MESSUPRE_H
+#include "me_function.h"
+#include "me_irmap.h"
+#include "me_dominance.h"
+
+namespace maple {
+enum SOccType {
+  kSOccUndef,
+  kSOccReal,
+  kSOccLambda,
+  kSOccLambdaRes,
+  kSOccEntry,
+  kSOccUse,
+  kSOccPhi
+};
+
+class SOcc {
+ public:
+  SOcc(SOccType ty, BB &bb) : occTy(ty), classId(0), mirBB(bb), use(nullptr) {}
+
+  virtual ~SOcc() = default;
+
+  virtual void Dump() const = 0;
+  bool IsPostDominate(Dominance *pdom, const SOcc *occ) const {
+    CHECK_NULL_FATAL(occ);
+    CHECK_NULL_FATAL(pdom);
+    return pdom->Dominate(mirBB, occ->mirBB);
+  }
+
+  SOccType GetOccTy() const {
+    return occTy;
+  }
+
+  void SetOccTy(SOccType type) {
+    this->occTy = type;
+  }
+
+  uint32 GetClassId() const {
+    return classId;
+  }
+
+  void SetClassId(uint32 id) {
+    this->classId = id;
+  }
+
+  BB &GetBB() {
+    return mirBB;
+  }
+
+  const BB &GetBB() const {
+    return mirBB;
+  }
+
+  SOcc *GetUse() const {
+    return use;
+  }
+
+  void SetUse(SOcc &currUse) {
+    this->use = &currUse;
+  }
+
+ private:
+  SOccType occTy;
+  uint32 classId;
+  BB &mirBB;  // the BB it occurs in
+  SOcc *use;  // points to its single use
+};
+
+class SRealOcc : public SOcc {
+ public:
+  explicit SRealOcc(BB &bb)
+      : SOcc(kSOccReal, bb), meStmt(nullptr), vMeExpr(nullptr), realFromDef(false), redundant(true) {}
+  explicit SRealOcc(MeStmt &s)
+      : SOcc(kSOccReal, *s.GetBB()), meStmt(&s), vMeExpr(nullptr), realFromDef(false), redundant(true) {}
+  SRealOcc(MeStmt &s, VarMeExpr &v)
+      : SOcc(kSOccReal, *s.GetBB()), meStmt(&s), vMeExpr(&v), realFromDef(false), redundant(true) {}
+  SRealOcc(BB &bb, VarMeExpr &v)
+      : SOcc(kSOccReal, bb), meStmt(nullptr), vMeExpr(&v), realFromDef(false), redundant(true) {}
+  virtual ~SRealOcc() = default;
+  void Dump() const override {
+    LogInfo::MapleLogger() << "RealOcc at bb" << GetBB().GetBBId();
+    if (realFromDef) {
+      LogInfo::MapleLogger() << "(from-def)";
+    }
+    LogInfo::MapleLogger() << " classId" << GetClassId();
+  }
+
+  MeStmt *GetStmt() const {
+    return meStmt;
+  }
+
+  VarMeExpr *GetVar() const {
+    return vMeExpr;
+  }
+
+  bool GetRealFromDef() const {
+    return realFromDef;
+  }
+
+  void SetRealFromDef(bool real) {
+    this->realFromDef = real;
+  }
+
+  bool GetRedundant() const {
+    return redundant;
+  }
+
+  void SetRedundant(bool isRedundant) {
+    this->redundant = isRedundant;
+  }
+
+ private:
+  MeStmt *meStmt;      // the stmt of this real occurrence; null for formal at entry
+  VarMeExpr *vMeExpr;  // the varmeexpr of this real occurrence
+  bool realFromDef;    // used only by placementRC
+  bool redundant;
+};
+
+class SLambdaOcc;
+
+class SLambdaResOcc : public SOcc {
+ public:
+  explicit SLambdaResOcc(BB &bb)
+      : SOcc(kSOccLambdaRes, bb), useLambdaOcc(nullptr), hasRealUse(false), insertHere(false) {}
+
+  virtual ~SLambdaResOcc() = default;
+  void Dump() const {
+    LogInfo::MapleLogger() << "LambdaResOcc at bb" << GetBB().GetBBId() << " classId" << GetClassId();
+  }
+
+  const SLambdaOcc *GetUseLambdaOcc() const {
+    return useLambdaOcc;
+  }
+
+  void SetUseLambdaOcc(SLambdaOcc &currUseLambdaOcc) {
+    this->useLambdaOcc = &currUseLambdaOcc;
+  }
+
+  bool GetHasRealUse() const {
+    return hasRealUse;
+  }
+
+  void SetHasRealUse(bool has) {
+    this->hasRealUse = has;
+  }
+
+  bool GetInsertHere() const {
+    return insertHere;
+  }
+
+  void SetInsertHere(bool currInsertHere) {
+    this->insertHere = currInsertHere;
+  }
+
+ private:
+  SLambdaOcc *useLambdaOcc;  // its rhs use
+  bool hasRealUse;
+  bool insertHere;
+};
+
+class SLambdaOcc : public SOcc {
+ public:
+  SLambdaOcc(BB &bb, MapleAllocator &alloc)
+      : SOcc(kSOccLambda, bb), isUpsafe(true), isCanBeAnt(true), isEarlier(true), lambdaRes(alloc.Adapter()) {}
+
+  virtual ~SLambdaOcc() = default;
+  bool WillBeAnt() const {
+    return isCanBeAnt && !isEarlier;
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << "LambdaOcc at bb" << GetBB().GetBBId() << " classId" << GetClassId() << " Lambda[";
+    for (size_t i = 0; i < lambdaRes.size(); i++) {
+      lambdaRes[i]->Dump();
+      if (i != lambdaRes.size() - 1) {
+        LogInfo::MapleLogger() << ", ";
+      }
+    }
+    LogInfo::MapleLogger() << "]";
+  }
+
+  bool GetIsUpsafe() const {
+    return isUpsafe;
+  }
+
+  void SetIsUpsafe(bool upsafe) {
+    this->isUpsafe = upsafe;
+  }
+
+  bool GetIsCanBeAnt() const {
+    return isCanBeAnt;
+  }
+
+  void SetIsCanBeAnt(bool canBeAnt) {
+    this->isCanBeAnt = canBeAnt;
+  }
+
+  bool GetIsEarlier() const {
+    return isEarlier;
+  }
+
+  void SetIsEarlier(bool earlier) {
+    this->isEarlier = earlier;
+  }
+
+  MapleVector<SLambdaResOcc*> &GetLambdaRes() {
+    return lambdaRes;
+  }
+
+ private:
+  bool isUpsafe;
+  bool isCanBeAnt;
+  bool isEarlier;
+  MapleVector<SLambdaResOcc*> lambdaRes;
+};
+
+class SEntryOcc : public SOcc {
+ public:
+  explicit SEntryOcc(BB &bb) : SOcc(kSOccEntry, bb) {}
+
+  virtual ~SEntryOcc() = default;
+  void Dump() const {
+    LogInfo::MapleLogger() << "EntryOcc at bb" << GetBB().GetBBId();
+  }
+};
+
+class SUseOcc : public SOcc {
+ public:
+  explicit SUseOcc(BB &bb) : SOcc(kSOccUse, bb) {}
+
+  virtual ~SUseOcc() = default;
+  void Dump() const {
+    LogInfo::MapleLogger() << "UseOcc at bb" << GetBB().GetBBId();
+  }
+};
+
+class SPhiOcc : public SOcc {
+ public:
+  SPhiOcc(BB &bb, MePhiNode &p, VarMeExpr &v) : SOcc(kSOccPhi, bb), phi(&p), vMeExpr(&v) {};
+
+  virtual ~SPhiOcc() = default;
+
+  MePhiNode *GetPhiNode() {
+    return phi;
+  }
+
+  const MePhiNode *GetPhiNode() const {
+    return phi;
+  }
+
+  VarMeExpr *GetVar() {
+    return vMeExpr;
+  }
+
+  const VarMeExpr *GetVar() const {
+    return vMeExpr;
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << "PhiOcc at bb" << GetBB().GetBBId();
+  }
+
+ private:
+  MePhiNode *phi;      // the phinode of this real occurrence;
+  VarMeExpr *vMeExpr;  // the varmeexpr of this real occurrence
+};
+
+class SpreWorkCand {
+ public:
+  SpreWorkCand(MapleAllocator &alloc, OriginalSt &ost)
+      : next(nullptr),
+        theOst(&ost),
+        theVar(nullptr),
+        realOccs(alloc.Adapter()),
+        hasStoreOcc(false),
+        hasCriticalEdge(false) {}
+
+  ~SpreWorkCand() = default;
+
+  const SpreWorkCand *GetNext() const {
+    return next;
+  }
+
+  OriginalSt *GetOst() const {
+    return theOst;
+  }
+
+  const VarMeExpr *GetTheVar() const {
+    return theVar;
+  }
+
+  void SetTheVar(VarMeExpr &var) {
+    this->theVar = &var;
+  }
+
+  MapleVector<SOcc*> &GetRealOccs() {
+    return realOccs;
+  }
+
+  bool GetHasStoreOcc() const {
+    return hasStoreOcc;
+  }
+
+  void SetHasStoreOcc(bool has) {
+    this->hasStoreOcc = has;
+  }
+
+  bool GetHasCriticalEdge() const {
+    return hasCriticalEdge;
+  }
+
+  void SetHasCriticalEdge(bool criticalEdge) {
+    this->hasCriticalEdge = criticalEdge;
+  }
+
+ private:
+  SpreWorkCand *next;
+  OriginalSt *theOst;           // the stored symbol of this workcand
+  VarMeExpr *theVar;            // any existing node of the lhs var
+  MapleVector<SOcc*> realOccs;  // maintained in order of pdt_preorder
+  bool hasStoreOcc;             // true if there is any store occurrence
+  bool hasCriticalEdge;         // determined by Finalize step
+};
+
+class MeSSUPre {
+ public:
+  enum PreKind {
+    kStorePre,
+    kDecrefPre,
+    kSecondDecrefPre,
+    kSubsumePre
+  } preKind;
+
+  MeSSUPre(MeFunction &f, Dominance &dom, Dominance &pdom, MemPool &memPool, PreKind kind, bool enabledDebug)
+      : preKind(kind),
+        func(&f),
+        cfg(f.GetCfg()),
+        ssaTab(f.GetMeSSATab()),
+        irMap(f.GetIRMap()),
+        mirModule(&f.GetMeSSATab()->GetModule()),
+        dom(&dom),
+        pdom(&pdom),
+        spreMp(&memPool),
+        spreAllocator(&memPool),
+        workCandMap(std::less<OStIdx>(), spreAllocator.Adapter()),
+        workCand(nullptr),
+        lambdaDfns(std::less<uint32>(), spreAllocator.Adapter()),
+        classCount(0),
+        allOccs(spreAllocator.Adapter()),
+        lambdaOccs(spreAllocator.Adapter()),
+        entryOccs(spreAllocator.Adapter()),
+        catchBlocks2Insert(spreAllocator.Adapter()),
+        enabledDebug(enabledDebug) {}
+
+  virtual ~MeSSUPre() = default;
+
+  void ApplySSUPre();
+
+ protected:
+  // step 6 methods
+  virtual void CodeMotion() = 0;
+  // step 5 methods
+  void Finalize();
+  // step 4 methods
+  void ResetCanBeAnt(SLambdaOcc &lambda) const;
+  void ComputeCanBeAnt() const;
+  void ResetEarlier(SLambdaOcc &lambda) const;
+  void ComputeEarlier() const;
+  void ResetCanBeFullyAnt(SLambdaOcc &lambda) const;
+  void ComputeCanBeFullyAnt() const;
+  // step 3 methods
+  void ResetUpsafe(const SLambdaResOcc &lambdaRes) const;
+  void ComputeUpsafe() const;
+  // step 2 methods
+  void Rename();
+  // step 1 methods
+  void GetIterPdomFrontier(const BB *bb, MapleSet<uint32> *pdfset) const {
+    for (auto bbid : pdom->GetIterDomFrontier(bb->GetID())) {
+      (void)pdfset->insert(pdom->GetDtDfnItem(bbid));
+    }
+  }
+
+  void FormLambdas();
+  void FormLambdaRes();
+  void CreateSortedOccs();
+  // step 0 methods
+  void CreateEntryOcc(BB &bb) {
+    SEntryOcc *entryOcc = spreMp->New<SEntryOcc>(bb);
+    entryOccs.push_back(entryOcc);
+  }
+
+  virtual void BuildWorkListBB(BB *bb) = 0;
+  virtual void PerCandInit() = 0;
+  virtual void CreateEmptyCleanupIntrinsics() {}
+
+  MeFunction *func;
+  MeCFG      *cfg;
+  SSATab *ssaTab;
+  MeIRMap *irMap;
+  MIRModule *mirModule;
+  Dominance *dom;
+  Dominance *pdom;
+  MemPool *spreMp;
+  MapleAllocator spreAllocator;
+  MapleMap<OStIdx, SpreWorkCand*> workCandMap;
+  SpreWorkCand *workCand;  // current SpreWorkCand
+  // step 1 lambda insertion data structures:
+  // following are set of BBs in terms of their dfn's; index into
+  // dominance->pdt_preorder to get their bbid's
+  MapleSet<uint32> lambdaDfns;  // set by FormLambdas()
+  // step 2 renaming
+  uint32 classCount;  // for assigning new class id
+  // the following 3 lists are all maintained in order of pdt_preorder
+  MapleVector<SOcc*> allOccs;           // cleared at start of each workcand
+  MapleVector<SLambdaOcc*> lambdaOccs;  // cleared at start of each workcand
+  MapleVector<SEntryOcc*> entryOccs;    // this is shared by all workcands
+  // used in steps 5 and 6
+  MapleSet<BBId> catchBlocks2Insert;  // need insertions at entries to these catch blocks
+  bool enabledDebug;
+};
+};  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MESSUPRE_H
diff --git a/src/mapleall/maple_me/include/me_stack_protect.h b/src/mapleall/maple_me/include/me_stack_protect.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6b94635f3391fb29233d330aa5d7aacf9075511
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_stack_protect.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_MESTACKPROTECT_H
+#define MAPLE_ME_INCLUDE_MESTACKPROTECT_H
+
+#include "me_function.h"
+
+namespace maple {
+bool FuncMayWriteStack(MeFunction &func);
+
+class MeStackProtect {
+ public:
+  explicit MeStackProtect(MeFunction &func) : f(&func) {}
+  ~MeStackProtect() = default;
+  void CheckAddrofStack();
+  bool MayWriteStack();
+
+ private:
+  bool IsMeStmtSafe(const MeStmt &stmt) const;
+  bool IsCallSafe(const MeStmt &stmt, bool isIcall, const FuncDesc *funcDesc = nullptr) const;
+  bool IsIntrnCallSafe(const MeStmt &stmt) const;
+  bool IsStackSymbol(const OriginalSt &ost) const;
+  bool IsAddressOfStackVar(const MeExpr &expr) const;
+  bool IsWriteFromSourceSafe(const MeStmt &stmt, uint64 numOfBytesToWrite) const;
+  bool IsValidWrite(const OriginalSt &targetOst, uint64 numByteToWrite, uint64 extraOffset) const;
+  bool IsDefInvolveAddressOfStackVar(const ScalarMeExpr &expr, std::set<int32> &visitedDefs) const;
+  bool IsPointToAddressOfStackVar(const MeExpr &expr, std::set<int32> &visitedDefs) const;
+  bool RecordExpr(std::set<int32> &visitedDefs, const ScalarMeExpr& expr) const;
+  bool IsMeOpExprPointedToAddressOfStackVar(const MeExpr &expr, std::set<int32> &visitedDefs) const;
+  const FuncDesc* GetFuncDesc(const MeStmt &stmt) const;
+  MeFunction *f;
+};
+}
+#endif
diff --git a/src/mapleall/maple_me/include/me_stmt_pre.h b/src/mapleall/maple_me/include/me_stmt_pre.h
new file mode 100644
index 0000000000000000000000000000000000000000..574a35d88463532264851abfd943cf998157eea7
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_stmt_pre.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MESTMTPRE_H
+#define MAPLE_ME_INCLUDE_MESTMTPRE_H
+
+#include "me_function.h"
+#include "me_irmap_build.h"
+#include "ssa_epre.h"
+
+namespace maple {
+class MeStmtPre : public SSAEPre {
+ public:
+  // a symbol is a candidate for ssaupdate if its ostidx key exists in the map;
+  // the mapped set gives bbs where dassign's are inserted by stmtpre for the symbol
+  MeStmtPre(MeFunction &func, IRMap &map, Dominance &dom, Dominance &pdom, MemPool &memPool, MemPool &mp2, uint32 limit)
+      : SSAEPre(map, dom, pdom, memPool, mp2, kStmtPre, limit, true, false),
+        candsForSSAUpdate(std::less<OStIdx>()),
+        func(&func),
+        versionStackVec(ssaTab->GetOriginalStTable().GetOriginalStVector().size(), nullptr, ssaPreAllocator.Adapter()),
+        useOccurMap(std::less<OStIdx>(), ssaPreAllocator.Adapter()) {}
+
+  virtual ~MeStmtPre() = default;
+  bool ScreenPhiBB(BBId) const override {
+    return true;
+  }
+
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &GetCandsForSSAUpdate() {
+    return candsForSSAUpdate;
+  }
+
+ protected:
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> candsForSSAUpdate;
+  MeFunction *func;
+  MapleVector<MapleStack<ScalarMeExpr*>*> versionStackVec;  // top of stack gives last version during BuildWorkList()
+  MapleMap<OStIdx, MapleSet<uint32>*> useOccurMap;  // give the set of BBs (in dfn) that contain uses of the symbol
+
+ private:
+  // code motion phase
+  void CodeMotion() override;
+  // finalize phase
+  void Finalize1() override;
+  void Finalize2() override {};
+  // fully available (replaces downsafety, canbeavail and later under SSAFRE)
+  void ResetFullyAvail(MePhiOcc &occ);
+  void ComputeFullyAvail();
+  // rename phase
+  bool AllVarsSameVersion(const MeRealOcc &realOcc1, const MeRealOcc &realOcc2) const override;
+  bool AllVarsSameVersionStmtFre(MeRealOcc &topOcc, MeRealOcc &curOcc) const;
+  void CollectVarForMeStmt(const MeStmt &meStmt, MeExpr *meExpr, std::vector<MeExpr*> &varVec) const;
+  void CollectVarForCand(MeRealOcc &realOcc, std::vector<MeExpr*> &varVec) const override;
+  MeStmt *PhiOpndFromRes4Stmt(MeRealOcc &realZ, size_t j, MeExpr *&lhsVar) const;
+  void Rename1StmtFre();
+  void Rename2() override;
+  // phi insertion phase
+  void ComputeVarAndDfPhis() override;
+  void CreateSortedOccs() override;
+  void ConstructUseOccurMapExpr(uint32 bbDfn, const MeExpr &meExpr);
+  void ConstructUseOccurMap() override;  // build useOccurMap for dassign candidates
+  PreStmtWorkCand *CreateStmtRealOcc(MeStmt &meStmt, int seqStmt);
+  void VersionStackChiListUpdate(const MapleMap<OStIdx, ChiMeNode*> &chiList);
+  void BuildWorkListBB(BB *bb) override;
+  void BuildWorkList() override;
+  void RemoveUnnecessaryAssign(MeStmt &meStmt);
+  void DoSSAFRE() override;
+  BB *GetBB(BBId id) const override {
+    return func->GetCfg()->GetBBFromID(id);
+  }
+
+  BB *GetBB(uint32 id) const {
+    return func->GetCfg()->GetBBFromID(BBId(id));
+  }
+
+  PUIdx GetPUIdx() const override {
+    return func->GetMirFunc()->GetPuidx();
+  }
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEStmtPre, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MESTMTPRE_H
diff --git a/src/mapleall/maple_me/include/me_store_pre.h b/src/mapleall/maple_me/include/me_store_pre.h
new file mode 100644
index 0000000000000000000000000000000000000000..cc66d03af5dec94db0722448bc9870dd9b85d774
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_store_pre.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MESTOREPRE_H
+#define MAPLE_ME_INCLUDE_MESTOREPRE_H
+#include "me_ssu_pre.h"
+#include "me_alias_class.h"
+#include "me_irmap_build.h"
+#include "me_ssa_update.h"
+
+namespace maple {
+class MeStorePre : public MeSSUPre {
+ public:
+  MeStorePre(MeFunction &f, Dominance &dom, Dominance &pdom, AliasClass &ac, MemPool &memPool, bool enabledDebug)
+      : MeSSUPre(f, dom, pdom, memPool, kStorePre, enabledDebug), aliasClass(&ac), curTemp(nullptr),
+        bbCurTempMap(spreAllocator.Adapter()),
+        candsForSSAUpdate() {}
+
+  virtual ~MeStorePre() = default;
+
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &CandsForSSAUpdate() {
+    return candsForSSAUpdate;
+  }
+
+ private:
+  inline bool IsJavaLang() const {
+    return mirModule->IsJavaModule();
+  }
+  // step 6 methods
+  void CheckCreateCurTemp();
+  RegMeExpr *EnsureRHSInCurTemp(BB &bb);
+  void CodeMotion() override;
+  // step 0 methods
+  void CreateRealOcc(const OStIdx &ostIdx, MeStmt &meStmt);
+  void CreateUseOcc(const OStIdx &ostIdx, BB &bb);
+  void CreateSpreUseOccsThruAliasing(const OriginalSt &muOst, BB &bb);
+  void FindAndCreateSpreUseOccs(const MeExpr &meExpr, BB &bb);
+  void CreateSpreUseOccsForAll(BB &bb) const;
+  void BuildWorkListBB(BB *bb) override;
+  void PerCandInit() override {
+    curTemp = nullptr;
+    bbCurTempMap.clear();
+  }
+
+  void AddCandsForSSAUpdate(OStIdx ostIdx, const BB &bb) {
+    MeSSAUpdate::InsertOstToSSACands(ostIdx, bb, &candsForSSAUpdate);
+  }
+
+  AliasClass *aliasClass;
+  // step 6 code motion
+  RegMeExpr *curTemp;                               // the preg for the RHS of inserted stores
+  MapleUnorderedMap<BB*, RegMeExpr*> bbCurTempMap;  // map bb to curTemp version
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> candsForSSAUpdate;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEStorePre, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MESTOREPRE_H
diff --git a/src/mapleall/maple_me/include/me_subsum_rc.h b/src/mapleall/maple_me/include/me_subsum_rc.h
new file mode 100644
index 0000000000000000000000000000000000000000..01a26e31f5b582f2597246b67a6220667373b84e
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_subsum_rc.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_SUBSUM_RC_H
+#define MAPLE_ME_INCLUDE_ME_SUBSUM_RC_H
+#include "me_ssu_pre.h"
+
+namespace maple {
+class DassignStmtPtrComparator {
+ public:
+  bool operator()(const DassignMeStmt *stmtA, const DassignMeStmt *stmtB) const {
+    ASSERT_NOT_NULL(stmtA);
+    ASSERT_NOT_NULL(stmtB);
+    ASSERT_NOT_NULL(stmtA->GetLHS());
+    ASSERT_NOT_NULL(stmtB->GetLHS());
+    return static_cast<VarMeExpr*>(stmtA->GetLHS())->GetVstIdx() <
+           static_cast<VarMeExpr*>(stmtB->GetLHS())->GetVstIdx();
+  }
+};
+
+class SubsumRC : public MeSSUPre {
+ public:
+  SubsumRC(MeFunction &f, Dominance &dom, Dominance &pdom, MemPool &mp, bool enabledDebug)
+      : MeSSUPre(f, dom, pdom, mp, kSubsumePre, enabledDebug),
+        candMap(spreAllocator.Adapter()),
+        bbVisited(f.GetCfg()->GetAllBBs().size(), false, spreAllocator.Adapter()),
+        verstCantSubsum(f.GetIRMap()->GetVerst2MeExprTable().size(), false, spreAllocator.Adapter()) {}
+
+  virtual ~SubsumRC() = default;
+  void RunSSUPre();
+
+ protected:
+  MapleMap<DassignMeStmt*, SpreWorkCand*, DassignStmtPtrComparator> candMap;
+  MapleVector<bool> bbVisited;
+  MapleVector<bool> verstCantSubsum;
+
+ private:
+  void SetCantSubsum();
+  // step 6 methods
+  void ReplaceExpr(BB &bb, const MeExpr &var, MeExpr &reg);
+  void SubsumeRC(MeStmt &stmt);
+  // step 0 methods
+  void CreateRealOcc(VarMeExpr &varX, DassignMeStmt &meStmt, MeStmt &decRef);
+  void BuildRealOccs(MeStmt &stmt, BB &bb);
+  void BuildWorkListBB(BB *bb) override;
+  void PerCandInit() override {}
+  void CodeMotion() override {}
+  bool IsRhsPostDominateLhs(const SOcc &rhsOcc, const VarMeExpr &lhs) const;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MESubsumRC, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_ME_SUBSUM_RC_H
diff --git a/src/mapleall/maple_me/include/me_toplevel_ssa.h b/src/mapleall/maple_me/include/me_toplevel_ssa.h
new file mode 100644
index 0000000000000000000000000000000000000000..021c91ebf698a5b9e4137941e3b958283be42adf
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_toplevel_ssa.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_SSA_LOCAL_H
+#define MAPLE_ME_INCLUDE_ME_SSA_LOCAL_H
+
+#include "mir_module.h"
+#include "mir_nodes.h"
+#include "me_function.h"
+#include "me_cfg.h"
+#include "ssa.h"
+#include "me_dominance.h"
+#include "me_loop_analysis.h"
+#include "maple_phase_manager.h"
+#include "vst_use_info.h"
+namespace maple {
+class MeTopLevelSSA : public SSA, public AnalysisResult {
+ public:
+  MeTopLevelSSA(MeFunction &f, SSATab *stab, Dominance &dom, MemPool &memPool)
+      : SSA(*stab, f.GetCfg()->GetAllBBs(), &dom, kSSATopLevel),
+        AnalysisResult(&memPool),
+        func(&f),
+        vstUseInfo(&memPool) {}
+
+  ~MeTopLevelSSA() = default;
+
+  void CollectUseInfo();
+  VstUseInfo *GetVstUseInfo() {
+    return &vstUseInfo;
+  }
+
+ private:
+  MeFunction *func = nullptr;
+  VstUseInfo vstUseInfo;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(METopLevelSSA, MeFunction)
+  MeTopLevelSSA *GetResult() {
+    return ssa;
+  }
+  MeTopLevelSSA *ssa = nullptr;
+ OVERRIDE_DEPENDENCE
+MAPLE_FUNC_PHASE_DECLARE_END
+} // namespace maple
+#endif // MAPLE_ME_INCLUDE_ME_SSA_LOCAL_H
diff --git a/src/mapleall/maple_me/include/me_value_range_prop.h b/src/mapleall/maple_me/include/me_value_range_prop.h
new file mode 100644
index 0000000000000000000000000000000000000000..7670599b33d9b13e939023d186800bb86681ff99
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_value_range_prop.h
@@ -0,0 +1,914 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ME_VALUE_RANGE_PROP_H
+#define MAPLE_ME_INCLUDE_ME_VALUE_RANGE_PROP_H
+
+#include "me_ir.h"
+#include "me_function.h"
+#include "me_cfg.h"
+#include "me_dominance.h"
+#include "me_loop_analysis.h"
+#include "me_scalar_analysis.h"
+namespace maple {
+constexpr size_t kFourByte = 4;
+constexpr size_t kEightByte = 8;
+constexpr uint32 kRecursionThreshold = 100;
+
+class ValueRangePropagation;
+class ValueRange;
+class SafetyCheck {
+ public:
+  SafetyCheck() = default;
+  explicit SafetyCheck(MeFunction &f) : func(&f) {}
+  virtual ~SafetyCheck() = default;
+
+  bool NeedDeleteTheAssertAfterErrorOrWarn(const MeStmt &stmt, bool isNullablePtr = false) const;
+  virtual void HandleAssignWithDeadBeef(BB &bb, MeStmt &meStmt, MeExpr &indexOpnd, MeExpr &boundOpnd) {}
+  virtual void HandleAssertNonnull(const MeStmt &meStmt, const ValueRange *valueRangeOfIndex) {}
+  virtual bool HandleAssertError(const MeStmt &meStmt) {
+    return false;
+  }
+
+  virtual bool HandleAssertltOrAssertle(const MeStmt &meStmt, Opcode op, int64 indexValue, int64 lengthValue) {
+    return false;
+  }
+
+ protected:
+  MeFunction *func = nullptr;
+};
+
+class SafetyCheckWithNonnullError : public SafetyCheck {
+ public:
+  explicit SafetyCheckWithNonnullError(MeFunction &f)
+      : SafetyCheck(f) {}
+  ~SafetyCheckWithNonnullError() override = default;
+  void HandleAssertNonnull(const MeStmt &meStmt, const ValueRange *valueRangeOfIndex) override;
+};
+
+class SafetyCheckWithBoundaryError : public SafetyCheck {
+ public:
+  SafetyCheckWithBoundaryError(MeFunction &f, ValueRangePropagation &valueRangeProp)
+      : SafetyCheck(f), vrp(valueRangeProp) {}
+  ~SafetyCheckWithBoundaryError() override = default;
+  void HandleAssignWithDeadBeef(BB &bb, MeStmt &meStmt, MeExpr &indexOpnd, MeExpr &boundOpnd) override;
+  bool HandleAssertError(const MeStmt &meStmt) override;
+  bool HandleAssertltOrAssertle(const MeStmt &meStmt, Opcode op, int64 indexValue, int64 lengthValue) override;
+
+ private:
+  ValueRangePropagation &vrp;
+};
+
+int64 GetMinNumber(PrimType pType);
+int64 GetMaxNumber(PrimType pType);
+bool IsNeededPrimType(PrimType pType);
+int64 GetRealValue(int64 value, PrimType pType);
+bool IsPrimTypeUint64(PrimType pType);
+
+class Bound {
+ public:
+  Bound() : var(nullptr), constant(0), primType(PTY_begin) {}
+  Bound(MeExpr *argVar, int64 argConstant, PrimType pType) : var(argVar), constant(argConstant), primType(pType) {}
+  Bound(MeExpr *argVar, PrimType pType) : var(argVar), constant(0), primType(pType) {}
+  Bound(int64 argConstant, PrimType pType) : var(nullptr), constant(argConstant), primType(pType) {}
+  ~Bound() = default;
+
+  const MeExpr *GetVar() const {
+    return var;
+  }
+
+  MeExpr *GetVar() {
+    return var;
+  }
+
+  void SetVar(MeExpr *expr) {
+    var = expr;
+  }
+
+  int64 GetConstant() const {
+    return constant;
+  }
+
+  void SetConstant(int64 val) {
+    constant = val;
+  }
+
+  PrimType GetPrimType() const {
+    return primType;
+  }
+
+  void SetPrimType(PrimType pType) {
+    primType = pType;
+  }
+
+  bool IsGreaterThan(const Bound rightBound, PrimType pType) const {
+    CHECK_FATAL(IsNeededPrimType(pType), "must not be here");
+    return IsPrimTypeUint64(pType) ? static_cast<uint64>(constant) > static_cast<uint64>(rightBound.GetConstant()) :
+        GetRealValue(constant, pType) > GetRealValue(rightBound.GetConstant(), pType);
+  }
+
+  bool IsLessThanOrEqualToMax(PrimType pType) const {
+    CHECK_FATAL(IsNeededPrimType(pType), "must not be here");
+    return IsPrimTypeUint64(pType) ? static_cast<uint64>(constant) <= static_cast<uint64>(GetMaxNumber(pType)) :
+        GetRealValue(constant, pType) <= GetRealValue(GetMaxNumber(pType), pType);
+  }
+
+  bool IsGreaterThanOrEqualToMin(PrimType pType) const {
+    CHECK_FATAL(IsNeededPrimType(pType), "must not be here");
+    return IsPrimTypeUint64(pType) ? static_cast<uint64>(constant) >= static_cast<uint64>(GetMinNumber(pType)):
+        GetRealValue(constant, pType) >= GetRealValue(GetMinNumber(pType), pType);
+  }
+
+  bool IsLessThanOrEqualTo(const Bound rightBound, PrimType pType) const {
+    CHECK_FATAL(IsNeededPrimType(pType), "must not be here");
+    return IsPrimTypeUint64(pType) ? static_cast<uint64>(constant) <= static_cast<uint64>(rightBound.GetConstant()) :
+        GetRealValue(constant, pType) <= GetRealValue(rightBound.GetConstant(), pType);
+  }
+
+  bool IsGreaterThanOrEqualTo(const Bound rightBound, PrimType pType) const {
+    CHECK_FATAL(IsNeededPrimType(pType), "must not be here");
+    return IsPrimTypeUint64(pType) ? static_cast<uint64>(constant) >= static_cast<uint64>(rightBound.GetConstant()):
+        GetRealValue(constant, pType) >= GetRealValue(rightBound.GetConstant(), pType);
+  }
+
+  bool IsEqual(const Bound rightBound, PrimType pType) const {
+    CHECK_FATAL(IsNeededPrimType(pType), "must not be here");
+    return IsPrimTypeUint64(pType) ? static_cast<uint64>(constant) == static_cast<uint64>(rightBound.GetConstant()) :
+        GetRealValue(constant, pType) == GetRealValue(rightBound.GetConstant(), pType);
+  }
+
+  bool IsEqualAfterCVT(PrimType fromType, PrimType toType) const {
+    if (!IsNeededPrimType(fromType) || !IsNeededPrimType(toType)) {
+      return false;
+    }
+    if (fromType == toType) {
+      return true;
+    }
+    if (IsPrimTypeUint64(fromType)) {
+      return static_cast<uint64>(constant) == GetRealValue(constant, toType);
+    } else if (IsPrimTypeUint64(toType)) {
+      return static_cast<uint64>(constant) == GetRealValue(constant, fromType);
+    } else {
+      return GetRealValue(constant, fromType) == GetRealValue(constant, toType);
+    }
+  }
+
+  bool IsEqualToMax(PrimType pType) const {
+    CHECK_FATAL(IsNeededPrimType(pType), "must not be here");
+    return IsPrimTypeUint64(pType) ? static_cast<uint64>(constant) == static_cast<uint64>(GetMaxNumber(pType)) :
+        GetRealValue(constant, pType) == GetRealValue(GetMaxNumber(pType), pType);
+  }
+
+  bool IsEqualToMin(PrimType pType) const {
+    CHECK_FATAL(IsNeededPrimType(pType), "must not be here");
+    return IsPrimTypeUint64(pType) ? static_cast<uint64>(constant) == static_cast<uint64>(GetMinNumber(pType)) :
+        GetRealValue(constant, pType) == GetRealValue(GetMinNumber(pType), pType);
+  }
+
+  static int64 GetRemResult(int64 lhsConstant, int64 rhsConstant, PrimType pType) {
+    CHECK_FATAL(IsNeededPrimType(pType), "must not be here");
+    return IsPrimTypeUint64(pType) ? static_cast<uint64>(lhsConstant) % static_cast<uint64>(rhsConstant) :
+        GetRealValue(lhsConstant, pType) % GetRealValue(rhsConstant, pType);
+  }
+
+  bool CanBeComparedWith(const Bound &bound) const;
+
+  bool operator==(const Bound &bound) const {
+    return var == bound.GetVar() && constant == bound.GetConstant() &&
+           (GetPrimTypeActualBitSize(primType) == GetPrimTypeActualBitSize(bound.GetPrimType()) &&
+            IsSignedInteger(primType) == IsSignedInteger(bound.GetPrimType()));
+  }
+
+  bool operator<(const Bound &bound) const;
+
+  bool operator<=(const Bound &bound) const;
+
+  Bound &operator++() { // prefix inc
+    ++constant;
+    return *this;
+  }
+  Bound &operator--() { // prefix dec
+    --constant;
+    return *this;
+  }
+
+  static Bound MinBound(PrimType pType) {
+    return Bound(nullptr, GetMinNumber(pType), pType);
+  }
+
+  static Bound MaxBound(PrimType pType) {
+    return Bound(nullptr, GetMaxNumber(pType), pType);
+  }
+
+  bool IsConstantBound() const {
+    return var == nullptr;
+  }
+
+ private:
+  MeExpr *var = nullptr;
+  int64 constant = 0;
+  PrimType primType = PTY_begin;
+};
+
+enum RangeType {
+  kRTEmpty,
+  kLowerAndUpper,
+  kSpecialUpperForLoop,
+  kSpecialLowerForLoop,
+  kOnlyHasLowerBound,
+  kOnlyHasUpperBound,
+  kNotEqual,
+  kEqual,
+  kRTComplete
+};
+
+enum StrideType {
+  kStrideIsConstant,
+  kStrideIsValueRange,
+  kCanNotCompute,
+};
+
+enum InRangeType {
+  kLowerInRange,
+  kUpperInRange,
+  kInRange,
+  kNotInRange,
+};
+
+using Lower = Bound;
+using Upper = Bound;
+
+struct RangePair {
+  RangePair() : lower(Bound()), upper(Bound()) {}
+  RangePair(const Bound &l, const Bound &u) : lower(l), upper(u) {}
+  Lower lower = Bound();
+  Upper upper = Bound();
+};
+
+class ValueRange {
+ public:
+  union Range {
+    Range() {};
+    RangePair pair;
+    Bound bound;
+  };
+
+  ValueRange(const Bound &bound, int64 argStride, RangeType type) : stride(argStride), rangeType(type) {
+    range.bound = bound;
+  }
+
+  ValueRange(const Bound &lower, const Bound &upper, RangeType type, bool argAccurate = false)
+      : rangeType(type), isAccurate(argAccurate) {
+    range.pair.lower = lower;
+    range.pair.upper = upper;
+  }
+
+  ValueRange(const Bound &bound, RangeType type, bool argAccurate = false) : rangeType(type), isAccurate(argAccurate) {
+    range.bound = bound;
+  }
+
+  explicit ValueRange(RangeType type) : rangeType(type) {} // only used for kRTEmpty/kRTComplete
+
+  ~ValueRange() = default;
+
+  void SetRangePair(const Bound &lower, const Bound &upper) {
+    range.pair.lower = lower;
+    range.pair.upper = upper;
+  }
+
+  const RangePair GetLowerAndupper() const {
+    return range.pair;
+  }
+
+  void SetLower(const Lower &lower) {
+    range.pair.lower = lower;
+  }
+
+  void SetUpper(const Upper &upper) {
+    range.pair.upper = upper;
+  }
+
+  Bound GetUpper() const {
+    switch (rangeType) {
+      case kLowerAndUpper:
+      case kSpecialLowerForLoop:
+      case kSpecialUpperForLoop:
+        return range.pair.upper;
+      case kOnlyHasUpperBound:
+      case kEqual:
+      case kNotEqual:
+        return range.bound;
+      case kOnlyHasLowerBound:
+        return MaxBound(range.bound.GetPrimType());
+      default:
+        CHECK_FATAL(false, "can not be here");
+    }
+  }
+
+  Bound GetLower() const {
+    switch (rangeType) {
+      case kLowerAndUpper:
+      case kSpecialLowerForLoop:
+      case kSpecialUpperForLoop:
+        return range.pair.lower;
+      case kOnlyHasLowerBound:
+      case kEqual:
+      case kNotEqual:
+        return range.bound;
+      case kOnlyHasUpperBound:
+        return MinBound(range.bound.GetPrimType());
+      default:
+        CHECK_FATAL(false, "can not be here");
+    }
+  }
+
+  bool IfLowerEqualToUpper() const {
+    return rangeType == kEqual ||
+           (rangeType == kLowerAndUpper &&
+            range.pair.lower.GetVar() == range.pair.upper.GetVar() &&
+            range.pair.lower.GetConstant() == range.pair.upper.GetConstant());
+  }
+
+  bool UpperIsMax(PrimType pType) const {
+    return GetUpper().IsEqualToMax(pType);
+  }
+
+  bool LowerIsMin(PrimType pType) const {
+    return GetLower().IsEqualToMin(pType);
+  }
+
+  void SetBound(const Bound &argBound) {
+    range.bound = argBound;
+  }
+
+  const Bound GetBound() const {
+    return range.bound;
+  }
+
+  Bound GetBound() {
+    return range.bound;
+  }
+
+  int64 GetStride() const {
+    return stride;
+  }
+
+  RangeType GetRangeType() const {
+    return rangeType;
+  }
+
+  void SetRangeType(RangeType type) {
+    rangeType = type;
+  }
+
+  void SetPrimType(PrimType pType) {
+    range.bound.SetPrimType(pType);
+    range.pair.upper.SetPrimType(pType);
+    range.pair.lower.SetPrimType(pType);
+  }
+
+  PrimType GetPrimType() const {
+    switch (rangeType) {
+      case kLowerAndUpper:
+      case kSpecialLowerForLoop:
+      case kSpecialUpperForLoop:
+        return range.pair.lower.GetPrimType();
+      case kEqual:
+      case kNotEqual:
+      case kOnlyHasLowerBound:
+      case kOnlyHasUpperBound:
+        return range.bound.GetPrimType();
+      default:
+        CHECK_FATAL(false, "can not be here");
+    }
+  }
+
+  bool IsZeroInRange() const {
+    return IsConstantLowerAndUpper() && GetUpper().GetConstant() >= 0 &&
+        GetLower().GetConstant() < GetUpper().GetConstant();
+  }
+  bool IsConstantRange() {
+    return (rangeType == kEqual && range.bound.GetVar() == nullptr) ||
+           (rangeType == kNotEqual && range.bound.GetVar() == nullptr) ||
+           (rangeType == kLowerAndUpper && range.pair.lower.GetVar() == nullptr &&
+            range.pair.lower.GetVar() == range.pair.upper.GetVar());
+  }
+
+  bool IsConstant() const {
+    return (rangeType == kEqual && range.bound.GetVar() == nullptr) ||
+           (rangeType == kNotEqual && range.bound.GetVar() == nullptr) ||
+           (rangeType == kLowerAndUpper && range.pair.lower.GetVar() == nullptr &&
+            range.pair.lower.GetVar() == range.pair.upper.GetVar() &&
+            range.pair.lower.GetConstant() == range.pair.upper.GetConstant());
+  }
+
+  bool IsConstantLowerAndUpper() const {
+    return (rangeType == kEqual && range.bound.GetVar() == nullptr) ||
+           (rangeType == kLowerAndUpper && range.pair.lower.GetVar() == nullptr &&
+            range.pair.upper.GetVar() == nullptr);
+  }
+
+  bool IsGreaterThanOrEqualToZero() const {
+    auto pType = GetPrimType();
+    Bound zeroBound(nullptr, 0, pType);
+    return GetLower().IsGreaterThanOrEqualTo(zeroBound, pType) &&
+      GetUpper().IsGreaterThanOrEqualTo(zeroBound, pType);
+  }
+
+  bool IsNotConstantVR() const {
+    return GetLower().GetVar() != nullptr || GetUpper().GetVar() != nullptr;
+  }
+
+  static Bound MinBound(PrimType pType) {
+    return Bound(nullptr, GetMinNumber(pType), pType);
+  }
+
+  static Bound MaxBound(PrimType pType) {
+    return Bound(nullptr, GetMaxNumber(pType), pType);
+  }
+
+  bool IsNotEqualZero() const {
+    return rangeType == kNotEqual && range.bound.GetVar() == nullptr && range.bound.GetConstant() == 0;
+  }
+
+  bool IsEqualZero() const {
+    return rangeType == kEqual && range.bound.GetVar() == nullptr && range.bound.GetConstant() == 0;
+  }
+
+  bool IsAccurate() const {
+    return isAccurate;
+  }
+
+  void SetAccurate(bool argAccurate) {
+    isAccurate = argAccurate;
+  }
+
+  bool IsEqualAfterCVT(PrimType fromType, PrimType toType) const {
+    if (fromType == toType) {
+      return true;
+    }
+    if (rangeType != kEqual && rangeType != kLowerAndUpper) {
+      return false;
+    }
+    if (!IsConstantLowerAndUpper()) {
+      return false;
+    }
+    return GetLower().IsEqualAfterCVT(fromType, toType) && GetUpper().IsEqualAfterCVT(fromType, toType);
+  }
+
+  bool IsEqual(ValueRange *valueRangeRight) const;
+
+ private:
+  Range range;
+  int64 stride = 0;
+  RangeType rangeType;
+  bool isAccurate = false;
+};
+
+// return nullptr means cannot merge, intersect = true : intersection set, intersect = false : union set
+std::unique_ptr<ValueRange> MergeVR(const ValueRange &vr1, const ValueRange &vr2, bool intersect = false);
+// give expr and its value range, use irmap to create a cmp expr
+MeExpr *GetCmpExprFromVR(const ValueRange *vr, MeExpr &expr, MeIRMap *irmap);
+
+class ValueRangePropagation {
+ public:
+  static bool isDebug;
+
+  ValueRangePropagation(MeFunction &meFunc, MeIRMap &argIRMap, Dominance &argDom,
+                        IdentifyLoops *argLoops, MemPool &pool,
+                        std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &candsTem, LoopScalarAnalysisResult &currSA,
+                        bool dealWithAssertArg, bool onlyProp = false)
+      : func(meFunc), irMap(argIRMap), dom(argDom), memPool(pool), mpAllocator(&pool), loops(argLoops),
+        caches(meFunc.GetCfg()->GetAllBBs().size()), analysisedLowerBoundChecks(meFunc.GetCfg()->GetAllBBs().size()),
+        analysisedUpperBoundChecks(meFunc.GetCfg()->GetAllBBs().size()),
+        analysisedAssignBoundChecks(meFunc.GetCfg()->GetAllBBs().size()),
+        cands(candsTem), sa(currSA), dealWithAssert(dealWithAssertArg), onlyPropVR(onlyProp) {
+    onlyRecordValueRangeInTempCache.push(false);
+  }
+  ~ValueRangePropagation() = default;
+
+  void DumpCaches();
+  void Execute();
+
+  bool IsCFGChange() const {
+    return isCFGChange;
+  }
+
+  bool NeedUpdateSSA() const {
+    return needUpdateSSA;
+  }
+
+  void SetSafetyNonnullCheck(SafetyCheck &check) {
+    safetyCheckNonnull = &check;
+  }
+
+  void SetSafetyBoundaryCheck(SafetyCheck &check) {
+    safetyCheckBoundary = &check;
+  }
+
+  void JudgeTheConsistencyOfDefPointsOfBoundaryCheck(
+      BB &bb, MeExpr &expr, std::set<MeExpr*> &visitedLHS, std::vector<MeStmt*> &stmts, bool &crossPhiNode);
+  bool TheValueOfOpndIsInvaliedInABCO(const BB &bb, const MeStmt *meStmt, MeExpr &boundOpnd, bool updateCaches = true);
+  ValueRange *FindValueRange(const BB &bb, MeExpr &expr, uint32 &numberOfRecursions,
+      std::unordered_set<int32> &foundExprs);
+  bool BrStmtInRange(const BB &bb, const ValueRange &leftRange, const ValueRange &rightRange, Opcode op,
+                     PrimType opndType, bool judgeNotInRange = false);
+  std::unique_ptr<ValueRange> CreateValueRangeOfNotEqualZero(PrimType pType) const {
+    return std::make_unique<ValueRange>(Bound(nullptr, 0, pType), kNotEqual);
+  }
+
+  std::unique_ptr<ValueRange> CreateValueRangeOfEqualZero(PrimType pType) const {
+    return std::make_unique<ValueRange>(Bound(nullptr, 0, pType), kEqual);
+  }
+
+  ValueRange CreateTempValueRangeOfNotEqualZero(PrimType pType) const {
+    return ValueRange(Bound(nullptr, 0, pType), kNotEqual);
+  }
+
+  ValueRange CreateTempValueRangeOfEqualZero(PrimType pType) const {
+    return ValueRange(Bound(nullptr, 0, pType), kEqual);
+  }
+
+  void ComputeCodeSize(const MeExpr &meExpr, uint32 &cost);
+  void ComputeCodeSize(const MeStmt &meStmt, uint32 &cost);
+  bool TowCompareOperandsAreInSameIterOfLoop(const MeExpr &lhs, const MeExpr &rhs) const;
+
+  ValueRange *FindValueRangeAndInitNumOfRecursion(const BB &bb, MeExpr &expr) {
+    uint32 numOfRecursion = 0;
+    std::unordered_set<int32> foundExprs{expr.GetExprID()};
+    return FindValueRange(bb, expr, numOfRecursion, foundExprs);
+  }
+
+ private:
+  struct CompareExpr {
+    bool operator()(const MeExpr *expr1, const MeExpr *expr2) const {
+      ASSERT_NOT_NULL(expr1);
+      ASSERT_NOT_NULL(expr2);
+      return expr1->GetExprID() < expr2->GetExprID();
+    }
+  };
+
+  struct CompareBB {
+    bool operator()(const BB *bb1, const BB *bb2) const {
+      ASSERT_NOT_NULL(bb1);
+      ASSERT_NOT_NULL(bb2);
+      return bb1->GetBBId() < bb2->GetBBId();
+    }
+  };
+
+  bool Insert2Caches(const BBId &bbID, int32 exprID, std::unique_ptr<ValueRange> valueRange,
+      const MeExpr *opnd = nullptr);
+
+  ValueRange *FindValueRangeInCurrentBB(BBId bbID, int32 exprID) {
+    auto it = caches.at(bbID).find(exprID);
+    return it != caches.at(bbID).end() ? it->second.get() : nullptr;
+  }
+
+  ValueRange *FindValueRangeInCaches(BBId bbID, int32 exprID, uint32 &numberOfRecursions) {
+    if (numberOfRecursions++ > kRecursionThreshold) {
+      return nullptr;
+    }
+    auto it = caches.at(bbID).find(exprID);
+    if (it != caches.at(bbID).end()) {
+      return it->second.get();
+    }
+    if (onlyRecordValueRangeInTempCache.top()) {
+      auto itOfTemp = tempCaches.find(bbID);
+      if (itOfTemp != tempCaches.end()) {
+        auto itOfVR = itOfTemp->second.find(exprID);
+        if (itOfVR != itOfTemp->second.end()) {
+          return itOfVR->second.get();
+        }
+      }
+    }
+    auto *domBB = dom.GetDom(bbID.GetIdx());
+    return (domBB == nullptr || domBB->GetID() == 0) ?
+        nullptr : FindValueRangeInCaches(BBId(domBB->GetID()), exprID, numberOfRecursions);
+  }
+
+  void Insert2AnalysisedArrayChecks(BBId bbID, MeExpr &array, MeExpr &index, Opcode op) {
+    auto &analysisedArrayChecks = kOpcodeInfo.IsAssertLowerBoundary(op) ? analysisedLowerBoundChecks :
+        kOpcodeInfo.IsAssertLeBoundary(op) ? analysisedAssignBoundChecks : analysisedUpperBoundChecks;
+    if (analysisedArrayChecks.at(bbID).empty() ||
+        analysisedArrayChecks.at(bbID).find(&array) == analysisedArrayChecks.at(bbID).end()) {
+      analysisedArrayChecks.at(bbID)[&array] = std::set<MeExpr*>{ &index };
+    } else {
+      analysisedArrayChecks.at(bbID)[&array].insert(&index);
+    }
+  }
+
+  void Insert2NewMergeBB2Opnd(BB &bb, const MeExpr &opnd) {
+    auto exprID = static_cast<uint32>(opnd.GetExprID());
+    auto ret = newMergeBB2Opnd.emplace(&bb, exprID);
+    if (!ret.second) {
+      CHECK_FATAL(ret.first->second == exprID, "must be equal");
+    }
+  }
+
+  BB *GetNewCopyFallthruBB(BB &trueOrFalseBranch, const BB &bb) {
+    auto it = trueOrFalseBranch2NewCopyFallthru.find(&trueOrFalseBranch);
+    if (it == trueOrFalseBranch2NewCopyFallthru.end()) {
+      return nullptr;
+    }
+    for (auto &pair : it->second) {
+      if (pair.first == &bb) {
+        return pair.second;
+      }
+    }
+    return nullptr;
+  }
+
+  void Insert2TrueOrFalseBranch2NewCopyFallthru(BB &trueOrFalseBranch, BB &fallthruBB, BB &newFalthru) {
+    auto it = trueOrFalseBranch2NewCopyFallthru.find(&trueOrFalseBranch);
+    if (it == trueOrFalseBranch2NewCopyFallthru.end()) {
+      trueOrFalseBranch2NewCopyFallthru[&trueOrFalseBranch] =
+          std::vector<std::pair<BB*, BB*>>{ std::make_pair(&fallthruBB, &newFalthru) };
+    } else {
+      trueOrFalseBranch2NewCopyFallthru[&trueOrFalseBranch].push_back(std::make_pair(&fallthruBB, &newFalthru));
+    }
+  }
+
+  void ResizeWhenCreateNewBB() {
+    caches.resize(caches.size() + 1);
+    analysisedLowerBoundChecks.resize(analysisedLowerBoundChecks.size() + 1);
+    analysisedUpperBoundChecks.resize(analysisedUpperBoundChecks.size() + 1);
+    analysisedAssignBoundChecks.resize(analysisedAssignBoundChecks.size() + 1);
+  }
+
+  bool IsGotoOrFallthruBB(const BB &bb) const {
+    return bb.GetKind() == kBBGoto || bb.GetKind() == kBBFallthru;
+  }
+
+  void Insert2PairOfExprs(MeExpr &lhs, MeExpr &rhs, BB &bb) {
+    if (lhs.IsVolatile() || rhs.IsVolatile()) {
+      return;
+    }
+    auto it = pairOfExprs.find(&lhs);
+    if (it == pairOfExprs.end()) {
+      std::map<BB*, std::set<MeExpr*, CompareExpr>, CompareBB> valueOfPairOfExprs{
+          std::make_pair<BB*, std::set<MeExpr*, CompareExpr>>(&bb, std::set<MeExpr*, CompareExpr>{&rhs }) };
+      pairOfExprs[&lhs] = valueOfPairOfExprs;
+    } else if (it->second.find(&bb) == it->second.end()) {
+      pairOfExprs[&lhs][&bb] = std::set<MeExpr*, CompareExpr>{&rhs };
+    } else {
+      pairOfExprs[&lhs][&bb].insert(&rhs);
+    }
+  }
+
+  // If the vr of lhs is equal to the vr of rhs in bb.
+  bool FindPairOfExprs(MeExpr &lhs, const MeExpr &rhs, const BB &bb) const {
+    auto it = pairOfExprs.find(&lhs);
+    if (it == pairOfExprs.end()) {
+      return false;
+    }
+    for (auto itOfValueMap = it->second.begin(); itOfValueMap != it->second.end(); ++itOfValueMap) {
+      auto bbOfPair = itOfValueMap->first;
+      auto exprs = itOfValueMap->second;
+      if (!dom.Dominate(*bbOfPair, bb)) {
+        continue;
+      }
+      for (auto itOfExprs = exprs.begin(); itOfExprs != exprs.end(); ++itOfExprs) {
+        if (*itOfExprs == &rhs && (*itOfExprs)->GetPrimType() == rhs.GetPrimType()) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  void JudgeEqual(MeExpr &expr, ValueRange &vrOfLHS, ValueRange &vrOfRHS, std::unique_ptr<ValueRange> &valueRangePtr);
+
+  // The pairOfExprs map collects the exprs which have the same valueRange in bbs,
+  // the pair of expr and preExpr is element of pairOfExprs.
+  ValueRange *FindValueRangeWithCompareOp(const BB &bb, MeExpr &expr, uint32 &numberOfRecursions,
+      std::unordered_set<int32> &foundExprs, MeExpr *preExpr = nullptr);
+
+  void DealWithPhi(const BB &bb);
+  void DealWithCondGoto(BB &bb, MeStmt &stmt);
+  void DealWithCondGotoWithOneOpnd(BB &bb, CondGotoMeStmt &brMeStmt);
+  void InsertValueRangeOfCondExpr2Caches(BB &bb, const MeStmt &stmt);
+  void DealWithBrStmtWithOneOpnd(BB &bb, const CondGotoMeStmt &stmt, MeExpr &opnd, Opcode op);
+  bool OverflowOrUnderflow(PrimType pType, int64 lhs, int64 rhs) const;
+  void DealWithAssign(BB &bb, const MeStmt &stmt);
+  bool IsConstant(const BB &bb, MeExpr &expr, int64 &constant, bool canNotBeNotEqual = true);
+  std::unique_ptr<ValueRange> CreateValueRangeForPhi(
+      LoopDesc &loop, const BB &bb, ScalarMeExpr &init, ScalarMeExpr &backedge,
+      const ScalarMeExpr &lhsOfPhi);
+  bool AddOrSubWithConstant(PrimType pType, Opcode op, int64 lhsConstant, int64 rhsConstant, int64 &res) const;
+  std::unique_ptr<ValueRange> NegValueRange(const BB &bb, MeExpr &opnd, uint32 &numberOfRecursions,
+      std::unordered_set<int32> &foundExprs);
+  bool AddOrSubWithBound(Bound oldBound, Bound &resBound, int64 rhsConstant, Opcode op);
+  std::unique_ptr<ValueRange> AddOrSubWithValueRange(Opcode op, ValueRange &valueRange, int64 rhsConstant);
+  std::unique_ptr<ValueRange> AddOrSubWithValueRange(
+      Opcode op, ValueRange &valueRangeLeft, ValueRange &valueRangeRight);
+  std::unique_ptr<ValueRange> DealWithAddOrSub(const BB &bb, const OpMeExpr &opMeExpr);
+  bool CanComputeLoopIndVar(const MeExpr &phiLHS, MeExpr &expr, int64 &constant);
+  std::unique_ptr<ValueRange> RemWithValueRange(const BB &bb, const OpMeExpr &opMeExpr, int64 rhsConstant);
+  std::unique_ptr<ValueRange> RemWithRhsValueRange(const OpMeExpr &opMeExpr, int64 rhsConstant) const;
+  std::unique_ptr<ValueRange> DealWithRem(const BB &bb, const MeExpr &lhsVar, const OpMeExpr &opMeExpr);
+  Bound Max(Bound leftBound, Bound rightBound);
+  Bound Min(Bound leftBound, Bound rightBound);
+  InRangeType InRange(const BB &bb, const ValueRange &rangeTemp, const ValueRange &range, bool lowerIsZero = false);
+  std::unique_ptr<ValueRange> CombineTwoValueRange(const ValueRange &leftRange,
+                                                   const ValueRange &rightRange, bool merge = false);
+  void DealWithArrayLength(const BB &bb, MeExpr &lhs, MeExpr &rhs);
+  void DealWithArrayCheck(BB &bb, MeStmt &meStmt, MeExpr &meExpr);
+  void DealWithArrayCheck();
+  bool IfAnalysisedBefore(const BB &bb, const MeStmt &stmt);
+  std::unique_ptr<ValueRange> MergeValueRangeOfPhiOperands(const BB &bb, MePhiNode &mePhiNode);
+  void ReplaceBoundForSpecialLoopRangeValue(LoopDesc &loop, ValueRange &valueRangeOfIndex, bool upperIsSpecial);
+  std::unique_ptr<ValueRange> CreateValueRangeForMonotonicIncreaseVar(
+      const LoopDesc &loop, BB &exitBB, const BB &bb, OpMeExpr &opMeExpr,
+      MeExpr &opnd1, Bound &initBound, int64 stride);
+  std::unique_ptr<ValueRange> CreateValueRangeForMonotonicDecreaseVar(
+      const LoopDesc &loop, BB &exitBB, const BB &bb, OpMeExpr &opMeExpr,
+      MeExpr &opnd1, Bound &initBound, int64 stride);
+  void CreateValueRangeForLeOrLt(const MeExpr &opnd, const ValueRange *leftRange, Bound newRightUpper,
+                                 Bound newRightLower, const BB &trueBranch, const BB &falseBranch, bool isAccurate);
+  void CreateValueRangeForGeOrGt(const MeExpr &opnd, const ValueRange *leftRange, Bound newRightUpper,
+                                 Bound newRightLower, const BB &trueBranch, const BB &falseBranch, bool isAccurate);
+  void CreateValueRangeForCondGoto(
+      const MeExpr &opnd, Opcode op, ValueRange *leftRange,
+      ValueRange &rightRange, const BB &trueBranch, const BB &falseBranch);
+  void DealWithCondGoto(BB &bb, Opcode op, ValueRange *leftRange, ValueRange &rightRange,
+                        const CondGotoMeStmt &brMeStmt);
+  bool CreateNewBoundWhenAddOrSub(Opcode op, Bound bound, int64 rhsConstant, Bound &res);
+  std::unique_ptr<ValueRange> CopyValueRange(ValueRange &valueRange, PrimType pType = PTY_begin);
+  bool LowerInRange(const BB &bb, Bound lowerTemp, Bound lower, bool lowerIsZero);
+  bool UpperInRange(const BB &bb, Bound upperTemp, Bound upper, bool upperIsArrayLength);
+  void PrepareForSSAUpdateWhenPredBBIsRemoved(const BB &pred, BB &bb, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+      std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr);
+  void InsertOstOfPhi2Cands(BB &bb, size_t i, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+                            std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr, bool setPhiIsDead = false);
+  void InsertOstOfPhi2Cands(BB &bb, size_t i);
+  void AnalysisUnreachableBBOrEdge(BB &bb, BB &unreachableBB, BB &succBB);
+  void CreateValueRangeForNeOrEq(const MeExpr &opnd, const ValueRange *leftRange,
+                                 ValueRange &rightRange, const BB &trueBranch, const BB &falseBranch);
+  void DeleteUnreachableBBs();
+  void ChangeLoop2Goto(LoopDesc &loop, BB &bb, BB &succBB, const BB &unreachableBB);
+  void UpdateTryAttribute(BB &bb);
+  void GetTrueAndFalseBranch(Opcode op, BB &bb, BB *&trueBranch, BB *&falseBranch) const;
+  Opcode GetTheOppositeOp(Opcode op) const;
+  bool GetValueRangeOfCondGotoOpnd(const BB &bb, OpMeExpr &opMeExpr, MeExpr &opnd, ValueRange *&valueRange,
+                                   std::unique_ptr<ValueRange> &rightRangePtr);
+  bool ConditionBBCanBeDeletedAfterOPNeOrEq(BB &bb, ValueRange &leftRange, ValueRange &rightRange, BB &falseBranch,
+                                            BB &trueBranch);
+  bool ConditionEdgeCanBeDeleted(BB &pred, BB &bb, const ValueRange *leftRange,
+      const ValueRange *rightRange, BB &falseBranch, BB &trueBranch, PrimType opndType, Opcode op,
+      ScalarMeExpr *updateSSAExceptTheScalarExpr, std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr);
+  void GetSizeOfUnreachableBBsAndReachableBB(BB &bb, size_t &unreachableBB, BB *&reachableBB);
+  bool ConditionEdgeCanBeDeleted(BB &bb, MeExpr &opnd0, ValueRange *rightRange, PrimType opndType, Opcode op);
+  bool OnlyHaveCondGotoStmt(BB &bb) const;
+  bool RemoveUnreachableEdge(BB &pred, BB &bb, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+                             std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr);
+  void RemoveUnreachableBB(BB &condGotoBB, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+                           std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr);
+  BB *CreateNewGotoBBWithoutCondGotoStmt(BB &bb);
+  void CopyMeStmts(BB &fromBB, BB &toBB);
+  bool ChangeTheSuccOfPred2TrueBranch(BB &pred, BB &bb, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+                                      std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr);
+  bool CopyFallthruBBAndRemoveUnreachableEdge(
+      BB &pred, BB &bb, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+      std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr);
+  size_t GetRealPredSize(const BB &bb) const;
+  bool RemoveTheEdgeOfPredBB(BB &pred, BB &bb, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+                             std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr);
+  void DealWithCondGotoWhenRightRangeIsNotExist(BB &bb, const MeExpr &opnd0, MeExpr &opnd1,
+                                                Opcode opOfBrStmt, Opcode conditionalOp, ValueRange *valueRangeOfLeft);
+  MeExpr *GetDefOfBase(const IvarMeExpr &ivar) const;
+  std::unique_ptr<ValueRange> DealWithMeOp(const BB &bb, const MeStmt &stmt);
+  void ReplaceOpndByDef(const BB &bb, MeExpr &currOpnd, MeExpr *&predOpnd, MePhiNode *&phi, bool &thePhiIsInBB);
+  bool AnalysisValueRangeInPredsOfCondGotoBB(BB &bb, MeExpr *opnd0, MeExpr &currOpnd,
+      ValueRange *rightRange, BB &falseBranch, BB &trueBranch, PrimType opndType, Opcode op, BB &condGoto);
+  void CreateLabelForTargetBB(BB &pred, BB &newBB);
+  size_t FindBBInSuccs(const BB &bb, const BB &succBB) const;
+  void DealWithOperand(const BB &bb, MeStmt &stmt, MeExpr &meExpr);
+  void CollectMeExpr(const BB &bb, MeStmt &stmt, MeExpr &meExpr,
+                     std::map<MeExpr*, std::pair<int64, PrimType>> &expr2ConstantValue);
+  void ReplaceOpndWithConstMeExpr(const BB &bb, MeStmt &stmt);
+  bool OnlyHaveOneCondGotoPredBB(const BB &bb, const BB &condGotoBB) const;
+  void GetValueRangeForUnsignedInt(const BB &bb, OpMeExpr &opMeExpr, const MeExpr &opnd, ValueRange *&valueRange,
+                                   std::unique_ptr<ValueRange> &rightRangePtr);
+  void GetValueRangeOfCRNode(const BB &bb, CRNode &opndOfCRNode, std::unique_ptr<ValueRange> &resValueRange,
+                             PrimType pTypeOfArray);
+  std::unique_ptr<ValueRange> GetValueRangeOfCRNodes(
+      const BB &bb, PrimType pTypeOfArray, std::vector<CRNode*> &crNodes);
+  bool DealWithAssertNonnull(BB &bb, const MeStmt &meStmt);
+  bool DealWithBoundaryCheck(BB &bb, MeStmt &meStmt);
+  MeExpr *GetAddressOfIndexOrBound(MeExpr &expr) const;
+  std::unique_ptr<ValueRange> FindValueRangeInCurrBBOrDominateBBs(const BB &bb, MeExpr &opnd);
+  bool ThePhiLHSIsLoopVariable(const LoopDesc &loop, const MeExpr &opnd) const;
+  bool IsLoopVariable(const LoopDesc &loop, const MeExpr &opnd) const;
+  void CollectIndexOpndWithBoundInLoop(
+      LoopDesc &loop, BB &bb, MeStmt &meStmt, MeExpr &opnd, std::map<MeExpr*, MeExpr*> &index2NewExpr);
+  bool CompareConstantOfIndexAndLength(
+      const MeStmt &meStmt, const ValueRange &valueRangeOfIndex, ValueRange &valueRangeOfLengthPtr, Opcode op);
+  bool CompareIndexWithUpper(const BB &bb, const MeStmt &meStmt, const ValueRange &valueRangeOfIndex,
+                             ValueRange &valueRangeOfLengthPtr, Opcode op, const MeExpr *indexOpnd = nullptr);
+  bool DealWithAssertLtOrLe(BB &bb, MeStmt &meStmt, CRNode &indexCR, CRNode &boundCR, Opcode op);
+  void DealWithCVT(const BB &bb, MeStmt &stmt, MeExpr *operand, size_t i, bool dealWithStmt = false);
+  std::unique_ptr<ValueRange> ZeroIsInRange(const ValueRange &valueRange);
+  void DealWithNeg(const BB &bb, const OpMeExpr &opMeExpr);
+  bool DealWithCVT(const BB &bb, MeStmt &stmt, OpMeExpr &opMeExpr);
+  bool IfTheLowerOrUpperOfLeftRangeEqualToTheRightRange(
+          const ValueRange &leftRange, ValueRange &rightRange, bool isLower) const;
+  bool DealWithSpecialCondGoto(const BB &bb, OpMeExpr &opMeExpr, const ValueRange &leftRange, ValueRange &rightRange,
+                               CondGotoMeStmt &brMeStmt);
+  void UpdateOrDeleteValueRange(const MeExpr &opnd, std::unique_ptr<ValueRange> valueRange, const BB &branch);
+  void Insert2UnreachableBBs(BB &unreachableBB);
+  void DeleteThePhiNodeWhichOnlyHasOneOpnd(BB &bb, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+      std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr);
+  void DealWithCallassigned(const BB &bb, MeStmt &stmt);
+  void DeleteAssertNonNull();
+  void DeleteBoundaryCheck();
+  bool MustBeFallthruOrGoto(const BB &defBB, const BB &bb) const;
+  std::unique_ptr<ValueRange> AntiValueRange(ValueRange &valueRange);
+  void DeleteUnreachableBBs(BB &curBB, BB &falseBranch, BB &trueBranch);
+  void PropValueRangeFromCondGotoToTrueAndFalseBranch(
+      const MeExpr &opnd0, ValueRange &rightRange, const BB &falseBranch, const BB &trueBranch);
+  bool CodeSizeIsOverflowOrTheOpOfStmtIsNotSupported(const BB &bb);
+  void DealWithSwitch(BB &bb, MeStmt &stmt);
+  bool DealWithSwitchWhenOpndIsConstant(BB &bb, BB *defaultBB, const ValueRange *valueRange,
+      const SwitchMeStmt &switchMeStmt);
+  bool AnalysisUnreachableForGeOrGt(BB &bb, const CondGotoMeStmt &brMeStmt, const ValueRange &leftRange);
+  bool AnalysisUnreachableForLeOrLt(BB &bb, const CondGotoMeStmt &brMeStmt, const ValueRange &leftRange);
+  bool AnalysisUnreachableForEqOrNe(BB &bb, const CondGotoMeStmt &brMeStmt, const ValueRange &leftRange);
+  bool DealWithVariableRange(BB &bb, const CondGotoMeStmt &brMeStmt, const ValueRange &leftRange);
+  std::unique_ptr<ValueRange> MergeValuerangeOfPhi(std::vector<std::unique_ptr<ValueRange>> &valueRangeOfPhi);
+  std::unique_ptr<ValueRange> MakeMonotonicIncreaseOrDecreaseValueRangeForPhi(int stride, Bound &initBound) const;
+  void CreateVRForPhi(const LoopDesc &loop);
+  void TravelBBs(std::vector<BB *> &reversePostOrderOfLoopBBs);
+  std::unique_ptr<ValueRange> CreateInitVRForPhi(LoopDesc &loop, const BB &bb, ScalarMeExpr &init,
+      ScalarMeExpr &backedge, const ScalarMeExpr &lhsOfPhi);
+  void MergeValueRangeOfPhiOperands(const LoopDesc &loop, const BB &bb,
+      std::vector<std::unique_ptr<ValueRange>> &valueRangeOfInitExprs, size_t indexOfInitExpr);
+  std::unique_ptr<ValueRange> MakeMonotonicIncreaseOrDecreaseValueRangeForPhi(int64 stride, Bound &initBound) const;
+  bool MergeVrOrInitAndBackedge(MePhiNode &mePhiNode, ValueRange &vrOfInitExpr,
+      ValueRange &valueRange, Bound &resBound);
+  void ReplaceUsePoints(MePhiNode *phi);
+  void CreateVRWithBitsSize(const BB &bb, const OpMeExpr &opMeExpr);
+  MeExpr &GetVersionOfOpndInPred(const BB &pred, const BB &bb, MeExpr &expr) const;
+  std::unique_ptr<ValueRange> GetValueRangeOfLHS(const BB &pred, const BB &bb, MeExpr &expr) const;
+  Opcode GetOpAfterSwapThePositionsOfTwoOperands(Opcode op) const;
+  bool IsSubOpndOfExpr(const MeExpr &expr, const MeExpr &subExpr) const;
+  void UpdateProfile(BB &pred, BB &bb, const BB &targetBB) const;
+  bool TheValueRangeOfOpndAndSubOpndAreEqual(const MeExpr &opnd) const;
+  void CalculateVROfSubOpnd(BBId bbID, const MeExpr &opnd, ValueRange &valueRange);
+  void CreateValueRangeForSubOpnd(const MeExpr &opnd, const BB &trueBranch, const BB &falseBranch,
+      ValueRange &resTrueBranchVR, ValueRange &resFalseBranchVR);
+  ValueRange *DealWithNegWhenFindValueRange(const BB &bb, const MeExpr &expr, const MeExpr *preExpr,
+      uint32 &numberOfRecursions, std::unordered_set<int32> &foundExprs);
+
+  MeFunction &func;
+  MeIRMap &irMap;
+  Dominance &dom;
+  MemPool &memPool;
+  MapleAllocator mpAllocator;
+  IdentifyLoops *loops;
+  std::vector<std::map<int32, std::unique_ptr<ValueRange>>> caches;
+  std::map<BBId, std::map<int32, std::unique_ptr<ValueRange>>> tempCaches;
+  std::set<MeExpr*> lengthSet;
+  std::vector<std::map<MeExpr*, std::set<MeExpr*>>> analysisedLowerBoundChecks;
+  std::vector<std::map<MeExpr*, std::set<MeExpr*>>> analysisedUpperBoundChecks;
+  std::vector<std::map<MeExpr*, std::set<MeExpr*>>> analysisedAssignBoundChecks;
+  std::map<MeExpr*, MeExpr*> length2Def;
+  std::set<BB*> unreachableBBs;
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &cands;
+  LoopScalarAnalysisResult &sa;
+  std::unordered_map<BB*, BB*> loopHead2TrueBranch;
+  std::unordered_map<BB*, uint32> newMergeBB2Opnd;
+  std::set<std::unique_ptr<ValueRange>> valueRanges;
+  std::unordered_map<BB*, std::vector<std::pair<BB*, BB*>>> trueOrFalseBranch2NewCopyFallthru;
+  // NewMergeBB must be true or false branch of condGoto bb and some preds of condGotoBB jump to this after opt.
+  BB *newMergeBB = nullptr;
+  bool hasCondGotoFromDomToPredBB = false;
+  bool isCFGChange = false;
+  bool needUpdateSSA = false;
+  uint32 codeSizeCost = 0;
+  SafetyCheck *safetyCheckNonnull = nullptr;
+  SafetyCheck *safetyCheckBoundary = nullptr;
+  // The map collects the exprs which have the same valueRange in bbs.
+  std::map<MeExpr*, std::map<BB*, std::set<MeExpr*, CompareExpr>, CompareBB>, CompareExpr> pairOfExprs;
+  bool dealWithPhi = false;
+  bool dealWithAssert = false;
+  bool onlyPropVR = false; // When need deal with check, do not opt cfg.
+  MeExprUseInfo *useInfo = nullptr;
+  std::stack<bool> onlyPropVRStack;
+  std::stack<bool> onlyRecordValueRangeInTempCache;
+  MapleVector<BaseGraphNode*>::iterator currItOfTravelReversePostOrder;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEValueRangePropagation, MeFunction)
+}  // namespace maple
+#endif
diff --git a/src/mapleall/maple_me/include/me_verify.h b/src/mapleall/maple_me/include/me_verify.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4b2de001377cfcc9ca93dbac469836319d94a97
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_verify.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MAPLE_ME_VERIFY_H
+#define MAPLE_ME_VERIFY_H
+#include "me_ir.h"
+#include "me_function.h"
+#include "me_irmap.h"
+#include "class_hierarchy_phase.h"
+
+namespace maple {
+void VerifyGlobalTypeTable();
+
+class MeVerify {
+ public:
+  explicit MeVerify(MeFunction &func) : meFunc(func) {}
+  ~MeVerify() = default;
+
+  void VerifyFunction();
+  void VerifyPhiNode(const BB &bb, const Dominance &dom) const;
+
+  static bool enableDebug;
+ private:
+  void VerifySuccAndPredOfBB(const BB &bb) const;
+  void VerifyBBKind(const BB &bb) const;
+  void DealWithSpecialCase(const BB &currBB, const BB &tryBB) const;
+  void VerifyNestedTry(const BB &tryBB, const BB &currBB) const;
+  void VerifyAttrTryBB(BB &tryBB, uint64 index);
+  void VerifyCondGotoBB(const BB &bb) const;
+  void VerifyGotoBB(const BB &bb) const;
+  void VerifyFallthruBB(const BB &bb) const;
+  void VerifyCommonExitBB() const;
+  bool IsOnlyHaveReturnOrThrowStmt(const BB &bb, Opcode op) const;
+  void VerifyReturnBB(const BB &bb) const;
+  void VerifySwitchBB(const BB &bb) const;
+  void VerifyPredBBOfSuccBB(const BB &bb, const MapleVector<BB*> &succs) const;
+
+  MeFunction &meFunc;
+};
+
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MEVerify, MeFunction)
+MAPLE_FUNC_PHASE_DECLARE_END
+} // namespace maple
+#endif  // MAPLE_ME_VERIFY_H
diff --git a/src/mapleall/maple_me/include/meconstprop.h b/src/mapleall/maple_me/include/meconstprop.h
new file mode 100644
index 0000000000000000000000000000000000000000..28f12fe3c2d619731d756bf374a71f6c7280fcb5
--- /dev/null
+++ b/src/mapleall/maple_me/include/meconstprop.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_MECONSTPROP_H
+#define MAPLE_ME_INCLUDE_MECONSTPROP_H
+#include "me_ir.h"
+
+namespace maple {
+class MeConstProp {
+ public:
+  MeConstProp() = default;
+
+  virtual ~MeConstProp() = default;
+  void IntraConstProp() const;
+  void InterConstProp() const;
+};
+
+#ifdef NOT_USED
+class MeDoIntraConstProp : public MeFuncPhase {
+ public:
+  explicit MeDoIntraConstProp(MePhaseID id) : MeFuncPhase(id) {}
+
+  virtual ~MeDoIntraConstProp() = default;
+  AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *frm, ModuleResultMgr *mrm) override;
+  std::string PhaseName() const override {
+    return "intraconstantpropagation";
+  }
+};
+
+class MeDoInterConstProp : public MeFuncPhase {
+ public:
+  explicit MeDoInterConstProp(MePhaseID id) : MeFuncPhase(id) {}
+
+  virtual ~MeDoInterConstProp() = default;
+  AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *frm, ModuleResultMgr *mrm) override;
+  std::string PhaseName() const override {
+    return "interconstantpropagation";
+  }
+};
+#endif
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_MECONSTPROP_H
diff --git a/src/mapleall/maple_me/include/meexpr_use_info.h b/src/mapleall/maple_me/include/meexpr_use_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..68774a97c2d50e6cb67ae791eac8293cd463dac7
--- /dev/null
+++ b/src/mapleall/maple_me/include/meexpr_use_info.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_MEEXPRUSEINFO_H
+#define MAPLE_ME_INCLUDE_MEEXPRUSEINFO_H
+#include "me_ir.h"
+#include "me_function.h"
+
+#include <variant>
+
+namespace maple {
+
+class UseItem final {
+public:
+  explicit UseItem(MeStmt *useStmt) : useNode(useStmt) {}
+  explicit UseItem(MePhiNode *phi) : useNode(phi) {}
+
+  const BB *GetUseBB() const {
+    return std::visit(
+        [this](auto &&arg) {
+          using T = std::decay_t<decltype(arg)>;
+          if constexpr (std::is_same_v<T, MeStmt *>) {
+            return Get<MeStmt>()->GetBB();
+          } else {
+            return Get<MePhiNode>()->GetDefBB();
+          }
+        },
+        useNode);
+  }
+
+  bool IsUseByPhi() const {
+    return std::holds_alternative<MePhiNode *>(useNode);
+  }
+
+  bool IsUseByStmt() const { return std::holds_alternative<MeStmt *>(useNode); }
+
+  const MeStmt *GetStmt() const { return Get<MeStmt>(); }
+  MeStmt *GetStmt() { return Get<MeStmt>(); }
+
+  const MePhiNode *GetPhi() const { return Get<MePhiNode>(); }
+  MePhiNode *GetPhi() { return Get<MePhiNode>(); }
+
+  uint32 GetRef() {
+    return ref;
+  }
+
+  void IncreaseRef() {
+    ref++;
+  }
+
+  bool operator==(const UseItem &other) const {
+    return useNode == other.useNode;
+  }
+  bool operator!=(const UseItem &other) const { return !(*this == other); }
+
+private:
+  template <typename T> const T *Get() const {
+    assert(std::holds_alternative<T *>(useNode) && "Invalid use type.");
+    return std::get<T *>(useNode);
+  }
+  template <typename T> T *Get() {
+    assert(std::holds_alternative<T *>(useNode) && "Invalid use type.");
+    return std::get<T *>(useNode);
+  }
+
+  std::variant<MeStmt *, MePhiNode *> useNode;
+  uint32 ref = 1;
+};
+
+enum MeExprUseInfoState {
+  kUseInfoInvalid = 0,
+  kUseInfoOfScalar = 1,
+  kUseInfoOfAllExpr = 3,
+};
+
+using UseSitesType = MapleList<UseItem>;
+using ExprUseInfoPair = std::pair<MeExpr*, UseSitesType*>;
+class MeExprUseInfo final {
+ public:
+  explicit MeExprUseInfo(MemPool *memPool)
+      : allocator(memPool),
+        useSites(nullptr),
+        useInfoState(kUseInfoInvalid) {}
+
+  ~MeExprUseInfo() {}
+  void CollectUseInfoInFunc(IRMap *irMap, Dominance *domTree, MeExprUseInfoState state);
+  UseSitesType *GetUseSitesOfExpr(const MeExpr *expr) const;
+  const MapleVector<ExprUseInfoPair> &GetUseSites() const {
+    return *useSites;
+  }
+
+  template<class T>
+  void AddUseSiteOfExpr(MeExpr *expr, T *useSite);
+
+  void CollectUseInfoInExpr(MeExpr *expr, MeStmt *stmt);
+  void CollectUseInfoInStmt(MeStmt *stmt);
+  void CollectUseInfoInBB(BB *bb);
+
+  // return true if use sites of scalarA all replaced by scalarB
+  bool ReplaceScalar(IRMap *irMap, const ScalarMeExpr *scalarA, ScalarMeExpr *scalarB);
+
+  MapleVector<ExprUseInfoPair> &GetUseSites() {
+    return *useSites;
+  }
+
+  void SetUseSites(MapleVector<ExprUseInfoPair> *sites) {
+    useSites = sites;
+  }
+
+  void SetState(MeExprUseInfoState state) {
+    useInfoState = state;
+  }
+
+  void InvalidUseInfo() {
+    useInfoState = kUseInfoInvalid;
+  }
+
+  bool IsInvalid() const {
+    return useInfoState == kUseInfoInvalid;
+  }
+
+  bool UseInfoOfScalarIsValid() const {
+    return useInfoState >= kUseInfoOfScalar;
+  }
+
+  bool UseInfoOfAllIsValid() const {
+    return useInfoState == kUseInfoOfAllExpr;
+  }
+
+ private:
+  MapleAllocator allocator;
+  MapleVector<ExprUseInfoPair> *useSites; // index is exprId
+  MeExprUseInfoState useInfoState;
+};
+}  // namespace maple
+#endif //MAPLE_ME_INCLUDE_MEEXPRUSEINFO_H
diff --git a/src/mapleall/maple_me/include/occur.h b/src/mapleall/maple_me/include/occur.h
new file mode 100644
index 0000000000000000000000000000000000000000..a24c969ed01333d4df7b858116a72ded04e9fcd4
--- /dev/null
+++ b/src/mapleall/maple_me/include/occur.h
@@ -0,0 +1,705 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_OCCUR_H
+#define MAPLE_ME_INCLUDE_OCCUR_H
+// the data structures that represent occurrences and work candidates for SSAPRE
+#include "me_function.h"
+#include "irmap.h"
+#include "dominance.h"
+
+namespace maple {
+enum OccType {
+  kOccUndef,
+  kOccReal,
+  kOccPhiocc,
+  kOccPhiopnd,
+  kOccExit,
+  kOccInserted,
+  kOccGcmalloc,
+  kOccUse,     // for use appearances when candidate is dassign
+  kOccMembar,  // for representing occurrence of memory barriers (use MeRealOcc)
+  kOccCompare, // for linear function test replacement (uses MeRealOcc)
+};
+
+class MePhiOcc;
+
+class MeOccur {
+ public:
+  MeOccur(OccType ty, int cId, MeOccur *df) : occTy(ty), classID(cId), mirBB(nullptr), def(df) {}
+  MeOccur(OccType ty, int cId, BB &bb, MeOccur *df) : occTy(ty), classID(cId), mirBB(&bb), def(df) {}
+  virtual ~MeOccur() = default;
+  virtual void Dump(const IRMap &irMap) const;
+  void DumpOccur(IRMap &irMap);
+  bool IsDominate(Dominance &dom, MeOccur &occ);
+  const BB *GetBB() const {
+    return mirBB;
+  }
+
+  BB *GetBB() {
+    return mirBB;
+  }
+
+  void SetBB(BB &bb) {
+    mirBB = &bb;
+  }
+
+  OccType GetOccType() const {
+    return occTy;
+  }
+
+  void SetOccType(OccType occType) {
+    occTy = occType;
+  }
+
+  int GetClassID() const {
+    return classID;
+  }
+
+  void SetClassID(int id) {
+    classID = id;
+  }
+
+  const MeOccur *GetDef() const {
+    return def;
+  }
+
+  MeOccur *GetDef() {
+    return def;
+  }
+
+  void SetDef(MeOccur *define) {
+    def = define;
+  }
+  virtual MeExpr *GetSavedExpr();
+
+ private:
+  OccType occTy;  // kinds of occ
+  int classID;    // class id
+  BB *mirBB;      // the BB it occurs in
+  MeOccur *def;
+};
+
+class MeRealOcc : public MeOccur {
+ public:
+  MeRealOcc(MeStmt *stmt, int sq, MeExpr *expr)
+      : MeOccur(kOccReal, 0, nullptr),
+        meStmt(stmt),
+        meExpr(expr),
+        savedExpr(nullptr),
+        seq(sq),
+        position(0),
+        isReload(false),
+        isSave(false),
+        isLHS(false),
+        isFormalAtEntry(false) {
+    if (stmt != nullptr) {
+      SetBB(*stmt->GetBB());
+    }
+  }
+
+  ~MeRealOcc() = default;
+  void Dump(const IRMap &irMap) const override;
+  const MeStmt *GetMeStmt() const {
+    return meStmt;
+  }
+
+  MeStmt *GetMeStmt() {
+    return meStmt;
+  }
+
+  void SetMeStmt(MeStmt &stmt) {
+    meStmt = &stmt;
+  }
+
+  Opcode GetOpcodeOfMeStmt() const {
+    ASSERT_NOT_NULL(meStmt);
+    return meStmt->GetOp();
+  }
+
+  const MeExpr *GetMeExpr() const {
+    return meExpr;
+  }
+
+  MeExpr *GetMeExpr() {
+    return meExpr;
+  }
+
+  void SetMeExpr(MeExpr &expr) {
+    meExpr = &expr;
+  }
+
+  MeExpr *GetSavedExpr() override {
+    return savedExpr;
+  }
+
+  void SetSavedExpr(MeExpr &expr) {
+    savedExpr = &expr;
+  }
+
+  int GetSequence() const {
+    return seq;
+  }
+
+  void SetSequence(int sequence) {
+    seq = sequence;
+  }
+
+  size_t GetPosition() const {
+    return position;
+  }
+
+  void SetPosition(size_t pos) {
+    position = pos;
+  }
+
+  bool IsReload() const {
+    return isReload;
+  }
+
+  void SetIsReload(bool reload) {
+    isReload = reload;
+  }
+
+  bool IsSave() const {
+    return isSave;
+  }
+
+  void SetIsSave(bool save) {
+    isSave = save;
+  }
+
+  bool IsLHS() const {
+    return isLHS;
+  }
+
+  void SetIsLHS(bool lhs) {
+    isLHS = lhs;
+  }
+
+  bool IsFormalAtEntry() const {
+    return isFormalAtEntry;
+  }
+
+  void SetIsFormalAtEntry(bool isFormal) {
+    isFormalAtEntry = isFormal;
+  }
+
+  bool IsHoisted() const {
+    return isHoisted;
+  }
+
+  void SetIsHoisted(bool val) {
+    isHoisted = val;
+  }
+
+ private:
+  MeStmt *meStmt;     // the stmt that has this occ
+  MeExpr *meExpr;     // the expr it's corresponding to
+  MeExpr *savedExpr;  // the reall occ saved to, must be a VarMeExpr/RegMeExpr
+  int seq;            // meStmt sequence number in the bb
+  size_t position;    // the position in the workCand->realOccs vector
+  bool isReload;
+  bool isSave;
+  bool isLHS;
+  bool isFormalAtEntry;  // the fake lhs occurrence at entry for formals
+  bool isHoisted = false;  // the hoisted occ used for hoisting
+};
+
+class MeInsertedOcc : public MeOccur {
+ public:
+  MeInsertedOcc(MeExpr *expr, MeStmt *stmt, BB &bb)
+      : MeOccur(kOccInserted, 0, bb, nullptr), meExpr(expr), meStmt(stmt), savedExpr(nullptr) {}
+
+  ~MeInsertedOcc() = default;
+  void Dump(const IRMap &irMap) const override;
+  const MeStmt *GetMeStmt() const {
+    return meStmt;
+  }
+
+  MeStmt *GetMeStmt() {
+    return meStmt;
+  }
+
+  void SetMeStmt(MeStmt &stmt) {
+    meStmt = &stmt;
+  }
+
+  Opcode GetOpcodeOfMeStmt() const {
+    ASSERT_NOT_NULL(meStmt);
+    return meStmt->GetOp();
+  }
+
+  const MeExpr *GetMeExpr() const {
+    return meExpr;
+  }
+
+  MeExpr *GetMeExpr() {
+    return meExpr;
+  }
+
+  void SetMeExpr(MeExpr &expr) {
+    meExpr = &expr;
+  }
+
+  MeExpr *GetSavedExpr() override {
+    return savedExpr;
+  }
+
+  void SetSavedExpr(MeExpr &expr) {
+    savedExpr = &expr;
+  }
+
+ private:
+  MeExpr *meExpr;
+  MeStmt *meStmt;
+  MeExpr *savedExpr;
+};
+
+class MePhiOpndOcc : public MeOccur {
+ public:
+  explicit MePhiOpndOcc(BB &bb)
+      : MeOccur(kOccPhiopnd, 0, bb, nullptr),
+        isProcessed(false),
+        hasRealUse(false),
+        isInsertedOcc(false),
+        isPhiOpndReload(false),
+        defPhiOcc(nullptr),
+        phiOpnd4Temp(nullptr) {
+    currentExpr.meStmt = nullptr;
+  }
+
+  ~MePhiOpndOcc() = default;
+  bool IsOkToInsert() const;
+  void Dump(const IRMap &irMap) const override;
+  bool IsProcessed() const {
+    return isProcessed;
+  }
+
+  void SetIsProcessed(bool processed) {
+    isProcessed = processed;
+  }
+
+  bool HasRealUse() const {
+    return hasRealUse;
+  }
+
+  void SetHasRealUse(bool realUse) {
+    hasRealUse = realUse;
+  }
+
+  bool IsInsertedOcc() const {
+    return isInsertedOcc;
+  }
+
+  void SetIsInsertedOcc(bool inserted) {
+    isInsertedOcc = inserted;
+  }
+
+  bool IsPhiOpndReload() const {
+    return isPhiOpndReload;
+  }
+
+  void SetIsPhiOpndReload(bool phiOpndReload) {
+    isPhiOpndReload = phiOpndReload;
+  }
+
+  const MePhiOcc *GetDefPhiOcc() const {
+    return defPhiOcc;
+  }
+
+  MePhiOcc *GetDefPhiOcc() {
+    return defPhiOcc;
+  }
+
+  void SetDefPhiOcc(MePhiOcc &occ) {
+    defPhiOcc = &occ;
+  }
+
+  const MeExpr *GetCurrentMeExpr() const {
+    return currentExpr.meExpr;
+  }
+
+  MeExpr *GetCurrentMeExpr() {
+    return currentExpr.meExpr;
+  }
+
+  void SetCurrentMeExpr(MeExpr &expr) {
+    currentExpr.meExpr = &expr;
+  }
+
+  const MeStmt *GetCurrentMeStmt() const {
+    return currentExpr.meStmt;
+  }
+
+  MeStmt *GetCurrentMeStmt() {
+    return currentExpr.meStmt;
+  }
+
+  void SetCurrentMeStmt(MeStmt &stmt) {
+    currentExpr.meStmt = &stmt;
+  }
+
+ private:
+  bool isProcessed;
+  bool hasRealUse;
+  bool isInsertedOcc;    // the phi operand was inserted by inserted occ
+  bool isPhiOpndReload;  // if insertedocc and redefined the def, set this flag
+  MePhiOcc *defPhiOcc;   // its lhs
+  union {
+    MeExpr *meExpr;  // the current expression at the end of the block containing this PhiOpnd
+    MeStmt *meStmt;  // which will be inserted during finalize
+  } currentExpr;
+ public:
+  MeExpr *phiOpnd4Temp; // must be a VarMeExpr/RegMeExpr, set in CodeMotion phase
+};
+
+class MePhiOcc : public MeOccur {
+ public:
+  MePhiOcc(BB &bb, MapleAllocator &alloc)
+      : MeOccur(kOccPhiocc, 0, bb, nullptr),
+        isDownSafe(!bb.GetAttributes(kBBAttrIsCatch)),
+        speculativeDownSafe(false),
+        isCanBeAvail(true),
+        isLater(true),
+        isExtraneous(false),
+        isRemoved(false),
+        phiOpnds(alloc.Adapter()),
+        regPhi(nullptr),
+        varPhi(nullptr) {}
+
+  virtual ~MePhiOcc() = default;
+  bool IsWillBeAvail() const {
+    return isCanBeAvail && !isLater;
+  }
+
+  bool IsDownSafe() const {
+    return isDownSafe;
+  }
+
+  void SetIsDownSafe(bool downSafe) {
+    isDownSafe = downSafe;
+  }
+
+  bool SpeculativeDownSafe() const {
+    return speculativeDownSafe;
+  }
+
+  void SetSpeculativeDownSafe(bool downSafe) {
+    speculativeDownSafe = downSafe;
+  }
+
+  bool IsCanBeAvail() const {
+    return isCanBeAvail;
+  }
+
+  void SetIsCanBeAvail(bool canBeAvail) {
+    isCanBeAvail = canBeAvail;
+  }
+
+  bool IsLater() const {
+    return isLater;
+  }
+
+  void SetIsLater(bool later) {
+    isLater = later;
+  }
+
+  bool IsExtraneous() const {
+    return isExtraneous;
+  }
+
+  void SetIsExtraneous(bool extra) {
+    isExtraneous = extra;
+  }
+
+  bool IsRemoved() const {
+    return isRemoved;
+  }
+
+  void SetIsRemoved(bool removed) {
+    isRemoved = removed;
+  }
+
+  const MapleVector<MePhiOpndOcc*> &GetPhiOpnds() const {
+    return phiOpnds;
+  }
+
+  MapleVector<MePhiOpndOcc*> &GetPhiOpnds() {
+    return phiOpnds;
+  }
+
+  MePhiOpndOcc *GetPhiOpnd(size_t idx) {
+    ASSERT(idx < phiOpnds.size(), "out of range in MePhiOcc::GetPhiOpnd");
+    return phiOpnds.at(idx);
+  }
+
+  const MePhiOpndOcc *GetPhiOpnd(size_t idx) const {
+    ASSERT(idx < phiOpnds.size(), "out of range in MePhiOcc::GetPhiOpnd");
+    return phiOpnds.at(idx);
+  }
+
+  void AddPhiOpnd(MePhiOpndOcc &opnd) {
+    phiOpnds.push_back(&opnd);
+  }
+
+  const MePhiNode *GetRegPhi() const {
+    return regPhi;
+  }
+
+  MePhiNode *GetRegPhi() {
+    return regPhi;
+  }
+
+  void SetRegPhi(MePhiNode &phi) {
+    regPhi = &phi;
+  }
+
+  const MePhiNode *GetVarPhi() const {
+    return varPhi;
+  }
+
+  MePhiNode *GetVarPhi() {
+    return varPhi;
+  }
+
+  void SetVarPhi(MePhiNode &phi) {
+    varPhi = &phi;
+  }
+
+  bool IsOpndDefByRealOrInserted() const;
+  void Dump(const IRMap &irMap) const;
+
+ private:
+  bool isDownSafe;           // default is true
+  bool speculativeDownSafe;  // is downsafe due to speculation
+  bool isCanBeAvail;
+  bool isLater;
+  bool isExtraneous;
+  bool isRemoved;  // during finalize2, marked this phiocc is removed or not
+  MapleVector<MePhiOpndOcc*> phiOpnds;
+  MePhiNode *regPhi;  // the reg phi being inserted, maybe can delete it later
+  MePhiNode *varPhi;  // the Var phi being inserted, maybe can delete it later
+};
+
+// each singly linked list repersents each bucket in workCandHashTable
+class PreWorkCand {
+ public:
+  PreWorkCand(MapleAllocator &alloc, MeExpr *meExpr, PUIdx pIdx)
+      : next(nullptr),
+        realOccs(alloc.Adapter()),
+        theMeExpr(meExpr),
+        puIdx(pIdx),
+        hasLocalOpnd(false),
+        redo2HandleCritEdges(false),
+        needLocalRefVar(false),
+        isSRCand(false),
+        onlyInvariantOpnds(false),
+        deletedFromWorkList(false) {
+    ASSERT(pIdx != 0, "PreWorkCand: initial puIdx cannot be 0");
+  }
+
+  virtual ~PreWorkCand() = default;
+  void Dump(const IRMap &irMap) const {
+    irMap.GetSSATab().GetModule().GetOut() << "========index: " << index << " has the following occ\n";
+    for (MeOccur *occ : realOccs) {
+      occ->Dump(irMap);
+    }
+  }
+
+  void AddRealOccAsLast(MeRealOcc &occ, PUIdx pIdx) {
+    realOccs.push_back(&occ);  // add as last
+    ASSERT(pIdx != 0, "puIdx of realocc cannot be 0");
+    if (pIdx != puIdx) {
+      ASSERT(!hasLocalOpnd, "candidate with local opnd cannot have real occurrences in more than one PU");
+      puIdx = 0;
+    }
+  }
+
+  void AddRealOccSorted(const Dominance &dom, MeRealOcc &occ, PUIdx pIdx);
+  PrimType GetPrimType() const {
+    ASSERT_NOT_NULL(theMeExpr);
+    PrimType pTyp = theMeExpr->GetPrimType();
+    CHECK_FATAL(pTyp != kPtyInvalid, "invalid primtype");
+    return pTyp;
+  }
+
+  virtual void DumpCand(IRMap &irMap) const {
+    ASSERT_NOT_NULL(theMeExpr);
+    theMeExpr->Dump(&irMap);
+  }
+
+  const PreWorkCand *GetNext() const {
+    return next;
+  }
+
+  PreWorkCand *GetNext() {
+    return next;
+  }
+
+  void SetNext(PreWorkCand &workCand) {
+    next = &workCand;
+  }
+
+  int32 GetIndex() const {
+    return index;
+  }
+
+  void SetIndex(int idx) {
+    index = idx;
+  }
+
+  const MapleVector<MeRealOcc*> &GetRealOccs() const {
+    return realOccs;
+  }
+
+  MapleVector<MeRealOcc*> &GetRealOccs() {
+    return realOccs;
+  }
+
+  const MeRealOcc *GetRealOcc(size_t idx) const {
+    ASSERT(idx < realOccs.size(), "out of range in PreWorkCand::GetRealOccAt");
+    return realOccs.at(idx);
+  }
+
+  MeRealOcc *GetRealOcc(size_t idx) {
+    ASSERT(idx < realOccs.size(), "out of range in PreWorkCand::GetRealOccAt");
+    return realOccs.at(idx);
+  }
+
+  const MeExpr *GetTheMeExpr() const {
+    return theMeExpr;
+  }
+
+  MeExpr *GetTheMeExpr() {
+    return theMeExpr;
+  }
+
+  void SetTheMeExpr(MeExpr &expr) {
+    theMeExpr = &expr;
+  }
+
+  PUIdx GetPUIdx() const {
+    return puIdx;
+  }
+
+  void SetPUIdx(PUIdx idx) {
+    puIdx = idx;
+  }
+
+  bool HasLocalOpnd() const {
+    return hasLocalOpnd;
+  }
+
+  void SetHasLocalOpnd(bool has) {
+    hasLocalOpnd = has;
+  }
+
+  bool Redo2HandleCritEdges() const {
+    return redo2HandleCritEdges;
+  }
+
+  void SetRedo2HandleCritEdges(bool redo) {
+    redo2HandleCritEdges = redo;
+  }
+
+  bool NeedLocalRefVar() const {
+    return needLocalRefVar;
+  }
+
+  void SetNeedLocalRefVar(bool need) {
+    needLocalRefVar = need;
+  }
+
+ private:
+  void InsertRealOccAt(MeRealOcc &occ, const MapleVector<MeRealOcc*>::iterator it, PUIdx pIdx);
+  PreWorkCand *next;
+  int32 index = 0;
+  MapleVector<MeRealOcc*> realOccs;  // maintained in order of dt_preorder
+  MeExpr *theMeExpr;                 // the expression of this workcand
+  PUIdx puIdx;                       // if 0, its occ span multiple PUs; initial value must
+  // not be 0; if set to 0, will be stuck at 0
+  bool hasLocalOpnd : 1;  // true if any opnd in the expression is local
+  // puIdx cannot be 0 if hasLocalOpnd is true
+  bool redo2HandleCritEdges : 1;  // redo to make critical edges affect canbevail
+  bool needLocalRefVar : 1;       // for the candidate, if necessary to introduce
+                                  // localrefvar in addition to the temp register to for saving the value
+ public:
+  bool isSRCand : 1;                // is a strength reduction candidate
+  bool onlyInvariantOpnds : 1;      // all operands have only 1 SSA version
+  bool deletedFromWorkList : 1;     // processed by SSAPRE already
+};
+
+class PreStmtWorkCand : public PreWorkCand {
+ public:
+  PreStmtWorkCand(MapleAllocator &alloc, MeStmt &meStmt, PUIdx pIdx)
+      : PreWorkCand(alloc, nullptr, pIdx), theMeStmt(&meStmt), lhsIsFinal(false) {}
+
+  virtual ~PreStmtWorkCand() = default;
+
+  void DumpCand(IRMap &irMap) const override {
+    theMeStmt->Dump(&irMap);
+  }
+
+  const MeStmt *GetTheMeStmt() const {
+    return theMeStmt;
+  }
+
+  MeStmt *GetTheMeStmt() {
+    return theMeStmt;
+  }
+
+  void SetTheMeStmt(MeStmt &stmt) {
+    theMeStmt = &stmt;
+  }
+
+  bool LHSIsFinal() const {
+    return lhsIsFinal;
+  }
+
+  void SetLHSIsFinal(bool isFinal) {
+    lhsIsFinal = isFinal;
+  }
+
+ private:
+  MeStmt *theMeStmt;  // the statement of this workcand
+  bool lhsIsFinal;    // used only if candidate is an assignment
+};
+
+class PreWorkCandHashTable {
+ public:
+  static const uint32 workCandHashLength = 229;
+  static uint32 ComputeWorkCandHashIndex(const MeExpr &meExpr);
+  static uint32 ComputeStmtWorkCandHashIndex(const MeStmt &stmt);
+
+  PreWorkCandHashTable() = default;
+  ~PreWorkCandHashTable() = default;
+
+  std::array<PreWorkCand*, workCandHashLength> &GetWorkcandHashTable() {
+    return workCandHashTable;
+  }
+
+  PreWorkCand *GetWorkcandFromIndex(size_t idx) {
+    return workCandHashTable[idx];
+  }
+
+  void SetWorkCandAt(size_t idx, PreWorkCand &workCand) {
+    workCandHashTable[idx] = &workCand;
+  }
+
+ private:
+  std::array<PreWorkCand*, workCandHashLength> workCandHashTable;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_OCCUR_H
diff --git a/src/mapleall/maple_me/include/optimizeCFG.h b/src/mapleall/maple_me/include/optimizeCFG.h
new file mode 100644
index 0000000000000000000000000000000000000000..885e4ef9d5b6e2d0e1fd71ee0f2938f6e318973c
--- /dev/null
+++ b/src/mapleall/maple_me/include/optimizeCFG.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_OPTIMIZECFG_H
+#define MAPLE_ME_INCLUDE_OPTIMIZECFG_H
+#include "me_function.h"
+#include "maple_phase.h"
+namespace maple {
+// contains only one valid goto me stmt
+bool HasOnlyMeGotoStmt(BB &bb);
+// contains only one valid goto mpl stmt
+bool HasOnlyMplGotoStmt(BB &bb);
+
+// contains only one valid condgoto me stmt
+bool HasOnlyMeCondGotoStmt(BB &bb);
+// contains only one valid condgoto mpl stmt
+bool HasOnlyMplCondGotoStmt(BB &bb);
+
+// contains no valid me stmt
+bool IsMeEmptyBB(BB &bb);
+// contains no valid mpl stmt
+bool IsMplEmptyBB(BB &bb);
+
+// pred-connecting-succ
+// connectingBB has only one pred and succ, and has no me stmt (except a single gotoStmt) in it
+bool IsConnectingBB(BB &bb);
+
+// RealSucc is a non-connecting BB which is not empty (or has just a single gotoStmt).
+// If we want to find the non-empty succ of currBB, we start from the succ (i.e. the argument)
+// skip those connecting bb used to connect its pred and succ, like: pred -- connecting -- succ
+BB *FindFirstRealSucc(BB *succ, const BB *stopBB = nullptr);
+
+// RealPred is a non-connecting BB which is not empty (or has just a single gotoStmt).
+// If we want to find the non-empty pred of currBB, we start from the pred (i.e. the argument)
+// skip those connecting bb used to connect its pred and succ, like: pred -- connecting -- succ
+// func will stop at first non-connecting BB or stopBB
+BB *FindFirstRealPred(BB *pred, const BB *stopBB = nullptr);
+
+int GetRealPredIdx(BB &succ, const BB &realPred);
+int GetRealSuccIdx(BB &pred, const BB &realSucc);
+// delete all empty bb used to connect its pred and succ, like: pred -- empty -- empty -- succ
+// the result after this will be : pred -- succ
+// if no empty exist, return;
+// we will stop at stopBB(stopBB will not be deleted), if stopBB is nullptr, means no constraint
+void EliminateEmptyConnectingBB(const BB *predBB, BB *emptyBB, const BB *stopBB, MeCFG &cfg);
+
+// Does bb have fallthru pred, including fallthruBB and condBB's fallthru target
+bool HasFallthruPred(const BB &bb);
+
+inline void RemoveBBLable(BB &bb) {
+  bb.SetBBLabel(0);
+}
+
+// phase for MPLIR, without SSA info
+MAPLE_FUNC_PHASE_DECLARE(MEOptimizeCFGNoSSA, MeFunction)
+// phase for MEIR, should maintain ssa info and split critical edge
+MAPLE_FUNC_PHASE_DECLARE(MEOptimizeCFG, MeFunction)
+
+} // namespace maple
+#endif // MAPLE_ME_INCLUDE_OPTIMIZECFG_H
diff --git a/src/mapleall/maple_me/include/orig_symbol.h b/src/mapleall/maple_me/include/orig_symbol.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c67b93543ce4741eaa3b49e62398d5f2e127bfc
--- /dev/null
+++ b/src/mapleall/maple_me/include/orig_symbol.h
@@ -0,0 +1,529 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_ORIG_SYMBOL_H
+#define MAPLE_ME_INCLUDE_ORIG_SYMBOL_H
+#include "mir_module.h"
+#include "mir_symbol.h"
+#include "mir_preg.h"
+#include "mir_function.h"
+#include "mpl_number.h"
+#include "class_hierarchy.h"
+
+// This file defines the data structure OriginalSt that represents a program
+// symbol occurring in the code of the program being optimized.
+namespace maple {
+class OStTag;
+using OStIdx = utils::Index<OStTag, uint32>;
+
+constexpr int kInitVersion = 0;
+class VarMeExpr;  // circular dependency exists, no other choice
+class VersionSt;  // circular dependency exists, no other choice
+class OriginalSt {
+ public:
+  struct OriginalStPtrComparator {
+    bool operator()(const OriginalSt *x, const OriginalSt *y) const {
+      return x->GetIndex() < y->GetIndex();
+    }
+  };
+
+  OriginalSt(uint32 index, PregIdx rIdx, PUIdx pIdx, MapleAllocator &alloc)
+      : OriginalSt(OStIdx(index), alloc, true, false, 0, pIdx, kPregOst, false, { .pregIdx = rIdx }) {}
+
+  OriginalSt(uint32 index, MIRSymbol &mirSt, PUIdx pIdx, FieldID fieldID, MapleAllocator &alloc)
+      : OriginalSt(OStIdx(index), alloc, mirSt.IsLocal(), mirSt.GetStorageClass() == kScFormal, fieldID, pIdx,
+                   kSymbolOst, mirSt.IgnoreRC(), { .mirSt = &mirSt }) {}
+
+  ~OriginalSt() = default;
+
+  void Dump() const;
+  PregIdx GetPregIdx() const {
+    ASSERT(ostType == kPregOst, "OriginalSt must be PregOst");
+    return symOrPreg.pregIdx;
+  }
+
+  MIRPreg *GetMIRPreg() const {
+    ASSERT(ostType == kPregOst, "OriginalSt must be PregOst");
+    return GlobalTables::GetGsymTable().GetModule()->CurFunction()->GetPregTab()->PregFromPregIdx(symOrPreg.pregIdx);
+  }
+
+  MIRSymbol *GetMIRSymbol() const {
+    ASSERT(ostType == kSymbolOst, "OriginalSt must be SymbolOst");
+    return symOrPreg.mirSt;
+  }
+
+  bool HasAttr(AttrKind attrKind) const {
+    if (ostType == kSymbolOst) {
+      TypeAttrs typeAttr = symOrPreg.mirSt->GetAttrs();
+      if (typeAttr.GetAttr(attrKind)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool HasOneElemSimdAttr() const {
+    if (ostType == kSymbolOst) {
+      TypeAttrs typeAttr = symOrPreg.mirSt->GetAttrs();
+      if (typeAttr.GetAttr(ATTR_oneelem_simd)) {
+        return true;
+      }
+      if (fieldID != 0) {
+        auto type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(symOrPreg.mirSt->GetTyIdx());
+        if (type->IsMIRArrayType()) {
+          type = static_cast<MIRArrayType*>(type)->GetElemType();
+        }
+        if (!type->IsMIRStructType()) {
+          return false;
+        }
+        MIRStructType *structType = static_cast<MIRStructType*>(type);
+        FieldAttrs fattrs = structType->GetFieldAttrs(fieldID);
+        if (fattrs.GetAttr(FLDATTR_oneelem_simd)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  bool IsLocal() const {
+    return isLocal;
+  }
+
+  bool IsFormal() const {
+    return isFormal;
+  }
+  void SetIsFormal(bool val) {
+    this->isFormal = val;
+  }
+
+  bool IsFinal() const {
+    return isFinal;
+  }
+  void SetIsFinal(bool val = true) {
+    this->isFinal = val;
+  }
+
+  bool IsPrivate() const {
+    return isPrivate;
+  }
+  void SetIsPrivate(bool val) {
+    this->isPrivate = val;
+  }
+
+  bool IsVolatile() const {
+    return (ostType == kSymbolOst) ? symOrPreg.mirSt->IsVolatile() : false;
+  }
+
+  bool IsVrNeeded() const {
+    return (ostType == kSymbolOst) ? symOrPreg.mirSt->GetIsTmp() : false;
+  }
+
+  bool Equal(const OriginalSt &ost) const;
+
+  bool IsRealSymbol() const {
+    return (ostType == kSymbolOst || ostType == kPregOst);
+  }
+
+  bool IsSymbolOst() const {
+    return ostType == kSymbolOst;
+  }
+
+  bool IsPregOst() const {
+    return (ostType == kPregOst);
+  }
+
+  bool IsSpecialPreg() const {
+    return ostType == kPregOst && symOrPreg.pregIdx < 0;
+  }
+
+  bool IsSameSymOrPreg(const OriginalSt *ost) const {
+    if (ostType != ost->ostType) {
+      return false;
+    }
+    if (IsSymbolOst()) {
+      return symOrPreg.mirSt == ost->symOrPreg.mirSt;
+    }
+    return symOrPreg.pregIdx == ost->symOrPreg.pregIdx;
+  }
+
+  int8 GetIndirectLev() const {
+    return indirectLev;
+  }
+
+  void SetIndirectLev(int8 level) {
+    indirectLev = level;
+  }
+
+  OStIdx GetIndex() const {
+    return index;
+  }
+
+  size_t GetVersionIndex(size_t version) const {
+    ASSERT(version < versionsIndices.size(), "version out of range");
+    return versionsIndices.at(version);
+  }
+
+  const MapleVector<size_t> &GetVersionsIndices() const {
+    return versionsIndices;
+  }
+  void PushbackVersionsIndices(size_t versionIndex) {
+    versionsIndices.push_back(versionIndex);
+  }
+
+  size_t GetZeroVersionIndex() const {
+    return zeroVersionIndex;
+  }
+
+  void SetZeroVersionIndex(size_t zeroVersionIndexParam) {
+    zeroVersionIndex = zeroVersionIndexParam;
+  }
+
+  const TyIdx &GetTyIdx() const {
+    return tyIdx;
+  }
+
+  void SetTyIdx(TyIdx tyIdxPara) {
+    tyIdx = tyIdxPara;
+  }
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(FieldID fieldIndex) {
+    this->fieldID = fieldIndex;
+  }
+
+  const OffsetType &GetOffset() const {
+    return offset;
+  }
+
+  void SetOffset(const OffsetType &offsetVal) {
+    offset = offsetVal;
+  }
+
+  bool IsIgnoreRC() const {
+    return ignoreRC;
+  }
+
+  bool IsAddressTaken() const {
+    return addressTaken;
+  }
+
+  void SetAddressTaken(bool addrTaken = true) {
+    addressTaken = addrTaken;
+  }
+
+  // current ost can not be define by MayDef, or used by mayUse
+  bool IsTopLevelOst() const;
+
+  bool IsEPreLocalRefVar() const {
+    return epreLocalRefVar;
+  }
+
+  void SetEPreLocalRefVar(bool epreLocalrefvarPara = true) {
+    epreLocalRefVar = epreLocalrefvarPara;
+  }
+
+  PUIdx GetPuIdx() const {
+    return puIdx;
+  }
+
+  bool IsIVCandidate() const {
+    if (indirectLev != 0 ||
+        (IsSymbolOst() && GetMIRSymbol()->GetName() == "__nads_dummysym__")) {
+      return false;
+    }
+    MIRType *mirtype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    if (IsPrimitiveInteger(mirtype->GetPrimType()) && (mirtype->GetKind() != kTypeBitField)) {
+      // additional check using MIRSymbol's tyIdx
+      if (IsSymbolOst()) {
+        return IsPrimitiveInteger(GetMIRSymbol()->GetType()->GetPrimType());
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  MIRType *GetType() const {
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  }
+
+  const OriginalSt *GetPrevLevelOst() const {
+    return prevLevOst;
+  }
+
+  OriginalSt *GetPrevLevelOst() {
+    return prevLevOst;
+  }
+
+  size_t GetPointerVstIdx() const {
+    return pointerVstIdx;
+  }
+
+  const TyIdx &GetPointerTyIdx() const {
+    if (tyIdxOfPointer == 0 && prevLevOst != nullptr) {
+      return prevLevOst->GetTyIdx();
+    }
+    return tyIdxOfPointer;
+  }
+
+  MIRType *GetPrevLevelPointerType() const {
+    auto ptrTyIdx = GetPointerTyIdx();
+    CHECK_FATAL(ptrTyIdx != 0, "No ptr-type variable points to current ost");
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTyIdx);
+  }
+
+  void SetPointerTyIdx(const TyIdx &idx) {
+    tyIdxOfPointer = idx;
+  }
+
+  void SetPointerVst(const VersionSt *vst);
+
+  uint32 NumSSAVersions() const {
+    if (zeroVersionIndex == 0 || !IsPregOst()) {
+      return static_cast<uint32>(versionsIndices.size());
+    }
+    return static_cast<uint32>(versionsIndices.size()) - 1;  // preg's zero version not counted
+  }
+  bool isPtrWithIncDec = false;  // is a pointer with self-increment/decrement
+  bool storesIVInitValue = false; // temp created to store IV's initial value
+
+ private:
+  enum OSTType {
+    kUnkonwnOst,
+    kSymbolOst,
+    kPregOst
+  };
+  union SymOrPreg {
+    PregIdx pregIdx;
+    MIRSymbol *mirSt;
+  };
+  OriginalSt(OStIdx index, MapleAllocator &alloc, bool local, bool isFormal, FieldID fieldID, PUIdx pIdx,
+      OSTType ostType, bool ignoreRC, SymOrPreg sysOrPreg)
+      : ostType(ostType),
+        index(index),
+        versionsIndices(alloc.Adapter()),
+        fieldID(fieldID),
+        offset(kOffsetUnknown),
+        isLocal(local),
+        isFormal(isFormal),
+        ignoreRC(ignoreRC),
+        symOrPreg(sysOrPreg),
+        puIdx(pIdx) {}
+
+  OSTType ostType;
+  OStIdx index;                       // index number in originalStVector
+  MapleVector<size_t> versionsIndices;  // the i-th element refers the index of versionst in versionst table
+  size_t zeroVersionIndex = 0;            // same as versionsIndices[0]
+  TyIdx tyIdx{ 0 };             // type of this symbol at this level; 0 for unknown
+  FieldID fieldID;                    // at each level of indirection
+  OffsetType offset;                  // bit offset
+  int8 indirectLev = 0;               // level of indirection; -1 for address, 0 for itself
+  bool isLocal;                       // get from defined stmt or use expr
+  bool isFormal;  // it's from the formal parameters so the type must be kSymbolOst or kPregOst after rename2preg
+  bool addressTaken = false;
+  bool isFinal = false;          // if the field has final attribute, only when fieldID != 0
+  bool isPrivate = false;        // if the field has private attribute, only when fieldID != 0
+  bool ignoreRC = false;         // base on MIRSymbol's IgnoreRC()
+  bool epreLocalRefVar = false;  // is a localrefvar temp created by epre phase
+  SymOrPreg symOrPreg;
+  PUIdx puIdx;
+  size_t pointerVstIdx = 0;
+  OriginalSt *prevLevOst = nullptr;
+  TyIdx tyIdxOfPointer{0}; // TyIdx of the pointer of virtual-ost
+};
+
+class SymbolFieldPair {
+ public:
+  SymbolFieldPair(const StIdx &stIdx, FieldID fld, const TyIdx &tyIdx,
+                  const OffsetType &offset = OffsetType(kOffsetUnknown))
+      : stIdx(stIdx), fldIDAndOffset((static_cast<int64>(offset.val) << 32U) + fld), tyIdx(tyIdx) {}
+  ~SymbolFieldPair() = default;
+  bool operator==(const SymbolFieldPair& pairA) const {
+    return (pairA.stIdx == stIdx) && (pairA.fldIDAndOffset == fldIDAndOffset) && (tyIdx == pairA.tyIdx);
+  }
+
+  const StIdx &GetStIdx() const {
+    return stIdx;
+  }
+
+  FieldID GetFieldID() const {
+    return static_cast<FieldID>(fldIDAndOffset);
+  }
+
+ private:
+  StIdx stIdx;
+  int64 fldIDAndOffset;
+  TyIdx tyIdx;
+};
+
+struct HashSymbolFieldPair {
+  size_t operator()(const SymbolFieldPair& symbolFldID) const {
+    return symbolFldID.GetStIdx().FullIdx();
+  }
+};
+
+// This Table is for original symobols only. There is no SSA info attached and SSA is built based on this table.
+class OriginalStTable {
+ public:
+  OriginalStTable(MemPool &memPool, MIRModule &mod);
+  ~OriginalStTable() = default;
+
+  using OriginalStContainer = MapleVector<OriginalSt*>;
+  using VstIdx2NextLevelOsts = MapleVector<OriginalStContainer*>;
+  using OriginalStIterator = OriginalStContainer::iterator;
+  using ConstOriginalStIterator = OriginalStContainer::const_iterator;
+
+  OriginalSt *FindOrCreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld);
+  std::pair<OriginalSt*, bool> FindOrCreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld,
+      const TyIdx &tyIdx, const OffsetType &offset = OffsetType(kOffsetUnknown));
+  OriginalSt *CreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld, const TyIdx &tyIdx,
+                                     const OffsetType &offset = OffsetType(kOffsetUnknown));
+  OriginalSt *FindOrCreatePregOriginalSt(PregIdx pregIdx, PUIdx puIdx);
+  OriginalSt *CreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx pidx, FieldID fld);
+  OriginalSt *CreatePregOriginalSt(PregIdx pregIdx, PUIdx puIdx);
+  OriginalSt *FindSymbolOriginalSt(const MIRSymbol &mirSt, FieldID fld, const TyIdx &tyIdx,
+                                   const OffsetType &offset);
+  OriginalSt *FindSymbolOriginalSt(const MIRSymbol &mirSt);
+  const OriginalSt *GetOriginalStFromID(OStIdx id, bool checkFirst = false) const {
+    if (checkFirst && id >= originalStVector.size()) {
+      return nullptr;
+    }
+    ASSERT(id < originalStVector.size(), "symbol table index out of range");
+    return originalStVector[id];
+  }
+  OriginalSt *GetOriginalStFromID(OStIdx id, bool checkFirst = false) {
+    return const_cast<OriginalSt *>(const_cast<const OriginalStTable*>(this)->GetOriginalStFromID(id, checkFirst));
+  }
+
+  size_t Size() const {
+    return originalStVector.size();
+  }
+
+  const MIRSymbol *GetMIRSymbolFromOriginalSt(const OriginalSt &ost) const {
+    ASSERT(ost.IsRealSymbol(), "runtime check error");
+    return ost.GetMIRSymbol();
+  }
+
+  const MIRSymbol *GetMIRSymbolFromID(OStIdx id) const {
+    return GetOriginalStFromID(id, false)->GetMIRSymbol();
+  }
+  MIRSymbol *GetMIRSymbolFromID(OStIdx id) {
+    auto *originalSt = GetOriginalStFromID(id, false);
+    CHECK_FATAL(originalSt, "originalSt is nullptr!");
+    return originalSt->GetMIRSymbol();
+  }
+
+  MapleAllocator &GetAlloc() {
+    return alloc;
+  }
+
+  MapleVector<OriginalSt*> &GetOriginalStVector() {
+    return originalStVector;
+  }
+
+  void SetEPreLocalRefVar(const OStIdx &id, bool epreLocalrefvarPara = true) {
+    ASSERT(id < originalStVector.size(), "symbol table index out of range");
+    originalStVector[id]->SetEPreLocalRefVar(epreLocalrefvarPara);
+  }
+
+  void SetZeroVersionIndex(const OStIdx &id, size_t zeroVersionIndexParam) {
+    ASSERT(id < originalStVector.size(), "symbol table index out of range");
+    originalStVector[id]->SetZeroVersionIndex(zeroVersionIndexParam);
+  }
+
+  size_t GetVersionsIndicesSize(const OStIdx &id) const {
+    ASSERT(id < originalStVector.size(), "symbol table index out of range");
+    return originalStVector[id]->GetVersionsIndices().size();
+  }
+
+  void UpdateVarOstMap(const OStIdx &id, std::map<OStIdx, OriginalSt*> &varOstMap) {
+    ASSERT(id < originalStVector.size(), "symbol table index out of range");
+    varOstMap[id] = originalStVector[id];
+  }
+
+  ConstOriginalStIterator begin() const {
+    auto it = originalStVector.begin();
+    // self-inc resulting from the fact that the 1st element is reserved and set null.
+    ++it;
+    return it;
+  }
+
+  OriginalStIterator begin() {
+    auto it = originalStVector.begin();
+    // self-inc resulting from the fact that the 1st element is reserved and set null.
+    ++it;
+    return it;
+  }
+
+  ConstOriginalStIterator end() const {
+    return originalStVector.end();
+  }
+
+  OriginalStIterator end() {
+    return originalStVector.end();
+  }
+
+  void Dump();
+  OriginalSt *FindOrCreateAddrofSymbolOriginalSt(OriginalSt *ost);
+  OriginalSt *FindOrCreateExtraLevOriginalSt(const VersionSt *vst, const TyIdx &ptyIdx, FieldID fld,
+                                             const OffsetType &offset = OffsetType(kOffsetUnknown));
+  OriginalSt *FindOrCreateExtraLevSymOrRegOriginalSt(const VersionSt *vst, TyIdx tyIdx, FieldID fld,
+                                                     const OffsetType &offset = OffsetType(kOffsetUnknown),
+                                                     const KlassHierarchy *klassHierarchy = nullptr);
+  OriginalSt *FindExtraLevOriginalSt(const MapleVector<OriginalSt*> &nextLevelOsts,
+                                     const TyIdx &tyIdxOfPtr, const MIRType *type, FieldID fld,
+                                     const OffsetType &offset = OffsetType(kOffsetUnknown)) const;
+  OriginalSt *FindExtraLevOriginalSt(const VersionSt *vst, const TyIdx &tyIdxOfPtr,
+                                     const MIRType *typeOfOst, FieldID fld,
+                                     const OffsetType &offset = OffsetType(kOffsetUnknown)) const;
+  MapleVector<OriginalSt*> *GetNextLevelOstsOfVst(size_t vstIdx) const;
+  MapleVector<OriginalSt*> *GetNextLevelOstsOfVst(const VersionSt *vst) const;
+  void AddNextLevelOstOfVst(size_t vstIdx, OriginalSt *ost);
+  void AddNextLevelOstOfVst(const VersionSt *vst, OriginalSt *ost);
+ private:
+  MapleAllocator alloc;
+  MIRModule &mirModule;
+  MapleVector<OriginalSt*> originalStVector;  // the vector that map a OriginalSt's index to its pointer
+  // mir symbol to original table, this only exists for no-original variables.
+ public:
+  MapleUnorderedMap<SymbolFieldPair, OStIdx, HashSymbolFieldPair> mirSt2Ost;
+  MapleUnorderedMap<StIdx, OStIdx> addrofSt2Ost;
+ private:
+  MapleUnorderedMap<PregIdx, OStIdx> preg2Ost;
+  // mir type to virtual variables in original table. this only exists for no-original variables.
+  MapleMap<TyIdx, OStIdx> pType2Ost;
+  // malloc info to virtual variables in original table. this only exists for no-original variables.
+  MapleMap<std::pair<BaseNode*, uint32>, OStIdx> malloc2Ost;
+  MapleMap<uint32, OStIdx> thisField2Ost;  // field of this_memory to virtual variables in original table.
+  VstIdx2NextLevelOsts nextLevelOstsOfVst; // index is VersionSt index.
+  OStIdx virtuaLostUnkownMem{ 0 };
+  OStIdx virtuaLostConstMem{ 0 };
+};
+
+using OstPtrSet = std::set<OriginalSt *, OriginalSt::OriginalStPtrComparator>;
+}  // namespace maple
+
+namespace std {
+template <>
+struct hash<maple::OStIdx> {
+  size_t operator()(const maple::OStIdx &x) const {
+    return static_cast<size_t>(x);
+  }
+};
+}  // namespace std
+#endif  // MAPLE_ME_INCLUDE_ORIG_SYMBOL_H
diff --git a/src/mapleall/maple_me/include/pme_emit.h b/src/mapleall/maple_me/include/pme_emit.h
new file mode 100644
index 0000000000000000000000000000000000000000..895f1f1256298e405be738387d44719e9cb4a4aa
--- /dev/null
+++ b/src/mapleall/maple_me/include/pme_emit.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_PME_EMIT_H
+#define MAPLE_ME_INCLUDE_PME_EMIT_H
+#include "mir_nodes.h"
+#include "me_irmap_build.h"
+#include "ipa_collect.h"
+
+namespace maple {
+class PreMeEmitter : public AnalysisResult {
+ public:
+  PreMeEmitter(MeIRMap *hmap, PreMeFunction *f, MemPool *premp)
+      : AnalysisResult(premp), meirmap(hmap),
+        preMeFunc(f),
+        mirFunc(f->meFunc->GetMirFunc()),
+        codeMP(f->meFunc->GetMirFunc()->GetCodeMempool()),
+        codeMPAlloc(&f->meFunc->GetMirFunc()->GetCodeMemPoolAllocator()),
+        preMeMP(premp),
+        preMeMPAlloc(preMeMP),
+        preMeStmtExtensionMap(preMeMPAlloc.Adapter()),
+        preMeExprExtensionMap(preMeMPAlloc.Adapter()),
+        cfg(f->meFunc->GetCfg()) {}
+  virtual ~PreMeEmitter() = default;
+  uint32 EmitPreMeBB(uint32 curJ, BlockNode *curBlk);
+  void SetPreMeStmtExtension(uint32_t stmtID, PreMeMIRExtension* pmeExt) {
+    preMeStmtExtensionMap[stmtID] = pmeExt;
+  }
+  void SetPreMeExprExtension(BaseNode *expr, PreMeMIRExtension* pmeExt) {
+    preMeExprExtensionMap[expr] = pmeExt;
+  }
+  PreMeMIRExtension* GetPreMeExprExtension(BaseNode *node) {
+    return preMeExprExtensionMap[node];
+  }
+  PreMeMIRExtension* GetPreMeStmtExtension(uint32_t stmtID) {
+    return preMeStmtExtensionMap[stmtID];
+  }
+  BaseNode *GetParent(BaseNode *node) {
+    PreMeMIRExtension *pmeExt = preMeExprExtensionMap[node];
+    if (pmeExt != nullptr) {
+      return pmeExt->parent;
+    }
+    return nullptr;
+  }
+  BaseNode *GetParent(uint32_t stmtID) {
+    PreMeMIRExtension *pmeExt = preMeStmtExtensionMap[stmtID];
+    if (pmeExt != nullptr) {
+      return pmeExt->parent;
+    }
+    return nullptr;
+  }
+  MeExpr *GetMexpr(BaseNode *node) {
+    MapleMap<BaseNode *, PreMeMIRExtension *>::iterator it = preMeExprExtensionMap.find(node);
+    if (it == preMeExprExtensionMap.end()) {
+      return nullptr;
+    }
+    PreMeMIRExtension *pmeExt = it->second;
+    ASSERT_NOT_NULL(pmeExt);
+    return pmeExt->meexpr;
+  }
+  MeStmt *GetMeStmt(uint32_t stmtID) {
+    PreMeMIRExtension *pmeExt = preMeStmtExtensionMap[stmtID];
+    return pmeExt->mestmt;
+  }
+  MIRFunction *GetMirFunction() { return mirFunc; }
+  MeIRMap *GetMeIRMap() { return meirmap; }
+  MemPool *GetCodeMP()  { return codeMP; }
+  MapleAllocator* GetCodeMPAlloc() { return codeMPAlloc; }
+  MapleMap<uint32_t, PreMeMIRExtension *> *GetPreMeStmtExtensionMap() { return &preMeStmtExtensionMap; }
+  MapleMap<BaseNode *, PreMeMIRExtension *> *GetPreMeExprExtensionMap() { return &preMeExprExtensionMap; }
+  FuncProfInfo *GetFuncProfData() { return mirFunc->GetFuncProfData(); }
+  void SetIpaInfo(CollectIpaInfo *info) { ipaInfo = info; }
+  void UpdateStmtInfo(const MeStmt &meStmt, StmtNode &stmt, BlockNode &currBlock, uint64 frequency);
+  void UpdateStmtInfoForLabelNode(LabelNode &label, BB &bb);
+ private:
+  ArrayNode *ConvertToArray(BaseNode *x, TyIdx ptrTyIdx);
+  BaseNode *EmitPreMeExpr(MeExpr *meExpr, BaseNode *parent);
+  StmtNode* EmitPreMeStmt(MeStmt *meStmt, BaseNode *parent);
+  void EmitBB(BB *bb, BlockNode *curBlk);
+  DoloopNode *EmitPreMeDoloop(BB *meWhileBB, BlockNode *curBlk, PreMeWhileInfo *whileInfo);
+  WhileStmtNode *EmitPreMeWhile(BB *meWhileBB, BlockNode *curBlk);
+  uint32 Raise2PreMeWhile(uint32 curJ, BlockNode *curBlk);
+  uint32 Raise2PreMeIf(uint32 curJ, BlockNode *curBlk);
+
+  MeIRMap *meirmap;
+  PreMeFunction *preMeFunc;
+  MIRFunction *mirFunc;
+  MemPool *codeMP;
+  MapleAllocator *codeMPAlloc;
+  MemPool *preMeMP;
+  MapleAllocator preMeMPAlloc;
+  MapleMap<uint32_t, PreMeMIRExtension*> preMeStmtExtensionMap; // key is stmtID
+  MapleMap<BaseNode*, PreMeMIRExtension*> preMeExprExtensionMap; // key is BaseNode*
+  MeCFG *cfg;
+  CollectIpaInfo *ipaInfo = nullptr;
+};
+
+/* emit ir to specified file */
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(MEPreMeEmission, MeFunction)
+  void SetIpaInfo(MIRFunction &mirFunc);
+  PreMeEmitter *GetResult() {
+    return emitter;
+  }
+  PreMeEmitter *emitter = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_FUNC_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_PME_EMIT_H
diff --git a/src/mapleall/maple_me/include/pme_function.h b/src/mapleall/maple_me/include/pme_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5d711b455fa679abfc1daad865df1dc39c0c22e
--- /dev/null
+++ b/src/mapleall/maple_me/include/pme_function.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_PME_FUNCTION_H
+#define MAPLE_ME_INCLUDE_PME_FUNCTION_H
+#include "pme_mir_extension.h"
+#include "me_ir.h"
+
+namespace maple {
+class MeFunction;
+
+class PreMeWhileInfo {
+ public:
+  MIRSymbol *injectedIVSym = nullptr;   // the injected IV
+  OriginalSt *ivOst = nullptr;          // the primary IV
+  MeExpr *initExpr = nullptr;
+  int32 stepValue = 0;
+  MeExpr *tripCount = nullptr;
+  bool canConvertDoloop = false;
+};
+
+class PreMeIfInfo {
+ public:
+  LabelIdx endLabel = 0;   // the label that is out of the if statement
+  LabelIdx elseLabel = 0;  // the label that is the begin of else branch
+};
+
+class PreMeFunction {
+ public:
+  MemPool *pmemp;
+  MapleAllocator pmeAlloc;
+  MeFunction *meFunc;
+  // key is label at beginning of lowered while code sequence
+  MapleMap<LabelIdx, PreMeWhileInfo*> label2WhileInfo;
+  // key is target label of first conditional branch of lowered if code sequence
+  MapleMap<LabelIdx, PreMeIfInfo*> label2IfInfo;
+  // for the labels that were created by PreMe, we won't emit it
+  MapleSet<LabelIdx> pmeCreatedIfLabelSet;
+  MapleSet<LabelIdx> pmeCreatedWhileLabelSet;
+
+  PreMeFunction(MemPool *mp, MeFunction *func)
+      : pmemp(mp),
+        pmeAlloc(mp),
+        meFunc(func),
+        label2WhileInfo(pmeAlloc.Adapter()),
+        label2IfInfo(pmeAlloc.Adapter()),
+        pmeCreatedIfLabelSet(pmeAlloc.Adapter()),
+        pmeCreatedWhileLabelSet(pmeAlloc.Adapter()) {}
+  virtual ~PreMeFunction() = default;
+
+  void SetIfLabelCreatedByPreMe(LabelIdx lbidx) {
+    pmeCreatedIfLabelSet.insert(lbidx);
+  }
+
+  bool IfLabelCreatedByPreMe(LabelIdx lbidx) const {
+    return pmeCreatedIfLabelSet.count(lbidx) != 0;
+  }
+
+  void SetWhileLabelCreatedByPreMe(LabelIdx lbidx) {
+    pmeCreatedWhileLabelSet.insert(lbidx);
+  }
+
+  bool WhileLabelCreatedByPreMe(LabelIdx lbidx) const {
+    return pmeCreatedWhileLabelSet.count(lbidx) != 0;
+  }
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_PME_FUNCTION_H
diff --git a/src/mapleall/maple_me/include/pme_mir_extension.h b/src/mapleall/maple_me/include/pme_mir_extension.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b80f60f189002354293626cccce55461727d6af
--- /dev/null
+++ b/src/mapleall/maple_me/include/pme_mir_extension.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_PME_MIR_EXTENSION_H_
+#define MAPLE_ME_INCLUDE_PME_MIR_EXTENSION_H_
+#include "me_ir.h"
+#include "mir_nodes.h"
+
+namespace maple {
+class PreMeMIRExtension {
+ public:
+  BaseNode *parent;
+  union {
+    MeExpr *meexpr;
+    MeStmt *mestmt;
+  };
+
+  explicit PreMeMIRExtension (BaseNode *p) : parent(p), meexpr(nullptr) {}
+  PreMeMIRExtension (BaseNode *p, MeExpr *expr) : parent(p), meexpr(expr) {}
+  PreMeMIRExtension (BaseNode *p, MeStmt *stmt) : parent(p), mestmt(stmt) {}
+  virtual ~PreMeMIRExtension() = default;
+  BaseNode *GetParent() { return parent; }
+  MeExpr *GetMeExpr()   { return meexpr; }
+  MeStmt *GetMeStmt()   { return mestmt; }
+  void SetParent(BaseNode *p) { parent = p; }
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_PME_MIR_EXTENSION_H_
diff --git a/src/mapleall/maple_me/include/pme_mir_lower.h b/src/mapleall/maple_me/include/pme_mir_lower.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f16553c67bfefe81a5fbaaaa9d5a6402cea4a6b
--- /dev/null
+++ b/src/mapleall/maple_me/include/pme_mir_lower.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_PME_MIR_LOWER_H
+#define MAPLE_ME_INCLUDE_PME_MIR_LOWER_H
+#include "mir_lower.h"
+#include "me_function.h"
+namespace maple {
+class PreMeMIRLower : public MIRLower {
+ public:
+  MeFunction *func;
+  PreMeFunction *preMeFunc;
+
+  PreMeMIRLower(MIRModule &mod, MeFunction *f)
+      : MIRLower(mod, f->GetMirFunc()),
+        func(f),
+        preMeFunc(f->GetPreMeFunc()) {}
+  virtual ~PreMeMIRLower() = default;
+
+  BlockNode *LowerWhileStmt(WhileStmtNode &whileStmt) override;
+  BlockNode *LowerIfStmt(IfStmtNode &ifstmt, bool recursive = true) override;
+  bool InLFO() const override { return true; }
+};
+}
+#endif  // MAPLE_ME_INCLUDE_PME_MIR_LOWER_H
diff --git a/src/mapleall/maple_me/include/preg_renamer.h b/src/mapleall/maple_me/include/preg_renamer.h
new file mode 100644
index 0000000000000000000000000000000000000000..4af3ef92f9aa2765c333bf2a7aabc71ab88789a0
--- /dev/null
+++ b/src/mapleall/maple_me/include/preg_renamer.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEME_INCLUDE_ME_PREGRENAMER_H
+#define MAPLEME_INCLUDE_ME_PREGRENAMER_H
+#include "ssa_pre.h"
+
+namespace maple {
+class PregRenamer {
+ public:
+  PregRenamer(MemPool *mp, MeFunction *f, MeIRMap *hmap) : mp(mp), alloc(mp), func(f), meirmap(hmap) {}
+  virtual ~PregRenamer() = default;
+  void RunSelf();
+
+ private:
+  std::string PhaseName() const {
+    return "pregrename";
+  }
+
+  MemPool *mp;
+  MapleAllocator alloc;
+  MeFunction *func;
+  MeIRMap *meirmap;
+};
+
+MAPLE_FUNC_PHASE_DECLARE(MEPregRename, MeFunction)
+}  // namespace maple
+#endif  // MAPLEME_INCLUDE_ME_PREGRENAMER_H
diff --git a/src/mapleall/maple_me/include/prop.h b/src/mapleall/maple_me/include/prop.h
new file mode 100644
index 0000000000000000000000000000000000000000..f194c90af8321737fb10a7b7ab586d807fed5608
--- /dev/null
+++ b/src/mapleall/maple_me/include/prop.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_PROP_H
+#define MAPLE_ME_INCLUDE_PROP_H
+#include <stack>
+#include "me_ir.h"
+#include "ver_symbol.h"
+#include "bb.h"
+#include "me_function.h"
+#include "dominance.h"
+#include "irmap.h"
+#include "safe_ptr.h"
+#include "me_ssa_update.h"
+
+namespace maple {
+
+enum Propagatability {
+  kPropNo,
+  kPropOnlyWithInverse,
+  kPropYes,
+};
+
+class Prop {
+ public:
+  struct PropConfig {
+    bool propagateBase;
+    bool propagateIloadRef;
+    bool propagateGlobalRef;
+    bool propagateFinalIloadRef;
+    bool propagateIloadRefNonParm;
+    bool propagateAtPhi;
+    bool propagateWithInverse;
+  };
+
+  Prop(IRMap &irMap, Dominance &dom, Dominance &pdom, MemPool &memPool, uint32 bbvecsize, const PropConfig &config,
+       uint32 limit = UINT32_MAX);
+  virtual ~Prop() = default;
+
+  MeExpr *CheckTruncation(MeExpr *lhs, MeExpr *rhs) const;
+  MeExpr &TryPropUnionVar(VarMeExpr &var);
+  MeExpr &PropVar(VarMeExpr &varMeExpr, bool atParm, bool checkPhi);
+  MeExpr &PropReg(RegMeExpr &regMeExpr, bool atParm, bool checkPhi);
+  MeExpr &TryPropUnionIvar(IvarMeExpr &ivar);
+  MeExpr &PropIvar(IvarMeExpr &ivarMeExpr);
+  void ReplaceVstLiveStackTop(size_t ostIdx, MeExpr &newTopExpr);
+  void PropUpdateDef(MeExpr &meExpr);
+  void PropUpdateChiListDef(const MapleMap<OStIdx, ChiMeNode*> &chiList);
+  void PropUpdateMustDefList(MeStmt *mestmt);
+  void TraversalBB(BB &bb);
+  size_t GetVstLiveStackVecSize() const {
+    return vstLiveStackVec.size();
+  }
+
+  MapleStack<MeExpr *> *GetVstLiveStackVec(size_t i) {
+    return vstLiveStackVec[i];
+  }
+
+  void GrowVstLiveStack();
+
+  void RecoverVstLiveStack();
+
+  void SetCurBB(BB *bb) {
+    curBB = bb;
+  }
+
+  bool NoPropUnionAggField(const MeStmt *meStmt, const StmtNode *stmt /* for irmap */, const MeExpr *propedRHS) const;
+
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &CandsForSSAUpdate() {
+    return candsForSSAUpdate;
+  }
+
+  uint32 propLimit;
+  uint32 propsPerformed = 0;    // count number of copy propagations performed
+  bool isLfo = false;           // true during LFO phases
+
+ protected:
+  virtual void UpdateCurFunction(BB&) const {
+  }
+
+  virtual bool LocalToDifferentPU(StIdx, const BB&) const {
+    return false;
+  }
+
+  Dominance &dom;
+  Dominance &pdom;
+
+  virtual MeExpr &PropMeExpr(MeExpr &meExpr, bool &isProped, bool atParm);
+
+  virtual BB *GetBB(BBId) {
+    return nullptr;
+  }
+
+  ScalarMeExpr *CreateTmpAssignForIassignRHS(IvarMeExpr &ivarMeExpr, IassignMeStmt &defStmt);
+
+  void PropEqualExpr(const MeExpr *replacedExpr, ConstMeExpr *constExpr, BB *fromBB);
+  void PropConditionBranchStmt(MeStmt *condBranchStmt);
+  virtual void TraversalMeStmt(MeStmt &meStmt);
+  void CollectSubVarMeExpr(const MeExpr &meExpr, std::vector<const MeExpr*> &varVec) const;
+  bool IsVersionConsistent(const std::vector<const MeExpr*> &vstVec,
+                           const MapleVector<MapleStack<MeExpr *> *> &vstLiveStack) const;
+  bool IvarIsFinalField(const IvarMeExpr &ivarMeExpr) const;
+  bool CanBeReplacedByConst(const MIRSymbol &symbol) const;
+  int32 InvertibleOccurrences(ScalarMeExpr *scalar, MeExpr *x);
+  bool IsFunctionOfCurVersion(ScalarMeExpr *scalar, const ScalarMeExpr *cur);
+  Propagatability Propagatable(MeExpr *x, BB *fromBB, bool atParm, bool checkInverse = false,
+                               ScalarMeExpr *propagatingScalar = nullptr);
+  MeExpr *FormInverse(ScalarMeExpr *v, MeExpr *x, MeExpr *formingExp);
+  MeExpr *RehashUsingInverse(MeExpr *x);
+
+  void RecordSSAUpdateCandidate(const OStIdx &ostIdx, const BB &bb) {
+    MeSSAUpdate::InsertOstToSSACands(ostIdx, bb, &candsForSSAUpdate);
+  }
+
+  IRMap &irMap;
+  SSATab &ssaTab;
+  MIRModule &mirModule;
+  MapleAllocator propMapAlloc;
+  MapleVector<MapleStack<MeExpr *> *> vstLiveStackVec;
+  std::vector<bool> bbVisited;  // needed because dominator tree is a DAG in wpo
+  BB *curBB = nullptr;          // gives the bb of the traversal
+  PropConfig config;
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> candsForSSAUpdate;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_PROP_H
diff --git a/src/mapleall/maple_me/include/propiloadlist.def b/src/mapleall/maple_me/include/propiloadlist.def
new file mode 100644
index 0000000000000000000000000000000000000000..e190ccf9667a83a5ff98c3f51be5527c6594eded
--- /dev/null
+++ b/src/mapleall/maple_me/include/propiloadlist.def
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FPackageParser_3B_7CgeneratePackageInfo_7C_28Landroid_2Fcontent_2Fpm_2FPackageParser_24Package_3BAIIJJLjava_2Futil_2FSet_3BLandroid_2Fcontent_2Fpm_2FPackageUserState_3BI_29Landroid_2Fcontent_2Fpm_2FPackageInfo_3B)
+PROPILOAD(Landroid_2Futil_2FArraySet_3B_7Cadd_7C_28Ljava_2Flang_2FObject_3B_29Z)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CfilterAppAccessLPr_7C_28Lcom_2Fandroid_2Fserver_2Fpm_2FPackageSetting_3BILandroid_2Fcontent_2FComponentName_3BII_29Z)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FPackageUserState_3B_7CisEnabled_7C_28Landroid_2Fcontent_2Fpm_2FComponentInfo_3BI_29Z)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FPackageParser_3B_7CgenerateActivityInfo_7C_28Landroid_2Fcontent_2Fpm_2FPackageParser_24Activity_3BILandroid_2Fcontent_2Fpm_2FPackageUserState_3BI_29Landroid_2Fcontent_2Fpm_2FActivityInfo_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CgeneratePackageInfo_7C_28Lcom_2Fandroid_2Fserver_2Fpm_2FPackageSetting_3BII_29Landroid_2Fcontent_2Fpm_2FPackageInfo_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CgetApplicationInfoInternal_7C_28Ljava_2Flang_2FString_3BIII_29Landroid_2Fcontent_2Fpm_2FApplicationInfo_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CgetInstalledApplications_7C_28II_29Landroid_2Fcontent_2Fpm_2FParceledListSlice_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CfilterSharedLibPackageLPr_7C_28Lcom_2Fandroid_2Fserver_2Fpm_2FPackageSetting_3BIII_29Z)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FPackageParser_3B_7CcopyNeeded_7C_28ILandroid_2Fcontent_2Fpm_2FPackageParser_24Package_3BLandroid_2Fcontent_2Fpm_2FPackageUserState_3BLandroid_2Fos_2FBundle_3BI_29Z)
+//PROPILOAD(Landroid_2Fapp_2FAppGlobals_3B_7CgetPackageManager_7C_28_29Landroid_2Fcontent_2Fpm_2FIPackageManager_3B)
+PROPILOAD(Landroid_2Futil_2FArraySet_3B_7CremoveAt_7C_28I_29Ljava_2Flang_2FObject_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CunregisterReceiver_7C_28Landroid_2Fcontent_2FIIntentReceiver_3B_29V)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fam_2FActiveServices_3B_7CbringDownServiceLocked_7C_28Lcom_2Fandroid_2Fserver_2Fam_2FServiceRecord_3B_29V)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fam_2FActiveServices_3B_7CunbindServiceLocked_7C_28Landroid_2Fapp_2FIServiceConnection_3B_29Z)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fam_2FActiveServices_3B_7CrealStartServiceLocked_7C_28Lcom_2Fandroid_2Fserver_2Fam_2FServiceRecord_3BLcom_2Fandroid_2Fserver_2Fam_2FProcessRecord_3BZ_29V)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fam_2FActiveServices_3B_7CremoveConnectionLocked_7C_28Lcom_2Fandroid_2Fserver_2Fam_2FConnectionRecord_3BLcom_2Fandroid_2Fserver_2Fam_2FProcessRecord_3BLcom_2Fandroid_2Fserver_2Fam_2FActivityRecord_3B_29V)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fam_2FActiveServices_3B_7CgetRunningServiceInfoLocked_7C_28IIIZZ_29Ljava_2Futil_2FList_3B)
+
+// for P version
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CresolveInternalPackageNameLPr_7C_28Ljava_2Flang_2FString_3BJ_29Ljava_2Flang_2FString_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fam_2FActiveServices_3B_7CretrieveServiceLocked_7C_28Landroid_2Fcontent_2FIntent_3BLjava_2Flang_2FString_3BLjava_2Flang_2FString_3BIIIZZZZ_29Lcom_2Fandroid_2Fserver_2Fam_2FActiveServices_24ServiceLookupResult_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2FHwPackageManagerService_3B_7CqueryIntentActivitiesInternal_7C_28Landroid_2Fcontent_2FIntent_3BLjava_2Flang_2FString_3BIIIZZ_29Ljava_2Futil_2FList_3B)
+// for P version
+
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FPackageInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FActivityInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FComponentInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FApplicationInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FActivityInfo_3B_7CtoString_7C_28_29Ljava_2Flang_2FString_3B)
+//PROPILOAD(Landroid_2Fcontent_2Fpm_2FPackageParser_3B_7CgenerateApplicationInfo_7C_28Landroid_2Fcontent_2Fpm_2FPackageParser_24Package_3BILandroid_2Fcontent_2Fpm_2FPackageUserState_3BI_29Landroid_2Fcontent_2Fpm_2FApplicationInfo_3B)
+
+PROPILOAD(Landroid_2Fapp_2FActivityManager_24RecentTaskInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fapp_2FActivityManager_24RunningAppProcessInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fapp_2FActivityManager_24RunningTaskInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fapp_2FActivityManager_24TaskDescription_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fapp_2FAppOpsManager_24PackageOps_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fapp_2FContentProviderHolder_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fapp_2Fservertransaction_2FClientTransaction_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fapp_2Fservertransaction_2FLaunchActivityItem_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fapp_2FWindowConfiguration_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2FComponentName_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2FIntent_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2FIntentFilter_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FPackageItemInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FPermissionInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FProviderInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FResolveInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FServiceInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FUserInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2Fres_2FConfiguration_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fnet_2FNetworkInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fnet_2FNetworkTemplate_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fnet_2FUri_24HierarchicalUri_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fnet_2FUri_24OpaqueUri_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fos_2FLocaleList_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fos_2FMessage_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fos_2FParcelFileDescriptor_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fos_2FPersistableBundle_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fos_2Fstorage_2FStorageVolume_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Frms_2Fconfig_2FResourceConfig_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fsecurity_2Fkeymaster_2FKeymasterArguments_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Futil_2FMergedConfiguration_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fview_2FDisplayCutout_24ParcelableWrapper_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fview_2FDisplayInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fview_2FInputDevice_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fview_2Finputmethod_2FEditorInfo_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fview_2FSurface_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Lcom_2Fandroid_2Finternal_2Fview_2FInputBindResult_3B_7CwriteToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V)
+PROPILOAD(Landroid_2Fcontent_2FComponentName_3B_7CwriteToParcel_7C_28Landroid_2Fcontent_2FComponentName_3BLandroid_2Fos_2FParcel_3B_29V)
+PROPILOAD(Landroid_2Ftext_2FTextUtils_3B_7CwriteToParcel_7C_28Ljava_2Flang_2FCharSequence_3BLandroid_2Fos_2FParcel_3BI_29V)
+// for #2899
+PROPILOAD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B_7CgetAdditional_7C_28II_29I)
+PROPILOAD(Landroid_2Ficu_2Futil_2FCaseInsensitiveString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z)
+
+PROPILOAD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B_7CcontainsNone_7C_28II_29Z)
+PROPILOAD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B_7CgetRangeStart_7C_28I_29I)
+PROPILOAD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B_7CgetRangeEnd_7C_28I_29I)
+PROPILOAD(Landroid_2Ficu_2Fimpl_2FTrie2__16_3B_7Cget_7C_28I_29I)
+PROPILOAD(Landroid_2Ficu_2Fimpl_2FTrie2__16_3B_7CrangeEnd_7C_28III_29I)
+
+PROPILOAD(Llibcore_2Finternal_2FStringPool_3B_7Cget_7C_28ACII_29Ljava_2Flang_2FString_3B)
+PROPILOAD(Landroid_2Futil_2FArrayMap_241_3B_7CcolGetEntry_7C_28II_29Ljava_2Flang_2FObject_3B)
+PROPILOAD(Landroid_2Futil_2FArrayMap_3B_7Cput_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B)
+PROPILOAD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B_7CfillBuffer_7C_28I_29Z)
+PROPILOAD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B_7CreadValue_7C_28CZZLcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_24ValueContext_3B_29Ljava_2Flang_2FString_3B)
+PROPILOAD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B_7CreadName_7C_28_29Ljava_2Flang_2FString_3B)
+PROPILOAD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B_7CparseStartTag_7C_28ZZ_29V)
+PROPILOAD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B_7CgetAttributeValue_7C_28I_29Ljava_2Flang_2FString_3B)
+PROPILOAD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B_7CgetAttributeValue_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B)
+PROPILOAD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B_7CpeekCharacter_7C_28_29I)
+PROPILOAD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B_7Cskip_7C_28_29V)
+PROPILOAD(Lcom_2Fandroid_2Finternal_2Fapp_2FProcessMap_3B_7Cget_7C_28Ljava_2Flang_2FString_3BI_29Ljava_2Flang_2FObject_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2Fpermission_2FPermissionsState_3B_7CgetPermissions_7C_28I_29Ljava_2Futil_2FSet_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2Fpermission_2FPermissionSettings_3B_7CgetPermissionLocked_7C_28Ljava_2Flang_2FString_3B_29Lcom_2Fandroid_2Fserver_2Fpm_2Fpermission_2FBasePermission_3B)
+PROPILOAD(Landroid_2Futil_2FArraySet_241_3B_7CcolGetEntry_7C_28II_29Ljava_2Flang_2FObject_3B)
+PROPILOAD(Lcom_2Fandroid_2Fserver_2Fpm_2FComponentResolver_24ActivityIntentResolver_3B_7CallowFilterResult_7C_28Landroid_2Fcontent_2Fpm_2FPackageParser_24ActivityIntentInfo_3BLjava_2Futil_2FList_3B_29Z)
+PROPILOAD(Landroid_2Fwidget_2FTextView_3B_7ConMeasure_7C_28II_29V)
+PROPILOAD(Landroid_2Fwidget_2FTextView_3B_7CgetExtendedPaddingTop_7C_28_29I)
+PROPILOAD(Landroid_2Fwidget_2FTextView_3B_7CgetBaseline_7C_28_29I)
+PROPILOAD(Landroid_2Fwidget_2FRelativeLayout_3B_7ConMeasure_7C_28II_29V)
+PROPILOAD(Landroid_2Fwidget_2FRelativeLayout_3B_7CgetRelatedView_7C_28AII_29Landroid_2Fview_2FView_3B)
+PROPILOAD(Landroid_2Fwidget_2FRelativeLayout_24LayoutParams_3B_7ChasRelativeRules_7C_28_29Z)
+PROPILOAD(Landroid_2Fview_2FViewGroup_3B_7CgetChildAt_7C_28I_29Landroid_2Fview_2FView_3B)
+PROPILOAD(Landroid_2Fview_2FView_3B_7Cmeasure_7C_28II_29V)
+PROPILOAD(Landroid_2Fcontent_2FContextWrapper_3B_7CgetApplicationInfo_7C_28_29Landroid_2Fcontent_2Fpm_2FApplicationInfo_3B)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CcountSpans_7C_28IILjava_2Flang_2FClass_3BI_29I)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CgetSpansRec_7C_28IILjava_2Flang_2FClass_3BIALjava_2Flang_2FObject_3BAIAIIZ_29I)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7Clength_7C_28_29I)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CnextSpanTransitionRec_7C_28IILjava_2Flang_2FClass_3BI_29I)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CrestoreInvariants_7C_28_29V)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CgetSpanStart_7C_28Ljava_2Flang_2FObject_3B_29I)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CgetSpanEnd_7C_28Ljava_2Flang_2FObject_3B_29I)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7Cchange_7C_28IILjava_2Flang_2FCharSequence_3BII_29V)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CsendToSpanWatchers_7C_28III_29V)
+PROPILOAD(Landroid_2Ftext_2FTextLine_3B_7ChandleRun_7C_28IIIZLandroid_2Fgraphics_2FCanvas_3BFIIILandroid_2Fgraphics_2FPaint_24FontMetricsInt_3BZ_29F)
+PROPILOAD(Landroid_2Ftext_2FSpanSet_3B_7Cinit_7C_28Landroid_2Ftext_2FSpanned_3BII_29V)
+PROPILOAD(Landroid_2Ftext_2FMeasuredParagraph_3B_7CapplyMetricsAffectingSpan_7C_28Landroid_2Ftext_2FTextPaint_3BALandroid_2Ftext_2Fstyle_2FMetricAffectingSpan_3BIILandroid_2Fgraphics_2Ftext_2FMeasuredText_24Builder_3B_29V)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7Cobtain_7C_28I_29AI)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CsetSpan_7C_28ZLjava_2Flang_2FObject_3BIIIZ_29V)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CcalcMax_7C_28I_29I)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CgetSpanFlags_7C_28Ljava_2Flang_2FObject_3B_29I)
+PROPILOAD(Landroid_2Ftext_2FSpannableStringBuilder_3B_7CsiftDown_7C_28IALjava_2Flang_2FObject_3BIAIAI_29V)
+PROPILOAD(Ljava_2Futil_2FHashMap_3B_7CgetNode_7C_28ILjava_2Flang_2FObject_3B_29Ljava_2Futil_2FHashMap_24Node_3B)
+PROPILOAD(Lsun_2Fmisc_2FCleaner_3B_7Cremove_7C_28Lsun_2Fmisc_2FCleaner_3B_29Z)
+PROPILOAD(Lcom_2Fandroid_2Finternal_2Futil_2FArrayUtils_3B_7CemptyArray_7C_28Ljava_2Flang_2FClass_3B_29ALjava_2Flang_2FObject_3B)
+PROPILOAD(Landroid_2Fgraphics_2FPaint_3B_7CsetClassVariablesFrom_7C_28Landroid_2Fgraphics_2FPaint_3B_29V)
+PROPILOAD(Landroid_2Ftext_2FSpanSet_3B_7CgetNextTransition_7C_28II_29I)
+PROPILOAD(Ljava_2Futil_2FCalendar_3B_7CsetFieldsComputed_7C_28I_29V)
+PROPILOAD(Ljava_2Futil_2FCalendar_3B_7CinternalSet_7C_28II_29V)
+PROPILOAD(Landroid_2Fcontent_2Fres_2FResources_3B_7CgetConfiguration_7C_28_29Landroid_2Fcontent_2Fres_2FConfiguration_3B)
+PROPILOAD(Landroid_2Fcontent_2Fres_2FResources_24ThemeKey_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z)
+PROPILOAD(Landroid_2Fview_2FContextThemeWrapper_3B_7CgetResourcesInternal_7C_28_29Landroid_2Fcontent_2Fres_2FResources_3B)
+PROPILOAD(Landroid_2Ftext_2FAutoGrowArray_24IntArray_3B_7Cappend_7C_28I_29V)
+PROPILOAD(Landroid_2Ftext_2FAutoGrowArray_24IntArray_3B_7CensureCapacity_7C_28I_29V)
+PROPILOAD(Landroid_2Futil_2FLongSparseArray_3B_7Cget_7C_28JLjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B)
+PROPILOAD(Landroid_2Ftext_2FMeasuredParagraph_3B_7CbuildForStaticLayout_7C_28Landroid_2Ftext_2FTextPaint_3BLjava_2Flang_2FCharSequence_3BIILandroid_2Ftext_2FTextDirectionHeuristic_3BZZLandroid_2Ftext_2FMeasuredParagraph_3BLandroid_2Ftext_2FMeasuredParagraph_3B_29Landroid_2Ftext_2FMeasuredParagraph_3B)
+PROPILOAD(Landroid_2Ftext_2FStaticLayout_3B_7Cgenerate_7C_28Landroid_2Ftext_2FStaticLayout_24Builder_3BZZ_29V)
+PROPILOAD(Landroid_2Ftext_2FStaticLayout_3B_7Cout_7C_28Ljava_2Flang_2FCharSequence_3BIIIIIIIFFALandroid_2Ftext_2Fstyle_2FLineHeightSpan_3BAILandroid_2Fgraphics_2FPaint_24FontMetricsInt_3BZIZLandroid_2Ftext_2FMeasuredParagraph_3BIZZZACILandroid_2Ftext_2FTextUtils_24TruncateAt_3BFFLandroid_2Ftext_2FTextPaint_3BZ_29I)
+PROPILOAD(Landroid_2Fcontent_2Fpm_2FActivityInfo_3B_7CactivityInfoConfigNativeToJava_7C_28I_29I)
+PROPILOAD(Landroid_2Fos_2FMessageQueue_3B_7CremoveMessages_7C_28Landroid_2Fos_2FHandler_3BILjava_2Flang_2FObject_3B_29V)
+PROPILOAD(Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_3B_7CgetEntry_7C_28Ljava_2Flang_2FThreadLocal_3B_29Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B)
+PROPILOAD(Landroid_2Futil_2FPools_24SimplePool_3B_7CisInPool_7C_28Ljava_2Flang_2FObject_3B_29Z)
+PROPILOAD(Landroid_2Fgraphics_2Fdrawable_2FDrawable_3B_7CgetCallback_7C_28_29Landroid_2Fgraphics_2Fdrawable_2FDrawable_24Callback_3B)
+PROPILOAD(Landroid_2Fview_2FView_3B_7CensureTransformationInfo_7C_28_29V)
+PROPILOAD(Landroid_2Fview_2FView_3B_7ConVisibilityAggregated_7C_28Z_29V)
+PROPILOAD(Landroid_2Fview_2FViewGroup_3B_7CdispatchCollectViewAttributes_7C_28Landroid_2Fview_2FView_24AttachInfo_3BI_29V)
+PROPILOAD(Landroid_2Fview_2FViewGroup_3B_7CdispatchVisibilityAggregated_7C_28Z_29Z)
+PROPILOAD(Landroid_2Fview_2FViewGroup_3B_7CdispatchGetDisplayList_7C_28_29V)
+PROPILOAD(Landroid_2Fview_2FViewGroup_3B_7CinvalidateChild_7C_28Landroid_2Fview_2FView_3BLandroid_2Fgraphics_2FRect_3B_29V)
+PROPILOAD(Landroid_2Fview_2FViewGroup_3B_7ConDescendantInvalidated_7C_28Landroid_2Fview_2FView_3BLandroid_2Fview_2FView_3B_29V)
+PROPILOAD(Landroid_2Fsupport_2Fv7_2Fwidget_2FChildHelper_3B_7CgetOffset_7C_28I_29I)
diff --git a/src/mapleall/maple_me/include/seqvec.h b/src/mapleall/maple_me/include/seqvec.h
new file mode 100644
index 0000000000000000000000000000000000000000..dd9e9f5d35c3c13cc87dc69ed9077dfc181af152
--- /dev/null
+++ b/src/mapleall/maple_me/include/seqvec.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021-2022] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_SEQVEC_H
+#define MAPLE_ME_INCLUDE_SEQVEC_H
+#include "me_function.h"
+#include "me_irmap.h"
+#include "me_ir.h"
+#include "pme_emit.h"
+
+namespace maple {
+class SeqVectorize {
+  using StoreList = MapleVector<IassignNode *>;
+  using StoreListMap = MapleMap<MeExpr *, StoreList *>;
+ public:
+  SeqVectorize(MemPool *localmp, PreMeEmitter *lfoEmit, bool debug = false)
+      : localMP(localmp), localAlloc(localmp),
+        codeMP(lfoEmit->GetCodeMP()), codeMPAlloc(lfoEmit->GetCodeMPAlloc()),
+        mirFunc(lfoEmit->GetMirFunction()),
+        meIRMap(lfoEmit->GetMeIRMap()),
+        stores(localAlloc.Adapter()), enableDebug(debug) {
+    PreMeStmtExtensionMap = lfoEmit->GetPreMeStmtExtensionMap();
+    PreMeExprExtensionMap = lfoEmit->GetPreMeExprExtensionMap();
+  }
+  virtual ~SeqVectorize() = default;
+  void Perform();
+  void VisitNode(StmtNode *stmt);
+  void CollectStores(IassignNode *iassign);
+  void DumpCandidates(const MeExpr *base, const StoreList *storelist) const;
+  void CheckAndTransform();
+  bool IsOpExprConsecutiveMem(MeExpr *off1, MeExpr *off2, int32_t diff) const;
+  bool CanSeqVec(const IassignNode *s1, const IassignNode *s2, bool reverse = false);
+  bool CanSeqVecRhs(MeExpr *rhs1, MeExpr *rhs2);
+  void LegalityCheckAndTransform(const StoreList *storelist);
+  bool HasVecType(PrimType sPrimType, uint8 lanes) const;
+  MIRType* GenVecType(PrimType sPrimType, uint8 lanes) const;
+  RegassignNode *GenDupScalarStmt(BaseNode *scalar, PrimType vecPrimType);
+  bool SameIntConstValue(const MeExpr *e1, const MeExpr *e2) const;
+  bool CanAdjustRhsType(PrimType targetType, const ConstvalNode *rhs) const;
+  void MergeIassigns(MapleVector<IassignNode *> &cands);
+  bool IsIvarExprConsecutiveMem(IvarMeExpr *ivar1, IvarMeExpr *ivar2, PrimType ptrType);
+  static uint32_t seqVecStores;
+  // iassignnode in same level block
+  MemPool *localMP;
+  MapleAllocator localAlloc;
+  MemPool *codeMP;
+  MapleAllocator *codeMPAlloc;
+  MIRFunction *mirFunc;
+  MeIRMap *meIRMap;
+  // point to PreMeStmtExtensionMap of PreMeEmitter, key is stmtID
+  MapleMap<uint32_t, PreMeMIRExtension *>  *PreMeStmtExtensionMap;
+  // point to PreMeExprExtensionMap of PreMeEmitter, key is mirnode
+  MapleMap<BaseNode *, PreMeMIRExtension *> *PreMeExprExtensionMap;
+  StoreListMap stores;
+  uint32_t currRhsStatus = 0; // unset
+  bool enableDebug = true;
+ private:
+  void ResetRhsStatus() { currRhsStatus = 0; }
+  void SetRhsConst() { currRhsStatus = 1; }
+  void SetRhsConsercutiveMem() { currRhsStatus = 2; }
+  bool IsExprDataIndependent(const MeExpr *expr, const IassignMeStmt *defStmt);
+  bool IsStmtDataIndependent(const IassignMeStmt *s1, const IassignMeStmt *s2);
+  bool IsRhsStatusUnset() const { return currRhsStatus == 0; }
+  bool IsRhsConst() const { return currRhsStatus == 1; }
+  bool IsRhsConsercutiveMem() const { return currRhsStatus == 0; }
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_SEQVEC_H
diff --git a/src/mapleall/maple_me/include/ssa.h b/src/mapleall/maple_me/include/ssa.h
new file mode 100644
index 0000000000000000000000000000000000000000..d50b9c8620cc1878d02739bc4067a718831130f1
--- /dev/null
+++ b/src/mapleall/maple_me/include/ssa.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_SSA_H
+#define MAPLE_ME_INCLUDE_SSA_H
+#include <iostream>
+#include "mir_module.h"
+#include "mir_nodes.h"
+#include "orig_symbol.h"
+#include "dominance.h"
+namespace maple {
+class BB;  // circular dependency exists, no other choice
+class MeCFG;  // circular dependency exists, no other choice
+class VersionSt;  // circular dependency exists, no other choice
+class VersionStTable;  // circular dependency exists, no other choice
+class SSATab;  // circular dependency exists, no other choice
+bool IsLocalTopLevelOst(const OriginalSt &ost);
+class PhiNode {
+ public:
+  PhiNode(MapleAllocator &alloc, VersionSt &vsym) : result(&vsym), phiOpnds(kNumOpnds, nullptr, alloc.Adapter()) {
+    phiOpnds.pop_back();
+    phiOpnds.pop_back();
+  }
+
+  ~PhiNode() = default;
+
+  void Dump();
+
+  VersionSt *GetResult() {
+    return result;
+  }
+  const VersionSt *GetResult() const {
+    return result;
+  }
+
+  void SetResult(VersionSt &resultPara) {
+    result = &resultPara;
+  }
+
+  MapleVector<VersionSt*> &GetPhiOpnds() {
+    return phiOpnds;
+  }
+  const MapleVector<VersionSt*> &GetPhiOpnds() const {
+    return phiOpnds;
+  }
+
+  VersionSt *GetPhiOpnd(size_t index) {
+    ASSERT(index < phiOpnds.size(), "out of range in PhiNode::GetPhiOpnd");
+    return phiOpnds.at(index);
+  }
+  const VersionSt *GetPhiOpnd(size_t index) const {
+    ASSERT(index < phiOpnds.size(), "out of range in PhiNode::GetPhiOpnd");
+    return phiOpnds.at(index);
+  }
+
+  void SetPhiOpnd(size_t index, VersionSt &opnd) {
+    ASSERT(index < phiOpnds.size(), "out of range in PhiNode::SetPhiOpnd");
+    phiOpnds[index] = &opnd;
+  }
+
+  void SetPhiOpnds(const MapleVector<VersionSt*> &phiOpndsPara) {
+    phiOpnds = phiOpndsPara;
+  }
+
+  void SetIsLive(bool isLiveVal) {
+    isLive = isLiveVal;
+  }
+
+  bool GetIsLive() const {
+    return isLive;
+  }
+
+ private:
+  VersionSt *result;
+  static constexpr uint32 kNumOpnds = 2;
+  MapleVector<VersionSt*> phiOpnds;
+  bool isLive = true;
+};
+
+class SSA {
+ public:
+  SSA(SSATab &stab, MapleVector<BB *> &bbvec, Dominance *dm, SSALevel level = kSSAInvalid)
+      : ssaTab(&stab),
+        bbVec(bbvec),
+        dom(dm),
+        targetLevel(level) {}
+
+  virtual ~SSA() = default;
+
+  virtual void InsertPhiNode();
+  void RenameAllBBs(const MeCFG *cfg);
+
+  void UpdateDom(Dominance *dm) {
+    dom = dm;
+  }
+
+  bool runRenameOnly = false;
+ protected:
+  void InsertPhiForDefBB(size_t bbid, VersionSt *vst);
+  void InitRenameStack(const OriginalStTable &oTable, const VersionStTable &verStTab, MapleAllocator &alloc);
+  VersionSt *CreateNewVersion(VersionSt &vSym, BB &defBB);
+  void ReplaceRenameStackTop(VersionSt &newTop) const;
+  void PushToRenameStack(VersionSt *vSym);
+  void RenamePhi(BB &bb);
+  void RenameDefs(StmtNode &stmt, BB &defBB);
+  void RenameMustDefs(const StmtNode &stmt, BB &defBB);
+  void RenameExpr(BaseNode &expr);
+  void RenameUses(const StmtNode &stmt);
+  void RenamePhiUseInSucc(const BB &bb) const;
+  void RenameMayUses(const BaseNode &node) const;
+  void RenameBB(BB &bb);
+
+  const MapleVector<MapleStack<VersionSt*>*> &GetVstStacks() const {
+    return *vstStacks;
+  }
+
+  VersionSt *GetVstStackTop(size_t ostIdx) const {
+    return GetVstStacks()[ostIdx]->top();
+  }
+
+  const MapleStack<VersionSt*> *GetVstStack(size_t idx) const {
+    ASSERT(idx < vstStacks->size(), "out of range of vstStacks");
+    return vstStacks->at(idx);
+  }
+  void PopVersionSt(size_t idx) {
+    vstStacks->at(idx)->pop();
+  }
+
+  SSATab *GetSSATab() {
+    return ssaTab;
+  }
+
+  bool BuildSSATopLevel() const {
+    return targetLevel & kSSATopLevel;
+  }
+  bool BuildSSAAddrTaken() const {
+    return targetLevel & kSSAAddrTaken;
+  }
+  bool BuildSSAAllLevel() const {
+    return BuildSSAAddrTaken() && BuildSSATopLevel();
+  }
+  // Check if ost should be processed according to target ssa level set before
+  bool ShouldProcessOst(const OriginalSt &ost) const;
+
+  bool ShouldRenameVst(const VersionSt *vst) const;
+
+  bool IsNewVstPushed(size_t ostIdx) const {
+    return isNewVstPushed->at(ostIdx);
+  }
+
+  void SetNewVstPushed(size_t ostIdx) {
+    isNewVstPushed->at(ostIdx) = true;
+  }
+
+  MapleVector<MapleStack<VersionSt*>*> *vstStacks = nullptr;    // rename stack for variable versions
+  std::vector<bool> *isNewVstPushed = nullptr; // this is a temp ptr, but shared in some functions
+  SSATab *ssaTab = nullptr;
+  MapleVector<BB *> &bbVec;
+  Dominance *dom = nullptr;
+  SSALevel targetLevel = kSSAInvalid;                // ssa level to build
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_SSA_H
diff --git a/src/mapleall/maple_me/include/ssa_devirtual.h b/src/mapleall/maple_me/include/ssa_devirtual.h
new file mode 100644
index 0000000000000000000000000000000000000000..7cc296fb24f20efe2e786cce07954d0b2ad4098e
--- /dev/null
+++ b/src/mapleall/maple_me/include/ssa_devirtual.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_SSADEVIRTUAL_H
+#define MAPLE_ME_INCLUDE_SSADEVIRTUAL_H
+#include "me_ir.h"
+#include "me_irmap.h"
+#include "dominance.h"
+#include "class_hierarchy.h"
+#include "clone.h"
+
+namespace maple {
+class SSADevirtual {
+ public:
+  static bool debug;
+  SSADevirtual(MemPool &memPool, MIRModule &currMod, IRMap &irMap, KlassHierarchy &currKh,
+               Dominance &currDom, size_t bbVecSize, bool skipReturnTypeOpt)
+      : devirtualAlloc(&memPool),
+        mod(&currMod),
+        irMap(&irMap),
+        kh(&currKh),
+        dom(&currDom),
+        bbVisited(bbVecSize, false, devirtualAlloc.Adapter()),
+        inferredTypeCandidatesMap(devirtualAlloc.Adapter()),
+        clone(nullptr),
+        retTy(kNotSeen),
+        inferredRetTyIdx(0),
+        totalVirtualCalls(0),
+        optedVirtualCalls(0),
+        totalInterfaceCalls(0),
+        optedInterfaceCalls(0),
+        nullCheckCount(0),
+        skipReturnTypeOpt(skipReturnTypeOpt) {}
+  SSADevirtual(MemPool &memPool, MIRModule &currMod, IRMap &irMap, KlassHierarchy &currKh,
+               Dominance &currDom, size_t bbVecSize, Clone &currClone, bool skipReturnTypeOpt)
+      : SSADevirtual(memPool, currMod, irMap, currKh, currDom, bbVecSize, skipReturnTypeOpt) {
+    clone = &currClone;
+  }
+
+  virtual ~SSADevirtual() = default;
+
+  void Perform(BB &entryBB);
+
+  void SetClone(Clone &currClone) {
+    clone = &currClone;
+  }
+ protected:
+  virtual MIRFunction *GetMIRFunction() const {
+    return nullptr;
+  }
+
+  virtual BB *GetBB(BBId id) const = 0;
+  void TraversalBB(BB *bb);
+  void TraversalMeStmt(MeStmt &meStmt);
+  void VisitVarPhiNode(MePhiNode &varPhi);
+  void VisitMeExpr(MeExpr *meExpr) const;
+  void PropVarInferredType(VarMeExpr &varMeExpr) const;
+  void PropIvarInferredType(IvarMeExpr &ivar) const;
+  void ReturnTyIdxInferring(const RetMeStmt &retMeStmt);
+  bool NeedNullCheck(const MeExpr &receiver) const;
+  void InsertNullCheck(CallMeStmt &callStmt, MeExpr &receiver) const;
+  bool DevirtualizeCall(CallMeStmt &callStmt);
+  void SSADevirtualize(CallNode &stmt);
+  void ReplaceCall(CallMeStmt &callStmt, const MIRFunction &targetFunc);
+  TyIdx GetInferredTyIdx(MeExpr &expr) const;
+
+ private:
+  MapleAllocator devirtualAlloc;
+  MIRModule *mod;
+  IRMap *irMap;
+  KlassHierarchy *kh;
+  Dominance *dom;
+  MapleVector<bool> bbVisited;  // needed because dominator tree is a DAG in wpo
+  MapleMap<int, MapleVector<TyIdx>*> inferredTypeCandidatesMap;  // key is VarMeExpr's exprID
+  Clone *clone;
+  enum TagRetTyIdx {
+    kNotSeen,
+    kSeen,
+    kFailed
+  } retTy;
+  TyIdx inferredRetTyIdx;
+  unsigned int totalVirtualCalls;
+  unsigned int optedVirtualCalls;
+  unsigned int totalInterfaceCalls;
+  unsigned int optedInterfaceCalls;
+  unsigned int nullCheckCount;
+  const bool skipReturnTypeOpt = false; // whether skip return type optimization, true if running me phases in parallel
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_SSADEVIRTUAL_H
diff --git a/src/mapleall/maple_me/include/ssa_epre.h b/src/mapleall/maple_me/include/ssa_epre.h
new file mode 100644
index 0000000000000000000000000000000000000000..0df35a90a787eb387d6be84decf1ec3a624f686c
--- /dev/null
+++ b/src/mapleall/maple_me/include/ssa_epre.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_SSAEPRE_H
+#define MAPLE_ME_INCLUDE_SSAEPRE_H
+#include "ssa_pre.h"
+
+namespace maple {
+class SSAEPre : public SSAPre {
+ public:
+  SSAEPre(IRMap &map, Dominance &dom, Dominance &pdom, MemPool &memPool, MemPool &mp2, PreKind kind,
+          uint32 limit, bool includeRef, bool lhsIvar)
+      : SSAPre(map, dom, pdom, memPool, mp2, kind, limit), epreIncludeRef(includeRef), enableLHSIvar(lhsIvar) {}
+
+  virtual ~SSAEPre() = default;
+
+ private:
+  MeExpr *GetTruncExpr(const IvarMeExpr &theLHS, MeExpr &savedRHS) const;
+  void GenerateSaveLHSRealocc(MeRealOcc &realOcc, ScalarMeExpr &regOrVar);
+  void GenerateSaveRealOcc(MeRealOcc &realOcc) override;
+  bool ReserveCalFuncAddrForDecouple(MeExpr &meExpr) const;
+  void GenerateReloadRealOcc(MeRealOcc &realOcc) override;
+  MeExpr *PhiOpndFromRes(MeRealOcc &realZ, size_t j) const override;
+  void ComputeVarAndDfPhis() override;
+  void BuildWorkListExpr(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool isRebuild,
+                         MeExpr *tempVar, bool isRootExpr, bool insertSorted) override;
+  void BuildWorkListIvarLHSOcc(MeStmt &meStmt, int32 seqStmt, bool isReBuild, MeExpr *tempVar) override;
+  void CollectVarForMeExpr(MeExpr &meExpr, std::vector<MeExpr*> &varVec) const override;
+  void CollectVarForCand(MeRealOcc &realOcc, std::vector<MeExpr*> &varVec) const override;
+  bool LeafIsVolatile(const MeExpr *x) const {
+    const VarMeExpr *v = safe_cast<VarMeExpr>(x);
+    return v != nullptr && v->IsVolatile();
+  }
+  virtual bool IsThreadObjField(const IvarMeExpr &expr) const {
+    (void)expr;
+    return false;
+  }
+
+  virtual bool CfgHasDoWhile() const {
+    return false;
+  }
+  // here starts methods related to strength reduction
+  bool AllVarsSameVersion(const MeRealOcc &realocc1, const MeRealOcc &realocc2) const override;
+  ScalarMeExpr *ResolveOneInjuringDef(ScalarMeExpr *regx) const;
+  ScalarMeExpr *ResolveAllInjuringDefs(ScalarMeExpr *regx) const override;
+  MeExpr *ResolveAllInjuringDefs(MeExpr *x) const override {
+    if (!workCand->isSRCand) {
+      return x;
+    }
+    if (x->GetMeOp() != kMeOpVar && x->GetMeOp() != kMeOpReg) {
+      return x;
+    }
+    return static_cast<MeExpr *>(ResolveAllInjuringDefs(static_cast<ScalarMeExpr *>(x)));
+  }
+  void SubstituteOpnd(MeExpr *x, MeExpr *oldopnd, MeExpr *newopnd) override;
+  bool OpndInDefOcc(const MeExpr *opnd, MeOccur *defocc, uint32 i) const;
+  void SRSetNeedRepair(MeOccur *useocc, std::set<MeStmt *> *needRepairInjuringDefs) override;
+  MeExpr *InsertRepairStmt(MeExpr *temp, int64 increAmt, MeStmt *injuringDef) const;
+  MeExpr *SRRepairOpndInjuries(MeExpr *curopnd, MeOccur *defocc, int32 i,
+      MeExpr *tempAtDef, std::set<MeStmt *> *needRepairInjuringDefs,
+      std::set<MeStmt *> *repairedInjuringDefs);
+  MeExpr *SRRepairInjuries(MeOccur *useocc,
+      std::set<MeStmt *> *needRepairInjuringDefs,
+      std::set<MeStmt *> *repairedInjuringDefs) override;
+
+  bool epreIncludeRef;
+  bool enableLHSIvar;
+  // here starts methods related to linear function test replacement
+  ScalarMeExpr *FindScalarVersion(ScalarMeExpr *scalar, MeStmt *stmt) const;
+  OpMeExpr *FormLFTRCompare(MeRealOcc *compOcc, MeExpr *regorvar) override;
+  void CreateCompOcc(MeStmt *meStmt, int seqStmt, OpMeExpr *compare, bool isRebuilt) override;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_SSAEPRE_H
diff --git a/src/mapleall/maple_me/include/ssa_mir_nodes.h b/src/mapleall/maple_me/include/ssa_mir_nodes.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c2f814ef87b22b63ff4947e6dd8dbac07d7e956
--- /dev/null
+++ b/src/mapleall/maple_me/include/ssa_mir_nodes.h
@@ -0,0 +1,641 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_SSA_MIR_NODES_H
+#define MAPLE_ME_INCLUDE_SSA_MIR_NODES_H
+#include <iostream>
+#include "bb.h"
+#include "ver_symbol.h"
+
+// This file define data structures to store SSA information in the IR instructions
+namespace maple {
+class MayDefNode {
+ public:
+  MayDefNode(VersionSt *sym, StmtNode *st) : opnd(sym), result(sym), stmt(st) {}
+
+  ~MayDefNode() = default;
+
+  VersionSt *GetOpnd() {
+    return opnd;
+  }
+  const VersionSt *GetOpnd() const {
+    return opnd;
+  }
+
+  VersionSt *GetResult() {
+    return result;
+  }
+  const VersionSt *GetResult() const {
+    return result;
+  }
+
+  StmtNode *GetStmt() {
+    return stmt;
+  }
+  const StmtNode *GetStmt() const {
+    return stmt;
+  }
+
+  void SetStmt(StmtNode *s) {
+    stmt = s;
+  }
+
+  void SetOpnd(VersionSt *sym) {
+    opnd = sym;
+  }
+
+  void SetResult(VersionSt *sym) {
+    result = sym;
+  }
+
+  void Dump() const {
+    result->Dump();
+    LogInfo::MapleLogger() << " = MAYD(";
+    opnd->Dump();
+    LogInfo::MapleLogger() << ")\n";
+  }
+
+  bool operator==(const MayDefNode &other) const {
+    return opnd == other.opnd && result == other.result && stmt == other.stmt;
+  }
+
+  VersionSt *base = nullptr; // only provided if indirectLev is 1 and attached to iassign
+ private:
+  VersionSt *opnd;
+  VersionSt *result;
+  StmtNode *stmt;
+};
+
+class MayUseNode {
+ public:
+  explicit MayUseNode(VersionSt *sym) : opnd(sym) {}
+
+  ~MayUseNode() = default;
+
+  VersionSt *GetOpnd() const {
+    return opnd;
+  }
+
+  void SetOpnd(VersionSt *sym) {
+    opnd = sym;
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << " MAYU(";
+    opnd->Dump();
+    LogInfo::MapleLogger() << ")\n";
+  }
+
+  bool operator==(const MayUseNode &other) const {
+    return opnd == other.opnd;
+  }
+
+ private:
+  VersionSt *opnd;
+};
+
+// this is only used in the callassigned type of call statements
+class MustDefNode {
+ public:
+  MustDefNode() = default;
+
+  MustDefNode(VersionSt *sym, StmtNode *st) : result(sym), stmt(st) {}
+
+  ~MustDefNode() = default;
+
+  VersionSt *GetResult() {
+    return result;
+  }
+  const VersionSt *GetResult() const {
+    return result;
+  }
+
+  void SetResult(VersionSt *sym) {
+    result = sym;
+  }
+
+  StmtNode *GetStmt() {
+    return stmt;
+  }
+  const StmtNode *GetStmt() const {
+    return stmt;
+  }
+
+  void Dump() const {
+    result->Dump();
+    LogInfo::MapleLogger() << " = MUSTDEF\n";
+  }
+
+ private:
+  VersionSt *result = nullptr;
+  StmtNode *stmt = nullptr;
+};
+
+using TypeOfMayUseList = MapleMap<OStIdx, MayUseNode>;
+using TypeOfMayDefList = MapleMap<OStIdx, MayDefNode>;
+using TypeOfMustDefList = MapleVector<MustDefNode>;
+class AccessSSANodes {
+ public:
+  AccessSSANodes() = default;
+  virtual ~AccessSSANodes() = default;
+
+  virtual const TypeOfMayDefList &GetMayDefNodes() const {
+    CHECK_FATAL(false, "No mayDefNodes");
+  }
+
+  virtual TypeOfMayDefList &GetMayDefNodes() {
+    CHECK_FATAL(false, "No mayDefNodes");
+  }
+
+  virtual const TypeOfMayUseList &GetMayUseNodes() const {
+    CHECK_FATAL(false, "No mayUseNodes");
+  }
+
+  virtual TypeOfMayUseList &GetMayUseNodes() {
+    CHECK_FATAL(false, "No mayUseNodes");
+  }
+
+  virtual const TypeOfMustDefList &GetMustDefNodes() const {
+    CHECK_FATAL(false, "No mustDefNodes");
+  }
+  virtual TypeOfMustDefList &GetMustDefNodes() {
+    CHECK_FATAL(false, "No mustDefNodes");
+  }
+
+  virtual const VersionSt *GetSSAVar() const {
+    CHECK_FATAL(false, "No ssaVar");
+  }
+
+  virtual VersionSt *GetSSAVar() {
+    CHECK_FATAL(false, "No ssaVar");
+  }
+
+  virtual void SetSSAVar(VersionSt&) {
+    CHECK_FATAL(false, "No ssaVar");
+  }
+
+  virtual void DumpMayDefNodes(const MIRModule&) const {
+    for (const auto &mayDefNode : GetMayDefNodes()) {
+      mayDefNode.second.Dump();
+    }
+  }
+
+  virtual void DumpMayUseNodes(const MIRModule&) const {
+    for (const auto &mapItem : GetMayUseNodes()) {
+      mapItem.second.Dump();
+    }
+  }
+
+  virtual void DumpMustDefNodes(const MIRModule&) const {
+    for (const auto &mustDefNode : GetMustDefNodes()) {
+      mustDefNode.Dump();
+    }
+  }
+
+  inline void InsertMayDefNode(MayDefNode mayDefNode) {
+    auto &mayDefNodes = GetMayDefNodes();
+    OStIdx ostIdx = mayDefNode.GetOpnd()->GetOrigIdx();
+    (void)mayDefNodes.insert({ ostIdx, mayDefNode });
+  }
+
+  inline void InsertMayUseNode(MayUseNode mayUseNode) {
+    auto &mayUseNodes = GetMayUseNodes();
+    OStIdx ostIdx = mayUseNode.GetOpnd()->GetOrigIdx();
+    (void)mayUseNodes.insert({ ostIdx, mayUseNode });
+  }
+
+  virtual void InsertMustDefNode(VersionSt *sym, StmtNode *s) {
+    GetMustDefNodes().emplace_back(MustDefNode(sym, s));
+  }
+};
+
+class MayDefPart : public AccessSSANodes {
+ public:
+  explicit MayDefPart(MapleAllocator *alloc) : mayDefNodes(alloc->Adapter()) {}
+
+  ~MayDefPart() override = default;
+
+  const TypeOfMayDefList &GetMayDefNodes() const override {
+    return mayDefNodes;
+  }
+
+  TypeOfMayDefList &GetMayDefNodes() override {
+    return mayDefNodes;
+  }
+
+ private:
+  TypeOfMayDefList mayDefNodes;
+};
+
+class MayUsePart : public AccessSSANodes {
+ public:
+  explicit MayUsePart(MapleAllocator *alloc) : mayUseNodes(alloc->Adapter()) {}
+
+  ~MayUsePart() override = default;
+
+  const TypeOfMayUseList &GetMayUseNodes() const override {
+    return mayUseNodes;
+  }
+
+  TypeOfMayUseList &GetMayUseNodes() override {
+    return mayUseNodes;
+  }
+
+ private:
+  TypeOfMayUseList mayUseNodes;
+};
+
+class MustDefPart : public AccessSSANodes {
+ public:
+  explicit MustDefPart(MapleAllocator *alloc) : mustDefNodes(alloc->Adapter()) {}
+
+  ~MustDefPart() override = default;
+
+  const TypeOfMustDefList &GetMustDefNodes() const override {
+    return mustDefNodes;
+  }
+
+  TypeOfMustDefList &GetMustDefNodes() override {
+    return mustDefNodes;
+  }
+
+ private:
+  TypeOfMustDefList mustDefNodes;
+};
+
+class MayDefPartWithVersionSt : public AccessSSANodes {
+ public:
+  explicit MayDefPartWithVersionSt(MapleAllocator *alloc) : mayDefNodes(alloc->Adapter()) {}
+
+  ~MayDefPartWithVersionSt() override = default;
+
+  const TypeOfMayDefList &GetMayDefNodes() const override {
+    return mayDefNodes;
+  }
+
+  TypeOfMayDefList &GetMayDefNodes() override {
+    return mayDefNodes;
+  }
+
+  const VersionSt *GetSSAVar() const override {
+    return ssaVar;
+  }
+
+  VersionSt *GetSSAVar() override {
+    return ssaVar;
+  }
+
+  void SetSSAVar(VersionSt &ssaVarPara) override {
+    ssaVar = &ssaVarPara;
+  }
+
+ private:
+  VersionSt *ssaVar = nullptr;
+  TypeOfMayDefList mayDefNodes;
+};
+
+class VersionStPart : public AccessSSANodes {
+ public:
+  VersionStPart() = default;
+  ~VersionStPart() override = default;
+
+  const VersionSt *GetSSAVar() const override {
+    return ssaVar;
+  }
+
+  VersionSt *GetSSAVar() override {
+    return ssaVar;
+  }
+
+  void SetSSAVar(VersionSt &ssaVarPara) override {
+    ssaVar = &ssaVarPara;
+  }
+
+ private:
+  VersionSt *ssaVar = nullptr;
+};
+
+class MayDefMayUsePart : public AccessSSANodes {
+ public:
+  explicit MayDefMayUsePart(MapleAllocator *alloc)
+      : mayDefNodes(alloc->Adapter()), mayUseNodes(alloc->Adapter()) {}
+
+  ~MayDefMayUsePart() override = default;
+
+  const TypeOfMayDefList &GetMayDefNodes() const override {
+    return mayDefNodes;
+  }
+
+  TypeOfMayDefList &GetMayDefNodes() override {
+    return mayDefNodes;
+  }
+
+  const TypeOfMayUseList &GetMayUseNodes() const override {
+    return mayUseNodes;
+  }
+
+  TypeOfMayUseList &GetMayUseNodes() override {
+    return mayUseNodes;
+  }
+
+ private:
+  TypeOfMayDefList mayDefNodes;
+  TypeOfMayUseList mayUseNodes;
+};
+
+class MayDefMayUseMustDefPart : public AccessSSANodes {
+ public:
+  explicit MayDefMayUseMustDefPart(MapleAllocator *alloc)
+      : mayDefNodes(alloc->Adapter()),
+        mayUseNodes(alloc->Adapter()),
+        mustDefNodes(alloc->Adapter()) {}
+
+  ~MayDefMayUseMustDefPart() override = default;
+
+  const TypeOfMayDefList &GetMayDefNodes() const override {
+    return mayDefNodes;
+  }
+
+  TypeOfMayDefList &GetMayDefNodes() override {
+    return mayDefNodes;
+  }
+
+  const TypeOfMayUseList &GetMayUseNodes() const override {
+    return mayUseNodes;
+  }
+
+  TypeOfMayUseList &GetMayUseNodes() override {
+    return mayUseNodes;
+  }
+
+  const TypeOfMustDefList &GetMustDefNodes() const override {
+    return mustDefNodes;
+  }
+  TypeOfMustDefList &GetMustDefNodes() override {
+    return mustDefNodes;
+  }
+
+ private:
+  TypeOfMayDefList mayDefNodes;
+  TypeOfMayUseList mayUseNodes;
+  TypeOfMustDefList mustDefNodes;
+};
+
+// statement nodes are covered by StmtsSSAPart
+class StmtsSSAPart {
+ public:
+  // Key of ssaPart is stmtID
+  // Each element of ssaPart, depending on the stmt, can be pointer to one of:
+  // (1) MayDefPart
+  // (2) MayUsePart
+  // (3) MayDefMayUsePart
+  // (4) MayDefPartWithVersionSt
+  // (5) MayDefMayUseMustDefPart
+  // (6) VersionSt
+  explicit StmtsSSAPart(MemPool *memPool)
+      : ssaPartMp(memPool), ssaPartAlloc(memPool), ssaPart(ssaPartAlloc.Adapter()) {}
+
+  ~StmtsSSAPart() = default;
+
+  AccessSSANodes *SSAPartOf(const StmtNode &stmt) {
+    return ssaPart[stmt.GetStmtID()];
+  }
+  const AccessSSANodes *SSAPartOf(const StmtNode &stmt) const {
+    return ssaPart.at(stmt.GetStmtID());
+  }
+
+  bool HasMayDef(const StmtNode &stmt) {
+    return kOpcodeInfo.HasSSADef(stmt.GetOpCode()) && !GetMayDefNodesOf(stmt).empty();
+  }
+
+  TypeOfMayDefList &GetMayDefNodesOf(const StmtNode &stmt) {
+    return ssaPart[stmt.GetStmtID()]->GetMayDefNodes();
+  }
+
+  TypeOfMayUseList &GetMayUseNodesOf(const StmtNode &stmt) {
+    return ssaPart[stmt.GetStmtID()]->GetMayUseNodes();
+  }
+
+  MapleVector<MustDefNode> &GetMustDefNodesOf(const StmtNode &stmt) {
+    return ssaPart.at(stmt.GetStmtID())->GetMustDefNodes();
+  }
+  const MapleVector<MustDefNode> &GetMustDefNodesOf(const StmtNode &stmt) const {
+    return ssaPart.at(stmt.GetStmtID())->GetMustDefNodes();
+  }
+
+  VersionSt *GetAssignedVarOf(const StmtNode &stmt) {
+    return ssaPart.at(stmt.GetStmtID())->GetSSAVar();
+  }
+  const VersionSt *GetAssignedVarOf(const StmtNode &stmt) const {
+    return ssaPart.at(stmt.GetStmtID())->GetSSAVar();
+  }
+
+  template <class T>
+  void SetSSAPartOf(const StmtNode &s, T *p) {
+    ssaPart[s.GetStmtID()] = static_cast<AccessSSANodes *>(p);
+  }
+
+  void SetSSAPartOf(const StmtNode &s, VersionSt *vst) {
+    auto *vstSSAPart = GetSSAPartMp()->New<VersionStPart>();
+    vstSSAPart->SetSSAVar(*vst);
+    ssaPart[s.GetStmtID()] = vstSSAPart;
+  }
+
+  MemPool *GetSSAPartMp() {
+    return ssaPartMp;
+  }
+
+  MapleAllocator &GetSSAPartAlloc() {
+    return ssaPartAlloc;
+  }
+
+ private:
+  MemPool *ssaPartMp;
+  MapleAllocator ssaPartAlloc;
+  MapleMap<uint32, AccessSSANodes*> ssaPart;  // key is stmtID
+};
+
+class SSANode : public BaseNode {
+ public:
+  SSANode(Opcode op, PrimType typ, uint8 numOpr) : BaseNode(op, typ, numOpr) {}
+
+  ~SSANode() override = default;
+
+  VersionSt *GetSSAVar() {
+    return ssaVar;
+  }
+  const VersionSt *GetSSAVar() const {
+    return ssaVar;
+  }
+
+  void SetSSAVar(VersionSt &ssaVarPara) {
+    ssaVar = &ssaVarPara;
+  }
+
+  bool IsSSANode() const override {
+    return true;
+  }
+
+  // MIRSymbol query
+  const MIRSymbol &GetMIRSymbol() const {
+    return *(GetSSAVar()->GetOst()->GetMIRSymbol());
+  }
+
+  virtual BaseNode *GetNoSSANode()= 0;
+
+ protected:
+  virtual void SetNoSSANode(BaseNode *node) = 0;
+  VersionSt *ssaVar = nullptr;
+};
+
+// The following expression nodes need extra fields to represent SSA
+class AddrofSSANode : public SSANode {
+ public:
+  explicit AddrofSSANode(AddrofNode &addrNode)
+      : SSANode(addrNode.GetOpCode(), addrNode.GetPrimType(), addrNode.NumOpnds()), addrofNode(&addrNode) {}
+
+  ~AddrofSSANode() override = default;
+
+  void Dump(int32 indent) const override {
+    addrofNode->Dump(indent);
+    if (GetSSAVar() != nullptr) {
+      GetSSAVar()->Dump(true);
+    }
+  }
+
+  StIdx GetStIdx() const {
+    return addrofNode->GetStIdx();
+  }
+
+  FieldID GetFieldID() const {
+    return addrofNode->GetFieldID();
+  }
+
+  BaseNode *GetNoSSANode() override {
+    return addrofNode;
+  }
+
+  AddrofSSANode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.New<AddrofSSANode>(*this);
+    BaseNode *newAddrof = node->GetNoSSANode()->CloneTree(allocator);
+    node->SetNoSSANode(newAddrof);
+    return node;
+  }
+
+ protected:
+  void SetNoSSANode(BaseNode *node) override {
+    ASSERT(node->GetOpCode() == OP_addrof || node->GetOpCode() == OP_dread, "must be!");
+    addrofNode = static_cast<AddrofNode *>(node);
+  }
+  AddrofNode *addrofNode;
+};
+
+class IreadSSANode : public SSANode {
+ public:
+  explicit IreadSSANode(IreadNode &iread)
+      : SSANode(iread.GetOpCode(), iread.GetPrimType(), iread.NumOpnds()), ireadNode(&iread) {}
+
+  ~IreadSSANode() override = default;
+
+  void Dump(int32 indent) const override {
+    if (GetSSAVar() != nullptr) {
+      GetSSAVar()->Dump(true);
+    }
+    ireadNode->Dump(indent);
+  }
+
+  FieldID GetFieldID() const {
+    return ireadNode->GetFieldID();
+  }
+
+  TyIdx GetTyIdx() const {
+    return ireadNode->GetTyIdx();
+  }
+
+  BaseNode *Opnd(size_t idx) const override {
+    return ireadNode->Opnd(idx);
+  }
+
+  void SetOpnd(BaseNode *node, size_t i = 0) override {
+    ireadNode->SetOpnd(node, i);
+  }
+
+  BaseNode *GetNoSSANode() override {
+    return ireadNode;
+  }
+
+  IreadSSANode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.New<IreadSSANode>(*this);
+    BaseNode *newIread = node->GetNoSSANode()->CloneTree(allocator);
+    node->SetNoSSANode(newIread);
+    return node;
+  }
+
+ protected:
+  void SetNoSSANode(BaseNode *node) override {
+    ASSERT(node->GetOpCode() == OP_iread, "must be!");
+    ireadNode = static_cast<IreadNode *>(node);
+  }
+  IreadNode *ireadNode;
+};
+
+class RegreadSSANode : public SSANode {
+ public:
+  explicit RegreadSSANode(RegreadNode &regRead)
+      : SSANode(regRead.GetOpCode(), regRead.GetPrimType(), regRead.GetNumOpnds()), regreadNode(&regRead) {}
+
+  ~RegreadSSANode() override = default;
+
+  void Dump(int32 indent) const override {
+    regreadNode->Dump(indent);
+    if (GetSSAVar() != nullptr) {
+      GetSSAVar()->Dump(true);
+    }
+  }
+
+  PregIdx GetRegIdx() const {
+    return regreadNode->GetRegIdx();
+  }
+
+  BaseNode *GetNoSSANode() override {
+    return regreadNode;
+  }
+
+  RegreadSSANode *CloneTree(MapleAllocator &allocator) const override {
+    auto *node = allocator.New<RegreadSSANode>(*this);
+    BaseNode *newRegread = node->GetNoSSANode()->CloneTree(allocator);
+    node->SetNoSSANode(newRegread);
+    return node;
+  }
+
+ protected:
+  void SetNoSSANode(BaseNode *node) override {
+    ASSERT(node->GetOpCode() == OP_regread, "must be!");
+    regreadNode = static_cast<RegreadNode *>(node);
+  }
+  RegreadNode *regreadNode;
+};
+
+void GenericSSAPrint(const MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart);
+TypeOfMayDefList *SSAGenericGetMayDefsFromVersionSt(const VersionSt &sym, StmtsSSAPart &stmtsSSAPart);
+bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func);
+
+inline bool HasMallocOpnd(const BaseNode *x) {
+  return x->op == OP_malloc || x->op == OP_gcmalloc || x->op == OP_gcmallocjarray || x->op == OP_alloca ||
+         x->op == OP_stackmalloc || x->op == OP_stackmallocjarray;
+}
+
+bool IsSameContent(const BaseNode *exprA, const BaseNode *exprB, bool isZeroVstEqual = true);
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_SSA_MIR_NODES_H
diff --git a/src/mapleall/maple_me/include/ssa_pre.h b/src/mapleall/maple_me/include/ssa_pre.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e782bca2749f91ef5da87934317a04d8aef2dcc
--- /dev/null
+++ b/src/mapleall/maple_me/include/ssa_pre.h
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_SSAPRE_H
+#define MAPLE_ME_INCLUDE_SSAPRE_H
+#include "irmap.h"
+#include "occur.h"
+#include "securec.h"
+
+namespace maple {
+enum PreKind {
+  kExprPre,
+  kStmtPre,
+  kLoadPre,
+  kAddrPre
+};
+
+class ExprHoist;
+class HoistSummary;
+
+class SSAPre {
+ public:
+  friend class ExprHoist;
+  SSAPre(IRMap &hMap, Dominance &currDom, Dominance &currPdom, MemPool &memPool, MemPool &mp2, PreKind kind,
+         uint32 limit)
+      : irMap(&hMap),
+        ssaTab(&hMap.GetSSATab()),
+        mirModule(&hMap.GetSSATab().GetModule()),
+        dom(&currDom),
+        pdom(&currPdom),
+        ssaPreMemPool(&memPool),
+        ssaPreAllocator(&memPool),
+        perCandMemPool(&mp2),
+        perCandAllocator(&mp2),
+        workList(ssaPreAllocator.Adapter()),
+        preKind(kind),
+        allOccs(ssaPreAllocator.Adapter()),
+        phiOccs(ssaPreAllocator.Adapter()),
+        exitOccs(ssaPreAllocator.Adapter()),
+        preLimit(limit),
+        dfPhiDfns(std::less<uint32>(), ssaPreAllocator.Adapter()),
+        varPhiDfns(std::less<uint32>(), ssaPreAllocator.Adapter()),
+        rename2Set(std::less<uint32>(), ssaPreAllocator.Adapter()),
+        temp2LocalRefVarMap(ssaPreAllocator.Adapter()) {
+    preWorkCandHashTable.GetWorkcandHashTable().fill(nullptr);
+  }
+
+  virtual ~SSAPre() = default;
+
+  void ApplySSAPRE();
+  bool DefVarDominateOcc(const MeExpr *meExpr, const MeOccur &meOcc) const;
+  virtual void CollectVarForMeExpr(MeExpr &meExpr, std::vector<MeExpr*> &varVec) const = 0;
+  virtual void CollectVarForCand(MeRealOcc &realOcc, std::vector<MeExpr*> &varVec) const = 0;
+  const MapleVector<MeRealOcc*> &GetRealOccList() const {
+    return workCand->GetRealOccs();
+  }
+
+  virtual IassignMeStmt *CopyIassignMeStmt(const IassignMeStmt &iaStmt) const;
+  void IncTreeid() {
+    // Incremented by 2 for each tree; purpose is to avoid processing a node the third time inside a tree
+    curTreeId += 2;
+  }
+
+  virtual void DumpWorkList() const;
+  virtual void DumpWorkListWrap() const;
+  GStrIdx NewTempStrIdx();
+  virtual BB *GetBB(BBId id) const = 0;
+  virtual PUIdx GetPUIdx() const = 0;
+  virtual void SetCurFunction(PUIdx) const {}
+
+  void GetIterDomFrontier(const BB *bb, MapleSet<uint32> *dfset) const {
+    for (auto bbid : dom->GetIterDomFrontier(bb->GetID())) {
+      (void)dfset->insert(dom->GetDtDfnItem(bbid));
+    }
+  }
+
+  void SetSpillAtCatch(bool status) {
+    spillAtCatch = status;
+  }
+
+  bool GetSpillAtCatch() const {
+    return spillAtCatch;
+  }
+
+  PreWorkCand* GetWorkCand() const {
+    return workCand;
+  }
+
+  void SetAddedNewLocalRefVars(bool status) {
+    addedNewLocalRefVars = status;
+  }
+
+  bool GetAddedNewLocalRefVars() const {
+    return addedNewLocalRefVars;
+  }
+
+  void SetSSAPreDebug(bool status) {
+    enableDebug = status;
+  }
+
+  bool GetSSAPreDebug() const {
+    return enableDebug;
+  }
+
+  void SetPlacementRC(bool status) {
+    placementRCEnabled = status;
+  }
+
+  bool GetPlacementRCOn() const {
+    return placementRCEnabled;
+  }
+
+  void SetRcLoweringOn(bool status) {
+    rcLoweringEnabled = status;
+  }
+
+  bool GetRcLoweringOn() const {
+    return rcLoweringEnabled;
+  }
+
+  void SetRegReadAtReturn(bool status) {
+    regReadAtReturn = status;
+  }
+
+  bool GetRegReadAtReturn() const {
+    return regReadAtReturn;
+  }
+
+  bool strengthReduction = false;
+  bool doLFTR = false;
+
+ protected:
+  // step 6 codemotion methods
+  ScalarMeExpr *CreateNewCurTemp(const MeExpr &meExpr);
+  VarMeExpr *CreateNewCurLocalRefVar();
+  virtual void GenerateSaveRealOcc(MeRealOcc &realOcc) = 0;
+  virtual void GenerateReloadRealOcc(MeRealOcc &realOcc) = 0;
+  void GenerateSaveInsertedOcc(MeInsertedOcc &insertedOcc);
+  void GenerateSavePhiOcc(MePhiOcc &phiOcc);
+  void UpdateInsertedPhiOccOpnd();
+  virtual OpMeExpr *FormLFTRCompare(MeRealOcc *compOcc, MeExpr *regorvar) {
+    (void)compOcc;
+    (void)regorvar;
+    return nullptr;
+  }
+  virtual void CodeMotion();
+  // step 5 Finalize methods
+  virtual void Finalize1();
+  void SetSave(MeOccur &defX);
+  void SetReplacement(MePhiOcc &occ, MeOccur &repDef);
+  virtual void Finalize2();
+  // hoist methods
+  void HoistExpr();
+  void ExprHoistPrepare();
+  static void HoistClean();
+  // step 4 willbevail methods
+  void ComputeCanBeAvail() const;
+  void ResetCanBeAvail(MePhiOcc &occ) const;
+  void ComputeLater() const;
+  void ResetLater(MePhiOcc &occ) const;
+  // step 3 downsafety methods
+  void ResetDS(MePhiOpndOcc &phiOpnd) const;
+  void ComputeDS() const;
+  // step 2 renaming methods
+  virtual bool AllVarsSameVersion(const MeRealOcc &realOcc1, const MeRealOcc &realOcc2) const {
+    return realOcc1.GetMeExpr() == realOcc2.GetMeExpr();
+  }
+
+  void Rename1();
+  MeExpr *GetReplaceMeExpr(const MeExpr &opnd, const BB &ePhiBB, size_t j) const;
+  virtual MeExpr *PhiOpndFromRes(MeRealOcc &realOcc, size_t i) const = 0;
+  virtual void Rename2();
+  // step 1 phi insertion methods
+  void SetVarPhis(MeExpr *meExpr);
+  virtual void ComputeVarAndDfPhis() = 0;
+  virtual void CreateSortedOccs();
+  // phi insertion methods end
+  virtual void BuildWorkList() = 0;
+  virtual void BuildEntryLHSOcc4Formals() const {}
+
+  virtual void BuildWorkListLHSOcc(MeStmt&, int32) {}
+
+  virtual void BuildWorkListIvarLHSOcc(MeStmt&, int32, bool, MeExpr*) {}
+
+  virtual void BuildWorkListExpr(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool isRebuilt, MeExpr *tempVar,
+                                 bool isRootExpr, bool insertSorted) = 0;
+  virtual void BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeExpr *tempVar = nullptr);
+  virtual void BuildWorkListBB(BB *bb);
+  virtual void ConstructUseOccurMap() {}
+
+  void CreateMembarOcc(MeStmt &meStmt, int seqStmt);
+  virtual void CreateMembarOccAtCatch(BB &bb);
+  void CreateExitOcc(BB &bb) {
+    MeOccur *exitOcc = ssaPreMemPool->New<MeOccur>(kOccExit, 0, bb, nullptr);
+    exitOccs.push_back(exitOcc);
+  }
+  virtual void CreateCompOcc(MeStmt *meStmt, int seqStmt, OpMeExpr *comapre, bool isRebuilt) {
+    (void)meStmt;
+    (void)seqStmt;
+    (void)comapre;
+    (void)isRebuilt;
+  }
+
+  bool CheckIfAnyLocalOpnd(const MeExpr &meExpr) const;
+  void CreateRealOcc(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool insertSorted, bool isLHS = false);
+  virtual bool ScreenPhiBB(BBId bbId) const = 0;
+  virtual bool EpreLocalRefVar() const {
+    return false;
+  }
+
+  virtual void EnterCandsForSSAUpdate(OStIdx, const BB&) {}
+
+  virtual bool IsLoopHeadBB(BBId) const {
+    return false;
+  }
+  virtual RegMeExpr *ResolveAllInjuringDefs(RegMeExpr *regx) const { return regx; }
+  virtual MeExpr *ResolveAllInjuringDefs(MeExpr *x) const { return x; }
+  virtual void SubstituteOpnd(MeExpr *x, MeExpr *oldopnd, MeExpr *newopnd) {
+    (void)x;
+    (void)oldopnd;
+    (void)newopnd;
+  }
+  virtual void SRSetNeedRepair(MeOccur *useocc, std::set<MeStmt *> *needRepairInjuringDefs) {
+    (void)useocc;
+    (void)needRepairInjuringDefs;
+  }
+  virtual MeExpr *SRRepairInjuries(MeOccur *useocc,
+      std::set<MeStmt *> *needRepairInjuringDefs,
+      std::set<MeStmt *> *repairedInjuringDefs) {
+    (void)useocc;
+    (void)needRepairInjuringDefs;
+    (void)repairedInjuringDefs;
+    return nullptr;
+  }
+
+  IRMap *irMap;
+  SSATab *ssaTab;
+  MIRModule *mirModule;
+  Dominance *dom;
+  Dominance *pdom;
+  MemPool *ssaPreMemPool;
+  MapleAllocator ssaPreAllocator;
+  MemPool *perCandMemPool;
+  MapleAllocator perCandAllocator;
+  MapleList<PreWorkCand*> workList;
+  PreWorkCand *workCand = nullptr;  // the current PreWorkCand
+  ExprHoist *eh = nullptr;
+  PreKind preKind;
+
+  uint32 curTreeId = 0;  // based on number of rooted trees processed in collecting
+  // PRE work candidates; incremented by 2 for each tree;
+  // purpose is to avoid processing a node the third time
+  // inside a tree (which is a DAG)
+  // the following 3 lists are all maintained in order of dt_preorder
+  MapleVector<MeOccur*> allOccs;     // cleared at start of each workcand
+  MapleVector<MePhiOcc*> phiOccs;    // cleared at start of each workcand
+  MapleVector<MeOccur*> exitOccs;  // this is shared by all workcands
+  uint32 preLimit;  // set by command-line option to limit the number of candidates optimized (for debugging purpose)
+  // step 1 phi insertion data structures
+  // following are set of BBs in terms of their dfn's; index into
+  // dominance->pdt_preorder to get their bbid's
+  MapleSet<uint32> dfPhiDfns;   // phis inserted due to dominance frontiers
+  MapleSet<uint32> varPhiDfns;  // phis inserted due to the var operands
+  // step 2 renaming data structures
+  uint32 classCount = 0;            // count class created during renaming
+  MapleSet<uint32> rename2Set;  // set created by rename1 for use rename2; value
+  // is index into workCand->realOccs
+  // step 6 codemotion data structures
+  ScalarMeExpr *curTemp = nullptr;            // the created temp for current workCand
+  VarMeExpr *curLocalRefVar = nullptr;  // the created localrefvar for ref-type iread
+  MapleMap<RegMeExpr*, VarMeExpr*> temp2LocalRefVarMap;
+  int32 reBuiltOccIndex = -1;  // stores the size of worklist every time when try to add new worklist, update before
+  // each code motion
+  uint32 strIdxCount = 0;  // ssapre will create a lot of temp variables if using var to store redundances, start from 0
+  PreWorkCandHashTable preWorkCandHashTable;
+
+ private:
+  virtual void DoSSAFRE() {};
+
+  bool enableDebug = false;
+  bool rcLoweringEnabled = false;
+  bool regReadAtReturn = false;
+  bool spillAtCatch = false;
+  bool placementRCEnabled = false;
+  bool addedNewLocalRefVars = false;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_SSAPRE_H
diff --git a/src/mapleall/maple_me/include/ssa_tab.h b/src/mapleall/maple_me/include/ssa_tab.h
new file mode 100644
index 0000000000000000000000000000000000000000..2851bd6dde90543f71f727e2379b0669240ee2e1
--- /dev/null
+++ b/src/mapleall/maple_me/include/ssa_tab.h
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_SSA_TAB_H
+#define MAPLE_ME_INCLUDE_SSA_TAB_H
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "ver_symbol.h"
+#include "ssa_mir_nodes.h"
+
+namespace maple {
+
+class MeFunction;
+
+class SSATab : public AnalysisResult {
+  // represent the SSA table
+ public:
+  SSATab(MemPool *memPool, MemPool *versMp, MIRModule *mod, MeFunction *f)
+      : AnalysisResult(memPool),
+        mirModule(*mod),
+        func(f),
+        versAlloc(versMp),
+        versionStTable(*versMp),
+        originalStTable(*memPool, *mod),
+        stmtsSSAPart(versMp),
+        defBBs4Ost(16, nullptr, versAlloc.Adapter()) {}
+
+  ~SSATab() = default;
+
+  BaseNode *CreateSSAExpr(BaseNode *expr);
+  void CreateSSAStmt(StmtNode &stmt, const BB *curbb);
+  bool HasDefBB(OStIdx oidx) {
+    return oidx < defBBs4Ost.size() && defBBs4Ost[oidx] && !defBBs4Ost[oidx]->empty();
+  }
+  void AddDefBB4Ost(OStIdx oidx, BBId bbid) {
+    if (oidx >= defBBs4Ost.size()) {
+      defBBs4Ost.resize(oidx + 16, nullptr);
+    }
+    if (defBBs4Ost[oidx] == nullptr) {
+      defBBs4Ost[oidx] = versAlloc.GetMemPool()->New<MapleSet<BBId>>(versAlloc.Adapter());
+    }
+    (void)defBBs4Ost[oidx]->insert(bbid);
+  }
+  MapleSet<BBId> *GetDefBBs4Ost(OStIdx oidx) {
+    return defBBs4Ost[oidx];
+  }
+  VersionSt *GetVerSt(size_t verIdx) {
+    return versionStTable.GetVersionStVectorItem(verIdx);
+  }
+
+  MapleAllocator &GetVersAlloc() {
+    return versAlloc;
+  }
+
+  // following are handles to methods in originalStTable
+  OriginalSt *CreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld) {
+    return originalStTable.CreateSymbolOriginalSt(mirSt, puIdx, fld);
+  }
+
+  OriginalSt *FindOrCreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld) {
+    return originalStTable.FindOrCreateSymbolOriginalSt(mirSt, puIdx, fld);
+  }
+
+  OriginalSt *FindOrCreateAddrofSymbolOriginalSt(OriginalSt *ost) {
+    CHECK_FATAL(ost, "ost is nullptr!");
+    auto *addrofOst = ost->GetPrevLevelOst();
+    if (ost->GetPrevLevelOst() != nullptr) {
+      return addrofOst;
+    }
+    addrofOst = originalStTable.FindOrCreateAddrofSymbolOriginalSt(ost);
+    auto *zeroVersionSt = versionStTable.GetOrCreateZeroVersionSt(*addrofOst);
+    originalStTable.AddNextLevelOstOfVst(zeroVersionSt, ost);
+    ost->SetPointerVst(zeroVersionSt);
+    return addrofOst;
+  }
+
+  const OriginalSt *GetOriginalStFromID(OStIdx id) const {
+    return originalStTable.GetOriginalStFromID(id);
+  }
+  OriginalSt *GetOriginalStFromID(OStIdx id) {
+    return originalStTable.GetOriginalStFromID(id);
+  }
+
+  const OriginalSt *GetSymbolOriginalStFromID(OStIdx id) const {
+    const OriginalSt *ost = originalStTable.GetOriginalStFromID(id);
+    ASSERT(ost->IsSymbolOst(), "GetSymbolOriginalStFromid: id has wrong ost type");
+    return ost;
+  }
+  OriginalSt *GetSymbolOriginalStFromID(OStIdx id) {
+    OriginalSt *ost = originalStTable.GetOriginalStFromID(id);
+    ASSERT(ost->IsSymbolOst() || ost->GetIndirectLev() > 0, "GetSymbolOriginalStFromid: id has wrong ost type");
+    return ost;
+  }
+
+  MapleVector<OriginalSt*> *GetNextLevelOsts(const VersionSt &vst) const {
+    return originalStTable.GetNextLevelOstsOfVst(vst.GetIndex());
+  }
+
+  MapleVector<OriginalSt*> *GetNextLevelOsts(size_t vstIdx) const {
+    return originalStTable.GetNextLevelOstsOfVst(vstIdx);
+  }
+
+  PrimType GetPrimType(OStIdx idx) const {
+    const MIRSymbol *symbol = GetMIRSymbolFromID(idx);
+    return symbol->GetType()->GetPrimType();
+  }
+
+  const MIRSymbol *GetMIRSymbolFromID(OStIdx id) const {
+    return originalStTable.GetMIRSymbolFromID(id);
+  }
+  MIRSymbol *GetMIRSymbolFromID(OStIdx id) {
+    return originalStTable.GetMIRSymbolFromID(id);
+  }
+
+  VersionStTable &GetVersionStTable() {
+    return versionStTable;
+  }
+
+  size_t GetVersionStTableSize() const {
+    return versionStTable.GetVersionStVectorSize();
+  }
+
+  OriginalStTable &GetOriginalStTable() {
+    return originalStTable;
+  }
+
+  const OriginalStTable &GetOriginalStTable() const {
+    return originalStTable;
+  }
+
+  size_t GetOriginalStTableSize() const {
+    return originalStTable.Size();
+  }
+
+  StmtsSSAPart &GetStmtsSSAPart() {
+    return stmtsSSAPart;
+  }
+  const StmtsSSAPart &GetStmtsSSAPart() const {
+    return stmtsSSAPart;
+  }
+
+  // should check HasSSAUse first
+  const TypeOfMayUseList &GetStmtMayUseNodes(const StmtNode &stmt) const {
+    return stmtsSSAPart.SSAPartOf(stmt)->GetMayUseNodes();
+  }
+  // should check IsCallAssigned first
+  MapleVector<MustDefNode> &GetStmtMustDefNodes(const StmtNode &stmt) {
+    return stmtsSSAPart.GetMustDefNodesOf(stmt);
+  }
+
+  bool IsWholeProgramScope() const {
+    return wholeProgramScope;
+  }
+
+  void SetWholeProgramScope(bool val) {
+    wholeProgramScope = val;
+  }
+
+  MIRModule &GetModule() const {
+    return mirModule;
+  }
+
+  void SetEPreLocalRefVar(const OStIdx &ostIdx, bool epreLocalrefvarPara = true) {
+    originalStTable.SetEPreLocalRefVar(ostIdx, epreLocalrefvarPara);
+  }
+
+  void SetZeroVersionIndex(const OStIdx &ostIdx, size_t zeroVersionIndexParam) {
+    originalStTable.SetZeroVersionIndex(ostIdx, zeroVersionIndexParam);
+  }
+
+  size_t GetVersionsIndicesSize(const OStIdx &ostIdx) const {
+    return originalStTable.GetVersionsIndicesSize(ostIdx);
+  }
+
+  void UpdateVarOstMap(const OStIdx &ostIdx, std::map<OStIdx, OriginalSt*> &varOstMap) {
+    originalStTable.UpdateVarOstMap(ostIdx, varOstMap);
+  }
+
+  // MIRSymbol query
+  const MIRSymbol &GetStmtMIRSymbol(const StmtNode &stmt) const {
+    return *(GetStmtsSSAPart().GetAssignedVarOf(stmt)->GetOst()->GetMIRSymbol());
+  }
+
+  bool IsInitVersion(size_t vstIdx, const OStIdx &ostIdx) const {
+    auto *ost = GetOriginalStFromID(ostIdx);
+    ASSERT(ost != nullptr, "null pointer check");
+    return ost->GetZeroVersionIndex() == vstIdx;
+  }
+
+  void CollectIterNextLevel(size_t vstIdx, OstPtrSet &resultOsts);
+ private:
+  MIRModule &mirModule;
+  MeFunction *func;
+  MapleAllocator versAlloc;
+  VersionStTable versionStTable;  // this uses special versMp because it will be freed earlier
+  OriginalStTable originalStTable;
+  StmtsSSAPart stmtsSSAPart;  // this uses special versMp because it will be freed earlier
+  MapleVector<MapleSet<BBId> *> defBBs4Ost; // gives the set of BBs that has def for each original symbol
+  bool wholeProgramScope = false;
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_SSA_TAB_H
diff --git a/src/mapleall/maple_me/include/sync_select.h b/src/mapleall/maple_me/include/sync_select.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c750094b0017662ca9934130858afa236b4181b
--- /dev/null
+++ b/src/mapleall/maple_me/include/sync_select.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_SYNCSELECT_H
+#define MAPLE_ME_INCLUDE_SYNCSELECT_H
+#include "me_function.h"
+#include "mir_module.h"
+#include "maple_phase.h"
+
+namespace maple {
+MAPLE_FUNC_PHASE_DECLARE(MESyncSelect, MeFunction)
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_SYNCSELECT_H
diff --git a/src/mapleall/maple_me/include/type_based_alias_analysis.h b/src/mapleall/maple_me/include/type_based_alias_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..24e62454164b76a79e78a1a62ced2c412e22c917
--- /dev/null
+++ b/src/mapleall/maple_me/include/type_based_alias_analysis.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_TYPE_BASED_ALIAS_ANALYSIS_H
+#define MAPLE_ME_INCLUDE_TYPE_BASED_ALIAS_ANALYSIS_H
+#include "alias_class.h"
+
+namespace maple {
+class TypeBasedAliasAnalysis {
+ public:
+  static bool MayAlias(const OriginalSt *ostA, const OriginalSt *ostB);
+  static bool FilterAliasElemOfRHSForIassign(const OriginalSt *aliasElemOst, const OriginalSt *lhsOst,
+                                             const OriginalSt *rhsOst);
+  static bool MayAliasTBAAForC(const OriginalSt *ostA, const OriginalSt *ostB);
+  static void ClearOstTypeUnsafeInfo();
+  static std::vector<bool> &GetPtrTypeUnsafe() {
+    return ptrValueTypeUnsafe;
+  }
+
+  static void SetVstValueTypeUnsafe(size_t vstIdx) {
+    if (vstIdx >= ptrValueTypeUnsafe.size()) {
+      ptrValueTypeUnsafe.resize(vstIdx + 1, false);
+    }
+    ptrValueTypeUnsafe[vstIdx] = true;
+  }
+
+  static void SetVstValueTypeUnsafe(const VersionSt &vst) {
+    SetVstValueTypeUnsafe(vst.GetIndex());
+  }
+
+  static bool IsValueTypeUnsafe(const VersionSt &vst) {
+    size_t vstIdx = vst.GetIndex();
+    if (vstIdx >= ptrValueTypeUnsafe.size()) {
+      return false;
+    }
+    return ptrValueTypeUnsafe[vstIdx];
+  }
+
+  static bool IsMemTypeUnsafe(const OriginalSt &ost) {
+    auto prevLevVstIdx = ost.GetPointerVstIdx();
+    if (prevLevVstIdx > ptrValueTypeUnsafe.size()) {
+      return false;
+    }
+    return ptrValueTypeUnsafe[prevLevVstIdx];
+  }
+
+ private:
+  static std::vector<bool> ptrValueTypeUnsafe; // index is OStIdx
+};
+} // namespace maple
+#endif // MAPLE_ME_INCLUDE_TYPE_BASED_ALIAS_ANALYSIS_H
diff --git a/src/mapleall/maple_me/include/union_find.h b/src/mapleall/maple_me/include/union_find.h
new file mode 100644
index 0000000000000000000000000000000000000000..387b03cb72dc706810e743d4dc240730fd1e1c02
--- /dev/null
+++ b/src/mapleall/maple_me/include/union_find.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_UNION_FIND_H
+#define MAPLE_ME_INCLUDE_UNION_FIND_H
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mpl_logging.h"
+#include "types_def.h"
+
+namespace maple {
+// This uses the Weighted Quick Union with Path Compression algorithm.
+// Build a flattened tree to represent each class, where all its class members
+// are linked together via the tree. The tree is represented by child pointing
+// to its parent only. The members of the same class are identified at any time
+// by having the same root, and the id of its root member can be used as class
+// id.
+class UnionFind {
+ public:
+  explicit UnionFind(MemPool &memPool)
+      : ufAlloc(&memPool), rootIDs(ufAlloc.Adapter()), sizeOfClass(ufAlloc.Adapter()) {}
+
+  UnionFind(MemPool &memPool, uint32 siz)
+      : ufAlloc(&memPool), num(siz), rootIDs(siz, 0, ufAlloc.Adapter()), sizeOfClass(siz, 0, ufAlloc.Adapter()) {
+    Reinit();
+  }
+
+  ~UnionFind() {
+    // for the root id's, the sum of their size should be population size
+#if DEBUG
+    size_t sum = 0;
+    for (size_t i = 0; i < num; ++i)
+      if (rootIDs[i] == i) {
+        // it is a root
+        sum += sizeOfClass[i];
+      }
+    ASSERT(sum == num, "Something wrong in UnionFind");
+#endif
+  }
+
+  void Reinit() {
+    for (size_t i = 0; i < num; ++i) {
+      rootIDs[i] = i;
+      sizeOfClass[i] = 1;
+    }
+  }
+
+  unsigned int NewMember() {
+    rootIDs.push_back(num);  // new member is its own root
+    sizeOfClass.push_back(1);
+    return ++num;
+  }
+
+  unsigned int NewMember(uint32 id) {
+    if (id + 1 >= rootIDs.size()) {
+      size_t oldSize = rootIDs.size();
+      uint incNum = id + 2 - rootIDs.size();
+      num += incNum;
+      rootIDs.insert(rootIDs.end(), incNum, 0);
+      sizeOfClass.insert(sizeOfClass.end(), incNum, 1);
+      for (size_t i = oldSize; i < rootIDs.size(); ++i) {
+        rootIDs[i] = i;  // new member is its own root
+      }
+    }
+    return num;
+  }
+
+  unsigned int Root(size_t i) {
+    while (rootIDs[i] != i) {
+      rootIDs[i] = rootIDs[rootIDs[i]];  // this compresses the path
+      i = rootIDs[i];
+    }
+    return i;
+  }
+
+  bool Find(size_t p, unsigned int q) {
+    return Root(p) == Root(q);
+  }
+
+  void Union(size_t p, size_t q) {
+    unsigned int i = Root(p);
+    unsigned int j = Root(q);
+    if (i == j) {
+      return;
+    }
+    // construct a balanced tree
+    if (sizeOfClass[i] < sizeOfClass[j]) {
+      rootIDs[i] = j;
+      sizeOfClass[j] += sizeOfClass[i];
+    } else {
+      rootIDs[j] = i;
+      sizeOfClass.at(i) += sizeOfClass.at(j);
+    }
+  }
+
+  unsigned int GetElementsNumber(size_t i) const {
+    ASSERT(i < sizeOfClass.size(), "index out of range");
+    return sizeOfClass[i];
+  }
+
+  bool SingleMemberClass(unsigned int p) {
+    unsigned int i = Root(p);
+    ASSERT(i < sizeOfClass.size(), "index out of range");
+    return sizeOfClass[i] == 1;
+  }
+
+  inline bool Find(unsigned int id) const {
+    return rootIDs.size() > id;
+  }
+
+ private:
+  MapleAllocator ufAlloc;
+  unsigned int num = 0;                     // the population size; can continue to increase
+  MapleVector<unsigned int> rootIDs;  // array index is id of each population member;
+  // value is id of the root member of its class;
+  // the member is a root if its value is itself;
+  // as its root changes, will keep updating so as to
+  // maintain a flat tree
+  MapleVector<unsigned int> sizeOfClass;  // gives number of elements in the tree rooted there
+};
+}  // namespace maple
+#endif  // MAPLE_ME_INCLUDE_UNION_FIND_H
diff --git a/src/mapleall/maple_me/include/ver_symbol.h b/src/mapleall/maple_me/include/ver_symbol.h
new file mode 100644
index 0000000000000000000000000000000000000000..579af1671a40c8582c43cfeae6fef9c42eaf85c8
--- /dev/null
+++ b/src/mapleall/maple_me/include/ver_symbol.h
@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_ME_INCLUDE_VER_SYMBOL_H
+#define MAPLE_ME_INCLUDE_VER_SYMBOL_H
+#include <iostream>
+#include "mir_module.h"
+#include "mir_symbol.h"
+#include "orig_symbol.h"
+
+namespace maple {
+class BB;  // circular dependency exists, no other choice
+class PhiNode;  // circular dependency exists, no other choice
+class MayDefNode;  // circular dependency exists, no other choice
+class MustDefNode;  // circular dependency exists, no other choice
+
+constexpr size_t kInvalidVstIdx = 0;
+class VersionSt {
+ public:
+  enum DefType {
+    kUnknown,
+    kAssign,
+    kPhi,
+    kMayDef,
+    kMustDef
+  };
+
+  VersionSt(size_t index, uint32 version, OriginalSt *ost)
+      : index(index),
+        version(version),
+        ost(ost),
+        defStmt() {}
+
+  ~VersionSt() = default;
+
+  size_t GetIndex() const {
+    return index;
+  }
+
+  int GetVersion() const {
+    return version;
+  }
+
+  void SetDefBB(BB *defbb) {
+    defBB = defbb;
+  }
+
+  BB *GetDefBB() const {
+    return defBB;
+  }
+
+  void DumpDefStmt() const;
+
+  bool IsInitVersion() const {
+    return version == kInitVersion;
+  }
+
+  DefType GetDefType() const {
+    return defType;
+  }
+
+  void SetDefType(DefType defineType) {
+    this->defType = defineType;
+  }
+
+  OStIdx GetOrigIdx() const {
+    return ost->GetIndex();
+  }
+
+  OriginalSt *GetOst() const {
+    return ost;
+  }
+
+  void SetOst(OriginalSt *originalSt) {
+    this->ost = originalSt;
+  }
+
+  const StmtNode *GetAssignNode() const {
+    return defStmt.assign;
+  }
+
+  StmtNode *GetAssignNode() {
+    return defStmt.assign;
+  }
+
+  void SetAssignNode(StmtNode *assignNode) {
+    defStmt.assign = assignNode;
+  }
+
+  PhiNode *GetPhi() const {
+    return defStmt.phi;
+  }
+  void SetPhi(PhiNode *phiNode) {
+    defStmt.phi = phiNode;
+  }
+
+  const MayDefNode *GetMayDef() const {
+    return defStmt.mayDef;
+  }
+  MayDefNode *GetMayDef() {
+    return defStmt.mayDef;
+  }
+  void SetMayDef(MayDefNode *mayDefNode) {
+    defStmt.mayDef = mayDefNode;
+  }
+
+  const MustDefNode *GetMustDef() const {
+    return defStmt.mustDef;
+  }
+  MustDefNode *GetMustDef() {
+    return defStmt.mustDef;
+  }
+  void SetMustDef(MustDefNode *mustDefNode) {
+    defStmt.mustDef = mustDefNode;
+  }
+
+  bool IsReturn() const {
+    return isReturn;
+  }
+
+  void Dump(bool omitName = false) const {
+    if (!omitName) {
+      ost->Dump();
+    }
+    LogInfo::MapleLogger() << "(vno" << version << "|vstIdx:" << index << ")";
+  }
+
+  bool DefByMayDef() const {
+    return defType == kMayDef;
+  }
+
+ private:
+  size_t index;     // index number in versionst_table_
+  int version;      // starts from 0 for each symbol
+  OriginalSt *ost;  // the index of related originalst in originalst_table
+  BB *defBB = nullptr;
+  DefType defType = kUnknown;
+
+  union DefStmt {
+    StmtNode *assign;
+    PhiNode *phi;
+    MayDefNode *mayDef;
+    MustDefNode *mustDef;
+  } defStmt;  // only valid after SSA
+
+  bool isReturn = false;  // the symbol will return in its function
+};
+
+class VersionStTable {
+ public:
+  explicit VersionStTable(MemPool &vstMp) : vstAlloc(&vstMp), versionStVector(vstAlloc.Adapter()) {
+    versionStVector.push_back(static_cast<VersionSt*>(nullptr));
+  }
+
+  using VersionStContainer = MapleVector<VersionSt*>;
+  using VersionStIterator = VersionStContainer::iterator;
+  using ConstVersionStIterator = VersionStContainer::const_iterator;
+
+  ~VersionStTable() = default;
+
+  VersionSt *CreateNextVersionSt(OriginalSt *ost);
+
+  void CreateZeroVersionSt(OriginalSt *ost);
+  VersionSt *GetOrCreateZeroVersionSt(OriginalSt &ost);
+
+  VersionSt *GetZeroVersionSt(const OriginalSt *ost) const {
+    CHECK_FATAL(ost, "ost is nullptr!");
+    CHECK_FATAL(!ost->GetVersionsIndices().empty(), "GetZeroVersionSt:: zero version has not been created");
+    return versionStVector[ost->GetZeroVersionIndex()];
+  }
+
+  size_t GetVersionStVectorSize() const {
+    return versionStVector.size();
+  }
+
+  VersionSt *GetVersionStVectorItem(size_t index) const {
+    CHECK_FATAL(index < versionStVector.size(), "out of range");
+    return versionStVector[index];
+  }
+
+  void SetVersionStVectorItem(size_t index, VersionSt *vst) {
+    CHECK_FATAL(index < versionStVector.size(), "out of range");
+    versionStVector[index] = vst;
+  }
+
+  MapleAllocator &GetVSTAlloc() {
+    return vstAlloc;
+  }
+
+  void Dump(const MIRModule *mod) const;
+
+  ConstVersionStIterator begin() const {
+    auto it = versionStVector.begin();
+    // first element in versionStVector is null.
+    ++it;
+    return it;
+  }
+
+  VersionStIterator begin() {
+    auto it = versionStVector.begin();
+    // first element in versionStVector is null.
+    ++it;
+    return it;
+  }
+
+  ConstVersionStIterator end() const {
+    return versionStVector.end();
+  }
+
+  VersionStIterator end() {
+    return versionStVector.end();
+  }
+
+ private:
+  MapleAllocator vstAlloc;                   // this stores versionStVector
+  MapleVector<VersionSt*> versionStVector;   // the vector that map a versionst's index to its pointer
+};
+}       // namespace maple
+#endif  // MAPLE_ME_INCLUDE_VER_SYMBOL_H
diff --git a/src/mapleall/maple_me/include/vst_use_info.h b/src/mapleall/maple_me/include/vst_use_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..254b9ff9016045be7627d65e9b5f4ee8bea4c436
--- /dev/null
+++ b/src/mapleall/maple_me/include/vst_use_info.h
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_VST_USE_INFO_H
+#define MAPLE_ME_INCLUDE_VST_USE_INFO_H
+#include <variant>
+#include "mir_nodes.h"
+#include "ssa.h"
+#include "bb.h"
+#include "me_function.h"
+#include "dominance.h"
+
+namespace maple {
+class VstUseItem final {
+ public:
+  explicit VstUseItem(StmtNode *useStmt) : useNode(useStmt) {}
+  explicit VstUseItem(PhiNode *usePhi) : useNode(usePhi) {}
+  explicit VstUseItem(MayUseNode *mayUse) : useNode(mayUse) {}
+
+  bool IsUsedByPhiNode() const {
+    return std::holds_alternative<PhiNode *>(useNode);
+  }
+  bool IsUsedByStmt() const {
+    return std::holds_alternative<StmtNode *>(useNode);
+  }
+  bool IsUsedByMayUseNode() const {
+    return std::holds_alternative<MayUseNode *>(useNode);
+  }
+
+  const StmtNode *GetStmt() const {
+    return Get<StmtNode>();
+  }
+
+  StmtNode *GetStmt() {
+    return Get<StmtNode>();
+  }
+
+  const PhiNode *GetPhi() const {
+    return Get<PhiNode>();
+  }
+
+  PhiNode *GetPhi() {
+    return Get<PhiNode>();
+  }
+
+  const MayUseNode *GetMayUse() const {
+    return Get<MayUseNode>();
+  }
+
+  MayUseNode *GetMayuse() {
+    return Get<MayUseNode>();
+  }
+
+  bool operator==(const VstUseItem &other) const {
+    return useNode == other.useNode;
+  }
+  bool operator!=(const VstUseItem &other) const {
+    return !(*this == other);
+  }
+
+  template<typename T> const T *Get() const {
+    ASSERT(std::holds_alternative<T *>(useNode), "Vst use site type error!");
+    return std::get<T *>(useNode);
+  }
+  template<typename T> T *Get() {
+    ASSERT(std::holds_alternative<T *>(useNode), "Vst use site type error!");
+    return std::get<T *>(useNode);
+  }
+
+ private:
+  std::variant<StmtNode *, PhiNode *, MayUseNode *> useNode;
+};
+
+using VstUseSiteList = MapleList<VstUseItem>;
+
+enum VstUnseInfoState {
+  kVstUseInfoInvalid = 0,
+  kVstUseInfoTopLevelVst = 1,
+  kVstUseInfoAddrTakenVst = 2
+};
+
+class VstUseInfo final {
+ public:
+  explicit VstUseInfo(MemPool *mp) : allocator(mp) {}
+
+  ~VstUseInfo() = default;
+
+  bool IsUseInfoOfTopLevelValid() const {
+    return useInfoState & kVstUseInfoTopLevelVst;
+  }
+  bool IsUseInfoInvalid() const {
+    return useInfoState == kVstUseInfoInvalid;
+  }
+
+  MapleVector<VstUseSiteList*> &GetAllUseSites() {
+    return *useSites;
+  }
+
+  VstUseSiteList *GetUseSitesOf(const VersionSt &vst) {
+    return (*useSites)[vst.GetIndex()];
+  }
+
+  template<typename T>
+  void AddUseSiteOfVst(const VersionSt *vst, T *useSite);
+
+  template<typename T>
+  void RemoveUseSiteOfVst(const VersionSt *vst, T *useSite);
+
+  template<typename T>
+  void UpdateUseSiteOfVst(const VersionSt *vst, T *oldUseSite, T *newUseSite);
+
+  void CollectUseInfoInBB(BB *bb);
+  void CollectUseInfoInStmt(StmtNode *stmt);
+  void CollectUseInfoInFunc(MeFunction *f, Dominance *dom, VstUnseInfoState state = kVstUseInfoTopLevelVst);
+
+ private:
+  void CollectUseInfoInExpr(BaseNode *expr, StmtNode *stmt);
+
+  MapleAllocator allocator;
+  SSATab *ssaTab = nullptr;
+  MapleVector<VstUseSiteList*> *useSites = nullptr; // index is vstIdx
+  VstUnseInfoState useInfoState = kVstUseInfoInvalid;
+};
+
+template<typename T>
+void VstUseInfo::AddUseSiteOfVst(const VersionSt *vst, T *useSite) {
+  if (vst == nullptr) {
+    return;
+  }
+  if (useInfoState == kVstUseInfoTopLevelVst) {
+    if (!IsLocalTopLevelOst(*vst->GetOst())) {
+      return;
+    }
+  }
+  size_t vstIdx = vst->GetIndex();
+  ASSERT(vstIdx < useSites->size(), "VersionSt out of range!");
+  if ((*useSites)[vstIdx] == nullptr) { // first use site
+    (*useSites)[vstIdx] = allocator.New<MapleList<VstUseItem>>(allocator.Adapter());
+  }
+  VstUseItem use(useSite);
+  if ((*useSites)[vstIdx]->empty() || (*useSites)[vstIdx]->front() != use) {
+    (*useSites)[vstIdx]->emplace_front(use);
+  }
+}
+
+template<typename T>
+void VstUseInfo::RemoveUseSiteOfVst(const VersionSt *vst, T *useSite) {
+  if (vst == nullptr) {
+    return;
+  }
+  size_t vstIdx = vst->GetIndex();
+  if (vstIdx >= useSites->size()) {
+    return;
+  }
+  auto *useList = (*useSites)[vstIdx];
+  if (useList == nullptr) {
+    return;
+  }
+  for (auto it = useList->begin(); it != useList->end(); ++it) {
+    if ((*it) == VstUseItem(useSite)) {
+      useList->erase(it);
+      return;
+    }
+  }
+}
+
+template<typename T>
+void VstUseInfo::UpdateUseSiteOfVst(const VersionSt *vst, T *oldUseSite, T *newUseSite) {
+  RemoveUseSiteOfVst(vst, oldUseSite);
+  AddUseSiteOfVst(vst, newUseSite);
+}
+} // namespace maple
+#endif // MAPLE_ME_INCLUDE_VST_USE_INFO_H
diff --git a/src/mapleall/maple_me/src/alias_class.cpp b/src/mapleall/maple_me/src/alias_class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a19bd0ff43cc9a9f4ca7c90222580e1fb67b5d2e
--- /dev/null
+++ b/src/mapleall/maple_me/src/alias_class.cpp
@@ -0,0 +1,2776 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "alias_class.h"
+#include "mpl_logging.h"
+#include "opcode_info.h"
+#include "ssa_mir_nodes.h"
+#include "mir_function.h"
+#include "mir_builder.h"
+#include "ipa_side_effect.h"
+#include "type_based_alias_analysis.h"
+
+namespace {
+using namespace maple;
+
+inline bool IsReadOnlyOst(const OriginalSt &ost) {
+  return ost.GetMIRSymbol()->HasAddrOfValues();
+}
+
+inline bool IsPotentialAddress(PrimType primType) {
+  return IsAddress(primType) || IsPrimitiveDynType(primType);
+}
+
+// return true if this expression opcode can result in a valid address
+static bool OpCanFormAddress(Opcode op) {
+  switch (op) {
+    case OP_dread:
+    case OP_regread:
+    case OP_iread:
+    case OP_ireadoff:
+    case OP_ireadfpoff:
+    case OP_ireadpcoff:
+    case OP_addrof:
+    case OP_addroffunc:
+    case OP_addroflabel:
+    case OP_addroffpc:
+    case OP_iaddrof:
+    case OP_constval:
+    case OP_conststr:
+    case OP_conststr16:
+    case OP_alloca:
+    case OP_malloc:
+    case OP_add:
+    case OP_sub:
+    case OP_select:
+    case OP_array:
+    case OP_intrinsicop:
+      return true;
+    default: ;
+  }
+  return false;
+}
+
+inline bool IsNullOrDummySymbolOst(const OriginalSt *ost) {
+  if ((ost == nullptr) || (ost && ost->IsSymbolOst() && (ost->GetMIRSymbol()->GetName() == "__nads_dummysym__"))) {
+    return true;
+  }
+  return false;
+}
+
+inline bool OriginalStIsAuto(const OriginalSt *ost) {
+  if (!ost->IsSymbolOst()) {
+    return false;
+  }
+  MIRSymbol *sym = ost->GetMIRSymbol();
+  return sym->GetStorageClass() == kScAuto || sym->GetStorageClass() == kScFormal;
+}
+
+// if epxr is type convertion, get the expr before convertion
+// expr op like cvt/retype/floor/round/ceil/trunc is type convertion
+inline BaseNode *RemoveTypeConversionIfExist(BaseNode *expr) {
+  while (kOpcodeInfo.IsTypeCvt(expr->GetOpCode())) {
+    expr = expr->Opnd(0);
+  }
+  return expr;
+}
+
+// result = first - second => elements in first and not in second
+template <typename FirstOstPtrSetType, typename SecondOstPtrSetType, typename ResOstPtrSetType>
+inline void OstPtrSetSub(const FirstOstPtrSetType &first, const SecondOstPtrSetType &second, ResOstPtrSetType &result) {
+  if (second.empty()) {
+    result.insert(first.begin(), first.end());
+  } else {
+    std::set_difference(first.begin(), first.end(), second.begin(), second.end(),
+                        std::inserter(result, result.end()), OriginalSt::OriginalStPtrComparator());
+  }
+}
+}  // namespace
+
+namespace maple {
+bool AliasClass::CallHasNoSideEffectOrPrivateDefEffect(const CallNode &stmt, FuncAttrKind attrKind) const {
+  ASSERT(attrKind == FUNCATTR_nosideeffect || attrKind == FUNCATTR_noprivate_defeffect, "Not supportted attrKind");
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt.GetPUIdx());
+  if (callee == nullptr) {
+    return false;
+  }
+  bool hasAttr = false;
+  if (callee->GetFuncAttrs().GetAttr(attrKind)) {
+    hasAttr = true;
+  } else if (!ignoreIPA) {
+    hasAttr = (attrKind == FUNCATTR_nosideeffect) ? (callee->IsNoDefEffect() && callee->IsNoDefArgEffect()) :
+                                                    callee->IsNoPrivateDefEffect();
+  }
+  return hasAttr;
+}
+
+const FuncDesc &AliasClass::GetFuncDescFromCallStmt(const CallNode &callstmt) const {
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callstmt.GetPUIdx());
+  return callee->GetFuncDesc();
+}
+// ost is a restrict pointer
+static bool IsRestrictPointer(const OriginalSt *ost) {
+  if (!IsAddress(ost->GetType()->GetPrimType())) {
+    return false;
+  }
+
+  if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) {
+    auto *symbol = ost->GetMIRSymbol();
+    auto fieldId = ost->GetFieldID();
+    if (fieldId != 0) {
+      auto type = symbol->GetType();
+      CHECK_FATAL(type->IsStructType(), "must be struct type");
+      bool restrictField = static_cast<MIRStructType*>(type)->IsFieldRestrict(fieldId);
+      return restrictField;
+    } else {
+      bool restrictPointer = symbol->GetAttr(ATTR_restrict);
+      return restrictPointer;
+    }
+  }
+  return false;
+}
+
+bool AliasClass::CallHasNoPrivateDefEffect(StmtNode *stmt) const {
+  if (calleeHasSideEffect) {
+    return true;
+  }
+  CallNode *callstmt = dynamic_cast<CallNode *>(stmt);
+  if (callstmt == nullptr) {
+    return true;
+  }
+  return CallHasNoSideEffectOrPrivateDefEffect(*callstmt, FUNCATTR_noprivate_defeffect);
+}
+
+// here starts pass 1 code
+void AliasClass::RecordAliasAnalysisInfo(const VersionSt &vst) {
+  if (IsNextLevNotAllDefsSeen(vst.GetIndex())) {
+    return;
+  }
+  auto &ost = *vst.GetOst();
+  if (IsNotAllDefsSeen(ost.GetIndex())) {
+    return;
+  }
+  if (ost.IsSymbolOst() && ost.GetIndirectLev() >= 0) {
+    const MIRSymbol *sym = ost.GetMIRSymbol();
+    if (sym->IsGlobal() && (mirModule.IsCModule() || (!sym->HasAddrOfValues() && !sym->GetIsTmp()))) {
+      (void)globalsMayAffectedByClinitCheck.insert(ost.GetIndex());
+      if (!sym->IsReflectionClassInfo()) {
+        if (!ost.IsFinal() || InConstructorLikeFunc()) {
+          (void)globalsAffectedByCalls.insert(&ost);
+          if (mirModule.IsCModule()) {
+            SetNotAllDefsSeen(ost.GetIndex());
+          }
+        }
+        SetNextLevNotAllDefsSeen(vst.GetIndex());
+      }
+    } else if (mirModule.IsCModule() &&
+               (sym->GetStorageClass() == kScPstatic || sym->GetStorageClass() == kScFstatic)) {
+      (void)globalsAffectedByCalls.insert(&ost);
+      SetNotAllDefsSeen(ost.GetIndex());
+      SetNextLevNotAllDefsSeen(vst.GetIndex());
+    }
+  }
+
+  if ((ost.IsFormal() && !IsRestrictPointer(&ost) && ost.GetIndirectLev() >= 0) || ost.GetIndirectLev() > 0) {
+    SetNextLevNotAllDefsSeen(vst.GetIndex());
+  }
+  if (ost.GetIndirectLev() > 1 || (IsNextLevNotAllDefsSeen(ost.GetPointerVstIdx()) && !ost.IsFinal())) {
+    SetNotAllDefsSeen(ost.GetIndex());
+  }
+  unionFind.NewMember(vst.GetIndex());
+}
+
+OffsetType AliasClass::OffsetInBitOfArrayElement(const ArrayNode *arrayNode) {
+  ASSERT(arrayNode->GetOpCode() == OP_array, "must be arrayNode");
+  bool arrayAddrIsConst = arrayNode->Opnd(0)->GetOpCode() == OP_addrof;
+  if (!arrayAddrIsConst) {
+    return OffsetType::InvalidOffset();
+  }
+
+  std::vector<int64> arrayIndexVector(arrayNode->NumOpnds() - 1, 0);
+  for (uint32 opndId = 1; opndId < arrayNode->NumOpnds(); ++opndId) {
+    auto *opnd = arrayNode->Opnd(opndId);
+    if (!opnd->IsConstval()) {
+      return OffsetType::InvalidOffset();
+    }
+    auto mirConst = static_cast<ConstvalNode*>(opnd)->GetConstVal();
+    ASSERT(mirConst->GetKind() == kConstInt, "array index must be integer");
+    int64 index = static_cast<MIRIntConst*>(mirConst)->GetExtValue();
+    arrayIndexVector[opndId - 1] = index;
+  }
+
+  auto *ptrTypeOfArrayType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(arrayNode->GetTyIdx());
+  ASSERT(ptrTypeOfArrayType->IsMIRPtrType(), "must be pointer type");
+  auto *mirType = static_cast<MIRPtrType*>(ptrTypeOfArrayType)->GetPointedType();
+  constexpr uint32 kUpperBoundaryOfElemNumOfIndexSensitiveArray = 100;
+  switch (mirType->GetKind()) {
+    case kTypeArray: {
+      auto arrayType = static_cast<MIRArrayType *>(mirType);
+      if (arrayType->ElemNumber() > kUpperBoundaryOfElemNumOfIndexSensitiveArray) {
+        return OffsetType::InvalidOffset();
+      }
+      return OffsetType(arrayType->GetBitOffsetFromArrayAddress(arrayIndexVector));
+    }
+    case kTypeFArray:
+    case kTypeJArray: {
+      ASSERT(arrayIndexVector.size() == 1, "FArray/JArray has single index");
+      return OffsetType(static_cast<MIRFarrayType*>(mirType)->GetBitOffsetFromArrayAddress(arrayIndexVector.front()));
+    }
+    default: {
+      CHECK_FATAL(false, "unsupported array type");
+      return OffsetType::InvalidOffset();
+    }
+  }
+}
+
+// tyIdx is pointer type of memory type, fld is the field of memory type,
+// offset is the offset of base.
+//     |-----offset------|---|---|-----|
+// prevLevOst          tyIdx fld
+OriginalSt *AliasClass::FindOrCreateExtraLevOst(SSATab *ssaTable, const VersionSt *pointerVst, const TyIdx &tyIdx,
+                                                FieldID fld, OffsetType offset) {
+  auto nextLevOst = ssaTable->GetOriginalStTable().FindOrCreateExtraLevOriginalSt(pointerVst, tyIdx, fld, offset);
+  ssaTable->GetVersionStTable().CreateZeroVersionSt(nextLevOst);
+  return nextLevOst;
+}
+
+static void UpdateFieldIdAndPtrType(const MIRType &baseType, FieldID baseFldId, OffsetType &offset,
+                                    TyIdx &memPtrTyIdx, FieldID &fld) {
+  MIRType *memPtrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(memPtrTyIdx);
+  ASSERT(memPtrType->IsMIRPtrType(), "tyIdx is TyIdx of iread/iassign, must be pointer type!");
+  auto *memType = static_cast<MIRPtrType*>(memPtrType)->GetPointedType();
+  if (fld != 0) {
+    CHECK_FATAL(memType->IsStructType(), "must be struct type");
+    // to be conservative, return for out-of-bound fld
+    if (static_cast<int32>(memType->NumberOfFieldIDs()) < fld) {
+      return;
+    }
+    offset += static_cast<MIRStructType*>(memType)->GetBitOffsetFromBaseAddr(fld);
+  }
+
+  if (offset.IsInvalid()) {
+    return;
+  }
+  if (!baseType.IsMIRPtrType()) {
+    return;
+  }
+  if (baseFldId != 0) {
+    return;
+  }
+  MIRType *baseMemType = static_cast<const MIRPtrType&>(baseType).GetPointedType();
+  if (!baseMemType->IsStructType() ||
+      static_cast<int32>(baseMemType->NumberOfFieldIDs()) < baseFldId) {
+    return;
+  }
+  auto *structType = static_cast<MIRStructType*>(baseMemType);
+  MIRType *fieldType = structType->GetFieldType(baseFldId);
+  if (fieldType->GetTypeIndex() != memType->GetTypeIndex()) {
+    return;
+  }
+
+  auto newFldId = baseFldId + fld;
+  auto offsetOfNewFld = structType->GetBitOffsetFromBaseAddr(newFldId);
+  if (offset.val != offsetOfNewFld) {
+    return;
+  }
+
+  memPtrTyIdx = baseType.GetTypeIndex();
+  fld = newFldId;
+}
+
+// return next level of baseAddress. Argument tyIdx specifies the pointer of the memory accessed.
+// fieldId represent offset from type of this memory.
+// Example: iread <*type> fld (base) or iassign <*type> fld (base):
+//   tyIdx is TyIdx of <*type>(notice not <type>), fieldId is fld
+VersionSt *AliasClass::FindOrCreateVstOfExtraLevOst(BaseNode &expr, const TyIdx &tyIdx,
+                                                    FieldID fieldId, bool typeHasBeenCasted) {
+  auto *baseAddr = RemoveTypeConversionIfExist(&expr);
+  AliasInfo aliasInfoOfBaseAddress = CreateAliasInfoExpr(*baseAddr);
+  if (aliasInfoOfBaseAddress.vst == nullptr) {
+    return FindOrCreateDummyNADSVst();
+  }
+  auto *vstOfBaseAddress = aliasInfoOfBaseAddress.vst;
+  auto *ostOfBaseAddress = vstOfBaseAddress->GetOst();
+  if (mirModule.IsCModule() && IsNullOrDummySymbolOst(ostOfBaseAddress)) {
+    return FindOrCreateDummyNADSVst();
+  }
+  // calculate the offset of extraLevOst (i.e. offset from baseAddr)
+  OffsetType offset = typeHasBeenCasted ? OffsetType(kOffsetUnknown) : aliasInfoOfBaseAddress.offset;
+  // If base has a valid baseFld, check type of this baseFld. If it is the same as tyIdx,
+  // update tyIdx as base memory type (not fieldType now), update fieldId by merging fieldId and baseFld
+  TyIdx newTyIdx = tyIdx;
+  MIRType *baseType = ostOfBaseAddress->GetType();
+  FieldID baseFld = aliasInfoOfBaseAddress.fieldID;
+  UpdateFieldIdAndPtrType(*baseType, baseFld, offset, newTyIdx, fieldId);
+
+  auto *nextLevOst = FindOrCreateExtraLevOst(&ssaTab, vstOfBaseAddress, newTyIdx, fieldId, offset);
+  ASSERT(nextLevOst != nullptr, "failed in creating next-level-ost");
+  auto *zeroVersionOfNextLevOst = ssaTab.GetVerSt(nextLevOst->GetZeroVersionIndex());
+  RecordAliasAnalysisInfo(*zeroVersionOfNextLevOst);
+  return zeroVersionOfNextLevOst;
+}
+
+VersionSt &AliasClass::FindOrCreateVstOfAddrofOSt(OriginalSt &oSt) {
+  CHECK_FATAL(oSt.GetIndirectLev() == 0, "ost must be at level 0");
+  auto vstOfAddrofOst = ssaTab.GetVerSt(oSt.GetPointerVstIdx());
+  if (vstOfAddrofOst != nullptr) {
+    return *vstOfAddrofOst;
+  }
+
+  OriginalSt *zeroFieldIDOst = &oSt;
+  if (oSt.GetFieldID() != 0) {
+    zeroFieldIDOst = ssaTab.FindOrCreateSymbolOriginalSt(*oSt.GetMIRSymbol(), oSt.GetPuIdx(), 0);
+    auto *zeroVersionOfZeroFieldIDOst = ssaTab.GetVersionStTable().GetOrCreateZeroVersionSt(*zeroFieldIDOst);
+    RecordAliasAnalysisInfo(*zeroVersionOfZeroFieldIDOst);
+  }
+
+  OriginalSt *addrofOst = ssaTab.FindOrCreateAddrofSymbolOriginalSt(zeroFieldIDOst);
+  auto *zeroVersionVst = ssaTab.GetVerSt(addrofOst->GetZeroVersionIndex());
+
+  if (oSt.GetFieldID() != 0) {
+    oSt.SetPointerVst(zeroVersionVst);
+    ssaTab.GetOriginalStTable().AddNextLevelOstOfVst(zeroVersionVst, &oSt);
+  }
+
+  RecordAliasAnalysisInfo(*zeroVersionVst);
+  return *zeroVersionVst;
+}
+
+AliasInfo AliasClass::CreateAliasInfoExpr(BaseNode &expr) {
+  switch (expr.GetOpCode()) {
+    case OP_addrof: {
+      AddrofSSANode &addrof = static_cast<AddrofSSANode &>(expr);
+      VersionSt *vst = addrof.GetSSAVar();
+      OriginalSt &oSt = *vst->GetOst();
+      oSt.SetAddressTaken();
+      RecordAliasAnalysisInfo(*vst);
+      auto vstOfAddrof = &FindOrCreateVstOfAddrofOSt(oSt);
+      int64 offsetVal =
+          (addrof.GetFieldID() == 0) ? 0 : oSt.GetMIRSymbol()->GetType()->GetBitOffsetFromBaseAddr(oSt.GetFieldID());
+      return AliasInfo(vstOfAddrof, addrof.GetFieldID(), OffsetType(offsetVal));
+    }
+    case OP_dread: {
+      VersionSt *vst = static_cast<AddrofSSANode&>(expr).GetSSAVar();
+      OriginalSt *ost = vst->GetOst();
+      if (ost->GetFieldID() != 0 && ost->GetPrevLevelOst() == nullptr) {
+        (void) FindOrCreateVstOfAddrofOSt(*ost);
+      }
+
+      RecordAliasAnalysisInfo(*vst);
+      return AliasInfo(vst, 0, OffsetType(0));
+    }
+    case OP_regread: {
+      VersionSt *vst = static_cast<RegreadSSANode&>(expr).GetSSAVar();
+      OriginalSt &oSt = *vst->GetOst();
+      return (oSt.IsSpecialPreg()) ? AliasInfo() : AliasInfo(vst, 0);
+    }
+    case OP_iread: {
+      auto &iread = static_cast<IreadSSANode&>(expr);
+      MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread.GetTyIdx());
+      CHECK_FATAL(mirType->GetKind() == kTypePointer, "CreateAliasInfoExpr: ptr type expected in iread");
+      auto *typeOfField = static_cast<MIRPtrType *>(mirType)->GetPointedType();
+      if (iread.GetFieldID() > 0) {
+        typeOfField = static_cast<MIRStructType *>(typeOfField)->GetFieldType(iread.GetFieldID());
+      }
+      bool typeHasBeenCasted = IreadedMemInconsistentWithPointedType(iread.GetPrimType(), typeOfField->GetPrimType());
+      return AliasInfo(
+          FindOrCreateVstOfExtraLevOst(*iread.Opnd(0), iread.GetTyIdx(), iread.GetFieldID(), typeHasBeenCasted),
+          0, OffsetType(0));
+    }
+    case OP_iaddrof: {
+      auto &iread = static_cast<IreadNode&>(expr);
+      const auto &aliasInfo = CreateAliasInfoExpr(*iread.Opnd(0));
+      OffsetType offset = aliasInfo.offset;
+      if (iread.GetFieldID() != 0) {
+        auto mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread.GetTyIdx());
+        auto pointeeType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+        OffsetType offsetOfField(pointeeType->GetBitOffsetFromBaseAddr(iread.GetFieldID()));
+        offset = offset + offsetOfField;
+      }
+      return AliasInfo(aliasInfo.vst, iread.GetFieldID(), offset);
+    }
+    case OP_add:
+    case OP_sub: {
+      const auto &aliasInfo = CreateAliasInfoExpr(*expr.Opnd(0));
+      (void) CreateAliasInfoExpr(*expr.Opnd(1));
+
+      if (aliasInfo.offset.IsInvalid()) {
+        return AliasInfo(aliasInfo.vst, 0, OffsetType::InvalidOffset());
+      }
+
+      auto *opnd = expr.Opnd(1);
+      if (!opnd->IsConstval() || !IsAddress(expr.GetPrimType())) {
+        return AliasInfo(aliasInfo.vst, 0, OffsetType::InvalidOffset());
+      }
+      auto mirConst = static_cast<ConstvalNode*>(opnd)->GetConstVal();
+      CHECK_FATAL(mirConst->GetKind() == kConstInt, "array index must be integer");
+      int64 constVal = static_cast<MIRIntConst*>(mirConst)->GetExtValue();
+      if (expr.GetOpCode() == OP_sub) {
+        constVal = -constVal;
+      } else {
+        ASSERT(expr.GetOpCode() == OP_add, "Wrong operation!");
+      }
+      OffsetType newOffset = aliasInfo.offset + static_cast<uint64>(constVal) * static_cast<uint64>(bitsPerByte);
+      return AliasInfo(aliasInfo.vst, 0, newOffset);
+    }
+    case OP_array: {
+      for (size_t i = 1; i < expr.NumOpnds(); ++i) {
+        (void) CreateAliasInfoExpr(*expr.Opnd(i));
+      }
+
+      const auto &aliasInfo = CreateAliasInfoExpr(*expr.Opnd(0));
+      OffsetType offset = OffsetInBitOfArrayElement(static_cast<const ArrayNode*>(&expr));
+      OffsetType newOffset = offset + aliasInfo.offset;
+      return AliasInfo(aliasInfo.vst, 0, newOffset);
+    }
+    case OP_cvt:
+    case OP_retype: {
+      return CreateAliasInfoExpr(*expr.Opnd(0));
+    }
+    case OP_select: {
+      (void) CreateAliasInfoExpr(*expr.Opnd(0));
+      AliasInfo ainfo = CreateAliasInfoExpr(*expr.Opnd(1));
+      AliasInfo ainfo2 = CreateAliasInfoExpr(*expr.Opnd(2));
+      if (!OpCanFormAddress(expr.Opnd(1)->GetOpCode()) && !OpCanFormAddress(expr.Opnd(2)->GetOpCode())) {
+        break;
+      }
+      if (ainfo.vst == nullptr) {
+        return ainfo2;
+      }
+      if (ainfo2.vst == nullptr) {
+        return ainfo;
+      }
+      ApplyUnionForDassignCopy(*ainfo.vst, ainfo2.vst, *expr.Opnd(2));
+      return ainfo;
+    }
+    case OP_intrinsicop: {
+      auto &intrn = static_cast<IntrinsicopNode&>(expr);
+      if (intrn.GetIntrinsic() == INTRN_MPL_READ_OVTABLE_ENTRY ||
+          (intrn.GetIntrinsic() == INTRN_JAVA_MERGE && intrn.NumOpnds() == 1 &&
+           intrn.GetNopndAt(0)->GetOpCode() == OP_dread)) {
+        return CreateAliasInfoExpr(*intrn.GetNopndAt(0));
+      }
+      IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrn.GetIntrinsic()];
+      if (intrinDesc->IsVectorOp()) {
+        SetPtrOpndsNextLevNADS(0, static_cast<unsigned int>(intrn.NumOpnds()), intrn.GetNopnd(),
+                               false);
+        return AliasInfo();
+      }
+      // fall-through
+    }
+    [[clang::fallthrough]];
+    default:
+      for (size_t i = 0; i < expr.NumOpnds(); ++i) {
+        (void) CreateAliasInfoExpr(*expr.Opnd(i));
+      }
+  }
+  return AliasInfo();
+}
+
+// when a mustDef is a pointer, set its pointees' notAllDefsSeen flag to true
+void AliasClass::SetNotAllDefsSeenForMustDefs(const StmtNode &callas) {
+  MapleVector<MustDefNode> &mustDefs = ssaTab.GetStmtsSSAPart().GetMustDefNodesOf(callas);
+  for (auto &mustDef : mustDefs) {
+    RecordAliasAnalysisInfo(*mustDef.GetResult());
+    SetNextLevNotAllDefsSeen(mustDef.GetResult()->GetIndex());
+  }
+}
+
+// given a struct/union assignment, regard it as if the fields that appear
+// in the code are also assigned
+void AliasClass::ApplyUnionForFieldsInCopiedAgg() {
+  for (const auto &ostPair : aggsToUnion) {
+    OriginalSt *lhsost = ostPair.first;
+    OriginalSt *rhsost = ostPair.second;
+    auto *preLevOfLHSOst = ssaTab.GetVerSt(lhsost->GetPointerVstIdx());
+    if (preLevOfLHSOst == nullptr) {
+      preLevOfLHSOst = &FindOrCreateVstOfAddrofOSt(*lhsost);
+    }
+    auto *preLevOfRHSOst = ssaTab.GetVerSt(rhsost->GetPointerVstIdx());
+    if (preLevOfRHSOst == nullptr) {
+      preLevOfRHSOst = &FindOrCreateVstOfAddrofOSt(*rhsost);
+    }
+
+    MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsost->GetTyIdx());
+    MIRStructType *mirStructType = static_cast<MIRStructType *>(mirType);
+    FieldID numFieldIDs = static_cast<FieldID>(mirStructType->NumberOfFieldIDs());
+    auto tyIdxOfPrevLevOst = preLevOfLHSOst->GetOst()->GetTyIdx();
+    for (FieldID fieldID = 1; fieldID <= numFieldIDs; fieldID++) {
+      MIRType *fieldType = mirStructType->GetFieldType(fieldID);
+      if (!IsPotentialAddress(fieldType->GetPrimType())) {
+        continue;
+      }
+      OffsetType offset(mirStructType->GetBitOffsetFromBaseAddr(fieldID));
+
+      auto fieldOstLHS = ssaTab.GetOriginalStTable().FindExtraLevOriginalSt(
+          preLevOfLHSOst, tyIdxOfPrevLevOst, fieldType, fieldID, offset);
+      auto fieldOstRHS = ssaTab.GetOriginalStTable().FindExtraLevOriginalSt(
+          preLevOfRHSOst, tyIdxOfPrevLevOst, fieldType, fieldID, offset);
+      if (fieldOstLHS == nullptr && fieldOstRHS == nullptr) {
+        continue;
+      }
+      if (fieldOstLHS == nullptr) {
+        auto ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(lhsost->GetTyIdx());
+        fieldOstLHS = ssaTab.GetOriginalStTable().FindOrCreateExtraLevOriginalSt(
+            preLevOfLHSOst, ptrType->GetTypeIndex(), fieldID, offset);
+      }
+      if (fieldOstRHS == nullptr) {
+        auto ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(rhsost->GetTyIdx());
+        fieldOstRHS = ssaTab.GetOriginalStTable().FindOrCreateExtraLevOriginalSt(
+            preLevOfRHSOst, ptrType->GetTypeIndex(), fieldID, offset);
+      }
+
+      auto *zeroVersionStOfFieldOstLHS = ssaTab.GetVersionStTable().GetOrCreateZeroVersionSt(*fieldOstLHS);
+      RecordAliasAnalysisInfo(*zeroVersionStOfFieldOstLHS);
+
+      auto *zeroVersionStOfFieldOstRHS = ssaTab.GetVersionStTable().GetOrCreateZeroVersionSt(*fieldOstRHS);
+      RecordAliasAnalysisInfo(*zeroVersionStOfFieldOstRHS);
+
+      CHECK_FATAL(fieldOstLHS, "fieldOstLHS is nullptr!");
+      CHECK_FATAL(fieldOstRHS, "fieldOstRHS is nullptr!");
+      unionFind.Union(fieldOstLHS->GetZeroVersionIndex(), fieldOstRHS->GetZeroVersionIndex());
+    }
+  }
+}
+
+// There are three cases that cause ptr escape from its original definition:
+// 1. pointer formal parameters for function definition; (has been dealed in UnionForNADS)
+// 2. pointer actual parameters for function call; (has been dealed in call stmts)
+// 3. pointer assigned to other variable whose alias will never be analyzed. (dealed here)
+//    - integer <- ptr or vice versa
+//    - agg <- ptr or vice versa
+//
+// return true if ptr escapes
+bool AliasClass::SetNextLevNADSForEscapePtr(const VersionSt &lhsVst, BaseNode &rhs) {
+  TyIdx lhsTyIdx = lhsVst.GetOst()->GetTyIdx();
+  PrimType lhsPtyp = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx)->GetPrimType();
+  BaseNode *realRhs = RemoveTypeConversionIfExist(&rhs);
+  PrimType rhsPtyp = realRhs->GetPrimType();
+  if (lhsPtyp != rhsPtyp) {
+    if ((IsPotentialAddress(lhsPtyp) && !IsPotentialAddress(rhsPtyp)) ||
+        (!IsPotentialAddress(lhsPtyp) && IsPotentialAddress(rhsPtyp))) {
+      SetNextLevNotAllDefsSeen(lhsVst.GetIndex());
+      AliasInfo realRhsAinfo = CreateAliasInfoExpr(*realRhs);
+      if (realRhsAinfo.vst != nullptr) {
+        SetNextLevNotAllDefsSeen(realRhsAinfo.vst->GetIndex());
+      }
+      return true;
+    } else if (IsPotentialAddress(lhsPtyp) &&
+               realRhs->GetOpCode() == OP_constval &&
+               static_cast<ConstvalNode*>(realRhs)->GetConstVal()->IsZero()) {
+      // special case, pointer initial : ptr <- 0
+      // In some cases for some language like C, pointers may be initialized as null pointer at first,
+      // and assigned a new value in other program site. If we do not handle this case, all pointers
+      // with 0 intial value will be set nextLevNADS and their nextLev will be unionized after this step.
+      // The result is right, but the set of nextLevNADS will be very large, leading to a great amount of
+      // aliasing pointers and the imprecision of the alias analyse result.
+      // Hence we do nothing but return true here to skip setting pointer nextLevNADS.
+      return true;
+    }
+  }
+  return false;
+}
+
+void AliasClass::ApplyUnionForDassignCopy(VersionSt &lhsVst, VersionSt *rhsVst, BaseNode &rhs) {
+  if (SetNextLevNADSForEscapePtr(lhsVst, rhs)) {
+    return;
+  }
+  if (rhsVst == nullptr) {
+    SetNextLevNotAllDefsSeen(lhsVst.GetIndex());
+    return;
+  }
+
+  auto *rhsOst = rhsVst->GetOst();
+  if (rhsOst->GetIndirectLev() < 0) {
+    for (auto *ost : *ssaTab.GetOriginalStTable().GetNextLevelOstsOfVst(rhsVst)) {
+      SetNextLevNotAllDefsSeen(ost->GetZeroVersionIndex());
+    }
+  }
+
+  if (mirModule.IsCModule()) {
+    auto *lhsOst = lhsVst.GetOst();
+    TyIdx lhsTyIdx = lhsOst->GetTyIdx();
+    TyIdx rhsTyIdx = rhsOst->GetTyIdx();
+    MIRType *rhsType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(rhsTyIdx);
+    if (lhsTyIdx == rhsTyIdx &&
+        (rhsType->GetKind() == kTypeStruct || rhsType->GetKind() == kTypeUnion)) {
+      if (lhsOst->GetIndex() < rhsOst->GetIndex()) {
+        aggsToUnion[lhsOst] = rhsOst;
+      } else {
+        aggsToUnion[rhsOst] = lhsOst;
+      }
+    }
+  }
+
+  if (rhsOst->GetIndirectLev() > 0 || IsNotAllDefsSeen(rhsOst->GetIndex())) {
+    SetNextLevNotAllDefsSeen(lhsVst.GetIndex());
+    return;
+  }
+  PrimType rhsPtyp = rhsOst->GetType()->GetPrimType();
+  if (!(IsPrimitiveInteger(rhsPtyp) && GetPrimTypeSize(rhsPtyp) == GetPrimTypeSize(PTY_ptr)) ||
+      kOpcodeInfo.NotPure(rhs.GetOpCode()) ||
+      HasMallocOpnd(&rhs) ||
+      (rhs.GetOpCode() == OP_addrof && IsReadOnlyOst(*rhsOst))) {
+    return;
+  }
+  unionFind.Union(lhsVst.GetIndex(), rhsVst->GetIndex());
+}
+
+void AliasClass::SetPtrOpndNextLevNADS(const BaseNode &opnd, VersionSt *vst, bool hasNoPrivateDefEffect) {
+  if (vst == nullptr) {
+    return;
+  }
+
+  auto *ost = vst->GetOst();
+  if (IsPotentialAddress(opnd.GetPrimType()) &&
+      !(hasNoPrivateDefEffect && ost->IsPrivate()) &&
+      !(opnd.GetOpCode() == OP_addrof && IsReadOnlyOst(*ost))) {
+    SetNextLevNotAllDefsSeen(vst->GetIndex());
+    auto *prevLevVst = ssaTab.GetVerSt(ost->GetPointerVstIdx());
+    if (ost->GetOffset().IsInvalid() && prevLevVst != nullptr) {
+      auto *siblingOsts = ssaTab.GetOriginalStTable().GetNextLevelOstsOfVst(prevLevVst);
+      for (auto *mayValueAliasOst : *siblingOsts) {
+        if (!IsPotentialAddress(mayValueAliasOst->GetType()->GetPrimType())) {
+          continue;
+        }
+        SetNextLevNotAllDefsSeen(mayValueAliasOst->GetZeroVersionIndex());
+        unionFind.Union(vst->GetIndex(), mayValueAliasOst->GetZeroVersionIndex());
+      }
+    }
+  }
+  if (opnd.GetOpCode() == OP_cvt) {
+    SetPtrOpndNextLevNADS(*opnd.Opnd(0), vst, hasNoPrivateDefEffect);
+  }
+}
+
+// Set aliasElem of the pointer-type opnds of a call as next_level_not_all_defines_seen
+void AliasClass::SetPtrOpndsNextLevNADS(unsigned int start, unsigned int end,
+                                        MapleVector<BaseNode*> &opnds,
+                                        bool hasNoPrivateDefEffect) {
+  for (size_t i = start; i < end; ++i) {
+    BaseNode *opnd = opnds[i];
+    AliasInfo ainfo = CreateAliasInfoExpr(*opnd);
+    SetPtrOpndNextLevNADS(*opnd, ainfo.vst, hasNoPrivateDefEffect);
+  }
+}
+
+void AliasClass::SetAggPtrFieldsNextLevNADS(const OriginalSt &ost) {
+  MIRTypeKind typeKind = ost.GetType()->GetKind();
+  if (typeKind == kTypeStruct || typeKind == kTypeUnion || typeKind == kTypeStructIncomplete) {
+    auto *structType = static_cast<MIRStructType*>(ost.GetType());
+    auto *prevVst = ssaTab.GetVerSt(ost.GetPointerVstIdx());
+    // if prevOst exist, all ptr nextLev ost should be set NextLevNADS
+    if (prevVst != nullptr) {
+      auto *nextLevelOsts = ssaTab.GetOriginalStTable().GetNextLevelOstsOfVst(prevVst);
+      for (auto *nextOst : *nextLevelOsts) {
+        if (IsNextLevNotAllDefsSeen(nextOst->GetZeroVersionIndex())) {
+          continue; // has been set before
+        }
+        // pointer arithmetic may cause ptr escape from no address type
+        // e.g.
+        // Examples: struct Node {
+        // Examples:  int val;
+        // Examples:  Node *next;
+        // Examples: } node;
+        // Examples: *((int*)&node + 1) <- ptr :
+        // LHS is next, and ptr will escape, but LHS's primtype is agg, not an address type.
+        //
+        // Hence we should not skip for this case
+        if (!IsPotentialAddress(nextOst->GetType()->GetPrimType())) {
+          MIRType *prevType = static_cast<MIRPtrType*>(prevVst->GetOst()->GetType())->GetPointedType();
+          int64 bitOffset = prevType->GetBitOffsetFromBaseAddr(nextOst->GetFieldID());
+          if (nextOst->GetOffset().val == bitOffset) {
+            continue;
+          }
+        }
+        SetNextLevNotAllDefsSeen(nextOst->GetZeroVersionIndex());
+      }
+      return;
+    }
+    // if prevOst not exist, all ptr field should be set NextLevNADS
+    FieldID numFieldIDs = static_cast<FieldID>(structType->NumberOfFieldIDs());
+    for (FieldID fieldID = 1; fieldID <= numFieldIDs; fieldID++) {
+      MIRType *fieldType = structType->GetFieldType(fieldID);
+      if (!IsPotentialAddress(fieldType->GetPrimType())) {
+        continue;
+      }
+      int64 bitOffset = structType->GetBitOffsetFromBaseAddr(fieldID);
+      OffsetType offset(bitOffset);
+      OriginalSt *fldOst = ssaTab.GetOriginalStTable().FindSymbolOriginalSt(
+          *ost.GetMIRSymbol(), fieldID, fieldType->GetTypeIndex(), offset);
+      if (fldOst != nullptr) {
+        SetNextLevNotAllDefsSeen(fldOst->GetZeroVersionIndex());
+      }
+    }
+  }
+}
+
+void AliasClass::SetAggOpndPtrFieldsNextLevNADS(MapleVector<BaseNode*> &opnds) {
+  for (size_t i = 0; i < opnds.size(); ++i) {
+    BaseNode *opnd = opnds[i];
+    if (opnd->GetPrimType() != PTY_agg) {
+      continue;
+    }
+    AliasInfo aInfo = CreateAliasInfoExpr(*opnd);
+    if (aInfo.vst == nullptr ||
+        (IsNextLevNotAllDefsSeen(aInfo.vst->GetIndex()) &&
+         aInfo.vst->GetOst()->GetIndirectLev() > 0)) {
+      continue;
+    }
+    SetAggPtrFieldsNextLevNADS(*aInfo.vst->GetOst());
+  }
+}
+
+void AliasClass::SetPtrFieldsOfAggNextLevNADS(const BaseNode *opnd, const VersionSt *vst) {
+  if (opnd->GetPrimType() != PTY_agg) {
+    return;
+  }
+  if (vst == nullptr ||
+      (IsNextLevNotAllDefsSeen(vst->GetIndex()) &&
+       vst->GetOst()->GetIndirectLev() > 0)) {
+    return;
+  }
+  SetAggPtrFieldsNextLevNADS(*vst->GetOst());
+}
+
+// Iteratively propagate type unsafe info to next level.
+void AliasClass::PropagateTypeUnsafeVertically(const VersionSt &vst) const {
+  auto *nextLevelOsts = ssaTab.GetOriginalStTable().GetNextLevelOstsOfVst(&vst);
+  if (nextLevelOsts == nullptr) {
+    return;
+  }
+  for (auto *nextLevOst : *nextLevelOsts) {
+    auto *zeroVersionSt = ssaTab.GetVersionStTable().GetZeroVersionSt(nextLevOst);
+    TypeBasedAliasAnalysis::SetVstValueTypeUnsafe(*zeroVersionSt);
+    PropagateTypeUnsafeVertically(*zeroVersionSt);
+  }
+}
+
+bool AliasClass::IsGlobalOstTypeUnsafe(const OriginalSt &ost) const {
+  if (ost.IsLocal()) {
+    return false;
+  }
+  const MIRSymbol *sym = ost.GetMIRSymbol();
+  if (sym == nullptr) {
+    return false;
+  }
+  const GSymbolTable &gSymbolTable = GlobalTables::GetGsymTable();
+  static auto unsafeGSym = std::vector<bool>();  // index is SyIdx
+  if (unsafeGSym.size() < gSymbolTable.GetSymbolTableSize()) {
+    auto oldSize = unsafeGSym.size();
+    unsafeGSym.resize(gSymbolTable.GetSymbolTableSize(), false);
+    for (size_t i = oldSize; i < gSymbolTable.GetSymbolTableSize(); ++i) {
+      const MIRSymbol *gSym = gSymbolTable.GetSymbol(i);
+      if (gSym == nullptr) {
+        continue;
+      }
+      // example : typeA *gSym = (typeA*)initVal (assume initVal with typeB*)
+      if (gSym->IsConst()) {
+        MIRConst *initValue = gSym->GetKonst();
+        // set gSym type unsafe if type conversion occurs
+        if (&initValue->GetType() != gSym->GetType() &&
+            (initValue->GetType().IsMIRPtrType() || gSym->GetType()->IsMIRPtrType())) {
+          unsafeGSym[gSym->GetStIndex()] = true;
+        }
+      }
+    }
+  }
+  CHECK_FATAL(sym->GetStIndex() < unsafeGSym.size(), "unsafeGsym buffer overflow");
+  return unsafeGSym[sym->GetStIndex()];
+}
+// Propagate type unsafe info as soon as assign set has been created.
+// If any Ost in assign set is type unsafe, propagate type-unsafe info
+// among all elements in this assign set and next level osts.
+void AliasClass::PropagateTypeUnsafe() {
+  if (!mirModule.IsCModule() || !MeOption::tbaa) {
+    return;
+  }
+
+  TypeBasedAliasAnalysis::GetPtrTypeUnsafe().resize(ssaTab.GetVersionStTableSize(), false);
+  for (auto *vst : ssaTab.GetVersionStTable()) {
+    auto *assSet = GetAssignSet(*vst);
+    if (assSet == nullptr) {
+      auto *ost = vst->GetOst();
+      if (ost->GetType()->IsUnsafeType() || TypeBasedAliasAnalysis::IsValueTypeUnsafe(*vst) ||
+          IsGlobalOstTypeUnsafe(*ost)) {
+        TypeBasedAliasAnalysis::SetVstValueTypeUnsafe(*vst);
+        // Vertical propagate : to next level.
+        PropagateTypeUnsafeVertically(*vst);
+      }
+      continue;
+    }
+    bool unsafe = false;
+    // if any element in assign set is typeUnsafe, all elements will be set unsafe
+    for (auto valueAliasVstIdx : *assSet) {
+      VersionSt *valueAliasVst = ssaTab.GetVerSt(valueAliasVstIdx);
+      OriginalSt &elemOst = *valueAliasVst->GetOst();
+      if (elemOst.GetType()->IsUnsafeType() || TypeBasedAliasAnalysis::IsValueTypeUnsafe(*valueAliasVst) ||
+          IsGlobalOstTypeUnsafe(elemOst)) {
+        unsafe = true;
+        break;
+      }
+    }
+    if (unsafe) {
+      for (auto valueAliasVstIdx : *assSet) {
+        VersionSt *valueAliasVst = ssaTab.GetVerSt(valueAliasVstIdx);
+        // Horizontal propagate : in assignSet
+        TypeBasedAliasAnalysis::SetVstValueTypeUnsafe(*valueAliasVst);
+        // Vertical propagate : to next level.
+        PropagateTypeUnsafeVertically(*valueAliasVst);
+      }
+    }
+  }
+}
+
+// type may be potential address type like u64/ptr etc.
+bool AliasClass::IsAddrTypeConsistent(MIRType *typeA, MIRType *typeB) const {
+  if (typeA == nullptr || typeB == nullptr) {
+    return false;
+  }
+  if (typeA == typeB) {
+    return true;
+  }
+  if (!typeA->IsMIRPtrType() || !typeB->IsMIRPtrType()) {
+    return false;
+  }
+  // <* [N] elemType> and <* elemType> are consistent
+  MIRType *pointedTypeA = static_cast<MIRPtrType *>(typeA)->GetPointedType();
+  MIRType *pointedTypeB = static_cast<MIRPtrType *>(typeB)->GetPointedType();
+  if (pointedTypeA->IsMIRArrayType()) {
+    pointedTypeA = static_cast<MIRArrayType *>(pointedTypeA)->GetElemType();
+  }
+  if (pointedTypeB->IsMIRArrayType()) {
+    pointedTypeB = static_cast<MIRArrayType *>(pointedTypeB)->GetElemType();
+  }
+  return pointedTypeA == pointedTypeB;
+}
+
+// Type of AliasInfo may be inconsistent with its corresponding expr.
+// The root cause is AliasInfo of addrof/iaddrof has a type as pointer
+// to base, instead of its field type.
+MIRType *AliasClass::GetAliasInfoRealType(const AliasInfo &ai, const BaseNode &expr) {
+  switch (expr.GetOpCode()) {
+    case OP_addrof: {
+      // type of addrof's vst is a pointer type to agg, instead of its field type.
+      if (ai.fieldID == 0) {
+        return ai.vst->GetOst()->GetType();
+      }
+      // if field is not 0, return pointer type of field type
+      auto *aggType = static_cast<MIRPtrType *>(ai.vst->GetOst()->GetType())->GetPointedType();
+      MIRType *fieldType = static_cast<MIRStructType *>(aggType)->GetFieldType(ai.fieldID);
+      return GlobalTables::GetTypeTable().GetOrCreatePointerType(*fieldType);
+    }
+    case OP_iaddrof: {
+      MIRType *memType = static_cast<const IreadNode&>(expr).GetType();
+      return GlobalTables::GetTypeTable().GetOrCreatePointerType(*memType);
+    }
+    case OP_dread:
+    case OP_regread:
+    case OP_iread: {
+      return ai.vst->GetOst()->GetType();
+    }
+    case OP_add:
+    case OP_sub:
+    case OP_array:
+    case OP_cvt:
+    case OP_retype: {
+      return GetAliasInfoRealType(CreateAliasInfoExpr(*expr.Opnd(0)), *expr.Opnd(0));
+    }
+    case OP_select: {
+      AliasInfo ai1 = CreateAliasInfoExpr(*expr.Opnd(1));
+      if (ai1.vst != nullptr) {
+        return GetAliasInfoRealType(ai1, *expr.Opnd(1));
+      }
+      return GetAliasInfoRealType(CreateAliasInfoExpr(*expr.Opnd(2)), *expr.Opnd(2));
+    }
+    default: {
+      return nullptr;
+    }
+  }
+}
+
+// if ae->ost is an address of an union type (or its field), we set ost type unsafe.
+// example: union {int x; float y;} u; u.x and u.y must alias, although their type is incompatible
+void AliasClass::SetTypeUnsafeForAddrofUnion(const VersionSt *vst) const {
+  if (!mirModule.IsCModule() || !MeOption::tbaa) {
+    return;
+  }
+  if (vst == nullptr) {
+    return;
+  }
+  const OriginalSt &ost = *vst->GetOst();
+  // if ost is an address of an union type (or its field), we set it type unsafe.
+  if (ost.GetIndirectLev() == -1) {
+    MIRType *rhsType = ost.GetType();
+    ASSERT(rhsType->IsMIRPtrType(), "Ost with -1 indirect level must have pointer type!");
+    MIRType *pointedType = static_cast<MIRPtrType*>(rhsType)->GetPointedType();
+    if (pointedType->GetKind() == kTypeUnion) {
+      TypeBasedAliasAnalysis::SetVstValueTypeUnsafe(*vst);
+    }
+  }
+}
+
+// For x <- y, if type of x is different from y, type conversion occurs, and we should set them type unsafe.
+void AliasClass::SetTypeUnsafeForTypeConversion(const VersionSt *lhsVst, BaseNode *rhsExpr) {
+  if (!mirModule.IsCModule() || !MeOption::tbaa) {
+    return;
+  }
+  AliasInfo rhsAinfo = CreateAliasInfoExpr(*rhsExpr);
+  const VersionSt *rhsVst = rhsAinfo.vst;
+  if (lhsVst == nullptr || rhsVst == nullptr) {
+    return;
+  }
+  // if lhs and rhs have different type, set both of them type unsafe
+  const OriginalSt &lhsOst = *lhsVst->GetOst();
+  MIRType *lhsType = lhsOst.GetType();
+  MIRType *rhsType = GetAliasInfoRealType(rhsAinfo, *rhsExpr);
+  if ((lhsType->IsMIRPtrType() || rhsType->IsMIRPtrType()) &&
+      !IsAddrTypeConsistent(lhsType, rhsType)) {
+    TypeBasedAliasAnalysis::SetVstValueTypeUnsafe(*lhsVst);
+    TypeBasedAliasAnalysis::SetVstValueTypeUnsafe(*rhsVst);
+  }
+}
+
+void AliasClass::ApplyUnionForIntrinsicCall(const IntrinsiccallNode &intrinsicCall) {
+  auto intrinsicId = intrinsicCall.GetIntrinsic();
+  bool opndsNextLevNADS = (intrinsicId == INTRN_JAVA_POLYMORPHIC_CALL);
+  for (uint32 i = 0; i < intrinsicCall.NumOpnds(); ++i) {
+    auto opnd = intrinsicCall.Opnd(i);
+    const AliasInfo &ainfo = CreateAliasInfoExpr(*opnd);
+    if (opndsNextLevNADS) {
+      SetPtrOpndNextLevNADS(*opnd, ainfo.vst, false);
+    }
+
+    // intrinsic call memset/memcpy return value of first opnd.
+    // create copy relation between first opnd and the returned value.
+    if (i == 0 && intrinsicCall.GetOpCode() == OP_intrinsiccallassigned &&
+        (intrinsicId == INTRN_C_memset || intrinsicId == INTRN_C_memcpy)) {
+      auto &mustDefs = ssaTab.GetStmtsSSAPart().GetMustDefNodesOf(intrinsicCall);
+      if (mustDefs.empty()) {
+        continue;
+      }
+      CHECK_FATAL(mustDefs.size() == 1, "multi-assign-part for C_memset/memcpy not supported");
+      auto *assignedPtr = mustDefs.front().GetResult();
+      if (ainfo.vst == nullptr) {
+        continue;
+      }
+      ApplyUnionForDassignCopy(*ainfo.vst, assignedPtr, *opnd);
+    }
+  }
+}
+
+void AliasClass::ApplyUnionForCopies(StmtNode &stmt) {
+  switch (stmt.GetOpCode()) {
+    case OP_maydassign:
+    case OP_dassign:
+    case OP_regassign: {
+      // RHS
+      ASSERT_NOT_NULL(stmt.Opnd(0));
+      AliasInfo rhsAinfo = CreateAliasInfoExpr(*stmt.Opnd(0));
+      // LHS
+      auto *lhsVst = ssaTab.GetStmtsSSAPart().GetAssignedVarOf(stmt);
+      OriginalSt *lhsOst = lhsVst->GetOst();
+      if (lhsOst->GetFieldID() != 0) {
+        (void) FindOrCreateVstOfAddrofOSt(*lhsOst);
+      }
+      RecordAliasAnalysisInfo(*lhsVst);
+      ApplyUnionForDassignCopy(*lhsVst, rhsAinfo.vst, *stmt.Opnd(0));
+      SetTypeUnsafeForAddrofUnion(rhsAinfo.vst);
+      return;
+    }
+    case OP_iassign: {
+      auto &iassignNode = static_cast<IassignNode&>(stmt);
+      AliasInfo rhsAinfo = CreateAliasInfoExpr(*iassignNode.Opnd(1));
+      auto *lhsVst =
+        FindOrCreateVstOfExtraLevOst(*iassignNode.Opnd(0), iassignNode.GetTyIdx(), iassignNode.GetFieldID(), false);
+      if (lhsVst != nullptr) {
+        ApplyUnionForDassignCopy(*lhsVst, rhsAinfo.vst, *iassignNode.Opnd(1));
+      }
+      SetTypeUnsafeForAddrofUnion(rhsAinfo.vst);
+      if (iassignNode.IsExpandedFromArrayOfCharFunc()) {
+        TypeBasedAliasAnalysis::SetVstValueTypeUnsafe(lhsVst->GetOst()->GetPointerVstIdx());
+      }
+      return;
+    }
+    case OP_throw: {
+      AliasInfo ainfo = CreateAliasInfoExpr(*stmt.Opnd(0));
+      SetPtrOpndNextLevNADS(*stmt.Opnd(0), ainfo.vst, false);
+      return;
+    }
+    case OP_call:
+    case OP_callassigned: {
+      const FuncDesc &desc = GetFuncDescFromCallStmt(static_cast<CallNode&>(stmt));
+      bool hasnoprivatedefeffect = CallHasNoPrivateDefEffect(&stmt);
+      for (uint32 i = 0; i < stmt.NumOpnds(); ++i) {
+        const AliasInfo &ainfo = CreateAliasInfoExpr(*stmt.Opnd(i));
+        // no need to solve args that are not used or readSelfOnly.
+        if (desc.IsArgUnused(i)) {
+          continue;
+        }
+        if (desc.IsReturnNoAlias() && desc.IsArgReadSelfOnly(i)) {
+          continue;
+        }
+        if (desc.IsReturnNoAlias() && desc.IsArgReadMemoryOnly(i) &&
+            ainfo.vst != nullptr && ssaTab.GetNextLevelOsts(*ainfo.vst) != nullptr) {
+          // Arg reads memory, we should set mayUse(*arg) here.
+          // If it has next level, memory alias of its nextLev will be inserted to MayUse later.
+          // If it has no next level, no elements will be inserted thru this arg.
+          continue;
+        }
+        SetPtrOpndNextLevNADS(*stmt.Opnd(i), ainfo.vst, hasnoprivatedefeffect);
+        SetPtrFieldsOfAggNextLevNADS(stmt.Opnd(i), ainfo.vst);
+      }
+      break;
+    }
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned: {
+      const FuncDesc &desc = GetFuncDescFromCallStmt(static_cast<CallNode&>(stmt));
+      bool hasnoprivatedefeffect = CallHasNoPrivateDefEffect(&stmt);
+      for (uint32 i = 0; i < stmt.NumOpnds(); ++i) {
+        const AliasInfo &ainfo = CreateAliasInfoExpr(*stmt.Opnd(i));
+        if (ainfo.vst == nullptr) {
+          continue;
+        }
+        if (i == 0) {
+          continue;
+        }
+        // no need to solve args that are not used.
+        if (desc.IsArgUnused(i)) {
+          continue;
+        }
+        if (hasnoprivatedefeffect && ainfo.vst->GetOst()->IsPrivate()) {
+          continue;
+        }
+        if (!IsPotentialAddress(stmt.Opnd(i)->GetPrimType())) {
+          continue;
+        }
+        if (stmt.Opnd(i)->GetOpCode() == OP_addrof && IsReadOnlyOst(*ainfo.vst->GetOst())) {
+          continue;
+        }
+        SetNextLevNotAllDefsSeen(ainfo.vst->GetIndex());
+      }
+      break;
+    }
+    case OP_asm:
+    case OP_icall:
+    case OP_icallassigned:
+    case OP_icallproto:
+    case OP_icallprotoassigned: {
+      for (uint32 i = 0; i < stmt.NumOpnds(); ++i) {
+        const AliasInfo &ainfo = CreateAliasInfoExpr(*stmt.Opnd(i));
+        if (stmt.GetOpCode() != OP_asm && i == 0) {
+          continue;
+        }
+        SetPtrOpndNextLevNADS(*stmt.Opnd(i), ainfo.vst, false);
+        SetPtrFieldsOfAggNextLevNADS(stmt.Opnd(i), ainfo.vst);
+      }
+      break;
+    }
+    case OP_intrinsiccall:
+    case OP_intrinsiccallassigned: {
+      ApplyUnionForIntrinsicCall(static_cast<IntrinsiccallNode&>(stmt));
+      break;
+    }
+    default: {
+      for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+        (void) CreateAliasInfoExpr(*stmt.Opnd(i));
+      }
+      break;
+    }
+  }
+  if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
+    if (stmt.GetOpCode() == OP_callassigned) {
+      auto &callStmt = static_cast<CallNode&>(stmt);
+      auto *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt.GetPUIdx());
+      if (mirFunc != nullptr && mirFunc->GetFuncDesc().IsReturnNoAlias()) {
+        MapleVector<MustDefNode> &mustDefs = ssaTab.GetStmtsSSAPart().GetMustDefNodesOf(callStmt);
+        for (auto &mustDef : mustDefs) {
+          RecordAliasAnalysisInfo(*mustDef.GetResult());
+        }
+        return;
+      }
+    }
+    SetNotAllDefsSeenForMustDefs(stmt);
+  }
+}
+
+void AliasClass::ApplyUnionForPhi(const PhiNode &phi) {
+  auto lhs = phi.GetResult();
+  RecordAliasAnalysisInfo(*lhs);
+  auto &opnds = phi.GetPhiOpnds();
+  for (auto *opnd : opnds) {
+    RecordAliasAnalysisInfo(*opnd);
+    unionFind.Union(lhs->GetIndex(), opnd->GetIndex());
+  }
+}
+
+void AliasClass::CreateAssignSets() {
+  // iterate through all the alias elems
+  for (auto *vst : ssaTab.GetVersionStTable()) {
+    auto vstIdx = vst->GetIndex();
+    if (!unionFind.Find(vstIdx)) {
+      // vst is not an alias analysis target
+      continue;
+    }
+
+    auto vstIdxOfRoot = unionFind.Root(vstIdx);
+    if (unionFind.GetElementsNumber(vstIdxOfRoot) > 1) {
+      auto maxVstIdx = (vstIdx > vstIdxOfRoot) ? vstIdx : vstIdxOfRoot;
+      if (maxVstIdx >= assignSetOfVst.size()) {
+        constexpr uint32 bufferSize = 10;
+        uint32 incNum = maxVstIdx + bufferSize - assignSetOfVst.size();
+        assignSetOfVst.insert(assignSetOfVst.end(), incNum, nullptr);
+      }
+      if (assignSetOfVst[vstIdxOfRoot] == nullptr) {
+        assignSetOfVst[vstIdxOfRoot] = acMemPool.New<AliasSet>(acAlloc.Adapter());
+      }
+      assignSetOfVst[vstIdx] = assignSetOfVst[vstIdxOfRoot];
+      assignSetOfVst[vstIdxOfRoot]->insert(vstIdx);
+    }
+  }
+}
+
+void AliasClass::DumpAssignSets() {
+  LogInfo::MapleLogger() << "/////// assign sets ///////\n";
+  for (auto *vst : ssaTab.GetVersionStTable()) {
+    auto vstIdx = vst->GetIndex();
+    if (!unionFind.Find(vstIdx)) {
+      // VersionSt is not an alias analysis target
+      continue;
+    }
+    if (unionFind.Root(vstIdx) != vstIdx) {
+      // VersionSt is no root of value-alias-set
+      continue;
+    }
+
+    auto *assignSet = GetAssignSet(*vst);
+    if (assignSet == nullptr) {
+      LogInfo::MapleLogger() << "Alone: ";
+      vst->Dump();
+      LogInfo::MapleLogger() << '\n';
+    } else {
+      LogInfo::MapleLogger() << "Members of assign set " << vstIdx << ": ";
+      for (auto valueAliasVst : *assignSet) {
+        ssaTab.GetVerSt(valueAliasVst)->Dump();
+        LogInfo::MapleLogger() << ", ";
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+void AliasClass::GetValueAliasSetOfVst(size_t vstIdx, std::set<size_t> &result) {
+  if (vstIdx >= assignSetOfVst.size() || assignSetOfVst[vstIdx] == nullptr) {
+    return;
+  }
+  auto *assignSet = assignSetOfVst[vstIdx];
+  if (assignSet == nullptr) {
+    result.insert(vstIdx);
+  } else {
+    result.insert(assignSet->begin(), assignSet->end());
+  }
+}
+
+void AliasClass::UnionAllPointedTos() {
+  std::vector<OStIdx> pointedTos;
+  for (auto *ost : ssaTab.GetOriginalStTable()) {
+    // OriginalSt is pointed to by another OriginalSt
+    if (ost->GetPrevLevelOst() != nullptr) {
+      SetNotAllDefsSeen(ost->GetIndex());
+      pointedTos.push_back(ost->GetIndex());
+    }
+  }
+  for (size_t i = 1; i < pointedTos.size(); ++i) {
+    unionFind.Union(pointedTos[0], pointedTos[i]);
+  }
+}
+
+void AliasClass::UnionNextLevelOfAliasOst(OstPtrSet &ostsToUnionNextLev) {
+  while (!ostsToUnionNextLev.empty()) {
+    auto tmpSet = ostsToUnionNextLev;
+    ostsToUnionNextLev.clear();
+    for (auto *ost : tmpSet) {
+      auto ostIdx = ost->GetIndex();
+      if (unionFind.Root(ostIdx) != ostIdx) {
+        continue;
+      }
+
+      std::set<OriginalSt *> mayAliasOsts;
+      for (auto *vst : ssaTab.GetVersionStTable()) {
+        if (!unionFind.Find(vst->GetOrigIdx()) ||
+            unionFind.Root(vst->GetOrigIdx()) != ostIdx) {
+          continue;
+        }
+
+        const auto &nextLevelOstCollector = [&](size_t vstIdx) -> void {
+          auto *nextLevOsts = ssaTab.GetNextLevelOsts(vstIdx);
+          if (nextLevOsts != nullptr) {
+            mayAliasOsts.insert(nextLevOsts->begin(), nextLevOsts->end());
+          }
+        };
+
+        auto *assignSet = GetAssignSet(*vst);
+        if (assignSet == nullptr) {
+          nextLevelOstCollector(vst->GetIndex());
+          continue;
+        } else {
+          for (auto assignedVstIdx : *assignSet) {
+            nextLevelOstCollector(assignedVstIdx);
+          }
+        }
+      }
+
+      if (mayAliasOsts.empty()) {
+        continue;
+      }
+
+      auto it = mayAliasOsts.begin();
+      // find the first non-final ost
+      while (it != mayAliasOsts.end() && (*it)->IsFinal()) {
+        ++it;
+      }
+      if (it == mayAliasOsts.end()) {
+        continue;
+      }
+
+      auto ostIdxA = (*it)->GetIndex();
+      ++it;
+      for (; it != mayAliasOsts.end(); ++it) {
+        auto *ostB = *it;
+        if (ostB->IsFinal()) {
+          continue;
+        }
+        auto ostIdxB = ostB->GetIndex();
+        if (unionFind.Root(ostIdxA) != unionFind.Root(ostIdxB)) {
+          unionFind.Union(ostIdxA, ostIdxB);
+
+          auto *rootOst = ssaTab.GetOriginalStFromID(OStIdx(unionFind.Root(ostIdxA)));
+          ostsToUnionNextLev.insert(rootOst);
+        }
+      }
+    }
+  }
+}
+
+// process the union among the pointed's of assignsets
+void AliasClass::ApplyUnionForPointedTos() {
+  // first, process nextLevNotAllDefsSeen for alias elems until no change
+  bool change = true;
+  while (change) {
+    change = false;
+    for (auto vst: ssaTab.GetVersionStTable()) {
+      auto vstIdx = vst->GetIndex();
+      if (!unionFind.Find(vstIdx)) {
+        continue;
+      }
+      if (IsNextLevNotAllDefsSeen(vstIdx) || IsNotAllDefsSeen(vst->GetOrigIdx())) {
+        const auto *nextLevelOsts = ssaTab.GetNextLevelOsts(vstIdx);
+        if (nextLevelOsts == nullptr) {
+          continue;
+        }
+        for (auto *ost : *nextLevelOsts) {
+          if (!ost->IsFinal() && !IsNotAllDefsSeen(ost->GetIndex())) {
+            SetNotAllDefsSeen(ost->GetIndex());
+            SetNextLevNotAllDefsSeen(ost->GetZeroVersionIndex());
+            change = true;
+          }
+        }
+      }
+    }
+  }
+  // only for c language
+  // base ptr may add/sub an offset to point to any field
+  if (mirModule.IsCModule()) {
+    ApplyUnionForStorageOverlaps();
+  }
+  // Union agg itself with all its fields because when the agg is modified,
+  // all its fields may be modified too.
+  if (!mirModule.IsJavaModule()) {
+    UnionForAggAndFields();
+  }
+
+  std::vector<bool> vstProcessed(ssaTab.GetVersionStTableSize(), false);
+  for (auto vst : ssaTab.GetVersionStTable()) {
+    auto vstIdx = vst->GetIndex();
+    if (vstProcessed[vstIdx]) {
+      continue;
+    }
+
+    auto *assignSet = GetAssignSet(*vst);
+    if (assignSet == nullptr) {
+      // next level Alias Elements of aliaselem may alias each other. union aliasing elements in following
+      OstPtrSet ostsToUnionNextLev;
+      auto *nextLevelOsts = ssaTab.GetNextLevelOsts(vstIdx);
+      if (nextLevelOsts == nullptr) {
+        continue;
+      }
+
+      const auto &endIt = nextLevelOsts->end();
+      for (auto ostItA = nextLevelOsts->begin(); ostItA != endIt; ++ostItA) {
+        OStIdx ostIdxA = (*ostItA)->GetIndex();
+        auto ostItB = ostItA;
+        ++ostItB;
+        for (; ostItB != endIt; ++ostItB) {
+          if (!MayAliasBasicAA(*ostItA, *ostItB)) {
+            continue;
+          }
+          OStIdx ostIdxB = (*ostItB)->GetIndex();
+          if (unionFind.Root(ostIdxA) != unionFind.Root(ostIdxB)) {
+            unionFind.Union(ostIdxA, ostIdxB);
+
+            auto *rootOst = ssaTab.GetOriginalStFromID(OStIdx(unionFind.Root(ostIdxA)));
+            ostsToUnionNextLev.insert(rootOst);
+          }
+        }
+      }
+      // union next-level-osts of aliased osts
+      UnionNextLevelOfAliasOst(ostsToUnionNextLev);
+      continue;
+    }
+
+    // iterate through all the alias elems to check if any has indirectLev > 0
+    // or if any has nextLevNotAllDefsSeen being true
+    bool hasNextLevNotAllDefsSeen = false;
+    for (auto vstIdxB : *assignSet) {
+      auto *ost = ssaTab.GetVerSt(vstIdxB)->GetOst();
+      if (ost->GetIndirectLev() > 0 || IsNotAllDefsSeen(ost->GetIndex()) || IsNextLevNotAllDefsSeen(vstIdxB)) {
+        hasNextLevNotAllDefsSeen = true;
+        break;
+      }
+      vstProcessed[vstIdxB] = true;
+    }
+    if (hasNextLevNotAllDefsSeen) {
+      // make all pointedto's in this assignSet notAllDefsSeen
+      for (auto vstIdxB : *assignSet) {
+        auto *nextLevelNodes = ssaTab.GetNextLevelOsts(vstIdxB);
+        if (nextLevelNodes == nullptr) {
+          continue;
+        }
+        for (auto *ost : *nextLevelNodes) {
+          if (!ost->IsFinal()) {
+            SetNotAllDefsSeen(ost->GetIndex());
+          }
+        }
+      }
+      continue;
+    }
+
+    // apply union among the assignSet elements
+    OstPtrSet ostsToUnionNextLev;
+    for (auto itA = assignSet->begin(); itA != assignSet->end(); ++itA) {
+      auto *nextLevelNodesA = ssaTab.GetNextLevelOsts(*itA);
+      if (nextLevelNodesA == nullptr) {
+        continue;
+      }
+
+      auto itB = itA;
+      ++itB;
+      for (; itB != assignSet->end(); ++itB) {
+        auto *nextLevelNodesB = ssaTab.GetNextLevelOsts(*itB);
+        if (nextLevelNodesB == nullptr) {
+          continue;
+        }
+
+        // union the next level of elements in the same assignSet
+        for (auto ostA : *nextLevelNodesA) {
+          for (auto ostB : *nextLevelNodesB) {
+            if (!MayAliasBasicAA(ostA, ostB)) {
+              continue;
+            }
+            uint32 rootA = unionFind.Root(ostA->GetIndex());
+            uint32 rootB = unionFind.Root(ostB->GetIndex());
+            if (rootA != rootB) {
+              unionFind.Union(ostA->GetIndex(), ostB->GetIndex());
+
+              auto newRootIdA = unionFind.Root(ostA->GetIndex());
+              auto *rootOstA = ssaTab.GetOriginalStFromID(OStIdx(newRootIdA));
+              ostsToUnionNextLev.insert(rootOstA);
+            }
+          }
+        }
+      }
+    }
+    // union next-level-osts of aliased osts
+    UnionNextLevelOfAliasOst(ostsToUnionNextLev);
+  }
+}
+
+void AliasClass::CollectRootIDOfNextLevelNodes(const MapleVector<OriginalSt*> *nextLevelOsts,
+                                               std::set<unsigned int> &rootIDOfNADSs) {
+  if (nextLevelOsts == nullptr) {
+    return;
+  }
+  for (OriginalSt *nextLevelOst : *nextLevelOsts) {
+    if (!nextLevelOst->IsFinal()) {
+      (void)rootIDOfNADSs.insert(unionFind.Root(nextLevelOst->GetIndex()));
+    }
+  }
+}
+
+void AliasClass::UnionForNotAllDefsSeen() {
+  std::set<unsigned int> rootOstIDOfNADSs;
+  for (auto *vst : ssaTab.GetVersionStTable()) {
+    auto vstIdx = vst->GetIndex();
+    auto *assignSet = GetAssignSet(*vst);
+    if (assignSet == nullptr) {
+      if (IsNotAllDefsSeen(vst->GetOst()->GetIndex()) || IsNextLevNotAllDefsSeen(vstIdx)) {
+        auto *nextLevelOsts = ssaTab.GetNextLevelOsts(vstIdx);
+        CollectRootIDOfNextLevelNodes(nextLevelOsts, rootOstIDOfNADSs);
+      }
+      continue;
+    }
+    for (size_t vstIdxA : *assignSet) {
+      auto ostIdxA = ssaTab.GetVerSt(vstIdxA)->GetOrigIdx();
+      if (IsNotAllDefsSeen(ostIdxA) || IsNextLevNotAllDefsSeen(vstIdxA)) {
+        for (size_t vstIdxB : *assignSet) {
+          auto *nextLevelOsts = ssaTab.GetNextLevelOsts(vstIdxB);
+          CollectRootIDOfNextLevelNodes(nextLevelOsts, rootOstIDOfNADSs);
+        }
+        break;
+      }
+    }
+  }
+  if (!rootOstIDOfNADSs.empty()) {
+    unsigned int idA = *(rootOstIDOfNADSs.begin());
+    rootOstIDOfNADSs.erase(rootOstIDOfNADSs.begin());
+    OstPtrSet ostsToUnionNextLev;
+    for (size_t idB : rootOstIDOfNADSs) {
+      if (unionFind.Root(idA) != unionFind.Root(idB)) {
+        unionFind.Union(idA, idB);
+
+        auto *rootOst = ssaTab.GetOriginalStFromID(OStIdx(unionFind.Root(idA)));
+        ostsToUnionNextLev.insert(rootOst);
+      }
+    }
+    UnionNextLevelOfAliasOst(ostsToUnionNextLev);
+    for (auto *ost : ssaTab.GetOriginalStTable()) {
+      auto ostIdx = ost->GetIndex();
+      if (unionFind.Find(ostIdx) && unionFind.Root(ostIdx) == unionFind.Root(idA)) {
+        SetNotAllDefsSeen(ostIdx);
+      }
+    }
+  }
+}
+
+void AliasClass::UnionForNotAllDefsSeenCLang() {
+  std::vector<OStIdx> notAllDefsSeenOsts;
+  for (auto *ost : ssaTab.GetOriginalStTable()) {
+    if (IsNotAllDefsSeen(ost->GetIndex())) {
+      notAllDefsSeenOsts.push_back(ost->GetIndex());
+    }
+  }
+
+  if (notAllDefsSeenOsts.empty()) {
+    return;
+  }
+
+  // nadsOst is the first notAllDefsSeen ost.
+  // Union nadsOst with the other notAllDefsSeen osts.
+  auto idA = notAllDefsSeenOsts[0];
+  (void)notAllDefsSeenOsts.erase(notAllDefsSeenOsts.begin());
+  OstPtrSet ostsToUnionNextLev;
+  for (const auto &idB : notAllDefsSeenOsts) {
+    if (unionFind.Root(idA) != unionFind.Root(idB)) {
+      unionFind.Union(idA, idB);
+
+      auto *rootOst = ssaTab.GetOriginalStFromID(OStIdx(unionFind.Root(idA)));
+      ostsToUnionNextLev.insert(rootOst);
+    }
+  }
+  UnionNextLevelOfAliasOst(ostsToUnionNextLev);
+  uint rootIdOfNotAllDefsSeenAe = unionFind.Root(idA);
+
+  for (auto *ost : ssaTab.GetOriginalStTable()) {
+    auto ostIdx = ost->GetIndex();
+    if (unionFind.Find(ostIdx) && unionFind.Root(ostIdx) == rootIdOfNotAllDefsSeenAe) {
+      SetNotAllDefsSeen(ostIdx);
+    }
+  }
+
+  // iterate through originalStTable; if the symbol (at level 0) is
+  // notAllDefsSeen, then set the same for all its level 1 members; then
+  // for each level 1 member of each symbol, if any is set notAllDefsSeen,
+  // set all members at that level to same;
+  for (VersionSt *vst : ssaTab.GetVersionStTable()) {
+    if (!vst->GetOst()->IsSymbolOst()) {
+      continue;
+    }
+    if (!unionFind.Find(vst->GetIndex())) {
+      // vst is not alias analysis target
+      continue;
+    }
+
+    auto *nextLevelOsts = ssaTab.GetNextLevelOsts(vst->GetIndex());
+    if (nextLevelOsts == nullptr) {
+      continue;
+    }
+
+    bool nextLevelNotAllDefsSeen = IsNotAllDefsSeen(vst->GetOrigIdx());
+    if (!nextLevelNotAllDefsSeen) {
+      // see if any at level 1 has notAllDefsSeen set
+      for (OriginalSt *nextLevelOst : *nextLevelOsts) {
+        if (IsNotAllDefsSeen(nextLevelOst->GetIndex())) {
+          nextLevelNotAllDefsSeen = true;
+          break;
+        }
+      }
+    }
+    if (nextLevelNotAllDefsSeen) {
+      // set to true for all members at this level
+      for (OriginalSt *nextLevelOst : *nextLevelOsts) {
+        SetNotAllDefsSeen(nextLevelOst->GetIndex());
+        unionFind.Union(idA, nextLevelOst->GetIndex());
+      }
+    }
+  }
+}
+
+void AliasClass::UnionForAggAndFields() {
+  // key: index of MIRSymbol; value: OStIdx.
+  std::map<uint32, std::set<OStIdx>> symbol2Osts;
+  // collect alias elements with same MIRSymbol, and the ost is zero level.
+  for (OriginalSt *ost : ssaTab.GetOriginalStTable()) {
+    if (ost->GetIndirectLev() == 0 && ost->IsSymbolOst()) {
+      (void)symbol2Osts[ost->GetMIRSymbol()->GetStIdx().FullIdx()].insert(ost->GetIndex());
+    }
+  }
+
+  // union alias elements of Agg(fieldID == 0) and fields(fieldID > 0).
+  for (auto &sym2Ost : symbol2Osts) {
+    auto &ostsWithSameSymbol = sym2Ost.second;
+    if (ostsWithSameSymbol.size() <= 1) {
+      continue;
+    }
+    for (const auto idA : ostsWithSameSymbol) {
+      auto *ostA = ssaTab.GetOriginalStFromID(idA);
+      CHECK_FATAL(ostA, "ostA is nullptr!");
+      if (ostA->GetFieldID() == 0) {
+        (void)ostsWithSameSymbol.erase(idA);
+        for (const auto &idB : ostsWithSameSymbol) {
+          unionFind.Union(idA, idB);
+        }
+        break;
+      }
+    }
+  }
+}
+
+// fabricate the imaginary not_all_def_seen AliasElem
+VersionSt *AliasClass::FindOrCreateDummyNADSVst() {
+  MIRSymbol *dummySym = mirModule.GetMIRBuilder()->GetOrCreateSymbol(TyIdx(PTY_i32), "__nads_dummysym__", kStVar,
+                                                                     kScGlobal, nullptr, kScopeGlobal, false);
+  ASSERT_NOT_NULL(dummySym);
+  dummySym->SetIsTmp(true);
+  dummySym->SetIsDeleted();
+  OriginalSt *dummyOst = ssaTab.GetOriginalStTable().FindOrCreateSymbolOriginalSt(*dummySym, 0, 0);
+  auto zeroVersionOfDummyOst = ssaTab.GetVersionStTable().GetOrCreateZeroVersionSt(*dummyOst);
+  SetNotAllDefsSeen(dummyOst->GetIndex());
+  dummyOst->SetOffset(OffsetType::InvalidOffset());
+  if (MeOption::tbaa) {
+    TypeBasedAliasAnalysis::SetVstValueTypeUnsafe(*zeroVersionOfDummyOst);
+  }
+  unionFind.NewMember(zeroVersionOfDummyOst->GetIndex());
+  return zeroVersionOfDummyOst;
+}
+
+void AliasClass::UnionAllNodes(MapleVector<OriginalSt *> *nextLevOsts) {
+  if (nextLevOsts == nullptr) {
+    return;
+  }
+  if (nextLevOsts->size() < 2) {
+    return;
+  }
+
+  auto it = nextLevOsts->begin();
+  OriginalSt *ostA = *it;
+  ++it;
+  OstPtrSet ostsToUnionNextLev;
+  for (; it != nextLevOsts->end(); ++it) {
+    OriginalSt *ostB = *it;
+    if (unionFind.Root(ostA->GetIndex()) != unionFind.Root(ostB->GetIndex())) {
+      unionFind.Union(ostA->GetIndex(), ostB->GetIndex());
+
+      auto *rootOst = ssaTab.GetOriginalStFromID(OStIdx(unionFind.Root(ostA->GetIndex())));
+      ostsToUnionNextLev.insert(rootOst);
+    }
+  }
+  // union next-level-osts of aliased osts
+  UnionNextLevelOfAliasOst(ostsToUnionNextLev);
+}
+
+// This is applicable only for C language.  For each ost that is a struct,
+// union all fields within the same struct
+void AliasClass::ApplyUnionForStorageOverlaps() {
+  // iterate through all the alias elems
+  for (VersionSt *vst : ssaTab.GetVersionStTable()) {
+    MIRType *mirType = vst->GetOst()->GetType();
+    if (mirType->GetKind() != kTypePointer) {
+      continue;
+    }
+
+    // work on the next indirect level
+    auto *nextLevOsts = ssaTab.GetNextLevelOsts(vst->GetIndex());
+    if (nextLevOsts == nullptr) {
+      continue;
+    }
+
+    MIRType *pointedType = static_cast<MIRPtrType *>(mirType)->GetPointedType();
+    if (pointedType->GetKind() == kTypeUnion) {
+      // union all fields of union
+      UnionAllNodes(nextLevOsts);
+      continue;
+    }
+
+    for (auto *nextLevOst : *nextLevOsts) {
+      // offset of nextLevOst is indeteminate, it may alias all other next-level-osts
+      if (nextLevOst->GetOffset().IsInvalid()) {
+        UnionAllNodes(nextLevOsts);
+        break;
+      }
+
+      MIRType *nextLevType = nextLevOst->GetType();
+      if (nextLevType->HasFields()) {
+        // union all fields if one next-level-ost has fields
+        UnionAllNodes(nextLevOsts);
+        break;
+      }
+    }
+  }
+}
+
+// TBAA
+// Collect the alias groups. Each alias group is a map that maps the rootId to the ids aliasing with the root.
+void AliasClass::CollectAliasGroups(std::map<unsigned, std::set<unsigned>> &aliasGroups) {
+  // key is the root id. The set contains ids of aes that alias with the root.
+  for (auto *ost : ssaTab.GetOriginalStTable()) {
+    auto ostId = ost->GetIndex();
+    unsigned int rootID = unionFind.Root(ostId);
+    if (ostId == rootID) {
+      continue;
+    }
+
+    if (aliasGroups.find(rootID) == aliasGroups.end()) {
+      std::set<unsigned int> idsAliasWithRoot;
+      (void)aliasGroups.insert(make_pair(rootID, idsAliasWithRoot));
+    }
+    (void)aliasGroups[rootID].insert(ostId);
+  }
+}
+
+bool AliasClass::AliasAccordingToType(TyIdx tyIdxA, TyIdx tyIdxB) {
+  MIRType *mirTypeA = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdxA);
+  MIRType *mirTypeB = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdxB);
+  if (mirTypeA == mirTypeB || mirTypeA == nullptr || mirTypeB == nullptr) {
+    return true;
+  }
+  if (mirTypeA->GetKind() != mirTypeB->GetKind()) {
+    return false;
+  }
+  switch (mirTypeA->GetKind()) {
+    case kTypeScalar: {
+      return (mirTypeA->GetPrimType() == mirTypeB->GetPrimType());
+    }
+    case kTypeClass: {
+      Klass *klassA = klassHierarchy->GetKlassFromTyIdx(mirTypeA->GetTypeIndex());
+      CHECK_NULL_FATAL(klassA);
+      Klass *klassB = klassHierarchy->GetKlassFromTyIdx(mirTypeB->GetTypeIndex());
+      CHECK_NULL_FATAL(klassB);
+      return (klassA == klassB || klassA->GetKlassName() == namemangler::kJavaLangObjectStr ||
+              klassB->GetKlassName() == namemangler::kJavaLangObjectStr ||
+              klassHierarchy->IsSuperKlass(klassA, klassB) || klassHierarchy->IsSuperKlass(klassB, klassA));
+    }
+    case kTypePointer: {
+      auto *pointedTypeA = (static_cast<MIRPtrType*>(mirTypeA))->GetPointedType();
+      auto *pointedTypeB = (static_cast<MIRPtrType*>(mirTypeB))->GetPointedType();
+      return AliasAccordingToType(pointedTypeA->GetTypeIndex(), pointedTypeB->GetTypeIndex());
+    }
+    case kTypeJArray: {
+      auto *mirJarrayTypeA = static_cast<MIRJarrayType*>(mirTypeA);
+      auto *mirJarrayTypeB = static_cast<MIRJarrayType*>(mirTypeB);
+      return AliasAccordingToType(mirJarrayTypeA->GetElemTyIdx(), mirJarrayTypeB->GetElemTyIdx());
+    }
+    default:
+      return true;
+  }
+}
+
+int AliasClass::GetOffset(const Klass &super, const Klass &base) const {
+  int offset = 0;
+  const Klass *superPtr = &super;
+  const Klass *basePtr = &base;
+  while (basePtr != superPtr) {
+    basePtr = basePtr->GetSuperKlass();
+    ASSERT_NOT_NULL(basePtr);
+    ++offset;
+  }
+  return offset;
+}
+
+bool AliasClass::AliasAccordingToFieldID(const OriginalSt &ostA, const OriginalSt &ostB) const {
+  if (ostA.GetFieldID() == 0 || ostB.GetFieldID() == 0) {
+    return true;
+  }
+  MIRType *mirTypeA =
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(ostA.GetPrevLevelOst()->GetTyIdx());
+  MIRType *mirTypeB =
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(ostB.GetPrevLevelOst()->GetTyIdx());
+  TyIdx idxA = mirTypeA->GetTypeIndex();
+  TyIdx idxB = mirTypeB->GetTypeIndex();
+  FieldID fldA = ostA.GetFieldID();
+  if (idxA != idxB) {
+    if (!(klassHierarchy->UpdateFieldID(idxA, idxB, fldA))) {
+      return false;
+    }
+  }
+  return fldA == ostB.GetFieldID();
+}
+
+void AliasClass::ProcessIdsAliasWithRoot(const std::set<uint32> &idsAliasWithRoot,
+                                         std::vector<uint32> &newGroups) {
+  for (uint32 ostIdxA : idsAliasWithRoot) {
+    bool unioned = false;
+    OriginalSt *ostA = ssaTab.GetOriginalStFromID(OStIdx(ostIdxA));
+    for (uint32 ostIdxB : newGroups) {
+      OriginalSt *ostB = ssaTab.GetOriginalStFromID(OStIdx(ostIdxB));
+      CHECK_FATAL(ostB, "ostB is nullptr");
+      CHECK_FATAL(ostB->GetPrevLevelOst(), "ostB PrevLevelOst is nullptr");
+      if (AliasAccordingToType(ostA->GetPrevLevelOst()->GetTyIdx(), ostB->GetPrevLevelOst()->GetTyIdx()) &&
+          AliasAccordingToFieldID(*ostA, *ostB)) {
+        unionFind.Union(ostIdxA, ostIdxB);
+        unioned = true;
+        break;
+      }
+    }
+    if (!unioned) {
+      newGroups.push_back(ostIdxA);
+    }
+  }
+}
+
+void AliasClass::ReconstructAliasGroups() {
+  // map the root id to the set contains the aliasElem-id that alias with the root.
+  std::map<uint32, std::set<uint32>> aliasGroups;
+  CollectAliasGroups(aliasGroups);
+  unionFind.Reinit();
+  // kv.first is the root id. kv.second is the id the alias with the root.
+  for (const auto &oneGroup : aliasGroups) {
+    std::vector<uint32> newGroups;  // contains one id of each new alias group.
+    uint32 rootId = oneGroup.first;
+    const std::set<uint32> &idsAliasWithRoot = oneGroup.second;
+    newGroups.push_back(rootId);
+    ProcessIdsAliasWithRoot(idsAliasWithRoot, newGroups);
+  }
+}
+
+void AliasClass::CollectNotAllDefsSeenAes() {
+  for (auto *ost : ssaTab.GetOriginalStTable()) {
+    if (IsNotAllDefsSeen(ost->GetIndex())) {
+      nadsOsts.insert(ost);
+    }
+  }
+}
+
+void AliasClass::CreateClassSets() {
+  // iterate through all the alias elems
+  for (OriginalSt *ost : ssaTab.GetOriginalStTable()) {
+    auto ostIdx = ost->GetIndex();
+    if (!unionFind.Find(ostIdx)) {
+      continue;
+    }
+    unsigned int rootID = unionFind.Root(ostIdx);
+    if (unionFind.GetElementsNumber(rootID) > 1) {
+      auto *aliasSet = GetAliasSet(OStIdx(rootID));
+      if (aliasSet == nullptr) {
+        aliasSet = acMemPool.New<AliasSet>(acAlloc.Adapter());
+        SetAliasSet(OStIdx(rootID), aliasSet);
+      }
+      SetAliasSet(ost->GetIndex(), aliasSet);
+      (void)aliasSet->insert(ost->GetIndex());
+    }
+  }
+  CollectNotAllDefsSeenAes();
+#if DEBUG
+  for (OriginalSt *ost : ssaTab.GetOriginalStTable()) {
+    if (unionFind.Find(ost->GetIndex()) &&
+        unionFind.Root(ost->GetIndex()) == ost->GetIndex() &&
+        GetAliasSet(ost->GetIndex()) != nullptr) {
+      CHECK_FATAL(GetAliasSet(ost->GetIndex())->size() == unionFind.GetElementsNumber(ost->GetIndex()),
+                  "AliasClass::CreateClassSets: wrong result");
+    }
+  }
+#endif
+}
+
+void AliasElem::Dump() const {
+  ost.Dump();
+  LogInfo::MapleLogger() << "id" << id << ((notAllDefsSeen) ? "? " : " ");
+}
+
+void AliasClass::DumpClassSets(bool onlyDumpRoot) {
+  LogInfo::MapleLogger() << "/////// class sets ///////\n";
+  for (auto *ost : ssaTab.GetOriginalStTable()) {
+    auto ostIdx = ost->GetIndex();
+    if (onlyDumpRoot) {
+      if (!unionFind.Find(ostIdx)) {
+        continue;
+      }
+      if (unionFind.Root(ostIdx) != ostIdx) {
+        continue;
+      }
+    }
+
+    auto *aliasSet = GetAliasSet(*ost);
+    if (aliasSet == nullptr || aliasSet->size() == 1) {
+      LogInfo::MapleLogger() << "Alone: ";
+      ost->Dump();
+      if (IsNotAllDefsSeen(ostIdx)) {
+        LogInfo::MapleLogger() << "?";
+      }
+      LogInfo::MapleLogger() << '\n';
+    } else {
+      LogInfo::MapleLogger() << "Alias class members of: ";
+      ost->Dump();
+      LogInfo::MapleLogger() << ":\n";
+      for (auto aliasedOstIdx : *aliasSet) {
+        CHECK_FATAL(ssaTab.GetOriginalStFromID(OStIdx(aliasedOstIdx)), "orig st is nullptr!");
+        ssaTab.GetOriginalStFromID(OStIdx(aliasedOstIdx))->Dump();
+        if (IsNotAllDefsSeen(OStIdx(aliasedOstIdx))) {
+          LogInfo::MapleLogger() << "?";
+        }
+        LogInfo::MapleLogger() << ", ";
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// if ostA alias with virtual-var ostB, base pointer of ostB must negatively offset from address of ostA
+// if ostA is global, negative-offset access is not permitted
+bool AliasResultInNegtiveOffset(const OriginalSt *ostA, const OriginalSt *ostB) {
+  if (!(ostA->GetIndirectLev() == 0 && ostA->IsSymbolOst() && ostA->GetMIRSymbol()->IsGlobal())) {
+    return false;
+  }
+  if (ostB->GetIndirectLev() <= 0) {
+    return false;
+  }
+
+  OffsetType offsetA = ostA->GetOffset();
+  OffsetType offsetB = ostB->GetOffset();
+  auto typeA = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ostA->GetTyIdx());
+  if (!offsetA.IsInvalid() && !offsetB.IsInvalid()) {
+    int32 bitSizeA = static_cast<int32>(GetTypeBitSize(typeA));
+    return (offsetA + bitSizeA) < offsetB;
+  }
+  return false;
+}
+
+bool AliasClass::MayAliasBasicAA(const OriginalSt *ostA, const OriginalSt *ostB) {
+  if (ostA == ostB) {
+    return true;
+  }
+
+  // final var  has no alias relation
+  if (ostA->IsFinal() || ostB->IsFinal()) {
+    return false;
+  }
+
+  auto indirectLevA = ostA->GetIndirectLev();
+  auto indirectLevB = ostB->GetIndirectLev();
+  // address of var has no alias relation
+  if (indirectLevA < 0 || indirectLevB < 0) {
+    return false;
+  }
+  // alias analysis based on type info
+  if (!TypeBasedAliasAnalysis::MayAlias(ostA, ostB)) {
+    return false;
+  }
+  // for global variable, negative-offset access is not permitted
+  if (indirectLevA == 0 && ostA->IsSymbolOst() && ostA->GetMIRSymbol()->IsGlobal() && indirectLevB > 0) {
+    return !AliasResultInNegtiveOffset(ostA, ostB);
+  }
+  if (indirectLevB == 0 && ostB->IsSymbolOst() && ostB->GetMIRSymbol()->IsGlobal() && indirectLevA > 0) {
+    return !AliasResultInNegtiveOffset(ostB, ostA);
+  }
+
+  // flow-insensitive basicAA cannot analysis alias relation of virtual-var.
+  // Pointer arithmetic may changed value of pointer, and result in aggPtr->fldA alias with aggPtr->fldB.
+  if (indirectLevA > 0 || indirectLevB > 0) {
+    return true;
+  }
+
+  // indirectLevA == 0 && indirectLevB == 0
+  // preg has no alias
+  if (ostA->IsPregOst() || ostB->IsPregOst()) {
+    return false;
+  }
+
+  // different zero-level-var not alias each other
+  if (ostA->GetMIRSymbol() != ostB->GetMIRSymbol()) {
+    return false;
+  }
+  const OffsetType &offsetA = ostA->GetOffset();
+  const OffsetType &offsetB = ostB->GetOffset();
+  // alias analysis based on offset.
+  if (!offsetA.IsInvalid() && !offsetB.IsInvalid()) {
+    // return if memory of ostA and ostB overlap
+    int32 bitSizeA = static_cast<int32>(GetTypeBitSize(ostA->GetType()));
+    int32 bitSizeB = static_cast<int32>(GetTypeBitSize(ostB->GetType()));
+    return IsMemoryOverlap(offsetA, bitSizeA, offsetB, bitSizeB);
+  }
+  return true;
+}
+
+bool AliasClass::MayAlias(const OriginalSt *ostA, const OriginalSt *ostB) const {
+  if (!MayAliasBasicAA(ostA, ostB)) {
+    return false;
+  }
+
+  if (ostA->GetIndex() >= aliasSetOfOst.size()) {
+    return true;
+  }
+  if (ostB->GetIndex() >= aliasSetOfOst.size()) {
+    return true;
+  }
+
+  auto *aliasSet = GetAliasSet(*ostA);
+  if (aliasSet == nullptr) {
+    return false;
+  }
+  return (aliasSet->find(ostB->GetIndex()) != aliasSet->end());
+}
+
+// here starts pass 2 code
+void AliasClass::InsertMayUseExpr(BaseNode &expr) {
+  for (size_t i = 0; i < expr.NumOpnds(); ++i) {
+    InsertMayUseExpr(*expr.Opnd(i));
+  }
+  if (expr.GetOpCode() != OP_iread) {
+    return;
+  }
+  AliasInfo rhsAinfo = CreateAliasInfoExpr(expr);
+  if (rhsAinfo.vst == nullptr) {
+    rhsAinfo.vst = FindOrCreateDummyNADSVst();
+  }
+  auto &ireadNode = static_cast<IreadSSANode&>(expr);
+  ireadNode.SetSSAVar(*rhsAinfo.vst);
+  ASSERT(ireadNode.GetSSAVar() != nullptr, "AliasClass::InsertMayUseExpr(): iread cannot have empty mayuse");
+}
+
+// collect the mayUses caused by globalsAffectedByCalls.
+void AliasClass::CollectMayUseFromGlobalsAffectedByCalls(OstPtrSet &mayUseOsts) {
+  mayUseOsts.insert(globalsAffectedByCalls.begin(), globalsAffectedByCalls.end());
+}
+
+// collect the mayUses caused by defined final field.
+void AliasClass::CollectMayUseFromDefinedFinalField(OstPtrSet &mayUseOsts) {
+  for (auto *ost : ssaTab.GetOriginalStTable()) {
+    if (!ost->IsFinal()) {
+      continue;
+    }
+
+    auto *prevLevelOst = ost->GetPrevLevelOst();
+    if (prevLevelOst == nullptr) {
+      continue;
+    }
+
+    TyIdx tyIdx = prevLevelOst->GetTyIdx();
+    auto *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    ASSERT(ptrType->IsMIRPtrType(), "Type of pointer must be MIRPtrType!");
+    tyIdx = static_cast<MIRPtrType*>(ptrType)->GetPointedTyIdx();
+    if (tyIdx == mirModule.CurFunction()->GetClassTyIdx()) {
+      (void)mayUseOsts.insert(ost);
+    }
+  }
+}
+
+// insert the ost of mayUseOsts into mayUseNodes
+void AliasClass::InsertMayUseNode(OstPtrSet &mayUseOsts, AccessSSANodes *ssaPart) {
+  for (OriginalSt *ost : mayUseOsts) {
+    ssaPart->InsertMayUseNode(MayUseNode(
+        ssaTab.GetVersionStTable().GetVersionStVectorItem(ost->GetZeroVersionIndex())));
+  }
+}
+
+void AliasClass::CollectMayUseFromFormals(OstPtrSet &mayUseOsts, bool needToBeRestrict) {
+  auto *curFunc = mirModule.CurFunction();
+  for (size_t formalId = 0; formalId < curFunc->GetFormalCount(); ++formalId) {
+    auto *formal = curFunc->GetFormal(formalId);
+    if (!needToBeRestrict || formal->GetAttr(ATTR_restrict)) {
+      auto *restrictFormalOst = ssaTab.GetOriginalStTable().FindSymbolOriginalSt(*formal);
+      if (restrictFormalOst == nullptr) {
+        continue;
+      }
+
+      auto zeroVersionIdxOfFormal = restrictFormalOst->GetZeroVersionIndex();
+      auto zeroVersionSt = ssaTab.GetVerSt(zeroVersionIdxOfFormal);
+      if (zeroVersionSt == nullptr) {
+        continue;
+      }
+
+      const auto &collectNextLevelOsts = [&](size_t vstIdx) {
+        auto *nextLevelOsts = ssaTab.GetNextLevelOsts(vstIdx);
+        if (nextLevelOsts == nullptr) {
+          return;
+        }
+        for (auto *nextLevelOst : *nextLevelOsts) {
+          mayUseOsts.insert(nextLevelOst);
+        }
+      };
+      auto *assignSet = GetAssignSet(*zeroVersionSt);
+      if (assignSet == nullptr) {
+        collectNextLevelOsts(zeroVersionIdxOfFormal);
+      } else {
+        for (auto valueAliasVstIdx : *assignSet) {
+          collectNextLevelOsts(valueAliasVstIdx);
+        }
+      }
+    }
+  }
+}
+
+// insert mayUse for Return-statement.
+// two kinds of mayUse's are insert into the mayUseNodes:
+// 1. mayUses caused by not_all_def_seen_ae;
+// 2. mayUses caused by globalsAffectedByCalls;
+// 3. collect mayUses caused by defined final field for constructor.
+void AliasClass::InsertMayUseReturn(const StmtNode &stmt) {
+  OstPtrSet mayUseOsts;
+  // 1. collect mayUses caused by not_all_def_seen_ae.
+  mayUseOsts.insert(nadsOsts.begin(), nadsOsts.end());
+  // 2. collect mayUses caused by globals_affected_by_call.
+  CollectMayUseFromGlobalsAffectedByCalls(mayUseOsts);
+  CollectMayUseFromFormals(mayUseOsts, true);
+  // 3. collect mayUses caused by defined final field for constructor
+  if (mirModule.CurFunction()->IsConstructor()) {
+    CollectMayUseFromDefinedFinalField(mayUseOsts);
+  }
+  auto *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+  InsertMayUseNode(mayUseOsts, ssaPart);
+}
+
+// collect next_level_nodes of the ost of ReturnOpnd into mayUseOsts
+void AliasClass::CollectPtsToOfReturnOpnd(const VersionSt &vst, OstPtrSet &mayUseOsts) {
+  auto *nextLevelOsts = ssaTab.GetNextLevelOsts(vst);
+  if (nextLevelOsts == nullptr) {
+    return;
+  }
+  for (OriginalSt *nextLevelOst : *nextLevelOsts) {
+    if (nextLevelOst->IsFinal()) {
+      continue;
+    }
+    auto *aliasSet = GetAliasSet(*nextLevelOst);
+    if (aliasSet == nullptr) {
+      (void)mayUseOsts.insert(nextLevelOst);
+      continue;
+    } else {
+      for (auto ostIdx : *aliasSet) {
+        auto *aliasedOst = ssaTab.GetOriginalStFromID(OStIdx(ostIdx));
+        (void)mayUseOsts.insert(aliasedOst);
+      }
+    }
+  }
+}
+
+// insert mayuses at a return stmt caused by its return operand being a pointer
+void AliasClass::InsertReturnOpndMayUse(const StmtNode &stmt) {
+  if (stmt.GetOpCode() == OP_return && stmt.NumOpnds() != 0) {
+    // insert mayuses for the return operand's next level
+    BaseNode *retValue = stmt.Opnd(0);
+    auto *vst = CreateAliasInfoExpr(*retValue).vst;
+    if (IsPotentialAddress(retValue->GetPrimType()) && vst != nullptr) {
+      if (retValue->GetOpCode() == OP_addrof && IsReadOnlyOst(*vst->GetOst())) {
+        return;
+      }
+      if (!IsNextLevNotAllDefsSeen(vst->GetIndex())) {
+        OstPtrSet mayUseOsts;
+        auto *assignSet = GetAssignSet(*vst);
+        if (assignSet == nullptr) {
+          CollectPtsToOfReturnOpnd(*vst, mayUseOsts);
+        } else {
+          for (size_t valueAliasVstIdx : *assignSet) {
+            CollectPtsToOfReturnOpnd(*ssaTab.GetVerSt(valueAliasVstIdx), mayUseOsts);
+          }
+        }
+        // insert mayUses
+        auto *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+        InsertMayUseNode(mayUseOsts, ssaPart);
+      }
+    }
+  }
+}
+
+void AliasClass::InsertMayUseAll(const StmtNode &stmt) {
+  TypeOfMayUseList &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt);
+  for (auto *ost : ssaTab.GetOriginalStTable()) {
+    if (ost->GetIndirectLev() >= 0 && !ost->IsPregOst()) {
+      MayUseNode mayUse = MayUseNode(
+          ssaTab.GetVersionStTable().GetVersionStVectorItem(ost->GetZeroVersionIndex()));
+      (void)mayUseNodes.emplace(ost->GetIndex(), mayUse);
+    }
+  }
+}
+
+void AliasClass::CollectMayDefForDassign(const StmtNode &stmt, OstPtrSet &mayDefOsts) {
+  OriginalSt *ostOfLhs = ssaTab.GetStmtsSSAPart().GetAssignedVarOf(stmt)->GetOst();
+  auto *aliasSet = GetAliasSet(*ostOfLhs);
+  if (aliasSet == nullptr) {
+    return;
+  }
+
+  FieldID fldIDA = ostOfLhs->GetFieldID();
+  for (uint aliasOstIdx : *aliasSet) {
+    if (aliasOstIdx == ostOfLhs->GetIndex()) {
+      continue;
+    }
+    OriginalSt *ostOfAliasAe = ssaTab.GetOriginalStFromID(OStIdx(aliasOstIdx));
+    FieldID fldIDB = ostOfAliasAe->GetFieldID();
+    if (!mirModule.IsCModule()) {
+      if (ostOfAliasAe->GetTyIdx() != ostOfLhs->GetTyIdx()) {
+        continue;
+      }
+      if (fldIDA == fldIDB || fldIDA == 0 || fldIDB == 0) {
+        (void)mayDefOsts.insert(ostOfAliasAe);
+      }
+    } else {
+      if (!MayAliasBasicAA(ostOfLhs, ostOfAliasAe)) {
+        continue;
+      }
+      (void)mayDefOsts.insert(ostOfAliasAe);
+    }
+  }
+}
+
+void AliasClass::InsertMayDefNode(OstPtrSet &mayDefOsts, AccessSSANodes *ssaPart,
+                                  StmtNode &stmt, BBId bbid) {
+  for (OriginalSt *mayDefOst : mayDefOsts) {
+    ssaPart->InsertMayDefNode(MayDefNode(
+        ssaTab.GetVersionStTable().GetVersionStVectorItem(mayDefOst->GetZeroVersionIndex()), &stmt));
+    ssaTab.AddDefBB4Ost(mayDefOst->GetIndex(), bbid);
+  }
+}
+
+void AliasClass::InsertMayDefDassign(StmtNode &stmt, BBId bbid) {
+  OstPtrSet mayDefOsts;
+  CollectMayDefForDassign(stmt, mayDefOsts);
+  InsertMayDefNode(mayDefOsts, ssaTab.GetStmtsSSAPart().SSAPartOf(stmt), stmt, bbid);
+}
+
+bool AliasClass::IsEquivalentField(TyIdx tyIdxA, FieldID fldA, TyIdx tyIdxB, FieldID fldB) const {
+  if (mirModule.IsJavaModule() && tyIdxA != tyIdxB) {
+    (void)klassHierarchy->UpdateFieldID(tyIdxA, tyIdxB, fldA);
+  }
+  return fldA == fldB;
+}
+
+bool AliasClass::IsAliasInfoEquivalentToExpr(const AliasInfo &ai, const BaseNode *expr) {
+  if (ai.vst == nullptr || ai.offset.IsInvalid()) {
+    return false;
+  }
+  switch (expr->GetOpCode()) {
+    case OP_addrof:
+    case OP_dread:
+    case OP_regread: {
+      return true;
+    }
+    case OP_iread: {
+      BaseNode *base = expr->Opnd(0);
+      return IsAliasInfoEquivalentToExpr(CreateAliasInfoExpr(*base), base);
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+void AliasClass::CollectMayDefForIassign(StmtNode &stmt, OstPtrSet &mayDefOsts) {
+  auto &iassignNode = static_cast<IassignNode&>(stmt);
+  VersionSt *lhsVst =
+      FindOrCreateVstOfExtraLevOst(*iassignNode.Opnd(0), iassignNode.GetTyIdx(), iassignNode.GetFieldID(), false);
+
+  OriginalSt *ostOfLhs = lhsVst->GetOst();
+  auto *aliasSet = GetAliasSet(*ostOfLhs);
+
+  // lhsAe does not alias with any aliasElem
+  if (aliasSet == nullptr) {
+    (void)mayDefOsts.insert(ostOfLhs);
+    return;
+  }
+
+  TyIdx pointedTyIdx = ostOfLhs->GetTyIdx();
+  BaseNode *rhs = iassignNode.GetRHS();
+  // we will try to filter rhs's alias element when rhs is iread expr
+  AliasInfo ai = CreateAliasInfoExpr(*rhs);
+  OriginalSt *rhsOst = nullptr;
+  if (rhs->GetOpCode() == OP_iread && IsAliasInfoEquivalentToExpr(ai, rhs)) {
+    rhsOst = ai.vst->GetOst();
+  }
+  for (uint32 aliasOstIdx : *aliasSet) {
+    OriginalSt *aliasedOst = ssaTab.GetOriginalStFromID(OStIdx(aliasOstIdx));
+    if (!mirModule.IsCModule()) {
+      if ((aliasedOst->GetIndirectLev() == 0) && OriginalStIsAuto(aliasedOst)) {
+        continue;
+      }
+      if (aliasedOst->GetTyIdx() != pointedTyIdx && pointedTyIdx != 0) {
+        continue;
+      }
+    } else {
+      if (!MayAliasBasicAA(ostOfLhs, aliasedOst)) {
+        continue;
+      }
+      if (TypeBasedAliasAnalysis::FilterAliasElemOfRHSForIassign(aliasedOst, ostOfLhs, rhsOst)) {
+        continue;
+      }
+    }
+    (void)mayDefOsts.insert(aliasedOst);
+  }
+}
+
+void AliasClass::InsertMayDefNodeExcludeFinalOst(OstPtrSet &mayDefOsts,
+                                                 AccessSSANodes *ssaPart, StmtNode &stmt,
+                                                 BBId bbid) {
+  for (OriginalSt *mayDefOst : mayDefOsts) {
+    if (!mayDefOst->IsFinal()) {
+      ssaPart->InsertMayDefNode(MayDefNode(
+          ssaTab.GetVersionStTable().GetVersionStVectorItem(mayDefOst->GetZeroVersionIndex()), &stmt));
+      ssaTab.AddDefBB4Ost(mayDefOst->GetIndex(), bbid);
+    }
+  }
+}
+
+void AliasClass::InsertMayDefIassign(StmtNode &stmt, BBId bbid) {
+  OstPtrSet mayDefOsts;
+  CollectMayDefForIassign(stmt, mayDefOsts);
+  auto *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+  if (mayDefOsts.size() == 1) {
+    InsertMayDefNode(mayDefOsts, ssaPart, stmt, bbid);
+  } else {
+    InsertMayDefNodeExcludeFinalOst(mayDefOsts, ssaPart, stmt, bbid);
+  }
+
+  TypeOfMayDefList &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt);
+  // go thru inserted MayDefNode to add the base info
+  TypeOfMayDefList::iterator it = mayDefNodes.begin();
+  for (; it != mayDefNodes.end(); ++it) {
+    MayDefNode &mayDef = it->second;
+    OriginalSt *ost = mayDef.GetResult()->GetOst();
+    if (ost->GetIndirectLev() == 1) {
+      mayDef.base = ssaTab.GetVersionStTable().GetZeroVersionSt(ost->GetPrevLevelOst());
+    }
+  }
+}
+
+void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt, BBId bbid) {
+  std::set<uint32> aliasSet;
+  // collect the full alias set first
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+    BaseNode *addrBase = stmt.Opnd(i);
+    if (addrBase->IsSSANode()) {
+      VersionSt *vst = static_cast<SSANode*>(addrBase)->GetSSAVar();
+      const auto &collectAliasedOsts = [&](const OStIdx &ostIdx) {
+        auto *aliasSetOfCurOSt = GetAliasSet(ostIdx);
+        if (aliasSetOfCurOSt == nullptr) {
+          return;
+        }
+        for (uint32 aliasOstIdx : *aliasSetOfCurOSt) {
+          aliasSet.insert(aliasOstIdx);
+        }
+      };
+
+      if (addrBase->GetOpCode() == OP_addrof) {
+        collectAliasedOsts(vst->GetOrigIdx());
+      } else {
+        auto *nextLevelOsts = ssaTab.GetNextLevelOsts(*vst);
+        if (nextLevelOsts != nullptr) {
+          for (OriginalSt *nextLevelOst : *nextLevelOsts) {
+            collectAliasedOsts(nextLevelOst->GetIndex());
+          }
+        }
+      }
+    } else {
+      for (auto *nadsOst : nadsOsts) {
+        aliasSet.insert(nadsOst->GetIndex());
+      }
+    }
+  }
+  // do the insertion according to aliasSet
+  AccessSSANodes *theSSAPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+  for (uint32 ostIdx : aliasSet) {
+    OriginalSt *aliasOst = ssaTab.GetOriginalStFromID(OStIdx(ostIdx));
+    if (!aliasOst->IsFinal()) {
+      VersionSt *vst0 = ssaTab.GetVerSt(aliasOst->GetZeroVersionIndex());
+      CHECK_FATAL(theSSAPart, "theSSAPart is nullptr!");
+      theSSAPart->InsertMayUseNode(MayUseNode(vst0));
+      theSSAPart->InsertMayDefNode(MayDefNode(vst0, &stmt));
+      ssaTab.AddDefBB4Ost(aliasOst->GetIndex(), bbid);
+    }
+  }
+}
+
+// collect mayDefs caused by mustDefs
+void AliasClass::CollectMayDefForMustDefs(const StmtNode &stmt, OstPtrSet &mayDefOsts) {
+  MapleVector<MustDefNode> &mustDefs = ssaTab.GetStmtsSSAPart().GetMustDefNodesOf(stmt);
+  for (MustDefNode &mustDef : mustDefs) {
+    VersionSt *vst = mustDef.GetResult();
+    OriginalSt *ost = vst->GetOst();
+    if (IsNotAllDefsSeen(ost->GetIndex())) {
+      continue;
+    }
+    auto *aliasSet = GetAliasSet(*ost);
+    if (aliasSet == nullptr) {
+      continue;
+    }
+    for (auto aliasOstIdx : *aliasSet) {
+      if (aliasOstIdx == ost->GetIndex()) {
+        continue;
+      }
+      auto *aliasOst = ssaTab.GetOriginalStFromID(OStIdx(aliasOstIdx));
+      (void)mayDefOsts.insert(aliasOst);
+    }
+  }
+}
+
+void AliasClass::CollectMayUseForNextLevel(const VersionSt &vst, OstPtrSet &mayUseOsts,
+                                           const StmtNode &stmt, bool isFirstOpnd) {
+  auto *nextLevelOsts = ssaTab.GetNextLevelOsts(vst);
+  if (nextLevelOsts == nullptr) {
+    return;
+  }
+  for (OriginalSt *nextLevelOst : *nextLevelOsts) {
+    if (nextLevelOst->IsFinal()) {
+      // only final fields pointed to by the first opnd(this) are considered.
+      if (!isFirstOpnd) {
+        continue;
+      }
+
+      auto *callerFunc = mirModule.CurFunction();
+      if (!callerFunc->IsConstructor()) {
+        continue;
+      }
+
+      PUIdx puIdx = static_cast<const CallNode&>(stmt).GetPUIdx();
+      auto *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+      if (!calleeFunc->IsConstructor()) {
+        continue;
+      }
+
+      if (callerFunc->GetBaseClassNameStrIdx() != calleeFunc->GetBaseClassNameStrIdx()) {
+        continue;
+      }
+    }
+
+    auto zeroVersionIdx = nextLevelOst->GetZeroVersionIndex();
+    auto zeroVersionSt = ssaTab.GetVerSt(zeroVersionIdx);
+    auto *aliasSet = GetAliasSet(*nextLevelOst);
+    if (aliasSet == nullptr) {
+      (void)mayUseOsts.insert(nextLevelOst);
+      CollectMayUseForNextLevel(*zeroVersionSt, mayUseOsts, stmt, false);
+    } else {
+      for (uint32 aliasOstIdx : *aliasSet) {
+        OriginalSt *aliasOst = ssaTab.GetOriginalStFromID(OStIdx(aliasOstIdx));
+        CHECK_FATAL(aliasOst->GetVersionsIndices().size() == 1, "ost must only has zero version");
+        auto retPair = mayUseOsts.insert(aliasOst);
+        if (retPair.second) {
+          CollectMayUseForNextLevel(*zeroVersionSt, mayUseOsts, stmt, false);
+        }
+      }
+    }
+  }
+}
+
+void AliasClass::CollectMayDefUseForIthOpnd(const VersionSt &vstOfIthOpnd, OstPtrSet &mayUseOsts,
+                                            const StmtNode &stmt, bool isFirstOpnd) {
+  CollectMayUseForNextLevel(vstOfIthOpnd, mayUseOsts, stmt, isFirstOpnd);
+
+  if (vstOfIthOpnd.GetIndex() >= assignSetOfVst.size()) {
+    return;
+  }
+  auto *valueAliasVsts = assignSetOfVst[vstOfIthOpnd.GetIndex()];
+  if (valueAliasVsts == nullptr) {
+    return;
+  }
+
+  // collect may use/def from value-alias-vsts of opnd
+  for (auto vstIdx : *valueAliasVsts) {
+    if (vstIdx == vstOfIthOpnd.GetIndex()) {
+      continue;
+    }
+
+    auto *valueAliasVst = ssaTab.GetVerSt(vstIdx);
+    if (valueAliasVst == nullptr) {
+      continue;
+    }
+    CollectMayUseForNextLevel(*valueAliasVst, mayUseOsts, stmt, isFirstOpnd);
+  }
+}
+
+void AliasClass::CollectMayUseForIntrnCallOpnd(const StmtNode &stmt,
+                                               OstPtrSet &mayDefOsts, OstPtrSet &mayUseOsts) {
+  auto &intrinNode = static_cast<const IntrinsiccallNode&>(stmt);
+  IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrinNode.GetIntrinsic()];
+  if (intrinDesc->IsAtomic()) {
+    // No matter which memorder is selected or whether the atomic operation defines ost or not,
+    // args or globals will be considered as being rewritten by other threads and hence need to be reloaded
+    CollectMayUseFromGlobalsAffectedByCalls(mayDefOsts);
+    CollectMayUseFromFormals(mayDefOsts, false);
+  }
+  for (uint32 opndId = 0; opndId < stmt.NumOpnds(); ++opndId) {
+    BaseNode *expr = stmt.Opnd(opndId);
+    expr = RemoveTypeConversionIfExist(expr);
+    AliasInfo aInfo = CreateAliasInfoExpr(*expr);
+    auto vst = aInfo.vst;
+    if (vst == nullptr) {
+      continue;
+    }
+
+    if (vst->GetOst()->GetType()->PointsToConstString()) {
+      continue;
+    }
+    OstPtrSet mayDefUseOsts;
+    CollectMayDefUseForIthOpnd(*vst, mayDefUseOsts, stmt, opndId == 0);
+    bool writeOpnd = intrinDesc->WriteNthOpnd(opndId);
+    if (mayDefUseOsts.size() == 0 && writeOpnd) {
+      // create next-level ost as it not seen before
+      auto nextLevOst = FindOrCreateExtraLevOst(
+          &ssaTab, vst, vst->GetOst()->GetTyIdx(), 0, OffsetType(0));
+      CHECK_FATAL(nextLevOst != nullptr, "Failed to create next-level ost");
+      auto *zeroVersionOfNextLevOst = ssaTab.GetVerSt(nextLevOst->GetZeroVersionIndex());
+      RecordAliasAnalysisInfo(*zeroVersionOfNextLevOst);
+      // add this into nads
+      (void)nadsOsts.insert(nextLevOst);
+      mayDefUseOsts.insert(nadsOsts.begin(), nadsOsts.end());
+    }
+    if (writeOpnd) {
+      mayDefOsts.insert(mayDefUseOsts.begin(), mayDefUseOsts.end());
+    }
+    if (intrinDesc->ReadNthOpnd(opndId)) {
+      mayUseOsts.insert(mayDefUseOsts.begin(), mayDefUseOsts.end());
+    }
+  }
+}
+
+void AliasClass::CollectMayDefUseForCallOpnd(const StmtNode &stmt,
+                                             OstPtrSet &mayDefOsts, OstPtrSet &mayUseOsts,
+                                             OstPtrSet &mustNotDefOsts, OstPtrSet &mustNotUseOsts) {
+  size_t opndId = kOpcodeInfo.IsICall(stmt.GetOpCode()) ? 1 : 0;
+  const FuncDesc *desc = nullptr;
+  if (stmt.GetOpCode() == OP_call || stmt.GetOpCode() == OP_callassigned) {
+    desc = &GetFuncDescFromCallStmt(static_cast<const CallNode&>(stmt));
+  }
+  for (; opndId < stmt.NumOpnds(); ++opndId) {
+    BaseNode *expr = stmt.Opnd(opndId);
+    expr = RemoveTypeConversionIfExist(expr);
+    if (!IsPotentialAddress(expr->GetPrimType())) {
+      continue;
+    }
+
+    AliasInfo aInfo = CreateAliasInfoExpr(*expr);
+    if (aInfo.vst == nullptr) {
+      continue;
+    }
+
+    if (aInfo.vst->GetOst()->GetType()->PointsToConstString()) {
+      ssaTab.CollectIterNextLevel(aInfo.vst->GetIndex(), mustNotDefOsts);
+      continue;
+    }
+
+    if (desc != nullptr && (desc->IsArgUnused(opndId) || desc->IsArgReadSelfOnly(opndId))) {
+      // configured desc guarantees iterNextLevel of opnd are never modified through any way(like global or other opnds)
+      if (desc->IsConfiged()) {
+        OstPtrSet result;
+        ssaTab.CollectIterNextLevel(aInfo.vst->GetIndex(), result);
+        mustNotDefOsts.insert(result.begin(), result.end());
+        mustNotUseOsts.insert(result.begin(), result.end());
+      }
+      continue;
+    }
+
+    if (desc != nullptr && desc->IsArgReadMemoryOnly(opndId)) {
+      CollectMayDefUseForIthOpnd(*aInfo.vst, mayUseOsts, stmt, opndId == 0);
+      if (desc->IsConfiged()) {
+        ssaTab.CollectIterNextLevel(aInfo.vst->GetIndex(), mustNotDefOsts);
+      }
+      continue;
+    }
+
+    if (desc != nullptr && desc->IsArgWriteMemoryOnly(opndId)) {
+      CollectMayDefUseForIthOpnd(*aInfo.vst, mayDefOsts, stmt, opndId == 0);
+      continue;
+    }
+    CollectMayDefUseForIthOpnd(*aInfo.vst, mayDefOsts, stmt, opndId == 0);
+    CollectMayDefUseForIthOpnd(*aInfo.vst, mayUseOsts, stmt, opndId == 0);
+  }
+}
+
+void AliasClass::InsertMayDefNodeForCall(OstPtrSet &mayDefOsts, AccessSSANodes *ssaPart,
+                                         StmtNode &stmt, BBId bbid,
+                                         bool hasNoPrivateDefEffect) {
+  for (OriginalSt *mayDefOst : mayDefOsts) {
+    if (!hasNoPrivateDefEffect || !mayDefOst->IsPrivate()) {
+      ssaPart->InsertMayDefNode(MayDefNode(
+          ssaTab.GetVersionStTable().GetVersionStVectorItem(mayDefOst->GetZeroVersionIndex()), &stmt));
+      ssaTab.AddDefBB4Ost(mayDefOst->GetIndex(), bbid);
+    }
+  }
+}
+
+// Insert mayDefs and mayUses for the callees.
+// Four kinds of mayDefs and mayUses are inserted, which are caused by callee
+// opnds, not_all_def_seen_ae, globalsAffectedByCalls, and mustDefs.
+void AliasClass::InsertMayDefUseCall(StmtNode &stmt, BBId bbid, bool isDirectCall) {
+  bool hasSideEffect = true;
+  bool hasNoPrivateDefEffect = false;
+  const FuncDesc *desc = nullptr;
+  if (isDirectCall) {
+    desc = &GetFuncDescFromCallStmt(static_cast<CallNode&>(stmt));
+    hasSideEffect = !desc->IsPure() && !desc->IsConst();
+  }
+  auto *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+  OstPtrSet mayDefOstsA;
+  OstPtrSet mayUseOstsA;
+  OstPtrSet mustNotDefOsts;
+  OstPtrSet mustNotUseOsts;
+  // 1. collect mayDefs and mayUses caused by callee-opnds
+  CollectMayDefUseForCallOpnd(stmt, mayDefOstsA, mayUseOstsA, mustNotDefOsts, mustNotUseOsts);
+  // 2. collect mayDefs and mayUses caused by not_all_def_seen_ae
+  OstPtrSetSub(nadsOsts, mustNotUseOsts, mayUseOstsA);
+  if (hasSideEffect) {
+    OstPtrSetSub(nadsOsts, mustNotDefOsts, mayDefOstsA);
+  }
+  // insert mayuse node caused by opnd and not_all_def_seen_ae.
+  InsertMayUseNode(mayUseOstsA, ssaPart);
+  // insert maydef node caused by opnd and not_all_def_seen_ae.
+  InsertMayDefNodeForCall(mayDefOstsA, ssaPart, stmt, bbid, hasNoPrivateDefEffect);
+
+  // 3. insert mayDefs and mayUses caused by globalsAffectedByCalls
+  OstPtrSet mayDefUseOfGOsts;
+  CollectMayUseFromGlobalsAffectedByCalls(mayDefUseOfGOsts);
+  if (desc == nullptr || !desc->IsConst()) {
+    InsertMayUseNode(mayDefUseOfGOsts, ssaPart);
+  }
+  // insert may def node, if the callee has side-effect.
+  if (hasSideEffect) {
+    InsertMayDefNodeExcludeFinalOst(mayDefUseOfGOsts, ssaPart, stmt, bbid);
+  }
+  if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
+    // 4. insert mayDefs caused by the mustDefs
+    OstPtrSet mayDefOstsC;
+    CollectMayDefForMustDefs(stmt, mayDefOstsC);
+    InsertMayDefNodeExcludeFinalOst(mayDefOstsC, ssaPart, stmt, bbid);
+  }
+}
+
+void AliasClass::InsertMayUseNodeExcludeFinalOst(const OstPtrSet &mayUseOsts,
+                                                 AccessSSANodes *ssaPart) {
+  for (OriginalSt *mayUseOst : mayUseOsts) {
+    if (!mayUseOst->IsFinal()) {
+      ssaPart->InsertMayUseNode(MayUseNode(
+          ssaTab.GetVersionStTable().GetVersionStVectorItem(mayUseOst->GetZeroVersionIndex())));
+    }
+  }
+}
+
+// Insert mayDefs and mayUses for intrinsiccall.
+// Four kinds of mayDefs and mayUses are inserted, which are caused by callee
+// opnds, not_all_def_seen_ae, globalsAffectedByCalls, and mustDefs.
+void AliasClass::InsertMayDefUseIntrncall(StmtNode &stmt, BBId bbid) {
+  auto *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+  OstPtrSet mayUseOsts;
+  OstPtrSet mayDefOsts;
+  // 1. collect mayDefs and mayUses caused by opnds
+  if (!mirModule.IsCModule()) {
+    for (uint32 i = 0; i < stmt.NumOpnds(); ++i) {
+      InsertMayUseExpr(*stmt.Opnd(i));
+    }
+    CollectMayUseFromGlobalsAffectedByCalls(mayUseOsts);
+    auto &intrinNode = static_cast<const IntrinsiccallNode&>(stmt);
+    IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrinNode.GetIntrinsic()];
+    if (!intrinDesc->HasNoSideEffect()) {
+      CollectMayUseFromGlobalsAffectedByCalls(mayDefOsts);
+    }
+  } else {
+    CollectMayUseForIntrnCallOpnd(stmt, mayDefOsts, mayUseOsts);
+  }
+  InsertMayUseNodeExcludeFinalOst(mayUseOsts, ssaPart);
+  InsertMayDefNodeExcludeFinalOst(mayDefOsts, ssaPart, stmt, bbid);
+
+  if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
+    // 4. insert maydefs caused by the mustdefs
+    OstPtrSet mayDefOstsFromMustdefs;
+    CollectMayDefForMustDefs(stmt, mayDefOstsFromMustdefs);
+    InsertMayDefNodeExcludeFinalOst(mayDefOstsFromMustdefs, ssaPart, stmt, bbid);
+  }
+}
+
+void AliasClass::InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt, BBId bbid) {
+  auto *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+  for (const OStIdx &ostIdx : globalsMayAffectedByClinitCheck) {
+    OriginalSt *ost = ssaTab.GetOriginalStFromID(OStIdx(ostIdx));
+    CHECK_FATAL(ost, "ost is nullptr!");
+    ssaPart->InsertMayDefNode(
+        MayDefNode(ssaTab.GetVersionStTable().GetVersionStVectorItem(ost->GetZeroVersionIndex()), &stmt));
+    ssaTab.AddDefBB4Ost(ostIdx, bbid);
+  }
+}
+
+void AliasClass::InsertMayDefUseAsm(StmtNode &stmt, const BBId bbID) {
+  AsmNode &asmStmt = static_cast<AsmNode&>(stmt);
+
+  /* process listClobber */
+  for (size_t i = 0; i < asmStmt.clobberList.size(); ++i) {
+    const std::string &str = GlobalTables::GetUStrTable().GetStringFromStrIdx(asmStmt.clobberList[i]);
+    if (str[0] == 'm') {
+      InsertMayDefUseCall(stmt, bbID, false);
+      return;
+    }
+  }
+
+  auto *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+  OstPtrSet mayDefOsts;
+  OstPtrSet mayUseOsts;
+  /* process input constraint */
+  for (size_t i = 0; i < asmStmt.numOpnds; ++i) {
+    BaseNode *expr = asmStmt.Opnd(i);
+    expr = RemoveTypeConversionIfExist(expr);
+    if (!IsPotentialAddress(expr->GetPrimType())) {
+      continue;
+    }
+
+    AliasInfo aInfo = CreateAliasInfoExpr(*expr);
+    if (aInfo.vst == nullptr) {
+      continue;
+    }
+
+    if (aInfo.vst->GetOst()->GetType()->PointsToConstString()) {
+      continue;
+    }
+    CollectMayDefUseForIthOpnd(*aInfo.vst, mayUseOsts, stmt, false);
+
+    const std::string &str = GlobalTables::GetUStrTable().GetStringFromStrIdx(asmStmt.inputConstraints[i]);
+    if (str[0] == '+') {
+      CollectMayUseForNextLevel(*aInfo.vst, mayDefOsts, stmt, false);
+    }
+  }
+
+  /* process output -- outputs are handled in mustdefs of the stmt. */
+  CollectMayDefForMustDefs(stmt, mayDefOsts);
+
+  InsertMayUseNode(mayUseOsts, ssaPart);
+  InsertMayDefNode(mayDefOsts, ssaPart, stmt, bbID);
+}
+
+void AliasClass::GenericInsertMayDefUse(StmtNode &stmt, BBId bbID) {
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+    InsertMayUseExpr(*stmt.Opnd(i));
+  }
+  switch (stmt.GetOpCode()) {
+    case OP_return: {
+      InsertMayUseReturn(stmt);
+      // insert mayuses caused by its return operand being a pointer
+      InsertReturnOpndMayUse(stmt);
+      return;
+    }
+    case OP_throw: {
+      if (mirModule.GetSrcLang() != kSrcLangJs && lessThrowAlias) {
+        ASSERT(GetBB(bbID) != nullptr, "GetBB(bbID) is nullptr in AliasClass::GenericInsertMayDefUse");
+        if (!GetBB(bbID)->IsGoto()) {
+          InsertMayUseReturn(stmt);
+        }
+        // if the throw is handled as goto, no alias consequence
+      } else {
+        InsertMayUseAll(stmt);
+      }
+      return;
+    }
+    case OP_gosub:
+    case OP_retsub: {
+      InsertMayUseAll(stmt);
+      return;
+    }
+    case OP_call:
+    case OP_callassigned: {
+      InsertMayDefUseCall(stmt, bbID, true);
+      return;
+    }
+    case OP_asm: {
+      InsertMayDefUseAsm(stmt, bbID);
+      return;
+    }
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_icallassigned:
+    case OP_icallprotoassigned:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_icall:
+    case OP_icallproto: {
+      InsertMayDefUseCall(stmt, bbID, false);
+      return;
+    }
+    case OP_intrinsiccallwithtype: {
+      auto &intrnNode = static_cast<IntrinsiccallNode&>(stmt);
+      if (intrnNode.GetIntrinsic() == INTRN_JAVA_CLINIT_CHECK) {
+        InsertMayDefUseClinitCheck(intrnNode, bbID);
+      }
+      InsertMayDefUseIntrncall(stmt, bbID);
+      return;
+    }
+    case OP_intrinsiccall:
+    case OP_xintrinsiccall:
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned:
+    case OP_intrinsiccallwithtypeassigned: {
+      InsertMayDefUseIntrncall(stmt, bbID);
+      return;
+    }
+    case OP_maydassign:
+    case OP_dassign: {
+      InsertMayDefDassign(stmt, bbID);
+      return;
+    }
+    case OP_iassign: {
+      InsertMayDefIassign(stmt, bbID);
+      return;
+    }
+    case OP_syncenter:
+    case OP_syncexit: {
+      InsertMayDefUseSyncOps(stmt, bbID);
+      return;
+    }
+    default:
+      return;
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/bb.cpp b/src/mapleall/maple_me/src/bb.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3b254e332b7dc94a230e4a7ec2e3d53c656471a5
--- /dev/null
+++ b/src/mapleall/maple_me/src/bb.cpp
@@ -0,0 +1,573 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "bb.h"
+#include "me_ir.h"
+#include "me_ssa.h"
+#include "mempool_allocator.h"
+#include "ver_symbol.h"
+
+namespace maple {
+std::string BB::StrAttribute() const {
+  switch (kind) {
+    case kBBUnknown:
+      return "unknown";
+    case kBBCondGoto:
+      return "condgoto";
+    case kBBGoto:
+      return "goto";
+    case kBBFallthru:
+      return "fallthru";
+    case kBBReturn:
+      return "return";
+    case kBBAfterGosub:
+      return "aftergosub";
+    case kBBSwitch:
+      return "switch";
+    case kBBIgoto:
+      return "igoto";
+    case kBBInvalid:
+      return "invalid";
+    case kBBNoReturn:
+      return "noreturn";
+    default:
+      CHECK_FATAL(false, "not yet implemented");
+  }
+  return "NYI";
+}
+
+void BB::DumpBBAttribute(const MIRModule *mod) const {
+  if (GetAttributes(kBBAttrIsEntry)) {
+    mod->GetOut() << " Entry ";
+  }
+  if (GetAttributes(kBBAttrIsExit)) {
+    mod->GetOut() << " Exit ";
+  }
+  if (GetAttributes(kBBAttrWontExit)) {
+    mod->GetOut() << " WontExit ";
+  }
+  if (GetAttributes(kBBAttrIsTry)) {
+    mod->GetOut() << " Try ";
+  }
+  if (GetAttributes(kBBAttrIsTryEnd)) {
+    mod->GetOut() << " Tryend ";
+  }
+  if (GetAttributes(kBBAttrIsJSCatch)) {
+    mod->GetOut() << " JSCatch ";
+  }
+  if (GetAttributes(kBBAttrIsJSFinally)) {
+    mod->GetOut() << " JSFinally ";
+  }
+  if (GetAttributes(kBBAttrIsJavaFinally)) {
+    mod->GetOut() << " Catch::Finally ";
+  } else if (GetAttributes(kBBAttrIsCatch)) {
+    mod->GetOut() << " Catch ";
+  }
+  if (GetAttributes(kBBAttrIsInLoop)) {
+    mod->GetOut() << " InLoop ";
+  }
+}
+
+void BB::DumpHeader(const MIRModule *mod) const {
+  mod->GetOut() << "============BB id:" << GetBBId() << " " << StrAttribute() << " [";
+  DumpBBAttribute(mod);
+  if (Options::profileUse) {
+    mod->GetOut() << "  freq: " << frequency << " ";
+  }
+  mod->GetOut() << "]===============\n";
+  mod->GetOut() << "preds: ";
+  for (const auto &predElement : pred) {
+    mod->GetOut() << predElement->GetBBId() << " ";
+  }
+  mod->GetOut() << "\nsuccs: ";
+  for (const auto &succElement : succ) {
+    mod->GetOut() << succElement->GetBBId() << " ";
+  }
+  // dump edge frequency
+  if (Options::profileUse && !succFreq.empty()) {
+    mod->GetOut() << "      succFreq [ ";
+    for (const auto &freq : succFreq) {
+      mod->GetOut() << freq << " ";
+    }
+    mod->GetOut() << " ]";
+  }
+  mod->GetOut() << '\n';
+  if (bbLabel != 0) {
+    LabelNode lblNode;
+    lblNode.SetLabelIdx(bbLabel);
+    lblNode.Dump(0);
+    mod->GetOut() << '\n';
+  }
+}
+
+void BB::Dump(const MIRModule *mod) {
+  DumpHeader(mod);
+  DumpPhi();
+  for (auto &stmt : stmtNodeList) {
+    stmt.Dump(1);
+  }
+}
+
+void BB::DumpPhi() {
+  for (auto &phi : phiList) {
+    phi.second.Dump();
+  }
+}
+
+const PhiNode *BB::PhiofVerStInserted(const VersionSt &versionSt) const {
+  auto phiIt = phiList.find(versionSt.GetOst()->GetIndex());
+  return (phiIt != phiList.end()) ? &(phiIt->second) : nullptr;
+}
+
+bool BB::InsertPhi(MapleAllocator *alloc, VersionSt *versionSt) {
+  PhiNode phiNode(*alloc, *versionSt);
+  auto status = phiList.emplace(std::make_pair(versionSt->GetOst()->GetIndex(), phiNode));
+  if (status.second) {
+    status.first->second.GetPhiOpnds().resize(pred.size());
+    for (int idx = 0; idx < pred.size(); ++idx) {
+      status.first->second.SetPhiOpnd(idx, *versionSt);
+    }
+  }
+  return status.second;
+}
+
+bool BB::IsInList(const MapleVector<BB*> &bbList) const {
+  for (const auto &bb : bbList) {
+    if (bb == this) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// remove the given bb from the BB vector bbVec; nothing done if not found
+int BB::RemoveBBFromVector(MapleVector<BB*> &bbVec) const {
+  size_t i = 0;
+  while (i < bbVec.size()) {
+    if (bbVec[i] == this) {
+      break;
+    }
+    ++i;
+  }
+  if (i == bbVec.size()) {
+    // bb not in the vector
+    return -1;
+  }
+  bbVec.erase(bbVec.cbegin() + i);
+  return i;
+}
+
+void BB::RemovePhiOpnd(int index) {
+  for (auto &phi : phiList) {
+    ASSERT(phi.second.GetPhiOpnds().size() > index, "index out of range in BB::RemovePhiOpnd");
+    phi.second.GetPhiOpnds().erase(phi.second.GetPhiOpnds().cbegin() + index);
+  }
+  for (auto &phi : mePhiList) {
+    ASSERT(phi.second->GetOpnds().size() > index, "index out of range in BB::RemovePhiOpnd");
+    phi.second->GetOpnds().erase(phi.second->GetOpnds().cbegin() + index);
+  }
+}
+
+void BB::RemoveBBFromPred(const BB &bb, bool updatePhi) {
+  int index = bb.RemoveBBFromVector(pred);
+  ASSERT(index != -1, "-1 is a very large number in BB::RemoveBBFromPred");
+  if (updatePhi) {
+    RemovePhiOpnd(index);
+  }
+}
+
+void BB::RemoveBBFromSucc(const BB &bb) {
+  int ret = bb.RemoveBBFromVector(succ);
+  if (ret != -1 && !succFreq.empty() && (Options::profileUse || frequency != 0)) {
+    succFreq.erase(succFreq.cbegin() + ret);
+  }
+}
+
+int BB::GetPredIndex(const BB &predBB) const {
+  size_t i = 0;
+  while (i < pred.size()) {
+    if (pred[i] == &predBB) {
+      return static_cast<int>(i);
+    }
+    ++i;
+  }
+  return -1;
+}
+
+int BB::GetSuccIndex(const BB &succBB) const {
+  size_t i = 0;
+  while (i < succ.size()) {
+    if (succ[i] == &succBB) {
+      return static_cast<int>(i);
+    }
+    ++i;
+  }
+  // bb not in the vector
+  return -1;
+}
+
+// add stmtnode to bb and update first_stmt_ and last_stmt_
+void BB::AddStmtNode(StmtNode *stmt) {
+  CHECK_FATAL(stmt != nullptr, "null ptr check");
+  stmtNodeList.push_back(stmt);
+}
+
+// add stmtnode at beginning of bb and update first_stmt_ and last_stmt_
+void BB::PrependStmtNode(StmtNode *stmt) {
+  stmtNodeList.push_front(stmt);
+}
+
+void BB::PrependMeStmt(MeStmt *meStmt) {
+  meStmtList.push_front(meStmt);
+  meStmt->SetBB(this);
+}
+
+// if the bb contains only one stmt other than comment, return that stmt
+// otherwise return nullptr
+StmtNode *BB::GetTheOnlyStmtNode() {
+  StmtNode *onlyStmtNode = nullptr;
+  for (auto &stmtNode : stmtNodeList) {
+    if (stmtNode.GetOpCode() == OP_comment) {
+      continue;
+    }
+    if (onlyStmtNode != nullptr) {
+      return nullptr;
+    }
+    onlyStmtNode = &stmtNode;
+  }
+  return onlyStmtNode;
+}
+
+// warning: if stmt is not in the bb, this will cause undefined behavior
+void BB::RemoveStmtNode(StmtNode *stmt) {
+  CHECK_FATAL(stmt != nullptr, "null ptr check");
+  stmtNodeList.erase(StmtNodes::iterator(stmt));
+}
+
+void BB::InsertStmtBefore(const StmtNode *stmt, StmtNode *newStmt) {
+  CHECK_FATAL(newStmt != nullptr, "null ptr check");
+  CHECK_FATAL(stmt != nullptr, "null ptr check");
+  stmtNodeList.insert(stmt, newStmt);
+}
+
+void BB::ReplaceStmt(StmtNode *stmt, StmtNode *newStmt) {
+  InsertStmtBefore(stmt, newStmt);
+  RemoveStmtNode(stmt);
+}
+
+// delete last_stmt_ and update
+void BB::RemoveLastStmt() {
+  stmtNodeList.pop_back();
+}
+
+// replace pred with newbb to keep position and add this as succ of newpred
+// and remove itself from succ of old
+void BB::ReplacePred(const BB *old, BB *newPred) {
+  ASSERT((old != nullptr && newPred != nullptr), "Nullptr check.");
+  ASSERT((old->IsInList(pred) && IsInList(old->succ)), "Nullptr check.");
+  for (auto &predElement : pred) {
+    if (predElement == old) {
+      predElement->RemoveBBFromSucc(*this);
+      if (IsInList(newPred->succ)) {
+        RemoveBBFromPred(*predElement, true);
+      } else {
+        newPred->succ.push_back(this);
+        predElement = newPred;
+      }
+      break;
+    }
+  }
+}
+
+// replace myself with a new succ in all my predecessors
+void BB::MoveAllPredToSucc(BB *newSucc, BB *commonEntry) {
+  ASSERT_NOT_NULL(newSucc);
+  if (GetAttributes(kBBAttrIsEntry)) {
+    ASSERT(IsSuccBB(*commonEntry), "BB is not in commonEntry's successors, but it is set kBBAttrIsEntry");
+    commonEntry->RemoveEntry(*this);
+    commonEntry->AddEntry(*newSucc);
+    newSucc->SetAttributes(kBBAttrIsEntry);
+  } else {
+    while (!GetPred().empty()) {
+      BB *firstPred = GetPred(0);
+      if (IsSuccBB(*firstPred)) {                     // avoid replacing twice
+        firstPred->ReplaceSucc(this, newSucc, true);  // firstPred will be removed from this->pred
+      }
+    }
+  }
+}
+
+// replace succ in current position with newsucc and add this as pred of newsucc
+// and remove itself from pred of old
+void BB::ReplaceSucc(const BB *old, BB *newSucc, bool updatePhi) {
+  ASSERT((old != nullptr && newSucc != nullptr), "Nullptr check.");
+  ASSERT((old->IsInList(succ) && IsInList(old->pred)), "Nullptr check.");
+  for (auto &succElement : succ) {
+    if (succElement == old) {
+      succElement->RemoveBBFromPred(*this, updatePhi);
+      if (IsInList(newSucc->pred)) {
+        RemoveBBFromSucc(*succElement);
+      } else {
+        newSucc->pred.push_back(this);
+        succElement = newSucc;
+      }
+      break;
+    }
+  }
+}
+
+// replace myself with a new pred in all my successors
+void BB::MoveAllSuccToPred(BB *newPred, BB *commonExit) {
+  ASSERT_NOT_NULL(newPred);
+  if (GetAttributes(kBBAttrIsExit)) {
+    ASSERT(IsPredBB(*commonExit), "BB is not in commonExit's predecessors, but it is set kBBAttrIsExit");
+    commonExit->RemoveExit(*this);
+    commonExit->AddExit(*newPred);
+    newPred->SetAttributes(kBBAttrIsExit);
+  } else {
+    while (!GetSucc().empty()) {
+      BB *firstSucc = GetSucc(0);
+      if (IsPredBB(*firstSucc)) {               // avoid replacing twice
+        firstSucc->ReplacePred(this, newPred);  // firstSucc will be removed from this->succ
+      }
+    }
+  }
+}
+
+void BB::FindReachableBBs(std::vector<bool> &visitedBBs) const {
+  CHECK_FATAL(GetBBId() < visitedBBs.size(), "out of range in BB::FindReachableBBs");
+  if (visitedBBs[GetBBId()]) {
+    return;
+  }
+  visitedBBs[GetBBId()] = true;
+  for (const BB *bb : succ) {
+    bb->FindReachableBBs(visitedBBs);
+  }
+}
+
+void BB::FindWillExitBBs(std::vector<bool> &visitedBBs) const {
+  CHECK_FATAL(GetBBId() < visitedBBs.size(), "out of range in BB::FindReachableBBs");
+  if (visitedBBs[GetBBId()]) {
+    return;
+  }
+  visitedBBs[GetBBId()] = true;
+  for (const BB *bb : pred) {
+    bb->FindWillExitBBs(visitedBBs);
+  }
+}
+
+void BB::SetFirstMe(MeStmt *stmt) {
+  meStmtList.update_front(stmt);
+}
+
+void BB::SetLastMe(MeStmt *stmt) {
+  meStmtList.update_back(stmt);
+}
+
+MeStmt *BB::GetFirstMe() {
+  return meStmtList.empty() ? nullptr : &meStmtList.front();
+}
+
+const MeStmt *BB::GetFirstMe() const {
+  return meStmtList.empty() ? nullptr : &meStmtList.front();
+}
+
+MeStmt *BB::GetLastMe() {
+  return meStmtList.empty() ? nullptr : &meStmtList.back();
+}
+
+const MeStmt *BB::GetLastMe() const {
+  return meStmtList.empty() ? nullptr : &meStmtList.back();
+}
+
+void BB::RemoveLastMeStmt() {
+  meStmtList.pop_back();
+}
+
+void BB::RemoveMeStmt(MeStmt *meStmt) {
+  CHECK_FATAL(meStmt != nullptr, "null ptr check");
+  meStmtList.erase(meStmt);
+}
+
+void BB::AddMeStmtFirst(MeStmt *meStmt) {
+  CHECK_FATAL(meStmt != nullptr, "null ptr check");
+  meStmtList.push_front(meStmt);
+  meStmt->SetBB(this);
+}
+
+void BB::AddMeStmtLast(MeStmt *meStmt) {
+  CHECK_FATAL(meStmt != nullptr, "null ptr check");
+  meStmtList.push_back(meStmt);
+  meStmt->SetBB(this);
+}
+
+void BB::InsertMeStmtBefore(const MeStmt *meStmt, MeStmt *inStmt) {
+  CHECK_FATAL(meStmt != nullptr, "null ptr check");
+  CHECK_FATAL(inStmt != nullptr, "null ptr check");
+  meStmtList.insert(meStmt, inStmt);
+  inStmt->SetBB(this);
+}
+
+void BB::InsertMeStmtAfter(const MeStmt *meStmt, MeStmt *inStmt) {
+  meStmtList.insertAfter(meStmt, inStmt);
+  inStmt->SetBB(this);
+}
+
+// insert instmt before br to the last of bb
+void BB::InsertMeStmtLastBr(MeStmt *inStmt) {
+  if (IsMeStmtEmpty()) {
+    AddMeStmtLast(inStmt);
+    return;
+  }
+  MeStmt *brStmt = meStmtList.rbegin().base().d();
+  Opcode op = brStmt->GetOp();
+  if (brStmt->IsCondBr() || op == OP_goto || op == OP_switch || op == OP_throw || op == OP_return || op == OP_gosub ||
+      op == OP_retsub || op == OP_igoto) {
+    InsertMeStmtBefore(brStmt, inStmt);
+  } else {
+    AddMeStmtLast(inStmt);
+  }
+}
+
+void BB::ReplaceMeStmt(MeStmt *stmt, MeStmt *newStmt) {
+  InsertMeStmtBefore(stmt, newStmt);
+  RemoveMeStmt(stmt);
+}
+
+void BB::DumpMeBB(const IRMap &irMap) {
+  for (MeStmt &meStmt : GetMeStmts()) {
+    meStmt.Dump(&irMap);
+  }
+}
+
+void BB::DumpMeVarPiList(const IRMap *irMap) {
+  if (meVarPiList.empty()) {
+    return;
+  }
+  std::cout << "<<<<<<<<<<<<<<  PI Node Start >>>>>>>>>>>>>>>>>>\n";
+  for (const auto &pair : meVarPiList) {
+    BB *bb = pair.first;
+    std::cout << "Frome BB : " << bb->GetBBId() << '\n';
+    for (const auto *stmt : pair.second) {
+      stmt->Dump(irMap);
+    }
+  }
+  std::cout << "<<<<<<<<<<<<<<  PI Node End >>>>>>>>>>>>>>>>>>>>\n";
+}
+
+void BB::DumpMePhiList(const IRMap *irMap) {
+  int count = 0;
+  for (const auto &phi : mePhiList) {
+    phi.second->Dump(irMap);
+    int dumpVsyNum = DumpOptions::GetDumpVsyNum();
+    if (dumpVsyNum > 0 && ++count >= dumpVsyNum) {
+      break;
+    }
+    ASSERT(count >= 0, "mePhiList too large");
+  }
+}
+
+// update edge frequency by scaled value when bb frequency is changed
+void BB::UpdateEdgeFreqs(bool updateBBFreqOfSucc) {
+  int len = GetSucc().size();
+  ASSERT(len == GetSuccFreq().size(), "sanity check");
+  int64_t succFreqs = 0;
+  for (int i = 0; i < len; i++) {
+    succFreqs += GetSuccFreq()[i];
+  }
+  int64 diff = abs(succFreqs - static_cast<int64>(GetFrequency()));
+  if (len == 0 ||
+      (len == 1 && diff == 0) ||
+      (len > 1 && diff <= 1)) {
+    return;
+  }
+  for (int i = 0; i < len; ++i) {
+    uint64 sfreq = GetSuccFreq()[i];
+    uint64 scalefreq = (succFreqs == 0 ? (frequency / len) : (sfreq * frequency / succFreqs));
+    SetSuccFreq(i, scalefreq);
+    // update succ frequency with new difference if needed
+    if (updateBBFreqOfSucc) {
+      auto *succBBLoc = GetSucc(static_cast<size_t>(static_cast<uint32>(i)));
+      int64_t diffFreq = scalefreq - sfreq;
+      int64_t succBBnewFreq = static_cast<int64>(succBBLoc->GetFrequency()) + diffFreq;
+      if (succBBnewFreq >= 0) {
+        succBBLoc->SetFrequency(static_cast<uint64>(succBBnewFreq));
+      }
+    }
+  }
+}
+
+void SCCOfBBs::Dump() {
+  std::cout << "SCC " << id << " contains\n";
+  for (BB *bb : bbs) {
+    std::cout << "bb(" << bb->UintID() << ")  ";
+  }
+  std::cout << '\n';
+}
+
+bool SCCOfBBs::HasCycle() const {
+  CHECK_FATAL(!bbs.empty(), "should have bbs in the scc");
+  if (bbs.size() > 1) {
+    return true;
+  }
+  BB *bb = bbs[0];
+  for (const BB *succ : bb->GetSucc()) {
+    if (succ == bb) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void SCCOfBBs::Verify(MapleVector<SCCOfBBs*> &sccOfBB) {
+  CHECK_FATAL(!bbs.empty(), "should have bbs in the scc");
+  for (const BB *bb : bbs) {
+    SCCOfBBs *scc = sccOfBB.at(bb->UintID());
+    CHECK_FATAL(scc == this, "");
+  }
+}
+
+void SCCOfBBs::SetUp(MapleVector<SCCOfBBs*> &sccOfBB) {
+  for (BB *bb : bbs) {
+    for (BB *succ : bb->GetSucc()) {
+      if (succ == nullptr || sccOfBB.at(succ->UintID()) == this) {
+        continue;
+      }
+      succSCC.insert(sccOfBB[succ->UintID()]);
+    }
+
+    for (BB *pred : bb->GetPred()) {
+      if (pred == nullptr || sccOfBB.at(pred->UintID()) == this) {
+        continue;
+      }
+      predSCC.insert(sccOfBB[pred->UintID()]);
+    }
+  }
+}
+
+bool ControlFlowInInfiniteLoop(const BB &bb, Opcode opcode) {
+  switch (opcode) {
+    // goto always return true
+    case OP_goto:
+    case OP_igoto:
+      return true;
+    case OP_brtrue:
+    case OP_brfalse:
+    case OP_switch:
+      return bb.GetAttributes(kBBAttrWontExit);
+    default:
+      return false;
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/cast_opt.cpp b/src/mapleall/maple_me/src/cast_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f354bd3ee27e69eededee3af9a5779860563f1a6
--- /dev/null
+++ b/src/mapleall/maple_me/src/cast_opt.cpp
@@ -0,0 +1,739 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cast_opt.h"
+#include "irmap.h"
+#include "mir_builder.h"
+#include "constantfold.h"
+
+namespace maple {
+// For controlling cast elimination
+static constexpr bool simplifyCastExpr = true;
+static constexpr bool simplifyCastAssign = true;
+// This is not safe because handlefunction may ignore necessary implicit intTrunc, so we skip it now.
+static constexpr bool mapleSimplifyZextU32 = false;
+
+CastKind GetCastKindByTwoType(PrimType fromType, PrimType toType) {
+  // This is a workaround, we don't optimize `cvt u1 xx <expr>` because it will be converted to
+  // `ne u1 xx (<expr>, constval xx 0)`. There is no `cvt u1 xx <expr>` in the future.
+  if (toType == PTY_u1 && fromType != PTY_u1) {
+    return CAST_unknown;
+  }
+  const uint32 fromTypeBitSize = GetPrimTypeActualBitSize(fromType);
+  const uint32 toTypeBitSize = GetPrimTypeActualBitSize(toType);
+  // Both integer, ptr/ref/a64/u64... are also integer
+  if (IsPrimitiveInteger(fromType) && IsPrimitiveInteger(toType)) {
+    if (toTypeBitSize == fromTypeBitSize) {
+      return CAST_retype;
+    } else if (toTypeBitSize < fromTypeBitSize) {
+      return CAST_intTrunc;
+    } else {
+      return IsSignedInteger(fromType) ? CAST_sext : CAST_zext;
+    }
+  }
+  // Both fp
+  if (IsPrimitiveFloat(fromType) && IsPrimitiveFloat(toType)) {
+    if (toTypeBitSize == fromTypeBitSize) {
+      return CAST_retype;
+    } else if (toTypeBitSize < fromTypeBitSize) {
+      return CAST_fpTrunc;
+    } else {
+      return CAST_fpExt;
+    }
+  }
+  // int2fp
+  if (IsPrimitiveInteger(fromType) && IsPrimitiveFloat(toType)) {
+    return CAST_int2fp;
+  }
+  // fp2int
+  if (IsPrimitiveFloat(fromType) && IsPrimitiveInteger(toType)) {
+    return CAST_fp2int;
+  }
+  return CAST_unknown;
+}
+
+MeExpr *MeCastOpt::CreateMeExprByCastKind(IRMap &irMap, CastKind castKind, PrimType srcType, PrimType dstType,
+                                          MeExpr *opnd, TyIdx dstTyIdx) {
+  if (castKind == CAST_zext) {
+    return irMap.CreateMeExprExt(OP_zext, dstType, GetPrimTypeActualBitSize(srcType), *opnd);
+  } else if (castKind == CAST_sext) {
+    return irMap.CreateMeExprExt(OP_sext, dstType, GetPrimTypeActualBitSize(srcType), *opnd);
+  } else if (castKind == CAST_retype && srcType == opnd->GetPrimType()) {
+    // If srcType is different from opnd->primType, we should create cvt instead of retype.
+    // Because CGFunc::SelectRetype always use opnd->primType as srcType.
+    CHECK_FATAL(dstTyIdx != 0, "must specify valid tyIdx for retype");
+    return irMap.CreateMeExprRetype(dstType, dstTyIdx, *opnd);
+  } else {
+    return irMap.CreateMeExprTypeCvt(dstType, srcType, *opnd);
+  }
+}
+
+BaseNode *MapleCastOpt::CreateMapleExprByCastKind(MIRBuilder &mirBuilder, CastKind castKind, PrimType srcType,
+                                                  PrimType dstType, BaseNode *opnd, TyIdx dstTyIdx) {
+  if (castKind == CAST_zext) {
+    return mirBuilder.CreateExprExtractbits(OP_zext, dstType, 0, GetPrimTypeActualBitSize(srcType), opnd);
+  } else if (castKind == CAST_sext) {
+    return mirBuilder.CreateExprExtractbits(OP_sext, dstType, 0, GetPrimTypeActualBitSize(srcType), opnd);
+  } else if (castKind == CAST_retype && srcType == opnd->GetPrimType()) {
+    // If srcType is different from opnd->primType, we should create cvt instead of retype.
+    // Because CGFunc::SelectRetype always use opnd->primType as srcType.
+    CHECK_FATAL(dstTyIdx != 0, "must specify valid tyIdx for retype");
+    MIRType *dstMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(dstTyIdx);
+    return mirBuilder.CreateExprRetype(*dstMIRType, srcType, opnd);
+  } else {
+    return mirBuilder.CreateExprTypeCvt(OP_cvt, dstType, srcType, *opnd);
+  }
+}
+
+// This interface is conservative, which means that some op are explicit type cast but
+// the interface returns false.
+bool CastOpt::IsExplicitCastOp(Opcode op) {
+  if (op == OP_retype || op == OP_cvt || op == OP_zext || op == OP_sext) {
+    return true;
+  }
+  return false;
+}
+
+// This interface is conservative, which means that some op are implicit type cast but
+// the interface returns false.
+bool CastOpt::IsImplicitCastOp(Opcode op) {
+  if (op == OP_iread || op == OP_regread || op == OP_dread) {
+    return true;
+  }
+  return false;
+}
+
+bool CastOpt::IsCompareOp(Opcode op) {
+  if (op == OP_eq || op == OP_ne || op == OP_ge || op == OP_gt || op == OP_le || op == OP_lt) {
+    return true;
+  }
+  return false;
+}
+
+// If the computed castInfo.kind is CAST_unknown, the computed castInfo is invalid
+// castInfo.expr should be valid
+// input: castInfo.expr
+// output: castInfo.kind, castInfo.srcType, castInfo.dstType
+template <typename T>
+void CastOpt::DoComputeCastInfo(CastInfo<T> &castInfo, bool isMeExpr) {
+  Opcode op = castInfo.GetOp();
+  PrimType dstType = castInfo.GetPrimType();
+  PrimType srcType = PTY_begin;
+  CastKind castKind = CAST_unknown;
+  switch (op) {
+    case OP_zext:
+    case OP_sext: {
+      size_t sizeBit = castInfo.GetBitsSize();
+      // The code can be improved
+      // exclude: sext ixx 1 <expr> because there is no i1 type
+      if (sizeBit == 1 && op == OP_sext) {
+        break;
+      }
+      if (sizeBit == 1 || sizeBit == 8 || sizeBit == 16 || sizeBit == 32 || sizeBit == 64) {
+        srcType = GetIntegerPrimTypeBySizeAndSign(sizeBit, op == OP_sext);
+        if (srcType == PTY_begin) {
+          break;  // invalid integer type
+        }
+        castKind = (op == OP_sext ? CAST_sext : CAST_zext);
+      }
+      break;
+    }
+    case OP_retype: {
+      // retype's opndType is invalid, we use opnd's primType
+      srcType = castInfo.GetOpndType();
+      if (GetPrimTypeActualBitSize(dstType) != GetPrimTypeActualBitSize(srcType)) {
+        // Example: retype u8 <u8> (iread i32 <* i8> 0 ...)
+        // In the above example, dstType is u8, but we get srcType i32 from iread.
+        // We won't optimize such retype unless we can get real opnd type for all kinds of opnds.
+        // We will improve it if possible.
+        break;
+      }
+      castKind = CAST_retype;
+      break;
+    }
+    case OP_cvt: {
+      srcType = castInfo.GetOpndType();
+      if (srcType == PTY_u1 && dstType != PTY_u1) {
+        srcType = PTY_u8;  // From the codegen view, `cvt xx u1` is always same as `cvt xx u8`
+      }
+      castKind = GetCastKindByTwoType(srcType, dstType);
+      break;
+    }
+    case OP_iread:
+    case OP_dread:
+    case OP_regread: {
+      if (op == OP_dread && isMeExpr) {
+        break;
+      }
+      srcType = castInfo.GetOpndType();
+      // Only consider regread/iread/dread with implicit integer extension
+      if (IsPrimitiveInteger(srcType) && IsPrimitiveInteger(dstType) &&
+          GetPrimTypeActualBitSize(srcType) < GetPrimTypeActualBitSize(dstType)) {
+        castKind = (IsSignedInteger(srcType) ? CAST_sext : CAST_zext);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  castInfo.kind = castKind;
+  castInfo.srcType = srcType;
+  castInfo.dstType = dstType;
+}
+
+static constexpr auto kNumCastKinds = static_cast<uint32>(CAST_unknown);
+static const uint8 castMatrix[kNumCastKinds][kNumCastKinds] = {
+    // i        i  f  f     r  -+
+    // t        n  p  t  f  e   |
+    // r  z  s  t  2  r  p  t   +- secondCastKind
+    // u  e  e  2  i  u  e  y   |
+    // n  x  x  f  n  n  x  p   |
+    // c  t  t  p  t  c  t  e  -+
+    {  1, 0, 0, 0,99,99,99, 3 },  // intTrunc   -+
+    {  8, 9, 9,10,99,99,99, 3 },  // zext        |
+    {  8, 0, 9, 0,99,99,99, 3 },  // sext        |
+    { 99,99,99,99, 0, 0, 0, 4 },  // int2fp      |
+    {  0, 0, 0, 0,99,99,99, 0 },  // fp2int      +- firstCastKind
+    { 99,99,99,99, 0, 0, 0, 4 },  // fpTrunc     |
+    { 99,99,99,99, 2, 8, 2, 4 },  // fpExt       |
+    {  5, 7, 7,11, 6, 6, 6, 1 },  // retype     -+
+};
+
+// This function determines whether to eliminate a cast pair according to castMatrix
+// Input is a cast pair like this:
+//   secondCastKind dstType midType2 (firstCastKind midType1 srcType)
+// If the function returns a valid resultCastKind, the cast pair can be optimized to:
+//   resultCastKind dstType srcType
+// If the cast pair can NOT be eliminated, -1 will be returned.
+// ATTENTION: This function may modify srcType
+int CastOpt::IsEliminableCastPair(CastKind firstCastKind, CastKind secondCastKind,
+                                  PrimType dstType, PrimType midType2, PrimType midType1, PrimType &srcType) {
+  int castCase = castMatrix[firstCastKind][secondCastKind];
+  uint32 srcSize = GetPrimTypeActualBitSize(srcType);
+  uint32 midSize1 = GetPrimTypeActualBitSize(midType1);
+  uint32 midSize2 = GetPrimTypeActualBitSize(midType2);
+  uint32 dstSize = GetPrimTypeActualBitSize(dstType);
+
+  switch (castCase) {
+    case 0: {
+      // Not allowed
+      return -1;
+    }
+    case 1: {
+      // first intTrunc, then intTrunc
+      // Example: cvt u16 u32 (cvt u32 u64)  ==>  cvt u16 u64
+      // first retype, then retype
+      // Example: retype i64 u64 (retype u64 ptr)  ==>  retype i64 ptr
+      return firstCastKind;
+    }
+    case 2: {
+      // first fpExt, then fpExt
+      // Example: cvt f128 f64 (cvt f64 f32)  ==>  cvt f128 f32
+      // first fpExt, then fp2int
+      // Example: cvt i64 f64 (cvt f64 f32)  ==>  cvt i64 f32
+      return secondCastKind;
+    }
+    case 3: {
+      if (IsPrimitiveInteger(dstType)) {
+        return firstCastKind;
+      }
+      return -1;
+    }
+    case 4: {
+      if (IsPrimitiveFloat(dstType)) {
+        return firstCastKind;
+      }
+      return -1;
+    }
+    case 5: {
+      if (IsPrimitiveInteger(srcType)) {
+        return secondCastKind;
+      }
+      return -1;
+    }
+    case 6: {
+      if (IsPrimitiveFloat(srcType)) {
+        return secondCastKind;
+      }
+      return -1;
+    }
+    case 7: {
+      // first integer retype, then sext/zext
+      if (IsPrimitiveInteger(srcType) && dstSize >= midSize1) {
+        CHECK_FATAL(srcSize == midSize1, "must be");
+        if (midSize2 >= srcSize) {
+          return secondCastKind;
+        }
+        // Example: zext u64 8 (retype u32 i32)  ==>  zext u64 8
+        srcType = midType2;
+        return secondCastKind;
+      }
+      return -1;
+    }
+    case 8: {
+      if (srcSize == dstSize) {
+        return CAST_retype;
+      } else if (srcSize < dstSize) {
+        return firstCastKind;
+      } else {
+        return secondCastKind;
+      }
+    }
+      // For integer extension pair
+    case 9: {
+      // first zext, then sext
+      // Extreme example: sext i32 16 (zext u64 8)  ==> zext i32 8
+      if (firstCastKind != secondCastKind && midSize2 <= midSize1) {
+        if (midSize2 > srcSize) {
+          // The first extension works. After the first zext, the most significant bit must be 0, so the second sext
+          // is actually a zext.
+          // Example: sext i64 16 (zext u32 8)  ==> zext i64 8
+          return firstCastKind;
+        }
+        // midSize2 <= srcSize
+        // The first extension didn't work
+        // Example: sext i64 8 (zext u32 16)  ==> sext i64 8
+        // Example: sext i16 8 (zext u32 16)  ==> sext i16 8
+        srcType = midType2;
+        return secondCastKind;
+      }
+
+      // first zext, then zext
+      // first sext, then sext
+      // Example: sext i32 8 (sext i32 8)  ==>  sext i32 8
+      // Example: zext u16 1 (zext u32 8)  ==>  zext u16 1    it's ok
+      // midSize2 < srcSize:
+      // Example: zext u64 8 (zext u32 16)  ==> zext u64 8
+      // Example: sext i64 8 (sext i32 16)  ==> sext i64 8
+      // Example: zext i32 1 (zext u32 8)  ==> zext i32 1
+      // Wrong example (midSize2 > midSize1): zext u64 32 (zext u16 8)  =[x]=>  zext u64 8
+      if (firstCastKind == secondCastKind && midSize2 <= midSize1) {
+        if (midSize2 < srcSize) {
+          srcType = midType2;
+        }
+        return secondCastKind;
+      }
+      return -1;
+    }
+    case 10: {
+      // first zext, then int2fp
+      if (IsSignedInteger(midType2)) {
+        return secondCastKind;
+      }
+      // To improved: consider unsigned
+      return -1;
+    }
+    case 11: {
+      // first retype, then int2fp
+      if (IsPrimitiveInteger(srcType)) {
+        if (IsSignedInteger(srcType) != IsSignedInteger(midType1)) {
+          // If sign diffs, use toType of retype
+          // Example: cvt f64 i64 (retype i64 u64)  ==>  cvt f64 i64
+          srcType = midType1;
+        }
+        return secondCastKind;
+      }
+      return -1;
+    }
+    case 99: {
+      CHECK_FATAL(false, "invalid cast pair");
+    }
+    default: {
+      CHECK_FATAL(false, "can not be here, is castMatrix wrong?");
+    }
+  }
+}
+
+void MeCastOpt::ComputeCastInfo(MeExprCastInfo &castInfo) {
+  DoComputeCastInfo(castInfo, true);
+}
+
+void MapleCastOpt::ComputeCastInfo(BaseNodeCastInfo &castInfo) {
+  DoComputeCastInfo(castInfo, false);
+}
+
+MeExpr *MeCastOpt::SimplifyCastSingle(IRMap &irMap, const MeExprCastInfo &castInfo) {
+  if (castInfo.IsInvalid()) {
+    return nullptr;
+  }
+  auto *castExpr = static_cast<MeExpr*>(castInfo.expr);
+  auto *opnd = castExpr->GetOpnd(0);
+  Opcode op = castExpr->GetOp();
+  Opcode opndOp = opnd->GetOp();
+  // cast to integer + compare  ==>  compare
+  if (IsPrimitiveInteger(castInfo.dstType) && IsCompareOp(opndOp)) {
+    // exclude the following castExpr:
+    //   sext xx 1 <expr>
+    bool excluded = (op == OP_sext && static_cast<OpMeExpr*>(castExpr)->GetBitsSize() == 1);
+    if (!excluded) {
+      opnd->SetPtyp(castExpr->GetPrimType());
+      return irMap.HashMeExpr(*opnd);
+    }
+  }
+  // cast + const  ==>  const
+  if (castInfo.kind != CAST_retype && opnd->GetMeOp() == kMeOpConst) {
+    ConstantFold cf(*theMIRModule);
+    MIRConst *cst = cf.FoldTypeCvtMIRConst(*static_cast<ConstMeExpr *>(opnd)->GetConstVal(),
+                                           castInfo.srcType, castInfo.dstType);
+    if (cst != nullptr) {
+      return irMap.CreateConstMeExpr(castInfo.dstType, *cst);
+    }
+  }
+  // prop u1 type for dread
+  if (opndOp == OP_dread && (castInfo.kind == CAST_zext || castInfo.kind == CAST_sext)) {
+    auto *varExpr = static_cast<VarMeExpr*>(opnd);
+    if (varExpr->GetPrimType() == PTY_u1) {
+      // zext/sext + dread u1 %var ==>  dread u1 %var
+      return opnd;
+    }
+    if (varExpr->GetDefBy() == kDefByStmt && !varExpr->IsVolatile()) {
+      MeStmt *defStmt = varExpr->GetDefByMeStmt();
+      if (defStmt->GetOp() == OP_dassign && IsCompareOp(static_cast<DassignMeStmt*>(defStmt)->GetRHS()->GetOp())) {
+        // zext/sext + dread non-u1 %var (%var is defined by compare op)  ==>  dread non-u1 %var
+        return opnd;
+      }
+    }
+  }
+  if (castInfo.dstType == opnd->GetPrimType() &&
+      GetPrimTypeActualBitSize(castInfo.srcType) >= GetPrimTypeActualBitSize(opnd->GetPrimType())) {
+    return opnd;
+  }
+  return nullptr;
+}
+
+// The firstCastExpr may be a implicit cast expr
+// The secondCastExpr must be a explicit cast expr
+MeExpr *MeCastOpt::SimplifyCastPair(IRMap &irMap, const MeExprCastInfo &firstCastInfo,
+                                    const MeExprCastInfo &secondCastInfo) {
+  if (firstCastInfo.IsInvalid()) {
+    // We can NOT eliminate the first cast, try to simplify the second cast individually
+    return SimplifyCastSingle(irMap, secondCastInfo);
+  }
+  if (secondCastInfo.IsInvalid()) {
+    return nullptr;
+  }
+  PrimType srcType = firstCastInfo.srcType;
+  PrimType origSrcType = srcType;
+  PrimType midType1 = firstCastInfo.dstType;
+  PrimType midType2 = secondCastInfo.srcType;
+  PrimType dstType = secondCastInfo.dstType;
+  int result = IsEliminableCastPair(firstCastInfo.kind, secondCastInfo.kind, dstType, midType2, midType1, srcType);
+  if (result == -1) {
+    return SimplifyCastSingle(irMap, secondCastInfo);
+  }
+  auto resultCastKind = CastKind(result);
+  auto *firstCastExpr = static_cast<MeExpr*>(firstCastInfo.expr);
+  auto *secondCastExpr = static_cast<MeExpr*>(secondCastInfo.expr);
+  auto *toCastExpr = firstCastExpr->GetOpnd(0);
+
+  // To improved: do more powerful optimization for firstCastImplicit
+  bool isFirstCastImplicit = !IsExplicitCastOp(firstCastExpr->GetOp());
+  if (isFirstCastImplicit) {
+    // Wrong example: zext u32 u8 (iread u32 <* u16>)  =[x]=>  iread u32 <* u16>
+    // srcType may be modified, we should use origSrcType
+    if (resultCastKind != CAST_unknown && dstType == midType1 &&
+        GetPrimTypeActualBitSize(midType2) >= GetPrimTypeActualBitSize(origSrcType)) {
+      return firstCastExpr;
+    } else {
+      return nullptr;
+    }
+  }
+
+  // Example: retype u32 <u32> (dread u32 %x)  ==>  dread u32 %x
+  // Example: retype ptr <* <$Foo>> (dread ptr %p)  ==>  dread ptr %p
+  if (resultCastKind == CAST_retype && srcType == dstType) {
+    if (toCastExpr->GetPrimType() != dstType) {
+      // Wrong example: retype i16 i16 (regread i32 %1)  =[x]=> regread i32 %1
+      //       instead: ==> cvt i16 i32 (regread i32 %1)
+      return irMap.CreateMeExprTypeCvt(dstType, toCastExpr->GetPrimType(), *toCastExpr);
+    }
+    return toCastExpr;
+  }
+
+  TyIdx dstTyIdx(0);
+  if (resultCastKind == CAST_retype) {
+    // result retype is generated from `retype t1 t2 (retype t3 t4)`
+    if (secondCastExpr->GetOp() == OP_retype) {
+      dstTyIdx = static_cast<OpMeExpr*>(secondCastExpr)->GetTyIdx();
+    } else {
+      dstTyIdx = TyIdx(dstType);
+    }
+  }
+  return CreateMeExprByCastKind(irMap, resultCastKind, srcType, dstType, toCastExpr, dstTyIdx);
+}
+
+// Return a simplified expr if succeed, return nullptr if fail
+MeExpr *MeCastOpt::SimplifyCast(IRMap &irMap, MeExpr *expr) {
+  if (!simplifyCastExpr) {
+    return nullptr;
+  }
+  Opcode op = expr->GetOp();
+  if (!IsExplicitCastOp(op)) {
+    return nullptr;
+  }
+  auto *opnd = expr->GetOpnd(0);
+
+  // Convert `cvt u1 xx <expr>` to `ne u1 xx (<expr>, constval xx 0)`
+  if (op == OP_cvt && expr->GetPrimType() == PTY_u1 &&
+      static_cast<OpMeExpr*>(expr)->GetOpndType() != PTY_u1) {  // No need to convert `cvt u1 u1 <expr>`
+    return TransformCvtU1ToNe(irMap, static_cast<OpMeExpr*>(expr));
+  }
+
+  // If the opnd is a iread/regread, it's OK because it may be a implicit zext or sext
+  Opcode opndOp = opnd->GetOp();
+  if (!IsExplicitCastOp(opndOp) && !IsImplicitCastOp(opndOp)) {
+    // only 1 cast
+    // Exmaple: cvt i32 i64 (add i32)  ==>  add i32
+    MeExprCastInfo castInfo(expr);
+    ComputeCastInfo(castInfo);
+    return SimplifyCastSingle(irMap, castInfo);
+  }
+  MeExprCastInfo firstCastInfo(opnd);
+  ComputeCastInfo(firstCastInfo);
+  MeExprCastInfo secondCastInfo(expr);
+  ComputeCastInfo(secondCastInfo);
+  auto *simplified1 = SimplifyCastPair(irMap, firstCastInfo, secondCastInfo);
+  MeExpr *simplified2 = nullptr;
+  if (simplified1 != nullptr && IsExplicitCastOp(simplified1->GetOp())) {
+    // Simplify cast further
+    secondCastInfo.expr = simplified1;
+    ComputeCastInfo(secondCastInfo);
+    simplified2 = SimplifyCastSingle(irMap, secondCastInfo);
+  }
+  return (simplified2 != nullptr ? simplified2 : simplified1);
+}
+
+void MeCastOpt::SimplifyCastForAssign(MeStmt *assignStmt) {
+  if (!simplifyCastAssign) {
+    return;
+  }
+  Opcode stmtOp = assignStmt->GetOp();
+  PrimType expectedType = PTY_begin;
+  MeExpr *rhsExpr = nullptr;
+  if (stmtOp == OP_dassign) {
+    auto *dassign = static_cast<DassignMeStmt*>(assignStmt);
+    expectedType = dassign->GetLHS()->GetPrimType();
+    rhsExpr = dassign->GetRHS();
+  } else if (stmtOp == OP_iassign) {
+    auto *iassign = static_cast<IassignMeStmt*>(assignStmt);
+    expectedType = iassign->GetLHSVal()->GetType()->GetPrimType();
+    rhsExpr = iassign->GetRHS();
+  } else if (stmtOp == OP_regassign) {
+    auto *regassign = static_cast<AssignMeStmt*>(assignStmt);
+    expectedType = assignStmt->GetLHS()->GetPrimType();
+    rhsExpr = regassign->GetRHS();
+  }
+  if (rhsExpr == nullptr || !IsPrimitiveInteger(expectedType) || !IsExplicitCastOp(rhsExpr->GetOp())) {
+    return;
+  }
+  MeExpr *cur = rhsExpr;
+  MeExprCastInfo castInfo(cur);
+  do {
+    castInfo.expr = cur;
+    ComputeCastInfo(castInfo);
+    if (castInfo.kind == CAST_intTrunc) {
+      if (GetPrimTypeActualBitSize(expectedType) > GetPrimTypeActualBitSize(castInfo.dstType)) {
+        // Implicit extension for assign is not expected, we can not optimize it
+        // Wrong example: regassign i32 %1 (cvt i8 u64 (regread u64 %2))  =[x]=>  regassign i32 %1 (regread u64 %2)
+        break;
+      }
+      // Example: dassign u8 %a (cvt u8 u32 <expr>)  ==>  dassign u8 %a <expr>
+      cur = cur->GetOpnd(0);
+    } else if ((castInfo.kind == CAST_zext || castInfo.kind == CAST_sext) &&
+        IsExplicitCastOp(cur->GetOp()) &&   // Exclude implicit cast such as iread etc.
+        GetPrimTypeActualBitSize(castInfo.srcType) == GetPrimTypeActualBitSize(expectedType)) {
+      // Example: dassign u8 %a (zext u32 8 <expr>)  ==>  dassign u8 %a <expr>
+      cur = cur->GetOpnd(0);
+    } else {
+      break;
+    }
+  } while (cur != nullptr);
+  if (cur != rhsExpr) {
+    if (stmtOp == OP_dassign) {
+      auto *dassign = static_cast<DassignMeStmt*>(assignStmt);
+      dassign->SetRHS(cur);
+    } else if (stmtOp == OP_iassign) {
+      auto *iassign = static_cast<IassignMeStmt*>(assignStmt);
+      iassign->SetRHS(cur);
+    }
+  }
+}
+
+MeExpr *MeCastOpt::TransformCvtU1ToNe(IRMap &irMap, OpMeExpr *cvtExpr) {
+  MeExpr *opnd = cvtExpr->GetOpnd(0);
+  PrimType fromType = cvtExpr->GetOpndType();
+  // Convert `cvt u1 xx <expr>` to `ne u1 xx (<expr>, constval xx 0)`
+  return irMap.CreateMeExprCompare(OP_ne, PTY_u1, fromType, *opnd, *irMap.CreateIntConstMeExpr(0, fromType));
+}
+
+BaseNode *MapleCastOpt::TransformCvtU1ToNe(MIRBuilder &mirBuilder, const TypeCvtNode *cvtExpr) {
+  PrimType fromType = cvtExpr->FromType();
+  auto *fromMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(fromType));
+  // We use u8 instead of u1 because codegen can't recognize u1
+  auto *toMIRType = GlobalTables::GetTypeTable().GetUInt8();
+  auto *zero = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *fromMIRType);
+  auto *converted = mirBuilder.CreateExprCompare(OP_ne, *toMIRType, *fromMIRType, cvtExpr->Opnd(0),
+                                                 mirBuilder.CreateConstval(zero));
+  return converted;
+}
+
+BaseNode *MapleCastOpt::SimplifyCast(MIRBuilder &mirBuilder, BaseNode *expr) {
+  Opcode op = expr->GetOpCode();
+  if (!IsExplicitCastOp(op)) {
+    return nullptr;
+  }
+  auto *opnd = expr->Opnd(0);
+
+  // Convert `cvt u1 xx <expr>` to `ne u1 xx (<expr>, constval xx 0)`
+  if (op == OP_cvt && expr->GetPrimType() == PTY_u1 &&
+      static_cast<TypeCvtNode*>(expr)->FromType() != PTY_u1) {  // No need to convert `cvt u1 u1 <expr>`
+    return TransformCvtU1ToNe(mirBuilder, static_cast<TypeCvtNode*>(expr));
+  }
+
+  // If the opnd is a iread/regread, it's OK because it may be a implicit zext or sext
+  Opcode opndOp = opnd->GetOpCode();
+  if (!IsExplicitCastOp(opndOp) && !IsImplicitCastOp(opndOp)) {
+    // only 1 cast
+    // Exmaple: cvt i32 i64 (add i32)  ==>  add i32
+    BaseNodeCastInfo castInfo(expr);
+    ComputeCastInfo(castInfo);
+    return SimplifyCastSingle(mirBuilder, castInfo);
+  }
+  BaseNodeCastInfo firstCastInfo(opnd);
+  ComputeCastInfo(firstCastInfo);
+  BaseNodeCastInfo secondCastInfo(expr);
+  ComputeCastInfo(secondCastInfo);
+  auto *simplified1 = SimplifyCastPair(mirBuilder, firstCastInfo, secondCastInfo);
+  BaseNode *simplified2 = nullptr;
+  if (simplified1 != nullptr && IsExplicitCastOp(simplified1->GetOpCode())) {
+    // Simplify cast further
+    secondCastInfo.expr = simplified1;
+    ComputeCastInfo(secondCastInfo);
+    simplified2 = SimplifyCastSingle(mirBuilder, secondCastInfo);
+  }
+  if (simplified2 != nullptr) {
+    return simplified2;
+  }
+  if (simplified1 == nullptr) {
+    BaseNodeCastInfo castInfo(expr);
+    ComputeCastInfo(castInfo);
+    return SimplifyCastSingle(mirBuilder, castInfo);
+  }
+  return simplified1;
+}
+
+BaseNode *MapleCastOpt::SimplifyCastSingle(MIRBuilder &mirBuilder, const BaseNodeCastInfo &castInfo) {
+  if (castInfo.IsInvalid()) {
+    return nullptr;
+  }
+  auto *castExpr = static_cast<BaseNode*>(castInfo.expr);
+  auto *opnd = castExpr->Opnd(0);
+  Opcode op = castExpr->GetOpCode();
+  Opcode opndOp = opnd->GetOpCode();
+  // cast to integer + compare  ==>  compare
+  if (IsPrimitiveInteger(castInfo.dstType) && IsCompareOp(opndOp)) {
+    // exclude the following castExpr:
+    //   sext xx 1 <expr>
+    bool excluded = (op == OP_sext && static_cast<ExtractbitsNode*>(castExpr)->GetBitsSize() == 1);
+    if (!excluded) {
+      opnd->SetPrimType(castExpr->GetPrimType());
+      return opnd;
+    }
+  }
+  // cast + const  ==>  const
+  if (castInfo.kind != CAST_retype && opndOp == OP_constval) {
+    ConstantFold cf(*theMIRModule);
+    MIRConst *cst = cf.FoldTypeCvtMIRConst(*static_cast<ConstvalNode *>(opnd)->GetConstVal(),
+                                           castInfo.srcType, castInfo.dstType);
+    if (cst != nullptr) {
+      return mirBuilder.CreateConstval(cst);
+    }
+  }
+  if (mapleSimplifyZextU32) {
+    // zextTo32 + read  ==>  read 32
+    if (castInfo.kind == CAST_zext && (opndOp == OP_iread || opndOp == OP_regread || opndOp == OP_dread)) {
+      uint32 dstSize = GetPrimTypeActualBitSize(castInfo.dstType);
+      if (dstSize == 32 && IsUnsignedInteger(castInfo.dstType) && IsUnsignedInteger(opnd->GetPrimType()) &&
+          GetPrimTypeActualBitSize(castInfo.srcType) == GetPrimTypeActualBitSize(opnd->GetPrimType())) {
+        opnd->SetPrimType(castInfo.dstType);
+        return opnd;
+      }
+    }
+  }
+  if (castInfo.dstType == opnd->GetPrimType() &&
+      GetPrimTypeActualBitSize(castInfo.srcType) >= GetPrimTypeActualBitSize(opnd->GetPrimType())) {
+    return opnd;
+  }
+  return nullptr;
+}
+
+BaseNode *MapleCastOpt::SimplifyCastPair(MIRBuilder &mirBuidler, const BaseNodeCastInfo &firstCastInfo,
+                                         const BaseNodeCastInfo &secondCastInfo) {
+  if (firstCastInfo.IsInvalid()) {
+    // We can NOT eliminate the first cast, try to simplify the second cast individually
+    return SimplifyCastSingle(mirBuidler, secondCastInfo);
+  }
+  if (secondCastInfo.IsInvalid()) {
+    return nullptr;
+  }
+  PrimType srcType = firstCastInfo.srcType;
+  PrimType origSrcType = srcType;
+  PrimType midType1 = firstCastInfo.dstType;
+  PrimType midType2 = secondCastInfo.srcType;
+  PrimType dstType = secondCastInfo.dstType;
+  int result = IsEliminableCastPair(firstCastInfo.kind, secondCastInfo.kind, dstType, midType2, midType1, srcType);
+  if (result == -1) {
+    return SimplifyCastSingle(mirBuidler, secondCastInfo);
+  }
+  auto resultCastKind = CastKind(result);
+  auto *firstCastExpr = static_cast<BaseNode*>(firstCastInfo.expr);
+  auto *secondCastExpr = static_cast<BaseNode*>(secondCastInfo.expr);
+
+  // To improved: do more powerful optimization for firstCastImplicit
+  bool isFirstCastImplicit = !IsExplicitCastOp(firstCastExpr->GetOpCode());
+  if (isFirstCastImplicit) {
+    // Wrong example: zext u32 u8 (iread u32 <* u16>)  =[x]=>  iread u32 <* u16>
+    // srcType may be modified, we should use origSrcType
+    if (resultCastKind != CAST_unknown && dstType == midType1 &&
+        GetPrimTypeActualBitSize(midType2) >= GetPrimTypeActualBitSize(origSrcType)) {
+      return firstCastExpr;
+    } else {
+      return nullptr;
+    }
+  }
+
+  auto *toCastExpr = firstCastExpr->Opnd(0);
+  // Example: retype u32 <u32> (dread u32 %x)  ==>  dread u32 %x
+  // Example: retype ptr <* <$Foo>> (dread ptr %p)  ==>  dread ptr %p
+  if (resultCastKind == CAST_retype && srcType == dstType) {
+    if (toCastExpr->GetPrimType() != dstType) {
+      // Wrong example: retype i16 i16 (regread i32 %1)  =[x]=> regread i32 %1
+      //       instead: ==> cvt i16 i32 (regread i32 %1)
+      return mirBuidler.CreateExprTypeCvt(OP_cvt, dstType, toCastExpr->GetPrimType(), *toCastExpr);
+    }
+    return toCastExpr;
+  }
+
+  TyIdx dstTyIdx(0);
+  if (resultCastKind == CAST_retype) {
+    // result retype is generated from `retype t1 t2 (retype t3 t4)`
+    if (secondCastExpr->GetOpCode() == OP_retype) {
+      dstTyIdx = static_cast<RetypeNode*>(secondCastExpr)->GetTyIdx();
+    } else {
+      dstTyIdx = TyIdx(dstType);
+    }
+  }
+  return CreateMapleExprByCastKind(mirBuidler, resultCastKind, srcType, dstType, toCastExpr, dstTyIdx);
+}
+}
diff --git a/src/mapleall/maple_me/src/cfg_opt.cpp b/src/mapleall/maple_me/src/cfg_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0a4d3f685de994172910504d438bbc67a55c9773
--- /dev/null
+++ b/src/mapleall/maple_me/src/cfg_opt.cpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cfg_opt.h"
+#include "mir_builder.h"
+#include "string_utils.h"
+#include "me_dominance.h"
+
+namespace maple {
+bool CfgOpt::IsShortCircuitBB(LabelIdx labelIdx) {
+  if (labelIdx == 0) {
+    return false;
+  }
+  std::string labelName = meFunc.GetMirFunc()->GetLabelTabItem(labelIdx);
+  return labelName.find("_end") == std::string::npos && labelName.find("shortCircuit_label") != std::string::npos;
+}
+
+bool CfgOpt::IsShortCircuitStIdx(StIdx stIdx) {
+  if (stIdx.IsGlobal()) {
+    return false;
+  }
+  auto *sym = meFunc.GetMirFunc()->GetSymTab()->GetSymbolFromStIdx(stIdx.Idx());
+  CHECK_FATAL(sym, "sym is nullptr!");
+  std::string symName = sym->GetName();
+  return symName.find("shortCircuit") != std::string::npos;
+}
+
+bool CfgOpt::IsAssignToShortCircuit(const StmtNode &stmt) {
+  if (stmt.GetOpCode() != OP_dassign) {
+    return false;
+  }
+  return IsShortCircuitStIdx(static_cast<const DassignNode&>(stmt).GetStIdx());
+}
+
+void CfgOpt::SimplifyCondGotoStmt(CondGotoNode &condGoto) const {
+  BaseNode *opnd = condGoto.Opnd(0);
+  Opcode curOp = condGoto.GetOpCode();
+  Opcode oppositeOp = curOp == OP_brtrue ? OP_brfalse : OP_brtrue;
+  if (opnd->GetOpCode() == OP_ne || opnd->GetOpCode() == OP_eq) {
+    BaseNode *rhs = opnd->Opnd(1);
+    if (rhs->GetOpCode() == OP_constval) {
+      ConstvalNode *constNode = static_cast<ConstvalNode*>(rhs);
+      if (constNode->GetConstVal()->GetKind() == kConstInt && constNode->GetConstVal()->IsZero()) {
+        Opcode simplifiedOpcode = opnd->GetOpCode() == OP_eq ? oppositeOp : curOp;
+        condGoto.SetOpCode(simplifiedOpcode);
+        condGoto.SetOpnd(opnd->Opnd(0), 0);
+      }
+    }
+  } else if (opnd->GetOpCode() == OP_lnot) {
+    condGoto.SetOpCode(oppositeOp);
+    condGoto.SetOpnd(opnd->Opnd(0), 0);
+  }
+}
+
+void CfgOpt::PropagateBB(BB &bb, BB *trueBranchBB, BB *falseBranchBB) {
+  if (!IsShortCircuitBB(bb.GetBBLabel())) {
+    return;
+  }
+  for (auto predBB : bb.GetPred()) {
+    if (predBB->IsEmpty()) {
+      continue;
+    }
+    BB *trueBranchBBForPred = trueBranchBB;
+    BB *falseBranchBBForPred = falseBranchBB;
+    switch (predBB->GetKind()) {
+      case kBBCondGoto: {
+        auto &condGoto = static_cast<CondGotoNode&>(predBB->GetLast());
+        SimplifyCondGotoStmt(condGoto);
+        BB *branchBB;
+        if (condGoto.GetOpCode() == OP_brfalse) {
+          trueBranchBBForPred = predBB->GetSucc(0);
+          branchBB = falseBranchBBForPred;
+        } else {
+          falseBranchBBForPred = predBB->GetSucc(0);
+          branchBB = trueBranchBBForPred;
+        }
+        if (trueBranchBBForPred != falseBranchBBForPred) {
+          changedShortCircuit.emplace_back(std::make_pair(predBB, branchBB));
+          condGoto.SetOffset(meFunc.GetOrCreateBBLabel(*branchBB));
+        }
+        break;
+      }
+      case kBBGoto:
+      case kBBFallthru: {
+        if (!IsShortCircuitBB(predBB->GetBBLabel())) {
+          continue;
+        }
+        if (trueBranchBBForPred == falseBranchBBForPred) {
+          trueBranchBBForPred = falseBranchBBForPred = predBB;
+        }
+        break;
+      }
+      default: {
+        CHECK_FATAL(false, "unexpected BB kind in shorcircuit");
+        break;
+      }
+    }
+    if (predBB->GetFirst().GetOpCode() == OP_dassign && predBB->GetFirst().Opnd(0)->GetOpCode() == OP_eq) {
+      BB *temp = trueBranchBBForPred;
+      trueBranchBBForPred = falseBranchBBForPred;
+      falseBranchBBForPred = temp;
+    }
+    if (!IsAssignToShortCircuit(predBB->GetFirst())) {
+      continue;
+    }
+    PropagateBB(*predBB, trueBranchBBForPred, falseBranchBBForPred);
+  }
+}
+
+void CfgOpt::PropagateOuterBBInfo() {
+  for (auto bb : cfg.GetAllBBs()) {
+    if (bb == nullptr || !IsShortCircuitBB(bb->GetBBLabel())) {
+      continue;
+    }
+    switch (bb->GetKind()) {
+      case kBBReturn:
+      case kBBGoto: {
+        PropagateBB(*bb, bb, bb);
+        break;
+      }
+      case kBBCondGoto: {
+        auto &condGoto = static_cast<CondGotoNode&>(bb->GetLast());
+        SimplifyCondGotoStmt(condGoto);
+        if (IsShortCircuitBB(condGoto.GetOffset())) {
+          break;
+        }
+        if (bb->GetFirst().GetOpCode() != OP_brfalse && bb->GetFirst().GetOpCode() != OP_brtrue) {
+          PropagateBB(*bb, bb, bb);
+        } else if (condGoto.GetOpCode() == OP_brfalse) {
+          PropagateBB(*bb, bb->GetSucc(0), bb->GetSucc(1));
+        } else {
+          PropagateBB(*bb, bb->GetSucc(1), bb->GetSucc(0));
+        }
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+}
+
+void CfgOpt::OptimizeShortCircuitBranch() {
+  for (auto pair : changedShortCircuit) {
+    BB *condGotoBB = pair.first;
+    BB *newBranchBB = pair.second;
+    BB *oldBranchBB = condGotoBB->GetSucc(1);
+    if (newBranchBB != oldBranchBB) {
+      condGotoBB->ReplaceSucc(oldBranchBB, newBranchBB);
+      cfgChanged = true;
+    }
+  }
+}
+
+void CfgOpt::Run() {
+  PropagateOuterBBInfo();
+  OptimizeShortCircuitBranch();
+}
+
+bool MECFGOPT::PhaseRun(MeFunction &f) {
+  CfgOpt cfgOpt(f, *f.GetCfg());
+  cfgOpt.Run();
+  if (cfgOpt.IsCfgChanged()) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+  }
+  return false;
+}
+
+void MECFGOPT::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/code_factoring.cpp b/src/mapleall/maple_me/src/code_factoring.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b01370d5199e22ba3bfbe5b60ae3692d58357a39
--- /dev/null
+++ b/src/mapleall/maple_me/src/code_factoring.cpp
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "code_factoring.h"
+#include "me_cfg.h"
+#include "me_dominance.h"
+
+// This phase aims to move identical stmts into common block to reduce code size
+// Two methods are used in this phase:
+// 1. local factoring: hoist/sink identical stmts to it's common predecessor/successor
+// 2. sequence extract: extract a series of stmts into one common block and merge
+//                      all predecessors and successors to this block
+namespace maple {
+struct cmpByBBID {
+  bool operator()(BB* bb1, BB* bb2) const {
+    return bb1->GetBBId() < bb2->GetBBId();
+  }
+};
+
+class FactoringOptimizer {
+ public:
+  FactoringOptimizer(MeFunction &f, bool enableDebug)
+      : func(f),
+        cfg(f.GetCfg()),
+        codeMP(f.GetMirFunc()->GetCodeMemPool()),
+        codeMPAlloc(&f.GetMirFunc()->GetCodeMemPoolAllocator()),
+        mirBuilder(f.GetMIRModule().GetMIRBuilder()),
+        dumpDetail(enableDebug) {}
+  ~FactoringOptimizer() = default;
+  bool IsCFGChanged() const {
+    return isCFGChanged;
+  }
+  bool IsIdenticalStmt(StmtNode *stmt1, StmtNode *stmt2);
+  void SinkStmtsInCands(std::map<BB*, StmtNode*, cmpByBBID> &cands);
+  void DoSink(BB *bb);
+  void RunLocalFactoring();
+
+ private:
+  MeFunction &func;
+  MeCFG *cfg;
+  MemPool *codeMP;
+  MapleAllocator *codeMPAlloc;
+  MIRBuilder *mirBuilder;
+  bool dumpDetail = false;
+  bool isCFGChanged = false;
+  uint32 sinkCount = 0;
+};
+
+static bool IsConstOp(Opcode op) {
+  return op == OP_constval || op == OP_conststr || op == OP_conststr;
+}
+
+bool FactoringOptimizer::IsIdenticalStmt(StmtNode *stmt1, StmtNode *stmt2) {
+  auto op = stmt1->GetOpCode();
+  if (op != stmt2->GetOpCode()) {
+    return false;
+  }
+  bool isCall = false;
+  switch (op) {
+    case OP_dassign: {
+      auto *dass1 = static_cast<DassignNode*>(stmt1);
+      auto *dass2 = static_cast<DassignNode*>(stmt2);
+      if (dass1->GetStIdx() != dass2->GetStIdx() ||
+          dass1->GetFieldID() != dass2->GetFieldID()) {
+        return false;
+      }
+      break;
+    }
+    case OP_dassignoff: {
+      auto *dassoff1 = static_cast<DassignoffNode*>(stmt1);
+      auto *dassoff2 = static_cast<DassignoffNode*>(stmt2);
+      if (dassoff1->stIdx != dassoff2->stIdx ||
+          dassoff1->offset != dassoff2->offset) {
+        return false;
+      }
+      break;
+    }
+    case OP_iassign: {
+      auto *iass1 = static_cast<IassignNode*>(stmt1);
+      auto *iass2 = static_cast<IassignNode*>(stmt2);
+      if (iass1->GetTyIdx() != iass2->GetTyIdx() ||
+          iass1->GetFieldID() != iass2->GetFieldID()) {
+        return false;
+      }
+      break;
+    }
+    case OP_iassignoff: {
+      auto *iassoff1 = static_cast<IassignoffNode*>(stmt1);
+      auto *iassoff2 = static_cast<IassignoffNode*>(stmt2);
+      if (iassoff1->GetOffset() != iassoff2->GetOffset()) {
+        return false;
+      }
+      break;
+    }
+    case OP_call:
+    case OP_callassigned: {
+      auto *call1 = static_cast<CallNode*>(stmt1);
+      auto *call2 = static_cast<CallNode*>(stmt2);
+      if (call1->GetPUIdx() != call2->GetPUIdx() ||
+          call1->GetTyIdx() != call2->GetTyIdx() ||
+          call1->GetCallReturnVector()->size() != call2->GetReturnVec().size()) {
+        return false;
+      }
+      for (size_t i = 0; i < call1->GetCallReturnVector()->size(); ++i) {
+        auto retPair1 = call1->GetReturnPair(i);
+        auto retPair2 = call2->GetReturnPair(i);
+        if (retPair1.first != retPair2.first ||
+            retPair1.second.GetPregIdx() != retPair2.second.GetPregIdx() ||
+            retPair1.second.GetFieldID() != retPair2.second.GetFieldID()) {
+          return false;
+        }
+      }
+      isCall = true;
+      break;
+    }
+    case OP_icall:
+    case OP_icallassigned:
+    case OP_icallproto:
+    case OP_icallprotoassigned: {
+      auto *icall1 = static_cast<IcallNode*>(stmt1);
+      auto *icall2 = static_cast<IcallNode*>(stmt2);
+      if (icall1->GetRetTyIdx() != icall2->GetRetTyIdx() ||
+          icall1->GetCallReturnVector()->size() != icall2->GetCallReturnVector()->size()) {
+        return false;
+      }
+      if (icall1->GetCallReturnVector()->size() > 0) {
+        auto retPair1 = icall1->GetCallReturnVector()->at(0);
+        auto retPair2 = icall2->GetCallReturnVector()->at(0);
+        if (retPair1.first != retPair2.first ||
+            retPair1.second.GetPregIdx() != retPair2.second.GetPregIdx() ||
+            retPair1.second.GetFieldID() != retPair2.second.GetFieldID()) {
+          return false;
+        }
+      }
+      isCall = true;
+      break;
+    }
+    case OP_intrinsiccall:
+    case OP_intrinsiccallassigned: {
+      auto *call1 = static_cast<IntrinsiccallNode*>(stmt1);
+      auto *call2 = static_cast<IntrinsiccallNode*>(stmt2);
+      if (call1->GetIntrinsic() != call2->GetIntrinsic() ||
+          call1->GetTyIdx() != call2->GetTyIdx() ||
+          call1->GetCallReturnVector()->size() != call2->GetReturnVec().size()) {
+        return false;
+      }
+      for (size_t i = 0; i < call1->GetCallReturnVector()->size(); ++i) {
+        auto retPair1 = call1->GetCallReturnPair(i);
+        auto retPair2 = call2->GetCallReturnPair(i);
+        if (retPair1.first != retPair2.first ||
+            retPair1.second.GetPregIdx() != retPair2.second.GetPregIdx() ||
+            retPair1.second.GetFieldID() != retPair2.second.GetFieldID()) {
+          return false;
+        }
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+
+  // check number of operands
+  if (stmt1->NumOpnds() != stmt2->NumOpnds()) {
+    return false;
+  }
+
+  // check the operands
+  for (size_t i = 0; i < stmt1->NumOpnds(); ++i) {
+    auto *opnd1 = stmt1->Opnd(i);
+    auto *opnd2 = stmt2->Opnd(i);
+    if (isCall && IsConstOp(opnd1->GetOpCode())) {
+      if (opnd1->GetOpCode() == opnd2->GetOpCode()) {
+        continue;
+      }
+      return false;
+    }
+    if (!opnd1->IsSameContent(opnd2)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void FactoringOptimizer::SinkStmtsInCands(std::map<BB *, StmtNode *, cmpByBBID> &cands) {
+  BB *succ = cands.begin()->first->GetSucc(0);
+  BB *sinkBB = nullptr;
+  if (succ->GetPred().size() == cands.size()) {
+    sinkBB = succ;
+  } else {
+    sinkBB = cfg->NewBasicBlock();
+    sinkBB->SetKind(kBBFallthru);
+    sinkBB->SetAttributes(kBBAttrArtificial);
+    for (auto &candPair : cands) {
+      auto *pred = candPair.first;
+      pred->ReplaceSucc(succ, sinkBB);
+    }
+    sinkBB->AddSucc(*succ);
+    isCFGChanged = true;
+  }
+  auto *identifyStmt = cands.begin()->second;
+  auto *sinkedStmt = identifyStmt->CloneTree(*codeMPAlloc);
+  if (kOpcodeInfo.IsCall(identifyStmt->GetOpCode())) {
+    for (size_t i = 0; i < identifyStmt->NumOpnds(); ++i) {
+      auto *param = identifyStmt->Opnd(i);
+      if (!IsConstOp(param->GetOpCode())) {
+        continue;
+      }
+      // for different const parameter, use tmp reg to unify them
+      bool diff = false;
+      auto *identifyConst = param;
+      for (auto &pair : cands) {
+        auto *curNode = pair.second->Opnd(i);
+        if (!curNode->IsSameContent(identifyConst)) {
+          diff = true;
+          break;
+        }
+      }
+      if (!diff) {
+        continue;
+      }
+      // create tmp param reg
+      auto ptyp = param->GetPrimType();
+      auto regIdx = func.GetMirFunc()->GetPregTab()->CreatePreg(ptyp);
+      for (auto &pair : cands) {
+        auto *origOpnd = pair.second->Opnd(i);
+        auto *regass =
+            mirBuilder->CreateStmtRegassign(ptyp, regIdx, origOpnd->CloneTree(*codeMPAlloc));
+        // add const mov to bb's first so that we can continue to sink the new last stmt
+        pair.first->PrependStmtNode(regass);
+      }
+      sinkedStmt->SetOpnd(mirBuilder->CreateExprRegread(ptyp, regIdx), i);
+    }
+  }
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "\nSink process" << sinkCount << ":\n";
+    ++sinkCount;
+  }
+  for (auto &pair : cands) {
+    auto *pred = pair.first;
+    if (dumpDetail) {
+      LogInfo::MapleLogger() << "\nstmt: \n";
+      pair.second->Dump();
+      LogInfo::MapleLogger() << "in BB:" << pred->GetBBId() << " removed.\n";
+    }
+    if (pred->IsGoto()) {
+      pred->RemoveLastStmt();
+      pred->SetKind(kBBFallthru);
+    }
+    pred->RemoveStmtNode(pair.second);
+  }
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "\nnew stmt: \n";
+    sinkedStmt->Dump();
+    LogInfo::MapleLogger() << "added to BB:" << sinkBB->GetBBId() << ".\n";
+  }
+  sinkBB->PrependStmtNode(sinkedStmt);
+}
+
+// try to sink BB's last stmt to its succ, check if other preds have identical last stmt
+void FactoringOptimizer::DoSink(BB *bb) {
+  if (!bb || bb->IsEmpty() || bb->GetSucc().size() != 1) {
+    return;
+  }
+  auto *identifyStmt = &bb->GetLast();
+  while (identifyStmt &&
+         (identifyStmt->GetOpCode() == OP_comment || identifyStmt->GetOpCode() == OP_goto)) {
+    identifyStmt = identifyStmt->GetPrev();
+  }
+  if (!identifyStmt) {
+    return;
+  }
+  auto *succ = bb->GetSucc(0);
+  std::map<BB*, StmtNode*, cmpByBBID> cands;
+  cands.emplace(bb, identifyStmt);
+  // check other pred's last stmt
+  for (auto *pred : succ->GetPred()) {
+    if (pred == bb || pred->GetSucc().size() != 1 || pred->IsEmpty()) {
+      continue;
+    }
+    auto *lastStmt = &pred->GetLast();
+    while (lastStmt &&
+           (lastStmt->GetOpCode() == OP_comment || lastStmt->GetOpCode() == OP_goto)) {
+      lastStmt = lastStmt->GetPrev();
+    }
+    if (!lastStmt) {
+      continue;
+    }
+    if (IsIdenticalStmt(lastStmt, identifyStmt)) {
+      cands.emplace(pred, lastStmt);
+    }
+  }
+  if (cands.size() < 2) {
+    return;
+  }
+  SinkStmtsInCands(cands);
+  // continue to sink new last stmt
+  DoSink(bb);
+}
+
+void FactoringOptimizer::RunLocalFactoring() {
+  if (func.IsEmpty()) {
+    return;
+  }
+  for (auto *bb : cfg->GetAllBBs()) {
+    DoSink(bb);
+  }
+}
+
+void MECodeFactoring::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.SetPreservedAll();
+}
+
+bool MECodeFactoring::PhaseRun(MeFunction &f) {
+  auto *optimizer = GetPhaseAllocator()->New<FactoringOptimizer>(f, DEBUGFUNC_NEWPM(f));
+  optimizer->RunLocalFactoring();
+  if (optimizer->IsCFGChanged()) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/copy_prop.cpp b/src/mapleall/maple_me/src/copy_prop.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..87bf586e65b7535fa5b8594cf421258fce9d920c
--- /dev/null
+++ b/src/mapleall/maple_me/src/copy_prop.cpp
@@ -0,0 +1,512 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "copy_prop.h"
+#include "me_cfg.h"
+
+namespace maple {
+static constexpr uint kMaxDepth = 5;
+static bool PropagatableByCopyProp(const MeExpr *newExpr) {
+  ASSERT_NOT_NULL(newExpr);
+  return newExpr->GetMeOp() == kMeOpReg || newExpr->GetMeOp() == kMeOpConst;
+}
+
+static bool PropagatableBaseOfIvar(const IvarMeExpr *ivar, const MeExpr *newExpr) {
+  if (PropagatableByCopyProp(newExpr)) {
+    return true;
+  }
+  if ((ivar->GetFieldID() != 0 && ivar->GetFieldID() != 1) || ivar->GetOffset() != 0) {
+    return false;
+  }
+
+#if TARGX86_64 || TARGX86 || TARGVM || TARGARM32
+  return false;
+#endif
+
+  if (newExpr->GetOp() == OP_add) {
+    auto opndA = newExpr->GetOpnd(0);
+    if (!PropagatableByCopyProp(opndA)) {
+      return false;
+    }
+
+    auto opndB = newExpr->GetOpnd(1);
+    if (PropagatableByCopyProp(opndB)) {
+      return true;
+    }
+
+    if (opndB->GetOp() == OP_cvt || opndB->GetOp() == OP_retype) {
+      if (PropagatableByCopyProp(opndB->GetOpnd(0))) {
+        return true;
+      }
+    } else if (opndB->GetOp() == OP_mul) {
+      auto opndC = opndB->GetOpnd(0);
+      if (!PropagatableByCopyProp(opndC)) {
+        return false;
+      }
+
+      auto opndD = opndB->GetOpnd(1);
+      if (opndD->GetMeOp() != kMeOpConst) {
+        return false;
+      }
+      auto constVal = static_cast<ConstMeExpr *>(opndD)->GetConstVal();
+      if (constVal->GetKind() != kConstInt) {
+        return false;
+      }
+      int64 val = static_cast<MIRIntConst*>(constVal)->GetExtValue();
+      if (val == 0 || val == GetPrimTypeSize(PTY_ptr)) {
+        return true;
+      }
+    }
+  }
+  if (newExpr->GetOp() == OP_iaddrof) {
+    return PropagatableByCopyProp(newExpr->GetOpnd(0));
+  }
+  return false;
+}
+
+static bool PropagatableOpndOfOperator(const MeExpr *meExpr, Opcode op, size_t opndId) {
+  if (PropagatableByCopyProp(meExpr)) {
+    return true;
+  }
+
+#if TARGX86_64 || TARGX86 || TARGVM || TARGARM32
+  return false;
+#endif
+
+  if (op != OP_add && op != OP_sub) {
+    return false;
+  }
+  if (opndId != 1) {
+    return false;
+  }
+
+  if (meExpr->GetOp() != OP_cvt && meExpr->GetOp() != OP_retype) {
+    return false;
+  }
+  if (!PropagatableByCopyProp(meExpr->GetOpnd(0))) {
+    return false;
+  }
+  return true;
+}
+
+static bool ExpectedPropedExpr(const MeExpr &expr) {
+  auto meop = expr.GetMeOp();
+  if (meop == kMeOpReg || meop == kMeOpConst) {
+    return true;
+  }
+  if (meop == kMeOpOp) {
+    for (size_t i = 0; i < expr.GetNumOpnds(); ++i) {
+      if (!ExpectedPropedExpr(*expr.GetOpnd(i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+static bool IsSimpleExprOfOst(MeExpr &rhs, const OStIdx &idx, MeExpr *&preVersion) {
+  if (rhs.GetDepth() > kMaxDepth) {
+    return false;
+  }
+  MeExprOp meOp = rhs.GetMeOp();
+  switch (meOp) {
+    case kMeOpReg: {
+      auto &regRead = static_cast<RegMeExpr&>(rhs);
+      if (regRead.GetRegIdx() < 0) {
+        return false;
+      }
+      if (regRead.GetOstIdx() != idx) {
+        return false;
+      }
+      preVersion = &regRead;
+      break;
+    }
+    case kMeOpOp: {
+      if (kOpcodeInfo.NotPure(rhs.GetOp())) {
+        return false;
+      }
+      auto &meopexpr = static_cast<const OpMeExpr &>(rhs);
+      for (uint8 i = 0; i < meopexpr.GetNumOpnds(); ++i) {
+        if (!meopexpr.GetOpnd(i)) {
+          continue;
+        }
+        if (!IsSimpleExprOfOst(*meopexpr.GetOpnd(i), idx, preVersion)) {
+          return false;
+        }
+      }
+      break;
+    }
+    case kMeOpConst:
+      return true;
+    default:
+      return false;
+  }
+  return true;
+}
+
+bool CopyProp::IsSingleUse(const MeExpr *expr) {
+  if (!expr || expr->GetMeOp() != kMeOpReg) {
+    return false;
+  }
+  auto regMeExpr = static_cast<const RegMeExpr *>(expr);
+  if (regMeExpr->GetRegIdx() < 0) {  // special register
+    return false;
+  }
+  if (!regMeExpr->IsDefByStmt()) {
+    return false;
+  }
+  auto *useSites = useInfo.GetUseSitesOfExpr(expr);
+  CHECK_NULL_FATAL(useSites);
+  if (useSites->size() != 1) {
+    return false;
+  }
+  auto useItem = useSites->front();
+  if (useItem.GetRef() != 1) {
+    return false;
+  }
+  if (useItem.IsUseByPhi() || useItem.GetStmt()->GetOp() == OP_asm || kOpcodeInfo.IsCall(useItem.GetStmt()->GetOp())) {
+    return false;
+  }
+  return true;
+}
+
+static bool FoldableOp(Opcode op) {
+  return op == OP_add || op == OP_sub || op == OP_mul || op == OP_bior || op == OP_band;
+}
+
+// we hope that prop the expr will not make the live-range more complicated
+void CopyProp::CheckLiveRange(const MeExpr &expr, int32 &badPropCnt) {
+  if (static_cast<uint32>(expr.GetDepth()) > kMaxDepth) {
+    badPropCnt += static_cast<int32>(kMaxDepth);
+    return;
+  }
+  switch (expr.GetMeOp()) {
+    case kMeOpReg: {
+      auto &scalar = static_cast<const ScalarMeExpr&>(expr);
+      bool findLongerUse = false;
+      for (auto &ui : *useInfo.GetUseSitesOfExpr(&scalar)) {
+        const BB *useBB = ui.GetUseBB();
+        if (dom.Dominate(*curBB, *useBB) || pdom.Dominate(*useBB, *curBB)) {
+          findLongerUse = true;
+          break;
+        }
+      }
+      badPropCnt += (findLongerUse ? 0 : 1);
+      return;
+    }
+    default: {
+      for (size_t i = 0; i < expr.GetNumOpnds(); ++i) {
+        CheckLiveRange(*expr.GetOpnd(i), badPropCnt);
+      }
+    }
+  }
+}
+
+bool CopyProp::CanPropSingleUse(const ScalarMeExpr &lhs, const MeExpr &rhs) {
+  if (!FoldableOp(rhs.GetOp()) && !rhs.IsScalar()) {
+    return false;
+  }
+  if (!IsSingleUse(&lhs)) {
+    return false;
+  }
+  BB *defBB = lhs.GetDefStmt()->GetBB();
+  if (curBB == defBB) {
+    return true;
+  }
+  if (loopInfo->GetBBLoopParent(curBB->GetBBId()) != loopInfo->GetBBLoopParent(defBB->GetBBId())) {
+    return false;
+  }
+  int32 badPropCnt = 0;
+  CheckLiveRange(rhs, badPropCnt);
+  static const int32 allowedBPC = 2;
+  return badPropCnt <= allowedBPC;
+}
+
+void CopyProp::ReplaceSelfAssign() {
+  for (auto &useSitesPair : useInfo.GetUseSites()) {
+    auto expr = useSitesPair.first;
+    if (!IsSingleUse(expr)) {
+      continue;
+    }
+    auto regMeExpr = static_cast<RegMeExpr *>(expr);
+    auto *defStmt = regMeExpr->GetDefStmt();
+    CHECK_NULL_FATAL(defStmt);
+    auto rhs = defStmt->GetRHS();
+    MeExpr* preVersionExpr = nullptr;
+    if (!IsSimpleExprOfOst(*rhs, regMeExpr->GetOstIdx(), preVersionExpr)) {
+      continue;
+    }
+    auto stmt = useSitesPair.second->front().GetStmt();
+    if (irMap.ReplaceMeExprStmt(*stmt, *regMeExpr, *rhs)) {
+      defStmt->GetBB()->RemoveMeStmt(defStmt);
+      if (preVersionExpr) {
+        useInfo.AddUseSiteOfExpr(preVersionExpr, stmt);
+      }
+    }
+  }
+}
+
+MeExpr &CopyProp::PropMeExpr(MeExpr &meExpr, bool &isproped, bool atParm) {
+  MeExprOp meOp = meExpr.GetMeOp();
+
+  bool subProped = false;
+  switch (meOp) {
+    case kMeOpVar: {
+      auto &varExpr = static_cast<VarMeExpr&>(meExpr);
+      MeExpr *propMeExpr = &meExpr;
+      MIRSymbol *symbol = varExpr.GetOst()->GetMIRSymbol();
+      if (mirModule.IsCModule() && CanBeReplacedByConst(*symbol) && symbol->GetKonst() != nullptr) {
+        propMeExpr = irMap.CreateConstMeExpr(varExpr.GetPrimType(), *symbol->GetKonst());
+      } else {
+        propMeExpr = &PropVar(varExpr, atParm, true);
+      }
+      if (propMeExpr != &varExpr) {
+        isproped = true;
+      }
+      return *propMeExpr;
+    }
+    case kMeOpReg: {
+      auto &regExpr = static_cast<RegMeExpr&>(meExpr);
+      if (regExpr.GetRegIdx() < 0) {
+        return meExpr;
+      }
+      MeExpr &propMeExpr = PropReg(regExpr, atParm, true);
+      if (&propMeExpr != &regExpr) {
+        isproped = true;
+      }
+      return propMeExpr;
+    }
+    case kMeOpIvar: {
+      auto *ivarMeExpr = static_cast<IvarMeExpr*>(&meExpr);
+      if (ivarMeExpr->HasMultipleMu()) {
+        return meExpr;
+      }
+      ASSERT(ivarMeExpr->GetUniqueMu() != nullptr, "PropMeExpr: ivar has mu == nullptr");
+      auto *base = ivarMeExpr->GetBase();
+      MeExpr *propedExpr = &PropMeExpr(utils::ToRef(base), subProped, false);
+      if (propedExpr == base) {
+        return meExpr;
+      }
+
+      if (!(base->GetMeOp() == kMeOpVar || base->GetMeOp() == kMeOpReg) ||
+          PropagatableBaseOfIvar(ivarMeExpr, propedExpr)) {
+        isproped = true;
+        IvarMeExpr newMeExpr(&irMap.GetIRMapAlloc(), -1, *ivarMeExpr);
+        newMeExpr.SetBase(propedExpr);
+        newMeExpr.SetDefStmt(nullptr);
+        ivarMeExpr = static_cast<IvarMeExpr*>(irMap.HashMeExpr(newMeExpr));
+        auto *simplified = irMap.SimplifyIvar(ivarMeExpr, false);
+        ivarMeExpr = (simplified != nullptr && simplified->GetMeOp() == kMeOpIvar) ?
+            static_cast<IvarMeExpr*>(simplified) : ivarMeExpr;
+      }
+
+      auto &propedIvar = PropIvar(*ivarMeExpr);
+      if (PropagatableByCopyProp(&propedIvar)) {
+        return propedIvar;
+      }
+      return *ivarMeExpr;
+    }
+    case kMeOpOp: {
+      auto &meOpExpr = static_cast<OpMeExpr&>(meExpr);
+      OpMeExpr newMeExpr(meOpExpr, -1);
+      MeExpr *simplifyExpr = nullptr;
+
+      for (size_t i = 0; i < newMeExpr.GetNumOpnds(); ++i) {
+        auto opnd = meOpExpr.GetOpnd(i);
+        auto &propedExpr = PropMeExpr(utils::ToRef(opnd), subProped, false);
+        if ((opnd->GetMeOp() == kMeOpVar || opnd->GetMeOp() == kMeOpReg) &&
+            !PropagatableOpndOfOperator(&propedExpr, meExpr.GetOp(), i) &&
+            // force prop into foldableop if is single use
+            (!FoldableOp(meExpr.GetOp()) || !CanPropSingleUse(static_cast<ScalarMeExpr&>(*opnd), propedExpr))) {
+          if (!ExpectedPropedExpr(propedExpr)) {
+            continue;
+          }
+          newMeExpr.SetOpnd(i, &propedExpr);
+          simplifyExpr = irMap.SimplifyOpMeExpr(&newMeExpr);
+          if (!simplifyExpr || simplifyExpr->GetDepth() >= newMeExpr.GetDepth()) {
+            newMeExpr.SetOpnd(i, opnd);
+            continue;
+          }
+        }
+
+        newMeExpr.SetOpnd(i, &propedExpr);
+        isproped = true;
+      }
+      simplifyExpr = irMap.SimplifyOpMeExpr(&newMeExpr);
+      return simplifyExpr != nullptr ? *simplifyExpr : utils::ToRef(irMap.HashMeExpr(newMeExpr));
+    }
+    case kMeOpNary: {
+      auto &naryMeExpr = static_cast<NaryMeExpr&>(meExpr);
+      NaryMeExpr newMeExpr(&propMapAlloc, -1, naryMeExpr);
+
+      bool needRehash = false;
+      for (size_t i = 0; i < naryMeExpr.GetOpnds().size(); ++i) {
+        if (i == 0 && naryMeExpr.GetOp() == OP_array && !config.propagateBase) {
+          continue;
+        }
+        auto *opnd = naryMeExpr.GetOpnd(i);
+        auto &propedExpr = PropMeExpr(utils::ToRef(opnd), subProped, false);
+        if (&propedExpr != opnd) {
+          if ((opnd->GetMeOp() == kMeOpVar || opnd->GetMeOp() == kMeOpReg) && !PropagatableByCopyProp(&propedExpr)) {
+            continue;
+          }
+          newMeExpr.SetOpnd(i, &propedExpr);
+          needRehash = true;
+        }
+      }
+
+      if (needRehash) {
+        isproped = true;
+        return utils::ToRef(irMap.HashMeExpr(newMeExpr));
+      } else {
+        return naryMeExpr;
+      }
+    }
+    default:
+      return meExpr;
+  }
+}
+
+void CopyProp::TraversalMeStmt(MeStmt &meStmt) {
+  ++cntOfPropedStmt;
+  if (cntOfPropedStmt > MeOption::copyPropLimit) {
+    return;
+  }
+  Opcode op = meStmt.GetOp();
+
+  bool subProped = false;
+  // prop operand
+  switch (op) {
+    case OP_iassign: {
+      auto &ivarStmt = static_cast<IassignMeStmt&>(meStmt);
+      auto *rhs = ivarStmt.GetRHS();
+      auto &propedRHS = PropMeExpr(utils::ToRef(rhs), subProped, false);
+      if (rhs->GetMeOp() == kMeOpVar || rhs->GetMeOp() == kMeOpReg) {
+        if (PropagatableByCopyProp(&propedRHS)) {
+          ivarStmt.SetRHS(&propedRHS);
+        }
+      } else {
+        ivarStmt.SetRHS(&propedRHS);
+      }
+
+      auto *lhs = ivarStmt.GetLHSVal();
+      auto *baseOfIvar = lhs->GetBase();
+      MeExpr *propedExpr = &PropMeExpr(utils::ToRef(baseOfIvar), subProped, false);
+      if (propedExpr != baseOfIvar &&
+          (PropagatableByCopyProp(propedExpr) ||
+           (propedExpr->GetDepth() == baseOfIvar->GetDepth() && !propedExpr->IsLeaf()))) {
+        ivarStmt.GetLHSVal()->SetBase(propedExpr);
+        ivarStmt.SetLHSVal(irMap.BuildLHSIvarFromIassMeStmt(ivarStmt));
+      }
+      break;
+    }
+    case OP_dassign:
+    case OP_regassign: {
+      AssignMeStmt &assignStmt = static_cast<AssignMeStmt &>(meStmt);
+      auto *rhs = assignStmt.GetRHS();
+      auto &propedRHS = PropMeExpr(utils::ToRef(rhs), subProped, false);
+      if (rhs->GetMeOp() == kMeOpVar || rhs->GetMeOp() == kMeOpReg) {
+        if (PropagatableByCopyProp(&propedRHS)) {
+          assignStmt.SetRHS(&propedRHS);
+        }
+      } else {
+        assignStmt.SetRHS(&propedRHS);
+      }
+
+      PropUpdateDef(*assignStmt.GetLHS());
+      break;
+    }
+    case OP_asm: break;
+    case OP_brtrue:
+    case OP_brfalse: {
+      PropConditionBranchStmt(&meStmt);
+      break;
+    }
+    default:{
+      for (size_t i = 0; i != meStmt.NumMeStmtOpnds(); ++i) {
+        auto opnd = meStmt.GetOpnd(i);
+        MeExpr &propedExpr = PropMeExpr(utils::ToRef(opnd), subProped, kOpcodeInfo.IsCall(op));
+        if (opnd->GetMeOp() == kMeOpVar || opnd->GetMeOp() == kMeOpReg) {
+          if (PropagatableByCopyProp(&propedExpr)) {
+            meStmt.SetOpnd(i, &propedExpr);
+          }
+        } else {
+          meStmt.SetOpnd(i, &propedExpr);
+        }
+      }
+      break;
+    }
+  }
+
+  // update chi
+  auto *chiList = meStmt.GetChiList();
+  if (chiList != nullptr) {
+    switch (op) {
+      case OP_syncenter:
+      case OP_syncexit: {
+        break;
+      }
+      default:
+        PropUpdateChiListDef(*chiList);
+        break;
+    }
+  }
+
+  // update must def
+  if (kOpcodeInfo.IsCallAssigned(op)) {
+    MapleVector<MustDefMeNode> *mustDefList = meStmt.GetMustDefList();
+    for (auto &node : utils::ToRef(mustDefList)) {
+      MeExpr *meLhs = node.GetLHS();
+      PropUpdateDef(utils::ToRef(static_cast<VarMeExpr*>(meLhs)));
+    }
+  }
+}
+
+void MECopyProp::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.SetPreservedAll();
+}
+
+bool MECopyProp::PhaseRun(maple::MeFunction &f) {
+  auto *dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  auto pdom = dominancePhase->GetPdomResult();
+  CHECK_NULL_FATAL(pdom);
+  auto *hMap = GET_ANALYSIS(MEIRMapBuild, f);
+  auto *loops = GET_ANALYSIS(MELoopAnalysis, f);
+
+  auto propConfig = Prop::PropConfig {
+      MeOption::propBase, true, MeOption::propGlobalRef, MeOption::propFinaliLoadRef, MeOption::propIloadRefNonParm,
+      MeOption::propAtPhi, MeOption::propWithInverse || f.IsLfo()
+  };
+  auto &useInfo = hMap->GetExprUseInfo();
+  if (useInfo.IsInvalid()) {
+    useInfo.CollectUseInfoInFunc(hMap, dom, kUseInfoOfScalar);
+  }
+  CopyProp copyProp(&f, useInfo, loops, *hMap, *dom, *pdom, *ApplyTempMemPool(), f.GetCfg()->NumBBs(), propConfig);
+  copyProp.ReplaceSelfAssign();
+  copyProp.TraversalBB(*f.GetCfg()->GetCommonEntryBB());
+  useInfo.InvalidUseInfo();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== After Copy Propagation  =============" << '\n';
+    f.Dump(false);
+    f.GetCfg()->DumpToFile("afterCopyProp-");
+  }
+  return false;
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/demand_driven_alias_analysis.cpp b/src/mapleall/maple_me/src/demand_driven_alias_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8781a30eba90efbf14002d708e76056116f34bd4
--- /dev/null
+++ b/src/mapleall/maple_me/src/demand_driven_alias_analysis.cpp
@@ -0,0 +1,1172 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "demand_driven_alias_analysis.h"
+#include "bb.h"
+#include "dominance.h"
+#include "mir_nodes.h"
+#include "ssa_mir_nodes.h"
+#include "mir_type.h"
+#include "orig_symbol.h"
+#include "me_cfg.h"
+#include "alias_class.h"
+#include "me_option.h"
+
+namespace maple {
+inline static bool IsAlloc(const BaseNode *x) {
+  return x->op == OP_malloc || x->op == OP_gcmalloc || x->op == OP_gcmallocjarray || x->op == OP_alloca ||
+         x->op == OP_stackmalloc || x->op == OP_stackmallocjarray;
+}
+
+void PEGNode::Dump() {
+  LogInfo::MapleLogger() << "PEGNode: idx(" << vst->GetIndex() << ")";
+  vst->Dump();
+  if (attr[kAliasAttrNotAllDefsSeen]) {
+    LogInfo::MapleLogger() << " NADS";
+  }
+  if (attr[kAliasAttrGlobal]) {
+    LogInfo::MapleLogger() << " Global";
+  }
+  if (attr[kAliasAttrFormal]) {
+    LogInfo::MapleLogger() << " Formal";
+  }
+  if (attr[kAliasAttrEscaped]) {
+    LogInfo::MapleLogger() << " Escaped";
+  }
+  if (attr[kAliasAttrNextLevNotAllDefsSeen]) {
+    LogInfo::MapleLogger() << " NextLevNADS";
+  }
+  if (multiDefed) {
+    LogInfo::MapleLogger() << " multiDefed";
+  }
+  LogInfo::MapleLogger() << std::endl;
+}
+
+PEGNode *ProgramExprGraph::GetOrCreateNodeOf(const VersionSt *vst) {
+  if (allNodes.size() > vst->GetIndex() && allNodes[vst->GetIndex()] != nullptr) {
+    return allNodes[vst->GetIndex()].get();
+  }
+
+  if (vst->GetIndex() >= allNodes.size()) {
+    constexpr uint32 buffer = 10;
+    auto newSize = vst->GetIndex() + buffer;
+    allNodes.resize(newSize);
+  }
+  auto newNode = std::make_unique<PEGNode>(vst);
+  auto *ost = vst->GetOst();
+  if (ost->GetIndirectLev() == 0) {
+    if (ost->IsFormal()) {
+      newNode->attr[kAliasAttrFormal] = true;
+    } else if (ost->IsSymbolOst() && ost->GetMIRSymbol()->IsGlobal()) {
+      newNode->attr[kAliasAttrGlobal] = true;
+    }
+  }
+  allNodes[vst->GetIndex()] = std::move(newNode);
+  return allNodes[vst->GetIndex()].get();
+}
+
+PEGNode *ProgramExprGraph::GetNodeOf(const VersionSt *vst) const {
+  if (vst->GetIndex() < allNodes.size()) {
+    return allNodes[vst->GetIndex()].get();
+  }
+  return nullptr;
+}
+
+PEGNode *ProgramExprGraph::GetNodeOf(const OriginalSt *ost) const {
+  CHECK_FATAL(ost->GetVersionsIndices().size() == 1, "ost must only has zero version");
+  if (ost->GetZeroVersionIndex() < allNodes.size()) {
+    return allNodes[ost->GetZeroVersionIndex()].get();
+  }
+  return nullptr;
+}
+
+void ProgramExprGraph::Dump() const {
+  LogInfo::MapleLogger() << ">>>>>>>>>>>>>>demand driven alias analysis: peg nodes<<<<<<<<<<<<<<<"
+                         << std::endl;
+  auto dumpOffset = [](OffsetType offset) {
+    LogInfo::MapleLogger() << "{offset: ";
+    if (offset.IsInvalid()) {
+      LogInfo::MapleLogger() << "UN} ";
+    } else {
+      LogInfo::MapleLogger() << offset.val << "} ";
+    }
+  };
+
+  for (auto &nodePtr : allNodes) {
+    auto node = nodePtr.get();
+    if (node == nullptr) {
+      continue;
+    }
+    node->vst->Dump();
+    LogInfo::MapleLogger() << " idx(" << node->vst->GetIndex() << ")";
+    if (node->attr[kAliasAttrNotAllDefsSeen]) {
+      LogInfo::MapleLogger() << " NADS";
+    }
+    if (node->attr[kAliasAttrGlobal]) {
+      LogInfo::MapleLogger() << " Global";
+    }
+    if (node->attr[kAliasAttrFormal]) {
+      LogInfo::MapleLogger() << " Formal";
+    }
+    if (node->attr[kAliasAttrEscaped]) {
+      LogInfo::MapleLogger() << " Escaped";
+    }
+    if (node->attr[kAliasAttrNextLevNotAllDefsSeen]) {
+      LogInfo::MapleLogger() << " NextLevNADS";
+    }
+    if (node->multiDefed) {
+      LogInfo::MapleLogger() << " multiDefed";
+    }
+
+    LogInfo::MapleLogger() << std::endl << ">>>assign from : ";
+    for (const auto &assignFrom : node->assignFrom) {
+      assignFrom.pegNode->vst->Dump();
+      dumpOffset(assignFrom.offset);
+    }
+
+    LogInfo::MapleLogger() << std::endl << ">>>assign to : ";
+    for (const auto &assignTo : node->assignTo) {
+      assignTo.pegNode->vst->Dump();
+    }
+
+    LogInfo::MapleLogger() << std::endl << ">>>prevLevNode : ";
+    if (node->prevLevNode != nullptr) {
+      node->prevLevNode->vst->Dump();
+    }
+
+    LogInfo::MapleLogger() << std::endl << ">>>nextLevNodes : ";
+    for (const auto *nextLevNode : node->nextLevNodes) {
+      nextLevNode->vst->Dump();
+      LogInfo::MapleLogger() << " ";
+    }
+    LogInfo::MapleLogger() << std::endl << std::endl;
+  }
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfDread(const AddrofSSANode *dread) {
+  auto *dreadNode = static_cast<const AddrofSSANode *>(dread);
+  auto *vst = dreadNode->GetSSAVar();
+  auto *ost = vst->GetOst();
+  PEGNode *pegNode = peg->GetOrCreateNodeOf(vst);
+  if (dreadNode->GetMIRSymbol().GetType()->IsStructType() && pegNode->prevLevNode == nullptr) {
+    auto *prevLevPointer = ssaTab->GetVerSt(ost->GetPointerVstIdx());
+    if (prevLevPointer != nullptr) {
+      auto pegNodeOfPointer = peg->GetOrCreateNodeOf(prevLevPointer);
+      pegNodeOfPointer->AddNextLevelNode(pegNode);
+      pegNode->prevLevNode = pegNodeOfPointer;
+    }
+  }
+  return PtrValueRecorder(pegNode, 0, OffsetType(0));
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfRegread(const RegreadSSANode *regread) {
+  auto *vst = regread->GetSSAVar();
+  if (vst->GetOst()->IsSpecialPreg()) {
+    return PtrValueRecorder(nullptr, 0, OffsetType(0));
+  }
+  return PtrValueRecorder(peg->GetOrCreateNodeOf(vst), 0, OffsetType(0));
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfIread(const IreadSSANode *iread) {
+  const auto &ptrNode = BuildPEGNodeOfExpr(iread->Opnd(0));
+  if (ptrNode.pegNode == nullptr) {
+    return PtrValueRecorder(nullptr, 0, OffsetType(0));
+  }
+
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx());
+  CHECK_FATAL(mirType->GetKind() == kTypePointer, "CreateAliasInfoExpr: ptr type expected in iread");
+  auto *pointedType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+  OffsetType offset(ptrNode.offset);
+  if (iread->GetFieldID() > 0) {
+    offset += pointedType->GetBitOffsetFromBaseAddr(iread->GetFieldID());
+    pointedType = static_cast<MIRStructType *>(pointedType)->GetFieldType(iread->GetFieldID());
+  }
+
+  bool typeHasBeenCasted =
+      AliasClass::IreadedMemInconsistentWithPointedType(iread->GetPrimType(), pointedType->GetPrimType());
+  offset = typeHasBeenCasted ? OffsetType::InvalidOffset() : offset;
+
+  auto *vstOfBase = ptrNode.pegNode->vst;
+  auto *mayUsedOst =
+      AliasClass::FindOrCreateExtraLevOst(ssaTab, vstOfBase, iread->GetTyIdx(), iread->GetFieldID(), offset);
+  auto *zeroVersionOfMayUsedOst = ssaTab->GetVersionStTable().GetZeroVersionSt(mayUsedOst);
+  // build prevLev-nextLev relationship
+  auto *pegNodeOfMayUsedOSt = peg->GetOrCreateNodeOf(zeroVersionOfMayUsedOst);
+
+  ptrNode.pegNode->AddNextLevelNode(pegNodeOfMayUsedOSt);
+  pegNodeOfMayUsedOSt->SetPrevLevelNode(ptrNode.pegNode);
+
+  return PtrValueRecorder(pegNodeOfMayUsedOSt, 0, OffsetType(0));
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfAddrof(const maple::AddrofSSANode *addrof) {
+  auto *vst = addrof->AddrofSSANode::GetSSAVar();
+  auto *ost = vst->GetOst();
+  auto *addrofOst = ost->GetPrevLevelOst();
+  if (addrofOst == nullptr) {
+    auto *ostOfAgg = ssaTab->GetOriginalStTable().FindSymbolOriginalSt(*ost->GetMIRSymbol());
+    addrofOst = ssaTab->FindOrCreateAddrofSymbolOriginalSt(ostOfAgg);
+  }
+
+  OffsetType offset(0);
+  if (ost->GetFieldID() > 1) { // offset of field 0 and 1 both are zero
+    offset.Set(ost->GetMIRSymbol()->GetType()->GetBitOffsetFromBaseAddr(ost->GetFieldID()));
+  }
+
+  auto *vstOfAddrofOst = ssaTab->GetVerSt(addrofOst->GetZeroVersionIndex());
+  auto *pegNodeOfAddrof = peg->GetOrCreateNodeOf(vstOfAddrofOst);
+  auto *pegNodeOfOst = peg->GetOrCreateNodeOf(vst);
+  pegNodeOfAddrof->AddNextLevelNode(pegNodeOfOst);
+  pegNodeOfOst->SetPrevLevelNode(pegNodeOfAddrof);
+
+  return PtrValueRecorder(pegNodeOfAddrof, ost->GetFieldID(), offset);
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfIaddrof(const IreadNode *iaddrof) {
+  const auto &ptrNode = BuildPEGNodeOfExpr(iaddrof->Opnd(0));
+  if (ptrNode.pegNode == nullptr) {
+    return PtrValueRecorder(nullptr, 0, OffsetType(0));
+  }
+
+  OffsetType offset = ptrNode.offset;
+  if (iaddrof->GetFieldID() != 0) {
+    auto mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iaddrof->GetTyIdx());
+    auto pointeeType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+    OffsetType offsetOfField(pointeeType->GetBitOffsetFromBaseAddr(iaddrof->GetFieldID()));
+    offset = offset + offsetOfField;
+  }
+
+  return PtrValueRecorder(ptrNode.pegNode, iaddrof->GetFieldID() + ptrNode.fieldId, offset);
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfAdd(const BinaryNode *binaryNode) {
+  const auto &ptrNode = BuildPEGNodeOfExpr(binaryNode->Opnd(0));
+  if (IsAddress(binaryNode->Opnd(0)->GetPrimType())) {
+    if (binaryNode->Opnd(1)->GetOpCode() != OP_constval) {
+      return PtrValueRecorder(ptrNode.pegNode, 0, OffsetType::InvalidOffset());
+    }
+
+    auto *constVal = static_cast<ConstvalNode *>(binaryNode->Opnd(1))->GetConstVal();
+    ASSERT(constVal->GetKind() == kConstInt, "pointer cannot add/sub a non-integer value");
+    int64 offsetInByte = static_cast<MIRIntConst *>(constVal)->GetExtValue();
+    int64 offsetInBit = kOffsetUnknown;
+    if (offsetInByte < kOffsetMax && offsetInByte > kOffsetMin) {
+      constexpr int kBitNumInOneByte = 8;
+      offsetInBit = offsetInByte * kBitNumInOneByte;
+    }
+
+    OffsetType offset(kOffsetUnknown);
+    if (binaryNode->GetOpCode() == OP_sub) {
+      offset = ptrNode.offset + (-offsetInBit);
+    } else if (binaryNode->GetOpCode() == OP_add) {
+      offset = ptrNode.offset + offsetInBit;
+    } else {
+      CHECK_FATAL(false, "unsupported pointer arithmetic");
+    }
+    return PtrValueRecorder(ptrNode.pegNode, 0, offset);
+  }
+  return PtrValueRecorder(ptrNode.pegNode, 0, OffsetType::InvalidOffset());
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfArray(const ArrayNode *arrayNode) {
+  for (uint32 id = 1; id < arrayNode->NumOpnds(); ++id) {
+    (void) BuildPEGNodeOfExpr(arrayNode->Opnd(id));
+  }
+
+  const auto &ptrNode = BuildPEGNodeOfExpr(arrayNode->Opnd(0));
+  OffsetType offset = AliasClass::OffsetInBitOfArrayElement(static_cast<const ArrayNode*>(arrayNode));
+  return PtrValueRecorder(ptrNode.pegNode, 0, offset + ptrNode.offset);
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfSelect(const  TernaryNode* selectNode) {
+  (void) BuildPEGNodeOfExpr(selectNode->Opnd(0));
+  const auto &ptrNodeA = BuildPEGNodeOfExpr(selectNode->Opnd(1));
+  const auto &ptrNodeB = BuildPEGNodeOfExpr(selectNode->Opnd(2));
+  if (ptrNodeA.pegNode == nullptr) {
+    return ptrNodeB;
+  }
+  return ptrNodeA;
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfIntrisic(const IntrinsicopNode* intrinsicNode) {
+  if (intrinsicNode->GetIntrinsic() == INTRN_MPL_READ_OVTABLE_ENTRY ||
+      (intrinsicNode->GetIntrinsic() == INTRN_JAVA_MERGE && intrinsicNode->NumOpnds() == 1 &&
+          intrinsicNode->GetNopndAt(0)->GetOpCode() == OP_dread)) {
+    return BuildPEGNodeOfExpr(intrinsicNode->GetNopndAt(0));
+  }
+  return PtrValueRecorder(nullptr, 0, OffsetType(0));
+}
+
+PEGBuilder::PtrValueRecorder PEGBuilder::BuildPEGNodeOfExpr(const BaseNode *expr) {
+  switch (expr->GetOpCode()) {
+    case OP_dread: {
+      return BuildPEGNodeOfDread(static_cast<const AddrofSSANode *>(expr));
+    }
+    case OP_regread: {
+      return BuildPEGNodeOfRegread(static_cast<const RegreadSSANode *>(expr));
+    }
+    case OP_iread: {
+      return BuildPEGNodeOfIread(static_cast<const IreadSSANode *>(expr));
+    }
+    case OP_addrof: {
+      return BuildPEGNodeOfAddrof(static_cast<const AddrofSSANode*>(expr));
+    }
+    case OP_iaddrof: {
+      return BuildPEGNodeOfIaddrof(static_cast<const IreadNode *>(expr));
+    }
+    case OP_add:
+    case OP_sub: {
+      return BuildPEGNodeOfAdd(static_cast<const BinaryNode *>(expr));
+    }
+    case OP_array: {
+      return BuildPEGNodeOfArray(static_cast<const ArrayNode*>(expr));
+    }
+    case OP_retype:
+    case OP_cvt: {
+      return BuildPEGNodeOfExpr(expr->Opnd(0));
+    }
+    case OP_select: {
+      return BuildPEGNodeOfSelect(static_cast<const TernaryNode *>(expr));
+    }
+    case OP_intrinsicop: {
+      return BuildPEGNodeOfIntrisic(static_cast<const IntrinsicopNode *>(expr));
+    }
+    default:
+      for (uint32 opndId = 0; opndId < expr->NumOpnds(); ++opndId) {
+        (void)BuildPEGNodeOfExpr(expr->Opnd(opndId));
+      }
+      return PtrValueRecorder(nullptr, 0, OffsetType(0));
+  }
+}
+
+inline bool CallStmtOpndEscape(const StmtNode *stmt) {
+  if (stmt->GetOpCode() != OP_call && stmt->GetOpCode() != OP_callassigned) {
+    return true;
+  }
+
+  auto *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(static_cast<const CallNode*>(stmt)->GetPUIdx());
+  if (mirFunc->GetFuncDesc().IsPure() || mirFunc->GetFuncDesc().IsConst()) {
+    return false;
+  }
+  return true;
+}
+
+inline static bool MaybeAddress(const TyIdx &tyIdx) {
+  auto primType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->GetPrimType();
+  return IsAddress(primType) || (IsPrimitiveInteger(primType) &&
+                                 GetPrimTypeSize(primType) >= GetPrimTypeSize(PTY_ptr));
+}
+
+void PEGBuilder::AddAssignEdge(const StmtNode *stmt, PEGNode *lhsNode, PEGNode *rhsNode, OffsetType offset) {
+  if (lhsNode == nullptr && rhsNode == nullptr) {
+    return;
+  }
+  if (lhsNode == rhsNode && offset.val == 0) {
+    return;
+  }
+
+  if (lhsNode == nullptr) {
+    bool rhsIsAddress = MaybeAddress(rhsNode->vst->GetOst()->GetTyIdx());
+    if (rhsIsAddress) {
+      rhsNode->attr[kAliasAttrEscaped] = true;
+    }
+    return;
+  }
+
+  bool lhsIsAddress = MaybeAddress(lhsNode->vst->GetOst()->GetTyIdx());
+  if (rhsNode == nullptr) {
+    if (!lhsIsAddress) {
+      return;
+    }
+    if (IsAlloc(stmt->Opnd(0))) {
+      return;
+    }
+    lhsNode->attr[kAliasAttrNextLevNotAllDefsSeen] = true;
+    return;
+  }
+
+  auto lhsOst = lhsNode->vst->GetOst();
+  auto rhsOst = rhsNode->vst->GetOst();
+  bool rhsIsAddress = MaybeAddress(rhsOst->GetTyIdx());
+  if (lhsIsAddress) {
+    // formal has init value at function entry,
+    // redefining makes formal be multi-defined.
+    if (lhsOst->IsFormal()) {
+      lhsNode->SetMultiDefined();
+    }
+
+    if (rhsIsAddress) {
+      peg->AddAssignEdge(lhsNode, rhsNode, offset);
+      lhsNode->attr |= rhsNode->attr;
+    } else {
+      lhsNode->attr[kAliasAttrNextLevNotAllDefsSeen] = true;
+    }
+  } else if (rhsIsAddress) {
+    rhsNode->attr[kAliasAttrEscaped] = true;
+  } else {
+    auto *lhsType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsOst->GetTyIdx());
+    auto *rhsType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(rhsOst->GetTyIdx());
+    if (lhsType != rhsType) {
+      return;
+    }
+
+    if (lhsType->IsStructType()) {
+      auto *preLevOfLHSOst = ssaTab->GetVerSt(lhsOst->GetPointerVstIdx());
+      if (preLevOfLHSOst == nullptr) {
+        return;
+      }
+      auto preLevOfRHSOst = ssaTab->GetVerSt(rhsOst->GetPointerVstIdx());
+      if (preLevOfRHSOst == nullptr) {
+        return;
+      }
+      auto *structType = static_cast<MIRStructType *>(lhsType);
+      auto tyIdxOfPrevLevOst = preLevOfLHSOst->GetOst()->GetTyIdx();
+      for (int32 fieldId = 1; fieldId <= static_cast<int32>(structType->NumberOfFieldIDs()); ++fieldId) {
+        auto *fieldType = structType->GetFieldType(fieldId);
+        if (!IsAddress(fieldType->GetPrimType())) {
+          continue;
+        }
+        OffsetType bitOffset(structType->GetBitOffsetFromBaseAddr(fieldId));
+
+        const auto *nextLevOstsOfLHS = ssaTab->GetNextLevelOsts(*preLevOfLHSOst);
+        auto fieldOstLHS = (nextLevOstsOfLHS == nullptr) ? nullptr :
+            ssaTab->GetOriginalStTable().FindExtraLevOriginalSt(
+                *nextLevOstsOfLHS, tyIdxOfPrevLevOst, fieldType, fieldId, bitOffset);
+
+        const auto *nextLevOstsOfRHS = ssaTab->GetNextLevelOsts(*preLevOfRHSOst);
+        auto fieldOstRHS = (nextLevOstsOfRHS == nullptr) ? nullptr :
+            ssaTab->GetOriginalStTable().FindExtraLevOriginalSt(
+                *nextLevOstsOfRHS, tyIdxOfPrevLevOst, fieldType, fieldId, bitOffset);
+        if (fieldOstLHS == nullptr && fieldOstRHS == nullptr) {
+          continue;
+        }
+
+        // the OriginalSt of at least one side has appearance in code
+        if (fieldOstLHS == nullptr) {
+          auto *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(lhsOst->GetTyIdx());
+          fieldOstLHS = ssaTab->GetOriginalStTable().FindOrCreateExtraLevOriginalSt(preLevOfLHSOst,
+                                                                                    ptrType->GetTypeIndex(),
+                                                                                    fieldId, bitOffset);
+        }
+
+        if (fieldOstRHS == nullptr) {
+          auto *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(rhsOst->GetTyIdx());
+          fieldOstRHS = ssaTab->GetOriginalStTable().FindOrCreateExtraLevOriginalSt(preLevOfRHSOst,
+                                                                                    ptrType->GetTypeIndex(),
+                                                                                    fieldId, bitOffset);
+        }
+
+        auto *zeroVersionOfFieldOstLHS = ssaTab->GetVersionStTable().GetOrCreateZeroVersionSt(*fieldOstLHS);
+        auto pegNodeOfLhsField = peg->GetOrCreateNodeOf(zeroVersionOfFieldOstLHS);
+        auto *prevLevNodeLhs = lhsNode->prevLevNode;
+        if (prevLevNodeLhs != nullptr) {
+          prevLevNodeLhs->AddNextLevelNode(pegNodeOfLhsField);
+          pegNodeOfLhsField->SetPrevLevelNode(prevLevNodeLhs);
+        }
+
+        auto *zeroVersionOfFieldOstRHS = ssaTab->GetVersionStTable().GetOrCreateZeroVersionSt(*fieldOstRHS);
+        auto pegNodeOfRhsField = peg->GetOrCreateNodeOf(zeroVersionOfFieldOstRHS);
+        auto *prevLevNodeRhs = rhsNode->prevLevNode;
+        if (prevLevNodeRhs != nullptr) {
+          prevLevNodeRhs->AddNextLevelNode(pegNodeOfRhsField);
+          pegNodeOfRhsField->SetPrevLevelNode(prevLevNodeRhs);
+        }
+
+        peg->AddAssignEdge(pegNodeOfLhsField, pegNodeOfRhsField, bitOffset);
+      }
+    }
+  }
+}
+
+void PEGBuilder::BuildPEGNodeInAssign(const StmtNode *stmt) {
+  VersionSt *vst = ssaTab->GetStmtsSSAPart().SSAPartOf(*stmt)->GetSSAVar();
+  OriginalSt *ost = vst->GetOst();
+  PEGNode *lhsNode = peg->GetOrCreateNodeOf(vst);
+  CHECK_FATAL(lhsNode != nullptr, "failed in create PEGNode");
+
+  if (ost->IsSymbolOst() && ost->GetMIRSymbol()->GetType()->IsStructType() &&
+      lhsNode->prevLevNode == nullptr) {
+    auto prevLevOfLhsOst = ssaTab->GetVerSt(ost->GetPointerVstIdx());
+    if (prevLevOfLhsOst == nullptr) {
+      auto *ostOfAgg = ssaTab->FindOrCreateSymbolOriginalSt(*ost->GetMIRSymbol(), ost->GetPuIdx(), 0);
+      auto *prevLevOst = ssaTab->FindOrCreateAddrofSymbolOriginalSt(ostOfAgg);
+      prevLevOfLhsOst = ssaTab->GetVerSt(prevLevOst->GetZeroVersionIndex());
+      if (ost->GetFieldID() != 0) {
+        ost->SetPointerVst(prevLevOfLhsOst);
+        ssaTab->GetOriginalStTable().AddNextLevelOstOfVst(prevLevOfLhsOst, ost);
+      }
+    }
+    auto pegNodeOfPrevLevOSt = peg->GetOrCreateNodeOf(prevLevOfLhsOst);
+    pegNodeOfPrevLevOSt->AddNextLevelNode(lhsNode);
+    lhsNode->SetPrevLevelNode(pegNodeOfPrevLevOSt);
+  }
+
+  // get or create PEGNode of rhs
+  if (stmt->Opnd(0)->GetOpCode() == OP_select) {
+    (void) BuildPEGNodeOfExpr(stmt->Opnd(0)->Opnd(0)); // build PEGNode in condition expr
+    const auto &rhsPtrValNodeA = BuildPEGNodeOfExpr(stmt->Opnd(0)->Opnd(1));
+    AddAssignEdge(stmt, lhsNode, rhsPtrValNodeA.pegNode, rhsPtrValNodeA.offset);
+
+    const auto &rhsPtrValNodeB = BuildPEGNodeOfExpr(stmt->Opnd(0)->Opnd(2));
+    AddAssignEdge(stmt, lhsNode, rhsPtrValNodeB.pegNode, rhsPtrValNodeB.offset);
+    return;
+  } else if (stmt->Opnd(0)->GetOpCode() == OP_constval &&
+             static_cast<ConstvalNode*>(stmt->Opnd(0))->GetConstVal()->IsZero()) {
+    return;
+  }
+  const auto &rhsPtrValNode = BuildPEGNodeOfExpr(stmt->Opnd(0));
+  AddAssignEdge(stmt, lhsNode, rhsPtrValNode.pegNode, rhsPtrValNode.offset);
+}
+
+void PEGBuilder::BuildPEGNodeInIassign(const IassignNode *iassign) {
+  const auto &baseAddrValNode = BuildPEGNodeOfExpr(iassign->IassignNode::Opnd(0));
+  const auto &rhsPtrNode = BuildPEGNodeOfExpr(iassign->Opnd(1));
+  if (baseAddrValNode.pegNode == nullptr) {
+    AddAssignEdge(iassign, nullptr, rhsPtrNode.pegNode, rhsPtrNode.offset);
+    return;
+  }
+
+  auto *vstOfBase = baseAddrValNode.pegNode->vst;
+  OriginalSt *defedOst = AliasClass::FindOrCreateExtraLevOst(
+      ssaTab, vstOfBase, iassign->GetTyIdx(), iassign->GetFieldID(), baseAddrValNode.offset);
+  CHECK_FATAL(defedOst, "defedOst is nullptr");
+  auto zeroVersionSt = ssaTab->GetVerSt(defedOst->GetZeroVersionIndex());
+  PEGNode *lhsNode = peg->GetOrCreateNodeOf(zeroVersionSt);
+
+  // build prevLev-nextLev relation
+  baseAddrValNode.pegNode->AddNextLevelNode(lhsNode);
+  lhsNode->SetPrevLevelNode(baseAddrValNode.pegNode);
+
+  AddAssignEdge(iassign, lhsNode, rhsPtrNode.pegNode, rhsPtrNode.offset);
+}
+
+void PEGBuilder::BuildPEGNodeInDirectCall(const CallNode *call) {
+  bool opndEscape = CallStmtOpndEscape(call);
+  if (!opndEscape) {
+    return;
+  }
+  for (uint32 opndId = 0; opndId < call->NumOpnds(); ++opndId) {
+    const auto &opndNode = BuildPEGNodeOfExpr(call->Opnd(opndId));
+    if (opndNode.pegNode != nullptr) {
+      opndNode.pegNode->attr[kAliasAttrEscaped] = true;
+    }
+  }
+}
+
+void PEGBuilder::BuildPEGNodeInIcall(const IcallNode *icall) {
+  (void)BuildPEGNodeOfExpr(icall->IcallNode::Opnd(0));
+  for (uint32 opndId = 1; opndId < icall->NumOpnds(); ++opndId) {
+    const auto &opndPtrNode = BuildPEGNodeOfExpr(icall->IcallNode::Opnd(opndId));
+    auto *pegNode = opndPtrNode.pegNode;
+    if (pegNode != nullptr) {
+      pegNode->attr[kAliasAttrEscaped] = true;
+    }
+  }
+}
+
+void PEGBuilder::BuildPEGNodeInVirtualcall(const NaryStmtNode *virtualCall) {
+  for (uint32 opndId = 0; opndId < virtualCall->NumOpnds(); ++opndId) {
+    const auto &opndPtrNode = BuildPEGNodeOfExpr(virtualCall->Opnd(opndId));
+    auto *pegNode = opndPtrNode.pegNode;
+    if (pegNode != nullptr) {
+      pegNode->attr[kAliasAttrEscaped] = true;
+    }
+  }
+}
+
+void PEGBuilder::BuildPEGNodeInIntrinsicCall(const IntrinsiccallNode *intrinsiccall) {
+  uint32 opndId = 0;
+  if (intrinsiccall->GetIntrinsic() == INTRN_JAVA_POLYMORPHIC_CALL) {
+    (void)BuildPEGNodeOfExpr(intrinsiccall->Opnd(opndId));
+    ++opndId;
+    for (; opndId < intrinsiccall->NumOpnds(); ++opndId) {
+      const auto &opndPtrNode = BuildPEGNodeOfExpr(intrinsiccall->Opnd(opndId));
+      auto *pegNode = opndPtrNode.pegNode;
+      if (pegNode != nullptr) {
+        pegNode->attr[kAliasAttrNextLevNotAllDefsSeen] = true;
+      }
+    }
+  } else if (intrinsiccall->GetIntrinsic() == INTRN_C_va_start) {
+    // opndId == 0, the first arg is set to points to formal
+    const auto &opndPtrNode = BuildPEGNodeOfExpr(intrinsiccall->Opnd(opndId));
+    opndPtrNode.pegNode->attr[kAliasAttrNextLevNotAllDefsSeen] = true;
+  }
+  for (; opndId < intrinsiccall->NumOpnds(); ++opndId) {
+    (void)BuildPEGNodeOfExpr(intrinsiccall->Opnd(opndId));
+  }
+}
+
+void PEGBuilder::BuildPEGNodeInStmt(const StmtNode *stmt) {
+  switch (stmt->GetOpCode()) {
+    case OP_maydassign:
+    case OP_regassign:
+    case OP_dassign: {
+      BuildPEGNodeInAssign(stmt);
+      return;
+    }
+    case OP_iassign: {
+      BuildPEGNodeInIassign(static_cast<const IassignNode*>(stmt));
+      return;
+    }
+    case OP_throw: {
+      auto *pegNode = BuildPEGNodeOfExpr(stmt->Opnd(0)).pegNode;
+      if (IsAddress(stmt->Opnd(0)->GetPrimType())) {
+        pegNode->attr[kAliasAttrEscaped] = true;
+      }
+      return;
+    }
+    case OP_call:
+    case OP_callassigned: {
+      BuildPEGNodeInDirectCall(static_cast<const CallNode *>(stmt));
+      break;
+    }
+    case OP_asm:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned: {
+      BuildPEGNodeInVirtualcall(static_cast<const NaryStmtNode *>(stmt));
+      break;
+    }
+    case OP_icall:
+    case OP_icallassigned:
+    case OP_icallproto:
+    case OP_icallprotoassigned: {
+      BuildPEGNodeInIcall(static_cast<const IcallNode *>(stmt));
+      break;
+    }
+    case OP_intrinsiccall:
+    case OP_intrinsiccallassigned: {
+      BuildPEGNodeInIntrinsicCall(static_cast<const IntrinsiccallNode*>(stmt));
+      break;
+    }
+    default:
+      for (uint32 opndId = 0; opndId < stmt->NumOpnds(); ++opndId) {
+        (void)BuildPEGNodeOfExpr(stmt->Opnd(opndId));
+      }
+      break;
+  }
+
+  if (kOpcodeInfo.IsCallAssigned(stmt->GetOpCode())) {
+    auto &mustDefNodes = ssaTab->GetStmtsSSAPart().SSAPartOf(*stmt)->GetMustDefNodes();
+    if (!mustDefNodes.empty()) {
+      auto *mustDefedVst = mustDefNodes.front().GetResult();
+      auto *mustDefedOst = mustDefedVst->GetOst();
+      auto *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(mustDefedOst->GetTyIdx());
+      if (IsAddress(mirType->GetPrimType())) {
+        auto *pegNode = peg->GetOrCreateNodeOf(mustDefedVst);
+        if (stmt->GetOpCode() == OP_callassigned) {
+          auto *callStmt = static_cast<const CallNode*>(stmt);
+          auto *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt->GetPUIdx());
+          if (mirFunc != nullptr && mirFunc->GetFuncDesc().IsReturnNoAlias()) {
+            return;
+          }
+        }
+        pegNode->attr[kAliasAttrNextLevNotAllDefsSeen] = true;
+      }
+    }
+  }
+}
+
+void PEGBuilder::BuildPEGNodeInPhi(const PhiNode &phi) {
+  auto *lhs = phi.GetResult();
+  auto *pegNodeLHS = peg->GetOrCreateNodeOf(lhs);
+  for (auto *opnd : phi.GetPhiOpnds()) {
+    auto *pegNodeOpnd = peg->GetOrCreateNodeOf(opnd);
+    peg->AddAssignEdge(pegNodeLHS, pegNodeOpnd, OffsetType(0));
+  }
+}
+
+void PropGlobalAndFormalAttr(PEGNode *node, AliasAttribute attr, int32 indirectLev, std::set<PEGNode*> &processed) {
+  if (node->attr[attr] || indirectLev > 0) {
+    return;
+  }
+
+  const auto &nodePair = processed.insert(node);
+  // insert failed, the node has been processed
+  if (!nodePair.second) {
+    return;
+  }
+
+  if (indirectLev == 0) {
+    node->attr[attr] = true;
+  }
+
+  for (const auto &assignToNode : node->assignTo) {
+    PropGlobalAndFormalAttr(assignToNode.pegNode, attr, indirectLev, processed);
+  }
+
+  auto prevLevNode = node->prevLevNode;
+  if (prevLevNode != nullptr) {
+    PropGlobalAndFormalAttr(prevLevNode, attr, indirectLev - 1, processed);
+  }
+
+  for (auto *nextLevNode : node->nextLevNodes) {
+    PropGlobalAndFormalAttr(nextLevNode, attr, indirectLev + 1, processed);
+  }
+}
+
+void PEGBuilder::UpdateAttributes() {
+  // multi-assign of ost results in uncertainty of value of the ost. For example:
+  // L1: int *ptr = array;
+  // L2: def/use *(ptr + 1) = 1;
+  // L3: ptr = array + 1;
+  // L4: use *ptr; <=== *ptr alias with L2: *(ptr+1)
+  for (auto &nodePtr : peg->GetAllNodes()) {
+    auto node = nodePtr.get();
+    if (node == nullptr) {
+      continue;
+    }
+    auto ostOfNode = node->vst->GetOst();
+    if (ostOfNode->GetIndirectLev() <= 0) {
+      if (ostOfNode->IsSymbolOst() && ostOfNode->GetMIRSymbol()->IsGlobal()) {
+        std::set<PEGNode*> processed;
+        PropGlobalAndFormalAttr(node, kAliasAttrGlobal, ostOfNode->GetIndirectLev(), processed);
+        continue;
+      }
+      if (ostOfNode->IsFormal()) {
+        std::set<PEGNode*> processed;
+        PropGlobalAndFormalAttr(node, kAliasAttrFormal, ostOfNode->GetIndirectLev(), processed);
+      }
+    }
+
+    if (ostOfNode->GetIndirectLev() > 0 || node->assignFrom.size() > 1 ||
+        (ostOfNode->IsFormal() && node->assignFrom.size() > 0) ||
+        (ostOfNode->IsSymbolOst() && ostOfNode->GetMIRSymbol()->IsStatic())) {
+      node->SetMultiDefined();
+    }
+  }
+
+  // update alias attributes
+  bool changed = true;
+  while (changed) {
+    changed = false;
+    for (auto &nodePtr : peg->GetAllNodes()) {
+      auto node = nodePtr.get();
+      if (node == nullptr) {
+        continue;
+      }
+      if (node->attr[kAliasAttrNotAllDefsSeen]) {
+        for (auto *nextLevNode : node->nextLevNodes) {
+          auto &attr = nextLevNode->attr;
+          if (!attr[kAliasAttrNotAllDefsSeen]) {
+            attr[kAliasAttrNotAllDefsSeen] = true;
+            changed = true;
+          }
+        }
+        for (const auto &assignFrom : node->assignFrom) {
+          auto &attr = assignFrom.pegNode->attr;
+          if (!attr[kAliasAttrEscaped]) {
+            attr[kAliasAttrEscaped] = true;
+            changed = true;
+          }
+        }
+        // update alias attribute of assign-to nodes
+        for (const auto &assignTo : node->assignTo) {
+          auto &attr = assignTo.pegNode->attr;
+          if (!attr[kAliasAttrNextLevNotAllDefsSeen]) {
+            attr[kAliasAttrNextLevNotAllDefsSeen] = true;
+            changed = true;
+          }
+        }
+        // AliasAttrNotAllDefsSeen is the most conservative attribute, we can stop to update other attr.
+        continue;
+      }
+
+      if (node->attr[kAliasAttrNextLevNotAllDefsSeen]) {
+        for (auto *nextLevNode : node->nextLevNodes) {
+          auto &attr = nextLevNode->attr;
+          if (!attr[kAliasAttrNotAllDefsSeen]) {
+            attr[kAliasAttrNotAllDefsSeen] = true;
+            changed = true;
+          }
+        }
+      }
+
+      if (node->attr[kAliasAttrGlobal]) {
+        for (auto *nextLevNode : node->nextLevNodes) {
+          auto &attr = nextLevNode->attr;
+          if (!attr[kAliasAttrNotAllDefsSeen]) {
+            attr[kAliasAttrNotAllDefsSeen] = true;
+            changed = true;
+          }
+        }
+      }
+
+      if (node->attr[kAliasAttrFormal]) {
+        for (auto *nextLevNode : node->nextLevNodes) {
+          auto &attr = nextLevNode->attr;
+          if (!attr[kAliasAttrNotAllDefsSeen]) {
+            attr[kAliasAttrNotAllDefsSeen] = true;
+            changed = true;
+          }
+        }
+      }
+
+      // update alias attribute of next-level nodes
+      if (node->attr[kAliasAttrEscaped]) {
+        for (auto *nextLevNode : node->nextLevNodes) {
+          auto &attr = nextLevNode->attr;
+          if (!attr[kAliasAttrNextLevNotAllDefsSeen]) {
+            attr[kAliasAttrNextLevNotAllDefsSeen] = true;
+            changed = true;
+          }
+        }
+        for (auto &assignFrom : node->assignFrom) {
+          auto &attr = assignFrom.pegNode->attr;
+          if (!attr[kAliasAttrEscaped]) {
+            attr[kAliasAttrEscaped] = true;
+            changed = true;
+          }
+        }
+      }
+
+      // update alias attribute of assign-to nodes
+      for (const auto &assignTo : node->assignTo) {
+        auto newAttr = assignTo.pegNode->attr | node->attr;
+        if (newAttr != assignTo.pegNode->attr) {
+          assignTo.pegNode->attr = newAttr;
+          changed = true;
+        }
+      }
+    }
+  }
+}
+
+void PEGBuilder::BuildPEG() {
+  for (const auto bb : func->GetCfg()->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+
+    auto &phiList = bb->GetPhiList();
+    for (auto &ost2phi : phiList) {
+      BuildPEGNodeInPhi(ost2phi.second);
+    }
+
+    if (bb->IsEmpty()) {
+      continue;
+    }
+    for (const auto &stmt : bb->GetStmtNodes()) {
+      BuildPEGNodeInStmt(&stmt);
+    }
+  }
+  UpdateAttributes();
+}
+
+MapleSet<ReachItem*, ReachItemComparator> *DemandDrivenAliasAnalysis::ReachSetOf(PEGNode *node) {
+  auto *reachSet = reachNodes[node];
+  if (reachSet == nullptr) {
+    reachSet = tmpMP->New<MapleSet<ReachItem*, ReachItemComparator>>(tmpAlloc.Adapter());
+    reachNodes[node] = reachSet;
+    return reachSet;
+  }
+  return reachSet;
+}
+
+std::pair<bool, ReachItem*> DemandDrivenAliasAnalysis::AddReachNode(PEGNode *to, PEGNode *src,
+                                                                    ReachState state, OffsetType offset) {
+  auto *reachSet = ReachSetOf(to);
+  auto reachItem = tmpMP->New<ReachItem>(src, state, offset);
+  const auto &insertedReachItemPair = reachSet->insert(reachItem);
+  auto it = insertedReachItemPair.first;
+  if (!insertedReachItemPair.second && (*it)->offset != offset) {
+    (*it)->offset.Set(kOffsetUnknown);
+  }
+  return {insertedReachItemPair.second, *it};
+}
+
+void DemandDrivenAliasAnalysis::Propagate(WorkListType &workList, PEGNode *to, const ReachItem &reachItem,
+                                          bool selfProp) {
+  if (to == nullptr || reachItem.src == nullptr) {
+    return;
+  }
+  if (to == reachItem.src && !selfProp) {
+    return;
+  }
+  const auto &newNode = AddReachNode(to, reachItem.src, reachItem.state, reachItem.offset);
+  const auto &offset = newNode.second->offset;
+  if (newNode.first) {
+    (void)workList.emplace_back(WorkListItem(to, reachItem.src, reachItem.state, offset));
+    to->CopyAttrFromValueAliasedNode(reachItem.src);
+    if (enableDebug) {
+      LogInfo::MapleLogger() << "===New candidate: ";
+      reachItem.src->vst->Dump();
+      LogInfo::MapleLogger() << " + " << offset.val << " => ";
+      to->vst->Dump();
+      LogInfo::MapleLogger() << std::endl << std::endl;
+    }
+  }
+}
+
+MapleSet<OriginalSt*> *DemandDrivenAliasAnalysis::AliasSetOf(OriginalSt *ost) {
+  auto it = aliasSets.find(ost);
+  if (it->second == nullptr || it == aliasSets.end()) {
+    auto *aliasSet = tmpMP->New<MapleSet<OriginalSt*>>(tmpAlloc.Adapter());
+    aliasSets[ost] = aliasSet;
+    return aliasSet;
+  }
+  return it->second;
+}
+
+bool DemandDrivenAliasAnalysis::AliasBasedOnAliasAttr(PEGNode *to, PEGNode *src) const {
+  if (to->attr[kAliasAttrNotAllDefsSeen]) {
+    if (src->attr[kAliasAttrNotAllDefsSeen]) {
+      return true;
+    }
+    if (src->attr[kAliasAttrGlobal]) {
+      return true;
+    }
+    auto *prevLevNodeOfSrc = GetPrevLevPEGNode(src);
+    if (prevLevNodeOfSrc != nullptr && prevLevNodeOfSrc->attr[kAliasAttrEscaped]) {
+      return true;
+    }
+  }
+
+  if (to->attr[kAliasAttrGlobal]) {
+    if (src->attr[kAliasAttrNotAllDefsSeen]) {
+      return true;
+    }
+  }
+
+  auto *prevLevNodeOfTo = GetPrevLevPEGNode(to);
+  if (prevLevNodeOfTo != nullptr && prevLevNodeOfTo->attr[kAliasAttrEscaped]) {
+    if (src->attr[kAliasAttrNotAllDefsSeen]) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+inline static bool MemOverlapAccordingOffset(OffsetType startA, OffsetType endA, OffsetType startB, OffsetType endB) {
+  if (startA == startB) {
+    return true;
+  }
+  if (startA.IsInvalid() || endA.IsInvalid() || startB.IsInvalid() || endB.IsInvalid()) {
+    return true;
+  }
+  return startA < endB && startB < endA;
+}
+
+inline static OffsetType OffsetFromPrevLevNode(const PEGNode *pegNode) {
+  return pegNode->vst->GetOst()->GetOffset();
+}
+
+void DemandDrivenAliasAnalysis::UpdateAliasInfoOfPegNode(PEGNode *pegNode) {
+  WorkListType workList{WorkListItem(pegNode, pegNode, S1, OffsetType(0))};
+
+  while (!workList.empty()) {
+    const auto &item = workList.front();
+    auto *toNode = item.to;
+    auto *srcNode = item.srcItem.src;
+    auto state = item.srcItem.state;
+    auto offset = item.srcItem.offset;
+    workList.pop_front();
+    if (srcNode->multiDefed || toNode->multiDefed) {
+      offset = OffsetType::InvalidOffset();
+    }
+
+    // toNode->ost value alias with srcNode->ost, the nextLevOsts may memory alias with each other
+    for (auto *nextLevNodeOfTo : toNode->nextLevNodes) {
+      constexpr int kBitNumInOneByte = 8;
+      auto *nextLevOstOfTo = nextLevNodeOfTo->vst->GetOst();
+      OffsetType offsetStartA = OffsetFromPrevLevNode(nextLevNodeOfTo) + offset;
+      OffsetType offsetEndA = static_cast<OffsetType>(offsetStartA +
+          nextLevOstOfTo->GetType()->GetSize() * kBitNumInOneByte);
+      for (auto *nextLevNodeOfSrc : srcNode->nextLevNodes) {
+        auto *nextLevOstOfSrc = nextLevNodeOfSrc->vst->GetOst();
+        OffsetType offsetStartB = OffsetFromPrevLevNode(nextLevNodeOfSrc);
+        OffsetType offsetEndB = static_cast<OffsetType>(offsetStartB +
+            nextLevOstOfSrc->GetType()->GetSize() * kBitNumInOneByte);
+        if (MemOverlapAccordingOffset(offsetStartA, offsetEndA, offsetStartB, offsetEndB)) {
+          AddAlias(nextLevOstOfTo, nextLevOstOfSrc);
+          for (const auto &reachItem : *ReachSetOf(nextLevNodeOfSrc)) {
+            switch (reachItem->state) {
+              case S1: {
+                Propagate(workList, nextLevNodeOfTo, {reachItem->src, S2, reachItem->offset});
+                break;
+              }
+              case S3: {
+                Propagate(workList, nextLevNodeOfTo, {reachItem->src, S4, reachItem->offset});
+                break;
+              }
+              default:
+                break;
+            }
+          }
+        }
+      }
+    }
+
+    switch (state) {
+      case S1: {
+        for (const auto &readNode : toNode->assignFrom) {
+          Propagate(workList, readNode.pegNode, {srcNode, S1, offset + readNode.offset});
+        }
+        for (auto *aliasOst : *AliasSetOf(toNode->vst->GetOst())) {
+          auto *aliasNode = peg.GetNodeOf(aliasOst);
+          Propagate(workList, aliasNode, {srcNode, S2, offset});
+        }
+        for (const auto &writeNode : toNode->assignTo) {
+          Propagate(workList, writeNode.pegNode, {srcNode, S3, writeNode.offset + (-offset)});
+        }
+        break;
+      }
+      case S2: {
+        for (const auto &readNode : toNode->assignFrom) {
+          Propagate(workList, readNode.pegNode, {srcNode, S1, offset +  readNode.offset});
+        }
+        for (const auto &writeNode : toNode->assignTo) {
+          Propagate(workList, writeNode.pegNode, {srcNode, S3, writeNode.offset + (-offset)});
+        }
+        break;
+      }
+      case S3: {
+        for (const auto &writeNode : toNode->assignTo) {
+          Propagate(workList, writeNode.pegNode, {srcNode, S3, writeNode.offset + offset});
+        }
+        for (auto *aliasOst : *AliasSetOf(toNode->vst->GetOst())) {
+          auto *aliasNode = peg.GetNodeOf(aliasOst);
+          Propagate(workList, aliasNode, {srcNode, S4, offset});
+        }
+        break;
+      }
+      case S4: {
+        for (const auto &writeNode : toNode->assignTo) {
+          Propagate(workList, writeNode.pegNode, {srcNode, S3, writeNode.offset + offset});
+        }
+        break;
+      }
+      default: {
+        CHECK_FATAL(false, "Not supported state");
+        break;
+      }
+    }
+
+    // propagate downward
+    if (state != S1 && state != S3) {
+      continue;
+    }
+    auto pegNodeOfPrevLevOst = toNode->prevLevNode;
+    if (pegNodeOfPrevLevOst != nullptr) {
+      Propagate(workList, pegNodeOfPrevLevOst, {pegNodeOfPrevLevOst, S1, OffsetType(0)}, true);
+    }
+  }
+}
+
+bool DemandDrivenAliasAnalysis::MayAlias(PEGNode *to, PEGNode *src) {
+  if (to == src) {
+    return true;
+  }
+  auto *ostOfTo = to->vst->GetOst();
+  auto *ostOfSrc = src->vst->GetOst();
+  // alias based on AliasAttr
+  auto *nodeOfPrevLevOfTo = to->prevLevNode;
+  auto *nodeOfPrevLevOfSrc = src->prevLevNode;
+  if (nodeOfPrevLevOfTo != nodeOfPrevLevOfSrc || nodeOfPrevLevOfTo->multiDefed) {
+    if (AliasBasedOnAliasAttr(to, src)) {
+      AddAlias(ostOfTo, ostOfSrc);
+      return true;
+    }
+  }
+
+  if (nodeOfPrevLevOfTo == nullptr || nodeOfPrevLevOfSrc == nullptr) {
+    return false;
+  }
+
+  if (nodeOfPrevLevOfTo->processed || nodeOfPrevLevOfSrc->processed) {
+    auto *aliasSetOfToOst = AliasSetOf(ostOfTo);
+    return (aliasSetOfToOst->find(ostOfSrc) != aliasSetOfToOst->end());
+  }
+
+  UpdateAliasInfoOfPegNode(nodeOfPrevLevOfTo);
+  nodeOfPrevLevOfTo->processed = true;
+
+  auto *aliasSetOfToOst = AliasSetOf(ostOfTo);
+  if (aliasSetOfToOst->find(ostOfSrc) != aliasSetOfToOst->end()) {
+    return true;
+  }
+
+  if (nodeOfPrevLevOfTo != nodeOfPrevLevOfSrc) {
+    bool aliasAccordingAttr = AliasBasedOnAliasAttr(to, src);
+    if (aliasAccordingAttr) {
+      AddAlias(ostOfTo, ostOfSrc);
+    }
+    return aliasAccordingAttr;
+  }
+  return false;
+}
+
+bool DemandDrivenAliasAnalysis::MayAlias(OriginalSt *ostA, OriginalSt *ostB) {
+  auto *aliasSet = AliasSetOf(ostA);
+  if (aliasSet->find(ostB) != aliasSet->end()) {
+    if (enableDebug) {
+      LogInfo::MapleLogger() << "a) Demand Driven Alias Aanlysis: ";
+      ostA->Dump();
+      LogInfo::MapleLogger() << " ostIdx(" << ostA->GetIndex() << ") and ";
+      ostB->Dump();
+      LogInfo::MapleLogger() << " ostIdx(" << ostB->GetIndex() << ")";
+      LogInfo::MapleLogger() << " alias." << std::endl;
+    }
+    return true;
+  }
+
+  bool mayAliasAccordingBasicAA = AliasClass::MayAliasBasicAA(ostA, ostB);
+  if (!mayAliasAccordingBasicAA) {
+    return false;
+  }
+  if (ostA->GetIndirectLev() <= 0 && ostB->GetIndirectLev() <= 0) {
+    return mayAliasAccordingBasicAA;
+  }
+
+  auto *to = peg.GetNodeOf(ostA);
+  auto *src = peg.GetNodeOf(ostB);
+  if (to == nullptr || src == nullptr) {
+    if (enableDebug) {
+      LogInfo::MapleLogger() << "b) Demand Driven Alias Aanlysis: ";
+      ostA->Dump();
+      LogInfo::MapleLogger() << " ostIdx(" << ostA->GetIndex() << ") and ";
+      ostB->Dump();
+      LogInfo::MapleLogger() << " ostIdx(" << ostB->GetIndex() << ")";
+      LogInfo::MapleLogger() << " alias." << std::endl;
+    }
+    return true;
+  }
+
+  bool aliasAccordingDDAA = MayAlias(to, src);
+  if (enableDebug) {
+    LogInfo::MapleLogger() << "c) Demand Driven Alias Aanlysis: ";
+    ostA->Dump();
+    LogInfo::MapleLogger() << " ostIdx(" << ostA->GetIndex() << ") and ";
+    ostB->Dump();
+    LogInfo::MapleLogger() << " ostIdx(" << ostB->GetIndex() << ")";
+    if (!aliasAccordingDDAA) {
+      LogInfo::MapleLogger() << " not ";
+    }
+    LogInfo::MapleLogger() << " alias." << std::endl;
+  }
+  return aliasAccordingDDAA;
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/dse.cpp b/src/mapleall/maple_me/src/dse.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9168dee6a11171935214d0aa145d26c7aa83c92a
--- /dev/null
+++ b/src/mapleall/maple_me/src/dse.cpp
@@ -0,0 +1,593 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "dse.h"
+#include "ssa_mir_nodes.h"
+#include "ver_symbol.h"
+#include "ssa.h"
+#include "opcode_info.h"
+#include "mir_function.h"
+#include "utils.h"
+#include "mir_builder.h"
+
+// This phase do dead store elimination. This optimization is done on SSA
+// version basis.
+// This optimization consider all stmt are not needed at first. The whole
+// algorithm is as follow:
+// 1. mark all stmt are not needed. init an empty worklist to put live node.
+// 2. mark some special stmts which has side effect as needed, such as
+//    return/eh/call and some assigned stmts who have volatile fileds and so on.
+//    Put all operands and mayUse nodes of the needed stmt into worklist.
+// 3. For the nodes in worklist mark the def stmt as needed just as step 2 and
+//    pop the node from the worklist.
+// 4. Repeat step 3 until the worklist is empty.
+namespace maple {
+using namespace utils;
+
+bool DSE::ExprHasSideEffect(const BaseNode &expr) const {
+  Opcode op = expr.GetOpCode();
+  // in c language, OP_array and OP_div has no side-effect
+  if (ssaTab.GetModule().IsCModule() && (op == OP_array || op == OP_div)) {
+    return false;
+  }
+  if (kOpcodeInfo.HasSideEffect(op)) {
+    return true;
+  }
+  // may throw exception
+  if (op == OP_gcmallocjarray || op == OP_gcpermallocjarray) {
+    return true;
+  }
+  // create a instance of interface
+  if (op == OP_gcmalloc || op == OP_gcpermalloc) {
+    auto &gcMallocNode = static_cast<const GCMallocNode&>(expr);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(gcMallocNode.GetTyIdx());
+    return type->GetKind() == kTypeInterface;
+  }
+  return false;
+}
+
+bool DSE::ExprNonDeletable(const BaseNode &expr) const {
+  if (ExprHasSideEffect(expr)) {
+    return true;
+  }
+  switch (expr.GetOpCode()) {
+    case OP_dread: {
+      auto &dread = static_cast<const AddrofSSANode&>(expr);
+      const MIRSymbol &sym = dread.GetMIRSymbol();
+      return sym.IsVolatile() || sym.IsTypeVolatile(dread.GetFieldID()) || (decoupleStatic && sym.IsGlobal());
+    }
+    case OP_iread: {
+      auto &iread = static_cast<const IreadSSANode&>(expr);
+      auto &ty = static_cast<const MIRPtrType&>(GetTypeFromTyIdx(iread.GetTyIdx()));
+      return ty.IsPointedTypeVolatile(iread.GetFieldID()) || ExprNonDeletable(ToRef(iread.Opnd(0)));
+    }
+    case OP_regread: {
+      auto &regreadNode = static_cast<const RegreadSSANode&>(expr);
+      return (regreadNode.GetRegIdx() == -kSregThrownval);
+    }
+    case OP_intrinsicop: {
+      auto &node = static_cast<const IntrinsicopNode&>(expr);
+      const IntrinDesc &intrinDesc = node.GetIntrinDesc();
+      return (!intrinDesc.HasNoSideEffect());
+    }
+    default: {
+      break;
+    }
+  }
+  for (size_t i = 0; i < expr.NumOpnds(); ++i) {
+    if (ExprNonDeletable(ToRef(expr.Opnd(i)))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool DSE::HasNonDeletableExpr(const StmtNode &stmt) const {
+  Opcode op = stmt.GetOpCode();
+
+  switch (op) {
+    case OP_dassign: {
+      auto &node = static_cast<const DassignNode&>(stmt);
+      const MIRSymbol &sym = ssaTab.GetStmtMIRSymbol(stmt);
+      bool isInjectIV = false;
+      if (isLfo) {
+        // check identify assignments
+        if (strncmp(sym.GetName().c_str(), "injected.iv", 11) == 0) {
+          isInjectIV = true;
+        } else if (node.Opnd()->GetOpCode() == OP_dread) {
+          auto *dread = static_cast<AddrofSSANode *>(node.Opnd());
+          if (node.GetStIdx() == dread->GetStIdx() && node.GetFieldID() == dread->GetFieldID()) {
+            isInjectIV = true;
+          }
+        }
+      }
+      return (sym.IsVolatile() || sym.IsTypeVolatile(node.GetFieldID()) ||
+              ExprNonDeletable(ToRef(node.GetRHS())) || isInjectIV);
+    }
+    case OP_regassign: {
+      if (isLfo) {
+        auto &rass = static_cast<const RegassignNode&>(stmt);
+        if (rass.Opnd()->GetOpCode() == OP_regread) {
+          RegreadNode *regread = static_cast<RegreadNode *>(rass.Opnd());
+          if (rass.GetRegIdx() == regread->GetRegIdx()) {
+            return true;
+          }
+        }
+      }
+      return ExprNonDeletable(ToRef(stmt.Opnd(0)));
+    }
+    // possible to throw exception
+    case OP_maydassign: {
+      return true;
+    }
+    case OP_iassign: {
+      auto *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+      auto &mayDefList = ssaPart->GetMayDefNodes();
+      for (auto &mayDefPair : std::as_const(mayDefList)) {
+        if (mayDefPair.second.GetResult()->GetOst()->IsVolatile()) {
+          return true;
+        }
+      }
+      auto &node = static_cast<const IassignNode&>(stmt);
+      auto &ty = static_cast<const MIRPtrType&>(GetTypeFromTyIdx(node.GetTyIdx()));
+      return (ty.IsPointedTypeVolatile(node.GetFieldID()) ||
+              ExprNonDeletable(ToRef(node.Opnd(0))) ||
+              ExprNonDeletable(ToRef(node.GetRHS())));
+    }
+    case OP_intrinsiccall: {
+      auto *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+      auto &mayDefList = ssaPart->GetMayDefNodes();
+      for (auto &mayDefPair: mayDefList) {
+        if (mayDefPair.second.GetResult()->GetOst()->IsVolatile()) {
+          return true;
+        }
+      }
+      bool opndNonDeletable = false;
+      for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+        opndNonDeletable |= ExprNonDeletable(ToRef(stmt.Opnd(i)));
+      }
+      return opndNonDeletable;
+    }
+    default:
+      return false;
+  }
+}
+
+bool DSE::StmtMustRequired(const StmtNode &stmt, const BB &bb) const {
+  Opcode op = stmt.GetOpCode();
+  // special opcode stmt cannot be eliminated
+  if (IsStmtMustRequire(op)) {
+    return true;
+  }
+  // atomic intrinsic call cannot be eliminated
+  if (op == OP_intrinsiccall) {
+    IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[static_cast<const IntrinsiccallNode &>(stmt).GetIntrinsic()];
+    if (intrinDesc->IsAtomic()) {
+      return true;
+    }
+  }
+
+  // control flow in an infinite loop cannot be eliminated
+  if (ControlFlowInInfiniteLoop(bb, op)) {
+    return true;
+  }
+
+  return HasNonDeletableExpr(stmt);
+}
+
+void DSE::DumpStmt(const StmtNode &stmt, const std::string &msg) const {
+  if (enableDebug) {
+    LogInfo::MapleLogger() << msg;
+    stmt.Dump();
+  }
+}
+
+bool DSE::IsCallReturnRemovable(const StmtNode &stmt) {
+  if (!kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
+    return false;
+  }
+  if (stmt.GetOpCode() == OP_asm) {
+    return false;
+  }
+  if (stmt.GetOpCode() == OP_intrinsiccallassigned) {
+    auto intrinsicID = static_cast<const IntrinsiccallNode&>(stmt).GetIntrinsic();
+    return !IntrinDesc::intrinTable[intrinsicID].IsAtomic();
+  }
+  return true;
+}
+
+void DSE::CheckRemoveCallAssignedReturn(StmtNode &stmt) {
+  if (!IsCallReturnRemovable(stmt)) {
+    return;
+  }
+  MapleVector<MustDefNode> &mustDefs = ssaTab.GetStmtMustDefNodes(stmt);
+  for (auto &node : mustDefs) {
+    if (IsSymbolLived(ToRef(node.GetResult()))) {
+      continue;
+    }
+    DumpStmt(stmt, "**** DSE1 deleting return value assignment in: ");
+    CallReturnVector *rets = stmt.GetCallReturnVector();
+    CHECK_FATAL(rets != nullptr, "null ptr check");
+    rets->clear();
+    mustDefs.clear();
+    break;
+  }
+}
+
+void DSE::OnRemoveBranchStmt(BB &bb, const StmtNode &stmt) {
+  if (stmt.GetOpCode() == OP_switch) {
+    // update CFG
+    while (bb.GetSucc().size() != 1) {
+      BB *succ = bb.GetSucc().back();
+      succ->RemovePred(bb);
+    }
+    bb.SetKind(kBBFallthru);
+    if (Options::profileUse && !bb.GetSuccFreq().empty()) {
+      int64_t succ0Freq = bb.GetSuccFreq()[0];
+      bb.GetSuccFreq().resize(1);
+      bb.SetSuccFreq(0, bb.GetFrequency());
+      ASSERT(bb.GetFrequency() >= succ0Freq, "sanity check");
+      bb.GetSucc(0)->SetFrequency(bb.GetSucc(0)->GetFrequency() + (bb.GetFrequency() - succ0Freq));
+    }
+    cfgUpdated = true;
+    return;
+  }
+  if (IsBranch(stmt.GetOpCode())) {
+    // update BB pred/succ
+    bb.SetKind(kBBFallthru);
+    cfgUpdated = true;  // tag cfg is changed
+    LabelIdx labelIdx = (stmt.GetOpCode() == OP_goto) ? static_cast<const GotoNode&>(stmt).GetOffset()
+                                                      : static_cast<const CondGotoNode&>(stmt).GetOffset();
+    for (size_t i = 0; i < bb.GetSucc().size(); ++i) {
+      if (bb.GetSucc(i)->GetBBLabel() == labelIdx) {
+        BB *succBB = bb.GetSucc(i);
+        bb.RemoveSucc(*succBB);
+        break;
+      }
+    }
+    // merge all frequency of condition goto bb to fallthru succ
+    if (Options::profileUse && !bb.GetSuccFreq().empty()) {
+      int64_t succ0Freq = bb.GetSuccFreq()[0];
+      bb.GetSuccFreq().resize(1);
+      bb.SetSuccFreq(0, bb.GetFrequency());
+      ASSERT(bb.GetFrequency() >= succ0Freq, "sanity check");
+      bb.GetSucc(0)->SetFrequency(bb.GetSucc(0)->GetFrequency() + (bb.GetFrequency() - succ0Freq));
+    }
+  }
+}
+
+void DSE::RemoveNotRequiredStmtsInBB(BB &bb) {
+  for (auto &stmt : bb.GetStmtNodes()) {
+    if (!IsStmtRequired(stmt)) {
+      DumpStmt(stmt, "**** DSE1 deleting: ");
+      OnRemoveBranchStmt(bb, stmt);
+      // A iread node contained in stmt or iass stmt
+      if (stmt2NotNullExpr.find(&stmt) != stmt2NotNullExpr.end()) {
+        for (BaseNode *node : stmt2NotNullExpr.at(&stmt)) {
+          if (NeedNotNullCheck(*node, bb)) {
+            MIRModule &mod = ssaTab.GetModule();
+            UnaryStmtNode *nullCheck = mod.GetMIRBuilder()->CreateStmtUnary(OP_assertnonnull, node);
+            bb.InsertStmtBefore(&stmt, nullCheck);
+            nullCheck->SetIsLive(true);
+            notNullExpr2Stmt[node].push_back(std::make_pair(nullCheck, &bb));
+          }
+        }
+      }
+      if (&stmt == &bb.GetLast()) {
+        bb.SetKind(kBBFallthru);
+      }
+      bb.RemoveStmtNode(&stmt);
+      continue;
+    }
+
+    CheckRemoveCallAssignedReturn(stmt);
+  }
+}
+
+// If a ivar's base not used as not null, should insert a not null stmt
+// Only make sure throw NPE in same BB
+// If must make sure throw at first stmt, much more not null stmt will be inserted
+bool DSE::NeedNotNullCheck(BaseNode &node, const BB &bb) {
+  if (theMIRModule->IsCModule()) {
+    return false;
+  }
+  if (node.GetOpCode() == OP_addrof) {
+    return false;
+  }
+  if (node.GetOpCode() == OP_iaddrof && static_cast<IreadNode &>(node).GetFieldID() > 0) {
+    return false;
+  }
+
+  for (auto item : notNullExpr2Stmt[&node]) {
+    if (!IsStmtRequired(*(item.first))) {
+      continue;
+    }
+    if (dom.Dominate(*(item.second), bb)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void DSE::PropagateUseLive(const VersionSt &vst) {
+  if (IsSymbolLived(vst)) {
+    return;
+  }
+  SetSymbolLived(vst);
+  const BB *dfBB = vst.GetDefBB();
+  if (dfBB == nullptr) {
+    return;
+  }
+  if (vst.GetDefType() == VersionSt::kAssign) {
+    const StmtNode *assign = vst.GetAssignNode();
+    MarkStmtRequired(ToRef(assign), ToRef(dfBB));
+  } else if (vst.GetDefType() == VersionSt::kPhi) {
+    PhiNode *phi = vst.GetPhi();
+    ASSERT(phi->GetResult() == &vst, "MarkVst: wrong corresponding version st in phi");
+    MarkControlDependenceLive(ToRef(dfBB));
+    for (size_t i = 0; i < phi->GetPhiOpnds().size(); ++i) {
+      const VersionSt *verSt = phi->GetPhiOpnds()[i];
+      AddToWorkList(verSt);
+    }
+    phi->SetIsLive(true);
+  } else if (vst.GetDefType() == VersionSt::kMayDef) {
+    const MayDefNode *mayDef = vst.GetMayDef();
+    ASSERT(mayDef->GetResult() == &vst, "MarkVst: wrong corresponding version st in maydef");
+    const VersionSt *verSt = mayDef->GetOpnd();
+
+    auto defStmt = mayDef->GetStmt();
+    if (kOpcodeInfo.IsCallAssigned(defStmt->GetOpCode())) {
+      MapleVector<MustDefNode> &mustDefs = ssaTab.GetStmtMustDefNodes(*defStmt);
+      for (auto &node : mustDefs) {
+        if (aliasInfo->MayAlias(node.GetResult()->GetOst(), vst.GetOst())) {
+          AddToWorkList(node.GetResult());
+        }
+      }
+    }
+
+    MarkStmtRequired(ToRef(defStmt), ToRef(dfBB));
+    AddToWorkList(verSt);
+  } else {
+    const MustDefNode *mustDef = vst.GetMustDef();
+    ASSERT(mustDef->GetResult() == &vst, "MarkVst: wrong corresponding version st in mustDef");
+    MarkStmtRequired(ToRef(mustDef->GetStmt()), ToRef(dfBB));
+  }
+}
+
+void DSE::MarkLastBranchStmtInPredBBRequired(const BB &bb) {
+  for (auto predIt = bb.GetPred().begin(); predIt != bb.GetPred().end(); ++predIt) {
+    const BB *predBB = *predIt;
+    CHECK_NULL_FATAL(predBB);
+    if (predBB == &bb || predBB->IsEmpty()) {
+      continue;
+    }
+    const StmtNode &lastStmt = predBB->GetLast();
+    if (IsBranch(lastStmt.GetOpCode())) {
+      MarkStmtRequired(lastStmt, ToRef(predBB));
+    }
+  }
+}
+
+void DSE::MarkLastBranchStmtInPDomBBRequired(const BB &bb) {
+  ASSERT(bb.GetBBId() < postDom.GetDomFrontierSize(), "index out of range in DSE::MarkBBLive ");
+  for (auto pdomBBID : postDom.GetDomFrontier(bb.GetID())) {
+    const BB *cdBB = bbVec[pdomBBID];
+    CHECK_FATAL(cdBB != nullptr, "cd_bb is null in DSE::MarkLastBranchStmtInPDomBBRequired");
+    if (cdBB == &bb || cdBB->IsEmpty()) {
+      continue;
+    }
+
+    const StmtNode &lastStmt = cdBB->GetLast();
+    Opcode op = lastStmt.GetOpCode();
+    if (IsBranch(op)) {
+      MarkStmtRequired(lastStmt, ToRef(cdBB));
+    }
+  }
+}
+
+void DSE::MarkLastBranchStmtInBBRequired(const BB &bb) {
+  if (!bb.IsEmpty()) {
+    // if bb's last stmt is a branch instruction, it is also needed
+    const StmtNode &lastStmt = bb.GetLast();
+    if (IsBranch(lastStmt.GetOpCode())) {
+      MarkStmtRequired(lastStmt, bb);
+    }
+  }
+}
+
+void DSE::MarkControlDependenceLive(const BB &bb) {
+  if (bbRequired[bb.GetBBId()]) {
+    return;
+  }
+  bbRequired[bb.GetBBId()] = true;
+
+  MarkLastBranchStmtInBBRequired(bb);
+  MarkLastBranchStmtInPDomBBRequired(bb);
+  MarkLastBranchStmtInPredBBRequired(bb);
+}
+
+void DSE::MarkSingleUseLive(const BaseNode &mirNode) {
+  Opcode op = mirNode.GetOpCode();
+  switch (op) {
+    case OP_dread: {
+      auto &addrofSSANode = static_cast<const AddrofSSANode&>(mirNode);
+      const VersionSt *verSt = addrofSSANode.GetSSAVar();
+      AddToWorkList(verSt);
+      break;
+    }
+    case OP_regread: {
+      auto &regreadSSANode = static_cast<const RegreadSSANode&>(mirNode);
+      const VersionSt *verSt = regreadSSANode.GetSSAVar();
+      AddToWorkList(verSt);
+      break;
+    }
+    case OP_iread: {
+      auto &ireadSSANode = static_cast<const IreadSSANode&>(mirNode);
+      const VersionSt *verSt = ireadSSANode.GetSSAVar();
+      CHECK_FATAL(verSt != nullptr, "DSE::MarkSingleUseLive: iread has no mayUse opnd");
+      AddToWorkList(verSt);
+      MarkSingleUseLive(ToRef(mirNode.Opnd(0)));
+      break;
+    }
+    default: {
+      for (size_t i = 0; i < mirNode.NumOpnds(); ++i) {
+        MarkSingleUseLive(ToRef(mirNode.Opnd(i)));
+      }
+      break;
+    }
+  }
+}
+
+void DSE::MarkStmtUseLive(const StmtNode &stmt) {
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+    MarkSingleUseLive(ToRef(stmt.Opnd(i)));
+  }
+
+  if (kOpcodeInfo.HasSSAUse(stmt.GetOpCode())) {
+    for (auto &mayUseItem : ssaTab.GetStmtMayUseNodes(stmt)) {
+      AddToWorkList(mayUseItem.second.GetOpnd());
+    }
+  }
+}
+
+void DSE::MarkStmtRequired(const StmtNode &stmt, const BB &bb) {
+  if (IsStmtRequired(stmt)) {
+    return;
+  }
+  SetStmtRequired(stmt);
+
+  // save only one line comment
+  StmtNode *prev = stmt.GetPrev();
+  if (prev != nullptr && prev->GetOpCode() == OP_comment) {
+    SetStmtRequired(*prev);
+  }
+
+  MarkStmtUseLive(stmt);
+
+  MarkControlDependenceLive(bb);
+}
+
+void DSE::MarkSpecialStmtRequired() {
+  for (auto bIt = bbVec.crbegin(); bIt != bbVec.crend(); ++bIt) {
+    auto *bb = *bIt;
+    if (bb == nullptr) {
+      continue;
+    }
+    for (auto itStmt = bb->GetStmtNodes().rbegin(); itStmt != bb->GetStmtNodes().rend(); ++itStmt) {
+      StmtNode &stmt = *itStmt;
+      if (StmtMustRequired(stmt, *bb)) {
+        MarkStmtRequired(stmt, *bb);
+        CollectNotNullNode(stmt, *bb);
+      }
+    }
+  }
+}
+
+// Find all stmt contains ivar and save to stmt2NotNullExpr
+// Find all not null expr used as ivar's base、OP_array's or OP_assertnonnull's opnd
+// And save to notNullExpr2Stmt
+void DSE::CollectNotNullNode(StmtNode &stmt, BB &bb) {
+  uint8 opndNum = static_cast<uint8>(stmt.NumOpnds());
+  uint8 nodeType = kNodeTypeNormal;
+  for (uint8 i = 0; i < opndNum; ++i) {
+    BaseNode *opnd = stmt.Opnd(i);
+    if (i == 0 && instance_of<CallNode>(stmt)) {
+      // A non-static call's first opnd is this, should be not null
+      CallNode &call = static_cast<CallNode&>(stmt);
+      if (!GlobalTables::GetFunctionTable().GetFunctionFromPuidx(call.GetPUIdx())->IsStatic()) {
+        nodeType = kNodeTypeNotNull;
+      }
+    } else if (i == 0 && stmt.GetOpCode() == OP_iassign) {
+      // A iass stmt, mark and save
+      BaseNode &base = *static_cast<IassignNode&>(stmt).Opnd(0);
+      stmt2NotNullExpr[&stmt].push_back(&base);
+      MarkSingleUseLive(base);
+      notNullExpr2Stmt[&base].push_back(std::make_pair(&stmt, &bb));
+      nodeType = kNodeTypeIvar;
+    } else {
+      // A normal opnd not sure
+      Opcode opndOp = opnd->GetOpCode();
+      if (opndOp == OP_dread || opndOp == OP_regread) {
+        continue;
+      }
+      nodeType = kNodeTypeNormal;
+    }
+    CollectNotNullNode(stmt, ToRef(opnd), bb, nodeType);
+  }
+}
+
+void DSE::CollectNotNullNode(StmtNode &stmt, BaseNode &node, BB &bb, uint8 nodeType) {
+  Opcode op = node.GetOpCode();
+  switch (op) {
+    case OP_dread:
+    case OP_regread:
+    case OP_constval: {
+      // Ref expr used in ivar、array or assertnotnull
+      PrimType type = node.GetPrimType();
+      if (nodeType != kNodeTypeNormal && (type == PTY_ref || type == PTY_ptr)) {
+        notNullExpr2Stmt[&node].push_back(std::make_pair(&stmt, &bb));
+      }
+      break;
+    }
+    case OP_iread: {
+      BaseNode &base = *static_cast<IreadNode&>(node).Opnd(0);
+      if (nodeType != kNodeTypeIvar) {
+        stmt2NotNullExpr[&stmt].push_back(&base);
+        MarkSingleUseLive(base);
+      }
+      notNullExpr2Stmt[&base].push_back(std::make_pair(&stmt, &bb));
+      CollectNotNullNode(stmt, base, bb, kNodeTypeIvar);
+      break;
+    }
+    default: {
+      if (nodeType != kNodeTypeNormal) {
+        // Ref expr used in ivar、array or assertnotnull
+        PrimType type = node.GetPrimType();
+        if (type == PTY_ref || type == PTY_ptr) {
+          notNullExpr2Stmt[&node].push_back(std::make_pair(&stmt, &bb));
+        }
+      } else {
+        // Ref expr used array or assertnotnull
+        bool notNull = op == OP_array || kOpcodeInfo.IsAssertNonnull(op);
+        nodeType = notNull ? kNodeTypeNotNull : kNodeTypeNormal;
+      }
+      for (size_t i = 0; i < node.GetNumOpnds(); ++i) {
+        CollectNotNullNode(stmt, ToRef(node.Opnd(i)), bb, nodeType);
+      }
+      break;
+    }
+  }
+}
+
+void DSE::Init() {
+  bbRequired[commonEntryBB.GetBBId()] = true;
+  bbRequired[commonExitBB.GetBBId()] = true;
+  for (auto *bb : bbVec) {
+    if (bb == nullptr) {
+      continue;
+    }
+    // mark phi nodes dead
+    for (auto &phiPair : bb->GetPhiList()) {
+      phiPair.second.SetIsLive(false);
+    }
+  }
+}
+
+void DSE::DoDSE() {
+  Init();
+  MarkSpecialStmtRequired();
+  PropagateLive();
+  RemoveNotRequiredStmts();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/func_emit.cpp b/src/mapleall/maple_me/src/func_emit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..61f3c49c29c67d5c9ec7ed70179fb44a2ad7ff3a
--- /dev/null
+++ b/src/mapleall/maple_me/src/func_emit.cpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "func_emit.h"
+#include "mir_function.h"
+#include "ssa_mir_nodes.h"
+
+namespace maple {
+void FuncEmit::EmitLabelForBB(MIRFunction &func, BB &bb) const {
+  ASSERT(bb.GetBBLabel() != 0, "Should have a label");
+  // create labelnode
+  LabelNode *label = func.GetCodeMempool()->New<LabelNode>();
+  // add freq for new added stmt node
+  if (Options::profileUse) {
+    func.SetStmtFreq(label->GetStmtID(), bb.GetFrequency());
+  }
+  label->SetLabelIdx(bb.GetBBLabel());
+  if (bb.IsEmpty()) {
+    bb.SetFirst(label);
+    bb.SetLast(label);
+  } else {
+    // Insert label before the first non-comment statement of bb.
+    StmtNode *first = bb.GetStmtNodes().begin().d();
+    StmtNode *firstPrev = nullptr;
+    while (first != nullptr && first->GetOpCode() == OP_comment) {
+      firstPrev = first;
+      first = first->GetNext();
+    }
+    // "first" points to the first non-comment statement, or nullptr.
+    if (first != nullptr) {
+      label->InsertAfterThis(*first);
+      if (first == bb.GetStmtNodes().begin().d()) {
+        bb.SetFirst(label);
+      }
+    } else {
+      ASSERT(firstPrev != nullptr, "check func's stmt");
+      label->InsertBeforeThis(*firstPrev);
+      if (firstPrev == bb.GetStmtNodes().rbegin().base().d()) {
+        bb.SetLast(label);
+      }
+    }
+  }
+}
+
+static BaseNode *ConvertSSANode(BaseNode *node) {
+  if (node->IsSSANode()) {
+    node = static_cast<SSANode *>(node)->GetNoSSANode();
+  }
+  for (uint32 opndId = 0; opndId < node->GetNumOpnds(); ++opndId) {
+    ASSERT_NOT_NULL(node->Opnd(opndId));
+    node->SetOpnd(ConvertSSANode(node->Opnd(opndId)), opndId);
+  }
+  return node;
+}
+
+static void ConvertStmt(BB &bb) {
+  for (auto &stmt : bb.GetStmtNodes()) {
+    (void)ConvertSSANode(&stmt);
+    if (stmt.GetOpCode() == OP_maydassign) {
+      stmt.SetOpCode(OP_dassign);
+    }
+  }
+}
+
+// Inserting BBs in bblist into func's body.
+void FuncEmit::EmitBeforeHSSA(MIRFunction &func, const MapleVector<BB*> &bbList) const {
+  StmtNode *lastStmt = nullptr;       // last stmt of previous bb
+  func.GetBody()->SetFirst(nullptr);  // reset body first stmt
+  func.GetBody()->SetLast(nullptr);
+  for (BB *bb : bbList) {
+    if (bb == nullptr) {
+      continue;
+    }
+    ConvertStmt(*bb);
+    if (bb->GetBBLabel() != 0) {
+      EmitLabelForBB(func, *bb);
+    }
+    if (!bb->IsEmpty()) {
+      if (func.GetBody()->GetFirst() == nullptr) {
+        func.GetBody()->SetFirst(bb->GetStmtNodes().begin().d());
+      }
+      if (lastStmt != nullptr) { // link basic blocks
+        bb->GetFirst().SetPrev(lastStmt);
+        lastStmt->SetNext(&bb->GetFirst());
+      }
+      lastStmt = bb->GetStmtNodes().rbegin().base().d();
+    }
+    if (bb->AddBackEndTry()) {
+      // generate op_endtry andd added to next, it could be in an empty bb.
+      StmtNode *endtry = func.GetCodeMempool()->New<StmtNode>(OP_endtry);
+      CHECK_FATAL(lastStmt != nullptr, "EmitBeforeHSSA: shouldn't insert before a null stmt");
+      endtry->InsertBeforeThis(*lastStmt);
+      lastStmt = endtry;
+    }
+  }
+  func.GetBody()->SetLast(lastStmt);
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/hdse.cpp b/src/mapleall/maple_me/src/hdse.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..81a141a5e9a49770a1b9500243214247c36cb162
--- /dev/null
+++ b/src/mapleall/maple_me/src/hdse.cpp
@@ -0,0 +1,896 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "hdse.h"
+
+#include <iostream>
+
+#include "irmap.h"
+#include "mir_preg.h"
+#include "opcode_info.h"
+#include "ssa_mir_nodes.h"
+#include "utils.h"
+#include "ver_symbol.h"
+
+namespace maple {
+using namespace utils;
+
+void HDSE::DetermineUseCounts(MeExpr *x) {
+  if (x->GetMeOp() == kMeOpVar) {
+    VarMeExpr *varmeexpr = static_cast<VarMeExpr*>(x);
+    verstUseCounts[varmeexpr->GetVstIdx()]++;
+    return;
+  }
+  for (uint32 i = 0; i < x->GetNumOpnds(); ++i) {
+    DetermineUseCounts(x->GetOpnd(i));
+  }
+}
+
+void HDSE::CheckBackSubsCandidacy(DassignMeStmt *dass) {
+  if (!dass->GetChiList()->empty()) {
+    return;
+  }
+  if (dass->GetRHS()->GetMeOp() != kMeOpVar && dass->GetRHS()->GetMeOp() != kMeOpReg) {
+    return;
+  }
+  ScalarMeExpr *lhsscalar = static_cast<ScalarMeExpr*>(dass->GetLHS());
+  OriginalSt *ost = lhsscalar->GetOst();
+  if (!ost->IsLocal()) {
+    return;
+  }
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx());
+  if (ty->GetPrimType() == PTY_agg && ty->GetSize() <= 16) {
+    return;
+  }
+  ScalarMeExpr *rhsscalar = static_cast<ScalarMeExpr*>(dass->GetRHS());
+  if (rhsscalar->GetDefBy() != kDefByMustDef) {
+    return;
+  }
+  if (rhsscalar->DefByBB() != dass->GetBB()) {
+    return;
+  }
+  // skip stmtpre candidate
+  auto defStmt = rhsscalar->GetDefMustDef().GetBase();
+  if (defStmt->GetOp() == OP_callassigned) {
+    MIRFunction &callee = static_cast<CallMeStmt*>(defStmt)->GetTargetFunction();
+    if (callee.IsPure() && callee.IsNoThrowException()) {
+      return;
+    }
+  }
+  backSubsCands.push_front(dass);
+}
+
+// STMT is going to be deleted, need to update the use of chi lhs defined by STMT
+// This is used to fix `ResolveContinuousRedefine()`
+void HDSE::UpdateChiUse(MeStmt *stmt) {
+  if (!stmt->GetChiList() || stmt->GetChiList()->empty()) {
+    return;
+  }
+  auto &chiList = *stmt->GetChiList();
+  auto *nextStmt = stmt->GetNext();
+  while (nextStmt) {
+    if (!nextStmt->GetChiList() || nextStmt->GetChiList()->empty()) {
+      nextStmt = nextStmt->GetNext();
+      continue;
+    }
+    for (auto &pair : std::as_const(*nextStmt->GetChiList())) {
+      auto *useChi = pair.second;
+      if (chiList.count(pair.first) != 0 && useChi->GetRHS() == chiList[pair.first]->GetLHS()) {
+        useChi->SetRHS(chiList[pair.first]->GetRHS());
+      }
+    }
+    // only need to update the first found chilist, no other uses
+    break;
+  }
+}
+
+// If EXPR is defined by the same assign with ASSIGN, that means the previous
+// assign can not be removed because that's a real use.
+bool HDSE::RealUse(MeExpr &expr, MeStmt &assign) {
+  switch (expr.GetMeOp()) {
+    case kMeOpVar: {
+      auto *defStmt = static_cast<VarMeExpr&>(expr).GetDefByMeStmt();
+      if (!defStmt || defStmt->GetBB() != assign.GetBB()) {
+        return false;
+      }
+      // handle dassign
+      if (defStmt->GetOp() == OP_dassign && assign.GetOp() == OP_dassign) {
+        if (defStmt->GetLHS()->IsUseSameSymbol(*assign.GetLHS())) {
+          return true;
+        }
+      }
+      // handle iassign
+      if (defStmt->GetOp() == OP_iassign && assign.GetOp() == OP_iassign) {
+        auto *prevIvar = static_cast<IassignMeStmt*>(defStmt)->GetLHSVal();
+        auto *postIvar = static_cast<IassignMeStmt&>(assign).GetLHSVal();
+        if (prevIvar->IsUseSameSymbol(*postIvar) && prevIvar->GetBase() == postIvar->GetBase()) {
+          return true;
+        }
+      }
+      return false;
+    }
+    case kMeOpIvar: {
+      auto *defStmt = static_cast<IvarMeExpr&>(expr).GetDefStmt();
+      // handle iassign
+      if (defStmt && defStmt->GetOp() == OP_iassign && assign.GetOp() == OP_iassign) {
+        auto *prevIvar = static_cast<IassignMeStmt*>(defStmt)->GetLHSVal();
+        auto *postIvar = static_cast<IassignMeStmt&>(assign).GetLHSVal();
+        if (prevIvar->IsUseSameSymbol(*postIvar) && prevIvar->GetBase() == postIvar->GetBase()) {
+          return true;
+        }
+      }
+      auto &ivar = static_cast<IvarMeExpr&>(expr);
+      if (RealUse(*ivar.GetBase(), assign)) {
+        return true;
+      }
+      for (auto *mu : ivar.GetMuList()) {
+        if (mu != nullptr && RealUse(*mu, assign)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    default:
+      break;
+  }
+  for (uint32 i = 0; i < expr.GetNumOpnds(); ++i) {
+    if (RealUse(*expr.GetOpnd(i), assign)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Search up for the same memory assign from ASSIGN, if there're no other uses
+// between these two assigns, kill the redundant first assign.
+// e.g.
+// dassign %a 2 (xxx)  ---- stmt1
+// ... (no other use of %a.field2 or any chi lhs def by stmt1)
+// dassign %a 2 (xxx)  ---- assign
+// we can remove `stmt1` because `assign` must define all that needs to be defined
+void HDSE::ResolveReassign(MeStmt &assign) {
+  if (assign.GetOp() != OP_dassign && assign.GetOp() != OP_iassign) {
+    return;
+  }
+  if (assign.GetChiList()->empty() || RealUse(*assign.GetRHS(), assign)) {
+    return;
+  }
+  MeStmt *prev = assign.GetPrev();
+  while (prev) {
+    MeStmt *cur = prev;
+    prev = prev->GetPrev();
+    if (!cur->GetIsLive()) {
+      continue;
+    }
+    if (cur->GetOp() == OP_dassign && assign.GetOp() == OP_dassign) {
+      DassignMeStmt *curDassign = static_cast<DassignMeStmt*>(cur);
+      if (curDassign->GetLHS()->IsUseSameSymbol(*assign.GetLHS())) {
+        curDassign->SetIsLive(false);
+        continue;
+      }
+    }
+    if (cur->GetOp() == OP_iassign && assign.GetOp() == OP_iassign) {
+      auto *prevIvar = static_cast<IassignMeStmt*>(cur)->GetLHSVal();
+      auto *postIvar = static_cast<IassignMeStmt&>(assign).GetLHSVal();
+      if (prevIvar->GetPrimType() == postIvar->GetPrimType() &&
+          prevIvar->IsUseSameSymbol(*postIvar) &&
+          prevIvar->GetBase() == postIvar->GetBase()) {
+        cur->SetIsLive(false);
+        continue;
+      }
+    }
+    // we do not want to traverse chi list, it's expensive to check every chi
+    if (cur->GetChiList() && !cur->GetChiList()->empty()) {
+      return;
+    }
+    // traverse every expr in the stmt
+    for (uint32 i = 0; i < cur->NumMeStmtOpnds(); ++i) {
+      if (RealUse(*cur->GetOpnd(i), assign)) {
+        return;
+      }
+    }
+    if (cur->GetMuList()) {
+      for (auto &pair : std::as_const(*cur->GetMuList())) {
+        if (RealUse(*pair.second, assign)) {
+          return;
+        }
+      }
+    }
+  }
+}
+
+// Check if there are redundant assigns to the same memory. Used to pick up
+// those redundant assigns marked live by chi list live prop.
+void HDSE::ResolveContinuousRedefine() {
+  for (auto *bb : bbVec) {
+    if (bb == nullptr) {
+      continue;
+    }
+    auto &meStmtNodes = bb->GetMeStmts();
+    for (auto itStmt = meStmtNodes.rbegin(); itStmt != meStmtNodes.rend(); ++itStmt) {
+      MeStmt *pStmt = to_ptr(itStmt);
+      if (!pStmt->GetIsLive() || HasNonDeletableExpr(*pStmt)) {
+        continue;
+      }
+      ResolveReassign(*pStmt);
+    }
+  }
+}
+
+void HDSE::RemoveNotRequiredStmtsInBB(BB &bb) {
+  MeStmt *mestmt = &bb.GetMeStmts().front();
+  MeStmt *nextstmt = nullptr;
+  while (mestmt) {
+    nextstmt = mestmt->GetNext();
+    if (!mestmt->GetIsLive()) {
+      if (hdseDebug) {
+        mirModule.GetOut() << "========== HSSA DSE is deleting this stmt: ";
+        mestmt->Dump(&irMap);
+      }
+      if (mestmt->GetOp() != OP_dassign &&
+          (mestmt->IsCondBr() || mestmt->GetOp() == OP_switch || mestmt->GetOp() == OP_igoto)) {
+        // update CFG
+        while (bb.GetSucc().size() != 1) {
+          BB *succ = bb.GetSucc().back();
+          succ->RemovePred(bb);
+          if (succ->GetPred().empty()) {
+            needUNClean = true;
+          }
+        }
+        bb.SetKind(kBBFallthru);
+        if (UpdateFreq()) {
+          uint64 succ0Freq = bb.GetSuccFreq()[0];
+          bb.GetSuccFreq().resize(1);
+          bb.SetSuccFreq(0, bb.GetFrequency());
+          ASSERT(bb.GetFrequency() >= succ0Freq, "sanity check");
+          bb.GetSucc(0)->SetFrequency(bb.GetSucc(0)->GetFrequency() + (bb.GetFrequency() - succ0Freq));
+        }
+      }
+      // A ivar contained in stmt
+      if (stmt2NotNullExpr.find(mestmt) != stmt2NotNullExpr.end()) {
+        for (MeExpr *meExpr : stmt2NotNullExpr.at(mestmt)) {
+          if (NeedNotNullCheck(*meExpr, bb)) {
+            UnaryMeStmt *nullCheck = irMap.New<UnaryMeStmt>(OP_assertnonnull);
+            nullCheck->SetBB(&bb);
+            nullCheck->SetSrcPos(mestmt->GetSrcPosition());
+            nullCheck->SetMeStmtOpndValue(meExpr);
+            bb.InsertMeStmtBefore(mestmt, nullCheck);
+            nullCheck->SetIsLive(true);
+            notNullExpr2Stmt[meExpr].push_back(nullCheck);
+          }
+        }
+      }
+      if (removeRedefine) {
+        UpdateChiUse(mestmt);
+      }
+      bb.RemoveMeStmt(mestmt);
+    } else {
+      // skip fold conditional branch because it may break recorded IfInfo.
+      bool isPme = mirModule.CurFunction()->GetMeFunc()->GetPreMeFunc() != nullptr;
+      if (mestmt->IsCondBr() && !isPme) {  // see if foldable to unconditional branch
+        CondGotoMeStmt *condbr = static_cast<CondGotoMeStmt*>(mestmt);
+        uint64 removedFreq = 0;
+        if (!mirModule.IsJavaModule() && condbr->GetOpnd()->GetMeOp() == kMeOpConst) {
+          CHECK_FATAL(IsPrimitiveInteger(condbr->GetOpnd()->GetPrimType()),
+                      "MeHDSE::DseProcess: branch condition must be integer type");
+          if ((condbr->GetOp() == OP_brtrue && condbr->GetOpnd()->IsZero()) ||
+              (condbr->GetOp() == OP_brfalse && !condbr->GetOpnd()->IsZero())) {
+            // delete the conditional branch
+            BB *succbb = bb.GetSucc().back();
+            if (UpdateFreq()) {
+              removedFreq = bb.GetSuccFreq().back();
+            }
+            succbb->RemoveBBFromPred(bb, false);
+            if (succbb->GetPred().empty()) {
+              needUNClean = true;
+            }
+            bb.GetSucc().pop_back();
+            bb.SetKind(kBBFallthru);
+            bb.RemoveMeStmt(mestmt);
+          } else {
+            // change to unconditional branch
+            BB *succbb = bb.GetSucc().front();
+            if (UpdateFreq()) {
+              removedFreq = bb.GetSuccFreq().front();
+            }
+            succbb->RemoveBBFromPred(bb, false);
+            if (succbb->GetPred().empty()) {
+              needUNClean = true;
+            }
+            (void)bb.GetSucc().erase(bb.GetSucc().cbegin());
+            bb.SetKind(kBBGoto);
+            GotoMeStmt *gotomestmt = irMap.New<GotoMeStmt>(condbr->GetOffset());
+            bb.ReplaceMeStmt(condbr, gotomestmt);
+          }
+          if (UpdateFreq()) {
+            bb.GetSuccFreq().resize(1);
+            bb.SetSuccFreq(0, bb.GetFrequency());
+            bb.GetSucc(0)->SetFrequency(bb.GetSucc(0)->GetFrequency() + removedFreq);
+          }
+        } else {
+          DetermineUseCounts(condbr->GetOpnd());
+        }
+      } else {
+        for (uint32 i = 0; i < mestmt->NumMeStmtOpnds(); ++i) {
+          DetermineUseCounts(mestmt->GetOpnd(i));
+        }
+        if (mestmt->GetOp() == OP_dassign) {
+          CheckBackSubsCandidacy(static_cast<DassignMeStmt*>(mestmt));
+        }
+      }
+    }
+    mestmt = nextstmt;
+  }
+  // update verstUseCOunts for uses in phi operands
+  for (auto &phipair : std::as_const(bb.GetMePhiList())) {
+    if (phipair.second->GetIsLive()) {
+      for (ScalarMeExpr *phiOpnd : phipair.second->GetOpnds()) {
+        VarMeExpr *varx = dynamic_cast<VarMeExpr*>(phiOpnd);
+        if (varx) {
+          verstUseCounts[varx->GetVstIdx()]++;
+        }
+      }
+    }
+  }
+}
+
+// If a ivar's base not used as not null, should insert a not null stmt
+// Only make sure throw NPE in same BB
+// If must make sure throw at first stmt, much more not null stmt will be inserted
+bool HDSE::NeedNotNullCheck(MeExpr &meExpr, const BB &bb) {
+  if (theMIRModule->IsCModule()) {
+    return false;
+  }
+  if (meExpr.GetOp() == OP_addrof) {
+    return false;
+  }
+  if (meExpr.GetOp() == OP_iaddrof && static_cast<OpMeExpr&>(meExpr).GetFieldID() > 0) {
+    return false;
+  }
+
+  for (MeStmt *stmt : notNullExpr2Stmt[&meExpr]) {
+    if (!stmt->GetIsLive()) {
+      continue;
+    }
+    if (dom.Dominate(*(stmt->GetBB()), bb)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void HDSE::MarkMuListRequired(MapleMap<OStIdx, ScalarMeExpr*> &muList) {
+  for (auto &pair : std::as_const(muList)) {
+    workList.push_front(pair.second);
+  }
+}
+
+void HDSE::MarkChiNodeRequired(ChiMeNode &chiNode) {
+  if (chiNode.GetIsLive()) {
+    return;
+  }
+  chiNode.SetIsLive(true);
+  workList.push_front(chiNode.GetRHS());
+  MeStmt *meStmt = chiNode.GetBase();
+
+  // set MustDefNode live, which defines the chiNode.
+  auto *mustDefList = meStmt->GetMustDefList();
+  if (mustDefList != nullptr) {
+    for (auto &mustDef : *mustDefList) {
+      if (aliasInfo->MayAlias(mustDef.GetLHS()->GetOst(), chiNode.GetLHS()->GetOst())) {
+        mustDef.SetIsLive(true);
+      }
+    }
+  }
+
+  MarkStmtRequired(*meStmt);
+}
+
+template <class VarOrRegPhiNode>
+void HDSE::MarkPhiRequired(VarOrRegPhiNode &mePhiNode) {
+  if (mePhiNode.GetIsLive()) {
+    return;
+  }
+  mePhiNode.SetIsLive(true);
+  for (auto *meExpr : mePhiNode.GetOpnds()) {
+    if (meExpr != nullptr) {
+      MarkSingleUseLive(*meExpr);
+    }
+  }
+  MarkControlDependenceLive(*mePhiNode.GetDefBB());
+}
+
+void HDSE::MarkVarDefByStmt(VarMeExpr &varMeExpr) {
+  switch (varMeExpr.GetDefBy()) {
+    case kDefByNo:
+      break;
+    case kDefByStmt: {
+      auto *defStmt = varMeExpr.GetDefStmt();
+      if (defStmt != nullptr) {
+        MarkStmtRequired(*defStmt);
+      }
+      break;
+    }
+    case kDefByPhi: {
+      MarkPhiRequired(varMeExpr.GetDefPhi());
+      break;
+    }
+    case kDefByChi: {
+      auto &defChi = varMeExpr.GetDefChi();
+      MarkChiNodeRequired(defChi);
+      break;
+    }
+    case kDefByMustDef: {
+      auto *mustDef = &varMeExpr.GetDefMustDef();
+      if (!mustDef->GetIsLive()) {
+        mustDef->SetIsLive(true);
+        MarkStmtRequired(*mustDef->GetBase());
+      }
+      break;
+    }
+    default:
+      ASSERT(false, "var defined wrong");
+      break;
+  }
+}
+
+void HDSE::MarkRegDefByStmt(RegMeExpr &regMeExpr) {
+  PregIdx regIdx = regMeExpr.GetRegIdx();
+  if (regIdx == -kSregRetval0) {
+    if (regMeExpr.GetDefStmt()) {
+      MarkStmtRequired(*regMeExpr.GetDefStmt());
+    }
+    return;
+  }
+  switch (regMeExpr.GetDefBy()) {
+    case kDefByNo:
+      break;
+    case kDefByStmt: {
+      auto *defStmt = regMeExpr.GetDefStmt();
+      if (defStmt != nullptr) {
+        MarkStmtRequired(*defStmt);
+      }
+      break;
+    }
+    case kDefByPhi:
+      MarkPhiRequired(regMeExpr.GetDefPhi());
+      break;
+    case kDefByChi: {
+      ASSERT(regMeExpr.GetOst()->GetIndirectLev() > 0, "MarkRegDefByStmt: preg cannot be defined by chi");
+      auto &defChi = regMeExpr.GetDefChi();
+      MarkChiNodeRequired(defChi);
+      break;
+    }
+    case kDefByMustDef: {
+      MustDefMeNode *mustDef = &regMeExpr.GetDefMustDef();
+      if (!mustDef->GetIsLive()) {
+        mustDef->SetIsLive(true);
+        MarkStmtRequired(*mustDef->GetBase());
+      }
+      break;
+    }
+    default:
+      ASSERT(false, "MarkRegDefByStmt unexpected defBy value");
+      break;
+  }
+}
+
+// Find all stmt contains ivar and save to stmt2NotNullExpr
+// Find all not null expr used as ivar's base、OP_array's or OP_assertnonnull's opnd
+// And save to notNullExpr2Stmt
+void HDSE::CollectNotNullExpr(MeStmt &stmt) {
+  size_t opndNum = stmt.NumMeStmtOpnds();
+  uint8 exprType = kExprTypeNormal;
+  for (size_t i = 0; i < opndNum; ++i) {
+    MeExpr *opnd = stmt.GetOpnd(i);
+    if (i == 0 && instance_of<CallMeStmt>(stmt)) {
+      // A non-static call's first opnd is this, should be not null
+      CallMeStmt &callStmt = static_cast<CallMeStmt&>(stmt);
+      exprType = callStmt.GetTargetFunction().IsStatic() ? kExprTypeNormal : kExprTypeNotNull;
+    } else {
+      // A normal opnd not sure
+      MeExprOp meOp = opnd->GetMeOp();
+      if (meOp == kMeOpVar || meOp == kMeOpReg) {
+        continue;
+      }
+      exprType = kExprTypeNormal;
+    }
+    CollectNotNullExpr(stmt, ToRef(opnd), exprType);
+  }
+}
+
+void HDSE::CollectNotNullExpr(MeStmt &stmt, MeExpr &meExpr, uint8 exprType) {
+  MeExprOp meOp = meExpr.GetMeOp();
+  switch (meOp) {
+    case kMeOpVar:
+    case kMeOpReg:
+    case kMeOpConst: {
+      PrimType type = meExpr.GetPrimType();
+      // Ref expr used in ivar、array or assertnotnull
+      if (exprType != kExprTypeNormal && (type == PTY_ref || type == PTY_ptr)) {
+        notNullExpr2Stmt[&meExpr].push_back(&stmt);
+      }
+      break;
+    }
+    case kMeOpIvar: {
+      MeExpr *base = static_cast<IvarMeExpr&>(meExpr).GetBase();
+      if (exprType != kExprTypeIvar) {
+        stmt2NotNullExpr[&stmt].push_back(base);
+        MarkSingleUseLive(meExpr);
+      }
+      notNullExpr2Stmt[base].push_back(&stmt);
+      CollectNotNullExpr(stmt, ToRef(base), kExprTypeIvar);
+      break;
+    }
+    default: {
+      if (exprType != kExprTypeNormal) {
+        // Ref expr used in ivar、array or assertnotnull
+        PrimType type = meExpr.GetPrimType();
+        if (type == PTY_ref || type == PTY_ptr) {
+          notNullExpr2Stmt[&meExpr].push_back(&stmt);
+        }
+      } else {
+        // Ref expr used array or assertnotnull
+        Opcode op = meExpr.GetOp();
+        bool notNull = op == OP_array || kOpcodeInfo.IsAssertNonnull(op);
+        exprType = notNull ? kExprTypeNotNull : kExprTypeNormal;
+      }
+      for (size_t i = 0; i < meExpr.GetNumOpnds(); ++i) {
+        CollectNotNullExpr(stmt, ToRef(meExpr.GetOpnd(i)), exprType);
+      }
+      break;
+    }
+  }
+}
+
+void HDSE::PropagateUseLive(MeExpr &meExpr) {
+  switch (meExpr.GetMeOp()) {
+    case kMeOpVar: {
+      auto &varMeExpr = static_cast<VarMeExpr&>(meExpr);
+      MarkVarDefByStmt(varMeExpr);
+      return;
+    }
+    case kMeOpReg: {
+      auto &regMeExpr = static_cast<RegMeExpr&>(meExpr);
+      MarkRegDefByStmt(regMeExpr);
+      return;
+    }
+    default: {
+      ASSERT(false, "MeOp ERROR");
+      return;
+    }
+  }
+}
+
+bool HDSE::ExprHasSideEffect(const MeExpr &meExpr) const {
+  Opcode op = meExpr.GetOp();
+  // in c language, OP_array and OP_div has no side-effect
+  if (mirModule.IsCModule() && (op == OP_array || op == OP_div || op == OP_rem)) {
+    return false;
+  }
+  if (kOpcodeInfo.HasSideEffect(op)) {
+    return true;
+  }
+  // may throw exception
+  if (op == OP_gcmallocjarray || op == OP_gcpermallocjarray) {
+    return true;
+  }
+  // create a instance of interface
+  if (op == OP_gcmalloc || op == OP_gcpermalloc) {
+    auto &gcMallocMeExpr = static_cast<const GcmallocMeExpr&>(meExpr);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(gcMallocMeExpr.GetTyIdx());
+    return type->GetKind() == kTypeInterface;
+  }
+  return false;
+}
+
+bool HDSE::ExprNonDeletable(const MeExpr &meExpr) const {
+  if (ExprHasSideEffect(meExpr)) {
+    return true;
+  }
+
+  switch (meExpr.GetMeOp()) {
+    case kMeOpReg: {
+      auto &regMeExpr = static_cast<const RegMeExpr&>(meExpr);
+      return (regMeExpr.GetRegIdx() == -kSregThrownval);
+    }
+    case kMeOpVar: {
+      auto &varMeExpr = static_cast<const VarMeExpr&>(meExpr);
+      return varMeExpr.IsVolatile() || (decoupleStatic && varMeExpr.GetOst()->GetMIRSymbol()->IsGlobal());
+    }
+    case kMeOpIvar: {
+      auto &opIvar = static_cast<const IvarMeExpr&>(meExpr);
+      return opIvar.IsVolatile() || ExprNonDeletable(*opIvar.GetBase());
+    }
+    case kMeOpNary: {
+      auto &opNary = static_cast<const NaryMeExpr&>(meExpr);
+      if (meExpr.GetOp() == OP_intrinsicop) {
+        IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[opNary.GetIntrinsic()];
+        return (!intrinDesc->HasNoSideEffect());
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  for (size_t i = 0; i != meExpr.GetNumOpnds(); ++i) {
+    if (ExprNonDeletable(*meExpr.GetOpnd(i))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool HDSE::HasNonDeletableExpr(const MeStmt &meStmt) const {
+  Opcode op = meStmt.GetOp();
+  switch (op) {
+    case OP_dassign: {
+      auto &dasgn = static_cast<const DassignMeStmt&>(meStmt);
+      VarMeExpr *varMeExpr = static_cast<VarMeExpr*>(dasgn.GetVarLHS());
+      return (varMeExpr != nullptr && varMeExpr->IsVolatile()) || ExprNonDeletable(*dasgn.GetRHS()) ||
+             (hdseKeepRef && dasgn.Propagated()) || dasgn.GetWasMayDassign() ||
+             (decoupleStatic && varMeExpr != nullptr && varMeExpr->GetOst()->GetMIRSymbol()->IsGlobal());
+    }
+    case OP_regassign: {
+      auto &rasgn = static_cast<const AssignMeStmt&>(meStmt);
+      return ExprNonDeletable(*rasgn.GetRHS());
+    }
+    case OP_maydassign:
+      return true;
+    case OP_iassign: {
+      auto &iasgn = static_cast<const IassignMeStmt&>(meStmt);
+      auto &ivarMeExpr = static_cast<IvarMeExpr&>(*iasgn.GetLHSVal());
+      return ivarMeExpr.IsVolatile() || ivarMeExpr.IsFinal() || ExprNonDeletable(*iasgn.GetLHSVal()->GetBase()) ||
+             ExprNonDeletable(*iasgn.GetRHS());
+    }
+    case OP_intrinsiccall: {
+      bool opndNonDeletable = false;
+      auto &intrinCall = static_cast<const IntrinsiccallMeStmt&>(meStmt);
+      auto *chiList = intrinCall.GetChiList();
+      for (auto &chi : *chiList) {
+        opndNonDeletable |= ExprNonDeletable(ToRef(chi.second->GetRHS()));
+      }
+      for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        opndNonDeletable |= ExprNonDeletable(ToRef(meStmt.GetOpnd(i)));
+      }
+      return opndNonDeletable;
+    }
+    default:
+      return false;
+  }
+}
+
+void HDSE::MarkLastBranchStmtInPredBBRequired(const BB &bb) {
+  for (auto predIt = bb.GetPred().begin(); predIt != bb.GetPred().end(); ++predIt) {
+    BB *predBB = *predIt;
+    if (predBB == &bb || predBB->GetMeStmts().empty()) {
+      continue;
+    }
+    auto &lastStmt = predBB->GetMeStmts().back();
+    if (!lastStmt.GetIsLive() && IsBranch(lastStmt.GetOp())) {
+      MarkStmtRequired(lastStmt);
+    }
+  }
+}
+
+void HDSE::MarkLastStmtInPDomBBRequired(const BB &bb) {
+  CHECK(bb.GetBBId() < postDom.GetDomFrontierSize(), "index out of range in HDSE::MarkLastStmtInPDomBBRequired");
+  for (auto cdBBId : postDom.GetDomFrontier(bb.GetID())) {
+    BB *cdBB = bbVec[cdBBId];
+    CHECK_FATAL(cdBB != nullptr, "cdBB is null in HDSE::MarkLastStmtInPDomBBRequired");
+    if (cdBB == &bb) {
+      continue;
+    }
+    if (cdBB->IsMeStmtEmpty()) {
+      CHECK_FATAL(cdBB->GetAttributes(kBBAttrIsTry), "empty bb in pdom frontier must have try attributes");
+      MarkLastStmtInPDomBBRequired(*cdBB);
+      continue;
+    }
+    auto &lastStmt = cdBB->GetMeStmts().back();
+    Opcode op = lastStmt.GetOp();
+    CHECK_FATAL((lastStmt.IsCondBr() || op == OP_switch || op == OP_igoto || op == OP_retsub || op == OP_throw ||
+                 cdBB->GetAttributes(kBBAttrIsTry) || cdBB->GetAttributes(kBBAttrWontExit)),
+                "HDSE::MarkLastStmtInPDomBBRequired: control dependent on unexpected statement");
+    if ((IsBranch(op) || op == OP_retsub || op == OP_throw)) {
+      MarkStmtRequired(lastStmt);
+    }
+  }
+}
+
+void HDSE::MarkLastBranchStmtInBBRequired(BB &bb) {
+  auto &meStmts = bb.GetMeStmts();
+  if (!meStmts.empty()) {
+    auto &lastStmt = meStmts.back();
+    Opcode op = lastStmt.GetOp();
+    if (IsBranch(op)) {
+      MarkStmtRequired(lastStmt);
+    }
+  }
+}
+
+void HDSE::MarkControlDependenceLive(BB &bb) {
+  if (bbRequired[bb.GetBBId()]) {
+    return;
+  }
+  bbRequired[bb.GetBBId()] = true;
+
+  MarkLastBranchStmtInBBRequired(bb);
+  MarkLastStmtInPDomBBRequired(bb);
+  MarkLastBranchStmtInPredBBRequired(bb);
+}
+
+void HDSE::MarkSingleUseLive(MeExpr &meExpr) {
+  if (IsExprNeeded(meExpr)) {
+    return;
+  }
+  SetExprNeeded(meExpr);
+  MeExprOp meOp = meExpr.GetMeOp();
+  switch (meOp) {
+    case kMeOpVar:
+    case kMeOpReg: {
+      workList.push_front(&meExpr);
+      break;
+    }
+    case kMeOpIvar: {
+      auto *base = static_cast<IvarMeExpr&>(meExpr).GetBase();
+      MarkSingleUseLive(*base);
+      auto &muList = static_cast<IvarMeExpr&>(meExpr).GetMuList();
+      for (auto *mu : muList) {
+        if (mu != nullptr) {
+          workList.push_front(mu);
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+  for (size_t i = 0; i != meExpr.GetNumOpnds(); ++i) {
+    MeExpr *operand = meExpr.GetOpnd(i);
+    if (operand != nullptr) {
+      MarkSingleUseLive(*operand);
+    }
+  }
+}
+
+void HDSE::MarkStmtUseLive(MeStmt &meStmt) {
+  // mark single use
+  for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+    auto *operand = meStmt.GetOpnd(i);
+    if (operand != nullptr) {
+      MarkSingleUseLive(*operand);
+    }
+  }
+
+  // mark MuList
+  auto *muList = meStmt.GetMuList();
+  if (muList != nullptr) {
+    MarkMuListRequired(*muList);
+  }
+}
+
+void HDSE::MarkStmtRequired(MeStmt &meStmt) {
+  if (meStmt.GetIsLive()) {
+    return;
+  }
+  meStmt.SetIsLive(true);
+
+  if (meStmt.GetOp() == OP_comment) {
+    return;
+  }
+
+  // mark use
+  MarkStmtUseLive(meStmt);
+
+  // markBB
+  MarkControlDependenceLive(*meStmt.GetBB());
+}
+
+bool HDSE::StmtMustRequired(const MeStmt &meStmt, const BB &bb) const {
+  Opcode op = meStmt.GetOp();
+  // special opcode cannot be eliminated
+  if (IsStmtMustRequire(op) || op == OP_comment) {
+    return true;
+  }
+  // control flow in an infinite loop cannot be eliminated
+  if (ControlFlowInInfiniteLoop(bb, op)) {
+    return true;
+  }
+  // if stmt has not deletable expr
+  if (HasNonDeletableExpr(meStmt)) {
+    return true;
+  }
+  return false;
+}
+
+void HDSE::MarkSpecialStmtRequired() {
+  for (auto *bb : bbVec) {
+    if (bb == nullptr) {
+      continue;
+    }
+    auto &meStmtNodes = bb->GetMeStmts();
+    for (auto itStmt = meStmtNodes.rbegin(); itStmt != meStmtNodes.rend(); ++itStmt) {
+      MeStmt *pStmt = to_ptr(itStmt);
+      CollectNotNullExpr(*pStmt);
+      if (pStmt->GetIsLive()) {
+        continue;
+      }
+      if (StmtMustRequired(*pStmt, *bb)) {
+        MarkStmtRequired(*pStmt);
+      }
+    }
+  }
+  if (IsLfo()) {
+    ProcessWhileInfos();
+  }
+}
+
+void HDSE::DseInit() {
+  // Init bb's required flag
+  bbRequired[commonEntryBB.GetBBId()] = true;
+  bbRequired[commonExitBB.GetBBId()] = true;
+
+  // Init all MeExpr to be dead;
+  exprLive.resize(irMap.GetExprID(), false);
+  // Init all use counts to be 0
+  verstUseCounts.resize(0);
+  verstUseCounts.resize(irMap.GetVerst2MeExprTable().size(), 0);
+
+  for (auto *bb : bbVec) {
+    if (bb == nullptr) {
+      continue;
+    }
+    // mark phi nodes dead
+    for (auto &phiPair : std::as_const(bb->GetMePhiList())) {
+      phiPair.second->SetIsLive(false);
+    }
+
+    for (auto &stmt : bb->GetMeStmts()) {
+      // mark stmt dead
+      stmt.SetIsLive(false);
+      // mark chi nodes dead
+      MapleMap<OStIdx, ChiMeNode*> *chiList = stmt.GetChiList();
+      if (chiList != nullptr) {
+        for (std::pair<OStIdx, ChiMeNode*> pair : std::as_const(*chiList)) {
+          pair.second->SetIsLive(false);
+        }
+      }
+      // mark mustDef nodes dead
+      if (kOpcodeInfo.IsCallAssigned(stmt.GetOp()) && stmt.GetOp() != OP_asm) {
+        MapleVector<MustDefMeNode> *mustDefList = stmt.GetMustDefList();
+        for (MustDefMeNode &mustDef : *mustDefList) {
+          mustDef.SetIsLive(false);
+        }
+      }
+    }
+  }
+}
+
+void HDSE::InvokeHDSEUpdateLive() {
+  DseInit();
+  MarkSpecialStmtRequired();
+  PropagateLive();
+}
+
+void HDSE::DoHDSE() {
+  DseInit();
+  MarkSpecialStmtRequired();
+  PropagateLive();
+  if (removeRedefine) {
+    ResolveContinuousRedefine();
+  }
+  RemoveNotRequiredStmts();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/irmap.cpp b/src/mapleall/maple_me/src/irmap.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eddb1de7933efd1b574bd719d1cd37059c149ac9
--- /dev/null
+++ b/src/mapleall/maple_me/src/irmap.cpp
@@ -0,0 +1,2821 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "irmap.h"
+#include <bitset>
+#include <queue>
+#include "me_ir.h"
+#include "opcodes.h"
+#include "ssa.h"
+#include "mir_builder.h"
+#include "constantfold.h"
+#include "cast_opt.h"
+
+namespace maple {
+void IRMap::UpdateIncDecAttr(MeStmt &meStmt) {
+  if (!kOpcodeInfo.AssignActualVar(meStmt.GetOp())) {
+    return;
+  }
+  auto *assign = static_cast<AssignMeStmt*>(&meStmt);
+  if (assign->GetOpnd(0)->GetMeOp() != kMeOpOp) {
+    assign->isIncDecStmt = false;
+    return;
+  }
+  auto *rhs = static_cast<OpMeExpr *>(assign->GetOpnd(0));
+  if (rhs->GetOp() != OP_add && rhs->GetOp() != OP_sub) {
+    assign->isIncDecStmt = false;
+    return;
+  }
+  if (rhs->GetOpnd(0)->GetMeOp() == kMeOpReg && rhs->GetOpnd(1)->GetMeOp() == kMeOpConst) {
+    assign->isIncDecStmt = assign->GetLHS()->GetOst() == static_cast<ScalarMeExpr *>(rhs->GetOpnd(0))->GetOst();
+  } else {
+    assign->isIncDecStmt = false;
+  }
+}
+
+// Return a simplified expr if succeed, return nullptr if fail
+MeExpr *IRMap::SimplifyCast(MeExpr *expr) {
+  return MeCastOpt::SimplifyCast(*this, expr);
+}
+
+// Try to remove redundant intTrunc for dassgin and iassign
+void IRMap::SimplifyCastForAssign(MeStmt *assignStmt) {
+  MeCastOpt::SimplifyCastForAssign(assignStmt);
+}
+
+void IRMap::SimplifyAssign(AssignMeStmt *assignStmt) {
+  if (assignStmt == nullptr) {
+    return;
+  }
+  if (assignStmt->GetOp() == OP_regassign) {
+    // try to remove redundant iaddrof
+    while (assignStmt->GetRHS()->GetOp() == OP_iaddrof) {
+      auto *iaddrof = static_cast<OpMeExpr*>(assignStmt->GetRHS());
+      FieldID fld = iaddrof->GetFieldID();
+      MIRType *type = iaddrof->GetType();
+      CHECK_FATAL(type->IsMIRPtrType(), "IaddrofExpr's type must be pointer type!");
+      MIRType *pointedType = static_cast<MIRPtrType*>(type)->GetPointedType();
+      int64 offset = pointedType->GetBitOffsetFromBaseAddr(fld);
+      if (offset == 0) {
+        // although iaddrof expr's type may be not the same as base(iaddrof is fieldType, base is agg's type),
+        // we could use base directly because regassign can reserve only primtype in a reg.
+        MeExpr *base = iaddrof->GetOpnd(0);
+        assignStmt->SetRHS(base);
+      } else {
+        break;
+      }
+    }
+  }
+  SimplifyCastForAssign(assignStmt);
+}
+
+VarMeExpr *IRMap::CreateVarMeExprVersion(OriginalSt *ost) {
+  CHECK_FATAL(ost, "ost is nullptr!");
+  VarMeExpr *varMeExpr = New<VarMeExpr>(exprID++, ost, verst2MeExprTable.size(),
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx())->GetPrimType());
+  ost->PushbackVersionsIndices(verst2MeExprTable.size());
+  verst2MeExprTable.push_back(varMeExpr);
+  return varMeExpr;
+}
+
+MeExpr *IRMap::CreateAddrofMeExpr(MeExpr &expr) {
+  if (expr.GetMeOp() == kMeOpVar) {
+    auto &varMeExpr = static_cast<VarMeExpr&>(expr);
+    AddrofMeExpr addrofme(-1, PTY_ptr, varMeExpr.GetOst());
+    return HashMeExpr(addrofme);
+  } else {
+    ASSERT(expr.GetMeOp() == kMeOpIvar, "expecting IVarMeExpr");
+    auto &ivarExpr = static_cast<IvarMeExpr&>(expr);
+    OpMeExpr opMeExpr(kInvalidExprID, OP_iaddrof, PTY_ptr, 1);
+    opMeExpr.SetFieldID(ivarExpr.GetFieldID());
+    opMeExpr.SetTyIdx(ivarExpr.GetTyIdx());
+    opMeExpr.SetOpnd(0, ivarExpr.GetBase());
+    return HashMeExpr(opMeExpr);
+  }
+}
+
+MeExpr *IRMap::CreateAddroffuncMeExpr(PUIdx puIdx) {
+  AddroffuncMeExpr addroffuncMeExpr(-1, puIdx);
+  addroffuncMeExpr.SetOp(OP_addroffunc);
+  addroffuncMeExpr.SetPtyp(PTY_ptr);
+  addroffuncMeExpr.SetNumOpnds(0);
+  return HashMeExpr(addroffuncMeExpr);
+}
+
+MeExpr *IRMap::CreateIaddrofMeExpr(FieldID fieldId, TyIdx tyIdx, MeExpr *base) {
+  OpMeExpr opMeExpr(kInvalidExprID, OP_iaddrof, PTY_ptr, 1);
+  opMeExpr.SetFieldID(fieldId);
+  opMeExpr.SetTyIdx(tyIdx);
+  opMeExpr.SetOpnd(0, base);
+  return HashMeExpr(opMeExpr);
+}
+
+MeExpr *IRMap::CreateIvarMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base) {
+  ASSERT(expr.GetMeOp() == kMeOpVar, "expecting IVarMeExpr");
+  auto &varMeExpr = static_cast<VarMeExpr&>(expr);
+  IvarMeExpr ivarMeExpr(&irMapAlloc, -1, varMeExpr.GetPrimType(), tyIdx, varMeExpr.GetOst()->GetFieldID());
+  ivarMeExpr.SetBase(&base);
+  ivarMeExpr.SetMuItem(0, &varMeExpr);
+  return HashMeExpr(ivarMeExpr);
+}
+
+NaryMeExpr *IRMap::CreateNaryMeExpr(const NaryMeExpr &nMeExpr) {
+  NaryMeExpr tmpNaryMeExpr(&(irMapAlloc), kInvalidExprID, nMeExpr);
+  tmpNaryMeExpr.SetBoundCheck(false);
+  MeExpr *newNaryMeExpr = HashMeExpr(tmpNaryMeExpr);
+  return static_cast<NaryMeExpr*>(newNaryMeExpr);
+}
+
+VarMeExpr *IRMap::CreateNewVar(GStrIdx strIdx, PrimType pType, bool isGlobal) {
+  MIRSymbol *st =
+      mirModule.GetMIRBuilder()->CreateSymbol(TyIdx(pType), strIdx, kStVar,
+                                              isGlobal ? kScGlobal : kScAuto,
+                                              isGlobal ? nullptr : mirModule.CurFunction(),
+                                              isGlobal ? kScopeGlobal : kScopeLocal);
+  if (isGlobal) {
+    st->SetIsTmp(true);
+  }
+  OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(*st, isGlobal ? 0 : mirModule.CurFunction()->GetPuidx(), 0);
+  oSt->SetZeroVersionIndex(verst2MeExprTable.size());
+  verst2MeExprTable.push_back(nullptr);
+  oSt->PushbackVersionsIndices(oSt->GetZeroVersionIndex());
+
+  VarMeExpr *varx = New<VarMeExpr>(exprID++, oSt, verst2MeExprTable.size(), pType);
+  verst2MeExprTable.push_back(varx);
+  return varx;
+}
+
+VarMeExpr *IRMap::CreateNewLocalRefVarTmp(GStrIdx strIdx, TyIdx tIdx) {
+  MIRSymbol *st =
+      mirModule.GetMIRBuilder()->CreateSymbol(tIdx, strIdx, kStVar, kScAuto, mirModule.CurFunction(), kScopeLocal);
+  st->SetInstrumented();
+  OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), 0);
+  oSt->SetZeroVersionIndex(verst2MeExprTable.size());
+  verst2MeExprTable.push_back(nullptr);
+  oSt->PushbackVersionsIndices(oSt->GetZeroVersionIndex());
+  auto *newLocalRefVar = New<VarMeExpr>(exprID++, oSt, verst2MeExprTable.size(), PTY_ref);
+  verst2MeExprTable.push_back(newLocalRefVar);
+  return newLocalRefVar;
+}
+
+RegMeExpr *IRMap::CreateRegMeExprVersion(OriginalSt &pregOSt) {
+  RegMeExpr *regReadExpr =
+      New<RegMeExpr>(exprID++, &pregOSt, verst2MeExprTable.size(), kMeOpReg,
+                     OP_regread, pregOSt.GetMIRPreg()->GetPrimType());
+  pregOSt.PushbackVersionsIndices(verst2MeExprTable.size());
+  verst2MeExprTable.push_back(regReadExpr);
+  return regReadExpr;
+}
+
+ScalarMeExpr *IRMap::CreateRegOrVarMeExprVersion(OStIdx ostIdx) {
+  OriginalSt *ost = ssaTab.GetOriginalStFromID(ostIdx);
+  CHECK_FATAL(ost, "ost is nullptr!");
+  if (ost->IsPregOst()) {
+    return CreateRegMeExprVersion(*ost);
+  } else {
+    return CreateVarMeExprVersion(ost);
+  }
+}
+
+RegMeExpr *IRMap::CreateRegMeExpr(PrimType pType) {
+  MIRFunction *mirFunc = mirModule.CurFunction();
+  PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(pType);
+  ASSERT(regIdx <= 0xffff, "register oversized");
+  OriginalSt *ost = ssaTab.GetOriginalStTable().CreatePregOriginalSt(regIdx, mirFunc->GetPuidx());
+  return CreateRegMeExprVersion(*ost);
+}
+
+RegMeExpr *IRMap::CreateRegMeExpr(MIRType &mirType) {
+  if (mirType.GetPrimType() != PTY_ref && mirType.GetPrimType() != PTY_ptr) {
+    return CreateRegMeExpr(mirType.GetPrimType());
+  }
+  if (mirType.GetPrimType() == PTY_ptr) {
+    return CreateRegMeExpr(mirType.GetPrimType());
+  }
+  MIRFunction *mirFunc = mirModule.CurFunction();
+  PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(PTY_ref, &mirType);
+  ASSERT(regIdx <= 0xffff, "register oversized");
+  OriginalSt *ost = ssaTab.GetOriginalStTable().CreatePregOriginalSt(regIdx, mirFunc->GetPuidx());
+  return CreateRegMeExprVersion(*ost);
+}
+
+RegMeExpr *IRMap::CreateRegRefMeExpr(const MeExpr &meExpr) {
+  MIRType *mirType = nullptr;
+  switch (meExpr.GetMeOp()) {
+    case kMeOpVar: {
+      auto &varMeExpr = static_cast<const VarMeExpr&>(meExpr);
+      const OriginalSt *ost = varMeExpr.GetOst();
+      ASSERT(ost->GetTyIdx() != 0u, "expect ost->tyIdx to be initialized");
+      mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx());
+      break;
+    }
+    case kMeOpIvar: {
+      auto &ivarMeExpr = static_cast<const IvarMeExpr&>(meExpr);
+      MIRType *ptrMirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr.GetTyIdx());
+      ASSERT(ptrMirType->GetKind() == kTypePointer, "must be point type for ivar");
+      auto *realMirType = static_cast<MIRPtrType*>(ptrMirType);
+      FieldID fieldID = ivarMeExpr.GetFieldID();
+      if (fieldID > 0) {
+        mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(realMirType->GetPointedTyIdxWithFieldID(fieldID));
+      } else {
+        mirType = realMirType->GetPointedType();
+      }
+      ASSERT(mirType->GetPrimType() == meExpr.GetPrimType() ||
+             !(IsAddress(mirType->GetPrimType()) && IsAddress(meExpr.GetPrimType())),
+             "inconsistent type");
+      ASSERT(mirType->GetPrimType() == PTY_ref, "CreateRegRefMeExpr: only ref type expected");
+      break;
+    }
+    case kMeOpOp:
+      if (meExpr.GetOp() == OP_retype) {
+        auto &opMeExpr = static_cast<const OpMeExpr&>(meExpr);
+        ASSERT(opMeExpr.GetTyIdx() != 0u, "expect opMeExpr.tyIdx to be initialized");
+        mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(opMeExpr.GetTyIdx());
+        break;
+      }
+      // fall thru
+      [[clang::fallthrough]];
+    default:
+      return CreateRegMeExpr(PTY_ptr);
+  }
+  return CreateRegMeExpr(*mirType);
+}
+
+VarMeExpr *IRMap::GetOrCreateZeroVersionVarMeExpr(OriginalSt &ost) {
+  ASSERT(ost.GetZeroVersionIndex() != 0,
+         "GetOrCreateZeroVersionVarMeExpr: version index of osym's kInitVersion not set");
+  ASSERT(ost.GetZeroVersionIndex() < verst2MeExprTable.size(),
+         "GetOrCreateZeroVersionVarMeExpr: version index of osym's kInitVersion out of range");
+  if (verst2MeExprTable[ost.GetZeroVersionIndex()] == nullptr) {
+    auto *varMeExpr = New<VarMeExpr>(exprID++, &ost, ost.GetZeroVersionIndex(),
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost.GetTyIdx())->GetPrimType());
+    ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check");
+    verst2MeExprTable[ost.GetZeroVersionIndex()] = varMeExpr;
+    return varMeExpr;
+  }
+  return static_cast<VarMeExpr*>(verst2MeExprTable[ost.GetZeroVersionIndex()]);
+}
+
+IvarMeExpr *IRMap::BuildLHSIvar(MeExpr &baseAddr, PrimType primType, const TyIdx &tyIdx, FieldID fieldID) {
+  auto *meDef = New<IvarMeExpr>(&irMapAlloc, exprID++, primType, tyIdx, fieldID);
+  meDef->SetBase(&baseAddr);
+  PutToBucket(meDef->GetHashIndex() % mapHashLength, *meDef);
+  return meDef;
+}
+
+static std::pair<MeExpr*, MeExpr*> GetTerminalBase(MeExpr *baseExpr) {
+  if (baseExpr->GetMeOp() == kMeOpOp &&
+      IsPrimitiveInteger(baseExpr->GetPrimType()) &&
+      (baseExpr->GetOp() == OP_add || baseExpr->GetOp() == OP_sub || baseExpr->GetOp() == OP_cvt)) {
+    auto ret = GetTerminalBase(static_cast<OpMeExpr *>(baseExpr)->GetOpnd(0));
+    if (ret.first == nullptr) {
+      ret.first = baseExpr;
+    }
+    return ret;
+  }
+  return std::make_pair(nullptr, baseExpr);
+}
+
+MeExpr* IRMap::SimplifyIvarWithConstOffset(IvarMeExpr *ivar, bool lhsIvar) {
+  if (ivar->simplifiedWithConstOffset) {
+    return nullptr;
+  }
+  auto *base = ivar->GetBase();
+  if (base->GetOp() == OP_add || base->GetOp() == OP_sub) {
+    MeExpr *offsetNode = base->GetOpnd(1);
+    if (offsetNode->GetOp() == OP_constval) {
+      auto foundTerminal = GetTerminalBase(base);
+      ScalarMeExpr *ptrVar = dynamic_cast<ScalarMeExpr *>(foundTerminal.second);
+      MeExpr *newBase = nullptr;
+      int32 offsetVal = 0;
+      bool dontRecurse = false;
+      if ((ptrVar == nullptr || ptrVar->GetOst()->isPtrWithIncDec || !MeOption::strengthReduction)) {
+        // get offset value
+        auto *mirConst = static_cast<ConstMeExpr*>(offsetNode)->GetConstVal();
+        CHECK_FATAL(mirConst->GetKind() == kConstInt, "must be integer const");
+        auto offsetInByte = static_cast<MIRIntConst*>(mirConst)->GetExtValue();
+        OffsetType offset(ivar->GetOffset());
+        offset += (base->GetOp() == OP_add ? offsetInByte : -offsetInByte);
+        if (offset.IsInvalid()) {
+          return nullptr;
+        }
+        newBase = base->GetOpnd(0);
+        offsetVal = offset.val;
+      } else {
+        dontRecurse = true;
+        offsetVal = ivar->GetOffset();
+        // reassociate the base expression such that the constant is added directly to ptrVar
+        MeExpr *newAddSub = CreateMeExprBinary(base->GetOp(), ptrVar->GetPrimType(), *ptrVar, *offsetNode);
+        if (ptrVar == base->GetOpnd(0)) {
+          newBase = newAddSub;
+        } else {
+          OpMeExpr newTerminal(*static_cast<OpMeExpr *>(foundTerminal.first), kInvalidExprID);
+          auto *newTerminalAddSub = ReplaceMeExprExpr(*foundTerminal.first, newTerminal, 1, *ptrVar, *newAddSub);
+          if (foundTerminal.first == base->GetOpnd(0)) {
+            newBase = newTerminalAddSub;
+          } else {
+            OpMeExpr newMeExpr(*static_cast<OpMeExpr *>(base->GetOpnd(0)), kInvalidExprID);
+            newBase = ReplaceMeExprExpr(*base->GetOpnd(0), newMeExpr, 1, *foundTerminal.first, *newTerminalAddSub);
+          }
+        }
+      }
+      Opcode op = (offsetVal == 0) ? OP_iread : OP_ireadoff;
+      IvarMeExpr *formedIvar = nullptr;
+      if (lhsIvar) {
+        formedIvar =
+            New<IvarMeExpr>(&irMapAlloc, exprID++, ivar->GetPrimType(), ivar->GetTyIdx(), ivar->GetFieldID(), op);
+        formedIvar->SetBase(newBase);
+        formedIvar->SetOffset(offsetVal);
+        formedIvar->SetMuList(ivar->GetMuList());
+        formedIvar->SetVolatileFromBaseSymbol(ivar->GetVolatileFromBaseSymbol());
+        PutToBucket(formedIvar->GetHashIndex() % mapHashLength, *formedIvar);
+      } else {
+        IvarMeExpr newIvar(&irMapAlloc, kInvalidExprID, ivar->GetPrimType(), ivar->GetTyIdx(), ivar->GetFieldID(), op);
+        newIvar.SetBase(newBase);
+        newIvar.SetOffset(offsetVal);
+        newIvar.SetMuList(ivar->GetMuList());
+        newIvar.SetVolatileFromBaseSymbol(ivar->GetVolatileFromBaseSymbol());
+        formedIvar = static_cast<IvarMeExpr *>(HashMeExpr(newIvar));
+      }
+      IvarMeExpr *nextSimplifiedIvar = nullptr;
+      if (!dontRecurse) {
+        nextSimplifiedIvar = static_cast<IvarMeExpr *>(SimplifyIvarWithConstOffset(formedIvar, lhsIvar));
+      }
+      if (nextSimplifiedIvar == nullptr) {
+        formedIvar->simplifiedWithConstOffset = true;
+        return formedIvar;
+      } else {
+        return nextSimplifiedIvar;
+      }
+    }
+  }
+  return nullptr;
+}
+
+MeExpr *IRMap::GetSimplifiedVarForIvarWithAddrofBase(OriginalSt &ost, IvarMeExpr &ivar) {
+  auto ostIdx = ost.GetIndex();
+
+  auto mu = ivar.GetUniqueMu();
+  if (mu == nullptr) {
+    return nullptr;
+  }
+  if (mu->GetOstIdx() == ostIdx) {
+    return static_cast<VarMeExpr*>(mu);
+  }
+
+  MeStmt *meStmt = mu->GetDefByMeStmt();
+  if (meStmt != nullptr) {
+    auto lhs = meStmt->GetVarLHS();
+    if (lhs != nullptr && lhs->GetOstIdx() == ostIdx) {
+      return static_cast<VarMeExpr *>(lhs);
+    }
+    auto *chiList = meStmt->GetChiList();
+    if (chiList->find(ostIdx) != chiList->end()) {
+      return static_cast<VarMeExpr *>(chiList->at(ostIdx)->GetLHS());
+    }
+  } else if (mu->GetDefBy() == kDefByPhi) {
+    auto *defBBOfPhi = mu->GetDefPhi().GetDefBB();
+    if (defBBOfPhi == nullptr) {
+      return nullptr;
+    }
+    const auto &phiList = defBBOfPhi->GetMePhiList();
+    auto it = phiList.find(ostIdx);
+    return (it != phiList.end()) ? it->second->GetLHS() : nullptr;
+  } else if (mu->GetDefBy() == kDefByNo) {
+    return GetOrCreateZeroVersionVarMeExpr(ost);
+  }
+  return nullptr;
+}
+
+MeExpr *IRMap::SimplifyIvarWithAddrofBase(IvarMeExpr *ivar) {
+  if (ivar->HasMultipleMu() || ivar->IsVolatile()) {
+    return nullptr;
+  }
+  auto *base = ivar->GetBase();
+  if (base->GetOp() != OP_addrof) {
+    return nullptr;
+  }
+
+  auto *addrofExpr = static_cast<const AddrofMeExpr *>(base);
+  auto *ost = addrofExpr->GetOst();
+  auto *typeOfIvar = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar->GetTyIdx());
+  CHECK_FATAL(typeOfIvar->IsMIRPtrType(), "type of ivar must be ptr");
+  CHECK_FATAL(ost, "ost is nullptr!");
+  auto *ptrTypeOfIvar = static_cast<MIRPtrType *>(typeOfIvar);
+  OffsetType offset(0);
+  if (addrofExpr->GetFieldID() > 1) {
+    auto *type = ost->GetMIRSymbol()->GetType();
+    offset += type->GetBitOffsetFromBaseAddr(addrofExpr->GetFieldID());
+  }
+  if (ivar->GetFieldID() > 1) {
+    offset += ptrTypeOfIvar->GetPointedType()->GetBitOffsetFromBaseAddr(ivar->GetFieldID());
+  }
+  if (ptrTypeOfIvar->GetPointedTyIdx() != ost->GetTyIdx()) {
+    // Special case: anytype ** <--> anytype **
+    // requirements: pointer to pointers
+    // XXXX (iread a64 <* <* type>> (addrof a64 %a))
+    // simplify to ===>
+    // XXXX (dread a64 %a)
+    bool areBothPtrToPtr = ptrTypeOfIvar->GetPointedType()->IsMIRPtrType() && ost->GetType()->IsMIRPtrType();
+    if (areBothPtrToPtr && ivar->GetOffset() == 0) {
+      return GetSimplifiedVarForIvarWithAddrofBase(*ost, *ivar);
+    }
+    //  dassign u64 %b 0 (dread u64 %x)
+    //  dassign u32 %c 0 (iread u32 <* u8> 0 (addrof ptr %b, constval u64 1))
+    //  simplify to ===>
+    //  dassign u64 %b 0 (dread u64 %x)
+    //  dassign u32 %c 0 (extractbits u32 8 8 (dread u64 %b))
+    auto *mu = ivar->GetUniqueMu();
+    if (mu != nullptr && mu->GetOst() == ost) {
+      MeStmt *meStmt = mu->GetDefByMeStmt();
+      if (meStmt == nullptr ||  meStmt->GetVarLHS() == nullptr ||
+          !IsPrimitiveInteger(meStmt->GetVarLHS()->GetPrimType()) ||
+          !IsPrimitiveInteger(ivar->GetPrimType())) {
+        return nullptr;
+      }
+      offset += ivar->GetOffset();
+      if (offset.val > 7) {  // allowed max byte offset is 7
+        return nullptr;
+      }
+      auto bitOffset = offset.val * 8;  // change byte offset to bit offset
+      auto bitSize = GetPrimTypeBitSize(ptrTypeOfIvar->GetPointedType()->GetPrimType());
+      auto *srcRHS = meStmt->GetRHS();
+      if (srcRHS->GetPrimType() != ivar->GetPrimType()) {
+        srcRHS = CreateMeExprTypeCvt(ivar->GetPrimType(), srcRHS->GetPrimType(), *srcRHS);
+      }
+      auto *extract = CreateMeExprUnary(OP_extractbits, ivar->GetPrimType(), *srcRHS);
+      static_cast<OpMeExpr *>(extract)->SetBitsSize(static_cast<uint8>(bitSize));
+      static_cast<OpMeExpr *>(extract)->SetBitsOffSet(static_cast<uint8>(bitOffset));
+      return extract;
+    }
+    return nullptr;
+  }
+
+  if (ivar->GetOffset() != 0) {
+    return nullptr;
+  }
+
+  auto fieldTypeIdx = ptrTypeOfIvar->GetPointedTyIdxWithFieldID(ivar->GetFieldID());
+  auto *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTypeIdx);
+  if (offset.IsInvalid()) {
+    return nullptr;
+  }
+  auto *siblingOsts = ssaTab.GetNextLevelOsts(ost->GetPointerVstIdx());
+  FieldID fld = ivar->GetFieldID() + addrofExpr->GetFieldID();
+  auto fieldOst = ssaTab.GetOriginalStTable().FindExtraLevOriginalSt(*siblingOsts, ost->GetPointerTyIdx(),
+                                                                     fieldType, fld, offset);
+  if (fieldOst == nullptr) {
+    return nullptr;
+  }
+  return GetSimplifiedVarForIvarWithAddrofBase(*fieldOst, *ivar);
+}
+
+MeExpr *IRMap::SimplifyIvarWithIaddrofBase(IvarMeExpr *ivar, bool lhsIvar) {
+  if (ivar->GetOffset() != 0 || ivar->IsVolatile()) {
+    return nullptr;
+  }
+
+  auto *base = ivar->GetBase();
+  if (base->GetOp() != OP_iaddrof) {
+    return nullptr;
+  }
+
+  auto *iaddrofExpr = static_cast<const OpMeExpr *>(base);
+  auto baseAddr = iaddrofExpr->GetOpnd(0);
+  auto *ireadPtrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar->GetTyIdx());
+  CHECK_FATAL(ireadPtrType->IsMIRPtrType(), "must be pointer");
+  auto ireadTyIdx = static_cast<MIRPtrType *>(ireadPtrType)->GetPointedTyIdx();
+  auto iaddrofPtrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iaddrofExpr->GetTyIdx());
+  CHECK_FATAL(iaddrofPtrType->IsMIRPtrType(), "must be pointer");
+  auto iaddrofTyIdx = static_cast<MIRPtrType *>(iaddrofPtrType)->GetPointedTyIdxWithFieldID(iaddrofExpr->GetFieldID());
+  if (ireadTyIdx != iaddrofTyIdx) {
+    return nullptr;
+  }
+
+  FieldID newFieldId = ivar->GetFieldID() + iaddrofExpr->GetFieldID();
+
+  if (lhsIvar) {
+    return BuildLHSIvar(*baseAddr, ivar->GetPrimType(), iaddrofExpr->GetTyIdx(), newFieldId);
+  } else {
+    IvarMeExpr newIvar(&irMapAlloc, kInvalidExprID, ivar->GetPrimType(), iaddrofExpr->GetTyIdx(), newFieldId);
+    newIvar.SetBase(baseAddr);
+    newIvar.SetMuList(ivar->GetMuList());
+    newIvar.SetVolatileFromBaseSymbol(ivar->GetVolatileFromBaseSymbol());
+    auto *retExpr = HashMeExpr(newIvar);
+    return retExpr;
+  }
+}
+
+MeExpr *IRMap::SimplifyIvar(IvarMeExpr *ivar, bool lhsIvar) {
+  if (ivar->IsVolatile()) {
+    return nullptr;
+  }
+  auto *simplifiedIvar = SimplifyIvarWithConstOffset(ivar, lhsIvar);
+  if (simplifiedIvar != nullptr) {
+    return simplifiedIvar;
+  }
+
+  simplifiedIvar = SimplifyIvarWithAddrofBase(ivar);
+  if (simplifiedIvar != nullptr) {
+    return simplifiedIvar;
+  }
+
+  simplifiedIvar = SimplifyIvarWithIaddrofBase(ivar, lhsIvar);
+  if (simplifiedIvar != nullptr) {
+    return simplifiedIvar;
+  }
+  return nullptr;
+}
+
+IvarMeExpr *IRMap::BuildLHSIvar(MeExpr &baseAddr, IassignMeStmt &iassignMeStmt, FieldID fieldID) {
+  auto *lhsIvar = iassignMeStmt.GetLHSVal();
+  PrimType primType;
+  if (lhsIvar != nullptr) {
+    primType = lhsIvar->GetPrimType();
+  } else {
+    MIRType *ptrMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iassignMeStmt.GetTyIdx());
+    auto *realMIRType = static_cast<MIRPtrType *>(ptrMIRType);
+    MIRType *ty = nullptr;
+    if (fieldID > 0) {
+      ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(realMIRType->GetPointedTyIdxWithFieldID(fieldID));
+    } else {
+      ty = realMIRType->GetPointedType();
+    }
+    primType = ty->GetPrimType();
+  }
+  auto *meDef = New<IvarMeExpr>(&irMapAlloc, exprID++, primType, iassignMeStmt.GetTyIdx(), fieldID);
+  if (iassignMeStmt.GetLHSVal() != nullptr && iassignMeStmt.GetLHSVal()->GetOffset() != 0) {
+    meDef->SetOp(OP_ireadoff);
+    meDef->SetOffset(iassignMeStmt.GetLHSVal()->GetOffset());
+  }
+  meDef->SetBase(&baseAddr);
+  meDef->SetDefStmt(&iassignMeStmt);
+  PutToBucket(meDef->GetHashIndex() % mapHashLength, *meDef);
+  return meDef;
+}
+
+IvarMeExpr *IRMap::BuildLHSIvarFromIassMeStmt(IassignMeStmt &iassignMeStmt) {
+  IvarMeExpr *ivarx = BuildLHSIvar(*iassignMeStmt.GetLHSVal()->GetBase(), iassignMeStmt,
+                                   iassignMeStmt.GetLHSVal()->GetFieldID());
+  ivarx->SetVolatileFromBaseSymbol(iassignMeStmt.GetLHSVal()->GetVolatileFromBaseSymbol());
+  return ivarx;
+}
+
+void IRMap::PutToBucket(uint32 hashIdx, MeExpr &meExpr) {
+  MeExpr *headExpr = hashTable[hashIdx];
+  if (headExpr != nullptr) {
+    meExpr.SetNext(headExpr);
+  }
+  hashTable[hashIdx] = &meExpr;
+}
+
+MeExpr *IRMap::HashMeExpr(MeExpr &meExpr) {
+  MeExpr *resultExpr = nullptr;
+  uint32 hashIdx = meExpr.GetHashIndex() % mapHashLength;
+  MeExpr *hashedExpr = hashTable[hashIdx];
+
+  if (hashedExpr != nullptr && meExpr.GetMeOp() != kMeOpGcmalloc) {
+    resultExpr = meExpr.GetIdenticalExpr(*hashedExpr, mirModule.CurFunction()->IsConstructor());
+  }
+
+  if (resultExpr == nullptr) {
+    switch (meExpr.GetMeOp()) {
+      case kMeOpIvar:
+        resultExpr = New<IvarMeExpr>(&irMapAlloc, exprID, static_cast<IvarMeExpr&>(meExpr));
+        break;
+      case kMeOpOp:
+        resultExpr = New<OpMeExpr>(static_cast<OpMeExpr&>(meExpr), exprID);
+        break;
+      case kMeOpConst:
+        resultExpr = New<ConstMeExpr>(exprID, static_cast<ConstMeExpr&>(meExpr).GetConstVal(), meExpr.GetPrimType());
+        break;
+      case kMeOpConststr:
+        resultExpr =
+            New<ConststrMeExpr>(exprID, static_cast<ConststrMeExpr&>(meExpr).GetStrIdx(), meExpr.GetPrimType());
+        break;
+      case kMeOpConststr16:
+        resultExpr =
+            New<Conststr16MeExpr>(exprID, static_cast<Conststr16MeExpr&>(meExpr).GetStrIdx(), meExpr.GetPrimType());
+        break;
+      case kMeOpSizeoftype:
+        resultExpr =
+            New<SizeoftypeMeExpr>(exprID, meExpr.GetPrimType(), static_cast<SizeoftypeMeExpr&>(meExpr).GetTyIdx());
+        break;
+      case kMeOpFieldsDist: {
+        auto &expr = static_cast<FieldsDistMeExpr&>(meExpr);
+        resultExpr = New<FieldsDistMeExpr>(exprID, meExpr.GetPrimType(), expr.GetTyIdx(),
+                                           expr.GetFieldID1(), expr.GetFieldID2());
+        break;
+      }
+      case kMeOpAddrof: {
+        auto *ost = static_cast<AddrofMeExpr &>(meExpr).GetOst();
+        CHECK_FATAL(ost != nullptr, "orign st is nullptr!");
+        resultExpr = New<AddrofMeExpr>(exprID, meExpr.GetPrimType(), ost);
+        auto pointerVstIdx = ost->GetPointerVstIdx();
+        if (pointerVstIdx != kInvalidVstIdx) {
+          SetVerst2MeExprTableItem(pointerVstIdx, resultExpr);
+        }
+        break;
+      }
+      case kMeOpNary:
+        resultExpr = NewInPool<NaryMeExpr>(exprID, static_cast<NaryMeExpr&>(meExpr));
+        break;
+      case kMeOpAddroffunc:
+        resultExpr = New<AddroffuncMeExpr>(exprID, static_cast<AddroffuncMeExpr&>(meExpr).GetPuIdx());
+        break;
+      case kMeOpAddroflabel:
+        resultExpr = New<AddroflabelMeExpr>(exprID, static_cast<AddroflabelMeExpr&>(meExpr).labelIdx);
+        break;
+      case kMeOpGcmalloc:
+        resultExpr = New<GcmallocMeExpr>(exprID, meExpr.GetOp(), meExpr.GetPrimType(),
+                                         static_cast<GcmallocMeExpr&>(meExpr).GetTyIdx());
+        break;
+      default:
+        CHECK_FATAL(false, "not yet implement");
+    }
+    ++exprID;
+    PutToBucket(hashIdx, *resultExpr);
+  }
+  return resultExpr;
+}
+
+MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize,
+                                 const MeExpr &meExpr, MeExpr &repExpr) {
+  bool needRehash = false;
+
+  for (size_t i = 0; i < opndsSize; ++i) {
+    MeExpr *origOpnd = origExpr.GetOpnd(i);
+    if (origOpnd == nullptr) {
+      continue;
+    }
+
+    if (origOpnd == &meExpr) {
+      needRehash = true;
+      newExpr.SetOpnd(i, &repExpr);
+    } else if (!origOpnd->IsLeaf()) {
+      newExpr.SetOpnd(i, ReplaceMeExprExpr(*newExpr.GetOpnd(i), meExpr, repExpr));
+      if (newExpr.GetOpnd(i) != origOpnd) {
+        needRehash = true;
+      }
+    }
+  }
+  if (needRehash) {
+    auto simplifiedExpr = SimplifyMeExpr(&newExpr);
+    return simplifiedExpr != &newExpr ? simplifiedExpr : HashMeExpr(newExpr);
+  }
+  return &origExpr;
+}
+
+// replace meExpr with repexpr. meExpr must be a kid of origexpr
+// return repexpr's parent if replaced, otherwise return nullptr
+MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, const MeExpr &meExpr, MeExpr &repExpr) {
+  if (origExpr.IsLeaf()) {
+    return &origExpr;
+  }
+
+  switch (origExpr.GetMeOp()) {
+    case kMeOpOp: {
+      auto &opMeExpr = static_cast<OpMeExpr&>(origExpr);
+      OpMeExpr newMeExpr(opMeExpr, kInvalidExprID);
+      return ReplaceMeExprExpr(opMeExpr, newMeExpr, kOperandNumTernary, meExpr, repExpr);
+    }
+    case kMeOpNary: {
+      auto &naryMeExpr = static_cast<NaryMeExpr&>(origExpr);
+      NaryMeExpr newMeExpr(&irMapAlloc, kInvalidExprID, naryMeExpr);
+      return ReplaceMeExprExpr(naryMeExpr, newMeExpr, naryMeExpr.GetOpnds().size(), meExpr, repExpr);
+    }
+    case kMeOpIvar: {
+      auto &ivarExpr = static_cast<IvarMeExpr&>(origExpr);
+      IvarMeExpr newMeExpr(&irMapAlloc, kInvalidExprID, ivarExpr);
+      bool needRehash = false;
+      if (ivarExpr.GetBase() == &meExpr) {
+        newMeExpr.SetBase(&repExpr);
+        needRehash = true;
+      } else if (!ivarExpr.GetBase()->IsLeaf()) {
+        newMeExpr.SetBase(ReplaceMeExprExpr(*newMeExpr.GetBase(), meExpr, repExpr));
+        if (newMeExpr.GetBase() != ivarExpr.GetBase()) {
+          needRehash = true;
+        }
+      }
+      return needRehash ? HashMeExpr(newMeExpr) : &origExpr;
+    }
+    default:
+      ASSERT(false, "NYI");
+      return nullptr;
+  }
+}
+
+bool IRMap::ReplaceMeExprStmtOpnd(uint32 opndID, MeStmt &meStmt, const MeExpr &meExpr, MeExpr &repExpr) {
+  MeExpr *opnd = meStmt.GetOpnd(opndID);
+
+  if (opnd == &meExpr) {
+    meStmt.SetOpnd(opndID, &repExpr);
+    SimplifyCastForAssign(&meStmt);
+    return true;
+  } else if (!opnd->IsLeaf()) {
+    meStmt.SetOpnd(opndID, ReplaceMeExprExpr(*opnd, meExpr, repExpr));
+    SimplifyCastForAssign(&meStmt);
+    return meStmt.GetOpnd(opndID) != opnd;
+  }
+
+  return false;
+}
+
+// replace meExpr in meStmt with repexpr
+bool IRMap::ReplaceMeExprStmt(MeStmt &meStmt, const MeExpr &meExpr, MeExpr &repexpr) {
+  bool isReplaced = false;
+  Opcode op = meStmt.GetOp();
+
+  for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+    if (op == OP_intrinsiccall || op == OP_xintrinsiccall || op == OP_intrinsiccallwithtype ||
+        op == OP_intrinsiccallassigned || op == OP_xintrinsiccallassigned ||
+        op == OP_intrinsiccallwithtypeassigned) {
+      MeExpr *opnd = meStmt.GetOpnd(i);
+      if (opnd->IsLeaf() && opnd->GetMeOp() == kMeOpVar) {
+        auto *varMeExpr = static_cast<VarMeExpr*>(opnd);
+        const OriginalSt *ost = varMeExpr->GetOst();
+        if (ost->IsSymbolOst() && ost->GetMIRSymbol()->GetAttr(ATTR_static)) {
+          // its address may be taken
+          continue;
+        }
+      }
+    }
+
+    bool curOpndReplaced = false;
+    if (i == 0 && op == OP_iassign) {
+      auto &ivarStmt = static_cast<IassignMeStmt&>(meStmt);
+      if (ivarStmt.GetLHSVal() == &meExpr) {
+        auto *newIvar = static_cast<IvarMeExpr*>(&repexpr);
+        newIvar->SetVolatileFromBaseSymbol(ivarStmt.GetLHSVal()->GetVolatileFromBaseSymbol());
+        ivarStmt.SetLHSVal(newIvar);
+      } else {
+        MeExpr *oldBase = ivarStmt.GetLHSVal()->GetBase();
+        MeExpr *newBase = nullptr;
+        if (oldBase == &meExpr) {
+          newBase = &repexpr;
+          curOpndReplaced = true;
+        } else if (!oldBase->IsLeaf()) {
+          newBase = ReplaceMeExprExpr(*oldBase, meExpr, repexpr);
+          curOpndReplaced = (newBase != oldBase);
+        }
+        if (curOpndReplaced) {
+          ASSERT_NOT_NULL(newBase);
+          auto *newLHS = BuildLHSIvar(*newBase, ivarStmt, ivarStmt.GetLHSVal()->GetFieldID());
+          newLHS->SetVolatileFromBaseSymbol(ivarStmt.GetLHSVal()->GetVolatileFromBaseSymbol());
+          ivarStmt.SetLHSVal(newLHS);
+        }
+      }
+    } else {
+      curOpndReplaced = ReplaceMeExprStmtOpnd(i, meStmt, meExpr, repexpr);
+    }
+    isReplaced = isReplaced || curOpndReplaced;
+  }
+
+  if (isReplaced) {
+    SimplifyCastForAssign(&meStmt);
+  }
+
+  return isReplaced;
+}
+
+MePhiNode *IRMap::CreateMePhi(ScalarMeExpr &meExpr) {
+  auto *phiMeVar = NewInPool<MePhiNode>();
+  phiMeVar->UpdateLHS(meExpr);
+  return phiMeVar;
+}
+
+IassignMeStmt *IRMap::CreateIassignMeStmt(TyIdx tyIdx, IvarMeExpr &lhs, MeExpr &rhs,
+                                          const MapleMap<OStIdx, ChiMeNode*> &clist) {
+  return NewInPool<IassignMeStmt>(tyIdx, &lhs, &rhs, &clist);
+}
+
+AssignMeStmt *IRMap::CreateAssignMeStmt(ScalarMeExpr &lhs, MeExpr &rhs, BB &currBB) {
+  AssignMeStmt *meStmt = nullptr;
+  if (lhs.GetMeOp() == kMeOpReg) {
+    meStmt = New<AssignMeStmt>(OP_regassign, &lhs, &rhs);
+  } else {
+    meStmt = NewInPool<DassignMeStmt>(&static_cast<VarMeExpr &>(lhs), &rhs);
+  }
+  lhs.SetDefBy(kDefByStmt);
+  lhs.SetDefStmt(meStmt);
+  meStmt->SetBB(&currBB);
+  return meStmt;
+}
+
+// get the false goto bb, if condgoto is brtrue, take the other bb of brture @lable
+// otherwise, take the bb of @lable
+const BB *IRMap::GetFalseBrBB(const CondGotoMeStmt &condgoto) {
+  auto lblIdx = LabelIdx(condgoto.GetOffset());
+  BB *gotoBB = GetBBForLabIdx(lblIdx);
+  const BB *bb = condgoto.GetBB();
+  ASSERT(bb->GetSucc().size() == kBBVectorInitialSize, "array size error");
+  if (condgoto.GetOp() == OP_brfalse) {
+    return gotoBB;
+  } else {
+    return gotoBB == bb->GetSucc(0) ? bb->GetSucc(1) : bb->GetSucc(0);
+  }
+}
+
+MeExpr *IRMap::CreateConstMeExpr(PrimType pType, MIRConst &mirConst) {
+  ConstMeExpr constMeExpr(kInvalidExprID, &mirConst, pType);
+  return HashMeExpr(constMeExpr);
+}
+
+MeExpr *IRMap::CreateIntConstMeExpr(const IntVal &value, PrimType pType) {
+  return CreateIntConstMeExpr(value.GetExtValue(), pType);
+}
+
+MeExpr *IRMap::CreateIntConstMeExpr(int64 value, PrimType pType) {
+  auto *intConst =
+      GlobalTables::GetIntConstTable().GetOrCreateIntConst(value, *GlobalTables::GetTypeTable().GetPrimType(pType));
+  return CreateConstMeExpr(pType, *intConst);
+}
+
+MeExpr *IRMap::CreateMeExprUnary(Opcode op, PrimType pType, MeExpr &expr0) {
+  OpMeExpr opMeExpr(kInvalidExprID, op, pType, kOperandNumUnary);
+  opMeExpr.SetOpnd(0, &expr0);
+  return HashMeExpr(opMeExpr);
+}
+
+MeExpr *IRMap::CreateMeExprBinary(Opcode op, PrimType pType, MeExpr &expr0, MeExpr &expr1) {
+  OpMeExpr opMeExpr(kInvalidExprID, op, pType, kOperandNumBinary);
+  opMeExpr.SetOpnd(0, &expr0);
+  opMeExpr.SetOpnd(1, &expr1);
+  opMeExpr.SetHasAddressValue();
+  return HashMeExpr(opMeExpr);
+}
+
+MeExpr *IRMap::CreateMeExprSelect(PrimType pType, MeExpr &expr0, MeExpr &expr1, MeExpr &expr2) {
+  OpMeExpr opMeExpr(kInvalidExprID, OP_select, pType, kOperandNumTernary);
+  opMeExpr.SetOpnd(0, &expr0);
+  opMeExpr.SetOpnd(1, &expr1);
+  opMeExpr.SetOpnd(2, &expr2);
+  opMeExpr.SetHasAddressValue();
+  return HashMeExpr(opMeExpr);
+}
+
+MeExpr *IRMap::CreateMeExprCompare(Opcode op, PrimType resptyp, PrimType opndptyp, MeExpr &opnd0, MeExpr &opnd1) {
+  OpMeExpr opMeExpr(kInvalidExprID, op, resptyp, kOperandNumBinary);
+  opMeExpr.SetOpnd(0, &opnd0);
+  opMeExpr.SetOpnd(1, &opnd1);
+  opMeExpr.SetOpndType(opndptyp);
+  MeExpr *retMeExpr = HashMeExpr(opMeExpr);
+  static_cast<OpMeExpr*>(retMeExpr)->SetOpndType(opndptyp);
+  return retMeExpr;
+}
+
+MeExpr *IRMap::CreateMeExprTypeCvt(PrimType pType, PrimType opndptyp, MeExpr &opnd0) {
+  OpMeExpr opMeExpr(kInvalidExprID, OP_cvt, pType, kOperandNumUnary);
+  opMeExpr.SetOpnd(0, &opnd0);
+  opMeExpr.SetOpndType(opndptyp);
+  if (opndptyp == PTY_i32 && GetPrimTypeSize(pType) == 8) {
+    opMeExpr.SetPtyp(GetSignedPrimType(pType));
+  }
+  return HashMeExpr(opMeExpr);
+}
+
+MeExpr *IRMap::CreateMeExprRetype(PrimType pType, TyIdx tyIdx, MeExpr &opnd) {
+  OpMeExpr opMeExpr(kInvalidExprID, OP_retype, pType, kOperandNumUnary);
+  opMeExpr.SetOpnd(0, &opnd);
+  opMeExpr.SetTyIdx(tyIdx);
+  opMeExpr.SetOpndType(opnd.GetPrimType());
+  return HashMeExpr(opMeExpr);
+}
+
+MeExpr *IRMap::CreateMeExprExt(Opcode op, PrimType pType, uint32 bitsSize, MeExpr &opnd) {
+  ASSERT(op == OP_zext || op == OP_sext, "must be");
+  OpMeExpr opMeExpr(kInvalidExprID, op, pType, kOperandNumUnary);
+  opMeExpr.SetOpnd(0, &opnd);
+  opMeExpr.SetBitsSize(static_cast<uint8>(bitsSize));
+  return HashMeExpr(opMeExpr);
+}
+
+UnaryMeStmt *IRMap::CreateUnaryMeStmt(Opcode op, MeExpr *opnd) {
+  UnaryMeStmt *unaryMeStmt = New<UnaryMeStmt>(op);
+  unaryMeStmt->SetMeStmtOpndValue(opnd);
+  return unaryMeStmt;
+}
+
+UnaryMeStmt *IRMap::CreateUnaryMeStmt(Opcode op, MeExpr *opnd, BB *bb, const SrcPosition *src) {
+  UnaryMeStmt *unaryMeStmt = CreateUnaryMeStmt(op, opnd);
+  unaryMeStmt->SetBB(bb);
+  unaryMeStmt->SetSrcPos(*src);
+  return unaryMeStmt;
+}
+
+RetMeStmt *IRMap::CreateRetMeStmt(MeExpr *opnd) {
+  RetMeStmt *retMeStmt = static_cast<RetMeStmt *>(NewInPool<NaryMeStmt>(OP_return));
+  if (opnd != nullptr) {
+    retMeStmt->PushBackOpnd(opnd);
+  }
+  return retMeStmt;
+}
+
+GotoMeStmt *IRMap::CreateGotoMeStmt(uint32 offset, BB *bb, const SrcPosition *src) {
+  GotoMeStmt *gotoMeStmt = New<GotoMeStmt>(offset);
+  gotoMeStmt->SetBB(bb);
+  if (src != nullptr) {
+    gotoMeStmt->SetSrcPos(*src);
+  }
+  return gotoMeStmt;
+}
+
+IntrinsiccallMeStmt *IRMap::CreateIntrinsicCallMeStmt(MIRIntrinsicID idx, std::vector<MeExpr*> &opnds, TyIdx tyIdx) {
+  auto *meStmt =
+      NewInPool<IntrinsiccallMeStmt>(tyIdx == 0u ? OP_intrinsiccall : OP_intrinsiccallwithtype, idx, tyIdx);
+  for (MeExpr *opnd : opnds) {
+    meStmt->PushBackOpnd(opnd);
+  }
+  return meStmt;
+}
+
+IntrinsiccallMeStmt *IRMap::CreateIntrinsicCallAssignedMeStmt(MIRIntrinsicID idx, std::vector<MeExpr*> &opnds,
+                                                              ScalarMeExpr *ret, TyIdx tyIdx) {
+  auto *meStmt = NewInPool<IntrinsiccallMeStmt>(
+      tyIdx == 0u ? OP_intrinsiccallassigned : OP_intrinsiccallwithtypeassigned, idx, tyIdx);
+  for (MeExpr *opnd : opnds) {
+    meStmt->PushBackOpnd(opnd);
+  }
+  if (ret != nullptr) {
+    auto *mustDef = New<MustDefMeNode>(ret, meStmt);
+    meStmt->GetMustDefList()->push_back(*mustDef);
+  }
+  return meStmt;
+}
+
+MeExpr *IRMap::CreateAddrofMeExprFromSymbol(MIRSymbol &st, PUIdx puIdx) {
+  OriginalSt *baseOst = ssaTab.FindOrCreateSymbolOriginalSt(st, puIdx, 0);
+  if (baseOst->GetZeroVersionIndex() == 0) {
+    baseOst->SetZeroVersionIndex(verst2MeExprTable.size());
+    verst2MeExprTable.push_back(nullptr);
+    baseOst->PushbackVersionsIndices(baseOst->GetZeroVersionIndex());
+  }
+
+  AddrofMeExpr addrOfMe(kInvalidExprID, PTY_ptr, baseOst);
+  return HashMeExpr(addrOfMe);
+}
+
+// (typeA -> typeB -> typeC) => (typeA -> typeC)
+static bool IgnoreInnerTypeCvt(PrimType typeA, PrimType typeB, PrimType typeC) {
+  if (IsPrimitiveInteger(typeA)) {
+    if (IsPrimitiveInteger(typeB)) {
+      if (IsPrimitiveInteger(typeC)) {
+        return (GetPrimTypeSize(typeB) >= GetPrimTypeSize(typeA) || GetPrimTypeSize(typeB) >= GetPrimTypeSize(typeC));
+      } else if (IsPrimitiveFloat(typeC)) {
+        return GetPrimTypeSize(typeB) >= GetPrimTypeSize(typeA) && IsSignedInteger(typeB) == IsSignedInteger(typeA);
+      }
+    } else if (IsPrimitiveFloat(typeB)) {
+      if (IsPrimitiveFloat(typeC)) {
+        return GetPrimTypeSize(typeB) >= GetPrimTypeSize(typeC);
+      }
+    }
+  } else if (IsPrimitiveFloat(typeA)) {
+    if (IsPrimitiveFloat(typeB) && IsPrimitiveFloat(typeC)) {
+      return GetPrimTypeSize(typeB) >= GetPrimTypeSize(typeA) || GetPrimTypeSize(typeB) >= GetPrimTypeSize(typeC);
+    }
+  }
+  return false;
+}
+
+// return nullptr if the result is unknow
+MeExpr *IRMap::SimplifyCompareSameExpr(OpMeExpr *opmeexpr) {
+  if (IsPrimitiveVector(opmeexpr->GetPrimType())) {
+    return nullptr;
+  }
+  CHECK_FATAL(opmeexpr->GetOpnd(0) == opmeexpr->GetOpnd(1), "must be");
+  Opcode opop = opmeexpr->GetOp();
+  int64 val = 0;
+  switch (opop) {
+    case OP_eq:
+    case OP_le:
+    case OP_ge: {
+      val = 1;
+      break;
+    }
+    case OP_ne:
+    case OP_lt:
+    case OP_gt:
+    case OP_cmp: {
+      val = 0;
+      break;
+    }
+    case OP_cmpl:
+    case OP_cmpg: {
+      // cmpl/cmpg is special for cases that any of opnd is NaN
+      auto opndType = opmeexpr->GetOpndType();
+      if (IsPrimitiveFloat(opndType) || IsPrimitiveDynFloat(opndType)) {
+        if (opmeexpr->GetOpnd(0)->GetMeOp() == kMeOpConst) {
+          double dVal =
+              static_cast<MIRFloatConst*>(static_cast<ConstMeExpr *>(opmeexpr->GetOpnd(0))->GetConstVal())->GetValue();
+          if (isnan(dVal)) {
+            val = (opop == OP_cmpl) ? -1 : 1;
+          } else {
+            val = 0;
+          }
+          break;
+        }
+        // other case, return nullptr because it is not sure whether any of opnd is nan.
+        return nullptr;
+      }
+      val = 0;
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "must be compare op!");
+  }
+  return CreateIntConstMeExpr(val, opmeexpr->GetPrimType());
+}
+
+// opA (opB (opndA, opndB), opndC)
+MeExpr *IRMap::CreateCanonicalizedMeExpr(PrimType primType, Opcode opA,  Opcode opB,
+                                         MeExpr *opndA, MeExpr *opndB, MeExpr *opndC) {
+  if (primType != opndC->GetPrimType() && !IsNoCvtNeeded(primType, opndC->GetPrimType())) {
+    opndC = CreateMeExprTypeCvt(primType, opndC->GetPrimType(), *opndC);
+  }
+
+  if (opndA->GetMeOp() == kMeOpConst && opndB->GetMeOp() == kMeOpConst) {
+    auto *constOpnd0 =
+        FoldConstExprBinary(primType, opB, *static_cast<ConstMeExpr *>(opndA), *static_cast<ConstMeExpr *>(opndB));
+
+    if (constOpnd0 != nullptr) {
+      return CreateMeExprBinary(opA, primType, *constOpnd0, *opndC);
+    }
+  }
+
+  if (primType != opndA->GetPrimType() && !IsNoCvtNeeded(primType, opndA->GetPrimType())) {
+    opndA = CreateMeExprTypeCvt(primType, opndA->GetPrimType(), *opndA);
+  }
+  if (primType != opndB->GetPrimType() && !IsNoCvtNeeded(primType, opndB->GetPrimType())) {
+    opndB = CreateMeExprTypeCvt(primType, opndB->GetPrimType(), *opndB);
+  }
+
+  auto *opnd0 = CreateMeExprBinary(opB, primType, *opndA, *opndB);
+  return CreateMeExprBinary(opA, primType, *opnd0, *opndC);
+}
+
+// opA (opndA, opB (opndB, opndC))
+MeExpr *IRMap::CreateCanonicalizedMeExpr(PrimType primType, Opcode opA, MeExpr *opndA,
+                                         Opcode opB, MeExpr *opndB, MeExpr *opndC) {
+  if (primType != opndA->GetPrimType() && !IsNoCvtNeeded(primType, opndA->GetPrimType())) {
+    opndA = CreateMeExprTypeCvt(primType, opndA->GetPrimType(), *opndA);
+  }
+
+  if (opndB->GetMeOp() == kMeOpConst && opndC->GetMeOp() == kMeOpConst) {
+    auto *constOpnd1 =
+        FoldConstExprBinary(primType, opB, *static_cast<ConstMeExpr *>(opndB), *static_cast<ConstMeExpr *>(opndC));
+    if (constOpnd1 != nullptr) {
+      return CreateMeExprBinary(opA, primType, *opndA, *constOpnd1);
+    }
+  }
+
+  if (primType != opndB->GetPrimType() && !IsNoCvtNeeded(primType, opndB->GetPrimType())) {
+    opndB = CreateMeExprTypeCvt(primType, opndB->GetPrimType(), *opndB);
+  }
+  if (primType != opndC->GetPrimType() && !IsNoCvtNeeded(primType, opndC->GetPrimType())) {
+    opndC = CreateMeExprTypeCvt(primType, opndC->GetPrimType(), *opndC);
+  }
+  auto *opnd1 = CreateMeExprBinary(opB, primType, *opndB, *opndC);
+  return CreateMeExprBinary(opA, primType, *opndA, *opnd1);
+}
+
+// opA (opB (opndA, opndB), opC (opndC, opndD))
+MeExpr *IRMap::CreateCanonicalizedMeExpr(PrimType primType, Opcode opA, Opcode opB, MeExpr *opndA, MeExpr *opndB,
+                                         Opcode opC, MeExpr *opndC, MeExpr *opndD) {
+  MeExpr *newOpnd0 = nullptr;
+  if (opndA->GetMeOp() == kMeOpConst && opndB->GetMeOp() == kMeOpConst) {
+    newOpnd0 = FoldConstExprBinary(primType, opB, *static_cast<ConstMeExpr*>(opndA), *static_cast<ConstMeExpr*>(opndB));
+  }
+  if (newOpnd0 == nullptr) {
+    if (primType != opndA->GetPrimType() && !IsNoCvtNeeded(primType, opndA->GetPrimType())) {
+      opndA = CreateMeExprTypeCvt(primType, opndA->GetPrimType(), *opndA);
+    }
+    if (primType != opndB->GetPrimType() && !IsNoCvtNeeded(primType, opndB->GetPrimType())) {
+      opndB = CreateMeExprTypeCvt(primType, opndB->GetPrimType(), *opndB);
+    }
+    newOpnd0 = CreateMeExprBinary(opB, primType, *opndA, *opndB);
+  }
+
+  MeExpr *newOpnd1 = nullptr;
+  if (opndC->GetMeOp() == kMeOpConst && opndD->GetMeOp() == kMeOpConst) {
+    newOpnd1 = FoldConstExprBinary(primType, opC, *static_cast<ConstMeExpr*>(opndC), *static_cast<ConstMeExpr*>(opndD));
+  }
+  if (newOpnd1 == nullptr) {
+    if (primType != opndC->GetPrimType() && !IsNoCvtNeeded(primType, opndC->GetPrimType())) {
+      opndC = CreateMeExprTypeCvt(primType, opndC->GetPrimType(), *opndC);
+    }
+    if (primType != opndD->GetPrimType() && !IsNoCvtNeeded(primType, opndD->GetPrimType())) {
+      opndD = CreateMeExprTypeCvt(primType, opndD->GetPrimType(), *opndD);
+    }
+    newOpnd1 = CreateMeExprBinary(opC, primType, *opndC, *opndD);
+  }
+  return CreateMeExprBinary(opA, primType, *newOpnd0, *newOpnd1);
+}
+
+MeExpr *IRMap::FoldConstExprBinary(PrimType primType, Opcode op, ConstMeExpr &opndA, ConstMeExpr &opndB) {
+  if (!IsPrimitiveInteger(primType)) {
+    return nullptr;
+  }
+
+  auto *constA = static_cast<MIRIntConst*>(opndA.GetConstVal());
+  auto *constB = static_cast<MIRIntConst*>(opndB.GetConstVal());
+  if ((op == OP_div || op == OP_rem) && !IsDivSafe(*constA, *constB, primType)) {
+    return nullptr;
+  }
+  MIRConst *resconst = ConstantFold::FoldIntConstBinaryMIRConst(op, primType, constA, constB);
+  return CreateConstMeExpr(primType, *resconst);
+}
+
+MeExpr *IRMap::FoldConstExprUnary(PrimType primType, Opcode op, ConstMeExpr &opnd) {
+  if (!IsPrimitiveInteger(primType)) {
+    return nullptr;
+  }
+
+  auto *constInt = static_cast<MIRIntConst *>(opnd.GetConstVal());
+  MIRConst *resconst = ConstantFold::FoldIntConstUnaryMIRConst(op, primType, constInt);
+  return CreateConstMeExpr(primType, *resconst);
+}
+
+static bool CanDoOutOfShift(const OpMeExpr &shiftExpr, const MeExpr &expr) {
+  switch (expr.GetOp()) {
+    case OP_add:
+      return shiftExpr.GetOp() == OP_shl;
+    // bior/band can also be done out of shift, however it will prevent byte reverse optimize, so it is removed
+    case OP_bxor: {
+      auto c = static_cast<const ConstMeExpr *>(expr.GetOpnd(1))->GetIntValue();
+      return !c.IsMaxValue();
+    }
+    default:
+      return false;
+  }
+}
+
+static MeExpr *SimplifyCommonLogicShift(IRMap &irMap, const OpMeExpr &meExpr) {
+  MeExpr *opnd0 = meExpr.GetOpnd(0);
+  MeExpr *opnd1 = meExpr.GetOpnd(1);
+  if (opnd0->GetMeOp() == kMeOpOp && opnd1->GetMeOp() == kMeOpConst) {
+    auto expr1 = opnd0->GetOpnd(0);
+    auto expr2 = opnd0->GetOpnd(1);
+    if (!expr2 || expr2->GetMeOp() != kMeOpConst) {
+      return nullptr;
+    }
+    // shl (op (opndA, opndB), opndC) -> op (shl (opndA, opndC), shl (opndB, opndC))
+    if (CanDoOutOfShift(meExpr, *opnd0)) {
+      auto newRhs = irMap.FoldConstExprBinary(meExpr.GetPrimType(), meExpr.GetOp(), *static_cast<ConstMeExpr *>(expr2),
+                                              *static_cast<ConstMeExpr *>(opnd1));
+      auto newShift = irMap.CreateMeExprBinary(meExpr.GetOp(), meExpr.GetPrimType(), *expr1, *opnd1);
+      auto res = irMap.CreateMeExprBinary(opnd0->GetOp(), meExpr.GetPrimType(), *newShift, *newRhs);
+      return res;
+    }
+  }
+  return nullptr;
+}
+
+static MeExpr *PullOutZext(IRMap &irMap, const OpMeExpr &meExpr) {
+  MeExpr *opnd0 = meExpr.GetOpnd(0);
+  MeExpr *opnd1 = meExpr.GetOpnd(1);
+  if (opnd0->GetOp() == OP_zext && opnd1->GetMeOp() == kMeOpConst) {
+    auto subExpr1 = opnd0->GetOpnd(0);
+    auto op0 = static_cast<OpMeExpr *>(opnd0);
+    if (op0->GetBitsSize() < GetPrimTypeBitSize(subExpr1->GetPrimType())) {
+      return nullptr;
+    }
+    auto c1 = static_cast<ConstMeExpr *>(opnd1)->GetIntValue();
+    // It is undefined behavior when shift num not less than bit size of primtype
+    if (IsLogicalShift(meExpr.GetOp()) && GetAlignedPrimTypeBitSize(subExpr1->GetPrimType()) <= c1.GetZXTValue()) {
+      return nullptr;
+    }
+
+    // if c1 == zext(trunc(c1)), we can pull zext out
+    if (c1.GetZXTValue() == c1.Trunc(op0->GetBitsSize(), c1.IsSigned()).GetZXTValue()) {
+      auto newConst = irMap.CreateIntConstMeExpr(c1.Trunc(subExpr1->GetPrimType()), subExpr1->GetPrimType());
+      auto newExpr = irMap.CreateMeExprBinary(meExpr.GetOp(), subExpr1->GetPrimType(), *subExpr1, *newConst);
+      auto res = irMap.CreateMeExprUnary(OP_zext, meExpr.GetPrimType(), *newExpr);
+      static_cast<OpMeExpr *>(res)->SetBitsSize(op0->GetBitsSize());
+      return res;
+    }
+  }
+  return nullptr;
+}
+
+// count coutinuous bit 1 from right hand side
+static int32 CountrOne(uint64 val) {
+  int32 count = 0;
+  while ((val & 1) != 0) {
+    ++count;
+    val >>= 1;
+  }
+  return val == 0 ? count : static_cast<int32>(-1);
+};
+
+MeExpr *IRMap::SimplifyLshrExpr(const OpMeExpr *shrExpr) {
+  MeExpr *opnd0 = shrExpr->GetOpnd(0);
+  MeExpr *opnd1 = shrExpr->GetOpnd(1);
+
+  // (a & c1) >> c2 == (a >> c2) & (c1 >> c2)
+  // try simplify when (c1 >> c2) is continuous bits 1
+  // then (a & c1) >> c2 == extract (bit 1 count) bits from (c2) offset of (a)
+  auto trySimplifyToExtractbits = [this, shrExpr](MeExpr *band, ConstMeExpr *shrConst)->MeExpr* {
+    auto *opnd0 = band->GetOpnd(0);
+    auto *opnd1 = band->GetOpnd(1);
+    auto shrOffset = static_cast<ConstMeExpr*>(shrConst)->GetExtIntValue();
+    if (opnd0->GetMeOp() != kMeOpConst && opnd1->GetMeOp() != kMeOpConst) {
+      return nullptr;
+    }
+    if (opnd0->GetMeOp() != kMeOpConst) {
+      opnd0 = opnd1;
+      opnd1 = band->GetOpnd(0);
+    }
+    int64 const0 = static_cast<ConstMeExpr*>(opnd0)->GetExtIntValue();
+    if (GetPrimTypeSize(opnd0->GetPrimType()) < GetPrimTypeSize(PTY_u64)) {
+      const0 = static_cast<int64>(static_cast<uint32>(const0));
+    }
+    auto bitOneCount = CountrOne(static_cast<uint64>(const0) >> static_cast<uint64>(shrOffset));
+    if (bitOneCount == -1) {
+      return nullptr;
+    } else if (bitOneCount == 0) {
+      return CreateIntConstMeExpr(0, shrExpr->GetPrimType());
+    } else {
+      if (bitOneCount + static_cast<int32>(shrOffset) > GetPrimTypeBitSize(shrExpr->GetPrimType())) {
+        return CreateIntConstMeExpr(0, shrExpr->GetPrimType());
+      }
+      auto *ret = CreateMeExprUnary(OP_extractbits, GetUnsignedPrimType(shrExpr->GetPrimType()), *opnd1);
+      static_cast<OpMeExpr*>(ret)->SetBitsOffSet(static_cast<uint8>(shrOffset));
+      static_cast<OpMeExpr*>(ret)->SetBitsSize(static_cast<uint8>(bitOneCount));
+      return ret;
+    }
+  };
+  if (opnd0->GetOp() == OP_band && opnd1->GetMeOp() == kMeOpConst) {
+    if (MeExpr *res = trySimplifyToExtractbits(opnd0, static_cast<ConstMeExpr *>(opnd1))) {
+      return res;
+    }
+  }
+  if (MeExpr *res = SimplifyCommonLogicShift(*this, *shrExpr)) {
+    return res;
+  }
+  if (MeExpr *res = PullOutZext(*this, *shrExpr)) {
+    return res;
+  }
+  return nullptr;
+}
+
+MeExpr *IRMap::SimplifyShlExpr(const OpMeExpr *shrExpr) {
+  if (MeExpr *res = SimplifyCommonLogicShift(*this, *shrExpr)) {
+    return res;
+  }
+  return nullptr;
+}
+
+static MeExpr *SimplifyBandWithConst(IRMap &irMap, const OpMeExpr &bandExpr) {
+  MeExpr *opnd0 = bandExpr.GetOpnd(0);
+  MeExpr *opnd1 = bandExpr.GetOpnd(1);
+  if (opnd0->GetMeOp() != kMeOpOp || opnd1->GetMeOp() != kMeOpConst) {
+    return nullptr;
+  }
+  auto c1 = static_cast<ConstMeExpr*>(opnd1)->GetIntValue();
+  auto op0 = opnd0->GetOp();
+  // band ( zext u32 size (x), c1)
+  // if (1 << size) > c1, we can remove zext
+  if (op0 == OP_zext || op0 == OP_sext || op0 == OP_extractbits) {
+    auto opExpr = static_cast<OpMeExpr*>(opnd0);
+    auto offset = opExpr->GetBitsOffSet();
+    auto size = opExpr->GetBitsSize();
+    if (offset == 0 && (1ull << size) > c1.GetZXTValue()) {
+      return irMap.CreateMeExprBinary(OP_band, bandExpr.GetPrimType(), *opnd0->GetOpnd(0), *opnd1);
+    }
+  }
+  return nullptr;
+}
+
+// band ( lshr/shl(x, c2), c1)
+// if shl/lshr(~c1, c2) == 0, we can remove band
+static MeExpr *DoBandEliminate(const OpMeExpr &bandExpr) {
+  MeExpr *opnd0 = bandExpr.GetOpnd(0);
+  MeExpr *opnd1 = bandExpr.GetOpnd(1);
+  if (opnd0->GetOp() == OP_cvt) {
+    opnd0 = opnd0->GetOpnd(0);
+  }
+
+  if (opnd1->GetMeOp() != kMeOpConst || !IsLogicalShift(opnd0->GetOp())) {
+    return nullptr;
+  }
+  auto expr1 = opnd0->GetOpnd(0);
+  auto expr2 = opnd0->GetOpnd(1);
+  if (expr2->GetMeOp() != kMeOpConst) {
+    return nullptr;
+  }
+  auto srcType = expr1->GetPrimType();
+  auto c1 = static_cast<ConstMeExpr *>(opnd1)->GetIntValue().TruncOrExtend(srcType);
+  auto c2 = static_cast<ConstMeExpr *>(expr2)->GetIntValue().TruncOrExtend(srcType);
+  auto c3 = ~c1.TruncOrExtend(srcType);
+  if (c2.GetZXTValue() >= GetPrimTypeBitSize(expr1->GetPrimType())) {
+    return nullptr;
+  }
+  if (opnd0->GetOp() == OP_lshr) {
+    c3 = c3.Shl(c2.GetZXTValue(), srcType);
+  } else {
+    c3 = c3.LShr(c2.GetZXTValue(), srcType);
+  }
+  if (c3 == 0) {
+    return opnd0;
+  }
+  return nullptr;
+}
+
+// a & (a | b) == a
+// try to simplify (a | b) & c == (a & c) | (b & c)
+static MeExpr *SimplifyBiorBand(IRMap &irMap, const MeExpr &band, const MeExpr &bior, MeExpr &anotherOpnd) {
+  if (static_cast<const OpMeExpr &>(bior).GetOpnd(0) == &anotherOpnd ||
+      static_cast<const OpMeExpr &>(bior).GetOpnd(1) == &anotherOpnd) {
+    return &anotherOpnd;
+  }
+  // form a & c
+  OpMeExpr distribute1(kInvalidExprID, OP_band, band.GetPrimType(), bior.GetOpnd(0), &anotherOpnd);
+  // form b & c
+  OpMeExpr distribute2(kInvalidExprID, OP_band, band.GetPrimType(), bior.GetOpnd(1), &anotherOpnd);
+  auto *simplified1 = irMap.SimplifyOpMeExpr(&distribute1);
+  auto *simplified2 = irMap.SimplifyOpMeExpr(&distribute2);
+  if (simplified1 && simplified2 && simplified1->GetDepth() + simplified2->GetDepth() + 1 < band.GetDepth()) {
+    return irMap.CreateMeExprBinary(OP_bior, band.GetPrimType(), *simplified1, *simplified2);
+  }
+  return nullptr;
+};
+
+MeExpr *IRMap::SimplifyBandExpr(const OpMeExpr *bandExpr) {
+  MeExpr *opnd0 = bandExpr->GetOpnd(0);
+  MeExpr *opnd1 = bandExpr->GetOpnd(1);
+
+  // fold band with same value
+  if (opnd0 == opnd1) {
+    return opnd0;
+  }
+
+  if (MeExpr *res = SimplifyBandWithConst(*this, *bandExpr)) {
+    return res;
+  }
+
+  if (MeExpr *res = DoBandEliminate(*bandExpr)) {
+    return res;
+  }
+
+  if (MeExpr *res = PullOutZext(*this, *bandExpr)) {
+    return res;
+  }
+
+  if (IsCompareHasReverseOp(opnd0->GetOp()) || IsCompareHasReverseOp(opnd1->GetOp())) {
+    return ConstantFold::FoldCmpExpr(*this, *opnd0, *opnd1, true);
+  }
+
+  if (opnd0->GetOp() != OP_band && opnd1->GetOp() != OP_band) {
+    return nullptr;
+  }
+
+  // a & b & a == a & b
+  if (opnd0->GetOp() == OP_band) {
+    if (static_cast<OpMeExpr *>(opnd0)->GetOpnd(0) == opnd1 || static_cast<OpMeExpr *>(opnd0)->GetOpnd(1) == opnd1) {
+      return opnd0;
+    }
+  }
+  if (opnd1->GetOp() == OP_band) {
+    if (static_cast<OpMeExpr *>(opnd1)->GetOpnd(0) == opnd0 || static_cast<OpMeExpr *>(opnd1)->GetOpnd(1) == opnd0) {
+      return opnd1;
+    }
+  }
+
+  if (opnd0->GetOp() == OP_bior) {
+    auto *simplified = SimplifyBiorBand(*this, *bandExpr, *opnd0, *opnd1);
+    if (simplified) {
+      return simplified;
+    }
+  }
+  if (opnd1->GetOp() == OP_bior) {
+    auto *simplified = SimplifyBiorBand(*this, *bandExpr, *opnd1, *opnd0);
+    if (simplified) {
+      return simplified;
+    }
+  }
+  return nullptr;
+}
+
+MeExpr *IRMap::SimplifySubExpr(const OpMeExpr *subExpr) {
+  MeExpr *opnd0 = subExpr->GetOpnd(0);
+  MeExpr *opnd1 = subExpr->GetOpnd(1);
+  auto subExprPrimType = subExpr->GetPrimType();
+
+  // a - (a & b) == a & (~b)
+  if (opnd1->GetOp() == OP_band) {
+    if (opnd1->GetOpnd(0) == opnd0) {
+      auto *bnot = CreateMeExprUnary(OP_bnot, opnd1->GetOpnd(1)->GetPrimType(), *opnd1->GetOpnd(1));
+      return CreateMeExprBinary(OP_band, subExprPrimType, *opnd0, *bnot);
+    }
+    if (opnd1->GetOpnd(1) == opnd0) {
+      auto *bnot = CreateMeExprUnary(OP_bnot, opnd1->GetOpnd(0)->GetPrimType(), *opnd1->GetOpnd(0));
+      return CreateMeExprBinary(OP_band, subExprPrimType, *opnd0, *bnot);
+    }
+  }
+
+  // addrof a64 %a c0 - addrof a64 %a c1 == offset between field_c0 and field_c1
+  if (opnd0->GetOp() == OP_addrof && opnd1->GetOp() == OP_addrof) {
+    auto ost0 = ssaTab.GetOriginalStFromID(static_cast<AddrofMeExpr*>(opnd0)->GetOstIdx());
+    auto prevLevelOfOst0 = ost0->GetPrevLevelOst();
+    auto ost1 = ssaTab.GetOriginalStFromID(static_cast<AddrofMeExpr*>(opnd1)->GetOstIdx());
+    auto prevLevelOfOst1 = ost1->GetPrevLevelOst();
+    bool isPrevLevelOfOstSame = prevLevelOfOst0 != nullptr && prevLevelOfOst1 == prevLevelOfOst0;
+    bool isOffsetValid = !ost0->GetOffset().IsInvalid() && !ost1->GetOffset().IsInvalid();
+    constexpr int kBitNumInOneByte = 8;
+    bool isByteAligned = ((ost0->GetOffset().val % kBitNumInOneByte) == 0) &&
+                         ((ost1->GetOffset().val % kBitNumInOneByte) == 0);
+    if (isPrevLevelOfOstSame && isOffsetValid && isByteAligned) {
+      auto distance = (ost0->GetOffset().val - ost1->GetOffset().val) / kBitNumInOneByte;
+      auto newConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          static_cast<uint64>(distance), *GlobalTables::GetTypeTable().GetTypeTable()[subExprPrimType]);
+      return CreateConstMeExpr(subExprPrimType, *newConst);
+    }
+  }
+
+  return nullptr;
+}
+
+MeExpr *IRMap::SimplifyAddExpr(const OpMeExpr *addExpr) {
+  if (IsPrimitiveVector(addExpr->GetPrimType())) {
+    return nullptr;
+  }
+  if (addExpr->GetOp() != OP_add) {
+    return nullptr;
+  }
+
+  auto *opnd0 = addExpr->GetOpnd(0);
+  auto *opnd1 = addExpr->GetOpnd(1);
+  if (opnd0->IsLeaf() && opnd1->IsLeaf()) {
+    if (opnd0->GetMeOp() == kMeOpConst && opnd1->GetMeOp() == kMeOpConst) {
+      return FoldConstExprBinary(addExpr->GetPrimType(), addExpr->GetOp(), *static_cast<ConstMeExpr *>(opnd0),
+                                 *static_cast<ConstMeExpr *>(opnd1));
+    }
+    return nullptr;
+  }
+  if (opnd0->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr *>(opnd0)->IsZero()) {
+    return opnd1;
+  } else if (opnd1->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr *>(opnd1)->IsZero()) {
+    return opnd0;
+  }
+
+  if (!opnd0->IsLeaf() && !opnd1->IsLeaf()) {
+    return nullptr;
+  }
+
+  if (!opnd1->IsLeaf()) {
+    auto *tmp = opnd1;
+    opnd1 = opnd0;
+    opnd0 = tmp;
+  }
+
+  if (opnd0->GetOp() == OP_cvt) {
+    auto *cvtExpr = static_cast<OpMeExpr *>(opnd0);
+    // unsigned overflow is allowed, so we can do noting to
+    //   e.g. (cvt u64 u32 (a + b)) + c  when we dont know the value range
+    if (GetPrimTypeSize(cvtExpr->GetOpndType()) < GetPrimTypeSize(cvtExpr->GetPrimType())) {
+      return nullptr;
+    }
+    opnd0 = opnd0->GetOpnd(0);
+    if (!IsPrimitiveInteger(opnd0->GetPrimType())) {
+      return nullptr;
+    }
+  } else if (opnd0->GetOp() == OP_iaddrof) {
+    auto *iaddrof = static_cast<OpMeExpr*>(opnd0);
+    auto *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iaddrof->GetTyIdx());
+    auto *pointedType = static_cast<MIRPtrType*>(type)->GetPointedType();
+    CHECK_FATAL(pointedType != nullptr, "expect a pointed type of iaddrof");
+    auto offset = pointedType->GetBitOffsetFromBaseAddr(iaddrof->GetFieldID()) / 8;
+    auto *newExpr = CreateMeExprBinary(OP_add, iaddrof->GetPrimType(), *iaddrof->GetOpnd(0),
+                                       *CreateIntConstMeExpr(offset, iaddrof->GetOpnd(0)->GetPrimType()));
+    auto *simplified = SimplifyMeExpr(newExpr);
+    opnd0 = simplified == nullptr ? newExpr : simplified;
+  }
+
+  OpMeExpr *retOpMeExpr = nullptr;
+  if (opnd0->GetOp() == OP_add) {
+    auto *opndA = opnd0->GetOpnd(0);
+    auto *opndB = opnd0->GetOpnd(1);
+    if (!opndA->IsLeaf() || !opndB->IsLeaf()) {
+      return nullptr;
+    }
+    if (opndA->GetPrimType() != opnd0->GetPrimType() || opndB->GetPrimType() != opnd0->GetPrimType()) {
+      return nullptr;
+    }
+    if (opndA->GetMeOp() == kMeOpConst) {
+      // (constA + constB) + opnd1
+      if (opndB->GetMeOp() == kMeOpConst) {
+        retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_add, opnd1,
+                                                                        OP_add, opndA, opndB));
+        if (addExpr->hasAddressValue) {
+          retOpMeExpr->hasAddressValue = true;
+        }
+        return retOpMeExpr;
+      }
+      // (constA + a) + constB --> a + (constA + constB)
+      if (opnd1->GetMeOp() == kMeOpConst) {
+        retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_add, opndB,
+                                                                        OP_add, opndA, opnd1));
+        if (addExpr->hasAddressValue) {
+          retOpMeExpr->hasAddressValue = true;
+        }
+        return retOpMeExpr;
+      }
+      // (const + a) + b --> (a + b) + const
+      retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_add, OP_add,
+                                                                      opndB, opnd1, opndA));
+      if (addExpr->hasAddressValue) {
+        retOpMeExpr->hasAddressValue = true;
+        if (retOpMeExpr->GetOpnd(0)->GetMeOp() == kMeOpOp) {
+          static_cast<OpMeExpr *>(retOpMeExpr->GetOpnd(0))->hasAddressValue = true;
+        }
+      }
+      return retOpMeExpr;
+    }
+
+    if (opndB->GetMeOp() == kMeOpConst) {
+      // (a + constA) + constB --> a + (constA + constB)
+      if (opnd1->GetMeOp() == kMeOpConst) {
+        retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_add, opndA,
+                                                                        OP_add, opndB, opnd1));
+        if (addExpr->hasAddressValue) {
+          retOpMeExpr->hasAddressValue = true;
+        }
+        return retOpMeExpr;
+      }
+      // (a + const) + b --> (a + b) + const
+      retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_add, OP_add,
+                                                                      opndA, opnd1, opndB));
+      if (addExpr->hasAddressValue) {
+        retOpMeExpr->hasAddressValue = true;
+        if (retOpMeExpr->GetOpnd(0)->GetMeOp() == kMeOpOp) {
+          static_cast<OpMeExpr *>(retOpMeExpr->GetOpnd(0))->hasAddressValue = true;
+        }
+      }
+      return retOpMeExpr;
+    }
+  }
+
+  if (opnd0->GetOp() == OP_sub) {
+    auto *opndA = opnd0->GetOpnd(0);
+    auto *opndB = opnd0->GetOpnd(1);
+    if (!opndA->IsLeaf() || !opndB->IsLeaf()) {
+      return nullptr;
+    }
+    if (opndA->GetMeOp() == kMeOpConst) {
+      // (constA - constB) + opnd1
+      if (opndB->GetMeOp() == kMeOpConst) {
+        retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_add, opnd1,
+                                                                        OP_sub, opndA, opndB));
+        if (addExpr->hasAddressValue) {
+          retOpMeExpr->hasAddressValue = true;
+        }
+        return retOpMeExpr;
+      }
+      // (constA - a) + constB --> (constA + constB) - a
+      if (opnd1->GetMeOp() == kMeOpConst) {
+        auto constA = static_cast<ConstMeExpr*>(opndA)->GetExtIntValue();
+        auto constB = static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue();
+        if (ConstantFold::IntegerOpIsOverflow(OP_add, opndA->GetPrimType(), constA, constB)) {
+          return nullptr;
+        }
+        retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_sub, OP_add,
+                                                                        opndA, opnd1, opndB));
+        if (addExpr->hasAddressValue) {
+          retOpMeExpr->hasAddressValue = true;
+        }
+        return retOpMeExpr;
+      }
+      // (const - a) + b --> (b - a) + const
+      retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_add, OP_sub,
+                                                                      opnd1, opndB, opndA));
+      if (addExpr->hasAddressValue) {
+        retOpMeExpr->hasAddressValue = true;
+        if (retOpMeExpr->GetOpnd(0)->GetMeOp() == kMeOpOp) {
+          static_cast<OpMeExpr *>(retOpMeExpr->GetOpnd(0))->hasAddressValue = true;
+        }
+      }
+      return retOpMeExpr;
+    }
+
+    if (opndB->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(opndB)->GetExtIntValue() != INT_MIN) {
+      // (a - constA) + constB --> a + (constB - constA)
+      if (opnd1->GetMeOp() == kMeOpConst) {
+        auto constA = static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue();
+        auto constB = static_cast<ConstMeExpr*>(opndB)->GetExtIntValue();
+        if (ConstantFold::IntegerOpIsOverflow(OP_sub, opndA->GetPrimType(), constA, constB)) {
+          return nullptr;
+        }
+        retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_add, opndA,
+                                                                        OP_sub, opnd1, opndB));
+        if (addExpr->hasAddressValue) {
+          retOpMeExpr->hasAddressValue = true;
+        }
+        return retOpMeExpr;
+      }
+      // (a - const) + b --> (a + b) - const
+      retOpMeExpr = static_cast<OpMeExpr *>(CreateCanonicalizedMeExpr(addExpr->GetPrimType(), OP_sub, OP_add,
+                                                                      opndA, opnd1, opndB));
+      if (addExpr->hasAddressValue) {
+        retOpMeExpr->hasAddressValue = true;
+        if (retOpMeExpr->GetOpnd(0)->GetMeOp() == kMeOpOp) {
+          static_cast<OpMeExpr *>(retOpMeExpr->GetOpnd(0))->hasAddressValue = true;
+        }
+      }
+      return retOpMeExpr;
+    }
+  }
+  return nullptr;
+}
+
+static inline bool SignExtendsOpnd(PrimType toType, PrimType fromType) {
+  if ((IsPrimitiveInteger(toType) && IsSignedInteger(fromType)) &&
+      (GetPrimTypeSize(fromType) < GetPrimTypeSize(toType))) {
+    return true;
+  }
+  return false;
+}
+
+MeExpr *IRMap::SimplifyMulExpr(const OpMeExpr *mulExpr) {
+  if (IsPrimitiveVector(mulExpr->GetPrimType())) {
+    return nullptr;
+  }
+  if (mulExpr->GetOp() != OP_mul) {
+    return nullptr;
+  }
+
+  auto *opnd0 = mulExpr->GetOpnd(0);
+  auto *opnd1 = mulExpr->GetOpnd(1);
+  if (opnd0->IsLeaf() && opnd1->IsLeaf()) {
+    if (opnd0->GetMeOp() == kMeOpConst && opnd1->GetMeOp() == kMeOpConst) {
+      return FoldConstExprBinary(mulExpr->GetPrimType(), mulExpr->GetOp(), *static_cast<ConstMeExpr *>(opnd0),
+                                 *static_cast<ConstMeExpr *>(opnd1));
+    }
+    return nullptr;
+  }
+
+  if (!opnd0->IsLeaf() && !opnd1->IsLeaf()) {
+    return nullptr;
+  }
+
+  if (!opnd1->IsLeaf()) {
+    auto *tmp = opnd1;
+    opnd1 = opnd0;
+    opnd0 = tmp;
+  }
+
+  if (opnd1->IsLeaf()) {
+    if (opnd0->GetOp() == OP_cvt) {
+      // reassociation effects sign extension
+      auto *cvtExpr = static_cast<OpMeExpr *>(opnd0);
+      if (SignExtendsOpnd(cvtExpr->GetPrimType(), cvtExpr->GetOpndType())) {
+        return nullptr;
+      }
+      opnd0 = opnd0->GetOpnd(0);
+    }
+    if (SignExtendsOpnd(mulExpr->GetPrimType(), opnd0->GetPrimType())) {
+      return nullptr;
+    }
+
+    if (opnd0->GetOp() == OP_add) {
+      auto *opndA = opnd0->GetOpnd(0);
+      auto *opndB = opnd0->GetOpnd(1);
+      if (!opndA->IsLeaf() || !opndB->IsLeaf()) {
+        return nullptr;
+      }
+      if (opndA->GetPrimType() != opnd0->GetPrimType() || opndB->GetPrimType() != opnd0->GetPrimType()) {
+        return nullptr;
+      }
+      if (opndA->GetMeOp() == kMeOpConst) {
+        // (constA + constB) * opnd1
+        if (opndB->GetMeOp() == kMeOpConst) {
+          return CreateCanonicalizedMeExpr(mulExpr->GetPrimType(), OP_mul, opnd1, OP_add, opndA, opndB);
+        }
+        // (constA + a) * constB --> a * constB + (constA * constB)
+        if (opnd1->GetMeOp() == kMeOpConst) {
+          if (GetPrimTypeSize(opnd0->GetPrimType()) < GetPrimTypeSize(opnd1->GetPrimType()) &&
+              IsUnsignedInteger(opnd0->GetPrimType())) {
+            // can not prove overflow wont happen
+            return nullptr;
+          }
+          return CreateCanonicalizedMeExpr(
+              mulExpr->GetPrimType(), OP_add, OP_mul, opndB, opnd1, OP_mul, opndA, opnd1);
+        }
+        return nullptr;
+      }
+
+      // (a + constA) * constB --> a * constB + (constA * constB)
+      if (opndB->GetMeOp() == kMeOpConst && opnd1->GetMeOp() == kMeOpConst) {
+        if (GetPrimTypeSize(opnd0->GetPrimType()) < GetPrimTypeSize(opnd1->GetPrimType()) &&
+            IsUnsignedInteger(opnd0->GetPrimType())) {
+          // can not prove overflow wont happen
+          return nullptr;
+        }
+        return CreateCanonicalizedMeExpr(
+            mulExpr->GetPrimType(), OP_add, OP_mul, opndA, opnd1, OP_mul, opndB, opnd1);
+      }
+      return nullptr;
+    }
+
+    if (opnd0->GetOp() == OP_sub) {
+      auto *opndA = opnd0->GetOpnd(0);
+      auto *opndB = opnd0->GetOpnd(1);
+      if (!opndA->IsLeaf() || !opndB->IsLeaf()) {
+        return nullptr;
+      }
+      if (opndA->GetMeOp() == kMeOpConst) {
+        // (constA - constB) * opnd1
+        if (opndB->GetMeOp() == kMeOpConst) {
+          return CreateCanonicalizedMeExpr(mulExpr->GetPrimType(), OP_mul, opnd1, OP_sub, opndA, opndB);
+        }
+        return nullptr;
+      }
+      return nullptr;
+    }
+
+    // (a * constA) * constB --> a * (constA * constB)
+    if (opnd0->GetOp() == OP_mul && opnd1->GetMeOp() == kMeOpConst) {
+      auto *simplified = SimplifyMulExpr(static_cast<OpMeExpr*>(opnd0));
+      opnd0 = simplified == nullptr ? opnd0 : simplified;
+      if (opnd0->GetOp() != OP_mul) {
+        return nullptr;
+      }
+      auto *opndA = opnd0->GetOpnd(0);
+      auto *opndB = opnd0->GetOpnd(1);
+      if (opndA->GetMeOp() != kMeOpConst && opndB->GetMeOp() != kMeOpConst) {
+        return nullptr;
+      }
+      if (opndA->GetMeOp() != kMeOpConst) {
+        // use opndA for const
+        auto *tmp = opndA;
+        opndA = opndB;
+        opndB = tmp;
+      }
+      if (opndA->GetPrimType() == opnd1->GetPrimType()) {
+        auto *newConst = FoldConstExprBinary(opndA->GetPrimType(), OP_mul, *static_cast<ConstMeExpr *>(opndA),
+                                             *static_cast<ConstMeExpr *>(opnd1));
+        return CreateMeExprBinary(OP_mul, mulExpr->GetPrimType(), *opndB, *newConst);
+      }
+    }
+  }
+  return nullptr;
+}
+
+bool IRMap::IfMeExprIsU1Type(const MeExpr *expr) const {
+  if (expr == nullptr || expr->IsVolatile()) {
+    return false;
+  }
+  // return type of compare expr may be set as its opnd's type, but it is actually u1
+  if (IsCompareHasReverseOp(expr->GetOp()) || expr->GetPrimType() == PTY_u1) {
+    return true;
+  }
+  if (expr->GetMeOp() == kMeOpVar) {
+    const auto *varExpr = static_cast<const VarMeExpr*>(expr);
+    // find if itself is u1
+    if (varExpr->GetOst()->GetType()->GetPrimType() == PTY_u1) {
+      return true;
+    }
+    // find if its definition is u1
+    if (varExpr->GetDefBy() == kDefByStmt) {
+      const auto *defSmt = static_cast<const AssignMeStmt*>(varExpr->GetDefStmt());
+      return IfMeExprIsU1Type(defSmt->GetRHS());
+    }
+    return false;
+  }
+  if (expr->GetMeOp() == kMeOpIvar) {
+    const auto *ivarExpr = static_cast<const IvarMeExpr*>(expr);
+    // find if itself is u1
+    if (ivarExpr->GetType()->GetPrimType() == PTY_u1) {
+      return true;
+    }
+    // find if its definition is u1
+    IassignMeStmt *iassignMeStmt = ivarExpr->GetDefStmt();
+    if (iassignMeStmt == nullptr) {
+      return false;
+    }
+    return IfMeExprIsU1Type(iassignMeStmt->GetRHS());
+  }
+  if (expr->GetMeOp() == kMeOpReg) {
+    const auto *regExpr = static_cast<const RegMeExpr*>(expr);
+    // find if itself is u1
+    if (regExpr->GetPrimType() == PTY_u1) {
+      return true;
+    }
+    // find if its definition is u1
+    if (regExpr->GetDefBy() == kDefByStmt) {
+      const auto *defStmt = static_cast<AssignMeStmt*>(regExpr->GetDefStmt());
+      return IfMeExprIsU1Type(defStmt->GetRHS());
+    }
+    return false;
+  }
+  if (expr->GetMeOp() == kMeOpOp) {
+    // remove convert/extension by recursive call
+    if (kOpcodeInfo.IsTypeCvt(expr->GetOp())) {
+      return IfMeExprIsU1Type(expr->GetOpnd(0));
+    }
+    if (expr->GetOp() == OP_zext || expr->GetOp() == OP_sext || expr->GetOp() == OP_extractbits) {
+      return IfMeExprIsU1Type(expr->GetOpnd(0));
+    }
+  }
+  return false;
+}
+
+MeExpr *IRMap::SimplifyCmpExpr(OpMeExpr *cmpExpr) {
+  Opcode cmpop = cmpExpr->GetOp();
+  if (!kOpcodeInfo.IsCompare(cmpop)) {
+    return nullptr;
+  }
+  MeExpr *opnd0 = cmpExpr->GetOpnd(0);
+  MeExpr *opnd1 = cmpExpr->GetOpnd(1);
+  if (opnd0 == opnd1) {
+    // node compared with itself
+    auto *res = SimplifyCompareSameExpr(cmpExpr);
+    if (res != nullptr) {
+      return res;
+    }
+  }
+  // fold constval cmp
+  if (opnd0->GetMeOp() == kMeOpConst && opnd1->GetMeOp() == kMeOpConst) {
+    maple::ConstantFold cf(mirModule);
+    MIRConst *opnd0const = static_cast<ConstMeExpr *>(opnd0)->GetConstVal();
+    MIRConst *opnd1const = static_cast<ConstMeExpr *>(opnd1)->GetConstVal();
+    MIRConst *resconst = cf.FoldConstComparisonMIRConst(cmpExpr->GetOp(), cmpExpr->GetPrimType(),
+                                                        cmpExpr->GetOpndType(), *opnd0const, *opnd1const);
+    return CreateConstMeExpr(cmpExpr->GetPrimType(), *resconst);
+  }
+
+  // case of:
+  // cmp (select(op1, op2), op3) ==> select(cmp (op1, op3), cmp (op2, op3)) ==> select(new_op1, new_op2)
+  // if new_op0 and new_op1 are both leaf
+  if (opnd0->GetOp() == OP_select || opnd1->GetOp() == OP_select) {
+    auto *selectExpr = opnd0->GetOp() == OP_select ? static_cast<OpMeExpr*>(opnd0) : static_cast<OpMeExpr*>(opnd1);
+    auto *opnd3 = selectExpr == opnd0 ? opnd1 : opnd0;
+    auto *selectOpnd1 = selectExpr->GetOpnd(1);
+    auto *selectOpnd2 = selectExpr->GetOpnd(2);
+    bool isSelectFirst = false;
+    if (selectExpr == opnd0) {
+      isSelectFirst = true;
+    }
+    OpMeExpr newOpnd1(kInvalidExprID, cmpop, cmpExpr->GetPrimType(), selectOpnd1, opnd3, isSelectFirst);
+    newOpnd1.SetOpndType(cmpExpr->GetOpndType());
+    auto *simplifiedOpnd1 = SimplifyCmpExpr(&newOpnd1);
+    if (simplifiedOpnd1 == nullptr || !simplifiedOpnd1->IsLeaf()) {
+      return nullptr;
+    }
+    OpMeExpr newOpnd2(kInvalidExprID, cmpop, cmpExpr->GetPrimType(), selectOpnd2, opnd3, isSelectFirst);
+    newOpnd2.SetOpndType(cmpExpr->GetOpndType());
+    auto *simplifiedOpnd2 = SimplifyCmpExpr(&newOpnd2);
+    if (simplifiedOpnd2 == nullptr || !simplifiedOpnd2->IsLeaf()) {
+      return nullptr;
+    }
+    OpMeExpr newSelect(kInvalidExprID, OP_select, PTY_u1, 3 /* select need 3 opnds */);
+    newSelect.SetOpnd(0, selectExpr->GetOpnd(0));
+    newSelect.SetOpnd(1, simplifiedOpnd1);
+    newSelect.SetOpnd(2, simplifiedOpnd2);
+    newSelect.SetHasAddressValue();
+    return HashMeExpr(newSelect);
+  }
+
+  switch (cmpop) {
+    case OP_ne:
+    case OP_eq: {
+      // case of:
+      // eq/ne (addrof, 0) ==> 0/1
+      if ((opnd0->GetMeOp() == kMeOpAddrof && opnd1->GetMeOp() == kMeOpConst) ||
+          (opnd0->GetMeOp() == kMeOpConst && opnd1->GetMeOp() == kMeOpAddrof)) {
+        MIRConst *resconst = nullptr;
+        if (opnd0->GetMeOp() == kMeOpAddrof) {
+          MIRConst *constopnd1 = static_cast<ConstMeExpr *>(opnd1)->GetConstVal();
+          if (constopnd1->IsZero()) {
+            // addrof will not be zero, so this comparison can be replaced with a constant
+            resconst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+                (cmpop == OP_ne), *GlobalTables::GetTypeTable().GetTypeTable()[PTY_u1]);
+          }
+        } else {
+          MIRConst *constopnd0 = static_cast<ConstMeExpr *>(opnd0)->GetConstVal();
+          if (constopnd0->IsZero()) {
+            // addrof will not be zero, so this comparison can be replaced with a constant
+            resconst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+                (cmpop == OP_ne), *GlobalTables::GetTypeTable().GetTypeTable()[PTY_u1]);
+          }
+        }
+        if (resconst != nullptr) {
+          return CreateConstMeExpr(cmpExpr->GetPrimType(), *resconst);
+        }
+      }
+
+      // case of:
+      // eq/ne (iaddrof, 0) ==> 0/1, when the offet is not 0
+      if ((opnd0->GetOp() == OP_iaddrof && opnd1->GetMeOp() == kMeOpConst) ||
+          (opnd0->GetMeOp() == kMeOpConst && opnd1->GetOp() == OP_iaddrof)) {
+        auto *constVal = static_cast<ConstMeExpr *>((opnd0->GetMeOp() == kMeOpConst) ? opnd0 : opnd1)->GetConstVal();
+        if (!constVal->IsZero()) {
+          return nullptr;
+        }
+        auto *iaddrExpr = static_cast<OpMeExpr *>((opnd0->GetOp() == OP_iaddrof) ? opnd0 : opnd1);
+        auto fieldId = iaddrExpr->GetFieldID();
+        auto *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iaddrExpr->GetTyIdx());
+        CHECK_FATAL(mirType->IsMIRPtrType(), "must be pointer type");
+        auto offset = static_cast<MIRPtrType *>(mirType)->GetPointedType()->GetBitOffsetFromBaseAddr(fieldId);
+        if (offset > 0) {
+          MIRConst *resconst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+              (cmpop == OP_ne), *GlobalTables::GetTypeTable().GetTypeTable()[PTY_u1]);
+          return CreateConstMeExpr(cmpExpr->GetPrimType(), *resconst);
+        }
+        return nullptr;
+      }
+
+      // case of:
+      // ne (u1 u1_expr, 0) ==> u1_expr
+      // ne (u1 u1_expr, 1) ==> !u1_expr
+      // eq (u1 u1_expr, 0) ==> !u1_expr
+      // eq (u1 u1_expr, 1) ==> u1_expr
+      if ((opnd1->GetMeOp() == kMeOpConst && IfMeExprIsU1Type(opnd0)) ||
+          (opnd0->GetMeOp() == kMeOpConst && IfMeExprIsU1Type(opnd1))) {
+        if (opnd0->GetMeOp() == kMeOpConst) { // ne/eq (0/1, u1 expr) => ne/eq (u1 expr, 0/1)
+          auto *tmpOpnd = opnd1;
+          opnd1 = opnd0;
+          opnd0 = tmpOpnd;
+        }
+        MIRConst *opnd1const = static_cast<ConstMeExpr *>(opnd1)->GetConstVal();
+        if ((cmpop == OP_ne && opnd1const->IsZero()) || (cmpop == OP_eq && opnd1const->IsOne())) {
+          return opnd0;
+        } else if ((cmpop == OP_ne && opnd1const->IsOne()) || (cmpop == OP_eq && opnd1const->IsZero())) {
+          if (IsCompareHasReverseOp(opnd0->GetOp())) {
+            OpMeExpr reverseMeExpr(kInvalidExprID, GetReverseCmpOp(opnd0->GetOp()), PTY_i32, opnd0->GetNumOpnds());
+            reverseMeExpr.SetOpnd(0, opnd0->GetOpnd(0));
+            reverseMeExpr.SetOpnd(1, opnd0->GetOpnd(1));
+            reverseMeExpr.SetOpndType(static_cast<OpMeExpr*>(opnd0)->GetOpndType());
+            auto *simplified = SimplifyCmpExpr(&reverseMeExpr);
+            return simplified == nullptr ? HashMeExpr(reverseMeExpr) : simplified;
+          }
+        }
+      }
+
+      // case of:
+      // eq/ne (cmp(op0, op1), 0) ==> eq/ne (op0, op1)
+      if (opnd0->GetOp() == OP_cmp && opnd1->GetMeOp() == kMeOpConst) {
+        auto *constVal = static_cast<ConstMeExpr*>(opnd1)->GetConstVal();
+        if (constVal->GetKind() == kConstInt && constVal->IsZero()) {
+          auto *subOpnd0 = opnd0->GetOpnd(0);
+          auto *subOpnd1 = opnd0->GetOpnd(1);
+          return CreateMeExprCompare(cmpop, PTY_i32, subOpnd0->GetPrimType(), *subOpnd0, *subOpnd1);
+        }
+      }
+      break;
+    }
+    case OP_lt:
+    case OP_ge: {
+      // case of:
+      // ge/lt unsigned (op0, 0) ==> 1/0
+      // ge/lt unsigned (0, op1) ==> eq/ne unsigned (op1, 0)
+      // ge/lt unsigned (op0, 1) ==> ne/eq unsigned (op0, 0)
+      if (IsUnsignedInteger(cmpExpr->GetOpndType())) {
+        if (opnd1->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(opnd1)->GetConstVal()->IsZero()) {
+          return CreateIntConstMeExpr(cmpop == OP_ge ? 1 : 0, PTY_u1);
+        }
+        // we prefer ne/eq in following optimizations
+        if (opnd0->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(opnd0)->GetConstVal()->IsZero()) {
+          auto *newcmp = CreateMeExprCompare(cmpop == OP_ge ? OP_eq : OP_ne, PTY_i32, cmpExpr->GetOpndType(),
+                                             *opnd1, *CreateIntConstMeExpr(0, cmpExpr->GetOpndType()));
+          auto *simplified = SimplifyCmpExpr(static_cast<OpMeExpr*>(newcmp));
+          return simplified == nullptr ? newcmp : simplified;
+        }
+        if (opnd1->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(opnd1)->GetConstVal()->IsOne()) {
+          auto *newcmp = CreateMeExprCompare(cmpop == OP_ge ? OP_ne : OP_eq, PTY_i32, cmpExpr->GetOpndType(),
+                                             *opnd0, *CreateIntConstMeExpr(0, cmpExpr->GetOpndType()));
+          auto *simplified = SimplifyCmpExpr(static_cast<OpMeExpr*>(newcmp));
+          return simplified == nullptr ? newcmp : simplified;
+        }
+      }
+      break;
+    }
+    case OP_le:
+    case OP_gt: {
+      // case of:
+      // gt/le unsigned (0, op1) ==> 0/1
+      // gt/le unsigned (op0, 0) ==> ne/eq unsigned (op0, 0)
+      // gt/le unsigned (1, op1) ==> eq/ne unsigned (op1, 0)
+      if (IsUnsignedInteger(cmpExpr->GetOpndType())) {
+        if (opnd0->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(opnd0)->GetConstVal()->IsZero()) {
+          return CreateIntConstMeExpr(cmpop == OP_gt ? 0 : 1, PTY_u1);
+        }
+        // we prefer ne/eq in following optimizations
+        if (opnd1->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(opnd1)->GetConstVal()->IsZero()) {
+          auto *newcmp = CreateMeExprCompare(cmpop == OP_gt ? OP_ne : OP_eq, PTY_i32, cmpExpr->GetOpndType(),
+                                             *opnd0, *CreateIntConstMeExpr(0, cmpExpr->GetOpndType()));
+          auto *simplified = SimplifyCmpExpr(static_cast<OpMeExpr*>(newcmp));
+          return simplified == nullptr ? newcmp : simplified;
+        }
+        if (opnd0->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(opnd0)->GetConstVal()->IsOne()) {
+          auto *newcmp = CreateMeExprCompare(cmpop == OP_gt ? OP_eq : OP_ne, PTY_i32, cmpExpr->GetOpndType(),
+                                             *opnd1, *CreateIntConstMeExpr(0, cmpExpr->GetOpndType()));
+          auto *simplified = SimplifyCmpExpr(static_cast<OpMeExpr*>(newcmp));
+          return simplified == nullptr ? newcmp : simplified;
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return nullptr;
+}
+
+MeExpr *IRMap::SimplifySelExpr(OpMeExpr *selExpr) {
+  if (selExpr->GetOp() != OP_select) {
+    return nullptr;
+  }
+  MeExpr *cond = selExpr->GetOpnd(0);
+  if (cond->GetMeOp() != kMeOpConst) {
+    return nullptr;
+  }
+  auto *constCond = static_cast<ConstMeExpr *>(cond);
+  return constCond->IsZero() ? selExpr->GetOpnd(2) : selExpr->GetOpnd(1);
+}
+
+class BitPart {
+ public:
+  BitPart(MeExpr *p, uint32 bitwidth) : provider(p) {
+    provenance.resize(bitwidth);
+  }
+
+  void Extend(uint32 bitwidth) {
+    if (provenance.size() < bitwidth) {
+      (void)provenance.insert(provenance.end(), bitwidth - provenance.size(), kUnset);
+    }
+  }
+
+  // the source oprand.
+  MeExpr *provider;
+  // provenance[A] = B means that bit A in Provider becomes bit B in the result of expression.
+  std::vector<int8> provenance;
+
+  static constexpr int kUnset = -1;
+};
+
+static constexpr uint32 kBitPartRecursionMaxDepth = 64;
+
+// collect expr's BitPart recursively to check if it's possible for bytewise reverse.
+// we can get the BitPart of a expr if the opcode is bit operation related.
+std::optional<BitPart> &CollectBitparts(MeExpr *expr, std::map<MeExpr *, std::optional<BitPart>> &bps, int depth) {
+  auto iter = bps.find(expr);
+  if (iter != bps.end()) {
+    return iter->second;
+  }
+
+  std::optional<BitPart> &result = bps[expr];
+  if (depth > static_cast<int>(kBitPartRecursionMaxDepth)) {
+    return result;
+  }
+  auto bitwidth = GetPrimTypeBitSize(expr->GetPrimType());
+  // if bitwidth is not a multiple of double bytes, it can't be a bytewise reverse.
+  if (bitwidth % 16 != 0) {
+    return result;
+  }
+
+  auto opcode = expr->GetOp();
+  if (opcode == OP_bior) {
+    auto &res0 = CollectBitparts(expr->GetOpnd(0), bps, depth + 1);
+    auto &res1 = CollectBitparts(expr->GetOpnd(1), bps, depth + 1);
+    if (!res0 || !res1) {
+      return result;
+    }
+
+    if (!res0->provider || res0->provider != res1->provider) {
+      return result;
+    }
+
+    if (bitwidth > res0->provenance.size()) {
+      return result;
+    }
+
+    result = BitPart(res0->provider, bitwidth);
+    // merge the two bit provenances together.
+    for (uint32 i = 0; i < bitwidth; ++i) {
+      if (res0->provenance[i] != BitPart::kUnset && res1->provenance[i] != BitPart::kUnset &&
+          res0->provenance[i] != res1->provenance[i]) {
+        return result = std::nullopt;
+      }
+
+      if (res0->provenance[i] == BitPart::kUnset) {
+        result->provenance[i] = res1->provenance[i];
+      } else {
+        result->provenance[i] = res0->provenance[i];
+      }
+    }
+
+    return result;
+  }
+
+  if (opcode == OP_band && expr->GetOpnd(1)->GetMeOp() == kMeOpConst) {
+    auto andMask = static_cast<ConstMeExpr *>(expr->GetOpnd(1))->GetExtIntValue();
+    if (__builtin_popcountll(andMask) % 8 != 0) {
+      return result;
+    }
+    auto &res = CollectBitparts(expr->GetOpnd(0), bps, depth + 1);
+    if (!res) {
+      return result;
+    }
+    result = res;
+    result->Extend(bitwidth);
+
+    uint64 bit = 1;
+    for (uint8 i = 0; i < bitwidth; ++i, bit <<= 1) {
+      // clear the bit if andMask is zero for this bit.
+      if ((andMask & bit) == 0) {
+        result->provenance[i] = BitPart::kUnset;
+      }
+    }
+
+    return result;
+  }
+  if (IsLogicalShift(opcode) && expr->GetOpnd(1)->GetMeOp() == kMeOpConst) {
+    auto bitShift = static_cast<ConstMeExpr *>(expr->GetOpnd(1))->GetExtIntValue();
+    if (bitShift < 0 || bitShift > bitwidth) {
+      return result;
+    }
+
+    auto &res = CollectBitparts(expr->GetOpnd(0), bps, depth + 1);
+    if (!res || bitShift > res->provenance.size()) {
+      return result;
+    }
+
+    result = res;
+    result->Extend(bitwidth);
+
+    // clear the bit that is discarded, and do the same shift of the rest bits.
+    auto &bitProvenance = result->provenance;
+    if (expr->GetOp() == OP_shl) {
+      bitProvenance.erase(std::prev(bitProvenance.end(), bitShift), bitProvenance.end());
+      bitProvenance.insert(bitProvenance.begin(), bitShift, BitPart::kUnset);
+    } else {
+      bitProvenance.erase(bitProvenance.begin(), std::next(bitProvenance.begin(), bitShift));
+      bitProvenance.insert(bitProvenance.end(), bitShift, BitPart::kUnset);
+    }
+
+    return result;
+  }
+
+  if (opcode == OP_zext || opcode == OP_extractbits) {
+    if (!GetPrimitiveTypeProperty(expr->GetPrimType()).IsUnsigned()) {
+      return result;
+    }
+    auto srcBitWidth = GetPrimTypeBitSize(expr->GetOpnd(0)->GetPrimType());
+    auto bitOffset = static_cast<OpMeExpr *>(expr)->GetBitsOffSet();
+    auto bitSize = static_cast<OpMeExpr *>(expr)->GetBitsSize();
+    if (bitOffset + bitSize > srcBitWidth) {
+      return result;
+    }
+
+    auto &res = CollectBitparts(expr->GetOpnd(0), bps, depth + 1);
+    if (!res) {
+      return result;
+    }
+
+    // do extractbits for provenance.
+    result = BitPart(res->provider, bitwidth);
+    for (uint32 i = 0; i < bitSize; ++i) {
+      result->provenance[i] = res->provenance[bitOffset + i];
+    }
+    for (uint32 i = bitSize; i < bitwidth; ++i) {
+      result->provenance[i] = BitPart::kUnset;
+    }
+    return result;
+  }
+
+  result = BitPart(expr, bitwidth);
+  for (uint8 i = 0; i < bitwidth; ++i) {
+    result->provenance[i] = i;
+  }
+  return result;
+}
+
+// check if the bit map of (from -> to) is symmetry about bitwidth
+static bool bitMapIsValidForReverse(uint32 from, uint32 to, uint8 bitwidth) {
+  if (from % 8 != to % 8) {
+    return false;
+  }
+  from >>= 3;
+  to >>= 3;
+  bitwidth >>= 3;
+  return from == bitwidth - to - 1;
+}
+
+// match OR bit operations for bytewise reverse, replace with intrinsic rev
+MeExpr *IRMap::SimplifyOrMeExpr(OpMeExpr *opmeexpr) {
+  Opcode opcode = opmeexpr->GetOp();
+  if (opcode != OP_bior) {
+    return nullptr;
+  }
+
+  if (MeExpr *res = PullOutZext(*this, *opmeexpr)) {
+    return res;
+  }
+
+  auto bitwidth = GetPrimTypeBitSize(opmeexpr->GetPrimType());
+  MeExpr *opnd0 = opmeexpr->GetOpnd(0);
+  MeExpr *opnd1 = opmeexpr->GetOpnd(1);
+  Opcode opcode0 = opnd0->GetOp();
+  Opcode opcode1 = opnd1->GetOp();
+
+  if (IsCompareHasReverseOp(opnd0->GetOp()) || IsCompareHasReverseOp(opnd1->GetOp())) {
+    return ConstantFold::FoldCmpExpr(*this, *opnd0, *opnd1, false);
+  }
+
+  if (MeExpr *res = ConstantFold::FoldOrOfAnds(*this, *opnd0, *opnd1)) {
+    return res;
+  }
+
+  // (X ^ C) | Y -> (X | Y) ^ C if Y & C ==0
+  if (opcode0 == OP_bxor && opnd1->GetMeOp() == kMeOpConst) {
+    auto expr1 = opnd0->GetOpnd(1);
+    if (expr1->GetMeOp() != kMeOpConst) {
+      return nullptr;
+    }
+    auto c1 = static_cast<ConstMeExpr *>(opnd1)->GetIntValue();
+    auto c2 = static_cast<ConstMeExpr *>(expr1)->GetIntValue();
+    if (c1.IsSigned() != c2.IsSigned()) {
+      c1.Assign(IntVal(c1, false));
+      c2.Assign(IntVal(c2, false));
+    }
+    if ((c1 & c2) == 0) {
+      auto newOpnd0 = CreateMeExprBinary(OP_bior, opmeexpr->GetPrimType(), *opnd0->GetOpnd(0), *opnd1);
+      auto res = CreateMeExprBinary(OP_bxor, opnd0->GetPrimType(), *newOpnd0, *expr1);
+      return res;
+    }
+  }
+
+  // (A | B) | C
+  bool OrOfOrs = (opcode0 == OP_bior) || (opcode1 == OP_bior);
+  // (A >> B) | (C << D)
+  bool OrOfShifts = IsLogicalShift(opcode0) && IsLogicalShift(opcode1);
+  // (A & B) | (C & D)
+  bool OrOfAnds = (opcode0 == OP_band) && (opcode1 == OP_band);
+  // (A & B) | (C << D)
+  bool OrOfAndAndsh =
+      (opcode0 == OP_band && IsLogicalShift(opcode1)) || (IsLogicalShift(opcode0) && opcode1 == OP_band);
+  // extractbits(A) | (B << C)
+  // hapens when a (M & N) >> X is omit to a extractbits operation
+  bool OrOfExtrAndsh =
+      (opcode0 == OP_extractbits && IsLogicalShift(opcode1)) || (IsLogicalShift(opcode0) && opcode1 == OP_extractbits);
+  // extractbits(A) | (B & C)
+  // hapens when a (M >> X) & N is omit to a extractbits operation
+  bool OrOfExtrAndAnd =
+      (opcode0 == OP_extractbits && opcode1 == OP_band) || (opcode0 == OP_band && opcode1 == OP_extractbits);
+
+  // if not match patterns above, we can't do bytewise reverse
+  if (!OrOfOrs && !OrOfShifts && !OrOfAnds && !OrOfAndAndsh && !OrOfExtrAndsh && !OrOfExtrAndAnd) {
+    return nullptr;
+  }
+  std::map<MeExpr *, std::optional<BitPart>> bps;
+  auto &res = CollectBitparts(opmeexpr, bps, 0);
+  if (!res) {
+    return nullptr;
+  }
+
+  auto &bitProvenance = res->provenance;
+
+  auto demandBitWidth = bitwidth;
+
+  if (bitProvenance.back() == BitPart::kUnset) {
+    while (!bitProvenance.empty() && bitProvenance.back() == BitPart::kUnset) {
+      bitProvenance.pop_back();
+    }
+    if (bitProvenance.empty()) {
+      return nullptr;
+    }
+    demandBitWidth = bitProvenance.size();
+  }
+
+  for (uint8 i = 0; i < demandBitWidth; ++i) {
+    if (!bitMapIsValidForReverse(i, bitProvenance[i], demandBitWidth)) {
+      return nullptr;
+    }
+  }
+
+  MIRIntrinsicID intrin;
+  PrimType demandType;
+  if (demandBitWidth == 16) {
+    intrin = INTRN_C_rev16_2;
+    demandType = PTY_u16;
+  } else if (demandBitWidth == 32) {
+    intrin = INTRN_C_rev_4;
+    demandType = PTY_u32;
+  } else if (demandBitWidth == 64) {
+    intrin = INTRN_C_rev_8;
+    demandType = PTY_u64;
+  } else {
+    return nullptr;
+  }
+
+  auto provider = res->provider;
+  NaryMeExpr revExpr(&irMapAlloc, kInvalidExprID, OP_intrinsicop, demandType, 1, TyIdx(0), intrin, false);
+  revExpr.PushOpnd(provider);
+  auto result = CreateNaryMeExpr(revExpr);
+  return result;
+}
+
+static bool IsSignBitZero(MeExpr *opnd, uint64 signBit, uint64 shiftAmt) {
+  Opcode opcode = opnd->GetOp();
+  uint64 knownZeroBits = 0;
+  auto bitWidth = GetPrimTypeBitSize(opnd->GetPrimType());
+  switch (opcode) {
+    case OP_zext: {
+      auto srcBitWidth = static_cast<OpMeExpr*>(opnd)->GetBitsSize();
+      if (srcBitWidth < bitWidth) {
+        knownZeroBits |= UINT64_MAX << (bitWidth - srcBitWidth);
+      }
+    } break;
+    case OP_band: {
+      auto opnd1 = opnd->GetOpnd(1);
+      if (opnd1->GetMeOp() != kMeOpConst) {
+        return false;
+      }
+      auto andValue = static_cast<ConstMeExpr *>(opnd1)->GetExtIntValue();
+      knownZeroBits |= ~andValue;
+      break;
+    }
+    default:
+      break;
+  }
+  knownZeroBits >>= shiftAmt;
+  if (knownZeroBits & signBit) {
+    return true;
+  }
+  return false;
+}
+
+MeExpr *IRMap::SimplifyDepositbits(const OpMeExpr &opmeexpr) {
+  if (opmeexpr.GetOp() != OP_depositbits) {
+    return nullptr;
+  }
+
+  auto *opnd0 = opmeexpr.GetOpnd(0);
+  auto *opnd1 = opmeexpr.GetOpnd(1);
+  if (opnd0->GetMeOp() == kMeOpConst && opnd1->GetMeOp() == kMeOpConst) {
+    uint8 bitsOffset = opmeexpr.GetBitsOffSet();
+    uint8 bitsSize = opmeexpr.GetBitsSize();
+    uint64 mask0 = (1LLU << (bitsSize + bitsOffset)) - 1;
+    uint64 mask1 = (1LLU << bitsOffset) - 1;
+    uint64 op0Mask = ~(mask0 ^ mask1);
+    uint64 op0ExtractVal = (static_cast<uint64>(static_cast<ConstMeExpr*>(opnd0)->GetExtIntValue()) & op0Mask);
+    uint64 op1ExtractVal = (static_cast<uint64>(static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue()) << bitsOffset) &
+                           ((1ULL << (bitsSize + bitsOffset)) - 1);
+    return CreateIntConstMeExpr(static_cast<int64>(op0ExtractVal | op1ExtractVal), opmeexpr.GetPrimType());
+  }
+
+  // depositbits 9 4 (a, zext u32 8 (b)) ==> depositbits 9 4 (a, b)
+  if (opnd1->GetOp() == OP_zext || opnd1->GetOp() == OP_sext) {
+    if (static_cast<OpMeExpr*>(opnd1)->GetBitsSize() >= opmeexpr.GetBitsSize()) {
+      OpMeExpr newOp(kInvalidExprID, OP_depositbits, opmeexpr.GetPrimType(), opnd0, opnd1->GetOpnd(0));
+      newOp.SetBitsOffSet(opmeexpr.GetBitsOffSet());
+      newOp.SetBitsSize(opmeexpr.GetBitsSize());
+      auto *ret = SimplifyDepositbits(newOp);
+      return ret == nullptr ? HashMeExpr(newOp) : ret;
+    }
+  }
+
+  // depositbits 1 7 (depositbits 1 5 (a, b), c) ==> depositbits 1 7 (a, c)
+  if (opnd0->GetOp() == OP_depositbits &&
+      opmeexpr.GetBitsOffSet() == static_cast<OpMeExpr*>(opnd0)->GetBitsOffSet() &&
+      opmeexpr.GetBitsSize() >= static_cast<OpMeExpr*>(opnd0)->GetBitsSize()) {
+    OpMeExpr newOp(kInvalidExprID, OP_depositbits, opmeexpr.GetPrimType(), opnd0->GetOpnd(0), opmeexpr.GetOpnd(1));
+    newOp.SetBitsOffSet(opmeexpr.GetBitsOffSet());
+    newOp.SetBitsSize(opmeexpr.GetBitsSize());
+    auto *ret = SimplifyDepositbits(newOp);
+    return ret == nullptr ? HashMeExpr(newOp) : ret;
+  }
+  return nullptr;
+}
+
+MeExpr *IRMap::SimplifyExtractbits(const OpMeExpr &opmeexpr) {
+  if (opmeexpr.GetOp() != OP_extractbits) {
+    return nullptr;
+  }
+
+  auto *opnd0 = opmeexpr.GetOpnd(0);
+  if (opnd0->GetMeOp() == kMeOpConst) {
+    uint8 bitsOffset = opmeexpr.GetBitsOffSet();
+    uint8 bitsSize = opmeexpr.GetBitsSize();
+    auto extractVal = IntVal(static_cast<ConstMeExpr*>(opnd0)->GetIntValue().GetZXTValue(), PTY_u64);
+    extractVal = extractVal.Shl(sizeof(uint64) * CHAR_BIT - (bitsOffset + bitsSize), PTY_u64);
+    extractVal = IsSignedInteger(opmeexpr.GetPrimType()) ?
+        extractVal.AShr(sizeof(uint64) * CHAR_BIT - bitsSize, PTY_u64) :
+        extractVal.LShr(sizeof(uint64) * CHAR_BIT - bitsSize, PTY_u64);
+    return CreateIntConstMeExpr(extractVal, opmeexpr.GetPrimType());
+  }
+
+  if (opnd0->GetOp() == OP_depositbits) {
+    // extractbits 7 22 (depositbits 1 6 (a, b)) ==> extractbits 7 22 (a)
+    // extractbits 7 2 (depositbits 23 4 (a, b)) ==> extractbits 7 2 (a)
+    auto *opnd = static_cast<OpMeExpr*>(opnd0);
+    if (opnd->GetBitsOffSet() + opnd->GetBitsSize() <= opmeexpr.GetBitsOffSet() ||
+        opmeexpr.GetBitsSize() + opmeexpr.GetBitsOffSet() <= opnd->GetBitsOffSet()) {
+      OpMeExpr newOp(kInvalidExprID, OP_extractbits, opmeexpr.GetPrimType(), opnd->GetOpnd(0));
+      newOp.SetBitsOffSet(opmeexpr.GetBitsOffSet());
+      newOp.SetBitsSize(opmeexpr.GetBitsSize());
+      return HashMeExpr(newOp);
+    }
+
+    // extractbits 7 2 (depositbits 7 2 (a, b)) ==> extractbits 0 2 (b)
+    if (opnd->GetBitsOffSet() == opmeexpr.GetBitsOffSet() && opnd->GetBitsSize() == opmeexpr.GetBitsSize()) {
+      OpMeExpr newOp(kInvalidExprID, OP_extractbits, opmeexpr.GetPrimType(), opnd->GetOpnd(1));
+      newOp.SetBitsOffSet(0);
+      newOp.SetBitsSize(opmeexpr.GetBitsSize());
+      return HashMeExpr(newOp);
+    }
+  }
+  return nullptr;
+}
+
+MeExpr *IRMap::SimplifyAshrMeExpr(OpMeExpr *opmeexpr) {
+  Opcode opcode = opmeexpr->GetOp();
+  if (opcode != OP_ashr) {
+    return nullptr;
+  }
+  auto opnd0 = opmeexpr->GetOpnd(0);
+  auto opnd1 = opmeexpr->GetOpnd(1);
+  if (opnd1->GetMeOp() != kMeOpConst) {
+    return nullptr;
+  }
+  auto shiftAmt = static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue();
+  auto bitWidth = GetPrimTypeBitSize(opmeexpr->GetPrimType());
+  if (shiftAmt >= bitWidth) {
+    return nullptr;
+  }
+
+  uint64 signBit = 1 << (bitWidth - shiftAmt - 1);
+  bool isSignBitZero = IsSignBitZero(opnd0, signBit, shiftAmt);
+  // sign bit is known to be zero, we can replace ashr with lshr
+  if (isSignBitZero) {
+    auto lshrExpr = CreateMeExprBinary(OP_lshr, opmeexpr->GetPrimType(), *opnd0, *opnd1);
+    return lshrExpr;
+  }
+  return nullptr;
+}
+
+MeExpr *IRMap::SimplifyXorMeExpr(OpMeExpr *opmeexpr) {
+  Opcode opcode = opmeexpr->GetOp();
+  if (opcode != OP_bxor) {
+    return nullptr;
+  }
+
+  if (MeExpr *res = PullOutZext(*this, *opmeexpr)) {
+    return res;
+  }
+
+  auto opnd0 = opmeexpr->GetOpnd(0);
+  auto opnd1 = opmeexpr->GetOpnd(1);
+  // (X & C) ^ (Y & C) --> (X ^ Y) & C
+  if (opnd0->GetOp() == OP_band && opnd1->GetOp() == OP_band) {
+    auto constExpr1 = opnd0->GetOpnd(1);
+    auto constExpr2 = opnd1->GetOpnd(1);
+    if (constExpr1->GetMeOp() != kMeOpConst || constExpr2->GetMeOp() != kMeOpConst) {
+      return nullptr;
+    }
+    auto c1 = static_cast<ConstMeExpr *>(constExpr1)->GetIntValue();
+    auto c2 = static_cast<ConstMeExpr *>(constExpr2)->GetIntValue();
+    if (c1 == c2) {
+      auto xorExpr = CreateMeExprBinary(OP_bxor, opmeexpr->GetPrimType(), *opnd0->GetOpnd(0), *opnd1->GetOpnd(0));
+      auto andExpr = CreateMeExprBinary(OP_band, opmeexpr->GetPrimType(), *xorExpr, *constExpr1);
+      return andExpr;
+    }
+  }
+  // (X | C2) ^ C1 --> (X & ~C2) ^ (C1 ^ C2)
+  if (opnd0->GetOp() == OP_bior && opnd1->GetMeOp() == kMeOpConst) {
+    auto expr1 = opnd0->GetOpnd(0);
+    auto expr2 = opnd0->GetOpnd(1);
+    if (expr2->GetMeOp() != kMeOpConst) {
+      return nullptr;
+    }
+    auto newConstExpr1 = FoldConstExprUnary(opmeexpr->GetPrimType(), OP_bnot, *static_cast<ConstMeExpr *>(expr2));
+    auto newConstExpr2 = FoldConstExprBinary(opmeexpr->GetPrimType(), OP_bxor, *static_cast<ConstMeExpr *>(opnd1),
+                                             *static_cast<ConstMeExpr *>(expr2));
+
+    auto newOpnd0 = CreateMeExprBinary(OP_band, opmeexpr->GetPrimType(), *expr1, *newConstExpr1);
+    auto res = CreateMeExprBinary(OP_bxor, opmeexpr->GetPrimType(), *newOpnd0, *newConstExpr2);
+    return res;
+  }
+  return nullptr;
+}
+
+MeExpr *IRMap::SimplifyOpMeExpr(OpMeExpr *opmeexpr) {
+  if (IsPrimitiveVector(opmeexpr->GetPrimType())) {
+    return nullptr;
+  }
+  Opcode opop = opmeexpr->GetOp();
+  MeExpr *simpleCast = SimplifyCast(opmeexpr);
+  if (simpleCast != nullptr) {
+    return simpleCast;
+  }
+  auto foldConst = [this](MeExpr *opnd0, MeExpr *opnd1, Opcode op, PrimType ptyp) {
+    MIRIntConst *opnd0const = static_cast<MIRIntConst *>(static_cast<ConstMeExpr *>(opnd0)->GetConstVal());
+    MIRIntConst *opnd1const = static_cast<MIRIntConst *>(static_cast<ConstMeExpr *>(opnd1)->GetConstVal());
+    MIRConst *resconst = ConstantFold::FoldIntConstBinaryMIRConst(op, ptyp, opnd0const, opnd1const);
+    return CreateConstMeExpr(ptyp, *resconst);
+  };
+  switch (opop) {
+    case OP_cvt: {
+      OpMeExpr *cvtmeexpr = static_cast<OpMeExpr *>(opmeexpr);
+      MeExpr *opnd0 = cvtmeexpr->GetOpnd(0);
+      if (opnd0->GetMeOp() == kMeOpConst) {
+        ConstantFold cf(mirModule);
+        MIRConst *tocvt =
+          cf.FoldTypeCvtMIRConst(*static_cast<ConstMeExpr *>(opnd0)->GetConstVal(),
+                                 cvtmeexpr->GetOpndType(), cvtmeexpr->GetPrimType());
+        if (tocvt) {
+          return CreateConstMeExpr(cvtmeexpr->GetPrimType(), *tocvt);
+        }
+      }
+      // If typeA, typeB, and typeC{fieldId} are integer, and sizeof(typeA) == sizeof(typeB).
+      // Simplfy expr: cvt typeA typeB (iread typeB <* typeC> fieldId address)
+      // to: iread typeA <* typeC> fieldId address
+      if (opnd0->GetMeOp() == kMeOpIvar && cvtmeexpr->GetOpndType() == opnd0->GetPrimType() &&
+          IsPrimitiveInteger(opnd0->GetPrimType()) && IsPrimitiveInteger(cvtmeexpr->GetPrimType()) &&
+          GetPrimTypeSize(opnd0->GetPrimType()) == GetPrimTypeSize(cvtmeexpr->GetPrimType())) {
+        IvarMeExpr *ivar = static_cast<IvarMeExpr*>(opnd0);
+        auto resultPrimType = ivar->GetType()->GetPrimType();
+        if (IsPrimitiveInteger(resultPrimType)) {
+          IvarMeExpr newIvar(&irMapAlloc, kInvalidExprID, *ivar);
+          newIvar.SetPtyp(cvtmeexpr->GetPrimType());
+          return HashMeExpr(newIvar);
+        }
+        return nullptr;
+      }
+      if (opnd0->GetOp() == OP_cvt) {
+        OpMeExpr *cvtopnd0 = static_cast<OpMeExpr *>(opnd0);
+        // cvtopnd0 should have tha same type as cvtopnd0->GetOpnd(0) or cvtmeexpr,
+        // and the type size of cvtopnd0 should be ge(>=) one of them.
+        // Otherwise, deleting the cvt of cvtopnd0 may result in information loss.
+        if (maple::IsSignedInteger(cvtmeexpr->GetOpndType()) != maple::IsSignedInteger(cvtopnd0->GetOpndType())) {
+          return nullptr;
+        }
+        if (maple::GetPrimTypeSize(cvtopnd0->GetPrimType()) >=
+            maple::GetPrimTypeSize(cvtopnd0->GetOpnd(0)->GetPrimType())) {
+          if ((maple::IsPrimitiveInteger(cvtopnd0->GetPrimType()) &&
+               maple::IsPrimitiveInteger(cvtopnd0->GetOpnd(0)->GetPrimType()) &&
+               !maple::IsPrimitiveFloat(cvtmeexpr->GetPrimType())) ||
+              (maple::IsPrimitiveFloat(cvtopnd0->GetPrimType()) &&
+               maple::IsPrimitiveFloat(cvtopnd0->GetOpnd(0)->GetPrimType()))) {
+            if (cvtmeexpr->GetPrimType() == cvtopnd0->GetOpndType()) {
+              return cvtopnd0->GetOpnd(0);
+            } else {
+              if (maple::IsUnsignedInteger(cvtopnd0->GetOpndType()) ||
+                  maple::GetPrimTypeSize(cvtopnd0->GetPrimType()) >= maple::GetPrimTypeSize(cvtmeexpr->GetPrimType())) {
+                return CreateMeExprTypeCvt(cvtmeexpr->GetPrimType(), cvtopnd0->GetOpndType(), *cvtopnd0->GetOpnd(0));
+              }
+              return nullptr;
+            }
+          }
+        }
+        if (maple::GetPrimTypeSize(cvtopnd0->GetPrimType()) >= maple::GetPrimTypeSize(cvtmeexpr->GetPrimType())) {
+          if ((maple::IsPrimitiveInteger(cvtopnd0->GetPrimType()) &&
+               maple::IsPrimitiveInteger(cvtmeexpr->GetPrimType()) &&
+               !maple::IsPrimitiveFloat(cvtopnd0->GetOpnd(0)->GetPrimType())) ||
+              (maple::IsPrimitiveFloat(cvtopnd0->GetPrimType()) &&
+               maple::IsPrimitiveFloat(cvtmeexpr->GetPrimType()))) {
+            return CreateMeExprTypeCvt(cvtmeexpr->GetPrimType(), cvtopnd0->GetOpndType(), *cvtopnd0->GetOpnd(0));
+          }
+        }
+        // simplify "cvt type1 type2 (cvt type2 type3 (expr ))" to "cvt type1 type3 expr"
+        auto typeA = cvtopnd0->GetOpnd(0)->GetPrimType();
+        auto typeB = cvtopnd0->GetPrimType();
+        auto typeC = opmeexpr->GetPrimType();
+        if (IgnoreInnerTypeCvt(typeA, typeB, typeC)) {
+          return CreateMeExprTypeCvt(typeC, typeA, utils::ToRef(cvtopnd0->GetOpnd(0)));
+        }
+      }
+      return nullptr;
+    }
+    case OP_add: {
+      if (!IsPrimitiveInteger(opmeexpr->GetPrimType())) {
+        return nullptr;
+      }
+      return SimplifyAddExpr(opmeexpr);
+    }
+    case OP_mul: {
+      if (!IsPrimitiveInteger(opmeexpr->GetPrimType())) {
+        return nullptr;
+      }
+      return SimplifyMulExpr(opmeexpr);
+    }
+    case OP_lnot: {
+      MeExpr *opnd0 = opmeexpr->GetOpnd(0);
+      if (IsCompareHasReverseOp(opnd0->GetOp())) {
+        OpMeExpr reverseMeExpr(kInvalidExprID, GetReverseCmpOp(opnd0->GetOp()), PTY_i32, opnd0->GetNumOpnds());
+        reverseMeExpr.SetOpnd(0, opnd0->GetOpnd(0));
+        reverseMeExpr.SetOpnd(1, opnd0->GetOpnd(1));
+        reverseMeExpr.SetOpndType(opnd0->GetOpnd(0)->GetPrimType());
+        return HashMeExpr(reverseMeExpr);
+      } else if (opnd0->GetMeOp() == kMeOpConst) {
+        MIRConst *constopnd0 = static_cast<ConstMeExpr *>(opnd0)->GetConstVal();
+        if (constopnd0->GetKind() == kConstInt) {
+          MIRConst *newconst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(constopnd0->IsZero(),
+              *GlobalTables::GetTypeTable().GetTypeTable()[PTY_u1]);
+          return CreateConstMeExpr(opmeexpr->GetPrimType(), *newconst);
+        }
+      }
+      return nullptr;
+    }
+    case OP_div:
+    case OP_rem:
+    case OP_ashr: {
+      MeExpr *shrexp = SimplifyAshrMeExpr(opmeexpr);
+      if (shrexp != nullptr) {
+        return shrexp;
+      }
+    }
+    case OP_shl:
+    case OP_max:
+    case OP_min:
+    case OP_bior: {
+      MeExpr *revexp = SimplifyOrMeExpr(opmeexpr);
+      if (revexp != nullptr) {
+        return revexp;
+      }
+    }
+    case OP_bxor: {
+      MeExpr *xorexp = SimplifyXorMeExpr(opmeexpr);
+      if (xorexp != nullptr) {
+        return xorexp;
+      }
+    }
+      [[fallthrough]];
+    case OP_cand:
+    case OP_land:
+    case OP_cior:
+    case OP_lior: {
+      if (!IsPrimitiveInteger(opmeexpr->GetPrimType())) {
+        return nullptr;
+      }
+      MeExpr *opnd0 = opmeexpr->GetOpnd(0);
+      MeExpr *opnd1 = opmeexpr->GetOpnd(1);
+      if (opnd0->GetMeOp() != kMeOpConst || opnd1->GetMeOp() != kMeOpConst) {
+        return nullptr;
+      }
+      MIRIntConst *opnd0const = static_cast<MIRIntConst *>(static_cast<ConstMeExpr *>(opnd0)->GetConstVal());
+      MIRIntConst *opnd1const = static_cast<MIRIntConst *>(static_cast<ConstMeExpr *>(opnd1)->GetConstVal());
+      if ((opop == OP_div || opop == OP_rem) && !IsDivSafe(*opnd0const, *opnd1const, opmeexpr->GetPrimType())) {
+          return nullptr;
+      }
+      MIRConst *resconst = ConstantFold::FoldIntConstBinaryMIRConst(opmeexpr->GetOp(),
+          opmeexpr->GetPrimType(), opnd0const, opnd1const);
+      return CreateConstMeExpr(opmeexpr->GetPrimType(), *resconst);
+    }
+    case OP_depositbits: {
+      if (!IsPrimitiveInteger(opmeexpr->GetPrimType())) {
+        return nullptr;
+      }
+      return SimplifyDepositbits(*opmeexpr);
+    }
+    case OP_extractbits: {
+      if (!IsPrimitiveInteger(opmeexpr->GetPrimType())) {
+        return nullptr;
+      }
+      return SimplifyExtractbits(*opmeexpr);
+    }
+    case OP_sub: {
+      if (!IsPrimitiveInteger(opmeexpr->GetPrimType())) {
+        return nullptr;
+      }
+      MeExpr *opnd0 = opmeexpr->GetOpnd(0);
+      MeExpr *opnd1 = opmeexpr->GetOpnd(1);
+      if (opnd0 == opnd1) {
+        return CreateIntConstMeExpr(0, opmeexpr->GetPrimType());
+      }
+      if (opnd0->GetMeOp() == kMeOpConst && opnd1->GetMeOp() == kMeOpConst) {
+        return foldConst(opnd0, opnd1, opmeexpr->GetOp(), opmeexpr->GetPrimType());
+      }
+      return SimplifySubExpr(opmeexpr);
+    }
+    case OP_lshr: {
+      if (!IsPrimitiveInteger(opmeexpr->GetPrimType())) {
+        return nullptr;
+      }
+      MeExpr *opnd0 = opmeexpr->GetOpnd(0);
+      MeExpr *opnd1 = opmeexpr->GetOpnd(1);
+
+      if (opnd0->GetMeOp() == kMeOpConst && opnd1->GetMeOp() == kMeOpConst) {
+        return foldConst(opnd0, opnd1, opmeexpr->GetOp(), opmeexpr->GetPrimType());
+      }
+
+      return SimplifyLshrExpr(opmeexpr);
+    }
+    case OP_band: {
+      if (!IsPrimitiveInteger(opmeexpr->GetPrimType())) {
+        return nullptr;
+      }
+      MeExpr *opnd0 = opmeexpr->GetOpnd(0);
+      MeExpr *opnd1 = opmeexpr->GetOpnd(1);
+      if (opnd0->GetMeOp() == kMeOpConst && opnd1->GetMeOp() == kMeOpConst) {
+        return foldConst(opnd0, opnd1, opmeexpr->GetOp(), opmeexpr->GetPrimType());
+      }
+      return SimplifyBandExpr(opmeexpr);
+    }
+    case OP_ne:
+    case OP_eq:
+    case OP_lt:
+    case OP_le:
+    case OP_ge:
+    case OP_gt:
+    case OP_cmp:
+    case OP_cmpl:
+    case OP_cmpg:
+      return SimplifyCmpExpr(opmeexpr);
+    case OP_neg: {
+      auto *opnd = opmeexpr->GetOpnd(0);
+      if (opnd->GetMeOp() == kMeOpConst && IsPrimitiveInteger(opnd->GetPrimType()) &&
+          IsPrimitiveInteger(opmeexpr->GetPrimType())) {
+        return CreateIntConstMeExpr(-static_cast<ConstMeExpr*>(opnd)->GetExtIntValue(), opmeexpr->GetPrimType());
+      }
+      return nullptr;
+    }
+    case OP_select:
+      return SimplifySelExpr(opmeexpr);
+    default:
+      return nullptr;
+  }
+}
+
+MeExpr *IRMap::SimplifyMeExpr(MeExpr *x) {
+  if (IsPrimitiveVector(x->GetPrimType())) {
+    return x;
+  }
+  switch (x->GetMeOp()) {
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpSizeoftype:
+    case kMeOpFieldsDist:
+    case kMeOpVar:
+    case kMeOpReg:
+    case kMeOpIvar: return x;
+    case kMeOpOp: {
+      OpMeExpr *opexp = static_cast<OpMeExpr *>(x);
+      opexp->SetOpnd(0, SimplifyMeExpr(opexp->GetOpnd(0)));
+      if (opexp->GetNumOpnds() > 1) {
+        opexp->SetOpnd(1, SimplifyMeExpr(opexp->GetOpnd(1)));
+        if (opexp->GetNumOpnds() > 2) {
+          opexp->SetOpnd(2, SimplifyMeExpr(opexp->GetOpnd(2)));
+        }
+      }
+      MeExpr *newexp = SimplifyOpMeExpr(opexp);
+      if (newexp != nullptr) {
+        return newexp;
+      }
+      return opexp;
+    }
+    case kMeOpNary: {
+      NaryMeExpr *opexp = static_cast<NaryMeExpr *>(x);
+      for (uint32 i = 0; i < opexp->GetNumOpnds(); i++) {
+        opexp->SetOpnd(i, SimplifyMeExpr(opexp->GetOpnd(i)));
+      }
+      // mir lowerer has done its best, we remove the remaining builtin_expect
+      if (opexp->GetOp() == OP_intrinsicop && opexp->GetIntrinsic() == INTRN_C___builtin_expect) {
+        return opexp->GetOpnd(0);
+      }
+      return opexp;
+    }
+    default:
+      break;
+  }
+  return x;
+}
+
+MIRType *IRMap::GetArrayElemType(const MeExpr &opnd) {
+  MIRType *type = nullptr;
+  switch (opnd.GetOp()) {
+    case OP_addrof: {
+      type = static_cast<MIRPtrType*>(static_cast<const AddrofMeExpr&>(opnd).GetOst()->GetType())->GetPointedType();
+      break;
+    }
+    case OP_iaddrof: {
+      auto &opMeExpr = static_cast<const OpMeExpr&>(opnd);
+      MIRPtrType *ptrType =
+          static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(opMeExpr.GetTyIdx()));
+      type = (opMeExpr.GetFieldID() == 0) ? ptrType->GetPointedType() :
+          GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrType->GetPointedTyIdxWithFieldID(opMeExpr.GetFieldID()));
+      break;
+    }
+    default:
+      return nullptr;
+  }
+  if (type == nullptr) {
+    return nullptr;
+  }
+  return (type->GetKind() == kTypeArray) ? static_cast<MIRArrayType*>(type)->GetElemType() : type;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/irmap_build.cpp b/src/mapleall/maple_me/src/irmap_build.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4772973cbb716d20b82f5abb9a738ef518791566
--- /dev/null
+++ b/src/mapleall/maple_me/src/irmap_build.cpp
@@ -0,0 +1,993 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "irmap_build.h"
+#include "factory.h"
+#include "prop.h"
+
+// Methods to convert Maple IR to MeIR
+namespace maple {
+#ifdef USE_ARM32_MACRO
+static constexpr uint32 kMaxRegParamNum = 4;
+#else
+static constexpr uint32 kMaxRegParamNum = 8;
+#endif
+
+using MeExprBuildFactory = FunctionFactory<Opcode, std::unique_ptr<MeExpr>, const IRMapBuild*, BaseNode&>;
+using MeStmtFactory = FunctionFactory<Opcode, MeStmt*, IRMapBuild*, StmtNode&, AccessSSANodes&>;
+
+VarMeExpr *IRMapBuild::GetOrCreateVarFromVerSt(const VersionSt &vst) {
+  size_t vindex = vst.GetIndex();
+  ASSERT(vindex < irMap->verst2MeExprTable.size(), "GetOrCreateVarFromVerSt: index %d is out of range", vindex);
+  MeExpr *meExpr = irMap->verst2MeExprTable.at(vindex);
+  if (meExpr != nullptr) {
+    return static_cast<VarMeExpr*>(meExpr);
+  }
+  OriginalSt *ost = vst.GetOst();
+  ASSERT(ost->IsSymbolOst() || ost->GetIndirectLev() > 0, "GetOrCreateVarFromVerSt: wrong ost_type");
+  auto *varx = irMap->New<VarMeExpr>(irMap->exprID++, ost, vindex,
+      GlobalTables::GetTypeTable().GetTypeTable()[ost->GetTyIdx().GetIdx()]->GetPrimType());
+  ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check");
+  irMap->verst2MeExprTable[vindex] = varx;
+  return varx;
+}
+
+RegMeExpr *IRMapBuild::GetOrCreateRegFromVerSt(const VersionSt &vst) {
+  size_t vindex = vst.GetIndex();
+  ASSERT(vindex < irMap->verst2MeExprTable.size(), " GetOrCreateRegFromVerSt: index %d is out of range", vindex);
+  MeExpr *meExpr = irMap->verst2MeExprTable[vindex];
+  if (meExpr != nullptr) {
+    return static_cast<RegMeExpr*>(meExpr);
+  }
+  OriginalSt *ost = vst.GetOst();
+  ASSERT(ost->IsPregOst(), "GetOrCreateRegFromVerSt: PregOST expected");
+  auto *regx = irMap->New<RegMeExpr>(irMap->exprID++,
+                                     ost, vindex, kMeOpReg, OP_regread, ost->GetMIRPreg()->GetPrimType());
+  irMap->verst2MeExprTable[vindex] = regx;
+  return regx;
+}
+
+MeExpr *IRMapBuild::BuildLHSVar(const VersionSt &vst, DassignMeStmt &defMeStmt) {
+  VarMeExpr *meDef = GetOrCreateVarFromVerSt(vst);
+  if (!vst.GetOst()->IsVolatile()) {
+    meDef->SetDefStmt(&defMeStmt);
+    meDef->SetDefBy(kDefByStmt);
+  }
+  irMap->verst2MeExprTable.at(vst.GetIndex()) = meDef;
+  return meDef;
+}
+
+MeExpr *IRMapBuild::BuildLHSReg(const VersionSt &vst, AssignMeStmt &defMeStmt, const RegassignNode &regassign) {
+  RegMeExpr *meDef = GetOrCreateRegFromVerSt(vst);
+  meDef->SetPtyp(regassign.GetPrimType());
+  meDef->SetDefStmt(&defMeStmt);
+  meDef->SetDefBy(kDefByStmt);
+  irMap->verst2MeExprTable.at(vst.GetIndex()) = meDef;
+  return meDef;
+}
+
+// build Me chilist from MayDefNode list
+void IRMapBuild::BuildChiList(MeStmt &meStmt, TypeOfMayDefList &mayDefNodes,
+                              MapleMap<OStIdx, ChiMeNode*> &outList) {
+  for (auto &mayDefNodeItem : mayDefNodes) {
+    VersionSt *opndSt = mayDefNodeItem.second.GetOpnd();
+    VersionSt *resSt = mayDefNodeItem.second.GetResult();
+
+    auto *chiMeStmt = irMap->New<ChiMeNode>(&meStmt);
+    if (opndSt->GetOst()->IsSymbolOst()) {
+      chiMeStmt->SetRHS(GetOrCreateVarFromVerSt(*opndSt));
+    } else {
+      chiMeStmt->SetRHS(GetOrCreateRegFromVerSt(*opndSt));
+    }
+
+    ScalarMeExpr *lhs = nullptr;
+    if (resSt->GetOst()->IsSymbolOst()) {
+      lhs = GetOrCreateVarFromVerSt(*resSt);
+    } else {
+      lhs = GetOrCreateRegFromVerSt(*resSt);
+    }
+    lhs->SetDefBy(kDefByChi);
+    lhs->SetDefChi(*chiMeStmt);
+    chiMeStmt->SetLHS(lhs);
+    (void)outList.insert(std::make_pair(lhs->GetOstIdx(), chiMeStmt));
+  }
+}
+
+void IRMapBuild::BuildMustDefList(MeStmt &meStmt, TypeOfMustDefList &mustDefList,
+                                  MapleVector<MustDefMeNode> &mustDefMeList) {
+  for (auto &mustDefNode : mustDefList) {
+    VersionSt *vst = mustDefNode.GetResult();
+    ScalarMeExpr *lhs = nullptr;
+    if (vst->GetOst()->IsSymbolOst()) {
+      lhs = GetOrCreateVarFromVerSt(*vst);
+    } else {
+      lhs = GetOrCreateRegFromVerSt(*vst);
+    }
+    mustDefMeList.emplace_back(MustDefMeNode(lhs, &meStmt));
+  }
+}
+
+void IRMapBuild::BuildPhiMeNode(BB &bb) {
+  for (auto &phi : bb.GetPhiList()) {
+    const OriginalSt *oSt = ssaTab.GetOriginalStFromID(phi.first);
+    VersionSt *vSt = phi.second.GetResult();
+
+    auto *phiMeNode = irMap->NewInPool<MePhiNode>();
+    phiMeNode->SetDefBB(&bb);
+    (void)bb.GetMePhiList().insert(std::make_pair(oSt->GetIndex(), phiMeNode));
+    if (oSt->IsPregOst()) {
+      RegMeExpr *meDef = GetOrCreateRegFromVerSt(*vSt);
+      phiMeNode->UpdateLHS(*meDef);
+      // build phi operands
+      for (VersionSt *opnd : phi.second.GetPhiOpnds()) {
+        phiMeNode->GetOpnds().push_back(GetOrCreateRegFromVerSt(*opnd));
+      }
+    } else {
+      VarMeExpr *meDef = GetOrCreateVarFromVerSt(*vSt);
+      phiMeNode->UpdateLHS(*meDef);
+      // build phi operands
+      for (VersionSt *opnd : phi.second.GetPhiOpnds()) {
+        phiMeNode->GetOpnds().push_back(GetOrCreateVarFromVerSt(*opnd));
+      }
+    }
+  }
+}
+
+void IRMapBuild::BuildMuList(TypeOfMayUseList &mayUseList, MapleMap<OStIdx, ScalarMeExpr*> &muList) {
+  for (auto &mayUseNodeItem : mayUseList) {
+    VersionSt *vst = mayUseNodeItem.second.GetOpnd();
+    ScalarMeExpr *muExpr = nullptr;
+    if (vst->GetOst()->IsPregOst()) {
+      muExpr = GetOrCreateRegFromVerSt(*vst);
+    } else {
+      muExpr = GetOrCreateVarFromVerSt(*vst);
+    }
+    (void)muList.insert(std::make_pair(muExpr->GetOstIdx(), muExpr));
+  }
+}
+
+void IRMapBuild::SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode, bool atParm, bool noProp) {
+  if (mirNode.IsUnaryNode()) {
+    if (mirNode.GetOpCode() != OP_iread) {
+      meExpr.SetOpnd(0, BuildExpr(*static_cast<UnaryNode&>(mirNode).Opnd(0), atParm, noProp));
+    }
+  } else if (mirNode.IsBinaryNode()) {
+    auto &binaryNode = static_cast<BinaryNode&>(mirNode);
+    meExpr.SetOpnd(0, BuildExpr(*binaryNode.Opnd(0), atParm, noProp));
+    meExpr.SetOpnd(1, BuildExpr(*binaryNode.Opnd(1), atParm, noProp));
+    if (meExpr.IsOpMeExpr()) {
+      static_cast<OpMeExpr&>(meExpr).SetHasAddressValue();
+    }
+  } else if (mirNode.IsTernaryNode()) {
+    auto &ternaryNode = static_cast<TernaryNode&>(mirNode);
+    meExpr.SetOpnd(0, BuildExpr(*ternaryNode.Opnd(0), atParm, noProp));
+    meExpr.SetOpnd(1, BuildExpr(*ternaryNode.Opnd(1), atParm, noProp));
+    meExpr.SetOpnd(2, BuildExpr(*ternaryNode.Opnd(2), atParm, noProp));
+    if (meExpr.IsOpMeExpr()) {
+      static_cast<OpMeExpr&>(meExpr).SetHasAddressValue();
+    }
+  } else if (mirNode.IsNaryNode()) {
+    auto &naryMeExpr = static_cast<NaryMeExpr&>(meExpr);
+    auto &naryNode = static_cast<NaryNode&>(mirNode);
+    for (size_t i = 0; i < naryNode.NumOpnds(); ++i) {
+      naryMeExpr.GetOpnds().push_back(BuildExpr(*naryNode.Opnd(i), atParm, noProp));
+    }
+  } else {
+    // No need to do anything
+  }
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildAddrofMeExpr(const BaseNode &mirNode) const {
+  auto &addrofNode = static_cast<const AddrofSSANode&>(mirNode);
+  auto meExpr = std::make_unique<AddrofMeExpr>(kInvalidExprID, addrofNode.GetPrimType(),
+                                               addrofNode.GetSSAVar()->GetOst());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildAddroffuncMeExpr(const BaseNode &mirNode) const {
+  auto meExpr = std::make_unique<AddroffuncMeExpr>(kInvalidExprID,
+                                                   static_cast<const AddroffuncNode&>(mirNode).GetPUIdx());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildAddroflabelMeExpr(const BaseNode &mirNode) const {
+  auto meExpr = std::make_unique<AddroflabelMeExpr>(kInvalidExprID,
+                                                    static_cast<const AddroflabelNode&>(mirNode).GetOffset());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildGCMallocMeExpr(const BaseNode &mirNode) const {
+  auto meExpr = std::make_unique<GcmallocMeExpr>(kInvalidExprID, mirNode.GetOpCode(),
+                                                 mirNode.GetPrimType(),
+                                                 static_cast<const GCMallocNode&>(mirNode).GetTyIdx());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildSizeoftypeMeExpr(const BaseNode &mirNode) const {
+  auto meExpr = std::make_unique<SizeoftypeMeExpr>(kInvalidExprID, mirNode.GetPrimType(),
+                                                   static_cast<const SizeoftypeNode&>(mirNode).GetTyIdx());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildFieldsDistMeExpr(const BaseNode &mirNode) const {
+  auto &fieldsDistNode = static_cast<const FieldsDistNode&>(mirNode);
+  auto meExpr = std::make_unique<FieldsDistMeExpr>(kInvalidExprID, mirNode.GetPrimType(),
+                                                   fieldsDistNode.GetTyIdx(),
+                                                   fieldsDistNode.GetFiledID1(), fieldsDistNode.GetFiledID2());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildIvarMeExpr(const BaseNode &mirNode) const {
+  auto &ireadSSANode = static_cast<const IreadSSANode&>(mirNode);
+  auto meExpr = std::make_unique<IvarMeExpr>(&irMap->GetIRMapAlloc(), kInvalidExprID,
+                                             mirNode.GetPrimType(), ireadSSANode.GetTyIdx(),
+                                             ireadSSANode.GetFieldID());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildConstMeExpr(BaseNode &mirNode) const {
+  auto &constvalNode = static_cast<ConstvalNode&>(mirNode);
+  auto meExpr = std::make_unique<ConstMeExpr>(kInvalidExprID, constvalNode.GetConstVal(),
+                                              mirNode.GetPrimType());
+  meExpr->SetOp(OP_constval);
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildConststrMeExpr(const BaseNode &mirNode) const {
+  auto meExpr = std::make_unique<ConststrMeExpr>(kInvalidExprID,
+                                                 static_cast<const ConststrNode&>(mirNode).GetStrIdx(),
+                                                 mirNode.GetPrimType());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildConststr16MeExpr(const BaseNode &mirNode) const {
+  auto meExpr = std::make_unique<Conststr16MeExpr>(kInvalidExprID,
+                                                   static_cast<const Conststr16Node&>(mirNode).GetStrIdx(),
+                                                   mirNode.GetPrimType());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildOpMeExprForCompare(const BaseNode &mirNode) const {
+  auto meExpr = BuildOpMeExpr(mirNode);
+  meExpr->SetOpndType(static_cast<const CompareNode&>(mirNode).GetOpndType());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildOpMeExprForTypeCvt(const BaseNode &mirNode) const {
+  auto meExpr = BuildOpMeExpr(mirNode);
+  meExpr->SetOpndType(static_cast<const TypeCvtNode&>(mirNode).FromType());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildOpMeExprForRetype(const BaseNode &mirNode) const {
+  auto meExpr = BuildOpMeExpr(mirNode);
+  auto &retypeNode = static_cast<const RetypeNode&>(mirNode);
+  meExpr->SetOpndType(retypeNode.FromType());
+  meExpr->SetTyIdx(retypeNode.GetTyIdx());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildOpMeExprForIread(const BaseNode &mirNode) const {
+  auto meExpr = BuildOpMeExpr(mirNode);
+  auto &ireadNode = static_cast<const IreadNode&>(mirNode);
+  meExpr->SetTyIdx(ireadNode.GetTyIdx());
+  meExpr->SetFieldID(ireadNode.GetFieldID());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildOpMeExprForExtractbits(const BaseNode &mirNode) const {
+  auto meExpr = BuildOpMeExpr(mirNode);
+  auto &extractbitsNode = static_cast<const ExtractbitsNode&>(mirNode);
+  meExpr->SetBitsOffSet(extractbitsNode.GetBitsOffset());
+  meExpr->SetBitsSize(extractbitsNode.GetBitsSize());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildOpMeExprForDepositbits(const BaseNode &mirNode) const {
+  auto meExpr = BuildOpMeExpr(mirNode);
+  auto &depositbitsNode = static_cast<const DepositbitsNode&>(mirNode);
+  meExpr->SetBitsOffSet(depositbitsNode.GetBitsOffset());
+  meExpr->SetBitsSize(depositbitsNode.GetBitsSize());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildOpMeExprForJarrayMalloc(const BaseNode &mirNode) const {
+  auto meExpr = BuildOpMeExpr(mirNode);
+  meExpr->SetTyIdx(static_cast<const JarrayMallocNode&>(mirNode).GetTyIdx());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildOpMeExprForResolveFunc(const BaseNode &mirNode) const {
+  auto meExpr = BuildOpMeExpr(mirNode);
+  meExpr->SetFieldID(static_cast<FieldID>(static_cast<const ResolveFuncNode&>(mirNode).GetPuIdx()));
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildNaryMeExprForArray(const BaseNode &mirNode) const {
+  auto &arrayNode = static_cast<const ArrayNode&>(mirNode);
+  auto meExpr = std::make_unique<NaryMeExpr>(&irMap->irMapAlloc, kInvalidExprID, mirNode.GetOpCode(),
+                                             mirNode.GetPrimType(), mirNode.GetNumOpnds(),
+                                             arrayNode.GetTyIdx(), INTRN_UNDEFINED,
+                                             arrayNode.GetBoundsCheck());
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildNaryMeExprForIntrinsicop(const BaseNode &mirNode) const {
+  auto meExpr = std::make_unique<NaryMeExpr>(&irMap->irMapAlloc, kInvalidExprID, mirNode.GetOpCode(),
+                                             mirNode.GetPrimType(), mirNode.GetNumOpnds(), TyIdx(0),
+                                             static_cast<const IntrinsicopNode&>(mirNode).GetIntrinsic(),
+                                             false);
+  return meExpr;
+}
+
+std::unique_ptr<MeExpr> IRMapBuild::BuildNaryMeExprForIntrinsicWithType(const BaseNode &mirNode) const {
+  auto &intrinNode = static_cast<const IntrinsicopNode&>(mirNode);
+  auto meExpr = std::make_unique<NaryMeExpr>(&irMap->irMapAlloc, kInvalidExprID, mirNode.GetOpCode(),
+                                             mirNode.GetPrimType(), mirNode.GetNumOpnds(),
+                                             intrinNode.GetTyIdx(), intrinNode.GetIntrinsic(), false);
+  return meExpr;
+}
+
+MeExpr *IRMapBuild::BuildExpr(BaseNode &mirNode, bool atParm, bool noProp) {
+  Opcode op = mirNode.GetOpCode();
+  if (op == OP_dread) {
+    auto &addrOfNode = static_cast<AddrofSSANode&>(mirNode);
+    VersionSt *vst = addrOfNode.GetSSAVar();
+    VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*vst);
+    ASSERT(!vst->GetOst()->IsPregOst(), "not expect preg symbol here");
+    varMeExpr->SetPtyp(GlobalTables::GetTypeTable().GetTypeFromTyIdx(vst->GetOst()->GetTyIdx())->GetPrimType());
+    varMeExpr->GetOst()->SetFieldID(addrOfNode.GetFieldID());
+    MeExpr *retmeexpr;
+    if (propagater && !noProp) {
+      MeExpr *propedMeExpr = &propagater->PropVar(*varMeExpr, atParm, true);
+      MeExpr *simplifiedMeexpr = nullptr;
+      if (propedMeExpr->GetMeOp() == kMeOpOp) {
+        simplifiedMeexpr = irMap->SimplifyOpMeExpr(static_cast<OpMeExpr *>(propedMeExpr));
+      }
+      retmeexpr = simplifiedMeexpr ? simplifiedMeexpr : propedMeExpr;
+    } else {
+      retmeexpr = varMeExpr;
+    }
+    uint32 typesize = GetPrimTypeSize(retmeexpr->GetPrimType());
+    if (typesize < GetPrimTypeSize(addrOfNode.GetPrimType()) && typesize != 0) {
+      // need to insert a convert
+      if (typesize < 4) {
+        OpMeExpr opmeexpr(kInvalidExprID, IsSignedInteger(retmeexpr->GetPrimType()) ? OP_sext : OP_zext,
+                          addrOfNode.GetPrimType(), 1);
+        opmeexpr.SetBitsSize(static_cast<uint8>(typesize * 8));
+        opmeexpr.SetOpnd(0, retmeexpr);
+        retmeexpr = irMap->HashMeExpr(opmeexpr);
+      } else {
+        bool isSigned = IsSignedInteger(addrOfNode.GetPrimType());
+        retmeexpr = irMap->CreateMeExprTypeCvt(addrOfNode.GetPrimType(), isSigned ? PTY_i32 : PTY_u32, *retmeexpr);
+      }
+      // Try to simplify new added cast expr
+      MeExpr *simplified = irMap->SimplifyMeExpr(retmeexpr);
+      retmeexpr = (simplified != nullptr ? simplified : retmeexpr);
+    }
+    return retmeexpr;
+  }
+
+  if (op == OP_regread) {
+    auto &regNode = static_cast<RegreadSSANode&>(mirNode);
+    VersionSt *vst = regNode.GetSSAVar();
+    RegMeExpr *regMeExpr = GetOrCreateRegFromVerSt(*vst);
+    regMeExpr->SetPtyp(mirNode.GetPrimType());
+    return regMeExpr;
+  }
+
+  auto func = CreateProductFunction<MeExprBuildFactory>(mirNode.GetOpCode());
+  ASSERT(func != nullptr, "NIY BuildExpe");
+  auto meExpr = func(this, mirNode);
+  SetMeExprOpnds(*meExpr, mirNode, atParm, noProp);
+
+  if (op == OP_iread) {
+    IvarMeExpr *ivarMeExpr = static_cast<IvarMeExpr*>(meExpr.get());
+    IreadSSANode &iReadSSANode = static_cast<IreadSSANode&>(mirNode);
+    ivarMeExpr->SetBase(BuildExpr(*iReadSSANode.Opnd(0), atParm, false));
+    VersionSt *verSt = iReadSSANode.GetSSAVar();
+    if (verSt != nullptr) {
+      VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*verSt);
+      ivarMeExpr->SetMuItem(0, varMeExpr);
+      if (verSt->GetOst()->IsVolatile()) {
+        ivarMeExpr->SetVolatileFromBaseSymbol(true);
+      }
+    }
+
+    IvarMeExpr *canIvar = static_cast<IvarMeExpr *>(irMap->HashMeExpr(*ivarMeExpr));
+    ASSERT(static_cast<IvarMeExpr*>(canIvar)->GetUniqueMu() != nullptr,
+        "BuildExpr: ivar node cannot have mu == nullptr");
+    MeExpr *retmeexpr;
+    if (propagater && !noProp) {
+      MeExpr *propedMeExpr = &propagater->PropIvar(*canIvar);
+      MeExpr *simplifiedMeexpr = nullptr;
+      if (propedMeExpr->GetMeOp() == kMeOpOp) {
+        simplifiedMeexpr = irMap->SimplifyOpMeExpr(static_cast<OpMeExpr *>(propedMeExpr));
+      } else if (propedMeExpr->GetMeOp() == kMeOpIvar) {
+        simplifiedMeexpr = irMap->SimplifyIvar(static_cast<IvarMeExpr *>(propedMeExpr), false);
+      }
+      retmeexpr = simplifiedMeexpr ? simplifiedMeexpr : propedMeExpr;
+    } else {
+      retmeexpr = canIvar;
+    }
+
+    uint32 typesize = GetPrimTypeSize(retmeexpr->GetPrimType());
+    if (typesize < GetPrimTypeSize(iReadSSANode.GetPrimType()) && typesize != 0) {
+      // need to insert a convert
+      if (typesize < 4) {
+        OpMeExpr opmeexpr(kInvalidExprID, IsSignedInteger(retmeexpr->GetPrimType()) ? OP_sext : OP_zext,
+                          iReadSSANode.GetPrimType(), 1);
+        opmeexpr.SetBitsSize(static_cast<uint8>(typesize * 8));
+        opmeexpr.SetOpnd(0, retmeexpr);
+        retmeexpr = irMap->HashMeExpr(opmeexpr);
+      } else {
+        retmeexpr = irMap->CreateMeExprTypeCvt(iReadSSANode.GetPrimType(), retmeexpr->GetPrimType(), *retmeexpr);
+      }
+    }
+    return retmeexpr;
+  }
+
+  if (meExpr->IsOpMeExpr()) {
+    auto *simplifiedMeExpr = irMap->SimplifyOpMeExpr(static_cast<OpMeExpr*>(meExpr.get()));
+    if (simplifiedMeExpr != nullptr) {
+      return simplifiedMeExpr;
+    }
+  }
+
+  if (op == OP_mul) {
+    OpMeExpr *opMeExpr = static_cast<OpMeExpr *>(meExpr.get());
+    if (opMeExpr->GetOpnd(0)->GetMeOp() == kMeOpConst) {
+      // canonicalize constant operand to be operand 1
+      MeExpr *savedOpnd = opMeExpr->GetOpnd(0);
+      opMeExpr->SetOpnd(0, opMeExpr->GetOpnd(1));
+      opMeExpr->SetOpnd(1, savedOpnd);
+    }
+  }
+
+  MeExpr *retMeExpr = irMap->HashMeExpr(*meExpr);
+
+  return retMeExpr;
+}
+
+void IRMapBuild::InitMeExprBuildFactory() {
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_addrof, &IRMapBuild::BuildAddrofMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_addroffunc, &IRMapBuild::BuildAddroffuncMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_addroflabel, &IRMapBuild::BuildAddroflabelMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_gcmalloc, &IRMapBuild::BuildGCMallocMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_gcpermalloc, &IRMapBuild::BuildGCMallocMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_sizeoftype, &IRMapBuild::BuildSizeoftypeMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_fieldsdist, &IRMapBuild::BuildFieldsDistMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_iread, &IRMapBuild::BuildIvarMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_constval, &IRMapBuild::BuildConstMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_conststr, &IRMapBuild::BuildConststrMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_conststr16, &IRMapBuild::BuildConststr16MeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_eq, &IRMapBuild::BuildOpMeExprForCompare);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_ne, &IRMapBuild::BuildOpMeExprForCompare);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_lt, &IRMapBuild::BuildOpMeExprForCompare);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_gt, &IRMapBuild::BuildOpMeExprForCompare);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_le, &IRMapBuild::BuildOpMeExprForCompare);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_ge, &IRMapBuild::BuildOpMeExprForCompare);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_cmpg, &IRMapBuild::BuildOpMeExprForCompare);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_cmpl, &IRMapBuild::BuildOpMeExprForCompare);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_cmp, &IRMapBuild::BuildOpMeExprForCompare);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_ceil, &IRMapBuild::BuildOpMeExprForTypeCvt);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_cvt, &IRMapBuild::BuildOpMeExprForTypeCvt);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_floor, &IRMapBuild::BuildOpMeExprForTypeCvt);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_round, &IRMapBuild::BuildOpMeExprForTypeCvt);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_trunc, &IRMapBuild::BuildOpMeExprForTypeCvt);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_retype, &IRMapBuild::BuildOpMeExprForRetype);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_abs, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_bnot, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_lnot, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_neg, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_recip, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_sqrt, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_alloca, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_malloc, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_iaddrof, &IRMapBuild::BuildOpMeExprForIread);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_sext, &IRMapBuild::BuildOpMeExprForExtractbits);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_zext, &IRMapBuild::BuildOpMeExprForExtractbits);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_extractbits, &IRMapBuild::BuildOpMeExprForExtractbits);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_depositbits, &IRMapBuild::BuildOpMeExprForDepositbits);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_gcmallocjarray, &IRMapBuild::BuildOpMeExprForJarrayMalloc);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_gcpermallocjarray, &IRMapBuild::BuildOpMeExprForJarrayMalloc);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_resolveinterfacefunc, &IRMapBuild::BuildOpMeExprForResolveFunc);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_resolvevirtualfunc, &IRMapBuild::BuildOpMeExprForResolveFunc);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_sub, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_mul, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_div, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_rem, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_ashr, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_lshr, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_shl, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_ror, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_max, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_min, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_band, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_bior, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_bxor, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_land, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_lior, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_add, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_select, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_cand, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_cior, &IRMapBuild::BuildOpMeExpr);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_array, &IRMapBuild::BuildNaryMeExprForArray);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_intrinsicop, &IRMapBuild::BuildNaryMeExprForIntrinsicop);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_intrinsicopwithtype, &IRMapBuild::BuildNaryMeExprForIntrinsicWithType);
+}
+
+MeStmt *IRMapBuild::BuildMeStmtWithNoSSAPart(StmtNode &stmt) {
+  Opcode op = stmt.GetOpCode();
+  switch (op) {
+    case OP_jscatch:
+    case OP_finally:
+    case OP_endtry:
+    case OP_cleanuptry:
+    case OP_membaracquire:
+    case OP_membarrelease:
+    case OP_membarstorestore:
+    case OP_membarstoreload:
+      return irMap->New<MeStmt>(&stmt);
+    case OP_goto:
+      return irMap->New<GotoMeStmt>(&stmt);
+    case OP_comment:
+      return irMap->NewInPool<CommentMeStmt>(&stmt);
+    case OP_jstry:
+      return irMap->New<JsTryMeStmt>(&stmt);
+    case OP_catch:
+      return irMap->NewInPool<CatchMeStmt>(&stmt);
+    case OP_brfalse:
+    case OP_brtrue: {
+      auto &condGotoNode = static_cast<CondGotoNode&>(stmt);
+      auto *condGotoMeStmt = irMap->New<CondGotoMeStmt>(&stmt);
+      condGotoMeStmt->SetOpnd(0, BuildExpr(*condGotoNode.Opnd(0), false, false));
+      return condGotoMeStmt;
+    }
+    case OP_try: {
+      auto &tryNode = static_cast<TryNode&>(stmt);
+      auto *tryMeStmt = irMap->NewInPool<TryMeStmt>(&stmt);
+      for (size_t i = 0; i < tryNode.GetOffsetsCount(); ++i) {
+        tryMeStmt->OffsetsPushBack(tryNode.GetOffset(i));
+      }
+      return tryMeStmt;
+    }
+    case OP_eval:
+    case OP_igoto:
+    case OP_free: {
+      auto &unaryStmt = static_cast<UnaryStmtNode&>(stmt);
+      auto *unMeStmt = irMap->New<UnaryMeStmt>(&stmt);
+      unMeStmt->SetOpnd(0, BuildExpr(*unaryStmt.Opnd(0), false, false));
+      return unMeStmt;
+    }
+    case OP_switch: {
+      auto &switchNode = static_cast<SwitchNode&>(stmt);
+      auto *meStmt = irMap->NewInPool<SwitchMeStmt>(&stmt);
+      meStmt->SetOpnd(0, BuildExpr(*switchNode.Opnd(0), false, false));
+      return meStmt;
+    }
+    case OP_calcassertge:
+    case OP_calcassertlt:
+    case OP_returnassertle:
+    case OP_assignassertle:
+    case OP_assertge:
+    case OP_assertlt: {
+      auto &checkStmt = static_cast<AssertBoundaryStmtNode&>(stmt);
+      auto *naryMeStmt = irMap->NewInPool<AssertBoundaryMeStmt>(&checkStmt);
+      naryMeStmt->PushBackOpnd(BuildExpr(*checkStmt.Opnd(0), false, false));
+      naryMeStmt->PushBackOpnd(BuildExpr(*checkStmt.Opnd(1), false, false));
+      return naryMeStmt;
+    }
+    case OP_callassertle: {
+      auto &checkStmt = static_cast<CallAssertBoundaryStmtNode&>(stmt);
+      auto *naryMeStmt = static_cast<NaryMeStmt*>(irMap->NewInPool<CallAssertBoundaryMeStmt>(&checkStmt));
+      naryMeStmt->PushBackOpnd(BuildExpr(*checkStmt.Opnd(0), false, false));
+      naryMeStmt->PushBackOpnd(BuildExpr(*checkStmt.Opnd(1), false, false));
+      return naryMeStmt;
+    }
+    case OP_callassertnonnull: {
+      auto &checkStmt = static_cast<CallAssertNonnullStmtNode&>(stmt);
+      auto *checkMeStmt = irMap->New<CallAssertNonnullMeStmt>(&checkStmt);
+      checkMeStmt->SetOpnd(0, BuildExpr(*checkStmt.Opnd(0), false, false));
+      return checkMeStmt;
+    }
+    case OP_assertnonnull:
+    case OP_assignassertnonnull:
+    case OP_returnassertnonnull: {
+      if (mirModule.IsCModule()) {
+        auto &checkStmt = static_cast<AssertNonnullStmtNode&>(stmt);
+        auto *checkMeStmt = irMap->New<AssertNonnullMeStmt>(&checkStmt);
+        checkMeStmt->SetOpnd(0, BuildExpr(*checkStmt.Opnd(0), false, false));
+        return checkMeStmt;
+      } else {
+        auto &checkStmt = static_cast<UnaryStmtNode&>(stmt);
+        auto *checkMeStmt = irMap->New<UnaryMeStmt>(&checkStmt);
+        checkMeStmt->SetOpnd(0, BuildExpr(*checkStmt.Opnd(0), false, false));
+        return checkMeStmt;
+      }
+    }
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+}
+
+static bool IncDecAmountIsSmallInteger(MeExpr *x) {
+  if (x->GetMeOp() != kMeOpConst) {
+    return false;
+  }
+  ConstMeExpr *cMeExpr = static_cast<ConstMeExpr *>(x);
+  MIRIntConst *cnode = dynamic_cast<MIRIntConst *>(cMeExpr->GetConstVal());
+  return cnode != nullptr && cnode->GetExtValue() < 0x1000;
+}
+
+MeStmt *IRMapBuild::BuildDassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  DassignMeStmt *meStmt = irMap->NewInPool<DassignMeStmt>(&stmt);
+  DassignNode &dassiNode = static_cast<DassignNode&>(stmt);
+  VarMeExpr *varLHS = static_cast<VarMeExpr*>(BuildLHSVar(*ssaPart.GetSSAVar(), *meStmt));
+  meStmt->SetLHS(varLHS);
+  MeExpr *propedRHS = BuildExpr(*dassiNode.GetRHS(), false, false);
+  bool noprop = (propagater && propagater->NoPropUnionAggField(meStmt, &stmt, propedRHS));
+  if (!noprop) {
+    meStmt->SetRHS(propedRHS);
+  } else {
+    meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS(), false, true));
+  }
+  irMap->SimplifyCastForAssign(meStmt);
+  BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *meStmt->GetChiList());
+  // determine isIncDecStmt
+  if (meStmt->GetChiList()->empty()) {
+    MeExpr *rhs = meStmt->GetRHS();
+    OriginalSt *ost = varLHS->GetOst();
+    if (ost->GetType()->GetSize() >= 4 &&
+        (rhs->GetOp() == OP_add || rhs->GetOp() == OP_sub) &&
+        IsPrimitivePureScalar(rhs->GetPrimType())) {
+      OpMeExpr *oprhs = static_cast<OpMeExpr *>(rhs);
+      if (oprhs->GetOpnd(0)->GetMeOp() == kMeOpVar && IncDecAmountIsSmallInteger(oprhs->GetOpnd(1))) {
+        meStmt->isIncDecStmt = ost == static_cast<VarMeExpr *>(oprhs->GetOpnd(0))->GetOst();
+      }
+    }
+  }
+  if (propagater) {
+    propagater->PropUpdateDef(*meStmt->GetLHS());
+    propagater->PropUpdateChiListDef(*meStmt->GetChiList());
+  }
+  return meStmt;
+}
+
+MeStmt *IRMapBuild::BuildAssignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  auto *meStmt = irMap->New<AssignMeStmt>(&stmt);
+  auto &regNode = static_cast<RegassignNode&>(stmt);
+  meStmt->SetRHS(BuildExpr(*regNode.Opnd(0), false, false));
+  auto *regLHS = static_cast<RegMeExpr*>(BuildLHSReg(*ssaPart.GetSSAVar(), *meStmt, regNode));
+  meStmt->UpdateLhs(regLHS);
+  irMap->SimplifyCastForAssign(meStmt);
+  // determine isIncDecStmt
+  MeExpr *rhs = meStmt->GetRHS();
+  if (rhs->GetOp() == OP_add || rhs->GetOp() == OP_sub) {
+    OpMeExpr *oprhs = static_cast<OpMeExpr *>(rhs);
+    if (oprhs->GetOpnd(0)->GetMeOp() == kMeOpReg && oprhs->GetOpnd(1)->GetMeOp() == kMeOpConst) {
+      meStmt->isIncDecStmt = regLHS->GetOst() == static_cast<RegMeExpr *>(oprhs->GetOpnd(0))->GetOst();
+    }
+  }
+  if (propagater) {
+    propagater->PropUpdateDef(*meStmt->GetLHS());
+  }
+  return meStmt;
+}
+
+MeStmt *IRMapBuild::BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  auto &iasNode = static_cast<IassignNode&>(stmt);
+
+  auto *baseAddr = BuildExpr(*iasNode.Opnd(0), false, false);
+  CHECK_FATAL(baseAddr, "baseAddr is nullptr!");
+  if (baseAddr->GetOp() == OP_addrof) {
+    auto *addrofExpr = static_cast<AddrofMeExpr*>(baseAddr);
+    auto *ost = addrofExpr->GetOst();
+    auto *iassType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iasNode.GetTyIdx());
+    if (static_cast<MIRPtrType*>(iassType)->GetPointedTyIdx() == ost->GetTyIdx()) {
+      auto fldId = iasNode.GetFieldID() + addrofExpr->GetFieldID();
+      OStIdx ostIdx(0);
+      if (fldId != 0) {
+        auto preLevType = ost->GetPrevLevelOst()->GetType();
+        auto type = static_cast<MIRPtrType*>(preLevType)->GetPointedType();
+        CHECK_FATAL(static_cast<uint32>(fldId) <= type->NumberOfFieldIDs(), "field id out of range");
+        auto fieldType = static_cast<MIRStructType*>(type)->GetFieldType(fldId);
+        OffsetType offset(static_cast<MIRStructType*>(type)->GetBitOffsetFromBaseAddr(fldId));
+        auto *siblingOsts = ssaTab.GetNextLevelOsts(ost->GetPointerVstIdx());
+        auto fieldOst = ssaTab.GetOriginalStTable().FindExtraLevOriginalSt(
+            *siblingOsts, preLevType->GetTypeIndex(), fieldType, fldId, offset);
+        if (fieldOst != nullptr) {
+          ostIdx = fieldOst->GetIndex();
+        }
+      } else {
+        ostIdx = addrofExpr->GetOstIdx();
+      }
+      if (ostIdx != 0) {
+        TypeOfMayDefList &mayDefList = ssaPart.GetMayDefNodes();
+        if (mayDefList.find(ostIdx) != mayDefList.end()) {
+          auto *vst = mayDefList.at(ostIdx).GetResult();
+          VarMeExpr *lhs = GetOrCreateVarFromVerSt(*vst);
+          CHECK_FATAL(fldId == lhs->GetFieldID(), "field id must be equal");
+          auto rhs = BuildExpr(*iasNode.GetRHS(), false, false);
+          auto *meStmt = irMap->New<DassignMeStmt>(&irMap->GetIRMapAlloc(), lhs, rhs);
+
+          BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *(meStmt->GetChiList()));
+          meStmt->GetChiList()->erase(lhs->GetOstIdx());
+          lhs->SetDefByStmt(*meStmt);
+          lhs->SetDefBy(kDefByStmt);
+          if (propagater) {
+            propagater->PropUpdateDef(*meStmt->GetLHS());
+            propagater->PropUpdateChiListDef(*meStmt->GetChiList());
+          }
+          return meStmt;
+        }
+      }
+    }
+  }
+
+  IassignMeStmt *meStmt = irMap->NewInPool<IassignMeStmt>(&stmt);
+  meStmt->SetTyIdx(iasNode.GetTyIdx());
+  meStmt->SetRHS(BuildExpr(*iasNode.GetRHS(), false, false));
+  auto *lhsIvar = irMap->BuildLHSIvar(*baseAddr, *meStmt, iasNode.GetFieldID());
+  if (mirModule.IsCModule()) {
+    bool isVolt = false;
+    for (auto &maydefItem : ssaPart.GetMayDefNodes()) {
+      const OriginalSt *ost = maydefItem.second.GetResult()->GetOst();
+      if (ost->IsVolatile()) {
+        isVolt = true;
+        break;
+      }
+    }
+    if (isVolt) {
+      lhsIvar->SetVolatileFromBaseSymbol(true);
+    }
+  }
+  auto *simplifiedIvar = irMap->SimplifyIvar(lhsIvar, true);
+  if (simplifiedIvar != nullptr && simplifiedIvar->GetMeOp() == kMeOpIvar) {
+    lhsIvar = static_cast<IvarMeExpr *>(simplifiedIvar);
+  }
+  meStmt->SetLHSVal(lhsIvar);
+  meStmt->SetExpandFromArrayOfCharFunc(static_cast<IassignNode &>(stmt).IsExpandedFromArrayOfCharFunc());
+
+  irMap->SimplifyCastForAssign(meStmt);
+  BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *(meStmt->GetChiList()));
+  if (propagater) {
+    propagater->PropUpdateChiListDef(*meStmt->GetChiList());
+  }
+  return meStmt;
+}
+
+MeStmt *IRMapBuild::BuildMaydassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  auto *meStmt = irMap->NewInPool<MaydassignMeStmt>(&stmt);
+  auto &dassiNode = static_cast<DassignNode&>(stmt);
+  meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS(), false, false));
+  meStmt->SetMayDassignSym(ssaPart.GetSSAVar()->GetOst());
+  meStmt->SetFieldID(dassiNode.GetFieldID());
+  BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *(meStmt->GetChiList()));
+  if (propagater) {
+    propagater->PropUpdateChiListDef(*meStmt->GetChiList());
+  }
+  return meStmt;
+}
+
+MeStmt *IRMapBuild::BuildCallMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  auto *callMeStmt = irMap->NewInPool<CallMeStmt>(&stmt);
+  auto &intrinNode = static_cast<CallNode&>(stmt);
+  callMeStmt->SetPUIdx(intrinNode.GetPUIdx());
+  for (size_t i = 0; i < intrinNode.NumOpnds(); ++i) {
+    MeExpr *meExpr = BuildExpr(*intrinNode.Opnd(i), true, false);
+    if (i >= kMaxRegParamNum) {
+      PrimType origType = intrinNode.Opnd(i)->GetPrimType();
+      CHECK_FATAL(meExpr, "meExpr is nullptr!");
+      PrimType curType = meExpr->GetPrimType();
+      if (GetPrimTypeSize(origType) != GetPrimTypeSize(curType)) {
+        // When we pass parameters by stack, cvt is needed for call opnds if type size changes
+        meExpr = irMap->CreateMeExprTypeCvt(origType, curType, *meExpr);
+      }
+    }
+    callMeStmt->PushBackOpnd(meExpr);
+  }
+  BuildMuList(ssaPart.GetMayUseNodes(), *(callMeStmt->GetMuList()));
+  if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
+    BuildMustDefList(*callMeStmt, ssaPart.GetMustDefNodes(), *(callMeStmt->GetMustDefList()));
+  }
+  BuildChiList(*callMeStmt, ssaPart.GetMayDefNodes(), *(callMeStmt->GetChiList()));
+  if (propagater) {
+    propagater->PropUpdateChiListDef(*callMeStmt->GetChiList());
+    if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
+      propagater->PropUpdateMustDefList(callMeStmt);
+    }
+  }
+  return callMeStmt;
+}
+
+
+MeStmt *IRMapBuild::BuildNaryMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  Opcode op = stmt.GetOpCode();
+  NaryMeStmt *naryMeStmt = (op == OP_icall || op == OP_icallassigned ||
+                            op == OP_icallproto || op == OP_icallprotoassigned)
+                           ? static_cast<NaryMeStmt*>(irMap->NewInPool<IcallMeStmt>(&stmt))
+                           : static_cast<NaryMeStmt*>(irMap->NewInPool<IntrinsiccallMeStmt>(&stmt));
+  auto &naryStmtNode = static_cast<NaryStmtNode&>(stmt);
+  for (size_t i = 0; i < naryStmtNode.NumOpnds(); ++i) {
+    naryMeStmt->PushBackOpnd(BuildExpr(*naryStmtNode.Opnd(i), false, false));
+  }
+  BuildMuList(ssaPart.GetMayUseNodes(), *(naryMeStmt->GetMuList()));
+  if (kOpcodeInfo.IsCallAssigned(op)) {
+    BuildMustDefList(*naryMeStmt, ssaPart.GetMustDefNodes(), *(naryMeStmt->GetMustDefList()));
+  }
+  BuildChiList(*naryMeStmt, ssaPart.GetMayDefNodes(), *(naryMeStmt->GetChiList()));
+  if (propagater) {
+    propagater->PropUpdateChiListDef(*naryMeStmt->GetChiList());
+  }
+  if (op == OP_icallproto || op == OP_icallprotoassigned) {
+    static_cast<IcallMeStmt *>(naryMeStmt)->SetRetTyIdx(static_cast<IcallNode&>(stmt).GetRetTyIdx());
+  }
+  return naryMeStmt;
+}
+
+MeStmt *IRMapBuild::BuildRetMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  auto &retStmt = static_cast<NaryStmtNode&>(stmt);
+  auto *meStmt = irMap->NewInPool<RetMeStmt>(&stmt);
+  for (size_t i = 0; i < retStmt.NumOpnds(); ++i) {
+    meStmt->PushBackOpnd(BuildExpr(*retStmt.Opnd(i), false, false));
+  }
+  BuildMuList(ssaPart.GetMayUseNodes(), *(meStmt->GetMuList()));
+  return meStmt;
+}
+
+MeStmt *IRMapBuild::BuildWithMuMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  auto *retSub = irMap->NewInPool<WithMuMeStmt>(&stmt);
+  BuildMuList(ssaPart.GetMayUseNodes(), *(retSub->GetMuList()));
+  return retSub;
+}
+
+MeStmt *IRMapBuild::BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  auto *goSub = irMap->NewInPool<GosubMeStmt>(&stmt);
+  BuildMuList(ssaPart.GetMayUseNodes(), *(goSub->GetMuList()));
+  return goSub;
+}
+
+MeStmt *IRMapBuild::BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  auto &unaryNode = static_cast<UnaryStmtNode&>(stmt);
+  auto *tmeStmt = irMap->NewInPool<ThrowMeStmt>(&stmt);
+  tmeStmt->SetMeStmtOpndValue(BuildExpr(*unaryNode.Opnd(0), false, false));
+  BuildMuList(ssaPart.GetMayUseNodes(), *(tmeStmt->GetMuList()));
+  return tmeStmt;
+}
+
+MeStmt *IRMapBuild::BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  auto &naryNode = static_cast<NaryStmtNode&>(stmt);
+  auto *naryStmt = irMap->NewInPool<SyncMeStmt>(&stmt);
+  for (size_t i = 0; i < naryNode.NumOpnds(); ++i) {
+    naryStmt->PushBackOpnd(BuildExpr(*naryNode.Opnd(i), false, false));
+  }
+  BuildMuList(ssaPart.GetMayUseNodes(), *(naryStmt->GetMuList()));
+  BuildChiList(*naryStmt, ssaPart.GetMayDefNodes(), *(naryStmt->GetChiList()));
+  return naryStmt;
+}
+
+MeStmt *IRMapBuild::BuildAsmMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) {
+  AsmNode *asmNode = &static_cast<AsmNode&>(stmt);
+  AsmMeStmt *asmMeStmt = irMap->NewInPool<AsmMeStmt>(asmNode);
+  for (size_t i = 0; i < asmNode->NumOpnds(); ++i) {
+    asmMeStmt->PushBackOpnd(BuildExpr(*asmNode->Opnd(i), true, true));
+  }
+  BuildMuList(ssaPart.GetMayUseNodes(), *(asmMeStmt->GetMuList()));
+  BuildMustDefList(*asmMeStmt, ssaPart.GetMustDefNodes(), *(asmMeStmt->GetMustDefList()));
+  BuildChiList(*asmMeStmt, ssaPart.GetMayDefNodes(), *(asmMeStmt->GetChiList()));
+  asmMeStmt->asmString = asmNode->asmString;
+  asmMeStmt->inputConstraints = asmNode->inputConstraints;
+  asmMeStmt->outputConstraints = asmNode->outputConstraints;
+  asmMeStmt->clobberList = asmNode->clobberList;
+  asmMeStmt->gotoLabels = asmNode->gotoLabels;
+  asmMeStmt->qualifiers = asmNode->qualifiers;
+  if (propagater) {
+    propagater->PropUpdateChiListDef(*asmMeStmt->GetChiList());
+    propagater->PropUpdateMustDefList(asmMeStmt);
+  }
+  return asmMeStmt;
+}
+
+MeStmt *IRMapBuild::BuildMeStmt(StmtNode &stmt) {
+  AccessSSANodes *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt);
+  if (ssaPart == nullptr) {
+    return BuildMeStmtWithNoSSAPart(stmt);
+  }
+
+  auto func = CreateProductFunction<MeStmtFactory>(stmt.GetOpCode());
+  CHECK_FATAL(func != nullptr, "func nullptr check");
+  return func(this, stmt, *ssaPart);
+}
+
+void IRMapBuild::InitMeStmtFactory() {
+  RegisterFactoryFunction<MeStmtFactory>(OP_dassign, &IRMapBuild::BuildDassignMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_regassign, &IRMapBuild::BuildAssignMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_iassign, &IRMapBuild::BuildIassignMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_maydassign, &IRMapBuild::BuildMaydassignMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_call, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_virtualcall, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_virtualicall, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_superclasscall, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_interfacecall, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_interfaceicall, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_customcall, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_polymorphiccall, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_callassigned, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_virtualcallassigned, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_virtualicallassigned, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_superclasscallassigned, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_interfacecallassigned, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_interfaceicallassigned, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_customcallassigned, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_polymorphiccallassigned, &IRMapBuild::BuildCallMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_icall, &IRMapBuild::BuildNaryMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_icallassigned, &IRMapBuild::BuildNaryMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_icallproto, &IRMapBuild::BuildNaryMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_icallprotoassigned, &IRMapBuild::BuildNaryMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_intrinsiccall, &IRMapBuild::BuildNaryMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_xintrinsiccall, &IRMapBuild::BuildNaryMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_intrinsiccallwithtype, &IRMapBuild::BuildNaryMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_intrinsiccallassigned, &IRMapBuild::BuildNaryMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_intrinsiccallwithtypeassigned, &IRMapBuild::BuildNaryMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_return, &IRMapBuild::BuildRetMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_retsub, &IRMapBuild::BuildWithMuMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_gosub, &IRMapBuild::BuildGosubMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_throw, &IRMapBuild::BuildThrowMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_syncenter, &IRMapBuild::BuildSyncMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_syncexit, &IRMapBuild::BuildSyncMeStmt);
+  RegisterFactoryFunction<MeStmtFactory>(OP_asm, &IRMapBuild::BuildAsmMeStmt);
+}
+
+// recursively invoke itself in a pre-order traversal of the dominator tree of
+// the CFG to build the HSSA representation for the code in each BB
+void IRMapBuild::BuildBB(BB &bb, std::vector<bool> &bbIRMapProcessed) {
+  BBId bbID = bb.GetBBId();
+  if (bbIRMapProcessed[bbID]) {
+    return;
+  }
+  bbIRMapProcessed[bbID] = true;
+  curBB = &bb;
+  irMap->SetCurFunction(bb);
+  // iterate phi list to update the definition by phi
+  BuildPhiMeNode(bb);
+  if (propagater) { // proper is not null that means we will do propragation during build meir.
+    propagater->SetCurBB(&bb);
+    propagater->GrowVstLiveStack();
+    // traversal phi nodes
+    MapleMap<OStIdx, MePhiNode *> &mePhiList = bb.GetMePhiList();
+    for (auto it = mePhiList.begin(); it != mePhiList.end(); ++it) {
+      MePhiNode *phimenode = it->second;
+      propagater->PropUpdateDef(*phimenode->GetLHS());
+    }
+  }
+
+  if (!bb.IsEmpty()) {
+    for (auto &stmt : bb.GetStmtNodes()) {
+      MeStmt *meStmt = BuildMeStmt(stmt);
+      bb.AddMeStmtLast(meStmt);
+    }
+  }
+  // travesal bb's dominated tree
+  ASSERT(bbID < dominance.GetDomChildrenSize(), " index out of range in IRMapBuild::BuildBB");
+  const auto &domChildren = dominance.GetDomChildren(bbID.GetIdx());
+  for (auto bbIt = domChildren.begin(); bbIt != domChildren.end(); ++bbIt) {
+    BBId childBBId = BBId(*bbIt);
+    BuildBB(*irMap->GetBB(childBBId), bbIRMapProcessed);
+  }
+  if (propagater) {
+    propagater->RecoverVstLiveStack();
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/irmap_emit.cpp b/src/mapleall/maple_me/src/irmap_emit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9dcee51bd5aa68df4e1dbe839717e1ed6b345c26
--- /dev/null
+++ b/src/mapleall/maple_me/src/irmap_emit.cpp
@@ -0,0 +1,732 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// This file contains methods to emit Maple IR nodes from MeExpr/MeStmt
+#include "me_ir.h"
+#include "irmap.h"
+#include "mir_builder.h"
+#include "orig_symbol.h"
+
+namespace maple {
+static MIRFunction *GetCurFunction() {
+  return theMIRModule->CurFunction();
+}
+
+bool VarMeExpr::IsValidVerIdx() const {
+  if (!GetOst()->IsSymbolOst()) {
+    return false;
+  }
+  StIdx stIdx = GetOst()->GetMIRSymbol()->GetStIdx();
+  return stIdx.Islocal() ? GetCurFunction()->GetSymTab()->IsValidIdx(stIdx.Idx())
+                         : GlobalTables::GetGsymTable().IsValidIdx(stIdx.Idx());
+}
+
+BaseNode &VarMeExpr::EmitExpr(MapleAllocator &alloc) {
+  MIRSymbol *symbol = GetOst()->GetMIRSymbol();
+  if (symbol->IsLocal()) {
+    symbol->ResetIsDeleted();
+  }
+  auto *addrofNode = alloc.New<AddrofNode>(
+      OP_dread, PrimType(GetPrimType()), symbol->GetStIdx(), GetOst()->GetFieldID());
+  ASSERT(addrofNode->GetPrimType() != kPtyInvalid, "runtime check error");
+  ASSERT(IsValidVerIdx(), "runtime check error");
+  return *addrofNode;
+}
+
+BaseNode &RegMeExpr::EmitExpr(MapleAllocator &alloc) {
+  auto *regRead = alloc.New<RegreadNode>();
+  regRead->SetPrimType(GetPrimType());
+  regRead->SetRegIdx(GetRegIdx());
+  ASSERT(GetRegIdx() < 0 ||
+         static_cast<uint32>(static_cast<int32>(GetRegIdx())) < GetCurFunction()->GetPregTab()->Size(),
+         "RegMeExpr::EmitExpr: pregIdx exceeds preg table size");
+  return *regRead;
+}
+
+BaseNode &ConstMeExpr::EmitExpr(MapleAllocator &alloc) {
+  auto *exprConst = alloc.New<ConstvalNode>(PrimType(GetPrimType()), constVal);
+  // if int const has been promoted from dyn int const, remove the type tag
+  if (IsPrimitiveInteger(exprConst->GetPrimType())) {
+    auto *intConst = safe_cast<MIRIntConst>(exprConst->GetConstVal());
+    MIRIntConst *newIntConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(intConst->GetExtValue(),
+        intConst->GetType());
+    exprConst->SetConstVal(newIntConst);
+  }
+  return *exprConst;
+}
+
+BaseNode &ConststrMeExpr::EmitExpr(MapleAllocator &alloc) {
+  auto *exprConst = alloc.New<ConststrNode>(PrimType(GetPrimType()), strIdx);
+  return *exprConst;
+}
+
+BaseNode &Conststr16MeExpr::EmitExpr(MapleAllocator &alloc) {
+  auto *exprConst = alloc.New<Conststr16Node>(PrimType(GetPrimType()), strIdx);
+  return *exprConst;
+}
+
+BaseNode &SizeoftypeMeExpr::EmitExpr(MapleAllocator &alloc) {
+  auto *exprSizeoftype = alloc.New<SizeoftypeNode>(PrimType(GetPrimType()), tyIdx);
+  return *exprSizeoftype;
+}
+
+BaseNode &FieldsDistMeExpr::EmitExpr(MapleAllocator &alloc) {
+  auto *exprSizeofType = alloc.New<FieldsDistNode>(PrimType(GetPrimType()), tyIdx, fieldID1, fieldID2);
+  return *exprSizeofType;
+}
+
+BaseNode &AddrofMeExpr::EmitExpr(MapleAllocator &alloc) {
+  MIRSymbol *symbol = GetOst()->GetMIRSymbol();
+  if (symbol->IsLocal()) {
+    symbol->ResetIsDeleted();
+  }
+  auto *addrofNode = alloc.New<AddrofNode>(OP_addrof, PrimType(GetPrimType()), symbol->GetStIdx(), GetFieldID());
+  return *addrofNode;
+}
+
+BaseNode &AddroffuncMeExpr::EmitExpr(MapleAllocator &alloc) {
+  auto *addroffuncNode = alloc.New<AddroffuncNode>(PrimType(GetPrimType()), puIdx);
+  return *addroffuncNode;
+}
+
+BaseNode &AddroflabelMeExpr::EmitExpr(MapleAllocator &alloc) {
+  auto *addroflabelNode = alloc.New<AddroflabelNode>(labelIdx);
+  addroflabelNode->SetPrimType(PTY_ptr);
+  return *addroflabelNode;
+}
+
+BaseNode &GcmallocMeExpr::EmitExpr(MapleAllocator &alloc) {
+  auto *gcMallocNode = alloc.New<GCMallocNode>(Opcode(GetOp()), PrimType(GetPrimType()), tyIdx);
+  return *gcMallocNode;
+}
+
+BaseNode &OpMeExpr::EmitExpr(MapleAllocator &alloc) {
+  switch (GetOp()) {
+    case OP_add:
+    case OP_ashr:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_div:
+    case OP_land:
+    case OP_lior:
+    case OP_cand:
+    case OP_cior:
+    case OP_lshr:
+    case OP_max:
+    case OP_min:
+    case OP_mul:
+    case OP_rem:
+    case OP_shl:
+    case OP_ror:
+    case OP_sub: {
+      auto *binaryNode = alloc.New<BinaryNode>(Opcode(GetOp()), PrimType(GetPrimType()));
+      binaryNode->SetBOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      binaryNode->SetBOpnd(&opnds[1]->EmitExpr(alloc), 1);
+      return *binaryNode;
+    }
+    case OP_eq:
+    case OP_ne:
+    case OP_lt:
+    case OP_gt:
+    case OP_le:
+    case OP_ge:
+    case OP_cmpl:
+    case OP_cmpg:
+    case OP_cmp: {
+      auto *cmpNode = alloc.New<CompareNode>(Opcode(GetOp()), PrimType(GetPrimType()));
+      cmpNode->SetBOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      cmpNode->SetBOpnd(&opnds[1]->EmitExpr(alloc), 1);
+      cmpNode->SetOpndType(opndType);
+      return *cmpNode;
+    }
+    case OP_abs:
+    case OP_bnot:
+    case OP_lnot:
+    case OP_neg:
+    case OP_recip:
+    case OP_sqrt:
+    case OP_alloca:
+    case OP_malloc: {
+      auto *unaryNode = alloc.New<UnaryNode>(Opcode(GetOp()), PrimType(GetPrimType()));
+      unaryNode->SetOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      return *unaryNode;
+    }
+    case OP_sext:
+    case OP_zext:
+    case OP_extractbits: {
+      auto *unode = alloc.New<ExtractbitsNode>(Opcode(GetOp()), PrimType(GetPrimType()));
+      unode->SetOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      unode->SetBitsOffset(bitsOffset);
+      unode->SetBitsSize(bitsSize);
+      return *unode;
+    }
+    case OP_depositbits: {
+      auto *bnode = alloc.New<DepositbitsNode>(Opcode(GetOp()), PrimType(GetPrimType()));
+      bnode->SetOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      bnode->SetOpnd(&opnds[1]->EmitExpr(alloc), 1);
+      bnode->SetBitsOffset(bitsOffset);
+      bnode->SetBitsSize(bitsSize);
+      return *bnode;
+    }
+    case OP_select: {
+      auto *ternaryNode = alloc.New<TernaryNode>(Opcode(GetOp()), PrimType(GetPrimType()));
+      const size_t opndNumOfTernary = 3;
+      for (size_t i = 0; i < opndNumOfTernary; ++i) {
+        ternaryNode->SetOpnd(&opnds[i]->EmitExpr(alloc), i);
+      }
+      return *ternaryNode;
+    }
+    case OP_ceil:
+    case OP_cvt:
+    case OP_floor:
+    case OP_round:
+    case OP_trunc: {
+      auto *cvtNode = alloc.New<TypeCvtNode>(Opcode(GetOp()), PrimType(GetPrimType()));
+      cvtNode->SetOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      cvtNode->SetFromType(opndType);
+      return *cvtNode;
+    }
+    case OP_retype: {
+      auto *cvtNode = alloc.New<RetypeNode>(PrimType(GetPrimType()));
+      cvtNode->SetOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      cvtNode->SetFromType(opndType);
+      cvtNode->SetTyIdx(tyIdx);
+      return *cvtNode;
+    }
+    case OP_gcmallocjarray:
+    case OP_gcpermallocjarray: {
+      auto *arrayMalloc = alloc.New<JarrayMallocNode>(Opcode(GetOp()), PrimType(GetPrimType()));
+      arrayMalloc->SetOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      arrayMalloc->SetTyIdx(tyIdx);
+      return *arrayMalloc;
+    }
+    case OP_resolveinterfacefunc:
+    case OP_resolvevirtualfunc: {
+      auto *resolveNode = alloc.New<ResolveFuncNode>(Opcode(GetOp()), PrimType(GetPrimType()));
+      resolveNode->SetBOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      resolveNode->SetBOpnd(&opnds[1]->EmitExpr(alloc), 1);
+      resolveNode->SetPUIdx(fieldID);
+      return *resolveNode;
+    }
+    case OP_iaddrof: {
+      auto *iaddrof = alloc.New<IaddrofNode>(OP_iaddrof, PrimType(GetPrimType()));
+      iaddrof->SetOpnd(&opnds[0]->EmitExpr(alloc), 0);
+      iaddrof->SetTyIdx(tyIdx);
+      iaddrof->SetFieldID(fieldID);
+      return *iaddrof;
+    }
+    default:
+      CHECK_FATAL(false, "unexpected op");
+  }
+}
+
+BaseNode &NaryMeExpr::EmitExpr(MapleAllocator &alloc) {
+  BaseNode *nodeToReturn = nullptr;
+  NaryOpnds *nopndPart = nullptr;
+  if (GetOp() == OP_array) {
+    auto *arrayNode = alloc.New<ArrayNode>(alloc, PrimType(GetPrimType()), tyIdx);
+    arrayNode->SetNumOpnds(GetNumOpnds());
+    arrayNode->SetBoundsCheck(GetBoundCheck());
+    nopndPart = arrayNode;
+    nodeToReturn = arrayNode;
+  } else {
+    auto *intrinNode = alloc.New<IntrinsicopNode>(alloc, GetOp(), PrimType(GetPrimType()), tyIdx);
+    intrinNode->SetNumOpnds(GetNumOpnds());
+    intrinNode->SetIntrinsic(intrinsic);
+    nopndPart = intrinNode;
+    nodeToReturn = intrinNode;
+  }
+  for (auto it = GetOpnds().begin(); it != GetOpnds().end(); ++it) {
+    nopndPart->GetNopnd().push_back(&(*it)->EmitExpr(alloc));
+  }
+  return *nodeToReturn;
+}
+
+BaseNode &IvarMeExpr::EmitExpr(MapleAllocator &alloc) {
+  CHECK_NULL_FATAL(base);
+  auto *ireadNode = alloc.New<IreadNode>(OP_iread, PrimType(GetPrimType()));
+  if (offset == 0) {
+    ireadNode->SetOpnd(&base->EmitExpr(alloc), 0);
+  } else {
+    auto *mirType = GlobalTables::GetTypeTable().GetInt32();
+    auto *mirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(offset, *mirType);
+    auto *constValNode = alloc.New<ConstvalNode>(mirType->GetPrimType(), mirConst);
+    auto *newAddrNode =
+        alloc.New<BinaryNode>(OP_add, base->GetPrimType(), &(base->EmitExpr(alloc)), constValNode);
+    ireadNode->SetOpnd(newAddrNode, 0);
+  }
+  ireadNode->SetFieldID(fieldID);
+  ireadNode->SetTyIdx(tyIdx);
+  ASSERT(ireadNode->GetPrimType() != kPtyInvalid, "");
+  ASSERT(tyIdx != 0, "wrong tyIdx for iread node in me emit");
+  ireadNode->SetTyIdx(tyIdx);
+  return *ireadNode;
+}
+
+StmtNode &MeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *stmt = alloc.New<StmtNode>(Opcode(GetOp()));
+  return *stmt;
+}
+
+StmtNode &DassignMeStmt::EmitStmt(MapleAllocator &alloc) {
+  if (GetEmitDassignoff()) {
+    OriginalSt *lhsSt = GetLHS()->GetOst();
+    MIRSymbol *lhsMirSt = lhsSt->GetMIRSymbol();
+    if (lhsMirSt->IsLocal()) {
+      lhsMirSt->ResetIsDeleted();
+    }
+    StIdx lhsStIdx = lhsMirSt->GetStIdx();
+    int32 offset = (GetVarLHS()->GetOst()->GetOffset().val) / 8;
+    PrimType rhsType = GetRHS()->GetPrimType();
+    int64 val = static_cast<ConstMeExpr *>(GetRHS())->GetExtIntValue();
+    ConstvalNode *rhsNode = theMIRModule->GetMIRBuilder()->CreateIntConst(val, rhsType);
+    DassignoffNode *dassignoffNode = alloc.New<DassignoffNode>(lhsStIdx, offset, rhsType, rhsNode);
+    return *dassignoffNode;
+  } else {
+    auto *dassignStmt = alloc.New<DassignNode>();
+    MIRSymbol *symbol = GetVarLHS()->GetOst()->GetMIRSymbol();
+    if (symbol->IsLocal()) {
+      symbol->ResetIsDeleted();
+    }
+    dassignStmt->SetStIdx(symbol->GetStIdx());
+    dassignStmt->SetFieldID(GetVarLHS()->GetOst()->GetFieldID());
+    dassignStmt->SetRHS(&GetRHS()->EmitExpr(alloc));
+    return *dassignStmt;
+  }
+}
+
+StmtNode &AssignMeStmt::EmitStmt(MapleAllocator &alloc) {
+  CHECK_NULL_FATAL(lhs);
+  CHECK_NULL_FATAL(rhs);
+  RegassignNode *regassignStmt =
+      alloc.New<RegassignNode>(lhs->GetPrimType(), lhs->GetRegIdx(), &rhs->EmitExpr(alloc));
+  return *regassignStmt;
+}
+
+StmtNode &MaydassignMeStmt::EmitStmt(MapleAllocator &alloc) {
+  CHECK_NULL_FATAL(rhs);
+  auto *dassignStmt = alloc.New<DassignNode>();
+  MIRSymbol *symbol = mayDSSym->GetMIRSymbol();
+  if (symbol->IsLocal()) {
+    symbol->ResetIsDeleted();
+  }
+  dassignStmt->SetStIdx(symbol->GetStIdx());
+  dassignStmt->SetFieldID(fieldID);
+  dassignStmt->SetRHS(&rhs->EmitExpr(alloc));
+  return *dassignStmt;
+}
+
+void MeStmt::EmitCallReturnVector(CallReturnVector &nRets) {
+  MapleVector<MustDefMeNode> *mustDefs = GetMustDefList();
+  CHECK_FATAL(mustDefs != nullptr, "EmitCallReturnVector: mustDefList cannot be null");
+  for (MustDefMeNode &mustdef : *mustDefs) {
+    MeExpr *meExpr = mustdef.GetLHS();
+    if (meExpr->GetMeOp() == kMeOpVar) {
+      OriginalSt *ost = static_cast<VarMeExpr*>(meExpr)->GetOst();
+      MIRSymbol *symbol = ost->GetMIRSymbol();
+      nRets.push_back(CallReturnPair(symbol->GetStIdx(), RegFieldPair(0, 0)));
+    } else if (meExpr->GetMeOp() == kMeOpReg) {
+      nRets.push_back(CallReturnPair(StIdx(), RegFieldPair(0, static_cast<RegMeExpr*>(meExpr)->GetRegIdx())));
+    }
+  }
+}
+
+StmtNode &IassignMeStmt::EmitStmt(MapleAllocator &alloc) {
+  CHECK_NULL_FATAL(lhsVar);
+  CHECK_NULL_FATAL(rhs);
+  if (GetEmitIassignoff()) {
+    PrimType rhsType = GetOpnd(1)->GetPrimType();
+    TyIdx lhsTyIdx = GetLHSVal()->GetTyIdx();
+    MIRPtrType *lhsMirPtrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx));
+    MIRStructType *lhsStructType = static_cast<MIRStructType *>(lhsMirPtrType->GetPointedType());
+    IvarMeExpr *iVar = GetLHSVal();
+    int32 offset = static_cast<int32>(lhsStructType->GetBitOffsetFromBaseAddr(iVar->GetFieldID()) / 8);
+
+    ASSERT(static_cast<ConstMeExpr *> (GetOpnd(1)), "IassignMeStmt does NOT have Const RHS");
+    BaseNode *addrNode = nullptr;
+    if (lhsVar->GetOffset() == 0) {
+      addrNode = &lhsVar->GetBase()->EmitExpr(alloc);
+    } else {
+      MIRType *mirType = GlobalTables::GetTypeTable().GetInt32();
+      MIRIntConst *mirOffsetConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(lhsVar->GetOffset(), *mirType);
+      ConstvalNode *offsetNode = alloc.New<ConstvalNode>(mirType->GetPrimType(), mirOffsetConst);
+      addrNode = alloc.New<BinaryNode>(
+          OP_add, lhsVar->GetBase()->GetPrimType(), &(lhsVar->GetBase()->EmitExpr(alloc)), offsetNode);
+    }
+    int64 val = static_cast<ConstMeExpr *>(GetOpnd(1))->GetExtIntValue();
+    ConstvalNode *rhsNode = theMIRModule->GetMIRBuilder()->CreateIntConst(val, rhsType);
+    IassignoffNode *iassignoffNode = alloc.New<IassignoffNode>(rhsType, offset, addrNode, rhsNode);
+    return *iassignoffNode;
+  } else {
+    auto *iassignNode = alloc.New<IassignNode>();
+    iassignNode->SetTyIdx(tyIdx);
+    iassignNode->SetFieldID(lhsVar->GetFieldID());
+    if (lhsVar->GetOffset() == 0) {
+      iassignNode->SetAddrExpr(&lhsVar->GetBase()->EmitExpr(alloc));
+    } else {
+      auto *mirType = GlobalTables::GetTypeTable().GetInt32();
+      auto *mirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(lhsVar->GetOffset(), *mirType);
+      auto *constValNode = alloc.New<ConstvalNode>(mirType->GetPrimType(), mirConst);
+      auto *newAddrNode = alloc.New<BinaryNode>(
+          OP_add, lhsVar->GetBase()->GetPrimType(), &(lhsVar->GetBase()->EmitExpr(alloc)), constValNode);
+      iassignNode->SetAddrExpr(newAddrNode);
+    }
+    iassignNode->SetRHS(&rhs->EmitExpr(alloc));
+    return *iassignNode;
+  }
+}
+const MIRFunction &CallMeStmt::GetTargetFunction() const {
+  return *GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+}
+
+MIRFunction &CallMeStmt::GetTargetFunction() {
+  return *GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+}
+
+StmtNode &CallMeStmt::EmitStmt(MapleAllocator &alloc) {
+  if (GetOp() != OP_icall && GetOp() != OP_icallassigned &&
+      GetOp() != OP_icallproto && GetOp() != OP_icallprotoassigned) {
+    auto *callNode = alloc.New<CallNode>(alloc, Opcode(GetOp()));
+    callNode->SetPUIdx(puIdx);
+    callNode->SetTyIdx(tyIdx);
+    callNode->GetNopnd().resize(NumMeStmtOpnds());
+    for (size_t i = 0; i < NumMeStmtOpnds(); ++i) {
+      callNode->SetOpnd(&GetOpnd(i)->EmitExpr(alloc), i);
+    }
+    callNode->SetNumOpnds(callNode->GetNopndSize());
+    if (kOpcodeInfo.IsCallAssigned(GetOp())) {
+      EmitCallReturnVector(callNode->GetReturnVec());
+      for (size_t j = 0; j < callNode->GetReturnVec().size(); ++j) {
+        CallReturnPair retPair = callNode->GetReturnVec()[j];
+        if (!retPair.second.IsReg()) {
+          StIdx stIdx = retPair.first;
+          if (stIdx.Islocal()) {
+            MIRSymbolTable *symbolTab = GetCurFunction()->GetSymTab();
+            MIRSymbol *symbol = symbolTab->GetSymbolFromStIdx(stIdx.Idx());
+            CHECK_FATAL(symbol, "symbol is nullptr!");
+            symbol->ResetIsDeleted();
+          }
+        }
+      }
+    }
+    return *callNode;
+  }
+  auto *icallNode = alloc.New<IcallNode>(alloc, Opcode(GetOp()));
+  icallNode->GetNopnd().resize(NumMeStmtOpnds());
+  for (size_t i = 0; i < NumMeStmtOpnds(); ++i) {
+    icallNode->SetOpnd(&GetOpnd(i)->EmitExpr(alloc), i);
+  }
+  icallNode->SetNumOpnds(icallNode->GetNopndSize());
+  if (kOpcodeInfo.IsCallAssigned(GetOp())) {
+    EmitCallReturnVector(icallNode->GetReturnVec());
+    icallNode->SetRetTyIdx(TyIdx(PTY_void));
+    for (size_t j = 0; j < icallNode->GetReturnVec().size(); ++j) {
+      CallReturnPair retPair = icallNode->GetReturnVec()[j];
+      if (!retPair.second.IsReg()) {
+        StIdx stIdx = retPair.first;
+        MIRSymbolTable *symbolTab = GetCurFunction()->GetSymTab();
+        MIRSymbol *symbol = symbolTab->GetSymbolFromStIdx(stIdx.Idx());
+        ASSERT_NOT_NULL(symbol);
+        icallNode->SetRetTyIdx(symbol->GetType()->GetTypeIndex());
+        if (stIdx.Islocal()) {
+          symbol->ResetIsDeleted();
+        }
+      } else {
+        auto pregIdx = PregIdx(retPair.second.GetPregIdx());
+        MIRPreg *preg = GetCurFunction()->GetPregTab()->PregFromPregIdx(pregIdx);
+        icallNode->SetRetTyIdx(TyIdx(preg->GetPrimType()));
+      }
+    }
+  }
+  return *icallNode;
+}
+
+StmtNode &IcallMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *icallNode = alloc.New<IcallNode>(alloc, Opcode(GetOp()));
+  icallNode->GetNopnd().resize(NumMeStmtOpnds());
+  for (size_t i = 0; i < NumMeStmtOpnds(); ++i) {
+    icallNode->SetOpnd(&GetOpnd(i)->EmitExpr(alloc), i);
+  }
+  icallNode->SetNumOpnds(icallNode->GetNopndSize());
+  if (kOpcodeInfo.IsCallAssigned(GetOp())) {
+    EmitCallReturnVector(icallNode->GetReturnVec());
+    icallNode->SetRetTyIdx(TyIdx(PTY_void));
+    for (size_t j = 0; j < icallNode->GetReturnVec().size(); ++j) {
+      CallReturnPair retPair = icallNode->GetReturnVec()[j];
+      if (!retPair.second.IsReg()) {
+        StIdx stIdx = retPair.first;
+        MIRSymbolTable *symbolTab = GetCurFunction()->GetSymTab();
+        MIRSymbol *symbol = symbolTab->GetSymbolFromStIdx(stIdx.Idx());
+        icallNode->SetRetTyIdx(symbol->GetType()->GetTypeIndex());
+        if (stIdx.Islocal()) {
+          symbol->ResetIsDeleted();
+        }
+      } else {
+        auto pregIdx = PregIdx(retPair.second.GetPregIdx());
+        MIRPreg *preg = GetCurFunction()->GetPregTab()->PregFromPregIdx(pregIdx);
+        icallNode->SetRetTyIdx(TyIdx(preg->GetPrimType()));
+      }
+    }
+  }
+  if (GetOp() == OP_icallproto || GetOp() == OP_icallprotoassigned) {
+    icallNode->SetRetTyIdx(retTyIdx);
+  }
+  return *icallNode;
+}
+
+StmtNode &IntrinsiccallMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *callNode = alloc.New<IntrinsiccallNode>(alloc, Opcode(GetOp()));
+  callNode->SetIntrinsic(intrinsic);
+  callNode->SetTyIdx(tyIdx);
+  callNode->GetNopnd().resize(NumMeStmtOpnds());
+  for (size_t i = 0; i < NumMeStmtOpnds(); ++i) {
+    callNode->SetOpnd(&GetOpnd(i)->EmitExpr(alloc), i);
+  }
+  callNode->SetNumOpnds(callNode->GetNopndSize());
+  if (kOpcodeInfo.IsCallAssigned(GetOp())) {
+    EmitCallReturnVector(callNode->GetReturnVec());
+    for (size_t j = 0; j < callNode->GetReturnVec().size(); ++j) {
+      CallReturnPair retPair = callNode->GetReturnVec()[j];
+      if (!retPair.second.IsReg()) {
+        StIdx stIdx = retPair.first;
+        if (stIdx.Islocal()) {
+          MIRSymbolTable *symbolTab = GetCurFunction()->GetSymTab();
+          MIRSymbol *symbol = symbolTab->GetSymbolFromStIdx(stIdx.Idx());
+          ASSERT_NOT_NULL(symbol);
+          symbol->ResetIsDeleted();
+        }
+      }
+    }
+  }
+  return *callNode;
+}
+
+StmtNode &AsmMeStmt::EmitStmt(MapleAllocator &alloc) {
+  AsmNode *asmNode = alloc.New<AsmNode>(&alloc);
+  asmNode->GetNopnd().resize(NumMeStmtOpnds());
+  for (size_t i = 0; i < NumMeStmtOpnds(); ++i) {
+    asmNode->SetOpnd(&GetOpnd(i)->EmitExpr(alloc), i);
+  }
+  asmNode->SetNumOpnds(static_cast<uint8>(asmNode->GetNopndSize()));
+  EmitCallReturnVector(*asmNode->GetCallReturnVector());
+  for (size_t j = 0; j < asmNode->GetCallReturnVector()->size(); ++j) {
+    CallReturnPair retPair = (*asmNode->GetCallReturnVector())[j];
+    if (!retPair.second.IsReg()) {
+      StIdx stIdx = retPair.first;
+      if (stIdx.Islocal()) {
+        MIRSymbolTable *symbolTab = GetCurFunction()->GetSymTab();
+        MIRSymbol *symbol = symbolTab->GetSymbolFromStIdx(stIdx.Idx());
+        ASSERT_NOT_NULL(symbol);
+        symbol->ResetIsDeleted();
+      }
+    }
+  }
+  asmNode->asmString = asmString;
+  asmNode->inputConstraints = inputConstraints;
+  asmNode->outputConstraints = outputConstraints;
+  asmNode->clobberList = clobberList;
+  asmNode->gotoLabels = gotoLabels;
+  asmNode->qualifiers = qualifiers;
+  return *asmNode;
+}
+
+StmtNode &NaryMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *naryStmt = alloc.New<NaryStmtNode>(alloc, Opcode(GetOp()));
+  naryStmt->GetNopnd().resize(NumMeStmtOpnds());
+  for (size_t i = 0; i < NumMeStmtOpnds(); ++i) {
+    naryStmt->SetOpnd(&opnds[i]->EmitExpr(alloc), i);
+  }
+  naryStmt->SetNumOpnds(naryStmt->GetNopndSize());
+  return *naryStmt;
+}
+
+StmtNode &UnaryMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *unaryStmt = alloc.New<UnaryStmtNode>(Opcode(GetOp()));
+  CHECK_NULL_FATAL(opnd);
+  unaryStmt->SetOpnd(&opnd->EmitExpr(alloc), 0);
+  return *unaryStmt;
+}
+
+StmtNode &CallAssertNonnullMeStmt::EmitStmt(MapleAllocator &alloc) {
+  std::string funcName = GetFuncName();
+  std::string stmtFuncName = GetStmtFuncName();
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  GStrIdx stmtStridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(stmtFuncName);
+  auto *ret = alloc.New<CallAssertNonnullStmtNode>(GetOp(), stridx, GetParamIndex(), stmtStridx);
+  ret->SetOpnd(&GetOpnd()->EmitExpr(alloc), 0);
+  return *ret;
+}
+
+StmtNode &AssertNonnullMeStmt::EmitStmt(MapleAllocator &alloc) {
+  GStrIdx stridx = GetFuncNameIdx();
+  auto *ret = alloc.New<AssertNonnullStmtNode>(GetOp(), stridx);
+  ret->SetOpnd(&GetOpnd()->EmitExpr(alloc), 0);
+  return *ret;
+}
+
+StmtNode &AssertBoundaryMeStmt::EmitStmt(MapleAllocator &alloc) {
+  std::string funcName = GetFuncName();
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  auto *ret = alloc.New<AssertBoundaryStmtNode>(alloc, GetOp(), stridx);
+  ret->GetNopnd().resize(NumMeStmtOpnds());
+  for (size_t i = 0; i < NumMeStmtOpnds(); ++i) {
+    ret->SetOpnd(&GetOpnd(i)->EmitExpr(alloc), i);
+  }
+  ret->SetNumOpnds(static_cast<uint8>(ret->GetNopndSize()));
+  return *ret;
+}
+
+StmtNode &CallAssertBoundaryMeStmt::EmitStmt(MapleAllocator &alloc) {
+  std::string funcName = GetFuncName();
+  std::string stmtFuncName = GetStmtFuncName();
+  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName);
+  GStrIdx stmtStridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(stmtFuncName);
+  auto *ret = alloc.New<CallAssertBoundaryStmtNode>(alloc, GetOp(), stridx, GetParamIndex(), stmtStridx);
+  ret->GetNopnd().resize(NumMeStmtOpnds());
+  for (size_t i = 0; i < NumMeStmtOpnds(); ++i) {
+    ret->SetOpnd(&GetOpnd(i)->EmitExpr(alloc), i);
+  }
+  ret->SetNumOpnds(static_cast<uint8>(ret->GetNopndSize()));
+  return *ret;
+}
+
+StmtNode &GotoMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *gotoNode = alloc.New<GotoNode>(OP_goto);
+  gotoNode->SetOffset(offset);
+  return *gotoNode;
+}
+
+StmtNode &CondGotoMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *cgNode = alloc.New<CondGotoNode>(Opcode(GetOp()));
+  cgNode->SetOffset(offset);
+  cgNode->SetBranchProb(branchProb);
+  cgNode->SetOpnd(&GetOpnd()->EmitExpr(alloc), 0);
+  return *cgNode;
+}
+
+StmtNode &JsTryMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *jtNode = alloc.New<JsTryNode>();
+  jtNode->SetCatchOffset(catchOffset);
+  jtNode->SetFinallyOffset(finallyOffset);
+  return *jtNode;
+}
+
+StmtNode &TryMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *tryNode = alloc.New<TryNode>(alloc);
+  tryNode->ResizeOffsets(offsets.size());
+  for (size_t i = 0; i < offsets.size(); ++i) {
+    tryNode->SetOffset(offsets[i], i);
+  }
+  return *tryNode;
+}
+
+StmtNode &CatchMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *catchNode = alloc.New<CatchNode>(alloc);
+  catchNode->SetExceptionTyIdxVec(exceptionTyIdxVec);
+  return *catchNode;
+}
+
+StmtNode &SwitchMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *switchNode = alloc.New<SwitchNode>(alloc);
+  switchNode->SetDefaultLabel(defaultLabel);
+  switchNode->SetSwitchTable(switchTable);
+  switchNode->SetSwitchOpnd(&GetOpnd()->EmitExpr(alloc));
+  return *switchNode;
+}
+
+StmtNode &CommentMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *commentNode = alloc.New<CommentNode>(alloc);
+  commentNode->SetComment(comment);
+  return *commentNode;
+}
+
+StmtNode &ThrowMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *unaryStmt = alloc.New<UnaryStmtNode>(OP_throw);
+  CHECK_NULL_FATAL(opnd);
+  unaryStmt->SetOpnd(&opnd->EmitExpr(alloc), 0);
+  return *unaryStmt;
+}
+
+StmtNode &GosubMeStmt::EmitStmt(MapleAllocator &alloc) {
+  auto *gosubNode = alloc.New<GotoNode>(OP_gosub);
+  gosubNode->SetOffset(offset);
+  return *gosubNode;
+}
+
+void BB::EmitBB(BlockNode &curblk, bool needAnotherPass) {
+  StmtNode *bbFirstStmt = nullptr;
+  StmtNode *bbLastStmt = nullptr;
+  // emit head. label
+  LabelIdx labidx = GetBBLabel();
+  if (labidx != 0) {
+    LabelNode *lbnode = GetCurFunction()->GetCodeMemPool()->New<LabelNode>();
+    lbnode->SetLabelIdx(labidx);
+    curblk.AddStatement(lbnode);
+    bbFirstStmt = lbnode;
+    bbLastStmt = lbnode;
+  }
+  auto &meStmts = GetMeStmts();
+  for (auto &meStmt : meStmts) {
+    if (!needAnotherPass) {
+      if (meStmt.GetOp() == OP_interfaceicall) {
+        meStmt.SetOp(OP_icall);
+      } else if (meStmt.GetOp() == OP_interfaceicallassigned) {
+        meStmt.SetOp(OP_icallassigned);
+      }
+    }
+    StmtNode *stmt = &meStmt.EmitStmt(GetCurFunction()->GetCodeMPAllocator());
+    stmt->SetSrcPos(meStmt.GetSrcPosition());
+    stmt->SetOriginalID(meStmt.GetOriginalId());
+    stmt->CopySafeRegionAttr(meStmt.GetStmtAttr());
+    curblk.AddStatement(stmt);
+    if (bbFirstStmt == nullptr) {
+      bbFirstStmt = stmt;
+    }
+    bbLastStmt = stmt;
+    if (Options::profileUse && GetCurFunction()->GetFuncProfData() &&
+        (IsCallAssigned(stmt->GetOpCode()) || stmt->GetOpCode() == OP_call)) {
+      GetCurFunction()->GetFuncProfData()->SetStmtFreq(stmt->GetStmtID(), frequency);
+    }
+  }
+  if (GetAttributes(kBBAttrIsTryEnd)) {
+    // generate op_endtry
+    StmtNode *endtry = GetCurFunction()->GetCodeMemPool()->New<StmtNode>(OP_endtry);
+    curblk.AddStatement(endtry);
+    if (bbFirstStmt == nullptr) {
+      bbFirstStmt = endtry;
+    }
+    bbLastStmt = endtry;
+  }
+  stmtNodeList.set_first(bbFirstStmt);
+  stmtNodeList.set_last(bbLastStmt);
+  // set stmt freq
+  if (Options::profileUse && GetCurFunction()->GetFuncProfData()) {
+    if (bbFirstStmt) {
+      GetCurFunction()->GetFuncProfData()->SetStmtFreq(bbFirstStmt->GetStmtID(), frequency);
+    }
+    if (bbLastStmt && (bbFirstStmt != bbLastStmt)) {
+      GetCurFunction()->GetFuncProfData()->SetStmtFreq(bbLastStmt->GetStmtID(), frequency);
+    }
+    if (stmtNodeList.empty()) {
+      auto *commentNode = GetCurFunction()->GetCodeMemPool()->New<CommentNode>(*theMIRModule);
+      commentNode->SetComment("profileStmt");
+      GetCurFunction()->GetFuncProfData()->SetStmtFreq(commentNode->GetStmtID(), frequency);
+      curblk.AddStatement(commentNode);
+      stmtNodeList.set_first(commentNode);
+      stmtNodeList.set_last(commentNode);
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/lfo_dep_test.cpp b/src/mapleall/maple_me/src/lfo_dep_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7823ffa03baaf712a0dcfd57ff783d0e4ec1121f
--- /dev/null
+++ b/src/mapleall/maple_me/src/lfo_dep_test.cpp
@@ -0,0 +1,855 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "lfo_dep_test.h"
+#include "me_function.h"
+
+namespace maple {
+void LfoDepInfo::CreateDoloopInfo(BlockNode *block, DoloopInfo *parent) {
+  StmtNode *stmt = block->GetFirst();
+  while (stmt != nullptr) {
+    switch (stmt->GetOpCode()) {
+      case OP_doloop: {
+        DoloopNode *doloop = static_cast<DoloopNode *>(stmt);
+        DoloopInfo *doloopInfo = memPool->New<DoloopInfo>(&alloc, this, doloop, parent);
+        (void)doloopInfoMap.emplace(std::pair<DoloopNode *, DoloopInfo *>(doloop, doloopInfo));
+        if (parent != nullptr) {
+          parent->children.push_back(doloopInfo);
+        } else {
+          outermostDoloopInfoVec.push_back(doloopInfo);
+        }
+        PreMeMIRExtension *lfopart = preEmit->GetPreMeStmtExtension(doloop->GetStmtID());
+        MeStmt *meStmt = lfopart->GetMeStmt();
+        doloopInfo->doloopBB = meStmt->GetBB();
+        CreateDoloopInfo(doloop->GetDoBody(), doloopInfo);
+        break;
+      }
+      case OP_block: {
+        CreateDoloopInfo(static_cast<BlockNode *>(stmt), parent);
+        break;
+      }
+      case OP_if: {
+        IfStmtNode *ifstmtnode = static_cast<IfStmtNode *>(stmt);
+        if (ifstmtnode->GetThenPart()) {
+          CreateDoloopInfo(ifstmtnode->GetThenPart(), parent);
+        }
+        if (ifstmtnode->GetElsePart()) {
+          CreateDoloopInfo(ifstmtnode->GetElsePart(), parent);
+        }
+        break;
+      }
+      case OP_dowhile:
+      case OP_while: {
+        if (parent != nullptr) {
+          parent->hasOtherCtrlFlow = true;
+        }
+        CreateDoloopInfo(static_cast<WhileStmtNode *>(stmt)->GetBody(), parent);
+        break;
+      }
+      case OP_goto:
+      case OP_igoto:
+      case OP_brtrue:
+      case OP_brfalse:
+      case OP_switch:
+      case OP_call:
+      case OP_callassigned:
+      case OP_icall:
+      case OP_icallassigned:
+      case OP_icallproto:
+      case OP_icallprotoassigned:
+      case OP_return:
+      case OP_throw:
+      case OP_asm:
+        if (parent != nullptr) {
+          parent->hasOtherCtrlFlow = true;
+        }
+        break;
+      case OP_label:
+        if (parent != nullptr) {
+          parent->hasLabels = true;
+        }
+        break;
+      default:
+        break;
+    }
+    stmt = stmt->GetNext();
+  }
+}
+
+// check if x is loop-invariant w.r.t. the doloop
+bool DoloopInfo::IsLoopInvariant(MeExpr *x) {
+  if (x == nullptr) {
+    return true;
+  }
+  switch (x->GetMeOp()) {
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpSizeoftype:
+    case kMeOpFieldsDist: return true;
+    case kMeOpVar:
+    case kMeOpReg: {
+      ScalarMeExpr *scalar = static_cast<ScalarMeExpr *>(x);
+      BB *defBB = scalar->DefByBB();
+      return defBB == nullptr || (defBB != doloopBB && depInfo->dom->Dominate(*defBB, *doloopBB));
+    }
+    case kMeOpIvar: {
+      IvarMeExpr *ivar = static_cast<IvarMeExpr *>(x);
+      if (ivar->HasMultipleMu()) {
+        return false;
+      }
+      if (!IsLoopInvariant(ivar->GetBase())) {
+        return false;
+      }
+      BB *defBB = ivar->GetUniqueMu()->DefByBB();
+      return defBB == nullptr || (defBB != doloopBB && depInfo->dom->Dominate(*defBB, *doloopBB));
+    }
+    case kMeOpOp: {
+      OpMeExpr *opexp = static_cast<OpMeExpr *>(x);
+      return IsLoopInvariant(opexp->GetOpnd(0)) &&
+             IsLoopInvariant(opexp->GetOpnd(1)) &&
+             IsLoopInvariant(opexp->GetOpnd(2));
+    }
+    case kMeOpNary: {
+      NaryMeExpr *opexp = static_cast<NaryMeExpr *>(x);
+      for (uint32 i = 0; i < opexp->GetNumOpnds(); ++i) {
+        if (!IsLoopInvariant(opexp->GetOpnd(i))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+// check if x is loop-invariant w.r.t. the doloop
+bool DoloopInfo::IsLoopInvariant2(BaseNode *x) {
+  MeExpr *meExpr = depInfo->preEmit->GetMexpr(x);
+  if (meExpr != nullptr) {
+    return IsLoopInvariant(meExpr);
+  }
+  for (size_t i = 0; i < x->NumOpnds(); ++i) {
+    if (!IsLoopInvariant2(x->Opnd(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool DoloopInfo::IsLoopIVNode(const BaseNode *x) const {
+  if (doloop->IsPreg()) {
+    if (x->GetOpCode() != OP_regread) {
+      return false;
+    }
+    return static_cast<const RegreadNode *>(x)->GetRegIdx() == doloop->GetDoVarPregIdx();
+  } else {
+    if (x->GetOpCode() != OP_dread) {
+      return false;
+    }
+    return static_cast<const AddrofNode *>(x)->GetStIdx() == doloop->GetDoVarStIdx();
+  }
+}
+
+// check if all the scalars contained in x are loop-invariant unless it is IV
+bool DoloopInfo::OnlyInvariantScalars(MeExpr *x) {
+  if (x == nullptr) {
+    return true;
+  }
+  switch (x->GetMeOp()) {
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpSizeoftype:
+    case kMeOpFieldsDist:
+      return true;
+    case kMeOpVar: {
+      VarMeExpr *varx = static_cast<VarMeExpr *>(x);
+      if (varx->GetOst()->GetMIRSymbol()->GetStIdx() == doloop->GetDoVarStIdx()) {
+        return true;  // it is the IV
+      }
+    }
+    // fall thru
+    [[clang::fallthrough]];
+    case kMeOpReg: {
+      ScalarMeExpr *scalar = static_cast<ScalarMeExpr *>(x);
+      BB *defBB = scalar->DefByBB();
+      return defBB == nullptr || (defBB != doloopBB && depInfo->dom->Dominate(*defBB, *doloopBB));
+    }
+    case kMeOpIvar: {
+      return OnlyInvariantScalars(x->GetOpnd(0));
+    }
+    case kMeOpOp: {
+      OpMeExpr *opexp = static_cast<OpMeExpr *>(x);
+      return OnlyInvariantScalars(opexp->GetOpnd(0)) &&
+             OnlyInvariantScalars(opexp->GetOpnd(1)) &&
+             OnlyInvariantScalars(opexp->GetOpnd(2));
+    }
+    case kMeOpNary: {
+      NaryMeExpr *opexp = static_cast<NaryMeExpr *>(x);
+      for (uint32 i = 0; i < opexp->GetNumOpnds(); ++i) {
+        if (!OnlyInvariantScalars(opexp->GetOpnd(i))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+SubscriptDesc *DoloopInfo::BuildOneSubscriptDesc(BaseNode *subsX) {
+  MeExpr *meExpr = depInfo->preEmit->GetMexpr(subsX);
+  SubscriptDesc *subsDesc = alloc->GetMemPool()->New<SubscriptDesc>(meExpr);
+  if (IsLoopInvariant2(subsX)) {
+    subsDesc->loopInvariant = true;
+    return subsDesc;
+  }
+  Opcode op = subsX->GetOpCode();
+  BaseNode *mainTerm = subsX;
+  if (op == OP_add || op == OP_sub) {  // get addtiveConst
+    BinaryNode *binNode = static_cast<BinaryNode *>(subsX);
+    BaseNode *opnd1 = binNode->Opnd(1);
+    if (opnd1->op == OP_constval) {
+      MIRConst *mirconst = static_cast<ConstvalNode *>(opnd1)->GetConstVal();
+      if (mirconst->GetKind() == kConstInt) {
+        subsDesc->additiveConst = static_cast<MIRIntConst *>(mirconst)->GetExtValue();
+        if (op == OP_sub) {
+          subsDesc->additiveConst = -subsDesc->additiveConst;
+        }
+        mainTerm = binNode->Opnd(0);
+      }
+    }
+  }
+  // if main term is another add, see if it is addition to loop-invarant
+  if (mainTerm->GetOpCode() == OP_add) {
+    BinaryNode *mtBinNode = static_cast<BinaryNode *>(mainTerm);
+    BaseNode *mtOpnd0 = mtBinNode->Opnd(0);
+    BaseNode *mtOpnd1 = mtBinNode->Opnd(1);
+    if (IsLoopInvariant2(mtOpnd0)) {
+      subsDesc->additiveLoopInvar = mtOpnd0;
+      mainTerm = mtOpnd1;
+    } else if (IsLoopInvariant2(mtOpnd1)) {
+      subsDesc->additiveLoopInvar = mtOpnd1;
+      mainTerm = mtOpnd0;
+    } else {
+      subsDesc->tooMessy = true;
+      return subsDesc;
+    }
+  }
+  // process mainTerm
+  BaseNode *varNode = nullptr;
+  if (mainTerm->GetOpCode() != OP_mul) {
+    varNode = mainTerm;
+  } else {
+    BinaryNode *mulbinnode = static_cast<BinaryNode *>(mainTerm);
+    BaseNode *mulopnd0 = mulbinnode->Opnd(0);
+    BaseNode *mulopnd1 = mulbinnode->Opnd(1);
+    if (mulopnd0->GetOpCode() != OP_dread && mulopnd0->GetOpCode() != OP_cvt) {
+      subsDesc->tooMessy = true;
+      return subsDesc;
+    }
+    varNode = mulopnd0;
+    if (mulopnd1->GetOpCode() != OP_constval) {
+      subsDesc->tooMessy = true;
+      return subsDesc;
+    }
+    MIRConst *mirconst = static_cast<ConstvalNode *>(mulopnd1)->GetConstVal();
+    if (mirconst->GetKind() != kConstInt) {
+      subsDesc->tooMessy = true;
+      return subsDesc;
+    }
+    subsDesc->coeff = static_cast<MIRIntConst *>(mirconst)->GetExtValue();
+  }
+  // process varNode
+  if (varNode->GetOpCode() == OP_cvt) {
+    varNode = varNode->Opnd(0);
+  }
+  if (varNode->GetOpCode() == OP_dread) {
+    DreadNode *dnode = static_cast<DreadNode *>(varNode);
+    if (dnode->GetStIdx() == doloop->GetDoVarStIdx()) {
+      subsDesc->iv = dnode;
+      return subsDesc;
+    }
+  }
+  subsDesc->tooMessy = true;
+  return subsDesc;
+}
+
+ArrayAccessDesc *DoloopInfo::BuildOneArrayAccessDesc(ArrayNode *arr, BaseNode *parentNode) {
+  MIRType *atype =  arr->GetArrayType(GlobalTables::GetTypeTable());
+  ASSERT(atype->GetKind() == kTypeArray, "type was wrong");
+  MIRArrayType *arryty = static_cast<MIRArrayType *>(atype);
+  if (!arryty->IsIncompleteArray()) {
+    size_t dim = arryty->GetDim();
+    CHECK_FATAL(dim >= arr->NumOpnds() - 1, "BuildOneArrayAccessDesc: inconsistent array dimension");
+  }
+  // ensure array base is loop invariant
+  if (!IsLoopInvariant2(arr->Opnd(0))) {
+    hasPtrAccess = true;
+    return nullptr;
+  }
+  // determine OStIdx for the array
+  IvarMeExpr *ivarMeExpr = nullptr;
+  MapleSet<OStIdx> *arryOstIdxSet = nullptr;
+  OpMeExpr *arrayMeExpr = static_cast<OpMeExpr *>(depInfo->preEmit->GetMexpr(arr));
+  if (arrayMeExpr == nullptr || arrayMeExpr->GetOp() == OP_add) {  // the array is converted from add
+  } else if (parentNode->op == OP_iread) {
+    ivarMeExpr = static_cast<IvarMeExpr *>(depInfo->preEmit->GetMexpr(parentNode));
+    CHECK_FATAL(ivarMeExpr, "ivarMeExpr is nullptr!");
+    if (ivarMeExpr->HasMultipleMu()) {
+      return nullptr;
+    }
+    auto *mu = ivarMeExpr->GetUniqueMu();
+    CHECK_FATAL(mu != nullptr, "BuildOneArrayAccessDesc: no mu corresponding to iread");
+    arryOstIdxSet = alloc->GetMemPool()->New<MapleSet<OStIdx>>(alloc->Adapter());
+    arryOstIdxSet->insert(mu->GetOst()->GetIndex());
+  } else if (parentNode->op == OP_iassign) {
+    IassignMeStmt *iassMeStmt = static_cast<IassignMeStmt *>(depInfo->preEmit->
+        GetMeStmt(static_cast<IassignNode *>(parentNode)->GetStmtID()));
+    ivarMeExpr = iassMeStmt->GetLHSVal();
+    if (ivarMeExpr->HasMultipleMu()) {
+      return nullptr;
+    }
+    arryOstIdxSet = alloc->GetMemPool()->New<MapleSet<OStIdx>>(alloc->Adapter());
+    auto *mu = ivarMeExpr->GetUniqueMu();
+    if (mu != nullptr) {
+      arryOstIdxSet->insert(mu->GetOst()->GetIndex());
+    } else {
+      MapleMap<OStIdx, ChiMeNode *> *chiList = iassMeStmt->GetChiList();
+      CHECK_FATAL(!chiList->empty(), "BuildOneArrayAccessDesc: no chi corresponding to iassign");
+      for (std::pair<OStIdx, ChiMeNode*> mapIt : *chiList) {
+        arryOstIdxSet->insert(mapIt.first);
+      }
+    }
+  } else {
+    hasPtrAccess = true;
+    return nullptr;
+  }
+
+  ArrayAccessDesc *arrDesc = alloc->GetMemPool()->New<ArrayAccessDesc>(alloc, arr, arryOstIdxSet);
+  if (parentNode->op == OP_iassign) {
+    lhsArrays.push_back(arrDesc);
+  } else {
+    rhsArrays.push_back(arrDesc);
+  }
+  for (size_t i = 0; i < arr->NumOpnds() - 1; ++i) {
+    SubscriptDesc *subs = BuildOneSubscriptDesc(arr->GetIndex(i));
+    arrDesc->subscriptVec.push_back(subs);
+  }
+  return arrDesc;
+}
+
+void DoloopInfo::CreateRHSArrayAccessDesc(BaseNode *x, BaseNode *parentNode) {
+  if (x->GetOpCode() == OP_array) {
+    if (parentNode->GetOpCode() != OP_iread) { // skip arrays not underneath iread unless loop-invariant
+      if (IsLoopInvariant2(x)) {
+        return;
+      }
+      hasPtrAccess = true;
+    } else {
+      (void)BuildOneArrayAccessDesc(static_cast<ArrayNode *>(x), parentNode);
+    }
+    return;
+  }
+  for (size_t i = 0; i < x->NumOpnds(); ++i) {
+    CreateRHSArrayAccessDesc(x->Opnd(i), x);
+  }
+}
+
+void DoloopInfo::CreateArrayAccessDesc(BlockNode *block) {
+  StmtNode *stmt = block->GetFirst();
+  while (stmt) {
+    switch (stmt->GetOpCode()) {
+      case OP_doloop: {
+        CHECK_FATAL(false, "CreateArrayAccessDesc: non-innermost doloop NYI");
+        break;
+      }
+      case OP_block: {
+        CreateArrayAccessDesc(static_cast<BlockNode *>(stmt));
+        break;
+      }
+      case OP_if: {
+        CreateRHSArrayAccessDesc(stmt->Opnd(0), stmt);
+        IfStmtNode *ifstmtnode = static_cast<IfStmtNode *>(stmt);
+        if (ifstmtnode->GetThenPart()) {
+          CreateArrayAccessDesc(ifstmtnode->GetThenPart());
+        }
+        if (ifstmtnode->GetElsePart()) {
+          CreateArrayAccessDesc(ifstmtnode->GetElsePart());
+        }
+        break;
+      }
+      case OP_dowhile:
+      case OP_while: {
+        CreateRHSArrayAccessDesc(stmt->Opnd(0), stmt);
+        CreateArrayAccessDesc(static_cast<WhileStmtNode *>(stmt)->GetBody());
+        break;
+      }
+      case OP_iassign: {
+        IassignNode *iass = static_cast<IassignNode *>(stmt);
+        if (iass->addrExpr->GetOpCode() == OP_array) {
+          ArrayAccessDesc *adesc = BuildOneArrayAccessDesc(static_cast<ArrayNode *>(iass->addrExpr), iass);
+          if (adesc != nullptr) {
+          }
+        } else {
+          hasPtrAccess = true;
+        }
+        CreateRHSArrayAccessDesc(iass->rhs, iass);
+        break;
+      }
+      case OP_dassign:
+      case OP_regassign: {
+        hasScalarAssign = true;
+        CreateRHSArrayAccessDesc(stmt->Opnd(0), stmt);
+        break;
+      }
+      default: {
+        for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+          CreateRHSArrayAccessDesc(stmt->Opnd(i), stmt);
+        }
+        break;
+      }
+    }
+    stmt = stmt->GetNext();
+  }
+}
+
+static bool ArrayOstIdxSetIntersect(MapleSet<OStIdx> *set1, MapleSet<OStIdx> *set2) {
+  for (OStIdx oidx1 : *set1) {
+    for (OStIdx oidx2 : *set2) {
+      if (oidx1 == oidx2) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void DoloopInfo::CreateDepTestLists() {
+  size_t i, j;
+  for (i = 0; i < lhsArrays.size(); ++i) {
+    for (j = i + 1; j < lhsArrays.size(); ++j) {
+      if (lhsArrays[i]->arrayOstIdxSet != nullptr && lhsArrays[j]->arrayOstIdxSet != nullptr) {
+        if (ArrayOstIdxSetIntersect(lhsArrays[i]->arrayOstIdxSet, lhsArrays[j]->arrayOstIdxSet)) {
+          (void)outputDepTestList.emplace_back(DepTestPair(i, j));
+        }
+      } else if (lhsArrays[i]->arrayOstIdxSet == nullptr && lhsArrays[j]->arrayOstIdxSet == nullptr) {
+        BaseNode *arry0 = lhsArrays[i]->theArray->Opnd(0);
+        BaseNode *arry1 = lhsArrays[j]->theArray->Opnd(0);
+        if (depInfo->preEmit->GetMexpr(arry0) == depInfo->preEmit->GetMexpr(arry1)) {
+          (void)outputDepTestList.emplace_back(DepTestPair(i, j));
+        }
+      }
+    }
+  }
+  for (i = 0; i < lhsArrays.size(); ++i) {
+    for (j = 0; j < rhsArrays.size(); ++j) {
+      if (lhsArrays[i]->arrayOstIdxSet != nullptr && rhsArrays[j]->arrayOstIdxSet != nullptr) {
+        if (ArrayOstIdxSetIntersect(lhsArrays[i]->arrayOstIdxSet, rhsArrays[j]->arrayOstIdxSet)) {
+          (void)flowDepTestList.emplace_back(DepTestPair(i, j));
+        }
+      } else if (lhsArrays[i]->arrayOstIdxSet == nullptr && rhsArrays[j]->arrayOstIdxSet == nullptr) {
+        BaseNode *arry0 = lhsArrays[i]->theArray->Opnd(0);
+        BaseNode *arry1 = rhsArrays[j]->theArray->Opnd(0);
+        if (depInfo->preEmit->GetMexpr(arry0) == depInfo->preEmit->GetMexpr(arry1)) {
+          (void)flowDepTestList.emplace_back(DepTestPair(i, j));
+        }
+      }
+    }
+  }
+}
+
+static int64 Gcd(int64 a, int64 b) {
+  CHECK_FATAL(a > 0 && b >= 0, "Gcd: NYI");
+  if (b == 0) {
+    return a;
+  }
+  return Gcd(b, a % b);
+}
+
+void DoloopInfo::TestDependences(MapleVector<DepTestPair> *depTestList, bool bothLHS) {
+  size_t i, j;
+  for (i = 0; i < depTestList->size(); ++i) {
+    DepTestPair *testPair = &(*depTestList)[i];
+    ArrayAccessDesc *arrDesc1 = lhsArrays[testPair->depTestPair.first];
+    ArrayAccessDesc *arrDesc2 = nullptr;
+    if (bothLHS) {
+      arrDesc2 = lhsArrays[testPair->depTestPair.second];
+    } else {
+      arrDesc2 = rhsArrays[testPair->depTestPair.second];
+    }
+    if (arrDesc1->subscriptVec.size() != arrDesc2->subscriptVec.size()) {
+      testPair->dependent = true;
+      testPair->unknownDist = true;
+      continue;
+    }
+    for (j = 0; j < arrDesc1->subscriptVec.size(); ++j) {
+      SubscriptDesc *subs1 = arrDesc1->subscriptVec[j];
+      SubscriptDesc *subs2 = arrDesc2->subscriptVec[j];
+      if (subs1->tooMessy || subs2->tooMessy) {
+        testPair->dependent = true;
+        testPair->unknownDist = true;
+        break;
+      }
+      if (subs1->loopInvariant || subs2->loopInvariant) {
+        if (subs1->subscriptX == subs2->subscriptX) {
+          continue;
+        } else {
+          testPair->dependent = true;
+          testPair->unknownDist = true;
+          break;
+        }
+      }
+      if (subs1->additiveLoopInvar != nullptr || subs2->additiveLoopInvar != nullptr) {
+        if (subs1->additiveLoopInvar == nullptr ||
+            subs2->additiveLoopInvar == nullptr ||
+            !subs1->additiveLoopInvar->IsSameContent(subs2->additiveLoopInvar)) {
+          testPair->dependent = true;
+          testPair->unknownDist = true;
+          break;
+        }
+      }
+      if (subs1->coeff == subs2->coeff) { // lamport test
+        if (((subs1->additiveConst - subs2->additiveConst) % subs1->coeff) != 0) {
+          continue;
+        }
+        testPair->dependent = true;
+        int64 dist = (subs1->additiveConst - subs2->additiveConst) / subs1->coeff;
+        if (dist != 0) {
+          testPair->depDist = dist;
+        }
+        continue;
+      }
+      // gcd test
+      if ((subs1->additiveConst - subs2->additiveConst) % Gcd(subs1->coeff, subs2->coeff) == 0) {
+        testPair->dependent = true;
+        testPair->unknownDist = true;
+        break;
+      }
+    }
+  }
+}
+
+bool DoloopInfo::Parallelizable() {
+  if (hasPtrAccess || hasOtherCtrlFlow || hasScalarAssign || hasMayDef) {
+    return false;
+  }
+  for (size_t i = 0; i < outputDepTestList.size(); ++i) {
+    DepTestPair *testPair = &outputDepTestList[i];
+    if (testPair->dependent && (testPair->unknownDist || testPair->depDist != 0)) {
+      return false;
+    }
+  }
+  for (size_t i = 0; i < flowDepTestList.size(); ++i) {
+    DepTestPair *testPair = &flowDepTestList[i];
+    if (testPair->dependent && (testPair->unknownDist || testPair->depDist != 0)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// complex case not handled
+bool DoloopInfo::NotParallel() {
+  if (hasPtrAccess || hasOtherCtrlFlow || hasMayDef ||
+      (hasScalarAssign && !CheckReductionLoop())) {
+    return true;
+  }
+  return false;
+}
+
+bool DoloopInfo::HasOutputDep() {
+  for (size_t i = 0; i < outputDepTestList.size(); ++i) {
+    DepTestPair *testPair = &outputDepTestList[i];
+    if (testPair->dependent && (testPair->unknownDist || testPair->depDist != 0)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// return 1 means has other dep type
+// return max anti-depDist which is < 0
+int DoloopInfo::HasAntiDepOnly() {
+  int depdist = INT32_MIN;
+  for (size_t i = 0; i < flowDepTestList.size(); ++i) {
+    DepTestPair *testPair = &flowDepTestList[i];
+    if (testPair->dependent) {
+      if (testPair->unknownDist || testPair->depDist > 0) {
+        return 1;
+      } else if (testPair->depDist < 0) {
+        depdist = depdist < testPair->depDist ? testPair->depDist : depdist; // get max value
+      }
+    }
+  }
+  return (depdist == INT32_MIN) ? 0 : depdist;
+}
+// -1 means has other dep type
+// return min flowdepdist which is >= 0
+int DoloopInfo::HasTrueDepOnly() {
+  int depdist = INT32_MAX;
+  for (size_t i = 0; i < flowDepTestList.size(); ++i) {
+    DepTestPair *testPair = &flowDepTestList[i];
+    if (testPair->dependent) {
+      if (testPair->unknownDist || testPair->depDist < 0) {
+        return -1;
+      } else if (testPair->depDist > 0) {
+        depdist = depdist < testPair->depDist ? depdist : testPair->depDist; // get min value
+      }
+    }
+  }
+  return (depdist == INT32_MAX) ? -1 : depdist;
+}
+
+
+static bool IsDreadOf(BaseNode *x, StIdx stIdx, FieldID fieldID) {
+  if (x->op != OP_dread) {
+    return false;
+  }
+  DreadNode *dread = static_cast<DreadNode *>(x);
+  return dread->GetStIdx() == stIdx && dread->GetFieldID() == fieldID;
+}
+
+bool DoloopInfo::CheckReductionLoop() {
+  if (hasPtrAccess || hasOtherCtrlFlow || !hasScalarAssign || hasMayDef) {
+    return false;
+  }
+  if (!lhsArrays.empty()) {
+    return false;
+  }
+  // make sure all rhsArrays are either loopInvariant or not messy
+  for (size_t i = 0; i < rhsArrays.size(); ++i) {
+    ArrayAccessDesc *arrAcc = rhsArrays[i];
+    for (size_t j = 0; j < arrAcc->subscriptVec.size(); ++j) {
+      SubscriptDesc *subs = arrAcc->subscriptVec[j];
+      if (!subs->loopInvariant && subs->tooMessy) {
+        return false;
+      }
+    }
+  }
+  // go thru all statements in loop body to check reduction form in scalar assignments
+  StmtNode *stmt = doloop->GetDoBody()->GetFirst();
+  while (stmt) {
+    if (stmt->op != OP_dassign) {
+      return false;
+    }
+    DassignNode *dass = static_cast<DassignNode *>(stmt);
+    BaseNode *rhs = dass->GetRHS();
+    if (rhs->GetOpCode() != OP_add && rhs->GetOpCode() != OP_sub) {
+      return false;
+    }
+    StIdx stIdx = dass->GetStIdx();
+    FieldID fieldID = dass->GetFieldID();
+    BinaryNode *binrhs = static_cast<BinaryNode *>(rhs);
+    BaseNode *otherOpnd = nullptr;
+    if (IsDreadOf(binrhs->GetBOpnd(0), stIdx, fieldID)) {
+      otherOpnd = binrhs->GetBOpnd(1);
+    } else if (binrhs->GetOpCode() == OP_add && IsDreadOf(binrhs->GetBOpnd(1), stIdx, fieldID)) {
+      otherOpnd = binrhs->GetBOpnd(0);
+      // swap the 2 sides
+      binrhs->SetBOpnd(binrhs->GetBOpnd(1), 0);
+      binrhs->SetBOpnd(otherOpnd, 1);
+    } else {
+      return false;
+    }
+    if (!OnlyInvariantScalars(depInfo->preEmit->GetMexpr(otherOpnd))) {
+      return false;
+    }
+    redVars.insert(stIdx);
+    stmt = stmt->GetNext();
+  }
+  return true;
+}
+
+ArrayAccessDesc* DoloopInfo::GetArrayAccessDesc(const ArrayNode *node, bool isRHS) {
+  MapleVector<ArrayAccessDesc *>* arrayDescptr = isRHS ? &rhsArrays : &lhsArrays;
+  for (auto it = arrayDescptr->begin(); it != arrayDescptr->end(); ++it) {
+    if ((*it)->theArray == node) {
+      return (*it);
+    }
+  }
+  return nullptr;
+}
+
+void LfoDepInfo::PerformDepTest() {
+  size_t i;
+  MapleMap<DoloopNode *, DoloopInfo *>::iterator mapit = doloopInfoMap.begin();
+  for (; mapit != doloopInfoMap.end(); ++mapit) {
+    DoloopInfo *doloopInfo = mapit->second;
+    if (!doloopInfo->children.empty()) {
+      continue;  // only handling innermost doloops
+    }
+    if (doloopInfo->hasOtherCtrlFlow) {
+      continue;
+    }
+    doloopInfo->CreateArrayAccessDesc(doloopInfo->doloop->GetDoBody());
+    if (DEBUGFUNC(preMeFunc->meFunc)) {
+      LogInfo::MapleLogger() << "Innermost Doloop:";
+      if (doloopInfo->hasPtrAccess) {
+        LogInfo::MapleLogger() << " hasPtrAccess";
+      }
+      if (doloopInfo->hasOtherCtrlFlow) {
+        LogInfo::MapleLogger() << " hasOtherCtrlFlow";
+      }
+      if (doloopInfo->hasScalarAssign) {
+        LogInfo::MapleLogger() << " hasScalarAssign";
+      }
+      if (doloopInfo->hasMayDef) {
+        LogInfo::MapleLogger() << " hasMayDef";
+      }
+      LogInfo::MapleLogger() << std::endl;
+      doloopInfo->doloop->Dump(0);
+      LogInfo::MapleLogger() << "LHS arrays:\n";
+      for (i = 0; i < doloopInfo->lhsArrays.size(); ++i) {
+        ArrayAccessDesc *arrAcc = doloopInfo->lhsArrays[i];
+        LogInfo::MapleLogger() << "(L" << i << ") ";
+        if (arrAcc->arrayOstIdxSet == nullptr) {
+          arrAcc->theArray->Opnd(0)->Dump(0);
+        } else {
+          for (OStIdx oidx : *arrAcc->arrayOstIdxSet) {
+            OriginalSt *ost = preMeFunc->meFunc->GetMeSSATab()->GetOriginalStFromID(oidx);
+            CHECK_FATAL(ost, "ost is nullptr!");
+            ost->Dump();
+            LogInfo::MapleLogger() << "| ";
+          }
+        }
+        LogInfo::MapleLogger() << " subscripts:";
+        for (SubscriptDesc *subs : arrAcc->subscriptVec) {
+          if (subs->loopInvariant) {
+            LogInfo::MapleLogger() << " [loopinvariant]";
+          } else if (subs->tooMessy) {
+            LogInfo::MapleLogger() << " [messy]";
+          } else {
+            LogInfo::MapleLogger() << " [" << subs->coeff << "*";
+            ScalarMeExpr *scalar = static_cast<ScalarMeExpr *>(preEmit->GetMexpr(subs->iv));
+            scalar->GetOst()->Dump();
+            LogInfo::MapleLogger() << "+" << subs->additiveConst;
+            if (subs->additiveLoopInvar != nullptr) {
+              LogInfo::MapleLogger() << "+<loopinvar>";
+            }
+            LogInfo::MapleLogger() << "]";
+          }
+        }
+        LogInfo::MapleLogger() << std::endl;
+      }
+      LogInfo::MapleLogger() << "RHS arrays:\n";
+      for (i = 0; i < doloopInfo->rhsArrays.size(); ++i) {
+        ArrayAccessDesc *arrAcc = doloopInfo->rhsArrays[i];
+        LogInfo::MapleLogger() << "(R" << i << ") ";
+        if (arrAcc->arrayOstIdxSet == nullptr) {
+          arrAcc->theArray->Opnd(0)->Dump(0);
+        } else {
+          for (OStIdx oidx : *arrAcc->arrayOstIdxSet) {
+            OriginalSt *ost = preMeFunc->meFunc->GetMeSSATab()->GetOriginalStFromID(oidx);
+            ost->Dump();
+          }
+        }
+        LogInfo::MapleLogger() << " subscripts:";
+        for (SubscriptDesc *subs : arrAcc->subscriptVec) {
+          if (subs->loopInvariant) {
+            LogInfo::MapleLogger() << " [loopinvariant]";
+          } else if (subs->tooMessy) {
+            LogInfo::MapleLogger() << " [messy]";
+          } else {
+            LogInfo::MapleLogger() << " [" << subs->coeff << "*";
+            ScalarMeExpr *scalar = static_cast<ScalarMeExpr *>(preEmit->GetMexpr(subs->iv));
+            scalar->GetOst()->Dump();
+            LogInfo::MapleLogger() << "+" << subs->additiveConst;
+            if (subs->additiveLoopInvar != nullptr) {
+              LogInfo::MapleLogger() << "+<loopinvar>";
+            }
+            LogInfo::MapleLogger() << "]";
+          }
+        }
+        LogInfo::MapleLogger() << std::endl;
+      }
+      LogInfo::MapleLogger() << std::endl;
+    }
+    doloopInfo->CreateDepTestLists();
+    doloopInfo->TestDependences(&doloopInfo->outputDepTestList, true);
+    doloopInfo->TestDependences(&doloopInfo->flowDepTestList, false);
+    if (DEBUGFUNC(preMeFunc->meFunc)) {
+      for (DepTestPair item : doloopInfo->outputDepTestList) {
+        LogInfo::MapleLogger() << "Dep between L" << item.depTestPair.first << " and L" << item.depTestPair.second;
+        if (!item.dependent) {
+          LogInfo::MapleLogger() << " independent";
+        } else {
+          LogInfo::MapleLogger() << " dependent";
+          if (item.unknownDist) {
+            LogInfo::MapleLogger() << " unknownDist";
+          } else {
+            LogInfo::MapleLogger() << " distance: " << item.depDist;
+          }
+        }
+        LogInfo::MapleLogger() << std::endl;
+      }
+      for (DepTestPair item : doloopInfo->flowDepTestList) {
+        LogInfo::MapleLogger() << "Dep between L" << item.depTestPair.first << " and R" << item.depTestPair.second;
+        if (!item.dependent) {
+          LogInfo::MapleLogger() << " independent";
+        } else {
+          LogInfo::MapleLogger() << " dependent";
+          if (item.unknownDist) {
+            LogInfo::MapleLogger() << " unknownDist";
+          } else {
+            LogInfo::MapleLogger() << " distance: " << item.depDist;
+          }
+        }
+        LogInfo::MapleLogger() << std::endl;
+      }
+      if (doloopInfo->Parallelizable()) {
+        LogInfo::MapleLogger() << "LOOP CAN BE VECTORIZED\n";
+      }
+      if (doloopInfo->CheckReductionLoop()) {
+        LogInfo::MapleLogger() << "LOOP IS REDUCTION LOOP\n";
+      }
+    }
+  }
+}
+
+bool MELfoDepTest::PhaseRun(MeFunction &f) {
+  Dominance *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  ASSERT(dom != nullptr, "dominance phase has problem");
+  PreMeEmitter *preEmit = GET_ANALYSIS(MEPreMeEmission, f);
+  ASSERT(preEmit != nullptr, "lfo preemit phase has problem");
+  PreMeFunction *preMeFunc = f.GetPreMeFunc();
+  MemPool *depTestMp = GetPhaseMemPool();
+  depInfo = depTestMp->New<LfoDepInfo>(depTestMp, preMeFunc, dom, preEmit);
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== LFO_DEP_TEST =============" << '\n';
+  }
+  depInfo->CreateDoloopInfo(f.GetMirFunc()->GetBody(), nullptr);
+  depInfo->PerformDepTest();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "________________" << std::endl;
+    preMeFunc->meFunc->GetMirFunc()->Dump();
+  }
+  return depInfo;
+}
+
+void MELfoDepTest::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEPreMeEmission>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/lfo_inject_iv.cpp b/src/mapleall/maple_me/src/lfo_inject_iv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..93e0d6b250ac88f0bfab8e7a38c76af002b6381b
--- /dev/null
+++ b/src/mapleall/maple_me/src/lfo_inject_iv.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "lfo_inject_iv.h"
+#include <string>
+#include "me_dominance.h"
+#include "me_loop_analysis.h"
+#include "me_option.h"
+#include "mir_builder.h"
+
+namespace maple {
+bool MELfoInjectIV::PhaseRun(MeFunction &f) {
+  Dominance *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  CHECK_FATAL(dom, "dominance phase has problem");
+  IdentifyLoops *identloops = GET_ANALYSIS(MELoopAnalysis, f);
+  CHECK_FATAL(identloops != nullptr, "identloops has problem");
+
+  uint32 ivCount = 0;
+  MIRBuilder *mirbuilder = f.GetMIRModule().GetMIRBuilder();
+  PreMeFunction *preMeFunc = f.GetPreMeFunc();
+
+  for (LoopDesc *aloop : identloops->GetMeLoops()) {
+    BB *headbb = aloop->head;
+    // check if the label has associated PreMeWhileInfo
+    if (headbb->GetBBLabel() == 0) {
+      continue;
+    }
+    if (headbb->GetPred().size() != 2) {
+      continue;  // won't insert IV for loops with > 1 tail bbs
+    }
+    MapleMap<LabelIdx, PreMeWhileInfo*>::iterator it = preMeFunc->label2WhileInfo.find(headbb->GetBBLabel());
+    if (it == preMeFunc->label2WhileInfo.end()) {
+      continue;
+    }
+    PreMeWhileInfo *whileInfo = it->second;
+    // find the entry BB as the predecessor of headbb that dominates headbb
+    MapleVector<BB*>::iterator predit = headbb->GetPred().begin();
+    for (; predit != headbb->GetPred().end(); ++predit) {
+      if (dom->Dominate(**predit, *headbb)) {
+        break;
+      }
+    }
+    if (predit == headbb->GetPred().end()) {
+      continue;  // cannot insert IV for this loop
+    }
+    BB *entrybb = *predit;
+
+    // create the IV for this loop
+    std::string ivName("injected.iv");
+    ivName.append(std::to_string(++ivCount));
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(ivName);
+    MIRSymbol *st = mirbuilder->CreateSymbol(TyIdx(PTY_i64), strIdx, kStVar, kScAuto, f.GetMirFunc(), kScopeLocal);
+    whileInfo->injectedIVSym = st;
+    if (DEBUGFUNC_NEWPM(f)) {
+      LogInfo::MapleLogger() << "****** Injected IV " << st->GetName() << " in while loop at label ";
+      LogInfo::MapleLogger() << "@" << f.GetMirFunc()->GetLabelName(headbb->GetBBLabel()) << std::endl;
+    }
+
+    // initialize IV to 0 at loop entry
+    DassignNode *dass = mirbuilder->CreateStmtDassign(st->GetStIdx(), 0, mirbuilder->CreateIntConst(0, PTY_i64));
+    StmtNode *laststmt = entrybb->IsEmpty() ? nullptr : &entrybb->GetLast();
+    if (laststmt &&
+        (laststmt->op == OP_brfalse || laststmt->op == OP_brtrue || laststmt->op == OP_goto ||
+         laststmt->op == OP_igoto || laststmt->op == OP_switch)) {
+      entrybb->InsertStmtBefore(laststmt, dass);
+    } else {
+      entrybb->AddStmtNode(dass);
+    }
+
+    // insert IV increment at loop tail BB
+    BB *tailbb = aloop->tail;
+    AddrofNode *dread = mirbuilder->CreateExprDread(*GlobalTables::GetTypeTable().GetInt64(), *st);
+    BinaryNode *addnode = mirbuilder->CreateExprBinary(OP_add, *GlobalTables::GetTypeTable().GetInt64(),
+                                                       dread, mirbuilder->CreateIntConst(1, PTY_i64));
+    dass = mirbuilder->CreateStmtDassign(*st, 0, addnode);
+    laststmt = tailbb->IsEmpty() ? nullptr : &tailbb->GetLast();
+    laststmt ? tailbb->InsertStmtBefore(laststmt, dass) : tailbb->AddStmtNode(dass);
+  }
+  return true;
+}
+
+void MELfoInjectIV::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/lfo_iv_canon.cpp b/src/mapleall/maple_me/src/lfo_iv_canon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..174be8a44730fa11ecac1ef009102346e21f5518
--- /dev/null
+++ b/src/mapleall/maple_me/src/lfo_iv_canon.cpp
@@ -0,0 +1,743 @@
+/*
+ * Copyright (c) [2021-2022] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#include "lfo_iv_canon.h"
+#include <iostream>
+#include "me_option.h"
+#include "pme_function.h"
+#include "me_dominance.h"
+
+// This phase implements Step 4 of the paper:
+//   S.-M. Liu, R. Lo and F. Chow, "Loop Induction Variable
+//   Canonicalization in Parallelizing Compiler", Intl. Conf. on Parallel
+//   Architectures and Compilation Techniques (PACT 96), Oct 1996.
+namespace maple {
+using namespace std;
+// Resolve value of x; return false if result is not of induction expression
+// form; goal is to resolve to an expression where the only non-constant is
+// philhs
+bool IVCanon::ResolveExprValue(MeExpr *x, ScalarMeExpr *phiLHS) {
+  switch (x->GetMeOp()) {
+    case kMeOpConst: return IsPrimitiveInteger(x->GetPrimType());
+    case kMeOpVar:
+    case kMeOpReg: {
+      if (x->IsVolatile()) {
+        return false;
+      }
+      if (x == phiLHS) {
+        return true;
+      }
+      ScalarMeExpr *scalar = static_cast<ScalarMeExpr *>(x);
+      if (!scalar->GetOst()->IsLocal() || scalar->GetOst()->IsAddressTaken() ||
+          scalar->GetOstIdx() != phiLHS->GetOstIdx()) {
+        return false;
+      }
+      if (scalar->GetDefBy() != kDefByStmt) {
+        return false;
+      }
+      AssignMeStmt *defStmt = static_cast<AssignMeStmt*>(scalar->GetDefStmt());
+      return ResolveExprValue(defStmt->GetRHS(), phiLHS);
+    }
+    case kMeOpOp: {  // restricting to only + and - for now
+      if (x->GetOp() != OP_add && x->GetOp() != OP_sub) {
+        return false;
+      }
+      OpMeExpr *opExpr = static_cast<OpMeExpr *>(x);
+      return ResolveExprValue(opExpr->GetOpnd(0), phiLHS) &&
+             ResolveExprValue(opExpr->GetOpnd(1), phiLHS);
+    }
+    default: return false;
+  }
+}
+
+// appearances accumulates the number of appearances of the induction variable;
+// it is negative if it is subtracted;
+// canBePrimary is set to false if it takes more than one increment statements
+// to get to phiLHS
+int32 IVCanon::ComputeIncrAmt(MeExpr *x, ScalarMeExpr *phiLHS, int32 *appearances, bool &canBePrimary) {
+  switch (x->GetMeOp()) {
+    case kMeOpConst: {
+      MIRConst *konst = static_cast<ConstMeExpr *>(x)->GetConstVal();
+      CHECK_FATAL(konst->GetKind() == kConstInt, "ComputeIncrAmt: must be integer constant");
+      MIRIntConst *intConst = static_cast<MIRIntConst *>(konst);
+      return static_cast<int32>(intConst->GetExtValue());
+    }
+    case kMeOpVar:
+    case kMeOpReg:{
+      if (x == phiLHS) {
+        *appearances = 1;
+        return 0;
+      }
+      ScalarMeExpr *scalar = static_cast<ScalarMeExpr *>(x);
+      CHECK_FATAL(scalar->GetDefBy() == kDefByStmt, "ComputeIncrAmt: cannot be here");
+      AssignMeStmt *defstmt = static_cast<AssignMeStmt*>(scalar->GetDefStmt());
+      return ComputeIncrAmt(defstmt->GetRHS(), phiLHS, appearances, canBePrimary);
+    }
+    case kMeOpOp: {
+      CHECK_FATAL(x->GetOp() == OP_add || x->GetOp() == OP_sub, "ComputeIncrAmt: cannot be here");
+      OpMeExpr *opexp = static_cast<OpMeExpr *>(x);
+      int32 appear0 = 0;
+      if (canBePrimary) {
+        if ((opexp->GetOpnd(0)->GetMeOp() == kMeOpVar || opexp->GetOpnd(0)->GetMeOp() == kMeOpReg) &&
+            opexp->GetOpnd(0) != phiLHS) {
+          canBePrimary = false;
+        } else if ((opexp->GetOpnd(1)->GetMeOp() == kMeOpVar || opexp->GetOpnd(1)->GetMeOp() == kMeOpReg) &&
+                   opexp->GetOpnd(1) != phiLHS) {
+          canBePrimary = false;
+        }
+      }
+      int32 incrAmt0 = ComputeIncrAmt(opexp->GetOpnd(0), phiLHS, &appear0, canBePrimary);
+      int32 appear1 = 0;
+      int32 incrAmt1 = ComputeIncrAmt(opexp->GetOpnd(1), phiLHS, &appear1, canBePrimary);
+      if (x->GetOp() == OP_sub) {
+        *appearances = appear0 - appear1;
+        return incrAmt0 - incrAmt1;
+      } else {
+        *appearances = appear0 + appear1;
+        return incrAmt0 + incrAmt1;
+      }
+    }
+    default:
+      break;
+  }
+  CHECK_FATAL(false, "ComputeIncrAmt: should not be here");
+  return 0;
+}
+
+// determine the initial and step values of the IV and push info to ivvec
+void IVCanon::CharacterizeIV(ScalarMeExpr *initversion, ScalarMeExpr *loopbackversion, ScalarMeExpr *philhs) {
+  IVDesc *ivdesc = mp->New<IVDesc>(initversion->GetOst());
+  if (initversion->GetDefBy() == kDefByStmt) {
+    AssignMeStmt *defStmt = static_cast<AssignMeStmt*>(initversion->GetDefStmt());
+    if (defStmt->GetRHS()->GetMeOp() == kMeOpConst ||
+        defStmt->GetRHS()->GetMeOp() == kMeOpAddrof ||
+        ((defStmt->GetRHS()->GetMeOp() == kMeOpConststr ||
+          defStmt->GetRHS()->GetMeOp() == kMeOpConststr16) &&
+         !func->GetMIRModule().IsCModule())) {
+      ivdesc->initExpr = defStmt->GetRHS();
+    } else {
+      ivdesc->initExpr = initversion;
+    }
+  } else {
+    ivdesc->initExpr = initversion;
+  }
+  int32 appearances = 0;
+  ivdesc->stepValue = ComputeIncrAmt(loopbackversion, philhs, &appearances, ivdesc->canBePrimary);
+  if (appearances == 1) {
+    ivvec.push_back(ivdesc);
+  }
+}
+
+void IVCanon::FindPrimaryIV() {
+  for (uint32 i = 0; i < ivvec.size(); i++) {
+    IVDesc *ivdesc = ivvec[i];
+    if (!ivdesc->canBePrimary) {
+      continue;
+    }
+    if (ivdesc->stepValue == 1) {
+      bool injected = false;
+      if (ivdesc->ost->IsSymbolOst() &&
+          strncmp(ivdesc->ost->GetMIRSymbol()->GetName().c_str(), "injected.iv", 11) == 0) {
+        injected = true;
+      }
+      if (injected) {
+        if (idxPrimaryIV == -1) {
+          idxPrimaryIV = static_cast<int32>(i);
+        }
+      } else {
+        // verify its increment is the last statement in loop body
+        BB *tailbb = aloop->tail;
+        ASSERT_NOT_NULL(tailbb->GetLastMe());
+        MeStmt *laststmt = tailbb->GetLastMe()->GetPrev(); // skipping the branch stmt
+        if (laststmt == nullptr || laststmt->GetOp() != OP_dassign) {
+          continue;
+        }
+        DassignMeStmt *lastdass = static_cast<DassignMeStmt *>(laststmt);
+        if (strncmp(lastdass->GetLHS()->GetOst()->GetMIRSymbol()->GetName().c_str(), "injected.iv", 11) == 0) {
+          laststmt = laststmt->GetPrev();
+          if (laststmt == nullptr || laststmt->GetOp() != OP_dassign ||
+              // variable is struct, skip use agg type variable as primary IV
+              // because fieldID doesn't store in whileloopinfo
+              (static_cast<DassignMeStmt *>(laststmt)->GetLHS()->GetOst()->GetFieldID() != 0)) {
+            continue;
+          }
+          lastdass = static_cast<DassignMeStmt *>(laststmt);
+        }
+        if (lastdass->GetLHS()->GetOst() == ivdesc->ost) {
+          idxPrimaryIV = static_cast<int32>(i);
+          return;
+        }
+      }
+    }
+  }
+}
+
+bool IVCanon::IsLoopInvariant(MeExpr *x) {
+  if (x == nullptr) {
+    return true;
+  }
+  switch (x->GetMeOp()) {
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpSizeoftype:
+    case kMeOpFieldsDist: return true;
+    case kMeOpVar:
+    case kMeOpReg: {
+      ScalarMeExpr *scalar = static_cast<ScalarMeExpr *>(x);
+      BB *defBB = scalar->DefByBB();
+      return defBB == nullptr || (defBB != aloop->head && dominance->Dominate(*defBB, *aloop->head));
+    }
+    case kMeOpIvar: {
+      IvarMeExpr *ivar = static_cast<IvarMeExpr *>(x);
+      if (ivar->HasMultipleMu()) {
+        return false;
+      }
+      if (!IsLoopInvariant(ivar->GetBase())) {
+        return false;
+      }
+      BB *defBB = ivar->GetUniqueMu()->DefByBB();
+      return defBB == nullptr || (defBB != aloop->head && dominance->Dominate(*defBB, *aloop->head));
+    }
+    case kMeOpOp: {
+      OpMeExpr *opexp = static_cast<OpMeExpr *>(x);
+      return IsLoopInvariant(opexp->GetOpnd(0)) &&
+             IsLoopInvariant(opexp->GetOpnd(1)) &&
+             IsLoopInvariant(opexp->GetOpnd(2));
+    }
+    case kMeOpNary: {
+      NaryMeExpr *opexp = static_cast<NaryMeExpr *>(x);
+      for (uint32 i = 0; i < opexp->GetNumOpnds(); i++) {
+        if (!IsLoopInvariant(opexp->GetOpnd(i))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+// If the LHS of the test expression is used to store the previous value of an
+// IV before it's increment/decrement, then change the test to be based on the
+// IV.  Return true if change has taken place.
+bool IVCanon::CheckPostIncDecFixUp(CondGotoMeStmt *condbr) {
+  ASSERT_NOT_NULL(condbr);
+  OpMeExpr *testExpr = static_cast<OpMeExpr *>(condbr->GetOpnd());
+  ScalarMeExpr *scalar = testExpr->GetOpnd(0)->IsScalar() ? static_cast<ScalarMeExpr *>(testExpr->GetOpnd(0))
+                                                          : nullptr;
+  bool cvtOnScalar = false;
+  if (scalar == nullptr && testExpr->GetOpnd(0)->GetOp() == OP_cvt) {
+    scalar = testExpr->GetOpnd(0)->GetOpnd(0)->IsScalar() ?
+        static_cast<ScalarMeExpr *>(testExpr->GetOpnd(0)->GetOpnd(0)) : nullptr;
+    cvtOnScalar = true;
+  }
+  if (scalar == nullptr) {
+    return false;
+  }
+  if (scalar->GetDefBy() != kDefByPhi) {
+    return false;
+  }
+  MePhiNode *phi = &scalar->GetDefPhi();
+  MapleVector<ScalarMeExpr *> &phiOpnds = phi->GetOpnds();
+  if (phiOpnds.size() != 2) {
+    return false;
+  }
+  if (phiOpnds[0]->GetDefBy() != kDefByStmt || phiOpnds[1]->GetDefBy() != kDefByStmt) {
+    return false;
+  }
+  AssignMeStmt *defStmt0 = static_cast<AssignMeStmt *>(phiOpnds[0]->GetDefStmt());
+  AssignMeStmt *defStmt1 = static_cast<AssignMeStmt *>(phiOpnds[1]->GetDefStmt());
+  ScalarMeExpr *rhsScalar0 = nullptr;
+  ScalarMeExpr *rhsScalar1 = nullptr;
+  if (defStmt0->GetRHS()->IsScalar()) {
+    rhsScalar0 = static_cast<ScalarMeExpr *>(defStmt0->GetRHS());
+  }
+  if (defStmt1->GetRHS()->IsScalar()) {
+    rhsScalar1 = static_cast<ScalarMeExpr *>(defStmt1->GetRHS());
+  }
+  if (rhsScalar0 == nullptr || rhsScalar1 == nullptr) {
+    return false;
+  }
+  if (rhsScalar0->GetOst() != rhsScalar1->GetOst()) {
+    return false;
+  }
+  OriginalSt *ivOst = rhsScalar0->GetOst();
+  // find the phi for ivOst
+  BB *bb = condbr->GetBB();
+  MapleMap<OStIdx, MePhiNode*> &mePhiList = bb->GetMePhiList();
+  MePhiNode *ivPhiNode =  mePhiList[ivOst->GetIndex()];
+  if (ivPhiNode == nullptr) {
+    return false;
+  }
+  if (ivPhiNode->GetOpnd(0)->GetDefBy() != kDefByStmt || ivPhiNode->GetOpnd(1)->GetDefBy() != kDefByStmt) {
+    return false;
+  }
+  AssignMeStmt *ivDefStmt0 = static_cast<AssignMeStmt *>(ivPhiNode->GetOpnd(0)->GetDefStmt());
+  AssignMeStmt *ivDefStmt1 = static_cast<AssignMeStmt *>(ivPhiNode->GetOpnd(1)->GetDefStmt());
+  if (!ivDefStmt0->isIncDecStmt || !ivDefStmt1->isIncDecStmt) {
+    return false;
+  }
+  if (ivDefStmt0->GetRHS()->GetOp() != ivDefStmt1->GetRHS()->GetOp()) {
+    return false;
+  }
+  if (ivDefStmt0->GetRHS()->GetOpnd(1) != ivDefStmt1->GetRHS()->GetOpnd(1)) {
+    return false;
+  }
+  ScalarMeExpr *iv0 = static_cast<ScalarMeExpr *>(ivDefStmt0->GetRHS()->GetOpnd(0));
+  ScalarMeExpr *iv1 = static_cast<ScalarMeExpr *>(ivDefStmt1->GetRHS()->GetOpnd(0));
+  if (iv0 != rhsScalar0 || iv1 != rhsScalar1) {
+    return false;
+  }
+  // give up if type is unsigned and it will decrement past 0
+  if (IsPrimitiveUnsigned(testExpr->GetOpndType()) && testExpr->GetOpnd(1)->IsZero()) {
+    return false;
+  }
+  // match successful; modify the test expression
+  OpMeExpr newCmpRHS(-1, ivDefStmt0->GetRHS()->GetOp(), testExpr->GetOpnd(1)->GetPrimType(), 2);
+  newCmpRHS.SetOpnd(0, testExpr->GetOpnd(1));
+  newCmpRHS.SetOpnd(1, ivDefStmt0->GetRHS()->GetOpnd(1));
+
+  OpMeExpr cmpMeExpr(-1, testExpr->GetOp(), testExpr->GetPrimType(), 2);
+  if (!cvtOnScalar) {
+    cmpMeExpr.SetOpnd(0, ivPhiNode->GetLHS());
+  } else {
+    OpMeExpr cvtx(-1, OP_cvt, testExpr->GetOpnd(0)->GetPrimType(), 1);
+    cvtx.SetOpnd(0, ivPhiNode->GetLHS());
+    cvtx.SetOpndType(static_cast<OpMeExpr *>(testExpr->GetOpnd(0))->GetOpndType());
+    cmpMeExpr.SetOpnd(0, func->GetIRMap()->HashMeExpr(cvtx));
+  }
+  cmpMeExpr.SetOpnd(1, func->GetIRMap()->HashMeExpr(newCmpRHS));
+  cmpMeExpr.SetOpndType(testExpr->GetOpndType());
+
+  condbr->SetOpnd(0, func->GetIRMap()->HashMeExpr(cmpMeExpr));
+  return true;
+}
+
+static bool CompareHasEqual(Opcode op) {
+  return (op == OP_le || op == OP_ge);
+}
+
+void IVCanon::ComputeTripCount() {
+  MeIRMap *irMap = func->GetIRMap();
+  // find the termination test expression
+  if (!aloop->head->GetLastMe()->IsCondBr()) {
+    return;
+  }
+  CondGotoMeStmt *condbr = static_cast<CondGotoMeStmt *>(aloop->head->GetLastMe());
+  if (!kOpcodeInfo.IsCompare(condbr->GetOpnd()->GetOp()) || condbr->GetOpnd()->GetOp() == OP_eq) {
+    return;
+  }
+  bool tryAgain = false;
+  size_t trialsCount = 0;
+  IVDesc *ivdesc = nullptr;
+  OpMeExpr *testExpr = nullptr;
+  do {
+    trialsCount++;
+    testExpr = static_cast<OpMeExpr *>(condbr->GetOpnd());
+    // check left operand
+    ScalarMeExpr *iv = testExpr->GetOpnd(0)->IsScalar() ? static_cast<ScalarMeExpr *>(testExpr->GetOpnd(0))
+                                                        : nullptr;
+    bool cvtDetected = false;
+    if (iv == nullptr && testExpr->GetOpnd(0)->GetOp() == OP_cvt) {
+      iv = testExpr->GetOpnd(0)->GetOpnd(0)->IsScalar() ?
+          static_cast<ScalarMeExpr *>(testExpr->GetOpnd(0)->GetOpnd(0)) : nullptr;
+      cvtDetected = true;
+    }
+    if (iv) {
+      for (uint32 i = 0; i < ivvec.size(); i++) {
+        if (iv->GetOst() == ivvec[i]->ost) {
+          ivdesc = ivvec[i];
+          if (cvtDetected) {
+            ivdesc->canBePrimary = false;
+          }
+          break;
+        }
+      }
+    }
+    if (ivdesc == nullptr) { // check second operand
+      cvtDetected = false;
+      iv = testExpr->GetOpnd(1)->IsScalar() ? static_cast<ScalarMeExpr *>(testExpr->GetOpnd(1)) : nullptr;
+      if (iv == nullptr && testExpr->GetOpnd(1)->GetOp() == OP_cvt) {
+        iv = testExpr->GetOpnd(1)->GetOpnd(0)->IsScalar() ?
+            static_cast<ScalarMeExpr *>(testExpr->GetOpnd(1)->GetOpnd(0)) : nullptr;
+        cvtDetected = true;
+      }
+      if (iv) {
+        for (uint32 i = 0; i < ivvec.size(); i++) {
+          if (iv->GetOst() == ivvec[i]->ost) {
+            ivdesc = ivvec[i];
+            if (cvtDetected) {
+              ivdesc->canBePrimary = false;
+            }
+            break;
+          }
+        }
+      }
+      if (ivdesc) {  // swap the 2 sides to make the IV the left operand
+        Opcode newop = testExpr->GetOp();
+        switch (testExpr->GetOp()) {
+          case OP_lt:
+            newop = OP_gt;
+            break;
+          case OP_le:
+            newop = OP_ge;
+            break;
+          case OP_gt:
+            newop = OP_lt;
+            break;
+          case OP_ge:
+            newop = OP_le;
+            break;
+          default:
+            break;
+        }
+        OpMeExpr opMeExpr(-1, newop, testExpr->GetPrimType(), 2);
+        opMeExpr.SetOpnd(0, testExpr->GetOpnd(1));
+        opMeExpr.SetOpnd(1, testExpr->GetOpnd(0));
+        opMeExpr.SetOpndType(testExpr->GetOpndType());
+        testExpr = static_cast<OpMeExpr *>(irMap->HashMeExpr(opMeExpr));
+        condbr->SetOpnd(0, testExpr);
+      }
+    }
+    if (ivdesc == nullptr && trialsCount == 1) {
+      tryAgain = CheckPostIncDecFixUp(condbr);
+    }
+  } while (tryAgain && trialsCount == 1);
+
+  if (ivdesc == nullptr || ivdesc->stepValue == 0) {
+    return;  // no IV in the termination test
+  }
+  if (!IsLoopInvariant(testExpr->GetOpnd(1))) {
+    return; // the right side is not loop-invariant
+  }
+
+  // check the termination test is in the right sense
+  if (ivdesc->stepValue > 0) {
+    if (condbr->GetOpnd()->GetOp() == OP_gt || condbr->GetOpnd()->GetOp() == OP_ge) {
+      return;
+    }
+  } else {
+    if (condbr->GetOpnd()->GetOp() == OP_lt || condbr->GetOpnd()->GetOp() == OP_le) {
+      return;
+    }
+  }
+
+  // form the trip count expression
+  MeExpr *testExprLHS = testExpr->GetOpnd(0);
+  MeExpr *testExprRHS = testExpr->GetOpnd(1);
+  PrimType primTypeUsed = testExprRHS->GetPrimType();
+  if (GetPrimTypeSize(testExprLHS->GetPrimType()) > GetPrimTypeSize(primTypeUsed)) {
+    primTypeUsed = testExprLHS->GetPrimType();
+  }
+  if (!ivdesc->initExpr->IsZero()) {
+    primTypeUsed = GetSignedPrimType(primTypeUsed);
+  }
+  PrimType divPrimType = primTypeUsed;
+  if (ivdesc->stepValue < 0) {
+    divPrimType = GetSignedPrimType(divPrimType);
+  }
+  // add: t = bound + (stepValue +/-1)
+  OpMeExpr add(-1, OP_add, primTypeUsed, 2);
+  add.SetOpnd(0, testExprRHS); // IV bound
+  if (CompareHasEqual(condbr->GetOpnd()->GetOp())) {
+    // if cond has equal operand, t = bound + stepValue
+    add.SetOpnd(1, irMap->CreateIntConstMeExpr(ivdesc->stepValue, primTypeUsed));
+  } else {
+    add.SetOpnd(1, irMap->CreateIntConstMeExpr(ivdesc->stepValue > 0 ? ivdesc->stepValue - 1
+                                                                     : ivdesc->stepValue + 1,
+                                               primTypeUsed));
+  }
+  MeExpr *subx = irMap->HashMeExpr(add);
+  if (!ivdesc->initExpr->IsZero()) {
+    // sub: t = t - initExpr
+    OpMeExpr subtract(-1, OP_sub, primTypeUsed, 2);
+    subtract.SetOpnd(0, subx);
+    subtract.SetOpnd(1, ivdesc->initExpr);
+    subx = irMap->HashMeExpr(subtract);
+  }
+  MeExpr *divx = subx;
+  if (ivdesc->stepValue != 1) {
+    // div: t = t / stepValue
+    OpMeExpr divide(-1, OP_div, divPrimType, 2);
+    divide.SetOpnd(0, divx);
+    divide.SetOpnd(1, irMap->CreateIntConstMeExpr(ivdesc->stepValue, divPrimType));
+    divx = irMap->HashMeExpr(divide);
+  }
+  tripCount = irMap->SimplifyMeExpr(dynamic_cast<OpMeExpr *>(divx));
+  // check value of tripCount, if it's negative int32_t, reset to 0
+  if (tripCount) {
+    if (tripCount->GetOp() == maple::OP_constval) {
+      MIRConst *con =  static_cast<ConstMeExpr *>(tripCount)->GetConstVal();
+      MIRIntConst *countval =  static_cast<MIRIntConst *>(con);
+      if (countval->IsNegative()) {
+        MIRIntConst *zeroConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, con->GetType());
+        tripCount = irMap->CreateConstMeExpr(tripCount->GetPrimType(), *zeroConst);
+      }
+    } else { // generate code to prevent negative trip count at run time
+      OpMeExpr maxExpr(-1, OP_max, divPrimType, 2);
+      maxExpr.SetOpnd(0, tripCount);
+      maxExpr.SetOpnd(1, irMap->CreateIntConstMeExpr(0, divPrimType));
+      tripCount = irMap->HashMeExpr(maxExpr);
+    }
+  }
+}
+
+void IVCanon::CanonEntryValues() {
+  for (uint32 i = 0; i < ivvec.size(); i++) {
+    IVDesc *ivdesc = ivvec[i];
+    if (ivdesc->initExpr->GetMeOp() == kMeOpVar || ivdesc->initExpr->GetMeOp() == kMeOpReg) {
+      std::string initName = "";
+      if (ivdesc->ost->IsPregOst()) {
+        (void)initName.append("regno").append(std::to_string(ivdesc->ost->GetPregIdx()));
+      } else {
+        (void)initName.append(ivdesc->ost->GetMIRSymbol()->GetName());
+      }
+      initName.append(std::to_string(ivdesc->ost->GetFieldID()));
+      initName.append(std::to_string(loopID));
+      initName.append(std::to_string(i));
+      initName.append(".init");
+      GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(initName);
+      ScalarMeExpr *scalarMeExpr = func->GetIRMap()->CreateNewVar(strIdx, ivdesc->primType, false);
+      scalarMeExpr->GetOst()->storesIVInitValue = true;
+      AssignMeStmt *ass = func->GetIRMap()->CreateAssignMeStmt(*scalarMeExpr, *ivdesc->initExpr, *aloop->preheader);
+      aloop->preheader->AddMeStmtLast(ass);
+      ivdesc->initExpr = scalarMeExpr;
+    }
+  }
+}
+
+void IVCanon::CanonExitValues() {
+  for (IVDesc *ivdesc : ivvec) {
+    // look for the identity assignment
+    MeStmt *stmt = aloop->exitBB->GetFirstMe();
+    while (stmt) {
+      if (stmt->GetOp() == OP_dassign || stmt->GetOp() == OP_regassign) {
+        AssignMeStmt *ass = static_cast<AssignMeStmt *>(stmt);
+        if (ass->GetLHS()->GetOst() == ivdesc->ost) {
+          break;
+        }
+      }
+      stmt = stmt->GetNext();
+    }
+    CHECK_FATAL(stmt != nullptr, "CanonExitValues: cannot find identity assignments at an exit node");
+    AssignMeStmt *ass = static_cast<AssignMeStmt *>(stmt);
+    CHECK_FATAL(ass->GetRHS()->GetMeOp() == kMeOpVar || ass->GetRHS()->GetMeOp() == kMeOpReg,
+                "CanonExitValues: assignment at exit node is not identity assignment");
+    ScalarMeExpr *rhsvar = static_cast<ScalarMeExpr *>(ass->GetRHS());
+    CHECK_FATAL(rhsvar->GetOst() == ivdesc->ost,
+                "CanonExitValues: assignment at exit node is not identity assignment");
+    MeExpr *tripCountUsed = tripCount;
+    if (GetPrimTypeSize(tripCount->GetPrimType()) != GetPrimTypeSize(ivdesc->primType)) {
+      OpMeExpr cvtx(-1, OP_cvt, ivdesc->primType, 1);
+      cvtx.SetOpnd(0, tripCount);
+      cvtx.SetOpndType(tripCount->GetPrimType());
+      tripCountUsed = func->GetIRMap()->HashMeExpr(cvtx);
+    }
+    MeExpr *mulx = tripCountUsed;
+    if (ivdesc->stepValue != 1) {
+      PrimType primTypeUsed = ivdesc->stepValue < 0 ? GetSignedPrimType(ivdesc->primType) : ivdesc->primType;
+      OpMeExpr mulmeexpr(-1, OP_mul, primTypeUsed, 2);
+      mulmeexpr.SetOpnd(0, mulx);
+      mulmeexpr.SetOpnd(1, func->GetIRMap()->CreateIntConstMeExpr(ivdesc->stepValue, primTypeUsed));
+      mulx = func->GetIRMap()->HashMeExpr(mulmeexpr);
+    }
+    MeExpr *addx = mulx;
+    if (!ivdesc->initExpr->IsZero()) {
+      OpMeExpr addmeexpr(-1, OP_add, ivdesc->primType, 2);
+      addmeexpr.SetOpnd(0, ivdesc->initExpr);
+      addmeexpr.SetOpnd(1, mulx);
+      addx = func->GetIRMap()->HashMeExpr(addmeexpr);
+    }
+    ass->SetRHS(addx);
+  }
+}
+
+void IVCanon::ReplaceSecondaryIVPhis() {
+  BB *headBB = aloop->head;
+  // first, form the expression of the primary IV minus its init value
+  IVDesc *primaryIVDesc = ivvec[static_cast<uint32>(idxPrimaryIV)];
+  // find its phi in the phi list at the loop head
+  MapleMap<OStIdx, MePhiNode *>::iterator it = headBB->GetMePhiList().find(primaryIVDesc->ost->GetIndex());
+  MePhiNode *phi = it->second;
+  MeExpr *iterCountExpr = phi->GetLHS();
+  if (!primaryIVDesc->initExpr->IsZero()) {
+    OpMeExpr submeexpr(-1, OP_sub, primaryIVDesc->primType, 2);
+    submeexpr.SetOpnd(0, phi->GetLHS());
+    submeexpr.SetOpnd(1, primaryIVDesc->initExpr);
+    iterCountExpr = func->GetIRMap()->HashMeExpr(submeexpr);
+  }
+
+  for (uint32 i = 0; i < ivvec.size(); i++) {
+    if (i == static_cast<uint32>(idxPrimaryIV)) {
+      continue;
+    }
+    IVDesc *ivdesc = ivvec[i];
+    // find its phi in the phi list at the loop head
+    it = headBB->GetMePhiList().find(ivdesc->ost->GetIndex());
+    phi = it->second;
+
+    MeExpr *iterCountUsed = iterCountExpr;
+    if (GetPrimTypeSize(iterCountExpr->GetPrimType()) != GetPrimTypeSize(ivdesc->primType)) {
+      OpMeExpr cvtx(-1, OP_cvt, ivdesc->primType, 1);
+      cvtx.SetOpnd(0, iterCountExpr);
+      cvtx.SetOpndType(iterCountExpr->GetPrimType());
+      iterCountUsed = func->GetIRMap()->HashMeExpr(cvtx);
+    }
+    MeExpr *mulx = iterCountUsed;
+    if (ivdesc->stepValue != 1) {
+      PrimType primTypeUsed = ivdesc->stepValue < 0 ? GetSignedPrimType(ivdesc->primType) : ivdesc->primType;
+      OpMeExpr mulMeExpr(-1, OP_mul, primTypeUsed, 2);
+      mulMeExpr.SetOpnd(0, mulx);
+      mulMeExpr.SetOpnd(1, func->GetIRMap()->CreateIntConstMeExpr(ivdesc->stepValue, primTypeUsed));
+      mulx = func->GetIRMap()->HashMeExpr(mulMeExpr);
+    }
+    OpMeExpr addMeExpr(-1, OP_add, ivdesc->primType, 2);
+    MeExpr *addx = mulx;
+    if (!ivdesc->initExpr->IsZero()) {
+      addMeExpr.SetOpnd(0, ivdesc->initExpr);
+      addMeExpr.SetOpnd(1, mulx);
+      addx = func->GetIRMap()->HashMeExpr(addMeExpr);
+    }
+    AssignMeStmt *ass = func->GetIRMap()->CreateAssignMeStmt(*phi->GetLHS(), *addx, *headBB);
+    headBB->PrependMeStmt(ass);
+    // change phi's lhs to new version
+    ScalarMeExpr *newlhs = nullptr;
+    if (phi->GetLHS()->GetMeOp() == kMeOpVar) {
+      newlhs = func->GetIRMap()->CreateVarMeExprVersion(ivdesc->ost);
+    } else {
+      newlhs = func->GetIRMap()->CreateRegMeExprVersion(*ivdesc->ost);
+    }
+    phi->SetLHS(newlhs);
+  }
+}
+
+void IVCanon::PerformIVCanon() {
+  BB *headBB = aloop->head;
+  uint32 phiOpndIdxOfInit = 1;
+  uint32 phiOpndIdxOfLoopBack = 0;
+  if (aloop->loopBBs.count(headBB->GetPred(0)->GetBBId()) == 0) {
+    phiOpndIdxOfInit = 0;
+    phiOpndIdxOfLoopBack = 1;
+  }
+  CHECK_FATAL(aloop->tail == headBB->GetPred(phiOpndIdxOfLoopBack), "PerformIVCanon: tail BB inaccurate");
+  // go thru the list of phis at the loop head to find all IVs
+  for (std::pair<OStIdx, MePhiNode*> mapEntry: headBB->GetMePhiList()) {
+    OriginalSt *ost = ssatab->GetOriginalStFromID(mapEntry.first);
+    CHECK_FATAL(ost, "ost is nullptr!");
+    if (!ost->IsIVCandidate()) {
+      continue;
+    }
+    ScalarMeExpr *philhs = mapEntry.second->GetLHS();
+    ScalarMeExpr *initVersion = mapEntry.second->GetOpnd(phiOpndIdxOfInit);
+    ScalarMeExpr *loopbackVersion = mapEntry.second->GetOpnd(phiOpndIdxOfLoopBack);
+    if (loopbackVersion != philhs && ResolveExprValue(loopbackVersion, philhs)) {
+      CharacterizeIV(initVersion, loopbackVersion, philhs);
+    }
+  }
+  CanonEntryValues();
+  ComputeTripCount();
+  if (tripCount == nullptr) {
+    return;
+  }
+  FindPrimaryIV();
+  if (DEBUGFUNC(func)) {
+    LogInfo::MapleLogger() << "****** while loop at label " << "@"
+                           << func->GetMirFunc()->GetLabelName(headBB->GetBBLabel());
+    LogInfo::MapleLogger() << ", BB id:" << headBB->GetBBId()  << " has IVs:" << endl;
+    for (uint32 i = 0; i < ivvec.size(); i++) {
+      IVDesc *ivdesc = ivvec[i];
+      ivdesc->ost->Dump();
+      LogInfo::MapleLogger() << "  step: " << ivdesc->stepValue << " initExpr: ";
+      ivdesc->initExpr->Dump(func->GetIRMap());
+      if (i == static_cast<uint32>(idxPrimaryIV)) {
+        LogInfo::MapleLogger() << " [PRIMARY IV]";
+      }
+      LogInfo::MapleLogger() << endl;
+    }
+  }
+  if (DEBUGFUNC(func)) {
+    LogInfo::MapleLogger() << "****** trip count is: ";
+    tripCount->Dump(func->GetIRMap(), 0);
+    LogInfo::MapleLogger() << endl;
+  }
+  CanonExitValues();
+  ReplaceSecondaryIVPhis();
+}
+
+bool MELfoIVCanon::PhaseRun(MeFunction &f) {
+  Dominance *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  ASSERT(dom != nullptr, "dominance phase has problem");
+
+  MeIRMap *irmap = GET_ANALYSIS(MEIRMapBuild, f);
+  ASSERT(irmap != nullptr, "hssamap has problem");
+
+  IdentifyLoops *identLoops = GET_ANALYSIS(MELoopAnalysis, f);
+  CHECK_FATAL(identLoops != nullptr, "identloops has problem");
+
+  PreMeFunction *preMeFunc = f.GetPreMeFunc();
+
+  // loop thru all the loops in reverse order so inner loops are processed first
+  for (int32 i = static_cast<int32>(identLoops->GetMeLoops().size()) - 1; i >= 0; i--) {
+    LoopDesc *aloop = identLoops->GetMeLoops()[i];
+    BB *headbb = aloop->head;
+    // check if the label has associated PreMeWhileInfo
+    if (headbb->GetBBLabel() == 0) {
+      continue;
+    }
+    if (aloop->exitBB == nullptr || aloop->preheader == nullptr) {
+      continue;
+    }
+    MapleMap<LabelIdx, PreMeWhileInfo*>::iterator it = preMeFunc->label2WhileInfo.find(headbb->GetBBLabel());
+    if (it == preMeFunc->label2WhileInfo.end()) {
+      continue;
+    }
+    PreMeWhileInfo *whileInfo = it->second;
+    if (whileInfo->injectedIVSym == nullptr) {
+      continue;
+    }
+
+    MemPool *ivmp = GetPhaseMemPool();
+    IVCanon ivCanon(ivmp, &f, dom, aloop, static_cast<uint32>(i), whileInfo);
+    ivCanon.PerformIVCanon();
+    // transfer primary IV info to whileinfo
+    if (ivCanon.idxPrimaryIV != -1) {
+      IVDesc *primaryIVDesc = ivCanon.ivvec[static_cast<size_t>(ivCanon.idxPrimaryIV)];
+      CHECK_FATAL(primaryIVDesc->ost->IsSymbolOst(), "primary IV cannot be preg");
+      whileInfo->ivOst = primaryIVDesc->ost;
+      whileInfo->initExpr = primaryIVDesc->initExpr;
+      whileInfo->stepValue = primaryIVDesc->stepValue;
+      whileInfo->tripCount = ivCanon.tripCount;
+      whileInfo->canConvertDoloop = ivCanon.tripCount != nullptr;
+    }
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== After IV Canonicalization  =============" << endl;
+    irmap->Dump();
+  }
+
+  return true;
+}
+
+void MELfoIVCanon::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/lfo_loop_vec.cpp b/src/mapleall/maple_me/src/lfo_loop_vec.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b44c1fe97b831e90a902bc09326a81b81419e9d8
--- /dev/null
+++ b/src/mapleall/maple_me/src/lfo_loop_vec.cpp
@@ -0,0 +1,2270 @@
+/*
+ * Copyright (c) [2021-2022] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "lfo_loop_vec.h"
+#include <iostream>
+#include <algorithm>
+#include "me_option.h"
+#include "mir_module.h"
+#include "mir_builder.h"
+#include "common_utils.h"
+
+constexpr uint32_t maxVecSize = 128;
+
+namespace maple {
+
+void LoopVecInfo::UpdateDoloopProfData(MIRFunction *mirFunc, DoloopNode *doLoop, int32_t vecLanes, bool isRemainder) {
+  auto *profData = mirFunc->GetFuncProfData();
+  if (!profData) {
+    return;
+  }
+  int64_t doloopFreq = profData->GetStmtFreq(doLoop->GetStmtID());
+  int64_t tempFreq;
+  BlockNode *body = doLoop->GetDoBody();
+  int64_t bodyFreq = profData->GetStmtFreq(body->GetStmtID());
+  if (isRemainder) {
+    // update doLoop node in remainder
+    tempFreq = (bodyFreq % vecLanes) + (doloopFreq - bodyFreq);
+    profData->SetStmtFreq(doLoop->GetStmtID(), tempFreq);
+    // update doLoop body freq in remainder
+    profData->SetStmtFreq(body->GetStmtID(), (bodyFreq % vecLanes));
+    // update stmtlist in doloopbody
+    if (body->GetFirst()) {
+      profData->SetStmtFreq(body->GetFirst()->GetStmtID(), (bodyFreq % vecLanes));
+    }
+    if (body->GetLast() && (body->GetFirst() != body->GetLast())) {
+      profData->SetStmtFreq(body->GetLast()->GetStmtID(), (bodyFreq % vecLanes));
+    }
+  } else {
+    // vectorized doLoop
+    tempFreq = (bodyFreq / vecLanes) + (doloopFreq - bodyFreq);
+    profData->SetStmtFreq(doLoop->GetStmtID(), tempFreq);
+    // update doLoop body freq
+    profData->SetStmtFreq(body->GetStmtID(), (bodyFreq / vecLanes));
+    // update stmtlist in doloopbody
+    if (body->GetFirst()) {
+      profData->SetStmtFreq(body->GetFirst()->GetStmtID(), (tempFreq / vecLanes));
+    }
+    if (body->GetLast() && (body->GetFirst() != body->GetLast())) {
+      profData->SetStmtFreq(body->GetLast()->GetStmtID(), (tempFreq / vecLanes));
+    }
+  }
+}
+
+uint32_t LoopVectorization::vectorizedLoop = 0;
+
+void LoopVecInfo::UpdateWidestTypeSize(uint32_t newTypesize) {
+  if (largestTypeSize < newTypesize) {
+    largestTypeSize = newTypesize;
+  }
+}
+
+bool LoopVecInfo::UpdateRHSTypeSize(PrimType ptype) {
+  uint32_t newSize = GetPrimTypeSize(ptype) * 8;
+  if (smallestTypeSize > newSize) {
+    smallestTypeSize = newSize;
+  }
+  if (currentRHSTypeSize == 0) {
+    currentRHSTypeSize = newSize;
+    return true;
+  } else if (newSize > currentRHSTypeSize) {
+    currentRHSTypeSize = newSize;
+    return false; // skip vectorize now since type is not consistent
+  } else if (newSize < currentRHSTypeSize) {
+    return false;
+  }
+  return true;
+}
+
+// generate new bound for vectorization loop and epilog loop
+// original bound info <initnode, uppernode, incrnode>, condNode doesn't include equal
+// limitation now:  initNode and incrNode are const and initnode is vectorLane aligned.
+// vectorization loop: <initnode, (uppernode-initnode)/vectorFactor * vectorFactor + initnode, incrNode*vectFact>
+// epilog loop: < (uppernode-initnode)/vectorFactor*vectorFactor+initnode, uppernode, incrnode>
+void LoopTransPlan::GenerateBoundInfo(const DoloopNode *doLoop, const DoloopInfo *li) {
+  (void) li;
+  BaseNode *initNode = doLoop->GetStartExpr();
+  BaseNode *incrNode = doLoop->GetIncrExpr();
+  BaseNode *condNode = doLoop->GetCondExpr();
+  bool condOpHasEqual = ((condNode->GetOpCode() == OP_le) || (condNode->GetOpCode() == OP_ge));
+  ConstvalNode *constOnenode = nullptr;
+  MIRType *typeInt = GlobalTables::GetTypeTable().GetInt32();
+  if (condOpHasEqual) {
+    MIRIntConst *constOne = GlobalTables::GetIntConstTable().GetOrCreateIntConst(1, *typeInt);
+    constOnenode = codeMP->New<ConstvalNode>(PTY_i32, constOne);
+  }
+  ASSERT(incrNode->IsConstval(), "too complex, incrNode should be const");
+  ConstvalNode *icn = static_cast<ConstvalNode *>(incrNode);
+  MIRIntConst *incrConst = static_cast<MIRIntConst *>(icn->GetConstVal());
+  ASSERT(condNode->IsBinaryNode(), "cmp node should be binary node");
+  BaseNode *upNode = condNode->Opnd(1);
+
+  MIRIntConst *newIncr = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+      vecFactor * incrConst->GetExtValue(), *typeInt);
+  ConstvalNode *newIncrNode = codeMP->New<ConstvalNode>(PTY_i32, newIncr);
+  PrimType newOpndtype = (static_cast<CompareNode *>(condNode))->GetOpndType() == PTY_ptr ? PTY_i64 : PTY_i32;
+  if (initNode->IsConstval()) {
+    ConstvalNode *lcn = static_cast<ConstvalNode *>(initNode);
+    MIRIntConst *lowConst = static_cast<MIRIntConst *>(lcn->GetConstVal());
+    int64 lowvalue = lowConst->GetExtValue();
+    // upNode is constant
+    if (upNode->IsConstval()) {
+      ConstvalNode *ucn = static_cast<ConstvalNode *>(upNode);
+      MIRIntConst *upConst = static_cast<MIRIntConst *>(ucn->GetConstVal());
+      int64 upvalue = upConst->GetExtValue();
+      if (condOpHasEqual) {
+        upvalue += 1;
+      }
+      int64 newIncrVal = newIncr->GetExtValue();
+      if (((upvalue - lowvalue) % newIncrVal) == 0) {
+        // early return, change vbound->stride only
+        vBound = localMP->New<LoopBound>(nullptr, nullptr, newIncrNode);
+      } else {
+        // trip count is not vector lane aligned
+        int64 newupval = (upvalue - lowvalue) / newIncrVal * newIncrVal + lowvalue;
+        MIRIntConst *newUpConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(newupval, *typeInt);
+        ConstvalNode *newUpNode = codeMP->New<ConstvalNode>(PTY_i32, newUpConst);
+        vBound = localMP->New<LoopBound>(nullptr, newUpNode, newIncrNode);
+        // generate epilog
+        eBound = localMP->New<LoopBound>(newUpNode, nullptr, nullptr);
+      }
+    } else {
+      // step 1: generate vectorized loop bound
+      // upNode of vBound is (uppnode - initnode) / newIncr * newIncr + initnode
+      BinaryNode *divnode = nullptr;
+      BaseNode *addnode = upNode;
+      if (condOpHasEqual) {
+        addnode = codeMP->New<BinaryNode>(OP_add, newOpndtype, upNode, constOnenode);
+      }
+      if (lowvalue != 0) {
+        BinaryNode *subnode = codeMP->New<BinaryNode>(OP_sub, newOpndtype, addnode, initNode);
+        divnode = codeMP->New<BinaryNode>(OP_div, newOpndtype, subnode, newIncrNode);
+      } else {
+        divnode = codeMP->New<BinaryNode>(OP_div, newOpndtype, addnode, newIncrNode);
+      }
+      BinaryNode *mulnode = codeMP->New<BinaryNode>(OP_mul, newOpndtype, divnode, newIncrNode);
+      addnode = codeMP->New<BinaryNode>(OP_add, newOpndtype, mulnode, initNode);
+      vBound = localMP->New<LoopBound>(nullptr, addnode, newIncrNode);
+      // step2:  generate epilog bound
+      eBound = localMP->New<LoopBound>(addnode, nullptr, nullptr);
+    }
+  } else {
+    // initnode is not constant
+    // set bound of vectorized loop
+    BinaryNode *subnode = nullptr;
+    if (condOpHasEqual) {
+      BinaryNode *addnode = codeMP->New<BinaryNode>(OP_add, newOpndtype, upNode, constOnenode);
+      subnode = codeMP->New<BinaryNode>(OP_sub, newOpndtype, addnode, initNode);
+    } else {
+      subnode = codeMP->New<BinaryNode>(OP_sub, newOpndtype, upNode, initNode);
+    }
+    BinaryNode *divnode = codeMP->New<BinaryNode>(OP_div, newOpndtype, subnode, newIncrNode);
+    BinaryNode *mulnode = codeMP->New<BinaryNode>(OP_mul, newOpndtype, divnode, newIncrNode);
+    BinaryNode *addnode = codeMP->New<BinaryNode>(OP_add, newOpndtype, mulnode, initNode);
+    vBound = localMP->New<LoopBound>(nullptr, addnode, newIncrNode);
+    // set bound of epilog loop
+    eBound = localMP->New<LoopBound>(addnode, nullptr, nullptr);
+  }
+}
+
+// generate best plan for current doloop
+bool LoopTransPlan::Generate(const DoloopNode *doLoop, const DoloopInfo* li, bool enableDebug) {
+  // vector length / type size
+  vecLanes = maxVecSize / (vecInfo->largestTypeSize);
+  vecFactor = vecLanes;
+  // return false if small type has no builtin vector type
+  if (vecFactor * vecInfo->smallestTypeSize < maplebe::k64BitSize) {
+    if (enableDebug) {
+      LogInfo::MapleLogger() << "NOT VECTORIZABLE because no builtin vector type for smallestType in loop\n";
+    }
+    return false;
+  }
+  // if depdist is not zero
+  if (vecInfo->minTrueDepDist > 0 || vecInfo->maxAntiDepDist < 0) {
+    // true dep distance is less than vecLanes, return false
+    if ((vecInfo->minTrueDepDist > 0) && (vecInfo->minTrueDepDist < vecLanes)) {
+      if (enableDebug) {
+        LogInfo::MapleLogger() << "NOT VECTORIZABLE because true dependence distance less than veclanes in loop\n";
+      }
+      return false;
+    }
+    // anti-dep distance doesn't break vectorization in case
+    //  use before def like a[i] = a[i+1]
+    // if use is after def as following, distance less than vecLanes will break vectorization
+    //  a[i] =
+    //       = a[i+1]
+    // there's no extra information to describe sequence now
+    // we only handle one stmt in loopbody without considering anti-dep distance
+    if ((vecInfo->maxAntiDepDist < 0) && ((-vecInfo->maxAntiDepDist) < vecLanes) &&
+        (doLoop->GetDoBody()->GetFirst() != doLoop->GetDoBody()->GetLast())) {
+      if (enableDebug) {
+        LogInfo::MapleLogger() << "NOT VECTORIZABLE because anti dependence distance less than veclanes in loop\n";
+      }
+      return false;
+    }
+  }
+  // compare trip count if lanes is larger than tripcount
+  {
+    BaseNode *initNode = doLoop->GetStartExpr();
+    BaseNode *incrNode = doLoop->GetIncrExpr();
+    BaseNode *condNode = doLoop->GetCondExpr();
+    BaseNode *upNode = condNode->Opnd(1);
+    BaseNode *condOpnd0 = condNode->Opnd(0);
+
+    // check opnd0 of condNode is an expression not a variable
+    // upperbound formula doesn't handle this case now
+    if ((condOpnd0->GetOpCode() != OP_dread) &&
+        (condOpnd0->GetOpCode() != OP_regread)) {
+      if (enableDebug) {
+        LogInfo::MapleLogger() << "NOT VECTORIZABLE because of doLoop condition compare is complex \n";
+      }
+      return false;
+    }
+
+    bool condOpHasEqual = ((condNode->GetOpCode() == OP_le) || (condNode->GetOpCode() == OP_ge));
+    if (initNode->IsConstval() && upNode->IsConstval() && incrNode->IsConstval()) {
+      ConstvalNode *lcn = static_cast<ConstvalNode *>(initNode);
+      MIRIntConst *lowConst = static_cast<MIRIntConst *>(lcn->GetConstVal());
+      int64 lowvalue = lowConst->GetExtValue();
+      ConstvalNode *ucn = static_cast<ConstvalNode *>(upNode);
+      MIRIntConst *upConst = static_cast<MIRIntConst *>(ucn->GetConstVal());
+      int64 upvalue = upConst->GetExtValue();
+      ConstvalNode *icn = static_cast<ConstvalNode *>(incrNode);
+      MIRIntConst *incrConst = static_cast<MIRIntConst *>(icn->GetConstVal());
+      if (condOpHasEqual) {
+        upvalue += 1;
+      }
+      int64 tripCount = (upvalue - lowvalue) / (incrConst->GetExtValue());
+      if (static_cast<uint32>(tripCount) < vecLanes) {
+        tripCount = (tripCount / 4 * 4); // get closest 2^n
+        if (tripCount * vecInfo->smallestTypeSize < maplebe::k64BitSize) {
+          if (enableDebug) {
+            LogInfo::MapleLogger() << "NOT VECTORIZABLE because of doLoop trip count is small \n";
+          }
+          return false;
+        } else {
+          vecLanes = static_cast<uint8_t>(tripCount);
+          vecFactor = static_cast<uint8_t>(tripCount);
+        }
+      }
+    }
+  }
+  // generate bound information
+  GenerateBoundInfo(doLoop, li);
+  return true;
+}
+
+MIRType* LoopVectorization::GenVecType(PrimType sPrimType, uint8 lanes) const {
+  MIRType *vecType = nullptr;
+  CHECK_FATAL(IsPrimitiveInteger(sPrimType), "primtype should be integer");
+  switch (sPrimType) {
+    case PTY_i32: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4Int32();
+      } else if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2Int32();
+      } else {
+        ASSERT(0, "unsupported int32 vectory lanes");
+      }
+      break;
+    }
+    case PTY_u32: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4UInt32();
+      } else if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2UInt32();
+      } else {
+        ASSERT(0, "unsupported uint32 vectory lanes");
+      }
+      break;
+    }
+    case PTY_i16: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4Int16();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8Int16();
+      } else {
+        ASSERT(0, "unsupported int16 vector lanes");
+      }
+      break;
+    }
+    case PTY_u16: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4UInt16();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8UInt16();
+      } else {
+        ASSERT(0, "unsupported uint16 vector lanes");
+      }
+      break;
+    }
+    case PTY_i8: {
+      if (lanes == 16) {
+        vecType = GlobalTables::GetTypeTable().GetV16Int8();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8Int8();
+      } else {
+        ASSERT(0, "unsupported int8 vector lanes");
+      }
+      break;
+    }
+    case PTY_u8: {
+      if (lanes == 16) {
+        vecType = GlobalTables::GetTypeTable().GetV16UInt8();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8UInt8();
+      } else {
+        ASSERT(0, "unsupported uint8 vector lanes");
+      }
+      break;
+    }
+    case PTY_i64: {
+      if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2Int64();
+      } else {
+        ASSERT(0, "unsupported int64 vector lanes");
+      }
+      break;
+    }
+    case PTY_u64: {
+      if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2UInt64();
+      } else {
+        ASSERT(0, "unsupported uint64 vector lanes");
+      }
+      break;
+    }
+    case PTY_a64: {
+      if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2UInt64();
+      } else {
+        ASSERT(0, "unsupported a64 vector lanes");
+      }
+    }
+    [[clang::fallthrough]];
+    case PTY_ptr: {
+      if (GetPrimTypeSize(sPrimType) == 4) {
+        if (lanes == 4)  {
+          vecType = GlobalTables::GetTypeTable().GetV4UInt32();
+        } else if (lanes == 2) {
+          vecType = GlobalTables::GetTypeTable().GetV2UInt32();
+        } else {
+          ASSERT(0, "unsupported ptr vector lanes");
+        }
+      } else if (GetPrimTypeSize(sPrimType) == 8) {
+        if (lanes == 2) {
+          vecType = GlobalTables::GetTypeTable().GetV2UInt64();
+        } else {
+          ASSERT(0, "unsupported ptr vector lanes");
+        }
+      }
+      break;
+    }
+    default:
+      ASSERT(0, "NIY");
+  }
+  return vecType;
+}
+
+// generate instrinsic node to sum all elements of a vector type
+IntrinsicopNode *LoopVectorization::GenSumVecStmt(BaseNode *vecTemp, PrimType vecPrimType) {
+  MIRIntrinsicID intrnID = INTRN_vector_sum_v4i32;
+  MIRType *retType = nullptr;
+  switch (vecPrimType) {
+    case PTY_v4i32: {
+      intrnID = INTRN_vector_sum_v4i32;
+      retType = GlobalTables::GetTypeTable().GetInt32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = INTRN_vector_sum_v2i32;
+      retType = GlobalTables::GetTypeTable().GetInt32();
+      break;
+    }
+    case PTY_v4u32: {
+      intrnID = INTRN_vector_sum_v4u32;
+      retType = GlobalTables::GetTypeTable().GetUInt32();
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = INTRN_vector_sum_v2u32;
+      retType = GlobalTables::GetTypeTable().GetUInt32();
+      break;
+    }
+    case PTY_v2i64: {
+      intrnID = INTRN_vector_sum_v2i64;
+      retType = GlobalTables::GetTypeTable().GetInt64();
+      break;
+    }
+    case PTY_v2u64: {
+      intrnID = INTRN_vector_sum_v2u64;
+      retType = GlobalTables::GetTypeTable().GetUInt64();
+      break;
+    }
+    case PTY_v8i16: {
+      intrnID = INTRN_vector_sum_v8i16;
+      retType = GlobalTables::GetTypeTable().GetInt16();
+      break;
+    }
+    case PTY_v8u16: {
+      intrnID = INTRN_vector_sum_v8u16;
+      retType = GlobalTables::GetTypeTable().GetUInt16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = INTRN_vector_sum_v4i16;
+      retType = GlobalTables::GetTypeTable().GetInt16();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = INTRN_vector_sum_v4u16;
+      retType = GlobalTables::GetTypeTable().GetUInt16();
+      break;
+    }
+    case PTY_v16i8: {
+      intrnID = INTRN_vector_sum_v16i8;
+      retType = GlobalTables::GetTypeTable().GetInt8();
+      break;
+    }
+    case PTY_v16u8: {
+      intrnID = INTRN_vector_sum_v16u8;
+      retType = GlobalTables::GetTypeTable().GetUInt8();
+      break;
+    }
+    case PTY_v8i8: {
+      intrnID = INTRN_vector_sum_v8i8;
+      retType = GlobalTables::GetTypeTable().GetInt8();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = INTRN_vector_sum_v8u8;
+      retType = GlobalTables::GetTypeTable().GetUInt8();
+      break;
+    }
+    default:
+      ASSERT(0, "NIY");
+  }
+  // generate instrinsic op
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, retType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(1);
+  rhs->GetNopnd().push_back(vecTemp);
+  rhs->SetTyIdx(retType->GetTypeIndex());
+  return rhs;
+}
+
+// check opcode is reduction, +/-/*///min/max
+// now only support +/-
+bool LoopVectorization::IsReductionOp(Opcode op) const {
+  return op == OP_add || op == OP_sub;
+}
+
+// generate instrinsic node to copy scalar to vector type
+IntrinsicopNode *LoopVectorization::GenDupScalarExpr(BaseNode *scalar, PrimType vecPrimType) {
+  MIRIntrinsicID intrnID = INTRN_vector_from_scalar_v4i32;
+  MIRType *vecType = nullptr;
+  switch (vecPrimType) {
+    case PTY_v4i32: {
+      intrnID = INTRN_vector_from_scalar_v4i32;
+      vecType = GlobalTables::GetTypeTable().GetV4Int32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = INTRN_vector_from_scalar_v2i32;
+      vecType = GlobalTables::GetTypeTable().GetV2Int32();
+      break;
+    }
+    case PTY_v4u32: {
+      intrnID = INTRN_vector_from_scalar_v4u32;
+      vecType = GlobalTables::GetTypeTable().GetV4UInt32();
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = INTRN_vector_from_scalar_v2u32;
+      vecType = GlobalTables::GetTypeTable().GetV2UInt32();
+      break;
+    }
+    case PTY_v8i16: {
+      intrnID = INTRN_vector_from_scalar_v8i16;
+      vecType = GlobalTables::GetTypeTable().GetV8Int16();
+      break;
+    }
+    case PTY_v8u16: {
+      intrnID = INTRN_vector_from_scalar_v8u16;
+      vecType = GlobalTables::GetTypeTable().GetV8UInt16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = INTRN_vector_from_scalar_v4i16;
+      vecType = GlobalTables::GetTypeTable().GetV4Int16();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = INTRN_vector_from_scalar_v4u16;
+      vecType = GlobalTables::GetTypeTable().GetV4UInt16();
+      break;
+    }
+    case PTY_v16i8: {
+      intrnID = INTRN_vector_from_scalar_v16i8;
+      vecType = GlobalTables::GetTypeTable().GetV16Int8();
+      break;
+    }
+    case PTY_v16u8: {
+      intrnID = INTRN_vector_from_scalar_v16u8;
+      vecType = GlobalTables::GetTypeTable().GetV16UInt8();
+      break;
+    }
+    case PTY_v8i8: {
+      intrnID = INTRN_vector_from_scalar_v8i8;
+      vecType = GlobalTables::GetTypeTable().GetV8Int8();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = INTRN_vector_from_scalar_v8u8;
+      vecType = GlobalTables::GetTypeTable().GetV8UInt8();
+      break;
+    }
+    case PTY_v2i64: {
+      intrnID = INTRN_vector_from_scalar_v2i64;
+      vecType = GlobalTables::GetTypeTable().GetV2Int64();
+      break;
+    }
+    case PTY_v2u64: {
+      intrnID = INTRN_vector_from_scalar_v2u64;
+      vecType = GlobalTables::GetTypeTable().GetV2UInt64();
+      break;
+    }
+    default: {
+      ASSERT(0, "NIY");
+    }
+  }
+  // generate instrinsic op
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, vecPrimType);
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(1);
+  rhs->GetNopnd().push_back(scalar);
+  rhs->SetTyIdx(vecType->GetTypeIndex());
+  return rhs;
+}
+
+IntrinsicopNode *LoopVectorization::GenVectorGetLow(BaseNode *vecNode, PrimType vecPrimType) {
+  MIRIntrinsicID intrnID = INTRN_vector_get_low_v16i8;
+  MIRType *retvecType = nullptr;
+  switch (vecPrimType) {
+    case PTY_v16i8: {
+      intrnID = INTRN_vector_get_low_v16i8;
+      retvecType = GlobalTables::GetTypeTable().GetV8Int8();
+      break;
+    }
+    case PTY_v16u8: {
+      intrnID = INTRN_vector_get_low_v16u8;
+      retvecType = GlobalTables::GetTypeTable().GetV8UInt8();
+      break;
+    }
+    case PTY_v8i16: {
+      intrnID = INTRN_vector_get_low_v8i16;
+      retvecType = GlobalTables::GetTypeTable().GetV4Int16();
+      break;
+    }
+    case PTY_v8u16: {
+      intrnID = INTRN_vector_get_low_v8u16;
+      retvecType = GlobalTables::GetTypeTable().GetV4UInt16();
+      break;
+    }
+    case PTY_v4i32: {
+      intrnID = INTRN_vector_get_low_v4i32;
+      retvecType = GlobalTables::GetTypeTable().GetV2Int32();
+      break;
+    }
+    case PTY_v4u32: {
+      intrnID = INTRN_vector_get_low_v4u32;
+      retvecType = GlobalTables::GetTypeTable().GetV2UInt32();
+      break;
+    }
+    case PTY_v2i64: {
+      intrnID = INTRN_vector_get_low_v2i64;
+      retvecType = GlobalTables::GetTypeTable().GetInt64();
+      break;
+    }
+    case PTY_v2u64: {
+      intrnID = INTRN_vector_get_low_v2u64;
+      retvecType = GlobalTables::GetTypeTable().GetUInt64();
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported type in vector_get_low");
+    }
+  }
+  // generate instrinsic op
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, retvecType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(1);
+  rhs->GetNopnd().push_back(vecNode);
+  rhs->SetTyIdx(retvecType->GetTypeIndex());
+  return rhs;
+}
+
+// vector add long oper0 and oper1 have same types
+IntrinsicopNode *LoopVectorization::GenVectorAddw(BaseNode *oper0, BaseNode *oper1, PrimType op1Type, bool highPart) {
+  MIRIntrinsicID intrnID = INTRN_vector_addw_low_v8i8;
+  MIRType *resType = nullptr;
+  switch (op1Type) {
+    case PTY_v8i8: {
+      intrnID = highPart ? INTRN_vector_addw_high_v8i8 : INTRN_vector_addw_low_v8i8;
+      resType = GlobalTables::GetTypeTable().GetV8Int16();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = highPart ? INTRN_vector_addw_high_v8u8 : INTRN_vector_addw_low_v8u8;
+      resType = GlobalTables::GetTypeTable().GetV8UInt16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = highPart ? INTRN_vector_addw_high_v4i16 : INTRN_vector_addw_low_v4i16;
+      resType = GlobalTables::GetTypeTable().GetV4Int32();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = highPart ? INTRN_vector_addw_high_v4u16 : INTRN_vector_addw_low_v4u16;
+      resType = GlobalTables::GetTypeTable().GetV4UInt32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = highPart ? INTRN_vector_addw_high_v2i32 : INTRN_vector_addw_low_v2i32;
+      resType = GlobalTables::GetTypeTable().GetV2Int64();
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = highPart ? INTRN_vector_addw_high_v2u32 : INTRN_vector_addw_low_v2u32;
+      resType = GlobalTables::GetTypeTable().GetV2UInt64();
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported type in vector_addwh");
+    }
+  }
+  // generate instrinsic op
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, resType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(2);
+  rhs->GetNopnd().push_back(oper0);
+  rhs->GetNopnd().push_back(oper1);
+  rhs->SetTyIdx(resType->GetTypeIndex());
+  return rhs;
+}
+
+// Subtract Long
+IntrinsicopNode *LoopVectorization::GenVectorSubl(BaseNode *oper0, BaseNode *oper1, PrimType op1Type, bool highPart) {
+  MIRIntrinsicID intrnID = INTRN_vector_subl_low_v8i8;
+  MIRType *resType = nullptr;
+  switch (op1Type) {
+    case PTY_v8i8: {
+      intrnID = highPart ? INTRN_vector_subl_high_v8i8 : INTRN_vector_subl_low_v8i8;
+      resType = GlobalTables::GetTypeTable().GetV8Int16();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = highPart ? INTRN_vector_subl_high_v8u8 : INTRN_vector_subl_low_v8u8;
+      resType = GlobalTables::GetTypeTable().GetV8UInt16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = highPart ? INTRN_vector_subl_high_v4i16 : INTRN_vector_subl_low_v4i16;
+      resType = GlobalTables::GetTypeTable().GetV4Int32();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = highPart ? INTRN_vector_subl_high_v4u16 : INTRN_vector_subl_low_v4u16;
+      resType = GlobalTables::GetTypeTable().GetV4UInt32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = highPart ? INTRN_vector_subl_high_v2i32 : INTRN_vector_subl_low_v2i32;
+      resType = GlobalTables::GetTypeTable().GetV2Int64();
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = highPart ? INTRN_vector_subl_high_v2u32 : INTRN_vector_subl_low_v2u32;
+      resType = GlobalTables::GetTypeTable().GetV2UInt64();
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported type in vector_subl");
+    }
+  }
+  // generate instrinsic op
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, resType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(2);
+  rhs->GetNopnd().push_back(oper0);
+  rhs->GetNopnd().push_back(oper1);
+  rhs->SetTyIdx(resType->GetTypeIndex());
+  return rhs;
+}
+
+// Vector Add long
+IntrinsicopNode *LoopVectorization::GenVectorAddl(BaseNode *oper0,
+    BaseNode *oper1, PrimType op1Type, bool highPart) {
+  MIRIntrinsicID intrnID = INTRN_vector_addl_low_v8i8;
+  MIRType *resType = nullptr;
+  switch (op1Type) {
+    case PTY_v8i8: {
+      intrnID = highPart ? INTRN_vector_addl_high_v8i8 : INTRN_vector_addl_low_v8i8;
+      resType = GlobalTables::GetTypeTable().GetV8Int16();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = highPart ? INTRN_vector_addl_high_v8u8 : INTRN_vector_addl_low_v8u8;
+      resType = GlobalTables::GetTypeTable().GetV8UInt16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = highPart ? INTRN_vector_addl_high_v4i16 : INTRN_vector_addl_low_v4i16;
+      resType = GlobalTables::GetTypeTable().GetV4Int32();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = highPart ? INTRN_vector_addl_high_v4u16 : INTRN_vector_addl_low_v4u16;
+      resType = GlobalTables::GetTypeTable().GetV4UInt32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = highPart ? INTRN_vector_addl_high_v2i32 : INTRN_vector_addl_low_v2i32;
+      resType = GlobalTables::GetTypeTable().GetV2Int64();
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = highPart ? INTRN_vector_addl_high_v2u32 : INTRN_vector_addl_low_v2u32;
+      resType = GlobalTables::GetTypeTable().GetV2UInt64();
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported type in vector_addl");
+    }
+  }
+  // generate instrinsic op
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, resType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(2);
+  rhs->GetNopnd().push_back(oper0);
+  rhs->GetNopnd().push_back(oper1);
+  rhs->SetTyIdx(resType->GetTypeIndex());
+  return rhs;
+}
+
+IntrinsicopNode *LoopVectorization::GenVectorMull(BaseNode *oper0,
+    BaseNode *oper1, PrimType op1Type, bool highPart) {
+  MIRIntrinsicID intrnID = INTRN_vector_mull_low_v2i32;
+  MIRType *resType = nullptr;
+  switch (op1Type) {
+    case PTY_v8i8: {
+      intrnID = highPart ? INTRN_vector_mull_high_v8i8 : INTRN_vector_mull_low_v8i8;
+      resType = GlobalTables::GetTypeTable().GetV8Int16();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = highPart ? INTRN_vector_mull_high_v8u8 : INTRN_vector_mull_low_v8u8;
+      resType = GlobalTables::GetTypeTable().GetV8UInt16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = highPart ? INTRN_vector_mull_high_v4i16 : INTRN_vector_mull_low_v4i16;
+      resType = GlobalTables::GetTypeTable().GetV4Int32();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = highPart ? INTRN_vector_mull_high_v4u16 : INTRN_vector_mull_low_v4u16;
+      resType = GlobalTables::GetTypeTable().GetV4UInt32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = highPart ? INTRN_vector_mull_high_v2i32 : INTRN_vector_mull_low_v2i32;
+      resType = GlobalTables::GetTypeTable().GetV2Int64();
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = highPart ? INTRN_vector_mull_high_v2u32 : INTRN_vector_mull_low_v2u32;
+      resType = GlobalTables::GetTypeTable().GetV2UInt64();
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported type in vector_mull");
+    }
+  }
+  // generate instrinsic op
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, resType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(2);
+  rhs->GetNopnd().push_back(oper0);
+  rhs->GetNopnd().push_back(oper1);
+  rhs->SetTyIdx(resType->GetTypeIndex());
+  return rhs;
+}
+
+
+// return intrinsicID
+MIRIntrinsicID LoopVectorization::GenVectorAbsSublID(MIRIntrinsicID intrnID) const {
+  MIRIntrinsicID newIntrnID = INTRN_vector_labssub_low_v8i8;
+  switch (intrnID)  {
+    case INTRN_vector_subl_low_v8i8: {
+      newIntrnID = INTRN_vector_labssub_low_v8i8;
+      break;
+    }
+    case INTRN_vector_subl_high_v8i8: {
+      newIntrnID = INTRN_vector_labssub_high_v8i8;
+      break;
+    }
+    case INTRN_vector_subl_low_v8u8: {
+      newIntrnID = INTRN_vector_labssub_low_v8u8;
+      break;
+    }
+    case INTRN_vector_subl_high_v8u8: {
+      newIntrnID =  INTRN_vector_labssub_high_v8u8;
+      break;
+    }
+    case INTRN_vector_subl_low_v4i16: {
+      newIntrnID = INTRN_vector_labssub_low_v4i16;
+      break;
+    }
+    case INTRN_vector_subl_high_v4i16: {
+      newIntrnID = INTRN_vector_labssub_high_v4i16;
+      break;
+    }
+    case INTRN_vector_subl_low_v4u16: {
+      newIntrnID = INTRN_vector_labssub_low_v4u16;
+      break;
+    }
+    case INTRN_vector_subl_high_v4u16: {
+      newIntrnID = INTRN_vector_labssub_high_v4u16;
+      break;
+    }
+    case INTRN_vector_subl_low_v2i32: {
+      newIntrnID = INTRN_vector_labssub_low_v2i32;
+      break;
+    }
+    case INTRN_vector_subl_high_v2i32: {
+      newIntrnID = INTRN_vector_labssub_high_v2i32;
+      break;
+    }
+    case INTRN_vector_subl_low_v2u32: {
+      newIntrnID = INTRN_vector_labssub_low_v2u32;
+      break;
+    }
+    case INTRN_vector_subl_high_v2u32: {
+      newIntrnID = INTRN_vector_labssub_high_v2u32;
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported change to vector_labssub");
+    }
+  }
+  return newIntrnID;
+}
+
+// return widened vector by getting the abs value of subtracted arguments
+IntrinsicopNode *LoopVectorization::GenVectorAbsSubl(BaseNode *oper0,
+    BaseNode *oper1, PrimType op1Type, bool highPart) {
+  MIRIntrinsicID intrnID = INTRN_vector_labssub_low_v8i8;
+  MIRType *resType = nullptr;
+  switch (op1Type) {
+    case PTY_v8i8: {
+      intrnID = highPart ? INTRN_vector_labssub_high_v8i8 : INTRN_vector_labssub_low_v8i8;
+      resType = GlobalTables::GetTypeTable().GetV8Int16();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = highPart ? INTRN_vector_labssub_high_v8u8 : INTRN_vector_labssub_low_v8u8;
+      resType = GlobalTables::GetTypeTable().GetV8UInt16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = highPart ? INTRN_vector_labssub_high_v4i16 : INTRN_vector_labssub_low_v4i16;
+      resType = GlobalTables::GetTypeTable().GetV4Int32();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = highPart ? INTRN_vector_labssub_high_v4u16 : INTRN_vector_labssub_low_v4u16;
+      resType = GlobalTables::GetTypeTable().GetV4UInt32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = highPart ? INTRN_vector_labssub_high_v2i32 : INTRN_vector_labssub_low_v2i32;
+      resType = GlobalTables::GetTypeTable().GetV2Int64();
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = highPart ? INTRN_vector_labssub_high_v2u32 : INTRN_vector_labssub_low_v2u32;
+      resType = GlobalTables::GetTypeTable().GetV2UInt64();
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported type in vector_labssub");
+    }
+  }
+  // generate instrinsic op
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, resType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(2);
+  rhs->GetNopnd().push_back(oper0);
+  rhs->GetNopnd().push_back(oper1);
+  rhs->SetTyIdx(resType->GetTypeIndex());
+  return rhs;
+}
+
+IntrinsicopNode *LoopVectorization::GenVectorWidenOpnd(BaseNode *opnd, PrimType vecPrimType, bool highPart) {
+  MIRIntrinsicID intrnID = INTRN_vector_widen_low_v8i8;
+  MIRType *resType = nullptr;
+  switch (vecPrimType) {
+    case PTY_v8i8: {
+      intrnID = highPart ? INTRN_vector_widen_high_v8i8 : INTRN_vector_widen_low_v8i8;
+      resType = GlobalTables::GetTypeTable().GetV8Int16();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = highPart ? INTRN_vector_widen_high_v8u8 : INTRN_vector_widen_low_v8u8;
+      resType = GlobalTables::GetTypeTable().GetV8UInt16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = highPart ? INTRN_vector_widen_high_v4i16 : INTRN_vector_widen_low_v4i16;
+      resType = GlobalTables::GetTypeTable().GetV4Int32();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = highPart ? INTRN_vector_widen_high_v4u16 : INTRN_vector_widen_low_v4u16;
+      resType = GlobalTables::GetTypeTable().GetV4UInt32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = highPart ? INTRN_vector_widen_high_v2i32 : INTRN_vector_widen_low_v2i32;
+      resType = GlobalTables::GetTypeTable().GetV2Int64(); // kArgTyV2I64
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = highPart ? INTRN_vector_widen_high_v2u32 : INTRN_vector_widen_low_v2u32;
+      resType = GlobalTables::GetTypeTable().GetV2UInt64();
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported type in vector_widen");
+    }
+  }
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, resType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(1);
+  rhs->GetNopnd().push_back(opnd);
+  rhs->SetTyIdx(resType->GetTypeIndex());
+  return rhs;
+}
+
+IntrinsicopNode *LoopVectorization::GenVectorPairWiseAccumulate(BaseNode *oper0,
+    BaseNode *oper1, PrimType oper1Type) {
+  MIRIntrinsicID intrnID = INTRN_vector_pairwise_adalp_v8i8;
+  MIRType *resType = nullptr;
+  switch (oper1Type) {
+    case PTY_v8i8: {
+      intrnID = INTRN_vector_pairwise_adalp_v8i8;
+      resType = GlobalTables::GetTypeTable().GetV4Int16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = INTRN_vector_pairwise_adalp_v4i16;
+      resType = GlobalTables::GetTypeTable().GetV2Int32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = INTRN_vector_pairwise_adalp_v2i32;
+      resType = GlobalTables::GetTypeTable().GetInt64();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = INTRN_vector_pairwise_adalp_v8u8;
+      resType = GlobalTables::GetTypeTable().GetV4UInt16();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = INTRN_vector_pairwise_adalp_v4u16;
+      resType = GlobalTables::GetTypeTable().GetV2UInt32();
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = INTRN_vector_pairwise_adalp_v2u32;
+      resType = GlobalTables::GetTypeTable().GetUInt64();
+      break;
+    }
+    case PTY_v16i8: {
+      intrnID = INTRN_vector_pairwise_adalp_v16i8;
+      resType = GlobalTables::GetTypeTable().GetV8Int16();
+      break;
+    }
+    case PTY_v8i16: {
+      intrnID = INTRN_vector_pairwise_adalp_v8i16;
+      resType = GlobalTables::GetTypeTable().GetV4Int32();
+      break;
+    }
+    case PTY_v4i32: {
+      intrnID = INTRN_vector_pairwise_adalp_v4i32;
+      resType = GlobalTables::GetTypeTable().GetV2Int64();
+      break;
+    }
+    case PTY_v16u8: {
+      intrnID = INTRN_vector_pairwise_adalp_v16u8;
+      resType = GlobalTables::GetTypeTable().GetV8UInt16();
+      break;
+    }
+    case PTY_v8u16: {
+      intrnID = INTRN_vector_pairwise_adalp_v8u16;
+      resType = GlobalTables::GetTypeTable().GetV4UInt32();
+      break;
+    }
+    case PTY_v4u32: {
+      intrnID = INTRN_vector_pairwise_adalp_v4u32;
+      resType = GlobalTables::GetTypeTable().GetV2UInt64();
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported type in vector_widen");
+    }
+  }
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, resType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(2);
+  rhs->GetNopnd().push_back(oper0);
+  rhs->GetNopnd().push_back(oper1);
+  rhs->SetTyIdx(resType->GetTypeIndex());
+  return rhs;
+}
+
+// vaddl,opnd0 and opnd1 are same type, target type are widen
+IntrinsicopNode *LoopVectorization::GenVectorWidenIntrn(BaseNode *oper0,
+    BaseNode *oper1, PrimType opndType, bool highPart, Opcode op) {
+  if (op == OP_add) {
+    return GenVectorAddl(oper0, oper1, opndType, highPart);
+  } else if (op == OP_sub) {
+    return GenVectorSubl(oper0, oper1, opndType, highPart);
+  } else if (op == OP_mul) {
+    return GenVectorMull(oper0, oper1, opndType, highPart);
+  }
+  ASSERT(0, "GenWidenIntrn : only support add and sub opcode"); // should not be here
+  return nullptr;
+}
+
+bool LoopVectorization::CanWidenOpcode(const BaseNode *target, PrimType opndType) const {
+  if ((target->GetPrimType() == opndType) ||
+      (GetPrimTypeSize(target->GetPrimType()) < GetPrimTypeSize(opndType))) {
+        return false;
+  }
+  Opcode op = target->GetOpCode();
+  // we have add/sub widen intrinsic now
+  if (op == OP_sub || op == OP_add || op == OP_mul) {
+    return true;
+  }
+  // no other widen intrins supported now
+  return false;
+}
+
+// generate addl/subl intrinsic
+void LoopVectorization::GenWidenBinaryExpr(Opcode binOp,
+                                           MapleVector<BaseNode *>& opnd0Vec,
+                                           MapleVector<BaseNode *>& opnd1Vec,
+                                           MapleVector<BaseNode *>& vectorizedNode) {
+  auto op1veclen = opnd0Vec.size();
+  auto op2veclen = opnd1Vec.size();
+  auto lenMin = op1veclen < op2veclen ? op1veclen : op2veclen;
+  for (size_t i = 0; i < lenMin; i++) {
+    BaseNode *opnd0 = opnd0Vec[i];
+    BaseNode *opnd1 = opnd1Vec[i];
+    PrimType opnd0PrimType = opnd0->GetPrimType();
+    PrimType opnd1PrimType = opnd1->GetPrimType();
+    // widen type need high/low part
+    if ((GetPrimTypeSize(opnd0PrimType) * 8) == maxVecSize) {
+      IntrinsicopNode *getLowop0Intrn = GenVectorGetLow(opnd0, opnd0PrimType);
+      IntrinsicopNode *getLowop1Intrn = GenVectorGetLow(opnd1, opnd1PrimType);
+      IntrinsicopNode *widenOpLow = GenVectorWidenIntrn(getLowop0Intrn, getLowop1Intrn, getLowop0Intrn->GetPrimType(),
+          false, binOp);
+      IntrinsicopNode *widenOpHigh = GenVectorWidenIntrn(opnd0, opnd1, getLowop0Intrn->GetPrimType(), true, binOp);
+      vectorizedNode.push_back(widenOpLow);
+      vectorizedNode.push_back(widenOpHigh);
+    } else {
+      IntrinsicopNode *widenOp = GenVectorWidenIntrn(opnd0, opnd1, opnd0PrimType, false, binOp);
+      vectorizedNode.push_back(widenOp);
+    }
+  }
+}
+
+// insert retype/cvt if sign/unsign
+BaseNode *LoopVectorization::ConvertNodeType(bool cvtSigned, BaseNode *n) {
+  MIRType *opcodetype = nullptr;
+  MIRType *nodetype = GenVecType(GetVecElemPrimType(n->GetPrimType()),
+                                 static_cast<uint8>(GetVecLanes(n->GetPrimType())));
+  if (cvtSigned) {
+    opcodetype = GenVecType(GetSignedPrimType(GetVecElemPrimType(n->GetPrimType())),
+                            static_cast<uint8>(GetVecLanes(n->GetPrimType())));
+  } else {
+    opcodetype = GenVecType(GetUnsignedPrimType(GetVecElemPrimType(n->GetPrimType())),
+                            static_cast<uint8>(GetVecLanes(n->GetPrimType())));
+  }
+  BaseNode *newnode = nullptr;
+  if (GetPrimTypeSize(n->GetPrimType()) == GetPrimTypeSize(opcodetype->GetPrimType())) {
+    newnode = codeMP->New<RetypeNode>(opcodetype->GetPrimType(), n->GetPrimType(), nodetype->GetTypeIndex(), n);
+  } else {
+    newnode = codeMP->New<TypeCvtNode>(OP_cvt, opcodetype->GetPrimType(), n->GetPrimType(), n);
+  }
+  return newnode;
+}
+
+IntrinsicopNode *LoopVectorization::GenVectorNarrowLowNode(BaseNode *opnd, PrimType opndPrimType) {
+  MIRIntrinsicID intrnID = INTRN_vector_narrow_low_v2i64;
+  MIRType *resType = nullptr;
+  switch (opndPrimType) {
+    case PTY_v2i64: {
+      intrnID = INTRN_vector_narrow_low_v2i64;
+      resType = GlobalTables::GetTypeTable().GetV2Int32();
+      break;
+    }
+    case PTY_v4i32: {
+      intrnID = INTRN_vector_narrow_low_v4i32;
+      resType = GlobalTables::GetTypeTable().GetV4Int16();
+      break;
+    }
+    case PTY_v8i16: {
+      intrnID = INTRN_vector_narrow_low_v8i16;
+      resType = GlobalTables::GetTypeTable().GetV8Int8();
+      break;
+    }
+    case PTY_v2u64: {
+      intrnID = INTRN_vector_narrow_low_v2u64;
+      resType = GlobalTables::GetTypeTable().GetV2UInt32();
+      break;
+    }
+    case PTY_v4u32: {
+      intrnID = INTRN_vector_narrow_low_v4u32;
+      resType = GlobalTables::GetTypeTable().GetV4UInt16();
+      break;
+    }
+    case PTY_v8u16: {
+      intrnID = INTRN_vector_narrow_low_v8u16;
+      resType = GlobalTables::GetTypeTable().GetV8UInt8();
+      break;
+    }
+    default: {
+      CHECK_FATAL(0, "unsupported type in vector_narrowlow");
+    }
+  }
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, resType->GetPrimType());
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(1);
+  rhs->GetNopnd().push_back(opnd);
+  rhs->SetTyIdx(resType->GetTypeIndex());
+  return rhs;
+}
+
+// create vectorized preg for reduction var and its init stmt vpreg = dup_scalar(0)
+RegreadNode *LoopVectorization::GenVectorReductionVar(StmtNode *stmt, LoopTransPlan *tp) {
+  PrimType lhsType;
+  uint8 lhsLanes = tp->vecFactor;
+  if (stmt->GetOpCode() == OP_dassign) {
+    StIdx redStIdx = (static_cast<DassignNode *>(stmt))->GetStIdx();
+    MIRSymbol *lhsSym = mirFunc->GetLocalOrGlobalSymbol(redStIdx);
+    lhsType = GetTypeFromTyIdx(lhsSym->GetTyIdx()).GetPrimType();
+    uint32_t lhstypesize = GetPrimTypeSize(lhsType) * 8;
+    uint32_t lhsMaxLanes = ((maxVecSize / lhstypesize) < tp->vecFactor) ?
+                            (maxVecSize / lhstypesize) : tp->vecFactor;
+    lhsLanes = lhsMaxLanes;
+  } else {
+    IassignNode *iassign = static_cast<IassignNode *>(stmt);
+    MIRType &mirType = GetTypeFromTyIdx(iassign->GetTyIdx());
+    lhsType = (static_cast<MIRPtrType*>(&mirType))->GetPointedType()->GetPrimType();
+  }
+  MIRType *lhsvecType = GenVecType(lhsType, static_cast<uint8>(lhsLanes));
+  PregIdx reglhsvec = mirFunc->GetPregTab()->CreatePreg(lhsvecType->GetPrimType());
+  BaseNode *constZero = const0Node;
+  if (GetPrimTypeSize(const0Node->GetPrimType()) != GetPrimTypeSize(lhsType)) {
+    constZero = const0Node->CloneTree(*codeMPAlloc);
+    constZero->SetPrimType(lhsType);
+  }
+  IntrinsicopNode *lhsvecIntrn = GenDupScalarExpr(constZero, lhsvecType->GetPrimType());
+  RegassignNode *initlhsvec = codeMP->New<RegassignNode>(lhsvecType->GetPrimType(), reglhsvec, lhsvecIntrn);
+  tp->vecInfo->beforeLoopStmts.push_back(initlhsvec);
+  RegreadNode *regReadlhsvec = codeMP->New<RegreadNode>(lhsvecType->GetPrimType(), reglhsvec);
+  tp->vecInfo->redVecNodes[stmt] = regReadlhsvec;
+  return regReadlhsvec;
+}
+
+// check vectorized preg is generated for current stmt
+RegreadNode *LoopVectorization::GetorNewVectorReductionVar(StmtNode *stmt, LoopTransPlan *tp) {
+  RegreadNode *regReadlhsvec;
+  if (tp->vecInfo->redVecNodes.find(stmt) != tp->vecInfo->redVecNodes.end()) {
+    regReadlhsvec = static_cast<RegreadNode *>(tp->vecInfo->redVecNodes[stmt]);
+  } else {
+    regReadlhsvec = GenVectorReductionVar(stmt, tp);
+  }
+  return regReadlhsvec;
+}
+
+static bool IsCompareNode(Opcode op) {
+  if (op == OP_eq || op == OP_ge || op == OP_gt || op == OP_le || op == OP_lt ||
+      op == OP_ne || op == OP_cmp || op == OP_cmpl || op == OP_cmpg) {
+    return true;
+  }
+  return false;
+}
+
+void LoopVectorization::VectorizeExpr(BaseNode *node, LoopTransPlan *tp, MapleVector<BaseNode *>& vectorizedNode,
+    uint32_t depth) {
+  switch (node->GetOpCode()) {
+    case OP_iread: {
+      IreadNode *ireadnode = static_cast<IreadNode *>(node);
+      // update tyidx
+      MIRType *mirType = ireadnode->GetType();
+      MIRType *vecType = nullptr;
+      // update lhs type
+      if (mirType->GetPrimType() == PTY_agg) {
+        // iread variable from a struct, use iread type
+        vecType = GenVecType(ireadnode->GetPrimType(), tp->vecFactor);
+        ASSERT(vecType != nullptr, "vector type should not be null");
+      } else {
+        vecType = GenVecType(mirType->GetPrimType(), tp->vecFactor);
+        ASSERT(vecType != nullptr, "vector type should not be null");
+        MIRType *pvecType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*vecType, PTY_ptr);
+        ireadnode->SetTyIdx(pvecType->GetTypeIndex());
+      }
+      PrimType optype = node->GetPrimType();
+      node->SetPrimType(vecType->GetPrimType());
+      if ((depth == 0) &&
+          (tp->vecInfo->currentLHSTypeSize > GetPrimTypeSize(GetVecElemPrimType(vecType->GetPrimType()))) &&
+          ((GetPrimTypeSize(optype) / GetPrimTypeSize(GetVecElemPrimType(vecType->GetPrimType()))) > 2)) {
+        // widen 128 bit node type : split two nodes
+        if (GetPrimTypeSize(vecType->GetPrimType()) == maplebe::k16BitSize) {
+          IntrinsicopNode *getLowIntrn = GenVectorGetLow(node, vecType->GetPrimType());
+          IntrinsicopNode *lowNode = GenVectorWidenOpnd(getLowIntrn, getLowIntrn->GetPrimType(), false);
+          IntrinsicopNode *highNode = GenVectorWidenOpnd(node, getLowIntrn->GetPrimType(), true);
+          vectorizedNode.push_back(lowNode);
+          vectorizedNode.push_back(highNode);
+        } else {
+          // widen element type
+          IntrinsicopNode *widenop = GenVectorWidenOpnd(node, vecType->GetPrimType(), false);
+          vectorizedNode.push_back(widenop);
+        }
+      } else {
+        vectorizedNode.push_back(node);
+      }
+      if ((IsSignedInteger(optype) && IsUnsignedInteger(vecType->GetPrimType())) ||
+          (IsUnsignedInteger(optype) && IsSignedInteger(vecType->GetPrimType()))) {
+        for (size_t i = 0; i < vectorizedNode.size(); i++) {
+          vectorizedNode[i] = ConvertNodeType(IsSignedInteger(optype), vectorizedNode[i]);
+        }
+      }
+      break;
+    }
+    // vector type support in opcode  +, -, *, &, |, <<, >>, compares, ~, !
+    case OP_add:
+    case OP_sub:
+    case OP_mul:
+    case OP_band:
+    case OP_bior:
+    case OP_shl:
+    case OP_lshr:
+    case OP_ashr:
+    case OP_bxor:
+    // compare
+    case OP_eq:
+    case OP_ne:
+    case OP_lt:
+    case OP_gt:
+    case OP_le:
+    case OP_ge:
+    case OP_cmpg:
+    case OP_cmpl: {
+      ASSERT(node->IsBinaryNode(), "should be binarynode");
+      BinaryNode *binNode = static_cast<BinaryNode *>(node);
+      MapleVector<BaseNode *> vecopnd1(localAlloc.Adapter());
+      MapleVector<BaseNode *> vecopnd2(localAlloc.Adapter());
+      BaseNode *opnd1 = binNode->Opnd(0);
+      BaseNode *opnd2 = binNode->Opnd(1);
+      if (tp->vecInfo->uniformVecNodes.find(opnd1) != tp->vecInfo->uniformVecNodes.end()) {
+        BaseNode *newnode = tp->vecInfo->uniformVecNodes[opnd1];
+        vecopnd1.push_back(newnode);
+      } else {
+        VectorizeExpr(opnd1, tp, vecopnd1, depth + 1);
+      }
+      if (tp->vecInfo->uniformVecNodes.find(opnd2) != tp->vecInfo->uniformVecNodes.end()) {
+        BaseNode *newnode = tp->vecInfo->uniformVecNodes[opnd2];
+        vecopnd2.push_back(newnode);
+      } else {
+        VectorizeExpr(opnd2, tp, vecopnd2, depth + 1);
+      }
+      CHECK_FATAL(((!vecopnd1.empty()) && !vecopnd2.empty()), "check binary op vectrized node");
+      PrimType opnd1PrimType = vecopnd1[0]->GetPrimType();
+      PrimType opnd2PrimType = vecopnd2[0]->GetPrimType();
+      // widen instruction (addl/subl) need two operands with same vectype
+      if ((GetVecElemPrimType(opnd1PrimType) != PTY_begin) &&
+          (GetVecElemPrimType(opnd2PrimType) != PTY_begin) &&
+          (opnd1PrimType == opnd2PrimType) &&
+          (tp->vecInfo->currentLHSTypeSize > GetPrimTypeSize(GetVecElemPrimType(opnd1PrimType))) &&
+          CanWidenOpcode(node, GetVecElemPrimType(opnd1PrimType))) {
+        GenWidenBinaryExpr(binNode->GetOpCode(), vecopnd1, vecopnd2, vectorizedNode);
+      } else if ((GetVecElemPrimType(opnd2PrimType) != PTY_begin) &&
+                 (GetPrimTypeSize(GetVecElemPrimType(opnd2PrimType)) >
+                 GetPrimTypeSize(GetVecElemPrimType(opnd1PrimType)))) {
+        // opnd2 is uniform scalar and type is different from opnd1
+        // widen opnd1 with same element type as opnd2
+        BaseNode *newopnd1 = vecopnd1[0];
+        int opnd2ElemPrimTypeSize = GetPrimTypeSize(GetVecElemPrimType(opnd2PrimType));
+        while (GetPrimTypeSize(GetVecElemPrimType(opnd1PrimType)) < opnd2ElemPrimTypeSize) {
+          newopnd1 = GenVectorWidenOpnd(newopnd1, opnd1PrimType, false);
+          opnd1PrimType = newopnd1->GetPrimType();
+        }
+        binNode->SetOpnd(newopnd1, 0);
+        binNode->SetOpnd(vecopnd2[0], 1);
+        binNode->SetPrimType(newopnd1->GetPrimType());
+        if (IsCompareNode(binNode->GetOpCode())) {
+          static_cast<CompareNode *>(binNode)->SetOpndType(binNode->GetPrimType());
+        }
+        vectorizedNode.push_back(binNode);
+      } else {
+        auto lenMax = vecopnd1.size() >= vecopnd2.size() ? vecopnd1.size() : vecopnd2.size();
+        for (size_t i = 0; i < lenMax; i++) {
+          BinaryNode *newbin = binNode->CloneTree(*codeMPAlloc);
+          BaseNode *vecn1 = i < vecopnd1.size() ? vecopnd1[i] : vecopnd1[0];
+          BaseNode *vecn2 = i < vecopnd2.size() ? vecopnd2[i] : vecopnd2[0];
+          newbin->SetOpnd(vecn1, 0);
+          newbin->SetOpnd(vecn2, 1);
+          if (GetVecLanes(vecn1->GetPrimType()) > 0) {
+            newbin->SetPrimType(vecn1->GetPrimType()); // update primtype of binary op with opnd's type
+          } else {
+            CHECK_FATAL(GetVecLanes(vecn2->GetPrimType()) > 0, "opnd2 should be vectype since opnd1 is scalar");
+            newbin->SetPrimType(vecn2->GetPrimType()); // update primtype of binary op with opnd's type
+          }
+          // update opndtype
+          if (IsCompareNode(newbin->GetOpCode())) {
+            static_cast<CompareNode *>(newbin)->SetOpndType(newbin->GetPrimType());
+          }
+          if (tp->vecInfo->currentLHSTypeSize / GetPrimTypeSize(GetVecElemPrimType(newbin->GetPrimType())) > 2) {
+            if (GetPrimTypeSize(newbin->GetPrimType()) == maplebe::k16BitSize) {
+              // widen vectorized node to low and high part if newbin is already 128-bit
+              IntrinsicopNode *getLowIntrn = GenVectorGetLow(newbin, newbin->GetPrimType());
+              IntrinsicopNode *lowNode = GenVectorWidenOpnd(getLowIntrn, getLowIntrn->GetPrimType(), false);
+              IntrinsicopNode *highNode = GenVectorWidenOpnd(newbin, getLowIntrn->GetPrimType(), true);
+              vectorizedNode.push_back(lowNode);
+              vectorizedNode.push_back(highNode);
+            } else {
+              // widen element type
+              IntrinsicopNode *widenop = GenVectorWidenOpnd(newbin, newbin->GetPrimType(), false);
+              vectorizedNode.push_back(widenop);
+            }
+          } else {
+            vectorizedNode.push_back(newbin);
+          }
+        }
+      }
+      break;
+    }
+    // unary op
+    case OP_abs:
+    case OP_neg:
+    case OP_bnot:
+    case OP_lnot: {
+      ASSERT(node->IsUnaryNode(), "should be unarynode");
+      UnaryNode *unaryNode = static_cast<UnaryNode *>(node);
+      MapleVector<BaseNode *> vecOpnd(localAlloc.Adapter());
+      if (tp->vecInfo->uniformVecNodes.find(unaryNode->Opnd(0)) != tp->vecInfo->uniformVecNodes.end()) {
+        BaseNode *newnode = tp->vecInfo->uniformVecNodes[unaryNode->Opnd(0)];
+        unaryNode->SetOpnd(newnode, 0);
+        node->SetPrimType(unaryNode->Opnd(0)->GetPrimType()); // update primtype of unary op with opnd's type
+        vectorizedNode.push_back(node);
+      } else {
+        VectorizeExpr(unaryNode->Opnd(0), tp, vecOpnd, depth + 1);
+        CHECK_FATAL(vecOpnd.size() >= 1, "vectorized node should be larger than 1");
+        // use abssub to replace subl
+        if ((node->GetOpCode() == OP_abs) && (vecOpnd[0]->GetOpCode() == OP_intrinsicop) &&
+            ((static_cast<IntrinsicopNode *>(vecOpnd[0]))->GetIntrinsic() >= INTRN_vector_subl_low_v8i8 &&
+             (static_cast<IntrinsicopNode *>(vecOpnd[0]))->GetIntrinsic() <= INTRN_vector_subl_high_v2u32)) {
+          for (size_t i = 0; i < vecOpnd.size(); i++) {
+            IntrinsicopNode *opnd0 = static_cast<IntrinsicopNode *>(vecOpnd[i]);
+            PrimType opndPrimType = opnd0->GetPrimType();
+            opnd0->SetIntrinsic(GenVectorAbsSublID(opnd0->GetIntrinsic()));
+            BaseNode *newopnd = opnd0;
+            if ((IsSignedInteger(node->GetPrimType()) && IsUnsignedInteger(opndPrimType)) ||
+                (IsUnsignedInteger(node->GetPrimType()) && IsSignedInteger(opndPrimType))) {
+              newopnd = ConvertNodeType(IsSignedInteger(node->GetPrimType()), opnd0);
+            }
+            vectorizedNode.push_back(newopnd);
+          }
+        } else {
+          for (size_t i = 0; i < vecOpnd.size(); i++) {
+            UnaryNode *cloneunaryNode = unaryNode->CloneTree(*codeMPAlloc);
+            BaseNode *opnd0 = vecOpnd[i];
+            PrimType opndPrimType = opnd0->GetPrimType();
+            cloneunaryNode->SetOpnd(opnd0, 0);
+            // insert cvt to change to sign or unsign
+            if ((IsSignedInteger(node->GetPrimType()) && IsUnsignedInteger(opndPrimType)) ||
+                (IsUnsignedInteger(node->GetPrimType()) && IsSignedInteger(opndPrimType))) {
+              BaseNode *newnode = ConvertNodeType(IsSignedInteger(node->GetPrimType()), opnd0);
+              cloneunaryNode->SetOpnd(newnode, 0);
+            }
+            cloneunaryNode->SetPrimType(cloneunaryNode->Opnd(0)->GetPrimType());
+            vectorizedNode.push_back(cloneunaryNode);
+          }
+        }
+      }
+      break;
+    }
+    case OP_dread:
+    case OP_constval: {
+      if (tp->vecInfo->ivNodes.find(node) != tp->vecInfo->ivNodes.end()) {
+        BaseNode *vecnode = tp->vecInfo->ivVecNodes[node];
+        vectorizedNode.push_back(vecnode);
+      } else {
+        // donothing
+        vectorizedNode.push_back(node);
+      }
+      break;
+    }
+    case OP_select: {
+      TernaryNode *tnode = static_cast<TernaryNode *>(node);
+      if (tp->vecInfo->uniformVecNodes.find(node) != tp->vecInfo->uniformVecNodes.end()) {
+        BaseNode *vecNode = tp->vecInfo->uniformVecNodes[node];
+        vectorizedNode.push_back(vecNode);
+      } else {
+        MapleVector<BaseNode *> vecopnd(localAlloc.Adapter());
+        const uint8 tnodeSize = 3;
+        for (int i = 0; i < tnodeSize; i++) {
+          BaseNode *opnd = tnode->Opnd(i);
+          if (tp->vecInfo->uniformVecNodes.find(opnd) != tp->vecInfo->uniformVecNodes.end()) {
+            vecopnd.push_back(tp->vecInfo->uniformVecNodes[opnd]);
+          } else {
+            VectorizeExpr(opnd, tp, vecopnd, depth + 1);
+          }
+          ASSERT(vecopnd.size() == 1, "NYI::select opnd need expand");
+          tnode->SetOpnd(vecopnd[0], i);
+          vecopnd.clear();
+        }
+        // update node type
+        PrimType vecType = node->Opnd(1)->GetPrimType();
+        node->SetPrimType(vecType);
+        vectorizedNode.push_back(node);
+      }
+      break;
+    }
+    default:
+      ASSERT(0, "can't be vectorized");
+  }
+  return;
+}
+
+// set lhs type to vector type and return lhs pointto type
+MIRType *LoopVectorization::VectorizeIassignLhs(IassignNode *iassign, LoopTransPlan *tp) {
+  MIRType &mirType = GetTypeFromTyIdx(iassign->GetTyIdx());
+  CHECK_FATAL(mirType.GetKind() == kTypePointer, "iassign must have pointer type");
+  MIRPtrType *ptrType = static_cast<MIRPtrType*>(&mirType);
+  MIRType *lhsvecType = GenVecType(ptrType->GetPointedType()->GetPrimType(), tp->vecFactor);
+  ASSERT(lhsvecType != nullptr, "vector type should not be null");
+  tp->vecInfo->currentLHSTypeSize = GetPrimTypeSize(GetVecElemPrimType(lhsvecType->GetPrimType()));
+  MIRType *pvecType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*lhsvecType, PTY_ptr);
+  iassign->SetTyIdx(pvecType->GetTypeIndex());
+  return lhsvecType;
+}
+
+void LoopVectorization::VectorizeReductionStmt(StmtNode *stmt, LoopTransPlan *tp) {
+  MapleVector<BaseNode *> vecOpnd(localAlloc.Adapter());
+  PreMeMIRExtension *lfopart = (*PreMeStmtExtensionMap)[stmt->GetStmtID()];
+  BlockNode *doloopbody = static_cast<BlockNode *>(lfopart->GetParent());
+  RegreadNode *regReadlhsvec = GetorNewVectorReductionVar(stmt, tp);
+  tp->vecInfo->currentLHSTypeSize = GetPrimTypeSize(GetVecElemPrimType(regReadlhsvec->GetPrimType()));
+  // skip vectorizing uniform node
+  // rhsvecNode : vectorizable_expr
+  BaseNode *rhsvecNode = stmt->GetRHS()->Opnd(1);
+  if (tp->vecInfo->uniformNodes.find(rhsvecNode) == tp->vecInfo->uniformNodes.end()) {
+    VectorizeExpr(rhsvecNode, tp, vecOpnd, 0);
+  } else {
+    // rhs is uniform
+    vecOpnd.push_back(rhsvecNode);
+  }
+  // use widen intrinsic
+  if ((GetPrimTypeSize(GetVecElemPrimType(regReadlhsvec->GetPrimType())) * 8 * tp->vecFactor) >
+      maxVecSize) {
+    BaseNode *currVecNode = nullptr;
+    PrimType currVecType;
+    for (size_t i = 0; i < vecOpnd.size(); i++) {
+      currVecNode = vecOpnd[i];
+      currVecType = currVecNode->GetPrimType();
+      // need widen
+      if (GetPrimTypeSize(GetVecElemPrimType(regReadlhsvec->GetPrimType())) >
+          GetPrimTypeSize(GetVecElemPrimType(currVecType))) {
+        ASSERT(((GetVecEleSize(regReadlhsvec->GetPrimType())) / GetVecEleSize(currVecType) == 2) &&
+               (GetVecLanes(regReadlhsvec->GetPrimType()) * 2 == GetVecLanes(currVecType)), "type check");
+        IntrinsicopNode *pairwiseWidenAddIntrn = GenVectorPairWiseAccumulate(regReadlhsvec, currVecNode, currVecType);
+        RegassignNode *regassign3 =
+            codeMP->New<RegassignNode>(regReadlhsvec->GetPrimType(), regReadlhsvec->GetRegIdx(), pairwiseWidenAddIntrn);
+        doloopbody->InsertBefore(stmt, regassign3);
+      } else {
+        BinaryNode *binaryNode =
+            codeMP->New<BinaryNode>(OP_add, regReadlhsvec->GetPrimType(), regReadlhsvec, currVecNode);
+        RegassignNode *regassign =
+            codeMP->New<RegassignNode>(regReadlhsvec->GetPrimType(), regReadlhsvec->GetRegIdx(), binaryNode);
+        doloopbody->InsertBefore(stmt, regassign);
+      }
+    }
+  } else {
+    BinaryNode *binaryNode =
+        codeMP->New<BinaryNode>(OP_add, regReadlhsvec->GetPrimType(), regReadlhsvec, vecOpnd[0]);
+    RegassignNode *regassign1 =
+        codeMP->New<RegassignNode>(regReadlhsvec->GetPrimType(), regReadlhsvec->GetRegIdx(), binaryNode);
+    doloopbody->InsertBefore(stmt, regassign1);
+  }
+  // red = red +/- sum_vec(redvec)
+  StmtNode *copyStmt = stmt->CloneTree(*codeMPAlloc);
+  IntrinsicopNode *intrnvecSum = GenSumVecStmt(regReadlhsvec, regReadlhsvec->GetPrimType());
+  copyStmt->GetRHS()->SetOpnd(intrnvecSum, 1);
+  tp->vecInfo->afterLoopStmts.push_back(copyStmt);
+  doloopbody->RemoveStmt(stmt);
+}
+
+// iterate tree node to vectorize scalar type to vector type
+// following opcode can be vectorized directly
+//  +, -, *, &, |, <<, >>, compares, ~, !
+// iassign, iread, dassign, dread
+void LoopVectorization::VectorizeStmt(BaseNode *node, LoopTransPlan *tp) {
+  if (enableDebug) {
+    node->Dump(0);
+  }
+  switch (node->GetOpCode()) {
+    case OP_iassign: {
+      IassignNode *iassign = static_cast<IassignNode *>(node);
+      // node is reduction stmt
+      if (tp->vecInfo->reductionStmts.find(iassign) != tp->vecInfo->reductionStmts.end()) {
+        VectorizeReductionStmt(static_cast<StmtNode *>(node), tp);
+      } else {
+        MIRType *lhsptvecType = VectorizeIassignLhs(iassign, tp);
+        BaseNode *rhs = iassign->GetRHS();
+        BaseNode *newrhs;
+        if (tp->vecInfo->uniformVecNodes.find(rhs) != tp->vecInfo->uniformVecNodes.end()) {
+          // rhs replaced scalar node with vector node
+          newrhs = tp->vecInfo->uniformVecNodes[rhs];
+          if (GetPrimTypeSize(GetVecElemPrimType(newrhs->GetPrimType())) < tp->vecInfo->currentLHSTypeSize) {
+            newrhs = GenVectorWidenOpnd(newrhs, newrhs->GetPrimType(), false);
+          }
+        } else {
+          MapleVector<BaseNode *> vecRhs(localAlloc.Adapter());
+          VectorizeExpr(rhs, tp, vecRhs, 0);
+          ASSERT(vecRhs.size() == 1, "iassign doesn't handle complex type cvt now");
+          // insert CVT if lsh type is not same as rhs type
+          newrhs = vecRhs[0];
+        }
+        // if need cvt for sign/unsign
+        if ((IsSignedInteger(lhsptvecType->GetPrimType()) && IsUnsignedInteger(newrhs->GetPrimType())) ||
+            (IsUnsignedInteger(lhsptvecType->GetPrimType()) && IsUnsignedInteger(newrhs->GetPrimType()))) {
+          newrhs = ConvertNodeType(IsSignedInteger(lhsptvecType->GetPrimType()), newrhs);
+        }
+        iassign->SetRHS(newrhs);
+      }
+      break;
+    }
+    // scalar related: widen type directly or unroll instructions
+    case OP_dassign: {
+      // handle reduction stmt
+      // sum = sum +/- vectorizable_expr
+      // =>
+      // Example: vec t1 = dup_scalar(0);
+      // Example: doloop {
+      // Example:   t1 = t1 + vectorized_node;
+      // Example: }
+      //  sum = sum +/- intrinsic_op vec_sum(t1)
+      StmtNode *dassign = static_cast<StmtNode *>(node);
+      ASSERT(tp->vecInfo->reductionStmts.find(dassign) != tp->vecInfo->reductionStmts.end(),
+             "dassign should be reduction stmt");
+      VectorizeReductionStmt(dassign, tp);
+      break;
+    }
+    default:
+      ASSERT(0, "can't be vectorized");
+  }
+}
+
+// update init/stride/upper nodes of doloop
+// now hack code to widen const stride with value "vecFactor * original stride"
+void LoopVectorization::widenDoloop(DoloopNode *doloop, LoopTransPlan *tp) {
+  if (tp->vBound) {
+    if (tp->vBound->incrNode) {
+      doloop->SetIncrExpr(tp->vBound->incrNode);
+    }
+    if (tp->vBound->lowNode) {
+      doloop->SetStartExpr(tp->vBound->lowNode);
+    }
+    if (tp->vBound->upperNode) {
+      BinaryNode *cmpn = static_cast<BinaryNode *>(doloop->GetCondExpr());
+      // remove equal condition included in compare
+      // updated upper node consider equal condition
+      if (cmpn->GetOpCode() == OP_le) {
+        cmpn->SetOpCode(OP_lt);
+      } else if (cmpn->GetOpCode() == OP_ge) {
+        cmpn->SetOpCode(OP_gt);
+      }
+      cmpn->SetBOpnd(tp->vBound->upperNode, 1);
+    }
+  }
+}
+
+
+void LoopVectorization::VectorizeDoLoop(DoloopNode *doloop, LoopTransPlan *tp) {
+  // LogInfo::MapleLogger() << "\n**** dump doloopnode ****\n";
+  // step 1: handle loop low/upper/stride
+  widenDoloop(doloop, tp);
+
+  // step 2: insert dup stmt before doloop
+  if ((!tp->vecInfo->uniformNodes.empty()) ||
+      (!tp->vecInfo->ivNodes.empty())) {
+    PreMeMIRExtension *lfopart = (*PreMeStmtExtensionMap)[doloop->GetStmtID()];
+    BaseNode *parent = lfopart->GetParent();
+    ASSERT(parent && (parent->GetOpCode() == OP_block), "nullptr check");
+    BlockNode *pblock = static_cast<BlockNode *>(parent);
+    auto it = tp->vecInfo->uniformNodes.begin();
+    for (; it != tp->vecInfo->uniformNodes.end(); ++it) {
+      BaseNode *node = *it;
+      PrimType ptype =  (node->GetOpCode() == OP_iread) ?
+          (static_cast<IreadNode *>(node))->GetType()->GetPrimType() : node->GetPrimType();
+      if (tp->vecInfo->constvalTypes.count(node) > 0) {
+        if (ptype != tp->vecInfo->constvalTypes[node]) {
+          node->SetPrimType(tp->vecInfo->constvalTypes[node]);
+        }
+        ptype = tp->vecInfo->constvalTypes[node];
+      }
+      MIRType *vecType = GenVecType(ptype, tp->vecFactor);
+      IntrinsicopNode *dupscalar = GenDupScalarExpr(node, vecType->GetPrimType());
+      PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(vecType->GetPrimType());
+      RegassignNode *dupScalarStmt = codeMP->New<RegassignNode>(vecType->GetPrimType(), regIdx, dupscalar);
+      pblock->InsertBefore(doloop, dupScalarStmt);
+      RegreadNode *regreadNode = codeMP->New<RegreadNode>(vecType->GetPrimType(), regIdx);
+      tp->vecInfo->uniformVecNodes[node] = regreadNode;
+    }
+    if (!tp->vecInfo->ivNodes.empty()) {
+      // initconst array -> [0, 1, 2... veclanes-1]
+      // vtype reg <- iread array + initval
+      // {
+      //   reg <- reg + veclanes
+      // }
+      MIRType *elemType = static_cast<MIRArrayType *>(tp->vecInfo->ivConstArraySym->GetType())->GetElemType();
+      MIRType *vecType = GenVecType(elemType->GetPrimType(), tp->vecLanes);
+      MIRType *ptvecType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*vecType);
+      PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(vecType->GetPrimType());
+      BaseNode *addr = codeMP->New<AddrofNode>(OP_addrof, PTY_ptr, tp->vecInfo->ivConstArraySym->GetStIdx(), 0);
+      IreadNode *ireadNode = codeMP->New<IreadNode>(OP_iread, vecType->GetPrimType(),
+                                                    ptvecType->GetTypeIndex(), 0, addr);
+      BaseNode *rhs = ireadNode;
+      if ((!doloop->GetStartExpr()->IsConstval()) ||
+          (static_cast<MIRIntConst *>(static_cast<ConstvalNode *>(doloop->GetStartExpr())->GetConstVal())
+              ->GetValue() != 0)) {
+        rhs = codeMP->New<BinaryNode>(OP_add, vecType->GetPrimType(), rhs, doloop->GetStartExpr());
+      }
+      RegassignNode *ivInitStmt = codeMP->New<RegassignNode>(vecType->GetPrimType(), regIdx, rhs);
+      pblock->InsertBefore(doloop, ivInitStmt);
+      RegreadNode *regreadNode = codeMP->New<RegreadNode>(vecType->GetPrimType(), regIdx);
+      it = tp->vecInfo->ivNodes.begin();
+      for (; it != tp->vecInfo->ivNodes.end(); ++it) {
+        tp->vecInfo->ivVecNodes[*it] = regreadNode;
+      }
+      // new increment stmt
+      BaseNode *incrNode = tp->vBound->incrNode;
+      if (GetPrimTypeSize(incrNode->GetPrimType()) != GetPrimTypeSize(elemType->GetPrimType())) {
+        ConstvalNode *constnode = static_cast<ConstvalNode *>(incrNode);
+        MIRIntConst *incrconst = static_cast<MIRIntConst *>(constnode->GetConstVal());
+        MIRIntConst *newConst =
+            GlobalTables::GetIntConstTable().GetOrCreateIntConst(incrconst->GetExtValue(), *elemType);
+        incrNode = codeMP->New<ConstvalNode>(elemType->GetPrimType(), newConst);
+      }
+      BaseNode *incrhs = codeMP->New<BinaryNode>(OP_add, vecType->GetPrimType(), regreadNode, incrNode);
+      tp->vecInfo->ivvecIncrStmt = codeMP->New<RegassignNode>(vecType->GetPrimType(), regIdx, incrhs);
+    }
+  }
+  // step 3: widen vectorizable stmt in doloop
+  BlockNode *loopbody = doloop->GetDoBody();
+  for (auto &stmt : loopbody->GetStmtNodes()) {
+    if (tp->vecInfo->vecStmtIDs.count(stmt.GetStmtID()) > 0) {
+      VectorizeStmt(&stmt, tp);
+    } else {
+      // stmt could not be widen directly, unroll instruction with vecFactor
+      // move value from vector type if need (need def-use information from plan)
+      CHECK_FATAL(0, "NIY:: unvectorized stmt");
+    }
+  }
+  // step 4: insert stmts before/after doloop
+  if (!tp->vecInfo->beforeLoopStmts.empty() ||
+      !tp->vecInfo->afterLoopStmts.empty()) {
+    PreMeMIRExtension *lfopart = (*PreMeStmtExtensionMap)[doloop->GetStmtID()];
+    BaseNode *parent = lfopart->GetParent();
+    ASSERT(parent && (parent->GetOpCode() == OP_block), "nullptr check");
+    BlockNode *pblock = static_cast<BlockNode *>(parent);
+    for (auto *stmtNode : tp->vecInfo->beforeLoopStmts) {
+      pblock->InsertBefore(doloop, stmtNode);
+    }
+    for (auto *stmtNode : tp->vecInfo->afterLoopStmts) {
+      pblock->InsertAfter(doloop, stmtNode);
+    }
+  }
+  if (tp->vecInfo->ivvecIncrStmt) {
+    loopbody->InsertLast(tp->vecInfo->ivvecIncrStmt);
+  }
+}
+
+// generate remainder loop
+DoloopNode *LoopVectorization::GenEpilog(DoloopNode *doloop) const {
+  // new doloopnode
+  // copy doloop body
+  // insert newdoloopnode after doloop
+  return doloop;
+}
+
+// generate prolog/epilog blocknode if needed
+// return doloop need to be vectorized
+DoloopNode *LoopVectorization::PrepareDoloop(DoloopNode *doloop, LoopTransPlan *tp) {
+  bool needPeel = false;
+  // generate peel code if need
+  if (needPeel) {
+    // peel code here
+    // udpate loop lower of doloop if need
+    // copy loop body
+  }
+  // generate epilog
+  if (tp->eBound) {
+    // copy doloop
+    DoloopNode *edoloop = doloop->CloneTree(*codeMPAlloc);
+    ASSERT(tp->eBound->lowNode, "nullptr check");
+    // update loop low bound
+    edoloop->SetStartExpr(tp->eBound->lowNode);
+    // add epilog after doloop
+    PreMeMIRExtension *lfoInfo = (*PreMeStmtExtensionMap)[doloop->GetStmtID()];
+    ASSERT(lfoInfo, "nullptr check");
+    BaseNode *parent = lfoInfo->GetParent();
+    ASSERT(parent && (parent->GetOpCode() ==  OP_block), "nullptr check");
+    BlockNode *pblock = static_cast<BlockNode *>(parent);
+    pblock->InsertAfter(doloop, edoloop);
+  }
+  return doloop;
+}
+
+void LoopVectorization::TransformLoop() {
+  auto it = vecPlans.begin();
+  for (; it != vecPlans.end(); ++it) {
+    // generate prilog/epilog according to vectorization plan
+    DoloopNode *donode = it->first;
+    LoopTransPlan *tplan = it->second;
+    DoloopNode *vecDoloopNode = PrepareDoloop(donode, tplan);
+    VectorizeDoLoop(vecDoloopNode, tplan);
+  }
+}
+
+bool LoopVectorization::ExprVectorizable(DoloopInfo *doloopInfo, LoopVecInfo* vecInfo, BaseNode *x) {
+  if (!IsPrimitiveInteger(x->GetPrimType())) {
+    return false;
+  }
+  switch (x->GetOpCode()) {
+    // supported leaf ops
+    case OP_constval:
+    case OP_dread:
+    case OP_iaddrof:
+    case OP_addrof: {
+      if (isArraySub) {
+        return true;
+      }
+      if (x->GetOpCode() == OP_constval) {
+        vecInfo->uniformNodes.insert(x);
+        return true;
+      }
+      if (doloopInfo->IsLoopInvariant2(x)) {
+        // no vectorize if rhs operands types are not same
+        if (!vecInfo->UpdateRHSTypeSize(x->GetPrimType())) {
+          return false;
+        }
+        vecInfo->uniformNodes.insert(x);
+        return true;
+      }
+      // check scalar is induction variable
+      if (x->GetOpCode() == OP_dread &&
+          doloopInfo->IsLoopIVNode(x)) {
+        vecInfo->ivNodes.insert(x);
+        return true;
+      }
+      return false;
+    }
+    // supported binary ops
+    case OP_add:
+    case OP_sub:
+    case OP_mul:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_shl:
+    case OP_lshr:
+    case OP_ashr:
+    case OP_eq:
+    case OP_ne:
+    case OP_lt:
+    case OP_gt:
+    case OP_le:
+    case OP_ge:
+    case OP_cmpg:
+    case OP_cmpl: {
+      // check two operands are constant
+      bool r0Uniform = doloopInfo->IsLoopInvariant2(x->Opnd(0));
+      bool r1Uniform = doloopInfo->IsLoopInvariant2(x->Opnd(1));
+      bool isvectorizable = false;
+      if (r0Uniform && r1Uniform) {
+        PreMeMIRExtension* lfopart = (*PreMeExprExtensionMap)[x];
+        CHECK_FATAL(lfopart, "nullptr check");
+        BaseNode *parent = lfopart->GetParent();
+        if (parent && parent->GetOpCode() == OP_array && x == parent->Opnd(0)) {
+          return true;
+        }
+        if (!isArraySub && !vecInfo->UpdateRHSTypeSize(x->GetPrimType())) {
+          // no vectorize if rhs operands types are not same
+          return false;
+        } else if (!isArraySub) {
+          vecInfo->uniformNodes.insert(x);
+        }
+        return true;
+      } else if ((!isArraySub) && r0Uniform) {
+        vecInfo->uniformNodes.insert(x->Opnd(0));
+        isvectorizable = ExprVectorizable(doloopInfo, vecInfo, x->Opnd(1));
+      } else if ((!isArraySub) && r1Uniform) {
+        vecInfo->uniformNodes.insert(x->Opnd(1));
+        isvectorizable = ExprVectorizable(doloopInfo, vecInfo, x->Opnd(0));
+        PrimType opnd1Type = x->Opnd(1)->GetPrimType();
+        // update constval type if needed
+        if (isvectorizable && (x->Opnd(1)->GetOpCode() == OP_constval)) {
+          PrimType targetType;
+          if (vecInfo->currentRHSTypeSize != 0 && vecInfo->currentRHSTypeSize < GetPrimTypeSize(opnd1Type)) {
+            targetType = vecInfo->currentRHSTypeSize == 32 ? PTY_i32 :
+                (vecInfo->currentRHSTypeSize == 16 ? PTY_i16 : PTY_i8);
+          } else {
+            targetType = x->Opnd(0)->GetPrimType();
+          }
+          if (GetPrimTypeSize(targetType) != GetPrimTypeSize(opnd1Type) &&
+              CanAdjustRhsConstType(targetType, static_cast<ConstvalNode *>(x->Opnd(1)))) {
+            vecInfo->constvalTypes[x->Opnd(1)] = targetType;
+          }
+        }
+      } else if (ExprVectorizable(doloopInfo, vecInfo, x->Opnd(0)) && ExprVectorizable(doloopInfo, vecInfo,
+          x->Opnd(1))) {
+        isvectorizable = true;
+      }
+      if (vecInfo->widenop > 0) {
+        vecInfo->widenop = vecInfo->widenop << 1;
+      }
+      return isvectorizable;
+    }
+    // supported unary ops
+    case OP_bnot:
+    case OP_lnot:
+    case OP_neg:
+    case OP_abs: {
+      bool r0Uniform = doloopInfo->IsLoopInvariant2(x->Opnd(0));
+      if ((!isArraySub) && r0Uniform) {
+        vecInfo->uniformNodes.insert(x->Opnd(0));
+        return true;
+      }
+      return ExprVectorizable(doloopInfo, vecInfo, x->Opnd(0));
+    }
+    case OP_cvt: {
+      // skip cvt in array subscript
+      return isArraySub;
+    }
+    case OP_iread: {
+      IreadNode* ireadnode = static_cast<IreadNode *>(x);
+      MIRType *mirType = ireadnode->GetType();
+      if (GetPrimTypeSize(ireadnode->GetPrimType()) > GetPrimTypeSize(mirType->GetPrimType())) {
+        vecInfo->widenop = (vecInfo->widenop | 1);
+      }
+      if ((!ireadnode->IsVolatile()) &&
+          (ireadnode->Opnd(0)->GetOpCode() == OP_array) &&
+          (doloopInfo->IsLoopInvariant2(ireadnode->Opnd(0)))) {
+        if (vecInfo->UpdateRHSTypeSize(mirType->GetPrimType()) &&
+          IsPrimitiveInteger(mirType->GetPrimType())) {
+          vecInfo->uniformNodes.insert(x);
+          return true;
+        }
+        return false;
+      }
+      if (isArraySub) {
+        return false; // iread is not constant value and used in array subscript
+      }
+      bool canVec = ExprVectorizable(doloopInfo, vecInfo, x->Opnd(0));
+      if (canVec) {
+        if (!vecInfo->UpdateRHSTypeSize(mirType->GetPrimType()) ||
+            (ireadnode->GetFieldID() != 0)) {
+          canVec = false; // skip if rhs type is not consistent
+        }
+      }
+      return canVec;
+    }
+    // supported n-ary ops
+    case OP_array: {
+      for (size_t i = 0; i < x->NumOpnds(); i++) {
+        isArraySub = true;
+        if (!ExprVectorizable(doloopInfo, vecInfo, x->Opnd(i))) {
+          isArraySub = false;
+          return false;
+        }
+        isArraySub = false;
+      }
+      return true;
+    }
+    // select
+    case OP_select : {
+      if (isArraySub) {
+        return false;
+      }
+      if (doloopInfo->IsLoopInvariant2(x)) {
+        vecInfo->uniformNodes.insert(x);
+      }
+      for (size_t i = 0; i < x->NumOpnds(); i++) {
+        if (!ExprVectorizable(doloopInfo, vecInfo, x->Opnd(i))) {
+          return false;
+        }
+      }
+      return false;
+    }
+    default: ;
+  }
+  return false;
+}
+
+// only handle one level convert
+// <short, int> or <int, short> pairs
+bool LoopVectorization::CanConvert(uint32_t lshtypeSize, uint32_t rhstypeSize) const {
+  if (lshtypeSize >= rhstypeSize) {
+    return ((lshtypeSize / rhstypeSize) <= 2);
+  }
+  // skip narrow case : lhs is small than rhs
+  return false;
+}
+
+bool LoopVectorization::CanAdjustRhsConstType(PrimType targetType, ConstvalNode *rhs) {
+  MIRIntConst *intConst = static_cast<MIRIntConst*>(rhs->GetConstVal());
+  int64 v = intConst->GetExtValue();
+  bool res = false;
+  switch (targetType) {
+    case PTY_i32: {
+      res = (v >= INT_MIN && v <= INT_MAX);
+      break;
+    }
+    case PTY_u32: {
+      res = (v >= 0 && v <= UINT_MAX);
+      break;
+    }
+    case PTY_i16: {
+      res = (v >= SHRT_MIN && v <= SHRT_MAX);
+      break;
+    }
+    case PTY_u16: {
+      res = (v >= 0 && v <=  USHRT_MAX);
+      break;
+    }
+    case PTY_i8: {
+      res = (v >= SCHAR_MIN && v <= SCHAR_MAX);
+      break;
+    }
+    case PTY_u8: {
+      res = (v >= 0 && v <= UCHAR_MAX);
+      break;
+    }
+    case PTY_i64:
+    case PTY_u64: {
+      res = true;
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  return res;
+}
+
+// handle iassign lhs ivar is constant and same as opnd0 of rhs
+// a[3] += vectorizable(opnd1)
+// a better way is to promote a[3] as a scalar before premeemit
+// scalar will be identified as reduction variable
+bool LoopVectorization::IassignIsReduction(IassignNode *iassign, LoopVecInfo* vecInfo) {
+  if (IsReductionOp(iassign->GetRHS()->GetOpCode()) &&
+      ((static_cast<BinaryNode *>(iassign->GetRHS()))->GetBOpnd(0)->GetOpCode() == OP_iread)) {
+    auto *stmtP = (*PreMeStmtExtensionMap)[iassign->GetStmtID()];
+    IassignMeStmt *iassMeStmt = static_cast<IassignMeStmt *>(stmtP->GetMeStmt());
+    IvarMeExpr *ivarlhsExpr = iassMeStmt->GetLHSVal();
+    auto *rhsOpnd0 = (*PreMeExprExtensionMap)[(static_cast<BinaryNode *>(iassign->GetRHS()))->GetBOpnd(0)];
+    BaseNode *rhsOpnd1 = iassign->GetRHS()->Opnd(1);
+    PrimType lhsmirType = (static_cast<MIRPtrType*>(&GetTypeFromTyIdx(iassign->GetTyIdx())))
+        ->GetPointedType()->GetPrimType();
+    PrimType rhsOpnd1Type = rhsOpnd1->GetPrimType();
+    if (ivarlhsExpr && rhsOpnd0 && rhsOpnd0->GetMeExpr() &&
+        (rhsOpnd0->GetMeExpr()->GetMeOp() == maple::kMeOpIvar)) {
+      IvarMeExpr *ivarrhs0Expr = static_cast<IvarMeExpr *>(rhsOpnd0->GetMeExpr());
+      if ((ivarlhsExpr->GetBase() == ivarrhs0Expr->GetBase()) &&
+          (lhsmirType == rhsOpnd1Type)) {
+        vecInfo->vecStmtIDs.insert((iassign)->GetStmtID());
+        vecInfo->reductionStmts.insert(iassign);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// assumed to be inside innermost loop
+bool LoopVectorization::Vectorizable(DoloopInfo *doloopInfo, LoopVecInfo* vecInfo, BlockNode *block) {
+  StmtNode *stmt = block->GetFirst();
+  while (stmt != nullptr) {
+    // reset vecInfo
+    vecInfo->ResetStmtRHSTypeSize();
+    switch (stmt->GetOpCode()) {
+      case OP_doloop:
+      case OP_dowhile:
+      case OP_while: {
+        CHECK_FATAL(false, "Vectorizable: cannot handle non-innermost loop");
+        break;
+      }
+      case OP_block:
+        return Vectorizable(doloopInfo, vecInfo, static_cast<DoloopNode *>(stmt)->GetDoBody());
+      case OP_iassign: {
+        IassignNode *iassign = static_cast<IassignNode *>(stmt);
+        bool lhsUseAsScalar = false;
+        // no vectorize lsh is complex or constant subscript
+        if (iassign->addrExpr->GetOpCode() == OP_array) {
+          ArrayNode *lhsArr = static_cast<ArrayNode *>(iassign->addrExpr);
+          ArrayAccessDesc *accessDesc = doloopInfo->GetArrayAccessDesc(lhsArr, false /* isRHS */);
+          ASSERT(accessDesc != nullptr, "nullptr check");
+          size_t dim = lhsArr->NumOpnds() - 1;
+          // check innest loop dimension is complex
+          // case like a[abs(i-1)] = 1; depth test will report it's parallelize
+          // or a[4*i+1] =; address is not continous if coeff > 1
+          if (accessDesc->subscriptVec[dim - 1]->tooMessy ||
+              accessDesc->subscriptVec[dim - 1]->coeff != 1) {
+            if (enableDebug) {
+              LogInfo::MapleLogger() << "NOT VECTORIZABLE because of complex array subscript\n";
+            }
+            return false;
+          } else if (accessDesc->subscriptVec[dim - 1]->loopInvariant) {
+            lhsUseAsScalar = true;
+          }
+        }
+        // check rsh
+        bool canVec = ExprVectorizable(doloopInfo, vecInfo, iassign->GetRHS());
+        if (!canVec) {
+          // early return
+          if (enableDebug) {
+            LogInfo::MapleLogger() << "NOT VECTORIZABLE because of RHS is not vectorizable\n";
+          }
+          return false;
+        }
+        if (iassign->GetFieldID() != 0) {  // check base of iassign
+          canVec = doloopInfo->IsLoopInvariant2(iassign->Opnd(0));
+          if (!canVec) {
+            if (enableDebug) {
+              LogInfo::MapleLogger() << "NOT VECTORIZABLE because of baseaddress is not const with non-zero filedID\n";
+            }
+            return false;
+          }
+        }
+        // check lhs is used like reduction variable
+        if (lhsUseAsScalar && (!IassignIsReduction(iassign, vecInfo))) {
+          if (enableDebug) {
+            LogInfo::MapleLogger() << "NOT VECTORIZABLE because of lhs is scalar\n";
+          }
+          return false;
+        }
+        // check type
+        {
+          MIRType &mirType = GetTypeFromTyIdx(iassign->GetTyIdx());
+          CHECK_FATAL(mirType.GetKind() == kTypePointer, "iassign must have pointer type");
+          MIRPtrType *ptrType = static_cast<MIRPtrType*>(&mirType);
+          PrimType stmtpt = ptrType->GetPointedType()->GetPrimType();
+          if (!IsPrimitiveInteger(stmtpt)) {
+             // iassign ptr type should be integer now
+            return false;
+          }
+          // now check lsh type size should be same as rhs typesize
+          uint32_t lshtypesize = GetPrimTypeSize(stmtpt) * 8;
+          if (iassign->GetRHS()->IsConstval() &&
+              (stmtpt != iassign->GetRHS()->GetPrimType()) &&
+              CanAdjustRhsConstType(stmtpt, static_cast<ConstvalNode *>(iassign->GetRHS()))) {
+            vecInfo->constvalTypes[iassign->GetRHS()] = stmtpt;
+            (void)vecInfo->UpdateRHSTypeSize(stmtpt);
+          } else if (iassign->GetRHS()->GetOpCode() != OP_iread) {
+            // iread will update rhs type in exprvectorizable
+            (void)vecInfo->UpdateRHSTypeSize(iassign->GetRHS()->GetPrimType());
+          }
+          if (!CanConvert(lshtypesize, vecInfo->currentRHSTypeSize)) {
+            // use one cvt could handle the type difference
+            if (enableDebug) {
+              LogInfo::MapleLogger() << "NOT VECTORIZABLE because of lhs and rhs type different\n";
+            }
+            return false; // need cvt instruction
+          }
+          // rsh is loop invariant
+          if (doloopInfo->IsLoopInvariant2(iassign->GetRHS())) {
+            vecInfo->uniformNodes.insert(iassign->GetRHS());
+          }
+          vecInfo->vecStmtIDs.insert((stmt)->GetStmtID());
+          // update largest type size
+          uint32_t maxSize = vecInfo->currentRHSTypeSize > lshtypesize ?
+              vecInfo->currentRHSTypeSize : lshtypesize;
+          vecInfo->UpdateWidestTypeSize(maxSize);
+          // update smallest type
+          if (lshtypesize < vecInfo->smallestTypeSize) {
+            vecInfo->smallestTypeSize = lshtypesize;
+          }
+        }
+        break;
+      }
+      case OP_dassign: {
+        DassignNode *dassign = static_cast<DassignNode *>(stmt);
+        StIdx lhsStIdx = dassign->GetStIdx();
+        MIRSymbol *lhsSym = mirFunc->GetLocalOrGlobalSymbol(lhsStIdx);
+        MIRType &lhsType = GetTypeFromTyIdx(lhsSym->GetTyIdx());
+        BaseNode *rhs = dassign->GetRHS();
+        uint32_t lhstypesize = GetPrimTypeSize(lhsType.GetPrimType()) * 8;
+        if (IsReductionOp(rhs->GetOpCode()) && doloopInfo->IsReductionVar(lhsStIdx)) {
+          BaseNode *opnd0 = rhs->Opnd(0);
+          BaseNode *opnd1 = rhs->Opnd(1);
+          CHECK_FATAL((opnd0->GetOpCode() == OP_dread) && ((static_cast<AddrofNode *>(opnd0))->GetStIdx() == lhsStIdx),
+                      "opnd0 is reduction variable");
+          if (ExprVectorizable(doloopInfo, vecInfo, opnd1)) {
+            // there's iread in rhs
+            if (vecInfo->currentRHSTypeSize != 0) {
+              if (lhstypesize < vecInfo->currentRHSTypeSize ||
+                  vecInfo->currentRHSTypeSize < 8) { // rsh typs size is less than i8/u8
+                // narrow down the result, not handle now
+                if (enableDebug) {
+                  LogInfo::MapleLogger() <<
+                     "NOT VECTORIZABLE because of different type between dassign reduction var and other opnd \n";
+                }
+                return false;
+              }
+              // return false if widen op in nested binary operation
+              if (vecInfo->widenop >= 4) {
+                return false;
+              }
+              vecInfo->UpdateWidestTypeSize(vecInfo->currentRHSTypeSize);
+            } else {
+              vecInfo->UpdateWidestTypeSize(lhstypesize);
+            }
+            vecInfo->vecStmtIDs.insert((stmt)->GetStmtID());
+            vecInfo->reductionStmts.insert(stmt);
+          } else {
+            if (enableDebug) {
+              LogInfo::MapleLogger() << "NOT VECTORIZABLE because of other opnd can't be vectorized\n";
+            }
+            return false; // only handle reduction scalar
+          }
+        } else {
+          if (enableDebug) {
+            LogInfo::MapleLogger() << "NOT VECTORIZABLE because of dassign variable is not reduction var\n";
+          }
+          return false;
+        }
+        break;
+      }
+      default: return false;
+    }
+    vecInfo->widenop = 0; // reset value
+    stmt = stmt->GetNext();
+  }
+  return true;
+}
+
+// create constant node if need in vectorization
+void LoopVectorization::GenConstVar(LoopVecInfo *vecInfo, uint8_t vecLanes) {
+  // create zero node used in reduction stmt
+  if ((!const0Node) && (!vecInfo->reductionStmts.empty())) {
+    PrimType ptype = vecLanes == 4 ? PTY_i32 : (vecLanes == 2 ? PTY_i64 : PTY_i16);
+    MIRType &typeInt = *GlobalTables::GetTypeTable().GetPrimType(ptype);
+    MIRIntConst *constZero = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, typeInt);
+    const0Node = codeMP->New<ConstvalNode>(ptype, constZero);
+  }
+  MIRSymbol *ivconstSym = (vecLanes == 4) ? initIVv4Sym : (vecLanes == 8 ? initIVv8Sym : initIVv2Sym);
+  if ((!ivconstSym) && (!vecInfo->ivNodes.empty())) {
+    std::string ivVecName("__ivvec");
+    ivVecName.append(std::to_string(vecLanes));
+    // add file name in case new constant array created in multi modules
+    MIRModule *mirModule = mirFunc->GetModule();
+    const std::string fileName = mirModule->GetFileName();
+    std::string::size_type lastDot = fileName.find_last_of('.');
+    std::string::size_type lastSlash = fileName.find_last_of('/');
+    if (lastSlash != std::string::npos &&
+        lastDot != std::string::npos) {
+      ivVecName.append("_" + fileName.substr(lastSlash + 1, lastDot));
+    } else if (lastSlash == std::string::npos) {
+      ivVecName.append("_" + fileName.substr(0, lastDot));
+    }
+    ivVecName.erase(std::remove(ivVecName.begin(), ivVecName.end(), '-'), ivVecName.end());
+    PrimType type = (vecLanes == 4) ? PTY_i32 : ((vecLanes == 8) ? PTY_i16 : PTY_i64);
+    MIRType *elemType = GlobalTables::GetTypeTable().GetPrimType(type);
+    MIRArrayType *arrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*elemType, 0);
+    MIRAggConst *constval = mirModule->GetMemPool()->New<MIRAggConst>((*mirModule), *arrayType);
+    for (uint32_t i = 0; i < vecLanes; i++) {
+      MIRIntConst *intconst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(i, *elemType);
+      constval->AddItem(intconst, 0);
+    }
+    ivconstSym = mirModule->GetMIRBuilder()->GetOrCreateGlobalDecl(ivVecName, *arrayType);
+    ASSERT_NOT_NULL(ivconstSym);
+    ivconstSym->SetKonst(constval);
+  }
+  vecInfo->ivConstArraySym = ivconstSym;
+}
+
+void LoopVectorization::Perform() {
+  // step 2: collect information, legality check and generate transform plan
+  MapleMap<DoloopNode *, DoloopInfo *>::iterator mapit = depInfo->doloopInfoMap.begin();
+  for (; mapit != depInfo->doloopInfoMap.end(); ++mapit) {
+    if (!mapit->second->children.empty() || mapit->second->NotParallel()) {
+      continue;
+    }
+    // check in debug
+    if (LoopVectorization::vectorizedLoop >= MeOption::vecLoopLimit) {
+      break;
+    }
+    LoopVecInfo *vecInfo = localMP->New<LoopVecInfo>(localAlloc);
+    if (mapit->second->HasTrueDepOnly() > 0) {
+      vecInfo->minTrueDepDist = mapit->second->HasTrueDepOnly();
+    }
+    if (mapit->second->HasAntiDepOnly() < 0) {
+      vecInfo->maxAntiDepDist = mapit->second->HasAntiDepOnly();
+    }
+    bool vectorizable = Vectorizable(mapit->second, vecInfo, mapit->first->GetDoBody());
+    if (vectorizable) {
+      LoopVectorization::vectorizedLoop++;
+    }
+    if (enableDebug) {
+      LogInfo::MapleLogger() << "\nInnermost Doloop:";
+      if (!vectorizable) {
+        LogInfo::MapleLogger() << " NOT";
+      }
+      LogInfo::MapleLogger() << " VECTORIZABLE\n";
+      mapit->first->Dump(0);
+    }
+    if (!vectorizable) {
+      continue;
+    }
+    // generate vectorize plan;
+    LoopTransPlan *tplan = localMP->New<LoopTransPlan>(codeMP, localMP, vecInfo);
+    if (tplan->Generate(mapit->first, mapit->second, enableDebug)) {
+      vecPlans[mapit->first] = tplan;
+      GenConstVar(vecInfo, tplan->vecLanes);
+      mapit->second->hasBeenVectorized = true;
+    }
+  }
+  // step 3: do transform
+  // transform plan map to each doloop
+  TransformLoop();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/lfo_unroll.cpp b/src/mapleall/maple_me/src/lfo_unroll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa66b1a65a10485376f9e8142cba6b15c10a75f8
--- /dev/null
+++ b/src/mapleall/maple_me/src/lfo_unroll.cpp
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) [2021-2022] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "lfo_unroll.h"
+#include <climits>
+#include "me_loop_analysis.h"
+
+namespace maple {
+uint32 LfoUnrollOneLoop::countOfLoopsUnrolled = 0;
+
+constexpr size_t unrolledSizeLimit = 12;  // unrolled loop body size to be < this value
+constexpr size_t unrollMax = 10;          // times to unroll never more than this
+
+BaseNode *LfoUnrollOneLoop::CloneIVNode() {
+  if (doloop->IsPreg()) {
+    return mirBuilder->CreateExprRegread(ivPrimType, doloop->GetDoVarPregIdx());
+  } else {
+    return codeMP->New<AddrofNode>(OP_dread, ivPrimType, doloop->GetDoVarStIdx(), 0);
+  }
+}
+
+// replace any occurrence of the IV in x with a copy of repNode
+void LfoUnrollOneLoop::ReplaceIV(BaseNode *x, BaseNode *repNode) {
+  if (x->GetOpCode() == OP_block) {
+    BlockNode *blk = static_cast<BlockNode *>(x);
+    StmtNode *stmt = blk->GetFirst();
+    while (stmt != nullptr) {
+      ReplaceIV(stmt, repNode);
+      stmt = stmt->GetNext();
+    }
+    return;
+  }
+  for (size_t i = 0; i < x->NumOpnds(); i++) {
+    if (doloopInfo->IsLoopIVNode(x->Opnd(i))) {
+      x->SetOpnd(repNode, i);
+    } else {
+      ReplaceIV(x->Opnd(i), repNode);
+    }
+  }
+}
+
+BlockNode *LfoUnrollOneLoop::DoFullUnroll(size_t tripCount) {
+  BlockNode *unrolledBlk;
+  size_t unrollTimes = tripCount;
+  if (Options::profileUse && preMeFunc->meFunc && preMeFunc->meFunc->GetMirFunc() &&
+      preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()) {
+    auto *profData = preMeFunc->meFunc->GetMirFunc()->GetFuncProfData();
+    auto &stmtFreqs = profData->GetStmtFreqs();
+    uint32 updateOp = (kKeepOrigFreq | kUpdateUnrolledFreq);
+    unrolledBlk = doloop->GetDoBody()->CloneTreeWithFreqs(mirModule->GetCurFuncCodeMPAllocator(),
+                                                          stmtFreqs, stmtFreqs, 1, unrollTimes, updateOp);
+  } else {
+    unrolledBlk = doloop->GetDoBody()->CloneTreeWithSrcPosition(*mirModule);
+  }
+  ReplaceIV(unrolledBlk, doloop->GetStartExpr());
+  BlockNode *nextIterBlk = nullptr;
+  tripCount--;
+  uint32 i = 0;
+  while (tripCount > 0) {
+    i++;
+    if (Options::profileUse && preMeFunc->meFunc && preMeFunc->meFunc->GetMirFunc() &&
+        preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()) {
+      auto &stmtFreqs = preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()->GetStmtFreqs();
+      nextIterBlk = doloop->GetDoBody()->CloneTreeWithFreqs(mirModule->GetCurFuncCodeMPAllocator(),
+                                                            stmtFreqs, stmtFreqs, 1, unrollTimes,
+                                                            (kKeepOrigFreq | kUpdateUnrolledFreq));
+    } else {
+      nextIterBlk = doloop->GetDoBody()->CloneTreeWithSrcPosition(*mirModule);
+    }
+    BaseNode *adjExpr = mirBuilder->CreateIntConst(stepAmount * i, ivPrimType);
+    BaseNode *repExpr = codeMP->New<BinaryNode>(OP_add, ivPrimType, doloop->GetStartExpr(), adjExpr);
+    ReplaceIV(nextIterBlk, repExpr);
+    unrolledBlk->InsertBlockAfter(*nextIterBlk, unrolledBlk->GetLast());
+    tripCount--;
+  }
+  return unrolledBlk;
+}
+
+// only handling constant trip count for now
+BlockNode *LfoUnrollOneLoop::DoUnroll(size_t times, size_t tripCount) {
+  BlockNode *unrolledBlk = nullptr;
+  // form the remainder loop before the unrolled loop
+  size_t remainderTripCount = tripCount % times; // used when constant tripcount
+  PregIdx regIdx = 0;   // used when unknown tripcount
+  if (tripCount != 0) {
+    if (remainderTripCount == 0) {
+      unrolledBlk = codeMP->New<BlockNode>();
+    } else if (remainderTripCount == 1) {
+      if (Options::profileUse && preMeFunc->meFunc && preMeFunc->meFunc->GetMirFunc() &&
+          preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()) {
+        auto &stmtFreqs = preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()->GetStmtFreqs();
+        unrolledBlk =
+            doloop->GetDoBody()->CloneTreeWithFreqs(mirModule->GetCurFuncCodeMPAllocator(),
+                                                    stmtFreqs, stmtFreqs, 1, times,
+                                                    (kKeepOrigFreq | kUpdateUnrollRemainderFreq));
+      } else {
+        unrolledBlk = doloop->GetDoBody()->CloneTreeWithSrcPosition(*mirModule);
+      }
+      ReplaceIV(unrolledBlk, doloop->GetStartExpr());
+    } else {
+      DoloopNode *remDoloop;
+      if (Options::profileUse && preMeFunc->meFunc && preMeFunc->meFunc->GetMirFunc() &&
+          preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()) {
+        auto &stmtFreqs = preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()->GetStmtFreqs();
+        remDoloop = doloop->CloneTreeWithFreqs(mirModule->GetCurFuncCodeMPAllocator(),
+                          stmtFreqs, stmtFreqs, 1/*numor*/, times/*denom*/,
+                          (kKeepOrigFreq | kUpdateUnrollRemainderFreq));
+      } else {
+        remDoloop = doloop->CloneTree(*preEmit->GetCodeMPAlloc());
+      }
+      // generate remDoloop's termination
+      BaseNode *terminationRHS = codeMP->New<BinaryNode>(OP_add, ivPrimType,
+          doloop->GetStartExpr()->CloneTree(*preEmit->GetCodeMPAlloc()),
+          mirBuilder->CreateIntConst(static_cast<int64>(remainderTripCount), ivPrimType));
+      remDoloop->SetContExpr(codeMP->New<CompareNode>(OP_lt, PTY_i32, ivPrimType, CloneIVNode(), terminationRHS));
+      unrolledBlk = codeMP->New<BlockNode>();
+      unrolledBlk->AddStatement(remDoloop);
+    }
+  } else {
+    // generate code to calculate the remainder loop trip count which is
+    // (endexpr - startexpr) % times (increment assumed to be 1)
+    BaseNode *startExpr = doloop->GetStartExpr();
+    BaseNode *condExpr = doloop->GetCondExpr();
+    BaseNode *endExpr = condExpr->Opnd(1);
+    BaseNode *tripsExpr = codeMP->New<BinaryNode>(OP_sub, ivPrimType,
+        endExpr->CloneTree(*preEmit->GetCodeMPAlloc()),
+        startExpr->CloneTree(*preEmit->GetCodeMPAlloc()));
+    if (condExpr->GetOpCode() == OP_ge || condExpr->GetOpCode() == OP_le) {
+      tripsExpr = codeMP->New<BinaryNode>(OP_add, ivPrimType, tripsExpr,
+          mirBuilder->CreateIntConst(1, ivPrimType));
+    }
+    tripsExpr = codeMP->New<BinaryNode>(OP_rem, ivPrimType, tripsExpr,
+        mirBuilder->CreateIntConst(static_cast<int64>(times), ivPrimType));
+    BaseNode *remLoopEndExpr = codeMP->New<BinaryNode>(OP_add, ivPrimType,
+        startExpr->CloneTree(*preEmit->GetCodeMPAlloc()), tripsExpr);
+    // store in a preg
+    regIdx = preMeFunc->meFunc->GetMirFunc()->GetPregTab()->CreatePreg(ivPrimType);
+    RegassignNode *rass = mirBuilder->CreateStmtRegassign(ivPrimType, regIdx, remLoopEndExpr);
+    unrolledBlk = codeMP->New<BlockNode>();
+    unrolledBlk->AddStatement(rass);
+    DoloopNode *remDoloop;
+    if (Options::profileUse && preMeFunc->meFunc && preMeFunc->meFunc->GetMirFunc() &&
+        preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()) {
+      auto &stmtFreqs = preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()->GetStmtFreqs();
+      remDoloop = doloop->CloneTreeWithFreqs(mirModule->GetCurFuncCodeMPAllocator(),
+                                             stmtFreqs, stmtFreqs, 1, times,
+                                             (kUpdateUnrollRemainderFreq));
+    } else {
+      remDoloop = doloop->CloneTree(*preEmit->GetCodeMPAlloc());
+    }
+    // generate remDoloop's termination
+    BaseNode *terminationRHS = mirBuilder->CreateExprRegread(ivPrimType, regIdx);
+    remDoloop->SetContExpr(codeMP->New<CompareNode>(OP_lt, PTY_i32, ivPrimType, CloneIVNode(), terminationRHS));
+    unrolledBlk->AddStatement(remDoloop);
+  }
+
+  // form the unrolled loop
+  DoloopNode *unrolledDoloop;
+  if (Options::profileUse && preMeFunc->meFunc && preMeFunc->meFunc->GetMirFunc() &&
+      preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()) {
+    auto &stmtFreqs = preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()->GetStmtFreqs();
+    unrolledDoloop = doloop->CloneTreeWithFreqs(mirModule->GetCurFuncCodeMPAllocator(),
+                                                stmtFreqs, stmtFreqs, 1, times,
+                                                (kKeepOrigFreq | kUpdateUnrolledFreq));
+  } else {
+    unrolledDoloop = doloop->CloneTree(*preEmit->GetCodeMPAlloc());
+  }
+  uint32 i = 1;
+  BlockNode *nextIterBlk = nullptr;
+  do {
+    if (Options::profileUse && preMeFunc->meFunc && preMeFunc->meFunc->GetMirFunc() &&
+        preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()) {
+      auto &stmtFreqs = preMeFunc->meFunc->GetMirFunc()->GetFuncProfData()->GetStmtFreqs();
+      nextIterBlk = doloop->GetDoBody()->CloneTreeWithFreqs(mirModule->GetCurFuncCodeMPAllocator(),
+                      stmtFreqs, stmtFreqs, 1/*numor*/, times/*denom*/, (kKeepOrigFreq | kUpdateUnrolledFreq));
+    } else {
+      nextIterBlk = doloop->GetDoBody()->CloneTreeWithSrcPosition(*mirModule);
+    }
+    BaseNode *adjExpr = mirBuilder->CreateIntConst(stepAmount * i, ivPrimType);
+    BaseNode *repExpr = codeMP->New<BinaryNode>(OP_add, ivPrimType, CloneIVNode(), adjExpr);
+    ReplaceIV(nextIterBlk, repExpr);
+    unrolledDoloop->GetDoBody()->InsertBlockAfter(*nextIterBlk, unrolledDoloop->GetDoBody()->GetLast());
+    i++;
+  } while (i != times);
+  // update startExpr
+  if (tripCount != 0) {
+    if (remainderTripCount != 0) {
+      BaseNode *newStartExpr = codeMP->New<BinaryNode>(OP_add, ivPrimType, unrolledDoloop->GetStartExpr(),
+          mirBuilder->CreateIntConst(static_cast<int64>(remainderTripCount), ivPrimType));
+      unrolledDoloop->SetStartExpr(newStartExpr);
+    }
+  } else {
+    BaseNode *newStartExpr = mirBuilder->CreateExprRegread(ivPrimType, regIdx);
+    unrolledDoloop->SetStartExpr(newStartExpr);
+  }
+  // update incrExpr
+  ConstvalNode *stepNode = static_cast<ConstvalNode *>(unrolledDoloop->GetIncrExpr());
+  uint64 origIncr = static_cast<MIRIntConst *>(stepNode->GetConstVal())->GetExtValue();
+  unrolledDoloop->SetIncrExpr(mirBuilder->CreateIntConst(origIncr * times, ivPrimType));
+  unrolledBlk->AddStatement(unrolledDoloop);
+  return unrolledBlk;
+}
+
+static size_t CountBlockStmts(BlockNode *blk) {
+  if (blk == nullptr) {
+    return 0;
+  }
+  size_t stmtCount = 0;
+  StmtNode *stmt = blk->GetFirst();
+  while (stmt != nullptr) {
+    if (stmt->GetOpCode() == OP_block) {
+      stmtCount += CountBlockStmts(static_cast<BlockNode *>(stmt));
+    } else if (stmt->GetOpCode() != OP_label && stmt->GetOpCode() != OP_comment) {
+      stmtCount++;
+      if (stmt->GetOpCode() == OP_if) {
+        constexpr uint8 kIfCount = 3;
+        stmtCount += kIfCount + CountBlockStmts(static_cast<IfStmtNode *>(stmt)->GetThenPart());
+        stmtCount += kIfCount + CountBlockStmts(static_cast<IfStmtNode *>(stmt)->GetElsePart());
+      }
+    }
+    ASSERT(stmt->GetOpCode() != OP_switch && stmt->GetOpCode() != OP_while &&
+           stmt->GetOpCode() != OP_dowhile && stmt->GetOpCode() != OP_doloop,
+           "CountBlockStmts: unexpected statement type");
+    stmt = stmt->GetNext();
+  }
+  return stmtCount;
+}
+
+void LfoUnrollOneLoop::Process() {
+  if (doloopInfo->hasOtherCtrlFlow || doloopInfo->hasBeenVectorized || doloopInfo->hasLabels) {
+    return;
+  }
+  if (!doloop->GetIncrExpr()->IsConstval()) {
+    return;
+  }
+  ivPrimType = doloop->GetStartExpr()->GetPrimType();
+  ConstvalNode *cvalnode = static_cast<ConstvalNode *>(doloop->GetIncrExpr());
+  if (!cvalnode->GetConstVal()->IsOne()) {
+    return;
+  }
+  size_t stmtCount = CountBlockStmts(doloop->GetDoBody());
+  constexpr uint8 kMaxStmtCount = 16;
+  if (stmtCount == 0 || stmtCount > kMaxStmtCount) {
+    return;
+  }
+
+  // screen doloop condExpr
+  BaseNode *condExpr = doloop->GetCondExpr();
+  if (!kOpcodeInfo.IsCompare(condExpr->GetOpCode())) {
+    return;
+  }
+  if (condExpr->GetOpCode() == OP_eq) {
+    return;
+  }
+  if (!doloopInfo->IsLoopIVNode(condExpr->Opnd(0))) {
+    return;
+  }
+  BaseNode *endExpr = condExpr->Opnd(1);
+
+  // screen doloop incrExpr
+  if (!doloop->GetIncrExpr()->IsConstval()) {
+    return;
+  }
+  ConstvalNode *stepNode = static_cast<ConstvalNode *>(doloop->GetIncrExpr());
+  MIRIntConst *stepConst = static_cast<MIRIntConst *>(stepNode->GetConstVal());
+  stepAmount = stepConst->GetExtValue();
+
+  size_t tripCount = 0;         // 0 if not constant trip count
+  if (doloop->GetStartExpr()->IsConstval() && endExpr->IsConstval()) {
+    ConstvalNode *startNode = static_cast<ConstvalNode *>(doloop->GetStartExpr());
+    MIRIntConst *startConst = static_cast<MIRIntConst *>(startNode->GetConstVal());
+    ConstvalNode *endNode = static_cast<ConstvalNode *>(endExpr);
+    MIRIntConst *endConst = static_cast<MIRIntConst *>(endNode->GetConstVal());
+    tripCount = static_cast<size_t>((endConst->GetExtValue() - startConst->GetExtValue()) / stepAmount);
+    if (condExpr->GetOpCode() == OP_ge || condExpr->GetOpCode() == OP_le) {
+      tripCount++;
+    }
+    auto invalidBits = sizeof(tripCount) * CHAR_BIT - GetPrimTypeBitSize(ivPrimType);
+    tripCount = (tripCount << invalidBits) >> invalidBits;  /* get the valid bits */
+  }
+  size_t unrollTimes = 1;
+  size_t unrolledStmtCount = stmtCount;
+  while (unrolledStmtCount < unrolledSizeLimit && unrollTimes < unrollMax) {
+    unrollTimes++;
+    unrolledStmtCount += stmtCount;
+  }
+  bool fullUnroll = tripCount != 0 && tripCount < (unrollTimes * 2);
+  BlockNode *unrolledBlk = nullptr;
+  if (fullUnroll) {
+    unrolledBlk = DoFullUnroll(tripCount);
+  } else {
+    if (MeOption::optLevel <= 2 || unrollTimes == 1) {
+      return;
+    }
+    unrolledBlk = DoUnroll(unrollTimes, tripCount);
+  }
+
+  // replace doloop by the statements in unrolledBlk
+  PreMeMIRExtension *lfopart = (*preEmit->GetPreMeStmtExtensionMap())[doloop->GetStmtID()];
+  BaseNode *parent = lfopart->GetParent();
+  ASSERT(parent && (parent->GetOpCode() == OP_block), "LfoUnroll: parent of doloop is not OP_block");
+  BlockNode *pblock = static_cast<BlockNode *>(parent);
+  pblock->ReplaceStmtWithBlock(*doloop, *unrolledBlk);
+
+  // update counter
+  countOfLoopsUnrolled++;
+};
+
+bool MELfoUnroll::PhaseRun(MeFunction &f) {
+  PreMeEmitter *preEmit = GET_ANALYSIS(MEPreMeEmission, f);
+  ASSERT(preEmit != nullptr, "lfo preemit phase has problem");
+  LfoDepInfo *lfoDepInfo = GET_ANALYSIS(MELfoDepTest, f);
+  ASSERT(lfoDepInfo != nullptr, "lfo dep test phase has problem");
+  PreMeFunction *preMeFunc = f.GetPreMeFunc();
+  uint32 savedCountOfLoopsUnrolled = LfoUnrollOneLoop::countOfLoopsUnrolled;
+
+  MapleMap<DoloopNode *, DoloopInfo *>::iterator mapit = lfoDepInfo->doloopInfoMap.begin();
+  for (; mapit != lfoDepInfo->doloopInfoMap.end(); ++mapit) {
+    if (MeOption::optForSize) {
+      break;
+    }
+    if (!mapit->second->children.empty() || mapit->second->hasBeenVectorized) {
+      continue;
+    }
+    LfoUnrollOneLoop unroll(preMeFunc, preEmit, mapit->second);
+    unroll.Process();
+  }
+  if (DEBUGFUNC_NEWPM(f) && savedCountOfLoopsUnrolled != LfoUnrollOneLoop::countOfLoopsUnrolled) {
+    LogInfo::MapleLogger() << "\n**** After lfo loop unrolling ****\n";
+    f.GetMirFunc()->Dump();
+  }
+  // cfg is invalid for now
+  f.SetTheCfg(nullptr);
+  return false;
+}
+
+void MELfoUnroll::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEPreMeEmission>();
+  aDep.AddRequired<MELfoDepTest>();
+  aDep.PreservedAllExcept<MEMeCfg>();
+  aDep.PreservedAllExcept<MEDominance>();
+  aDep.PreservedAllExcept<MELoopAnalysis>();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/lmbc_lower.cpp b/src/mapleall/maple_me/src/lmbc_lower.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..279a9c2672f0b0efe64f5b5d4f3bd8236ed00be5
--- /dev/null
+++ b/src/mapleall/maple_me/src/lmbc_lower.cpp
@@ -0,0 +1,552 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "lmbc_lower.h"
+
+namespace maple {
+
+using namespace std;
+
+PregIdx LMBCLowerer::GetSpecialRegFromSt(const MIRSymbol *sym) {
+  ASSERT_NOT_NULL(sym);
+  MIRStorageClass storageClass = sym->GetStorageClass();
+  PregIdx specreg = 0;
+  if (storageClass == kScAuto) {
+    CHECK(sym->GetStIndex() < memlayout->sym_alloc_table.size(),
+          "index out of range in LMBCLowerer::GetSpecialRegFromSt");
+    SymbolAlloc *symalloc = &memlayout->sym_alloc_table[sym->GetStIndex()];
+    if (symalloc->mem_segment->kind == MS_FPbased) {
+      specreg = -kSregFp;
+    } else {
+      CHECK_FATAL(false, "LMBCLowerer::LowerDread: bad memory layout for local variable");
+    }
+  } else if (storageClass == kScGlobal || storageClass == kScFstatic ||
+             storageClass == kScExtern || storageClass == kScPstatic) {
+    specreg = -kSregGp;
+  } else {
+    CHECK_FATAL(false, "LMBCLowerer::LowerDread: NYI");
+  }
+  return specreg;
+}
+
+BaseNode *LMBCLowerer::LowerAddrof(AddrofNode *expr) {
+  MIRSymbol *symbol = func->GetLocalOrGlobalSymbol(expr->GetStIdx());
+  ASSERT_NOT_NULL(symbol);
+  symbol->ResetIsDeleted();
+  int32 offset = 0;
+  if (expr->GetFieldID() != 0) {
+    MIRStructType *structty = static_cast<MIRStructType *>(symbol->GetType());
+    offset = becommon->GetFieldOffset(*structty, expr->GetFieldID()).first;
+  }
+  PrimType symty = (expr->GetPrimType() == PTY_simplestr ||
+                    expr->GetPrimType() == PTY_simpleobj) ? expr->GetPrimType() : GetLoweredPtrType();
+  if (!symbol->LMBCAllocateOffSpecialReg()) {
+    return mirBuilder->CreateExprDreadoff(OP_addrofoff, GetLoweredPtrType(), *symbol, offset);
+  }
+  BaseNode *rrn = mirBuilder->CreateExprRegread(symty, GetSpecialRegFromSt(symbol));
+  offset += symbol->IsLocal() ? memlayout->sym_alloc_table[symbol->GetStIndex()].offset
+                              : globmemlayout->sym_alloc_table[symbol->GetStIndex()].offset;
+  return (offset == 0) ? rrn : mirBuilder->CreateExprBinary(OP_add,
+                                                            expr->GetPrimType(),
+                                                            rrn,
+                                                            mirBuilder->GetConstInt(offset));}
+
+BaseNode *LMBCLowerer::LowerDread(AddrofNode *expr) {
+  MIRSymbol *symbol = func->GetLocalOrGlobalSymbol(expr->GetStIdx());
+  ASSERT_NOT_NULL(symbol);
+  symbol->ResetIsDeleted();
+  PrimType symty = symbol->GetType()->GetPrimType();
+  int32 offset = 0;
+  if (expr->GetFieldID() != 0) {
+    MIRStructType *structty = static_cast<MIRStructType *>(symbol->GetType());
+    FieldPair thepair = structty->TraverseToField(expr->GetFieldID());
+    symty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(thepair.second.first)->GetPrimType();
+    offset = becommon->GetFieldOffset(*structty, expr->GetFieldID()).first;
+  }
+  if (!symbol->LMBCAllocateOffSpecialReg()) {
+    BaseNode *base = mirBuilder->CreateExprDreadoff(OP_addrofoff, GetLoweredPtrType(), *symbol, 0);
+    IreadoffNode *ireadoff = mirBuilder->CreateExprIreadoff(symty, offset, base);
+    if (GetPrimTypeSize(ireadoff->GetPrimType()) == GetPrimTypeSize(expr->GetPrimType())) {
+      return ireadoff;
+    }
+    return mirBuilder->CreateExprTypeCvt(OP_cvt, expr->GetPrimType(), GetRegPrimType(ireadoff->GetPrimType()),
+                                         *ireadoff);
+  }
+  PregIdx spcreg = GetSpecialRegFromSt(symbol);
+  if (spcreg == -kSregFp) {
+    CHECK_FATAL(symbol->IsLocal(), "load from fp non local?");
+    IreadFPoffNode *ireadoff = mirBuilder->CreateExprIreadFPoff(
+        symty, memlayout->sym_alloc_table[symbol->GetStIndex()].offset + offset);
+    if (GetPrimTypeSize(ireadoff->GetPrimType()) == GetPrimTypeSize(expr->GetPrimType())) {
+      return ireadoff;
+    }
+    return mirBuilder->CreateExprTypeCvt(OP_cvt, expr->GetPrimType(), GetRegPrimType(ireadoff->GetPrimType()),
+                                         *ireadoff);
+  } else {
+    BaseNode *rrn = mirBuilder->CreateExprRegread(GetLoweredPtrType(), spcreg);
+    SymbolAlloc &symalloc = symbol->IsLocal() ? memlayout->sym_alloc_table[symbol->GetStIndex()]
+                                              : globmemlayout->sym_alloc_table[symbol->GetStIndex()];
+    IreadoffNode *ireadoff = mirBuilder->CreateExprIreadoff(symty, symalloc.offset + offset, rrn);
+    if (GetPrimTypeSize(ireadoff->GetPrimType()) == GetPrimTypeSize(expr->GetPrimType())) {
+      return ireadoff;
+    }
+    return mirBuilder->CreateExprTypeCvt(OP_cvt, expr->GetPrimType(), GetRegPrimType(ireadoff->GetPrimType()),
+                                         *ireadoff);
+  }
+}
+
+BaseNode *LMBCLowerer::LowerDreadoff(DreadoffNode *dreadoff) {
+  MIRSymbol *symbol = func->GetLocalOrGlobalSymbol(dreadoff->stIdx);
+  ASSERT_NOT_NULL(symbol);
+  symbol->ResetIsDeleted();
+  if (!symbol->LMBCAllocateOffSpecialReg()) {
+    return dreadoff;
+  }
+  PrimType symty = symbol->GetType()->GetPrimType();
+  PregIdx spcreg = GetSpecialRegFromSt(symbol);
+  if (spcreg == -kSregFp) {
+    CHECK_FATAL(symbol->IsLocal(), "load from fp non local?");
+    IreadFPoffNode *ireadoff = mirBuilder->CreateExprIreadFPoff(
+        symty, memlayout->sym_alloc_table[symbol->GetStIndex()].offset + dreadoff->offset);
+    return ireadoff;
+  } else {
+    BaseNode *rrn = mirBuilder->CreateExprRegread(GetLoweredPtrType(), spcreg);
+    SymbolAlloc &symalloc = symbol->IsLocal() ? memlayout->sym_alloc_table[symbol->GetStIndex()]
+                                              : globmemlayout->sym_alloc_table[symbol->GetStIndex()];
+    IreadoffNode *ireadoff = mirBuilder->CreateExprIreadoff(symty, symalloc.offset + dreadoff->offset, rrn);
+    return ireadoff;
+  }
+}
+
+static MIRType *GetPointedToType(const MIRPtrType *pointerty) {
+  MIRType *atype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerty->GetPointedTyIdx());
+  if (atype->GetKind() == kTypeArray) {
+    MIRArrayType *arraytype = static_cast<MIRArrayType *>(atype);
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(arraytype->GetElemTyIdx());
+  }
+  if (atype->GetKind() == kTypeFArray || atype->GetKind() == kTypeJArray) {
+    MIRFarrayType *farraytype = static_cast<MIRFarrayType *>(atype);
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(farraytype->GetElemTyIdx());
+  }
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerty->GetPointedTyIdx());
+}
+
+BaseNode *LMBCLowerer::LowerIread(IreadNode *expr) {
+  int32 offset = 0;
+  MIRPtrType *ptrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(expr->GetTyIdx()));
+  MIRType *type = ptrType->GetPointedType();
+  if (expr->GetFieldID() != 0) {
+    MIRStructType *structty = static_cast<MIRStructType *>(type);
+    offset = becommon->GetFieldOffset(*structty, expr->GetFieldID()).first;
+    type = structty->GetFieldType(expr->GetFieldID());
+  }
+  BaseNode *ireadoff = mirBuilder->CreateExprIreadoff(type->GetPrimType(), offset, expr->Opnd(0));
+  if (GetPrimTypeSize(ireadoff->GetPrimType()) == GetPrimTypeSize(expr->GetPrimType())) {
+    return ireadoff;
+  }
+  return mirBuilder->CreateExprTypeCvt(OP_cvt, expr->GetPrimType(), GetRegPrimType(ireadoff->GetPrimType()), *ireadoff);
+}
+
+BaseNode *LMBCLowerer::LowerIaddrof(IaddrofNode *expr) {
+  int32 offset = 0;
+  if (expr->GetFieldID() != 0) {
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(expr->GetTyIdx());
+    MIRStructType *structty =
+        static_cast<MIRStructType*>(
+            GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<MIRPtrType*>(type)->GetPointedTyIdx()));
+    offset = becommon->GetFieldOffset(*structty, expr->GetFieldID()).first;
+  }
+  if (offset == 0) {
+    return expr->Opnd(0);
+  }
+  return mirBuilder->CreateExprBinary(OP_add, expr->GetPrimType(), expr->Opnd(0),
+                                      mirBuilder->CreateIntConst(offset, expr->GetPrimType()));
+}
+
+BaseNode *LMBCLowerer::LowerExpr(BaseNode *expr) {
+  for (size_t i = 0; i < expr->NumOpnds(); ++i) {
+    expr->SetOpnd(LowerExpr(expr->Opnd(i)), i);
+  }
+  switch (expr->GetOpCode()) {
+    case OP_addrof:
+      return LowerAddrof(static_cast<AddrofNode *>(expr));
+    case OP_addrofoff: {
+      MIRSymbol *symbol = func->GetLocalOrGlobalSymbol(static_cast<AddrofoffNode*>(expr)->stIdx);
+      symbol->ResetIsDeleted();
+      CHECK_FATAL(!symbol->LMBCAllocateOffSpecialReg(),
+                  "LMBCLowerer:: illegal addrofoff instruction");
+      break;
+    }
+    case OP_dread:
+      return LowerDread(static_cast<DreadNode *>(expr));
+    case OP_dreadoff:
+      return LowerDreadoff(static_cast<DreadoffNode *>(expr));
+    case OP_iread:
+      return LowerIread(static_cast<IreadNode *>(expr));
+    case OP_iaddrof:
+      return LowerIaddrof(static_cast<IreadNode *>(expr));
+    default:
+      break;
+  }
+  return expr;
+}
+
+// lower using OP_blkassignoff
+void LMBCLowerer::LowerAggDassign(const DassignNode *dsnode, MIRType *lhsty,
+                                  int32 offset, BlockNode *newblk) {
+  BaseNode *rhs = dsnode->Opnd(0);
+  CHECK_FATAL(rhs->GetOpCode() == OP_dread || rhs->GetOpCode() == OP_iread,
+              "LowerAggDassign: rhs inconsistent");
+  // change rhs to address of rhs
+  if (rhs->GetOpCode() == OP_dread) {
+    rhs->SetOpCode(OP_addrof);
+  } else {  // OP_iread
+    rhs->SetOpCode(OP_iaddrof);
+  }
+  rhs->SetPrimType(GetLoweredPtrType());
+  // generate lhs address expression
+  BaseNode *lhs = nullptr;
+  MIRSymbol *symbol = func->GetLocalOrGlobalSymbol(dsnode->GetStIdx());
+  ASSERT_NOT_NULL(symbol);
+  symbol->ResetIsDeleted();
+  if (!symbol->LMBCAllocateOffSpecialReg()) {
+    lhs = mirBuilder->CreateExprDreadoff(OP_addrofoff, GetLoweredPtrType(), *symbol, offset);
+  } else {
+    lhs = mirBuilder->CreateExprRegread(GetLoweredPtrType(), GetSpecialRegFromSt(symbol));
+    SymbolAlloc &symalloc = symbol->IsLocal() ? memlayout->sym_alloc_table[symbol->GetStIndex()]
+                                              : globmemlayout->sym_alloc_table[symbol->GetStIndex()];
+    offset = symalloc.offset + offset;
+  }
+  // generate the blkassignoff
+  BlkassignoffNode *bass = mirModule->CurFuncCodeMemPool()->New<BlkassignoffNode>(offset, lhsty->GetSize());
+  bass->SetAlign(lhsty->GetAlign());
+  bass->SetBOpnd(lhs, 0);
+  bass->SetBOpnd(LowerExpr(rhs), 1);
+  newblk->AddStatement(bass);
+}
+
+void LMBCLowerer::LowerDassign(DassignNode *dsnode, BlockNode *newblk) {
+  MIRSymbol *symbol = func->GetLocalOrGlobalSymbol(dsnode->GetStIdx());
+  symbol->ResetIsDeleted();
+  MIRType *symty = symbol->GetType();
+  int32 offset = 0;
+  if (dsnode->GetFieldID() != 0) {
+    MIRStructType *structty = static_cast<MIRStructType *>(symbol->GetType());
+    ASSERT_NOT_NULL(structty);
+    FieldPair thepair = structty->TraverseToField(dsnode->GetFieldID());
+    symty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(thepair.second.first);
+    offset = becommon->GetFieldOffset(*structty, dsnode->GetFieldID()).first;
+  }
+  BaseNode *rhs = LowerExpr(dsnode->Opnd(0));
+  if (rhs->GetPrimType() != PTY_agg || rhs->GetOpCode() == OP_regread) {
+    PrimType ptypUsed = symty->GetPrimType();
+    if (ptypUsed == PTY_agg) {
+      ptypUsed = rhs->GetPrimType();
+    }
+    if (!symbol->LMBCAllocateOffSpecialReg()) {
+      BaseNode *base = mirBuilder->CreateExprDreadoff(OP_addrofoff, GetLoweredPtrType(), *symbol, 0);
+      IassignoffNode *iassignoff = mirBuilder->CreateStmtIassignoff(ptypUsed,
+                                                                    offset, base, rhs);
+      newblk->AddStatement(iassignoff);
+      return;
+    }
+    PregIdx spcreg = GetSpecialRegFromSt(symbol);
+    if (spcreg == -kSregFp) {
+      IassignFPoffNode *iassignoff = mirBuilder->CreateStmtIassignFPoff(OP_iassignfpoff,
+          ptypUsed,
+          memlayout->sym_alloc_table[symbol->GetStIndex()].offset + offset, rhs);
+      newblk->AddStatement(iassignoff);
+    } else {
+      BaseNode *rrn = mirBuilder->CreateExprRegread(GetLoweredPtrType(), spcreg);
+      SymbolAlloc &symalloc = symbol->IsLocal() ?
+          memlayout->sym_alloc_table[symbol->GetStIndex()] :
+          globmemlayout->sym_alloc_table[symbol->GetStIndex()];
+      IassignoffNode *iassignoff = mirBuilder->CreateStmtIassignoff(ptypUsed,
+                                                                    symalloc.offset + offset,
+                                                                    rrn,
+                                                                    rhs);
+      newblk->AddStatement(iassignoff);
+    }
+  } else {
+    LowerAggDassign(dsnode, symty, offset, newblk);
+  }
+}
+
+void LMBCLowerer::LowerDassignoff(DassignoffNode *dsnode, BlockNode *newblk) {
+  MIRSymbol *symbol = func->GetLocalOrGlobalSymbol(dsnode->stIdx);
+  ASSERT_NOT_NULL(symbol);
+  symbol->ResetIsDeleted();
+  CHECK_FATAL(dsnode->Opnd(0)->GetPrimType() != PTY_agg, "LowerDassignoff: agg primitive type NYI");
+  BaseNode *rhs = LowerExpr(dsnode->Opnd(0));
+  if (!symbol->LMBCAllocateOffSpecialReg()) {
+    newblk->AddStatement(dsnode);
+    return;
+  }
+  PregIdx spcreg = GetSpecialRegFromSt(symbol);
+  if (spcreg == -kSregFp) {
+    IassignFPoffNode *iassignoff = mirBuilder->CreateStmtIassignFPoff(OP_iassignfpoff,
+        dsnode->GetPrimType(),
+        memlayout->sym_alloc_table[symbol->GetStIndex()].offset + dsnode->offset, rhs);
+    newblk->AddStatement(iassignoff);
+  } else {
+    BaseNode *rrn = mirBuilder->CreateExprRegread(GetLoweredPtrType(), spcreg);
+    SymbolAlloc &symalloc = symbol->IsLocal() ? memlayout->sym_alloc_table[symbol->GetStIndex()]
+                                              : globmemlayout->sym_alloc_table[symbol->GetStIndex()];
+    IassignoffNode *iassignoff =
+        mirBuilder->CreateStmtIassignoff(dsnode->GetPrimType(),
+                                         symalloc.offset + dsnode->offset, rrn, rhs);
+    newblk->AddStatement(iassignoff);
+  }
+}
+  // lower using OP_blkassignoff
+void LMBCLowerer::LowerAggIassign(IassignNode *iassign, MIRType *lhsty,
+                                  int32 offset, BlockNode *newblk) {
+  BaseNode *rhs = iassign->rhs;
+  CHECK_FATAL(rhs->GetOpCode() == OP_dread || rhs->GetOpCode() == OP_iread ||
+              rhs->GetOpCode() == OP_ireadoff || rhs->GetOpCode() == OP_ireadfpoff,
+              "LowerAggIassign: rhs inconsistent");
+  // change rhs to address of rhs
+  switch (rhs->GetOpCode()) {
+    case OP_dread: rhs->SetOpCode(OP_addrof); break;
+    case OP_iread: rhs->SetOpCode(OP_iaddrof); break;
+    case OP_ireadoff: {
+      IreadoffNode *ireadoff = static_cast<IreadoffNode*>(rhs);
+      rhs = mirBuilder->CreateExprBinary(OP_add, GetLoweredPtrType(), rhs->Opnd(0),
+                                         mirBuilder->GetConstInt(ireadoff->GetOffset()));
+      break;
+    }
+    case OP_ireadfpoff: {
+      IreadFPoffNode *ireadfpoff = static_cast<IreadFPoffNode*>(rhs);
+      rhs = mirBuilder->CreateExprBinary(OP_add, GetLoweredPtrType(),
+                                         mirBuilder->CreateExprRegread(GetLoweredPtrType(), -kSregFp),
+                                         mirBuilder->GetConstInt(ireadfpoff->GetOffset()));
+      break;
+    }
+    default: ;
+  }
+  rhs->SetPrimType(GetLoweredPtrType());
+  // generate the blkassignoff
+  BlkassignoffNode *bass = mirModule->CurFuncCodeMemPool()->New<BlkassignoffNode>(offset,
+                                                                                  lhsty->GetSize());
+  bass->SetAlign(lhsty->GetAlign());
+  bass->SetBOpnd(iassign->addrExpr, 0);
+  bass->SetBOpnd(rhs, 1);
+  newblk->AddStatement(bass);
+}
+
+void LMBCLowerer::LowerIassign(IassignNode *iassign, BlockNode *newblk) {
+  iassign->addrExpr = LowerExpr(iassign->Opnd(0));
+  iassign->rhs = LowerExpr(iassign->GetRHS());
+  int32 offset = 0;
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iassign->GetTyIdx());
+  MIRPtrType *pointerty = static_cast<MIRPtrType *>(type);
+  if (iassign->GetFieldID() != 0) {
+    MIRStructType *structty = static_cast<MIRStructType *>(
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointerty->GetPointedTyIdx()));
+    offset = becommon->GetFieldOffset(*structty, iassign->GetFieldID()).first;
+    TyIdx ftyidx = structty->TraverseToField(iassign->GetFieldID()).second.first;
+    type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ftyidx);
+  } else {
+    type = GetPointedToType(pointerty);
+  }
+  if (iassign->GetRHS()->GetPrimType() != PTY_agg) {
+    PrimType ptypused = type->GetPrimType();
+    if (ptypused == PTY_agg) {
+      ptypused = iassign->GetRHS()->GetPrimType();
+    }
+    IassignoffNode *iassignoff = mirBuilder->CreateStmtIassignoff(ptypused,
+                                                                  offset,
+                                                                  iassign->addrExpr,
+                                                                  iassign->rhs);
+    newblk->AddStatement(iassignoff);
+  } else {
+    LowerAggIassign(iassign, type, offset, newblk);
+  }
+}
+
+// called only if the return has > 1 operand; assume prior lowering already
+// converted any return of structs to be via fake parameter
+void LMBCLowerer::LowerReturn(NaryStmtNode *retNode, BlockNode *newblk) {
+  if (retNode->Opnd(0)->GetPrimType() != PTY_agg) {
+    CHECK_FATAL(retNode->NumOpnds() <= 2, "LMBCLowerer::LowerReturn: more than 2 return values NYI");
+    for (size_t i = 0; i < retNode->NumOpnds(); ++i) {
+      // insert regassign for the returned value
+      PrimType ptyp = retNode->Opnd(i)->GetPrimType();
+      BaseNode *rhs = LowerExpr(retNode->Opnd(i));
+      RegassignNode *regasgn = mirBuilder->CreateStmtRegassign(ptyp,
+                                                               i == 0 ? -kSregRetval0 : -kSregRetval1,
+                                                               rhs);
+      newblk->AddStatement(regasgn);
+    }
+  } else {  // handle return of small struct using only %%retval0
+    BaseNode *rhs = LowerExpr(retNode->Opnd(0));
+    RegassignNode *regasgn = mirBuilder->CreateStmtRegassign(PTY_agg, -kSregRetval0, rhs);
+    newblk->AddStatement(regasgn);
+  }
+  retNode->GetNopnd().clear();  // remove the return operands
+  retNode->SetNumOpnds(0);
+  newblk->AddStatement(retNode);
+}
+
+void LMBCLowerer::LowerCall(NaryStmtNode *stmt, BlockNode *newblk) {
+  for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+    if (stmt->Opnd(i)->GetPrimType() != PTY_agg) {
+      stmt->SetOpnd(LowerExpr(stmt->Opnd(i)), i);
+      continue;
+    }
+    bool paramInPrototype = false;
+    if (stmt->GetOpCode() != OP_asm) {
+      MIRFuncType *funcType = nullptr;
+      if (stmt->GetOpCode() == OP_icallproto) {
+        IcallNode *icallproto = static_cast<IcallNode*>(stmt);
+        funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(icallproto->GetRetTyIdx()));
+        paramInPrototype = (i - 1) < funcType->GetParamTypeList().size();
+      } else {
+        CallNode *callNode = static_cast<CallNode*>(stmt);
+        MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+        funcType = calleeFunc->GetMIRFuncType();
+        paramInPrototype = i < funcType->GetParamTypeList().size();
+      }
+    }
+    if (paramInPrototype) {
+      stmt->SetOpnd(LowerExpr(stmt->Opnd(i)), i);
+      continue;
+    }
+    // lower to iread so the type can be provided
+    if (stmt->Opnd(i)->GetOpCode() ==  OP_iread) {
+      IreadNode *iread = static_cast<IreadNode *>(stmt->Opnd(i));
+      iread->SetOpnd(LowerExpr(iread->Opnd(0)), 0);
+    } else if (stmt->Opnd(i)->GetOpCode() ==  OP_dread) {
+      AddrofNode *addrof = static_cast<AddrofNode *>(stmt->Opnd(i));
+      FieldID fid = addrof->GetFieldID();
+      addrof->SetOpCode(OP_addrof);
+      addrof->SetPrimType(GetExactPtrPrimType());
+      addrof->SetFieldID(0);
+      MIRSymbol *symbol = func->GetLocalOrGlobalSymbol(addrof->GetStIdx());
+      ASSERT_NOT_NULL(symbol);
+      MIRPtrType ptrType(symbol->GetTyIdx(), GetExactPtrPrimType());
+      ptrType.SetTypeAttrs(symbol->GetAttrs());
+      TyIdx addrTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+      if (addrTyIdx == becommon->GetSizeOfTypeSizeTable()) {
+        MIRType *newType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(addrTyIdx);
+        becommon->UpdateTypeTable(*newType);
+      }
+      IreadNode *newIread = mirModule->CurFuncCodeMemPool()->New<IreadNode>(
+          OP_iread, PTY_agg, addrTyIdx, fid, LowerExpr(addrof));
+      stmt->SetOpnd(newIread, i);
+    }
+  }
+  newblk->AddStatement(stmt);
+}
+
+void LMBCLowerer::FixPrototype4FirstArgReturn(IcallNode *icall) {
+  MIRFuncType *ftype = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(icall->GetRetTyIdx()));
+  if (!ftype->FirstArgReturn()) {
+    return;
+  }
+  MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ftype->GetRetTyIdx());
+  if (retType->GetPrimType() == PTY_void) {
+    return;
+  }
+  // insert return type as fake first parameter
+  size_t oldSize = ftype->GetParamTypeList().size();
+  ftype->GetParamTypeList().emplace_back(TyIdx(0));
+  ftype->GetParamAttrsList().emplace_back(TypeAttrs());
+  for (size_t i = oldSize; i > 0; i--) {
+    ftype->GetParamTypeList()[i] = ftype->GetParamTypeList()[i - 1];
+    ftype->GetParamAttrsList()[i] = ftype->GetParamAttrsList()[i - 1];
+  }
+  MIRType *newType = GlobalTables::GetTypeTable().GetOrCreatePointerType(
+      ftype->GetRetTyIdx(), GetExactPtrPrimType(), ftype->GetRetAttrs());
+  ftype->GetParamTypeList()[0] = newType->GetTypeIndex();
+  ftype->GetParamAttrsList()[0] = TypeAttrs();
+  // change return type to void
+  ftype->SetRetTyIdx(GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex());
+  ftype->SetRetAttrs(TypeAttrs());
+}
+
+BlockNode *LMBCLowerer::LowerBlock(BlockNode *block) {
+  BlockNode *newblk = mirModule->CurFuncCodeMemPool()->New<BlockNode>();
+  if (!block->GetFirst()) {
+    return newblk;
+  }
+  StmtNode *nextstmt = block->GetFirst();
+  do {
+    StmtNode *stmt = nextstmt;
+    if (stmt == block->GetLast()) {
+      nextstmt = nullptr;
+    } else {
+      nextstmt = stmt->GetNext();
+    }
+    stmt->SetNext(nullptr);
+    switch (stmt->GetOpCode()) {
+      case OP_dassign: {
+        LowerDassign(static_cast<DassignNode*>(stmt), newblk);
+        break;
+      }
+      case OP_dassignoff: {
+        LowerDassignoff(static_cast<DassignoffNode*>(stmt), newblk);
+        break;
+      }
+      case OP_iassign: {
+        LowerIassign(static_cast<IassignNode*>(stmt), newblk);
+        break;
+      }
+      case OP_return: {
+        NaryStmtNode *retNode = static_cast<NaryStmtNode*>(stmt);
+        if (retNode->GetNopndSize() == 0) {
+          newblk->AddStatement(stmt);
+        } else {
+          LowerReturn(retNode, newblk);
+        }
+        break;
+      }
+      case OP_icallproto:
+        FixPrototype4FirstArgReturn(static_cast<IcallNode *>(stmt));
+        // fall thru
+      case OP_asm:
+      case OP_call: {
+        LowerCall(static_cast<NaryStmtNode*>(stmt), newblk);
+        break;
+      }
+      default: {
+        for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+          stmt->SetOpnd(LowerExpr(stmt->Opnd(i)), i);
+        }
+        newblk->AddStatement(stmt);
+        break;
+      }
+    }
+  } while (nextstmt != nullptr);
+  return newblk;
+}
+
+void LMBCLowerer::LowerFunction() {
+  // set extern global vars' isDeleted field; will reset when visited
+  MapleVector<StIdx>::const_iterator sit = mirModule->GetSymbolDefOrder().begin();
+  for (; sit != mirModule->GetSymbolDefOrder().end(); ++sit) {
+    MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx(sit->Idx());
+    ASSERT_NOT_NULL(s);
+    if (s->GetSKind() == kStVar && s->GetStorageClass() == kScExtern && !s->HasPotentialAssignment()) {
+      s->SetIsDeleted();
+    }
+  }
+
+  BlockNode *origbody = func->GetBody();
+  BlockNode *newbody = LowerBlock(origbody);
+  func->SetBody(newbody);
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/lmbc_memlayout.cpp b/src/mapleall/maple_me/src/lmbc_memlayout.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e89a40d7b62bafc2580d034d05cc73192f04c3ca
--- /dev/null
+++ b/src/mapleall/maple_me/src/lmbc_memlayout.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+// For each function being compiled, lay out its local variables on its stack
+// frame.  Allocate all the global variables within the global memory block
+// which is addressed via offset from the global pointer GP during execution.
+// Allocate this block pointed to by mirModule.globalBlkMap.
+
+#include "lmbc_memlayout.h"
+#include "mir_symbol.h"
+
+namespace maple {
+
+constexpr size_t kVarargSaveAreaSize = 192;
+
+void LMBCMemLayout::LayoutStackFrame(void) {
+  if (func->IsVarargs()) {
+    seg_FPbased.size -= kVarargSaveAreaSize;
+  }
+
+  // allocate the local variables
+  uint32 symtabsize = func->GetSymTab()->GetSymbolTableSize();
+  for (uint32 i = 0; i < symtabsize; i++) {
+    MIRSymbol *sym = func->GetSymTab()->GetSymbolFromStIdx(i);
+    if (!sym) {
+      continue;
+    }
+    if (sym->IsDeleted()) {
+      continue;
+    }
+    if (sym->GetStorageClass() == kScPstatic && sym->LMBCAllocateOffSpecialReg()) {
+      uint32 stindex = sym->GetStIndex();
+      sym_alloc_table[stindex].mem_segment = seg_GPbased;
+      seg_GPbased->size = maplebe::RoundUp(seg_GPbased->size, sym->GetType()->GetAlign());
+      sym_alloc_table[stindex].offset = seg_GPbased->size;
+      seg_GPbased->size += sym->GetType()->GetSize();
+    }
+    if (sym->GetStorageClass() != kScAuto) {
+      continue;
+    }
+    uint32 stindex = sym->GetStIndex();
+    sym_alloc_table[stindex].mem_segment = &seg_FPbased;
+    seg_FPbased.size -= sym->GetType()->GetSize();
+    seg_FPbased.size = maplebe::RoundDown(seg_FPbased.size, sym->GetType()->GetAlign());
+    sym_alloc_table[stindex].offset = seg_FPbased.size;
+  }
+}
+
+GlobalMemLayout::GlobalMemLayout(MIRModule *mod, MapleAllocator *mallocator) :
+    seg_GPbased(MS_GPbased), sym_alloc_table(mallocator->Adapter()), mirModule(mod) {
+  uint32 symtabsize = GlobalTables::GetGsymTable().GetSymbolTableSize();
+  sym_alloc_table.resize(symtabsize);
+  MIRSymbol *sym = nullptr;
+  // allocate the global variables ordered based on alignments
+  for (uint32 curalign = 8; curalign != 0; curalign >>= 1) {
+    for (uint32 i = 0; i < symtabsize; i++) {
+      sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
+      if (!sym) {
+        continue;
+      }
+      if (sym->GetStorageClass() != kScGlobal && sym->GetStorageClass() != kScFstatic) {
+        continue;
+      }
+      if (!sym->LMBCAllocateOffSpecialReg()) {
+        continue;
+      }
+      if (sym->GetType()->GetAlign() != curalign) {
+        continue;
+      }
+      uint32 stindex = sym->GetStIndex();
+      sym_alloc_table[stindex].mem_segment = &seg_GPbased;
+      seg_GPbased.size = maplebe::RoundUp(seg_GPbased.size, sym->GetType()->GetAlign());
+      sym_alloc_table[stindex].offset = seg_GPbased.size;
+      seg_GPbased.size += sym->GetType()->GetSize();
+    }
+  }
+  seg_GPbased.size = maplebe::RoundUp(seg_GPbased.size, GetPrimTypeSize(PTY_ptr));
+  mirModule->SetGlobalMemSize(seg_GPbased.size);
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_abco.cpp b/src/mapleall/maple_me/src/me_abco.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4929d481d3081d4d164e06fa78b8d74b923f7e39
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_abco.cpp
@@ -0,0 +1,1107 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_abco.h"
+#include "me_loop_analysis.h"
+
+// This phase removes redundant array bounds checks.
+// ABCD: Eliminating Array Bounds Checks on Demand.
+// Rastislav Bodik, Rajiv Gupta, Vivek Sarkar.
+namespace maple {
+bool MeABC::isDebug = false;
+constexpr int kNumOpnds = 2;
+constexpr int kPiListSize = 2;
+
+void MeABC::AddEdgePair(ESSABaseNode &from, ESSABaseNode &to, int64 value, EdgeType type) {
+  InequalEdge *pairEdge1 = inequalityGraph->AddEdge(from, to, value, type);
+  InequalEdge *pairEdge2 = inequalityGraph->AddEdge(to, from, -value, type);
+  CHECK_FATAL(pairEdge1, "pairEdge1 is nullptr!");
+  CHECK_FATAL(pairEdge2, "pairEdge2 is nullptr!");
+  pairEdge1->SetPairEdge(*pairEdge2);
+  pairEdge2->SetPairEdge(*pairEdge1);
+}
+
+void MeABC::ABCCollectArrayExpr(MeStmt &meStmt, MeExpr &meExpr, bool isUpdate) {
+  if (meExpr.GetOp() == OP_array) {
+    auto *nMeExpr = static_cast<NaryMeExpr*>(&meExpr);
+    if (nMeExpr->GetBoundCheck()) {
+      if (!isUpdate) {
+        CHECK_FATAL(arrayChecks.find(&meStmt) == arrayChecks.end(), "Must be");
+        arrayChecks[&meStmt] = nMeExpr;
+        CHECK_FATAL(meStmt.GetOp() == OP_dassign || meStmt.GetOp() == OP_iassign ||
+                    meStmt.GetOp() == OP_maydassign, "must be");
+        if (containsBB.find(meStmt.GetBB()) == containsBB.end()) {
+          containsBB[meStmt.GetBB()] = { &meStmt };
+        } else {
+          containsBB[meStmt.GetBB()].push_back(&meStmt);
+        }
+      } else {
+        CHECK_FATAL(arrayNewChecks.find(&meStmt) == arrayNewChecks.end(), "Must be");
+        arrayNewChecks[&meStmt] = nMeExpr;
+      }
+    }
+  }
+  for (int32 i = 0; i < meExpr.GetNumOpnds(); ++i) {
+    ABCCollectArrayExpr(meStmt, *(meExpr.GetOpnd(i)), isUpdate);
+  }
+}
+
+bool MeABC::CollectABC() {
+  auto cfg = meFunc->GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    for (auto &meStmt : (*bIt)->GetMeStmts()) {
+      if (meStmt.GetOp() == OP_callassigned) {
+        auto *callNode = static_cast<CallMeStmt*>(&meStmt);
+        MIRFunction *callFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+        if (callFunc->GetBaseClassName().compare("Ljava_2Flang_2FSystem_3B") == 0 &&
+            callFunc->GetBaseFuncName().compare("arraycopy") == 0) {
+          arrayChecks[&meStmt] = nullptr;
+        }
+      }
+      for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        ABCCollectArrayExpr(meStmt, *(meStmt.GetOpnd(i)));
+      }
+    }
+  }
+  return !arrayChecks.empty();
+}
+
+bool MeABC::IsVirtualVar(const VarMeExpr &var) const {
+  const OriginalSt *ost = var.GetOst();
+  return ost->GetIndirectLev() > 0;
+}
+
+ESSABaseNode *MeABC::GetOrCreateRHSNode(MeExpr &expr) {
+  auto &rhs = static_cast<VarMeExpr&>(expr);
+  ESSABaseNode *result = nullptr;
+  if (rhs.GetDefBy() != kDefByPhi) {
+    result = inequalityGraph->GetOrCreateVarNode(rhs);
+  } else {
+    MePhiNode *defPhi = &(rhs.GetDefPhi());
+    result = inequalityGraph->GetOrCreatePhiNode(*defPhi);
+  }
+  return result;
+}
+
+void MeABC::BuildPhiInGraph(MePhiNode &phi) {
+  if (!IsPrimitivePureScalar(phi.GetLHS()->GetPrimType())) {
+    MeExpr *varExpr = phi.GetLHS();
+    varExpr = TryToResolveVar(*varExpr, false);
+    if (varExpr != nullptr) {
+      ESSAArrayNode *arrayNode = inequalityGraph->GetOrCreateArrayNode(*(phi.GetLHS()));
+      ESSAVarNode *varNode = inequalityGraph->GetOrCreateVarNode(*varExpr);
+      AddEdgePair(*arrayNode, *varNode, 0, EdgeType::kUpper);
+    }
+    return;
+  }
+  VarMeExpr *lhsExpr = static_cast<VarMeExpr*>(phi.GetLHS());
+  if (lhsExpr != nullptr && IsVirtualVar(*lhsExpr)) {
+    return;
+  }
+  for (auto *phiRHS : phi.GetOpnds()) {
+    AddUseDef(*phiRHS);
+  }
+}
+
+void MeABC::BuildSoloPiInGraph(const PiassignMeStmt &piMeStmt) {
+  VarMeExpr *piLHS = piMeStmt.GetLHS();
+  VarMeExpr *piRHS = piMeStmt.GetRHS();
+  AddUseDef(*piRHS);
+  ESSAVarNode *piLHSNode = inequalityGraph->GetOrCreateVarNode(*piLHS);
+  ESSABaseNode *piRHSNode = GetOrCreateRHSNode(*piRHS);
+  (void)inequalityGraph->AddEdge(*piRHSNode, *piLHSNode, 0, EdgeType::kUpper);
+  (void)inequalityGraph->AddEdge(*piLHSNode, *piRHSNode, 0, EdgeType::kLower);
+}
+
+bool MeABC::PiExecuteBeforeCurrentCheck(const PiassignMeStmt &piMeStmt) {
+  BB *currentCheckBB = currentCheck->GetBB();
+  const BB *piBB = piMeStmt.GetBB();
+  if (currentCheckBB != piBB) {
+    return dom->Dominate(*piBB, *currentCheckBB);
+  }
+  const MeStmt *lastMeStmt = piBB->GetLastMe();
+  ASSERT_NOT_NULL(lastMeStmt);
+  CHECK_FATAL(lastMeStmt->GetNextMeStmt() == nullptr, "must be");
+  MeStmt *tmpMeStmt = piMeStmt.GetNextMeStmt();
+  while (tmpMeStmt != nullptr) {
+    if (tmpMeStmt == currentCheck) {
+      return true;
+    }
+    tmpMeStmt = tmpMeStmt->GetNextMeStmt();
+  }
+  return false;
+}
+
+bool MeABC::BuildArrayCheckInGraph(MeStmt &meStmt) {
+  CHECK_FATAL(meStmt.GetOp() == OP_piassign, "must be");
+  auto *piMeStmt = static_cast<PiassignMeStmt*>(&meStmt);
+  BuildSoloPiInGraph(*piMeStmt);
+  if (!PiExecuteBeforeCurrentCheck(*piMeStmt)) {
+    return true;
+  }
+  MeStmt *generatedByMeStmt = piMeStmt->GetGeneratedBy();
+  CHECK_FATAL(arrayChecks.find(generatedByMeStmt) != arrayChecks.end(), "must be");
+  NaryMeExpr *arrCheck = arrayChecks[generatedByMeStmt];
+  MeExpr *opnd1 = arrCheck->GetOpnd(0);
+  MeExpr *opnd2 = arrCheck->GetOpnd(1);
+  CHECK_FATAL(opnd1->GetMeOp() == kMeOpVar, "must be");
+  CHECK_FATAL(opnd1->GetPrimType() == PTY_ref, "must be");
+  CHECK_FATAL(opnd2->GetMeOp() == kMeOpVar, "must be");
+  AddUseDef(*opnd1);
+  VarMeExpr *piLHS = piMeStmt->GetLHS();
+  ESSAArrayNode *arrayNode = inequalityGraph->GetOrCreateArrayNode(*opnd1);
+  ESSAVarNode *piLHSNode = inequalityGraph->GetOrCreateVarNode(*piLHS);
+  (void)inequalityGraph->AddEdge(*arrayNode, *piLHSNode, -1, EdgeType::kNone);
+  (void)inequalityGraph->AddEdge(*piLHSNode, *(inequalityGraph->GetOrCreateConstNode(0)), 0, EdgeType::kNone);
+  return true;
+}
+
+Opcode TransCmpOp(Opcode cmpOp, Opcode brOp) {
+  if (brOp == OP_brtrue) {
+    return cmpOp;
+  }
+  switch (cmpOp) {
+    case OP_ge:
+      return OP_lt;
+    case OP_le:
+      return OP_gt;
+    case OP_lt:
+      return OP_ge;
+    case OP_gt:
+      return OP_le;
+    case OP_ne:
+      return OP_eq;
+    case OP_eq:
+      return OP_ne;
+    default:
+      CHECK_FATAL(false, "must be");
+  }
+}
+
+bool MeABC::BuildBrMeStmtInGraph(MeStmt &meStmt) {
+  auto *brMeStmt = static_cast<CondGotoMeStmt*>(&meStmt);
+  BB *brBB = brMeStmt->GetBB();
+  BB *brTarget = brBB->GetSucc(1);
+  BB *brFallThru = brBB->GetSucc(0);
+  CHECK_FATAL(brMeStmt->GetOffset() == brTarget->GetBBLabel(), "must be");
+  MapleMap<BB*, std::vector<PiassignMeStmt*>> &brTargetPiBBList = brTarget->GetPiList();
+  MapleMap<BB*, std::vector<PiassignMeStmt*>> &brFallThruPiBBList = brFallThru->GetPiList();
+  if (brTargetPiBBList.find(brBB) == brTargetPiBBList.end()) {
+    return false;
+  }
+  for (PiassignMeStmt* piMeStmt : brTargetPiBBList[brBB]) {
+    BuildSoloPiInGraph(*piMeStmt);
+  }
+  for (PiassignMeStmt* piMeStmt : brFallThruPiBBList[brBB]) {
+    BuildSoloPiInGraph(*piMeStmt);
+  }
+  std::vector<PiassignMeStmt*> &brTargetPiList = brTargetPiBBList[brBB];
+  std::vector<PiassignMeStmt*> &brFallThruPiList = brFallThruPiBBList[brBB];
+  ESSABaseNode *brTargetOpnd1 = nullptr;
+  ESSABaseNode *brTargetOpnd2 = nullptr;
+  ESSABaseNode *brFallThruOpnd1 = nullptr;
+  ESSABaseNode *brFallThruOpnd2 = nullptr;
+  auto *opMeExpr = static_cast<OpMeExpr*>(brMeStmt->GetOpnd());
+  MeExpr *opOpnd1 = opMeExpr->GetOpnd(0);
+  MeExpr *opOpnd2 = opMeExpr->GetOpnd(1);
+  if (brTargetPiList.size() == kPiListSize) {
+    brTargetOpnd1 = inequalityGraph->GetOrCreateVarNode(*brTargetPiList[0]->GetLHS());
+    brTargetOpnd2 = inequalityGraph->GetOrCreateVarNode(*brTargetPiList[1]->GetLHS());
+    brFallThruOpnd1 = inequalityGraph->GetOrCreateVarNode(*brFallThruPiList.at(0)->GetLHS());
+    brFallThruOpnd2 = inequalityGraph->GetOrCreateVarNode(*brFallThruPiList.at(1)->GetLHS());
+    AddUseDef(*opOpnd1);
+    AddUseDef(*opOpnd2);
+  } else if (opOpnd1->GetMeOp() == kMeOpConst) {
+    brTargetOpnd1 = inequalityGraph->GetOrCreateConstNode(static_cast<ConstMeExpr*>(opOpnd1)->GetExtIntValue());
+    brTargetOpnd2 = inequalityGraph->GetOrCreateVarNode(*brTargetPiList[0]->GetLHS());
+    brFallThruOpnd1 = inequalityGraph->GetOrCreateConstNode(static_cast<ConstMeExpr*>(opOpnd1)->GetExtIntValue());
+    brFallThruOpnd2 = inequalityGraph->GetOrCreateVarNode(*brFallThruPiList.at(0)->GetLHS());
+    AddUseDef(*opOpnd2);
+  } else if (opOpnd2->GetMeOp() == kMeOpConst) {
+    brTargetOpnd1 = inequalityGraph->GetOrCreateVarNode(*brTargetPiList[0]->GetLHS());
+    brTargetOpnd2 = inequalityGraph->GetOrCreateConstNode(static_cast<ConstMeExpr*>(opOpnd2)->GetExtIntValue());
+    brFallThruOpnd1 = inequalityGraph->GetOrCreateVarNode(*brFallThruPiList.at(0)->GetLHS());
+    brFallThruOpnd2 = inequalityGraph->GetOrCreateConstNode(static_cast<ConstMeExpr*>(opOpnd2)->GetExtIntValue());
+    AddUseDef(*opOpnd1);
+  } else {
+    CHECK_FATAL(false, "impossible");
+  }
+  Opcode cmpOp = TransCmpOp(opMeExpr->GetOp(), brMeStmt->GetOp());
+  switch (cmpOp) {
+    case OP_ge: {
+      (void)inequalityGraph->AddEdge(*brTargetOpnd1, *brTargetOpnd2, 0, EdgeType::kNone);
+      (void)inequalityGraph->AddEdge(*brFallThruOpnd2, *brFallThruOpnd1, -1, EdgeType::kNone);
+      break;
+    }
+    case OP_le: {
+      (void)inequalityGraph->AddEdge(*brTargetOpnd2, *brTargetOpnd1, 0, EdgeType::kNone);
+      (void)inequalityGraph->AddEdge(*brFallThruOpnd1, *brFallThruOpnd2, -1, EdgeType::kNone);
+      break;
+    }
+    case OP_lt: {
+      (void)inequalityGraph->AddEdge(*brTargetOpnd2, *brTargetOpnd1, -1, EdgeType::kNone);
+      (void)inequalityGraph->AddEdge(*brFallThruOpnd1, *brFallThruOpnd2, 0, EdgeType::kNone);
+      break;
+    }
+    case OP_gt: {
+      (void)inequalityGraph->AddEdge(*brTargetOpnd1, *brTargetOpnd2, -1, EdgeType::kNone);
+      (void)inequalityGraph->AddEdge(*brFallThruOpnd2, *brFallThruOpnd1, 0, EdgeType::kNone);
+      break;
+    }
+    case OP_ne: {
+      AddEdgePair(*brFallThruOpnd1, *brFallThruOpnd2, 0, EdgeType::kUpper);
+      AddEdgePair(*brFallThruOpnd2, *brFallThruOpnd1, 0, EdgeType::kLower);
+      break;
+    }
+    case OP_eq: {
+      AddEdgePair(*brTargetOpnd1, *brTargetOpnd2, 0, EdgeType::kUpper);
+      AddEdgePair(*brTargetOpnd2, *brTargetOpnd1, 0, EdgeType::kLower);
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "impossible");
+  }
+  return true;
+}
+
+MeExpr *MeABC::TryToResolveVar(MeExpr &expr, bool isConst) {
+  std::set<MePhiNode*> visitedPhi;
+  ConstMeExpr dummyExpr(kInvalidExprID, nullptr, PTY_unknown);
+  MeExpr *tmp = TryToResolveVar(expr, visitedPhi, dummyExpr, isConst);
+  if (tmp != nullptr && tmp != &dummyExpr) {
+    return tmp;
+  }
+  return nullptr;
+}
+
+MeExpr *MeABC::TryToResolveVar(MeExpr &expr, std::set<MePhiNode*> &visitedPhi, MeExpr &dummyExpr, bool isConst) {
+  CHECK_FATAL(expr.GetMeOp() == kMeOpVar, "must be");
+  auto *var = static_cast<VarMeExpr*>(&expr);
+
+  if (var->GetDefBy() == kDefByStmt) {
+    ASSERT_NOT_NULL(var->GetDefStmt());
+    auto *rhs = var->GetDefStmt()->GetRHS();
+    CHECK_NULL_FATAL(rhs);
+    if (isConst && !rhs->IsLeaf()) {
+      return nullptr;
+    }
+    if (isConst && rhs->GetMeOp() == kMeOpConst) {
+      return rhs;
+    }
+    if (!isConst && rhs->GetMeOp() == kMeOpIvar) {
+      return rhs;
+    }
+    if (isConst) {
+      CHECK_FATAL(rhs->GetMeOp() == kMeOpVar, "must be");
+      return TryToResolveVar(*rhs, visitedPhi, dummyExpr, isConst);
+    }
+  }
+
+  if (var->GetDefBy() == kDefByPhi) {
+    MePhiNode *phi = &(var->GetDefPhi());
+    if (visitedPhi.find(phi) != visitedPhi.end()) {
+      return &dummyExpr;
+    }
+    visitedPhi.insert(phi);
+    std::set<MeExpr*> res;
+    for (auto *phiOpnd : phi->GetOpnds()) {
+      MeExpr *tmp = TryToResolveVar(*phiOpnd, visitedPhi, dummyExpr, isConst);
+      if (tmp == nullptr) {
+        return nullptr;
+      }
+      if (tmp != &dummyExpr) {
+        res.insert(tmp);
+      }
+    }
+    if (res.size() == 1) {
+      return *(res.begin());
+    } else if (res.empty()) {
+      return &dummyExpr;
+    }
+  }
+
+  return nullptr;
+}
+
+bool MeABC::BuildAssignInGraph(const MeStmt &meStmt) {
+  MeExpr *lhs = meStmt.GetLHS();
+  MeExpr *rhs = meStmt.GetRHS();
+  CHECK_NULL_FATAL(lhs);
+  CHECK_NULL_FATAL(rhs);
+  if (!lhs->IsLeaf()) {
+    return false;
+  }
+  if (!IsPrimitivePureScalar(lhs->GetPrimType()) && rhs->GetOp() != OP_gcmallocjarray &&
+      rhs->GetPrimType() != PTY_ref) {
+    return false;
+  }
+  if (!rhs->IsLeaf() && rhs->GetMeOp() != kMeOpOp && rhs->GetMeOp() != kMeOpNary && rhs->GetPrimType() != PTY_ref) {
+    return false;
+  }
+  if (rhs->GetMeOp() == kMeOpOp) {
+    auto *opMeExpr = static_cast<OpMeExpr*>(rhs);
+    switch (opMeExpr->GetOp()) {
+      case OP_gcmallocjarray: {
+        ESSAArrayNode *arrLength = inequalityGraph->GetOrCreateArrayNode(*lhs);
+        CHECK_FATAL(opMeExpr->GetNumOpnds() == 1, "must be");
+        ESSABaseNode *rhsNode = nullptr;
+        if (opMeExpr->GetOpnd(0)->GetMeOp() == kMeOpVar) {
+          rhsNode = GetOrCreateRHSNode(*opMeExpr->GetOpnd(0));
+          AddUseDef(*(opMeExpr->GetOpnd(0)));
+          // Try to resolve Var is assigned from Const
+          MeExpr *varExpr = opMeExpr->GetOpnd(0);
+          varExpr = TryToResolveVar(*varExpr, true);
+          if (varExpr != nullptr) {
+            CHECK_FATAL(varExpr->GetMeOp() == kMeOpConst, "must be");
+            ESSAConstNode *constNode = inequalityGraph->GetOrCreateConstNode(
+                static_cast<ConstMeExpr*>(varExpr)->GetExtIntValue());
+            AddEdgePair(*arrLength, *constNode, 0, EdgeType::kNone);
+          } else {
+            AddEdgePair(*arrLength, *rhsNode, 0, EdgeType::kNone);
+          }
+        } else {
+          CHECK_FATAL(opMeExpr->GetOpnd(0)->GetMeOp() == kMeOpConst, "must be");
+          rhsNode = inequalityGraph->GetOrCreateConstNode(
+              static_cast<ConstMeExpr*>(opMeExpr->GetOpnd(0))->GetExtIntValue());
+          AddEdgePair(*arrLength, *rhsNode, 0, EdgeType::kNone);
+        }
+        return true;
+      }
+      case OP_sub: {
+        if (MeOption::conservativeABCO) {
+          return false;
+        }
+        CHECK_FATAL(opMeExpr->GetNumOpnds() == kNumOpnds, "must be");
+        MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+        MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+        if (!opnd1->IsLeaf() || !opnd2->IsLeaf()) {
+          return false;
+        }
+        ESSAVarNode *lhsNode = inequalityGraph->GetOrCreateVarNode(*lhs);
+        if (opnd1->GetMeOp() == kMeOpConst || opnd2->GetMeOp() == kMeOpConst) {
+          if (opnd1->GetMeOp() == kMeOpConst && opnd2->GetMeOp() == kMeOpConst) {
+            CHECK_FATAL(false, "consider this pattern");
+          } else if (opnd2->GetMeOp() == kMeOpConst) {
+            visited.clear();
+            if (!HasRelativeWithLength(*opnd1)) {
+              return false;
+            }
+            ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1);
+            AddUseDef(*opnd1);
+            AddEdgePair(*rhsNode, *lhsNode,
+                -static_cast<ConstMeExpr*>(opnd2)->GetExtIntValue(), EdgeType::kUpper);
+            AddEdgePair(*lhsNode, *rhsNode,
+                static_cast<ConstMeExpr*>(opnd2)->GetExtIntValue(), EdgeType::kLower);
+            return true;
+          }else {
+            // support this pattern later
+            return false;
+          }
+        } else if (opnd1->GetMeOp() == kMeOpVar && opnd2->GetMeOp() == kMeOpVar) {
+          // Try to resolve Var is assigned from Const
+          opnd2 = TryToResolveVar(*opnd2, true);
+          if (opnd2 == nullptr) {
+            return false;
+          }
+          CHECK_FATAL(opnd2->GetMeOp() == kMeOpConst, "must be");
+          visited.clear();
+          if (!HasRelativeWithLength(*opnd1)) {
+            return false;
+          }
+          ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1);
+          AddUseDef(*opnd1);
+          AddEdgePair(*rhsNode, *lhsNode,
+              -static_cast<ConstMeExpr*>(opnd2)->GetExtIntValue(), EdgeType::kUpper);
+          AddEdgePair(*lhsNode, *rhsNode,
+              static_cast<ConstMeExpr*>(opnd2)->GetExtIntValue(), EdgeType::kLower);
+          return true;
+        } else {
+          // support this pattern later
+          return false;
+        }
+        CHECK_FATAL(false, "impossible");
+      }
+      case OP_add: {
+        if (MeOption::conservativeABCO) {
+          return false;
+        }
+        CHECK_FATAL(opMeExpr->GetNumOpnds() == kNumOpnds, "must be");
+        MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+        MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+        if (!opnd1->IsLeaf() || !opnd2->IsLeaf()) {
+          return false;
+        }
+        ESSAVarNode *lhsNode = inequalityGraph->GetOrCreateVarNode(*lhs);
+        if (opnd1->GetMeOp() != kMeOpConst && opnd2->GetMeOp() != kMeOpConst) {
+          CHECK_FATAL(opnd1->GetMeOp() == kMeOpVar, "must be");
+          CHECK_FATAL(opnd2->GetMeOp() == kMeOpVar, "must be");
+          MeExpr *tmpVar = opnd2;
+          tmpVar = TryToResolveVar(*tmpVar, true);
+          if (tmpVar != nullptr) {
+            CHECK_FATAL(tmpVar->GetMeOp() == kMeOpConst, "must be");
+            visited.clear();
+            if (!HasRelativeWithLength(*opnd1)) {
+              return false;
+            }
+            AddUseDef(*opnd1);
+            ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1);
+            AddEdgePair(*rhsNode, *lhsNode,
+                static_cast<ConstMeExpr*>(tmpVar)->GetExtIntValue(), EdgeType::kUpper);
+            AddEdgePair(*lhsNode, *rhsNode,
+                -static_cast<ConstMeExpr*>(tmpVar)->GetExtIntValue(), EdgeType::kLower);
+            return true;
+          }
+          visited.clear();
+          if (HasRelativeWithLength(*opnd1)) {
+            unresolveEdge[std::make_pair(lhs, opnd1)] = opnd2;
+            AddUseDef(*opnd1);
+            AddUseDef(*opnd2);
+          }
+          visited.clear();
+          if (HasRelativeWithLength(*opnd2)) {
+            unresolveEdge[std::make_pair(lhs, opnd2)] = opnd1;
+            AddUseDef(*opnd1);
+            AddUseDef(*opnd2);
+          }
+          return false;
+        }
+        if (opnd1->GetMeOp() == kMeOpConst && opnd2->GetMeOp() == kMeOpConst) {
+          CHECK_FATAL(false, "consider this pattern");
+        } else if (opnd2->GetMeOp() == kMeOpConst) {
+          visited.clear();
+          if (!HasRelativeWithLength(*opnd1)) {
+            return false;
+          }
+          ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1);
+          AddUseDef(*opnd1);
+          AddEdgePair(*rhsNode, *lhsNode,
+              static_cast<ConstMeExpr*>(opnd2)->GetExtIntValue(), EdgeType::kUpper);
+          AddEdgePair(*lhsNode, *rhsNode,
+              -static_cast<ConstMeExpr*>(opnd2)->GetExtIntValue(), EdgeType::kLower);
+          return true;
+        } else {
+          visited.clear();
+          if (!HasRelativeWithLength(*opnd2)) {
+            return false;
+          }
+          ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd2);
+          AddUseDef(*opnd2);
+          AddEdgePair(*rhsNode, *lhsNode,
+              static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue(), EdgeType::kUpper);
+          AddEdgePair(*lhsNode, *rhsNode,
+              -static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue(), EdgeType::kLower);
+          return true;
+        }
+        CHECK_FATAL(false, "impossible");
+      }
+      case OP_band: {
+        CHECK_FATAL(opMeExpr->GetNumOpnds() == kNumOpnds, "must be");
+        MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+        MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+        if (!opnd1->IsLeaf() || !opnd2->IsLeaf()) {
+          return false;
+        }
+        ESSAVarNode *lhsNode = inequalityGraph->GetOrCreateVarNode(*lhs);
+        ESSABaseNode *rhsNode1 = nullptr;
+        ESSABaseNode *rhsNode2 = nullptr;
+        if (IsUnsignedInteger(opnd1->GetPrimType())) {
+          AddUseDef(*opnd1);
+          rhsNode1 = GetOrCreateRHSNode(*opnd1);
+        } else if (opnd1->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue() >= 0) {
+          rhsNode1 = inequalityGraph->GetOrCreateConstNode(static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue());
+        }
+        if (IsUnsignedInteger(opnd2->GetPrimType())) {
+          AddUseDef(*opnd2);
+          rhsNode2 = GetOrCreateRHSNode(*opnd2);
+        } else if (opnd2->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(opnd2)->GetExtIntValue() >= 0) {
+          rhsNode2 = inequalityGraph->GetOrCreateConstNode(static_cast<ConstMeExpr*>(opnd2)->GetExtIntValue());
+        }
+        if (rhsNode1 == nullptr && rhsNode2 == nullptr) {
+          return false;
+        }
+        if (rhsNode1 != nullptr) {
+          (void)inequalityGraph->AddEdge(*rhsNode1, *lhsNode, 0, EdgeType::kUpper);
+        }
+        if (rhsNode2 != nullptr) {
+          (void)inequalityGraph->AddEdge(*rhsNode2, *lhsNode, 0, EdgeType::kUpper);
+        }
+        (void)inequalityGraph->AddEdge(*lhsNode, *(inequalityGraph->GetOrCreateConstNode(0)), 0, EdgeType::kNone);
+        return true;
+      }
+      case OP_div: {
+        if (MeOption::conservativeABCO) {
+          return false;
+        }
+        CHECK_FATAL(opMeExpr->GetNumOpnds() == kNumOpnds, "must be");
+        MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+        MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+        if (!opnd1->IsLeaf() || !opnd2->IsLeaf()) {
+          return false;
+        }
+        if (opnd2->GetMeOp() == kMeOpConst) {
+          if (static_cast<ConstMeExpr*>(opnd2)->GetExtIntValue() > 0) {
+            visited.clear();
+            if (HasRelativeWithLength(*opnd1)) {
+              unresolveEdge[std::make_pair(lhs, nullptr)] = opnd2;
+              AddUseDef(*opnd1);
+            }
+          }
+          return false;
+        }
+        MeExpr *varExpr = opnd2;
+        varExpr = TryToResolveVar(*varExpr, true);
+        if (varExpr != nullptr) {
+          CHECK_FATAL(varExpr->GetMeOp() == kMeOpConst, "must be");
+          if (static_cast<ConstMeExpr*>(varExpr)->GetExtIntValue() > 0) {
+            visited.clear();
+            if (HasRelativeWithLength(*opnd1)) {
+              unresolveEdge[std::make_pair(lhs, nullptr)] = opnd2;
+              AddUseDef(*opnd1);
+            }
+          }
+        }
+        return false;
+      }
+      default:
+        return false;
+    }
+  } else if (rhs->GetMeOp() == kMeOpNary) {
+    auto *nary = static_cast<NaryMeExpr*>(rhs);
+    if (nary->GetIntrinsic() != INTRN_JAVA_ARRAY_LENGTH) {
+      return false;
+    }
+    ESSAVarNode *lhsNode = inequalityGraph->GetOrCreateVarNode(*lhs);
+    CHECK_FATAL(nary->GetOpnds().size() == 1, "must be");
+    MeExpr *array = nary->GetOpnd(0);
+    if (IsPrimitivePureScalar(array->GetPrimType())) {
+      return false;
+    }
+    CHECK_FATAL(array->GetPrimType() == PTY_ref, "must be");
+    AddUseDef(*array);
+    ESSAArrayNode *arrLength = inequalityGraph->GetOrCreateArrayNode(*array);
+    (void)inequalityGraph->AddEdge(*arrLength, *lhsNode, 0, EdgeType::kUpper);
+    (void)inequalityGraph->AddEdge(*lhsNode, *arrLength, 0, EdgeType::kLower);
+    return true;
+  } else if (rhs->GetPrimType() == PTY_ref) {
+    if ((rhs->GetMeOp() != kMeOpVar && rhs->GetMeOp() != kMeOpIvar) || (lhs->GetPrimType() != PTY_ref)) {
+      return false;
+    }
+    ESSAVarNode *ivarNode = inequalityGraph->GetOrCreateVarNode(*rhs);
+    ESSAArrayNode *arrayNode = inequalityGraph->GetOrCreateArrayNode(*lhs);
+    AddEdgePair(*ivarNode, *arrayNode, 0, EdgeType::kUpper);
+    if (rhs->GetMeOp() == kMeOpVar) {
+      AddUseDef(*rhs);
+    }
+    return true;
+  } else {
+    CHECK_FATAL(rhs->GetMeOp() == kMeOpVar || rhs->GetMeOp() == kMeOpConst, "must be");
+    ESSAVarNode *lhsNode = inequalityGraph->GetOrCreateVarNode(*lhs);
+    if (rhs->GetMeOp() == kMeOpVar) {
+      AddUseDef(*rhs);
+      ESSABaseNode *rhsNode = GetOrCreateRHSNode(*rhs);
+      AddEdgePair(*rhsNode, *lhsNode, 0, EdgeType::kUpper);
+      AddEdgePair(*lhsNode, *rhsNode, 0, EdgeType::kLower);
+    } else {
+      ESSAConstNode *rhsNode = inequalityGraph->GetOrCreateConstNode(static_cast<ConstMeExpr*>(rhs)->GetExtIntValue());
+      AddEdgePair(*rhsNode, *lhsNode, 0, EdgeType::kUpper);
+      AddEdgePair(*lhsNode, *rhsNode, 0, EdgeType::kLower);
+    }
+    return true;
+  }
+}
+
+bool MeABC::HasRelativeWithLength(MeExpr &meExpr) {
+  if (MeOption::aggressiveABCO) {
+    return true;
+  }
+  if (meExpr.GetMeOp() != kMeOpVar) {
+    return false;
+  }
+  auto *varOpnd1 = static_cast<VarMeExpr*>(&meExpr);
+  switch (varOpnd1->GetDefBy()) {
+    case kDefByStmt: {
+      MeStmt *meStmt = varOpnd1->GetDefStmt();
+      if (meStmt->GetOp() == OP_dassign) {
+        DassignMeStmt *dassignMeStmt = static_cast<DassignMeStmt*>(meStmt);
+        MeExpr *rhs = dassignMeStmt->GetRHS();
+        if (rhs->GetMeOp() == kMeOpVar) {
+          return HasRelativeWithLength(*rhs);
+        } else if (rhs->GetMeOp() == kMeOpOp && (rhs->GetOp() == OP_add || rhs->GetOp() == OP_sub)) {
+          auto *opMeExpr = static_cast<OpMeExpr*>(rhs);
+          CHECK_FATAL(opMeExpr->GetNumOpnds() == kNumOpnds, "must be");
+          MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+          MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+          return HasRelativeWithLength(*opnd1) || HasRelativeWithLength(*opnd2);
+        }
+      } else if (meStmt->GetOp() == OP_piassign) {
+        PiassignMeStmt *piMeStmt = static_cast<PiassignMeStmt*>(meStmt);
+        if (piMeStmt->GetGeneratedBy()->IsCondBr()) {
+          auto *opMeExpr = static_cast<OpMeExpr*>(piMeStmt->GetGeneratedBy()->GetOpnd(0));
+          MeExpr *opOpnd1 = opMeExpr->GetOpnd(0);
+          MeExpr *opOpnd2 = opMeExpr->GetOpnd(1);
+          return HasRelativeWithLength(*opOpnd1) || HasRelativeWithLength(*opOpnd2);
+        } else {
+          return HasRelativeWithLength(*piMeStmt->GetRHS());
+        }
+      }
+      break;
+    }
+    case kDefByChi: {
+      MeStmt *meStmt = varOpnd1->GetDefChi().GetBase();
+      MeExpr *rhs = meStmt->GetRHS();
+      if (rhs == nullptr || rhs->GetMeOp() != kMeOpNary) {
+        return false;
+      }
+      auto *nary = static_cast<NaryMeExpr*>(rhs);
+      if (nary->GetIntrinsic() != INTRN_JAVA_ARRAY_LENGTH) {
+        return false;
+      }
+      return true;
+    }
+    case kDefByPhi: {
+      MePhiNode &defPhi = varOpnd1->GetDefPhi();
+      if (visited.find(&defPhi) != visited.end()) {
+        return false;
+      }
+      (void)visited.insert(&defPhi);
+      for (MeExpr *expr : defPhi.GetOpnds()) {
+        if (HasRelativeWithLength(*expr)) {
+          return true;
+        }
+      }
+      break;
+    }
+    case kDefByNo:
+    case kDefByMustDef:
+      break;
+  }
+  return false;
+}
+
+bool MeABC::BuildStmtInGraph(MeStmt &meStmt) {
+  bool validInsn = false;
+  switch (meStmt.GetOp()) {
+    case OP_dassign:
+    case OP_maydassign: {
+      validInsn = BuildAssignInGraph(meStmt);
+      break;
+    }
+    case OP_piassign: {
+      validInsn = BuildArrayCheckInGraph(meStmt);
+      break;
+    }
+    case OP_brfalse:
+    case OP_brtrue: {
+      validInsn = BuildBrMeStmtInGraph(meStmt);
+      break;
+    }
+    default:
+      break;
+  }
+  return validInsn;
+}
+void MeABC::AddCareInsn(MeStmt &defS) {
+  MeStmt *defStmt = &defS;
+  if (careMeStmts.find(defStmt) == careMeStmts.end()) {
+    CarePoint *carePoint = GetMemPool()->New<CarePoint>(CarePoint::CareKind::kMeStmt);
+    carePoint->SetMeStmt(*defStmt);
+    carePoints.push_back(carePoint);
+    careMeStmts.insert(defStmt);
+  }
+}
+void MeABC::AddCarePhi(MePhiNode &defP) {
+  MePhiNode *defPhi = &defP;
+  if (careMePhis.find(defPhi) == careMePhis.end()) {
+    CarePoint *carePoint = GetMemPool()->New<CarePoint>(CarePoint::CareKind::kMePhi);
+    carePoint->SetMePhi(*defPhi);
+    carePoints.push_back(carePoint);
+    careMePhis.insert(defPhi);
+  }
+}
+void MeABC::AddUseDef(MeExpr &meExpr) {
+  CHECK_FATAL(meExpr.GetMeOp() == kMeOpVar, "must be");
+  auto *varOpnd1 = static_cast<VarMeExpr*>(&meExpr);
+  switch (varOpnd1->GetDefBy()) {
+    case kDefByStmt: {
+      MeStmt *meStmt = varOpnd1->GetDefStmt();
+      MeStmt *defStmt = meStmt;
+      if (meStmt->GetOp() == OP_piassign) {
+        MeStmt *tmp = static_cast<PiassignMeStmt*>(meStmt)->GetGeneratedBy();
+        if (tmp->IsCondBr()) {
+          defStmt = tmp;
+        }
+      }
+      AddCareInsn(*defStmt);
+      break;
+    }
+    case kDefByChi: {
+      MeStmt *defStmt = varOpnd1->GetDefChi().GetBase();
+      AddCareInsn(*defStmt);
+      break;
+    }
+    case kDefByPhi: {
+      MePhiNode *defPhi = &varOpnd1->GetDefPhi();
+      AddCarePhi(*defPhi);
+      break;
+    }
+    case kDefByNo: {
+      CHECK_FATAL(varOpnd1->IsZeroVersion(), "must be");
+      break;
+    }
+    case kDefByMustDef: {
+      break;
+    }
+  }
+}
+
+void MeABC::CollectCareInsns() {
+  for (auto pair : arrayChecks) {
+    MeStmt *meStmt = pair.first;
+    if (IsCallAssigned(meStmt->GetOp())) {
+      arrayNewChecks[meStmt] = nullptr;
+    }
+    for (size_t i = 0; i < meStmt->NumMeStmtOpnds(); ++i) {
+      ABCCollectArrayExpr(*meStmt, *(meStmt->GetOpnd(i)), true);
+    }
+  }
+  CHECK_FATAL(arrayNewChecks.size() == arrayChecks.size(), "must be");
+}
+
+bool MeABC::ProveGreaterZ(const MeExpr &weight) {
+  ESSABaseNode &zNode = inequalityGraph->GetNode(0);
+  ESSABaseNode *idxNode = &(inequalityGraph->GetNode(weight));
+  bool lowerResult = prove->DemandProve(zNode, *idxNode, kLower);
+  return lowerResult;
+}
+
+void MeABC::ReSolveEdge() {
+  for (auto pair : unresolveEdge) {
+    MeExpr *weight = pair.second;
+    if (!inequalityGraph->HasNode(*weight)) {
+      continue;
+    }
+    if (ProveGreaterZ(*weight)) {
+      MeExpr *lhs = pair.first.first;
+      MeExpr *rhs = pair.first.second;
+      ESSAVarNode *lhsNode = inequalityGraph->GetOrCreateVarNode(*lhs);
+      ESSABaseNode *rhsNode = nullptr;
+      if (rhs != nullptr) {
+        rhsNode = GetOrCreateRHSNode(*rhs);
+      } else {
+        rhsNode = &(inequalityGraph->GetNode(0));
+      }
+      (void)inequalityGraph->AddEdge(*lhsNode, *rhsNode, 0, EdgeType::kNone);
+    }
+  }
+}
+
+void MeABC::BuildInequalityGraph() {
+  for (size_t i = 0; i < carePoints.size(); ++i) {
+    CarePoint *cp = carePoints[i];
+    if (cp->IsCareMeStmt()) {
+      (void)BuildStmtInGraph(*(cp->GetMeStmt()));
+    } else {
+      BuildPhiInGraph(*(cp->GetMePhi()));
+    }
+  }
+  inequalityGraph->ConnectTrivalEdge();
+  ReSolveEdge();
+}
+
+// opnds <= opnd1.length
+bool MeABC::IsLessOrEuqal(const MeExpr &opnd1, const MeExpr &opnd2) {
+  CHECK_FATAL(opnd1.GetMeOp() == kMeOpVar, "must be");
+  CHECK_FATAL(opnd1.GetPrimType() == PTY_ref, "must be");
+  if (!inequalityGraph->HasNode(opnd1)) {
+    return false;
+  }
+  if (opnd2.GetMeOp() == kMeOpVar && !inequalityGraph->HasNode(opnd2)) {
+    return false;
+  }
+  if (prove->IsLessOrEqual(opnd1, opnd2)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void MeABC::FindRedundantABC(MeStmt &meStmt, const NaryMeExpr &naryMeExpr) {
+  MeExpr *opnd1 = naryMeExpr.GetOpnd(0);
+  MeExpr *opnd2 = naryMeExpr.GetOpnd(1);
+  CHECK_FATAL(opnd1->GetMeOp() == kMeOpVar, "must be");
+  CHECK_FATAL(opnd1->GetPrimType() == PTY_ref, "must be");
+  if (!inequalityGraph->HasNode(*opnd1)) {
+    if (MeABC::isDebug) {
+      LogInfo::MapleLogger() << "Array Node Not Found" << '\n';
+      meStmt.Dump(irMap);
+    }
+    return;
+  }
+  if (opnd2->GetMeOp() == kMeOpVar && !inequalityGraph->HasNode(*opnd2)) {
+    if (MeABC::isDebug) {
+      LogInfo::MapleLogger() << "Array Index Not Found" << '\n';
+      meStmt.Dump(irMap);
+    }
+    return;
+  }
+  if (prove->DemandProve(*opnd1, *opnd2)) {
+    if (MeABC::isDebug) {
+      LogInfo::MapleLogger() << "Find One OPT" << '\n';
+      meStmt.Dump(irMap);
+    }
+    targetMeStmt.insert(&meStmt);
+  } else {
+    if (MeABC::isDebug) {
+      LogInfo::MapleLogger() << "Can not OPT" << '\n';
+      meStmt.Dump(irMap);
+    }
+  }
+}
+
+MeExpr *MeABC::ReplaceArrayExpr(MeExpr &rhs, MeExpr &naryMeExpr, MeStmt *ivarStmt) {
+  if (rhs.IsLeaf()) {
+    return nullptr;
+  }
+  if (&rhs == &naryMeExpr) {
+    auto *oldNaryMeExpr = static_cast<NaryMeExpr*>(&naryMeExpr);
+    NaryMeExpr tmpNaryMeExpr(&(irMap->GetIRMapAlloc()), kInvalidExprID, *oldNaryMeExpr);
+    CHECK_FATAL(tmpNaryMeExpr.GetBoundCheck(), "must be");
+    tmpNaryMeExpr.SetBoundCheck(false);
+    MeExpr *newNaryMeExpr = irMap->HashMeExpr(tmpNaryMeExpr);
+    return newNaryMeExpr;
+  }
+  if (rhs.GetMeOp() == kMeOpOp) {
+    auto &oldOpMeExpr = static_cast<OpMeExpr&>(rhs);
+    OpMeExpr newMeExpr(oldOpMeExpr, kInvalidExprID);
+    for (size_t i = 0; i < kOperandNumTernary; i++) {
+      if (oldOpMeExpr.GetOpnd(i) == nullptr) {
+        continue;
+      }
+      MeExpr *newOpnd = ReplaceArrayExpr(*(oldOpMeExpr.GetOpnd(i)), naryMeExpr, ivarStmt);
+      newMeExpr.SetOpnd(i, newOpnd);
+    }
+    MeExpr *newOpMeExpr = irMap->HashMeExpr(newMeExpr);
+    return newOpMeExpr;
+  }
+  CHECK_FATAL(rhs.GetMeOp() == kMeOpIvar, "must be");
+  MeExpr *newBase = ReplaceArrayExpr(*static_cast<IvarMeExpr&>(rhs).GetBase(), naryMeExpr, ivarStmt);
+  CHECK_NULL_FATAL(newBase);
+  MeExpr *newIvarExpr = nullptr;
+  if (ivarStmt == nullptr) {
+    auto *oldIvarExpr = static_cast<IvarMeExpr*>(&rhs);
+    IvarMeExpr tmpIvarMeExpr(&irMap->GetIRMapAlloc(), kInvalidExprID, *oldIvarExpr);
+    tmpIvarMeExpr.SetBase(newBase);
+    newIvarExpr = irMap->HashMeExpr(tmpIvarMeExpr);
+  } else {
+    auto &iassingMeStmt = *static_cast<IassignMeStmt*>(ivarStmt);
+    newIvarExpr = irMap->BuildLHSIvar(*newBase, iassingMeStmt, iassingMeStmt.GetLHSVal()->GetFieldID());
+  }
+  return newIvarExpr;
+}
+
+bool MeABC::CleanABCInStmt(MeStmt &meStmt, NaryMeExpr &naryMeExpr) {
+  bool replaced = false;
+  switch (meStmt.GetOp()) {
+    case OP_dassign:
+    case OP_maydassign: {
+      MeExpr *rhs = meStmt.GetRHS();
+      ASSERT_NOT_NULL(rhs);
+      CHECK_FATAL(!rhs->IsLeaf(), "must be");
+      MeExpr *newRHS = ReplaceArrayExpr(*rhs, naryMeExpr, nullptr);
+      replaced = rhs != newRHS;
+      meStmt.SetOpnd(0, newRHS);
+      break;
+    }
+    case OP_iassign: {
+      MeExpr *lhs = static_cast<IassignMeStmt*>(&meStmt)->GetLHSVal();
+      MeExpr *newLHS = ReplaceArrayExpr(*lhs, naryMeExpr, &meStmt);
+      replaced = lhs != newLHS;
+      static_cast<IassignMeStmt*>(&meStmt)->SetLHSVal(static_cast<IvarMeExpr*>(newLHS));
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "must be");
+  }
+  return replaced;
+}
+
+void MeABC::DeleteABC() {
+  for (MeStmt *meStmt : targetMeStmt) {
+    NaryMeExpr *naryMeExpr = arrayChecks[meStmt];
+    bool replaced = CleanABCInStmt(*meStmt, *naryMeExpr);
+    CHECK_FATAL(replaced, "must be");
+  }
+  inequalityGraph = nullptr;
+  prove = nullptr;
+  ssi = nullptr;
+}
+
+void MeABC::InitNewStartPoint(MeStmt &meStmt, MeExpr &opnd1, MeExpr &opnd2, bool clearGraph) {
+  careMeStmts.clear();
+  careMePhis.clear();
+  carePoints.clear();
+  unresolveEdge.clear();
+  if (clearGraph) {
+    inequalityGraph = std::make_unique<InequalityGraph>(*meFunc);
+  }
+  CHECK_FATAL(inequalityGraph != nullptr, "inequalityGraph is nullptr");
+  prove = std::make_unique<ABCD>(*inequalityGraph);
+  CHECK_FATAL(prove != nullptr, "prove is nullptr");
+  CHECK_FATAL(opnd1.GetMeOp() == kMeOpVar, "must be");
+  AddUseDef(opnd1);
+  if (opnd2.GetMeOp() == kMeOpVar) {
+    AddUseDef(opnd2);
+  } else {
+    CHECK_FATAL(opnd2.GetMeOp() == kMeOpConst, "must be");
+    (void)inequalityGraph->GetOrCreateConstNode(static_cast<ConstMeExpr*>(&opnd2)->GetExtIntValue());
+  }
+  BB *curBB = meStmt.GetBB();
+  if (curBB->GetPiList().size()) {
+    for (auto pair : curBB->GetPiList()) {
+      CHECK_FATAL(pair.second.size() >= 1, "must be");
+      PiassignMeStmt *pi = pair.second[0];
+      AddUseDef(*pi->GetLHS());
+    }
+  }
+  currentCheck = &meStmt;
+}
+
+void MeABC::ProcessCallParameters(CallMeStmt &callNode) {
+  MIRFunction *callFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode.GetPUIdx());
+  if (callFunc->GetBaseClassName().compare("Ljava_2Flang_2FSystem_3B") == 0 &&
+      callFunc->GetBaseFuncName().compare("arraycopy") == 0) {
+    MeExpr *opnd1 = callNode.GetOpnd(1); // The 1th parameter.
+    MeExpr *opnd3 = callNode.GetOpnd(3); // The 3th parameter.
+    if (opnd1->GetOp() != OP_dread || opnd3->GetOp() != OP_dread) {
+      return;
+    }
+    ConstMeExpr *constOpnd1 = nullptr;
+    ConstMeExpr *constOpnd3 = nullptr;
+    VarMeExpr *varOpnd1 = static_cast<VarMeExpr*>(opnd1);
+    if (varOpnd1->GetDefBy() == kDefByStmt) {
+      MeStmt *defOpnd1Stmt = varOpnd1->GetDefStmt();
+      if (defOpnd1Stmt->GetOp() == OP_dassign && defOpnd1Stmt->GetOpnd(0)->GetOp() == OP_constval) {
+        constOpnd1 = static_cast<ConstMeExpr*>(defOpnd1Stmt->GetOpnd(0));
+      }
+    }
+    VarMeExpr *varOpnd3 = static_cast<VarMeExpr*>(opnd3);
+    if (varOpnd3->GetDefBy() == kDefByStmt) {
+      MeStmt *defOpnd3Stmt = varOpnd3->GetDefStmt();
+      if (defOpnd3Stmt->GetOp() == OP_dassign && defOpnd3Stmt->GetOpnd(0)->GetOp() == OP_constval) {
+        constOpnd3 = static_cast<ConstMeExpr*>(defOpnd3Stmt->GetOpnd(0));
+      }
+    }
+    if (constOpnd1 != nullptr && constOpnd3 != nullptr && constOpnd1->IsZero() && constOpnd3->IsZero()) {
+      MeExpr *opnd0 = callNode.GetOpnd(0); // The 0th parameter.
+      MeExpr *opnd2 = callNode.GetOpnd(2); // The 2th parameter.
+      MeExpr *opnd4 = callNode.GetOpnd(4); // The 4th parameter.
+      InitNewStartPoint(callNode, *opnd0, *opnd4);
+      BuildInequalityGraph();
+      bool opnd0Proved = IsLessOrEuqal(*opnd0, *opnd4);
+      InitNewStartPoint(callNode, *opnd2, *opnd4, false);
+      BuildInequalityGraph();
+      bool opnd2Proved = IsLessOrEuqal(*opnd2, *opnd4);
+      bool boundaryCheck = false;
+      if (opnd0Proved && opnd2Proved) {
+        boundaryCheck = true;
+      }
+      CHECK_FATAL(opnd0->GetOp() == OP_dread, "must be");
+      CHECK_FATAL(opnd2->GetOp() == OP_dread, "must be");
+      VarMeExpr *array0 = static_cast<VarMeExpr*>(opnd0);
+      VarMeExpr *array2 = static_cast<VarMeExpr*>(opnd2);
+      bool nullCheck = false;
+      if (!array0->GetMaybeNull() && !array2->GetMaybeNull()) {
+        nullCheck = true;
+      }
+      bool typeCheck = false;
+      bool isScalar = false;
+      if (array0->GetInferredTyIdx() != 0 && array2->GetInferredTyIdx() != 0) {
+        MIRType *type0 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(array0->GetInferredTyIdx());
+        MIRType *type2 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(array2->GetInferredTyIdx());
+        if (type0 && type2 && type0->IsMIRJarrayType() && type2->IsMIRJarrayType()) {
+          MIRArrayType *arrayType0 = static_cast<MIRArrayType*>(type0);
+          MIRArrayType *arrayType2 = static_cast<MIRArrayType*>(type2);
+          if (arrayType0->GetElemTyIdx() == arrayType2->GetElemTyIdx()) {
+            typeCheck = true;
+            if (arrayType0->GetElemType()->IsScalarType()) {
+              isScalar = true;
+            }
+          }
+        }
+      }
+      if (boundaryCheck && nullCheck && typeCheck) {
+        if (isScalar) {
+          MIRFunction *arrayCopyFunc = meFunc->GetMIRModule().GetMIRBuilder()->GetOrCreateFunction(
+              "Native_java_lang_System_arraycopyCharUnchecked___3CI_3CII", TyIdx(PTY_void));
+          callNode.SetPUIdx(arrayCopyFunc->GetPuidx());
+          return;
+        } // ref can be handled, but need to extend ABI.
+      }
+    }
+    if (callFunc->GetBaseFuncNameWithType().compare(
+        "arraycopy_7C_28Ljava_2Flang_2FObject_3BILjava_2Flang_2FObject_3BII_29V") == 0) {
+      MIRFunction *arrayCopyFunc = meFunc->GetMIRModule().GetMIRBuilder()->GetOrCreateFunction(
+          "Native_java_lang_System_arraycopy__Ljava_lang_Object_2ILjava_lang_Object_2II", TyIdx(PTY_void));
+      callNode.SetPUIdx(arrayCopyFunc->GetPuidx());
+    }
+  }
+}
+
+void MeABC::ExecuteABCO() {
+  if (CollectABC()) {
+    ssi->ConvertToSSI();
+    CollectCareInsns();
+    for (auto pair : arrayNewChecks) {
+      if (pair.first->GetOp() == OP_callassigned) {
+        auto *callNode = static_cast<CallMeStmt*>(pair.first);
+        ProcessCallParameters(*callNode);
+      } else {
+        InitNewStartPoint(*(pair.first), *((static_cast<NaryMeExpr *>(pair.second))->GetOpnd(0)),
+                          *((static_cast<NaryMeExpr *>(pair.second))->GetOpnd(1)));
+        BuildInequalityGraph();
+        if (MeABC::isDebug) {
+          meFunc->GetCfg()->DumpToFile(meFunc->GetName());
+          inequalityGraph->DumpDotFile(DumpType::kDumpUpperAndNone);
+          inequalityGraph->DumpDotFile(DumpType::kDumpLowerAndNone);
+        }
+        FindRedundantABC(*(pair.first), *(static_cast<NaryMeExpr*>(pair.second)));
+      }
+    }
+    ssi->ConvertToSSA();
+    DeleteABC();
+  }
+}
+
+void MEABCOpt::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MEABCOpt::PhaseRun(maple::MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  ASSERT(dom != nullptr, "dominance phase has problem");
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  ASSERT(irMap != nullptr, "irMap phase has problem");
+  MeABC meABC(f, *dom, *irMap, *GetPhaseMemPool());
+  MeABC::isDebug = DEBUGFUNC_NEWPM(f);
+  meABC.ExecuteABCO();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== After boundary check optimization  =============" << std::endl;
+    irMap->Dump();
+  }
+  return false;
+}
+}
diff --git a/src/mapleall/maple_me/src/me_alias_class.cpp b/src/mapleall/maple_me/src/me_alias_class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2224be0bf93ddeaab4ac89e1119595368c1dc628
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_alias_class.cpp
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_alias_class.h"
+#include "me_option.h"
+#include "mpl_logging.h"
+#include "ssa_mir_nodes.h"
+#include "me_ssa_tab.h"
+#include "me_function.h"
+#include "mpl_timer.h"
+#include "demand_driven_alias_analysis.h"
+#include "me_dominance.h"
+#include "class_hierarchy_phase.h"
+#include "me_phase_manager.h"
+#include "type_based_alias_analysis.h"
+
+namespace maple {
+// This phase performs alias analysis based on union-based alias analysis algorithm and
+// represent the resulting alias relationships in the Maple IR representation
+bool MeAliasClass::HasWriteToStaticFinal() const {
+  for (auto bIt = cfg->valid_begin(); bIt != cfg->valid_end(); ++bIt) {
+    for (const auto &stmt : (*bIt)->GetStmtNodes()) {
+      if (stmt.GetOpCode() == OP_dassign) {
+        const auto &dassignNode = static_cast<const DassignNode&>(stmt);
+        if (dassignNode.GetStIdx().IsGlobal()) {
+          const MIRSymbol *sym = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dassignNode.GetStIdx());
+          ASSERT_NOT_NULL(sym);
+          if (sym->IsFinal()) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
+void MeAliasClass::PerformTBAAForC() {
+  if (!mirModule.IsCModule() || !MeOption::tbaa) {
+    return;
+  }
+  for (auto *ost : func.GetMeSSATab()->GetOriginalStTable()) {
+    auto *aliasSet = GetAliasSet(*ost);
+    if (aliasSet == nullptr) {
+      continue;
+    }
+    auto *oldAliasSet = aliasSet;
+    AliasSet *newAliasSet = nullptr;
+    for (auto aliasedOstIdx : *oldAliasSet) {
+      if (aliasedOstIdx == ost->GetIndex()) {
+        continue;
+      }
+      bool alias = false;
+      if (ost->GetIndex() < aliasedOstIdx) {
+        auto *aliasedOst = func.GetMeSSATab()->GetOriginalStFromID(OStIdx(aliasedOstIdx));
+        alias = TypeBasedAliasAnalysis::MayAliasTBAAForC(ost, aliasedOst);
+      } else {
+        auto aliasSetOfAliasedOst = GetAliasSet(OStIdx(aliasedOstIdx));
+        alias = aliasSetOfAliasedOst == nullptr ||
+                (aliasSetOfAliasedOst->find(ost->GetIndex()) != aliasSetOfAliasedOst->end());
+      }
+      if (alias) {
+        continue;
+      }
+      if (newAliasSet == nullptr) {
+        newAliasSet = GetMapleAllocator().GetMemPool()->New<AliasSet>(GetMapleAllocator().Adapter());
+        newAliasSet->insert(oldAliasSet->cbegin(), oldAliasSet->cend());
+      }
+      newAliasSet->erase(aliasedOstIdx);
+    }
+    if (newAliasSet != nullptr) {
+      SetAliasSet(ost->GetIndex(), newAliasSet);
+    }
+  }
+}
+
+void MeAliasClass::PerformDemandDrivenAliasAnalysis() {
+  if (!MeOption::ddaa) {
+    return;
+  }
+  if (!mirModule.IsCModule()) {
+    return;
+  }
+
+  DemandDrivenAliasAnalysis ddAlias(&func, func.GetMeSSATab(), localMemPool, enabledDebug);
+  for (auto *ost : func.GetMeSSATab()->GetOriginalStTable()) {
+    auto *aliasSet = GetAliasSet(*ost);
+    if (aliasSet != nullptr) {
+      auto *oldAliasSet = aliasSet;
+      AliasSet *newAliasSet = nullptr;
+      for (auto aliasedOstIdx : *aliasSet) {
+        if (aliasedOstIdx == ost->GetIndex()) {
+          continue;
+        }
+
+        bool alias = false;
+        if (ost->GetIndex() < aliasedOstIdx) {
+          auto *aliasedOst = func.GetMeSSATab()->GetOriginalStFromID(OStIdx(aliasedOstIdx));
+          alias = ddAlias.MayAlias(ost, aliasedOst);
+        } else {
+          auto aliasSetOfAliasedOst = GetAliasSet(OStIdx(aliasedOstIdx));
+          alias = aliasSetOfAliasedOst == nullptr ||
+                  (aliasSetOfAliasedOst->find(ost->GetIndex()) != aliasSetOfAliasedOst->end());
+        }
+        if (!alias) {
+          if (newAliasSet == nullptr) {
+            newAliasSet =
+                GetMapleAllocator().GetMemPool()->New<AliasSet>(GetMapleAllocator().Adapter());
+            newAliasSet->insert(oldAliasSet->cbegin(), oldAliasSet->cend());
+          }
+          newAliasSet->erase(aliasedOstIdx);
+        }
+      }
+      if (newAliasSet != nullptr) {
+        SetAliasSet(ost->GetIndex(), newAliasSet);
+      }
+    }
+  }
+}
+
+void MeAliasClass::DoAliasAnalysis() {
+  // pass 1 through the program statements
+  for (auto bIt = cfg->valid_begin(); bIt != cfg->valid_end(); ++bIt) {
+    const auto &phiList = (*bIt)->GetPhiList();
+    for (const auto &ost2phi : phiList) {
+      ApplyUnionForPhi(ost2phi.second);
+    }
+
+    for (auto &stmt : (*bIt)->GetStmtNodes()) {
+      ApplyUnionForCopies(stmt);
+    }
+  }
+  ApplyUnionForFieldsInCopiedAgg();
+  CreateAssignSets();
+  PropagateTypeUnsafe();
+  if (enabledDebug) {
+    DumpAssignSets();
+  }
+  ReinitUnionFind();
+  if (!MeOption::unionBasedAA) {
+    UnionAllPointedTos();
+  } else {
+    ApplyUnionForPointedTos();
+    if (mirModule.IsJavaModule()) {
+      UnionForNotAllDefsSeen();
+    } else {
+      UnionForNotAllDefsSeenCLang();
+    }
+  }
+  // perform TBAA for Java
+  if (MeOption::tbaa && mirModule.IsJavaModule()) {
+    ReconstructAliasGroups();
+  }
+  CreateClassSets();
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "\n============ Alias Info After UBAA ============\n" << std::endl;
+    DumpClassSets();
+  }
+  PerformTBAAForC();
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "\n============ Alias Info After TBAA ============\n" << std::endl;
+    DumpClassSets(false); // every element has its own aliasSet
+  }
+  PerformDemandDrivenAliasAnalysis();
+  if (enabledDebug) {
+    if (MeOption::ddaa) {
+      ReinitUnionFind();
+    }
+    LogInfo::MapleLogger() << "\n============ Alias Info After DDAA ============\n" << std::endl;
+    DumpClassSets(false); // every element has its own aliasSet
+  }
+  // pass 2 through the program statements
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "\n============ Alias Classification Pass 2 ============" << '\n';
+  }
+
+  for (auto bIt = cfg->valid_begin(); bIt != cfg->valid_end(); ++bIt) {
+    auto *bb = *bIt;
+    for (auto &stmt : bb->GetStmtNodes()) {
+      GenericInsertMayDefUse(stmt, bb->GetBBId());
+    }
+  }
+
+  SetAnalyzedOstNum(func.GetMeSSATab()->GetOriginalStTableSize());
+  TypeBasedAliasAnalysis::ClearOstTypeUnsafeInfo();
+}
+
+bool MEAliasClass::PhaseRun(maple::MeFunction &f) {
+  MPLTimer timer;
+  timer.Start();
+  KlassHierarchy *kh = nullptr;
+  if (f.GetMIRModule().IsJavaModule()) {
+    MaplePhase *it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MKlassHierarchy, MIRModule>(f.GetMIRModule());
+    kh = static_cast<M2MKlassHierarchy *>(it)->GetResult();
+  }
+  aliasClass = GetPhaseAllocator()->New<MeAliasClass>(*GetPhaseMemPool(), *ApplyTempMemPool(), f.GetMIRModule(),
+                                                      *f.GetMeSSATab(), f, MeOption::lessThrowAlias,
+                                                      MeOption::ignoreIPA, DEBUGFUNC_NEWPM(f),
+                                                      MeOption::setCalleeHasSideEffect, kh);
+  aliasClass->DoAliasAnalysis();
+  timer.Stop();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "ssaTab + aliasClass passes consume cumulatively " << timer.Elapsed() << "seconds "
+                           << '\n';
+  }
+  return true;
+}
+
+void MEAliasClass::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MESSATab>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_analyze_rc.cpp b/src/mapleall/maple_me/src/me_analyze_rc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dd40aba17c760cd1335d640cc010a4ea0573d144
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_analyze_rc.cpp
@@ -0,0 +1,483 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_analyze_rc.h"
+#include "me_phase_manager.h"
+#include "me_option.h"
+#include "me_dominance.h"
+#include "me_cond_based_rc.h"
+#include "me_delegate_rc.h"
+#include "me_subsum_rc.h"
+
+// This phase analyzes the defs and uses of ref pointers in the function and
+// performs the following modifications to the code:
+//
+// A. Insert a decref for the ref pointer before each of its definition.  If the
+// ref pointer is local (a localrefvar) and the analysis shows that it is the
+// first definition since entering the function, the decref will be omitted.
+//
+// B. At each statement that assigns a new value to a ref pointer, insert an
+// incref after the assignment. In cases where the incref has already been
+// performed when the assigned value is computed, it will not insert the incref.
+//
+// C. A localrefvar need to be cleaned up before function exit.  This clean-up
+// corresponds to performing a decref.  Instead of inserting a decref to clean up
+// each localrefvar, the cleanup for the localrefvars in the function is
+// represented aggregate via a call to the intrinsic CLEANUP_LOCALREFVARS
+// inserted before each return statement.  The localrefvars to be cleaned up
+// for each return statement are indicated as actual parameters in the
+// intrinsiccall statement. If a localrefvar's definition cannot reach a return
+// statement, it will not be included in the actual parameters. If the number
+// of localrefvar parameters in the intrinsiccall is more than
+// `kCleanupLocalRefVarsLimit`, the intrinsiccall will be omitted, in which
+// case the code generator will clean up all localrefvars.
+//
+// For C, analyzerc can try to do more optimization by inserting decrefs for
+// individual localrefvars earlier than the return statements.  This is done
+// when the placementRC flag is set to true. This optimization is performed by
+// calling PlacementRC::ApplySSUPre for all localrefvars.
+// Under placementRC, the CLEANUP_LOCALREFVARS intrinsiccall will still be
+// inserted for the decrefs being inserted before the return statement.
+//
+// When a formal parameter of ref type is ever assigned inside the function,
+// an incref for it needs to be inserted at function entry.  This is done
+// by the placementRC phase. For such formal parameters, placementRC phase will
+// also insert decref's to clean them up after their last use.
+//
+// If the return statement returns a ref pointer variable, an incref for it
+// needs to be effected. This is not handled by analyzerc, but is handled by
+// the rcLowering phase.
+//
+// This phase needs to be run before register promotion, because some alias
+// information is lost after a pointer is promoted to preg. Because it is run
+// after EPRE phase, there can be regassign's and regread's of ref type but
+// they will not cause decref or incref insertion.
+//
+// if number of live localrefvars is more than this limit at a return, we will
+// not insert the intrinsiccall to CLEANUP_LOCALREFVARS
+namespace {
+constexpr int kCleanupLocalRefVarsLimit = 200;
+}  // namespace
+
+namespace maple {
+void RCItem::Dump() {
+  ost.Dump();
+  if (!noAlias) {
+    LogInfo::Info() << " aliased";
+  }
+  if (nonLocal) {
+    LogInfo::Info() << " nonLocal";
+  }
+  if (isFormal) {
+    LogInfo::Info() << " isFormal";
+  }
+  for (BBId bbId : occurBBs) {
+    LogInfo::Info() << " " << bbId;
+  }
+  LogInfo::Info() << '\n';
+}
+
+RCItem *AnalyzeRC::FindOrCreateRCItem(OriginalSt &ost) {
+  auto mapIt = rcItemsMap.find(ost.GetIndex());
+  if (mapIt != rcItemsMap.end()) {
+    return mapIt->second;
+  }
+  RCItem *rcItem = analyzeRCMp->New<RCItem>(ost, analyzeRCAllocator);
+  rcItemsMap[ost.GetIndex()] = rcItem;
+  auto *aliasSet = aliasClass.GetAliasSet(ost);
+  rcItem->noAlias = aliasSet == nullptr;
+  rcItem->nonLocal = ost.GetIndirectLev() > 0 || ost.GetMIRSymbol()->IsGlobal();
+  if (!rcItem->nonLocal) {
+    rcItem->isFormal = ost.GetMIRSymbol()->GetStorageClass() == kScFormal;
+  }
+  return rcItem;
+}
+
+OriginalSt *AnalyzeRC::GetOriginalSt(const MeExpr &refLHS) const {
+  if (refLHS.GetMeOp() == kMeOpVar) {
+    auto &varMeExpr = static_cast<const VarMeExpr&>(refLHS);
+    return varMeExpr.GetOst();
+  }
+  ASSERT(refLHS.GetMeOp() == kMeOpIvar, "GetOriginalSt: unexpected node type");
+  auto &ivarMeExpr = static_cast<const IvarMeExpr&>(refLHS);
+  if (ivarMeExpr.GetUniqueMu() != nullptr) {
+    return ivarMeExpr.GetUniqueMu()->GetOst();
+  }
+  ASSERT(ivarMeExpr.GetDefStmt() != nullptr, "GetOriginalSt: ivar with mu==nullptr has no defStmt");
+  IassignMeStmt *iass = ivarMeExpr.GetDefStmt();
+  CHECK_FATAL(!iass->GetChiList()->empty(), "GetOriginalSt: ivar with mu==nullptr has empty chiList at its def");
+  return iass->GetChiList()->begin()->second->GetLHS()->GetOst();
+}
+
+VarMeExpr *AnalyzeRC::GetZeroVersionVarMeExpr(const VarMeExpr &var) {
+  OriginalSt *ost = var.GetOst();
+  return irMap.GetOrCreateZeroVersionVarMeExpr(*ost);
+}
+
+// check if incref needs to be inserted after this ref pointer assignment;
+// if it is callassigned, the incref has already been done in the callee;
+// if rhs is gcmalloc/gcmallocjarray, the refcount is already 1;
+// if rhs is neither dread or iread, it cannot be a pointer, so incref not needed
+bool AnalyzeRC::NeedIncref(const MeStmt &stmt) const {
+  if (kOpcodeInfo.IsCallAssigned(stmt.GetOp())) {
+    return false;
+  }
+  MeExpr *rhs = stmt.GetRHS();
+  CHECK_NULL_FATAL(rhs);
+  return rhs->PointsToSomethingThatNeedsIncRef();
+}
+
+// identify assignments to ref pointers and insert decref before it and incref
+// after it
+void AnalyzeRC::IdentifyRCStmts() {
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto &bb = **bIt;
+    for (auto &stmt : bb.GetMeStmts()) {
+      MeExpr *lhsRef = stmt.GetLHSRef(skipLocalRefVars);
+      if (lhsRef != nullptr) {
+        OriginalSt *ost = GetOriginalSt(*lhsRef);
+        ASSERT(ost != nullptr, "IdentifyRCStmts: cannot get SymbolOriginalSt");
+        (void)FindOrCreateRCItem(*ost);
+        // this part for inserting decref
+        if (lhsRef->GetMeOp() == kMeOpVar) {
+          // insert a decref statement
+          UnaryMeStmt *decrefStmt = irMap.CreateUnaryMeStmt(
+              OP_decref, GetZeroVersionVarMeExpr(static_cast<const VarMeExpr&>(*lhsRef)), &bb, &stmt.GetSrcPosition());
+          // insertion position is before stmt
+          bb.InsertMeStmtBefore(&stmt, decrefStmt);
+        } else {
+          auto *lhsIvar = static_cast<IvarMeExpr*>(lhsRef);
+          {
+            // insert a decref statement
+            IvarMeExpr ivarMeExpr(&irMap.GetIRMapAlloc(), -1, lhsIvar->GetPrimType(),
+                lhsIvar->GetTyIdx(), lhsIvar->GetFieldID());
+            ivarMeExpr.SetBase(lhsIvar->GetBase());
+            // form mu from chiList
+            auto &iass = static_cast<IassignMeStmt&>(stmt);
+            auto xit = iass.GetChiList()->cbegin();
+            for (; xit != iass.GetChiList()->end(); ++xit) {
+              ChiMeNode *chi = xit->second;
+              if (chi->GetRHS()->GetOst() == ost) {
+                CHECK_FATAL(!ivarMeExpr.HasMultipleMu(), "NYI");
+                ivarMeExpr.SetMuItem(0, chi->GetRHS());
+                break;
+              }
+            }
+            ASSERT(xit != iass.GetChiList()->end(), "IdentifyRCStmts: failed to find corresponding chi node");
+            UnaryMeStmt *decrefStmt = irMap.CreateUnaryMeStmt(
+                OP_decref, irMap.HashMeExpr(ivarMeExpr), &bb, &stmt.GetSrcPosition());
+            // insertion position is before stmt
+            bb.InsertMeStmtBefore(&stmt, decrefStmt);
+            ost = GetOriginalSt(*decrefStmt->GetOpnd());
+            ASSERT(ost != nullptr, "IdentifyRCStmts: cannot get SymbolOriginalSt");
+            (void)FindOrCreateRCItem(*ost);
+          }
+        }
+        // this part for inserting incref
+        if (NeedIncref(stmt)) {
+          stmt.EnableNeedIncref();
+        }
+      }
+    }  // end of stmt iteration
+  }
+}
+
+void AnalyzeRC::CreateCleanupIntrinsics() {
+  for (BB *bb : cfg->GetCommonExitBB()->GetPred()) {
+    auto &meStmts = bb->GetMeStmts();
+    if (meStmts.empty() || meStmts.back().GetOp() != OP_return) {
+      continue;
+    }
+    std::vector<MeExpr*> opnds;
+    for (auto &mapItem : std::as_const(rcItemsMap)) {
+      RCItem *rcItem = mapItem.second;
+      if (rcItem->nonLocal || rcItem->isFormal) {
+        continue;
+      }
+      opnds.push_back(irMap.GetOrCreateZeroVersionVarMeExpr(rcItem->ost));
+    }
+    IntrinsiccallMeStmt *intrn = irMap.CreateIntrinsicCallMeStmt(INTRN_MPL_CLEANUP_LOCALREFVARS, opnds);
+    bb->InsertMeStmtBefore(&(meStmts.back()), intrn);
+  }
+}
+
+void AnalyzeRC::TraverseStmt(BB &bb) {
+  if (bb.GetMeStmts().empty()) {
+    return;
+  }
+  for (auto &meStmt : bb.GetMeStmts()) {
+    if (meStmt.GetOp() == OP_decref || (meStmt.GetOp() == OP_intrinsiccall &&
+        static_cast<IntrinsiccallMeStmt&>(meStmt).GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS)) {
+      RenameUses(meStmt);
+    } else {
+      MeExpr *lhsRef = meStmt.GetLHSRef(skipLocalRefVars);
+      if (lhsRef == nullptr) {
+        continue;
+      }
+      const OriginalSt *ost = GetOriginalSt(*lhsRef);
+      RCItem *rcItem = rcItemsMap[ost->GetIndex()];
+      if (!rcItem->nonLocal) {
+        rcItem->versionStack.push(lhsRef);
+      }
+    }
+  }
+}
+
+void AnalyzeRC::RenameRefPtrs(BB *bb) {
+  if (skipLocalRefVars || bb == nullptr) {
+    return;
+  }
+  std::map<RCItem*, size_t> savedStacksize;  // to record stack size
+  // in each RCItem for stack pop-ups
+  for (const auto &mapItem : std::as_const(rcItemsMap)) {
+    RCItem *rcItem = mapItem.second;
+    if (rcItem->nonLocal) {
+      continue;
+    }
+    // record stack size
+    savedStacksize[rcItem] = rcItem->versionStack.size();
+    // if there is a phi, push stack
+    auto phiIt = bb->GetMePhiList().find(mapItem.second->ost.GetIndex());
+    if (phiIt != bb->GetMePhiList().end()) {
+      rcItem->versionStack.push((*phiIt).second->GetLHS());
+    }
+  }
+  // traverse the BB stmts
+  TraverseStmt(*bb);
+  // recursive call in preorder traversal of dominator tree
+  ASSERT(bb->GetBBId() < dominance.GetDomChildrenSize(), "index out of range in AnalyzeRC::RenameRefPtrs");
+  const auto &domChildren = dominance.GetDomChildren(bb->GetID());
+  for (const auto &childBBId : domChildren) {
+    RenameRefPtrs(cfg->GetAllBBs().at(childBBId));
+  }
+  // restore the stacks to their size at entry to this function invocation
+  for (auto &mapItem : std::as_const(rcItemsMap)) {
+    RCItem *rcItem = mapItem.second;
+    if (rcItem->nonLocal) {
+      continue;
+    }
+    size_t lastSize = savedStacksize[rcItem];
+    while (rcItem->versionStack.size() > lastSize) {
+      rcItem->versionStack.pop();
+    }
+  }
+}
+
+void AnalyzeRC::RenameUses(MeStmt &meStmt) {
+  for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+    const OriginalSt *ost = GetOriginalSt(*meStmt.GetOpnd(i));
+    RCItem *rcItem = rcItemsMap[ost->GetIndex()];
+    if (meStmt.GetOp() == OP_intrinsiccall) {
+      ASSERT(!rcItem->nonLocal, "cleanupLocalrefvars only takes locals");
+    }
+    if (!rcItem->nonLocal && !rcItem->versionStack.empty()) {
+      meStmt.SetOpnd(i, rcItem->versionStack.top());
+    }
+  }
+}
+
+DassignMeStmt *AnalyzeRC::CreateDassignInit(OriginalSt &ost, BB &bb) {
+  VarMeExpr *lhs = irMap.CreateVarMeExprVersion(&ost);
+  MeExpr *rhs = irMap.CreateIntConstMeExpr(0, PTY_ref);
+  return static_cast<DassignMeStmt *>(irMap.CreateAssignMeStmt(utils::ToRef(lhs), utils::ToRef(rhs), bb));
+}
+
+UnaryMeStmt *AnalyzeRC::CreateIncrefZeroVersion(OriginalSt &ost) {
+  return irMap.CreateUnaryMeStmt(OP_incref, irMap.GetOrCreateZeroVersionVarMeExpr(ost));
+}
+
+void AnalyzeRC::OptimizeRC() {
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    for (auto itStmt = bb->GetMeStmts().begin(); itStmt != bb->GetMeStmts().end(); ++itStmt) {
+      MeStmt *stmt = to_ptr(itStmt);
+      if (itStmt->GetOp() != OP_decref) {
+        continue;
+      }
+      auto *decref = static_cast<UnaryMeStmt*>(stmt);
+      MeStmt *refAssign = stmt->GetNext();
+      MeExpr *opnd = decref->GetOpnd();
+      OriginalSt *ost = GetOriginalSt(*opnd);
+      if (opnd->GetMeOp() == kMeOpVar && ost->IsLocal() && skipLocalRefVars) {
+        continue;
+      }
+      RCItem *rcItem = rcItemsMap[ost->GetIndex()];
+      if (!rcItem->isFormal && opnd->GetMeOp() == kMeOpVar) {
+        // !nonLocal && noAlias
+        rcItem->occurBBs.insert(bb->GetBBId());
+        rcItem->needSomeRC = true;
+      }
+      if (NeedDecRef(*rcItem, *opnd)) {
+        refAssign->EnableNeedDecref();
+      } else {
+        bb->RemoveMeStmt(stmt);  // delete the decref
+      }
+      ++itStmt;  // next iteration will process the stmt after refAssign
+    }
+  }
+}
+
+bool AnalyzeRC::NeedDecRef(const RCItem &rcItem, MeExpr &expr) const {
+  CHECK_FATAL((rcItem.nonLocal || rcItem.noAlias), "OptimizeRC: local pointers cannot have alias");
+  // see if the decref can be optimized away
+  if (rcItem.nonLocal) {
+    // the decref can be avoided for iassign thru this in constructor funcs
+    if (rcItem.ost.GetIndirectLev() == 1 && func.GetMirFunc()->IsConstructor()) {
+      auto &ivarMeExpr = static_cast<IvarMeExpr&>(expr);
+      return NeedDecRef(ivarMeExpr);
+    }
+    return true;
+  }
+  if (rcItem.isFormal || expr.GetMeOp() != kMeOpVar) {
+    return true;
+  }
+  auto &varMeExpr = static_cast<VarMeExpr&>(expr);
+  return NeedDecRef(varMeExpr);
+}
+
+bool AnalyzeRC::NeedDecRef(IvarMeExpr &ivar) const {
+  auto *base = ivar.GetBase();
+  if (base->GetMeOp() != kMeOpVar) {
+    return true;
+  }
+  auto *baseVar = static_cast<VarMeExpr*>(base);
+  const MIRSymbol *sym = baseVar->GetOst()->GetMIRSymbol();
+  if (sym->GetStorageClass() != kScFormal || sym != func.GetMirFunc()->GetFormal(0)) {
+    return true;
+  }
+  MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx());
+  MIRType *type = static_cast<MIRPtrType*>(baseType)->GetPointedType();
+  if (!instance_of<MIRClassType>(type)) {
+    return true;
+  }
+  auto *classType = static_cast<MIRClassType*>(type);
+  // check ivarMeExpr->fieldID is not from base classes
+  if (!classType->IsOwnField(ivar.GetFieldID())) {
+    return true;
+  }
+  // check the ivar's mu is zero version
+  OriginalSt *ost = GetOriginalSt(ivar);
+  for (auto *mu : ivar.GetMuList()) {
+    if (mu == nullptr) {
+      return false;
+    }
+    if (mu->GetVstIdx() != ost->GetZeroVersionIndex() && mu->GetDefBy() != kDefByNo) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+bool AnalyzeRC::NeedDecRef(const VarMeExpr &var) const {
+  OriginalSt *ost = GetOriginalSt(var);
+  return var.GetVstIdx() != ost->GetZeroVersionIndex() && var.GetDefBy() != kDefByNo;
+}
+
+// among the arguments in the intrinsiccall to INTRN_CLEANUP_LOCALREFVARS, those
+// that are zero version are not live, and can be deleted; if the number of
+// arguments left are > `kCleanupLocalRefVarsLimit`, delete the intrinsiccall.
+void AnalyzeRC::RemoveUnneededCleanups() {
+  for (BB *bb : cfg->GetCommonExitBB()->GetPred()) {
+    auto &meStmts = bb->GetMeStmts();
+    if (meStmts.empty() || meStmts.back().GetOp() != OP_return) {
+      continue;
+    }
+    MeStmt *meStmt = meStmts.back().GetPrev();
+    CHECK_NULL_FATAL(meStmt);
+    ASSERT(meStmt->GetOp() == OP_intrinsiccall, "RemoveUnneededCleanups: cannot find cleanup intrinsic stmt");
+    auto intrn = static_cast<IntrinsiccallMeStmt*>(meStmt);
+    ASSERT(intrn->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS,
+           "RemoveUnneededCleanups: cannot find cleanup intrinsic stmt");
+    size_t nextPos = 0;
+    size_t i = 0;
+    for (; i < intrn->NumMeStmtOpnds(); ++i) {
+      auto varMeExpr = static_cast<VarMeExpr*>(intrn->GetOpnd(i));
+      if (varMeExpr->IsZeroVersion()) {
+        continue;
+      }
+      if (nextPos != i) {
+        intrn->SetOpnd(nextPos, varMeExpr);
+      }
+      ++nextPos;
+    }
+    while (nextPos < i) {
+      intrn->PopBackOpnd();
+      --i;
+    }
+    if (intrn->NumMeStmtOpnds() > kCleanupLocalRefVarsLimit) {
+      bb->RemoveMeStmt(intrn);  // delete the intrinsiccall stmt
+    }
+  }
+}
+
+void AnalyzeRC::Run() {
+  if (func.GetHints() & kPlacementRCed) {
+    skipLocalRefVars = true;
+  } else {
+    func.SetHints(func.GetHints() | kAnalyzeRCed);
+  }
+  IdentifyRCStmts();
+  if (!skipLocalRefVars) {
+    CreateCleanupIntrinsics();
+  }
+  RenameRefPtrs(cfg->GetCommonEntryBB());
+  if (MeOption::optLevel > 0 && !skipLocalRefVars) {
+    RemoveUnneededCleanups();
+  }
+  OptimizeRC();
+}
+
+void MEAnalyzeRC::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEAliasClass>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MEAnalyzeRC::PhaseRun(maple::MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  ASSERT(dom != nullptr, "dominance phase has problem");
+  auto *aliasClass = GET_ANALYSIS(MEAliasClass, f);
+  ASSERT(aliasClass != nullptr, "aliasClass phase has problem");
+  ASSERT_NOT_NULL((GET_ANALYSIS(MEIRMapBuild, f)));
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::Info() << " Processing " << f.GetMirFunc()->GetName() << '\n';
+  }
+  // add extra scope so destructor for analyzerc will be invoked earlier
+  AnalyzeRC analyzerc(f, *dom, *aliasClass, GetPhaseMemPool());
+  analyzerc.Run();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::Info() << "\n============== After ANALYZE RC =============" << '\n';
+    f.Dump(false);
+  }
+  if (MeOption::subsumRC && MeOption::rcLowering && MeOption::optLevel > 0) {
+    GetAnalysisInfoHook()->ForceRunTransFormPhase<MeFuncOptTy, MeFunction>(&MESubsumRC::id, f);
+  }
+  if (!MeOption::noDelegateRC && MeOption::rcLowering && MeOption::optLevel > 0) {
+    GetAnalysisInfoHook()->ForceRunTransFormPhase<MeFuncOptTy, MeFunction>(&MEDelegateRC::id, f);
+  }
+  if (!MeOption::noCondBasedRC && !(f.GetHints() & kPlacementRCed) &&
+      MeOption::rcLowering && MeOption::optLevel > 0) {
+    GetAnalysisInfoHook()->ForceRunTransFormPhase<MeFuncOptTy, MeFunction>(&MECondBasedRC::id, f);
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::Info() << "\n============== After delegate RC and condbased RC =============" << '\n';
+    f.Dump(false);
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_analyzector.cpp b/src/mapleall/maple_me/src/me_analyzector.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e47619b2beef9d0f1b260ddb388d51a0b0575af9
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_analyzector.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_analyzector.h"
+#include "utils.h"
+
+// AnalyzeCtor analyzes which fields are assigned inside of each constructor
+namespace maple {
+void AnalyzeCtor::ProcessFunc() {
+  MIRFunction *curFunc = func->GetMirFunc();
+  if (!curFunc->IsConstructor() || curFunc->IsEmpty() || curFunc->GetParamSize() == 0) {
+    return;
+  }
+  hasSideEffect = false;
+  auto cfg = func->GetCfg();
+  if (curFunc->GetBody() != nullptr) {
+    for (BB *bb : cfg->GetAllBBs()) {
+      if (bb == nullptr) {
+        continue;
+      }
+      for (auto &meStmt : bb->GetMeStmts()) {
+        ProcessStmt(meStmt);
+      }
+    }
+  }
+  PUIdx puIdx = curFunc->GetPuidx();
+  // if the function has calls with sideeffect, conservatively
+  // we assume all fields are modified in ctor
+  if (hasSideEffect) {
+    MapleSet<FieldID> *fieldSubSet =
+        func->GetMIRModule().GetMemPool()->New<MapleSet<FieldID>>(std::less<FieldID>(),
+                                                                  func->GetMIRModule().GetMPAllocator().Adapter());
+    fieldSubSet->insert(0);  // write to all
+    func->GetMIRModule().SetPuIdxFieldSet(puIdx, fieldSubSet);
+  } else if (!fieldSet.empty()) {
+    MapleSet<FieldID> *fieldSubSet =
+        func->GetMIRModule().GetMemPool()->New<MapleSet<FieldID>>(std::less<FieldID>(),
+                                                                  func->GetMIRModule().GetMPAllocator().Adapter());
+    std::copy(fieldSet.begin(), fieldSet.end(), std::inserter(*fieldSubSet, fieldSubSet->begin()));
+    func->GetMIRModule().SetPuIdxFieldSet(puIdx, fieldSubSet);
+  }
+}
+
+// collect field ids which are assigned inside the stmt and mark sideeffect
+// flag for non-ctor calls
+void AnalyzeCtor::ProcessStmt(MeStmt &stmt) {
+  if (kOpcodeInfo.IsCall(stmt.GetOp())) {
+    hasSideEffect = true;
+    return;
+  }
+  switch (stmt.GetOp()) {
+    case OP_iassign: {
+      auto &iassign = static_cast<IassignMeStmt&>(stmt);
+      auto &ivarMeExpr = static_cast<IvarMeExpr&>(*iassign.GetLHSVal());
+      MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr.GetTyIdx());
+      ASSERT(baseType != nullptr, "null ptr check");
+      auto *pointedType = static_cast<MIRPtrType*>(baseType)->GetPointedType();
+      auto structType = safe_cast<MIRStructType>(pointedType);
+      if (structType != nullptr) {
+        MIRType *fieldType = structType->GetFieldType(ivarMeExpr.GetFieldID());
+        if (fieldType->GetPrimType() != PTY_ref) {
+          break;
+        }
+      }
+      fieldSet.insert(ivarMeExpr.GetFieldID());
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+bool MEAnalyzeCtor::PhaseRun(MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  MaplePhase *it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MKlassHierarchy, MIRModule>(f.GetMIRModule());
+  auto *kh = static_cast<M2MKlassHierarchy*>(it)->GetResult();
+  ASSERT_NOT_NULL(dom);
+  ASSERT_NOT_NULL((GET_ANALYSIS(MEIRMapBuild, f)));
+  AnalyzeCtor analyzeCtor(f, *dom, *kh);
+  analyzeCtor.ProcessFunc();
+  return false;
+}
+
+void MEAnalyzeCtor::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_autovec.cpp b/src/mapleall/maple_me/src/me_autovec.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..abdefe971de569c146c0ca517136c992321ef3f1
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_autovec.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021-2022] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_autovec.h"
+#include <iostream>
+#include <algorithm>
+#include "me_option.h"
+#include "mir_module.h"
+#include "me_loop_analysis.h"
+#include "lfo_loop_vec.h"
+#include "seqvec.h"
+
+namespace maple {
+bool MEAutoVectorization::PhaseRun(MeFunction &f) {
+  // generate lfo IR
+  PreMeEmitter *lfoemit = GET_ANALYSIS(MEPreMeEmission, f);
+  CHECK_NULL_FATAL(lfoemit);
+
+  if (MeOption::loopVec) {
+    // step 1: get dependence graph for each loop
+    auto *lfodepInfo = GET_ANALYSIS(MELfoDepTest, f);
+    CHECK_NULL_FATAL(lfodepInfo);
+
+    if (DEBUGFUNC_NEWPM(f)) {
+      LogInfo::MapleLogger() << "\n**** Before loop vectorization ****\n";
+      f.GetMirFunc()->Dump(false);
+    }
+
+    // run loop vectorization
+    LoopVectorization loopVec(GetPhaseMemPool(), lfoemit, lfodepInfo, DEBUGFUNC_NEWPM(f));
+    loopVec.Perform();
+
+    if (DEBUGFUNC_NEWPM(f)) {
+      LogInfo::MapleLogger() << "\n\n\n**** After loop vectorization ****\n";
+      f.GetMirFunc()->Dump(false);
+    }
+  }
+
+  if (MeOption::seqVec) {
+    // run sequence vectorization
+    SeqVectorize seqVec(GetPhaseMemPool(), lfoemit, DEBUGFUNC_NEWPM(f));
+    seqVec.Perform();
+    if (DEBUGFUNC_NEWPM(f)) {
+      LogInfo::MapleLogger() << "\n\n\n**** After sequence vectorization ****\n";
+      f.GetMirFunc()->Dump(false);
+    }
+  }
+
+  return false;
+}
+
+void MEAutoVectorization::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEPreMeEmission>();
+  aDep.AddRequired<MELfoDepTest>();
+  aDep.PreservedAllExcept<MEDominance>();
+  aDep.PreservedAllExcept<MELoopAnalysis>();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_bb_analyze.cpp b/src/mapleall/maple_me/src/me_bb_analyze.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4351bb41ade1f80440f9ece66b51bba4f31bffe5
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_bb_analyze.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_bb_analyze.h"
+
+namespace maple {
+  void BBAnalyze::SetHotAndColdBBCountThreshold() {
+    std::vector<uint64> times;
+    auto eIt = cfg->valid_end();
+    for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+      auto *bb = *bIt;
+      times.push_back((bb->GetFrequency()));
+    }
+    std::sort(times.begin(), times.end(), std::greater<uint32>());
+    uint32 hotIndex =
+        static_cast<uint32>(static_cast<double>(times.size()) / kPrecision * (MeOption::profileBBHotRate));
+    uint32 coldIndex =
+        static_cast<uint32>(static_cast<double>(times.size()) / kPrecision * (MeOption::profileBBColdRate));
+    hotBBCountThreshold = static_cast<uint32>(times.at(hotIndex));
+    coldBBCountThreshold = static_cast<uint32>(times.at(coldIndex));
+  }
+
+  bool BBAnalyze::CheckBBHot(const BBId bbId) const {
+    BB *bb = cfg->GetBBFromID(bbId);
+    return bb->GetFrequency() >= hotBBCountThreshold;
+  }
+
+  bool BBAnalyze::CheckBBCold(const BBId bbId) const {
+    BB *bb = cfg->GetBBFromID(bbId);
+    return bb->GetFrequency() <= coldBBCountThreshold;
+  }
+
+  uint32 BBAnalyze::getHotBBCountThreshold() const {
+    return hotBBCountThreshold;
+  }
+
+  uint32 BBAnalyze::getColdBBCountThreshold() const {
+    return coldBBCountThreshold;
+  }
+
+#ifdef NOT_USED
+  AnalysisResult *MeDoBBAnalyze::Run(MeFunction *func, MeFuncResultMgr *, ModuleResultMgr*) {
+    MemPool *meBBAnalyze = NewMemPool();
+    BBAnalyze *bbAnalyze = meBBAnalyze->New<BBAnalyze>(*meBBAnalyze, *func);
+    if (func->IsIRProfValid()) {
+      bbAnalyze->SetHotAndColdBBCountThreshold();
+      return bbAnalyze;
+    }
+    return nullptr;
+  }
+#endif
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_bb_layout.cpp b/src/mapleall/maple_me/src/me_bb_layout.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d5c65fb3f0f689984aa1309a5359d37b540cf405
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_bb_layout.cpp
@@ -0,0 +1,1400 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_bb_layout.h"
+
+#include "bb.h"
+#include "maple_phase.h"
+#include "me_cfg.h"
+#include "me_critical_edge.h"
+#include "me_irmap.h"
+#include "me_option.h"
+#include "me_predict.h"
+
+// This BB layout strategy strictly obeys source ordering when inside try blocks.
+// This Optimization will reorder the bb layout. it start from the first bb of func.
+// All bbs will be put into layoutBBs and it gives the determined layout order.
+// The entry of the optimization is MeDoBBLayout::Run. If func's IR profile is
+// valid, use the either chain layout or Pettis & Hansen intra func bb layout
+// according to useChainLayout argument.
+// the PH layout refer the following paper:
+// Profile Guided Code Positioning
+// The idea is when there's a branch, put the most probility target next to
+// the branch to get the minimum jump distance.
+// If the profile is invalid, do the normal bb layout:
+// It starts from the first bb.
+// 1. If curBB is condtion goto or goto kind, do OptimizeBranchTarget for bb.
+// 2. Find curBB's next bb nextBB, and based on nextBB do the following:
+// 3. (1) For fallthru/catch/finally, fix curBB's fallthru
+//    (2) For condtion goto curBB:
+//        i) If the target bb can be moved, then put it as currBB's next
+//           and retarget curBB to it's fallthru bb. add targetBB as next.
+//        ii) If curBB's fallthru is not its next bb add fallthru as its next if
+//            fallthru can be moved else create a new fallthru contains a goto to
+//            the original fallthru
+//    (3) For goto curBB see if goto target can be placed as next.
+// 5. do step 3 for nextBB until all bbs are laid out
+namespace maple {
+static constexpr uint32 kMaxNumBBToPredict = 7500;
+
+static void CreateGoto(BB &bb, MeFunction &func, BB &fallthru) {
+  LabelIdx label = func.GetOrCreateBBLabel(fallthru);
+  if (func.GetIRMap() != nullptr) {
+    GotoNode stmt(OP_goto);
+    auto *newGoto = func.GetIRMap()->New<GotoMeStmt>(&stmt);
+    newGoto->SetOffset(label);
+    bb.AddMeStmtLast(newGoto);
+  } else {
+    auto *newGoto = func.GetMirFunc()->GetCodeMempool()->New<GotoNode>(OP_goto);
+    newGoto->SetOffset(label);
+    bb.AddStmtNode(newGoto);
+  }
+  bb.SetKind(kBBGoto);
+}
+
+bool BBLayout::IsBBInCurrContext(const BB &bb, const MapleVector<bool> *context) const {
+  if (context == nullptr) {
+    return true;
+  }
+  return (*context)[bb.GetBBId()];
+}
+
+// Create chains for each BB
+void BBLayout::InitBBChains() {
+  uint32 id = 0;
+  bb2chain.resize(cfg->NumBBs(), nullptr);
+  for (auto it = cfg->valid_begin(); it != cfg->valid_end(); ++it) {
+    // BBChain constructor will update bb2chain
+    (void)layoutAlloc.GetMemPool()->New<BBChain>(layoutAlloc, bb2chain, *it, id++);
+  }
+}
+
+void BBLayout::BuildChainForFunc() {
+  debugChainLayout = enabledDebug;
+  uint32 validBBNum = 0;
+  for (auto it = cfg->valid_begin(); it != cfg->valid_end(); ++it) {
+    ++validBBNum;
+  }
+  --validBBNum;  // exclude common entry BB
+  if (debugChainLayout) {
+    LogInfo::MapleLogger() << "\n[Chain layout] " << func.GetName() << ", valid bb num: " << validBBNum << std::endl;
+  }
+  InitBBChains();
+  BuildChainForLoops();
+  // init ready chains for func
+  for (auto it = cfg->valid_begin(); it != cfg->valid_end(); ++it) {
+    BB *bb = *it;
+    BBId bbId = bb->GetBBId();
+    BBChain *chain = bb2chain[bbId];
+    if (chain->IsReadyToLayout(nullptr)) {
+      readyToLayoutChains.insert(chain);
+    }
+  }
+  BB *entryBB = func.GetCfg()->GetCommonEntryBB();
+  BBChain *entryChain = bb2chain[entryBB->GetBBId()];
+  DoBuildChain(*entryBB, *entryChain, nullptr);
+  // To sure all of BBs have been laid out
+  CHECK_FATAL(entryChain->size() == validBBNum, "has any BB not been laid out?");
+}
+
+void BBLayout::BuildChainForLoops() {
+  if (meLoop == nullptr || meLoop->GetMeLoops().empty()) {
+    return;
+  }
+  auto &loops = meLoop->GetMeLoops();
+  // sort loops from inner most to outer most
+  // need use the same sort rules as prediction?
+  std::stable_sort(loops.begin(), loops.end(),
+                   [](const LoopDesc *loop1, const LoopDesc *loop2) { return loop1->nestDepth > loop2->nestDepth; });
+  // build chain for loops one by one
+  auto *context = layoutAlloc.GetMemPool()->New<MapleVector<bool>>(cfg->NumBBs(), false, layoutAlloc.Adapter());
+  for (auto *loop : loops) {
+    BuildChainForLoop(loop, context);
+  }
+}
+
+void BBLayout::BuildChainForLoop(LoopDesc *loop, MapleVector<bool> *context) {
+  // init loop context
+  std::fill(context->begin(), context->end(), false);
+  for (BBId bbId : loop->loopBBs) {
+    (*context)[bbId] = true;
+  }
+  // init ready chains for loop
+  for (BBId bbId : loop->loopBBs) {
+    BBChain *chain = bb2chain[bbId];
+    if (chain->IsReadyToLayout(context)) {
+      readyToLayoutChains.insert(chain);
+    }
+  }
+  // find loop chain starting BB
+  BB *startBB = FindBestStartBBForLoop(loop, context);
+  if (startBB == nullptr) {
+    return;  // all blocks in the loop have been laid out, just return
+  }
+  BBChain *startChain = bb2chain[startBB->GetBBId()];
+  DoBuildChain(*startBB, *startChain, context);
+  readyToLayoutChains.clear();
+}
+
+// Multiple loops may share the same header, we try to find the best unplaced BB in the loop
+// This function can be improved
+BB *BBLayout::FindBestStartBBForLoop(LoopDesc *loop, const MapleVector<bool> *context) {
+  // If the loop header has not been placed, take it as start BB of the loop chain
+  auto *headerChain = bb2chain[loop->head->GetBBId()];
+  if (headerChain->size() == 1) {
+    return loop->head;
+  }
+  // take inner loop chain tail BB as start BB
+  if (headerChain->size() > 1 && IsBBInCurrContext(*headerChain->GetTail(), context)) {
+    return headerChain->GetTail();
+  }
+  for (BBId bbId : loop->loopBBs) {
+    if (bb2chain[bbId]->size() == 1) {
+      return cfg->GetBBFromID(bbId);
+    }
+  }
+  return nullptr;
+}
+
+void BBLayout::DoBuildChain(const BB &header, BBChain &chain, const MapleVector<bool> *context) {
+  CHECK_FATAL(bb2chain[header.GetBBId()] == &chain, "bb2chain mis-match");
+  BB *bb = chain.GetTail();
+  BB *bestSucc = GetBestSucc(*bb, chain, context, false);
+  while (bestSucc != nullptr) {
+    BBChain *succChain = bb2chain[bestSucc->GetBBId()];
+    succChain->UpdateSuccChainBeforeMerged(chain, context, readyToLayoutChains);
+    chain.MergeFrom(succChain);
+    readyToLayoutChains.erase(succChain);
+    bb = chain.GetTail();
+    bestSucc = GetBestSucc(*bb, chain, context, false);
+  }
+  if (debugChainLayout) {
+    bool inLoop = context != nullptr;
+    LogInfo::MapleLogger() << "Finish forming " << (inLoop ? "loop" : "func") << " chain: ";
+    chain.Dump();
+  }
+}
+
+bool BBLayout::IsCandidateSucc(const BB &bb, const BB &succ, const MapleVector<bool> *context) {
+  if (!IsBBInCurrContext(succ, context)) {  // succ must be in the current context (current loop or current func)
+    return false;
+  }
+  if (succ.GetKind() == kBBNoReturn) {
+    return false;  // noreturn BB is unlikely taken
+  }
+  if (bb2chain[succ.GetBBId()] == bb2chain[bb.GetBBId()]) {  // bb and succ should belong to different chains
+    return false;
+  }
+  if (succ.GetBBId() == 1) {  // special case, exclude common exit BB
+    return false;
+  }
+  return true;
+}
+
+// Whether succ has a better layout pred than bb
+bool BBLayout::HasBetterLayoutPred(const BB &bb, BB &succ) {
+  auto &predList = succ.GetPred();
+  // predList.size() may be 0 if bb is common entry BB
+  if (predList.size() <= 1) {
+    return false;
+  }
+  uint64 sumEdgeFreq = succ.GetFrequency();
+  const double hotEdgeFreqPercent = 0.8;  // should further fine tuning
+  uint64 hotEdgeFreq = static_cast<uint64>(sumEdgeFreq * hotEdgeFreqPercent);
+  // if edge freq(bb->succ) contribute more than 80% to succ block freq, no better layout pred than bb
+  for (uint32 i = 0; i < predList.size(); ++i) {
+    if (predList[i] == &bb) {
+      continue;
+    }
+    uint64 edgeFreq = predList[i]->GetEdgeFreq(&succ);
+    if (edgeFreq > (sumEdgeFreq - hotEdgeFreq)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// considerBetterPredForSucc: whether consider better layout pred for succ, we found better
+// performance when this argument is disabled
+BB *BBLayout::GetBestSucc(BB &bb, const BBChain &chain, const MapleVector<bool> *context,
+                          bool considerBetterPredForSucc) {
+  // (1) search in succ
+  CHECK_FATAL(bb2chain[bb.GetBBId()] == &chain, "bb2chain mis-match");
+  uint32 bestEdgeFreq = 0;
+  BB *bestSucc = nullptr;
+  for (uint32 i = 0; i < bb.GetSucc().size(); ++i) {
+    BB *succ = bb.GetSucc(i);
+    if (!IsCandidateSucc(bb, *succ, context)) {
+      continue;
+    }
+    if (considerBetterPredForSucc && HasBetterLayoutPred(bb, *succ)) {
+      continue;
+    }
+    uint32 currEdgeFreq = static_cast<uint32>(bb.GetEdgeFreq(i));  // attention: entryBB->succFreq[i] is always 0
+    if (bb.GetBBId() == 0) {                                       // special case for common entry BB
+      CHECK_FATAL(bb.GetSucc().size() == 1, "common entry BB should not have more than 1 succ");
+      bestSucc = succ;
+      break;
+    }
+    if (currEdgeFreq > bestEdgeFreq) {  // find max edge freq
+      bestEdgeFreq = currEdgeFreq;
+      bestSucc = succ;
+    }
+  }
+  if (bestSucc != nullptr) {
+    if (debugChainLayout) {
+      LogInfo::MapleLogger() << "Select [range1 succ ]: ";
+      LogInfo::MapleLogger() << bb.GetBBId() << " -> " << bestSucc->GetBBId() << std::endl;
+    }
+    return bestSucc;
+  }
+
+  // (2) search in readyToLayoutChains
+  uint64 bestFreq = 0;
+  for (auto it = readyToLayoutChains.begin(); it != readyToLayoutChains.end(); ++it) {
+    BBChain *readyChain = *it;
+    BB *header = readyChain->GetHeader();
+    if (!IsCandidateSucc(bb, *header, context)) {
+      continue;
+    }
+    bool useBBFreq = false;
+    if (useBBFreq) {                            // use bb freq
+      if (header->GetFrequency() > bestFreq) {  // find max bb freq
+        bestFreq = header->GetFrequency();
+        bestSucc = header;
+      }
+    } else {  // use edge freq
+      uint32 subBestFreq = 0;
+      for (auto *pred : header->GetPred()) {
+        uint32 curFreq = static_cast<uint32>(pred->GetEdgeFreq(header));
+        if (curFreq > subBestFreq) {
+          subBestFreq = curFreq;
+        }
+      }
+      if (subBestFreq > bestFreq) {
+        bestFreq = subBestFreq;
+        bestSucc = header;
+      } else if (subBestFreq == bestFreq && bestSucc != nullptr &&
+                 bb2chain[header->GetBBId()]->GetId() < bb2chain[bestSucc->GetBBId()]->GetId()) {
+        bestSucc = header;
+      }
+    }
+  }
+  if (bestSucc != nullptr) {
+    readyToLayoutChains.erase(bb2chain[bestSucc->GetBBId()]);
+    if (debugChainLayout) {
+      LogInfo::MapleLogger() << "Select [range2 ready]: ";
+      LogInfo::MapleLogger() << bb.GetBBId() << " -> " << bestSucc->GetBBId() << std::endl;
+    }
+    return bestSucc;
+  }
+
+  // (3) search left part in context by topological sequence
+  const auto &rpoVec = dom->GetReversePostOrder();
+  bool searchedAgain = false;
+  for (uint32 i = rpoSearchPos; i < rpoVec.size(); ++i) {
+    auto *candBB = cfg->GetBBFromID(BBId(rpoVec[i]->GetID()));
+    if (IsBBInCurrContext(*candBB, context) && bb2chain[candBB->GetBBId()] != &chain) {
+      rpoSearchPos = i;
+      if (debugChainLayout) {
+        LogInfo::MapleLogger() << "Select [range3 rpot ]: ";
+        LogInfo::MapleLogger() << bb.GetBBId() << " -> " << candBB->GetBBId() << std::endl;
+      }
+      return candBB;
+    }
+    if (i == rpoVec.size() - 1 && !searchedAgain) {
+      i = 0;
+      searchedAgain = true;
+    }
+  }
+  return nullptr;
+}
+
+// return true if bb is empty and its kind is fallthru.
+bool BBLayout::BBEmptyAndFallthru(const BB &bb) {
+  if (bb.GetAttributes(kBBAttrIsTryEnd)) {
+    return false;
+  }
+  if (bb.GetKind() == kBBFallthru) {
+    if (func.GetIRMap() != nullptr) {
+      return bb.IsMeStmtEmpty();
+    }
+    return bb.IsEmpty();
+  }
+  return false;
+}
+
+// Return true if bb only has conditonal branch stmt except comment
+bool BBLayout::BBContainsOnlyCondGoto(const BB &bb) const {
+  if (bb.GetKind() != kBBCondGoto || bb.GetAttributes(kBBAttrIsTryEnd)) {
+    return false;
+  }
+
+  if (func.GetIRMap() != nullptr) {
+    auto &meStmts = bb.GetMeStmts();
+    if (meStmts.empty()) {
+      return false;
+    }
+    for (auto itMeStmt = meStmts.begin(); itMeStmt != meStmts.rbegin().base(); ++itMeStmt) {
+      if (!itMeStmt->IsCondBr() && itMeStmt->GetOp() != OP_comment) {
+        return false;
+      }
+    }
+    return meStmts.back().IsCondBr();
+  }
+  auto &stmtNodes = bb.GetStmtNodes();
+  if (stmtNodes.empty()) {
+    return false;
+  }
+  for (auto itStmt = stmtNodes.begin(); itStmt != stmtNodes.rbegin().base(); ++itStmt) {
+    if (!itStmt->IsCondBr() && itStmt->GetOpCode() != OP_comment) {
+      return false;
+    }
+  }
+  return bb.GetStmtNodes().back().IsCondBr();
+}
+
+bool BBLayout::ChooseTargetAsFallthru(const BB &bb, const BB &targetBB, const BB &oldFallThru,
+                                      const BB &fallThru) const {
+  if (&targetBB == &fallThru) {
+    return false;
+  }
+  if (profValid) {
+    uint64 freqToTargetBB = bb.GetEdgeFreq(&targetBB);
+    uint64 freqToFallthru = bb.GetEdgeFreq(&fallThru);
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << func.GetName() << " " << bb.GetBBId() << "->" << targetBB.GetBBId() << " freq "
+                             << freqToTargetBB << " " << bb.GetBBId() << "->" << fallThru.GetBBId() << " freq "
+                             << freqToFallthru << '\n';
+    }
+    if ((freqToTargetBB > freqToFallthru) && BBCanBeMovedBasedProf(targetBB, bb)) {
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << func.GetName() << bb.GetBBId() << " move targeBB " << targetBB.GetBBId()
+                               << " to fallThru" << '\n';
+      }
+      return true;
+    }
+  } else {
+    if ((&oldFallThru != &fallThru || fallThru.GetPred().size() > 1) && BBCanBeMoved(targetBB, bb)) {
+      return true;
+    }
+  }
+  return false;
+}
+// Return the opposite opcode for condition/compare opcode.
+static Opcode GetOppositeOp(Opcode opcInput) {
+  Opcode opc = OP_undef;
+  switch (opcInput) {
+    case OP_brtrue:
+      opc = OP_brfalse;
+      break;
+    case OP_brfalse:
+      opc = OP_brtrue;
+      break;
+    case OP_ne:
+      opc = OP_eq;
+      break;
+    case OP_eq:
+      opc = OP_ne;
+      break;
+    case OP_gt:
+      opc = OP_le;
+      break;
+    case OP_le:
+      opc = OP_gt;
+      break;
+    case OP_lt:
+      opc = OP_ge;
+      break;
+    case OP_ge:
+      opc = OP_lt;
+      break;
+    default:
+      break;
+  }
+  return opc;
+}
+
+bool BBLayout::BBContainsOnlyGoto(const BB &bb) const {
+  if (bb.GetKind() != kBBGoto || bb.GetAttributes(kBBAttrIsTryEnd)) {
+    return false;
+  }
+
+  if (func.GetIRMap() != nullptr) {
+    auto &meStmts = bb.GetMeStmts();
+    if (meStmts.empty()) {
+      return false;
+    }
+    for (auto itMeStmt = meStmts.begin(); itMeStmt != meStmts.rbegin().base(); ++itMeStmt) {
+      if (itMeStmt->GetOp() != OP_goto && itMeStmt->GetOp() != OP_comment) {
+        return false;
+      }
+    }
+    return meStmts.back().GetOp() == OP_goto;
+  }
+  auto &stmtNodes = bb.GetStmtNodes();
+  if (stmtNodes.empty()) {
+    return false;
+  }
+  for (auto itStmt = stmtNodes.begin(); itStmt != stmtNodes.rbegin().base(); ++itStmt) {
+    if (itStmt->GetOpCode() != OP_goto && itStmt->GetOpCode() != OP_comment) {
+      return false;
+    }
+  }
+  return bb.GetStmtNodes().back().GetOpCode() == OP_goto;
+}
+
+// Return true if all the following are satisfied:
+// 1.fromBB only has one predecessor
+// 2.fromBB has not been laid out.
+// 3.fromBB has only one succor when fromBB is artifical or fromBB and
+//   toafter_bb are both not in try block.
+// The other case is fromBB has one predecessor and one successor and
+// contains only goto stmt.
+bool BBLayout::BBCanBeMoved(const BB &fromBB, const BB &toAfterBB) const {
+  if (laidOut[fromBB.GetBBId()]) {
+    return false;
+  }
+  if (fromBB.GetPred().size() > 1) {
+    // additional condition: if all preds have been laidout, fromBB can be freely moved
+    for (auto *pred : fromBB.GetPred()) {
+      if (!laidOut[pred->GetBBId()]) {
+        return false;
+      }
+    }
+  }
+
+  if (fromBB.GetAttributes(kBBAttrArtificial) ||
+      (!fromBB.GetAttributes(kBBAttrIsTry) && !toAfterBB.GetAttributes(kBBAttrIsTry))) {
+    return fromBB.GetSucc().size() == 1;
+  }
+  return BBContainsOnlyGoto(fromBB);
+}
+
+// Return true if all the following are satisfied:
+// 1.fromBB has not been laid out.
+// 2.fromBB has only one succor when fromBB is artifical or fromBB and
+//   toafter_bb are both not in try block.
+// The other case is fromBB contains only goto stmt.
+bool BBLayout::BBCanBeMovedBasedProf(const BB &fromBB, const BB &toAfterBB) const {
+  if (laidOut[fromBB.GetBBId()]) {
+    return false;
+  }
+  if (fromBB.GetAttributes(kBBAttrArtificial) ||
+      (!fromBB.GetAttributes(kBBAttrIsTry) && !toAfterBB.GetAttributes(kBBAttrIsTry))) {
+    return fromBB.GetSucc().size() <= 1;
+  }
+  return BBContainsOnlyGoto(fromBB);
+}
+
+// Return true if bb1 and bb2 has the branch conditon.such as
+// bb1 : brfalse (a > 3)  bb2: brfalse (a > 3)/ brtrue (a <= 3)
+bool BBLayout::HasSameBranchCond(BB &bb1, BB &bb2) const {
+  if (func.GetIRMap() == nullptr) {
+    return false;
+  }
+  auto &meStmt1 = static_cast<CondGotoMeStmt&>(bb1.GetMeStmts().back());
+  auto &meStmt2 = static_cast<CondGotoMeStmt&>(bb2.GetMeStmts().back());
+  MeExpr *expr1 = meStmt1.GetOpnd();
+  MeExpr *expr2 = meStmt2.GetOpnd();
+  // Compare the opcode:  brtrue/brfalse
+  if (!(meStmt1.GetOp() == meStmt2.GetOp() && expr1->GetOp() == expr2->GetOp()) &&
+      !(meStmt1.GetOp() == GetOppositeOp(meStmt2.GetOp()) && expr1->GetOp() == GetOppositeOp(expr2->GetOp()))) {
+    return false;
+  }
+  if (!(expr1->GetMeOp() == expr2->GetMeOp() && expr1->GetMeOp() == kMeOpOp)) {
+    return false;
+  }
+  auto *opMeExpr1 = static_cast<OpMeExpr*>(expr1);
+  auto *opMeExpr2 = static_cast<OpMeExpr*>(expr2);
+  // Compare the two operands to make sure they are both equal.
+  if (opMeExpr1->GetOpnd(0) != opMeExpr2->GetOpnd(0)) {
+    return false;
+  }
+  // If one side is const, assume it is always the rhs.
+  if ((opMeExpr1->GetOpnd(1) != opMeExpr2->GetOpnd(1)) &&
+      !(opMeExpr1->GetOpnd(1)->IsZero() && opMeExpr2->GetOpnd(1)->IsZero())) {
+    return false;
+  }
+  return true;
+}
+
+bool BBLayout::BBIsEmpty(const BB *bb) {
+  CHECK_FATAL(bb, "bb is nullptr!");
+  if (func.GetIRMap() != nullptr) {
+    return bb->IsMeStmtEmpty();
+  }
+  return bb->IsEmpty();
+}
+
+void BBLayout::OptimizeCaseTargets(BB *switchBB, CaseVector *swTable) {
+  CaseVector::iterator caseIt = swTable->begin();
+  for (; caseIt != swTable->end(); ++caseIt) {
+    LabelIdx lidx = caseIt->second;
+    BB *brTargetBB = func.GetCfg()->GetLabelBBAt(lidx);
+    CHECK_FATAL(brTargetBB, "brTargetBB is nullptr!");
+    if (brTargetBB->GetSucc().size() != 0) {
+      OptimizeBranchTarget(*brTargetBB);
+    }
+    if (brTargetBB->GetSucc().size() != 1) {
+      continue;
+    }
+    if (!(BBContainsOnlyGoto(*brTargetBB) || BBIsEmpty(brTargetBB))) {
+      continue;
+    }
+    BB *newTargetBB = brTargetBB->GetSucc().front();
+    if (newTargetBB == brTargetBB) {
+      continue;
+    }
+    LabelIdx newTargetLabel = func.GetOrCreateBBLabel(*newTargetBB);
+    caseIt->second = newTargetLabel;
+    if (!newTargetBB->IsSuccBB(*switchBB)) {
+      switchBB->AddSucc(*newTargetBB);
+    }
+  }
+}
+
+// (1) bb's last statement is a conditional or unconditional branch; if the branch
+// target is a BB with only a single goto statement, optimize the branch target
+// to the eventual target
+// (2) bb's last statement is a conditonal branch, if the branch target is a BB with a single
+// conditional branch statement and has the same condition as bb's last statement, optimize the
+// branch target to the eventual target.
+void BBLayout::OptimizeBranchTarget(BB &bb) {
+  if (bbVisited[bb.GetBBId().GetIdx()]) {
+    return;
+  }
+  if (func.GetIRMap() != nullptr) {
+    auto &meStmts = bb.GetMeStmts();
+    if (meStmts.empty()) {
+      return;
+    }
+    if (meStmts.back().GetOp() != OP_goto && !meStmts.back().IsCondBr()) {
+      return;
+    }
+  } else {
+    auto &stmtNodes = bb.GetStmtNodes();
+    if (stmtNodes.empty()) {
+      return;
+    }
+    if (stmtNodes.back().GetOpCode() != OP_goto && !stmtNodes.back().IsCondBr()) {
+      return;
+    }
+  }
+  do {
+    ASSERT(!bb.GetSucc().empty(), "container check");
+    // condgoto's succ layout: [0] fallthru succ, [1] target succ, [2-...] eh succ/wontexit succ
+    // goto's succ layout: [0] target succ, [1-...] eh succ/wontexit succ
+    BB *brTargetBB = bb.GetKind() == kBBCondGoto ? bb.GetSucc(1) : bb.GetSucc(0);
+    CHECK_FATAL((bb.GetKind() != kBBCondGoto || bb.GetSucc(1) != bb.GetSucc(0)), "target is same as fallthru");
+    if (brTargetBB->GetAttributes(kBBAttrWontExit)) {
+      return;
+    }
+    if (!BBContainsOnlyGoto(*brTargetBB) && !BBEmptyAndFallthru(*brTargetBB) &&
+        !(bb.GetKind() == kBBCondGoto && brTargetBB->GetKind() == kBBCondGoto && &bb != brTargetBB &&
+          BBContainsOnlyCondGoto(*brTargetBB) && HasSameBranchCond(bb, *brTargetBB))) {
+      return;
+    }
+    bbVisited[bb.GetBBId().GetIdx()] = true;
+    OptimizeBranchTarget(*brTargetBB);
+    // optimize stmt
+    BB *newTargetBB = (brTargetBB->GetKind() == kBBCondGoto) ? brTargetBB->GetSucc(1) : brTargetBB->GetSucc(0);
+    if (newTargetBB == brTargetBB) {
+      return;
+    }
+    LabelIdx newTargetLabel = func.GetOrCreateBBLabel(*newTargetBB);
+    if (func.GetIRMap() != nullptr) {
+      auto &lastStmt = bb.GetMeStmts().back();
+      if (lastStmt.GetOp() == OP_goto) {
+        auto &gotoMeStmt = static_cast<GotoMeStmt&>(lastStmt);
+        ASSERT(brTargetBB->GetBBLabel() == gotoMeStmt.GetOffset(), "OptimizeBranchTarget: wrong branch target BB");
+        gotoMeStmt.SetOffset(newTargetLabel);
+      } else {
+        auto &gotoMeStmt = static_cast<CondGotoMeStmt&>(lastStmt);
+        ASSERT(brTargetBB->GetBBLabel() == gotoMeStmt.GetOffset(), "OptimizeBranchTarget: wrong branch target BB");
+        gotoMeStmt.SetOffset(newTargetLabel);
+      }
+    } else {
+      StmtNode &lastStmt = bb.GetStmtNodes().back();
+      if (lastStmt.GetOpCode() == OP_goto) {
+        auto &gotoNode = static_cast<GotoNode&>(lastStmt);
+        ASSERT(brTargetBB->GetBBLabel() == gotoNode.GetOffset(), "OptimizeBranchTarget: wrong branch target BB");
+        gotoNode.SetOffset(newTargetLabel);
+      } else {
+        auto &gotoNode = static_cast<CondGotoNode&>(lastStmt);
+        ASSERT(brTargetBB->GetBBLabel() == gotoNode.GetOffset(), "OptimizeBranchTarget: wrong branch target BB");
+        gotoNode.SetOffset(newTargetLabel);
+      }
+    }
+    // update CFG
+    bb.ReplaceSucc(brTargetBB, newTargetBB);
+    if (brTargetBB->GetPred().empty()) {
+      laidOut[brTargetBB->GetBBId()] = true;
+      RemoveUnreachable(*brTargetBB);
+      if (needDealWithTryBB) {
+        DealWithStartTryBB();
+      }
+    }
+  } while (true);
+}
+
+void BBLayout::AddBB(BB &bb) {
+  CHECK_FATAL(bb.GetBBId() < laidOut.size(), "index out of range in BBLayout::AddBB");
+  ASSERT(!laidOut[bb.GetBBId()], "AddBB: bb already laid out");
+  layoutBBs.push_back(&bb);
+  laidOut[bb.GetBBId()] = true;
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "bb id " << bb.GetBBId() << " kind is " << bb.StrAttribute();
+  }
+  bool isTry = false;
+  if (func.GetIRMap() != nullptr) {
+    isTry = !bb.GetMeStmts().empty() && bb.GetMeStmts().front().GetOp() == OP_try;
+  } else {
+    isTry = !bb.GetStmtNodes().empty() && bb.GetStmtNodes().front().GetOpCode() == OP_try;
+  }
+  if (isTry) {
+    ASSERT(!tryOutstanding, "BBLayout::AddBB: cannot lay out another try without ending the last one");
+    tryOutstanding = true;
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << " try";
+    }
+  }
+  if (bb.GetAttributes(kBBAttrIsTryEnd) && func.GetMIRModule().IsJavaModule()) {
+    tryOutstanding = false;
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << " endtry";
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << '\n';
+  }
+  // If the pred bb is goto bb and the target bb of goto bb is the current bb which is be added to layoutBBs, change the
+  // goto bb to fallthru bb.
+  if (layoutBBs.size() > 1) {
+    BB *predBB = layoutBBs.at(layoutBBs.size() - 2);  // Get the pred of bb.
+    if (predBB->GetKind() != kBBGoto) {
+      return;
+    }
+    if (func.GetIRMap() != nullptr) {
+      ASSERT_NOT_NULL(predBB->GetLastMe());
+      if (predBB->GetLastMe()->GetOp() == OP_throw) {
+        return;
+      }
+    } else {
+      if (predBB->GetLast().GetOpCode() == OP_throw) {
+        return;
+      }
+    }
+    if (predBB->GetSucc().front() != &bb) {
+      return;
+    }
+    ChangeToFallthruFromGoto(*predBB);
+  }
+}
+
+BB *BBLayout::GetFallThruBBSkippingEmpty(BB &bb) {
+  ASSERT(bb.GetKind() == kBBFallthru || bb.GetKind() == kBBCondGoto, "GetFallThruSkippingEmpty: unexpected BB kind");
+  ASSERT(!bb.GetSucc().empty(), "container check");
+  BB *fallthru = bb.GetSucc().front();
+  do {
+    if (fallthru->GetPred().size() > 1 || fallthru->GetAttributes(kBBAttrIsTryEnd)) {
+      return fallthru;
+    }
+    if (func.GetIRMap() != nullptr) {
+      if (!fallthru->IsMeStmtEmpty() && !BBContainsOnlyGoto(*fallthru)) {
+        return fallthru;
+      }
+    } else {
+      if (!fallthru->IsEmpty()) {
+        return fallthru;
+      }
+    }
+    // in case of duplicate succ
+    if (fallthru->GetSucc().front() == bb.GetSucc().back()) {
+      return fallthru;
+    }
+    laidOut[fallthru->GetBBId()] = true;
+    BB *oldFallThru = fallthru;
+    fallthru = fallthru->GetSucc().front();
+    bb.ReplaceSucc(oldFallThru, fallthru);
+    if (oldFallThru->GetPred().empty()) {
+      RemoveUnreachable(*oldFallThru);
+      if (needDealWithTryBB) {
+        DealWithStartTryBB();
+      }
+    }
+  } while (true);
+}
+
+// bb end with a goto statement; remove the goto stmt if its target
+// is its fallthru nextBB.
+void BBLayout::ChangeToFallthruFromGoto(BB &bb) {
+  ASSERT(bb.GetKind() == kBBGoto, "ChangeToFallthruFromGoto: unexpected BB kind");
+  if (func.GetIRMap() != nullptr) {
+    bb.RemoveMeStmt(to_ptr(bb.GetMeStmts().rbegin()));
+  } else {
+    bb.RemoveLastStmt();
+  }
+  bb.SetKind(kBBFallthru);
+}
+
+void BBLayout::ChangeToFallthruFromCondGoto(BB &bb) {
+  ASSERT(bb.GetKind() == kBBCondGoto, "ChangeToFallthruFromCondGoto: unexpected BB kind");
+  if (func.GetIRMap() != nullptr) {
+    bb.RemoveMeStmt(to_ptr(bb.GetMeStmts().rbegin()));
+  } else {
+    bb.RemoveLastStmt();
+  }
+  bb.SetKind(kBBFallthru);
+}
+
+// bb does not end with a branch statement; if its fallthru is not nextBB,
+// perform the fix by either laying out the fallthru immediately or adding a goto
+void BBLayout::ResolveUnconditionalFallThru(BB &bb, BB &nextBB) {
+  if (bb.GetKind() != kBBFallthru) {
+    return;
+  }
+  ASSERT(bb.GetAttributes(kBBAttrIsTry) || bb.GetAttributes(kBBAttrWontExit) || bb.GetSucc().size() == 1,
+         "runtime check error");
+  BB *fallthru = GetFallThruBBSkippingEmpty(bb);
+  if (fallthru != &nextBB) {
+    if (BBCanBeMoved(*fallthru, bb)) {
+      AddBB(*fallthru);
+      SetAttrTryForTheCanBeMovedBB(bb, *fallthru);
+      ResolveUnconditionalFallThru(*fallthru, nextBB);
+      OptimizeBranchTarget(*fallthru);
+    } else {
+      CreateGoto(bb, func, *fallthru);
+      OptimizeBranchTarget(bb);
+    }
+  }
+}
+
+void BBLayout::FixEndTryBB(BB &bb) {
+  BBId prevID = bb.GetBBId() - 1UL;
+  for (BBId id = prevID; id != 0; --id) {
+    auto prevBB = func.GetCfg()->GetBBFromID(id);
+    if (prevBB != nullptr) {
+      if (prevBB->GetAttributes(kBBAttrIsTry) && !prevBB->GetAttributes(kBBAttrIsTryEnd)) {
+        prevBB->SetAttributes(kBBAttrIsTryEnd);
+        cfg->SetTryBBByOtherEndTryBB(prevBB, &bb);
+      }
+      break;
+    }
+  }
+}
+
+void BBLayout::FixTryBB(BB &startTryBB, BB &nextBB) {
+  startTryBB.RemoveAllPred();
+  for (size_t i = 0; i < nextBB.GetPred().size(); ++i) {
+    nextBB.GetPred(i)->ReplaceSucc(&nextBB, &startTryBB);
+  }
+  nextBB.RemoveAllPred();
+  ASSERT(startTryBB.GetSucc().empty(), "succ of try should have been removed");
+  startTryBB.AddSucc(nextBB);
+}
+
+void BBLayout::DealWithStartTryBB() {
+  size_t size = startTryBBVec.size();
+  for (size_t i = 0; i < size; ++i) {
+    if (!startTryBBVec[i]) {
+      continue;
+    }
+    auto curBB = cfg->GetBBFromID(BBId(i));
+    for (size_t j = i + 1; j < size && !startTryBBVec[j]; ++j) {
+      auto nextBB = cfg->GetBBFromID(BBId(j));
+      if (nextBB != nullptr) {
+        if (nextBB->GetAttributes(kBBAttrIsTry)) {
+          FixTryBB(*curBB, *nextBB);
+        } else {
+          curBB->RemoveAllSucc();
+          cfg->NullifyBBByID(curBB->GetBBId());
+          for (auto it = layoutBBs.begin(); it != layoutBBs.end(); ++it) {
+            if (*it == curBB) {
+              layoutBBs.erase(it);
+              break;
+            }
+          }
+        }
+        break;
+      } else if (j == size - 1) {
+        curBB->RemoveAllSucc();
+        cfg->NullifyBBByID(curBB->GetBBId());
+        for (auto it = layoutBBs.begin(); it != layoutBBs.end(); ++it) {
+          if (*it == curBB) {
+            layoutBBs.erase(it);
+            break;
+          }
+        }
+      }
+    }
+    startTryBBVec[i] = false;
+  }
+  needDealWithTryBB = false;
+}
+
+// remove unnessary bb whose pred size is zero
+// keep cfg correct to rebuild dominance
+void BBLayout::RemoveUnreachable(BB &bb) {
+  if (bb.GetAttributes(kBBAttrIsEntry)) {
+    return;
+  }
+
+  while (!bb.GetSucc().empty()) {
+    BB *succ = bb.GetSucc(0);
+    succ->RemovePred(bb, false);
+    if (succ->GetPred().empty()) {
+      RemoveUnreachable(*succ);
+    }
+  }
+
+  if (bb.GetAttributes(kBBAttrIsTry) && !bb.GetAttributes(kBBAttrIsTryEnd)) {
+    // identify if try bb is the start try bb
+    if (!bb.GetMeStmts().empty() && bb.GetMeStmts().front().GetOp() == OP_try) {
+      startTryBBVec[bb.GetBBId()] = true;
+      needDealWithTryBB = true;
+      return;
+    }
+  }
+  if (bb.GetAttributes(kBBAttrIsTryEnd)) {
+    FixEndTryBB(bb);
+  }
+  bb.RemoveAllSucc();
+  cfg->NullifyBBByID(bb.GetBBId());
+  for (auto it = layoutBBs.begin(); it != layoutBBs.end(); ++it) {
+    if (*it == &bb) {
+      layoutBBs.erase(it);
+      break;
+    }
+  }
+}
+
+void BBLayout::UpdateNewBBWithAttrTry(const BB &bb, BB &fallthru) const {
+  auto tryBB = &bb;
+  fallthru.SetAttributes(kBBAttrIsTry);
+  if (bb.IsReturnBB()) {
+    int i = 1;
+    tryBB = cfg->GetBBFromID(bb.GetBBId() - i);
+    while (tryBB == nullptr || tryBB->IsReturnBB()) {
+      ++i;
+      tryBB = cfg->GetBBFromID(bb.GetBBId() - i);
+    }
+    ASSERT_NOT_NULL(tryBB);
+    ASSERT(tryBB->GetAttributes(kBBAttrIsTry), "must be try");
+  }
+  bool setEHEdge = false;
+  for (auto *candCatch : tryBB->GetSucc()) {
+    if (candCatch != nullptr && candCatch->GetAttributes(kBBAttrIsCatch)) {
+      setEHEdge = true;
+      fallthru.AddSucc(*candCatch);
+    }
+  }
+  ASSERT(setEHEdge, "must set eh edge");
+}
+
+// create a new fallthru that contains a goto to the original fallthru
+// bb              bb
+//  |     ====>    |
+//  |              [NewCreated]
+//  |              |
+// fallthru       fallthru
+BB *BBLayout::CreateGotoBBAfterCondBB(BB &bb, BB &fallthru) {
+  ASSERT(bb.GetKind() == kBBCondGoto, "CreateGotoBBAfterCondBB: unexpected BB kind");
+  BB *newFallthru = cfg->NewBasicBlock();
+  bbVisited.push_back(false);
+  newFallthru->SetAttributes(kBBAttrArtificial);
+  AddLaidOut(false);
+  newFallthru->SetKind(kBBGoto);
+  SetNewBBInLayout();
+  LabelIdx fallthruLabel = func.GetOrCreateBBLabel(fallthru);
+  if (func.GetIRMap() != nullptr) {
+    GotoNode stmt(OP_goto);
+    auto *newGoto = func.GetIRMap()->New<GotoMeStmt>(&stmt);
+    newGoto->SetOffset(fallthruLabel);
+    newFallthru->SetFirstMe(newGoto);
+    newFallthru->SetLastMe(to_ptr(newFallthru->GetMeStmts().begin()));
+  } else {
+    auto *newGoto = func.GetMirFunc()->GetCodeMempool()->New<GotoNode>(OP_goto);
+    newGoto->SetOffset(fallthruLabel);
+    newFallthru->SetFirst(newGoto);
+    newFallthru->SetLast(newFallthru->GetStmtNodes().begin().d());
+  }
+  // replace pred and succ
+  size_t index = fallthru.GetPred().size();
+  while (index > 0) {
+    if (fallthru.GetPred(index - 1) == &bb) {
+      break;
+    }
+    index--;
+  }
+  bb.ReplaceSucc(&fallthru, newFallthru);
+  // pred has been remove for pred vector of succ
+  // means size reduced, so index reduced
+  index--;
+  fallthru.AddPred(*newFallthru, index);
+  newFallthru->SetFrequency(fallthru.GetFrequency());
+  if (cfg->UpdateCFGFreq()) {
+    newFallthru->PushBackSuccFreq(fallthru.GetFrequency());
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "Created fallthru and goto original fallthru" << '\n';
+  }
+  AddBB(*newFallthru);
+  SetAttrTryForTheCanBeMovedBB(bb, *newFallthru);
+  return newFallthru;
+}
+
+void BBLayout::OptimizeEmptyFallThruBB(BB &bb) {
+  if (needDealWithTryBB) {
+    return;
+  }
+  auto *fallthru = bb.GetSucc().front();
+  while (fallthru && (fallthru->GetPred().size() == 1) &&
+         (BBEmptyAndFallthru(*fallthru) || BBContainsOnlyGoto(*fallthru)) &&
+         !fallthru->GetAttributes(kBBAttrWontExit)) {
+    BB *newFallthru = fallthru->GetSucc().front();
+    if (newFallthru == bb.GetSucc().back()) {
+      bb.ReplaceSucc(fallthru, newFallthru);
+      ASSERT(fallthru->GetPred().empty(), "fallthru should not has other pred");
+      ChangeToFallthruFromCondGoto(bb);
+      bb.GetSucc().resize(1);  // resize succ to 1
+    } else if (newFallthru->GetPred().size() == 1) {
+      if (newFallthru->GetBBLabel() != 0) {
+        // reset newFallthru label
+        newFallthru->SetBBLabel(0);
+      }
+      // replace empty fallthru with fallthru's succ
+      bb.ReplaceSucc(fallthru, newFallthru);
+    } else {
+      break;
+    }
+    laidOut[fallthru->GetBBId()] = true;
+    RemoveUnreachable(*fallthru);
+    fallthru = newFallthru;
+  }
+}
+
+void BBLayout::DumpBBPhyOrder() const {
+  LogInfo::MapleLogger() << func.GetName() << " final BB order " << '\n';
+  for (auto bb : layoutBBs) {
+    LogInfo::MapleLogger() << bb->GetBBId();
+    if (bb != layoutBBs.back()) {
+      LogInfo::MapleLogger() << "-->";
+    }
+  }
+  LogInfo::MapleLogger() << '\n';
+}
+
+void BBLayout::OptimiseCFG() {
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    if (bb->GetKind() == kBBCondGoto || bb->GetKind() == kBBGoto) {
+      OptimizeBranchTarget(*bb);
+      // check fallthru is empty without label, delete fallthru and
+      // make fallthrSucc as the only succ of bb
+      //      bb
+      //      /      \
+      //   fallthru  |
+      //      \      /
+      //      fallthruSucc
+      if (bb->GetKind() == kBBCondGoto) {
+        OptimizeEmptyFallThruBB(*bb);
+      }
+    }
+  }
+  (void)cfg->UnreachCodeAnalysis(false);
+
+  // do 2nd fallthru optimize if succs of bb were optimized by first iteration
+  for (auto bIt = cfg->valid_begin(); bIt != cfg->valid_end(); ++bIt) {
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    if (bb->GetKind() == kBBCondGoto) {
+      OptimizeEmptyFallThruBB(*bb);
+    }
+  }
+  (void)cfg->UnreachCodeAnalysis(false);
+}
+
+void BBLayout::SetAttrTryForTheCanBeMovedBB(BB &bb, BB &canBeMovedBB) const {
+  if (bb.GetAttributes(kBBAttrIsTryEnd)) {
+    bb.ClearAttributes(kBBAttrIsTryEnd);
+    canBeMovedBB.SetAttributes(kBBAttrIsTryEnd);
+    cfg->SetTryBBByOtherEndTryBB(&canBeMovedBB, &bb);
+  }
+  if (bb.GetAttributes(kBBAttrIsTry) && !canBeMovedBB.GetAttributes(kBBAttrIsTry)) {
+    UpdateNewBBWithAttrTry(bb, canBeMovedBB);
+  }
+}
+
+void BBLayout::LayoutWithoutProf() {
+  RebuildFreq();
+  BB *bb = cfg->GetFirstBB();
+  while (bb != nullptr) {
+    AddBB(*bb);
+    if (bb->GetKind() == kBBCondGoto || bb->GetKind() == kBBGoto) {
+      OptimizeBranchTarget(*bb);
+    }
+    BB *nextBB = NextBB();
+    if (nextBB != nullptr) {
+      // check try-endtry correspondence
+      bool isTry = false;
+      if (func.GetIRMap() != nullptr) {
+        isTry = !nextBB->GetMeStmts().empty() && nextBB->GetMeStmts().front().GetOp() == OP_try;
+      } else {
+        auto &stmtNodes = nextBB->GetStmtNodes();
+        isTry = !stmtNodes.empty() && stmtNodes.front().GetOpCode() == OP_try;
+      }
+      ASSERT(!(isTry && GetTryOutstanding()), "cannot emit another try if last try has not been ended");
+      if (nextBB->GetAttributes(kBBAttrIsTryEnd)) {
+        ASSERT(cfg->GetTryBBFromEndTryBB(nextBB) == nextBB || IsBBLaidOut(cfg->GetTryBBFromEndTryBB(nextBB)->GetBBId()),
+               "cannot emit endtry bb before its corresponding try bb");
+      }
+    }
+    // based on nextBB, may need to fix current bb's fall-thru
+    if (bb->GetKind() == kBBFallthru) {
+      ResolveUnconditionalFallThru(*bb, *nextBB);
+    } else if (bb->GetKind() == kBBCondGoto) {
+      BB *oldFallThru = bb->GetSucc(0);
+      BB *fallthru = GetFallThruBBSkippingEmpty(*bb);
+      BB *brTargetBB = bb->GetSucc(1);
+      if (ChooseTargetAsFallthru(*bb, *brTargetBB, *oldFallThru, *fallthru)) {
+        // flip the sense of the condgoto and lay out brTargetBB right here
+        LabelIdx fallthruLabel = func.GetOrCreateBBLabel(*fallthru);
+        if (func.GetIRMap() != nullptr) {
+          auto &condGotoMeStmt = static_cast<CondGotoMeStmt&>(bb->GetMeStmts().back());
+          ASSERT(brTargetBB->GetBBLabel() == condGotoMeStmt.GetOffset(), "bbLayout: wrong branch target BB");
+          condGotoMeStmt.SetOffset(fallthruLabel);
+          condGotoMeStmt.SetOp((condGotoMeStmt.GetOp() == OP_brtrue) ? OP_brfalse : OP_brtrue);
+        } else {
+          auto &condGotoNode = static_cast<CondGotoNode&>(bb->GetStmtNodes().back());
+          ASSERT(brTargetBB->GetBBLabel() == condGotoNode.GetOffset(), "bbLayout: wrong branch target BB");
+          condGotoNode.SetOffset(fallthruLabel);
+          condGotoNode.SetOpCode((condGotoNode.GetOpCode() == OP_brtrue) ? OP_brfalse : OP_brtrue);
+        }
+        // The offset of condgotostmt must be the label of second succ bb.
+        ASSERT(bb->GetSucc(0)->GetBBId() == fallthru->GetBBId(), "must be the fallthru");
+        ASSERT(bb->GetSucc(1)->GetBBId() == brTargetBB->GetBBId(), "must be the brTargetBB");
+        bb->SetSucc(0, brTargetBB);
+        bb->SetSucc(1, fallthru);
+        if (func.GetIRMap() != nullptr) {
+          ASSERT(bb->GetSucc(1)->GetBBLabel() == static_cast<CondGotoMeStmt&>(bb->GetMeStmts().back()).GetOffset(),
+                 "bbLayout: wrong branch target BB");
+        } else {
+          ASSERT(bb->GetSucc(1)->GetBBLabel() == static_cast<CondGotoNode&>(bb->GetStmtNodes().back()).GetOffset(),
+                 "bbLayout: wrong branch target BB");
+        }
+        AddBB(*brTargetBB);
+        SetAttrTryForTheCanBeMovedBB(*bb, *brTargetBB);
+        ResolveUnconditionalFallThru(*brTargetBB, *nextBB);
+        OptimizeBranchTarget(*brTargetBB);
+      } else if (fallthru != nextBB) {
+        if (BBCanBeMoved(*fallthru, *bb)) {
+          AddBB(*fallthru);
+          SetAttrTryForTheCanBeMovedBB(*bb, *fallthru);
+          ResolveUnconditionalFallThru(*fallthru, *nextBB);
+          OptimizeBranchTarget(*fallthru);
+        } else {
+          BB *newFallthru = CreateGotoBBAfterCondBB(*bb, *fallthru);
+          OptimizeBranchTarget(*newFallthru);
+        }
+      }
+    } else if (bb->GetKind() == kBBSwitch) {
+      if (func.GetIRMap() != nullptr) {
+        SwitchMeStmt *swStmt = &static_cast<SwitchMeStmt&>(bb->GetMeStmts().back());
+        OptimizeCaseTargets(bb, &swStmt->GetSwitchTable());
+      } else {
+        SwitchNode *swStmt = &static_cast<SwitchNode&>(bb->GetStmtNodes().back());
+        OptimizeCaseTargets(bb, &swStmt->GetSwitchTable());
+      }
+    }
+    if (bb->GetKind() == kBBGoto) {
+      // see if goto target can be placed here
+      BB *gotoTarget = bb->GetSucc().front();
+      CHECK_FATAL(gotoTarget != nullptr, "null ptr check");
+
+      if (gotoTarget != nextBB && BBCanBeMoved(*gotoTarget, *bb)) {
+        SetAttrTryForTheCanBeMovedBB(*bb, *gotoTarget);
+        ChangeToFallthruFromGoto(*bb);
+        AddBB(*gotoTarget);
+        ResolveUnconditionalFallThru(*gotoTarget, *nextBB);
+        OptimizeBranchTarget(*gotoTarget);
+      } else if (gotoTarget->GetKind() == kBBCondGoto && gotoTarget->GetPred().size() == 1) {
+        BB *targetNext = gotoTarget->GetSucc().front();
+        if (targetNext != nextBB && BBCanBeMoved(*targetNext, *bb)) {
+          SetAttrTryForTheCanBeMovedBB(*bb, *gotoTarget);
+          ChangeToFallthruFromGoto(*bb);
+          AddBB(*gotoTarget);
+          OptimizeBranchTarget(*gotoTarget);
+          AddBB(*targetNext);
+          SetAttrTryForTheCanBeMovedBB(*bb, *targetNext);
+          ResolveUnconditionalFallThru(*targetNext, *nextBB);
+          OptimizeBranchTarget(*targetNext);
+        }
+      }
+    }
+    if (nextBB != nullptr && IsBBLaidOut(nextBB->GetBBId())) {
+      nextBB = NextBB();
+    }
+    bb = nextBB;
+  }
+}
+
+void BBLayout::AddBBProf(BB &bb) {
+  if (layoutBBs.empty()) {
+    AddBB(bb);
+    return;
+  }
+  BB *curBB = layoutBBs.back();
+  if ((curBB->GetKind() == kBBFallthru || curBB->GetKind() == kBBGoto) && !curBB->GetSucc().empty()) {
+    BB *targetBB = curBB->GetSucc().front();
+    if (curBB->GetKind() == kBBFallthru && (&bb != targetBB)) {
+      CreateGoto(*curBB, func, *targetBB);
+    } else if (curBB->GetKind() == kBBGoto && (&bb == targetBB)) {
+      // delete the goto stmt
+      ChangeToFallthruFromGoto(*curBB);
+    }
+  } else if (curBB->GetKind() == kBBCondGoto) {
+    BB *fallthru = curBB->GetSucc(0);
+    BB *targetBB = curBB->GetSucc(1);
+    CHECK_FATAL(targetBB != fallthru, "condbb targetBB is same as fallthru");
+    if (targetBB == &bb) {
+      LabelIdx fallthruLabel = func.GetOrCreateBBLabel(*fallthru);
+      if (func.GetIRMap() != nullptr) {
+        auto &condGotoMeStmt = static_cast<CondGotoMeStmt&>(curBB->GetMeStmts().back());
+        ASSERT(targetBB->GetBBLabel() == condGotoMeStmt.GetOffset(), "bbLayout: wrong branch target BB");
+        condGotoMeStmt.SetOffset(fallthruLabel);
+        condGotoMeStmt.SetOp((condGotoMeStmt.GetOp() == OP_brtrue) ? OP_brfalse : OP_brtrue);
+      } else {
+        auto &condGotoNode = static_cast<CondGotoNode&>(curBB->GetStmtNodes().back());
+        ASSERT(targetBB->GetBBLabel() == condGotoNode.GetOffset(), "bbLayout: wrong branch target BB");
+        condGotoNode.SetOffset(fallthruLabel);
+        condGotoNode.SetOpCode((condGotoNode.GetOpCode() == OP_brtrue) ? OP_brfalse : OP_brtrue);
+      }
+    } else if (&bb != fallthru) {
+      (void)CreateGotoBBAfterCondBB(*curBB, *fallthru);
+    }
+  }
+  AddBB(bb);
+}
+
+void BBLayout::BuildEdges() {
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    for (size_t i = 0; i < bb->GetSucc().size(); ++i) {
+      BB *dest = bb->GetSucc(i);
+      uint64 w = bb->GetEdgeFreq(i);
+      allEdges.emplace_back(layoutAlloc.GetMemPool()->New<BBEdge>(bb, dest, w));
+    }
+  }
+  std::stable_sort(allEdges.begin(), allEdges.end(),
+                   [](const BBEdge *edge1, const BBEdge *edge2) { return edge1->GetWeight() > edge2->GetWeight(); });
+}
+
+BB *BBLayout::GetBBFromEdges() {
+  while (edgeIdx < allEdges.size()) {
+    BBEdge *edge = allEdges[edgeIdx];
+    BB *srcBB = edge->GetSrcBB();
+    BB *destBB = edge->GetDestBB();
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << srcBB->GetBBId() << "->" << destBB->GetBBId() << " freq " << srcBB->GetEdgeFreq(destBB)
+                             << '\n';
+    }
+
+    if (!laidOut[srcBB->GetBBId()]) {
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << "choose srcBB " << srcBB->GetBBId() << '\n';
+      }
+      return srcBB;
+    }
+    if (!laidOut[destBB->GetBBId()]) {
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << "choose destBB " << destBB->GetBBId() << '\n';
+      }
+      return destBB;
+    }
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "skip this edge " << '\n';
+    }
+    edgeIdx++;
+  }
+  return nullptr;
+}
+// find the most probility succ,if bb's succ more then one
+// if no succ,choose the most weight edge in the edges
+BB *BBLayout::NextBBProf(BB &bb) {
+  if (bb.GetSucc().size() == 0) {
+    return GetBBFromEdges();
+  }
+
+  if (bb.GetSucc().size() == 1) {
+    BB *succBB = bb.GetSucc(0);
+    if (!laidOut[succBB->GetBBId()]) {
+      return succBB;
+    }
+    return NextBBProf(*succBB);
+  }
+  // max freq intial
+  uint64 maxFreq = 0;
+  size_t idx = 0;
+  bool found = false;
+  for (size_t i = 0; i < bb.GetSucc().size(); ++i) {
+    BB *succBB = bb.GetSucc(i);
+    if (!laidOut[succBB->GetBBId()]) {
+      uint64 edgeFreqFromBB = bb.GetEdgeFreq(i);
+      // if bb isn't executed, choose the first valid bb
+      if (bb.GetFrequency() == 0) {
+        idx = i;
+        found = true;
+        break;
+      }
+      if (edgeFreqFromBB > maxFreq) {
+        maxFreq = edgeFreqFromBB;
+        idx = i;
+        found = true;
+      }
+    }
+  }
+  if (found) {
+    return bb.GetSucc(idx);
+  }
+  return GetBBFromEdges();
+}
+
+void BBLayout::RebuildFreq() {
+  auto *hook = phase->GetAnalysisInfoHook();
+  hook->ForceEraseAnalysisPhase(func.GetUniqueID(), &MEDominance::id);
+  hook->ForceEraseAnalysisPhase(func.GetUniqueID(), &MELoopAnalysis::id);
+  auto dominancePhase = static_cast<MEDominance*>(
+      hook->ForceRunAnalysisPhase<MapleFunctionPhase<MeFunction>>(&MEDominance::id, func));
+  dom = dominancePhase->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  auto pdom = dominancePhase->GetPdomResult();
+  CHECK_NULL_FATAL(pdom);
+  meLoop = static_cast<MELoopAnalysis*>(
+               hook->ForceRunAnalysisPhase<MapleFunctionPhase<MeFunction>>(&MELoopAnalysis::id, func))
+               ->GetResult();
+  if (!cfg->UpdateCFGFreq()) {
+    MePrediction::RebuildFreq(func, *dom, *pdom, *meLoop);
+  }
+}
+
+void BBLayout::LayoutWithProf(bool useChainLayout) {
+  OptimiseCFG();
+  // We rebuild freq after OptimiseCFG
+  RebuildFreq();
+  if (enabledDebug) {
+    cfg->DumpToFile("cfgopt", false, true);
+  }
+
+  BB *bb = cfg->GetFirstBB();
+  if (useChainLayout) {  // chain BB layout
+    BuildChainForFunc();
+    BBChain *mainChain = bb2chain[bb->GetBBId()];
+    for (auto it = mainChain->begin(); it != mainChain->end(); ++it) {
+      if (it == mainChain->begin()) {
+        continue;  // skip common entry BB
+      }
+      AddBBProf(**it);
+    }
+  } else {  // PH BB layout
+    BuildEdges();
+    while (bb != nullptr) {
+      AddBBProf(*bb);
+      bb = NextBBProf(*bb);
+    }
+  }
+
+  // adjust the last BB if kind is fallthru or condtion BB
+  BB *lastBB = layoutBBs.empty() ? nullptr : layoutBBs.back();
+  if (lastBB != nullptr) {
+    if (lastBB->GetKind() == kBBFallthru) {
+      if (!lastBB->IsPredBB(*cfg->GetCommonExitBB())) {
+        BB *targetBB = lastBB->GetSucc().front();
+        CreateGoto(*lastBB, func, *targetBB);
+      }
+    } else if (lastBB->GetKind() == kBBCondGoto) {
+      BB *fallthru = lastBB->GetSucc(0);
+      (void)CreateGotoBBAfterCondBB(*lastBB, *fallthru);
+    }
+  }
+}
+
+void BBLayout::RunLayout() {
+  // If the func is too large, won't run prediction
+  if (MeOption::layoutWithPredict && func.GetMIRModule().IsCModule() && cfg->GetAllBBs().size() <= kMaxNumBBToPredict) {
+    LayoutWithProf(true);
+  } else {
+    LayoutWithoutProf();
+  }
+}
+
+// check condBB if they have same succs
+void BBLayout::VerifyBB() {
+  for (auto bIt = cfg->valid_begin(); bIt != cfg->valid_end(); ++bIt) {
+    auto *bb = *bIt;
+    if (bb->GetKind() == kBBCondGoto) {
+      auto *fallthru = bb->GetSucc(0);
+      auto *targetBB = bb->GetSucc(1);
+      if (fallthru == targetBB || (BBEmptyAndFallthru(*fallthru) && (fallthru->GetSucc(0) == targetBB))) {
+        LogInfo::MapleLogger() << "WARN: cond BB " << bb->GetBBId() << " has same target";
+      }
+    }
+  }
+}
+
+void MEBBLayout::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.SetPreservedAll();
+}
+
+bool MEBBLayout::PhaseRun(maple::MeFunction &f) {
+  if (f.GetMIRModule().IsCModule() && MeSplitCEdge(false).SplitCriticalEdgeForMeFunc(f)) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MELoopAnalysis::id);
+  }
+  auto *bbLayout = GetPhaseAllocator()->New<BBLayout>(*GetPhaseMemPool(), f, DEBUGFUNC_NEWPM(f), this);
+  // assume common_entry_bb is always bb 0
+  MeCFG *cfg = f.GetCfg();
+  ASSERT(cfg->front() == cfg->GetCommonEntryBB(), "assume bb[0] is the commont entry bb");
+  if (DEBUGFUNC_NEWPM(f)) {
+    cfg->DumpToFile("beforeBBLayout", false);
+  }
+  bbLayout->RunLayout();
+  f.SetLaidOutBBs(bbLayout->GetBBs());
+
+  if (Options::profileUse) {
+    if (cfg->UpdateCFGFreq() && cfg->DumpIRProfileFile()) {
+      cfg->DumpToFile("after-bblayout", false, true);
+    }
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    // verify CFG : check condBB's succs should be different
+    bbLayout->VerifyBB();
+    bbLayout->DumpBBPhyOrder();
+    cfg->DumpToFile("afterBBLayout", false);
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_bypath_eh.cpp b/src/mapleall/maple_me/src/me_bypath_eh.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..55a0c7237647f97e80d16a3b6868bb62d6d0fd2e
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_bypath_eh.cpp
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_bypath_eh.h"
+#include <iostream>
+#include "me_cfg.h"
+#include "me_option.h"
+#include "dominance.h"
+#include "me_function.h"
+#include "me_phase_manager.h"
+
+namespace maple {
+bool MeBypathEH::DoBypathException(BB *tryBB, BB *catchBB, const Klass *catchClass, const StIdx &stIdx,
+                                   const KlassHierarchy &kh, MeFunction &func, const StmtNode *syncExitStmt) const {
+  std::vector<BB*> tryBBV;
+  std::set<BB*> tryBBS;
+  tryBBV.push_back(tryBB);
+  (void)tryBBS.insert(tryBB);
+  uint32 idx = 0;
+  bool transformed = false;
+  while (idx < tryBBV.size()) {
+    BB *bb = tryBBV[idx];
+    ++idx;
+    // Deal with throw
+    for (StmtNode *stmt = &bb->GetFirst(); stmt != nullptr && stmt != bb->GetLast().GetNext(); stmt = stmt->GetNext()) {
+      if (stmt->GetOpCode() == OP_throw) {
+        auto *node = static_cast<UnaryStmtNode*>(stmt);
+        BaseNode *rhExpr = nullptr;
+        Klass *throwClass = nullptr;
+        if (node->Opnd(0)->GetOpCode() == OP_dread) {
+          auto *dread = static_cast<AddrofNode*>(node->Opnd(0));
+          StIdx ehObjIdx = dread->GetStIdx();
+          const MIRSymbol *ehObjSymbol = func.GetMirFunc()->GetLocalOrGlobalSymbol(ehObjIdx);
+          MIRType *pType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ehObjSymbol->GetTyIdx());
+          CHECK_FATAL(pType->GetKind() == kTypePointer, "must be pointer");
+          TyIdx pTypeIdx = (static_cast<MIRPtrType*>(pType))->GetPointedType()->GetTypeIndex();
+          throwClass = kh.GetKlassFromTyIdx(pTypeIdx);
+          rhExpr = dread;
+        } else if (node->Opnd(0)->GetOpCode() == OP_iread) {
+          auto *iread = static_cast<IreadNode*>(node->Opnd(0));
+          MIRType *pType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx());
+          CHECK_FATAL(pType->GetKind() == kTypePointer, "must be pointer");
+          TyIdx pTypeIdx = (static_cast<MIRPtrType*>(pType))->GetPointedType()->GetTypeIndex();
+          pType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pTypeIdx);
+          auto *structType = static_cast<MIRStructType*>(pType);
+          pType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(structType->GetFieldTyIdx(iread->GetFieldID()));
+          CHECK_FATAL(pType->GetKind() == kTypePointer, "must be pointer");
+          pTypeIdx = (static_cast<MIRPtrType*>(pType))->GetPointedType()->GetTypeIndex();
+          throwClass = kh.GetKlassFromTyIdx(pTypeIdx);
+          rhExpr = iread;
+        } else if (node->Opnd(0)->GetOpCode() == OP_constval) {
+          /*
+           * when cfg changed, this phase will re-run,
+           * some throw would like:
+           * throw (constval ref 0)
+           */
+          continue;
+        } else {
+          CHECK_FATAL(false, "Can't be here!");
+        }
+        if (!kh.IsSuperKlass(catchClass, throwClass)) {
+          continue;
+        }
+        MIRBuilder *mirBuilder = func.GetMIRModule().GetMIRBuilder();
+        UnaryStmtNode *nullCheck = mirBuilder->CreateStmtUnary(OP_assertnonnull, rhExpr);
+        bb->InsertStmtBefore(stmt, nullCheck);
+        DassignNode *copyStmt = mirBuilder->CreateStmtDassign(stIdx, 0, rhExpr);
+        bb->InsertStmtBefore(stmt, copyStmt);
+        CHECK_NULL_FATAL(catchBB);
+        GotoNode *gotoNode = mirBuilder->CreateStmtGoto(OP_goto, catchBB->GetBBLabel());
+        bb->ReplaceStmt(stmt, gotoNode);
+        if (syncExitStmt != nullptr) {
+          bb->InsertStmtBefore(gotoNode, syncExitStmt->CloneTree(func.GetMIRModule().GetCurFuncCodeMPAllocator()));
+        }
+        transformed = true;
+        bb->AddSucc(*catchBB, 0);
+      }
+    }
+    // Add fall through bb
+    if (bb->GetKind() == kBBFallthru && !bb->GetAttributes(kBBAttrIsTryEnd)) {
+      bool findBB = false;
+      for (BB *bbTmp : func.GetCfg()->GetAllBBs()) {
+        if (findBB && bbTmp != nullptr) {
+          if (bbTmp == catchBB || bbTmp->IsEmpty() || bbTmp->GetFirst().GetOpCode() == OP_try ||
+              bbTmp->GetAttributes(kBBAttrIsCatch)) {
+            break;
+          }
+          if (bbTmp->GetAttributes(kBBAttrIsTry)) {
+            std::pair<std::set<BB*>::iterator, bool> rev = tryBBS.insert(bbTmp);
+            if (rev.second) {
+              tryBBV.push_back(bbTmp);
+            }
+          }
+          break;
+        }
+        if (bbTmp == bb) {
+          findBB = true;
+        }
+      }
+    }
+    if (!bb->GetAttributes(kBBAttrIsTryEnd)) {
+      for (uint32 i = 0; i < bb->GetSucc().size(); i++) {
+        BB *succ = bb->GetSucc(i);
+        if (succ == catchBB || succ->IsEmpty() || succ->GetFirst().GetOpCode() == OP_try ||
+            succ->GetAttributes(kBBAttrIsCatch)) {
+          continue;
+        }
+        if (succ->GetAttributes(kBBAttrIsTry)) {
+          std::pair<std::set<BB*>::iterator, bool> rev = tryBBS.insert(succ);
+          if (rev.second) {
+            tryBBV.push_back(succ);
+          }
+        }
+      }
+    }
+  }
+  return transformed;
+}
+
+StmtNode *MeBypathEH::IsSyncExit(BB &syncBB, const MeFunction &func, LabelIdx secondLabel) const {
+  StmtNode *syncExitStmt = nullptr;
+  StmtNode *stmt = syncBB.GetFirst().GetNext();
+  for (; stmt != nullptr && stmt != syncBB.GetLast().GetNext(); stmt = stmt->GetNext()) {
+    if (stmt->GetOpCode() != OP_comment) {
+      break;
+    }
+  }
+  if (stmt == nullptr || stmt->GetOpCode() != OP_dassign) {
+    return nullptr;
+  }
+  auto *dassignNode = static_cast<DassignNode*>(stmt);
+  ASSERT(dassignNode->Opnd(0)->GetOpCode() == OP_regread, "Must be regread");
+  auto *regreadNode = static_cast<RegreadNode*>(dassignNode->Opnd(0));
+  if (regreadNode->GetRegIdx() != -kSregThrownval) {
+    return nullptr;
+  }
+  for (stmt = stmt->GetNext(); stmt != nullptr && stmt != syncBB.GetLast().GetNext(); stmt = stmt->GetNext()) {
+    if (stmt->GetOpCode() == OP_comment) {
+      continue;
+    }
+    if (stmt->GetOpCode() == OP_syncexit) {
+      syncExitStmt = stmt;
+      if (stmt != &syncBB.GetLast()) {
+        return nullptr;
+      }
+    } else {
+      return nullptr;
+    }
+  }
+
+  BB *prevBB = &syncBB;
+  while (true) {
+    BB *bbTmp = nullptr;
+    for (size_t i = prevBB->GetBBId() + 1; i < func.GetCfg()->GetAllBBs().size(); ++i) {
+      bbTmp = func.GetCfg()->GetAllBBs()[i];
+      if (bbTmp != nullptr) {
+        break;
+      }
+    }
+    if (bbTmp == nullptr) {
+      return nullptr;
+    }
+    bool findThrow = false;
+    for (stmt = &bbTmp->GetFirst(); stmt != nullptr && stmt != bbTmp->GetLast().GetNext(); stmt = stmt->GetNext()) {
+      if (stmt->GetOpCode() == OP_comment) {
+        continue;
+      }
+      if (stmt->GetOpCode() == OP_try) {
+        auto *tryNode = static_cast<TryNode*>(stmt);
+        if (tryNode->GetOffsetsCount() != 1 || tryNode->GetOffset(0) != secondLabel) {
+          return nullptr;
+        }
+      } else if (stmt->GetOpCode() == OP_throw) {
+        if (stmt != &bbTmp->GetLast()) {
+          return nullptr;
+        }
+        auto *throwStmt = static_cast<UnaryStmtNode*>(stmt);
+        if (throwStmt->GetRHS()->GetOpCode() != OP_dread) {
+          return nullptr;
+        }
+        auto *dreadNode = static_cast<AddrofNode*>(throwStmt->GetRHS());
+        ASSERT_NOT_NULL(dreadNode);
+        if (dreadNode->GetStIdx() != dassignNode->GetStIdx()) {
+          return nullptr;
+        }
+        findThrow = true;
+      } else {
+        return nullptr;
+      }
+    }
+    if (findThrow) {
+      break;
+    }
+    prevBB = bbTmp;
+  }
+  return syncExitStmt;
+}
+
+void MeBypathEH::BypathException(MeFunction &func, const KlassHierarchy &kh) const {
+  // Condition check:
+  // 1. There is only one catch statement, and the catch can handle the thrown exception
+  auto labelIdx = static_cast<LabelIdx>(-1);
+  // Some new bb will be created, so use visited
+  std::set<BB*> visited;
+  for (BB *bb : func.GetCfg()->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+
+    if (visited.find(bb) != visited.end()) {
+      continue;
+    }
+    (void)visited.emplace(bb);
+    for (StmtNode *stmt = &bb->GetFirst(); stmt != nullptr && stmt != bb->GetLast().GetNext(); stmt = stmt->GetNext()) {
+      if (stmt->GetOpCode() != OP_try) {
+        continue;
+      }
+      labelIdx = static_cast<LabelIdx>(-1);
+      StmtNode *syncExitStmt = nullptr;
+      auto *tryNode = static_cast<TryNode*>(stmt);
+      if (tryNode->GetOffsetsCount() == 1) {
+        labelIdx = tryNode->GetOffset(0);
+      } else if (tryNode->GetOffsetsCount() == 2) { // Deal with sync
+        BB *catchBB = nullptr;
+        for (BB *bbInner : func.GetCfg()->GetAllBBs()) {
+          if (bbInner == nullptr) {
+            continue;
+          }
+          if (bbInner->GetBBLabel() == tryNode->GetOffset(0)) {
+            catchBB = bbInner;
+          }
+        }
+        ASSERT(catchBB != nullptr, "must not be null");
+        StmtNode &stmtInner = catchBB->GetFirst();
+        if (stmtInner.GetOpCode() != OP_catch) { // Finally is not a catch
+          break;
+        }
+        auto &catchStmt = static_cast<CatchNode&>(stmtInner);
+        if (catchStmt.GetExceptionTyIdxVec().size() == 1) {
+          MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchStmt.GetExceptionTyIdxVecElement(0));
+          ASSERT(type->GetKind() == kTypePointer, "Must be pointer");
+          auto *pType = static_cast<MIRPtrType*>(type);
+          if (pType->GetPointedTyIdx() == PTY_void) {
+            syncExitStmt = IsSyncExit(*catchBB, func, tryNode->GetOffset(1));
+            if (syncExitStmt != nullptr) {
+              labelIdx = tryNode->GetOffset(1);
+            }
+          }
+        }
+      }
+
+      if (labelIdx == static_cast<LabelIdx>(-1)) {
+        continue;
+      }
+      // Find catch label, and create a new bb
+      for (BB *bbInner : func.GetCfg()->GetAllBBs()) {
+        if (bbInner == nullptr || bbInner->GetBBLabel() != labelIdx) {
+          continue;
+        }
+        StmtNode &stmtInner = bbInner->GetFirst();
+        ASSERT(stmtInner.GetOpCode() == OP_catch, "Must be java catch.");
+        auto &catchNode = static_cast<CatchNode&>(stmtInner);
+        if (catchNode.GetExceptionTyIdxVec().size() != 1) {
+          continue;
+        }
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchNode.GetExceptionTyIdxVecElement(0));
+        ASSERT(type->GetKind() == kTypePointer, "Must be pointer");
+        auto *pType = static_cast<MIRPtrType*>(type);
+        Klass *catchClass = nullptr;
+        if (pType->GetPointedTyIdx() == PTY_void) {
+          catchClass = kh.GetKlassFromName(namemangler::kJavaLangExceptionStr);
+        } else {
+          catchClass = kh.GetKlassFromTyIdx(pType->GetPointedTyIdx());
+        }
+        if (stmtInner.GetNext() == nullptr || stmtInner.GetNext()->GetOpCode() != OP_dassign) {
+          labelIdx = static_cast<LabelIdx>(-1);
+          continue;
+        }
+        auto *dassignNode = static_cast<DassignNode*>(stmtInner.GetNext());
+        ASSERT(dassignNode->Opnd(0)->GetOpCode() == OP_regread, "Must be regread");
+        auto *regreadNode = static_cast<RegreadNode*>(dassignNode->Opnd(0));
+        if (regreadNode->GetRegIdx() != -kSregThrownval) {
+          continue;
+        }
+        // Insert goto label
+        GStrIdx labelStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("bypatheh" +
+            func.GetMirFunc()->GetLabelName(bbInner->GetBBLabel()));
+        BB *newBB = nullptr;
+        bool hasCreated = false;
+        auto it = func.GetMirFunc()->GetLabelTab()->GetStrIdxToLabelIdxMap().find(labelStrIdx);
+        if (it == func.GetMirFunc()->GetLabelTab()->GetStrIdxToLabelIdxMap().end()) {
+          LabelIdx labIdx = func.GetMirFunc()->GetLabelTab()->AddLabel(labelStrIdx);
+          newBB = func.GetCfg()->NewBasicBlock();
+          func.GetCfg()->SetLabelBBAt(labIdx, newBB);
+          newBB->SetBBLabel(labIdx);
+        } else {
+          hasCreated = true;
+          for (BB *newBBIter : func.GetCfg()->GetAllBBs()) {
+            if (newBBIter == nullptr) {
+              continue;
+            }
+            if (newBBIter->GetBBLabel() == it->second) {
+              newBB = newBBIter;
+              break;
+            }
+          }
+        }
+        if (DoBypathException(bb, newBB, catchClass, dassignNode->GetStIdx(), kh, func, syncExitStmt)) {
+          if (!hasCreated) {
+            ASSERT(newBB == func.GetCfg()->GetLastBB(), "newBB should be the last one");
+            func.GetCfg()->GetAllBBs().pop_back();
+            newBB = &func.GetCfg()->SplitBB(*bbInner, *stmtInner.GetNext(), newBB);
+          }
+        } else {
+          if (!hasCreated) {
+            func.GetCfg()->GetAllBBs().pop_back();
+            func.GetCfg()->DecNextBBId();
+            func.GetMirFunc()->GetLabelTab()->GetLabelTable().pop_back();
+            func.GetCfg()->EraseLabelBBAt(
+                func.GetMirFunc()->GetLabelTab()->GetStrIdxToLabelIdxMap().at(labelStrIdx));
+            func.GetMirFunc()->GetLabelTab()->EraseStrIdxToLabelIdxElem(labelStrIdx);
+          }
+        }
+        labelIdx = static_cast<LabelIdx>(-1);
+        break;
+      }
+    }
+  }
+}
+
+bool MEBypathEH::PhaseRun(maple::MeFunction &f) {
+  MaplePhase *it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MKlassHierarchy, MIRModule>(f.GetMIRModule());
+  auto *kh = static_cast<M2MKlassHierarchy*>(it)->GetResult();
+  CHECK_NULL_FATAL(kh);
+  auto *meBypathEH = GetPhaseAllocator()->New<MeBypathEH>();
+  meBypathEH->BypathException(f, *kh);
+  return true;
+}
+
+void MEBypathEH::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_cfg.cpp b/src/mapleall/maple_me/src/me_cfg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..202d51f7fecf348b901679e9392a9c04fb7835c6
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_cfg.cpp
@@ -0,0 +1,2140 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_cfg.h"
+
+#include <algorithm>
+#include <iostream>
+#include <string>
+
+#include "bb.h"
+#include "me_critical_edge.h"
+#include "me_irmap.h"
+#include "me_loop_canon.h"
+#include "mir_builder.h"
+#include "mir_lower.h"
+#include "ssa_mir_nodes.h"
+
+namespace {
+constexpr int kFuncNameLenLimit = 80;
+}
+
+namespace maple {
+#define MATCH_STMT(stmt, kOpCode)                                    \
+  do {                                                               \
+    while ((stmt) != nullptr && (stmt)->GetOpCode() == OP_comment) { \
+      (stmt) = (stmt)->GetNext();                                    \
+    }                                                                \
+    if ((stmt) == nullptr || (stmt)->GetOpCode() != (kOpCode)) {     \
+      return false;                                                  \
+    }                                                                \
+  } while (0)  // END define
+// determine if need to be replaced by assertnonnull
+bool MeCFG::IfReplaceWithAssertNonNull(const BB &bb) const {
+  const StmtNode *stmt = bb.GetStmtNodes().begin().d();
+  constexpr const char npeTypeName[] = "Ljava_2Flang_2FNullPointerException_3B";
+  GStrIdx npeGStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(npeTypeName);
+  TyIdx npeTypeIdx = func.GetMIRModule().GetTypeNameTab()->GetTyIdxFromGStrIdx(npeGStrIdx);
+  // match first stmt
+  MATCH_STMT(stmt, OP_intrinsiccallwithtype);
+
+  auto *cNode = static_cast<const IntrinsiccallNode*>(stmt);
+  if (cNode->GetTyIdx() != npeTypeIdx) {
+    return false;
+  }
+  stmt = stmt->GetNext();
+  // match second stmt
+  MATCH_STMT(stmt, OP_dassign);
+
+  auto *dassignNode = static_cast<const DassignNode*>(stmt);
+  if (dassignNode->GetRHS()->GetOpCode() != OP_gcmalloc) {
+    return false;
+  }
+  auto *gcMallocNode = static_cast<GCMallocNode*>(dassignNode->GetRHS());
+  if (gcMallocNode->GetTyIdx() != npeTypeIdx) {
+    return false;
+  }
+  stmt = stmt->GetNext();
+  // match third stmt
+  MATCH_STMT(stmt, OP_callassigned);
+
+  auto *callNode = static_cast<const CallNode*>(stmt);
+  if (GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx())->GetName() !=
+      "Ljava_2Flang_2FNullPointerException_3B_7C_3Cinit_3E_7C_28_29V") {
+    return false;
+  }
+  stmt = stmt->GetNext();
+  MATCH_STMT(stmt, OP_throw);
+
+  return true;
+}
+
+void MeCFG::AddCatchHandlerForTryBB(BB &bb, MapleVector<BB*> &exitBlocks) {
+  if (!bb.GetAttributes(kBBAttrIsTry)) {
+    return;
+  }
+  auto it = GetBBTryNodeMap().find(&bb);
+  CHECK_FATAL(it != GetBBTryNodeMap().end(), "try bb without try");
+  StmtNode *currTry = it->second;
+  const auto *tryNode = static_cast<const TryNode*>(currTry);
+  bool hasFinallyHandler = false;
+  // add exception handler bb
+  for (size_t j = 0; j < tryNode->GetOffsetsCount(); ++j) {
+    LabelIdx labelIdx = tryNode->GetOffset(j);
+    ASSERT(GetLabelBBIdMap().find(labelIdx) != GetLabelBBIdMap().end(), "runtime check error");
+    BB *meBB = GetLabelBBAt(labelIdx);
+    CHECK_FATAL(meBB != nullptr, "null ptr check");
+    ASSERT(meBB->GetAttributes(kBBAttrIsCatch), "runtime check error");
+    if (meBB->GetAttributes(kBBAttrIsJSFinally) || meBB->GetAttributes(kBBAttrIsCatch)) {
+      hasFinallyHandler = true;
+    }
+    // avoid redundant succ
+    if (!meBB->IsSuccBB(bb)) {
+      bb.AddSucc(*meBB);
+    }
+  }
+  // if try block don't have finally catch handler, add common_exit_bb as its succ
+  if (!hasFinallyHandler) {
+    if (!bb.GetAttributes(kBBAttrIsExit)) {
+      bb.SetAttributes(kBBAttrIsExit);  // may exit
+      exitBlocks.push_back(&bb);
+    }
+  } else if (func.GetMIRModule().IsJavaModule() && bb.GetAttributes(kBBAttrIsExit)) {
+    // deal with throw bb, if throw bb in a tryblock and has finallyhandler
+    auto &stmtNodes = bb.GetStmtNodes();
+    if (!stmtNodes.empty() && stmtNodes.back().GetOpCode() == OP_throw) {
+      bb.ClearAttributes(kBBAttrIsExit);
+      ASSERT(&bb == exitBlocks.back(), "runtime check error");
+      exitBlocks.pop_back();
+    }
+  }
+}
+
+void MeCFG::BuildMirCFG() {
+  MapleVector<BB*> entryBlocks(GetAlloc().Adapter());
+  MapleVector<BB*> exitBlocks(GetAlloc().Adapter());
+  auto eIt = valid_end();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == common_entry() || bIt == common_exit()) {
+      continue;
+    }
+    BB *bb = *bIt;
+    CHECK_FATAL(bb != nullptr, "null ptr check ");
+
+    if (bb->GetAttributes(kBBAttrIsEntry)) {
+      entryBlocks.push_back(bb);
+    }
+    if (bb->GetAttributes(kBBAttrIsExit)) {
+      exitBlocks.push_back(bb);
+    }
+    switch (bb->GetKind()) {
+      case kBBGoto: {
+        StmtNode &lastStmt = bb->GetStmtNodes().back();
+        if (lastStmt.GetOpCode() == OP_throw) {
+          break;
+        }
+        ASSERT(lastStmt.GetOpCode() == OP_goto, "runtime check error");
+        auto &gotoStmt = static_cast<GotoNode&>(lastStmt);
+        LabelIdx lblIdx = gotoStmt.GetOffset();
+        BB *meBB = GetLabelBBAt(lblIdx);
+        bb->AddSucc(*meBB);
+        break;
+      }
+      case kBBCondGoto: {
+        StmtNode &lastStmt = bb->GetStmtNodes().back();
+        ASSERT(lastStmt.IsCondBr(), "runtime check error");
+        // succ[0] is fallthru, succ[1] is gotoBB
+        auto rightNextBB = bIt;
+        ++rightNextBB;
+        CHECK_FATAL(rightNextBB != eIt, "null ptr check ");
+        bb->AddSucc(**rightNextBB);
+        // link goto
+        auto &gotoStmt = static_cast<CondGotoNode&>(lastStmt);
+        LabelIdx lblIdx = gotoStmt.GetOffset();
+        BB *meBB = GetLabelBBAt(lblIdx);
+        if (*rightNextBB == meBB) {
+          constexpr char tmpBool[] = "tmpBool";
+          auto *mirBuilder = func.GetMIRModule().GetMIRBuilder();
+          MIRSymbol *st = mirBuilder->GetOrCreateLocalDecl(tmpBool, *GlobalTables::GetTypeTable().GetUInt1());
+          auto *dassign = mirBuilder->CreateStmtDassign(st->GetStIdx(), 0, lastStmt.Opnd(0));
+          bb->ReplaceStmt(&lastStmt, dassign);
+          bb->SetKind(kBBFallthru);
+        } else {
+          bb->AddSucc(*meBB);
+        }
+        // can the gotostmt be replaced by assertnonnull ?
+        if (IfReplaceWithAssertNonNull(*meBB)) {
+          patternSet.insert(lblIdx);
+        }
+        break;
+      }
+      case kBBSwitch: {
+        StmtNode &lastStmt = bb->GetStmtNodes().back();
+        ASSERT(lastStmt.GetOpCode() == OP_switch, "runtime check error");
+        auto &switchStmt = static_cast<SwitchNode&>(lastStmt);
+        LabelIdx lblIdx = switchStmt.GetDefaultLabel();
+        BB *mirBB = GetLabelBBAt(lblIdx);
+        if (mirBB != nullptr) {
+          bb->AddSucc(*mirBB);
+        }
+        for (size_t j = 0; j < switchStmt.GetSwitchTable().size(); ++j) {
+          lblIdx = switchStmt.GetCasePair(j).second;
+          BB *meBB = GetLabelBBAt(lblIdx);
+          CHECK_FATAL(meBB, "meBB is nullptr!");
+          // Avoid duplicate succs.
+          if (!meBB->IsSuccBB(*bb)) {
+            bb->AddSucc(*meBB);
+          }
+        }
+        if (bb->GetSucc().size() == 1) {
+          bb->RemoveLastStmt();
+          bb->SetKind(kBBFallthru);
+        }
+        break;
+      }
+      case kBBIgoto: {
+        for (LabelIdx lidx : func.GetMirFunc()->GetLabelTab()->GetAddrTakenLabels()) {
+          BB *mebb = GetLabelBBAt(lidx);
+          bb->AddSucc(*mebb);
+        }
+        break;
+      }
+      case kBBReturn:
+        break;
+      default: {
+        // fall through?
+        auto rightNextBB = bIt;
+        ++rightNextBB;
+        if (rightNextBB != eIt) {
+          bb->AddSucc(**rightNextBB);
+        }
+        break;
+      }
+    }
+    // deal try blocks, add catch handler to try's succ. SwitchBB dealed individually
+    if (bb->GetAttributes(kBBAttrIsTry)) {
+      AddCatchHandlerForTryBB(*bb, exitBlocks);
+    }
+  }
+
+  // merge all blocks in entryBlocks
+  for (BB *bb : entryBlocks) {
+    GetCommonEntryBB()->AddEntry(*bb);
+  }
+  // merge all blocks in exitBlocks
+  for (BB *bb : exitBlocks) {
+    GetCommonExitBB()->AddExit(*bb);
+  }
+}
+
+bool MeCFG::FindExprUse(const BaseNode &expr, StIdx stIdx) const {
+  if (expr.GetOpCode() == OP_addrof || expr.GetOpCode() == OP_dread) {
+    const auto &addofNode = static_cast<const AddrofNode&>(expr);
+    return addofNode.GetStIdx() == stIdx;
+  } else if (expr.GetOpCode() == OP_iread) {
+    return FindExprUse(*expr.Opnd(0), stIdx);
+  } else {
+    for (size_t i = 0; i < expr.NumOpnds(); ++i) {
+      if (FindExprUse(*expr.Opnd(i), stIdx)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool MeCFG::FindUse(const StmtNode &stmt, StIdx stIdx) const {
+  Opcode opcode = stmt.GetOpCode();
+  switch (opcode) {
+    case OP_call:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_icall:
+    case OP_icallproto:
+    case OP_intrinsiccall:
+    case OP_xintrinsiccall:
+    case OP_intrinsiccallwithtype:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_icallassigned:
+    case OP_icallprotoassigned:
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned:
+    case OP_intrinsiccallwithtypeassigned:
+    case OP_asm:
+    case OP_syncenter:
+    case OP_syncexit: {
+      for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+        BaseNode *argExpr = stmt.Opnd(i);
+        if (FindExprUse(*argExpr, stIdx)) {
+          return true;
+        }
+      }
+      break;
+    }
+    case OP_dassign: {
+      const auto &dNode = static_cast<const DassignNode&>(stmt);
+      return FindExprUse(*dNode.GetRHS(), stIdx);
+    }
+    case OP_regassign: {
+      const auto &rNode = static_cast<const RegassignNode&>(stmt);
+      if (rNode.GetRegIdx() < 0) {
+        return false;
+      }
+      return FindExprUse(*rNode.Opnd(0), stIdx);
+    }
+    case OP_iassign: {
+      const auto &iNode = static_cast<const IassignNode&>(stmt);
+      if (FindExprUse(*iNode.Opnd(0), stIdx)) {
+        return true;
+      } else {
+        return FindExprUse(*iNode.GetRHS(), stIdx);
+      }
+    }
+      CASE_OP_ASSERT_NONNULL
+    case OP_eval:
+    case OP_free:
+    case OP_switch: {
+      BaseNode *argExpr = stmt.Opnd(0);
+      return FindExprUse(*argExpr, stIdx);
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+bool MeCFG::FindDef(const StmtNode &stmt, StIdx stIdx) const {
+  if (stmt.GetOpCode() != OP_dassign && !kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
+    return false;
+  }
+  if (stmt.GetOpCode() == OP_dassign) {
+    const auto &dassStmt = static_cast<const DassignNode&>(stmt);
+    return dassStmt.GetStIdx() == stIdx;
+  }
+  const auto &cNode = static_cast<const CallNode&>(stmt);
+  const CallReturnVector &nRets = cNode.GetReturnVec();
+  if (!nRets.empty()) {
+    ASSERT(nRets.size() == 1, "Single Ret value for now.");
+    StIdx idx = nRets[0].first;
+    RegFieldPair regFieldPair = nRets[0].second;
+    if (!regFieldPair.IsReg()) {
+      return idx == stIdx;
+    }
+  }
+  return false;
+}
+
+// Return true if there is no use or def of sym betweent from to to.
+bool MeCFG::HasNoOccBetween(StmtNode &from, const StmtNode &to, StIdx stIdx) const {
+  for (StmtNode *stmt = &from; stmt && stmt != &to; stmt = stmt->GetNext()) {
+    if (FindUse(*stmt, stIdx) || FindDef(*stmt, stIdx)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Fix the initially created CFG
+void MeCFG::FixMirCFG() {
+  auto eIt = valid_end();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == common_entry() || bIt == common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    // Split bb in try if there are use -- def the same ref var.
+    if (bb->GetAttributes(kBBAttrIsTry)) {
+      // 1. Split callassigned/dassign stmt to two insns if it redefine a symbole and also use
+      //    the same symbol as its operand.
+      for (StmtNode *stmt = to_ptr(bb->GetStmtNodes().begin()); stmt != nullptr; stmt = stmt->GetNext()) {
+        const MIRSymbol *sym = nullptr;
+        if (kOpcodeInfo.IsCallAssigned(stmt->GetOpCode())) {
+          auto *cNode = static_cast<CallNode*>(stmt);
+          sym = cNode->GetCallReturnSymbol(func.GetMIRModule());
+        } else if (stmt->GetOpCode() == OP_dassign) {
+          auto *dassStmt = static_cast<DassignNode*>(stmt);
+          // exclude the case a = b;
+          if (dassStmt->GetRHS()->GetOpCode() == OP_dread) {
+            continue;
+          }
+          sym = func.GetMirFunc()->GetLocalOrGlobalSymbol(dassStmt->GetStIdx());
+        }
+        if (sym == nullptr || sym->GetType()->GetPrimType() != PTY_ref || !sym->IsLocal()) {
+          continue;
+        }
+        if (kOpcodeInfo.IsCallAssigned(stmt->GetOpCode()) || FindUse(*stmt, sym->GetStIdx())) {
+          func.GetMirFunc()->IncTempCount();
+          std::string tempStr = std::string("tempRet").append(std::to_string(func.GetMirFunc()->GetTempCount()));
+          MIRBuilder *builder = func.GetMirFunc()->GetModule()->GetMIRBuilder();
+          MIRSymbol *targetSt = builder->GetOrCreateLocalDecl(tempStr, *sym->GetType());
+          targetSt->ResetIsDeleted();
+          if (stmt->GetOpCode() == OP_dassign) {
+            auto *rhs = static_cast<DassignNode*>(stmt)->GetRHS();
+            StmtNode *dassign = builder->CreateStmtDassign(*targetSt, 0, rhs);
+            bb->ReplaceStmt(stmt, dassign);
+            stmt = dassign;
+          } else {
+            auto *cNode = static_cast<CallNode*>(stmt);
+            CallReturnPair retPair = cNode->GetReturnPair(0);
+            retPair.first = targetSt->GetStIdx();
+            cNode->SetReturnPair(retPair, 0);
+          }
+          StmtNode *dassign = builder->CreateStmtDassign(*sym, 0, builder->CreateExprDread(*targetSt));
+          if (stmt->GetNext() != nullptr) {
+            bb->InsertStmtBefore(stmt->GetNext(), dassign);
+          } else {
+            ASSERT(stmt == &(bb->GetStmtNodes().back()), "just check");
+            stmt->SetNext(dassign);
+            dassign->SetPrev(stmt);
+            bb->GetStmtNodes().update_back(dassign);
+          }
+        }
+      }
+    }
+  }
+
+  // 2. Split bb to two bbs if there are use and def the same ref var in bb.
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == common_entry() || bIt == common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    if (bb == nullptr) {
+      continue;
+    }
+    if (bb->GetAttributes(kBBAttrIsTry)) {
+      for (auto &splitPoint : bb->GetStmtNodes()) {
+        const MIRSymbol *sym = nullptr;
+        StmtNode *nextStmt = splitPoint.GetNext();
+        if (kOpcodeInfo.IsCallAssigned(splitPoint.GetOpCode())) {
+          auto *cNode = static_cast<CallNode*>(&splitPoint);
+          sym = cNode->GetCallReturnSymbol(func.GetMIRModule());
+        } else {
+          if (nextStmt == nullptr ||
+              (nextStmt->GetOpCode() != OP_dassign && !kOpcodeInfo.IsCallAssigned(nextStmt->GetOpCode()))) {
+            continue;
+          }
+          if (nextStmt->GetOpCode() == OP_dassign) {
+            auto *dassignStmt = static_cast<DassignNode*>(nextStmt);
+            const StIdx stIdx = dassignStmt->GetStIdx();
+            sym = func.GetMirFunc()->GetLocalOrGlobalSymbol(stIdx);
+          } else {
+            auto *cNode = static_cast<CallNode*>(nextStmt);
+            sym = cNode->GetCallReturnSymbol(func.GetMIRModule());
+          }
+        }
+        if (sym == nullptr || sym->GetType()->GetPrimType() != PTY_ref || !sym->IsLocal()) {
+          continue;
+        }
+        if (!kOpcodeInfo.IsCallAssigned(splitPoint.GetOpCode()) &&
+            HasNoOccBetween(*bb->GetStmtNodes().begin().d(), *nextStmt, sym->GetStIdx())) {
+          continue;
+        }
+        BB &newBB = SplitBB(*bb, splitPoint);
+        // because SplitBB will insert a bb, we need update bIt & eIt
+        auto newBBIt = std::find(cbegin(), cend(), bb);
+        bIt = build_filter_iterator(
+            newBBIt, std::bind(FilterNullPtr<MapleVector<BB*>::const_iterator>, std::placeholders::_1, end()));
+        eIt = valid_end();
+        for (size_t si = 0; si < newBB.GetSucc().size(); ++si) {
+          BB *sucBB = newBB.GetSucc(si);
+          if (sucBB->GetAttributes(kBBAttrIsCatch)) {
+            bb->AddSucc(*sucBB);
+          }
+        }
+        break;
+      }
+    }
+    // removing outgoing exception edge from normal return bb
+    if (bb->GetKind() != kBBReturn || !bb->GetAttributes(kBBAttrIsTry) || bb->IsEmpty()) {
+      continue;
+    }
+    // make sure this is a normal return bb
+    // throw, retsub and retgoto are not allowed here
+    if (bb->GetStmtNodes().back().GetOpCode() != OP_return) {
+      continue;
+    }
+    // fast path
+    StmtNode *stmt = bb->GetTheOnlyStmtNode();
+    if (stmt != nullptr) {
+      // simplify the cfg removing all succs of this bb
+      for (size_t si = 0; si < bb->GetSucc().size(); ++si) {
+        BB *sucBB = bb->GetSucc(si);
+        if (sucBB->GetAttributes(kBBAttrIsCatch)) {
+          sucBB->RemovePred(*bb);
+          --si;
+        }
+      }
+      continue;
+    }
+    // split this non-trivial bb
+    StmtNode *splitPoint = bb->GetStmtNodes().back().GetPrev();
+    while (splitPoint != nullptr && splitPoint->GetOpCode() == OP_comment) {
+      splitPoint = splitPoint->GetPrev();
+    }
+    CHECK_FATAL(splitPoint != nullptr, "null ptr check");
+    BB &newBB = SplitBB(*bb, *splitPoint);
+    // because SplitBB will insert a bb, we need update bIt & eIt
+    auto newBBIt = std::find(cbegin(), cend(), bb);
+    bIt = build_filter_iterator(
+        newBBIt, std::bind(FilterNullPtr<MapleVector<BB*>::const_iterator>, std::placeholders::_1, end()));
+    eIt = valid_end();
+    // redirect all succs of new bb to bb
+    for (size_t si = 0; si < newBB.GetSucc().size(); ++si) {
+      BB *sucBB = newBB.GetSucc(si);
+      if (sucBB->GetAttributes(kBBAttrIsCatch)) {
+        sucBB->ReplacePred(&newBB, bb);
+        --si;
+      }
+    }
+    if (bIt == eIt) {
+      break;
+    }
+  }
+}
+
+// replace "if() throw NPE()" with assertnonnull
+void MeCFG::ReplaceWithAssertnonnull() {
+  constexpr char rnnTypeName[] =
+      "Ljava_2Futil_2FObjects_3B_7CrequireNonNull_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B";
+  if (func.GetName() == rnnTypeName) {
+    return;
+  }
+  for (LabelIdx lblIdx : patternSet) {
+    BB *bb = GetLabelBBAt(lblIdx);
+    // if BB->pred_.size()==0, it won't enter this function
+    for (size_t i = 0; i < bb->GetPred().size(); ++i) {
+      BB *innerBB = bb->GetPred(i);
+      if (innerBB->GetKind() == kBBCondGoto) {
+        StmtNode &stmt = innerBB->GetStmtNodes().back();
+        Opcode stmtOp = stmt.GetOpCode();
+        ASSERT(stmt.IsCondBr(), "CondGoto BB with no condGoto stmt");
+        auto &condGotoNode = static_cast<CondGotoNode&>(stmt);
+        if ((stmtOp == OP_brtrue && condGotoNode.Opnd(0)->GetOpCode() != OP_eq) ||
+            (stmtOp == OP_brfalse && condGotoNode.Opnd(0)->GetOpCode() != OP_ne)) {
+          continue;
+        }
+        auto *cmpNode = static_cast<CompareNode*>(condGotoNode.Opnd(0));
+        BaseNode *opnd = nullptr;
+        if (cmpNode->GetOpndType() != PTY_ref && cmpNode->GetOpndType() != PTY_ptr) {
+          continue;
+        }
+        if (cmpNode->GetBOpnd(0)->GetOpCode() == OP_constval) {
+          auto *constNode = static_cast<ConstvalNode*>(cmpNode->GetBOpnd(0));
+          if (!constNode->GetConstVal()->IsZero()) {
+            continue;
+          }
+          opnd = cmpNode->GetBOpnd(1);
+        } else if (cmpNode->GetBOpnd(1)->GetOpCode() == OP_constval) {
+          auto *constNode = static_cast<ConstvalNode*>(cmpNode->GetBOpnd(1));
+          if (!constNode->GetConstVal()->IsZero()) {
+            continue;
+          }
+          opnd = cmpNode->GetBOpnd(0);
+        }
+        ASSERT(opnd != nullptr, "Compare with non-zero");
+        UnaryStmtNode *nullCheck = func.GetMIRModule().GetMIRBuilder()->CreateStmtUnary(OP_assertnonnull, opnd);
+        innerBB->ReplaceStmt(&stmt, nullCheck);
+        innerBB->SetKind(kBBFallthru);
+        innerBB->RemoveSucc(*bb);
+        --i;
+      }
+    }
+  }
+}
+
+bool MeCFG::IsStartTryBB(maple::BB &meBB) const {
+  if (!meBB.GetAttributes(kBBAttrIsTry) || meBB.GetAttributes(kBBAttrIsTryEnd)) {
+    return false;
+  }
+  return (!meBB.GetStmtNodes().empty() && meBB.GetStmtNodes().front().GetOpCode() == OP_try);
+}
+
+void MeCFG::FixTryBB(maple::BB &startBB, maple::BB &nextBB) {
+  startBB.RemoveAllPred();
+  for (size_t i = 0; i < nextBB.GetPred().size(); ++i) {
+    nextBB.GetPred(i)->ReplaceSucc(&nextBB, &startBB);
+  }
+  ASSERT(nextBB.GetPred().empty(), "pred of nextBB should be empty");
+  startBB.RemoveAllSucc();
+  startBB.AddSucc(nextBB);
+}
+
+// analyse the CFG to find the BBs that are not reachable from function entries
+// and delete them
+bool MeCFG::UnreachCodeAnalysis(bool updatePhi) {
+  std::vector<bool> visitedBBs(NumBBs(), false);
+  GetCommonEntryBB()->FindReachableBBs(visitedBBs);
+  // delete the unreached bb
+  bool cfgChanged = false;
+  auto eIt = valid_end();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    if (bb->GetAttributes(kBBAttrIsEntry)) {
+      continue;
+    }
+    BBId idx = bb->GetBBId();
+    if (visitedBBs[idx]) {
+      continue;
+    }
+
+    // if bb is StartTryBB, relationship between endtry and try should be maintained
+    if (IsStartTryBB(*bb)) {
+      bool needFixTryBB = false;
+      size_t size = GetAllBBs().size();
+      for (size_t nextIdx = idx + 1; nextIdx < size; ++nextIdx) {
+        auto nextBB = GetBBFromID(BBId(nextIdx));
+        if (nextBB == nullptr) {
+          continue;
+        }
+        if (!visitedBBs[nextIdx] && nextBB->GetAttributes(kBBAttrIsTryEnd)) {
+          break;
+        }
+        if (visitedBBs[nextIdx]) {
+          needFixTryBB = true;
+          visitedBBs[idx] = true;
+          FixTryBB(*bb, *nextBB);
+          cfgChanged = true;
+          break;
+        }
+      }
+      if (needFixTryBB) {
+        continue;
+      }
+    }
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "#### BB " << bb->GetBBId() << " deleted because unreachable\n";
+    }
+    if (bb->GetAttributes(kBBAttrIsTryEnd)) {
+      // unreachable bb has try end info
+      auto bbIt = std::find(rbegin(), rend(), bb);
+      auto prevIt = ++bbIt;
+      for (auto it = prevIt; it != rend(); ++it) {
+        if (*it != nullptr) {
+          // move entrytry tag to previous bb with try
+          if ((*it)->GetAttributes(kBBAttrIsTry) && !(*it)->GetAttributes(kBBAttrIsTryEnd)) {
+            (*it)->SetAttributes(kBBAttrIsTryEnd);
+            SetTryBBByOtherEndTryBB(*it, bb);
+          }
+          break;
+        }
+      }
+    }
+    DeleteBasicBlock(*bb);
+    cfgChanged = true;
+    // remove the bb from its succ's pred_ list
+    while (bb->GetSucc().size() > 0) {
+      BB *sucBB = bb->GetSucc(0);
+      sucBB->RemovePred(*bb, updatePhi);
+      if (updatePhi) {
+        if (sucBB->GetPred().empty()) {
+          sucBB->ClearPhiList();
+        } else if (sucBB->GetPred().size() == 1) {
+          ConvertPhis2IdentityAssigns(*sucBB);
+        }
+      }
+    }
+    // remove the bb from common_exit_bb's pred list if it is there
+    auto &predsOfCommonExit = GetCommonExitBB()->GetPred();
+    auto it = std::find(predsOfCommonExit.begin(), predsOfCommonExit.end(), bb);
+    if (it != predsOfCommonExit.end()) {
+      GetCommonExitBB()->RemoveExit(*bb);
+    }
+  }
+  return cfgChanged;
+}
+
+void MeCFG::ConvertPhiList2IdentityAssigns(BB &meBB) const {
+  for (auto phiIt = meBB.GetPhiList().begin(); phiIt != meBB.GetPhiList().end(); ++phiIt) {
+    if (!phiIt->second.GetIsLive()) {
+      continue;
+    }
+    // replace phi with identify assignment as it only has 1 opnd
+    const OriginalSt *ost = func.GetMeSSATab()->GetOriginalStFromID(phiIt->first);
+    CHECK_FATAL(ost, "ost is nullptr!");
+    if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) {
+      const MIRSymbol *st = ost->GetMIRSymbol();
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(st->GetTyIdx());
+      AddrofNode *dread = func.GetMIRModule().GetMIRBuilder()->CreateDread(*st, GetRegPrimType(type->GetPrimType()));
+      dread->SetFieldID(ost->GetFieldID());
+      auto *dread2 = func.GetMirFunc()->GetCodeMemPool()->New<AddrofSSANode>(*dread);
+      dread2->SetSSAVar(*(*phiIt).second.GetPhiOpnd(0));
+      DassignNode *dassign = func.GetMIRModule().GetMIRBuilder()->CreateStmtDassign(*st, ost->GetFieldID(), dread2);
+      func.GetMeSSATab()->GetStmtsSSAPart().SetSSAPartOf(
+          *dassign, func.GetMeSSATab()->GetStmtsSSAPart().GetSSAPartMp()->New<MayDefPartWithVersionSt>(
+              &func.GetMeSSATab()->GetStmtsSSAPart().GetSSAPartAlloc()));
+      auto *theSSAPart =
+          static_cast<MayDefPartWithVersionSt*>(func.GetMeSSATab()->GetStmtsSSAPart().SSAPartOf(*dassign));
+      theSSAPart->SetSSAVar(*((*phiIt).second.GetResult()));
+      meBB.PrependStmtNode(dassign);
+    }
+  }
+  meBB.ClearPhiList();  // delete all the phis
+}
+
+void MeCFG::ConvertMePhiList2IdentityAssigns(BB &meBB) const {
+  for (auto phiIt = meBB.GetMePhiList().cbegin(); phiIt != meBB.GetMePhiList().cend(); ++phiIt) {
+    if (!phiIt->second->GetIsLive()) {
+      continue;
+    }
+    // replace phi with identify assignment as it only has 1 opnd
+    const OriginalSt *ost = func.GetMeSSATab()->GetOriginalStFromID(phiIt->first);
+    CHECK_FATAL(ost, "ost is nullptr!");
+    if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) {
+      MePhiNode *varPhi = phiIt->second;
+      auto *dassign =
+          func.GetIRMap()->NewInPool<DassignMeStmt>(static_cast<VarMeExpr*>(varPhi->GetLHS()), varPhi->GetOpnd(0));
+      dassign->SetBB(varPhi->GetDefBB());
+      dassign->SetIsLive(varPhi->GetIsLive());
+      meBB.PrependMeStmt(dassign);
+    } else if (ost->IsPregOst()) {
+      MePhiNode *regPhi = phiIt->second;
+      auto *regAss = func.GetIRMap()->New<AssignMeStmt>(OP_regassign, static_cast<RegMeExpr*>(regPhi->GetLHS()),
+                                                        regPhi->GetOpnd(0));
+      regPhi->GetLHS()->SetDefByStmt(*regAss);
+      regPhi->GetLHS()->SetDefBy(kDefByStmt);
+      regAss->SetBB(regPhi->GetDefBB());
+      regAss->SetIsLive(regPhi->GetIsLive());
+      meBB.PrependMeStmt(regAss);
+    }
+  }
+  meBB.GetMePhiList().clear();  // delete all the phis
+}
+
+// used only after DSE because it looks at live field of VersionSt
+void MeCFG::ConvertPhis2IdentityAssigns(BB &meBB) const {
+  if (meBB.IsEmpty()) {
+    return;
+  }
+  ConvertPhiList2IdentityAssigns(meBB);
+  ConvertMePhiList2IdentityAssigns(meBB);
+}
+
+// analyse the CFG to find the BBs that will not reach any function exit; these
+// are BBs inside infinite loops; mark their wontExit flag and create
+// artificial edges from them to common_exit_bb
+void MeCFG::WontExitAnalysis() {
+  if (NumBBs() == 0) {
+    return;
+  }
+  std::vector<bool> visitedBBs(NumBBs(), false);
+  GetCommonExitBB()->FindWillExitBBs(visitedBBs);
+  auto eIt = valid_end();
+  std::vector<bool> currVisitedBBs(NumBBs(), false);
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == common_entry()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    BBId idx = bb->GetBBId();
+    if (visitedBBs[idx]) {
+      continue;
+    }
+    bb->SetAttributes(kBBAttrWontExit);
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "#### BB " << idx << " wont exit\n";
+    }
+    if (currVisitedBBs[idx]) {
+      // In the loop, only one edge needs to be connected to the common_exit_bb,
+      // and other bbs only need to add attributes.
+      continue;
+    }
+    if (bb->GetKind() != kBBGoto && bb->GetKind() != kBBIgoto && bb->GetKind() != kBBFallthru) {
+      continue;
+    }
+    if (bb->GetKind() == kBBFallthru) {
+      // Change fallthru bb to goto bb.
+      if (func.GetIRMap() == nullptr || bb->GetSucc().empty()) {
+        continue;
+      }
+      bb->AddMeStmtLast(func.GetIRMap()->New<GotoMeStmt>(func.GetOrCreateBBLabel(*bb->GetSucc(0))));
+      bb->SetKind(kBBGoto);
+    }
+    // create artificial BB to transition to common_exit_bb
+    BB *newBB = NewBasicBlock();
+    // update bIt & eIt
+    auto newBBIt = std::find(cbegin(), cend(), bb);
+    bIt = build_filter_iterator(
+        newBBIt, std::bind(FilterNullPtr<MapleVector<BB*>::const_iterator>, std::placeholders::_1, end()));
+    eIt = valid_end();
+    newBB->SetKindReturn();
+    newBB->SetAttributes(kBBAttrArtificial);
+    bb->AddSucc(*newBB);
+    // newBB is added as succ of bb, set freq 0 as its edge frequency
+    if (updateFreq) {
+      bb->PushBackSuccFreq(0);
+    }
+    GetCommonExitBB()->AddExit(*newBB);
+    bb->FindWillExitBBs(currVisitedBBs); // Mark other bbs in the loop as visited.
+  }
+}
+
+// CFG Verify
+// Check bb-vec and bb-list are strictly consistent.
+void MeCFG::Verify() const {
+  // Check every bb in bb-list.
+  auto eIt = valid_end();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == common_entry() || bIt == common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    ASSERT(bb->GetBBId() < bbVec.size(), "CFG Error!");
+    ASSERT(bbVec.at(bb->GetBBId()) == bb, "CFG Error!");
+    if (bb->IsEmpty()) {
+      continue;
+    }
+    ASSERT(bb->GetKind() != kBBUnknown, "runtime check error");
+    // verify succ[1] is goto bb
+    if (bb->GetKind() == kBBCondGoto) {
+      if (!bb->GetAttributes(kBBAttrIsTry) && !bb->GetAttributes(kBBAttrWontExit)) {
+        ASSERT(bb->GetStmtNodes().rbegin().base().d() != nullptr, "runtime check error");
+        ASSERT(bb->GetSucc().size() == kBBVectorInitialSize, "runtime check error");
+      }
+      ASSERT(bb->GetSucc(1)->GetBBLabel() == static_cast<CondGotoNode&>(bb->GetStmtNodes().back()).GetOffset(),
+             "runtime check error");
+    } else if (bb->GetKind() == kBBGoto) {
+      if (bb->GetStmtNodes().back().GetOpCode() == OP_throw) {
+        continue;
+      }
+      if (!bb->GetAttributes(kBBAttrIsTry) && !bb->GetAttributes(kBBAttrWontExit)) {
+        ASSERT(bb->GetStmtNodes().rbegin().base().d() != nullptr, "runtime check error");
+        ASSERT(bb->GetSucc().size() == 1, "runtime check error");
+      }
+      ASSERT(bb->GetSucc(0)->GetBBLabel() == static_cast<GotoNode&>(bb->GetStmtNodes().back()).GetOffset(),
+             "runtime check error");
+    }
+  }
+}
+
+// check that all the target labels in jump statements are defined
+void MeCFG::VerifyLabels() const {
+  auto eIt = valid_end();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    BB *mirBB = *bIt;
+    auto &stmtNodes = mirBB->GetStmtNodes();
+    if (stmtNodes.rbegin().base().d() == nullptr) {
+      continue;
+    }
+    if (mirBB->GetKind() == kBBGoto) {
+      if (stmtNodes.back().GetOpCode() == OP_throw) {
+        continue;
+      }
+      ASSERT(GetLabelBBAt(static_cast<GotoNode&>(stmtNodes.back()).GetOffset())->GetBBLabel() ==
+          static_cast<GotoNode&>(stmtNodes.back()).GetOffset(), "undefined label in goto");
+    } else if (mirBB->GetKind() == kBBCondGoto) {
+      ASSERT(GetLabelBBAt(static_cast<CondGotoNode&>(stmtNodes.back()).GetOffset())->GetBBLabel() ==
+          static_cast<CondGotoNode&>(stmtNodes.back()).GetOffset(), "undefined label in conditional branch");
+    } else if (mirBB->GetKind() == kBBSwitch) {
+      auto &switchStmt = static_cast<SwitchNode&>(stmtNodes.back());
+      LabelIdx targetLabIdx = switchStmt.GetDefaultLabel();
+      BB *bb = GetLabelBBAt(targetLabIdx);
+      if (targetLabIdx == 0) {
+        ASSERT(bb == nullptr, "undefined label in switch");
+      }
+      for (size_t j = 0; j < switchStmt.GetSwitchTable().size(); ++j) {
+        targetLabIdx = switchStmt.GetCasePair(j).second;
+        bb = GetLabelBBAt(targetLabIdx);
+        ASSERT(bb->GetBBLabel() == targetLabIdx, "undefined switch target label");
+      }
+    }
+  }
+}
+
+void MeCFG::Dump() const {
+  // BSF Dump the cfg
+  LogInfo::MapleLogger() << "####### CFG Dump: ";
+  ASSERT(NumBBs() != 0, "size to be allocated is 0");
+  auto *visitedMap = static_cast<bool*>(calloc(NumBBs(), sizeof(bool)));
+  if (visitedMap != nullptr) {
+    std::queue<BB*> qu;
+    qu.push(GetFirstBB());
+    while (!qu.empty()) {
+      BB *bb = qu.front();
+      qu.pop();
+      if (bb == nullptr) {
+        continue;
+      }
+      BBId id = bb->GetBBId();
+      if (visitedMap[static_cast<long>(id)]) {
+        continue;
+      }
+      LogInfo::MapleLogger() << id << " ";
+      visitedMap[static_cast<long>(id)] = true;
+      auto it = bb->GetSucc().begin();
+      while (it != bb->GetSucc().end()) {
+        BB *kidBB = *it;
+        if (!visitedMap[static_cast<long>(kidBB->GetBBId())]) {
+          qu.push(kidBB);
+        }
+        ++it;
+      }
+    }
+    LogInfo::MapleLogger() << '\n';
+    free(visitedMap);
+  }
+}
+
+// replace special char in FunctionName for output file
+static void ReplaceFilename(std::string &fileName) {
+  for (char &c : fileName) {
+    if (c == ';' || c == '/' || c == '|') {
+      c = '_';
+    }
+  }
+}
+
+static bool ContainsConststr(const BaseNode &x) {
+  if (x.GetOpCode() == OP_conststr || x.GetOpCode() == OP_conststr16) {
+    return true;
+  }
+  for (size_t i = 0; i < x.NumOpnds(); ++i) {
+    if (ContainsConststr(*x.Opnd(i))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+std::string MeCFG::ConstructFileNameToDump(const std::string &prefix) const {
+  std::string fileName;
+  if (!prefix.empty()) {
+    fileName.append(prefix);
+    fileName.append("-");
+  }
+  // the func name length may exceed OS's file name limit, so truncate after 80 chars
+  if (func.GetName().size() <= kFuncNameLenLimit) {
+    fileName.append(func.GetName());
+  } else {
+    fileName.append(func.GetName().c_str(), kFuncNameLenLimit);
+  }
+  ReplaceFilename(fileName);
+  fileName.append(".dot");
+  return fileName;
+}
+
+void MeCFG::DumpToFileInStrs(std::ofstream &cfgFile) const {
+  const auto &eIt = valid_end();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    if (bb->GetKind() == kBBCondGoto) {
+      cfgFile << "BB" << bb->GetBBId() << "[shape=diamond,label= \" BB" << bb->GetBBId() << ":\n{ ";
+    } else {
+      cfgFile << "BB" << bb->GetBBId() << "[shape=box,label= \" BB" << bb->GetBBId() << ":\n{ ";
+    }
+    if (bb->GetBBLabel() != 0) {
+      cfgFile << "@" << func.GetMirFunc()->GetLabelName(bb->GetBBLabel()) << ":\n";
+    }
+    for (auto &phiPair : bb->GetPhiList()) {
+      phiPair.second.Dump();
+    }
+    for (auto &stmt : bb->GetStmtNodes()) {
+      // avoid printing content that may contain " as this needs to be quoted
+      if (stmt.GetOpCode() == OP_comment) {
+        continue;
+      }
+      if (ContainsConststr(stmt)) {
+        continue;
+      }
+      stmt.Dump(1);
+    }
+    cfgFile << "}\"];\n";
+  }
+}
+
+// generate dot file for cfg
+void MeCFG::DumpToFile(const std::string &prefix, bool dumpInStrs, bool dumpEdgeFreq,
+                       const MapleVector<BB*> *laidOut) const {
+  if (MeOption::noDot) {
+    return;
+  }
+  std::ofstream cfgFile;
+  std::streambuf *coutBuf = LogInfo::MapleLogger().rdbuf();  // keep original cout buffer
+  std::streambuf *buf = cfgFile.rdbuf();
+  LogInfo::MapleLogger().rdbuf(buf);
+  const std::string &fileName = ConstructFileNameToDump(prefix);
+  cfgFile.open(fileName, std::ios::trunc);
+  cfgFile << "digraph {\n";
+  cfgFile << " # /*" << func.GetName() << " (red line is exception handler)*/\n";
+  // dump edge
+  auto eIt = valid_end();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    if (bIt == common_exit()) {
+      // specical case for common_exit_bb
+      for (auto it = bb->GetPred().begin(); it != bb->GetPred().end(); ++it) {
+        cfgFile << "BB" << (*it)->GetBBId() << " -> "
+                << "BB" << bb->GetBBId() << "[style=dotted];\n";
+      }
+      continue;
+    }
+    if (bb->GetAttributes(kBBAttrIsInstrument)) {
+      cfgFile << "BB" << bb->GetBBId() << "[color=blue];\n";
+    }
+
+    for (auto it = bb->GetSucc().begin(); it != bb->GetSucc().end(); ++it) {
+      cfgFile << "BB" << bb->GetBBId() << " -> "
+              << "BB" << (*it)->GetBBId();
+      if (bb == GetCommonEntryBB()) {
+        cfgFile << "[style=dotted]";
+        continue;
+      }
+      if ((*it)->GetAttributes(kBBAttrIsCatch)) {
+        /* succ is exception handler */
+        cfgFile << "[color=red]";
+      }
+
+      if (dumpEdgeFreq) {
+        cfgFile << "[label=" << bb->GetEdgeFreq(*it) << "];\n";
+      } else {
+        cfgFile << ";\n";
+      }
+    }
+  }
+  if (dumpEdgeFreq && laidOut == nullptr) {
+    for (auto it = valid_begin(); it != valid_end(); ++it) {
+      auto bbId = (*it)->GetBBId();
+      cfgFile << "BB" << bbId << "[label=BB" << bbId << "_freq_" << (*it)->GetFrequency() << "];\n";
+    }
+  }
+  if (laidOut != nullptr) {
+    static std::vector<std::string> colors = {"indianred1", "darkorange1", "lightyellow1", "green3",
+                                              "cyan", "dodgerblue2", "purple2"};
+    uint32 colorIdx = 0;
+    size_t clusterSize = laidOut->size() / colors.size();
+    uint32 cnt = 0;
+    for (uint32 i = 0; i < laidOut->size(); ++i) {
+      auto *bb = (*laidOut)[i];
+      auto bbId = bb->GetBBId();
+      std::string bbNameLabel = dumpEdgeFreq ? "BB" + std::to_string(bbId.GetIdx()) + "_freq_" +
+          std::to_string(bb->GetFrequency()) : "BB" + std::to_string(bbId.GetIdx());
+      cfgFile << "BB" << bbId << "[style=filled, color=" << colors[colorIdx % colors.size()] <<
+          ", label=" << bbNameLabel << "__" << i << "]\n";
+      ++cnt;
+      if (cnt > clusterSize) {
+        cnt = 0;
+        ++colorIdx;
+      }
+    }
+  }
+  // dump instruction in each BB
+  if (dumpInStrs) {
+    DumpToFileInStrs(cfgFile);
+  }
+  cfgFile << "}\n";
+  cfgFile.flush();
+  LogInfo::MapleLogger().rdbuf(coutBuf);
+}
+
+BB *MeCFG::NewBasicBlock() {
+  BB *newBB = memPool->New<BB>(&mecfgAlloc, &func.GetVersAlloc(), BBId(nextBBId++));
+  bbVec.push_back(newBB);
+  return newBB;
+}
+
+// new a basic block and insert before position or after position
+BB &MeCFG::InsertNewBasicBlock(const BB &position, bool isInsertBefore) {
+  BB *newBB = memPool->New<BB>(&mecfgAlloc, &func.GetVersAlloc(), BBId(nextBBId++));
+
+  auto bIt = std::find(begin(), end(), &position);
+  auto idx = position.GetBBId();
+  if (!isInsertBefore) {
+    ++bIt;
+    ++idx;
+  }
+  auto newIt = bbVec.insert(bIt, newBB);
+  auto eIt = end();
+  // update bb's idx
+  for (auto it = newIt; it != eIt; ++it) {
+    if ((*it) != nullptr) {
+      (*it)->SetBBId(BBId(idx));
+    }
+    ++idx;
+  }
+  return *newBB;
+}
+
+void MeCFG::DeleteBasicBlock(const BB &bb) {
+  ASSERT(bbVec[bb.GetBBId()] == &bb, "runtime check error");
+  /* update first_bb_ and last_bb if needed */
+  bbVec.at(bb.GetBBId()) = nullptr;
+}
+
+/* get next bb in bbVec */
+BB *MeCFG::NextBB(const BB *bb) {
+  auto bbIt = std::find(cbegin(), cend(), bb);
+  CHECK_FATAL(bbIt != end(), "bb must be inside bb_vec");
+  for (auto it = ++bbIt; it != end(); ++it) {
+    if (*it != nullptr) {
+      return *it;
+    }
+  }
+  return nullptr;
+}
+
+/* get prev bb in bbVec */
+BB *MeCFG::PrevBB(const BB *bb) {
+  auto bbIt = std::find(crbegin(), crend(), bb);
+  CHECK_FATAL(bbIt != rend(), "bb must be inside bb_vec");
+  for (auto it = ++bbIt; it != rend(); ++it) {
+    if (*it != nullptr) {
+      return *it;
+    }
+  }
+  return nullptr;
+}
+
+/* clone stmtnode in orig bb to newBB */
+void MeCFG::CloneBasicBlock(BB &newBB, const BB &orig) {
+  if (orig.IsEmpty()) {
+    return;
+  }
+  for (const auto &stmt : orig.GetStmtNodes()) {
+    StmtNode *newStmt = stmt.CloneTree(func.GetMIRModule().GetCurFuncCodeMPAllocator());
+    newStmt->SetNext(nullptr);
+    newStmt->SetPrev(nullptr);
+    newBB.AddStmtNode(newStmt);
+    if (func.GetMeSSATab() != nullptr) {
+      func.GetMeSSATab()->CreateSSAStmt(*newStmt, &newBB);
+    }
+  }
+}
+
+// Unify all returns into one block
+// Return false if there is only one return block; otherwise, return true
+bool MeCFG::UnifyRetBBs() {
+  // Find all return blocks
+  std::vector<BB*> retBBs;
+  auto theCFG = func.GetCfg();
+  auto eIt = theCFG->valid_end();
+  for (auto bIt = theCFG->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    if (bb->IsReturnBB()) {
+      retBBs.push_back(bb);
+    }
+  }
+  // Check the number of return blocks to determine whether unification is necessary
+  if (retBBs.size() < 2) {
+    return false;
+  }
+
+  if (!MeOption::quiet) {
+    LogInfo::MapleLogger() << "++ Going to unify " << retBBs.size() << " returns\n";
+  }
+  // Create a return block as the only return block
+  BB *newRetBB = theCFG->NewBasicBlock();
+  newRetBB->SetKindReturn();
+  // Add return statement in the new return block
+  auto mirBuilder = func.GetMIRModule().GetMIRBuilder();
+  MIRSymbol *unifiedFuncRet = nullptr;
+  if (func.GetMirFunc()->IsReturnVoid()) {
+    newRetBB->SetFirst(mirBuilder->CreateStmtReturn(nullptr));
+  } else {
+    unifiedFuncRet = mirBuilder->CreateSymbol(func.GetMirFunc()->GetReturnTyIdx(), "unified_func_ret", kStVar, kScAuto,
+                                              func.GetMirFunc(), kScopeLocal);
+    newRetBB->SetFirst(mirBuilder->CreateStmtReturn(mirBuilder->CreateExprDread(*unifiedFuncRet)));
+  }
+  newRetBB->SetLast(newRetBB->GetStmtNodes().begin().d());
+
+  LabelIdx newRetBBLabel = func.GetOrCreateBBLabel(*newRetBB);
+  auto exitBB = func.GetCfg()->GetCommonExitBB();
+  for (auto curRetBB : retBBs) {
+    // Replace the return statement in the existing blocks with Dassign statement
+    // where the target var is "unified_func_ret" if the return of the function is not void.
+    if (unifiedFuncRet) {
+      auto *newAssign = mirBuilder->CreateStmtDassign(*unifiedFuncRet, 0, curRetBB->GetLast().Opnd(0));
+      curRetBB->RemoveLastStmt();
+      curRetBB->AddStmtNode(newAssign);
+    } else {
+      curRetBB->RemoveLastStmt();
+    }
+    // Add new goto assignment in existing return blocks so that it will goto the new return block
+    auto *newGoto = mirBuilder->CreateStmtGoto(OP_goto, newRetBBLabel);
+    curRetBB->AddStmtNode(newGoto);
+    curRetBB->SetKind(kBBGoto);
+    curRetBB->RemoveAllSucc();
+    curRetBB->AddSucc(*newRetBB);
+    exitBB->RemoveExit(*curRetBB);
+  }
+  exitBB->AddExit(*newRetBB);
+  return true;
+}
+
+void MeCFG::SplitBBPhysically(BB &bb, StmtNode &splitPoint, BB &newBB) {
+  StmtNode *newBBStart = splitPoint.GetNext();
+  // Fix Stmt in BB.
+  if (newBBStart != nullptr) {
+    newBBStart->SetPrev(nullptr);
+    for (StmtNode *stmt = newBBStart; stmt != nullptr;) {
+      StmtNode *nextStmt = stmt->GetNext();
+      newBB.AddStmtNode(stmt);
+      if (func.GetMeSSATab() != nullptr) {
+        func.GetMeSSATab()->CreateSSAStmt(*stmt, &newBB);
+      }
+      stmt = nextStmt;
+    }
+  }
+  bb.SetLast(&splitPoint);
+  splitPoint.SetNext(nullptr);
+}
+
+/* Split BB at split_point */
+BB &MeCFG::SplitBB(BB &bb, StmtNode &splitPoint, BB *newBB) {
+  if (newBB == nullptr) {
+    newBB = memPool->New<BB>(&mecfgAlloc, &func.GetVersAlloc(), BBId(nextBBId++));
+  }
+  SplitBBPhysically(bb, splitPoint, *newBB);
+  // Fix BB in CFG
+  newBB->SetKind(bb.GetKind());
+  bb.SetKind(kBBFallthru);
+  auto bIt = std::find(begin(), end(), &bb);
+  auto idx = bb.GetBBId();
+  auto newIt = bbVec.insert(++bIt, newBB);
+  auto eIt = end();
+  // update bb's idx
+  for (auto it = newIt; it != eIt; ++it) {
+    ++idx;
+    if ((*it) != nullptr) {
+      (*it)->SetBBId(BBId(idx));
+    }
+  }
+  // Special Case: commonExitBB is orig bb's succ
+  auto *commonExitBB = *common_exit();
+  if (bb.IsPredBB(*commonExitBB)) {
+    commonExitBB->RemoveExit(bb);
+    commonExitBB->AddExit(*newBB);
+  }
+  while (bb.GetSucc().size() > 0) {
+    BB *succ = bb.GetSucc(0);
+    succ->ReplacePred(&bb, newBB);
+  }
+  bb.AddSucc(*newBB);
+  // Setup flags
+  newBB->CopyFlagsAfterSplit(bb);
+  if (newBB->GetAttributes(kBBAttrIsTryEnd)) {
+    endTryBB2TryBB[newBB] = endTryBB2TryBB[&bb];
+    endTryBB2TryBB[&bb] = nullptr;
+    bb.ClearAttributes(kBBAttrIsTryEnd);
+  }
+  bb.ClearAttributes(kBBAttrIsExit);
+  return *newBB;
+}
+
+void MeCFG::SetTryBlockInfo(const StmtNode *nextStmt, StmtNode *tryStmt, BB *lastTryBB, BB *curBB, BB *newBB) {
+  if (nextStmt->GetOpCode() == OP_endtry) {
+    curBB->SetAttributes(kBBAttrIsTryEnd);
+    ASSERT(lastTryBB != nullptr, "null ptr check");
+    endTryBB2TryBB[curBB] = lastTryBB;
+  } else {
+    newBB->SetAttributes(kBBAttrIsTry);
+    bbTryNodeMap[newBB] = tryStmt;
+  }
+}
+
+void MeCFG::CreateBasicBlocks() {
+  if (func.CurFunction()->IsEmpty()) {
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "function is empty, cfg is nullptr\n";
+    }
+    return;
+  }
+  // create common_entry/exit bb first as bbVec[0] and bb_vec[1]
+  bool isJavaModule = func.GetMIRModule().IsJavaModule();
+  auto *commonEntryBB = NewBasicBlock();
+  commonEntryBB->SetAttributes(kBBAttrIsEntry);
+  auto *commonExitBB = NewBasicBlock();
+  commonExitBB->SetAttributes(kBBAttrIsExit);
+  auto *firstBB = NewBasicBlock();
+  firstBB->SetAttributes(kBBAttrIsEntry);
+  StmtNode *nextStmt = func.CurFunction()->GetBody()->GetFirst();
+  ASSERT(nextStmt != nullptr, "function has no statement");
+  BB *curBB = firstBB;
+  StmtNode *tryStmt = nullptr;  // record current try stmt for map<bb, try_stmt>
+  BB *lastTryBB = nullptr;      // bb containing try_stmt
+  do {
+    StmtNode *stmt = nextStmt;
+    nextStmt = stmt->GetNext();
+    switch (stmt->GetOpCode()) {
+      case OP_goto: {
+        if (curBB->IsEmpty()) {
+          curBB->SetFirst(stmt);
+        }
+        curBB->SetLast(stmt);
+        curBB->SetKind(kBBGoto);
+        if (nextStmt != nullptr) {
+          BB *newBB = NewBasicBlock();
+          if (tryStmt != nullptr) {
+            SetTryBlockInfo(nextStmt, tryStmt, lastTryBB, curBB, newBB);
+          }
+          curBB = newBB;
+        }
+        break;
+      }
+      case OP_igoto: {
+        if (curBB->IsEmpty()) {
+          curBB->SetFirst(stmt);
+        }
+        curBB->SetLast(stmt);
+        curBB->SetKind(kBBIgoto);
+        if (nextStmt != nullptr) {
+          curBB = NewBasicBlock();
+        }
+        break;
+      }
+      case OP_dassign: {
+        DassignNode *dass = static_cast<DassignNode*>(stmt);
+        // delete identity assignments inserted by LFO
+        if (dass->GetRHS()->GetOpCode() == OP_dread) {
+          DreadNode *dread = static_cast<DreadNode*>(dass->GetRHS());
+          if (dass->GetStIdx() == dread->GetStIdx() && dass->GetFieldID() == dread->GetFieldID()) {
+            func.CurFunction()->GetBody()->RemoveStmt(stmt);
+            break;
+          }
+        }
+        if (curBB->IsEmpty()) {
+          curBB->SetFirst(stmt);
+        }
+        if (isJavaModule && dass->GetRHS()->MayThrowException()) {
+          stmt->SetOpCode(OP_maydassign);
+          if (tryStmt != nullptr) {
+            // breaks new BB only inside try blocks
+            curBB->SetLast(stmt);
+            curBB->SetKind(kBBFallthru);
+            BB *newBB = NewBasicBlock();
+            SetTryBlockInfo(nextStmt, tryStmt, lastTryBB, curBB, newBB);
+            curBB = newBB;
+            break;
+          }
+        }
+        if ((nextStmt == nullptr) && to_ptr(curBB->GetStmtNodes().rbegin()) == nullptr) {
+          curBB->SetLast(stmt);
+        }
+        break;
+      }
+      case OP_brfalse:
+      case OP_brtrue: {
+        if (curBB->IsEmpty()) {
+          curBB->SetFirst(stmt);
+        }
+        curBB->SetLast(stmt);
+        curBB->SetKind(kBBCondGoto);
+        BB *newBB = NewBasicBlock();
+        if (tryStmt != nullptr) {
+          SetTryBlockInfo(nextStmt, tryStmt, lastTryBB, curBB, newBB);
+        }
+        curBB = newBB;
+        break;
+      }
+      case OP_if:
+      case OP_doloop:
+      case OP_dowhile:
+      case OP_while: {
+        ASSERT(false, "not yet implemented");
+        break;
+      }
+      case OP_throw:
+        if (tryStmt != nullptr) {
+          // handle as goto
+          if (curBB->IsEmpty()) {
+            curBB->SetFirst(stmt);
+          }
+          curBB->SetLast(stmt);
+          curBB->SetKind(kBBGoto);
+          if (nextStmt != nullptr) {
+            BB *newBB = NewBasicBlock();
+            SetTryBlockInfo(nextStmt, tryStmt, lastTryBB, curBB, newBB);
+            curBB = newBB;
+          }
+          break;
+        }
+        // fall thru to handle as return
+        [[clang::fallthrough]];
+      case OP_gosub:
+      case OP_retsub:
+      case OP_return: {
+        if (curBB->IsEmpty()) {
+          curBB->SetFirst(stmt);
+        }
+        curBB->SetLast(stmt);
+        curBB->SetKindReturn();
+        if (nextStmt != nullptr) {
+          BB *newBB = NewBasicBlock();
+          if (tryStmt != nullptr) {
+            SetTryBlockInfo(nextStmt, tryStmt, lastTryBB, curBB, newBB);
+          }
+          curBB = newBB;
+          if (stmt->GetOpCode() == OP_gosub) {
+            curBB->SetAttributes(kBBAttrIsEntry);
+          }
+        }
+        break;
+      }
+      case OP_endtry:
+        if (isJavaModule) {
+          if (tryStmt == nullptr) {
+            break;
+          }
+          /* skip OP_entry and generate it in emit phase */
+          ASSERT(lastTryBB != nullptr, "null ptr check");
+          tryStmt = nullptr;  // reset intryblocks
+          if (!curBB->IsEmpty()) {
+            StmtNode *lastStmt = stmt->GetPrev();
+            ASSERT(curBB->GetStmtNodes().rbegin().base().d() == nullptr ||
+                       curBB->GetStmtNodes().rbegin().base().d() == lastStmt,
+                   "something wrong building BB");
+            curBB->SetLast(lastStmt);
+            if (curBB->GetKind() == kBBUnknown) {
+              curBB->SetKind(kBBFallthru);
+            }
+            curBB->SetAttributes(kBBAttrIsTryEnd);
+            SetBBTryBBMap(curBB, lastTryBB);
+            curBB = NewBasicBlock();
+          } else if (curBB->GetBBLabel() != 0) {
+            // create the empty BB
+            curBB->SetKind(kBBFallthru);
+            curBB->SetAttributes(kBBAttrIsTryEnd);
+            SetBBTryBBMap(curBB, lastTryBB);
+            curBB = NewBasicBlock();
+          } else {
+          }  // endtry has already been processed in SetTryBlockInfo()
+          lastTryBB = nullptr;
+        } else {
+          if (curBB->IsEmpty()) {
+            curBB->SetFirst(stmt);
+          }
+          if ((nextStmt == nullptr) && (curBB->GetStmtNodes().rbegin().base().d() == nullptr)) {
+            curBB->SetLast(stmt);
+          }
+        }
+        break;
+      case OP_try: {
+        // start a new bb or with a label
+        if (!curBB->IsEmpty()) {
+          // prepare a new bb
+          StmtNode *lastStmt = stmt->GetPrev();
+          ASSERT(curBB->GetStmtNodes().rbegin().base().d() == nullptr ||
+              curBB->GetStmtNodes().rbegin().base().d() == lastStmt, "something wrong building BB");
+          curBB->SetLast(lastStmt);
+          if (curBB->GetKind() == kBBUnknown) {
+            curBB->SetKind(kBBFallthru);
+          }
+          BB *newBB = NewBasicBlock();
+          // assume no nested try, so no need to call SetTryBlockInfo()
+          curBB = newBB;
+        }
+        curBB->SetFirst(stmt);
+        tryStmt = stmt;
+        lastTryBB = curBB;
+        curBB->SetAttributes(kBBAttrIsTry);
+        bbTryNodeMap[curBB] = tryStmt;
+        // prepare a new bb that contains only a OP_try. It is needed for
+        // dse to work correctly: assignments in a try block should not affect
+        // assignments before the try block as exceptions might occur.
+        curBB->SetLast(stmt);
+        curBB->SetKind(kBBFallthru);
+        BB *newBB = NewBasicBlock();
+        SetTryBlockInfo(nextStmt, tryStmt, lastTryBB, curBB, newBB);
+        curBB = newBB;
+        break;
+      }
+      case OP_catch: {
+        // start a new bb or with a label
+        if (!curBB->IsEmpty()) {
+          // prepare a new bb
+          StmtNode *lastStmt = stmt->GetPrev();
+          ASSERT(curBB->GetStmtNodes().rbegin().base().d() == nullptr ||
+              curBB->GetStmtNodes().rbegin().base().d() == lastStmt, "something wrong building BB");
+          curBB->SetLast(lastStmt);
+          if (curBB->GetKind() == kBBUnknown) {
+            curBB->SetKind(kBBFallthru);
+          }
+          BB *newBB = NewBasicBlock();
+          if (tryStmt != nullptr) {
+            SetTryBlockInfo(nextStmt, tryStmt, lastTryBB, curBB, newBB);
+          }
+          curBB = newBB;
+        }
+        curBB->SetFirst(stmt);
+        curBB->SetAttributes(kBBAttrIsCatch);
+        auto *catchNode = static_cast<CatchNode*>(stmt);
+        const MapleVector<TyIdx> &exceptionTyIdxVec = catchNode->GetExceptionTyIdxVec();
+
+        for (TyIdx exceptIdx : exceptionTyIdxVec) {
+          MIRType *eType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(exceptIdx);
+          ASSERT(eType != nullptr && (eType->GetPrimType() == PTY_ptr || eType->GetPrimType() == PTY_ref),
+                 "wrong exception type");
+          auto *exceptType = static_cast<MIRPtrType*>(eType);
+          MIRType *pointType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(exceptType->GetPointedTyIdx());
+          const std::string &eName = GlobalTables::GetStrTable().GetStringFromStrIdx(pointType->GetNameStrIdx());
+          if ((pointType->GetPrimType() == PTY_void) || (eName == "Ljava/lang/Throwable;") ||
+              (eName == "Ljava/lang/Exception;")) {
+            // "Ljava/lang/Exception;" is risk to set isJavaFinally because it
+            // only deal with "throw exception". if throw error,  it's wrong
+            curBB->SetAttributes(kBBAttrIsJavaFinally);  // this is a start of finally handler
+          }
+        }
+        break;
+      }
+      case OP_label: {
+        auto *labelNode = static_cast<LabelNode*>(stmt);
+        LabelIdx labelIdx = labelNode->GetLabelIdx();
+        if (func.IsPme() && curBB == firstBB && curBB->IsEmpty()) {
+          // when function starts with a label, need to insert dummy BB as entry
+          curBB = NewBasicBlock();
+        }
+        if (!curBB->IsEmpty() || curBB->GetBBLabel() != 0) {
+          // prepare a new bb
+          StmtNode *lastStmt = stmt->GetPrev();
+          ASSERT((curBB->GetStmtNodes().rbegin().base().d() == nullptr ||
+                  curBB->GetStmtNodes().rbegin().base().d() == lastStmt),
+                 "something wrong building BB");
+          if (curBB->GetStmtNodes().rbegin().base().d() == nullptr && (lastStmt->GetOpCode() != OP_label)) {
+            if (isJavaModule && lastStmt->GetOpCode() == OP_endtry) {
+              if (curBB->GetStmtNodes().empty()) {
+                curBB->SetLast(nullptr);
+              } else {
+                // find a valid stmt which is not label or endtry
+                StmtNode *p = lastStmt->GetPrev();
+                ASSERT(p != nullptr, "null ptr check");
+                ASSERT(p->GetOpCode() != OP_label, "runtime check error");
+                ASSERT(p->GetOpCode() != OP_endtry, "runtime check error");
+                curBB->SetLast(p);
+              }
+            } else {
+              curBB->SetLast(lastStmt);
+            }
+          }
+          if (curBB->GetKind() == kBBUnknown) {
+            curBB->SetKind(kBBFallthru);
+          }
+          BB *newBB = NewBasicBlock();
+          if (tryStmt != nullptr) {
+            newBB->SetAttributes(kBBAttrIsTry);
+            SetBBTryNodeMap(*newBB, *tryStmt);
+          }
+          curBB = newBB;
+        } else if (func.GetPreMeFunc() && (func.GetPreMeFunc()->label2WhileInfo.find(labelIdx) !=
+                                           func.GetPreMeFunc()->label2WhileInfo.end())) {
+          curBB->SetKind(kBBFallthru);
+          BB *newBB = NewBasicBlock();
+          if (tryStmt != nullptr) {
+            newBB->SetAttributes(kBBAttrIsTry);
+            SetBBTryNodeMap(*newBB, *tryStmt);
+          }
+          curBB = newBB;
+        }
+        labelBBIdMap[labelIdx] = curBB;
+        curBB->SetBBLabel(labelIdx);
+        // label node is not real node in bb, get frequency information to bb
+        if (Options::profileUse && func.GetMirFunc()->GetFuncProfData()) {
+          auto freq = func.GetMirFunc()->GetFuncProfData()->GetStmtFreq(stmt->GetStmtID());
+          if (freq >= 0) {
+            curBB->SetFrequency(freq);
+          }
+        }
+        break;
+      }
+      case OP_jscatch: {
+        if (curBB->IsEmpty()) {
+          curBB->SetFirst(stmt);
+        }
+        curBB->SetAttributes(kBBAttrIsEntry);
+        curBB->SetAttributes(kBBAttrIsJSCatch);
+        break;
+      }
+      case OP_finally: {
+        ASSERT(curBB->GetStmtNodes().empty(), "runtime check error");
+        curBB->SetFirst(stmt);
+        curBB->SetAttributes(kBBAttrIsEntry);
+        curBB->SetAttributes(kBBAttrIsJSFinally);
+        break;
+      }
+      case OP_switch: {
+        if (curBB->IsEmpty()) {
+          curBB->SetFirst(stmt);
+        }
+        curBB->SetLast(stmt);
+        curBB->SetKind(kBBSwitch);
+        BB *newBB = NewBasicBlock();
+        if (tryStmt != nullptr) {
+          SetTryBlockInfo(nextStmt, tryStmt, lastTryBB, curBB, newBB);
+        }
+        curBB = newBB;
+        break;
+      }
+      case OP_call: {
+        CallNode *callStmt = static_cast<CallNode*>(stmt);
+        MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt->GetPUIdx());
+        if (callee->GetFuncAttrs().GetAttr(FUNCATTR_noreturn)) {
+          if (curBB->IsEmpty()) {
+            curBB->SetFirst(stmt);
+          }
+          curBB->SetLast(stmt);
+          curBB->SetKindReturn();
+          if (nextStmt != nullptr) {
+            BB *newBB = NewBasicBlock();
+            curBB = newBB;
+          }
+          break;
+        }
+        // fall thru to handle as default
+        [[clang::fallthrough]];
+      }
+      default: {
+        if (curBB->IsEmpty()) {
+          curBB->SetFirst(stmt);
+        }
+        if ((nextStmt == nullptr) && (curBB->GetStmtNodes().rbegin().base().d() == nullptr)) {
+          curBB->SetLast(stmt);
+        }
+        break;
+      }
+    }
+  } while (nextStmt != nullptr);
+  ASSERT(tryStmt == nullptr, "unclosed try");      // tryandendtry should be one-one mapping
+  ASSERT(lastTryBB == nullptr, "unclosed tryBB");  // tryandendtry should be one-one mapping
+  auto *lastBB = curBB;
+  if (lastBB->IsEmpty()) {
+    // insert a return statement
+    lastBB->SetFirst(func.GetMIRModule().GetMIRBuilder()->CreateStmtReturn(nullptr));
+    lastBB->SetLast(lastBB->GetStmtNodes().begin().d());
+    lastBB->SetKindReturn();
+  } else if (lastBB->GetKind() == kBBUnknown) {
+    lastBB->SetKindReturn();
+    lastBB->SetAttributes(kBBAttrIsExit);
+  }
+}
+
+void MeCFG::BBTopologicalSort(SCCOfBBs &scc) {
+  std::set<BB*> inQueue;
+  std::vector<BB*> bbs;
+  for (BB *bb : scc.GetBBs()) {
+    bbs.push_back(bb);
+  }
+  scc.Clear();
+  scc.AddBBNode(scc.GetEntry());
+  (void)inQueue.insert(scc.GetEntry());
+
+  for (size_t i = 0; i < scc.GetBBs().size(); ++i) {
+    BB *bb = scc.GetBBs()[i];
+    for (BB *succ : bb->GetSucc()) {
+      if (succ == nullptr) {
+        continue;
+      }
+      if (inQueue.find(succ) != inQueue.end() || std::find(bbs.begin(), bbs.end(), succ) == bbs.end()) {
+        continue;
+      }
+      bool predAllVisited = true;
+      for (BB *pred : succ->GetPred()) {
+        if (pred == nullptr) {
+          continue;
+        }
+        if (std::find(bbs.begin(), bbs.end(), pred) == bbs.end()) {
+          continue;
+        }
+        if (backEdges.find(std::pair<uint32, uint32>(pred->UintID(), succ->UintID())) != backEdges.end()) {
+          continue;
+        }
+        if (inQueue.find(pred) == inQueue.end()) {
+          predAllVisited = false;
+          break;
+        }
+      }
+      if (predAllVisited) {
+        scc.AddBBNode(succ);
+        (void)inQueue.insert(succ);
+      }
+    }
+  }
+}
+
+void MeCFG::BuildSCCDFS(BB &bb, uint32 &visitIndex, std::vector<SCCOfBBs*> &sccNodes,
+                        std::vector<uint32> &visitedOrder, std::vector<uint32> &lowestOrder, std::vector<bool> &inStack,
+                        std::stack<uint32> &visitStack) {
+  uint32 id = bb.UintID();
+  visitedOrder[id] = visitIndex;
+  lowestOrder[id] = visitIndex;
+  ++visitIndex;
+  visitStack.push(id);
+  inStack[id] = true;
+
+  for (BB *succ : bb.GetSucc()) {
+    if (succ == nullptr) {
+      continue;
+    }
+    uint32 succId = succ->UintID();
+    if (!visitedOrder[succId]) {
+      BuildSCCDFS(*succ, visitIndex, sccNodes, visitedOrder, lowestOrder, inStack, visitStack);
+      if (lowestOrder[succId] < lowestOrder[id]) {
+        lowestOrder[id] = lowestOrder[succId];
+      }
+    } else if (inStack[succId]) {
+      (void)backEdges.emplace(std::pair<uint32, uint32>(id, succId));
+      if (visitedOrder[succId] < lowestOrder[id]) {
+        lowestOrder[id] = visitedOrder[succId];
+      }
+    }
+  }
+
+  if (visitedOrder.at(id) == lowestOrder.at(id)) {
+    auto *sccNode = GetAlloc().GetMemPool()->New<SCCOfBBs>(numOfSCCs++, &bb, &GetAlloc());
+    uint32 stackTopId;
+    do {
+      stackTopId = visitStack.top();
+      visitStack.pop();
+      inStack[stackTopId] = false;
+      auto *topBB = static_cast<BB*>(GetAllBBs()[stackTopId]);
+      sccNode->AddBBNode(topBB);
+      sccOfBB[stackTopId] = sccNode;
+    } while (stackTopId != id);
+
+    sccNodes.push_back(sccNode);
+  }
+}
+
+void MeCFG::VerifySCC() {
+  for (BB *bb : GetAllBBs()) {
+    if (bb == nullptr || bb == GetCommonExitBB()) {
+      continue;
+    }
+    SCCOfBBs *scc = sccOfBB.at(bb->UintID());
+    CHECK_FATAL(scc != nullptr, "bb should belong to a scc");
+  }
+}
+
+void MeCFG::SCCTopologicalSort(std::vector<SCCOfBBs*> &sccNodes) {
+  std::set<SCCOfBBs*> inQueue;
+  for (SCCOfBBs *node : sccNodes) {
+    if (!node->HasPred()) {
+      sccTopologicalVec.push_back(node);
+      (void)inQueue.insert(node);
+    }
+  }
+
+  // Top-down iterates all nodes
+  for (size_t i = 0; i < sccTopologicalVec.size(); ++i) {
+    SCCOfBBs *sccBB = sccTopologicalVec[i];
+    for (SCCOfBBs *succ : sccBB->GetSucc()) {
+      if (inQueue.find(succ) == inQueue.end()) {
+        // successor has not been visited
+        bool predAllVisited = true;
+        // check whether all predecessors of the current successor have been visited
+        for (SCCOfBBs *pred : succ->GetPred()) {
+          if (inQueue.find(pred) == inQueue.end()) {
+            predAllVisited = false;
+            break;
+          }
+        }
+        if (predAllVisited) {
+          sccTopologicalVec.push_back(succ);
+          (void)inQueue.insert(succ);
+        }
+      }
+    }
+  }
+}
+
+void MeCFG::BuildSCC() {
+  size_t n = GetAllBBs().size();
+  sccTopologicalVec.clear();
+  sccOfBB.clear();
+  sccOfBB.assign(n, nullptr);
+  std::vector<uint32> visitedOrder(n, 0);
+  std::vector<uint32> lowestOrder(n, 0);
+  std::vector<bool> inStack(n, false);
+  std::vector<SCCOfBBs*> sccNodes;
+  uint32 visitIndex = 1;
+  std::stack<uint32> visitStack;
+
+  // Starting from common entry bb for DFS
+  BuildSCCDFS(*GetCommonEntryBB(), visitIndex, sccNodes, visitedOrder, lowestOrder, inStack, visitStack);
+
+  for (SCCOfBBs *scc : sccNodes) {
+    scc->Verify(sccOfBB);
+    scc->SetUp(sccOfBB);
+  }
+
+  VerifySCC();
+  SCCTopologicalSort(sccNodes);
+}
+
+// After currBB's succ is changed, we can update currBB's target
+void MeCFG::UpdateBranchTarget(BB &currBB, const BB &oldTarget, BB &newTarget, MeFunction &meFunc) {
+  bool forMeIR = meFunc.GetIRMap() != nullptr;
+  // update statement offset if succ is goto target
+  if (currBB.IsGoto()) {
+    ASSERT(currBB.GetSucc(0) == &newTarget, "[FUNC: %s]Goto's target BB is not newTarget", func.GetName().c_str());
+    LabelIdx label = meFunc.GetOrCreateBBLabel(newTarget);
+    if (forMeIR) {
+      auto *gotoBr = static_cast<GotoMeStmt*>(currBB.GetLastMe());
+      if (gotoBr->GetOffset() != label) {
+        gotoBr->SetOffset(label);
+      }
+    } else {
+      auto &gotoBr = static_cast<GotoNode&>(currBB.GetLast());
+      if (gotoBr.GetOffset() != label) {
+        gotoBr.SetOffset(label);
+      }
+    }
+  } else if (currBB.GetKind() == kBBCondGoto) {
+    if (currBB.GetSucc(0) == &newTarget) {
+      return; // no need to update offset for fallthru BB
+    }
+    BB *gotoBB = currBB.GetSucc().at(1);
+    ASSERT(gotoBB == &newTarget, "[FUNC: %s]newTarget is not one of CondGoto's succ BB", func.GetName().c_str());
+    LabelIdx label = meFunc.GetOrCreateBBLabel(*gotoBB);
+    if (forMeIR) {
+      auto *condBr = static_cast<CondGotoMeStmt*>(currBB.GetLastMe());
+      if (condBr->GetOffset() != label) {
+        // original gotoBB is replaced by newBB
+        condBr->SetOffset(label);
+      }
+    } else {
+      auto &condBr = static_cast<CondGotoNode&>(currBB.GetLast());
+      if (condBr.GetOffset() != label) {
+        condBr.SetOffset(label);
+      }
+    }
+  } else if (currBB.GetKind() == kBBSwitch) {
+    LabelIdx oldLabelIdx = oldTarget.GetBBLabel();
+    LabelIdx label = meFunc.GetOrCreateBBLabel(newTarget);
+    if (forMeIR) {
+      auto *switchStmt = static_cast<SwitchMeStmt*>(currBB.GetLastMe());
+      ASSERT_NOT_NULL(switchStmt);
+      if (switchStmt->GetDefaultLabel() == oldLabelIdx) {
+        switchStmt->SetDefaultLabel(label);
+      }
+      for (size_t i = 0; i < switchStmt->GetSwitchTable().size(); ++i) {
+        LabelIdx caseLabel = switchStmt->GetSwitchTable().at(i).second;
+        if (caseLabel == oldLabelIdx) {
+          switchStmt->SetCaseLabel(i, label);
+        }
+      }
+    } else {
+      auto &switchStmt = static_cast<SwitchNode&>(currBB.GetLast());
+      if (switchStmt.GetDefaultLabel() == oldLabelIdx) {
+        switchStmt.SetDefaultLabel(label);
+      }
+      for (size_t i = 0; i < switchStmt.GetSwitchTable().size(); ++i) {
+        LabelIdx caseLabel = switchStmt.GetSwitchTable().at(i).second;
+        if (caseLabel == oldLabelIdx) {
+          switchStmt.UpdateCaseLabelAt(i, label);
+        }
+      }
+    }
+  }
+}
+
+// BBId is index of BB in the bbVec, so we should swap two BB's pos in bbVec, if we want to swap their BBId.
+void MeCFG::SwapBBId(BB &bb1, BB &bb2) {
+  bbVec[bb1.GetBBId()] = &bb2;
+  bbVec[bb2.GetBBId()] = &bb1;
+  BBId tmp = bb1.GetBBId();
+  bb1.SetBBId(bb2.GetBBId());
+  bb2.SetBBId(tmp);
+}
+
+// set bb succ frequency from bb freq
+// no critical edge is expected
+void MeCFG::ConstructEdgeFreqFromBBFreq() {
+  // set succfreqs
+  auto eIt = valid_end();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    if (!bb) {
+      continue;
+    }
+    if (bb->GetSucc().size() == 1) {
+      bb->PushBackSuccFreq(bb->GetFrequency());
+    } else if (bb->GetSucc().size() == 2) {
+      auto *fallthru = bb->GetSucc(0);
+      auto *targetBB = bb->GetSucc(1);
+      if (fallthru->GetPred().size() == 1) {
+        auto succ0Freq = fallthru->GetFrequency();
+        bb->PushBackSuccFreq(succ0Freq);
+        ASSERT(bb->GetFrequency() >= succ0Freq, "sanity check");
+        bb->PushBackSuccFreq(bb->GetFrequency() - succ0Freq);
+      } else if (targetBB->GetPred().size() == 1) {
+        auto succ1Freq = targetBB->GetFrequency();
+        ASSERT(bb->GetFrequency() >= succ1Freq, "sanity check");
+        bb->PushBackSuccFreq(bb->GetFrequency() - succ1Freq);
+        bb->PushBackSuccFreq(succ1Freq);
+      } else {
+        CHECK_FATAL(false, "ConstructEdgeFreqFromBBFreq::NYI critical edge");
+      }
+    } else if (bb->GetSucc().size() > 2) {
+      // switch case, no critical edge is supposted
+      for (size_t i = 0; i < bb->GetSucc().size(); ++i) {
+        bb->PushBackSuccFreq(bb->GetSucc(i)->GetFrequency());
+      }
+    }
+  }
+}
+
+// set bb frequency from stmt record
+void MeCFG::ConstructBBFreqFromStmtFreq() {
+  FuncProfInfo *funcData = func.GetMirFunc()->GetFuncProfData();
+  if (!funcData) {
+    return;
+  }
+  if (funcData->stmtFreqs.empty()) {
+    return;
+  }
+  auto eIt = valid_end();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    if ((*bIt)->IsEmpty()) continue;
+    StmtNode &first = (*bIt)->GetFirst();
+    if (funcData->stmtFreqs.count(first.GetStmtID()) > 0) {
+      (*bIt)->SetFrequency(funcData->stmtFreqs[first.GetStmtID()]);
+    } else if (funcData->stmtFreqs.count((*bIt)->GetLast().GetStmtID()) > 0) {
+      (*bIt)->SetFrequency(funcData->stmtFreqs[(*bIt)->GetLast().GetStmtID()]);
+    } else {
+      LogInfo::MapleLogger() << "ERROR::  bb " << (*bIt)->GetBBId() << "frequency is not set"
+                             << "\n";
+      ASSERT(0, "no freq set");
+    }
+  }
+  // add common entry and common exit
+  auto *bb = *common_entry();
+  uint64_t freq = 0;
+  for (size_t i = 0; i < bb->GetSucc().size(); ++i) {
+    freq += bb->GetSucc(i)->GetFrequency();
+  }
+  bb->SetFrequency(freq);
+  bb = *common_exit();
+  freq = 0;
+  for (size_t i = 0; i < bb->GetPred().size(); ++i) {
+    freq += bb->GetPred(i)->GetFrequency();
+  }
+  bb->SetFrequency(freq);
+  // set succfreqs
+  ConstructEdgeFreqFromBBFreq();
+  // clear stmtFreqs since cfg frequency is create
+  funcData->stmtFreqs.clear();
+
+  // set updateFrequency with true
+  updateFreq = true;
+}
+
+void MeCFG::ConstructStmtFreq() {
+  FuncProfInfo *funcData = func.GetMirFunc()->GetFuncProfData();
+  if (!funcData) {
+    return;
+  }
+  auto eIt = valid_end();
+  // clear stmtFreqs
+  funcData->stmtFreqs.clear();
+  for (auto bIt = valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    if (bIt == common_entry()) {
+      funcData->entryFreq = bb->GetFrequency();
+      funcData->realEntryfreq = funcData->entryFreq;
+    }
+    for (auto &stmt : bb->GetStmtNodes()) {
+      Opcode op = stmt.GetOpCode();
+      // record bb start/end stmt
+      if (stmt.GetStmtID() == bb->GetFirst().GetStmtID() || stmt.GetStmtID() == bb->GetLast().GetStmtID() ||
+          IsCallAssigned(op) || op == OP_call) {
+        funcData->stmtFreqs[stmt.GetStmtID()] = bb->GetFrequency();
+      }
+    }
+  }
+}
+
+// bb frequency may be changed in transform phase,
+// update edgeFreq with new BB frequency by scale
+void MeCFG::UpdateEdgeFreqWithBBFreq() {
+  BuildSCC();
+  for (size_t i = 0; i < GetSccTopologicalVec().size(); ++i) {
+    SCCOfBBs *scc = GetSccTopologicalVec()[i];
+    CHECK_FATAL(scc != nullptr, "scc must not be null");
+    if (scc->GetBBs().size() > 1) {
+      BBTopologicalSort(*scc);
+    }
+    const uint32 maxLoopCount = 2;
+    unsigned loopCount = scc->GetBBs().size() > 1 ? maxLoopCount : 1;
+    for (unsigned j = 0; j < loopCount; ++j) {
+      for (BB *bb : scc->GetBBs()) {
+        if (bb == nullptr) {
+          continue;
+        }
+        // collect pred total except entry
+        if (!bb->GetAttributes(kBBAttrIsEntry)) {
+          int64_t inputFreq = 0;
+          for (auto *pred : bb->GetPred()) {
+            int idx = pred->GetSuccIndex(*bb);
+            ASSERT(idx >= 0 && idx < pred->GetSuccFreq().size(), "sanity check");
+            inputFreq += static_cast<int64_t>(pred->GetSuccFreq()[static_cast<uint32>(idx)]);
+          }
+          bb->SetFrequency(static_cast<uint32>(inputFreq));
+        }
+        // make bb frequency and succs frequency consistent
+        bb->UpdateEdgeFreqs(false);
+      }
+    }
+  }
+}
+
+void MeCFG::ClearFuncFreqInfo() {
+  SetUpdateCFGFreq(false);
+  func.GetMirFunc()->SetFuncProfData(nullptr);
+  auto &bbVecLoc = GetAllBBs();
+  for (size_t i = 0; i < bbVecLoc.size(); ++i) {  // skip common entry and common exit
+    auto *bb = bbVecLoc[i];
+    if (bb == nullptr) {
+      continue;
+    }
+    bb->SetFrequency(0);
+    bb->GetSuccFreq().clear();
+  }
+}
+
+// return value is 0 means pass verification, else has problem
+int MeCFG::VerifyBBFreq(bool checkFatal) {
+  int64_t entryFreq = static_cast<int64_t>(func.GetMirFunc()->GetFuncProfData()->GetFuncFrequency());
+  ASSERT(entryFreq >= 0, "sanity check");
+  bool entryIsZero = entryFreq == 0 ? true : false;
+  for (size_t i = 2; i < bbVec.size(); ++i) {  // skip common entry and common exit
+    auto *bb = bbVec[i];
+    if (bb == nullptr || bb->GetAttributes(kBBAttrIsEntry) || bb->GetAttributes(kBBAttrIsExit)) {
+      continue;
+    }
+    // check case 1: entry count is zero, internal bb has frequency value > 0
+    if (entryIsZero && bb->GetFrequency() > 0) {
+      LogInfo::MapleLogger() << func.GetName() << ": entry freq is 0 but freq of BB " << bb->GetBBId()
+          << " is " << bb->GetFrequency() << std::endl;
+      if (checkFatal) {
+        CHECK_FATAL(false, "VerifyBBFreq: verification fails");
+      } else {
+        return 1;
+      }
+    }
+    // check case 2: bb succ frequence numbers should be equal to succ number except wontexit bb
+    // may has wrong succ, skip it
+    if (bb->GetSuccFreq().size() != bb->GetSucc().size() && !bb->GetAttributes(kBBAttrWontExit)) {
+      if (checkFatal) {
+        LogInfo::MapleLogger() << func.GetName() << "wrong BB " << bb->GetBBId() << std::endl;
+        CHECK_FATAL(false, "VerifyBBFreq: succFreq size != succ size");
+      } else {
+        ClearFuncFreqInfo();
+        return 1;
+      }
+    }
+    // check case 3: bb freq == sum(out edge freq)
+    uint64 succSumFreq = 0;
+    for (auto succFreq : bb->GetSuccFreq()) {
+      succSumFreq += succFreq;
+    }
+    if (succSumFreq == bb->GetFrequency()) {
+      continue;
+    }
+    int64 diff = static_cast<int64>(succSumFreq - bb->GetFrequency());
+    diff = diff >= 0 ? diff : -diff;
+    if (diff > 1) {
+      if (checkFatal) {
+        LogInfo::MapleLogger() << func.GetName() << "wrong BB " << bb->GetBBId() << std::endl;
+        LogInfo::MapleLogger() << " freq: " << bb->GetFrequency() << ", all succ edge freq sum: " << succSumFreq
+                               << std::endl;
+        CHECK_FATAL(false, "VerifyFreq failure: bb freq != succ freq sum");
+      } else {
+        ClearFuncFreqInfo();
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+bool MEMeCfg::PhaseRun(MeFunction &f) {
+  if (!f.IsPme() && f.GetPreMeFunc() != nullptr) {
+    GetAnalysisInfoHook()->ForceEraseAllAnalysisPhase();
+    f.SetMeSSATab(nullptr);
+    f.SetIRMap(nullptr);
+
+    MIRLower mirlowerer(f.GetMIRModule(), f.GetMirFunc());
+    mirlowerer.SetLowerME();
+    mirlowerer.SetLowerExpandArray();
+    mirlowerer.LowerFunc(*f.GetMirFunc());
+  }
+
+  MemPool *meCfgMp = GetPhaseMemPool();
+  theCFG = meCfgMp->New<MeCFG>(meCfgMp, f);
+  f.SetTheCfg(theCFG);
+  theCFG->CreateBasicBlocks();
+  if (theCFG->NumBBs() == 0) {
+    /* there's no basicblock generated */
+    return theCFG;
+  }
+  theCFG->BuildMirCFG();
+  if (MeOption::optLevel > kLevelZero) {
+    theCFG->FixMirCFG();
+  }
+  theCFG->ReplaceWithAssertnonnull();
+  theCFG->VerifyLabels();
+  (void)theCFG->UnreachCodeAnalysis();
+  theCFG->WontExitAnalysis();
+  if (!f.GetMIRModule().IsJavaModule() && MeOption::unifyRets) {
+    theCFG->UnifyRetBBs();
+  }
+  theCFG->Verify();
+  // construct bb freq from stmt freq
+  if (Options::profileUse && f.GetMirFunc()->GetFuncProfData()) {
+    theCFG->ConstructBBFreqFromStmtFreq();
+    if (theCFG->DumpIRProfileFile()) {
+      std::string fileName = "after-mecfgbuild";
+      if (f.IsPme()) {
+        static_cast<void>(fileName.append("-lfo"));
+      } else {
+        static_cast<void>(fileName.append("-mplme"));
+      }
+      theCFG->DumpToFile(fileName, false, true);
+    }
+  }
+  return false;
+}
+
+bool MECfgVerifyFrequency::PhaseRun(MeFunction &f) {
+  // if transform pass is not fully support, set disableFreqInfo to true
+  // function profile information will be deleted after verification phase
+  if (f.GetCfg()->UpdateCFGFreq()) {
+    static_cast<void>(f.GetCfg()->VerifyBBFreq());
+  }
+#ifdef disableFreqInfo
+  // clear function profile information
+  f.GetCfg()->ClearFuncFreqInfo();
+#endif
+  return false;
+}
+
+void GdbDumpToFile(const MeCFG &cfg, bool dumpEdgeFreq) {
+  std::string fileName = "cfgfromgdb";
+  cfg.DumpToFile(fileName, false, dumpEdgeFreq, nullptr);
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_cfg_opt.cpp b/src/mapleall/maple_me/src/me_cfg_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5040d858303cf225ceada08581d9efa5774ac4b1
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_cfg_opt.cpp
@@ -0,0 +1,451 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "me_cfg_opt.h"
+#include "me_bb_layout.h"
+#include "me_irmap_build.h"
+
+// We find the following pattern in JAVA code:
+// Examples: if (empty) { a = 1; } else { a = 3; }
+//
+// It will generate the following IR in mpl file:
+// brfalse @label1 (dread u1 %Reg4_Z)
+// dassign %Reg1_I 0 (cvt i32 i8 (constval i8 1))
+// goto @label2
+// @label1   dassign %Reg1_I 0 (cvt i32 i8 (constval i8 3))
+//
+// The mecfgopt phase overwrite the upper pattern with following code:
+// regassign i32 %26 (select i32 (
+//    select u1 (
+//      ne u1 i32 (regread i32 %1, constval i32 0),
+//      constval u1 0,
+//      constval u1 1),
+//    constval i32 1,
+//    constval i32 3))
+namespace maple {
+bool MeCfgOpt::IsExpensiveOp(Opcode op) {
+  switch (op) {
+    case OP_abs:
+    case OP_bnot:
+    case OP_lnot:
+    case OP_sqrt:
+    case OP_neg:
+      return false;
+    case OP_recip:
+    case OP_div:
+    case OP_rem:
+    case OP_alloca:
+    case OP_malloc:
+    case OP_gcmalloc:
+    case OP_gcmallocjarray:
+      return true;
+    case OP_ceil:
+    case OP_cvt:
+    case OP_floor:
+    case OP_retype:
+    case OP_round:
+    case OP_trunc:
+      return false;
+    case OP_sext:
+    case OP_zext:
+    case OP_extractbits:
+      return false;
+    case OP_iaddrof:
+    case OP_iread:
+      return true;
+    case OP_ireadoff:
+      return true;
+    case OP_ireadfpoff:
+      return true;
+    case OP_add:
+    case OP_ashr:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_cand:
+    case OP_cior:
+    case OP_land:
+    case OP_lior:
+    case OP_lshr:
+    case OP_max:
+    case OP_min:
+    case OP_mul:
+    case OP_shl:
+    case OP_sub:
+      return false;
+    case OP_CG_array_elem_add:
+      return true;
+    case OP_eq:
+    case OP_ne:
+    case OP_ge:
+    case OP_gt:
+    case OP_le:
+    case OP_lt:
+    case OP_cmp:
+    case OP_cmpl:
+    case OP_cmpg:
+      return false;
+    case OP_depositbits:
+      return true;
+    case OP_select:
+      return false;
+    case OP_intrinsicop:
+    case OP_intrinsicopwithtype:
+      return true;
+    case OP_constval:
+    case OP_conststr:
+    case OP_conststr16:
+      return false;
+    case OP_sizeoftype:
+    case OP_fieldsdist:
+      return false;
+    case OP_array:
+      return true;
+    case OP_addrof:
+    case OP_dread:
+    case OP_regread:
+    case OP_addroffunc:
+    case OP_addroflabel:
+      return false;
+    // statement nodes start here
+    default:
+      CHECK_FATAL(false, "should be an expression or NYI");
+  }
+}
+
+MeStmt *MeCfgOpt::GetCondBrStmtFromBB(BB &bb) const {
+  CHECK_FATAL(bb.GetKind() == kBBCondGoto, "must be cond goto");
+  MeStmt *meStmt = to_ptr(bb.GetMeStmts().rbegin());
+  if (meStmt->IsCondBr()) {
+    return meStmt;
+  }
+  CHECK_FATAL(meStmt->GetOp() == OP_comment, "NYI");
+  return nullptr;
+}
+
+// if the bb contains only one stmt other than comment, return that stmt
+// otherwise return nullptr
+MeStmt *MeCfgOpt::GetTheOnlyMeStmtFromBB(BB &bb) const {
+  MeStmt *noCommentStmt = nullptr;
+  for (auto &meStmt : bb.GetMeStmts()) {
+    if (meStmt.GetOp() == OP_comment) {
+      continue;
+    }
+    if (noCommentStmt != nullptr) {
+      return nullptr;
+    }
+    noCommentStmt = &meStmt;
+  }
+  return noCommentStmt;
+}
+
+// if the bb contains only one stmt other than comment and goto, return that stmt
+// otherwise return nullptr
+MeStmt *MeCfgOpt::GetTheOnlyMeStmtWithGotoFromBB(BB &bb) const {
+  constexpr uint32 stmtCount = 2;
+  MeStmt *arrayStmt[stmtCount];
+  uint32 index = 0;
+  for (auto &meStmt : bb.GetMeStmts()) {
+    if (meStmt.GetOp() == OP_comment) {
+      continue;
+    }
+    if (index >= stmtCount) {
+      return nullptr;
+    }
+    arrayStmt[index++] = &meStmt;
+  }
+  if (index == stmtCount && arrayStmt[0]->GetOp() != OP_comment && arrayStmt[1]->GetOp() == OP_goto) {
+    return arrayStmt[0];
+  }
+  return nullptr;
+}
+
+bool MeCfgOpt::IsOk2Select(const MeExpr &expr0, const MeExpr &expr1) const {
+  if (expr0.GetExprID() == expr1.GetExprID()) {
+    return true;
+  }
+  std::set<int32> expensiveOps1;
+  std::set<int32> expensiveOps2;
+  if (CollectExpensiveOps(expr0, expensiveOps1)) {
+    return false;
+  }
+  if (CollectExpensiveOps(expr1, expensiveOps2)) {
+    return false;
+  }
+  if (expensiveOps1.size() != expensiveOps2.size()) {
+    return false;
+  }
+  for (auto it = expensiveOps1.begin(); it != expensiveOps1.end(); ++it) {
+    int32 expr1Id = *it;
+    if (expensiveOps2.find(expr1Id) == expensiveOps2.end()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MeCfgOpt::HasFloatCmp(const MeExpr &meExpr) const {
+  Opcode op = meExpr.GetOp();
+  if ((op == OP_cmpl || op == OP_cmpg || op == OP_cmp) &&
+      IsPrimitiveFloat(static_cast<const OpMeExpr&>(meExpr).GetOpndType())) {
+    return true;
+  }
+  for (size_t i = 0; i < meExpr.GetNumOpnds(); ++i) {
+    if (HasFloatCmp(*meExpr.GetOpnd(i))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MeCfgOpt::PreCheck(const MeCFG &cfg) const {
+  auto eIt = cfg.valid_end();
+  for (auto bIt = cfg.valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    if (bb->GetAttributes(kBBAttrIsTry) && bb->GetBBLabel() != 0) {
+      for (size_t i = 0; i < bb->GetPred().size(); ++i) {
+        BB *predBB = bb->GetPred(i);
+        if (!predBB->GetAttributes(kBBAttrIsTry)) {
+          // comes from outside of try. give up folding select.
+          return false;
+        }
+      }
+    }
+    for (auto &stmt : bb->GetMeStmts()) {
+      for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+        MeExpr *meExpr = stmt.GetOpnd(i);
+        if (HasFloatCmp(*meExpr)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool MeCfgOpt::Run(MeCFG &cfg) {
+  if (!PreCheck(cfg)) {
+    return false;
+  }
+  bool isCfgChanged = false;
+  auto eIt = cfg.valid_end();
+  for (auto bIt = cfg.valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    constexpr uint32 numOfSuccs = 2;
+    if (bb->GetKind() == kBBCondGoto && bb->GetSucc().size() == numOfSuccs) {
+      MeStmt *condMeStmt = GetCondBrStmtFromBB(*bb);
+      if (condMeStmt == nullptr || !condMeStmt->IsCondBr()) {
+        continue;
+      }
+      BB *bbLeft = bb->GetSucc(0);
+      BB *bbRight = bb->GetSucc(1);
+      if (bbLeft->GetSucc().size() != 1 || bbLeft->GetPred().size() != 1 ||
+          bbRight->GetPred().size() != 1 || bbRight->GetSucc().size() != 1) {
+        continue;
+      }
+      const auto *condGotoMeStmt = static_cast<const CondGotoMeStmt*>(condMeStmt);
+      if (bbLeft->GetBBLabel() && bbLeft->GetBBLabel() == condGotoMeStmt->GetOffset()) {
+        BB *tmpBB = bbLeft;
+        bbLeft = bbRight;
+        bbRight = tmpBB;
+      }
+      if (bbLeft->GetKind() != kBBGoto || bbLeft->GetPred(0)->GetBBId() != bb->GetBBId() ||
+          bbRight->GetKind() != kBBFallthru || bbRight->GetPred(0)->GetBBId() != bb->GetBBId() ||
+          bbLeft->GetSucc(0) != bbRight->GetSucc(0)) {
+        continue;
+      }
+      MeStmt *assStmtLeft = GetTheOnlyMeStmtWithGotoFromBB(*bbLeft);
+      if (!(assStmtLeft != nullptr && (assStmtLeft->GetOp() == OP_iassign || assStmtLeft->GetOp() == OP_dassign))) {
+        continue;
+      }
+      MeStmt *assStmtRight = GetTheOnlyMeStmtFromBB(*bbRight);
+      if (!(assStmtRight != nullptr && (assStmtRight->GetOp() == OP_iassign || assStmtRight->GetOp() == OP_dassign) &&
+            assStmtRight->GetOp() == assStmtLeft->GetOp())) {
+        continue;
+      }
+      bool isTrueBr = (condMeStmt->GetOp() == OP_brtrue);
+      bool isIassign = (assStmtLeft->GetOp() == OP_iassign);
+      MeExpr *selectOpLeft = nullptr;
+      MeExpr *selectOpRight = nullptr;
+      if (isIassign) {
+        auto *iassLeft = static_cast<IassignMeStmt*>(assStmtLeft);
+        auto *iassRight = static_cast<IassignMeStmt*>(assStmtRight);
+        if (iassLeft->GetLHSVal()->GetBase() != iassRight->GetLHSVal()->GetBase() ||
+            iassLeft->GetLHSVal()->GetFieldID() != iassRight->GetLHSVal()->GetFieldID()) {
+          continue;
+        }
+        // patter match
+        selectOpLeft = iassLeft->GetRHS();
+        selectOpRight = iassRight->GetRHS();
+      } else {
+        auto *dassLeft = static_cast<DassignMeStmt*>(assStmtLeft);
+        auto *dassRight = static_cast<DassignMeStmt*>(assStmtRight);
+        if (!dassLeft->GetLHS()->IsUseSameSymbol(*dassRight->GetLHS())) {
+          continue;
+        }
+        selectOpLeft = dassLeft->GetRHS();
+        selectOpRight = dassRight->GetRHS();
+      }
+      if (!IsOk2Select(*selectOpLeft, *selectOpRight) ||
+          (selectOpLeft->GetPrimType() == PTY_ref && MeOption::rcLowering)) {
+        continue;
+      }
+      MeExpr *selectMeExpr = meIrMap->CreateMeExprSelect(
+          selectOpLeft->GetPrimType(), *condGotoMeStmt->GetOpnd(),
+          *(isTrueBr ? selectOpRight : selectOpLeft),
+          *(isTrueBr ? selectOpLeft : selectOpRight));
+      if (isIassign) {
+        // use bb as the new bb and put new iassign there
+        static_cast<IassignMeStmt*>(assStmtLeft)->SetRHS(selectMeExpr);
+      } else {
+        static_cast<DassignMeStmt*>(assStmtLeft)->SetRHS(selectMeExpr);
+      }
+      bb->ReplaceMeStmt(condMeStmt, assStmtLeft);
+      // update the preds and succs
+      bb->RemoveAllSucc();
+      BB *succBB = bbLeft->GetSucc(0);
+      succBB->RemovePred(*bbLeft);
+      if (bbRight->IsPredBB(*succBB)) {
+        succBB->RemovePred(*bbRight);
+      }
+      bb->AddSucc(*succBB);
+      bb->SetKind(kBBFallthru);
+      bb->GetSuccFreq().push_back(bb->GetFrequency());
+      cfg.DeleteBasicBlock(*bbLeft);
+      cfg.DeleteBasicBlock(*bbRight);
+      isCfgChanged = true;
+    }
+  }
+  return isCfgChanged;
+}
+
+bool CheckAnalysisResult(const MeFunction &func) {
+  if (func.GetCfg()->NumBBs() > 0) {
+    return func.HasLaidOut();
+  }
+  return false;
+}
+
+extern void ResetDependentedSymbolLive(MIRFunction *mirFunction);
+
+void EmitMapleIr(MeFunction &func) {
+  CHECK_FATAL(func.HasLaidOut(), "Check bb layout phase.");
+  auto layoutBBs = func.GetLaidOutBBs();
+  CHECK_NULL_FATAL(func.GetIRMap());
+  MIRFunction *mirFunction = func.GetMirFunc();
+
+  mirFunction->ReleaseCodeMemory();
+  mirFunction->SetMemPool(new ThreadLocalMemPool(memPoolCtrler, "IR from IRMap::Emit()"));
+  mirFunction->SetBody(mirFunction->GetCodeMemPool()->New<BlockNode>());
+
+  for (size_t k = 1; k < mirFunction->GetSymTab()->GetSymbolTableSize(); ++k) {
+    MIRSymbol *sym = mirFunction->GetSymTab()->GetSymbolFromStIdx(k);
+    CHECK_FATAL(sym, "sym is nullptr!");
+    if (sym->GetSKind() == kStVar) {
+      sym->SetIsDeleted();
+    }
+  }
+  func.GetIRMap()->SetNeedAnotherPass(true);
+  for (BB *bb : layoutBBs) {
+    ASSERT(bb != nullptr, "bb should not be nullptr");
+    bb->EmitBB(*func.GetMirFunc()->GetBody(), true);
+  }
+  ResetDependentedSymbolLive(mirFunction);
+
+  func.ClearLayout();
+}
+
+bool FindLocalRefVarUses(const MeIRMap &irMap, const MeExpr &expr,
+                         const MeStmt &meStmt, const VarMeExpr &var) {
+  if (expr.GetMeOp() == kMeOpVar) {
+    const auto &varMeExpr = static_cast<const VarMeExpr&>(expr);
+    if (varMeExpr.GetOstIdx() == var.GetOstIdx()) {
+      return true;
+    }
+  }
+  for (size_t i = 0; i < expr.GetNumOpnds(); ++i) {
+    if (FindLocalRefVarUses(irMap, *expr.GetOpnd(i), meStmt, var)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MePostCfgOpt(const MeFunction &func, const MeIRMap &irMap) {
+  // check all basic blocks searching for split case
+  for (BB *bb : func.GetCfg()->GetAllBBs()) {
+    if (bb == nullptr || !(bb->GetAttributes(kBBAttrIsTry))) {
+      continue;
+    }
+    // use and def in the same bb.
+    for (MeStmt *stmt = to_ptr(bb->GetMeStmts().begin()); stmt != nullptr; stmt = stmt->GetNextMeStmt()) {
+      // use and def the same var in one callassign statement
+      if (stmt->GetOp() == OP_dassign) {  // skip identity assignments
+        auto *dass = static_cast<DassignMeStmt*>(stmt);
+        if (dass->GetLHS()->IsUseSameSymbol(*dass->GetRHS())) {
+          continue;
+        }
+      }
+      VarMeExpr *theLHS = nullptr;
+      if (stmt->GetOp() == OP_dassign || kOpcodeInfo.IsCallAssigned(stmt->GetOp())) {
+        theLHS = static_cast<VarMeExpr*>(stmt->GetLHSRef(false));
+      }
+      if (theLHS == nullptr) {
+        continue;
+      }
+      MeStmt *nextStmt = stmt->GetNextMeStmt();
+      for (MeStmt *stmtNew = to_ptr(bb->GetMeStmts().begin()); stmtNew != nullptr && stmtNew != nextStmt;
+           stmtNew = stmtNew->GetNextMeStmt()) {
+        // look for use occurrence of localrefvars
+        for (size_t i = 0; i < stmtNew->NumMeStmtOpnds(); ++i) {
+          ASSERT(stmtNew->GetOpnd(i) != nullptr, "null ptr check");
+          if (FindLocalRefVarUses(irMap, *stmtNew->GetOpnd(i), *stmtNew, *theLHS)) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
+void MECfgOpt::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+}
+
+/* change CFG */
+bool MECfgOpt::PhaseRun(maple::MeFunction &f) {
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  ASSERT_NOT_NULL(irMap);
+  MeCfgOpt cfgOpt(irMap);
+  auto cfgoptFunc = [](MeFunction &func)->void{
+    if (CheckAnalysisResult(func)) {
+      EmitMapleIr(func);
+    }
+    func.SetMeSSATab(nullptr);
+    func.SetIRMap(nullptr);
+  };
+  if (cfgOpt.Run(*f.GetCfg())) {
+    cfgoptFunc(f);
+    return true;
+  }
+
+  if (MePostCfgOpt(f, *irMap)) {
+    cfgoptFunc(f);
+    return true;
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_check_cast.cpp b/src/mapleall/maple_me/src/me_check_cast.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..22cfdacbe196e686ce4386d3a73256b5475fb7c1
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_check_cast.cpp
@@ -0,0 +1,734 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_check_cast.h"
+#include "class_hierarchy_phase.h"
+#include "me_phase_manager.h"
+
+namespace maple {
+MIRStructType *GetClassTypeFromName(const std::string &className);
+
+std::string GetLabel(AnnotationType &aType) {
+  std::string lable;
+  switch (aType.GetKind()) {
+    case kPrimeType:
+    case kGenericType: {
+      lable = aType.GetName();
+      break;
+    }
+    case kGenericDeclare: {
+      GenericDeclare *gDeclare = static_cast<GenericDeclare*>(&aType);
+      lable = "(" + gDeclare->GetBelongToName() + ")" + ": T" + gDeclare->GetName();
+      break;
+    }
+    case kGenericMatch: {
+      lable = "*";
+      break;
+    }
+    case kExtendType: {
+      ExtendGeneric *extendGeneric = static_cast<ExtendGeneric*>(&aType);
+      AnnotationType *contains = extendGeneric->GetContainsGeneric();
+      if (extendGeneric->GetExtendInfo() == kHierarchyExtend) {
+        lable = "(+)" + GetLabel(*contains);
+      } else if (extendGeneric->GetExtendInfo() == kArrayType) {
+        lable = "([)" + GetLabel(*contains);
+      } else {
+        lable = "(-)" + GetLabel(*contains);
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "must be");
+  }
+  return lable;
+}
+
+void CheckCast::DumpGenericNode(GenericNode &node, std::ostream &out) {
+  std::string lable = GetLabel(*node.aType);
+  out << node.aType->GetId() << " [label=\"" << lable << "\"];\n";
+  if (node.next != nullptr) {
+    out << node.aType->GetId() << "->" << node.next->aType->GetId() << ";\n";
+  }
+}
+
+void CheckCast::DumpGenericGraph() {
+  std::filebuf fileBuf;
+  std::string outFile = func->GetName() + "-GenericGraph.dot";
+  std::filebuf *fileBufPtr = fileBuf.open(outFile, std::ios::trunc | std::ios::out);
+  CHECK_FATAL(fileBufPtr, "open file : %s failed!", outFile.c_str());
+  std::ostream dotFile(&fileBuf);
+  dotFile << "digraph InequalityGraph {\n";
+  for (auto pair : created) {
+    GenericNode *node = pair.second;
+    DumpGenericNode(*node, dotFile);
+  }
+  dotFile << "}\n";
+  fileBufPtr = fileBuf.close();
+  CHECK_FATAL(fileBufPtr, "close file : %s failed", outFile.c_str());
+}
+
+GenericNode *CheckCast::GetOrCreateGenericNode(AnnotationType *annoType) {
+  if (created.find(annoType) != created.end()) {
+    return created[annoType];
+  }
+  GenericNode *newNode = graphTempMem->New<GenericNode>();
+  newNode->aType = annoType;
+  created[annoType] = newNode;
+  return newNode;
+}
+
+void CheckCast::AddNextNode(GenericNode &from, GenericNode &to) const {
+  if (from.multiOutput ||
+      (from.next != nullptr && from.next != &to && from.next->aType->GetKind() != kGenericDeclare)) {
+    from.multiOutput = true;
+    from.next = nullptr;
+    return;
+  }
+  from.next = &to;
+}
+
+void CheckCast::BuildGenericGraph(AnnotationType *annoType) {
+  if (annoType == nullptr) {
+    return;
+  }
+  switch (annoType->GetKind()) {
+    case kGenericType: {
+      GenericType *gType = static_cast<GenericType*>(annoType);
+      for (auto pair : gType->GetGenericMap()) {
+        GenericDeclare *gDeclare = pair.first;
+        AnnotationType *realType = pair.second;
+        GenericNode *gDeclareNode = GetOrCreateGenericNode(gDeclare);
+        GenericNode *realTypeNode = GetOrCreateGenericNode(realType);
+        AddNextNode(*gDeclareNode, *realTypeNode);
+        BuildGenericGraph(realType);
+      }
+      break;
+    }
+    case kExtendType: {
+      ExtendGeneric *extendGeneric = static_cast<ExtendGeneric*>(annoType);
+      if (extendGeneric->GetExtendInfo() == kHierarchyExtend) {
+        GenericNode *gExtendNode = GetOrCreateGenericNode(annoType);
+        GenericNode *containsNode = GetOrCreateGenericNode(extendGeneric->GetContainsGeneric());
+        AddNextNode(*gExtendNode, *containsNode);
+        BuildGenericGraph(extendGeneric->GetContainsGeneric());
+      }
+      break;
+    }
+    case kGenericDeclare:
+    case kGenericMatch:
+    case kPrimeType:
+      break;
+    default:
+      CHECK_FATAL(false, "must be");
+  }
+}
+
+void CheckCast::TryToResolveFuncArg(MeExpr &expr, AnnotationType &at) {
+  MIRType *mirType = nullptr;
+  if (at.GetKind() == kGenericDeclare) {
+    if (expr.GetMeOp() == kMeOpVar) {
+      VarMeExpr *var = static_cast<VarMeExpr*>(&expr);
+      const OriginalSt *symOst = func->GetIRMap()->GetSSATab().GetOriginalStFromID(var->GetOstIdx());
+      CHECK_FATAL(symOst, "symOst is nullptr!");
+      const MIRSymbol *sym = symOst->GetMIRSymbol();
+      CHECK_FATAL(sym, "sym is nullptr!");
+      mirType = sym->GetType();
+    } else if (expr.GetMeOp() == kMeOpIvar) {
+      IvarMeExpr *ivar = static_cast<IvarMeExpr*>(&expr);
+      mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar->GetTyIdx());
+      if (mirType->GetKind() == kTypePointer) {
+        mirType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+      }
+      CHECK_FATAL(mirType->IsStructType(), "must be");
+      mirType = static_cast<MIRStructType*>(mirType)->GetFieldType(ivar->GetFieldID());
+    } else {
+      return;
+    }
+    if (mirType->GetKind() == kTypePointer) {
+      mirType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+    }
+    GenericType *realType = graphTempMem->New<GenericType>(mirType->GetNameStrIdx(),
+                                                           mirType, graphTempAllocator);
+    GenericNode *realNode = GetOrCreateGenericNode(realType);
+    GenericNode *declareNode = GetOrCreateGenericNode(&at);
+    AddNextNode(*declareNode, *realNode);
+  } else if (at.GetKind() == kGenericType && expr.GetMeOp() == kMeOpVar) {
+    VarMeExpr *var = static_cast<VarMeExpr*>(&expr);
+    if (var->GetDefBy() != kDefByStmt) {
+      return;
+    }
+    GenericType *gt = static_cast<GenericType*>(&at);
+    MeStmt *defStmt = var->GetDefStmt();
+    if (!(defStmt->GetOp() == OP_dassign && defStmt->GetRHS()->GetMeOp() == kMeOpNary)) {
+      return;
+    }
+    NaryMeExpr *naryExpr = static_cast<NaryMeExpr*>(defStmt->GetRHS());
+    if (naryExpr->GetIntrinsic() == INTRN_JAVA_CONST_CLASS) {
+      mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(naryExpr->GetTyIdx());
+      if (mirType->GetKind() == kTypePointer) {
+        mirType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+      }
+      MapleMap<GenericDeclare*, AnnotationType*> &gtMap = gt->GetGenericMap();
+      CHECK_FATAL(gtMap.size() == 1, "must be");
+      AnnotationType *gd = gtMap.begin()->second;
+      if (gd->GetKind() != kGenericDeclare) {
+        return;
+      }
+      GenericType *realType = graphTempMem->New<GenericType>(mirType->GetNameStrIdx(), mirType,
+                                                             graphTempAllocator);
+      GenericNode *realNode = GetOrCreateGenericNode(realType);
+      GenericNode *declareNode = GetOrCreateGenericNode(gd);
+      AddNextNode(*declareNode, *realNode);
+    }
+  } else if (at.GetKind() == kExtendType && expr.GetMeOp() == kMeOpVar) {
+    ExtendGeneric *extendG = static_cast<ExtendGeneric*>(&at);
+    CHECK_FATAL(extendG->GetExtendInfo() == kArrayType, "must be");
+    if (extendG->GetContainsGeneric()->GetKind() != kGenericDeclare) {
+      return;
+    }
+    VarMeExpr *var = static_cast<VarMeExpr*>(&expr);
+    const OriginalSt *symOst = func->GetIRMap()->GetSSATab().GetOriginalStFromID(var->GetOstIdx());
+    ASSERT_NOT_NULL(symOst);
+    const MIRSymbol *sym = symOst->GetMIRSymbol();
+    mirType = sym->GetType();
+    if (mirType->GetKind() == kTypePointer) {
+      mirType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+    }
+    if (!mirType->IsMIRJarrayType()) {
+      return;
+    }
+    GenericType *realType = graphTempMem->New<GenericType>(mirType->GetNameStrIdx(), mirType,
+                                                           graphTempAllocator);
+    GenericNode *realNode = GetOrCreateGenericNode(realType);
+    GenericNode *declareNode = GetOrCreateGenericNode(extendG);
+    AddNextNode(*declareNode, *realNode);
+    mirType = static_cast<MIRJarrayType*>(mirType)->GetElemType();
+    if (mirType->GetKind() == kTypePointer) {
+      mirType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+    }
+    GenericType *subRealType = graphTempMem->New<GenericType>(mirType->GetNameStrIdx(), mirType,
+                                                              graphTempAllocator);
+    GenericNode *subRealNode = GetOrCreateGenericNode(subRealType);
+    GenericNode *subDeclareNode = GetOrCreateGenericNode(extendG->GetContainsGeneric());
+    AddNextNode(*subDeclareNode, *subRealNode);
+  }
+}
+
+void CheckCast::TryToResolveFuncGeneric(MIRFunction &callee, const CallMeStmt &callMeStmt, size_t thisIdx) {
+  size_t argStartPos = thisIdx;
+  if (!callee.IsStatic()) {
+    argStartPos += 1;
+  }
+  MapleVector<AnnotationType*> &argVec = callee.GetFuncGenericArg();
+  CHECK_FATAL(callMeStmt.NumMeStmtOpnds() == argVec.size() + argStartPos, "must be");
+  for (size_t i = 0; i < argVec.size(); ++i) {
+    AnnotationType *at = argVec[i];
+    MeExpr *expr = callMeStmt.GetOpnd(i + argStartPos);
+    TryToResolveFuncArg(*expr, *at);
+  }
+}
+
+void CheckCast::TryToResolveCall(MeStmt &meStmt) {
+  CallMeStmt &callMeStmt = static_cast<CallMeStmt&>(meStmt);
+  MIRFunction &callee = callMeStmt.GetTargetFunction();
+  size_t thisIdx = 0;
+  if (callMeStmt.GetOp() == OP_interfaceicallassigned || callMeStmt.GetOp() == OP_virtualicallassigned) {
+    CHECK_FATAL(callee.GetParamSize() + 1 == callMeStmt.GetOpnds().size(), "must be");
+    thisIdx = 1;
+  } else if (callMeStmt.GetOp() == OP_callassigned) {
+    thisIdx = 0;
+  } else {
+    CHECK_FATAL(false, "must be");
+  }
+  if (!callee.GetFuncGenericDeclare().empty()) {
+    TryToResolveFuncGeneric(callee, callMeStmt, thisIdx);
+  }
+  if (callee.GetClassTyIdx() == 0 || callee.IsStatic()) {
+    return;
+  }
+  MIRStructType *structType = static_cast<MIRStructType*>(
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(callee.GetClassTyIdx()));
+  if (structType->GetGenericDeclare().empty()) {
+    return;
+  }
+  switch (callMeStmt.GetOpnd(thisIdx)->GetMeOp()) {
+    case kMeOpVar: {
+      (void)TryToResolveVar(*static_cast<VarMeExpr*>(callMeStmt.GetOpnd(thisIdx)), structType);
+      break;
+    }
+    case kMeOpIvar: {
+      TryToResolveIvar(*static_cast<IvarMeExpr*>(callMeStmt.GetOpnd(thisIdx)), structType);
+      break;
+    }
+    default:
+      break;
+  }
+  BuildGenericGraph(callee.GetFuncGenericRet());
+  return;
+}
+
+void CheckCast::TryToResolveIvar(IvarMeExpr &ivar, MIRStructType *callStruct) {
+  if (ivar.GetBase()->GetMeOp() == kMeOpIvar) {
+    TryToResolveIvar(*static_cast<IvarMeExpr*>(ivar.GetBase()));
+  } else if (ivar.GetBase()->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx());
+  if (type->GetKind() == kTypePointer) {
+    type = static_cast<MIRPtrType*>(type)->GetPointedType();
+  }
+  if (!type->IsStructType()) {
+    return;
+  }
+  MIRStructType *structType = static_cast<MIRStructType*>(type);
+  GStrIdx gStrIdx = structType->GetFieldGStrIdx(ivar.GetFieldID());
+  MIRType *ivarType = structType->GetFieldType(ivar.GetFieldID());
+  if (ivarType->GetKind() == kTypePointer) {
+    ivarType = static_cast<MIRPtrType*>(ivarType)->GetPointedType();
+  }
+  CHECK_FATAL(ivarType->IsStructType(), "must be");
+  AnnotationType *annotationType = nullptr;
+  MIRStructType *tmpStructType = structType;
+  do {
+    annotationType = tmpStructType->GetFieldGenericDeclare(gStrIdx);
+    Klass *super = klassh->GetKlassFromTyIdx(tmpStructType->GetTypeIndex())->GetSuperKlass();
+    if (super != nullptr) {
+      tmpStructType = super->GetMIRStructType();
+    } else {
+      tmpStructType = nullptr;
+    }
+  } while (annotationType == nullptr && tmpStructType != nullptr);
+
+  if (NeedChangeVarType(static_cast<MIRStructType*>(ivarType), callStruct)) {
+    ivarType = callStruct;
+    annotationType = CloneNewAnnotationType(annotationType, callStruct);
+  }
+  AddClassInheritanceInfo(*ivarType);
+  if (annotationType == nullptr) {
+    return;
+  }
+  if (annotationType->GetKind() == kGenericType) {
+    BuildGenericGraph(annotationType);
+    return;
+  }
+}
+
+bool CheckCast::TryToResolveStaticVar(const VarMeExpr &var) {
+  const OriginalSt *symOst = func->GetIRMap()->GetSSATab().GetOriginalStFromID(var.GetOstIdx());
+  CHECK_FATAL(symOst, "ost is nullptr!");
+  const MIRSymbol *sym = symOst->GetMIRSymbol();
+  if (!sym->IsStatic()) {
+    return false;
+  }
+  std::string varTotalName = sym->GetName();
+  size_t posOfClass = varTotalName.find("_7C");
+  std::string className = varTotalName.substr(0, posOfClass);
+  std::string varName = varTotalName.substr(posOfClass + strlen(namemangler::kNameSplitterStr));
+  MIRStructType *structType = GetClassTypeFromName(className);
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(varName);
+  AnnotationType *aType = structType->GetFieldGenericDeclare(gStrIdx);
+  if (aType == nullptr) {
+    return true;
+  }
+  if (aType->GetKind() == kGenericType) {
+    BuildGenericGraph(aType);
+  } else {
+    CHECK_FATAL(false, "must be");
+  }
+  return true;
+}
+
+void CheckCast::TryToResolveDassign(MeStmt &meStmt) {
+  CHECK_FATAL(meStmt.GetOp() == OP_dassign, "must be");
+  DassignMeStmt &dassignMeStmt = static_cast<DassignMeStmt&>(meStmt);
+  if (dassignMeStmt.GetRHS()->GetMeOp() == kMeOpIvar) {
+    IvarMeExpr *ivar = static_cast<IvarMeExpr*>(dassignMeStmt.GetRHS());
+    TryToResolveIvar(*ivar);
+  } else if (dassignMeStmt.GetRHS()->GetMeOp() == kMeOpVar) {
+    bool tmpResult = TryToResolveStaticVar(*static_cast<VarMeExpr*>(dassignMeStmt.GetRHS()));
+    if (!tmpResult) {
+      (void)TryToResolveVar(static_cast<VarMeExpr&>(*dassignMeStmt.GetRHS()));
+    }
+  }
+}
+
+MIRType *CheckCast::TryToResolveType(GenericNode &retNode) {
+  (void)visited.insert(&retNode);
+  if (retNode.next == nullptr || visited.find(retNode.next) != visited.end()) {
+    AnnotationType *at = retNode.aType;
+    if (at->GetKind() == kGenericType) {
+      return static_cast<GenericType*>(at)->GetMIRType();
+    } else if (at->GetKind() == kGenericDeclare) {
+      AnnotationType *defaultType = static_cast<GenericDeclare*>(at)->GetDefaultType();
+      while (defaultType->GetKind() == kGenericDeclare) {
+        defaultType = static_cast<GenericDeclare*>(defaultType)->GetDefaultType();
+      }
+      if (defaultType->GetKind() == kGenericType) {
+        return static_cast<GenericType*>(defaultType)->GetMIRStructType();
+      }
+      CHECK_FATAL(false, "must be");
+    } else {
+      return nullptr;
+    }
+  }
+  return TryToResolveType(*retNode.next);
+}
+
+void CheckCast::AddClassInheritanceInfo(MIRType &mirType) {
+  if (mirType.GetKind() == kTypePointer) {
+    mirType = *static_cast<MIRPtrType&>(mirType).GetPointedType();
+  }
+  if (!mirType.IsStructType()) {
+    return;
+  }
+  MIRStructType *structType = static_cast<MIRStructType*>(&mirType);
+  for (GenericType *gt : structType->GetInheritanceGeneric()) {
+    BuildGenericGraph(gt);
+    AddClassInheritanceInfo(*gt->GetMIRStructType());
+  }
+}
+
+// varStruct is parent, callStruct is child
+bool CheckCast::ExactlyMatch(MIRStructType &varStruct, MIRStructType &callStruct) {
+  if (varStruct.GetGenericDeclare().size() == 0 || callStruct.GetGenericDeclare().size() == 0) {
+    return false;
+  }
+  if (varStruct.GetGenericDeclare().size() != callStruct.GetGenericDeclare().size()) {
+    return false;
+  }
+  GenericType *gTmp = nullptr;
+  for (GenericType *gt : callStruct.GetInheritanceGeneric()) {
+    if (gt->GetMIRStructType() == &varStruct) {
+      gTmp = gt;
+      break;
+    }
+  }
+  if (gTmp == nullptr) {
+    return false;
+  }
+
+  for (size_t i = 0; i < gTmp->GetGenericArg().size(); ++i) {
+    if (gTmp->GetGenericArg()[i] != callStruct.GetGenericDeclare()[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool CheckCast::NeedChangeVarType(MIRStructType *varStruct, MIRStructType *callStruct) {
+  if (callStruct == nullptr) {
+    return false;
+  }
+  if (varStruct == callStruct) {
+    return false;
+  }
+  Klass *varKlass = klassh->GetKlassFromTyIdx(varStruct->GetTypeIndex());
+  Klass *callKlass = klassh->GetKlassFromTyIdx(callStruct->GetTypeIndex());
+  if (klassh->IsSuperKlass(varKlass, callKlass) ||
+      klassh->IsSuperKlassForInterface(varKlass, callKlass) || klassh->IsInterfaceImplemented(varKlass, callKlass)) {
+    if (ExactlyMatch(*varStruct, *callStruct)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+AnnotationType *CheckCast::CloneNewAnnotationType(AnnotationType *at, MIRStructType *callStruct) {
+  if (at == nullptr || at->GetKind() != kGenericType) {
+    return at;
+  }
+  GenericType *newGT = graphTempMem->New<GenericType>(callStruct->GetNameStrIdx(), callStruct, graphTempAllocator);
+  MapleVector<AnnotationType*> &argVec = static_cast<GenericType*>(at)->GetGenericArg();
+  for (size_t i = 0; i < argVec.size(); i++) {
+    newGT->AddGenericPair(callStruct->GetGenericDeclare()[i], argVec[i]);
+  }
+  return newGT;
+}
+
+bool CheckCast::RetIsGenericRelative(MIRFunction &callee) {
+  if (callee.GetFuncGenericRet() == nullptr) {
+    return false;
+  }
+  AnnotationType *ret = callee.GetFuncGenericRet();
+  if (ret->GetKind() == kGenericDeclare) {
+    return true;
+  }
+  if (ret->GetKind() == kExtendType) {
+    ExtendGeneric *extendRet = static_cast<ExtendGeneric*>(ret);
+    if (extendRet->GetExtendInfo() != kArrayType && extendRet->GetExtendInfo() != kHierarchyExtend) {
+      return false;
+    }
+    if (extendRet->GetContainsGeneric()->GetKind() == kGenericDeclare) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool CheckCast::TryToResolveVar(VarMeExpr &var, MIRStructType *callStruct, bool checkFirst) {
+  const OriginalSt *symOst = func->GetIRMap()->GetSSATab().GetOriginalStFromID(var.GetOstIdx());
+  const MIRSymbol *sym = symOst->GetMIRSymbol();
+  AnnotationType *at = func->GetMirFunc()->GetFuncLocalGenericVar(sym->GetNameStrIdx());
+
+  MIRType *varType = sym->GetType();
+  if (at != nullptr && at->GetKind() == kGenericType) {
+    varType = static_cast<GenericType*>(at)->GetMIRStructType();
+  }
+  if (varType->GetKind() == kTypePointer) {
+    varType = static_cast<MIRPtrType*>(varType)->GetPointedType();
+  }
+  if (varType->IsStructType() && NeedChangeVarType(static_cast<MIRStructType*>(varType), callStruct)) {
+    varType = callStruct;
+    at = CloneNewAnnotationType(at, callStruct);
+  }
+  if (at != nullptr && at->GetKind() == kGenericType) {
+    BuildGenericGraph(at);
+  }
+  AddClassInheritanceInfo(*varType);
+
+  MeDefBy defBy = var.GetDefBy();
+  switch (defBy) {
+    case kDefByStmt: {
+      if (checkFirst) {
+        break;
+      }
+      CHECK_FATAL(var.GetDefStmt()->GetOp() == OP_dassign, "must be");
+      TryToResolveDassign(*var.GetDefStmt());
+      break;
+    }
+    case kDefByPhi:
+      break;
+    case kDefByChi: {
+      if (checkFirst) {
+        break;
+      }
+      (void)TryToResolveStaticVar(var);
+      break;
+    }
+    case kDefByMustDef: {
+      CallMeStmt *callMeStmt = safe_cast<CallMeStmt>(var.GetDefMustDef().GetBase());
+      if (callMeStmt == nullptr) {
+        break;
+      }
+      MIRFunction &callee = callMeStmt->GetTargetFunction();
+      if (checkFirst) {
+        if (!RetIsGenericRelative(callee)) {
+          break;
+        }
+      }
+      TryToResolveCall(*var.GetDefMustDef().GetBase());
+      if (checkFirst) {
+        GenericNode *retNode = GetOrCreateGenericNode(callee.GetFuncGenericRet());
+        MIRType *resultType = TryToResolveType(*retNode);
+        if (curCheckCastType == resultType) {
+          return true;
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+bool CheckCast::ProvedByAnnotationInfo(const IntrinsiccallMeStmt &callNode) {
+  MeExpr *expr = callNode.GetOpnd(0);
+  bool result = false;
+  switch (expr->GetMeOp()) {
+    case kMeOpVar: {
+      VarMeExpr *var = static_cast<VarMeExpr*>(expr);
+      result = TryToResolveVar(*var, nullptr, true);
+      break;
+    }
+    case kMeOpConst:
+      CHECK_FATAL(static_cast<ConstMeExpr*>(expr)->IsZero(), "must be");
+      break;
+    case kMeOpIvar: {
+      break;
+    }
+    default:
+      break;
+  }
+  created.clear();
+  visited.clear();
+  return result;
+}
+
+void CheckCast::RemoveRedundantCheckCast(MeStmt &stmt, BB &bb) {
+  if (stmt.GetOp() == OP_intrinsiccallwithtypeassigned) {
+    auto *callAssign = static_cast<IntrinsiccallMeStmt*>(&stmt);
+    ScalarMeExpr *lhs = callAssign->GetAssignedLHS();
+    AssignMeStmt *newDass = func->GetIRMap()->CreateAssignMeStmt(*lhs, *(callAssign->GetOpnd(0)), bb);
+    newDass->SetSrcPos(stmt.GetSrcPosition());
+    lhs->SetDefByStmt(*newDass);
+    bb.InsertMeStmtBefore(&stmt, newDass);
+  }
+  bb.RemoveMeStmt(&stmt);
+}
+
+ProveRes CheckCast::TraverseBackProve(MeExpr &expr, MIRType &targetType, std::set<MePhiNode*> &visitedPhi) {
+  if (expr.GetMeOp() == kMeOpConst) {
+    CHECK_FATAL(static_cast<ConstMeExpr*>(&expr)->IsZero(), "must be");
+    return ProveRes::kT;
+  }
+  if (expr.GetMeOp() == kMeOpIvar && !static_cast<IvarMeExpr&>(expr).HasMultipleMu()) {
+    return TraverseBackProve(*(static_cast<IvarMeExpr&>(expr).GetUniqueMu()), targetType, visitedPhi);
+  }
+  if (expr.GetMeOp() != kMeOpVar) {
+    return ProveRes::kF;
+  }
+  if (meSSI->GetInferredType(&expr) == &targetType) {
+    return ProveRes::kT;
+  }
+  VarMeExpr *var = static_cast<VarMeExpr*>(&expr);
+  switch (var->GetDefBy()) {
+    case kDefByStmt: {
+      MeStmt *meStmt = var->GetDefStmt();
+      if (meStmt->IsAssign()) {
+        return TraverseBackProve(*(meStmt->GetRHS()), targetType, visitedPhi);
+      }
+      break;
+    }
+    case kDefByPhi: {
+      MePhiNode &phi = var->GetDefPhi();
+      if (visitedPhi.find(&phi) == visitedPhi.end()) {
+        return ProveRes::kIgnore;
+      }
+      visitedPhi.insert(&phi);
+      ProveRes res = ProveRes::kF;
+      for (auto *scalar : phi.GetOpnds()) {
+        ProveRes tmp = TraverseBackProve(*scalar, targetType, visitedPhi);
+        if (tmp == ProveRes::kF) {
+          return ProveRes::kF;
+        } else if (tmp == ProveRes::kT) {
+          res = ProveRes::kT;
+        }
+      }
+      return res;
+    }
+    default:
+    break;
+  }
+  return ProveRes::kF;
+}
+
+bool CheckCast::ProvedBySSI(const IntrinsiccallMeStmt &callNode) {
+  std::set<MePhiNode*> visitedPhi;
+  MeExpr *expr = callNode.GetOpnd(0);
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(callNode.GetTyIdx());
+  return TraverseBackProve(*expr, *mirType, visitedPhi) == ProveRes::kT;
+}
+
+void CheckCast::DoCheckCastOpt() {
+  auto cfg = func->GetCfg();
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    MeStmt *nextStmt = nullptr;
+    auto &meStmts = bb->GetMeStmts();
+    MeStmt *stmt = to_ptr(meStmts.begin());
+    for (; stmt != nullptr; stmt = nextStmt) {
+      nextStmt = stmt->GetNext();
+      if (stmt->GetOp() != OP_intrinsiccallwithtypeassigned && stmt->GetOp() != OP_intrinsiccallwithtype) {
+        continue;
+      }
+      auto *callNode = safe_cast<IntrinsiccallMeStmt>(stmt);
+      if (callNode == nullptr || callNode->GetIntrinsic() != INTRN_JAVA_CHECK_CAST) {
+        continue;
+      }
+      MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(callNode->GetTyIdx());
+      if (mirType->GetKind() == kTypePointer) {
+        mirType = static_cast<MIRPtrType*>(mirType)->GetPointedType();
+      }
+      if (!mirType->IsInstanceOfMIRStructType()) {
+        if (!mirType->IsMIRJarrayType()) {
+          continue;
+        }
+        MIRType *tmpType = static_cast<MIRJarrayType*>(mirType)->GetElemType();
+        if (tmpType->GetKind() == kTypePointer) {
+          tmpType = static_cast<MIRPtrType*>(tmpType)->GetPointedType();
+        }
+        if (!tmpType->IsInstanceOfMIRStructType()) {
+          continue;
+        }
+      }
+      curCheckCastType = mirType;
+
+      if (ProvedByAnnotationInfo(*callNode)) {
+        RemoveRedundantCheckCast(*stmt, *bb);
+        continue;
+      }
+    }
+  }
+  ReleaseMemory();
+}
+
+void CheckCast::FindRedundantChecks() {
+  auto cfg = func->GetCfg();
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    MeStmt *nextStmt = nullptr;
+    auto &meStmts = bb->GetMeStmts();
+    MeStmt *stmt = to_ptr(meStmts.begin());
+    for (; stmt != nullptr; stmt = nextStmt) {
+      nextStmt = stmt->GetNext();
+      if (stmt->GetOp() != OP_intrinsiccallwithtypeassigned && stmt->GetOp() != OP_intrinsiccallwithtype) {
+        continue;
+      }
+      auto *callNode = safe_cast<IntrinsiccallMeStmt>(stmt);
+      if (callNode == nullptr || callNode->GetIntrinsic() != INTRN_JAVA_CHECK_CAST) {
+        continue;
+      }
+      if (ProvedBySSI(*callNode)) {
+        redundantChecks.push_back(stmt);
+      }
+    }
+  }
+}
+
+void CheckCast::DeleteRedundants() {
+  for (MeStmt *meStmt : redundantChecks) {
+    RemoveRedundantCheckCast(*meStmt, *(meStmt->GetBB()));
+  }
+}
+
+void MECheckCastOpt::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MECheckCastOpt::PhaseRun(maple::MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  MaplePhase *it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MKlassHierarchy, MIRModule>(f.GetMIRModule());
+  auto *kh = static_cast<M2MKlassHierarchy*>(it)->GetResult();
+  ASSERT_NOT_NULL(dom);
+
+  MeSSI meSSI(f, *dom, *f.GetIRMap(), *GetPhaseMemPool());
+  CheckCast checkCast(f, *kh, meSSI);
+  meSSI.SetSSIType(kCheckCastOpt);
+  meSSI.ConvertToSSI();
+  checkCast.FindRedundantChecks();
+  meSSI.ConvertToSSA();
+  checkCast.DeleteRedundants();
+  if (MeOption::checkCastOpt) {
+    checkCast.DoCheckCastOpt();
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_cond_based_opt.cpp b/src/mapleall/maple_me/src/me_cond_based_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d9718d236861728d2b09f32fc47650c41b89190c
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_cond_based_opt.cpp
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_cond_based_rc.h"
+#include "me_cond_based_npc.h"
+#include "me_const.h"
+#include "me_dominance.h"
+#include "opcode_info.h"
+
+// We do two types of condition based optimization here:
+// 1. condition based null pointer check(NPC) elimination
+// 2. condition based RC elimination
+// both use post dominance data to see if the symbol they are dealing with is
+// zero or not. To be specific, retrieve every stmt of all the bbs', if the stmt
+// is an assertnonnull/MCC_DecRef_NaiveRCFast, then retrieve the enclosing bb's
+// every post dominance frontiers in a backward order, if a frontier is found of
+// conditional branch, and the `expr` it compared is the same as that of
+// the assertnonnull/MCC_DecRef_NaiveRCFast, then the value of the symbol can be
+// known. If it's not zero, condbasednpc could remove the assertnonnull
+// statement; if it is a zero, then MCC_DecRef_NaiveRCFast could be removed.
+//
+// There are other conditions that the assertnonnull can be removed, e.g. if
+// the statement next to assertnonnull is an iread and the base is the
+// symbol assertnonnull is dealing with, then the assertnonnull can be removed,
+// because the exception will be thrown at this same place by iread, as the
+// symbol's value is zero.
+namespace maple {
+// check if varmeexpr is under the condition varmeexpr == 0 when expectedEq0 is true,
+// or varmeexpr != 0 if expectedEq0 is false
+bool MeCondBased::NullValueFromOneTestCond(const VarMeExpr &varMeExpr, const BB &cdBB,
+                                           const BB &bb, bool expectedEq0) const {
+  const auto &meStmts = cdBB.GetMeStmts();
+  if (meStmts.empty()) {
+    return false;
+  }
+  if (!meStmts.back().IsCondBr()) {
+    return false;
+  }
+  auto &condBrMeStmt = static_cast<const CondGotoMeStmt&>(meStmts.back());
+  bool isTrueBr = condBrMeStmt.GetOp() == OP_brtrue;
+  MeExpr *testMeExpr = condBrMeStmt.GetOpnd();
+  if (testMeExpr->GetOp() != OP_eq && testMeExpr->GetOp() != OP_ne) {
+    return false;
+  }
+  bool isEq = testMeExpr->GetOp() == OP_eq;
+  auto *cmpMeExpr = static_cast<OpMeExpr*>(testMeExpr);
+  if (cmpMeExpr->GetOpnd(0)->GetMeOp() != kMeOpVar || cmpMeExpr->GetOpnd(1)->GetOp() != OP_constval) {
+    return false;
+  }
+  auto *constMeExpr = static_cast<ConstMeExpr*>(cmpMeExpr->GetOpnd(1));
+  if (!constMeExpr->IsZero()) {
+    return false;
+  }
+  if (!cmpMeExpr->GetOpnd(0)->IsSameVariableValue(varMeExpr)) {
+    return false;
+  }
+  const BB *sucDomBB = nullptr;
+  for (size_t i = 0; i < cdBB.GetSucc().size(); ++i) {
+    const BB *sucBB = cdBB.GetSucc(i);
+    if (dominance->Dominate(*sucBB, bb)) {
+      sucDomBB = sucBB;
+      break;
+    }
+  }
+  if (sucDomBB == nullptr) {
+    return false;
+  }
+  bool isJumptoBB = sucDomBB->GetBBLabel() == condBrMeStmt.GetOffset();
+  if (expectedEq0) {
+    isEq = !isEq;
+  }
+  return isJumptoBB ? ((isTrueBr && !isEq) || (!isTrueBr && isEq)) : ((isTrueBr && isEq) || (!isTrueBr && !isEq));
+}
+
+bool MeCondBased::NullValueFromTestCond(const VarMeExpr &varMeExpr, const BB &bb, bool expectedEq0) const {
+  auto *pdomFrt = &postDominance->GetDomFrontier(bb.GetID());
+  size_t bbSize = dominance->GetNodeVecSize();
+  std::vector<bool> visitedMap(bbSize, false);
+  bool provenNull = false;
+  MeCFG *cfg = func->GetCfg();
+  while (pdomFrt->size() == 1) {
+    BB &cdBB = *cfg->GetAllBBs().at(*(pdomFrt->begin()));
+    if (visitedMap[cdBB.GetBBId()]) {
+      break;
+    }
+    visitedMap[cdBB.GetBBId()] = true;
+    if (NullValueFromOneTestCond(varMeExpr, cdBB, bb, expectedEq0)) {
+      provenNull = true;
+      break;
+    }
+    pdomFrt = &postDominance->GetDomFrontier(cdBB.GetID());
+  }
+  return provenNull;
+}
+
+bool MeCondBased::IsIreadWithTheBase(const VarMeExpr &var, const MeExpr &meExpr) const {
+  if (meExpr.GetOp() == OP_iread) {
+    const auto &ivarMeExpr = static_cast<const IvarMeExpr&>(meExpr);
+    if (ivarMeExpr.GetBase()->GetExprID() == var.GetExprID()) {
+      return true;
+    }
+  }
+  for (uint8 i = 0; i < meExpr.GetNumOpnds(); ++i) {
+    if (IsIreadWithTheBase(var, *meExpr.GetOpnd(i))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MeCondBased::StmtHasDereferencedBase(const MeStmt &stmt, const VarMeExpr &var) const {
+  if (stmt.GetOp() == OP_iassign) {
+    const auto &iassStmt = static_cast<const IassignMeStmt&>(stmt);
+    if (iassStmt.GetLHSVal()->GetBase()->GetExprID() == var.GetExprID()) {
+      return true;
+    }
+  }
+  if (stmt.GetOp() == OP_syncenter || stmt.GetOp() == OP_syncexit) {
+    const auto &syncMeStmt = static_cast<const SyncMeStmt&>(stmt);
+    const MapleVector<MeExpr*> &opnds = syncMeStmt.GetOpnds();
+    for (auto it = opnds.begin(); it != opnds.end(); ++it) {
+      if ((*it)->GetExprID() == var.GetExprID()) {
+        return true;
+      }
+    }
+  }
+  for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+    MeExpr *meExpr = stmt.GetOpnd(i);
+    if (IsIreadWithTheBase(var, *meExpr)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MeCondBased::PointerWasDereferencedBefore(const VarMeExpr &var, const UnaryMeStmt &assertMeStmt,
+                                               const BB &bb) const {
+  // If var is defined in the function, let BBx be the BB that defines var.
+  // If var is not defined, then let BBx be the function entry BB.
+  // Let BBy be the current BB that contains the assertnonnull.
+  // Search backward along the path in the dominator tree from BBy to BBx.
+  // If it sees an iread or iassign whose base is var, then the assertnonnull can be deleted.
+  MeStmt *defMeStmt = nullptr;
+  BB *bbx = var.GetDefByBBMeStmt(*func->GetCfg(), defMeStmt);
+  if (bbx == nullptr) {
+    return false;
+  }
+  CHECK_FATAL(dominance->Dominate(*bbx, bb), "bbx should dominate bb at this point");
+  for (MeStmt *stmt = assertMeStmt.GetPrev(); stmt != nullptr; stmt = stmt->GetPrev()) {
+    if (StmtHasDereferencedBase(*stmt, var)) {
+      return true;
+    }
+  }
+  if (bbx == &bb) {
+    return false;
+  }
+  BB *itBB = func->GetCfg()->GetBBFromID(BBId(dominance->GetDom(bb.GetID())->GetID()));
+  while (itBB != bbx) {
+    // check if there is an iread or iassign in itbb whose base is var
+    auto &meStmts = itBB->GetMeStmts();
+    for (auto itStmt = meStmts.rbegin(); itStmt != meStmts.rend(); ++itStmt) {
+      if (StmtHasDereferencedBase(*to_ptr(itStmt), var)) {
+        return true;
+      }
+    }
+    itBB = func->GetCfg()->GetBBFromID(BBId(dominance->GetDom(itBB->GetID())->GetID()));
+  }
+  auto &meStmts = bbx->GetMeStmts();
+  for (auto itStmt = meStmts.rbegin(); to_ptr(itStmt) != defMeStmt; ++itStmt) {
+    if (StmtHasDereferencedBase(*to_ptr(itStmt), var)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MeCondBased::PointerWasDereferencedRightAfter(const VarMeExpr &var, const UnaryMeStmt &assertMeStmt) const {
+  // assertnonnull(var)
+  // t = iread(var, 0)
+  // we can safely delete assertnonnull(var)
+  // if we got
+  // assertnonnull(var)
+  // t2 <-
+  // t = iread (var)
+  // we can't remove assertnonnull(var) safely, because if var is null, then the position of throwing exception is
+  // not the same.
+  MeStmt *nextMeStmt = assertMeStmt.GetNextMeStmt();
+  return (nextMeStmt != nullptr) && StmtHasDereferencedBase(*nextMeStmt, var);
+}
+
+bool MeCondBased::IsNotNullValue(const VarMeExpr &varMeExpr, const UnaryMeStmt &assertMeStmt, const BB &bb) const {
+  const OriginalSt *varOst = varMeExpr.GetOst();
+  if (varOst->IsFormal() && varOst->GetMIRSymbol()->GetName() == kStrThisPointer) {
+    return true;
+  }
+  if (varMeExpr.GetDefBy() == kDefByStmt && varMeExpr.GetDefStmt()->GetOp() == OP_dassign) {
+    MeExpr *rhs = static_cast<DassignMeStmt*>(varMeExpr.GetDefStmt())->GetRHS();
+    if (rhs->GetOp() == OP_gcmalloc || rhs->GetOp() == OP_gcmallocjarray) {
+      return true;
+    }
+    if (rhs->GetMeOp() == kMeOpVar) {
+      auto *rhsVar = static_cast<VarMeExpr*>(rhs);
+      const OriginalSt *ost = rhsVar->GetOst();
+      if (ost->IsFormal() && ost->GetMIRSymbol()->GetName() == kStrThisPointer) {
+        return true;
+      }
+    }
+  }
+  if (PointerWasDereferencedBefore(varMeExpr, assertMeStmt, bb)) {
+    return true;
+  }
+  return PointerWasDereferencedRightAfter(varMeExpr, assertMeStmt);
+}
+
+void CondBasedNPC::DoCondBasedNPC() const {
+  MeCFG *cfg = GetFunc()->GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    for (auto &stmt : bb->GetMeStmts()) {
+      if (!kOpcodeInfo.IsAssertNonnull(stmt.GetOp())) {
+        continue;
+      }
+      auto &assertMeStmt = static_cast<UnaryMeStmt&>(stmt);
+      if (assertMeStmt.GetOpnd()->GetMeOp() != kMeOpVar) {
+        continue;
+      }
+      auto *varMeExpr = static_cast<VarMeExpr*>(assertMeStmt.GetOpnd());
+      if (NullValueFromTestCond(*varMeExpr, *bb, false) || IsNotNullValue(*varMeExpr, assertMeStmt, *bb)) {
+        bb->RemoveMeStmt(&stmt);
+      }
+    }
+  }
+}
+
+void MECondBasedRC::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MECondBasedRC::PhaseRun(maple::MeFunction &f) {
+  auto *dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  ASSERT(dom != nullptr, "dominance construction has problem");
+  auto pdom = dominancePhase->GetPdomResult();
+  ASSERT(pdom != nullptr, "postdominance construction has problem");
+  CondBasedRC condBasedRC(f, *dom, *pdom);
+  MeCFG *cfg = f.GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    for (auto &stmt : bb->GetMeStmts()) {
+      if (stmt.GetOp() != OP_decref) {
+        continue;
+      }
+      auto &decref = static_cast<UnaryMeStmt&>(stmt);
+      if (decref.GetOpnd()->GetMeOp() != kMeOpVar) {
+        continue;
+      }
+      auto *varMeExpr = static_cast<VarMeExpr*>(decref.GetOpnd());
+      const OriginalSt *ost = varMeExpr->GetOst();
+      if (!ost->IsLocal() && ost->IsVolatile()) {
+        // global volatile cannot be optimized
+        continue;
+      }
+      MeStmt *refAssign = stmt.GetNext();
+      if (!condBasedRC.NullValueFromTestCond(*varMeExpr, *bb, true)) {
+        continue;
+      }
+      bb->RemoveMeStmt(&stmt);  // delete the decref
+      if (refAssign == nullptr) {
+        break;
+      }
+      refAssign->DisableNeedDecref();
+      stmt = *refAssign;  // next iteration will process the stmt after refassign
+    }
+  }
+  return true;
+}
+
+void MECondBasedNPC::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MECondBasedNPC::PhaseRun(maple::MeFunction &f) {
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  ASSERT(dom != nullptr, "dominance construction has problem");
+  auto pdom = dominancePhase->GetPdomResult();
+  ASSERT(pdom != nullptr, "postdominance construction has problem");
+  CondBasedNPC condBasedNPC(f, *dom, *pdom);
+  condBasedNPC.DoCondBasedNPC();
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_critical_edge.cpp b/src/mapleall/maple_me/src/me_critical_edge.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd97bb2452e55a003cecf55c0b7ee4b1c39d2599
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_critical_edge.cpp
@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_critical_edge.h"
+
+#include <iostream>
+
+#include "me_cfg.h"
+#include "me_dominance.h"
+#include "me_function.h"
+#include "me_irmap.h"
+#include "me_loop_analysis.h"
+#include "me_option.h"
+
+// This phase finds critical edges and split them into two, because their
+// presence would restrict the optimizations performed by SSAPRE-based phases.
+// An edge is a critical edge when its pred has more than one succ and its succ
+// has more than one pred
+//     pred
+//    /    \
+//  newbb   \   <-- newbb (newbb is an empty bb but may carry a label)
+//  \ /      \
+//  succ
+//
+// newbb is always appended at the end of bb_vec_ and pred/succ will be updated.
+// The bblayout phase will determine the final layout order of the bbs.
+namespace maple {
+// This function is used to find the eh edge when predBB is tryBB.
+void MeSplitCEdge::UpdateNewBBInTry(const MeFunction &func, BB &newBB, const BB &pred) const {
+  auto tryBB = &pred;
+  newBB.SetAttributes(kBBAttrIsTry);
+  // The bb which is returnBB and only have return stmt would not have eh edge,
+  // so need find a try bb which have eh edge continue.
+  if (pred.IsReturnBB()) {
+    int i = 1;
+    tryBB = func.GetCfg()->GetBBFromID(newBB.GetBBId() - i);
+    while (tryBB == nullptr || tryBB->IsReturnBB()) {
+      ++i;
+      tryBB = func.GetCfg()->GetBBFromID(newBB.GetBBId() - i);
+    }
+    ASSERT_NOT_NULL(tryBB);
+    ASSERT(tryBB->GetAttributes(kBBAttrIsTry), "must be try");
+  }
+  bool setEHEdge = false;
+  for (auto *candCatch : tryBB->GetSucc()) {
+    if (candCatch != nullptr && candCatch->GetAttributes(kBBAttrIsCatch)) {
+      setEHEdge = true;
+      newBB.AddSucc(*candCatch);
+    }
+  }
+  ASSERT(setEHEdge, "must set eh edge");
+}
+
+void MeSplitCEdge::UpdateGotoLabel(BB &newBB, MeFunction &func, BB &pred, BB &succ) const {
+  auto &gotoStmt = static_cast<CondGotoNode&>(pred.GetStmtNodes().back());
+  BB *gotoBB = pred.GetSucc().at(1);
+  LabelIdx oldLabelIdx = gotoStmt.GetOffset();
+  if (oldLabelIdx != gotoBB->GetBBLabel()) {
+    // original gotoBB is replaced by newBB
+    LabelIdx label = func.GetOrCreateBBLabel(*gotoBB);
+    gotoStmt.SetOffset(label);
+  }
+  if (isDebugFunc) {
+    LogInfo::MapleLogger() << "******after break: dump updated condgoto_BB *****\n";
+    pred.Dump(&func.GetMIRModule());
+    newBB.Dump(&func.GetMIRModule());
+    succ.Dump(&func.GetMIRModule());
+  }
+}
+
+void MeSplitCEdge::UpdateCaseLabel(BB &newBB, MeFunction &func, BB &pred, BB &succ) const {
+  auto &switchStmt = static_cast<SwitchNode&>(pred.GetStmtNodes().back());
+  LabelIdx oldLabelIdx = succ.GetBBLabel();
+  LabelIdx label = func.GetOrCreateBBLabel(newBB);
+  if (switchStmt.GetDefaultLabel() == oldLabelIdx) {
+    switchStmt.SetDefaultLabel(label);
+  }
+  for (size_t i = 0; i < switchStmt.GetSwitchTable().size(); ++i) {
+    LabelIdx labelIdx = switchStmt.GetCasePair(i).second;
+    if (labelIdx == oldLabelIdx) {
+      switchStmt.UpdateCaseLabelAt(i, label);
+    }
+  }
+  if (isDebugFunc) {
+    LogInfo::MapleLogger() << "******after break: dump updated switchBB *****\n";
+    pred.Dump(&func.GetMIRModule());
+    newBB.Dump(&func.GetMIRModule());
+    succ.Dump(&func.GetMIRModule());
+  }
+}
+
+void MeSplitCEdge::DealWithTryBB(const MeFunction &func, BB &pred, BB &succ, BB *&newBB,
+                                 bool &isInsertAfterPred) const {
+  if ((!succ.GetStmtNodes().empty() && succ.GetStmtNodes().front().GetOpCode() == OP_try) ||
+      (!succ.IsMeStmtEmpty() && succ.GetFirstMe()->GetOp() == OP_try)) {
+    newBB = &func.GetCfg()->InsertNewBasicBlock(pred, false);
+    isInsertAfterPred = true;
+    if (pred.GetAttributes(kBBAttrIsTryEnd)) {
+      newBB->SetAttributes(kBBAttrIsTryEnd);
+      pred.ClearAttributes(kBBAttrIsTryEnd);
+      func.GetCfg()->SetTryBBByOtherEndTryBB(newBB, &pred);
+    }
+  } else {
+    newBB = &func.GetCfg()->InsertNewBasicBlock(succ);
+    isInsertAfterPred = false;
+  }
+}
+
+void MeSplitCEdge::BreakCriticalEdge(MeFunction &func, BB &pred, BB &succ) const {
+  if (isDebugFunc) {
+    LogInfo::MapleLogger() << "******before break : critical edge : BB" << pred.GetBBId() << " -> BB" << succ.GetBBId()
+                           << "\n";
+    pred.Dump(&func.GetMIRModule());
+    succ.Dump(&func.GetMIRModule());
+  }
+  ASSERT(!succ.GetAttributes(kBBAttrIsCatch), "BreakCriticalEdge: cannot break an EH edge");
+  // create newBB and set pred/succ
+  BB *newBB = nullptr;
+  MeCFG *cfg = func.GetCfg();
+  // use replace instead of remove/add to keep position in pred/succ
+  bool isInsertAfterPred = false;
+  bool needUpdateTryAttr = true;
+  size_t index = succ.GetPred().size();
+  if (&pred == cfg->GetCommonEntryBB()) {
+    newBB = &cfg->InsertNewBasicBlock(*cfg->GetFirstBB());
+    newBB->SetAttributes(kBBAttrIsEntry);
+    succ.ClearAttributes(kBBAttrIsEntry);
+    pred.RemoveEntry(succ);
+    pred.AddEntry(*newBB);
+    needUpdateTryAttr = false;
+  } else {
+    if (pred.GetAttributes(kBBAttrIsTry)) {
+      DealWithTryBB(func, pred, succ, newBB, isInsertAfterPred);
+    } else {
+      newBB = cfg->NewBasicBlock();
+      needUpdateTryAttr = false;
+    }
+    while (index > 0) {
+      if (succ.GetPred(index - 1) == &pred) {
+        break;
+      }
+      index--;
+    }
+    pred.ReplaceSucc(&succ, newBB);
+  }
+  // pred has been remove for pred vector of succ
+  // means size reduced, so index reduced
+  index--;
+  succ.AddPred(*newBB, index);
+  newBB->SetKind(kBBFallthru);  // default kind
+  newBB->SetAttributes(kBBAttrArtificial);
+
+  // update newBB frequency : copy predBB succFreq as newBB frequency
+  if (cfg->UpdateCFGFreq() && (!(func.IsPme() || func.IsLfo()))) {
+    int idx = pred.GetSuccIndex(*newBB);
+    ASSERT(idx >= 0 && idx < pred.GetSucc().size(), "sanity check");
+    uint64_t freq = pred.GetEdgeFreq(idx);
+    newBB->SetFrequency(freq);
+    newBB->PushBackSuccFreq(freq);
+  }
+
+  if (needUpdateTryAttr && isInsertAfterPred && pred.GetAttributes(kBBAttrIsTry)) {
+    UpdateNewBBInTry(func, *newBB, pred);
+  }
+  if (needUpdateTryAttr && !isInsertAfterPred && succ.GetAttributes(kBBAttrIsTry) &&
+      (succ.GetStmtNodes().empty() || succ.GetStmtNodes().front().GetOpCode() != OP_try)) {
+    UpdateNewBBInTry(func, *newBB, succ);
+  }
+  if (func.GetIRMap() != nullptr) {
+    // update statement offset if succ is goto target
+    cfg->UpdateBranchTarget(pred, succ, *newBB, func);
+  } else {
+    // update statement offset if succ is goto target
+    if (pred.GetKind() == kBBCondGoto) {
+      UpdateGotoLabel(*newBB, func, pred, succ);
+    } else if (pred.GetKind() == kBBSwitch) {
+      UpdateCaseLabel(*newBB, func, pred, succ);
+    }
+  }
+  // profileGen invokes MESplitCEdge to remove critical edges without going through ME completely
+  // newBB needs to be materialized
+  if (Options::profileGen || (Options::profileUse && (func.IsPme() || func.IsLfo()))) {
+    LabelIdx succLabel = succ.GetBBLabel();
+    ASSERT(succLabel != 0, "succ's label missed");
+    if (func.GetIRMap() != nullptr) {
+      GotoNode stmt(OP_goto);
+      GotoMeStmt *gotoSucc = func.GetIRMap()->New<GotoMeStmt>(&stmt);
+      gotoSucc->SetOffset(succLabel);
+      newBB->AddMeStmtLast(gotoSucc);
+    } else {
+      GotoNode *gotoSucc = func.GetMirFunc()->GetCodeMempool()->New<GotoNode>(OP_goto);
+      gotoSucc->SetOffset(succLabel);
+      newBB->AddStmtNode(gotoSucc);
+    }
+    newBB->SetKind(kBBGoto);
+  }
+}
+
+// Is a critical edge is cut by bb
+bool MeSplitCEdge::IsCriticalEdgeBB(const BB &bb) {
+  if (bb.GetPred().size() != 1 || bb.GetSucc().size() != 1) {
+    return false;
+  }
+  return (bb.GetPred(0)->GetSucc().size() > 1) && (bb.GetSucc(0)->GetPred().size() > 1);
+}
+
+// return true if there is critical edge, return false otherwise
+// Split critical edge around bb, i.e. its predecessors and successors
+bool MeSplitCEdge::SplitCriticalEdgeForBB(MeFunction &func, BB &bb) const {
+  bool split = false;
+  if (bb.GetSucc().size() > 1) {
+    for (auto *succ : bb.GetSucc()) {
+      if (succ->GetPred().size() > 1) {
+        // critical edge is found : bb->succ
+        BreakCriticalEdge(func, bb, *succ);
+        split = true;
+      }
+    }
+  }
+  if (bb.GetPred().size() > 1) {
+    for (auto *pred : bb.GetPred()) {
+      if (pred->GetSucc().size() > 1) {
+        // critical edge is found : bb->succ
+        BreakCriticalEdge(func, *pred, bb);
+        split = true;
+      }
+    }
+  }
+  return split;
+}
+
+void ScanEdgeInFunc(const MeCFG &cfg, std::vector<std::pair<BB*, BB*>> &criticalEdge) {
+  auto eIt = cfg.valid_end();
+  for (auto bIt = cfg.valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == cfg.common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    const MapleVector<BB*> &preds = bb->GetPred();
+    // skip fallthrough bb or bb is handler block
+    if (preds.size() < 2 || bb->GetAttributes(kBBAttrIsCatch)) {
+      continue;
+    }
+    // current BB is a merge
+    for (BB *pred : preds) {
+      if (pred->GetKind() == kBBGoto || pred->GetKind() == kBBIgoto) {
+        continue;
+      }
+      if (pred->GetSucc().size() > 1) {
+        // pred has more than one succ
+        criticalEdge.push_back(std::make_pair(pred, bb));
+      }
+    }
+  }
+  // separate treatment for commonEntryBB's succ BBs
+  for (BB *entryBB : cfg.GetCommonEntryBB()->GetSucc()) {
+    if (!entryBB->GetPred().empty()) {
+      criticalEdge.push_back(std::make_pair(cfg.GetCommonEntryBB(), entryBB));
+    }
+  }
+}
+
+bool MeSplitCEdge::SplitCriticalEdgeForMeFunc(MeFunction &func) const {
+  std::vector<std::pair<BB*, BB*>> criticalEdge;
+  ScanEdgeInFunc(*func.GetCfg(), criticalEdge);
+  bool split = false;
+  if (!criticalEdge.empty()) {
+    split = true;
+    if (isDebugFunc) {
+      LogInfo::MapleLogger() << "*******************before break dump function*****************\n";
+      func.DumpFunctionNoSSA();
+      func.GetCfg()->DumpToFile("cfgbeforebreak");
+    }
+    for (auto it = criticalEdge.begin(); it != criticalEdge.end(); ++it) {
+      BreakCriticalEdge(func, *(it->first), *(it->second));
+    }
+    if (isDebugFunc) {
+      LogInfo::MapleLogger() << "******************after break dump function******************\n";
+      func.Dump(true);
+      func.GetCfg()->DumpToFile("cfgafterbreak");
+    }
+  }
+  return split;
+}
+
+void MESplitCEdge::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.PreservedAllExcept<MEDominance>();
+  aDep.PreservedAllExcept<MELoopAnalysis>();
+}
+
+bool MESplitCEdge::PhaseRun(maple::MeFunction &f) {
+  bool enableDebug = DEBUGFUNC_NEWPM(f);
+  MeSplitCEdge mscedge = MeSplitCEdge(enableDebug);
+  mscedge.SplitCriticalEdgeForMeFunc(f);
+  if (Options::profileUse) {
+    if ((f.IsPme() || f.IsLfo()) && f.GetPreMeFunc()) {
+      // new inserted BB break cached while/if label information and IR layout
+      f.GetPreMeFunc()->label2IfInfo.clear();
+      f.GetPreMeFunc()->label2WhileInfo.clear();
+      f.GetPreMeFunc()->pmeCreatedIfLabelSet.clear();
+      f.GetPreMeFunc()->pmeCreatedWhileLabelSet.clear();
+    }
+  }
+  if (f.GetCfg()->UpdateCFGFreq() && (f.GetCfg()->DumpIRProfileFile())) {
+    f.GetCfg()->DumpToFile("after-splitcriticaledge", false, true);
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_delegate_rc.cpp b/src/mapleall/maple_me/src/me_delegate_rc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0256ded4cd1f5a01abc6bcd8286f09b70d0e452c
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_delegate_rc.cpp
@@ -0,0 +1,881 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_delegate_rc.h"
+#include "mir_builder.h"
+#include "me_hdse.h"
+
+// This phase finds local ref pointer variables that are delegated and thus can
+// have their RC omitted.  This optimization is done on a per-SSA version basis.
+// As a result, an overall criterion is that the SSA version must not have
+// appeared as phi operand;
+//
+// There are two forms of delegation:
+//
+// Form A. The following conditions have to be satisfied for an SSA version to be
+// delegated:
+// (1) In the BB where it is defined, there is a last use of it as the assigned
+//     value in an assignment statement, which is either iassign or
+//     dassign-to-global, and the assignment statement is marked need_incref.
+// (2) Between its definition and last use, there is no statement that may
+//     potentially raise exception.
+// For each such case, the optimization is as follows:
+// (a) The SSA version is renamed to a new and unique preg with PTY_ptr type;
+//     this has the effect of eliminating its store and loads and its
+//     decref-before-return;
+// (b) The need_incref flag in the respective assignment statement is cleared.
+// The reference count correctness is maintained because the removed decref and
+// incref are for the same offect.
+//
+// Form B. An SSA version is determined to not need incref at its def and not
+// need decref when it becomes dead.  In this case, the SSA version is renamed
+// to a new and unique preg with PTY_ptr type as in (a) above.
+//
+// There are different ways to establish that an SSA version does not any RC:
+// B1: The SSA version is never dereferenced and never copied to another variable
+//     or passed on as a parameter.
+// B2: The RHS of its definition is iread of a final field with this as base or
+//     dread of a static final field.
+// B3: Within the SSA version's live range, there is no operation that can result
+//     in decref of any object.
+namespace {
+// following intrinsics can throw exception
+const std::set<maple::MIRIntrinsicID> canThrowIntrinsicsList {
+    maple::INTRN_MPL_CLINIT_CHECK,
+    maple::INTRN_MPL_BOUNDARY_CHECK,
+    maple::INTRN_JAVA_CLINIT_CHECK,
+    maple::INTRN_JAVA_CLINIT_CHECK_SGET,
+    maple::INTRN_JAVA_CLINIT_CHECK_SPUT,
+    maple::INTRN_JAVA_CLINIT_CHECK_NEW,
+    maple::INTRN_JAVA_CHECK_CAST,
+    maple::INTRN_JAVA_THROW_ARITHMETIC,
+    maple::INTRN_JAVA_THROW_CLASSCAST,
+};
+const std::set<std::string> whitelistFunc {
+#include "rcwhitelist.def"
+};
+}
+
+namespace maple {
+static bool CheckOp(const MeStmt &stmt, const Opcode op) {
+  return stmt.GetOp() == op;
+}
+static bool IsIntrinsic(const MeStmt &stmt) {
+  return CheckOp(stmt, OP_intrinsiccall) || CheckOp(stmt, OP_intrinsiccallassigned) ||
+         CheckOp(stmt, OP_xintrinsiccall) || CheckOp(stmt, OP_xintrinsiccallassigned) ||
+         CheckOp(stmt, OP_intrinsiccallwithtype) || CheckOp(stmt, OP_intrinsiccallwithtypeassigned);
+}
+
+static bool IsCleanUpStmt(const MeStmt &stmt) {
+  return CheckOp(stmt, OP_intrinsiccall) &&
+         static_cast<const IntrinsiccallMeStmt&>(stmt).GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS;
+}
+
+static bool IsVarDecRefStmt(const MeStmt &stmt) {
+  return (CheckOp(stmt, OP_decref) && stmt.GetOpnd(0)->GetMeOp() == kMeOpVar) ||
+         CheckOp(stmt, OP_decrefreset);
+}
+
+void DelegateRC::SetCantDelegate(const MapleMap<OStIdx, MePhiNode*> &meVarPhiList) {
+  for (auto it = meVarPhiList.begin(); it != meVarPhiList.end(); ++it) {
+    const OriginalSt *ost = ssaTab.GetOriginalStFromID(it->first);
+    CHECK_FATAL(ost, "ost is nullptr!");
+    if (!ost->IsSymbolOst() || ost->GetIndirectLev() != 0) {
+      continue;
+    }
+    MePhiNode *mePhi = it->second;
+    if (!mePhi->GetIsLive()) {
+      continue;
+    }
+    for (auto *phiOpnd : mePhi->GetOpnds()) {
+      verStCantDelegate[phiOpnd->GetVstIdx()] = true;
+    }
+  }
+}
+
+void DelegateRC::SaveDerefedOrCopiedVst(const MeExpr *expr) {
+  CHECK_NULL_FATAL(expr);
+  while (expr->GetOp() == OP_retype) {
+    expr = expr->GetOpnd(0);
+  }
+  if (expr->GetMeOp() == kMeOpVar) {
+    const auto *varExpr = static_cast<const VarMeExpr*>(expr);
+    verStDerefedCopied[varExpr->GetVstIdx()] = true;
+  }
+}
+
+bool DelegateRC::IsCopiedOrDerefedOp(Opcode op) const {
+  return op == OP_dassign || op == OP_maydassign || op == OP_regassign || op == OP_syncenter ||
+         op == OP_syncexit || op == OP_throw || op == OP_return || op == OP_iassign ||  // cause var copied
+         kOpcodeInfo.IsCall(op);  // callstmt need considering parameter
+}
+
+void DelegateRC::CollectDerefedOrCopied(const MeStmt &stmt) {
+  Opcode op = stmt.GetOp();
+  if (!IsCopiedOrDerefedOp(op)) {
+    return;
+  }
+  for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+    MeExpr *curOpnd = stmt.GetOpnd(i);
+    SaveDerefedOrCopiedVst(curOpnd);
+  }
+}
+
+void DelegateRC::CollectDerefedOrCopied(const MeExpr &expr) {
+  Opcode op = expr.GetOp();
+  if (op == OP_iaddrof || op == OP_add) {
+    for (size_t i = 0; i < expr.GetNumOpnds(); ++i) {
+      SaveDerefedOrCopiedVst(expr.GetOpnd(i));
+    }
+    return;
+  }
+
+  if (op == OP_cvt) {
+    // in some cases, we have cvt from int to ref
+    // dassign %Reg0_I 0 (cvt i32 ref (dread ref %Reg0_XXXX))
+    // cvt ref i32 (dread i32 %Reg0_I)
+    if (expr.GetPrimType() == PTY_ref && expr.GetOpnd(0)->GetMeOp() == kMeOpVar) {
+      auto *baseVar = static_cast<VarMeExpr*>(expr.GetOpnd(0));
+      verStDerefedCopied[baseVar->GetVstIdx()] = true;
+      // collect the def of basevar
+      if (baseVar->GetDefBy() == kDefByStmt) {
+        MeStmt *defStmt = baseVar->GetDefStmt();
+        if (defStmt->GetOp() == OP_dassign && defStmt->GetRHS() != nullptr && defStmt->GetRHS()->GetOp() == OP_cvt) {
+          SaveDerefedOrCopiedVst(defStmt->GetRHS()->GetOpnd(0));
+        }
+      } else if (baseVar->GetDefBy() == kDefByPhi) {
+        MePhiNode &defPhi = baseVar->GetDefPhi();
+        for (auto *phiOpnd : defPhi.GetOpnds()) {
+          if (phiOpnd->GetDefBy() == kDefByStmt) {
+            MeStmt *defStmt = phiOpnd->GetDefStmt();
+            if (defStmt->GetOp() == OP_dassign && defStmt->GetRHS() != nullptr &&
+                defStmt->GetRHS()->GetOp() == OP_cvt) {
+              SaveDerefedOrCopiedVst(defStmt->GetRHS()->GetOpnd(0));
+            }
+          }
+        }  // next phi opnd
+      }  // end of all phi
+    }
+    return;
+  }
+
+  if (op == OP_array ||
+      (op == OP_intrinsicop && static_cast<const NaryMeExpr&>(expr).GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH) ||
+      (op == OP_intrinsicopwithtype && static_cast<const NaryMeExpr&>(expr).GetIntrinsic() == INTRN_JAVA_INSTANCE_OF)) {
+    CHECK_FATAL(expr.GetNumOpnds() != 0, "container check");
+    SaveDerefedOrCopiedVst(expr.GetOpnd(0));
+    return;
+  }
+
+  if (expr.GetMeOp() == kMeOpIvar) {
+    SaveDerefedOrCopiedVst(expr.GetOpnd(0));
+  }
+}
+
+void DelegateRC::CollectVstCantDecrefEarly(MeExpr &opnd0, MeExpr &opnd1) {
+  if (opnd0.GetMeOp() != kMeOpVar || opnd1.GetMeOp() != kMeOpVar) {
+    return;
+  }
+  auto &varOpnd0 = static_cast<VarMeExpr&>(opnd0);
+  auto &varOpnd1 = static_cast<VarMeExpr&>(opnd1);
+  if (varOpnd0.GetDefBy() == kDefByNo || varOpnd1.GetDefBy() == kDefByNo) {
+    return;
+  }
+  BB *opnd0DefBB = varOpnd0.DefByBB();
+  BB *opnd1DefBB = varOpnd1.DefByBB();
+
+  if (opnd0DefBB == opnd1DefBB) {
+    verStCantDecrefEarly[varOpnd0.GetVstIdx()] = true;
+    verStCantDecrefEarly[varOpnd1.GetVstIdx()] = true;
+  } else if (dominance.Dominate(*opnd0DefBB, *opnd1DefBB)) {
+    verStCantDecrefEarly[varOpnd0.GetVstIdx()] = true;
+  } else {
+    verStCantDecrefEarly[varOpnd1.GetVstIdx()] = true;
+  }
+}
+
+void DelegateRC::CollectUseCounts(const MeExpr &expr) {
+  if (expr.GetMeOp() == kMeOpVar) {
+    const auto &varMeExpr = static_cast<const VarMeExpr&>(expr);
+    ASSERT(varMeExpr.GetVstIdx() < verStUseCounts.size(), "CollectUsesInfo: vstIdx out of bounds");
+    verStUseCounts[varMeExpr.GetVstIdx()]++;
+  }
+}
+
+void DelegateRC::CollectUsesInfo(const MeExpr &expr) {
+  for (size_t i = 0; i < expr.GetNumOpnds(); ++i) {
+    CollectUsesInfo(*expr.GetOpnd(i));
+  }
+  if ((expr.GetOp() == OP_eq || expr.GetOp() == OP_ne) && static_cast<const OpMeExpr&>(expr).GetOpndType() == PTY_ref) {
+    CollectVstCantDecrefEarly(*expr.GetOpnd(0), *expr.GetOpnd(1));
+  }
+  CollectDerefedOrCopied(expr);
+  CollectUseCounts(expr);
+}
+
+// traverse expression x; at each occurrence of rhsvar in x, decrement
+// remaining_uses
+void DelegateRC::FindAndDecrUseCount(const VarMeExpr &rhsVar, const MeExpr &expr, int32 &remainingUses) const {
+  for (size_t i = 0; i < expr.GetNumOpnds(); ++i) {
+    FindAndDecrUseCount(rhsVar, *expr.GetOpnd(i), remainingUses);
+  }
+  if (&expr == &rhsVar) {
+    --remainingUses;
+  }
+}
+
+bool DelegateRC::MayThrowException(const MeStmt &stmt) const {
+  if (CheckOp(stmt, OP_maydassign) || CheckOp(stmt, OP_throw)) {
+    return true;
+  }
+
+  if (CheckOp(stmt, OP_dassign)) {
+    const auto &dass = static_cast<const DassignMeStmt&>(stmt);
+    const MeExpr *rhs = dass.GetRHS();
+    CHECK_NULL_FATAL(rhs);
+    return dass.GetWasMayDassign() || rhs->GetOp() == OP_gcmalloc || rhs->GetOp() == OP_gcmallocjarray;
+  }
+
+  if (CheckOp(stmt, OP_regassign)) {
+    ASSERT_NOT_NULL(stmt.GetRHS());
+    return stmt.GetRHS()->GetOp() == OP_gcmalloc || stmt.GetRHS()->GetOp() == OP_gcmallocjarray;
+  }
+
+  if (IsIntrinsic(stmt)) {
+    const auto &intrn = static_cast<const IntrinsiccallMeStmt&>(stmt);
+    return canThrowIntrinsicsList.find(intrn.GetIntrinsic()) != canThrowIntrinsicsList.end();
+  }
+
+  if (kOpcodeInfo.IsCall(stmt.GetOp())) {
+    const auto &callStmt = static_cast<const CallMeStmt&>(stmt);
+    MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt.GetPUIdx());
+    return (!callee->GetFuncAttrs().GetAttr(FUNCATTR_nothrow_exception)) ||
+           (!MeOption::ignoreIPA && !callee->IsNoThrowException());
+  }
+  return false;
+}
+
+// Traverse backwards from fromstmt to tostmt to see if the single use of rhsvar
+// in fromstmt is the last use of rhsvar; tostmt is the statement that defines
+// rhsvar, so it can be assumed that tostmt does not contain any use; this check
+// make use of verStUseCounts in its determination. In addition, if it comes
+// across any stmt that can raise exception, also return false.
+bool DelegateRC::ContainAllTheUses(const VarMeExpr &rhsVar, const MeStmt &fromStmt, const MeStmt &toStmt) const {
+  int32 remainingUses = static_cast<int32>(verStUseCounts[rhsVar.GetVstIdx()]) - 1;
+  for (MeStmt *cur = fromStmt.GetPrev(); cur != &toStmt; cur = cur->GetPrev()) {
+    // do not count decref operands
+    if (IsVarDecRefStmt(*cur)) {
+      continue;
+    }
+    if (MayThrowException(*cur)) {
+      return false;
+    }
+    // function call contains yieldpoint, we cant not optimize across a call
+    if (kOpcodeInfo.IsCall(cur->GetOp()) && !IsIntrinsic(*cur)) {
+      return false;
+    }
+    if (IsCleanUpStmt(*cur)) {
+      continue;
+    }
+    for (size_t i = 0; i < cur->NumMeStmtOpnds(); ++i) {
+      FindAndDecrUseCount(rhsVar, *cur->GetOpnd(i), remainingUses);
+    }
+  }
+  CHECK_FATAL(remainingUses >= 0, "ContainAllTheUses: inconsistent use count");
+  return remainingUses == 0;
+}
+
+// return the RegMeExpr node to replace the original temp; nullptr if not successful
+RegMeExpr *DelegateRC::RHSTempDelegated(MeExpr &rhs, const MeStmt &useStmt) {
+  if (rhs.GetMeOp() != kMeOpVar) {
+    return nullptr;
+  }
+  auto &rhsVar = static_cast<VarMeExpr&>(rhs);
+  if (verStCantDelegate[rhsVar.GetVstIdx()]) {
+    return nullptr;
+  }
+  if (refVar2RegMap.find(&rhsVar) != refVar2RegMap.end()) {
+    return nullptr;  // already delegated by another assignment
+  }
+  const OriginalSt *ost = rhsVar.GetOst();
+  if (ost->IsFormal() || ost->GetMIRSymbol()->IsGlobal()) {
+    return nullptr;
+  }
+  // The index number in originalStVector is bigger than two.
+  if ((func.GetHints() & kPlacementRCed) && ssaTab.GetVersionsIndicesSize(ost->GetIndex()) > 2) {
+    return nullptr;
+  }
+  if (rhsVar.GetDefBy() == kDefByMustDef) {
+    MustDefMeNode &mustDef = rhsVar.GetDefMustDef();
+    ASSERT(mustDef.GetLHS() == &rhsVar, "DelegateRCTemp: inconsistent mustdef");
+    MeStmt *callStmt = mustDef.GetBase();
+    if (callStmt->GetBB() != useStmt.GetBB()) {
+      return nullptr;
+    }
+    if (!ContainAllTheUses(rhsVar, useStmt, *callStmt)) {
+      return nullptr;
+    }
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "delegaterc of form A for func " << func.GetName() << '\n';
+      LogInfo::MapleLogger() << "\nreplace stmt :\n" << '\n';
+      callStmt->Dump(func.GetIRMap());
+    }
+    // replace temp by a new preg
+    rhsVar.SetDefBy(kDefByNo);
+    RegMeExpr *curReg = nullptr;
+    if (ost->GetMIRSymbol()->GetType()->GetPrimType() == PTY_ptr) {
+      curReg = irMap.CreateRegMeExpr(PTY_ptr);
+    } else {
+      curReg = irMap.CreateRegMeExpr(rhsVar);
+    }
+    refVar2RegMap[&rhsVar] = curReg;  // record this replacement
+    mustDef.UpdateLHS(*curReg);
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "with stmt :\n" << '\n';
+      mustDef.GetBase()->Dump(func.GetIRMap());
+    }
+    return curReg;
+  } else if (rhsVar.GetDefBy() == kDefByStmt) {
+    MeStmt *defStmt = rhsVar.GetDefStmt();
+    if (defStmt->GetBB() != useStmt.GetBB()) {
+      return nullptr;
+    }
+    if (!ContainAllTheUses(rhsVar, useStmt, *defStmt)) {
+      return nullptr;
+    }
+    MeExpr *rhsExpr = defStmt->GetRHS();
+    bool defStmtNeedIncref = defStmt->NeedIncref();
+    CHECK_FATAL(defStmt->GetOp() == OP_dassign || defStmt->GetOp() == OP_maydassign,
+                "DelegateRCTemp: unexpected stmt op for kDefByStmt");
+    ASSERT(defStmt->GetVarLHS() == &rhsVar, "DelegateRCTemp: inconsistent def by dassign");
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "delegaterc of form A for func " << func.GetName() << '\n';
+      LogInfo::MapleLogger() << "\nreplace stmt :\n" << '\n';
+      defStmt->Dump(func.GetIRMap());
+    }
+    // replace temp by a new preg
+    rhsVar.SetDefBy(kDefByNo);
+    RegMeExpr *curReg = irMap.CreateRegMeExpr(rhsVar);
+    refVar2RegMap[&rhsVar] = curReg;  // record this replacement
+    // create new regassign statement
+    MeStmt *regass = irMap.CreateAssignMeStmt(*curReg, *rhsExpr, *defStmt->GetBB());
+    curReg->SetDefByStmt(*regass);
+    if (defStmtNeedIncref) {
+      regass->EnableNeedIncref();
+    } else {
+      regass->DisableNeedIncref();
+    }
+    defStmt->GetBB()->ReplaceMeStmt(defStmt, regass);
+    regass->SetSrcPos(defStmt->GetSrcPosition());
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "with stmt :\n" << '\n';
+      regass->Dump(func.GetIRMap());
+    }
+    return curReg;
+  }
+  return nullptr;
+}
+
+// process each assignment statement for Form A delegation
+void DelegateRC::DelegateRCTemp(MeStmt &stmt) {
+  switch (stmt.GetOp()) {
+    case OP_iassign: {
+      if (!stmt.NeedIncref()) {
+        break;
+      }
+      IvarMeExpr *lhs = static_cast<IassignMeStmt&>(stmt).GetLHSVal();
+      if (lhs->IsRCWeak() || lhs->IsVolatile()) {
+        break;
+      }
+      if (lhs->GetBase()->GetOp() == OP_array) {
+        // array may raise exception
+        break;
+      }
+      MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhs->GetTyIdx());
+      ASSERT(baseType->GetKind() == kTypePointer, "DelegateRCTemp: unexpected type");
+      MIRType *pointedType = static_cast<MIRPtrType*>(baseType)->GetPointedType();
+      if (pointedType->GetKind() == kTypeClass &&
+          static_cast<MIRClassType*>(pointedType)->IsFieldRCUnownedRef(lhs->GetFieldID())) {
+        break;
+      }
+      MeExpr *rhs = stmt.GetRHS();
+      CHECK_FATAL(rhs != nullptr, "null rhs check");
+      RegMeExpr *curReg = RHSTempDelegated(*rhs, stmt);
+      if (curReg != nullptr) {
+        rhs = curReg;
+        stmt.DisableNeedIncref();
+      }
+      break;
+    }
+    case OP_dassign: {
+      if (!stmt.NeedIncref()) {
+        break;
+      }
+      ScalarMeExpr *lhsVar = stmt.GetVarLHS();
+      CHECK_FATAL(lhsVar != nullptr, "null lhs check");
+      const OriginalSt *ost = lhsVar->GetOst();
+      if (Options::lazyBinding != 0 || !ost->GetMIRSymbol()->IsGlobal()) {
+        break;
+      }
+      MeExpr *rhs = stmt.GetRHS();
+      CHECK_FATAL(rhs != nullptr, "null rhs check");
+      RegMeExpr *curReg = RHSTempDelegated(*rhs, stmt);
+      if (curReg != nullptr) {
+        rhs = curReg;
+        stmt.DisableNeedIncref();
+      }
+      break;
+    }
+    case OP_return: {
+      std::string funcName = func.GetMirFunc()->GetName();
+      if (whitelistFunc.find(funcName) != whitelistFunc.end()) {
+        break;
+      }
+      auto &retStmt = static_cast<RetMeStmt&>(stmt);
+      if (!retStmt.NumMeStmtOpnds()) {
+        break;
+      }
+      MeExpr *ret = retStmt.GetOpnd(0);
+      if (ret->GetPrimType() != PTY_ref && ret->GetPrimType() != PTY_ptr) {
+        break;
+      }
+      if (ret->GetMeOp() == kMeOpVar) {
+        auto *val = static_cast<VarMeExpr*>(ret);
+        if (val->GetDefBy() == kDefByMustDef) {
+          MeStmt *defStmt = val->GetDefMustDef().GetBase();
+          if (retStmt.GetBB() == defStmt->GetBB() && ContainAllTheUses(*val, stmt, *defStmt)) {
+            RegMeExpr *curReg = RHSTempDelegated(*ret, stmt);
+            if (curReg != nullptr) {
+              retStmt.SetOpnd(0, curReg);
+            }
+          }
+        } else if (val->GetDefBy() == kDefByStmt) {
+          MeStmt *defStmt = val->GetDefStmt();
+          MeExpr *rhs = defStmt->GetRHS();
+          CHECK_FATAL(rhs != nullptr, "null rhs check");
+          const OriginalSt *ost = nullptr;
+          if (rhs->GetMeOp() == kMeOpVar) {
+            auto *theVar = static_cast<VarMeExpr*>(rhs);
+            ost = theVar->GetOst();
+          }
+          if (rhs->IsGcmalloc() || (rhs->GetMeOp() == kMeOpIvar && !static_cast<IvarMeExpr*>(rhs)->IsFinal()) ||
+              (rhs->GetMeOp() == kMeOpVar && !ost->IsFinal() && ost->GetMIRSymbol()->IsGlobal()) ||
+              (rhs->GetOp() == OP_regread && static_cast<RegMeExpr*>(rhs)->GetRegIdx() == -kSregThrownval)) {
+            if (retStmt.GetBB() == defStmt->GetBB() && ContainAllTheUses(*val, stmt, *defStmt)) {
+              RegMeExpr *curReg = RHSTempDelegated(*ret, stmt);
+              if (curReg != nullptr) {
+                retStmt.SetOpnd(0, curReg);
+                // Convert following cases:
+                //   dassign %Reg_xxx  (iread ref xxx)
+                //   return (dread ref %Reg_xxx)
+                // To:
+                //   // iread will be converted to LoadRefField
+                //   regassign %1 (iread ref xxx)  [RC+]
+                //   return (regread ref %1)
+                if (rhs->GetMeOp() == kMeOpIvar ||
+                    (rhs->GetMeOp() == kMeOpVar && !ost->IsFinal() && ost->GetMIRSymbol()->IsGlobal())) {
+                  curReg->GetDefStmt()->EnableNeedIncref();
+                }
+              }
+            }
+          }
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+bool DelegateRC::FinalRefNoRC(const MeExpr &expr) const {
+  if (expr.GetMeOp() == kMeOpVar) {
+    const auto &theVar = static_cast<const VarMeExpr&>(expr);
+    const OriginalSt *ost = theVar.GetOst();
+    return ost->IsFinal() && ost->GetMIRSymbol()->IsGlobal();
+  } else if (expr.GetMeOp() == kMeOpIvar) {
+    if (func.GetMirFunc()->IsConstructor() || func.GetMirFunc()->IsStatic() ||
+        func.GetMirFunc()->GetFormalCount() == 0) {
+      return false;
+    }
+    const auto &ivar = static_cast<const IvarMeExpr&>(expr);
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx());
+    ASSERT(ty->GetKind() == kTypePointer, "FinalRefNoRC: pointer type expected");
+    MIRType *pointedTy = static_cast<MIRPtrType*>(ty)->GetPointedType();
+    if (pointedTy->GetKind() == kTypeClass) {
+      auto *structType = static_cast<MIRStructType*>(pointedTy);
+      FieldID fieldID = ivar.GetFieldID();
+      if (structType->IsFieldFinal(fieldID) && !structType->IsFieldRCUnownedRef(fieldID)) {
+        if (ivar.GetBase()->GetMeOp() != kMeOpVar) {
+          return false;
+        }
+        const auto *varMeExpr = static_cast<const VarMeExpr*>(ivar.GetBase());
+        const OriginalSt *ost = varMeExpr->GetOst();
+        if (ost->IsSymbolOst()) {
+          const MIRSymbol *mirst = ost->GetMIRSymbol();
+          return mirst == func.GetMirFunc()->GetFormal(0);
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// return true if it is OK to omit reference counting for the LHS variable; if
+// returning true, only_with_decref specifies whether a decref needs inserted
+bool DelegateRC::CanOmitRC4LHSVar(const MeStmt &stmt, bool &onlyWithDecref) const {
+  onlyWithDecref = false;
+  switch (stmt.GetOp()) {
+    case OP_dassign:
+    case OP_maydassign: {
+      const VarMeExpr *theLhs = static_cast<VarMeExpr *>(stmt.GetVarLHS());
+      MeExpr *theRhs = stmt.GetRHS();
+      CHECK_FATAL(theLhs != nullptr, "null ptr check");
+      CHECK_FATAL(theRhs != nullptr, "null ptr check");
+      if (theLhs->GetPrimType() != PTY_ref || theLhs->GetNoDelegateRC()) {
+        return false;
+      }
+      const OriginalSt *ost = theLhs->GetOst();
+      if (!ost->IsLocal() || ost->IsFormal() ||
+          // avoid multi-version vars because of it is hard to find the decrefreset.
+          ((func.GetHints() & kPlacementRCed) && ssaTab.GetVersionsIndicesSize(ost->GetIndex()) > 2)) {
+        return false;
+      }
+      if (ost->GetMIRSymbol()->IsInstrumented()) {
+        return false;
+      }
+      if (verStCantDelegate[theLhs->GetVstIdx()]) {
+        return false;
+      }
+      if (theRhs->GetMeOp() == kMeOpIvar) {
+        auto *ivarRhs = static_cast<IvarMeExpr*>(theRhs);
+        if (ivarRhs->IsVolatile() || ivarRhs->IsRCWeak()) {
+          return false;
+        }
+      }
+      // condition B2
+      if (FinalRefNoRC(*theRhs)) {
+        return true;
+      }
+      // condition B1
+      if (!verStDerefedCopied[theLhs->GetVstIdx()]) {
+        onlyWithDecref = theRhs->GetOp() == OP_gcmalloc || theRhs->GetOp() == OP_gcmallocjarray ||
+            (theRhs->GetOp() == OP_regread && static_cast<RegMeExpr*>(theRhs)->GetRegIdx() == -kSregThrownval);
+        if (onlyWithDecref && verStCantDecrefEarly[theLhs->GetVstIdx()]) {
+          onlyWithDecref = false;
+          return false;
+        }
+        // except reset of localrefvar because of special handle throw operand
+        if ((func.GetHints() & kPlacementRCed) && theRhs->GetOp() == OP_constval) {
+          return false;
+        }
+        return true;
+      }
+      break;
+    }
+    default:
+      if (kOpcodeInfo.IsCallAssigned(stmt.GetOp())) {
+        const MapleVector<MustDefMeNode> &mustdefList = stmt.GetMustDefList();
+        if (mustdefList.empty()) {
+          return false;
+        }
+        const MeExpr *lhs = mustdefList.front().GetLHS();
+        if (lhs->GetMeOp() != kMeOpVar) {
+          return false;
+        }
+        const auto *theLhs = static_cast<const VarMeExpr*>(lhs);
+        if (theLhs->GetPrimType() != PTY_ref) {
+          return false;
+        }
+        const OriginalSt *ost = theLhs->GetOst();
+        if (!ost->IsLocal() || ost->IsFormal() ||
+            // avoid multi-version vars because of it is hard to find the decrefreset.
+            ((func.GetHints() & kPlacementRCed) && ssaTab.GetVersionsIndicesSize(ost->GetIndex()) > 2)) {
+          return false;
+        }
+        if (verStCantDelegate[theLhs->GetVstIdx()]) {
+          return false;
+        }
+        if (!verStDerefedCopied[theLhs->GetVstIdx()]) {
+          // condition B1
+          if (!verStCantDecrefEarly[theLhs->GetVstIdx()]) {
+            onlyWithDecref = true;
+            return true;
+          }
+        }
+      }
+      break;
+  }
+  return false;
+}
+
+void DelegateRC::DelegateHandleNoRCStmt(MeStmt &stmt, bool addDecref) {
+  VarMeExpr *theLhs = nullptr;
+  MeExpr *rhsExpr = stmt.GetRHS();
+  if (CheckOp(stmt, OP_dassign) || CheckOp(stmt, OP_maydassign)) {
+    theLhs = static_cast<VarMeExpr *>(stmt.GetVarLHS());
+  } else if (kOpcodeInfo.IsCallAssigned(stmt.GetOp()) && addDecref) {
+    theLhs = static_cast<VarMeExpr*>(stmt.GetAssignedLHS());
+  } else {
+    return;
+  }
+  CHECK_FATAL(theLhs != nullptr, "null ptr check");
+  if (theLhs->GetPrimType() != PTY_ref) {
+    return;
+  }
+
+  BB &bb = *stmt.GetBB();
+  // bool defstmt_need_incref;
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "delegaterc of form B for func " << func.GetName() << '\n';
+    LogInfo::MapleLogger() << "\nreplace stmt :\n" << '\n';
+    stmt.Dump(func.GetIRMap());
+  }
+  // replace temp by a new preg
+  MeStmt *newStmt = &stmt;
+  theLhs->SetDefBy(kDefByNo);
+  RegMeExpr *curReg = irMap.CreateRegMeExpr(*theLhs);
+  refVar2RegMap[theLhs] = curReg;  // record this replacement
+  if (rhsExpr != nullptr) {
+    // create new regassign statement
+    MeStmt *regass = irMap.CreateAssignMeStmt(*curReg, *rhsExpr, *stmt.GetBB());
+    curReg->SetDefByStmt(*regass);
+    bb.ReplaceMeStmt(newStmt, regass);
+    newStmt = regass;  // for inserting defref after it below
+  } else {
+    // callassigned
+    static_cast<CallMeStmt&>(stmt).SetCallReturn(*curReg);
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "with stmt :\n" << '\n';
+    newStmt->Dump(func.GetIRMap());
+  }
+  if (addDecref) {
+    // We use RC intrinsic instead of direct function call,
+    // so that mplcg can decide how to generate code for it.
+    // for example: when GCONLY is enabled, decref will be omitted.
+    std::vector<MeExpr*> opnds = { curReg };
+    IntrinsiccallMeStmt *decRefIntrin = irMap.CreateIntrinsicCallMeStmt(INTRN_MCCDecRef, opnds);
+    decRefIntrin->SetSrcPos(newStmt->GetSrcPosition());
+    bb.InsertMeStmtAfter(newStmt, decRefIntrin);
+  }
+}
+
+void DelegateRC::RenameDelegatedRefVarUses(MeStmt &meStmt, MeExpr &meExpr) {
+  for (size_t i = 0; i < meExpr.GetNumOpnds(); ++i) {
+    RenameDelegatedRefVarUses(meStmt, *meExpr.GetOpnd(i));
+  }
+  if (meExpr.GetMeOp() == kMeOpVar) {
+    auto &varMeExpr = static_cast<VarMeExpr&>(meExpr);
+    auto it = refVar2RegMap.find(&varMeExpr);
+    if (it != refVar2RegMap.end()) {
+      (void)irMap.ReplaceMeExprStmt(meStmt, varMeExpr, *it->second);
+    }
+  }
+}
+
+void DelegateRC::SetCantDelegateAndCountUses() {
+  MeCFG *cfg = func.GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto &bb = **bIt;
+    SetCantDelegate(bb.GetMePhiList());
+    for (auto &stmt : bb.GetMeStmts()) {
+      // do not count decref operands
+      if (IsVarDecRefStmt(stmt)) {
+        continue;
+      }
+      // do not count the cleanup intrinsic
+      if (IsCleanUpStmt(stmt)) {
+        continue;
+      }
+      for (size_t i = 0; i < stmt.NumMeStmtOpnds(); i++) {
+        CHECK_FATAL(stmt.GetOpnd(i) != nullptr, "null mestmtopnd check");
+        CollectUsesInfo(*stmt.GetOpnd(i));
+      }
+      CollectDerefedOrCopied(stmt);
+    }
+  }
+}
+
+void DelegateRC::DelegateStmtRC() {
+  MeCFG *cfg = func.GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto &bb = **bIt;
+    for (auto &stmt : bb.GetMeStmts()) {
+      bool withDecref = false;
+      if (CanOmitRC4LHSVar(stmt, withDecref)) {
+        DelegateHandleNoRCStmt(stmt, withDecref);  // Form B
+      } else {
+        DelegateRCTemp(stmt);  // Form A
+      }
+    }
+  }
+}
+
+std::set<OStIdx> DelegateRC::RenameAndGetLiveLocalRefVar() {
+  std::set<OStIdx> liveLocalrefvars;
+  MeCFG *cfg = func.GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto &bb = **bIt;
+    for (auto &stmt : bb.GetMeStmts()) {
+      if (IsVarDecRefStmt(stmt)) {
+        continue;  // it is wrong to replace decref operand as it is intended for the original localrefvar
+      }
+      // no need process the cleanup intrinsic
+      if (IsCleanUpStmt(stmt)) {
+        continue;
+      }
+      for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+        CHECK_FATAL(stmt.GetOpnd(i) != nullptr, "null mestmtopnd check");
+        RenameDelegatedRefVarUses(stmt, *stmt.GetOpnd(i));
+      }
+      // for live_localrefvars
+      if (CheckOp(stmt, OP_dassign) || CheckOp(stmt, OP_maydassign)) {
+        ScalarMeExpr *lhs = stmt.GetVarLHS();
+        CHECK_FATAL(lhs != nullptr, "null ptr check");
+        const OriginalSt *ost = lhs->GetOst();
+        if (ost->IsLocal() && !ost->IsFormal() && !ost->IsIgnoreRC() && lhs->GetPrimType() == PTY_ref) {
+          (void)liveLocalrefvars.insert(lhs->GetOstIdx());
+        }
+      } else if (kOpcodeInfo.IsCallAssigned(stmt.GetOp())) {
+        MapleVector<MustDefMeNode> *mustdefList = stmt.GetMustDefList();
+        CHECK_NULL_FATAL(mustdefList);
+        if (mustdefList->empty()) {
+          continue;
+        }
+        MeExpr *theLhs = mustdefList->front().GetLHS();
+        if (theLhs->GetMeOp() == kMeOpVar && theLhs->GetPrimType() == PTY_ref) {
+          auto *varLhs = static_cast<VarMeExpr*>(theLhs);
+          const OriginalSt *ost = varLhs->GetOst();
+          if (ost->IsLocal() && !ost->IsFormal() && !ost->IsIgnoreRC()) {
+            (void)liveLocalrefvars.insert(ost->GetIndex());
+          }
+        }
+      }
+    }
+  }
+  return liveLocalrefvars;
+}
+
+void DelegateRC::CleanUpDeadLocalRefVar(const std::set<OStIdx> &liveLocalrefvars) {
+  MeCFG *cfg = func.GetCfg();
+  for (BB *bb : cfg->GetCommonExitBB()->GetPred()) {
+    auto &meStmts = bb->GetMeStmts();
+    if (meStmts.empty() || meStmts.back().GetOp() != OP_return) {
+      continue;
+    }
+    MeStmt *stmt = meStmts.back().GetPrev();
+    while (stmt != nullptr && stmt->GetOp() != OP_intrinsiccall) {
+      stmt = stmt->GetPrev();
+    }
+    if (stmt == nullptr) {
+      continue;
+    }
+    if (IsCleanUpStmt(*stmt)) {
+      continue;
+    }
+    // delete the operands that are not live
+    size_t nextPos = 0;
+    IntrinsiccallMeStmt *intrin = static_cast<IntrinsiccallMeStmt*>(stmt);
+    for (size_t i = 0; i < intrin->NumMeStmtOpnds(); ++i) {
+      auto *varMeExpr = static_cast<VarMeExpr*>(intrin->GetOpnd(i));
+      if (liveLocalrefvars.find(varMeExpr->GetOstIdx()) == liveLocalrefvars.end()) {
+        continue;
+      }
+      if (nextPos != i) {
+        intrin->SetOpnd(nextPos, varMeExpr);
+      }
+      ++nextPos;
+    }
+    intrin->EraseOpnds(intrin->GetOpnds().begin() + nextPos, intrin->GetOpnds().end());
+  }
+  if (func.GetHints() & kPlacementRCed) {  // delete decref if opnd not in livelocalrefvars
+    auto eIt = cfg->valid_end();
+    for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+      auto *bb = *bIt;
+      for (auto &stmt : bb->GetMeStmts()) {
+        if (stmt.GetOp() != OP_decrefreset) {
+          continue;
+        }
+        if (stmt.GetOpnd(0)->GetMeOp() != kMeOpAddrof) {
+          continue;
+        }
+        auto *varMeExpr = static_cast<AddrofMeExpr*>(stmt.GetOpnd(0));
+        const OriginalSt *ost = varMeExpr->GetOst();
+        CHECK_FATAL(ost, "ost is nullptr!");
+        if (ost->IsLocal() && !ost->IsFormal() && !ost->IsIgnoreRC() &&
+            liveLocalrefvars.find(varMeExpr->GetOstIdx()) == liveLocalrefvars.end()) {
+          bb->RemoveMeStmt(&stmt);
+        }
+      }
+    }
+  }
+}
+
+void MEDelegateRC::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEAliasClass>();
+  aDep.SetPreservedAll();
+}
+
+bool MEDelegateRC::PhaseRun(maple::MeFunction &f) {
+  static uint32 puCount = 0;
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto *dom = dominancePhase->GetDomResult();
+  ASSERT(dom != nullptr, "dominance construction has problem");
+  auto *pdom = dominancePhase->GetPdomResult();
+  ASSERT(pdom != nullptr, "postdominance construction has problem");
+
+  {
+    auto *aliasClass = GET_ANALYSIS(MEAliasClass, f);
+    auto *hdse = GetPhaseAllocator()->New<MeHDSE>(
+        f, *dom, *pdom, *f.GetIRMap(), aliasClass, DEBUGFUNC_NEWPM(f));
+    // invoke hdse to update isLive only
+    hdse->InvokeHDSEUpdateLive();
+  }
+
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << " Processing " << f.GetMirFunc()->GetName() << '\n';
+  }
+
+  DelegateRC delegaterc(f, *dom, GetPhaseMemPool(), DEBUGFUNC_NEWPM(f));
+  if (puCount > MeOption::delRcPULimit) {
+    ++puCount;
+    return false;
+  }
+  if (puCount == MeOption::delRcPULimit) {
+    LogInfo::MapleLogger() << f.GetMirFunc()->GetName()
+                           << " is last PU optimized by delegaterc under -delrcpulimit option" << '\n';
+  }
+  // first pass
+  delegaterc.SetCantDelegateAndCountUses();
+  // main pass
+  delegaterc.DelegateStmtRC();
+  // final pass: rename the uses of the delegated ref pointer variable versions;
+  // set live_localrefvars based on appearances on LHS
+  // to detect dead localrefvars
+  std::set<OStIdx> liveLocalRefVars = delegaterc.RenameAndGetLiveLocalRefVar();
+  // postpass: go through the cleanup intrinsics to delete dead localrefvars
+  delegaterc.CleanUpDeadLocalRefVar(liveLocalRefVars);
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== After DELEGATE RC =============" << '\n';
+    f.GetIRMap()->Dump();
+  }
+  ++puCount;
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_dominance.cpp b/src/mapleall/maple_me/src/me_dominance.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b59fcf817fe7b5ef2f5a8757b41aa1643523065b
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_dominance.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_dominance.h"
+#include <iostream>
+#include "me_option.h"
+#include "me_cfg.h"
+#include "base_graph_node.h"
+// This phase analyses the CFG of the given MeFunction, generates the dominator tree,
+// and the dominance frontiers of each basic block using Keith Cooper's algorithm.
+// For some backward data-flow problems, such as LiveOut,
+// the reverse CFG(The CFG with its edges reversed) is always useful,
+// so we also generates the above two structures on the reverse CFG.
+namespace maple {
+void MEDominance::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.SetPreservedAll();
+}
+
+bool MEDominance::PhaseRun(maple::MeFunction &f) {
+  MeCFG *cfg = f.GetCfg();
+  ASSERT_NOT_NULL(cfg);
+  MemPool *memPool = GetPhaseMemPool();
+  auto alloc = MapleAllocator(memPool);
+  auto nodeVec = memPool->New<MapleVector<BaseGraphNode*>>(alloc.Adapter());
+  CHECK_NULL_FATAL(nodeVec);
+  ConvertToVectorOfBasePtr<BB>(cfg->GetAllBBs(), *nodeVec);
+  dom = memPool->New<Dominance>(*memPool, *nodeVec, *cfg->GetCommonEntryBB(), *cfg->GetCommonExitBB(), false);
+  CHECK_NULL_FATAL(dom);
+  pdom = memPool->New<Dominance>(*memPool, *nodeVec, *cfg->GetCommonExitBB(), *cfg->GetCommonEntryBB(), true);
+  CHECK_NULL_FATAL(pdom);
+  dom->Init();
+  pdom->Init();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "-----------------Dump dominance info and postdominance info---------\n";
+    dom->DumpDoms();
+    pdom->DumpDoms();
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_dse.cpp b/src/mapleall/maple_me/src/me_dse.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a97bcc7204fb52a36b5f1a0a94ff54b921248f9a
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_dse.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_dse.h"
+
+#include <iostream>
+
+#include "me_phase_manager.h"
+
+namespace maple {
+
+MeDSE::MeDSE(MeFunction &func, Dominance *dom, Dominance *pdom, const AliasClass *aliasClass, bool enabledDebug)
+    : DSE(std::vector<BB *>(func.GetCfg()->GetAllBBs().begin(), func.GetCfg()->GetAllBBs().end()),
+          *func.GetCfg()->GetCommonEntryBB(), *func.GetCfg()->GetCommonExitBB(), *func.GetMeSSATab(), *dom, *pdom,
+          aliasClass, enabledDebug, MeOption::decoupleStatic, func.IsLfo()),
+      func(func),
+      cfg(func.GetCfg()) {}
+void MeDSE::VerifyPhi() const {
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == cfg->common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    if (bb->GetPhiList().empty()) {
+      continue;
+    }
+    size_t predBBNums = bb->GetPred().size();
+    for (auto &pair : std::as_const(bb->GetPhiList())) {
+      if (IsSymbolLived(*pair.second.GetResult())) {
+        if (predBBNums <= 1) {  // phi is live and non-virtual in bb with 0 or 1 pred
+          const OriginalSt *ost = func.GetMeSSATab()->GetOriginalStFromID(pair.first);
+          CHECK_FATAL(ost, "ost is nullptr!");
+          CHECK_FATAL(!ost->IsSymbolOst() || ost->GetIndirectLev() != 0,
+                      "phi is live and non-virtual in bb with zero or one pred");
+        } else if (pair.second.GetPhiOpnds().size() != predBBNums) {
+          ASSERT(false, "phi opnd num is not consistent with pred bb num(need update phi)");
+        }
+      }
+    }
+  }
+}
+
+void MeDSE::RunDSE() {
+  if (enableDebug) {
+    func.Dump(true);
+  }
+  DoDSE();
+
+  // remove unreached BB
+  (void)cfg->UnreachCodeAnalysis(true);
+  VerifyPhi();
+  if (enableDebug) {
+    func.Dump(true);
+  }
+}
+
+bool MEDse::PhaseRun(maple::MeFunction &f) {
+  if (f.dseRuns >= MeOption::dseRunsLimit) {
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "  == " << PhaseName() << " skipped\n";
+    }
+  } else {
+    auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+    auto dom = dominancePhase->GetDomResult();
+    CHECK_NULL_FATAL(dom);
+    auto pdom = dominancePhase->GetPdomResult();
+    CHECK_NULL_FATAL(pdom);
+    auto *aliasClass = GET_ANALYSIS(MEAliasClass, f);
+    CHECK_NULL_FATAL(aliasClass);
+    MeDSE dse(f, dom, pdom, aliasClass, DEBUGFUNC_NEWPM(f));
+    dse.RunDSE();
+    f.Verify();
+    // cfg change , invalid results in MeFuncResultMgr
+    if (dse.UpdatedCfg()) {
+      if (f.GetCfg()->UpdateCFGFreq()) {
+        f.GetCfg()->UpdateEdgeFreqWithBBFreq();
+        if (f.GetCfg()->DumpIRProfileFile()) {
+          f.GetCfg()->DumpToFile(("after-dse" + std::to_string(f.dseRuns)), false, true);
+        }
+      }
+      GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+    }
+  }
+  if (f.GetMIRModule().IsCModule() && MeOption::performFSAA) {
+    /* invoke FSAA */
+    GetAnalysisInfoHook()->ForceRunTransFormPhase<MeFuncOptTy, MeFunction>(&MEFSAA::id, f);
+  }
+  return false;
+}
+
+void MEDse::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEAliasClass>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_emit.cpp b/src/mapleall/maple_me/src/me_emit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..28d59e43145fcb5e65e35865e3c8432edc858170
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_emit.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_emit.h"
+#include <mutex>
+#include "mir_function.h"
+#include "thread_env.h"
+#include "me_bb_layout.h"
+#include "me_irmap.h"
+#include "me_cfg.h"
+#include "constantfold.h"
+#include "me_merge_stmts.h"
+
+namespace maple {
+void MEEmit::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEBBLayout>();
+  aDep.SetPreservedAll();
+}
+
+static void ResetDependentedSymbolLive(MIRConst *mirConst) {
+  if (mirConst == nullptr) {
+    return;
+  }
+
+  if (mirConst->GetKind() == kConstAddrof) {
+    auto stIdx = static_cast<MIRAddrofConst*>(mirConst)->GetSymbolIndex();
+    auto *usedSymbol = theMIRModule->GetMIRBuilder()->GetSymbolFromEnclosingScope(stIdx);
+    if (usedSymbol->IsDeleted()) {
+      usedSymbol->ResetIsDeleted();
+      if (usedSymbol->IsConst()) {
+        auto preConst = usedSymbol->GetKonst();
+        ResetDependentedSymbolLive(preConst);
+      }
+    }
+  } else if (mirConst->GetKind() == kConstAggConst) {
+    for (auto *fldCst : static_cast<MIRAggConst*>(mirConst)->GetConstVec()) {
+      ResetDependentedSymbolLive(fldCst);
+    }
+  }
+}
+
+void ResetDependentedSymbolLive(MIRFunction *func) {
+  for (size_t k = 1; k < func->GetSymTab()->GetSymbolTableSize(); ++k) {
+    MIRSymbol *sym = func->GetSymTab()->GetSymbolFromStIdx(k);
+    CHECK_FATAL(sym, "sym is nullptr!");
+    if (!sym->IsConst()) {
+      continue;
+    }
+    ResetDependentedSymbolLive(sym->GetKonst());
+  }
+}
+
+// emit IR to specified file
+bool MEEmit::PhaseRun(maple::MeFunction &f) {
+  static std::mutex mtx;
+  ParallelGuard guard(mtx, ThreadEnv::IsMeParallel());
+  if (f.GetCfg()->NumBBs() > 0) {
+    CHECK_FATAL(f.HasLaidOut(), "Check bb layout phase.");
+    // each phase need to keep either irmap or mirfunction is valid
+    if (f.GetIRMap()) {
+      if (MeOption::mergeStmts) {
+        MergeStmts mergeStmts(f);
+        mergeStmts.MergeMeStmts();
+      }
+      // emit after hssa
+      auto layoutBBs = f.GetLaidOutBBs();
+      MIRFunction *mirFunction = f.GetMirFunc();
+      mirFunction->ReleaseCodeMemory();
+      mirFunction->SetMemPool(new ThreadLocalMemPool(memPoolCtrler, "IR from IRMap::Emit()"));
+      mirFunction->SetBody(mirFunction->GetCodeMempool()->New<BlockNode>());
+      if (Options::profileUse && mirFunction->GetFuncProfData()) {
+        mirFunction->GetFuncProfData()->SetStmtFreq(mirFunction->GetBody()->GetStmtID(),
+            mirFunction->GetFuncProfData()->entryFreq);
+      }
+      // initialize is_deleted field to true; will reset when emitting Maple IR
+      for (size_t k = 1; k < mirFunction->GetSymTab()->GetSymbolTableSize(); ++k) {
+        MIRSymbol *sym = mirFunction->GetSymTab()->GetSymbolFromStIdx(k);
+        CHECK_FATAL(sym, "sym is nullptr!");
+        if (sym->GetSKind() == kStVar) {
+          sym->SetIsDeleted();
+        }
+      }
+      // the formal symbol should be reserved for mplbc mode
+      for (FormalDef formalDef : mirFunction->GetFormalDefVec()) {
+        if (formalDef.formalSym != nullptr) {
+          // in case of __built_va_start functions, whose formalSym are nullptr
+          formalDef.formalSym->ResetIsDeleted();
+        }
+      }
+      for (BB *bb : layoutBBs) {
+        ASSERT(bb != nullptr, "Check bblayout phase");
+        bb->EmitBB(*mirFunction->GetBody(), false);
+        if (bb->IsEmpty()) {
+          continue;
+        }
+        auto &lastStmt = bb->GetStmtNodes().back();
+        auto &firstStmt = bb->GetStmtNodes().front();
+        f.GetMirFunc()->SetFirstFreqMap(firstStmt.GetStmtID(), bb->GetFrequency());
+        f.GetMirFunc()->SetLastFreqMap(lastStmt.GetStmtID(), bb->GetFrequency());
+      }
+      ResetDependentedSymbolLive(mirFunction);
+
+      bool dumpFreq = MeOption::dumpFunc == f.GetName();
+      if (dumpFreq && f.GetMirFunc()->HasFreqMap()) {
+        auto &freqMap = f.GetMirFunc()->GetLastFreqMap();
+        LogInfo::MapleLogger() << "Dump freqMap:" << std::endl;
+        for (BB *bb : layoutBBs) {
+          if (!bb->GetStmtNodes().empty()) {
+            auto &lastStmt = bb->GetStmtNodes().back();
+            auto it = freqMap.find(lastStmt.GetStmtID());
+            if (it != freqMap.end()) {
+              LogInfo::MapleLogger() << "BB" << bb->GetBBId() << ", freq: " << it->second << std::endl;
+            }
+          }
+        }
+      }
+    } else {
+      // emit from mir function body
+      f.EmitBeforeHSSA((*(f.GetMirFunc())), f.GetLaidOutBBs());
+    }
+    if (!DEBUGFUNC_NEWPM(f) && f.GetIRMap()) {
+      // constantfolding does not update BB's stmtNodeList, which breaks MirCFG::DumpToFile();
+      // constantfolding also cannot work on SSANode's
+      auto config = ConstantFold::CFConfig { !f.GetMIRModule().IsJavaModule() };
+      ConstantFold cf(f.GetMIRModule(), config);
+      (void)cf.Simplify(f.GetMirFunc()->GetBody());
+    }
+    if (DEBUGFUNC_NEWPM(f)) {
+      LogInfo::MapleLogger() << "\n==============after meemit =============" << '\n';
+      f.GetMirFunc()->Dump();
+    }
+    if (DEBUGFUNC_NEWPM(f)) {
+      f.GetCfg()->DumpToFile("meemit", true);
+    }
+  }
+  return false;
+}
+
+void ProfileGenEmit::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.SetPreservedAll();
+}
+
+// emit IR for profileGen
+bool ProfileGenEmit::PhaseRun(maple::MeFunction &f) {
+  if (f.GetCfg()->NumBBs() > 0) {
+    CHECK_FATAL(f.GetIRMap(), "sanity check");
+    // emit after hssa
+    MIRFunction *mirFunction = f.GetMirFunc();
+    mirFunction->ReleaseCodeMemory();
+    mirFunction->SetMemPool(new ThreadLocalMemPool(memPoolCtrler, "IR from IRMap::Emit()"));
+    mirFunction->SetBody(mirFunction->GetCodeMempool()->New<BlockNode>());
+    // initialize is_deleted field to true; will reset when emitting Maple IR
+    for (size_t k = 1; k < mirFunction->GetSymTab()->GetSymbolTableSize(); ++k) {
+      MIRSymbol *sym = mirFunction->GetSymTab()->GetSymbolFromStIdx(static_cast<uint32>(k));
+      if (sym->GetSKind() == kStVar) {
+        sym->SetIsDeleted();
+      }
+    }
+    for (BB *bb : f.GetCfg()->GetAllBBs()) {
+      if (bb == nullptr) {
+        continue;
+      }
+      bb->EmitBB(*mirFunction->GetBody(), false);
+    }
+    ResetDependentedSymbolLive(mirFunction);
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_fsaa.cpp b/src/mapleall/maple_me/src/me_fsaa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..15aef4b6b01391e0b819494571982040f93323e9
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_fsaa.cpp
@@ -0,0 +1,390 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_fsaa.h"
+#include "me_ssa.h"
+#include "ssa_mir_nodes.h"
+#include "me_option.h"
+
+// The FSAA phase performs flow-sensitive alias analysis.  This is flow
+// sensitive because, based on the SSA that has been constructed, it is
+// possible to look up the assigned value of pointers.  It focuses only on
+// using known assigned pointer values to fine-tune the aliased items at
+// iassign statements.  When the base of an iassign statements has an assigned
+// value that is unique (i.e. of known value or is pointing to read-only
+// memory), it will go through the maydefs attached to the iassign statement to
+// trim away any whose base cannot possibly be the same value as the base's
+// assigned value.  When any mayDef has bee deleted, the SSA form of the
+// function will be updated by re-running only the SSA rename step, so as to
+// maintain the correctness of the SSA form.
+
+using namespace std;
+
+namespace maple {
+namespace {
+// return a VersionSt that can represent expr exactly
+const VersionSt *GetVersionStFromExpr(const BaseNode *expr) {
+  // SSAVar of addrof expr is the address-taken symbol, can not represent addrof express exactly
+  if (expr == nullptr || !expr->IsSSANode() || expr->GetOpCode() == OP_addrof) {
+    return nullptr;
+  }
+  return static_cast<const SSANode *>(expr)->GetSSAVar();
+}
+
+// tracking def-chain to find the original def-expr
+const BaseNode *GetOriginalDefExpr(const VersionSt &vst) {
+  const BaseNode *rhs = nullptr;
+  const VersionSt *rhsVst = &vst;
+  while (rhsVst != nullptr && rhsVst->GetDefType() == VersionSt::kAssign) {
+    const StmtNode *defStmt = rhsVst->GetAssignNode();
+    rhs = defStmt->GetRHS();
+    rhsVst = GetVersionStFromExpr(rhs);
+  }
+  return rhs;
+}
+
+// overload version, if expr has no VersionSt, return expr itself.
+const BaseNode &GetOriginalDefExpr(const BaseNode &expr) {
+  const VersionSt *vst = GetVersionStFromExpr(&expr);
+  if (vst == nullptr) {
+    return expr;
+  }
+  const BaseNode *res = GetOriginalDefExpr(*vst);
+  return res == nullptr ? expr : *res;
+}
+
+// find stmt which vst is attached to.
+const StmtNode *GetVstDefStmt(const VersionSt *vst) {
+  if (vst == nullptr) {
+    return nullptr;
+  }
+  VersionSt::DefType defType = vst->GetDefType();
+  switch (defType) {
+    case VersionSt::kAssign:
+      return vst->GetAssignNode();
+    case VersionSt::kMayDef:
+      return vst->GetMayDef()->GetStmt();
+    case VersionSt::kMustDef:
+      return vst->GetMustDef()->GetStmt();
+    case VersionSt::kUnknown:
+    case VersionSt::kPhi:
+      return nullptr;
+    default:
+      CHECK_FATAL(false, "DefType is not supported yet!");
+  }
+}
+
+bool HasSameContent(const BaseNode *exprA, const BaseNode *exprB) {
+  if (exprA == nullptr || exprB == nullptr) {
+    return false;
+  }
+  if (exprA == exprB) {
+    return true;
+  }
+  Opcode opA = exprA->GetOpCode();
+  Opcode opB = exprB->GetOpCode();
+  PrimType ptypA = exprA->GetPrimType();
+  PrimType ptypB = exprB->GetPrimType();
+  size_t opndNumA = exprA->NumOpnds();
+  size_t opndNumB = exprB->NumOpnds();
+  if (opA != opB || ptypA != ptypB || opndNumA != opndNumB) {
+    return false;
+  }
+  if (opA == OP_constval || opA == OP_addrof || opA == OP_addroffunc || opA == OP_addroflabel) {
+    return exprA->IsSameContent(exprB);
+  }
+  const VersionSt *vstA = GetVersionStFromExpr(exprA);
+  const VersionSt *vstB = GetVersionStFromExpr(exprB);
+  if (vstA != nullptr || vstB != nullptr) {
+    return (vstA == vstB);
+  }
+  if (exprA->IsLeaf()) {
+    return false;
+  }
+  for (size_t i = 0; i < opndNumA; ++i) {
+    if (!HasSameContent(exprA->Opnd(i), exprB->Opnd(i))) {
+      return false;
+    }
+  }
+  return exprA->IsSameContent(exprB);
+}
+
+// if vstA and vstB are(or may be) defined by the same stmt.
+bool DefinedBySameStmt(const VersionSt *vstA, const VersionSt *vstB) {
+  if (vstA == nullptr || vstB == nullptr) {
+    return false;
+  }
+  const StmtNode *stmtA = GetVstDefStmt(vstA);
+  const StmtNode *stmtB = GetVstDefStmt(vstB);
+  return (stmtA != nullptr && stmtA == stmtB);
+}
+
+// if iread and maydef represent the same memory.
+bool AccessSameMemory(const IreadSSANode &iread, const MayDefNode &maydef) {
+  const VersionSt *ireadVst = GetVersionStFromExpr(&iread);
+  // no need for nullptr check for ireadVst here
+  OffsetType ireadOffset = ireadVst->GetOst()->GetOffset();
+  if (ireadOffset.IsInvalid()) {
+    return false; // if offset is not valid, memory represented by iread is not exact, we process it conservatively.
+  }
+  const BaseNode &base = GetOriginalDefExpr(*iread.Opnd(0));
+  OriginalSt *aliasOst = maydef.GetOpnd()->GetOst();
+  if (base.GetOpCode() == OP_addrof) {
+    // base is addrof, we can just compare their symbol
+    // case 1 : iread fld1 (addrof fld2 a) <=> a{fld1 + fld2}
+    auto &addrofBase = static_cast<const AddrofSSANode &>(base);
+    if (aliasOst->GetIndirectLev() == 0 && aliasOst->IsSymbolOst() &&
+        aliasOst->GetMIRSymbol()->GetStIdx() == addrofBase.GetStIdx() &&
+        aliasOst->GetOffset() == ireadOffset &&
+        aliasOst->GetType() == static_cast<IreadNode*>(const_cast<IreadSSANode&>(iread).GetNoSSANode())->GetType() &&
+        aliasOst->GetFieldID() == addrofBase.GetFieldID() + iread.GetFieldID()) {
+      return true;
+    }
+  }
+  // case 2: tracking def-chain of MayDef's base to find def-expr
+  VersionSt *aliasBaseVst = maydef.base;
+  if (aliasBaseVst == nullptr || aliasOst->GetFieldID() != iread.GetFieldID() ||
+      ireadOffset != aliasOst->GetOffset()) { // iread represents a different memory from MayDef if offset differs
+    return false;
+  }
+  const BaseNode *aliasBaseOrigSrc = GetOriginalDefExpr(*aliasBaseVst);
+  return HasSameContent(aliasBaseOrigSrc, &base);
+}
+} // anonymous namespace
+
+// if the pointer represented by vst is found to have a unique pointer value,
+// return the BB of the definition
+BB *FSAA::FindUniquePointerValueDefBB(VersionSt *vst) {
+  if (vst->IsInitVersion()) {
+    return nullptr;
+  }
+  if (vst->GetDefType() != VersionSt::kAssign) {
+    return nullptr;
+  }
+  UnaryStmtNode *ass = static_cast<UnaryStmtNode *>(vst->GetAssignNode());
+  BaseNode *rhs = ass->Opnd(0);
+
+  if (rhs->GetOpCode() == OP_malloc || rhs->GetOpCode() == OP_gcmalloc || rhs->GetOpCode() == OP_gcpermalloc ||
+      rhs->GetOpCode() == OP_gcmallocjarray || rhs->GetOpCode() == OP_alloca) {
+    return vst->GetDefBB();
+  } else if (rhs->GetOpCode() == OP_dread) {
+    AddrofSSANode *dread = static_cast<AddrofSSANode *>(rhs);
+    OriginalSt *ost = dread->GetSSAVar()->GetOst();
+    if (ost->GetMIRSymbol()->IsLiteralPtr() || (ost->IsFinal() && !ost->IsLocal())) {
+      return vst->GetDefBB();
+    } else {  // rhs is another pointer; call recursively for its rhs
+      return FindUniquePointerValueDefBB(dread->GetSSAVar());
+    }
+  } else if (rhs->GetOpCode() == OP_iread) {
+    if (func->GetMirFunc()->IsConstructor() || func->GetMirFunc()->IsStatic() ||
+        func->GetMirFunc()->GetFormalDefVec().empty()) {
+      return nullptr;
+    }
+    // check if rhs is reading a final field thru this
+    IreadSSANode *iread = static_cast<IreadSSANode *>(rhs);
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx());
+    MIRType *pointedty = static_cast<MIRPtrType *>(ty)->GetPointedType();
+    if (pointedty->GetKind() == kTypeClass &&
+        static_cast<MIRStructType *>(pointedty)->IsFieldFinal(iread->GetFieldID()) &&
+        iread->Opnd(0)->GetOpCode() == OP_dread) {
+      AddrofSSANode *basedread = static_cast<AddrofSSANode *>(iread->Opnd(0));
+      MIRSymbol *mirst = basedread->GetSSAVar()->GetOst()->GetMIRSymbol();
+      if (mirst == func->GetMirFunc()->GetFormal(0)) {
+        return vst->GetDefBB();
+      }
+    }
+    return nullptr;
+  }
+  return nullptr;
+}
+
+// remove item specified by it and update it
+void FSAA::EraseMayDefItem(TypeOfMayDefList &mayDefNodes, MapleMap<OStIdx, MayDefNode>::iterator &it,
+                           bool canBeErased) {
+  if (canBeErased) {
+    it = mayDefNodes.erase(it);
+    needUpdateSSA = true;
+  } else {
+    ++it;
+  }
+}
+
+bool FSAA::IfChiSameAsRHS(const VersionSt &chiOpnd, const VersionSt &rhsVst, const BaseNode &rhsOrigSrc) {
+  bool isSame = (rhsVst.GetIndex()  == chiOpnd.GetIndex());
+  if (!isSame) {
+    const BaseNode *aliasOrigSrc = GetOriginalDefExpr(chiOpnd);
+    isSame = HasSameContent(aliasOrigSrc, &rhsOrigSrc);
+  }
+  return isSame;
+}
+// For iread, we first track the def-chain of RHS and every MayDef to find their original define expr.
+// If they have the same original value, we can remove the MayDef. Otherwise, we track def-chain of
+// their base. If they have the same base, and they also read the same field/offset of this base,
+// they are the same exactly, so we can also remove this MayDef from MayDefList.
+void FSAA::RemoveMayDefByIreadRHS(const IreadSSANode &rhs, TypeOfMayDefList &mayDefNodes) {
+  const VersionSt *rhsVst = GetVersionStFromExpr(&rhs);
+  OffsetType rhsOffset = rhsVst->GetOst()->GetOffset();
+  // N.B. one ost may corresponding to more than one expr, like : both array[i], array[i + n] has ost array{offset:Und}
+  // Even only one expr is found, a ost may represent a serious of memory, like : array index expr in a for loop
+  if (rhsOffset.IsInvalid()) {
+    return;
+  }
+  const BaseNode &rhsOrigSrc = GetOriginalDefExpr(rhs);
+  for (auto it = mayDefNodes.begin(); it != mayDefNodes.end();) {
+    VersionSt *aliasVst = it->second.GetOpnd();
+    // step 1: check if MayDef is the same as iread Vst
+    // step 2: check if MayDef's base is the same as iread's base
+    bool canBeErased = IfChiSameAsRHS(*aliasVst, *rhsVst, rhsOrigSrc) || AccessSameMemory(rhs, it->second);
+    EraseMayDefItem(mayDefNodes, it, canBeErased); // will update iterator
+  }
+}
+
+// For dread, we will first track the def-chain of RHS and every MayDef to find the original define expr.
+// If they have the same def-exprs, we can remove the MayDef. Otherwise, if the def-expr of rhs is an
+// iread expr, we will double check this iread expr like what we do for iread expr. That is to compare if
+// iread's base is the same as MayDef's.
+void FSAA::RemoveMayDefByDreadRHS(const AddrofSSANode &rhs, TypeOfMayDefList &mayDefNodes) {
+  const VersionSt *rhsVst = GetVersionStFromExpr(&rhs);
+  const BaseNode &rhsOrigSrc = GetOriginalDefExpr(rhs);
+  for (auto it = mayDefNodes.begin(); it != mayDefNodes.end();) {
+    // step 1: check if MayDef has the same value as rhs.
+    MayDefNode maydef = it->second;
+    const VersionSt *aliasVst = maydef.GetOpnd();
+    bool canBeErased = IfChiSameAsRHS(*aliasVst, *rhsVst, rhsOrigSrc);
+    // step 2: rhs is equivalent to an iread expr, check if it has the same base as MayDef's.
+    // only if step 1 is not true and def-epxr of rhs is an iread expr, will step 2 be processed.
+    if (!canBeErased && rhsOrigSrc.GetOpCode() == OP_iread) {
+      bool sameMemory =
+          AccessSameMemory(static_cast<const IreadSSANode &>(rhsOrigSrc), maydef);
+      // Notice that memory version may be changed even if its base keep the same.
+      // Example:
+      // 1: baseB <- baseA
+      // 2: rhs <- iread baseA
+      // 3: iassign (baseA/baseB, ...)
+      // 4: iassign (lhs, rhs) MayDef(baseB<1>)
+      // We can not remove MayDef(baseB<1>) because its version is changed by line3 although baseB is not changed.
+      const VersionSt *rhsOrigVst = GetVersionStFromExpr(&rhsOrigSrc);
+      // no need to nullptr check for rhsOrigVst here
+      bool isMemNotModified = (rhsOrigVst->IsInitVersion() && it->second.GetOpnd()->IsInitVersion()) ||
+          DefinedBySameStmt(maydef.GetOpnd(), rhsOrigVst);
+      canBeErased = sameMemory && isMemNotModified;
+    }
+    EraseMayDefItem(mayDefNodes, it, canBeErased);
+  }
+}
+
+// Only for type-safe : iassign (lhs, rhs),
+// If the MayDef is the same as rhs, then operation 'rhs -> lhs' will never change the MayDef's value.
+// Case 1: The MayDef is not alias with lhs actually, then apparently, iassign will never change the MayDef.
+// Case 2: The MayDef is alias with lhs, their memories overlap completely(not partially). Storing rhs to
+//         lhs will update the MayDef's value, but the value is the same as before.
+// Therefore, for typesafe, we can delete this MayDef from MayDefList.
+void FSAA::RemoveMayDefIfSameAsRHS(const IassignNode &stmt) {
+  if (!MeOption::tbaa) {
+    return; // type-safe constraint is not valid, do nothing
+  }
+  BaseNode *rhs = stmt.GetRHS();
+  TypeOfMayDefList &mayDefNodes = ssaTab->GetStmtsSSAPart().GetMayDefNodesOf(stmt);
+  MIRType *lhsType = stmt.GetLHSType();
+  if (rhs->GetOpCode() == OP_iread) {
+    // type size is not the same, can not overlap completely
+    if (lhsType->GetSize() != static_cast<IreadSSANode *>(rhs)->GetSSAVar()->GetOst()->GetType()->GetSize()) {
+      return;
+    }
+    RemoveMayDefByIreadRHS(static_cast<IreadSSANode &>(*rhs), mayDefNodes);
+  } else if (rhs->GetOpCode() == OP_dread) {
+    // type size is not the same, can not overlap completely
+    if (lhsType->GetSize() != static_cast<AddrofSSANode *>(rhs)->GetSSAVar()->GetOst()->GetType()->GetSize()) {
+      return;
+    }
+    RemoveMayDefByDreadRHS(static_cast<AddrofSSANode &>(*rhs), mayDefNodes);
+  }
+}
+
+void FSAA::ProcessBB(BB *bb) {
+  auto &stmtNodes = bb->GetStmtNodes();
+  for (auto itStmt = stmtNodes.begin(); itStmt != stmtNodes.rbegin().base(); ++itStmt) {
+    if (itStmt->GetOpCode() != OP_iassign) {
+      continue;
+    }
+    IassignNode &iass = static_cast<IassignNode &>(*itStmt);
+    RemoveMayDefIfSameAsRHS(iass);
+    VersionSt *vst = nullptr;
+    if (iass.addrExpr->GetOpCode() == OP_dread) {
+      vst = static_cast<AddrofSSANode *>(iass.addrExpr)->GetSSAVar();
+    } else if (iass.addrExpr->GetOpCode() == OP_regread) {
+      vst = static_cast<RegreadSSANode *>(iass.addrExpr)->GetSSAVar();
+    } else {
+      break;
+    }
+
+    BB *defBB = FindUniquePointerValueDefBB(vst);
+    if (defBB != nullptr) {
+      if (DEBUGFUNC(func)) {
+        LogInfo::MapleLogger() << "FSAA finds unique pointer value def\n";
+      }
+      // delete any maydefnode in the list that is defined before defBB
+      TypeOfMayDefList &mayDefNodes = ssaTab->GetStmtsSSAPart().GetMayDefNodesOf(*itStmt);
+      for (auto it = mayDefNodes.begin(); it != mayDefNodes.end();) {
+        bool canBeErased = false;
+        if (it->second.base != nullptr) {
+          BB *aliasedDefBB = it->second.base->GetDefBB();
+          if (aliasedDefBB == nullptr) {
+            canBeErased = true;
+          } else {
+            canBeErased = defBB != aliasedDefBB && dom->Dominate(*aliasedDefBB, *defBB);
+          }
+        }
+        EraseMayDefItem(mayDefNodes, it, canBeErased);
+      }
+    }
+  }
+}
+
+bool MEFSAA::PhaseRun(MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  auto *ssaTab = GET_ANALYSIS(MESSATab, f);
+  CHECK_NULL_FATAL(ssaTab);
+  auto *ssa = GET_ANALYSIS(MESSA, f);
+  CHECK_NULL_FATAL(ssa);
+
+  FSAA fsaa(&f, dom);
+  auto cfg = f.GetCfg();
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb != nullptr) {
+      fsaa.ProcessBB(bb);
+    }
+  }
+
+  if (fsaa.needUpdateSSA) {
+    ssa->runRenameOnly = true;
+    ssa->UpdateDom(dom); // dom info may be set invalid in dse when cfg is modified
+    ssa->RenameAllBBs(cfg);
+    ssa->VerifySSA();
+
+    if (DEBUGFUNC_NEWPM(f)) {
+      f.DumpFunction();
+    }
+  }
+  return false;
+}
+
+void MEFSAA::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MESSATab>();
+  aDep.AddRequired<MESSA>();
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_func_opt.cpp b/src/mapleall/maple_me/src/me_func_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..81bdf22acfd0a723193b0db87b6cbb7fc2f83031
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_func_opt.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_func_opt.h"
+#include "thread_env.h"
+
+namespace maple {
+#ifdef NOT_USED
+thread_local std::unique_ptr<MeFuncOptExecutor> MeFuncOptScheduler::funcOptLocal;
+
+int MeFuncOptTask::RunImpl(MplTaskParam *param) {
+  module.SetCurFunction(&mirFunc);
+  auto *optExe = static_cast<MeFuncOptExecutor*>(param);
+  CHECK_NULL_FATAL(optExe);
+  optExe->ProcessRun(mirFunc, rangeNum, meInput);
+  return 0;
+}
+
+std::unique_ptr<MeFuncOptExecutor> MeFuncOptExecutor::Clone() const {
+  // thread local memPoolCtrler and fpm
+  auto threadLocalCtrler = std::make_unique<MemPoolCtrler>();
+  auto *memPool = threadLocalCtrler->NewMemPool("thread local func opt mempool", true /* isLcalPool */);
+  MeFuncPhaseManager &fpmCopy = fpm.Clone(*memPool, *threadLocalCtrler);
+  auto copy = std::make_unique<MeFuncOptExecutor>(std::move(threadLocalCtrler), fpmCopy);
+  return copy;
+}
+
+void MeFuncOptExecutor::ProcessRun(MIRFunction &mirFunc, size_t rangeNum, const std::string &meInput) {
+  fpm.Run(&mirFunc, rangeNum, meInput, *mpCtrler);
+}
+
+void MeFuncOptScheduler::CallbackThreadMainStart() {
+  ThreadEnv::InitThreadIndex(std::this_thread::get_id());
+  funcOptLocal = funcOpt->Clone();
+}
+
+void MeFuncOptScheduler::CallbackThreadMainEnd() {
+  funcOptLocal = nullptr;
+}
+
+MplTaskParam *MeFuncOptScheduler::CallbackGetTaskRunParam() const {
+  return funcOptLocal.get();
+}
+
+MplTaskParam *MeFuncOptScheduler::CallbackGetTaskFinishParam() const {
+  return funcOptLocal.get();
+}
+
+void MeFuncOptScheduler::AddFuncOptTask(MIRModule &module, MIRFunction &mirFunc,
+                                        size_t rangeNum, const std::string &meInput) {
+  std::unique_ptr<MeFuncOptTask> task = std::make_unique<MeFuncOptTask>(module, mirFunc, rangeNum, meInput);
+  AddTask(task.get());
+  tasksUniquePtr.emplace_back(std::move(task));
+}
+#endif
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_function.cpp b/src/mapleall/maple_me/src/me_function.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f3567fe2d7ada2cf77287e9fe766902fe08ab168
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_function.cpp
@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_function.h"
+#include <iostream>
+#include <functional>
+#include "ssa_mir_nodes.h"
+#include "me_cfg.h"
+#include "mir_lower.h"
+#include "mir_builder.h"
+#include "constantfold.h"
+#include "me_irmap.h"
+#include "pme_mir_lower.h"
+#include "me_ssa_update.h"
+
+namespace maple {
+#if DEBUG
+MIRModule *globalMIRModule = nullptr;
+MeFunction *globalFunc = nullptr;
+MeIRMap *globalIRMap = nullptr;
+SSATab *globalSSATab = nullptr;
+#endif
+void MeFunction::PartialInit() {
+  theCFG = nullptr;
+  irmap = nullptr;
+  regNum = 0;
+  hasEH = false;
+  ConstantFold cf(mirModule);
+  (void)cf.Simplify(mirFunc->GetBody());
+  if (mirModule.IsJavaModule() && (!mirFunc->GetInfoVector().empty())) {
+    std::string string("INFO_registers");
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(string);
+    regNum = mirFunc->GetInfo(strIdx);
+    std::string tryNum("INFO_tries_size");
+    strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(tryNum);
+    uint32 num = mirFunc->GetInfo(strIdx);
+    hasEH = (num != 0);
+  }
+}
+
+void MeFunction::Release() {
+  ReleaseVersMemory();
+  if (preMeMp) {
+    memPoolCtrler.DeleteMemPool(preMeMp);
+  }
+  preMeMp = nullptr;
+}
+
+void MeFunction::DumpFunction() const {
+  if (theCFG == nullptr) {
+    mirFunc->Dump(false);
+    return;
+  }
+  if (meSSATab == nullptr) {
+    LogInfo::MapleLogger() << "no ssa info, just dump simpfunction\n";
+    DumpFunctionNoSSA();
+    return;
+  }
+  auto eIt = theCFG->valid_end();
+  for (auto bIt = theCFG->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    bb->DumpHeader(&mirModule);
+    for (auto &phiPair : bb->GetPhiList()) {
+      phiPair.second.Dump();
+    }
+    for (auto &stmt : bb->GetStmtNodes()) {
+      GenericSSAPrint(mirModule, stmt, 1, meSSATab->GetStmtsSSAPart());
+    }
+  }
+}
+
+void MeFunction::DumpFunctionNoSSA() const {
+  if (theCFG == nullptr) {
+    LogInfo::MapleLogger()  << "Warning: no cfg analysis, just dump ir" << '\n';
+    mirFunc->Dump();
+    return;
+  }
+  auto eIt = theCFG->valid_end();
+  for (auto bIt = theCFG->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    bb->DumpHeader(&mirModule);
+    for (auto &phiPair : bb->GetPhiList()) {
+      phiPair.second.Dump();
+    }
+    for (auto &stmt : bb->GetStmtNodes()) {
+      stmt.Dump(1);
+    }
+  }
+}
+
+void MeFunction::DumpMayDUFunction() const {
+  auto eIt = theCFG->valid_end();
+  for (auto bIt = theCFG->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    bb->DumpHeader(&mirModule);
+    bool skipStmt = false;
+    CHECK_FATAL(meSSATab != nullptr, "meSSATab is null");
+    for (auto &stmt : bb->GetStmtNodes()) {
+      if (meSSATab->GetStmtsSSAPart().HasMayDef(stmt) || HasMayUseOpnd(stmt, *meSSATab) ||
+          kOpcodeInfo.NotPure(stmt.GetOpCode())) {
+        if (skipStmt) {
+          mirModule.GetOut() << "......\n";
+        }
+        GenericSSAPrint(mirModule, stmt, 1, meSSATab->GetStmtsSSAPart());
+        skipStmt = false;
+      } else {
+        skipStmt = true;
+      }
+    }
+    if (skipStmt) {
+      mirModule.GetOut() << "......\n";
+    }
+  }
+}
+
+void MeFunction::Dump(bool DumpSimpIr) const {
+  LogInfo::MapleLogger() << ">>>>> Dump IR for Function " << mirFunc->GetName() << "<<<<<\n";
+  if (irmap == nullptr || DumpSimpIr) {
+    LogInfo::MapleLogger() << "no ssa or irmap info, just dump simp function\n";
+    DumpFunction();
+    return;
+  }
+  auto eIt = theCFG->valid_end();
+  for (auto bIt = theCFG->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    bb->DumpHeader(&mirModule);
+    bb->DumpMePhiList(irmap);
+    for (auto &meStmt : bb->GetMeStmts()) {
+      meStmt.Dump(irmap);
+    }
+  }
+}
+
+void MeFunction::IPAPrepare() {
+  MemPool* pmemp = memPoolCtrler.NewMemPool("ipapme", true);
+  SetPreMeFunc(pmemp->New<PreMeFunction>(pmemp, this));
+  SetPmeMempool(pmemp);
+  isPme = true;
+  PreMeMIRLower pmemirlowerer(mirModule, this);
+  pmemirlowerer.LowerFunc(*CurFunction());
+}
+
+void MeFunction::Prepare() {
+  // the restriction need to be removed after opt enhanced
+  bool lfoRestricted = MeOption::boundaryCheckMode != SafetyCheckMode::kNoCheck;
+  if (MeOption::enableLFO && mirModule.IsCModule() && !lfoRestricted) {
+    MemPool* pmemp = memPoolCtrler.NewMemPool("lfo", true);
+    SetPreMeFunc(pmemp->New<PreMeFunction>(pmemp, this));
+    SetPmeMempool(pmemp);
+    isPme = true;
+    isLfo = true;
+    PreMeMIRLower pmemirlowerer(mirModule, this);
+    pmemirlowerer.LowerFunc(*CurFunction());
+  } else {
+    /* lower first */
+    MIRLower mirLowerer(mirModule, CurFunction());
+    mirLowerer.Init();
+    mirLowerer.SetLowerME();
+    mirLowerer.SetOptLevel(MeOption::optLevel);
+    if (mirModule.IsJavaModule()) {
+      mirLowerer.SetLowerExpandArray();
+    }
+    ASSERT(CurFunction() != nullptr, "nullptr check");
+    mirLowerer.LowerFunc(*CurFunction());
+  }
+}
+
+void MeFunction::Verify() const {
+  CHECK_FATAL(theCFG != nullptr, "theCFG is null");
+  theCFG->Verify();
+  theCFG->VerifyLabels();
+}
+
+/* create label for bb */
+LabelIdx MeFunction::GetOrCreateBBLabel(BB &bb) {
+  LabelIdx label = bb.GetBBLabel();
+  if (label != 0) {
+    return label;
+  }
+  label = mirModule.CurFunction()->GetLabelTab()->CreateLabelWithPrefix('m');
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(label);
+  bb.SetBBLabel(label);
+  theCFG->SetLabelBBAt(label, &bb);
+  return label;
+}
+
+namespace {
+// Clone ChiList from srcStmt to destStmt
+void CloneChiListOfStmt(MeStmt &srcStmt, MeStmt &destStmt, MeIRMap &irmap,
+                        std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *ssaCands = nullptr) {
+  const MapleMap<OStIdx, ChiMeNode*> *srcChiList = srcStmt.GetChiList();
+  MapleMap<OStIdx, ChiMeNode*> *destChiList = destStmt.GetChiList();
+  if (srcChiList == nullptr || destChiList == nullptr || !destChiList->empty()) {
+    return;
+  }
+  const BB &newBB = *destStmt.GetBB();
+  for (auto &chiNode : *srcChiList) {
+    CHECK_FATAL(chiNode.first == chiNode.second->GetLHS()->GetOstIdx(), "must be");
+    VarMeExpr *newMul = irmap.CreateVarMeExprVersion(chiNode.second->GetLHS()->GetOst());
+    MeSSAUpdate::InsertOstToSSACands(newMul->GetOstIdx(), newBB, ssaCands);
+    auto *newChiNode = irmap.New<ChiMeNode>(&destStmt);
+    newMul->SetDefChi(*newChiNode);
+    newMul->SetDefBy(kDefByChi);
+    newChiNode->SetLHS(newMul);
+    newChiNode->SetRHS(chiNode.second->GetRHS());
+    destChiList->emplace(chiNode.first, newChiNode);
+  }
+}
+
+// Clone MustDefList from srcStmt to destStmt
+void CloneMustDefListOfStmt(MeStmt &srcStmt, MeStmt &destStmt, MeIRMap &irmap,
+                            std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *ssaCands = nullptr) {
+  const MapleVector<MustDefMeNode> *srcMustDef = srcStmt.GetMustDefList();
+  MapleVector<MustDefMeNode> *destMustDef = destStmt.GetMustDefList();
+  if (srcMustDef == nullptr || destMustDef == nullptr || !destMustDef->empty()) {
+    return;
+  }
+  const BB &newBB = *destStmt.GetBB();
+  for (auto &mustDefNode : *srcMustDef) {
+    const ScalarMeExpr *oldLHS = mustDefNode.GetLHS();
+    ScalarMeExpr *newLHS = irmap.CreateRegOrVarMeExprVersion(oldLHS->GetOstIdx());
+    newLHS->SetDefBy(kDefByMustDef);
+    MeSSAUpdate::InsertOstToSSACands(newLHS->GetOstIdx(), newBB, ssaCands);
+    auto *mustDef = irmap.New<MustDefMeNode>(newLHS, &destStmt);
+    newLHS->SetDefMustDef(*mustDef);
+    destMustDef->push_back(*mustDef);
+  }
+}
+} // anonymous namespace
+
+// clone MeStmts from srcBB to destBB, and collect new version to ssaCands which is used for ssa-updater
+// if ssaCands is nullptr, no new version will be collected.
+void MeFunction::CloneBBMeStmts(BB &srcBB, BB &destBB, std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *ssaCands,
+                                bool copyWithoutLastMe) {
+  if (irmap == nullptr) {
+    return;
+  }
+  for (auto &stmt : srcBB.GetMeStmts()) {
+    if (copyWithoutLastMe && &stmt == srcBB.GetLastMe()) {
+      break;
+    }
+    MeStmt *newStmt = nullptr;
+    switch (stmt.GetOp()) {
+      case OP_dassign:
+      case OP_regassign: {
+        ScalarMeExpr *scalarLHS = stmt.GetLHS();
+        ScalarMeExpr *newVerLHS = irmap->CreateRegOrVarMeExprVersion(scalarLHS->GetOstIdx());
+        MeSSAUpdate::InsertOstToSSACands(newVerLHS->GetOstIdx(), destBB, ssaCands);
+        newStmt = irmap->CreateAssignMeStmt(*newVerLHS, *stmt.GetRHS(), destBB);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_iassign: {
+        auto *iassStmt = static_cast<IassignMeStmt*>(&stmt);
+        IvarMeExpr *ivar = irmap->BuildLHSIvarFromIassMeStmt(*iassStmt);
+        newStmt = irmap->NewInPool<IassignMeStmt>(
+            iassStmt->GetTyIdx(), *static_cast<IvarMeExpr*>(ivar), *iassStmt->GetRHS());
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_maydassign: {
+        auto &maydassStmt = static_cast<MaydassignMeStmt&>(stmt);
+        newStmt = irmap->NewInPool<MaydassignMeStmt>(maydassStmt);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_goto: {
+        auto &gotoStmt = static_cast<GotoMeStmt&>(stmt);
+        newStmt = irmap->New<GotoMeStmt>(gotoStmt);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_brfalse:
+      case OP_brtrue: {
+        auto &condGotoStmt = static_cast<CondGotoMeStmt&>(stmt);
+        newStmt = irmap->New<CondGotoMeStmt>(condGotoStmt);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_switch: {
+        auto &switchStmt = static_cast<SwitchMeStmt&>(stmt);
+        newStmt = irmap->New<SwitchMeStmt>(switchStmt);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_intrinsiccall:
+      case OP_intrinsiccallassigned:
+      case OP_intrinsiccallwithtypeassigned:
+      case OP_intrinsiccallwithtype: {
+        auto *intrnStmt = static_cast<IntrinsiccallMeStmt*>(&stmt);
+        newStmt =
+            irmap->NewInPool<IntrinsiccallMeStmt>(static_cast<const NaryMeStmt*>(intrnStmt), intrnStmt->GetIntrinsic(),
+                                                  intrnStmt->GetTyIdx(), intrnStmt->GetReturnPrimType());
+        for (auto &mu : std::as_const(*intrnStmt->GetMuList())) {
+          newStmt->GetMuList()->emplace(mu.first, mu.second);
+        }
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_icall:
+      case OP_icallassigned:
+      case OP_icallproto:
+      case OP_icallprotoassigned: {
+        auto *icallStmt = static_cast<IcallMeStmt*>(&stmt);
+        newStmt = irmap->NewInPool<IcallMeStmt>(static_cast<NaryMeStmt*>(icallStmt),
+                                                icallStmt->GetRetTyIdx(), icallStmt->GetStmtID());
+        for (auto &mu : std::as_const(*icallStmt->GetMuList())) {
+          newStmt->GetMuList()->emplace(mu.first, mu.second);
+        }
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_asm: {
+        auto *asmStmt = static_cast<AsmMeStmt*>(&stmt);
+        newStmt = irmap->NewInPool<AsmMeStmt>(asmStmt);
+        for (auto &mu : std::as_const(*asmStmt->GetMuList())) {
+          newStmt->GetMuList()->emplace(mu.first, mu.second);
+        }
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_call:
+      case OP_callassigned:
+      case OP_virtualcallassigned:
+      case OP_virtualicallassigned:
+      case OP_interfacecallassigned:
+      case OP_interfaceicallassigned: {
+        auto *callStmt = static_cast<CallMeStmt*>(&stmt);
+        newStmt =
+            irmap->NewInPool<CallMeStmt>(static_cast<NaryMeStmt*>(callStmt), callStmt->GetPUIdx());
+        for (auto &mu : std::as_const(*callStmt->GetMuList())) {
+          newStmt->GetMuList()->emplace(mu.first, mu.second);
+        }
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_returnassertnonnull:
+      case OP_assertnonnull:
+      case OP_assignassertnonnull: {
+        auto &unaryStmt = static_cast<AssertNonnullMeStmt&>(stmt);
+        newStmt = irmap->New<AssertNonnullMeStmt>(unaryStmt);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_callassertnonnull: {
+        auto &callAssertStmt = static_cast<CallAssertNonnullMeStmt&>(stmt);
+        newStmt = irmap->New<CallAssertNonnullMeStmt>(callAssertStmt);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_membaracquire:
+      case OP_membarrelease:
+      case OP_membarstoreload:
+      case OP_membarstorestore: {
+        newStmt = irmap->New<MeStmt>(stmt.GetOp());
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_eval: {
+        newStmt = irmap->New<UnaryMeStmt>(static_cast<UnaryMeStmt&>(stmt));
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_incref:
+      case OP_decref:
+      case OP_decrefreset: {
+        auto &unaryStmt = static_cast<UnaryMeStmt&>(stmt);
+        newStmt = irmap->New<UnaryMeStmt>(static_cast<UnaryMeStmt&>(stmt));
+        if (unaryStmt.GetMuList() != nullptr) {
+          for (auto &mu : std::as_const(*unaryStmt.GetMuList())) {
+            newStmt->GetMuList()->emplace(mu.first, mu.second);
+          }
+        }
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_comment: {
+        break;
+      }
+      case OP_callassertle:{
+        auto &oldStmt = static_cast<CallAssertBoundaryMeStmt&>(stmt);
+        newStmt = irmap->New<CallAssertBoundaryMeStmt>(oldStmt);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_calcassertge:
+      case OP_calcassertlt:
+      case OP_assignassertle:
+      case OP_assertlt:
+      case OP_assertge:
+      case OP_returnassertle: {
+        auto &oldStmt = static_cast<AssertBoundaryMeStmt&>(stmt);
+        newStmt = irmap->New<AssertBoundaryMeStmt>(oldStmt);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      case OP_return: {
+        auto &oldStmt = static_cast<RetMeStmt&>(stmt);
+        newStmt = irmap->New<RetMeStmt>(oldStmt);
+        destBB.AddMeStmtLast(newStmt);
+        break;
+      }
+      default:
+        LogInfo::MapleLogger() << "stmt with op :"<< stmt.GetOp() << " is not implemented yet\n";
+        CHECK_FATAL(false, "NYI");
+        break;
+    }
+    if (stmt.GetChiList() != nullptr) {
+      CloneChiListOfStmt(stmt, *newStmt, *irmap, ssaCands);
+    }
+    if (stmt.GetMustDefList() != nullptr) {
+      CloneMustDefListOfStmt(stmt, *newStmt, *irmap, ssaCands);
+    }
+    if (newStmt != nullptr) {
+      newStmt->CopyInfo(stmt);
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_gc_lowering.cpp b/src/mapleall/maple_me/src/me_gc_lowering.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..216c405c09d63f2f83c20ef2c0b8afe7df116fa1
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_gc_lowering.cpp
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_gc_lowering.h"
+#include <cstring>
+
+// GCLowering phase generate GC intrinsic for reference assignment
+// based on previous analyze results. GC intrinsic will later be lowered
+// in Code Generation
+namespace maple {
+void GCLowering::Prepare() {
+  isReferent = func.GetMirFunc()->GetName() == "Ljava_2Flang_2Fref_2FReference_3B_7C_3Cinit_3E_7C_"
+                                               "28Ljava_2Flang_2FObject_3BLjava_2Flang_2Fref_2FReferenceQueue_3B_29V";
+  // preparation steps before going through basicblocks
+  MIRFunction *mirFunction = func.GetMirFunc();
+  size_t tableSize = mirFunction->GetSymTab()->GetSymbolTableSize();
+  for (size_t i = 0; i < tableSize; ++i) {
+    MIRSymbol *sym = mirFunction->GetSymTab()->GetSymbolFromStIdx(i);
+    if (sym != nullptr && sym->GetStorageClass() == kScAuto) {
+      MIRType *type = sym->GetType();
+      if (type != nullptr && type->GetPrimType() == PTY_ref) {
+        sym->SetLocalRefVar();
+      }
+    }
+  }
+}
+
+void GCLowering::GCLower() {
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    GCLower(**bIt);
+  }
+}
+
+void GCLowering::Finish() {
+  CheckRefs();
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "\n============== After GC LOWERING =============" << '\n';
+    func.Dump(false);
+  }
+}
+
+void GCLowering::GCLower(BB &bb) {
+  for (auto &stmt : bb.GetMeStmts()) {
+    if (stmt.IsAssign()) {
+      HandleAssignMeStmt(stmt);
+    }
+  }
+}
+
+void GCLowering::HandleAssignMeStmt(MeStmt &stmt) {
+  MeExpr *lhs = stmt.GetLHSRef(false);
+  if (lhs == nullptr) {
+    return;
+  }
+  if (lhs->GetMeOp() == kMeOpVar) {
+    HandleVarAssignMeStmt(stmt);
+  } else if (lhs->GetMeOp() == kMeOpIvar) {
+    HandleIvarAssignMeStmt(stmt);
+  }
+}
+
+void GCLowering::HandleVarAssignMeStmt(MeStmt &stmt) {
+  VarMeExpr *lhsVar = static_cast<VarMeExpr *>(stmt.GetVarLHS());
+  ASSERT_NOT_NULL(lhsVar);
+  MIRSymbol *lSym = ssaTab.GetMIRSymbolFromID(lhsVar->GetOstIdx());
+  if (lSym == nullptr || !lSym->IsGlobal()) {
+    return;
+  }
+  std::vector<MeExpr*> opnds = { irMap.CreateAddrofMeExpr(*lhsVar), stmt.GetRHS() };
+  MeStmt *writeRefCall = irMap.CreateIntrinsicCallMeStmt(SelectWriteBarrier(stmt), opnds);
+  stmt.GetBB()->ReplaceMeStmt(&stmt, writeRefCall);
+}
+
+MIRIntrinsicID GCLowering::SelectWriteBarrier(const MeStmt &stmt) {
+  MeExpr *lhs = nullptr;
+  if (stmt.GetOp() == OP_dassign) {
+    lhs = stmt.GetLHS();
+  } else if (stmt.GetOp() == OP_iassign) {
+    lhs = static_cast<const IassignMeStmt&>(stmt).GetLHSVal();
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  CHECK_NULL_FATAL(lhs);
+  MeExprOp meOp = lhs->GetMeOp();
+  CHECK_FATAL((meOp == kMeOpVar || meOp == kMeOpIvar), "Not Expected meOp");
+  if (lhs->IsVolatile()) {
+    return PrepareVolatileCall(stmt, meOp == kMeOpVar ? INTRN_MCCWriteSVol : INTRN_MCCWriteVol);
+  }
+  return meOp == kMeOpVar ? INTRN_MCCWriteS : INTRN_MCCWrite;
+}
+
+static void CheckRemove(MeStmt *stmt, Opcode op) {
+  if (stmt != nullptr && stmt->GetOp() == op) {
+    stmt->GetBB()->RemoveMeStmt(stmt);
+  }
+}
+
+MIRIntrinsicID GCLowering::PrepareVolatileCall(const MeStmt &stmt, MIRIntrinsicID intrnId) {
+  CheckRemove(stmt.GetPrev(), OP_membarrelease);
+  CheckRemove(stmt.GetNext(), OP_membarstoreload);
+  return intrnId;
+}
+
+void GCLowering::HandleIvarAssignMeStmt(MeStmt &stmt) {
+  auto &iAssignStmt = static_cast<IassignMeStmt&>(stmt);
+  HandleWriteReferent(iAssignStmt);
+  IvarMeExpr *lhsInner = iAssignStmt.GetLHSVal();
+  MeExpr *base = GetBase(*lhsInner);
+  std::vector<MeExpr*> opnds = { &(base->GetAddrExprBase()),
+                                 irMap.CreateAddrofMeExpr(*lhsInner), stmt.GetRHS() };
+  MeStmt *writeRefCall = irMap.CreateIntrinsicCallMeStmt(SelectWriteBarrier(stmt), opnds);
+  stmt.GetBB()->ReplaceMeStmt(&stmt, writeRefCall);
+}
+
+MeExpr *GCLowering::GetBase(IvarMeExpr &ivar) {
+  MeExpr *base = ivar.GetBase();
+  CHECK_NULL_FATAL(base);
+  if (!Options::buildApp || ivar.GetFieldID() != 0 || base->GetMeOp() != kMeOpReg) {
+    return base;
+  }
+  MeExpr *expr = base;
+  while (expr->GetMeOp() == kMeOpReg) {
+    auto *reg = static_cast<RegMeExpr*>(expr);
+    if (reg->GetDefBy() != kDefByStmt) {
+      break;
+    }
+    expr = reg->GetDefStmt()->GetRHS();
+    CHECK_NULL_FATAL(expr);
+  }
+  if (expr->GetOp() != OP_add) {
+    return base;
+  }
+  while (expr->GetOpnd(0)->GetOp() == OP_add) {
+    expr = expr->GetOpnd(0);
+    ASSERT_NOT_NULL(expr);
+  }
+  if (expr->GetMeOp() == kMeOpNary) {
+    auto *naryExp = static_cast<NaryMeExpr*>(expr);
+    MIRIntrinsicID intrinID = naryExp->GetIntrinsic();
+    if (intrinID == INTRN_MPL_READ_OVTABLE_ENTRY ||
+        intrinID == INTRN_MPL_READ_OVTABLE_ENTRY2 ||
+        intrinID == INTRN_MPL_READ_OVTABLE_ENTRY_LAZY ||
+        intrinID == INTRN_MPL_READ_OVTABLE_ENTRY_VTAB_LAZY ||
+        intrinID == INTRN_MPL_READ_OVTABLE_ENTRY_FIELD_LAZY) {
+      return expr->GetOpnd(0);
+    }
+  }
+  return base;
+}
+
+void GCLowering::HandleWriteReferent(IassignMeStmt &stmt) {
+  if (!isReferent) {
+    return;
+  }
+  IvarMeExpr *lhsInner = stmt.GetLHSVal();
+  MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsInner->GetTyIdx());
+  MIRType *ptype = utils::ToRef(safe_cast<MIRPtrType>(baseType)).GetPointedType();
+  FieldID id = mirModule.GetMIRBuilder()->GetStructFieldIDFromFieldNameParentFirst(ptype, "referent");
+  if (id != lhsInner->GetFieldID()) {
+    return;
+  }
+  CheckRemove(stmt.GetNext(), OP_membarstoreload);
+  std::vector<MeExpr*> opnds = { &(lhsInner->GetBase()->GetAddrExprBase()), stmt.GetRHS() };
+  MeStmt *writeReferentCall = irMap.CreateIntrinsicCallMeStmt(INTRN_MCCWriteReferent, opnds);
+  stmt.GetBB()->InsertMeStmtAfter(&stmt, writeReferentCall);
+}
+
+// DFX Support:
+// traverse all statement, and add MCCGCCheck for each ref
+// Formals of type ref
+// LHS of type ref in assign
+// return value of type ref
+void GCLowering::CheckRefs() {
+  auto theCFG = func.GetCfg();
+  ParseCheckFlag();
+  if (checkRefFormal) {
+    CheckFormals();
+  }
+  for (BB *bb : theCFG->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    if (checkRefAssign) {
+      CheckRefsInAssignStmt(*bb);
+    }
+    if (checkRefReturn) {
+      CheckRefReturn(*bb);
+    }
+  }
+}
+
+void GCLowering::ParseCheckFlag() {
+  if (MeOption::checkRefUsedInFuncs.find(func.GetName()) != MeOption::checkRefUsedInFuncs.end() ||
+      MeOption::checkRefUsedInFuncs.find("ALL") != MeOption::checkRefUsedInFuncs.end() ||
+      MeOption::checkRefUsedInFuncs.find("*") != MeOption::checkRefUsedInFuncs.end()) {
+    checkRefFormal = true;
+    checkRefAssign = true;
+    checkRefReturn = true;
+  } else {
+    if (MeOption::checkRefUsedInFuncs.find("FORMAL") != MeOption::checkRefUsedInFuncs.end()) {
+      checkRefFormal = true;
+    }
+    if (MeOption::checkRefUsedInFuncs.find("ASSIGN") != MeOption::checkRefUsedInFuncs.end()) {
+      checkRefAssign = true;
+    }
+    if (MeOption::checkRefUsedInFuncs.find("RETURN") != MeOption::checkRefUsedInFuncs.end()) {
+      checkRefReturn = true;
+    }
+  }
+}
+
+void GCLowering::CheckFormals() {
+  MIRFunction *mirFunc = func.GetMirFunc();
+  if (mirFunc->IsEmpty()) {
+    return;
+  }
+
+  BB *firstBB = func.GetCfg()->GetFirstBB();
+  for (size_t i = 0; i < mirFunc->GetFormalCount(); ++i) {
+    MIRSymbol *formalSt = mirFunc->GetFormal(i);
+    if (formalSt == nullptr || formalSt->GetType()->GetPrimType() != PTY_ref) {
+      continue;
+    }
+    OriginalSt *ost = ssaTab.FindOrCreateSymbolOriginalSt(*formalSt, func.GetMirFunc()->GetPuidx(), 0);
+    MeExpr *argVar = irMap.GetOrCreateZeroVersionVarMeExpr(*ost);
+    std::vector<MeExpr*> opnds = { argVar };
+    IntrinsiccallMeStmt *checkCall = irMap.CreateIntrinsicCallMeStmt(INTRN_MCCGCCheck, opnds);
+    firstBB->AddMeStmtFirst(checkCall);
+  }
+}
+
+void GCLowering::CheckRefsInAssignStmt(BB &bb) {
+  for (MeStmt &stmt : bb.GetMeStmts()) {
+    if (!stmt.IsAssign()) {
+      continue;
+    }
+    MeExpr *lhs = stmt.GetLHS();
+    CHECK_NULL_FATAL(lhs);
+    if (lhs->GetPrimType() != PTY_ref && lhs->GetPrimType() != PTY_ptr) {
+      continue;
+    }
+    std::vector<MeExpr*> opnds = { lhs };
+    IntrinsiccallMeStmt *checkCall = irMap.CreateIntrinsicCallMeStmt(INTRN_MCCGCCheck, opnds);
+    bb.InsertMeStmtAfter(&stmt, checkCall);
+  }
+}
+
+void GCLowering::CheckRefReturn(BB &bb) {
+  if (bb.GetKind() != kBBReturn) {
+    return;
+  }
+  MeStmt *lastMeStmt = to_ptr(bb.GetMeStmts().rbegin());
+  if (lastMeStmt == nullptr || lastMeStmt->GetOp() != OP_return || lastMeStmt->NumMeStmtOpnds() == 0) {
+    return;
+  }
+  MeExpr* ret = lastMeStmt->GetOpnd(0);
+  if (ret->GetPrimType() != PTY_ref && ret->GetPrimType() != PTY_ptr) {
+    return;
+  }
+  std::vector<MeExpr*> opnds = { ret };
+  IntrinsiccallMeStmt *checkCall = irMap.CreateIntrinsicCallMeStmt(INTRN_MCCGCCheck, opnds);
+  bb.InsertMeStmtBefore(lastMeStmt, checkCall);
+}
+
+void MEGCLowering::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MEGCLowering::PhaseRun(maple::MeFunction &f) {
+  CHECK_NULL_FATAL((GET_ANALYSIS(MEIRMapBuild, f)));
+
+  GCLowering gcLowering(f, DEBUGFUNC_NEWPM(f));
+  gcLowering.Prepare();
+  gcLowering.GCLower();
+  gcLowering.Finish();
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_gc_write_barrier_opt.cpp b/src/mapleall/maple_me/src/me_gc_write_barrier_opt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..93b236dbc0c2ccc99dac89cc28e0775ca06cf32b
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_gc_write_barrier_opt.cpp
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_gc_write_barrier_opt.h"
+#include "dominance.h"
+
+// GCWriteBarrierOpt phase generate GC intrinsic for reference assignment
+// based on previous analyze results. GC intrinsic will later be lowered
+// in Code Generation
+namespace maple {
+#ifdef NOT_USED
+AnalysisResult *MeDoGCWriteBarrierOpt::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr*) {
+  Dominance *dom = static_cast<Dominance*>(funcResMgr->GetAnalysisResult(MeFuncPhase_DOMINANCE, func));
+  CHECK_FATAL(dom != nullptr, "dominance phase has problem");
+
+  GCWriteBarrierOpt gcWriteBarrierOpt(*func, *dom, DEBUGFUNC(func));
+  gcWriteBarrierOpt.Prepare();
+  std::map<OStIdx, std::vector<MeStmt*>> writeBarrierMap;
+  BB *entryBB = func->GetCfg()->GetCommonEntryBB();
+  gcWriteBarrierOpt.GCLower(*entryBB, writeBarrierMap);
+  gcWriteBarrierOpt.Finish();
+  return nullptr;
+}
+#endif
+
+void GCWriteBarrierOpt::Prepare() {
+  callBBs.resize(func.GetCfg()->NumBBs());
+  visited.resize(func.GetCfg()->NumBBs());
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "\n============== Before GC WRITE BARRIER OPT =============" << '\n';
+    func.Dump(false);
+  }
+}
+
+void GCWriteBarrierOpt::GCLower(BB &bb, std::map<OStIdx, std::vector<MeStmt*>> &writeBarrierMap) {
+  // to record stack size
+  std::map<OStIdx, size_t> savedStacksize;
+  for (const auto &item : writeBarrierMap) {
+    savedStacksize[item.first] = item.second.size();
+  }
+  for (auto &stmt : bb.GetMeStmts()) {
+    if (!visited[bb.GetBBId()] && IsCall(stmt)) {
+      callBBs[bb.GetBBId()] = true;
+      visited[bb.GetBBId()] = true;
+    }
+    if (IsWriteBarrier(stmt)) {
+      IntrinsiccallMeStmt &intrinsicCall = static_cast<IntrinsiccallMeStmt&>(stmt);
+      MeExpr *opnd = intrinsicCall.GetOpnd(0);
+      OStIdx ostIdx = GetOStIdx(*opnd);
+      CHECK_FATAL(ostIdx != 0u, "ostIdx is not expected.");
+      std::vector<MeStmt*> &stmtVec = writeBarrierMap[ostIdx];
+      if (stmtVec.empty()) {
+        stmtVec.push_back(&stmt);
+        callBBs[bb.GetBBId()] = true;
+      } else {
+        MeStmt *start = stmtVec.back();
+        if (!HasYieldPoint(*start, stmt)) {
+          ResetMeStmt(intrinsicCall);
+        } else {
+          stmtVec.push_back(&stmt);
+          callBBs[bb.GetBBId()] = true;
+        }
+      }
+    }
+  }
+  visited[bb.GetBBId()] = true;
+  const auto &domChildren = dominance.GetDomChildren(bb.GetID());
+  for (const auto &childBBId : domChildren) {
+    BB *child = func.GetCfg()->GetBBFromID(BBId(childBBId));
+    if (child == nullptr) {
+      continue;
+    }
+    GCLower(*child, writeBarrierMap);
+  }
+  // restore the stacks to their size at entry to this function invocation
+  for (auto &item : writeBarrierMap) {
+    size_t lastSize = savedStacksize[item.first];
+    while (item.second.size() > lastSize) {
+      item.second.pop_back();
+    }
+  }
+}
+
+bool GCWriteBarrierOpt::IsWriteBarrier(const MeStmt &stmt) const {
+  if (stmt.GetOp() != OP_intrinsiccall) {
+    return false;
+  }
+  const IntrinsiccallMeStmt &intrinsicCall = static_cast<const IntrinsiccallMeStmt&>(stmt);
+  MIRIntrinsicID id = intrinsicCall.GetIntrinsic();
+  return id == INTRN_MCCWriteS || id == INTRN_MCCWrite;
+}
+
+void GCWriteBarrierOpt::ResetMeStmt(IntrinsiccallMeStmt &stmt) {
+  MeStmt *meStmt = nullptr;
+  MeExpr *rhs = stmt.GetOpnds().back();
+  if (stmt.GetIntrinsic() == INTRN_MCCWrite) {
+    OpMeExpr *opnd = static_cast<OpMeExpr*>(stmt.GetOpnd(1));
+    IvarMeExpr *ivar = irMap.BuildLHSIvar(*opnd->GetOpnd(0), opnd->GetPrimType(),
+                                          opnd->GetTyIdx(), opnd->GetFieldID());
+    MapleMap<OStIdx, ChiMeNode*> *chiList = stmt.GetChiList();
+    meStmt = irMap.CreateIassignMeStmt(opnd->GetTyIdx(), *ivar, *rhs, *chiList);
+  } else {
+    ScalarMeExpr *lhs = static_cast<ScalarMeExpr *>(stmt.GetOpnds().front());
+    if (lhs->GetMeOp() == kMeOpReg) {
+      meStmt = irMap.CreateAssignMeStmt(*lhs, *rhs, *stmt.GetBB());
+    } else {
+      CHECK_FATAL((lhs->GetMeOp() == kMeOpVar && stmt.GetIntrinsic() == INTRN_MCCWriteS), "Not Expected.");
+      auto *ost = ssaTab.GetOriginalStFromID(GetOStIdx(*lhs));
+      VarMeExpr *lhsVar = irMap.GetOrCreateZeroVersionVarMeExpr(*ost);
+      meStmt = irMap.CreateAssignMeStmt(*lhsVar, *rhs, *stmt.GetBB());
+    }
+  }
+  stmt.GetBB()->ReplaceMeStmt(&stmt, meStmt);
+}
+
+OStIdx GCWriteBarrierOpt::GetOStIdx(MeExpr &meExpr) {
+  MeExprOp meOp = meExpr.GetMeOp();
+  switch (meOp) {
+    case kMeOpAddrof:
+      return (static_cast<AddrofMeExpr&>(meExpr)).GetOstIdx();
+    case kMeOpVar:
+      return (static_cast<VarMeExpr &>(meExpr)).GetOstIdx();
+    case kMeOpReg:
+      return (static_cast<RegMeExpr &>(meExpr)).GetOstIdx();
+    case kMeOpIvar:
+      return GetOStIdx(*((static_cast<IvarMeExpr&>(meExpr)).GetBase()));
+    default:
+      CHECK_FATAL(meOp == kMeOpReg, "MeOp is not expected.");
+      break;
+  }
+  return OStIdx(0);
+}
+
+bool GCWriteBarrierOpt::IsCall(const MeStmt &stmt) const {
+  return kOpcodeInfo.IsCall(stmt.GetOp()) && !IsWriteBarrier(stmt);
+}
+
+bool GCWriteBarrierOpt::HasYieldPoint(const MeStmt &start, const MeStmt &end) {
+  const BB *startBB = start.GetBB();
+  const BB *endBB = end.GetBB();
+  if (startBB == endBB) {
+    return HasCallBetweenStmt(start, end);
+  }
+  if (!dominance.Dominate(*startBB, *endBB)) {
+    return true;
+  }
+  if (HasCallAfterStmt(start) || HasCallBeforeStmt(end) || IsBackEdgeDest(*endBB)) {
+    return true;
+  }
+  const auto &domChildren = dominance.GetDomChildren(startBB->GetID());
+  const auto pdomChildren = postDominance.GetDomChildren(endBB->GetID());
+  const MapleVector<BB*> bbVec = func.GetCfg()->GetAllBBs();
+  for (const auto &childBBId : domChildren) {
+    if (std::find(pdomChildren.begin(), pdomChildren.end(), childBBId) == pdomChildren.end()) {
+      continue;
+    }
+    BB *bb = bbVec.at(childBBId);
+    if (bb == nullptr) {
+      continue;
+    }
+    if (IsBackEdgeDest(*bb)) {
+      return true;
+    }
+    if (HasCallInBB(*bb)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool GCWriteBarrierOpt::HasCallAfterStmt(const MeStmt &stmt) {
+  const MeStmt &lastMeStmt = stmt.GetBB()->GetMeStmts().back();
+  return HasCallBetweenStmt(stmt, lastMeStmt);
+}
+
+bool GCWriteBarrierOpt::HasCallBeforeStmt(const MeStmt &stmt) {
+  const MeStmt &firstMeStmt = stmt.GetBB()->GetMeStmts().front();
+  return HasCallBetweenStmt(firstMeStmt, stmt);
+}
+
+bool GCWriteBarrierOpt::HasCallBetweenStmt(const MeStmt &start, const MeStmt &end) {
+  CHECK_FATAL(start.GetBB() == end.GetBB(), "NYI.");
+  for (const MeStmt *meStmt = &start; meStmt != &end; meStmt = meStmt->GetNext()) {
+    if (IsCall(*meStmt)) {
+      return true;
+    }
+  }
+  return IsCall(end);
+}
+
+bool GCWriteBarrierOpt::IsBackEdgeDest(const BB &bb) {
+  for (BB *pred : bb.GetPred()) {
+    if (dominance.Dominate(bb, *pred)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool GCWriteBarrierOpt::HasCallInBB(const BB &bb) {
+  BBId id = bb.GetBBId();
+  if (callBBs.at(id)) {
+    return true;
+  } else if (visited.at(id)) {
+    return false;
+  }
+  for (auto &stmt : bb.GetMeStmts()) {
+    if (IsCall(stmt)) {
+      callBBs[id] = true;
+      visited[id] = true;
+      return true;
+    }
+  }
+  visited[id] = true;
+  return false;
+}
+
+void GCWriteBarrierOpt::Finish() {
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "\n============== After GC WRITE BARRIER OPT =============" << '\n';
+    func.Dump(false);
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_hdse.cpp b/src/mapleall/maple_me/src/me_hdse.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..36f999e256006c2e639a851470162bbb55a9fc61
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_hdse.cpp
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_hdse.h"
+
+#include <iostream>
+
+#include "hdse.h"
+#include "me_ssa.h"
+#include "ssa_mir_nodes.h"
+#include "ver_symbol.h"
+
+// The hdse phase performs dead store elimination using the well-known algorithm
+// based on SSA.  The algorithm works as follows:
+// 0. Initially, assume all stmts and expressions are not needed.
+// 1. In a pass over the program, mark stmts that cannot be deleted as needed.
+//    These include return/eh/call statements and assignments to volatile fields
+//    and variables.  Expressions used by needed statements are put into a
+//    worklist.
+// 2. Process each node in the worklist. For any variable used in expression,
+//    mark the def stmt for the variable as needed and push expressions used
+//    by the def stmt to the worklist.
+// 3. When the worklist becomes empty, perform a pass over the program to delete
+//    statements that have not been marked as needed.
+//
+// The backward substitution optimization is also performed in this phase by
+// piggy-backing on Step 3.  In the pass over the program in Step 3, it counts
+// the number of uses for each variable version.  It also create a list of
+// backward substitution candidates, which are dassign statements of the form:
+//              x_i = y_j
+// where x is a local variable with no alias, and y_j is defined via the return
+// value of a call which is in the same BB.  Then,
+// 4. For each backward substitution candidate x_i = y_j, if the use count of y_j
+//    is 1, then replace the return value definition of y_j by x_i, and delete
+//    the statement x_i = y_j.
+// Before the hdse phase finishes, it performs 2 additional optimizations:
+// 5. When earlier deletion caused a try block to become empty, delete the empty
+//    try block while fixing up the CFG.
+// 6. Perform unreacble code analysis, delete the BBs found unreachable and fix
+//    up the CFG.
+
+namespace maple {
+// mark initExpr in whileinfo live
+void MeHDSE::ProcessWhileInfos() {
+  PreMeFunction *preMeFunc = func.GetPreMeFunc();
+  if (preMeFunc == nullptr) {
+    return;
+  }
+  MapleMap<LabelIdx, PreMeWhileInfo*>::iterator it = preMeFunc->label2WhileInfo.begin();
+  for (; it != preMeFunc->label2WhileInfo.end(); ++it) {
+    if (it->second->initExpr != nullptr &&
+        (it->second->initExpr->GetMeOp() == maple::kMeOpVar || it->second->initExpr->GetMeOp() == maple::kMeOpReg)) {
+      workList.push_front(it->second->initExpr);
+    }
+  }
+}
+
+void MeHDSE::BackwardSubstitution() {
+  for (DassignMeStmt *dass : std::as_const(backSubsCands)) {
+    ScalarMeExpr *rhsscalar = static_cast<ScalarMeExpr*>(dass->GetRHS());
+    if (verstUseCounts[rhsscalar->GetVstIdx()] != 1) {
+      continue;
+    }
+    ScalarMeExpr *lhsscalar = dass->GetLHS();
+    // check that lhsscalar has no use after rhsscalar's definition
+    CHECK_FATAL(rhsscalar->GetDefBy() == kDefByMustDef, "MeHDSE::BackwardSubstitution: rhs not defined by mustDef");
+    MustDefMeNode *mustDef = &rhsscalar->GetDefMustDef();
+    MeStmt *defStmt = mustDef->GetBase();
+    bool hasAppearance = false;
+    MeStmt *curstmt = dass->GetPrev();
+    while (curstmt != defStmt && !hasAppearance) {
+      for (uint32 i = 0; i < curstmt->NumMeStmtOpnds(); ++i) {
+        if (curstmt->GetOpnd(i)->SymAppears(lhsscalar->GetOst()->GetIndex())) {
+          hasAppearance = true;
+        }
+      }
+      curstmt = curstmt->GetPrev();
+    }
+    if (hasAppearance) {
+      continue;
+    }
+    // perform the backward substitution
+    if (hdseDebug) {
+      LogInfo::MapleLogger() << "------ hdse backward substitution deletes this stmt: ";
+      dass->Dump(&irMap);
+    }
+    mustDef->UpdateLHS(*lhsscalar);
+    dass->GetBB()->RemoveMeStmt(dass);
+  }
+}
+
+void MakeEmptyTrysUnreachable(MeFunction &func) {
+  auto cfg = func.GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    BB *tryBB = *bIt;
+    // get next valid bb
+    auto endTryIt = bIt;
+    if (++endTryIt == eIt) {
+      break;
+    }
+    BB *endTry = *endTryIt;
+    auto &meStmts = tryBB->GetMeStmts();
+    if (tryBB->GetAttributes(kBBAttrIsTry) && !meStmts.empty() && meStmts.front().GetOp() == OP_try &&
+        tryBB->GetMePhiList().empty() && endTry->GetAttributes(kBBAttrIsTryEnd) && endTry->IsMeStmtEmpty()) {
+      // we found a try BB followed by an empty endtry BB
+      BB *targetBB = endTry->GetSucc(0);
+      while (!tryBB->GetPred().empty()) {
+        auto *tryPred = tryBB->GetPred(0);
+        // update targetbb's predecessors
+        if (!tryPred->IsPredBB(*targetBB)) {
+          ASSERT(endTry->IsPredBB(*targetBB), "MakeEmptyTrysUnreachable: processing error");
+          for (size_t k = 0; k < targetBB->GetPred().size(); ++k) {
+            if (targetBB->GetPred(k) == endTry) {
+              // push additional phi operand for each phi at targetbb
+              auto phiIter = targetBB->GetMePhiList().begin();
+              for (; phiIter != targetBB->GetMePhiList().end(); ++phiIter) {
+                MePhiNode *meVarPhi = phiIter->second;
+                meVarPhi->GetOpnds().push_back(meVarPhi->GetOpnds()[k]);
+              }
+            }
+          }
+        }
+        // replace tryBB in the pred's succ list by targetbb
+        tryPred->ReplaceSucc(tryBB, targetBB);
+        // if needed, update branch label
+        MeStmt *br = to_ptr(tryPred->GetMeStmts().rbegin());
+        if (br != nullptr) {
+          if (br->IsCondBr()) {
+            if (static_cast<CondGotoMeStmt*>(br)->GetOffset() == tryBB->GetBBLabel()) {
+              LabelIdx label = func.GetOrCreateBBLabel(*targetBB);
+              static_cast<CondGotoMeStmt*>(br)->SetOffset(label);
+            }
+          } else if (br->GetOp() == OP_goto) {
+            LabelIdx label = func.GetOrCreateBBLabel(*targetBB);
+            ASSERT(static_cast<GotoMeStmt*>(br)->GetOffset() == tryBB->GetBBLabel(), "Wrong label");
+            static_cast<GotoMeStmt*>(br)->SetOffset(label);
+          } else if (br->GetOp() == OP_multiway || br->GetOp() == OP_rangegoto) {
+            CHECK_FATAL(false, "OP_multiway and OP_rangegoto are not supported");
+          } else if (br->GetOp() == OP_switch) {
+            LabelIdx label = func.GetOrCreateBBLabel(*targetBB);
+            auto *switchNode = static_cast<SwitchMeStmt*>(br);
+            if (switchNode->GetDefaultLabel() == tryBB->GetBBLabel()) {
+              switchNode->SetDefaultLabel(label);
+            }
+            for (size_t m = 0; m < switchNode->GetSwitchTable().size(); ++m) {
+              if (switchNode->GetSwitchTable()[m].second == tryBB->GetBBLabel()) {
+                switchNode->SetCaseLabel(m, label);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+void MEHdse::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEAliasClass>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.PreservedAllExcept<MEDominance>();
+  aDep.PreservedAllExcept<MELoopAnalysis>();
+}
+
+bool MEHdse::PhaseRun(maple::MeFunction &f) {
+  if (f.hdseRuns >= MeOption::hdseRunsLimit) {
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "  == " << PhaseName() << " skipped\n";
+    }
+    return false;
+  }
+  f.hdseRuns++;
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto *dom = dominancePhase->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  auto *pdom = dominancePhase->GetPdomResult();
+  CHECK_NULL_FATAL(pdom);
+  auto *aliasClass = GET_ANALYSIS(MEAliasClass, f);
+  CHECK_NULL_FATAL(aliasClass);
+  auto *hMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_NULL_FATAL(hMap);
+
+  MeHDSE hdse = MeHDSE(f, *dom, *pdom, *hMap, aliasClass, DEBUGFUNC_NEWPM(f));
+  hdse.hdseKeepRef = MeOption::dseKeepRef;
+  hdse.SetUpdateFreq(Options::profileUse && f.GetMirFunc()->GetFuncProfData());
+  if (f.hdseRuns > 2) {
+    hdse.SetRemoveRedefine(true);
+  }
+  hdse.DoHDSE();
+  hdse.BackwardSubstitution();
+  MakeEmptyTrysUnreachable(f);
+  (void)f.GetCfg()->UnreachCodeAnalysis(true);
+  f.GetCfg()->WontExitAnalysis();
+  // update frequency
+  if (hdse.UpdateFreq()) {
+    if (f.GetCfg()->DumpIRProfileFile()) {
+      f.GetCfg()->DumpToFile("after-HDSE" + std::to_string(f.hdseRuns), false, true);
+    }
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== HDSE =============" << '\n';
+    f.Dump(false);
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_inequality_graph.cpp b/src/mapleall/maple_me/src/me_inequality_graph.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef2a2d47330189bd628c4bcd70d90341a0d1d6b6
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_inequality_graph.cpp
@@ -0,0 +1,470 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_inequality_graph.h"
+
+namespace {
+constexpr maple::int32 kUpperBound = -1;
+constexpr maple::int32 kLowerBound = 0;
+}  // namespace
+
+namespace maple {
+ESSAConstNode *InequalityGraph::GetOrCreateConstNode(int64 value) {
+  if (HasNode(value)) {
+    return static_cast<ESSAConstNode*>(constNodes[value].get());
+  }
+  std::unique_ptr<ESSAConstNode> newConstNode = std::make_unique<ESSAConstNode>(GetValidID(), value);
+  CHECK_FATAL(newConstNode != nullptr, "new failed");
+  ESSAConstNode *newConst = newConstNode.get();
+  constNodes[value] = std::move(newConstNode);
+  return newConst;
+}
+
+ESSAVarNode *InequalityGraph::GetOrCreateVarNode(MeExpr &meExpr) {
+  if (HasNode(meExpr)) {
+    return static_cast<ESSAVarNode*>(varNodes[meExpr.GetExprID()].get());
+  }
+  CHECK_FATAL(meExpr.GetMeOp() == kMeOpVar || meExpr.GetMeOp() == kMeOpIvar, "meExpr must be VarMeExpr");
+  std::unique_ptr<ESSAVarNode> newVarNode = std::make_unique<ESSAVarNode>(GetValidID(), meExpr);
+  CHECK_FATAL(newVarNode != nullptr, "new failed");
+  ESSAVarNode *newVar = newVarNode.get();
+  varNodes[meExpr.GetExprID()] = std::move(newVarNode);
+  return newVar;
+}
+
+ESSAPhiNode *InequalityGraph::GetOrCreatePhiNode(MePhiNode &phiNode) {
+  MeExpr *expr = phiNode.GetLHS();
+  CHECK_FATAL(expr != nullptr, "meExpr phiNode must has lhs");
+  if (HasNode(*expr)) {
+    return static_cast<ESSAPhiNode*>(varNodes[expr->GetExprID()].get());
+  }
+  CHECK_FATAL(expr->GetMeOp() == kMeOpVar, "meExpr must be VarMeExpr");
+  std::unique_ptr<ESSAPhiNode> newPhiNode = std::make_unique<ESSAPhiNode>(GetValidID(), *expr);
+  CHECK_FATAL(newPhiNode != nullptr, "new failed");
+  newPhiNode->SetPhiOpnds(phiNode.GetOpnds());
+  ESSAPhiNode *newPhi = newPhiNode.get();
+  varNodes[expr->GetExprID()] = std::move(newPhiNode);
+  for (auto *phiRHS : phiNode.GetOpnds()) {
+    ESSABaseNode *rhs = nullptr;
+    if (phiRHS->GetDefBy() != kDefByPhi) {
+      rhs = GetOrCreateVarNode(*phiRHS);
+    } else {
+      MePhiNode *defPhi = &(phiRHS->GetDefPhi());
+      rhs = GetOrCreatePhiNode(*defPhi);
+    }
+    AddPhiEdge(*rhs, *newPhi, EdgeType::kUpper);
+    AddPhiEdge(*newPhi, *rhs, EdgeType::kLower);
+  }
+  CHECK_FATAL(newPhi->GetPhiOpnds().size() == newPhi->GetInPhiEdgeMap().size(), "must be");
+  return newPhi;
+}
+
+ESSAArrayNode *InequalityGraph::GetOrCreateArrayNode(MeExpr &meExpr) {
+  if (HasNode(meExpr)) {
+    return static_cast<ESSAArrayNode*>(varNodes[meExpr.GetExprID()].get());
+  }
+  CHECK_FATAL(meExpr.GetMeOp() == kMeOpVar, "meExpr must be VarMeExpr");
+  std::unique_ptr<ESSAArrayNode> newArrayNode = std::make_unique<ESSAArrayNode>(GetValidID(), meExpr);
+  CHECK_FATAL(newArrayNode != nullptr, "new failed");
+  ESSAArrayNode *newArray = newArrayNode.get();
+  varNodes[meExpr.GetExprID()] = std::move(newArrayNode);
+  return newArray;
+}
+
+InequalEdge *InequalityGraph::AddEdge(ESSABaseNode &from, ESSABaseNode &to, int64 value, EdgeType type) {
+  InequalEdge tmpEdge = InequalEdge(value, type);
+  InequalEdge *edge = HasEdge(from, to, tmpEdge);
+  if (edge != nullptr) {
+    return edge;
+  }
+  std::unique_ptr<InequalEdge> e = std::make_unique<InequalEdge>(value, type);
+  InequalEdge *ePtr = e.get();
+  CHECK_FATAL(e != nullptr, "new failed");
+  from.InsertOutWithConstEdgeMap(to, *e);
+  to.InsertInWithConstEdgeMap(from, *e);
+  from.InsertEdges(std::move(e));
+  return ePtr;
+}
+
+void InequalityGraph::AddPhiEdge(ESSABaseNode &from, ESSABaseNode &to, EdgeType type) {
+  std::unique_ptr<InequalEdge> edge = std::make_unique<InequalEdge>(0, type);
+  CHECK_FATAL(edge != nullptr, "new failed");
+  if (type == EdgeType::kUpper) {
+    from.InsertOutWithConstEdgeMap(to, *edge);
+    CHECK_FATAL(to.GetKind() == kPhiNode, "must be");
+    static_cast<ESSAPhiNode&>(to).InsertInPhiEdgeMap(from, *edge);
+    from.InsertEdges(std::move(edge));
+  } else {
+    CHECK_FATAL(from.GetKind() == kPhiNode, "must be");
+    static_cast<ESSAPhiNode&>(from).InsertOutPhiEdgeMap(to, *edge);
+    to.InsertInWithConstEdgeMap(from, *edge);
+    from.InsertEdges(std::move(edge));
+  }
+}
+
+void InequalityGraph::AddEdge(ESSABaseNode &from, ESSABaseNode &to, MeExpr &value, bool positive, EdgeType type) {
+  InequalEdge tmpEdge = InequalEdge(value, positive, type);
+  if (HasEdge(from, to, tmpEdge)) {
+    return;
+  }
+  std::unique_ptr<InequalEdge> edge = std::make_unique<InequalEdge>(value, positive, type);
+  CHECK_FATAL(edge != nullptr, "new failed");
+  from.InsertOutWithVarEdgeMap(to, *edge);
+  to.InsertInWithVarEdgeMap(from, *edge);
+  from.InsertEdges(std::move(edge));
+}
+
+bool InequalityGraph::HasNode(const MeExpr &meExpr) const {
+  return varNodes.find(meExpr.GetExprID()) != varNodes.end();
+}
+
+bool InequalityGraph::HasNode(int64 value) const {
+  return constNodes.find(value) != constNodes.end();
+}
+
+void InequalityGraph::ConnectTrivalEdge() {
+  int64 prevValue = 0;
+  ESSABaseNode* prevNode = nullptr;
+  for (auto &pair : std::as_const(constNodes)) {
+    int64 value = pair.first;
+    ESSABaseNode* node = pair.second.get();
+    if (prevNode == nullptr) {
+      prevValue = value;
+      prevNode = node;
+      continue;
+    }
+    CHECK_FATAL(value > prevValue, "must be");
+    InequalEdge *pairEdge1 = AddEdge(*node, *prevNode, prevValue - value, EdgeType::kNone);
+    InequalEdge *pairEdge2 = AddEdge(*prevNode, *node, value - prevValue, EdgeType::kNone);
+    CHECK_FATAL(pairEdge1, "pairEdge1 is nullptr!");
+    CHECK_FATAL(pairEdge2, "pairEdge2 is nullptr!");
+    pairEdge1->SetPairEdge(*pairEdge2);
+    pairEdge2->SetPairEdge(*pairEdge1);
+    prevValue = value;
+    prevNode = node;
+  }
+}
+
+ESSABaseNode &InequalityGraph::GetNode(const MeExpr &meExpr) {
+  CHECK_FATAL(HasNode(meExpr), "node is not created");
+  return *varNodes[meExpr.GetExprID()];
+}
+
+ESSABaseNode &InequalityGraph::GetNode(int64 value) {
+  CHECK_FATAL(HasNode(value), "node is not created");
+  return *constNodes[value];
+}
+
+InequalEdge *InequalityGraph::HasEdge(const ESSABaseNode &from, ESSABaseNode &to,
+                                      const InequalEdge &type) const {
+  auto miter = from.GetOutWithConstEdgeMap().equal_range(&to);
+  for (auto it = miter.first; it != miter.second; ++it) {
+    if (it->second->IsSame(type)) {
+      return it->second;
+    }
+  }
+  miter = from.GetOutWithVarEdgeMap().equal_range(&to);
+  for (auto it = miter.first; it != miter.second; ++it) {
+    if (it->second->IsSame(type)) {
+      return it->second;
+    }
+  }
+  return nullptr;
+}
+
+std::string InequalityGraph::GetName(const MeExpr &meExpr) const {
+  std::string name;
+  MeExprOp meOp = meExpr.GetMeOp();
+  CHECK_FATAL(meOp == kMeOpVar, "must be VarMeExpr");
+  const auto *varMeExpr = static_cast<const VarMeExpr*>(&meExpr);
+  MIRSymbol *sym = varMeExpr->GetOst()->GetMIRSymbol();
+  name = sym->GetName() + "\\nmx" + std::to_string(meExpr.GetExprID());
+  return name;
+}
+
+std::string InequalityGraph::GetName(const ESSABaseNode &node) const {
+  std::string name;
+  if (node.GetKind() == kConstNode) {
+    return std::to_string((*static_cast<const ESSAConstNode*>(&node)).GetValue());
+  }
+  const MeExpr *meExpr = &(node.GetMeExpr());
+  CHECK_FATAL(meExpr != nullptr, "meExpr is nullptr");
+  const VarMeExpr *varMeExpr = nullptr;
+  if (meExpr->GetMeOp() == kMeOpVar) {
+    varMeExpr = static_cast<const VarMeExpr*>(meExpr);
+  } else if (meExpr->GetMeOp() == kMeOpIvar) {
+    const auto *ivarMeExpr = static_cast<const IvarMeExpr*>(meExpr);
+    const MeExpr *base = ivarMeExpr->GetBase();
+    if (base->GetMeOp() == kMeOpVar) {
+      varMeExpr = static_cast<const VarMeExpr*>(base);
+    } else {
+      name = "ivar" + std::to_string(ivarMeExpr->GetExprID());
+      return name;
+    }
+  }
+  MIRSymbol *sym = varMeExpr->GetOst()->GetMIRSymbol();
+  name = sym->GetName() + "\\nmx" + std::to_string(meExpr->GetExprID());
+  if (node.GetKind() == kArrayNode) {
+    name += ".length";
+  } else if (node.GetKind() == kPhiNode) {
+    name += " = phi(";
+    for (auto iter = (*static_cast<const ESSAPhiNode*>(&node)).GetPhiOpnds().begin();
+         iter != (*static_cast<const ESSAPhiNode*>(&node)).GetPhiOpnds().end(); ++iter) {
+      name += "mx" + std::to_string((*iter)->GetExprID()) + ", ";
+    }
+    name += ")";
+  }
+  name += "\\nID: " + std::to_string(node.GetID());
+  return name;
+}
+
+std::string InequalityGraph::GetColor(EdgeType type) const {
+  switch (type) {
+    case kUpper:
+      return "color = red";
+    case kUpperInvalid:
+      return "color = red, style=dashed";
+    case kLower:
+      return "color = blue";
+    case kLowerInvalid:
+      return "color = blue, style=dashed";
+    case kNone:
+      return "color = black";
+    case kNoneInvalid:
+      return "color = black, style=dashed";
+  }
+}
+
+void InequalityGraph::DumpDotEdges(const std::pair<ESSABaseNode*, InequalEdge*> &map,
+                                   std::ostream &out, const std::string &from) const {
+  ASSERT_NOT_NULL(map.second);
+  if (map.second->IsVarValue()) {
+    std::string to = GetName(*(map.first));
+    std::string positive = map.second->GetVarValue().IsPositive() ? "" : "-";
+    std::string color = GetColor(map.second->GetEdgeType());
+    out << "\"" << from << "\" -> \"" << to << "\" ";
+    out << "[label=\"" << positive << GetName(map.second->GetVarValue().GetVarMeExpr())
+        << "\" " << color << "];\n";
+  } else {
+    std::string to = GetName(*(map.first));
+    std::string color = GetColor(map.second->GetEdgeType());
+    out << "\"" << from << "\" -> \"" << to << "\" ";
+    out << "[label=\"" << map.second->GetConstValue() << "\" " << color << "];\n";
+  }
+}
+
+void InequalityGraph::DumpDotNodes(std::ostream &out, DumpType dumpType,
+                                   const std::map<int64, std::unique_ptr<ESSABaseNode>> &nodes) const {
+  for (auto iter = nodes.begin(); iter != nodes.end(); ++iter) {
+    std::string from = GetName(*(iter->second));
+    out << "\"" << from << "\";\n";
+    for (auto iterConstEdges = iter->second.get()->GetOutWithConstEdgeMap().begin();
+         iterConstEdges != iter->second.get()->GetOutWithConstEdgeMap().end(); ++iterConstEdges) {
+      EdgeType edgeType = iterConstEdges->second->GetEdgeType();
+      if (dumpType == kDumpNone) {
+        DumpDotEdges(*iterConstEdges, out, from);
+      } else if ((dumpType == kDumpUpperAndNone) &&
+                 (edgeType == kUpper || edgeType == kNone || edgeType == kUpperInvalid || edgeType == kNoneInvalid)) {
+        DumpDotEdges(*iterConstEdges, out, from);
+      } else if ((dumpType == kDumpLowerAndNone) &&
+                 (edgeType == kLower || edgeType == kNone || edgeType == kLowerInvalid || edgeType == kNoneInvalid)) {
+        DumpDotEdges(*iterConstEdges, out, from);
+      }
+    }
+    if (iter->second.get()->GetKind() == kPhiNode) {
+      auto *phiNode = static_cast<ESSAPhiNode*>(iter->second.get());
+      for (auto iterConstEdges = phiNode->GetOutPhiEdgeMap().begin();
+           iterConstEdges != phiNode->GetOutPhiEdgeMap().end(); ++iterConstEdges) {
+        EdgeType edgeType = iterConstEdges->second->GetEdgeType();
+        if (dumpType == kDumpNone) {
+          DumpDotEdges(*iterConstEdges, out, from);
+        } else if ((dumpType == kDumpUpperAndNone) &&
+                   (edgeType == kUpper || edgeType == kNone ||
+                    edgeType == kUpperInvalid || edgeType == kNoneInvalid)) {
+          DumpDotEdges(*iterConstEdges, out, from);
+        } else if ((dumpType == kDumpLowerAndNone) &&
+                   (edgeType == kLower || edgeType == kNone ||
+                    edgeType == kLowerInvalid || edgeType == kNoneInvalid)) {
+          DumpDotEdges(*iterConstEdges, out, from);
+        }
+      }
+    }
+    for (auto iterVarEdges = iter->second.get()->GetOutWithVarEdgeMap().begin();
+         iterVarEdges != iter->second.get()->GetOutWithVarEdgeMap().end(); ++iterVarEdges) {
+      EdgeType edgeType = iterVarEdges->second->GetEdgeType();
+      if (dumpType == kDumpNone) {
+        DumpDotEdges(*iterVarEdges, out, from);
+      } else if ((dumpType == kDumpUpperAndNone) &&
+                 (edgeType == kUpper || edgeType == kNone || edgeType == kUpperInvalid || edgeType == kNoneInvalid)) {
+        DumpDotEdges(*iterVarEdges, out, from);
+      } else if ((dumpType == kDumpLowerAndNone) &&
+                 (edgeType == kLower || edgeType == kNone || edgeType == kLowerInvalid || edgeType == kNoneInvalid)) {
+        DumpDotEdges(*iterVarEdges, out, from);
+      }
+    }
+  }
+}
+
+void InequalityGraph::DumpDotFile(DumpType dumpType) const {
+  std::filebuf fileBuf;
+  std::string dumpT = dumpType == kDumpUpperAndNone ? "Upper_" : "Lower_";
+  std::string outFile =  dumpT + meFunction->GetName() + "-inequalityGraph.dot";
+  fileBuf.open(outFile, std::ios::trunc | std::ios::out);
+  std::ostream essaDotFile(&fileBuf);
+  essaDotFile << "digraph InequalityGraph {\n";
+  DumpDotNodes(essaDotFile, dumpType, constNodes);
+  DumpDotNodes(essaDotFile, dumpType, varNodes);
+  essaDotFile << "}\n";
+  fileBuf.close();
+}
+
+bool ABCD::IsLessOrEqual(const MeExpr &arrayNode, const MeExpr &idx) {
+  ESSABaseNode &aNode = inequalityGraph->GetNode(arrayNode);
+  ESSABaseNode *idxNode = nullptr;
+  if (idx.GetMeOp() == kMeOpVar) {
+    idxNode = &(inequalityGraph->GetNode(idx));
+  } else {
+    CHECK_FATAL(idx.GetMeOp() == kMeOpConst, "must be");
+    idxNode = &(inequalityGraph->GetNode(static_cast<const ConstMeExpr&>(idx).GetExtIntValue()));
+  }
+  std::unique_ptr<InequalEdge> e = std::make_unique<InequalEdge>(kLowerBound, kUpper);
+  active.clear();
+  ProveResult res = Prove(aNode, *idxNode, *e.get());
+  return res == kTrue;
+}
+
+bool ABCD::DemandProve(const MeExpr &arrayNode, const MeExpr &idx) {
+  ESSABaseNode &aNode = inequalityGraph->GetNode(arrayNode);
+  ESSABaseNode *idxNode = nullptr;
+  if (idx.GetMeOp() == kMeOpVar) {
+    idxNode = &(inequalityGraph->GetNode(idx));
+  } else {
+    CHECK_FATAL(idx.GetMeOp() == kMeOpConst, "must be");
+    idxNode = &(inequalityGraph->GetNode(static_cast<const ConstMeExpr&>(idx).GetExtIntValue()));
+  }
+  ESSABaseNode &zNode = inequalityGraph->GetNode(0);
+  bool upperResult = ABCD::DemandProve(aNode, *idxNode, kUpper);
+  bool lowerResult = ABCD::DemandProve(zNode, *idxNode, kLower);
+  return upperResult && lowerResult;
+}
+
+bool ABCD::DemandProve(ESSABaseNode &firstNode, ESSABaseNode &secondNode, EdgeType edgeType) {
+  std::unique_ptr<InequalEdge> e =
+      std::make_unique<InequalEdge>(edgeType == kUpper ? kUpperBound : kLowerBound, edgeType);
+  active.clear();
+  ProveResult res = Prove(firstNode, secondNode, *e.get());
+  return res == kTrue;
+}
+
+void ABCD::PrintTracing() const {
+  for (size_t i = 0; i < tracing.size(); i++) {
+    std::cout << "Traversing Node : " << tracing[i]->GetExprID() << '\n';
+  }
+  std::cout << '\n';
+}
+
+ProveResult ABCD::Prove(ESSABaseNode &aNode, ESSABaseNode &bNode, InequalEdge &edge) {
+  ++recursiveCount;
+  if (recursiveCount > kDFSLimit) {
+    return kFalse;
+  }
+
+  tracing.push_back(&bNode);
+  if (&aNode == &bNode) {
+    if (edge.GreaterEqual(0)) {
+      tracing.pop_back();
+      return kTrue;
+    } else {
+      tracing.pop_back();
+      return kFalse;
+    }
+  }
+  bool hasPreNode = false;
+  auto constEdge = (edge.GetEdgeType() == kUpper) ? bNode.GetInWithConstEdgeMap() : bNode.GetOutWithConstEdgeMap();
+  for (auto iter = constEdge.begin(); iter != constEdge.end(); ++iter) {
+    if (iter->second->GetEdgeType() == edge.GetEdgeType() || iter->second->GetEdgeType() == EdgeType::kNone) {
+      hasPreNode = true;
+      break;
+    }
+  }
+  if (bNode.GetKind() == kPhiNode) {
+    hasPreNode = true;
+  }
+  if (!hasPreNode) {
+    tracing.pop_back();
+    return kFalse;
+  }
+
+  if (active.find(&bNode) != active.end()) {
+    if (active.find(&bNode)->second->LessEqual(edge)) {
+      tracing.pop_back();
+      return kReduced;
+    } else {
+      tracing.pop_back();
+      return kFalse;
+    }
+  }
+
+  active[&bNode] = &edge;
+  ProveResult res = bNode.GetKind() == kPhiNode ? UpdateCacheResult(aNode, bNode, edge, Min)
+                                                : UpdateCacheResult(aNode, bNode, edge, Max);
+  active.erase(&bNode);
+  tracing.pop_back();
+  return res;
+}
+
+ProveResult ABCD::UpdateCacheResult(ESSABaseNode &aNode, ESSABaseNode &bNode,
+                                    const InequalEdge &edge, MeetFunction meet) {
+  ProveResult res = meet == Min ? kReduced : kFalse;
+  if (meet == Min) {
+    CHECK_FATAL(bNode.GetKind() == kPhiNode, "must be");
+    auto& bPhiNode = static_cast<ESSAPhiNode&>(bNode);
+    auto constEdgeMap = (edge.GetEdgeType() == kUpper) ? bPhiNode.GetInPhiEdgeMap() : bPhiNode.GetOutPhiEdgeMap();
+    for (auto iter = constEdgeMap.begin(); iter != constEdgeMap.end(); ++iter) {
+      if (((res == kTrue) && (meet == Max)) || ((res == kFalse) && (meet == Min))) {
+        break;
+      }
+      InequalEdge *in = iter->second;
+      if (in->GetEdgeType() == edge.GetEdgeType() || in->GetEdgeType() == kNone) {
+        InequalEdge nextEdge(edge, *in);
+        if (in->GetPairEdge()) {
+          in->GetPairEdge()->SetEdgeTypeInValid();
+        }
+        res = meet(res, Prove(aNode, *(iter->first), nextEdge));
+        if (in->GetPairEdge()) {
+          in->GetPairEdge()->SetEdgeTypeValid();
+        }
+      }
+    }
+  }
+  auto constEdgeMap = (edge.GetEdgeType() == kUpper) ? bNode.GetInWithConstEdgeMap() : bNode.GetOutWithConstEdgeMap();
+  for (auto iter = constEdgeMap.begin(); iter != constEdgeMap.end(); ++iter) {
+    if (res == kTrue) {
+      break;
+    }
+    InequalEdge *in = iter->second;
+    if (in->GetEdgeType() == edge.GetEdgeType() || in->GetEdgeType() == kNone) {
+      InequalEdge nextEdge(edge, *in);
+      if (in->GetPairEdge()) {
+        in->GetPairEdge()->SetEdgeTypeInValid();
+      }
+      res = Max(res, Prove(aNode, *(iter->first), nextEdge));
+      if (in->GetPairEdge()) {
+        in->GetPairEdge()->SetEdgeTypeValid();
+      }
+    }
+  }
+  return res;
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/me_ir.cpp b/src/mapleall/maple_me/src/me_ir.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..37f0df26359501d94b4857f5f69148c385a6eb47
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ir.cpp
@@ -0,0 +1,1806 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ir.h"
+#include "opcode_info.h"
+#include "irmap.h"
+#include "me_irmap.h"
+#include "printing.h"
+#include "me_ssa.h"
+#include "mir_function.h"
+#include "global_tables.h"
+#include "me_cfg.h"
+
+namespace {
+  constexpr int32_t kDefaultPrintIndentNum = 5;
+}
+
+namespace maple {
+bool MeExpr::IsTheSameWorkcand(const MeExpr &expr) const {
+  ASSERT((exprID != -1 || expr.GetExprID() != -1), "at least one of them should not be none initialized");
+  if (exprID == expr.GetExprID()) {
+    return true;
+  }
+  if (op != expr.GetOp()) {
+    return false;
+  }
+  if (IsPrimitiveFloat(primType) != IsPrimitiveFloat(expr.GetPrimType())) {
+    return false;
+  }
+  if (GetPrimTypeSize(GetRegPrimType(primType)) != GetPrimTypeSize(GetRegPrimType(expr.GetPrimType()))) {
+    return false;
+  }
+  if ((op == OP_div || op == OP_rem) && primType != expr.GetPrimType()) {
+    // div result differs between different types
+    return false;
+  }
+  if (kOpcodeInfo.IsTypeCvt(op) || kOpcodeInfo.IsCompare(op)) {
+    if (primType != expr.primType ||
+        static_cast<const OpMeExpr *>(this)->GetOpndType() != static_cast<const OpMeExpr &>(expr).GetOpndType()) {
+      return false;
+    }
+  }
+  if (op == OP_extractbits || op == OP_depositbits || op == OP_sext || op == OP_zext) {
+    if (static_cast<const OpMeExpr *>(this)->GetBitsOffSet() != static_cast<const OpMeExpr &>(expr).GetBitsOffSet() ||
+        static_cast<const OpMeExpr *>(this)->GetBitsSize() != static_cast<const OpMeExpr &>(expr).GetBitsSize()) {
+      return false;
+    }
+  }
+  if (op == OP_resolveinterfacefunc || op == OP_resolvevirtualfunc || op == OP_iaddrof) {
+    if (static_cast<const OpMeExpr*>(this)->GetFieldID() != static_cast<const OpMeExpr &>(expr).GetFieldID()) {
+      return false;
+    }
+  }
+  return IsUseSameSymbol(expr);
+}
+
+// get the definition of this
+// for example:
+// v2 = x + b
+// v1 = v2
+// then v1->ResolveMeExprValue() returns x+b
+MeExpr *MeExpr::ResolveMeExprValue() {
+  MeExpr *cmpOpLocal = this;
+  while (cmpOpLocal != nullptr && cmpOpLocal->GetMeOp() == kMeOpVar) {
+    auto *varCmpOp = static_cast<VarMeExpr*>(cmpOpLocal);
+    cmpOpLocal = nullptr;
+    if (varCmpOp->GetDefBy() == kDefByStmt) {
+      cmpOpLocal = static_cast<DassignMeStmt*>(varCmpOp->GetDefStmt())->GetRHS();
+    } else if (varCmpOp->GetDefBy() == kDefByChi) {
+      ChiMeNode &defchi = varCmpOp->GetDefChi();
+      MeStmt *base = defchi.GetBase();
+      if (base->GetOp() == OP_maydassign) {
+        cmpOpLocal = static_cast<MaydassignMeStmt*>(base)->GetRHS();
+      }
+    }
+  }
+  return cmpOpLocal;
+}
+
+// if expr contains volatile subexpr
+bool MeExpr::ContainsVolatile() const {
+  if (GetMeOp() == kMeOpIvar || GetMeOp() == kMeOpVar) {
+    return IsVolatile();
+  }
+  for (size_t i = 0; i < numOpnds; ++i) {
+    if (GetOpnd(i)->ContainsVolatile()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool VarMeExpr::IsSameVariableValue(const VarMeExpr &expr) const {
+  if (&expr == this) {
+    return true;
+  }
+
+  if (GetMeOp() == kMeOpVar && GetDefBy() == kDefByStmt && GetDefStmt()->GetOp() == OP_dassign) {
+    auto *stmt = static_cast<DassignMeStmt*>(GetDefStmt());
+    if (stmt->GetRHS() == &expr) {
+      return true;
+    }
+  }
+
+  return MeExpr::IsSameVariableValue(expr);
+}
+
+bool RegMeExpr::IsSameVariableValue(const VarMeExpr &expr) const {
+  if (static_cast<const MeExpr *>(&expr) == this) {
+    return true;
+  }
+
+  if (GetMeOp() == kMeOpReg && GetDefBy() == kDefByStmt && GetDefStmt()->GetOp() == OP_regassign) {
+    auto *stmt = static_cast<AssignMeStmt*>(GetDefStmt());
+    if (stmt->GetRHS() == &expr) {
+      return true;
+    }
+  }
+
+  return MeExpr::IsSameVariableValue(expr);
+}
+
+// get the definition VarMeExpr of this
+// for expample:
+// v2 = v3
+// v1 = v2
+// this = v1
+// this->ResolveVarMeValue() returns v3;
+// if no resolved VarMeExpr, return this
+VarMeExpr &VarMeExpr::ResolveVarMeValue() {
+  VarMeExpr *cmpop0 = this;
+  while (true) {
+    if (cmpop0->GetDefBy() != kDefByStmt || cmpop0->IsVolatile()) {
+      break;
+    }
+
+    auto *defStmt = static_cast<DassignMeStmt*>(cmpop0->GetDefStmt());
+    MeExpr *expr = defStmt->GetRHS();
+    if (expr->GetMeOp() != kMeOpVar) {
+      break;
+    }
+
+    cmpop0 = static_cast<VarMeExpr*>(expr);
+  }
+  return *cmpop0;
+}
+
+// *this can be any node, but *v must be VarMeExpr
+bool MeExpr::IsSameVariableValue(const VarMeExpr &expr) const {
+  if (&expr == this) {
+    return true;
+  }
+  // look up v's value
+  if (expr.GetDefBy() == kDefByStmt && expr.GetDefStmt()->GetOp() == OP_dassign) {
+    auto *stmt = static_cast<DassignMeStmt*>(expr.GetDefStmt());
+    if (stmt->GetRHS() == this) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// return true if the expression could throw exception; needs to be in sync with
+// BaseNode::MayThrowException()
+bool MeExpr::CouldThrowException() const {
+  if (kOpcodeInfo.MayThrowException(op)) {
+    if (op != OP_array) {
+      return true;
+    }
+    if (static_cast<const NaryMeExpr*>(this)->GetBoundCheck()) {
+      return true;
+    }
+  } else if (op == OP_intrinsicop) {
+    if (static_cast<const NaryMeExpr*>(this)->GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH) {
+      return true;
+    }
+  }
+  for (int32 i = 0; i < GetNumOpnds(); ++i) {
+    if (GetOpnd(i)->CouldThrowException()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// search through the SSA graph to find a version with GetDefBy() == DefBYy_stmt
+// visited is for avoiding processing a node more than once
+RegMeExpr *RegMeExpr::FindDefByStmt(std::set<RegMeExpr*> &visited) {
+  if (visited.find(this) != visited.end()) {
+    return nullptr;
+  }
+  visited.insert(this);
+  if (GetDefBy() == kDefByStmt) {
+    return this;
+  }
+  if (GetDefBy() == kDefByPhi) {
+    MePhiNode &phiReg = GetDefPhi();
+    for (auto *phiOpnd : phiReg.GetOpnds()) {
+      auto *res = static_cast<RegMeExpr*>(phiOpnd)->FindDefByStmt(visited);
+      if (res != nullptr) {
+        return res;
+      }
+    }
+  }
+  return nullptr;
+}
+
+MeExpr &MeExpr::GetAddrExprBase() {
+  switch (meOp) {
+    case kMeOpAddrof:
+    case kMeOpVar:
+      return *this;
+    case kMeOpOp:
+      if (op == OP_add || op == OP_sub || op == OP_iaddrof || op == OP_retype) {
+        auto *opMeExpr = static_cast<OpMeExpr*>(this);
+        return opMeExpr->GetOpnd(0)->GetAddrExprBase();
+      }
+      return *this;
+    case kMeOpNary:
+      if (op == OP_array) {
+        auto *naryExpr = static_cast<NaryMeExpr*>(this);
+        ASSERT(naryExpr->GetOpnd(0) != nullptr, "");
+        return naryExpr->GetOpnd(0)->GetAddrExprBase();
+      }
+      return *this;
+    case kMeOpReg: {
+      auto *baseVar = static_cast<RegMeExpr*>(this);
+      std::set<RegMeExpr*> visited;
+      baseVar = baseVar->FindDefByStmt(visited);
+      if (baseVar != nullptr && baseVar->GetDefBy() == kDefByStmt) {
+        MeStmt *baseDefStmt = baseVar->GetDefStmt();
+        auto *regAssign = static_cast<AssignMeStmt*>(baseDefStmt);
+        MeExpr *rhs = regAssign->GetRHS();
+        // Following we only consider array, add and sub
+        // Prevent the following situation for reg %1
+        // regAssign ref %1 (gcmallocjarray ref ...)
+        if (rhs->op == OP_array || rhs->op == OP_add || rhs->op == OP_sub) {
+          return rhs->GetAddrExprBase();
+        }
+      }
+      return *this;
+    }
+    default:
+      return *this;
+  }
+}
+
+bool NaryMeExpr::IsUseSameSymbol(const MeExpr &expr) const {
+  if (expr.GetMeOp() != kMeOpNary) {
+    return false;
+  }
+  auto &naryMeExpr = static_cast<const NaryMeExpr&>(expr);
+  if (expr.GetOp() != GetOp() || naryMeExpr.GetIntrinsic() != intrinsic || naryMeExpr.tyIdx != tyIdx) {
+    return false;
+  }
+  if (opnds.size() != naryMeExpr.GetOpnds().size()) {
+    return false;
+  }
+  for (size_t i = 0; i < opnds.size(); ++i) {
+    if (!opnds[i]->IsUseSameSymbol(*naryMeExpr.GetOpnd(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MeExpr::IsAllOpndsIdentical(const MeExpr &meExpr) const {
+  for (uint8 i = 0; i < GetNumOpnds(); ++i) {
+    if (GetOpnd(i)->GetExprID() != meExpr.GetOpnd(i)->GetExprID()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool OpMeExpr::IsAllOpndsIdentical(const OpMeExpr &meExpr) const {
+  // add/mul/or/xor/and/etc..., need not to consider opnd order
+  if (IsCommutative(meExpr.GetOp())) {
+    ASSERT(meExpr.GetNumOpnds() == 2, "not supported opcode: %d", meExpr.GetOp());
+    return (meExpr.GetOpnd(0) == this->GetOpnd(0) && meExpr.GetOpnd(1) == this->GetOpnd(1)) ||
+           (meExpr.GetOpnd(1) == this->GetOpnd(0) && meExpr.GetOpnd(0) == this->GetOpnd(1));
+  }
+  return MeExpr::IsAllOpndsIdentical(meExpr);
+}
+
+bool OpMeExpr::IsCompareIdentical(const OpMeExpr &meExpr) const {
+  // x > y <==> y < x; x <= y <==> y >= x;
+  switch (meExpr.GetOp()) {
+    case OP_ge:
+      if (this->GetOp() != OP_le) {
+        return false;
+      }
+      break;
+    case OP_le:
+      if (this->GetOp() != OP_ge) {
+        return false;
+      }
+      break;
+    case OP_gt:
+      if (this->GetOp() != OP_lt) {
+        return false;
+      }
+      break;
+    case OP_lt:
+      if (this->GetOp() != OP_gt) {
+        return false;
+      }
+      break;
+    default:
+      return false;
+  }
+
+  return (meExpr.GetOpnd(1) == this->GetOpnd(0)) && (meExpr.GetOpnd(0) == this->GetOpnd(1));
+}
+
+static bool CompatibleIntegerTypes(PrimType pty1, PrimType pty2) {
+  if (IsPrimitiveInteger(pty1) && IsPrimitiveInteger(pty2)) {
+    return GetPrimTypeSize(pty1) == GetPrimTypeSize(pty2) && IsSignedInteger(pty1) == IsSignedInteger(pty2);
+  }
+  return pty1 == pty2;
+}
+
+bool OpMeExpr::IsIdentical(const OpMeExpr &meExpr) const {
+  if (meExpr.GetOp() != GetOp()) {
+    return false;
+  }
+  if (!CompatibleIntegerTypes(meExpr.GetPrimType(), GetPrimType()) || meExpr.opndType != opndType ||
+      meExpr.bitsOffset != bitsOffset || meExpr.bitsSize != bitsSize || meExpr.tyIdx != tyIdx ||
+      meExpr.fieldID != fieldID) {
+    return false;
+  }
+  if (IsAllOpndsIdentical(meExpr)) {
+    return true;
+  }
+
+  if (IsCompareIdentical(meExpr)) {
+    return true;
+  }
+
+  return false;
+}
+
+bool NaryMeExpr::IsIdentical(const NaryMeExpr &meExpr) const {
+  if (meExpr.GetOp() != GetOp() || meExpr.tyIdx != tyIdx || meExpr.GetIntrinsic() != intrinsic ||
+      meExpr.boundCheck != boundCheck) {
+    return false;
+  }
+  if (meExpr.GetNumOpnds() != GetNumOpnds()) {
+    return false;
+  }
+  return IsAllOpndsIdentical(meExpr);
+}
+
+bool IvarMeExpr::IsUseSameSymbol(const MeExpr &expr) const {
+  if (expr.GetExprID() == GetExprID()) {
+    return true;
+  }
+  if (expr.GetMeOp() != kMeOpIvar) {
+    return false;
+  }
+  auto &ivarMeExpr = static_cast<const IvarMeExpr&>(expr);
+  CHECK_FATAL(base != nullptr, "base is null");
+  if (base->IsUseSameSymbol(*ivarMeExpr.base) && fieldID == ivarMeExpr.fieldID && offset == ivarMeExpr.offset) {
+    return true;
+  }
+  return false;
+}
+
+bool IvarMeExpr::IsVolatile() const {
+  if (volatileFromBaseSymbol) {
+    return true;
+  }
+  auto *type = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx));
+  if (type->IsPointedTypeVolatile(fieldID)) {
+    return true;
+  }
+  MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(type->GetPointedTyIdx());
+  if (fieldID == 0) {
+    return pointedType->HasVolatileField();
+  }
+  return static_cast<MIRStructType*>(pointedType)->IsFieldVolatile(fieldID);
+}
+
+bool IvarMeExpr::IsFinal() {
+  auto *type = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx));
+  MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(type->GetPointedTyIdx());
+  if (fieldID == 0) {
+    return false;
+  }
+  return static_cast<MIRStructType*>(pointedType)->IsFieldFinal(fieldID);
+}
+
+
+// check paragma
+//   pragma 0 var %keySet <$Ljava_2Flang_2Fannotation_2FRCWeakRef_3B>
+
+bool IvarMeExpr::IsRCWeak() const {
+  auto *type = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx));
+  MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(type->GetPointedTyIdx());
+  if (pointedType->GetKind() == kTypeClass) {
+    auto *classType = static_cast<MIRClassType*>(pointedType);
+    return classType->IsFieldRCWeak(fieldID);
+  }
+  return false;
+}
+
+// If self is the first use of the same ivar coming from an iassign
+// (argument expr), then update its mu: expr->mu = this->mu.
+bool IvarMeExpr::IsIdentical(IvarMeExpr &expr, bool inConstructor) const {
+  CHECK_FATAL(expr.base != nullptr, "null ptr check");
+  if (base->GetExprID() != expr.base->GetExprID() || fieldID != expr.fieldID ||
+      offset != expr.offset || tyIdx != expr.tyIdx ||
+      (IsPrimitiveVector(primType) != IsPrimitiveVector(expr.GetPrimType()))) {
+    return false;
+  }
+
+  if (!inConstructor) {
+    auto *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    ASSERT(ptrType->IsMIRPtrType(), "Type of ivar must be poniter");
+    auto *pointedType = static_cast<MIRPtrType*>(ptrType)->GetPointedType();
+    if (pointedType->IsStructType()) {
+      auto attr = static_cast<MIRStructType*>(pointedType)->GetFieldAttrs(fieldID);
+      if (attr.GetAttr(FLDATTR_final)) {
+        return true;
+      }
+    }
+  }
+
+  return IsMuListIdentical(expr);
+}
+
+bool IvarMeExpr::IsMuListIdentical(IvarMeExpr &expr) const {
+  if (muList.size() != expr.muList.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < muList.size(); ++i) {
+    auto *mu = muList[i];
+    auto *rhsMu = expr.muList[i];
+    if (mu == rhsMu) {
+      continue;
+    }
+    // Two different mu may be regarded as identical
+    if (mu != nullptr && rhsMu != nullptr) {
+      if (mu->GetDefByMeStmt() == rhsMu->GetDefByMeStmt() && mu->GetDefByMeStmt() == nullptr) {
+        if (mu->GetDefBy() == kDefByPhi && rhsMu->GetDefBy() == kDefByPhi) {
+          if (mu->GetDefPhi().GetDefBB() == rhsMu->GetDefPhi().GetDefBB()) {
+            continue;  // check next mu
+          }
+          return false;
+        }
+
+        if (mu->GetDefBy() == kDefByNo && rhsMu->GetDefBy() == kDefByNo) {
+          continue;  // check next mu
+        }
+        return false;
+      }
+      if (mu->GetDefByMeStmt() == rhsMu->GetDefByMeStmt()) {
+        continue;  // check next mu
+      }
+      return false;
+    }
+
+    if (mu != nullptr && rhsMu == nullptr && expr.GetDefStmt() != nullptr) {
+      IassignMeStmt *iass = expr.GetDefStmt();
+      if (iass->GetOp() != OP_iassign) {
+        // this can happen due to use of placement new
+        return false;
+      }
+      bool foundMu = false;
+      for (auto xit = iass->GetChiList()->begin(); xit != iass->GetChiList()->end(); ++xit) {
+        ChiMeNode *chi = xit->second;
+        if (chi->GetLHS()->GetExprID() == mu->GetExprID()) {
+          expr.SetMuItem(i, mu);
+          foundMu = true;
+          break;
+        }
+      }
+      if (foundMu) {
+        continue;  // check next mu
+      }
+    }
+    return false;
+  }
+  return true;
+}
+
+MeExpr *IvarMeExpr::GetIdenticalExpr(MeExpr &expr, bool inConstructor) const {
+  auto *ivarExpr = static_cast<IvarMeExpr*>(&expr);
+
+  while (ivarExpr != nullptr) {
+    if (ivarExpr->GetMeOp() == kMeOpIvar && IsIdentical(*ivarExpr, inConstructor)) {
+      return ivarExpr;
+    }
+    ivarExpr = static_cast<IvarMeExpr*>(ivarExpr->GetNext());
+  }
+  return nullptr;
+}
+
+bool ScalarMeExpr::IsUseSameSymbol(const MeExpr &expr) const {
+  if (expr.GetMeOp() != GetMeOp()) {
+    return false;
+  }
+  auto &scalarMeExpr = static_cast<const ScalarMeExpr&>(expr);
+  return ost == scalarMeExpr.ost;
+}
+
+BB *ScalarMeExpr::DefByBB() const{
+  switch (defBy) {
+    case kDefByNo:
+      return nullptr;
+    case kDefByStmt:
+      ASSERT(def.defStmt, "ScalarMeExpr::DefByBB: defStmt cannot be nullptr");
+      return def.defStmt->GetBB();
+    case kDefByPhi:
+      ASSERT(def.defPhi, "ScalarMeExpr::DefByBB: defPhi cannot be nullptr");
+      return def.defPhi->GetDefBB();
+    case kDefByChi: {
+      ASSERT(def.defChi, "ScalarMeExpr::DefByBB: defChi cannot be nullptr");
+      ASSERT(def.defChi->GetBase(), "ScalarMeExpr::DefByBB: defChi->base cannot be nullptr");
+      return def.defChi->GetBase()->GetBB();
+    }
+    case kDefByMustDef: {
+      ASSERT(def.defMustDef, "ScalarMeExpr::DefByBB: defMustDef cannot be nullptr");
+      ASSERT(def.defMustDef->GetBase(), "ScalarMeExpr::DefByBB: defMustDef->base cannot be nullptr");
+      return def.defMustDef->GetBase()->GetBB();
+    }
+    default:
+      ASSERT(false, "ScalarMeExpr define unknown");
+      return nullptr;
+  }
+}
+
+MeStmt *ScalarMeExpr::GetDefByMeStmt() const {
+  switch (defBy) {
+    case kDefByNo:
+      return nullptr;
+    case kDefByStmt:
+      ASSERT(def.defStmt, "ScalarMeExpr::DefByBB: defStmt cannot be nullptr");
+      return def.defStmt;
+    case kDefByPhi:
+      ASSERT(def.defPhi, "ScalarMeExpr::DefByBB: defPhi cannot be nullptr");
+      return nullptr;
+    case kDefByChi: {
+      ASSERT(def.defChi, "ScalarMeExpr::DefByBB: defChi cannot be nullptr");
+      ASSERT(def.defChi->GetBase(), "ScalarMeExpr::DefByBB: defChi->base cannot be nullptr");
+      return GetDefChi().GetBase();
+    }
+    case kDefByMustDef: {
+      ASSERT(def.defMustDef, "ScalarMeExpr::DefByBB: defMustDef cannot be nullptr");
+      ASSERT(def.defMustDef->GetBase(), "ScalarMeExpr::DefByBB: defMustDef->base cannot be nullptr");
+      return def.defMustDef->GetBase();
+    }
+    default:
+      ASSERT(false, "ScalarMeExpr define unknown");
+      return nullptr;
+  }
+}
+
+BB *ScalarMeExpr::GetDefByBBMeStmt(const MeCFG &cfg, MeStmtPtr &defMeStmt) const {
+  switch (defBy) {
+    case kDefByNo:
+      return cfg.GetCommonEntryBB();
+    case kDefByStmt:
+      ASSERT(def.defStmt, "ScalarMeExpr::DefByBB: defStmt cannot be nullptr");
+      defMeStmt = def.defStmt;
+      return def.defStmt->GetBB();
+    case kDefByPhi:
+      ASSERT(def.defPhi, "ScalarMeExpr::DefByBB: defPhi cannot be nullptr");
+      return def.defPhi->GetDefBB();
+    case kDefByChi: {
+      ASSERT(def.defChi, "ScalarMeExpr::DefByBB: defChi cannot be nullptr");
+      ASSERT(def.defChi->GetBase(), "ScalarMeExpr::DefByBB: defChi->base cannot be nullptr");
+      defMeStmt = GetDefChi().GetBase();
+      return def.defChi->GetBase()->GetBB();
+    }
+    case kDefByMustDef: {
+      ASSERT(def.defMustDef, "ScalarMeExpr::DefByBB: defMustDef cannot be nullptr");
+      ASSERT(def.defMustDef->GetBase(), "ScalarMeExpr::DefByBB: defMustDef->base cannot be nullptr");
+      defMeStmt = def.defMustDef->GetBase();
+      return def.defMustDef->GetBase()->GetBB();
+    }
+    default:
+      ASSERT(false, "ScalarMeExpr define unknown");
+      return nullptr;
+  }
+}
+
+bool VarMeExpr::IsPureLocal(const MIRFunction &irFunc) const {
+  const MIRSymbol *st = GetOst()->GetMIRSymbol();
+  return st->IsLocal() && !irFunc.IsAFormal(st);
+}
+
+bool ScalarMeExpr::IsZeroVersion() const {
+  ASSERT(GetVstIdx() != 0, "VarMeExpr::IsZeroVersion: cannot determine because vstIdx is 0");
+  return GetOst()->GetZeroVersionIndex() == GetVstIdx();
+}
+
+bool AddrofMeExpr::IsUseSameSymbol(const MeExpr &expr) const {
+  if (expr.GetMeOp() != kMeOpAddrof) {
+    return false;
+  }
+  const auto &varMeExpr = static_cast<const AddrofMeExpr&>(expr);
+  return GetOstIdx() == varMeExpr.GetOstIdx();
+}
+
+bool OpMeExpr::IsUseSameSymbol(const MeExpr &expr) const {
+  if (expr.GetOp() != GetOp()) {
+    return false;
+  }
+  if (expr.GetMeOp() != kMeOpOp) {
+    return false;
+  }
+  auto &opMeExpr = static_cast<const OpMeExpr&>(expr);
+  for (uint32 i = 0; i < kOperandNumTernary; ++i) {
+    if (opnds[i]) {
+      if (!opMeExpr.opnds[i]) {
+        return false;
+      }
+      if (!opnds[i]->IsUseSameSymbol(*opMeExpr.opnds[i])) {
+        return false;
+      }
+    } else {
+      if (opMeExpr.opnds[i]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+MeExpr *OpMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  if (!kOpcodeInfo.NotPure(GetOp())) {
+    auto *opExpr = static_cast<OpMeExpr*>(&expr);
+
+    while (opExpr != nullptr) {
+      if (IsIdentical(*opExpr)) {
+        return opExpr;
+      }
+      opExpr = static_cast<OpMeExpr*>(opExpr->GetNext());
+    }
+  }
+
+  return nullptr;
+}
+
+bool OpMeExpr::StrengthReducible() {
+  if (MeOption::ivopts) {
+    return false;
+  }
+  if (!IsPrimitiveInteger(primType)) {
+    return false;
+  }
+  switch (op) {
+    case OP_cvt: {
+      return IsPrimitiveInteger(opndType) && GetPrimTypeSize(primType) >= GetPrimTypeSize(opndType);
+    }
+    case OP_mul: {
+      if (GetOpnd(1)->GetOp() == OP_constval) {
+        ConstMeExpr *cMeExpr = static_cast<ConstMeExpr *>(GetOpnd(1));
+        MIRIntConst *cnode = static_cast<MIRIntConst *>(cMeExpr->GetConstVal());
+        return cnode->GetExtValue() < 0x1000;
+      }
+      return false;
+    }
+    case OP_add:
+    case OP_sub: {
+      if (MeOption::srForAdd) {
+        return !HasAddressValue();
+      }
+      return false;
+    }
+    default: return false;
+  }
+}
+
+int64 OpMeExpr::SRMultiplier(OriginalSt *ost) {
+  ASSERT(StrengthReducible(), "OpMeExpr::SRMultiplier: operation is not strength reducible");
+  switch (op) {
+    case OP_cvt:
+    case OP_add:
+      return 1;
+    case OP_sub: {
+      ScalarMeExpr *scalarOpnd1 = dynamic_cast<ScalarMeExpr *>(GetOpnd(1));
+      if (scalarOpnd1 && scalarOpnd1->GetOst() == ost) {
+        return -1;
+      }
+      return 1;
+    }
+    case OP_mul: {
+      MIRConst *constVal = static_cast<ConstMeExpr *>(GetOpnd(1))->GetConstVal();
+      ASSERT(constVal->GetKind() == kConstInt, "OpMeExpr::SRMultiplier: multiplier not an integer constant");
+      return static_cast<MIRIntConst *>(constVal)->GetExtValue();
+    }
+    default:
+      CHECK_FATAL(false, "SRMultiplier: unexpected strength reduction opcode");
+  }
+  return 0;
+}
+
+// first, make sure it's int const and return true if the int const great or eq 0
+bool ConstMeExpr::GeZero() const {
+  return (GetExtIntValue() >= 0);
+}
+
+bool ConstMeExpr::GtZero() const {
+  CHECK_FATAL(constVal != nullptr, "constVal is null");
+  if (constVal->GetKind() != kConstInt) {
+    return false;
+  }
+  return (safe_cast<MIRIntConst>(constVal)->IsPositive());
+}
+
+bool ConstMeExpr::IsZero() const {
+  if (constVal->GetKind() == kConstInt) {
+    auto *intConst = safe_cast<MIRIntConst>(constVal);
+    CHECK_NULL_FATAL(intConst);
+    return (intConst->GetValue() == 0);
+  } else if (constVal->GetKind() == kConstFloatConst) {
+    auto *floatConst = safe_cast<MIRFloatConst>(constVal);
+    CHECK_NULL_FATAL(floatConst);
+    return (floatConst->GetIntValue() == 0);
+  } else if (constVal->GetKind() == kConstDoubleConst) {
+    auto *doubleConst = safe_cast<MIRDoubleConst>(constVal);
+    CHECK_NULL_FATAL(doubleConst);
+    return (doubleConst->GetIntValue() == 0);
+  }
+  return false;
+}
+
+bool ConstMeExpr::IsIntZero() const {
+  if (constVal->GetKind() == kConstInt) {
+    auto *intConst = safe_cast<MIRIntConst>(constVal);
+    CHECK_NULL_FATAL(intConst);
+    return (intConst->GetValue() == 0);
+  }
+  return false;
+}
+
+bool ConstMeExpr::IsOne() const {
+  CHECK_FATAL(constVal != nullptr, "constVal is null");
+  if (constVal->GetKind() != kConstInt) {
+    return false;
+  }
+  return safe_cast<MIRIntConst>(constVal)->IsOne();
+}
+
+IntVal ConstMeExpr::GetIntValue() const {
+  CHECK_FATAL(constVal != nullptr, "constVal is null");
+  CHECK_FATAL(constVal->GetKind() == kConstInt, "expect int const");
+  return safe_cast<MIRIntConst>(constVal)->GetValue();
+}
+
+int64 ConstMeExpr::GetExtIntValue() const {
+  CHECK_FATAL(constVal != nullptr, "constVal is null");
+  CHECK_FATAL(constVal->GetKind() == kConstInt, "expect int const");
+  return safe_cast<MIRIntConst>(constVal)->GetExtValue();
+}
+
+uint64 ConstMeExpr::GetZXTIntValue() const {
+  CHECK_FATAL(constVal != nullptr, "constVal is null");
+  CHECK_FATAL(constVal->GetKind() == kConstInt, "expect int const");
+  return safe_cast<MIRIntConst>(constVal)->GetZXTValue();
+}
+
+int64 ConstMeExpr::GetSXTIntValue() const {
+  CHECK_FATAL(constVal != nullptr, "constVal is null");
+  CHECK_FATAL(constVal->GetKind() == kConstInt, "expect int const");
+  return safe_cast<MIRIntConst>(constVal)->GetSXTValue();
+}
+
+MeExpr *ConstMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  auto *constExpr = static_cast<ConstMeExpr*>(&expr);
+
+  while (constExpr != nullptr) {
+    if (constExpr->GetMeOp() == kMeOpConst && constExpr->GetPrimType() == GetPrimType() &&
+        *constExpr->GetConstVal() == *constVal) {
+      return constExpr;
+    }
+    constExpr = static_cast<ConstMeExpr*>(constExpr->GetNext());
+  }
+
+  return nullptr;
+}
+
+MeExpr *ConststrMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  auto *constStrExpr = static_cast<ConststrMeExpr*>(&expr);
+
+  while (constStrExpr != nullptr) {
+    if (constStrExpr->GetMeOp() == kMeOpConststr && constStrExpr->GetStrIdx() == strIdx) {
+      return constStrExpr;
+    }
+    constStrExpr = static_cast<ConststrMeExpr*>(constStrExpr->GetNext());
+  }
+
+  return nullptr;
+}
+
+MeExpr *Conststr16MeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  auto *constStr16Expr = static_cast<Conststr16MeExpr*>(&expr);
+
+  while (constStr16Expr != nullptr) {
+    if (constStr16Expr->GetMeOp() == kMeOpConststr16 && constStr16Expr->GetStrIdx() == strIdx) {
+      return constStr16Expr;
+    }
+    constStr16Expr = static_cast<Conststr16MeExpr*>(constStr16Expr->GetNext());
+  }
+
+  return nullptr;
+}
+
+MeExpr *SizeoftypeMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  auto *sizeoftypeExpr = static_cast<SizeoftypeMeExpr*>(&expr);
+
+  while (sizeoftypeExpr != nullptr) {
+    if (sizeoftypeExpr->GetMeOp() == kMeOpSizeoftype && sizeoftypeExpr->GetTyIdx() == tyIdx) {
+      return sizeoftypeExpr;
+    }
+    sizeoftypeExpr = static_cast<SizeoftypeMeExpr*>(sizeoftypeExpr->GetNext());
+  }
+
+  return nullptr;
+}
+
+MeExpr *FieldsDistMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  auto *fieldsDistExpr = static_cast<FieldsDistMeExpr*>(&expr);
+
+  while (fieldsDistExpr != nullptr) {
+    if (fieldsDistExpr->GetMeOp() == kMeOpFieldsDist && fieldsDistExpr->GetTyIdx() == GetTyIdx() &&
+        fieldsDistExpr->GetFieldID1() == fieldID1 && fieldsDistExpr->GetFieldID2() == fieldID2) {
+        return fieldsDistExpr;
+    }
+    fieldsDistExpr = static_cast<FieldsDistMeExpr*>(fieldsDistExpr->GetNext());
+  }
+
+  return nullptr;
+}
+
+MeExpr *AddrofMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  auto *addrofExpr = static_cast<AddrofMeExpr*>(&expr);
+
+  while (addrofExpr != nullptr) {
+    if (addrofExpr->GetMeOp() == kMeOpAddrof &&
+        addrofExpr->GetOstIdx() == GetOstIdx() &&
+        addrofExpr->GetFieldID() == GetFieldID()) {
+      return addrofExpr;
+    }
+    addrofExpr = static_cast<AddrofMeExpr*>(addrofExpr->GetNext());
+  }
+
+  return nullptr;
+}
+
+MeExpr *NaryMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  auto *naryExpr = static_cast<NaryMeExpr*>(&expr);
+
+  while (naryExpr != nullptr) {
+    bool isPureIntrinsic =
+        naryExpr->GetOp() == OP_intrinsicop && IntrinDesc::intrinTable[naryExpr->GetIntrinsic()].IsPure();
+    if ((naryExpr->GetOp() == OP_array || isPureIntrinsic) && IsIdentical(*naryExpr)) {
+      return naryExpr;
+    }
+    naryExpr = static_cast<NaryMeExpr*>(naryExpr->GetNext());
+  }
+
+  return nullptr;
+}
+
+MeExpr *AddroffuncMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  auto *addroffuncExpr = static_cast<AddroffuncMeExpr*>(&expr);
+
+  while (addroffuncExpr != nullptr) {
+    if (addroffuncExpr->GetMeOp() == kMeOpAddroffunc && addroffuncExpr->GetPuIdx() == puIdx) {
+      return addroffuncExpr;
+    }
+    addroffuncExpr = static_cast<AddroffuncMeExpr*>(addroffuncExpr->GetNext());
+  }
+
+  return nullptr;
+}
+
+MeExpr *AddroflabelMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
+  auto *addroflabelExpr = static_cast<AddroflabelMeExpr*>(&expr);
+
+  while (addroflabelExpr != nullptr) {
+    if (addroflabelExpr->GetMeOp() == kMeOpAddroflabel && addroflabelExpr->labelIdx == labelIdx) {
+      return addroflabelExpr;
+    }
+    addroflabelExpr = static_cast<AddroflabelMeExpr*>(addroflabelExpr->GetNext());
+  }
+
+  return nullptr;
+}
+
+void MePhiNode::Dump(const IRMap *irMap) const {
+  const OriginalSt *ost =  lhs->GetOst();
+  bool isSym = ost->IsSymbolOst();
+  CHECK_FATAL(lhs != nullptr, "lsh is null");
+  if (isSym) {
+    if (isPiAdded) {
+      LogInfo::MapleLogger() << "PI_ADD VAR:";
+    }
+    LogInfo::MapleLogger() << "VAR:";
+    ost->Dump();
+  } else {
+    PregIdx regId = static_cast<RegMeExpr*>(lhs)->GetRegIdx();
+    LogInfo::MapleLogger() << "REGINDX:" << regId;
+    LogInfo::MapleLogger() << "(%"
+                           << irMap->GetMIRModule().CurFunction()
+                                                   ->GetPregTab()
+                                                   ->PregFromPregIdx(regId)
+                                                   ->GetPregNo()
+                           << ")";
+  }
+  LogInfo::MapleLogger() << " mx" << lhs->GetExprID();
+  LogInfo::MapleLogger() << " = MEPHI{";
+  for (size_t i = 0; i < opnds.size(); ++i) {
+    LogInfo::MapleLogger() << "mx" << opnds[i]->GetExprID();
+    if (i != opnds.size() - 1) {
+      LogInfo::MapleLogger() << ",";
+    }
+  }
+  LogInfo::MapleLogger() << "}";
+  if (!isLive) {
+    LogInfo::MapleLogger() << " dead";
+  }
+  LogInfo::MapleLogger() << '\n';
+}
+
+void VarMeExpr::Dump(const IRMap *irMap, int32) const {
+  CHECK_NULL_FATAL(irMap);
+  LogInfo::MapleLogger() << "VAR ";
+  GetOst()->Dump();
+  LogInfo::MapleLogger() << " (field)" << GetOst()->GetFieldID();
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+  if (IsZeroVersion()) {
+    LogInfo::MapleLogger() << "<Z>";
+  }
+}
+
+void RegMeExpr::Dump(const IRMap *irMap, int32) const {
+  CHECK_NULL_FATAL(irMap);
+  LogInfo::MapleLogger() << "REGINDX:" << GetRegIdx();
+  LogInfo::MapleLogger() << " " << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger()
+      << " %"
+      << irMap->GetMIRModule().CurFunction()->GetPregTab()->PregFromPregIdx(GetRegIdx())->GetPregNo();
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+}
+
+void AddroffuncMeExpr::Dump(const IRMap*, int32) const {
+  LogInfo::MapleLogger() << "ADDROFFUNC:";
+  LogInfo::MapleLogger() << GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx)->GetName();
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+}
+
+void AddroflabelMeExpr::Dump(const IRMap *irMap, int32) const {
+  LogInfo::MapleLogger() << "ADDROFLABEL:";
+  LogInfo::MapleLogger() << " @" << irMap->GetMIRModule().CurFunction()->GetLabelName(labelIdx);
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+}
+
+void GcmallocMeExpr::Dump(const IRMap*, int32) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOp()).name << " " << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger() << " ";
+  GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(0);
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+  LogInfo::MapleLogger() << " ";
+}
+
+void ConstMeExpr::Dump(const IRMap*, int32) const {
+  LogInfo::MapleLogger() << "CONST ";
+  LogInfo::MapleLogger() << GetPrimTypeName(constVal->GetType().GetPrimType()) << " ";
+  CHECK_FATAL(constVal != nullptr, "constVal is null");
+  constVal->Dump();
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+}
+
+void ConststrMeExpr::Dump(const IRMap*, int32) const {
+  LogInfo::MapleLogger() << "CONSTSTR";
+  LogInfo::MapleLogger() << " ";
+  LogInfo::MapleLogger() << strIdx;
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+}
+
+void Conststr16MeExpr::Dump(const IRMap*, int32) const {
+  LogInfo::MapleLogger() << "CONSTSTR16";
+  LogInfo::MapleLogger() << " ";
+  LogInfo::MapleLogger() << strIdx;
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+}
+
+void SizeoftypeMeExpr::Dump(const IRMap*, int32) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOp()).name << " " << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger() << " TYIDX:" << tyIdx;
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  mirType->Dump(0);
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+}
+
+void FieldsDistMeExpr::Dump(const IRMap*, int32) const {
+  LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOp()).name << " " << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger() << " TYIDX:" << tyIdx;
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  mirType->Dump(0);
+  LogInfo::MapleLogger() << " (field)" << fieldID1;
+  LogInfo::MapleLogger() << " (field)" << fieldID2;
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+}
+
+void AddrofMeExpr::Dump(const IRMap*, int32) const {
+  LogInfo::MapleLogger() << "ADDROF:";
+  GetOst()->Dump();
+  LogInfo::MapleLogger() << " (field)" << GetFieldID();
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+}
+
+void OpMeExpr::Dump(const IRMap *irMap, int32 indent) const {
+  LogInfo::MapleLogger() << "OP " << kOpcodeInfo.GetTableItemAt(GetOp()).name;
+  LogInfo::MapleLogger() << " " << GetPrimTypeName(primType) << " " << GetPrimTypeName(opndType);
+  if (GetOp() == OP_iaddrof) {
+    LogInfo::MapleLogger() << " (field)" << GetFieldID();
+  }
+  LogInfo::MapleLogger() << " mx" << GetExprID();
+  LogInfo::MapleLogger() << '\n';
+  ASSERT(opnds[0] != nullptr, "OpMeExpr::Dump: cannot have 0 operand");
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << "opnd[0] = ";
+  opnds[0]->Dump(irMap, indent + 1);
+  if (opnds[1]) {
+    LogInfo::MapleLogger() << '\n';
+  } else {
+    return;
+  }
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << "opnd[1] = ";
+  opnds[1]->Dump(irMap, indent + 1);
+  if (opnds[2]) {
+    LogInfo::MapleLogger() << '\n';
+  } else {
+    return;
+  }
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << "opnd[2] = ";
+  opnds[2]->Dump(irMap, indent + 1);
+}
+
+void IvarMeExpr::Dump(const IRMap *irMap, int32 indent) const {
+  LogInfo::MapleLogger() << "IVAR mx" << GetExprID();
+  LogInfo::MapleLogger() << " " << GetPrimTypeName(GetPrimType());
+  LogInfo::MapleLogger() << " TYIDX:" << tyIdx;
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  mirType->Dump(0);
+  LogInfo::MapleLogger() << " (field)" << fieldID;
+  if (op == OP_ireadoff) {
+    LogInfo::MapleLogger() << " (offset)" << offset;
+  }
+  LogInfo::MapleLogger() << std::endl;
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << "base = ";
+  CHECK_FATAL(base != nullptr, "base is null");
+  base->Dump(irMap, indent + 1);
+  LogInfo::MapleLogger() << '\n';
+  PrintIndentation(indent + 1);
+  LogInfo::MapleLogger() << "- MU: {";
+  bool firstMu = true;
+  for (auto *mu : muList) {
+    if (mu != nullptr) {
+      if (!firstMu) {
+        LogInfo::MapleLogger() << ", ";
+      }
+      mu->Dump(irMap);
+      firstMu = false;
+    }
+  }
+  LogInfo::MapleLogger() << "}";
+}
+
+void NaryMeExpr::Dump(const IRMap *irMap, int32 indent) const {
+  ASSERT(static_cast<size_t>(GetNumOpnds()) == opnds.size(), "array size error");
+  if (GetOp() == OP_array) {
+    LogInfo::MapleLogger() << "ARRAY ";
+  } else if (GetOp() == OP_intrinsicop) {
+    LogInfo::MapleLogger() << GetIntrinsicName(intrinsic);
+  } else {
+    ASSERT(GetOp() == OP_intrinsicopwithtype, "NaryMeExpr has bad GetOp()code");
+    LogInfo::MapleLogger() << "INTRINOPWTY[" << intrinsic << "]";
+  }
+  LogInfo::MapleLogger() << " mx" << GetExprID() << '\n';
+  for (int32 i = 0; i < GetNumOpnds(); ++i) {
+    PrintIndentation(indent + 1);
+    LogInfo::MapleLogger() << "opnd[" << i << "] = ";
+    opnds[i]->Dump(irMap, indent + 1);
+    if (i != GetNumOpnds() - 1) {
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+MeExpr *DassignMeStmt::GetLHSRef(bool excludeLocalRefVar) {
+  ScalarMeExpr *lhsOpnd = GetVarLHS();
+  if (lhsOpnd->GetPrimType() != PTY_ref) {
+    return nullptr;
+  }
+  const OriginalSt *ost = lhsOpnd->GetOst();
+  if (ost->IsIgnoreRC()) {
+    return nullptr;
+  }
+  if (excludeLocalRefVar && ost->IsLocal()) {
+    return nullptr;
+  }
+  return lhsOpnd;
+}
+
+MeExpr *MaydassignMeStmt::GetLHSRef(bool excludeLocalRefVar) {
+  ScalarMeExpr *lhs = GetVarLHS();
+  if (lhs->GetPrimType() != PTY_ref) {
+    return nullptr;
+  }
+  const OriginalSt *ost = lhs->GetOst();
+  if (ost->IsIgnoreRC()) {
+    return nullptr;
+  }
+  if (excludeLocalRefVar && ost->IsLocal()) {
+    return nullptr;
+  }
+  return lhs;
+}
+
+MeExpr *IassignMeStmt::GetLHSRef(bool) {
+  CHECK_FATAL(lhsVar != nullptr, "lhsVar is null");
+  MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsVar->GetTyIdx());
+  ASSERT(baseType != nullptr, "null ptr check");
+  auto *pType = static_cast<MIRPtrType*>(baseType)->GetPointedType();
+  if (!pType->IsStructType()) {
+    if (pType->GetKind() == kTypePointer) {
+      if (lhsVar->GetFieldID() == 0) {
+        if (static_cast<MIRPtrType*>(pType)->GetPrimType() != PTY_ref) {
+          return nullptr;
+        }
+      } else {
+        auto *ppType = static_cast<MIRPtrType*>(pType)->GetPointedType();
+        auto fTyIdx = static_cast<MIRStructType*>(ppType)->GetFieldTyIdx(lhsVar->GetFieldID());
+        if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(fTyIdx)->GetPrimType() != PTY_ref) {
+          return nullptr;
+        }
+      }
+    } else if (pType->GetKind() == kTypeJArray) {
+      auto *ppType = static_cast<MIRPtrType*>(pType)->GetPointedType();
+      if (static_cast<MIRPtrType*>(ppType)->GetPrimType() != PTY_ref) {
+        return nullptr;
+      }
+    } else {
+      return nullptr;
+    }
+  } else {
+    auto *structType = static_cast<MIRStructType*>(pType);
+    if (lhsVar->GetFieldID() == 0) {
+      return nullptr;  // struct assign is not ref
+    }
+    if (structType->GetFieldType(lhsVar->GetFieldID())->GetPrimType() != PTY_ref) {
+      return nullptr;
+    }
+  }
+  return lhsVar;
+}
+
+VarMeExpr *AssignedPart::GetAssignedPartLHSRef(bool excludeLocalRefVar) {
+  if (mustDefList.empty()) {
+    return nullptr;
+  }
+  MeExpr *assignedLHS = mustDefList.front().GetLHS();
+  if (assignedLHS->GetMeOp() != kMeOpVar) {
+    return nullptr;
+  }
+  auto *theLHS = static_cast<VarMeExpr*>(assignedLHS);
+  if (theLHS->GetPrimType() != PTY_ref) {
+    return nullptr;
+  }
+  const OriginalSt *ost = theLHS->GetOst();
+  if (ost->IsIgnoreRC()) {
+    return nullptr;
+  }
+  if (excludeLocalRefVar && ost->IsLocal()) {
+    return nullptr;
+  }
+  return theLHS;
+}
+
+// default Dump
+void MeStmt::Dump(const IRMap *irMap) const {
+  if (op == OP_comment) {
+    return;
+  }
+  CHECK_NULL_FATAL(irMap);
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  irMap->GetMIRModule().GetOut() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(op).name << '\n';
+}
+
+// get the real next mestmt that is not a comment
+MeStmt *MeStmt::GetNextMeStmt() const {
+  MeStmt *nextMeStmt = next;
+  while (nextMeStmt != nullptr && nextMeStmt->op == OP_comment) {
+    nextMeStmt = nextMeStmt->next;
+  }
+  return nextMeStmt;
+}
+
+void PiassignMeStmt::Dump(const IRMap *irMap) const {
+  LogInfo::MapleLogger() << "||MEIR PI|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " ";
+  CHECK_FATAL(lhs != nullptr, "lhs is null");
+  lhs->Dump(irMap);
+  LogInfo::MapleLogger() << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << "rhs = ";
+  rhs->Dump(irMap, kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void DassignMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " ";
+  CHECK_FATAL(lhs != nullptr, "lhs is null");
+  lhs->Dump(irMap);
+  LogInfo::MapleLogger() << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << "rhs = ";
+  CHECK_FATAL(rhs != nullptr, "rhs is null");
+  rhs->Dump(irMap, kDefaultPrintIndentNum);
+  if (needIncref) {
+    LogInfo::MapleLogger() << " [RC+]";
+  }
+  if (needDecref) {
+    LogInfo::MapleLogger() << " [RC-]";
+  }
+  LogInfo::MapleLogger() << '\n';
+  DumpChiList(irMap, chiList);
+}
+
+void AssignMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " ";
+  CHECK_FATAL(lhs != nullptr, "lhs is null");
+  lhs->Dump(irMap);
+  LogInfo::MapleLogger() << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << "rhs = ";
+  CHECK_FATAL(rhs != nullptr, "rhs is null");
+  rhs->Dump(irMap, kDefaultPrintIndentNum);
+  if (needIncref) {
+    LogInfo::MapleLogger() << " [RC+]";
+  }
+  LogInfo::MapleLogger() << '\n';
+}
+
+void MaydassignMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << "rhs = ";
+  CHECK_FATAL(rhs != nullptr, "rhs is null");
+  rhs->Dump(irMap, kDefaultPrintIndentNum);
+  if (needIncref) {
+    LogInfo::MapleLogger() << " [RC+]";
+  }
+  if (needDecref) {
+    LogInfo::MapleLogger() << " [RC-]";
+  }
+  LogInfo::MapleLogger() << '\n';
+  DumpChiList(irMap, chiList);
+}
+
+void ChiMeNode::Dump(const IRMap *irMap) const {
+  CHECK_NULL_FATAL(irMap);
+  auto *meLHS = static_cast<VarMeExpr*>(lhs);
+  auto *meRHS = static_cast<VarMeExpr*>(rhs);
+  CHECK_FATAL(meLHS != nullptr, "Node doesn't have lhs?");
+  CHECK_FATAL(meRHS != nullptr, "Node doesn't have rhs?");
+  if (!DumpOptions::GetSimpleDump()) {
+    LogInfo::MapleLogger() << "VAR:";
+    meLHS->GetOst()->Dump();
+  }
+  LogInfo::MapleLogger() << " mx" << meLHS->GetExprID() << " = CHI{";
+  LogInfo::MapleLogger() << "mx" << meRHS->GetExprID() << "}";
+}
+
+void DumpMuList(const IRMap *irMap, const MapleMap<OStIdx, ScalarMeExpr*> &muList) {
+  if (muList.empty()) {
+    return;
+  }
+  int count = 0;
+  LogInfo::MapleLogger() << "---- MULIST: { ";
+  for (auto it = muList.begin();;) {
+    if (!DumpOptions::GetSimpleDump()) {
+      (*it).second->Dump(irMap);
+    } else {
+      LogInfo::MapleLogger() << "mx" << (*it).second->GetExprID();
+    }
+    ++it;
+    if (it == muList.end()) {
+      break;
+    } else {
+      LogInfo::MapleLogger() << ", ";
+    }
+    if (DumpOptions::GetDumpVsyNum() > 0 && ++count >= DumpOptions::GetDumpVsyNum()) {
+      LogInfo::MapleLogger() << " ... ";
+      break;
+    }
+  }
+  LogInfo::MapleLogger() << " }\n";
+}
+
+void DumpChiList(const IRMap *irMap, const MapleMap<OStIdx, ChiMeNode*> &chiList) {
+  if (chiList.empty()) {
+    return;
+  }
+  int count = 0;
+  LogInfo::MapleLogger() << "---- CHILIST: { ";
+  for (auto it = chiList.begin();;) {
+    it->second->Dump(irMap);
+    ++it;
+    if (it == chiList.end()) {
+      break;
+    } else {
+      LogInfo::MapleLogger() << ", ";
+    }
+    if (DumpOptions::GetDumpVsyNum() > 0 && count++ >= DumpOptions::GetDumpVsyNum()) {
+      LogInfo::MapleLogger() << " ... ";
+      break;
+    }
+  }
+  LogInfo::MapleLogger() << " }\n";
+}
+
+void IassignMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << "lhs = ";
+  CHECK_FATAL(lhsVar != nullptr, "lhsVar is null");
+  lhsVar->Dump(irMap, kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << "rhs = ";
+  CHECK_FATAL(rhs != nullptr, "rhs is null");
+  rhs->Dump(irMap, kDefaultPrintIndentNum);
+  if (needIncref) {
+    LogInfo::MapleLogger() << " [RC+]";
+  }
+  if (needDecref) {
+    LogInfo::MapleLogger() << " [RC-]";
+  }
+  LogInfo::MapleLogger() << '\n';
+  DumpChiList(irMap, chiList);
+}
+
+void NaryMeStmt::DumpOpnds(const IRMap *irMap) const {
+  for (size_t i = 0; i < opnds.size(); ++i) {
+    PrintIndentation(kDefaultPrintIndentNum);
+    LogInfo::MapleLogger() << "opnd[" << i << "] = ";
+    opnds[i]->Dump(irMap, kDefaultPrintIndentNum);
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+void NaryMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " \n";
+  DumpOpnds(irMap);
+}
+
+void AssignedPart::DumpAssignedPart(const IRMap *irMap) const {
+  LogInfo::MapleLogger() << "    assignedpart: {";
+  for (auto it = mustDefList.begin(); it != mustDefList.end(); ++it) {
+    LogInfo::MapleLogger() << " ";
+    const MeExpr *lhsVar = (*it).GetLHS();
+    lhsVar->Dump(irMap);
+  }
+  if (needIncref) {
+    LogInfo::MapleLogger() << " [RC+]";
+  }
+  if (needDecref) {
+    LogInfo::MapleLogger() << " [RC-]";
+  }
+  LogInfo::MapleLogger() << "}\n";
+}
+
+void CallMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " ";
+  if (tyIdx != 0u) {
+    LogInfo::MapleLogger() << " TYIDX:" << tyIdx;
+    MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    mirType->Dump(0);
+  }
+  // target function name
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  if (irMap->GetMIRModule().IsJavaModule()) {
+    LogInfo::MapleLogger() << namemangler::DecodeName(func->GetName()) << '\n';
+  } else {
+    LogInfo::MapleLogger() << func->GetName() << '\n';
+  }
+  DumpOpnds(irMap);
+  DumpMuList(irMap, muList);
+  DumpChiList(irMap, chiList);
+  DumpAssignedPart(irMap);
+}
+
+void IcallMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " ";
+  LogInfo::MapleLogger() << " TYIDX:" << retTyIdx;
+  DumpOpnds(irMap);
+  DumpMuList(irMap, muList);
+  DumpChiList(irMap, chiList);
+  DumpAssignedPart(irMap);
+}
+
+void IntrinsiccallMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " ";
+  LogInfo::MapleLogger() << "TYIDX:" << tyIdx;
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  if (mirType != nullptr) {
+    mirType->Dump(0);
+  }
+  LogInfo::MapleLogger() << GetIntrinsicName(intrinsic) << '\n';
+  DumpOpnds(irMap);
+  DumpMuList(irMap, muList);
+  DumpChiList(irMap, chiList);
+  DumpAssignedPart(irMap);
+}
+
+void AsmMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " \"";
+  if (!asmString.empty()) {
+    LogInfo::MapleLogger() << asmString.c_str();
+  }
+  LogInfo::MapleLogger() << " \"\n";
+
+  DumpOpnds(irMap);
+  DumpMuList(irMap, muList);
+  DumpChiList(irMap, chiList);
+  DumpAssignedPart(irMap);
+}
+
+void RetMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n';
+  DumpOpnds(irMap);
+  DumpMuList(irMap, muList);
+}
+
+void CondGotoMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name;
+  if (IsBranchProbValid()) {
+    double branchPercent = branchProb * 100.0 / CondGotoNode::probAll;
+    LogInfo::MapleLogger() << " [fallthru: " << (100.0 - branchPercent) << "%, branch: " << branchPercent << "%]";
+  }
+  LogInfo::MapleLogger() << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << "cond: ";
+  auto mirFunc = static_cast<const MeIRMap*>(irMap)->GetFunc().GetMirFunc();
+  LogInfo::MapleLogger() << " @" << mirFunc->GetLabelName(LabelIdx(offset));
+  GetOpnd()->Dump(irMap, kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void UnaryMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << " unaryopnd: ";
+  CHECK_FATAL(opnd != nullptr, "opnd is null");
+  opnd->Dump(irMap, kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void SwitchMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << "switchOpnd: ";
+  GetOpnd()->Dump(irMap, kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << '\n';
+}
+
+void GosubMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n';
+  DumpMuList(irMap, *GetMuList());
+  LogInfo::MapleLogger() << '\n';
+}
+
+void ThrowMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n';
+  PrintIndentation(kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << "throwopnd: ";
+  CHECK_FATAL(opnd != nullptr, "opnd is null");
+  opnd->Dump(irMap, kDefaultPrintIndentNum);
+  LogInfo::MapleLogger() << '\n';
+  DumpMuList(irMap, *GetMuList());
+}
+
+void SyncMeStmt::Dump(const IRMap *irMap) const {
+  if (IsInSafeRegion()) {
+    stmtAttrs.DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  LogInfo::MapleLogger() << "\n";
+  LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n';
+  DumpOpnds(irMap);
+  DumpMuList(irMap, muList);
+  DumpChiList(irMap, chiList);
+}
+
+bool MeStmt::IsTheSameWorkcand(const MeStmt &mestmt) const {
+  if (op != mestmt.op) {
+    return false;
+  }
+  if (op == OP_dassign) {
+    if (this->GetVarLHS()->GetOst() != mestmt.GetVarLHS()->GetOst()) {
+      return false;
+    }
+  } else if (op == OP_intrinsiccallwithtype) {
+    if (static_cast<const IntrinsiccallMeStmt*>(this)->GetTyIdx() !=
+        static_cast<const IntrinsiccallMeStmt &>(mestmt).GetTyIdx()) {
+      return false;
+    }
+    if (static_cast<const IntrinsiccallMeStmt*>(this)->GetIntrinsic() !=
+        static_cast<const IntrinsiccallMeStmt &>(mestmt).GetIntrinsic()) {
+      return false;
+    }
+  } else if (op == OP_callassigned) {
+    auto *thisCass = static_cast<const CallMeStmt*>(this);
+    auto &cass = static_cast<const CallMeStmt &>(mestmt);
+    if (thisCass->GetPUIdx() != cass.GetPUIdx()) {
+      return false;
+    }
+    if (thisCass->MustDefListSize() != cass.MustDefListSize()) {
+      return false;
+    }
+    if (thisCass->MustDefListSize() > 0) {
+      auto *thisVarMeExpr = static_cast<const VarMeExpr*>(thisCass->GetAssignedLHS());
+      auto *varMeExpr = static_cast<const VarMeExpr*>(cass.GetAssignedLHS());
+      if (thisVarMeExpr->GetOst() != varMeExpr->GetOst()) {
+        return false;
+      }
+    }
+  }
+  // check the operands
+  for (size_t i = 0; i < NumMeStmtOpnds(); ++i) {
+    ASSERT(GetOpnd(i) != nullptr, "null ptr check");
+    if (!GetOpnd(i)->IsUseSameSymbol(*mestmt.GetOpnd(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool VarMeExpr::IsVolatile() const {
+  const OriginalSt *ost = GetOst();
+  if (!ost->IsSymbolOst()) {
+    return false;
+  }
+  const MIRSymbol *sym = ost->GetMIRSymbol();
+  if (sym->IsVolatile()) {
+    return true;
+  }
+  if (ost->GetFieldID() == 0) {
+    return (ost->GetType()->HasVolatileField());
+  }
+  MIRType *type = nullptr;
+  if (ost->GetPointerTyIdx() != 0) {
+    auto *ptrType = ost->GetPrevLevelPointerType();
+    CHECK_FATAL(ptrType->IsMIRPtrType(), "must be pointer type");
+    type = static_cast<MIRPtrType *>(ptrType)->GetPointedType();
+  } else if (ost->GetIndirectLev() == 0) {
+    type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx());
+  } else {
+    return false;
+  }
+
+  if (type->GetKind() == kTypeArray) {
+    type = static_cast<MIRArrayType*>(type)->GetElemType();
+  } else if (type->GetKind() == kTypeFArray ||
+             type->GetKind() == kTypeJArray) {
+    type = static_cast<MIRFarrayType*>(type)->GetElemType();
+  }
+
+  CHECK_FATAL(type->IsStructType(), "must be struct type");
+  auto *structType = static_cast<MIRStructType*>(type);
+  return structType->IsFieldVolatile(ost->GetFieldID());
+}
+
+bool VarMeExpr::PointsToStringLiteral() {
+  VarMeExpr &var = ResolveVarMeValue();
+  if (var.GetDefBy() == kDefByMustDef) {
+    MeStmt *baseStmt = var.GetDefMustDef().GetBase();
+    if (baseStmt->GetOp() == OP_callassigned) {
+      auto *call = static_cast<CallMeStmt*>(baseStmt);
+      MIRFunction &callFunc = call->GetTargetFunction();
+      if (callFunc.GetName() == "MCC_GetOrInsertLiteral") {
+        return true;
+      }
+    }
+  }
+  const OriginalSt *ost = var.GetOst();
+  if (!ost->IsSymbolOst()) {
+    return false;
+  }
+  const MIRSymbol *sym = ost->GetMIRSymbol();
+  if (sym->IsLiteralPtr()) {
+    return true;
+  }
+  return false;
+}
+
+MeExpr *MeExpr::FindSymAppearance(OStIdx oidx) {
+  if (meOp == kMeOpVar) {
+    if (static_cast<VarMeExpr*>(this)->GetOstIdx() == oidx) {
+      return this;
+    }
+    return nullptr;
+  }
+  for (uint8 i = 0; i < GetNumOpnds(); ++i) {
+    MeExpr *retx = GetOpnd(i)->FindSymAppearance(oidx);
+    if (retx != nullptr) {
+      return retx;
+    }
+  }
+  return nullptr;
+}
+
+bool MeExpr::SymAppears(OStIdx oidx) {
+  return FindSymAppearance(oidx) != nullptr;
+}
+
+bool MeExpr::HasIvar() const {
+  if (meOp == kMeOpIvar) {
+    return true;
+  }
+  for (uint8 i = 0; i < GetNumOpnds(); ++i) {
+    ASSERT(GetOpnd(i) != nullptr, "null ptr check");
+    if (GetOpnd(i)->HasIvar()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MeExpr::IsDexMerge() const {
+  if (op != OP_intrinsicop) {
+    return false;
+  }
+  auto *naryx = static_cast<const NaryMeExpr*>(this);
+  if (naryx->GetIntrinsic() != INTRN_JAVA_MERGE) {
+    return false;
+  }
+  if (naryx->GetOpnds().size() != 1) {
+    return false;
+  }
+  if (naryx->GetOpnd(0)->GetMeOp() == kMeOpVar || naryx->GetOpnd(0)->GetMeOp() == kMeOpIvar) {
+    return true;
+  }
+  if (naryx->GetOpnd(0)->GetMeOp() == kMeOpReg) {
+    auto *r = static_cast<RegMeExpr*>(naryx->GetOpnd(0));
+    return r->GetRegIdx() >= 0;
+  }
+  return false;
+}
+
+// check if MeExpr can be a pointer to something that requires incref for its
+// assigned target
+bool MeExpr::PointsToSomethingThatNeedsIncRef() {
+  if (op == OP_retype) {
+    return true;
+  }
+  if (IsDexMerge()) {
+    return true;
+  }
+  if (meOp == kMeOpIvar) {
+    return true;
+  }
+  if (meOp == kMeOpVar) {
+    auto *var = static_cast<VarMeExpr*>(this);
+    if (var->PointsToStringLiteral()) {
+      return false;
+    }
+    return true;
+  }
+  if (meOp == kMeOpReg) {
+    auto *r = static_cast<RegMeExpr*>(this);
+    return r->GetRegIdx() != -kSregThrownval;
+  }
+  return false;
+}
+
+MapleMap<OStIdx, ChiMeNode*> *GenericGetChiListFromVarMeExprInner(ScalarMeExpr &expr,
+                                                                  std::unordered_set<ScalarMeExpr*> &visited) {
+  if (expr.GetDefBy() == kDefByNo || visited.find(&expr) != visited.end()) {
+    return nullptr;
+  }
+  visited.insert(&expr);
+  if (expr.GetDefBy() == kDefByPhi) {
+    MePhiNode &phiMe = expr.GetDefPhi();
+    MapleVector<ScalarMeExpr*> &phiOpnds = phiMe.GetOpnds();
+    for (auto it = phiOpnds.begin(); it != phiOpnds.end(); ++it) {
+      auto *meExpr = static_cast<VarMeExpr*>(*it);
+      MapleMap<OStIdx, ChiMeNode*> *chiList = GenericGetChiListFromVarMeExprInner(*meExpr, visited);
+      if (chiList != nullptr) {
+        return chiList;
+      }
+    }
+    return nullptr;
+  }
+  if (expr.GetDefBy() == kDefByChi) {
+    return expr.GetDefChi().GetBase()->GetChiList();
+  }
+  return nullptr;
+}
+
+MapleMap<OStIdx, ChiMeNode*> *GenericGetChiListFromVarMeExpr(ScalarMeExpr &expr) {
+  std::unordered_set<ScalarMeExpr*> visited;
+  return GenericGetChiListFromVarMeExprInner(expr, visited);
+}
+
+void CallMeStmt::SetCallReturn(ScalarMeExpr &curexpr) {
+  MustDefMeNode &mustDefMeNode = GetMustDefList()->front();
+  mustDefMeNode.UpdateLHS(curexpr);
+}
+
+bool DumpOptions::simpleDump = false;
+int DumpOptions::dumpVsymNum = 0;
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_irmap.cpp b/src/mapleall/maple_me/src/me_irmap.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb1bee0e6b77d8d6c5c98cef74008277ce4d1b03
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_irmap.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_irmap.h"
+
+namespace maple {
+void MeIRMap::Dump() {
+  // back up mempool and use a new mempool every time
+  // we dump IRMap, restore the mempool afterwards
+  MIRFunction *mirFunction = func.GetMirFunc();
+  MemPool *backup = mirFunction->GetCodeMempool();
+  mirFunction->SetMemPool(new ThreadLocalMemPool(memPoolCtrler, "IR Dump"));
+  auto theCFG = func.GetCfg();
+  LogInfo::MapleLogger() << "===================Me IR dump==================\n";
+  auto eIt = theCFG->valid_end();
+  for (auto bIt = theCFG->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    bb->DumpHeader(&GetMIRModule());
+    LogInfo::MapleLogger() << "frequency : " << bb->GetFrequency() << "\n";
+    bb->DumpMeVarPiList(this);
+    bb->DumpMePhiList(this);
+    int i = 0;
+    for (auto &meStmt : bb->GetMeStmts()) {
+      if (GetDumpStmtNum()) {
+        LogInfo::MapleLogger() << "(" << i++ << ") ";
+      }
+      if (meStmt.GetOp() != OP_piassign) {
+        meStmt.EmitStmt(mirFunction->GetCodeMemPoolAllocator()).Dump(0);
+      }
+      meStmt.Dump(this);
+    }
+  }
+  mirFunction->ReleaseCodeMemory();
+  mirFunction->SetMemPool(backup);
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_irmap_build.cpp b/src/mapleall/maple_me/src/me_irmap_build.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe13de99737155c55fb5fe6cad236c1c2c17aa83
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_irmap_build.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "me_irmap_build.h"
+#include "me_ssa.h"
+#include "me_ssa_tab.h"
+#include "me_prop.h"
+#include "me_alias_class.h"
+#include "me_dse.h"
+
+// This phase converts Maple IR to MeIR.
+
+namespace maple {
+void MEIRMapBuild::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.AddRequired<MESSATab>();
+  aDep.AddRequired<MEAliasClass>();
+  aDep.AddRequired<MESSA>();
+  aDep.AddRequired<MEDominance>();
+  aDep.PreservedAllExcept<MESSA>();
+  aDep.PreservedAllExcept<MEDse>();
+}
+
+bool MEIRMapBuild::PhaseRun(maple::MeFunction &f) {
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  ASSERT_NOT_NULL(dom);
+  auto pdom = dominancePhase->GetPdomResult();
+  ASSERT_NOT_NULL(pdom);
+  irMap = GetPhaseAllocator()->New<MeIRMap>(f, *GetPhaseMemPool());
+  f.SetIRMap(irMap);
+#if DEBUG
+  globalIRMap = irMap;
+#endif
+  MemPool *propMp = nullptr;
+  MeCFG *cfg = f.GetCfg();
+  if (!f.GetMIRModule().IsJavaModule() && MeOption::propDuringBuild) {
+    // create propgation
+    propMp = ApplyTempMemPool();
+    MeProp meprop(*irMap, *dom, *pdom, *propMp, Prop::PropConfig{false, false, false, false, false, false, false});
+    meprop.isLfo = f.IsLfo();
+    IRMapBuild irmapbuild(irMap, dom, &meprop);
+    std::vector<bool> bbIrmapProcessed(cfg->NumBBs(), false);
+    irmapbuild.BuildBB(*cfg->GetCommonEntryBB(), bbIrmapProcessed);
+  } else {
+    IRMapBuild irmapbuild(irMap, dom, nullptr);
+    std::vector<bool> bbIrmapProcessed(cfg->NumBBs(), false);
+    irmapbuild.BuildBB(*cfg->GetCommonEntryBB(), bbIrmapProcessed);
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    irMap->Dump();
+    if (f.GetCfg()->UpdateCFGFreq()) {
+      f.GetCfg()->DumpToFile("irmapbuild", true, true);
+    }
+  }
+
+  // delete mempool for meirmap temporaries
+  // now versmp use one mempool as analysis result, just clear the content here
+  // delete input IR code for current function
+  MIRFunction *mirFunc = f.GetMirFunc();
+  mirFunc->ReleaseCodeMemory();
+
+  // delete versionst_table
+  // nullify all references to the versionst_table contents
+  for (uint32 i = 0; i < f.GetMeSSATab()->GetVersionStTable().GetVersionStVectorSize(); i++) {
+    f.GetMeSSATab()->GetVersionStTable().SetVersionStVectorItem(i, nullptr);
+  }
+  // clear BB's phiList which uses versionst; nullify first_stmt_, last_stmt_
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    bb->ClearPhiList();
+    bb->SetFirst(nullptr);
+    bb->SetLast(nullptr);
+  }
+  f.ReleaseVersMemory();
+  f.SetMeFuncState(kSSAHSSA);
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_ivopts.cpp b/src/mapleall/maple_me/src/me_ivopts.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..264d953cf7f2ca89eb281078e709a00aed237c04
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ivopts.cpp
@@ -0,0 +1,2657 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ivopts.h"
+#include "me_irmap.h"
+#include "me_scalar_analysis.h"
+#include "me_hdse.h"
+#include "me_phase_manager.h"
+#include "meexpr_use_info.h"
+#include "me_ssa_update.h"
+
+namespace maple {
+constexpr uint32 kMaxUseCount = 250;
+constexpr uint32 kMaxCandidatesPerGroup = 40;
+constexpr uint64 kDefaultEstimatedLoopIterNum = 10;
+constexpr uint32 kInfinityCost = 0xdeadbeef;
+constexpr uint32 kRegCost = 1;
+constexpr uint32 kRegCost2 = 2;
+constexpr uint32 kCost3 = 3;
+constexpr uint32 kCost5 = 5;
+class IVGroup;
+class IVUse;
+class IVCand;
+
+// the struct of IV
+class IV {
+ public:
+  friend class IVGroup;
+  friend class IVUse;
+  friend class IVCand;
+  friend class IVOptData;
+  friend class IVOptimizer;
+
+  IV(MeExpr *setExpr, MeExpr *setBase, MeExpr *setStep, bool setBasic)
+      : expr(setExpr), base(setBase), step(setStep), isBasicIV(setBasic) {}
+ private:
+  MeExpr *expr;  // the expr that the iv holds
+  MeExpr *base;  // the base value of the iv
+  MeExpr *step;  // the step of the iv
+  bool isBasicIV;  // true if the iv is not one of the linear version of other ivs
+  bool usedInAddress = false;  // true if the iv is used in any address expr
+};
+
+enum IVUseType {
+  kUseGeneral,  // use in a non-linear expr
+  kUseAddress,  // use as a base of ivar
+  kUseCompare   // use as a compare expr
+};
+
+// record the use message in the loop of iv
+class IVUse {
+ public:
+  friend class IVOptData;
+  friend class IVOptimizer;
+  IVUse(MeStmt *s, IV *i)
+      : stmt(s), iv(i) {}
+
+ private:
+  MeStmt *stmt;  // the stmts that the use belongs to
+  IV *iv;  // the iv that the use holds
+  IVGroup *group = nullptr;  // the group that the use belongs to
+  MeExpr *comparedExpr = nullptr;  // another hand of the compare, used for kUseCompare type
+  MeExpr *expr = nullptr;  // the expr that holds the iv
+  bool hasField = false;  // use to record whether the address use include field computation
+};
+
+// collect uses that can be considered together
+class IVGroup {
+ public:
+  friend class IVOptData;
+  friend class IVOptimizer;
+  using IVGroupID = utils::Index<IVGroup>;
+  void SetID(uint32 idx) {
+    id = IVGroupID(idx);
+  }
+  uint32 GetID() const {
+    return static_cast<uint32>(id);
+  }
+
+ private:
+  std::vector<std::unique_ptr<IVUse>> uses;  // the uses that the group holds
+  IVUseType type = kUseGeneral;  // the type of the group, same of all uses
+  IVGroupID id = IVGroupID(-1);  // the id of the group
+  std::set<uint32> relatedCands;  // record the IVCand.id of every related IVCand
+  std::vector<uint32> candCosts;  // record the cost of cand, index is candID
+};
+
+enum IncPos {
+  kBeforeExitTest,  // increase before exit test, normal case
+  kAfterExitTest,   // increase after exit test
+  kBeforeUse,       // increase before one of the uses
+  kAfterUse,        // increase after one of the uses
+  kOriginal         // the candidate is the original iv that we always prefer
+};
+
+// the template iv we produce for replacing
+class IVCand {
+ public:
+  friend class IVOptData;
+  friend class IVOptimizer;
+  using IVCandID = utils::Index<IVCand>;
+  IVCand(std::unique_ptr<IV> i, MeExpr *inc) : iv(std::move(i)), incVersion(inc) {}
+  void SetID(uint32 idx) {
+    id = IVCandID(idx);
+  }
+  uint32 GetID() const {
+    return static_cast<uint32>(id);
+  }
+
+ private:
+  IVCandID id = IVCandID(-1);  // the id of the candidate
+  std::unique_ptr<IV> iv = nullptr;  // the iv that the candidate holds
+  IncPos incPos = kBeforeExitTest;  // where the iv increase
+  MeExpr *incVersion = nullptr;  // record the ssa version after inc
+  MeExpr *originTmp = nullptr;  // use tmp to record the before-inc version of iv
+  uint32 cost = 0;  // the cost of the candidate ifself
+  IVUse *inc_use = nullptr;  // the use for before/after increasing, only used for kBeforeUse/kAfterUse
+  IV *origIV = nullptr;  // record the orig_iv if this candidate is the expand type of origIV
+  bool important = false;  // true if every use should consider this cand.
+                           // (some times we will skip considering all cands if there're too many)
+};
+
+class CandSet;
+// record the data of the IVOptimizer
+class IVOptData {
+ public:
+  friend class IVOptimizer;
+  IVOptData() = default;
+  void CreateIV(MeExpr *expr, MeExpr *base, MeExpr *step, bool isBasicIV);
+  void CreateFakeGroup(MeStmt &stmt, IV &iv, IVUseType type, MeExpr *expr);
+  void CreateGroup(MeStmt &stmt, IV &iv, IVUseType type, MeExpr *expr);
+  IVCand *CreateCandidate(MeExpr *ivTmp, MeExpr *base, MeExpr *step, MeExpr *inc);
+  IV *GetIV(const MeExpr &expr);
+  bool IsLoopInvariant(const MeExpr &expr);
+ private:
+  std::vector<std::unique_ptr<IVGroup>> groups;  // record all groups in this loop, use IVGroup.id as index
+  std::vector<std::unique_ptr<IVGroup>> fakeGroups;  // record the groups that extracted by pre
+                                                     // and no need to compute the cost
+  std::vector<std::unique_ptr<IVCand>> cands;  // record all candidates in this loop, use IVCand.id as index
+  std::unordered_map<int32, std::vector<IVCand*>> candRecord;  // record candidates with same base,
+                                                               // use base.exprID as key
+  std::unordered_map<int32, std::unique_ptr<IV>> ivs;  // record all ivs, use exprID as key
+  LoopDesc *currLoop = nullptr;  // currently optimized loop
+  uint64 iterNum = kDefaultEstimatedLoopIterNum;  // the iterations of current loop
+  uint64 realIterNum = -1;  // record the real iternum if we can compute
+  bool considerAll = false;  // true if we consider all candidates for every use
+  std::unique_ptr<CandSet> set = nullptr;  // used to record set
+};
+
+class CandSet {
+ public:
+  friend class IVOptData;
+  friend class IVOptimizer;
+  uint32 NumIVs();
+ private:
+  std::vector<IVCand*> chosenCands;  // record cands, use IVGroup.id as index
+  std::vector<uint32> candCount;  // record used cand and its count
+  uint32 cost = kInfinityCost;  // record set cost
+};
+
+class IVOptimizer {
+ public:
+  IVOptimizer(MeFunction &f, bool enabledDebug, IdentifyLoops *meLoops, Dominance *d)
+      : func(f),
+        irMap(f.GetIRMap()),
+        dumpDetail(enabledDebug),
+        cfg(f.GetCfg()),
+        loops(meLoops),
+        dom(d) {}
+
+  ~IVOptimizer() = default;
+  void Run();
+  void DumpIV(const IV &iv, int32 indent = 0);
+  void DumpGroup(const IVGroup &group);
+  void DumpCand(const IVCand &cand);
+  void DumpSet(const CandSet &set);
+  bool LoopOptimized() const;
+  // step1: find basic iv (the minimal inc uint)
+  MeExpr *ReplacePhiLhs(OpMeExpr *op, ScalarMeExpr *phiLhs, MeExpr *replace);
+  MeExpr *ResolveBasicIV(const ScalarMeExpr *backValue, ScalarMeExpr *phiLhs, MeExpr *replace);
+  bool CheckBasicIV(MeExpr *solve, ScalarMeExpr *phiLhs, int &meet);
+  bool FindBasicIVs();
+  // step2: find all ivs that is the affine form of basic iv, collect iv uses the same time
+  bool CreateIVFromAdd(OpMeExpr &op, MeStmt &stmt);
+  bool CreateIVFromMul(OpMeExpr &op, MeStmt &stmt);
+  bool CreateIVFromSub(OpMeExpr &op, MeStmt &stmt);
+  bool CreateIVFromCvt(OpMeExpr &op, MeStmt &stmt);
+  bool CreateIVFromIaddrof(OpMeExpr &op, MeStmt &stmt);
+  OpMeExpr *TryCvtCmp(OpMeExpr &op, MeStmt &stmt);
+  bool FindGeneralIVInExpr(MeStmt &stmt, MeExpr &expr, bool useInAddress = false);
+  MeExpr *OptimizeInvariable(MeExpr *expr);
+  bool LHSEscape(const ScalarMeExpr *lhs);
+  void FindGeneralIVInStmt(MeStmt &stmt);
+  void FindGeneralIVInPhi(MePhiNode &phi);
+  void TraversalLoopBB(BB &bb, std::vector<bool> &bbVisited);
+  // step3: create candidates used to replace ivs
+  void CreateIVCandidateFromBasicIV(IV &iv);
+  MeExpr *StripConstantPart(MeExpr &expr, int64 &offset);
+  void CreateIVCandidateFromUse(IVUse &use);
+  void CreateIVCandidate();
+  // step4: estimate the costs of candidates in every use and its own costs
+  void ComputeCandCost();
+  int64 ComputeRatioOfStep(MeExpr &candStep, MeExpr &groupStep);
+  MeExpr *ComputeExtraExprOfBase(MeExpr &candBase, MeExpr &groupBase, uint64 ratio, bool &replaced);
+  uint32 ComputeCandCostForGroup(const IVCand &cand, IVGroup &group);
+  void ComputeGroupCost();
+  uint32 ComputeSetCost(CandSet &set);
+  // step5: greedily find the best set of candidates in all uses
+  void InitSet(bool originFirst);
+  void TryOptimize(bool originFirst);
+  void FindCandSet();
+  void TryReplaceWithCand(CandSet &set, IVCand &cand, std::unordered_map<IVGroup*, IVCand*> &changehange);
+  bool OptimizeSet();
+  // step6: replace ivs with selected candidates
+  bool IsReplaceSameOst(const MeExpr *parent, ScalarMeExpr *target);
+  MeStmt *GetIncPos();
+  MeExpr *GetInvariant(MeExpr *expr);
+  MeExpr *ReplaceCompareOpnd(const OpMeExpr &cmp, MeExpr *compared, MeExpr *replace);
+  bool PrepareCompareUse(int64 &ratio, IVUse *use, IVCand *cand, MeStmt *incPos,
+                         MeExpr *&extraExpr, MeExpr *&replace);
+  MeExpr *GenerateRealReplace(int64 ratio, MeExpr *extraExpr, MeExpr *replace,
+                              PrimType realUseType, bool replaceCompare);
+  void UseReplace();
+  // optimization entry
+  void ApplyOptimize();
+
+ private:
+  MeFunction &func;
+  MeIRMap *irMap;
+  bool dumpDetail;  // dump the detail of the optimization
+  MeCFG *cfg;
+  IdentifyLoops *loops;
+  Dominance *dom;
+  MeExprUseInfo *useInfo = nullptr;
+  bool optimized = false;
+  std::unique_ptr<IVOptData> data = nullptr;  // used to record the messages when processing the loop
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> ssaupdateCands;
+  std::unordered_map<int32, MeExpr*> invariables;  // used to record the newly added invariables
+};
+
+void IVOptimizer::DumpIV(const IV &iv, int32 indent) {
+  constexpr int32 kIndent8 = 8;
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "IV:\n";
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "  HSSA:\tmx" << iv.expr->GetExprID() << std::endl;
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "  Type: " << GetPrimTypeName(iv.expr->GetPrimType()) << std::endl;
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "  Base: ";
+  iv.base->Dump(irMap, indent + kIndent8);
+  LogInfo::MapleLogger() << std::endl;
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "  Step: ";
+  iv.step->Dump(irMap, indent + kIndent8);
+  LogInfo::MapleLogger() << std::endl;
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << "  BasicIV: " << (iv.isBasicIV ? "Yes\n" : "No\n");
+}
+
+void IVOptimizer::DumpGroup(const IVGroup &group) {
+  constexpr int32 kIndent4 = 4;
+  LogInfo::MapleLogger() << "Group" << group.id << ":\n"
+                         << "  Type: ";
+  if (group.type == kUseGeneral) {
+    LogInfo::MapleLogger() << "General\n";
+  } else if (group.type == kUseAddress) {
+    LogInfo::MapleLogger() << "Address\n";
+  } else {
+    LogInfo::MapleLogger() << "Compare\n";
+  }
+  // dump uses
+  for (uint32 i = 0; i < group.uses.size(); ++i) {
+    auto *use = group.uses[i].get();
+    LogInfo::MapleLogger() << "  Use" << i << ":\n"
+                           << "    At Stmt:\n";
+    use->stmt->Dump(irMap);
+    DumpIV(*use->iv, kIndent4);
+  }
+}
+
+void IVOptimizer::DumpCand(const IVCand &cand) {
+  constexpr int32 kIndent2 = 2;
+  LogInfo::MapleLogger() << "Candidate" << cand.id << ":\n"
+                         << "  IV Name:\t%" << static_cast<RegMeExpr*>(cand.iv->expr)->GetRegIdx() << std::endl;
+  DumpIV(*cand.iv, kIndent2);
+  LogInfo::MapleLogger() << "  Inc Position: ";
+  if (cand.incPos == kOriginal) {
+    LogInfo::MapleLogger() << "Origin IV\n";
+  } else if (cand.incPos == kBeforeExitTest) {
+    LogInfo::MapleLogger() << "before exit test\n";
+  } else if (cand.incPos == kAfterExitTest) {
+    LogInfo::MapleLogger() << "after exit test\n";
+  } else if (cand.incPos == kAfterUse) {
+    LogInfo::MapleLogger() << "after use: ";
+    cand.inc_use->stmt->Dump(irMap);
+  } else if (cand.incPos == kBeforeUse) {
+    LogInfo::MapleLogger() << "before use: ";
+    cand.inc_use->stmt->Dump(irMap);
+  }
+}
+
+void IVOptimizer::DumpSet(const CandSet &set) {
+  LogInfo::MapleLogger() << "  cost: " << set.cost << std::endl
+                         << "  cand cost: ";
+  uint32 candCost = 0;
+  for (uint32 k = 0; k < set.candCount.size(); ++k) {
+    if (set.candCount[k] > 0) {
+      candCost += data->cands[k]->cost;
+    }
+  }
+  LogInfo::MapleLogger() << candCost << std::endl;
+  LogInfo::MapleLogger() << "  group cost: ";
+  uint32 groupCost = 0;
+  for (uint32 i = 0; i < set.chosenCands.size(); ++i) {
+    auto *cand = set.chosenCands[i];
+    groupCost += data->groups[i]->candCosts[cand->GetID()];
+  }
+  LogInfo::MapleLogger() << groupCost << std::endl;
+  LogInfo::MapleLogger() << "  chosen candidates: ";
+  for (uint32 j = 0; j < set.candCount.size(); ++j) {
+    if (set.candCount[j] > 0) {
+      LogInfo::MapleLogger() << j << ", ";
+    }
+  }
+  LogInfo::MapleLogger() << std::endl;
+  for (uint32 t = 0; t < set.chosenCands.size(); ++t) {
+    LogInfo::MapleLogger() << "     group" << data->groups[t]->GetID() << ": cand" << set.chosenCands[t]->GetID()
+                           << ", cost:" << data->groups[t]->candCosts[set.chosenCands[t]->GetID()] << std::endl;
+  }
+}
+
+bool IVOptimizer::LoopOptimized() const {
+  return optimized;
+}
+
+void IVOptData::CreateIV(MeExpr *expr, MeExpr *base, MeExpr *step, bool isBasicIV) {
+  if (ivs.find(expr->GetExprID()) != ivs.end()) {
+    return;
+  }
+  ivs.emplace(expr->GetExprID(), std::make_unique<IV>(expr, base, step, isBasicIV));
+}
+
+void IVOptData::CreateFakeGroup(MeStmt &stmt, IV &iv, IVUseType type, MeExpr *expr) {
+  auto group = std::make_unique<IVGroup>();
+  group->SetID(static_cast<uint32>(fakeGroups.size()));
+  auto use = std::make_unique<IVUse>(&stmt, &iv);
+  use->group = group.get();
+  use->expr = expr;
+  group->uses.emplace_back(std::move(use));
+  group->type = type;
+  fakeGroups.emplace_back(std::move(group));
+}
+
+void IVOptData::CreateGroup(MeStmt &stmt, IV &iv, IVUseType type, MeExpr *expr) {
+  auto group = std::make_unique<IVGroup>();
+  group->SetID(static_cast<uint32>(groups.size()));
+  auto use = std::make_unique<IVUse>(&stmt, &iv);
+  use->group = group.get();
+  use->expr = expr;
+  group->uses.emplace_back(std::move(use));
+  group->type = type;
+  groups.emplace_back(std::move(group));
+}
+
+IVCand *IVOptData::CreateCandidate(MeExpr *ivTmp, MeExpr *base, MeExpr *step, MeExpr *inc) {
+  auto it = candRecord.find(base->GetExprID());
+  if (it != candRecord.end()) {
+    for (auto *cand : it->second) {
+      if (cand->iv->step == step) {
+        // already created
+        return cand;
+      }
+    }
+  }
+
+  auto iv = std::make_unique<IV>(ivTmp, base, step, false);
+  auto cand = std::make_unique<IVCand>(std::move(iv), inc);
+  cand->SetID(static_cast<uint32>(cands.size()));
+  auto canPtr = cand.get();
+  cands.emplace_back(std::move(cand));
+  candRecord[base->GetExprID()].emplace_back(canPtr);
+  return canPtr;
+}
+
+IV *IVOptData::GetIV(const MeExpr &expr) {
+  auto iter = ivs.find(expr.GetExprID());
+  return iter == ivs.end() ? nullptr : iter->second.get();
+}
+
+bool IVOptData::IsLoopInvariant(const MeExpr &expr) {
+  switch (expr.GetMeOp()) {
+    case kMeOpConst:
+      return true;
+    case kMeOpReg:
+    case kMeOpVar: {
+      if (expr.IsVolatile()) {
+        return false;
+      }
+      auto *bb = static_cast<const ScalarMeExpr&>(expr).DefByBB();
+      auto *phi = static_cast<const ScalarMeExpr&>(expr).GetMePhiDef();
+      if (phi != nullptr && phi->GetDefBB() == currLoop->head) {
+        for (auto *phiOpnd : phi->GetOpnds()) {
+          if (phiOpnd == phi->GetLHS()) {
+            return true;
+          }
+        }
+      }
+      if (bb != nullptr) {
+        return currLoop->loopBBs.count(static_cast<const ScalarMeExpr&>(expr).DefByBB()->GetBBId()) == 0;
+      }
+      return true;
+    }
+    case kMeOpOp: {
+      auto &op = static_cast<const OpMeExpr&>(expr);
+      for (size_t i = 0; i < op.GetNumOpnds(); ++i) {
+        if (!IsLoopInvariant(*op.GetOpnd(i))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    default:
+      // we hope that other kinds of invariant have been moved outside by epre phase, so we don't care them here.
+      return false;
+  }
+}
+
+// replace the 'phiLHS' with 'replace' so we can the base & step from the inc expr
+MeExpr *IVOptimizer::ReplacePhiLhs(OpMeExpr *op, ScalarMeExpr *phiLhs, MeExpr *replace) {
+  for (uint32 i = 0; i < op->GetNumOpnds(); ++i) {
+    auto *opnd = op->GetOpnd(i);
+    switch (opnd->GetMeOp()) {
+      case kMeOpConst:
+        continue;
+      case kMeOpReg:
+      case kMeOpVar: {
+        auto *scalar = static_cast<ScalarMeExpr*>(opnd);
+        if (scalar == phiLhs) {
+          return irMap->ReplaceMeExprExpr(*op, *scalar, *replace);
+        }
+        if (scalar->GetOstIdx() == phiLhs->GetOstIdx()) {
+          ASSERT(scalar->GetDefBy() == kDefByStmt, "NYI");
+          if (scalar->GetDefStmt()->GetRHS()->GetMeOp() != kMeOpOp) {
+            return op;
+          }
+          auto *replaced = ReplacePhiLhs(static_cast<OpMeExpr*>(scalar->GetDefStmt()->GetRHS()), phiLhs, replace);
+          return irMap->ReplaceMeExprExpr(*op, *scalar, *replaced);
+        }
+        continue;
+      }
+      case kMeOpOp: {
+        auto *opOpnd = static_cast<OpMeExpr*>(opnd);
+        auto *replaced = ReplacePhiLhs(opOpnd, phiLhs, replace);
+        if (replaced == opOpnd) {
+          continue;
+        }
+        return irMap->ReplaceMeExprExpr(*op, *opnd, *replaced);
+      }
+      default:
+        CHECK_FATAL(false, "should not reach here");
+    }
+  }
+  return op;
+}
+
+// try to find the base & step from inc expr
+MeExpr *IVOptimizer::ResolveBasicIV(const ScalarMeExpr *backValue, ScalarMeExpr *phiLhs, MeExpr *replace) {
+  if (backValue->GetDefBy() != kDefByStmt) {
+    return nullptr;
+  }
+  auto *backRhs = backValue->GetDefStmt()->GetRHS();
+  if (backRhs->GetMeOp() != kMeOpOp) {
+    return nullptr;
+  }
+  auto replaced = ReplacePhiLhs(static_cast<OpMeExpr*>(backRhs), phiLhs, replace);
+  if (replaced == backRhs) {  // replace failed, can not get step
+    return nullptr;
+  }
+  return replaced;
+}
+
+// find if there are basic ivs
+bool IVOptimizer::CheckBasicIV(MeExpr *solve, ScalarMeExpr *phiLhs, int &meet) {
+  switch (solve->GetMeOp()) {
+    case kMeOpVar:
+    case kMeOpReg: {
+      if (solve->IsVolatile()) {
+        return false;
+      }
+      if (solve == phiLhs) {
+        ++meet;
+        return true;
+      }
+      auto *scalar = static_cast<ScalarMeExpr*>(solve);
+      if (phiLhs == nullptr || scalar->GetOstIdx() != phiLhs->GetOstIdx()) {
+        if (scalar->IsDefByNo()) {  // parameter
+          return true;
+        }
+        return data->currLoop->loopBBs.count(scalar->DefByBB()->GetBBId()) == 0;
+      }
+      if (scalar->GetDefBy() != kDefByStmt) {
+        return false;
+      }
+      return CheckBasicIV(scalar->GetDefStmt()->GetRHS(), phiLhs, meet);
+    }
+    case kMeOpConst:
+      return IsPrimitiveInteger(solve->GetPrimType());
+    case kMeOpOp: {
+      if (solve->GetOp() == OP_add) {
+        auto *opMeExpr = static_cast<OpMeExpr*>(solve);
+        return CheckBasicIV(opMeExpr->GetOpnd(0), phiLhs, meet) &&
+               CheckBasicIV(opMeExpr->GetOpnd(1), phiLhs, meet);
+      }
+      if (solve->GetOp() == OP_sub) {
+        auto *opMeExpr = static_cast<OpMeExpr*>(solve);
+        return CheckBasicIV(opMeExpr->GetOpnd(0), phiLhs, meet) &&
+               CheckBasicIV(opMeExpr->GetOpnd(1), nullptr, meet);
+      }
+      return false;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+// check if there are basic ivs in loop, return true if found and created one
+bool IVOptimizer::FindBasicIVs() {
+  bool find = false;
+  auto *loopHeader = data->currLoop->head;
+  // basic iv always appears in head's phi list
+  for (auto &phi : loopHeader->GetMePhiList()) {
+    if (!phi.second->GetIsLive()) {
+      continue;
+    }
+    OriginalSt *ost = func.GetMeSSATab()->GetOriginalStFromID(phi.first);
+    CHECK_FATAL(ost, "ost is nullptr!");
+    if (!ost->IsIVCandidate()) {
+      continue;
+    }
+    auto *phiLhs = phi.second->GetLHS();
+    auto *initValue = phi.second->GetOpnd(0);
+    auto *backValue = phi.second->GetOpnd(1);
+    if (data->currLoop->loopBBs.count(loopHeader->GetPred(0)->GetBBId()) != 0) {
+      initValue = phi.second->GetOpnd(1);
+      backValue = phi.second->GetOpnd(0);
+    }
+    int meet = 0;
+    if (!CheckBasicIV(backValue, phiLhs, meet) || meet != 1) {
+      continue;
+    }
+    auto *step = ResolveBasicIV(backValue, phiLhs, irMap->CreateIntConstMeExpr(0, phiLhs->GetPrimType()));
+    if (step == nullptr || (step->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(step)->IsZero())) {
+      continue;
+    }
+    auto *simplified = irMap->SimplifyMeExpr(step);
+    if (simplified != nullptr) { step = simplified; }
+    // Create Basic IV
+    auto *initDef = initValue->GetDefByMeStmt();
+    MeExpr *init = initValue;
+    if (initDef != nullptr && initDef->GetRHS() != nullptr && initDef->GetRHS()->GetMeOp() == kMeOpConst) {
+      init = initDef->GetRHS();
+    }
+    data->CreateIV(phiLhs, init, step, true);
+    // Create Basic IV for inc version
+    auto *backInit = ResolveBasicIV(backValue, phiLhs, init);
+    data->CreateIV(backValue, backInit, step, true);
+    find = true;
+  }
+  return find;
+}
+
+bool IVOptimizer::CreateIVFromAdd(OpMeExpr &op, MeStmt &stmt) {
+  auto *iv0 = data->GetIV(*op.GetOpnd(0));
+  auto *iv1 = data->GetIV(*op.GetOpnd(1));
+  if (iv0 != nullptr && iv1 != nullptr) {
+    auto *initValue = irMap->CreateMeExprBinary(OP_add, op.GetPrimType(),
+                                                *iv0->base, *iv1->base);
+    auto *simplified = irMap->SimplifyMeExpr(initValue);
+    if (simplified != nullptr) {
+      initValue = simplified;
+    }
+    auto *step = irMap->CreateMeExprBinary(OP_add, op.GetPrimType(),
+                                           *iv0->step, *iv1->step);
+    simplified = irMap->SimplifyMeExpr(step);
+    if (simplified != nullptr) {
+      step = simplified;
+    }
+    data->CreateIV(&op, initValue, step, false);
+    return true;
+  } else if (iv0 != nullptr || iv1 != nullptr) {
+    auto *realIV = iv0 != nullptr ? iv0 : iv1;
+    auto *opnd = iv0 != nullptr ? op.GetOpnd(1) : op.GetOpnd(0);
+    if (data->IsLoopInvariant(*opnd)) {
+      auto *initValue = irMap->CreateMeExprBinary(OP_add, op.GetPrimType(),
+                                                  *realIV->base, *opnd);
+      auto *simplified = irMap->SimplifyMeExpr(initValue);
+      if (simplified != nullptr) {
+        initValue = simplified;
+      }
+      data->CreateIV(&op, initValue, realIV->step, false);
+      return true;
+    }
+    // need to record a use of the realIV
+    data->CreateGroup(stmt, *realIV, kUseGeneral, &op);
+    return false;
+  }
+  return false;
+}
+
+bool IVOptimizer::CreateIVFromMul(OpMeExpr &op, MeStmt &stmt) {
+  auto *iv0 = data->GetIV(*op.GetOpnd(0));
+  auto *iv1 = data->GetIV(*op.GetOpnd(1));
+  if (iv0 != nullptr && iv1 != nullptr) {
+    // record use of both iv
+    data->CreateGroup(stmt, *iv0, kUseGeneral, &op);
+    data->CreateGroup(stmt, *iv1, kUseGeneral, &op);
+    return false;
+  } else if (iv0 != nullptr || iv1 != nullptr) {
+    auto *realIV = iv0 != nullptr ? iv0 : iv1;
+    auto *opnd = iv0 != nullptr ? op.GetOpnd(1) : op.GetOpnd(0);
+    if (opnd->IsZero()) {
+      return false;
+    }
+    if (data->IsLoopInvariant(*opnd)) {
+      auto *initValue = irMap->CreateMeExprBinary(OP_mul, op.GetPrimType(),
+                                                  *realIV->base, *opnd);
+      auto *simplified = irMap->SimplifyMeExpr(initValue);
+      if (simplified != nullptr) {
+        initValue = simplified;
+      }
+      auto *step = irMap->CreateMeExprBinary(OP_mul, op.GetPrimType(),
+                                             *realIV->step, *opnd);
+      simplified = irMap->SimplifyMeExpr(step);
+      if (simplified != nullptr) {
+        step = simplified;
+      }
+      data->CreateIV(&op, initValue, step, false);
+      return true;
+    }
+    // need to record a use of the realIV
+    data->CreateGroup(stmt, *realIV, kUseGeneral, &op);
+    return false;
+  }
+  return false;
+}
+
+bool IVOptimizer::CreateIVFromSub(OpMeExpr &op, MeStmt &stmt) {
+  auto *iv0 = data->GetIV(*op.GetOpnd(0));
+  auto *iv1 = data->GetIV(*op.GetOpnd(1));
+  if (iv0 != nullptr && iv1 != nullptr) {
+    auto *initValue = irMap->CreateMeExprBinary(OP_sub, op.GetPrimType(),
+                                                *iv0->base, *iv1->base);
+    auto *simplified = irMap->SimplifyMeExpr(initValue);
+    if (simplified != nullptr) {
+      initValue = simplified;
+    }
+    auto *step = irMap->CreateMeExprBinary(OP_sub, op.GetPrimType(),
+                                           *iv0->step, *iv1->step);
+    simplified = irMap->SimplifyMeExpr(step);
+    if (simplified != nullptr) {
+      step = simplified;
+    }
+    data->CreateIV(&op, initValue, step, false);
+    return true;
+  } else if (iv0 != nullptr || iv1 != nullptr) {
+    auto *realIV = iv0 != nullptr ? iv0 : iv1;
+    auto *opnd = iv0 != nullptr ? op.GetOpnd(1) : op.GetOpnd(0);
+    if (data->IsLoopInvariant(*opnd)) {
+      auto *initValue = irMap->CreateMeExprBinary(OP_sub, op.GetPrimType(),
+                                                  iv0 != nullptr ? *realIV->base : *opnd,
+                                                  iv0 != nullptr ? *opnd : *realIV->base);
+      auto *simplified = irMap->SimplifyMeExpr(initValue);
+      if (simplified != nullptr) {
+        initValue = simplified;
+      }
+      auto *step = realIV->step;
+      if (iv0 == nullptr) {
+        step = irMap->CreateMeExprUnary(OP_neg, op.GetPrimType(), *step);
+        static_cast<OpMeExpr*>(step)->SetOpndType(realIV->step->GetPrimType());
+        simplified = irMap->SimplifyMeExpr(step);
+        if (simplified != nullptr) {
+          step = simplified;
+        }
+      }
+      data->CreateIV(&op, initValue, step, false);
+      return true;
+    }
+    // need to record a use of the realIV
+    data->CreateGroup(stmt, *realIV, kUseGeneral, &op);
+    return false;
+  }
+  return false;
+}
+
+bool IVOptimizer::CreateIVFromCvt(OpMeExpr &op, MeStmt &stmt) {
+  auto *iv = data->GetIV(*op.GetOpnd(0));
+  ASSERT_NOT_NULL(iv);
+  if (!IsPrimitiveInteger(op.GetPrimType())) {
+    data->CreateGroup(stmt, *iv, kUseGeneral, &op);
+    return false;
+  }
+  auto *initValue = irMap->CreateMeExprTypeCvt(op.GetPrimType(), op.GetOpndType(), *iv->base);
+  auto *simplified = irMap->SimplifyMeExpr(initValue);
+  if (simplified != nullptr) {
+    initValue = simplified;
+  }
+  auto *step = irMap->CreateMeExprTypeCvt(op.GetPrimType(), GetSignedPrimType(op.GetOpndType()), *iv->step);
+  simplified = irMap->SimplifyMeExpr(step);
+  if (simplified != nullptr) {
+    step = simplified;
+  }
+  data->CreateIV(&op, initValue, step, false);
+  return true;
+}
+
+bool IVOptimizer::CreateIVFromIaddrof(OpMeExpr &op, MeStmt &stmt) {
+  auto *iv = data->GetIV(*op.GetOpnd(0));
+  ASSERT_NOT_NULL(iv);
+  if (!IsPrimitiveInteger(op.GetPrimType())) {
+    data->CreateGroup(stmt, *iv, kUseGeneral, &op);
+    return false;
+  }
+  auto *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(op.GetTyIdx());
+  auto *pointedType = static_cast<MIRPtrType*>(type)->GetPointedType();
+  CHECK_FATAL(pointedType != nullptr, "expect a pointed type of iaddrof");
+  auto offset = pointedType->GetBitOffsetFromBaseAddr(op.GetFieldID()) / 8;
+  auto *inc = irMap->CreateIntConstMeExpr(offset, op.GetPrimType());
+  auto *initValue = irMap->CreateMeExprBinary(OP_add, op.GetPrimType(), *iv->base, *inc);
+  auto *simplified = irMap->SimplifyMeExpr(initValue);
+  if (simplified != nullptr) { initValue = simplified; }
+  data->CreateIV(&op, initValue, iv->step, false);
+  return true;
+}
+
+// try to cvt condition OP in condition stmt STMT to ne because it's better for optimization
+OpMeExpr *IVOptimizer::TryCvtCmp(OpMeExpr &op, MeStmt &stmt) {
+  if (data->currLoop->inloopBB2exitBBs.size() != 1 ||  // do not handle multi-exit loop
+      (stmt.GetOp() != OP_brfalse && stmt.GetOp() != OP_brtrue) ||
+      cfg->GetBBFromID(data->currLoop->inloopBB2exitBBs.begin()->first)->GetLastMe() != &stmt) {
+    return &op;
+  }
+  auto *bb = stmt.GetBB();
+  if (!dom->Dominate(*bb, *data->currLoop->latch)) {
+    return &op;
+  }
+  auto &condbr = static_cast<CondGotoMeStmt&>(stmt);
+  bool fallthruInLoop = data->currLoop->loopBBs.count(bb->GetSucc(0)->GetBBId()) != 0;
+  bool targetInLoop = data->currLoop->loopBBs.count(bb->GetSucc(1)->GetBBId()) != 0;
+  CHECK_FATAL(fallthruInLoop != targetInLoop, "TryCvtCmp: check loop form.");
+  IV *iv = nullptr;
+  MeExpr *opnd = nullptr;
+  auto *iv0 = data->GetIV(*op.GetOpnd(0));
+  auto *iv1 = data->GetIV(*op.GetOpnd(1));
+  auto *opnd0 = op.GetOpnd(0);
+  auto *opnd1 = op.GetOpnd(1);
+  OpMeExpr newOp(op, kInvalidExprID);
+  // prefer iv in left, if not, swap them
+  if (iv0 != nullptr && data->IsLoopInvariant(*opnd1)) {
+    iv = iv0;
+    opnd = opnd1;
+  } else if (iv1 != nullptr && data->IsLoopInvariant(*opnd0)) {
+    auto condop = newOp.GetOp();
+    condop = condop == OP_ge ? OP_le
+                             : condop == OP_le ? OP_ge
+                                               : condop == OP_lt ? OP_gt
+                                                                 : condop == OP_gt ? OP_lt : condop;
+    newOp.SetOp(condop);
+    newOp.SetOpnd(0, opnd1);
+    newOp.SetOpnd(1, opnd0);
+    iv = iv1;
+    opnd = opnd0;
+  } else {
+    return &op;
+  }
+  CHECK_NULL_FATAL(iv);
+  if (iv->base->GetMeOp() != kMeOpConst || iv->step->GetMeOp() != kMeOpConst) {
+    // do not handle range-unknown iv
+    return &op;
+  }
+  if (opnd->GetMeOp() != kMeOpConst) {
+    return &op;
+  }
+  int64 cmpConst = static_cast<ConstMeExpr*>(opnd)->GetExtIntValue();
+  if (GetPrimTypeSize(opnd->GetPrimType()) < kEightByte) {
+    cmpConst = static_cast<int64>(static_cast<int32>(cmpConst));
+  }
+  // prefer target in loop, if not, swap them
+  if (fallthruInLoop) {
+    condbr.SetOp(condbr.GetOp() == OP_brtrue ? OP_brfalse : OP_brtrue);
+    condbr.SetOffset(func.GetOrCreateBBLabel(*bb->GetSucc(0)));
+    auto *tmp = bb->GetSucc(0);
+    bb->SetSucc(0, bb->GetSucc(1));
+    bb->SetSucc(1, tmp);
+  }
+
+  int64 baseConst = static_cast<ConstMeExpr*>(iv->base)->GetExtIntValue();
+  if (GetPrimTypeSize(iv->base->GetPrimType()) < kEightByte) {
+    baseConst = static_cast<int64>(static_cast<int32>(baseConst));
+  }
+  int64 stepConst = static_cast<ConstMeExpr*>(iv->step)->GetExtIntValue();
+  if (GetPrimTypeSize(iv->step->GetPrimType()) < kEightByte) {
+    stepConst = static_cast<int64>(static_cast<int32>(stepConst));
+  }
+
+  if ((newOp.GetOp() == OP_lt && condbr.GetOp() == OP_brtrue && stepConst == 1) ||
+      (newOp.GetOp() == OP_ge && condbr.GetOp() == OP_brfalse && stepConst == 1)) {
+    // case1: i < 8, i++  ===>  i != 8, i++
+    bool firstCheck = IsSignedInteger(newOp.GetOpndType()) ? baseConst <= cmpConst :
+        static_cast<uint64>(baseConst) <= static_cast<uint64>(cmpConst);
+    if (!firstCheck) {
+      return &op;
+    }
+  } else if ((newOp.GetOp() == OP_gt && condbr.GetOp() == OP_brtrue && stepConst == -1) ||
+             (newOp.GetOp() == OP_le && condbr.GetOp() == OP_brfalse && stepConst == -1)) {
+    // case2: i > 8, i--  ===>  i != 8, i--
+    bool firstCheck = IsSignedInteger(newOp.GetOpndType()) ? baseConst >= cmpConst :
+        static_cast<uint64>(baseConst) >= static_cast<uint64>(cmpConst);
+    if (!firstCheck) {
+      return &op;
+    }
+  } else if ((newOp.GetOp() == OP_le && condbr.GetOp() == OP_brtrue && stepConst == 1) ||
+             (newOp.GetOp() == OP_gt && condbr.GetOp() == OP_brfalse && stepConst == 1)) {
+    // case3: i <= 8, i++  ===>  i < 9, i++  ===>  i != 9, i++
+    bool overflow = IsSignedInteger(newOp.GetOpndType()) ? cmpConst == INT64_MAX : cmpConst == UINT64_MAX;
+    if (overflow) {
+      return &op;
+    }
+    cmpConst = cmpConst + stepConst;
+    bool firstCheck = IsSignedInteger(newOp.GetOpndType()) ? baseConst <= cmpConst :
+        static_cast<uint64>(baseConst) <= static_cast<uint64>(cmpConst);
+    if (!firstCheck) {
+      return &op;
+    }
+    newOp.SetOpnd(1, irMap->CreateIntConstMeExpr(cmpConst, opnd->GetPrimType()));
+  } else if ((newOp.GetOp() == OP_ge && condbr.GetOp() == OP_brtrue && stepConst == -1) ||
+             (newOp.GetOp() == OP_lt && condbr.GetOp() == OP_brfalse && stepConst == -1)) {
+    // case4: i >= 8, i--  ===>  i > 7, i--  ===>  i != 7, i--
+    bool underflow = IsSignedInteger(newOp.GetOpndType()) ? cmpConst == INT64_MIN : cmpConst == 0;
+    if (underflow) {
+      return &op;
+    }
+    cmpConst = cmpConst + stepConst;
+    bool firstCheck = IsSignedInteger(newOp.GetOpndType()) ? baseConst >= cmpConst :
+        static_cast<uint64>(baseConst) >= static_cast<uint64>(cmpConst);
+    if (!firstCheck) {
+      return &op;
+    }
+    newOp.SetOpnd(1, irMap->CreateIntConstMeExpr(cmpConst, opnd->GetPrimType()));
+  } else {
+    return &op;
+  }
+  newOp.SetOp(condbr.GetOp() == OP_brtrue ? OP_ne : OP_eq);
+  auto *hashed = irMap->HashMeExpr(newOp);
+  irMap->ReplaceMeExprStmt(stmt, op, *hashed);
+  return static_cast<OpMeExpr*>(hashed);
+}
+
+// find other ivs that is the affine transform of other ivs
+bool IVOptimizer::FindGeneralIVInExpr(MeStmt &stmt, MeExpr &expr, bool useInAddress) {
+  switch (expr.GetMeOp()) {
+    case kMeOpOp: {
+      if (data->GetIV(expr) != nullptr) {
+        return true;
+      }
+      auto &op = static_cast<OpMeExpr&>(expr);
+      bool opndIsIV = false;
+      for (uint32 i = 0; i < op.GetNumOpnds(); ++i) {
+        if (FindGeneralIVInExpr(stmt, *op.GetOpnd(i))) {
+          opndIsIV = true;
+        }
+      }
+      if (!opndIsIV) {
+        return false;
+      }
+      if (op.GetOp() == OP_add) {
+        return CreateIVFromAdd(op, stmt);
+      }
+      if (op.GetOp() == OP_mul) {
+        return CreateIVFromMul(op, stmt);
+      }
+      if (op.GetOp() == OP_sub) {
+        return CreateIVFromSub(op, stmt);
+      }
+      if (op.GetOp() == OP_cvt) {
+        return CreateIVFromCvt(op, stmt);
+      }
+      if (op.GetOp() == OP_iaddrof) {
+        return CreateIVFromIaddrof(op, stmt);
+      }
+      if (IsCompareHasReverseOp(op.GetOp())) {  // record compare use
+        auto *cmp = TryCvtCmp(op, stmt);
+        auto *iv = data->GetIV(*cmp->GetOpnd(0));
+        if (iv != nullptr && data->IsLoopInvariant(*cmp->GetOpnd(1))) {
+          data->CreateGroup(stmt, *iv, kUseCompare, cmp);
+          (*data->groups.rbegin())->uses[0]->comparedExpr = cmp->GetOpnd(1);
+          return false;
+        }
+        iv = data->GetIV(*cmp->GetOpnd(1));
+        if (iv != nullptr && data->IsLoopInvariant(*cmp->GetOpnd(0))) {
+          data->CreateGroup(stmt, *iv, kUseCompare, cmp);
+          (*data->groups.rbegin())->uses[0]->comparedExpr = cmp->GetOpnd(0);
+          return false;
+        }
+        iv = iv == nullptr ? data->GetIV(*cmp->GetOpnd(0)) : iv;
+        data->CreateGroup(stmt, *iv, kUseGeneral, cmp);
+        return false;
+      }
+      for (uint8 j = 0; j < op.GetNumOpnds(); ++j) {
+        auto *iv = data->GetIV(*op.GetOpnd(j));
+        if (iv != nullptr) {
+          // create use of the iv
+          data->CreateGroup(stmt, *iv, kUseGeneral, &op);
+        }
+      }
+      return false;
+    }
+    case kMeOpVar:
+    case kMeOpReg: {
+      auto *iv = data->GetIV(expr);
+      if (iv != nullptr) {
+        iv->usedInAddress = useInAddress;
+        return true;
+      }
+      return false;
+    }
+    case kMeOpIvar: {
+      auto &ivar = static_cast<IvarMeExpr&>(expr);
+      auto *base = ivar.GetBase();
+      if (FindGeneralIVInExpr(stmt, *base, true)) {
+        auto *iv = data->GetIV(*base);
+        data->CreateGroup(stmt, *iv, kUseAddress, &ivar);
+        (*(*data->groups.rbegin())->uses.rbegin())->hasField = ivar.GetFieldID() != 0 || ivar.GetOffset() != 0;
+      }
+      return false;
+    }
+    case kMeOpNary: {
+      auto &nary = static_cast<NaryMeExpr&>(expr);
+      for (auto *opnd : nary.GetOpnds()) {
+        if (FindGeneralIVInExpr(stmt, *opnd)) {
+          auto *iv = data->GetIV(*opnd);
+          data->CreateGroup(stmt, *iv, kUseGeneral, &nary);
+        }
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+
+void IVOptimizer::FindGeneralIVInPhi(MePhiNode &phi) {
+  if (!phi.GetIsLive()) {
+    return;
+  }
+
+  bool allSameIV = true;
+  auto *firstOpnd = phi.GetOpnd(0);
+  auto firstIV = data->GetIV(*firstOpnd);
+  if (firstIV == nullptr) {
+    return;
+  }
+  for (auto *phiOpnd : phi.GetOpnds()) {
+    auto *iv = data->GetIV(*phiOpnd);
+    if (iv == nullptr) {
+      return;
+    }
+    if (iv->base != firstIV->base || iv->step != firstIV->step) {
+      allSameIV = false;
+      break;
+    }
+  }
+
+  if (allSameIV) {
+    data->CreateIV(phi.GetLHS(), firstIV->base, firstIV->step, false);
+  }
+}
+
+// check if the assign escape the loop, if so, we need to keep the value
+bool IVOptimizer::LHSEscape(const ScalarMeExpr *lhs) {
+  if (lhs->IsVolatile()) {  // volatile var needs to keep the value, same as escaping the loop
+    return true;
+  }
+  auto *useList = useInfo->GetUseSitesOfExpr(lhs);
+  if (useList == nullptr || useList->empty()) {
+    return false;
+  }
+  // find in all uses to check if the lhs escape the loop
+  for (auto &useSite : *useList) {
+    if (useSite.IsUseByStmt()) {
+      auto *useBB = useSite.GetStmt()->GetBB();
+      if (data->currLoop->loopBBs.count(useBB->GetBBId()) == 0) {
+        return true;
+      }
+    }
+    if (useSite.IsUseByPhi()) {
+      auto *useBB = useSite.GetPhi()->GetDefBB();
+      auto *iv = data->GetIV(*lhs);
+      CHECK_FATAL(iv, "iv is nullptr");
+      if (useBB != data->currLoop->head || !iv->isBasicIV) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+MeExpr *IVOptimizer::OptimizeInvariable(MeExpr *expr) {
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    auto *opnd = expr->GetOpnd(i);
+    if (opnd->GetMeOp() == kMeOpOp && data->IsLoopInvariant(*opnd)) {
+      // move loop invariant out of current loop
+      auto found = invariables.find(opnd->GetExprID());
+      RegMeExpr *outValue = nullptr;
+      if (found == invariables.end()) {
+        outValue = irMap->CreateRegMeExpr(*opnd);
+        invariables.emplace(opnd->GetExprID(), outValue);
+        auto *outStmt = irMap->CreateAssignMeStmt(static_cast<ScalarMeExpr &>(*outValue), *opnd,
+                                                  *data->currLoop->preheader);
+        data->currLoop->preheader->InsertMeStmtLastBr(outStmt);
+      } else {
+        outValue = static_cast<RegMeExpr *>(found->second);
+      }
+      expr = irMap->ReplaceMeExprExpr(*expr, *opnd, *outValue);
+      continue;
+    }
+    auto *res = OptimizeInvariable(opnd);
+    expr = irMap->ReplaceMeExprExpr(*expr, *opnd, *res);
+  }
+  if (expr->GetMeOp() == kMeOpOp && data->IsLoopInvariant(*expr)) {
+    // move loop invariant out of current loop
+    auto found = invariables.find(expr->GetExprID());
+    RegMeExpr *outValue = nullptr;
+    if (found == invariables.end()) {
+      outValue = irMap->CreateRegMeExpr(*expr);
+      invariables.emplace(expr->GetExprID(), outValue);
+      auto *outStmt = irMap->CreateAssignMeStmt(static_cast<ScalarMeExpr &>(*outValue), *expr,
+                                                *data->currLoop->preheader);
+      data->currLoop->preheader->InsertMeStmtLastBr(outStmt);
+    } else {
+      outValue = static_cast<RegMeExpr*>(found->second);
+    }
+    return outValue;
+  }
+  return expr;
+}
+
+void IVOptimizer::FindGeneralIVInStmt(MeStmt &stmt) {
+  for (uint32 i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+    auto *opnd = stmt.GetOpnd(i);
+    auto *opted = OptimizeInvariable(opnd);
+    if (opted != opnd) {
+      irMap->ReplaceMeExprStmt(stmt, *opnd, *opted);
+      opnd = opted;
+    }
+    bool isUsedInAddr = (stmt.GetOp() == OP_iassign || stmt.GetOp() == OP_iassignoff) && i == 0;
+    isUsedInAddr |= stmt.GetOp() == OP_assertnonnull;
+    if (FindGeneralIVInExpr(stmt, *opnd, isUsedInAddr)) {
+      auto *iv = data->GetIV(*opnd);
+      CHECK_FATAL(iv, "iv is nullptr!");
+      if (stmt.GetOp() == OP_regassign || stmt.GetOp() == OP_dassign) {
+        // record lhs scalar same (base, step) iv as rhs
+        data->CreateIV(stmt.GetLHS(), iv->base, iv->step, false);
+        // skip ivs that wont escape the loop
+        auto *lhs = static_cast<AssignMeStmt&>(stmt).GetLHS();
+        if (!LHSEscape(lhs)) {
+          data->CreateFakeGroup(stmt, *iv, kUseGeneral, opnd);
+          continue;
+        }
+      }
+      if (stmt.GetOp() == OP_assertnonnull) {
+        data->CreateGroup(stmt, *iv, kUseAddress, opnd);
+        continue;
+      }
+      if (isUsedInAddr) {
+        data->CreateGroup(stmt, *iv, kUseAddress, static_cast<IassignMeStmt&>(stmt).GetLHSVal());
+        (*(*data->groups.rbegin())->uses.rbegin())->hasField =
+            static_cast<IassignMeStmt&>(stmt).GetLHSVal()->GetFieldID() != 0 ||
+            static_cast<IassignMeStmt&>(stmt).GetLHSVal()->GetOffset() != 0;
+        continue;
+      }
+      // record use of iv that is root expr
+      data->CreateGroup(stmt, *iv, kUseGeneral, opnd);
+    }
+  }
+}
+
+void IVOptimizer::TraversalLoopBB(BB &bb, std::vector<bool> &bbVisited) {
+  if (bbVisited[bb.GetBBId()] || data->currLoop->loopBBs.count(bb.GetBBId()) == 0) {
+    return;
+  }
+  bbVisited[bb.GetBBId()] = true;
+
+  if (&bb != data->currLoop->head) {
+    for (auto &phiMap : bb.GetMePhiList()) {
+      FindGeneralIVInPhi(*phiMap.second);
+    }
+  }
+
+  for (auto &stmt : bb.GetMeStmts()) {
+    FindGeneralIVInStmt(stmt);
+  }
+
+  for (auto childID : dom->GetDomChildren(bb.GetID())) {
+    TraversalLoopBB(*cfg->GetBBFromID(BBId(childID)), bbVisited);
+  }
+}
+
+void IVOptimizer::CreateIVCandidateFromBasicIV(IV &iv) {
+  ScalarMeExpr *tmp = nullptr;
+  ScalarMeExpr *inc = nullptr;
+  MeExpr *base = nullptr;
+  MeExpr *step = nullptr;
+  IVCand *cand = nullptr;
+  // create origin version
+  if (iv.expr->GetMeOp() == kMeOpReg || iv.expr->GetMeOp() == kMeOpVar) {
+    if (static_cast<ScalarMeExpr*>(iv.expr)->IsDefByPhi()) {
+      inc = data->currLoop->preheader == data->currLoop->head->GetPred(0) ?
+          static_cast<ScalarMeExpr*>(iv.expr)->GetDefPhi().GetOpnd(1) :
+          static_cast<ScalarMeExpr*>(iv.expr)->GetDefPhi().GetOpnd(0);
+      cand = data->CreateCandidate(iv.expr, iv.base, iv.step, inc);
+      cand->incPos = kOriginal;
+      if (cand->iv->expr != iv.expr) {
+        // already created a iv with same base & step, use origin one to replace it
+        cand->iv->expr = iv.expr;
+        cand->incVersion = inc;
+      }
+      cand->important = true;
+    }
+  }
+
+  // create unsigned version
+  auto type = GetUnsignedPrimType(iv.expr->GetPrimType());
+  tmp = irMap->CreateRegMeExpr(type);
+  base = irMap->CreateMeExprTypeCvt(type, iv.base->GetPrimType(), *iv.base);
+  auto *simplified = irMap->SimplifyMeExpr(base);
+  if (simplified != nullptr) {
+    base = simplified;
+  }
+  step = irMap->CreateMeExprTypeCvt(type, iv.step->GetPrimType(), *iv.step);
+  simplified = irMap->SimplifyMeExpr(step);
+  if (simplified != nullptr) {
+    step = simplified;
+  }
+  inc = irMap->CreateRegMeExprVersion(*tmp);
+  cand = data->CreateCandidate(tmp, base, step, inc);
+  cand->important = true;
+
+  // create zero-based version
+  tmp = irMap->CreateRegMeExpr(type);
+  base = irMap->CreateIntConstMeExpr(0, type);
+  inc = irMap->CreateRegMeExprVersion(*tmp);
+  cand = data->CreateCandidate(tmp, base, step, inc);
+  cand->important = true;
+
+  // create address version
+  auto addressPTY = GetPrimTypeSize(PTY_ptr) == GetPrimTypeSize(PTY_u64) ? PTY_u64 : PTY_u32;
+  tmp = irMap->CreateRegMeExpr(addressPTY);
+  base = irMap->CreateMeExprTypeCvt(addressPTY, GetSignedPrimType(iv.base->GetPrimType()), *iv.base);
+  simplified = irMap->SimplifyMeExpr(base);
+  if (simplified != nullptr) {
+    base = simplified;
+  }
+  step = irMap->CreateMeExprTypeCvt(addressPTY, GetSignedPrimType(iv.step->GetPrimType()), *iv.step);
+  simplified = irMap->SimplifyMeExpr(step);
+  if (simplified != nullptr) {
+    step = simplified;
+  }
+  inc = irMap->CreateRegMeExprVersion(*tmp);
+  cand = data->CreateCandidate(tmp, base, step, inc);
+  cand->important = true;
+  cand->origIV = &iv;
+}
+
+MeExpr *IVOptimizer::StripConstantPart(MeExpr &expr, int64 &offset) {
+  int64 offset0 = 0;
+  int64 offset1 = 0;
+  switch (expr.GetOp()) {
+    case OP_add:
+    case OP_sub: {
+      auto *opnd0 = static_cast<OpMeExpr&>(expr).GetOpnd(0);
+      auto *opnd1 = static_cast<OpMeExpr&>(expr).GetOpnd(1);
+      auto *op0 = StripConstantPart(*opnd0, offset0);
+      auto *op1 = StripConstantPart(*opnd1, offset1);
+      offset = expr.GetOp() == OP_add ? (offset0 + offset1) : (offset0 - offset1);
+      if (op0 != nullptr && op1 != nullptr) {
+        return irMap->CreateMeExprBinary(expr.GetOp(), expr.GetPrimType(), *op0, *op1);
+      }
+      if (op0 != nullptr) {
+        return op0;
+      }
+      if (op1 != nullptr) {
+        return expr.GetOp() == OP_add ? op1 : irMap->CreateMeExprUnary(OP_neg, expr.GetPrimType(), *op1);
+      }
+      return nullptr;
+    }
+    case OP_mul: {
+      auto *opnd0 = static_cast<OpMeExpr&>(expr).GetOpnd(0);
+      auto *opnd1 = static_cast<OpMeExpr&>(expr).GetOpnd(1);
+      auto *op0 = StripConstantPart(*opnd0, offset0);
+      auto *op1 = StripConstantPart(*opnd1, offset1);
+      if (op0 != nullptr && op1 != nullptr) {
+        return &expr;
+      }
+      if (op0 != nullptr) {
+        if (op0 == opnd0) {
+          return &expr;
+        }
+        offset = offset1 * offset0;
+        return irMap->CreateMeExprBinary(OP_mul, expr.GetPrimType(), *op0,
+                                         *irMap->CreateIntConstMeExpr(offset1, expr.GetPrimType()));
+      }
+      if (op1 != nullptr) {
+        if (op1 == opnd1) {
+          return &expr;
+        }
+        offset = offset1 * offset0;
+        return irMap->CreateMeExprBinary(OP_mul, expr.GetPrimType(), *op1,
+                                         *irMap->CreateIntConstMeExpr(offset0, expr.GetPrimType()));
+      }
+      offset = offset1 * offset0;
+      return nullptr;
+    }
+    case OP_constval: {
+      offset = static_cast<ConstMeExpr&>(expr).GetExtIntValue();
+      return nullptr;
+    }
+    default: {
+      return &expr;
+    }
+  }
+}
+
+void IVOptimizer::CreateIVCandidateFromUse(IVUse &use) {
+  auto *tmp = irMap->CreateRegMeExpr(GetUnsignedPrimType(use.iv->expr->GetPrimType()));
+  auto *inc = irMap->CreateRegMeExprVersion(*tmp);
+  auto *cand = data->CreateCandidate(tmp, use.iv->base, use.iv->step, inc);
+  use.group->relatedCands.emplace(cand->GetID());
+
+  MeExpr *simplified = nullptr;
+  // try to find simpler candidate
+  if (use.iv->base->GetOp() == OP_add) {
+    for (uint32 i = 0; i < 2 ; ++i) { // add/sub has 2 opnds
+      if (use.iv->base->GetOpnd(i) == use.iv->step) {
+        tmp = irMap->CreateRegMeExpr(GetUnsignedPrimType(use.iv->expr->GetPrimType()));
+        inc = irMap->CreateRegMeExprVersion(*tmp);
+        cand = data->CreateCandidate(tmp, use.iv->base->GetOpnd(1 - i), use.iv->step, inc);
+        use.group->relatedCands.emplace(cand->GetID());
+      }
+    }
+  } else if (use.iv->base->GetOp() == OP_sub) {
+    if (use.iv->base->GetOpnd(1) == use.iv->step) {
+      tmp = irMap->CreateRegMeExpr(GetUnsignedPrimType(use.iv->expr->GetPrimType()));
+      inc = irMap->CreateRegMeExprVersion(*tmp);
+      cand = data->CreateCandidate(tmp, use.iv->base->GetOpnd(0), use.iv->step, inc);
+      use.group->relatedCands.emplace(cand->GetID());
+    }
+  }
+  // strip constant part of base and create a candidate
+  int64 offset = 0;
+  auto *newBase = StripConstantPart(*use.iv->base, offset);
+  if (newBase == nullptr) {
+    return;
+  }
+  simplified = irMap->SimplifyMeExpr(newBase);
+  newBase = simplified == nullptr ? newBase : simplified;
+  if (newBase != use.iv->base) {
+    tmp = irMap->CreateRegMeExpr(GetUnsignedPrimType(use.iv->expr->GetPrimType()));
+    inc = irMap->CreateRegMeExprVersion(*tmp);
+    cand = data->CreateCandidate(tmp, use.iv->base, use.iv->step, inc);
+    use.group->relatedCands.emplace(cand->GetID());
+  }
+}
+
+void IVOptimizer::CreateIVCandidate() {
+  // create (0, +1) iv
+  auto *tmp = irMap->CreateRegMeExpr(PTY_u32);
+  auto *base = irMap->CreateIntConstMeExpr(0, PTY_u32);
+  auto *inc = irMap->CreateRegMeExprVersion(*tmp);
+  auto *step = irMap->CreateIntConstMeExpr(1, PTY_u32);
+  auto *newCand = data->CreateCandidate(tmp, base, step, inc);
+  newCand->important = true;
+
+  tmp = irMap->CreateRegMeExpr(PTY_u64);
+  base = irMap->CreateIntConstMeExpr(0, PTY_u64);
+  inc = irMap->CreateRegMeExprVersion(*tmp);
+  step = irMap->CreateIntConstMeExpr(1, PTY_u64);
+  newCand = data->CreateCandidate(tmp, base, step, inc);
+  newCand->important = true;
+  // create candidate from basic IV
+  for (auto &itIV : data->ivs) {
+    auto *iv = itIV.second.get();
+    if (iv->isBasicIV) {
+      CreateIVCandidateFromBasicIV(*iv);
+    }
+  }
+
+  // add all candidate created from basic iv to all groups
+  for (auto &group : data->groups) {
+    for (auto &cand : data->cands) {
+      group->relatedCands.emplace(cand->GetID());
+    }
+  }
+
+  std::map<MeExpr*, std::vector<IVUse*>> offsetCount;
+  // create candidate from use
+  for (auto &group : data->groups) {
+    // just need to consider the first use
+    CreateIVCandidateFromUse(*group->uses[0]);
+
+    // apart base
+    auto ivExpr = group->uses[0]->iv->expr;
+    if (ivExpr->GetOp() == OP_add) {
+      auto *opExpr = static_cast<OpMeExpr*>(ivExpr);
+      MeExpr *aparted = nullptr;
+      if (data->IsLoopInvariant(*opExpr->GetOpnd(0))) {
+        aparted = opExpr->GetOpnd(1);
+      } else if (data->IsLoopInvariant(*opExpr->GetOpnd(1))) {
+        aparted = opExpr->GetOpnd(0);
+      }
+      if (aparted != nullptr) {
+        offsetCount.try_emplace(aparted, std::vector<IVUse*>());
+        offsetCount[aparted].emplace_back(group->uses[0].get());
+      }
+    }
+  }
+
+  // create candidate from common offset
+  for (auto &it : offsetCount) {
+    if (it.second.size() > 1) {
+      tmp = irMap->CreateRegMeExpr(it.first->GetPrimType());
+      auto *iv = data->GetIV(*it.first);
+      CHECK_FATAL(iv != nullptr, "common offset must be a iv");
+      inc = irMap->CreateRegMeExprVersion(*tmp);
+      auto *cand = data->CreateCandidate(tmp, iv->base, iv->step, inc);
+      for (auto *use : it.second) {
+        use->group->relatedCands.emplace(cand->GetID());
+      }
+    }
+  }
+
+  // create candidate from fakeGroup
+  for (auto &group : data->fakeGroups) {
+    // just need to consider the first use
+    CreateIVCandidateFromUse(*group->uses[0]);
+  }
+}
+
+static uint32 ComputeExprCost(MeExpr &expr, const MeExpr *parent = nullptr) {
+#ifndef TARGAARCH64
+  return 0;
+#endif
+  // initialize cost
+  constexpr uint32 regCost = 0;
+  constexpr uint32 constCost = 4;
+  constexpr uint32 cvtCost = 4;
+  constexpr uint32 addCost = 4;
+  constexpr uint32 addressCost = 5;
+  constexpr uint32 mulCost = 5;
+  constexpr uint32 symbolCost = 9;
+  constexpr uint32 defaultCost = 16;
+
+  switch (expr.GetMeOp()) {
+    case kMeOpReg:
+      return regCost;
+    case kMeOpVar: {
+      if (static_cast<VarMeExpr&>(expr).HasAddressValue()) {
+        return addressCost;
+      }
+      return symbolCost;
+    }
+    case kMeOpConst:
+      return constCost;
+    case kMeOpOp: {
+      uint32 op0Cost = 0;
+      uint32 op1Cost = 0;
+      auto &op = static_cast<OpMeExpr&>(expr);
+      if (op.GetOp() == OP_mul) {
+        op0Cost = ComputeExprCost(*op.GetOpnd(0), &op);
+        op1Cost = ComputeExprCost(*op.GetOpnd(1), &op);
+        if (parent != nullptr) {
+          if (parent->GetOp() == OP_sub || parent->GetOp() == OP_add) {
+            return op0Cost + op1Cost + 1;
+          }
+        }
+        return op0Cost + op1Cost + mulCost;
+      }
+      if (op.GetOp() == OP_add || op.GetOp() == OP_sub) {
+        op0Cost = ComputeExprCost(*op.GetOpnd(0), &op);
+        op1Cost = ComputeExprCost(*op.GetOpnd(1), &op);
+        return op0Cost + op1Cost + addCost;
+      }
+      if (op.GetOp() == OP_cvt || op.GetOp() == OP_retype) {
+        op0Cost = ComputeExprCost(*op.GetOpnd(0), &op);
+        if (GetPrimTypeSize(op.GetOpndType()) <= GetPrimTypeSize(op.GetPrimType())) {
+          return op0Cost;
+        }
+        return op0Cost + cvtCost;
+      }
+      return defaultCost;
+    }
+    default:
+      return defaultCost;
+  }
+}
+
+static uint32 ComputeAddressCost(MeExpr *expr, int64 ratio, bool hasField) {
+  bool ratioCombine = ratio == 1 || ratio == 2 || ratio == 4 || ratio == 8;
+  uint32 cost = 0;
+  if (expr != nullptr) {
+    cost += 1;
+  }
+  if (!ratioCombine) {
+    cost += kCost5;
+  }
+  if (hasField && (!expr || expr->GetMeOp() != kMeOpConst)) {
+    cost += kCost3;
+  }
+  return cost;
+}
+
+void IVOptimizer::ComputeCandCost() {
+  for (auto &cand : data->cands) {
+    uint32 baseCost = ComputeExprCost(*cand->iv->base);
+    if (baseCost == 0) {
+      // reg generally need a copy
+      baseCost = 1;
+    }
+#ifdef TARGAARCH64
+    uint32 stepCost = 4;
+#else
+    uint32 stepCost = 0;
+#endif
+    uint32 cost = baseCost / data->iterNum + stepCost;  // average baseCost to per loop iter and add iv inc cost
+    if (cand->incPos != kOriginal) {
+      // we prefer original iv because it is closer to the source code, but we wont give too much weight for this.
+      ++cost;
+    }
+    if (cand->incPos == kAfterExitTest && data->currLoop->latch->IsMeStmtEmpty()) {
+      // do not insert stmt to empty bb, or we need to insert an extra jump stmt
+      ++cost;
+    }
+    cand->cost = cost;
+  }
+}
+
+static void FindScalarFactor(MeExpr &expr, std::unordered_map<int32, std::pair<MeExpr*, int64>> &record,
+                             int64 multiplier) {
+  switch (expr.GetMeOp()) {
+    case kMeOpConst: {
+      int64 constVal = static_cast<ConstMeExpr&>(expr).GetExtIntValue();
+      auto it = record.find(kInvalidExprID);
+      if (it == record.end()) {
+        record.emplace(kInvalidExprID, std::make_pair(nullptr, multiplier * constVal));
+      } else {
+        it->second.second += (multiplier * constVal);
+      }
+      return;
+    }
+    case kMeOpReg:
+    case kMeOpVar: {
+      auto it = record.find(expr.GetExprID());
+      if (it == record.end()) {
+        record.emplace(expr.GetExprID(), std::make_pair(&expr, multiplier));
+      } else {
+        it->second.second += multiplier;
+      }
+      return;
+    }
+    case kMeOpOp: {
+      auto &op = static_cast<OpMeExpr&>(expr);
+      if (op.GetOp() == OP_add) {
+        FindScalarFactor(*op.GetOpnd(0), record, multiplier);
+        FindScalarFactor(*op.GetOpnd(1), record, multiplier);
+      } else if (op.GetOp() == OP_sub) {
+        FindScalarFactor(*op.GetOpnd(0), record, multiplier);
+        FindScalarFactor(*op.GetOpnd(1), record, -multiplier);
+      } else if (op.GetOp() == OP_mul) {
+        auto *opnd0 = op.GetOpnd(0);
+        auto *opnd1 = op.GetOpnd(1);
+        if (opnd0->GetMeOp() != kMeOpConst && opnd1->GetMeOp() != kMeOpConst) {
+          record.emplace(expr.GetExprID(), std::make_pair(&expr, multiplier));
+          return;
+        }
+        if (opnd0->GetMeOp() == kMeOpConst) {
+          FindScalarFactor(*op.GetOpnd(1), record, multiplier * static_cast<ConstMeExpr*>(opnd0)->GetExtIntValue());
+        } else {
+          FindScalarFactor(*op.GetOpnd(0), record, multiplier * static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue());
+        }
+      } else if (op.GetOp() == OP_cvt) {
+        FindScalarFactor(*op.GetOpnd(0), record, multiplier);
+      }
+      return;
+    }
+    default:
+      return;
+  }
+}
+
+int64 IVOptimizer::ComputeRatioOfStep(MeExpr &candStep, MeExpr &groupStep) {
+  if (candStep.GetMeOp() == kMeOpConst || groupStep.GetMeOp() == kMeOpConst) {
+    if (groupStep.GetMeOp() != kMeOpConst || candStep.GetMeOp() != kMeOpConst) {
+      // can not compute
+      return 0;
+    }
+    int64 candConst = static_cast<ConstMeExpr&>(candStep).GetExtIntValue();
+    int64 groupConst = static_cast<ConstMeExpr&>(groupStep).GetExtIntValue();
+    if (candStep.GetPrimType() == PTY_u32 || groupStep.GetPrimType() == PTY_u32) {
+      candConst = static_cast<int64>(static_cast<int32>(candConst));
+      groupConst = static_cast<int64>(static_cast<int32>(groupConst));
+    }
+    if (candConst == 0) {
+      return 0;
+    }
+    int64 remainder = groupConst % candConst;
+    return remainder == 0 ? groupConst / candConst : 0;
+  }
+
+  std::unordered_map<int32, std::pair<MeExpr*, int64>> candMap;
+  std::unordered_map<int32, std::pair<MeExpr*, int64>> groupMap;
+  FindScalarFactor(candStep, candMap, 1);
+  FindScalarFactor(groupStep, groupMap, 1);
+  int64 commonRatio = 0;
+  for (auto &itGroup : groupMap) {
+    auto itCand = candMap.find(itGroup.first);
+    if (itCand == candMap.end()) {
+      return 0;
+    }
+  }
+  for (auto &itCand : candMap) {
+    auto itGroup = groupMap.find(itCand.first);
+    if (itGroup == groupMap.end()) {
+      return 0;
+    }
+    if (itGroup->second.second == 0 && itCand.second.second == 0) {
+      continue;
+    } else if (itCand.second.second == 0) {
+      return kInfinityCost;
+    }
+    int64 remainder = itGroup->second.second % itCand.second.second;
+    if (remainder != 0) {
+      return 0;
+    }
+    int64 ratio = itGroup->second.second / itCand.second.second;
+    if (ratio == 0) {
+      return 0;
+    }
+    if (commonRatio == 0) {
+      commonRatio = ratio;
+    }
+    if (ratio != commonRatio) {
+      return 0;
+    }
+  }
+  return commonRatio;
+}
+
+MeExpr *IVOptimizer::ComputeExtraExprOfBase(MeExpr &candBase, MeExpr &groupBase, uint64 ratio, bool &replaced) {
+  std::unordered_map<int32, std::pair<MeExpr*, int64>> candMap;
+  std::unordered_map<int32, std::pair<MeExpr*, int64>> groupMap;
+  FindScalarFactor(candBase, candMap, 1);
+  FindScalarFactor(groupBase, groupMap, 1);
+  MeExpr *extraExpr = nullptr;
+  int64 candConst = 0;
+  int64 groupConst = 0;
+  for (auto &itGroup : groupMap) {
+    auto itCand = candMap.find(itGroup.first);
+    if (itGroup.first == kInvalidExprID) {
+      candConst = itCand == candMap.end() ? 0 : itCand->second.second * ratio;
+      groupConst = itGroup.second.second;
+      continue;
+    }
+    if (itCand == candMap.end()) {
+      MeExpr *constExpr = nullptr;
+      MeExpr *expr = itGroup.second.first;
+      if (NeedCvtOrRetype(expr->GetPrimType(), groupBase.GetPrimType())) {
+        expr = irMap->CreateMeExprTypeCvt(groupBase.GetPrimType(), expr->GetPrimType(), *expr);
+      }
+      if (itGroup.second.second != 1) {
+        constExpr = irMap->CreateIntConstMeExpr(itGroup.second.second, groupBase.GetPrimType());
+        expr = irMap->CreateMeExprBinary(OP_mul, groupBase.GetPrimType(), *expr, *constExpr);
+      }
+      extraExpr = extraExpr == nullptr ? expr
+                                       : irMap->CreateMeExprBinary(OP_add, groupBase.GetPrimType(), *extraExpr, *expr);
+    } else {
+      int64 newMultiplier = itGroup.second.second - (itCand->second.second * ratio);
+      if (newMultiplier == 0) {
+        continue;
+      }
+      MeExpr *constExpr = nullptr;
+      MeExpr *expr = itGroup.second.first;
+      if (NeedCvtOrRetype(expr->GetPrimType(), groupBase.GetPrimType())) {
+        expr = irMap->CreateMeExprTypeCvt(groupBase.GetPrimType(), expr->GetPrimType(), *expr);
+      }
+      if (newMultiplier != 1) {
+        constExpr = irMap->CreateIntConstMeExpr(newMultiplier, groupBase.GetPrimType());
+        expr = irMap->CreateMeExprBinary(OP_mul, groupBase.GetPrimType(), *expr, *constExpr);
+      }
+      extraExpr = extraExpr == nullptr ? expr
+                                       : irMap->CreateMeExprBinary(OP_add, groupBase.GetPrimType(), *extraExpr, *expr);
+    }
+  }
+  auto ptyp = groupBase.GetPrimType();
+  if (GetPrimTypeSize(candBase.GetPrimType()) > GetPrimTypeSize(groupBase.GetPrimType())) {
+    ptyp = candBase.GetPrimType();
+  }
+  for (auto &itCand : candMap) {
+    auto itGroup = groupMap.find(itCand.first);
+    if (itCand.first == kInvalidExprID) {
+      candConst = itCand.second.second * ratio;
+      groupConst = itGroup == groupMap.end() ? 0 : itGroup->second.second;
+      continue;
+    }
+    if (itGroup == groupMap.end()) {
+      if (itCand.second.first->GetPrimType() == PTY_ptr ||
+          itCand.second.first->GetPrimType() == PTY_a64 ||
+          itCand.second.first->GetPrimType() == PTY_a32) {  // it's not good to use one obj to form others
+        replaced = false;
+        return nullptr;
+      }
+      auto *constExpr = irMap->CreateIntConstMeExpr(-(itCand.second.second * ratio), ptyp);
+      auto *expr = itCand.second.first;
+      if (extraExpr != nullptr) {
+        if (NeedCvtOrRetype(extraExpr->GetPrimType(), ptyp)) {
+          extraExpr = irMap->CreateMeExprTypeCvt(ptyp, extraExpr->GetPrimType(), *extraExpr);
+        }
+      }
+      if (NeedCvtOrRetype(expr->GetPrimType(), ptyp)) {
+        expr = irMap->CreateMeExprTypeCvt(ptyp, expr->GetPrimType(), *expr);
+      }
+      expr = irMap->CreateMeExprBinary(OP_mul, ptyp, *expr, *constExpr);
+      extraExpr = extraExpr == nullptr ? expr
+                                       : irMap->CreateMeExprBinary(OP_add, ptyp, *extraExpr, *expr);
+    }
+  }
+  if (static_cast<uint64>(groupConst) - static_cast<uint64>(candConst) == 0) {
+    return extraExpr;
+  }
+  auto *constExpr = irMap->CreateIntConstMeExpr(static_cast<uint64>(groupConst) - static_cast<uint64>(candConst), ptyp);
+  extraExpr = extraExpr == nullptr ? constExpr
+                                   : irMap->CreateMeExprBinary(OP_add, ptyp, *extraExpr, *constExpr);
+  return extraExpr;
+}
+
+static bool CheckOverflow(const MeExpr *opnd0, const MeExpr *opnd1, Opcode op, PrimType ptyp) {
+  // can be extended to scalar later
+  if (opnd0->GetMeOp() != kMeOpConst || opnd1->GetMeOp() != kMeOpConst) {
+    return true;
+  }
+  int64 const0 = static_cast<const ConstMeExpr*>(opnd0)->GetExtIntValue();
+  int64 const1 = static_cast<const ConstMeExpr*>(opnd1)->GetExtIntValue();
+  if (op == OP_add) {
+    int64 res = static_cast<int64>(static_cast<uint64>(const0) + static_cast<uint64>(const1));
+    if (IsUnsignedInteger(ptyp)) {
+      auto shiftNum = 64 - GetPrimTypeBitSize(ptyp);
+      return (static_cast<uint64>(res) << shiftNum) >> shiftNum <
+             (static_cast<uint64>(const0) << shiftNum) >> shiftNum;
+    }
+    auto rightShiftNumToGetSignFlag = GetPrimTypeBitSize(ptyp) - 1;
+    return (static_cast<uint64>(res) >> rightShiftNumToGetSignFlag !=
+            static_cast<uint64>(const0) >> rightShiftNumToGetSignFlag) &&
+           (static_cast<uint64>(res) >> rightShiftNumToGetSignFlag !=
+            static_cast<uint64>(const1) >> rightShiftNumToGetSignFlag);
+  }
+  if (op == OP_sub) {
+    if (IsUnsignedInteger(ptyp)) {
+      return const0 < const1;
+    }
+    int64 res = static_cast<int64>(static_cast<uint64>(const0) - static_cast<uint64>(const1));
+    auto rightShiftNumToGetSignFlag = GetPrimTypeBitSize(ptyp) - 1;
+    return (static_cast<uint64>(const0) >> rightShiftNumToGetSignFlag !=
+            static_cast<uint64>(const1) >> rightShiftNumToGetSignFlag) &&
+           (static_cast<uint64>(res) >> rightShiftNumToGetSignFlag !=
+            static_cast<uint64>(const0) >> rightShiftNumToGetSignFlag);
+  }
+  return true;
+}
+
+uint32 IVOptimizer::ComputeCandCostForGroup(const IVCand &cand, IVGroup &group) {
+  if (GetPrimTypeSize(cand.iv->expr->GetPrimType()) < GetPrimTypeSize(group.uses[0]->iv->expr->GetPrimType())) {
+    return kInfinityCost;
+  }
+  int64 ratio = ComputeRatioOfStep(*cand.iv->step, *group.uses[0]->iv->step);
+  bool replaced = true;
+  if (ratio == 0) {
+    // if the cand is bigger than cmp group, we can also replace it by increasing the other hand of cmp
+    if (group.type == kUseCompare) {
+      ratio = ComputeRatioOfStep(*group.uses[0]->iv->step, *cand.iv->step);
+      if (ratio == 0) {
+        return kInfinityCost;
+      }
+      auto *cmp = static_cast<OpMeExpr*>(group.uses[0]->expr);
+      auto isEqNe = cmp->GetOp() == OP_eq || cmp->GetOp() == OP_ne;
+      if (!isEqNe && ratio != 1 && ratio != -1) {
+        return kInfinityCost;
+      }
+      MeExpr *extraExpr = ComputeExtraExprOfBase(*group.uses[0]->iv->base, *cand.iv->base,
+                                                 static_cast<uint64>(ratio), replaced);
+      if (!replaced) {
+        return kInfinityCost;
+      }
+      if (extraExpr == nullptr) {
+        return 0;
+      }
+      return ComputeExprCost(*extraExpr) / data->iterNum;
+    }
+    return kInfinityCost;
+  }
+
+  MeExpr *extraExpr = ComputeExtraExprOfBase(*cand.iv->base, *group.uses[0]->iv->base,
+                                             static_cast<uint64>(ratio), replaced);
+  if (!replaced) {
+    return kInfinityCost;
+  }
+  uint32 mulCost = 5;
+  uint8 extraConstCost = 4;
+  if (group.type == kUseGeneral) {
+    if (extraExpr == nullptr) {
+      return (ratio == 1 ? 0 : mulCost + kRegCost);
+    }
+    if (extraExpr == cand.iv->step && ratio == 1) {
+      return 0;
+    }
+    uint32 cost = ComputeExprCost(*extraExpr);
+    if (extraExpr->GetMeOp() == kMeOpConst) {
+      return extraConstCost;
+    }
+    return (cost / data->iterNum) + (ratio == 1 ? mulCost - 1 + kRegCost : mulCost + kRegCost2);
+  } else if (group.type == kUseAddress) {
+    if (GetPrimTypeSize(cand.iv->expr->GetPrimType()) > GetPrimTypeSize(PTY_ptr)) {
+      // keep address type
+      return kInfinityCost;
+    }
+    uint32 addressCost = ComputeAddressCost(extraExpr, ratio, group.uses[0]->hasField);
+    if (extraExpr == nullptr) {
+      return addressCost;
+    }
+    uint32 cost = ComputeExprCost(*extraExpr);
+    return (cost / data->iterNum) + (extraExpr->IsLeaf() ? 0 : kRegCost) + addressCost;
+  } else if (group.type == kUseCompare) {
+    if (extraExpr == nullptr) {
+      return ((ratio == 1 || ratio == -1) ? 0 : mulCost + kRegCost);
+    }
+    uint32 cost = ComputeExprCost(*extraExpr);
+    auto isEqNe = group.uses[0]->expr->GetOp() == OP_eq || group.uses[0]->expr->GetOp() == OP_ne;
+    return (cost / data->iterNum) + ((ratio == 1 || (ratio == -1 && isEqNe)) ? 0 : mulCost + kRegCost2);
+  }
+  return kInfinityCost;
+}
+
+void IVOptimizer::ComputeGroupCost() {
+  for (auto &group : data->groups) {
+    for (auto &cand : data->cands) {
+      uint32 cost = ComputeCandCostForGroup(*cand, *group);
+      group->candCosts.emplace_back(cost);
+    }
+  }
+}
+
+uint32 IVOptimizer::ComputeSetCost(CandSet &set) {
+  uint32 cost = 0;
+  for (uint32 k = 0; k < set.candCount.size(); ++k) {
+    if (set.candCount[k] > 0) {
+      cost += (data->cands[k]->cost + kRegCost);
+    }
+  }
+  for (uint32 i = 0; i < set.chosenCands.size(); ++i) {
+    auto *cand = set.chosenCands[i];
+    cost += data->groups[i]->candCosts[cand->GetID()];
+  }
+  return cost;
+}
+
+void IVOptimizer::InitSet(bool originFirst) {
+  auto init = std::make_unique<CandSet>();
+  init->chosenCands.resize(data->groups.size(), nullptr);
+  init->candCount.resize(data->cands.size(), 0);
+  for (auto &group : data->groups) {
+    for (auto &cand : data->cands) {
+      if (group->candCosts[cand->GetID()] == kInfinityCost) {
+        continue;
+      }
+      if (init->chosenCands[group->GetID()] == nullptr) {
+        init->chosenCands[group->GetID()] = cand.get();
+        ++init->candCount[cand->GetID()];
+        continue;
+      }
+      if (originFirst) {
+        if (cand->incPos == kOriginal) {
+          if (init->chosenCands[group->GetID()]->incPos != kOriginal) {
+            ++init->candCount[cand->GetID()];
+            --init->candCount[init->chosenCands[group->GetID()]->GetID()];
+            init->chosenCands[group->GetID()] = cand.get();
+            continue;
+          }
+        } else if (cand->origIV != nullptr) {
+          if (init->chosenCands[group->GetID()]->incPos == kOriginal) {
+            continue;
+          } else if (init->chosenCands[group->GetID()]->origIV != nullptr) {
+          } else {
+            ++init->candCount[cand->GetID()];
+            --init->candCount[init->chosenCands[group->GetID()]->GetID()];
+            init->chosenCands[group->GetID()] = cand.get();
+            continue;
+          }
+        } else {
+          if (init->chosenCands[group->GetID()]->incPos == kOriginal ||
+              init->chosenCands[group->GetID()]->origIV != nullptr) {
+            continue;
+          }
+        }
+      }
+      uint32 curCost = group->candCosts[init->chosenCands[group->GetID()]->GetID()];
+      uint32 candCost = group->candCosts[cand->GetID()];
+      if (candCost < curCost) {
+        ++init->candCount[cand->GetID()];
+        --init->candCount[init->chosenCands[group->GetID()]->GetID()];
+        init->chosenCands[group->GetID()] = cand.get();
+      }
+    }
+    if (init->chosenCands[group->GetID()] == nullptr ||
+        group->candCosts[init->chosenCands[group->GetID()]->GetID()] == kInfinityCost) {
+      if (dumpDetail) {
+        LogInfo::MapleLogger() << "Can not initial" << (originFirst ? " original set" : "") << "!!!!\n";
+      }
+      return;
+    }
+  }
+  // try eliminate cand by replacing it with other used cands
+  for (auto &cand : data->cands) {
+    if (init->candCount[cand->GetID()] >= 1) {
+      auto tmpSet = *init;
+      std::unordered_map<IVGroup*, IVCand*> tmpChange;
+      TryReplaceWithCand(tmpSet, *cand, tmpChange);
+      if (tmpSet.cost < init->cost) {
+        for (auto &it : tmpChange) {
+          ++init->candCount[it.second->GetID()];
+          --init->candCount[init->chosenCands[it.first->GetID()]->GetID()];
+          init->chosenCands[it.first->GetID()] = it.second;
+        }
+      }
+    }
+  }
+  init->cost = ComputeSetCost(*init);
+  data->set = std::move(init);
+}
+
+uint32 CandSet::NumIVs() {
+  uint32 num = 0;
+  for (auto count : candCount) {
+    if (count > 0) {
+      ++num;
+    }
+  }
+  return num;
+}
+
+// try to replace more with the 'cand' and find if there're opportunities
+void IVOptimizer::TryReplaceWithCand(CandSet &set, IVCand &cand, std::unordered_map<IVGroup*, IVCand*> &change) {
+  std::vector<bool> visitedCands(set.candCount.size(), false);
+  for (uint32 i = 0; i < set.chosenCands.size(); ++i) {
+    auto *group = data->groups[i].get();
+    auto *chosenCand = set.chosenCands[i];
+    if (chosenCand == &cand || visitedCands[chosenCand->GetID()]) {
+      continue;
+    }
+    visitedCands[chosenCand->GetID()] = true;
+    if (set.candCount[chosenCand->GetID()] == 1) {
+      if (group->candCosts[cand.GetID()] <= group->candCosts[chosenCand->GetID()] + kRegCost + chosenCand->cost) {
+        change.insert_or_assign(group, &cand);
+        set.chosenCands[i] = &cand;
+        set.cost = set.cost - group->candCosts[chosenCand->GetID()] - kRegCost + group->candCosts[cand.GetID()] -
+                   chosenCand->cost;
+      }
+      continue;
+    }
+    uint32 tmpCost = set.cost;
+    std::unordered_map<IVGroup*, IVCand*> tmpChange;
+    bool allReplaced = true;
+    for (uint32 j = i; j < set.chosenCands.size(); ++j) {
+      auto *anotherGroup = data->groups[j].get();
+      auto *anotherCand = set.chosenCands[j];
+      if (anotherCand != chosenCand) {
+        continue;
+      }
+      if (anotherGroup->candCosts[cand.GetID()] == kInfinityCost) {
+        allReplaced = false;
+        continue;
+      }
+      tmpChange.emplace(anotherGroup, &cand);
+      tmpCost = tmpCost - anotherGroup->candCosts[chosenCand->GetID()] + anotherGroup->candCosts[cand.GetID()];
+    }
+    tmpCost = allReplaced ? tmpCost - kRegCost - chosenCand->cost : tmpCost;
+    if (tmpCost <= set.cost) {
+      for (auto &it : tmpChange) {
+        set.chosenCands[it.first->GetID()] = &cand;
+        change.insert_or_assign(it.first, it.second);
+      }
+      set.cost = tmpCost;
+    }
+  }
+}
+
+bool IVOptimizer::OptimizeSet() {
+  auto *set = data->set.get();
+  uint32 bestCost = set->cost;
+  uint32 numIVs = set->NumIVs();
+  std::unordered_map<IVGroup*, IVCand*> bestChange;
+  uint32 bestInitDepth = 0;
+  for (auto &cand : data->cands) {
+    if (set->candCount[cand->GetID()] != 0) {
+      bestInitDepth += cand->iv->base->GetDepth();
+    }
+  }
+  for (auto &cand : data->cands) {
+    if (set->candCount[cand->GetID()] != 0) {
+      continue;
+    }
+    uint32 curCost = set->cost;
+    std::unordered_map<IVGroup*, IVCand*> curChange;
+    uint32 curInitDepth = bestInitDepth;
+    std::vector<uint32> tmpCandCount = set->candCount;
+    bool replaced = false;
+    for (auto &group : data->groups) {
+      auto chosenCand = set->chosenCands[group->GetID()];
+      if (group->candCosts[cand->GetID()] <= group->candCosts[chosenCand->GetID()]) {
+        curCost = curCost - group->candCosts[chosenCand->GetID()] + group->candCosts[cand->GetID()];
+        if (--tmpCandCount[chosenCand->GetID()] == 0) {
+          curCost = curCost - kRegCost - chosenCand->cost;
+          curInitDepth = curInitDepth - chosenCand->iv->base->GetDepth();
+        }
+        if (++tmpCandCount[cand->GetID()] == 1) {
+          curCost = curCost + kRegCost + cand->cost;
+          curInitDepth = curInitDepth + cand->iv->base->GetDepth();
+        }
+        curChange.emplace(group.get(), cand.get());
+        replaced = true;
+      }
+    }
+    constexpr uint8 kMaxNumIvs = 10;
+    if (replaced && numIVs < kMaxNumIvs) {
+      auto tmpSet = *set;
+      tmpSet.cost = curCost;
+      for (auto &it : curChange) {
+        tmpSet.chosenCands[it.first->GetID()] = it.second;
+      }
+      tmpSet.candCount = tmpCandCount;
+      TryReplaceWithCand(tmpSet, *cand, curChange);
+      curCost = tmpSet.cost;
+      curInitDepth = 0;
+      for (auto &tmpCand : data->cands) {
+        if (tmpSet.candCount[tmpCand->GetID()] != 0) {
+          bestInitDepth += tmpCand->iv->base->GetDepth();
+        }
+      }
+    }
+    if (curCost < bestCost || (curCost == bestCost && curInitDepth < bestInitDepth)) {
+      bestCost = curCost;
+      bestChange = curChange;
+    }
+  }
+  if (bestCost == set->cost) {
+    return false;
+  }
+  set->cost = bestCost;
+  for (auto &it : bestChange) {
+    ++set->candCount[it.second->GetID()];
+    --set->candCount[set->chosenCands[it.first->GetID()]->GetID()];
+    set->chosenCands[it.first->GetID()] = it.second;
+  }
+  return true;
+}
+
+void IVOptimizer::TryOptimize(bool originFirst) {
+  InitSet(originFirst);
+  if (data->set != nullptr) {
+    if (dumpDetail) {
+      LogInfo::MapleLogger() << std::endl << "||||Initial Set||||" << std::endl;
+      DumpSet(*data->set);
+    }
+    while (OptimizeSet()) {
+      if (dumpDetail) {
+        LogInfo::MapleLogger() << std::endl << "||||Optimized Set||||" << std::endl;
+        DumpSet(*data->set);
+      }
+    }
+    // try eliminate cand by replacing it with other used cands
+    for (auto &cand : data->cands) {
+      if (data->set->candCount[cand->GetID()] >= 1) {
+        auto tmpSet = *data->set;
+        std::unordered_map<IVGroup*, IVCand*> tmpChange;
+        TryReplaceWithCand(tmpSet, *cand, tmpChange);
+        if (tmpSet.cost < data->set->cost) {
+          for (auto &it : tmpChange) {
+            ++data->set->candCount[it.second->GetID()];
+            --data->set->candCount[data->set->chosenCands[it.first->GetID()]->GetID()];
+            data->set->chosenCands[it.first->GetID()] = it.second;
+          }
+        }
+      }
+    }
+    if (dumpDetail) {
+      LogInfo::MapleLogger() << std::endl << "||||Optimized Set||||" << std::endl;
+      DumpSet(*data->set);
+    }
+  }
+}
+
+void IVOptimizer::FindCandSet() {
+  // first time start from origin iv
+  TryOptimize(true);
+  auto firstSet = std::move(data->set);
+
+  // second time start from chosen iv
+  TryOptimize(false);
+  auto secondSet = std::move(data->set);
+  if (firstSet == nullptr && secondSet == nullptr) {
+  } else if (firstSet == nullptr) {
+    data->set = std::move(secondSet);
+  } else if (secondSet == nullptr) {
+    data->set = std::move(firstSet);
+  } else {
+    if (firstSet->cost > secondSet->cost) {
+      data->set = std::move(secondSet);
+    } else {
+      data->set = std::move(firstSet);
+    }
+  }
+}
+
+bool IVOptimizer::IsReplaceSameOst(const MeExpr *parent, ScalarMeExpr *target) {
+  switch (parent->GetMeOp()) {
+    case kMeOpReg:
+    case kMeOpVar:
+      return static_cast<const ScalarMeExpr*>(parent)->GetOstIdx() == target->GetOstIdx();
+    default: {
+      for (uint32 i = 0; i < parent->GetNumOpnds(); ++i) {
+        auto *opnd = parent->GetOpnd(i);
+        if (IsReplaceSameOst(opnd, target)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+}
+
+MeStmt *IVOptimizer::GetIncPos() {
+  auto *latchBB = data->currLoop->latch;
+  MeStmt *incPos = latchBB->GetLastMe();
+  while (incPos != nullptr && (incPos->GetOp() == OP_comment || incPos->GetOp() == OP_goto)) {
+    incPos = incPos->GetPrev();
+  }
+  bool headQuicklyExit = data->currLoop->inloopBB2exitBBs.find(data->currLoop->head->GetBBId()) !=
+                         data->currLoop->inloopBB2exitBBs.end();
+  if (headQuicklyExit) {
+    auto *headFirst = data->currLoop->head->GetFirstMe();
+    while (headFirst != nullptr && headFirst->GetOp() == OP_comment) {
+      headFirst = headFirst->GetNext();
+    }
+    if (headFirst == nullptr || !headFirst->IsCondBr()) {
+      headQuicklyExit = false;
+    }
+  }
+  // cross the empty and try to find the real pos
+  if (incPos == nullptr && latchBB->GetPred().size() == 1 && !headQuicklyExit) {
+    auto *pred = latchBB->GetPred(0);
+    MeStmt *lastMe = nullptr;
+    while (pred != nullptr) {
+      bool predIsExit = data->currLoop->inloopBB2exitBBs.find(pred->GetBBId()) !=
+                        data->currLoop->inloopBB2exitBBs.end();
+      if (pred->GetSucc().size() > 1 && !predIsExit) {
+        break;
+      }
+      lastMe = pred->GetLastMe();
+      while (lastMe != nullptr && (lastMe->GetOp() == OP_comment || lastMe->GetOp() == OP_goto)) {
+        lastMe = lastMe->GetPrev();
+      }
+      if (lastMe == nullptr) {
+        if (pred->GetPred().size() > 1 || pred->GetSucc().size() > 1) {
+          break;
+        }
+        pred = pred->GetPred(0);
+        continue;
+      }
+      break;
+    }
+    incPos = lastMe;
+  }
+  return incPos;
+}
+
+MeExpr *IVOptimizer::GetInvariant(MeExpr *expr) {
+  auto *preheaderLast = data->currLoop->preheader->GetLastMe();
+  while (preheaderLast != nullptr && (preheaderLast->GetOp() == OP_comment || preheaderLast->GetOp() == OP_goto)) {
+    preheaderLast = preheaderLast->GetPrev();
+  }
+  if (invariables.find(expr->GetExprID()) == invariables.end()) {
+    if (expr->GetMeOp() != kMeOpConst) {
+      auto *extraReg = irMap->CreateRegMeExpr(expr->GetPrimType());
+      auto *assign = irMap->CreateAssignMeStmt(*extraReg, *expr, *data->currLoop->preheader);
+      if (preheaderLast == nullptr) {
+        data->currLoop->preheader->AddMeStmtFirst(assign);
+      } else {
+        preheaderLast->GetBB()->InsertMeStmtAfter(preheaderLast, assign);
+      }
+      invariables.emplace(expr->GetExprID(), extraReg);
+      return extraReg;
+    }
+  } else {
+    return invariables[expr->GetExprID()];
+  }
+  return expr;
+}
+
+MeExpr *IVOptimizer::ReplaceCompareOpnd(const OpMeExpr &cmp, MeExpr *compared, MeExpr *replace) {
+  OpMeExpr newOpExpr(cmp, kInvalidExprID);
+  for (size_t i = 0; i < newOpExpr.GetNumOpnds(); i++) {
+    if (newOpExpr.GetOpnd(i) == compared) {
+      newOpExpr.SetOpnd(i, replace);
+    }
+  }
+  return irMap->HashMeExpr(newOpExpr);
+}
+
+bool IVOptimizer::PrepareCompareUse(int64 &ratio, IVUse *use, IVCand *cand, MeStmt *incPos,
+                                    MeExpr *&extraExpr, MeExpr *&replace) {
+  bool replaced = true;
+  bool replaceCompare = false;
+  MeExpr *simplified = nullptr;
+  if (IsSignedInteger(static_cast<OpMeExpr*>(use->expr)->GetOpndType())) {
+    static_cast<OpMeExpr*>(use->expr)->SetOpndType(GetSignedPrimType(cand->iv->expr->GetPrimType()));
+  }
+  ratio = ComputeRatioOfStep(*cand->iv->step, *use->iv->step);
+  if (ratio == 0) {
+    ratio = ComputeRatioOfStep(*use->iv->step, *cand->iv->step);
+    // swap comparison if ratio is negative
+    if (ratio < 0) {
+      OpMeExpr newOpExpr(static_cast<OpMeExpr&>(*use->expr), kInvalidExprID);
+      auto op = newOpExpr.GetOp();
+      CHECK_FATAL(IsCompareHasReverseOp(op), "should be known op!");
+      auto newOp = GetSwapCmpOp(op);
+      newOpExpr.SetOp(newOp);
+      auto *hashed = irMap->HashMeExpr(newOpExpr);
+      (void)irMap->ReplaceMeExprStmt(*use->stmt, *use->expr, *hashed);
+      use->expr = hashed;
+    }
+    // compute extra expr after replaced by new iv
+    if (incPos != nullptr && incPos->IsCondBr() && use->stmt == incPos) {
+      // use inc version to replace
+      auto *newBase = irMap->CreateMeExprBinary(OP_add, cand->iv->base->GetPrimType(),
+                                                *cand->iv->base, *cand->iv->step);
+      extraExpr = ComputeExtraExprOfBase(*use->iv->base, *newBase, static_cast<uint64>(ratio), replaced);
+      auto *tmp = irMap->ReplaceMeExprExpr(*use->expr, *use->iv->expr, *cand->incVersion);
+      (void)irMap->ReplaceMeExprStmt(*use->stmt, *use->expr, *tmp);
+      use->expr = tmp;
+    } else {
+      extraExpr = ComputeExtraExprOfBase(*use->iv->base, *cand->iv->base, static_cast<uint64>(ratio), replaced);
+      auto *tmp = irMap->ReplaceMeExprExpr(*use->expr, *use->iv->expr, *replace);
+      (void)irMap->ReplaceMeExprStmt(*use->stmt, *use->expr, *tmp);
+      use->expr = tmp;
+    }
+    replace = use->comparedExpr;
+    replaceCompare = true;
+  } else {
+    bool mayOverflow = true;
+    if (incPos != nullptr && incPos->IsCondBr() && use->stmt == incPos) {
+      // use inc version to replace
+      auto *newBase = irMap->CreateMeExprBinary(OP_add, cand->iv->base->GetPrimType(),
+                                                *cand->iv->base, *cand->iv->step);
+      extraExpr = ComputeExtraExprOfBase(*newBase, *use->iv->base, static_cast<uint64>(ratio), replaced);
+      replace = cand->incVersion;
+    } else {
+      extraExpr = ComputeExtraExprOfBase(*cand->iv->base, *use->iv->base, static_cast<uint64>(ratio), replaced);
+    }
+    // move extra computation to comparedExpr
+    if (extraExpr != nullptr) {
+      if (data->realIterNum == -1) {
+        mayOverflow = true;
+      } else {
+        mayOverflow = CheckOverflow(use->comparedExpr, extraExpr, OP_sub,
+                                    extraExpr->GetPrimType());
+        if (!mayOverflow) {
+          auto *candBase = cand->iv->base;
+          auto *candStep = cand->iv->step;
+          auto *tmp = irMap->CreateMeExprBinary(OP_mul, candStep->GetPrimType(), *candStep,
+              *irMap->CreateIntConstMeExpr(static_cast<int64>(data->realIterNum), candStep->GetPrimType()));
+          simplified = irMap->SimplifyMeExpr(tmp);
+          tmp = simplified == nullptr ? tmp : simplified;
+          mayOverflow = CheckOverflow(candBase, tmp, OP_add, tmp->GetPrimType()) ||
+                        CheckOverflow(candBase, extraExpr, OP_add, extraExpr->GetPrimType()) ||
+                        CheckOverflow(tmp, extraExpr, OP_add, extraExpr->GetPrimType());
+        }
+      }
+    }
+    if (static_cast<OpMeExpr*>(use->expr)->GetOp() == OP_eq ||
+        static_cast<OpMeExpr*>(use->expr)->GetOp() == OP_ne ||
+        !mayOverflow) {
+      if (extraExpr != nullptr) {
+        auto *comparedExpr = use->comparedExpr;
+        if (NeedCvtOrRetype(extraExpr->GetPrimType(), comparedExpr->GetPrimType())) {
+          comparedExpr = irMap->CreateMeExprTypeCvt(extraExpr->GetPrimType(),
+                                                    comparedExpr->GetPrimType(), *comparedExpr);
+        }
+        extraExpr = irMap->CreateMeExprBinary(OP_sub, extraExpr->GetPrimType(),
+                                              *comparedExpr, *extraExpr);
+        if (extraExpr->GetPrimType() != static_cast<OpMeExpr*>(use->expr)->GetOpndType()) {
+          extraExpr = irMap->CreateMeExprTypeCvt(static_cast<OpMeExpr*>(use->expr)->GetOpndType(),
+                                                 extraExpr->GetPrimType(), *extraExpr);
+        }
+        simplified = irMap->SimplifyMeExpr(extraExpr);
+        if (simplified != nullptr) { extraExpr = simplified; }
+        extraExpr = GetInvariant(extraExpr);
+        if (ratio == -1) {
+          // swap comparison
+          OpMeExpr newOpExpr(static_cast<OpMeExpr&>(*use->expr), kInvalidExprID);
+          auto op = newOpExpr.GetOp();
+          CHECK_FATAL(IsCompareHasReverseOp(op), "should be known op!");
+          auto newOp = GetSwapCmpOp(op);
+          newOpExpr.SetOp(newOp);
+          auto *hashed = irMap->HashMeExpr(newOpExpr);
+          (void)irMap->ReplaceMeExprStmt(*use->stmt, *use->expr, *hashed);
+          use->expr = hashed;
+          extraExpr = irMap->CreateMeExprBinary(OP_mul, extraExpr->GetPrimType(), *extraExpr,
+                                                *irMap->CreateIntConstMeExpr(-1, extraExpr->GetPrimType()));
+          ratio = 1;
+          simplified = irMap->SimplifyMeExpr(extraExpr);
+          if (simplified != nullptr) { extraExpr = simplified; }
+        }
+        extraExpr = GetInvariant(extraExpr);
+        auto *newCmp = ReplaceCompareOpnd(static_cast<OpMeExpr&>(*use->expr), use->comparedExpr, extraExpr);
+        (void)irMap->ReplaceMeExprStmt(*use->stmt, *use->expr, *newCmp);
+        use->expr = newCmp;
+        use->comparedExpr = extraExpr;
+        extraExpr = nullptr;
+      }
+    }
+    if (use->comparedExpr->GetPrimType() != static_cast<OpMeExpr*>(use->expr)->GetOpndType()) {
+      auto *cvt = irMap->CreateMeExprTypeCvt(static_cast<OpMeExpr*>(use->expr)->GetOpndType(),
+                                             use->comparedExpr->GetPrimType(), *use->comparedExpr);
+      cvt = GetInvariant(cvt);
+      auto *newCmp = ReplaceCompareOpnd(static_cast<OpMeExpr&>(*use->expr), use->comparedExpr, cvt);
+      (void)irMap->ReplaceMeExprStmt(*use->stmt, *use->expr, *newCmp);
+      use->expr = newCmp;
+      use->comparedExpr = cvt;
+    }
+  }
+  ASSERT(replaced, "use should be able to be replaced");
+  return replaceCompare;
+}
+
+MeExpr *IVOptimizer::GenerateRealReplace(int64 ratio, MeExpr *extraExpr, MeExpr *replace, PrimType realUseType,
+                                         bool replaceCompare) {
+  MeExpr *simplified = nullptr;
+  if (ratio == 1 && extraExpr == nullptr) {
+  } else if (ratio == 1) {
+    replace = irMap->CreateMeExprBinary(OP_add, realUseType, *extraExpr, *replace);
+    simplified = irMap->SimplifyMeExpr(replace);
+    if (simplified != nullptr) { replace = simplified; }
+  } else if (extraExpr == nullptr) {
+    replace = irMap->CreateMeExprBinary(OP_mul, realUseType,
+                                        *irMap->CreateIntConstMeExpr(ratio, replace->GetPrimType()), *replace);
+  } else {
+    replace = irMap->CreateMeExprBinary(OP_mul, realUseType, *replace,
+                                        *irMap->CreateIntConstMeExpr(ratio, replace->GetPrimType()));
+    if (replaceCompare && extraExpr->GetMeOp() == kMeOpReg) {
+      auto *regExtra = static_cast<RegMeExpr*>(extraExpr);
+      auto *def = regExtra->GetDefStmt();
+      if (def != nullptr && invariables.find(def->GetRHS()->GetExprID()) != invariables.end()) {
+        auto *tmpReplace = irMap->CreateMeExprBinary(OP_add, replace->GetPrimType(),
+                                                     *regExtra->GetDefStmt()->GetRHS(), *replace);
+        simplified = irMap->SimplifyMeExpr(tmpReplace);
+        if (simplified != nullptr) { tmpReplace = simplified; }
+        if (tmpReplace->GetDepth() <= regExtra->GetDefStmt()->GetRHS()->GetDepth()) {
+          return tmpReplace;
+        }
+      }
+    }
+    replace = irMap->CreateMeExprBinary(OP_add, replace->GetPrimType(), *extraExpr, *replace);
+    simplified = irMap->SimplifyMeExpr(replace);
+    if (simplified != nullptr) { replace = simplified; }
+  }
+  return replace;
+}
+
+void IVOptimizer::UseReplace() {
+  auto *latchBB = data->currLoop->latch;
+  auto *incPos = GetIncPos();
+
+  for (size_t i = 0; i < data->groups.size(); ++i) {
+    auto *group = data->groups[i].get();
+    auto *cand = data->set->chosenCands[i];
+    if (cand->incPos == kOriginal && cand->originTmp == nullptr) {
+      cand->originTmp = irMap->CreateRegMeExpr(cand->iv->expr->GetPrimType());
+      auto *tmpAssign = irMap->CreateAssignMeStmt(static_cast<ScalarMeExpr&>(*cand->originTmp),
+                                                  *cand->iv->expr, *data->currLoop->head);
+      data->currLoop->head->AddMeStmtFirst(tmpAssign);
+    }
+    // replace use
+    for (auto &use : group->uses) {
+      MeExpr *replace = cand->iv->expr;
+      if (cand->incPos == kOriginal) {
+        if (IsReplaceSameOst(use->expr, static_cast<ScalarMeExpr*>(cand->iv->expr)) &&
+            use->iv->step == cand->iv->step) {
+          // no need to replace original iv itself
+          continue;
+        }
+        replace = cand->originTmp;
+      }
+      bool replaceCompare = false;
+      int64 ratio = 0;
+      MeExpr *extraExpr = nullptr;
+      // preprocess use
+      if (group->type == kUseCompare) {
+        replaceCompare = PrepareCompareUse(ratio, use.get(), cand, incPos, extraExpr, replace);
+      } else {
+        bool replaced = true;
+        ratio = ComputeRatioOfStep(*cand->iv->step, *use->iv->step);
+        extraExpr = ComputeExtraExprOfBase(*cand->iv->base, *use->iv->base, static_cast<uint64>(ratio), replaced);
+        if (incPos != nullptr && incPos->IsCondBr() && use->stmt == incPos) {
+          if (extraExpr == nullptr || (extraExpr->IsLeaf() && extraExpr->GetMeOp() != kMeOpConst)) {
+            auto *tmpExpr = irMap->CreateRegMeExpr(use->expr->GetPrimType());
+            auto *assignStmt = irMap->CreateAssignMeStmt(*tmpExpr, *use->expr, *incPos->GetBB());
+            incPos->GetBB()->InsertMeStmtBefore(incPos, assignStmt);
+            (void)irMap->ReplaceMeExprStmt(*use->stmt, *use->expr, *tmpExpr);
+            use->stmt = assignStmt;
+          } else {
+            // use inc version to replace
+            auto *newBase = irMap->CreateMeExprBinary(OP_add, cand->iv->base->GetPrimType(),
+                                                      *cand->iv->base, *cand->iv->step);
+            extraExpr = ComputeExtraExprOfBase(*newBase, *use->iv->base, static_cast<uint64>(ratio), replaced);
+            replace = cand->incVersion;
+          }
+        }
+        ASSERT(replaced, "should have been replaced");
+      }
+      // confirm type consistent
+      MeExpr *simplified = nullptr;
+      auto realUseType = replace->GetPrimType();
+      if ((IsCompareHasReverseOp(use->expr->GetOp()) || use->expr->GetOp() == OP_retype) &&
+          static_cast<OpMeExpr*>(use->expr)->GetOpndType() != kPtyInvalid) {
+        realUseType = static_cast<OpMeExpr*>(use->expr)->GetOpndType();
+      } else if (GetPrimTypeSize(realUseType) > GetPrimTypeSize(use->iv->expr->GetPrimType())) {
+        realUseType = use->iv->expr->GetPrimType();
+      }
+      // Update real use type for vector intrinsicop
+      if (use->expr->GetOp() == OP_intrinsicop) {
+        auto *naryExpr = static_cast<NaryMeExpr*>(use->expr);
+        MIRIntrinsicID intrnID = naryExpr->GetIntrinsic();
+        IntrinDesc &intrinDesc = IntrinDesc::intrinTable[intrnID];
+        if (intrinDesc.IsVectorOp()) {
+          realUseType = use->iv->expr->GetPrimType();
+        }
+      }
+      if (extraExpr != nullptr) {
+        if (NeedCvtOrRetype(extraExpr->GetPrimType(), realUseType)) {
+          extraExpr = irMap->CreateMeExprTypeCvt(realUseType, extraExpr->GetPrimType(), *extraExpr);
+          simplified = irMap->SimplifyMeExpr(extraExpr);
+          if (simplified != nullptr) { extraExpr = simplified; }
+        }
+        extraExpr = GetInvariant(extraExpr);
+      }
+      if (NeedCvtOrRetype(replace->GetPrimType(), realUseType)) {
+        replace = irMap->CreateMeExprTypeCvt(realUseType, replace->GetPrimType(), *replace);
+        simplified = irMap->SimplifyMeExpr(replace);
+        if (simplified != nullptr) { replace = simplified; }
+      }
+      // compute real replace
+      replace = GenerateRealReplace(ratio, extraExpr, replace, realUseType, replaceCompare);
+      // do replace
+      if (replaceCompare) {
+        replace = GetInvariant(replace);
+        auto *newCmp = ReplaceCompareOpnd(static_cast<OpMeExpr&>(*use->expr), use->comparedExpr, replace);
+        (void)irMap->ReplaceMeExprStmt(*use->stmt, *use->expr, *newCmp);
+      } else {
+        replace = use->expr == use->iv->expr ? replace :
+            irMap->ReplaceMeExprExpr(*use->expr, *use->iv->expr, *replace);
+        (void)irMap->ReplaceMeExprStmt(*use->stmt, *use->expr, *replace);
+      }
+    }
+  }
+
+  auto *preheaderLast = data->currLoop->preheader->GetLastMe();
+  while (preheaderLast != nullptr && (preheaderLast->GetOp() == OP_comment || preheaderLast->GetOp() == OP_goto)) {
+    preheaderLast = preheaderLast->GetPrev();
+  }
+
+  for (auto &cand : data->cands) {
+    if (data->set->candCount[cand->GetID()] == 0 || cand->incPos == kOriginal) {
+      continue;
+    }
+    // add init
+    auto *initVersion = irMap->CreateRegMeExprVersion(static_cast<RegMeExpr &>(*cand->iv->expr));
+    auto *initStmt = irMap->CreateAssignMeStmt(static_cast<ScalarMeExpr &>(*initVersion), *cand->iv->base,
+                                               *data->currLoop->preheader);
+    if (preheaderLast == nullptr) {
+      data->currLoop->preheader->AddMeStmtLast(initStmt);
+    } else {
+      preheaderLast->GetBB()->InsertMeStmtAfter(preheaderLast, initStmt);
+    }
+    preheaderLast = initStmt;
+
+    // add inc
+    auto *latchVersion = static_cast<ScalarMeExpr*>(cand->incVersion);
+    auto *incStmt = irMap->CreateAssignMeStmt(*latchVersion,
+                                              *irMap->CreateMeExprBinary(OP_add, latchVersion->GetPrimType(),
+                                                                         *cand->iv->expr, *cand->iv->step),
+                                              *data->currLoop->preheader);
+    if (incPos == nullptr) {
+      latchBB->AddMeStmtFirst(incStmt);
+      incPos = incStmt;
+    } else if (incPos->IsCondBr()) {
+      incPos->GetBB()->InsertMeStmtBefore(incPos, incStmt);
+    } else {
+      incPos->GetBB()->InsertMeStmtAfter(incPos, incStmt);
+      incPos = incStmt;
+    }
+    auto *bb = incStmt->GetBB();
+    auto ostID = latchVersion->GetOstIdx();
+    MeSSAUpdate::InsertOstToSSACands(ostID, *bb, &ssaupdateCands);
+
+    // add phi
+    auto *headPhi = irMap->CreateMePhi(static_cast<ScalarMeExpr&>(*cand->iv->expr));
+    if (data->currLoop->preheader == data->currLoop->head->GetPred(0)) {
+      headPhi->GetOpnds().emplace_back(initVersion);
+      headPhi->GetOpnds().emplace_back(latchVersion);
+    } else {
+      headPhi->GetOpnds().emplace_back(latchVersion);
+      headPhi->GetOpnds().emplace_back(initVersion);
+    }
+    data->currLoop->head->GetMePhiList().emplace(initVersion->GetOstIdx(), headPhi);
+    headPhi->SetDefBB(data->currLoop->head);
+  }
+  // clean up the invariables
+  invariables.clear();
+}
+
+void IVOptimizer::ApplyOptimize() {
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "IVOpts's details of func: " << func.GetName() << std::endl
+                           << "Processing loop with preheader BB id: " << data->currLoop->preheader->GetBBId()
+                           << std::endl;
+    if (data->currLoop->inloopBB2exitBBs.size() == 1) {
+      auto *testStmt = cfg->GetBBFromID(data->currLoop->inloopBB2exitBBs.begin()->first)->GetLastMe();
+      while (testStmt != nullptr && !testStmt->IsCondBr()) {
+        testStmt = testStmt->GetPrev();
+      }
+      if (testStmt != nullptr) {
+        LogInfo::MapleLogger() << "    loop has single exit with cond ";
+        testStmt->Dump(irMap);
+        LogInfo::MapleLogger() << std::endl << std::endl;
+      }
+    }
+  }
+
+  // if there's call in loop, we need to consider the register pressure later,
+  // if the pressure is high, choose minimal ivs
+  if (!FindBasicIVs()) {
+    return;
+  }
+  // find general ivs
+  std::vector<bool> bbVisited(cfg->GetAllBBs().size(), false);
+  TraversalLoopBB(*data->currLoop->head, bbVisited);
+  invariables.clear();
+  if (data->groups.empty()) {
+    return;
+  }
+  // can merge groups with same base obj later
+  // too much uses in loop causes little opportunity but huge cost to optimize, just skip it
+  if (data->groups.size() >= kMaxUseCount) {
+    return;
+  }
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "||||Induction Variables||||" << std::endl;
+    for (auto &itIV : data->ivs) {
+      DumpIV(*itIV.second);
+    }
+    LogInfo::MapleLogger() << std::endl;
+
+    LogInfo::MapleLogger() << "||||Groups||||" << std::endl;
+    for (auto &group : data->groups) {
+      DumpGroup(*group);
+    }
+    LogInfo::MapleLogger() << std::endl;
+  }
+  // create candidates used to replace uses's ivs
+  CreateIVCandidate();
+  data->considerAll = data->cands.size() <= kMaxCandidatesPerGroup;
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "||||Candidates||||" << std::endl;
+    for (auto &cand : data->cands) {
+      DumpCand(*cand);
+    }
+    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << "Important Candidate:  ";
+    for (auto &cand : data->cands) {
+      if (cand->important) {
+        LogInfo::MapleLogger() << cand->GetID() << ", ";
+      }
+    }
+    LogInfo::MapleLogger() << std::endl << std::endl;
+    LogInfo::MapleLogger() << "Group , Related Cand :\n";
+    for (auto &group : data->groups) {
+      LogInfo::MapleLogger() << "  Group " << group->GetID() << ":\t";
+      for (auto candID : group->relatedCands) {
+        LogInfo::MapleLogger() << candID << ", ";
+      }
+      LogInfo::MapleLogger() << std::endl;
+    }
+    LogInfo::MapleLogger() << std::endl;
+  }
+
+  // compute cost model
+  ComputeCandCost();
+  ComputeGroupCost();
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "||||Cand Cost||||" << std::endl;
+    LogInfo::MapleLogger() << "  cand  cost" << std::endl;
+    for (auto &cand : data->cands) {
+      LogInfo::MapleLogger() << "  " << cand->GetID() << "    " << cand->cost << std::endl;
+    }
+    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << "||||Group-Candidate Cost||||" << std::endl;
+    for (auto &group : data->groups) {
+      LogInfo::MapleLogger() << "Group" << group->GetID() << ":\n";
+      LogInfo::MapleLogger() << "  cand  cost" << std::endl;
+      for (uint32 i = 0; i < group->candCosts.size(); ++i) {
+        if (group->candCosts[i] != kInfinityCost) {
+          LogInfo::MapleLogger() << "  " << i << "    " << group->candCosts[i] << std::endl;
+        }
+      }
+    }
+  }
+
+  FindCandSet();
+  if (data->set == nullptr) {
+    return;
+  }
+
+  optimized = true;
+  // replace uses with chosen ivs
+  UseReplace();
+}
+
+void IVOptimizer::Run() {
+  // prepare
+  useInfo = &irMap->GetExprUseInfo();
+  if (!useInfo->UseInfoOfScalarIsValid()) { // sink only depends on use info of scalar
+    useInfo->CollectUseInfoInFunc(irMap, dom, kUseInfoOfScalar);
+  }
+  for (int32 i = static_cast<int32>(loops->GetMeLoops().size()) - 1; i >= 0; i--) {
+    auto *loop = loops->GetMeLoops()[i];
+    if (loop->head == nullptr || loop->preheader == nullptr || loop->latch == nullptr) {
+      // not canonicalized
+      continue;
+    }
+    // remove redundant phi
+    for (auto &phi : loop->head->GetMePhiList()) {
+      for (uint32 k = 0; k < phi.second->GetOpnds().size(); ++k) {
+        auto *phiOpnd = phi.second->GetOpnd(k);
+        if (phiOpnd == phi.second->GetLHS()) {
+          // replace it by another opnd
+          (void)useInfo->ReplaceScalar(irMap, phiOpnd, phi.second->GetOpnd(1 - k));
+          phi.second->SetIsLive(false);
+        }
+      }
+    }
+  }
+  for (int32 i = static_cast<int32>(loops->GetMeLoops().size()) - 1; i >= 0; --i) {
+    auto *loop = loops->GetMeLoops()[i];
+    if (loop->head == nullptr || loop->preheader == nullptr || loop->latch == nullptr) {
+      // not canonicalized
+      continue;
+    }
+    constexpr uint32 kMaxLoopBBSize = 60;
+    if (loop->loopBBs.size() > kMaxLoopBBSize && loop->nestDepth > 0) {
+      // just skip now because we can hardly get register pressure
+      continue;
+    }
+    data = std::make_unique<IVOptData>();
+    data->currLoop = loop;
+    LoopScalarAnalysisResult sa(*irMap, data->currLoop);
+    uint64 tripCount = 0;
+    CRNode *conditionCRNode = nullptr;
+    CR *itCR = nullptr;
+    TripCountType type = sa.ComputeTripCount(func, tripCount, conditionCRNode, itCR);
+    if (type == kConstCR) {
+      data->iterNum = tripCount;
+      data->realIterNum = tripCount;
+    }
+    if ((loops->GetMeLoops().size() - static_cast<size_t>(i)) > MeOption::ivoptsLimit) {
+      break;
+    }
+    ApplyOptimize();
+  }
+  useInfo->InvalidUseInfo();
+  MeSSAUpdate ssaUpdate(func, *func.GetMeSSATab(), *dom, ssaupdateCands);
+  ssaUpdate.Run();
+}
+
+void MEIVOpts::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.AddRequired<MELoopCanon>();
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEAliasClass>();
+  aDep.SetPreservedAll();
+}
+
+bool MEIVOpts::PhaseRun(maple::MeFunction &f) {
+  if (!MeOption::ivopts) {
+    return false;
+  }
+  MeCFG *cfg = GET_ANALYSIS(MEMeCfg, f);
+  IdentifyLoops *meLoop = GET_ANALYSIS(MELoopAnalysis, f);
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  auto *pdom = EXEC_ANALYSIS(MEDominance, f)->GetPdomResult();
+  CHECK_NULL_FATAL(pdom);
+  auto *aliasClass = GET_ANALYSIS(MEAliasClass, f);
+  MeHDSE hdse(f, *dom, *pdom, *f.GetIRMap(), aliasClass, DEBUGFUNC_NEWPM(f));
+  // invoke hdse to update isLive only
+  hdse.InvokeHDSEUpdateLive();
+
+  IVOptimizer ivOptimizer(f, DEBUGFUNC_NEWPM(f), meLoop, dom);
+  if (DEBUGFUNC_NEWPM(f)) {
+    cfg->DumpToFile("beforeIVOpts", false);
+    f.Dump();
+  }
+  ivOptimizer.Run();
+  if (ivOptimizer.LoopOptimized()) {
+    // run hdse to remove unused exprs
+    auto *aliasClass0 = FORCE_GET(MEAliasClass);
+    MeHDSE hdse0(f, *dom, *pdom, *f.GetIRMap(), aliasClass0, DEBUGFUNC_NEWPM(f));
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "  == " << PhaseName() << " invokes [ " << hdse0.PhaseName() << " ] ==\n";
+    }
+    hdse0.DoHDSE();
+    if (hdse0.NeedUNClean()) {
+      f.GetCfg()->UnreachCodeAnalysis(true);
+    }
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_jump_threading.cpp b/src/mapleall/maple_me/src/me_jump_threading.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7233560d44e6d0c21d4db6a56c366edd67b297b6
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_jump_threading.cpp
@@ -0,0 +1,801 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_jump_threading.h"
+#include "me_value_range_prop.h"
+#include "me_dominance.h"
+#include "me_ssa_update.h"
+#include "me_phase_manager.h"
+
+namespace maple {
+constexpr size_t kNumOperands = 2;
+bool JumpThreading::isDebug = false;
+size_t JumpThreading::pathSize = 0;
+int64 JumpThreading::codeSizeOfCopy = 0;
+constexpr int64 kCodeSizeLimit = 10; // Copy up to 10 statements per path.
+constexpr size_t kLimitOfVisitedBB = 40; // A maximum of 40 bbs can be traversed when recursively finding a def point.
+constexpr size_t kLimitOfPathLength = 12; // The maximum length of each path is 12 bbs.
+constexpr size_t kLimitOfPathsSize = 20; // Each function can optimize up to 20 paths.
+constexpr int64 kModuleCodeSizeLimit = 155;
+constexpr size_t kLimitOfModulePathSize = 25;
+
+#define DEBUG_LOG() if (JumpThreading::isDebug)     \
+  LogInfo::MapleLogger()
+
+void JumpThreading::Execute() {
+  for (auto bIt = dom.GetReversePostOrder().begin(); bIt != dom.GetReversePostOrder().end(); ++bIt) {
+    auto bb = func.GetCfg()->GetBBFromID(BBId((*bIt)->GetID()));
+    switch (bb->GetKind()) {
+      case kBBCondGoto: {
+        DealWithCondGoto(*bb);
+        break;
+      }
+      case kBBSwitch: {
+        DealWithSwitch(*bb);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  DEBUG_LOG() << "=========dump path begin=========\n";
+  if (JumpThreading::isDebug) {
+    for (auto &pathTmp : paths) {
+      for (auto *bb : *pathTmp) {
+        DEBUG_LOG() << bb->GetBBId() << " ";
+      }
+      DEBUG_LOG() << "\n";
+    }
+  }
+  DEBUG_LOG() << "=========dump path end=========\n";
+  if (paths.empty()) {
+    return;
+  }
+  ExecuteJumpThreading();
+}
+
+// Insert the ost of phi opnds to their def bbs.
+void JumpThreading::InsertOstOfPhi2Cands(BB &bb, size_t i) {
+  for (auto &it : bb.GetMePhiList()) {
+    if (i >= it.second->GetOpnds().size()) {
+      break;
+    }
+    auto *opnd = it.second->GetOpnd(i);
+    MeStmt *stmt = nullptr;
+    auto *defBB = opnd->GetDefByBBMeStmt(*func.GetCfg(), stmt);
+    // At the time of optimizing redundant branches, when the all preds of condgoto BB can jump directly to
+    // the successors of condgoto BB and the conditional expr is only used for conditional stmt, after opt,
+    // the ssa of expr not need to be updated, otherwise the ssa of epr still needs to be updated.
+    MeSSAUpdate::InsertOstToSSACands(it.first, *defBB, &cands);
+  }
+}
+
+void JumpThreading::PrepareForSSAUpdateWhenPredBBIsRemoved(const BB &pred, BB &bb) {
+  int index = bb.GetPredIndex(pred);
+  CHECK_FATAL(index != -1, "pred is not in preds of bb");
+  InsertOstOfPhi2Cands(bb, static_cast<size_t>(static_cast<int64>(index)));
+  MeSSAUpdate::InsertDefPointsOfBBToSSACands(bb, cands);
+}
+
+BB *JumpThreading::CopyBB(BB &bb, bool copyWithoutLastStmt) {
+  // Each wont exit bb corresponds to an wont exit return bb,
+  // so when the bb to be copied is an wont exit bb, copy the bb.
+  bool isWontExitReturnBB = bb.GetAttributes(kBBAttrWontExit | kBBAttrIsExit) && bb.GetKind() == kBBReturn;
+  if (!isWontExitReturnBB && bb.GetMeStmts().empty()) {
+    return nullptr;
+  }
+  size_t numOfStmts = 0;
+  for (auto &stmt : bb.GetMeStmts()) {
+    if (stmt.GetOp() == OP_comment) {
+      continue;
+    }
+    numOfStmts++;
+  }
+  // Need not copy the condition stmt which would be jumped after opt.
+  if (!isWontExitReturnBB && (numOfStmts == 0 || (copyWithoutLastStmt && (numOfStmts == 1)))) {
+    return nullptr;
+  }
+  BB *newBB = func.GetCfg()->NewBasicBlock();
+  if (copyWithoutLastStmt) {
+    newBB->SetKind(kBBFallthru);
+  } else {
+    newBB->SetKind(bb.GetKind());
+  }
+  newBB->SetAttributes(bb.GetAttributes());
+  func.CloneBBMeStmts(bb, *newBB, &cands, copyWithoutLastStmt);
+  return newBB;
+}
+
+void JumpThreading::SetNewOffsetOfLastMeStmtForNewBB(const BB &oldBB, BB &newBB, const BB &oldSucc, BB &newSucc) {
+  switch (newBB.GetKind()) {
+    case kBBGoto: {
+      auto *oldLastMe = static_cast<const GotoMeStmt*>(oldBB.GetLastMe());
+      auto *newLastMe = static_cast<GotoMeStmt*>(newBB.GetLastMe());
+      if (oldLastMe->GetOffset() == oldSucc.GetBBLabel()) {
+        newLastMe->SetOffset(func.GetOrCreateBBLabel(newSucc));
+      }
+      break;
+    }
+    case kBBCondGoto: {
+      auto *oldLastMe = static_cast<const CondGotoMeStmt*>(oldBB.GetLastMe());
+      auto *newLastMe = static_cast<CondGotoMeStmt*>(newBB.GetLastMe());
+      if (oldLastMe->GetOffset() == oldSucc.GetBBLabel()) {
+        newLastMe->SetOffset(func.GetOrCreateBBLabel(newSucc));
+      }
+      break;
+    }
+    case kBBSwitch: {
+      auto *oldLastMe = static_cast<const SwitchMeStmt*>(oldBB.GetLastMe());
+      auto *newLastMe = static_cast<SwitchMeStmt*>(newBB.GetLastMe());
+      if (oldLastMe->GetDefaultLabel() == oldSucc.GetBBLabel()) {
+        newLastMe->SetDefaultLabel(func.GetOrCreateBBLabel(newSucc));
+      }
+      for (size_t i = 0; i < oldLastMe->GetSwitchTable().size(); ++i) {
+        LabelIdx labelIdx = oldLastMe->GetSwitchTable().at(i).second;
+        if (labelIdx == oldSucc.GetBBLabel()) {
+          newLastMe->SetCaseLabel(i, func.GetOrCreateBBLabel(newSucc));
+        }
+      }
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+
+void JumpThreading::ConnectNewPath(std::vector<BB*> &currPath, std::vector<std::pair<BB*, BB*>> &old2NewBB,
+    size_t thePosOfSec2LastBB) {
+  size_t idxOfCurrBB = 0;
+  auto *currentBB = currPath[0];
+  auto *currentSucc = currPath[1];
+  for (size_t i = 1; i < currPath.size(); ++i) {
+    auto *newSuccBB = old2NewBB[i].second;
+    if (newSuccBB == nullptr) {
+      continue;
+    }
+    if (idxOfCurrBB == thePosOfSec2LastBB) {
+      old2NewBB[idxOfCurrBB].second->AddSucc(*newSuccBB);
+      if (func.GetCfg()->UpdateCFGFreq()) {
+        uint64 freqUsed = old2NewBB[idxOfCurrBB].second->GetFrequency();
+        old2NewBB[idxOfCurrBB].second->PushBackSuccFreq(freqUsed);
+        newSuccBB->SetFrequency(static_cast<uint32>(freqUsed));
+      }
+      break;
+    }
+    for (auto *temp : currentBB->GetSucc()) {
+      auto *newTemp = temp;
+      if (temp == currentSucc) {
+        // If the succ of currentBB is in path, replace it with the new copied bb.
+        // For example:
+        // Current path has bb0, bb2, bb4, bb5, when currentBB is bb2, and temp bb is bb4,
+        // need push the new copied bb of bb4 to the succs of bb2'(copied from bb2).
+        //  bb0  bb1
+        //    \ /
+        //    bb2
+        //    / \
+        //  bb3 bb4
+        //        \
+        //        bb5
+        newTemp = newSuccBB;
+        if (currentBB == old2NewBB[idxOfCurrBB].second) {
+          currentBB->ReplaceSucc(temp, newTemp, true);
+          if (func.GetCfg()->UpdateCFGFreq()) {
+            int idxInSucc = currentBB->GetSuccIndex(*newTemp);
+            CHECK_FATAL(idxInSucc != -1, "idxInSucc can not be -1");
+            newTemp->SetFrequency(currentBB->GetSuccFreq()[static_cast<uint32>(idxInSucc)]);
+          }
+        } else {
+          old2NewBB[idxOfCurrBB].second->AddSucc(*newTemp);
+          if (func.GetCfg()->UpdateCFGFreq()) {
+            old2NewBB[idxOfCurrBB].second->PushBackSuccFreq(0);
+            newTemp->SetFrequency(0);
+          }
+        }
+      } else if (currentBB != old2NewBB[idxOfCurrBB].second) {
+        // Deal with the case like the succ of currentBB is not in path.
+        for (size_t idx = 0; idx < newTemp->GetPred().size(); ++idx) {
+          InsertOstOfPhi2Cands(*newTemp, idx);
+        }
+        // Push the temp to the succ of new copied bb of currentBB.
+        if (currentBB->GetKind() == kBBGoto && currentBB->GetAttributes(kBBAttrWontExit) &&
+            currentBB->GetSuccIndex(*newTemp) == 1 && newTemp->GetAttributes(kBBAttrIsExit)) {
+          BB *newWontExitBB = CopyBB(*newTemp);
+          old2NewBB[idxOfCurrBB].second->AddSucc(*newWontExitBB);
+          func.GetCfg()->GetCommonExitBB()->GetPred().push_back(newWontExitBB);
+        } else {
+          old2NewBB[idxOfCurrBB].second->AddSucc(*newTemp);
+        }
+        if (func.GetCfg()->UpdateCFGFreq()) {
+          old2NewBB[idxOfCurrBB].second->PushBackSuccFreq(newTemp->GetFrequency());
+        }
+      }
+      // Set label for new bb.
+      SetNewOffsetOfLastMeStmtForNewBB(*currentBB, *old2NewBB[idxOfCurrBB].second, *temp, *newTemp);
+    }
+    idxOfCurrBB = i;
+    currentBB = currPath[i];
+    currentSucc = currPath[i + 1];
+  }
+}
+
+void JumpThreading::CopyAndConnectPath(std::vector<BB*> &currPath) {
+  auto length = currPath.size();
+  size_t thePosOfSec2LastBB = length - 2; // The position of second to last bb.
+  std::vector<std::pair<BB*, BB*>> old2NewBB;
+  (void)old2NewBB.emplace_back(currPath[0], currPath[0]); // The first bb need not to be copied.
+  DEBUG_LOG() << "old: " << currPath[0]->GetBBId() << " new: " << currPath[0]->GetBBId() << "\n";
+  for (size_t i = 1; i < length; ++i) {
+    PrepareForSSAUpdateWhenPredBBIsRemoved(*currPath[i - 1], *currPath[i]);
+    if (i == length - 1) {
+      // Need not copy the target bb.
+      break;
+    }
+    auto *oldBB = currPath[i];
+    auto *newBB = (i == thePosOfSec2LastBB) ? CopyBB(*oldBB, true) : CopyBB(*oldBB);
+    old2NewBB.push_back(std::make_pair(oldBB, newBB));
+    if (newBB == nullptr) {
+      DEBUG_LOG() << "old: " << oldBB->GetBBId() << " new: nullptr\n";
+    } else {
+      DEBUG_LOG() << "old: " << oldBB->GetBBId() << " new: " << newBB->GetBBId() << "\n";
+    }
+  }
+  (void)old2NewBB.emplace_back(currPath[length - 1], currPath[length - 1]); // The last bb need not to be copied.
+  DEBUG_LOG() << "old: " << currPath[length - 1]->GetBBId() << " new: " << currPath[length - 1]->GetBBId() << "\n";
+  CHECK_FATAL(old2NewBB.size() == currPath.size(), "must be equal");
+  ConnectNewPath(currPath, old2NewBB, thePosOfSec2LastBB);
+}
+
+bool JumpThreading::TraverseBBsOfPath(std::vector<BB*> &currPath, int64 &currSize, bool &optSwitchBB,
+                                      bool &multiBranchInPath, bool &pathThroughLatch) {
+  auto thePositionOfThreadedBB = currPath.size() - 2; // The position of second to last bb.
+  auto *loop = loops->GetBBLoopParent(currPath[0]->GetBBId());
+  for (size_t i = 1; i < currPath.size() - 1; ++i) {
+    if (currPath[i]->GetKind() == kBBSwitch) {
+      if (i == thePositionOfThreadedBB) {
+        optSwitchBB = true;
+      } else {
+        multiBranchInPath = true;
+      }
+    }
+    if (i + 1 < currPath.size() && currPath[i]->GetSuccIndex(*currPath[i + 1]) == -1) {
+      DEBUG_LOG() << "The path is not connected.\n";
+      return false;
+    }
+    if (loop && loops->GetBBLoopParent(currPath[i]->GetBBId()) != loop) {
+      DEBUG_LOG() << "The path crosses loops.\n";
+      return false;
+    }
+    pathThroughLatch = (loop != nullptr && currPath[i] == loop->latch);
+    for (auto &stmt : currPath[i]->GetMeStmts()) {
+      if (i == thePositionOfThreadedBB && &stmt == currPath[i]->GetLastMe()) {
+        // Need not copy the condition stmt of second to last bb.
+        break;
+      }
+      if (!IsSupportedOpForCopyInPhasesLoopUnrollAndVRP(stmt.GetOp(), true)) {
+        DEBUG_LOG() << "Is not supported op for copy.\n";
+        return false;
+      }
+      if (stmt.GetOp() == OP_comment) {
+        continue;
+      }
+      currSize += stmtCostAnalyzer.GetMeStmtCost(&stmt) / static_cast<int64>(kSizeScale);
+      if (JumpThreading::isDebug) {
+        stmt.Dump(func.GetIRMap());
+      }
+    }
+  }
+  return true;
+}
+
+// Check whether the path to be optimized is connected and whether the code size after opt is less than threshold.
+bool JumpThreading::PreCopyAndConnectPath(std::vector<BB*> &currPath) {
+  bool multiBranchInPath = false;
+  bool optSwitchBB = false;
+  int64 currSize = 0;
+  bool pathThroughLatch = false;
+  auto *loop = loops->GetBBLoopParent(currPath[0]->GetBBId());
+  if (!TraverseBBsOfPath(currPath, currSize, optSwitchBB, multiBranchInPath, pathThroughLatch)) {
+    return false;
+  }
+  if (multiBranchInPath && !optSwitchBB) {
+    DEBUG_LOG() << "The threaded bb is not switch bb and the path has switch bb.\n";
+    return false;
+  }
+  bool createsIrreducibleLoop = (pathThroughLatch && !dom.Dominate(*currPath.back(), *loop->latch));
+  DEBUG_LOG() << "currStmtSize currPathSize: " << currSize << " " << currPath.size() << "\n";
+  if (!optSwitchBB && createsIrreducibleLoop && (static_cast<uint64>(currSize) > currPath.size())) {
+    DEBUG_LOG() << "In order to control the code size, each bb only can copy one stmt on average.\n";
+    return false;
+  }
+  if (!(multiBranchInPath && optSwitchBB) && currSize > 10) {
+    DEBUG_LOG() << "In order to control the code size of common thread jump, the limit of stmt size is 10.\n";
+    return false;
+  }
+  auto codeSizeLimit = MeOption::optForSize ? 0 : kCodeSizeLimit;
+  if (currSize > codeSizeLimit || static_cast<uint64>(currSize) > currPath.size() * kNumOperands ||
+      codeSizeOfCopy + currSize > kModuleCodeSizeLimit) {
+    DEBUG_LOG() << "Code size "<< currSize << "is greater than threshold\n";
+    return false;
+  }
+  codeSizeOfCopy += currSize;
+  DEBUG_LOG() << codeSizeOfCopy << "\n";
+  return true;
+}
+
+void JumpThreading::ExecuteJumpThreading() {
+  std::vector<bool> startBBs(func.GetCfg()->GetAllBBs().size());
+  DEBUG_LOG() << "***************" << func.GetName() << " " << paths.size() << "***************" << "\n";
+  for (size_t i = 0; i < paths.size(); ++i) {
+    DEBUG_LOG() << "================" << i << "================" << "\n";
+    auto *currPath = paths[i].get();
+    if (startBBs[currPath->at(0)->GetBBId()]) {
+      // If the start bb of current path has already jumped, do nothing.
+      continue;
+    }
+    if (currPath->size() <= 2 || currPath->size() > kLimitOfPathLength) {
+      // The current path must have more than one bb.
+      // If current path only has two bbs, has been optimized in vrp phase now.
+      continue;
+    }
+    if (i > kLimitOfPathsSize || pathSize > kLimitOfModulePathSize) {
+      return;
+    }
+    if (!PreCopyAndConnectPath(*currPath)) {
+      DEBUG_LOG() << "Can not jump thread with this path\n";
+      continue;
+    }
+    isCFGChange = true;
+    DEBUG_LOG() << "============path " << i << "begin\n";
+    CopyAndConnectPath(*currPath);
+    if (JumpThreading::isDebug) {
+      func.GetCfg()->DumpToFile(
+          "jump-threading-after" + std::to_string(func.jumpThreadingRuns) + "_" + std::to_string(i));
+    }
+    startBBs[currPath->at(0)->GetBBId()] = true;
+    DEBUG_LOG() << "============path " << i << "end\n";
+    ++pathSize;
+  }
+}
+
+// Find sub path from the use of a1 in bb3 to the def of a1 in bb0, and push it to the path.
+//     bb0 a1 = 1
+//      |
+// bb1  bb2
+//  \  /
+//  bb3 a2 = phi(a0, a1)
+//   |
+//  bb4 if a2 < 0
+//  / \
+// b5 b6
+bool JumpThreading::FindSubPathFromUseToDefOfExpr(
+    BB &defBB, BB &useBB, std::vector<BB*> &subPath, std::set<BB*> &visited) {
+  auto *loop = loops->GetBBLoopParent(defBB.GetBBId());
+  if (loop != nullptr) {
+    if (currLoop != nullptr && loop != currLoop) {
+      return false; // Only support walk through one loop.
+    }
+    currLoop = loop;
+  }
+  if (&defBB == &useBB) {
+    return true;
+  }
+  if (visited.insert(&defBB).second) {
+    for (auto &succ : defBB.GetSucc()) {
+      if (FindSubPathFromUseToDefOfExpr(*succ, useBB, subPath, visited)) {
+        subPath.push_back(&defBB);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool JumpThreading::PushSubPath2Path(BB &defBB, BB &useBB, size_t &lengthOfSubPath) {
+  size_t countOfSubPath = 0;
+  std::vector<BB*> subPath;
+  for (auto &pred : useBB.GetPred()) {
+    std::set<BB*> visited;
+    subPath.push_back(&useBB);
+    subPath.push_back(pred);
+    if (FindSubPathFromUseToDefOfExpr(defBB, *pred, subPath, visited)) {
+      ++countOfSubPath;
+    }
+    if (countOfSubPath > 1) {
+      return false;
+    }
+  }
+  if (countOfSubPath == 0) {
+    return false;
+  }
+  if (!subPath.empty()) {
+    subPath.pop_back();
+  }
+  (void)path->insert(path->end(), subPath.begin(), subPath.end());
+  lengthOfSubPath = subPath.size();
+  return true;
+}
+
+void JumpThreading::ResizePath(size_t lengthOfSubPath) {
+  while (lengthOfSubPath != 0) {
+    path->pop_back();
+    lengthOfSubPath--;
+  }
+}
+
+void JumpThreading::RegisterPath(BB &srcBB, BB &dstBB) {
+  std::unique_ptr<std::vector<BB*>> pathTemp = std::make_unique<std::vector<BB*>>();
+  pathTemp->push_back(&srcBB);
+  (void)pathTemp->insert(pathTemp->end(), path->rbegin(), path->rend());
+
+  pathTemp->push_back(&dstBB);
+  paths.push_back(std::move(pathTemp));
+}
+
+// Judge whether the value range meets the conditions.
+bool JumpThreading::CanJump2SuccOfCurrBB(
+    BB &bb, ValueRange *vrOfOpnd0, ValueRange *vrOfOpnd1, BB &toBeJumpedBB, Opcode op) {
+  if (vrOfOpnd0 == nullptr || vrOfOpnd1 == nullptr) {
+    return false;
+  }
+  if (currBB->GetKind() != kBBCondGoto && currBB->GetKind() != kBBSwitch) {
+    return false;
+  }
+  ASSERT_NOT_NULL(currBB->GetLastMe());
+  auto pType = (currBB->GetKind() == kBBCondGoto && currBB->GetLastMe()->GetOpnd(0)->GetMeOp() == kMeOpOp) ?
+      static_cast<OpMeExpr*>(currBB->GetLastMe()->GetOpnd(0))->GetOpndType() :
+      currBB->GetLastMe()->GetOpnd(0)->GetPrimType();
+  if (!valueRanges.BrStmtInRange(bb, *vrOfOpnd0, *vrOfOpnd1, op, pType)) {
+    return false;
+  }
+  RegisterPath(bb, toBeJumpedBB);
+  return true;
+}
+
+bool JumpThreading::CanJumpThreadingWithCondGoto(BB &bb, MeExpr *opnd, ValueRange *vrOfOpnd0) {
+  auto vrpOfEqualZero = valueRanges.CreateTempValueRangeOfEqualZero(PTY_u1);
+  auto *vrOfOpnd1 = (opnd == nullptr) ? &vrpOfEqualZero : valueRanges.FindValueRangeAndInitNumOfRecursion(bb, *opnd);
+  ASSERT_NOT_NULL(currBB->GetLastMe());
+  auto op = opnd == nullptr ? OP_ne : currBB->GetLastMe()->GetOpnd(0)->GetOp();
+  if (vrOfOpnd0 != nullptr && vrOfOpnd1 != nullptr) {
+    BB *trueBranch = nullptr;
+    BB *falseBranch = nullptr;
+    currBB->GetTrueAndFalseBranch(
+        static_cast<CondGotoMeStmt*>(currBB->GetLastMe())->GetOp(), trueBranch, falseBranch);
+    if (CanJump2SuccOfCurrBB(bb, vrOfOpnd0, vrOfOpnd1, *trueBranch, op)) {
+      return true;
+    } else if (CanJump2SuccOfCurrBB(bb, vrOfOpnd0, vrOfOpnd1, *falseBranch, GetReverseCmpOp(op))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool JumpThreading::CanJumpThreadingWithSwitch(BB &bb, ValueRange *vrOfOpnd0) {
+  if (vrOfOpnd0 == nullptr || currBB->GetLastMe()->GetOp() != OP_switch) {
+    return false;
+  }
+  auto *switchMeStmt = static_cast<SwitchMeStmt*>(currBB->GetLastMe());
+  ASSERT_NOT_NULL(switchMeStmt);
+  auto *opnd = switchMeStmt->GetOpnd();
+  auto *defalutBB = func.GetCfg()->GetLabelBBAt(switchMeStmt->GetDefaultLabel());
+  for (auto &succ : currBB->GetSucc()) {
+    if (succ == defalutBB) {
+      continue;
+    }
+    auto *vrOfCurrCase = valueRanges.FindValueRangeAndInitNumOfRecursion(*succ, *opnd);
+    if (CanJump2SuccOfCurrBB(bb, vrOfOpnd0, vrOfCurrCase, *succ, OP_eq)) {
+      return true;
+    }
+  }
+  if (defalutBB == nullptr) {
+    return false;
+  }
+  if (vrOfOpnd0->IsConstantLowerAndUpper() && vrOfOpnd0->GetRangeType() == kEqual) {
+    RegisterPath(bb, *defalutBB);
+    return true;
+  }
+  return false;
+}
+
+// Judge whether the value range meets the conditions.
+bool JumpThreading::CanJumpThreading(BB &bb, MeExpr &opnd0, MeExpr *opnd1) {
+  if (currBB->GetKind() != kBBSwitch && currBB->GetKind() != kBBCondGoto) {
+    return false;
+  }
+  auto *vrOfOpnd0 = valueRanges.FindValueRangeAndInitNumOfRecursion(bb, opnd0);
+  std::unique_ptr<ValueRange> uniquePtrOfOpnd0 = nullptr;
+  if (vrOfOpnd0 == nullptr && opnd0.GetMeOp() == kMeOpConst &&
+      static_cast<ConstMeExpr&>(opnd0).GetConstVal()->GetKind() == kConstInt) {
+    uniquePtrOfOpnd0 = std::make_unique<ValueRange>(Bound(static_cast<ConstMeExpr&>(opnd0).GetExtIntValue(),
+        opnd0.GetPrimType()), kEqual);
+    vrOfOpnd0 = uniquePtrOfOpnd0.get();
+  }
+  return (currBB->GetKind() == kBBCondGoto) ? CanJumpThreadingWithCondGoto(bb, opnd1, vrOfOpnd0) :
+      CanJumpThreadingWithSwitch(bb, vrOfOpnd0);
+}
+
+void JumpThreading::FindPathWhenDefPointInCurrBB(BB &defBB, BB &predBB, MeExpr &opnd0, MeExpr *opnd1) {
+  path->push_back(&defBB);
+  auto cmpOpnds = std::make_pair(&opnd0, opnd1);
+  FindPath(predBB, cmpOpnds);
+  path->pop_back();
+}
+
+void JumpThreading::FindPathWhenDefByIsNotStmtAndPhi(BB &defBB, BB &predBB, CompareOpnds &cmpOpnds) {
+  path->push_back(&predBB);
+  FindPath(defBB, cmpOpnds);
+  path->pop_back();
+}
+
+void JumpThreading::FindPathWhenDefPointIsNotInCurrBB(BB &defBB, BB &useBB, MeExpr &opnd0, MeExpr *opnd1) {
+  size_t lengthOfSubPath = 0;
+  if (!PushSubPath2Path(defBB, useBB, lengthOfSubPath)) {
+    return;
+  }
+  auto cmpOpnds = std::make_pair(&opnd0, opnd1);
+  FindPath(defBB, cmpOpnds);
+  ResizePath(lengthOfSubPath);
+}
+
+void JumpThreading::FindPathWhenDefByStmt(BB &useBB, CompareOpnds &cmpOpnds, bool theFirstCmpOpndIsDefByPhi) {
+  size_t lengthOfSubPath = 0;
+  auto *opnd = theFirstCmpOpndIsDefByPhi ? cmpOpnds.first : cmpOpnds.second;
+  if (!opnd->IsScalar() || static_cast<ScalarMeExpr*>(opnd)->GetDefBy() != kDefByStmt) {
+    return;
+  }
+  auto *scalar = static_cast<ScalarMeExpr*>(opnd);
+  auto *defBB = scalar->GetDefStmt()->GetBB();
+  if (defBB == &useBB) {
+    path->push_back(defBB);
+    auto newCmpOpnds = theFirstCmpOpndIsDefByPhi ? std::make_pair(scalar->GetDefStmt()->GetRHS(), cmpOpnds.second) :
+        std::make_pair(cmpOpnds.first, scalar->GetDefStmt()->GetRHS());
+    FindPath(*defBB, newCmpOpnds);
+    path->pop_back();
+    return;
+  }
+  if (!PushSubPath2Path(*defBB, useBB, lengthOfSubPath)) {
+    return;
+  }
+  auto newCmpOpnds = theFirstCmpOpndIsDefByPhi ? std::make_pair(scalar->GetDefStmt()->GetRHS(), cmpOpnds.second) :
+      std::make_pair(cmpOpnds.first, scalar->GetDefStmt()->GetRHS());
+  FindPath(*defBB, newCmpOpnds);
+  ResizePath(lengthOfSubPath);
+}
+
+void JumpThreading::FindPathFromUse2DefWhenOneOpndIsDefByPhi(BB &bb, BB &pred, CompareOpnds &cmpOpnds,
+    size_t i, bool theFirstCmpOpndIsDefByPhi) {
+  ScalarMeExpr *scalarMeExpr = theFirstCmpOpndIsDefByPhi ? static_cast<ScalarMeExpr*>(cmpOpnds.first) :
+      static_cast<ScalarMeExpr*>(cmpOpnds.second);
+  auto *defPhi = &scalarMeExpr->GetDefPhi();
+  auto *defBB = defPhi->GetDefBB();
+  if (defBB != &bb) {
+    FindPathWhenDefPointIsNotInCurrBB(*defBB, bb, *cmpOpnds.first, cmpOpnds.second);
+    return;
+  }
+  auto *opnd0 = theFirstCmpOpndIsDefByPhi ? defPhi->GetOpnd(i) : cmpOpnds.first;
+  if (theFirstCmpOpndIsDefByPhi && opnd0 == cmpOpnds.first) {
+    return;
+  }
+  auto *opnd1 = theFirstCmpOpndIsDefByPhi ? cmpOpnds.second : defPhi->GetOpnd(i);
+  if (!theFirstCmpOpndIsDefByPhi && opnd1->GetMeOp() != kMeOpConst && opnd1 == cmpOpnds.second) {
+    return;
+  }
+  if (opnd0 != nullptr && opnd1 != nullptr && opnd0->IsScalar() && opnd1->IsScalar()) {
+    MeStmt *defStmt0 = nullptr;
+    MeStmt *defStmt1 = nullptr;
+    auto *defBB0 = static_cast<ScalarMeExpr*>(opnd0)->GetDefByBBMeStmt(*func.GetCfg(), defStmt0);
+    auto *defBB1 = static_cast<ScalarMeExpr*>(opnd1)->GetDefByBBMeStmt(*func.GetCfg(), defStmt1);
+    if ((theFirstCmpOpndIsDefByPhi && !dom.Dominate(*defBB1, *defBB0)) ||
+        (!theFirstCmpOpndIsDefByPhi && !dom.Dominate(*defBB0, *defBB1))) {
+      // When recursively searching for the version of the value, the def points of two opnds must be dom each other.
+      // For example, when searching for the definition point of a1 in bb1, the def point of B1 is bb3,
+      // and bb3 does not dom bb1, so cannot continue to search upward.
+      //      bb0  bb1
+      //        \  /
+      //    bb2  bb3  a2 = phi(a0, a1), b1 = 0
+      //      \  /
+      //     condgoto a5 = phi(a4, a3), b3 = phi(b2, b1)
+      //       / \    if (a5 != b3)
+      //     bb5 bb6
+      return;
+    }
+  }
+  FindPathWhenDefPointInCurrBB(*defBB, pred, *opnd0, opnd1);
+}
+
+void JumpThreading::FindPathWithTwoOperandsAreScalarMeExpr(BB &bb, BB &pred, CompareOpnds &cmpOpnds, size_t i) {
+  auto *scalar0 = static_cast<ScalarMeExpr*>(cmpOpnds.first);
+  auto *scalar1 = static_cast<ScalarMeExpr*>(cmpOpnds.second);
+  MeStmt *defStmt0 = nullptr;
+  MeStmt *defStmt1 = nullptr;
+  auto *defBB0 = scalar0->GetDefByBBMeStmt(*func.GetCfg(), defStmt0);
+  auto *defBB1 = scalar1->GetDefByBBMeStmt(*func.GetCfg(), defStmt1);
+  if (scalar0->GetDefBy() == kDefByPhi && scalar1->GetDefBy() == kDefByPhi) {
+    auto *defPhi0 = &scalar0->GetDefPhi();
+    auto *defPhi1 = &scalar1->GetDefPhi();
+    if (defBB0 == &bb && defBB1 == &bb) {
+      FindPathWhenDefPointInCurrBB(bb, pred, *defPhi0->GetOpnd(i), defPhi1->GetOpnd(i));
+    } else if (defBB0 == &bb) {
+      FindPathWhenDefPointInCurrBB(bb, pred, *defPhi0->GetOpnd(i), cmpOpnds.second);
+    } else if (defBB1 == &bb) {
+      FindPathWhenDefPointInCurrBB(bb, pred, *cmpOpnds.first, defPhi1->GetOpnd(i));
+    } else {
+      if (dom.Dominate(*defBB0, *defBB1)) {
+        FindPathWhenDefPointIsNotInCurrBB(*defBB1, bb, *cmpOpnds.first, cmpOpnds.second);
+      } else if (dom.Dominate(*defBB1, *defBB0)) {
+        FindPathWhenDefPointIsNotInCurrBB(*defBB0, bb, *cmpOpnds.first, cmpOpnds.second);
+      }
+    }
+  } else if (scalar0->GetDefBy() == kDefByPhi) {
+    FindPathFromUse2DefWhenOneOpndIsDefByPhi(bb, pred, cmpOpnds, i, true);
+  } else if (scalar1->GetDefBy() == kDefByPhi) {
+    FindPathFromUse2DefWhenOneOpndIsDefByPhi(bb, pred, cmpOpnds, i, false);
+  } else if (scalar0->GetDefBy() == kDefByStmt && scalar1->GetDefBy() == kDefByStmt) {
+    if (dom.Dominate(*defBB0, *defBB1)) {
+      FindPathWhenDefByStmt(bb, cmpOpnds, false);
+    } else if (dom.Dominate(*defBB1, *defBB0)) {
+      FindPathWhenDefByStmt(bb, cmpOpnds, true);
+    }
+  } else if (static_cast<ScalarMeExpr*>(cmpOpnds.first)->GetDefBy() == kDefByStmt) {
+    FindPathWhenDefByStmt(bb, cmpOpnds, true);
+  } else if (static_cast<ScalarMeExpr*>(cmpOpnds.second)->GetDefBy() == kDefByStmt) {
+    FindPathWhenDefByStmt(bb, cmpOpnds, false);
+  }
+}
+
+void JumpThreading::FindPath(BB &bb, CompareOpnds &cmpOpnds) {
+  auto *loop = loops->GetBBLoopParent(bb.GetBBId());
+  if (loop != nullptr) {
+    if (currLoop != nullptr && loop != currLoop) {
+      return; // Only support walk through one loop.
+    }
+    currLoop = loop;
+  }
+  if (!visitedBBs.insert(&bb).second || bb.GetKind() == kBBIgoto ||
+      visitedBBs.size() > kLimitOfVisitedBB) {
+    return;
+  }
+  DEBUG_LOG() << bb.GetBBId() << " ";
+  if ((bb.GetKind() == kBBFallthru || bb.GetKind() == kBBGoto) &&
+      CanJumpThreading(bb, *cmpOpnds.first, cmpOpnds.second)) {
+    return;
+  }
+  for (size_t i = 0; i < bb.GetPred().size(); ++i) {
+    auto *pred = bb.GetPred(i);
+    auto currPathsSize = paths.size();
+    if (cmpOpnds.first->IsScalar() && cmpOpnds.second != nullptr && cmpOpnds.second->IsScalar()) {
+      FindPathWithTwoOperandsAreScalarMeExpr(bb, *pred, cmpOpnds, i);
+    } else if (cmpOpnds.first->IsScalar()) {
+      if (static_cast<ScalarMeExpr*>(cmpOpnds.first)->GetDefBy() == kDefByPhi) {
+        FindPathFromUse2DefWhenOneOpndIsDefByPhi(bb, *pred, cmpOpnds, i, true);
+      } else if (static_cast<ScalarMeExpr*>(cmpOpnds.first)->GetDefBy() == kDefByStmt) {
+        FindPathWhenDefByStmt(bb, cmpOpnds, true);
+      }
+    } else if (cmpOpnds.second != nullptr && cmpOpnds.second->IsScalar()) {
+      if (static_cast<ScalarMeExpr*>(cmpOpnds.second)->GetDefBy() == kDefByPhi) {
+        FindPathFromUse2DefWhenOneOpndIsDefByPhi(bb, *pred, cmpOpnds, i, false);
+      } else if (static_cast<ScalarMeExpr*>(cmpOpnds.second)->GetDefBy() == kDefByStmt) {
+        FindPathWhenDefByStmt(bb, cmpOpnds, false);
+      }
+    }
+    if (currPathsSize + 1 == paths.size()) {
+      continue; // This path has been optimized.
+    }
+    if (cmpOpnds.second != nullptr &&
+        !valueRanges.TowCompareOperandsAreInSameIterOfLoop(*cmpOpnds.first, *cmpOpnds.second)) {
+      continue;
+    }
+    // If currBB dom pred, can not do opt continue, because the value range of opnd in pred is come from currBB.
+    // For example:
+    // The loop has bb0, currBB, pred in the cfg:
+    //       |
+    //     currBB
+    //     / ^ \
+    //    v  |  v
+    //  bb0  | bb1
+    //     \ |
+    //      pred
+    if (!dom.Dominate(*currBB, *pred)) {
+      FindPathWhenDefByIsNotStmtAndPhi(*pred, bb, cmpOpnds);
+    }
+  }
+}
+
+void JumpThreading::PreFindPath(BB &bb, MeExpr &opnd0, MeExpr *opnd1) {
+  currLoop = nullptr;
+  visitedBBs.clear();
+  path->clear();
+  currBB = &bb;
+  auto compareOpnds = std::make_pair(&opnd0, opnd1);
+  FindPath(bb, compareOpnds);
+  currBB = nullptr;
+  DEBUG_LOG() << "\n";
+}
+
+void JumpThreading::DealWithCondGoto(BB &bb) {
+  if (!bb.GetLastMe()->IsCondBr()) {
+    return;
+  }
+  auto *condGotoMeStmt = static_cast<CondGotoMeStmt*>(bb.GetLastMe());
+  ASSERT_NOT_NULL(condGotoMeStmt);
+  auto *opMeExpr = static_cast<OpMeExpr*>(condGotoMeStmt->GetOpnd());
+  if (opMeExpr->GetNumOpnds() == 1) {
+    PreFindPath(bb, *opMeExpr);
+    return;
+  }
+  if (opMeExpr->GetNumOpnds() != kNumOperands) {
+    return;
+  }
+  PreFindPath(bb, *opMeExpr->GetOpnd(0), opMeExpr->GetOpnd(1));
+}
+
+void JumpThreading::DealWithSwitch(BB &bb) {
+  ASSERT_NOT_NULL(bb.GetLastMe());
+  if (bb.GetLastMe()->GetOp() != OP_switch) {
+    return;
+  }
+  auto *switchMeStmt = static_cast<SwitchMeStmt*>(bb.GetLastMe());
+  PreFindPath(bb, *switchMeStmt->GetOpnd());
+}
+
+void MEJumpThreading::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MELoopCanon>();
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.SetPreservedAll();
+}
+
+bool MEJumpThreading::PhaseRun(maple::MeFunction &f) {
+  f.jumpThreadingRuns++;
+  JumpThreading::isDebug = DEBUGFUNC_NEWPM(f);
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_FATAL(irMap != nullptr, "irMap phase has problem");
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  CHECK_FATAL(dom != nullptr, "dominance phase has problem");
+  auto *meLoop = GET_ANALYSIS(MELoopAnalysis, f);
+  if (JumpThreading::isDebug) {
+    LogInfo::MapleLogger() << f.GetName() << "\n";
+    f.Dump(false);
+    f.GetCfg()->DumpToFile("jump-threading-before" + std::to_string(f.jumpThreadingRuns));
+  }
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> cands((std::less<OStIdx>()));
+  LoopScalarAnalysisResult sa(*irMap, nullptr);
+  sa.SetComputeTripCountForLoopUnroll(false);
+  auto *memPool = GetPhaseMemPool();
+  StmtCostAnalyzer stmtCostAnalyzer(memPool, f.GetMirFunc());
+  ValueRangePropagation valueRangePropagation(f, *irMap, *dom, meLoop, *memPool, cands, sa, false, true);
+  JumpThreading jumpThreading(f, *dom, meLoop, valueRangePropagation, stmtCostAnalyzer, cands);
+  valueRangePropagation.Execute();
+  jumpThreading.Execute();
+  if (jumpThreading.IsCFGChange()) {
+    (void)f.GetCfg()->UnreachCodeAnalysis(true);
+    f.GetCfg()->WontExitAnalysis();
+    (void)MeSplitCEdge(false).SplitCriticalEdgeForMeFunc(f);
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+    dom = FORCE_EXEC(MEDominance)->GetDomResult();
+    MeSSAUpdate ssaUpdate(f, *f.GetMeSSATab(), *dom, cands);
+    ssaUpdate.Run();
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MELoopAnalysis::id);
+    GetAnalysisInfoHook()->ForceRunTransFormPhase<MeFuncOptTy, MeFunction>(&MELoopCanon::id, f);
+  }
+  if (JumpThreading::isDebug) {
+    LogInfo::MapleLogger() << f.GetName() << "\n";
+    f.Dump(false);
+    f.GetCfg()->DumpToFile("jump-threading-after" + std::to_string(f.jumpThreadingRuns));
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_loop_analysis.cpp b/src/mapleall/maple_me/src/me_loop_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6412097dfa921c8d63038fa744960e3e8aed039a
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_loop_analysis.cpp
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_loop_analysis.h"
+#include "me_dominance.h"
+
+// This phase analyses the CFG and identify the loops. The implementation is
+// based on the idea that, given two basic block a and b, if b is a's pred and
+// a dominates b, then there is a loop from a to b. Loop identification is done
+// in a preorder traversal of the dominator tree. In this order, outer loop is
+// always detected before its nested loop(s). The building of the LoopDesc data
+// structure takes advantage of this ordering.
+namespace maple {
+LoopDesc *IdentifyLoops::CreateLoopDesc(BB &hd, BB &tail) {
+  LoopDesc *newLoop = meLoopMemPool->New<LoopDesc>(meLoopAlloc, &hd, &tail);
+  meLoops.push_back(newLoop);
+  return newLoop;
+}
+
+void IdentifyLoops::SetLoopParent4BB(const BB &bb, LoopDesc &loopDesc) {
+  if (bbLoopParent[bb.GetBBId()] != nullptr) {
+    if (loopDesc.parent == nullptr) {
+      loopDesc.parent = bbLoopParent[bb.GetBBId()];
+      ASSERT_NOT_NULL(loopDesc.parent);
+      loopDesc.nestDepth = loopDesc.parent->nestDepth + 1;
+    }
+  }
+  bbLoopParent[bb.GetBBId()] = &loopDesc;
+}
+
+void IdentifyLoops::SetExitBB(LoopDesc &loop) {
+  for (auto bbId : loop.loopBBs) {
+    auto *bb = cfg->GetBBFromID(bbId);
+    for (auto *succ : bb->GetSucc()) {
+      if (loop.loopBBs.count(succ->GetBBId()) == 0) {
+        if (loop.exitBB && loop.exitBB != succ) {
+          loop.exitBB = nullptr;
+          return;
+        }
+        loop.exitBB = succ;
+      }
+    }
+  }
+}
+
+// process each BB in preorder traversal of dominator tree
+void IdentifyLoops::ProcessBB(BB *bb) {
+  if (bb == nullptr || bb == cfg->GetCommonExitBB()) {
+    return;
+  }
+  const MapleUnorderedSet<LabelIdx> &addrTakenLabels = func.GetMirFunc()->GetLabelTab()->GetAddrTakenLabels();
+  for (BB *pred : bb->GetPred()) {
+    if (dominance->Dominate(*bb, *pred)) {
+      // create a loop with bb as loop head and pred as loop tail
+      LoopDesc *loop = CreateLoopDesc(*bb, *pred);
+      // check try...catch
+      auto found = std::find_if(bb->GetPred().begin(), bb->GetPred().end(),
+                                [](BB *pre) { return pre->GetAttributes(kBBAttrIsTry); });
+      if (found != bb->GetPred().end()) {
+        loop->SetHasTryBB(true);
+      }
+      // check igoto
+      if (addrTakenLabels.find(bb->GetBBLabel()) != addrTakenLabels.end()) {
+        loop->SetHasIGotoBB(true);
+      }
+      std::list<BB*> bodyList;
+      bodyList.push_back(pred);
+      while (!bodyList.empty()) {
+        BB *curr = bodyList.front();
+        bodyList.pop_front();
+        // skip bb or if it has already been dealt with
+        if (curr == bb || loop->loopBBs.count(curr->GetBBId()) == 1) {
+          continue;
+        }
+        (void)loop->loopBBs.insert(curr->GetBBId());
+        curr->SetAttributes(kBBAttrIsInLoop);
+        // check try...catch
+        if (curr->GetAttributes(kBBAttrIsTry) || curr->GetAttributes(kBBAttrWontExit)) {
+          loop->SetHasTryBB(true);
+        }
+        SetLoopParent4BB(*curr, *loop);
+        for (BB *curPred : curr->GetPred()) {
+          bodyList.push_back(curPred);
+        }
+      }
+      (void)loop->loopBBs.insert(bb->GetBBId());
+      bb->SetAttributes(kBBAttrIsInLoop);
+      SetLoopParent4BB(*bb, *loop);
+      if (!loop->HasTryBB() && !loop->HasIGotoBB()) {
+        ProcessPreheaderAndLatch(*loop);
+      }
+      SetExitBB(*loop);
+    }
+  }
+  // recursive call
+  const auto &domChildren = dominance->GetDomChildren(bb->GetID());
+  for (auto bbIt = domChildren.begin(); bbIt != domChildren.end(); ++bbIt) {
+    ProcessBB(cfg->GetAllBBs().at(*bbIt));
+  }
+}
+
+void IdentifyLoops::Dump() const {
+  for (LoopDesc *meLoop : meLoops) {
+    // loop
+    LogInfo::MapleLogger() << "nest depth: " << meLoop->nestDepth
+                           << " loop head BB: " << meLoop->head->GetBBId()
+                           << " HasTryBB: " << meLoop->HasTryBB()
+                           << " tail BB:" << meLoop->tail->GetBBId() << '\n';
+    LogInfo::MapleLogger() << "loop body:";
+    for (auto it = meLoop->loopBBs.begin(); it != meLoop->loopBBs.end(); ++it) {
+      BBId bbId = *it;
+      LogInfo::MapleLogger() << bbId << " ";
+    }
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+void IdentifyLoops::ProcessPreheaderAndLatch(LoopDesc &loop) {
+  // If predsize of head is one, it means that one is entry bb.
+  if (loop.head->GetPred().size() == 1) {
+    CHECK_FATAL(cfg->GetCommonEntryBB()->GetSucc(0) == loop.head, "succ of entry bb must be head");
+    loop.preheader = cfg->GetCommonEntryBB();
+    CHECK_FATAL(!loop.head->GetPred(0)->GetAttributes(kBBAttrIsTry), "must not be kBBAttrIsTry");
+    loop.latch = loop.head->GetPred(0);
+    return;
+  }
+  /* for example: GetInstance.java : 152
+   * There are two loop in identifyLoops, and one has no try no catch.
+   * In loop canon whould ont merge loops with latch bb.
+   * for () {
+   *   if () {
+   *     do somthing
+   *     continue
+   *   }
+   *   try {
+   *     do somthing
+   *   } catch (NoSuchAlgorithmException e) {
+   *     do somthing
+   *   }
+   * }
+   */
+  if (loop.head->GetPred().size() != 2) { // Head must has two preds.
+    loop.SetIsCanonicalLoop(false);
+    loop.SetHasTryBB(true);
+    return;
+  }
+  if (!loop.Has(*loop.head->GetPred(0))) {
+    loop.preheader = loop.head->GetPred(0);
+    // loop canon phase may not be called when identloop is used
+    if ((loop.preheader->GetKind() != kBBFallthru) &&
+        (loop.preheader->GetKind() != kBBGoto)) {
+      loop.SetIsCanonicalLoop(false);
+      return;
+    }
+    CHECK_FATAL(loop.preheader->GetKind() == kBBFallthru ||
+                loop.preheader->GetKind() == kBBGoto,
+                "must be kBBFallthru or kBBGoto");
+    CHECK_FATAL(loop.Has(*loop.head->GetPred(1)), "must be latch bb");
+    loop.latch = loop.head->GetPred(1);
+    CHECK_FATAL(!loop.latch->GetAttributes(kBBAttrIsTry), "must not be kBBAttrIsTry");
+  } else {
+    loop.latch = loop.head->GetPred(0);
+    CHECK_FATAL(!loop.latch->GetAttributes(kBBAttrIsTry), "must not be kBBAttrIsTry");
+    CHECK_FATAL(!loop.Has(*loop.head->GetPred(1)), "must be latch preheader bb");
+    loop.preheader = loop.head->GetPred(1);
+  }
+}
+
+bool MELoopAnalysis::PhaseRun(maple::MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  ASSERT_NOT_NULL(dom);
+  identLoops = GetPhaseAllocator()->New<IdentifyLoops>(GetPhaseMemPool(), f, dom);
+  identLoops->ProcessBB(f.GetCfg()->GetCommonEntryBB());
+  if (DEBUGFUNC_NEWPM(f)) {
+    identLoops->Dump();
+  }
+  return false;
+}
+
+void MELoopAnalysis::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_loop_canon.cpp b/src/mapleall/maple_me/src/me_loop_canon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fa6502b41eab2f251e3995ebb415585b173dcb21
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_loop_canon.cpp
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_loop_canon.h"
+
+#include <algorithm>
+#include <iostream>
+
+#include "me_cfg.h"
+#include "me_dominance.h"
+#include "me_option.h"
+#include "me_phase_manager.h"
+
+namespace maple {
+// This phase ensures that every loop has a preheader and a single latch,
+// and also ensures all exits are dominated by the loop head.
+
+// Only when backedge or preheader is not try bb, update head map.
+void MeLoopCanon::FindHeadBBs(Dominance &dom, const BB *bb, std::map<BBId, std::vector<BB*>> &heads) const {
+  if (bb == nullptr || bb == func.GetCfg()->GetCommonExitBB()) {
+    return;
+  }
+  bool hasTry = bb->GetAttributes(kBBAttrIsTry) || bb->GetAttributes(kBBAttrWontExit);
+  bool hasIgoto = false;
+  for (BB *pred : bb->GetPred()) {
+    // backedge or preheader is try bb
+    if (pred->GetAttributes(kBBAttrIsTry) || bb->GetAttributes(kBBAttrWontExit)) {
+      hasTry = true;
+    }
+  }
+  // backedge is constructed by igoto
+  if (bb->GetBBLabel() != 0) {
+    const MapleUnorderedSet<LabelIdx> &addrTakenLabels = func.GetMirFunc()->GetLabelTab()->GetAddrTakenLabels();
+    if (addrTakenLabels.find(bb->GetBBLabel()) != addrTakenLabels.end()) {
+      hasIgoto = true;
+    }
+  }
+  if ((!hasTry) && (!hasIgoto)) {
+    for (BB *pred : bb->GetPred()) {
+      // add backedge bb
+      if (dom.Dominate(*bb, *pred)) {
+        if (heads.find(bb->GetBBId()) != heads.end()) {
+          heads[bb->GetBBId()].push_back(pred);
+        } else {
+          std::vector<BB*> tails;
+          tails.push_back(pred);
+          heads[bb->GetBBId()] = tails;
+        }
+      }
+    }
+  }
+  const auto &domChildren = dom.GetDomChildren(bb->GetID());
+  for (auto bbit = domChildren.begin(); bbit != domChildren.end(); ++bbit) {
+    FindHeadBBs(dom, func.GetCfg()->GetAllBBs().at(*bbit), heads);
+  }
+}
+
+void MeLoopCanon::UpdateTheOffsetOfStmtWhenTargetBBIsChange(BB &curBB, const BB &oldSuccBB, BB &newSuccBB) const {
+  MeStmt &lastStmt = curBB.GetMeStmts().back();
+  if ((lastStmt.GetOp() == OP_brtrue || lastStmt.GetOp() == OP_brfalse) &&
+      static_cast<CondGotoMeStmt&>(lastStmt).GetOffset() == oldSuccBB.GetBBLabel()) {
+    auto label = func.GetOrCreateBBLabel(newSuccBB);
+    static_cast<CondGotoMeStmt&>(lastStmt).SetOffset(label);
+  } else if (lastStmt.GetOp() == OP_goto && static_cast<GotoMeStmt&>(lastStmt).GetOffset() == oldSuccBB.GetBBLabel()) {
+    auto label = func.GetOrCreateBBLabel(newSuccBB);
+    static_cast<GotoMeStmt&>(lastStmt).SetOffset(label);
+  } else if (lastStmt.GetOp() == OP_switch) {
+    SwitchMeStmt &switchStmt = static_cast<SwitchMeStmt&>(lastStmt);
+    auto label = func.GetOrCreateBBLabel(newSuccBB);
+    if (switchStmt.GetDefaultLabel() == oldSuccBB.GetBBLabel()) {
+      switchStmt.SetDefaultLabel(label);
+    }
+    for (size_t i = 0; i < switchStmt.GetSwitchTable().size(); ++i) {
+      LabelIdx labelIdx = switchStmt.GetSwitchTable().at(i).second;
+      if (labelIdx == oldSuccBB.GetBBLabel()) {
+        switchStmt.SetCaseLabel(i, label);
+      }
+    }
+  }
+}
+
+// used to split some preds of SPLITTEDBB into MERGEDBB, these preds are saved in SPLITLIST
+void MeLoopCanon::SplitPreds(const std::vector<BB*> &splitList, BB *splittedBB, BB *mergedBB) {
+  if (splitList.size() == 1) {
+    // quick split
+    auto *pred = splitList[0];
+    int index = pred->GetSuccIndex(*splittedBB);
+    // add frequency to mergedBB
+    if (updateFreqs) {
+      int idx = pred->GetSuccIndex(*splittedBB);
+      ASSERT(idx >= 0 && idx < pred->GetSucc().size(), "sanity check");
+      uint64_t freq = pred->GetEdgeFreq(static_cast<uint32>(idx));
+      mergedBB->SetFrequency(freq);
+      mergedBB->PushBackSuccFreq(freq);
+    }
+    splittedBB->ReplacePred(pred, mergedBB);
+    pred->AddSucc(*mergedBB, static_cast<size_t>(static_cast<uint32>(index)));
+    if (updateFreqs) {
+      pred->AddSuccFreq(mergedBB->GetFrequency(), static_cast<size_t>(static_cast<uint32>(index)));
+    }
+    if (!pred->GetMeStmts().empty()) {
+      UpdateTheOffsetOfStmtWhenTargetBBIsChange(*pred, *splittedBB, *mergedBB);
+    }
+    isCFGChange = true;
+    return;
+  }
+  // create phi list for mergedBB
+  for (auto &phiIter : std::as_const(splittedBB->GetMePhiList())) {
+    auto *latchLhs = func.GetIRMap()->CreateRegOrVarMeExprVersion(phiIter.first);
+    auto *latchPhi = func.GetIRMap()->CreateMePhi(*latchLhs);
+    latchPhi->SetDefBB(mergedBB);
+    mergedBB->GetMePhiList().emplace(latchLhs->GetOstIdx(), latchPhi);
+    phiIter.second->GetOpnds().push_back(latchLhs);
+  }
+  uint64_t freq = 0;
+  for (BB *pred : splitList) {
+    auto pos = splittedBB->GetPredIndex(*pred);
+    for (auto &phiIter : std::as_const(mergedBB->GetMePhiList())) {
+      // replace phi opnd
+      phiIter.second->GetOpnds().push_back(splittedBB->GetMePhiList().at(phiIter.first)->GetOpnd(pos));
+    }
+    splittedBB->RemovePhiOpnd(pos);
+    if (updateFreqs) {
+      int idx = pred->GetSuccIndex(*splittedBB);
+      ASSERT(idx >= 0 && idx < pred->GetSucc().size(), "sanity check");
+      freq = pred->GetEdgeFreq(static_cast<size_t>(static_cast<uint32>(idx)));
+      mergedBB->SetFrequency(mergedBB->GetFrequency() + freq);
+    }
+    pred->ReplaceSucc(splittedBB, mergedBB);
+    if (updateFreqs) {
+      int idx = pred->GetSuccIndex(*mergedBB);
+      pred->SetSuccFreq(idx, freq);
+    }
+    if (pred->GetMeStmts().empty()) {
+      continue;
+    }
+    UpdateTheOffsetOfStmtWhenTargetBBIsChange(*pred, *splittedBB, *mergedBB);
+  }
+  // may introduce redundant phi node, clean it
+  for (auto phiIter = mergedBB->GetMePhiList().begin(); phiIter != mergedBB->GetMePhiList().end();) {
+    auto *phi = phiIter->second;
+    auto *phiOpnd0 = phi->GetOpnd(0);
+    auto foundDiff = std::find_if(phi->GetOpnds().begin(), phi->GetOpnds().end(),
+                                  [phiOpnd0](ScalarMeExpr *opnd) { return opnd != phiOpnd0; });
+    if (foundDiff == phi->GetOpnds().end()) {
+      auto &opnds = splittedBB->GetMePhiList()[phiIter->first]->GetOpnds();
+      // mergedBB is always the last pred of splittedBB
+      opnds[opnds.size() - 1] = phiOpnd0;
+      phiIter = mergedBB->GetMePhiList().erase(phiIter);
+    } else {
+      ++phiIter;
+    }
+  }
+  splittedBB->AddPred(*mergedBB);
+  if (updateFreqs) {
+    mergedBB->PushBackSuccFreq(mergedBB->GetFrequency());
+  }
+  isCFGChange = true;
+}
+
+// merge backedges with the same headBB
+void MeLoopCanon::Merge(const std::map<BBId, std::vector<BB*>> &heads) {
+  MeCFG *cfg = func.GetCfg();
+  for (auto iter = heads.begin(); iter != heads.end(); ++iter) {
+    BB *head = cfg->GetBBFromID(iter->first);
+    // skip case : check latch bb is already added
+    // one pred is preheader bb and the other is latch bb
+    if ((head->GetPred().size() == 2) && (head->GetPred(0)->GetAttributes(kBBAttrArtificial)) &&
+        (head->GetPred(0)->GetKind() == kBBFallthru) && (head->GetPred(1)->GetAttributes(kBBAttrArtificial)) &&
+        (head->GetPred(1)->GetKind() == kBBFallthru)) {
+      continue;
+    }
+    auto *latchBB = cfg->NewBasicBlock();
+    latchBB->SetAttributes(kBBAttrArtificial);
+    latchBB->SetAttributes(kBBAttrIsInLoop); // latchBB is inloop
+    latchBB->SetKind(kBBFallthru);
+    SplitPreds(iter->second, head, latchBB);
+  }
+}
+
+void MeLoopCanon::AddPreheader(const std::map<BBId, std::vector<BB*>> &heads) {
+  MeCFG *cfg = func.GetCfg();
+  for (auto iter = heads.begin(); iter != heads.end(); ++iter) {
+    BB *head = cfg->GetBBFromID(iter->first);
+    std::vector<BB*> preds;
+    for (BB *pred : head->GetPred()) {
+      // FindHeadBBs has filtered out this possibility.
+      CHECK_FATAL(!pred->GetAttributes(kBBAttrIsTry), "can not support kBBAttrIsTry");
+      if (std::find(iter->second.begin(), iter->second.end(), pred) == iter->second.end()) {
+        preds.push_back(pred);
+      }
+    }
+    // if the head is entry bb, we also need to add a preheader to replace it as new entry
+    if (head->GetAttributes(kBBAttrIsEntry)) {
+      auto *newEntry = func.GetCfg()->NewBasicBlock();
+      func.GetCfg()->GetCommonEntryBB()->RemoveEntry(*head);
+      func.GetCfg()->GetCommonEntryBB()->AddEntry(*newEntry);
+      newEntry->SetKind(kBBFallthru);
+      newEntry->SetAttributes(kBBAttrIsEntry);
+      head->ClearAttributes(kBBAttrIsEntry);
+      head->AddPred(*newEntry);
+      isCFGChange = true;
+    }
+    // If the num of backages is zero or one and bb kind is kBBFallthru, Preheader is already canonical.
+    if (preds.empty()) {
+      continue;
+    }
+    if (preds.size() == 1 && preds.front()->GetKind() == kBBFallthru) {
+      continue;
+    }
+    // add preheader
+    auto *preheader = cfg->NewBasicBlock();
+    preheader->SetAttributes(kBBAttrArtificial);
+    preheader->SetKind(kBBFallthru);
+    SplitPreds(preds, head, preheader);
+    if (preheader->GetPred().size() > 1) {
+      (void)func.GetOrCreateBBLabel(*preheader);
+    }
+  }
+}
+
+void MeLoopCanon::InsertExitBB(LoopDesc &loop) {
+  std::set<BB*> traveledBBs;
+  std::queue<BB*> inLoopBBs;
+  MeCFG *cfg = func.GetCfg();
+  inLoopBBs.push(loop.head);
+  CHECK_FATAL(loop.inloopBB2exitBBs.empty(), "inloopBB2exitBBs must be empty");
+  while (!inLoopBBs.empty()) {
+    BB *curBB = inLoopBBs.front();
+    inLoopBBs.pop();
+    if (curBB->GetKind() == kBBCondGoto) {
+      if (curBB->GetSucc().size() == 1) {
+        // When the size of succs is one, one of succs may be commonExitBB. Need insert to loopBB2exitBBs.
+        CHECK_FATAL(false, "return bb");
+      }
+    } else if (!curBB->GetMeStmts().empty() && curBB->GetLastMe()->IsReturn()) {
+      CHECK_FATAL(false, "return bb");
+    }
+    for (BB *succ : curBB->GetSucc()) {
+      if (traveledBBs.count(succ) != 0) {
+        continue;
+      }
+      if (loop.Has(*succ)) {
+        inLoopBBs.push(succ);
+        traveledBBs.insert(succ);
+        continue;
+      }
+      bool needNewExitBB = false;
+      for (auto pred : succ->GetPred()) {
+        if (!loop.Has(*pred)) {
+          needNewExitBB = true;
+          break;
+        }
+      }
+      if (needNewExitBB) {
+        // break the critical edge for code sinking
+        BB *newExitBB = cfg->NewBasicBlock();
+        newExitBB->SetKind(kBBFallthru);
+        auto pos = succ->GetPredIndex(*curBB);
+        uint64_t freq = 0;
+        if (updateFreqs) {
+          int idx = curBB->GetSuccIndex(*succ);
+          ASSERT(idx >= 0 && idx < curBB->GetSuccFreq().size(), "sanity check");
+          freq = curBB->GetSuccFreq()[static_cast<uint32>(idx)];
+        }
+        curBB->ReplaceSucc(succ, newExitBB);
+        succ->AddPred(*newExitBB, pos);
+        if (updateFreqs) {
+          newExitBB->SetFrequency(freq);
+          newExitBB->PushBackSuccFreq(freq);
+        }
+        if (!curBB->GetMeStmts().empty()) {
+          UpdateTheOffsetOfStmtWhenTargetBBIsChange(*curBB, *succ, *newExitBB);
+        }
+        succ = newExitBB;
+        isCFGChange = true;
+      }
+      loop.InsertInloopBB2exitBBs(*curBB, *succ);
+    }
+  }
+}
+
+void MeLoopCanon::NormalizationHeadAndPreHeaderOfLoop(Dominance &dom) {
+  if (isDebugFunc) {
+    LogInfo::MapleLogger() << "-----------------Dump mefunction before loop normalization----------\n";
+    func.Dump(true);
+    func.GetCfg()->DumpToFile("cfgbeforLoopNormalization", false, func.GetCfg()->UpdateCFGFreq());
+  }
+  std::map<BBId, std::vector<BB*>> heads;
+  isCFGChange = false;
+  FindHeadBBs(dom, func.GetCfg()->GetCommonEntryBB(), heads);
+  AddPreheader(heads);
+  Merge(heads);
+}
+
+void MeLoopCanon::NormalizationExitOfLoop(IdentifyLoops &meLoop) {
+  for (auto loop : meLoop.GetMeLoops()) {
+    if (loop->HasTryBB() || loop->HasIGotoBB()) {
+      continue;
+    }
+    loop->inloopBB2exitBBs.clear();
+    InsertExitBB(*loop);
+    loop->SetIsCanonicalLoop(true);
+  }
+  if (isDebugFunc) {
+    LogInfo::MapleLogger() << "-----------------Dump mefunction after loop normalization-----------\n";
+    func.Dump(true);
+    func.GetCfg()->DumpToFile("cfgafterLoopNormalization", false, func.GetCfg()->UpdateCFGFreq());
+  }
+}
+
+void MELoopCanon::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MELoopCanon::PhaseRun(maple::MeFunction &f) {
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_FATAL(irMap != nullptr, "irMap phase has problem");
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  ASSERT(dom != nullptr, "dom is null in MeDoLoopCanon::Run");
+  MemPool *loopCanonMp = GetPhaseMemPool();
+  bool updateFrequency = (Options::profileUse && f.GetMirFunc()->GetFuncProfData());
+  auto *meLoopCanon = loopCanonMp->New<MeLoopCanon>(f, DEBUGFUNC_NEWPM(f), updateFrequency);
+
+  // 1. Add preheaderBB and normalization headBB for loop.
+  meLoopCanon->NormalizationHeadAndPreHeaderOfLoop(*dom);
+  if (meLoopCanon->IsCFGChange()) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MELoopAnalysis::id);
+  }
+  IdentifyLoops *meLoop = FORCE_GET(MELoopAnalysis);
+  if (meLoop == nullptr) {
+    return false;
+  }
+  // 2. Normalization exitBB for loop.
+  meLoopCanon->ResetIsCFGChange();
+  meLoopCanon->NormalizationExitOfLoop(*meLoop);
+  if (meLoopCanon->IsCFGChange()) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+    if (updateFrequency && (f.GetCfg()->DumpIRProfileFile())) {
+      f.GetCfg()->DumpToFile("after-loopcanon", false, true);
+    }
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_loop_inversion.cpp b/src/mapleall/maple_me/src/me_loop_inversion.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fddacb87d9cd8064afe753307f5780505d88d82a
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_loop_inversion.cpp
@@ -0,0 +1,394 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_loop_inversion.h"
+
+#include <algorithm>
+#include <iostream>
+
+#include "me_cfg.h"
+#include "me_dominance.h"
+#include "me_option.h"
+#include "me_phase_manager.h"
+
+namespace maple {
+// This phase changes the control flow graph to canonicalize loops so that the
+// resulting loop form can provide places to insert loop-invariant code hoisted
+// from the loop body.  This means converting loops to exhibit the
+//      do {} while (condition)
+// loop form.
+//
+// Step 1: Loops are identified by the existence of a BB that dominates one of
+// its predecessors.  For each such backedge, the function NeedConvert() is
+// called to check if it needs to be re-structured.  If so, the backEdges are
+// collected.
+//
+// Step2: The collected backEdges are sorted so that their loop restructuring
+// can be processed in just one pass.
+//
+// Step3: Perform the conversion for the loop represented by each collected
+// backedge in sorted order.
+// sort backEdges if bb is used as pred in one backedge and bb in another backedge
+// deal with the bb used as pred first
+static bool CompareBackedge(const std::pair<BB*, BB*> &a, const std::pair<BB*, BB*> &b) {
+  // second is pred, first is bb
+  if ((a.second)->GetBBId() == (b.first)->GetBBId()) {
+    return true;
+  }
+  if ((a.first)->GetBBId() == (b.second)->GetBBId()) {
+    return false;
+  }
+  return (a.first)->GetBBId() < (b.first)->GetBBId();
+}
+
+bool MeLoopInversion::NeedConvert(MeFunction *func, BB &bb, BB &pred, MapleAllocator &localAlloc,
+                                  MapleMap<Key, bool> &swapSuccs) const {
+  // loop is transformed
+  if (pred.GetAttributes(kBBAttrArtificial) && bb.GetAttributes(kBBAttrArtificial)) {
+    return false;
+  }
+  bb.SetAttributes(kBBAttrIsInLoop);
+  pred.SetAttributes(kBBAttrIsInLoop);
+  // do not convert do-while loop
+  if ((bb.GetKind() != kBBCondGoto) || (&pred == &bb) || bb.GetAttributes(kBBAttrIsTry) ||
+      bb.GetAttributes(kBBAttrIsCatch)) {
+    return false;
+  }
+  auto *condPrev = bb.GetLast().GetPrev();
+  while (condPrev) {
+    if (condPrev->GetOpCode() != OP_comment) {
+      return false;
+    }
+    condPrev = condPrev->GetPrev();
+  }
+
+  if (bb.GetBBLabel() != 0) {
+    const MapleUnorderedSet<LabelIdx> &addrTakenLabels = func->GetMirFunc()->GetLabelTab()->GetAddrTakenLabels();
+    if (addrTakenLabels.find(bb.GetBBLabel()) != addrTakenLabels.end()) {
+      return false;  // target of igoto cannot be cloned
+    }
+  }
+  ASSERT(bb.GetSucc().size() == 2, "the number of bb's successors must equal 2");
+  // if both succs are equal, return false
+  if (bb.GetSucc().front() == bb.GetSucc().back()) {
+    return false;
+  }
+  // check bb's succ both in loop body or not, such as
+  //   1  <--
+  //  / \   |
+  //  2 |   |
+  //  \ |   |
+  //   3 ---|
+  //  /
+  MapleSet<BBId> inLoop(std::less<BBId>(), localAlloc.Adapter());
+  MapleList<BB*> bodyList(localAlloc.Adapter());
+  bodyList.push_back(&pred);
+  while (!bodyList.empty()) {
+    BB *curr = bodyList.front();
+    bodyList.pop_front();
+    // skip bb and bb is already in loop body(has been dealt with)
+    if (curr == &bb || inLoop.count(curr->GetBBId()) == 1) {
+      continue;
+    }
+    (void)inLoop.insert(curr->GetBBId());
+    for (BB *tmpPred : curr->GetPred()) {
+      ASSERT_NOT_NULL(tmpPred);
+      bodyList.push_back(tmpPred);
+      tmpPred->SetAttributes(kBBAttrIsInLoop);
+    }
+  }
+  if ((inLoop.count(bb.GetSucc(0)->GetBBId()) == 1) && (inLoop.count(bb.GetSucc(1)->GetBBId()) == 1)) {
+    return false;
+  }
+  // other case
+  // fallthru is in loop body, latchBB need swap succs
+  if (inLoop.count(bb.GetSucc().at(0)->GetBBId()) == 1) {
+    (void)swapSuccs.insert(make_pair(std::make_pair(&bb, &pred), true));
+  }
+  return true;
+}
+
+void MeLoopInversion::Convert(MeFunction &func, BB &bb, BB &pred, MapleMap<Key, bool> &swapSuccs) {
+  // if bb->fallthru is in loopbody, latchBB need convert condgoto and make original target as its fallthru
+  bool swapSuccOfLatch = (swapSuccs.find(std::make_pair(&bb, &pred)) != swapSuccs.cend());
+  if (isDebugFunc) {
+    LogInfo::MapleLogger() << "***loop convert: backedge bb->id " << bb.GetBBId() << " pred->id " << pred.GetBBId();
+    if (swapSuccOfLatch) {
+      LogInfo::MapleLogger() << " need swap succs\n";
+    } else {
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+  // new latchBB
+  BB *latchBB = func.GetCfg()->NewBasicBlock();
+  latchBB->SetAttributes(kBBAttrArtificial);
+  latchBB->SetAttributes(kBBAttrIsInLoop);  // latchBB is inloop
+  // update newBB frequency : copy predBB succFreq as latch frequency
+  if (func.GetCfg()->UpdateCFGFreq()) {
+    int idx = pred.GetSuccIndex(bb);
+    ASSERT(idx >= 0 && idx < pred.GetSucc().size(), "sanity check");
+    uint64_t freq = pred.GetEdgeFreq(idx);
+    latchBB->SetFrequency(freq);
+    // update bb frequency: remove pred frequency since pred is deleted
+    ASSERT(bb.GetFrequency() >= freq, "sanity check");
+    bb.SetFrequency(bb.GetFrequency() - freq);
+  }
+  // update pred bb
+  pred.ReplaceSucc(&bb, latchBB);  // replace pred.succ with latchBB and set pred of latchBB
+  // update pred stmt if needed
+  if (pred.GetKind() == kBBGoto) {
+    ASSERT(pred.GetAttributes(kBBAttrIsTry) || pred.GetSucc().size() == 1, "impossible");
+    ASSERT(!pred.GetStmtNodes().empty(), "impossible");
+    ASSERT(pred.GetStmtNodes().back().GetOpCode() == OP_goto, "impossible");
+    // delete goto stmt and make pred is fallthru
+    pred.RemoveLastStmt();
+    pred.SetKind(kBBFallthru);
+  } else if (pred.GetKind() == kBBCondGoto) {
+    // if replaced bb is goto target
+    ASSERT(pred.GetAttributes(kBBAttrIsTry) || pred.GetSucc().size() == 2,
+           "pred should have attr kBBAttrIsTry or have 2 successors");
+    ASSERT(!pred.GetStmtNodes().empty(), "pred's stmtNodeList should not be empty");
+    auto &condGotoStmt = static_cast<CondGotoNode&>(pred.GetStmtNodes().back());
+    if (latchBB == pred.GetSucc().at(1)) {
+      // latchBB is the new target
+      LabelIdx label = func.GetOrCreateBBLabel(*latchBB);
+      condGotoStmt.SetOffset(label);
+    }
+  } else if (pred.GetKind() == kBBFallthru) {
+    // do nothing
+  } else if (pred.GetKind() == kBBSwitch) {
+    ASSERT(!pred.GetStmtNodes().empty(), "bb is empty");
+    auto &switchStmt = static_cast<SwitchNode&>(pred.GetStmtNodes().back());
+    ASSERT(bb.GetBBLabel() != 0, "wrong bb label");
+    LabelIdx oldLabIdx = bb.GetBBLabel();
+    LabelIdx label = func.GetOrCreateBBLabel(*latchBB);
+    if (switchStmt.GetDefaultLabel() == oldLabIdx) {
+      switchStmt.SetDefaultLabel(label);
+    }
+    for (size_t i = 0; i < switchStmt.GetSwitchTable().size(); i++) {
+      LabelIdx labelIdx = switchStmt.GetCasePair(i).second;
+      if (labelIdx == oldLabIdx) {
+        switchStmt.UpdateCaseLabelAt(i, label);
+      }
+    }
+  } else {
+    CHECK_FATAL(false, "unexpected pred kind");
+  }
+  // clone instructions of bb to latchBB
+  func.GetCfg()->CloneBasicBlock(*latchBB, bb);
+  // clone bb's succ to latchBB
+  for (BB *succ : bb.GetSucc()) {
+    ASSERT(!latchBB->GetAttributes(kBBAttrIsTry) || latchBB->GetSucc().empty(),
+           "loopcanon : tryblock should insert succ before handler");
+    latchBB->AddSucc(*succ);
+  }
+  latchBB->SetKind(bb.GetKind());
+  // update succFreq
+  if (func.GetCfg()->UpdateCFGFreq()) {
+    if (latchBB->GetKind() == kBBCondGoto) {
+      BB *succInloop = swapSuccOfLatch ? bb.GetSucc(0) : bb.GetSucc(1);
+      if ((latchBB->GetFrequency() != 0) && (succInloop->GetFrequency() > 0)) {
+        // loop is executed
+        int64_t latchFreq = latchBB->GetFrequency();
+        if (swapSuccOfLatch) {
+          // bb fallthru is in loop, frequency of bb -> exitbb is set 0
+          // latchBB fallthru is loop exit
+          int fallthrudiff = static_cast<int>(bb.GetSucc(0)->GetFrequency() - bb.GetFrequency());
+          if (fallthrudiff >= 0) {
+            bb.SetSuccFreq(0, bb.GetFrequency());
+            bb.SetSuccFreq(1, 0);
+            latchBB->PushBackSuccFreq(latchFreq - fallthrudiff);
+            latchBB->PushBackSuccFreq(fallthrudiff);
+          } else {  // assume loop body executed only once
+            bb.SetSuccFreq(0, bb.GetSucc(0)->GetFrequency());
+            bb.SetSuccFreq(1, bb.GetFrequency() - bb.GetSucc(0)->GetFrequency());
+            latchBB->PushBackSuccFreq(latchBB->GetFrequency());
+            latchBB->PushBackSuccFreq(0);
+          }
+        } else {
+          // bb->fallthru is loop exit, edge frequency of  bb ->exitbb is set 0
+          // latchBB fallthru is in loop
+          int fallthrudiff = static_cast<int>(bb.GetSucc(1)->GetFrequency() - bb.GetFrequency());
+          if (fallthrudiff >= 0) {
+            bb.SetSuccFreq(1, bb.GetFrequency());
+            bb.SetSuccFreq(0, 0);
+            latchBB->PushBackSuccFreq(latchFreq - fallthrudiff);
+            latchBB->PushBackSuccFreq(fallthrudiff);
+          } else {
+            bb.SetSuccFreq(1, bb.GetSucc(0)->GetFrequency());
+            bb.SetSuccFreq(0, bb.GetFrequency() - bb.GetSucc(0)->GetFrequency());
+            latchBB->PushBackSuccFreq(0);
+            latchBB->PushBackSuccFreq(latchBB->GetFrequency());
+          }
+        }
+      } else {
+        // loop is not executed
+        if (latchBB->GetFrequency() != 0) {
+          if (swapSuccOfLatch) {
+            bb.SetSuccFreq(0, 0);
+            bb.SetSuccFreq(1, bb.GetFrequency());
+          } else {
+            bb.SetSuccFreq(0, bb.GetFrequency());
+            bb.SetSuccFreq(1, 0);
+          }
+        }
+        ASSERT(latchBB->GetFrequency() == 0, "sanity check");
+        latchBB->PushBackSuccFreq(0);
+        latchBB->PushBackSuccFreq(0);
+      }
+    } else if (latchBB->GetKind() == kBBFallthru || latchBB->GetKind() == kBBGoto) {
+      int64_t newsuccFreq = (latchBB->GetFrequency() == 0) ? 0 : latchBB->GetSuccFreq()[0] - 1;
+      latchBB->SetSuccFreq(0, newsuccFreq);  // loop is changed to do-while format
+      bb.SetSuccFreq(0, bb.GetFrequency());
+    } else {
+      ASSERT(0, "NYI:: unexpected bb type");
+    }
+  }
+  // swap latchBB's succ if needed
+  if (swapSuccOfLatch) {
+    // modify condBr stmt
+    ASSERT(latchBB->GetKind() == kBBCondGoto, "impossible");
+    auto &condGotoStmt = static_cast<CondGotoNode&>(latchBB->GetStmtNodes().back());
+    ASSERT(condGotoStmt.IsCondBr(), "impossible");
+    condGotoStmt.SetOpCode((condGotoStmt.GetOpCode() == OP_brfalse) ? OP_brtrue : OP_brfalse);
+    BB *fallthru = latchBB->GetSucc(0);
+    LabelIdx label = func.GetOrCreateBBLabel(*fallthru);
+    condGotoStmt.SetOffset(label);
+    // swap succ
+    BB *tmp = latchBB->GetSucc(0);
+    latchBB->SetSucc(0, latchBB->GetSucc(1));
+    latchBB->SetSucc(1, tmp);
+  }
+}
+
+void MeLoopInversion::ExecuteLoopInversion(MeFunction &func, const Dominance &dom) {
+  // set MeCFG's has_do_while flag
+  MeCFG *cfg = func.GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    if (bb->GetKind() != kBBCondGoto) {
+      continue;
+    }
+    StmtNode *stmt = bb->GetStmtNodes().rbegin().base().d();
+    if (stmt == nullptr) {
+      continue;
+    }
+    CondGotoNode *condBr = safe_cast<CondGotoNode>(stmt);
+    if (condBr == nullptr) {
+      continue;
+    }
+    BB *brTargetbb = bb->GetSucc(1);
+    if (dom.Dominate(*brTargetbb, *bb)) {
+      cfg->SetHasDoWhile(true);
+      break;
+    }
+  }
+  MapleAllocator localAlloc(innerMp);
+  MapleVector<std::pair<BB*, BB*>> backEdges(localAlloc.Adapter());
+  MapleMap<Key, bool> swapSuccs(std::less<Key>(), localAlloc.Adapter());
+  // collect backedge first: if bb dominator its pred, then the edge pred->bb is a backedge
+  eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    const MapleVector<BB*> &preds = bb->GetPred();
+    for (BB *pred : preds) {
+      ASSERT(cfg->GetCommonEntryBB() != nullptr, "impossible");
+      ASSERT_NOT_NULL(pred);
+      // bb is reachable from entry && bb dominator pred
+      if (dom.Dominate(*cfg->GetCommonEntryBB(), *bb) && dom.Dominate(*bb, *pred) &&
+          !pred->GetAttributes(kBBAttrWontExit) && (NeedConvert(&func, *bb, *pred, localAlloc, swapSuccs))) {
+        if (isDebugFunc) {
+          LogInfo::MapleLogger() << "find backedge " << bb->GetBBId() << " <-- " << pred->GetBBId() << '\n';
+        }
+        backEdges.push_back(std::make_pair(bb, pred));
+      }
+    }
+  }
+  // l with the edge which shared bb is used as pred
+  // if backedge 4->3 is converted first, it will create a new backedge
+  // <new latchBB-> BB1>, which needs iteration to deal with.
+  //                 1  <---
+  //               /  \    |
+  //              6   2    |
+  //                  /    |
+  //          |---> 3 -----|
+  //          |     |
+  //          ------4
+  //
+  sort(backEdges.begin(), backEdges.end(), CompareBackedge);
+  if (!backEdges.empty()) {
+    if (isDebugFunc) {
+      LogInfo::MapleLogger() << "-----------------Dump mefunction before loop convert----------\n";
+      func.Dump(true);
+    }
+    for (size_t i = 0; i < backEdges.size(); i++) {
+      BB *bb = backEdges[i].first;
+      BB *pred = backEdges[i].second;
+      ASSERT(bb != nullptr, "bb should not be nullptr");
+      ASSERT(pred != nullptr, "pred should not be nullptr");
+      Convert(func, *bb, *pred, swapSuccs);
+      for (auto *succ : bb->GetSucc()) {
+        if (!dom.Dominate(*succ, *pred)) {
+          continue;
+        }
+        for (BB *tmpPred : succ->GetPred()) {
+          if (!tmpPred->IsSuccBB(*pred)) {
+            continue;
+          }
+          if ((NeedConvert(&func, *succ, *tmpPred, localAlloc, swapSuccs))) {
+            if (isDebugFunc) {
+              LogInfo::MapleLogger() << "find new backedge " << succ->GetBBId() << " <-- " << tmpPred->GetBBId()
+                                     << '\n';
+            }
+            backEdges.push_back(std::make_pair(succ, tmpPred));
+          }
+        }
+      }
+    }
+    isCFGChange = true;
+    if (isDebugFunc) {
+      LogInfo::MapleLogger() << "-----------------Dump mefunction after loop convert-----------\n";
+      func.Dump(true);
+    }
+  }
+}
+
+void MELoopInversion::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MELoopInversion::PhaseRun(maple::MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  ASSERT(dom != nullptr, "dom is null in MeDoLoopCanon::Run");
+  MemPool *loopInversionMp = GetPhaseMemPool();
+  auto *meLoopInversion = loopInversionMp->New<MeLoopInversion>(DEBUGFUNC_NEWPM(f), *loopInversionMp);
+  meLoopInversion->ExecuteLoopInversion(f, *dom);
+  if (meLoopInversion->IsCFGChange()) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MELoopAnalysis::id);
+    if (f.GetCfg()->UpdateCFGFreq() && (f.GetCfg()->DumpIRProfileFile())) {
+      f.GetCfg()->DumpToFile("after-loopinversion", false, true);
+    }
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_loop_unrolling.cpp b/src/mapleall/maple_me/src/me_loop_unrolling.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef62b92744fa156399366b05c067fcae7ac401c9
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_loop_unrolling.cpp
@@ -0,0 +1,1261 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_loop_unrolling.h"
+
+#include <algorithm>
+#include <iostream>
+
+#include "me_cfg.h"
+#include "me_option.h"
+#include "me_phase_manager.h"
+#include "mir_builder.h"
+#include "mir_module.h"
+
+namespace maple {
+bool LoopUnrollingExecutor::enableDebug = false;
+bool LoopUnrollingExecutor::enableDump = false;
+constexpr uint32 kOneInsn = 1;
+constexpr uint32 kTwoInsn = 2;
+constexpr uint32 kThreeInsn = 3;
+constexpr uint32 kFiveInsn = 5;
+constexpr uint32 kMaxIndex = 2;
+constexpr uint32 kLoopBodyNum = 1;
+constexpr uint32 kOperandNum = 2;
+
+bool ProfileCheck(const maple::MeFunction &f) {
+  auto &profile = f.GetMIRModule().GetProfile();
+  if (!profile.IsValid()) {
+    if (LoopUnrollingExecutor::enableDebug) {
+      LogInfo::MapleLogger() << "DeCompress failed in loopUnrolling"
+                             << "\n";
+    }
+    return false;
+  }
+  if (!profile.CheckFuncHot(f.GetName())) {
+    if (LoopUnrollingExecutor::enableDebug) {
+      LogInfo::MapleLogger() << "func is not hot"
+                             << "\n";
+    }
+    return false;
+  }
+  return true;
+}
+
+void LoopUnrolling::ComputeCodeSize(const MeStmt &meStmt, uint32 &cost) {
+  switch (meStmt.GetOp()) {
+    case OP_igoto:
+    case OP_switch: {
+      canUnroll = false;
+      break;
+    }
+    case OP_comment: {
+      break;
+    }
+    case OP_goto:
+    case OP_dassign:
+    case OP_regassign:
+    case OP_membarrelease: {
+      cost += kOneInsn;
+      break;
+    }
+    case OP_brfalse:
+    case OP_brtrue:
+    case OP_maydassign:
+      CASE_OP_ASSERT_BOUNDARY {
+        cost += kTwoInsn;
+        break;
+      }
+    case OP_iassign:
+      CASE_OP_ASSERT_NONNULL
+    case OP_membaracquire: {
+      cost += kThreeInsn;
+      break;
+    }
+    case OP_call:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_interfaceicallassigned:
+    case OP_intrinsiccall:
+    case OP_intrinsiccallassigned:
+    case OP_intrinsiccallwithtype:
+    case OP_membarstorestore:
+    case OP_membarstoreload: {
+      cost += kFiveInsn;
+      break;
+    }
+    case OP_asm: {
+      // currently skip unrolling loop with asm stmt
+      cost += kMaxCost;
+      break;
+    }
+    default:
+      if (LoopUnrollingExecutor::enableDebug) {
+        LogInfo::MapleLogger() << "consider this op :" << meStmt.GetOp() << "\n";
+      }
+      canUnroll = false;
+      break;
+  }
+}
+
+BB *LoopUnrolling::CopyBB(BB &bb, bool isInLoop) {
+  BB *newBB = cfg->NewBasicBlock();
+  if (isInLoop) {
+    newBB->SetAttributes(kBBAttrIsInLoop);
+  }
+  newBB->SetKind(bb.GetKind());
+  func->CloneBBMeStmts(bb, *newBB, &cands);
+  return newBB;
+}
+
+void LoopUnrolling::SetLabelWithCondGotoOrGotoBB(BB &bb, std::unordered_map<BB*, BB*> &old2NewBB, const BB &exitBB,
+                                                 LabelIdx oldlabIdx) {
+  CHECK_FATAL(!bb.GetMeStmts().empty(), "must not be empty");
+  for (auto succ : bb.GetSucc()) {
+    // process in replace preds of exit bb
+    if (succ == &exitBB || old2NewBB.find(succ) == old2NewBB.end()) {
+      continue;
+    }
+    bool inLastNew2OldBB = false;
+    if (old2NewBB.find(succ) == old2NewBB.end()) {
+      for (auto &it : std::as_const(lastNew2OldBB)) {
+        if (it.second == succ) {
+          inLastNew2OldBB = true;
+          break;
+        }
+      }
+      if (inLastNew2OldBB) {
+        continue;
+      } else {
+        CHECK_FATAL(false, "impossible");
+      }
+    }
+    if (oldlabIdx == succ->GetBBLabel()) {
+      LabelIdx label = old2NewBB[succ]->GetBBLabel();
+      CHECK_FATAL(label != 0, "label must not be zero");
+      if (bb.GetKind() == kBBCondGoto) {
+        static_cast<CondGotoMeStmt&>(old2NewBB[&bb]->GetMeStmts().back()).SetOffset(label);
+      } else {
+        CHECK_FATAL(bb.GetKind() == kBBGoto, "must be kBBGoto");
+        static_cast<GotoMeStmt&>(old2NewBB[&bb]->GetMeStmts().back()).SetOffset(label);
+      }
+    }
+  }
+}
+
+// When loop unroll times is two, use this function to update the preds and succs of the duplicate loopbody.
+void LoopUnrolling::ResetOldLabel2NewLabel(std::unordered_map<BB*, BB*> &old2NewBB, BB &bb, const BB &exitBB,
+                                           BB &newHeadBB) {
+  if (bb.GetKind() == kBBCondGoto) {
+    CHECK_FATAL(!bb.GetMeStmts().empty(), "must not be empty");
+    CondGotoMeStmt &condGotoNode = static_cast<CondGotoMeStmt&>(bb.GetMeStmts().back());
+    LabelIdx oldlabIdx = condGotoNode.GetOffset();
+    CHECK_FATAL(oldlabIdx == exitBB.GetBBLabel(), "must equal");
+    LabelIdx label = func->GetOrCreateBBLabel(newHeadBB);
+    condGotoNode.SetOffset(label);
+    static_cast<CondGotoMeStmt&>(newHeadBB.GetMeStmts().back()).SetOffset(oldlabIdx);
+  } else if (bb.GetKind() == kBBGoto) {
+    CHECK_FATAL(!bb.GetMeStmts().empty(), "must not be empty");
+    GotoMeStmt &gotoStmt = static_cast<GotoMeStmt&>(bb.GetMeStmts().back());
+    LabelIdx oldlabIdx = gotoStmt.GetOffset();
+    CHECK_FATAL(oldlabIdx == exitBB.GetBBLabel(), "must equal");
+    LabelIdx label = func->GetOrCreateBBLabel(newHeadBB);
+    gotoStmt.SetOffset(label);
+    static_cast<GotoMeStmt&>(old2NewBB[&bb]->GetMeStmts().back()).SetOffset(oldlabIdx);
+  }
+}
+
+// When loop unroll times more than two, use this function to update the preds and succs of duplicate loopbodys.
+void LoopUnrolling::ResetOldLabel2NewLabel2(std::unordered_map<BB*, BB*> &old2NewBB, BB &bb, const BB &exitBB,
+                                            BB &newHeadBB) {
+  if (bb.GetKind() == kBBCondGoto) {
+    CHECK_FATAL(!bb.GetMeStmts().empty(), "must not be empty");
+    CondGotoMeStmt &condGotoNode = static_cast<CondGotoMeStmt&>(bb.GetMeStmts().back());
+    LabelIdx oldlabIdx = condGotoNode.GetOffset();
+    CHECK_FATAL(oldlabIdx == exitBB.GetBBLabel(), "must equal");
+    LabelIdx label = func->GetOrCreateBBLabel(newHeadBB);
+    condGotoNode.SetOffset(label);
+    static_cast<CondGotoMeStmt&>(newHeadBB.GetMeStmts().back()).SetOffset(oldlabIdx);
+  } else if (bb.GetKind() == kBBGoto) {
+    CHECK_FATAL(!bb.GetMeStmts().empty(), "must not be empty");
+    GotoMeStmt &gotoStmt = static_cast<GotoMeStmt&>(bb.GetMeStmts().back());
+    LabelIdx oldlabIdx = gotoStmt.GetOffset();
+    LabelIdx label = func->GetOrCreateBBLabel(newHeadBB);
+    gotoStmt.SetOffset(label);
+    static_cast<GotoMeStmt&>(old2NewBB[lastNew2OldBB[&bb]]->GetMeStmts().back()).SetOffset(oldlabIdx);
+  }
+}
+
+void LoopUnrolling::ResetFrequency(const BB &curBB, const BB &succ, const BB &exitBB, BB &curCopyBB, bool copyAllLoop) {
+  if (resetFreqForUnrollWithVar && copyAllLoop) {
+    if (&curBB == &exitBB && &succ == *loop->inloopBB2exitBBs.begin()->second->begin()) {
+      curCopyBB.PushBackSuccFreq(loop->head->GetFrequency() % replicatedLoopNum == 0 ? 0 : 1);
+    }
+    if ((&curBB == loop->latch && &succ == loop->head) || (&curBB == &exitBB && &succ == loop->latch)) {
+      curCopyBB.PushBackSuccFreq(
+          loop->head->GetFrequency() % replicatedLoopNum == 0 ? 0 : loop->head->GetFrequency() % replicatedLoopNum - 1);
+    } else {
+      curCopyBB.PushBackSuccFreq(curBB.GetEdgeFreq(&succ) % replicatedLoopNum);
+    }
+  } else {
+    profValid &&resetFreqForAfterInsertGoto
+        ? curCopyBB.PushBackSuccFreq(curBB.GetEdgeFreq(&succ) - 1 == 0 ? curBB.GetEdgeFreq(&succ)
+                                                                       : curBB.GetEdgeFreq(&succ) - 1)
+        : curCopyBB.PushBackSuccFreq(curBB.GetEdgeFreq(&succ));
+  }
+}
+
+void LoopUnrolling::CreateLableAndInsertLabelBB(BB &newHeadBB, std::set<BB*> &labelBBs) {
+  if (loop->head->GetBBLabel() != 0) {
+    (void)func->GetOrCreateBBLabel(newHeadBB);
+  }
+  if (newHeadBB.GetKind() == kBBCondGoto || newHeadBB.GetKind() == kBBGoto) {
+    labelBBs.insert(loop->head);
+  }
+}
+
+void LoopUnrolling::CopyLoopBodyForProfile(BB &newHeadBB, std::unordered_map<BB*, BB*> &old2NewBB,
+                                           std::set<BB*> &labelBBs, const BB &exitBB, bool copyAllLoop) {
+  CreateLableAndInsertLabelBB(newHeadBB, labelBBs);
+  std::queue<BB*> bbQue;
+  bbQue.push(loop->head);
+  while (!bbQue.empty()) {
+    BB *curBB = bbQue.front();
+    bbQue.pop();
+    BB *curCopyBB = old2NewBB[curBB];
+    for (BB *succ : curBB->GetSucc()) {
+      if (loop->loopBBs.find(succ->GetBBId()) == loop->loopBBs.end() ||
+          (!copyAllLoop && (succ == &exitBB || succ == loop->latch))) {
+        continue;
+      }
+      if (old2NewBB.find(succ) != old2NewBB.end()) {
+        ResetFrequency(*curBB, *succ, exitBB, *curCopyBB, copyAllLoop);
+        curCopyBB->AddSucc(*old2NewBB[succ]);
+      } else {
+        if (needUpdateInitLoopFreq) {
+          ResetFrequency(*succ);
+        }
+        BB *newBB = CopyBB(*succ, true);
+        if (resetFreqForUnrollWithVar) {
+          if (succ == loop->latch) {
+            newBB->SetFrequency(loop->head->GetFrequency() % replicatedLoopNum - 1);
+          } else {
+            newBB->SetFrequency(succ->GetFrequency() % replicatedLoopNum);
+          }
+        } else {
+          resetFreqForAfterInsertGoto
+              ? newBB->SetFrequency(succ->GetFrequency() - 1 == 0 ? succ->GetFrequency() : succ->GetFrequency() - 1)
+              : newBB->SetFrequency(succ->GetFrequency());
+        }
+        curCopyBB->AddSucc(*newBB);
+        ResetFrequency(*curBB, *succ, exitBB, *curCopyBB, copyAllLoop);
+        (void)old2NewBB.emplace(succ, newBB);
+        bbQue.push(succ);
+        if (succ->GetBBLabel() != 0) {
+          (void)func->GetOrCreateBBLabel(*newBB);
+        }
+        if (succ->GetKind() == kBBCondGoto || succ->GetKind() == kBBGoto) {
+          labelBBs.insert(succ);
+        }
+      }
+    }
+  }
+}
+
+void LoopUnrolling::CopyLoopBody(BB &newHeadBB, std::unordered_map<BB*, BB*> &old2NewBB, std::set<BB*> &labelBBs,
+                                 const BB &exitBB, bool copyAllLoop) {
+  CreateLableAndInsertLabelBB(newHeadBB, labelBBs);
+  std::queue<BB*> bbQue;
+  bbQue.push(loop->head);
+  while (!bbQue.empty()) {
+    BB *curBB = bbQue.front();
+    bbQue.pop();
+    BB *curCopyBB = old2NewBB[curBB];
+    for (BB *succ : curBB->GetSucc()) {
+      if (loop->loopBBs.find(succ->GetBBId()) == loop->loopBBs.end() ||
+          (!copyAllLoop && (succ == &exitBB || succ == loop->latch))) {
+        continue;
+      }
+      if (old2NewBB.find(succ) != old2NewBB.end()) {
+        curCopyBB->AddSucc(*old2NewBB[succ]);
+      } else {
+        BB *newBB = CopyBB(*succ, true);
+        curCopyBB->AddSucc(*newBB);
+        CHECK_NULL_FATAL(newBB);
+        (void)old2NewBB.emplace(succ, newBB);
+        bbQue.push(succ);
+        if (succ->GetBBLabel() != 0) {
+          (void)func->GetOrCreateBBLabel(*newBB);
+        }
+        if (succ->GetKind() == kBBCondGoto || succ->GetKind() == kBBGoto) {
+          labelBBs.insert(succ);
+        }
+      }
+    }
+  }
+}
+
+// Update frequency of old BB.
+void LoopUnrolling::ResetFrequency(BB &bb) {
+  uint64 freq = bb.GetFrequency() / replicatedLoopNum;
+  if ((!instrumentProf) && freq == 0 && partialCount == 0 && bb.GetFrequency() != 0) {
+    freq = 1;
+  }
+  bb.SetFrequency(freq + partialCount);
+  for (size_t i = 0; i < bb.GetSucc().size(); ++i) {
+    auto currFreq = bb.GetEdgeFreq(i) / replicatedLoopNum;
+    if ((!instrumentProf) && currFreq == 0 && partialCount == 0 && bb.GetFrequency() != 0) {
+      currFreq = 1;
+    }
+    bb.SetEdgeFreq(bb.GetSucc(i), currFreq + partialCount);
+  }
+}
+
+// Update frequency of old exiting BB and latch BB.
+void LoopUnrolling::ResetFrequency() {
+  auto exitBB = cfg->GetBBFromID(loop->inloopBB2exitBBs.begin()->first);
+  auto latchBB = loop->latch;
+  if (isUnrollWithVar) {
+    uint64 latchFreq = loop->head->GetFrequency() % replicatedLoopNum - loop->preheader->GetFrequency();
+    exitBB->SetFrequency(loop->head->GetFrequency() % replicatedLoopNum - latchFreq);
+    exitBB->SetEdgeFreq(latchBB, latchFreq);
+    latchBB->SetFrequency(latchFreq);
+    latchBB->SetEdgeFreq(loop->head, latchFreq);
+  } else {
+    uint64 exitFreq = exitBB->GetFrequency() / replicatedLoopNum;
+    if (exitFreq == 0 && exitBB->GetFrequency() != 0) {
+      exitFreq = 1;
+    }
+    exitBB->SetFrequency(exitFreq);
+    auto exitEdgeFreq = exitBB->GetEdgeFreq(latchBB) / replicatedLoopNum;
+    if (exitEdgeFreq == 0 && exitBB->GetEdgeFreq(latchBB) != 0) {
+      exitEdgeFreq = 1;
+    }
+    exitBB->SetEdgeFreq(latchBB, exitEdgeFreq);
+    auto latchFreq = latchBB->GetFrequency() / replicatedLoopNum;
+    if (latchFreq == 0 && latchBB->GetFrequency() != 0) {
+      latchFreq = 1;
+    }
+    latchBB->SetFrequency(latchFreq);
+    latchBB->SetEdgeFreq(loop->head, latchFreq);
+  }
+}
+
+// When copying the loop for the first time, insert the loop header behind the tail of the original loop.
+void LoopUnrolling::AddEdgeForExitBBLastNew2OldBBEmpty(BB &exitBB, std::unordered_map<BB*, BB*> &old2NewBB,
+                                                       BB &newHeadBB) {
+  if (!exitBB.GetPred().empty()) {
+    for (auto &it : std::as_const(exitBB.GetMePhiList())) {
+      MeSSAUpdate::InsertOstToSSACands(it.first, *exitBB.GetPred(0), &cands);
+    }
+  }
+  for (size_t idx = 0; idx < exitBB.GetPred().size(); ++idx) {
+    auto *bb = exitBB.GetPred(idx);
+    auto it = old2NewBB.find(bb);
+    CHECK_FATAL(it != old2NewBB.end(), "Can not find bb in old2NewBB");
+    bb->ReplaceSucc(&exitBB, &newHeadBB);
+    exitBB.AddPred(*old2NewBB[bb], idx);
+    if (profValid) {
+      resetFreqForAfterInsertGoto
+          ? (bb->GetEdgeFreq(idx) - 1 == 0 ? old2NewBB[bb]->PushBackSuccFreq(bb->GetEdgeFreq(idx))
+                                           : old2NewBB[bb]->PushBackSuccFreq(bb->GetEdgeFreq(idx) - 1))
+          : old2NewBB[bb]->PushBackSuccFreq(bb->GetEdgeFreq(idx));
+    }
+    ResetOldLabel2NewLabel(old2NewBB, *bb, exitBB, newHeadBB);
+  }
+}
+
+void LoopUnrolling::AddEdgeForExitBB(BB &exitBB, std::unordered_map<BB*, BB*> &old2NewBB, BB &newHeadBB) {
+  for (size_t idx = 0; idx < exitBB.GetPred().size(); ++idx) {
+    auto *bb = exitBB.GetPred(idx);
+    auto it = old2NewBB.find(lastNew2OldBB[bb]);
+    CHECK_FATAL(it != old2NewBB.end(), "Can not find bb in lastNew2OldBB");
+    bb->ReplaceSucc(&exitBB, &newHeadBB);
+    exitBB.AddPred(*old2NewBB[lastNew2OldBB[bb]], idx);
+    if (profValid) {
+      (resetFreqForAfterInsertGoto && firstResetForAfterInsertGoto)
+          ? (bb->GetEdgeFreq(idx) - 1 == 0 ? old2NewBB[lastNew2OldBB[bb]]->PushBackSuccFreq(bb->GetEdgeFreq(idx))
+                                           : old2NewBB[lastNew2OldBB[bb]]->PushBackSuccFreq(bb->GetEdgeFreq(idx) - 1))
+          : old2NewBB[lastNew2OldBB[bb]]->PushBackSuccFreq(bb->GetEdgeFreq(idx));
+      firstResetForAfterInsertGoto = false;
+    }
+    ResetOldLabel2NewLabel2(old2NewBB, *bb, exitBB, newHeadBB);
+  }
+}
+
+// Copy loop except exiting BB and latch BB.
+void LoopUnrolling::CopyAndInsertBB(bool isPartial) {
+  auto exitBB = cfg->GetBBFromID(loop->inloopBB2exitBBs.begin()->first);
+  CHECK_FATAL(exitBB->GetKind() == kBBCondGoto, "exiting bb must be kBBCondGoto");
+  std::unordered_map<BB*, BB*> old2NewBB;
+  BB *newHeadBB = CopyBB(*loop->head, true);
+  if (profValid && needUpdateInitLoopFreq) {
+    ResetFrequency(*loop->head);
+    ResetFrequency();
+  }
+  profValid &&resetFreqForAfterInsertGoto
+      ? (loop->head->GetFrequency() - 1 == 0 ? newHeadBB->SetFrequency(loop->head->GetFrequency())
+                                             : newHeadBB->SetFrequency(loop->head->GetFrequency() - 1))
+      : newHeadBB->SetFrequency(loop->head->GetFrequency());
+  (void)old2NewBB.emplace(loop->head, newHeadBB);
+  std::set<BB*> labelBBs;
+  profValid ? CopyLoopBodyForProfile(*newHeadBB, old2NewBB, labelBBs, *exitBB, false)
+            : CopyLoopBody(*newHeadBB, old2NewBB, labelBBs, *exitBB, false);
+  if (isPartial) {
+    partialSuccHead = newHeadBB;
+  }
+  for (auto bb : labelBBs) {
+    if (bb->GetKind() == kBBCondGoto) {
+      CHECK_FATAL(!bb->GetMeStmts().empty(), "must not be empty");
+      LabelIdx oldlabIdx = static_cast<CondGotoMeStmt&>(bb->GetMeStmts().back()).GetOffset();
+      SetLabelWithCondGotoOrGotoBB(*bb, old2NewBB, *exitBB, oldlabIdx);
+    } else if (bb->GetKind() == kBBGoto) {
+      CHECK_FATAL(!bb->GetMeStmts().empty(), "must not be empty");
+      LabelIdx oldlabIdx = static_cast<GotoMeStmt&>(bb->GetMeStmts().back()).GetOffset();
+      SetLabelWithCondGotoOrGotoBB(*bb, old2NewBB, *exitBB, oldlabIdx);
+    } else {
+      CHECK_FATAL(false, "must be kBBCondGoto or kBBGoto");
+    }
+  }
+  if (lastNew2OldBB.empty()) {
+    AddEdgeForExitBBLastNew2OldBBEmpty(*exitBB, old2NewBB, *newHeadBB);
+  } else {
+    AddEdgeForExitBB(*exitBB, old2NewBB, *newHeadBB);
+  }
+  lastNew2OldBB.clear();
+  for (auto it : old2NewBB) {
+    lastNew2OldBB[it.second] = it.first;
+  }
+}
+
+void LoopUnrolling::RemoveCondGoto() {
+  BB *exitingBB = cfg->GetBBFromID(loop->inloopBB2exitBBs.begin()->first);
+  CHECK_FATAL(exitingBB->GetSucc().size() == 2, "must has two succ bb");
+  if (exitingBB->GetSucc(0) != loop->latch && exitingBB->GetSucc(1) != loop->latch) {
+    CHECK_FATAL(false, "latch must be pred of exiting bb");
+  }
+  exitingBB->RemoveSucc(*loop->latch);
+  exitingBB->RemoveMeStmt(exitingBB->GetLastMe());
+  exitingBB->SetKind(kBBFallthru);
+  if (profValid) {
+    exitingBB->SetEdgeFreq(exitingBB->GetSucc(0), exitingBB->GetFrequency());
+  }
+  loop->head->RemovePred(*loop->latch);
+  cfg->DeleteBasicBlock(*loop->latch);
+}
+
+bool LoopUnrolling::SplitCondGotoBB() {
+  auto *exitBB = func->GetCfg()->GetBBFromID(loop->inloopBB2exitBBs.begin()->first);
+  auto *exitedBB = *(loop->inloopBB2exitBBs.cbegin()->second->cbegin());
+  MeStmt *lastStmt = exitBB->GetLastMe();
+  ASSERT_NOT_NULL(lastStmt);
+  if (lastStmt->GetOp() == OP_igoto || lastStmt->GetOp() == OP_switch) {
+    return false;
+  }
+  if (lastStmt->GetOp() != OP_brfalse && lastStmt->GetOp() != OP_brtrue) {
+    return false;
+  }
+  bool notOnlyHasBrStmt = true;
+  for (auto &stmt : exitBB->GetMeStmts()) {
+    if (&stmt != exitBB->GetLastMe()) {
+      notOnlyHasBrStmt = false;
+      break;
+    }
+  }
+  if (notOnlyHasBrStmt) {
+    return true;
+  }
+  BB *newCondGotoBB = func->GetCfg()->NewBasicBlock();
+  newCondGotoBB->SetKind(kBBCondGoto);
+  newCondGotoBB->SetAttributes(kBBAttrIsInLoop);
+  exitBB->SetKind(kBBFallthru);
+  loop->loopBBs.insert(newCondGotoBB->GetBBId());
+  loop->InsertInloopBB2exitBBs(*newCondGotoBB, *exitedBB);
+  loop->inloopBB2exitBBs.erase(exitBB->GetBBId());
+
+  for (auto *bb : exitBB->GetSucc()) {
+    bb->ReplacePred(exitBB, newCondGotoBB);
+  }
+
+  exitBB->AddSucc(*newCondGotoBB);
+  exitBB->RemoveMeStmt(lastStmt);
+  newCondGotoBB->InsertMeStmtLastBr(lastStmt);
+  return true;
+}
+
+LoopUnrolling::ReturnKindOfFullyUnroll LoopUnrolling::LoopFullyUnroll(int64 tripCount) {
+  if (tripCount > kMaxCost) {
+    // quickly return if iteration is large enough
+    return kCanNotFullyUnroll;
+  }
+  if (MeOption::optForSize) {
+    return kCanNotFullyUnroll;
+  }
+  uint32 costResult = 0;
+  for (auto bbId : loop->loopBBs) {
+    BB *bb = cfg->GetBBFromID(bbId);
+    for (auto &meStmt : bb->GetMeStmts()) {
+      uint32 cost = 0;
+      ComputeCodeSize(meStmt, cost);
+      if (!canUnroll) {
+        return kCanNotFullyUnroll;
+      }
+      costResult += cost;
+      if (costResult * tripCount > kMaxCost) {
+        return kCanNotFullyUnroll;
+      }
+    }
+  }
+  if (!SplitCondGotoBB()) {
+    return kCanNotSplitCondGoto;
+  }
+  replicatedLoopNum = static_cast<uint64>(tripCount);
+  for (int64 i = 0; i < tripCount; ++i) {
+    if (i > 0) {
+      needUpdateInitLoopFreq = false;
+    }
+    CopyAndInsertBB(false);
+  }
+  RemoveCondGoto();
+  return kCanFullyUnroll;
+}
+
+void LoopUnrolling::ResetFrequency(BB &newCondGotoBB, BB &exitingBB, const BB &exitedBB, uint64 headFreq) {
+  if (profValid) {
+    newCondGotoBB.SetFrequency(headFreq);
+    exitingBB.SetEdgeFreq(&exitedBB, 0);
+  }
+}
+
+void LoopUnrolling::InsertCondGotoBB() {
+  CHECK_NULL_FATAL(partialSuccHead);
+  BB *exitingBB = cfg->GetBBFromID(loop->inloopBB2exitBBs.begin()->first);
+  BB *exitedBB = *(loop->inloopBB2exitBBs.cbegin()->second->cbegin());
+  BB *newCondGotoBB = CopyBB(*exitingBB, true);
+  uint64 headFreq = loop->head->GetFrequency();
+  ResetFrequency(*newCondGotoBB, *exitingBB, *exitedBB, headFreq);
+  MeStmt *lastMeStmt = newCondGotoBB->GetLastMe();
+  CHECK_FATAL(lastMeStmt != nullptr, "last meStmt must not be nullptr");
+  CHECK_FATAL(partialSuccHead->GetBBLabel() != 0, "label must not be zero");
+  static_cast<CondGotoMeStmt*>(lastMeStmt)->SetOffset(partialSuccHead->GetBBLabel());
+  bool addExitedSucc = false;
+  if (exitingBB->GetSucc().front() == exitedBB) {
+    addExitedSucc = true;
+    newCondGotoBB->AddSucc(*exitedBB);
+    if (profValid) {
+      newCondGotoBB->PushBackSuccFreq(1);
+    }
+  }
+  for (size_t idx = 0; idx < partialSuccHead->GetPred().size(); ++idx) {
+    auto *pred = partialSuccHead->GetPred(idx);
+    pred->ReplaceSucc(partialSuccHead, newCondGotoBB);
+    partialSuccHead->AddPred(*newCondGotoBB, idx);
+    if (profValid) {
+      newCondGotoBB->PushBackSuccFreq(headFreq - 1 == 0 ? headFreq : headFreq - 1);
+    }
+    if (pred->GetKind() == kBBCondGoto) {
+      CHECK_FATAL(!pred->GetMeStmts().empty(), "must not be empty");
+      CondGotoMeStmt &condGotoNode = static_cast<CondGotoMeStmt&>(pred->GetMeStmts().back());
+      LabelIdx oldlabIdx = condGotoNode.GetOffset();
+      CHECK_FATAL(oldlabIdx == partialSuccHead->GetBBLabel(), "must equal");
+      LabelIdx label = func->GetOrCreateBBLabel(*newCondGotoBB);
+      condGotoNode.SetOffset(label);
+    } else if (pred->GetKind() == kBBGoto) {
+      CHECK_FATAL(!pred->GetMeStmts().empty(), "must not be empty");
+      GotoMeStmt &gotoStmt = static_cast<GotoMeStmt&>(pred->GetMeStmts().back());
+      LabelIdx oldlabIdx = gotoStmt.GetOffset();
+      CHECK_FATAL(oldlabIdx == partialSuccHead->GetBBLabel(), "must equal");
+      LabelIdx label = func->GetOrCreateBBLabel(*newCondGotoBB);
+      gotoStmt.SetOffset(label);
+    }
+  }
+  if (!addExitedSucc) {
+    newCondGotoBB->AddSucc(*exitedBB);
+    if (profValid) {
+      newCondGotoBB->PushBackSuccFreq(headFreq - 1 == 0 ? headFreq : headFreq - 1);
+    }
+  }
+}
+
+bool LoopUnrolling::DetermineUnrollTimes(uint32 &index, bool isConst) {
+  uint32 costResult = 0;
+  uint32 unrollTime = unrollTimes[index];
+  for (auto bbId : loop->loopBBs) {
+    BB *bb = cfg->GetBBFromID(bbId);
+    auto exitBB = cfg->GetBBFromID(loop->inloopBB2exitBBs.cbegin()->first);
+    if (bb == exitBB) {
+      continue;
+    }
+    for (auto &meStmt : bb->GetMeStmts()) {
+      uint32 cost = 0;
+      ComputeCodeSize(meStmt, cost);
+      if (!canUnroll) {
+        return false;
+      }
+      costResult += cost;
+      if ((isConst && costResult * (unrollTime - 1) > kMaxCost) || (!isConst && costResult * unrollTime > kMaxCost)) {
+        if (index < kMaxIndex) {
+          ++index;
+          return DetermineUnrollTimes(index, isConst);
+        } else {
+          return false;
+        }
+      }
+    }
+  }
+  if (LoopUnrollingExecutor::enableDebug) {
+    LogInfo::MapleLogger() << "CodeSize: " << costResult << "\n";
+  }
+  return true;
+}
+
+void LoopUnrolling::AddPreHeader(BB *oldPreHeader, BB *head) {
+  CHECK_FATAL(oldPreHeader->GetKind() == kBBCondGoto, "must be kBBCondGoto");
+  auto *preheader = cfg->NewBasicBlock();
+  preheader->SetAttributes(kBBAttrArtificial);
+  preheader->SetKind(kBBFallthru);
+  uint64 preheaderFreq = 0;
+  if (profValid) {
+    preheaderFreq = oldPreHeader->GetEdgeFreq(head);
+  }
+  size_t index = head->GetPred().size();
+  while (index > 0) {
+    if (head->GetPred(index - 1) == oldPreHeader) {
+      break;
+    }
+    --index;
+  }
+  oldPreHeader->ReplaceSucc(head, preheader);
+  --index;
+  head->AddPred(*preheader, index);
+  if (profValid) {
+    preheader->PushBackSuccFreq(preheaderFreq);
+    preheader->SetFrequency(preheaderFreq);
+  }
+  CondGotoMeStmt *condGotoStmt = static_cast<CondGotoMeStmt*>(oldPreHeader->GetLastMe());
+  LabelIdx oldlabIdx = condGotoStmt->GetOffset();
+  if (oldlabIdx == head->GetBBLabel()) {
+    LabelIdx label = func->GetOrCreateBBLabel(*preheader);
+    condGotoStmt->SetOffset(label);
+  }
+}
+
+bool LoopUnrolling::LoopPartialUnrollWithConst(uint64 tripCount) {
+  uint32 index = 0;
+  if (!DetermineUnrollTimes(index, true)) {
+    if (LoopUnrollingExecutor::enableDebug) {
+      LogInfo::MapleLogger() << "CodeSize is too large"
+                             << "\n";
+    }
+    return false;
+  }
+  uint32 unrollTime = unrollTimes[index];
+  if (tripCount / unrollTime < 1) {
+    return false;
+  }
+  uint32 remainder = (static_cast<uint32>(tripCount) + kLoopBodyNum) % unrollTime;
+  if (!SplitCondGotoBB()) {
+    return false;
+  }
+  if (LoopUnrollingExecutor::enableDebug) {
+    LogInfo::MapleLogger() << "Unrolltime: " << unrollTime << "\n";
+    LogInfo::MapleLogger() << "Remainder: " << remainder << "\n";
+  }
+  if (remainder == 0) {
+    for (int64 i = 1; i < unrollTime; ++i) {
+      if (i > 1) {
+        needUpdateInitLoopFreq = false;
+      }
+      replicatedLoopNum = unrollTime;
+      CopyAndInsertBB(false);
+    }
+  } else {
+    partialCount = 1;
+    for (int64 i = 1; i < unrollTime; ++i) {
+      if (i > 1) {
+        needUpdateInitLoopFreq = false;
+      }
+      resetFreqForAfterInsertGoto = i < remainder ? false : true;
+      replicatedLoopNum = unrollTime;
+      if (i == remainder) {
+        CopyAndInsertBB(true);
+      } else {
+        CopyAndInsertBB(false);
+      }
+    }
+    replicatedLoopNum = unrollTime;
+    InsertCondGotoBB();
+  }
+  return true;
+}
+
+void LoopUnrolling::CopyLoopForPartialAndPre(BB *&newHead, BB *&newExiting) {
+  needUpdateInitLoopFreq = false;
+  auto exitBB = cfg->GetBBFromID(loop->inloopBB2exitBBs.begin()->first);
+  CHECK_FATAL(exitBB->GetKind() == kBBCondGoto, "exiting bb must be kBBCondGoto");
+  std::unordered_map<BB*, BB*> old2NewBB;
+  BB *newHeadBB = CopyBB(*loop->head, true);
+  if (profValid) {
+    newHeadBB->SetFrequency(loop->head->GetFrequency() % replicatedLoopNum);
+  }
+  (void)old2NewBB.emplace(loop->head, newHeadBB);
+  std::set<BB*> labelBBs;
+  resetFreqForUnrollWithVar = true;
+  profValid ? CopyLoopBodyForProfile(*newHeadBB, old2NewBB, labelBBs, *exitBB, true)
+            : CopyLoopBody(*newHeadBB, old2NewBB, labelBBs, *exitBB, true);
+  resetFreqForUnrollWithVar = false;
+  for (auto bb : labelBBs) {
+    if (bb->GetKind() == kBBCondGoto) {
+      CHECK_FATAL(!bb->GetMeStmts().empty(), "must not be empty");
+      LabelIdx oldlabIdx = static_cast<CondGotoMeStmt&>(bb->GetMeStmts().back()).GetOffset();
+      SetLabelWithCondGotoOrGotoBB(*bb, old2NewBB, *exitBB, oldlabIdx);
+    } else if (bb->GetKind() == kBBGoto) {
+      CHECK_FATAL(!bb->GetMeStmts().empty(), "must not be empty");
+      LabelIdx oldlabIdx = static_cast<GotoMeStmt&>(bb->GetMeStmts().back()).GetOffset();
+      SetLabelWithCondGotoOrGotoBB(*bb, old2NewBB, *exitBB, oldlabIdx);
+    } else {
+      CHECK_FATAL(false, "must be kBBCondGoto or kBBGoto");
+    }
+  }
+  newHead = newHeadBB;
+  newExiting = old2NewBB[exitBB];
+}
+
+VarMeExpr *LoopUnrolling::CreateIndVarOrTripCountWithName(const std::string &name) {
+  MIRSymbol *symbol =
+      func->GetMIRModule().GetMIRBuilder()->CreateLocalDecl(name, *GlobalTables::GetTypeTable().GetInt32());
+  OriginalSt *ost = irMap->GetSSATab().CreateSymbolOriginalSt(*symbol, func->GetMirFunc()->GetPuidx(), 0);
+  ost->SetZeroVersionIndex(irMap->GetVerst2MeExprTable().size());
+  irMap->GetVerst2MeExprTable().push_back(nullptr);
+  ost->PushbackVersionsIndices(ost->GetZeroVersionIndex());
+  VarMeExpr *var = irMap->CreateVarMeExprVersion(ost);
+  return var;
+}
+
+// i < tripcount / unrollTime
+void LoopUnrolling::UpdateCondGotoStmt(BB &bb, VarMeExpr &indVar, MeExpr &tripCount, MeExpr &unrollTimeExpr,
+                                       uint32 offset) {
+  for (auto &stmt : bb.GetMeStmts()) {
+    bb.RemoveMeStmt(&stmt);
+  }
+  MeExpr *divMeExpr = irMap->CreateMeExprBinary(OP_div, PTY_i32, tripCount, unrollTimeExpr);
+  MeExpr *opMeExpr = irMap->CreateMeExprCompare(OP_ge, PTY_u1, PTY_i32, static_cast<MeExpr&>(indVar), *divMeExpr);
+  UnaryMeStmt *unaryMeStmt = irMap->New<UnaryMeStmt>(OP_brfalse);
+  unaryMeStmt->SetOpnd(0, opMeExpr);
+  CondGotoMeStmt *newCondGotoStmt = irMap->New<CondGotoMeStmt>(*unaryMeStmt, offset);
+  bb.AddMeStmtLast(newCondGotoStmt);
+}
+
+// i++
+// i < tripcount / unrollTime
+void LoopUnrolling::UpdateCondGotoBB(BB &bb, VarMeExpr &indVar, MeExpr &tripCount, MeExpr &unrollTimeExpr) {
+  uint32 offset = static_cast<CondGotoMeStmt*>(bb.GetLastMe())->GetOffset();
+  for (auto &stmt : bb.GetMeStmts()) {
+    bb.RemoveMeStmt(&stmt);
+  }
+  VarMeExpr *newVarLHS = irMap->CreateVarMeExprVersion(indVar.GetOst());
+  MeSSAUpdate::InsertOstToSSACands(newVarLHS->GetOstIdx(), bb, &cands);
+  MeExpr *constMeExprForOne = irMap->CreateIntConstMeExpr(1, PTY_i32);
+  MeExpr *addMeExpr = irMap->CreateMeExprBinary(OP_add, PTY_i32, indVar, *constMeExprForOne);
+  UpdateCondGotoStmt(bb, indVar, tripCount, unrollTimeExpr, offset);
+  bb.AddMeStmtFirst(irMap->CreateAssignMeStmt(*newVarLHS, *addMeExpr, bb));
+}
+
+void LoopUnrolling::ExchangeSucc(BB &partialExit) {
+  BB *succ0 = partialExit.GetSucc(0);
+  partialExit.SetSucc(0, partialExit.GetSucc(1));
+  partialExit.SetSucc(1, succ0);
+}
+
+// copy loop for partial
+void LoopUnrolling::CopyLoopForPartial(BB &partialCondGoto, BB &exitedBB, BB &exitingBB) {
+  BB *partialHead = nullptr;
+  BB *partialExit = nullptr;
+  CopyLoopForPartialAndPre(partialHead, partialExit);
+  (void)func->GetOrCreateBBLabel(partialCondGoto);
+  CHECK_FATAL(partialHead->GetBBLabel() != 0, "must not be zero");
+  CHECK_FATAL(!partialCondGoto.GetMeStmts().empty(), "must not be empty");
+  CondGotoMeStmt &condGotoStmt = static_cast<CondGotoMeStmt&>(partialCondGoto.GetMeStmts().back());
+  condGotoStmt.SetOffset(partialHead->GetBBLabel());
+  size_t index = exitedBB.GetPred().size();
+  while (index > 0) {
+    if (exitedBB.GetPred(index - 1) == &exitingBB) {
+      break;
+    }
+    --index;
+  }
+  exitingBB.ReplaceSucc(&exitedBB, &partialCondGoto);
+  --index;
+  exitedBB.AddPred(partialCondGoto, index);
+  if (profValid) {
+    partialCondGoto.PushBackSuccFreq(exitedBB.GetFrequency() - (loop->head->GetFrequency() % replicatedLoopNum));
+  }
+  partialExit->AddSucc(exitedBB);
+  if (profValid) {
+    partialExit->PushBackSuccFreq(loop->head->GetFrequency() % replicatedLoopNum);
+  }
+  CHECK_FATAL(partialExit->GetKind() == kBBCondGoto, "must be kBBCondGoto");
+  if (static_cast<CondGotoMeStmt*>(partialExit->GetLastMe())->GetOffset() != partialExit->GetSucc(1)->GetBBLabel()) {
+    ExchangeSucc(*partialExit);
+    if (profValid) {
+      auto tempFreq = partialExit->GetEdgeFreq(partialExit->GetSucc(0));
+      partialExit->SetEdgeFreq(partialExit->GetSucc(0), partialExit->GetEdgeFreq(partialExit->GetSucc(1)));
+      partialExit->SetEdgeFreq(partialExit->GetSucc(1), tempFreq);
+    }
+  }
+  partialCondGoto.AddSucc(*partialHead);
+  if (profValid) {
+    partialCondGoto.PushBackSuccFreq(loop->head->GetFrequency() % replicatedLoopNum);
+    partialCondGoto.SetFrequency(partialCondGoto.GetEdgeFreq(static_cast<size_t>(0)) + partialCondGoto.GetEdgeFreq(1));
+  }
+  CHECK_FATAL(partialCondGoto.GetKind() == kBBCondGoto, "must be partialCondGoto");
+  CHECK_FATAL(!partialCondGoto.GetMeStmts().empty(), "must not be empty");
+  if (static_cast<CondGotoMeStmt*>(partialCondGoto.GetLastMe())->GetOffset() !=
+      partialCondGoto.GetSucc(1)->GetBBLabel()) {
+    ExchangeSucc(partialCondGoto);
+  }
+  AddPreHeader(&partialCondGoto, partialHead);
+}
+
+MeExpr *LoopUnrolling::CreateExprWithCRNode(CRNode &crNode) {
+  switch (crNode.GetCRType()) {
+    case kCRConstNode: {
+      return irMap->CreateIntConstMeExpr(static_cast<const CRConstNode&>(crNode).GetConstValue(), PTY_i32);
+    }
+    case kCRVarNode: {
+      CHECK_FATAL(crNode.GetExpr() != nullptr, "expr must not be nullptr");
+      return crNode.GetExpr();
+    }
+    case kCRAddNode: {
+      auto addCRNode = static_cast<const CRAddNode&>(crNode);
+      auto addOpnd1 = CreateExprWithCRNode(*addCRNode.GetOpnd(0));
+      auto addOpnd2 = CreateExprWithCRNode(*addCRNode.GetOpnd(1));
+      MeExpr *addOpnds = irMap->CreateMeExprBinary(OP_add, PTY_i32, *addOpnd1, *addOpnd2);
+      for (size_t i = 2; i < addCRNode.GetOpndsSize(); ++i) {
+        auto addOpnd = CreateExprWithCRNode(*addCRNode.GetOpnd(i));
+        addOpnds = irMap->CreateMeExprBinary(OP_add, PTY_i32, *addOpnds, *addOpnd);
+      }
+      return addOpnds;
+    }
+    case kCRMulNode: {
+      auto mulCRNode = static_cast<const CRMulNode&>(crNode);
+      auto mulOpnd1 = CreateExprWithCRNode(*mulCRNode.GetOpnd(0));
+      auto mulOpnd2 = CreateExprWithCRNode(*mulCRNode.GetOpnd(1));
+      MeExpr *mulOpnds = irMap->CreateMeExprBinary(OP_mul, PTY_i32, *mulOpnd1, *mulOpnd2);
+      for (size_t i = 2; i < mulCRNode.GetOpndsSize(); ++i) {
+        auto mulOpnd = CreateExprWithCRNode(*mulCRNode.GetOpnd(i));
+        mulOpnds = irMap->CreateMeExprBinary(OP_mul, PTY_i32, *mulOpnds, *mulOpnd);
+      }
+      return mulOpnds;
+    }
+    case kCRDivNode: {
+      auto divCRNode = static_cast<CRDivNode&>(crNode);
+      auto opnd1 = CreateExprWithCRNode(*divCRNode.GetLHS());
+      auto opnd2 = CreateExprWithCRNode(*divCRNode.GetRHS());
+      return irMap->CreateMeExprBinary(OP_div, PTY_i32, *opnd1, *opnd2);
+    }
+    default: {
+      CHECK_FATAL(false, "impossible");
+    }
+  }
+}
+
+void LoopUnrolling::CreateIndVarAndCondGotoStmt(CR &cr, CRNode &varNode, BB &preCondGoto, uint32 unrollTime, uint32 i) {
+  // create stmt : int i = 0.
+  BB *indVarAndTripCountDefBB = cfg->NewBasicBlock();
+  std::string indVarName = std::string("__LoopUnrolllIndvar__") + std::to_string(i);
+  VarMeExpr *indVar = CreateIndVarOrTripCountWithName(indVarName);
+  indVarAndTripCountDefBB->SetKind(kBBFallthru);
+  MeExpr *constMeExprForZero = irMap->CreateIntConstMeExpr(0, PTY_i32);
+  indVarAndTripCountDefBB->AddMeStmtLast(
+      irMap->CreateAssignMeStmt(*indVar, *constMeExprForZero, *indVarAndTripCountDefBB));
+  MeSSAUpdate::InsertOstToSSACands(indVar->GetOstIdx(), *indVarAndTripCountDefBB, &cands);
+
+  // create stmt : tripCount = (n - start) / stride.
+  BB *exitingBB = cfg->GetBBFromID(loop->inloopBB2exitBBs.cbegin()->first);
+  auto opnd0 = CreateExprWithCRNode(*cr.GetOpnd(0));
+  auto opnd1 = CreateExprWithCRNode(*cr.GetOpnd(1));
+  MeExpr *conditionExpr = CreateExprWithCRNode(varNode);
+
+  MeExpr *subMeExpr = irMap->CreateMeExprBinary(OP_sub, PTY_i32, *conditionExpr, *opnd0);
+  MeExpr *divMeExpr = irMap->CreateMeExprBinary(OP_div, PTY_i32, *subMeExpr, *opnd1);
+  std::string tripConutName = std::string("__LoopUnrolllTripCount__") + std::to_string(i);
+  VarMeExpr *tripCountExpr = CreateIndVarOrTripCountWithName(tripConutName);
+  indVarAndTripCountDefBB->AddMeStmtLast(
+      irMap->CreateAssignMeStmt(*tripCountExpr, *divMeExpr, *indVarAndTripCountDefBB));
+  MeSSAUpdate::InsertOstToSSACands(tripCountExpr->GetOstIdx(), *indVarAndTripCountDefBB, &cands);
+  for (size_t idx = 0; idx < preCondGoto.GetPred().size(); ++idx) {
+    auto *bb = preCondGoto.GetPred(idx);
+    bb->ReplaceSucc(&preCondGoto, indVarAndTripCountDefBB);
+    preCondGoto.AddPred(*indVarAndTripCountDefBB, idx);
+    if (profValid) {
+      indVarAndTripCountDefBB->PushBackSuccFreq(preCondGoto.GetEdgeFreq(idx));
+    }
+    switch (bb->GetKind()) {
+      case kBBFallthru: {
+        break;
+      }
+      case kBBGoto: {
+        auto gotoStmt = static_cast<GotoMeStmt*>(bb->GetLastMe());
+        if (preCondGoto.GetBBLabel() == gotoStmt->GetOffset()) {
+          LabelIdx label = func->GetOrCreateBBLabel(*indVarAndTripCountDefBB);
+          gotoStmt->SetOffset(label);
+        }
+        break;
+      }
+      case kBBCondGoto: {
+        auto condGotoStmt = static_cast<CondGotoMeStmt*>(bb->GetLastMe());
+        if (preCondGoto.GetBBLabel() == condGotoStmt->GetOffset()) {
+          LabelIdx label = func->GetOrCreateBBLabel(*indVarAndTripCountDefBB);
+          condGotoStmt->SetOffset(label);
+        }
+        break;
+      }
+      default: {
+        CHECK_FATAL(false, "NYI");
+      }
+    }
+  }
+  MeExpr *unrollTimeExpr = irMap->CreateIntConstMeExpr(unrollTime, PTY_i32);
+  UpdateCondGotoBB(*exitingBB, *indVar, *tripCountExpr, *unrollTimeExpr);
+  UpdateCondGotoStmt(preCondGoto, *indVar, *tripCountExpr, *unrollTimeExpr, loop->head->GetBBLabel());
+}
+
+void LoopUnrolling::CopyLoopForPartial(CR &cr, CRNode &varNode, uint32 j, uint32 unrollTime) {
+  BB *exitingBB = cfg->GetBBFromID(loop->inloopBB2exitBBs.cbegin()->first);
+  BB *exitedBB = *loop->inloopBB2exitBBs.cbegin()->second->cbegin();
+  BB *partialCondGoto = CopyBB(*exitingBB, false);
+  replicatedLoopNum = unrollTime;
+  CopyLoopForPartial(*partialCondGoto, *exitedBB, *exitingBB);
+  // create preCondGoto bb
+  BB *preCondGoto = cfg->NewBasicBlock();
+  if (profValid) {
+    preCondGoto->SetFrequency(loop->preheader->GetFrequency());
+  }
+  size_t idx = loop->head->GetPred().size();
+  while (idx > 0) {
+    if (loop->head->GetPred(idx - 1) == loop->preheader) {
+      break;
+    }
+    --idx;
+  }
+  loop->preheader->ReplaceSucc(loop->head, preCondGoto);
+  --idx;
+  loop->head->AddPred(*preCondGoto, idx);
+  preCondGoto->AddSucc(*partialCondGoto);
+  preCondGoto->GetSuccFreq().resize(kOperandNum);
+  if (profValid) {
+    preCondGoto->SetEdgeFreq(partialCondGoto, loop->head->GetFrequency() >= unrollTime ? 0 : 1);
+    preCondGoto->SetEdgeFreq(loop->head, loop->head->GetFrequency() / unrollTime);
+  }
+  preCondGoto->SetKind(kBBCondGoto);
+  CreateIndVarAndCondGotoStmt(cr, varNode, *preCondGoto, unrollTime, j);
+  AddPreHeader(preCondGoto, loop->head);
+  CHECK_FATAL(preCondGoto->GetKind() == kBBCondGoto, "must be kBBCondGoto");
+  if (static_cast<CondGotoMeStmt*>(preCondGoto->GetLastMe())->GetOffset() != preCondGoto->GetSucc(1)->GetBBLabel()) {
+    ExchangeSucc(*preCondGoto);
+    auto tempFreq = preCondGoto->GetEdgeFreq(preCondGoto->GetSucc(0));
+    if (profValid) {
+      preCondGoto->SetEdgeFreq(preCondGoto->GetSucc(0), preCondGoto->GetEdgeFreq(preCondGoto->GetSucc(1)));
+      preCondGoto->SetEdgeFreq(preCondGoto->GetSucc(1), tempFreq);
+    }
+  }
+}
+
+bool LoopUnrolling::LoopPartialUnrollWithVar(CR &cr, CRNode &varNode, uint32 j) {
+  uint32 index = 0;
+  if (!DetermineUnrollTimes(index, false)) {
+    if (LoopUnrollingExecutor::enableDebug) {
+      LogInfo::MapleLogger() << "codesize is too large"
+                             << "\n";
+    }
+    return false;
+  }
+  if (LoopUnrollingExecutor::enableDebug) {
+    LogInfo::MapleLogger() << "partial unrolling with var"
+                           << "\n";
+  }
+  if (LoopUnrollingExecutor::enableDump) {
+    irMap->Dump();
+    profValid ? cfg->DumpToFile("cfgIncludeFreqInfobeforeLoopPartialWithVarUnrolling", false, true)
+              : cfg->DumpToFile("cfgbeforeLoopPartialWithVarUnrolling");
+  }
+  if (!SplitCondGotoBB()) {
+    return false;
+  }
+  uint32 unrollTime = unrollTimes[index];
+  if (LoopUnrollingExecutor::enableDebug) {
+    LogInfo::MapleLogger() << "unrolltime: " << unrollTime << "\n";
+  }
+  CopyLoopForPartial(cr, varNode, j, unrollTime);
+  replicatedLoopNum = unrollTime;
+  needUpdateInitLoopFreq = true;
+  isUnrollWithVar = true;
+  for (int64 i = 1; i < unrollTime; ++i) {
+    if (i > 1) {
+      needUpdateInitLoopFreq = false;
+    }
+    CopyAndInsertBB(false);
+  }
+  if (LoopUnrollingExecutor::enableDump) {
+    irMap->Dump();
+    profValid ? cfg->DumpToFile("cfgIncludeFreqInfoafterLoopPartialWithVarUnrolling", false, true)
+              : cfg->DumpToFile("cfgafterLoopPartialWithVarUnrolling");
+  }
+  return true;
+}
+
+void LoopUnrollingExecutor::SetNestedLoop(const IdentifyLoops &meLoop,
+                                          std::unordered_map<LoopDesc*, std::set<LoopDesc*>> &parentLoop) const {
+  for (auto loop : meLoop.GetMeLoops()) {
+    if (loop->nestDepth == 0) {
+      continue;
+    }
+    CHECK_NULL_FATAL(loop->parent);
+    auto it = parentLoop.find(loop->parent);
+    if (it == parentLoop.end()) {
+      parentLoop[loop->parent] = {loop};
+    } else {
+      parentLoop[loop->parent].insert(loop);
+    }
+  }
+}
+
+bool LoopUnrollingExecutor::IsDoWhileLoop(const MeFunction &func, LoopDesc &loop) const {
+  if (loop.inloopBB2exitBBs.find(loop.head->GetBBId()) != loop.inloopBB2exitBBs.end()) {
+    // if head and exit are the same bb, this must be a do-while loop
+    return true;
+  }
+  for (auto *succ : loop.head->GetSucc()) {
+    if (!loop.Has(*succ)) {
+      return false;
+    }
+  }
+  auto exitBB = func.GetCfg()->GetBBFromID(loop.inloopBB2exitBBs.begin()->first);
+  for (auto pred : exitBB->GetPred()) {
+    if (!loop.Has(*pred)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool LoopUnrollingExecutor::PredIsOutOfLoopBB(const MeFunction &func, LoopDesc &loop) const {
+  MeCFG *cfg = func.GetCfg();
+  for (auto bbID : loop.loopBBs) {
+    auto bb = cfg->GetBBFromID(bbID);
+    if (bb == loop.head) {
+      continue;
+    }
+    for (auto pred : bb->GetPred()) {
+      if (!loop.Has(*pred)) {
+        CHECK_FATAL(false, "pred is out of loop bb");
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool LoopUnrollingExecutor::IsCanonicalAndOnlyOneExitLoop(
+    const MeFunction &func, LoopDesc &loop,
+    const std::unordered_map<LoopDesc*, std::set<LoopDesc*>> &parentLoop) const {
+  // Only handle one nested loop.
+  if (parentLoop.find(&loop) != parentLoop.end() && ProfileCheck(func)) {
+    return false;
+  }
+  // Must be canonical loop and has one exit bb.
+  if (loop.inloopBB2exitBBs.size() != 1 || loop.inloopBB2exitBBs.begin()->second->size() != 1 ||
+      !loop.IsCanonicalLoop()) {
+    return false;
+  }
+  CHECK_NULL_FATAL(loop.preheader);
+  CHECK_NULL_FATAL(loop.latch);
+  auto headBB = loop.head;
+  auto exitBB = func.GetCfg()->GetBBFromID(loop.inloopBB2exitBBs.cbegin()->first);
+  CHECK_FATAL(headBB->GetPred().size() == 2, "head must has two preds");
+  if (!IsDoWhileLoop(func, loop)) {
+    if (enableDebug) {
+      LogInfo::MapleLogger() << "While-do loop"
+                             << "\n";
+    }
+    return false;
+  }
+  if (PredIsOutOfLoopBB(func, loop)) {
+    return false;
+  }
+  // latch bb only has one pred bb
+  if (loop.latch->GetPred().size() != 1 || loop.latch->GetPred(0) != exitBB) {
+    return false;
+  }
+  return true;
+}
+
+bool LoopUnrolling::LoopUnrollingWithConst(uint64 tripCount, bool onlyFully) {
+  if (tripCount == kInvalidTripCount) {
+    if (LoopUnrollingExecutor::enableDebug) {
+      LogInfo::MapleLogger() << "tripCount is invalid"
+                             << "\n";
+    }
+    return false;
+  }
+  if (LoopUnrollingExecutor::enableDebug) {
+    LogInfo::MapleLogger() << "start unrolling with const"
+                           << "\n";
+    LogInfo::MapleLogger() << "tripCount: " << tripCount << "\n";
+  }
+  if (LoopUnrollingExecutor::enableDebug) {
+    irMap->Dump();
+    func->IsIRProfValid() ? func->GetCfg()->DumpToFile("cfgIncludeFreqInfobeforLoopUnrolling", false, true)
+                          : func->GetCfg()->DumpToFile("cfgbeforLoopUnrolling" + std::to_string(loop->head->GetBBId()));
+  }
+  // fully unroll
+  ReturnKindOfFullyUnroll returnKind = LoopFullyUnroll(static_cast<int64>(tripCount));
+  if (returnKind == LoopUnrolling::kCanNotSplitCondGoto) {
+    return false;
+  }
+  if (returnKind == LoopUnrolling::kCanFullyUnroll) {
+    if (LoopUnrollingExecutor::enableDebug) {
+      LogInfo::MapleLogger() << "fully unrolling"
+                             << "\n";
+    }
+    if (LoopUnrollingExecutor::enableDebug) {
+      irMap->Dump();
+      func->IsIRProfValid()
+          ? func->GetCfg()->DumpToFile("cfgIncludeFreqInfoafterLoopFullyUnrolling", false, true)
+          : func->GetCfg()->DumpToFile("cfgafterLoopFullyUnrolling" + std::to_string(loop->head->GetBBId()));
+    }
+    return true;
+  }
+  if (onlyFully) {
+    return false;
+  }
+  // partial unroll with const
+  if (LoopPartialUnrollWithConst(tripCount)) {
+    if (LoopUnrollingExecutor::enableDebug) {
+      LogInfo::MapleLogger() << "partial unrolling with const"
+                             << "\n";
+    }
+    if (LoopUnrollingExecutor::enableDebug) {
+      irMap->Dump();
+      func->IsIRProfValid() ? func->GetCfg()->DumpToFile("cfgIncludeFreqInfoafterLoopPartialWithConst", false, true)
+                            : func->GetCfg()->DumpToFile("cfgafterLoopPartialWithConstUnrolling");
+    }
+    return true;
+  }
+  return false;
+}
+
+void LoopUnrollingExecutor::ExecuteLoopUnrolling(MeFunction &func, MeIRMap &irMap,
+                                                 std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &cands,
+                                                 IdentifyLoops &meLoop, const MapleAllocator &alloc) {
+  if (enableDebug) {
+    LogInfo::MapleLogger() << func.GetName() << "\n";
+  }
+  std::unordered_map<LoopDesc*, std::set<LoopDesc*>> parentLoop;
+  // Do loop unrolling only when the function is hot in profile,
+  // or we only apply fully unrolling on those small loops.
+  if (!ProfileCheck(func)) {
+    if (func.GetMIRModule().IsJavaModule()) {
+      // not apply on java
+      return;
+    }
+    for (auto loop : meLoop.GetMeLoops()) {
+      if (!IsCanonicalAndOnlyOneExitLoop(func, *loop, parentLoop)) {
+        continue;
+      }
+      LoopScalarAnalysisResult sa(irMap, loop);
+      LoopUnrolling loopUnrolling(func, *loop, irMap, alloc, cands);
+      if (func.GetCfg()->UpdateCFGFreq()) {
+        loopUnrolling.SetInstrumentProf(true);
+      }
+      uint64 tripCount = 0;
+      CRNode *conditionCRNode = nullptr;
+      CR *itCR = nullptr;
+      TripCountType type = sa.ComputeTripCount(func, tripCount, conditionCRNode, itCR);
+      if (type == kConstCR) {
+        if (loopUnrolling.LoopUnrollingWithConst(tripCount, true)) {
+          isCFGChange = true;
+        }
+      }
+    }
+    return;
+  }
+  SetNestedLoop(meLoop, parentLoop);
+  uint32 i = 0;
+  for (auto loop : meLoop.GetMeLoops()) {
+    if (!IsCanonicalAndOnlyOneExitLoop(func, *loop, parentLoop)) {
+      continue;
+    }
+    LoopScalarAnalysisResult sa(irMap, loop);
+    LoopUnrolling loopUnrolling(func, *loop, irMap, alloc, cands);
+    uint64 tripCount = 0;
+    CRNode *conditionCRNode = nullptr;
+    CR *itCR = nullptr;
+    TripCountType type = sa.ComputeTripCount(func, tripCount, conditionCRNode, itCR);
+    if (type == kConstCR) {
+      if (loopUnrolling.LoopUnrollingWithConst(tripCount)) {
+        isCFGChange = true;
+      }
+    } else if ((type == kVarCR || type == kVarCondition) && itCR->GetOpndsSize() == kOperandNum &&
+               // Will create stmt : tripCount = (n - start) / stride, so the stride must not be zero.
+               itCR->GetOpnd(1)->GetCRType() == kCRConstNode &&
+               static_cast<CRConstNode*>(itCR->GetOpnd(1))->GetConstValue() != 0) {
+      if (loopUnrolling.LoopPartialUnrollWithVar(*itCR, *conditionCRNode, i)) {
+        isCFGChange = true;
+      }
+      ++i;
+    }
+  }
+}
+
+void MELoopUnrolling::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MELoopUnrolling::PhaseRun(maple::MeFunction &f) {
+  IdentifyLoops *meLoop = GET_ANALYSIS(MELoopAnalysis, f);
+  if (meLoop == nullptr) {
+    return false;
+  }
+  auto *loopunrollMemPool = GetPhaseMemPool();
+  MapleAllocator loopUnrollingAlloc = MapleAllocator(loopunrollMemPool);
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> cands((std::less<OStIdx>()));
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_NULL_FATAL(irMap);
+  if (DEBUGFUNC_NEWPM(f)) {
+    f.GetCfg()->DumpToFile("beforeloopunrolling", false);
+  }
+  LoopUnrollingExecutor loopUnrollingExe = LoopUnrollingExecutor(*loopunrollMemPool);
+  loopUnrollingExe.ExecuteLoopUnrolling(f, *irMap, cands, *meLoop, loopUnrollingAlloc);
+  if (loopUnrollingExe.IsCFGChange()) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+    auto dom = FORCE_EXEC(MEDominance)->GetDomResult();
+    MeSSAUpdate ssaUpdate(f, *f.GetMeSSATab(), *dom, cands);
+    ssaUpdate.Run();
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MELoopAnalysis::id);
+    if (f.GetCfg()->UpdateCFGFreq() && f.GetCfg()->DumpIRProfileFile()) {
+      f.GetCfg()->DumpToFile("after-meloopunroll", false, true);
+    }
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    f.GetCfg()->DumpToFile("afterloopunrolling", false);
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_lower_globals.cpp b/src/mapleall/maple_me/src/me_lower_globals.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0cd1afe6b507dea661c244085497e69ab9c4b5ee
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_lower_globals.cpp
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_lower_globals.h"
+
+// the dassign/dread of global or static variables are lowered into
+// iassign/iread to expose the addrof.  The inserted addrof is always of fieldID
+// 0 to reduce the number of registers needed for storing addresses after the
+// addrof's are allocated to pregs.  The fieldID's thus reside in the iassign's
+// and iread's.
+//
+// By the same token, an addrof with non-zero field id is also lowered into
+// iaddrof with same field id whose operand is addrof with 0 field id.
+//
+// call and callassigned are lowered into icall/icallassigned and addroffunc.
+// The addroffunc is inserted as the extra first operand and the
+// call/callassinged is renamed to icall/icallassigned.
+namespace maple {
+void MeLowerGlobals::LowerGlobalDreads(MeStmt &stmt, MeExpr &expr) {
+  switch (expr.GetMeOp()) {
+    case kMeOpOp: {
+      auto &meOpExpr = static_cast<OpMeExpr&>(expr);
+      for (size_t i = 0; i < kOperandNumTernary; ++i) {
+        MeExpr *opnd = meOpExpr.GetOpnd(i);
+        if (opnd != nullptr) {
+          LowerGlobalDreads(stmt, *opnd);
+        }
+      }
+      break;
+    }
+    case kMeOpNary: {
+      auto &naryMeExpr = static_cast<NaryMeExpr&>(expr);
+      MapleVector<MeExpr*> &opnds = naryMeExpr.GetOpnds();
+      for (auto it = opnds.begin(); it != opnds.end(); ++it) {
+        LowerGlobalDreads(stmt, **it);
+      }
+      break;
+    }
+    case kMeOpIvar: {
+      auto &ivarMeExpr = static_cast<IvarMeExpr&>(expr);
+      LowerGlobalDreads(stmt, *ivarMeExpr.GetBase());
+      break;
+    }
+    case kMeOpVar: {
+      auto &varExpr = static_cast<VarMeExpr&>(expr);
+      OriginalSt *ost = varExpr.GetOst();
+      if (ost->IsLocal()) {
+        break;
+      }
+      // lower to ivar to expose addrof
+      OriginalSt *baseOst = ost;
+      if (ost->GetFieldID() != 0) {
+        PUIdx puIdx = func.GetMirFunc()->GetPuidx();
+        baseOst = ssaTable->FindOrCreateSymbolOriginalSt(*ost->GetMIRSymbol(), puIdx, 0);
+      }
+      AddrofMeExpr tmpAddrofMeExpr(-1, PTY_ptr, baseOst);
+      auto *addrofExpr = static_cast<AddrofMeExpr*>(irMap->HashMeExpr(tmpAddrofMeExpr));
+      MIRPtrType ptrType(baseOst->GetTyIdx(), PTY_ptr);
+      if (ost->IsVolatile() || ost->HasOneElemSimdAttr()) {
+        TypeAttrs attrs;
+        if (ost->IsVolatile()) {
+          attrs.SetAttr(ATTR_volatile);
+        }
+        if (ost->HasOneElemSimdAttr()) {
+          attrs.SetAttr(ATTR_oneelem_simd);
+        }
+        ptrType.SetTypeAttrs(attrs);
+      }
+      TyIdx addrTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+      auto *ivarExpr = static_cast<IvarMeExpr*>(irMap->CreateIvarMeExpr(varExpr, addrTyIdx, *addrofExpr));
+      (void)irMap->ReplaceMeExprStmt(stmt, varExpr, *ivarExpr);
+      break;
+    }
+    case kMeOpAddrof: {
+      auto &addrofExpr = static_cast<AddrofMeExpr&>(expr);
+      if (addrofExpr.GetFieldID() == 0) {
+        break;
+      }
+      OriginalSt *ost = addrofExpr.GetOst();
+      if (ost->IsLocal()) {
+        break;
+      }
+      // lower to iaddrof to expose addrof with 0 fieldID
+      PUIdx puIdx = func.GetMirFunc()->GetPuidx();
+      OriginalSt *baseOst = ssaTable->FindOrCreateSymbolOriginalSt(*ost->GetMIRSymbol(),
+          func.GetMirFunc()->GetPuidx(), 0);
+      MeExpr *newAddrofExpr = irMap->CreateAddrofMeExprFromSymbol(*ost->GetMIRSymbol(), puIdx);
+      MIRPtrType ptrType(baseOst->GetTyIdx(), PTY_ptr);
+      TyIdx addrTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+      ASSERT_NOT_NULL(irMap);
+      MeExpr *iaddrofExpr = irMap->CreateIaddrofMeExpr(addrofExpr.GetFieldID(), addrTyIdx, newAddrofExpr);
+      (void)irMap->ReplaceMeExprStmt(stmt, addrofExpr, *iaddrofExpr);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void MeLowerGlobals::Run() {
+  MeCFG *cfg = func.GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    for (auto &stmt : bb->GetMeStmts()) {
+      for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+        LowerGlobalDreads(stmt, *stmt.GetOpnd(i));
+      }
+      if (stmt.GetOp() == OP_dassign) {
+        auto &dass = static_cast<DassignMeStmt&>(stmt);
+        OriginalSt *ost = dass.GetVarLHS()->GetOst();
+        if (ost->IsLocal()) {
+          continue;
+        }
+        // lower to iassign to expose addrof
+        OriginalSt *baseOst = ost;
+        if (ost->GetFieldID() != 0) {
+          baseOst = ssaTable->FindOrCreateSymbolOriginalSt(*ost->GetMIRSymbol(),
+              func.GetMirFunc()->GetPuidx(), 0);
+        }
+        AddrofMeExpr addrofmeexpr(-1, PTY_ptr, baseOst);
+        AddrofMeExpr *addrof = static_cast<AddrofMeExpr *>(irMap->HashMeExpr(addrofmeexpr));
+
+        MIRPtrType ptrType(baseOst->GetTyIdx(), PTY_ptr);
+        if (ost->IsVolatile() || ost->HasOneElemSimdAttr()) {
+          TypeAttrs attrs;
+          if (ost->IsVolatile()) {
+            attrs.SetAttr(ATTR_volatile);
+          }
+          if (ost->HasOneElemSimdAttr()) {
+            attrs.SetAttr(ATTR_oneelem_simd);
+          }
+          ptrType.SetTypeAttrs(attrs);
+        }
+        TyIdx addrTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+        MeExpr *lhs = dass.GetLHS();
+        CHECK_NULL_FATAL(lhs);
+        auto *lhsIvar = static_cast<IvarMeExpr*>(irMap->CreateIvarMeExpr(*lhs, addrTyIdx, *addrof));
+        IassignMeStmt *iass = irMap->NewInPool<IassignMeStmt>(addrTyIdx, lhsIvar, dass.GetRHS(), &*dass.GetChiList());
+        iass->SetBB(bb);
+        iass->SetSrcPos(dass.GetSrcPosition());
+        iass->SetIsLive(true);
+
+        auto chiNode = irMap->New<ChiMeNode>(iass);
+        chiNode->SetLHS(dass.GetVarLHS());
+        dass.GetVarLHS()->SetDefBy(kDefByChi);
+        dass.GetVarLHS()->SetDefChi(*chiNode);
+
+        auto zeroVersionVar = irMap->GetOrCreateZeroVersionVarMeExpr(*ost);
+        chiNode->SetRHS(static_cast<ScalarMeExpr*>(zeroVersionVar));
+        iass->GetChiList()->insert(std::make_pair(ost->GetIndex(), chiNode));
+        auto chiList = dass.GetChiList();
+        iass->GetChiList()->insert(chiList->cbegin(), chiList->cend());
+        for (auto &ostIdx2ChiNode : std::as_const(*iass->GetChiList())) {
+          auto *chi = ostIdx2ChiNode.second;
+          chi->SetBase(iass);
+        }
+
+        bb->ReplaceMeStmt(&stmt, iass);
+      } else if (stmt.GetOp() == OP_call || stmt.GetOp() == OP_callassigned) {
+        // don't do this if current function is in libcore-all
+        if (!MeOption::optDirectCall) {
+          continue;
+        }
+        std::string name = namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr);
+        auto strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(name);
+        if (GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx) != nullptr) {
+          continue;
+        }
+        auto &callStmt = static_cast<CallMeStmt&>(stmt);
+        MIRFunction &callee = callStmt.GetTargetFunction();
+        if (!callee.IsJava() && callee.GetBaseClassName().empty()) {
+          continue;  // not a java callee
+        }
+        MeExpr *addroffuncExpr = irMap->CreateAddroffuncMeExpr(callee.GetPuidx());
+        auto insertpos = callStmt.GetOpnds().begin();
+        callStmt.InsertOpnds(insertpos, addroffuncExpr);
+        IcallMeStmt *icallStmt = nullptr;
+        if (func.GetMIRModule().IsCModule()) {
+          icallStmt = irMap->NewInPool<IcallMeStmt>(stmt.GetOp() == OP_call ? OP_icallproto : OP_icallprotoassigned);
+        } else {
+          icallStmt = irMap->NewInPool<IcallMeStmt>(stmt.GetOp() == OP_call ? OP_icall : OP_icallassigned);
+        }
+        icallStmt->SetIsLive(callStmt.GetIsLive());
+        icallStmt->SetSrcPos(callStmt.GetSrcPosition());
+        for (MeExpr *o : callStmt.GetOpnds()) {
+          icallStmt->PushBackOpnd(o);
+        }
+        icallStmt->GetMuList()->insert(callStmt.GetMuList()->cbegin(), callStmt.GetMuList()->cend());
+        icallStmt->GetChiList()->insert(callStmt.GetChiList()->cbegin(), callStmt.GetChiList()->cend());
+        if (func.GetMIRModule().IsCModule()) {
+          icallStmt->SetRetTyIdx(callee.GetMIRFuncType()->GetTypeIndex());
+        } else {
+          icallStmt->SetRetTyIdx(callee.GetReturnTyIdx());
+        }
+        if (stmt.GetOp() != OP_call) {
+          if (callStmt.NeedDecref()) {
+            icallStmt->EnableNeedDecref();
+          } else {
+            icallStmt->DisableNeedDecref();
+          }
+          if (callStmt.NeedIncref()) {
+            icallStmt->EnableNeedIncref();
+          } else {
+            icallStmt->DisableNeedIncref();
+          }
+          icallStmt->GetMustDefList()->assign(callStmt.GetMustDefList()->begin(), callStmt.GetMustDefList()->end());
+          auto *mustDefList = icallStmt->GetMustDefList();
+          if (mustDefList != nullptr) {
+            for (auto &mustDef : *mustDefList) {
+              mustDef.SetBase(icallStmt);
+            }
+          }
+        }
+        bb->ReplaceMeStmt(&stmt, icallStmt);
+      }
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_may2dassign.cpp b/src/mapleall/maple_me/src/me_may2dassign.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b60de326ee40c19b2b0eb4d57be5be8fd82e20d2
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_may2dassign.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_may2dassign.h"
+
+// this phase converts all maydassign back to dassign
+namespace maple {
+void May2Dassign::DoIt() {
+  MeCFG *cfg = func.GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    for (auto &stmt : bb->GetMeStmts()) {
+      if (stmt.GetOp() != OP_maydassign) {
+        continue;
+      }
+      auto &mass = static_cast<MaydassignMeStmt&>(stmt);
+      // chiList for Maydassign has only 1 element
+      CHECK_FATAL(!mass.GetChiList()->empty(), "chiList is empty in DoIt");
+      VarMeExpr *theLhs = static_cast<VarMeExpr *>(mass.GetChiList()->cbegin()->second->GetLHS());
+      ASSERT(mass.GetMayDassignSym() == theLhs->GetOst(),
+             "MeDoMay2Dassign: cannot find maydassign lhs");
+      auto *dass = static_cast<DassignMeStmt*>(irMap->CreateAssignMeStmt(*theLhs, *mass.GetRHS(), *bb));
+      dass->SetNeedDecref(mass.NeedDecref());
+      dass->SetNeedIncref(mass.NeedIncref());
+      dass->SetWasMayDassign(true);
+      dass->SetChiList(*mass.GetChiList());
+      dass->GetChiList()->clear();
+      bb->ReplaceMeStmt(&mass, dass);
+    }
+  }
+}
+
+void MEMay2Dassign::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MEMay2Dassign::PhaseRun(maple::MeFunction &f) {
+  May2Dassign may2Dassign(f);
+  may2Dassign.DoIt();
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_merge_stmts.cpp b/src/mapleall/maple_me/src/me_merge_stmts.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..59b44d7b75e649ba9debb28929ca9b0ceeea099c
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_merge_stmts.cpp
@@ -0,0 +1,674 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_merge_stmts.h"
+#include "me_irmap.h"
+#include "mpl_options.h"
+
+namespace maple {
+int32 MergeStmts::GetStructFieldBitSize(const MIRStructType *structType, FieldID fieldID) {
+  TyIdx fieldTypeIdx = structType->GetFieldTyIdx(fieldID);
+  MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTypeIdx);
+  uint32 fieldBitSize;
+  if (fieldType->GetKind() == kTypeBitField) {
+    fieldBitSize = static_cast<MIRBitFieldType*>(fieldType)->GetFieldSize();
+  } else {
+    fieldBitSize = static_cast<uint32>(fieldType->GetSize() * 8);
+  }
+  return fieldBitSize;
+}
+
+int32 MergeStmts::GetPointedTypeBitSize(TyIdx ptrTypeIdx) {
+  MIRPtrType *ptrMirType = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTypeIdx));
+  MIRType *PointedMirType = ptrMirType->GetPointedType();
+  return static_cast<int32>(PointedMirType->GetSize() * 8);
+}
+
+// Candidate stmts LHS must cover contiguous memory and RHS expr must be const
+void MergeStmts::mergeIassigns(vOffsetStmt& iassignCandidates) {
+  if (iassignCandidates.empty() || iassignCandidates.size() == 1) {
+    return;
+  }
+
+  std::sort(iassignCandidates.begin(), iassignCandidates.end());
+
+  auto numOfCandidates = iassignCandidates.size();
+  size_t startCandidate = 0;
+  size_t endCandidate = numOfCandidates - 1;
+  ASSERT(iassignCandidates[startCandidate].second->GetOp() == OP_iassign, "Candidate MeStmt must be Iassign");
+
+  while (startCandidate < endCandidate) {
+    TyIdx lhsTyIdx = static_cast<IassignMeStmt*>(iassignCandidates[startCandidate].second)->GetLHSVal()->GetTyIdx();
+    MIRPtrType *mirPtrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx));
+    MIRStructType *lhsStructType = static_cast<MIRStructType *>(mirPtrType->GetPointedType());
+
+    bool found = false;
+    size_t endIdx = 0;
+    int32 startBitOffset = iassignCandidates[startCandidate].first;
+
+    if ((startBitOffset & 0x7) != 0) {
+      startCandidate++;
+      continue;
+    }
+
+    // Find qualified candidates as many as possible
+    int32 targetBitSize;
+    for (size_t end = endCandidate; end > startCandidate; end--) {
+      FieldID endFieldID =  static_cast<IassignMeStmt*>(iassignCandidates[end].second)->GetLHSVal()->GetFieldID();
+      if (endFieldID == 0) {
+        TyIdx lhsPtrTypeIdx = static_cast<IassignMeStmt*>(iassignCandidates[end].second)->GetLHSVal()->GetTyIdx();
+        int32 lhsPointedTypeBitSize = GetPointedTypeBitSize(lhsPtrTypeIdx);
+        targetBitSize = iassignCandidates[end].first + lhsPointedTypeBitSize - startBitOffset;
+        if (targetBitSize == 16 || targetBitSize == 32 || targetBitSize == 64) {
+          int32 coveredBitSize = 0;
+          for (size_t i = startCandidate; i <= end; i++) {
+            TyIdx lhsPtrTypeIndex = static_cast<IassignMeStmt*>(iassignCandidates[i].second)->GetLHSVal()->GetTyIdx();
+            coveredBitSize += GetPointedTypeBitSize(lhsPtrTypeIndex);
+          }
+          if (coveredBitSize == targetBitSize) {
+            found = true;
+            endIdx = end;
+            break;
+          }
+        }
+      } else {
+        targetBitSize = iassignCandidates[end].first +
+            static_cast<int32>(GetStructFieldBitSize(lhsStructType, endFieldID)) - startBitOffset;
+        if (targetBitSize == 16 || targetBitSize == 32 || targetBitSize == 64) {
+          int32 coveredBitSize = 0;
+          for (size_t i = startCandidate; i <= end; i++) {
+            FieldID fieldID = static_cast<IassignMeStmt*>(iassignCandidates[i].second)->GetLHSVal()->GetFieldID();
+            coveredBitSize += GetStructFieldBitSize(lhsStructType, fieldID);
+          }
+          if (coveredBitSize == targetBitSize) {
+            found = true;
+            endIdx = end;
+            break;
+          }
+        }
+      }
+    }
+
+    if (found) {
+      // Concatenate constants
+      bool isBigEndian = MeOption::IsBigEndian();
+      size_t firstIdx = isBigEndian ? startCandidate : endIdx;
+
+      FieldID fieldID = static_cast<IassignMeStmt*>(iassignCandidates[firstIdx].second)->GetLHSVal()->GetFieldID();
+      int32 fieldBitSize;
+      if (fieldID == 0) {
+        TyIdx lhsPtrTypeIdx = static_cast<IassignMeStmt*>(iassignCandidates[firstIdx].second)->GetLHSVal()->GetTyIdx();
+        fieldBitSize = GetPointedTypeBitSize(lhsPtrTypeIdx);
+      } else {
+        fieldBitSize = GetStructFieldBitSize(lhsStructType, fieldID);
+      }
+      IassignMeStmt *lastIassignMeStmt = static_cast<IassignMeStmt*>(iassignCandidates[firstIdx].second);
+      ConstMeExpr *rhsLastIassignMeStmt = static_cast<ConstMeExpr*>(lastIassignMeStmt->GetOpnd(1));
+      uint64 fieldVal = static_cast<uint64>(rhsLastIassignMeStmt->GetExtIntValue());
+      uint64 combinedVal = (fieldVal << (64 - fieldBitSize)) >> (64 - fieldBitSize);
+
+      auto combineValue = [&](int stmtIdx) {
+        fieldID = static_cast<IassignMeStmt*>(iassignCandidates[stmtIdx].second)->GetLHSVal()->GetFieldID();
+        if (fieldID == 0) {
+          TyIdx lhsPtrTypeIdx = static_cast<IassignMeStmt*>(iassignCandidates[stmtIdx].second)->GetLHSVal()->GetTyIdx();
+          fieldBitSize = GetPointedTypeBitSize(lhsPtrTypeIdx);
+        } else {
+          fieldBitSize = GetStructFieldBitSize(lhsStructType, fieldID);
+        }
+        fieldVal = static_cast<uint64>(static_cast<ConstMeExpr*>(
+            static_cast<IassignMeStmt*>(iassignCandidates[stmtIdx].second)->GetOpnd(1))->GetExtIntValue());
+        fieldVal = (fieldVal << (64 - fieldBitSize)) >> (64 - fieldBitSize);
+        combinedVal = combinedVal << fieldBitSize | fieldVal;
+      };
+
+      if (isBigEndian) {
+        for (int stmtIdx = static_cast<int>(startCandidate) + 1; stmtIdx <= static_cast<int>(endIdx); ++stmtIdx) {
+          combineValue(stmtIdx);
+        }
+      } else {
+        for (int stmtIdx = static_cast<int>(endIdx) - 1; stmtIdx >= static_cast<int>(startCandidate); --stmtIdx) {
+          combineValue(stmtIdx);
+        }
+      }
+
+      // Iassignoff is NOT part of MeStmt yet
+      IassignMeStmt *firstIassignStmt = static_cast<IassignMeStmt*>(iassignCandidates[startCandidate].second);
+      PrimType newValType = (targetBitSize == 16) ? PTY_u16 : ((targetBitSize == 32) ? PTY_u32 : PTY_u64);
+      MeExpr *newVal = func.GetIRMap()->CreateIntConstMeExpr(static_cast<int64>(combinedVal), newValType);
+      firstIassignStmt->SetRHS(newVal);
+      firstIassignStmt->SetEmitIassignoff(true);
+      firstIassignStmt->SetOmitEmit(false);
+      // Mark deletion on the rest of merged stmts
+      BB *bb = firstIassignStmt->GetBB();
+      for (size_t canIdx = startCandidate + 1; canIdx <= endIdx; canIdx++) {
+        IassignMeStmt *removedIassignStmt = static_cast<IassignMeStmt*>(iassignCandidates[canIdx].second);
+        removedIassignStmt->SetEmitIassignoff(false);
+        removedIassignStmt->SetOmitEmit(true);
+        bb->RemoveMeStmt(removedIassignStmt);
+      }
+      startCandidate = endIdx + 1;
+    } else {
+      startCandidate++;
+    }
+  }
+}
+
+// Candidate stmts LHS must cover contiguous memory and RHS expr must be const
+void MergeStmts::mergeDassigns(vOffsetStmt& dassignCandidates) {
+  if (dassignCandidates.empty() || dassignCandidates.size() == 1) {
+    return;
+  }
+
+  sort(dassignCandidates.begin(), dassignCandidates.end());
+
+  size_t numOfCandidates = dassignCandidates.size();
+  size_t startCandidate = 0;
+  size_t endCandidate = numOfCandidates - 1;
+  ASSERT(dassignCandidates[startCandidate].second->GetOp() == OP_dassign, "Candidate MeStmt must be Dassign");
+
+  while (startCandidate < endCandidate) {
+    int32 startBitOffset = dassignCandidates[startCandidate].first;
+    if ((startBitOffset & 0x7) != 0) {
+      startCandidate++;
+      continue;
+    }
+    OriginalSt *lhsOrigStStart = static_cast<DassignMeStmt*>(
+        dassignCandidates[startCandidate].second)->GetLHS()->GetOst();
+    int32 lhsFieldBitOffsetStart = lhsOrigStStart->GetOffset().val;
+    MIRSymbol *lhsMIRStStart = lhsOrigStStart->GetMIRSymbol();
+    TyIdx lhsTyIdxStart = lhsMIRStStart->GetTyIdx();
+    MIRStructType *lhsStructTypeStart = static_cast<MIRStructType *>(
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdxStart));
+
+    // Find qualified candidates as many as possible
+    bool found = false;
+    int32 targetBitSize;
+    size_t endIdx = 0;
+
+    for (size_t end = endCandidate; end > startCandidate; end--) {
+      OriginalSt *lhsOrigStEnd = static_cast<DassignMeStmt*>(dassignCandidates[end].second)->GetVarLHS()->GetOst();
+      FieldID lhsFieldIDEnd = lhsOrigStEnd->GetFieldID();
+      targetBitSize = dassignCandidates[end].first + static_cast<int32>(GetStructFieldBitSize(
+          lhsStructTypeStart, lhsFieldIDEnd)) - lhsFieldBitOffsetStart;
+      if (targetBitSize == 16 || targetBitSize == 32 || targetBitSize == 64) {
+        int32 coveredBitSize = 0;
+        for (size_t i = startCandidate; i <= end; i++) {
+          OriginalSt *lhsOrigSt = static_cast<DassignMeStmt*>(dassignCandidates[i].second)->GetLHS()->GetOst();
+          FieldID lhsFieldID = lhsOrigSt->GetFieldID();
+          coveredBitSize += GetStructFieldBitSize(lhsStructTypeStart, lhsFieldID);
+        }
+        if (coveredBitSize == targetBitSize) {
+          found = true;
+          endIdx = end;
+          break;
+        }
+      }
+    }
+
+    if (found) {
+      // Concatenate constants
+      bool isBigEndian = MeOption::IsBigEndian();
+      size_t firstIdx = isBigEndian ? startCandidate : endIdx;
+
+      OriginalSt *lhsOrigStFirstIdx =
+          static_cast<DassignMeStmt*>(dassignCandidates[firstIdx].second)->GetLHS()->GetOst();
+      FieldID fieldIDEndIdx = lhsOrigStFirstIdx->GetFieldID();
+      int32 fieldBitSizeEndIdx = GetStructFieldBitSize(lhsStructTypeStart, fieldIDEndIdx);
+
+      uint64 fieldValIdx = static_cast<uint64>(static_cast<ConstMeExpr*>(static_cast<IassignMeStmt*>(
+          dassignCandidates[firstIdx].second)->GetRHS())->GetExtIntValue());
+
+      uint64 combinedVal = (fieldValIdx << (64 - fieldBitSizeEndIdx)) >> (64 - fieldBitSizeEndIdx);
+
+      auto combineValue = [&](int stmtIdx) {
+        OriginalSt *lhsOrigStStmtIdx =
+            static_cast<DassignMeStmt*>(dassignCandidates[stmtIdx].second)->GetVarLHS()->GetOst();
+        FieldID fieldIDStmtIdx = lhsOrigStStmtIdx->GetFieldID();
+        int32 fieldBitSizeStmtIdx = GetStructFieldBitSize(lhsStructTypeStart, fieldIDStmtIdx);
+        uint64 fieldValStmtIdx = static_cast<uint64>(static_cast<ConstMeExpr *>(
+            static_cast<DassignMeStmt *>(dassignCandidates[stmtIdx].second)->GetRHS())->GetExtIntValue());
+        fieldValStmtIdx = (fieldValStmtIdx << (64 - fieldBitSizeStmtIdx)) >> (64 - fieldBitSizeStmtIdx);
+        combinedVal = (combinedVal << fieldBitSizeStmtIdx) | fieldValStmtIdx;
+      };
+
+      if (isBigEndian) {
+        for (size_t stmtIdx = startCandidate + 1; stmtIdx <= endIdx; ++stmtIdx) {
+          combineValue(stmtIdx);
+        }
+      } else {
+        for (int stmtIdx = static_cast<int>(endIdx) - 1; stmtIdx >= static_cast<int>(startCandidate); --stmtIdx) {
+          combineValue(stmtIdx);
+        }
+      }
+
+      // Dassignoff is NOT part of MeStmt yet
+      DassignMeStmt *firstDassignStmt = static_cast<DassignMeStmt*>(dassignCandidates[startCandidate].second);
+      PrimType newValType = (targetBitSize == 16) ? PTY_u16 : ((targetBitSize == 32) ? PTY_u32 : PTY_u64) ;
+      MeExpr *newVal =  func.GetIRMap()->CreateIntConstMeExpr(static_cast<int64>(combinedVal), newValType);
+      firstDassignStmt->SetRHS(newVal);
+      firstDassignStmt->SetEmitDassignoff(true);
+      firstDassignStmt->SetOmitEmit(false);
+      // Mark deletion on the rest of merged stmts
+      BB *bb = firstDassignStmt->GetBB();
+      for (size_t canIdx = startCandidate + 1; canIdx <= endIdx; canIdx++) {
+        DassignMeStmt *removedDassignStmt = static_cast<DassignMeStmt*>(dassignCandidates[canIdx].second);
+        removedDassignStmt->SetEmitDassignoff(false);
+        removedDassignStmt->SetOmitEmit(true);
+        // Cancel emit instead of removal here
+        bb->RemoveMeStmt(removedDassignStmt);
+      }
+      startCandidate = endIdx + 1;
+    } else {
+      startCandidate++;
+    }
+  }
+}
+
+IassignMeStmt *MergeStmts::genSimdIassign(int32 offset, IvarMeExpr iVar1, IvarMeExpr iVar2,
+                                          const MapleMap<OStIdx, ChiMeNode *> &stmtChi, TyIdx ptrTypeIdx) {
+  MeIRMap *irMap = func.GetIRMap();
+  iVar1.SetOffset(offset);
+  IvarMeExpr *dstIvar = static_cast<IvarMeExpr *>(irMap->HashMeExpr(iVar1));
+  iVar2.SetOffset(offset);
+  IvarMeExpr *srcIvar = static_cast<IvarMeExpr *>(irMap->HashMeExpr(iVar2));
+  IassignMeStmt *xIassignStmt = irMap->CreateIassignMeStmt(ptrTypeIdx, *dstIvar, *srcIvar, stmtChi);
+  return xIassignStmt;
+}
+
+IassignMeStmt *MergeStmts::genSimdIassign(int32 offset, IvarMeExpr iVar, MeExpr &valMeExpr,
+                                          const MapleMap<OStIdx, ChiMeNode *> &stmtChi, TyIdx ptrTypeIdx) {
+  MeIRMap *irMap = func.GetIRMap();
+  iVar.SetOffset(offset);
+  IvarMeExpr *dstIvar = static_cast<IvarMeExpr *>(irMap->HashMeExpr(iVar));
+  IassignMeStmt *xIassignStmt = irMap->CreateIassignMeStmt(ptrTypeIdx, *dstIvar, valMeExpr, stmtChi);
+  return xIassignStmt;
+}
+
+void MergeStmts::genShortSet(MeExpr *dstMeExpr, uint32 offset, const MIRType *uXTgtMirType, RegMeExpr *srcRegMeExpr,
+                             IntrinsiccallMeStmt* memsetCallStmt,
+                             const MapleMap<OStIdx, ChiMeNode *> &memsetCallStmtChi) {
+  MIRType *uXTgtPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*uXTgtMirType, PTY_ptr);
+  IvarMeExpr iVarBase(&func.GetIRMap()->GetIRMapAlloc(), kInvalidExprID, uXTgtMirType->GetPrimType(),
+                      uXTgtPtrType->GetTypeIndex(), 0);
+  iVarBase.SetBase(dstMeExpr);
+  IassignMeStmt *xIassignStmt = genSimdIassign(offset, iVarBase, *srcRegMeExpr, memsetCallStmtChi,
+                                               uXTgtPtrType->GetTypeIndex());
+  memsetCallStmt->GetBB()->InsertMeStmtBefore(memsetCallStmt, xIassignStmt);
+  xIassignStmt->CopyInfo(*memsetCallStmt);
+}
+
+bool EnableSIMD(const int &length, bool needToBeMultiplyOfByte) {
+  constexpr int32 kSimdUpperThreshold = 128;
+  const int32 kSimdLowerThreshold = 64;
+  bool withinBound = length <= kSimdUpperThreshold && length >= kSimdLowerThreshold;
+  if (needToBeMultiplyOfByte) {
+    bool isAMultipleOfByte = length % 8 == 0;
+    return withinBound && isAMultipleOfByte;
+  } else {
+    return withinBound;
+  }
+}
+
+void MergeStmts::simdMemcpy(IntrinsiccallMeStmt* memcpyCallStmt) {
+  ASSERT(memcpyCallStmt->GetIntrinsic() == INTRN_C_memcpy, "The stmt is NOT intrinsic memcpy");
+
+  ConstMeExpr *lengthExpr = static_cast<ConstMeExpr*>(memcpyCallStmt->GetOpnd(2));
+  if (!lengthExpr || lengthExpr->GetMeOp() != kMeOpConst ||
+      lengthExpr->GetConstVal()->GetKind() != kConstInt) {
+    return;
+  }
+  int32 copyLength = static_cast<int32>(lengthExpr->GetExtIntValue());
+  // No need to perform simd if the copyLength is too small
+  if (!EnableSIMD(copyLength, true)) {
+    return;
+  }
+
+  int32 numOf16Byte = copyLength / 16;
+  int32 numOf8Byte = (copyLength % 16) / 8;
+  int32 offset8Byte = copyLength - (copyLength % 16);
+  /* Leave following cases for future
+  int32 numOf4Byte = (copyLength % 8) / 4;
+  int32 offset4Byte = copyLength - (copyLength % 8);
+  int32 numOf2Byte = (copyLength % 4) / 2;
+  int32 offset2Byte = copyLength - (copyLength % 4);
+  int32 numOf1Byte = (copyLength % 2);
+  int32 offset1Byte = copyLength - (copyLength % 2);
+  */
+  MeExpr *dstMeExpr = memcpyCallStmt->GetOpnd(0);
+  MeExpr *srcMeExpr = memcpyCallStmt->GetOpnd(1);
+  MapleMap<OStIdx, ChiMeNode *>  *memcpyCallStmtChi = memcpyCallStmt->GetChiList();
+  MIRType *v16uint8MirType = GlobalTables::GetTypeTable().GetV16UInt8();
+  MIRType *v16uint8PtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*v16uint8MirType, PTY_ptr);
+
+  IvarMeExpr tmpIvar1(&func.GetIRMap()->GetIRMapAlloc(), kInvalidExprID, PTY_v16u8, v16uint8PtrType->GetTypeIndex(), 0);
+  if (dstMeExpr->GetOp() != OP_regread) {
+    RegMeExpr *addrRegMeExpr = func.GetIRMap()->CreateRegMeExpr(PTY_a64);
+    MeStmt *addrRegAssignMeStmt = func.GetIRMap()->CreateAssignMeStmt(
+        *addrRegMeExpr, *dstMeExpr, *memcpyCallStmt->GetBB());
+    memcpyCallStmt->GetBB()->InsertMeStmtBefore(memcpyCallStmt, addrRegAssignMeStmt);
+    addrRegAssignMeStmt->CopyInfo(*memcpyCallStmt);
+    dstMeExpr = addrRegMeExpr;
+  }
+  tmpIvar1.SetBase(dstMeExpr);
+  IvarMeExpr tmpIvar2(&func.GetIRMap()->GetIRMapAlloc(), kInvalidExprID, PTY_v16u8, v16uint8PtrType->GetTypeIndex(), 0);
+  if (srcMeExpr->GetOp() != OP_regread) {
+    RegMeExpr *addrRegMeExpr = func.GetIRMap()->CreateRegMeExpr(PTY_a64);
+    MeStmt *addrRegAssignMeStmt = func.GetIRMap()->CreateAssignMeStmt(
+        *addrRegMeExpr, *srcMeExpr, *memcpyCallStmt->GetBB());
+    memcpyCallStmt->GetBB()->InsertMeStmtBefore(memcpyCallStmt, addrRegAssignMeStmt);
+    addrRegAssignMeStmt->CopyInfo(*memcpyCallStmt);
+    srcMeExpr = addrRegMeExpr;
+  }
+  tmpIvar2.SetBase(srcMeExpr);
+
+  for (int32 i = 0; i < numOf16Byte; i++) {
+    IassignMeStmt *xIassignStmt = genSimdIassign(16 * i, tmpIvar1, tmpIvar2, *memcpyCallStmtChi,
+                                                 v16uint8PtrType->GetTypeIndex());
+    memcpyCallStmt->GetBB()->InsertMeStmtBefore(memcpyCallStmt, xIassignStmt);
+    xIassignStmt->CopyInfo(*memcpyCallStmt);
+  }
+
+  if (numOf8Byte != 0) {
+    MIRType *v8uint8MirType = GlobalTables::GetTypeTable().GetV8UInt8();
+    MIRType *v8uint8PtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*v8uint8MirType, PTY_ptr);
+    IvarMeExpr tmpIvar3(&func.GetIRMap()->GetIRMapAlloc(), kInvalidExprID, PTY_v8u8, v8uint8PtrType->GetTypeIndex(), 0);
+    tmpIvar3.SetBase(dstMeExpr);
+    IvarMeExpr tmpIvar4(&func.GetIRMap()->GetIRMapAlloc(), kInvalidExprID, PTY_v8u8, v8uint8PtrType->GetTypeIndex(), 0);
+    tmpIvar4.SetBase(srcMeExpr);
+    IassignMeStmt *xIassignStmt = genSimdIassign(offset8Byte, tmpIvar3, tmpIvar4, *memcpyCallStmtChi,
+                                                 v8uint8PtrType->GetTypeIndex());
+    memcpyCallStmt->GetBB()->InsertMeStmtBefore(memcpyCallStmt, xIassignStmt);
+    xIassignStmt->CopyInfo(*memcpyCallStmt);
+  }
+
+  // Remove memcpy stmt
+  if (numOf8Byte != 0 || numOf16Byte != 0) {
+    BB *bb = memcpyCallStmt->GetBB();
+    bb->RemoveMeStmt(memcpyCallStmt);
+  }
+}
+
+void MergeStmts::simdMemset(IntrinsiccallMeStmt *memsetCallStmt) {
+  ASSERT(memsetCallStmt->GetIntrinsic() == INTRN_C_memset, "The stmt is NOT intrinsic memset");
+
+  ConstMeExpr *numExpr = static_cast<ConstMeExpr*>(memsetCallStmt->GetOpnd(2));
+  if (!numExpr || numExpr->GetMeOp() != kMeOpConst ||
+      numExpr->GetConstVal()->GetKind() != kConstInt) {
+    return;
+  }
+  int32 setLength = static_cast<int32>(numExpr->GetExtIntValue());
+  // It seems unlikely that setLength is just a few bytes long
+  if (!EnableSIMD(setLength, false)) {
+    return;
+  }
+  int32 numOf16Byte = setLength / 16;
+  int32 numOf8Byte = (setLength % 16) / 8;
+  int32 offset8Byte = setLength - (setLength % 16);
+  int32 numOf4Byte = (setLength % 8) / 4;
+  int32 offset4Byte = setLength - (setLength % 8);
+  int32 numOf2Byte = (setLength % 4) / 2;
+  int32 offset2Byte = setLength - (setLength % 4);
+  int32 numOf1Byte = (setLength % 2);
+  int32 offset1Byte = setLength - (setLength % 2);
+  MeExpr *dstMeExpr = memsetCallStmt->GetOpnd(0);
+  MeExpr *fillValMeExpr = memsetCallStmt->GetOpnd(1);
+  MapleMap<OStIdx, ChiMeNode *>  *memsetCallStmtChi = memsetCallStmt->GetChiList();
+  MIRType *v16u8MirType = GlobalTables::GetTypeTable().GetV16UInt8();
+  MIRType *v16u8PtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*v16u8MirType, PTY_ptr);
+
+  auto alloc = func.GetIRMap()->GetIRMapAlloc();
+  IvarMeExpr tmpIvar(&alloc, kInvalidExprID, PTY_v16u8, v16u8PtrType->GetTypeIndex(), 0);
+  if (dstMeExpr->GetOp() != OP_regread) {
+    RegMeExpr *addrRegMeExpr = func.GetIRMap()->CreateRegMeExpr(PTY_a64);
+    MeStmt *addrRegAssignMeStmt = func.GetIRMap()->CreateAssignMeStmt(
+        *addrRegMeExpr, *dstMeExpr, *memsetCallStmt->GetBB());
+    memsetCallStmt->GetBB()->InsertMeStmtBefore(memsetCallStmt, addrRegAssignMeStmt);
+    addrRegAssignMeStmt->CopyInfo(*memsetCallStmt);
+    dstMeExpr = addrRegMeExpr;
+  }
+  tmpIvar.SetBase(dstMeExpr);
+
+  RegMeExpr *dupRegMeExpr = func.GetIRMap()->CreateRegMeExpr(PTY_v16u8);
+  NaryMeExpr expr(&alloc, kInvalidExprID, OP_intrinsicop, PTY_v16u8, 1, TyIdx(0), INTRN_vector_from_scalar_v16u8,
+                  false);
+  expr.PushOpnd(fillValMeExpr);
+  auto dupValMeExpr = func.GetIRMap()->CreateNaryMeExpr(expr);
+  MeStmt *dupRegAssignMeStmt = func.GetIRMap()->CreateAssignMeStmt(
+      *dupRegMeExpr, *dupValMeExpr, *memsetCallStmt->GetBB());
+  memsetCallStmt->GetBB()->InsertMeStmtBefore(memsetCallStmt, dupRegAssignMeStmt);
+  dupRegAssignMeStmt->CopyInfo(*memsetCallStmt);
+
+  for (int32 i = 0; i < numOf16Byte; i++) {
+    IassignMeStmt *xIassignStmt = genSimdIassign(16 * i, tmpIvar, *dupRegMeExpr, *memsetCallStmtChi,
+                                                 v16u8PtrType->GetTypeIndex());
+    memsetCallStmt->GetBB()->InsertMeStmtBefore(memsetCallStmt, xIassignStmt);
+    xIassignStmt->CopyInfo(*memsetCallStmt);
+  }
+
+  bool hasRemainder = numOf1Byte != 0 || numOf2Byte != 0 ||
+                      numOf4Byte != 0 || numOf8Byte != 0;
+  if (hasRemainder) {
+    RegMeExpr *u64RegMeExpr = func.GetIRMap()->CreateRegMeExpr(PTY_u64);
+    OpMeExpr *u64BitsMeOpExpr =
+        static_cast<OpMeExpr *>(func.GetIRMap()->CreateMeExprUnary(OP_extractbits, PTY_u64, *dupRegMeExpr));
+    u64BitsMeOpExpr->SetOpndType(PTY_u64);
+    u64BitsMeOpExpr->SetBitsOffSet(0);
+    u64BitsMeOpExpr->SetBitsSize(64);
+    MeStmt *u64RegAssignMeStmt = func.GetIRMap()->CreateAssignMeStmt(
+        *u64RegMeExpr, *u64BitsMeOpExpr, *memsetCallStmt->GetBB());
+    memsetCallStmt->GetBB()->InsertMeStmtBefore(memsetCallStmt, u64RegAssignMeStmt);
+    u64RegAssignMeStmt->CopyInfo(*memsetCallStmt);
+
+    if (numOf8Byte != 0) {
+      MIRType *u64MirType = GlobalTables::GetTypeTable().GetUInt64();
+      genShortSet(dstMeExpr, static_cast<uint32>(offset8Byte), u64MirType, u64RegMeExpr, memsetCallStmt,
+                  *memsetCallStmtChi);
+    }
+    if (numOf4Byte != 0) {
+      MIRType *u32MirType = GlobalTables::GetTypeTable().GetUInt32();
+      genShortSet(dstMeExpr, static_cast<uint32>(offset4Byte), u32MirType, u64RegMeExpr, memsetCallStmt,
+                  *memsetCallStmtChi);
+    }
+    if (numOf2Byte != 0) {
+      MIRType *u16MirType = GlobalTables::GetTypeTable().GetUInt16();
+      genShortSet(dstMeExpr, static_cast<uint32>(offset2Byte), u16MirType, u64RegMeExpr, memsetCallStmt,
+                  *memsetCallStmtChi);
+    }
+    if (numOf1Byte != 0) {
+      MIRType *u8MirType = GlobalTables::GetTypeTable().GetUInt8();
+      genShortSet(dstMeExpr, static_cast<uint32>(offset1Byte), u8MirType, u64RegMeExpr, memsetCallStmt,
+                  *memsetCallStmtChi);
+    }
+  }
+  // Remove memset stmt
+  if (hasRemainder || numOf16Byte != 0) {
+    BB *bb = memsetCallStmt->GetBB();
+    bb->RemoveMeStmt(memsetCallStmt);
+  }
+}
+
+// Merge assigns on consecutive struct fields into one assignoff
+// Or Simdize memset/memcpy
+void MergeStmts::MergeMeStmts() {
+  auto layoutBBs = func.GetLaidOutBBs();
+
+  for (BB *bb : layoutBBs) {
+    ASSERT(bb != nullptr, "Check bblayout phase");
+    std::queue<MeStmt*> candidateStmts;
+
+    // Identify consecutive (I/D)assign stmts
+    // Candidates of (I/D)assignment are grouped together and seperated by nullptr
+    MeStmts &meStmts = bb->GetMeStmts();
+    for (MeStmt &meStmt : meStmts) {
+      Opcode op = meStmt.GetOp();
+      switch (op) {
+        case OP_iassign: {
+          IassignMeStmt *iassignStmt = static_cast<IassignMeStmt *>(&meStmt);
+          TyIdx lhsTyIdx = iassignStmt->GetLHSVal()->GetTyIdx();
+          MIRPtrType *lhsMirPtrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx));
+          MIRType *lhsMirType = lhsMirPtrType->GetPointedType();
+          ConstMeExpr *rhsIassignStmt = static_cast<ConstMeExpr*>(iassignStmt->GetOpnd(1));
+          if (rhsIassignStmt->GetMeOp() != kMeOpConst ||
+              rhsIassignStmt->GetConstVal()->GetKind() != kConstInt) {
+            candidateStmts.push(nullptr);
+            break;
+          }
+
+          if (iassignStmt->GetLHSVal()->GetFieldID() == 0) {
+            // Grouping based on lhs base addresses
+            if (candidateStmts.empty() || candidateStmts.back() == nullptr) {
+              candidateStmts.push(&meStmt);
+            } else if (candidateStmts.back()->GetOp() == OP_iassign &&
+                       static_cast<IassignMeStmt*>(candidateStmts.back())->GetLHSVal()->GetFieldID() == 0 &&
+                       static_cast<IassignMeStmt*>(candidateStmts.back())->GetLHSVal()->GetBase() ==
+                       iassignStmt->GetLHSVal()->GetBase()) {
+              candidateStmts.push(&meStmt);
+            } else {
+              candidateStmts.push(nullptr);
+              candidateStmts.push(&meStmt);
+            }
+          } else {
+            // Grouping based on struct fields
+            if (!lhsMirType->IsMIRStructType()) {
+              candidateStmts.push(nullptr);
+            } else if (candidateStmts.empty() || candidateStmts.back() == nullptr) {
+              candidateStmts.push(&meStmt);
+            } else if (candidateStmts.back()->GetOp() == OP_iassign &&
+                       static_cast<IassignMeStmt*>(candidateStmts.back())->GetLHSVal()->GetTyIdx() == lhsTyIdx &&
+                       static_cast<IassignMeStmt*>(candidateStmts.back())->GetLHSVal()->GetBase() ==
+                           iassignStmt->GetLHSVal()->GetBase() &&
+                       static_cast<IassignMeStmt*>(candidateStmts.back())->GetLHSVal()->GetOffset() ==
+                           iassignStmt->GetLHSVal()->GetOffset()) {
+              candidateStmts.push(&meStmt);
+            } else {
+              candidateStmts.push(nullptr);
+              candidateStmts.push(&meStmt);
+            }
+          }
+          break;
+        }
+        case OP_dassign: {
+          DassignMeStmt *dassignStmt = static_cast<DassignMeStmt *>(&meStmt);
+          OriginalSt *lhsSt = dassignStmt->GetLHS()->GetOst();
+          MIRSymbol *lhsMirSt = lhsSt->GetMIRSymbol();
+          TyIdx lhsTyIdx = lhsMirSt->GetTyIdx();
+          MIRType *lhsMirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx);
+          ConstMeExpr *rhsDassignStmt = static_cast<ConstMeExpr*>(dassignStmt->GetRHS());
+          if (lhsSt->GetFieldID() == 0 ||
+              !lhsMirType->IsMIRStructType() ||
+              rhsDassignStmt->GetMeOp() != kMeOpConst ||
+              rhsDassignStmt->GetConstVal()->GetKind() != kConstInt) {
+            candidateStmts.push(nullptr);
+          } else if (candidateStmts.empty() || candidateStmts.back() == nullptr) {
+            candidateStmts.push(&meStmt);
+          } else if (candidateStmts.back()->GetOp() == OP_dassign &&
+              static_cast<DassignMeStmt*>(candidateStmts.back())->GetLHS()->GetOst()->GetMIRSymbol() == lhsMirSt) {
+            candidateStmts.push(&meStmt);
+          } else {
+            candidateStmts.push(nullptr);
+            candidateStmts.push(&meStmt);
+          }
+          break;
+        }
+        // Simdize intrinsic. SIMD should really be handled in CG
+        case OP_intrinsiccall: {
+          if (MeOption::generalRegOnly) {
+            break;  // avoid generate float point type if --genral-reg-only is enabled
+          }
+          IntrinsiccallMeStmt *intrinsicCallStmt = static_cast<IntrinsiccallMeStmt*>(&meStmt);
+          MIRIntrinsicID intrinsicCallID = intrinsicCallStmt->GetIntrinsic();
+          if (intrinsicCallID == INTRN_C_memcpy) {
+            candidateStmts.push(nullptr);
+            simdMemcpy(intrinsicCallStmt);
+          } else if (intrinsicCallID == INTRN_C_memset) {
+            candidateStmts.push(nullptr);
+            simdMemset(intrinsicCallStmt);
+          } else {
+            // More to come
+          }
+          break;
+        }
+        default: {
+          candidateStmts.push(nullptr);
+          break;
+        }
+      }
+    }
+
+    // Merge possible candidate (I/D)assign stmts
+    while (!candidateStmts.empty()) {
+      if (candidateStmts.front() == nullptr) {
+        candidateStmts.pop();
+        continue;
+      }
+      Opcode op = candidateStmts.front()->GetOp();
+      switch (op) {
+        case OP_iassign: {
+          vOffsetStmt iassignCandidates;
+          std::map<uint32, MeStmt*> uniqueCheck;
+          while (!candidateStmts.empty() && candidateStmts.front() != nullptr &&
+                 candidateStmts.front()->GetOp() == OP_iassign) {
+            IassignMeStmt *iassignStmt = static_cast<IassignMeStmt*>(candidateStmts.front());
+            IvarMeExpr *iVarIassignStmt = iassignStmt->GetLHSVal();
+
+            if (iVarIassignStmt->GetFieldID() == 0) {
+              int32 bitOffsetIVar = iVarIassignStmt->GetOffset() * 8;
+              // It is possible to have dup bitOffsetIVar for FieldID() == 0
+              if (uniqueCheck[bitOffsetIVar] != nullptr) {
+                bb->RemoveMeStmt(uniqueCheck[bitOffsetIVar]);
+              }
+              uniqueCheck[bitOffsetIVar] = iassignStmt;
+            } else {
+              TyIdx lhsTyIdx = iVarIassignStmt->GetTyIdx();
+              MIRPtrType *lhsMirPtrType =
+                static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx));
+              MIRStructType *lhsStructType = static_cast<MIRStructType *>(lhsMirPtrType->GetPointedType());
+              int64 fieldBitOffset = lhsStructType->GetBitOffsetFromBaseAddr(iVarIassignStmt->GetFieldID());
+              if (uniqueCheck[fieldBitOffset] != nullptr) {
+                bb->RemoveMeStmt(uniqueCheck[fieldBitOffset]);
+              }
+              uniqueCheck[fieldBitOffset] = candidateStmts.front();
+            }
+            candidateStmts.pop();
+          }
+          iassignCandidates.insert(iassignCandidates.begin(), uniqueCheck.begin(), uniqueCheck.end());
+          mergeIassigns(iassignCandidates);
+          break;
+        }
+        case OP_dassign: {
+          vOffsetStmt dassignCandidates;
+          std::map<int32, MeStmt*> uniqueCheck;
+          while (!candidateStmts.empty() && candidateStmts.front() != nullptr &&
+                 candidateStmts.front()->GetOp() == OP_dassign) {
+            OriginalSt *lhsOrigSt = static_cast<DassignMeStmt*>(candidateStmts.front())->GetLHS()->GetOst();
+            int32 fieldBitOffset = lhsOrigSt->GetOffset().val;
+            if (uniqueCheck[fieldBitOffset] != nullptr) {
+              bb->RemoveMeStmt(uniqueCheck[fieldBitOffset]);
+            }
+            uniqueCheck[fieldBitOffset] = candidateStmts.front();
+            candidateStmts.pop();
+          }
+          dassignCandidates.insert(dassignCandidates.begin(), uniqueCheck.begin(), uniqueCheck.end());
+          mergeDassigns(dassignCandidates);
+          break;
+        }
+        default: {
+          ASSERT(false, "NYI");
+          break;
+        }
+      }
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_obj_size.cpp b/src/mapleall/maple_me/src/me_obj_size.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c298359409d1774635e6cfeb35fdd9f498489242
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_obj_size.cpp
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_obj_size.h"
+#include "me_irmap_build.h"
+#include "me_dominance.h"
+
+namespace maple {
+constexpr int64 kBitsPerByte = 8; // 8 bits per byte
+constexpr size_t kNumOperands = 2;
+constexpr uint64 kInvalidDestSize = static_cast<uint64>(-1);
+constexpr char kMalloc[] = "malloc";
+constexpr char kSprintfChk[] = "__sprintf_chk";
+constexpr char kVsprintfChk[] = "__vsprintf_chk";
+
+const std::map<std::string, std::string> kReplacedFuncPairs {
+    {"__memcpy_chk", "memcpy"},
+    {"__memset_chk", "memset"},
+    {"__strncpy_chk", "strncpy"},
+    {"__strcpy_chk", "strcpy"},
+    {"__stpcpy_chk", "stpcpy"},
+    {"__strcat_chk", "strcat"},
+    {"__strncat_chk", "strncat"},
+    {"__mempcpy_chk", "mempcpy"},
+    {"__memmove_chk", "memmove"},
+    {"__sprintf_chk", "sprintf"},
+    {"__snprintf_chk", "snprintf"},
+    {"__vsprintf_chk", "vsprintf"},
+    {"__vsnprintf_chk", "vsnprintf"}
+};
+
+// Pair.first is the position of the src length information in the parameter list. If the position is -1,
+// no such information. Pair.second is the position of the dest length information in the parameter list.
+const std::map<std::string, std::pair<size_t, size_t>> kIndexOfSrcLength {
+    // Function definition reference :
+    // http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/libcman.html
+    //
+    // void * memcpy (void * dest, const void * src, size_t len)
+    // void * __memcpy_chk(void * dest, const void * src, size_t len, size_t destlen)
+    // The parameter destlen specifies the size of the object dest. If len exceeds destlen, the function shall abort,
+    // and the program calling it shall exit.
+    {"__memcpy_chk", {2, 3}},
+    // void * memset (void * dest, int c, size_t len)
+    // void * __memset_chk(void * dest, int c, size_t len, size_t destlen)
+    // The parameter destlen specifies the size of the object dest. If len exceeds destlen, the function shall abort,
+    // and the program calling it shall exit.
+    {"__memset_chk", {2, 3}},
+    // char * strncpy (char * s1, const char * s2, size_t n)
+    // char * __strncpy_chk(char * s1, const char * s2, size_t n, size_t s1len)
+    // The parameter s1len specifies the size of the object pointed to by s1.
+    {"__strncpy_chk", {2, 3}},
+    // char* strcpy(char * dest, const char * src)
+    // char * __strcpy_chk(char * dest, const char * src, size_t destlen)
+    // The parameter destlen specifies the size of the object pointed to by dest.
+    {"__strcpy_chk", {1, 2}},
+    // char *stpcpy(char * dest, const char * src)
+    // char * __stpcpy_chk(char * dest, const char * src, size_t destlen)
+    // The parameter destlen specifies the size of the object pointed to by dest.
+    {"__stpcpy_chk", {1, 2}},
+    // int vsprintf(char *s, const char *format, va_list arg)
+    // int __vsprintf_chk(char * s, int flag, size_t slen, const char * format, va_list args)
+    // The parameter slen specifies the size of the object pointed to by s. If its value is zero,
+    // the function shall abort and the program calling it shall exit.
+    {"__vsprintf_chk", {-1, 2}},
+    // int vsnprintf (char * s, size_t slen, const char * format, va_list arg)
+    // int __vsnprintf_chk(char * s, size_t maxlen, int flag, size_t slen, const char * format, va_list args)
+    // The parameter slen specifies the size of the object pointed to by s. If slen is less than maxlen,
+    // the function shall abort and the program calling it shall exit.
+    {"__vsnprintf_chk", {1, 3}},
+    // int snprintf (char * str, size_t strlen, const char * format, ...)
+    // int __snprintf_chk(char * str, size_t maxlen, int flag, size_t strlen, const char * format, ...)
+    // The parameter strlen specifies the size of the buffer str. If strlen is less than maxlen,
+    // the function shall abort, and the program calling it shall exit.
+    {"__snprintf_chk", {1, 3}},
+    // int sprintf(char *str, const char *format, ...)
+    // int __sprintf_chk(char * str, int flag, size_t strlen, const char * format, ...)
+    // The parameter strlen specifies the size of the string str. If strlen is zero,
+    // the function shall abort, and the program calling it shall exit.
+    {"__sprintf_chk", {-1, 2}},
+    // char *strcat(char * dest, const char * src)
+    // char * __strcat_chk(char * dest, const char * src, size_t destlen)
+    // The parameter destlen specifies the size of the object pointed to by dest
+    {"__strcat_chk", {1, 2}},
+    // char * strncat (char * s1, const char * s2, size_t n)
+    // char * __strncat_chk(char * s1, const char * s2, size_t n, size_t s1len)
+    // The parameter s1len specifies the size of the object pointed to by s1.
+    // N is maximum number of source to be appended.
+    {"__strncat_chk", {2, 3}},
+    // void *mempcpy(void * dest, const void * src, size_t len)
+    // void * __mempcpy_chk(void * dest, const void * src, size_t len, size_t destlen)
+    // The parameter destlen specifies the size of the object dest. If len exceeds destlen, the function shall abort,
+    // and the program calling it shall exit.
+    {"__mempcpy_chk", {2, 3}},
+    // void * memmove(void * dest, const void * src, size_t len)
+    // void * __memmove_chk(void * dest, const void * src, size_t len, size_t destlen)
+    // The parameter destlen specifies the size of the object dest. If len exceeds destlen,
+    // the function shall abort, and the program calling it shall exit.
+    {"__memmove_chk", {2, 3}},
+    // char *stpncpy(char * dest, const char * src, size_t n)
+    // char * __stpncpy_chk(char * dest, const char * src, size_t n, size_t destlen)
+    // The parameter destlen specifies the size of the object pointed to by dest. If n exceeds destlen,
+    // the function shall abort, and the program calling it shall exit.
+    {"__stpncpy_chk", {2, 3}}
+};
+
+void OBJSize::Execute() {
+  auto cfg = func.GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    if (*bIt == nullptr) {
+      continue;
+    }
+    for (auto &meStmt : (*bIt)->GetMeStmts()) {
+      if (meStmt.GetOp() == OP_intrinsiccallassigned) {
+        DealWithBuiltinObjectSize(**bIt, meStmt);
+      } else {
+        ComputeObjectSize(meStmt);
+      }
+    }
+  }
+}
+
+void OBJSize::ERRWhenSizeTypeIsInvalid(const MeStmt &meStmt) const {
+  auto srcPosition = meStmt.GetSrcPosition();
+  bool inlined = (srcPosition.GetInlinedLineNum() != 0);
+  auto fileNum = inlined ? srcPosition.GetInlinedFileNum() : srcPosition.FileNum();
+  const std::string &currFile = func.GetMIRModule().GetFileNameFromFileNum(fileNum);
+  auto lineNum = inlined ? srcPosition.GetInlinedLineNum() : srcPosition.LineNum();
+  FATAL(kLncFatal, "%s:%d: error: last argument of __builtin_object_size is not integer constant between 0 and 3",
+        currFile.c_str(), lineNum);
+}
+
+void OBJSize::DealWithBuiltinObjectSize(BB &bb, MeStmt &meStmt) {
+  auto &intrinsiccall = static_cast<IntrinsiccallMeStmt&>(meStmt);
+  if (intrinsiccall.GetIntrinsic() != INTRN_C___builtin_object_size) {
+    return;
+  }
+  auto *opnd1 = intrinsiccall.GetOpnd(1);
+  if (opnd1->GetMeOp() != kMeOpConst) {
+    ERRWhenSizeTypeIsInvalid(meStmt);
+  }
+  // Type is an integer constant from 0 to 3.
+  auto type = static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue();
+  if (type != kTypeZero && type != kTypeOne && type != kTypeTwo && type != kTypeThree) {
+    ERRWhenSizeTypeIsInvalid(meStmt);
+  }
+  auto *opnd0 = intrinsiccall.GetOpnd(0);
+  auto size = ComputeObjectSizeWithType(*opnd0, type);
+  if (IsInvalidSize(size)) {
+    bool getMaxSizeOfObjs = (type == kTypeZero || type == kTypeOne);
+    size = InvalidSize(getMaxSizeOfObjs);
+  }
+  // Replace callstmt ___builtin_object_size with dassign:
+  // ||MEIR|| intrinsiccallassigned TYIDX:0C___builtin_object_size
+  //          opnd[0] = VAR %arg{offset:0}<0>[idx:2] (field)0 mx2<Z>
+  //          opnd[1] = CONST i32 0 mx3
+  //    assignedpart: { VAR %_64__retVar_6_0{offset:0}<0>[idx:3] (field)0 mx4}
+  // ====>
+  // ||MEIR|| dassign VAR %_64__retVar_6_0{offset:0}<0>[idx:3] (field)0 mx4
+  //          rhs = CONST u64 0 mx6
+  MeExpr *constExpr = irMap.CreateIntConstMeExpr(static_cast<int64>(size), PTY_u64);
+  auto *newStmt = irMap.CreateAssignMeStmt(*intrinsiccall.GetAssignedLHS(), *constExpr, bb);
+  bb.ReplaceMeStmt(&intrinsiccall, newStmt);
+}
+
+// Recursively find whether the definition point is a string.
+MeExpr *OBJSize::GetStrMeExpr(MeExpr &expr) {
+  if (expr.GetMeOp() == kMeOpConststr) {
+    return &expr;
+  }
+  if (expr.IsScalar() && static_cast<const ScalarMeExpr&>(expr).GetDefBy() == kDefByStmt) {
+    return GetStrMeExpr(*static_cast<const ScalarMeExpr&>(expr).GetDefStmt()->GetRHS());
+  }
+  return nullptr;
+}
+
+size_t OBJSize::DealWithSprintfAndVsprintf(const CallMeStmt &callMeStmt, const MIRFunction &calleeFunc) {
+  if (calleeFunc.GetName() != kSprintfChk && calleeFunc.GetName() != kVsprintfChk) {
+    return kInvalidDestSize;
+  }
+  auto *fmt = GetStrMeExpr(*callMeStmt.GetOpnd(3));
+  if (fmt == nullptr || fmt->GetMeOp() != kMeOpConststr) {
+    return kInvalidDestSize;
+  }
+  auto *constStrMeExpr = static_cast<ConststrMeExpr*>(fmt);
+  auto &fmtStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(constStrMeExpr->GetStrIdx());
+  if (strchr(fmtStr.c_str(), '%') == nullptr) {
+    // If the format doesn't contain % args or %%, the size is the length of fmtStr.
+    return strlen(fmtStr.c_str()) + 1;
+  } else if (calleeFunc.GetName() == kSprintfChk && strcmp (fmtStr.c_str(), "%s") == 0) {
+    // If the format is "%s" and first ... argument is a string literal, the size is the length of string literal.
+    if (callMeStmt.GetOpnds().size() < 5) {
+      return kInvalidDestSize;
+    }
+    auto *src = callMeStmt.GetOpnd(4);
+    src = GetStrMeExpr(*src);
+    if (src != nullptr) {
+      return ComputeObjectSizeWithType(*src, 0);
+    }
+  }
+  return kInvalidDestSize;
+}
+
+const std::map<std::string, std::pair<size_t, size_t>> kIndexOfParam {
+    {"sprintf", {1, 2}},
+    {"snprintf", {2, 3}},
+    {"vsprintf", {1, 2}},
+    {"vsnprintf", {2, 3}}
+};
+
+// If do not know the size of the buffer, replace the function without check. Such as:
+// __memcpy_chk => memcpy
+void OBJSize::ReplaceStmt(CallMeStmt &callMeStmt, const std::string &str) {
+  auto *mirFunc = func.GetMIRModule().GetMIRBuilder()->GetOrCreateFunction(str, TyIdx(PTY_void));
+  auto *newCallMeStmt = irMap.NewInPool<CallMeStmt>(callMeStmt.GetOp());
+  const std::set<std::string> kReplacedExceptArgs {"sprintf", "snprintf", "vsprintf", "vsnprintf"};
+  if (kReplacedExceptArgs.find(str) != kReplacedExceptArgs.end()) {
+    for (size_t i = 0; i < callMeStmt.GetOpnds().size(); ++i) {
+      // When replacing with a function without check, the second and third parameters need to be deleted.
+      auto itOfIndex = kReplacedExceptArgs.find(str);
+      if (itOfIndex == kReplacedExceptArgs.end()) {
+        return;
+      }
+      auto itOfIndexParam = kIndexOfParam.find(str);
+      if (i == itOfIndexParam->second.first || i == itOfIndexParam->second.second) {
+        continue;
+      }
+      newCallMeStmt->PushBackOpnd(callMeStmt.GetOpnd(i));
+    }
+  } else {
+    for (size_t i = 0; i < callMeStmt.GetOpnds().size() - 1; ++i) {
+      newCallMeStmt->PushBackOpnd(callMeStmt.GetOpnd(i));
+    }
+  }
+  newCallMeStmt->SetPUIdx(mirFunc->GetPuidx());
+  for (auto &mu : *callMeStmt.GetMuList()) {
+    (void)newCallMeStmt->GetMuList()->emplace(mu.first, mu.second);
+  }
+  newCallMeStmt->SetMustDefList(*callMeStmt.GetMustDefList());
+  newCallMeStmt->SetChiList(*callMeStmt.GetChiList());
+  callMeStmt.GetBB()->ReplaceMeStmt(&callMeStmt, newCallMeStmt);
+}
+
+void OBJSize::ComputeObjectSize(MeStmt &meStmt) {
+  if (meStmt.GetOp() != OP_callassigned) {
+    return;
+  }
+  auto &callMeStmt = static_cast<CallMeStmt&>(meStmt);
+  MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callMeStmt.GetPUIdx());
+  auto it = kReplacedFuncPairs.find(calleeFunc->GetName());
+  if (it == kReplacedFuncPairs.end()) {
+    return;
+  }
+  auto itOfIndex = kIndexOfSrcLength.find(calleeFunc->GetName());
+  if (itOfIndex == kIndexOfSrcLength.end()) {
+    return;
+  }
+  auto *destSizeOpnd = callMeStmt.GetOpnd(itOfIndex->second.second);
+  size_t destSize = 0;
+  int type = 0;
+  destSize = ComputeObjectSizeWithType(*destSizeOpnd, type);
+  if (destSize == 0 || destSize == kInvalidDestSize) {
+    // The length information of dest is unknown during compilation.
+    ReplaceStmt(callMeStmt, it->second);
+    return;
+  }
+  size_t srcSize = 0;
+  if (itOfIndex->second.first == kInvalidDestSize) {
+    srcSize = DealWithSprintfAndVsprintf(callMeStmt, *calleeFunc);
+  } else {
+    MeExpr *srcSizeOpnd = callMeStmt.GetOpnd(itOfIndex->second.first);
+    srcSize = ComputeObjectSizeWithType(*srcSizeOpnd, 0);
+  }
+  if (IsInvalidSize(srcSize)) {
+    // The length information of src is unknown during compilation.
+    return;
+  }
+  if (srcSize <= destSize) {
+    ReplaceStmt(callMeStmt, it->second);
+    return;
+  }
+  auto srcPosition = callMeStmt.GetSrcPosition();
+  SrcPosition pos = (srcPosition.GetInlinedFileNum() != 0) ?
+      SrcPosition(srcPosition.GetInlinedFileNum(), srcPosition.GetInlinedLineNum(), 0, 0) : srcPosition;
+  WARN_USER(kLncWarn, pos, func.GetMIRModule(), "‘__builtin_%s’ will always overflow; "
+      "destination buffer has size %lu, but size argument is %lu", calleeFunc->GetName().c_str(), destSize, srcSize);
+}
+
+size_t OBJSize::DealWithAddrof(const MeExpr &opnd, bool getSizeOfWholeVar) const {
+  auto &addrofMeExpr = static_cast<const AddrofMeExpr&>(opnd);
+  auto *ost = addrofMeExpr.GetOst();
+  auto fieldID = ost->GetFieldID();
+  auto *typeOfBase = ost->GetMIRSymbol()->GetType();
+  if (fieldID == 0) {
+    return typeOfBase->GetSize();
+  }
+  if (typeOfBase->GetKind() != kTypeStruct) {
+    return kInvalidDestSize;
+  }
+  auto *structMIRType = static_cast<MIRStructType*>(typeOfBase);
+  if (!getSizeOfWholeVar) {
+    return structMIRType->GetFieldType(fieldID)->GetSize();
+  }
+  auto offset = structMIRType->GetBitOffsetFromBaseAddr(fieldID);
+  if (offset == kOffsetUnknown) {
+    return kInvalidDestSize;
+  }
+  return structMIRType->GetSize() - static_cast<uint64>(offset / kBitsPerByte);
+}
+
+size_t OBJSize::DealWithIaddrof(const MeExpr &opnd, int64 type, bool getSizeOfWholeVar) const {
+  auto &iaddrofMeExpr = static_cast<const OpMeExpr&>(opnd);
+  auto fieldIDOfIaddrof = iaddrofMeExpr.GetFieldID();
+  auto *typeOfBase = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iaddrofMeExpr.GetTyIdx());
+  if (fieldIDOfIaddrof == 0) {
+    return typeOfBase->GetSize();
+  }
+  if (typeOfBase->GetKind() == kTypePointer) {
+    typeOfBase = static_cast<MIRPtrType*>(typeOfBase)->GetPointedType();
+  }
+  if (typeOfBase->GetKind() != kTypeStruct) {
+    return kInvalidDestSize;
+  }
+  if (!getSizeOfWholeVar) {
+    return static_cast<MIRStructType*>(typeOfBase)->GetFieldType(fieldIDOfIaddrof)->GetSize();
+  }
+  if (iaddrofMeExpr.GetNumOpnds() != 1) {
+    return kInvalidDestSize;
+  }
+  auto *iaddrofOpnd0 = iaddrofMeExpr.GetOpnd(0);
+  auto sizeOfIaddrofOpnd0 = ComputeObjectSizeWithType(*iaddrofOpnd0, type);
+  if (IsInvalidSize(sizeOfIaddrofOpnd0)) {
+    return kInvalidDestSize;
+  }
+  return sizeOfIaddrofOpnd0 -
+      static_cast<uint64>(typeOfBase->GetBitOffsetFromBaseAddr(fieldIDOfIaddrof) / kBitsPerByte);
+}
+
+size_t OBJSize::DealWithDread(const MeExpr &opnd, int64 type, bool getMaxSizeOfObjs) const {
+  if (!opnd.IsScalar()) {
+    return kInvalidDestSize;
+  }
+  auto &scalarMeExpr = static_cast<const ScalarMeExpr&>(opnd);
+  if (scalarMeExpr.GetDefBy() == kDefByPhi) {
+    auto &phi = scalarMeExpr.GetDefPhi();
+    size_t size = getMaxSizeOfObjs ? 0 : std::numeric_limits<uint64_t>::max();
+    for (size_t i = 0; i < phi.GetOpnds().size(); ++i) {
+      size = getMaxSizeOfObjs ? std::max(ComputeObjectSizeWithType(*phi.GetOpnd(i), type), size) :
+          std::min(ComputeObjectSizeWithType(*phi.GetOpnd(i), type), size);
+    }
+    return size;
+  }
+  if (scalarMeExpr.GetDefBy() == kDefByMustDef) {
+    auto *defStmt = scalarMeExpr.GetDefMustDef().GetBase();
+    if (defStmt->GetOp() != OP_callassigned) {
+      return kInvalidDestSize;
+    }
+    MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(
+        static_cast<const CallMeStmt*>(defStmt)->GetPUIdx());
+    if (mirFunc->GetName() != kMalloc) {
+      return kInvalidDestSize;
+    }
+    auto *opnd0 = defStmt->GetOpnd(0);
+    if (IsConstIntExpr(*opnd0)) {
+      return static_cast<ConstMeExpr*>(opnd0)->GetZXTIntValue();
+    }
+  }
+  if (scalarMeExpr.GetDefBy() == kDefByStmt) {
+    return ComputeObjectSizeWithType(*scalarMeExpr.GetDefStmt()->GetRHS(), type);
+  }
+  auto *mirType = scalarMeExpr.GetOst()->GetType();
+  if (mirType->IsMIRPtrType()) {
+    // If the type is pointer type, can not compute the size of obj.
+    // For example: int *b, memcpy(b, buf4, 1000).
+    return kInvalidDestSize;
+  }
+  auto size = mirType->GetSize();
+  if (size == kOffsetUnknown) {
+    return kInvalidDestSize;
+  }
+  return size;
+}
+
+size_t OBJSize::DealWithArray(const MeExpr &opnd, int64 type) const {
+  if (opnd.GetNumOpnds() != kNumOperands) {
+    return kInvalidDestSize;
+  }
+  auto opnd0 = opnd.GetOpnd(0);
+  auto opnd1 = opnd.GetOpnd(1);
+  MIRType *elemType = IRMap::GetArrayElemType(*opnd0);
+  if (elemType == nullptr) {
+    return kInvalidDestSize;
+  }
+  auto size1 = ComputeObjectSizeWithType(*opnd0, type);
+  auto size2 = ComputeObjectSizeWithType(*opnd1, type);
+  if (IsInvalidSize(size1) || IsInvalidSize(size2)) {
+    return kInvalidDestSize;
+  }
+  return size1 - size2 * elemType->GetSize();
+}
+
+// This function returns the size of object and
+// If it is not possible to determine which objects ptr points to at compile time,
+// should return (size_t) -1 for type 0 or 1 and (size_t) 0 for type 2 or 3.
+size_t OBJSize::ComputeObjectSizeWithType(MeExpr &opnd, int64 type) const {
+  // If the least significant bit is clear, objects are whole variables, if it is set,
+  // a closest surrounding subobject is considered the object a pointer points to.
+  bool getSizeOfWholeVar = (type == kTypeZero || type == kTypeTwo);
+  // If the pointer points to multiple objects at compile time,
+  // The second bit determines whether computes the maximum or minimum of the remaining byte counts in those objects.
+  bool getMaxSizeOfObjs = (type == kTypeZero || type == kTypeOne);
+
+  switch (opnd.GetOp()) {
+    case OP_addrof: {
+      return DealWithAddrof(opnd, getSizeOfWholeVar);
+    }
+    case OP_iaddrof: {
+      return DealWithIaddrof(opnd, type, getSizeOfWholeVar);
+    }
+    case OP_dread: {
+      return DealWithDread(opnd, type, getMaxSizeOfObjs);
+    }
+    case OP_add:
+    case OP_sub: {
+      if (opnd.GetNumOpnds() != kNumOperands) {
+        return kInvalidDestSize;
+      }
+      auto size1 = ComputeObjectSizeWithType(*opnd.GetOpnd(0), type);
+      auto size2 = ComputeObjectSizeWithType(*opnd.GetOpnd(1), type);
+      if (IsInvalidSize(size1) || IsInvalidSize(size2)) {
+        return kInvalidDestSize;
+      }
+      return (opnd.GetOp() == OP_add || opnd.GetOp() == OP_array) ? (size1 - size2) : (size1 + size2);
+    }
+    case OP_array: {
+      return DealWithArray(opnd, type);
+    }
+    case OP_constval: {
+      auto &constMeExpr = static_cast<ConstMeExpr&>(opnd);
+      if (constMeExpr.GetConstVal()->GetKind() != kConstInt) {
+        return kInvalidDestSize;
+      }
+      return static_cast<ConstMeExpr&>(opnd).GetIntValue().GetZXTValue();
+    }
+    case OP_conststr: {
+      auto &constStrMeExpr = static_cast<ConststrMeExpr&>(opnd);
+      auto &str = GlobalTables::GetUStrTable().GetStringFromStrIdx(constStrMeExpr.GetStrIdx());
+      return strlen(str.c_str()) + 1;
+    }
+    default:
+      break;
+  }
+  return kInvalidDestSize;
+}
+
+void MEOBJSize::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MEOBJSize::PhaseRun(maple::MeFunction &f) {
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_FATAL(irMap != nullptr, "irMap phase has problem");
+  OBJSize objSize(f, *irMap);
+  objSize.Execute();
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_option.cpp b/src/mapleall/maple_me/src/me_option.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d062458a0d0cadb7fd11280ee95254e4bd9679f4
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_option.cpp
@@ -0,0 +1,500 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_option.h"
+#include <iostream>
+#include "driver_options.h"
+#include "me_options.h"
+#include "mpl_logging.h"
+#include "string_utils.h"
+#include "triple.h"
+
+namespace maple {
+
+std::unordered_set<std::string> MeOption::dumpPhases = {};
+std::unordered_set<std::string> MeOption::skipPhases = {};
+bool MeOption::isBigEndian = false;
+bool MeOption::dumpAfter = false;
+std::string MeOption::dumpFunc = "*";
+unsigned long MeOption::range[kRangeArrayLen] = { 0, 0 };
+bool MeOption::useRange = false;
+bool MeOption::quiet = false;
+bool MeOption::setCalleeHasSideEffect = false;
+bool MeOption::unionBasedAA = true;
+bool MeOption::tbaa = true;
+bool MeOption::ddaa = true;
+uint8 MeOption::aliasAnalysisLevel = 3;
+bool MeOption::noDot = false;
+bool MeOption::stmtNum = false;
+bool MeOption::optForSize = false;
+bool MeOption::enableHotColdSplit = false;
+uint8 MeOption::optLevel = 0;
+bool MeOption::ignoreIPA = true;
+bool MeOption::aggressiveABCO = false;
+bool MeOption::commonABCO = true;
+bool MeOption::conservativeABCO = false;
+bool MeOption::lessThrowAlias = true;
+bool MeOption::regreadAtReturn = true;
+bool MeOption::propBase = true;
+bool MeOption::propIloadRef = false;
+bool MeOption::propGlobalRef = false;
+bool MeOption::propFinaliLoadRef = true;
+bool MeOption::propIloadRefNonParm = false;
+uint32 MeOption::delRcPULimit = UINT32_MAX;
+uint32 MeOption::stmtprePULimit = UINT32_MAX;
+uint32 MeOption::epreLimit = UINT32_MAX;
+uint32 MeOption::eprePULimit = UINT32_MAX;
+uint32 MeOption::lpreLimit = UINT32_MAX;
+uint32 MeOption::lprePULimit = UINT32_MAX;
+uint32 MeOption::pregRenameLimit = UINT32_MAX;
+uint32 MeOption::rename2pregLimit = UINT32_MAX;
+uint32 MeOption::propLimit = UINT32_MAX;
+uint32 MeOption::copyPropLimit = UINT32_MAX;
+uint32 MeOption::vecLoopLimit = UINT32_MAX;
+uint32 MeOption::ivoptsLimit = UINT32_MAX;
+uint32 MeOption::profileBBHotRate = 10;
+uint32 MeOption::profileBBColdRate = 99;
+bool MeOption::noDelegateRC = false;
+bool MeOption::noCondBasedRC = false;
+bool MeOption::clinitPre = true;
+bool MeOption::dassignPre = false;
+bool MeOption::mergeStmts = true;
+bool MeOption::generalRegOnly = false;
+bool MeOption::nullCheckPre = false;
+bool MeOption::assign2FinalPre = false;
+bool MeOption::epreIncludeRef = false;
+bool MeOption::epreLocalRefVar = true;
+bool MeOption::epreLHSIvar = true;
+bool MeOption::lpreSpeculate = false;
+bool MeOption::lpre4Address = true;
+bool MeOption::lpre4LargeInt = true;
+bool MeOption::spillAtCatch = false;
+bool MeOption::rcLowering = true;
+bool MeOption::optDirectCall = false;
+bool MeOption::propAtPhi = true;
+bool MeOption::propDuringBuild = true;
+bool MeOption::propWithInverse = false;
+bool MeOption::dseKeepRef = false;
+bool MeOption::decoupleStatic = false;
+bool MeOption::dumpBefore = false;
+std::string MeOption::skipFrom = "";
+std::string MeOption::skipAfter = "";
+bool MeOption::noRC = false;
+bool MeOption::lazyDecouple = false;
+bool MeOption::strictNaiveRC = false;
+std::unordered_set<std::string> MeOption::checkRefUsedInFuncs = {};
+bool MeOption::gcOnly = false;
+bool MeOption::gcOnlyOpt = false;
+bool MeOption::noGCBar = true;
+bool MeOption::realCheckCast = false;
+bool MeOption::regNativeFunc = false;
+bool MeOption::warnNativeFunc = false;
+uint32 MeOption::parserOpt = 0;
+uint32 MeOption::threads = 1;  // set default threads number
+bool MeOption::ignoreInferredRetType = false;
+bool MeOption::checkCastOpt = false;
+bool MeOption::parmToPtr = false;
+bool MeOption::nativeOpt = true;
+bool MeOption::enableEA = false;
+bool MeOption::placementRC = false;
+bool MeOption::subsumRC = false;
+bool MeOption::performFSAA = true;
+bool MeOption::strengthReduction = true;
+bool MeOption::srForAdd = false;
+bool MeOption::doLFTR = true;
+bool MeOption::ivopts = true;
+std::string MeOption::inlineFuncList = "";
+bool MeOption::meVerify = false;
+uint32 MeOption::dseRunsLimit = 2;    // dse phase run at most 2 times each PU
+uint32 MeOption::hdseRunsLimit = 3;   // hdse phase run at most 3 times each PU
+uint32 MeOption::hpropRunsLimit = 2;  // hprop phase run at most 2 times each PU
+uint32 MeOption::sinkLimit = UINT32_MAX;
+uint32 MeOption::sinkPULimit = UINT32_MAX;
+bool MeOption::loopVec = true;
+bool MeOption::seqVec = true;
+bool MeOption::enableLFO = true;
+uint8 MeOption::rematLevel = 2;
+bool MeOption::layoutWithPredict = true;  // optimize output layout using branch prediction
+SafetyCheckMode MeOption::npeCheckMode = SafetyCheckMode::kNoCheck;
+bool MeOption::isNpeCheckAll = false;
+SafetyCheckMode MeOption::boundaryCheckMode = SafetyCheckMode::kNoCheck;
+bool MeOption::safeRegionMode = false;
+bool MeOption::unifyRets = false;
+bool MeOption::dumpCfgOfPhases = false;
+#if MIR_JAVA
+std::string MeOption::acquireFuncName = "Landroid/location/LocationManager;|requestLocationUpdates|";
+std::string MeOption::releaseFuncName = "Landroid/location/LocationManager;|removeUpdates|";
+unsigned int MeOption::warningLevel = 0;
+bool MeOption::mplToolOnly = false;
+bool MeOption::mplToolStrict = false;
+bool MeOption::skipVirtualMethod = false;
+#endif
+
+void MeOption::DecideMeRealLevel() const {
+  if (opts::me::o1) {
+    optLevel = kLevelOne;
+  } else if (opts::me::o2 || opts::me::os) {
+    if (opts::me::os) {
+      optForSize = true;
+    }
+    optLevel = kLevelTwo;
+    // Turn the followings ON only at O2
+    optDirectCall = true;
+    placementRC = true;
+    subsumRC = true;
+    epreIncludeRef = true;
+  } else if (opts::me::o3) {
+    optForSize = false;
+    optLevel = kLevelThree;
+    // turn on as O2
+    optDirectCall = true;
+    placementRC = true;
+    subsumRC = true;
+    epreIncludeRef = true;
+  }
+}
+
+bool MeOption::SolveOptions(bool isDebug) {
+  DecideMeRealLevel();
+  if (isDebug) {
+    LogInfo::MapleLogger() << "Real Me level:" << std::to_string(optLevel) << "\n";
+
+    for (const auto &opt : meCategory.GetEnabledOptions()) {
+      std::string printOpt;
+      for (const auto &val : opt->GetRawValues()) {
+        printOpt += opt->GetName() + " " + val + " ";
+      }
+      LogInfo::MapleLogger() << "me options: " << printOpt << '\n';
+    }
+  }
+
+  if (opts::me::skipPhases.IsEnabledByUser()) {
+    SplitSkipPhases(opts::me::skipPhases);
+  }
+
+  if (opts::me::refusedcheck.IsEnabledByUser()) {
+    SplitPhases(opts::me::refusedcheck, checkRefUsedInFuncs);
+  }
+
+  if (opts::me::range.IsEnabledByUser()) {
+    useRange = true;
+    bool ret = GetRange(opts::me::range);
+    if (!ret) {
+      return ret;
+    }
+  }
+
+  maplecl::CopyIfEnabled(dumpBefore, opts::me::dumpBefore);
+  maplecl::CopyIfEnabled(dumpAfter, opts::me::dumpAfter);
+
+  /* big endian can be set with several options: --target, -Be.
+   * Triple takes to account all these options and allows to detect big endian with IsBigEndian() interface */
+  if (Triple::GetTriple().IsBigEndian()) {
+    isBigEndian = true;
+  }
+
+  maplecl::CopyIfEnabled(dumpFunc, opts::me::dumpFunc);
+  maplecl::CopyIfEnabled(skipFrom, opts::me::skipFrom);
+  maplecl::CopyIfEnabled(skipAfter, opts::me::skipAfter);
+
+  if (opts::me::dumpPhases.IsEnabledByUser()) {
+    SplitPhases(opts::me::dumpPhases, dumpPhases);
+  }
+
+  maplecl::CopyIfEnabled(quiet, opts::me::quiet);
+  maplecl::CopyIfEnabled(quiet, !opts::verbose, opts::verbose);
+
+  if (opts::profileGen.IsEnabledByUser()) {
+    if (optLevel != kLevelZero) {
+      WARN(kLncWarn, "profileGen requires no optimization");
+      return false;
+    }
+  }
+
+  maplecl::CopyIfEnabled(setCalleeHasSideEffect, opts::me::calleeHasSideEffect);
+  maplecl::CopyIfEnabled(unionBasedAA, opts::me::ubaa);
+  maplecl::CopyIfEnabled(tbaa, opts::me::tbaa);
+  maplecl::CopyIfEnabled(ddaa, opts::me::ddaa);
+
+  if (opts::me::aliasAnalysisLevel.IsEnabledByUser()) {
+    aliasAnalysisLevel = opts::me::aliasAnalysisLevel;
+    if (aliasAnalysisLevel > kLevelThree) {
+      aliasAnalysisLevel = kLevelThree;
+    }
+
+    switch (aliasAnalysisLevel) {
+      case kLevelThree: {
+        setCalleeHasSideEffect = false;
+        unionBasedAA = true;
+        tbaa = true;
+        break;
+      }
+      case kLevelZero: {
+        setCalleeHasSideEffect = true;
+        unionBasedAA = false;
+        tbaa = false;
+        break;
+      }
+      case kLevelOne: {
+        setCalleeHasSideEffect = false;
+        unionBasedAA = true;
+        tbaa = false;
+        break;
+      }
+      case kLevelTwo: {
+        setCalleeHasSideEffect = false;
+        unionBasedAA = false;
+        tbaa = true;
+        break;
+      }
+      default:
+        break;
+    }
+
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: setCalleeHasSideEffect "
+                             << setCalleeHasSideEffect << '\n';
+      LogInfo::MapleLogger() << "--sub options: ubaa " << unionBasedAA << '\n';
+      LogInfo::MapleLogger() << "--sub options: tbaa " << tbaa << '\n';
+    }
+  }
+
+  maplecl::CopyIfEnabled(rcLowering, opts::me::rclower);
+  maplecl::CopyIfEnabled(noRC, !opts::me::userc, opts::me::userc);
+  maplecl::CopyIfEnabled(lazyDecouple, opts::me::lazydecouple);
+  maplecl::CopyIfEnabled(strictNaiveRC, opts::me::strictNaiverc);
+
+  if (opts::gcOnly.IsEnabledByUser()) {
+    gcOnly = opts::gcOnly;
+    propIloadRef = opts::gcOnly;
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: propIloadRef " << propIloadRef << '\n';
+      LogInfo::MapleLogger() << "--sub options: propGlobalRef " << propGlobalRef << '\n';
+    }
+  }
+
+  maplecl::CopyIfEnabled(gcOnlyOpt, opts::me::gconlyopt);
+  maplecl::CopyIfEnabled(noGCBar, !opts::me::usegcbar, opts::me::usegcbar);
+  maplecl::CopyIfEnabled(realCheckCast, opts::me::realcheckcast);
+  maplecl::CopyIfEnabled(noDot, opts::me::nodot);
+  maplecl::CopyIfEnabled(stmtNum, opts::me::stmtnum);
+  maplecl::CopyIfEnabled(regNativeFunc, opts::me::regnativefunc);
+  maplecl::CopyIfEnabled(warnNativeFunc, opts::me::warnemptynative);
+  maplecl::CopyIfEnabled(epreLimit, opts::me::eprelimit);
+  maplecl::CopyIfEnabled(eprePULimit, opts::me::eprepulimit);
+  maplecl::CopyIfEnabled(stmtprePULimit, opts::me::stmtprepulimit);
+  maplecl::CopyIfEnabled(lpreLimit, opts::me::lprelimit);
+  maplecl::CopyIfEnabled(lprePULimit, opts::me::lprepulimit);
+  maplecl::CopyIfEnabled(pregRenameLimit, opts::me::pregrenamelimit);
+  maplecl::CopyIfEnabled(rename2pregLimit, opts::me::rename2preglimit);
+  maplecl::CopyIfEnabled(propLimit, opts::me::proplimit);
+  maplecl::CopyIfEnabled(copyPropLimit, opts::me::copyproplimit);
+  maplecl::CopyIfEnabled(delRcPULimit, opts::me::delrcpulimit);
+  maplecl::CopyIfEnabled(profileBBHotRate, opts::me::profileBbHotRate);
+  maplecl::CopyIfEnabled(profileBBColdRate, opts::me::profileBbColdRate);
+  maplecl::CopyIfEnabled(ignoreIPA, opts::me::ignoreipa);
+  maplecl::CopyIfEnabled(enableHotColdSplit, opts::me::enableHotColdSplit);
+  maplecl::CopyIfEnabled(aggressiveABCO, opts::me::aggressiveABCO);
+  maplecl::CopyIfEnabled(commonABCO, opts::me::commonABCO);
+  maplecl::CopyIfEnabled(conservativeABCO, opts::me::conservativeABCO);
+  maplecl::CopyIfEnabled(epreIncludeRef, opts::me::epreincluderef);
+  maplecl::CopyIfEnabled(epreLocalRefVar, opts::me::eprelocalrefvar);
+  maplecl::CopyIfEnabled(epreLHSIvar, opts::me::eprelhsivar);
+  maplecl::CopyIfEnabled(dseKeepRef, opts::me::dsekeepref);
+  maplecl::CopyIfEnabled(lessThrowAlias, opts::me::lessthrowalias);
+  maplecl::CopyIfEnabled(propBase, opts::me::propbase);
+  maplecl::CopyIfEnabled(dumpCfgOfPhases, opts::me::dumpCfgOfPhases);
+
+  if (opts::me::propiloadref.IsEnabledByUser()) {
+    propIloadRef = opts::me::propiloadref;
+    if (opts::me::propiloadref) {
+      propIloadRefNonParm = false;  // to override previous -propIloadRefNonParm
+    }
+
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: propIloadRefNonParm " << propIloadRefNonParm << '\n';
+    }
+  }
+
+  maplecl::CopyIfEnabled(propGlobalRef, opts::me::propglobalref);
+  maplecl::CopyIfEnabled(propFinaliLoadRef, opts::me::propfinaliloadref);
+
+  if (opts::me::propiloadrefnonparm.IsEnabledByUser()) {
+    propIloadRefNonParm = opts::me::propiloadrefnonparm;
+    propIloadRef = propIloadRefNonParm;
+
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: propIloadRef " << propIloadRef << '\n';
+    }
+  }
+
+  maplecl::CopyIfEnabled(noDelegateRC, opts::me::nodelegaterc);
+  maplecl::CopyIfEnabled(noCondBasedRC, opts::me::nocondbasedrc);
+  maplecl::CopyIfEnabled(checkCastOpt, opts::me::checkcastopt);
+  maplecl::CopyIfEnabled(parmToPtr, opts::me::parmtoptr);
+  maplecl::CopyIfEnabled(nullCheckPre, opts::me::nullcheckpre);
+  maplecl::CopyIfEnabled(clinitPre, opts::me::clinitpre);
+  maplecl::CopyIfEnabled(dassignPre, opts::me::dassignpre);
+  maplecl::CopyIfEnabled(mergeStmts, opts::me::mergestmts);
+  maplecl::CopyIfEnabled(generalRegOnly, opts::me::generalRegOnly);
+  maplecl::CopyIfEnabled(assign2FinalPre, opts::me::assign2finalpre);
+  maplecl::CopyIfEnabled(regreadAtReturn, opts::me::regreadatreturn);
+  maplecl::CopyIfEnabled(propAtPhi, opts::me::propatphi);
+  maplecl::CopyIfEnabled(propDuringBuild, opts::me::propduringbuild);
+  maplecl::CopyIfEnabled(propWithInverse, opts::me::propwithinverse);
+  maplecl::CopyIfEnabled(nativeOpt, opts::me::nativeopt);
+  maplecl::CopyIfEnabled(optDirectCall, opts::me::optdirectcall);
+  maplecl::CopyIfEnabled(enableEA, opts::me::enableEa);
+  maplecl::CopyIfEnabled(lpreSpeculate, opts::me::lprespeculate);
+  maplecl::CopyIfEnabled(lpre4Address, opts::me::lpre4address);
+  maplecl::CopyIfEnabled(lpre4LargeInt, opts::me::lpre4largeint);
+  maplecl::CopyIfEnabled(spillAtCatch, opts::me::spillatcatch);
+
+  if (opts::me::placementrc.IsEnabledByUser()) {
+    placementRC = opts::me::placementrc;
+    if (!placementRC) {
+      subsumRC = false;
+      epreIncludeRef = false;
+      if (isDebug) {
+        LogInfo::MapleLogger() << "--sub options: subsumRC " << subsumRC << '\n';
+        LogInfo::MapleLogger() << "--sub options: epreIncludeRef " << epreIncludeRef << '\n';
+      }
+    }
+  }
+
+  if (opts::me::subsumrc.IsEnabledByUser()) {
+    subsumRC = opts::me::subsumrc;
+    epreIncludeRef = opts::me::subsumrc;
+  }
+
+  maplecl::CopyIfEnabled(performFSAA, opts::me::performFSAA);
+  maplecl::CopyIfEnabled(strengthReduction, opts::me::strengthreduction);
+  maplecl::CopyIfEnabled(srForAdd, opts::me::sradd);
+  maplecl::CopyIfEnabled(doLFTR, opts::me::lftr);
+  maplecl::CopyIfEnabled(ivopts, opts::me::ivopts);
+
+  // must have processed opts::strengthReduction
+  if (ivopts) {
+    // disable strengthReduction when ivopts is on
+    strengthReduction = false;
+  }
+
+  maplecl::CopyIfEnabled(inlineFuncList, opts::me::inlinefunclist);
+  maplecl::CopyIfEnabled(decoupleStatic, opts::decoupleStatic);
+  maplecl::CopyIfEnabled(threads, opts::me::threads);
+  maplecl::CopyIfEnabled(ignoreInferredRetType, opts::me::ignoreInferredRetType);
+  maplecl::CopyIfEnabled(meVerify, opts::me::meverify);
+  maplecl::CopyIfEnabled(dseRunsLimit, opts::me::dserunslimit);
+  maplecl::CopyIfEnabled(hdseRunsLimit, opts::me::hdserunslimit);
+  maplecl::CopyIfEnabled(hpropRunsLimit, opts::me::hproprunslimit);
+  maplecl::CopyIfEnabled(sinkLimit, opts::me::sinklimit);
+  maplecl::CopyIfEnabled(sinkPULimit, opts::me::sinkPUlimit);
+  maplecl::CopyIfEnabled(loopVec, opts::me::loopvec);
+  maplecl::CopyIfEnabled(seqVec, opts::me::seqvec);
+  maplecl::CopyIfEnabled(enableLFO, opts::me::lfo);
+  maplecl::CopyIfEnabled(rematLevel, opts::me::remat);
+  maplecl::CopyIfEnabled(layoutWithPredict, opts::me::layoutwithpredict);
+  maplecl::CopyIfEnabled(vecLoopLimit, opts::me::veclooplimit);
+  maplecl::CopyIfEnabled(ivoptsLimit, opts::me::ivoptslimit);
+  maplecl::CopyIfEnabled(unifyRets, opts::me::unifyrets);
+
+#if MIR_JAVA
+  maplecl::CopyIfEnabled(acquireFuncName, opts::me::acquireFunc);
+  maplecl::CopyIfEnabled(releaseFuncName, opts::me::releaseFunc);
+  maplecl::CopyIfEnabled(warningLevel, opts::me::warning);
+  maplecl::CopyIfEnabled(mplToolOnly, opts::me::toolonly);
+  maplecl::CopyIfEnabled(mplToolStrict, opts::me::toolstrict);
+  maplecl::CopyIfEnabled(skipVirtualMethod, opts::me::skipvirtual);
+#endif
+
+  return true;
+}
+
+MeOption &MeOption::GetInstance() {
+  static MeOption instance;
+  return instance;
+}
+
+void MeOption::ParseOptions(int argc, char **argv, std::string &fileName) {
+  maplecl::CommandLine::GetCommandLine().Parse(argc, argv, meCategory);
+  bool result = SolveOptions(false);
+  if (!result) {
+    return;
+  }
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  int inputFileCount = 0;
+  for (auto &arg : badArgs) {
+    if (FileUtils::IsFileExists(arg.first)) {
+      inputFileCount++;
+      fileName = arg.first;
+    } else {
+      LogInfo::MapleLogger() << "Unknown Option: " << arg.first;
+      CHECK_FATAL(false, "Unknown Option");
+    }
+  }
+
+  /* only 1 input file should be set */
+  if (inputFileCount != 1) {
+    LogInfo::MapleLogger() << "expecting one .mpl file as last argument, found: ";
+    for (const auto &optionArg : badArgs) {
+      LogInfo::MapleLogger() << optionArg.first << " ";
+    }
+    LogInfo::MapleLogger() << '\n';
+    CHECK_FATAL(false, "option parser error");
+  }
+
+#ifdef DEBUG_OPTION
+  LogInfo::MapleLogger() << "mpl file : " << fileName << "\t";
+#endif
+}
+
+void MeOption::SplitPhases(const std::string &str, std::unordered_set<std::string> &set) const {
+  std::string s{ str };
+
+  if (s.compare("*") == 0) {
+    set.insert(s);
+    return;
+  }
+  StringUtils::Split(s, set, ',');
+}
+
+bool MeOption::GetRange(const std::string &str) const {
+  std::string s{ str };
+  size_t comma = s.find_first_of(",", 0);
+  if (comma != std::string::npos) {
+    range[0] = std::stoul(s.substr(0, comma), nullptr);
+    range[1] = std::stoul(s.substr(comma + 1, std::string::npos - (comma + 1)), nullptr);
+  }
+  if (range[0] > range[1]) {
+    LogInfo::MapleLogger(kLlErr) << "invalid values for --range=" << range[0] << "," << range[1] << '\n';
+    return false;
+  }
+  return true;
+}
+
+bool MeOption::DumpPhase(const std::string &phase) {
+  if (phase == "") {
+    return false;
+  }
+  return ((dumpPhases.find(phase) != dumpPhases.end()) || (dumpPhases.find("*") != dumpPhases.end()));
+}
+
+bool MeOption::DumpFunc(const std::string &func) {
+  if (func == "") {
+    return false;
+  }
+  return dumpFunc == "*" || dumpFunc == func;
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/me_options.cpp b/src/mapleall/maple_me/src/me_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..79adab5f52fb8c5344b73ff209a164139213328f
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_options.cpp
@@ -0,0 +1,702 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "driver_options.h"
+
+#include <bits/stdint-uintn.h>
+#include <stdint.h>
+#include <string>
+
+namespace opts::me {
+
+maplecl::Option<bool> help({"--help", "-h"},
+                      "  -h --help                   \tPrint usage and exit.Available command names:\n"
+                      "                              \tme\n", {meCategory});
+
+maplecl::Option<bool> o1({"--O1", "-O1"},
+                    "  -O1                         \tDo some optimization.\n",
+                    {meCategory});
+
+maplecl::Option<bool> o2({"--O2", "-O2"},
+                    "  -O2                         \tDo some optimization.\n",
+                    {meCategory});
+
+maplecl::Option<bool> os({"--Os", "-Os"},
+                    "  -Os                         \tOptimize for size, based on O2.\n",
+                    {meCategory});
+
+maplecl::Option<bool> o3({"--O3", "-O3"},
+                    "  -O3                         \tDo aggressive optimizations.\n",
+                    {meCategory});
+
+maplecl::Option<std::string> refusedcheck({"--refusedcheck"},
+                                     "  --refusedcheck=FUNCNAME,...    \tEnable ref check used in func in the comma"
+                                     " separated list, * means all func.\n",
+                                     {meCategory});
+
+maplecl::Option<std::string> range({"--range"},
+                              "  --range                     \tOptimize only functions in the range [NUM0, NUM1]\n"
+                              "                              \t--range=NUM0,NUM1\n",
+                              {meCategory});
+
+maplecl::Option<std::string> dumpPhases({"--dump-phases"},
+                                   "  --dump-phases               \tEnable debug trace for specified phases"
+                                   " in the comma separated list\n"
+                                   "                              \t--dump-phases=PHASENAME,...\n",
+                                   {meCategory});
+
+maplecl::Option<std::string> skipPhases({"--skip-phases"},
+                                   "  --skip-phases               \tSkip the phases specified"
+                                   " in the comma separated list\n"
+                                   "                              \t--skip-phases=PHASENAME,...\n",
+                                   {meCategory});
+
+maplecl::Option<std::string> dumpFunc({"--dump-func"},
+                                 "  --dump-func                 \tDump/trace only for functions whose names"
+                                 " contain FUNCNAME as substring\n"
+                                 "                              \t(can only specify once)\n"
+                                 "                              \t--dump-func=FUNCNAME\n",
+                                 {meCategory});
+
+maplecl::Option<bool> quiet({"--quiet"},
+                       "  --quiet                     \tDisable brief trace messages with phase/function names\n"
+                       "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
+                       {meCategory},
+                       maplecl::DisableWith("--no-quiet"));
+
+maplecl::Option<bool> nodot({"--nodot"},
+                       "  --nodot                     \tDisable dot file generation from cfg\n"
+                       "  --no-nodot                  \tEnable dot file generation from cfg\n",
+                       {meCategory},
+                       maplecl::DisableWith("--no-nodot"));
+
+maplecl::Option<bool> userc({"--userc"},
+                       "  --userc                     \tEnable reference counting [default]\n"
+                       "  --no-userc                  \tDisable reference counting [default]\n",
+                       {meCategory},
+                       maplecl::DisableWith("--no-userc"));
+
+maplecl::Option<bool> strictNaiverc({"--strict-naiverc"},
+                               "  --strict-naiverc            \tStrict Naive RC mode, assume no unsafe multi-thread"
+                               " read/write racing\n"
+                               "  --no-strict-naiverc         \tDisable Strict Naive RC mode, assume no unsafe"
+                               " multi-thread read/write racing\n",
+                               {meCategory},
+                               maplecl::DisableWith("--no-strict-naiverc"));
+
+maplecl::Option<std::string> skipFrom({"--skip-from"},
+                                 "  --skip-from                 \tSkip the rest phases from PHASENAME(included)\n"
+                                 "                              \t--skip-from=PHASENAME\n",
+                                 {meCategory});
+
+maplecl::Option<std::string> skipAfter({"--skip-after"},
+                                  "  --skip-after                \tSkip the rest phases after PHASENAME(excluded)\n"
+                                  "                              \t--skip-after=PHASENAME\n",
+                                  {meCategory});
+
+maplecl::Option<bool> calleeHasSideEffect({"--setCalleeHasSideEffect"},
+                                     "  --setCalleeHasSideEffect    \tSet all the callees have side effect\n"
+                                     "  --no-setCalleeHasSideEffect \tNot set all the callees have side effect\n",
+                                     {meCategory},
+                                     maplecl::DisableWith("--no-setCalleeHasSideEffect"));
+
+maplecl::Option<bool> ubaa({"--ubaa"},
+                      "  --ubaa                      \tEnable UnionBased alias analysis\n"
+                      "  --no-ubaa                   \tDisable UnionBased alias analysis\n",
+                      {meCategory},
+                      maplecl::DisableWith("--no-ubaa"));
+
+maplecl::Option<bool> tbaa({"--tbaa"},
+                      "  --tbaa                      \tEnable type-based alias analysis\n"
+                      "  --no-tbaa                   \tDisable type-based alias analysis\n",
+                      {meCategory},
+                      maplecl::DisableWith("--no-tbaa"));
+
+maplecl::Option<bool> ddaa({"--ddaa"},
+                      "  --ddaa                      \tEnable demand driven alias analysis\n"
+                      "  --no-ddaa                   \tDisable demand driven alias analysis\n",
+                      {meCategory},
+                      maplecl::DisableWith("--no-ddaa"));
+
+maplecl::Option<uint8_t> aliasAnalysisLevel({"--aliasAnalysisLevel"},
+                                       "  --aliasAnalysisLevel        \tSet level of alias analysis. \n"
+                                       "                              \t0: most conservative;\n"
+                                       "                              \t1: Union-based alias analysis;"
+                                       " 2: type-based alias analysis;\n"
+                                       "                              \t3: Union-based and type-based alias analysis\n"
+                                       "                              \t--aliasAnalysisLevel=NUM\n",
+                                       {meCategory});
+
+maplecl::Option<bool> stmtnum({"--stmtnum"},
+                         "  --stmtnum                   \tPrint MeStmt index number in IR dump\n"
+                         "  --no-stmtnum                \tDon't print MeStmt index number in IR dump\n",
+                         {meCategory},
+                         maplecl::DisableWith("--no-stmtnum"));
+
+maplecl::Option<bool> rclower({"--rclower"},
+                         "  --rclower                   \tEnable rc lowering\n"
+                         "  --no-rclower                \tDisable rc lowering\n",
+                         {meCategory},
+                         maplecl::DisableWith("--no-rclower"));
+
+maplecl::Option<bool> gconlyopt({"--gconlyopt"},
+                           "  --gconlyopt                     \tEnable write barrier optimization in gconly\n"
+                           "  --no-gconlyopt                  \tDisable write barrier optimization in gconly\n",
+                           {meCategory},
+                           maplecl::DisableWith("--no-gconlyopt"));
+
+maplecl::Option<bool> usegcbar({"--usegcbar"},
+                          "  --usegcbar                  \tEnable GC barriers\n"
+                          "  --no-usegcbar               \tDisable GC barriers\n",
+                          {meCategory},
+                          maplecl::DisableWith("--no-usegcbar"));
+
+maplecl::Option<bool> regnativefunc({"--regnativefunc"},
+                               "  --regnativefunc             \tGenerate native stub function to support JNI"
+                               " registration and calling\n"
+                               "  --no-regnativefunc          \tDon't generate native stub function to support JNI"
+                               " registration and calling\n",
+                               {meCategory},
+                               maplecl::DisableWith("--no-regnativefunc"));
+
+maplecl::Option<bool> warnemptynative({"--warnemptynative"},
+                                 "  --warnemptynative           \tGenerate warning and abort unimplemented native"
+                                 " function\n"
+                                 "  --no-warnemptynative        \tDon't generate warning and abort unimplemented"
+                                 " native function\n",
+                                 {meCategory},
+                                 maplecl::DisableWith("--no-warnemptynative"));
+
+maplecl::Option<bool> dumpBefore({"--dump-before"},
+                            "  --dump-before               \tDo extra IR dump before the specified phase in me\n"
+                            "  --no-dump-before            \tDon't extra IR dump before the specified phase in me\n",
+                            {meCategory},
+                            maplecl::DisableWith("--no-dump-before"));
+
+maplecl::Option<bool> dumpAfter({"--dump-after"},
+                           "  --dump-after                \tDo extra IR dump after the specified phase in me\n"
+                           "  --no-dump-after             \tDo not extra IR dump after the specified phase in me\n",
+                           {meCategory},
+                           maplecl::DisableWith("--no-dump-after"));
+
+maplecl::Option<bool> realcheckcast({"--realcheckcast"},
+                               "  --realcheckcast\n"
+                               "  --no-realcheckcast\n",
+                               {meCategory},
+                               maplecl::DisableWith("--no-realcheckcast"));
+
+maplecl::Option<uint32_t> eprelimit({"--eprelimit"},
+                               "  --eprelimit                 \tApply EPRE optimization only for"
+                               " the first NUM expressions\n"
+                               "                              \t--eprelimit=NUM\n",
+                               {meCategory});
+
+maplecl::Option<uint32_t> eprepulimit({"--eprepulimit"},
+                                 "  --eprepulimit               \tApply EPRE optimization only for the first NUM PUs\n"
+                                 "                              \t--eprepulimit=NUM\n",
+                                 {meCategory});
+
+maplecl::Option<uint32_t> stmtprepulimit({"--stmtprepulimit"},
+                                    "  --stmtprepulimit            \tApply STMTPRE optimization only for"
+                                    " the first NUM PUs\n"
+                                    "                              \t--stmtprepulimit=NUM\n",
+                                    {meCategory});
+
+maplecl::Option<uint32_t> lprelimit({"--lprelimit"},
+                               "  --lprelimit                 \tApply LPRE optimization only for"
+                               " the first NUM variables\n"
+                               "                              \t--lprelimit=NUM\n",
+                               {meCategory});
+
+maplecl::Option<uint32_t> lprepulimit({"--lprepulimit"},
+                                 "  --lprepulimit               \tApply LPRE optimization only for the first NUM PUs\n"
+                                 "                              \t--lprepulimit=NUM\n",
+                                 {meCategory});
+
+maplecl::Option<uint32_t> pregrenamelimit({"--pregrenamelimit"},
+                                     "  --pregrenamelimit"
+                                     "           \tApply Preg Renaming optimization only up to NUM times\n"
+                                     "                              \t--pregrenamelimit=NUM\n",
+                                     {meCategory});
+
+maplecl::Option<uint32_t> rename2preglimit({"--rename2preglimit"},
+                                      "  --rename2preglimit"
+                                      "          \tApply Rename-to-Preg optimization only up to NUM times\n"
+                                      "                              \t--rename2preglimit=NUM\n",
+                                      {meCategory});
+
+maplecl::Option<uint32_t> proplimit({"--proplimit"},
+                               "  --proplimit"
+                               "             \tApply propagation only up to NUM times in each hprop invocation\n"
+                               "                              \t--proplimit=NUM\n",
+                               {meCategory});
+
+maplecl::Option<uint32_t> copyproplimit({"--copyproplimit"},
+                                   "  --copyproplimit             \tApply copy propagation only up to NUM times\n"
+                                   "                              \t--copyproplimit=NUM\n",
+                                   {meCategory});
+
+maplecl::Option<uint32_t> delrcpulimit({"--delrcpulimit"},
+                                  "  --delrcpulimit"
+                                  "              \tApply DELEGATERC optimization only for the first NUM PUs\n"
+                                  "                              \t--delrcpulimit=NUM\n",
+                                  {meCategory});
+
+maplecl::Option<uint32_t> profileBbHotRate({"--profile-bb-hot-rate"},
+                                      "  --profile-bb-hot-rate=10"
+                                      "   \tA count is regarded as hot if it is in the largest 10%\n",
+                                      {meCategory});
+
+maplecl::Option<uint32_t> profileBbColdRate({"--profile-bb-cold-rate"},
+                                       "  --profile-bb-cold-rate=99"
+                                       "  \tA count is regarded as cold if it is in the smallest 1%\n",
+                                       {meCategory});
+
+maplecl::Option<bool> ignoreipa({"--ignoreipa"},
+                           "  --ignoreipa                 \tIgnore information provided by interprocedural analysis\n"
+                           "  --no-ignoreipa"
+                           "              \tDon't ignore information provided by interprocedural analysis\n",
+                           {meCategory},
+                           maplecl::DisableWith("--no-ignoreipa"));
+
+maplecl::Option<bool> enableHotColdSplit({"--enableHotColdSplit"},
+                                    "  --enableHotColdSplit        \tEnable the HotCold function split\n"
+                                    "  --no-enableHotColdSplit   \tDisable the HotCold function split\n",
+                                    {meCategory},
+                                    maplecl::DisableWith("--no-enableHotColdSplit"));
+
+maplecl::Option<bool> aggressiveABCO({"--aggressiveABCO"},
+                                "  --aggressiveABCO"
+                                "                 \tEnable aggressive array boundary check optimization\n"
+                                "  --no-aggressiveABCO"
+                                "              \tDon't enable aggressive array boundary check optimization\n",
+                                {meCategory},
+                                maplecl::DisableWith("--no-aggressiveABCO"));
+
+maplecl::Option<bool> commonABCO({"--commonABCO"},
+                            "  --commonABCO                 \tEnable aggressive array boundary check optimization\n"
+                            "  --no-commonABCO"
+                            "              \tDon't enable aggressive array boundary check optimization\n",
+                            {meCategory},
+                            maplecl::DisableWith("--no-commonABCO"));
+
+maplecl::Option<bool> conservativeABCO({"--conservativeABCO"},
+                                  "  --conservativeABCO"
+                                  "                 \tEnable aggressive array boundary check optimization\n"
+                                  "  --no-conservativeABCO"
+                                  "              \tDon't enable aggressive array boundary check optimization\n",
+                                  {meCategory},
+                                  maplecl::DisableWith("--no-conservativeABCO"));
+
+maplecl::Option<bool> epreincluderef({"--epreincluderef"},
+                                "  --epreincluderef"
+                                "            \tInclude ref-type expressions when performing epre optimization\n"
+                                "  --no-epreincluderef"
+                                "         \tDon't include ref-type expressions when performing epre optimization\n",
+                                {meCategory},
+                                maplecl::DisableWith("--no-epreincluderef"));
+
+maplecl::Option<bool> eprelocalrefvar({"--eprelocalrefvar"},
+                                 "  --eprelocalrefvar"
+                                 "           \tThe EPRE phase will create new localrefvars when appropriate\n"
+                                 "  --no-eprelocalrefvar"
+                                 "        \tDisable the EPRE phase create new localrefvars when appropriate\n",
+                                 {meCategory},
+                                 maplecl::DisableWith("--no-eprelocalrefvar"));
+
+maplecl::Option<bool> eprelhsivar({"--eprelhsivar"},
+                             "  --eprelhsivar"
+                             "               \tThe EPRE phase will consider iassigns when optimizing ireads\n"
+                             "  --no-eprelhsivar"
+                             "            \tDisable the EPRE phase consider iassigns when optimizing ireads\n",
+                             {meCategory},
+                             maplecl::DisableWith("--no-eprelhsivar"));
+
+maplecl::Option<bool> dsekeepref({"--dsekeepref"},
+                            "  --dsekeepref"
+                            "                \tPreverse dassign of local var that are of ref type to anywhere\n"
+                            "  --no-dsekeepref"
+                            "             \tDon't preverse dassign of local var that are of ref type to anywhere\n",
+                            {meCategory},
+                            maplecl::DisableWith("--no-dsekeepref"));
+
+maplecl::Option<bool> propbase({"--propbase"},
+                          "  --propbase                  \tApply copy propagation"
+                          " that can change the base of indirect memory accesses\n"
+                          "  --no-propbase               \tDon't apply copy propagation\n",
+                          {meCategory},
+                          maplecl::DisableWith("--no-propbase"));
+
+maplecl::Option<bool> propiloadref({"--propiloadref"},
+                              "  --propiloadref"
+                              "              \tAllow copy propagating iloads that are of ref type to anywhere\n"
+                              "  --no-propiloadref"
+                              "           \tDon't aAllow copy propagating iloads that are of ref type to anywhere\n",
+                              {meCategory},
+                              maplecl::DisableWith("--no-propiloadref"));
+
+maplecl::Option<bool> propglobalref({"--propglobalref"},
+                               "  --propglobalref"
+                               "             \tAllow copy propagating global that are of ref type to anywhere\n"
+                               "  --no-propglobalref"
+                               "          \tDon't allow copy propagating global that are of ref type to anywhere\n",
+                               {meCategory},
+                               maplecl::DisableWith("--no-propglobalref"));
+
+maplecl::Option<bool> propfinaliloadref({"--propfinaliloadref"},
+                                   "  --propfinaliloadref         \tAllow copy propagating iloads of\n"
+                                   "                              \tfinal fields that are of ref type to anywhere\n"
+                                   "  --no-propfinaliloadref      \tDisable propfinaliloadref\n",
+                                   {meCategory},
+                                   maplecl::DisableWith("--no-propfinaliloadref"));
+
+maplecl::Option<bool> propiloadrefnonparm({"--propiloadrefnonparm"},
+                                     "  --propiloadrefnonparm"
+                                     "       \tAllow copy propagating iloads that are of ref type to\n"
+                                     "                              \tanywhere except actual parameters\n"
+                                     "  --no-propiloadrefnonparm    \tDisbale propiloadref\n",
+                                     {meCategory},
+                                     maplecl::DisableWith("--no-propiloadrefnonparm"));
+
+maplecl::Option<bool> lessthrowalias({"--lessthrowalias"},
+                                "  --lessthrowalias"
+                                "            \tHandle aliases at java throw statements more accurately\n"
+                                "  --no-lessthrowalias         \tDisable lessthrowalias\n",
+                                {meCategory},
+                                maplecl::DisableWith("--no-lessthrowalias"));
+
+maplecl::Option<bool> nodelegaterc({"--nodelegaterc"},
+                              "  --nodelegateerc"
+                              "             \tDo not apply RC delegation to local object reference pointers\n"
+                              "  --no-nodelegateerc          \tDisable nodelegateerc\n",
+                              {meCategory},
+                              maplecl::DisableWith("--no-nodelegateerc"));
+
+maplecl::Option<bool> nocondbasedrc({"--nocondbasedrc"},
+                               "  --nocondbasedrc             \tDo not apply condition-based RC optimization to\n"
+                               "                              \tlocal object reference pointers\n"
+                               "  --no-nocondbasedrc          \tDisable nocondbasedrc\n",
+                               {meCategory},
+                               maplecl::DisableWith("--no-nocondbasedrc"));
+
+maplecl::Option<bool> subsumrc({"--subsumrc"},
+                          "  --subsumrc"
+                          "               \tDelete decrements for localrefvars whose live range is just in\n"
+                          "                           \tanother which point to the same obj\n"
+                          "  --no-subsumrc            \tDisable subsumrc\n",
+                          {meCategory},
+                          maplecl::DisableWith("--no-subsumrc"));
+
+maplecl::Option<bool> performFSAA({"--performFSAA"},
+                             "  --performFSAA            \tPerform flow sensitive alias analysis\n"
+                             "  --no-performFSAA         \tDisable flow sensitive alias analysis\n",
+                             {meCategory},
+                             maplecl::DisableWith("--no-performFSAA"));
+
+maplecl::Option<bool> strengthreduction({"--strengthreduction"},
+                                   "  --strengthreduction      \tPerform strength reduction\n"
+                                   "  --no-strengthreduction   \tDisable strength reduction\n",
+                                   {meCategory},
+                                   maplecl::DisableWith("--no-strengthreduction"));
+
+maplecl::Option<bool> sradd({"--sradd"},
+                       "  --sradd                   \tPerform strength reduction for OP_add/sub\n"
+                       "  --no-sradd                \tDisable strength reduction for OP_add/sub\n",
+                       {meCategory},
+                       maplecl::DisableWith("--no-sradd"));
+
+maplecl::Option<bool> lftr({"--lftr"},
+                      "  --lftr                   \tPerform linear function test replacement\n"
+                      "  --no-lftr                \tDisable linear function test replacement\n",
+                      {meCategory},
+                      maplecl::DisableWith("--no-lftr"));
+
+maplecl::Option<bool> ivopts({"--ivopts"},
+                        "  --ivopts                   \tPerform induction variables optimization\n"
+                        "  --no-ivopts                \tDisable induction variables optimization\n",
+                        {meCategory},
+                        maplecl::DisableWith("--no-ivopts"));
+
+maplecl::Option<bool> checkcastopt({"--checkcastopt"},
+                              "  --checkcastopt             \tApply template--checkcast optimization \n"
+                              "  --no-checkcastopt          \tDisable checkcastopt \n",
+                              {meCategory},
+                              maplecl::DisableWith("--no-checkcastopt"));
+
+maplecl::Option<bool> parmtoptr({"--parmtoptr"},
+                           "  --parmtoptr"
+                           "                 \tAllow rcoptlocals to change actual parameters from ref to ptr type\n"
+                           "  --no-parmtoptr              \tDisable parmtoptr\n",
+                           {meCategory},
+                           maplecl::DisableWith("--no-parmtoptr"));
+
+maplecl::Option<bool> nullcheckpre({"--nullcheckpre"},
+                              "  --nullcheckpre"
+                              "              \tTurn on partial redundancy elimination of null pointer checks\n"
+                              "  --no-nullcheckpre           \tDisable nullcheckpre\n",
+                              {meCategory},
+                              maplecl::DisableWith("--no-nullcheckpre"));
+
+maplecl::Option<bool> clinitpre({"--clinitpre"},
+                           "  --clinitpre"
+                           "                 \tTurn on partial redundancy elimination of class initialization checks\n"
+                           "  --no-clinitpre              \tDisable clinitpre\n",
+                           {meCategory},
+                           maplecl::DisableWith("--no-clinitpre"));
+
+maplecl::Option<bool> dassignpre({"--dassignpre"},
+                            "  --dassignpre""                \tTurn on partial redundancy"
+                            " elimination of assignments to scalar variables\n"
+                            "  --no-dassignpre             \tDisable dassignpre\n",
+                            {meCategory},
+                            maplecl::DisableWith("--no-dassignpre"));
+
+maplecl::Option<bool> assign2finalpre({"--assign2finalpre"},
+                                 "  --assign2finalpre           \tTurn on partial redundancy"
+                                 " elimination of assignments to final variables\n"
+                                 "  --no-assign2finalpre        \tDisable assign2finalpre\n",
+                                 {meCategory},
+                                 maplecl::DisableWith("--no-assign2finalpre"));
+
+maplecl::Option<bool> regreadatreturn({"--regreadatreturn"},
+                                 "  --regreadatreturn           \tAllow register promotion"
+                                 " to promote the operand of return statements\n"
+                                 "  --no-regreadatreturn        \tDisable regreadatreturn\n",
+                                 {meCategory},
+                                 maplecl::DisableWith("--no-regreadatreturn"));
+
+maplecl::Option<bool> propatphi({"--propatphi"},
+                           "  --propatphi                 \tEnable copy propagation across phi nodes\n"
+                           "  --no-propatphi              \tDisable propatphi\n",
+                           {meCategory},
+                           maplecl::DisableWith("--no-propatphi"));
+
+maplecl::Option<bool> propduringbuild({"--propduringbuild"},
+                                 "  --propduringbuild           \tEnable copy propagation when building HSSA\n"
+                                 "  --no-propduringbuild        \tDisable propduringbuild\n",
+                                 {meCategory},
+                                 maplecl::DisableWith("--no-propduringbuild"));
+
+maplecl::Option<bool> propwithinverse({"--propwithinverse"},
+                                 "  --propwithinverse"
+                                 "           \tEnable copy propagation across statements with inverse functions"
+                                 "  --no-propwithinverse"
+                                 "        \tDisable copy propagation across statements with inverse functions\n",
+                                 {meCategory},
+                                 maplecl::DisableWith(""));
+
+maplecl::Option<bool> nativeopt({"--nativeopt"},
+                           "  --nativeopt              \tEnable native opt\n"
+                           "  --no-nativeopt           \tDisable native opt\n",
+                           {meCategory},
+                           maplecl::DisableWith("--no-nativeopt"));
+
+maplecl::Option<bool> optdirectcall({"--optdirectcall"},
+                               "  --optdirectcall             \tEnable redundancy elimination of directcalls\n"
+                               "  --no-optdirectcall          \tDisable optdirectcall\n",
+                               {meCategory},
+                               maplecl::DisableWith("--no-optdirectcall"));
+
+maplecl::Option<bool> enableEa({"--enable-ea"},
+                           "  --enable-ea                 \tEnable escape analysis\n"
+                           "  --no-enable-ea              \tDisable escape analysis\n",
+                          {meCategory},
+                           maplecl::DisableWith("--no-enable-ea"));
+
+maplecl::Option<bool> lprespeculate({"--lprespeculate"},
+                               "  --lprespeculate             \tEnable speculative code motion in LPRE phase\n"
+                               "  --no-lprespeculate          \tDisable speculative code motion in LPRE phase\n",
+                               {meCategory},
+                               maplecl::DisableWith("--no-lprespeculate"));
+
+maplecl::Option<bool> lpre4address({"--lpre4address"},
+                              "  --lpre4address              \tEnable register promotion of addresses in LPRE phase\n"
+                              "  --no-lpre4address"
+                              "           \tDisable register promotion of addresses in LPRE phase\n",
+                              maplecl::DisableWith("--no-lpre4address"));
+
+maplecl::Option<bool> lpre4largeint({"--lpre4largeint"},
+                               "  --lpre4largeint"
+                               "             \tEnable register promotion of large integers in LPRE phase\n"
+                               "  --no-lpre4largeint"
+                               "          \tDisable register promotion of large integers in LPRE phase\n",
+                               {meCategory},
+                               maplecl::DisableWith("--no-lpre4largeint"));
+
+maplecl::Option<bool> spillatcatch({"--spillatcatch"},
+                              "  --spillatcatch              \tMinimize upward exposed preg usage in catch blocks\n"
+                              "  --no-spillatcatch           \tDisable spillatcatch\n",
+                              {meCategory},
+                              maplecl::DisableWith("--no-spillatcatch"));
+
+maplecl::Option<bool> placementrc({"--placementrc"},
+                             "  --placementrc               \tInsert RC decrements for localrefvars using\n"
+                             "                              \tthe placement optimization approach\n"
+                             "  --no-placementrc            \tInsert RC decrements for localrefvars using\n",
+                             {meCategory},
+                             maplecl::DisableWith("--no-placementrc"));
+
+maplecl::Option<bool> lazydecouple({"--lazydecouple"},
+                              "  --lazydecouple              \tDo optimized for lazy Decouple\n"
+                              "  --no-lazydecouple           \tDo not optimized for lazy Decouple\n",
+                              {meCategory},
+                              maplecl::DisableWith("--no-lazydecouple"));
+
+maplecl::Option<bool> mergestmts({"--mergestmts"},
+                            "  --mergestmts                \tTurn on statment merging optimization\n"
+                            "  --no-mergestmts             \tDisable mergestmts\n",
+                            {meCategory},
+                            maplecl::DisableWith("--no-mergestmts"));
+
+maplecl::Option<bool> generalRegOnly({"--general-reg-only"},
+                                "  --general-reg-only"
+                                "        \tME will avoid generate fp type when enable general-reg-only\n"
+                                "  --no-general-reg-only     \tDisable general-reg-only\n",
+                                {meCategory});
+
+maplecl::Option<std::string> inlinefunclist({"--inlinefunclist"},
+                                       "  --inlinefunclist            \tInlining related configuration\n"
+                                       "                              \t--inlinefunclist=\n",
+                                       {meCategory});
+
+maplecl::Option<uint32_t> threads({"--threads"},
+                             "  --threads=n                 \tOptimizing me functions using n threads\n"
+                             "                              \tIf n >= 2,"
+                             " ignore-inferred-return-type will be enabled default\n",
+                             {meCategory});
+
+maplecl::Option<bool> ignoreInferredRetType({"--ignore-inferred-ret-type"},
+                                       "  --ignore-inferred-ret-type  \tIgnore func return type inferred by ssadevrt\n"
+                                       "  --no-ignore-inferred-ret-type"
+                                       "\tDo not ignore func return type inferred by ssadevirt\n",
+                                       {meCategory},
+                                       maplecl::DisableWith("--no-ignore-inferred-ret-type"));
+
+maplecl::Option<bool> meverify({"--meverify"},
+                          "  --meverify                       \tenable meverify features\n",
+                          {meCategory},
+                          maplecl::DisableWith("--no-meverify"));
+
+maplecl::Option<uint32_t> dserunslimit({"--dserunslimit"},
+                                  "  --dserunslimit=n            \tControl number of times dse phase can be run\n"
+                                  "                              \t--dserunslimit=NUM\n",
+                                  {meCategory});
+
+maplecl::Option<uint32_t> hdserunslimit({"--hdserunslimit"},
+                                   "  --hdserunslimit=n           \tControl number of times hdse phase can be run\n"
+                                   "                              \t--hdserunslimit=NUM\n",
+                                   {meCategory});
+
+maplecl::Option<uint32_t> hproprunslimit({"--hproprunslimit"},
+                                    "  --hproprunslimit=n          \tControl number of times hprop phase can be run\n"
+                                    "                              \t--hproprunslimit=NUM\n",
+                                    {meCategory});
+
+maplecl::Option<uint32_t> sinklimit({"--sinklimit"},
+                               "  --sinklimit=n          \tControl number of stmts sink-phase can sink\n"
+                               "                              \t--sinklimit=NUM\n",
+                               {meCategory});
+
+maplecl::Option<uint32_t> sinkPUlimit({"--sinkPUlimit"},
+                                 "  --sinkPUlimit=n          \tControl number of function sink-phase can be run\n"
+                                 "                              \t--sinkPUlimit=NUM\n",
+                                 {meCategory});
+
+maplecl::Option<bool> loopvec({"--loopvec"},
+                         "  --loopvec                   \tEnable auto loop vectorization\n"
+                         "  --no-loopvec                \tDisable auto loop vectorization\n",
+                         {meCategory},
+                         maplecl::DisableWith("--no-loopvec"));
+
+maplecl::Option<bool> seqvec({"--seqvec"},
+                        "  --seqvec                   \tEnable auto sequencial vectorization\n"
+                        "  --no-seqvec                \tDisable auto sequencial vectorization\n",
+                        {meCategory},
+                        maplecl::DisableWith("--no-seqvec"));
+
+maplecl::Option<bool> layoutwithpredict({"--layoutwithpredict"},
+                                   "  --layoutwithpredict"
+                                   "        \tEnable optimizing output layout using branch prediction\n"
+                                   "  --no-layoutwithpredict"
+                                   "     \tDisable optimizing output layout using branch prediction\n",
+                                   {meCategory},
+                                   maplecl::DisableWith("--no-layoutwithpredict"));
+
+maplecl::Option<uint32_t> veclooplimit({"--veclooplimit"},
+                                  "  --veclooplimit             \tApply vectorize loops only up to NUM \n"
+                                  "                              \t--veclooplimit=NUM\n",
+                                  {meCategory});
+
+maplecl::Option<uint32_t> ivoptslimit({"--ivoptslimit"},
+                                 "  --ivoptslimit              \tApply ivopts only up to NUM loops \n"
+                                 "                              \t--ivoptslimit=NUM\n",
+                                 {meCategory});
+
+maplecl::Option<std::string> acquireFunc({"--acquire-func"},
+                                    "  --acquire-func              \t--acquire-func=FUNCNAME\n",
+                                    {meCategory});
+
+maplecl::Option<std::string> releaseFunc({"--release-func"},
+                                     "  --release-func              \t--release-func=FUNCNAME\n",
+                                    {meCategory});
+
+maplecl::Option<bool> toolonly({"--toolonly"},
+                          "  --toolonly\n"
+                          "  --no-toolonly\n",
+                          {meCategory},
+                          maplecl::DisableWith("--no-toolonly"));
+
+maplecl::Option<bool> toolstrict({"--toolstrict"},
+                            "  --toolstrict\n"
+                            "  --no-toolstrict\n",
+                            {meCategory},
+                            maplecl::DisableWith("--no-toolstrict"));
+
+maplecl::Option<bool> skipvirtual({"--skipvirtual"},
+                             "  --skipvirtual\n"
+                             "  --no-skipvirtual\n",
+                             {meCategory},
+                             maplecl::DisableWith("--no-skipvirtual"));
+
+maplecl::Option<uint32_t> warning({"--warning"},
+                             "  --warning=level             \t--warning=level\n",
+                             {meCategory});
+
+maplecl::Option<uint8_t> remat({"--remat"},
+                          "  --remat                     \tEnable rematerialization during register allocation\n"
+                          "                              \t     0: no rematerialization (default)\n"
+                          "                              \t  >= 1: rematerialize constants\n"
+                          "                              \t  >= 2: rematerialize addresses\n"
+                          "                              \t  >= 3: rematerialize local dreads\n"
+                          "                              \t  >= 4: rematerialize global dreads\n",
+                          {meCategory});
+
+maplecl::Option<bool> unifyrets({"--unifyrets"},
+                           "  --unifyrets                   \tEnable return blocks unification\n"
+                           "  --no-unifyrets                \tDisable return blocks unification\n",
+                           {meCategory},
+                           maplecl::DisableWith("--no-unifyrets"));
+
+maplecl::Option<bool> lfo({"--lfo"},
+                     "  --lfo                   \tEnable LFO framework\n"
+                     "  --no-lfo                \tDisable LFO framework\n",
+                     {meCategory},
+                     maplecl::DisableWith("--no-lfo"));
+
+maplecl::Option<bool> dumpCfgOfPhases({"--dumpcfgofphases"},
+                     "  --dumpcfgofphases       \tDump CFG from various phases to .dot files\n",
+                     {meCategory});
+
+}
diff --git a/src/mapleall/maple_me/src/me_phase_manager.cpp b/src/mapleall/maple_me/src/me_phase_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3e8b3c6b60cc4412a435faa97973bb3acd8a1f27
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_phase_manager.cpp
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_phase_manager.h"
+#include "bin_mplt.h"
+#include "becommon.h"
+#include "lower.h"
+#include "lmbc_memlayout.h"
+#include "lmbc_lower.h"
+
+#define JAVALANG (mirModule.IsJavaModule())
+#define CLANG (mirModule.IsCModule())
+
+namespace maple {
+bool MeFuncPM::genMeMpl = false;
+bool MeFuncPM::genMapleBC = false;
+bool MeFuncPM::genLMBC = false;
+bool MeFuncPM::timePhases = false;
+
+void MeFuncPM::DumpMEIR(const MeFunction &f, const std::string phaseName, bool isBefore) {
+  bool dumpFunc = MeOption::DumpFunc(f.GetName());
+  bool dumpPhase = MeOption::DumpPhase(phaseName);
+  if (MeOption::dumpBefore && dumpFunc && dumpPhase && isBefore) {
+    LogInfo::MapleLogger() << ">>>>> Dump before " << phaseName << " <<<<<\n";
+    if (phaseName != "meemit") {
+      f.Dump(false);
+    } else {
+      f.DumpFunctionNoSSA();
+    }
+    LogInfo::MapleLogger() << ">>>>> Dump before End <<<<<\n";
+    return;
+  }
+  if ((MeOption::dumpAfter || dumpPhase) && dumpFunc && !isBefore) {
+    LogInfo::MapleLogger() << ">>>>> Dump after " << phaseName << " <<<<<\n";
+    if (phaseName != "meemit" && phaseName != "lfounroll") {
+      f.Dump(false);
+    } else {
+      f.DumpFunctionNoSSA();
+    }
+    LogInfo::MapleLogger() << ">>>>> Dump after End <<<<<\n\n";
+  }
+}
+
+bool MeFuncPM::SkipFuncForMe(const MIRFunction &func, uint64 range) {
+  if (func.IsEmpty() || (MeOption::useRange && (range < MeOption::range[0] || range > MeOption::range[1]))) {
+    return true;
+  }
+  if (func.HasSetjmp()) {
+    LogInfo::MapleLogger() << "Function  < " << func.GetName() << " not optimized because it has setjmp\n";
+    return true;
+  }
+  return false;
+}
+
+bool MeFuncPM::PhaseRun(maple::MIRModule &m) {
+  bool changed = false;
+  auto &compFuncList = m.GetFunctionList();
+  auto admMempool = AllocateMemPoolInPhaseManager("me phase manager's analysis data manager mempool");
+  auto *serialADM = GetManagerMemPool()->New<AnalysisDataManager>(*(admMempool.get()));
+  SetQuiet(MeOption::quiet);
+  if (MeFuncPM::timePhases) {
+    InitTimeHandler();
+  }
+  auto userDefinedOptLevel = MeOption::optLevel;
+  DoPhasesPopulate(m);
+  size_t i = 0;
+  for (auto &func : std::as_const(compFuncList)) {
+    ++i;
+    ASSERT_NOT_NULL(func);
+    if (SkipFuncForMe(*func, i - 1)) {
+      if (!func->IsEmpty()) {
+        // mir cg lower should not be skipped
+        MIRLower mirLower(m, func);
+        mirLower.SetLowerCG();
+        mirLower.SetMirFunc(func);
+        mirLower.LowerFunc(*func);
+      }
+      continue;
+    }
+    if (userDefinedOptLevel == 2 && m.HasPartO2List()) {
+      if (m.IsInPartO2List(func->GetNameStrIdx())) {
+        MeOption::optLevel = 2;
+      } else {
+        MeOption::optLevel = 0;
+      }
+      ClearAllPhases();
+      DoPhasesPopulate(m);
+    }
+    m.SetCurFunction(func);
+    if (!IsQuiet()) {
+      LogInfo::MapleLogger() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>> Optimizing Function  < " << func->GetName()
+                             << " id=" << func->GetPuidxOrigin() << " >---\n";
+    }
+    /* prepare me func */
+    auto meFuncMP = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "maple_me per-function mempool");
+    auto meFuncStackMP = std::make_unique<StackMemPool>(memPoolCtrler, "");
+    MemPool *versMP = new ThreadLocalMemPool(memPoolCtrler, "first verst mempool");
+    MeFunction &meFunc = *(meFuncMP->New<MeFunction>(&m, func, meFuncMP.get(), *meFuncStackMP, versMP, meInput));
+    if (genLMBC) {
+      meFunc.genLMBC = true;
+    }
+    func->SetMeFunc(&meFunc);
+    meFunc.PartialInit();
+#if DEBUG
+    globalMIRModule = &m;
+    globalFunc = &meFunc;
+#endif
+    if (!IsQuiet()) {
+      LogInfo::MapleLogger() << "---Preparing Function  < " << func->GetName() << " > [" << i - 1 << "] ---\n";
+    }
+    meFunc.Prepare();
+    (void)FuncLevelRun(meFunc, *serialADM);
+    meFunc.Release();
+    serialADM->EraseAllAnalysisPhase();
+  }
+  if (genMeMpl) {
+    m.Emit("comb.me.mpl");
+  }
+  if (genMapleBC) {
+    m.SetFlavor(kFlavorMbc);
+    // output .mbc
+    BinaryMplt binMplt(m);
+    std::string modFileName = m.GetFileName();
+    std::string::size_type lastdot = modFileName.find_last_of(".");
+
+    binMplt.GetBinExport().not2mplt = true;
+    std::string filestem = modFileName.substr(0, lastdot);
+    binMplt.Export(filestem + ".mbc", nullptr);
+  }
+  if (genLMBC) {
+    m.SetFlavor(kFlavorLmbc);
+    GlobalMemLayout globalMemLayout(&m, &m.GetMPAllocator());
+    maplebe::BECommon beCommon(m);
+    maplebe::CGLowerer cgLower(m, beCommon, *GetPhaseMemPool(), false, false);
+    cgLower.RegisterBuiltIns();
+    cgLower.RegisterExternalLibraryFunctions();
+    for (auto &func : std::as_const(compFuncList)) {
+      if (func->GetBody() == nullptr) {
+        continue;
+      }
+      if (!IsQuiet()) {
+        LogInfo::MapleLogger() << ">>>> Generating LMBC for Function  < " << func->GetName() << " >\n";
+      }
+      m.SetCurFunction(func);
+      cgLower.LowerFunc(*func);
+      MemPool *layoutMp = memPoolCtrler.NewMemPool("layout mempool", true);
+      MapleAllocator layoutAlloc(layoutMp);
+      LMBCMemLayout localMemLayout(func, &globalMemLayout.seg_GPbased, &layoutAlloc);
+      localMemLayout.LayoutStackFrame();
+      LMBCLowerer lmbcLowerer(&m, &beCommon, func, &globalMemLayout, &localMemLayout);
+      lmbcLowerer.LowerFunction();
+      func->SetFrameSize(localMemLayout.StackFrameSize());
+      memPoolCtrler.DeleteMemPool(layoutMp);
+    }
+    globalMemLayout.seg_GPbased.size =
+        maplebe::RoundUp(static_cast<uint64>(globalMemLayout.seg_GPbased.size), GetPrimTypeSize(PTY_ptr));
+    m.SetGlobalMemSize(globalMemLayout.seg_GPbased.size);
+    // output .lmbc
+    BinaryMplt binMplt(m);
+    std::string modFileName = m.GetFileName();
+    std::string::size_type lastdot = modFileName.find_last_of(".");
+
+    binMplt.GetBinExport().not2mplt = true;
+    std::string filestem = modFileName.substr(0, lastdot);
+    binMplt.Export(filestem + ".lmbc", nullptr);
+  }
+  if (MeFuncPM::timePhases) {
+    DumpPhaseTime();
+  }
+  return changed;
+}
+
+bool MeFuncPM::FuncLevelRun(MeFunction &meFunc, AnalysisDataManager &serialADM) {
+  bool changed = false;
+  for (size_t i = 0; i < phasesSequence.size(); ++i) {
+    SolveSkipFrom(MeOption::GetSkipFromPhase(), i);
+    const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+    if (!IsQuiet()) {
+      LogInfo::MapleLogger() << "---Run Me " << (curPhase->IsAnalysis() ? "analysis" : "transform")
+                             << " Phase [ " << curPhase->PhaseName() << " ]---\n";
+    }
+    DumpMEIR(meFunc, curPhase->PhaseName(), true);
+    if (curPhase->IsAnalysis()) {
+      changed |= RunAnalysisPhase<MeFuncOptTy, MeFunction>(*curPhase, serialADM, meFunc);
+    } else {
+      changed |= RunTransformPhase<MeFuncOptTy, MeFunction>(*curPhase, serialADM, meFunc);
+    }
+    DumpMEIR(meFunc, curPhase->PhaseName(), false);
+    SolveSkipAfter(MeOption::GetSkipAfterPhase(), i);
+  }
+  return changed;
+}
+
+void MeFuncPM::DoPhasesPopulate(const maple::MIRModule &mirModule) {
+#define ME_PHASE
+#include "phases.def"
+#undef ME_PHASE
+}
+
+void MeFuncPM::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MClone>();
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.AddPreserved<M2MKlassHierarchy>();
+}
+
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MeFuncPM, meFuncPM)
+
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MEMeCfg, mecfgbuild)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MECfgVerifyFrequency, cfgverifyfreq)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MEVerify, meverify)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MEAliasClass, aliasclass)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MESSATab, ssatab)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MEPreMeEmission, premeemit)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MEAnalyzeCtor, analyzector)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MEDominance, dominance)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MELoopAnalysis, identloops)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MELfoDepTest, deptest)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MESSADevirtual, ssadevirt)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MESideEffect, sideeffect)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MESSA, ssa)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(METopLevelSSA, toplevelssa)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MEBBLayout, bblayout)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MEIRMapBuild, irmapbuild)
+MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(MEPredict, predict)
+
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEAnalyzeRC, analyzerc)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEStorePre, storepre)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MESubsumRC, subsumrc)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MESSARename2Preg, rename2preg)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEMeProp, hprop)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MESSAProp, ssaprop)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEMeSink, sink)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEIVOpts, ivopts)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MECodeFactoring, codefactoring)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MESyncSelect, syncselect)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEMay2Dassign, may2dassign)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MECondBasedRC, condbasedrc)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MECondBasedNPC, condbasednpc)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEPregRename, pregrename)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEStmtPre, stmtpre)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MECfgOpt, cfgopt)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEAutoVectorization, autovec)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MELfoUnroll, lfounroll)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MECFGOPT, cfgOpt)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MELoopUnrolling, loopunrolling)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEHdse, hdse)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MELfoIVCanon, ivcanon)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEValueRangePropagation, valueRangePropagation)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEJumpThreading, jumpThreading)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEOBJSize, objSize)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MESafetyWarning, safetyWarning)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEBypathEH, bypatheh)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEProfUse, profileUse)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEGCLowering, gclowering)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MELfoInjectIV, injectiv)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MECopyProp, copyprop)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MERCLowering, rclowering)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MESSALPre, lpre)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MELoopCanon, loopcanon)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MELoopInversion, loopinversion)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEDelegateRC, delegaterc)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEFSAA, fsaa)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MESplitCEdge, splitcriticaledge)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MECheckCastOpt, checkcastopt)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MESSAEPre, epre)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEOptimizeCFGNoSSA, optimizeCFGNoSSA)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEOptimizeCFG, optimizeCFG)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MESLPVectorizer, slp)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEProfGen, profileGen)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEPlacementRC, placementrc)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEDse, dse)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(MEABCOpt, abcopt)
+MAPLE_TRANSFORM_PHASE_REGISTER(MEEmit, meemit)
+MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(ProfileGenEmit, profgenEmit);
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_placement_rc.cpp b/src/mapleall/maple_me/src/me_placement_rc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f1f8423b735b6e9525f16cc58e7e6a10bc335a3c
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_placement_rc.cpp
@@ -0,0 +1,937 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_placement_rc.h"
+#include "me_irmap_build.h"
+
+namespace {
+const std::set<std::string> whiteListFunc {
+#include "rcwhitelist.def"
+};
+}
+
+namespace maple {
+// ================ Step 6: Code Motion ================
+// Insert newstmt at earliest point in bb, but after statements required to be
+// first statements in the BB
+static void InsertAtBBEntry(BB &bb, MeStmt &newStmt) {
+  MeStmt *curStmt = to_ptr(bb.GetMeStmts().begin());
+
+  while (curStmt != nullptr &&
+         (curStmt->GetOp() == OP_catch || curStmt->GetOp() == OP_try || curStmt->GetOp() == OP_comment)) {
+    curStmt = curStmt->GetNext();
+  }
+
+  if (curStmt == nullptr) {
+    bb.AddMeStmtLast(&newStmt);
+  } else {
+    bb.InsertMeStmtBefore(curStmt, &newStmt);
+  }
+}
+
+UnaryMeStmt *PlacementRC::GenIncrefAtEntry(OriginalSt &ost) const {
+  UnaryMeStmt *incRefStmt = irMap->New<UnaryMeStmt>(OP_incref);
+  incRefStmt->SetMeStmtOpndValue(irMap->GetOrCreateZeroVersionVarMeExpr(ost));
+  BB *insertBB = func->GetCfg()->GetFirstBB();
+  incRefStmt->SetBB(insertBB);
+  InsertAtBBEntry(*insertBB, *incRefStmt);
+  return incRefStmt;
+}
+
+void PlacementRC::CollectDecref(VarMeExpr *var, MeStmt *decrefStmt) {
+  if (var == nullptr || decrefStmt == nullptr) {
+    return;
+  }
+  ASSERT_NOT_NULL(irMap);
+  auto mit = irMap->FindDecrefItem(*var);
+  if (mit != irMap->GetDecrefsEnd()) {
+    MapleSet<MeStmt*> *set = mit->second;
+    (void)set->insert(decrefStmt);
+    irMap->SetDecrefs(*var, *set);
+  } else {
+    MapleAllocator *irMapAlloc = &irMap->GetIRMapAlloc();
+    MapleSet<MeStmt*> *set = irMapAlloc->GetMemPool()->New<MapleSet<MeStmt*>>(std::less<MeStmt*>(),
+                                                                              irMapAlloc->Adapter());
+    (void)set->insert(decrefStmt);
+    irMap->SetDecrefs(*var, *set);
+  }
+}
+
+UnaryMeStmt *PlacementRC::GenerateDecrefreset(OStIdx ostIdx, BB &bb) const {
+  UnaryMeStmt *decrefStmt = irMap->New<UnaryMeStmt>(OP_decrefreset);
+  decrefStmt->SetBB(&bb);
+
+  AddrofMeExpr addrofMeExpr(-1, PTY_ptr, ssaTab->GetOriginalStFromID(ostIdx));
+  decrefStmt->SetMeStmtOpndValue(irMap->HashMeExpr(addrofMeExpr));
+  return decrefStmt;
+}
+
+void PlacementRC::HandleThrowOperand(SRealOcc &realOcc, ThrowMeStmt &thwStmt) {
+  VarMeExpr *tempVar = nullptr;
+  bool doAddCleanup = false;
+
+  if (placementRCTemp == nullptr) {
+    // Allocate a new localrefvar
+    GStrIdx tempStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("_placerc_temp");
+    tempVar = irMap->CreateNewLocalRefVarTmp(tempStrIdx, workCand->GetOst()->GetTyIdx());
+    OriginalSt *tempVarOst = tempVar->GetOst();
+    placementRCTemp = irMap->GetOrCreateZeroVersionVarMeExpr(*tempVarOst);
+    doAddCleanup = true;
+  } else {
+    tempVar = irMap->CreateVarMeExprVersion(*placementRCTemp);
+  }
+
+  // Generate a copy to tempVar and regard this as the last use of workCand
+  DassignMeStmt *newDass =
+      static_cast<DassignMeStmt *>(irMap->CreateAssignMeStmt(*tempVar, *realOcc.GetVar(), realOcc.GetBB()));
+  newDass->SetSrcPos(thwStmt.GetSrcPosition());
+  newDass->EnableNeedDecref();
+  tempVar->SetDefByStmt(*newDass);
+  realOcc.GetBB().InsertMeStmtBefore(&thwStmt, newDass);
+  // Generate a decref statement before that copy statement
+  UnaryMeStmt *decrefStmt = irMap->New<UnaryMeStmt>(OP_decref);
+  decrefStmt->SetBB(&realOcc.GetBB());
+  decrefStmt->SetSrcPos(thwStmt.GetSrcPosition());
+  decrefStmt->SetMeStmtOpndValue(placementRCTemp);
+  realOcc.GetBB().InsertMeStmtBefore(newDass, decrefStmt);
+  // Store nullptr into workCand
+  VarMeExpr *candVar = irMap->CreateVarMeExprVersion(*realOcc.GetVar());
+  AssignMeStmt *resetDass =
+      irMap->CreateAssignMeStmt(*candVar, *irMap->CreateIntConstMeExpr(0, PTY_ptr), realOcc.GetBB());
+  resetDass->SetSrcPos(thwStmt.GetSrcPosition());
+  candVar->SetDefByStmt(*resetDass);
+  realOcc.GetBB().InsertMeStmtBefore(&thwStmt, resetDass);
+  // Replace thwStmt's operand by tempVar
+  thwStmt.SetMeStmtOpndValue(tempVar);
+
+  // Add placementRCTemp as argument to the cleanup intrinsics
+  if (doAddCleanup) {
+    AddCleanupArg();
+  }
+}
+
+void PlacementRC::AddCleanupArg() {
+  auto cfg = func->GetCfg();
+  for (BB *bb : cfg->GetCommonExitBB()->GetPred()) {
+    auto &meStmts = bb->GetMeStmts();
+    if (meStmts.empty() || meStmts.back().GetOp() != OP_return) {
+      continue;
+    }
+
+    MeStmt *meStmt = meStmts.back().GetPrev();
+    while (meStmt != nullptr && meStmt->GetOp() != OP_intrinsiccall) {
+      meStmt = meStmt->GetPrev();
+    }
+
+    if (meStmt != nullptr) {
+      CHECK_FATAL(meStmt->GetOp() == OP_intrinsiccall, "HandleThrowOperand: cannot find cleanup intrinsic stmt");
+    }
+
+    auto *intrn = static_cast<IntrinsiccallMeStmt*>(meStmt);
+    CHECK_NULL_FATAL(intrn);
+    CHECK_FATAL(intrn->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS,
+                "HandleThrowOperand: cannot find cleanup intrinsic stmt");
+    intrn->PushBackOpnd(placementRCTemp);
+  }
+}
+
+static bool IsDereferenced(const MeExpr &meExpr, const OStIdx &ostIdx) {
+  switch (meExpr.GetMeOp()) {
+    case kMeOpIvar: {
+      const auto &ivarExpr = static_cast<const IvarMeExpr&>(meExpr);
+      if (ivarExpr.GetBase()->GetMeOp() == kMeOpVar &&
+          static_cast<const VarMeExpr*>(ivarExpr.GetBase())->GetOstIdx() == ostIdx) {
+        return true;
+      }
+      return IsDereferenced(*ivarExpr.GetBase(), ostIdx);
+    }
+    case kMeOpOp: {
+      const auto &op = static_cast<const OpMeExpr&>(meExpr);
+      if (meExpr.GetOp() == OP_iaddrof || meExpr.GetOp() == OP_add) {
+        if (op.GetOpnd(0)->GetMeOp() == kMeOpVar &&
+            static_cast<VarMeExpr*>(op.GetOpnd(0))->GetOstIdx() == ostIdx) {
+          return true;
+        }
+      }
+      for (size_t i = 0; i < kOperandNumTernary; i++) {
+        if (op.GetOpnd(i) == nullptr) {
+          return false;
+        }
+        if (IsDereferenced(*op.GetOpnd(i), ostIdx)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    case kMeOpNary: {
+      const auto &nary = static_cast<const NaryMeExpr&>(meExpr);
+      const MapleVector<MeExpr*> &opnds = nary.GetOpnds();
+      CHECK_FATAL(!opnds.empty(), "container empty check");
+      if ((meExpr.GetOp() == OP_array) ||
+          (meExpr.GetOp() == OP_intrinsicop && nary.GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH) ||
+          (meExpr.GetOp() == OP_intrinsicopwithtype && nary.GetIntrinsic() == INTRN_JAVA_INSTANCE_OF)) {
+        if (opnds[0]->GetMeOp() == kMeOpVar &&
+            static_cast<VarMeExpr*>(opnds[0])->GetOstIdx() == ostIdx) {
+          return true;
+        }
+      }
+      for (MeExpr *o : opnds) {
+        if (IsDereferenced(*o, ostIdx)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+// occstmt is the statement containing the last use of ostIdx; check if OK to
+// insert ostIdx's decrefreset after occstmt
+static bool CannotInsertAfterStmt(const MeStmt &occStmt, OStIdx ostIdx, bool realFromDef) {
+  if (kOpcodeInfo.IsCall(occStmt.GetOp())) {
+    if (realFromDef) {
+      return false;
+    }
+    // Return false if ostIdx is an actual parameter; otherwise true
+    const auto &callStmt = static_cast<const NaryMeStmt&>(occStmt);
+    for (size_t i = 0; i < callStmt.NumMeStmtOpnds(); i++) {
+      if (callStmt.GetOpnd(i)->GetMeOp() == kMeOpVar &&
+          static_cast<VarMeExpr*>(callStmt.GetOpnd(i))->GetOstIdx() == ostIdx) {
+        return false;
+      }
+      if (IsDereferenced(*callStmt.GetOpnd(i), ostIdx)) {
+        return false;
+      }
+      if (callStmt.GetOpnd(i)->GetOp() == OP_retype) {
+        auto *retypex = static_cast<OpMeExpr*>(callStmt.GetOpnd(i));
+        if (retypex->GetOpnd(0)->GetMeOp() == kMeOpVar &&
+            static_cast<VarMeExpr*>(retypex->GetOpnd(0))->GetOstIdx() == ostIdx) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  if (occStmt.GetOp() == OP_return || occStmt.GetOp() == OP_throw) {
+    return true;
+  }
+  const BB *lastUseBB = occStmt.GetBB();
+  if (&occStmt == to_ptr(lastUseBB->GetMeStmts().rbegin()) && lastUseBB->GetKind() != kBBFallthru) {
+    return true;
+  }
+  if (!realFromDef && occStmt.GetOp() == OP_dassign) {
+    const auto &dass = static_cast<const DassignMeStmt&>(occStmt);
+    return dass.GetVarLHS()->GetOstIdx() == ostIdx;
+  }
+  return false;
+}
+
+// Insert decrefreset at entry of bb, if there is no define of workCand in bb.
+// Otherwise insert it before the redefine stmt. because there maybe some stmts
+// which will throw exception in the bb before the redefine stmt, and the old
+// value maybe used later
+void PlacementRC::CheckAndInsert(BB &bb, SOcc *occ) {
+  MeStmt *defStmt = GetDefStmt(bb); // Check if there is a redefinition if this is a try block
+  UnaryMeStmt *decrefStmt = GenerateDecrefreset(workCand->GetTheVar()->GetOstIdx(), bb);
+
+  // Need to insert immediately before redefinition in case of throw
+  VarMeExpr *var = nullptr;
+  if (occ != nullptr) {
+    var = (occ->GetOccTy() == kSOccReal) ? static_cast<SRealOcc*>(occ)->GetVar() : static_cast<SPhiOcc*>(occ)->GetVar();
+  }
+
+  if (defStmt != nullptr) {
+    if (kOpcodeInfo.IsCallAssigned(defStmt->GetOp())) {
+      // Store the new value to a reg for callassigned stmt in case it has use in the call
+      MapleVector<MustDefMeNode> *mustDefList = defStmt->GetMustDefList();
+      CHECK_FATAL(mustDefList != nullptr, "mustdef list must be not nullptr.");
+      CHECK_FATAL(!mustDefList->empty(), "mustdef list must be not empty.");
+      MustDefMeNode *mustDefMeNode = &mustDefList->front();
+      ScalarMeExpr *mdLHS = mustDefMeNode->GetLHS();
+      ASSERT(mdLHS->GetMeOp() == kMeOpVar, "MeExprOp of mustDefMeNode lhs must be kMeOpVar");
+      ASSERT(static_cast<VarMeExpr *>(mdLHS)->GetOstIdx() == workCand->GetTheVar()->GetOstIdx(), "ostIdx not equal");
+      RegMeExpr *curReg = irMap->CreateRegMeExpr(PTY_ref);
+      mustDefMeNode->UpdateLHS(*curReg);
+      // Create new dassign for original lhs
+      MeStmt *newDass = irMap->CreateAssignMeStmt(*mdLHS, *curReg, bb);
+      mdLHS->SetDefByStmt(*newDass);
+      newDass->SetSrcPos(defStmt->GetSrcPosition());
+      bb.InsertMeStmtAfter(defStmt, newDass);
+      bb.InsertMeStmtBefore(newDass, decrefStmt);
+      CollectDecref(var, decrefStmt);
+    } else {
+      bb.InsertMeStmtBefore(defStmt, decrefStmt);
+      CollectDecref(var, decrefStmt);
+    }
+
+    if (occ != nullptr && occ->GetOccTy() == kSOccPhi) {
+      MePhiNode *phi = static_cast<SPhiOcc*>(occ)->GetPhiNode();
+      for (auto *phiOpnd : phi->GetOpnds()) {
+        CollectDecref(static_cast<VarMeExpr*>(phiOpnd), decrefStmt);
+      }
+    }
+  } else {
+    // Match throw special case
+    // Frame unwinding takes care of RC for us
+    if (!GoStraightToThrow(bb)) {
+      InsertAtBBEntry(bb, *decrefStmt);
+      CollectDecref(var, decrefStmt);
+      if (occ != nullptr && occ->GetOccTy() == kSOccPhi) {
+        MePhiNode *phi = static_cast<SPhiOcc*>(occ)->GetPhiNode();
+        for (auto *phiOpnd : phi->GetOpnds()) {
+          CollectDecref(static_cast<VarMeExpr*>(phiOpnd), decrefStmt);
+        }
+      }
+    }
+  }
+}
+
+// Check if there is a redefinition if this is a try block
+MeStmt *PlacementRC::GetDefStmt(BB &bb) {
+  MeStmt *defStmt = nullptr;
+
+  if (bb.GetAttributes(kBBAttrIsTry)) {
+    for (auto &stmt : bb.GetMeStmts()) {
+      if (stmt.GetOp() == OP_dassign || stmt.GetOp() == OP_maydassign) {
+        VarMeExpr *lhs = static_cast<VarMeExpr *>(stmt.GetVarLHS());
+        CHECK_NULL_FATAL(lhs);
+        if (lhs->GetOst() == workCand->GetTheVar()->GetOst()) {
+          defStmt = &stmt;
+          break;
+        }
+      } else if (kOpcodeInfo.IsCallAssigned(stmt.GetOp())) {
+        MapleVector<MustDefMeNode> *mustdefList = stmt.GetMustDefList();
+        CHECK_NULL_FATAL(mustdefList);
+
+        if (mustdefList->empty() || mustdefList->front().GetLHS()->GetMeOp() != kMeOpVar) {
+          continue;
+        }
+
+        auto *theLHS = static_cast<VarMeExpr*>(mustdefList->front().GetLHS());
+        if (theLHS->GetOst() == workCand->GetTheVar()->GetOst()) {
+          defStmt = &stmt;
+          break;
+        }
+      }
+    }
+  }
+
+  return defStmt;
+}
+
+bool PlacementRC::GoStraightToThrow(const BB &bb) const {
+  if (!(bb.GetMeStmts().empty()) &&
+      bb.GetMeStmts().back().GetOp() == OP_throw &&
+      bb.GetSucc().empty()) {
+    return true;
+  }
+  const BB *temp = &bb;
+  while (temp != nullptr && temp->GetSucc().size() == 1) {
+    temp = temp->GetSucc(0);
+    if (!(temp->GetMeStmts().empty()) &&
+        temp->GetMeStmts().back().GetOp() == OP_throw &&
+        temp->GetSucc().empty()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+SOcc *PlacementRC::FindLambdaReal(const SLambdaOcc &occ) const {
+  auto cfg = func->GetCfg();
+  std::vector<bool> visitedBBs(cfg->NumBBs(), false);
+  std::set<BBId> lambdaRealBBs;
+  FindRealPredBB(occ.GetBB(), visitedBBs, lambdaRealBBs);
+  SOcc *retOcc = nullptr;
+  for (SOcc *realOcc : workCand->GetRealOccs()) {
+    if (realOcc->GetOccTy() == kSOccUse) {
+      continue;
+    }
+    BB *mirBB = &realOcc->GetBB();
+    if (lambdaRealBBs.find(mirBB->GetBBId()) != lambdaRealBBs.end()) {
+      if (retOcc == nullptr) {
+        retOcc = realOcc;
+      } else if (&retOcc->GetBB() != mirBB) {
+        std::vector<bool> bbVisited(cfg->NumBBs(), false);
+        retOcc->GetBB().FindReachableBBs(bbVisited);
+        if (bbVisited[mirBB->GetBBId()]) {
+          retOcc = realOcc;
+        }
+      }
+    }
+  }
+  return retOcc;
+}
+
+void PlacementRC::FindRealPredBB(const BB &bb, std::vector<bool> &visitedBBs, std::set<BBId> &lambdaRealSet) const {
+  BBId id = bb.GetBBId();
+  if (visitedBBs[id]) {
+    return;
+  }
+  visitedBBs[id] = true;
+
+  if (bbHasReal[id]) {
+    (void)lambdaRealSet.insert(id);
+    return;
+  }
+  for (BB *pred : bb.GetPred()) {
+    FindRealPredBB(*pred, visitedBBs, lambdaRealSet);
+  }
+}
+
+void PlacementRC::CodeMotion() {
+  ResetHasReal();
+  UpdateHasRealWithRealOccs(workCand->GetRealOccs());
+
+  UnaryMeStmt *entryIncref = nullptr;
+  if (workCand->GetOst()->IsFormal()) {
+    if (!MeOption::gcOnly) {
+      entryIncref = GenIncrefAtEntry(*workCand->GetOst());
+    }
+    SetFormalParamsAttr(*func->GetMirFunc());
+  }
+
+  for (SOcc *occ : allOccs) {
+    if (occ->GetOccTy() == kSOccReal) {
+      CodeMotionForReal(static_cast<SRealOcc&>(*occ), entryIncref);
+    } else if (occ->GetOccTy() == kSOccLambdaRes) {
+      CodeMotionForSLambdares(static_cast<SLambdaResOcc&>(*occ));
+    }
+  }
+
+  // Do insertions at catch blocks according to catchBlocks2Insert
+  auto cfg = func->GetCfg();
+  for (BBId bbId : catchBlocks2Insert) {
+    BB *bb = cfg->GetBBFromID(bbId);
+    CheckAndInsert(*bb, nullptr);
+  }
+}
+
+void PlacementRC::ResetHasReal() {
+  for (size_t i = 0; i < bbHasReal.size(); i++) {
+    bbHasReal[i] = false;
+  }
+}
+
+void PlacementRC::UpdateHasRealWithRealOccs(const MapleVector<SOcc*> &realOccs) {
+  for (SOcc *realOcc : realOccs) {
+    if (realOcc->GetOccTy() == kSOccReal || realOcc->GetOccTy() == kSOccPhi) {
+      bbHasReal[realOcc->GetBB().GetBBId()] = true;
+    }
+  }
+}
+
+void PlacementRC::SetFormalParamsAttr(MIRFunction &mirFunc) const {
+  for (uint32 i = (mirFunc.IsStatic() ? 0 : 1); i < mirFunc.GetFormalCount(); i++) {
+    MIRSymbol *formalSt = mirFunc.GetFormal(i);
+    if (formalSt->GetType()->GetPrimType() != PTY_ref) {
+      continue;
+    }
+    ASSERT_NOT_NULL(ssaTab);
+    OriginalSt *ost = ssaTab->GetOriginalStTable().FindSymbolOriginalSt(*formalSt);
+    if (workCand->GetOst() == ost) {
+      formalSt->SetLocalRefVar();
+    }
+  }
+}
+
+void PlacementRC::DeleteEntryIncref(SRealOcc &realOcc, UnaryMeStmt *entryIncref) const {
+  CHECK_NULL_FATAL(entryIncref);
+  CHECK_FATAL(workCand->GetOst()->IsFormal(), "PlacementRC::CodeMotion: realOcc->meStmt cannot be null");
+
+  // Store nullptr into workCand
+  VarMeExpr *candVar = irMap->CreateVarMeExprVersion(*realOcc.GetVar());
+  auto *resetDass = irMap->CreateAssignMeStmt(*candVar, *irMap->CreateIntConstMeExpr(0, PTY_ptr), realOcc.GetBB());
+  resetDass->SetSrcPos(entryIncref->GetSrcPosition());
+  candVar->SetDefByStmt(*resetDass);
+  CHECK_FATAL(func->GetCfg()->GetFirstBB(), "firstBB is nullptr!");
+  func->GetCfg()->GetFirstBB()->InsertMeStmtBefore(entryIncref, resetDass);
+  func->GetCfg()->GetFirstBB()->RemoveMeStmt(entryIncref);
+}
+
+void PlacementRC::UpdateCatchBlocks2Insert(const BB &lastUseBB) {
+  if (!lastUseBB.GetAttributes(kBBAttrIsTry)) {
+    return;
+  }
+
+  for (BB *suc : lastUseBB.GetSucc()) {
+    if (suc->GetAttributes(kBBAttrIsCatch) && suc != &lastUseBB) {
+      (void)catchBlocks2Insert.insert(suc->GetBBId());
+    }
+  }
+}
+
+void PlacementRC::ReplaceOpndWithReg(MeExpr &opnd, BB &lastUseBB, const SRealOcc &realOcc, uint32 idx) const {
+  // Save this operand in a preg
+  RegMeExpr *curReg = opnd.GetPrimType() != PTY_ref ? irMap->CreateRegMeExpr(opnd.GetPrimType())
+                                                    : irMap->CreateRegMeExpr(opnd);
+  MeStmt *regAss = irMap->CreateAssignMeStmt(*curReg, opnd, lastUseBB);
+  curReg->SetDefByStmt(*regAss);
+  lastUseBB.InsertMeStmtBefore(realOcc.GetStmt(), regAss);
+
+  // Replace this operand of the stmt by the preg
+  realOcc.GetStmt()->SetOpnd(idx, curReg);
+}
+
+void PlacementRC::HandleCanInsertAfterStmt(const SRealOcc &realOcc, UnaryMeStmt &decrefStmt, BB &lastUseBB) {
+  // In case use and def the same symbol
+  if (kOpcodeInfo.IsCallAssigned(realOcc.GetStmt()->GetOp())) {
+    MapleVector<MustDefMeNode> *mustDefList = realOcc.GetStmt()->GetMustDefList();
+    CHECK_NULL_FATAL(mustDefList);
+    if (!mustDefList->empty()) {
+      MustDefMeNode *mustDefMeNode = &mustDefList->front();
+      ScalarMeExpr *mdLHS = mustDefMeNode->GetLHS();
+      if (!realOcc.GetRealFromDef()) {
+        if (mdLHS->GetMeOp() == kMeOpVar &&
+            static_cast<VarMeExpr*>(mdLHS)->GetOst() == realOcc.GetVar()->GetOst()) {
+          RegMeExpr *curReg = irMap->CreateRegMeExpr(PTY_ref);
+          mustDefMeNode->UpdateLHS(*curReg);
+
+          // Create new dassign for original lhs
+          MeStmt *newDass = irMap->CreateAssignMeStmt(*mdLHS, *curReg, lastUseBB);
+          mdLHS->SetDefByStmt(*newDass);
+          newDass->SetSrcPos(realOcc.GetStmt()->GetSrcPosition());
+          lastUseBB.InsertMeStmtAfter(realOcc.GetStmt(), newDass);
+          lastUseBB.InsertMeStmtBefore(newDass, &decrefStmt);
+          CollectDecref(realOcc.GetVar(), &decrefStmt);
+          return;
+        }
+      } else if (mdLHS->GetMeOp() == kMeOpReg) {
+        // The case callasigned (dassign var) ==> callassigned (regassign reg). Find the real defStmt.
+        MeStmt *defStmt = nullptr;
+        BB *bb = realOcc.GetVar()->GetDefByBBMeStmt(*cfg, defStmt);
+        CHECK_FATAL(bb == &lastUseBB, "the bb is not last use bb");
+        CHECK_NULL_FATAL(defStmt);
+        lastUseBB.InsertMeStmtAfter(defStmt, &decrefStmt);
+        CollectDecref(realOcc.GetVar(), &decrefStmt);
+        return;
+      }
+    }
+  }
+  lastUseBB.InsertMeStmtAfter(realOcc.GetStmt(), &decrefStmt);
+}
+
+void PlacementRC::HandleCannotInsertAfterStmt(const SRealOcc &realOcc, UnaryMeStmt &decrefStmt, BB &lastUseBB) {
+  for (size_t i = 0; i < realOcc.GetStmt()->NumMeStmtOpnds(); i++) {
+    MeExpr *curOpnd = realOcc.GetStmt()->GetOpnd(i);
+    if (!curOpnd->SymAppears(realOcc.GetVar()->GetOstIdx())) {
+      continue;
+    }
+    ReplaceOpndWithReg(*curOpnd, lastUseBB, realOcc, i);
+  }
+
+  // Insert decrefreset before stmt
+  lastUseBB.InsertMeStmtBefore(realOcc.GetStmt(), &decrefStmt);
+}
+
+void PlacementRC::CodeMotionForSLambdares(SLambdaResOcc &lambdaResOcc) {
+  if (!lambdaResOcc.GetInsertHere()) {
+    return;
+  }
+  const SLambdaOcc *lambdaOcc = lambdaResOcc.GetUseLambdaOcc();
+  SOcc *lambdaRealOcc = FindLambdaReal(*lambdaOcc);
+  if (enabledDebug) {
+    if (lambdaRealOcc == nullptr) {
+      LogInfo::MapleLogger() << "lambda->real is null in func:" << func->GetName() << '\n';
+    } else {
+      LogInfo::MapleLogger() << "lambdares in bb" << lambdaResOcc.GetBB().GetBBId() << " real is in bb" <<
+          lambdaRealOcc->GetBB().GetBBId() << '\n';
+      if (lambdaRealOcc->GetOccTy() == kSOccReal) {
+        static_cast<SRealOcc*>(lambdaRealOcc)->GetStmt()->Dump(irMap);
+      } else {
+        static_cast<SPhiOcc*>(lambdaRealOcc)->GetPhiNode()->Dump(irMap);
+      }
+    }
+  }
+  CheckAndInsert(lambdaResOcc.GetBB(), lambdaRealOcc);
+}
+
+void PlacementRC::CodeMotionForReal(SOcc &occ, UnaryMeStmt *entryIncref) {
+  SRealOcc &realOcc = static_cast<SRealOcc&>(occ);
+  if (realOcc.GetRedundant()) {
+    return;
+  }
+
+  BB *lastUseBB = &occ.GetBB();
+
+  UpdateCatchBlocks2Insert(*lastUseBB);
+
+  // Special case: delete the formal's entry incref
+  if (realOcc.GetStmt() == nullptr) {
+    if (!MeOption::gcOnly) {
+      CHECK_FATAL(lastUseBB == func->GetCfg()->GetFirstBB(),
+                  "PlacementRC::CodeMotion: realOcc from entry incref has wrong bb");
+      DeleteEntryIncref(realOcc, entryIncref);
+    }
+    return;
+  }
+
+  if (realOcc.GetStmt()->GetOp() == OP_return && realOcc.GetStmt()->GetOpnd(0)->GetMeOp() == kMeOpVar) {
+    realOcc.GetVar()->SetNoSubsumeRC(true);
+    return;  // No decref for localrefvar being return operand
+  }
+
+  if (realOcc.GetStmt()->GetOp() == OP_throw && !MeOption::gcOnly) {
+    ThrowMeStmt *thwStmt = static_cast<ThrowMeStmt*>(realOcc.GetStmt());
+    if (thwStmt->GetOpnd()->GetMeOp() == kMeOpVar && !realOcc.GetBB().GetSucc().empty()) {
+      HandleThrowOperand(realOcc, *thwStmt);
+    }
+    return;
+  }
+
+  UnaryMeStmt *decrefStmt = GenerateDecrefreset(realOcc.GetVar()->GetOstIdx(), *lastUseBB);
+  if (CannotInsertAfterStmt(*realOcc.GetStmt(), realOcc.GetVar()->GetOstIdx(), realOcc.GetRealFromDef())) {
+    HandleCannotInsertAfterStmt(realOcc, *decrefStmt, *lastUseBB);
+  } else {  // Ordinary case
+    HandleCanInsertAfterStmt(realOcc, *decrefStmt, *lastUseBB);
+  }
+
+  if (realOcc.GetVar()->PointsToStringLiteral()) {
+    MeExpr *zeroExpr = irMap->CreateIntConstMeExpr(0, realOcc.GetVar()->GetPrimType());
+    VarMeExpr *newVar = irMap->CreateVarMeExprVersion(*realOcc.GetVar());
+    DassignMeStmt *newstmt =
+        static_cast<DassignMeStmt *>(irMap->CreateAssignMeStmt(*newVar, *zeroExpr, realOcc.GetBB()));
+    realOcc.GetBB().ReplaceMeStmt(decrefStmt, newstmt);
+    return;
+  }
+
+  CollectDecref(realOcc.GetVar(), decrefStmt);
+}
+
+// ================ Step 0: Collect occurrences ================
+void PlacementRC::CreateEmptyCleanupIntrinsics() {
+  auto cfg = func->GetCfg();
+  for (BB *bb : cfg->GetCommonExitBB()->GetPred()) {
+    auto &meStmts = bb->GetMeStmts();
+    if (!meStmts.empty() && meStmts.back().GetOp() == OP_return) {
+      IntrinsiccallMeStmt *intrn =
+          irMap->NewInPool<IntrinsiccallMeStmt>(OP_intrinsiccall, INTRN_MPL_CLEANUP_LOCALREFVARS);
+      bb->InsertMeStmtBefore(&(meStmts.back()), intrn);
+    }
+  }
+}
+
+void PlacementRC::GenEntryOcc4Formals() {
+  for (uint32 i = 0; i < func->GetMirFunc()->GetFormalCount(); i++) {
+    MIRSymbol *formalSt = func->GetMirFunc()->GetFormal(i);
+    if (formalSt->GetType()->GetPrimType() != PTY_ref) {
+      continue;
+    }
+    ASSERT_NOT_NULL(ssaTab);
+    OriginalSt *ost = ssaTab->GetOriginalStTable().FindSymbolOriginalSt(*formalSt);
+    if (ost == nullptr) {
+      continue;
+    }
+    CreateRealOcc(ost->GetIndex(), nullptr, *irMap->GetOrCreateZeroVersionVarMeExpr(*ost));
+  }
+}
+
+// Create a new phi occurrence for the def of a localrefvar
+void PlacementRC::CreatePhiOcc(const OStIdx &ostIdx, BB &bb, MePhiNode &phi, VarMeExpr &var) {
+  SpreWorkCand *wkCand = nullptr;
+  auto mapIt = workCandMap.find(ostIdx);
+  if (mapIt != workCandMap.end()) {
+    wkCand = mapIt->second;
+  } else {
+    OriginalSt *ost = ssaTab->GetSymbolOriginalStFromID(ostIdx);
+    wkCand = spreMp->New<SpreWorkCand>(spreAllocator, *ost);
+    workCandMap[ostIdx] = wkCand;
+  }
+  if (wkCand->GetTheVar() == nullptr) {
+    wkCand->SetTheVar(var);
+  }
+  SPhiOcc *newOcc = spreMp->New<SPhiOcc>(bb, phi, var);
+  wkCand->GetRealOccs().push_back(newOcc);
+}
+
+// Create a new real occurrence for the def of a localrefvar
+void PlacementRC::CreateRealOcc(const OStIdx &ostIdx, MeStmt *meStmt, VarMeExpr &var, bool causedByDef) {
+  SpreWorkCand *wkCand = nullptr;
+  auto mapIt = workCandMap.find(ostIdx);
+  if (mapIt != workCandMap.end()) {
+    wkCand = mapIt->second;
+  } else {
+    OriginalSt *ost = ssaTab->GetSymbolOriginalStFromID(ostIdx);
+    wkCand = spreMp->New<SpreWorkCand>(spreAllocator, *ost);
+    workCandMap[ostIdx] = wkCand;
+  }
+  if (wkCand->GetTheVar() == nullptr) {
+    wkCand->SetTheVar(var);
+  }
+  SRealOcc *newOcc = meStmt != nullptr ? spreMp->New<SRealOcc>(*meStmt, var)
+                                       : spreMp->New<SRealOcc>(*func->GetCfg()->GetFirstBB(), var);
+  if (causedByDef) {
+    newOcc->SetRealFromDef(true);
+  }
+  wkCand->GetRealOccs().push_back(newOcc);
+}
+
+// Create a new use occurrence for symbol ostIdx resulting from the given dassign
+void PlacementRC::CreateUseOcc(const OStIdx &ostIdx, BB &bb, VarMeExpr &var) {
+  SpreWorkCand *wkCand = nullptr;
+  auto mapIt = workCandMap.find(ostIdx);
+  if (mapIt != workCandMap.end()) {
+    wkCand = mapIt->second;
+  } else {
+    OriginalSt *ost = ssaTab->GetSymbolOriginalStFromID(ostIdx);
+    wkCand = spreMp->New<SpreWorkCand>(spreAllocator, *ost);
+    workCandMap[ostIdx] = wkCand;
+  }
+  if (wkCand->GetTheVar() == nullptr) {
+    wkCand->SetTheVar(var);
+  }
+  SUseOcc *newOcc = spreMp->New<SUseOcc>(bb);
+  wkCand->GetRealOccs().push_back(newOcc);
+  wkCand->SetHasStoreOcc(true);
+}
+
+void PlacementRC::FindLocalrefvarUses(MeExpr &meExpr, MeStmt *meStmt) {
+  if (meExpr.GetMeOp() == kMeOpVar) {
+    VarMeExpr &varx = static_cast<VarMeExpr&>(meExpr);
+    if (varx.GetPrimType() != PTY_ref) {
+      return;
+    }
+    const OriginalSt *ost = varx.GetOst();
+    if (preKind == kSecondDecrefPre && !ost->IsEPreLocalRefVar()) {
+      return;
+    }
+    if (!ost->IsLocal() || ost->IsIgnoreRC()) {
+      return;
+    }
+    CreateRealOcc(varx.GetOstIdx(), meStmt, varx);
+    return;
+  }
+  for (size_t i = 0; i < meExpr.GetNumOpnds(); i++) {
+    FindLocalrefvarUses(*meExpr.GetOpnd(i), meStmt);
+  }
+}
+
+void PlacementRC::SetNeedIncref(MeStmt &stmt) const {
+  VarMeExpr *theLHS = static_cast<VarMeExpr*>(stmt.GetLHSRef(false));
+  if (theLHS != nullptr) {  // Set need_incref
+    if (preKind == kDecrefPre) {
+      CHECK_NULL_FATAL(stmt.GetRHS());
+      if (stmt.GetRHS()->PointsToSomethingThatNeedsIncRef()) {
+        stmt.EnableNeedIncref();
+      }
+    } else {
+      const OriginalSt *ost = theLHS->GetOst();
+      if (ost->IsEPreLocalRefVar()) {
+        stmt.EnableNeedIncref();
+      }
+    }
+  }
+}
+
+// Check if the lhs variable is being dereferenced in the rhs; if so,
+// save the rhs value to a preg, insert the regassign before stmt and
+// replace the rhs by the preg
+void PlacementRC::ReplaceRHSWithPregForDassign(MeStmt &stmt, BB &bb) const {
+  VarMeExpr *theLHS = static_cast<VarMeExpr*>(stmt.GetLHSRef(false));
+  if (theLHS != nullptr) {
+    const OriginalSt *ost = theLHS->GetOst();
+    if (ost->IsLocal()) {
+      DassignMeStmt &dass = static_cast<DassignMeStmt&>(stmt);
+      if (IsDereferenced(*dass.GetRHS(), ost->GetIndex())) {
+        RegMeExpr *regTemp = irMap->CreateRegMeExpr(*theLHS);
+        AssignMeStmt *rass = irMap->CreateAssignMeStmt(*regTemp, *dass.GetRHS(), bb);
+        regTemp->SetDefByStmt(*rass);
+        bb.InsertMeStmtBefore(&stmt, rass);
+        dass.SetRHS(regTemp);
+      }
+    }
+  }
+}
+
+// Check if there is actual parameter being also the return value; if so,
+// change return value to a preg and insert a dassign after it
+bool PlacementRC::DoesDassignInsertedForCallAssigned(MeStmt &stmt, BB &bb) const {
+  VarMeExpr *theLHS = static_cast<VarMeExpr*>(stmt.GetLHSRef(false));
+  if (theLHS == nullptr) {
+    return false;
+  }
+  const OriginalSt *ost = theLHS->GetOst();
+  CHECK_NULL_FATAL(ost);
+  if (!ost->IsLocal()) {
+    return false;
+  }
+  bool resAmongOpnds = false;
+  for (size_t i = 0; i < stmt.NumMeStmtOpnds(); i++) {
+    MeExpr *curOpnd = stmt.GetOpnd(i);
+    if (curOpnd->GetMeOp() == kMeOpVar && static_cast<VarMeExpr*>(curOpnd)->GetOst() == theLHS->GetOst()) {
+      resAmongOpnds = true;
+      break;
+    }
+  }
+
+  if (!resAmongOpnds) {
+    return false;
+  }
+  RegMeExpr *regTemp = irMap->CreateRegMeExpr(*theLHS);
+  MapleVector<MustDefMeNode> *mustDefList = stmt.GetMustDefList();
+  CHECK_NULL_FATAL(mustDefList);
+  CHECK_FATAL(!mustDefList->empty(), "container check");
+  mustDefList->front().UpdateLHS(*regTemp);
+  DassignMeStmt *dass = static_cast<DassignMeStmt *>(irMap->CreateAssignMeStmt(*theLHS, *regTemp, bb));
+  theLHS->SetDefByStmt(*dass);
+  bb.InsertMeStmtAfter(&stmt, dass);
+  return true;
+}
+
+void PlacementRC::LookForRealOccOfStores(MeStmt &stmt, BB &bb) {
+  if (stmt.GetOp() == OP_dassign || kOpcodeInfo.IsCallAssigned(stmt.GetOp())) {
+    VarMeExpr *theLHS = static_cast<VarMeExpr*>(stmt.GetLHSRef(false));
+    if (theLHS != nullptr) {
+      const OriginalSt *ost = theLHS->GetOst();
+      if ((preKind == kDecrefPre && ost->IsLocal()) || (preKind == kSecondDecrefPre && ost->IsEPreLocalRefVar())) {
+        CreateRealOcc(theLHS->GetOstIdx(), &stmt, *theLHS, true);
+        CreateUseOcc(theLHS->GetOstIdx(), bb, *theLHS);
+      }
+    }
+  }
+}
+
+void PlacementRC::LookForUseOccOfLocalRefVars(MeStmt &stmt) {
+  for (size_t i = 0; i < stmt.NumMeStmtOpnds(); i++) {
+    CHECK_NULL_FATAL(stmt.GetOpnd(i));
+    FindLocalrefvarUses(*stmt.GetOpnd(i), &stmt);
+  }
+}
+
+void PlacementRC::TraverseStatementsBackwards(BB &bb) {
+  auto &meStmts = bb.GetMeStmts();
+
+  for (auto itStmt = meStmts.rbegin(); itStmt != meStmts.rend(); ++itStmt) {
+    if (itStmt->GetOp() == OP_dassign) {  // skip identity assignments
+      DassignMeStmt *dass = static_cast<DassignMeStmt*>(to_ptr(itStmt));
+      ASSERT_NOT_NULL(dass->GetLHS());
+      if (dass->GetLHS()->IsUseSameSymbol(*dass->GetRHS())) {
+        continue;
+      }
+      SetNeedIncref(*itStmt);
+    }
+
+    if (preKind == kDecrefPre) {
+      if (itStmt->GetOp() == OP_dassign) {
+        ReplaceRHSWithPregForDassign(*itStmt, bb);
+      } else {
+        // Check if there is actual parameter being also the return value; if so,
+        // change return value to a preg and insert a dassign after it and back up
+        // stmt to point to the newly inserted dassign
+        if (kOpcodeInfo.IsCallAssigned(itStmt->GetOp()) && DoesDassignInsertedForCallAssigned(*itStmt, bb)) {
+          // dass has been inserted after current itStmt, and itStmt is reverse iterator, so itStmt-- to use dass
+          --itStmt;
+        }
+      }
+    }
+
+    LookForRealOccOfStores(*itStmt, bb);
+    LookForUseOccOfLocalRefVars(*itStmt);
+  }
+}
+
+void PlacementRC::BuildWorkListBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+
+  TraverseStatementsBackwards(*bb);
+
+  for (auto it = bb->GetMePhiList().crbegin(); it != bb->GetMePhiList().crend(); ++it) {
+    MePhiNode *phi = it->second;
+    if (!phi->GetIsLive()) {
+      continue;
+    }
+    const OriginalSt *ost = ssaTab->GetOriginalStFromID(it->first);
+    CHECK_FATAL(ost, "ost is nullptr!");
+    if (!ost->IsSymbolOst() || ost->GetIndirectLev() != 0 || ost->IsIgnoreRC()) {
+      continue;
+    }
+    if (!(preKind == kDecrefPre && ost->IsLocal()) && !(preKind == kSecondDecrefPre && ost->IsEPreLocalRefVar())) {
+      continue;
+    }
+    auto *lhs = static_cast<VarMeExpr*>(phi->GetLHS());
+    CreatePhiOcc(lhs->GetOstIdx(), *bb, *phi, *lhs);
+  }
+
+  if (bb->GetAttributes(kBBAttrIsEntry)) {
+    if (preKind != kSecondDecrefPre) {
+      GenEntryOcc4Formals();
+    }
+    CreateEntryOcc(*bb);
+  }
+
+  // Recurse on child BBs in post-dominator tree
+  for (auto bbId : pdom->GetDomChildren(bb->GetID())) {
+    BuildWorkListBB(func->GetCfg()->GetAllBBs().at(bbId));
+  }
+}
+
+void MEPlacementRC::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MEPlacementRC::PhaseRun(maple::MeFunction &f) {
+  std::string funcName = f.GetName();
+  if (whiteListFunc.find(funcName) != whiteListFunc.end() || f.GetMirFunc()->GetAttr(FUNCATTR_rclocalunowned)) {
+    return false;
+  }
+  auto *cfg = GET_ANALYSIS(MEMeCfg, f);
+  // Workaround for RCWeakRef-annotated field access: leave it to analyzerc
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+
+    for (MeStmt *stmt = to_ptr(bb->GetMeStmts().begin()); stmt != nullptr; stmt = stmt->GetNext()) {
+      if (stmt->GetOp() != OP_dassign) {
+        continue;
+      }
+
+      MeExpr *rhs = stmt->GetRHS();
+      CHECK_NULL_FATAL(rhs);
+
+      if (rhs->GetMeOp() == kMeOpIvar) {
+        IvarMeExpr *irhs = static_cast<IvarMeExpr*>(rhs);
+        if (irhs->IsRCWeak() && !irhs->IsFinal()) {
+          return false;
+        }
+      }
+    }
+  }
+
+  f.SetHints(f.GetHints() | kPlacementRCed);
+
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  ASSERT_NOT_NULL(dom);
+  auto pdom = dominancePhase->GetPdomResult();
+  ASSERT_NOT_NULL(pdom);
+  MeIRMap *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_NULL_FATAL(irMap);
+  PlacementRC placementRC(f, *dom, *pdom, *GetPhaseMemPool(), DEBUGFUNC_NEWPM(f));
+  placementRC.ApplySSUPre();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== After PLACEMENT RC =============" << '\n';
+    f.Dump(false);
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_predict.cpp b/src/mapleall/maple_me/src/me_predict.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4afb1392ff6ffd51cba86749581fe032f8797da7
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_predict.cpp
@@ -0,0 +1,1101 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_predict.h"
+#include <iostream>
+#include <queue>
+#include <unordered_set>
+#include <algorithm>
+#include "bb.h"
+#include "me_ir.h"
+#include "me_irmap_build.h"
+#include "me_irmap.h"
+#include "me_dominance.h"
+#include "optimizeCFG.h"
+#include "mir_lower.h"
+
+namespace {
+using namespace maple;
+constexpr uint32 kScaleDownFactor = 2;
+// kProbVeryUnlikely should be small enough so basic block predicted
+// by it gets below HOT_BB_FREQUENCY_FRACTION.
+constexpr int kLevelVeryUnlikely = 2000;  // higher the level, smaller the probability
+constexpr int kProbVeryUnlikely = kProbBase / kLevelVeryUnlikely - 1;
+constexpr int kProbAlways = kProbBase;
+constexpr uint32 kProbUninitialized = 0;
+constexpr int kHitRateOffset = 50;
+constexpr int kHitRateDivisor = 100;
+constexpr uint32 kMaxNumBBToPredict = 15000;
+}  // anonymous namespace
+
+namespace maple {
+// Recompute hitrate in percent to our representation.
+#define HITRATE(VAL) (static_cast<int>((VAL) * kProbBase + kHitRateOffset) / kHitRateDivisor)
+#define DEF_PREDICTOR(ENUM, NAME, HITRATE) { NAME, HITRATE },
+const PredictorInfo MePrediction::predictorInfo[kEndPrediction + 1] = {
+#include "me_predict.def"
+  // Upper bound on predictors.
+  { nullptr, 0 }
+};
+// return the edge src->dest if it exists.
+Edge *MePrediction::FindEdge(const BB &src, const BB &dest) const {
+  Edge *edge = edges[src.GetBBId()];
+  while (edge != nullptr) {
+    if (&dest == &edge->dest) {
+      return edge;
+    }
+    edge = edge->next;
+  }
+  return nullptr;
+}
+
+// Recognize backedges identified by loops.
+bool MePrediction::IsBackEdge(const Edge &edge) const {
+  for (auto *backEdge : backEdges) {
+    if (backEdge == &edge) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// search use-def chain
+const ConstMeExpr *TryGetConstExprFromMeExpr(const MeExpr *expr) {
+  if (expr == nullptr) {
+    return nullptr;
+  }
+  if (expr->GetMeOp() == kMeOpConst) {
+    return static_cast<const ConstMeExpr*>(expr);
+  }
+  if (expr->GetMeOp() == kMeOpReg) {
+    auto *reg = static_cast<const RegMeExpr*>(expr);
+    if (reg->GetDefBy() != kDefByStmt) {
+      return nullptr;
+    }
+    MeStmt *defStmt = reg->GetDefStmt();
+    if (defStmt->GetOp() != OP_regassign) {
+      return nullptr;
+    }
+    auto *rhs = static_cast<AssignMeStmt*>(defStmt)->GetRHS();
+    CHECK_NULL_FATAL(rhs);
+    if (rhs->GetMeOp() == kMeOpConst) {
+      return static_cast<ConstMeExpr*>(rhs);
+    }
+  }
+  return nullptr;
+}
+
+// Try to guess whether the value of return means error code.
+Predictor MePrediction::ReturnPrediction(const MeExpr *meExpr, Prediction &prediction) const {
+  auto *constExpr = TryGetConstExprFromMeExpr(meExpr);
+  if (constExpr == nullptr) {
+    return kPredNoPrediction;
+  }
+  PrimType retType = constExpr->GetPrimType();
+  if (MustBeAddress(retType) && constExpr->IsZero()) {
+    // nullptr is usually not returned.
+    prediction = kNotTaken;
+    return kPredNullReturn;
+  } else if (IsPrimitiveInteger(retType)) {
+    // Negative return values are often used to indicate errors.
+    if (constExpr->GetExtIntValue() < 0) {
+      prediction = kNotTaken;
+      return kPredNegativeReturn;
+    }
+    // Constant return values seems to be commonly taken.Zero/one often represent
+    // booleans so exclude them from the heuristics.
+    if (!constExpr->IsZero() && !constExpr->IsOne()) {
+      prediction = kNotTaken;
+      return kPredConstReturn;
+    }
+  }
+  return kPredNoPrediction;
+}
+
+bool MePrediction::HasEdgePredictedBy(const Edge &edge, Predictor predictor) {
+  EdgePrediction *curr = bbPredictions[edge.src.GetBBId()];
+  while (curr != nullptr) {
+    if (curr->epPredictor == predictor) {
+      return true;
+    }
+    curr = curr->epNext;
+  }
+  return false;
+}
+
+// Predict edge E with the given PROBABILITY.
+void MePrediction::PredictEdge(Edge &edge, Predictor predictor, int probability) {
+  if (&edge.src != cfg->GetCommonEntryBB() && edge.src.GetSucc().size() > 1) {
+    const BB &src = edge.src;
+    auto *newEdgePred = tmpAlloc.GetMemPool()->New<EdgePrediction>(edge);
+    EdgePrediction *bbPred = bbPredictions[src.GetBBId()];
+    newEdgePred->epNext = bbPred;
+    bbPredictions[src.GetBBId()] = newEdgePred;
+    newEdgePred->epProbability = probability;
+    newEdgePred->epPredictor = predictor;
+  }
+}
+
+// Predict edge by given predictor if possible.
+void MePrediction::PredEdgeDef(Edge &edge, Predictor predictor, Prediction taken) {
+  int probability = predictorInfo[static_cast<int>(predictor)].hitRate;
+  if (taken != kTaken) {
+    probability = kProbBase - probability;
+  }
+  PredictEdge(edge, predictor, probability);
+}
+
+void MePrediction::PredictForPostDomFrontier(const BB &bb, Predictor predictor, Prediction direction) {
+  // prediction for frontier condgoto BB
+  const auto &frontier = pdom->GetDomFrontier(bb.GetID());
+  for (auto bbId : frontier) {
+    BB *frontBB = cfg->GetBBFromID(BBId(bbId));
+    if (frontBB->GetSucc().size() != 2) {  // only consider 2-way branch BB
+      continue;
+    }
+    // find succ that leading to target return BB
+    uint32 leadingRetIdx = 0;
+    if (!pdom->Dominate(bb, *frontBB->GetSucc(0))) {
+      leadingRetIdx = 1;
+    }
+    auto *targetEdge = FindEdge(*frontBB, *frontBB->GetSucc(leadingRetIdx));
+    CHECK_NULL_FATAL(targetEdge);
+    PredEdgeDef(*targetEdge, predictor, direction);
+  }
+}
+
+// Look for basic block that contains unlikely to happen events
+// (such as noreturn calls) and mark all paths leading to execution
+// of this basic blocks as unlikely.
+void MePrediction::BBLevelPredictions() {
+  // iterate all return BB for return prediction
+  for (BB *bb : cfg->GetCommonExitBB()->GetPred()) {
+    MeStmt *lastMeStmt = to_ptr(bb->GetMeStmts().rbegin());
+    if (lastMeStmt == nullptr || lastMeStmt->GetOp() != OP_return) {
+      continue;
+    }
+    auto *retStmt = static_cast<RetMeStmt*>(lastMeStmt);
+    if (retStmt->NumMeStmtOpnds() == 0) {
+      continue;
+    }
+    MeExpr *retExpr = retStmt->GetOpnd(0);
+    auto *constExpr = TryGetConstExprFromMeExpr(retExpr);
+    if (constExpr != nullptr) {
+      Prediction direction;
+      Predictor predictor = ReturnPrediction(retExpr, direction);
+      if (predictor == kPredNoPrediction) {
+        continue;
+      }
+      // prediction for frontier condgoto BB
+      PredictForPostDomFrontier(*bb, predictor, direction);
+      continue;
+    }
+
+    // handle return opnd defined by phi
+    if (retExpr->GetMeOp() != kMeOpReg || static_cast<RegMeExpr*>(retExpr)->GetDefBy() != kDefByPhi) {
+      continue;
+    }
+    auto *regExpr = static_cast<RegMeExpr*>(retExpr);
+    auto &defPhi = regExpr->GetDefPhi();
+    const size_t defPhiOpndSize = defPhi.GetOpnds().size();
+    CHECK_FATAL(defPhiOpndSize > 0, "container check");
+    Prediction firstDirection;
+    Predictor firstPred = ReturnPrediction(defPhi.GetOpnd(0), firstDirection);
+    size_t phiNumArgs = defPhi.GetOpnds().size();
+    uint32 i = 0;
+    for (i = 1; i < phiNumArgs; ++i) {
+      Prediction direction;
+      Predictor pred = ReturnPrediction(defPhi.GetOpnd(i), direction);
+      if (pred != firstPred) {
+        break;
+      }
+    }
+
+    if (i == phiNumArgs && firstPred != kPredNoPrediction) {
+      // all phi of return opnd has same predictor
+      PredictForPostDomFrontier(*bb, firstPred, firstDirection);
+      continue;
+    }
+    for (uint32 k = 0; k < phiNumArgs; ++k) {
+      // ssa phi info is not trustable, we need check it and skip wrong info
+      if (k >= bb->GetPred().size()) {
+        break;
+      }
+      BB *currBB = bb->GetPred(k);
+      if (currBB->GetSucc().size() != 1) {
+        continue;  // skip bb with multiple succ
+      }
+      Prediction direction;
+      Predictor pred = ReturnPrediction(defPhi.GetOpnd(k), direction);
+      if (pred == kPredNoPrediction) {
+        continue;
+      }
+      PredictForPostDomFrontier(*currBB, pred, direction);
+    }
+  }
+}
+
+// Build edges for all bbs in the cfg.
+void MePrediction::Init() {
+  bbPredictions.resize(cfg->GetAllBBs().size());
+  edges.resize(cfg->GetAllBBs().size());
+  bbVisited.resize(cfg->GetAllBBs().size());
+  for (auto *bb : cfg->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    BBId idx = bb->GetBBId();
+    bbVisited[idx] = true;
+    bbPredictions[idx] = nullptr;
+    edges[idx] = nullptr;
+    for (auto *it : bb->GetSucc()) {
+      Edge *edge = tmpAlloc.GetMemPool()->New<Edge>(*bb, *it);
+      edge->next = edges[idx];
+      edges[idx] = edge;
+    }
+  }
+  if (cfg->GetCommonEntryBB() != cfg->GetFirstBB()) {
+    bbVisited[cfg->GetCommonEntryBB()->GetBBId()] = true;
+  }
+  if (cfg->GetCommonExitBB() != cfg->GetLastBB()) {
+    bbVisited[cfg->GetCommonExitBB()->GetBBId()] = true;
+  }
+}
+
+// Return true if edge is predicated by one of loop heuristics.
+bool MePrediction::PredictedByLoopHeuristic(const BB &bb) const {
+  EdgePrediction *pred = bbPredictions[bb.GetBBId()];
+  while (pred != nullptr) {
+    if (pred->epPredictor == kPredLoopExit) {
+      return true;
+    }
+    pred = pred->epNext;
+  }
+  return false;
+}
+
+// Sort loops first so that hanle innermost loop first in PropFreqInLoops.
+void MePrediction::SortLoops() {
+  const auto &bbId2rpoId = dom->GetReversePostOrderId();
+  std::stable_sort(meLoop->GetMeLoops().begin(), meLoop->GetMeLoops().end(),
+                   [&bbId2rpoId](const LoopDesc *loop1, const LoopDesc *loop2) {
+    // inner loop first
+    if (loop1->nestDepth > loop2->nestDepth) {
+      return true;
+    } else if (loop1->nestDepth < loop2->nestDepth) {
+      return false;
+    }
+    uint32_t loop1RpoId = bbId2rpoId[loop1->head->GetBBId()];
+    uint32_t loop2RpoId = bbId2rpoId[loop2->head->GetBBId()];
+    // big rpoId first
+    if (loop1RpoId > loop2RpoId) {
+      return true;
+    } else if (loop1RpoId < loop2RpoId) {
+      return false;
+    }
+    // small loop first
+    return (loop1->loopBBs.size() < loop2->loopBBs.size());
+  });
+}
+
+void MePrediction::PredictLoops() {
+  constexpr uint32 minBBNumRequired = 2;
+  for (auto *loop : meLoop->GetMeLoops()) {
+    MapleSet<BBId> &loopBBs = loop->loopBBs;
+    // Find loop exiting edge. An exiting edge is an edge from inside the loop to a node outside of the loop
+    MapleVector<Edge*> exits(tmpAlloc.Adapter());
+    for (auto &bbID : loopBBs) {
+      BB *bb = cfg->GetAllBBs().at(bbID);
+      if (bb == nullptr || bb->GetSucc().size() < minBBNumRequired) {
+        continue;
+      }
+      for (auto *it : bb->GetSucc()) {
+        ASSERT_NOT_NULL(it);
+        if (!loop->Has(*it)) {
+          Edge *edge = FindEdge(*bb, *it);
+          exits.push_back(edge);
+          break;
+        }
+      }
+    }
+    // predicate loop exit.
+    if (exits.empty()) {
+      return;
+    }
+    for (auto &exit : exits) {
+      // Loop heuristics do not expect exit conditional to be inside
+      // inner loop.  We predict from innermost to outermost loop.
+      if (PredictedByLoopHeuristic(exit->src)) {
+        continue;
+      }
+      int32 probability = kProbBase - predictorInfo[kPredLoopExit].hitRate;
+      PredictEdge(*exit, kPredLoopExit, probability);
+    }
+  }
+}
+
+// Predict using opcode of the last statement in basic block.
+void MePrediction::PredictByOpcode(BB *bb) {
+  if (bb == nullptr || bb->GetMeStmts().empty() || !bb->GetMeStmts().back().IsCondBr()) {
+    return;
+  }
+  auto &condStmt = static_cast<CondGotoMeStmt&>(bb->GetMeStmts().back());
+  bool isTrueBr = condStmt.GetOp() == OP_brtrue;
+  MeExpr *testExpr = condStmt.GetOpnd();
+  MeExpr *op0 = nullptr;
+  MeExpr *op1 = nullptr;
+  // Only predict MeOpOp operands now.
+  if (testExpr->GetMeOp() != kMeOpOp) {
+    return;
+  }
+  auto *cmpExpr = static_cast<OpMeExpr*>(testExpr);
+  op0 = cmpExpr->GetOpnd(0);
+  op1 = cmpExpr->GetOpnd(1);
+  Opcode cmp = testExpr->GetOp();
+  Edge *e0 = edges[bb->GetBBId()];
+  Edge *e1 = e0->next;
+  bool isE0BranchEdge = e0->dest.GetBBLabel() == condStmt.GetOffset();
+  Edge *jumpEdge = (isE0BranchEdge) ? e0 : e1;
+
+  // prediction for builtin_expect
+  if (condStmt.GetBranchProb() == kProbLikely) {
+    if (builtinExpectInfo != nullptr) {
+      (void)builtinExpectInfo->emplace_back(&condStmt, condStmt.GetBranchProb());
+    }
+    PredEdgeDef(*jumpEdge, kPredBuiltinExpect, kTaken);
+    return;
+  }
+  if (condStmt.GetBranchProb() == kProbUnlikely) {
+    if (builtinExpectInfo != nullptr) {
+      (void)builtinExpectInfo->emplace_back(&condStmt, condStmt.GetBranchProb());
+    }
+    PredEdgeDef(*jumpEdge, kPredBuiltinExpect, kNotTaken);
+    return;
+  }
+
+  Edge *thenEdge = (isTrueBr != isE0BranchEdge) ? e1 : e0;
+
+  PrimType pty = op0->GetPrimType();
+  bool isCmpPtr = MustBeAddress(cmpExpr->GetOpndType());
+  // cmpExpr is not always real compare op, so we should check nullptr for op0 and op1
+  bool isOpnd0Ptr = op0 != nullptr && MustBeAddress(op0->GetPrimType());
+  bool isOpnd1Ptr = op1 != nullptr && MustBeAddress(op1->GetPrimType());
+  // Try "pointer heuristic." A comparison ptr == 0 is predicted as false.
+  // Similarly, a comparison ptr1 == ptr2 is predicted as false.
+  if (isCmpPtr || isOpnd0Ptr || isOpnd1Ptr) {
+    if (cmp == OP_eq) {
+      PredEdgeDef(*thenEdge, kPredPointer, kNotTaken);
+    } else if (cmp == OP_ne) {
+      PredEdgeDef(*thenEdge, kPredPointer, kTaken);
+    }
+  } else {
+    // Try "opcode heuristic." EQ tests are usually false and NE tests are usually true. Also,
+    // most quantities are positive, so we can make the appropriate guesses
+    // about signed comparisons against zero.
+    switch (cmp) {
+      case OP_eq:
+      case OP_ne: {
+        Prediction taken = ((cmp == OP_eq) ? kNotTaken : kTaken);
+        // identify that a comparerison of an integer equal to a const or floating point numbers
+        // are equal to be not taken
+        if (IsPrimitiveFloat(pty) || (IsPrimitiveInteger(pty) && (op1->GetMeOp() == kMeOpConst))) {
+          PredEdgeDef(*thenEdge, kPredOpcodeNonEqual, taken);
+        }
+        break;
+      }
+      case OP_lt:
+      case OP_le:
+      case OP_gt:
+      case OP_ge: {
+        if (op1->GetMeOp() == kMeOpConst) {
+          auto *constVal = static_cast<ConstMeExpr*>(op1);
+          if (constVal->IsZero() || constVal->IsOne()) {
+            Prediction taken = ((cmp == OP_lt || cmp == OP_le) ? kNotTaken : kTaken);
+            PredEdgeDef(*thenEdge, kPredOpcodePositive, taken);
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+
+// skip the following meaningless BB:
+// case 1:
+// ============BB id:3 fallthru []==========
+// preds: 2
+// succs: 4
+// =========================================
+//
+// case 2:
+// ============BB id:4 goto []==============
+// preds: 3
+// succs: 5
+//    ||MEIR|| goto
+// =========================================
+static const BB *GetSignificativeSucc(BB &bb, size_t i) {
+  BB *curr = bb.GetSucc(i);
+  while (curr->GetSucc().size() == 1) {
+    BB *next = curr->GetSucc(0);
+    if ((next->GetKind() == kBBFallthru && IsMeEmptyBB(*next)) ||  // case 1
+         HasOnlyMeGotoStmt(*next)) {                               // case 2
+      curr = next;
+      continue;
+    }
+    break;
+  }
+  return curr;
+}
+
+void MePrediction::EstimateBBProb(BB &bb) {
+  for (size_t i = 0; i < bb.GetSucc().size(); ++i) {
+    const BB *dest = bb.GetSucc(i);
+    const BB *sigSucc = GetSignificativeSucc(bb, i);
+    // try fallthrou if taken.
+    if (!bb.GetMeStmts().empty() && bb.GetMeStmts().back().GetOp() == OP_try && i == 0) {
+      PredEdgeDef(*FindEdge(bb, *dest), kPredTry, kTaken);
+    } else if (sigSucc->GetAttributes(kBBAttrWontExit)) {
+      PredEdgeDef(*FindEdge(bb, *dest), kPredWontExit, kNotTaken);
+    } else if (!sigSucc->GetMeStmts().empty() && sigSucc->GetMeStmts().back().GetOp() == OP_return) {
+      Edge *currEdge = FindEdge(bb, *dest);
+      if (HasEdgePredictedBy(*currEdge, kPredNullReturn) || HasEdgePredictedBy(*currEdge, kPredNegativeReturn) ||
+          HasEdgePredictedBy(*currEdge, kPredConstReturn)) {
+        continue;
+      }
+      PredEdgeDef(*currEdge, kPredEarlyReturn, kNotTaken);
+    } else if (dest != cfg->GetCommonExitBB() && dest != &bb && dom->Dominate(bb, *dest) &&
+               !pdom->Dominate(*dest, bb)) {
+      for (const MeStmt &stmt : sigSucc->GetMeStmts()) {
+        if (stmt.GetOp() == OP_call || stmt.GetOp() == OP_callassigned) {
+          auto &callMeStmt = static_cast<const CallMeStmt&>(stmt);
+          const MIRFunction &callee = callMeStmt.GetTargetFunction();
+          // call heuristic : exceptional calls not taken.
+          if (!callee.IsPure()) {
+            PredEdgeDef(*FindEdge(bb, *dest), kPredCall, kNotTaken);
+          } else {
+            // call heristic : normal call taken.
+            PredEdgeDef(*FindEdge(bb, *dest), kPredCall, kTaken);
+          }
+          break;
+        }
+      }
+    }
+  }
+  PredictByOpcode(&bb);
+}
+
+void MePrediction::ClearBBPredictions(const BB &bb) {
+  bbPredictions[bb.GetBBId()] = nullptr;
+}
+
+// Combine predictions into single probability and store them into CFG.
+// Remove now useless prediction entries.
+void MePrediction::CombinePredForBB(const BB &bb) {
+  // When there is no successor or only one choice, prediction is easy.
+  // When we have a basic block with more than 2 successors, the situation
+  // is more complicated as DS theory cannot be used literally.
+  // More precisely, let's assume we predicted edge e1 with probability p1,
+  // thus: m1({b1}) = p1.  As we're going to combine more than 2 edges, we
+  // need to find probability of e.g. m1({b2}), which we don't know.
+  // The only approximation is to equally distribute 1-p1 to all edges
+  // different from b1.
+  constexpr uint32 succNumForComplicatedSituation = 2;
+  if (bb.GetSucc().size() != succNumForComplicatedSituation) {
+    MapleSet<Edge*> unlikelyEdges(tmpAlloc.Adapter());
+    // Identify all edges that have a probability close to very unlikely.
+    EdgePrediction *preds = bbPredictions[bb.GetBBId()];
+    if (preds != nullptr) {
+      EdgePrediction *pred = nullptr;
+      for (pred = preds; pred != nullptr; pred = pred->epNext) {
+        if (pred->epProbability <= kProbVeryUnlikely) {
+          unlikelyEdges.insert(&pred->epEdge);
+        }
+      }
+    }
+    uint32 all = kProbAlways;
+    uint32 nEdges = 0;
+    uint32 unlikelyCount = 0;
+    Edge *edge = edges[bb.GetBBId()];
+    for (Edge *e = edge; e != nullptr; e = e->next) {
+      if (e->probability > 0) {
+        CHECK_FATAL(e->probability <= all, "e->probability is greater than all");
+        all -= e->probability;
+      } else {
+        nEdges++;
+        if (!unlikelyEdges.empty() && unlikelyEdges.find(edge) != unlikelyEdges.end()) {
+          CHECK_FATAL(all >= kProbVeryUnlikely, "all is lesser than kProbVeryUnlikely");
+          all -= kProbVeryUnlikely;
+          e->probability = kProbVeryUnlikely;
+          unlikelyCount++;
+        }
+      }
+    }
+    if (unlikelyCount == nEdges) {
+      unlikelyEdges.clear();
+      ClearBBPredictions(bb);
+      return;
+    }
+    uint32 total = 0;
+    for (Edge *e = edge; e != nullptr; e = e->next) {
+      if (e->probability == kProbUninitialized) {
+        e->probability = all / (nEdges - unlikelyCount);
+        total += e->probability;
+      }
+      if (predictDebug) {
+        LogInfo::MapleLogger() << "Predictions for bb " << bb.GetBBId() << " \n";
+        if (unlikelyEdges.empty()) {
+          LogInfo::MapleLogger() << nEdges << " edges in bb " << bb.GetBBId() <<
+              " predicted to even probabilities.\n";
+        } else {
+          LogInfo::MapleLogger() << nEdges << " edges in bb " << bb.GetBBId() <<
+              " predicted with some unlikely edges\n";
+        }
+      }
+    }
+    if (total != all) {
+      edge->probability += all - total;
+    }
+    ClearBBPredictions(bb);
+    return;
+  }
+  if (predictDebug) {
+    LogInfo::MapleLogger() << "Predictions for bb " << bb.GetBBId() << " \n";
+  }
+  int nunknown = 0;
+  Edge *first = nullptr;
+  Edge *second = nullptr;
+  for (Edge *edge = edges[bb.GetBBId()]; edge != nullptr; edge = edge->next) {
+    if (first == nullptr) {
+      first = edge;
+    } else if (second == nullptr) {
+      second = edge;
+    }
+    if (edge->probability == kProbUninitialized) {
+      nunknown++;
+    }
+  }
+  // If we have only one successor which is unknown, we can compute missing probablity.
+  if (nunknown == 1) {
+    int32 prob = kProbAlways;
+    Edge *missing = nullptr;
+    for (Edge *edge = edges[bb.GetBBId()]; edge != nullptr; edge = edge->next) {
+      if (edge->probability > 0) {
+        prob -= edge->probability;
+      } else if (missing == nullptr) {
+        missing = edge;
+      } else {
+        CHECK_FATAL(false, "unreachable");
+      }
+    }
+    CHECK_FATAL(missing != nullptr, "null ptr check");
+    missing->probability = prob;
+    return;
+  }
+  EdgePrediction *preds = bbPredictions[bb.GetBBId()];
+  int combinedProbability = kProbBase / static_cast<int>(kScaleDownFactor);
+  int denominator = 0;
+  if (preds != nullptr) {
+    // use Dempster-Shafer Theory.
+    for (EdgePrediction *pred = preds; pred != nullptr; pred = pred->epNext) {
+      int probability = pred->epProbability;
+      if (&pred->epEdge != first) {
+        probability = kProbBase - probability;
+      }
+      denominator = (combinedProbability * probability + (kProbBase - combinedProbability) * (kProbBase - probability));
+      // Use FP math to avoid overflows of 32bit integers.
+      if (denominator == 0) {
+        // If one probability is 0% and one 100%, avoid division by zero.
+        combinedProbability = kProbBase / kScaleDownFactor;
+      } else {
+        combinedProbability =
+            static_cast<int>(static_cast<double>(combinedProbability) * probability * kProbBase / denominator);
+      }
+    }
+  }
+  if (predictDebug) {
+    CHECK_FATAL(first != nullptr, "null ptr check");
+    constexpr int hundredPercent = 100;
+    LogInfo::MapleLogger() << "combined heuristics of edge BB" << bb.GetBBId() << "->BB" << first->dest.GetBBId() <<
+        ":" << (combinedProbability * hundredPercent / kProbBase) << "%\n";
+    if (preds != nullptr) {
+      for (EdgePrediction *pred = preds; pred != nullptr; pred = pred->epNext) {
+        Predictor predictor = pred->epPredictor;
+        int probability = pred->epProbability;
+        LogInfo::MapleLogger() << predictorInfo[predictor].name << " heuristics of edge BB" <<
+            pred->epEdge.src.GetBBId() << "->BB" << pred->epEdge.dest.GetBBId() <<
+            ":" << (probability * hundredPercent / kProbBase) << "%\n";
+      }
+    }
+  }
+  ClearBBPredictions(bb);
+  CHECK_FATAL(first != nullptr, "null ptr check");
+  first->probability = combinedProbability;
+  CHECK_FATAL(second != nullptr, "null ptr check");
+  second->probability = kProbBase - combinedProbability;
+}
+
+void MePrediction::FindSCCHeaders(const SCCOfBBs &scc, std::vector<BB*> &headers) {
+  // init inSCCPtr
+  if (inSCCPtr == nullptr) {
+    inSCCPtr = tmpAlloc.GetMemPool()->New<MapleVector<std::pair<bool, uint32>>>(
+        cfg->NumBBs(), std::pair{ false, 0 }, tmpAlloc.Adapter());
+  } else {
+    std::fill(inSCCPtr->begin(), inSCCPtr->end(), std::pair{ false, 0 });
+  }
+  auto &inSCC = *inSCCPtr;
+  for (BB *bb : scc.GetBBs()) {
+    inSCC[bb->GetBBId()] = { true, 0 };
+  }
+
+  uint32 rpoIdx = 0;
+  for (auto *bb : dom->GetReversePostOrder()) {
+    if (inSCC[bb->GetID()].first) {
+      inSCC[bb->GetID()].second = rpoIdx++;
+    }
+  }
+
+  // detect entry header
+  for (auto *bb : scc.GetBBs()) {
+    for (BB *pred : bb->GetPred()) {
+      bool isPredInSCC = inSCC[pred->GetBBId()].first;
+      auto predRpoIdx = inSCC[pred->GetBBId()].second;
+      auto bbRpoIdx = inSCC[bb->GetBBId()].second;
+      // case1: out scc BB --> in scc BB
+      // case2: big rpoIdx BB --> small rpoIdx BB
+      if (!isPredInSCC || predRpoIdx > bbRpoIdx) {
+        // entry block
+        headers.push_back(bb);
+        break;
+      }
+    }
+  }
+  // only add back edge for irreducible SCC
+  if (headers.size() > 1) {
+    for (auto *header : headers) {
+      for (auto *pred : header->GetPred()) {
+        bool isPredInSCC = inSCC[pred->GetBBId()].first;
+        auto predRpoIdx = inSCC[pred->GetBBId()].second;
+        auto bbRpoIdx = inSCC[header->GetBBId()].second;
+        if (isPredInSCC && predRpoIdx > bbRpoIdx) {
+          backEdges.push_back(FindEdge(*pred, *header));
+        }
+      }
+    }
+  }
+}
+
+void MePrediction::BuildSCC() {
+  cfg->BuildSCC();
+  for (auto *scc : cfg->GetSccTopologicalVec()) {
+    if (scc->GetBBs().size() > 1) {
+      sccVec.push_back(scc);
+    }
+  }
+}
+
+// Use head to propagate freq for normal loops. Use headers to propagate freq for irreducible SCCs
+// because there are multiple headers in irreducible SCCs.
+bool MePrediction::DoPropFreq(const BB *head, std::vector<BB*> *headers, BB &bb) {
+  if (bbVisited[bb.GetBBId()]) {
+    return true;
+  }
+  // 1. find bfreq(bb)
+  if (&bb == head) {
+    bb.SetFrequency(kFreqBase);
+    if (predictDebug) {
+      LogInfo::MapleLogger() << "Set Header Frequency BB" << bb.GetBBId() << ": " << bb.GetFrequency() << std::endl;
+    }
+  } else if (headers != nullptr && std::find(headers->begin(), headers->end(), &bb) != headers->end()) {
+    bb.SetFrequency(kFreqBase / headers->size());
+    if (predictDebug) {
+      LogInfo::MapleLogger() << "Set Header Frequency BB" << bb.GetBBId() << ": " << bb.GetFrequency() << std::endl;
+    }
+  } else {
+    // Check whether all pred bb have been estimated
+    for (size_t i = 0; i < bb.GetPred().size(); ++i) {
+      BB *pred = bb.GetPred(i);
+      if (!bbVisited[pred->GetBBId()] && pred != &bb && !IsBackEdge(*FindEdge(*pred, bb))) {
+        if (predictDebug) {
+          LogInfo::MapleLogger() << "BB" << bb.GetBBId() << " can't be estimated because it's predecessor BB" <<
+              pred->GetBBId() << " hasn't be estimated yet\n";
+          if (bb.GetAttributes(kBBAttrIsInLoop) &&
+              (bb.GetAttributes(kBBAttrIsTry) || bb.GetAttributes(kBBAttrIsCatch) ||
+               pred->GetAttributes(kBBAttrIsTry) || pred->GetAttributes(kBBAttrIsCatch))) {
+            LogInfo::MapleLogger() << "BB" << bb.GetBBId() <<
+                " can't be recognized as loop head/tail because of eh.\n";
+          }
+        }
+        return false;
+      }
+    }
+    uint64 freq = 0;
+    double cyclicProb = 0;
+    for (BB *pred : bb.GetPred()) {
+      Edge *edge = FindEdge(*pred, bb);
+      ASSERT_NOT_NULL(edge);
+      if (IsBackEdge(*edge) && &edge->dest == &bb) {
+        cyclicProb += backEdgeProb[edge];
+      } else {
+        freq += edge->frequency;
+      }
+    }
+    if (cyclicProb > (1 - std::numeric_limits<double>::epsilon())) {
+      cyclicProb = 1 - std::numeric_limits<double>::epsilon();
+    }
+    // Floating-point numbers have precision problems, consider using integers to represent backEdgeProb?
+    bb.SetFrequency(static_cast<uint64>(static_cast<uint32>(freq / (1 - cyclicProb))));
+  }
+  // 2. calculate frequencies of bb's out edges
+  if (predictDebug) {
+    LogInfo::MapleLogger() << "Estimate Frequency of BB" << bb.GetBBId() << "\n";
+  }
+  bbVisited[bb.GetBBId()] = true;
+  uint32 tmp = 0;
+  uint64 total = 0;
+  Edge *bestEdge = nullptr;
+  for (size_t i = 0; i < bb.GetSucc().size(); ++i) {
+    Edge *edge = FindEdge(bb, *bb.GetSucc(i));
+    CHECK_NULL_FATAL(edge);
+    if (i == 0) {
+      bestEdge = edge;
+      tmp = edge->probability;
+    } else {
+      if (edge->probability > tmp) {
+        tmp = edge->probability;
+        bestEdge = edge;
+      }
+    }
+    edge->frequency = bb.GetFrequency() * 1.0 * edge->probability / kProbBase;
+    total += edge->frequency;
+    bool isBackEdge = headers != nullptr ? std::find(headers->begin(), headers->end(), &edge->dest) != headers->end() :
+                                           &edge->dest == head;
+    if (isBackEdge) {  // is the edge a back edge
+      backEdgeProb[edge] = static_cast<double>(edge->probability) * bb.GetFrequency() / (kProbBase * kFreqBase);
+    }
+  }
+  // To ensure that the sum of out edge frequency is equal to bb frequency
+  if (bestEdge != nullptr && total != bb.GetFrequency()) {
+    bestEdge->frequency += static_cast<uint32>(bb.GetFrequency() - total);
+  }
+  return true;
+}
+
+void MePrediction::PropFreqInIrreducibleSCCs() {
+  if (predictDebug) {
+    LogInfo::MapleLogger() << "== freq prop for irreducible SCC" << std::endl;
+  }
+  BuildSCC();
+  CHECK_FATAL(!sccVec.empty(), "must be");
+  // prop freq for irreducible SCC
+  for (auto *scc : sccVec) {
+    std::vector<BB*> headers;
+    FindSCCHeaders(*scc, headers);
+    if (headers.size() <= 1) {
+      continue;  // The normal loops should have been processed by PropFreqInLoops
+    }
+    std::fill(bbVisited.begin(), bbVisited.end(), false);
+    // prop header first
+    for (auto *sccHead : headers) {
+      bool result = DoPropFreq(nullptr, &headers, *sccHead);
+      CHECK_FATAL(result, "prop freq for irreducible SCC headers failed");
+    }
+    // prop other BBs in the SCC by topological orde
+    for (auto *curBB : dom->GetReversePostOrder()) {
+      bool inSCC = (*inSCCPtr)[curBB->GetID()].first;
+      if (!inSCC) {
+        continue;
+      }
+      bool result = DoPropFreq(nullptr, &headers, *cfg->GetBBFromID(BBId(curBB->GetID())));
+      CHECK_FATAL(result, "prop freq for irreducible SCC BB failed");
+    }
+  }
+}
+
+bool MePrediction::PropFreqInFunc() {
+  if (predictDebug) {
+    LogInfo::MapleLogger() << "== freq prop for func" << std::endl;
+  }
+  // Now propagate the frequencies through all the blocks.
+  std::fill(bbVisited.begin(), bbVisited.end(), false);
+  BB *entryBB = cfg->GetCommonEntryBB();
+  if (entryBB != cfg->GetFirstBB()) {
+    bbVisited[entryBB->GetBBId()] = false;
+  }
+  if (cfg->GetCommonExitBB() != cfg->GetLastBB()) {
+    bbVisited[cfg->GetCommonExitBB()->GetBBId()] = false;
+  }
+  entryBB->SetFrequency(kFreqBase);
+
+  for (auto *node : dom->GetReversePostOrder()) {
+    auto bb = cfg->GetBBFromID(BBId(node->GetID()));
+    if (bb == entryBB) {
+      continue;
+    }
+    ASSERT(entryBB->GetSucc().size() == 1, "comment entry BB always has only 1 succ");
+    bool ret = DoPropFreq(entryBB->GetSucc()[0], nullptr, *bb);
+    if (!ret) {
+      // found irreducible SCC
+      return false;
+    }
+  }
+  return true;
+}
+
+void MePrediction::PropFreqInLoops() {
+  for (auto *loop : meLoop->GetMeLoops()) {
+    MapleSet<BBId> &loopBBs = loop->loopBBs;
+    auto *backEdge = FindEdge(*loop->tail, *loop->head);
+    backEdges.push_back(backEdge);
+    for (auto &bbId : loopBBs) {
+      bbVisited[bbId] = false;
+    }
+    if (predictDebug) {
+      LogInfo::MapleLogger() << "== freq prop for loop: header BB" << loop->head->GetBBId() << std::endl;
+    }
+    // sort loop BB by topological order
+    const auto &bbId2RpoId = dom->GetReversePostOrderId();
+    std::vector<BBId> rpoLoopBBs(loopBBs.begin(), loopBBs.end());
+    std::sort(rpoLoopBBs.begin(), rpoLoopBBs.end(), [&bbId2RpoId](BBId a, BBId b) {
+      return bbId2RpoId[a] < bbId2RpoId[b];
+    });
+    // calculate header first
+    bool ret = DoPropFreq(loop->head, nullptr, *loop->head);
+    CHECK_FATAL(ret, "prop freq for loop header failed");
+    for (auto bbId : rpoLoopBBs) {
+      // it will fail if the loop contains irreducible SCC
+      (void)DoPropFreq(loop->head, nullptr, *cfg->GetBBFromID(bbId));
+    }
+  }
+}
+
+void MePrediction::ComputeBBFreq() {
+  if (predictDebug) {
+    LogInfo::MapleLogger() << "\ncompute-bb-freq" << std::endl;
+  }
+  BB *entry = cfg->GetCommonEntryBB();
+  edges[entry->GetBBId()]->probability = kProbAlways;
+  double backProb = 0.0;
+  for (size_t i = 0; i < cfg->GetAllBBs().size(); ++i) {
+    Edge *edge = edges[i];
+    while (edge != nullptr) {
+      if (edge->probability > 0) {
+        backProb = edge->probability;
+      } else {
+        backProb = kProbBase / kScaleDownFactor;
+      }
+      backProb = backProb / kProbBase;
+      (void)backEdgeProb.insert(std::make_pair(edge, backProb));
+      edge = edge->next;
+    }
+  }
+  // First compute frequencies locally for each loop from innermost
+  // to outermost to examine frequencies for back edges.
+  PropFreqInLoops();
+  if (!PropFreqInFunc()) {
+    // found irreducible SCC
+    PropFreqInIrreducibleSCCs();
+    bool ret = PropFreqInFunc();  // estimate func again after solving irr scc
+    CHECK_FATAL(ret, "estimate func failure again");
+  }
+}
+
+void MePrediction::Run() {
+  if (predictDebug) {
+    LogInfo::MapleLogger() << "prediction: " << func->GetName() << "\n" <<
+                           "============" << std::string(func->GetName().size(), '=') << std::endl;
+  }
+  if (cfg->GetAllBBs().size() > kMaxNumBBToPredict) {
+    // The func is too large, won't run prediction
+    if (predictDebug) {
+      LogInfo::MapleLogger() << "func is too large to run prediction, bb number > " << kMaxNumBBToPredict << std::endl;
+    }
+    return;
+  }
+  EstimateBranchProb();
+  ComputeBBFreq();
+  SavePredictResultIntoCfg();
+}
+
+// Main function
+void MePrediction::EstimateBranchProb() {
+  if (predictDebug) {
+    LogInfo::MapleLogger() << "estimate-block-prob" << std::endl;
+  }
+  Init();
+  BBLevelPredictions();
+  if (!meLoop->GetMeLoops().empty()) {
+    // innermost loop in the first place for EstimateFrequencies.
+    SortLoops();
+    PredictLoops();
+  }
+
+  MapleVector<BB*> &bbVec = cfg->GetAllBBs();
+  for (auto *bb : bbVec) {
+    if (bb != nullptr) {
+      EstimateBBProb(*bb);
+    }
+  }
+  for (auto *bb : bbVec) {
+    if (bb != nullptr) {
+      CombinePredForBB(*bb);
+    }
+  }
+  for (size_t i = 0; i < cfg->GetAllBBs().size(); ++i) {
+    int32 all = 0;
+    for (Edge *edge = edges[i]; edge != nullptr; edge = edge->next) {
+      if (predictDebug) {
+        constexpr uint32 hundredPercent = 100;
+        LogInfo::MapleLogger() << "probability for edge BB" << edge->src.GetBBId() << "->BB" <<
+            edge->dest.GetBBId() << " is " << (edge->probability / hundredPercent) << "%\n";
+      }
+      all += edge->probability;
+    }
+    if (edges[i] != nullptr) {
+      CHECK_FATAL(all == kProbBase, "total probability is not 1");
+    }
+  }
+}
+
+void MePrediction::SetPredictDebug(bool val) {
+  predictDebug = val;
+}
+
+void MePrediction::SavePredictResultIntoCfg() {
+  // Init bb succFreq if needed
+  for (auto *bb : cfg->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    if (bb->GetSuccFreq().size() != bb->GetSucc().size()) {
+      bb->InitEdgeFreq();
+    }
+  }
+  // Save edge freq into cfg
+  for (auto *edge : edges) {
+    while (edge != nullptr) {
+      BB &srcBB = edge->src;
+      BB &destBB = edge->dest;
+      srcBB.SetEdgeFreq(&destBB, edge->frequency);
+      // Set branchProb for condgoto stmt
+      if (srcBB.GetKind() == kBBCondGoto && &destBB == srcBB.GetSucc(1)) {
+        auto *lastMeStmt = srcBB.GetLastMe();
+        if (lastMeStmt != nullptr) {
+          Opcode op = lastMeStmt->GetOp();
+          CHECK_FATAL(op == OP_brtrue || op == OP_brfalse, "must be");
+          static_cast<CondGotoMeStmt*>(lastMeStmt)->SetBranchProb(static_cast<int32>(edge->probability));
+        }
+      }
+      edge = edge->next;
+    }
+  }
+  func->SetProfValid(true);
+  if (predictDebug) {
+    cfg->DumpToFile("rebuild", false, true);
+  }
+  VerifyFreq(*func);
+}
+
+void MePrediction::VerifyFreq(const MeFunction &meFunc) {
+  const auto &bbVec = meFunc.GetCfg()->GetAllBBs();
+  for (size_t i = 2; i < bbVec.size(); ++i) {  // skip common entry and common exit
+    auto *bb = bbVec[i];
+    if (bb == nullptr || bb->GetAttributes(kBBAttrIsEntry) || bb->GetAttributes(kBBAttrIsExit)) {
+      continue;
+    }
+    // bb freq == sum(out edge freq)
+    uint64 succSumFreq = 0;
+    for (auto succFreq : bb->GetSuccFreq()) {
+      succSumFreq += succFreq;
+    }
+    if (succSumFreq != bb->GetFrequency()) {
+      LogInfo::MapleLogger() << "[VerifyFreq failure] BB" << bb->GetBBId() << " freq: " <<
+          bb->GetFrequency() << ", all succ edge freq sum: " << succSumFreq << std::endl;
+      LogInfo::MapleLogger() << meFunc.GetName() << std::endl;
+      CHECK_FATAL(bb->GetKind() == kBBNoReturn, "VerifyFreq failure: bb freq != succ freq sum");
+    }
+  }
+}
+
+// Prediction will sort meLoop
+void MePrediction::RebuildFreq(MeFunction &meFunc, Dominance &newDom, Dominance &newPdom, IdentifyLoops &newMeLoop,
+    BuiltinExpectInfo *expectInfo) {
+  meFunc.SetProfValid(false);
+  StackMemPool stackMp(memPoolCtrler, "");
+  MePrediction predict(stackMp, stackMp, meFunc, newDom, newPdom, newMeLoop, *meFunc.GetIRMap());
+  if (MeOption::dumpFunc == meFunc.GetName()) {
+    predict.SetPredictDebug(true);
+  }
+  if (expectInfo != nullptr) {
+    predict.SetBuiltinExpectInfo(*expectInfo);
+  }
+  predict.Run();
+}
+
+void MePrediction::RecoverBuiltinExpectInfo(const BuiltinExpectInfo &expectInfo) {
+  for (auto &pair : expectInfo) {
+    CondGotoMeStmt *condStmt = pair.first;
+    int32 branchProb = pair.second;
+    condStmt->SetBranchProb(branchProb);
+  }
+}
+
+void Edge::Dump(bool dumpNext) const {
+  LogInfo::MapleLogger() << src.GetBBId() << " ==> " << dest.GetBBId() << " (prob: " << probability <<
+      ", freq: " << frequency << ")" << std::endl;
+  if (dumpNext && next != nullptr) {
+    next->Dump(dumpNext);
+  }
+}
+
+void MEPredict::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MELoopAnalysis>();
+}
+
+// Estimate the execution frequecy for all bbs.
+bool MEPredict::PhaseRun(maple::MeFunction &f) {
+  auto *hMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_NULL_FATAL(hMap);
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  auto pdom = dominancePhase->GetPdomResult();
+  CHECK_NULL_FATAL(pdom);
+  auto *meLoop = GET_ANALYSIS(MELoopAnalysis, f);
+  CHECK_NULL_FATAL(meLoop);
+
+  MemPool *mePredMp = GetPhaseMemPool();
+  auto *mePredict = mePredMp->New<MePrediction>(*mePredMp, *ApplyTempMemPool(), f, *dom, *pdom, *meLoop, *hMap);
+  if (DEBUGFUNC_NEWPM(f)) {
+    mePredict->SetPredictDebug(true);
+  }
+  mePredict->Run();
+
+  if (DEBUGFUNC_NEWPM(f)) {
+    f.GetCfg()->DumpToFile("freq", false, true);
+    LogInfo::MapleLogger() << "\n============== Prediction =============" << '\n';
+    for (auto *bb : f.GetCfg()->GetAllBBs()) {
+      if (bb == nullptr) {
+        continue;
+      }
+      LogInfo::MapleLogger() << "bb " << bb->GetBBId() << ", freq: " << bb->GetFrequency() << std::endl;
+    }
+  }
+  MePrediction::VerifyFreq(f);
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_profile_gen.cpp b/src/mapleall/maple_me/src/me_profile_gen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a36b769c429b4e4de3a64eef491dcdbf3c60d17d
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_profile_gen.cpp
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_profile_gen.h"
+#include <iostream>
+#include <algorithm>
+#include "me_cfg.h"
+#include "me_option.h"
+#include "me_function.h"
+#include "me_irmap_build.h"
+#include "mir_builder.h"
+#include "gen_profile.h"
+#include "itab_util.h"
+
+/*
+ * This phase do CFG edge profile using a minimum spanning tree based
+ * on the following paper:
+ * [1] Donald E. Knuth, Francis R. Stevenson. Optimal measurement of points
+ * FOR program frequency counts. BIT Numerical Mathematics 1973, Volume 13,
+ * Issue 3, pp 313-322
+ * The count of edge on spanning tree can be derived from
+ * those edges not on the spanning tree. Knuth proves this method instruments
+ * the minimum number of edges.
+ */
+
+namespace maple {
+uint64 MeProfGen::counterIdx = 0;
+uint64 MeProfGen::totalBB = 0;
+uint64 MeProfGen::instrumentBB = 0;
+uint64 MeProfGen::totalFunc = 0;
+uint64 MeProfGen::instrumentFunc = 0;
+bool MeProfGen::firstRun = true;
+MIRSymbol *MeProfGen::bbCounterTabSym = nullptr;
+
+void MeProfGen::DumpSummary() {
+  LogInfo::MapleLogger() << "instrument BB " << instrumentBB << " total BB " << totalBB << std::setprecision(2)
+                         << " ratio "  << (static_cast<float>(instrumentBB) / totalBB) << "\n";
+  LogInfo::MapleLogger() << "instrument func " << instrumentFunc << " total BB " << totalFunc << std::setprecision(2)
+                         << " ratio " <<  (static_cast<float>(instrumentFunc) / totalFunc) << "\n";
+}
+
+void MeProfGen::IncTotalFunc() {
+  totalFunc++;
+}
+
+void MeProfGen::Init() {
+  if (Options::profileGen) {
+    return;
+  }
+  if (!firstRun) {
+    return;
+  }
+  MIRArrayType &muidIdxArrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetUInt32(), 0);
+  std::string bbProfileName = namemangler::kBBProfileTabPrefixStr + func->GetMIRModule().GetFileNameAsPostfix();
+  bbCounterTabSym = func->GetMIRModule().GetMIRBuilder()->CreateGlobalDecl(bbProfileName.c_str(), muidIdxArrayType);
+  MIRAggConst *bbProfileTab = func->GetMIRModule().GetMemPool()->New<MIRAggConst>(
+      func->GetMIRModule(), *GlobalTables::GetTypeTable().GetUInt32());
+  bbCounterTabSym->SetKonst(bbProfileTab);
+  bbCounterTabSym->SetStorageClass(kScFstatic);
+  firstRun = false;
+}
+
+void MeProfGen::InstrumentBB(BB &bb) {
+  /* append intrinsic call at the begin of bb */
+  CHECK_FATAL(counterIdx != (UINT32_MAX / GetPrimTypeSize(PTY_u32)), "profile counter overflow");
+  MeExpr *arg0 = hMap->CreateIntConstMeExpr(static_cast<int64>(counterIdx), PTY_u32);
+  std::vector<MeExpr*> opnds = { arg0 };
+  IntrinsiccallMeStmt *counterIncCall = hMap->CreateIntrinsicCallMeStmt(INTRN_MPL_PROF_COUNTER_INC, opnds);
+  bb.AddMeStmtFirst(counterIncCall);
+  bb.SetAttributes(kBBAttrIsInstrument);
+  counterIdx++;
+  if (dump) {
+    LogInfo::MapleLogger() << "instrument on BB" << bb.GetBBId() << "\n";
+  }
+}
+
+void MeProfGen::SaveProfile() {
+  if (!Options::profileTest) {
+    return;
+  }
+  if (func->GetName().find("main") != std::string::npos) {
+    std::vector<MeExpr*> opnds;
+    IntrinsiccallMeStmt *saveProfCall = hMap->CreateIntrinsicCallMeStmt(INTRN_MCCSaveProf, opnds);
+    for (BB *exitBB : func->GetCfg()->GetCommonExitBB()->GetPred()) {
+      exitBB->AddMeStmtFirst(saveProfCall);
+    }
+  }
+}
+
+void MeProfGen::InstrumentFunc() {
+  FindInstrumentEdges();
+  std::vector<BB*> instrumentBBs;
+  GetInstrumentBBs(instrumentBBs);
+
+  if (Options::profileGen) {
+    counterIdx = 0;
+    MIRModule *mod = func->GetMirFunc()->GetModule();
+    uint32 nCtrs = instrumentBBs.size();
+    func->GetMirFunc()->SetNumCtrs(nCtrs);
+    if (nCtrs != 0) {
+      MIRType *arrOfInt64Ty =
+          GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetInt64(), nCtrs);
+      // flatten the counter table name
+      std::string ctrTblName = namemangler::kprefixProfCtrTbl +
+                               func->GetMIRModule().GetFileName() + "_" +
+                               func->GetMirFunc()->GetName();
+      std::replace(ctrTblName.begin(), ctrTblName.end(), '.', '_');
+      std::replace(ctrTblName.begin(), ctrTblName.end(), '-', '_');
+      std::replace(ctrTblName.begin(), ctrTblName.end(), '/', '_');
+
+      MIRSymbol *ctrTblSym = mod->GetMIRBuilder()->CreateGlobalDecl(ctrTblName, *arrOfInt64Ty, kScFstatic);
+      ctrTblSym->SetSKind(kStVar);
+      func->GetMirFunc()->SetProfCtrTbl(ctrTblSym);
+    }
+    for (auto *bb : instrumentBBs) {
+      InstrumentBB(*bb);
+    }
+
+    // Checksums are relatively sensitive to source changes
+    // Generate the function's lineno checksum
+    std::string fileName = func->GetMIRModule().GetFileName();
+    uint64 fileNameHash = DJBHash(fileName.c_str());
+    std::string lineNo = std::to_string(func->GetMirFunc()->GetSrcPosition().LineNum());
+    uint64 linenoHash = fileNameHash << 32 | DJBHash(lineNo.c_str());
+    func->GetMirFunc()->SetFileLineNoChksum(linenoHash);
+
+    // Generate The function's CFG checksum
+    uint64 cfgCheckSum = ComputeFuncHash();
+    func->GetMirFunc()->SetCFGChksum(cfgCheckSum);
+
+    if (dump) {
+      LogInfo::MapleLogger() << "******************after profileGen dump function******************\n";
+      func->Dump(true);
+    }
+    return;
+  }
+
+  // record the current counter start, used in the function profile description
+  uint32 counterStart = static_cast<uint32>(counterIdx);
+  MIRAggConst *bbProfileTab = safe_cast<MIRAggConst>(bbCounterTabSym->GetKonst());
+  for (auto *bb : instrumentBBs) {
+    MIRIntConst *indexConst =
+        func->GetMIRModule().GetMemPool()->New<MIRIntConst>(0, *GlobalTables::GetTypeTable().GetUInt32());
+    bbProfileTab->AddItem(indexConst, 0);
+    InstrumentBB(*bb);
+  }
+
+  uint32 counterEnd = static_cast<uint32>(counterIdx - 1);
+  uint64 hash = ComputeFuncHash();
+  func->AddProfileDesc(hash, counterStart, counterEnd);
+  instrumentBB += instrumentBBs.size();
+  totalBB += GetAllBBs();
+  instrumentFunc++;
+  SaveProfile();
+  if (dump) {
+    LogInfo::MapleLogger() << "******************after profile gen  dump function******************\n";
+    func->Dump(true);
+  }
+  if (Options::profileTest || dump) {
+    LogInfo::MapleLogger() << func->GetName() << " profile description info: "
+                           << "func hash " << std::hex << hash << std::dec << " counter range ["
+                           << counterStart << "," << counterEnd << "]\n";
+  }
+}
+
+// if function have try can't instrument
+// if function have infinite loop, can't instrument,because it may cause counter
+// overflow
+bool MeProfGen::CanInstrument() const {
+  MeCFG *cfg = func->GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    auto *bb = *bIt;
+    if (bb->GetAttributes(kBBAttrIsTry) || bb->GetAttributes(kBBAttrWontExit)) {
+      if (func->GetMIRModule().IsCModule()) {
+        // Consider the case of non-exit as a special program
+        continue;
+      } else {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool MEProfGen::PhaseRun(maple::MeFunction &f) {
+  if (!f.GetCfg()->empty()) {
+    MeProfGen::IncTotalFunc();
+  }
+  // function with try can't determine the instrument BB,because
+  // there have critial-edge which can't be split
+  if (f.HasException()) {
+    return false;
+  }
+
+  auto *hMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_FATAL(hMap != nullptr, "hssamap is nullptr");
+  MeProfGen profGen(f, *GetPhaseMemPool(), *hMap, DEBUGFUNC_NEWPM(f));
+  if (!profGen.CanInstrument()) {
+    return false;
+  }
+  profGen.InstrumentFunc();
+
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "dump edge info in profile gen phase " << f.GetMirFunc()->GetName() << std::endl;
+    f.GetCfg()->DumpToFile("afterProfileGen", false);
+    profGen.DumpEdgeInfo();
+  }
+  return true;
+}
+
+void MEProfGen::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_profile_use.cpp b/src/mapleall/maple_me/src/me_profile_use.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d43fa03e7361af5cefbc653b38d1ea46a130af2c
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_profile_use.cpp
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_profile_use.h"
+
+#include <iostream>
+
+#include "me_cfg.h"
+#include "me_function.h"
+#include "me_option.h"
+
+namespace maple {
+BBUseInfo *MeProfUse::GetOrCreateBBUseInfo(const BB &bb) {
+  auto item = bbProfileInfo.find(&bb);
+  if (item != bbProfileInfo.end()) {
+    return item->second;
+  } else {
+    BBUseInfo *useInfo = mp->New<BBUseInfo>(*mp);
+    bbProfileInfo.insert(std::make_pair(&bb, useInfo));
+    return useInfo;
+  }
+}
+
+BBUseInfo *MeProfUse::GetBBUseInfo(const BB &bb) const {
+  auto item = bbProfileInfo.find(&bb);
+  ASSERT(item->second != nullptr, "bb info not created");
+  return item->second;
+}
+
+uint64 MeProfUse::SumEdgesCount(const MapleVector<BBUseEdge*> &edges) const {
+  uint64 count = 0;
+  for (const auto &e : edges) {
+    count += e->GetCount();
+  }
+  return count;
+}
+
+/* create BB use info */
+void MeProfUse::InitBBEdgeInfo() {
+  for (auto &e : GetAllEdges()) {
+    BB *src = e->GetSrcBB();
+    BB *dest = e->GetDestBB();
+    auto srcUseInfo = GetOrCreateBBUseInfo(*src);
+    srcUseInfo->AddOutEdge(e);
+    auto destUseInfo = GetOrCreateBBUseInfo(*dest);
+    destUseInfo->AddInEdge(e);
+  }
+  for (auto &e : GetAllEdges()) {
+    if (e->IsInMST()) {
+      continue;
+    }
+    BB *src = e->GetSrcBB();
+    auto srcUseInfo = GetBBUseInfo(*src);
+    if (srcUseInfo->GetStatus() && srcUseInfo->GetOutEdgeSize() == 1) {
+      SetEdgeCount(*e, srcUseInfo->GetCount());
+    } else {
+      BB *dest = e->GetDestBB();
+      auto destUseInfo = GetBBUseInfo(*dest);
+      if (destUseInfo->GetStatus() && destUseInfo->GetInEdgeSize() == 1) {
+        SetEdgeCount(*e, destUseInfo->GetCount());
+      }
+    }
+    if (e->GetStatus()) {
+      continue;
+    }
+    SetEdgeCount(*e, 0);
+  }
+}
+
+// If all input edges or output edges determined, caculate BB freq
+void MeProfUse::ComputeBBFreq(BBUseInfo &bbInfo, bool &changed) {
+  uint64 count = 0;
+  if (!bbInfo.GetStatus()) {
+    if (bbInfo.GetUnknownOutEdges() == 0) {
+      count = SumEdgesCount(bbInfo.GetOutEdges());
+      bbInfo.SetCount(count);
+      changed = true;
+    } else if (bbInfo.GetUnknownInEdges() == 0) {
+      count = SumEdgesCount(bbInfo.GetInEdges());
+      bbInfo.SetCount(count);
+      changed = true;
+    }
+  }
+}
+
+/* compute all edge freq in the cfg without consider exception */
+void MeProfUse::ComputeEdgeFreq() {
+  bool change = true;
+  size_t pass = 0;
+  MeCFG *cfg = func->GetCfg();
+  auto eIt = cfg->valid_end();
+  while (change) {
+    change = false;
+    pass++;
+    CHECK_FATAL(pass != UINT8_MAX, "parse all edges fail");
+    /*
+     * use the bb edge to infer the bb's count,when all bb's count is valid
+     * then all edges count is valid
+     */
+    for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+      auto *bb = *bIt;
+      BBUseInfo *useInfo = GetBBUseInfo(*bb);
+      if (useInfo == nullptr) {
+        continue;
+      }
+      ComputeBBFreq(*useInfo, change);
+      if (useInfo->GetStatus()) {
+        if (useInfo->GetUnknownOutEdges() == 1) {
+          uint64 total = 0;
+          uint64 outCount = SumEdgesCount(useInfo->GetOutEdges());
+          if (useInfo->GetCount() > outCount) {
+            total = useInfo->GetCount() - outCount;
+          }
+          SetEdgeCount(useInfo->GetOutEdges(), total);
+          change = true;
+        }
+        if (useInfo->GetUnknownInEdges() == 1) {
+          uint64 total = 0;
+          uint64 inCount = SumEdgesCount(useInfo->GetInEdges());
+          if (useInfo->GetCount() > inCount) {
+            total = useInfo->GetCount() - inCount;
+          }
+          SetEdgeCount(useInfo->GetInEdges(), total);
+          change = true;
+        }
+      }
+    }
+  }
+  if (dump) {
+    LogInfo::MapleLogger() << "parse all edges in " << pass << " pass" << '\n';
+  }
+  if (Options::profileTest) {
+    LogInfo::MapleLogger() << func->GetName() << " succ compute all edges " << '\n';
+  }
+}
+
+/*
+ * this used to set the edge count for the unknown edge
+ * ensure only one unkown edge in the edges
+ */
+void MeProfUse::SetEdgeCount(MapleVector<BBUseEdge*> &edges, uint64 value) {
+  for (const auto &e : edges) {
+    if (!e->GetStatus()) {
+      e->SetCount(value);
+      BBUseInfo *srcInfo = GetBBUseInfo(*(e->GetSrcBB()));
+      BBUseInfo *destInfo = GetBBUseInfo(*(e->GetDestBB()));
+      srcInfo->DecreaseUnKnownOutEdges();
+      destInfo->DecreaseUnKnownInEdges();
+      return;
+    }
+  }
+  CHECK(false, "can't find unkown edge");
+}
+
+void MeProfUse::SetEdgeCount(BBUseEdge &edge, size_t value) {
+  // edge counter already valid skip
+  if (edge.GetStatus()) {
+    return;
+  }
+  edge.SetCount(value);
+  BBUseInfo *srcInfo = GetBBUseInfo(*(edge.GetSrcBB()));
+  BBUseInfo *destInfo = GetBBUseInfo(*(edge.GetDestBB()));
+  srcInfo->DecreaseUnKnownOutEdges();
+  destInfo->DecreaseUnKnownInEdges();
+  return;
+}
+
+// return true,if all counter is zero
+bool MeProfUse::IsAllZero(Profile::BBInfo &result) const {
+  bool allZero = true;
+  for (size_t i = 0; i < result.totalCounter; ++i) {
+    if (result.counter[i] != 0) {
+      allZero = false;
+      break;
+    }
+  }
+  return allZero;
+}
+
+bool MeProfUse::BuildEdgeCount() {
+  Profile::BBInfo result;
+  bool ret = true;
+  ret = func->GetMIRModule().GetProfile().GetFunctionBBProf(func->GetName(), result);
+  if (!ret) {
+    if (dump) {
+      LogInfo::MapleLogger() << func->GetName() << " isn't in profile" << '\n';
+    }
+    return false;
+  }
+  if (IsAllZero(result)) {
+    if (dump) {
+      LogInfo::MapleLogger() << func->GetName() << " counter all zero" << '\n';
+    }
+    return false;
+  }
+  FindInstrumentEdges();
+  uint64 hash = ComputeFuncHash();
+  if (hash != result.funcHash) {
+    if (dump) {
+      LogInfo::MapleLogger() << func->GetName() << " hash doesn't match profile hash " << result.funcHash
+                             << " func real hash " << hash << '\n';
+    }
+    return false;
+  }
+  std::vector<BB*> instrumentBBs;
+  GetInstrumentBBs(instrumentBBs);
+  if (dump) {
+    DumpEdgeInfo();
+  }
+  if (instrumentBBs.size() != result.totalCounter) {
+    if (dump) {
+      LogInfo::MapleLogger() << func->GetName() << " counter doesn't match profile counter " << result.totalCounter
+                             << " func real counter " << instrumentBBs.size() << '\n';
+    }
+    return false;
+  }
+  size_t i = 0;
+  for (auto *bb : instrumentBBs) {
+    auto *bbUseInfo = GetOrCreateBBUseInfo(*bb);
+    bbUseInfo->SetCount(result.counter[i]);
+    i++;
+  }
+
+  InitBBEdgeInfo();
+  ComputeEdgeFreq();
+  succCalcuAllEdgeFreq = true;
+  return true;
+}
+
+void MeProfUse::SetFuncEdgeInfo() {
+  MeCFG *cfg = func->GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    auto *bbInfo = GetBBUseInfo(*bb);
+    bb->SetFrequency(bbInfo->GetCount());
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    bb->InitEdgeFreq();
+    auto outEdges = bbInfo->GetOutEdges();
+    for (auto *e : outEdges) {
+      auto *destBB = e->GetDestBB();
+      // common_exit's pred's BB doesn't have succ BB of common exit
+      // so skip this edge
+      if (destBB == cfg->GetCommonExitBB()) {
+        continue;
+      }
+      bb->SetEdgeFreq(destBB, e->GetCount());
+    }
+  }
+  func->SetProfValid(true);
+  func->SetFrequency(cfg->GetCommonEntryBB()->GetFrequency());
+  if (Options::genPGOReport) {
+    func->GetMIRModule().GetProfile().SetFuncStatus(func->GetName(), true);
+  }
+}
+
+void MeProfUse::DumpFuncCFGEdgeFreq() const {
+  LogInfo::MapleLogger() << "populate status " << succCalcuAllEdgeFreq << "\n";
+  if (!succCalcuAllEdgeFreq) {
+    return;
+  }
+  LogInfo::MapleLogger() << "func freq " << func->GetFrequency() << "\n";
+  MeCFG *cfg = func->GetCfg();
+  auto eIt = cfg->valid_end();
+  for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    auto bb = *bIt;
+    LogInfo::MapleLogger() << bb->GetBBId() << " freq " << bb->GetFrequency() << '\n';
+    for (const auto *succBB : bb->GetSucc()) {
+      LogInfo::MapleLogger() << "edge " << bb->GetBBId() << "->" << succBB->GetBBId() << " freq "
+                             << bb->GetEdgeFreq(succBB) << '\n';
+    }
+  }
+}
+
+bool MeProfUse::Run() {
+  if (!BuildEdgeCount()) {
+    return false;
+  }
+  SetFuncEdgeInfo();
+  return true;
+}
+
+FuncProfInfo *MeProfUse::GetFuncData() {
+  MplProfileData *profData = func->GetMIRModule().GetMapleProfile();
+  if (!profData) {
+    return nullptr;
+  }
+  FuncProfInfo *funcData = profData->GetFuncProfile(func->GetUniqueID());
+  return funcData;
+}
+
+void MeProfUse::CheckSumFail(const uint64 hash, const uint32 expectedCheckSum, const std::string &tag) {
+  uint32 curCheckSum = static_cast<uint32>((hash >> 32) ^ (hash & 0xffffffff));
+  CHECK_FATAL(curCheckSum == expectedCheckSum, "%s() %s checksum %u doesn't match the expected %u; aborting\n",
+              func->GetName().c_str(), tag.c_str(), curCheckSum, expectedCheckSum);
+}
+
+bool MeProfUse::MapleProfRun() {
+  FuncProfInfo *funcData = GetFuncData();
+  if (!funcData) {
+    return false;
+  }
+  func->GetMirFunc()->SetFuncProfData(funcData);
+  // abort if lineno fail
+  CheckSumFail(ComputeLinenoHash(), funcData->linenoChecksum, "lineno");
+  FindInstrumentEdges();
+  // abort if cfgchecksum fail
+  CheckSumFail(ComputeFuncHash(), funcData->cfgChecksum, "function");
+  std::vector<BB*> instrumentBBs;
+  GetInstrumentBBs(instrumentBBs);
+  if (dump) {
+    DumpEdgeInfo();
+  }
+  if (instrumentBBs.size() != funcData->edgeCounts) {
+    if (dump) {
+      LogInfo::MapleLogger() << func->GetName() << " counter doesn't match profile counter " << funcData->edgeCounts
+                             << " func real counter " << instrumentBBs.size() << '\n';
+    }
+    func->GetMirFunc()->SetFuncProfData(nullptr);  // clear func profile data
+    return false;
+  }
+  size_t i = 0;
+  for (auto *bb : instrumentBBs) {
+    auto *bbUseInfo = GetOrCreateBBUseInfo(*bb);
+    bbUseInfo->SetCount(funcData->counts[i]);
+    i++;
+  }
+  InitBBEdgeInfo();
+  ComputeEdgeFreq();
+  succCalcuAllEdgeFreq = true;
+  // save edge frequence to bb
+  SetFuncEdgeInfo();
+  func->GetCfg()->ConstructStmtFreq();
+  return true;
+}
+
+void MEProfUse::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.SetPreservedAll();
+}
+
+bool MEProfUse::PhaseRun(maple::MeFunction &f) {
+  MeProfUse profUse(f, *GetPhaseMemPool(), DEBUGFUNC_NEWPM(f));
+  bool result = true;
+  if (Options::profileUse) {
+    result = profUse.MapleProfRun();
+    if (result) {
+      result = f.GetCfg()->VerifyBBFreq() != 0 ? true : false;
+      if (result && (DEBUGFUNC_NEWPM(f))) {
+        LogInfo::MapleLogger() << "func profileUse verification fail" << std::endl;
+      }
+    }
+  } else {
+    profUse.Run();
+  }
+
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "******************after profile use  dump function******************\n";
+    profUse.DumpFuncCFGEdgeFreq();
+  }
+  if (f.GetCfg()->DumpIRProfileFile()) {
+    f.GetCfg()->DumpToFile("after-ProfileUse", false, true);
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_prop.cpp b/src/mapleall/maple_me/src/me_prop.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..be42905946cd62e6c847614d07c87d4cacda4cca
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_prop.cpp
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_prop.h"
+#include "me_option.h"
+#include "me_dominance.h"
+#include "me_ssa_update.h"
+
+// This phase perform copy propagation optimization based on SSA representation.
+// The propagation will not apply to ivar's of ref type unless the option
+// --propiloadref is enabled.
+//
+// Copy propagation works by conducting a traversal over the program.  When it
+// encounters a variable reference, it uses its SSA representation to look up
+// its assigned value and try to do the substitution.
+namespace {
+const std::set<std::string> propWhiteList {
+#define PROPILOAD(funcname) #funcname,
+#include "propiloadlist.def"
+#undef PROPILOAD
+};
+}
+
+namespace maple {
+void MEMeProp::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MEMeProp::PhaseRun(maple::MeFunction &f) {
+  if (f.hpropRuns >= MeOption::hpropRunsLimit) {
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "  == " << PhaseName() << " skipped\n";
+    }
+    return false;
+  }
+  f.hpropRuns++;
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  auto pdom = dominancePhase->GetPdomResult();
+  CHECK_NULL_FATAL(pdom);
+  auto *hMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_NULL_FATAL(hMap);
+  bool propIloadRef = MeOption::propIloadRef;
+  if (!propIloadRef) {
+    MIRSymbol *fnSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(f.GetMirFunc()->GetStIdx().Idx());
+    CHECK_FATAL(fnSt, "fnSt is nullptr");
+    const std::string &funcName = fnSt->GetName();
+    propIloadRef = propWhiteList.find(funcName) != propWhiteList.end();
+    if (DEBUGFUNC_NEWPM(f)) {
+      if (propIloadRef) {
+        LogInfo::MapleLogger() << "propiloadref enabled because function is in white list";
+      }
+    }
+  }
+  auto propConfig = Prop::PropConfig {
+      MeOption::propBase, propIloadRef, MeOption::propGlobalRef, MeOption::propFinaliLoadRef,
+      MeOption::propIloadRefNonParm, MeOption::propAtPhi, MeOption::propWithInverse || f.IsLfo()
+  };
+  MeProp meProp(*hMap, *dom, *pdom, *ApplyTempMemPool(), propConfig, MeOption::propLimit);
+  meProp.isLfo = f.IsLfo();
+  meProp.TraversalBB(*f.GetCfg()->GetCommonEntryBB());
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\nNumber of propagations performed by hprop: " << meProp.propsPerformed << std::endl;
+    LogInfo::MapleLogger() << "============== After Copy Propagation  =============" << '\n';
+    f.Dump(false);
+  }
+
+  if (!meProp.CandsForSSAUpdate().empty()) {
+    MeSSAUpdate ssaUpdate(f, *f.GetMeSSATab(), *dom, meProp.CandsForSSAUpdate());
+    ssaUpdate.Run();
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_rc_lowering.cpp b/src/mapleall/maple_me/src/me_rc_lowering.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bd83f21825036227da5e714e3163f7a6ba7a0468
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_rc_lowering.cpp
@@ -0,0 +1,1682 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_rc_lowering.h"
+#include <cstring>
+#include "me_option.h"
+#include "me_dominance.h"
+#include "me_phase_manager.h"
+
+// RCLowering phase generate RC intrinsic for reference assignment
+// based on previous analyze results. RC intrinsic will later be lowered
+// in Code Generation
+namespace {
+const std::set<std::string> whiteListFunc {
+#include "rcwhitelist.def"
+};
+}
+
+namespace maple {
+static inline bool CheckOp(const MeStmt *stmt, Opcode op) {
+  return stmt != nullptr && stmt->GetOp() == op;
+}
+
+static inline void CheckRemove(MeStmt *stmt, Opcode op) {
+  if (CheckOp(stmt, op)) {
+    stmt->GetBB()->RemoveMeStmt(stmt);
+  }
+}
+
+void RCLowering::Prepare() {
+  MIRFunction *mirFunction = func.GetMirFunc();
+  ASSERT(mirFunction->GetModule()->CurFunction() == mirFunction, "unexpected CurFunction");
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "Handling function " << mirFunction->GetName() << '\n';
+  }
+  func.SetHints(func.GetHints() | kRcLowered);
+  isAnalyzed = (func.GetHints() & (kAnalyzeRCed | kPlacementRCed)) != 0;
+  rcCheckReferent = (mirFunction->GetName() ==
+                     "Ljava_2Flang_2Fref_2FReference_3B_7C_3Cinit_3E_7C_"
+                     "28Ljava_2Flang_2FObject_3BLjava_2Flang_2Fref_2FReferenceQueue_3B_29V");
+}
+
+void RCLowering::PreRCLower() {
+  // preparation steps before going through basicblocks
+  MarkLocalRefVar();
+
+  // if analyze rc phase has run, skip this
+  if (isAnalyzed) {
+    return;
+  }
+
+  MarkAllRefOpnds();
+  CreateCleanupIntrinsics();
+  auto *bb = func.GetCfg()->GetCommonEntryBB();
+  CHECK_FATAL(bb != nullptr, "null ptr check");
+  UpdateRefVarVersions(*bb);
+  UnmarkNotNeedDecRefOpnds();
+}
+
+void RCLowering::MarkLocalRefVar() {
+  MIRFunction *mirFunction = func.GetMirFunc();
+  size_t bsize = mirFunction->GetSymTab()->GetSymbolTableSize();
+  for (size_t i = 0; i < bsize; ++i) {
+    MIRSymbol *sym = mirFunction->GetSymTab()->GetSymbolFromStIdx(i);
+    if (sym != nullptr && sym->GetStorageClass() == kScAuto && !sym->IgnoreRC()) {
+      sym->SetLocalRefVar();
+    }
+  }
+}
+
+void RCLowering::MarkAllRefOpnds() {
+  // to prevent valid_end from being called repeatedly, don't modify the definition of eIt
+  for (auto bIt = cfg->valid_begin(), eIt = cfg->valid_end(); bIt != eIt; ++bIt) {
+    for (auto &stmt : (*bIt)->GetMeStmts()) {
+      MeExpr *lhsRef = stmt.GetLHSRef(false);
+      if (lhsRef == nullptr) {
+        continue;
+      }
+      if (lhsRef->GetMeOp() == kMeOpVar) {
+        auto *var = static_cast<VarMeExpr*>(lhsRef);
+        const OStIdx &ostIdx = var->GetOstIdx();
+        cleanUpVars[ostIdx] = var;
+        ssaTab.UpdateVarOstMap(ostIdx, varOStMap);
+      }
+      stmt.EnableNeedDecref();
+      MeExpr *rhs = stmt.GetRHS();
+      if (rhs == nullptr) {
+        continue;
+      }
+      if (rhs->PointsToSomethingThatNeedsIncRef()) {
+        stmt.EnableNeedIncref();
+      } else {
+        stmt.DisableNeedIncref();
+      }
+    }
+  }
+}
+
+// Mark the statement that needs incref or decref
+void RCLowering::UpdateRefVarVersions(BB &bb) {
+  std::map<OStIdx, size_t> savedStackSize;
+  RecordVarPhiVersions(savedStackSize, bb);
+
+  // traverse the BB stmts
+  TraverseAllStmts(bb);
+
+  // recursive call in preorder traversal of dominator tree
+  ASSERT(bb.GetBBId() < dominance->GetDomChildrenSize(), "index out of range");
+  const auto &domChildren = dominance->GetDomChildren(bb.GetID());
+  for (const auto &id : domChildren) {
+    UpdateRefVarVersions(*cfg->GetAllBBs().at(id));
+  }
+
+  // restore the stacks to their size at entry to this function invocation
+  RestoreVersionRecords(savedStackSize);
+}
+
+void RCLowering::RecordVarPhiVersions(std::map<OStIdx, size_t> &savedStackSize, const BB &bb) {
+  for (auto &item : std::as_const(varOStMap)) {
+    if (!item.second->IsLocal()) {
+      continue;
+    }
+    // record stack size
+    savedStackSize[item.second->GetIndex()] = varVersions[item.second->GetIndex()].size();
+    // if there is a phi, push stack
+    auto it = bb.GetMePhiList().find(item.second->GetIndex());
+    if (it != bb.GetMePhiList().end()) {
+      varVersions[item.second->GetIndex()].push_back((*it).second->GetLHS());
+    }
+  }
+}
+
+void RCLowering::TraverseAllStmts(BB &bb) {
+  MeStmts &stmts = bb.GetMeStmts();
+  if (stmts.empty()) {
+    return;
+  }
+
+  for (auto &stmt : stmts) {
+    MeExpr *lhsRef = stmt.GetLHSRef(false);
+    if (lhsRef == nullptr) {
+      continue;
+    }
+    OStIdx ostIdx(0);
+    if (lhsRef->GetMeOp() == kMeOpVar) {
+      ostIdx = static_cast<VarMeExpr*>(lhsRef)->GetOstIdx();
+    } else {
+      ASSERT(lhsRef->GetMeOp() == kMeOpIvar, "PreRCLower: Not Expected meop");
+      auto *ivar = static_cast<IvarMeExpr*>(lhsRef);
+      CHECK_FATAL(!ivar->HasMultipleMu(), "NYI");
+      auto *mu = ivar->GetUniqueMu();
+      if (mu != nullptr) {
+        ostIdx = mu->GetOstIdx();
+      } else {
+        ASSERT(ivar->GetDefStmt() != nullptr, "PreRCLower: ivar with mu==nullptr has no defStmt");
+        IassignMeStmt *iass = ivar->GetDefStmt();
+        ASSERT(!iass->GetChiList()->empty(), "PreRCLower: ivar with mu==nullptr has empty chiList at its def");
+        ostIdx = iass->GetChiList()->begin()->second->GetLHS()->GetOstIdx();
+      }
+    }
+    ASSERT(ostIdx != 0, "PreRCLower: cannot get ostIdx");
+    if (varOStMap.find(ostIdx) != varOStMap.end()) {
+      if (!varVersions[ostIdx].empty()) {
+        decOpnds[&stmt] = varVersions[ostIdx].back();
+      } else {
+        decOpnds[&stmt] = irMap.GetOrCreateZeroVersionVarMeExpr(*varOStMap[ostIdx]);
+      }
+    } else if (stmt.GetOp() == OP_intrinsiccall &&
+               static_cast<IntrinsiccallMeStmt&>(stmt).GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS) {
+      auto &intrn = static_cast<IntrinsiccallMeStmt&>(stmt);
+      for (size_t i = 0; i < intrn.NumMeStmtOpnds(); ++i) {
+        auto *varMeExpr = static_cast<VarMeExpr*>(intrn.GetOpnd(i));
+        if (!varVersions[ostIdx].empty()) {
+          intrn.SetOpnd(i, varVersions[varMeExpr->GetOstIdx()].back());
+        }
+      }
+    }
+    varVersions[ostIdx].push_back(lhsRef);
+  }
+}
+
+void RCLowering::RestoreVersionRecords(std::map<OStIdx, size_t> &savedStackSize) {
+  for (auto &item : std::as_const(varOStMap)) {
+    if (!item.second->IsLocal()) {
+      continue;
+    }
+    size_t lastSize = savedStackSize[item.second->GetIndex()];
+    while (varVersions[item.second->GetIndex()].size() > lastSize) {
+      varVersions[item.second->GetIndex()].pop_back();
+    }
+  }
+}
+
+void RCLowering::UnmarkNotNeedDecRefOpnds() {
+  for (auto &item : std::as_const(decOpnds)) {
+    if (item.first->GetLHSRef(false)->GetMeOp() == kMeOpVar) {
+      auto *var = static_cast<VarMeExpr*>(item.second);
+      OriginalSt *ost = varOStMap[var->GetOstIdx()];
+      if (ost->IsLocal() && !ost->IsFormal() && (var->IsZeroVersion() || var->GetDefBy() == kDefByNo)) {
+        item.first->DisableNeedDecref();
+      }
+    }
+  }
+}
+
+void RCLowering::CreateCleanupIntrinsics() {
+  for (BB *bb : cfg->GetCommonExitBB()->GetPred()) {
+    MeStmt *lastMeStmt = to_ptr(bb->GetMeStmts().rbegin());
+    if (!CheckOp(lastMeStmt, OP_return)) {
+      continue;
+    }
+    std::vector<MeExpr*> opnds;
+    for (auto &item : std::as_const(cleanUpVars)) {
+      if (!varOStMap[item.first]->IsLocal() || varOStMap[item.first]->IsFormal()) {
+        continue;
+      }
+      opnds.push_back(item.second);
+    }
+    IntrinsiccallMeStmt *intrn = irMap.CreateIntrinsicCallMeStmt(INTRN_MPL_CLEANUP_LOCALREFVARS, opnds);
+    bb->InsertMeStmtBefore(to_ptr(bb->GetMeStmts().rbegin()), intrn);
+  }
+}
+
+// move to MeFunction::CreateVarMeExprFromSym as func has ssaTab and irMap
+VarMeExpr *RCLowering::CreateVarMeExprFromSym(MIRSymbol &sym) const {
+  OriginalSt *ost = ssaTab.FindOrCreateSymbolOriginalSt(sym, func.GetMirFunc()->GetPuidx(), 0);
+  return irMap.GetOrCreateZeroVersionVarMeExpr(*ost);
+}
+
+// note that RCInstrinsic creation will check the ref assignment and reuse lhs if possible
+IntrinsiccallMeStmt *RCLowering::CreateRCIntrinsic(MIRIntrinsicID intrnID, const MeStmt &stmt,
+                                                   std::vector<MeExpr*> &opnds, bool assigned) {
+  IntrinsiccallMeStmt *intrn = nullptr;
+  if (assigned) {
+    ScalarMeExpr *ret = (stmt.GetOp() == OP_regassign) ? stmt.GetLHS() : irMap.CreateRegMeExpr(PTY_ref);
+    intrn = irMap.CreateIntrinsicCallAssignedMeStmt(intrnID, opnds, ret);
+  } else {
+    intrn = irMap.CreateIntrinsicCallMeStmt(intrnID, opnds);
+  }
+  intrn->SetSrcPos(stmt.GetSrcPosition());
+  return intrn;
+}
+
+MIRIntrinsicID RCLowering::PrepareVolatileCall(const MeStmt &stmt, MIRIntrinsicID intrnId) {
+  bool isLoad = (intrnId == INTRN_MCCLoadRefSVol || intrnId == INTRN_MCCLoadWeakVol || intrnId == INTRN_MCCLoadRefVol);
+  if (isLoad) {
+    CheckRemove(stmt.GetNext(), OP_membaracquire);
+  } else {  // volatile store case
+    CheckRemove(stmt.GetPrev(), OP_membarrelease);
+    CheckRemove(stmt.GetNext(), OP_membarstoreload);
+  }
+  return intrnId;
+}
+
+IntrinsiccallMeStmt *RCLowering::GetVarRHSHandleStmt(const MeStmt &stmt) {
+  auto *var = static_cast<VarMeExpr*>(stmt.GetRHS());
+  const MIRSymbol *sym = var->GetOst()->GetMIRSymbol();
+  if (!sym->IsGlobal() || sym->IsFinal()) {
+    return nullptr;
+  }
+  // load global into temp and update rhs to temp
+  std::vector<MeExpr*> opnds;
+  bool isVolatile = var->IsVolatile();
+  MIRIntrinsicID rcCallID = INTRN_UNDEFINED;
+  if (!MeOption::strictNaiveRC || isVolatile) {
+    rcCallID = isVolatile ? PrepareVolatileCall(stmt, INTRN_MCCLoadRefSVol) : INTRN_MCCLoadRefS;
+    opnds.push_back(irMap.CreateAddrofMeExpr(*var));
+  }
+
+  // rhs is not special, skip
+  if (rcCallID == INTRN_UNDEFINED) {
+    return nullptr;
+  }
+  // rhs is special, need handle
+  return CreateRCIntrinsic(rcCallID, stmt, opnds, true);
+}
+
+IntrinsiccallMeStmt *RCLowering::GetIvarRHSHandleStmt(const MeStmt &stmt) {
+  auto *ivar = static_cast<IvarMeExpr*>(stmt.GetRHS());
+  if (ivar->IsFinal()) {
+    return nullptr;
+  }
+  // load global into temp and update rhs to temp
+  std::vector<MeExpr*> opnds;
+  bool isRCWeak = ivar->IsRCWeak();
+  // @Weak annotation handling
+  MIRIntrinsicID rcCallId =
+      ivar->IsVolatile() ? PrepareVolatileCall(stmt, isRCWeak ? INTRN_MCCLoadWeakVol : INTRN_MCCLoadRefVol)
+                         : (isRCWeak ? INTRN_MCCLoadWeak : INTRN_MCCLoadRef);
+  opnds.push_back(&ivar->GetBase()->GetAddrExprBase());
+  opnds.push_back(irMap.CreateAddrofMeExpr(*ivar));
+  // rhs is not special, skip
+  if (rcCallId == INTRN_UNDEFINED) {
+    return nullptr;
+  }
+  // rhs is special, need handle
+  return CreateRCIntrinsic(rcCallId, stmt, opnds, true);
+}
+
+// this function returns true if we generated new MRT calls and replaced rhs
+void RCLowering::HandleAssignMeStmtRHS(MeStmt &stmt) {
+  if (!stmt.NeedIncref()) {
+    return;
+  }
+  MeExpr *rhs = stmt.GetRHS();
+  CHECK_FATAL(rhs != nullptr, "rhs is nullptr in RCLowering::HandleAssignMeStmtRHS");
+  IntrinsiccallMeStmt *loadCall = nullptr;
+  bool isRCWeak = false;
+  std::vector<MeExpr*> opnds;
+  if (rhs->GetMeOp() == kMeOpVar) {
+    loadCall = GetVarRHSHandleStmt(stmt);
+  } else if (rhs->GetMeOp() == kMeOpIvar) {
+    isRCWeak = static_cast<IvarMeExpr*>(rhs)->IsRCWeak();
+    loadCall = GetIvarRHSHandleStmt(stmt);
+  }
+  // rhs is not special, skip
+  if (loadCall == nullptr) {
+    return;
+  }
+  if (stmt.GetOp() == OP_regassign) {
+    stmt.GetBB()->ReplaceMeStmt(&stmt, loadCall);
+    if (rhs->IsVolatile() && !isRCWeak) {
+      stmt.SetOpnd(1, loadCall->GetMustDefList()->front().GetLHS());
+    }
+  } else {
+    stmt.GetBB()->InsertMeStmtBefore(&stmt, loadCall);
+    stmt.SetOpnd(1, loadCall->GetMustDefList()->front().GetLHS());
+  }
+  stmt.DisableNeedIncref();
+}
+
+void RCLowering::HandleCallAssignedMeStmt(MeStmt &stmt, MeExpr *pendingDec) {
+  MapleVector<MustDefMeNode> *mustDefs = stmt.GetMustDefList();
+  ASSERT_NOT_NULL(mustDefs);
+
+  BB *bb = stmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb null ptr check");
+  if (mustDefs->empty()) {
+    // introduce a ret and decref on it as callee has +1 return ref
+    IntroduceRegRetIntoCallAssigned(stmt);
+    return;
+  }
+
+  // decref for old value
+  MeExpr *lhs = mustDefs->front().GetLHS();
+  if (lhs->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  auto *ost = static_cast<VarMeExpr*>(lhs)->GetOst();
+  if (!ost->IsSymbolOst()) {
+    return;
+  }
+  const MIRSymbol *retSym = ost->GetMIRSymbol();
+  if (retSym == nullptr) {
+    return;
+  }
+  // rcunowned needs special handling
+  if (retSym->IgnoreRC() && !retSym->GetAttr(ATTR_rcunowned)) {
+    return;
+  }
+  assignedPtrSym.insert(retSym);
+  if (retSym->GetAttr(ATTR_rcunowned)) {
+    // if retSym is rcunowned, we need to introduce a new localrefvar to decref in cleanup
+    MeStmt *regToTmp = irMap.CreateAssignMeStmt(*CreateNewTmpVarMeExpr(true), *lhs, *bb);
+    bb->InsertMeStmtAfter(&stmt, regToTmp);
+    return;
+  }
+  if (!stmt.NeedDecref()) {
+    return;
+  }
+
+  CHECK_FATAL(pendingDec != nullptr, "pendingDec null ptr check");
+  HandleRetOfCallAssignedMeStmt(stmt, *pendingDec);
+}
+
+void RCLowering::IntroduceRegRetIntoCallAssigned(MeStmt &stmt) {
+  RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref);
+  stmt.GetMustDefList()->push_back(MustDefMeNode(curTmp, &stmt));
+  std::vector<MeExpr*> opnds = { curTmp };
+  IntrinsiccallMeStmt *decRefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
+  stmt.GetBB()->InsertMeStmtAfter(&stmt, decRefCall);
+}
+
+void RCLowering::HandleRetOfCallAssignedMeStmt(MeStmt &stmt, MeExpr &pendingDec) {
+  BB *bb = stmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb null ptr check");
+  AssignMeStmt *backup = irMap.CreateAssignMeStmt(*irMap.CreateRegMeExpr(PTY_ref), pendingDec, *bb);
+  std::vector<MeExpr*> opnds = { backup->GetLHS() };
+  IntrinsiccallMeStmt *decRefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
+  if (!instance_of<CallMeStmt>(stmt)) {
+    bb->InsertMeStmtBefore(&stmt, backup);
+    bb->InsertMeStmtAfter(&stmt, decRefCall);
+  } else {
+    // simple optimization for callassign
+    // instead of change callassign {dassign} to backup; callassign {dassign}; decref
+    // callassign {regassign}; backup; dassign (regread); decref
+    RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref);
+    MeStmt *regToVar = irMap.CreateAssignMeStmt(*stmt.GetAssignedLHS(), *curTmp, *bb);
+    stmt.GetMustDefList()->front().UpdateLHS(*curTmp);
+    bb->InsertMeStmtAfter(&stmt, decRefCall);
+    bb->InsertMeStmtAfter(&stmt, regToVar);
+    bb->InsertMeStmtAfter(&stmt, backup);
+  }
+}
+
+bool RCLowering::RCFirst(MeExpr &rhs) {
+  // null, local var/reg read
+  if (rhs.GetMeOp() == kMeOpConst) {
+    return static_cast<ConstMeExpr&>(rhs).IsZero();
+  }
+  if (rhs.GetMeOp() == kMeOpVar) {
+    auto &rhsVar = static_cast<VarMeExpr&>(rhs);
+    const MIRSymbol *sym = rhsVar.GetOst()->GetMIRSymbol();
+    return sym->IsLocal();
+  }
+  return rhs.GetMeOp() == kMeOpReg;
+}
+
+void RCLowering::PreprocessAssignMeStmt(MeStmt &stmt) {
+  BB *bb = stmt.GetBB();
+  MeExpr *lhs = nullptr;
+  if (stmt.GetOp() != OP_iassign) {
+    lhs = stmt.GetLHS();
+  } else {
+    lhs = static_cast<IassignMeStmt &>(stmt).GetLHSVal();
+  }
+  CHECK_FATAL(lhs != nullptr, "null ptr check");
+  MeExpr *rhs = stmt.GetRHS();
+  CHECK_FATAL(rhs != nullptr, "null ptr check");
+  // Check whether there is any statement exist whose opnd is the throw value in catch BB
+  if (needSpecialHandleException && rhs->GetMeOp() == kMeOpReg &&
+      static_cast<RegMeExpr*>(rhs)->GetRegIdx() == -kSregThrownval) {
+    needSpecialHandleException = false;
+  }
+  if (lhs->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  const MIRSymbol *lsym = stmt.GetVarLHS()->GetOst()->GetMIRSymbol();
+  if (stmt.GetOp() == OP_dassign && (lsym->GetStorageClass() == kScAuto || lsym->GetStorageClass() == kScFormal) &&
+      stmt.GetLHS()->GetOst() != static_cast<ScalarMeExpr *>(stmt.GetRHS())->GetOst()) {
+    assignedPtrSym.insert(lsym);
+  }
+  if (rhs->GetMeOp() != kMeOpGcmalloc) {
+    return;
+  }
+  gcMallocObjects.insert(lhs);
+  if (lsym->GetAttr(ATTR_rcunowned)) {
+    // if new obj is assigned to unowned refvar, we need a localrefvar
+    // to decref at exit
+    // introduce new localrefvar = lhs after current stmt
+    MeStmt *backup = irMap.CreateAssignMeStmt(*CreateNewTmpVarMeExpr(true), *lhs, *bb);
+    // backup will not have any incref/decref
+    bb->InsertMeStmtAfter(&stmt, backup);
+  }
+}
+
+void RCLowering::HandleAssignMeStmtRegLHS(MeStmt &stmt) {
+  if (!stmt.NeedIncref()) {
+    return;
+  }
+  std::vector<MeExpr*> opnds = { stmt.GetLHS() };
+  IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, opnds);
+  stmt.GetBB()->InsertMeStmtAfter(&stmt, incCall);
+}
+
+void RCLowering::HandleAssignMeStmtVarLHS(MeStmt &stmt, MeExpr *pendingDec) {
+  const MIRSymbol *lsym = stmt.GetVarLHS()->GetOst()->GetMIRSymbol();
+  if (lsym->IgnoreRC()) {
+    return;
+  }
+  if (lsym->IsGlobal()) {
+    // decref could be optimized away after if null check
+    HandleAssignToGlobalVar(stmt);
+  } else {
+    // local assign, backup old value and insert Inc and Dec after
+    HandleAssignToLocalVar(stmt, pendingDec);
+  }
+  assignedPtrSym.insert(lsym);
+}
+
+MIRType *RCLowering::GetArrayNodeType(const VarMeExpr &var) {
+  const MIRSymbol *arrayElemSym = var.GetOst()->GetMIRSymbol();
+  MIRType *baseType = arrayElemSym->GetType();
+  MIRType *arrayElemType = nullptr;
+  if (baseType != nullptr) {
+    MIRType *stType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(
+        static_cast<MIRPtrType*>(baseType)->GetPointedTyIdx());
+    while (stType->GetKind() == kTypeJArray) {
+      MIRJarrayType *baseType1 = static_cast<MIRJarrayType*>(stType);
+      MIRType *elemType = baseType1->GetElemType();
+      if (elemType->GetKind() == kTypePointer) {
+        const TyIdx &index = static_cast<MIRPtrType*>(elemType)->GetPointedTyIdx();
+        stType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(index);
+      } else {
+        stType = elemType;
+      }
+    }
+    arrayElemType = stType;
+  }
+  return arrayElemType;
+}
+
+void RCLowering::CheckArrayStore(IntrinsiccallMeStmt &writeRefCall) {
+  if (!Options::checkArrayStore) {
+    return;
+  }
+  MIRIntrinsicID intrnID = writeRefCall.GetIntrinsic();
+  if (!((INTRN_MCCWriteVolNoInc <= intrnID) && (INTRN_MCCWrite >= intrnID))) {
+    return;
+  }
+  if (writeRefCall.GetOpnd(1)->GetOp() != OP_iaddrof) {
+    return;
+  }
+  OpMeExpr *opExpr = static_cast<OpMeExpr*>(writeRefCall.GetOpnd(1));
+  if (opExpr->GetOpnd(0)->GetOp() != OP_array) {
+    return;
+  }
+  MeExpr *arrayNode = writeRefCall.GetOpnd(0);
+  if (arrayNode->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  VarMeExpr *arrayVar = static_cast<VarMeExpr*>(arrayNode);
+  MeExpr *valueNode = writeRefCall.GetOpnd(2);
+  if (valueNode->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  MIRType *arrayElemType = GetArrayNodeType(*arrayVar);
+  MIRType *valueRealType = GetArrayNodeType(*(static_cast<VarMeExpr*>(valueNode)));
+  if ((arrayElemType != nullptr) && (arrayElemType->GetKind() == kTypeClass) &&
+      static_cast<MIRClassType*>(arrayElemType)->IsFinal() &&
+      (valueRealType != nullptr) && (valueRealType->GetKind() == kTypeClass) &&
+      static_cast<MIRClassType*>(valueRealType)->IsFinal() &&
+      (valueRealType->GetTypeIndex() == arrayElemType->GetTypeIndex())) {
+    return;
+  }
+  std::vector<MeExpr*> opnds = { arrayNode, valueNode };
+  IntrinsiccallMeStmt *checkStmt = irMap.CreateIntrinsicCallMeStmt(INTRN_MCCCheckArrayStore, opnds);
+  writeRefCall.GetBB()->InsertMeStmtBefore(&writeRefCall, checkStmt);
+}
+
+void RCLowering::HandleAssignToGlobalVar(MeStmt &stmt) {
+  MeExpr *lhs = stmt.GetLHS();
+  CHECK_FATAL(lhs != nullptr, "null ptr check");
+  MeExpr *rhs = stmt.GetRHS();
+  CHECK_FATAL(rhs != nullptr, "null ptr check");
+  BB *bb = stmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb null ptr check");
+
+  std::vector<MeExpr*> opnds = { irMap.CreateAddrofMeExpr(*lhs), rhs };
+  IntrinsiccallMeStmt *writeRefCall = CreateRCIntrinsic(SelectWriteBarrier(stmt), stmt, opnds);
+  bb->ReplaceMeStmt(&stmt, writeRefCall);
+  CheckArrayStore(*writeRefCall);
+}
+
+void RCLowering::HandleAssignToLocalVar(MeStmt &stmt, MeExpr *pendingDec) {
+  MeExpr *lhs = stmt.GetLHS();
+  CHECK_FATAL(lhs != nullptr, "null ptr check");
+  MeExpr *rhs = stmt.GetRHS();
+  CHECK_FATAL(rhs != nullptr, "null ptr check");
+  BB *bb = stmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb null ptr check");
+  bool incWithLHS = stmt.NeedIncref();
+
+  if (stmt.NeedDecref()) {
+    if (RCFirst(*rhs)) {
+      // temp is not needed
+      if (incWithLHS) {
+        std::vector<MeExpr*> opnds = { rhs };
+        IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, opnds);
+        bb->InsertMeStmtBefore(&stmt, incCall);
+        incWithLHS = false;
+      }
+      std::vector<MeExpr*> opnds = { pendingDec };
+      IntrinsiccallMeStmt *decCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
+      bb->InsertMeStmtBefore(&stmt, decCall);
+    } else {
+      AssignMeStmt *backup = irMap.CreateAssignMeStmt(*irMap.CreateRegMeExpr(PTY_ref), *pendingDec, *bb);
+      bb->InsertMeStmtBefore(&stmt, backup);
+      std::vector<MeExpr*> opnds = { backup->GetLHS() };
+      IntrinsiccallMeStmt *decCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
+      bb->InsertMeStmtAfter(&stmt, decCall);
+    }
+  }
+  if (incWithLHS) {
+    std::vector<MeExpr*> opnds = { lhs };
+    IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, opnds);
+    bb->InsertMeStmtAfter(&stmt, incCall);
+  }
+}
+
+bool RCLowering::IsInitialized(IvarMeExpr &ivar) {
+  MeExpr *base = ivar.GetBase();
+  if (base->GetMeOp() != kMeOpVar) {
+    return true;
+  }
+  if (gcMallocObjects.find(base) == gcMallocObjects.end()) {
+    return true;
+  }
+  FieldID fieldID = ivar.GetFieldID();
+  std::set<FieldID> &fieldSet = initializedFields[base];
+  if (fieldSet.count(fieldID) > 0 || fieldSet.count(0) > 0) {
+    return true;
+  }
+  MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx());
+  auto *ptype = utils::ToRef(safe_cast<MIRPtrType>(baseType)).GetPointedType();
+  auto *classType = safe_cast<MIRClassType>(ptype);
+  return classType == nullptr || !classType->IsOwnField(fieldID);
+}
+
+void RCLowering::HandleAssignMeStmtIvarLHS(MeStmt &stmt) {
+  auto &iassign = static_cast<IassignMeStmt&>(stmt);
+  IvarMeExpr *lhsInner = iassign.GetLHSVal();
+  FieldID fieldID = lhsInner->GetFieldID();
+  MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsInner->GetTyIdx());
+  auto *ptype = utils::ToRef(safe_cast<MIRPtrType>(baseType)).GetPointedType();
+  auto *classType = safe_cast<MIRClassType>(ptype);
+  // skip RC operation if the field is unowned
+  if (classType != nullptr && classType->IsFieldRCUnownedRef(fieldID)) {
+    return;
+  }
+  if (!IsInitialized(*lhsInner)) {
+    stmt.DisableNeedDecref();
+    std::set<FieldID> &fieldSet = initializedFields[lhsInner->GetBase()];
+    fieldSet.insert(fieldID);
+  }
+  MeExpr *rhsInner = stmt.GetRHS();
+  bool isReferent = false;
+  if (rcCheckReferent) {
+    // check if iassign field is volatile T referent;
+    FieldID id = mirModule.GetMIRBuilder()->GetStructFieldIDFromFieldNameParentFirst(ptype, "referent");
+    if (id == iassign.GetLHSVal()->GetFieldID()) {
+      std::vector<MeExpr*> opnds = { &lhsInner->GetBase()->GetAddrExprBase(), rhsInner };
+      IntrinsiccallMeStmt *writeReferentCall = CreateRCIntrinsic(INTRN_MCCWriteReferent, stmt, opnds);
+      stmt.GetBB()->InsertMeStmtAfter(&stmt, writeReferentCall);
+      isReferent = true;
+    }
+  }
+  MIRIntrinsicID intrinsicID = SelectWriteBarrier(stmt);
+  if (isReferent) {  // optimize storeload again due to referent handling
+    MeStmt *next = stmt.GetNext();
+    if (next != nullptr) {
+      next = next->GetNext();
+    }
+    CheckRemove(next, OP_membarstoreload);
+  }
+  std::vector<MeExpr*> opnds = {
+      &lhsInner->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*lhsInner), rhsInner };
+  IntrinsiccallMeStmt *writeRefCall = CreateRCIntrinsic(intrinsicID, stmt, opnds);
+  stmt.GetBB()->ReplaceMeStmt(&stmt, writeRefCall);
+  CheckArrayStore(*writeRefCall);
+}
+
+void RCLowering::HandleAssignMeStmt(MeStmt &stmt, MeExpr *pendingDec) {
+  HandlePerManent(stmt);
+  PreprocessAssignMeStmt(stmt);
+  if (!stmt.NeedIncref() && !stmt.NeedDecref()) {
+    return;
+  }
+  HandleAssignMeStmtRHS(stmt);
+  MeExpr *lhs = nullptr;
+  if (stmt.GetOp() != OP_iassign) {
+    lhs = stmt.GetLHS();
+  } else {
+    lhs = static_cast<IassignMeStmt &>(stmt).GetLHSVal();
+  }
+  CHECK_FATAL(lhs != nullptr, "null ptr check");
+  if (lhs->GetMeOp() == kMeOpReg) {
+    HandleAssignMeStmtRegLHS(stmt);
+  } else if (lhs->GetMeOp() == kMeOpVar) {
+    HandleAssignMeStmtVarLHS(stmt, pendingDec);
+  } else if (lhs->GetMeOp() == kMeOpIvar) {
+    HandleAssignMeStmtIvarLHS(stmt);
+  }
+}
+
+void RCLowering::HandlePerManent(MeStmt &stmt) {
+  VarMeExpr *lhs = static_cast<VarMeExpr *>(stmt.GetVarLHS());
+  if (lhs == nullptr) {
+    return;
+  }
+
+  const MIRSymbol *sym = lhs->GetOst()->GetMIRSymbol();
+  if (sym->GetType()->GetPrimType() != PTY_ref) {
+    return;
+  }
+  if (!sym->IsStatic() || !sym->IsFinal()) {
+    return;
+  }
+
+  MeExpr *rhs = stmt.GetRHS();
+  MeStmt *defStmt = nullptr;
+  if (rhs->GetMeOp() == kMeOpVar) {
+    auto *var = static_cast<VarMeExpr*>(rhs);
+    if (var->GetDefBy() == kDefByStmt) {
+      defStmt = var->GetDefStmt();
+    }
+  } else if (rhs->GetMeOp() == kMeOpReg) {
+    auto *regVar = static_cast<RegMeExpr*>(rhs);
+    if (regVar->GetDefBy() == kDefByStmt) {
+      defStmt = regVar->GetDefStmt();
+    }
+  }
+  if (defStmt != nullptr) {
+    MeExpr *rhsOfDefStmt = defStmt->GetRHS();
+    if (rhsOfDefStmt->IsGcmalloc() && !HasCallOrBranch(*defStmt, stmt)) {
+      if (rhsOfDefStmt->GetOp() == OP_gcmalloc) {
+        rhsOfDefStmt->SetOp(OP_gcpermalloc);
+      } else if (rhsOfDefStmt->GetOp() == OP_gcmallocjarray) {
+        rhsOfDefStmt->SetOp(OP_gcpermallocjarray);
+      }
+      return;
+    }
+  }
+  std::vector<MeExpr*> opnds = { rhs };
+  IntrinsiccallMeStmt *setPermanentCall = CreateRCIntrinsic(INTRN_MCCSetPermanent, stmt, opnds);
+  stmt.GetBB()->InsertMeStmtBefore(&stmt, setPermanentCall);
+}
+
+bool RCLowering::HasCallOrBranch(const MeStmt &from, const MeStmt &to) const {
+  if (from.GetBB() != to.GetBB()) {
+    return true;
+  }
+  for (const MeStmt *stmt = &from; stmt != &to; stmt = stmt->GetNextMeStmt()) {
+    if (kOpcodeInfo.IsCall(stmt->GetOp())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// align with order in rcinsertion, otherwise missing weak volatile
+// note that we are generating INTRN_MCCWriteNoRC so write_barrier is supported,
+// otherwise iassign would be enough.
+MIRIntrinsicID RCLowering::SelectWriteBarrier(const MeStmt &stmt) {
+  bool incWithLHS = stmt.NeedIncref();
+  bool decWithLHS = stmt.NeedDecref();
+  MeExpr *lhs = nullptr;
+  if (stmt.GetOp() != OP_iassign) {
+    lhs = stmt.GetLHS();
+  } else {
+    lhs = static_cast<const IassignMeStmt &>(stmt).GetLHSVal();
+  }
+  CHECK_FATAL(lhs != nullptr, "null ptr check");
+  MeExprOp meOp = lhs->GetMeOp();
+  CHECK_FATAL((meOp == kMeOpVar || meOp == kMeOpIvar), "Not Expected meOp");
+  if (lhs->IsVolatile()) {
+    if (meOp == kMeOpVar) {
+      return PrepareVolatileCall(stmt, incWithLHS ? (decWithLHS ? INTRN_MCCWriteSVol : INTRN_MCCWriteSVolNoDec)
+                                                  : (decWithLHS ? INTRN_MCCWriteSVolNoInc : INTRN_MCCWriteSVolNoRC));
+    }
+    if (static_cast<IvarMeExpr*>(lhs)->IsRCWeak()) {
+      return PrepareVolatileCall(stmt, INTRN_MCCWriteVolWeak);
+    }
+    return PrepareVolatileCall(stmt, incWithLHS ? INTRN_MCCWriteVol : INTRN_MCCWriteVolNoInc);
+  }
+  if (meOp == kMeOpVar) {
+    return incWithLHS ? (decWithLHS ? INTRN_MCCWriteS : INTRN_MCCWriteSNoDec)
+                      : (decWithLHS ? INTRN_MCCWriteSNoInc : INTRN_MCCWriteSNoRC);
+  }
+  if (static_cast<IvarMeExpr*>(lhs)->IsRCWeak()) {
+    return INTRN_MCCWriteWeak;
+  }
+  return incWithLHS ? (decWithLHS ? INTRN_MCCWrite : INTRN_MCCWriteNoDec)
+                    : (decWithLHS ? INTRN_MCCWriteNoInc : INTRN_MCCWriteNoRC);
+}
+
+void RCLowering::RCLower() {
+  // to prevent valid_end from being called repeatedly, don't modify the definition of eIt
+  for (auto bIt = cfg->valid_begin(), eIt = cfg->valid_end(); bIt != eIt; ++bIt) {
+    if (bIt == cfg->common_entry() || bIt == cfg->common_exit()) {
+      continue;
+    }
+    EpreFixup(**bIt);
+    BBLower(**bIt);
+  }
+}
+
+MeExpr *RCLowering::HandleIncRefAndDecRefStmt(MeStmt &stmt) {
+  Opcode opCode = stmt.GetOp();
+  if (opCode == OP_decref) {
+    stmt.GetBB()->RemoveMeStmt(&stmt);
+    return stmt.GetOpnd(0);
+  }
+
+  if (opCode != OP_incref && opCode != OP_decrefreset) {
+    return nullptr;
+  }
+
+  MIRIntrinsicID rcCallID = opCode == OP_incref ? INTRN_MCCIncRef : INTRN_MCCDecRefReset;
+  std::vector<MeExpr*> opnds = { stmt.GetOpnd(0) };
+  IntrinsiccallMeStmt *rcCall = CreateRCIntrinsic(rcCallID, stmt, opnds);
+  stmt.GetBB()->ReplaceMeStmt(&stmt, rcCall);
+  return nullptr;
+}
+
+// if a var me expr is initialized by constructor, record it's initialized map
+// if a field id is not in initialized map, means the field has not been assigned a value
+// dec ref is not necessary in it's first assignment.
+void RCLowering::InitializedObjectFields(MeStmt &stmt) {
+  if (stmt.GetOp() != OP_callassigned) {
+    return;
+  }
+  auto &call = static_cast<CallMeStmt&>(stmt);
+  MIRFunction &callee = call.GetTargetFunction();
+  if (call.NumMeStmtOpnds() == 0 || call.GetOpnd(0)->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  MeExpr *firstOpnd = call.GetOpnd(0);
+  bool isNew = gcMallocObjects.find(firstOpnd) != gcMallocObjects.end();
+  bool hasNotInitialized = initializedFields.find(firstOpnd) == initializedFields.end();
+  bool inInitializedMap =
+      mirModule.GetPuIdxFieldInitializedMap().find(call.GetPUIdx()) != mirModule.GetPuIdxFieldInitializedMap().end();
+  if (callee.IsConstructor() && isNew && hasNotInitialized && inInitializedMap) {
+    initializedFields.emplace(firstOpnd, std::set<FieldID>());
+    const auto *origFieldSet = mirModule.GetPUIdxFieldInitializedMapItem(call.GetPUIdx());
+    if (origFieldSet != nullptr) {
+      initializedFields[firstOpnd].insert(origFieldSet->cbegin(), origFieldSet->cend());
+    }
+  } else {
+    for (auto iter : call.GetOpnds()) {
+      gcMallocObjects.erase(iter);
+    }
+  }
+}
+
+void RCLowering::BBLower(BB &bb) {
+  MeExpr *pendingDec = nullptr;
+  gcMallocObjects.clear();
+  initializedFields.clear();
+  needSpecialHandleException = bb.GetAttributes(kBBAttrIsCatch);
+  for (auto &stmt : bb.GetMeStmts()) {
+    if (!isAnalyzed && decOpnds.find(&stmt) != decOpnds.end()) {
+      pendingDec = decOpnds[&stmt];
+    }
+    Opcode opcode = stmt.GetOp();
+    if (opcode == OP_return) {
+      rets.push_back(&stmt);
+    } else if (kOpcodeInfo.IsCallAssigned(opcode)) {
+      MIRType *retType = stmt.GetReturnType();
+      if (retType != nullptr && retType->GetPrimType() == PTY_ref) {
+        HandleCallAssignedMeStmt(stmt, pendingDec);
+      }
+      InitializedObjectFields(stmt);
+    } else if (stmt.IsAssign()) {
+      HandleAssignMeStmt(stmt, pendingDec);
+    } else {
+      MeExpr *ret = HandleIncRefAndDecRefStmt(stmt);
+      pendingDec = ret == nullptr ? pendingDec : ret;
+    }
+  }
+  // there is no any statement exist whose opnd is the throw value, handle it
+  if (needSpecialHandleException) {
+    // create throw value
+    OriginalSt *ost =
+        ssaTab.GetOriginalStTable().FindOrCreatePregOriginalSt(-kSregThrownval, func.GetMirFunc()->GetPuidx());
+    ost->SetTyIdx(GlobalTables::GetTypeTable().GetPrimType(PTY_ref)->GetTypeIndex());
+    RegMeExpr *regReadExpr = irMap.CreateRegMeExprVersion(*ost);
+    regReadExpr->SetPtyp(PTY_ref);
+    MeStmt *firstMeStmt = to_ptr(bb.GetMeStmts().begin());
+    std::vector<MeExpr*> opnds = { regReadExpr };
+    IntrinsiccallMeStmt *decRefcall = CreateRCIntrinsic(INTRN_MCCDecRef, *firstMeStmt, opnds);
+    bb.InsertMeStmtAfter(firstMeStmt, decRefcall);
+  }
+}
+
+IntrinsiccallMeStmt *FindCleanupIntrinsic(BB &bb) {
+  auto &meStmts = bb.GetMeStmts();
+  for (auto iter = meStmts.rbegin(); iter != meStmts.rend(); ++iter) {
+    if (CheckOp(to_ptr(iter), OP_intrinsiccall)) {
+      auto *intrinsicCall = static_cast<IntrinsiccallMeStmt*>(to_ptr(iter));
+      if (intrinsicCall->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS) {
+        return intrinsicCall;
+      }
+    }
+  }
+  return nullptr;
+}
+
+// epre could have change dassign (iread) to regassign (iread) + dassign (regread)
+// as a result, LoadRefField was not generated. This function fixes up the issue
+// by checking rhs to see if it is regread and then try to
+// propagate incref from current stmt back to regassign from iread which had no incref
+void RCLowering::EpreFixup(BB &bb) {
+  for (auto &stmt : bb.GetMeStmts()) {
+    // remove decref as mpl2mpl will insert based on ref assign
+    if (!stmt.NeedIncref()) {
+      continue;
+    }
+    MeExpr *rhs = stmt.GetRHS();
+    if (stmt.GetOp() != OP_dassign || rhs == nullptr || rhs->GetOp() != OP_regread) {
+      continue;
+    }
+    auto *rhsVar = static_cast<RegMeExpr*>(rhs);
+    if (rhsVar->GetDefBy() != kDefByStmt) {
+      continue;
+    }
+    MeStmt *defStmt = rhsVar->GetDefStmt();
+    if (defStmt->GetBB() != stmt.GetBB()) {
+      continue;  // we cannot fix up across bb
+    }
+    CHECK_FATAL(defStmt->GetRHS() != nullptr, "null ptr check");
+    if (defStmt->NeedIncref() || defStmt->GetRHS()->GetOp() != OP_iread) {
+      continue;
+    }
+    // pull incref from regread stmt to regassign
+    defStmt->EnableNeedIncref();
+    stmt.DisableNeedIncref();
+  }
+}
+
+void RCLowering::HandleReturnVar(RetMeStmt &ret) {
+  auto *retVar = static_cast<VarMeExpr*>(ret.GetOpnd(0));
+  CHECK_FATAL(retVar != nullptr, "retVal null ptr check");
+  MIRSymbol *sym = retVar->GetOst()->GetMIRSymbol();
+  if (sym != nullptr && sym->IgnoreRC()) {
+    return;
+  }
+  // if dread is local assigned var, no need inc because we will skip its dec
+  // unless we are change it to regread in later optimization
+  if (assignedPtrSym.count(sym) > 0 && sym->GetStorageClass() == kScAuto && !MeOption::regreadAtReturn) {
+    return;
+  }
+  if (sym != nullptr && sym->IsGlobal() && !sym->IsFinal()) {
+    HandleReturnGlobal(ret);
+  } else if (assignedPtrSym.count(sym) > 0 && sym->GetStorageClass() == kScAuto && sym->GetAttr(ATTR_localrefvar)) {
+    // must be regreadAtReturn
+    // checking localrefvar because some objects are meta
+    HandleReturnRegread(ret);
+  } else if (!((func.GetHints() & kPlacementRCed) && sym != nullptr && sym->GetStorageClass() == kScFormal &&
+               assignedPtrSym.count(sym) > 0)) {
+    // if returning formal, incref unless placementRC is used and formal is NOT reassigned
+    HandleReturnFormal(ret);
+  }
+}
+
+void RCLowering::HandleReturnGlobal(RetMeStmt &ret) {
+  BB *bb = ret.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb null ptr check");
+  auto *retVar = static_cast<VarMeExpr*>(ret.GetOpnd(0));
+  CHECK_FATAL(retVar != nullptr, "retVal null ptr check");
+  if (MeOption::strictNaiveRC) {
+    RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref);
+    AssignMeStmt *regAssStmt = irMap.CreateAssignMeStmt(*curTmp, *retVar, *bb);
+    bb->InsertMeStmtBefore(&ret, regAssStmt);
+    std::vector<MeExpr*> opnds = { regAssStmt->GetLHS() };
+    IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, *regAssStmt, opnds, true);
+    bb->InsertMeStmtBefore(&ret, incCall);
+    ret.SetOpnd(0, curTmp);
+  } else {
+    std::vector<MeExpr*> opnds = { irMap.CreateAddrofMeExpr(*retVar) };
+    IntrinsiccallMeStmt *loadCall = CreateRCIntrinsic(INTRN_MCCLoadRefS, ret, opnds, true);
+    bb->InsertMeStmtBefore(&ret, loadCall);
+    ret.SetOpnd(0, loadCall->GetMustDefList()->front().GetLHS());
+  }
+}
+
+void RCLowering::HandleReturnRegread(RetMeStmt &ret) {
+  BB *bb = ret.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb null ptr check");
+  auto *retVar = static_cast<VarMeExpr*>(ret.GetOpnd(0));
+  CHECK_FATAL(retVar != nullptr, "retVal null ptr check");
+  IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(*bb);
+  if (cleanup == nullptr) {
+    std::vector<MeExpr*> opnds = { retVar };
+    IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, ret, opnds);
+    bb->InsertMeStmtBefore(&ret, incCall);
+  } else {
+    // remove argument from intrinsiccall MPL_CLEANUP_LOCALREFVARS (dread ref %Reg1_R5678, ...
+    const MapleVector<MeExpr*> *opnds = &cleanup->GetOpnds();
+    for (auto iter = opnds->begin(); iter != opnds->end(); ++iter) {
+      if (*iter == retVar || (!isAnalyzed && static_cast<VarMeExpr*>(*iter)->GetOst() == retVar->GetOst())) {
+        cleanup->EraseOpnds(iter);
+        cleanup->PushBackOpnd(retVar);  // pin it to end of std::vector
+        cleanup->SetIntrinsic(INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP);
+        MIRSymbol *sym = retVar->GetOst()->GetMIRSymbol();
+        if (sym->GetAttr(ATTR_localrefvar)) {
+          func.GetMirFunc()->InsertMIRSymbol(sym);
+        }
+        break;
+      }
+    }
+  }
+}
+
+void RCLowering::HandleReturnFormal(RetMeStmt &ret) {
+  BB *bb = ret.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb null ptr check");
+  auto *retVar = static_cast<VarMeExpr*>(ret.GetOpnd(0));
+  CHECK_FATAL(retVar != nullptr, "retVal null ptr check");
+  std::vector<MeExpr*> opnds = { retVar };
+  IntrinsiccallMeStmt *incRefStmt = CreateRCIntrinsic(INTRN_MCCIncRef, ret, opnds, true);
+  ret.SetOpnd(0, incRefStmt->GetMustDefList()->front().GetLHS());
+  IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(*bb);
+  if (cleanup == nullptr) {
+    bb->InsertMeStmtBefore(&ret, incRefStmt);
+  } else {
+    bb->InsertMeStmtAfter(cleanup, incRefStmt);
+  }
+}
+
+void RCLowering::HandleReturnIvar(RetMeStmt &ret) {
+  // insert calls
+  auto *retIvar = static_cast<IvarMeExpr*>(ret.GetOpnd(0));
+  if (retIvar->IsVolatile()) {
+    std::vector<MeExpr*> opnds = { &retIvar->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*retIvar) };
+    IntrinsiccallMeStmt *loadCall = CreateRCIntrinsic(PrepareVolatileCall(ret, INTRN_MCCLoadRefVol), ret, opnds, true);
+    ret.GetBB()->InsertMeStmtBefore(&ret, loadCall);
+    ret.SetOpnd(0, loadCall->GetMustDefList()->front().GetLHS());
+  } else {
+    if (MeOption::strictNaiveRC) {
+      RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref);
+      AssignMeStmt *regAssStmt = irMap.CreateAssignMeStmt(*curTmp, *retIvar, *ret.GetBB());
+      ret.GetBB()->InsertMeStmtBefore(&ret, regAssStmt);
+      std::vector<MeExpr*> opnds = { regAssStmt->GetLHS() };
+      IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, *regAssStmt, opnds, true);
+      ret.GetBB()->InsertMeStmtBefore(&ret, incCall);
+      ret.SetOpnd(0, curTmp);
+    } else {
+      std::vector<MeExpr*> opnds = { &retIvar->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*retIvar) };
+      IntrinsiccallMeStmt *loadCall = CreateRCIntrinsic(INTRN_MCCLoadRef, ret, opnds, true);
+      ret.GetBB()->InsertMeStmtBefore(&ret, loadCall);
+      ret.SetOpnd(0, loadCall->GetMustDefList()->front().GetLHS());
+    }
+  }
+}
+
+void RCLowering::HandleReturnReg(RetMeStmt &ret) {
+  // if the register with ref value is defined by callassigned or gcmalloc
+  // return incref should have been delegated and not needed.
+  auto *regRet = static_cast<RegMeExpr*>(ret.GetOpnd(0));
+  if (regRet->GetDefBy() == kDefByMustDef) {
+    return;
+  }
+  if (regRet->GetDefBy() == kDefByStmt && regRet->GetDefStmt()->GetOp() == OP_regassign) {
+    MeExpr *rhs = regRet->GetDefStmt()->GetRHS();
+    ASSERT_NOT_NULL(rhs);
+    if (rhs->GetOp() == OP_gcmalloc || rhs->GetOp() == OP_gcmallocjarray) {
+      return;
+    }
+  }
+  std::vector<MeExpr*> opnds = { regRet };
+  IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, ret, opnds, true);
+  ret.SetOpnd(0, incCall->GetMustDefList()->front().GetLHS());
+  ret.GetBB()->InsertMeStmtBefore(&ret, incCall);
+}
+
+void RCLowering::HandleReturnWithCleanup() {
+  for (auto *stmt : rets) {
+    auto *ret = static_cast<RetMeStmt*>(stmt);
+    IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(*ret->GetBB());
+    if (cleanup != nullptr && !tmpLocalRefVars.empty()) {  // new localrefvar introduced in this phase
+      for (auto tmpVar : tmpLocalRefVars) {
+        cleanup->PushBackOpnd(tmpVar);
+      }
+    }
+    if (ret->GetOpnds().empty()) {
+      continue;
+    }
+    MeExpr *retVal = ret->GetOpnd(0);
+    // handle nullptr return first
+    if (retVal->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(retVal)->IsZero()) {
+      continue;
+    }
+    if (retVal->GetMeOp() == kMeOpVar) {
+      HandleReturnVar(*ret);
+    } else if (retVal->GetMeOp() == kMeOpIvar) {
+      HandleReturnIvar(*ret);
+    } else if (retVal->GetMeOp() == kMeOpReg) {
+      HandleReturnReg(*ret);
+    } else {
+      // incref by default
+      RegMeExpr *tmpReg = irMap.CreateRegMeExpr(PTY_ref);
+      AssignMeStmt *temp = irMap.CreateAssignMeStmt(*tmpReg, *retVal, *stmt->GetBB());
+      stmt->GetBB()->InsertMeStmtBefore(stmt, temp);
+      std::vector<MeExpr*> opnds = { tmpReg };
+      IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, *stmt, opnds);
+      stmt->GetBB()->InsertMeStmtBefore(stmt, incCall);
+      ret->SetOpnd(0, tmpReg);
+    }
+  }
+}
+
+void RCLowering::HandleReturnNeedBackup() {
+  // any return value expression containing ivar has to be saved in a
+  // temp with the temp being returned
+  for (auto *stmt : rets) {
+    auto *ret = static_cast<RetMeStmt*>(stmt);
+    if (ret->NumMeStmtOpnds() == 0) {
+      continue;
+    }
+    MeExpr *retVal = ret->GetOpnd(0);
+    if (!retVal->HasIvar()) {
+      continue;
+    }
+    RegMeExpr *curTmp = irMap.CreateRegMeExpr(retVal->GetPrimType());
+    MeStmt *regAssign = irMap.CreateAssignMeStmt(*curTmp, *retVal, *ret->GetBB());
+    ret->GetBB()->InsertMeStmtBefore(ret, regAssign);
+    ret->SetOpnd(0, curTmp);
+  }
+}
+
+void RCLowering::HandleReturnStmt() {
+  bool returnRef = (func.GetMirFunc()->GetReturnType()->GetPrimType() == PTY_ref);
+  bool updateCleanup = !tmpLocalRefVars.empty();
+  if (returnRef || updateCleanup) {
+    HandleReturnWithCleanup();
+  } else {
+    HandleReturnNeedBackup();
+  }
+}
+
+void RCLowering::HandleArguments() {
+  // placementRC would have already addressed formals
+  if (func.GetHints() & kPlacementRCed) {
+    return;
+  }
+  // handle arguments, if the formal gets modified
+  // insert incref at entry and decref before all returns
+  MIRFunction *mirFunc = func.GetMirFunc();
+  BB *firstBB = func.GetCfg()->GetFirstBB();
+  CHECK_FATAL(firstBB, "firstBB is nullptr!");
+  MeStmt *firstMeStmt = to_ptr(firstBB->GetMeStmts().begin());
+  for (size_t i = (mirFunc->IsStatic() ? 0 : 1); i < mirFunc->GetFormalCount(); ++i) {
+    MIRSymbol *sym = mirFunc->GetFormal(i);
+    if (sym == nullptr || sym->IgnoreRC() || (!sym->IsGlobal() && assignedPtrSym.count(sym) == 0)) {
+      continue;
+    }
+    VarMeExpr *argVar = CreateVarMeExprFromSym(*sym);
+    CHECK_FATAL(argVar != nullptr, "null ptr check");
+    IntrinsiccallMeStmt *incCall = nullptr;
+    if (firstMeStmt != nullptr) {
+      std::vector<MeExpr*> opnds = { argVar };
+      incCall = CreateRCIntrinsic(INTRN_MCCIncRef, *firstMeStmt, opnds);
+      firstBB->InsertMeStmtBefore(firstMeStmt, incCall);
+    }
+    sym->SetLocalRefVar();
+    mirFunc->GetFormalDefVec()[i].formalAttrs.SetAttr(ATTR_localrefvar);
+
+    for (auto *stmt : rets) {
+      std::vector<MeExpr*> opnds = { argVar };
+      IntrinsiccallMeStmt *decRefCall = CreateRCIntrinsic(INTRN_MCCDecRef, *stmt, opnds);
+      stmt->GetBB()->InsertMeStmtBefore(stmt, decRefCall);
+    }
+  }
+}
+
+void RCLowering::PostRCLower() {
+  HandleArguments();
+  // handle ret stmts
+  HandleReturnStmt();
+  // compact RC
+  // to prevent valid_end from being called repeatedly, don't modify the definition of eIt
+  for (auto bIt = cfg->valid_begin(), eIt = cfg->valid_end(); bIt != eIt; ++bIt) {
+    CompactRC(**bIt);
+  }
+}
+
+void RCLowering::Finish() {
+  CheckRefs();
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "\n============== After RC LOWERING =============" << '\n';
+    func.Dump(false);
+  }
+}
+
+void RCLowering::CheckRefs() {
+  ParseCheckFlag();
+  if (checkRefFormal) {
+    CheckFormals();
+  }
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    if (checkRefAssign) {
+      CheckRefsInAssignStmt(*bb);
+    }
+    if (checkRefReturn) {
+      CheckRefReturn(*bb);
+    }
+  }
+}
+
+void RCLowering::ParseCheckFlag() {
+  if (MeOption::checkRefUsedInFuncs.find(func.GetName()) != MeOption::checkRefUsedInFuncs.end() ||
+      MeOption::checkRefUsedInFuncs.find("ALL") != MeOption::checkRefUsedInFuncs.end() ||
+      MeOption::checkRefUsedInFuncs.find("*") != MeOption::checkRefUsedInFuncs.end()) {
+    checkRefFormal = true;
+    checkRefAssign = true;
+    checkRefReturn = true;
+  } else {
+    if (MeOption::checkRefUsedInFuncs.find("FORMAL") != MeOption::checkRefUsedInFuncs.end()) {
+      checkRefFormal = true;
+    }
+    if (MeOption::checkRefUsedInFuncs.find("ASSIGN") != MeOption::checkRefUsedInFuncs.end()) {
+      checkRefAssign = true;
+    }
+    if (MeOption::checkRefUsedInFuncs.find("RETURN") != MeOption::checkRefUsedInFuncs.end()) {
+      checkRefReturn = true;
+    }
+  }
+}
+
+void RCLowering::CheckFormals() {
+  MIRFunction *mirFunc = func.GetMirFunc();
+  BB *firstBB = func.GetCfg()->GetFirstBB();
+  CHECK_FATAL(firstBB, "firstBB is nullptr!");
+  if (firstBB->IsMeStmtEmpty()) {
+    return;
+  }
+  for (size_t i = 0; i < mirFunc->GetFormalCount(); ++i) {
+    MIRSymbol *sym = mirFunc->GetFormal(i);
+    if (sym == nullptr) {
+      continue;
+    }
+    if (sym->IgnoreRC()) {
+      continue;
+    }
+    MeStmt &firstMeStmt = firstBB->GetMeStmts().front();
+    VarMeExpr *argVar = CreateVarMeExprFromSym(*sym);
+    std::vector<MeExpr*> exprs = { argVar, irMap.CreateIntConstMeExpr(++checkRCIndex, PTY_u32) };
+    IntrinsiccallMeStmt *checkCall = CreateRCIntrinsic(INTRN_MCCCheck, firstMeStmt, exprs);
+    firstBB->InsertMeStmtBefore(&firstMeStmt, checkCall);
+  }
+}
+
+void RCLowering::CheckRefsInAssignStmt(BB &bb) {
+  for (MeStmt &stmt : bb.GetMeStmts()) {
+    if (!stmt.IsAssign()) {
+      continue;
+    }
+    MeExpr *lhs = stmt.GetLHS();
+    CHECK_NULL_FATAL(lhs);
+    if (lhs->GetPrimType() != PTY_ref && lhs->GetPrimType() != PTY_ptr) {
+      continue;
+    }
+    std::vector<MeExpr*> opnds = { lhs, irMap.CreateIntConstMeExpr(++checkRCIndex, PTY_u32) };
+    IntrinsiccallMeStmt *checkCall = irMap.CreateIntrinsicCallMeStmt(INTRN_MCCCheck, opnds);
+    bb.InsertMeStmtAfter(&stmt, checkCall);
+  }
+}
+
+void RCLowering::CheckRefReturn(BB &bb) {
+  if (bb.GetKind() != kBBReturn) {
+    return;
+  }
+  MeStmt *lastMeStmt = to_ptr(bb.GetMeStmts().rbegin());
+  if (lastMeStmt == nullptr || lastMeStmt->GetOp() != OP_return || lastMeStmt->NumMeStmtOpnds() == 0) {
+    return;
+  }
+  MeExpr* ret = lastMeStmt->GetOpnd(0);
+  if (ret->GetPrimType() != PTY_ref && ret->GetPrimType() != PTY_ptr) {
+    return;
+  }
+  std::vector<MeExpr*> opnds = { ret };
+  IntrinsiccallMeStmt *checkCall = irMap.CreateIntrinsicCallMeStmt(INTRN_MCCCheck, opnds);
+  bb.InsertMeStmtBefore(lastMeStmt, checkCall);
+}
+
+static inline bool CheckIntrinsicID(MeStmt *stmt, MIRIntrinsicID id) {
+  if (!CheckOp(stmt, OP_intrinsiccall)) {
+    return false;
+  }
+  auto *intrinsicCall = static_cast<IntrinsiccallMeStmt*>(stmt);
+  return intrinsicCall->GetIntrinsic() == id;
+}
+
+static inline MeStmt *GetPrevMeStmt(const MeStmt &stmt) {
+  MeStmt *prevStmt = stmt.GetPrev();
+  while (CheckOp(prevStmt, OP_comment)) {
+    prevStmt = prevStmt->GetPrev();
+  }
+  return prevStmt;
+}
+
+static inline MeStmt *GetNextMeStmt(const MeStmt &stmt) {
+  MeStmt *nextStmt = stmt.GetPrev();
+  while (CheckOp(nextStmt, OP_comment)) {
+    nextStmt = nextStmt->GetNext();
+  }
+  return nextStmt;
+}
+
+// iterate over stmts and find back-to-back incref/decref
+// and merge them into one intrinsic if needed
+void RCLowering::CompactRC(BB &bb) {
+  for (auto &stmt : bb.GetMeStmts()) {
+    if (CheckIntrinsicID(&stmt, INTRN_MCCIncRef)) {
+      MeStmt *prevStmt = GetPrevMeStmt(stmt);
+      if (CheckIntrinsicID(prevStmt, INTRN_MCCDecRef)) {
+        CompactIncAndDec(stmt, *prevStmt);
+      }
+    }
+    if (CheckIntrinsicID(&stmt, INTRN_MCCDecRef)) {
+      MeStmt *prevStmt = GetPrevMeStmt(stmt);
+      if (CheckIntrinsicID(prevStmt, INTRN_MCCIncRef)) {
+        CompactIncAndDec(*prevStmt, stmt);
+      }
+    }
+    if ((func.GetHints() & kPlacementRCed) == 0) {
+      continue;
+    }
+    if (!CheckIntrinsicID(&stmt, INTRN_MCCDecRefReset)) {
+      continue;
+    }
+    MeStmt *prevStmt = GetPrevMeStmt(stmt);
+    if (CheckIntrinsicID(prevStmt, INTRN_MCCDecRefReset)) {
+      CompactAdjacentDecReset(*prevStmt, stmt);
+    }
+    if (CheckOp(prevStmt, OP_dassign)) {
+      ReplaceDecResetWithDec(*prevStmt, stmt);
+    }
+    if (CheckIntrinsicID(prevStmt, INTRN_MCCIncRef)) {
+      CompactIncAndDecReset(*prevStmt, stmt);
+    } else {
+      MeStmt *nextStmt = GetNextMeStmt(stmt);
+      if (CheckIntrinsicID(nextStmt, INTRN_MCCIncRef)) {
+        CompactIncAndDecReset(*nextStmt, stmt);
+      }
+    }
+  }
+}
+
+void RCLowering::CompactIncAndDec(MeStmt &incStmt, MeStmt &decStmt) {
+  BB *bb = incStmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb nullptr check");
+  MeExpr *incOpnd = incStmt.GetOpnd(0);
+  MeExpr *decOpnd = decStmt.GetOpnd(0);
+  if (incOpnd == decOpnd) {
+    bb->RemoveMeStmt(&incStmt);
+  } else {
+    std::vector<MeExpr*> opnds = { incOpnd, decOpnd };
+    IntrinsiccallMeStmt *incDecCall = CreateRCIntrinsic(INTRN_MCCIncDecRef, incStmt, opnds);
+    bb->ReplaceMeStmt(&incStmt, incDecCall);
+  }
+  bb->RemoveMeStmt(&decStmt);
+}
+
+void RCLowering::CompactIncAndDecReset(MeStmt &incStmt, MeStmt &resetStmt) {
+  BB *bb = incStmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb nullptr check");
+  MeExpr *incOpnd = incStmt.GetOpnd(0);
+  MeExpr *resetOpnd = resetStmt.GetOpnd(0);
+  if (incOpnd == resetOpnd) {
+    bb->RemoveMeStmt(&resetStmt);
+  } else {
+    std::vector<MeExpr*> opnds = { incOpnd, resetOpnd };
+    IntrinsiccallMeStmt *incDecReset = CreateRCIntrinsic(INTRN_MCCIncDecRefReset, resetStmt, opnds);
+    bb->ReplaceMeStmt(&resetStmt, incDecReset);
+  }
+  bb->RemoveMeStmt(&incStmt);
+}
+
+void RCLowering::ReplaceDecResetWithDec(MeStmt &prevStmt, MeStmt &stmt) {
+  auto *addrofMeExpr = static_cast<AddrofMeExpr*>(stmt.GetOpnd(0));
+  ASSERT_NOT_NULL(addrofMeExpr);
+  auto *dass = static_cast<DassignMeStmt*>(&prevStmt);
+  if (dass->GetRHS()->GetMeOp() != kMeOpReg || dass->GetVarLHS()->GetOstIdx() != addrofMeExpr->GetOstIdx()) {
+    return;
+  }
+  BB *bb = stmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb nullptr check");
+  std::vector<MeExpr*> opnds = { dass->GetRHS() };
+  IntrinsiccallMeStmt *decRefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
+  bb->ReplaceMeStmt(&stmt, decRefCall);
+  bb->RemoveMeStmt(&prevStmt);
+}
+
+void RCLowering::CompactAdjacentDecReset(MeStmt &prevStmt, MeStmt &stmt) {
+  MeExpr *prevOpnd = prevStmt.GetOpnd(0);
+  MeExpr *curOpnd = stmt.GetOpnd(0);
+  BB *bb = stmt.GetBB();
+  if (prevOpnd != curOpnd) {
+    std::vector<MeExpr*> opnds = { prevOpnd, curOpnd };
+    IntrinsiccallMeStmt *decRefCall = CreateRCIntrinsic(INTRN_MCCDecRefResetPair, stmt, opnds);
+    bb->ReplaceMeStmt(&stmt, decRefCall);
+  }
+  bb->RemoveMeStmt(&prevStmt);
+}
+
+OriginalSt *RCLowering::RetrieveOSt(const std::string &name, bool isLocalRefVar) const {
+  MIRSymbol *backupSym = mirModule.GetMIRBuilder()->GetOrCreateLocalDecl(
+      name, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_ptr)));  // use PTY_ptr for temp
+  backupSym->SetIsTmp(true);
+  if (isLocalRefVar) {
+    backupSym->SetLocalRefVar();
+  }
+  OriginalSt *ost = ssaTab.FindOrCreateSymbolOriginalSt(*backupSym, func.GetMirFunc()->GetPuidx(), 0);
+  return ost;
+}
+
+// function for creating short-lived temp
+VarMeExpr *RCLowering::CreateNewTmpVarMeExpr(bool isLocalRefVar) {
+  std::string name = std::string("__RCTemp__").append(std::to_string(++tmpCount));
+  OriginalSt *ost = RetrieveOSt(name, isLocalRefVar);
+  if (ost->GetZeroVersionIndex() == 0) {
+    ost->SetZeroVersionIndex(irMap.GetVerst2MeExprTable().size());
+    irMap.GetVerst2MeExprTable().push_back(nullptr);
+    ost->PushbackVersionsIndices(ost->GetZeroVersionIndex());
+  }
+  VarMeExpr *varMeExpr = irMap.CreateVarMeExprVersion(ost);
+  if (isLocalRefVar) {
+    tmpLocalRefVars.insert(varMeExpr);
+  }
+  return varMeExpr;
+}
+
+// Fast path: Special RC handling for simple methods
+// where local ref assignments can be ignored
+// functions with global write cannot use fast path
+void RCLowering::FastBBLower(BB &bb) {
+  MapleMap<uint32, MeStmt*> exceptionAllocsites(func.GetAlloc().Adapter());
+  for (auto &stmt : bb.GetMeStmts()) {
+    if (CheckOp(&stmt, OP_incref) || CheckOp(&stmt, OP_decref) ||
+        CheckIntrinsicID(&stmt, INTRN_MPL_CLEANUP_LOCALREFVARS)) {
+      // ignore RC operations inserted by analyzerc
+      bb.RemoveMeStmt(&stmt);
+    }else if (CheckOp(&stmt, OP_throw)) {
+      FastLowerThrowStmt(stmt, exceptionAllocsites);
+    }else if (CheckOp(&stmt, OP_return)) {
+      FastLowerRetStmt(stmt);
+    }else if (stmt.IsAssign()) {
+      MeExpr *lhs = stmt.GetLHSRef(false);
+      if (lhs == nullptr) {
+        continue;
+      }
+      if (lhs->GetMeOp() == kMeOpVar) {
+        FastLowerAssignToVar(stmt, exceptionAllocsites);
+      } else if (lhs->GetMeOp() == kMeOpIvar) {
+        FastLowerAssignToIvar(stmt);
+      }
+    }else if (kOpcodeInfo.IsCallAssigned(stmt.GetOp())) {
+      MIRType *retType = stmt.GetReturnType();
+      if (retType != nullptr && retType->GetPrimType() == PTY_ref) {
+        FastLowerCallAssignedStmt(stmt);
+      }
+    }
+  }
+
+  for (auto &iter : std::as_const(exceptionAllocsites)) {
+    MeStmt *stmt = iter.second;
+    AssignMeStmt *backup = irMap.CreateAssignMeStmt(*CreateNewTmpVarMeExpr(true), *stmt->GetLHS(), *stmt->GetBB());
+    stmt->GetBB()->InsertMeStmtAfter(stmt, backup);
+  }
+}
+
+void RCLowering::FastLowerThrowStmt(MeStmt &stmt, MapleMap<uint32, MeStmt*> &exceptionAllocsites) {
+  auto &throwMeStmt = static_cast<ThrowMeStmt&>(stmt);
+  // insert localrefvar for decref on throw arg
+  MeExpr *throwVal = throwMeStmt.GetOpnd();
+  BB *bb = stmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb nullptr check");
+  AssignMeStmt *backup = irMap.CreateAssignMeStmt(*CreateNewTmpVarMeExpr(true), *throwVal, *bb);
+  bb->InsertMeStmtBefore(&throwMeStmt, backup);
+  if (throwVal->GetMeOp() == kMeOpVar) {
+    auto *var = static_cast<VarMeExpr*>(throwVal);
+    auto iter = exceptionAllocsites.find(var->GetVstIdx());
+    if (iter != exceptionAllocsites.cend()) {
+      exceptionAllocsites.erase(iter);
+    }
+  }
+}
+
+void RCLowering::FastLowerRetStmt(MeStmt &stmt) {
+  auto &retMeStmt = static_cast<RetMeStmt&>(stmt);
+  const MapleVector<MeExpr*> &opnds = retMeStmt.GetOpnds();
+  if (opnds.empty()) {
+    // function return void
+    return;
+  }
+  MeExpr *ret = opnds[0];
+  PrimType retPtyp = ret->GetPrimType();
+  if (retPtyp != PTY_ref) {
+    return;
+  }
+  if (ret->GetMeOp() == kMeOpVar) {
+    FastLowerRetVar(retMeStmt);
+  } else if (ret->GetMeOp() == kMeOpReg) {
+    FastLowerRetReg(retMeStmt);
+  } else {
+    // ret->GetMeOp() == kMeOpIvar etc
+    // return ivar, put into temp and IncRef
+    FastLowerRetIvar(retMeStmt);
+  }
+}
+
+void RCLowering::FastLowerRetVar(RetMeStmt &stmt) {
+  auto *val = static_cast<VarMeExpr*>(stmt.GetOpnd(0));
+  const MIRSymbol *sym = val->GetOst()->GetMIRSymbol();
+  if (val->GetDefBy() == kDefByStmt && CheckOp(val->GetDefStmt(), OP_dassign)) {
+    // gcmalloc already has incref
+    ASSERT_NOT_NULL(val->GetDefStmt()->GetRHS());
+    Opcode op = val->GetDefStmt()->GetRHS()->GetOp();
+    if (op == OP_gcmalloc || op == OP_gcmallocjarray) {
+      return;
+    }
+  }
+  if (sym != nullptr && !sym->IgnoreRC()) {
+    std::vector<MeExpr*> opnds = { val };
+    IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, opnds, true);
+    stmt.SetOpnd(0, incCall->GetMustDefList()->front().GetLHS());
+    stmt.GetBB()->InsertMeStmtBefore(&stmt, incCall);
+  }
+}
+
+void RCLowering::FastLowerRetIvar(RetMeStmt &stmt) {
+  BB *bb = stmt.GetBB();
+  CHECK_NULL_FATAL(bb);
+  AssignMeStmt *tmpRet = irMap.CreateAssignMeStmt(*irMap.CreateRegMeExpr(PTY_ref), *stmt.GetOpnd(0), *bb);
+  bb->InsertMeStmtBefore(&stmt, tmpRet);
+  std::vector<MeExpr*> opnds = { tmpRet->GetLHS() };
+  IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, opnds);
+  bb->InsertMeStmtBefore(&stmt, incCall);
+  stmt.SetOpnd(0, tmpRet->GetLHS());
+}
+
+void RCLowering::FastLowerRetReg(RetMeStmt &stmt) {
+  auto *regRet = static_cast<RegMeExpr*>(stmt.GetOpnd(0));
+  if (regRet->GetDefBy() == kDefByStmt && CheckOp(regRet->GetDefStmt(), OP_regassign)) {
+    MeExpr *rhs = regRet->GetDefStmt()->GetRHS();
+    ASSERT_NOT_NULL(rhs);
+    if (rhs->GetOp() == OP_gcmalloc || rhs->GetOp() == OP_gcmallocjarray) {
+      return;
+    }
+  }
+  std::vector<MeExpr*> opnds = { regRet };
+  IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, opnds);
+  stmt.GetBB()->InsertMeStmtBefore(&stmt, incCall);
+}
+
+void RCLowering::FastLowerAssignToVar(MeStmt &stmt, MapleMap<uint32, MeStmt*> &exceptionAllocsites) {
+  ScalarMeExpr *lhs = stmt.GetVarLHS();
+  ASSERT_NOT_NULL(lhs);
+  if (stmt.NeedIncref() || stmt.NeedDecref()) {
+    const MIRSymbol *lSym = lhs->GetOst()->GetMIRSymbol();
+    if (lSym->IgnoreRC()) {
+      return;
+    }
+    ASSERT(!lSym->IsGlobal(), "Write to global not expected");
+  }
+  if (stmt.GetOp() != OP_dassign) {
+    return;
+  }
+  ASSERT_NOT_NULL(stmt.GetRHS());
+  if (!(stmt.GetRHS()->IsGcmalloc())) {
+    return;
+  }
+  auto *rhs = static_cast<GcmallocMeExpr*>(stmt.GetRHS());
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(rhs->GetTyIdx());
+  Klass *klass = klassHierarchy.GetKlassFromStrIdx(type->GetNameStrIdx());
+  CHECK_FATAL(klass != nullptr, "null ptr check");
+  if (klass->IsExceptionKlass()) {
+    exceptionAllocsites[lhs->GetVstIdx()] = &stmt;
+  } else {
+    // add a localrefvar temp to compensate incref with new object
+    BB *bb = stmt.GetBB();
+    CHECK_FATAL(bb != nullptr, "bb nullptr check");
+    AssignMeStmt *backup = irMap.CreateAssignMeStmt(*CreateNewTmpVarMeExpr(true), *lhs, *bb);
+    bb->InsertMeStmtAfter(&stmt, backup);
+  }
+}
+
+void RCLowering::FastLowerAssignToIvar(MeStmt &stmt) {
+  // only handle lhs
+  MeExpr *rhs = stmt.GetRHS();
+  ASSERT_NOT_NULL(rhs);
+  bool incWithLHS = stmt.NeedIncref();
+  bool decWithLHS = stmt.NeedDecref();
+  if (!incWithLHS && (rhs->GetOp() == OP_regread)) {
+    // check for regread
+    auto *rhsVar = static_cast<RegMeExpr*>(rhs);
+    if (rhsVar->GetDefBy() == kDefByStmt) {
+      incWithLHS = rhsVar->GetDefStmt()->NeedIncref();
+    } else {
+      // callassign is fine as IncRef has been done inside call, just skip
+      ASSERT(rhsVar->GetDefBy() == kDefByMustDef, "not supported yet");
+    }
+  }
+  if (!incWithLHS && !decWithLHS) {
+    return;
+  }
+  HandleAssignMeStmtRHS(stmt);
+  rhs = stmt.GetRHS();
+  IvarMeExpr *lhs = (static_cast<IassignMeStmt&>(stmt)).GetLHSVal();
+  BB *bb = stmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb nullptr check");
+  if (lhs->IsVolatile()) {
+    CheckRemove(stmt.GetPrev(), OP_membarrelease);
+    CheckRemove(stmt.GetNext(), OP_membarstoreload);
+  }
+  std::vector<MeExpr*> opnds = { &lhs->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*lhs), rhs };
+  IntrinsiccallMeStmt *writeRefCall = CreateRCIntrinsic(SelectWriteBarrier(stmt), stmt, opnds);
+  bb->ReplaceMeStmt(&stmt, writeRefCall);
+  CheckArrayStore(*writeRefCall);
+}
+
+void RCLowering::FastLowerCallAssignedStmt(MeStmt &stmt) {
+  MapleVector<MustDefMeNode> *mustDefs = stmt.GetMustDefList();
+  ASSERT_NOT_NULL(mustDefs);
+
+  BB *bb = stmt.GetBB();
+  CHECK_FATAL(bb != nullptr, "bb null ptr check");
+  if (mustDefs->empty()) {
+    // introduce a ret and decref on it
+    RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref);
+    ASSERT_NOT_NULL(stmt.GetMustDefList());
+    stmt.GetMustDefList()->push_back(MustDefMeNode(curTmp, &stmt));
+    std::vector<MeExpr*> opnds = { curTmp };
+    IntrinsiccallMeStmt *decRefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
+    bb->InsertMeStmtAfter(&stmt, decRefCall);
+  } else {
+    CHECK_FATAL(mustDefs->size() == 1, "return val count check");
+    MeExpr *lhs = mustDefs->front().GetLHS();
+    if (lhs->GetMeOp() != kMeOpVar) {
+      return;
+    }
+    const OriginalSt *ost = static_cast<VarMeExpr*>(lhs)->GetOst();
+    if (!ost->IsSymbolOst()) {
+      return;
+    }
+    const MIRSymbol *retSym = ost->GetMIRSymbol();
+    // if retSym is null, that means we do not need decref
+    // to offset the incref before function return, just break
+    if (retSym == nullptr || retSym->IgnoreRC()) {
+      return;
+    }
+    // insert localrefvar for decref on ret
+    AssignMeStmt *backup = irMap.CreateAssignMeStmt(*CreateNewTmpVarMeExpr(true), *lhs, *bb);
+    bb->InsertMeStmtAfter(&stmt, backup);
+  }
+}
+
+bool MERCLowering::PhaseRun(maple::MeFunction &f) {
+  MaplePhase *it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MKlassHierarchy, MIRModule>(f.GetMIRModule());
+  auto *kh = static_cast<M2MKlassHierarchy *>(it)->GetResult();
+  ASSERT_NOT_NULL(kh);
+  CHECK_FATAL(GET_ANALYSIS(MEIRMapBuild, f) != nullptr, "hssamap has problem");
+  CHECK_FATAL(f.GetMeSSATab() != nullptr, "ssatab has problem");
+  RCLowering rcLowering(f, *kh, DEBUGFUNC_NEWPM(f));
+  rcLowering.Prepare();
+  if (!rcLowering.GetIsAnalyzed()) {
+    auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+    CHECK_FATAL(dom != nullptr, "dominance phase has problem");
+    rcLowering.SetDominance(*dom);
+  }
+  MIRFunction *mirFunction = f.GetMirFunc();
+  MeCFG *cfg = f.GetCfg();
+  if (whiteListFunc.find(mirFunction->GetName()) != whiteListFunc.end() ||
+      mirFunction->GetAttr(FUNCATTR_rclocalunowned)) {
+    auto eIt = cfg->valid_end();
+    for (auto bIt = cfg->valid_begin(); bIt != eIt; ++bIt) {
+      auto *bb = *bIt;
+      rcLowering.FastBBLower(*bb);
+    }
+    rcLowering.Finish();
+    return true;
+  }
+  rcLowering.PreRCLower();
+  rcLowering.RCLower();
+  // handle all the extra RC work
+  rcLowering.PostRCLower();
+  rcLowering.Finish();
+  return true;
+}
+
+void MERCLowering::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_rename2preg.cpp b/src/mapleall/maple_me/src/me_rename2preg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..36c9c688c21703a0d6e858c175e79d0ac8d91636
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_rename2preg.cpp
@@ -0,0 +1,560 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_rename2preg.h"
+#include "mir_builder.h"
+#include "me_irmap_build.h"
+#include "me_option.h"
+#include "me_ssa_update.h"
+
+// This phase mainly renames the variables to pseudo register.
+// Only non-ref-type variables (including parameters) with no alias are
+// workd on here.  Remaining variables are left to LPRE phase.  This is
+// because for ref-type variables, their stores have to be left intact.
+
+namespace maple {
+bool SSARename2Preg::VarMeExprIsRenameCandidate(const VarMeExpr &varMeExpr) const {
+  if (rename2pregCount >= MeOption::rename2pregLimit) {
+    return false;
+  }
+  const OriginalSt *ost = varMeExpr.GetOst();
+  if (ost->GetIndirectLev() != 0) {
+    return false;
+  }
+  const MIRSymbol *mirst = ost->GetMIRSymbol();
+  if (mirst->GetAttr(ATTR_localrefvar) || ost->HasOneElemSimdAttr() || (mirst->GetAsmAttr() != 0)) {
+    return false;
+  }
+  auto primType = varMeExpr.GetPrimType();
+  if (!IsPrimitiveScalar(primType)) {
+    return false;
+  }
+  if (ost->IsFormal() && primType == PTY_ref) {
+    return false;
+  }
+  if (ost->IsVolatile() || ost->IsAddressTaken() ||
+      !aliasclass->OstAnalyzed(ost->GetIndex())) {
+    return false;
+  }
+  if (!mirst->IsLocal() || mirst->GetStorageClass() == kScPstatic || mirst->GetStorageClass() == kScFstatic) {
+    return false;
+  }
+  // local primitive-type symbol with no address taken can be renamed to preg
+  if (ost->GetFieldID() == 0 && ost->GetOffset().val == 0 && ost->GetTyIdx() == ost->GetMIRSymbol()->GetTyIdx()) {
+    return true;
+  }
+  // following check may be time-consuming, keep it as the last check.
+  // var can be renamed to preg if ost of var:
+  // 1. not used by MU or defined by CHI;
+  // 2. aliased-ost of ost is not used anywhere (by MU or dread).
+  //    If defining of aliased-ost defines ost as well.
+  //    There must be a CHI defines ost, and this condition is included in the prev condition.
+  //    Therefore, condition 2 not includes defined-by-CHI.
+  auto *aliasSet = GetAliasSet(ost);
+  if (aliasSet == nullptr) {
+    return true;
+  }
+  for (auto aliasedOstIdx : *aliasSet) {
+    auto aliasedOst = ssaTab->GetOriginalStFromID(OStIdx(aliasedOstIdx));
+    if (aliasedOst == ost) {
+      continue;
+    }
+    // If an ost aliases with a formal, it is defined at entry by the formal.
+    // Cannot rename the ost to preg.
+    if (aliasedOst->IsFormal()) {
+      return false;
+    }
+    bool aliasedOstUsed = ostUsedByDread[aliasedOst->GetIndex()] || ostDefedByDassign[aliasedOst->GetIndex()];
+    if (aliasedOstUsed && AliasClass::MayAliasBasicAA(ost, aliasedOst)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+RegMeExpr *SSARename2Preg::CreatePregForVar(const VarMeExpr *varMeExpr) {
+  auto primType = varMeExpr->GetPrimType();
+  RegMeExpr *curtemp = nullptr;
+  if (primType != PTY_ref) {
+    curtemp = meirmap->CreateRegMeExpr(primType);
+  } else {
+    curtemp = meirmap->CreateRegMeExpr(*varMeExpr->GetType());
+  }
+  OriginalSt *pregOst = curtemp->GetOst();
+  if (varMeExpr->IsZeroVersion()) {
+    pregOst->SetZeroVersionIndex(curtemp->GetVstIdx());
+  }
+  const OriginalSt *ost = varMeExpr->GetOst();
+  pregOst->SetIsFormal(ost->IsFormal());
+  sym2reg_map[ost->GetIndex()] = pregOst;
+  (void)vstidx2reg_map.emplace(std::make_pair(varMeExpr->GetExprID(), curtemp));
+  // set fields in MIRPreg to support rematerialization
+  MIRPreg *preg = pregOst->GetMIRPreg();
+  preg->SetOp(OP_dread);
+  preg->rematInfo.sym = ost->GetMIRSymbol();
+  preg->fieldID = ost->GetFieldID();
+  if (ost->IsFormal()) {
+    const MIRSymbol *mirst = ost->GetMIRSymbol();
+    uint32 parmindex = func->GetMirFunc()->GetFormalIndex(mirst);
+    CHECK_FATAL(parm_used_vec[parmindex], "parm_used_vec not set correctly");
+    if (!reg_formal_vec[parmindex]) {
+      reg_formal_vec[parmindex] = curtemp;
+    }
+  }
+  ++rename2pregCount;
+  if (DEBUGFUNC(func)) {
+    ost->Dump();
+    LogInfo::MapleLogger() << "(ost idx " << ost->GetIndex() << ") renamed to ";
+    pregOst->Dump();
+    LogInfo::MapleLogger() << " (count: " << rename2pregCount << ")" << std::endl;
+  }
+  return curtemp;
+}
+
+// For VarMeExpr that can be renamed to PregMeExpr, ChiNode is redundant.
+// To construct correct SSA for PregMeExpr, ChiNodes should be bypassed.
+static const VarMeExpr *GetSrcOfRenameableVarMeExpr(const VarMeExpr &varMeExpr) {
+  auto *srcVar = &varMeExpr;
+  while (srcVar->IsDefByChi()) {
+    auto &chiNode = srcVar->GetDefChi();
+    auto *rhs = chiNode.GetRHS();
+    CHECK_FATAL(rhs != nullptr, "null ptr check");
+    CHECK_FATAL(rhs->GetMeOp() == kMeOpVar, "rhs must be VarMeExpr");
+    srcVar = static_cast<const VarMeExpr*>(rhs);
+    (void) chiNode.GetBase()->GetChiList()->erase(varMeExpr.GetOstIdx());
+  }
+  return srcVar;
+}
+
+RegMeExpr *SSARename2Preg::RenameVar(const VarMeExpr *varMeExpr) {
+  CHECK_FATAL(varMeExpr != nullptr, "null ptr check");
+  if (!VarMeExprIsRenameCandidate(*varMeExpr)) {
+    return nullptr;
+  }
+
+  varMeExpr = GetSrcOfRenameableVarMeExpr(*varMeExpr);
+  auto var2regIt = vstidx2reg_map.find(varMeExpr->GetExprID());
+  if (var2regIt != vstidx2reg_map.end()) {
+    // return the RegMeExpr has been created for VarMeExpr
+    return var2regIt->second;
+  }
+
+  auto *ost = varMeExpr->GetOst();
+  CHECK_FATAL(ost != nullptr, "null ptr check");
+  auto varOst2RegOstIt = sym2reg_map.find(ost->GetIndex());
+  RegMeExpr *regForVarMeExpr = nullptr;
+  if (varOst2RegOstIt == sym2reg_map.end()) {
+    regForVarMeExpr = CreatePregForVar(varMeExpr);
+  } else {
+    OriginalSt *pregOst = varOst2RegOstIt->second;
+    CHECK_FATAL(pregOst != nullptr, "null ptr check");
+    regForVarMeExpr = meirmap->CreateRegMeExprVersion(*pregOst);
+    (void)vstidx2reg_map.emplace(std::make_pair(varMeExpr->GetExprID(), regForVarMeExpr));
+  }
+  return regForVarMeExpr;
+}
+
+void SSARename2Preg::Rename2PregCallReturn(MapleVector<MustDefMeNode> &mustdeflist) {
+  MapleVector<MustDefMeNode>::iterator it = mustdeflist.begin();
+  for (; it != mustdeflist.end(); ++it) {
+    MustDefMeNode &mustdefmenode = *it;
+    MeExpr *melhs = mustdefmenode.GetLHS();
+    if (melhs->GetMeOp() != kMeOpVar) {
+      return;
+    }
+    VarMeExpr *lhs = static_cast<VarMeExpr *>(melhs);
+    SetupParmUsed(lhs);
+
+    RegMeExpr *varreg = RenameVar(lhs);
+    if (varreg != nullptr) {
+      mustdefmenode.UpdateLHS(*varreg);
+    }
+  }
+}
+
+RegMeExpr *SSARename2Preg::FindOrCreatePregForVarPhiOpnd(const VarMeExpr *varMeExpr) {
+  varMeExpr = GetSrcOfRenameableVarMeExpr(*varMeExpr);
+  auto varOst2RegOstIt = sym2reg_map.find(varMeExpr->GetOstIdx());
+  CHECK_FATAL(varOst2RegOstIt != sym2reg_map.end(), "PregOst must have been created for phi");
+
+  auto var2regIt = vstidx2reg_map.find(varMeExpr->GetExprID());
+  if (var2regIt != vstidx2reg_map.end()) {
+    return var2regIt->second;
+  }
+
+  OriginalSt *pregOst = varOst2RegOstIt->second;
+  CHECK_FATAL(pregOst != nullptr, "null ptr check");
+  RegMeExpr *regForVarMeExpr = meirmap->CreateRegMeExprVersion(*pregOst);
+  (void)vstidx2reg_map.emplace(std::make_pair(varMeExpr->GetExprID(), regForVarMeExpr));
+  return regForVarMeExpr;
+}
+
+// update regphinode operands
+void SSARename2Preg::UpdateRegPhi(MePhiNode *mevarphinode, MePhiNode *regphinode,
+                                  const VarMeExpr *lhs) {
+  // update phi's opnds
+  for (uint32 i = 0; i < mevarphinode->GetOpnds().size(); i++) {
+    auto *opndexpr = mevarphinode->GetOpnds()[i];
+    ASSERT(opndexpr->GetOst()->GetIndex() == lhs->GetOst()->GetIndex(), "phi is not correct");
+    CHECK_FATAL(opndexpr->GetMeOp() == kMeOpVar, "opnd of Var-PhiNode must be VarMeExpr");
+    RegMeExpr *opndtemp = FindOrCreatePregForVarPhiOpnd(static_cast<VarMeExpr*>(opndexpr));
+    regphinode->GetOpnds().push_back(opndtemp);
+  }
+  (void)lhs;
+}
+
+bool SSARename2Preg::Rename2PregPhi(MePhiNode *mevarphinode, MapleMap<OStIdx, MePhiNode *> &regPhiList) {
+  VarMeExpr *lhs = static_cast<VarMeExpr*>(mevarphinode->GetLHS());
+  SetupParmUsed(lhs);
+  RegMeExpr *lhsreg = RenameVar(lhs);
+  if (lhsreg == nullptr) {
+    return false;
+  }
+  MePhiNode *regphinode = meirmap->CreateMePhi(*lhsreg);
+  regphinode->SetDefBB(mevarphinode->GetDefBB());
+  UpdateRegPhi(mevarphinode, regphinode, lhs);
+  regphinode->SetIsLive(mevarphinode->GetIsLive());
+  mevarphinode->SetIsLive(false);
+
+  (void) regPhiList.insert(std::make_pair(lhsreg->GetOst()->GetIndex(), regphinode));
+  return true;
+}
+
+void SSARename2Preg::Rename2PregLeafRHS(MeStmt *mestmt, const VarMeExpr *varmeexpr) {
+  SetupParmUsed(varmeexpr);
+  MeExpr *varreg = RenameVar(varmeexpr);
+  if (varreg != nullptr) {
+    if (varreg->GetPrimType() != varmeexpr->GetPrimType()) {
+      varreg = meirmap->CreateMeExprTypeCvt(varmeexpr->GetPrimType(), varreg->GetPrimType(), *varreg);
+    } else if (static_cast<ScalarMeExpr*>(varreg)->IsZeroVersion() && GetPrimTypeSize(varreg->GetPrimType()) < 4) {
+      // if reading garbage, need to truncate the garbage value
+      Opcode extOp = IsSignedInteger(varreg->GetPrimType()) ? OP_sext : OP_zext;
+      varreg = meirmap->CreateMeExprUnary(extOp, GetRegPrimType(varreg->GetPrimType()), *varreg);
+      static_cast<OpMeExpr *>(varreg)->SetBitsSize(GetPrimTypeSize(varmeexpr->GetPrimType()) * 8);
+    }
+    (void)meirmap->ReplaceMeExprStmt(*mestmt, *varmeexpr, *varreg);
+  }
+}
+
+void SSARename2Preg::Rename2PregLeafLHS(MeStmt *mestmt, const VarMeExpr *varmeexpr) {
+  SetupParmUsed(varmeexpr);
+  RegMeExpr *varreg = RenameVar(varmeexpr);
+  if (varreg == nullptr) {
+    return;
+  }
+  Opcode desop = mestmt->GetOp();
+  CHECK_FATAL(desop == OP_dassign || desop == OP_maydassign, "NYI");
+  MeExpr *oldrhs = (desop == OP_dassign) ? (static_cast<DassignMeStmt *>(mestmt)->GetRHS())
+                                         : (static_cast<MaydassignMeStmt *>(mestmt)->GetRHS());
+  TyIdx lhsTyIdx = varmeexpr->GetOst()->GetTyIdx();
+  MIRType *lhsTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx);
+  if (lhsTy->GetKind() == kTypeBitField) {
+    MIRBitFieldType *bitfieldTy = static_cast<MIRBitFieldType *>(lhsTy);
+    if (GetPrimTypeBitSize(oldrhs->GetPrimType()) > bitfieldTy->GetFieldSize()) {
+      Opcode extOp = IsSignedInteger(lhsTy->GetPrimType()) ? OP_sext : OP_zext;
+      PrimType newPrimType = PTY_u32;
+      if (bitfieldTy->GetFieldSize() <= 32) {
+        newPrimType = IsSignedInteger(lhsTy->GetPrimType()) ? PTY_i32 : PTY_u32;
+      } else {
+        newPrimType = IsSignedInteger(lhsTy->GetPrimType()) ? PTY_i64 : PTY_u64;
+      }
+      OpMeExpr opmeexpr(-1, extOp, newPrimType, 1);
+      opmeexpr.SetBitsSize(bitfieldTy->GetFieldSize());
+      opmeexpr.SetOpnd(0, oldrhs);
+      auto *simplifiedExpr = meirmap->SimplifyOpMeExpr(&opmeexpr);
+      oldrhs = simplifiedExpr != nullptr ? simplifiedExpr : meirmap->HashMeExpr(opmeexpr);
+    }
+  } else if (GetPrimTypeSize(oldrhs->GetPrimType()) > GetPrimTypeSize(varreg->GetPrimType())) {
+    // insert integer truncation
+    if (GetPrimTypeSize(varreg->GetPrimType()) >= 4) {
+      oldrhs = meirmap->CreateMeExprTypeCvt(varreg->GetPrimType(), oldrhs->GetPrimType(), *oldrhs);
+    } else {
+      Opcode extOp = IsSignedInteger(varreg->GetPrimType()) ? OP_sext : OP_zext;
+      PrimType newPrimType = IsSignedInteger(varreg->GetPrimType()) ? PTY_i32 : PTY_u32;
+      OpMeExpr opmeexpr(-1, extOp, newPrimType, 1);
+      opmeexpr.SetBitsSize(static_cast<uint8>(GetPrimTypeSize(varreg->GetPrimType()) * 8));
+      opmeexpr.SetOpnd(0, oldrhs);
+      oldrhs = meirmap->HashMeExpr(opmeexpr);
+    }
+  }
+  auto *regssmestmt = meirmap->New<AssignMeStmt>(OP_regassign, varreg, oldrhs);
+  varreg->SetDefByStmt(*regssmestmt);
+  varreg->SetDefBy(kDefByStmt);
+  regssmestmt->CopyBase(*mestmt);
+  mestmt->GetBB()->ReplaceMeStmt(mestmt, regssmestmt);
+  mestmt->SetIsLive(false);
+  if (ostDefedByChi[varmeexpr->GetOstIdx()]) {
+    MeSSAUpdate::InsertOstToSSACands(varreg->GetOstIdx(), *mestmt->GetBB(), &candsForSSAUpdate);
+  }
+  meirmap->SimplifyAssign(regssmestmt);
+}
+
+void SSARename2Preg::SetupParmUsed(const VarMeExpr *varmeexpr) {
+  const OriginalSt *ost = varmeexpr->GetOst();
+  if (ost->IsFormal() && ost->IsSymbolOst()) {
+    const MIRSymbol *mirst = ost->GetMIRSymbol();
+    uint32 index = func->GetMirFunc()->GetFormalIndex(mirst);
+    parm_used_vec[index] = true;
+  }
+}
+
+// only handle the leaf of load, because all other expressions has been done by previous SSAPre
+void SSARename2Preg::Rename2PregExpr(MeStmt *mestmt, MeExpr *meexpr) {
+  MeExprOp meOp = meexpr->GetMeOp();
+  switch (meOp) {
+    case kMeOpIvar:
+    case kMeOpOp:
+    case kMeOpNary: {
+      for (uint32 i = 0; i < meexpr->GetNumOpnds(); ++i) {
+        Rename2PregExpr(mestmt, meexpr->GetOpnd(i));
+      }
+      break;
+    }
+    case kMeOpVar:
+      Rename2PregLeafRHS(mestmt, static_cast<VarMeExpr *>(meexpr));
+      break;
+    case kMeOpAddrof: {
+      AddrofMeExpr *addrofx = static_cast<AddrofMeExpr *>(meexpr);
+      const OriginalSt *ost = addrofx->GetOst();
+      if (ost->IsFormal()) {
+        const MIRSymbol *mirst = ost->GetMIRSymbol();
+        uint32 index = func->GetMirFunc()->GetFormalIndex(mirst);
+        parm_used_vec[index] = true;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return;
+}
+
+void SSARename2Preg::Rename2PregStmt(MeStmt *stmt) {
+  for (uint32 i = 0; i < stmt->NumMeStmtOpnds(); ++i) {
+    Rename2PregExpr(stmt, stmt->GetOpnd(i));
+  }
+
+  MapleVector<MustDefMeNode> *mustdeflist = stmt->GetMustDefList();
+  if (mustdeflist != nullptr) {
+    Rename2PregCallReturn(*mustdeflist);
+  }
+
+  auto *chiList = stmt->GetChiList();
+  if (chiList != nullptr && !chiList->empty()) {
+    auto chiListIt = chiList->begin();
+    while (chiListIt != chiList->end()) {
+      auto *lhs = chiListIt->second->GetLHS();
+      if (lhs->GetMeOp() == kMeOpVar &&
+          VarMeExprIsRenameCandidate(*static_cast<VarMeExpr*>(lhs))) {
+        chiListIt = chiList->erase(chiListIt);
+        continue;
+      }
+      ++chiListIt;
+    }
+  }
+
+  auto *muList = stmt->GetMuList();
+  if (muList != nullptr && !muList->empty()) {
+    auto muListIt = muList->begin();
+    while (muListIt != muList->end()) {
+      auto *mayUsedVar = muListIt->second;
+      if (mayUsedVar->GetMeOp() == kMeOpVar &&
+          VarMeExprIsRenameCandidate(*static_cast<VarMeExpr*>(mayUsedVar))) {
+        muListIt = muList->erase(muListIt);
+        continue;
+      }
+      ++muListIt;
+    }
+  }
+
+  Opcode op = stmt->GetOp();
+  if (op == OP_dassign || op == OP_maydassign) {
+    CHECK_FATAL(stmt->GetRHS() && stmt->GetVarLHS(), "null ptr check");
+    Rename2PregLeafLHS(stmt, static_cast<VarMeExpr *>(stmt->GetVarLHS()));
+  }
+}
+
+void SSARename2Preg::UpdateMirFunctionFormal() {
+  MIRFunction *mirFunc = func->GetMirFunc();
+  const MIRBuilder *mirbuilder = mirModule->GetMIRBuilder();
+  for (uint32 i = 0; i < mirFunc->GetFormalDefVec().size(); i++) {
+    if (!parm_used_vec[i]) {
+      // in this case, the paramter is not used by any statement, promote it
+      MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirFunc->GetFormalDefVec()[i].formalTyIdx);
+      if (mirType->GetPrimType() != PTY_agg) {
+        PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(
+            mirType->GetPrimType(), mirType->GetPrimType() == PTY_ref ? mirType : nullptr);
+        mirFunc->GetFormalDefVec()[i].formalSym =
+            mirbuilder->CreatePregFormalSymbol(mirType->GetTypeIndex(), regIdx, *mirFunc);
+      }
+    } else {
+      RegMeExpr *regformal = reg_formal_vec[i];
+      if (regformal) {
+        PregIdx regIdx = regformal->GetRegIdx();
+        MIRSymbol *oldformalst = mirFunc->GetFormalDefVec()[i].formalSym;
+        MIRSymbol *newformalst = mirbuilder->CreatePregFormalSymbol(oldformalst->GetTyIdx(), regIdx, *mirFunc);
+        mirFunc->GetFormalDefVec()[i].formalSym = newformalst;
+      }
+    }
+  }
+}
+
+void SSARename2Preg::CollectUsedOst(const MeExpr *meExpr) {
+  if (meExpr->GetMeOp() == kMeOpVar) {
+    auto ostIdx = static_cast<const ScalarMeExpr*>(meExpr)->GetOstIdx();
+    ostUsedByDread[ostIdx] = true;
+  } else if (meExpr->GetMeOp() == kMeOpAddrof) {
+    auto *ost = static_cast<const AddrofMeExpr *>(meExpr)->GetOst();
+    ost->SetAddressTaken(true);
+    auto *siblingOsts = ssaTab->GetNextLevelOsts(ost->GetPointerVstIdx());
+    if (siblingOsts != nullptr) {
+      for (auto *siblingOst : *siblingOsts) {
+        siblingOst->SetAddressTaken(true);
+      }
+    }
+  }
+
+  for (uint32 id = 0; id < meExpr->GetNumOpnds(); ++id) {
+    CollectUsedOst(meExpr->GetOpnd(id));
+  }
+}
+
+void SSARename2Preg::CollectDefUseInfoOfOst() {
+  // reset address taken attr of all symbol
+  for (auto *ost : func->GetMeSSATab()->GetOriginalStTable().GetOriginalStVector()) {
+    if (ost == nullptr) {
+      continue;
+    }
+    if (ost->GetIndirectLev() > 0) {
+      continue;
+    }
+    ost->SetAddressTaken(false);
+  }
+
+  for (BB *meBB : func->GetCfg()->GetAllBBs()) {
+    if (meBB == nullptr) {
+      continue;
+    }
+    for (MeStmt &stmt: meBB->GetMeStmts()) {
+      for (uint32 id = 0; id < stmt.NumMeStmtOpnds(); ++id) {
+        CollectUsedOst(stmt.GetOpnd(id));
+      }
+
+      auto *lhsVar = stmt.GetVarLHS();
+      if (lhsVar != nullptr) {
+        ostDefedByDassign[lhsVar->GetOstIdx()] = true;
+      }
+
+      auto *chiList = stmt.GetChiList();
+      if (chiList != nullptr) {
+        for (auto &chi : std::as_const(*chiList)) {
+          ostDefedByChi[chi.first] = true;
+        }
+      }
+    }
+  }
+}
+
+void SSARename2Preg::Init() {
+  size_t formalsize = func->GetMirFunc()->GetFormalDefVec().size();
+  parm_used_vec.resize(formalsize);
+  reg_formal_vec.resize(formalsize);
+}
+
+void SSARename2Preg::RunSelf() {
+  auto cfg = func->GetCfg();
+  Init();
+  CollectDefUseInfoOfOst();
+
+  for (BB *mebb : cfg->GetAllBBs()) {
+    if (mebb == nullptr) {
+      continue;
+    }
+    // rename the phi'ss
+    if (DEBUGFUNC(func)) {
+      LogInfo::MapleLogger() << " working on phi part of BB" << mebb->GetBBId() << std::endl;
+    }
+    MapleMap<OStIdx, MePhiNode *> &phiList = mebb->GetMePhiList();
+    MapleMap<OStIdx, MePhiNode *> regPhiList(func->GetIRMap()->GetIRMapAlloc().Adapter());
+    auto phiListIt = phiList.cbegin();
+    while (phiListIt != phiList.cend()) {
+      if (phiListIt->second->UseReg()) {
+        ++phiListIt;
+        continue;
+      }
+      if (!Rename2PregPhi(phiListIt->second, regPhiList)) {
+        ++phiListIt;
+        continue;
+      }
+      phiListIt->second->SetIsLive(false);
+      phiListIt = phiList.erase(phiListIt);
+    }
+    phiList.insert(regPhiList.cbegin(), regPhiList.cend());
+
+    if (DEBUGFUNC(func)) {
+      LogInfo::MapleLogger() << " working on stmt part of BB" << mebb->GetBBId() << std::endl;
+    }
+    for (MeStmt &stmt : mebb->GetMeStmts()) {
+      Rename2PregStmt(&stmt);
+    }
+  }
+
+  UpdateMirFunctionFormal();
+
+  if (!candsForSSAUpdate.empty()) {
+    MeSSAUpdate ssaUpdate(*func, *func->GetMeSSATab(), *dom, candsForSSAUpdate);
+    ssaUpdate.Run();
+  }
+}
+
+void SSARename2Preg::PromoteEmptyFunction() {
+  Init();
+  UpdateMirFunctionFormal();
+}
+
+void MESSARename2Preg::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MEAliasClass>();
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MESSARename2Preg::PhaseRun(maple::MeFunction &f) {
+  if (f.GetCfg()->empty()) {
+    return false;
+  }
+  MeIRMap *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  ASSERT(irMap != nullptr, "irMap is wrong.");
+  Dominance *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  ASSERT(dom != nullptr, "domTree is wrong");
+
+  MemPool *renamemp = ApplyTempMemPool();
+  if (f.GetCfg()->GetAllBBs().size() == 0) {
+    // empty function, we only promote the parameter
+    SSARename2Preg emptyrenamer(renamemp, &f, nullptr, nullptr, nullptr);
+    emptyrenamer.PromoteEmptyFunction();
+    return true;
+  }
+
+  auto *aliasClass = GET_ANALYSIS(MEAliasClass, f);
+  ASSERT(aliasClass != nullptr, "");
+
+  SSARename2Preg phase(renamemp, &f, f.GetIRMap(), dom, aliasClass);
+  phase.RunSelf();
+  if (DEBUGFUNC_NEWPM(f)) {
+    irMap->Dump();
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_safety_warning.cpp b/src/mapleall/maple_me/src/me_safety_warning.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..84accc2d361b06c398c104bfece142541fda1395
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_safety_warning.cpp
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_safety_warning.h"
+#include <sstream>
+#include "global_tables.h"
+#include "inline.h"
+#include "me_dominance.h"
+#include "me_irmap_build.h"
+#include "me_option.h"
+#include "mpl_logging.h"
+#include "opcode_info.h"
+
+namespace maple {
+std::string GetNthStr(size_t index) {
+  switch (index) {
+    case 0:
+      return "1st";
+    case 1:
+      return "2nd";
+    case 2:
+      return "3rd";
+    default: {
+      std::ostringstream oss;
+      oss << index + 1 << "th";
+      return oss.str();
+    }
+  }
+}
+
+inline static bool HandleAssertNonnull(const MeStmt &stmt, const MIRModule &mod, const MeFunction &func) {
+  auto srcPosition = stmt.GetSrcPosition();
+  auto &newStmt = static_cast<const AssertNonnullMeStmt &>(stmt);
+  GStrIdx curFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(func.GetName().c_str());
+  GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(newStmt.GetFuncName().c_str());
+  if (curFuncNameIdx == stmtFuncNameIdx) {
+    WARN_USER(kLncWarn, srcPosition, mod, "Dereference of nullable pointer");
+  } else {
+    WARN_USER(kLncWarn, srcPosition, mod, "Dereference of nullable pointer when inlined to %s",
+         newStmt.GetFuncName().c_str());
+  }
+  return !MeOption::isNpeCheckAll || MeOption::npeCheckMode == SafetyCheckMode::kStaticCheck;
+}
+
+inline static bool HandleReturnAssertNonnull(const MeStmt &stmt, const MIRModule &mod, const MeFunction &func) {
+  auto srcPosition = stmt.GetSrcPosition();
+  auto &returnStmt = static_cast<const AssertNonnullMeStmt &>(stmt);
+  GStrIdx curFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(func.GetName().c_str());
+  GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(returnStmt.GetFuncName().c_str());
+  if (curFuncNameIdx == stmtFuncNameIdx) {
+    if (MeOption::safeRegionMode && stmt.IsInSafeRegion()) {
+      FATAL(kLncFatal, "%s:%d error: %s return nonnull but got nullable pointer in safe region",
+            mod.GetFileNameFromFileNum(srcPosition.FileNum()).c_str(), srcPosition.LineNum(),
+            returnStmt.GetFuncName().c_str());
+    } else {
+      WARN_USER(kLncWarn, srcPosition, mod, "%s return nonnull but got nullable pointer",
+           returnStmt.GetFuncName().c_str());
+    }
+  } else {
+    if (MeOption::safeRegionMode && stmt.IsInSafeRegion()) {
+      FATAL(kLncFatal, "%s:%d error: %s return nonnull but got nullable pointer in safe region when inlined to %s",
+            mod.GetFileNameFromFileNum(srcPosition.FileNum()).c_str(), srcPosition.LineNum(),
+            returnStmt.GetFuncName().c_str(), func.GetName().c_str());
+    } else {
+      WARN_USER(kLncWarn, srcPosition, mod, "%s return nonnull but got nullable pointer when inlined to %s",
+           returnStmt.GetFuncName().c_str(), func.GetName().c_str());
+    }
+  }
+
+  return MeOption::npeCheckMode == SafetyCheckMode::kStaticCheck;
+}
+
+inline static bool HandleAssignAssertNonnull(const MeStmt &stmt, const MIRModule &mod, const MeFunction &func) {
+  auto srcPosition = stmt.GetSrcPosition();
+  auto &assignStmt = static_cast<const AssertNonnullMeStmt &>(stmt);
+  GStrIdx curFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(func.GetName().c_str());
+  GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(assignStmt.GetFuncName().c_str());
+  if (curFuncNameIdx == stmtFuncNameIdx) {
+    if (MeOption::safeRegionMode && stmt.IsInSafeRegion()) {
+      FATAL(kLncFatal, "%s:%d error: nullable pointer assignment of nonnull pointer in safe region",
+            mod.GetFileNameFromFileNum(srcPosition.FileNum()).c_str(), srcPosition.LineNum());
+    } else {
+      WARN_USER(kLncWarn, srcPosition, mod, "nullable pointer assignment of nonnull pointer");
+    }
+  } else {
+    if (MeOption::safeRegionMode && stmt.IsInSafeRegion()) {
+      FATAL(kLncFatal, "%s:%d error: nullable pointer assignment of nonnull pointer in safe region when inlined to %s",
+            mod.GetFileNameFromFileNum(srcPosition.FileNum()).c_str(), srcPosition.LineNum(), func.GetName().c_str());
+    } else {
+      WARN_USER(kLncWarn, srcPosition, mod, "nullable pointer assignment of nonnull pointer when inlined to %s",
+           func.GetName().c_str());
+    }
+  }
+  return MeOption::npeCheckMode == SafetyCheckMode::kStaticCheck;
+}
+
+inline static bool HandleCallAssertNonnull(const MeStmt &stmt, const MIRModule &mod, const MeFunction &func) {
+  auto srcPosition = stmt.GetSrcPosition();
+  auto &callStmt = static_cast<const CallAssertNonnullMeStmt &>(stmt);
+  GStrIdx curFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(func.GetName().c_str());
+  GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(callStmt.GetStmtFuncName().c_str());
+  if (curFuncNameIdx == stmtFuncNameIdx) {
+    WARN_USER(kLncWarn, srcPosition, mod, "nullable pointer passed to %s that requires nonnull for %s argument",
+         callStmt.GetFuncName().c_str(), GetNthStr(callStmt.GetParamIndex()).c_str());
+  } else {
+    WARN_USER(kLncWarn, srcPosition, mod,
+         "nullable pointer passed to %s that requires nonnull for %s argument when inlined to %s",
+         callStmt.GetFuncName().c_str(), GetNthStr(callStmt.GetParamIndex()).c_str(), func.GetName().c_str());
+  }
+  return MeOption::npeCheckMode == SafetyCheckMode::kStaticCheck;
+}
+
+static bool HandleCalculationAssert(const MeStmt &stmt, const MIRModule &mod, const MeFunction &func) {
+  auto srcPosition = stmt.GetSrcPosition();
+  auto &newStmt = static_cast<const AssertBoundaryMeStmt &>(stmt);
+  GStrIdx curFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(func.GetName().c_str());
+  GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(newStmt.GetFuncName().c_str());
+  std::ostringstream oss;
+  if (curFuncNameIdx == stmtFuncNameIdx) {
+    if (kOpcodeInfo.IsAssertUpperBoundary(stmt.GetOp())) {
+      oss << "can't prove the pointer < the upper bounds after calculation";
+    } else {
+      oss << "can't prove the pointer >= the lower bounds after calculation";
+    }
+    WARN_USER(kLncWarn, srcPosition, mod, oss.str().c_str());
+  } else {
+    if (kOpcodeInfo.IsAssertUpperBoundary(stmt.GetOp())) {
+      oss << "can't prove the pointer < the upper bounds after calculation when inlined to %s";
+    } else {
+      oss << "can't prove the pointer >= the lower bounds after calculation when inlined to %s";
+    }
+    WARN_USER(kLncWarn, srcPosition, mod, oss.str().c_str(), func.GetName().c_str());
+  }
+  return true;
+}
+
+static bool HandleMemoryAccessAssert(const MeStmt &stmt, const MIRModule &mod, const MeFunction &func) {
+  auto srcPosition = stmt.GetSrcPosition();
+  auto &newStmt = static_cast<const AssertBoundaryMeStmt &>(stmt);
+  GStrIdx curFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(func.GetName().c_str());
+  GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(newStmt.GetFuncName().c_str());
+  std::ostringstream oss;
+  if (curFuncNameIdx == stmtFuncNameIdx) {
+    if (kOpcodeInfo.IsAssertUpperBoundary(stmt.GetOp())) {
+      oss << "can't prove the pointer < the upper bounds when accessing the memory";
+    } else {
+      oss << "can't prove the pointer >= the lower bounds when accessing the memory";
+    }
+    WARN_USER(kLncWarn, srcPosition, mod, oss.str().c_str());
+  } else {
+    if (kOpcodeInfo.IsAssertUpperBoundary(stmt.GetOp())) {
+      oss << "can't prove the pointer < the upper bounds when accessing the memory and inlined to %s";
+    } else {
+      oss << "can't prove the pointer >= the lower bounds when accessing the memory and inlined to %s";
+    }
+    WARN_USER(kLncWarn, srcPosition, mod, oss.str().c_str(), func.GetName().c_str());
+  }
+  return MeOption::boundaryCheckMode == SafetyCheckMode::kStaticCheck;
+}
+
+static bool HandleBoundaryCheckAssertAssign(const MeStmt &stmt, const MIRModule &mod, const MeFunction &func) {
+  auto srcPosition = stmt.GetSrcPosition();
+  auto &newStmt = static_cast<const AssertBoundaryMeStmt &>(stmt);
+  GStrIdx curFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(func.GetName().c_str());
+  GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(newStmt.GetFuncName().c_str());
+  if (curFuncNameIdx == stmtFuncNameIdx) {
+    WARN_USER(kLncWarn, srcPosition, mod, "can't prove l-value's upper bounds <= r-value's upper bounds");
+  } else {
+    WARN_USER(kLncWarn, srcPosition, mod, "can't prove l-value's upper bounds <= r-value's upper bounds when inlined to %s",
+         func.GetName().c_str());
+  }
+
+  return MeOption::boundaryCheckMode == SafetyCheckMode::kStaticCheck;
+}
+
+inline static bool HandleBoundaryCheckAssertCall(const MeStmt &stmt, const MIRModule &mod, const MeFunction &func) {
+  auto srcPosition = stmt.GetSrcPosition();
+  auto &callStmt = static_cast<const CallAssertBoundaryMeStmt &>(stmt);
+  GStrIdx curFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(func.GetName().c_str());
+  GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(callStmt.GetStmtFuncName().c_str());
+  if (curFuncNameIdx == stmtFuncNameIdx) {
+    WARN_USER(kLncWarn, srcPosition, mod,
+         "can't prove pointer's bounds match the function %s declaration for the %s argument",
+         callStmt.GetFuncName().c_str(), GetNthStr(callStmt.GetParamIndex()).c_str());
+  } else {
+    WARN_USER(kLncWarn, srcPosition, mod,
+         "can't prove pointer's bounds match the function %s declaration for the %s argument when inlined to %s",
+         callStmt.GetFuncName().c_str(), GetNthStr(callStmt.GetParamIndex()).c_str(), func.GetName().c_str());
+  }
+  return MeOption::boundaryCheckMode == SafetyCheckMode::kStaticCheck;
+}
+
+inline static bool HandleBoundaryCheckAssertReturn(const MeStmt &stmt, const MIRModule &mod, const MeFunction &func) {
+  auto srcPosition = stmt.GetSrcPosition();
+  auto &returnStmt = static_cast<const AssertBoundaryMeStmt &>(stmt);
+  GStrIdx curFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(func.GetName().c_str());
+  GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(returnStmt.GetFuncName().c_str());
+  if (curFuncNameIdx == stmtFuncNameIdx) {
+    WARN_USER(kLncWarn, srcPosition, mod, "can't prove return value's bounds match the function declaration for %s",
+         returnStmt.GetFuncName().c_str());
+  } else {
+    WARN_USER(kLncWarn, srcPosition, mod,
+         "can't prove return value's bounds match the function declaration for %s when inlined to %s",
+         returnStmt.GetFuncName().c_str(), func.GetName().c_str());
+  }
+  return MeOption::boundaryCheckMode == SafetyCheckMode::kStaticCheck;
+}
+
+SafetyWarningHandlers MESafetyWarning::npeHandleMap = {
+    { OP_assertnonnull, HandleAssertNonnull },
+    { OP_returnassertnonnull, HandleReturnAssertNonnull },
+    { OP_assignassertnonnull, HandleAssignAssertNonnull },
+    { OP_callassertnonnull, HandleCallAssertNonnull }
+};
+
+SafetyWarningHandlers MESafetyWarning::boundaryHandleMap = {
+    { OP_assertlt, HandleMemoryAccessAssert },
+    { OP_assertge, HandleMemoryAccessAssert },
+    { OP_calcassertlt, HandleCalculationAssert },
+    { OP_calcassertge, HandleCalculationAssert },
+    { OP_callassertle, HandleBoundaryCheckAssertCall },
+    { OP_returnassertle, HandleBoundaryCheckAssertReturn },
+    { OP_assignassertle, HandleBoundaryCheckAssertAssign }
+};
+
+SafetyWarningHandlers MESafetyWarning::npeSilentHandleMap = {
+    { OP_assertnonnull, [](auto&, auto&, auto&) -> bool { return !MeOption::isNpeCheckAll; } },
+    { OP_returnassertnonnull, [](auto&, auto&, auto&) -> bool { return false; } },
+    { OP_assignassertnonnull, [](auto&, auto&, auto&) -> bool { return false; } },
+    { OP_callassertnonnull, [](auto&, auto&, auto&) -> bool { return false; } }
+};
+
+SafetyWarningHandlers MESafetyWarning::boundarySilentHandleMap = {
+    { OP_assertlt, [](auto&, auto&, auto&) -> bool { return false; } },
+    { OP_assertge, [](auto&, auto&, auto&) -> bool { return false; } },
+    { OP_calcassertlt, [](auto&, auto&, auto&) -> bool { return true; } },
+    { OP_calcassertge, [](auto&, auto&, auto&) -> bool { return true; } },
+    { OP_callassertle, [](auto&, auto&, auto&) -> bool { return false; } },
+    { OP_returnassertle, [](auto&, auto&, auto&) -> bool { return false; } },
+    { OP_assignassertle, [](auto&, auto&, auto&) -> bool { return false; } }
+};
+
+void MESafetyWarning::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MESafetyWarning::IsStaticModeForOp(Opcode op) const {
+  switch (op) {
+    CASE_OP_ASSERT_NONNULL
+    return MeOption::npeCheckMode == SafetyCheckMode::kStaticCheck;
+    CASE_OP_ASSERT_BOUNDARY
+    return MeOption::boundaryCheckMode == SafetyCheckMode::kStaticCheck;
+    default:
+      CHECK_FATAL(false, "NEVER REACH");
+      break;
+  }
+  return false;
+}
+
+SafetyWarningHandler *MESafetyWarning::FindHandler(Opcode op) {
+  auto handler = realNpeHandleMap->find(op);
+  if (handler != realNpeHandleMap->end()) {
+    return &handler->second;
+  }
+  handler = realBoundaryHandleMap->find(op);
+  if (handler != realBoundaryHandleMap->end()) {
+    return &handler->second;
+  }
+  return nullptr;
+}
+
+bool MESafetyWarning::PhaseRun(MeFunction &meFunction) {
+  auto &mod = meFunction.GetMIRModule();
+  MapleVector<MeStmt*> removeStmts(mod.GetMPAllocator().Adapter());
+  for (auto *bb : meFunction.GetCfg()->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    for (auto &stmt : bb->GetMeStmts()) {
+      auto *handle = FindHandler(stmt.GetOp());
+      if (handle != nullptr) {
+        // check has warned or not
+        if (mod.HasNotWarned(stmt.GetSrcPosition().LineNum(), stmt.GetOriginalId())) {
+          if ((*handle)(stmt, mod, meFunction)) {
+            // record stmt to delete
+            removeStmts.emplace_back(&stmt);
+          }
+        } else if (IsStaticModeForOp(stmt.GetOp()) ||
+                   // deref assert nonnull need to remove in all mode
+                   stmt.GetOp() == OP_assertnonnull ||
+                   // calcassert need to be removed in all mode
+                   kOpcodeInfo.IsCalcAssertBoundary(stmt.GetOp())) {
+          // remove inlined code
+          removeStmts.emplace_back(&stmt);
+        }
+      }
+    }
+    // remove stmt
+    for (auto &stmt : removeStmts) {
+      bb->RemoveMeStmt(stmt);
+    }
+    removeStmts.clear();
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_scalar_analysis.cpp b/src/mapleall/maple_me/src/me_scalar_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..74d697abcbe255c86bd13d7e3610fac6250671a6
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_scalar_analysis.cpp
@@ -0,0 +1,1463 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_scalar_analysis.h"
+#include <iostream>
+#include <algorithm>
+#include "me_loop_analysis.h"
+
+namespace maple {
+bool LoopScalarAnalysisResult::enableDebug = false;
+constexpr int kNumOpnds = 2;
+
+bool CRNode::IsEqual(const CRNode &crNode) const {
+  if (crType != crNode.GetCRType()) {
+    return false;
+  }
+  switch (crType) {
+    case kCRConstNode: {
+      return static_cast<const CRConstNode&>(crNode).GetConstValue() ==
+             static_cast<const CRConstNode*>(this)->GetConstValue();
+    }
+    case kCRVarNode: {
+      return expr == crNode.expr;
+    }
+    case kCRNode:
+    case kCRAddNode:
+    case kCRMulNode: {
+      auto &opndsOfCRNode = crNode.GetOpnds();
+      auto &opndsOfThis = this->GetOpnds();
+      if (opndsOfCRNode.size() != opndsOfThis.size()) {
+        return false;
+      }
+      for (size_t i = 0; i < opndsOfCRNode.size(); ++i) {
+        if (!opndsOfCRNode.at(i)->IsEqual(*opndsOfThis.at(i))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case kCRDivNode: {
+      return static_cast<const CRDivNode&>(crNode).GetLHS()->IsEqual(*static_cast<const CRDivNode*>(this)->GetLHS()) &&
+             static_cast<const CRDivNode&>(crNode).GetRHS()->IsEqual(*static_cast<const CRDivNode*>(this)->GetRHS());
+    }
+    default:
+      return false;
+  }
+}
+
+// Put the sub nodes of crNode in vector for opt the boundary check, such as:
+// crNode: ptr + length * 4 - 8
+// =>
+// curVector: { ptr, length * 4, -8 }
+void CRNode::PutTheSubNode2Vector(std::vector<CRNode*> &curVector) {
+  switch (crType) {
+    case kCRConstNode:
+    case kCRVarNode:
+    case kCRDivNode:
+    case kCRMulNode:
+    case kCRNode:
+    case kCRUnKnown:
+      curVector.push_back(this);
+      break;
+    case kCRAddNode:
+      auto *crAddNode = static_cast<CRAddNode*>(this);
+      curVector.insert(curVector.cend(), crAddNode->GetOpnds().cbegin(), crAddNode->GetOpnds().cend());
+      break;
+  }
+}
+
+static bool IsConstantMultipliedByVariable(const CRMulNode &crMulNode) {
+  return (crMulNode.GetOpndsSize() == kNumOpnds && crMulNode.GetOpnd(0)->GetCRType() == kCRConstNode);
+}
+
+// Get the byte size of array for simpify the crNodes.
+uint8 LoopScalarAnalysisResult::GetByteSize(std::vector<CRNode*> &crNodeVector) {
+  for (size_t i = 0; i < crNodeVector.size(); ++i) {
+    if (crNodeVector[i]->GetCRType() != kCRMulNode) {
+      continue;
+    }
+    auto *crMulNode = static_cast<CRMulNode*>(crNodeVector[i]);
+    if (!IsConstantMultipliedByVariable(*crMulNode)) {
+      return 0;
+    }
+    return static_cast<uint8>(static_cast<CRConstNode*>(crMulNode->GetOpnd(0))->GetConstValue());
+  }
+  return 0;
+}
+
+// Get the prim type of index or bound, if not found, return PTY_i64.
+PrimType LoopScalarAnalysisResult::GetPrimType(std::vector<CRNode*> &crNodeVector) {
+  for (size_t i = 0; i < crNodeVector.size(); ++i) {
+    if (crNodeVector[i]->GetCRType() == kCRVarNode) {
+      return crNodeVector[i]->GetExpr()->GetPrimType();
+    }
+  }
+  return PTY_i64;
+}
+
+// If the byteSize is 4, simpify the crNodes like this:
+// before: length * 4 - var * 4 - 4
+// =>
+// after: lenght - var - 1
+bool LoopScalarAnalysisResult::NormalizationWithByteCount(std::vector<CRNode*> &crNodeVector, uint8 byteSize) {
+  if (byteSize <= 1) {
+    return true;
+  }
+  for (size_t i = 0; i < crNodeVector.size(); ++i) {
+    if (crNodeVector[i]->GetCRType() != kCRConstNode && crNodeVector[i]->GetCRType() != kCRMulNode) {
+      return false;
+    }
+    if (crNodeVector[i]->GetCRType() == kCRConstNode) {
+      auto value = static_cast<CRConstNode*>(crNodeVector[i])->GetConstValue();
+      if (value % byteSize != 0) {
+        return false;
+      }
+      value = value / byteSize;
+      crNodeVector[i] = GetOrCreateCRConstNode(nullptr, value);
+      continue;
+    }
+    if (crNodeVector[i]->GetCRType() == kCRMulNode) {
+      auto *crMulNode = static_cast<CRMulNode*>(crNodeVector[i]);
+      if (!IsConstantMultipliedByVariable(*crMulNode)) {
+        return false;
+      }
+      auto value = static_cast<CRConstNode*>(crMulNode->GetOpnd(0))->GetConstValue();
+      if (value % byteSize != 0) {
+        return false;
+      }
+      value = value / byteSize;
+      if (value == 1) {
+        crNodeVector[i] = crMulNode->GetOpnd(1);
+      } else {
+        std::vector<CRNode*> crMulNodes { GetOrCreateCRConstNode(nullptr, value), crMulNode->GetOpnd(1) };
+        crNodeVector[i] = GetOrCreateCRMulNode(nullptr, crMulNodes);
+      }
+      continue;
+    }
+  }
+  return true;
+}
+
+// Return the unequal sub nodes of index crNode and bound crNode.
+void CRNode::GetTheUnequalSubNodesOfIndexAndBound(
+    CRNode &boundCRNode, std::vector<CRNode*> &indexVector, std::vector<CRNode*> &boundVector) {
+  this->PutTheSubNode2Vector(indexVector);
+  boundCRNode.PutTheSubNode2Vector(boundVector);
+  for (auto it = indexVector.begin(); it != indexVector.end();) {
+    bool findTheSameCR = false;
+    for (auto itOfBoundVec = boundVector.begin(); itOfBoundVec != boundVector.end(); ++itOfBoundVec) {
+      // The vectors are sorted by specified order like :
+      // kCRConstNode < kCRVarNode < kCRAddNode < kCRMulNode < kCRDivNode < kCRNode < kCRUnKnown.
+      if ((*itOfBoundVec)->GetCRType() > (*it)->GetCRType()) {
+        break;
+      }
+      if ((*itOfBoundVec)->GetCRType() != (*it)->GetCRType()) {
+        continue;
+      }
+      // If the crNodes are equal, erase them from their vector.
+      if ((*it)->IsEqual(**itOfBoundVec)) {
+        findTheSameCR = true;
+        it = indexVector.erase(it);
+        boundVector.erase(itOfBoundVec);
+        break;
+      }
+    }
+    if (!findTheSameCR) {
+      ++it;
+    }
+  }
+}
+
+CRNode *CR::GetPolynomialsValueAtITerm(CRNode &iterCRNode, size_t num, LoopScalarAnalysisResult &scalarAnalysis) const {
+  if (num == 1) {
+    return &iterCRNode;
+  }
+  // BC(It, K) = (It * (It - 1) * ... * (It - K + 1)) / K!;
+  size_t factorialOfNum = 1;
+  // compute K!
+  for (size_t i = 2; i <= num; ++i) {
+    factorialOfNum *= i;
+  }
+  CRConstNode factorialOfNumCRNode = CRConstNode(nullptr, factorialOfNum);
+  CRNode *result = &iterCRNode;
+  for (size_t i = 1; i != num; ++i) {
+    std::vector<CRNode*> crAddNodes;
+    crAddNodes.push_back(&iterCRNode);
+    CRConstNode constNode = CRConstNode(nullptr, i);
+    CRNode *negetive2Mul = scalarAnalysis.ChangeNegative2MulCRNode(*static_cast<CRNode*>(&constNode));
+    crAddNodes.push_back(negetive2Mul);
+    CRNode *addResult = scalarAnalysis.GetCRAddNode(nullptr, crAddNodes);
+    std::vector<CRNode*> crMulNodes;
+    crMulNodes.push_back(result);
+    crMulNodes.push_back(addResult);
+    result = scalarAnalysis.GetCRMulNode(nullptr, crMulNodes);
+  }
+  return scalarAnalysis.GetOrCreateCRDivNode(nullptr, *result, *static_cast<CRNode*>(&factorialOfNumCRNode));
+}
+
+CRNode *CR::ComputeValueAtIteration(uint32 i, LoopScalarAnalysisResult &scalarAnalysis) const {
+  CRConstNode iterCRNode(nullptr, i);
+  CRNode *result = opnds[0];
+  CRNode *subResult = nullptr;
+  for (size_t j = 1; j < opnds.size(); ++j) {
+    subResult = GetPolynomialsValueAtITerm(iterCRNode, j, scalarAnalysis);
+    CHECK_NULL_FATAL(subResult);
+    std::vector<CRNode*> crMulNodes;
+    crMulNodes.push_back(opnds[j]);
+    crMulNodes.push_back(subResult);
+    CRNode *mulResult = scalarAnalysis.GetCRMulNode(nullptr, crMulNodes);
+    std::vector<CRNode*> crAddNodes;
+    crAddNodes.push_back(result);
+    crAddNodes.push_back(mulResult);
+    result = scalarAnalysis.GetCRAddNode(nullptr, crAddNodes);
+  }
+  return result;
+}
+
+MeExpr *LoopScalarAnalysisResult::TryToResolveScalar(MeExpr &expr, std::set<MePhiNode*> &visitedPhi,
+                                                     MeExpr &dummyExpr) {
+  if (expr.GetMeOp() != kMeOpVar && expr.GetMeOp() != kMeOpReg) {
+    return nullptr;
+  }
+  auto *scalar = static_cast<ScalarMeExpr*>(&expr);
+  if (scalar->GetDefBy() == kDefByStmt) {
+    if (!scalar->GetDefStmt()->GetRHS()->IsLeaf()) {
+      return nullptr;
+    }
+    if (scalar->GetDefStmt()->GetRHS()->GetMeOp() == kMeOpConst) {
+      return scalar->GetDefStmt()->GetRHS();
+    }
+    return TryToResolveScalar(*(scalar->GetDefStmt()->GetRHS()), visitedPhi, dummyExpr);
+  }
+
+  if (scalar->GetDefBy() == kDefByPhi) {
+    MePhiNode *phi = &(scalar->GetDefPhi());
+    if (visitedPhi.find(phi) != visitedPhi.end()) {
+      return &dummyExpr;
+    }
+    visitedPhi.insert(phi);
+    std::set<MeExpr*> constRes;
+    for (auto *phiOpnd : phi->GetOpnds()) {
+      MeExpr *tmp = TryToResolveScalar(*phiOpnd, visitedPhi, dummyExpr);
+      if (tmp == nullptr) {
+        return nullptr;
+      }
+      if (tmp != &dummyExpr) {
+        constRes.insert(tmp);
+      }
+    }
+    if (constRes.size() == 1) {
+      return *(constRes.begin());
+    } else {
+      return nullptr;
+    }
+  }
+  return nullptr;
+}
+
+void LoopScalarAnalysisResult::VerifyCR(const CRNode &crNode) {
+  constexpr uint32 verifyTimes = 10; // Compute top ten iterations result of crNode.
+  for (uint32 i = 0; i < verifyTimes; ++i) {
+    if (crNode.GetCRType() != kCRNode) {
+      continue;
+    }
+    const CRNode *r = static_cast<const CR*>(&crNode)->ComputeValueAtIteration(i, *this);
+    if (r->GetCRType() == kCRConstNode) {
+      std::cout << static_cast<const CRConstNode*>(r)->GetConstValue() << std::endl;
+    }
+  }
+}
+
+
+void LoopScalarAnalysisResult::Dump(const CRNode &crNode) {
+  switch (crNode.GetCRType()) {
+    case kCRConstNode: {
+      LogInfo::MapleLogger() << static_cast<const CRConstNode*>(&crNode)->GetConstValue();
+      return;
+    }
+    case kCRVarNode: {
+      CHECK_FATAL(crNode.GetExpr() != nullptr, "crNode must has expr");
+      const MeExpr *meExpr = crNode.GetExpr();
+      std::string name;
+      OStIdx oStIdx;
+      if (meExpr->GetMeOp() == kMeOpReg) {
+        LogInfo::MapleLogger() << "mx" + std::to_string(meExpr->GetExprID());
+        return;
+      } else if (meExpr->GetMeOp() == kMeOpAddrof) {
+        oStIdx = static_cast<const AddrofMeExpr*>(meExpr)->GetOstIdx();
+      } else if (meExpr->GetMeOp() == kMeOpVar) {
+        oStIdx = static_cast<const VarMeExpr*>(meExpr)->GetOstIdx();
+      } else if (meExpr->GetMeOp() == kMeOpIvar) {
+        const auto *ivarMeExpr = static_cast<const IvarMeExpr*>(meExpr);
+        const MeExpr *base = ivarMeExpr->GetBase();
+        if (base->GetMeOp() == kMeOpVar) {
+          oStIdx = static_cast<const VarMeExpr*>(base)->GetOstIdx();
+        } else {
+          name = "ivar" + std::to_string(ivarMeExpr->GetExprID());
+          LogInfo::MapleLogger() << name;
+          return;
+        }
+      } else {
+        LogInfo::MapleLogger() << "_mx" + std::to_string(meExpr->GetExprID());
+        return;
+      }
+      MIRSymbol *sym = irMap->GetSSATab().GetMIRSymbolFromID(oStIdx);
+      name = sym->GetName() + "_mx" + std::to_string(meExpr->GetExprID());
+      LogInfo::MapleLogger() << name;
+      return;
+    }
+    case kCRAddNode: {
+      const CRAddNode *crAddNode = static_cast<const CRAddNode*>(&crNode);
+      CHECK_FATAL(crAddNode->GetOpndsSize() > 1, "crAddNode must has more than one opnd");
+      Dump(*crAddNode->GetOpnd(0));
+      for (size_t i = 1; i < crAddNode->GetOpndsSize(); ++i) {
+        LogInfo::MapleLogger() << " + ";
+        Dump(*crAddNode->GetOpnd(i));
+      }
+      return;
+    }
+    case kCRMulNode: {
+      const CRMulNode *crMulNode = static_cast<const CRMulNode*>(&crNode);
+      CHECK_FATAL(crMulNode->GetOpndsSize() > 1, "crMulNode must has more than one opnd");
+      if (crMulNode->GetOpnd(0)->GetCRType() != kCRConstNode && crMulNode->GetOpnd(0)->GetCRType() != kCRVarNode) {
+        LogInfo::MapleLogger() << "(";
+        Dump(*crMulNode->GetOpnd(0));
+        LogInfo::MapleLogger() << ")";
+      } else {
+        Dump(*crMulNode->GetOpnd(0));
+      }
+
+      for (size_t i = 1; i < crMulNode->GetOpndsSize(); ++i) {
+        LogInfo::MapleLogger() << " * ";
+        if (crMulNode->GetOpnd(i)->GetCRType() != kCRConstNode && crMulNode->GetOpnd(i)->GetCRType() != kCRVarNode) {
+          LogInfo::MapleLogger() << "(";
+          Dump(*crMulNode->GetOpnd(i));
+          LogInfo::MapleLogger() << ")";
+        } else {
+          Dump(*crMulNode->GetOpnd(i));
+        }
+      }
+      return;
+    }
+    case kCRDivNode: {
+      const CRDivNode *crDivNode = static_cast<const CRDivNode*>(&crNode);
+      if (crDivNode->GetLHS()->GetCRType() != kCRConstNode && crDivNode->GetLHS()->GetCRType() != kCRVarNode) {
+        LogInfo::MapleLogger() << "(";
+        Dump(*crDivNode->GetLHS());
+        LogInfo::MapleLogger() << ")";
+      } else {
+        Dump(*crDivNode->GetLHS());
+      }
+      LogInfo::MapleLogger() << " / ";
+      if (crDivNode->GetRHS()->GetCRType() != kCRConstNode && crDivNode->GetRHS()->GetCRType() != kCRVarNode) {
+        LogInfo::MapleLogger() << "(";
+        Dump(*crDivNode->GetRHS());
+        LogInfo::MapleLogger() << ")";
+      } else {
+        Dump(*crDivNode->GetRHS());
+      }
+      return;
+    }
+    case kCRNode: {
+      const CR *cr = static_cast<const CR*>(&crNode);
+      CHECK_FATAL(cr->GetOpndsSize() > 1, "cr must has more than one opnd");
+      LogInfo::MapleLogger() << "{";
+      Dump(*cr->GetOpnd(0));
+      for (size_t i = 1; i < cr->GetOpndsSize(); ++i) {
+        LogInfo::MapleLogger() << ", + ,";
+        Dump(*cr->GetOpnd(i));
+      }
+      LogInfo::MapleLogger() << "}";
+      return;
+    }
+    default:
+      LogInfo::MapleLogger() << crNode.GetExpr()->GetExprID() << "@@@" << crNode.GetCRType();
+      CHECK_FATAL(false, "can not support");
+  }
+}
+
+CRNode *LoopScalarAnalysisResult::GetOrCreateCRConstNode(MeExpr *expr, int64 value) {
+  if (expr == nullptr) {
+    std::unique_ptr<CRConstNode> constNode = std::make_unique<CRConstNode>(nullptr, value);
+    CRConstNode *constPtr = constNode.get();
+    allCRNodes.insert(std::move(constNode));
+    return constPtr;
+  }
+  auto it = expr2CR.find(expr);
+  if (it != expr2CR.end()) {
+    return it->second;
+  }
+
+  std::unique_ptr<CRConstNode> constNode = std::make_unique<CRConstNode>(expr, value);
+  CRConstNode *constPtr = constNode.get();
+  allCRNodes.insert(std::move(constNode));
+  InsertExpr2CR(*expr, constPtr);
+  return constPtr;
+}
+
+CRNode *LoopScalarAnalysisResult::GetOrCreateCRVarNode(MeExpr &expr) {
+  auto it = expr2CR.find(&expr);
+  if (it != expr2CR.end()) {
+    return it->second;
+  }
+
+  std::unique_ptr<CRVarNode> varNode = std::make_unique<CRVarNode>(&expr);
+  CRVarNode *varPtr = varNode.get();
+  allCRNodes.insert(std::move(varNode));
+  InsertExpr2CR(expr, varPtr);
+  return varPtr;
+}
+
+CRNode *LoopScalarAnalysisResult::GetOrCreateLoopInvariantCR(MeExpr &expr) {
+  if (expr.GetMeOp() == kMeOpConst && static_cast<ConstMeExpr&>(expr).GetConstVal()->GetKind() == kConstInt) {
+    return GetOrCreateCRConstNode(&expr, static_cast<ConstMeExpr&>(expr).GetExtIntValue());
+  }
+  if (expr.GetMeOp() == kMeOpVar || expr.GetMeOp() == kMeOpReg) {
+    // Try to resolve Var is assigned from Const
+    MeExpr *scalar = &expr;
+    std::set<MePhiNode*> visitedPhi;
+    ConstMeExpr dummyExpr(kInvalidExprID, nullptr, PTY_unknown);
+    scalar = TryToResolveScalar(*scalar, visitedPhi, dummyExpr);
+    if (scalar != nullptr && scalar != &dummyExpr) {
+      CHECK_FATAL(scalar->GetMeOp() == kMeOpConst, "must be");
+      return GetOrCreateCRConstNode(&expr, static_cast<ConstMeExpr*>(scalar)->GetExtIntValue());
+    }
+    return GetOrCreateCRVarNode(expr);
+  }
+  return GetOrCreateCRVarNode(expr);
+}
+
+CRNode* LoopScalarAnalysisResult::GetOrCreateCRAddNode(MeExpr *expr, const std::vector<CRNode*> &crAddNodes) {
+  if (expr == nullptr) {
+    std::unique_ptr<CRAddNode> crAdd = std::make_unique<CRAddNode>(nullptr);
+    CRAddNode *crPtr = crAdd.get();
+    allCRNodes.insert(std::move(crAdd));
+    crPtr->SetOpnds(crAddNodes);
+    return crPtr;
+  }
+  auto it = expr2CR.find(expr);
+  if (it != expr2CR.end()) {
+    return it->second;
+  }
+  std::unique_ptr<CRAddNode> crAdd = std::make_unique<CRAddNode>(expr);
+  CRAddNode *crAddPtr = crAdd.get();
+  allCRNodes.insert(std::move(crAdd));
+  crAddPtr->SetOpnds(crAddNodes);
+  // can not insert crAddNode to expr2CR map
+  return crAddPtr;
+}
+
+CRNode *LoopScalarAnalysisResult::GetOrCreateCR(MeExpr &expr, CRNode &start, CRNode &stride) {
+  auto it = expr2CR.find(&expr);
+  if (it != expr2CR.end() && (it->second == nullptr || it->second->GetCRType() != kCRUnKnown)) {
+    return it->second;
+  }
+  std::unique_ptr<CR> cr = std::make_unique<CR>(&expr);
+  CR *crPtr = cr.get();
+  allCRNodes.insert(std::move(cr));
+  InsertExpr2CR(expr, crPtr);
+  crPtr->PushOpnds(start);
+  if (stride.GetCRType() == kCRNode) {
+    crPtr->InsertOpnds(static_cast<CR*>(&stride)->GetOpnds().begin(), static_cast<CR*>(&stride)->GetOpnds().end());
+    return crPtr;
+  }
+  crPtr->PushOpnds(stride);
+  return crPtr;
+}
+
+CRNode *LoopScalarAnalysisResult::GetOrCreateCR(MeExpr *expr, const std::vector<CRNode*> &crNodes) {
+  auto it = expr2CR.find(expr);
+  if (it != expr2CR.end()) {
+    return it->second;
+  }
+  std::unique_ptr<CR> cr = std::make_unique<CR>(expr);
+  CR *crPtr = cr.get();
+  allCRNodes.insert(std::move(cr));
+  crPtr->SetOpnds(crNodes);
+  if (expr != nullptr) {
+    InsertExpr2CR(*expr, crPtr);
+  }
+  return crPtr;
+}
+
+CRNode *LoopScalarAnalysisResult::GetCRAddNode(MeExpr *expr, std::vector<CRNode*> &crAddOpnds) {
+  if (crAddOpnds.size() == 1) {
+    return crAddOpnds[0];
+  }
+  std::sort(crAddOpnds.begin(), crAddOpnds.end(), CompareCRNodeWithCRType());
+  // merge constCRNode
+  // 1 + 2 + 3 + X -> 6 + X
+  size_t index = 0;
+  if (crAddOpnds[0]->GetCRType() == kCRConstNode) {
+    CRConstNode *constLHS = static_cast<CRConstNode*>(crAddOpnds[0]);
+    ++index;
+    while (index < crAddOpnds.size() && crAddOpnds[index]->GetCRType() == kCRConstNode) {
+      CRConstNode *constRHS = static_cast<CRConstNode*>(crAddOpnds[index]);
+      crAddOpnds[0] = GetOrCreateCRConstNode(nullptr, constLHS->GetConstValue() + constRHS->GetConstValue());
+      if (crAddOpnds.size() == kNumOpnds) {
+        return crAddOpnds[0];
+      }
+      crAddOpnds.erase(crAddOpnds.cbegin() + 1);
+      constLHS = static_cast<CRConstNode*>(crAddOpnds[0]);
+    }
+    // After merge constCRNode, if crAddOpnds[0] is 0, delete it from crAddOpnds vector
+    // 0 + X -> X
+    if (constLHS->GetConstValue() == 0) {
+      crAddOpnds.erase(crAddOpnds.cbegin());
+      --index;
+    }
+    if (crAddOpnds.size() == 1) {
+      return crAddOpnds[0];
+    }
+  }
+
+  // if the crType of operand is CRAddNode, unfold the operand
+  // 1 + (X + Y) -> 1 + X + Y
+  size_t addCRIndex = index;
+  while (addCRIndex < crAddOpnds.size() && crAddOpnds[addCRIndex]->GetCRType() != kCRAddNode) {
+    ++addCRIndex;
+  }
+  if (addCRIndex < crAddOpnds.size()) {
+    while (crAddOpnds[addCRIndex]->GetCRType() == kCRAddNode) {
+      crAddOpnds.insert(crAddOpnds.cend(),
+                        static_cast<CRAddNode*>(crAddOpnds[addCRIndex])->GetOpnds().cbegin(),
+                        static_cast<CRAddNode*>(crAddOpnds[addCRIndex])->GetOpnds().cend());
+      crAddOpnds.erase(crAddOpnds.cbegin() + addCRIndex);
+    }
+    return GetCRAddNode(expr, crAddOpnds);
+  }
+
+  // merge cr
+  size_t crIndex = index;
+  while (crIndex < crAddOpnds.size() && crAddOpnds[crIndex]->GetCRType() != kCRNode) {
+    ++crIndex;
+  }
+  if (crIndex < crAddOpnds.size()) {
+    // X + { Y, + , Z } -> { X + Y, + , Z }
+    if (crIndex != 0) {
+      std::vector<CRNode*> startOpnds(crAddOpnds.begin(), crAddOpnds.begin() + crIndex);
+      crAddOpnds.erase(crAddOpnds.cbegin(), crAddOpnds.cbegin() + crIndex);
+      startOpnds.push_back(static_cast<CR*>(crAddOpnds[crIndex])->GetOpnd(0));
+      CRNode *start = GetCRAddNode(nullptr, startOpnds);
+      std::vector<CRNode*> newCROpnds{ start };
+      newCROpnds.insert(newCROpnds.cend(), static_cast<CR*>(crAddOpnds[crIndex])->GetOpnds().cbegin() + 1,
+                        static_cast<CR*>(crAddOpnds[crIndex])->GetOpnds().cend());
+      CR *newCR = static_cast<CR*>(GetOrCreateCR(expr, newCROpnds));
+      if (crAddOpnds.size() == 1) {
+        return static_cast<CRNode*>(newCR);
+      }
+      crAddOpnds[0] = static_cast<CRNode*>(newCR);
+      crIndex = 0;
+    }
+    // { X1 , + , Y1,  + , ... , + , Z1 } + { X2 , + , Y2, + , ... , + , Z2 }
+    // ->
+    // { X1 + X2, + , Y1 + Y2, + , ... , + , Z1 + Z2 }
+    ++crIndex;
+    CR *crLHS = static_cast<CR*>(crAddOpnds[0]);
+    while (crIndex < crAddOpnds.size() && crAddOpnds[crIndex]->GetCRType() == kCRNode) {
+      CR *crRHS = static_cast<CR*>(crAddOpnds[crIndex]);
+      crAddOpnds[0] = static_cast<CRNode*>(AddCRWithCR(*crLHS, *crRHS));
+      if (crAddOpnds.size() == kNumOpnds) {
+        if (crAddOpnds[0]->GetCRType() == kCRNode && crAddOpnds[0]->GetOpnds().size() == 1) {
+          return static_cast<CR*>(crAddOpnds[0])->GetOpnd(0);
+        }
+        return crAddOpnds[0];
+      }
+      crAddOpnds.erase(crAddOpnds.cbegin() + 1);
+      crLHS = static_cast<CR*>(crAddOpnds[0]);
+    }
+    if (crAddOpnds.size() == 1) {
+      return crAddOpnds[0];
+    }
+  }
+  return GetOrCreateCRAddNode(expr, crAddOpnds);
+}
+
+CRNode *LoopScalarAnalysisResult::GetCRMulNode(MeExpr *expr, std::vector<CRNode*> &crMulOpnds) {
+  if (crMulOpnds.size() == 1) {
+    return crMulOpnds[0];
+  }
+  std::sort(crMulOpnds.begin(), crMulOpnds.end(), CompareCRNodeWithCRType());
+  // merge constCRNode
+  // 1 * 2 * 3 * X -> 6 * X
+  size_t index = 0;
+  if (crMulOpnds[0]->GetCRType() == kCRConstNode) {
+    CRConstNode *constLHS = static_cast<CRConstNode*>(crMulOpnds[0]);
+    ++index;
+    while (index < crMulOpnds.size() && crMulOpnds[index]->GetCRType() == kCRConstNode) {
+      CRConstNode *constRHS = static_cast<CRConstNode*>(crMulOpnds[index]);
+      crMulOpnds[0] = GetOrCreateCRConstNode(nullptr, constLHS->GetConstValue() * constRHS->GetConstValue());
+      if (crMulOpnds.size() == kNumOpnds) {
+        return crMulOpnds[0];
+      }
+      crMulOpnds.erase(crMulOpnds.cbegin() + 1);
+      constLHS = static_cast<CRConstNode*>(crMulOpnds[0]);
+    }
+    // After merge constCRNode, if crMulOpnds[0] is 1, delete it from crMulOpnds vector
+    // 1 * X -> X
+    if (constLHS->GetConstValue() == 1) {
+      crMulOpnds.erase(crMulOpnds.cbegin());
+      --index;
+    }
+    // After merge constCRNode, if crMulOpnds[0] is 0, return crMulOpnds[0]
+    // 0 * X -> 0
+    if (constLHS->GetConstValue() == 0) {
+      return crMulOpnds[0];
+    }
+    if (crMulOpnds.size() == 1) {
+      return crMulOpnds[0];
+    }
+  }
+
+  // if the crType of operand is CRAddNode, unfold the operand
+  // 2 * (X * Y) -> 2 * X * Y
+  size_t mulCRIndex = index;
+  while (mulCRIndex < crMulOpnds.size() && crMulOpnds[mulCRIndex]->GetCRType() != kCRMulNode) {
+    ++mulCRIndex;
+  }
+  if (mulCRIndex < crMulOpnds.size()) {
+    while (crMulOpnds[mulCRIndex]->GetCRType() == kCRMulNode) {
+      crMulOpnds.insert(crMulOpnds.cend(),
+                        static_cast<CRAddNode*>(crMulOpnds[mulCRIndex])->GetOpnds().cbegin(),
+                        static_cast<CRAddNode*>(crMulOpnds[mulCRIndex])->GetOpnds().cend());
+      crMulOpnds.erase(crMulOpnds.cbegin() + mulCRIndex);
+    }
+    return GetCRMulNode(expr, crMulOpnds);
+  }
+
+  // if the crType of operand is CRAddNode, unfold the operand
+  // 2 * (X + Y) -> 2 * X + 2 * Y
+  if (irMap->GetMIRModule().IsCModule() &&
+      crMulOpnds.size() == kNumOpnds && crMulOpnds[0]->GetCRType() == kCRConstNode &&
+      crMulOpnds[1]->GetCRType() == kCRAddNode && static_cast<CRAddNode*>(crMulOpnds[1])->GetOpndsSize() == kNumOpnds) {
+    auto *addCRNode = static_cast<CRAddNode*>(crMulOpnds[1]);
+    std::vector<CRNode*> currOpndsLHSOfMulNode { crMulOpnds[0], addCRNode->GetOpnd(0) };
+    std::vector<CRNode*> currOpndsRHSOfMulNode { crMulOpnds[0], addCRNode->GetOpnd(1) };
+    CRNode *lhsOfMulNode = GetCRMulNode(nullptr, currOpndsLHSOfMulNode);
+    CRNode *rhsOfMulNode = GetCRMulNode(nullptr, currOpndsRHSOfMulNode);
+    std::vector<CRNode*> crAddOpnds({ lhsOfMulNode, rhsOfMulNode });
+    return GetCRAddNode(expr, crAddOpnds);
+  }
+
+  // if the crType of operand is CRDivNode, simplify the operand
+  // 8 * (X / 4) -> 2 * X
+  if (crMulOpnds.size() > 1 && crMulOpnds[0]->GetCRType() == kCRConstNode) {
+    size_t divCRIndex = index;
+    while (divCRIndex < crMulOpnds.size() && crMulOpnds[divCRIndex]->GetCRType() != kCRDivNode) {
+      ++divCRIndex;
+    }
+    if (divCRIndex < crMulOpnds.size()) {
+      auto *divCRNode = static_cast<CRDivNode*>(crMulOpnds[divCRIndex]);
+      if (divCRNode->GetRHS()->GetCRType() == kCRConstNode) {
+        auto constantOfDivOperand = static_cast<CRConstNode*>(divCRNode->GetRHS())->GetConstValue();
+        auto constantOfMulOperand = static_cast<CRConstNode*>(crMulOpnds[0])->GetConstValue();
+        if (constantOfMulOperand == constantOfDivOperand) {
+          // 8 * (X / 8) -> X
+          crMulOpnds.insert(crMulOpnds.cend(), divCRNode->GetLHS());
+          crMulOpnds.erase(crMulOpnds.cbegin() + divCRIndex);
+          crMulOpnds.erase(crMulOpnds.cbegin());
+          if (crMulOpnds.size() == 1) {
+            return crMulOpnds[0];
+          }
+        } else if (constantOfMulOperand > constantOfDivOperand) {
+          auto rem = constantOfMulOperand % constantOfDivOperand;
+          if (rem == 0) {
+            // 8 * (X / 4) -> X * 2
+            auto res = constantOfMulOperand / constantOfDivOperand;
+            crMulOpnds.insert(crMulOpnds.cend(), divCRNode->GetLHS());
+            crMulOpnds.erase(crMulOpnds.cbegin() + divCRIndex);
+            crMulOpnds.erase(crMulOpnds.cbegin());
+            crMulOpnds.insert(crMulOpnds.cend(), GetOrCreateCRConstNode(nullptr, res));
+          }
+        } else {
+          auto rem = constantOfDivOperand % constantOfMulOperand;
+          if (rem == 0) {
+            // 4 * (X / 8) -> X / 2
+            auto res = constantOfDivOperand / constantOfMulOperand;
+            crMulOpnds.erase(crMulOpnds.cbegin() + divCRIndex);
+            crMulOpnds.erase(crMulOpnds.cbegin());
+            crMulOpnds.insert(crMulOpnds.cend(),
+                              GetOrCreateCRDivNode(nullptr,
+                                                   *divCRNode->GetLHS(),
+                                                   *GetOrCreateCRConstNode(nullptr, res)));
+            if (crMulOpnds.size() == 1) {
+              return crMulOpnds[0];
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // merge cr
+  size_t crIndex = index;
+  while (crIndex < crMulOpnds.size() && crMulOpnds[crIndex]->GetCRType() != kCRNode) {
+    ++crIndex;
+  }
+  if (crIndex < crMulOpnds.size()) {
+    // X * { Y, + , Z } -> { X * Y, + , X * Z }
+    if (crIndex != 0) {
+      std::vector<CRNode*> newCROpnds;
+      CR *currCR = static_cast<CR*>(crMulOpnds[crIndex]);
+      std::vector<CRNode*> crOpnds(crMulOpnds.begin(), crMulOpnds.begin() + crIndex);
+      crMulOpnds.erase(crMulOpnds.cbegin(), crMulOpnds.cbegin() + crIndex);
+      for (size_t i = 0; i < currCR->GetOpndsSize(); ++i) {
+        std::vector<CRNode*> currOpnds(crOpnds);
+        currOpnds.push_back(currCR->GetOpnd(i));
+        CRNode *start = GetCRMulNode(nullptr, currOpnds);
+        newCROpnds.push_back(start);
+      }
+      CR *newCR = static_cast<CR*>(GetOrCreateCR(expr, newCROpnds));
+      if (crMulOpnds.size() == 1) {
+        return static_cast<CRNode*>(newCR);
+      }
+      crMulOpnds[0] = static_cast<CRNode*>(newCR);
+      crIndex = 0;
+    }
+    // { X1 , + , Y1,  + , ... , + , Z1 } * { X2 , + , Y2, + , ... , + , Z2 }
+    // ->
+    // { X1 + X2, + , Y1 + Y2, + , ... , + , Z1 + Z2 }
+    ++crIndex;
+    while (crIndex < crMulOpnds.size() && crMulOpnds[crIndex]->GetCRType() == kCRNode) {
+      return GetOrCreateCRMulNode(expr, crMulOpnds);
+    }
+    if (crMulOpnds.size() == 1) {
+      return crMulOpnds[0];
+    }
+  }
+  return GetOrCreateCRMulNode(expr, crMulOpnds);
+}
+
+CRNode *LoopScalarAnalysisResult::GetOrCreateCRMulNode(MeExpr *expr, const std::vector<CRNode*> &crMulNodes) {
+  std::unique_ptr<CRMulNode> crMul = std::make_unique<CRMulNode>(expr);
+  CRMulNode *crMulPtr = crMul.get();
+  allCRNodes.insert(std::move(crMul));
+  crMulPtr->SetOpnds(crMulNodes);
+  return crMulPtr;
+}
+
+CRNode *LoopScalarAnalysisResult::GetOrCreateCRDivNode(MeExpr *expr, CRNode &lhsCRNode, CRNode &rhsCRNode) {
+  if (lhsCRNode.GetCRType() == kCRConstNode && rhsCRNode.GetCRType() == kCRConstNode) {
+    CRConstNode *lhsConst = static_cast<CRConstNode*>(&lhsCRNode);
+    CRConstNode *rhsConst = static_cast<CRConstNode*>(&rhsCRNode);
+    CHECK_FATAL(rhsConst->GetConstValue() != 0, "rhs is zero");
+    if (lhsConst->GetConstValue() % rhsConst->GetConstValue() == 0) {
+      std::unique_ptr<CRConstNode> constNode =
+          std::make_unique<CRConstNode>(expr, lhsConst->GetConstValue() / rhsConst->GetConstValue());
+      CRConstNode *constPtr = constNode.get();
+      allCRNodes.insert(std::move(constNode));
+      return constPtr;
+    }
+  }
+  std::unique_ptr<CRDivNode> divNode = std::make_unique<CRDivNode>(expr, lhsCRNode, rhsCRNode);
+  CRDivNode *divPtr = divNode.get();
+  allCRNodes.insert(std::move(divNode));
+  return divPtr;
+}
+
+// -expr => -1 * expr
+CRNode *LoopScalarAnalysisResult::ChangeNegative2MulCRNode(CRNode &crNode) {
+  std::unique_ptr<CRConstNode> constNode = std::make_unique<CRConstNode>(nullptr, -1);
+  CRConstNode *constPtr = constNode.get();
+  allCRNodes.insert(std::move(constNode));
+  std::vector<CRNode*> crMulNodes;
+  crMulNodes.push_back(constPtr);
+  crMulNodes.push_back(&crNode);
+  return GetCRMulNode(nullptr, crMulNodes);
+}
+
+
+CR *LoopScalarAnalysisResult::AddCRWithCR(CR &lhsCR, CR &rhsCR) {
+  std::unique_ptr<CR> cr = std::make_unique<CR>(nullptr);
+  CR *crPtr = cr.get();
+  allCRNodes.insert(std::move(cr));
+  size_t len = lhsCR.GetOpndsSize() < rhsCR.GetOpndsSize() ? lhsCR.GetOpndsSize() : rhsCR.GetOpndsSize();
+  std::vector<CRNode*> crOpnds;
+  size_t i = 0;
+  for (; i < len; ++i) {
+    std::vector<CRNode*> crAddOpnds{lhsCR.GetOpnd(i), rhsCR.GetOpnd(i)};
+    auto *tempCRNode = GetCRAddNode(nullptr, crAddOpnds);
+    if (tempCRNode != nullptr && tempCRNode->GetCRType() == kCRConstNode &&
+        static_cast<CRConstNode*>(tempCRNode)->GetConstValue() == 0) {
+      continue;
+    }
+    crOpnds.push_back(tempCRNode);
+  }
+  if (i < lhsCR.GetOpndsSize()) {
+    crOpnds.insert(crOpnds.cend(), lhsCR.GetOpnds().begin() + i, lhsCR.GetOpnds().end());
+  } else if (i < rhsCR.GetOpndsSize()) {
+    crOpnds.insert(crOpnds.cend(), rhsCR.GetOpnds().begin() + i, rhsCR.GetOpnds().end());
+  }
+  crPtr->SetOpnds(crOpnds);
+  return crPtr;
+}
+
+// support later
+CR *LoopScalarAnalysisResult::MulCRWithCR(const CR &lhsCR, const CR &rhsCR) const {
+  CHECK_FATAL(lhsCR.GetCRType() == kCRNode, "must be kCRNode");
+  CHECK_FATAL(rhsCR.GetCRType() == kCRNode, "must be kCRNode");
+  CHECK_FATAL(false, "NYI");
+}
+
+CRNode *LoopScalarAnalysisResult::ComputeCRNodeWithOperator(MeExpr &expr, CRNode &lhsCRNode,
+                                                            CRNode &rhsCRNode, Opcode op) {
+  switch (op) {
+    case OP_add: {
+      std::vector<CRNode*> crAddNodes;
+      crAddNodes.push_back(&lhsCRNode);
+      crAddNodes.push_back(&rhsCRNode);
+      return GetCRAddNode(&expr, crAddNodes);
+    }
+    case OP_sub: {
+      std::vector<CRNode*> crAddNodes;
+      crAddNodes.push_back(&lhsCRNode);
+      crAddNodes.push_back(ChangeNegative2MulCRNode(rhsCRNode));
+      return GetCRAddNode(&expr, crAddNodes);
+    }
+    case OP_mul: {
+      std::vector<CRNode*> crMulNodes;
+      crMulNodes.push_back(&lhsCRNode);
+      crMulNodes.push_back(&rhsCRNode);
+      return GetCRMulNode(&expr, crMulNodes);
+    }
+    case OP_div: {
+      return GetOrCreateCRDivNode(&expr, lhsCRNode, rhsCRNode);
+    }
+    default:
+      return nullptr;
+  }
+}
+
+bool LoopScalarAnalysisResult::HasUnknownCRNode(CRNode &crNode, CRNode *&result) {
+  switch (crNode.GetCRType()) {
+    case kCRConstNode: {
+      return false;
+    }
+    case kCRVarNode: {
+      return false;
+    }
+    case kCRAddNode: {
+      CRAddNode *crAddNode = static_cast<CRAddNode*>(&crNode);
+      CHECK_FATAL(crAddNode->GetOpndsSize() > 1, "crAddNode must has more than one opnd");
+      for (size_t i = 0; i < crAddNode->GetOpndsSize(); ++i) {
+        if (HasUnknownCRNode(*crAddNode->GetOpnd(i), result)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    case kCRMulNode: {
+      CRMulNode *crMulNode = static_cast<CRMulNode*>(&crNode);
+      CHECK_FATAL(crMulNode->GetOpndsSize() > 1, "crMulNode must has more than one opnd");
+      for (size_t i = 0; i < crMulNode->GetOpndsSize(); ++i) {
+        if (HasUnknownCRNode(*crMulNode->GetOpnd(i), result)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    case kCRDivNode: {
+      CRDivNode *crDivNode = static_cast<CRDivNode*>(&crNode);
+      return HasUnknownCRNode(*crDivNode->GetLHS(), result) || HasUnknownCRNode(*crDivNode->GetLHS(), result);
+    }
+    case kCRNode: {
+      CR *cr = static_cast<CR*>(&crNode);
+      CHECK_FATAL(cr->GetOpndsSize() > 1, "cr must has more than one opnd");
+      for (size_t i = 0; i < cr->GetOpndsSize(); ++i) {
+        if (HasUnknownCRNode(*cr->GetOpnd(i), result)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    case kCRUnKnown:
+      result = &crNode;
+      return true;
+    default:
+      CHECK_FATAL(false, "impossible !");
+  }
+  return true;
+}
+
+// a = phi(b, c)
+// c = a + d
+// b and d is loopInvarirant
+CRNode *LoopScalarAnalysisResult::CreateSimpleCRForPhi(MePhiNode &phiNode,
+                                                       VarMeExpr &startExpr, const VarMeExpr &backEdgeExpr) {
+  if (loop == nullptr) {
+    return nullptr;
+  }
+  if (backEdgeExpr.GetDefBy() != kDefByStmt) {
+    return nullptr;
+  }
+  MeExpr *rhs = backEdgeExpr.GetDefStmt()->GetRHS();
+  if (rhs == nullptr) {
+    return nullptr;
+  }
+  if (rhs->GetMeOp() == kMeOpConst && startExpr.GetDefBy() == kDefByStmt) {
+    MeExpr *rhs2 = startExpr.GetDefStmt()->GetRHS();
+    if (rhs2->GetMeOp() == kMeOpConst &&
+        (static_cast<ConstMeExpr*>(rhs)->GetExtIntValue() == static_cast<ConstMeExpr*>(rhs2)->GetExtIntValue())) {
+      return GetOrCreateLoopInvariantCR(*rhs);
+    }
+  }
+  if (rhs->GetMeOp() != kMeOpOp || static_cast<OpMeExpr*>(rhs)->GetOp() != OP_add) {
+    return nullptr;
+  }
+  OpMeExpr *opMeExpr = static_cast<OpMeExpr*>(rhs);
+  MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+  MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+  CRNode *stride = nullptr;
+  MeExpr *strideExpr = nullptr;
+  if (opnd1->GetMeOp() == kMeOpVar && static_cast<VarMeExpr*>(opnd1)->GetDefBy() == kDefByPhi &&
+      &(static_cast<VarMeExpr*>(opnd1)->GetDefPhi()) == &phiNode) {
+    strideExpr = opnd2;
+  } else if (opnd2->GetMeOp() == kMeOpVar && static_cast<VarMeExpr*>(opnd2)->GetDefBy() == kDefByPhi &&
+             &(static_cast<VarMeExpr*>(opnd2)->GetDefPhi()) == &phiNode) {
+    strideExpr = opnd1;
+  }
+  if (strideExpr == nullptr) {
+    return nullptr;
+  }
+  switch (strideExpr->GetMeOp()) {
+    case kMeOpConst: {
+      stride = GetOrCreateLoopInvariantCR(*strideExpr);
+      break;
+    }
+    case kMeOpVar: {
+      if (static_cast<VarMeExpr*>(strideExpr)->DefByBB() != nullptr &&
+          !loop->Has(*static_cast<VarMeExpr*>(strideExpr)->DefByBB())) {
+        stride = GetOrCreateLoopInvariantCR(*strideExpr);
+      }
+      break;
+    }
+    case kMeOpIvar: {
+      if (static_cast<IvarMeExpr*>(strideExpr)->GetDefStmt() != nullptr &&
+          static_cast<IvarMeExpr*>(strideExpr)->GetDefStmt()->GetBB() != nullptr &&
+          !loop->Has(*static_cast<IvarMeExpr*>(strideExpr)->GetDefStmt()->GetBB())) {
+        stride = GetOrCreateLoopInvariantCR(*strideExpr);
+      }
+      break;
+    }
+    default: {
+      return nullptr;
+    }
+  }
+  if (stride == nullptr) {
+    return nullptr;
+  }
+  CRNode *start = GetOrCreateLoopInvariantCR(startExpr);
+  return GetOrCreateCR(*phiNode.GetLHS(), *start, *stride);
+}
+
+CRNode *LoopScalarAnalysisResult::CreateCRForPhi(MePhiNode &phiNode) {
+  if (loop == nullptr) {
+    return nullptr;
+  }
+  auto *opnd1 = static_cast<VarMeExpr*>(phiNode.GetOpnd(0));
+  auto *opnd2 = static_cast<VarMeExpr*>(phiNode.GetOpnd(1));
+  VarMeExpr *startExpr = nullptr;
+  VarMeExpr *backEdgeExpr = nullptr;
+  if (opnd1->DefByBB() == nullptr || opnd2->DefByBB() == nullptr) {
+    return nullptr;
+  }
+  if (!loop->Has(*opnd1->DefByBB()) && loop->Has(*opnd2->DefByBB())) {
+    startExpr = opnd1;
+    backEdgeExpr = opnd2;
+  } else if (loop->Has(*opnd1->DefByBB()) && !loop->Has(*opnd2->DefByBB())) {
+    startExpr = opnd2;
+    backEdgeExpr = opnd1;
+  } else {
+    return nullptr;
+  }
+  if (startExpr == nullptr || backEdgeExpr == nullptr) {
+    return nullptr;
+  }
+  if (auto *cr = CreateSimpleCRForPhi(phiNode, *startExpr, *backEdgeExpr)) {
+    return cr;
+  }
+  std::unique_ptr<CRUnKnownNode> phiUnKnown = std::make_unique<CRUnKnownNode>(static_cast<MeExpr*>(phiNode.GetLHS()));
+  CRUnKnownNode *phiUnKnownPtr = phiUnKnown.get();
+  allCRNodes.insert(std::move(phiUnKnown));
+  InsertExpr2CR(*(static_cast<MeExpr*>(phiNode.GetLHS())), static_cast<CRNode*>(phiUnKnownPtr));
+  CRNode *backEdgeCRNode = GetOrCreateCRNode(*backEdgeExpr);
+  if (backEdgeCRNode == nullptr) {
+    InsertExpr2CR(*(static_cast<MeExpr*>(phiNode.GetLHS())), nullptr);
+    return nullptr;
+  }
+  if (backEdgeCRNode->GetCRType() == kCRAddNode) {
+    size_t index = static_cast<CRAddNode*>(backEdgeCRNode)->GetOpndsSize() + 1;
+    for (size_t i = 0; i < static_cast<CRAddNode*>(backEdgeCRNode)->GetOpndsSize(); ++i) {
+      if (static_cast<CRAddNode*>(backEdgeCRNode)->GetOpnd(i) == phiUnKnownPtr) {
+        index = i;
+        break;
+      }
+    }
+    if (index == (static_cast<CRAddNode*>(backEdgeCRNode)->GetOpndsSize() + 1)) {
+      InsertExpr2CR(*(static_cast<MeExpr*>(phiNode.GetLHS())), nullptr);
+      return nullptr;
+    }
+    std::vector<CRNode*> crNodes;
+    for (size_t i = 0; i < static_cast<CRAddNode*>(backEdgeCRNode)->GetOpndsSize(); ++i) {
+      if (i != index) {
+        crNodes.push_back(static_cast<CRAddNode*>(backEdgeCRNode)->GetOpnd(i));
+      }
+    }
+    CRNode *start = GetOrCreateLoopInvariantCR(*(static_cast<MeExpr*>(startExpr)));
+    CRNode *stride = GetCRAddNode(nullptr, crNodes);
+    if (stride == nullptr) {
+      InsertExpr2CR(*(static_cast<MeExpr*>(phiNode.GetLHS())), nullptr);
+      return nullptr;
+    }
+    CRNode *crNode = nullptr;
+    if (HasUnknownCRNode(*stride, crNode)) {
+      CHECK_NULL_FATAL(crNode);
+      CHECK_FATAL(crNode->GetCRType() == kCRUnKnown, "must be kCRUnKnown!");
+      InsertExpr2CR(*(static_cast<MeExpr*>(phiNode.GetLHS())), nullptr);
+      return nullptr;
+    }
+    CR *cr = static_cast<CR*>(GetOrCreateCR(*phiNode.GetLHS(), *start, *stride));
+    return cr;
+  } else {
+    InsertExpr2CR(*(static_cast<MeExpr*>(phiNode.GetLHS())), nullptr);
+    return nullptr;
+  }
+}
+
+CRNode *LoopScalarAnalysisResult::DealWithMeOpOp(MeExpr &currOpMeExpr, MeExpr &expr) {
+  OpMeExpr &opMeExpr = static_cast<OpMeExpr&>(currOpMeExpr);
+  switch (opMeExpr.GetOp()) {
+    case OP_add:
+    case OP_sub:
+    case OP_mul:
+    case OP_div: {
+      CHECK_FATAL(opMeExpr.GetNumOpnds() == kNumOpnds, "must be");
+      MeExpr *opnd1 = opMeExpr.GetOpnd(0);
+      MeExpr *opnd2 = opMeExpr.GetOpnd(1);
+      CRNode *lhsCR = GetOrCreateCRNode(*opnd1);
+      CRNode *rhsCR = GetOrCreateCRNode(*opnd2);
+      if (lhsCR == nullptr || rhsCR == nullptr) {
+        return nullptr;
+      }
+      return ComputeCRNodeWithOperator(expr, *lhsCR, *rhsCR, opMeExpr.GetOp());
+    }
+    case OP_cvt: {
+      if (!computeTripCountForLoopUnroll) {
+        return GetOrCreateCRNode(*opMeExpr.GetOpnd(0));
+      }
+      auto toType = opMeExpr.GetPrimType();
+      auto fromType = opMeExpr.GetOpndType();
+      if (GetPrimTypeBitSize(toType) > GetPrimTypeBitSize(fromType) && IsUnsignedInteger(fromType)) {
+        return nullptr;
+      }
+      return GetOrCreateCRNode(*opMeExpr.GetOpnd(0));
+    }
+    case OP_zext: {
+      if (!computeTripCountForLoopUnroll) {
+        return GetOrCreateCRNode(*opMeExpr.GetOpnd(0));
+      }
+      InsertExpr2CR(expr, nullptr);
+      return nullptr;
+    }
+    case OP_iaddrof: {
+      return GetOrCreateCRNode(*opMeExpr.GetOpnd(0));
+    }
+    case OP_rem: {
+      return GetOrCreateCRVarNode(expr);
+    }
+    default:
+      InsertExpr2CR(expr, nullptr);
+      return nullptr;
+  }
+}
+
+CRNode *LoopScalarAnalysisResult::GetOrCreateCRNode(MeExpr &expr) {
+  if (IsAnalysised(expr)) {
+    return expr2CR[&expr];
+  }
+  // Only support expr is kMeOpConst, kMeOpVar, kMeOpIvar
+  switch (expr.GetMeOp()) {
+    case kMeOpConst: {
+      return GetOrCreateLoopInvariantCR(expr);
+    }
+    case kMeOpVar:
+    case kMeOpReg: {
+      ScalarMeExpr *scalar = static_cast<ScalarMeExpr*>(&expr);
+      if (scalar->IsVolatile()) {
+        // volatile variable can not find real def pos, skip it
+        InsertExpr2CR(expr, nullptr);
+        return nullptr;
+      }
+      if (scalar->DefByBB() != nullptr && loop != nullptr && !loop->Has(*scalar->DefByBB())) {
+        return GetOrCreateLoopInvariantCR(expr);
+      }
+      switch (scalar->GetDefBy()) {
+        case kDefByStmt: {
+          MeExpr *rhs = scalar->GetDefStmt()->GetRHS();
+          switch (rhs->GetMeOp()) {
+            case kMeOpVar: {
+              return GetOrCreateCRNode(*rhs);
+            }
+            case kMeOpOp: {
+              return DealWithMeOpOp(*rhs, expr);
+            }
+            default:
+              return GetOrCreateLoopInvariantCR(*rhs);
+          }
+        }
+        case kDefByPhi: {
+          if (!computeTripCountForLoopUnroll) {
+            return GetOrCreateCRVarNode(expr);
+          }
+          MePhiNode *phiNode = &(scalar->GetDefPhi());
+          if (phiNode->GetOpnds().size() == kNumOpnds) {
+            return CreateCRForPhi(*phiNode);
+          } else {
+            InsertExpr2CR(expr, nullptr);
+            return nullptr;
+          }
+        }
+        default:
+          return GetOrCreateLoopInvariantCR(expr);
+      }
+    }
+    case kMeOpOp: {
+      return DealWithMeOpOp(expr, expr);
+    }
+    default:
+      return GetOrCreateLoopInvariantCR(expr);
+  }
+}
+
+bool IsLegal(MeStmt &meStmt) {
+  CHECK_FATAL(meStmt.IsCondBr(), "must be");
+  auto *brMeStmt = static_cast<CondGotoMeStmt*>(&meStmt);
+  MeExpr *meCmp = brMeStmt->GetOpnd();
+  if (meCmp->GetMeOp() != kMeOpOp) {
+    return false;
+  }
+  auto *opMeExpr = static_cast<OpMeExpr*>(meCmp);
+  if (opMeExpr->GetNumOpnds() != kNumOpnds) {
+    return false;
+  }
+  if (opMeExpr->GetOp() != OP_ge && opMeExpr->GetOp() != OP_le &&
+      opMeExpr->GetOp() != OP_lt && opMeExpr->GetOp() != OP_gt &&
+      opMeExpr->GetOp() != OP_eq && opMeExpr->GetOp() != OP_ne) {
+    return false;
+  }
+  MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+  MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+  if (!IsPrimitivePureScalar(opnd1->GetPrimType()) || !IsPrimitivePureScalar(opnd2->GetPrimType())) {
+    return false;
+  }
+  return true;
+}
+
+
+// need consider min and max integer
+uint32 LoopScalarAnalysisResult::ComputeTripCountWithCR(const CR &cr, const OpMeExpr &opMeExpr, int32 value) {
+  uint32 tripCount = 0;
+  for (uint32 i = 0; ; ++i) {
+    CRNode *result = cr.ComputeValueAtIteration(i, *this);
+    switch (opMeExpr.GetOp()) {
+      case OP_ge: { // <
+        if (static_cast<CRConstNode*>(result)->GetConstValue() < value) {
+          ++tripCount;
+        } else {
+          return tripCount;
+        }
+        break;
+      }
+      case OP_le: {
+        if (static_cast<CRConstNode*>(result)->GetConstValue() > value) {
+          ++tripCount;
+        } else {
+          return tripCount;
+        }
+        break;
+      }
+      case OP_gt: { // <=
+        if (static_cast<CRConstNode*>(result)->GetConstValue() <= value) {
+          ++tripCount;
+        } else {
+          return tripCount;
+        }
+        break;
+      }
+      case OP_lt: {
+        if (static_cast<CRConstNode*>(result)->GetConstValue() >= value) {
+          ++tripCount;
+        } else {
+          return tripCount;
+        }
+        break;
+      }
+      case OP_eq: {
+        if (static_cast<CRConstNode*>(result)->GetConstValue() != value) {
+          ++tripCount;
+        } else {
+          return tripCount;
+        }
+        break;
+      }
+      default:
+        CHECK_FATAL(false, "operator must be >=, <=, >, <, !=");
+    }
+  }
+}
+
+uint64 LoopScalarAnalysisResult::ComputeTripCountWithSimpleConstCR(Opcode op, bool isSigned, int64 value,
+                                                                   int64 start, int64 stride) const {
+  CHECK_FATAL(stride != 0, "stride must not be zero");
+  int64 times = (value - start) / stride;
+  if (times < 0) {
+    return kInvalidTripCount;
+  }
+  uint64 remainder = static_cast<uint64>((value - start) % stride);
+  switch (op) {
+    case OP_ge: {
+      if (isSigned && start < value) { return 0; }
+      if (!isSigned && static_cast<uint64>(start) < static_cast<uint64>(value)) { return 0; }
+      // consider if there's overflow
+      if (stride > 0) {
+        if (isSigned ||  // undefined overflow
+            value == 0 || value < stride ||  // infinite loop
+            remainder != 0) {  // not common case, just skip
+          return kInvalidTripCount;
+        }
+        // change to "i <= umax" to compute
+        return ComputeTripCountWithSimpleConstCR(OP_le, false, -1, start, stride);
+      }
+      return static_cast<uint64>(times + 1);
+    }
+    case OP_gt: {
+      if (isSigned && start <= value) { return 0; }
+      if (!isSigned && static_cast<uint64>(start) <= static_cast<uint64>(value)) { return 0; }
+      // consider if there's overflow
+      if (stride > 0) {
+        if (isSigned ||  // undefined overflow
+            remainder != 0) {  // not common case, just skip
+          return kInvalidTripCount;
+        }
+        // change to "i <= umax" to compute
+        return ComputeTripCountWithSimpleConstCR(OP_le, false, -1, start, stride);
+      }
+      return static_cast<uint64>(times + (remainder != 0));
+    }
+    case OP_le: {
+      if (isSigned && start > value) { return 0; }
+      if (!isSigned && static_cast<uint64>(start) > static_cast<uint64>(value)) { return 0; }
+      // consider if there's underflow
+      if (stride < 0) {
+        if (isSigned ||  // undefined underflow
+            value == -1 || static_cast<uint64>(value) >= static_cast<uint64>(stride) ||  // infinite loop
+            remainder != 0) {  // not common case, just skip
+          return kInvalidTripCount;
+        }
+        // change to "i >= 0" to compute
+        return ComputeTripCountWithSimpleConstCR(OP_ge, false, 0, start, stride);
+      }
+      return static_cast<uint64>(times + 1);
+    }
+    case OP_lt: {
+      if (isSigned && start >= value) { return 0; }
+      if (!isSigned && static_cast<uint64>(start) >= static_cast<uint64>(value)) { return 0; }
+      // consider if there's underflow
+      if (stride < 0) {
+        if (isSigned ||  // undefined underflow
+            remainder != 0) {  // not common case, just skip
+          return kInvalidTripCount;
+        }
+        // change to "i >= 0" to compute
+        return ComputeTripCountWithSimpleConstCR(OP_ge, false, 0, start, stride);
+      }
+      return static_cast<uint64>(times + static_cast<uint>(remainder != 0));
+    }
+    case OP_eq: {
+      if (start != value) { return 0; }
+      return 1;
+    }
+    case OP_ne: {
+      if (start == value) { return 0; }
+      if (remainder != 0) { return kInvalidTripCount; }  // infinite loop
+      if (stride < 0) {
+        // consider if there's underflow
+        if (isSigned && start < value) { return kInvalidTripCount; }  // undefined underflow
+      } else {
+        // consider if there's overflow
+        if (isSigned && start > value) { return kInvalidTripCount; }  // undefined overflow
+      }
+      return static_cast<uint64>(times);
+    }
+    default:
+      CHECK_FATAL(false, "operator must be >=, <=, >, <, !=, ==");
+  }
+}
+
+void LoopScalarAnalysisResult::SortOperatorCRNode(std::vector<CRNode*> &crNodeOperands, MeExpr &addrExpr) {
+  for (auto &opnd : crNodeOperands) {
+    (void)SortCROperand(*opnd, addrExpr);
+  }
+}
+
+void LoopScalarAnalysisResult::PutTheAddrExprAtTheFirstOfVector(
+    std::vector<CRNode*> &crNodeOperands, const MeExpr &addrExpr) {
+  if (crNodeOperands.size() >= 1 && crNodeOperands[0]->GetExpr() == &addrExpr) {
+    return;
+  }
+  bool find = false;
+  CRNode *crNode = nullptr;
+  for (auto it = crNodeOperands.begin(); it != crNodeOperands.end();) {
+    if ((*it)->GetCRType() != kCRVarNode) {
+      ++it;
+      continue;
+    }
+    if ((*it)->GetExpr() == &addrExpr) {
+      find = true;
+      crNode = *it;
+      it = crNodeOperands.erase(it);
+      break;
+    }
+    ++it;
+  }
+  if (find) {
+    crNodeOperands.insert(crNodeOperands.cbegin(), crNode);
+  }
+}
+
+CRNode &LoopScalarAnalysisResult::SortCROperand(CRNode &crNode, MeExpr &addrExpr) {
+  switch (crNode.GetCRType()) {
+    case kCRAddNode: {
+      auto &crNodeOperands = static_cast<CRAddNode&>(crNode).GetOpnds();
+      std::sort(crNodeOperands.begin(), crNodeOperands.end(), CompareCRNodeWithReverseOrderOfCRType());
+      SortOperatorCRNode(crNodeOperands, addrExpr);
+      PutTheAddrExprAtTheFirstOfVector(crNodeOperands, addrExpr);
+      break;
+    }
+    case kCRMulNode: {
+      auto &crNodeOperands = static_cast<CRAddNode&>(crNode).GetOpnds();
+      std::sort(crNodeOperands.begin(), crNodeOperands.end(), CompareCRNodeWithReverseOrderOfCRType());
+      SortOperatorCRNode(crNodeOperands, addrExpr);
+      break;
+    }
+    default:
+      break;
+  }
+  return crNode;
+}
+
+void LoopScalarAnalysisResult::DumpTripCount(const CR &cr, int32 value, const MeExpr *expr) {
+  LogInfo::MapleLogger() << "==========Dump CR=========\n";
+  Dump(cr);
+  if (expr == nullptr) {
+    LogInfo::MapleLogger() << "\n" << "value: " << value << "\n";
+  } else {
+    LogInfo::MapleLogger() << "\n" << "value: mx_" << expr->GetExprID() << "\n";
+  }
+
+  VerifyCR(cr);
+  LogInfo::MapleLogger() << "==========Dump CR End=========\n";
+}
+
+TripCountType LoopScalarAnalysisResult::ComputeTripCount(const MeFunction &func, uint64 &tripCountResult,
+                                                         CRNode *&conditionCRNode, CR *&itCR) {
+  if (loop == nullptr) {
+    return kCouldNotComputeCR;
+  }
+  enableDebug = false;
+  BB *exitBB = func.GetCfg()->GetBBFromID(loop->inloopBB2exitBBs.begin()->first);
+  if (exitBB->GetKind() == kBBCondGoto && IsLegal(*(exitBB->GetLastMe()))) {
+    auto *brMeStmt = static_cast<CondGotoMeStmt*>(exitBB->GetLastMe());
+    BB *brTarget = exitBB->GetSucc(1);
+    CHECK_FATAL(brMeStmt->GetOffset() == brTarget->GetBBLabel(), "must be");
+    auto *opMeExpr = static_cast<OpMeExpr*>(brMeStmt->GetOpnd());
+    Opcode op = OP_undef;
+    if (loop->Has(*exitBB->GetSucc(0)) && !loop->Has(*exitBB->GetSucc(1))) {
+      op = (brMeStmt->GetOp() == OP_brtrue) ? GetReverseCmpOp(opMeExpr->GetOp()) : opMeExpr->GetOp();
+    } else if (loop->Has(*exitBB->GetSucc(1)) && !loop->Has(*exitBB->GetSucc(0))) {
+      op = (brMeStmt->GetOp() == OP_brtrue) ? opMeExpr->GetOp() : GetReverseCmpOp(opMeExpr->GetOp());
+    } else {
+      return kCouldNotComputeCR;
+    }
+    MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+    MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+    if (!IsPrimitiveInteger(opMeExpr->GetOpndType())) {
+      return kCouldNotComputeCR;
+    }
+    CRNode *crNode1 = GetOrCreateCRNode(*opnd1);
+    CRNode *crNode2 = GetOrCreateCRNode(*opnd2);
+    CR *cr = nullptr;
+    CRConstNode *constNode = nullptr;
+    if (crNode1 != nullptr && crNode2 != nullptr) {
+      if (crNode1->GetCRType() == kCRNode && crNode2->GetCRType() == kCRConstNode) {
+        cr = static_cast<CR*>(crNode1);
+        constNode = static_cast<CRConstNode*>(crNode2);
+      } else if (crNode2->GetCRType() == kCRNode && crNode1->GetCRType() == kCRConstNode) {
+        cr = static_cast<CR*>(crNode2);
+        constNode = static_cast<CRConstNode*>(crNode1);
+      } else if (crNode1->GetCRType() == kCRNode && crNode2->GetCRType() == kCRNode) {
+        return kCouldNotUnroll; // can not compute tripcount
+      } else if (crNode1->GetCRType() == kCRNode || crNode2->GetCRType() == kCRNode) {
+        if (crNode1->GetCRType() == kCRNode) {
+          conditionCRNode = crNode2;
+          itCR = static_cast<CR*>(crNode1);
+        } else if (crNode2->GetCRType() == kCRNode) {
+          conditionCRNode = crNode1;
+          itCR = static_cast<CR*>(crNode2);
+        } else {
+          CHECK_FATAL(false, "impossible");
+        }
+        if (enableDebug) {
+          DumpTripCount(*itCR, 0, conditionCRNode->GetExpr());
+        }
+        return kVarCondition;
+      } else {
+        return kCouldNotComputeCR;
+      }
+    } else {
+      return kCouldNotComputeCR;
+    }
+    if (enableDebug) {
+      DumpTripCount(*cr, static_cast<int32>(constNode->GetConstValue()), nullptr);
+    }
+    for (auto opnd : cr->GetOpnds()) {
+      if (opnd->GetCRType() != kCRConstNode) {
+        conditionCRNode = constNode;
+        itCR = cr;
+        return kVarCR;
+      }
+    }
+    CHECK_FATAL(cr->GetOpndsSize() > 1, "impossible");
+    if (cr->GetOpndsSize() == 2) { // cr has two opnds like {1, + 1}
+      if (crNode1->GetCRType() == kCRConstNode) {
+        // swap comparison to make const always being right
+        op = op == OP_ge ? OP_le
+                         : op == OP_le ? OP_ge
+                                       : op == OP_lt ? OP_gt
+                                                     : op == OP_gt ? OP_lt
+                                                                   : op;
+      }
+      tripCountResult = ComputeTripCountWithSimpleConstCR(op, IsSignedInteger(opMeExpr->GetOpndType()),
+                                                          constNode->GetConstValue(),
+                                                          static_cast<CRConstNode*>(cr->GetOpnd(0))->GetConstValue(),
+                                                          static_cast<CRConstNode*>(cr->GetOpnd(1))->GetConstValue());
+      return (tripCountResult == 0) ? kCouldNotUnroll : kConstCR;
+    } else {
+      return kCouldNotComputeCR;
+    }
+  }
+  return kCouldNotUnroll;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_side_effect.cpp b/src/mapleall/maple_me/src/me_side_effect.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c65de6677ab72df3bee19a7e89971e76f0035d77
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_side_effect.cpp
@@ -0,0 +1,1141 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_side_effect.h"
+#include "me_function.h"
+#include "ver_symbol.h"
+#include "me_ir.h"
+#include "me_irmap.h"
+#include "me_phase_manager.h"
+#include "ipa_option.h"
+
+// IPA sideeffect analysis
+// Default value:
+//   Mirfunc->attribute: not Pure, defArg, def, return Global, throw eh, return Arg, def private
+//   ipasideeffect.cpp:  pure, no defArg, no Def, no Return Global, no throw eh, no return Arg, no def private
+// For a close environment which consists of many modules:
+// 1. Focus on Pure, DefGlobal, DefArg, ThrowException
+// 2. Build SCC in one function, propgate Arg or Global attribute
+// For a open environment with decouple and dynamic class load:
+using namespace maple;
+namespace {
+const FuncWithSideEffect kMrtList[] {
+#include "mrt_info.def"
+};
+size_t mrtListSz = 0;
+std::map<PUIdx, uint8> mrtPuIdx;
+// keep track of union of all side effects in a SCC
+std::map<uint32, uint8> sccSe;
+const SCCNode<CGNode> *currSccNode = nullptr;
+size_t cgNodeCount = 0;
+}
+
+namespace maple {
+IpaSideEffect::IpaSideEffect(MeFunction &mf, MemPool *memPool, CallGraph &callGraph, Dominance &dom)
+    : isSeen(false),
+      notPure(false),
+      hasDefArg(false),
+      hasDef(false),
+      hasRetGlobal(false),
+      hasThrException(false),
+      hasRetArg(false),
+      hasPrivateDef(false),
+      isGlobal(false),
+      isArg(false),
+      meFunc(mf),
+      alloc(memPool),
+      callGraph(callGraph),
+      sccId(0),
+      dominance(dom) {}
+
+void IpaSideEffect::SetEffectsTrue() {
+  notPure = true;
+  hasDefArg = true;
+  hasDef = true;
+  hasRetGlobal = true;
+  hasThrException = true;
+  hasRetArg = true;
+  hasPrivateDef = true;
+}
+
+bool IpaSideEffect::IsIgnoreMethod(const MIRFunction &func) {
+  // Ignore if virtual or no method
+  if (func.IsAbstract()) {
+    return true;
+  }
+  Klass *klass = callGraph.GetKlassh()->GetKlassFromFunc(&func);
+  if (klass == nullptr) {
+    // An array, must have method, but has all effects
+    SetEffectsTrue();
+    return true;
+  }
+  const auto &methods = klass->GetMethods();
+  return std::find(methods.begin(), methods.end(), &func) == methods.end();
+}
+
+void IpaSideEffect::CopySccSideEffectToAllFunctions(SCCNode<CGNode> &scc, uint8 seMask) {
+  // For all members of the SCC, copy the sum of the side effect of SCC to each member func.
+  for (auto &sccIt : scc.GetNodes()) {
+    CGNode *cgNode = sccIt;
+    MIRFunction *func = cgNode->GetMIRFunction();
+    if (mrtPuIdx.find(func->GetPuidx()) != mrtPuIdx.end()) {
+      CHECK_FATAL(false, "Pay attention, manual defined func in a SCC. %s", func->GetName().c_str());
+    }
+    CHECK_FATAL(func->IsIpaSeen(), "Must have been processed.");
+    CHECK_FATAL(func->IsPure() || (seMask & kNotPure) == kNotPure, "Must be true.");
+    CHECK_FATAL(func->IsNoDefEffect() || (seMask & kHasDef) == kHasDef, "Must be true.");
+    CHECK_FATAL(func->IsNoThrowException() || (seMask & kHasThrow) == kHasThrow, "Must be true.");
+    CHECK_FATAL(func->IsNoPrivateDefEffect() || (seMask & kHasPrivateDef) == kHasPrivateDef, "Must be true.");
+    if (seMask & kNotPure) {
+      func->UnsetPure();
+    }
+    if (seMask & kHasDef) {
+      func->UnsetNoDefEffect();
+    }
+    if (seMask & kHasThrow) {
+      func->UnsetNoThrowException();
+    }
+    if (seMask & kHasPrivateDef) {
+      func->UnsetNoPrivateDefEffect();
+    }
+  }
+}
+
+void IpaSideEffect::GetEffectFromCallee(MIRFunction &callee, const MIRFunction &caller) {
+  uint32 calleeScc = GetOrSetSCCNodeId(callee);
+  if (IsCallingIntoSCC(calleeScc)) {
+    // Call graph ensures that all methods in SCC are visited before a call into the SCC.
+    auto it = sccSe.find(calleeScc);
+    CHECK_FATAL(it != sccSe.end(), "Sideeffect of scc must have been set.");
+    uint8 mask = it->second;
+
+    hasDefArg = hasDefArg || (mask & kHasDefArg);
+    hasDef = hasDef || (mask & kHasDef);
+    hasThrException = hasThrException || (mask & kHasThrow);
+    hasRetArg = hasRetArg || (mask & kHasRetArg);
+    hasPrivateDef = hasPrivateDef || (mask & kHasPrivateDef);
+  } else if (callee.IsIpaSeen()) {
+    notPure = notPure || !callee.IsPure();
+    hasDefArg = hasDefArg || !callee.IsNoDefArgEffect();
+    hasDef = hasDef || !callee.IsNoDefEffect();
+    hasRetGlobal = hasRetGlobal || !callee.IsNoRetGlobal();
+    hasThrException = hasThrException || !callee.IsNoThrowException();
+    hasRetArg = hasRetArg || !callee.IsNoRetArg();
+    hasPrivateDef = hasPrivateDef || !callee.IsNoPrivateDefEffect();
+  } else if (!MatchPuidxAndSetSideEffects(callee.GetPuidx())) {
+    // function was not compiled before and it is not one of the predetermined
+    // sideeffect functions, then assume
+    //  - native function : no side effects
+    //  - non-native function : all side effects
+    if (!callee.IsNative()) {
+      SetEffectsTrue();
+      return;
+    }
+    // If the caller and callee are in the same SCC, then its ok, since
+    // the side effect of SCC is the sum of the methods in the SCC. The
+    // side effect of the not yet visited method will be added in the
+    // combined SCC side effects later when it is actually visited.
+    if (callee.GetName() == caller.GetName()) {
+      return;
+    }
+    // !!!!!!!!!!!!MUST PRINT WARNING!!!!!!!!!!!
+    if (calleeScc != sccId && !MeOption::quiet) {
+      LogInfo::MapleLogger() << "WARNING: cross scc default no side effects " << callee.GetName()
+                             << " Native-function\n";
+    }
+  }
+}
+
+bool IpaSideEffect::MEAnalyzeDefExpr(MeExpr &baseExprMe, std::vector<MeExpr*> &varVector) {
+  CHECK_FATAL(baseExprMe.GetOp() == OP_dread, "Must be dread");
+  auto &baseExpr = static_cast<VarMeExpr&>(baseExprMe);
+  const OriginalSt *ostSymbol = meFunc.GetMeSSATab()->GetOriginalStFromID(baseExpr.GetOstIdx());
+  if (!ostSymbol->IsLocal()) {
+    return true;
+  }
+  switch (baseExpr.GetDefBy()) {
+    case kDefByStmt: {
+      if (baseExpr.GetDefStmt() == nullptr) {
+        return true;
+      }
+      MeStmt *defStmt = baseExpr.GetDefStmt();
+      CHECK_FATAL(defStmt->GetOp() == OP_dassign, "Must be dassign");
+      auto *dassignMeStmt = static_cast<DassignMeStmt*>(defStmt);
+      switch (dassignMeStmt->GetRHS()->GetOp()) {
+        case OP_dread: {
+          for (auto it = varVector.begin(); it != varVector.end(); ++it) {
+            // Cycle
+            if (*it == dassignMeStmt->GetRHS()) {
+              return true;
+            }
+          }
+          varVector.push_back(dassignMeStmt->GetRHS());
+          if (MEAnalyzeDefExpr(*dassignMeStmt->GetRHS(), varVector)) {
+            return true;
+          }
+          break;
+        }
+        case OP_gcmallocjarray:
+        case OP_gcmalloc:
+        case OP_constval: {
+          return false;
+        }
+        case OP_iread: {
+          return true;
+        }
+        case OP_cvt:
+        case OP_retype: {
+          auto *node = static_cast<OpMeExpr*>(dassignMeStmt->GetRHS());
+          CHECK_FATAL(node->GetOpnd(0)->GetOp() == OP_dread, "must be dread");
+          for (auto it = varVector.begin(); it != varVector.end(); ++it) {
+            // Cycle
+            if (*it == node->GetOpnd(0)) {
+              return true;
+            }
+          }
+          varVector.push_back(node->GetOpnd(0));
+          if (MEAnalyzeDefExpr(*node->GetOpnd(0), varVector)) {
+            return true;
+          }
+          break;
+        }
+        default:
+          CHECK_FATAL(false, "NYI");
+      }
+      break;
+    }
+    case kDefByPhi: {
+      for (auto *expr : baseExpr.GetDefPhi().GetOpnds()) {
+        if (expr->GetMeOp() != kMeOpVar) {
+          continue;
+        }
+        if (std::find(varVector.begin(), varVector.end(), &baseExpr) != varVector.end()) {
+          return true;
+        }
+        varVector.push_back(expr);
+        if (MEAnalyzeDefExpr(*expr, varVector)) {
+          return true;
+        }
+      }
+      break;
+    }
+    case kDefByChi:
+    case kDefByMustDef: {
+      // Defined symbol is not a global
+      return false;
+    }
+    default: {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Def global variable or formal parameter
+bool IpaSideEffect::AnalyzeDefExpr(VersionSt &baseVar, std::vector<VersionSt*> &varVector) {
+  if (!baseVar.GetOst()->IsLocal()) {
+    return true;
+  }
+  switch (baseVar.GetDefType()) {
+    case VersionSt::kAssign: {
+      if (baseVar.GetAssignNode() == nullptr) {
+        return true;
+      }
+      BaseNode *rhs = baseVar.GetAssignNode()->GetRHS();
+      ASSERT_NOT_NULL(rhs);
+      switch (rhs->GetOpCode()) {
+        case OP_dread: {
+          VersionSt *st = (static_cast<AddrofSSANode*>(rhs))->GetSSAVar();
+          for (auto it = varVector.begin(); it != varVector.end(); ++it) {
+            // Cycle
+            if (*it == st) {
+              return true;
+            }
+          }
+          varVector.push_back(st);
+          if (AnalyzeDefExpr(*st, varVector)) {
+            return true;
+          }
+          break;
+        }
+        case OP_gcmallocjarray:
+        case OP_gcmalloc:
+        case OP_constval: {
+          return false;
+        }
+        case OP_iread: {
+          return true;
+        }
+        case OP_cvt:
+        case OP_retype: {
+          auto *node = static_cast<TypeCvtNode*>(rhs);
+          CHECK_FATAL(node->Opnd(0)->GetOpCode() == OP_dread, "must be dread");
+          VersionSt *st = (static_cast<AddrofSSANode*>(node->Opnd(0)))->GetSSAVar();
+          for (auto it = varVector.begin(); it != varVector.end(); ++it) {
+            // Cycle
+            if (*it == st) {
+              return true;
+            }
+          }
+          varVector.push_back(st);
+          if (AnalyzeDefExpr(*st, varVector)) {
+            return true;
+          }
+          break;
+        }
+        default:
+          CHECK_FATAL(false, "NYI");
+      }
+      break;
+    }
+    // case VersionSt::Regassign:
+    case VersionSt::kPhi: {
+      for (size_t i = 0; i < baseVar.GetPhi()->GetPhiOpnds().size(); ++i) {
+        VersionSt *st = baseVar.GetPhi()->GetPhiOpnd(i);
+        for (auto it = varVector.begin(); it != varVector.end(); ++it) {
+          // Cycle
+          if (*it == st) {
+            return true;
+          }
+        }
+        varVector.push_back(st);
+        if (AnalyzeDefExpr(*st, varVector)) {
+          return true;
+        }
+      }
+      break;
+    }
+    case VersionSt::kMayDef:
+    case VersionSt::kMustDef: {
+      return true;
+    }
+    default: {
+      CHECK_FATAL(false, "NYI");
+      break;
+    }
+  }
+  return false;
+}
+
+bool IpaSideEffect::MatchPuidxAndSetSideEffects(PUIdx idx) {
+  if (idx == 0) {
+    return false;
+  }
+  auto mrtIt = mrtPuIdx.find(idx);
+  if (mrtIt == mrtPuIdx.end()) {
+    return false;
+  }
+  uint8 mrtSe = mrtIt->second;
+  notPure = notPure || !(mrtSe & kPure);
+  hasDefArg = hasDefArg || (mrtSe & kHasDefArg);
+  hasDef = hasDef || (mrtSe & kHasDef);
+  hasRetGlobal = hasRetGlobal || (mrtSe & kHasRetGlobal);
+  hasThrException = hasThrException || (mrtSe & kHasThrow);
+  hasRetArg = hasRetArg || (mrtSe & kHasRetArg);
+  hasPrivateDef = hasPrivateDef || (mrtSe & kHasPrivateDef);
+  return true;
+}
+
+
+bool IpaSideEffect::IsPureFromSummary(const MIRFunction &func) const {
+  const std::string &funcName = func.GetName();
+  return funcName.find("_7ChashCode_7C") != std::string::npos ||
+         funcName.find("_7CgetClass_7C") != std::string::npos ||
+         funcName.find("_7CgetName_7C") != std::string::npos ||
+         funcName.find("_7CtoString_7C") != std::string::npos ||
+         funcName.find("_7CvalueOf_7C") != std::string::npos;
+}
+
+
+void IpaSideEffect::ReadSummary() {
+  if (mrtListSz != 0) {
+    return;
+  }
+  mrtListSz = sizeof(kMrtList) / sizeof(FuncWithSideEffect);
+  for (size_t i = 0; i < mrtListSz; i++) {
+    MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+        GlobalTables::GetStrTable().GetStrIdxFromName(kMrtList[i].GetFuncName()));
+    if (sym != nullptr) {
+      MIRFunction *func = sym->GetFunction();
+      uint8 seMask = 0;
+      if (kMrtList[i].GetPure()) {
+        seMask |= kPure;
+        func->SetPure();
+      }
+      if (kMrtList[i].GetDefArg()) {
+        seMask |= kHasDefArg;
+      } else {
+        func->SetNoDefArgEffect();
+      }
+      if (kMrtList[i].GetDef()) {
+        seMask |= kHasDef;
+      } else {
+        func->SetNoDefEffect();
+      }
+      if (kMrtList[i].GetRetGlobal()) {
+        seMask |= kHasRetGlobal;
+      } else {
+        func->SetNoRetGlobal();
+      }
+      if (kMrtList[i].GetException()) {
+        seMask |= kHasThrow;
+      } else {
+        func->SetNoThrowException();
+      }
+      if (kMrtList[i].GetRetArg()) {
+        seMask |= kHasRetArg;
+      } else {
+        func->SetNoRetArg();
+      }
+      if (kMrtList[i].GetPrivateDef()) {
+        seMask |= kHasPrivateDef;
+      } else {
+        func->SetNoPrivateDefEffect();
+      }
+      func->SetIpaSeen();
+      mrtPuIdx[func->GetPuidx()] = seMask;
+    }
+  }
+}
+
+uint32 IpaSideEffect::GetOrSetSCCNodeId(MIRFunction &mirfunc) {
+  if (mirfunc.GetSCCId() != -1) {
+    return static_cast<uint32>(mirfunc.GetSCCId());
+  }
+  auto it = callGraph.GetNodesMap().find(&mirfunc);
+  if (it != callGraph.GetNodesMap().end()) {
+    CGNode *callGraphNode = it->second;
+    SCCNode<CGNode> *sccn = callGraphNode->GetSCCNode();
+    if (sccn != nullptr && sccn->GetNodes().size() > 1) {
+      mirfunc.SetSCCId(static_cast<int32>(sccn->GetID()));
+      return sccn->GetID();
+    }
+  }
+  mirfunc.SetSCCId(0);
+  return 0;
+}
+
+bool IpaSideEffect::IsCallingIntoSCC(uint32 sccID) const {
+  if (sccID == 0) {
+    return false;
+  }
+  if (sccId == 0) {
+    return false;
+  }
+  return (sccID != sccId);
+}
+
+void IpaSideEffect::UpdateExternalFuncSideEffects(MIRFunction &func) {
+  if (!func.IsIpaSeen()) {
+    return;
+  }
+  // This is an external caller read in from an already processed mplt file.
+  // Need to process all callee and update the caller side effects.
+  notPure = notPure || !func.IsPure();
+  hasDefArg = hasDefArg || !func.IsNoDefArgEffect();
+  hasDef = hasDef || !func.IsNoDefEffect();
+  hasRetGlobal = hasRetGlobal || !func.IsNoRetGlobal();
+  hasThrException = hasThrException || !func.IsNoThrowException();
+  hasRetArg = hasRetArg || !func.IsNoRetArg();
+  hasPrivateDef = hasPrivateDef || !func.IsNoPrivateDefEffect();
+  auto callerIt = callGraph.GetNodesMap().find(&func);
+  CHECK_FATAL(callerIt != callGraph.GetNodesMap().end(), "CGNode not found.");
+  CGNode *cgNode = callerIt->second;
+  for (auto &callSite : cgNode->GetCallee()) {
+    // IPASEEN == true, body == NULL;
+    // IPASEEN == true, body != NULL;
+    // IPASEEN == false, body != NULL, ignore
+    // IPASEEN == false, body == NULL, most conservative
+    uint8 mask1 = 0;
+    uint8 mask2 = 0;
+
+    for (auto &cgIt : *callSite.second) {
+      MIRFunction *callee = cgIt->GetMIRFunction();
+      if (callee->IsIpaSeen()) {
+        auto &mask = (callee->GetBody() == nullptr) ? mask1 : mask2;
+        mask |= (!callee->IsNoDefArgEffect() ?     kHasDefArg :     0) |
+                (!callee->IsNoDefEffect() ?        kHasDef :        0) |
+                (!callee->IsNoRetGlobal() ?        kHasRetGlobal :  0) |
+                (!callee->IsNoThrowException() ?   kHasThrow :      0) |
+                (!callee->IsNoRetArg() ?           kHasRetArg :     0) |
+                (!callee->IsNoPrivateDefEffect() ? kHasPrivateDef : 0);
+      } else if (!callee->IsIpaSeen() && callee->GetBody() == nullptr) {
+        if (!IsPureFromSummary(*callee)) { // Set pure
+          hasPrivateDef = true;
+          hasThrException = true;
+          hasDef = true;
+        }
+      }
+    }
+    if ((((mask1 & kHasDef) == 0) && ((mask2 & kHasDef) == kHasDef)) ||
+        (((mask1 & kHasDefArg) == 0) && ((mask2 & kHasDefArg) == kHasDefArg))) {
+      CHECK_FATAL(false, "Need to update");
+    }
+  }
+}
+
+// Whether or not the expr is reading global or arg variables
+void IpaSideEffect::AnalyzeExpr(MeExpr &expr,
+                                std::set<VarMeExpr*> &globalExprs, std::set<VarMeExpr*> &argExprs,
+                                std::set<VarMeExpr*> &nextLevelGlobalExprs, std::set<VarMeExpr*> &nextLevelArgExprs) {
+  bool isGlobalTmp = false;
+  bool isArgTmp = false;
+  if (expr.GetPrimType() != PTY_ptr && expr.GetPrimType() != PTY_ref) {
+    return;
+  }
+  Opcode op = expr.GetOp();
+  for (size_t i = 0; i < expr.GetNumOpnds(); ++i) {
+    AnalyzeExpr(*expr.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+  }
+  switch (op) {
+    case OP_iread: {
+      hasThrException = true;
+      IvarMeExpr &ivarMeExpr = static_cast<IvarMeExpr&>(expr);
+      MeExpr *tmpBase = ivarMeExpr.GetBase();
+      CHECK_FATAL(tmpBase->GetOp() == OP_dread || tmpBase->GetOp() == OP_array, "Must be dread or array");
+      MeExpr *baseNode = nullptr;
+      if (tmpBase->GetOp() == OP_array) {
+        NaryMeExpr *arrayNode = static_cast<NaryMeExpr*>(tmpBase);
+        CHECK_FATAL(arrayNode->GetOpnd(0)->GetOp() == OP_dread, "Must be dread");
+        baseNode = arrayNode->GetOpnd(0);
+      } else {
+        baseNode = tmpBase;
+      }
+      CHECK_FATAL(baseNode->GetOp() == OP_dread, "must be dread");
+      VarMeExpr *dread = static_cast<VarMeExpr*>(baseNode);
+      if (nextLevelGlobalExprs.find(dread) != nextLevelGlobalExprs.end()) {
+        isGlobalTmp = true;
+      }
+      if (nextLevelArgExprs.find(dread) != nextLevelArgExprs.end()) {
+        isArgTmp = true;
+      }
+      break;
+    }
+    case OP_array: {
+      hasThrException = true;
+      break;
+    }
+    case OP_intrinsicop: {
+      NaryMeExpr &intrnNode = static_cast<NaryMeExpr&>(expr);
+      if (intrnNode.GetIntrinsic() != INTRN_JAVA_MERGE) {
+        CHECK_FATAL(false, "NYI");
+      }
+      break;
+    }
+    case OP_div:
+    case OP_rem:
+    case OP_gcmalloc:
+    case OP_gcmallocjarray:
+    case OP_gcpermallocjarray:
+    case OP_gcpermalloc: {
+      hasThrException = true;
+      isGlobalTmp = false;
+      isArgTmp = false;
+      break;
+    }
+    case OP_dread: {
+      VarMeExpr &dread = static_cast<VarMeExpr&>(expr);
+      const OriginalSt *ost = meFunc.GetMeSSATab()->GetSymbolOriginalStFromID(dread.GetOstIdx());
+      if ((ost->GetMIRSymbol()->IsGlobal() && !ost->GetMIRSymbol()->IsConst() && !ost->GetMIRSymbol()->IsFinal()) ||
+          globalExprs.find(&dread) != globalExprs.end()) {
+        isGlobalTmp = true;
+      } else if (meFunc.GetMirFunc()->IsAFormal(ost->GetMIRSymbol()) || argExprs.find(&dread) != argExprs.end()) {
+        isArgTmp = true;
+      }
+      break;
+    }
+    case OP_constval:
+    case OP_cvt:
+    case OP_shl:
+    case OP_lshr:
+    case OP_band:
+    case OP_add:
+    case OP_ashr:
+    case OP_bior:
+    case OP_bxor:
+    case OP_cand:
+    case OP_cior:
+    case OP_cmp:
+    case OP_cmpg:
+    case OP_cmpl:
+    case OP_addrof:
+    case OP_sub: {
+      isGlobalTmp = false;
+      isArgTmp = false;
+      break;
+    }
+    case OP_retype:
+    case OP_regread: {
+      break;
+    }
+    case OP_intrinsicopwithtype: {
+      NaryMeExpr &instrinsicExpr = static_cast<NaryMeExpr&>(expr);
+      if (instrinsicExpr.GetIntrinsic() == INTRN_JAVA_CONST_CLASS ||
+          instrinsicExpr.GetIntrinsic() == INTRN_JAVA_INSTANCE_OF) {
+        isGlobalTmp = false;
+        isArgTmp = false;
+      } else {
+        CHECK_FATAL(false, "NYI");
+      }
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "NYI");
+    }
+  }
+  isGlobal = isGlobal || isGlobalTmp;
+  isArg = isArg || isArgTmp;
+}
+
+bool IpaSideEffect::UpdateSideEffectWithStmt(MeStmt &meStmt,
+                                             std::set<VarMeExpr*> &globalExprs, std::set<VarMeExpr*> &argExprs,
+                                             std::set<VarMeExpr*> &nextLevelGlobalExprs,
+                                             std::set<VarMeExpr*> &nextLevelArgExprs) {
+  isArg = false;
+  isGlobal = false;
+  Opcode op = meStmt.GetOp();
+  switch (op) {
+    case OP_return: {
+      for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        AnalyzeExpr(*meStmt.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+      }
+      if (isGlobal) {
+        hasRetGlobal = true;
+      }
+      if (isArg) {
+        hasRetArg = true;
+      }
+      break;
+    }
+    case OP_iassign: {
+      for (size_t i = 1; i < meStmt.NumMeStmtOpnds(); ++i) { // Ignore base (LHR), both array or structure
+        AnalyzeExpr(*meStmt.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+      }
+      hasThrException = true;
+      IassignMeStmt &iasNode = static_cast<IassignMeStmt&>(meStmt);
+      CHECK_FATAL(iasNode.GetLHSVal()->GetBase()->GetOp() == OP_dread ||
+                  iasNode.GetLHSVal()->GetBase()->GetOp() == OP_array, "Must be dread");
+      MeExpr *baseNode = nullptr;
+      if (iasNode.GetLHSVal()->GetBase()->GetOp() == OP_array) {
+        NaryMeExpr *arrayNode = static_cast<NaryMeExpr*>(iasNode.GetLHSVal()->GetBase());
+        CHECK_FATAL(arrayNode->GetOpnd(0)->GetOp() == OP_dread, "Must be dread");
+        baseNode = arrayNode->GetOpnd(0);
+      } else {
+        baseNode = iasNode.GetLHSVal()->GetBase();
+      }
+      VarMeExpr *dread = static_cast<VarMeExpr*>(baseNode);
+      const OriginalSt *ost = meFunc.GetMeSSATab()->GetSymbolOriginalStFromID(dread->GetOstIdx());
+      CHECK_FATAL(ost, "ost is nullptr!");
+      if (ost->GetMIRSymbol()->IsGlobal() || globalExprs.find(dread) != globalExprs.end()) {
+        SetHasDef();
+      } else if (meFunc.GetMirFunc()->IsAFormal(ost->GetMIRSymbol()) || argExprs.find(dread) != argExprs.end()) {
+        hasDefArg = true;
+      }
+      if (isGlobal) {
+        (void)nextLevelGlobalExprs.insert(dread);
+      }
+      if (isArg) {
+        (void)nextLevelArgExprs.insert(dread);
+      }
+      std::vector<MeExpr*> varVector;
+      if (MEAnalyzeDefExpr(*dread, varVector)) {
+        MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iasNode.GetTyIdx());
+        MIRType *pType = static_cast<MIRPtrType*>(baseType)->GetPointedType();
+        if (pType != nullptr && pType->IsInstanceOfMIRStructType()) {
+          MIRStructType *structType = static_cast<MIRStructType*>(pType);
+          FieldAttrs fattrs = structType->GetFieldAttrs(iasNode.GetLHSVal()->GetFieldID());
+          if (fattrs.GetAttr(FLDATTR_private)) {
+            hasPrivateDef = true;
+          }
+        }
+      }
+      break;
+    }
+    case OP_throw: {
+      hasThrException = true;
+      break;
+    }
+    case OP_intrinsiccall:
+    case OP_intrinsiccallwithtype: {
+      IntrinsiccallMeStmt &callNode = static_cast<IntrinsiccallMeStmt&>(meStmt);
+      if (callNode.GetIntrinsic() != INTRN_JAVA_CLINIT_CHECK) {
+        CHECK_FATAL(false, "NYI");
+      }
+      break;
+    }
+    case OP_intrinsiccallassigned:
+    case OP_intrinsiccallwithtypeassigned: {
+      for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        AnalyzeExpr(*meStmt.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+      }
+      IntrinsiccallMeStmt &callNode = static_cast<IntrinsiccallMeStmt&>(meStmt);
+      if (callNode.GetIntrinsic() == INTRN_JAVA_CHECK_CAST) {
+        hasThrException = true;
+        MeExpr *lhs = callNode.GetAssignedLHS();
+        CHECK_NULL_FATAL(lhs);
+        CHECK_FATAL(lhs->GetOp() == OP_dread, "Must be dread.");
+        VarMeExpr *lhsVar = static_cast<VarMeExpr*>(lhs);
+        const OriginalSt *ost = meFunc.GetMeSSATab()->GetSymbolOriginalStFromID(lhsVar->GetOstIdx());
+        if (ost->GetMIRSymbol()->IsGlobal()) {
+          SetHasDef();
+        }
+        if (isGlobal) {
+          (void)globalExprs.insert(lhsVar);
+        }
+        if (isArg) {
+          (void)argExprs.insert(lhsVar);
+        }
+      } else if (callNode.GetIntrinsic() == INTRN_JAVA_ARRAY_FILL ||
+                 callNode.GetIntrinsic() == INTRN_JAVA_FILL_NEW_ARRAY) {
+        hasThrException = true;
+        MeExpr *lhs = meStmt.GetOpnd(0);
+        CHECK_FATAL(lhs->GetOp() == OP_dread, "Must be dread.");
+        VarMeExpr *lhsVar = static_cast<VarMeExpr*>(lhs);
+        const OriginalSt *ost = meFunc.GetMeSSATab()->GetSymbolOriginalStFromID(lhsVar->GetOstIdx());
+        if (ost->GetMIRSymbol()->IsGlobal()) {
+          SetHasDef();
+        }
+        if (isGlobal) {
+          (void)globalExprs.insert(lhsVar);
+        }
+        if (isArg) {
+          (void)argExprs.insert(lhsVar);
+        }
+      } else if (callNode.GetIntrinsic() == INTRN_JAVA_POLYMORPHIC_CALL) {
+        hasPrivateDef = hasThrException = true;
+        SetHasDef();
+        CallMeStmt &callMeStmt = static_cast<CallMeStmt&>(meStmt);
+        MeExpr *lhs = callMeStmt.GetAssignedLHS();
+        if (lhs != nullptr) {
+          CHECK_FATAL(lhs->GetOp() == OP_dread, "Must be dread.");
+          VarMeExpr *lhsVar = static_cast<VarMeExpr*>(lhs);
+          (void)globalExprs.insert(lhsVar);
+          if (isArg) {
+            (void)argExprs.insert(lhsVar);
+          }
+        }
+        if (isArg) {
+          hasDefArg = true;
+        }
+      } else {
+        CHECK_FATAL(false, "NYI");
+      }
+      break;
+    }
+    case OP_dassign: { // Pass by value, special case is addrof C_str and const_array, in java only
+      for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        AnalyzeExpr(*meStmt.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+      }
+      DassignMeStmt &dassignNode = static_cast<DassignMeStmt&>(meStmt);
+      VarMeExpr *lhsVar = static_cast<VarMeExpr*>(dassignNode.GetVarLHS());
+      const OriginalSt *ost = meFunc.GetMeSSATab()->GetSymbolOriginalStFromID(lhsVar->GetOstIdx());
+      if (ost->GetMIRSymbol()->IsGlobal()) {
+        SetHasDef();
+      }
+      if (isGlobal) {
+        (void)globalExprs.insert(lhsVar);
+      }
+      if (isArg) {
+        (void)argExprs.insert(lhsVar);
+      }
+      break;
+    }
+    case OP_maydassign: {
+      for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        AnalyzeExpr(*meStmt.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+      }
+      MaydassignMeStmt &dassignNode = static_cast<MaydassignMeStmt&>(meStmt);
+      if (dassignNode.GetMayDassignSym()->GetMIRSymbol()->IsGlobal()) {
+        SetHasDef();
+      }
+      if (isGlobal) {
+        (void)globalExprs.insert(static_cast<VarMeExpr*>(dassignNode.GetChiList()->begin()->second->GetLHS()));
+      }
+      if (isArg) {
+        (void)argExprs.insert(static_cast<VarMeExpr*>(dassignNode.GetChiList()->begin()->second->GetLHS()));
+      }
+      break;
+    }
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_interfacecallassigned: {
+      CallMeStmt &callMeStmt = static_cast<CallMeStmt&>(meStmt);
+      MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callMeStmt.GetPUIdx());
+      if (callee->GetBaseClassName().find(JARRAY_PREFIX_STR) == 0) {
+        // An array, must have method, but has all effects
+        SetEffectsTrue();
+        break;
+      }
+      // If callee is init, process the first argument only.
+      size_t count = 0;
+      if (callee->IsConstructor()) {
+        count = 1;
+      } else {
+        count = meStmt.NumMeStmtOpnds();
+      }
+      for (size_t i = 0; i < count; ++i) {
+        AnalyzeExpr(*meStmt.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+      }
+      CGNode *callerNode = callGraph.GetCGNode(meFunc.GetMirFunc());
+      CHECK_FATAL(callerNode != nullptr, "Must not be null");
+      bool defArg = false;
+      bool returnGlobal = false;
+      bool returnArg = false;
+      for (auto &callSite : callerNode->GetCallee()) {
+        if (callSite.first->GetID() == callMeStmt.GetStmtID()) {
+          for (auto *calleeNode : *callSite.second) {
+            MIRFunction *calleeFunc = calleeNode->GetMIRFunction();
+            if (calleeFunc->IsIpaSeen()) {
+              if (IsPureFromSummary(*calleeFunc)) { // Set pure
+                continue;
+              }
+              if (!calleeFunc->IsNoPrivateDefEffect()) {
+                hasPrivateDef = true;
+              }
+              if (!calleeFunc->IsNoThrowException()) {
+                hasThrException = true;
+              }
+              if (!calleeFunc->IsNoDefEffect()) {
+                SetHasDef();
+              }
+              if (!calleeFunc->IsNoDefArgEffect()) {
+                defArg = true;
+              }
+              if (!calleeFunc->IsNoRetGlobal()) {
+                returnGlobal = true;
+              }
+              if (!calleeFunc->IsNoRetArg()) {
+                returnArg = true;
+              }
+              if (hasPrivateDef && hasThrException && hasDef && defArg && returnGlobal && returnArg) {
+                break;
+              }
+            } else {
+              if (!IsPureFromSummary(*calleeFunc)) { // Set pure
+                hasPrivateDef = true;
+                hasThrException = true;
+                defArg = true;
+                returnGlobal = true;
+                returnArg = true;
+                SetHasDef();
+              }
+            }
+          }
+          if (!isGlobal && !isArg) {
+            callSite.first->SetAllArgsLocal();
+          }
+          break;
+        }
+      }
+      MeExpr *lhs = callMeStmt.GetAssignedLHS();
+      if (lhs != nullptr) {
+        CHECK_FATAL(lhs->GetOp() == OP_dread, "Must be dread.");
+        VarMeExpr *lhsVar = static_cast<VarMeExpr*>(lhs);
+        const OriginalSt *ost = meFunc.GetMeSSATab()->GetSymbolOriginalStFromID(lhsVar->GetOstIdx());
+        if (ost->GetMIRSymbol()->IsGlobal()) {
+          SetHasDef();
+        }
+        if (returnGlobal) {
+          (void)globalExprs.insert(lhsVar);
+        } else if (returnArg) {
+          if (isGlobal) {
+            (void)globalExprs.insert(lhsVar);
+          }
+          if (isArg) {
+            (void)argExprs.insert(lhsVar);
+          }
+        }
+      }
+      if (defArg) {
+        if (isGlobal) {
+          SetHasDef();
+        }
+        if (isArg) {
+          hasDefArg = true;
+        }
+      }
+      break;
+    }
+    case OP_call:
+    case OP_virtualcall:
+    case OP_interfacecall: {
+      for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        AnalyzeExpr(*meStmt.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+      }
+      CallMeStmt &callMeStmt = static_cast<CallMeStmt&>(meStmt);
+      MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callMeStmt.GetPUIdx());
+      if (callee->GetBaseClassName().find(JARRAY_PREFIX_STR) == 0) {
+        // An array, must have method, but has all effects
+        SetEffectsTrue();
+        break;
+      }
+      CGNode *callerNode = callGraph.GetCGNode(meFunc.GetMirFunc());
+      CHECK_FATAL(callerNode != nullptr, "Must not be null");
+      bool defArg = false;
+      for (Callsite callSite : callerNode->GetCallee()) {
+        if (callSite.first->GetID() == callMeStmt.GetStmtID()) {
+          for (auto *calleeNode : *callSite.second) {
+            MIRFunction *calleeFunc = calleeNode->GetMIRFunction();
+            if (calleeFunc->IsIpaSeen()) {
+              if (IsPureFromSummary(*calleeFunc)) { // Set pure
+                continue;
+              }
+              if (!calleeFunc->IsNoPrivateDefEffect()) {
+                hasPrivateDef = true;
+              }
+              if (!calleeFunc->IsNoThrowException()) {
+                hasThrException = true;
+              }
+              if (!calleeFunc->IsNoDefEffect()) {
+                SetHasDef();
+              }
+              if (!calleeFunc->IsNoDefArgEffect()) {
+                defArg = true;
+              }
+              if (hasPrivateDef && hasThrException && hasDef && defArg) {
+                break;
+              }
+            } else {
+              if (!IsPureFromSummary(*calleeFunc)) { // Set pure
+                hasPrivateDef = true;
+                hasThrException = true;
+                defArg = true;
+                SetHasDef();
+              }
+            }
+          }
+          break;
+        }
+      }
+      if (defArg) {
+        if (isGlobal) {
+          SetHasDef();
+        }
+        if (isArg) {
+          hasDefArg = true;
+        }
+      }
+      break;
+    }
+    case OP_virtualicallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_icallassigned:
+    case OP_icallprotoassigned:
+    case OP_superclasscallassigned:
+    case OP_asm: {
+      hasPrivateDef = hasThrException = true;
+      SetHasDef();
+      for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        AnalyzeExpr(*meStmt.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+      }
+      CallMeStmt &callMeStmt = static_cast<CallMeStmt&>(meStmt);
+      MeExpr *lhs = callMeStmt.GetAssignedLHS();
+      if (lhs != nullptr) {
+        CHECK_FATAL(lhs->GetOp() == OP_dread, "Must be dread.");
+        VarMeExpr *lhsVar = static_cast<VarMeExpr*>(lhs);
+        (void)globalExprs.insert(lhsVar);
+        if (isArg) {
+          (void)argExprs.insert(lhsVar);
+        }
+      }
+      if (isArg) {
+        hasDefArg = true;
+      }
+      break;
+    }
+    case OP_virtualicall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_icall:
+    case OP_icallproto: {
+      hasPrivateDef = hasThrException = true;
+      SetHasDef();
+      for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+        AnalyzeExpr(*meStmt.GetOpnd(i), globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs);
+      }
+      if (isArg) {
+        hasDefArg = true;
+      }
+      break;
+    }
+    case OP_jscatch:
+    case OP_finally:
+    case OP_endtry:
+    case OP_cleanuptry:
+    case OP_membaracquire:
+    case OP_membarrelease:
+    case OP_membarstoreload:
+    case OP_membarstorestore:
+    case OP_retsub:
+    case OP_gosub:
+    case OP_goto:
+    case OP_brfalse:
+    case OP_brtrue:
+    case OP_comment:
+    case OP_jstry:
+    case OP_try:
+    case OP_catch:
+    case OP_syncenter:
+    case OP_syncexit:
+    CASE_OP_ASSERT_NONNULL
+    case OP_eval:
+    case OP_free:
+    case OP_switch:
+    case OP_label:
+      break;
+    default: {
+      CHECK_FATAL(false, "NYI");
+    }
+  }
+  return isGlobal;
+}
+
+void IpaSideEffect::DoAnalysis() {
+  ReadSummary(); // Read once
+  MIRFunction *func = meFunc.GetMirFunc();
+  if (func->IsAbstract() || mrtPuIdx.find(func->GetPuidx()) != mrtPuIdx.end()) {
+    return;
+  }
+  // SCC check
+  auto it = callGraph.GetNodesMap().find(func);
+  CHECK_FATAL(it != callGraph.GetNodesMap().end(), "Must have cg node");
+  CGNode *cgNode = it->second;
+  SCCNode<CGNode> *sccNode = cgNode->GetSCCNode();
+  CHECK_FATAL(sccNode != nullptr, "Must not be null.");
+  if (currSccNode == nullptr) {
+    currSccNode = sccNode;
+    cgNodeCount = sccNode->GetNodes().size();
+  } else if (currSccNode == sccNode) {
+    CHECK_FATAL(cgNodeCount > 0, "cgNodeCount must be larger than 0");
+  } else {
+    currSccNode = sccNode;
+    cgNodeCount = sccNode->GetNodes().size();
+  }
+  bool useGlobal = false;
+  if (func->GetBody() == nullptr) { // External function from mplt, need to update effects
+    UpdateExternalFuncSideEffects(*func);
+  } else {
+    auto cfg = meFunc.GetCfg();
+    cfg->BuildSCC();
+    std::set<VarMeExpr*> globalExprs;
+    std::set<VarMeExpr*> argExprs;
+    std::set<VarMeExpr*> nextLevelGlobalExprs;
+    std::set<VarMeExpr*> nextLevelArgExprs;
+    for (size_t i = 0; i < cfg->GetSccTopologicalVec().size(); ++i) {
+      SCCOfBBs *scc = cfg->GetSccTopologicalVec()[i];
+      CHECK_FATAL(scc != nullptr, "scc must not be null");
+      if (scc->GetBBs().size() > 1) {
+        cfg->BBTopologicalSort(*scc);
+      }
+      const uint32 maxLoopCount = 2;
+      unsigned loopCount = scc->GetBBs().size() > 1 ? maxLoopCount : 1; // Loop count
+      for (unsigned j = 0; j < loopCount; ++j) {
+        for (BB *bb : scc->GetBBs()) {
+          if (bb == cfg->GetCommonEntryBB() || bb == cfg->GetCommonExitBB()) {
+            continue;
+          }
+          for (auto &meStmt : bb->GetMeStmts()) {
+            if (UpdateSideEffectWithStmt(meStmt, globalExprs, argExprs, nextLevelGlobalExprs, nextLevelArgExprs)) {
+              useGlobal = true;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  uint8 mask = 0;
+  sccId = GetOrSetSCCNodeId(*func);
+  if (sccId != 0) {
+    auto itTmp = sccSe.find(sccId);
+    if (itTmp != sccSe.end()) {
+      mask = itTmp->second;
+    }
+  }
+  if (hasDefArg || hasDef || useGlobal) {
+    mask |= kNotPure;
+  } else {
+    func->SetPure();
+  }
+  if (!hasDefArg) {
+    func->SetNoDefArgEffect();
+  }
+  if (hasDef) {
+    mask |= kHasDef;
+  } else {
+    func->SetNoDefEffect();
+  }
+  if (!hasRetGlobal) {
+    func->SetNoRetGlobal();
+  }
+  if (hasThrException) {
+    mask |= kHasThrow;
+  } else {
+    func->SetNoThrowException();
+  }
+  if (!hasRetArg) {
+    func->SetNoRetArg();
+  }
+  if (hasPrivateDef) {
+    mask |= kHasPrivateDef;
+  } else {
+    func->SetNoPrivateDefEffect();
+  }
+  func->SetIpaSeen();
+  --cgNodeCount;
+  if (sccId != 0) {
+    sccSe[sccId] = mask;
+  }
+  if (cgNodeCount == 0 && sccNode->GetNodes().size() > 1) {
+    CopySccSideEffectToAllFunctions(*sccNode, mask);
+  }
+  // Delete redundant callinfo. func+callType+allargsarelocal
+  std::unordered_set<uint64> callInfoHash;
+  for (auto callSite = cgNode->GetCallee().begin(); callSite != cgNode->GetCallee().end();) {
+    uint64 key = (static_cast<uint64>(callSite->first->GetFunc()->GetPuidx()) << 32) + // leftshift 32 bits
+                 (static_cast<uint64>(callSite->first->GetCallType()) << 16) + // leftshift 16 bits
+                 (callSite->first->AreAllArgsLocal() ? 1 : 0);
+    if (callInfoHash.find(key) != callInfoHash.end()) {
+      callSite = cgNode->GetCallee().erase(callSite);
+    } else {
+      (void)callInfoHash.insert(key);
+      ++callSite;
+    }
+  }
+}
+
+void MESideEffect::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+}
+
+bool MESideEffect::PhaseRun(MeFunction &f) {
+  if (f.GetMirFunc()->IsNative()) {
+    return false;
+  }
+  Dominance *dom = nullptr;
+  if (f.GetMirFunc()->GetBody() != nullptr) {
+    dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  }
+  CHECK_FATAL(dom != nullptr, "Dominance must be built.");
+  MaplePhase *it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MCallGraph, MIRModule>(f.GetMIRModule());
+  CallGraph *callGraph = static_cast<M2MCallGraph*>(it)->GetResult();
+  CHECK_FATAL(callGraph != nullptr, "Call graph must be built.");
+  IpaSideEffect ipaSideEffect(f, ApplyTempMemPool(), *callGraph, *dom);
+  ipaSideEffect.DoAnalysis();
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_sink.cpp b/src/mapleall/maple_me/src/me_sink.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..60c1eb56f31a13c5c18968428d1e9741ece6ac80
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_sink.cpp
@@ -0,0 +1,1450 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "me_sink.h"
+#include "me_phase_manager.h"
+#include "meexpr_use_info.h"
+
+namespace maple {
+struct DefUseInfoOfPhi {
+  bool allOpndsUsedOnlyInPhi; // true only if all opnds of phi used only in current phi
+  bool allOpndsDefedByStmt; // true only if all opnds of phi defined by stmt (assign/callassign)
+  bool opndsHasIdenticalVal;
+  bool opndsOnlyFlowIntoTargetPhi; // the phi opnds
+  MeExpr *valueExpr; // nonnull only if all opnds of phi defined by AssignMeStmt with identical rhs
+};
+
+struct ScalarMeExprCmp {
+  bool operator()(const ScalarMeExpr *a, const ScalarMeExpr *b) const {
+    return a->GetExprID() < b->GetExprID();
+  }
+};
+
+using ScalarVec = std::set<ScalarMeExpr *, ScalarMeExprCmp>;
+
+class MeSink {
+ public:
+  MeSink(MeFunction *meFunc, IRMap *irMap, Dominance *dom, Dominance *pdom, IdentifyLoops *loops, bool debug)
+      : func(meFunc), irMap(irMap), domTree(dom), pdomTree(pdom), loopInfo(loops), debug(debug) {
+    Init();
+  }
+
+  ~MeSink() = default;
+  void Init();
+  MeExpr *ConstructExpr(MeExpr *expr, const BB *predBB, const BB *phiBB);
+  static bool ExprsHasSameValue(const MeExpr *exprA, const MeExpr *exprB);
+  bool OpndOfExprRedefined(const MeExpr *expr) const;
+  bool ScalarOnlyUsedInCurStmt(const ScalarMeExpr *scalar, const MeStmt *stmt,
+                               std::set<const ScalarMeExpr*> &visitedScalars) const;
+  void RecordStmtSinkToHeaderOfTargetBB(MeStmt *defStmt, const BB *targetBB);
+  void RecordStmtSinkToBottomOfTargetBB(MeStmt *defStmt, const BB *targetBB);
+
+  bool MeExprSinkable(MeExpr *expr) const;
+  bool DefStmtSinkable(MeStmt *defStmt) const;
+  void AddNewDefinedScalar(ScalarMeExpr *scalar);
+  bool OstHasNotBeenDefined(const OriginalSt *ost);
+  bool ScalarHasValidDefStmt(const ScalarMeExpr *scalar);
+
+  bool MergeAssignStmtWithCallAssign(AssignMeStmt *assign, MeStmt *callAssignStmt);
+  DefUseInfoOfPhi DefAndUseInfoOfPhiOpnds(MePhiNode *phi, std::map<ScalarMeExpr*, MeStmt*> &defStmts);
+  DefUseInfoOfPhi DefAndUseInfoOfPhiOpnds(MePhiNode *phi, std::map<ScalarMeExpr*, MeStmt*> &defStmts,
+      std::set<MePhiNode*> &processedPhi, std::set<const MePhiNode*> &phisUseCurrPhiOpnds);
+  void ReplacePhiWithNewDataFlow(MePhiNode *phi, ScalarMeExpr *scalar);
+  bool PhiCanBeReplacedWithDataFlowOfScalar(const ScalarMeExpr *scalar, const BB *defBBOfScalar, MePhiNode *phi,
+                                            std::map<ScalarMeExpr*, MeStmt*> &defStmtsOfPhiOpnds);
+  bool MergeAssignStmtWithPhi(AssignMeStmt *assign, MePhiNode *phi);
+  bool UpwardMergeAssignStmt(MeStmt *stmt);
+  void ProcessStmt(MeStmt *stmt);
+
+  void SinkStmtsToHeaderOfBB(BB *bb);
+  void SinkStmtsToBottomOfBB(BB *bb);
+
+  bool MergePhiWithPrevAssign(MePhiNode *phi, BB *bb);
+  void ProcessPhiList(BB *bb);
+  void SinkStmtsInBB(BB *bb);
+
+  const BB *BestSinkBB(const BB *fromBB, const BB *toBB);
+  std::pair<const BB*, bool> CalCandSinkBBForUseSites(const ScalarMeExpr *scalar, const UseSitesType &useList);
+  const BB *CalSinkSiteOfScalarDefStmt(const ScalarMeExpr *scalar);
+  void CalSinkSites();
+  void Run();
+
+ private:
+  MeFunction *func = nullptr;
+  IRMap *irMap = nullptr;
+  Dominance *domTree = nullptr;
+  Dominance *pdomTree = nullptr;
+  IdentifyLoops *loopInfo = nullptr;
+  MeExprUseInfo *useInfoOfExprs = nullptr;
+  std::vector<std::unique_ptr<std::list<MeStmt*>>> defStmtsSinkToHeader; // index is bbId
+  std::vector<std::unique_ptr<std::list<MeStmt*>>> defStmtsSinkToBottom; // index is bbId
+  std::vector<std::unique_ptr<std::list<ScalarMeExpr*>>> versionStack; // index is ostIdx
+  std::vector<uint16> defineCnt; // index is ostIdx
+  std::vector<bool> scalarHasValidDef; // index is exprId, true if scalar is define by a valid stmt/phi
+  uint32 sinkCnt = 0;
+  bool debug;
+};
+
+void MeSink::Init() {
+  defStmtsSinkToHeader.resize(func->GetCfg()->NumBBs());
+  defStmtsSinkToBottom.resize(func->GetCfg()->NumBBs());
+  auto ostNum = func->GetMeSSATab()->GetOriginalStTableSize();
+  versionStack.resize(ostNum);
+  defineCnt.insert(defineCnt.cend(), ostNum, 0);
+  for (size_t ostId = 0; ostId < ostNum; ++ostId) {
+    versionStack[ostId] = std::make_unique<std::list<ScalarMeExpr*>>();
+    auto *ost = func->GetMeSSATab()->GetOriginalStFromID(OStIdx(ostId));
+    if (ost == nullptr) {
+      continue;
+    }
+    auto *zeroVersionScalar = static_cast<ScalarMeExpr *>(irMap->GetMeExpr(ost->GetZeroVersionIndex()));
+    if (zeroVersionScalar != nullptr) {
+      versionStack[ostId]->push_front(zeroVersionScalar);
+    }
+  }
+}
+
+void MeSink::AddNewDefinedScalar(ScalarMeExpr *scalar) {
+  if (scalar == nullptr) {
+    return;
+  }
+
+  auto ostIdx = scalar->GetOstIdx();
+  if (versionStack.size() <= ostIdx) {
+    constexpr uint32 bufferSize = 10;
+    versionStack.resize(ostIdx + bufferSize);
+    versionStack[ostIdx] = std::make_unique<std::list<ScalarMeExpr *>>();
+  }
+  versionStack[ostIdx]->push_front(scalar);
+  ++defineCnt[ostIdx];
+
+  if (scalarHasValidDef.size() <= static_cast<uint32>(scalar->GetExprID())) {
+    constexpr uint32 bufferSize = 10;
+    scalarHasValidDef.insert(scalarHasValidDef.cend(),
+        bufferSize + static_cast<uint32>(scalar->GetExprID()) - scalarHasValidDef.size(), false);
+  }
+  scalarHasValidDef[static_cast<uint32>(scalar->GetExprID())] = true;
+}
+
+bool MeSink::MeExprSinkable(maple::MeExpr *expr) const {
+  if (expr == nullptr) {
+    return false;
+  }
+
+  if (expr->IsScalar()) {
+    auto *scalar = static_cast<ScalarMeExpr *>(expr);
+    return !scalar->IsVolatile();
+  } else if (expr->GetMeOp() == kMeOpIvar) {
+    if (static_cast<IvarMeExpr *>(expr)->IsVolatile()) {
+      return false;
+    }
+  }
+
+  for (size_t opndId = 0; opndId < expr->GetNumOpnds(); ++opndId) {
+    auto *opnd = expr->GetOpnd(opndId);
+    if (opnd == nullptr) {
+      continue;
+    }
+    if (!MeExprSinkable(opnd)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MeSink::DefStmtSinkable(MeStmt *defStmt) const {
+  auto *lhs = defStmt->GetAssignedLHS();
+  if (lhs != nullptr && (lhs->IsVolatile() || lhs->GetPrimType() == PTY_ref)) {
+    return false;
+  }
+  lhs = defStmt->GetLHS();
+  if (lhs != nullptr && (lhs->IsVolatile() || lhs->GetPrimType() == PTY_ref)) {
+    return false;
+  }
+  for (size_t opndId = 0; opndId < defStmt->NumMeStmtOpnds(); ++opndId) {
+    auto *opnd = defStmt->GetOpnd(opndId);
+    if (opnd == nullptr) {
+      continue;
+    }
+    if (!MeExprSinkable(opnd)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MeSink::OstHasNotBeenDefined(const OriginalSt *ost) {
+  // global and formal has implicit define at entry
+  if (!ost->IsLocal() || ost->IsFormal()) {
+    return false;
+  }
+
+  // local static var maybe defined in prev run
+  if (ost->IsSymbolOst() && ost->GetMIRSymbol()->GetStorageClass() == kScPstatic) {
+    return false;
+  }
+
+  auto *versions = versionStack[ost->GetIndex()].get();
+  if (versions == nullptr || versions->empty()) {
+    return true;
+  }
+  for (auto *ver : std::as_const(*versions)) {
+    if (ver == nullptr) {
+      continue;
+    }
+    if (static_cast<size_t>(ver->GetExprID()) == ost->GetZeroVersionIndex()) {
+      continue;
+    }
+
+    if (ver->IsDefByStmt()) {
+      if (ScalarHasValidDefStmt(ver)) {
+        return false;
+      }
+      continue;
+    }
+    if (!ver->IsDefByNo()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MeSink::ScalarHasValidDefStmt(const ScalarMeExpr *scalar) {
+  if (static_cast<uint32>(scalar->GetExprID()) >= scalarHasValidDef.size()) {
+    return false;
+  }
+  return scalarHasValidDef[static_cast<uint32>(scalar->GetExprID())];
+}
+
+// callassigned(...) {dassign %a}; |  ===>  | callassigned(...) {dassign %b}
+// %b = %a;                        |        |
+bool MeSink::MergeAssignStmtWithCallAssign(AssignMeStmt *assign, MeStmt *callAssignStmt) {
+  auto *lhs = assign->GetLHS();
+  // non-zero-field is not support in emit/lower of mustDefVec
+  if (lhs->GetOst()->GetFieldID() != 0) {
+    return false;
+  }
+  if (sinkCnt >= MeOption::sinkLimit) {
+    return false;
+  }
+  auto &mustDefNode = callAssignStmt->GetMustDefList()->front();
+  // preg has no alias, it is safe to replace it with another scalar
+  if (mustDefNode.GetLHS()->GetMeOp() != kMeOpReg) {
+    return false;
+  }
+
+  if (assign == callAssignStmt->GetNextMeStmt() || OstHasNotBeenDefined(lhs->GetOst())) {
+    ++sinkCnt;
+    if (debug) {
+      LogInfo::MapleLogger() << sinkCnt << ": merge call assign:";
+      callAssignStmt->Dump(irMap);
+      LogInfo::MapleLogger() << ">>with:";
+      assign->Dump(irMap);
+    }
+
+    lhs->SetDefBy(kDefByMustDef);
+    lhs->SetDefMustDef(const_cast<MustDefMeNode&>(mustDefNode));
+    const_cast<MustDefMeNode&>(mustDefNode).SetLHS(lhs);
+    // merge chiList of copyStmt and CallAssignStmt
+    auto *chiList = assign->GetChiList();
+    if (chiList != nullptr) {
+      auto *chiListOfCall = assign->GetChiList();
+      for (auto &ost2chi : std::as_const(*chiList)) {
+        auto it = chiListOfCall->find(ost2chi.first);
+        if (it == chiListOfCall->end()) {
+          (void)chiListOfCall->emplace(ost2chi.first, ost2chi.second);
+          ost2chi.second->SetBase(const_cast<MeStmt*>(callAssignStmt));
+        } else {
+          it->second->SetLHS(ost2chi.second->GetLHS());
+          ost2chi.second->GetLHS()->SetDefChi(*it->second);
+        }
+      }
+    }
+    assign->GetBB()->RemoveMeStmt(assign);
+    assign->SetIsLive(false);
+    return true;
+  }
+  return false;
+}
+
+
+DefUseInfoOfPhi MeSink::DefAndUseInfoOfPhiOpnds(MePhiNode *phi, std::map<ScalarMeExpr*, MeStmt*> &defStmts,
+                                                std::set<MePhiNode*> &processedPhi,
+                                                std::set<const MePhiNode*> &phisUseCurrPhiOpnds) {
+  DefUseInfoOfPhi defInfo{true, true, true, true, nullptr};
+  auto &opnds = phi->GetOpnds();
+  for (auto *opnd : opnds) {
+    auto *useSitesOfOpnd = useInfoOfExprs->GetUseSitesOfExpr(opnd);
+    // use sites of phi-opnd has not been traced
+    if (useSitesOfOpnd == nullptr) {
+      return {false, false, false, false, nullptr};
+    }
+    for (auto &useSite : std::as_const(*useSitesOfOpnd)) {
+      if (!useSite.IsUseByPhi()) {
+        defInfo.allOpndsUsedOnlyInPhi = false;
+        break;
+      }
+      auto *phiUsingOpnd = useSite.GetPhi();
+      if (phiUsingOpnd->GetIsLive()) {
+        phisUseCurrPhiOpnds.insert(phiUsingOpnd);
+      }
+    }
+
+    if (!ScalarHasValidDefStmt(opnd)) {
+      return {false, false, false, false, nullptr};
+    }
+
+    if (opnd->IsDefByStmt()) {
+      auto *assignStmt = static_cast<AssignMeStmt *>(opnd->GetDefStmt());
+      if (defInfo.opndsHasIdenticalVal &&
+          (defInfo.valueExpr == nullptr ||
+           ExprsHasSameValue(defInfo.valueExpr, assignStmt->GetRHS()))) {
+        defInfo.valueExpr = assignStmt->GetRHS();
+      } else {
+        defInfo.valueExpr = nullptr;
+        defInfo.opndsHasIdenticalVal = false;
+      }
+      defStmts[opnd] = assignStmt;
+    } else if (opnd->IsDefByMustDef()) {
+      defInfo.opndsHasIdenticalVal = false;
+      defInfo.valueExpr = nullptr;
+      defStmts[opnd] = opnd->GetDefMustDef().GetBase();
+    } else if (opnd->IsDefByPhi()) {
+      auto *defPhi = &opnd->GetDefPhi();
+      auto notProcessedPhi = processedPhi.insert(defPhi).second;
+      if (notProcessedPhi) {
+        const auto &defineInfo = DefAndUseInfoOfPhiOpnds(defPhi, defStmts, processedPhi, phisUseCurrPhiOpnds);
+        defInfo.allOpndsUsedOnlyInPhi &= defineInfo.allOpndsUsedOnlyInPhi;
+        defInfo.allOpndsDefedByStmt &= defineInfo.allOpndsDefedByStmt;
+        defInfo.opndsHasIdenticalVal &= defineInfo.opndsHasIdenticalVal;
+        if (defInfo.opndsHasIdenticalVal &&
+            (defInfo.valueExpr == nullptr || ExprsHasSameValue(defInfo.valueExpr, defineInfo.valueExpr))) {
+          defInfo.valueExpr = defineInfo.valueExpr;
+        } else {
+          defInfo.opndsHasIdenticalVal = false;
+          defInfo.valueExpr = nullptr;
+        }
+      }
+    } else {
+      return {false, false, false, false, nullptr};
+    }
+  }
+  return defInfo;
+}
+
+DefUseInfoOfPhi MeSink::DefAndUseInfoOfPhiOpnds(MePhiNode *phi, std::map<ScalarMeExpr*, MeStmt*> &defStmts) {
+  std::set<MePhiNode*> processedPhi{phi};
+  std::set<const MePhiNode*> phisUseCurrPhiOpnds{phi};
+  auto defUseInfo = DefAndUseInfoOfPhiOpnds(phi, defStmts, processedPhi, phisUseCurrPhiOpnds);
+  defUseInfo.opndsOnlyFlowIntoTargetPhi = (phisUseCurrPhiOpnds.size() <= processedPhi.size());
+  return defUseInfo;
+}
+
+void MeSink::ReplacePhiWithNewDataFlow(MePhiNode *phi, ScalarMeExpr *scalar) {
+  if (!phi->GetIsLive()) {
+    return;
+  }
+  phi->SetIsLive(false);
+  auto *bb = phi->GetDefBB();
+  auto *newMePhi = irMap->New<MePhiNode>(&irMap->GetIRMapAlloc());
+  newMePhi->SetLHS(scalar);
+  newMePhi->SetDefBB(bb);
+  (void)bb->GetMePhiList().emplace(std::pair<OStIdx, MePhiNode*>(scalar->GetOstIdx(), newMePhi));
+  scalar->SetDefBy(kDefByPhi);
+  scalar->SetDefPhi(*newMePhi);
+  AddNewDefinedScalar(scalar);
+  for (auto *opnd : phi->GetOpnds()) {
+    auto *newVerScalar = irMap->CreateRegOrVarMeExprVersion(scalar->GetOstIdx());
+    if (opnd->IsDefByStmt()) {
+      auto *defStmt = opnd->GetDefStmt();
+      if (!defStmt->GetIsLive()) {
+        continue;
+      }
+      // if rhs is the same ost with scalar, not create self copy
+      if (kOpcodeInfo.AssignActualVar(defStmt->GetOp())) {
+        auto *rhs = static_cast<AssignMeStmt*>(defStmt)->GetRHS();
+        if (rhs->IsScalar() && static_cast<ScalarMeExpr*>(rhs)->GetOst() == scalar->GetOst()) {
+          useInfoOfExprs->AddUseSiteOfExpr(rhs, newMePhi);
+          newMePhi->GetOpnds().push_back(static_cast<ScalarMeExpr*>(rhs));
+          defStmt->GetBB()->RemoveMeStmt(defStmt);
+          defStmt->SetIsLive(false);
+          continue;
+        }
+      }
+      if (opnd->GetMeOp() != newVerScalar->GetMeOp()) {
+        auto *newDefStmt = irMap->CreateAssignMeStmt(*newVerScalar, *defStmt->GetRHS(), *defStmt->GetBB());
+        defStmt->GetBB()->InsertMeStmtAfter(defStmt, newDefStmt);
+        defStmt->GetBB()->RemoveMeStmt(defStmt);
+        defStmt->SetIsLive(false);
+        defStmt = newDefStmt;
+      } else {
+        static_cast<AssignMeStmt*>(defStmt)->SetLHS(newVerScalar);
+      }
+      newVerScalar->SetDefBy(kDefByStmt);
+      newVerScalar->SetDefByStmt(*defStmt);
+      AddNewDefinedScalar(newVerScalar);
+      useInfoOfExprs->AddUseSiteOfExpr(newVerScalar, newMePhi);
+      newMePhi->GetOpnds().push_back(newVerScalar);
+    } else if (opnd->IsDefByMustDef()) {
+      auto &mustDef = opnd->GetDefMustDef();
+      mustDef.SetLHS(newVerScalar);
+      newVerScalar->SetDefBy(kDefByMustDef);
+      newVerScalar->SetDefMustDef(mustDef);
+      AddNewDefinedScalar(newVerScalar);
+      useInfoOfExprs->AddUseSiteOfExpr(newVerScalar, newMePhi);
+      newMePhi->GetOpnds().push_back(newVerScalar);
+    } else if (opnd->IsDefByPhi()) {
+      auto &defPhi = opnd->GetDefPhi();
+      ReplacePhiWithNewDataFlow(&defPhi, newVerScalar);
+      useInfoOfExprs->AddUseSiteOfExpr(newVerScalar, newMePhi);
+      newMePhi->GetOpnds().push_back(newVerScalar);
+    } else {
+      CHECK_FATAL(false, "scalar defined by no or chi cannot be replaced");
+    }
+  }
+}
+
+bool MeSink::PhiCanBeReplacedWithDataFlowOfScalar(const ScalarMeExpr *scalar, const BB *defBBOfScalar, MePhiNode *phi,
+                                                  std::map<ScalarMeExpr*, MeStmt*> &defStmtsOfPhiOpnds) {
+  auto *verStack = versionStack[scalar->GetOstIdx()].get();
+  // scalar has not been defined, the phi can be replaced
+  ScalarMeExpr *topVer = nullptr;
+  BB *defBBOfTopVer = func->GetCfg()->GetCommonEntryBB();
+  if (verStack != nullptr && !verStack->empty()) {
+    topVer = verStack->front();
+    MeStmt *defStmt = nullptr;
+    defBBOfTopVer = topVer->GetDefByBBMeStmt(*func->GetCfg(), defStmt);
+    (void)defStmt;
+  }
+
+  // define stmt/phi of top-version must dominate phi and the define stmts of phi-opnds.
+  // define stmt of scalar must post-dominate define stmts of phi-opnds.
+  // Otherwise, new value of scalar will be available in a path which was nonavailable.
+  auto *domBBOfDefStmts = phi->GetDefBB();
+  if (domTree->Dominate(*domBBOfDefStmts, *defBBOfTopVer)) {
+    return false;
+  }
+  for (auto &scalar2defStmt : std::as_const(defStmtsOfPhiOpnds)) {
+    auto *defStmtOfScalar = scalar2defStmt.second;
+    auto *bbOfDefStmt = defStmtOfScalar->GetBB();
+    if (defBBOfTopVer == bbOfDefStmt || !domTree->Dominate(*defBBOfTopVer, *bbOfDefStmt)) {
+      return false;
+    }
+    if (defBBOfScalar == bbOfDefStmt || !pdomTree->Dominate(*defBBOfScalar, *bbOfDefStmt)) {
+      return false;
+    }
+    while (!domTree->Dominate(*domBBOfDefStmts, *bbOfDefStmt)) {
+      domBBOfDefStmts = func->GetCfg()->GetBBFromID(BBId(domTree->GetDom(domBBOfDefStmts->GetID())->GetID()));
+    }
+  }
+  if (!domTree->Dominate(*defBBOfTopVer, *domBBOfDefStmts)) {
+    return false;
+  }
+
+  // define stmts of phi-opnds will be replaced by define stmts of scalar,
+  // new defs of scalar cannot destruct its data-flow.
+  // To keep validation of data-flow of scalar,
+  // dominator of new define stmts should not dominate use sites of top-version.
+  if (topVer != nullptr) {
+    auto *useSitesOfTopVer = useInfoOfExprs->GetUseSitesOfExpr(topVer);
+    if (useSitesOfTopVer != nullptr) {
+      for (auto &useSite : std::as_const(*useSitesOfTopVer)) {
+        if (useSite.IsUseByStmt()) {
+          auto *bbOfUseSite = useSite.GetStmt()->GetBB();
+          if (domTree->Dominate(*domBBOfDefStmts, *bbOfUseSite)) {
+            return false;
+          }
+        } else {
+          CHECK_FATAL(useSite.IsUseByPhi(), "must be use by phi");
+          auto *phiUseTopVer = useSite.GetPhi();
+          auto &phiOpnds = phiUseTopVer->GetOpnds();
+          for (size_t id = 0; id < phiOpnds.size(); ++id) {
+            if (phiOpnds[id] == topVer) {
+              auto *predBB = phiUseTopVer->GetDefBB()->GetPred(id);
+              if (domTree->Dominate(*domBBOfDefStmts, *predBB)) {
+                return false;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return true;
+}
+
+// a1 = exprA    a2 = exprB  |      | b2 = exprA      b3 = exprB
+//        \       /          |      |        \        /
+//      a3 = phi(a1, a2)     | ===> |     b1 = phi(b2, b3)
+//      b1 = a3              |      |
+bool MeSink::MergeAssignStmtWithPhi(AssignMeStmt *assign, MePhiNode *phi) {
+  if (sinkCnt >= MeOption::sinkLimit) {
+    return false;
+  }
+  if (phi == nullptr) {
+    return false;
+  }
+  if (!phi->GetIsLive()) {
+    return false;
+  }
+  if (!assign->GetIsLive()) {
+    return false;
+  }
+  if (assign->GetChiList() != nullptr && !assign->GetChiList()->empty()) {
+    return false;
+  }
+
+  auto *lhsOfPhi = phi->GetLHS();
+  if (lhsOfPhi->GetMeOp() == kMeOpVar) {
+    return false;
+  }
+
+  std::set<const ScalarMeExpr*> visitedScalars;
+  bool scalarOnlyUsedInCurStmt = ScalarOnlyUsedInCurStmt(lhsOfPhi, assign, visitedScalars);
+  if (!scalarOnlyUsedInCurStmt) {
+    return false;
+  }
+
+  std::map<ScalarMeExpr*, MeStmt*> defStmtsOfPhiOpnds;
+  const auto &defUseInfo = DefAndUseInfoOfPhiOpnds(phi, defStmtsOfPhiOpnds);
+  if (!defUseInfo.allOpndsUsedOnlyInPhi || !defUseInfo.allOpndsDefedByStmt || !defUseInfo.opndsOnlyFlowIntoTargetPhi) {
+    return false;
+  }
+
+  if (defUseInfo.valueExpr && !OpndOfExprRedefined(defUseInfo.valueExpr)) {
+    assign->SetRHS(defUseInfo.valueExpr);
+    if (debug) {
+      LogInfo::MapleLogger() << "merge assign with phi: " << std::endl;
+      assign->Dump(irMap);
+      phi->Dump(irMap);
+    }
+    return true;
+  }
+
+  auto *lhs = assign->GetLHS();
+  if (PhiCanBeReplacedWithDataFlowOfScalar(lhs, assign->GetBB(), phi, defStmtsOfPhiOpnds)) {
+    if (debug) {
+      LogInfo::MapleLogger() << sinkCnt << ": merge assign with phi: " << std::endl;
+      assign->Dump(irMap);
+      phi->Dump(irMap);
+    }
+
+    ++sinkCnt;
+    ReplacePhiWithNewDataFlow(phi, lhs);
+    assign->GetBB()->RemoveMeStmt(assign);
+    assign->SetIsLive(false);
+    return true;
+  }
+  return false;
+}
+
+static ScalarMeExpr *GetEquivalentScalar(MeExpr *meExpr) {
+  if (meExpr->IsScalar()) {
+    return static_cast<ScalarMeExpr*>(meExpr);
+  } else if (meExpr->IsLeaf()) {
+    return nullptr;
+  }
+
+  while (meExpr->GetOp() == OP_cvt) {
+    auto fromType = static_cast<OpMeExpr*>(meExpr)->GetOpndType();
+    if (!IsPrimitiveInteger(fromType)) {
+      return nullptr;
+    }
+    auto toType = static_cast<OpMeExpr*>(meExpr)->GetPrimType();
+    if (!IsPrimitiveInteger(toType)) {
+      return nullptr;
+    }
+    if (GetPrimTypeSize(fromType) != GetPrimTypeSize(toType)) {
+      return nullptr;
+    }
+    meExpr = meExpr->GetOpnd(0);
+  }
+  if (!meExpr->IsScalar()) {
+    return nullptr;
+  }
+  return static_cast<ScalarMeExpr*>(meExpr);
+}
+
+// 1: merge callassign with assign stmt. For intance, {a = callassign(...); b = a} ====> {b = callassign()}
+// 2: merge assign with phi
+bool MeSink::UpwardMergeAssignStmt(MeStmt *stmt) {
+  if (!kOpcodeInfo.AssignActualVar(stmt->GetOp())) {
+    return false;
+  }
+
+  auto *assign = static_cast<AssignMeStmt*>(stmt);
+  auto *lhs = assign->GetLHS();
+  if (lhs->GetOst()->IsVolatile() || !lhs->GetOst()->IsLocal() || lhs->GetPrimType() == PTY_ref ||
+      (lhs->GetOst()->IsSymbolOst() && lhs->GetOst()->GetMIRSymbol()->GetStorageClass() == kScPstatic)) {
+    return false;
+  }
+
+  auto *rhs = GetEquivalentScalar(assign->GetRHS());
+  if (rhs == nullptr || rhs->IsVolatile() || rhs->GetPrimType() == PTY_ref) {
+    return false;
+  }
+
+  std::set<const ScalarMeExpr*> visitedScalars;
+  bool scalarOnlyUsedInCurStmt = ScalarOnlyUsedInCurStmt(rhs, assign, visitedScalars);
+  if (!scalarOnlyUsedInCurStmt) {
+    return false;
+  }
+
+  if (rhs->IsDefByMustDef()) {
+    auto *callAssignStmt = rhs->GetDefMustDef().GetBase();
+    return MergeAssignStmtWithCallAssign(assign, callAssignStmt);
+  }
+
+  if (rhs->IsDefByPhi()) {
+    return MergeAssignStmtWithPhi(assign, &rhs->GetDefPhi());
+  }
+  return false;
+}
+
+void MeSink::ProcessStmt(MeStmt *stmt) {
+  if (UpwardMergeAssignStmt(stmt)) {
+    AddNewDefinedScalar(stmt->GetLHS());
+  }
+
+  auto *lhs = stmt->GetAssignedLHS();
+  if (lhs != nullptr) {
+    AddNewDefinedScalar(lhs);
+  }
+  lhs = stmt->GetLHS();
+  if (lhs != nullptr && lhs != versionStack[lhs->GetOstIdx()]->front()) {
+    AddNewDefinedScalar(lhs);
+  }
+
+  auto *chiList = stmt->GetChiList();
+  if (chiList != nullptr) {
+    for (auto &ost2Chi : std::as_const(*chiList)) {
+      AddNewDefinedScalar(ost2Chi.second->GetLHS());
+    }
+  }
+}
+
+bool MeSink::OpndOfExprRedefined(const MeExpr *expr) const {
+  switch (expr->GetMeOp()) {
+    case kMeOpVar:
+    case kMeOpReg: {
+      auto *scalar = static_cast<const ScalarMeExpr *>(expr);
+      if (scalar->IsVolatile()) {
+        return true;
+      }
+      auto *currentVersion = versionStack[scalar->GetOstIdx()]->front();
+      if (currentVersion == nullptr) {
+        return !scalar->IsDefByNo();
+      }
+      return currentVersion != scalar;
+    }
+    case kMeOpIvar: {
+      for (auto *mu : static_cast<const IvarMeExpr *>(expr)->GetMuList()) {
+        if (mu == nullptr) {
+          return true;
+        }
+        if (OpndOfExprRedefined(mu)) {
+          return true;
+        }
+      }
+      break;
+    }
+    case kMeOpConst:
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpAddroflabel: {
+      return false;
+    }
+    default: {
+      break;
+    }
+  }
+  for (size_t opndId = 0; opndId < expr->GetNumOpnds(); ++opndId) {
+    auto *opnd = expr->GetOpnd(opndId);
+    if (OpndOfExprRedefined(opnd)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MeSink::ExprsHasSameValue(const MeExpr *exprA, const MeExpr *exprB) {
+  // use gvn to judge value equality instead of hssa
+  return exprA == exprB;
+}
+
+MeExpr *MeSink::ConstructExpr(MeExpr *expr, const BB *predBB, const BB *phiBB) {
+  if (expr == nullptr) {
+    return nullptr;
+  }
+
+  switch (expr->GetMeOp()) {
+    case kMeOpReg:
+    case kMeOpVar: {
+      auto ostIdx = static_cast<ScalarMeExpr *>(expr)->GetOstIdx();
+      if (defineCnt[ostIdx] <= 1) {
+        return expr;
+      }
+      auto *currentVersion = versionStack[ostIdx]->front();
+      if (predBB == nullptr) {
+        return currentVersion;
+      }
+      if (currentVersion == nullptr) {
+        return nullptr;
+      }
+      if (currentVersion == expr) {
+        return currentVersion;
+      }
+      if (currentVersion->IsDefByPhi()) {
+        auto &phiList = phiBB->GetMePhiList();
+        auto phiIt = phiList.find(ostIdx);
+        if (phiIt == phiList.end()) {
+          return nullptr;
+        }
+        auto predIdx = phiBB->GetPredIndex(*predBB);
+        return phiIt->second->GetOpnd(static_cast<size_t>(predIdx));
+      }
+      return nullptr;
+    }
+    case kMeOpIvar: {
+      IvarMeExpr newIvar(&irMap->GetIRMapAlloc(), kInvalidExprID, *static_cast<IvarMeExpr *>(expr));
+      auto *newBase = ConstructExpr(newIvar.GetBase(), predBB, phiBB);
+      if (newBase == nullptr) {
+        return nullptr;
+      }
+      newIvar.SetBase(newBase);
+      std::vector<ScalarMeExpr*> newMuList;
+      for (auto *mu : newIvar.GetMuList()) {
+        auto *newMu = ConstructExpr(mu, predBB, phiBB);
+        if (newMu == nullptr) {
+          return nullptr;
+        }
+        newMuList.push_back(static_cast<ScalarMeExpr*>(newMu));
+      }
+      newIvar.SetMuList(newMuList);
+      return irMap->HashMeExpr(newIvar);
+    }
+    case kMeOpOp: {
+      OpMeExpr opMeExpr(*static_cast<OpMeExpr *>(expr), kInvalidExprID);
+      for (size_t opndId = 0; opndId < expr->GetNumOpnds(); ++opndId) {
+        auto *opnd = expr->GetOpnd(opndId);
+        if (opnd == nullptr) {
+          break;
+        }
+        auto newOpnd = ConstructExpr(opnd, predBB, phiBB);
+        if (newOpnd == nullptr) {
+          return nullptr;
+        }
+        opMeExpr.SetOpnd(opndId, newOpnd);
+      }
+      return irMap->HashMeExpr(opMeExpr);
+    }
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpAddroflabel: {
+      return expr;
+    }
+    default: {
+      return nullptr;
+    }
+  }
+}
+
+bool MeSink::ScalarOnlyUsedInCurStmt(const ScalarMeExpr *scalar, const MeStmt *stmt,
+                                     std::set<const ScalarMeExpr*> &visitedScalars) const {
+  const auto &itPair = visitedScalars.insert(scalar);
+  if (!itPair.second) {
+    return true;
+  }
+
+  auto *useSitesOfExpr = useInfoOfExprs->GetUseSitesOfExpr(scalar);
+  if (useSitesOfExpr == nullptr) {
+    if (visitedScalars.size() == 1) {
+      return false;
+    }
+    return true;
+  }
+
+  for (auto &useItem : std::as_const(*useSitesOfExpr)) {
+    if (useItem.IsUseByStmt()) {
+      auto *useStmt = useItem.GetStmt();
+      if (stmt != useStmt) {
+        return false;
+      }
+    } else if (useItem.IsUseByPhi()) {
+      auto *phi = useItem.GetPhi();
+      if (!phi->GetIsLive()) {
+        continue;
+      }
+
+      bool usedOnlyInCurStmt = ScalarOnlyUsedInCurStmt(phi->GetLHS(), stmt, visitedScalars);
+      if (!usedOnlyInCurStmt) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+static void ResetLiveStateOfDefPhi(MeExpr *expr) {
+  if (expr == nullptr) {
+    return;
+  }
+  if (expr->IsScalar()) {
+    auto *scalar = static_cast<ScalarMeExpr*>(expr);
+    if (scalar->IsDefByPhi()) {
+      scalar->GetDefPhi().SetIsLive(true);
+    }
+    return;
+  }
+  if (expr->IsLeaf()) {
+    return;
+  }
+  if (expr->GetMeOp() == kMeOpIvar) {
+    for (auto *mu : static_cast<IvarMeExpr*>(expr)->GetMuList()) {
+      ResetLiveStateOfDefPhi(mu);
+    }
+  }
+
+  for (size_t opndId = 0; opndId < expr->GetNumOpnds(); ++opndId) {
+    ResetLiveStateOfDefPhi(expr->GetOpnd(opndId));
+  }
+}
+
+//  a1 = ...         a2 = ...       |       |    a1 = ...         a2 = ...
+//  b1 = ...         b2 = ...       |       |    b1 = ...         b2 = ...
+//  c1 = a1 + b1     c2 = a2 + b2   | ====> |          \          /
+//            \     /               |       |        a3 = phi(a1, a2)
+//      a3 = phi(a1, a2)            |       |        b3 = phi(b1, b2)
+//      b3 = phi(b1, b2)            |       |        c3 = a3 + b3
+//      c3 = phi(c1, c2)            |       |
+bool MeSink::MergePhiWithPrevAssign(MePhiNode *phi, BB *bb) {
+  if (sinkCnt >= MeOption::sinkLimit) {
+    return false;
+  }
+  if (phi == nullptr) {
+    return false;
+  }
+  if (!phi->GetIsLive()) {
+    return false;
+  }
+  auto *lhs = phi->GetLHS();
+  if (lhs->IsVolatile() || lhs->GetPrimType() == PTY_ref) {
+    return false;
+  }
+  std::map<ScalarMeExpr*, MeStmt*> defStmts;
+  auto defUseInfoOfPhiOpnds = DefAndUseInfoOfPhiOpnds(phi, defStmts);
+  if (!defUseInfoOfPhiOpnds.allOpndsDefedByStmt || !defUseInfoOfPhiOpnds.allOpndsUsedOnlyInPhi) {
+    return false;
+  }
+
+  int domCnt = 0;
+  int notDomCnt = 0;
+  for (const auto &scalar2defStmt : std::as_const(defStmts)) {
+    if (!pdomTree->Dominate(*bb, *scalar2defStmt.second->GetBB())) {
+      ++notDomCnt;
+    } else {
+      ++domCnt;
+    }
+  }
+  // if exist a defstmt not post-domed by phi, that defstmt may cannot be removed after merge.
+  // set a threld at 4, above which, abandon merge phi with defstmts.
+  constexpr int threldOfSinkPreAssign = 4;
+  if (domCnt < (notDomCnt * threldOfSinkPreAssign)) {
+    return false;
+  }
+
+  if (defUseInfoOfPhiOpnds.opndsHasIdenticalVal && !OpndOfExprRedefined(defUseInfoOfPhiOpnds.valueExpr)) {
+    auto *assign = irMap->CreateAssignMeStmt(*lhs, *defUseInfoOfPhiOpnds.valueExpr, *bb);
+    if (debug) {
+      LogInfo::MapleLogger() << sinkCnt << ": sink phi ";
+      phi->Dump(irMap);
+      LogInfo::MapleLogger() << " as ";
+      assign->Dump(irMap);
+    }
+    ++sinkCnt;
+
+    bb->GetMeStmts().push_front(assign);
+    auto *newLhs = irMap->CreateRegOrVarMeExprVersion(lhs->GetOstIdx());
+    newLhs->SetDefBy(kDefByPhi);
+    newLhs->SetDefPhi(*phi);
+    phi->SetLHS(newLhs);
+    phi->SetIsLive(false);
+    return true;
+  }
+
+  auto &opnds = phi->GetOpnds();
+  MeExpr *siblingRhs = nullptr;
+  for (size_t opndId = 0; opndId < opnds.size(); ++opndId) {
+    auto *opnd = opnds[opndId];
+    if (opnd->GetDefBy() != kDefByStmt) {
+      return false;
+    }
+    if (!ScalarHasValidDefStmt(opnd)) {
+      return false;
+    }
+
+    auto *useSitesOfOpnd = useInfoOfExprs->GetUseSitesOfExpr(opnd);
+    if (useSitesOfOpnd == nullptr || useSitesOfOpnd->size() != 1) {
+      return false;
+    }
+
+    auto *defStmt = opnd->GetDefStmt();
+    auto *defBB = defStmt->GetBB();
+    if (defBB == bb) {
+      return false;
+    }
+
+    auto *chiList = defStmt->GetChiList();
+    if (chiList != nullptr && !chiList->empty()) {
+      return false;
+    }
+
+    auto *rhs = defStmt->GetRHS();
+    if (rhs == nullptr) {
+      return false;
+    }
+
+    auto *predBB = bb->GetPred(opndId);
+    auto *rhsAtEndOfPredBB = ConstructExpr(rhs, predBB, bb);
+    if (rhsAtEndOfPredBB == nullptr) {
+      return false;
+    }
+
+    // opnd of rhs maybe redefined, but if we get the same value at bb, the define stmt still sinkable
+    if (!ExprsHasSameValue(rhsAtEndOfPredBB, rhs)) {
+      return false;
+    }
+
+    if (siblingRhs == nullptr) {
+      siblingRhs = rhsAtEndOfPredBB;
+      continue;
+    }
+
+    auto *siblingRhsAtEndOfPredBB = ConstructExpr(siblingRhs, predBB, bb);
+    if (ExprsHasSameValue(siblingRhsAtEndOfPredBB, rhsAtEndOfPredBB)) {
+      continue;
+    }
+    return false;
+  }
+
+  if (siblingRhs == nullptr) {
+    return false;
+  }
+
+  auto *rhsInCurrentBB = ConstructExpr(siblingRhs, nullptr, bb);
+  ResetLiveStateOfDefPhi(rhsInCurrentBB);
+  auto *assign = irMap->CreateAssignMeStmt(*lhs, *rhsInCurrentBB, *bb);
+  bb->GetMeStmts().push_front(assign);
+  bb->GetMePhiList().erase(phi->GetLHS()->GetOstIdx());
+  if (debug) {
+    LogInfo::MapleLogger() << sinkCnt << ": sink phi ";
+    phi->Dump(irMap);
+    LogInfo::MapleLogger() << " as ";
+    assign->Dump(irMap);
+  }
+  ++sinkCnt;
+
+  // remove define stmt of phi opnds
+  std::set<ScalarMeExpr *> scalarHasRemovedDefStmt;
+  for (auto *opnd : opnds) {
+    if (opnd->GetDefBy() != kDefByStmt) {
+      return false;
+    }
+    const auto &erased = scalarHasRemovedDefStmt.emplace(opnd);
+    if (!erased.second) {
+      continue;
+    }
+    auto *defStmt = opnd->GetDefStmt();
+    if (pdomTree->Dominate(*bb, *defStmt->GetBB())) {
+      defStmt->GetBB()->RemoveMeStmt(defStmt);
+      defStmt->SetIsLive(false);
+    }
+  }
+  return true;
+}
+
+static void CollectUsedScalar(MeExpr *expr, ScalarVec &scalarVec) {
+  switch (expr->GetMeOp()) {
+    case kMeOpReg:
+    case kMeOpVar: {
+      (void)scalarVec.insert(static_cast<ScalarMeExpr *>(expr));
+      break;
+    }
+    case kMeOpIvar: {
+      for (auto *mu : static_cast<IvarMeExpr *>(expr)->GetMuList()) {
+        (void)scalarVec.insert(mu);
+      }
+      break;
+    }
+    default: {
+      for (size_t opndId = 0; opndId < expr->GetNumOpnds(); ++opndId) {
+        auto opnd = expr->GetOpnd(opndId);
+        if (opnd == nullptr) {
+          continue;
+        }
+        CollectUsedScalar(opnd, scalarVec);
+      }
+      break;
+    }
+  }
+}
+
+static ScalarMeExpr *IsSelfCopy(const AssignMeStmt *assign) {
+  auto *rhs = GetEquivalentScalar(assign->GetRHS());
+  if (rhs == nullptr) {
+    return nullptr;
+  }
+
+  auto *lhs = assign->GetLHS();
+  if (lhs->GetOst() == static_cast<ScalarMeExpr*>(rhs)->GetOst()) {
+    return static_cast<ScalarMeExpr*>(rhs);
+  } else {
+    return nullptr;
+  }
+}
+
+static inline bool IsTryCatchBB(const BB *bb) {
+  return bb->GetAttributes(kBBAttrIsTry) || bb->GetAttributes(kBBAttrIsCatch);
+}
+
+static bool BBIsEmptyOrContainsSingleGoto(const BB *bb) {
+  if (bb == nullptr || bb->GetMeStmts().empty()) {
+    return true;
+  }
+
+  auto *stmt = &bb->GetMeStmts().front();
+  while (stmt != nullptr) {
+    if (stmt->GetOp() == OP_comment) {
+      stmt = stmt->GetNext();
+    } else if (stmt->GetOp() == OP_goto) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  return false;
+}
+
+// we should not sink stmt from non-loop BB into loop BB or from outter loop into inner loop.
+// if toBB is in a different loop with fromBB, return a dominator of toBB which is in the same loop with fromBB.
+const BB *MeSink::BestSinkBB(const BB *fromBB, const BB *toBB) {
+  CHECK_FATAL(domTree->Dominate(*fromBB, *toBB), "fromBB must dom toBB");
+  if (fromBB == toBB) {
+    return toBB;
+  }
+
+  // fromBB strictly dom toBB, fromBB must in the outter loop
+  auto *loopOutter = loopInfo->GetBBLoopParent(fromBB->GetBBId());
+  auto *loopInner = loopInfo->GetBBLoopParent(toBB->GetBBId());
+
+  while (loopOutter != loopInner || BBIsEmptyOrContainsSingleGoto(toBB)) {
+    auto domBBId = BBId(domTree->GetDom(toBB->GetID())->GetID());
+    loopInner = loopInfo->GetBBLoopParent(domBBId);
+    toBB = func->GetCfg()->GetBBFromID(domBBId);
+  }
+
+  CHECK_FATAL(domTree->Dominate(*fromBB, *toBB), "fromBB must dom toBB");
+  return toBB;
+}
+
+void MeSink::RecordStmtSinkToHeaderOfTargetBB(MeStmt *defStmt, const BB *targetBB) {
+  if (defStmtsSinkToHeader[targetBB->GetBBId()] == nullptr) {
+    defStmtsSinkToHeader[targetBB->GetBBId()] = std::make_unique<std::list<MeStmt *>>();
+  }
+  defStmtsSinkToHeader[targetBB->GetBBId()]->push_front(defStmt);
+}
+
+void MeSink::RecordStmtSinkToBottomOfTargetBB(MeStmt *defStmt, const BB *targetBB) {
+  if (defStmtsSinkToBottom[targetBB->GetBBId()] == nullptr) {
+    defStmtsSinkToBottom[targetBB->GetBBId()] = std::make_unique<std::list<MeStmt *>>();
+  }
+  defStmtsSinkToBottom[targetBB->GetBBId()]->push_front(defStmt);
+}
+
+std::pair<const BB*, bool> MeSink::CalCandSinkBBForUseSites(const ScalarMeExpr *scalar, const UseSitesType &useList) {
+  if (useList.empty()) {
+    return {nullptr, false};
+  }
+
+  const BB *candSinkBB = nullptr;
+  for (auto it = useList.rbegin(); it != useList.rend(); ++it) {
+    const auto &useItem = *it;
+    if (useItem.IsUseByStmt()) {
+      auto *useBB = it->GetUseBB();
+      if (candSinkBB == nullptr) {
+        candSinkBB = useBB;
+        continue;
+      }
+      while (candSinkBB != useBB && !domTree->Dominate(*candSinkBB, *useBB)) {
+        candSinkBB = func->GetCfg()->GetBBFromID(BBId(domTree->GetDom(candSinkBB->GetID())->GetID()));
+      }
+    } else {
+      auto *usePhi = it->GetPhi();
+      auto *useBB = it->GetUseBB();
+      for (size_t id = 0; id < usePhi->GetOpnds().size(); ++id) {
+        if (usePhi->GetOpnd(id) != scalar) {
+          continue;
+        }
+        auto *predBB = useBB->GetPred(id);
+        if (candSinkBB == nullptr) {
+          candSinkBB = predBB;
+          continue;
+        }
+        while (candSinkBB != predBB && !domTree->Dominate(*candSinkBB, *predBB)) {
+          candSinkBB = func->GetCfg()->GetBBFromID(BBId(domTree->GetDom(candSinkBB->GetID())->GetID()));
+        }
+      }
+    }
+  }
+
+  bool useSitesDomByCandSinkBB = true;
+  for (auto &useSite : useList) {
+    useSitesDomByCandSinkBB &= (candSinkBB != useSite.GetUseBB() || useSite.IsUseByPhi());
+  }
+
+  return {candSinkBB, useSitesDomByCandSinkBB};
+}
+
+const BB *MeSink::CalSinkSiteOfScalarDefStmt(const ScalarMeExpr *scalar) {
+  if (scalar->IsVolatile() || scalar->GetPrimType() == PTY_ref) {
+    return nullptr;
+  }
+  auto *useList = useInfoOfExprs->GetUseSitesOfExpr(scalar);
+  if (useList == nullptr || useList->empty()) {
+    return nullptr;
+  }
+  if (!scalar->IsDefByStmt()) {
+    return nullptr;
+  }
+  auto *defStmt = scalar->GetDefStmt();
+  if (!defStmt->GetIsLive()) {
+    return nullptr;
+  }
+  if (defStmt->GetChiList() != nullptr && !defStmt->GetChiList()->empty()) {
+    return nullptr;
+  }
+  if (!DefStmtSinkable(defStmt)) {
+    return nullptr;
+  }
+  if (IsTryCatchBB(defStmt->GetBB())) {
+    return nullptr;
+  }
+
+  // remove self copies like: a_2 = a_1;
+  if (auto *rhsScalar = IsSelfCopy(static_cast<AssignMeStmt *>(defStmt))) {
+    (void)useInfoOfExprs->ReplaceScalar(irMap, scalar, rhsScalar);
+    defStmt->GetBB()->RemoveMeStmt(defStmt);
+    defStmt->SetIsLive(false);
+    return nullptr;
+  }
+
+  const auto &candSinkSite = CalCandSinkBBForUseSites(scalar, *useList);
+  const BB *candSinkBB = candSinkSite.first;
+  if (candSinkBB == nullptr) {
+    // scalar defined without use, the defStmt should be removed
+    return nullptr;
+  }
+
+  auto *defBB = defStmt->GetBB();
+  if (!domTree->Dominate(*defBB, *candSinkBB)) {
+    return nullptr;
+  }
+  candSinkBB = BestSinkBB(defBB, candSinkBB);
+  if (candSinkBB == nullptr || IsTryCatchBB(candSinkBB)) {
+    return nullptr;
+  }
+
+  if (candSinkSite.second) {
+    RecordStmtSinkToBottomOfTargetBB(defStmt, candSinkBB);
+  } else {
+    if (candSinkBB == defBB) {
+      return nullptr;
+    }
+    RecordStmtSinkToHeaderOfTargetBB(defStmt, candSinkBB);
+  }
+  return candSinkBB;
+}
+
+void MeSink::ProcessPhiList(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+  auto &phiList = bb->GetMePhiList();
+  if (phiList.empty()) {
+    return;
+  }
+
+  for (auto &ost2Phi : std::as_const(phiList)) {
+    versionStack[ost2Phi.first]->push_front(ost2Phi.second->GetLHS());
+    AddNewDefinedScalar(ost2Phi.second->GetLHS());
+  }
+
+  for (auto &ost2Phi : std::as_const(phiList)) {
+    if (!ost2Phi.second->GetIsLive()) {
+      continue;
+    }
+    (void)MergePhiWithPrevAssign(ost2Phi.second, bb);
+  }
+}
+
+void MeSink::SinkStmtsToHeaderOfBB(BB *bb) {
+  if (BBIsEmptyOrContainsSingleGoto(bb)) {
+    return;
+  }
+
+  bool changed = true;
+  while (changed) {
+    changed = false;
+    auto sinkCands = std::move(defStmtsSinkToHeader[bb->GetBBId()]);
+    defStmtsSinkToHeader[bb->GetBBId()] = nullptr;
+    if (sinkCands == nullptr || sinkCands->empty()) {
+      return;
+    }
+
+    for (auto &defStmt : std::as_const(*sinkCands)) {
+      if (defStmt->GetBB() == bb) {
+        continue;
+      }
+      if (!defStmt->GetIsLive()) {
+        continue;
+      }
+      auto *lhs = defStmt->GetLHS();
+      if (versionStack[lhs->GetOstIdx()]->front() != lhs) {
+        continue;
+      }
+      auto *chiList = defStmt->GetChiList();
+      if (chiList != nullptr && !chiList->empty()) {
+        continue;
+      }
+      if (sinkCnt >= MeOption::sinkLimit) {
+        return;
+      }
+
+      bool opndRedefined = false;
+      for (size_t opndId = 0; opndId < defStmt->NumMeStmtOpnds(); ++opndId) {
+        auto *opnd = defStmt->GetOpnd(opndId);
+        if (OpndOfExprRedefined(opnd)) {
+          opndRedefined = true;
+          break;
+        }
+      }
+      if (opndRedefined) {
+        continue;
+      }
+
+      if (debug) {
+        LogInfo::MapleLogger() << sinkCnt << ": sink stmt to header of bb(" << bb->GetBBId() << ") from bb"
+                               << defStmt->GetBB()->GetBBId() << "): ";
+        defStmt->Dump(irMap);
+      }
+      ++sinkCnt;
+      defStmt->GetBB()->GetMeStmts().erase(defStmt);
+      bb->GetMeStmts().push_front(defStmt);
+      defStmt->SetBB(bb);
+      changed = true;
+      ScalarVec scalarVec;
+      for (size_t opndId = 0; opndId < defStmt->NumMeStmtOpnds(); ++opndId) {
+        auto *opnd = defStmt->GetOpnd(opndId);
+        if (opnd == nullptr) {
+          continue;
+        }
+        CollectUsedScalar(opnd, scalarVec);
+      }
+      for (auto *scalar : scalarVec) {
+        (void)CalSinkSiteOfScalarDefStmt(scalar);
+      }
+    }
+  }
+}
+
+void MeSink::SinkStmtsToBottomOfBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+  bool changed = true;
+  while (changed) {
+    changed = false;
+    auto sinkCands = std::move(defStmtsSinkToBottom[bb->GetBBId()]);
+    defStmtsSinkToBottom[bb->GetBBId()] = nullptr;
+    if (sinkCands == nullptr || sinkCands->empty()) {
+      return;
+    }
+
+    for (auto &stmt : std::as_const(*sinkCands)) {
+      if (!stmt->GetIsLive()) {
+        continue;
+      }
+      if (sinkCnt >= MeOption::sinkLimit) {
+        return;
+      }
+
+      auto *lhs = stmt->GetLHS();
+      if (versionStack[lhs->GetOstIdx()]->front() != lhs) {
+        continue;
+      }
+      auto *chiList = stmt->GetChiList();
+      if (chiList != nullptr && !chiList->empty()) {
+        continue;
+      }
+      versionStack[lhs->GetOstIdx()]->pop_front();
+
+      bool opndRedefined = false;
+      for (size_t opndId = 0; opndId < stmt->NumMeStmtOpnds(); ++opndId) {
+        auto *opnd = stmt->GetOpnd(opndId);
+        if (OpndOfExprRedefined(opnd)) {
+          opndRedefined = true;
+          break;
+        }
+      }
+      if (opndRedefined) {
+        ProcessStmt(stmt);
+        continue;
+      }
+
+      if (debug) {
+        LogInfo::MapleLogger() << sinkCnt << ": sink stmt to bottom of bb(" << bb->GetBBId() << ") from bb("
+                               << stmt->GetBB()->GetBBId() << "): ";
+        stmt->Dump(irMap);
+      }
+      ++sinkCnt;
+      stmt->GetBB()->GetMeStmts().erase(stmt);
+      auto *lastStmt = &bb->GetMeStmts().back();
+      if (bb->GetMeStmts().empty()) {
+        bb->GetMeStmts().push_front(stmt);
+      } else if (IsBranch(lastStmt->GetOp())) {
+        bb->InsertMeStmtBefore(lastStmt, stmt);
+      } else {
+        bb->InsertMeStmtAfter(lastStmt, stmt);
+      }
+      stmt->SetBB(bb);
+
+      ProcessStmt(stmt);
+      ScalarVec scalarVec;
+      for (size_t opndId = 0; opndId < stmt->NumMeStmtOpnds(); ++opndId) {
+        auto *opnd = stmt->GetOpnd(opndId);
+        if (opnd == nullptr) {
+          continue;
+        }
+        CollectUsedScalar(opnd, scalarVec);
+      }
+      for (auto *scalar : scalarVec) {
+        (void)CalSinkSiteOfScalarDefStmt(scalar);
+      }
+      changed = true;
+    }
+  }
+}
+
+void MeSink::SinkStmtsInBB(BB *bb) {
+  if (debug) {
+    LogInfo::MapleLogger() << "Proceess bb " << bb->GetBBId() << ": " << std::endl;
+  }
+
+  std::vector<uint32> curStackSizeVec(versionStack.size(), 0);
+  for (size_t i = 1; i < versionStack.size(); ++i) {
+    curStackSizeVec[i] = static_cast<uint32>(versionStack[i]->size());
+  }
+
+  ProcessPhiList(bb);
+  SinkStmtsToHeaderOfBB(bb);
+  for (auto &meStmt : bb->GetMeStmts()) {
+    ProcessStmt(&meStmt);
+  }
+  SinkStmtsToBottomOfBB(bb);
+
+  auto &domChildren = domTree->GetDomChildren(bb->GetID());
+  for (const auto &childbbid : domChildren) {
+    SinkStmtsInBB(func->GetCfg()->GetBBFromID(BBId(childbbid)));
+  }
+
+  for (size_t i = 1; i < versionStack.size(); ++i) {
+    auto *liveStack = versionStack[i].get();
+    size_t curSize = curStackSizeVec[i];
+    while (liveStack->size() > curSize) {
+      liveStack->pop_front();
+    }
+  }
+}
+
+void MeSink::CalSinkSites() {
+  for (auto &scalar2UseSites : useInfoOfExprs->GetUseSites()) {
+    auto *expr = scalar2UseSites.first;
+    if (expr == nullptr) {
+      continue;
+    }
+    if (!expr->IsScalar()) {
+      continue;
+    }
+    (void)CalSinkSiteOfScalarDefStmt(static_cast<ScalarMeExpr*>(expr));
+  }
+}
+
+void MeSink::Run() {
+  // 1: collect use sites and calculate the candidate sinking stmts
+  for (auto *bb : func->GetCfg()->GetAllBBs()) {
+    if (bb != nullptr && bb->GetKind() == kBBIgoto) {
+      if (debug) {
+        LogInfo::MapleLogger() << "skip func(" << func->GetName() << ") contains igoto." << std::endl;
+      }
+      return;
+    }
+  }
+
+  useInfoOfExprs = &irMap->GetExprUseInfo();
+  if (!useInfoOfExprs->UseInfoOfScalarIsValid()) { // sink only depends on use info of scalar
+    useInfoOfExprs->CollectUseInfoInFunc(irMap, domTree, kUseInfoOfScalar);
+  }
+
+  // 2: calculate sink site based pre-collected usesites.
+  CalSinkSites();
+
+  // 3: sink stmts
+  auto *entryBB = func->GetCfg()->GetCommonEntryBB();
+  SinkStmtsInBB(entryBB->GetSucc(0));
+  useInfoOfExprs->InvalidUseInfo();
+}
+
+void MEMeSink::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+    aDep.AddRequired<MEDominance>();
+    aDep.AddRequired<MELoopAnalysis>();
+    aDep.SetPreservedAll();
+}
+
+bool MEMeSink::PhaseRun(maple::MeFunction &f) {
+  static uint32 sinkedFuncCnt = 0;
+  if (sinkedFuncCnt >= MeOption::sinkPULimit) {
+    return false;
+  }
+  ++sinkedFuncCnt;
+  auto phase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = phase->GetDomResult();
+  CHECK_FATAL(dom != nullptr, "failed to get dominace tree");
+  auto pdom = phase->GetPdomResult();
+  CHECK_FATAL(pdom != nullptr, "failed to get postdominace tree");
+  auto *loopInfo = GET_ANALYSIS(MELoopAnalysis, f);
+  CHECK_NULL_FATAL(loopInfo);
+  auto *irMap = f.GetIRMap();
+  if (DEBUGFUNC_NEWPM(f)) {
+    f.GetCfg()->DumpToFile("sink-");
+    f.Dump();
+  }
+
+  MeSink sink(&f, irMap, dom, pdom, loopInfo, DEBUGFUNC_NEWPM(f));
+  sink.Run();
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_slp.cpp b/src/mapleall/maple_me/src/me_slp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c5832d65be08a25154776b9b07ef4b9f7ed82e95
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_slp.cpp
@@ -0,0 +1,3411 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_slp.h"
+#include <optional>
+#include "me_cfg.h"
+#include "me_irmap.h"
+#include "me_dominance.h"
+#include "common_utils.h"
+
+#define SLP_DEBUG(X) \
+do { if (debug) { LogInfo::MapleLogger() << "[SLP] "; (X); } } while (false)
+
+#define SLP_OK_DEBUG(X) \
+do { if (debug) { LogInfo::MapleLogger() << "[SLP OK] "; (X); } } while (false)
+
+#define SLP_GATHER_DEBUG(X) \
+do { if (debug) { LogInfo::MapleLogger() << "[SLP GATHER] "; (X); } } while (false)
+
+#define SLP_FAILURE_DEBUG(X) \
+do { if (debug) { LogInfo::MapleLogger() << "[SLP FAILURE] "; (X); } } while (false)
+
+namespace {
+using namespace maple;
+constexpr maple::int32 kHugeCost = 10000;  // Used for impossible vectorized node
+
+const std::vector<Opcode> supportedOps = {
+    OP_iread, OP_ireadoff, OP_add, OP_sub, OP_constval, OP_bxor, OP_band, OP_mul, OP_intrinsicop
+};
+
+const std::vector<MIRIntrinsicID> supportedIntrns = {INTRN_C_rev_4, INTRN_C_rev_8, INTRN_C_rev16_2};
+
+std::vector<int32> *localSymOffsetTab = nullptr;
+}  // anonymous namespace
+
+namespace maple {
+using namespace maplebe;
+#include "immvalid.def"
+}
+
+namespace maple {
+// A wrapper class of meExpr with its defStmt, this can avoid repeated searches for use-def chains
+constexpr int8 k8Bit = 8;
+class ExprWithDef {
+ public:
+  explicit ExprWithDef(MeExpr *meExpr, BB *bb = nullptr) : expr(meExpr) {
+    if (expr->GetOp() == OP_regread) {
+      FindDef(static_cast<ScalarMeExpr*>(expr), bb);
+    }
+  }
+
+  MeExpr *GetExpr() {
+    return expr;
+  }
+
+  MeStmt *GetDefStmt() {
+    return defStmt;
+  }
+
+  MeExpr *GetRealExpr() {
+    if (defStmt != nullptr) {
+      return defStmt->GetRHS();
+    }
+    return expr;
+  }
+
+ private:
+  void FindDef(ScalarMeExpr *scalarExpr, BB *bb) {
+    if (scalarExpr->GetDefBy() != kDefByStmt) {
+      return;
+    }
+    auto *stmt = scalarExpr->GetDefStmt();
+    if (bb != nullptr && stmt->GetBB() != bb) {
+      return;
+    }
+    defStmt = stmt;
+  }
+
+  MeExpr *expr = nullptr;
+  MeStmt *defStmt = nullptr;
+};
+
+// ----------------- //
+//  Memory Location  //
+// ----------------- //
+MeExpr *MemLoc::Emit() const {
+  return rawExpr;
+}
+
+// Dump example:
+// [(mx4 mx3 -mx5), 8] : int32
+void MemLoc::DumpWithoutEndl() const {
+  LogInfo::MapleLogger() << "[";
+  base->Dump();
+  LogInfo::MapleLogger() << ", " << offset << "] : ";
+  type->Dump(0);
+}
+
+void MemLoc::Dump() const {
+  DumpWithoutEndl();
+  LogInfo::MapleLogger() << std::endl;
+}
+
+static bool IsPointerType(PrimType type) {
+  return type == PTY_ptr || type == PTY_a64;
+}
+
+// Only support add, sub, constval, iaddrof, pointer cvt for now, we can support more op if more scenes are found
+void MemoryHelper::ExtractAddendOffset(const MeExpr &expr, bool isNeg, MemLoc &memLoc) {
+  Opcode op = expr.GetOp();
+  switch (op) {
+    case OP_add: {
+      ExtractAddendOffset(*expr.GetOpnd(0), isNeg, memLoc);
+      ExtractAddendOffset(*expr.GetOpnd(1), isNeg, memLoc);
+      break;
+    }
+    case OP_sub: {
+      ExtractAddendOffset(*expr.GetOpnd(0), isNeg, memLoc);
+      ExtractAddendOffset(*expr.GetOpnd(1), !isNeg, memLoc);
+      break;
+    }
+    case OP_iaddrof: {
+      FieldID fieldId = static_cast<const OpMeExpr&>(expr).GetFieldID();
+      if (fieldId != 0) {
+        auto *type = static_cast<const OpMeExpr&>(expr).GetType();
+        CHECK_FATAL(type->GetKind() == kTypePointer, "must be");
+        auto *pointedType = static_cast<MIRPtrType*>(type)->GetPointedType();
+        CHECK_FATAL(pointedType->GetKind() == kTypeStruct || pointedType->GetKind() == kTypeUnion, "must be");
+        auto bitOffset = static_cast<MIRStructType*>(pointedType)->GetBitOffsetFromBaseAddr(fieldId);
+        memLoc.offset += (bitOffset / k8Bit);
+      }
+      ExtractAddendOffset(*expr.GetOpnd(0), isNeg, memLoc);
+      break;
+    }
+    case OP_constval: {
+      auto val = static_cast<const ConstMeExpr&>(expr).GetExtIntValue();
+      memLoc.offset += (isNeg ? -val : val);
+      break;
+    }
+    case OP_cvt:
+    case OP_retype: {
+      const auto &opExpr = static_cast<const OpMeExpr&>(expr);
+      PrimType fromType = opExpr.GetOpndType();
+      PrimType toType = opExpr.GetPrimType();
+      if (IsPointerType(fromType) && IsPointerType(toType)) {
+        ExtractAddendOffset(*opExpr.GetOpnd(0), isNeg, memLoc);
+        break;
+      }
+    }
+    [[clang::fallthrough]];
+    default: {
+      if (memLoc.base == nullptr) {
+        memLoc.base = alloc.GetMemPool()->New<MemBasePtr>();
+      }
+      memLoc.base->PushAddendExpr(alloc, expr, isNeg);
+      break;
+    }
+  }
+}
+
+void MemoryHelper::UniqueMemLocBase(MemLoc &memLoc) {
+  // must be sorted first
+  memLoc.base->Sort();
+  auto key = memLoc.base->GetHashKey();
+  auto it = basePtrSet.find(key);
+  if (it != basePtrSet.end()) {
+    auto &vec = it->second;
+    bool found = false;
+    for (auto &base : vec) {
+      if (*base == *memLoc.base) {
+        // found it, update base
+        memLoc.base = base;
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      // found vec but no target element, just push it
+      vec.push_back(memLoc.base);
+    }
+  } else {
+    // Create vec and push new element
+    basePtrSet[key].push_back(memLoc.base);
+  }
+}
+
+MemLoc *MemoryHelper::GetMemLoc(VarMeExpr &var) {
+  auto *ost = var.GetOst();
+  auto *prevLevOst = ost->GetPrevLevelOst();
+  CHECK_NULL_FATAL(prevLevOst);
+  // find memLoc from cache first
+  auto it = cache.find(&var);
+  if (it != cache.end()) {
+    return it->second;
+  }
+  auto *memLocPtr = alloc.GetMemPool()->New<MemLoc>();
+  MemLoc &memLoc = *memLocPtr;
+  memLoc.rawExpr = &var;
+  memLoc.offset = ost->GetOffset().val / k8Bit;
+  memLoc.type = ost->GetType();
+  memLoc.base = alloc.GetMemPool()->New<MemBasePtr>();
+  memLoc.base->SetBaseOstIdx(prevLevOst->GetIndex().get());
+
+  // unique memLoc base
+  UniqueMemLocBase(memLoc);
+
+  // update cache
+  cache.emplace(&var, &memLoc);
+  return &memLoc;
+}
+
+MemLoc *MemoryHelper::GetMemLoc(IvarMeExpr &ivar) {
+  // find memLoc from cache first
+  auto it = cache.find(&ivar);
+  if (it != cache.end()) {
+    return it->second;
+  }
+
+  auto *memLocPtr = alloc.GetMemPool()->New<MemLoc>();
+  MemLoc &memLoc = *memLocPtr;
+  memLoc.rawExpr = &ivar;
+  auto *ivarBase = ivar.GetBase();
+  MeExpr *realBase = ivarBase;
+  if (ivarBase->GetOp() == OP_regread) {
+    ExprWithDef exprWithDef(ivarBase);
+    realBase = exprWithDef.GetRealExpr();
+  }
+  ExtractAddendOffset(*realBase, false, memLoc);
+  // bugfix for constval ivar.base
+  if (memLoc.base == nullptr) {
+    memLoc.base = alloc.GetMemPool()->New<MemBasePtr>();
+    memLoc.base->PushAddendExpr(alloc, *ivar.GetBase(), false);
+  }
+  // unique memLoc base
+  UniqueMemLocBase(memLoc);
+
+  // Consider filedId and offset of ivar to get extraOffset
+  int32 extraOffset = 0;
+  if (ivar.GetFieldID() != 0) {
+    auto *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx());
+    ASSERT(type->GetKind() == kTypePointer, "must be");
+    auto *pointedType = static_cast<MIRPtrType*>(type)->GetPointedType();
+    // pointedType is either kTypeStruct or kTypeUnion
+    ASSERT(pointedType->GetKind() == kTypeStruct || pointedType->GetKind() == kTypeUnion, "must be");
+    auto *structType = static_cast<MIRStructType*>(pointedType);
+    auto bitOffset = structType->GetBitOffsetFromBaseAddr(ivar.GetFieldID());
+    extraOffset += (bitOffset / k8Bit);
+  }
+  extraOffset += ivar.GetOffset();
+  memLoc.extraOffset = extraOffset;
+  memLoc.offset += extraOffset;
+  memLoc.type = ivar.GetType();
+  // update cache
+  cache.emplace(&ivar, &memLoc);
+  return &memLoc;
+}
+
+MemLoc *MemoryHelper::GetMemLoc(MeExpr &meExpr) {
+  auto meOp = meExpr.GetMeOp();
+  switch (meOp) {
+    case kMeOpIvar:
+      return GetMemLoc(static_cast<IvarMeExpr&>(meExpr));
+    case kMeOpVar:
+      return GetMemLoc(static_cast<VarMeExpr&>(meExpr));
+    default:
+      CHECK_FATAL(false, "MemoryHelper::GetMemLoc: not supported meOp");
+      break;
+  }
+  return nullptr;
+}
+
+bool MemoryHelper::HaveSameBase(const MemLoc &mem1, const MemLoc &mem2) {
+  CHECK_NULL_FATAL(mem1.base);
+  CHECK_NULL_FATAL(mem2.base);
+  return mem1.base == mem2.base;
+}
+
+std::optional<int32> MemoryHelper::Distance(const MemLoc &from, const MemLoc &to) {
+  if (!HaveSameBase(from, to)) {
+    return {};
+  }
+  return to.offset - from.offset;
+}
+
+bool MemoryHelper::IsSame(const MemLoc &mem1, const MemLoc &mem2) {
+  if (mem1.type != mem2.type) {
+    return false;
+  }
+  auto dis = Distance(mem1, mem2);
+  if (!dis) {
+    return false;
+  }
+  return dis.value() == 0;
+}
+
+bool MemoryHelper::IsConsecutive(const MemLoc &mem1, const MemLoc &mem2, bool mustSameType) {
+  if (mustSameType && mem1.type != mem2.type) {
+    return false;
+  }
+  auto dis = Distance(mem1, mem2);
+  if (!dis) {
+    return false;
+  }
+  return dis.value() == mem1.type->GetSize();
+}
+
+bool MemoryHelper::MustHaveNoOverlap(const MemLoc &mem1, const MemLoc &mem2) {
+  // If the bases are not same, we can't tell if they overlap
+  if (!HaveSameBase(mem1, mem2)) {
+    return false;
+  }
+  int32 offset1 = mem1.offset;
+  int32 offset2 = mem2.offset;
+  int32 size1 = mem1.type->GetSize();
+  int32 size2 = mem2.type->GetSize();
+  // overlapping case one:
+  // mem1: |------|
+  // mem2:     |------|
+  if (offset1 <= offset2 && (offset2 - offset1) < size1) {
+    return false;
+  }
+  // overlapping case two:
+  // mem1:     |------|
+  // mem2: |------|
+  if (offset2 < offset1 && (offset1 - offset2) < size2) {
+    return false;
+  }
+  return true;
+}
+
+// Order-insensitive for now, maybe need a new parameter named `isOrderSensitive`
+bool MemoryHelper::IsAllIvarConsecutive(const std::vector<MeExpr*> &ivarVec, bool mustSameType) {
+  CHECK_FATAL(ivarVec.size() >= 2, "must be");
+  std::vector<MemLoc*> memLocVec;
+  auto *firstMem = GetMemLoc(static_cast<IvarMeExpr&>(*ivarVec[0]));
+  memLocVec.push_back(firstMem);
+  for (size_t i = 1; i < ivarVec.size(); ++i) {
+    auto *mem = GetMemLoc(static_cast<IvarMeExpr&>(*ivarVec[i]));
+    if (mustSameType && firstMem->type != mem->type) {
+      return false;
+    }
+    if (!HaveSameBase(*firstMem, *mem)) {
+      return false;
+    }
+    memLocVec.push_back(mem);
+  }
+  std::sort(memLocVec.begin(), memLocVec.end(), [](const MemLoc *mem1, const MemLoc *mem2) {
+    return mem1->offset < mem2->offset;
+  });
+  for (size_t i = 0; i < ivarVec.size() - 1; ++i) {
+    if (!IsConsecutive(*memLocVec[i], *memLocVec[i + 1], mustSameType)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+int32 GetLocalSymApproximateOffset(MIRSymbol *sym, MeFunction &func) {
+  if (localSymOffsetTab == nullptr) {
+    localSymOffsetTab = new std::vector<int32>();
+  }
+  auto &offsetTab = *localSymOffsetTab;
+  uint32 symIdx = sym->GetStIndex();
+  if (symIdx < offsetTab.size()) {
+    return offsetTab[symIdx];
+  }
+  for (uint32 i = offsetTab.size(); i <= symIdx; ++i) {
+    if (i == 0) {
+      offsetTab.push_back(0);
+      continue;
+    }
+    auto *lastSym = func.GetMirFunc()->GetSymbolTabItem(i - 1);
+    if (lastSym == nullptr || lastSym->GetStorageClass() != kScAuto || lastSym->IsDeleted()) {
+      offsetTab.push_back(offsetTab[i - 1]);
+      continue;
+    }
+    // align 8 bytes
+    auto sizeAfterAlign = (lastSym->GetType()->GetSize() + 7) & -8;
+    offsetTab.push_back(offsetTab[i - 1] + sizeAfterAlign);
+  }
+  return offsetTab[symIdx];
+}
+
+std::optional<int32> EstimateStackOffsetOfMemLoc(MemLoc *memLoc, MeFunction &func) {
+  if (memLoc->rawExpr->GetMeOp() != kMeOpIvar) {
+    return {};
+  }
+  auto *ivarBase = static_cast<IvarMeExpr*>(memLoc->rawExpr)->GetBase();
+  if (ivarBase->GetOp() != OP_regread) {
+    return {};
+  }
+  auto *baseRegExpr = static_cast<RegMeExpr*>(ivarBase);
+  if (baseRegExpr->GetDefBy() != kDefByStmt) {
+    return {};
+  }
+  auto *defStmt = baseRegExpr->GetDefStmt();
+  if (defStmt != nullptr && defStmt->GetOp() == OP_regassign) {
+    auto *rhs = static_cast<AssignMeStmt*>(defStmt)->GetRHS();
+    if (rhs->GetOp() == OP_addrof) {
+      auto *ost = static_cast<AddrofMeExpr*>(rhs)->GetOst();
+      CHECK_FATAL(ost, "ost is nullptr");
+      if (ost->IsLocal()) {
+        return GetLocalSymApproximateOffset(ost->GetMIRSymbol(), func);
+      }
+    }
+  }
+  return {};
+}
+
+// This is target-dependent function for armv8, maybe we need abstract it TargetInfo
+bool IsIntStpLdpOffsetValid(uint32 typeBitSize, int32 offset) {
+  switch (typeBitSize) {
+    case 32: {
+      return StrLdr32PairImmValid(offset);
+    }
+    case 64: {
+      return StrLdr64PairImmValid(offset);
+    }
+    default: {
+      CHECK_FATAL(false, "should not be here");
+      break;
+    }
+  }
+  return false;
+}
+
+// This is target-dependent function for armv8, maybe we need abstract it TargetInfo
+bool IsVecStrLdrOffsetValid(uint32 typeBitSize, int32 offset) {
+  switch (typeBitSize) {
+    case 8: {
+      return StrLdr8ImmValid(offset);
+    }
+    case 16: {
+      return StrLdr16ImmValid(offset);
+    }
+    case 32: {
+      return StrLdr32ImmValid(offset);
+    }
+    case 64: {
+      return StrLdr64ImmValid(offset);
+    }
+    case 128: {
+      return StrLdr128ImmValid(offset);
+    }
+    default: {
+      CHECK_FATAL(false, "should not be here");
+      break;
+    }
+  }
+  return false;
+}
+
+// ------------------- //
+//  Assign Stmt Split  //
+// ------------------- //
+// Create a new regassign with specified rhs expr and insert it before anchor stmt
+// return the new created regassign
+AssignMeStmt *CreateAndInsertRegassign(MeExpr &rhsExpr, MeStmt &anchorStmt, MeFunction &func) {
+  auto *bb = anchorStmt.GetBB();
+  auto *regLhs = func.GetIRMap()->CreateRegMeExpr(rhsExpr.GetPrimType());
+  auto *newAssign = func.GetIRMap()->CreateAssignMeStmt(*regLhs, rhsExpr, *bb);
+  newAssign->SetSrcPos(anchorStmt.GetSrcPosition());
+  bb->InsertMeStmtBefore(&anchorStmt, newAssign);
+  return newAssign;
+}
+
+// Only split iassign, regassign
+// Support custom exit conditions if needed
+void TrySplitMeStmt(MeStmt &stmt, MeFunction &func, bool &changed) {
+  Opcode op = stmt.GetOp();
+  if (op == OP_iassign || op == OP_dassign) {
+    // DO NOT split iassign/dassign with agg type
+    auto lhsType = op == OP_iassign ? static_cast<IassignMeStmt&>(stmt).GetLHSVal()->GetPrimType() :
+        static_cast<DassignMeStmt&>(stmt).GetLHS()->GetPrimType();
+    if (lhsType == PTY_agg || stmt.GetRHS()->GetPrimType() == PTY_agg) {
+      return;
+    }
+    auto *rhs = stmt.GetRHS();
+    if (rhs->IsLeaf() && rhs->GetOp() != OP_addroffunc) {
+      return;
+    }
+    auto *newAssign = CreateAndInsertRegassign(*rhs, stmt, func);
+    stmt.SetOpnd(1, newAssign->GetLHS());
+    changed = true;
+    TrySplitMeStmt(*newAssign, func, changed);
+  }
+
+  if (op == OP_regassign) {
+    auto *rhs = stmt.GetRHS();
+    if (rhs->IsLeaf() || rhs->GetMeOp() == kMeOpIvar) {
+      return;
+    }
+    auto *anchorStmt = &stmt;
+    auto numOpnds = static_cast<size_t>(rhs->GetNumOpnds());
+    for (size_t i = 0; i < numOpnds; ++i) {
+      auto *opnd = rhs->GetOpnd(i);
+      if (opnd->IsLeaf()) {
+        continue;
+      }
+      auto *newAssign = CreateAndInsertRegassign(*opnd, *anchorStmt, func);
+      // We should always use the latest rhs here
+      auto *repParent = func.GetIRMap()->ReplaceMeExprExpr(*stmt.GetRHS(), *opnd, *newAssign->GetLHS());
+      if (repParent != nullptr) {
+        static_cast<AssignMeStmt&>(stmt).SetRHS(repParent);
+      }
+      changed = true;
+      TrySplitMeStmt(*newAssign, func, changed);
+    }
+  }
+}
+
+// A wrapper class of iassign stmt with it's store memLoc, this can avoid repeated memLoc calculations
+struct StoreWrapper {
+  StoreWrapper(MeStmt *meStmt, MemLoc *memLoc)
+      : stmt(meStmt), storeMem(memLoc) {}
+
+  MeStmt *stmt = nullptr;  // IassignMeStmt or DassignMeStmt
+  MemLoc *storeMem = nullptr;
+};
+
+bool AreCompatibleMeExprsShallow(const MeExpr &expr1, const MeExpr &expr2) {
+  // We take ivar as a special case because iread and ireadoff are compatible
+  bool bothIvar = (expr1.GetMeOp() == kMeOpIvar && expr2.GetMeOp() == kMeOpIvar);
+  if (!bothIvar && expr1.GetOp() != expr2.GetOp()) {
+    return false;
+  }
+  auto type1 = expr1.GetPrimType();
+  auto type2 = expr2.GetPrimType();
+  // Different pointer types are always compatible
+  bool bothPtrType = IsPointerType(type1) && IsPointerType(type2);
+  if (!bothPtrType && expr1.GetPrimType() != expr2.GetPrimType()) {
+    return false;
+  }
+  return true;
+}
+
+bool AreAllExprsCompatibleShallow(const std::vector<MeExpr*> &exprs) {
+  CHECK_FATAL(!exprs.empty(), "container check");
+  for (size_t i = 0; i < exprs.size() - 1; ++i) {
+    auto *curr = exprs[i];
+    auto *next = exprs[i + 1];
+    if (!AreCompatibleMeExprsShallow(*curr, *next)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Compatible stores need meet the following conditions:
+// (1) same data type
+// (2) 1-level compatible rhs
+bool AreCompatibleStoreWrappers(const StoreWrapper &store1, const StoreWrapper &store2) {
+  CHECK_NULL_FATAL(store1.stmt);
+  CHECK_NULL_FATAL(store2.stmt);
+  if (store1.stmt == store2.stmt) {
+    return true;
+  }
+  // Different pointer types are always compatible
+  bool bothPtrType = IsPointerType(store1.storeMem->type->GetPrimType()) &&
+                     IsPointerType(store2.storeMem->type->GetPrimType());
+  if (!bothPtrType && store1.storeMem->type != store2.storeMem->type) {
+    return false;
+  }
+  return AreCompatibleMeExprsShallow(*store1.stmt->GetRHS(), *store2.stmt->GetRHS());
+}
+
+std::string GetOpName(Opcode op) {
+  return kOpcodeInfo.GetTableItemAt(op).name;
+}
+
+// ------------ //
+//  SSA Update  //
+// ------------ //
+MapleMap<OStIdx, ChiMeNode*> *MergeChiList(const std::vector<MapleMap<OStIdx, ChiMeNode*>*> &chiListVec,
+    IRMap &irMap, MeStmt &newBase) {
+  auto &alloc = irMap.GetIRMapAlloc();
+  auto &mergedChiList = *alloc.New<MapleMap<OStIdx, ChiMeNode*>>(alloc.Adapter());
+  for (auto *chiList : chiListVec) {
+    for (auto &pair : *chiList) {
+      auto ostIdx = pair.first;
+      auto *chi = pair.second;
+      auto it = mergedChiList.find(ostIdx);
+      if (it == mergedChiList.end()) {
+        auto *newChi = irMap.New<ChiMeNode>(&newBase);
+        newChi->SetLHS(chi->GetLHS());
+        chi->GetLHS()->SetDefChi(*newChi);
+        newChi->SetRHS(chi->GetRHS());
+        mergedChiList.emplace(ostIdx, newChi);
+      } else {
+        it->second->SetLHS(chi->GetLHS());
+        chi->GetLHS()->SetDefChi(*it->second);
+      }
+    }
+  }
+  return &mergedChiList;
+}
+
+// both `stmt1` and `stmt2` must have chiList
+bool SwapChiForSameOstIfNeeded(MeStmt &stmt1, MeStmt &stmt2) {
+  bool swapped = false;
+  auto *chiList1 = stmt1.GetChiList();
+  auto *chiList2 = stmt2.GetChiList();
+  CHECK_NULL_FATAL(chiList1);
+  CHECK_NULL_FATAL(chiList2);
+  auto p = chiList1->begin();
+  auto q = chiList2->begin();
+  while (p != chiList1->end() && q != chiList2->end()) {
+    if (p->first == q->first) {
+      if (p->second->GetRHS() == q->second->GetLHS()) {
+        auto *tmp = p->second;
+        p->second = q->second;
+        q->second = tmp;
+        // Update defStmt
+        p->second->SetBase(&stmt1);
+        q->second->SetBase(&stmt2);
+        swapped = true;
+      }
+      ++p;
+      ++q;
+    } else if (p->first < q->first) {
+      ++p;
+    } else {
+      ++q;
+    }
+  }
+  return swapped;
+}
+
+using VisitedPhiOpnds = std::map<size_t, ScalarMeExpr*>;
+
+ScalarMeExpr* DoFindPreVersionByAlias(ScalarMeExpr &aliasPreVersion, ScalarMeExpr &curVersion,
+    VisitedPhiOpnds &visitedPhiOpnds, bool &foundLoop);
+
+ScalarMeExpr* DoFindPreVersionByAliasInPhi(ScalarMeExpr &aliasPreVersion, ScalarMeExpr &curVersion,
+    VisitedPhiOpnds &visitedPhiOpnds, bool &foundLoop) {
+  OStIdx targetOstIdx = curVersion.GetOstIdx();
+  auto &aliasPhi = aliasPreVersion.GetDefPhi();
+  auto &phiList = aliasPhi.GetDefBB()->GetMePhiList();
+  auto it = phiList.find(targetOstIdx);
+  if (it != phiList.end()) {
+    return it->second->GetLHS();
+  }
+  auto &phiOpnds = aliasPhi.GetOpnds();
+  for (ScalarMeExpr *opnd : phiOpnds) {
+    if (opnd == aliasPhi.GetLHS()) {
+      continue;
+    }
+    auto retPair = visitedPhiOpnds.try_emplace(visitedPhiOpnds.size(), opnd);
+    if (!retPair.second) {
+      // found loop
+      foundLoop = true;
+      return nullptr;
+    }
+    size_t oldMaxId = visitedPhiOpnds.size() - 1;
+    auto *result = DoFindPreVersionByAlias(*opnd, curVersion, visitedPhiOpnds, foundLoop);
+    if (!foundLoop) {
+      return result;
+    }
+    foundLoop = false;
+    for (size_t i = visitedPhiOpnds.size() - 1; i > oldMaxId; --i) {
+      (void)visitedPhiOpnds.erase(i);
+    }
+  }
+  CHECK_FATAL_FALSE("should not be here, wrong alias?");
+}
+
+ScalarMeExpr* DoFindPreVersionByAlias(ScalarMeExpr &aliasPreVersion, ScalarMeExpr &curVersion,
+    VisitedPhiOpnds &visitedPhiOpnds, bool &foundLoop) {
+  OStIdx targetOstIdx = curVersion.GetOstIdx();
+  auto defType = aliasPreVersion.GetDefBy();
+  if (defType == kDefByNo) {
+    return nullptr;
+  }
+  if (defType == kDefByPhi) {
+    return DoFindPreVersionByAliasInPhi(aliasPreVersion, curVersion, visitedPhiOpnds, foundLoop);
+  }
+
+  auto *defStmt = aliasPreVersion.GetDefByMeStmt();
+  CHECK_NULL_FATAL(defStmt);  // kDefByChi, kDefByStmt or kDefByMustDef
+  // Search defStmt lhs
+  if (defStmt->GetOp() == OP_dassign) {
+    auto *dassignLhs = static_cast<DassignMeStmt*>(defStmt)->GetLHS();
+    if (dassignLhs->GetOstIdx() == targetOstIdx) {
+      return dassignLhs;
+    }
+  }
+  // Search defStmt chiList
+  ScalarMeExpr *nextExpr = nullptr;
+  auto *chiList = defStmt->GetChiList();
+  if (chiList != nullptr) {
+    auto it = chiList->find(targetOstIdx);
+    if (it != chiList->end()) {
+      return it->second->GetRHS();
+    }
+    nextExpr = aliasPreVersion.GetDefChi().GetRHS();
+  }
+  // Search defStmt mustDefList
+  auto *mustDefList = defStmt->GetMustDefList();
+  if (mustDefList != nullptr) {
+    for (auto &mustDef : *mustDefList) {
+      if (mustDef.GetLHS()->GetOstIdx() == targetOstIdx) {
+        return mustDef.GetLHS();
+      }
+    }
+  }
+  CHECK_NULL_FATAL(nextExpr);
+  return DoFindPreVersionByAlias(*nextExpr, curVersion, visitedPhiOpnds, foundLoop);
+}
+
+// Try to find previous version of `curVersion` by searching all possible defs of `aliasPreVersion`.
+// Return preVersion if found, otherwise return nullptr.
+ScalarMeExpr* FindPreVersionByAlias(ScalarMeExpr &aliasPreVersion, ScalarMeExpr &curVersion) {
+  VisitedPhiOpnds visitedPhiOpnds;
+  bool foundLoop = false;
+  return DoFindPreVersionByAlias(aliasPreVersion, curVersion, visitedPhiOpnds, foundLoop);
+}
+
+// Find previous version of dassignStmt lhsVar
+static ScalarMeExpr *FindPreVersionOfDassignLhs(DassignMeStmt &dassignStmt, IRMap &irMap) {
+  auto *curVersion = dassignStmt.GetLHS();
+  auto *dassignChiList = dassignStmt.GetChiList();
+  CHECK_NULL_FATAL(dassignChiList);
+  CHECK_FATAL(!dassignChiList->empty(), "chiList empty");
+  ChiMeNode *aliasChi = dassignChiList->begin()->second;
+  ScalarMeExpr *aliasPreVersion = aliasChi->GetRHS();
+  auto *preVersion = FindPreVersionByAlias(*aliasPreVersion, *curVersion);
+  if (preVersion == nullptr) {
+    preVersion = irMap.GetOrCreateZeroVersionVarMeExpr(*curVersion->GetOst());
+  }
+  return preVersion;
+}
+
+static void MovDefsFromDassignsToVecIassign(MapleVector<MeStmt*> &dassignStmts, IassignMeStmt &vecIassign,
+    IRMap &irMap) {
+  for (auto *stmt : dassignStmts) {
+    CHECK_FATAL(stmt->GetOp() == OP_dassign, "must be");
+    auto *dassign = static_cast<DassignMeStmt*>(stmt);
+    auto *curVersion = dassign->GetLHS();
+    auto *preVersion = FindPreVersionOfDassignLhs(*dassign, irMap);
+    auto *newChi = irMap.New<ChiMeNode>(&vecIassign);
+    newChi->SetLHS(curVersion);
+    newChi->SetRHS(preVersion);
+    curVersion->SetDefBy(kDefByChi);
+    curVersion->SetDefChi(*newChi);
+    (void)vecIassign.GetChiList()->emplace(curVersion->GetOstIdx(), newChi);
+  }
+}
+
+// ------------------------ //
+//  Block Level Scheduling  //
+// ------------------------ //
+void SaveAndRenumberStmtIds(BB &bb, std::vector<uint32> &buffer) {
+  buffer.clear();
+  auto *stmt = bb.GetFirstMe();
+  uint32 id = 0;
+  while (stmt != nullptr) {
+    buffer.push_back(stmt->GetMeStmtId());
+    stmt->SetMeStmtId(id++);
+    stmt = stmt->GetNext();
+  }
+}
+
+void RecoverStmtIds(BB &bb, const std::vector<uint32> &buffer) {
+  auto *stmt = bb.GetFirstMe();
+  size_t i = 0;
+  while (stmt != nullptr) {
+    if (i >= buffer.size()) {
+      ++i;
+      stmt = stmt->GetNext();
+      continue;
+    }
+    stmt->SetMeStmtId(buffer[i++]);
+    stmt = stmt->GetNext();
+  }
+}
+
+uint32 GetOrderId(MeStmt *stmt) {
+  if (stmt == nullptr) {
+    return UINT32_MAX;
+  }
+  return stmt->GetMeStmtId();
+}
+
+void SetOrderId(MeStmt *stmt, uint32 id) {
+  CHECK_NULL_FATAL(stmt);
+  stmt->SetMeStmtId(id);
+}
+
+// Assume there are two stmts in a same bb, stmt1 is located before stmt2:
+//   stmt1
+//   ...
+//   stmt2
+// Now we want to schedule stmt2 before stmt1, the scenario of scheduling failure is as follows:
+enum class SchedFailReason {
+  kSchedSuccess,        // schedule success
+  kSchedFailOpndDep,    // dependencies of stmt2's opnds is within the range [stmt1, stmt2)
+  kSchedFailMuDep,      // dependencies of stmt2's mu is within the range [stmt1, stmt2)
+  kSchedFailChiRhsDep,  // dependencies of stmt2's chiRhs is within the range [stmt1, stmt2)
+  kSchedFailChiRhsUse,  // [cross-version ref] stmt2's chiRhs is used by stmts in the range [stmt1, stmt2)
+  kSchedFailPregWAR     // preg Write After Read
+};
+
+// ---------- //
+//  SLP Tree  //
+// ---------- //
+class SLPTree;  // pre-dependency
+
+class TreeNode {
+ public:
+  using StmtVec = MapleVector<MeStmt*>;
+  using ExprVec = MapleVector<MeExpr*>;
+  using ExprWithDefVec = MapleVector<ExprWithDef*>;
+  // Create TreeNode object from stmts
+  TreeNode(SLPTree &inTree, MapleAllocator &alloc, const std::vector<MeStmt*> &meStmts,
+           TreeNode *parentNode, uint32 inputId, MemoryHelper &memoryHelper, bool canVect)
+      : tree(inTree),
+        stmts(alloc.Adapter()),
+        exprs(alloc.Adapter()),
+        memLocs(alloc.Adapter()),
+        order(alloc.Adapter()),
+        outStmts(alloc.Adapter()),
+        children(alloc.Adapter()),
+        id(inputId),
+        canVectorized(canVect) {
+    ASSERT(!meStmts.empty(), "container check");
+    for (auto *stmt : meStmts) {
+      stmts.push_back(stmt);
+    }
+    auto *firstStmt = stmts[0];
+    auto firstOp = firstStmt->GetOp();
+    if (firstOp == OP_iassign || firstOp == OP_dassign) {
+      op = firstOp;
+    } else if (firstOp == OP_regassign) {
+      op = firstStmt->GetRHS()->GetOp();
+    } else {
+      CHECK_FATAL(false, "NYI");
+    }
+    // Init memLocs
+    if (op == OP_iassign || op == OP_dassign) {
+      // Init store memLoc
+      for (auto *stmt : stmts) {
+        MemLoc *memLoc = nullptr;
+        if (op == OP_iassign) {
+          auto *ivar = static_cast<IassignMeStmt*>(stmt)->GetLHSVal();
+          memLoc = memoryHelper.GetMemLoc(*ivar);
+        } else {
+          MeExpr *var = static_cast<DassignMeStmt*>(stmt)->GetLHS();
+          CHECK_FATAL(var->GetOp() == OP_dread, "unexpected stmt");
+          memLoc = memoryHelper.GetMemLoc(*static_cast<VarMeExpr*>(var));
+        }
+        memLocs.push_back(memLoc);
+      }
+      auto *minMemLoc = GetMinMemLoc();
+      auto typeSize = minMemLoc->type->GetSize();
+      for (auto *memLoc : memLocs) {
+        order.push_back((memLoc->offset - minMemLoc->offset) / typeSize);
+      }
+    } else if (firstStmt->GetRHS() != nullptr && firstStmt->GetRHS()->GetMeOp() == kMeOpIvar) {
+      // Init load memLoc
+      for (auto *stmt : stmts) {
+        auto *ivar = static_cast<IvarMeExpr*>(stmt->GetRHS());
+        auto *memLoc = memoryHelper.GetMemLoc(*ivar);
+        memLocs.push_back(memLoc);
+      }
+      auto *minMemLoc = GetMinMemLoc();
+      auto typeSize = minMemLoc->type->GetSize();
+      for (auto *memLoc : memLocs) {
+        order.push_back((memLoc->offset - minMemLoc->offset) / typeSize);
+      }
+    }
+    SetParent(parentNode);
+  }
+
+  // Create TreeNode object from exprs
+  TreeNode(SLPTree &inTree, MapleAllocator &alloc, const std::vector<ExprWithDef*> &exprVec,
+           TreeNode *parentNode, uint32 inputId, bool canVect)
+      : tree(inTree),
+        stmts(alloc.Adapter()),
+        exprs(alloc.Adapter()),
+        memLocs(alloc.Adapter()),
+        order(alloc.Adapter()),
+        outStmts(alloc.Adapter()),
+        children(alloc.Adapter()),
+        id(inputId),
+        canVectorized(canVect) {
+    ASSERT(!exprVec.empty(), "container check");
+    for (auto *exprWithDef : exprVec) {
+      if (canVect) {
+        exprs.push_back(exprWithDef->GetRealExpr());
+      } else {
+        exprs.push_back(exprWithDef->GetExpr());
+      }
+      stmts.push_back(exprWithDef->GetDefStmt());
+    }
+    op = exprs[0]->GetOp();
+    SetParent(parentNode);
+  }
+
+  SLPTree &GetTree() {
+    return tree;
+  }
+
+  bool ConstOrNeedGather() const {
+    return op == OP_constval || !CanVectorized();
+  }
+
+  Opcode GetOp() const {
+    return op;
+  }
+
+  void SetId(uint32 inputId) {
+    id = inputId;
+  }
+
+  uint32 GetId() const {
+    return id;
+  }
+
+  const MapleVector<TreeNode*> &GetChildren() const {
+    return children;
+  }
+
+  void RemoveAllChildren() {
+    children.clear();
+  }
+
+  void ChangeToNeedGatherNode() {
+    CHECK_FATAL(!ConstOrNeedGather(), "must be");
+    exprs.resize(stmts.size());
+    for (size_t i = 0; i < stmts.size(); ++i) {
+      CHECK_NULL_FATAL(stmts[i]);
+      CHECK_NULL_FATAL(stmts[i]->GetLHS());
+      exprs[i] = stmts[i]->GetLHS();
+    }
+    canVectorized = false;
+  }
+
+  TreeNode *GetParent() const {
+    return parent;
+  }
+
+  const TreeNode *GetTreeRoot() const {
+    auto *root = GetParent();
+    if (root == nullptr) {
+      return this;  // current node is root node
+    }
+    while (root->GetParent() != nullptr) {
+      root = root->GetParent();
+    }
+    return root;
+  }
+
+  uint32 GetBundleSize() const;
+
+  int32 GetCost() const;
+
+  int32 GetExternalUserCost() const;
+
+  // Only valid for load/store treeNode for now
+  int32 GetScalarCost() const;
+
+  // Only valid for load/store treeNode for now
+  int32 GetVectorCost() const;
+
+  const StmtVec &GetStmts() const {
+    return stmts;
+  }
+
+  StmtVec &GetStmts() {
+    return stmts;
+  }
+
+  void PushStmt(MeStmt *stmt) {
+    stmts.push_back(stmt);
+  }
+
+  const ExprVec &GetExprs() const {
+    return exprs;
+  }
+
+  bool SameExpr() const {
+    CHECK_FATAL(!exprs.empty(), "exprs empty");
+    bool allSame = true;
+    auto *firstExpr = exprs[0];
+    for (size_t i = 1; i < exprs.size(); ++i) {
+      if (firstExpr != exprs[i]) {
+        allSame = false;
+        break;
+      }
+    }
+    return allSame;
+  }
+
+  const MapleVector<MemLoc*> &GetMemLocs() const {
+    return memLocs;
+  }
+
+  bool IsLoad() const {
+    return op == OP_iread || op == OP_ireadoff;
+  }
+
+  bool IsStore() const {
+    return op == OP_iassign;
+  }
+
+  bool CanNodeUseLoadStorePair() const {
+    if (!IsLoad() && !IsStore()) {
+      return false;
+    }
+    if (IsLoad() && stmts[0] == nullptr) {
+      // iread with agg primType won't be splited, it's treeNode has no valid stmts
+      return false;
+    }
+    auto typeBitSize = GetPrimTypeBitSize(GetType());
+    if (GetLane() == 2 && (typeBitSize == 32 || typeBitSize == 64)) {
+      return true;
+    }
+    return false;
+  }
+
+  bool IsLeaf() const {
+    return children.empty();
+  }
+
+  const MapleVector<uint32> &GetOrder() const {
+    return order;
+  }
+
+  void DumpOrder() const {
+    if (!IsStore() && !IsLoad()) {
+      LogInfo::MapleLogger() << "DumpOrder: Tree node is neither store nor load" << std::endl;
+      return;
+    }
+    for (size_t i = 0; i < stmts.size(); ++i) {
+      LogInfo::MapleLogger() << order[i] << ": ";
+      memLocs[i]->Dump();
+    }
+  }
+
+  // Get memLoc with min offset, only valid for store/load treeNode
+  MemLoc *GetMinMemLoc() const {
+    CHECK_FATAL(!memLocs.empty(), "memLocs is empty, make sure this tree node is a load or store");
+    MemLoc *minMem = memLocs[0];
+    int32 minOffset = memLocs[0]->offset;
+    for (size_t i = 1; i < memLocs.size(); ++i) {
+      auto offset = memLocs[i]->offset;
+      if (offset < minOffset) {
+        minOffset = offset;
+        minMem = memLocs[i];
+      }
+    }
+    return minMem;
+  }
+
+  size_t GetLane() const {
+    auto lane = (!exprs.empty() ? exprs.size() : stmts.size());
+    return lane;
+  }
+
+  PrimType GetType() const;
+
+  void DumpVecStmts(const IRMap &irMap) const {
+    LogInfo::MapleLogger() << "  Emit stmts:" << std::endl;
+    for (auto *stmt : outStmts) {
+      stmt->Dump(&irMap);
+    }
+  }
+
+  void DumpInDot(const MeFunction &func) const {
+    (void)func;
+    LogInfo::MapleLogger() << "[" << id << "] ";
+    LogInfo::MapleLogger() << GetOpName(op);
+    LogInfo::MapleLogger() << ", lane = " << GetLane();
+    LogInfo::MapleLogger() << ", cost = " << GetCost();
+    if (!canVectorized) {
+      LogInfo::MapleLogger() << ". NOT VEC";
+    }
+  }
+
+  StmtVec &GetOutStmts() {
+    return outStmts;
+  }
+
+  void ClearOutStmts() {
+    outStmts.clear();
+  }
+
+  void PushOutStmt(MeStmt *stmt) {
+    if (stmt == nullptr) {
+      return;
+    }
+    outStmts.push_back(stmt);
+  }
+
+  bool CanVectorized() const {
+    return canVectorized;
+  }
+
+  void Dump(MeFunction &func) const {
+    LogInfo::MapleLogger() << "[Tree Node " << id << "]";
+    if (!canVectorized) {
+      LogInfo::MapleLogger() << " (can NOT be vectorized)";
+    }
+    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << "op: " << GetOpName(op) << std::endl;
+    LogInfo::MapleLogger() << "lane: " << GetLane() << std::endl;
+    LogInfo::MapleLogger() << "cost: " << GetCost() << std::endl;
+    if (IsLoad()) {
+      int32 externalUserCost = GetExternalUserCost();
+      if (externalUserCost != 0) {
+        LogInfo::MapleLogger() << "externalUserCost: " << externalUserCost << std::endl;
+      }
+    }
+    if (IsLoad() || IsStore()) {
+      LogInfo::MapleLogger() << "CanNodeUseLoadStorePair: " << (CanNodeUseLoadStorePair() ? "yes" : "no") << std::endl;
+      LogInfo::MapleLogger() << "scalar cost: " << GetScalarCost() << std::endl;
+      LogInfo::MapleLogger() << "vector cost: " << GetVectorCost() << std::endl;
+      if (GetMinMemLoc()->offset == 0) {
+        auto stackOffset = EstimateStackOffsetOfMemLoc(GetMinMemLoc(), func);
+        if (stackOffset) {
+          LogInfo::MapleLogger() << "must in stack, offset: " << stackOffset.value() << std::endl;
+        }
+      }
+    }
+    LogInfo::MapleLogger() << "parent: " << (parent == nullptr ? "NULL" : std::to_string(parent->id)) << std::endl;
+    LogInfo::MapleLogger() << "children: ";
+    for (auto *child : children) {
+      LogInfo::MapleLogger() << child->id << " ";
+    }
+    LogInfo::MapleLogger() << std::endl;
+    if (!order.empty()) {
+      LogInfo::MapleLogger() << "order: ";
+      for (auto ord : order) {
+        LogInfo::MapleLogger() << ord << " ";
+      }
+      LogInfo::MapleLogger() << std::endl;
+    }
+    if (!exprs.empty()) {
+      for (auto *expr : exprs) {
+        expr->Dump(func.GetIRMap(), 0);
+        LogInfo::MapleLogger() << std::endl;
+      }
+    } else {
+      for (size_t i = 0; i < stmts.size(); ++i) {
+        if (stmts[i] != nullptr) {
+          stmts[i]->Dump(func.GetIRMap());
+          if (!memLocs.empty()) {
+            LogInfo::MapleLogger() << "---- memLoc: ";
+            CHECK_FATAL(i < memLocs.size(), "must be");
+            CHECK_NULL_FATAL(memLocs[i]);
+            memLocs[i]->Dump();
+          }
+        }
+      }
+    }
+  }
+
+ private:
+  void SetParent(TreeNode *parentNode) {
+    parent = parentNode;
+    if (parent != nullptr) {
+      parent->children.push_back(this);
+    }
+  }
+
+  SLPTree &tree;                   // SLP tree that current node belongs to
+  MapleVector<MeStmt*> stmts;      // input stmts
+  MapleVector<MeExpr*> exprs;      // input exprs only used when op == OP_constval
+  MapleVector<MemLoc*> memLocs;    // only valid for store and load
+  MapleVector<uint32> order;       // only valid for store and load
+  MapleVector<MeStmt*> outStmts;   // output vectorizd stmts
+  MapleVector<TreeNode*> children; // children nodes
+  TreeNode *parent = nullptr;      // parent node
+  Opcode op = OP_undef;            // tree node opcode
+  uint32 id;                       // tree node id
+  bool canVectorized = false;      // whether the tree node can be vectorized or must be gathered
+};
+
+struct BlockScheduling;
+class SLPTree {
+ public:
+  SLPTree(MapleAllocator &allocator, MemoryHelper &memHelper, MeFunction &f, BlockScheduling &bs)
+      : alloc(allocator), memoryHelper(memHelper), func(f), blockScheduling(bs), treeNodeVec(alloc.Adapter()) {}
+
+  MapleVector<TreeNode*> &GetNodes() {
+    return treeNodeVec;
+  }
+
+  TreeNode *GetRoot() {
+    ASSERT(!treeNodeVec.empty(), "empty tree");
+    return treeNodeVec[0];
+  }
+
+  size_t GetSize() const {
+    return treeNodeVec.size();
+  }
+
+  PrimType GetType() const {
+    return treeNodeVec[0]->GetType();
+  }
+
+  size_t GetLane() const {
+    return treeNodeVec[0]->GetLane();
+  }
+
+  MeFunction &GetFunc() {
+    return func;
+  }
+
+  MeExprUseInfo &GetUseInfo();
+
+  int32 GetCost() const;
+
+  TreeNode *CreateTreeNodeByExprs(const std::vector<ExprWithDef*> &exprVec, TreeNode *parentNode, bool canVect) {
+    auto *treeNode = alloc.New<TreeNode>(*this, alloc, exprVec, parentNode, treeNodeVec.size(), canVect);
+    treeNodeVec.push_back(treeNode);
+    return treeNode;
+  }
+
+  TreeNode *CreateTreeNodeByStmts(const std::vector<MeStmt*> &stmts, TreeNode *parentNode) {
+    auto *treeNode = alloc.New<TreeNode>(*this, alloc, stmts, parentNode, treeNodeVec.size(), memoryHelper, true);
+    treeNodeVec.push_back(treeNode);
+    return treeNode;
+  }
+
+  void AddTreeNode(TreeNode *treeNode) {
+    treeNode->SetId(treeNodeVec.size());
+    treeNodeVec.push_back(treeNode);
+  }
+
+  void PopTreeNode() {
+    treeNodeVec.pop_back();
+  }
+
+  // store treeNode + constval treeNode
+  // can use integer register
+  bool CanTreeUseScalarTypeForConstvalIassign() const {
+    if (treeNodeVec.size() == 2 && treeNodeVec[1]->GetOp() == OP_constval) {
+      auto *root = treeNodeVec[0];
+      size_t bundleSize = GetPrimTypeBitSize(root->GetType()) * root->GetLane();
+      if (bundleSize <= 64) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool CanTreeUseStp() const {
+    if (treeNodeVec.size() != 2) {
+      return false;
+    }
+    auto storeTypeSize = GetPrimTypeBitSize(treeNodeVec[0]->GetType());
+    if (storeTypeSize != 32 && storeTypeSize != 64) {
+      return false;
+    }
+    auto *secondTreeNode = treeNodeVec[1];
+    if (secondTreeNode->IsLoad()) {
+      if (secondTreeNode->GetStmts()[0] == nullptr) {
+        return false;  // iread with agg primType won't be splited, it's treeNode has no valid stmts
+      }
+      if (secondTreeNode->GetLane() == 2) {
+        return true;
+      }
+    }
+    return secondTreeNode->ConstOrNeedGather();
+  }
+
+  bool CanTreeBeVectorizedCompletely() const {
+    for (auto *treeNode : treeNodeVec) {
+      if (!treeNode->CanVectorized()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+ private:
+  MapleAllocator &alloc;
+  MemoryHelper &memoryHelper;
+  MeFunction &func;
+  BlockScheduling &blockScheduling;
+  MapleVector<TreeNode*> treeNodeVec;  // the first node is always root
+};
+
+PrimType TreeNode::GetType() const {
+  if (op == OP_constval) {
+    return exprs[0]->GetPrimType();
+  }
+  // sometimes memLoc type is more precise than stmt rhs.
+  // example: iread u32 <*u8>
+  // we should use type u8 instead of u32
+  if (!memLocs.empty()) {
+    return memLocs[0]->type->GetPrimType();
+  }
+  if (stmts[0] != nullptr) {
+    return stmts[0]->GetRHS()->GetPrimType();
+  }
+  if (exprs[0] != nullptr) {
+    return exprs[0]->GetPrimType();
+  }
+  return tree.GetRoot()->GetType();
+}
+
+uint32 TreeNode::GetBundleSize() const {
+  return GetLane() * GetPrimTypeBitSize(tree.GetType());
+}
+
+// Only valid for load/store treeNode for now
+int32 TreeNode::GetScalarCost() const {
+  ASSERT(IsLoad() || IsStore(), "must be");
+  int32 cost = GetLane();
+  if (CanNodeUseLoadStorePair()) {
+    cost /= 2;
+    auto *minMemLoc = GetMinMemLoc();
+    int32 offset = minMemLoc->offset;
+    if (offset == 0) {
+      auto stackOffset = EstimateStackOffsetOfMemLoc(minMemLoc, tree.GetFunc());
+      if (stackOffset) {
+        offset = stackOffset.value();
+      }
+    }
+    // If stp/ldp for stack memory, we think that an extra insn is always needed for preparing offset
+    bool offsetValid = IsIntStpLdpOffsetValid(GetPrimTypeBitSize(GetType()), offset);
+    if (!offsetValid) {
+      cost += 1;  // invalid offset, an extra instruction is needed to prepare offset const
+      if (IsStore()) {
+        bool canReuseOffsetPrepareInsn = tree.GetSize() == 2 && tree.GetNodes()[1]->IsLoad() &&
+            minMemLoc->base == tree.GetNodes()[1]->GetMinMemLoc()->base;
+        if (canReuseOffsetPrepareInsn) {
+          // If ldp and stp have same base, only 1 extra insn is needed to prepare offset const
+          cost -= 1;
+        }
+      }
+    }
+  }
+  return cost;
+}
+
+// Only valid for load/store treeNode for now
+int32 TreeNode::GetVectorCost() const {
+  // If we reorder stmts instead of vectorizing stmts, lane may be invalid, we check it here
+  if (GetLane() % 2 != 0) {
+    return kHugeCost;
+  }
+  ASSERT(IsLoad() || IsStore(), "must be");
+  ASSERT(CanVectorized(), "must be");
+  int32 cost = 1;
+  int32 offset = GetMinMemLoc()->offset;
+  if (!IsVecStrLdrOffsetValid(GetBundleSize(), offset)) {
+    cost += 1;
+  }
+  return cost;
+}
+
+int32 TreeNode::GetExternalUserCost() const {
+  int32 externalUserCost = 0;
+  auto &exprUseInfo = tree.GetUseInfo();
+  for (auto *scalarStmt : GetStmts()) {
+    auto *lhs = scalarStmt->GetLHS();
+    auto *useItems = exprUseInfo.GetUseSitesOfExpr(lhs);
+    if (useItems == nullptr) {
+      continue;
+    }
+    for (auto &use : *useItems) {
+      if (!use.IsUseByStmt()) {
+        externalUserCost += 1;
+        continue;
+      }
+      auto &internalUseStmts = GetParent()->GetStmts();
+      if (std::find(internalUseStmts.begin(), internalUseStmts.end(), use.GetStmt()) == internalUseStmts.end()) {
+        // Found external user in current BB, we can delete the scalar stmt, extra cost should be considered.
+        externalUserCost += 1;
+      }
+    }
+  }
+  return externalUserCost;
+}
+
+// Wether the constval is in the range of insn's imm field
+static bool IsConstvalInRangeOfInsnImm(ConstMeExpr *constExpr, Opcode op, uint32 typeBitSize) {
+  if (constExpr->GetConstVal()->GetKind() != kConstInt) {
+    return false;
+  }
+  auto val = constExpr->GetExtIntValue();
+  switch (op) {
+    case OP_add:
+    case OP_sub:
+      return Imm12BitValid(val);
+    case OP_band:
+    case OP_bior:
+    case OP_bxor: {
+      if (typeBitSize == 32) {
+        return Imm12BitMaskValid(val);
+      } else if (typeBitSize == 64) {
+        return Imm13BitMaskValid(val);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+int32 TreeNode::GetCost() const {
+  bool isLoadOrStore = IsLoad() || IsStore();
+  if (IsPrimitiveFloat(GetType()) && !isLoadOrStore) {
+    // Currently CodeGen can not support set_element/get_element for float type.
+    // So return a huge cost that prevent slp tree from being vectorized.
+    // It is OK for float type to load/store.
+    return kHugeCost;
+  }
+  if (!CanVectorized()) {
+    return GetLane();
+  }
+  if (op == OP_constval) {
+    if (SameExpr()) {
+      auto typeBitSize = GetPrimTypeBitSize(GetType());
+      if (IsConstvalInRangeOfInsnImm(static_cast<ConstMeExpr*>(exprs[0]), GetParent()->GetOp(), typeBitSize)) {
+        return 2;  // no extra constval assign insn is needed, for example, sub x1, x1, #1
+      }
+      return 1;
+    } else {
+      return GetLane();
+    }
+  }
+  int32 cost = -(GetLane() - 1);
+  if (op == OP_ashr) {
+    // aarch64 only vector shl(register), lowering vector shr will introduce an extra vector neg instruction.
+    cost += 1;
+  }
+  if (isLoadOrStore) {
+    int32 vectorCost = GetVectorCost();
+    int32 scalarCost = GetScalarCost();
+    cost = vectorCost - scalarCost;
+    if (IsLoad()) {  // only consider load treeNode's external user cost for now
+      int32 externalUserCost = GetExternalUserCost();
+      if (externalUserCost != 0) {
+        cost += externalUserCost;
+      }
+    }
+  }
+  return cost;
+}
+
+int32 SLPTree::GetCost() const {
+  // Special case for store 0, stp wzr/xzr is better because no need to prepare zero vector register
+  if (GetSize() == 2 && treeNodeVec[1]->GetOp() == OP_constval && treeNodeVec[1]->SameExpr()) {
+    auto *constVal = static_cast<ConstMeExpr*>(treeNodeVec[1]->GetExprs()[0])->GetConstVal();
+    if (constVal->GetKind() == kConstInt && static_cast<MIRIntConst*>(constVal)->GetValue() == 0) {
+      // two 'str wzr' can be merged into one 'str xzr' now
+      bool canMergeTwoStrWzr = GetLane() == 2 && GetPrimTypeBitSize(GetType()) == 32 &&
+          treeNodeVec[0]->GetOp() == OP_iassign;
+      if (!canMergeTwoStrWzr) {
+        return kHugeCost;
+      }
+    }
+  }
+  int32 cost = 0;
+  for (auto *treeNode : treeNodeVec) {
+    cost += treeNode->GetCost();
+  }
+  return cost;
+}
+
+void PrintTreeNode(TreeNode *node, MeFunction &func, bool inDot) {
+  if (inDot) {
+    LogInfo::MapleLogger() << "Node" << node->GetId() << " [shape=record" <<
+        (node->GetCost() > 0 ? ",style=bold,color=red" : "") << ",label=\"{";
+    node->DumpInDot(func);
+    LogInfo::MapleLogger() << "}\"]" << std::endl;
+  } else {
+    node->Dump(func);
+  }
+}
+
+void PrintSLPTree(TreeNode *root, MeFunction &func, bool inDot) {
+  PrintTreeNode(root, func, inDot);
+  for (auto *node : root->GetChildren()) {
+    PrintSLPTree(node, func, inDot);
+    if (inDot) {
+      LogInfo::MapleLogger() << "Node" << root->GetId() << " -> Node" << node->GetId() << std::endl;
+    }
+  }
+}
+
+void PrintTreeInDotFormat(TreeNode *root, MeFunction &func) {
+  LogInfo::MapleLogger() << "digraph {\n";
+  LogInfo::MapleLogger() << "label=\"Total Cost: " << root->GetTree().GetCost() << "\"\n";
+  LogInfo::MapleLogger() << "rankdir=\"BT\"\n";  // bottom to top
+  PrintSLPTree(root, func, true);
+  LogInfo::MapleLogger() << "}" << std::endl;
+}
+
+struct BlockScheduling {
+  BlockScheduling(MeFunction &f, BB *block, MemoryHelper &memHelper, bool dbg)
+      : func(f), bb(block), os(LogInfo::MapleLogger()), memoryHelper(memHelper), debug(dbg) {}
+
+  MeFunction &func;
+  BB *bb = nullptr;
+  std::vector<uint32> stmtIdBuffer;  // we should recover stmtId before any IR transformation
+  std::vector<MeStmt*> stmtVec;      // map position to stmt
+  std::ostream &os;
+  MeExprUseInfo *exprUseInfo = nullptr;
+  MemoryHelper &memoryHelper;
+  bool extendUseInfo = false;
+  bool irModified = false;  // If IR is modified when scheduled, we must save scheduling result
+  bool debug = false;
+
+  std::vector<MeStmt*> &GetStmtVec() {
+    return stmtVec;
+  }
+
+  void DumpStmtVec() const;
+
+  void SwapStmts(MeStmt *stmt1, MeStmt *stmt2) {
+    // swap position in stmtVec
+    stmtVec[GetOrderId(stmt1)] = stmt2;
+    stmtVec[GetOrderId(stmt2)] = stmt1;
+    // swap orderId
+    auto tmp = GetOrderId(stmt1);
+    SetOrderId(stmt1, GetOrderId(stmt2));
+    SetOrderId(stmt2, tmp);
+  }
+
+  bool IsRegionEmpty(MeStmt *beginStmt, MeStmt *endStmt) const {
+    return beginStmt == endStmt;
+  }
+
+  BB *GetBB() {
+    return bb;
+  }
+
+  void Init() {
+    SaveAndRenumberStmtIds(*bb, stmtIdBuffer);
+    stmtVec.clear();
+    stmtVec.reserve(stmtIdBuffer.size());
+    auto *stmt = bb->GetFirstMe();
+    while (stmt != nullptr) {
+      stmtVec.push_back(stmt);
+      stmt = stmt->GetNext();
+    }
+  }
+
+  bool IsStmtInRegion(MeStmt *stmt, MeStmt *beginStmt, MeStmt *endStmt) {
+    if (IsRegionEmpty(beginStmt, endStmt)) {
+      return false;
+    }
+    if (stmt->GetBB() != bb) {
+      return false;
+    }
+    auto id = GetOrderId(stmt);
+    if (id >= GetOrderId(beginStmt) && id <= GetOrderId(endStmt)) {
+      return true;
+    }
+    return false;
+  }
+
+  MeStmt *FindAnyStmtInRegion(const std::vector<MeStmt*> &meStmtVec, MeStmt *beginStmt, MeStmt *endStmt) {
+    for (auto *stmt : meStmtVec) {
+      if (IsStmtInRegion(stmt, beginStmt, endStmt)) {
+        return stmt;
+      }
+    }
+    return nullptr;
+  }
+
+  bool IsAnyStmtInRegion(const std::vector<MeStmt*> &meStmtVec, MeStmt *beginStmt, MeStmt *endStmt) {
+    for (auto *stmt : meStmtVec) {
+      if (IsStmtInRegion(stmt, beginStmt, endStmt)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool IsOstUsedByStmt(OriginalSt *ost, MeStmt *stmt);
+
+  void ScheduleStmtBefore(MeStmt *stmt, MeStmt *anchor, bool needRectifyChiList = false) {
+    CHECK_FATAL(stmt->GetBB() == anchor->GetBB(), "must belong to same BB");
+    int32 stmtOrderId = GetOrderId(stmt);
+    int32 anchorOrderId = GetOrderId(anchor);
+    CHECK_FATAL(anchorOrderId < stmtOrderId, "anchor must be before stmt");
+    if (needRectifyChiList) {
+      irModified = SwapChiForSameOstIfNeeded(*stmt, *anchor);
+    }
+    // should use signed id
+    for (int32 id = stmtOrderId - 1; id >= anchorOrderId; --id) {
+      SwapStmts(stmt, stmtVec[id]);
+    }
+    if (debug) {
+      VerifyScheduleResult(GetOrderId(stmt), GetOrderId(anchor));
+    }
+  }
+
+  bool CanScheduleStmtBefore(MeStmt *stmt, MeStmt *anchor, SchedFailReason &failReason);
+  bool CanScheduleAssignWithoutOverlapBefore(MeStmt *stmt, MeStmt *anchor);
+  bool TryScheduleTwoStmtsTogether(MeStmt *first, MeStmt *second);
+  void VerifyScheduleResult(uint32 firstOrderId, uint32 lastOrderId);
+  // Collect use info from `begin` to `end` (not include `end`) in current BB
+  // These use info are needed by dependency analysis and stmt scheduling
+  void RebuildUseInfo(MeStmt *begin, MeStmt *end, MapleAllocator &alloc);
+  void ExtendUseInfo();
+};
+
+MeExprUseInfo &SLPTree::GetUseInfo() {
+  blockScheduling.ExtendUseInfo();
+  return *blockScheduling.exprUseInfo;
+}
+
+void BlockScheduling::DumpStmtVec() const {
+  LogInfo::MapleLogger() << "--- [ DumpStmtVec ] ---" << std::endl;
+  for (auto *stmt : stmtVec) {
+    if (stmt == nullptr) {
+      continue;
+    }
+    os << "  <" << GetOrderId(stmt) << "> LOC " << stmt->GetSrcPosition().LineNum();
+    stmt->Dump(func.GetIRMap());
+  }
+  LogInfo::MapleLogger() << "--- [ DumpStmtVec ] ---" << std::endl;
+}
+
+// --------------------- //
+//  Dependency Analysis  //
+// --------------------- //
+// Move these two functions into some util class when doing code refactor
+// Collect defStmt of `expr`
+void GetDependencyStmts(MeExpr *expr, std::vector<MeStmt*> &dependencies) {
+  if (expr->IsScalar()) {
+    // we don't need to consider defPhi, we only focus on BB level use-def
+    auto *defStmt = static_cast<ScalarMeExpr*>(expr)->GetDefByMeStmt();
+    if (defStmt != nullptr) {
+      dependencies.push_back(defStmt);
+    }
+  } else if (expr->GetMeOp() == kMeOpIvar) {
+    for (auto *mu : static_cast<IvarMeExpr*>(expr)->GetMuList()) {
+      auto *defStmt = mu->GetDefByMeStmt();
+      if (defStmt != nullptr) {
+        dependencies.push_back(defStmt);
+      }
+    }
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    auto *opnd = expr->GetOpnd(i);
+    GetDependencyStmts(opnd, dependencies);
+  }
+}
+
+// Collect defStmt of `stmt`
+void GetDependencyStmts(MeStmt *stmt, std::vector<MeStmt*> &depsOfOpnd, std::vector<MeStmt*> &depsOfChiRhs,
+    std::vector<MeStmt*> &depsOfMu) {
+  for (size_t i = 0; i < stmt->NumMeStmtOpnds(); ++i) {
+    auto *opnd = stmt->GetOpnd(i);
+    GetDependencyStmts(opnd, depsOfOpnd);
+  }
+  auto *chiList = stmt->GetChiList();
+  if (chiList != nullptr) {
+    for (auto &chiNodePair : *chiList) {
+      auto *chiNode = chiNodePair.second;
+      auto *defStmt = chiNode->GetRHS()->GetDefByMeStmt();
+      if (defStmt != nullptr) {
+        depsOfChiRhs.push_back(defStmt);
+      }
+    }
+  }
+
+  auto *muList = stmt->GetMuList();
+  if (muList != nullptr) {
+    for (auto &muPair : *muList) {
+      auto *mu = muPair.second;
+      auto *defStmt = mu->GetDefByMeStmt();
+      if (defStmt != nullptr) {
+        depsOfMu.push_back(defStmt);
+      }
+    }
+  }
+}
+
+void GetOstsUsed(MeExpr *expr, std::unordered_set<OriginalSt*> &ostsUsed) {
+  Opcode op = expr->GetOp();
+  if (op == OP_regread) {
+    // we don't need to consider defPhi, we only focus on BB level use-def
+    auto *ost = static_cast<RegMeExpr*>(expr)->GetOst();
+    ostsUsed.insert(ost);
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    auto *opnd = expr->GetOpnd(i);
+    GetOstsUsed(opnd, ostsUsed);
+  }
+}
+
+void GetOstsUsed(MeStmt *stmt, std::unordered_set<OriginalSt*> &ostsUsed) {
+  // We only consider stmt opnd, skip chiList, because there is always no chi for preg
+  for (size_t i = 0; i < stmt->NumMeStmtOpnds(); ++i) {
+    auto *opnd = stmt->GetOpnd(i);
+    GetOstsUsed(opnd, ostsUsed);
+  }
+}
+
+void GetUseStmtsOfChiRhs(const MeExprUseInfo &useInfo, MeStmt *stmt, std::vector<MeStmt*> &useStmts) {
+  auto *chiList = stmt->GetChiList();
+  if (chiList == nullptr) {
+    return;
+  }
+  for (auto &chiNodePair : *chiList) {
+    auto *chiNode = chiNodePair.second;
+    auto *chiRhs = chiNode->GetRHS();
+    // Get use stmt of chiRhs
+    auto *useList = useInfo.GetUseSitesOfExpr(chiRhs);
+    if (useList == nullptr || useList->empty()) {
+      continue;
+    }
+    for (auto &useItem : *useList) {
+      // We don't care usePhi because schedule stmts in BB level
+      if (useItem.IsUseByStmt()) {
+        auto *useStmt = useItem.GetStmt();
+        useStmts.push_back(useStmt);
+      }
+    }
+  }
+}
+
+void BlockScheduling::VerifyScheduleResult(uint32 firstOrderId, uint32 lastOrderId) {
+  for (auto orderId = firstOrderId; orderId <= lastOrderId; ++orderId) {
+    auto *stmt = stmtVec[orderId];
+    // Only check iassign chiList for now
+    if (stmt->GetOp() == OP_iassign) {
+      continue;
+    }
+    auto *chiList = static_cast<IassignMeStmt*>(stmt)->GetChiList();
+    if (chiList == nullptr) {
+      continue;
+    }
+    for (auto chiPair : *chiList) {
+      auto *chi = chiPair.second;
+      CHECK_FATAL(chi->GetBase() == stmt, "chi base mismatch");
+      auto *defStmt = chi->GetRHS()->GetDefByMeStmt();
+      if (defStmt == nullptr || defStmt->GetBB() != stmt->GetBB()) {
+        continue;
+      }
+      CHECK_FATAL(GetOrderId(defStmt) < GetOrderId(stmt), "def first, use second");
+    }
+  }
+}
+
+// `end` may be nullptr
+void BlockScheduling::RebuildUseInfo(MeStmt *begin, MeStmt *end, MapleAllocator &alloc) {
+  CHECK_NULL_FATAL(begin);
+  CHECK_FATAL(begin->GetBB() == bb, "begin stmt must belong to current BB");
+  exprUseInfo = alloc.New<MeExprUseInfo>(alloc.GetMemPool());
+  auto *useSites = alloc.New<MapleVector<ExprUseInfoPair>>(alloc.Adapter());
+  exprUseInfo->SetUseSites(useSites);
+  auto *stmt = begin;
+  while (stmt != nullptr && stmt != end) {
+    exprUseInfo->CollectUseInfoInStmt(stmt);
+    stmt = stmt->GetNext();
+  }
+  exprUseInfo->SetState(kUseInfoOfScalar);
+}
+
+void BlockScheduling::ExtendUseInfo() {
+  if (extendUseInfo) {
+    return;
+  }
+  ASSERT_NOT_NULL(exprUseInfo);
+  for (auto *succ : bb->GetSucc()) {
+    exprUseInfo->CollectUseInfoInBB(succ);
+  }
+  extendUseInfo = true;
+}
+
+bool BlockScheduling::IsOstUsedByStmt(OriginalSt *ost, MeStmt *stmt) {
+  std::unordered_set<OriginalSt*> ostsUsed;
+  GetOstsUsed(stmt, ostsUsed);
+  return ostsUsed.find(ost) != ostsUsed.end();
+}
+
+// `anchor` must be before `stmt`
+bool BlockScheduling::CanScheduleStmtBefore(MeStmt *stmt, MeStmt *anchor, SchedFailReason &failReason) {
+  CHECK_FATAL(stmt->GetBB() == anchor->GetBB(), "must belong to same BB");
+  auto stmtOrderId = GetOrderId(stmt);
+  auto anchorOrderId = GetOrderId(anchor);
+  CHECK_FATAL(anchorOrderId < stmtOrderId, "anchor must be before stmt");
+  std::vector<MeStmt*> depsOfOpnd;
+  std::vector<MeStmt*> depsOfChiRhs;
+  std::vector<MeStmt*> depsOfMu;
+  GetDependencyStmts(stmt, depsOfOpnd, depsOfChiRhs, depsOfMu);
+  // check opndDep
+  MeStmt *found = FindAnyStmtInRegion(depsOfOpnd, anchor, stmt);  // range: [anchor, stmt)
+  if (found != nullptr) {
+    failReason = SchedFailReason::kSchedFailOpndDep;
+    SLP_DEBUG(os << "stmt" << GetOrderId(stmt) << "'s opnd depends on stmt" << GetOrderId(found) << std::endl);
+    return false;
+  }
+  // check muDep
+  found = FindAnyStmtInRegion(depsOfMu, anchor, stmt);
+  if (found != nullptr) {
+    failReason = SchedFailReason::kSchedFailMuDep;
+    SLP_DEBUG(os << "stmt" << GetOrderId(stmt) << "'s mu depends on stmt" << GetOrderId(found) << std::endl);
+    return false;
+  }
+  // check chiRhsDep
+  found = FindAnyStmtInRegion(depsOfChiRhs, anchor, stmt);
+  if (found != nullptr) {
+    failReason = SchedFailReason::kSchedFailChiRhsDep;
+    SLP_DEBUG(os << "stmt" << GetOrderId(stmt) << "'s chiRhs depends on stmt" << GetOrderId(found) << std::endl);
+    return false;
+  }
+
+  // check chiRhsUse
+  std::vector<MeStmt*> useChiRhsStmts;
+  GetUseStmtsOfChiRhs(*exprUseInfo, stmt, useChiRhsStmts);
+  found = FindAnyStmtInRegion(useChiRhsStmts, anchor, stmt);
+  if (found != nullptr) {
+    failReason = SchedFailReason::kSchedFailChiRhsUse;
+    SLP_DEBUG(os << "stmt" << GetOrderId(stmt) << " chi rhs is used by stmt" << GetOrderId(found) << std::endl);
+    return false;
+  }
+  // Identify WAR (Write After Read) for a same preg
+  if (stmt->GetOp() == OP_regassign) {
+    auto *defOst = static_cast<AssignMeStmt*>(stmt)->GetLHS()->GetOst();
+    for (size_t id = anchorOrderId; id < stmtOrderId; ++id) {
+      if (IsOstUsedByStmt(defOst, stmtVec[id])) {
+        failReason = SchedFailReason::kSchedFailPregWAR;
+        SLP_DEBUG(os << "Found WAR: stmt" << GetOrderId(stmtVec[id]) << " uses ost ");
+        if (debug) {
+          defOst->Dump();
+          os << " that will defined by stmt" << GetOrderId(stmt) << std::endl;
+        }
+        return false;
+      }
+    }
+  }
+  failReason = SchedFailReason::kSchedSuccess;
+  return true;
+}
+
+// Both `anchor` and `stmt` must be iassign/dassign stmt and must be adjacent
+bool BlockScheduling::CanScheduleAssignWithoutOverlapBefore(MeStmt *stmt, MeStmt *anchor) {
+  bool bothDassign = (stmt->GetOp() == OP_dassign && anchor->GetOp() == OP_dassign);
+  bool bothIassign = (stmt->GetOp() == OP_iassign && anchor->GetOp() == OP_iassign);
+  if (!bothDassign && !bothIassign) {
+    return false;
+  }
+  CHECK_FATAL(stmt->GetBB() == anchor->GetBB(), "must belong to same BB");
+  auto stmtOrderId = GetOrderId(stmt);
+  auto anchorOrderId = GetOrderId(anchor);
+  // Two stmts must be adjacent:
+  //   id     : anchor
+  //   id + 1 : stmt
+  if (stmtOrderId - 1 != anchorOrderId) {
+    return false;
+  }
+  MeExpr *lhsAnchor = nullptr;
+  MeExpr *lhsStmt = nullptr;
+  if (bothDassign) {
+    lhsAnchor = static_cast<DassignMeStmt*>(anchor)->GetLHS();
+    lhsStmt = static_cast<DassignMeStmt*>(stmt)->GetLHS();
+  } else if (bothIassign) {
+    lhsAnchor = static_cast<IassignMeStmt*>(anchor)->GetLHSVal();
+    lhsStmt = static_cast<IassignMeStmt*>(stmt)->GetLHSVal();
+  }
+  if (PrimitiveType(lhsAnchor->GetPrimType()).IsVector() ||
+      PrimitiveType(lhsStmt->GetPrimType()).IsVector()) {
+    return false;
+  }
+  auto *firstMemLoc = memoryHelper.GetMemLoc(*lhsAnchor);
+  auto *secondMemLoc = memoryHelper.GetMemLoc(*lhsStmt);
+  CHECK_NULL_FATAL(firstMemLoc);
+  CHECK_NULL_FATAL(secondMemLoc);
+  if (!MemoryHelper::HaveSameBase(*firstMemLoc, *secondMemLoc) ||
+      !MemoryHelper::MustHaveNoOverlap(*firstMemLoc, *secondMemLoc)) {
+    return false;
+  }
+  return true;
+}
+
+bool BlockScheduling::TryScheduleTwoStmtsTogether(MeStmt *first, MeStmt *second) {
+  CHECK_FATAL(first->GetBB() == second->GetBB(), "must belong to same BB");
+  auto firstOrderId = GetOrderId(first);
+  auto secondOrderId = GetOrderId(second);
+  CHECK_FATAL(firstOrderId < secondOrderId, "`first` must be before `second`");
+  for (uint32 id = firstOrderId + 1; id < secondOrderId; ++id) {
+    auto *stmt = stmtVec[id];
+    SchedFailReason failReason = SchedFailReason::kSchedSuccess;
+    if (!CanScheduleStmtBefore(stmt, first, failReason)) {
+      SLP_DEBUG(os << "stmt" << GetOrderId(stmt) << " can not be scheduled before stmt" <<
+          GetOrderId(first) << std::endl);
+      if (debug) {
+        for (auto i = GetOrderId(first); i <= GetOrderId(stmt); ++i) {
+          os << "  <" << i << "> LOC " << stmtVec[i]->GetSrcPosition().LineNum();
+          stmtVec[i]->Dump(func.GetIRMap());
+        }
+      }
+      // Try schedule iassign/dassign stmts without overlap
+      if (failReason == SchedFailReason::kSchedFailChiRhsDep && CanScheduleAssignWithoutOverlapBefore(stmt, first)) {
+        ScheduleStmtBefore(stmt, first, true);
+        if (debug) {
+          os << "Schedule iassign/dassign stmts without overlap successfully\nAfter scheduled:" << std::endl;
+          // orderIds have been swapped now
+          for (auto i = GetOrderId(stmt); i <= GetOrderId(first); ++i) {
+            os << "  <" << i << "> LOC " << stmtVec[i]->GetSrcPosition().LineNum();
+            stmtVec[i]->Dump(func.GetIRMap());
+          }
+        }
+        continue;
+      }
+      return false;
+    }
+    // DO NOT cache orderIds because ScheduleStmtBefore will change them
+    ScheduleStmtBefore(stmt, first);
+  }
+  return true;
+}
+
+// Vectorization infrastruction
+MIRType *GetScalarUnsignedTypeBySize(uint32 typeSize) {
+  switch (typeSize) {
+    case 8: return GlobalTables::GetTypeTable().GetUInt8();
+    case 16: return GlobalTables::GetTypeTable().GetUInt16();
+    case 32: return GlobalTables::GetTypeTable().GetUInt32();
+    case 64: return GlobalTables::GetTypeTable().GetUInt64();
+    default: CHECK_FATAL(false, "error type size");
+  }
+  return nullptr;
+}
+
+MIRType* GenVecType(PrimType sPrimType, uint8 lanes) {
+  MIRType *vecType = nullptr;
+  switch (sPrimType) {
+    case PTY_f32: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4Float32();
+      } else if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2Float32();
+      } else {
+        CHECK_FATAL(false, "unsupported f32 vecotry lanes");
+      }
+      break;
+    }
+    case PTY_f64: {
+      if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2Float64();
+      } else {
+        CHECK_FATAL(false, "unsupported f64 vectory lanes");
+      }
+      break;
+    }
+    case PTY_i32: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4Int32();
+      } else if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2Int32();
+      } else {
+        CHECK_FATAL(false, "unsupported int32 vectory lanes");
+      }
+      break;
+    }
+    case PTY_u32:
+    case PTY_a32: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4UInt32();
+      } else if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2UInt32();
+      } else {
+        CHECK_FATAL(false, "unsupported uint32 vectory lanes");
+      }
+      break;
+    }
+    case PTY_i16: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4Int16();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8Int16();
+      } else {
+        CHECK_FATAL(false, "unsupported int16 vector lanes");
+      }
+      break;
+    }
+    case PTY_u16: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4UInt16();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8UInt16();
+      } else {
+        CHECK_FATAL(false, "unsupported uint16 vector lanes");
+      }
+      break;
+    }
+    case PTY_i8: {
+      if (lanes == 16) {
+        vecType = GlobalTables::GetTypeTable().GetV16Int8();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8Int8();
+      } else {
+        CHECK_FATAL(false, "unsupported int8 vector lanes");
+      }
+      break;
+    }
+    case PTY_u8: {
+      if (lanes == 16) {
+        vecType = GlobalTables::GetTypeTable().GetV16UInt8();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8UInt8();
+      } else {
+        CHECK_FATAL(false, "unsupported uint8 vector lanes");
+      }
+      break;
+    }
+    case PTY_i64: {
+      if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2Int64();
+      } else {
+        CHECK_FATAL(false, "unsupported i64 vector lanes");
+      }
+    }
+    [[clang::fallthrough]];
+    case PTY_u64:
+    case PTY_a64: {
+      if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2UInt64();
+      } else {
+        CHECK_FATAL(false, "unsupported a64/u64 vector lanes");
+      }
+    }
+    [[clang::fallthrough]];
+    case PTY_ptr: {
+      if (GetPrimTypeSize(sPrimType) == 4) {
+        if (lanes == 4)  {
+          vecType = GlobalTables::GetTypeTable().GetV4UInt32();
+        } else if (lanes == 2) {
+          vecType = GlobalTables::GetTypeTable().GetV2UInt32();
+        } else {
+          CHECK_FATAL(false, "unsupported ptr vector lanes");
+        }
+      } else if (GetPrimTypeSize(sPrimType) == 8) {
+        if (lanes == 2) {
+          vecType = GlobalTables::GetTypeTable().GetV2UInt64();
+        } else {
+          CHECK_FATAL(false, "unsupported ptr vector lanes");
+        }
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "NIY");
+  }
+  return vecType;
+}
+
+#define VECTOR_INTRN_CASE(OP, TY)                      \
+  case PTY_##TY: {                                     \
+    intrinsic = INTRN_##OP##_##TY;                     \
+    break;                                             \
+  }
+
+#define GET_VECTOR_INTRN_8BIT(OP)                      \
+  VECTOR_INTRN_CASE(OP, v16i8)                         \
+  VECTOR_INTRN_CASE(OP, v16u8)                         \
+  VECTOR_INTRN_CASE(OP, v8i8)                          \
+  VECTOR_INTRN_CASE(OP, v8u8)
+
+#define GET_VECTOR_INTRN_16BIT(OP)                     \
+  VECTOR_INTRN_CASE(OP, v8i16)                         \
+  VECTOR_INTRN_CASE(OP, v8u16)                         \
+  VECTOR_INTRN_CASE(OP, v4i16)                         \
+  VECTOR_INTRN_CASE(OP, v4u16)
+
+#define GET_VECTOR_INTRN_32BIT(OP)                     \
+  VECTOR_INTRN_CASE(OP, v4i32)                         \
+  VECTOR_INTRN_CASE(OP, v2i32)                         \
+  VECTOR_INTRN_CASE(OP, v4u32)                         \
+  VECTOR_INTRN_CASE(OP, v2u32)
+
+#define GET_VECTOR_INTRN_NYI                           \
+  default:                                             \
+    CHECK_FATAL(false, "NYI");
+
+#define GET_VECTOR_INTRN(OP)                           \
+  GET_VECTOR_INTRN_32BIT(OP)                           \
+  GET_VECTOR_INTRN_16BIT(OP)                           \
+  GET_VECTOR_INTRN_8BIT(OP)                            \
+  VECTOR_INTRN_CASE(OP, v2i64)                         \
+  VECTOR_INTRN_CASE(OP, v2u64)                         \
+  VECTOR_INTRN_CASE(OP, v2f32)                         \
+  VECTOR_INTRN_CASE(OP, v4f32)                         \
+  VECTOR_INTRN_CASE(OP, v2f64)                         \
+  GET_VECTOR_INTRN_NYI
+
+MIRIntrinsicID GetVectorSetElementIntrnId(PrimType type) {
+  MIRIntrinsicID intrinsic;
+  switch (type) {
+    GET_VECTOR_INTRN(vector_set_element);
+  }
+  return intrinsic;
+}
+
+MIRIntrinsicID GetVectorFromScalarIntrnId(PrimType type) {
+  MIRIntrinsicID intrinsic;
+  switch (type) {
+    GET_VECTOR_INTRN(vector_from_scalar);
+  }
+  return intrinsic;
+}
+
+MIRIntrinsicID GetVectorReverse32IntrnId(PrimType type) {
+  MIRIntrinsicID intrinsic;
+  switch (type) {
+    GET_VECTOR_INTRN(vector_reverse);
+  }
+  return intrinsic;
+}
+
+MIRIntrinsicID GetVectorReverse16IntrnId(PrimType type) {
+  MIRIntrinsicID intrinsic;
+  switch (type) {
+    GET_VECTOR_INTRN_8BIT(vector_reverse16)
+    GET_VECTOR_INTRN_NYI
+  }
+  return intrinsic;
+}
+
+MIRIntrinsicID GetVectorReverse64IntrnId(PrimType type) {
+  MIRIntrinsicID intrinsic;
+  switch (type) {
+    GET_VECTOR_INTRN_32BIT(vector_reverse64)
+    GET_VECTOR_INTRN_16BIT(vector_reverse64)
+    GET_VECTOR_INTRN_8BIT(vector_reverse64)
+    GET_VECTOR_INTRN_NYI
+  }
+  return intrinsic;
+}
+
+// ---------------- //
+//  SLP Vectorizer  //
+// ---------------- //
+// Superword Level Parallelism Vectorizer for straight-line code
+class SLPVectorizer {
+ public:
+  using StoreVec = std::vector<StoreWrapper*>;
+  using StmtVec = MapleVector<MeStmt*>;
+  SLPVectorizer(MemPool &mp, MeFunction &f, Dominance &dom, bool dbg)
+      : alloc(&mp),
+        memoryHelper(mp),
+        func(f),
+        irMap(*f.GetIRMap()),
+        dom(dom),
+        debug(dbg),
+        os(LogInfo::MapleLogger()) {
+  }
+
+  void Run();
+  void ProcessBB(BB &bb);
+  void CollectSeedStmts();
+  void AddSeedStore(MeStmt *stmt, MemLoc *memLoc);
+  void FilterAndSortSeedStmts();
+  bool TrySplitSeedStmts();
+
+  void VectorizeStoreVecMap();
+  void VectorizeStores(StoreVec &storeVec);
+  void VectorizeCompatibleStores(StoreVec &storeVec, uint32 begin, uint32 end);
+  void VectorizeConsecutiveStores(StoreVec &storeVec, uint32 begin, uint32 end);
+  bool DoVectorizeSlicedStores(StoreVec &storeVec, uint32 begin, uint32 end, bool onlySchedule = false);
+
+  bool TryScheduleTogehter(const std::vector<MeStmt*> &stmts);
+  bool BuildTree(std::vector<MeStmt*> &stmts);
+  TreeNode *BuildTreeRec(std::vector<ExprWithDef*> &exprVec, uint32 depth, TreeNode *parentNode);
+
+  bool VectorizeTreeNode(TreeNode *treeNode);
+  bool DoVectTreeNodeIvar(TreeNode *treeNode);
+  bool DoVectTreeNodeConstval(TreeNode *treeNode);
+  bool DoVectTreeNodeBinary(TreeNode *treeNode);
+  bool DoVectTreeNodeNary(TreeNode *treeNode);
+  bool DoVectTreeNodeNaryReverse(TreeNode *treeNode, MIRIntrinsicID intrnId);
+  bool DoVectTreeNodeIassign(TreeNode *treeNode);
+  bool DoVectTreeNodeGatherNeeded(TreeNode *treeNode);
+  bool VectorizeSLPTree();
+  void SetStmtVectorized(MeStmt &stmt);
+  bool IsStmtVectorized(MeStmt &stmt) const;
+  MIRType* GenMergedType(PrimType primType, uint8 lanes) const;
+
+  void MarkStmtsVectorizedInTree();
+  void ReplaceStmts(const std::vector<MeStmt*> &origStmtVec, std::list<MeStmt*> &newStmtList);
+  void CodeMotionVectorize();
+  void CodeMotionReorderStoresAndLoads();
+  void CodeMotionSaveSchedulingResult();
+
+ private:
+  MapleAllocator alloc;
+  MapleAllocator *tmpAlloc = nullptr;
+  MemoryHelper memoryHelper;
+  MeFunction &func;
+  IRMap &irMap;
+  Dominance &dom;
+  std::map<MemBasePtr*, StoreVec, MemBasePtrCmp> storeVecMap;  // key is base point part of store lhs ivar
+  std::unordered_set<MeStmt*> vectorizedStmts;  // Vectorized stmts in current BB, to avoid vectorize a stmt twice
+  BlockScheduling *blockScheduling = nullptr;
+  BB *currBB = nullptr;
+  bool splited = false;     // whether the stmts in currBB have been splited
+  bool mergeToVecType = true;
+  SLPTree *tree = nullptr;
+  bool debug = false;
+  std::ostream &os;
+};
+
+void SLPVectorizer::Run() {
+  SLP_DEBUG(os << "Before processing func " << func.GetName() << std::endl);
+  const auto &rpo = dom.GetReversePostOrder();
+  for (auto *bb : rpo) {
+    ProcessBB(*func.GetCfg()->GetBBFromID(BBId(bb->GetID())));
+  }
+  if (localSymOffsetTab != nullptr) {
+    delete localSymOffsetTab;
+    localSymOffsetTab = nullptr;
+  }
+  SLP_DEBUG(os << "After processing func " << func.GetName() << std::endl);
+}
+
+void SLPVectorizer::ProcessBB(BB &bb) {
+  blockScheduling = nullptr;
+  currBB = &bb;
+  vectorizedStmts.clear();
+  CollectSeedStmts();
+  FilterAndSortSeedStmts();
+  if (storeVecMap.empty()) {
+    return;
+  }
+  SLP_DEBUG(os << "=========================================================" << std::endl);
+  SLP_DEBUG(os << "Collected " << storeVecMap.size() << " storeVecs in BB" << bb.GetBBId() << std::endl);
+  splited = false;
+  TrySplitSeedStmts();
+  VectorizeStoreVecMap();
+}
+
+void SLPVectorizer::VectorizeStoreVecMap() {
+  if (storeVecMap.empty()) {
+    return;
+  }
+  StackMemPool stackMemPool(memPoolCtrler, "");
+  MapleAllocator stackAlloc(&stackMemPool);
+  tmpAlloc = &stackAlloc;
+  for (auto &entry : storeVecMap) {
+    StoreVec &storeVec = entry.second;
+    CHECK_FATAL(storeVec.size() >= 2, "storeVec with size less than 2 should have been removed before");
+    VectorizeStores(storeVec);
+  }
+  tmpAlloc = nullptr;
+}
+
+// All stores in the `storeVec` have same store memory base pointer
+// Exmaple1: store memory base pointer is &A
+//   A[100] = ...
+//   A[101] = ...
+// Example2: store memory base pointer is &obj
+//   obj.field1 = ...
+//   obj.field2 = ...
+void SLPVectorizer::VectorizeStores(StoreVec &storeVec) {
+  SLP_DEBUG(os << "VectorizeStores with size " << storeVec.size() << std::endl);
+  if (debug) {
+    uint32 i = 0;
+    for (auto *storeWrapper : storeVec) {
+      os << "  " << i++ << ": ";
+      storeWrapper->storeMem->DumpWithoutEndl();
+      auto *rhs = storeWrapper->stmt->GetRHS();
+      os << " = ";
+      if (rhs->GetOp() == OP_constval) {
+        rhs->Dump(&irMap);
+      } else {
+        os << GetOpName(rhs->GetOp());
+      }
+      os << " : ";
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(rhs->GetPrimType()))->Dump(0);
+      os << " ...... LOC " << storeWrapper->stmt->GetSrcPosition().LineNum();
+      os << std::endl;
+    }
+  }
+  // Find compatible store range and try to vectorize them
+  for (size_t i = 0; i < storeVec.size();) {
+    size_t j = i + 1;
+    while (j < storeVec.size() && AreCompatibleStoreWrappers(*storeVec[i], *storeVec[j])) {
+      ++j;
+    }
+    size_t num = j - i;
+    if (num <= 1) {
+      // no enough compatible stores, can't do vectorization
+      ++i;
+      continue;
+    }
+    // num > 2, try to vectorize storeSlice
+    VectorizeCompatibleStores(storeVec, i, j);
+    i = j;
+  }
+}
+
+// Try to vectorize storeVec[begin, end), in which all stores are compatible
+void SLPVectorizer::VectorizeCompatibleStores(StoreVec &storeVec, uint32 begin, uint32 end) {
+  SLP_DEBUG(os << "== VectorizeCompatibleStores [" << begin << ", " << end << ")" << std::endl);
+  for (uint32 i = begin; i < end;) {
+    uint32 j = i + 1;
+    for (; j < end; ++j) {
+      if (!MemoryHelper::IsConsecutive(*storeVec[j - 1]->storeMem, *storeVec[j]->storeMem, false)) {
+        break;
+      }
+    }
+    uint32 num = j - i;
+    if (num <= 1) {
+      // no enough consecutive stores. can't do vectorization
+      ++i;
+      continue;
+    }
+    VectorizeConsecutiveStores(storeVec, i, j);
+    i = j;
+  }
+}
+
+// This is target-dependent, we need abstract TargetInfo in the future
+// The first is VectorFactor, the second is ScalarFactor
+std::pair<uint32, uint32> GetMaxFactors(PrimType scalarType) {
+  CHECK_FATAL(!PrimitiveType(scalarType).IsVector(), "must be");
+  auto typeSize = GetPrimTypeSize(scalarType);
+  CHECK_FATAL(typeSize != 0, "unknown type size");
+  return { 16 / typeSize, 8 / typeSize };  // max vector regsize: 16byte, max scalar regsize: 8byte
+}
+
+std::pair<uint32, uint32> GetMinFactors(PrimType scalarType) {
+  CHECK_FATAL(!PrimitiveType(scalarType).IsVector(), "must be");
+  auto typeSize = GetPrimTypeSize(scalarType);
+  CHECK_FATAL(typeSize != 0, "unknown type size");
+  return { std::max(8 / typeSize, 2u), 2u };  // min vector regsize: 8byte, minSf is always 2
+}
+
+bool IsTwoStoreWrapperSame(StoreWrapper *s1, StoreWrapper *s2) {
+  return MemoryHelper::IsSame(*s1->storeMem, *s2->storeMem) && s1->stmt->GetRHS() == s2->stmt->GetRHS();
+}
+
+bool IsSurroundedByRepeatedStore(SLPVectorizer::StoreVec &storeVec, uint32 first, uint32 last) {
+  auto size = storeVec.size();
+  if (first > 0 && IsTwoStoreWrapperSame(storeVec[first - 1], storeVec[first])) {
+    return true;
+  }
+  if (last < size - 1 && IsTwoStoreWrapperSame(storeVec[last], storeVec[last + 1])) {
+    return true;
+  }
+  return false;
+}
+
+// Try to vectorize storeVec[begin, end), in which all stores are compatible and consecutive
+void SLPVectorizer::VectorizeConsecutiveStores(StoreVec &storeVec, uint32 begin, uint32 end) {
+  SLP_DEBUG(os << "==== VectorizeConsecutiveStores [" << begin << ", " << end << ")" << std::endl);
+  PrimType scalarType = storeVec[begin]->storeMem->type->GetPrimType();
+  const auto &maxFactors = GetMaxFactors(scalarType);
+  const auto &minFactors = GetMinFactors(scalarType);
+  const uint32 maxVf = maxFactors.first;
+  const uint32 maxSf = maxFactors.second;
+  const uint32 minVf = minFactors.first;
+  const uint32 minSf = minFactors.second;
+  SLP_DEBUG(os << "minVf: " << minVf << ", maxVf: " << maxVf <<
+      "; minSf: " << minSf << ", maxSf: " << maxSf << std::endl);
+  uint32 endIdx = end;
+  bool tried = false;
+  std::vector<bool> vectorized(storeVec.size(), false);
+  for (uint32 factor = maxVf; factor >= minSf; factor /= k2BitSize) {
+    for (uint32 i = endIdx; i >= factor && i - factor >= begin;) {
+      // Make sure no scalar stores have been vectorized
+      // When stmts are vectorized successfully, we will set them vectorizd
+      // to avoid vectorize them again.
+      mergeToVecType = factor >= minVf;
+      uint32 currBegin = i - factor;
+      bool allStoresNotVectorized = true;
+      for (uint32 k = currBegin; k < i; ++k) {
+        if (vectorized[k]) {
+          allStoresNotVectorized = false;
+          break;
+        }
+      }
+      if (!allStoresNotVectorized) {
+        i -= factor;  // can use --i for more optimization at the cost of build time
+        continue;
+      }
+      if (IsSurroundedByRepeatedStore(storeVec, currBegin, i - 1)) {  // we trust hdse
+        SLP_FAILURE_DEBUG(os << "surrounded by repeated stores" << std::endl);
+        i -= factor;
+        continue;
+      }
+      bool res = DoVectorizeSlicedStores(storeVec, currBegin, i);
+      tried = true;
+      if (res) {
+        for (uint32 j = currBegin; j < i; ++j) {
+          vectorized[j] = true;
+        }
+        if (i == endIdx) {
+          endIdx -= factor;
+        }
+        i -= factor;
+        continue;
+      }
+      i -= factor;  // can use --i for more optimization at the cost of build time
+    }
+  }
+  if (!tried) {
+    SLP_DEBUG(os << "can't find appropriate vector factor, minVf = " << minVf << ", maxVf = " << maxVf << std::endl);
+    SLP_DEBUG(os << "vectorize failure, try to reorder load/store" << std::endl);
+    DoVectorizeSlicedStores(storeVec, begin, end, true);
+  }
+}
+
+// input: consecutive compatible stores
+// Try to vectorize storeVec[begin, begin + vf)
+bool SLPVectorizer::DoVectorizeSlicedStores(StoreVec &storeVec, uint32 begin, uint32 end, bool onlySchedule) {
+  uint32 vf = end - begin;
+  SLP_DEBUG(os << "====== DoVectorizeSlicedStores [" << begin << ", " << end << ") vf = " << vf << std::endl);
+  // Init blockScheduling if needed
+  auto bsPtr = std::make_unique<BlockScheduling>(func, currBB, memoryHelper, debug);
+  blockScheduling = bsPtr.get();
+  SLP_DEBUG(os << "Init BlockScheduling for BB" << currBB->GetBBId() << std::endl);
+  blockScheduling->Init();
+  // Rebuild currBB use info before building tree
+  // Rebuild if needed
+  blockScheduling->RebuildUseInfo(currBB->GetFirstMe(), nullptr, *tmpAlloc);
+
+  std::vector<MeStmt*> stmts;
+  for (uint32 i = begin; i < end; ++i) {
+    stmts.push_back(storeVec[i]->stmt);
+  }
+  bool res = BuildTree(stmts);
+  if (!res) {
+    CHECK_FATAL(false, "should not be here");
+  }
+  if (onlySchedule) {
+    SLP_DEBUG(os << "onlySchedule save result" << std::endl);
+    CodeMotionSaveSchedulingResult();
+    return true;
+  }
+
+  bool vectorized = VectorizeSLPTree();
+  // If we can use stp instruction, don't need to replace scalar stmts with vector stmts
+  if (vectorized) {
+    SLP_DEBUG(os << "CodeMotionVectorize" << std::endl);
+    MarkStmtsVectorizedInTree();
+    CodeMotionVectorize();
+  } else if (blockScheduling->irModified) {
+    // If IR have been modified after scheduling (such as chiList), scheduling result must be saved
+    SLP_DEBUG(os << "CodeMotionSaveSchedulingResult" << std::endl);
+    CodeMotionSaveSchedulingResult();
+  } else if (tree->CanTreeUseStp()) {
+    SLP_DEBUG(os << "CodeMotionReorderStoresAndLoads" << std::endl);
+    CodeMotionReorderStoresAndLoads();
+  } else if (tree->GetSize() > k2BitSize) {
+    bool hasLoadStorePair = false;
+    for (auto *treeNode : tree->GetNodes()) {
+      if (treeNode->CanNodeUseLoadStorePair()) {
+        hasLoadStorePair = true;
+        break;
+      }
+    }
+    if (hasLoadStorePair) {
+      SLP_DEBUG(os << "CodeMotionSaveSchedulingResult" << std::endl);
+      CodeMotionSaveSchedulingResult();  // Save scheduling result to put load/store pair together
+    }
+  }
+  return vectorized;
+}
+
+void SLPVectorizer::CodeMotionSaveSchedulingResult() {
+  // We should call RecoverStmtIds before any real code motion
+  RecoverStmtIds(*currBB, blockScheduling->stmtIdBuffer);
+  currBB->GetMeStmts().clear();
+  for (auto *stmt : blockScheduling->GetStmtVec()) {
+    stmt->SetPrev(nullptr);
+    stmt->SetNext(nullptr);
+    currBB->AddMeStmtLast(stmt);
+  }
+}
+
+void SLPVectorizer::CodeMotionVectorize() {
+  std::list<MeStmt*> newStmtList;
+  // ReplaceStmts must be called before RecoverStmtIds
+  ReplaceStmts(blockScheduling->GetStmtVec(), newStmtList);
+  // We should call RecoverStmtIds before any real code motion
+  RecoverStmtIds(*currBB, blockScheduling->stmtIdBuffer);
+  currBB->GetMeStmts().clear();
+  for (auto *stmt : newStmtList) {
+    stmt->SetPrev(nullptr);
+    stmt->SetNext(nullptr);
+    currBB->AddMeStmtLast(stmt);
+  }
+}
+
+// The output newStmtList must have no repeated elements
+void SLPVectorizer::ReplaceStmts(const std::vector<MeStmt*> &origStmtVec, std::list<MeStmt*> &newStmtList) {
+  bool keepStmtsExceptIassign = true;
+  std::set<uint32> insertPositions;
+  std::set<uint32> toBeRemoved;
+  std::map<uint32, std::vector<MeStmt*>> pos2newStmts;
+  for (auto *treeNode : tree->GetNodes()) {
+    if (treeNode->ConstOrNeedGather()) {
+      continue;
+    }
+    uint32 pos = 0;
+    for (auto *stmt : treeNode->GetStmts()) {
+      if (stmt == nullptr) {
+        continue;
+      }
+      auto orderId = GetOrderId(stmt);
+      if (keepStmtsExceptIassign && (treeNode->GetOp() == OP_iassign || treeNode->GetOp() == OP_dassign)) {
+        toBeRemoved.insert(orderId);  // only remove store scalar stmts
+      }
+      if (orderId > pos) {
+        pos = orderId;
+      }
+    }
+    std::vector<MeStmt*> newStmts;
+    for (auto *child : treeNode->GetChildren()) {
+      if (child->ConstOrNeedGather()) {
+        newStmts.insert(newStmts.end(), child->GetOutStmts().begin(), child->GetOutStmts().end());
+      }
+    }
+    newStmts.insert(newStmts.end(), treeNode->GetOutStmts().begin(), treeNode->GetOutStmts().end());
+    if (pos != 0 && !newStmts.empty()) {
+      insertPositions.insert(pos);
+      pos2newStmts.emplace(pos, newStmts);
+    }
+  }
+
+  for (size_t i = 0; i < origStmtVec.size(); ++i) {
+    auto orderId = GetOrderId(origStmtVec[i]);
+    if (orderId == *insertPositions.begin()) {
+      auto it = pos2newStmts.find(orderId);
+      CHECK_FATAL(it != pos2newStmts.end(), "must be");
+      for (auto *stmt : it->second) {
+        newStmtList.push_back(stmt);
+      }
+      insertPositions.erase(insertPositions.begin());
+    }
+    if (toBeRemoved.find(orderId) == toBeRemoved.end()) {
+      newStmtList.push_back(origStmtVec[i]);
+    } else {
+      auto *removeStmt = origStmtVec[i];
+      if (removeStmt->GetOp() == OP_iassign) {
+        static_cast<IassignMeStmt*>(removeStmt)->GetLHSVal()->SetDefStmt(nullptr);
+      }
+    }
+  }
+}
+
+void SLPVectorizer::CodeMotionReorderStoresAndLoads() {
+  if (tree->GetSize() == 0) {
+    return;
+  }
+  auto scalarTypeSize = GetPrimTypeBitSize(tree->GetType());
+  if (scalarTypeSize != k32BitSize && scalarTypeSize != k64BitSize) {
+    return;
+  }
+  auto lane = tree->GetLane();
+  if (lane != k2BitSize) {
+    return;
+  }
+  auto *root = tree->GetRoot();
+  std::vector<MeStmt*> storeStmts;
+  for (auto *stmt : root->GetStmts()) {
+    storeStmts.push_back(stmt);
+  }
+  // sort stmts by orderId
+  std::sort(storeStmts.begin(), storeStmts.end(), [](MeStmt *a, MeStmt *b) {
+    return GetOrderId(a) < GetOrderId(b);
+  });
+
+  bool isRhsLoad = root->GetChildren()[0]->IsLoad();
+  std::vector<MeStmt*> loadStmts;
+  if (isRhsLoad) {
+    for (auto *stmt : root->GetChildren()[0]->GetStmts()) {
+      loadStmts.push_back(stmt);
+    }
+    std::sort(loadStmts.begin(), loadStmts.end(), [](MeStmt *a, MeStmt *b) {
+      return GetOrderId(a) < GetOrderId(b);
+    });
+  }
+
+  // We should call RecoverStmtIds before any real code motion
+  RecoverStmtIds(*currBB, blockScheduling->stmtIdBuffer);
+
+  // Do scheduling stores
+  for (size_t i = 0; i < lane - 1; ++i) {
+    auto *currStmt = storeStmts[i];
+    currBB->RemoveMeStmt(currStmt);
+    currBB->InsertMeStmtBefore(storeStmts.back(), currStmt);
+  }
+
+  if (isRhsLoad) {
+    // Do scheduling loads
+    // To improve: If we can identify that all loads have been scheduled together before,
+    // we can skip the following code to save build time.
+    MeStmt *anchor = loadStmts[0];
+    for (size_t i = 1; i < lane; ++i) {
+      auto *currStmt = loadStmts[i];
+      currBB->RemoveMeStmt(currStmt);
+      currBB->InsertMeStmtAfter(anchor, currStmt);
+      anchor = currStmt;
+    }
+  }
+}
+
+bool SLPVectorizer::TrySplitSeedStmts() {
+  // Each bb enters this function at most once
+  if (splited) {
+    return false;
+  }
+  SLP_DEBUG(os << "Try to split seed stmts" << std::endl);
+  splited = true;
+  bool changed = false;
+  for (auto &entry : storeVecMap) {
+    StoreVec &storeVec = entry.second;
+    CHECK_FATAL(storeVec.size() >= k2BitSize, "storeVec with size less than 2 should have been removed before");
+    // Split the potentially vectorizable seed stmts
+    for (auto *store : storeVec) {
+      TrySplitMeStmt(*store->stmt, func, changed);
+    }
+  }
+  return changed;
+}
+
+void SLPVectorizer::AddSeedStore(MeStmt *stmt, MemLoc *memLoc) {
+  MemBasePtr *key = memLoc->base;
+  auto *storeWrapper = alloc.GetMemPool()->New<StoreWrapper>(stmt, memLoc);
+  auto it = storeVecMap.find(key);
+  if (it != storeVecMap.end()) {
+    it->second.push_back(storeWrapper);
+  } else {
+    storeVecMap[key].push_back(storeWrapper);
+  }
+}
+
+// Currently we only collect store, it may be enhanced in the future.
+void SLPVectorizer::CollectSeedStmts() {
+  // Clear old seed stmts first
+  storeVecMap.clear();
+
+  auto *stmt = currBB->GetFirstMe();
+  while (stmt != nullptr) {
+    auto *next = stmt->GetNextMeStmt();
+    if (stmt->GetOp() == OP_iassign) {
+      auto *lhsIvar = static_cast<IassignMeStmt*>(stmt)->GetLHSVal();
+      auto *lhsIvarType = lhsIvar->GetType();
+      // Skip volatile store, vector store, agg store, bitfield store
+      if (lhsIvar->IsVolatile() || PrimitiveType(lhsIvarType->GetPrimType()).IsVector() ||
+          lhsIvar->GetPrimType() == PTY_agg || lhsIvarType->GetKind() == kTypeBitField) {
+        stmt = next;
+        continue;
+      }
+      MemLoc *memLoc = memoryHelper.GetMemLoc(*lhsIvar);
+      AddSeedStore(stmt, memLoc);
+    } else if (stmt->GetOp() == OP_dassign) {
+      auto *lhs = static_cast<DassignMeStmt*>(stmt)->GetLHS();
+      if (lhs->GetOp() != OP_dread || lhs->IsVolatile() || PrimitiveType(lhs->GetPrimType()).IsVector() ||
+          lhs->GetPrimType() == PTY_agg) {
+        stmt = next;
+        continue;
+      }
+      auto *lhsVar = static_cast<VarMeExpr*>(lhs);
+      auto *lhsVarType = lhsVar->GetType();
+      if (lhsVarType->GetKind() == kTypeBitField || lhsVar->GetFieldID() == 0) {  // only consider agg field dassign
+        stmt = next;
+        continue;
+      }
+      MemLoc *memLoc = memoryHelper.GetMemLoc(*lhsVar);
+      AddSeedStore(stmt, memLoc);
+    }
+    stmt = next;
+  }
+}
+
+// Remove storeVec with size less than 2 and
+// sort storeVec by address offset in ascending order
+void SLPVectorizer::FilterAndSortSeedStmts() {
+  for (auto it = storeVecMap.begin(); it != storeVecMap.end();) {
+    if (it->second.size() <= 1) {
+      it = storeVecMap.erase(it);
+    } else {
+      auto &storeVec = it->second;
+      // Sort storeVec by address offset in ascending order
+      std::stable_sort(storeVec.begin(), storeVec.end(), [](const auto *a, const auto *b) {
+        return a->storeMem->offset < b->storeMem->offset;
+      });
+      ++it;
+    }
+  }
+}
+
+
+// Schedule stmts from bottom to up
+bool SLPVectorizer::TryScheduleTogehter(const std::vector<MeStmt*> &stmts) {
+  // Sort stmts by source code order. The purpose of sorting is to schedule correctly.
+  // We must use original stmts when we create tree node, so we need to copy stmts.
+  std::vector<MeStmt*> sortedStmts = stmts;
+  std::sort(sortedStmts.begin(), sortedStmts.end(), [](MeStmt *a, MeStmt *b) {
+    return GetOrderId(a) < GetOrderId(b);
+  });
+  for (int32 i = sortedStmts.size() - 2; i >= 0; --i) {
+    bool res = blockScheduling->TryScheduleTwoStmtsTogether(sortedStmts[i], sortedStmts[i + 1]);
+    if (!res) {
+      return false;  // Schedule fail
+    }
+  }
+  return true;  // Schedule succeed
+}
+
+// Building SLP tree
+// input: sorted stmts by memLoc offset
+bool SLPVectorizer::BuildTree(std::vector<MeStmt*> &stmts) {
+  tree = tmpAlloc->New<SLPTree>(*tmpAlloc, memoryHelper, func, *blockScheduling);
+  SLP_DEBUG(os << "Build tree node for " << GetOpName(stmts[0]->GetOp()) << std::endl);
+  CHECK_FATAL(stmts.size() >= k2BitSize, "must be");
+
+  if (!TryScheduleTogehter(stmts)) {
+    SLP_FAILURE_DEBUG(os << "Scheduling failure" << std::endl);
+    return true;
+  }
+  SLP_DEBUG(os << "Scheduling OK, building tree node..." << std::endl);
+  auto *rootNode = tree->CreateTreeNodeByStmts(stmts, nullptr);
+
+  std::vector<ExprWithDef*> exprVec;
+  for (auto *stmt : stmts) {
+    CHECK_NULL_FATAL(stmt->GetRHS());
+    auto *exprWithDef = alloc.GetMemPool()->New<ExprWithDef>(stmt->GetRHS(), currBB);
+    exprVec.push_back(exprWithDef);
+  }
+  (void)BuildTreeRec(exprVec, 1, rootNode);
+
+  if (debug) {
+    os << "===== Print tree in dot format =====" << std::endl;
+    PrintTreeInDotFormat(rootNode, func);
+    os << "===== Print tree in text foramt =====" << std::endl;
+    PrintSLPTree(rootNode, func, false);
+  }
+  return true;
+}
+
+TreeNode *SLPVectorizer::BuildTreeRec(std::vector<ExprWithDef*> &exprVec, uint32 depth, TreeNode *parentNode) {
+  std::vector<MeExpr*> realExprs;
+  std::vector<MeExpr*> lhsExprs;
+  for (auto *exprWithDef : exprVec) {
+    realExprs.push_back(exprWithDef->GetRealExpr());
+    lhsExprs.push_back(exprWithDef->GetExpr());
+  }
+  auto *firstRealExpr = exprVec[0]->GetRealExpr();
+  Opcode currOp = firstRealExpr->GetOp();
+  SLP_DEBUG(os << "Build tree node for expr " << GetOpName(currOp) << std::endl);
+
+  // (1) Compatible exprs
+  bool compatible = AreAllExprsCompatibleShallow(realExprs);
+  if (!compatible) {
+    SLP_GATHER_DEBUG(os << "expr not compatible" << std::endl);
+    if (debug) {
+      for (size_t i = 0; i < realExprs.size(); ++i) {
+        os << "<expr" << i << "> ";
+        realExprs[i]->Dump(&irMap, 2);
+        os << std::endl;
+      }
+    }
+    return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+  }
+
+  // Now all the exprs are compatible
+  // (2) Supported ops/intrinsicops
+  if (std::find(supportedOps.begin(), supportedOps.end(), currOp) == supportedOps.end()) {
+    SLP_GATHER_DEBUG(os << "unsupported expr op: " << GetOpName(currOp) << std::endl);
+    return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+  }
+  if (currOp == OP_intrinsicop) {
+    auto intrnId = static_cast<NaryMeExpr*>(firstRealExpr)->GetIntrinsic();
+    if (std::find(supportedIntrns.begin(), supportedIntrns.end(), intrnId) == supportedIntrns.end()) {
+      SLP_GATHER_DEBUG(os << "unsupported intrinsicop: " << intrnId << std::endl);
+      return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+    }
+  }
+
+  if (currOp == OP_constval) {
+    return tree->CreateTreeNodeByExprs(exprVec, parentNode, true);
+  }
+
+  // mul v2u64 and mul v2i64 are not supported by armv8
+  // This is target-dependent configuration, maybe we need abstract it TargetInfo
+  if (currOp == OP_mul && exprVec.size() == 2 && GetPrimTypeBitSize(firstRealExpr->GetPrimType()) == 64) {
+    SLP_GATHER_DEBUG(os << "Unsupported vector mul pattern" << std::endl);
+    return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+  }
+
+  // (3) [CHECK LOAD] Check load/store size and check bit field load
+  if (firstRealExpr->GetMeOp() == kMeOpIvar) {
+    auto *firstIvar = static_cast<IvarMeExpr*>(firstRealExpr);
+    auto *loadMIRType = firstIvar->GetType();
+    PrimType loadType = loadMIRType->GetPrimType();
+    PrimType storeType = tree->GetType(); // The first tree node is always store
+    if (GetPrimTypeSize(loadType) != GetPrimTypeSize(storeType)) {
+      SLP_GATHER_DEBUG(os << "The type size of load and store can not match" << std::endl);
+      return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+    }
+    if (loadMIRType->GetKind() == kTypeBitField) {
+      SLP_GATHER_DEBUG(os << "BitField load vectorization is not supported" << std::endl);
+      return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+    }
+    // All loads must be consecutive
+    if (!memoryHelper.IsAllIvarConsecutive(realExprs, true)) {
+      SLP_GATHER_DEBUG(os << "loads are not consecutive" << std::endl);
+      return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+    }
+  }
+
+  std::vector<MeStmt*> stmts;
+  bool hasNullStmt = false;
+  bool hasVectorizedStmt = false;
+  std::set<MeExpr*> uniqueExprs;
+  std::set<MeStmt*> uniqueStmts;
+  for (auto *exprWithDef : exprVec) {
+    auto *currStmt = exprWithDef->GetDefStmt();
+    stmts.push_back(currStmt);
+    uniqueExprs.insert(exprWithDef->GetRealExpr());
+    uniqueStmts.insert(currStmt);
+    if (currStmt == nullptr) {
+      hasNullStmt = true;
+    }
+    if (currStmt != nullptr && IsStmtVectorized(*currStmt)) {
+      hasVectorizedStmt = true;
+    }
+  }
+
+  if (hasNullStmt) {
+    SLP_GATHER_DEBUG(os << "has null stmt" << std::endl);
+    return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+  }
+  if (hasVectorizedStmt) {
+    SLP_GATHER_DEBUG(os << "has vectorized stmt" << std::endl);
+    return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+  }
+
+  bool exprNotUnique = uniqueExprs.size() < exprVec.size();
+  if (exprNotUnique) {
+    SLP_GATHER_DEBUG(os << "expr not unique " << func.GetName() << std::endl);
+    return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+  }
+  bool stmtNotUnique = uniqueStmts.size() < exprVec.size();
+  if (stmtNotUnique) {
+    SLP_GATHER_DEBUG(os << "stmt not unique" << std::endl);
+    return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+  }
+
+  if (!TryScheduleTogehter(stmts)) {
+    SLP_GATHER_DEBUG(os << "Scheduling failure" << std::endl);
+    return tree->CreateTreeNodeByExprs(exprVec, parentNode, false);
+  }
+  SLP_DEBUG(os << "Scheduling OK, building tree node..." << std::endl);
+  auto *treeNode = tree->CreateTreeNodeByStmts(stmts, parentNode);
+
+  // We no longer split ivar nodes
+  if (realExprs[0]->IsLeaf() || realExprs[0]->GetMeOp() == kMeOpIvar) {
+    return treeNode;
+  }
+
+  size_t numOpnd = realExprs[0]->GetNumOpnds();
+  size_t numLane = exprVec.size();
+  size_t numChildrenNeededGather = 0;
+  for (size_t i = 0; i < numOpnd; ++i) {
+    std::vector<ExprWithDef*> opndVec;
+    for (size_t lane = 0; lane < numLane; ++lane) {
+      auto *opnd = realExprs[lane]->GetOpnd(i);
+      auto *opndWithDef = alloc.GetMemPool()->New<ExprWithDef>(opnd, currBB);
+      opndVec.push_back(opndWithDef);
+    }
+    auto *childTreeNode = BuildTreeRec(opndVec, depth + 1, treeNode);
+    if (childTreeNode->IsLeaf() && !childTreeNode->CanVectorized()) {
+      ++numChildrenNeededGather;
+    }
+  }
+  // Too many children needed gathering, we should remove them for better tree cost
+  if (numChildrenNeededGather > 1) {
+    treeNode->RemoveAllChildren();
+    treeNode->ChangeToNeedGatherNode();
+    for (size_t num = 0; num < numChildrenNeededGather; ++num) {
+      tree->PopTreeNode();   // remove node from treeNodeVec
+    }
+  }
+  return treeNode;
+}
+
+// posExprVec: pair.first means where to insert the value
+//             pair.second means what value to insert
+MeExpr *BuildExprAfterVectorSetElement(MeFunction &func, RegMeExpr *vecReg,
+    const std::vector<std::pair<uint32, MeExpr*>> &posExprVec, PrimType laneType) {
+  auto &irMap = *func.GetIRMap();
+  auto vecPrimType = vecReg->GetPrimType();
+  MeExpr *currVecExpr = vecReg;
+  for (size_t i = 0; i < posExprVec.size(); ++i) {
+    const auto &posExprPair = posExprVec[i];
+    uint32 pos = posExprPair.first;
+    MeExpr *valueExpr = posExprPair.second;
+    if (valueExpr->GetPrimType() != laneType) {
+      valueExpr = irMap.CreateMeExprTypeCvt(laneType, valueExpr->GetPrimType(), *valueExpr);
+    }
+    MIRIntrinsicID intrnId = GetVectorSetElementIntrnId(vecPrimType);
+    NaryMeExpr naryExpr(&irMap.GetIRMapAlloc(), kInvalidExprID, OP_intrinsicop,
+        vecPrimType, 3, TyIdx(0), intrnId, false);
+    naryExpr.PushOpnd(valueExpr);
+    naryExpr.PushOpnd(currVecExpr);
+    naryExpr.PushOpnd(irMap.CreateIntConstMeExpr(pos, PTY_i32));
+    currVecExpr = irMap.CreateNaryMeExpr(naryExpr);
+  }
+  return currVecExpr;
+}
+
+// Example:
+//   constants: [ 12, 35, 78, 89 ], elemSize: 8bit
+//   output: (bin) 01011001 01001110 00100011 00001100
+uint64 ConstructConstants(std::vector<int64> &constants, uint32 elemSize) {
+  uint64 res = 0;
+  uint32 shift = 0;
+  uint32 maskShift = 64 - elemSize;
+  uint64 mask = (static_cast<uint64>(-1) << maskShift) >> maskShift;
+  for (auto cst : constants) {
+    res += ((cst & mask) << shift);
+    shift += elemSize;
+  }
+  return res;
+}
+
+bool SLPVectorizer::DoVectTreeNodeConstval(TreeNode *treeNode) {
+  // We will support float point constval when allowed by cg handlefunc
+  if (!IsPrimitiveInteger(treeNode->GetType())) {
+    SLP_FAILURE_DEBUG(os << "float point vectorization has not been supported by cg handlefunc" << std::endl);
+    return false;
+  }
+  PrimType elemType = tree->GetType();
+  auto *vecType = GenMergedType(tree->GetType(), treeNode->GetLane());
+  CHECK_NULL_FATAL(vecType);
+  bool useScalarType = tree->CanTreeUseScalarTypeForConstvalIassign();
+  ScalarMeExpr *lhsReg = nullptr;
+  MeExpr *rhs = nullptr;
+  if (useScalarType) {
+    if (!mergeToVecType) {
+      auto firstConstVal = static_cast<ConstMeExpr*>(treeNode->GetExprs()[0])->GetIntValue();
+      if (!treeNode->SameExpr() || firstConstVal != 0) {
+        SLP_FAILURE_DEBUG(os << "all constVals must be 0 if mergeToScalarType considering big const performance" <<
+            std::endl);
+        return false;
+      }
+    }
+    vecType = GetScalarUnsignedTypeBySize(GetPrimTypeBitSize(vecType->GetPrimType()));
+    lhsReg = irMap.CreateRegMeExpr(*vecType);
+    std::vector<int64> constants(treeNode->GetExprs().size());
+    std::transform(treeNode->GetExprs().begin(), treeNode->GetExprs().end(), constants.begin(), [](MeExpr *expr) {
+      return static_cast<ConstMeExpr*>(expr)->GetExtIntValue();
+    });
+    uint64 mergeConstval = ConstructConstants(constants, GetPrimTypeBitSize(elemType));
+    rhs = irMap.CreateIntConstMeExpr(mergeConstval, vecType->GetPrimType());
+  } else if (treeNode->SameExpr()) {
+    if (!mergeToVecType) {
+      SLP_DEBUG(os << "vector_from_scalar is not supproted for scalar mergedType" << std::endl);
+      return false;
+    }
+    MIRIntrinsicID intrnId = GetVectorFromScalarIntrnId(vecType->GetPrimType());
+    MeExpr *constExpr = treeNode->GetExprs()[0];
+    if (constExpr->GetPrimType() != elemType) {
+      constExpr = irMap.CreateMeExprTypeCvt(elemType, constExpr->GetPrimType(), *constExpr);
+    }
+    lhsReg = irMap.CreateRegMeExpr(*vecType);
+    // Create vector intrinsicop
+    NaryMeExpr naryExpr(&irMap.GetIRMapAlloc(), kInvalidExprID, OP_intrinsicop,
+        vecType->GetPrimType(), 1, TyIdx(0), intrnId, false);
+    naryExpr.PushOpnd(constExpr);
+    rhs = irMap.CreateNaryMeExpr(naryExpr);
+  } else {
+    if (!mergeToVecType) {
+      SLP_DEBUG(os << "vector_set_element is not supproted for scalar mergedType" << std::endl);
+      return false;
+    }
+    auto *vecReg = irMap.CreateRegMeExpr(*vecType);
+    auto exprNum = treeNode->GetExprs().size();
+    std::vector<std::pair<uint32, MeExpr*>> posExprVec;
+    for (size_t i = 0; i < exprNum; ++i) {
+      posExprVec.emplace_back(i, treeNode->GetExprs()[i]);
+    }
+    rhs = BuildExprAfterVectorSetElement(func, vecReg, posExprVec, elemType);
+    lhsReg = irMap.CreateRegMeExpr(*vecType);
+  }
+  auto *constVecAssign = irMap.CreateAssignMeStmt(*lhsReg, *rhs, *currBB);
+  treeNode->PushOutStmt(constVecAssign);
+  if (debug) {
+    treeNode->DumpVecStmts(irMap);
+  }
+  return true;
+}
+
+void SetMuListForVectorIvar(IvarMeExpr &ivar, TreeNode *treeNode, IRMap &irMap) {
+  auto &order = treeNode->GetOrder();
+  ivar.GetMuList().resize(order.size(), nullptr);
+  for (size_t i = 0; i < order.size(); ++i) {
+    uint32 orderIdx = order[i];
+    auto *mu = static_cast<IvarMeExpr*>(treeNode->GetMemLocs()[i]->Emit())->GetUniqueMu();
+    ivar.SetMuItem(orderIdx, mu);
+  }
+}
+
+bool SLPVectorizer::DoVectTreeNodeIvar(TreeNode *treeNode) {
+  // Shuffle has not been supported for now
+  CHECK_FATAL(treeNode->GetOrder().size() == treeNode->GetLane(), "must be");
+  const auto &rootStoreOrder = tree->GetRoot()->GetOrder();
+  if (treeNode->GetOrder() != rootStoreOrder) {
+    SLP_FAILURE_DEBUG(os << "Shuffle has not been supported" << std::endl);
+    if (debug) {
+      os << "[Loads]\n";
+      treeNode->DumpOrder();
+      os << "[Stores]\n";
+      tree->GetRoot()->DumpOrder();
+    }
+    return false;
+  }
+  auto *vecType = GenMergedType(tree->GetType(), treeNode->GetLane());
+  CHECK_NULL_FATAL(vecType);
+  auto *minMem = treeNode->GetMinMemLoc();
+  auto *vecPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*vecType);
+  auto *addrExpr = minMem->Emit();
+  auto *ivarExpr = static_cast<IvarMeExpr*>(addrExpr);
+  auto *newBase = ivarExpr->GetBase();
+  if (minMem->extraOffset != 0) {
+    auto *extraOffsetExpr = irMap.CreateIntConstMeExpr(minMem->extraOffset, PTY_u64);
+    newBase = irMap.CreateMeExprBinary(OP_add, PTY_u64, *newBase, *extraOffsetExpr);
+  }
+  IvarMeExpr newIvar(&irMap.GetIRMapAlloc(), -1, vecType->GetPrimType(), TyIdx(PTY_u64), 0);
+  newIvar.SetTyIdx(vecPtrType->GetTypeIndex());
+  newIvar.SetPtyp(vecType->GetPrimType());
+  newIvar.SetBase(newBase);
+  SetMuListForVectorIvar(newIvar, treeNode, irMap);
+  addrExpr = irMap.HashMeExpr(newIvar);
+
+  CHECK_FATAL(addrExpr->GetMeOp() == kMeOpIvar, "only iread memLoc is supported for now");
+  auto *lhsReg = irMap.CreateRegMeExpr(*vecType);
+  auto *vecRegassign = irMap.CreateAssignMeStmt(*lhsReg, *addrExpr, *currBB);
+  vecRegassign->SetSrcPos(treeNode->GetStmts()[0]->GetSrcPosition());
+  treeNode->PushOutStmt(vecRegassign);
+  if (debug) {
+    treeNode->DumpVecStmts(irMap);
+  }
+  return true;
+}
+
+bool SLPVectorizer::DoVectTreeNodeBinary(TreeNode *treeNode) {
+  CHECK_FATAL(treeNode->GetChildren().size() == 2, "must be");
+  auto *vecType = GenMergedType(tree->GetType(), treeNode->GetLane());
+  CHECK_NULL_FATAL(vecType);
+  // Get the first vector operand
+  auto &childOutStmts0 = treeNode->GetChildren()[0]->GetOutStmts();
+  auto *defStmt0 = childOutStmts0.back();
+  MeExpr *opnd0 = defStmt0->GetLHS();
+  CHECK_NULL_FATAL(opnd0);
+  CHECK_FATAL(opnd0->GetPrimType() == vecType->GetPrimType(), "must be");
+
+  // Get the second vector operand
+  auto &childOutStmts1 = treeNode->GetChildren()[1]->GetOutStmts();
+  auto *defStmt1 = childOutStmts1.back();
+  MeExpr *opnd1 = defStmt1->GetLHS();
+  CHECK_NULL_FATAL(opnd1);
+  CHECK_FATAL(opnd1->GetPrimType() == vecType->GetPrimType(), "must be");
+
+  // Create binary expr and assign stmt
+  auto *binaryExpr = irMap.CreateMeExprBinary(treeNode->GetOp(), vecType->GetPrimType(), *opnd0, *opnd1);
+  auto *lhsReg = irMap.CreateRegMeExpr(*vecType);
+  auto *assign = irMap.CreateAssignMeStmt(*lhsReg, *binaryExpr, *currBB);
+  assign->SetSrcPos(treeNode->GetStmts()[0]->GetSrcPosition());
+  treeNode->PushOutStmt(assign);
+  if (debug) {
+    treeNode->DumpVecStmts(irMap);
+  }
+  return true;
+}
+
+void GetRevInfoFromScalarRevIntrnId(MIRIntrinsicID intrnId, uint32 &rangeBitSize, uint32 &elementBitSize) {
+  switch (intrnId) {
+    case INTRN_C_rev_4:
+      rangeBitSize = 32;
+      elementBitSize = 8;
+      break;
+    case INTRN_C_rev_8:
+      rangeBitSize = 64;
+      elementBitSize = 8;
+      break;
+    case INTRN_C_rev16_2:
+      rangeBitSize = 16;
+      elementBitSize = 8;
+      break;
+    default:
+      CHECK_FATAL(false, "NYI");
+      break;
+  }
+}
+
+bool SLPVectorizer::DoVectTreeNodeNary(TreeNode *treeNode) {
+  CHECK_FATAL(treeNode->GetOp() == OP_intrinsicop, "only support intrinsicop for now");
+  CHECK_FATAL(treeNode->GetChildren().size() == 1, "must be");
+  CHECK_FATAL(!treeNode->GetStmts().empty(), "treeNode need gather?");
+  auto *firstRealExpr = treeNode->GetStmts()[0]->GetRHS();
+  CHECK_FATAL(firstRealExpr->GetOp() == OP_intrinsicop, "must be");
+  auto intrnId = static_cast<NaryMeExpr*>(firstRealExpr)->GetIntrinsic();
+  if (std::find(supportedIntrns.begin(), supportedIntrns.end(), intrnId) == supportedIntrns.end()) {
+    SLP_FAILURE_DEBUG(os << "unsupported intrinsic" << std::endl);
+    return false;
+  }
+  switch (intrnId) {
+    case INTRN_C_rev_4:
+    case INTRN_C_rev_8:
+    case INTRN_C_rev16_2:
+      return DoVectTreeNodeNaryReverse(treeNode, intrnId);
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+  return false;
+}
+
+bool SLPVectorizer::DoVectTreeNodeNaryReverse(TreeNode *treeNode, MIRIntrinsicID intrnId) {
+  uint32 rangeBitSize = 0;
+  uint32 elementBitSize = 0;
+  GetRevInfoFromScalarRevIntrnId(intrnId, rangeBitSize, elementBitSize);
+  uint32 opndBitSize = GetPrimTypeBitSize(treeNode->GetType());
+  uint32 vecOpndBitSize = opndBitSize * treeNode->GetLane();
+  if (vecOpndBitSize != 64 && vecOpndBitSize != 128) {
+    SLP_FAILURE_DEBUG(
+        os << "only v64 and v128 are allowed as vector reverse operand, but get " << vecOpndBitSize << std::endl);
+    return false;
+  }
+  auto *vecType = GenMergedType(tree->GetType(), treeNode->GetLane());
+  CHECK_NULL_FATAL(vecType);
+  uint32 newNumLane = vecOpndBitSize / elementBitSize;
+  auto isSign = !PrimitiveType(treeNode->GetType()).IsUnsigned();
+  auto newElementType = GetIntegerPrimTypeBySizeAndSign(elementBitSize, isSign);
+  auto revVecType = GenMergedType(newElementType, newNumLane);
+  MIRIntrinsicID vecIntrnId;
+  switch (rangeBitSize) {
+    case 16:
+      vecIntrnId = GetVectorReverse16IntrnId(revVecType->GetPrimType());
+      break;
+    case 32:
+      vecIntrnId = GetVectorReverse32IntrnId(revVecType->GetPrimType());
+      break;
+    case 64:
+      vecIntrnId = GetVectorReverse64IntrnId(revVecType->GetPrimType());
+      break;
+    default:
+      CHECK_FATAL(false, "should not be here");
+      break;
+  }
+  NaryMeExpr naryExpr(&irMap.GetIRMapAlloc(), kInvalidExprID, treeNode->GetOp(),
+      vecType->GetPrimType(), 1, TyIdx(0), vecIntrnId, false);
+  for (auto *child : treeNode->GetChildren()) {
+    auto *defStmt = child->GetOutStmts().back();
+    auto *opnd = defStmt->GetLHS();
+    CHECK_NULL_FATAL(opnd);
+    naryExpr.PushOpnd(opnd);
+  }
+  auto *vecExpr = irMap.HashMeExpr(naryExpr);
+  auto *lhsReg = irMap.CreateRegMeExpr(*vecType);
+  auto *assign = irMap.CreateAssignMeStmt(*lhsReg, *vecExpr, *currBB);
+  assign->SetSrcPos(treeNode->GetStmts()[0]->GetSrcPosition());
+  treeNode->PushOutStmt(assign);
+  if (debug) {
+    treeNode->DumpVecStmts(irMap);
+  }
+  return true;
+}
+
+bool SLPVectorizer::DoVectTreeNodeIassign(TreeNode *treeNode) {
+  CHECK_FATAL(treeNode->GetChildren().size() == 1, "must be");
+  auto *minMem = treeNode->GetMinMemLoc();
+  CHECK_NULL_FATAL(minMem);
+  // Use root node type for covering the following case:
+  //   [(mx943), 4] : u8 = constval : u32
+  auto *vecType = GenMergedType(tree->GetType(), treeNode->GetLane());
+  CHECK_NULL_FATAL(vecType);
+  if (tree->CanTreeUseScalarTypeForConstvalIassign()) {
+    vecType = GetScalarUnsignedTypeBySize(GetPrimTypeBitSize(vecType->GetPrimType()));
+  }
+  auto *vecPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*vecType);
+  MeExpr *addrExpr = minMem->Emit();
+  if (treeNode->GetOp() == OP_dassign) {
+    auto &varMeExpr = static_cast<VarMeExpr&>(*addrExpr);
+    AddrofMeExpr addrofExpr(-1, PTY_ptr, varMeExpr.GetOst());
+    auto *newBase = irMap.HashMeExpr(addrofExpr);
+    IvarMeExpr newIvar(&irMap.GetIRMapAlloc(), -1, vecType->GetPrimType(), TyIdx(PTY_u64), 0);
+    newIvar.SetTyIdx(vecPtrType->GetTypeIndex());
+    newIvar.SetPtyp(vecType->GetPrimType());
+    newIvar.SetBase(newBase);
+    addrExpr = irMap.HashMeExpr(newIvar);
+  } else {
+    auto *ivarExpr = static_cast<IvarMeExpr*>(addrExpr);
+    if (ivarExpr->GetFieldID() == 0) {
+      IvarMeExpr newIvar(*ivarExpr);
+      newIvar.SetTyIdx(vecPtrType->GetTypeIndex());
+      newIvar.SetPtyp(vecType->GetPrimType());
+      addrExpr = irMap.HashMeExpr(newIvar);
+    } else {  // fieldId != 0
+      auto *newBase = ivarExpr->GetBase();
+      if (minMem->extraOffset != 0) {
+        auto *extraOffsetExpr = irMap.CreateIntConstMeExpr(minMem->extraOffset, PTY_u64);
+        newBase = irMap.CreateMeExprBinary(OP_add, PTY_u64,
+            *newBase, *extraOffsetExpr);
+      }
+      IvarMeExpr newIvar(&irMap.GetIRMapAlloc(), -1, vecType->GetPrimType(), TyIdx(PTY_u64), 0);
+      newIvar.SetTyIdx(vecPtrType->GetTypeIndex());
+      newIvar.SetPtyp(vecType->GetPrimType());
+      newIvar.SetBase(newBase);
+      addrExpr = irMap.HashMeExpr(newIvar);
+    }
+  }
+  // lhs ivar don't need mu
+  auto *childStmt = treeNode->GetChildren()[0]->GetOutStmts().back();
+  MeExpr *rhs = childStmt->GetLHS();
+  auto *chiList = static_cast<IassignMeStmt*>(treeNode->GetStmts()[0])->GetChiList();
+  auto *vecIassign = irMap.CreateIassignMeStmt(vecPtrType->GetTypeIndex(),
+      static_cast<IvarMeExpr&>(*addrExpr), *rhs, *chiList);
+  vecIassign->SetSrcPos(treeNode->GetStmts()[0]->GetSrcPosition());
+
+  // Merge chiList
+  std::vector<MapleMap<OStIdx, ChiMeNode*>*> chiListVec;
+  std::vector<MeStmt*> sortedStmts;
+  for (auto *stmt : treeNode->GetStmts()) {
+    sortedStmts.push_back(stmt);
+  }
+  std::sort(sortedStmts.begin(), sortedStmts.end(), [](MeStmt *a, MeStmt *b) {
+    return GetOrderId(a) < GetOrderId(b);
+  });
+  for (auto *stmt : sortedStmts) {  // must iterate stmt by orderId
+    auto *cl = stmt->GetChiList();
+    CHECK_NULL_FATAL(cl);
+    chiListVec.push_back(cl);
+  }
+  auto *mergedChiList = MergeChiList(chiListVec, irMap, *vecIassign);
+  vecIassign->SetChiList(*mergedChiList);
+
+  treeNode->PushOutStmt(vecIassign);
+  if (debug) {
+    treeNode->DumpVecStmts(irMap);
+  }
+  return true;
+}
+
+bool SLPVectorizer::DoVectTreeNodeGatherNeeded(TreeNode *treeNode) {
+  if (!mergeToVecType) {
+    SLP_DEBUG(os << "vector_set_element/vector_from_scalar is not supproted for scalar mergedType" << std::endl);
+    return false;
+  }
+  auto elemType = tree->GetType();
+  auto *vecType = GenMergedType(elemType, treeNode->GetLane());
+  CHECK_NULL_FATAL(vecType);
+  auto *vecReg = irMap.CreateRegMeExpr(*vecType);
+  auto exprNum = treeNode->GetExprs().size();
+  std::vector<std::pair<uint32, MeExpr*>> posExprVec;
+  for (size_t i = 0; i < exprNum; ++i) {
+    MeExpr *valueExpr = treeNode->GetExprs()[i];
+    posExprVec.emplace_back(i, valueExpr);
+  }
+  MeExpr *vecRegNew = nullptr;
+  if (treeNode->SameExpr()) {
+    MIRIntrinsicID intrnId = GetVectorFromScalarIntrnId(vecType->GetPrimType());
+    // Create vector intrinsicop
+    NaryMeExpr naryExpr(&irMap.GetIRMapAlloc(), kInvalidExprID, OP_intrinsicop,
+        vecType->GetPrimType(), 1, TyIdx(0), intrnId, false);
+    naryExpr.PushOpnd(treeNode->GetExprs()[0]);
+    vecRegNew = irMap.CreateNaryMeExpr(naryExpr);
+  } else {
+    vecRegNew = BuildExprAfterVectorSetElement(func, vecReg, posExprVec, elemType);
+  }
+  auto *lhsReg = irMap.CreateRegMeExpr(*vecType);
+  auto *vecAssign = irMap.CreateAssignMeStmt(*lhsReg, *vecRegNew, *currBB);
+  treeNode->PushOutStmt(vecAssign);
+  CHECK_FATAL(treeNode->GetChildren().empty(), "NOT VEC treeNode should not have children");
+  if (debug) {
+    treeNode->DumpVecStmts(irMap);
+  }
+  return true;
+}
+
+bool SLPVectorizer::VectorizeTreeNode(TreeNode *treeNode) {
+  for (auto *child : treeNode->GetChildren()) {
+    if (!VectorizeTreeNode(child)) {
+      SLP_DEBUG(os << "VectorizeTreeNode failed: tree node " << child->GetId() << ", " <<
+          GetOpName(child->GetOp()) << std::endl);
+      return false;
+    }
+  }
+  SLP_DEBUG(os << "Start to vectorize tree node " << treeNode->GetId() << " (" <<
+      GetOpName(treeNode->GetOp()) << ")" << std::endl);
+
+  // Tree node can not be vectorized, we use vector_set_element
+  if (!treeNode->CanVectorized()) {
+    return DoVectTreeNodeGatherNeeded(treeNode);
+  }
+
+  switch (treeNode->GetOp()) {
+    case OP_iread:
+    case OP_ireadoff: {
+      return DoVectTreeNodeIvar(treeNode);
+    }
+    case OP_bxor:
+    case OP_band:
+    case OP_ashr:
+    case OP_add:
+    case OP_mul:
+    case OP_sub: {
+      return DoVectTreeNodeBinary(treeNode);
+    }
+    case OP_intrinsicop: {
+      return DoVectTreeNodeNary(treeNode);
+    }
+    case OP_constval: {
+      return DoVectTreeNodeConstval(treeNode);
+    }
+    case OP_dassign:
+    case OP_iassign: {
+      bool ret = DoVectTreeNodeIassign(treeNode);
+      if (ret && treeNode->GetOp() == OP_dassign) {
+        auto &dassignStmts = treeNode->GetStmts();
+        auto *vecIassign = treeNode->GetOutStmts().back();
+        CHECK_FATAL(vecIassign->GetOp() == OP_iassign, "must be");
+        MovDefsFromDassignsToVecIassign(dassignStmts, static_cast<IassignMeStmt&>(*vecIassign), irMap);
+      }
+      return ret;
+    }
+    default: {
+      SLP_FAILURE_DEBUG(os << "unsupported op: " << GetOpName(treeNode->GetOp()) << std::endl);
+      return false;
+    }
+  }
+  return false;
+}
+
+bool SLPVectorizer::VectorizeSLPTree() {
+  if (tree->GetSize() <= 1) {
+    return false;
+  }
+  SLP_DEBUG(os << "Start to vectorize slp tree" << std::endl);
+  auto cost = tree->GetCost();
+  if (cost > 0) {
+    SLP_FAILURE_DEBUG(os << "tree cost: " << cost << std::endl);
+    return false;
+  }
+  bool res = VectorizeTreeNode(tree->GetRoot());
+  if (!res) {
+    SLP_DEBUG(os << "Vectorize tree failure" << std::endl);
+    return false;
+  }
+  SLP_DEBUG(os << "Vectorize tree successfully" << std::endl);
+  SLP_OK_DEBUG(os << "tree size: " << tree->GetSize() << ", tree cost: " << cost << ", func: " << func.GetName() <<
+      ", bbId: " << currBB->GetBBId() << ", loc: 0" << std::endl);
+  return true;
+}
+
+MIRType *SLPVectorizer::GenMergedType(PrimType primType, uint8 lanes) const {
+  if (mergeToVecType) {
+    return GenVecType(primType, lanes);
+  }
+  uint32 totalByteBitSize = GetPrimTypeBitSize(primType) * lanes;
+  CHECK_FATAL(totalByteBitSize >= 16, "must be");
+  return GetScalarUnsignedTypeBySize(totalByteBitSize);
+}
+
+void SLPVectorizer::SetStmtVectorized(MeStmt &stmt) {
+  vectorizedStmts.insert(&stmt);
+}
+
+bool SLPVectorizer::IsStmtVectorized(MeStmt &stmt) const {
+  // Most of the time the container is empty, so don't worry too much about performance
+  return vectorizedStmts.find(&stmt) != vectorizedStmts.end();
+}
+
+void SLPVectorizer::MarkStmtsVectorizedInTree() {
+  for (auto *treeNode : tree->GetNodes()) {
+    auto &stmts = treeNode->GetStmts();
+    for (auto *stmt : stmts) {
+      if (stmt == nullptr) {
+        continue;
+      }
+      SetStmtVectorized(*stmt);
+    }
+  }
+}
+
+void MESLPVectorizer::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MESLPVectorizer::PhaseRun(MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  MemPool *memPool = GetPhaseMemPool();
+  bool debug = DEBUGFUNC_NEWPM(f);
+  SLPVectorizer slpVectorizer(*memPool, f, *dom, debug);
+  slpVectorizer.Run();
+  return false;
+}
+}  // namespace maple
+
diff --git a/src/mapleall/maple_me/src/me_ssa.cpp b/src/mapleall/maple_me/src/me_ssa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..515eb0654ca5a80a0baac33e91bf1844c878aaed
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ssa.cpp
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ssa.h"
+#include <iostream>
+#include "bb.h"
+#include "me_option.h"
+#include "ssa_mir_nodes.h"
+#include "ver_symbol.h"
+#include "dominance.h"
+#include "me_function.h"
+#include "mir_builder.h"
+#include "me_ssa_tab.h"
+#include "me_phase_manager.h"
+
+// This phase builds the SSA form of a function. Before this we have got the dominator tree
+// and each bb's dominance frontiers. Then the algorithm follows this outline:
+//
+// Step 1: Inserting phi-node.
+// With dominance frontiers, we can determine more
+// precisely where phi-node might be needed. The basic idea is simple.
+// A definition of x in block b forces a phi-node at every node in b's
+// dominance frontiers. Since that phi-node is a new definition of x,
+// it may, in turn, force the insertion of additional phi-node.
+//
+// Step 2: Renaming.
+// Renames both definitions and uses of each symbol in
+// a preorder walk over the dominator tree. In each block, we first
+// rename the values defined by phi-node at the head of the block, then
+// visit each stmt in the block: we rewrite each uses of a symbol with current
+// SSA names(top of the stack which holds the current SSA version of the corresponding symbol),
+// then it creates a new SSA name for the result of the stmt.
+// This latter act makes the new name current. After all the stmts in the
+// block have been rewritten, we rewrite the appropriate phi-node's
+// parameters in each cfg successor of the block, using the current SSA names.
+// Finally, it recurs on any children of the block in the dominator tree. When it
+// returns from those recursive calls, we restores the stack of current SSA names to
+// the state that existed before the current block was visited.
+namespace maple {
+void MeSSA::VerifySSAOpnd(const BaseNode &node) const {
+  Opcode op = node.GetOpCode();
+  size_t vtableSize = func->GetMeSSATab()->GetVersionStTable().GetVersionStVectorSize();
+  if (op == OP_dread || op == OP_addrof) {
+    const auto &addrOfSSANode = static_cast<const AddrofSSANode&>(node);
+    const VersionSt *verSt = addrOfSSANode.GetSSAVar();
+    CHECK_FATAL(verSt->GetIndex() < vtableSize, "runtime check error");
+    return;
+  }
+  if (op == OP_regread) {
+    const auto &regNode = static_cast<const RegreadSSANode&>(node);
+    const VersionSt *verSt = regNode.GetSSAVar();
+    CHECK_FATAL(verSt->GetIndex() < vtableSize, "runtime check error");
+    return;
+  }
+
+  for (size_t i = 0; i < node.NumOpnds(); ++i) {
+    VerifySSAOpnd(*node.Opnd(i));
+  }
+}
+
+void MeSSA::VerifySSA() const {
+  size_t vtableSize = func->GetMeSSATab()->GetVersionStTable().GetVersionStVectorSize();
+  auto cfg = func->GetCfg();
+  // to prevent valid_end from being called repeatedly, don't modify the definition of eIt
+  for (auto bIt = cfg->valid_begin(), eIt = cfg->valid_end(); bIt != eIt; ++bIt) {
+    auto *bb = *bIt;
+    Opcode opcode;
+    for (auto &stmt : bb->GetStmtNodes()) {
+      opcode = stmt.GetOpCode();
+      if (opcode == OP_dassign || opcode == OP_regassign) {
+        VersionSt *verSt = func->GetMeSSATab()->GetStmtsSSAPart().GetAssignedVarOf(stmt);
+        CHECK_FATAL(verSt != nullptr && verSt->GetIndex() < vtableSize, "runtime check error");
+      }
+      for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+        VerifySSAOpnd(*stmt.Opnd(i));
+      }
+    }
+  }
+}
+
+void MeSSA::InsertIdentifyAssignments(IdentifyLoops *identloops) {
+  MIRBuilder *mirbuilder = func->GetMIRModule().GetMIRBuilder();
+  PreMeFunction *preMeFunc = func->GetPreMeFunc();
+  SSATab *ssatab = func->GetMeSSATab();
+
+  for (LoopDesc *aloop : identloops->GetMeLoops()) {
+    BB *headbb = aloop->head;
+    // check if the label has associated PreMeWhileInfo
+    if (headbb->GetBBLabel() == 0) {
+      continue;
+    }
+    if (aloop->exitBB == nullptr) {
+      continue;
+    }
+    auto it = preMeFunc->label2WhileInfo.find(headbb->GetBBLabel());
+    if (it == preMeFunc->label2WhileInfo.end()) {
+      continue;
+    }
+    if (headbb->GetPred().size() != 2) {
+      continue;
+    }
+    // collect the symbols for inserting identity assignments
+    std::set<OriginalSt *, OriginalSt::OriginalStPtrComparator> ostSet;
+    for (auto &mapEntry: std::as_const(headbb->GetPhiList())) {
+      OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(mapEntry.first);
+      CHECK_FATAL(ost, "ost is nullptr");
+      if (ost->IsIVCandidate()) {
+        ostSet.insert(ost);
+      }
+    }
+    if (ostSet.empty()) {
+      continue;
+    }
+    // for the exitBB, insert identify assignment for any var that has phi at
+    // headbb
+    for (OriginalSt *ost : ostSet) {
+      MIRType *mirtype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx());
+      if (ost->IsSymbolOst()) {
+        AddrofNode *dread = func->GetMirFunc()->GetCodeMempool()->New<AddrofNode>(OP_dread,
+            mirtype->GetPrimType(), ost->GetMIRSymbol()->GetStIdx(), ost->GetFieldID());
+        AddrofSSANode *ssadread = func->GetMirFunc()->GetCodeMempool()->New<AddrofSSANode>(*dread);
+        ssadread->SetSSAVar(*ssatab->GetVersionStTable().GetZeroVersionSt(ost));
+
+        DassignNode *dass = mirbuilder->CreateStmtDassign(*ost->GetMIRSymbol(), ost->GetFieldID(), ssadread);
+        aloop->exitBB->PrependStmtNode(dass);
+
+        MayDefPartWithVersionSt *thessapart = ssatab->GetStmtsSSAPart().GetSSAPartMp()->New<MayDefPartWithVersionSt>(
+            &ssatab->GetStmtsSSAPart().GetSSAPartAlloc());
+        ssatab->GetStmtsSSAPart().SetSSAPartOf(*dass, thessapart);
+        thessapart->SetSSAVar(*ssatab->GetVersionStTable().GetZeroVersionSt(ost));
+      } else {
+        RegreadNode *regread = func->GetMirFunc()->GetCodeMempool()->New<RegreadNode>(ost->GetPregIdx());
+        MIRPreg *preg = func->GetMirFunc()->GetPregTab()->PregFromPregIdx(ost->GetPregIdx());
+        regread->SetPrimType(preg->GetPrimType());
+        RegreadSSANode *ssaregread = func->GetMirFunc()->GetCodeMempool()->New<RegreadSSANode>(*regread);
+        ssaregread->SetSSAVar(*ssatab->GetVersionStTable().GetZeroVersionSt(ost));
+
+        RegassignNode *rass = mirbuilder->CreateStmtRegassign(mirtype->GetPrimType(), ost->GetPregIdx(), ssaregread);
+        aloop->exitBB->PrependStmtNode(rass);
+
+        VersionSt *vst = ssatab->GetVersionStTable().GetZeroVersionSt(ost);
+        ssatab->GetStmtsSSAPart().SetSSAPartOf(*rass, vst);
+      }
+      ssatab->AddDefBB4Ost(ost->GetIndex(), aloop->exitBB->GetBBId());
+    }
+    if (eDebug) {
+      LogInfo::MapleLogger() << "****** Identity assignments inserted at loop exit BB "
+                             << aloop->exitBB->GetBBId() << "\n";
+    }
+  }
+}
+
+void MESSA::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MESSATab>();
+  aDep.SetPreservedAll();
+}
+
+bool MESSA::PhaseRun(maple::MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  CHECK_FATAL(dom != nullptr, "dominance phase has problem");
+  auto *ssaTab = GET_ANALYSIS(MESSATab, f);
+  CHECK_FATAL(ssaTab != nullptr, "ssaTab phase has problem");
+  ssa = GetPhaseAllocator()->New<MeSSA>(f, ssaTab, *dom, *GetPhaseMemPool(), DEBUGFUNC_NEWPM(f));
+  auto cfg = f.GetCfg();
+  ssa->InsertPhiNode();
+  if (f.IsLfo()) {
+    IdentifyLoops *identloops = FORCE_GET(MELoopAnalysis);
+    CHECK_FATAL(identloops != nullptr, "identloops has problem");
+    ssa->InsertIdentifyAssignments(identloops);
+  }
+  ssa->RenameAllBBs(cfg);
+  ssa->VerifySSA();
+  if (DEBUGFUNC_NEWPM(f)) {
+    ssaTab->GetVersionStTable().Dump(&ssaTab->GetModule());
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    f.DumpFunction();
+  }
+  f.SetMeFuncState(kSSAMemory);
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_ssa_devirtual.cpp b/src/mapleall/maple_me/src/me_ssa_devirtual.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0633115d4c20b270b3bb67659f440d6f908dfd8e
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ssa_devirtual.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ssa_devirtual.h"
+#include "me_function.h"
+#include "me_option.h"
+#include "me_ssa_tab.h"
+#include "me_loop_analysis.h"
+#include "me_phase_manager.h"
+#include "maple_phase.h"
+#include "me_dominance.h"
+#include "me_irmap_build.h"
+
+namespace maple {
+bool MESSADevirtual::PhaseRun(MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  ASSERT(dom != nullptr, "dominance phase has problem");
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  ASSERT(irMap != nullptr, "hssaMap has problem");
+  MaplePhase *it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MKlassHierarchy, MIRModule>(f.GetMIRModule());
+  auto *kh = static_cast<M2MKlassHierarchy *>(it)->GetResult();
+
+  ASSERT(kh != nullptr, "KlassHierarchy has problem");
+  bool skipReturnTypeOpt = false;
+  // If not in ipa and ignoreInferredRetType is enabled, ssadevirt will ignore inferred return type of any function
+  if (!f.GetMIRModule().IsInIPA() && MeOption::ignoreInferredRetType) {
+    skipReturnTypeOpt = true;
+  }
+  MeSSADevirtual meSSADevirtual(*GetPhaseMemPool(), f.GetMIRModule(), f, *irMap, *kh, *dom, skipReturnTypeOpt);
+  if (Options::O2) {
+    it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MClone, MIRModule>(f.GetMIRModule());
+    Clone *clone = static_cast<M2MClone*>(it)->GetResult();
+    if (clone != nullptr) {
+      meSSADevirtual.SetClone(*clone);
+    }
+  }
+
+  if (DEBUGFUNC_NEWPM(f)) {
+    SSADevirtual::debug = true;
+  }
+  meSSADevirtual.Perform(*f.GetCfg()->GetCommonEntryBB());
+  if (DEBUGFUNC_NEWPM(f)) {
+    SSADevirtual::debug = false;
+    LogInfo::MapleLogger() << "\n============== After SSA Devirtualization  =============" << "\n";
+    f.Dump(false);
+  }
+  return true;
+}
+
+void MESSADevirtual::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_ssa_epre.cpp b/src/mapleall/maple_me/src/me_ssa_epre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f2019b28a06c8a362bd206ad0595f44270d99d71
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ssa_epre.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ssa_epre.h"
+#include "me_dominance.h"
+#include "me_ssa_update.h"
+#include "me_phase_manager.h"
+#include "me_placement_rc.h"
+#include "me_loop_analysis.h"
+#include "me_hdse.h"
+#include "me_stack_protect.h"
+
+namespace {
+const std::set<std::string> propWhiteList {
+#define PROPILOAD(funcName) #funcName,
+#include "propiloadlist.def"
+#undef PROPILOAD
+};
+}
+
+// accumulate the BBs that are in the iterated dominance frontiers of bb in
+// the set dfSet, visiting each BB only once
+namespace maple {
+void MeSSAEPre::BuildWorkList() {
+  auto cfg = func->GetCfg();
+  const auto &preOrderDt = dom->GetDtPreOrder();
+  for (auto &bbID : preOrderDt) {
+    BB *bb = cfg->GetAllBBs().at(bbID);
+    BuildWorkListBB(bb);
+  }
+}
+
+bool MeSSAEPre::IsThreadObjField(const IvarMeExpr &expr) const {
+  if (klassHierarchy == nullptr) {
+    return false;
+  }
+  if (expr.GetFieldID() == 0) {
+    return false;
+  }
+  auto *type = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(expr.GetTyIdx()));
+  TyIdx runnableInterface = klassHierarchy->GetKlassFromLiteral("Ljava_2Flang_2FRunnable_3B")->GetTypeIdx();
+  Klass *klass = klassHierarchy->GetKlassFromTyIdx(type->GetPointedTyIdx());
+  if (klass == nullptr) {
+    return false;
+  }
+  for (Klass *inter : klass->GetImplInterfaces()) {
+    if (inter->GetTypeIdx() == runnableInterface) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MESSAEPre::PhaseRun(maple::MeFunction &f) {
+  static uint32 puCount = 0;  // count PU to support the eprePULimit option
+  if (puCount > MeOption::eprePULimit) {
+    ++puCount;
+    return false;
+  }
+  // make irmapbuild first because previous phase may invalid all analysis results
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  ASSERT(irMap != nullptr, "irMap phase has problem");
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  ASSERT(dom != nullptr, "dominance construction has problem");
+  auto pdom = dominancePhase->GetPdomResult();
+  ASSERT(pdom != nullptr, "postdominance construction has problem");
+
+  // checking the need for stack protection
+  if (Options::stackProtectorStrong) {
+    MeStackProtect checker(f);
+    checker.CheckAddrofStack();
+  }
+
+  KlassHierarchy *kh = nullptr;
+  if (f.GetMIRModule().IsJavaModule()) {
+    MaplePhase *it = GetAnalysisInfoHook()->GetTopLevelAnalyisData<M2MKlassHierarchy, MIRModule>(f.GetMIRModule());
+    kh = static_cast<M2MKlassHierarchy*>(it)->GetResult();
+    CHECK_FATAL(kh != nullptr, "KlassHierarchy phase has problem");
+  }
+
+  IdentifyLoops *identLoops = GET_ANALYSIS(MELoopAnalysis, f);
+  CHECK_NULL_FATAL(identLoops);
+
+  bool eprePULimitSpecified = MeOption::eprePULimit != UINT32_MAX;
+  uint32 epreLimitUsed =
+      (eprePULimitSpecified && puCount != MeOption::eprePULimit) ? UINT32_MAX : MeOption::epreLimit;
+  MemPool *ssaPreMemPool = ApplyTempMemPool();
+  bool epreIncludeRef = MeOption::epreIncludeRef;
+  if (!MeOption::gcOnly && propWhiteList.find(f.GetName()) != propWhiteList.end()) {
+    epreIncludeRef = false;
+  }
+  MeSSAEPre ssaPre(f, *irMap, *dom, *pdom, kh, *ssaPreMemPool, *ApplyTempMemPool(), epreLimitUsed, epreIncludeRef,
+                   MeOption::epreLocalRefVar, MeOption::epreLHSIvar);
+  ssaPre.SetSpillAtCatch(MeOption::spillAtCatch);
+  if (MeOption::strengthReduction && !f.GetMIRModule().IsJavaModule()) {
+    ssaPre.strengthReduction = true;
+    if (MeOption::doLFTR) {
+      ssaPre.doLFTR = true;
+    }
+  }
+  if (f.GetHints() & kPlacementRCed) {
+    ssaPre.SetPlacementRC(true);
+  }
+  if (eprePULimitSpecified && puCount == MeOption::eprePULimit && epreLimitUsed != UINT32_MAX) {
+    LogInfo::MapleLogger() << "applying EPRE limit " << epreLimitUsed << " in function " <<
+        f.GetMirFunc()->GetName() << "\n";
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    ssaPre.SetSSAPreDebug(true);
+  }
+  ssaPre.ApplySSAPRE();
+  if (!ssaPre.GetCandsForSSAUpdate().empty()) {
+    MeSSAUpdate ssaUpdate(f, *f.GetMeSSATab(), *dom, ssaPre.GetCandsForSSAUpdate());
+    ssaUpdate.Run();
+  }
+  if ((f.GetHints() & kPlacementRCed) && ssaPre.GetAddedNewLocalRefVars()) {
+    PlacementRC placeRC(f, *dom, *pdom, *ssaPreMemPool, DEBUGFUNC_NEWPM(f));
+    placeRC.preKind = MeSSUPre::kSecondDecrefPre;
+    placeRC.ApplySSUPre();
+  }
+  if (ssaPre.strengthReduction && !MeOption::ivopts) { // for deleting redundant injury repairs
+    auto *aliasClass = FORCE_GET(MEAliasClass);
+    MeHDSE hdse(f, *dom, *pdom, *f.GetIRMap(), aliasClass, DEBUGFUNC_NEWPM(f));
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "  == " << PhaseName() << " invokes [ " << hdse.PhaseName() << " ] ==\n";
+    }
+    hdse.hdseKeepRef = MeOption::dseKeepRef;
+    hdse.DoHDSE();
+    if (hdse.NeedUNClean()) {
+      f.GetCfg()->UnreachCodeAnalysis(true);
+    }
+  }
+  ++puCount;
+  return true;
+}
+
+void MESSAEPre::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MELoopCanon>();
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_ssa_lpre.cpp b/src/mapleall/maple_me/src/me_ssa_lpre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0170974cf4329a6467de1ef3ed166c4eb66e4ab3
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ssa_lpre.cpp
@@ -0,0 +1,555 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ssa_lpre.h"
+#include "mir_builder.h"
+#include "me_lower_globals.h"
+#include "me_ssa_update.h"
+#include "me_dominance.h"
+#include "me_irmap_build.h"
+
+namespace maple {
+void MeSSALPre::GenerateSaveRealOcc(MeRealOcc &realOcc) {
+  ASSERT(GetPUIdx() == workCand->GetPUIdx() || workCand->GetPUIdx() == 0,
+         "GenerateSaveRealOcc: inconsistent puIdx");
+  ScalarMeExpr *regOrVar = CreateNewCurTemp(*realOcc.GetMeExpr());
+  CHECK_NULL_FATAL(regOrVar);
+  if (!realOcc.IsLHS()) {
+    // create a new meStmt before realOcc->GetMeStmt()
+    MeStmt *newMeStmt = irMap->CreateAssignMeStmt(*regOrVar, *realOcc.GetMeExpr(), *realOcc.GetMeStmt()->GetBB());
+    regOrVar->SetDefByStmt(*newMeStmt);
+    newMeStmt->CopyInfo(*realOcc.GetMeStmt());
+    realOcc.GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc.GetMeStmt(), newMeStmt);
+    EnterCandsForSSAUpdate(regOrVar->GetOstIdx(), *realOcc.GetMeStmt()->GetBB());
+    // replace realOcc->GetMeStmt()'s occ with regOrVar
+    (void)irMap->ReplaceMeExprStmt(*realOcc.GetMeStmt(), *realOcc.GetMeExpr(), *regOrVar);
+  } else if (realOcc.IsFormalAtEntry()) {
+    // no need generate any code, but change formal declaration to preg
+    CHECK_FATAL(regOrVar->GetMeOp() == kMeOpReg, "formals not promoted to register");
+    auto *varMeExpr = static_cast<VarMeExpr*>(realOcc.GetMeExpr());
+    const MIRSymbol *oldFormalSt = varMeExpr->GetOst()->GetMIRSymbol();
+    auto *regFormal = static_cast<RegMeExpr*>(regOrVar);
+    MIRSymbol *newFormalSt = mirModule->GetMIRBuilder()->CreatePregFormalSymbol(oldFormalSt->GetTyIdx(),
+                                                                                regFormal->GetRegIdx(),
+                                                                                *func->GetMirFunc());
+    size_t i = 0;
+    for (; i < func->GetMirFunc()->GetFormalCount(); ++i) {
+      if (func->GetMirFunc()->GetFormalDefVec()[i].formalSym == oldFormalSt) {
+        func->GetMirFunc()->GetFormalDefVec()[i].formalSym = newFormalSt;
+        break;
+      }
+    }
+    CHECK_FATAL(i < func->GetMirFunc()->GetFormalCount(), "Cannot replace promoted formal");
+  } else if (realOcc.GetOpcodeOfMeStmt() == OP_dassign || realOcc.GetOpcodeOfMeStmt() == OP_maydassign) {
+    VarMeExpr *theLHS = static_cast<VarMeExpr*>(realOcc.GetMeStmt()->GetVarLHS());
+    MeExpr *savedRHS = realOcc.GetMeStmt()->GetRHS();
+    CHECK_NULL_FATAL(theLHS);
+    CHECK_NULL_FATAL(savedRHS);
+    CHECK_NULL_FATAL(realOcc.GetMeStmt()->GetChiList());
+
+    SrcPosition savedSrcPos = realOcc.GetMeStmt()->GetSrcPosition();
+    BB *savedBB = realOcc.GetMeStmt()->GetBB();
+    MeStmt *savedPrev = realOcc.GetMeStmt()->GetPrev();
+    MeStmt *savedNext = realOcc.GetMeStmt()->GetNext();
+
+    // create new dassign for original lhs
+    MeStmt *newDassign = irMap->CreateAssignMeStmt(*theLHS, *regOrVar, *savedBB);
+    auto *oldChiList = realOcc.GetMeStmt()->GetChiList();
+    newDassign->GetChiList()->insert(oldChiList->cbegin(), oldChiList->cend());
+    for (auto &ostIdx2ChiNode : std::as_const(*newDassign->GetChiList())) {
+      auto *chiNode = ostIdx2ChiNode.second;
+      chiNode->SetBase(newDassign);
+    }
+    oldChiList->clear();
+
+    // judge if lhs has smaller size than rhs, if so, we need solve truncation.
+    savedRHS = GetTruncExpr(*theLHS, *savedRHS);
+
+    // change original dassign/maydassign to regassign;
+    // use placement new to modify in place, because other occ nodes are pointing
+    // to this statement in order to get to the rhs expression;
+    // this assume AssignMeStmt has smaller size then DassignMeStmt and
+    // MaydassignMeStmt
+    auto *rass =
+        new (realOcc.GetMeStmt()) AssignMeStmt(OP_regassign, static_cast<RegMeExpr*>(regOrVar), savedRHS);
+    rass->SetSrcPos(savedSrcPos);
+    rass->SetBB(savedBB);
+    rass->SetPrev(savedPrev);
+    rass->SetNext(savedNext);
+    regOrVar->SetDefBy(kDefByStmt);
+    regOrVar->SetDefByStmt(*rass);
+    EnterCandsForSSAUpdate(regOrVar->GetOstIdx(), *savedBB);
+    savedBB->InsertMeStmtAfter(realOcc.GetMeStmt(), newDassign);
+  } else {
+    CHECK_FATAL(kOpcodeInfo.IsCallAssigned(realOcc.GetOpcodeOfMeStmt()),
+                "LHS real occurrence has unrecognized stmt type");
+    MapleVector<MustDefMeNode> *mustDefList = realOcc.GetMeStmt()->GetMustDefList();
+    CHECK_NULL_FATAL(mustDefList);
+    CHECK_FATAL(!mustDefList->empty(), "empty mustdef in callassigned stmt");
+    MapleVector<MustDefMeNode>::iterator it = mustDefList->begin();
+    for (; it != mustDefList->end(); ++it) {
+      MustDefMeNode *mustDefMeNode = &(*it);
+      VarMeExpr *theLHS = static_cast<VarMeExpr*>(mustDefMeNode->GetLHS());
+      // check that this var is the worklist item being worked on
+      if (static_cast<VarMeExpr *>(workCand->GetTheMeExpr())->GetOst() != theLHS->GetOst()) {
+        continue;
+      }
+      if (regOrVar->GetMeOp() == kMeOpReg) {
+        // change mustDef lhs to regOrVar
+        mustDefMeNode->UpdateLHS(*regOrVar);
+        EnterCandsForSSAUpdate(regOrVar->GetOstIdx(), *realOcc.GetMeStmt()->GetBB());
+        // create new dassign for original lhs
+        MeStmt *newDassign = irMap->CreateAssignMeStmt(*theLHS, *regOrVar, *realOcc.GetMeStmt()->GetBB());
+        theLHS->SetDefByStmt(*newDassign);
+        realOcc.GetMeStmt()->GetBB()->InsertMeStmtAfter(realOcc.GetMeStmt(), newDassign);
+      } else {
+        CHECK_FATAL(false, "GenerateSaveRealOcc: non-reg temp for callassigned LHS occurrence NYI");
+      }
+    }
+  }
+  realOcc.SetSavedExpr(*regOrVar);
+}
+
+MeExpr *MeSSALPre::GetTruncExpr(const VarMeExpr &theLHS, MeExpr &savedRHS) {
+  MIRType *lhsType = theLHS.GetType();
+  if (theLHS.GetType()->GetKind() != kTypeBitField) {
+    if (GetPrimTypeSize(theLHS.GetPrimType()) < GetPrimTypeSize(savedRHS.GetPrimType())) {
+      // regassign can not take implicit truncation
+      return irMap->CreateMeExprTypeCvt(theLHS.GetPrimType(), savedRHS.GetPrimType(), savedRHS);
+    }
+    return &savedRHS;
+  }
+  MIRBitFieldType *bitfieldTy = static_cast<MIRBitFieldType *>(lhsType);
+  if (GetPrimTypeBitSize(savedRHS.GetPrimType()) <= bitfieldTy->GetFieldSize()) {
+    return &savedRHS;
+  }
+  // insert OP_zext or OP_sext
+  Opcode extOp = IsSignedInteger(lhsType->GetPrimType()) ? OP_sext : OP_zext;
+  PrimType newPrimType = PTY_u32;
+  if (bitfieldTy->GetFieldSize() <= GetPrimTypeBitSize(PTY_u32)) {
+    if (IsSignedInteger(lhsType->GetPrimType())) {
+      newPrimType = PTY_i32;
+    }
+  } else {
+    if (IsSignedInteger(lhsType->GetPrimType())) {
+      newPrimType = PTY_i64;
+    } else {
+      newPrimType = PTY_u64;
+    }
+  }
+  OpMeExpr opmeexpr(-1, extOp, newPrimType, 1);
+  opmeexpr.SetBitsSize(bitfieldTy->GetFieldSize());
+  opmeexpr.SetOpnd(0, &savedRHS);
+  return irMap->HashMeExpr(opmeexpr);
+}
+
+void MeSSALPre::GenerateReloadRealOcc(MeRealOcc &realOcc) {
+  CHECK_FATAL(!realOcc.IsLHS(), "GenerateReloadRealOcc: cannot be LHS occurrence");
+  MeExpr *regOrVar = nullptr;
+  MeOccur *defOcc = realOcc.GetDef();
+  if (defOcc->GetOccType() == kOccReal) {
+    auto *defRealOcc = static_cast<MeRealOcc*>(defOcc);
+    regOrVar = defRealOcc->GetSavedExpr();
+  } else if (defOcc->GetOccType() == kOccPhiocc) {
+    auto *defPhiOcc = static_cast<MePhiOcc*>(defOcc);
+    MePhiNode *regPhi = defPhiOcc->GetRegPhi();
+    regOrVar = regPhi->GetLHS();
+  } else if (defOcc->GetOccType() == kOccInserted) {
+    auto *defInsertedOcc = static_cast<MeInsertedOcc*>(defOcc);
+    regOrVar = defInsertedOcc->GetSavedExpr();
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+  CHECK_NULL_FATAL(regOrVar);
+  // replace realOcc->GetMeStmt()'s occ with regOrVar
+  (void)irMap->ReplaceMeExprStmt(*realOcc.GetMeStmt(), *realOcc.GetMeExpr(), *regOrVar);
+}
+
+// the variable in realZ is defined by a phi; replace it by the jth phi opnd
+MeExpr *MeSSALPre::PhiOpndFromRes(MeRealOcc &realZ, size_t j) const {
+  MeOccur *defZ = realZ.GetDef();
+  CHECK_NULL_FATAL(defZ);
+  CHECK_FATAL(defZ->GetOccType() == kOccPhiocc, "must be def by phiocc");
+  MeExpr *meExprZ = realZ.GetMeExpr();
+  BB *ePhiBB = static_cast<MePhiOcc*>(defZ)->GetBB();
+  MeExpr *retVar = GetReplaceMeExpr(*meExprZ, *ePhiBB, j);
+  return (retVar != nullptr) ? retVar : meExprZ;
+}
+
+void MeSSALPre::ComputeVarAndDfPhis() {
+  varPhiDfns.clear();
+  dfPhiDfns.clear();
+  PreWorkCand *workCand = GetWorkCand();
+  const MapleVector<MeRealOcc*> &realOccList = workCand->GetRealOccs();
+  CHECK_FATAL(!dom->IsNodeVecEmpty(), "size to be allocated is 0");
+  for (auto it = realOccList.begin(); it != realOccList.end(); ++it) {
+    MeRealOcc *realOcc = *it;
+    BB *defBB = realOcc->GetBB();
+    GetIterDomFrontier(defBB, &dfPhiDfns);
+    MeExpr *meExpr = realOcc->GetMeExpr();
+    if (meExpr->GetMeOp() == kMeOpVar) {
+      SetVarPhis(meExpr);
+    }
+  }
+  std::set<uint32> tmpVarPhi(varPhiDfns.begin(), varPhiDfns.end());
+  for (uint32 dfn : tmpVarPhi) {
+    GetIterDomFrontier(GetBB(BBId(dom->GetDtPreOrderItem(dfn))), &varPhiDfns);
+  }
+}
+
+void MeSSALPre::BuildEntryLHSOcc4Formals() const {
+  if (preKind == kAddrPre) {
+    return;
+  }
+  PreWorkCand *workCand = GetWorkCand();
+  auto *varMeExpr = static_cast<VarMeExpr*>(workCand->GetTheMeExpr());
+  OriginalSt *ost = varMeExpr->GetOst();
+  if (!ost->IsFormal() || ost->IsAddressTaken()) {
+    return;
+  }
+  if (ost->GetFieldID() != 0) {
+    return;
+  }
+  if (assignedFormals.find(ost->GetIndex()) != assignedFormals.end()) {
+    return;  // the formal's memory location has to be preserved
+  }
+  // Avoid promoting formals if it has been marked localrefvar
+  if (ost->HasAttr(ATTR_localrefvar)) {
+    return;
+  }
+  if (ost->HasOneElemSimdAttr()) {
+    return;
+  }
+  // get the zero version VarMeExpr node
+  VarMeExpr *zeroVersion = irMap->GetOrCreateZeroVersionVarMeExpr(*ost);
+  MeRealOcc *occ = ssaPreMemPool->New<MeRealOcc>(nullptr, 0, zeroVersion);
+  auto occIt = workCand->GetRealOccs().begin();
+  (void)workCand->GetRealOccs().insert(occIt, occ);  // insert at beginning
+  occ->SetIsLHS(true);
+  occ->SetIsFormalAtEntry(true);
+  occ->SetBB(*func->GetCfg()->GetFirstBB());
+}
+
+void MeSSALPre::BuildWorkListLHSOcc(MeStmt &meStmt, int32 seqStmt) {
+  if (preKind == kAddrPre) {
+    return;
+  }
+  if (meStmt.GetOp() == OP_dassign || meStmt.GetOp() == OP_maydassign) {
+    VarMeExpr *lhs = static_cast<VarMeExpr*>(meStmt.GetVarLHS());
+    CHECK_NULL_FATAL(lhs);
+    const OriginalSt *ost = lhs->GetOst();
+    if (mirModule->IsCModule()) {
+      MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx());
+      if (ty->GetKind() == kTypeBitField || ty->GetSize() < 4) {
+        return;  // no advantage
+      }
+    }
+    if (ost->IsFormal()) {
+      (void)assignedFormals.insert(ost->GetIndex());
+    }
+    CHECK_NULL_FATAL(meStmt.GetRHS());
+    if (ost->IsVolatile() || ost->HasOneElemSimdAttr()) {
+      return;
+    }
+    if (lhs->GetPrimType() == PTY_agg) {
+      return;
+    }
+    CreateRealOcc(meStmt, seqStmt, *lhs, false, true);
+  } else if (kOpcodeInfo.IsCallAssigned(meStmt.GetOp())) {
+    MapleVector<MustDefMeNode> *mustDefList = meStmt.GetMustDefList();
+    MapleVector<MustDefMeNode>::iterator it = mustDefList->begin();
+    size_t i = 0; /* count for inline asm out put constraints */
+    bool isAsm = meStmt.GetOp() == OP_asm;
+    for (; it != mustDefList->end(); ++it) {
+      if ((*it).GetLHS()->GetMeOp() != kMeOpVar) {
+        continue;
+      }
+      if (isAsm) {
+        const std::string &str =
+            GlobalTables::GetUStrTable().GetStringFromStrIdx(static_cast<AsmMeStmt&>(meStmt).outputConstraints[i++]);
+        /* skip memory access in inline asm */
+        if (str.find("Q") != std::string::npos || str.find("m") != std::string::npos) {
+          continue;
+        }
+      }
+      auto *theLHS = static_cast<VarMeExpr*>((*it).GetLHS());
+      const OriginalSt *ost = theLHS->GetOst();
+      if (ost->IsFormal()) {
+        (void)assignedFormals.insert(ost->GetIndex());
+      }
+      if (theLHS->GetPrimType() == PTY_ref && !MeOption::rcLowering) {
+        continue;
+      }
+      if (ost->IsVolatile()) {
+        continue;
+      }
+      if (theLHS->GetPrimType() == PTY_agg) {
+        continue;
+      }
+      CreateRealOcc(meStmt, seqStmt, *theLHS, false, true);
+    }
+    return;
+  }
+}
+
+void MeSSALPre::CreateMembarOccAtCatch(BB &bb) {
+  // go thru all workcands and insert a membar occurrence for each of them
+  uint32 cnt = 0;
+  for (PreWorkCand *wkCand : std::as_const(workList)) {
+    ++cnt;
+    if (cnt > preLimit) {
+      break;
+    }
+    MeRealOcc *newOcc = ssaPreMemPool->New<MeRealOcc>(nullptr, 0, wkCand->GetTheMeExpr());
+    newOcc->SetOccType(kOccMembar);
+    newOcc->SetBB(bb);
+    wkCand->AddRealOccAsLast(*newOcc, GetPUIdx());
+    if (preKind == kAddrPre) {
+      continue;
+    }
+    auto *varMeExpr = static_cast<VarMeExpr*>(wkCand->GetTheMeExpr());
+    const OriginalSt *ost = varMeExpr->GetOst();
+    if (ost->IsFormal()) {
+      (void)assignedFormals.insert(ost->GetIndex());
+    }
+  }
+}
+
+// only handle the leaf of load, because all other expressions has been done by
+// previous SSAPre
+void MeSSALPre::BuildWorkListExpr(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool isRebuild, MeExpr *tmpVar,
+                                  bool isRootExpr, bool insertSorted) {
+  (void) isRebuild;
+  (void) tmpVar;
+  (void) isRootExpr;
+  (void) insertSorted;
+  MeExprOp meOp = meExpr.GetMeOp();
+  switch (meOp) {
+    case kMeOpVar: {
+      if (preKind != kLoadPre) {
+        break;
+      }
+      auto *varMeExpr = static_cast<VarMeExpr*>(&meExpr);
+      const OriginalSt *ost = varMeExpr->GetOst();
+      if (ost->IsVolatile() || ost->HasOneElemSimdAttr()) {
+        break;
+      }
+      const MIRSymbol *sym = ost->GetMIRSymbol();
+      if (sym->GetAsmAttr() != 0) {
+        break;
+      }
+      if (sym->IsInstrumented() && !(func->GetHints() & kPlacementRCed)) {
+        // not doing because its SSA form is not complete
+        break;
+      }
+      if (meExpr.GetPrimType() == PTY_agg) {
+        break;
+      }
+      CreateRealOcc(meStmt, seqStmt, meExpr, false);
+      break;
+    }
+    case kMeOpAddrof: {
+      if (preKind != kAddrPre) {
+        break;
+      }
+      if (!MeOption::lpre4Address) {
+        break;
+      }
+      if (!(mirModule->IsCModule()) || MeOption::rematLevel < kLevelTwo) {
+        auto *addrOfMeExpr = static_cast<AddrofMeExpr *>(&meExpr);
+        const OriginalSt *ost = addrOfMeExpr->GetOst();
+        CHECK_FATAL(ost, "ost is nullptr");
+        if (ost->IsLocal()) {  // skip lpre for stack addresses as they are cheap and need keep for rc
+          break;
+        }
+      }
+      CreateRealOcc(meStmt, seqStmt, meExpr, false);
+      break;
+    }
+    case kMeOpAddroffunc: {
+      if (preKind != kAddrPre) {
+        break;
+      }
+      if (!MeOption::lpre4Address) {
+        break;
+      }
+      if (func->genLMBC) {
+        break;
+      }
+      CreateRealOcc(meStmt, seqStmt, meExpr, false);
+      break;
+    }
+    case kMeOpConst: {
+      if (preKind != kAddrPre) {
+        break;
+      }
+      if (!MeOption::lpre4LargeInt) {
+        break;
+      }
+      if (!IsPrimitiveInteger(meExpr.GetPrimType())) {
+        break;
+      }
+      MIRIntConst *intConst = dynamic_cast<MIRIntConst *>(static_cast<ConstMeExpr&>(meExpr).GetConstVal());
+      if (intConst == nullptr) {
+        break;
+      }
+      if ((intConst->GetExtValue() >> 12) == 0) {
+        break;  // not promoting if value fits in 12 bits
+      }
+      if (!meStmt.GetBB()->GetAttributes(kBBAttrIsInLoop)) {
+        break;
+      }
+      if (meStmt.GetOp() != OP_brfalse && meStmt.GetOp() != OP_brtrue) {
+        break;
+      }
+      OpMeExpr *compareX = dynamic_cast<OpMeExpr *>(meStmt.GetOpnd(0));
+      if (compareX == nullptr) {
+        break;
+      }
+      if (!kOpcodeInfo.IsCompare(compareX->GetOp())) {
+        break;
+      }
+      if (compareX->GetOpnd(1) != &meExpr) {
+        break;
+      }
+      CreateRealOcc(meStmt, seqStmt, meExpr, false);
+      break;
+    }
+    case kMeOpOp: {
+      auto *meOpExpr = static_cast<OpMeExpr*>(&meExpr);
+      for (size_t i = 0; i < kOperandNumTernary; ++i) {
+        MeExpr *opnd = meOpExpr->GetOpnd(i);
+        if (opnd != nullptr) {
+          BuildWorkListExpr(meStmt, seqStmt, *opnd, false, nullptr, false, false);
+        }
+      }
+      break;
+    }
+    case kMeOpNary: {
+      auto *naryMeExpr = static_cast<NaryMeExpr*>(&meExpr);
+      MapleVector<MeExpr*> &opnds = naryMeExpr->GetOpnds();
+      for (auto it = opnds.begin(); it != opnds.end(); ++it) {
+        MeExpr *opnd = *it;
+        BuildWorkListExpr(meStmt, seqStmt, *opnd, false, nullptr, false, false);
+      }
+      break;
+    }
+    case kMeOpIvar: {
+      auto *ivarMeExpr = static_cast<IvarMeExpr*>(&meExpr);
+      BuildWorkListExpr(meStmt, seqStmt, *ivarMeExpr->GetBase(), false, nullptr, false, false);
+      break;
+    }
+    case kMeOpAddroflabel:
+    default:
+      break;
+  }
+}
+
+void MeSSALPre::BuildWorkList() {
+  MeFunction &tmpFunc = irMap->GetFunc();
+  size_t numBBs = dom->GetDtPreOrderSize();
+  if (numBBs > kDoLpreBBsLimit) {
+    return;
+  }
+  const auto &preOrderDt = dom->GetDtPreOrder();
+  for (size_t i = 0; i < numBBs; ++i) {
+    BB *bb = tmpFunc.GetCfg()->GetBBFromID(BBId(preOrderDt[i]));
+    BuildWorkListBB(bb);
+  }
+}
+
+void MeSSALPre::FindLoopHeadBBs(const IdentifyLoops &identLoops) {
+  for (LoopDesc *mapleLoop : identLoops.GetMeLoops()) {
+    if (mapleLoop->head != nullptr) {
+      (void)loopHeadBBs.insert(mapleLoop->head->GetBBId());
+    }
+  }
+}
+
+bool MESSALPre::PhaseRun(maple::MeFunction &f) {
+  static uint32 puCount = 0;  // count PU to support the lprePULimit option
+  if (puCount > MeOption::lprePULimit) {
+    ++puCount;
+    return false;
+  }
+
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  auto pdom = dominancePhase->GetPdomResult();
+  CHECK_NULL_FATAL(pdom);
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_NULL_FATAL(irMap);
+  auto *identLoops = GET_ANALYSIS(MELoopAnalysis, f);
+  CHECK_NULL_FATAL(identLoops);
+  bool lprePULimitSpecified = MeOption::lprePULimit != UINT32_MAX;
+  uint32 lpreLimitUsed =
+      (lprePULimitSpecified && puCount != MeOption::lprePULimit) ? UINT32_MAX : MeOption::lpreLimit;
+  {
+    MeSSALPre ssaLpre(f, *irMap, *dom, *pdom, *ApplyTempMemPool(), *ApplyTempMemPool(), kLoadPre, lpreLimitUsed);
+    ssaLpre.SetRcLoweringOn(MeOption::rcLowering);
+    ssaLpre.SetRegReadAtReturn(MeOption::regreadAtReturn);
+    ssaLpre.SetSpillAtCatch(MeOption::spillAtCatch);
+    if (lprePULimitSpecified && puCount == MeOption::lprePULimit && lpreLimitUsed != UINT32_MAX) {
+      LogInfo::MapleLogger() << "applying LPRE limit " << lpreLimitUsed << " in function " <<
+          f.GetMirFunc()->GetName() << '\n';
+    }
+    if (DEBUGFUNC_NEWPM(f)) {
+      ssaLpre.SetSSAPreDebug(true);
+    }
+    if (MeOption::lpreSpeculate && !f.HasException()) {
+      ssaLpre.FindLoopHeadBBs(*identLoops);
+    }
+    ssaLpre.ApplySSAPRE();
+    if (DEBUGFUNC_NEWPM(f)) {
+      LogInfo::MapleLogger() << "\n==============after LoadPre =============" << '\n';
+      f.Dump(false);
+    }
+
+    auto &candsForSSAUpdate = ssaLpre.GetCandsForSSAUpdate();
+    if (!candsForSSAUpdate.empty()) {
+      MeSSAUpdate ssaUpdate(f, *f.GetMeSSATab(), *dom, candsForSSAUpdate);
+      ssaUpdate.Run();
+    }
+  }
+  if (MeOption::lpre4Address) {
+    MeLowerGlobals lowerGlobals(f, f.GetMeSSATab());
+    lowerGlobals.Run();
+  }
+  if (MeOption::lpre4Address || MeOption::lpre4LargeInt) {
+    MeSSALPre ssaLpre(f, *irMap, *dom, *pdom, *ApplyTempMemPool(), *ApplyTempMemPool(), kAddrPre, lpreLimitUsed);
+    ssaLpre.SetSpillAtCatch(MeOption::spillAtCatch);
+    if (DEBUGFUNC_NEWPM(f)) {
+      ssaLpre.SetSSAPreDebug(true);
+    }
+    if (MeOption::lpreSpeculate && !f.HasException()) {
+      ssaLpre.FindLoopHeadBBs(*identLoops);
+    }
+    ssaLpre.ApplySSAPRE();
+    if (DEBUGFUNC_NEWPM(f)) {
+      LogInfo::MapleLogger() << "\n==============after AddrPre =============" << '\n';
+      f.Dump(false);
+    }
+  }
+  ++puCount;
+  return true;
+}
+
+void MESSALPre::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_ssa_prop.cpp b/src/mapleall/maple_me/src/me_ssa_prop.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2294f7d8beef7759d1c1c701a3c80a9b6630027a
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ssa_prop.cpp
@@ -0,0 +1,422 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ssa_prop.h"
+#include "me_phase_manager.h"
+#include "constantfold.h"
+namespace maple {
+SSAProp::SSAProp(MeFunction *f, Dominance *d) : func(f), dom(d), ssaTab(func->GetMeSSATab()) {
+  auto &origTab = func->GetMeSSATab()->GetOriginalStTable().GetOriginalStVector();
+  vstLiveStack.resize(origTab.size());
+  for (size_t i = 1; i < origTab.size(); ++i) {
+    OriginalSt *ost = origTab[i];
+    if (ost->GetVersionsIndices().size() != 0) {
+      VersionSt *zeroVst = ssaTab->GetVersionStTable().GetZeroVersionSt(origTab[i]);
+      vstLiveStack[i].push(zeroVst);
+    }
+  }
+}
+
+// iread fld1 (addrof fld2 a) => dread fld1+fld2 a
+BaseNode *SSAProp::SimplifyIreadAddrof(IreadSSANode *ireadSSA) const {
+  if (ireadSSA->Opnd(0)->GetOpCode() != OP_addrof) {
+    return ireadSSA;
+  }
+  BaseNode *base = ireadSSA->Opnd(0);
+  ASSERT(base->IsSSANode(), "ssa-tab should run before!");
+  OriginalSt *baseOst = static_cast<AddrofSSANode *>(base)->GetSSAVar()->GetOst();
+  TyIdx baseTyIdx = baseOst->GetTyIdx(); // note: baseTyIdx is memory type, not pointer to memory type
+  IreadNode *iread = static_cast<IreadNode *>(ireadSSA->GetNoSSANode());
+  MIRType *ireadBaseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx());
+  ASSERT(ireadBaseType->IsMIRPtrType(), "Type of IreadNode's base must be pointer!");
+  // type consistent check : if access type of iread is different from that of addrofNode, we cannot simplify it.
+  // for example : `a : <[2] i32>; iread i32 <* i32> (addrof 0 a)` can not be simplified to `dread i32 a`;
+  if (static_cast<MIRPtrType *>(ireadBaseType)->GetPointedTyIdx() != baseTyIdx) {
+    return ireadSSA;
+  }
+  ASSERT(baseOst->IsSymbolOst(), "Ost of Addrof must be symbol ost!");
+  MIRSymbol *sym = baseOst->GetMIRSymbol();
+  FieldID newFld = baseOst->GetFieldID() + iread->GetFieldID();
+  VersionSt *mu = ireadSSA->GetSSAVar();
+  if (mu != nullptr) { // mu will be set after alias analysis.
+    OriginalSt *muOst = mu->GetOst();
+    if (!muOst->IsSymbolOst() || muOst->GetMIRSymbol() != sym || muOst->GetFieldID() != newFld) {
+      return ireadSSA;
+    }
+  }
+  DreadNode *dread = func->GetMIRModule().GetMIRBuilder()->CreateExprDread(iread->GetPrimType(), newFld, *sym);
+  auto *dreadSSANode = static_cast<SSANode *>(ssaTab->CreateSSAExpr(dread));
+  if (mu != nullptr) {
+    dreadSSANode->SetSSAVar(*mu);
+  }
+  return dreadSSANode;
+}
+
+BaseNode *SSAProp::SimplifyExpr(BaseNode *expr) const {
+  for (size_t i = 0; i < expr->NumOpnds(); ++i) {
+    expr->SetOpnd(SimplifyExpr(expr->Opnd(i)), i);
+  }
+  // iread fld1 (addrof fld2 a)
+  BaseNode *result = expr;
+  if (expr->GetOpCode() == OP_iread) {
+    ASSERT(expr->IsSSANode(), "ssa-tab should run before!");
+    result = SimplifyIreadAddrof(static_cast<IreadSSANode *>(expr));
+    if (result != expr) {
+      return result;
+    }
+  }
+  // process other simplify like constant fold
+  if (expr->IsBinaryNode() && expr->Opnd(0)->IsConstval() && expr->Opnd(1)->IsConstval()) {
+    ConstantFold folder(func->GetMIRModule());
+    result = folder.Fold(expr);
+    if (result != nullptr) {
+      return result;
+    }
+  }
+  return expr;
+}
+
+// iassign fld1 (addrof fld2 sym) => dassign fld1+fld2 sym
+StmtNode *SSAProp::SimplifyIassignAddrof(IassignNode *iassign, BB *bb) const {
+  BaseNode *base = iassign->Opnd(0);
+  if (base->GetOpCode() != OP_addrof) {
+    return iassign;
+  }
+  AddrofNode *addrofNode =
+      static_cast<AddrofNode *>((base->IsSSANode()) ? static_cast<AddrofSSANode *>(base)->GetNoSSANode() : base);
+  // 1. try to simplify
+  ConstantFold folder(func->GetMIRModule());
+  StmtNode *dassign = folder.SimplifyIassignWithAddrofBaseNode(*iassign, *addrofNode);
+  if (dassign == iassign) { // cannot be simplified
+    return iassign;
+  }
+  // 2. set ssa part for new stmt.
+  ssaTab->CreateSSAStmt(*dassign, bb);
+  if (func->IsMemSSAValid()) { // after memory ssa, we should maintain maydef list.
+    StmtsSSAPart &ssaPart = ssaTab->GetStmtsSSAPart();
+    // check if new assigned ost is in maydef list.
+    TypeOfMayDefList &oldMayDefList = ssaPart.GetMayDefNodesOf(*iassign);
+    VersionSt *newDef = ssaPart.GetAssignedVarOf(*dassign);
+    OriginalSt *newOst = newDef->GetOst();
+    auto it = oldMayDefList.find(newOst->GetIndex());
+    if (it == oldMayDefList.end()) {
+      return iassign; // no must def version find, not simplify.
+    }
+    // set ssa var as new version found in may list.
+    VersionSt *vst = it->second.GetResult();
+    ssaPart.SSAPartOf(*dassign)->SetSSAVar(*vst);
+    // note: should update vst's def info, otherwise it will be defined by mayDef list of old stmt.
+    vst->SetAssignNode(dassign);
+    vst->SetDefType(VersionSt::kAssign);
+    // copy other item of original may def list.
+    TypeOfMayDefList &newMayDefList = ssaPart.GetMayDefNodesOf(*dassign);
+    ASSERT(newMayDefList.empty(), "A new iassign should not be set maydef list before");
+    newMayDefList.insert(oldMayDefList.cbegin(), oldMayDefList.cend());
+    newMayDefList.erase(newOst->GetIndex());
+    // note: should update maydefNode's def info, otherwise it will be associated with old stmt.
+    std::for_each(newMayDefList.begin(), newMayDefList.end(), [dassign](std::pair<const OStIdx, MayDefNode> &item) {
+      item.second.SetStmt(dassign);
+    });
+  }
+  return dassign;
+}
+
+StmtNode *SSAProp::SimplifyStmt(StmtNode *stmt, BB *bb) const {
+  for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+    BaseNode *oldOpnd = stmt->Opnd(i);
+    BaseNode *newOpnd = SimplifyExpr(oldOpnd);
+    if (oldOpnd != newOpnd) {
+      stmt->SetOpnd(newOpnd, i);
+    }
+  }
+  if (stmt->GetOpCode() == OP_iassign && stmt->Opnd(0)->GetOpCode() == OP_addrof) {
+    return SimplifyIassignAddrof(static_cast<IassignNode *>(stmt), bb);
+  }
+  return stmt;
+}
+
+bool SSAProp::CanOstProped(OriginalSt *ost) const {
+  if (ost->IsVolatile()) {
+    return false;
+  }
+  if (ost->IsPregOst() && ost->GetPregIdx() < 0) {
+    return false; // no prop for special reg.
+  }
+  if (!ost->IsLocal() && !ost->IsFinal() && !ost->IsIgnoreRC()) {
+    return false;
+  }
+  if (func->IsMemSSAValid()) {
+    return true;
+  }
+  if (func->IsTopLevelSSAValid()) {
+    return IsLocalTopLevelOst(*ost);
+  }
+  return false;
+}
+// check if :
+//   1) rhs is leaf node and,
+//   2) prop rhs must not cross a new version
+bool SSAProp::Propagatable(BaseNode *rhs) const {
+  if (rhs->GetOpCode() == OP_iaddrof) {
+    return Propagatable(rhs->Opnd(0));
+  }
+  if (!rhs->IsLeaf()) { // propagate non-leaf expr will generate compound expr
+    return false;
+  }
+  switch (rhs->GetOpCode()) {
+    case OP_regread:
+    case OP_dread: {
+      VersionSt *vst = static_cast<SSANode *>(rhs)->GetSSAVar();
+      if (!CanOstProped(vst->GetOst())) {
+        return false;
+      }
+      // version consistent : make sure no vst cross a new version
+      if (vstLiveStack[vst->GetOst()->GetIndex()].top() != vst) {
+        return false;
+      }
+      return true;
+    }
+    case OP_addrof:
+    case OP_constval: {
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+void SSAProp::UpdateDef(VersionSt *vst) {
+  if (vst != nullptr && !vst->IsInitVersion()) {
+    vstLiveStack[vst->GetOst()->GetIndex()].push(vst);
+  }
+}
+
+void SSAProp::UpdateDefOfMayDef(const StmtNode &stmt) {
+  if (!kOpcodeInfo.HasSSADef(stmt.GetOpCode()) || stmt.GetOpCode() == maple::OP_regassign) {
+    return;
+  }
+  StmtsSSAPart &ssaPart = ssaTab->GetStmtsSSAPart();
+  TypeOfMayDefList &mayDefList = ssaPart.GetMayDefNodesOf(stmt);
+  for (auto it = mayDefList.begin(); it != mayDefList.end(); ++it) {
+    MayDefNode &mayDef = it->second;
+    VersionSt *vst = mayDef.GetResult();
+    UpdateDef(vst);
+  }
+}
+
+// if lhs is smaller than rhs, insert operation to simulate the truncation
+// effect of rhs being stored into lhs; otherwise, just return rhs
+BaseNode *SSAProp::CheckTruncation(BaseNode *lhs, BaseNode *rhs) const {
+  PrimType rhsPtyp = rhs->GetPrimType();
+  if (func->GetMIRModule().IsJavaModule() || !IsPrimitiveInteger(rhsPtyp)) {
+    return rhs;
+  }
+  ASSERT(lhs->IsSSANode(), "ssatab must run before!");
+  OriginalSt *ost = static_cast<SSANode *>(lhs)->GetSSAVar()->GetOst();
+  MIRType *lhsType = ost->GetType();
+  PrimType lhsPtyp = lhsType->GetPrimType();
+  const MIRBuilderPtr builder = func->GetMIRModule().GetMIRBuilder();
+  if (lhsType->GetKind() == kTypeBitField) {
+    auto *bfType = static_cast<MIRBitFieldType *>(lhsType);
+    if (GetPrimTypeBitSize(rhsPtyp) <= bfType->GetFieldSize()) { // no need cvt for : large type <- small type
+      return rhs;
+    }
+    Opcode extOp = IsSignedInteger(lhsPtyp) ? OP_sext : OP_zext;
+    PrimType extPtyp = (bfType->GetFieldSize() <= k32BitSize) ? (IsSignedInteger(lhsPtyp) ? PTY_i32 : PTY_u32)
+                                                              : (IsSignedInteger(lhsPtyp) ? PTY_i64 : PTY_u64);
+    return builder->CreateExprExtractbits(extOp, extPtyp, 0, bfType->GetFieldSize(), rhs);
+  }
+  if (IsPrimitiveInteger(lhsPtyp) != IsPrimitiveInteger(rhsPtyp) ||
+      (GetPrimTypeSize(lhsPtyp) < GetPrimTypeSize(rhsPtyp) && GetPrimTypeBitSize(lhsPtyp) > k32BitSize) ||
+      (GetPrimTypeSize(lhsPtyp) == GetPrimTypeSize(rhsPtyp) && IsSignedInteger(lhsPtyp) != IsSignedInteger(rhsPtyp))) {
+    return builder->CreateExprTypeCvt(OP_cvt, lhsPtyp, rhsPtyp, *rhs);
+  }
+  if (GetPrimTypeSize(lhsPtyp) < GetPrimTypeSize(rhsPtyp)) {
+    Opcode extOp = IsSignedInteger(lhsPtyp) ? OP_sext : OP_zext;
+    PrimType extPtyp = IsSignedInteger(lhsPtyp) ? PTY_i32 : PTY_u32;
+    return builder->CreateExprExtractbits(extOp, extPtyp, 0, GetPrimTypeBitSize(lhsPtyp), rhs);
+  }
+  return rhs;
+}
+
+// if all phiOpnds are the same(after proped), we can prop it, otherwise return nullptr.
+BaseNode *SSAProp::PropPhi(PhiNode *phi) {
+  if (!MeOption::propAtPhi) {
+    return nullptr;
+  }
+  MapleVector<VersionSt *> &phiOpnds = phi->GetPhiOpnds();
+  VersionSt *phiOpndLast = phiOpnds.back();
+  // To avoid endless loop : if phiOpnd is def by a phi, stop propagating.
+  BaseNode *opndLastProp = PropVst(phiOpndLast, false);
+  if (opndLastProp == nullptr) {
+    return nullptr;
+  }
+  for (auto it = phiOpnds.crbegin() + 1; it != phiOpnds.crend(); ++it) {
+    BaseNode *opnd = PropVst(*it, false);
+    if (!IsSameContent(opnd, opndLastProp, true)) {
+      return nullptr;
+    }
+  }
+  return opndLastProp;
+}
+
+// if vst can be propagated, return expr, otherwise return nullptr;
+BaseNode *SSAProp::PropVst(VersionSt *vst, bool checkPhi) {
+  if (vst == nullptr || vst->GetOst()->IsVolatile()) {
+    return nullptr;
+  }
+  if (vst->GetDefType() == VersionSt::kPhi && checkPhi && MeOption::propAtPhi) {
+    // try to prop phi if all phiOpnds are the same.
+    return PropPhi(vst->GetPhi());
+  }
+  if (vst->GetDefType() != VersionSt::kAssign) {
+    return nullptr;
+  }
+  StmtNode *defStmt = vst->GetAssignNode();
+  // check if defRHS can be prop
+  BaseNode *defRHS = defStmt->GetRHS();
+  if (!Propagatable(defRHS)) {
+    return nullptr;
+  }
+  // replace expr with defRHS
+  MapleAllocator &allocator = func->GetMIRModule().GetMPAllocator();
+  BaseNode *newRHS = defRHS->CloneTree(allocator);
+  return newRHS;
+}
+
+BaseNode *SSAProp::PropExpr(BaseNode *expr, bool &subProp) {
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    BaseNode *oldOpnd = expr->Opnd(i);
+    BaseNode *newOpnd = PropExpr(oldOpnd, subProp);
+    if (newOpnd != oldOpnd) { // prop happen
+      expr->SetOpnd(newOpnd, i);
+      subProp = true;
+    }
+  }
+  if (!expr->IsSSANode() || expr->GetOpCode() == OP_addrof) {
+    return expr;
+  }
+  VersionSt *vst = static_cast<SSANode *>(expr)->GetSSAVar();
+  BaseNode *newRHS = PropVst(vst, true);
+  if (newRHS == nullptr) {
+    return expr; // no prop
+  }
+  newRHS = CheckTruncation(expr, newRHS);
+  subProp = true; // update state.
+  return newRHS;
+}
+
+void SSAProp::TraverseStmt(StmtNode *stmt, BB *currBB) {
+  Opcode op = stmt->GetOpCode();
+  if (op == OP_asm) { // do not prop use in inline asm
+    UpdateDefOfMayDef(*stmt);
+    return;
+  }
+  // 1.prop use in stmt's opnds
+  bool proped = false;
+  for (size_t i = 0; i < stmt->GetNumOpnds(); ++i) {
+    BaseNode *oldOpnd = stmt->Opnd(i);
+    BaseNode *newOpnd = PropExpr(oldOpnd, proped);
+    if (newOpnd != oldOpnd) {
+      stmt->SetOpnd(newOpnd, i);
+      proped = true;
+    }
+  }
+  if (proped) {
+    // try to simplify
+    StmtNode *newStmt = SimplifyStmt(stmt, currBB);
+    if (newStmt != stmt) {
+      currBB->ReplaceStmt(stmt, newStmt);
+      stmt = newStmt;
+    }
+  }
+  // 2.Push def version to vstLiveStack according to stmt kind.
+  //   1) def of reg-/d-assign
+  //   2) must def list
+  //   3) may def list
+  StmtsSSAPart &ssaPart = ssaTab->GetStmtsSSAPart();
+  // 1) def by regassign/dassign
+  if (kOpcodeInfo.AssignActualVar(stmt->GetOpCode())) {
+    VersionSt *vst = ssaPart.GetAssignedVarOf(*stmt);
+    UpdateDef(vst);
+  } else if (kOpcodeInfo.IsCallAssigned(stmt->GetOpCode())) {
+    // 2) def by must def list
+    MapleVector<MustDefNode> &mustDefs = ssaPart.GetMustDefNodesOf(*stmt);
+    for (MustDefNode &mustDefNode : mustDefs) {
+      VersionSt *vst = mustDefNode.GetResult();
+      UpdateDef(vst);
+    }
+  }
+  // 3) def by may def list
+  if (kOpcodeInfo.HasSSADef(stmt->GetOpCode())) {
+    UpdateDefOfMayDef(*stmt);
+  }
+}
+
+void SSAProp::TraversalBB(BB &bb) {
+  // record stack size for recovering vstLiveStack after traversing dominance children BB
+  std::vector<size_t> curStackSize(vstLiveStack.size(), 0);
+  for (size_t i = 1; i < vstLiveStack.size(); ++i) {
+    curStackSize[i] = vstLiveStack[i].size();
+  }
+  // update def from phi list
+  for (auto &phi : bb.GetPhiList()) {
+    UpdateDef(phi.second.GetResult());
+  }
+  // traverse stmt
+  for (auto &stmt : bb.GetStmtNodes()) {
+    TraverseStmt(&stmt, &bb);
+  }
+  // traverse dominator children
+  auto &domChildren = dom->GetDomChildren(bb.GetID());
+  for (auto it = domChildren.begin(); it != domChildren.end(); ++it) {
+    TraversalBB(*func->GetCfg()->GetBBFromID(BBId(*it)));
+  }
+
+  // recover vstLive
+  for (size_t i = 1; i < vstLiveStack.size(); ++i) {
+    std::stack<VersionSt *> &liveStack = vstLiveStack[i];
+    if (i < curStackSize.size()) {
+      while (curStackSize[i] < liveStack.size()) {
+        liveStack.pop();
+      }
+    } else {
+      // clear tmp vst
+      while (!liveStack.empty()) {
+        liveStack.pop();
+      }
+    }
+  }
+}
+
+void SSAProp::PropInFunc() {
+  TraversalBB(*func->GetCfg()->GetCommonEntryBB());
+}
+
+void MESSAProp::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MESSAProp::PhaseRun(maple::MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  CHECK_NULL_FATAL(dom);
+  if (!f.IsMplIRAvailable()) {
+    return false;
+  }
+  SSAProp ssaProp(&f, dom);
+  ssaProp.PropInFunc();
+  return false;
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/me_ssa_tab.cpp b/src/mapleall/maple_me/src/me_ssa_tab.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5f1e3b2f4745797809fcb45a5f11071989fe94c3
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ssa_tab.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ssa_tab.h"
+#include "me_cfg.h"
+#include "mpl_timer.h"
+#include "me_dominance.h"
+#include "ssa_tab.h"
+
+// allocate the data structure to store SSA information
+namespace maple {
+bool MESSATab::PhaseRun(maple::MeFunction &f) {
+  auto *cfg = f.GetCfg();
+  MPLTimer timer;
+  timer.Start();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== SSA and AA preparation =============" << '\n';
+  }
+  MemPool *memPool = GetPhaseMemPool();
+  // allocate ssaTab including its SSAPart to store SSA information for statements
+  ssaTab = memPool->New<SSATab>(memPool, f.GetVersMp(), &f.GetMIRModule(), &f);
+  f.SetMeSSATab(ssaTab);
+#if DEBUG
+  globalSSATab = ssaTab;
+#endif
+  // pass through the program statements
+  for (auto bIt = cfg->valid_begin(); bIt != cfg->valid_end(); ++bIt) {
+    auto *bb = *bIt;
+    for (auto &stmt : bb->GetStmtNodes()) {
+      ssaTab->CreateSSAStmt(stmt, bb);  // this adds the SSANodes for exprs
+    }
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    timer.Stop();
+    LogInfo::MapleLogger() << "ssaTab consumes cumulatively " << timer.Elapsed() << "seconds " << '\n';
+  }
+  return false;
+}
+
+void MESSATab::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_ssa_update.cpp b/src/mapleall/maple_me/src/me_ssa_update.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c63220cd8aa24d910a2dba37e64049f67ca0951
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ssa_update.cpp
@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ssa_update.h"
+
+// Create or update HSSA representation for variables given by *updateCands;
+// for each variable, the mapped bb set gives the bbs that have newly inserted
+// dassign's to the variable.
+// If some assignments have been deleted, the current implementation does not
+// delete useless phi's, and these useless phi's may end up having identical
+// phi operands.
+namespace maple {
+std::stack<ScalarMeExpr*> *VectorVersionStacks::GetRenameStack(OStIdx idx) {
+  return renameWithVectorStacks.at(idx).get();
+}
+
+std::stack<ScalarMeExpr*> *MapVersionStacks::GetRenameStack(OStIdx idx) {
+  auto it = renameWithMapStacks.find(idx);
+  if (it == renameWithMapStacks.end()) {
+    return nullptr;
+  }
+  return it->second.get();
+}
+
+void VectorVersionStacks::InsertZeroVersion2RenameStack(SSATab &ssaTab, IRMap &irMap) {
+  for (size_t i = 1; i < renameWithVectorStacks.size(); ++i) {
+    if (renameWithVectorStacks.at(i) == nullptr) {
+      continue;
+    }
+    OriginalSt *ost = ssaTab.GetOriginalStFromID(OStIdx(i));
+    CHECK_FATAL(ost, "ost is nullptr");
+    ScalarMeExpr *zeroVersScalar =
+        (ost->IsSymbolOst()) ? irMap.GetOrCreateZeroVersionVarMeExpr(*ost) : irMap.CreateRegMeExprVersion(*ost);
+    auto renameStack = renameWithVectorStacks.at(i).get();
+    renameStack->push(zeroVersScalar);
+  }
+}
+
+void MapVersionStacks::InsertZeroVersion2RenameStack(SSATab &ssaTab, IRMap &irMap) {
+  for (auto &renameWithMapStack : std::as_const(renameWithMapStacks)) {
+    OriginalSt *ost = ssaTab.GetOriginalStFromID(renameWithMapStack.first);
+    ScalarMeExpr *zeroVersScalar =
+        (ost->IsSymbolOst()) ? irMap.GetOrCreateZeroVersionVarMeExpr(*ost) : irMap.CreateRegMeExprVersion(*ost);
+    auto renameStack = renameWithMapStack.second.get();
+    renameStack->push(zeroVersScalar);
+  }
+}
+
+void VectorVersionStacks::InitRenameStack(OStIdx idx) {
+  renameWithVectorStacks[idx] = std::make_unique<std::stack<ScalarMeExpr*>>();
+}
+
+void MapVersionStacks::InitRenameStack(OStIdx idx) {
+  renameWithMapStacks[idx] = std::make_unique<std::stack<ScalarMeExpr*>>();
+}
+
+void VectorVersionStacks::RecordCurrentStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) {
+  origStackSize.resize(renameWithVectorStacks.size());
+  uint32 stackId = 0;
+  for (size_t i = 0; i < renameWithVectorStacks.size(); ++i) {
+    if (renameWithVectorStacks.at(i) == nullptr) {
+      continue;
+    }
+    origStackSize[i] = std::make_pair(renameWithVectorStacks.at(i)->size(), OStIdx(i));
+    ++stackId;
+  }
+}
+
+void MapVersionStacks::RecordCurrentStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) {
+  origStackSize.resize(renameWithMapStacks.size());
+  uint32 stackId = 0;
+  for (auto &ost2stack : std::as_const(renameWithMapStacks)) {
+    origStackSize[stackId] = std::make_pair(ost2stack.second->size(), ost2stack.first);
+    ++stackId;
+  }
+}
+
+void VectorVersionStacks::RecoverStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) {
+  for (size_t i = 1; i < renameWithVectorStacks.size(); ++i) {
+    if (renameWithVectorStacks.at(i) == nullptr) {
+      continue;
+    }
+    while (renameWithVectorStacks.at(i)->size() > origStackSize[i].first) {
+      renameWithVectorStacks.at(i)->pop();
+    }
+  }
+}
+
+void MapVersionStacks::RecoverStackSize(std::vector<std::pair<uint32, OStIdx >> &origStackSize) {
+  uint32 stackId = 0;
+  for (auto &ost2stack : std::as_const(renameWithMapStacks)) {
+    ASSERT(ost2stack.first == origStackSize[stackId].second,
+           "OStIdx must be equal, element of renameWithMapStacks should not be changed");
+    while (ost2stack.second->size() > origStackSize[stackId].first) {
+      ost2stack.second->pop();
+    }
+    ++stackId;
+  }
+}
+
+void MeSSAUpdate::InsertPhis() {
+  auto it = updateCands.begin();
+  std::set<uint32> dfSet;
+  auto cfg = func.GetCfg();
+  for (; it != updateCands.end(); ++it) {
+    const OriginalSt *ost = ssaTab.GetOriginalStFromID(it->first);
+    if (ost->IsVolatile()) { // volatile variables will not have ssa form.
+      continue;
+    }
+    dfSet.clear();
+    for (const auto &bbId : *it->second) {
+      dfSet.insert(dom.GetIterDomFrontier(bbId.GetIdx()).cbegin(), dom.GetIterDomFrontier(bbId.GetIdx()).cend());
+    }
+    for (const auto &bbId : dfSet) {
+      // insert a phi node
+      BB *bb = cfg->GetBBFromID(BBId(bbId));
+      ASSERT_NOT_NULL(bb);
+      auto phiListIt = bb->GetMePhiList().find(it->first);
+      if (phiListIt != bb->GetMePhiList().end()) {
+        phiListIt->second->SetIsLive(true);
+        if (phiListIt->second->GetOpnds().size() != bb->GetPred().size()) {
+          phiListIt->second->GetOpnds().resize(bb->GetPred().size());
+        }
+        continue;
+      }
+      auto *phiMeNode = irMap.NewInPool<MePhiNode>();
+      phiMeNode->SetDefBB(bb);
+      phiMeNode->GetOpnds().resize(bb->GetPred().size());
+      auto *ost1 = ssaTab.GetOriginalStFromID(it->first);
+      CHECK_FATAL(ost1, "ost1 is nullptr!");
+      ScalarMeExpr *newScalar =
+          (ost1->IsSymbolOst()) ? irMap.CreateVarMeExprVersion(ost1) : irMap.CreateRegMeExprVersion(*ost1);
+      phiMeNode->UpdateLHS(*newScalar);
+      (void)bb->GetMePhiList().insert(std::make_pair(it->first, phiMeNode));
+    }
+    // initialize its rename stack
+    rename->InitRenameStack(it->first);
+  }
+}
+
+void MeSSAUpdate::RenamePhi(const BB &bb) {
+  if (bb.GetMePhiList().empty()) {
+    return;
+  }
+  for (auto &pair : bb.GetMePhiList()) {
+    auto *renameStack = rename->GetRenameStack(pair.first);
+    if (renameStack == nullptr) {
+      continue;
+    }
+    // if there is existing phi result node
+    MePhiNode *phi = pair.second;
+    phi->SetIsLive(true);  // always make it live, for correctness
+    renameStack->push(phi->GetLHS());
+  }
+}
+
+// changed has been initialized to false by caller
+MeExpr *MeSSAUpdate::RenameExpr(MeExpr &meExpr, bool &changed) {
+  bool needRehash = false;
+  switch (meExpr.GetMeOp()) {
+    case kMeOpVar:
+    case kMeOpReg: {
+      auto &varExpr = static_cast<ScalarMeExpr&>(meExpr);
+      auto *renameStack = rename->GetRenameStack(varExpr.GetOstIdx());
+      if (renameStack == nullptr) {
+        return &meExpr;
+      }
+      ScalarMeExpr *curVar = renameStack->top();
+      if (&varExpr == curVar) {
+        return &meExpr;
+      }
+      changed = true;
+      return curVar;
+    }
+    case kMeOpIvar: {
+      auto &ivarMeExpr = static_cast<IvarMeExpr&>(meExpr);
+      MeExpr *newbase = RenameExpr(*ivarMeExpr.GetBase(), needRehash);
+      std::vector<ScalarMeExpr*> newMuList;
+      for (auto *mu : ivarMeExpr.GetMuList()) {
+        if (mu == nullptr) {
+          continue;
+        }
+        auto *newMu = RenameExpr(*mu, needRehash);
+        newMuList.push_back(static_cast<ScalarMeExpr*>(newMu));
+      }
+      if (needRehash) {
+        changed = true;
+        IvarMeExpr newMeExpr(&irMap.GetIRMapAlloc(), kInvalidExprID, ivarMeExpr);
+        newMeExpr.SetBase(newbase);
+        newMeExpr.SetMuList(newMuList);
+        newMeExpr.SetDefStmt(nullptr);
+        return irMap.HashMeExpr(newMeExpr);
+      }
+      return &meExpr;
+    }
+    case kMeOpOp: {
+      auto &meOpExpr = static_cast<OpMeExpr&>(meExpr);
+      OpMeExpr newMeExpr(kInvalidExprID, meExpr.GetOp(), meOpExpr.GetPrimType(), meOpExpr.GetNumOpnds());
+      newMeExpr.SetOpnd(0, RenameExpr(*meOpExpr.GetOpnd(0), needRehash));
+      if (meOpExpr.GetOpnd(1) != nullptr) {
+        newMeExpr.SetOpnd(1, RenameExpr(*meOpExpr.GetOpnd(1), needRehash));
+        if (meOpExpr.GetOpnd(2) != nullptr) {
+          newMeExpr.SetOpnd(2, RenameExpr(*meOpExpr.GetOpnd(2), needRehash));
+        }
+      }
+      if (needRehash) {
+        changed = true;
+        newMeExpr.SetOpndType(meOpExpr.GetOpndType());
+        newMeExpr.SetBitsOffSet(meOpExpr.GetBitsOffSet());
+        newMeExpr.SetBitsSize(meOpExpr.GetBitsSize());
+        newMeExpr.SetTyIdx(meOpExpr.GetTyIdx());
+        newMeExpr.SetFieldID(meOpExpr.GetFieldID());
+        newMeExpr.SetHasAddressValue();
+        return irMap.HashMeExpr(newMeExpr);
+      }
+      return &meExpr;
+    }
+    case kMeOpNary: {
+      auto &naryMeExpr = static_cast<NaryMeExpr&>(meExpr);
+      NaryMeExpr newMeExpr(&irMap.GetIRMapAlloc(), kInvalidExprID, meExpr.GetOp(), meExpr.GetPrimType(),
+                           meExpr.GetNumOpnds(), naryMeExpr.GetTyIdx(), naryMeExpr.GetIntrinsic(),
+                           naryMeExpr.GetBoundCheck());
+      for (size_t i = 0; i < naryMeExpr.GetOpnds().size(); ++i) {
+        newMeExpr.GetOpnds().push_back(RenameExpr(*naryMeExpr.GetOpnd(i), needRehash));
+      }
+      if (needRehash) {
+        changed = true;
+        return irMap.HashMeExpr(newMeExpr);
+      }
+      return &meExpr;
+    }
+    default:
+      return &meExpr;
+  }
+}
+
+void MeSSAUpdate::RenameStmts(BB &bb) {
+  for (auto &stmt : bb.GetMeStmts()) {
+    auto *muList = stmt.GetMuList();
+    if (muList != nullptr) {
+      for (auto &mu : *muList) {
+        auto *renameStack = rename->GetRenameStack(mu.first);
+        if (renameStack != nullptr) {
+          mu.second = renameStack->top();
+        }
+      }
+    }
+    // rename the expressions
+    for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+      bool changed = false;
+      stmt.SetOpnd(static_cast<uint32>(i), RenameExpr(*stmt.GetOpnd(i), changed));
+      // if base of iassign's ivar is changed, a new ivar is needed
+      if (stmt.GetOp() == OP_iassign && i == 0 && changed) {
+        auto &iAssign = static_cast<IassignMeStmt&>(stmt);
+        IvarMeExpr *iVar = irMap.BuildLHSIvarFromIassMeStmt(iAssign);
+        iAssign.SetLHSVal(iVar);
+      }
+    }
+    // process mayDef
+    MapleMap<OStIdx, ChiMeNode*> *chiList = stmt.GetChiList();
+    if (chiList != nullptr) {
+      for (auto &chi : std::as_const(*chiList)) {
+        auto *renameStack = rename->GetRenameStack(chi.first);
+        if (renameStack != nullptr && chi.second != nullptr) {
+          chi.second->SetRHS(renameStack->top());
+          renameStack->push(chi.second->GetLHS());
+        }
+      }
+    }
+    // process the LHS
+    ScalarMeExpr *lhs = nullptr;
+    if (stmt.GetOp() == OP_dassign || stmt.GetOp() == OP_maydassign || stmt.GetOp() == OP_regassign) {
+      lhs = stmt.GetLHS();
+      CHECK_FATAL(lhs != nullptr, "stmt doesn't have lhs?");
+      auto *renameStack = rename->GetRenameStack(lhs->GetOstIdx());
+      if (renameStack != nullptr) {
+        renameStack->push(lhs);
+      }
+    } else if (kOpcodeInfo.IsCallAssigned(stmt.GetOp())) {
+      MapleVector<MustDefMeNode> *mustDefList = stmt.GetMustDefList();
+      auto mustdefit = mustDefList->begin();
+      for (; mustdefit != mustDefList->end(); ++mustdefit) {
+        lhs = (*mustdefit).GetLHS();
+        CHECK_FATAL(lhs != nullptr, "stmt doesn't have lhs?");
+        auto *renameStack = rename->GetRenameStack(lhs->GetOstIdx());
+        if (renameStack != nullptr) {
+          renameStack->push(lhs);
+        }
+      }
+    }
+  }
+}
+
+void MeSSAUpdate::RenamePhiOpndsInSucc(const BB &bb) {
+  for (BB *succ : bb.GetSucc()) {
+    if (succ->GetMePhiList().empty()) {
+      continue;
+    }
+    auto predIdx = static_cast<size_t>(succ->GetPredIndex(bb));
+    CHECK_FATAL(predIdx < succ->GetPred().size(), "RenamePhiOpndsinSucc: cannot find corresponding pred");
+    for (auto &pair : std::as_const(succ->GetMePhiList())) {
+      auto *renameStack = rename->GetRenameStack(pair.first);
+      if (renameStack == nullptr) {
+        continue;
+      }
+      MePhiNode *phi = pair.second;
+      ScalarMeExpr *curScalar = renameStack->top();
+      if (phi->GetOpnd(predIdx) != curScalar) {
+        phi->SetOpnd(predIdx, curScalar);
+      }
+    }
+  }
+}
+
+void MeSSAUpdate::RenameBB(BB &bb) {
+  // for recording stack height on entering this BB, to  back to same height
+  // when backing up the dominator tree
+  std::vector<std::pair<uint32, OStIdx>> origStackSize;
+  rename->RecordCurrentStackSize(origStackSize);
+
+  RenamePhi(bb);
+  RenameStmts(bb);
+  RenamePhiOpndsInSucc(bb);
+  // recurse down dominator tree in pre-order traversal
+  auto cfg = func.GetCfg();
+  const auto &children = dom.GetDomChildren(bb.GetID());
+  for (const auto &child : children) {
+    RenameBB(*cfg->GetBBFromID(BBId(child)));
+  }
+  // pop stacks back to where they were at entry to this BB
+  rename->RecoverStackSize(origStackSize);
+}
+
+void MeSSAUpdate::InsertOstToSSACands(OStIdx ostIdx, const BB &defBB,
+    std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *ssaCands) {
+  if (ssaCands == nullptr) {
+    return;
+  }
+  auto it = ssaCands->find(ostIdx);
+  if (it == ssaCands->end()) {
+    std::unique_ptr<std::set<BBId>> bbSet = std::make_unique<std::set<BBId>>(std::less<BBId>());
+    bbSet->insert(defBB.GetBBId());
+    ssaCands->emplace(ostIdx, std::move(bbSet));
+  } else {
+    it->second->insert(defBB.GetBBId());
+  }
+}
+
+// Insert ost and def bbs to ssa cands except the updateSSAExceptTheOstIdx.
+void MeSSAUpdate::InsertDefPointsOfBBToSSACands(
+    BB &defBB, std::map<OStIdx, std::unique_ptr<std::set<BBId>>> &ssaCands, const OStIdx updateSSAExceptTheOstIdx) {
+  // Insert the ost of philist to defBB.
+  for (auto &it : std::as_const(defBB.GetMePhiList())) {
+    if (it.first == updateSSAExceptTheOstIdx) {
+      continue;
+    }
+    MeSSAUpdate::InsertOstToSSACands(it.first, defBB, &ssaCands);
+  }
+  // Insert the ost of def points to the def bbs.
+  for (auto &meStmt : defBB.GetMeStmts()) {
+    if (kOpcodeInfo.AssignActualVar(meStmt.GetOp()) && meStmt.GetLHS() != nullptr) {
+      if (meStmt.GetLHS()->GetOstIdx() == updateSSAExceptTheOstIdx) {
+        continue;
+      }
+      MeSSAUpdate::InsertOstToSSACands(meStmt.GetLHS()->GetOstIdx(), defBB, &ssaCands);
+    }
+    if (meStmt.GetChiList() != nullptr) {
+      for (auto &chi : std::as_const(*meStmt.GetChiList())) {
+        auto *lhs = chi.second->GetLHS();
+        const OStIdx &ostIdx = lhs->GetOstIdx();
+        MeSSAUpdate::InsertOstToSSACands(ostIdx, defBB, &ssaCands);
+      }
+    }
+    if (meStmt.GetMustDefList() != nullptr) {
+      for (auto &mustDefNode : *meStmt.GetMustDefList()) {
+        const ScalarMeExpr *lhs = static_cast<const ScalarMeExpr*>(mustDefNode.GetLHS());
+        MeSSAUpdate::InsertOstToSSACands(lhs->GetOstIdx(), defBB, &ssaCands);
+      }
+    }
+  }
+}
+
+void MeSSAUpdate::Run() {
+  VectorVersionStacks renameWithVectorStack;
+  MapVersionStacks renameWithMapStack;
+  // When the number of osts is greater than kOstLimitSize or greater than half of the size of original ost table,
+  // use the RenameWithVectorStack object to update the ssa, otherwise,
+  // use the RenameWithMapStack object to update the ssa.
+  if (updateCands.size() >= kOstLimitSize || updateCands.size() >= ssaTab.GetOriginalStTableSize() / 2) {
+    renameWithVectorStack.ResizeRenameStack(ssaTab.GetOriginalStTableSize());
+    rename = &renameWithVectorStack;
+  } else {
+    rename = &renameWithMapStack;
+  }
+  InsertPhis();
+  // push zero-version varmeexpr nodes to rename stacks
+  rename->InsertZeroVersion2RenameStack(ssaTab, irMap);
+  // recurse down dominator tree in pre-order traversal
+  auto cfg = func.GetCfg();
+  const auto &children = dom.GetDomChildren(cfg->GetCommonEntryBB()->GetID());
+  for (const auto &child : children) {
+    RenameBB(*cfg->GetBBFromID(BBId(child)));
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_ssi.cpp b/src/mapleall/maple_me/src/me_ssi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4f19d103fcdb96935f8be02e73247670ecaf6ab7
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ssi.cpp
@@ -0,0 +1,666 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ssi.h"
+
+namespace maple {
+bool MeSSI::isDebug = false;
+constexpr int kNumOpnds = 2;
+constexpr int kPiStmtUpperBound = 2;
+
+VarMeExpr *MeSSI::CreateNewPiExpr(const MeExpr &opnd) {
+  if (opnd.GetMeOp() == kMeOpConst) {
+    return nullptr;
+  }
+  CHECK_FATAL(opnd.GetMeOp() == kMeOpVar, "must be");
+  OriginalSt *ost = static_cast<const VarMeExpr*>(&opnd)->GetOst();
+  CHECK_NULL_FATAL(ost);
+  CHECK_FATAL(!ost->IsVolatile(), "must be");
+  VarMeExpr *var = irMap->New<VarMeExpr>(irMap->GetExprID(), ost,
+                                         irMap->GetVerst2MeExprTable().size(), opnd.GetPrimType());
+  irMap->SetExprID(irMap->GetExprID() + 1);
+  irMap->GetVerst2MeExprTable().push_back(var);
+  ost->PushbackVersionsIndices(var->GetVstIdx());
+  return var;
+}
+
+void MeSSI::CreateNewPiStmt(VarMeExpr *lhs, MeExpr &rhs, BB &bb, MeStmt &generatedBy, bool isToken) {
+  if (lhs == nullptr) {
+    return;
+  }
+  PiassignMeStmt *meStmt = GetMemPool()->New<PiassignMeStmt>(&GetAllocator());
+  meStmt->SetGeneratedBy(generatedBy);
+  meStmt->SetRHS(*(static_cast<VarMeExpr*>(&rhs)));
+  meStmt->SetLHS(*lhs);
+  meStmt->SetBB(&bb);
+  meStmt->SetIsToken(isToken);
+  lhs->SetDefBy(kDefByStmt);
+  lhs->SetDefStmt(meStmt);
+  bb.InsertPi(*(generatedBy.GetBB()), *meStmt);
+  DefPoint *newDef = GetMemPool()->New<DefPoint>(DefPoint::DefineKind::kDefByPi);
+  newDef->SetDefPi(*meStmt);
+  newDefPoints.push_back(newDef);
+  newDef2Old[newDef] = static_cast<VarMeExpr*>(&rhs);
+}
+
+void MeSSI::CreateNewPiStmt(VarMeExpr *lhs, MeExpr &rhs, MeStmt &generatedBy) {
+  if (lhs == nullptr) {
+    return;
+  }
+  PiassignMeStmt *meStmt = GetMemPool()->New<PiassignMeStmt>(&GetAllocator());
+  meStmt->SetGeneratedBy(generatedBy);
+  meStmt->SetRHS(*(static_cast<VarMeExpr*>(&rhs)));
+  meStmt->SetLHS(*lhs);
+  meStmt->SetBB(generatedBy.GetBB());
+  lhs->SetDefBy(kDefByStmt);
+  lhs->SetDefStmt(meStmt);
+  generatedBy.GetBB()->InsertMeStmtAfter(&generatedBy, meStmt);
+  DefPoint *newDef = GetMemPool()->New<DefPoint>(DefPoint::DefineKind::kDefByPi);
+  newDef->SetDefPi(*meStmt);
+  newDefPoints.push_back(newDef);
+  newDef2Old[newDef] = static_cast<VarMeExpr*>(&rhs);
+}
+
+void MeSSI::AddPiForABCOpt(BB &bb) {
+  CHECK_FATAL(containsBB != nullptr && arrayChecks != nullptr, "must be");
+  auto it = containsBB->find(&bb);
+  if (it == containsBB->end()) {
+    return;
+  }
+  std::vector<MeStmt*> &arryChk = it->second;
+  for (MeStmt *meStmt : arryChk) {
+    NaryMeExpr *naryMeExpr = (*arrayChecks)[meStmt];
+    CHECK_FATAL(naryMeExpr->GetOpnds().size() == kNumOpnds, "must be");
+    MeExpr *opnd1 = naryMeExpr->GetOpnd(0);
+    MeExpr *opnd2 = naryMeExpr->GetOpnd(1);
+    CHECK_FATAL(opnd1->GetMeOp() == kMeOpVar, "must be");
+    CHECK_FATAL(opnd1->GetPrimType() == PTY_ref, "must be");
+    CHECK_FATAL(opnd2->GetMeOp() == kMeOpVar || opnd2->GetMeOp() == kMeOpConst, "must be");
+    VarMeExpr *arrayCheckOpnd2 = CreateNewPiExpr(*opnd2);
+    CreateNewPiStmt(arrayCheckOpnd2, *opnd2, *meStmt);
+  }
+}
+
+NaryMeExpr *MeSSI::GetInstanceOfType(MeExpr &e) {
+  CHECK_FATAL(e.GetMeOp() == kMeOpVar, "must b");
+  VarMeExpr *var = static_cast<VarMeExpr*>(&e);
+  if (var->GetPrimType() != PTY_u1 || var->GetDefBy() != kDefByStmt) {
+    return nullptr;
+  }
+  MeStmt *defStmt = var->GetDefStmt();
+  if (defStmt == nullptr || defStmt->GetOp() != OP_dassign) {
+    return nullptr;
+  }
+  MeExpr *expr = defStmt->GetRHS();
+  if (expr == nullptr || expr->GetOp() != OP_intrinsicopwithtype) {
+    return nullptr;
+  }
+  auto *callNode = safe_cast<NaryMeExpr>(expr);
+  if (callNode == nullptr || callNode->GetIntrinsic() != INTRN_JAVA_INSTANCE_OF) {
+    return nullptr;
+  }
+  if (callNode->GetOpnd(0)->GetMeOp() != kMeOpVar && callNode->GetOpnd(0)->GetMeOp() != kMeOpIvar) {
+    return nullptr;
+  }
+  return callNode;
+}
+
+uint8_t MeSSI::AnalysisBranch(MeStmt &meStmt) {
+  CHECK_FATAL(meStmt.IsCondBr(), "must be");
+  auto *brMeStmt = static_cast<CondGotoMeStmt*>(&meStmt);
+  MeExpr *meCmp = brMeStmt->GetOpnd();
+  uint8_t result = 0;
+  if (meCmp->GetMeOp() == kMeOpVar) {
+    NaryMeExpr *instanceofType = GetInstanceOfType(*meCmp);
+    if (instanceofType != nullptr) {
+      result = result | kCheckCastOpt;
+    }
+  } else if (meCmp->GetMeOp() == kMeOpOp) {
+    auto *opMeExpr = static_cast<OpMeExpr*>(meCmp);
+    if (opMeExpr->GetNumOpnds() != kNumOpnds) {
+      return result;
+    }
+    if (opMeExpr->GetOp() != OP_ge && opMeExpr->GetOp() != OP_le &&
+        opMeExpr->GetOp() != OP_lt && opMeExpr->GetOp() != OP_gt &&
+        opMeExpr->GetOp() != OP_ne && opMeExpr->GetOp() != OP_eq) {
+      return result;
+    }
+    MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+    MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+    if ((opnd1->GetMeOp() != kMeOpVar && opnd1->GetMeOp() != kMeOpConst) ||
+        (opnd2->GetMeOp() != kMeOpVar && opnd2->GetMeOp() != kMeOpConst)) {
+      return result;
+    }
+    if (IsPrimitivePureScalar(opnd1->GetPrimType()) && IsPrimitivePureScalar(opnd2->GetPrimType())) {
+      return result | kArrayBoundsCheckOpt;
+    }
+    if (opMeExpr->GetOp() == OP_ne || opMeExpr->GetOp() == OP_eq) {
+      CHECK_FATAL(IsAddress(opnd1->GetPrimType()) == IsPrimitivePoint(opnd1->GetPrimType()), "MUST BE");
+      CHECK_FATAL(IsAddress(opnd2->GetPrimType()) == 1, "MUST BE");
+      return result | kNullPointerCheckOpt | kCondBaseRCOpt;
+    }
+  }
+  return result;
+}
+
+void MeSSI::AddNullPointerInfoForVar() const {
+  CHECK_FATAL(false, "NYI");
+}
+
+void MeSSI::InsertPiNodes() {
+  for (auto bIt = cfg->valid_begin(), eIt = cfg->valid_end(); bIt != eIt; ++bIt) {
+    BB *bb = *bIt;
+    if (bb->GetKind() == kBBCondGoto) {
+      uint8_t careOpt = AnalysisBranch(*(bb->GetLastMe()));
+      SSIType careBranch{};
+      careBranch.SetOptType(careOpt & ssiType.GetOptType());
+      auto *brMeStmt = static_cast<CondGotoMeStmt*>(bb->GetLastMe());
+      CHECK_FATAL(brMeStmt, "brMeStmt is nullptr");
+      BB *brTarget = bb->GetSucc(1);
+      BB *brFallThru = bb->GetSucc(0);
+      CHECK_FATAL(brMeStmt->GetOffset() == brTarget->GetBBLabel(), "must be");
+      if (careBranch.GetOptKindType(kCheckCastOpt)) {
+        NaryMeExpr *instanceofType = GetInstanceOfType(*brMeStmt->GetOpnd());
+        MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(instanceofType->GetTyIdx());
+        ASSERT_NOT_NULL(instanceofType);
+        MeExpr *opnd = instanceofType->GetOpnd(0);
+        if (opnd->GetMeOp() == kMeOpIvar) {
+          CHECK_FATAL(!static_cast<IvarMeExpr*>(opnd)->HasMultipleMu(), "NYI");
+          opnd = static_cast<IvarMeExpr*>(opnd)->GetUniqueMu();
+        }
+        VarMeExpr *brTargetNewOpnd = CreateNewPiExpr(*opnd);
+        bool isToken = (brMeStmt->GetOp() == OP_brtrue);
+        CreateNewPiStmt(brTargetNewOpnd, *opnd, *brTarget, *brMeStmt, true);
+        VarMeExpr *brFallThruNewOpnd = CreateNewPiExpr(*opnd);
+        CreateNewPiStmt(brFallThruNewOpnd, *opnd, *brFallThru, *brMeStmt, false);
+        // Add Type Info For Var
+        if (isToken) {
+          inferredType[brTargetNewOpnd] = mirType;
+        } else {
+          inferredType[brFallThruNewOpnd] = mirType;
+        }
+      } else if (careBranch.GetOptType() != 0) {
+        CHECK_FATAL(brMeStmt->GetOpnd()->GetMeOp() == kMeOpOp, "must be");
+        auto *opMeExpr = static_cast<OpMeExpr*>(brMeStmt->GetOpnd());
+        MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+        MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+        VarMeExpr *brTargetNewOpnd1 = CreateNewPiExpr(*opnd1);
+        VarMeExpr *brTargetNewOpnd2 = CreateNewPiExpr(*opnd2);
+        CreateNewPiStmt(brTargetNewOpnd1, *opnd1, *brTarget, *brMeStmt, true);
+        CreateNewPiStmt(brTargetNewOpnd2, *opnd2, *brTarget, *brMeStmt, true);
+        VarMeExpr *brFallThruNewOpnd1 = CreateNewPiExpr(*opnd1);
+        VarMeExpr *brFallThruNewOpnd2 = CreateNewPiExpr(*opnd2);
+        CreateNewPiStmt(brFallThruNewOpnd1, *opnd1, *brFallThru, *brMeStmt, false);
+        CreateNewPiStmt(brFallThruNewOpnd2, *opnd2, *brFallThru, *brMeStmt, false);
+        if (careBranch.GetOptKindType(kNullPointerCheckOpt) || careBranch.GetOptKindType(kCondBaseRCOpt)) {
+          AddNullPointerInfoForVar();
+        }
+      }
+    }
+    if (ssiType.GetOptKindType(kArrayBoundsCheckOpt)) {
+      AddPiForABCOpt(*bb);
+    }
+  }
+}
+
+bool MeSSI::ExistedPhiNode(BB &bb, const VarMeExpr &rhs) {
+  return bb.GetMePhiList().find(rhs.GetOstIdx()) != bb.GetMePhiList().end();
+}
+
+bool MeSSI::ExistedPiNode(BB &bb, BB &parentBB, const VarMeExpr &rhs) {
+  MapleMap<BB*, std::vector<PiassignMeStmt*>> &piList = bb.GetPiList();
+  auto it = piList.find(&parentBB);
+  if (it == piList.end()) {
+    return false;
+  }
+  std::vector<PiassignMeStmt*> &piStmts = it->second;
+  CHECK_FATAL(!piStmts.empty(), "should not be empty");
+  CHECK_FATAL(piStmts.size() <= kPiStmtUpperBound, "must be");
+  PiassignMeStmt *pi1 = piStmts.at(0);
+  if (pi1->GetLHS()->GetOst() == rhs.GetOst()) {
+    return true;
+  }
+  if (piStmts.size() == kPiStmtUpperBound) {
+    PiassignMeStmt *pi2 = piStmts.at(1);
+    if (pi2->GetLHS()->GetOst() == rhs.GetOst()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void MeSSI::CreatePhi(VarMeExpr &rhs, BB &dfBB) {
+  VarMeExpr *phiNewLHS = CreateNewPiExpr(rhs);
+  ASSERT_NOT_NULL(phiNewLHS);
+  MePhiNode *newPhi = GetMemPool()->New<MePhiNode>(phiNewLHS, &GetAllocator());
+  newPhi->SetDefBB(&dfBB);
+  newPhi->GetOpnds().resize(dfBB.GetPred().size(), &rhs);
+  newPhi->SetPiAdded();
+  dfBB.GetMePhiList().insert(std::make_pair(phiNewLHS->GetOstIdx(), newPhi));
+  DefPoint *newDef = GetMemPool()->New<DefPoint>(DefPoint::DefineKind::kDefByPhi);
+  newDef->SetDefPhi(*newPhi);
+  newDefPoints.push_back(newDef);
+  newDef2Old[newDef] = &rhs;
+}
+
+void MeSSI::InsertPhiNodes() {
+  for (size_t i = 0; i < newDefPoints.size(); ++i) {
+    DefPoint *newDefStmt = newDefPoints[i];
+    BB *newDefBB = newDefStmt->GetBB();
+    CHECK_NULL_FATAL(newDefBB);
+    VarMeExpr *rhs = newDefStmt->GetRHS();
+    if (newDefStmt->IsPiStmt()) {
+      BB *genByBB = newDefStmt->GetGeneratedByBB();
+      if (!dom->Dominate(*genByBB, *newDefBB)) {
+        if (!ExistedPhiNode(*newDefBB, *rhs)) {
+          CreatePhi(*rhs, *newDefBB);
+        }
+        continue;
+      }
+    }
+    BB *oldDefBB = rhs->DefByBB();
+    if (oldDefBB == nullptr) {
+      oldDefBB = cfg->GetCommonEntryBB();
+      CHECK_FATAL(rhs->IsZeroVersion(), "must be");
+    }
+    CHECK_NULL_FATAL(oldDefBB);
+    auto &dfs = dom->GetDomFrontier(newDefBB->GetBBId());
+    for (auto bbID : dfs) {
+      BB *dfBB = cfg->GetBBFromID(BBId(bbID));
+      if (!dom->Dominate(*oldDefBB, *dfBB)) {
+        auto &dfsTmp = dom->GetDomFrontier(oldDefBB->GetBBId());
+        CHECK_FATAL(dfsTmp.find(bbID) != dfsTmp.end(), "must be");
+        continue;
+      }
+      if (ExistedPhiNode(*dfBB, *rhs)) {
+        continue;
+      }
+      CreatePhi(*rhs, *dfBB);
+    }
+  }
+}
+
+void MeSSI::RenameStartPiBr(DefPoint &newDefPoint) {
+  const OStIdx &ostIdx = newDefPoint.GetOStIdx();
+  BB *newDefBB = newDefPoint.GetBB();
+  if (!ExistedPhiNode(*(newDefPoint.GetBB()), *(newDefPoint.GetRHS()))) {
+    RenameStartPhi(newDefPoint);
+    return;
+  }
+  MePhiNode* phi = newDefBB->GetMePhiList()[ostIdx];
+  BB *genByBB = newDefPoint.GetGeneratedByBB();
+  size_t index = 0;
+  while (index < newDefBB->GetPred().size()) {
+    if (newDefBB->GetPred(index) == genByBB) {
+      break;
+    }
+    ++index;
+  }
+  CHECK_FATAL(index < newDefBB->GetPred().size(), "must be");
+  ScalarMeExpr *oldVar = phi->GetOpnd(index);
+  phi->SetOpnd(index, newDefPoint.GetLHS());
+  if (!phi->IsPiAdded()) {
+    if (modifiedPhi.find(phi) == modifiedPhi.end()) {
+      modifiedPhi[phi] = std::vector<ScalarMeExpr*>(phi->GetOpnds().size(), nullptr);
+    }
+    if (modifiedPhi[phi][index] == nullptr) {
+      modifiedPhi[phi][index] = oldVar;
+    }
+  }
+}
+
+void MeSSI::RenameStartPiArray(DefPoint &newDefPoint) {
+  BB *newDefBB = newDefPoint.GetBB();
+  MeStmt *piStmt = newDefPoint.GetPiStmt();
+  if (piStmt != newDefBB->GetLastMe()) {
+    for (MeStmt *meStmt = piStmt->GetNext(); meStmt != nullptr; meStmt = meStmt->GetNext()) {
+      if (ReplaceStmt(*meStmt, *(newDefPoint.GetLHS()), *(newDef2Old[&newDefPoint]))) {
+        return;
+      }
+    }
+  }
+  ReplacePiPhiInSuccs(*newDefBB, *(newDefPoint.GetLHS()));
+  const auto &children = dom->GetDomChildren(newDefBB->GetID());
+  for (const auto &child : children) {
+    ReplaceBB(*(cfg->GetBBFromID(BBId(child))), *newDefBB, newDefPoint);
+  }
+}
+
+void MeSSI::RenameStartPhi(DefPoint &newDefPoint) {
+  BB *newDefBB = newDefPoint.GetBB();
+  for (MeStmt &meStmt : newDefBB->GetMeStmts()) {
+    if (ReplaceStmt(meStmt, *newDefPoint.GetLHS(), *newDef2Old[&newDefPoint])) {
+      return;
+    }
+  }
+  ReplacePiPhiInSuccs(*newDefBB, *(newDefPoint.GetLHS()));
+  const auto &children = dom->GetDomChildren(newDefBB->GetID());
+  for (const auto &child : children) {
+    ReplaceBB(*(cfg->GetBBFromID(BBId(child))), *newDefBB, newDefPoint);
+  }
+}
+
+void MeSSI::ReplacePiPhiInSuccs(BB &bb, VarMeExpr &newVar) {
+  for (BB *succBB : bb.GetSucc()) {
+    MapleMap<BB*, std::vector<PiassignMeStmt*>> &piList = succBB->GetPiList();
+    auto it1 = piList.find(&bb);
+    if (it1 != piList.end()) {
+      std::vector<PiassignMeStmt*> &piStmts = it1->second;
+      // the size of pi statements must be 1 or 2
+      CHECK_FATAL(!piStmts.empty(), "should not be empty");
+      CHECK_FATAL(piStmts.size() <= kPiStmtUpperBound, "must be");
+      PiassignMeStmt *pi1 = piStmts.at(0);
+      if (pi1->GetLHS()->GetOst() == newVar.GetOst()) {
+        pi1->SetRHS(newVar);
+        continue;
+      }
+      if (piStmts.size() == kPiStmtUpperBound) {
+        PiassignMeStmt *pi2 = piStmts.at(1);
+        if (pi2->GetLHS()->GetOst() == newVar.GetOst()) {
+          pi2->SetRHS(newVar);
+          continue;
+        }
+      }
+    }
+    size_t index = 0;
+    while (index < succBB->GetPred().size()) {
+      if (succBB->GetPred(index) == &bb) {
+        break;
+      }
+      ++index;
+    }
+    CHECK_FATAL(index < succBB->GetPred().size(), "must be");
+    MapleMap<OStIdx, MePhiNode*> &phiList = succBB->GetMePhiList();
+    auto it2 = phiList.find(newVar.GetOstIdx());
+    if (it2 != phiList.end()) {
+      MePhiNode *phi = it2->second;
+      ScalarMeExpr *oldVar = phi->GetOpnd(index);
+      phi->SetOpnd(index, &newVar);
+      if (!phi->IsPiAdded()) {
+        if (modifiedPhi.find(phi) == modifiedPhi.end()) {
+          modifiedPhi[phi] = std::vector<ScalarMeExpr*>(phi->GetOpnds().size(), nullptr);
+        }
+        if (modifiedPhi[phi][index] == nullptr) {
+          modifiedPhi[phi][index] = oldVar;
+        }
+      }
+    }
+  }
+}
+
+MeExpr *MeSSI::NewMeExpr(MeExpr &meExpr) {
+  switch (meExpr.GetMeOp()) {
+    case kMeOpIvar: {
+      auto &ivarMeExpr = static_cast<IvarMeExpr&>(meExpr);
+      IvarMeExpr *newIvarExpr = GetMemPool()->New<IvarMeExpr>(&irMap->GetIRMapAlloc(), irMap->GetExprID(), ivarMeExpr);
+      irMap->SetExprID(irMap->GetExprID() + 1);
+      return newIvarExpr;
+    }
+    case kMeOpOp: {
+      auto &opMeExpr = static_cast<OpMeExpr&>(meExpr);
+      OpMeExpr *newOpMeExpr = GetMemPool()->New<OpMeExpr>(opMeExpr, irMap->GetExprID());
+      irMap->SetExprID(irMap->GetExprID() + 1);
+      return newOpMeExpr;
+    }
+    case kMeOpNary: {
+      auto &naryMeExpr = static_cast<NaryMeExpr&>(meExpr);
+      NaryMeExpr *newNaryMeExpr = GetMemPool()->New<NaryMeExpr>(&GetAllocator(), irMap->GetExprID(), naryMeExpr);
+      irMap->SetExprID(irMap->GetExprID() + 1);
+      return newNaryMeExpr;
+    }
+    default:
+      CHECK_FATAL(false, "impossible");
+  }
+}
+
+MeExpr *MeSSI::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &oldVar, MeExpr &repExpr) {
+  if (origExpr.IsLeaf()) {
+    return &origExpr;
+  }
+  switch (origExpr.GetMeOp()) {
+    case kMeOpOp: {
+      auto &opMeExpr = static_cast<OpMeExpr&>(origExpr);
+      OpMeExpr newMeExpr(opMeExpr, kInvalidExprID);
+      bool needRehash = false;
+      for (uint32 i = 0; i < kOperandNumTernary; ++i) {
+        if (opMeExpr.GetOpnd(i) == nullptr) {
+          continue;
+        }
+        if (opMeExpr.GetOpnd(i) == &oldVar) {
+          needRehash = true;
+          newMeExpr.SetOpnd(i, &repExpr);
+        } else if (!opMeExpr.GetOpnd(i)->IsLeaf()) {
+          newMeExpr.SetOpnd(i, ReplaceMeExprExpr(*newMeExpr.GetOpnd(i), oldVar, repExpr));
+          if (newMeExpr.GetOpnd(i) != opMeExpr.GetOpnd(i)) {
+            needRehash = true;
+          }
+        }
+      }
+      return needRehash ? NewMeExpr(newMeExpr) : &origExpr;
+    }
+    case kMeOpNary: {
+      auto &naryMeExpr = static_cast<NaryMeExpr&>(origExpr);
+      NaryMeExpr newMeExpr(&GetAllocator(), kInvalidExprID, naryMeExpr);
+      const MapleVector<MeExpr*> &opnds = naryMeExpr.GetOpnds();
+      bool needRehash = false;
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        if (opnd == &oldVar) {
+          newMeExpr.SetOpnd(i, &repExpr);
+          needRehash = true;
+        } else if (!opnd->IsLeaf()) {
+          newMeExpr.SetOpnd(i, ReplaceMeExprExpr(*newMeExpr.GetOpnd(i), oldVar, repExpr));
+          if (newMeExpr.GetOpnd(i) != opnd) {
+            needRehash = true;
+          }
+        }
+      }
+      return needRehash ? NewMeExpr(newMeExpr) : &origExpr;
+    }
+    case kMeOpIvar: {
+      auto &ivarExpr = static_cast<IvarMeExpr&>(origExpr);
+      IvarMeExpr newMeExpr(&irMap->GetIRMapAlloc(), kInvalidExprID, ivarExpr);
+      bool needRehash = false;
+      if (ivarExpr.GetBase() == &oldVar) {
+        newMeExpr.SetBase(&repExpr);
+        needRehash = true;
+      } else if (!ivarExpr.GetBase()->IsLeaf()) {
+        newMeExpr.SetBase(ReplaceMeExprExpr(*newMeExpr.GetBase(), oldVar, repExpr));
+        if (newMeExpr.GetBase() != ivarExpr.GetBase()) {
+          needRehash = true;
+        }
+      }
+      size_t i = 0;
+      for (auto *mu : ivarExpr.GetMuList()) {
+        if (mu == &oldVar) {
+          CHECK_FATAL(repExpr.GetMeOp() == kMeOpVar, "must be");
+          newMeExpr.SetMuItem(i, static_cast<VarMeExpr*>(&repExpr));
+          needRehash = true;
+        }
+        ++i;
+      }
+      return needRehash ? NewMeExpr(newMeExpr) : &origExpr;
+    }
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+}
+
+bool MeSSI::ReplaceMeExprStmtOpnd(uint32 opndID, MeStmt &meStmt, MeExpr &oldVar, MeExpr &newVar, bool update) {
+  MeExpr *opnd = meStmt.GetOpnd(opndID);
+  bool isFromIassign = (meStmt.GetOp() == OP_iassign) && (opndID == 0);
+  if (isFromIassign) {
+    opnd = static_cast<IassignMeStmt*>(&meStmt)->GetLHSVal();
+  }
+  bool replaced = false;
+  MeExpr *newExpr = nullptr;
+  if (opnd == &oldVar) {
+    if (isFromIassign) {
+      static_cast<IassignMeStmt*>(&meStmt)->SetLHSVal(static_cast<IvarMeExpr*>(&newVar));
+    } else {
+      meStmt.SetOpnd(opndID, &newVar);
+    }
+    replaced = true;
+  } else if (!opnd->IsLeaf()) {
+    newExpr = ReplaceMeExprExpr(*opnd, oldVar, newVar);
+    replaced = (newExpr != opnd);
+    if (isFromIassign) {
+      static_cast<IassignMeStmt*>(&meStmt)->SetLHSVal(static_cast<IvarMeExpr*>(newExpr));
+    } else {
+      meStmt.SetOpnd(opndID, newExpr);
+    }
+  }
+  if (replaced && update) {
+    if (modifiedStmt.find(std::make_pair(&meStmt, opndID)) == modifiedStmt.end()) {
+      modifiedStmt[std::make_pair(&meStmt, opndID)] = opnd;
+    }
+  }
+  return replaced;
+}
+
+bool MeSSI::ReplaceStmtWithNewVar(MeStmt &meStmt, MeExpr &oldVar, MeExpr &newVar, bool update) {
+  switch (meStmt.GetOp()) {
+    case OP_dassign:
+    case OP_maydassign:
+    case OP_brtrue:
+    case OP_brfalse: {
+      return ReplaceMeExprStmtOpnd(0, meStmt, oldVar, newVar, update);
+    }
+    case OP_iassign: {
+      bool baseIsReplaced = ReplaceMeExprStmtOpnd(0, meStmt, oldVar, newVar, update);
+      bool rhsReplaced = ReplaceMeExprStmtOpnd(1, meStmt, oldVar, newVar, update);
+      return baseIsReplaced || rhsReplaced;
+    }
+    case OP_intrinsiccallwithtype: {
+      auto &callNode = static_cast<IntrinsiccallMeStmt&>(meStmt);
+      if (callNode.GetIntrinsic() != INTRN_JAVA_CHECK_CAST) {
+        break;
+      }
+      return ReplaceMeExprStmtOpnd(0, meStmt, oldVar, newVar, update);
+    }
+    case OP_regassign: {
+      CHECK_FATAL(false, "should not happen");
+    }
+    default: {
+      break;
+    }
+  }
+  return false;
+}
+
+bool MeSSI::ReplaceStmt(MeStmt &meStmt, VarMeExpr &newVar, VarMeExpr &oldVar) {
+  if (meStmt.GetOp() == OP_piassign) {
+    auto *pi = static_cast<PiassignMeStmt*>(&meStmt);
+    if (pi->GetRHS() == &oldVar) {
+      pi->SetRHS(newVar);
+    }
+  } else {
+    (void)ReplaceStmtWithNewVar(meStmt, oldVar, newVar, true);
+  }
+  const OStIdx &ostIdx = newVar.GetOstIdx();
+  MapleMap<OStIdx, ChiMeNode*> *chiList = meStmt.GetChiList();
+  if (chiList != nullptr && chiList->find(ostIdx) != chiList->end()) {
+    return true;
+  }
+  MeExpr *lhs = meStmt.GetAssignedLHS();
+  if (lhs != nullptr && lhs->GetMeOp() == kMeOpVar && static_cast<VarMeExpr*>(lhs)->GetOstIdx() == ostIdx) {
+    return true;
+  }
+  if (meStmt.GetOp() != OP_dassign) {
+    return false;
+  }
+  lhs = meStmt.GetLHS();
+  return (lhs != nullptr && lhs->GetMeOp() == kMeOpVar && static_cast<VarMeExpr*>(lhs)->GetOstIdx() == ostIdx);
+}
+
+void MeSSI::Rename() {
+  for (size_t i = 0; i < newDefPoints.size(); ++i) {
+    DefPoint *newDefStmt = newDefPoints[i];
+    visitedBBs.clear();
+    if (newDefStmt->IsPiStmt()) {
+      if (newDefStmt->IsGeneratedByBr()) {
+        RenameStartPiBr(*newDefStmt);
+      } else {
+        RenameStartPiArray(*newDefStmt);
+      }
+    } else {
+      RenameStartPhi(*newDefStmt);
+    }
+  }
+}
+
+void MeSSI::ReplaceBB(BB &bb, BB &parentBB, DefPoint &newDefPoint) {
+  if (visitedBBs.find(&bb) != visitedBBs.end()) {
+    return;
+  }
+  visitedBBs.insert(&bb);
+  if (ExistedPhiNode(bb, *(newDefPoint.GetLHS())) || ExistedPiNode(bb, parentBB, *(newDefPoint.GetLHS()))) {
+    return;
+  }
+  for (MeStmt &meStmt : bb.GetMeStmts()) {
+    if (ReplaceStmt(meStmt, *(newDefPoint.GetLHS()), *(newDef2Old[&newDefPoint]))) {
+      return;
+    }
+  }
+  ReplacePiPhiInSuccs(bb, *(newDefPoint.GetLHS()));
+  const auto &children = dom->GetDomChildren(bb.GetID());
+  for (const auto &child : children) {
+    ReplaceBB(*(cfg->GetBBFromID(BBId(child))), bb, newDefPoint);
+  }
+}
+
+void MeSSI::RemoveExtraNodes() {
+  for (DefPoint *defP : newDefPoints) {
+    defP->RemoveFromBB();
+  }
+  for (auto pair : modifiedStmt) {
+    MeStmt *meStmt = pair.first.first;
+    MeExpr *newVar = nullptr;
+    if ((meStmt->GetOp() == OP_iassign) && (pair.first.second == 0)) {
+      newVar = static_cast<IassignMeStmt*>(meStmt)->GetLHSVal();
+    } else {
+      newVar = meStmt->GetOpnd(pair.first.second);
+    }
+    MeExpr *oldVar = pair.second;
+    bool replaced = ReplaceStmtWithNewVar(*meStmt, *newVar, *oldVar, false);
+    CHECK_FATAL(replaced, "must be");
+  }
+  for (auto pair : modifiedPhi) {
+    MePhiNode *phi = pair.first;
+    for (size_t i = 0; i < pair.second.size(); ++i) {
+      size_t index = i;
+      ScalarMeExpr *oldVar = pair.second[i];
+      if (oldVar != nullptr) {
+        phi->SetOpnd(index, oldVar);
+      }
+    }
+  }
+}
+
+MIRType *MeSSI::GetInferredType(MeExpr *expr) {
+  if (inferredType.find(expr) == inferredType.end()) {
+    return nullptr;
+  }
+  return inferredType[expr];
+}
+
+void MeSSI::ConvertToSSI() {
+  InsertPiNodes();
+  InsertPhiNodes();
+  Rename();
+}
+void MeSSI::ConvertToSSA() {
+  RemoveExtraNodes();
+}
+}
diff --git a/src/mapleall/maple_me/src/me_ssu_pre.cpp b/src/mapleall/maple_me/src/me_ssu_pre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..08cbf90cffd018df6c4d1cd613768636fe9675f5
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_ssu_pre.cpp
@@ -0,0 +1,570 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_ssu_pre.h"
+
+namespace maple {
+#define JAVALANG (mirmodule->IsJavaModule())
+
+// ================ Step 5: Finalize ================
+void MeSSUPre::Finalize() {
+  std::vector<SOcc*> anticipatedDefVec(classCount + 1, nullptr);
+  // preorder traversal of post-dominator tree
+  for (SOcc *occ : allOccs) {
+    size_t classId = static_cast<size_t>(occ->GetClassId());
+    switch (occ->GetOccTy()) {
+      case kSOccLambda: {
+        auto *lambdaOcc = static_cast<SLambdaOcc*>(occ);
+        if (lambdaOcc->WillBeAnt()) {
+          anticipatedDefVec[classId] = lambdaOcc;
+        }
+        break;
+      }
+      case kSOccReal: {
+        auto *realOcc = static_cast<SRealOcc*>(occ);
+        if (anticipatedDefVec[classId] == nullptr || !anticipatedDefVec[classId]->IsPostDominate(pdom, occ)) {
+          realOcc->SetRedundant(false);
+          anticipatedDefVec[classId] = realOcc;
+        } else {
+          realOcc->SetRedundant(true);
+        }
+        break;
+      }
+      case kSOccLambdaRes: {
+        auto *lambdaResOcc = static_cast<SLambdaResOcc*>(occ);
+        const SLambdaOcc *lambdaOcc = lambdaResOcc->GetUseLambdaOcc();
+        if (lambdaOcc->WillBeAnt()) {
+          if (lambdaResOcc->GetUse() == nullptr || (!lambdaResOcc->GetHasRealUse() &&
+                                                    lambdaResOcc->GetUse()->GetOccTy() == kSOccLambda &&
+                                                    !static_cast<SLambdaOcc*>(lambdaResOcc->GetUse())->WillBeAnt())) {
+            // insert a store
+            BB *insertBB = &lambdaResOcc->GetBB();
+            if (insertBB->GetAttributes(kBBAttrIsCatch)) {
+              if (preKind == kDecrefPre) {
+                (void)catchBlocks2Insert.insert(insertBB->GetBBId());
+              } // else { kStorePre: omit insertion at entry of catch blocks }
+              break;
+            }
+            if (lambdaResOcc->GetBB().GetPred().size() != 1) {  // critical edge
+              if (preKind != kDecrefPre && preKind != kSecondDecrefPre) {
+                CHECK_FATAL(false, "MeSSUPre::Finalize: insertion at critical edge");
+                ASSERT_NOT_NULL(workCand);
+                workCand->SetHasCriticalEdge(true);
+                return;
+              }
+            }
+            if (insertBB->GetAttributes(kBBAttrArtificial) && insertBB->GetAttributes(kBBAttrIsExit)) {
+              // do not insert at fake BBs created due to infinite loops
+              break;
+            }
+            lambdaResOcc->SetInsertHere(true);
+          } else {
+            lambdaResOcc->SetUse(*anticipatedDefVec[classId]);
+          }
+        }
+        break;
+      }
+      case kSOccEntry:
+      case kSOccUse:
+      case kSOccPhi:
+        break;
+      default:
+        ASSERT(false, "Finalize: unexpected occ type");
+        break;
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after finalize _______" << '\n';
+    for (SOcc *occ : allOccs) {
+      if (occ->GetOccTy() == kSOccReal) {
+        auto *realOcc = static_cast<SRealOcc*>(occ);
+        if (realOcc->GetRedundant()) {
+          occ->Dump();
+          LogInfo::MapleLogger() << " deleted" << '\n';
+        }
+      } else if (occ->GetOccTy() == kSOccLambdaRes) {
+        auto *lambdaResOcc = static_cast<SLambdaResOcc*>(occ);
+        if (lambdaResOcc->GetInsertHere()) {
+          occ->Dump();
+          LogInfo::MapleLogger() << " insertHere" << '\n';
+        }
+      }
+    }
+  }
+}
+
+// ================ Step 4: WillBeAnt Computation ================
+void MeSSUPre::ResetCanBeFullyAnt(SLambdaOcc &lambda) const {
+  lambda.SetIsCanBeAnt(false);
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) {
+      if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == &lambda &&
+          !lambdaResOcc->GetHasRealUse() && lambdaOcc->GetIsCanBeAnt()) {
+          ResetCanBeFullyAnt(*lambdaOcc);
+      }
+    }
+  }
+}
+
+void MeSSUPre::ComputeCanBeFullyAnt() const {
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    bool existNullUse = false;
+    for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) {
+      if (lambdaResOcc->GetUse() == nullptr) {
+        existNullUse = true;
+        break;
+      }
+    }
+    if (existNullUse) {
+      ResetCanBeFullyAnt(*lambdaOcc);
+    }
+  }
+}
+
+void MeSSUPre::ResetCanBeAnt(SLambdaOcc &lambda) const {
+  lambda.SetIsCanBeAnt(false);
+  // the following loop finds lambda's defs and reset them
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) {
+      if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == &lambda) {
+        if (!lambdaResOcc->GetHasRealUse() && !lambdaOcc->GetIsUpsafe() && lambdaOcc->GetIsCanBeAnt()) {
+          ResetCanBeAnt(*lambdaOcc);
+        }
+      }
+    }
+  }
+}
+
+void MeSSUPre::ComputeCanBeAnt() const {
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    if (!lambdaOcc->GetIsUpsafe() && lambdaOcc->GetIsCanBeAnt()) {
+      bool existNullUse = false;
+      for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) {
+        if (lambdaResOcc->GetUse() == nullptr) {
+          existNullUse = true;
+          break;
+        }
+      }
+      if (existNullUse) {
+        ResetCanBeAnt(*lambdaOcc);
+      }
+    }
+  }
+}
+
+void MeSSUPre::ResetEarlier(SLambdaOcc &lambda) const {
+  lambda.SetIsEarlier(false);
+  // the following loop finds lambda's defs and reset them
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) {
+      if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == &lambda) {
+        if (lambdaOcc->GetIsEarlier()) {
+          ResetEarlier(*lambdaOcc);
+        }
+      }
+    }
+  }
+}
+
+void MeSSUPre::ComputeEarlier() const {
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    lambdaOcc->SetIsEarlier(lambdaOcc->GetIsCanBeAnt());
+  }
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    if (lambdaOcc->GetIsEarlier()) {
+      bool existNonNullUse = false;
+      for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) {
+        if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetHasRealUse()) {
+          existNonNullUse = true;
+          break;
+        }
+      }
+      if (existNonNullUse) {
+        ResetEarlier(*lambdaOcc);
+      }
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after earlier computation _______" << '\n';
+    for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+      lambdaOcc->Dump();
+      if (lambdaOcc->GetIsCanBeAnt()) {
+        LogInfo::MapleLogger() << " canbeant";
+      }
+      if (lambdaOcc->GetIsEarlier()) {
+        LogInfo::MapleLogger() << " earlier";
+      }
+      if (lambdaOcc->GetIsCanBeAnt() && !lambdaOcc->GetIsEarlier()) {
+        LogInfo::MapleLogger() << " will be ant";
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 3: Upsafe Computation ================
+void MeSSUPre::ResetUpsafe(const SLambdaResOcc &lambdaRes) const {
+  if (lambdaRes.GetHasRealUse()) {
+    return;
+  }
+  SOcc *useOcc = lambdaRes.GetUse();
+  if (useOcc == nullptr || useOcc->GetOccTy() != kSOccLambda) {
+    return;
+  }
+  auto *useLambdaOcc = static_cast<SLambdaOcc*>(useOcc);
+  if (!useLambdaOcc->GetIsUpsafe()) {
+    return;
+  }
+  useLambdaOcc->SetIsUpsafe(false);
+  for (SLambdaResOcc *lambdaResOcc : useLambdaOcc->GetLambdaRes()) {
+    ResetUpsafe(*lambdaResOcc);
+  }
+}
+
+void MeSSUPre::ComputeUpsafe() const {
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    if (!lambdaOcc->GetIsUpsafe()) {
+      // propagate not-upsafe forward along def-use edges
+      for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) {
+        ResetUpsafe(*lambdaResOcc);
+      }
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after upsafe computation _______" << '\n';
+    for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+      lambdaOcc->Dump();
+      if (lambdaOcc->GetIsUpsafe()) {
+        LogInfo::MapleLogger() << " upsafe";
+      }
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 2: rename ================
+void MeSSUPre::Rename() {
+  std::stack<SOcc*> occStack;
+  classCount = 0;
+  // iterate thru the occurrences in order of preorder traversal of
+  // post-dominator tree
+  for (SOcc *occ : allOccs) {
+    while (!occStack.empty() && !occStack.top()->IsPostDominate(pdom, occ)) {
+      occStack.pop();
+    }
+    switch (occ->GetOccTy()) {
+      case kSOccUse:
+        if (!occStack.empty()) {
+          SOcc *topOcc = occStack.top();
+          if (topOcc->GetOccTy() == kSOccLambda) {
+            static_cast<SLambdaOcc*>(topOcc)->SetIsUpsafe(false);
+          }
+        }
+        occStack.push(occ);
+        break;
+      case kSOccEntry:
+        if (!occStack.empty()) {
+          SOcc *topOcc = occStack.top();
+          if (topOcc->GetOccTy() == kSOccLambda) {
+            // make sure this lambda is dominated by at least one kill occurrence
+            if (preKind == kDecrefPre || preKind == kSecondDecrefPre) {
+              for (SOcc *realOcc : workCand->GetRealOccs()) {
+                if (realOcc->GetOccTy() == kSOccUse || realOcc->GetOccTy() == kSOccPhi) {
+                  continue;
+                }
+                CHECK_FATAL(realOcc->GetOccTy() == kSOccReal, "just check");
+                if (!static_cast<SRealOcc *>(realOcc)->GetRealFromDef()) {
+                  continue;
+                }
+                CHECK_NULL_FATAL(dom);
+                if (!dom->Dominate(realOcc->GetBB(), topOcc->GetBB())) {
+                  continue;
+                }
+                static_cast<SLambdaOcc *>(topOcc)->SetIsUpsafe(false);
+                break;
+              }
+            } else {
+              static_cast<SLambdaOcc *>(topOcc)->SetIsUpsafe(false);
+            }
+          }
+        }
+        break;
+      case kSOccLambda:
+        // assign new class
+        occ->SetClassId(++classCount);
+        occStack.push(occ);
+        break;
+      case kSOccReal: {
+        if (occStack.empty()) {
+          // assign new class
+          occ->SetClassId(++classCount);
+          occStack.push(occ);
+          break;
+        }
+        SOcc *topOcc = occStack.top();
+        if (topOcc->GetOccTy() == kSOccUse) {
+          // assign new class
+          occ->SetClassId(++classCount);
+          occStack.push(occ);
+          break;
+        }
+        ASSERT(topOcc->GetOccTy() == kSOccLambda || topOcc->GetOccTy() == kSOccReal,
+               "Rename: unexpected top-of-stack occ");
+        occ->SetClassId(topOcc->GetClassId());
+        if (topOcc->GetOccTy() == kSOccLambda) {
+          occStack.push(occ);
+        }
+        break;
+      }
+      case kSOccLambdaRes: {
+        if (occStack.empty()) {
+          // leave classId as 0
+          break;
+        }
+        SOcc *topOcc = occStack.top();
+        if (topOcc->GetOccTy() == kSOccUse) {
+          // leave classId as 0
+          break;
+        }
+        ASSERT(topOcc->GetOccTy() == kSOccLambda || topOcc->GetOccTy() == kSOccReal,
+               "Rename: unexpected top-of-stack occ");
+        if (occ->GetBB().GetAttributes(kBBAttrArtificial) &&
+            occ->GetBB().GetAttributes(kBBAttrIsExit)) {
+          // do not consider fake BBs created due to infinite loops
+          break;
+        }
+        occ->SetUse(*topOcc);
+        occ->SetClassId(topOcc->GetClassId());
+        if (topOcc->GetOccTy() == kSOccReal) {
+          static_cast<SLambdaResOcc*>(occ)->SetHasRealUse(true);
+        }
+        break;
+      }
+      case kSOccPhi:
+        break;
+      default:
+        ASSERT(false, "Rename: unexpected type of occurrence");
+        break;
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after rename _______" << '\n';
+    for (SOcc *occ : allOccs) {
+      occ->Dump();
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+// ================ Step 1: insert lambdas ================
+
+// form lambda occ based on the real occ in workCand->realOccs; result is
+// stored in lambdaDfns
+void MeSSUPre::FormLambdas() {
+  lambdaDfns.clear();
+  CHECK_NULL_FATAL(workCand);
+  for (SOcc *occ : workCand->GetRealOccs()) {
+    GetIterPdomFrontier(&occ->GetBB(), &lambdaDfns);
+  }
+}
+
+// form allOccs inclusive of real, use, lambda, lambdaRes, entry occurrences;
+// form lambdaOccs containing only the lambdas
+void MeSSUPre::CreateSortedOccs() {
+  // form lambdaRes occs based on the succs of the lambda occs; result is
+  // stored in lambdaResDfns
+  std::multiset<uint32> lambdaResDfns;
+  for (uint32 dfn : lambdaDfns) {
+    const auto &bbId = pdom->GetDtPreOrderItem(dfn);
+    BB *bb = cfg->GetAllBBs().at(bbId);
+    for (BB *succ : bb->GetSucc()) {
+      (void)lambdaResDfns.insert(pdom->GetDtDfnItem(succ->GetBBId()));
+    }
+  }
+  allOccs.clear();
+  lambdaOccs.clear();
+  std::unordered_map<BBId, std::forward_list<SLambdaResOcc*>> bb2LambdaResMap;
+  auto realOccIt = workCand->GetRealOccs().begin();
+  auto entryOccIt = entryOccs.begin();
+  auto lambdaDfnIt = lambdaDfns.begin();
+  auto lambdaResDfnIt = lambdaResDfns.begin();
+  SOcc *nextRealOcc = nullptr;
+  if (realOccIt != workCand->GetRealOccs().end()) {
+    nextRealOcc = *realOccIt;
+  }
+  SEntryOcc *nextEntryOcc = nullptr;
+  if (entryOccIt != entryOccs.end()) {
+    nextEntryOcc = *entryOccIt;
+  }
+  SLambdaOcc *nextLambdaOcc = nullptr;
+  if (lambdaDfnIt != lambdaDfns.end()) {
+    nextLambdaOcc =
+        spreMp->New<SLambdaOcc>(*cfg->GetAllBBs().at(pdom->GetDtPreOrderItem(*lambdaDfnIt)), spreAllocator);
+  }
+  SLambdaResOcc *nextLambdaResOcc = nullptr;
+  if (lambdaResDfnIt != lambdaResDfns.end()) {
+    nextLambdaResOcc = spreMp->New<SLambdaResOcc>(*cfg->GetAllBBs().at(pdom->GetDtPreOrderItem(*lambdaResDfnIt)));
+    auto it = bb2LambdaResMap.find(BBId(pdom->GetDtPreOrderItem(*lambdaResDfnIt)));
+    if (it == bb2LambdaResMap.end()) {
+      std::forward_list<SLambdaResOcc*> newlist = { nextLambdaResOcc };
+      bb2LambdaResMap[BBId(pdom->GetDtPreOrderItem(*lambdaResDfnIt))] = newlist;
+    } else {
+      it->second.push_front(nextLambdaResOcc);
+    }
+  }
+  SOcc *pickedOcc = nullptr;  // the next picked occ in order of preorder traversal of post-dominator tree
+  do {
+    pickedOcc = nullptr;
+    if (nextLambdaOcc != nullptr) {
+      pickedOcc = nextLambdaOcc;
+    }
+    if (nextRealOcc != nullptr && (pickedOcc == nullptr || pdom->GetDtDfnItem(nextRealOcc->GetBB().GetBBId()) <
+                                   pdom->GetDtDfnItem(pickedOcc->GetBB().GetBBId()))) {
+      pickedOcc = nextRealOcc;
+    }
+    if (nextLambdaResOcc != nullptr &&
+        (pickedOcc == nullptr || *lambdaResDfnIt < pdom->GetDtDfnItem(pickedOcc->GetBB().GetBBId()))) {
+      pickedOcc = nextLambdaResOcc;
+    }
+    if (nextEntryOcc != nullptr && (pickedOcc == nullptr || pdom->GetDtDfnItem(nextEntryOcc->GetBB().GetBBId()) <
+                                    pdom->GetDtDfnItem(pickedOcc->GetBB().GetBBId()))) {
+      pickedOcc = nextEntryOcc;
+    }
+    if (pickedOcc != nullptr) {
+      allOccs.push_back(pickedOcc);
+      switch (pickedOcc->GetOccTy()) {
+        case kSOccReal:
+        case kSOccUse:
+        case kSOccPhi:
+          // get the next real/use occ
+          CHECK_FATAL(realOccIt != workCand->GetRealOccs().end(), "iterator check");
+          ++realOccIt;
+          if (realOccIt != workCand->GetRealOccs().end()) {
+            nextRealOcc = *realOccIt;
+          } else {
+            nextRealOcc = nullptr;
+          }
+          break;
+        case kSOccEntry:
+          CHECK_FATAL(entryOccIt != entryOccs.end(), "iterator check");
+          ++entryOccIt;
+          if (entryOccIt != entryOccs.end()) {
+            nextEntryOcc = *entryOccIt;
+          } else {
+            nextEntryOcc = nullptr;
+          }
+          break;
+        case kSOccLambda:
+          lambdaOccs.push_back(static_cast<SLambdaOcc*>(pickedOcc));
+          CHECK_FATAL(lambdaDfnIt != lambdaDfns.end(), "iterator check");
+          ++lambdaDfnIt;
+          if (lambdaDfnIt != lambdaDfns.end()) {
+            nextLambdaOcc =
+                spreMp->New<SLambdaOcc>(*cfg->GetAllBBs().at(pdom->GetDtPreOrderItem(*lambdaDfnIt)), spreAllocator);
+          } else {
+            nextLambdaOcc = nullptr;
+          }
+          break;
+        case kSOccLambdaRes:
+          CHECK_FATAL(lambdaResDfnIt != lambdaResDfns.end(), "iterator check");
+          ++lambdaResDfnIt;
+          if (lambdaResDfnIt != lambdaResDfns.end()) {
+            nextLambdaResOcc =
+                spreMp->New<SLambdaResOcc>(*cfg->GetAllBBs().at(pdom->GetDtPreOrderItem(*lambdaResDfnIt)));
+            CHECK_NULL_FATAL(dom);
+            auto it = bb2LambdaResMap.find(BBId(pdom->GetDtPreOrderItem(*lambdaResDfnIt)));
+            if (it == bb2LambdaResMap.end()) {
+              std::forward_list<SLambdaResOcc*> newlist = { nextLambdaResOcc };
+              bb2LambdaResMap[BBId(pdom->GetDtPreOrderItem(*lambdaResDfnIt))] = newlist;
+            } else {
+              it->second.push_front(nextLambdaResOcc);
+            }
+          } else {
+            nextLambdaResOcc = nullptr;
+          }
+          break;
+        default:
+          ASSERT(false, "CreateSortedOccs: unexpected occTy");
+          break;
+      }
+    }
+  } while (pickedOcc != nullptr);
+  // initialize lambdaRes vector in each SLambdaOcc node
+  for (SLambdaOcc *lambdaOcc : lambdaOccs) {
+    for (BB *succ : lambdaOcc->GetBB().GetSucc()) {
+      SLambdaResOcc *lambdaResOcc = bb2LambdaResMap[succ->GetBBId()].front();
+      lambdaOcc->GetLambdaRes().push_back(lambdaResOcc);
+      lambdaResOcc->SetUseLambdaOcc(*lambdaOcc);
+      bb2LambdaResMap[succ->GetBBId()].pop_front();
+    }
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << " _______ after lambda insertion _______" << '\n';
+    for (SOcc *occ : allOccs) {
+      occ->Dump();
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+void MeSSUPre::ApplySSUPre() {
+  BuildWorkListBB(cfg->GetCommonExitBB());
+  if (!MeOption::gcOnly && preKind != kSecondDecrefPre) {  // #0 build worklist
+    CreateEmptyCleanupIntrinsics();
+  }
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "------ worklist initial size " << workCandMap.size() << '\n';
+  }
+  int32 candNum = 0;
+  for (auto &wkCandPair : std::as_const(workCandMap)) {
+    if (preKind == kStorePre) {
+      if (!wkCandPair.second->GetHasStoreOcc()) {
+        continue;
+      }
+    } else if (preKind == kDecrefPre) {
+      if (wkCandPair.second->GetOst()->IsFormal() && !wkCandPair.second->GetHasStoreOcc()) {
+        continue;
+      }
+    }
+    workCand = wkCandPair.second;
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "||||||| SPRE candidate " << candNum << " (ostidx "
+                             << workCand->GetOst()->GetIndex() << "): ";
+      workCand->GetOst()->Dump();
+      LogInfo::MapleLogger() << '\n';
+    }
+    PerCandInit();
+    // #1 insert lambdas; results in allOccs and lambdaOccs
+    FormLambdas();  // result put in the set lambda_bbs
+    CreateSortedOccs();
+    // #2 rename
+    Rename();
+    if (!lambdaOccs.empty()) {
+      // #3 UpSafety
+      ComputeUpsafe();
+      // #4 CanBeAnt
+      ComputeCanBeAnt();
+      ComputeEarlier();
+    }
+    // #5 Finalize
+    Finalize();
+    // #6 Code Motion
+    CHECK_NULL_FATAL(workCand);
+    if (!workCand->GetHasCriticalEdge()) {
+      CodeMotion();
+    }
+    candNum++;
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_stack_protect.cpp b/src/mapleall/maple_me/src/me_stack_protect.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..69848b3230485eb06e550709c9885d466d972a45
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_stack_protect.cpp
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "me_stack_protect.h"
+#include "me_irmap_build.h"
+#include "cg_options.h"
+
+namespace maple {
+bool MeStackProtect::IsStackSymbol(const OriginalSt &ost) const {
+  auto *symbol = ost.GetMIRSymbol();
+  if (symbol->GetStorageClass() == kScAuto) {
+    return true;
+  }
+  return false;
+}
+
+bool MeStackProtect::IsValidWrite(const OriginalSt &targetOst, uint64 numByteToWrite,
+                                  uint64 extraOffset) const {
+  if (!IsStackSymbol(targetOst)) {
+    return true;
+  }
+  auto offset = targetOst.GetOffset();
+  if (offset.IsInvalid()) {
+    // offset of array is set to be invalid -> it is safe to set the offset to be 0 in this case
+    if (!targetOst.GetType()->IsMIRArrayType()) {
+      return false;
+    }
+  } else {
+    CHECK_FATAL(offset.val >= 0, "offset has to be >= 0");
+    extraOffset += static_cast<uint64>(offset.val);
+  }
+  // check whether it is within bound
+  if ((numByteToWrite + extraOffset) <= static_cast<uint64>(targetOst.GetType()->GetSize())) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool MeStackProtect::RecordExpr(std::set<int32> &visitedDefs, const ScalarMeExpr& expr) const {
+  auto exprID = expr.GetExprID();
+  auto it = visitedDefs.insert(exprID);
+  if (!it.second) {
+    return false; // visited
+  }
+  return true;
+}
+
+bool MeStackProtect::IsDefInvolveAddressOfStackVar(const ScalarMeExpr &expr, std::set<int32> &visitedDefs) const {
+  switch (expr.GetDefBy()) {
+    case kDefByMustDef: {
+      // it may point the address of stack variable if
+      // - the function call (call or intrinsic call) takes the addresses of stack variable as arguments, and
+      // - return the addresses of stack variables
+      // however, there is no need to track this, since the function call will be marked as "malicious"
+      return false;
+    }
+    case kDefByPhi: {
+      const auto defStmt = expr.GetDefPhi();
+      for (const auto opnd: defStmt.GetOpnds()) {
+        if (!RecordExpr(visitedDefs, *opnd)) {
+          return false;
+        }
+        if (IsPointToAddressOfStackVar(*opnd, visitedDefs)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    case kDefByStmt: {
+      const auto defStmt = expr.GetDefStmt();
+      return IsPointToAddressOfStackVar(*defStmt->GetRHS(), visitedDefs);
+    }
+    case kDefByNo: {
+      auto ost = expr.GetOst();
+      if (ost->IsPregOst()) {
+        return !ost->IsSpecialPreg();
+      } else {
+        return IsStackSymbol(*ost);
+      }
+    }
+    case kDefByChi: {
+      const auto defStmt = expr.GetDefChi();
+      const auto rhs = defStmt.GetRHS();
+      if (!RecordExpr(visitedDefs, *rhs)) {
+        return false;
+      }
+      return IsPointToAddressOfStackVar(*rhs, visitedDefs);
+    }
+    default: {
+      CHECK_FATAL(false, "Undefined.");
+    }
+  }
+}
+
+bool MeStackProtect::IsMeOpExprPointedToAddressOfStackVar(const MeExpr &expr, std::set<int32> &visitedDefs) const {
+  for (size_t argIdx = 0; argIdx < expr.GetNumOpnds(); ++argIdx) {
+    if (IsPointToAddressOfStackVar(*expr.GetOpnd(argIdx), visitedDefs)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MayBeAddress(PrimType type) {
+  if (type == PTY_ptr) {
+    return true;
+  }
+  auto curPtrType = GetExactPtrPrimType();
+  if (curPtrType == PTY_a32 && (type == PTY_u32 || type == PTY_a32 || type == PTY_i32)) {
+    return true;
+  }
+  if (curPtrType == PTY_a64 && (type == PTY_u64 || type == PTY_a64 || type == PTY_i64)) {
+    return true;
+  }
+  return false;
+}
+
+bool MeStackProtect::IsPointToAddressOfStackVar(const MeExpr &expr, std::set<int32> &visitedDefs) const {
+  // check whether it may be address given the type
+  if (!MayBeAddress(expr.GetPrimType())) {
+    return false;
+  }
+  // check whether the address pointed by the ptr is stack address
+  switch (expr.GetMeOp()) {
+    case kMeOpReg: {
+      return IsDefInvolveAddressOfStackVar(static_cast<const RegMeExpr&>(expr), visitedDefs);
+    }
+    case kMeOpVar: {
+      return IsDefInvolveAddressOfStackVar(static_cast<const VarMeExpr&>(expr), visitedDefs);
+    }
+    case kMeOpAddrof: {
+      return IsStackSymbol(*static_cast<const AddrofMeExpr&>(expr).GetOst());
+    }
+    case kMeOpOp: {
+      return IsMeOpExprPointedToAddressOfStackVar(expr, visitedDefs);
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+bool MeStackProtect::IsCallSafe(const MeStmt &stmt, bool isIcall, const FuncDesc *funcDesc) const {
+  size_t argIdx = isIcall ? 1 : 0;
+  for (; argIdx < stmt.NumMeStmtOpnds(); ++argIdx) {
+    if (funcDesc != nullptr &&
+        (funcDesc->IsArgUnused(argIdx) ||
+         funcDesc->IsArgReadSelfOnly(argIdx) ||
+         funcDesc->IsArgReadMemoryOnly(argIdx))) {
+      continue;
+    }
+    std::set<int32> visitedDefs;
+    if (IsPointToAddressOfStackVar(*stmt.GetOpnd(argIdx), visitedDefs)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MeStackProtect::IsWriteFromSourceSafe(const MeStmt &stmt, uint64 numOfBytesToWrite) const {
+  // always write to the first opnd
+  auto lhs = stmt.GetOpnd(0);
+  auto lhsOp = lhs->GetOp();
+  if (lhsOp != OP_addrof && lhsOp != OP_iaddrof) {
+    std::set<int32> visitedDefs;
+    return !IsPointToAddressOfStackVar(*lhs, visitedDefs);
+  }
+  OriginalSt* lhsOst;
+  uint64 offset = 0;
+  if (lhsOp == OP_addrof) {
+    lhsOst = static_cast<AddrofMeExpr*>(lhs)->GetOst();
+  } else {
+    auto iaddrofExpr = static_cast<OpMeExpr*>(lhs);
+    auto targetOpnd = iaddrofExpr->GetOpnd(0);
+    auto targetOp = targetOpnd->GetMeOp();
+    if (targetOp == kMeOpAddrof) {
+      lhsOst = static_cast<AddrofMeExpr*>(targetOpnd)->GetOst();
+    } else {
+      std::set<int32> visitedDefs;
+      return !IsPointToAddressOfStackVar(*lhs, visitedDefs);
+    }
+    constexpr uint8 kNumOfBitsInByte = 8;
+    offset += static_cast<uint64>(iaddrofExpr->GetBitsOffSet() / kNumOfBitsInByte);
+  }
+  return IsValidWrite(*lhsOst, numOfBytesToWrite, offset);
+}
+
+bool MeStackProtect::IsIntrnCallSafe(const MeStmt &stmt) const {
+  auto intrnCallStmt = static_cast<const IntrinsiccallMeStmt&>(stmt);
+  auto intrinsicID = intrnCallStmt.GetIntrinsic();
+  // no side effect --> not write anything --> safe
+  if (IntrinDesc::intrinTable[intrinsicID].HasNoSideEffect()) {
+    return true;
+  }
+  switch (intrinsicID) {
+    case INTRN_C_strcpy: {
+      // strcpy: <target, src>
+      // - copy everything from src to target
+      // size is equal to the size of second operand
+      auto numOfBytesToWrite = GetPrimTypeSize(stmt.GetOpnd(1)->GetPrimType());
+      return IsWriteFromSourceSafe(stmt, static_cast<uint64>(numOfBytesToWrite));
+    }
+    case INTRN_C_strncpy:
+    case INTRN_C_memcpy:
+    case INTRN_C_memset: {
+      // memset, memcpy, and strncpy share the same pattern <target, src, size>:
+      // - write to the memory pointed by the first opnd
+      // - the number of written bytes is controlled by the third opnd
+      auto sizeExpr = stmt.GetOpnd(2);
+      if (sizeExpr->GetOp() == OP_constval) {
+        auto numOfBytesToWrite = static_cast<ConstMeExpr*>(sizeExpr)->GetSXTIntValue();
+        CHECK_FATAL(numOfBytesToWrite >= 0, "num of bytes to write cannot be negative.");
+        return IsWriteFromSourceSafe(stmt, static_cast<uint64>(numOfBytesToWrite));
+      } else {
+        // check whether the first opnd points to stack
+        std::set<int32> visitedDefs;
+        return !IsPointToAddressOfStackVar(*stmt.GetOpnd(0), visitedDefs);
+      }
+    }
+    case INTRN_C_va_start: {
+      return true;
+    }
+    default: {
+      // treat it as same as normal call
+      return IsCallSafe(stmt, false);
+    }
+  }
+}
+
+const FuncDesc* MeStackProtect::GetFuncDesc(const MeStmt &stmt) const {
+  auto callStmt = static_cast<const CallMeStmt&>(stmt);
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt.GetPUIdx());
+  auto funcDesc = &(callee->GetFuncDesc());
+  if (!funcDesc->IsConfiged()) { // only desc from .def file is trustworthy
+    funcDesc = nullptr;
+  }
+  return funcDesc;
+}
+
+bool MeStackProtect::IsMeStmtSafe(const MeStmt &stmt) const {
+  switch (stmt.GetOp()) {
+    // write to stack given the address of stack variable --> may be malicious
+    case OP_iassign:
+    case OP_iassignoff: {
+      auto accessedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(
+          static_cast<const IassignMeStmt&>(stmt).GetTyIdx());
+      CHECK_FATAL(accessedType->IsMIRPtrType(), "need to be a pointer");
+      auto numOfByteToWrite = static_cast<uint64>(static_cast<MIRPtrType*>(accessedType)->GetPointedType()->GetSize());
+      return IsWriteFromSourceSafe(stmt, numOfByteToWrite);
+    }
+    // address of stack variable escape --> may be malicious
+    case OP_icallprotoassigned:
+    case OP_icallproto:
+    case OP_icallassigned:
+    case OP_icall: {
+      return IsCallSafe(stmt, true);
+    }
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_call:
+    case OP_callassigned:
+    case OP_superclasscallassigned:
+    case OP_interfaceicallassigned:
+    case OP_interfacecallassigned:
+    case OP_virtualicallassigned:
+    case OP_virtualcallassigned: {
+      const auto funcDesc = GetFuncDesc(stmt);
+      return IsCallSafe(stmt, false, funcDesc);
+    }
+    // intrinsic call with explicit meaning:
+    // - no side effect --> safe
+    // - write to stack given the address of stack variable --> may be malicious
+    case OP_xintrinsiccall:
+    case OP_xintrinsiccallassigned:
+    case OP_intrinsiccallwithtype:
+    case OP_intrinsiccallassigned:
+    case OP_intrinsiccallwithtypeassigned:
+    case OP_intrinsiccall: {
+      return IsIntrnCallSafe(stmt);
+    }
+    default: {
+      // may write to reg / stack without its address --> safe
+      return true;
+    }
+  }
+}
+
+/*
+ * Following potential behaviors may use the address of stack variables for malicious purposes:
+ * - callees take the address of stack variables as inputs and may write to it
+ * - write stack variables given its address (iassign & intrinsiccall)
+ * Note: Arguments are not considered as stack variables here
+ */
+void MeStackProtect::CheckAddrofStack() {
+  auto *mirFunc = f->GetMirFunc();
+  mirFunc->CheckMayWriteToAddrofStack();
+  mirFunc->UnsetMayWriteToAddrofStack();  // reset it before analysis
+  if (MayWriteStack()) {
+    mirFunc->SetMayWriteToAddrofStack();
+  }
+}
+
+bool MeStackProtect::MayWriteStack() {
+  auto *cfg = f->GetCfg();
+  for (BB *bb: cfg->GetAllBBs()) {
+    if (bb == nullptr || bb == cfg->GetCommonEntryBB() || bb == cfg->GetCommonExitBB()) {
+      continue;
+    }
+    for (auto &stmt: bb->GetMeStmts()) {
+      if (!IsMeStmtSafe(stmt)) {
+        f->GetMirFunc()->SetMayWriteToAddrofStack();
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool FuncMayWriteStack(MeFunction &func) {
+  MeStackProtect checker(func);
+  return checker.MayWriteStack();
+}
+}
+
diff --git a/src/mapleall/maple_me/src/me_stmt_fre.cpp b/src/mapleall/maple_me/src/me_stmt_fre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..576e3bd2a6c09d24e465e44df4a2f7a971b9b9e4
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_stmt_fre.cpp
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_option.h"
+#include "me_stmt_pre.h"
+
+namespace maple {
+void MeStmtPre::ResetFullyAvail(MePhiOcc &occ) {
+  occ.SetIsCanBeAvail(false);
+  // reset those phiocc nodes that have oc as one of its operands
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+      if (phiOpnd->GetDef() != nullptr && phiOpnd->GetDef() == &occ) {
+        // phiOpnd is a use of occ
+        if (!phiOpnd->HasRealUse()) {
+          ResetCanBeAvail(*phiOcc);
+        }
+      }
+    }
+  }
+}
+
+// the fullyavail attribute is stored in the isCanBeAvail field
+void MeStmtPre::ComputeFullyAvail() {
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    // reset canbeavail if any phi operand is null
+    bool existNullDef = false;
+    for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+      if (phiOpnd->GetDef() == nullptr) {
+        existNullDef = true;
+        break;
+      }
+    }
+    if (existNullDef) {
+      ResetFullyAvail(*phiOcc);
+    }
+  }
+}
+
+bool MeStmtPre::AllVarsSameVersionStmtFre(MeRealOcc &topOcc, MeRealOcc &curOcc) const {
+  ASSERT(topOcc.GetOpcodeOfMeStmt() == OP_dassign || topOcc.GetOpcodeOfMeStmt() == OP_callassigned,
+      "AllVarsSameVersionStmtFre: only dassign or callassigned is handled");
+  if (topOcc.GetMeStmt()->NumMeStmtOpnds() != curOcc.GetMeStmt()->NumMeStmtOpnds()) {
+    return false;
+  }
+  for (size_t i = 0; i < topOcc.GetMeStmt()->NumMeStmtOpnds(); ++i) {
+    if (topOcc.GetMeStmt()->GetOpnd(i) != curOcc.GetMeStmt()->GetOpnd(i)) {
+      return false;
+    }
+  }
+  return topOcc.GetMeStmt()->GetVarLHS() == curOcc.GetMeExpr();
+}
+
+void MeStmtPre::Rename1StmtFre() {
+  std::stack<MeOccur*> occStack;
+  rename2Set.clear();
+  classCount = 1;
+  // iterate the occurrence according to its preorder dominator tree
+  for (MeOccur *occ : allOccs) {
+    while (!occStack.empty() && !occStack.top()->IsDominate(*dom, *occ)) {
+      occStack.pop();
+    }
+    switch (occ->GetOccType()) {
+      case kOccReal: {
+        if (occStack.empty()) {
+          // assign new class
+          occ->SetClassID(classCount++);
+          occStack.push(occ);
+          break;
+        }
+        MeOccur *topOccur = occStack.top();
+        if (topOccur->GetOccType() == kOccMembar) {
+          occ->SetClassID(classCount++);
+          occStack.push(occ);
+          break;
+        }
+        auto *realOcc = static_cast<MeRealOcc*>(occ);
+        if (topOccur->GetOccType() == kOccReal) {
+          auto *realTopOccur = static_cast<MeRealOcc*>(topOccur);
+          if (AllVarsSameVersionStmtFre(*realTopOccur, *realOcc)) {
+            // all corresponding variables are the same
+            realOcc->SetClassID(realTopOccur->GetClassID());
+            realOcc->SetDef(realTopOccur);
+          } else {
+            // assign new class
+            occ->SetClassID(classCount++);
+          }
+          occStack.push(occ);
+        } else {
+          // top of stack is a PHI occurrence
+          std::vector<MeExpr*> varVec;
+          CollectVarForCand(*realOcc, varVec);
+          bool isAllDom = true;
+          for (auto varIt = varVec.begin(); varIt != varVec.end(); ++varIt) {
+            MeExpr *varMeExpr = *varIt;
+            if (!DefVarDominateOcc(varMeExpr, *topOccur)) {
+              isAllDom = false;
+            }
+          }
+          if (isAllDom) {
+            realOcc->SetClassID(topOccur->GetClassID());
+            realOcc->SetDef(topOccur);
+            (void)rename2Set.insert(realOcc->GetPosition());
+            occStack.push(realOcc);
+          } else {
+            // assign new class
+            occ->SetClassID(classCount++);
+          }
+          occStack.push(occ);
+        }
+        break;
+      }
+      case kOccPhiocc: {
+        // assign new class
+        occ->SetClassID(classCount++);
+        occStack.push(occ);
+        break;
+      }
+      case kOccPhiopnd: {
+        if (occStack.empty() || occStack.top()->GetOccType() == kOccMembar) {
+          occ->SetDef(nullptr);
+        } else {
+          MeOccur *topOccur = occStack.top();
+          occ->SetDef(topOccur);
+          occ->SetClassID(topOccur->GetClassID());
+          if (topOccur->GetOccType() == kOccReal) {
+            static_cast<MePhiOpndOcc*>(occ)->SetHasRealUse(true);
+          }
+        }
+        break;
+      }
+      case kOccExit:
+        break;
+      case kOccMembar:
+        if (occStack.empty() || occStack.top()->GetOccType() != kOccMembar) {
+          occStack.push(occ);
+        }
+        break;
+      default:
+        ASSERT(false, "should not be here");
+        break;
+    }
+  }
+  if (GetSSAPreDebug()) {
+    PreWorkCand *curCand = workCand;
+    mirModule->GetOut() << "======== ssafre candidate " << curCand->GetIndex() <<
+        " after rename1StmtFre ===================\n";
+    for (MeOccur *occ : allOccs) {
+      occ->Dump(*irMap);
+      mirModule->GetOut() << "\n";
+    }
+    mirModule->GetOut() << "\n" << "rename2 set:\n";
+    for (uint32 pos : rename2Set) {
+      MeRealOcc *occur = workCand->GetRealOcc(pos);
+      occur->Dump(*irMap);
+      mirModule->GetOut() << " with def at\n";
+      occur->GetDef()->Dump(*irMap);
+      mirModule->GetOut() << "\n";
+    }
+    mirModule->GetOut() << "\n";
+  }
+}
+
+void MeStmtPre::DoSSAFRE() {
+  if (GetSSAPreDebug()) {
+    mirModule->GetOut() << "{{{{{{{{ start of SSAFRE }}}}}}}}" << '\n';
+  }
+  // form new allOccs that has no use_occ and reflect insertions and deletions
+  MapleVector<MeOccur*> newAllOccs(perCandAllocator.Adapter());
+  int32 realOccCnt = 0;
+  bool hasInsertion = false;  // if there is insertion, do not perform SSAFRE
+  // because SSA form has not been updated
+  for (MeOccur *occ : allOccs) {
+    switch (occ->GetOccType()) {
+      case kOccReal: {
+        auto *realOcc = static_cast<MeRealOcc*>(occ);
+        if (!realOcc->IsReload()) {
+          realOcc->SetIsReload(false);
+          realOcc->SetIsSave(false);
+          realOcc->SetClassID(0);
+          realOcc->SetDef(nullptr);
+          newAllOccs.push_back(realOcc);
+          ++realOccCnt;
+        }
+        break;
+      }
+      case kOccPhiopnd: {
+        auto *phiOpnd = static_cast<MePhiOpndOcc*>(occ);
+        if (phiOpnd->GetDefPhiOcc()->IsWillBeAvail()) {
+          MeOccur *defOcc = phiOpnd->GetDef();
+          if (defOcc != nullptr && defOcc->GetOccType() == kOccInserted && !phiOpnd->IsPhiOpndReload()) {
+            hasInsertion = true;
+            break;
+          }
+        }
+        phiOpnd->SetIsProcessed(false);
+        phiOpnd->SetHasRealUse(false);
+        phiOpnd->SetIsInsertedOcc(false);
+        phiOpnd->SetIsPhiOpndReload(false);
+        phiOpnd->SetClassID(0);
+        phiOpnd->SetDef(nullptr);
+        newAllOccs.push_back(phiOpnd);
+        break;
+      }
+      case kOccPhiocc: {
+        auto *phiOcc = static_cast<MePhiOcc*>(occ);
+        phiOcc->SetIsDownSafe(false);
+        phiOcc->SetIsCanBeAvail(true);
+        phiOcc->SetIsLater(false);
+        phiOcc->SetIsExtraneous(false);
+        phiOcc->SetIsRemoved(false);
+        phiOcc->SetClassID(0);
+        newAllOccs.push_back(phiOcc);
+        break;
+      }
+      case kOccExit:
+      case kOccMembar:
+        newAllOccs.push_back(occ);
+        break;
+      case kOccUse:
+        break;
+      default:
+        ASSERT(false, "should not be here");
+        break;
+    }
+    if (hasInsertion) {
+      break;
+    }
+  }
+  if (hasInsertion || realOccCnt <= 1) {
+    return;
+  }
+  allOccs = newAllOccs;
+  Rename1StmtFre();
+  Rename2();
+  ComputeFullyAvail();
+  Finalize1();
+  Finalize2();
+  CodeMotion();
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/me_stmt_pre.cpp b/src/mapleall/maple_me/src/me_stmt_pre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7a6d13161c02e2ac3e765e56a9ab8ec3b536ce67
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_stmt_pre.cpp
@@ -0,0 +1,1225 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "utils.h"
+#include "me_dominance.h"
+#include "me_option.h"
+#include "me_ssa_update.h"
+#include "me_stmt_pre.h"
+
+// Note: after the movement of assignments, some phi nodes that used to be dead
+// can become live.  Before we run another round of dead store elimination, we
+// should NOT trust the isLive flag in phi nodes.
+// accumulate the BBs that are in the iterated dominance frontiers of bb in
+// the set dfset, visiting each BB only once
+namespace maple {
+static bool IsParaAndRetTypeRefOrPtr(const CallMeStmt &stmt) {
+  const MIRFunction &func = stmt.GetTargetFunction();
+  if (func.GetName() == "MCC_GetOrInsertLiteral") {
+    return false;
+  }
+  for (auto it : stmt.GetOpnds()) {
+    if (MustBeAddress(it->GetPrimType())) {
+      return true;
+    }
+  }
+  const MeExpr *expr = stmt.GetAssignedLHS();
+  if (expr != nullptr && MustBeAddress(expr->GetPrimType())) {
+    return true;
+  }
+  return false;
+}
+
+void MeStmtPre::CodeMotion() {
+  for (MeOccur *occ : allOccs) {
+    switch (occ->GetOccType()) {
+      case kOccReal: {
+        auto *realOcc = static_cast<MeRealOcc*>(occ);
+        if (realOcc->IsSave()) {
+          CHECK_FATAL(!realOcc->IsReload(), "should be false");
+        } else if (realOcc->IsReload()) {
+          realOcc->GetBB()->RemoveMeStmt(realOcc->GetMeStmt());
+          if (realOcc->GetOpcodeOfMeStmt() == OP_dassign) {
+            auto *dass = static_cast<DassignMeStmt*>(realOcc->GetMeStmt());
+            OStIdx ostIdx = dass->GetVarLHS()->GetOstIdx();
+            if (candsForSSAUpdate.find(ostIdx) == candsForSSAUpdate.end()) {
+              candsForSSAUpdate.emplace(ostIdx, std::make_unique<std::set<BBId>>(std::less<BBId>()));
+            }
+          } else if (realOcc->GetOpcodeOfMeStmt() == OP_callassigned) {
+            auto *call = static_cast<CallMeStmt*>(realOcc->GetMeStmt());
+            if (call->GetAssignedLHS() != nullptr) {
+              CHECK_FATAL(call->GetAssignedLHS()->GetMeOp() == kMeOpVar, "should be var");
+              auto *var = static_cast<VarMeExpr*>(call->GetAssignedLHS());
+              OStIdx ostIdx = var->GetOstIdx();
+              if (candsForSSAUpdate.find(ostIdx) == candsForSSAUpdate.end()) {
+                candsForSSAUpdate.emplace(ostIdx, std::make_unique<std::set<BBId>>(std::less<BBId>()));
+              }
+            }
+          }
+          auto *chiList = realOcc->GetMeStmt()->GetChiList();
+          if (chiList != nullptr) {
+            for (auto &ostIdx2Chi : std::as_const(*chiList)) {
+              OStIdx ostIdx = ostIdx2Chi.first;
+              if (candsForSSAUpdate.find(ostIdx) == candsForSSAUpdate.end()) {
+                candsForSSAUpdate.emplace(ostIdx, std::make_unique<std::set<BBId>>(std::less<BBId>()));
+              }
+            }
+          }
+        }
+        break;
+      }
+      case kOccPhiopnd: {
+        auto *phiOpnd = static_cast<MePhiOpndOcc*>(occ);
+        if (!phiOpnd->GetDefPhiOcc()->IsWillBeAvail()) {
+          break;
+        }
+        MeOccur *defOcc = phiOpnd->GetDef();
+        if (defOcc->GetOccType() == kOccInserted) {
+          if (!phiOpnd->IsPhiOpndReload()) {
+            auto *insertedOcc = static_cast<MeInsertedOcc*>(defOcc);
+            if (insertedOcc->GetOpcodeOfMeStmt() == OP_dassign) {
+              auto *dass = static_cast<DassignMeStmt*>(insertedOcc->GetMeStmt());
+              OStIdx ostIdx = dass->GetVarLHS()->GetOstIdx();
+              MeSSAUpdate::InsertOstToSSACands(ostIdx, *occ->GetBB(), &candsForSSAUpdate);
+              // create a new LHS for the dassign in insertedOcc->GetMeStmt()
+              VarMeExpr *newVarVersion = irMap->CreateVarMeExprVersion(*(static_cast<VarMeExpr *>(dass->GetVarLHS())));
+              dass->UpdateLhs(newVarVersion);
+            } else if (insertedOcc->GetOpcodeOfMeStmt() == OP_callassigned) {
+              auto *call = static_cast<CallMeStmt*>(insertedOcc->GetMeStmt());
+              if (call->GetAssignedLHS() != nullptr) {
+                CHECK_FATAL(call->GetAssignedLHS()->GetMeOp() == kMeOpVar, "should be var");
+                auto *var = static_cast<VarMeExpr*>(call->GetAssignedLHS());
+                ASSERT_NOT_NULL(var);
+                OStIdx ostIdx = var->GetOstIdx();
+                MeSSAUpdate::InsertOstToSSACands(ostIdx, *occ->GetBB(), &candsForSSAUpdate);
+                VarMeExpr *newVarVersion = irMap->CreateVarMeExprVersion(*var);
+                auto &mustDef = call->GetMustDefList()->front();
+                mustDef.UpdateLHS(*newVarVersion);
+                newVarVersion->SetDefBy(kDefByMustDef);
+                newVarVersion->SetDefMustDef(mustDef);
+              }
+            }
+            if (insertedOcc->GetOpcodeOfMeStmt() == OP_intrinsiccallwithtype &&
+                (static_cast<IntrinsiccallMeStmt*>(insertedOcc->GetMeStmt())->GetIntrinsic() ==
+                 INTRN_JAVA_CLINIT_CHECK)) {
+              BB *insertBB = insertedOcc->GetBB();
+              // insert at earlist point in BB, but after statements required
+              // to be first statement in BB
+              MeStmt *curStmt = to_ptr(insertBB->GetMeStmts().begin());
+              while (curStmt != nullptr && (curStmt->GetOp() == OP_catch || curStmt->GetOp() == OP_try ||
+                                            curStmt->GetOp() == OP_comment)) {
+                curStmt = curStmt->GetNext();
+              }
+              if (curStmt == nullptr) {
+                insertBB->AddMeStmtLast(insertedOcc->GetMeStmt());
+              } else {
+                insertBB->InsertMeStmtBefore(curStmt, insertedOcc->GetMeStmt());
+              }
+            } else {
+              insertedOcc->GetBB()->InsertMeStmtLastBr(insertedOcc->GetMeStmt());
+            }
+          }
+        }
+        break;
+      }
+      case kOccPhiocc:
+      case kOccExit:
+      case kOccUse:
+      case kOccMembar:
+        break;
+      default:
+        ASSERT(false, "should not be here");
+        break;
+    }
+  }
+}
+
+void MeStmtPre::Finalize1() {
+  PreWorkCand *workCand = GetWorkCand();
+  std::vector<MeOccur*> availDefVec(classCount, nullptr);
+  // traversal in preoder DT
+  for (MeOccur *occ : allOccs) {
+    uint32 classId = static_cast<uint32>(occ->GetClassID());
+    switch (occ->GetOccType()) {
+      case kOccPhiocc: {
+        auto *phiOcc = static_cast<MePhiOcc*>(occ);
+        if (phiOcc->IsWillBeAvail()) {
+          availDefVec[classId] = phiOcc;
+        }
+        break;
+      }
+      case kOccReal: {
+        MeOccur *availDef = availDefVec[classId];
+        auto *realOcc = static_cast<MeRealOcc*>(occ);
+        if (availDef == nullptr || !availDef->IsDominate(*dom, *occ)) {
+          realOcc->SetIsReload(false);
+          availDefVec[classId] = realOcc;
+        } else {
+          realOcc->SetIsReload(true);
+          ASSERT(!realOcc->IsSave(), "real occ with isSave cannot be set isReload");
+          realOcc->SetDef(availDefVec[classId]);
+          CHECK_NULL_FATAL(realOcc->GetDef());
+        }
+        break;
+      }
+      case kOccPhiopnd: {
+        // we assume one phiOpnd has only one phiOcc use because critical edge split the blocks
+        auto *phiOpnd = static_cast<MePhiOpndOcc*>(occ);
+        MePhiOcc *phiOcc = phiOpnd->GetDefPhiOcc();
+        if (phiOcc->IsWillBeAvail()) {
+          if (phiOpnd->IsOkToInsert()) {
+            // insert the current expression at the end of the block containing phiOpnd
+            if (phiOpnd->GetBB()->GetSucc().size() > 1) {
+              CHECK_FATAL(!workCand->Redo2HandleCritEdges(), "Finalize1: insertion at critical edge; aborting");
+              workCand->SetRedo2HandleCritEdges(true);
+              if (GetSSAPreDebug()) {
+                mirModule->GetOut() << "<<<<< Re-doing this candidate due to existence of critical edge >>>>>\n";
+              }
+              return;
+            }
+            MeStmt *insertedStmt = phiOpnd->GetCurrentMeStmt();
+            ASSERT(insertedStmt != nullptr, "NYI");
+            MeInsertedOcc *insertedOcc =
+                perCandMemPool->New<MeInsertedOcc>(static_cast<MeExpr*>(nullptr), insertedStmt, *phiOpnd->GetBB());
+            insertedOcc->SetClassID(classCount++);
+            phiOpnd->SetDef(insertedOcc);
+            phiOpnd->SetClassID(insertedOcc->GetClassID());
+            if (workCand->GetPUIdx() != GetPUIdx()) {
+              ASSERT(!workCand->HasLocalOpnd(), "candidate with local opnd cannot be inserted outside its PU");
+              workCand->SetPUIdx(0);
+            }
+            phiOpnd->SetIsInsertedOcc(true);
+          } else {
+            phiOpnd->SetDef(availDefVec[classId]);
+          }
+        }
+        break;
+      }
+      case kOccExit:
+      case kOccUse:
+      case kOccMembar:
+        break;
+      default:
+        ASSERT(false, "should not be here");
+        break;
+    }
+  }
+  if (GetSSAPreDebug()) {
+    PreWorkCand *curCand = workCand;
+    mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() <<
+        " after Finalize1===================\n";
+    for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+      MePhiOcc *phiOcc = *it;
+      if (phiOcc->IsWillBeAvail()) {
+        for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+          ASSERT(phiOpnd->GetDef() != nullptr, "EPhiFinalizer::DumpFinalize1: phiopndocc cannot have no def");
+          MeOccur *defOcc = phiOpnd->GetDef();
+          if (defOcc->GetOccType() == kOccInserted) {
+            auto *realDefOcc = static_cast<MeInsertedOcc*>(defOcc);
+            phiOpnd->Dump(*irMap);
+            mirModule->GetOut() << " was inserted by ";
+            realDefOcc->Dump(*irMap);
+            mirModule->GetOut() << "\n";
+          }
+        }
+      }
+    }
+  }
+}
+
+bool MeStmtPre::AllVarsSameVersion(const MeRealOcc &realOcc1, const MeRealOcc &realOcc2) const {
+  const MeStmt *stmt1 = realOcc1.GetMeStmt();
+  Opcode op = stmt1->GetOp();
+  if (op == OP_intrinsiccallwithtype) {
+    return true;
+  }
+  if ((op == OP_dassign || op == OP_callassigned) && realOcc1.GetMeExpr() != realOcc2.GetMeExpr()) {
+    return false;
+  }
+  const MeStmt *stmt2 = realOcc2.GetMeStmt();
+  for (size_t i = 0; i < stmt1->NumMeStmtOpnds(); ++i) {
+    if (stmt1->GetOpnd(i) != stmt2->GetOpnd(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// collect meExpr's variables and put them into varvec;
+// varvec can only store RegMeExpr and VarMeExpr
+void MeStmtPre::CollectVarForMeStmt(const MeStmt &meStmt, MeExpr *meExpr, std::vector<MeExpr*> &varVec) const {
+  switch (meStmt.GetOp()) {
+    CASE_OP_ASSERT_NONNULL {
+      auto *unaryStmt = static_cast<const UnaryMeStmt*>(&meStmt);
+      if (unaryStmt->GetOpnd()->GetMeOp() == kMeOpVar || unaryStmt->GetOpnd()->GetMeOp() == kMeOpReg) {
+        varVec.push_back(unaryStmt->GetOpnd());
+      }
+      break;
+    }
+    CASE_OP_ASSERT_BOUNDARY {
+      auto *naryStmt = static_cast<const NaryMeStmt*>(&meStmt);
+      for (auto *opnd : naryStmt->GetOpnds()) {
+        if (opnd->GetMeOp() == kMeOpVar || opnd->GetMeOp() == kMeOpReg) {
+          varVec.push_back(opnd);
+        }
+      }
+      break;
+    }
+    case OP_dassign: {
+      auto *dassMeStmt = static_cast<const DassignMeStmt*>(&meStmt);
+      if (dassMeStmt->GetRHS()->GetMeOp() == kMeOpVar || dassMeStmt->GetRHS()->GetMeOp() == kMeOpReg) {
+        varVec.push_back(dassMeStmt->GetRHS());
+      }
+      if (meExpr != nullptr) {
+        CHECK_FATAL(meExpr->GetMeOp() == kMeOpVar, "CollectVarForMeStmt:bad meExpr field in realocc node");
+        varVec.push_back(meExpr);
+      }
+      break;
+    }
+    case OP_intrinsiccallwithtype:
+    case OP_intrinsiccall:
+    case OP_callassigned: {
+      auto *nStmt = static_cast<const NaryMeStmt*>(&meStmt);
+      for (size_t i = 0; i < nStmt->NumMeStmtOpnds(); ++i) {
+        if (nStmt->GetOpnd(i)->GetMeOp() == kMeOpVar || nStmt->GetOpnd(i)->GetMeOp() == kMeOpReg) {
+          varVec.push_back(nStmt->GetOpnd(i));
+        }
+      }
+      if (meExpr != nullptr) {
+        CHECK_FATAL(meExpr->GetMeOp() == kMeOpVar, "CollectVarForMeStmt:bad meExpr field in realocc node");
+        varVec.push_back(meExpr);
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "MeStmtEPre::CollectVarForCand: NYI");
+  }
+}
+
+void MeStmtPre::CollectVarForCand(MeRealOcc &realOcc, std::vector<MeExpr*> &varVec) const {
+  CollectVarForMeStmt(*realOcc.GetMeStmt(), realOcc.GetMeExpr(), varVec);
+}
+
+static MeStmt *CopyMeStmt(IRMap *irMap, const MeStmt &meStmt) {
+  MeStmt *newStmt = nullptr;
+  switch (meStmt.GetOp()) {
+    case OP_callassertnonnull: {
+      auto *callAssertStmt = static_cast<const CallAssertNonnullMeStmt*>(&meStmt);
+      newStmt = irMap->New<CallAssertNonnullMeStmt>(*callAssertStmt);
+      break;
+    }
+    case OP_assertlt:
+    case OP_assertge:
+    case OP_assignassertle:
+    case OP_calcassertge:
+    case OP_calcassertlt:
+    case OP_returnassertle: {
+      auto *naryStmt = static_cast<const AssertBoundaryMeStmt*>(&meStmt);
+      newStmt = irMap->NewInPool<AssertBoundaryMeStmt>(*naryStmt);
+      break;
+    }
+    case OP_callassertle: {
+      auto *callAssertStmt = static_cast<const CallAssertBoundaryMeStmt*>(&meStmt);
+      newStmt = irMap->NewInPool<CallAssertBoundaryMeStmt>(*callAssertStmt);
+      break;
+    }
+    case OP_dassign: {
+      auto *dass = static_cast<const DassignMeStmt*>(&meStmt);
+      newStmt = irMap->New<DassignMeStmt>(&irMap->GetIRMapAlloc(), dass);
+      break;
+    }
+    case OP_intrinsiccall:
+    case OP_intrinsiccallwithtype: {
+      auto *intrnStmt = static_cast<const IntrinsiccallMeStmt*>(&meStmt);
+      newStmt = irMap->NewInPool<IntrinsiccallMeStmt>(intrnStmt);
+      break;
+    }
+    case OP_callassigned: {
+      auto *callAss = static_cast<const CallMeStmt*>(&meStmt);
+      newStmt = irMap->NewInPool<CallMeStmt>(callAss);
+      break;
+    }
+    case OP_assertnonnull:
+    case OP_assignassertnonnull:
+    case OP_returnassertnonnull: {
+      auto *assertStmt = static_cast<const AssertNonnullMeStmt*>(&meStmt);
+      newStmt = irMap->New<AssertNonnullMeStmt>(*assertStmt);
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "MeStmtEPre::CopyMeStmt: NYI");
+  }
+  newStmt->CopyInfo(meStmt);
+  return newStmt;
+}
+
+// for each variable in realz that is defined by a phi, replace it by the jth
+// phi opnd; the tagged lhs is returned in the reference parameter lhsvar
+MeStmt *MeStmtPre::PhiOpndFromRes4Stmt(MeRealOcc &realZ, size_t j, MeExpr *&lhsVar) const {
+  MeOccur *defZ = realZ.GetDef();
+  CHECK_FATAL(defZ != nullptr, "must be def by phiocc");
+  CHECK_FATAL(defZ->GetOccType() == kOccPhiocc, "must be def by phiocc");
+  MeStmt *stmtQ = CopyMeStmt(irMap, utils::ToRef(realZ.GetMeStmt()));
+  lhsVar = realZ.GetMeExpr();
+  BB *phiBB = defZ->GetBB();
+  CHECK_FATAL(stmtQ != nullptr, "nullptr check");
+  switch (stmtQ->GetOp()) {
+    CASE_OP_ASSERT_NONNULL {
+      auto *unaryStmtQ = static_cast<UnaryMeStmt*>(stmtQ);
+      MeExpr *retOpnd = GetReplaceMeExpr(*unaryStmtQ->GetOpnd(), *phiBB, j);
+      if (retOpnd != nullptr) {
+        unaryStmtQ->SetMeStmtOpndValue(retOpnd);
+      }
+      break;
+    }
+    CASE_OP_ASSERT_BOUNDARY {
+      auto *naryStmtQ = static_cast<NaryMeStmt*>(stmtQ);
+      for (size_t i = 0; i < naryStmtQ->GetOpnds().size(); ++i) {
+        auto *opnd = naryStmtQ->GetOpnd(i);
+        MeExpr *retOpnd = GetReplaceMeExpr(*opnd, *phiBB, j);
+        if (retOpnd != nullptr) {
+          naryStmtQ->SetOpnd(i, retOpnd);
+        }
+      }
+      break;
+    }
+    case OP_dassign: {
+      auto *dassQ = static_cast<DassignMeStmt*>(stmtQ);
+      MeExpr *retOpnd = GetReplaceMeExpr(*dassQ->GetRHS(), *phiBB, j);
+      if (retOpnd != nullptr) {
+        dassQ->SetRHS(retOpnd);
+      }
+      break;
+    }
+    case OP_intrinsiccall:
+    case OP_intrinsiccallwithtype:
+    case OP_callassigned: {
+      auto *nStmtQ = static_cast<NaryMeStmt*>(stmtQ);
+      for (size_t i = 0; i < nStmtQ->NumMeStmtOpnds(); ++i) {
+        MeExpr *retOpnd = GetReplaceMeExpr(*nStmtQ->GetOpnd(i), *phiBB, j);
+        if (retOpnd != nullptr) {
+          nStmtQ->SetOpnd(i, retOpnd);
+        }
+      }
+      break;
+    }
+    default:
+      ASSERT(false, "MeStmtPre::PhiOpndFromRes4Stmt: NYI");
+      break;
+  }
+  if ((stmtQ->GetOp() == OP_dassign || stmtQ->GetOp() == OP_callassigned) && realZ.GetMeExpr() != nullptr) {
+    MeExpr *retOpnd = GetReplaceMeExpr(*realZ.GetMeExpr(), *phiBB, j);
+    if (retOpnd != nullptr) {
+      lhsVar = retOpnd;
+    }
+  }
+  return stmtQ;
+}
+
+void MeStmtPre::Rename2() {
+  PreWorkCand *workCand = GetWorkCand();
+  while (!rename2Set.empty()) {
+    MapleSet<uint32>::iterator it = rename2Set.begin();
+    MeRealOcc *realOcc = workCand->GetRealOcc(*it);
+    (void)rename2Set.erase(it);
+    MeOccur *defOcc = realOcc->GetDef();
+    CHECK_FATAL(defOcc != nullptr, "should be def by phiocc");
+    CHECK_FATAL(defOcc->GetOccType() == kOccPhiocc, "should be def by phiocc");
+    auto *defPhiOcc = static_cast<MePhiOcc*>(defOcc);
+    MapleVector<MePhiOpndOcc*> &phiOpnds = defPhiOcc->GetPhiOpnds();
+    for (size_t i = 0; i < phiOpnds.size(); ++i) {
+      MePhiOpndOcc *phiOccOpnd = phiOpnds[i];
+      if (!phiOccOpnd->IsProcessed()) {
+        phiOccOpnd->SetIsProcessed(true);
+        MeExpr *varY = nullptr;
+        MeStmt *stmtY = PhiOpndFromRes4Stmt(*realOcc, i, varY);
+        stmtY->SetBB(phiOccOpnd->GetBB());
+        phiOccOpnd->SetCurrentMeStmt(*stmtY);  // stmtY might be inserted at the end of the block
+        MeOccur *defX = phiOccOpnd->GetDef();
+        if (defX == nullptr) {
+          continue;
+        }
+        if (defX->GetOccType() == kOccReal) {
+          auto *realDefX = static_cast<MeRealOcc*>(defX);
+          std::vector<MeExpr*> varVecX;
+          std::vector<MeExpr*> varVecY;
+          CollectVarForCand(*realDefX, varVecX);
+          CollectVarForMeStmt(*stmtY, varY, varVecY);
+          CHECK_FATAL(varVecX.size() == varVecY.size(), "vector size should be the same");
+          bool hasSameVersion = true;
+          size_t checkLimit = varVecY.size();
+          if (varY != nullptr) {
+            if (varVecY[checkLimit - 1] == realDefX->GetMeStmt()->GetVarLHS()) {
+              --checkLimit;
+            }
+          }
+          for (size_t j = 0; j < checkLimit; ++j) {
+            if (varVecX[j] != varVecY[j]) {
+              hasSameVersion = false;
+            }
+          }
+          if (!hasSameVersion) {
+            phiOccOpnd->SetDef(nullptr);
+            phiOccOpnd->SetHasRealUse(false);
+          }
+        } else if (defX->GetOccType() == kOccPhiocc) {
+          std::vector<MeExpr*> varVecY;
+          bool allDom = true;
+          CollectVarForMeStmt(*stmtY, varY, varVecY);
+          size_t checkLimit = varVecY.size();
+          if (varY != nullptr) {
+            if (varVecY[checkLimit - 1] == stmtY->GetVarLHS()) {
+              --checkLimit;
+            }
+          }
+          for (size_t k = 0; k < checkLimit; ++k) {
+            if (!DefVarDominateOcc(varVecY[k], *defX)) {
+              allDom = false;
+            }
+          }
+          if (allDom) {
+            // create a realOcc and add to rename2 set
+            MeRealOcc *occY = perCandMemPool->New<MeRealOcc>(stmtY, 0, varY);
+            occY->SetPosition(workCand->GetRealOccs().size());
+            workCand->GetRealOccs().push_back(occY);
+            occY->SetDef(defX);
+            occY->SetClassID(defX->GetClassID());
+            (void)rename2Set.insert(occY->GetPosition());
+            if (GetSSAPreDebug()) {
+              mirModule->GetOut() << "--- rename2 adds to rename2Set manufactured ";
+              occY->Dump(*irMap);
+              mirModule->GetOut() << '\n';
+            }
+          } else {
+            phiOccOpnd->SetDef(nullptr);
+            phiOccOpnd->SetHasRealUse(false);
+            auto *phiDefX = static_cast<MePhiOcc*>(defX);
+            phiDefX->SetIsDownSafe(false);
+          }
+        }
+      }
+    }
+  }
+  if (GetSSAPreDebug()) {
+    PreWorkCand *curCand = workCand;
+    mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() << " after rename2===================\n";
+    for (MeOccur *occ : allOccs) {
+      occ->Dump(*irMap);
+      mirModule->GetOut() << '\n';
+    }
+  }
+}
+
+// Df phis are computed into the df_phis set; Var Phis in the var_phis set
+void MeStmtPre::ComputeVarAndDfPhis() {
+  varPhiDfns.clear();
+  dfPhiDfns.clear();
+  PreWorkCand *workCand = GetWorkCand();
+  const MapleVector<MeRealOcc*> &realOccList = workCand->GetRealOccs();
+  CHECK_FATAL(!dom->IsNodeVecEmpty(), "size to be allocated is 0");
+  for (auto it = realOccList.begin(); it != realOccList.end(); ++it) {
+    MeRealOcc *realOcc = *it;
+    if (realOcc->GetOccType() == kOccMembar) {
+      continue;
+    }
+    BB *defBB = realOcc->GetMeStmt()->GetBB();
+    GetIterDomFrontier(defBB, &dfPhiDfns);
+    MeStmt *stmt = realOcc->GetMeStmt();
+    switch (stmt->GetOp()) {
+      CASE_OP_ASSERT_NONNULL {
+        auto *unaryStmt = static_cast<UnaryMeStmt*>(stmt);
+        SetVarPhis(unaryStmt->GetOpnd());
+        break;
+      }
+      CASE_OP_ASSERT_BOUNDARY {
+        auto *naryStmt = static_cast<NaryMeStmt*>(stmt);
+        for (auto *opnd : naryStmt->GetOpnds()) {
+          SetVarPhis(opnd);
+        }
+        break;
+      }
+      case OP_dassign: {
+        auto *dassMeStmt = static_cast<DassignMeStmt*>(stmt);
+        SetVarPhis(dassMeStmt->GetRHS());
+        SetVarPhis(realOcc->GetMeExpr());
+        break;
+      }
+      case OP_intrinsiccall:
+      case OP_intrinsiccallwithtype:
+      case OP_callassigned: {
+        auto *nStmt = static_cast<NaryMeStmt*>(stmt);
+        for (size_t i = 0; i < nStmt->NumMeStmtOpnds(); ++i) {
+          SetVarPhis(nStmt->GetOpnd(i));
+        }
+        if (realOcc->GetMeExpr() != nullptr) {
+          SetVarPhis(realOcc->GetMeExpr());
+        }
+        break;
+      }
+      default:
+        CHECK_FATAL(false, "NYI");
+    }
+  }
+  std::set<uint32> tmpVarPhi(varPhiDfns.begin(), varPhiDfns.end());
+  for (uint32 dfn : tmpVarPhi) {
+    GetIterDomFrontier(GetBB(dom->GetDtPreOrderItem(dfn)), &varPhiDfns);
+  }
+}
+
+// Based on ssapre->workCand's realOccs and dfPhiDfns (which will privides all
+// the inserted phis) and the mapped set in useOccurMap,
+// create the phi, phiopnd occ nodes and use_occ nodes; link them all
+// up in order of dt_preorder in ssapre->allOccs; the phi occ nodes are in
+// addition provided in order of dt_preorder in ssapre->phiOccs.
+// When a real_occ has uses before it in its bb, ignore (do not insert)
+// the real_occ.
+void MeStmtPre::CreateSortedOccs() {
+  // get set of bb dfns that contain uses if candidate is dassign or callassigned
+  MapleSet<uint32> *useDfns;
+  PreWorkCand *workCand = GetWorkCand();
+  auto *stmtWkCand = static_cast<PreStmtWorkCand*>(workCand);
+  if ((stmtWkCand->GetTheMeStmt()->GetOp() == OP_dassign || stmtWkCand->GetTheMeStmt()->GetOp() == OP_callassigned) &&
+       stmtWkCand->GetTheMeStmt()->GetVarLHS() != nullptr && !stmtWkCand->LHSIsFinal()) {
+    VarMeExpr *lhsVar = static_cast<VarMeExpr*>(stmtWkCand->GetTheMeStmt()->GetVarLHS());
+    OStIdx ostIdx = lhsVar->GetOstIdx();
+    auto uMapIt = useOccurMap.find(ostIdx);
+    CHECK_FATAL(uMapIt != useOccurMap.end(), "MeStmtPre::CreateSortedOccs: missing entry in useOccurMap");
+    useDfns = uMapIt->second;
+  } else {
+    // create empty MapleSet<uint32> to be pointed to by use_dfns
+    useDfns = perCandMemPool->New<MapleSet<uint32>>(perCandAllocator.Adapter());
+  }
+  // merge varPhiDfns to dfPhiDfns
+  dfPhiDfns.insert(varPhiDfns.cbegin(), varPhiDfns.cend());
+  // form phiopnd_dfns
+  std::multiset<uint32> phiOpndDfns;
+  for (uint32 dfn : dfPhiDfns) {
+    auto bbId = dom->GetDtPreOrderItem(dfn);
+    BB *bb = GetBB(bbId);
+    CHECK_FATAL(bb != nullptr, "GetBB error");
+    for (BB *pred : bb->GetPred()) {
+      (void)phiOpndDfns.insert(dom->GetDtDfnItem(pred->GetBBId()));
+    }
+  }
+  std::unordered_map<BBId, std::forward_list<MePhiOpndOcc*>> bb2PhiOpndMap;
+  MapleVector<MeRealOcc*>::iterator realOccIt = workCand->GetRealOccs().begin();
+  MapleVector<MeOccur*>::iterator exitOccIt = exitOccs.begin();
+  auto phiDfnIt = dfPhiDfns.begin();
+  auto phiOpndDfnIt = phiOpndDfns.begin();
+  auto useDfnIt = useDfns->begin();
+  MeOccur *nextUseOcc = nullptr;
+  if (useDfnIt != useDfns->end()) {
+    nextUseOcc = perCandMemPool->New<MeOccur>(kOccUse, 0, *GetBB(dom->GetDtPreOrderItem(*useDfnIt)), nullptr);
+  }
+  MeRealOcc *nextRealOcc = nullptr;
+  if (realOccIt != workCand->GetRealOccs().end()) {
+    nextRealOcc = *realOccIt;
+  }
+  MeOccur *nextExitOcc = nullptr;
+  if (exitOccIt != exitOccs.end()) {
+    nextExitOcc = *exitOccIt;
+  }
+  MePhiOcc *nextPhiOcc = nullptr;
+  if (phiDfnIt != dfPhiDfns.end()) {
+    nextPhiOcc = perCandMemPool->New<MePhiOcc>(*GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), perCandAllocator);
+  }
+  MePhiOpndOcc *nextPhiOpndOcc = nullptr;
+  if (phiOpndDfnIt != phiOpndDfns.end()) {
+    nextPhiOpndOcc = perCandMemPool->New<MePhiOpndOcc>(*GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt)));
+    std::unordered_map<BBId, std::forward_list<MePhiOpndOcc*>>::iterator it =
+        bb2PhiOpndMap.find(BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt)));
+    if (it == bb2PhiOpndMap.end()) {
+      std::forward_list<MePhiOpndOcc*> newList = { nextPhiOpndOcc };
+      CHECK(*phiOpndDfnIt < dom->GetDtPreOrderSize(), "index out of range in SSAPre::CreateSortedOccs");
+      bb2PhiOpndMap[BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt))] = newList;
+    } else {
+      it->second.push_front(nextPhiOpndOcc);
+    }
+  }
+  bool realOccInserted = false;
+  MeOccur *pickedOcc = nullptr;  // the next picked occ in order of preorder traveral of dominator tree
+  do {
+    pickedOcc = nullptr;
+    // the 5 kinds of occ must be checked in this order, so it will be right
+    // if more than 1 has the same dfn
+    if (nextPhiOcc != nullptr) {
+      pickedOcc = nextPhiOcc;
+    }
+    if (nextRealOcc != nullptr && (pickedOcc == nullptr ||
+        dom->GetDtDfnItem(nextRealOcc->GetBB()->GetBBId()) < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) {
+      pickedOcc = nextRealOcc;
+    }
+    if (nextUseOcc != nullptr && (pickedOcc == nullptr ||
+        dom->GetDtDfnItem(nextUseOcc->GetBB()->GetBBId()) < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) {
+      pickedOcc = nextUseOcc;
+    }
+    if (nextExitOcc != nullptr && (pickedOcc == nullptr ||
+        dom->GetDtDfnItem(nextExitOcc->GetBB()->GetBBId()) < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) {
+      pickedOcc = nextExitOcc;
+    }
+    if (nextPhiOpndOcc != nullptr && (pickedOcc == nullptr ||
+        *phiOpndDfnIt < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) {
+      pickedOcc = nextPhiOpndOcc;
+    }
+    if (pickedOcc != nullptr) {
+      allOccs.push_back(pickedOcc);
+      switch (pickedOcc->GetOccType()) {
+        case kOccUse: {
+          // get the next use occ
+          ASSERT(useDfnIt != useDfns->end(), "check useDfnIt");
+          ++useDfnIt;
+          if (useDfnIt != useDfns->end()) {
+            CHECK_NULL_FATAL(GetBB(dom->GetDtPreOrderItem(*useDfnIt)));
+            nextUseOcc = perCandMemPool->New<MeOccur>(kOccUse, 0, *GetBB(dom->GetDtPreOrderItem(*useDfnIt)), nullptr);
+          } else {
+            nextUseOcc = nullptr;
+          }
+          break;
+        }
+        case kOccReal:
+        case kOccMembar:
+          // get the next real occ
+          ASSERT(realOccIt != workCand->GetRealOccs().end(), "check realOccIt");
+          ++realOccIt;
+          if (realOccIt != workCand->GetRealOccs().end()) {
+            nextRealOcc = *realOccIt;
+          } else {
+            nextRealOcc = nullptr;
+          }
+          realOccInserted = true;
+          break;
+        case kOccExit:
+          ASSERT(exitOccIt != exitOccs.end(), "check exitOccIt");
+          ++exitOccIt;
+          if (exitOccIt != exitOccs.end()) {
+            nextExitOcc = *exitOccIt;
+          } else {
+            nextExitOcc = nullptr;
+          }
+          break;
+        case kOccPhiocc:
+          phiOccs.push_back(static_cast<MePhiOcc*>(pickedOcc));
+          ASSERT(phiDfnIt != dfPhiDfns.end(), "check phiDfnIt");
+          ++phiDfnIt;
+          if (phiDfnIt != dfPhiDfns.end()) {
+            nextPhiOcc = perCandMemPool->New<MePhiOcc>(*GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), perCandAllocator);
+          } else {
+            nextPhiOcc = nullptr;
+          }
+          break;
+        case kOccPhiopnd:
+          ASSERT(phiOpndDfnIt != phiOpndDfns.end(), "check phiOpndDfnIt");
+          ++phiOpndDfnIt;
+          if (phiOpndDfnIt != phiOpndDfns.end()) {
+            nextPhiOpndOcc = perCandMemPool->New<MePhiOpndOcc>(*GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt)));
+            std::unordered_map<BBId, std::forward_list<MePhiOpndOcc*>>::iterator it =
+                bb2PhiOpndMap.find(BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt)));
+            if (it == bb2PhiOpndMap.end()) {
+              std::forward_list<MePhiOpndOcc*> newList = { nextPhiOpndOcc };
+              bb2PhiOpndMap[BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt))] = newList;
+            } else {
+              it->second.push_front(nextPhiOpndOcc);
+            }
+          } else {
+            nextPhiOpndOcc = nullptr;
+          }
+          break;
+        default:
+          ASSERT(false, "CreateSortedOccs: unexpected occty");
+          break;
+      }
+    }
+  } while (pickedOcc != nullptr);
+  // if no real occ inserted, no more work for this workCand
+  if (!realOccInserted) {
+    workCand->GetRealOccs().clear();
+  }
+  // initialize phiOpnds vector in each MePhiOcc node and defPhiOcc field in
+  // each MePhiOpndOcc node
+  for (MePhiOcc *phiOcc : phiOccs) {
+    for (BB *pred : phiOcc->GetBB()->GetPred()) {
+      MePhiOpndOcc *phiOpndOcc = bb2PhiOpndMap[pred->GetBBId()].front();
+      phiOcc->AddPhiOpnd(*phiOpndOcc);
+      phiOpndOcc->SetDefPhiOcc(*phiOcc);
+      bb2PhiOpndMap[pred->GetBBId()].pop_front();
+    }
+  }
+  if (GetSSAPreDebug()) {
+    mirModule->GetOut() << "========ssapre candidate " << workCand->GetIndex() <<
+        " after phi insert===================\n";
+    for (MeOccur *occ : allOccs) {
+      occ->Dump(*irMap);
+      mirModule->GetOut() << '\n';
+    }
+  }
+}
+
+void MeStmtPre::ConstructUseOccurMapExpr(uint32 bbDfn, const MeExpr &meExpr) {
+  if (meExpr.GetMeOp() == kMeOpVar) {
+    OStIdx ostIdx = static_cast<const VarMeExpr*>(&meExpr)->GetOstIdx();
+    auto mapIt = useOccurMap.find(ostIdx);
+    if (mapIt == useOccurMap.end()) {
+      return;
+    }
+    MapleSet<uint32> *bbDfnSet = mapIt->second;
+    (void)bbDfnSet->insert(bbDfn);
+    return;
+  }
+  for (uint8 i = 0; i < meExpr.GetNumOpnds(); ++i) {
+    ConstructUseOccurMapExpr(bbDfn, *meExpr.GetOpnd(i));
+  }
+}
+
+void MeStmtPre::ConstructUseOccurMap() {
+  for (PreWorkCand *wkCand : std::as_const(workList)) {
+    auto *stmtWkCand = static_cast<PreStmtWorkCand*>(wkCand);
+    if (stmtWkCand->GetTheMeStmt()->GetOp() != OP_dassign && stmtWkCand->GetTheMeStmt()->GetOp() != OP_callassigned) {
+      continue;
+    }
+    if (stmtWkCand->LHSIsFinal()) {
+      continue;
+    }
+    VarMeExpr *lhsVar = static_cast<VarMeExpr *>(stmtWkCand->GetTheMeStmt()->GetVarLHS());
+    if (lhsVar == nullptr) {
+      continue;
+    }
+    OStIdx ostIdx = lhsVar->GetOstIdx();
+    if (useOccurMap.find(ostIdx) == useOccurMap.end()) {
+      // add an entry for ostIdx
+      useOccurMap[ostIdx] = ssaPreMemPool->New<MapleSet<uint32>>(ssaPreAllocator.Adapter());
+    }
+  }
+  // do a pass over the program
+  const auto &preOrderDt = dom->GetDtPreOrder();
+  auto cfg = func->GetCfg();
+  for (size_t i = 0; i < preOrderDt.size(); ++i) {
+    BB *bb = cfg->GetAllBBs().at(preOrderDt[i]);
+    for (auto &stmt : bb->GetMeStmts()) {
+      for (size_t j = 0; j < stmt.NumMeStmtOpnds(); ++j) {
+        ConstructUseOccurMapExpr(static_cast<uint32>(i), *stmt.GetOpnd(j));
+      }
+    }
+  }
+}
+
+// create a new realOcc based on meStmt
+PreStmtWorkCand *MeStmtPre::CreateStmtRealOcc(MeStmt &meStmt, int seqStmt) {
+  if (meStmt.GetLHS() != nullptr && meStmt.GetLHS()->IsVolatile()) {
+    return nullptr;
+  }
+  uint32 hashIdx = PreWorkCandHashTable::ComputeStmtWorkCandHashIndex(meStmt);
+  auto *wkCand = static_cast<PreStmtWorkCand*>(preWorkCandHashTable.GetWorkcandFromIndex(hashIdx));
+  while (wkCand != nullptr) {
+    MeStmt *currStmt = wkCand->GetTheMeStmt();
+    ASSERT(currStmt != nullptr, "CreateStmtRealOcc: found workcand with theMeStmt as nullptr");
+    if (currStmt->IsTheSameWorkcand(meStmt)) {
+      break;
+    }
+    wkCand = static_cast<PreStmtWorkCand*>(wkCand->GetNext());
+  }
+  MeExpr *meExpr = nullptr;
+  if ((meStmt.GetOp() == OP_dassign || meStmt.GetOp() == OP_callassigned) && meStmt.GetVarLHS() != nullptr) {
+    MapleStack<ScalarMeExpr*> *pStack = versionStackVec.at(meStmt.GetVarLHS()->GetOstIdx());
+    meExpr = pStack->top();
+  }
+  MeRealOcc *newOcc = ssaPreMemPool->New<MeRealOcc>(&meStmt, seqStmt, meExpr);
+  if (wkCand != nullptr) {
+    wkCand->AddRealOccAsLast(*newOcc, GetPUIdx());
+    return wkCand;
+  }
+  // workCand not yet created; create a new one and add to workList
+  wkCand = ssaPreMemPool->New<PreStmtWorkCand>(ssaPreAllocator, meStmt, GetPUIdx());
+  wkCand->SetHasLocalOpnd(true);  // dummy
+  workList.push_back(wkCand);
+  wkCand->AddRealOccAsLast(*newOcc, GetPUIdx());
+  // add to bucket at workcandHashTable[hashIdx]
+  wkCand->SetNext(*preWorkCandHashTable.GetWorkcandFromIndex(hashIdx));
+  preWorkCandHashTable.SetWorkCandAt(hashIdx, *wkCand);
+  return wkCand;
+}
+
+void MeStmtPre::VersionStackChiListUpdate(const MapleMap<OStIdx, ChiMeNode*> &chiList) {
+  for (auto it = chiList.begin(); it != chiList.end(); ++it) {
+    const OriginalSt *ost = it->second->GetLHS()->GetOst();
+    if (!ost->IsSymbolOst() || ost->GetIndirectLev() != 0) {
+      continue;
+    }
+    MapleStack<ScalarMeExpr*> *pStack = versionStackVec.at(it->second->GetLHS()->GetOstIdx());
+    pStack->push(it->second->GetLHS());
+  }
+}
+
+// verify that there is no prior use of lhsVar before stmt in its BB
+static bool NoPriorUseInBB(const OStIdx &ostIdx, const MeStmt *defStmt) {
+  for (MeStmt *stmt = defStmt->GetPrev(); stmt != nullptr; stmt = stmt->GetPrev()) {
+    for (size_t i = 0; i < stmt->NumMeStmtOpnds(); ++i) {
+      CHECK_FATAL(stmt->GetOpnd(i) != nullptr, "null ptr check");
+      if (stmt->GetOpnd(i)->SymAppears(ostIdx)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+void MeStmtPre::BuildWorkListBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+  // record stack size for variable versions, used for stack pop up at return
+  std::vector<size_t> curStackSizeVec;
+  curStackSizeVec.resize(versionStackVec.size());
+  for (size_t i = 1; i < versionStackVec.size(); ++i) {
+    if (versionStackVec[i] == nullptr) {
+      continue;
+    }
+    curStackSizeVec[i] = versionStackVec[i]->size();
+  }
+  // traverse var phi nodes to update versionStack
+  MapleMap<OStIdx, MePhiNode*> &mePhiList = bb->GetMePhiList();
+  for (auto &it : std::as_const(mePhiList)) {
+    MePhiNode *phiMeNode = it.second;
+    const OriginalSt *ost = phiMeNode->GetLHS()->GetOst();
+    if (!ost->IsSymbolOst() || ost->GetIndirectLev() != 0) {
+      continue;
+    }
+    MapleStack<ScalarMeExpr*> *pStack = versionStackVec.at(phiMeNode->GetLHS()->GetOstIdx());
+    pStack->push(phiMeNode->GetLHS());
+  }
+  // traverse statements
+  uint32 seqStmt = 0;
+  for (auto &stmt : bb->GetMeStmts()) {
+    ++seqStmt;
+    switch (stmt.GetOp()) {
+      case OP_jstry:
+      case OP_jscatch:
+      case OP_finally:
+      case OP_endtry:
+      case OP_cleanuptry:
+      case OP_try:
+      case OP_catch:
+      case OP_goto:
+      case OP_comment:
+      case OP_brtrue:
+      case OP_brfalse:
+      case OP_switch:
+      case OP_igoto:
+        break;
+      case OP_membaracquire:
+      case OP_membarrelease:
+      case OP_membarstoreload:
+      case OP_membarstorestore:
+        CreateMembarOcc(stmt, seqStmt);
+        break;
+      case OP_gosub:
+      case OP_retsub:
+      case OP_throw:
+      case OP_return:
+        break;
+      case OP_iassign: {
+        auto &iass = static_cast<IassignMeStmt&>(stmt);
+        auto *lhs = iass.GetLHSVal();
+        auto *rhs = iass.GetRHS();
+        const static auto identicalAssign = [](const IvarMeExpr *lhs, const IvarMeExpr *rhs) -> bool {
+          return lhs->GetOp() == rhs->GetOp() && lhs->GetBase() == rhs->GetBase() &&
+                 lhs->GetPrimType() == rhs->GetPrimType() && lhs->GetTyIdx() == rhs->GetTyIdx() &&
+                 lhs->GetOffset() == rhs->GetOffset() && lhs->GetFieldID() == rhs->GetFieldID();
+        };
+        if (rhs->GetMeOp() == kMeOpIvar && identicalAssign(lhs, static_cast<IvarMeExpr*>(rhs))) {
+          RemoveUnnecessaryAssign(stmt);
+        }
+        VersionStackChiListUpdate(*iass.GetChiList());
+        break;
+      }
+      case OP_maydassign: {
+        auto &maydStmt = static_cast<MaydassignMeStmt&>(stmt);
+        VersionStackChiListUpdate(*maydStmt.GetChiList());
+        break;
+      }
+      case OP_regassign:
+      case OP_eval:
+      case OP_decref:
+      case OP_decrefreset:
+      case OP_incref:
+      case OP_free:
+      case OP_syncenter:
+      case OP_syncexit:
+        break;
+      case OP_asm:
+      case OP_call:
+      case OP_virtualcall:
+      case OP_virtualicall:
+      case OP_superclasscall:
+      case OP_interfacecall:
+      case OP_interfaceicall:
+      case OP_customcall:
+      case OP_polymorphiccall:
+      case OP_virtualcallassigned:
+      case OP_virtualicallassigned:
+      case OP_superclasscallassigned:
+      case OP_interfacecallassigned:
+      case OP_interfaceicallassigned:
+      case OP_customcallassigned:
+      case OP_polymorphiccallassigned: {
+        auto &callMeStmt = static_cast<CallMeStmt&>(stmt);
+        VersionStackChiListUpdate(*callMeStmt.GetChiList());
+        break;
+      }
+      case OP_icall:
+      case OP_icallassigned:
+      case OP_icallproto:
+      case OP_icallprotoassigned: {
+        auto &icallMeStmt = static_cast<IcallMeStmt&>(stmt);
+        VersionStackChiListUpdate(*icallMeStmt.GetChiList());
+        break;
+      }
+      case OP_xintrinsiccall:
+      case OP_intrinsiccallassigned:
+      case OP_xintrinsiccallassigned:
+      case OP_intrinsiccallwithtypeassigned: {
+        auto &intrinStmt = static_cast<IntrinsiccallMeStmt&>(stmt);
+        VersionStackChiListUpdate(*intrinStmt.GetChiList());
+        break;
+      }
+      CASE_OP_ASSERT_NONNULL {
+        auto &unaryStmt = static_cast<UnaryMeStmt&>(stmt);
+        if (!unaryStmt.GetOpnd()->IsLeaf()) {
+          break;
+        }
+        (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
+        break;
+      }
+      CASE_OP_ASSERT_BOUNDARY {
+        auto &naryStmt = static_cast<NaryMeStmt&>(stmt);
+        bool allIsLeaf = true;
+        for (auto *opnd : naryStmt.GetOpnds()) {
+          if (!opnd->IsLeaf()) {
+            allIsLeaf = false;
+            break;
+          }
+        }
+        if (allIsLeaf) {
+          (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
+        }
+        break;
+      }
+      case OP_dassign: {
+        auto &dassMeStmt = static_cast<DassignMeStmt&>(stmt);
+        if (!MeOption::dassignPre || !dassMeStmt.GetRHS()->IsLeaf() || !dassMeStmt.GetChiList()->empty() ||
+            dassMeStmt.NeedIncref() ||
+            (dassMeStmt.GetRHS()->GetOp() == OP_regread &&
+             static_cast<RegMeExpr*>(dassMeStmt.GetRHS())->GetRegIdx() == -kSregThrownval)) {
+          // update version stacks
+          MapleStack<ScalarMeExpr*> *pStack = versionStackVec.at(dassMeStmt.GetVarLHS()->GetOstIdx());
+          pStack->push(dassMeStmt.GetVarLHS());
+          VersionStackChiListUpdate(*dassMeStmt.GetChiList());
+          break;
+        }
+        VarMeExpr *varMeExpr = static_cast<VarMeExpr *>(dassMeStmt.GetVarLHS());
+        const OriginalSt *ost = varMeExpr->GetOst();
+        CHECK_FATAL(ost, "ost is nullptr");
+        if (ost->IsFinal()) {
+          PreStmtWorkCand *stmtWkCand = CreateStmtRealOcc(stmt, seqStmt);
+          ASSERT_NOT_NULL(stmtWkCand);
+          stmtWkCand->SetLHSIsFinal(true);
+        } else if (!dassMeStmt.GetRHS()->SymAppears(varMeExpr->GetOstIdx()) && dassMeStmt.GetRHS()->Pure()) {
+          if (NoPriorUseInBB(dassMeStmt.GetVarLHS()->GetOstIdx(), &stmt)) {
+            (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
+          }
+        } else if (dassMeStmt.GetLHS() != nullptr && dassMeStmt.GetLHS()->IsUseSameSymbol(*dassMeStmt.GetRHS())) {
+          RemoveUnnecessaryAssign(dassMeStmt);
+        }
+        // update version stacks
+        MapleStack<ScalarMeExpr*> *pStack = versionStackVec.at(dassMeStmt.GetVarLHS()->GetOstIdx());
+        pStack->push(dassMeStmt.GetVarLHS());
+        VersionStackChiListUpdate(*dassMeStmt.GetChiList());
+        break;
+      }
+      case OP_intrinsiccallwithtype: {
+        auto &intrnStmt = static_cast<IntrinsiccallMeStmt&>(stmt);
+        VersionStackChiListUpdate(*intrnStmt.GetChiList());
+        if (!MeOption::clinitPre) {
+          VersionStackChiListUpdate(*intrnStmt.GetChiList());
+          break;
+        }
+        if (intrnStmt.GetIntrinsic() == INTRN_JAVA_CLINIT_CHECK) {
+          (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
+        }
+        break;
+      }
+      case OP_intrinsiccall: {
+        auto &intrnStmt = static_cast<IntrinsiccallMeStmt&>(stmt);
+        bool allOperandsAreLeaf = true;
+        for (size_t i = 0; i < intrnStmt.NumMeStmtOpnds(); ++i) {
+          if (!intrnStmt.GetOpnd(i)->IsLeaf()) {
+            allOperandsAreLeaf = false;
+            break;
+          }
+        }
+        if (!allOperandsAreLeaf) {
+          break;
+        }
+        if (intrnStmt.GetIntrinsic() == INTRN_MPL_BOUNDARY_CHECK) {
+          (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
+        }
+        VersionStackChiListUpdate(*intrnStmt.GetChiList());
+        break;
+      }
+      case OP_callassigned: {
+        auto &callAss = static_cast<CallMeStmt&>(stmt);
+        VersionStackChiListUpdate(*callAss.GetChiList());
+        MIRFunction &callee = callAss.GetTargetFunction();
+        if (!callAss.GetChiList()->empty() || !callee.IsPure() || !callee.IsNoThrowException()) {
+          break;
+        }
+        if (IsParaAndRetTypeRefOrPtr(callAss)) {
+          break;
+        }
+
+        bool allOperandsAreLeafAndPure = true;
+        for (MeExpr *o : callAss.GetOpnds()) {
+          if (!o->IsLeaf() || !o->Pure()) {
+            allOperandsAreLeafAndPure = false;
+            break;
+          }
+        }
+        if (!allOperandsAreLeafAndPure) {
+          break;
+        }
+        if (callAss.GetMustDefList()->empty()) {
+          (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
+          break;
+        }
+        const OriginalSt *ost = callAss.GetMustDefList()->front().GetLHS()->GetOst();
+        if (ost->IsFinal()) {
+          PreStmtWorkCand *stmtWkCand = CreateStmtRealOcc(stmt, seqStmt);
+          ASSERT_NOT_NULL(stmtWkCand);
+          stmtWkCand->SetLHSIsFinal(true);
+        } else {
+          bool allOperandFeasible = true;
+          for (MeExpr *o : callAss.GetOpnds()) {
+            if (o->SymAppears(ost->GetIndex())) {
+              allOperandFeasible = false;
+              break;
+            }
+          }
+          if (allOperandFeasible && NoPriorUseInBB(ost->GetIndex(), &stmt)) {
+            (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
+          }
+        }
+        break;
+      }
+      default:
+        ASSERT(stmt.GetOp() == OP_comment, "must be OP_comment");
+        break;
+    }
+    if (kOpcodeInfo.IsCallAssigned(stmt.GetOp())) {
+      // update version stacks
+      MapleVector<MustDefMeNode> *mustDefList = stmt.GetMustDefList();
+      MapleVector<MustDefMeNode>::iterator it = mustDefList->begin();
+      for (; it != mustDefList->end(); ++it) {
+        MeExpr *meLHS = (*it).GetLHS();
+        if (meLHS->GetMeOp() == kMeOpVar) {
+          auto *lhsVar = static_cast<VarMeExpr*>(meLHS);
+          MapleStack<ScalarMeExpr*> *pStack = versionStackVec.at(lhsVar->GetOstIdx());
+          pStack->push(lhsVar);
+        }
+      }
+    }
+  }
+  if (bb->GetAttributes(kBBAttrIsExit) || bb->GetAttributes(kBBAttrWontExit)) {
+    CreateExitOcc(*bb);
+  }
+  // recurse on child BBs in dominator tree
+  const auto &domChildren = dom->GetDomChildren(bb->GetID());
+  for (auto bbIt = domChildren.begin(); bbIt != domChildren.end(); ++bbIt) {
+    auto childBBId = *bbIt;
+    BuildWorkListBB(GetBB(childBBId));
+  }
+  // pop the stacks back to their levels on entry
+  for (size_t i = 1; i < versionStackVec.size(); ++i) {
+    MapleStack<ScalarMeExpr*> *pStack = versionStackVec[i];
+    if (pStack == nullptr) {
+      continue;
+    }
+    size_t curSize = curStackSizeVec[i];
+    while (pStack->size() > curSize) {
+      pStack->pop();
+    }
+  }
+}
+
+void MeStmtPre::BuildWorkList() {
+  // initialize version stack
+  const MapleVector<OriginalSt*> &originalStVec = ssaTab->GetOriginalStTable().GetOriginalStVector();
+  for (size_t i = 1; i < originalStVec.size(); ++i) {
+    OriginalSt *ost = originalStVec[i];
+    if (!ost->IsSymbolOst() || ost->GetIndirectLev() != 0 || ost->GetVersionsIndices().empty()) {
+      continue;
+    }
+    MapleStack<ScalarMeExpr*> *varStack = ssaPreMemPool->New<MapleStack<ScalarMeExpr*>>(ssaPreAllocator.Adapter());
+    varStack->push(static_cast<VarMeExpr*>(irMap->GetOrCreateZeroVersionVarMeExpr(*ost)));
+    versionStackVec[ost->GetIndex()] = varStack;
+  }
+  BuildWorkListBB(func->GetCfg()->GetCommonEntryBB());
+}
+
+void MeStmtPre::RemoveUnnecessaryAssign(MeStmt &meStmt) {
+  BB *bb = meStmt.GetBB();
+  bb->RemoveMeStmt(&meStmt);
+  auto *lhs = meStmt.GetVarLHS();
+  if (lhs != nullptr) {
+    OStIdx ostIdx = lhs->GetOstIdx();
+    MeSSAUpdate::InsertOstToSSACands(ostIdx, *bb, &candsForSSAUpdate);
+  }
+
+  auto *chiList = meStmt.GetChiList();
+  if (chiList == nullptr) {
+    return;
+  }
+  for (auto &chi : std::as_const(*chiList)) {
+    MeSSAUpdate::InsertOstToSSACands(chi.first, *bb, &candsForSSAUpdate);
+  }
+}
+
+void MEStmtPre::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MEStmtPre::PhaseRun(maple::MeFunction &f) {
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  ASSERT(dom != nullptr, "dominance construction has problem");
+  auto pdom = dominancePhase->GetPdomResult();
+  ASSERT(pdom != nullptr, "postdominance construction has problem");
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  ASSERT(irMap != nullptr, "irMap phase has problem");
+  MeStmtPre ssaPre(f, *irMap, *dom, *pdom, *ApplyTempMemPool(), *ApplyTempMemPool(), MeOption::stmtprePULimit);
+  if (DEBUGFUNC_NEWPM(f)) {
+    ssaPre.SetSSAPreDebug(true);
+  }
+  ssaPre.ApplySSAPRE();
+  if (!ssaPre.GetCandsForSSAUpdate().empty()) {
+    MeSSAUpdate ssaUpdate(f, *f.GetMeSSATab(), *dom, ssaPre.GetCandsForSSAUpdate());
+    ssaUpdate.Run();
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== STMTPRE =============" << '\n';
+    f.Dump(false);
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_store_pre.cpp b/src/mapleall/maple_me/src/me_store_pre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b7f0b241a32d7caee88e1634911cb13a798f398c
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_store_pre.cpp
@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_store_pre.h"
+#include "me_ssa_update.h"
+
+namespace maple {
+// ================ Step 6: Code Motion ================
+void MeStorePre::CheckCreateCurTemp() {
+  if (curTemp != nullptr) {
+    return;
+  }
+  ASSERT_NOT_NULL(irMap);
+  // try to use the same preg that LPRE used for the variable
+  auto mapIt = irMap->FindLpreTmpsItem(workCand->GetOst()->GetIndex());
+  if (mapIt == irMap->GetLpreTmpsEnd()) {
+    curTemp = irMap->CreateRegMeExpr(workCand->GetTheVar()->GetPrimType());
+  } else {
+    curTemp = mapIt->second;
+  }
+}
+
+// Starting at bb's bottom, search for the definition of workCand->theOst and
+// save its RHS in curTemp.  Since the def must dominate, searching by ascending
+// the dominator tree is sufficient.  If the def is by a phi, call recursively
+// for each phi operand and also insert phi for curTemp if needed.
+// bbCurTempMap maps bb to cur_temp_version and is used to avoid re-processing
+// each bb.  The return value is the curTemp version that contains the RHS value
+// at the entry to bb;
+RegMeExpr *MeStorePre::EnsureRHSInCurTemp(BB &bb) {
+  CHECK_FATAL(&bb != func->GetCfg()->GetCommonEntryBB(), "EnsureRHSInCurTemp: cannot find earlier definition");
+  // see if processed before
+  auto mapIt = bbCurTempMap.find(&bb);
+  if (mapIt != bbCurTempMap.end()) {
+    return mapIt->second;
+  }
+  // traverse statements
+  auto &meStmts = bb.GetMeStmts();
+  for (auto itStmt = meStmts.rbegin(); itStmt != meStmts.rend(); ++itStmt) {
+    if (itStmt->GetOp() == OP_dassign) {
+      auto *dass = static_cast<DassignMeStmt*>(to_ptr(itStmt));
+      if (dass->GetVarLHS()->GetOst() != workCand->GetOst()) {
+        continue;
+      }
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << "EnsureRHSInCurTemp: found dassign at BB" << bb.GetBBId() << '\n';
+      }
+      ASSERT_NOT_NULL(curTemp);
+      if (dass->GetRHS()->GetMeOp() == kMeOpReg &&
+          static_cast<RegMeExpr*>(dass->GetRHS())->GetOst() == curTemp->GetOst()) {
+        return static_cast<RegMeExpr*>(dass->GetRHS());
+      }
+      // create and insert regassign before dass
+      RegMeExpr *lhsReg = irMap->CreateRegMeExprVersion(*curTemp);
+      AssignMeStmt *rass = irMap->CreateAssignMeStmt(*lhsReg, *dass->GetRHS(), bb);
+      rass->SetSrcPos(itStmt->GetSrcPosition());
+      lhsReg->SetDefByStmt(*rass);
+      bb.InsertMeStmtBefore(dass, rass);
+      // change dass's rhs to lhsReg
+      dass->SetRHS(lhsReg);
+      bbCurTempMap[&bb] = lhsReg;
+      return lhsReg;
+    } else if (kOpcodeInfo.IsCallAssigned(itStmt->GetOp())) {
+      MapleVector<MustDefMeNode> *mustDefList = itStmt->GetMustDefList();
+      CHECK_NULL_FATAL(mustDefList);
+      MapleVector<MustDefMeNode>::iterator it = mustDefList->begin();
+      for (; it != mustDefList->end(); ++it) {
+        MeExpr *mdLHS = (*it).GetLHS();
+        if (mdLHS->GetMeOp() != kMeOpVar) {
+          continue;
+        }
+        auto *lhsVar = static_cast<VarMeExpr*>(mdLHS);
+        if (lhsVar->GetOst() != workCand->GetOst()) {
+          continue;
+        }
+        if (enabledDebug) {
+          LogInfo::MapleLogger() << "EnsureRHSInCurTemp: found callassigned at BB" << bb.GetBBId() << '\n';
+        }
+        // change mustDefList
+        RegMeExpr *lhsReg = irMap->CreateRegMeExprVersion(*curTemp);
+        (*it).UpdateLHS(*lhsReg);
+        // create dassign
+        AssignMeStmt *dass = irMap->CreateAssignMeStmt(*lhsVar, *lhsReg, bb);
+        dass->SetSrcPos(itStmt->GetSrcPosition());
+        lhsVar->SetDefByStmt(*dass);
+        bb.InsertMeStmtAfter(to_ptr(itStmt), dass);
+        bbCurTempMap[&bb] = lhsReg;
+        return lhsReg;
+      }
+    }
+  }
+  // check if there is def by phi
+  auto phiIt = bb.GetMePhiList().find(workCand->GetOst()->GetIndex());
+  if (phiIt != bb.GetMePhiList().end()) {
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "EnsureRHSInCurTemp: found def-by-phi at BB" << bb.GetBBId() << '\n';
+    }
+    RegMeExpr *lhsReg = irMap->CreateRegMeExprVersion(*curTemp);
+    bbCurTempMap[&bb] = lhsReg;
+    // form a new phi for the temp
+    MePhiNode *regPhi = irMap->NewInPool<MePhiNode>();
+    regPhi->SetLHS(lhsReg);
+    regPhi->SetDefBB(&bb);
+    // call recursively for each varPhi operands
+    for (BB *pred : bb.GetPred()) {
+      RegMeExpr *regPhiOpnd = EnsureRHSInCurTemp(*pred);
+      CHECK_NULL_FATAL(regPhiOpnd);
+      regPhi->GetOpnds().push_back(regPhiOpnd);
+    }
+    // insert the regPhi
+    (void)bb.GetMePhiList().insert(std::make_pair(lhsReg->GetOstIdx(), regPhi));
+    return lhsReg;
+  }
+  // continue at immediate dominator
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "EnsureRHSInCurTemp: cannot find def at BB" << bb.GetBBId() << '\n';
+  }
+  RegMeExpr *savedCurTemp = EnsureRHSInCurTemp(*cfg->GetBBFromID(BBId(dom->GetDom(bb.GetID())->GetID())));
+  CHECK_NULL_FATAL(savedCurTemp);
+  bbCurTempMap[&bb] = savedCurTemp;
+  return savedCurTemp;
+}
+
+void MeStorePre::CodeMotion() {
+  // pass 1 only donig insertion
+  for (SOcc *occ : allOccs) {
+    if (occ->GetOccTy() != kSOccLambdaRes) {
+      continue;
+    }
+    auto *lambdaResOcc = static_cast<SLambdaResOcc*>(occ);
+    if (lambdaResOcc->GetInsertHere()) {
+      // form the lhs VarMeExpr node
+      VarMeExpr *lhsVar = irMap->CreateVarMeExprVersion(*workCand->GetTheVar());
+      // create a new dassign
+      BB *insertBB = &lambdaResOcc->GetBB();
+      CheckCreateCurTemp();
+      CHECK_FATAL(insertBB->GetPred().size() == 1, "CodeMotion: encountered critical edge");
+      RegMeExpr *rhsReg = EnsureRHSInCurTemp(*insertBB->GetPred(0));
+      AssignMeStmt *newDass = irMap->CreateAssignMeStmt(*lhsVar, *rhsReg, *insertBB);
+      lhsVar->SetDefByStmt(*newDass);
+      // insert at earliest point in BB, but after statements required to be
+      // first statements in BBG
+      MeStmt *curStmt = to_ptr(insertBB->GetMeStmts().begin());
+      while (curStmt != nullptr && (curStmt->GetOp() == OP_catch || curStmt->GetOp() == OP_try ||
+             curStmt->GetOp() == OP_comment)) {
+        curStmt = curStmt->GetNext();
+      }
+      if (curStmt == nullptr) {
+        insertBB->AddMeStmtLast(newDass);
+      } else {
+        insertBB->InsertMeStmtBefore(curStmt, newDass);
+      }
+
+      AddCandsForSSAUpdate(lhsVar->GetOstIdx(), *insertBB);
+    }
+  }
+  // pass 2 only doing deletion
+  ASSERT_NOT_NULL(workCand);
+  for (SOcc *occ : workCand->GetRealOccs()) {
+    if (occ->GetOccTy() != kSOccReal) {
+      continue;
+    }
+    auto *realOcc = static_cast<SRealOcc*>(occ);
+    if (realOcc->GetRedundant()) {
+      if (realOcc->GetStmt()->GetOp() == OP_dassign) {
+        auto *dass = static_cast<DassignMeStmt*>(realOcc->GetStmt());
+        if (dass->GetRHS()->CouldThrowException()) {
+          // insert a new eval statement
+          UnaryMeStmt *evalStmt = irMap->New<UnaryMeStmt>(OP_eval);
+          evalStmt->SetBB(dass->GetBB());
+          evalStmt->SetSrcPos(dass->GetSrcPosition());
+          evalStmt->SetMeStmtOpndValue(dass->GetRHS());
+          realOcc->GetBB().InsertMeStmtBefore(dass, evalStmt);
+        }
+        realOcc->GetBB().RemoveMeStmt(dass);
+        dass->SetIsLive(false);
+      } else {
+        CHECK_FATAL(kOpcodeInfo.IsCallAssigned(realOcc->GetStmt()->GetOp()) && realOcc->GetStmt()->
+            GetOp() != OP_asm, "CodeMotion: callassign expected");
+        MapleVector<MustDefMeNode> *mustDefList = realOcc->GetStmt()->GetMustDefList();
+        CHECK_NULL_FATAL(mustDefList);
+        mustDefList->clear();
+      }
+    }
+  }
+}
+
+// ================ Step 0: collect occurrences ================
+// create a new real occurrence for the store of meStmt of symbol oidx
+void MeStorePre::CreateRealOcc(const OStIdx &ostIdx, MeStmt &meStmt) {
+  // skip vars with alias until we can deal with chi
+  if (!aliasClass->OstAnalyzed(ostIdx)) {
+    return;
+  }
+  auto *aliasSet = aliasClass->GetAliasSet(ostIdx);
+  if (aliasSet != nullptr) {
+    return;
+  }
+
+  SpreWorkCand *wkCand = nullptr;
+  auto mapIt = workCandMap.find(ostIdx);
+  if (mapIt != workCandMap.end()) {
+    wkCand = mapIt->second;
+  } else {
+    OriginalSt *ost = ssaTab->GetSymbolOriginalStFromID(ostIdx);
+    CHECK_FATAL(ost, "ost is nullptr!");
+    wkCand = spreMp->New<SpreWorkCand>(spreAllocator, *ost);
+    workCandMap[ostIdx] = wkCand;
+    // if it is local symbol, insert artificial use occ at common_exit_bb
+    if (ost->IsLocal()) {
+      SRealOcc *artOcc = spreMp->New<SRealOcc>(*func->GetCfg()->GetCommonExitBB());
+      wkCand->GetRealOccs().push_back(artOcc);
+    }
+  }
+  if (wkCand->GetTheVar() == nullptr) {
+    if (meStmt.GetOp() == OP_dassign) {
+      wkCand->SetTheVar(*static_cast<VarMeExpr*>(static_cast<DassignMeStmt*>(&meStmt)->GetVarLHS()));
+    } else {
+      ASSERT(kOpcodeInfo.IsCallAssigned(meStmt.GetOp()) && meStmt.GetOp() != OP_asm,
+          "CreateRealOcc: callassign expected");
+      MapleVector<MustDefMeNode> *mustDefList = meStmt.GetMustDefList();
+      CHECK_FATAL(mustDefList != nullptr, "CreateRealOcc: mustDefList cannot be empty");
+      CHECK_FATAL(!mustDefList->empty(), "CreateRealOcc: mustDefList cannot be empty");
+      wkCand->SetTheVar(*static_cast<VarMeExpr*>(mustDefList->front().GetLHS()));
+    }
+  }
+  SRealOcc *newOcc = spreMp->New<SRealOcc>(meStmt);
+  wkCand->GetRealOccs().push_back(newOcc);
+  wkCand->SetHasStoreOcc(true);
+}
+
+// create a new use occurrence for symbol oidx in given bb
+void MeStorePre::CreateUseOcc(const OStIdx &ostIdx, BB &bb) {
+  SpreWorkCand *wkCand = nullptr;
+  auto mapIt = workCandMap.find(ostIdx);
+  if (mapIt == workCandMap.end()) {
+    OriginalSt *ost = ssaTab->GetSymbolOriginalStFromID(ostIdx);
+    CHECK_FATAL(ost, "ost is nullptr!");
+    wkCand = spreMp->New<SpreWorkCand>(spreAllocator, *ost);
+    workCandMap[ostIdx] = wkCand;
+    // if it is local symbol, insert artificial real occ at common_exit_bb
+    if (ost->IsLocal()) {
+      SRealOcc *artOcc = spreMp->New<SRealOcc>(*func->GetCfg()->GetCommonExitBB());
+      wkCand->GetRealOccs().push_back(artOcc);
+    }
+  } else {
+    wkCand = mapIt->second;
+  }
+
+  if (!wkCand->GetRealOccs().empty()) {
+    SOcc *lastOcc = wkCand->GetRealOccs().back();
+    if (lastOcc->GetOccTy() == kSOccUse && &lastOcc->GetBB() == &bb) {
+      return;  // no need to push consecutive use occurrences at same BB
+    }
+  }
+
+  SUseOcc *newOcc = spreMp->New<SUseOcc>(bb);
+  wkCand->GetRealOccs().push_back(newOcc);
+}
+
+// create use occurs for all the symbols that alias with muost
+void MeStorePre::CreateSpreUseOccsThruAliasing(const OriginalSt &muOst, BB &bb) {
+  if (!aliasClass->OstAnalyzed(muOst.GetIndex())) {
+    return;
+  }
+  CreateUseOcc(muOst.GetIndex(), bb);
+}
+
+void MeStorePre::FindAndCreateSpreUseOccs(const MeExpr &meExpr, BB &bb) {
+  if (meExpr.GetMeOp() == kMeOpVar) {
+    auto *var = static_cast<const VarMeExpr*>(&meExpr);
+    const OriginalSt *ost = var->GetOst();
+    if (!ost->IsVolatile()) {
+      CreateUseOcc(var->GetOstIdx(), bb);
+    }
+    return;
+  }
+  for (uint8 i = 0; i < meExpr.GetNumOpnds(); i++) {
+    FindAndCreateSpreUseOccs(*meExpr.GetOpnd(i), bb);
+  }
+  if (IsJavaLang()) {
+    return;
+  }
+  if (meExpr.GetMeOp() == kMeOpIvar) {
+    auto *ivarMeExpr = static_cast<const IvarMeExpr*>(&meExpr);
+    for (auto *mu : ivarMeExpr->GetMuList()) {
+      if (mu != nullptr) {
+        CreateSpreUseOccsThruAliasing(*mu->GetOst(), bb);
+      }
+    }
+  }
+}
+
+void MeStorePre::CreateSpreUseOccsForAll(BB &bb) const {
+  // go thru all workcands and insert a use occurrence for each of them
+  for (std::pair<OStIdx, SpreWorkCand*> wkCandPair : workCandMap) {
+    SpreWorkCand *wkCand = wkCandPair.second;
+    CHECK_NULL_FATAL(wkCand);
+    CHECK_FATAL(!wkCand->GetRealOccs().empty(), "container empty check");
+    SOcc *lastOcc = wkCand->GetRealOccs().back();
+    if (lastOcc->GetOccTy() == kSOccUse && &lastOcc->GetBB() == &bb) {
+      continue;  // no need to push consecutive use occurrences at same BB
+    }
+    SUseOcc *newOcc = spreMp->New<SUseOcc>(bb);
+    wkCand->GetRealOccs().push_back(newOcc);
+  }
+}
+
+void MeStorePre::BuildWorkListBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+  // traverse statements backwards
+  auto &meStmts = bb->GetMeStmts();
+  for (auto stmt = meStmts.rbegin(); stmt != meStmts.rend(); ++stmt) {
+    // look for real occurrence of stores
+    OStIdx lhsOstIdx(0);
+    if (stmt->GetOp() == OP_dassign) {
+      auto *dass = static_cast<DassignMeStmt*>(to_ptr(stmt));
+      if (dass->GetLHS()->GetPrimType() != PTY_ref && dass->GetLHS()->GetPrimType() != PTY_agg) {
+        lhsOstIdx = dass->GetVarLHS()->GetOstIdx();
+      }
+    } else if (kOpcodeInfo.IsCallAssigned(stmt->GetOp()) && stmt->GetOp() != OP_asm) {
+      MapleVector<MustDefMeNode> *mustDefList = stmt->GetMustDefList();
+      CHECK_NULL_FATAL(mustDefList);
+      if (!mustDefList->empty()) {
+        MeExpr *mdLHS = mustDefList->front().GetLHS();
+        if (mdLHS->GetMeOp() == kMeOpVar && mdLHS->GetPrimType() != PTY_ref && mdLHS->GetPrimType() != PTY_agg) {
+          lhsOstIdx = static_cast<VarMeExpr*>(mdLHS)->GetOstIdx();
+        }
+      }
+    }
+    if (lhsOstIdx != 0u) {
+      const OriginalSt *ost = ssaTab->GetOriginalStFromID(lhsOstIdx);
+      CHECK_FATAL(ost, "ost is nullptr!");
+      if (!ost->IsVolatile()) {
+        CreateRealOcc(lhsOstIdx, *to_ptr(stmt));
+      }
+    }
+    // look for use occurrence of stores
+    for (size_t i = 0; i < stmt->NumMeStmtOpnds(); i++) {
+      FindAndCreateSpreUseOccs(*stmt->GetOpnd(i), *stmt->GetBB());
+    }
+    if (!IsJavaLang()) {
+      // go thru mu list
+      NaryMeStmt *naryMeStmt = safe_cast<NaryMeStmt>(to_ptr(stmt));
+      if (naryMeStmt != nullptr) {
+        CHECK_NULL_FATAL(naryMeStmt->GetMuList());
+        for (auto &muPair : std::as_const(*(naryMeStmt->GetMuList()))) {
+          CreateSpreUseOccsThruAliasing(*muPair.second->GetOst(), *bb);
+        }
+      }
+    }
+  }
+  if (bb->GetAttributes(kBBAttrIsCatch)) {
+    CreateSpreUseOccsForAll(*bb);
+  }
+  if (bb->GetAttributes(kBBAttrIsEntry)) {
+    CreateEntryOcc(*bb);
+  }
+  // recurse on child BBs in post-dominator tree
+  for (auto bbId : pdom->GetDomChildren(bb->GetID())) {
+    BuildWorkListBB(func->GetCfg()->GetAllBBs().at(bbId));
+  }
+}
+
+void MEStorePre::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEAliasClass>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MEStorePre::PhaseRun(maple::MeFunction &f) {
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  ASSERT(dom != nullptr, "dominance construction has problem");
+  auto pdom = dominancePhase->GetPdomResult();
+  ASSERT(pdom != nullptr, "postdominance construction has problem");
+  auto *aliasClass = GET_ANALYSIS(MEAliasClass, f);
+  ASSERT(aliasClass != nullptr, "aliasClass phase has problem");
+  auto *meIrMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_FATAL(meIrMap != nullptr, "irmap phase has problem");
+  if (!meIrMap->GetMIRModule().IsCModule()) {
+    return false;
+  }
+
+  MeStorePre storePre(f, *dom, *pdom, *aliasClass, *ApplyTempMemPool(), DEBUGFUNC_NEWPM(f));
+  storePre.ApplySSUPre();
+
+  auto &candsForSSAUpdate = storePre.CandsForSSAUpdate();
+  if (!candsForSSAUpdate.empty()) {
+    MeSSAUpdate ssaUpdate(f, *f.GetMeSSATab(), *dom, candsForSSAUpdate);
+    ssaUpdate.Run();
+  }
+
+  if (DEBUGFUNC_NEWPM(f)) {
+    f.Dump(false);
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_subsum_rc.cpp b/src/mapleall/maple_me/src/me_subsum_rc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1debe908f1e11c8e52e8c13672ffc4d7bf52e9eb
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_subsum_rc.cpp
@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_subsum_rc.h"
+#include "me_phase_manager.h"
+
+namespace maple {
+void SubsumRC::SetCantSubsum() {
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    for (auto it : bb->GetMePhiList()) {
+      const OriginalSt *ost = ssaTab->GetOriginalStFromID(it.first);
+      CHECK_FATAL(ost, "ost is nullptr!");
+      if (!ost->IsSymbolOst() || ost->GetIndirectLev() != 0) {
+        continue;
+      }
+      MePhiNode *phi = it.second;
+      if (!phi->GetIsLive()) {
+        continue;
+      }
+      for (auto *phiOpnd : phi->GetOpnds()) {
+        verstCantSubsum[phiOpnd->GetVstIdx()] = true;
+      }
+    }
+  }
+}
+// Return true if there is an occ of the lhs is post-dominated by rhs occ.
+bool SubsumRC::IsRhsPostDominateLhs(const SOcc &rhsOcc, const VarMeExpr &lhs) const {
+  for (SOcc *occ : allOccs) {
+    if (occ->GetOccTy() == kSOccReal) {
+      auto *realOcc = static_cast<SRealOcc*>(occ);
+      if (realOcc->GetVar() == &lhs && rhsOcc.IsPostDominate(pdom, occ)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// ================ Step 6: Code Motion ================
+void SubsumRC::SubsumeRC(MeStmt &stmt) {
+  ASSERT(stmt.GetOp() == OP_dassign, "work_cand should be a dassign stmt");
+  auto *dass = static_cast<DassignMeStmt*>(&stmt);
+  auto *lhs = static_cast<VarMeExpr*>(stmt.GetLHSRef(false));
+  auto *rhsVar = dass->GetRHS();
+  bool lhsFound = false;
+  for (SOcc *occ : allOccs) {
+    if (occ->GetOccTy() == kSOccReal) {
+      auto *realOcc = static_cast<SRealOcc*>(occ);
+      if (realOcc->GetVar() == lhs && !realOcc->GetRedundant()) {
+        lhsFound = true;
+        break;
+      } else if (realOcc->GetVar() == rhsVar) {
+        bool redundantRHSDec = realOcc->GetRedundant();
+        bool rhsDecPdomLHS = IsRhsPostDominateLhs(*realOcc, *lhs);
+        bool rhsDecPdomStmt = pdom->Dominate(realOcc->GetBB(), *stmt.GetBB());
+        if (redundantRHSDec && (rhsDecPdomLHS || rhsDecPdomStmt)) {
+          // if there is a decref of rhs is just post-dominate that of the lhs,
+          // it can't do subsum either.
+          lhsFound = true;
+          break;
+        }
+        if (!redundantRHSDec && !rhsDecPdomLHS && rhsDecPdomStmt) {
+          // if there is a decref of rhs is just post-dominate that of the stmt,
+          // remove inc may cause early dec
+          lhsFound = true;
+          break;
+        }
+      }
+    }
+  }
+  if (!lhsFound) {
+    ASSERT_NOT_NULL(lhs);
+    auto mItem = irMap->FindDecrefItem(*lhs);
+    MapleSet<MeStmt*> *stmts = (*mItem).second;
+    for (auto it = stmts->begin(); it != stmts->end(); ++it) {
+      MeStmt *stmtTemp = *it;
+      stmtTemp->GetBB()->RemoveMeStmt(stmtTemp);
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << "Remove decrefreset stmt in BB" << stmtTemp->GetBB()->GetBBId() << ":\n";
+        stmtTemp->Dump(irMap);
+      }
+    }
+    stmt.DisableNeedIncref();
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "Remove the incref of stmt: ";
+      stmt.Dump(irMap);
+    }
+    // Replace the localvar of the lhs with a register., in case it throws excption just after
+    // the dassign stmt, because we ignore the incref of the lhs.
+    RegMeExpr *regTemp = irMap->CreateRegRefMeExpr(*lhs);
+    AssignMeStmt *rass = irMap->CreateAssignMeStmt(*regTemp, *dass->GetRHS(), *stmt.GetBB());
+    regTemp->SetDefByStmt(*rass);
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "Replace dassign stmt:";
+      stmt.Dump(irMap);
+      LogInfo::MapleLogger() << "with regassign stmt:";
+      rass->Dump(irMap);
+    }
+    stmt.GetBB()->ReplaceMeStmt(&stmt, rass);
+    rass->DisableNeedIncref();
+    ReplaceExpr(*stmt.GetBB(), *lhs, *regTemp);
+    for (size_t i = 0; i < bbVisited.size(); ++i) {
+      bbVisited[i] = false;
+    }
+  } else {
+    // check the special case.
+    auto *rhs = static_cast<VarMeExpr*>(dass->GetRHS());
+    ASSERT_NOT_NULL(irMap);
+    auto mItem = irMap->FindDecrefItem(*rhs);
+    MapleSet<MeStmt*> *stmts = (*mItem).second;
+    MeStmt *decRef = stmt.GetNextMeStmt();
+    if (decRef != nullptr && decRef->GetOp() == OP_decrefreset && stmts->find(decRef) != stmts->end()) {
+      ASSERT_NOT_NULL(lhs);
+      lhs->SetNoDelegateRC(true);
+      stmt.GetBB()->RemoveMeStmt(decRef);
+      stmt.DisableNeedIncref();
+      VarMeExpr *tempVar = irMap->CreateVarMeExprVersion(*rhs);
+      MeExpr *zeroExpr = irMap->CreateIntConstMeExpr(0, PTY_ref);
+      AssignMeStmt *newDass = irMap->CreateAssignMeStmt(*tempVar, *zeroExpr, *stmt.GetBB());
+      stmt.GetBB()->InsertMeStmtAfter(&stmt, newDass);
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << "last subsum for stmt:";
+        stmt.Dump(irMap);
+      }
+    }
+  }
+}
+
+void SubsumRC::ReplaceExpr(BB &bb, const MeExpr &var, MeExpr &reg) {
+  if (bbVisited[bb.GetBBId()]) {
+    return;
+  }
+  bbVisited[bb.GetBBId()] = true;
+  auto &meStmts = bb.GetMeStmts();
+  for (auto itStmt = meStmts.rbegin(); itStmt != meStmts.rend(); ++itStmt) {
+    MeStmt *stmt = to_ptr(itStmt);
+    if (stmt->NumMeStmtOpnds() == 0) {
+      continue;
+    }
+    ASSERT_NOT_NULL(irMap);
+    (void)irMap->ReplaceMeExprStmt(*stmt, var, reg);
+  }
+  for (BB *succ : bb.GetSucc()) {
+    ReplaceExpr(*succ, var, reg);
+  }
+}
+
+// ================ Step 0: collect occurrences ================
+// create realoccurence decRef of varX, meStmt is the work candidate.
+void SubsumRC::CreateRealOcc(VarMeExpr &varX, DassignMeStmt &meStmt, MeStmt &decRef) {
+  SpreWorkCand *wkCand = nullptr;
+  auto mapIt = candMap.find(&meStmt);
+  if (mapIt != candMap.end()) {
+    wkCand = mapIt->second;
+  } else {
+    OriginalSt *ost = ssaTab->GetSymbolOriginalStFromID(varX.GetOstIdx());
+    wkCand = spreMp->New<SpreWorkCand>(spreAllocator, *ost);
+    candMap[&meStmt] = wkCand;
+  }
+  if (wkCand->GetTheVar() == nullptr) {
+    wkCand->SetTheVar(varX);
+  }
+  SRealOcc *newOcc = spreMp->New<SRealOcc>(decRef, varX);
+  wkCand->GetRealOccs().push_back(newOcc);
+}
+
+// collect occurenc in postdominator preorder.
+void SubsumRC::BuildRealOccs(MeStmt &stmt, BB &bb) {
+  ASSERT(stmt.GetOp() == OP_dassign, "stmt should be dassign.");
+  auto *dass = static_cast<DassignMeStmt*>(&stmt);
+  auto *lhs = static_cast<VarMeExpr*>(stmt.GetLHSRef(false));
+  auto *rhs = static_cast<VarMeExpr*>(dass->GetRHS());
+  ASSERT(lhs != nullptr, "lhs should be var");
+  ASSERT(rhs != nullptr, "rhs should be var");
+  auto mItemLhs = irMap->FindDecrefItem(*lhs);
+  MapleSet<MeStmt*> *stmtsLhs = (*mItemLhs).second;
+  auto mItemRhs = irMap->FindDecrefItem(*rhs);
+  MapleSet<MeStmt*> *stmtsRhs = (*mItemRhs).second;
+  auto &meStmts = bb.GetMeStmts();
+  for (auto itStmt = meStmts.rbegin(); itStmt != meStmts.rend(); ++itStmt) {
+    if (itStmt->GetOp() != OP_decrefreset) {
+      continue;
+    }
+    MeStmt *st = to_ptr(itStmt);
+    if (stmtsLhs->find(st) != stmtsLhs->end()) {
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << "Create realocc for stmt lhs in BB" << st->GetBB()->GetBBId() << ":\n";
+        st->Dump(irMap);
+      }
+      CreateRealOcc(*lhs, *dass, *st);
+    } else if (stmtsRhs->find(st) != stmtsRhs->end()) {
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << "Create realocc for stmt rhs in BB" << st->GetBB()->GetBBId() << ":\n";
+        st->Dump(irMap);
+      }
+      CreateRealOcc(*rhs, *dass, *st);
+    }
+  }
+  // recurse on child BBs in post-dominator tree
+  for (auto bbId : pdom->GetDomChildren(bb.GetID())) {
+    BuildRealOccs(stmt, *cfg->GetBBFromID(BBId(bbId)));
+  }
+}
+
+void SubsumRC::BuildWorkListBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+  // traverse statements backwards
+  auto &meStmts = bb->GetMeStmts();
+  for (auto itStmt = meStmts.rbegin(); itStmt != meStmts.rend(); ++itStmt) {
+    if (itStmt->GetOp() != OP_dassign) {
+      continue;
+    }
+    // skip identity assignments
+    auto *dass = static_cast<DassignMeStmt*>(to_ptr(itStmt));
+    ASSERT_NOT_NULL(dass->GetLHS());
+    if (dass->GetLHS()->IsUseSameSymbol(*dass->GetRHS())) {
+      continue;
+    }
+    if (!dass->NeedIncref()) {
+      continue;
+    }
+    if (dass->GetRHS() == nullptr || dass->GetRHS()->GetMeOp() != kMeOpVar ||
+        dass->GetRHS()->GetPrimType() != PTY_ref) {
+      continue;
+    }
+    // look for real occurrence of y = x;
+    auto *lhs = static_cast<VarMeExpr*>(dass->GetLHSRef(false));
+    if (lhs == nullptr) {
+      continue;
+    }
+    if (verstCantSubsum[lhs->GetVstIdx()] || lhs->GetNoSubsumeRC()) {
+      if (enabledDebug) {
+        dass->Dump(irMap);
+        verstCantSubsum[lhs->GetVstIdx()] ? LogInfo::MapleLogger() << "thelhs is phiopnd." << '\n'
+                                          : LogInfo::MapleLogger() << "thelhs is nosubsumed." << '\n';
+      }
+      continue;
+    }
+    const OriginalSt *lhsOst = ssaTab->GetSymbolOriginalStFromID(lhs->GetOstIdx());
+    CHECK_FATAL(lhsOst, "lhsOst is nullptr!");
+    if (lhsOst->IsLocal() || lhsOst->IsEPreLocalRefVar()) {
+      auto mItemLhs = irMap->FindDecrefItem(*lhs);
+      if (mItemLhs == irMap->GetDecrefsEnd()) {
+        continue;
+      }
+      auto *rhs = static_cast<VarMeExpr*>(dass->GetRHS());
+      auto mItemRhs = irMap->FindDecrefItem(*rhs);
+      if (mItemRhs == irMap->GetDecrefsEnd()) {
+        continue;
+      }
+      MapleSet<MeStmt*> *lhsStmts = (*mItemLhs).second;
+      MapleSet<MeStmt*> *rhsStmts = (*mItemRhs).second;
+      if (lhsStmts == nullptr || rhsStmts == nullptr) {
+        if (enabledDebug) {
+          LogInfo::MapleLogger() << "thelhs is decefreseted in cleanup.\n";
+        }
+        continue;
+      }
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << "Create realocc for stmt:";
+        dass->Dump(irMap);
+      }
+      BuildRealOccs(*dass, *(cfg->GetCommonExitBB()));
+    }
+  }
+  if (bb->GetAttributes(kBBAttrIsEntry)) {
+    CreateEntryOcc(*bb);
+  }
+  // recurse on child BBs in post-dominator tree
+  for (auto bbId : dom->GetDomChildren(bb->GetID())) {
+    BuildWorkListBB(cfg->GetBBFromID(BBId(bbId)));
+  }
+}
+
+void SubsumRC::RunSSUPre() {
+  SetCantSubsum();
+  BuildWorkListBB(cfg->GetCommonExitBB());
+  if (enabledDebug) {
+    LogInfo::MapleLogger() << "------ worklist initial size " << candMap.size() << '\n';
+  }
+  size_t candNum = 0;
+  for (std::pair<MeStmt*, SpreWorkCand*> wkCandPair : candMap) {
+    workCand = wkCandPair.second;
+    MeStmt *stmt = wkCandPair.first;
+    ASSERT(stmt->GetOp() == OP_dassign, "work_cand should be a dassign stmt");
+    auto *dass = static_cast<DassignMeStmt*>(stmt);
+    // Because SubsumeRC may replace lvar by reg.
+    if (dass->GetRHS()->GetMeOp() != kMeOpVar) {
+      if (enabledDebug) {
+        LogInfo::MapleLogger() << "candidate " << candNum << "has been changed to:" << '\n';
+        stmt->Dump(irMap);
+        LogInfo::MapleLogger() << "do nothing for it.\n";
+      }
+      continue;
+    }
+
+    if (enabledDebug) {
+      LogInfo::MapleLogger() << "Subsum candidate " << candNum << " in BB " << stmt->GetBB()->GetBBId() << ":";
+      stmt->Dump(irMap);
+    }
+    // #1 insert lambdas; results in allOccs and lambdaOccs
+    FormLambdas();  // result put in the set lambda_bbs
+    CreateSortedOccs();
+    // #2 rename
+    Rename();
+    if (!lambdaOccs.empty()) {
+      // #3 UpSafety
+      ComputeUpsafe();
+      // #4 CanBeAnt
+      ComputeCanBeFullyAnt();
+      ComputeEarlier();
+    }
+    // #5 Finalize
+    Finalize();
+    // #6 Code Mmotion
+    ASSERT_NOT_NULL(workCand);
+    if (!workCand->GetHasCriticalEdge()) {
+      SubsumeRC(*stmt);
+    }
+    ++candNum;
+  }
+}
+
+void MESubsumRC::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.SetPreservedAll();
+}
+
+bool MESubsumRC::PhaseRun(maple::MeFunction &f) {
+  if (!(f.GetHints() & kPlacementRCed)) {
+    return false;
+  }
+  if (!MeOption::subsumRC) {
+    return false;
+  }
+  auto dominancePhase = EXEC_ANALYSIS(MEDominance, f);
+  auto dom = dominancePhase->GetDomResult();
+  ASSERT(dom != nullptr, "dominance construction has problem");
+  auto pdom = dominancePhase->GetPdomResult();
+  ASSERT(pdom != nullptr, "postdominance construction has problem");
+  SubsumRC subsumRC(f, *dom, *pdom, *GetPhaseMemPool(), DEBUGFUNC_NEWPM(f));
+  subsumRC.RunSSUPre();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n============== After SUBSUM RC =============\n";
+    f.Dump(false);
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_toplevel_ssa.cpp b/src/mapleall/maple_me/src/me_toplevel_ssa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..438997555a5fcf3643a8ca7adcc623cbd0d8dac6
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_toplevel_ssa.cpp
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_toplevel_ssa.h"
+#include "me_phase_manager.h"
+#include "bb.h"
+#include "me_option.h"
+#include "ssa_mir_nodes.h"
+#include "ver_symbol.h"
+#include "dominance.h"
+#include "mir_builder.h"
+#include "ssa_tab.h"
+namespace maple {
+void MeTopLevelSSA::CollectUseInfo() {
+  if (!vstUseInfo.IsUseInfoOfTopLevelValid()) {
+    vstUseInfo.CollectUseInfoInFunc(func, dom, kVstUseInfoTopLevelVst);
+  }
+}
+
+void METopLevelSSA::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MESSATab>();
+  aDep.SetPreservedAll();
+}
+
+bool METopLevelSSA::PhaseRun(maple::MeFunction &f) {
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  CHECK_FATAL(dom != nullptr, "dominance phase has problem");
+  auto *ssaTab = GET_ANALYSIS(MESSATab, f);
+  CHECK_FATAL(ssaTab != nullptr, "ssaTab phase has problem");
+  ssa = GetPhaseAllocator()->New<MeTopLevelSSA>(f, ssaTab, *dom, *GetPhaseMemPool());
+  auto cfg = f.GetCfg();
+  if (DEBUGFUNC_NEWPM(f)) {
+    cfg->DumpToFile("ssalocal-");
+  }
+  ssa->InsertPhiNode();
+  ssa->RenameAllBBs(cfg);
+  if (DEBUGFUNC_NEWPM(f)) {
+    ssaTab->GetVersionStTable().Dump(&ssaTab->GetModule());
+  }
+  if (DEBUGFUNC_NEWPM(f)) {
+    f.DumpFunction();
+  }
+  f.SetMeFuncState(kSSATopLevel); // update current ssa state
+  return true;
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/me_value_range_prop.cpp b/src/mapleall/maple_me/src/me_value_range_prop.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fdc0216da2351c1901ca53a2a73f79537e28ef09
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_value_range_prop.cpp
@@ -0,0 +1,5261 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "me_value_range_prop.h"
+#include "me_dominance.h"
+#include "me_abco.h"
+#include "me_ssa_update.h"
+#include "me_phase_manager.h"
+#include "me_safety_warning.h"
+
+namespace maple {
+bool ValueRangePropagation::isDebug = false;
+constexpr size_t kNumOperands = 2;
+constexpr size_t kCodeSizeLimit = 2000;
+constexpr std::uint64_t kInvaliedBound = 0xdeadbeef;
+constexpr size_t kLimitOfLoopNestDepth = 10;
+constexpr size_t kLimitOfLoopBBs = 500;
+static constexpr int32 kProbLikely = 9000;
+static constexpr int32 kProbUnlikely = 1000;
+
+bool Bound::CanBeComparedWith(const Bound &bound) const {
+  // Only bounds with same var can be compared
+  // Only comparison between bounds with same primtype makes sense!
+  if (primType != bound.GetPrimType()) {
+    return false;
+  }
+  if (var == bound.GetVar()) {
+    return true;
+  }
+  return (*this == MinBound(primType) || *this == MaxBound(primType) ||
+          bound == MinBound(primType) || bound == MaxBound(primType));
+}
+
+bool Bound::operator<(const Bound &bound) const {
+  if (!CanBeComparedWith(bound)) {
+    return false;
+  }
+  if (*this == bound) {
+    return false;
+  }
+  if (*this == MaxBound(primType) || bound == MinBound(primType)) {
+    return false;
+  }
+  if (IsPrimitiveUnsigned(primType)) {
+    if (var == nullptr && bound.var == nullptr) {
+      return static_cast<uint64>(constant) < static_cast<uint64>(bound.GetConstant());
+    }
+  }
+  return constant < bound.GetConstant();
+}
+
+bool Bound::operator<=(const Bound &bound) const {
+  if (!CanBeComparedWith(bound)) {
+    return false;
+  }
+  if (*this == bound) {
+    return true;
+  }
+  if (*this == MinBound(primType) || bound == MaxBound(primType)) {
+    return true;
+  }
+  if (IsPrimitiveUnsigned(primType)) {
+    if (var == nullptr && bound.var == nullptr) {
+      return static_cast<uint64>(constant) <= static_cast<uint64>(bound.GetConstant());
+    }
+  }
+  return (var == bound.var && constant <= bound.GetConstant());
+}
+
+void ValueRangePropagation::Execute() {
+  useInfo = &irMap.GetExprUseInfo();
+  if (!useInfo->UseInfoOfAllIsValid()) {
+    useInfo->CollectUseInfoInFunc(&irMap, &dom, kUseInfoOfAllExpr);
+  }
+  // In reverse post order traversal, a bb is accessed before any of its successor bbs. So the range of def points would
+  // be calculated before and need not calculate the range of use points repeatedly.
+  for (auto bIt = dom.GetReversePostOrder().begin(); bIt != dom.GetReversePostOrder().end(); ++bIt) {
+    currItOfTravelReversePostOrder = bIt;
+    auto curBB = func.GetCfg()->GetBBFromID(BBId((*bIt)->GetID()));
+    if (unreachableBBs.find(curBB) != unreachableBBs.end()) {
+      continue;
+    }
+    dealWithPhi = true;
+    DealWithPhi(*curBB);
+    dealWithPhi = false;
+    if (func.GetCfg()->UpdateCFGFreq()) {
+      // update edge frequency
+      curBB->UpdateEdgeFreqs(false);
+    }
+    for (auto it = curBB->GetMeStmts().begin(); it != curBB->GetMeStmts().end();) {
+      bool deleteStmt = false;
+      if (!onlyPropVR) {
+        ReplaceOpndWithConstMeExpr(*curBB, *it);
+      }
+      bool isNotNeededPType = false;
+      for (size_t i = 0; i < it->NumMeStmtOpnds(); ++i) {
+        if (!IsNeededPrimType(it->GetOpnd(i)->GetPrimType())) {
+          isNotNeededPType = true;
+          continue;
+        }
+        DealWithOperand(*curBB, *it, *it->GetOpnd(i));
+      }
+      if (isNotNeededPType) {
+        ++it;
+        continue;
+      }
+      if (MeOption::safeRegionMode && (it->IsInSafeRegion()) &&
+          kOpcodeInfo.IsCall(it->GetOp()) && instance_of<CallMeStmt>(*it)) {
+        MIRFunction *callFunc =
+            GlobalTables::GetFunctionTable().GetFunctionFromPuidx(static_cast<CallMeStmt&>(*it).GetPUIdx());
+        if (callFunc->IsUnSafe()) {
+          auto srcPosition = it->GetSrcPosition();
+          FATAL(kLncFatal, "%s %d error: call unsafe function %s from safe region that requires safe function",
+                func.GetMIRModule().GetFileNameFromFileNum(srcPosition.FileNum()).c_str(), srcPosition.LineNum(),
+                callFunc->GetName().c_str());
+        }
+      }
+      switch (it->GetOp()) {
+        case OP_dassign:
+        case OP_maydassign:
+        case OP_regassign: {
+          if (it->GetLHS() != nullptr && it->GetLHS()->IsVolatile()) {
+            break;
+          }
+          DealWithAssign(*curBB, *it);
+          break;
+        }
+        case OP_brfalse:
+        case OP_brtrue: {
+          DealWithCondGoto(*curBB, *it);
+          InsertValueRangeOfCondExpr2Caches(*curBB, *it);
+          break;
+        }
+        CASE_OP_ASSERT_NONNULL {
+          if (!dealWithAssert) {
+            break;
+          }
+          // If the option safeRegion is open and the stmt is not in safe region, delete it.
+          if (MeOption::safeRegionMode && !it->IsInSafeRegion()) {
+            deleteStmt = true;
+          } else if (DealWithAssertNonnull(*curBB, *it)) {
+            if (ValueRangePropagation::isDebug) {
+              LogInfo::MapleLogger() << "=========delete assert nonnull=========\n";
+              it->Dump(&irMap);
+              LogInfo::MapleLogger() << "=========delete assert nonnull=========\n";
+            }
+            deleteStmt = true;
+          }
+          break;
+        }
+        CASE_OP_ASSERT_BOUNDARY {
+          if (!dealWithAssert) {
+            break;
+          }
+          // If the option safeRegion is open and the stmt is not in safe region, delete it.
+          if (MeOption::safeRegionMode && !it->IsInSafeRegion()) {
+            deleteStmt = true;
+          } else if (DealWithBoundaryCheck(*curBB, *it)) {
+            if (ValueRangePropagation::isDebug) {
+              LogInfo::MapleLogger() << "=========delete boundary check=========\n";
+              it->Dump(&irMap);
+              LogInfo::MapleLogger() << "=========delete boundary check=========\n";
+            }
+            deleteStmt = true;
+          }
+          break;
+        }
+        case OP_callassigned: {
+          DealWithCallassigned(*curBB, *it);
+          break;
+        }
+        case OP_switch: {
+          DealWithSwitch(*curBB, *it);
+          break;
+        }
+        case OP_igoto:
+        default:
+          break;
+      }
+      if (deleteStmt) {
+        curBB->GetMeStmts().erase(it++);
+      } else {
+        ++it;
+      }
+    }
+  }
+  if (ValueRangePropagation::isDebug) {
+    DumpCaches();
+  }
+  DeleteUnreachableBBs();
+  useInfo->InvalidUseInfo();
+}
+
+void ValueRangePropagation::DealWithCallassigned(const BB &bb, MeStmt &stmt) {
+  auto &callassign = static_cast<CallMeStmt&>(stmt);
+  MIRFunction *callFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callassign.GetPUIdx());
+  if (callFunc->GetAttr(FUNCATTR_nonnull) && callassign.GetAssignedLHS() != nullptr) {
+    (void)Insert2Caches(bb.GetBBId(), callassign.GetAssignedLHS()->GetExprID(),
+        std::make_unique<ValueRange>(Bound(nullptr, 0, callassign.GetAssignedLHS()->GetPrimType()), kNotEqual));
+  }
+}
+
+bool ValueRangePropagation::DealWithSwitchWhenOpndIsConstant(BB &bb, BB *defaultBB,
+    const ValueRange *valueRange, const SwitchMeStmt &switchMeStmt) {
+  if (onlyPropVR || valueRange == nullptr || valueRange->GetRangeType() != kEqual ||
+      !valueRange->GetBound().IsConstantBound()) {
+    return false;
+  }
+  bool findBB = false;
+  for (auto &pair : switchMeStmt.GetSwitchTable()) {
+    auto *caseBB = func.GetCfg()->GetLabelBBAt(pair.second);
+    CHECK_FATAL(caseBB, "caseBB is nullptr!");
+    // The value ranges of opnd and case are equal.
+    if (valueRange->GetBound().IsEqual(Bound(nullptr, pair.first, PTY_i64), valueRange->GetBound().GetPrimType())) {
+      findBB = true;
+      continue;
+    }
+    bb.RemoveSucc(*caseBB);
+  }
+  // If the value ranges of opnd and one of cases are equal, the defaultBB is unreachable.
+  if (findBB && defaultBB != nullptr) {
+    bb.RemoveSucc(*defaultBB);
+  }
+  bb.RemoveLastMeStmt();
+  bb.SetKind(kBBFallthru);
+  isCFGChange = true;
+  return true;
+}
+
+void ValueRangePropagation::DealWithSwitch(BB &bb, MeStmt &stmt) {
+  auto &switchMeStmt = static_cast<SwitchMeStmt&>(stmt);
+  auto *opnd = switchMeStmt.GetOpnd();
+  auto *defaultBB = func.GetCfg()->GetLabelBBAt(switchMeStmt.GetDefaultLabel());
+  auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, *opnd);
+  if (DealWithSwitchWhenOpndIsConstant(bb, defaultBB, valueRange, switchMeStmt)) {
+    return;
+  }
+  std::set<BBId> bbOfCases;
+  if (defaultBB != nullptr) {
+    bbOfCases.insert(defaultBB->GetBBId());
+  }
+  std::vector<int64> valueOfCase;
+  for (auto &pair : switchMeStmt.GetSwitchTable()) {
+    valueOfCase.push_back(pair.first);
+    auto *currbb = func.GetCfg()->GetLabelBBAt(pair.second);
+    CHECK_FATAL(currbb, "currbb is nullptr!");
+    // Can prop value range to target bb only when the pred size of target bb is one and
+    // only one case can jump to the target bb.
+    if (currbb->GetPred().size() == 1 && bbOfCases.insert(currbb->GetBBId()).second) {
+      (void)Insert2Caches(
+          currbb->GetBBId(), opnd->GetExprID(),
+          std::make_unique<ValueRange>(Bound(nullptr, pair.first, PTY_i64), kEqual));
+    } else {
+      (void)Insert2Caches(currbb->GetBBId(), opnd->GetExprID(), nullptr);
+    }
+  }
+  if (onlyPropVR || defaultBB == nullptr) {
+    return;
+  }
+  // Delete the default branch when it is unreachable.
+  auto *currBB = &bb;
+  while (valueRange == nullptr && currBB->GetPred().size() == 1) {
+    currBB = currBB->GetPred(0);
+    valueRange = FindValueRangeAndInitNumOfRecursion(*currBB, *opnd);
+  }
+  if (valueRange == nullptr || !valueRange->IsConstantRange()) {
+    return;
+  }
+  auto upper = valueRange->GetUpper().GetConstant();
+  auto lower = valueRange->GetLower().GetConstant();
+  if (upper < lower || static_cast<uint64>(upper - lower + 1) != valueOfCase.size()) {
+    return;
+  }
+  std::sort(valueOfCase.begin(), valueOfCase.end());
+  if (valueOfCase.front() == lower && valueOfCase.back() == upper) {
+    if (ValueRangePropagation::isDebug) {
+      LogInfo::MapleLogger() << "===========delete defaultBranch " << defaultBB->GetBBId() << "===========\n";
+    }
+    switchMeStmt.SetDefaultLabel(0);
+    defaultBB->RemovePred(bb);
+    isCFGChange = true;
+  }
+}
+
+void ValueRangePropagation::DeleteThePhiNodeWhichOnlyHasOneOpnd(
+    BB &bb, ScalarMeExpr *updateSSAExceptTheScalarExpr, std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr) {
+  if (unreachableBBs.find(&bb) != unreachableBBs.end()) {
+    return;
+  }
+  if (bb.GetMePhiList().empty()) {
+    return;
+  }
+  if (bb.GetPred().size() == 1) {
+    InsertOstOfPhi2Cands(bb, 0, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr, true);
+    bb.GetMePhiList().clear();
+  }
+}
+
+bool ValueRange::IsEqual(ValueRange *valueRangeRight) const  {
+  if (valueRangeRight == nullptr) {
+    return false;
+  }
+  if (rangeType != valueRangeRight->GetRangeType()) {
+    return false;
+  }
+  switch (rangeType) {
+    case kLowerAndUpper:
+    case kSpecialUpperForLoop:
+    case kSpecialLowerForLoop:
+      return range.pair.upper == (valueRangeRight->GetUpper()) &&
+             range.pair.lower == (valueRangeRight->GetLower());
+    case kOnlyHasLowerBound:
+      return range.pair.lower == (valueRangeRight->GetLower()) &&
+             stride == valueRangeRight->GetStride();
+    case kOnlyHasUpperBound:
+      return range.pair.upper == (valueRangeRight->GetUpper()) &&
+             stride == valueRangeRight->GetStride();
+    case kNotEqual:
+    case kEqual:
+      return range.bound == (valueRangeRight->GetBound());
+    default:
+      CHECK_FATAL(false, "can not be here");
+  }
+}
+
+// return nullptr means cannot merge, intersect = true : intersection set, intersect = false : union set
+std::unique_ptr<ValueRange> MergeVR(const ValueRange &vr1, const ValueRange &vr2, bool intersect) {
+  RangeType vr1Type = vr1.GetRangeType();
+  RangeType vr2Type = vr2.GetRangeType();
+  // Only these range type can be merged
+  if ((vr1Type != kEqual && vr1Type != kNotEqual && vr1Type != kLowerAndUpper) ||
+      (vr2Type != kEqual && vr2Type != kNotEqual && vr2Type != kLowerAndUpper)) {
+    return nullptr;
+  }
+  // Enumerate all possible combinations of vr1Type and vr2Type
+  switch (vr1Type) {
+    case kLowerAndUpper: {
+      Bound lower1 = vr1.GetLower();
+      Bound upper1 = vr1.GetUpper();
+      switch (vr2Type) {
+        case kLowerAndUpper: {
+          // [lower1 ...... upper1]
+          //     [lower2 .......... upper2]
+          Bound lower2 = vr2.GetLower();
+          Bound upper2 = vr2.GetUpper();
+          if (!lower1.CanBeComparedWith(lower2) || !upper1.CanBeComparedWith(upper2) ||
+              !lower1.CanBeComparedWith(upper2) || !upper1.CanBeComparedWith(lower2)) {
+            return nullptr;
+          }
+          if (upper2 < lower1 || upper1 < lower2) {
+            return intersect ? std::make_unique<ValueRange>(kRTEmpty) : nullptr; // always false
+          } else if (upper2 == lower1) {
+            return intersect ? std::make_unique<ValueRange>(lower1, kEqual)
+                             : std::make_unique<ValueRange>(lower2, upper1, kLowerAndUpper);
+          } else if (upper1 == lower2) {
+            return intersect ? std::make_unique<ValueRange>(lower2, kEqual)
+                             : std::make_unique<ValueRange>(lower1, upper2, kLowerAndUpper);
+          } else if (lower1 < upper2 && lower2 < upper1) {
+            return intersect ?
+                std::make_unique<ValueRange>(std::max(lower1, lower2), std::min(upper1, upper2), kLowerAndUpper) :
+                std::make_unique<ValueRange>(std::min(lower1, lower2), std::max(upper1, upper2), kLowerAndUpper);
+          }
+          return nullptr;
+        }
+        case kEqual: {
+          //                [lower1 ...... upper1]
+          // bound : ^pos1          ^pos2          ^pos3
+          Bound bound = vr2.GetBound();
+          if (!lower1.CanBeComparedWith(bound) || !upper1.CanBeComparedWith(bound)) {
+            return nullptr;
+          }
+          if (lower1 <= bound && bound <= upper1) {
+            return intersect ? std::make_unique<ValueRange>(bound, kEqual)
+                             : std::make_unique<ValueRange>(lower1, upper1, kLowerAndUpper);
+          } else if (bound < lower1 || upper1 < bound) {
+            return intersect ? std::make_unique<ValueRange>(kRTEmpty) // always false
+                             : nullptr; // can not merge
+          }
+          return nullptr;
+        }
+        case kNotEqual: {
+          //                [lower1 ...... upper1]
+          // bound : ^pos1  ^pos2      ^pos3     ^pos4   ^pos5
+          Bound bound = vr2.GetBound();
+          if (!lower1.CanBeComparedWith(bound) || !upper1.CanBeComparedWith(bound)) {
+            return nullptr;
+          }
+          if (bound < lower1 || upper1 < bound) {
+            return intersect ? std::make_unique<ValueRange>(lower1, upper1, kLowerAndUpper)
+                             : std::make_unique<ValueRange>(bound, kNotEqual);
+          } else if (lower1 < bound && bound < upper1) {
+            return intersect ? nullptr : std::make_unique<ValueRange>(kRTComplete);
+          } else if (bound == lower1) {
+            return intersect ? std::make_unique<ValueRange>(++lower1, upper1, kLowerAndUpper)
+                             : std::make_unique<ValueRange>(kRTComplete); // always true;
+          } else if (bound == upper1) {
+            return intersect ? std::make_unique<ValueRange>(lower1, --upper1, kLowerAndUpper)
+                             : std::make_unique<ValueRange>(kRTComplete); // always true;
+          }
+          return nullptr;
+        }
+        default:
+          return nullptr;
+      }
+    }
+    case kEqual: {
+      Bound b1 = vr1.GetBound();
+      Bound b2 = vr2.GetBound();
+      if (!b1.CanBeComparedWith(b2)) {
+        return nullptr;
+      }
+      switch (vr2Type) {
+        case kLowerAndUpper: {
+          return MergeVR(vr2, vr1, intersect); // swap two vr
+        }
+        case kEqual: {
+          if (b1 == b2) {
+            return std::make_unique<ValueRange>(b1, kEqual);
+          } else if (b1 < b2 || b2 < b1) {
+            return intersect ? std::make_unique<ValueRange>(kRTEmpty) : nullptr;
+          }
+          return nullptr;
+        }
+        case kNotEqual: {
+          if (b1 == b2) {
+            return intersect ? std::make_unique<ValueRange>(kRTEmpty) : std::make_unique<ValueRange>(kRTComplete);
+          } else if (b1 < b2 || b2 < b1) {
+            return intersect ? std::make_unique<ValueRange>(b1, kEqual) : std::make_unique<ValueRange>(b2, kNotEqual);
+          }
+          return nullptr;
+        }
+        default:
+          return nullptr;
+      }
+    }
+    case kNotEqual: {
+      switch (vr2Type) {
+        case kLowerAndUpper:
+        case kEqual: {
+          return MergeVR(vr2, vr1, intersect); // swap two vr
+        }
+        case kNotEqual: {
+          Bound b1 = vr1.GetBound();
+          Bound b2 = vr2.GetBound();
+          if (!b1.CanBeComparedWith(b2)) {
+            return nullptr;
+          }
+          if (b1 == b2) {
+            return std::make_unique<ValueRange>(b1, kNotEqual);
+          } else if (b1 < b2 || b2 < b1) {
+            return intersect ? nullptr : std::make_unique<ValueRange>(kRTComplete);
+          }
+          return nullptr;
+        }
+        default:
+          return nullptr;
+      }
+    }
+    default:
+      return nullptr;
+  }
+}
+
+MeExpr *GetCmpExprFromBound(Bound b, MeExpr &expr, MeIRMap *irmap, Opcode op) {
+  int64 val = b.GetConstant();
+  MeExpr *var = const_cast<MeExpr *>(b.GetVar());
+  PrimType ptyp = b.GetPrimType();
+  MeExpr *constExpr = irmap->CreateIntConstMeExpr(val, ptyp);
+  MeExpr *resExpr = nullptr;
+  if (var == nullptr) {
+    resExpr = irmap->CreateMeExprBinary(op, PTY_u1, expr, *constExpr);
+  } else {
+    if (val == 0) {
+      resExpr = irmap->CreateMeExprBinary(op, PTY_u1, expr, *var);
+    } else if (val > 0) {
+      MeExpr *addExpr = irmap->CreateMeExprBinary(OP_add, ptyp, *var, *constExpr);
+      static_cast<OpMeExpr*>(addExpr)->SetOpndType(ptyp);
+      resExpr = irmap->CreateMeExprBinary(op, PTY_u1, expr, *addExpr);
+    } else {
+      MeExpr *subExpr = irmap->CreateMeExprBinary(OP_sub, ptyp, *var, *constExpr);
+      static_cast<OpMeExpr*>(subExpr)->SetOpndType(ptyp);
+      resExpr = irmap->CreateMeExprBinary(op, PTY_u1, expr, *subExpr);
+    }
+  }
+  static_cast<OpMeExpr*>(resExpr)->SetOpndType(ptyp);
+  return resExpr;
+}
+// give expr and its value range, use irmap to create a cmp expr
+MeExpr *GetCmpExprFromVR(const ValueRange *vr, MeExpr &expr, MeIRMap *irmap) {
+  if (vr == nullptr) {
+    return nullptr;
+  }
+  RangeType rt = vr->GetRangeType();
+  switch (rt) {
+    case kLowerAndUpper: {
+      Bound lower = vr->GetLower();
+      Bound upper = vr->GetUpper();
+      if (lower == Bound::MinBound(lower.GetPrimType())) {
+        // expr <= upper
+        return GetCmpExprFromBound(upper, expr, irmap, OP_le);
+      } else if (upper == Bound::MaxBound(upper.GetPrimType())) {
+        // lower <= expr
+        return GetCmpExprFromBound(lower, expr, irmap, OP_ge);
+      } else {
+        // lower <= expr <= upper
+        MeExpr *upperExpr = GetCmpExprFromBound(upper, expr, irmap, OP_le);
+        MeExpr *lowerExpr = GetCmpExprFromBound(lower, expr, irmap, OP_ge);
+        return irmap->CreateMeExprBinary(OP_land, PTY_u1, *upperExpr, *lowerExpr);
+      }
+    }
+    case kOnlyHasLowerBound: {
+      // expr >= val
+      Bound lower = vr->GetLower();
+      return GetCmpExprFromBound(lower, expr, irmap, OP_ge);
+    }
+    case kOnlyHasUpperBound: {
+      // expr <= val
+      Bound upper = vr->GetUpper();
+      return GetCmpExprFromBound(upper, expr, irmap, OP_le);
+    }
+    case kNotEqual: {
+      // expr != val
+      Bound bound = vr->GetBound();
+      return GetCmpExprFromBound(bound, expr, irmap, OP_ne);
+    }
+    case kEqual: {
+      // expr == val
+      Bound bound = vr->GetBound();
+      return GetCmpExprFromBound(bound, expr, irmap, OP_eq);
+    }
+    case kRTEmpty: {
+      // false
+      return irmap->CreateIntConstMeExpr(0, PTY_u1);
+    }
+    case kRTComplete: {
+      // true
+      return irmap->CreateIntConstMeExpr(1, PTY_u1);
+    }
+    default:
+      return nullptr;
+  }
+}
+
+// DealWith this case :
+// a: valueRange(0, constant) || valueRange(constant, 0)
+// ==>
+// a: valueRange(1, constant) || valueRange(constant, -1)
+std::unique_ptr<ValueRange> ValueRangePropagation::ZeroIsInRange(const ValueRange &valueRange) {
+  if (valueRange.GetRangeType() == kLowerAndUpper && valueRange.GetLower().GetVar() == nullptr &&
+      valueRange.GetUpper().GetVar() == nullptr &&
+      valueRange.GetLower().GetConstant() < valueRange.GetUpper().GetConstant()) {
+    if (valueRange.GetLower().GetConstant() == 0) {
+      return std::make_unique<ValueRange>(
+          Bound(1, valueRange.GetLower().GetPrimType()), valueRange.GetUpper(), kLowerAndUpper);
+    }
+    if (valueRange.GetUpper().GetConstant() == 0) {
+      return std::make_unique<ValueRange>(
+          valueRange.GetLower(), Bound(-1, valueRange.GetUpper().GetPrimType()), kLowerAndUpper);
+    }
+  }
+  return nullptr;
+}
+
+std::unique_ptr<ValueRange> ValueRangePropagation::FindValueRangeInCurrBBOrDominateBBs(
+    const BB &bb, MeExpr &opnd) {
+  auto *res = FindValueRangeInCurrentBB(bb.GetBBId(), opnd.GetExprID());
+  if (res != nullptr) {
+    return CopyValueRange(*res);
+  }
+  auto *valueRangeOfOpnd = FindValueRangeAndInitNumOfRecursion(bb, opnd);
+  if (valueRangeOfOpnd != nullptr) {
+    return CopyValueRange(*valueRangeOfOpnd);
+  }
+  return nullptr;
+}
+
+void SafetyCheckWithBoundaryError::HandleAssignWithDeadBeef(
+    BB &bb, MeStmt &meStmt, MeExpr &indexOpnd,
+    MeExpr &boundOpnd) {
+  std::set<MeExpr*> visitedLHS;
+  std::vector<MeStmt*> stmts{ &meStmt };
+  bool crossPhiNode = false;
+  vrp.JudgeTheConsistencyOfDefPointsOfBoundaryCheck(bb, indexOpnd, visitedLHS, stmts, crossPhiNode);
+  visitedLHS.clear();
+  stmts.clear();
+  stmts.push_back(&meStmt);
+  crossPhiNode = false;
+  vrp.JudgeTheConsistencyOfDefPointsOfBoundaryCheck(bb, boundOpnd, visitedLHS, stmts, crossPhiNode);
+}
+
+// Deal with this case :
+// valueRangeOfIndex zero is in range and in safe region mode, compiler err
+// valueRangeOfIndex is zero and not in safe region mode, compiler err
+void SafetyCheckWithNonnullError::HandleAssertNonnull(const MeStmt &meStmt, const ValueRange *valueRangeOfIndex) {
+  if ((valueRangeOfIndex == nullptr || valueRangeOfIndex->IsZeroInRange()) &&
+      meStmt.IsInSafeRegion() && MeOption::safeRegionMode) {
+    (void)NeedDeleteTheAssertAfterErrorOrWarn(meStmt, true);
+  }
+  if (valueRangeOfIndex != nullptr && valueRangeOfIndex->IsEqualZero()) {
+    (void)NeedDeleteTheAssertAfterErrorOrWarn(meStmt);
+  }
+}
+
+bool SafetyCheckWithBoundaryError::HandleAssertError(const MeStmt &meStmt) {
+  return NeedDeleteTheAssertAfterErrorOrWarn(meStmt);
+}
+
+bool SafetyCheckWithBoundaryError::HandleAssertltOrAssertle(
+    const MeStmt &meStmt, Opcode op, int64 indexValue, int64 lengthValue) {
+  if (kOpcodeInfo.IsAssertLeBoundary((op))) {
+    if (indexValue > lengthValue) {
+      return NeedDeleteTheAssertAfterErrorOrWarn(meStmt);
+    }
+  } else {
+    if (indexValue >= lengthValue) {
+      return NeedDeleteTheAssertAfterErrorOrWarn(meStmt);
+    }
+  }
+  return false;
+}
+
+bool ValueRangePropagation::CompareConstantOfIndexAndLength(
+    const MeStmt &meStmt, const ValueRange &valueRangeOfIndex, ValueRange &valueRangeOfLengthPtr, Opcode op) {
+  if (safetyCheckBoundary->HandleAssertltOrAssertle(meStmt, op, valueRangeOfIndex.GetUpper().GetConstant(),
+                                                    valueRangeOfLengthPtr.GetBound().GetConstant())) {
+    return true;
+  }
+  return (kOpcodeInfo.IsAssertLeBoundary(op) ?
+      valueRangeOfIndex.GetUpper().GetConstant() <= valueRangeOfLengthPtr.GetBound().GetConstant() :
+      valueRangeOfIndex.GetUpper().GetConstant() < valueRangeOfLengthPtr.GetBound().GetConstant());
+}
+
+bool ValueRangePropagation::CompareIndexWithUpper(const BB &bb, const MeStmt &meStmt,
+    const ValueRange &valueRangeOfIndex, ValueRange &valueRangeOfLengthPtr, Opcode op, const MeExpr *indexOpnd) {
+  if (valueRangeOfIndex.GetRangeType() == kNotEqual || valueRangeOfLengthPtr.GetRangeType() == kNotEqual) {
+    return false;
+  }
+  // Opt array boundary check when the array length is a constant.
+  if (valueRangeOfLengthPtr.IsConstantLowerAndUpper()) {
+    auto lowerOfLength = valueRangeOfLengthPtr.GetLower().GetConstant();
+    auto upperOfLength = valueRangeOfLengthPtr.GetUpper().GetConstant();
+    if (valueRangeOfIndex.GetRangeType() == kSpecialLowerForLoop ||
+        (valueRangeOfIndex.GetRangeType() == kLowerAndUpper && valueRangeOfIndex.IsAccurate())) {
+      if (safetyCheckBoundary->HandleAssertltOrAssertle(meStmt, op, valueRangeOfIndex.GetUpper().GetConstant(),
+                                                        upperOfLength)) {
+        return true;
+      }
+      return (kOpcodeInfo.IsAssertLeBoundary((op))) ? valueRangeOfIndex.GetUpper().GetConstant() <= lowerOfLength :
+          valueRangeOfIndex.GetUpper().GetConstant() < lowerOfLength;
+    }
+    if (!valueRangeOfIndex.IsConstantLowerAndUpper() ||
+        valueRangeOfIndex.GetLower().GetConstant() > valueRangeOfIndex.GetUpper().GetConstant() ||
+        valueRangeOfLengthPtr.GetLower().GetConstant() > valueRangeOfLengthPtr.GetUpper().GetConstant()) {
+      return false;
+    }
+    if (valueRangeOfLengthPtr.GetLower().GetConstant() < 0) {
+      // The value of length is overflow, need deal with this case later.
+    }
+    auto *loop = loops->GetBBLoopParent(bb.GetBBId());
+    // When some values of index which is loop var are out of bound, error during static compilation
+    // only if the loop is canonical and the range of var is accurate.
+    if (valueRangeOfIndex.IsAccurate() && indexOpnd != nullptr && loop != nullptr &&
+        loop->IsCanonicalAndOnlyHasOneExitBBLoop() && IsLoopVariable(*loop, *indexOpnd)) {
+      if (safetyCheckBoundary->HandleAssertltOrAssertle(meStmt, op, valueRangeOfIndex.GetUpper().GetConstant(),
+                                                        upperOfLength)) {
+        return true;
+      }
+    } else {
+      if (safetyCheckBoundary->HandleAssertltOrAssertle(meStmt, op, valueRangeOfIndex.GetLower().GetConstant(),
+                                                        upperOfLength)) {
+        return true;
+      }
+    }
+    return (kOpcodeInfo.IsAssertLeBoundary((op))) ? valueRangeOfIndex.GetUpper().GetConstant() <= lowerOfLength :
+        valueRangeOfIndex.GetUpper().GetConstant() < lowerOfLength;
+  } else if (valueRangeOfLengthPtr.GetRangeType() == kEqual) {
+    // Opt array boundary check when the array length is a var.
+    if (valueRangeOfIndex.GetRangeType() == kSpecialUpperForLoop ||
+        valueRangeOfIndex.GetRangeType() == kLowerAndUpper) {
+      // When the var of index is not equal to the var of length, need analysis if the var of index is related to the
+      // var of length. For example:
+      // Example: i = len - i;
+      // Example: p[i];
+      // Example: assertlt(p + i * 4, p + len * 4)
+      if (valueRangeOfIndex.GetUpper().GetVar() != valueRangeOfLengthPtr.GetBound().GetVar()) {
+        // deal with the case like i = len + x:
+        auto *upperVar = valueRangeOfIndex.GetUpper().GetVar();
+        if (upperVar == nullptr) {
+          return false;
+        }
+        auto *crNode = sa.GetOrCreateCRNode(*upperVar);
+        if (crNode == nullptr) {
+          return false;
+        }
+        if (crNode->GetCRType() == kCRVarNode) {
+          return (crNode->GetExpr() == valueRangeOfLengthPtr.GetBound().GetVar()) &&
+              CompareConstantOfIndexAndLength(meStmt, valueRangeOfIndex, valueRangeOfLengthPtr, op);
+        }
+        if (crNode->GetCRType() != kCRAddNode ||
+            static_cast<CRAddNode*>(crNode)->GetOpndsSize() != kNumOperands ||
+            static_cast<CRAddNode*>(crNode)->GetOpnd(1)->GetExpr() == nullptr ||
+            static_cast<CRAddNode*>(crNode)->GetOpnd(1)->GetExpr() != valueRangeOfLengthPtr.GetBound().GetVar() ||
+            static_cast<CRAddNode*>(crNode)->GetOpnd(0)->GetCRType() != kCRConstNode) {
+          return false;
+        }
+        // Update the valueRange of index after analysis the relationship of expr and length.
+        // valueRangeOfIndex : (lower(nullptr, 1), upper: (expr, -1), kLowerAndUpper)
+        // valueRangeOfLength: (Bound(length, 0), kEqual)
+        // expr = length - 1
+        // after analysis: valueRangeOfIndex :  (lower(length), upper: (-2), kLowerAndUpper)
+        int64 res = 0;
+        auto constantValue =
+            static_cast<CRConstNode*>(static_cast<CRAddNode*>(crNode)->GetOpnd(0))->GetConstValue();
+        if (!AddOrSubWithConstant(valueRangeOfLengthPtr.GetUpper().GetPrimType(), OP_add, constantValue,
+                                  valueRangeOfIndex.GetUpper().GetConstant(), res)) {
+          return false;
+        }
+        if (safetyCheckBoundary->HandleAssertltOrAssertle(meStmt, op, res,
+                                                          valueRangeOfLengthPtr.GetBound().GetConstant())) {
+          return true;
+        }
+        return (kOpcodeInfo.IsAssertLeBoundary(op) ? res <= valueRangeOfLengthPtr.GetBound().GetConstant() :
+            res < valueRangeOfLengthPtr.GetBound().GetConstant());
+      } else {
+        return CompareConstantOfIndexAndLength(meStmt, valueRangeOfIndex, valueRangeOfLengthPtr, op);
+      }
+    }
+    if ((valueRangeOfIndex.GetLower().GetVar() != valueRangeOfIndex.GetUpper().GetVar()) ||
+        valueRangeOfIndex.GetUpper().GetVar() != valueRangeOfLengthPtr.GetBound().GetVar()) {
+      return false;
+    }
+    if (safetyCheckBoundary->HandleAssertltOrAssertle(meStmt, op, valueRangeOfIndex.GetUpper().GetConstant(),
+                                                      valueRangeOfLengthPtr.GetBound().GetConstant())) {
+      return true;
+    }
+    return kOpcodeInfo.IsAssertLeBoundary(op) ?
+        valueRangeOfIndex.GetUpper().GetConstant() <= valueRangeOfLengthPtr.GetBound().GetConstant() :
+        valueRangeOfIndex.GetUpper().GetConstant() < valueRangeOfLengthPtr.GetBound().GetConstant();
+  }
+  return false;
+}
+
+// If the bb of the boundary check which is analysised befor dominates the bb of the boundary check which is
+// analysised now, then eliminate the current boundary check.
+bool ValueRangePropagation::IfAnalysisedBefore(const BB &bb, const MeStmt &stmt) {
+  MeExpr &index = *stmt.GetOpnd(0);
+  MeExpr &bound = *stmt.GetOpnd(1);
+  auto &analysisedArrayChecks = (kOpcodeInfo.IsAssertLowerBoundary(stmt.GetOp())) ? analysisedLowerBoundChecks :
+      (kOpcodeInfo.IsAssertLeBoundary(stmt.GetOp())) ? analysisedAssignBoundChecks : analysisedUpperBoundChecks;
+  for (size_t i = 0; i < analysisedArrayChecks.size(); ++i) {
+    auto *analysisedBB = func.GetCfg()->GetBBFromID(BBId(i));
+    if (!dom.Dominate(*analysisedBB, bb)) {
+      continue;
+    }
+    auto &analysisedChecks = analysisedArrayChecks[i];
+    auto it = analysisedChecks.find(&bound);
+    // Determine if they are the same array.
+    if (it == analysisedChecks.end()) {
+      return false;
+    }
+    // Determine if the index of the array check which is analysised before equals to the index of the array check
+    // which is analysised now.
+    if (it->second.find(&index) != it->second.end()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ValueRangePropagation::TheValueOfOpndIsInvaliedInABCO(
+    const BB &bb, const MeStmt *meStmt, MeExpr &boundOpnd, bool updateCaches) {
+  if (boundOpnd.GetMeOp() == kMeOpConst &&
+      static_cast<const ConstMeExpr&>(boundOpnd).GetConstVal()->GetKind() == kConstInt &&
+      static_cast<uint64>(static_cast<const ConstMeExpr&>(boundOpnd).GetExtIntValue()) == kInvaliedBound) {
+    if (updateCaches) {
+      Insert2AnalysisedArrayChecks(bb.GetBBId(), *meStmt->GetOpnd(1), *meStmt->GetOpnd(0), meStmt->GetOp());
+    }
+    return true;
+  } else {
+    auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, boundOpnd);
+    if (valueRange != nullptr && valueRange->GetRangeType() != kNotEqual &&
+        valueRange->IsConstant() && static_cast<uint64>(valueRange->GetLower().GetConstant()) == kInvaliedBound) {
+      if (updateCaches) {
+        Insert2AnalysisedArrayChecks(bb.GetBBId(), *meStmt->GetOpnd(1), *meStmt->GetOpnd(0), meStmt->GetOp());
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+// Pointer assigned from multibranch requires the bounds info for all branches.
+// if:
+//    p = GetBoundaryPtr
+// else:
+//    p = GetBoundarylessPtr
+// error: p + i
+void ValueRangePropagation::JudgeTheConsistencyOfDefPointsOfBoundaryCheck(
+    BB &bb, MeExpr &expr, std::set<MeExpr*> &visitedLHS, std::vector<MeStmt*> &stmts, bool &crossPhiNode) {
+  if (TheValueOfOpndIsInvaliedInABCO(bb, nullptr, expr, false)) {
+    std::string errorLog = "";
+    if (!crossPhiNode) {
+      if (stmts[0]->IsInSafeRegion() &&
+          (stmts[0]->GetOp() == OP_calcassertge || stmts[0]->GetOp() == OP_calcassertlt)) {
+        errorLog += "error: the pointer has no boundary info.\n";
+      } else {
+        bb.RemoveMeStmt(stmts[0]);
+        return;
+      }
+    } else {
+      errorLog += "error: pointer assigned from multibranch requires the boundary info for all branches.\n";
+    }
+    for (size_t i = 0; i < stmts.size(); ++i) {
+      if (i == 0) {
+        errorLog += "Where the pointer is used at the statement:\n";
+      }
+      if (i == 1) {
+        errorLog += "Pointer is assigned from pointer which has no boundary info. The data flow is:\n";
+      }
+      auto &srcPosition = stmts[i]->GetSrcPosition();
+      errorLog += func.GetMIRModule().GetFileNameFromFileNum(srcPosition.FileNum()) + ":" +
+          std::to_string(srcPosition.LineNum()) + "\n";
+    }
+    FATAL(kLncFatal, "%s", errorLog.c_str());
+  }
+  if (!expr.IsScalar()) {
+    for (size_t i = 0; i < expr.GetNumOpnds(); ++i) {
+      JudgeTheConsistencyOfDefPointsOfBoundaryCheck(bb, *expr.GetOpnd(i), visitedLHS, stmts, crossPhiNode);
+    }
+    return;
+  }
+  ScalarMeExpr &scalar = static_cast<ScalarMeExpr&>(expr);
+  if (scalar.GetDefBy() == kDefByStmt) {
+    stmts.push_back(scalar.GetDefStmt());
+    if (visitedLHS.find(scalar.GetDefStmt()->GetRHS()) != visitedLHS.end()) {
+      return;
+    }
+    JudgeTheConsistencyOfDefPointsOfBoundaryCheck(bb, *scalar.GetDefStmt()->GetRHS(), visitedLHS, stmts, crossPhiNode);
+    stmts.pop_back();
+    visitedLHS.insert(scalar.GetDefStmt()->GetRHS());
+  } else if (scalar.GetDefBy() == kDefByPhi) {
+    crossPhiNode = true;
+    MePhiNode &phi = scalar.GetDefPhi();
+    if (visitedLHS.find(phi.GetLHS()) != visitedLHS.end()) {
+      return;
+    }
+    visitedLHS.insert(phi.GetLHS());
+    for (auto &opnd : phi.GetOpnds()) {
+      JudgeTheConsistencyOfDefPointsOfBoundaryCheck(bb, *opnd, visitedLHS, stmts, crossPhiNode);
+    }
+  }
+}
+
+bool ValueRangePropagation::IsLoopVariable(const LoopDesc &loop, const MeExpr &opnd) const {
+  if (!opnd.IsScalar()) {
+    return false;
+  }
+  bool opndIsLoopVar = false;
+  auto defBy = static_cast<const ScalarMeExpr&>(opnd).GetDefBy();
+  // Check whether it is a loop variable.
+  if (defBy == kDefByStmt) {
+    // If the def stmt is inc or dec stmt, the opnd is loop variable.
+    auto *defStmt = static_cast<const ScalarMeExpr&>(opnd).GetDefByMeStmt();
+    if (defStmt != nullptr && kOpcodeInfo.AssignActualVar(defStmt->GetOp())) {
+      MeExpr *rhs = defStmt->GetRHS();
+      if (rhs->GetOp() == OP_add || rhs->GetOp() == OP_sub) {
+        OpMeExpr *opRHS = static_cast<OpMeExpr*>(rhs);
+        if (defStmt->GetLHS()->GetOst() == static_cast<ScalarMeExpr*>(opRHS->GetOpnd(0))->GetOst()) {
+          opndIsLoopVar = ThePhiLHSIsLoopVariable(loop, *opRHS->GetOpnd(0));
+        }
+      }
+    }
+  } else if (defBy == kDefByPhi) {
+    opndIsLoopVar = ThePhiLHSIsLoopVariable(loop, opnd);
+  }
+  return opndIsLoopVar;
+}
+
+bool ValueRangePropagation::ThePhiLHSIsLoopVariable(const LoopDesc &loop, const MeExpr &opnd) const {
+  if (!opnd.IsScalar()) {
+    return false;
+  }
+  auto defBy = static_cast<const ScalarMeExpr&>(opnd).GetDefBy();
+  if (defBy != kDefByPhi) {
+    return false;
+  }
+  auto &defPhi = static_cast<const ScalarMeExpr&>(opnd).GetDefPhi();
+  MeStmt *defStmt = nullptr;
+  if (defPhi.GetOpnds().size() == kNumOperands) {
+    auto *defBBOfOpnd0 = defPhi.GetOpnd(0)->GetDefByBBMeStmt(*func.GetCfg(), defStmt);
+    auto *defBBOfOpnd1 = defPhi.GetOpnd(1)->GetDefByBBMeStmt(*func.GetCfg(), defStmt);
+    // if the def bb of opnd0 is out of loop and the def bb of opnd1 is in loop, the opnd is loop variable.
+    if (defPhi.GetDefBB() == loop.head && !loop.Has(*defBBOfOpnd0) && loop.Has(*defBBOfOpnd1)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static inline bool CanNotDoReplaceLoopVarOpt(const ValueRange *valueRange) {
+  if (valueRange == nullptr) {
+    return true;
+  }
+  auto type = valueRange->GetRangeType();
+  return type != kEqual && !(type == kLowerAndUpper && valueRange->IsAccurate());
+}
+
+void ValueRangePropagation::CollectIndexOpndWithBoundInLoop(
+    LoopDesc &loop, BB &bb, MeStmt &meStmt, MeExpr &opnd, std::map<MeExpr*, MeExpr*> &index2NewExpr) {
+  // If the var is opnd of ivar, can not replace it with the bound.
+  // For example: array[s[i]]
+  // assert(array + iread(s + i) * 4, array + 1024)
+  // Can not replace i with its upper bound.
+  if (!opnd.IsScalar()) {
+    index2NewExpr[&opnd] = nullptr;
+    return;
+  } else {
+    if (!IsLoopVariable(loop, opnd)) {
+      index2NewExpr[&opnd] = nullptr;
+    } else {
+      auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, opnd);
+      if (CanNotDoReplaceLoopVarOpt(valueRange)) {
+        index2NewExpr[&opnd] = nullptr;
+      } else {
+        // If the assert stmt is lower boundary check, replace the index opnd with the lower bound, otherwise,
+        // replace the index opnd with the upper bound.
+        auto bound =
+            kOpcodeInfo.IsAssertLowerBoundary(meStmt.GetOp()) ? valueRange->GetLower() : valueRange->GetUpper();
+        MeExpr *newExpr = nullptr;
+        if (bound.GetVar() == nullptr) {
+          newExpr = irMap.CreateIntConstMeExpr(bound.GetConstant(), bound.GetPrimType());
+        } else if (bound.GetConstant() == 0) {
+          newExpr = bound.GetVar();
+        } else {
+          auto *newConstExpr = irMap.CreateIntConstMeExpr(bound.GetConstant(), bound.GetPrimType());
+          newExpr = irMap.CreateMeExprBinary(OP_add, bound.GetPrimType(), *bound.GetVar(), *newConstExpr);
+        }
+        index2NewExpr[&opnd] = newExpr;
+      }
+    }
+  }
+  for (uint8 i = 0; i < opnd.GetNumOpnds(); ++i) {
+    CollectIndexOpndWithBoundInLoop(loop, bb, meStmt, *(opnd.GetOpnd(i)), index2NewExpr);
+  }
+}
+
+MeExpr *ValueRangePropagation::GetAddressOfIndexOrBound(MeExpr &expr) const {
+  if (expr.IsLeaf()) {
+    return (expr.IsScalar() && static_cast<ScalarMeExpr&>(expr).GetDefBy() == kDefByStmt) ?
+        GetAddressOfIndexOrBound(*static_cast<ScalarMeExpr&>(expr).GetDefStmt()->GetRHS()) : &expr;
+  }
+  return GetAddressOfIndexOrBound(*expr.GetOpnd(0));
+}
+
+void ValueRangePropagation::GetValueRangeOfCRNode(
+    const BB &bb, CRNode &opndOfCRNode, std::unique_ptr<ValueRange> &resValueRange, PrimType pTypeOfArray) {
+  // Deal with the operand which is a constant.
+  if (opndOfCRNode.GetCRType() == kCRConstNode) {
+    int64 constant = static_cast<CRConstNode&>(opndOfCRNode).GetConstValue();
+    resValueRange = (resValueRange == nullptr) ?
+        std::make_unique<ValueRange>(Bound(constant, pTypeOfArray), kEqual) :
+        AddOrSubWithValueRange(OP_add, *resValueRange, constant);
+    return;
+  }
+  // Deal with the operand which is a meexpr.
+  if (opndOfCRNode.GetExpr() == nullptr) {
+    resValueRange = nullptr;
+    return;
+  }
+  auto valueRangOfOpnd = FindValueRangeInCurrBBOrDominateBBs(bb, *opndOfCRNode.GetExpr());
+  if (valueRangOfOpnd == nullptr) {
+    valueRangOfOpnd = std::make_unique<ValueRange>(
+        Bound(opndOfCRNode.GetExpr(), opndOfCRNode.GetExpr()->GetPrimType()), kEqual);
+    if (resValueRange == nullptr) {
+      resValueRange = std::move(valueRangOfOpnd);
+    } else if (resValueRange->IsNotConstantVR()) {
+      resValueRange = nullptr;
+    } else {
+      resValueRange = AddOrSubWithValueRange(OP_add, *resValueRange, *valueRangOfOpnd);
+      if (resValueRange == nullptr) {
+        resValueRange = nullptr;
+      }
+    }
+  } else if (valueRangOfOpnd->GetRangeType() == kNotEqual && resValueRange == nullptr) {
+    resValueRange = std::make_unique<ValueRange>(
+        Bound(opndOfCRNode.GetExpr(), opndOfCRNode.GetExpr()->GetPrimType()), kEqual);
+  } else if (valueRangOfOpnd->GetRangeType() == kOnlyHasUpperBound ||
+             valueRangOfOpnd->GetRangeType() == kOnlyHasLowerBound) {
+    resValueRange = nullptr;
+  } else {
+    resValueRange = (resValueRange == nullptr) ? std::move(valueRangOfOpnd) :
+        AddOrSubWithValueRange(OP_add, *resValueRange, *valueRangOfOpnd);
+  }
+}
+
+// Get the valueRange of index and bound, for example:
+// assertge(ptr, ptr + 8) -> the valueRange of index is 8
+// assertge(ptr, ptr + len * 4 - 8) -> the valueRange of index is len - 2
+std::unique_ptr<ValueRange> ValueRangePropagation::GetValueRangeOfCRNodes(
+    const BB &bb, PrimType pTypeOfArray, std::vector<CRNode*> &crNodes) {
+  if (crNodes.empty()) {
+    return CreateValueRangeOfEqualZero(pTypeOfArray);
+  }
+  std::unique_ptr<ValueRange> resValueRange = nullptr;
+  for (size_t i = 0; i < crNodes.size(); ++i) {
+    auto *opndOfCRNode = crNodes[i];
+    if (opndOfCRNode->GetCRType() != kCRConstNode && opndOfCRNode->GetCRType() != kCRVarNode &&
+        opndOfCRNode->GetCRType() != kCRAddNode) {
+      return nullptr;
+    }
+    if (opndOfCRNode->GetCRType() != kCRAddNode) {
+      GetValueRangeOfCRNode(bb, *opndOfCRNode, resValueRange, pTypeOfArray);
+    } else {
+      auto *addCRNOde = static_cast<CRAddNode*>(opndOfCRNode);
+      for (size_t addNodeIndex = 0; addNodeIndex < addCRNOde->GetOpndsSize(); ++addNodeIndex) {
+        GetValueRangeOfCRNode(bb, *addCRNOde->GetOpnd(addNodeIndex), resValueRange, pTypeOfArray);
+        if (resValueRange == nullptr) {
+          return nullptr;
+        }
+      }
+    }
+    if (resValueRange == nullptr) {
+      return nullptr;
+    }
+  }
+  return resValueRange;
+}
+
+bool ValueRangePropagation::DealWithBoundaryCheck(BB &bb, MeStmt &meStmt) {
+  // If the stmt is analysised before, delete the boundary check.
+  if (IfAnalysisedBefore(bb, meStmt)) {
+    return true;
+  }
+  // Add the stmt to cache to prevent duplicate checks.
+  Insert2AnalysisedArrayChecks(bb.GetBBId(), *meStmt.GetOpnd(1), *meStmt.GetOpnd(0), meStmt.GetOp());
+  CHECK_FATAL(meStmt.NumMeStmtOpnds() == kNumOperands, "must have two opnds");
+  auto &naryMeStmt = static_cast<NaryMeStmt&>(meStmt);
+  auto *boundOpnd = naryMeStmt.GetOpnd(1);
+  auto *indexOpnd = naryMeStmt.GetOpnd(0);
+  safetyCheckBoundary->HandleAssignWithDeadBeef(bb, meStmt, *indexOpnd, *boundOpnd);
+  CRNode *indexCR = sa.GetOrCreateCRNode(*indexOpnd);
+  CRNode *boundCR = sa.GetOrCreateCRNode(*boundOpnd);
+  if (indexCR == nullptr || boundCR == nullptr) {
+    return false;
+  }
+  MeExpr *addrExpr = GetAddressOfIndexOrBound(*indexOpnd);
+  if (addrExpr != GetAddressOfIndexOrBound(*boundOpnd)) {
+    if (ValueRangePropagation::isDebug) {
+      meStmt.Dump(&irMap);
+      LogInfo::MapleLogger() << "The address of bases is not equal\n";
+    }
+    return false;
+  }
+  if (ValueRangePropagation::isDebug) {
+    meStmt.Dump(&irMap);
+    sa.Dump(*indexCR);
+    LogInfo::MapleLogger() << "\n";
+    sa.Dump(*boundCR);
+    LogInfo::MapleLogger() << "\n";
+  }
+  bool indexIsEqualToBound = indexCR->IsEqual(*boundCR);
+  if (indexIsEqualToBound) {
+    if (kOpcodeInfo.IsAssertLowerBoundary(meStmt.GetOp()) || kOpcodeInfo.IsAssertLeBoundary(meStmt.GetOp())) {
+      return true;
+    }
+    if (safetyCheckBoundary->HandleAssertError(meStmt)) {
+      return true;
+    }
+  }
+  std::vector<CRNode*> indexVector;
+  std::vector<CRNode*> boundVector;
+  indexCR->GetTheUnequalSubNodesOfIndexAndBound(*boundCR, indexVector, boundVector);
+  PrimType primType = sa.GetPrimType(indexVector);
+  auto byteSizeFromIndexVector = sa.GetByteSize(indexVector);
+  auto byteSizeFromBoundVector = sa.GetByteSize(boundVector);
+  uint8 byteSize = (byteSizeFromIndexVector > 1) ? byteSizeFromIndexVector : byteSizeFromBoundVector;
+  // If can not normalization the vector, return false.
+  if ((!sa.NormalizationWithByteCount(indexVector, byteSize) ||
+       !sa.NormalizationWithByteCount(boundVector, byteSize))) {
+    return false;
+  }
+  if (ValueRangePropagation::isDebug) {
+    std::for_each(indexVector.begin(), indexVector.end(), [this](const CRNode *cr) {
+        sa.Dump(*cr);
+        std::cout << " ";});
+    LogInfo::MapleLogger() << "\n";
+    std::for_each(boundVector.begin(), boundVector.end(), [this](const CRNode *cr) {
+        sa.Dump(*cr);
+        std::cout << " ";});
+    LogInfo::MapleLogger() << "\n";
+  }
+  // Get the valueRange of index and bound
+  auto valueRangeOfIndex = GetValueRangeOfCRNodes(bb, primType, indexVector);
+  auto valueRangeOfbound = GetValueRangeOfCRNodes(bb, primType, boundVector);
+  if (valueRangeOfIndex == nullptr || valueRangeOfbound == nullptr) {
+    return false;
+  }
+  if (kOpcodeInfo.IsAssertLowerBoundary(meStmt.GetOp())) {
+    if (BrStmtInRange(bb, *valueRangeOfIndex, *valueRangeOfbound, OP_ge,
+                      valueRangeOfIndex->GetLower().GetPrimType())) {
+      // Can opt the boundary check.
+      return true;
+    } else if (BrStmtInRange(bb, *valueRangeOfIndex, *valueRangeOfbound, OP_lt,
+                             valueRangeOfIndex->GetLower().GetPrimType())) {
+      // Error during static compilation.
+      if (safetyCheckBoundary->HandleAssertError(meStmt)) {
+        return true;
+      }
+    } else if ((valueRangeOfIndex->GetRangeType() == kSpecialUpperForLoop ||
+               valueRangeOfIndex->GetRangeType() == kOnlyHasLowerBound ||
+               (valueRangeOfIndex->GetRangeType() == kLowerAndUpper && valueRangeOfIndex->IsAccurate())) &&
+               valueRangeOfIndex->GetLower().GetVar() == nullptr && valueRangeOfbound->GetLower().GetVar() == nullptr &&
+               valueRangeOfbound->GetUpper().GetVar() == nullptr) {
+      if (valueRangeOfIndex->GetLower().GetConstant() < valueRangeOfbound->GetUpper().GetConstant()) {
+        // Error during static compilation.
+        if (safetyCheckBoundary->HandleAssertError(meStmt)) {
+          return true;
+        }
+        return false;
+      } else {
+        // Can opt the boundary check.
+        return true;
+      }
+    } else if (valueRangeOfIndex->GetRangeType() == kLowerAndUpper && valueRangeOfIndex->IsAccurate() &&
+        valueRangeOfIndex->IsConstantLowerAndUpper() && valueRangeOfbound->IsEqualZero() &&
+        valueRangeOfIndex->GetLower().GetConstant() < 0) {
+      // Error during static compilation.
+      if (safetyCheckBoundary->HandleAssertError(meStmt)) {
+        return true;
+      }
+    }
+  } else {
+    auto *currIndexOpnd = (indexVector.size() == 1) ? indexVector[0]->GetExpr() : nullptr;
+    if (CompareIndexWithUpper(bb, meStmt, *valueRangeOfIndex, *valueRangeOfbound, meStmt.GetOp(), currIndexOpnd)) {
+      return true;
+    }
+  }
+  auto *loop = loops->GetBBLoopParent(bb.GetBBId());
+  if (loop != nullptr && loop->IsCanonicalLoop() && loop->inloopBB2exitBBs.size() == 1 &&
+      loop->inloopBB2exitBBs.begin()->second->size() == 1) {
+    std::map<MeExpr*, MeExpr*> index2NewExpr;
+    for (uint8 i = 0; i < indexOpnd->GetNumOpnds(); ++i) {
+      auto *opnd = indexOpnd->GetOpnd(i);
+      if (index2NewExpr.find(opnd) != index2NewExpr.end()) {
+        continue;
+      }
+      CollectIndexOpndWithBoundInLoop(*loop, bb, meStmt, *opnd, index2NewExpr);
+    }
+    for (auto it = index2NewExpr.begin(); it != index2NewExpr.end(); ++it) {
+      if (it->second == nullptr) {
+        continue;
+      }
+      (void)irMap.ReplaceMeExprStmt(meStmt, *it->first, *it->second);
+    }
+  }
+  return false;
+}
+
+// If error in Compile return false, else return true.
+bool SafetyCheck::NeedDeleteTheAssertAfterErrorOrWarn(const MeStmt &stmt, bool isNullablePtr) const {
+  auto srcPosition = stmt.GetSrcPosition();
+  const std::string &fileName = func->GetMIRModule().GetFileNameFromFileNum(srcPosition.FileNum());
+  switch (stmt.GetOp()) {
+    case OP_calcassertlt:
+    case OP_calcassertge: {
+      auto &newStmt = static_cast<const AssertBoundaryMeStmt &>(stmt);
+      GStrIdx curFuncNameIdx = func->GetMirFunc()->GetNameStrIdx();
+      GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(newStmt.GetFuncName().c_str());
+      if (curFuncNameIdx == stmtFuncNameIdx) {
+        if (stmt.GetOp() == OP_calcassertlt) {
+          WARN_USER(kLncWarn, srcPosition, func->GetMIRModule(), "the pointer >= the upper bounds after calculation");
+        } else if (stmt.GetOp() == OP_calcassertge) {
+          WARN_USER(kLncWarn, srcPosition, func->GetMIRModule(), "the pointer < the lower bounds after calculation");
+        }
+      } else {
+        if (stmt.GetOp() == OP_calcassertlt) {
+          WARN_USER(kLncWarn, srcPosition, func->GetMIRModule(),
+               "the pointer >= the upper bounds after calculation when inlined to %s", func->GetName().c_str());
+        } else if (stmt.GetOp() == OP_calcassertge) {
+          WARN_USER(kLncWarn, srcPosition, func->GetMIRModule(),
+               "the pointer < the lower bounds after calculation when inlined to %s", func->GetName().c_str());
+        }
+      }
+      return true;
+    }
+    case OP_assignassertnonnull:
+    case OP_assertnonnull:
+    case OP_returnassertnonnull: {
+      auto &newStmt = static_cast<const AssertNonnullMeStmt &>(stmt);
+      GStrIdx curFuncNameIdx = func->GetMirFunc()->GetNameStrIdx();
+      GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(newStmt.GetFuncName().c_str());
+      if (curFuncNameIdx == stmtFuncNameIdx) {
+        if (isNullablePtr) {
+          if (stmt.GetOp() == OP_assertnonnull) {
+            FATAL(kLncFatal, "%s:%d error: Dereference of nullable pointer in safe region",
+                  fileName.c_str(), srcPosition.LineNum());
+          } else if (stmt.GetOp() == OP_returnassertnonnull) {
+            FATAL(kLncFatal, "%s:%d error: %s return nonnull but got nullable pointer in safe region",
+                  fileName.c_str(), srcPosition.LineNum(), newStmt.GetFuncName().c_str());
+          } else {
+            FATAL(kLncFatal, "%s:%d error: nullable pointer assignment of nonnull pointer in safe region",
+                  fileName.c_str(), srcPosition.LineNum());
+          }
+        } else {
+          if (stmt.GetOp() == OP_assertnonnull) {
+            FATAL(kLncFatal, "%s:%d error: Dereference of null pointer", fileName.c_str(), srcPosition.LineNum());
+          } else if (stmt.GetOp() == OP_returnassertnonnull) {
+            FATAL(kLncFatal, "%s:%d error: %s return nonnull but got null pointer", fileName.c_str(),
+                  srcPosition.LineNum(), newStmt.GetFuncName().c_str());
+          } else {
+            FATAL(kLncFatal, "%s:%d error: null assignment of nonnull pointer", fileName.c_str(),
+                  srcPosition.LineNum());
+          }
+        }
+      } else {
+        if (isNullablePtr) {
+          if (stmt.GetOp() == OP_assertnonnull) {
+            FATAL(kLncFatal, "%s:%d error: Dereference of nullable pointer in safe region when inlined to %s",
+                  fileName.c_str(), srcPosition.LineNum(), func->GetName().c_str());
+          } else if (stmt.GetOp() == OP_returnassertnonnull) {
+            FATAL(kLncFatal,
+                  "%s:%d error: %s return nonnull but got nullable pointer in safe region when inlined to %s",
+                  fileName.c_str(), srcPosition.LineNum(), newStmt.GetFuncName().c_str(), func->GetName().c_str());
+          } else {
+            FATAL(kLncFatal,
+                  "%s:%d error: nullable pointer assignment of nonnull pointer in safe region when inlined to %s",
+                  fileName.c_str(), srcPosition.LineNum(), func->GetName().c_str());
+          }
+        } else {
+          if (stmt.GetOp() == OP_assertnonnull) {
+            FATAL(kLncFatal, "%s:%d error: Dereference of null pointer when inlined to %s",
+                  fileName.c_str(), srcPosition.LineNum(), func->GetName().c_str());
+          } else if (stmt.GetOp() == OP_returnassertnonnull) {
+            FATAL(kLncFatal, "%s:%d error: %s return nonnull but got null pointer when inlined to %s",
+                  fileName.c_str(), srcPosition.LineNum(), newStmt.GetFuncName().c_str(), func->GetName().c_str());
+          } else {
+            FATAL(kLncFatal, "%s:%d error: null assignment of nonnull pointer when inlined to %s",
+                  fileName.c_str(), srcPosition.LineNum(), func->GetName().c_str());
+          }
+        }
+      }
+      break;
+    }
+    case OP_callassertnonnull: {
+      auto &callStmt = static_cast<const CallAssertNonnullMeStmt &>(stmt);
+      GStrIdx curFuncNameIdx = func->GetMirFunc()->GetNameStrIdx();
+      GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(callStmt.GetStmtFuncName().c_str());
+      if (curFuncNameIdx == stmtFuncNameIdx) {
+        if (isNullablePtr) {
+          FATAL(kLncFatal, "%s:%d error: nullable pointer passed to %s that requires a nonnull pointer "\
+                "for %s argument in safe region", fileName.c_str(), srcPosition.LineNum(),
+                callStmt.GetFuncName().c_str(), GetNthStr(callStmt.GetParamIndex()).c_str());
+        } else {
+          FATAL(kLncFatal, "%s:%d error: NULL passed to %s that requires a nonnull pointer for %s argument",
+                fileName.c_str(), srcPosition.LineNum(), callStmt.GetFuncName().c_str(),
+                GetNthStr(callStmt.GetParamIndex()).c_str());
+        }
+      } else {
+        if (isNullablePtr) {
+          FATAL(kLncFatal, "%s:%d error: nullable pointer passed to %s that requires a nonnull pointer "\
+                "for %s argument in safe region when inlined to %s", fileName.c_str(), srcPosition.LineNum(),
+                callStmt.GetFuncName().c_str(), GetNthStr(callStmt.GetParamIndex()).c_str(), func->GetName().c_str());
+        } else {
+          FATAL(kLncFatal, "%s:%d error: NULL passed to %s that requires a nonnull pointer for %s argument "\
+                "when inlined to %s", fileName.c_str(), srcPosition.LineNum(), callStmt.GetFuncName().c_str(),
+                GetNthStr(callStmt.GetParamIndex()).c_str(), func->GetName().c_str());
+        }
+      }
+      break;
+    }
+    case OP_returnassertle:
+    case OP_assignassertle:
+    case OP_assertlt:
+    case OP_assertge: {
+      auto &newStmt = static_cast<const AssertBoundaryMeStmt &>(stmt);
+      GStrIdx curFuncNameIdx = func->GetMirFunc()->GetNameStrIdx();
+      GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(newStmt.GetFuncName().c_str());
+      if (curFuncNameIdx == stmtFuncNameIdx) {
+        if (stmt.GetOp() == OP_assertlt) {
+          FATAL(kLncFatal, "%s:%d error: the pointer >= the upper bounds when accessing the memory",
+                fileName.c_str(), srcPosition.LineNum());
+        } else if (stmt.GetOp() == OP_assertge) {
+          FATAL(kLncFatal, "%s:%d error: the pointer < the lower bounds when accessing the memory",
+                fileName.c_str(), srcPosition.LineNum());
+        } else if (stmt.GetOp() == OP_assignassertle) {
+          FATAL(kLncFatal, "%s:%d error: l-value boundary should not be larger than r-value boundary",
+                fileName.c_str(), srcPosition.LineNum());
+        } else {
+          FATAL(kLncFatal, "%s:%d error: return value's bounds does not match the function declaration for %s",
+                fileName.c_str(), srcPosition.LineNum(), newStmt.GetFuncName().c_str());
+        }
+      } else {
+        if (stmt.GetOp() == OP_assertlt) {
+          FATAL(kLncFatal, "%s:%d error: the pointer >= the upper bounds when accessing the memory and inlined to %s",
+                fileName.c_str(), srcPosition.LineNum(), func->GetName().c_str());
+        } else if (stmt.GetOp() == OP_assertge) {
+          FATAL(kLncFatal, "%s:%d error: the pointer < the lower bounds when accessing the memory and inlined to %s",
+                fileName.c_str(), srcPosition.LineNum(), func->GetName().c_str());
+        } else if (stmt.GetOp() == OP_assignassertle) {
+          FATAL(kLncFatal,
+                "%s:%d error: l-value boundary should not be larger than r-value boundary when inlined to %s",
+                fileName.c_str(), srcPosition.LineNum(), func->GetName().c_str());
+        } else {
+          FATAL(kLncFatal,
+                "%s:%d error: return value's bounds does not match the function declaration for %s when inlined to %s",
+                fileName.c_str(), srcPosition.LineNum(), newStmt.GetFuncName().c_str(), func->GetName().c_str());
+        }
+      }
+      break;
+    }
+    case OP_callassertle: {
+      auto &callStmt = static_cast<const CallAssertBoundaryMeStmt&>(stmt);
+      GStrIdx curFuncNameIdx = func->GetMirFunc()->GetNameStrIdx();
+      GStrIdx stmtFuncNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(callStmt.GetStmtFuncName().c_str());
+      if (curFuncNameIdx == stmtFuncNameIdx) {
+        FATAL(kLncFatal,
+              "%s:%d error: the pointer's bounds does not match the function %s declaration for the %s argument",
+              func->GetMIRModule().GetFileNameFromFileNum(srcPosition.FileNum()).c_str(), srcPosition.LineNum(),
+              callStmt.GetFuncName().c_str(), GetNthStr(callStmt.GetParamIndex()).c_str());
+      } else {
+        FATAL(kLncFatal, "%s:%d error: the pointer's bounds does not match the function %s declaration "\
+              "for the %s argument when inlined to %s", fileName.c_str(), srcPosition.LineNum(),
+              callStmt.GetFuncName().c_str(), GetNthStr(callStmt.GetParamIndex()).c_str(), func->GetName().c_str());
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "can not be here");
+  }
+  return false;
+}
+
+bool ValueRangePropagation::DealWithAssertNonnull(BB &bb, const MeStmt &meStmt) {
+  auto *opnd = static_cast<const UnaryMeStmt&>(meStmt).GetOpnd();
+  auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, *opnd);
+  if (valueRange == nullptr) {
+    // If the cfg is changed and dom is not update, need find the valuerange in pred bbs
+    // when pred bbs are goto or fallthru. The cfg changed like this :
+    // pred0   pred1             pred0  pred1
+    //     \   /                   |      |
+    //     condgoto     ---->      |      |
+    //     /  \                    |      |
+    //    bb   succ                bb     succ
+    if (bb.GetPred().size() == 1) {
+      auto *pred = bb.GetPred(0);
+      while (IsGotoOrFallthruBB(*pred) && pred->GetPred().size() == 1 && IsGotoOrFallthruBB(*pred->GetPred(0))) {
+        pred = pred->GetPred(0);
+      }
+      auto *predValueRange = FindValueRangeAndInitNumOfRecursion(*pred, *opnd);
+      if (predValueRange != nullptr && predValueRange->IsNotEqualZero()) {
+        return true;
+      }
+    }
+    safetyCheckNonnull->HandleAssertNonnull(meStmt, valueRange);
+    (void)Insert2Caches(bb.GetBBId(), opnd->GetExprID(),
+                        std::make_unique<ValueRange>(Bound(nullptr, 0, opnd->GetPrimType()), kNotEqual));
+    return false;
+  }
+  safetyCheckNonnull->HandleAssertNonnull(meStmt, valueRange);
+  auto newValueRange = ZeroIsInRange(*valueRange);
+  if (newValueRange != nullptr) {
+    (void)Insert2Caches(bb.GetBBId(), opnd->GetExprID(), std::move(newValueRange));
+  }
+  return valueRange->IsNotEqualZero() ? true : false;
+}
+
+// When the valuerange of expr is constant, replace it with constMeExpr.
+void ValueRangePropagation::ReplaceOpndWithConstMeExpr(const BB &bb, MeStmt &stmt) {
+  std::map<MeExpr*, std::pair<int64, PrimType>> expr2ConstantValue;
+  for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+    CollectMeExpr(bb, stmt, *stmt.GetOpnd(i), expr2ConstantValue);
+  }
+  if (expr2ConstantValue.empty()) {
+    return;
+  }
+  for (auto it = expr2ConstantValue.begin(); it != expr2ConstantValue.end(); ++it) {
+    auto *newConstExpr = irMap.CreateIntConstMeExpr(it->second.first, it->second.second);
+    (void)irMap.ReplaceMeExprStmt(stmt, *it->first, *newConstExpr);
+  }
+  irMap.UpdateIncDecAttr(stmt);
+}
+
+// When the valuerange of expr is constant, collect it and do replace later.
+void ValueRangePropagation::CollectMeExpr(
+    const BB &bb, MeStmt &stmt, MeExpr &meExpr, std::map<MeExpr*, std::pair<int64, PrimType>> &expr2ConstantValue) {
+  if (meExpr.GetMeOp() == kMeOpConst) {
+    return;
+  }
+  auto *valueRangeOfOperand = FindValueRangeAndInitNumOfRecursion(bb, meExpr);
+  if (valueRangeOfOperand != nullptr && valueRangeOfOperand->IsConstant() &&
+      valueRangeOfOperand->GetRangeType() != kNotEqual && stmt.GetOp() != OP_asm) {
+    auto rangeType = valueRangeOfOperand->GetRangeType();
+    int64 value = (rangeType == kEqual) ? valueRangeOfOperand->GetBound().GetConstant() :
+        valueRangeOfOperand->GetLower().GetConstant();
+    PrimType pType = (rangeType == kEqual) ? valueRangeOfOperand->GetBound().GetPrimType() :
+        valueRangeOfOperand->GetLower().GetPrimType();
+    expr2ConstantValue[&meExpr] = std::make_pair(value, pType);
+    return;
+  }
+  for (uint8 i = 0; i < meExpr.GetNumOpnds(); ++i) {
+    CollectMeExpr(bb, stmt, *(meExpr.GetOpnd(i)), expr2ConstantValue);
+  }
+}
+
+// Create VR for bitSize like:
+// bitsSize : 12
+// =>
+// vr: (0, 0xfff)
+void ValueRangePropagation::CreateVRWithBitsSize(const BB &bb, const OpMeExpr &opMeExpr) {
+  auto bitsSize = opMeExpr.GetBitsSize();
+  if (bitsSize < 64) {
+    auto pTypeOfOpMeExpr = opMeExpr.GetPrimType();
+    uint64 maxNumber = (1ULL << bitsSize) - 1;
+    (void)Insert2Caches(bb.GetBBId(), opMeExpr.GetExprID(), std::make_unique<ValueRange>(
+        Bound(nullptr, 0, pTypeOfOpMeExpr),
+        Bound(maxNumber, pTypeOfOpMeExpr), kLowerAndUpper));
+  }
+}
+
+void ValueRangePropagation::DealWithOperand(const BB &bb, MeStmt &stmt, MeExpr &meExpr) {
+  switch (meExpr.GetMeOp()) {
+    case kMeOpConst: {
+      if (static_cast<ConstMeExpr&>(meExpr).GetConstVal()->GetKind() == kConstInt) {
+        (void)Insert2Caches(bb.GetBBId(), meExpr.GetExprID(), std::make_unique<ValueRange>(
+            Bound(nullptr, static_cast<ConstMeExpr&>(meExpr).GetExtIntValue(), meExpr.GetPrimType()), kEqual));
+      }
+      break;
+    }
+    case kMeOpIvar: {
+      auto &ivarMeExpr = static_cast<IvarMeExpr&>(meExpr);
+      // prop value range of base
+      auto *base = ivarMeExpr.GetBase();
+      auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, *base);
+      if (valueRange == nullptr) {
+        (void)Insert2Caches(bb.GetBBId(), base->GetExprID(), CreateValueRangeOfNotEqualZero(base->GetPrimType()));
+      } else {
+        auto newValueRange = ZeroIsInRange(*valueRange);
+        if (newValueRange != nullptr) {
+          (void)Insert2Caches(bb.GetBBId(), base->GetExprID(), std::move(newValueRange));
+        }
+      }
+      // prop value range of field
+      auto filedID = static_cast<IvarMeExpr&>(meExpr).GetFieldID();
+      auto *ptrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr.GetTyIdx()));
+      if (ptrType->GetPointedType()->IsStructType() &&
+          static_cast<MIRStructType*>(ptrType->GetPointedType())->GetFieldAttrs(filedID).GetAttr(FLDATTR_nonnull)) {
+        (void)Insert2Caches(bb.GetBBId(), meExpr.GetExprID(), CreateValueRangeOfNotEqualZero(meExpr.GetPrimType()));
+      }
+      break;
+    }
+    case kMeOpVar: {
+      auto &varMeExpr = static_cast<VarMeExpr&>(meExpr);
+      // get nonnull attr from symbol or fieldPair
+      if (varMeExpr.GetOst()->GetMIRSymbol()->GetAttr(ATTR_nonnull)) {
+        (void)Insert2Caches(bb.GetBBId(), meExpr.GetExprID(), CreateValueRangeOfNotEqualZero(meExpr.GetPrimType()));
+      } else if (varMeExpr.GetFieldID() != 0) {
+        auto filedID = varMeExpr.GetFieldID();
+        auto *ty = varMeExpr.GetOst()->GetMIRSymbol()->GetType();
+        if (ty->IsStructType() && static_cast<MIRStructType*>(ty)->GetFieldAttrs(filedID).GetAttr(FLDATTR_nonnull)) {
+          (void)Insert2Caches(bb.GetBBId(), meExpr.GetExprID(), CreateValueRangeOfNotEqualZero(meExpr.GetPrimType()));
+        }
+      }
+      break;
+    }
+    case kMeOpOp: {
+      auto *vrOfOpMeExpr = FindValueRangeAndInitNumOfRecursion(bb, meExpr);
+      if (vrOfOpMeExpr != nullptr) {
+        break;
+      }
+      auto &opMeExpr = static_cast<OpMeExpr&>(meExpr);
+      switch (opMeExpr.GetOp()) {
+        case OP_select: {
+          return;
+        }
+        case OP_cvt: {
+          if (DealWithCVT(bb, stmt, static_cast<OpMeExpr&>(meExpr))) {
+            return;
+          }
+          break;
+        }
+        case OP_zext: {
+          // zext <unsigned-int-type> <bsize> (<opnd>)
+          auto *opnd = opMeExpr.GetOpnd(0);
+          auto pTypeOpnd = opnd->GetPrimType();
+          auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, *opnd);
+          if (valueRange != nullptr && valueRange->GetRangeType() != kNotEqual &&
+              (IsPrimitiveUnsigned(pTypeOpnd) || valueRange->IsGreaterThanOrEqualToZero())) {
+            auto bSize = opMeExpr.GetBitsSize();
+            if (bSize < 64) {
+              uint64 maxNumber = (1ULL << bSize) - 1;
+              // Judge whether the truncated range is the same as the previous range.
+              if (valueRange->IsEqualAfterCVT(valueRange->GetLower().GetPrimType(), pTypeOpnd) &&
+                  valueRange->GetUpper().IsLessThanOrEqualTo(Bound(maxNumber, PTY_u64), PTY_u64)) {
+                (void) Insert2Caches(bb.GetBBId(), opMeExpr.GetExprID(), CopyValueRange(*valueRange));
+                break;
+              }
+            }
+          }
+        }
+        [[clang::fallthrough]];
+        case OP_extractbits: {
+          // extractbits <int-type> <boffset> <bsize> (<opnd>)
+          // Deal with the case like :
+          // zext u64 12 u32 (<opnd>) or extractbits u64 13 12 (<opnd>):
+          // vr: (0, 0xfff)
+          if (opMeExpr.GetOp() == OP_zext ||
+              (opMeExpr.GetOp() == OP_extractbits && IsPrimitiveUnsigned(opMeExpr.GetPrimType()))) {
+            CreateVRWithBitsSize(bb, opMeExpr);
+          }
+          break;
+        }
+        case OP_iaddrof: {
+          auto *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(opMeExpr.GetTyIdx());
+          CHECK_FATAL(mirType->IsMIRPtrType(), "must be pointer type");
+          auto *pointerType = static_cast<MIRPtrType*>(mirType);
+          auto *opnd = opMeExpr.GetOpnd(0);
+          auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, *opnd);
+          if (pointerType->GetPointedType()->GetBitOffsetFromBaseAddr(opMeExpr.GetFieldID()) != 0 ||
+              (valueRange != nullptr && valueRange->IsNotEqualZero())) {
+            (void)Insert2Caches(bb.GetBBId(), opMeExpr.GetExprID(),
+                                CreateValueRangeOfNotEqualZero(meExpr.GetPrimType()));
+          }
+          break;
+        }
+        case OP_neg: {
+          DealWithNeg(bb, opMeExpr);
+          break;
+        }
+        case OP_add:
+        case OP_sub: {
+          (void)Insert2Caches(bb.GetBBId(), opMeExpr.GetExprID(), DealWithAddOrSub(bb, opMeExpr));
+          break;
+        }
+        default:
+          break;
+      }
+      break;
+    }
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpAddroflabel: {
+      auto *valueRangeOfAddrof = FindValueRangeAndInitNumOfRecursion(bb, meExpr);
+      if (valueRangeOfAddrof == nullptr) {
+        (void)Insert2Caches(bb.GetBBId(), meExpr.GetExprID(), CreateValueRangeOfNotEqualZero(meExpr.GetPrimType()));
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  for (uint8 i = 0; i < meExpr.GetNumOpnds(); ++i) {
+    DealWithOperand(bb, stmt, *(meExpr.GetOpnd(i)));
+  }
+}
+
+void ValueRangePropagation::DealWithNeg(const BB &bb, const OpMeExpr &opMeExpr) {
+  CHECK_FATAL(opMeExpr.GetNumOpnds() == 1, "must have one opnd");
+  auto *opnd = opMeExpr.GetOpnd(0);
+  uint32 numberOfRecursions = 0;
+  std::unordered_set<int32> foundExprs;
+  auto res = NegValueRange(bb, *opnd, numberOfRecursions, foundExprs);
+  (void)Insert2Caches(bb.GetBBId(), opMeExpr.GetExprID(), std::move(res));
+}
+
+// If the value of opnd of cvt would not overflow or underflow after convert, delete the cvt.
+bool ValueRangePropagation::DealWithCVT(const BB &bb, MeStmt &stmt, OpMeExpr &opMeExpr) {
+  CHECK_FATAL(opMeExpr.GetNumOpnds() == 1, "must have one opnd");
+  auto toType = opMeExpr.GetPrimType();
+  auto fromType = opMeExpr.GetOpndType();
+  auto *opnd = opMeExpr.GetOpnd(0);
+  if (opnd->GetOp() == OP_add || opnd->GetOp() == OP_sub) {
+    auto *addOrSubExpr = static_cast<OpMeExpr*>(opnd);
+    auto *opnd0 = addOrSubExpr->GetOpnd(0);
+    auto *opnd1 = addOrSubExpr->GetOpnd(1);
+    if (opnd0->GetMeOp() == kMeOpConst || opnd1->GetMeOp() == kMeOpConst) {
+      // If the op of opnd is OP_add or OP_sub and the vr before and after cvt is the same, then fold cvt:
+      // rhs = OP cvt i64 i32 mx4
+      //   opnd[0] = OP add i32 kPtyInvalid mx3
+      //     opnd[0] = REGINDX:7 %7 mx1
+      //     opnd[1] = CONST 1 mx2
+      // =>
+      // rhs = OP add i64 kPtyInvalid mx7
+      //     opnd[0] = cvt i64 i32 mx6
+      //       opnd[0] = REGINDX:7 %7 mx1
+      //     opnd[1] = cvt i64 i32 mx5
+      //       opnd[1] = CONST 1 mx2
+      auto valueRange = DealWithAddOrSub(bb, *addOrSubExpr);
+      if (valueRange != nullptr && valueRange->IsEqualAfterCVT(fromType, toType)) {
+        auto *cvtOfOpnd0 = irMap.CreateMeExprTypeCvt(toType, fromType, *opnd0);
+        auto *cvtOfOpnd1 = irMap.CreateMeExprTypeCvt(toType, fromType, *opnd1);
+        auto *newOpMeExpr = irMap.CreateMeExprBinary(opnd->GetOp(), toType, *cvtOfOpnd0, *cvtOfOpnd1);
+        (void)irMap.ReplaceMeExprStmt(stmt, opMeExpr, *newOpMeExpr);
+        return true;
+      }
+    }
+  }
+
+  if ((fromType == PTY_u1 || fromType == PTY_u8 || fromType == PTY_u16 || fromType == PTY_u32 || fromType == PTY_a32 ||
+      ((fromType == PTY_ref || fromType == PTY_ptr) && GetPrimTypeSize(fromType) == 4)) &&
+      GetPrimTypeBitSize(toType) > GetPrimTypeBitSize(fromType)) {
+    auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, opMeExpr);
+    if (valueRange != nullptr) {
+      return false;
+    }
+    (void)Insert2Caches(bb.GetBBId(), opMeExpr.GetExprID(), std::make_unique<ValueRange>(
+        Bound(nullptr, 0, fromType), Bound(GetMaxNumber(fromType), fromType), kLowerAndUpper));
+  }
+  return false;
+}
+
+// When unreachable bb has trystmt or endtry attribute, need update try and endtry bbs.
+void ValueRangePropagation::UpdateTryAttribute(BB &bb) {
+  // update try end bb
+  if (bb.GetAttributes(kBBAttrIsTryEnd) &&
+      (bb.GetMeStmts().empty() || (bb.GetMeStmts().front().GetOp() != OP_try))) {
+    auto *startTryBB = func.GetCfg()->GetTryBBFromEndTryBB(&bb);
+    auto *newEndTry = func.GetCfg()->GetBBFromID(bb.GetBBId() - 1);
+    CHECK_NULL_FATAL(newEndTry);
+    CHECK_FATAL(!newEndTry->GetAttributes(kBBAttrIsTryEnd), "must not be try end");
+    if (newEndTry->GetAttributes(kBBAttrIsTry) && !newEndTry->GetAttributes(kBBAttrIsTryEnd)) {
+      newEndTry->SetAttributes(kBBAttrIsTryEnd);
+      func.GetCfg()->SetBBTryBBMap(newEndTry, startTryBB);
+    }
+  }
+  // update start try bb
+  if (!bb.GetMeStmts().empty() && bb.GetMeStmts().front().GetOp() == OP_try &&
+      !bb.GetAttributes(kBBAttrIsTryEnd)) {
+    for (auto &pair : func.GetCfg()->GetEndTryBB2TryBB()) {
+      if (pair.second == &bb) {
+        auto *newStartTry = func.GetCfg()->GetBBFromID(bb.GetBBId() + 1);
+        CHECK_NULL_FATAL(newStartTry);
+        CHECK_FATAL(newStartTry->GetAttributes(kBBAttrIsTry), "must be try");
+        newStartTry->AddMeStmtFirst(&bb.GetMeStmts().front());
+        func.GetCfg()->SetBBTryBBMap(pair.first, newStartTry);
+        break;
+      }
+    }
+  }
+}
+
+// Insert the ost of phi opnds to their def bbs.
+void ValueRangePropagation::InsertOstOfPhi2Cands(
+    BB &bb, size_t i, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+    std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr, bool setPhiIsDead) {
+  for (auto &it : bb.GetMePhiList()) {
+    if (setPhiIsDead) {
+      it.second->SetIsLive(false);
+    }
+    auto *opnd = it.second->GetOpnd(i);
+    MeStmt *stmt = nullptr;
+    auto *defBB = opnd->GetDefByBBMeStmt(*func.GetCfg(), stmt);
+    // At the time of optimizing redundant branches, when the all preds of condgoto BB can jump directly to
+    // the successors of condgoto BB and the conditional expr is only used for conditional stmt, after opt,
+    // the ssa of expr not need to be updated, otherwise the ssa of epr still needs to be updated.
+    if (updateSSAExceptTheScalarExpr != nullptr && it.first == updateSSAExceptTheScalarExpr->GetOstIdx()) {
+      // when do opt
+      ssaupdateCandsForCondExpr[it.first].insert(defBB);
+    } else {
+      MeSSAUpdate::InsertOstToSSACands(it.first, *defBB, &cands);
+      needUpdateSSA = true;
+    }
+  }
+}
+
+// Deal with the cfg changed like this:
+//  pred                  pred
+//    |                     |
+//    bb       -->          |   bb
+//   /  \                   |  /  \
+// true false              true   false
+void ValueRangePropagation::PrepareForSSAUpdateWhenPredBBIsRemoved(
+    const BB &pred, BB &bb, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+    std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr) {
+  int index = bb.GetPredIndex(pred);
+  CHECK_FATAL(index != -1, "pred is not in preds of bb");
+  InsertOstOfPhi2Cands(bb, static_cast<size_t>(index), updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+  auto updateSSAExceptTheOstIdx = updateSSAExceptTheScalarExpr == nullptr ? OStIdx(0) :
+      updateSSAExceptTheScalarExpr->GetOstIdx();
+  MeSSAUpdate::InsertDefPointsOfBBToSSACands(bb, cands, updateSSAExceptTheOstIdx);
+}
+
+void ValueRangePropagation::DeleteUnreachableBBs() {
+  if (unreachableBBs.empty()) {
+    return;
+  }
+  isCFGChange = true;
+  for (BB *bb : unreachableBBs) {
+    auto succs = bb->GetSucc();
+    bb->RemoveAllPred();
+    bb->RemoveAllSucc();
+    for (auto &succ : succs) {
+      std::map<OStIdx, std::set<BB*>> ssaupdateCandsForCondExpr;
+      DeleteThePhiNodeWhichOnlyHasOneOpnd(*succ, nullptr, ssaupdateCandsForCondExpr);
+    }
+    UpdateTryAttribute(*bb);
+    func.GetCfg()->NullifyBBByID(bb->GetBBId());
+    // remove the bb from common_exit_bb's pred list if it is there
+    auto &predsOfCommonExit = func.GetCfg()->GetCommonExitBB()->GetPred();
+    auto it = std::find(predsOfCommonExit.begin(), predsOfCommonExit.end(), bb);
+    if (it != predsOfCommonExit.end()) {
+      func.GetCfg()->GetCommonExitBB()->RemoveExit(*bb);
+    }
+  }
+}
+
+bool IsEqualPrimType(PrimType lhsType, PrimType rhsType) {
+  if (lhsType == rhsType) {
+    return true;
+  }
+  if (IsUnsignedInteger(lhsType) == IsUnsignedInteger(rhsType) &&
+      GetPrimTypeSize(lhsType) == GetPrimTypeSize(rhsType)) {
+    return true;
+  }
+  return false;
+}
+
+bool IsNeededPrimType(PrimType prim) {
+  return (prim == PTY_i8 || prim == PTY_i16 || prim == PTY_i32 || prim == PTY_i64 || prim == PTY_u8 ||
+          prim == PTY_u16 || prim == PTY_u32 || prim == PTY_a32 || prim == PTY_ref || prim == PTY_ptr ||
+          prim == PTY_u64 || prim == PTY_a64 || prim == PTY_u1);
+}
+
+int64 GetMinNumber(PrimType primType) {
+  switch (primType) {
+    case PTY_i8:
+      return std::numeric_limits<int8_t>::min();
+    case PTY_i16:
+      return std::numeric_limits<int16_t>::min();
+    case PTY_i32:
+      return std::numeric_limits<int32_t>::min();
+    case PTY_i64:
+      return std::numeric_limits<int64_t>::min();
+    case PTY_u8:
+      return std::numeric_limits<uint8_t>::min();
+    case PTY_u16:
+      return std::numeric_limits<uint16_t>::min();
+    case PTY_u32:
+    case PTY_a32:
+      return std::numeric_limits<uint32_t>::min();
+    case PTY_ref:
+    case PTY_ptr:
+      if (GetPrimTypeSize(primType) == kFourByte) { // 32 bit
+        return std::numeric_limits<uint32_t>::min();
+      } else { // 64 bit
+        CHECK_FATAL(GetPrimTypeSize(primType) == kEightByte, "must be 64 bit");
+        return std::numeric_limits<uint64_t>::min();
+      }
+    case PTY_u64:
+    case PTY_a64:
+      return std::numeric_limits<uint64_t>::min();
+    case PTY_u1:
+      return 0;
+    default:
+      CHECK_FATAL(false, "must not be here");
+  }
+}
+
+int64 GetMaxNumber(PrimType primType) {
+  switch (primType) {
+    case PTY_i8:
+      return std::numeric_limits<int8_t>::max();
+    case PTY_i16:
+      return std::numeric_limits<int16_t>::max();
+    case PTY_i32:
+      return std::numeric_limits<int32_t>::max();
+    case PTY_i64:
+      return std::numeric_limits<int64_t>::max();
+    case PTY_u8:
+      return std::numeric_limits<uint8_t>::max();
+    case PTY_u16:
+      return std::numeric_limits<uint16_t>::max();
+    case PTY_u32:
+    case PTY_a32:
+      return std::numeric_limits<uint32_t>::max();
+    case PTY_ref:
+    case PTY_ptr:
+      if (GetPrimTypeSize(primType) == kFourByte) { // 32 bit
+        return std::numeric_limits<uint32_t>::max();
+      } else { // 64 bit
+        CHECK_FATAL(GetPrimTypeSize(primType) == kEightByte, "must be 64 bit");
+        return std::numeric_limits<uint64_t>::max();
+      }
+    case PTY_u64:
+    case PTY_a64:
+      return std::numeric_limits<uint64_t>::max();
+    case PTY_u1:
+      return 1;
+    default:
+      CHECK_FATAL(false, "must not be here");
+  }
+}
+
+// If the result of operator add or sub is overflow or underflow, return false.
+bool ValueRangePropagation::AddOrSubWithConstant(
+    PrimType primType, Opcode op, int64 lhsConstant, int64 rhsConstant, int64 &res) const {
+  if (ConstantFold::IntegerOpIsOverflow(op, primType, lhsConstant, rhsConstant)) {
+    return false;
+  }
+  if (IsPrimTypeUint64(primType)) {
+    res = (op == OP_add) ?
+        (static_cast<uint64>(lhsConstant) + static_cast<uint64>(rhsConstant)) :
+        (static_cast<uint64>(lhsConstant) - static_cast<uint64>(rhsConstant));
+  } else {
+    res = (op == OP_add) ? (lhsConstant + rhsConstant) : (lhsConstant - rhsConstant);
+  }
+  return true;
+}
+
+// Create new bound when old bound add or sub with a constant.
+bool ValueRangePropagation::CreateNewBoundWhenAddOrSub(Opcode op, Bound bound, int64 rhsConstant, Bound &res) {
+  int64 constant = 0;
+  if (AddOrSubWithConstant(bound.GetPrimType(), op, bound.GetConstant(), rhsConstant, constant)) {
+    res = Bound(bound.GetVar(), constant, bound.GetPrimType());
+    return true;
+  }
+  return false;
+}
+
+// Judge whether the value is constant.
+bool ValueRangePropagation::IsConstant(const BB &bb, MeExpr &expr, int64 &value, bool canNotBeNotEqual) {
+  if (expr.GetMeOp() == kMeOpConst && static_cast<ConstMeExpr&>(expr).GetConstVal()->GetKind() == kConstInt) {
+    value = static_cast<ConstMeExpr&>(expr).GetExtIntValue();
+    return true;
+  }
+  auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, expr);
+  if (valueRange == nullptr) {
+    if (expr.GetMeOp() == kMeOpVar && static_cast<VarMeExpr&>(expr).GetDefBy() == kDefByStmt &&
+        static_cast<VarMeExpr&>(expr).GetDefStmt()->GetRHS()->GetMeOp() == kMeOpConst &&
+        static_cast<ConstMeExpr*>(static_cast<VarMeExpr&>(expr).GetDefStmt()->GetRHS())->GetConstVal()->GetKind() ==
+            kConstInt) {
+      value = static_cast<ConstMeExpr*>(static_cast<VarMeExpr&>(expr).GetDefStmt()->GetRHS())->GetExtIntValue();
+      (void)Insert2Caches(static_cast<VarMeExpr&>(expr).GetDefStmt()->GetBB()->GetBBId(), expr.GetExprID(),
+                          std::make_unique<ValueRange>(Bound(value, expr.GetPrimType()), kEqual));
+      return true;
+    }
+    return false;
+  }
+  if (valueRange->IsConstant()) {
+    if (canNotBeNotEqual && valueRange->GetRangeType() == kNotEqual) {
+      return false;
+    }
+    value = valueRange->GetBound().GetConstant();
+    return true;
+  }
+  return false;
+}
+
+// Create new valueRange when old valueRange add or sub with a valuerange.
+std::unique_ptr<ValueRange> ValueRangePropagation::AddOrSubWithValueRange(
+    Opcode op, ValueRange &valueRangeLeft, ValueRange &valueRangeRight) {
+  if (valueRangeLeft.GetRangeType() == kNotEqual || valueRangeRight.GetRangeType() == kNotEqual ||
+      valueRangeLeft.GetRangeType() == kOnlyHasLowerBound || valueRangeRight.GetRangeType() == kOnlyHasLowerBound ||
+      valueRangeLeft.GetRangeType() == kOnlyHasUpperBound || valueRangeRight.GetRangeType() == kOnlyHasUpperBound) {
+    return nullptr;
+  }
+  // Deal with the case like :
+  // x: vr(var: expr, constant: 4, kEqual)
+  // y: vr(var: nullptr, constant: 2, kEqual)
+  // x + y => vr(expr, 6, kEqual)
+  if (valueRangeLeft.GetRangeType() == kEqual && valueRangeRight.GetRangeType() == kEqual) {
+    auto *varOfLHS = valueRangeLeft.GetBound().GetVar();
+    auto *varOfRHS = valueRangeRight.GetBound().GetVar();
+    if ((varOfLHS == nullptr && varOfRHS != nullptr) || (varOfLHS != nullptr && varOfRHS == nullptr)) {
+      auto *resVar = (varOfLHS == nullptr) ? varOfRHS : varOfLHS;
+      int64 rhsConst = valueRangeRight.GetBound().GetConstant();
+      int64 lhsConst = valueRangeLeft.GetBound().GetConstant();
+      int64 res = 0;
+      if (AddOrSubWithConstant(valueRangeLeft.GetLower().GetPrimType(), op, rhsConst, lhsConst, res)) {
+        return std::make_unique<ValueRange>(Bound(resVar, res, valueRangeLeft.GetLower().GetPrimType()), kEqual);
+      }
+    }
+  }
+  if (valueRangeLeft.GetLower().GetVar() != valueRangeRight.GetLower().GetVar() ||
+      valueRangeLeft.GetUpper().GetVar() != valueRangeRight.GetUpper().GetVar()) {
+    return nullptr;
+  }
+  int64 rhsLowerConst = valueRangeRight.GetLower().GetConstant();
+  int64 rhsUpperConst = valueRangeRight.GetUpper().GetConstant();
+  int64 res = 0;
+  if (!AddOrSubWithConstant(valueRangeLeft.GetLower().GetPrimType(), op,
+                            valueRangeLeft.GetLower().GetConstant(), rhsLowerConst, res)) {
+    return nullptr;
+  }
+  Bound lower = Bound(valueRangeLeft.GetLower().GetVar(), res, valueRangeLeft.GetLower().GetPrimType());
+  res = 0;
+  if (!AddOrSubWithConstant(valueRangeLeft.GetLower().GetPrimType(), op,
+                            valueRangeLeft.GetUpper().GetConstant(), rhsUpperConst, res)) {
+    return nullptr;
+  }
+  Bound upper = Bound(valueRangeLeft.GetUpper().GetVar(), res, valueRangeLeft.GetUpper().GetPrimType());
+  return std::make_unique<ValueRange>(lower, upper, kLowerAndUpper,
+      valueRangeLeft.IsAccurate() || valueRangeRight.IsAccurate());
+}
+
+bool ValueRangePropagation::AddOrSubWithBound(Bound oldBound, Bound &resBound, int64 rhsConstant, Opcode op) {
+  int64 res = 0;
+  if (!AddOrSubWithConstant(oldBound.GetPrimType(), op, oldBound.GetConstant(), rhsConstant, res)) {
+    return false;
+  }
+  resBound = Bound(oldBound.GetVar(), res, oldBound.GetPrimType());
+  return true;
+}
+
+// Create new valueRange when old valueRange add or sub with a constant.
+std::unique_ptr<ValueRange> ValueRangePropagation::AddOrSubWithValueRange(
+    Opcode op, ValueRange &valueRange, int64 rhsConstant) {
+  if (valueRange.GetRangeType() == kLowerAndUpper) {
+    if (valueRange.IsConstantLowerAndUpper() &&
+        valueRange.GetLower().IsGreaterThan(valueRange.GetUpper(), valueRange.GetPrimType())) {
+      return nullptr;
+    }
+    Bound lower;
+    if (!AddOrSubWithBound(valueRange.GetLower(), lower, rhsConstant, op)) {
+      return nullptr;
+    }
+    Bound upper;
+    if (!AddOrSubWithBound(valueRange.GetUpper(), upper, rhsConstant, op)) {
+      return nullptr;
+    }
+    return std::make_unique<ValueRange>(lower, upper, kLowerAndUpper, valueRange.IsAccurate());
+  } else if (valueRange.GetRangeType() == kEqual) {
+    Bound bound;
+    if (!AddOrSubWithBound(valueRange.GetBound(), bound, rhsConstant, op)) {
+      return nullptr;
+    }
+    return std::make_unique<ValueRange>(bound, valueRange.GetRangeType(), valueRange.IsAccurate());
+  } else if (valueRange.GetRangeType() == kOnlyHasLowerBound || valueRange.GetRangeType() == kOnlyHasUpperBound) {
+    Bound bound;
+    if (!AddOrSubWithBound(valueRange.GetBound(), bound, rhsConstant, op)) {
+      return nullptr;
+    }
+    return std::make_unique<ValueRange>(bound, valueRange.GetStride(), valueRange.GetRangeType());
+  }
+  return nullptr;
+}
+
+// deal with the case like var % x, range is [1-x, x-1]
+std::unique_ptr<ValueRange> ValueRangePropagation::RemWithRhsValueRange(
+    const OpMeExpr &opMeExpr, int64 rhsConstant) const {
+  int64 res = 0;
+  int64 upperRes = 0;
+  int64 lowerRes = 0;
+  auto pType = opMeExpr.GetOpnd(1)->GetPrimType();
+  if (pType == PTY_i64 && rhsConstant == GetMinNumber(PTY_i64)) { // var % x, if var is negative unlimited
+    return nullptr;
+  }
+  if (Bound(rhsConstant, pType).IsGreaterThan(Bound(nullptr, 0, pType), pType)) {
+    if (AddOrSubWithConstant(opMeExpr.GetPrimType(), OP_sub, 1, rhsConstant, res)) {
+      lowerRes = res;
+    } else {
+      return nullptr;
+    }
+    if (AddOrSubWithConstant(opMeExpr.GetPrimType(), OP_sub, rhsConstant, 1, res)) {
+      upperRes = res;
+    } else {
+      return nullptr;
+    }
+  } else {
+    if (AddOrSubWithConstant(opMeExpr.GetPrimType(), OP_add, 1, rhsConstant, res)) {
+      lowerRes = res;
+    } else {
+      return nullptr;
+    }
+    if (AddOrSubWithConstant(opMeExpr.GetPrimType(), OP_sub, -rhsConstant, 1, res)) {
+      upperRes = res;
+    } else {
+      return nullptr;
+    }
+  }
+  Bound lower = Bound(nullptr, lowerRes, opMeExpr.GetPrimType());
+  Bound upper = Bound(nullptr, upperRes, opMeExpr.GetPrimType());
+  return std::make_unique<ValueRange>(lower, upper, kLowerAndUpper);
+}
+
+// Create new valueRange when old valueRange rem with a constant.
+std::unique_ptr<ValueRange> ValueRangePropagation::RemWithValueRange(const BB &bb, const OpMeExpr &opMeExpr,
+    int64 rhsConstant) {
+  auto remValueRange = RemWithRhsValueRange(opMeExpr, rhsConstant);
+  if (remValueRange == nullptr) {
+    return nullptr;
+  }
+  auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, *opMeExpr.GetOpnd(0));
+  if (valueRange == nullptr) {
+    return remValueRange;
+  }
+  if (!valueRange->IsConstantLowerAndUpper()) {
+    return remValueRange;
+  } else if (valueRange->GetRangeType() == kEqual) {
+    if (valueRange->GetBound().IsEqualToMin(opMeExpr.GetPrimType())) {
+      return nullptr;
+    }
+    int64 res = Bound::GetRemResult(valueRange->GetBound().GetConstant(), rhsConstant, opMeExpr.GetPrimType());
+    Bound bound = Bound(nullptr, res, valueRange->GetBound().GetPrimType());
+    return std::make_unique<ValueRange>(bound, valueRange->GetRangeType());
+  } else {
+    std::unique_ptr<ValueRange> combineRes = CombineTwoValueRange(*remValueRange, *valueRange);
+    int64 lowerRes = combineRes->GetLower().GetConstant();
+    int64 upperRes = combineRes->GetUpper().GetConstant();
+    if (upperRes <= lowerRes) {
+      return remValueRange;
+    }
+    if (lowerRes > 0 && valueRange->GetUpper().GetConstant() > upperRes) {
+      lowerRes = 0;
+    }
+    Bound lower = Bound(nullptr, lowerRes, opMeExpr.GetPrimType());
+    Bound upper = Bound(nullptr, upperRes, opMeExpr.GetPrimType());
+    return std::make_unique<ValueRange>(lower, upper, kLowerAndUpper);
+  }
+  return nullptr;
+}
+
+// Create valueRange when deal with OP_rem.
+std::unique_ptr<ValueRange> ValueRangePropagation::DealWithRem(
+    const BB &bb, const MeExpr &lhsVar, const OpMeExpr &opMeExpr) {
+  if (!IsNeededPrimType(opMeExpr.GetPrimType())) {
+    return nullptr;
+  }
+  auto *opnd0 = opMeExpr.GetOpnd(0);
+  auto *opnd1 = opMeExpr.GetOpnd(1);
+  int64 lhsConstant = 0;
+  int64 rhsConstant = 0;
+  bool lhsIsConstant = IsConstant(bb, *opnd0, lhsConstant);
+  bool rhsIsConstant = IsConstant(bb, *opnd1, rhsConstant);
+  if (rhsConstant == 0) {
+    return nullptr;
+  }
+  std::unique_ptr<ValueRange> newValueRange;
+  if (lhsIsConstant && rhsIsConstant) {
+    if (Bound(lhsConstant, opMeExpr.GetPrimType()).IsEqualToMin(opMeExpr.GetPrimType())) {
+      return nullptr;
+    }
+    int64 res = Bound::GetRemResult(lhsConstant, rhsConstant, opMeExpr.GetPrimType());
+    newValueRange = std::make_unique<ValueRange>(Bound(res, opMeExpr.GetPrimType()), kEqual);
+  } else if (rhsIsConstant) {
+    newValueRange = RemWithValueRange(bb, opMeExpr, rhsConstant);
+  }
+  if (newValueRange != nullptr) {
+    auto *valueRangePtr = newValueRange.get();
+    if (Insert2Caches(bb.GetBBId(), lhsVar.GetExprID(), CopyValueRange(*valueRangePtr))) {
+      (void)Insert2Caches(bb.GetBBId(), opMeExpr.GetExprID(), CopyValueRange(*valueRangePtr));
+      return CopyValueRange(*valueRangePtr);
+    }
+  }
+  return nullptr;
+}
+
+// Create valueRange when deal with OP_add or OP_sub.
+std::unique_ptr<ValueRange> ValueRangePropagation::DealWithAddOrSub(const BB &bb, const OpMeExpr &opMeExpr) {
+  auto *opnd0 = opMeExpr.GetOpnd(0);
+  auto *opnd1 = opMeExpr.GetOpnd(1);
+  int64 lhsConstant = 0;
+  int64 rhsConstant = 0;
+  bool lhsIsConstant = IsConstant(bb, *opnd0, lhsConstant);
+  bool rhsIsConstant = IsConstant(bb, *opnd1, rhsConstant);
+  std::unique_ptr<ValueRange> newValueRange;
+  if (lhsIsConstant && rhsIsConstant) {
+    int64 res = 0;
+    if (AddOrSubWithConstant(opMeExpr.GetPrimType(), opMeExpr.GetOp(), lhsConstant, rhsConstant, res)) {
+      newValueRange = std::make_unique<ValueRange>(Bound(res, opMeExpr.GetPrimType()), kEqual);
+    }
+  } else if (rhsIsConstant) {
+    auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, *opnd0);
+    if (valueRange == nullptr) {
+      return nullptr;
+    }
+    newValueRange = AddOrSubWithValueRange(opMeExpr.GetOp(), *valueRange, rhsConstant);
+  } else if (lhsIsConstant && opMeExpr.GetOp() == OP_add) {
+    auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, *opnd1);
+    if (valueRange == nullptr) {
+      return nullptr;
+    }
+    newValueRange = AddOrSubWithValueRange(opMeExpr.GetOp(), *valueRange, lhsConstant);
+  }
+  return newValueRange;
+}
+
+// Save array length to caches for eliminate array boundary check.
+void ValueRangePropagation::DealWithArrayLength(const BB &bb, MeExpr &lhs, MeExpr &rhs) {
+  if (rhs.GetMeOp() == kMeOpVar) {
+    auto *valueRangeOfLength = FindValueRangeAndInitNumOfRecursion(bb, rhs);
+    if (valueRangeOfLength == nullptr) {
+      (void)Insert2Caches(bb.GetBBId(), lhs.GetExprID(),
+                          std::make_unique<ValueRange>(Bound(&rhs, rhs.GetPrimType()), kEqual));
+      (void)Insert2Caches(bb.GetBBId(), rhs.GetExprID(),
+                          std::make_unique<ValueRange>(Bound(&rhs, rhs.GetPrimType()), kEqual));
+    } else {
+      (void)Insert2Caches(bb.GetBBId(), lhs.GetExprID(), CopyValueRange(*valueRangeOfLength));
+    }
+  } else {
+    CHECK_FATAL(rhs.GetMeOp() == kMeOpConst, "must be constant");
+  }
+  length2Def[&lhs] = &rhs;
+  lengthSet.insert(&lhs);
+  lengthSet.insert(&rhs);
+}
+
+bool IsPrimTypeUint64(PrimType pType) {
+  if (pType == PTY_u64 || pType == PTY_a64 || ((pType == PTY_ref || pType == PTY_ptr) &&
+      GetPrimTypeSize(pType) == kEightByte)) {
+    return true;
+  }
+  return false;
+}
+
+// Get the real value with primType.
+int64 GetRealValue(int64 value, PrimType primType) {
+  switch (primType) {
+    case PTY_i8:
+      return static_cast<int8>(value);
+    case PTY_i16:
+      return static_cast<int16>(value);
+    case PTY_i32:
+      return static_cast<int32>(value);
+    case PTY_i64:
+      return static_cast<int64>(value);
+    case PTY_u8:
+      return static_cast<uint8>(value);
+    case PTY_u16:
+      return static_cast<uint16>(value);
+    case PTY_u32:
+    case PTY_a32:
+      return static_cast<uint32>(value);
+    case PTY_ref:
+    case PTY_ptr:
+      if (GetPrimTypeSize(primType) == kFourByte) { // 32 bit
+        return static_cast<uint32>(value);
+      } else { // 64 bit
+        CHECK_FATAL(GetPrimTypeSize(primType) == kEightByte, "must be 64 bit");
+        return static_cast<uint64>(value);
+      }
+    case PTY_u64:
+    case PTY_a64:
+      return static_cast<uint64>(value);
+    case PTY_u1:
+      return static_cast<bool>(value);
+    default:
+      CHECK_FATAL(false, "must not be here");
+  }
+}
+
+std::unique_ptr<ValueRange> ValueRangePropagation::CopyValueRange(ValueRange &valueRange, PrimType primType) {
+  if (primType != PTY_begin && (!valueRange.GetLower().IsEqualAfterCVT(valueRange.GetPrimType(), primType) ||
+                                !valueRange.GetUpper().IsEqualAfterCVT(valueRange.GetPrimType(), primType))) {
+    // When the valueRange changes after conversion according to the parameter primType, return nullptr.
+    return nullptr;
+  }
+  switch (valueRange.GetRangeType()) {
+    case kEqual:
+    case kNotEqual:
+      if (primType == PTY_begin) {
+        return std::make_unique<ValueRange>(valueRange.GetBound(), valueRange.GetRangeType(), valueRange.IsAccurate());
+      } else {
+        Bound bound = Bound(valueRange.GetBound().GetVar(), valueRange.GetBound().GetConstant(), primType);
+        return std::make_unique<ValueRange>(bound, valueRange.GetRangeType(), valueRange.IsAccurate());
+      }
+    case kLowerAndUpper:
+    case kSpecialUpperForLoop:
+    case kSpecialLowerForLoop:
+      if (primType == PTY_begin) {
+        return std::make_unique<ValueRange>(valueRange.GetLower(), valueRange.GetUpper(), valueRange.GetRangeType(),
+            valueRange.IsAccurate());
+      } else {
+        Bound lower = Bound(valueRange.GetLower().GetVar(), valueRange.GetLower().GetConstant(), primType);
+        Bound upper = Bound(valueRange.GetUpper().GetVar(), valueRange.GetUpper().GetConstant(), primType);
+        return std::make_unique<ValueRange>(lower, upper, valueRange.GetRangeType(), valueRange.IsAccurate());
+      }
+    case kOnlyHasLowerBound:
+      if (primType == PTY_begin) {
+        return std::make_unique<ValueRange>(valueRange.GetLower(), valueRange.GetStride(), kOnlyHasLowerBound);
+      } else {
+        Bound lower = Bound(valueRange.GetLower().GetVar(), valueRange.GetLower().GetConstant(), primType);
+        return std::make_unique<ValueRange>(lower, valueRange.GetStride(), kOnlyHasLowerBound);
+      }
+
+    case kOnlyHasUpperBound:
+      if (primType == PTY_begin) {
+        return std::make_unique<ValueRange>(valueRange.GetUpper(), valueRange.GetStride(), kOnlyHasUpperBound);
+      } else {
+        Bound upper = Bound(valueRange.GetUpper().GetVar(), valueRange.GetUpper().GetConstant(), primType);
+        return std::make_unique<ValueRange>(upper, kOnlyHasUpperBound, valueRange.IsAccurate());
+      }
+    default:
+      CHECK_FATAL(false, "can not be here");
+      break;
+  }
+}
+
+std::unique_ptr<ValueRange> ValueRangePropagation::DealWithMeOp(const BB &bb, const MeStmt &stmt) {
+  auto *lhs = stmt.GetLHS();
+  auto *rhs = stmt.GetRHS();
+  auto *opMeExpr = static_cast<OpMeExpr*>(rhs);
+  switch (rhs->GetOp()) {
+    case OP_add:
+    case OP_sub: {
+      return DealWithAddOrSub(bb, *opMeExpr);
+    }
+    case OP_gcmallocjarray: {
+      DealWithArrayLength(bb, *lhs, *opMeExpr->GetOpnd(0));
+      break;
+    }
+    case OP_rem: {
+      return DealWithRem(bb, *lhs, *opMeExpr);
+    }
+    default:
+      break;
+  }
+  return nullptr;
+}
+
+// Create new value range when deal with assign.
+void ValueRangePropagation::DealWithAssign(BB &bb, const MeStmt &stmt) {
+  auto *lhs = stmt.GetLHS();
+  auto *rhs = stmt.GetRHS();
+  if (lhs == nullptr || rhs == nullptr) {
+    return;
+  }
+  Insert2PairOfExprs(*lhs, *rhs, bb);
+  Insert2PairOfExprs(*rhs, *lhs, bb);
+  std::unique_ptr<ValueRange> resVR = nullptr;
+  auto *existValueRange = FindValueRangeAndInitNumOfRecursion(bb, *rhs);
+  if (existValueRange != nullptr && existValueRange->GetRangeType() != kOnlyHasLowerBound &&
+      existValueRange->GetRangeType() != kOnlyHasUpperBound) {
+    resVR = CopyValueRange(*existValueRange);
+  } else if (rhs->GetMeOp() == kMeOpOp) {
+    resVR = DealWithMeOp(bb, stmt);
+  } else if (rhs->GetMeOp() == kMeOpConst && static_cast<ConstMeExpr*>(rhs)->GetConstVal()->GetKind() == kConstInt) {
+    resVR = std::make_unique<ValueRange>(
+        Bound(static_cast<ConstMeExpr*>(rhs)->GetExtIntValue(), rhs->GetPrimType()), kEqual);
+  }
+  if (resVR != nullptr) {
+    auto pTypeOfLHS = lhs->GetPrimType();
+    auto pTypeOfRHS = rhs->GetPrimType();
+    auto primTypeOfVR = resVR->GetLower().GetPrimType();
+    // The rhs may be truncated when assigned to lhs,
+    // so it is necessary to judge whether the range before and after is consistent.
+    if (resVR->IsEqualAfterCVT(pTypeOfLHS, pTypeOfRHS) &&
+        resVR->IsEqualAfterCVT(pTypeOfLHS, primTypeOfVR) &&
+        resVR->IsEqualAfterCVT(pTypeOfRHS, primTypeOfVR)) {
+      Insert2Caches(bb.GetBBId(), lhs->GetExprID(), CopyValueRange(*resVR, pTypeOfLHS));
+    } else {
+      Insert2Caches(bb.GetBBId(), lhs->GetExprID(), nullptr);
+    }
+  }
+}
+
+// Analysis the stride of loop induction var, like this pattern:
+// i1 = phi(i0, i2),
+// i2 = i1 + 1,
+// stride is 1.
+bool ValueRangePropagation::CanComputeLoopIndVar(const MeExpr &phiLHS, MeExpr &expr, int64 &constant) {
+  auto *curExpr = &expr;
+  while (true) {
+    if (!curExpr->IsScalar()) {
+      break;
+    }
+    ScalarMeExpr *scalarMeExpr = static_cast<ScalarMeExpr*>(curExpr);
+    if (scalarMeExpr->GetDefBy() != kDefByStmt) {
+      break;
+    }
+    MeStmt *defStmt = scalarMeExpr->GetDefStmt();
+    if (defStmt->GetRHS()->GetOp() != OP_add && defStmt->GetRHS()->GetOp() != OP_sub) {
+      break;
+    }
+    OpMeExpr &opMeExpr = static_cast<OpMeExpr&>(*defStmt->GetRHS());
+    if (opMeExpr.GetOpnd(1)->GetMeOp() == kMeOpConst &&
+        static_cast<ConstMeExpr*>(opMeExpr.GetOpnd(1))->GetConstVal()->GetKind() == kConstInt) {
+      ConstMeExpr *rhsExpr = static_cast<ConstMeExpr*>(opMeExpr.GetOpnd(1));
+      int64 res = 0;
+      auto rhsConst = rhsExpr->GetExtIntValue();
+      if (rhsExpr->GetPrimType() == PTY_u64 && static_cast<uint64>(rhsConst) > GetMaxNumber(PTY_i64)) {
+        return false;
+      }
+      if (AddOrSubWithConstant(opMeExpr.GetPrimType(), defStmt->GetRHS()->GetOp(), constant, rhsConst, res)) {
+        constant = res;
+        curExpr = opMeExpr.GetOpnd(0);
+        if (curExpr == &phiLHS) {
+          return true;
+        }
+        continue;
+      }
+    }
+    break;
+  }
+  return false;
+}
+
+// Create new value range when the loop induction var is monotonic increase.
+std::unique_ptr<ValueRange> ValueRangePropagation::CreateValueRangeForMonotonicIncreaseVar(
+    const LoopDesc &loop, BB &exitBB, const BB &bb, OpMeExpr &opMeExpr, MeExpr &opnd1,
+    Bound &initBound, int64 stride) {
+  BB *inLoopBB = nullptr;
+  BB *outLoopBB = nullptr;
+  if (loop.Has(*exitBB.GetSucc(0))) {
+    inLoopBB = exitBB.GetSucc(0);
+    outLoopBB = exitBB.GetSucc(1);
+    CHECK_FATAL(!loop.Has(*exitBB.GetSucc(1)), "must not in loop");
+  } else {
+    inLoopBB = exitBB.GetSucc(1);
+    outLoopBB = exitBB.GetSucc(0);
+    CHECK_FATAL(!loop.Has(*exitBB.GetSucc(0)), "must not in loop");
+  }
+  int64 rightConstant = 0;
+  if (opMeExpr.GetOp() == OP_lt || opMeExpr.GetOp() == OP_ge ||
+      opMeExpr.GetOp() == OP_ne || opMeExpr.GetOp() == OP_eq) {
+    rightConstant = -stride;
+  }
+  Bound upperBound;
+  int64 constantValue = 0;
+  if (IsConstant(bb, opnd1, constantValue)) {
+    int64 res = 0;
+    if (AddOrSubWithConstant(opnd1.GetPrimType(), OP_add, constantValue, rightConstant, res)) {
+      upperBound = Bound(res, opnd1.GetPrimType());
+    } else {
+      return nullptr;
+    }
+    if (initBound.GetVar() == upperBound.GetVar() && initBound.IsGreaterThan(upperBound, opMeExpr.GetOpndType())) {
+      if (opMeExpr.GetOp() != OP_ne && opMeExpr.GetOp() != OP_eq) {
+        AnalysisUnreachableBBOrEdge(exitBB, *inLoopBB, *outLoopBB);
+      }
+      return nullptr;
+    }
+    if (initBound.GetVar() != nullptr) {
+      return std::make_unique<ValueRange>(initBound, upperBound, kSpecialLowerForLoop);
+    } else {
+      return std::make_unique<ValueRange>(initBound, upperBound, kLowerAndUpper);
+    }
+  } else if (opnd1.GetOp() == OP_add || opnd1.GetOp() == OP_sub) {
+    auto valueRangeOfUpper = DealWithAddOrSub(bb, static_cast<OpMeExpr&>(opnd1));
+    if (valueRangeOfUpper != nullptr) {
+      int64 res = 0;
+      if (AddOrSubWithConstant(opnd1.GetPrimType(), OP_add, valueRangeOfUpper->GetUpper().GetConstant(),
+                               rightConstant, res)) {
+        upperBound = Bound(valueRangeOfUpper->GetUpper().GetVar(), res, opnd1.GetPrimType());
+      }
+      if (initBound.GetVar() == nullptr) {
+        if (valueRangeOfUpper->GetRangeType() == kLowerAndUpper || valueRangeOfUpper->GetRangeType() == kEqual) {
+          if (valueRangeOfUpper->GetUpper().GetVar() == nullptr) {
+            return std::make_unique<ValueRange>(initBound, upperBound, kLowerAndUpper);
+          } else {
+            return std::make_unique<ValueRange>(initBound, upperBound, kSpecialUpperForLoop);
+          }
+        }
+      } else if ((valueRangeOfUpper->GetRangeType() == kLowerAndUpper || valueRangeOfUpper->GetRangeType() == kEqual) &&
+                 valueRangeOfUpper->GetUpper().GetVar() == nullptr) {
+        return std::make_unique<ValueRange>(initBound, upperBound, kSpecialLowerForLoop);
+      }
+    }
+  }
+  if (initBound.GetVar() == nullptr) {
+    return std::make_unique<ValueRange>(
+        initBound, Bound(&opnd1, rightConstant, initBound.GetPrimType()), kSpecialUpperForLoop);
+  }
+  return nullptr;
+}
+
+// Create new value range when the loop induction var is monotonic decrease.
+std::unique_ptr<ValueRange> ValueRangePropagation::CreateValueRangeForMonotonicDecreaseVar(
+    const LoopDesc &loop, BB &exitBB, const BB &bb, OpMeExpr &opMeExpr, MeExpr &opnd1,
+    Bound &initBound, int64 stride) {
+  BB *inLoopBB = nullptr;
+  BB *outLoopBB = nullptr;
+  if (loop.Has(*exitBB.GetSucc(0))) {
+    inLoopBB = exitBB.GetSucc(0);
+    outLoopBB = exitBB.GetSucc(1);
+    CHECK_FATAL(!loop.Has(*exitBB.GetSucc(1)), "must not in loop");
+  } else {
+    inLoopBB = exitBB.GetSucc(1);
+    outLoopBB = exitBB.GetSucc(0);
+    CHECK_FATAL(!loop.Has(*exitBB.GetSucc(0)), "must not in loop");
+  }
+  int64 rightConstant = 0;
+  if (opMeExpr.GetOp() == OP_le || opMeExpr.GetOp() == OP_gt ||
+      opMeExpr.GetOp() == OP_ne || opMeExpr.GetOp() == OP_eq) {
+    rightConstant = -stride;
+  }
+  Bound lowerBound;
+  int64 constantValue = 0;
+  if (IsConstant(bb, opnd1, constantValue)) {
+    int64 res = 0;
+    if (AddOrSubWithConstant(opnd1.GetPrimType(), OP_add, constantValue, rightConstant, res)) {
+      lowerBound = Bound(res, opnd1.GetPrimType());
+    } else {
+      return nullptr;
+    }
+    if (lowerBound.GetVar() == initBound.GetVar() && lowerBound.IsGreaterThan(initBound, opMeExpr.GetOpndType())) {
+      if (opMeExpr.GetOp() != OP_ne && opMeExpr.GetOp() != OP_eq) {
+        AnalysisUnreachableBBOrEdge(exitBB, *inLoopBB, *outLoopBB);
+      }
+      return nullptr;
+    }
+    return initBound.GetVar() == nullptr ? std::make_unique<ValueRange>(lowerBound, initBound, kLowerAndUpper) :
+        std::make_unique<ValueRange>(lowerBound, initBound, kSpecialUpperForLoop);
+  } else {
+    if (initBound.GetVar() == nullptr) {
+      return std::make_unique<ValueRange>(
+          Bound(&opnd1, rightConstant, opnd1.GetPrimType()), initBound, kSpecialLowerForLoop);
+    }
+  }
+  return nullptr;
+}
+
+std::unique_ptr<ValueRange> ValueRangePropagation::MergeValuerangeOfPhi(
+    std::vector<std::unique_ptr<ValueRange>> &valueRangeOfPhi) {
+  std::unique_ptr<ValueRange> res = std::move(valueRangeOfPhi.at(0));
+  for (size_t i = 1; i < valueRangeOfPhi.size(); ++i) {
+    res = CombineTwoValueRange(*res, *valueRangeOfPhi[i]);
+  }
+  return res;
+}
+
+std::unique_ptr<ValueRange> ValueRangePropagation::MakeMonotonicIncreaseOrDecreaseValueRangeForPhi(
+    int64 stride, Bound &initBound) const {
+  if (stride > 0) {
+    return std::make_unique<ValueRange>(initBound, stride, kOnlyHasLowerBound);
+  }
+  if (stride < 0) {
+    return std::make_unique<ValueRange>(initBound, stride, kOnlyHasUpperBound);
+  }
+  return nullptr;
+}
+
+// Traverse the bbs in the loop in order to create vr for the loop variable.
+void ValueRangePropagation::TravelBBs(std::vector<BB*> &reversePostOrderOfLoopBBs) {
+  for (size_t i = 0; i < reversePostOrderOfLoopBBs.size(); ++i) {
+    auto *bb = reversePostOrderOfLoopBBs[i];
+    if (unreachableBBs.find(bb) != unreachableBBs.end()) {
+      continue;
+    }
+    if (i != 0) { // The phi has already been dealed with.
+      DealWithPhi(*bb);
+    }
+    for (auto it = bb->GetMeStmts().begin(); it != bb->GetMeStmts().end(); ++it) {
+      for (size_t j = 0; j < it->NumMeStmtOpnds(); ++j) {
+        DealWithOperand(*bb, *it, *it->GetOpnd(j));
+      }
+      switch (it->GetOp()) {
+        case OP_dassign:
+        case OP_maydassign:
+        case OP_regassign: {
+          if (it->GetLHS() != nullptr && it->GetLHS()->IsVolatile()) {
+            break;
+          }
+          DealWithAssign(*bb, *it);
+          break;
+        }
+        case OP_brfalse:
+        case OP_brtrue: {
+          DealWithCondGoto(*bb, *it);
+          break;
+        }
+        case OP_callassigned: {
+          DealWithCallassigned(*bb, *it);
+          break;
+        }
+        case OP_switch: {
+          DealWithSwitch(*bb, *it);
+          break;
+        }
+        case OP_igoto:
+        default:
+          break;
+      }
+    }
+  }
+}
+
+void ValueRangePropagation::CreateVRForPhi(const LoopDesc &loop) {
+  onlyPropVRStack.push(onlyPropVR);
+  onlyPropVR = true;
+  std::vector<BB*> reversePostOrderOfLoopBBs;
+  // Collect loop bbs.
+  for (auto it = currItOfTravelReversePostOrder; it != dom.GetReversePostOrder().end(); ++it) {
+    if (reversePostOrderOfLoopBBs.size() == loop.loopBBs.size()) {
+      break;
+    }
+    auto bb = func.GetCfg()->GetBBFromID(BBId((*it)->GetID()));
+    if (loop.Has(*bb)) {
+      reversePostOrderOfLoopBBs.push_back(bb);
+    }
+  }
+  // Travels loop bbs.
+  TravelBBs(reversePostOrderOfLoopBBs);
+  onlyPropVR = onlyPropVRStack.top();
+  onlyPropVRStack.pop();
+}
+
+// Calculate the valuerange of def-operand according to the valuerange of each rhs operand.
+std::unique_ptr<ValueRange> ValueRangePropagation::MergeValueRangeOfPhiOperands(const BB &bb, MePhiNode &mePhiNode) {
+  auto *resValueRange = FindValueRangeAndInitNumOfRecursion(*bb.GetPred(0), *mePhiNode.GetOpnd(0));
+  if (resValueRange == nullptr || !resValueRange->IsConstant()) {
+    return nullptr;
+  }
+  bool theRangeTypeIsNotEqual = (resValueRange->GetRangeType() == kNotEqual);
+  auto resValueRangePtr = CopyValueRange(*resValueRange);
+  for (size_t i = 1; i < mePhiNode.GetOpnds().size(); ++i) {
+    auto *operand = mePhiNode.GetOpnd(i);
+    auto *valueRange = FindValueRangeAndInitNumOfRecursion(*bb.GetPred(i), *operand);
+    // If one valuerange is nullptr, the result is nullptr.
+    if (valueRange == nullptr || !valueRange->IsConstant()) {
+      return nullptr;
+    }
+    theRangeTypeIsNotEqual |= (valueRange->GetRangeType() == kNotEqual);
+    if (resValueRange->IsEqual(valueRange)) {
+      continue;
+    }
+    // If the range type of phi operands is kNotEqual and the values are not equal, return nullptr.
+    if (theRangeTypeIsNotEqual) {
+      return nullptr;
+    }
+    if (resValueRange->GetUpper().GetPrimType() != valueRange->GetUpper().GetPrimType()) {
+      return nullptr;
+    }
+    resValueRangePtr = CombineTwoValueRange(*resValueRangePtr, *valueRange, true);
+  }
+  return resValueRangePtr;
+}
+
+bool ValueRangePropagation::MergeVrOrInitAndBackedge(MePhiNode &mePhiNode, ValueRange &vrOfInitExpr,
+    ValueRange &valueRange, Bound &resBound) {
+  bool isOnlyHasLowerBound = vrOfInitExpr.GetRangeType() == kOnlyHasLowerBound;
+  auto pType = mePhiNode.GetLHS()->GetPrimType();
+  auto upperBound = isOnlyHasLowerBound ? valueRange.GetBound() : vrOfInitExpr.GetBound();
+  auto LowerBound = isOnlyHasLowerBound ? vrOfInitExpr.GetBound() : valueRange.GetBound();
+  if (valueRange.GetRangeType() == kNotEqual) {
+    if (vrOfInitExpr.GetBound().IsConstantBound() && valueRange.IsConstantRange()) {
+      if (LowerBound.IsGreaterThan(upperBound, pType)) {
+        return false;
+      }
+      int64 res = 0;
+      if (!AddOrSubWithConstant(pType, OP_sub, upperBound.GetConstant(), LowerBound.GetConstant(), res)) {
+        return false;
+      }
+      if (Bound(res, pType).IsLessThanOrEqualTo(Bound(vrOfInitExpr.GetStride(), pType), pType)) {
+        return false;
+      }
+    }
+    int64 res = 0;
+    if (AddOrSubWithConstant(pType, isOnlyHasLowerBound ? OP_sub : OP_add,
+        valueRange.GetBound().GetConstant(), 1, res)) {
+      resBound = Bound(valueRange.GetBound().GetVar(), res, pType);
+    } else {
+      return false;
+    }
+  } else {
+    resBound = isOnlyHasLowerBound ? valueRange.GetUpper() : valueRange.GetLower();
+    resBound.SetPrimType(pType);
+  }
+  return true;
+}
+
+// Calculate the valuerange of def-operand according to the valuerange of each rhs operand.
+void ValueRangePropagation::MergeValueRangeOfPhiOperands(const LoopDesc &loop, const BB &bb,
+    std::vector<std::unique_ptr<ValueRange>> &valueRangeOfInitExprs, size_t indexOfInitExpr) {
+  size_t index = 0;
+  for (auto &it : bb.GetMePhiList()) {
+    if (!it.second->GetIsLive()) {
+      continue;
+    }
+    if (it.second->GetOpnds().size() != kNumOperands) {
+      return;
+    }
+    auto *mePhiNode = it.second;
+    auto *vrOfInitExpr = valueRangeOfInitExprs.at(index).get();
+    auto pType = it.second->GetLHS()->GetPrimType();
+    if (vrOfInitExpr == nullptr ||
+        (vrOfInitExpr->GetRangeType() != kOnlyHasLowerBound && vrOfInitExpr->GetRangeType() != kOnlyHasUpperBound) ||
+        (GetVecLanes(pType) > 0)) {
+      index++;
+      continue;
+    }
+    Bound resBound = vrOfInitExpr->GetRangeType() == kOnlyHasLowerBound ?
+        Bound(nullptr, GetMaxNumber(pType), pType) : Bound( nullptr, GetMinNumber(pType), pType);
+    bool vrCanBeComputed = true;
+    index++;
+    bool isAccurateBound = false;
+    for (size_t i = 0; i < mePhiNode->GetOpnds().size(); ++i) {
+      if (i == indexOfInitExpr) {
+        continue;
+      }
+      auto *operand = mePhiNode->GetOpnd(i);
+      auto *valueRange = FindValueRangeAndInitNumOfRecursion(*bb.GetPred(i), *operand);
+      if (valueRange == nullptr ||
+          valueRange->GetRangeType() == kOnlyHasUpperBound ||
+          valueRange->GetRangeType() == kOnlyHasLowerBound ||
+          vrOfInitExpr->IsEqual(valueRange) ||
+          !MergeVrOrInitAndBackedge(*mePhiNode, *vrOfInitExpr, *valueRange, resBound)) {
+        vrCanBeComputed = false;
+        break;
+      }
+      isAccurateBound = valueRange->IsAccurate() || valueRange->GetRangeType() == kEqual ||
+          valueRange->GetRangeType() == kNotEqual;
+    }
+    if (!vrCanBeComputed) {
+      continue;
+    }
+    auto stride = abs(vrOfInitExpr->GetStride());
+    onlyRecordValueRangeInTempCache.push(false);
+
+    bool isOnlyHasLowerBound = vrOfInitExpr->GetRangeType() == kOnlyHasLowerBound;
+    auto valueRangeOfPhi = isOnlyHasLowerBound ?
+        std::make_unique<ValueRange>(vrOfInitExpr->GetBound(), resBound, kLowerAndUpper) :
+        std::make_unique<ValueRange>(resBound, vrOfInitExpr->GetBound(), kLowerAndUpper);
+    if (!valueRangeOfPhi->IsConstantRange() || stride == 1) {
+      if (loop.IsCanonicalAndOnlyHasOneExitBBLoop() && isAccurateBound) {
+        valueRangeOfPhi->SetAccurate(true);
+      }
+    } else if (stride != 1) {
+      auto constLower = valueRangeOfPhi->GetLower().GetConstant();
+      auto constUpper = valueRangeOfPhi->GetUpper().GetConstant();
+      if (!ConstantFold::IntegerOpIsOverflow(OP_sub, pType, constUpper, constLower) &&
+          Bound(constUpper - constLower, pType).IsGreaterThan(Bound(stride, pType), pType) &&
+          valueRangeOfPhi->GetUpper().IsGreaterThan(valueRangeOfPhi->GetLower(), pType)) {
+        int64 rem = (constUpper - constLower) % stride;
+        bool isAccurate = false;
+        if (isOnlyHasLowerBound) {
+          // If the vr of phi node is (lower: 0, upper: 19, stride: 2),
+          // update the vr with (lower: 0, upper: 18, stride: 2)
+          if (!ConstantFold::IntegerOpIsOverflow(OP_sub, pType, constUpper, rem)) {
+            int64 constantOfNewUpper = constUpper - rem;
+            if (constantOfNewUpper >= constLower && constantOfNewUpper <= constUpper) {
+              valueRangeOfPhi->SetUpper(Bound(nullptr, constantOfNewUpper, pType));
+              isAccurate = true;
+            }
+          }
+        } else {
+          if (!ConstantFold::IntegerOpIsOverflow(OP_add, pType, constUpper, rem)) {
+            int64 constantOfNewLower = constLower + rem;
+            if (constantOfNewLower >= constLower && constantOfNewLower <= constUpper) {
+              valueRangeOfPhi->SetLower(Bound(nullptr, constantOfNewLower, pType));
+              isAccurate = true;
+            }
+          }
+        }
+        if (loop.IsCanonicalAndOnlyHasOneExitBBLoop() && isAccurate && isAccurateBound) {
+          valueRangeOfPhi->SetAccurate(true);
+        }
+      }
+    }
+    Insert2Caches(bb.GetBBId(), mePhiNode->GetLHS()->GetExprID(), std::move(valueRangeOfPhi));
+    onlyRecordValueRangeInTempCache.pop();
+  }
+}
+
+bool ValueRangePropagation::TheValueRangeOfOpndAndSubOpndAreEqual(const MeExpr &opnd) const {
+  // opnd[0] = OP zext i32 kPtyInvalid mx590
+  //   opnd[0] = REGINDX:15 u8 %15 mx589
+  return (opnd.GetOp() == OP_zext && static_cast<const OpMeExpr&>(opnd).GetBitsOffSet() == 0 &&
+      IsPrimitiveUnsigned(opnd.GetOpnd(0)->GetPrimType()));
+}
+
+void ValueRangePropagation::CalculateVROfSubOpnd(BBId bbID, const MeExpr &opnd, ValueRange &valueRange) {
+  // Deal with the case like:
+  // opnd[0] = OP sub u32 u32 mx1
+  //   opnd[1] = REGINDX:15 u32 %15 mx2
+  //   opnd[2] = const 5 mx3
+  // If the vr of opnd mx1 has been calculated, the vr of opnd mx2 can be calculated.
+  if (opnd.GetOp() != OP_add && opnd.GetOp() != OP_sub) {
+    return;
+  }
+  auto &opMeExpr = static_cast<const OpMeExpr&>(opnd);
+  auto *opnd0 = opMeExpr.GetOpnd(0);
+  auto *opnd1 = opMeExpr.GetOpnd(1);
+  if (opnd1->GetMeOp() != kMeOpConst || static_cast<ConstMeExpr*>(opnd1)->GetConstVal()->GetKind() != kConstInt) {
+    return;
+  }
+  int64 rhsConstant = static_cast<ConstMeExpr*>(opnd1)->GetExtIntValue();
+  auto antiOp = (opnd.GetOp() == OP_add) ? OP_sub : OP_add;
+  Insert2Caches(bbID, opnd0->GetExprID(), AddOrSubWithValueRange(antiOp, valueRange, rhsConstant), opnd0);
+}
+
+bool ValueRangePropagation::Insert2Caches(
+    const BBId &bbID, int32 exprID, std::unique_ptr<ValueRange> valueRange, const MeExpr *opnd) {
+  if (valueRange == nullptr) {
+    if (onlyRecordValueRangeInTempCache.top()) {
+      tempCaches[bbID].insert(std::make_pair(exprID, nullptr));
+    } else {
+      caches.at(bbID)[exprID] = nullptr;
+    }
+    return true;
+  }
+  if (!IsNeededPrimType(valueRange->GetPrimType())) {
+    return false;
+  }
+  auto tempVR = CopyValueRange(*valueRange);
+  if (valueRange->IsConstant() && valueRange->GetRangeType() == kLowerAndUpper) {
+    valueRange->SetRangeType(kEqual);
+    valueRange->SetBound(valueRange->GetLower());
+  }
+
+  if (onlyRecordValueRangeInTempCache.top()) {
+    if (opnd != nullptr && TheValueRangeOfOpndAndSubOpndAreEqual(*opnd)) {
+      (void)tempCaches[bbID].insert(std::make_pair(opnd->GetOpnd(0)->GetExprID(), CopyValueRange(*valueRange)));
+    }
+    tempCaches[bbID][exprID] = std::move(valueRange);
+  } else {
+    if (opnd != nullptr && TheValueRangeOfOpndAndSubOpndAreEqual(*opnd)) {
+      caches.at(bbID)[opnd->GetOpnd(0)->GetExprID()] = CopyValueRange(*valueRange);
+    }
+    caches.at(bbID)[exprID] = std::move(valueRange);
+  }
+  if (opnd != nullptr) {
+    CalculateVROfSubOpnd(bbID, *opnd, *tempVR);
+  }
+  return true;
+}
+
+// The rangeType of vrOfRHS is kEqual and the rangeType of vrOfLHS is kEqual, kNotEqual or kLowerAndUpper
+void ValueRangePropagation::JudgeEqual(MeExpr &expr, ValueRange &vrOfLHS, ValueRange &vrOfRHS,
+    std::unique_ptr<ValueRange> &valueRangePtr) {
+  if (vrOfRHS.GetRangeType() != kEqual) {
+    return;
+  }
+  auto primType = static_cast<OpMeExpr&>(expr).GetOpndType();
+  auto resPType = static_cast<OpMeExpr&>(expr).GetPrimType();
+  auto op = expr.GetOp();
+  if (vrOfLHS.GetRangeType() == kEqual) {
+    if (vrOfRHS.GetBound().IsEqual(vrOfLHS.GetBound(), primType)) {
+      // dealwith this case:
+      // a = (b == c)
+      // valueRange(b): kEqual 1
+      // valueRange(c): kEqual 1
+      // ==>
+      // valueRange(a): kNotEqual 0
+      valueRangePtr = (op == OP_eq) ? CreateValueRangeOfNotEqualZero(resPType) : CreateValueRangeOfEqualZero(resPType);
+    } else {
+      // dealwith this case:
+      // a = (b == c)
+      // valueRange(b): kEqual 1
+      // valueRange(c): kEqual 2
+      // ==>
+      // valueRange(a): kEqual 0
+      valueRangePtr = (op == OP_eq) ? CreateValueRangeOfEqualZero(resPType) : CreateValueRangeOfNotEqualZero(resPType);
+    }
+  } else if (vrOfLHS.GetRangeType() == kNotEqual) {
+    if (vrOfRHS.GetBound().IsEqual(vrOfLHS.GetBound(), primType)) {
+      // dealwith this case:
+      // a = (b == c)
+      // valueRange(b): kNotEqual 1
+      // valueRange(c): kEqual 1
+      // ==>
+      // valueRange(a): kEqual 0
+      valueRangePtr = (op == OP_eq) ? CreateValueRangeOfEqualZero(resPType) : CreateValueRangeOfNotEqualZero(resPType);
+    }
+  } else if (vrOfLHS.GetRangeType() == kLowerAndUpper) {
+    if (!vrOfLHS.GetLower().IsGreaterThan(vrOfLHS.GetUpper(), primType) &&
+        (vrOfLHS.GetLower().IsGreaterThan(vrOfRHS.GetBound(), primType) ||
+        vrOfRHS.GetBound().IsGreaterThan(vrOfLHS.GetUpper(), primType))) {
+      // dealwith this case:
+      // a = (b == c)
+      // valueRange(b): kLowerAndUpper (1, Max)
+      // valueRange(c): kEqual 0
+      // ==>
+      // valueRange(a): kEqual 0
+      valueRangePtr = (op == OP_eq) ? CreateValueRangeOfEqualZero(resPType) : CreateValueRangeOfNotEqualZero(resPType);
+    }
+  }
+}
+
+std::unique_ptr<ValueRange> ValueRangePropagation::NegValueRange(
+    const BB &bb, MeExpr &opnd, uint32 &numberOfRecursions, std::unordered_set<int32> &foundExprs) {
+  auto *valueRange = FindValueRange(bb, opnd, numberOfRecursions, foundExprs);
+  if (valueRange == nullptr) {
+    return nullptr;
+  }
+  auto constantZero = CreateValueRangeOfEqualZero(opnd.GetPrimType());
+  auto valueRangePtr = AddOrSubWithValueRange(OP_sub, *constantZero, *valueRange);
+  if (valueRangePtr == nullptr) {
+    return nullptr;
+  }
+  auto lower = valueRangePtr->GetLower();
+  valueRangePtr->SetLower(valueRangePtr->GetUpper());
+  valueRangePtr->SetUpper(lower);
+  return valueRangePtr;
+}
+
+ValueRange *ValueRangePropagation::DealWithNegWhenFindValueRange(const BB &bb, const MeExpr &expr,
+    const MeExpr *preExpr, uint32 &numberOfRecursions, std::unordered_set<int32> &foundExprs) {
+  auto *opnd = expr.GetOpnd(0);
+  if (!foundExprs.insert(opnd->GetExprID()).second) {
+    return nullptr;
+  }
+  if (opnd == preExpr) {
+    return nullptr;
+  }
+  auto valueRangePtr = NegValueRange(bb, *opnd, numberOfRecursions, foundExprs);
+  if (valueRangePtr == nullptr) {
+    return nullptr;
+  }
+  auto *resValueRange = valueRangePtr.get();
+  (void)Insert2Caches(bb.GetBBId(), expr.GetExprID(), std::move(valueRangePtr));
+  return resValueRange;
+}
+
+ValueRange *ValueRangePropagation::FindValueRangeWithCompareOp(
+    const BB &bb, MeExpr &expr, uint32 &numberOfRecursions, std::unordered_set<int32> &foundExprs, MeExpr *preExpr) {
+  auto op = expr.GetOp();
+  if (op == OP_neg) {
+    return DealWithNegWhenFindValueRange(bb, expr, preExpr, numberOfRecursions, foundExprs);
+  }
+  if (!IsCompareHasReverseOp(op) || expr.GetNumOpnds() != kNumOperands) {
+    return nullptr;
+  }
+  auto *opnd0 = expr.GetOpnd(0);
+  auto *opnd1 = expr.GetOpnd(1);
+  auto *valueRangeOfOpnd0 = FindValueRange(bb, *opnd0, numberOfRecursions, foundExprs);
+  if (valueRangeOfOpnd0 == nullptr) {
+    return nullptr;
+  }
+  auto *valueRangeOfOpnd1 = FindValueRange(bb, *opnd1, numberOfRecursions, foundExprs);
+  if (valueRangeOfOpnd1 == nullptr || !valueRangeOfOpnd0->IsConstantRange() || !valueRangeOfOpnd1->IsConstantRange()) {
+    return nullptr;
+  }
+  auto rangeTypeOfOpnd0 = valueRangeOfOpnd0->GetRangeType();
+  auto rangeTypeOfOpnd1 = valueRangeOfOpnd1->GetRangeType();
+  std::unique_ptr<ValueRange> valueRangePtr = nullptr;
+  ValueRange *resValueRange = nullptr;
+  auto resPType = static_cast<OpMeExpr&>(expr).GetPrimType();
+  auto opndType = static_cast<OpMeExpr&>(expr).GetOpndType();
+  // Deal with op ne and eq.
+  if ((op == OP_eq || op == OP_ne)) {
+    if (rangeTypeOfOpnd1 == kEqual) {
+      JudgeEqual(expr, *valueRangeOfOpnd0, *valueRangeOfOpnd1, valueRangePtr);
+    } else if (rangeTypeOfOpnd0 == kEqual) {
+      JudgeEqual(expr, *valueRangeOfOpnd1, *valueRangeOfOpnd0, valueRangePtr);
+    } else if (rangeTypeOfOpnd0 == kLowerAndUpper && rangeTypeOfOpnd1 == kLowerAndUpper &&
+               (BrStmtInRange(bb, *valueRangeOfOpnd0, *valueRangeOfOpnd1, OP_lt, opndType) ||
+                BrStmtInRange(bb, *valueRangeOfOpnd0, *valueRangeOfOpnd1, OP_gt, opndType))) {
+      valueRangePtr = (op == OP_eq) ? CreateValueRangeOfEqualZero(resPType) : CreateValueRangeOfNotEqualZero(resPType);
+    }
+  }
+  // Deal with op gt, ge, lt and le.
+  if ((rangeTypeOfOpnd0 == kEqual || rangeTypeOfOpnd0 == kLowerAndUpper) &&
+      (rangeTypeOfOpnd1 == kEqual || rangeTypeOfOpnd1 == kLowerAndUpper)) {
+    if (BrStmtInRange(bb, *valueRangeOfOpnd0, *valueRangeOfOpnd1, op, opndType)) {
+      valueRangePtr = CreateValueRangeOfNotEqualZero(resPType);
+    } else if (BrStmtInRange(bb, *valueRangeOfOpnd0, *valueRangeOfOpnd1, GetReverseCmpOp(op), opndType)) {
+      valueRangePtr = CreateValueRangeOfEqualZero(resPType);
+    }
+  }
+  if (valueRangePtr != nullptr) {
+    resValueRange = valueRangePtr.get();
+    (void)Insert2Caches(bb.GetBBId(), expr.GetExprID(), std::move(valueRangePtr));
+  }
+  return resValueRange;
+}
+
+bool ValueRangePropagation::IsSubOpndOfExpr(const MeExpr &expr, const MeExpr &subExpr) const {
+  if (&expr == &subExpr) {
+    return true;
+  }
+  for (uint8 i = 0; i < expr.GetNumOpnds(); ++i) {
+    if (IsSubOpndOfExpr(*(expr.GetOpnd(i)), subExpr)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// When the valueRange of expr is not exist, need find the valueRange of the def point or use points.
+ValueRange *ValueRangePropagation::FindValueRange(const BB &bb, MeExpr &expr, uint32 &numberOfRecursionsArg,
+                                                  std::unordered_set<int32> &foundExprs) {
+  if (numberOfRecursionsArg++ > kRecursionThreshold) {
+    return nullptr;
+  }
+  uint32 recursions = 0;
+  auto *valueRange = FindValueRangeInCaches(bb.GetBBId(), expr.GetExprID(), recursions);
+  if (valueRange != nullptr) {
+    return valueRange;
+  }
+  valueRange = FindValueRangeWithCompareOp(bb, expr, numberOfRecursionsArg, foundExprs);
+  if (valueRange != nullptr) {
+    return valueRange;
+  }
+  auto it = pairOfExprs.find(&expr);
+  if (it == pairOfExprs.end()) {
+    return nullptr;
+  }
+  for (auto itOfValueMap = it->second.begin(); itOfValueMap != it->second.end(); ++itOfValueMap) {
+    auto bbOfPair = itOfValueMap->first;
+    auto exprs = itOfValueMap->second;
+    if (!dom.Dominate(*bbOfPair, bb)) {
+      continue;
+    }
+    for (auto itOfExprs = exprs.begin(); itOfExprs != exprs.end(); ++itOfExprs) {
+      if (!foundExprs.insert((*itOfExprs)->GetExprID()).second) {
+        return nullptr;
+      }
+      recursions = 0;
+      valueRange = FindValueRangeInCaches(bb.GetBBId(), (*itOfExprs)->GetExprID(), recursions);
+      if (valueRange != nullptr && valueRange->IsEqualAfterCVT(expr.GetPrimType(), (*itOfExprs)->GetPrimType())) {
+        return valueRange;
+      }
+      if (IsSubOpndOfExpr(**itOfExprs, expr)) {
+        // When the condition is true, mx1297 and mx553 are equivalent. When the vr of mx533 cannot be found,
+        // there is no need to continue to find the vr of mx1297, because it will fall into a dead cycle.
+        // For example:
+        // ||MEIR|| brtrue
+        //     opnd[0] = OP eq u1 u32 mx1297
+        //       opnd[0] = i32 i64 mx553
+        //     opnd[1] = OP cvt i32 i64 mx553
+        continue;
+      }
+      valueRange = FindValueRangeWithCompareOp(bb, **itOfExprs, numberOfRecursionsArg, foundExprs, &expr);
+      if (valueRange != nullptr) {
+        return valueRange;
+      }
+    }
+  }
+  return nullptr;
+}
+
+std::unique_ptr<ValueRange> ValueRangePropagation::CreateInitVRForPhi(LoopDesc &loop,
+    const BB &bb, ScalarMeExpr &init, ScalarMeExpr &backedge, const ScalarMeExpr &lhsOfPhi) {
+  Bound initBound;
+  ValueRange *valueRangeOfInit = FindValueRangeAndInitNumOfRecursion(bb, init);
+  if (valueRangeOfInit != nullptr && valueRangeOfInit->IsConstant() && valueRangeOfInit->GetRangeType() != kNotEqual) {
+    auto bound = valueRangeOfInit->GetBound();
+    initBound = Bound(GetRealValue(bound.GetConstant(), bound.GetPrimType()), bound.GetPrimType());
+  } else {
+    initBound = Bound(&init, init.GetPrimType());
+  }
+  int64 stride = 0;
+  if (!CanComputeLoopIndVar(lhsOfPhi, backedge, stride) || stride == 0) {
+    if (valueRangeOfInit == nullptr || !valueRangeOfInit->IsConstant()) {
+      return nullptr;
+    }
+    if (loop.inloopBB2exitBBs.size() != 1) {
+      return nullptr;
+    }
+    auto *exitBB = func.GetCfg()->GetBBFromID(loop.inloopBB2exitBBs.begin()->first);
+    if (exitBB->GetKind() != kBBCondGoto) {
+      return nullptr;
+    }
+    auto *brMeStmt = static_cast<CondGotoMeStmt*>(exitBB->GetLastMe());
+    auto *opMeExpr = static_cast<OpMeExpr*>(brMeStmt->GetOpnd());
+    MeExpr *opnd0 = opMeExpr->GetOpnd(0);
+    MeExpr *opnd1 = opMeExpr->GetOpnd(1);
+    BB *trueBranch = nullptr;
+    BB *falseBranch = nullptr;
+    ASSERT_NOT_NULL(brMeStmt);
+    GetTrueAndFalseBranch(brMeStmt->GetOp(), *exitBB, trueBranch, falseBranch);
+    if (opnd0 != &backedge) {
+      return nullptr;
+    }
+    if (opMeExpr->GetOp() != OP_ne && opMeExpr->GetOp() != OP_eq) {
+      return nullptr;
+    }
+    int64 constantValue = 0;
+    if (IsConstant(*exitBB, *opnd1, constantValue) && valueRangeOfInit != nullptr &&
+        valueRangeOfInit->GetBound().GetConstant() == constantValue) {
+      RangeType initRangeType = valueRangeOfInit->GetRangeType();
+      std::unique_ptr<ValueRange> vr;
+      if ((opMeExpr->GetOp() == OP_ne && loop.Has(*trueBranch) && initRangeType == kNotEqual) ||
+          (opMeExpr->GetOp() == OP_eq && loop.Has(*falseBranch) && initRangeType == kNotEqual)) {
+        vr = std::make_unique<ValueRange>(Bound(constantValue, opMeExpr->GetOpndType()), kNotEqual);
+      } else if ((opMeExpr->GetOp() == OP_ne && loop.Has(*falseBranch) && initRangeType == kEqual) ||
+                 (opMeExpr->GetOp() == OP_eq && loop.Has(*trueBranch) && initRangeType == kEqual)) {
+        vr = std::make_unique<ValueRange>(Bound(constantValue, opMeExpr->GetOpndType()), kEqual);
+      } else {
+        vr = nullptr;
+      }
+      Insert2Caches(bb.GetBBId(), lhsOfPhi.GetExprID(), std::move(vr));
+    }
+    return nullptr;
+  }
+  auto valueRangeForPhi = MakeMonotonicIncreaseOrDecreaseValueRangeForPhi(stride, initBound);
+  if (valueRangeForPhi == nullptr) {
+    return nullptr;
+  }
+  if (Insert2Caches(bb.GetBBId(), lhsOfPhi.GetExprID(), CopyValueRange(*valueRangeForPhi, init.GetPrimType()))) {
+    return valueRangeForPhi;
+  }
+  return nullptr;
+}
+
+// Calculate the valuerange of the operands according to the mePhiNode.
+void ValueRangePropagation::DealWithPhi(const BB &bb) {
+  if (bb.GetMePhiList().empty()) {
+    return;
+  }
+  // If the bb is not in loop or the bb is not the head of loop, merge the value range of phi operands.
+  if (bb.GetPred().size() == 1 || loops == nullptr || loops->GetMeLoops().size() == 0 ||
+      loops->GetBBLoopParent(bb.GetBBId()) == nullptr || loops->GetBBLoopParent(bb.GetBBId())->head != &bb) {
+    for (auto &pair : bb.GetMePhiList()) {
+      auto *mePhiNode = pair.second;
+      std::unique_ptr<ValueRange> valueRangeOfPhi = MergeValueRangeOfPhiOperands(bb, *mePhiNode);
+      if (valueRangeOfPhi != nullptr) {
+        (void)Insert2Caches(bb.GetBBId(), mePhiNode->GetLHS()->GetExprID(), std::move(valueRangeOfPhi));
+      }
+    }
+    return;
+  }
+  auto *loop = loops->GetBBLoopParent(bb.GetBBId());
+  std::set<ScalarMeExpr*> initExprsOfPhi;
+  std::set<ScalarMeExpr*> backExprOfPhi;
+  size_t indexOfInitExpr = -1;
+  std::vector<std::unique_ptr<ValueRange>> valueRangeOfInitExprs;
+  auto index = 0;
+  // Collect the initial value and the back edge value of phi node.
+  for (auto &pair : bb.GetMePhiList()) {
+    if (!pair.second->GetIsLive()) {
+      continue;
+    }
+    if (pair.second->GetOpnds().size() != kNumOperands) {
+      return;
+    }
+    for (size_t i = 0; i < pair.second->GetOpnds().size(); ++i) {
+      MeStmt *defStmt = nullptr;
+      auto *opnd = pair.second->GetOpnd(i);
+      BB *defBB = opnd->GetDefByBBMeStmt(*func.GetCfg(), defStmt);
+      if (!loop->Has(*defBB)) {
+        initExprsOfPhi.insert(opnd);
+        if (indexOfInitExpr == -1) {
+          indexOfInitExpr = i;
+        }
+      } else {
+        backExprOfPhi.insert(opnd);
+      }
+    }
+    if (backExprOfPhi.empty()) {
+      valueRangeOfInitExprs.emplace_back(nullptr);
+    } else if (initExprsOfPhi.size() == 1 && backExprOfPhi.size() == 1) { // Create vr for initial value of phi node.
+      auto vrOfInitExpr = CreateInitVRForPhi(
+          *loop, bb, **initExprsOfPhi.begin(), **backExprOfPhi.begin(), *pair.second->GetLHS());
+      valueRangeOfInitExprs.emplace_back(std::move(vrOfInitExpr));
+    } else {
+      valueRangeOfInitExprs.emplace_back(nullptr);
+    }
+    initExprsOfPhi.clear();
+    backExprOfPhi.clear();
+    index++;
+  }
+  // When the number of nested layers of the loop is too deep, do not continue to calculate vr of phi nodes.
+  if (loop->nestDepth > kLimitOfLoopNestDepth || loop->loopBBs.size() > kLimitOfLoopBBs) {
+    return;
+  }
+  onlyRecordValueRangeInTempCache.push(true);
+  CreateVRForPhi(*loop);
+  MergeValueRangeOfPhiOperands(*loop, bb, valueRangeOfInitExprs, indexOfInitExpr);
+  onlyRecordValueRangeInTempCache.pop();
+  tempCaches.clear();
+}
+
+// Return the max of leftBound or rightBound.
+Bound ValueRangePropagation::Max(Bound leftBound, Bound rightBound) {
+  if (leftBound.GetVar() == rightBound.GetVar()) {
+    return (leftBound.GetConstant() > rightBound.GetConstant()) ? leftBound : rightBound;
+  } else {
+    if (leftBound.GetVar() == nullptr && leftBound.IsEqualToMin(leftBound.GetPrimType()) &&
+        rightBound.GetConstant() < 1 && lengthSet.find(rightBound.GetVar()) != lengthSet.end()) {
+      return rightBound;
+    }
+    if (rightBound.GetVar() == nullptr && rightBound.IsEqualToMin(rightBound.GetPrimType()) &&
+        leftBound.GetConstant() < 1 && lengthSet.find(leftBound.GetVar()) != lengthSet.end()) {
+      return leftBound;
+    }
+  }
+  return leftBound;
+}
+
+// Return the min of leftBound or rightBound.
+Bound ValueRangePropagation::Min(Bound leftBound, Bound rightBound) {
+  if (leftBound.GetVar() == rightBound.GetVar()) {
+    return (leftBound.GetConstant() < rightBound.GetConstant()) ? leftBound : rightBound;
+  } else {
+    if (leftBound.GetVar() == nullptr && leftBound.IsEqualToMax(leftBound.GetPrimType()) &&
+        rightBound.GetConstant() < 1 && lengthSet.find(rightBound.GetVar()) != lengthSet.end()) {
+      return rightBound;
+    }
+    if (rightBound.GetVar() == nullptr && rightBound.IsEqualToMax(rightBound.GetPrimType()) &&
+        leftBound.GetConstant() < 1 && lengthSet.find(leftBound.GetVar()) != lengthSet.end()) {
+      return leftBound;
+    }
+  }
+  return leftBound;
+}
+
+// Judge whether the lower is in range.
+bool ValueRangePropagation::LowerInRange(const BB &bb, Bound lowerTemp, Bound lower, bool lowerIsZero) {
+  if ((lowerIsZero && lowerTemp.GetVar() == nullptr) ||
+      (!lowerIsZero && lowerTemp.GetVar() == lower.GetVar())) {
+    int64 lowerConstant = lowerIsZero ? 0 : lower.GetConstant();
+    return (lowerTemp.GetConstant() >= lowerConstant);
+  } else {
+    if (lowerTemp.GetVar() != nullptr) {
+      auto *lowerVar = lowerTemp.GetVar();
+      auto *lowerRangeValue = FindValueRangeAndInitNumOfRecursion(bb, *lowerVar);
+      if (lowerRangeValue != nullptr && lowerRangeValue->IfLowerEqualToUpper() &&
+          lowerRangeValue->GetLower().GetVar() != lowerVar) {
+        if (lowerTemp.GetConstant() == 0) {
+          return LowerInRange(bb, lowerRangeValue->GetLower(), lower, lowerIsZero);
+        } else {
+          Bound newLower;
+          if (CreateNewBoundWhenAddOrSub(OP_add, lowerRangeValue->GetBound(),
+                                         lowerTemp.GetConstant(), newLower)) {
+            return LowerInRange(bb, newLower, lower, lowerIsZero);
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// Judge whether the upper is in range.
+bool ValueRangePropagation::UpperInRange(const BB &bb, Bound upperTemp, Bound upper, bool upperIsArrayLength) {
+  if (upperTemp.GetVar() == upper.GetVar()) {
+    return upperIsArrayLength ? (upperTemp.GetConstant() < upper.GetConstant()) :
+        (upperTemp.GetConstant() <= upper.GetConstant());
+  }
+  if (upperTemp.GetVar() == nullptr) {
+    return false;
+  }
+  auto *upperVar = upperTemp.GetVar();
+  auto *upperRangeValue = FindValueRangeAndInitNumOfRecursion(bb, *upperVar);
+  if (upperRangeValue == nullptr) {
+    auto *currVar = upperVar;
+    while (length2Def.find(currVar) != length2Def.end()) {
+      currVar = length2Def[currVar];
+      if (currVar == upper.GetVar()) {
+        Bound newUpper;
+        if (CreateNewBoundWhenAddOrSub(
+            OP_add, upper, upperTemp.GetConstant(), newUpper)) {
+          return UpperInRange(bb, newUpper, upper, upperIsArrayLength);
+        } else {
+          return false;
+        }
+      }
+    }
+  } else if (upperRangeValue->IfLowerEqualToUpper() &&
+             upperRangeValue->GetUpper().GetVar() != upperVar) {
+    if (upperTemp.GetConstant() == 0) {
+      return UpperInRange(bb, upperRangeValue->GetUpper(), upper, upperIsArrayLength);
+    } else {
+      Bound newUpper;
+      if (CreateNewBoundWhenAddOrSub(OP_add, upperRangeValue->GetBound(),
+                                     upperTemp.GetConstant(), newUpper)) {
+        return UpperInRange(bb, newUpper, upper, upperIsArrayLength);
+      } else {
+        return false;
+      }
+    }
+  } else if (!upperRangeValue->IfLowerEqualToUpper()) {
+    if (length2Def.find(upperVar) != length2Def.end() && length2Def[upperVar] == upper.GetVar()) {
+      return upperIsArrayLength ? (upperTemp.GetConstant() < upper.GetConstant()) :
+          (upperTemp.GetConstant() <= upper.GetConstant());
+    }
+  }
+  return false;
+}
+
+// Judge whether the lower and upper are in range.
+InRangeType ValueRangePropagation::InRange(const BB &bb, const ValueRange &rangeTemp,
+                                           const ValueRange &range, bool lowerIsZero) {
+  bool lowerInRange = LowerInRange(bb, rangeTemp.GetLower(), range.GetLower(), lowerIsZero);
+  Bound upperBound;
+  if (lowerIsZero && !range.IfLowerEqualToUpper()) {
+    upperBound = range.GetLower();
+  } else {
+    upperBound = range.GetUpper();
+  }
+  bool upperInRange = UpperInRange(bb, rangeTemp.GetUpper(), upperBound, lowerIsZero);
+  if (lowerInRange && upperInRange) {
+    return kInRange;
+  } else if (lowerInRange) {
+    return kLowerInRange;
+  } else if (upperInRange) {
+    return kUpperInRange;
+  } else {
+    return kNotInRange;
+  }
+}
+
+std::unique_ptr<ValueRange> ValueRangePropagation::CombineTwoValueRange(
+    const ValueRange &leftRange, const ValueRange &rightRange, bool merge) {
+  if (merge) {
+    return std::make_unique<ValueRange>(Min(leftRange.GetLower(), rightRange.GetLower()),
+                                        Max(leftRange.GetUpper(), rightRange.GetUpper()), kLowerAndUpper);
+  } else {
+    if (rightRange.GetRangeType() == kOnlyHasLowerBound) {
+      return std::make_unique<ValueRange>(rightRange.GetLower(), Max(leftRange.GetUpper(),
+          Bound(GetMaxNumber(rightRange.GetUpper().GetPrimType()), rightRange.GetUpper().GetPrimType())),
+              kLowerAndUpper, rightRange.IsAccurate());
+    }
+    if (rightRange.GetRangeType() == kOnlyHasUpperBound) {
+      return std::make_unique<ValueRange>(Min(leftRange.GetLower(),
+          Bound(GetMinNumber(rightRange.GetLower().GetPrimType()), rightRange.GetLower().GetPrimType())),
+              leftRange.GetUpper(), kLowerAndUpper, rightRange.IsAccurate());
+    }
+    return std::make_unique<ValueRange>(Max(leftRange.GetLower(), rightRange.GetLower()),
+        Min(leftRange.GetUpper(), rightRange.GetUpper()), kLowerAndUpper, rightRange.IsAccurate());
+  }
+}
+
+// When delete the exit bb of loop and delete the condgoto stmt,
+// the loop would not exit, so need change bb to gotobb for the f.GetCfg()->WontExitAnalysis().
+void ValueRangePropagation::ChangeLoop2Goto(LoopDesc &loop, BB &bb, BB &succBB, const BB &unreachableBB) {
+  auto it = loop.inloopBB2exitBBs.find(bb.GetBBId());
+  bool theLoopWontExit = false;
+  if (it != loop.inloopBB2exitBBs.end()) {
+    for (auto *exitedBB : *it->second) {
+      if (exitedBB == &unreachableBB) {
+        theLoopWontExit = true;
+        break;
+      }
+    }
+  }
+  if (!theLoopWontExit) {
+    return;
+  }
+  auto *gotoMeStmt = irMap.New<GotoMeStmt>(func.GetOrCreateBBLabel(succBB));
+  bb.AddMeStmtLast(gotoMeStmt);
+  bb.SetKind(kBBGoto);
+}
+
+void ValueRangePropagation::Insert2UnreachableBBs(BB &unreachableBB) {
+  if (ValueRangePropagation::isDebug) {
+    LogInfo::MapleLogger() << "=====================delete bb " << unreachableBB.GetBBId() <<
+        "========================\n";
+  }
+  unreachableBBs.insert(&unreachableBB);
+  return;
+}
+
+// when determine remove the condgoto stmt, need analysis which bbs need be deleted.
+void ValueRangePropagation::AnalysisUnreachableBBOrEdge(BB &bb, BB &unreachableBB, BB &succBB) {
+  if (onlyPropVR) {
+    return;
+  }
+  for (auto &pred : bb.GetPred()) {
+    UpdateProfile(*pred, bb, unreachableBB);
+  }
+  Insert2UnreachableBBs(unreachableBB);
+  // update frequency before cfg changed
+  bb.RemoveSucc(unreachableBB);
+  bb.RemoveMeStmt(bb.GetLastMe());
+  bb.SetKind(kBBFallthru);
+  auto *loop = loops->GetBBLoopParent(bb.GetBBId());
+  if (loop == nullptr) {
+    return;
+  }
+  ChangeLoop2Goto(*loop, bb, succBB, unreachableBB);
+}
+
+// Judge whether the value range is in range.
+bool ValueRangePropagation::BrStmtInRange(const BB &bb, const ValueRange &leftRange,
+                                          const ValueRange &rightRange, Opcode op, PrimType opndType,
+                                          bool judgeNotInRange) {
+  Bound leftLower = leftRange.GetLower();
+  Bound leftUpper = leftRange.GetUpper();
+  Bound rightLower = rightRange.GetLower();
+  Bound rightUpper = rightRange.GetUpper();
+  RangeType leftRangeType = leftRange.GetRangeType();
+  RangeType rightRangeType = rightRange.GetRangeType();
+  if (!IsNeededPrimType(opndType) ||
+      leftLower.GetVar() != leftUpper.GetVar() || leftUpper.GetVar() != rightUpper.GetVar() ||
+      rightUpper.GetVar() != rightLower.GetVar() || leftRangeType == kSpecialLowerForLoop ||
+      leftRangeType == kSpecialUpperForLoop ||
+      leftRange.GetRangeType() == kOnlyHasLowerBound ||
+      leftRange.GetRangeType() == kOnlyHasUpperBound ||
+      rightRangeType == kSpecialLowerForLoop ||
+      rightRangeType == kSpecialUpperForLoop ||
+      rightRange.GetRangeType() == kOnlyHasLowerBound ||
+      rightRange.GetRangeType() == kOnlyHasUpperBound) {
+    return false;
+  }
+  if (judgeNotInRange) {
+    if (leftLower.GetVar() != nullptr) {
+      return false;
+    }
+  } else {
+    if (leftLower.GetVar() != nullptr) {
+      auto *valueRange = FindValueRangeAndInitNumOfRecursion(bb, *leftLower.GetVar());
+      if (valueRange == nullptr || !valueRange->IsConstant()) {
+        return false;
+      }
+    }
+  }
+  // deal the difference between i32 and u32.
+  if (leftLower.IsGreaterThan(leftUpper, opndType) ||
+      rightLower.IsGreaterThan(rightUpper, opndType)) {
+    return false;
+  }
+  if ((op == OP_eq && !judgeNotInRange) || (op == OP_ne && judgeNotInRange)) {
+    // If the range of leftOpnd equal to the range of rightOpnd, remove the falseBranch.
+    return leftRangeType != kNotEqual && rightRangeType != kNotEqual &&
+        leftLower.IsEqual(leftUpper, opndType) &&
+        rightLower.IsEqual(rightUpper, opndType) &&
+        leftLower.IsEqual(rightLower, opndType);
+  } else if ((op == OP_ne && !judgeNotInRange) || (op == OP_eq && judgeNotInRange)) {
+    // If the range type of leftOpnd is kLowerAndUpper and the rightRange is not in range of it,
+    // remove the trueBranch, such as :
+    // brstmt a == b
+    // valueRange a: [1, max]
+    // valueRange b: 0
+    return (leftRangeType != kNotEqual && rightRangeType != kNotEqual &&
+        (leftLower.IsGreaterThan(rightUpper, opndType) || rightLower.IsGreaterThan(leftUpper, opndType))) ||
+        (leftRangeType == kNotEqual && rightRangeType == kEqual && leftLower.IsEqual(rightLower, opndType)) ||
+        (leftRangeType == kEqual && rightRangeType == kNotEqual && leftLower.IsEqual(rightLower, opndType));
+  } else if ((op == OP_lt && !judgeNotInRange) || (op == OP_ge && judgeNotInRange)) {
+    return leftRangeType != kNotEqual && rightRangeType != kNotEqual && rightLower.IsGreaterThan(leftUpper, opndType);
+  } else if ((op == OP_ge && !judgeNotInRange) || (op == OP_lt && judgeNotInRange)) {
+    return leftRangeType != kNotEqual && rightRangeType != kNotEqual && !rightUpper.IsGreaterThan(leftLower, opndType);
+  } else if ((op == OP_le && !judgeNotInRange) || (op == OP_gt && judgeNotInRange)) {
+    return leftRangeType != kNotEqual && rightRangeType != kNotEqual && !leftUpper.IsGreaterThan(rightLower, opndType);
+  } else if ((op == OP_gt && !judgeNotInRange) || (op == OP_le && judgeNotInRange)) {
+    return leftRangeType != kNotEqual && rightRangeType != kNotEqual && leftLower.IsGreaterThan(rightUpper, opndType);
+  }
+  return false;
+}
+
+void ValueRangePropagation::GetTrueAndFalseBranch(Opcode op, BB &bb, BB *&trueBranch, BB *&falseBranch) const {
+  if (op == OP_brtrue) {
+    trueBranch = bb.GetSucc(1);
+    falseBranch = bb.GetSucc(0);
+  } else {
+    trueBranch = bb.GetSucc(0);
+    falseBranch = bb.GetSucc(1);
+  }
+}
+
+void ValueRangePropagation::CreateValueRangeForSubOpnd(const MeExpr &opnd, const BB &trueBranch, const BB &falseBranch,
+    ValueRange &resTrueBranchVR, ValueRange &resFalseBranchVR) {
+  // Deal with the case like:
+  // brtrue @@m357 (lt u1 i32 (zext u32 8 (regread u8 %102), constval i32 1))
+  // The vr of opnd in curr bb is leftRange and in true branch is resTrueBranchVR.
+  // If the op of opnd is zext, and the vr before and after zext is the same,
+  // after judgment, the vr of before zext is the same as the opnd in true or false branch.
+  if (opnd.GetOp() != OP_zext) {
+    return;
+  }
+  auto &opMeExpr = static_cast<const OpMeExpr&>(opnd);
+  auto pTypeOfBitSize = GetIntegerPrimTypeBySizeAndSign(opMeExpr.GetBitsSize(), false);
+  if (pTypeOfBitSize == opMeExpr.GetOpnd(0)->GetPrimType()) {
+    (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetOpnd(0)->GetExprID(), CopyValueRange(resTrueBranchVR), &opnd);
+    (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetOpnd(0)->GetExprID(), CopyValueRange(resFalseBranchVR), &opnd);
+  }
+}
+
+void ValueRangePropagation::CreateValueRangeForLeOrLt(const MeExpr &opnd, const ValueRange *leftRange,
+    Bound newRightUpper, Bound newRightLower, const BB &trueBranch, const BB &falseBranch, bool isAccurate) {
+  CHECK_FATAL(IsEqualPrimType(newRightUpper.GetPrimType(), newRightLower.GetPrimType()), "must be equal");
+  if (leftRange == nullptr) {
+    std::unique_ptr<ValueRange> newTrueBranchRange = std::make_unique<ValueRange>(
+        ValueRange::MinBound(newRightUpper.GetPrimType()), newRightUpper, kLowerAndUpper, isAccurate);
+    (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(), std::move(newTrueBranchRange), &opnd);
+    std::unique_ptr<ValueRange> newFalseBranchRange = std::make_unique<ValueRange>(newRightLower,
+        ValueRange::MaxBound(newRightUpper.GetPrimType()), kLowerAndUpper, isAccurate);
+    (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(), std::move(newFalseBranchRange), &opnd);
+  } else if (leftRange->GetRangeType() == kOnlyHasLowerBound) {
+    std::unique_ptr<ValueRange> newRightRange = std::make_unique<ValueRange>(
+        ValueRange::MinBound(newRightUpper.GetPrimType()), newRightUpper, kLowerAndUpper, isAccurate);
+    std::unique_ptr<ValueRange> newLeftRange = std::make_unique<ValueRange>(leftRange->GetLower(),
+        ValueRange::MaxBound(leftRange->GetLower().GetPrimType()), kLowerAndUpper, isAccurate);
+    if (leftRange->IsConstantLowerAndUpper() && newRightRange->IsConstantLowerAndUpper()) {
+      (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(),
+                          CombineTwoValueRange(*leftRange, *newRightRange), &opnd);
+    } else {
+      (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(), std::make_unique<ValueRange>(
+          leftRange->GetLower(), newRightUpper, kLowerAndUpper, isAccurate), &opnd);
+    }
+    newRightRange = std::make_unique<ValueRange>(
+        newRightLower, ValueRange::MaxBound(newRightUpper.GetPrimType()), kLowerAndUpper, isAccurate);
+  } else if (leftRange->GetRangeType() == kOnlyHasUpperBound) {
+    std::unique_ptr<ValueRange> newRightRange = std::make_unique<ValueRange>(
+        ValueRange::MinBound(newRightUpper.GetPrimType()), newRightUpper, kLowerAndUpper, isAccurate);
+    std::unique_ptr<ValueRange> newLeftRange = std::make_unique<ValueRange>(
+        ValueRange::MinBound(newRightUpper.GetPrimType()), leftRange->GetBound(), kLowerAndUpper, isAccurate);
+    newRightRange = std::make_unique<ValueRange>(
+        newRightLower, ValueRange::MaxBound(newRightUpper.GetPrimType()), kLowerAndUpper, isAccurate);
+    (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(),
+                        CombineTwoValueRange(*leftRange, *newRightRange), &opnd);
+  } else {
+    std::unique_ptr<ValueRange> newRightRange = std::make_unique<ValueRange>(
+        ValueRange::MinBound(newRightUpper.GetPrimType()), newRightUpper, kLowerAndUpper, isAccurate);
+    auto resTrueBranchVR = CombineTwoValueRange(*leftRange, *newRightRange);
+    (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(), CopyValueRange(*resTrueBranchVR), &opnd);
+    newRightRange = std::make_unique<ValueRange>(
+        newRightLower, ValueRange::MaxBound(newRightUpper.GetPrimType()), kLowerAndUpper, isAccurate);
+    auto resFalseBranchVR = CombineTwoValueRange(*leftRange, *newRightRange);
+    (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(), CopyValueRange(*resFalseBranchVR), &opnd);
+    if (leftRange->IsConstantLowerAndUpper()) {
+      CreateValueRangeForSubOpnd(opnd, trueBranch, falseBranch, *resTrueBranchVR, *resFalseBranchVR);
+    }
+  }
+}
+
+void ValueRangePropagation::CreateValueRangeForGeOrGt(
+    const MeExpr &opnd, const ValueRange *leftRange, Bound newRightUpper, Bound newRightLower,
+    const BB &trueBranch, const BB &falseBranch, bool isAccurate) {
+  CHECK_FATAL(IsEqualPrimType(newRightUpper.GetPrimType(), newRightLower.GetPrimType()), "must be equal");
+  if (leftRange == nullptr) {
+    std::unique_ptr<ValueRange> newTrueBranchRange = std::make_unique<ValueRange>(newRightLower,
+        ValueRange::MaxBound(newRightUpper.GetPrimType()), kLowerAndUpper, isAccurate);
+    (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(), std::move(newTrueBranchRange), &opnd);
+    std::unique_ptr<ValueRange> newFalseBranchRange = std::make_unique<ValueRange>(
+        ValueRange::MinBound(newRightUpper.GetPrimType()), newRightUpper, kLowerAndUpper, isAccurate);
+    (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(), std::move(newFalseBranchRange), &opnd);
+  } else if (leftRange->GetRangeType() == kOnlyHasLowerBound) {
+    auto newRightRange = std::make_unique<ValueRange>(
+        ValueRange::MinBound(newRightUpper.GetPrimType()), newRightUpper, kLowerAndUpper, isAccurate);
+    (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(),
+                        CombineTwoValueRange(*leftRange, *newRightRange), &opnd);
+  } else if (leftRange->GetRangeType() == kOnlyHasUpperBound) {
+    std::unique_ptr<ValueRange> newRightRange = std::make_unique<ValueRange>(newRightLower,
+        ValueRange::MaxBound(newRightUpper.GetPrimType()), kLowerAndUpper, isAccurate);
+    (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(),
+                        CombineTwoValueRange(*leftRange, *newRightRange), &opnd);
+  } else {
+    std::unique_ptr<ValueRange> newRightRange = std::make_unique<ValueRange>(newRightLower,
+        ValueRange::MaxBound(newRightUpper.GetPrimType()), kLowerAndUpper, isAccurate);
+    (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(),
+        CombineTwoValueRange(*leftRange, *newRightRange), &opnd);
+    newRightRange = std::make_unique<ValueRange>(ValueRange::MinBound(newRightUpper.GetPrimType()), newRightUpper,
+        kLowerAndUpper, isAccurate);
+    (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(),
+                        CombineTwoValueRange(*leftRange, *newRightRange), &opnd);
+  }
+}
+
+// Return true if the lower or upper of leftRange is equal to the bound of rightRange, like this:
+// leftRang: (5, constant) rightRange: (5) ==> return true;
+// leftRang: (constant, 5) rightRange: (5) ==> return true;
+bool ValueRangePropagation::IfTheLowerOrUpperOfLeftRangeEqualToTheRightRange(
+    const ValueRange &leftRange, ValueRange &rightRange, bool isLower) const {
+  bool lowerOrUpperIsEqual = isLower ? leftRange.GetLower().GetConstant() == rightRange.GetBound().GetConstant() :
+      leftRange.GetUpper().GetConstant() == rightRange.GetBound().GetConstant();
+  return leftRange.GetRangeType() == kLowerAndUpper && leftRange.IsConstantLowerAndUpper() &&
+         leftRange.GetLower().GetConstant() < leftRange.GetUpper().GetConstant() && lowerOrUpperIsEqual;
+}
+
+void ValueRangePropagation::CreateValueRangeForNeOrEq(
+    const MeExpr &opnd, const ValueRange *leftRange, ValueRange &rightRange, const BB &trueBranch,
+    const BB &falseBranch) {
+  if (rightRange.GetRangeType() == kEqual) {
+    std::unique_ptr<ValueRange> newTrueBranchRange =
+        std::make_unique<ValueRange>(rightRange.GetBound(), kEqual);
+    auto &opMeExpr = static_cast<const OpMeExpr&>(opnd);
+    if (opMeExpr.GetOp() == OP_zext && rightRange.IsConstant() &&
+        opMeExpr.GetOpnd(0)->GetPrimType() == GetIntegerPrimTypeBySizeAndSign(opMeExpr.GetBitsSize(), false)) {
+      (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetOpnd(0)->GetExprID(), CopyValueRange(*newTrueBranchRange));
+    }
+    (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(), std::move(newTrueBranchRange));
+    if (leftRange == nullptr) {
+      std::unique_ptr<ValueRange> newFalseBranchRange =
+          std::make_unique<ValueRange>(rightRange.GetBound(), kNotEqual);
+      (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(), std::move(newFalseBranchRange));
+    } else if (IfTheLowerOrUpperOfLeftRangeEqualToTheRightRange(*leftRange, rightRange, true)) {
+      // Deal with this case:
+      // leftRang: (5, constant)
+      // rightRange: (5)
+      // ==>
+      // leftRang: (6, constant)
+      Bound newLower;
+      if (CreateNewBoundWhenAddOrSub(OP_add, leftRange->GetLower(), 1, newLower)) {
+        std::unique_ptr<ValueRange> newFalseBranchRange =
+            std::make_unique<ValueRange>(newLower, leftRange->GetUpper(), kLowerAndUpper);
+        (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(), std::move(newFalseBranchRange));
+      }
+    } else if (IfTheLowerOrUpperOfLeftRangeEqualToTheRightRange(*leftRange, rightRange, false)) {
+      // Deal with this case:
+      // leftRang: (constant, 5)
+      // rightRange: (5)
+      // ==>
+      // leftRang: (constant, 4)
+      Bound newUpper;
+      if (CreateNewBoundWhenAddOrSub(OP_sub, leftRange->GetUpper(), 1, newUpper)) {
+        std::unique_ptr<ValueRange> newFalseBranchRange =
+            std::make_unique<ValueRange>(leftRange->GetLower(), newUpper, kLowerAndUpper);
+        (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(), std::move(newFalseBranchRange));
+      }
+    } else if (leftRange->GetRangeType() == kLowerAndUpper) {
+      std::unique_ptr<ValueRange> newFalseBranchRange =
+          std::make_unique<ValueRange>(rightRange.GetBound(), kNotEqual);
+      (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(), std::move(newFalseBranchRange));
+    } else if (leftRange->GetRangeType() == kOnlyHasLowerBound || leftRange->GetRangeType() == kOnlyHasUpperBound) {
+      std::unique_ptr<ValueRange> newFalseBranchRange =
+          std::make_unique<ValueRange>(rightRange.GetBound(), kNotEqual);
+      (void)Insert2Caches(falseBranch.GetBBId(), opnd.GetExprID(), std::move(newFalseBranchRange));
+    }
+  } else if (rightRange.GetRangeType() == kNotEqual) {
+    if (leftRange == nullptr) {
+      std::unique_ptr<ValueRange> newTrueBranchRange =
+          std::make_unique<ValueRange>(rightRange.GetBound(), kNotEqual);
+      (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(), std::move(newTrueBranchRange));
+    } else if (IfTheLowerOrUpperOfLeftRangeEqualToTheRightRange(*leftRange, rightRange, true)) {
+      Bound newLower;
+      if (CreateNewBoundWhenAddOrSub(OP_add, leftRange->GetLower(), 1, newLower)) {
+        std::unique_ptr<ValueRange> newTrueBranchRange =
+            std::make_unique<ValueRange>(newLower, leftRange->GetUpper(), kLowerAndUpper);
+        (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(), std::move(newTrueBranchRange));
+      }
+    } else if (IfTheLowerOrUpperOfLeftRangeEqualToTheRightRange(*leftRange, rightRange, false)) {
+      Bound newUpper;
+      if (CreateNewBoundWhenAddOrSub(OP_sub, leftRange->GetUpper(), 1, newUpper)) {
+        std::unique_ptr<ValueRange> newTrueBranchRange =
+            std::make_unique<ValueRange>(leftRange->GetLower(), newUpper, kLowerAndUpper);
+        (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(), std::move(newTrueBranchRange));
+      }
+    } else if (leftRange->GetRangeType() == kOnlyHasLowerBound || leftRange->GetRangeType() == kOnlyHasUpperBound) {
+      std::unique_ptr<ValueRange> newTrueBranchRange =
+          std::make_unique<ValueRange>(rightRange.GetBound(), kNotEqual);
+      (void)Insert2Caches(trueBranch.GetBBId(), opnd.GetExprID(), std::move(newTrueBranchRange));
+    }
+  }
+}
+
+// Deal with the case like this:
+// if a == 5
+// If the valueRange of a is valuerange(5, kEqual), delete the false branch.
+// Else if the valeuRange of a is valueRange(5, kNotEqual), delete the ture branch.
+bool ValueRangePropagation::ConditionBBCanBeDeletedAfterOPNeOrEq(
+    BB &bb, ValueRange &leftRange, ValueRange &rightRange, BB &falseBranch, BB &trueBranch) {
+  if ((leftRange.GetRangeType() == kEqual && rightRange.GetRangeType() == kEqual) &&
+      leftRange.GetBound().GetVar() == rightRange.GetBound().GetVar()) {
+    if (leftRange.GetBound().GetConstant() == rightRange.GetBound().GetConstant()) {
+      AnalysisUnreachableBBOrEdge(bb, falseBranch, trueBranch);
+      return true;
+    } else {
+      AnalysisUnreachableBBOrEdge(bb, trueBranch, falseBranch);
+      return true;
+    }
+  } else if (leftRange.GetRangeType() == kNotEqual && rightRange.GetRangeType() == kEqual &&
+             leftRange.GetBound().GetVar() == rightRange.GetBound().GetVar() &&
+             leftRange.GetBound().GetConstant() == rightRange.GetBound().GetConstant()) {
+    AnalysisUnreachableBBOrEdge(bb, trueBranch, falseBranch);
+    return true;
+  }
+  return false;
+}
+
+bool ValueRangePropagation::OnlyHaveCondGotoStmt(BB &bb) const {
+  CHECK_FATAL(!bb.GetMeStmts().empty(), "must not be empty");
+  MeStmt *stmt = bb.GetFirstMe();
+  if (stmt->GetOp() == OP_comment) {
+    stmt = stmt->GetNextMeStmt();
+  }
+  return stmt == bb.GetLastMe();
+}
+
+bool ValueRangePropagation::OnlyHaveOneCondGotoPredBB(const BB &bb, const BB &condGotoBB) const {
+  return bb.GetPred().size() == 1 && bb.GetPred(0) == &condGotoBB;
+}
+
+void ValueRangePropagation::UpdateProfile(BB &pred, BB &bb, const BB &targetBB) const {
+  if (bb.GetKind() != kBBCondGoto || bb.IsMeStmtEmpty() || !bb.GetLastMe()->IsCondBr()) {
+    return;
+  }
+  auto *condGotoStmt = static_cast<CondGotoMeStmt*>(bb.GetLastMe());
+  if (condGotoStmt->GetBranchProb() != kProbLikely && condGotoStmt->GetBranchProb() != kProbUnlikely) {
+    return; // need not update profile
+  }
+  int32 targetBranchProb = 0;
+  if (&targetBB == bb.GetSucc(0)) {
+    targetBranchProb = CondGotoNode::probAll - condGotoStmt->GetBranchProb();
+  } else {
+    ASSERT(&targetBB == bb.GetSucc(1), "must equal");
+    targetBranchProb = condGotoStmt->GetBranchProb();
+  }
+  BB *predCondGoto = &pred;
+  BB *succBB = &bb; // succ of predCondGoto to targetBB
+  while (predCondGoto != nullptr) {
+    if (predCondGoto->GetKind() == kBBCondGoto) {
+      break;
+    }
+    if (predCondGoto->GetPred().size() != 1) {
+      predCondGoto = nullptr;
+      break;
+    }
+    succBB = predCondGoto;
+    predCondGoto = predCondGoto->GetPred(0);
+  }
+  if (!predCondGoto || predCondGoto->IsMeStmtEmpty() || !predCondGoto->GetLastMe()->IsCondBr()) {
+    return;
+  }
+  auto *targetCondGotoStmt = static_cast<CondGotoMeStmt*>(predCondGoto->GetLastMe());
+  if (targetCondGotoStmt->GetBranchProb() == kProbUnlikely || targetCondGotoStmt->GetBranchProb() == kProbLikely) {
+    return;
+  }
+  int size = predCondGoto->GetSuccIndex(*succBB);
+  ASSERT(size != -1, "must find");
+  if (size == 1) {
+    targetCondGotoStmt->SetBranchProb(targetBranchProb);
+  } else {
+    targetCondGotoStmt->SetBranchProb(CondGotoNode::probAll - targetBranchProb);
+  }
+  return;
+}
+
+// If the pred vector of false branch only have one bb, delete the false branch:
+//       condGotoBB          condGotoBB
+//            |                   |
+//           / \     ---->        |
+//          /   \                 |
+//       false  true             true
+// else remove the false branch from the succ vecotr of condGotoBB:
+//    bb    condGotoBB         bb   condGotoBB
+//      \       |               |       |
+//       \     / \     ---->    |       |
+//        \   /   \             |       |
+//        false  true          false   true
+void ValueRangePropagation::RemoveUnreachableBB(
+    BB &condGotoBB, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+    std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr) {
+  CHECK_FATAL(condGotoBB.GetSucc().size() == kNumOperands, "must have 2 succ");
+  auto *succ0 = condGotoBB.GetSucc(0);
+  auto *succ1 = condGotoBB.GetSucc(1);
+  if (succ0 == &trueBranch) {
+    if (OnlyHaveOneCondGotoPredBB(*succ1, condGotoBB)) {
+      AnalysisUnreachableBBOrEdge(condGotoBB, *succ1, trueBranch);
+    } else {
+      if (condGotoBB.GetPred().size() == 1) {
+        UpdateProfile(*condGotoBB.GetPred(0), condGotoBB, trueBranch);
+      }
+      condGotoBB.SetKind(kBBFallthru);
+      condGotoBB.RemoveSucc(*succ1);
+      DeleteThePhiNodeWhichOnlyHasOneOpnd(*succ1, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+      condGotoBB.RemoveMeStmt(condGotoBB.GetLastMe());
+    }
+  } else {
+    if (OnlyHaveOneCondGotoPredBB(*succ0, condGotoBB)) {
+      AnalysisUnreachableBBOrEdge(condGotoBB, *succ0, trueBranch);
+    } else {
+      if (condGotoBB.GetPred().size() == 1) {
+        UpdateProfile(*condGotoBB.GetPred(0), condGotoBB, trueBranch);
+      }
+      condGotoBB.SetKind(kBBFallthru);
+      if (func.GetCfg()->UpdateCFGFreq()) {
+        condGotoBB.SetSuccFreq(0, condGotoBB.GetSuccFreq()[1]);
+      }
+      condGotoBB.RemoveSucc(*succ0);
+      DeleteThePhiNodeWhichOnlyHasOneOpnd(*succ0, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+      condGotoBB.RemoveMeStmt(condGotoBB.GetLastMe());
+    }
+  }
+}
+
+BB *ValueRangePropagation::CreateNewGotoBBWithoutCondGotoStmt(BB &bb) {
+  if (CodeSizeIsOverflowOrTheOpOfStmtIsNotSupported(bb)) {
+    return nullptr;
+  }
+  BB *newBB = func.GetCfg()->NewBasicBlock();
+  ResizeWhenCreateNewBB();
+  CopyMeStmts(bb, *newBB);
+  /* create at least one gotoBB in the new loop to facilitate WontExitAnalysis */
+  newBB->SetKind(kBBGoto);
+  return newBB;
+}
+
+void ValueRangePropagation::CopyMeStmts(BB &fromBB, BB &toBB) {
+  if (fromBB.GetMeStmts().empty()) {
+    return;
+  }
+  /* Do not copy the last stmt of condGoto and Goto BB */
+  bool copyWithoutLastStmt = false;
+  if (fromBB.GetKind() == kBBCondGoto || fromBB.GetKind() == kBBGoto) {
+    copyWithoutLastStmt = true;
+  } else if (fromBB.GetKind() == kBBFallthru) {
+    copyWithoutLastStmt = false;
+  } else {
+    CHECK_FATAL(false, "must be condGoto, goto or fallthru bb");
+  }
+  func.CloneBBMeStmts(fromBB, toBB, &cands, copyWithoutLastStmt);
+  needUpdateSSA = true;
+}
+
+size_t ValueRangePropagation::GetRealPredSize(const BB &bb) const {
+  size_t unreachablePredSize = 0;
+  for (auto &pred : bb.GetPred()) {
+    if (unreachableBBs.find(pred) != unreachableBBs.end()) {
+      unreachablePredSize++;
+    }
+  }
+  auto res = bb.GetPred().size() - unreachablePredSize;
+  return res;
+}
+
+void ValueRangePropagation::CreateLabelForTargetBB(BB &pred, BB &newBB) {
+  if (pred.GetLastMe() == nullptr) {
+    return;
+  }
+  switch (pred.GetKind()) {
+    case kBBGoto:
+      static_cast<GotoMeStmt*>(pred.GetLastMe())->SetOffset(func.GetOrCreateBBLabel(newBB));
+      break;
+    case kBBIgoto:
+      CHECK_FATAL(false, "can not be here");
+    case kBBCondGoto: {
+      auto *condGotoStmt = static_cast<CondGotoMeStmt *>(pred.GetLastMe());
+      ASSERT_NOT_NULL(condGotoStmt);
+      if (&newBB == pred.GetSucc().at(1)) {
+        condGotoStmt->SetOffset(func.GetOrCreateBBLabel(newBB));
+      }
+      break;
+    }
+    case kBBSwitch: {
+      auto *switchStmt = static_cast<SwitchMeStmt*>(pred.GetLastMe());
+      ASSERT_NOT_NULL(switchStmt);
+      LabelIdx oldLabIdx = pred.GetBBLabel();
+      LabelIdx label = func.GetOrCreateBBLabel(newBB);
+      if (switchStmt->GetDefaultLabel() == oldLabIdx) {
+        switchStmt->SetDefaultLabel(label);
+      }
+      for (size_t i = 0; i < switchStmt->GetSwitchTable().size(); i++) {
+        LabelIdx labelIdx = switchStmt->GetSwitchTable().at(i).second;
+        if (labelIdx == oldLabIdx) {
+          switchStmt->SetCaseLabel(i, label);
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+size_t ValueRangePropagation::FindBBInSuccs(const BB &bb, const BB &succBB) const {
+  for (size_t i = 0; i < bb.GetSucc().size(); ++i) {
+    if (bb.GetSucc(i) == &succBB) {
+      return i;
+    }
+  }
+  CHECK_FATAL(false, "find fail");
+}
+
+void ValueRangePropagation::ComputeCodeSize(const MeExpr &meExpr, uint32 &cost) {
+  for (uint8 i = 0; i < meExpr.GetNumOpnds(); ++i) {
+    cost++;
+    ComputeCodeSize(*(meExpr.GetOpnd(i)), cost);
+  }
+}
+
+void ValueRangePropagation::ComputeCodeSize(const MeStmt &meStmt, uint32 &cost) {
+  for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); ++i) {
+    cost++;
+    ComputeCodeSize(*meStmt.GetOpnd(i), cost);
+  }
+}
+
+bool ValueRangePropagation::CodeSizeIsOverflowOrTheOpOfStmtIsNotSupported(const BB &bb) {
+  auto *currBB = &bb;
+  uint32 currCost = 0;
+  // When the succ of pred0 can be optimized to succ0, need copy the fallthru bbs and compute the code size of stmts.
+  // pred0  pred1                 pred0    pred1
+  //     \ /                        |       |
+  //      |                         |       |
+  //  fallthru0                    copy  fallthru0
+  //      |                         |       |
+  //  fallthru1      ----->         |    fallthru1
+  //      |                         |       |
+  //   condgoto                      \    condgoto
+  //     / \                           \    / \
+  // succ0 succ1                      succ0  succ1
+
+  while (currBB != nullptr) {
+    for (auto &meStmt : currBB->GetMeStmts()) {
+      if (!IsSupportedOpForCopyInPhasesLoopUnrollAndVRP(meStmt.GetOp())) {
+        return true;
+      }
+      if (meStmt.GetOp() == OP_goto || meStmt.GetOp() == OP_brfalse || meStmt.GetOp() == OP_brtrue) {
+        continue;
+      }
+      ComputeCodeSize(meStmt, currCost);
+    }
+    if (currBB->GetKind() == kBBCondGoto) {
+      break;
+    }
+    currBB = currBB->GetSucc(0);
+  }
+  auto codeSizeLimit = MeOption::optForSize ? 0 : kCodeSizeLimit;
+  if (currCost > codeSizeLimit) {
+    if (ValueRangePropagation::isDebug) {
+      LogInfo::MapleLogger() << "code size is overflow\n";
+    }
+    return true;
+  } else {
+    codeSizeCost += currCost;
+    return false;
+  }
+}
+
+bool ValueRangePropagation::ChangeTheSuccOfPred2TrueBranch(
+    BB &pred, BB &bb, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+    std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr) {
+  auto *exitCopyFallthru = GetNewCopyFallthruBB(trueBranch, bb);
+  if (exitCopyFallthru != nullptr) {
+    PrepareForSSAUpdateWhenPredBBIsRemoved(pred, bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+    size_t index = FindBBInSuccs(pred, bb);
+    uint64 edgeFreq = 0;
+    if (func.GetCfg()->UpdateCFGFreq()) {
+      edgeFreq = pred.GetSuccFreq()[index];
+    }
+    pred.RemoveSucc(bb);
+    DeleteThePhiNodeWhichOnlyHasOneOpnd(bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+    pred.AddSucc(*exitCopyFallthru, index);
+    CreateLabelForTargetBB(pred, *exitCopyFallthru);
+    if (func.GetCfg()->UpdateCFGFreq()) {
+      exitCopyFallthru->SetFrequency(exitCopyFallthru->GetFrequency() + edgeFreq);
+      pred.AddSuccFreq(edgeFreq, index);
+      // update bb frequency
+      ASSERT(bb.GetFrequency() >= edgeFreq, "sanity check");
+      bb.SetFrequency(bb.GetFrequency() - edgeFreq);
+      bb.UpdateEdgeFreqs();
+    }
+    return true;
+  }
+  if (CodeSizeIsOverflowOrTheOpOfStmtIsNotSupported(bb)) {
+    return false;
+  }
+  auto *mergeAllFallthruBBs = CreateNewGotoBBWithoutCondGotoStmt(bb);
+  if (mergeAllFallthruBBs == nullptr) {
+    return false;
+  }
+  if (ValueRangePropagation::isDebug) {
+    LogInfo::MapleLogger() << "old: " << pred.GetBBId() << " new: " << mergeAllFallthruBBs->GetBBId() << "\n";
+  }
+  auto *currBB = &bb;
+  BB *predOfCurrBB = nullptr;
+  while (currBB->GetKind() != kBBCondGoto) {
+    if (currBB->GetKind() != kBBFallthru && currBB->GetKind() != kBBGoto) {
+      CHECK_FATAL(false, "must be fallthru or goto bb");
+    }
+    predOfCurrBB = currBB;
+    currBB = currBB->GetSucc(0);
+    CopyMeStmts(*currBB, *mergeAllFallthruBBs);
+    PrepareForSSAUpdateWhenPredBBIsRemoved(
+        *predOfCurrBB, *currBB, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+  }
+  if (predOfCurrBB != nullptr) {
+    PrepareForSSAUpdateWhenPredBBIsRemoved(
+        *predOfCurrBB, *currBB, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+  }
+  CHECK_FATAL(currBB->GetKind() == kBBCondGoto, "must be condgoto bb");
+  auto *gotoMeStmt = irMap.New<GotoMeStmt>(func.GetOrCreateBBLabel(trueBranch));
+  mergeAllFallthruBBs->AddMeStmtLast(gotoMeStmt);
+  PrepareForSSAUpdateWhenPredBBIsRemoved(pred, bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+  size_t index = FindBBInSuccs(pred, bb);
+  uint64 edgeFreq = 0;
+  if (func.GetCfg()->UpdateCFGFreq()) {
+    edgeFreq = pred.GetSuccFreq()[index];
+  }
+  pred.RemoveSucc(bb);
+  pred.AddSucc(*mergeAllFallthruBBs, index);
+  if (func.GetCfg()->UpdateCFGFreq()) {
+    mergeAllFallthruBBs->SetFrequency(edgeFreq);
+    mergeAllFallthruBBs->PushBackSuccFreq(edgeFreq);
+    pred.AddSuccFreq(edgeFreq, index);
+    // update bb frequency
+    if (bb.GetFrequency() >= edgeFreq) {
+      bb.SetFrequency(bb.GetFrequency() - edgeFreq);
+      bb.UpdateEdgeFreqs();
+    }
+  }
+  mergeAllFallthruBBs->AddSucc(trueBranch);
+  DeleteThePhiNodeWhichOnlyHasOneOpnd(bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+  CreateLabelForTargetBB(pred, *mergeAllFallthruBBs);
+  return true;
+}
+
+// If the valuerange of opnd in pred0 and pred1 is equal the valuerange in true branch:
+//      pred0                                pred0                                 pred0
+//        |                                   |                                      |
+//        |                                   |                                      |
+//        bb  pred1                          bb      pred1                           bb     pred1
+//         \  /                               |        |                             |        |
+//          \/                                |        |                             |        |
+//          bb0  [fallthru/goto]           bb0(copy)  bb0                         bb0(copy)  bb0
+//          |                    case1        |        |            case2            |        |
+//          bb1 [fallthru/goto] ------>    bb1(copy)   bb1        -------->       bb1(copy)   bb1
+//          |                                 |        |                             |        |
+//          bb2 [condgoto]                    |        bb2 [condgoto]                |        bb2 [fallthru]
+//          /\                                 \     / |                             |        |
+//         /  \                                 \   /  |                             |        |
+//      true  false                             true false                         true     false
+bool ValueRangePropagation::CopyFallthruBBAndRemoveUnreachableEdge(
+    BB &pred, BB &bb, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+    std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr) {
+  /* case1: the number of branches reaching to condBB > 1 */
+  auto *tmpPred = &pred;
+  do {
+    tmpPred = tmpPred->GetSucc(0);
+    if (GetRealPredSize(*tmpPred) > 1) {
+      return ChangeTheSuccOfPred2TrueBranch(
+          pred, bb, trueBranch, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+    }
+  } while (tmpPred->GetKind() != kBBCondGoto);
+  if (GetRealPredSize(bb) != 1) {
+    return false;
+  }
+  // step2
+  auto *currBB = &bb;
+  while (currBB->GetKind() != kBBCondGoto) {
+    currBB = currBB->GetSucc(0);
+  }
+  /* case2: the number of branches reaching to condBB == 1 */
+  RemoveUnreachableBB(*currBB, trueBranch, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+  return true;
+}
+
+// If the valuerange of opnd in pred0 and pred1 is equal the valuerange in true branch:
+//     pred0   pred1                        pred0    pred1                         pred0    pred1
+//         \  /                               |        |                             |        |
+//          \/                case1           |        |                case2        |        |
+//          bb2 [condgoto]   ------->         |        bb2 [condgoto]  ------->      |        bb2 [fallthru]
+//          /\                                 \     / |                             |        |
+//         /  \                                 \   /  |                             |        |
+//      true  false                             true false                         true     false
+// case1: the number of branches reaching to condBB > 1
+// case2: the number of branches reaching to condBB == 1
+bool ValueRangePropagation::RemoveTheEdgeOfPredBB(
+    BB &pred, BB &bb, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+    std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr) {
+  CHECK_FATAL(bb.GetKind() == kBBCondGoto, "must be condgoto bb");
+  if (GetRealPredSize(bb) < kNumOperands) {
+    CHECK_FATAL(GetRealPredSize(bb) == 1, "must have one pred");
+    RemoveUnreachableBB(bb, trueBranch, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+    return true;
+  }
+  if (OnlyHaveCondGotoStmt(bb)) {
+    PrepareForSSAUpdateWhenPredBBIsRemoved(pred, bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+    size_t index = FindBBInSuccs(pred, bb);
+    uint64 edgeFreq = 0;
+    if (func.GetCfg()->UpdateCFGFreq()) {
+      edgeFreq = pred.GetSuccFreq()[index];
+      ASSERT(bb.GetFrequency() >= edgeFreq, "sanity check");
+    }
+    pred.RemoveSucc(bb);
+    DeleteThePhiNodeWhichOnlyHasOneOpnd(bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+    pred.AddSucc(trueBranch, index);
+    CreateLabelForTargetBB(pred, trueBranch);
+    if (func.GetCfg()->UpdateCFGFreq()) {
+      if (bb.GetFrequency() > edgeFreq) {
+        bb.SetFrequency(static_cast<uint32>(bb.GetFrequency() - edgeFreq));
+        size_t trueBranchIdx = static_cast<uint32>(bb.GetSuccIndex(trueBranch));
+        int64_t updatedtrueFreq = static_cast<int64_t>(bb.GetSuccFreq()[trueBranchIdx] - static_cast<uint64>(edgeFreq));
+        // transform may not be consistent with frequency value
+        updatedtrueFreq = updatedtrueFreq > 0 ? updatedtrueFreq : 0;
+        bb.SetSuccFreq(static_cast<int>(trueBranchIdx), static_cast<uint64>(updatedtrueFreq));
+      }
+      pred.AddSuccFreq(static_cast<uint64>(edgeFreq), index);
+    }
+  } else {
+    auto *exitCopyFallthru = GetNewCopyFallthruBB(trueBranch, bb);
+    if (exitCopyFallthru != nullptr) {
+      PrepareForSSAUpdateWhenPredBBIsRemoved(pred, bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+      size_t index = FindBBInSuccs(pred, bb);
+      uint64 edgeFreq = 0;
+      if (func.GetCfg()->UpdateCFGFreq()) {
+        edgeFreq = pred.GetSuccFreq()[index];
+        ASSERT(bb.GetFrequency() >= edgeFreq, "sanity check");
+      }
+      pred.RemoveSucc(bb);
+      DeleteThePhiNodeWhichOnlyHasOneOpnd(bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+      pred.AddSucc(*exitCopyFallthru, index);
+      CreateLabelForTargetBB(pred, *exitCopyFallthru);
+      if (func.GetCfg()->UpdateCFGFreq()) {
+        if (bb.GetFrequency() > edgeFreq) {
+          bb.SetFrequency(static_cast<uint32>(bb.GetFrequency() - edgeFreq));
+          exitCopyFallthru->SetFrequency(static_cast<uint32>(edgeFreq));
+          exitCopyFallthru->PushBackSuccFreq(static_cast<uint64>(edgeFreq));
+          size_t trueBranchIdx = static_cast<uint32>(bb.GetSuccIndex(trueBranch));
+          int64_t updatedtrueFreq = static_cast<int64_t>(
+              bb.GetSuccFreq()[trueBranchIdx] - static_cast<uint64>(edgeFreq));
+          ASSERT(updatedtrueFreq >= 0, "sanity check");
+          bb.SetSuccFreq(static_cast<int>(trueBranchIdx), static_cast<uint64>(updatedtrueFreq));
+        }
+        pred.AddSuccFreq(static_cast<uint64>(edgeFreq), index);
+      }
+      return true;
+    }
+    auto *newBB = CreateNewGotoBBWithoutCondGotoStmt(bb);
+    if (newBB == nullptr) {
+      return false;
+    }
+    if (ValueRangePropagation::isDebug) {
+      LogInfo::MapleLogger() << "old: " << pred.GetBBId() << " new: " << newBB->GetBBId() << "\n";
+    }
+    auto *gotoMeStmt = irMap.New<GotoMeStmt>(func.GetOrCreateBBLabel(trueBranch));
+    newBB->AddMeStmtLast(gotoMeStmt);
+    PrepareForSSAUpdateWhenPredBBIsRemoved(pred, bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+    size_t index = FindBBInSuccs(pred, bb);
+    uint64 edgeFreq = 0;
+    if (func.GetCfg()->UpdateCFGFreq()) {
+      edgeFreq = pred.GetSuccFreq()[index];
+      ASSERT(bb.GetFrequency() >= edgeFreq, "sanity check");
+    }
+    pred.RemoveSucc(bb);
+    pred.AddSucc(*newBB, index);
+    newBB->AddSucc(trueBranch);
+    if (func.GetCfg()->UpdateCFGFreq()) {
+      if (bb.GetFrequency() > edgeFreq) {
+        bb.SetFrequency(static_cast<uint32>(bb.GetFrequency() - edgeFreq));
+        bb.UpdateEdgeFreqs();
+      }
+      newBB->SetFrequency(static_cast<uint32>(edgeFreq));
+      newBB->PushBackSuccFreq(static_cast<uint64>(edgeFreq));
+      pred.AddSuccFreq(static_cast<uint64>(edgeFreq), index);
+    }
+    DeleteThePhiNodeWhichOnlyHasOneOpnd(bb, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+    (void)func.GetOrCreateBBLabel(trueBranch);
+    CreateLabelForTargetBB(pred, *newBB);
+  }
+  return true;
+}
+
+// tmpPred, tmpBB, reachableBB
+bool ValueRangePropagation::RemoveUnreachableEdge(
+    BB &pred, BB &bb, BB &trueBranch, ScalarMeExpr *updateSSAExceptTheScalarExpr,
+    std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr) {
+  if (onlyPropVR) {
+    return false;
+  }
+  if (bb.GetKind() == kBBFallthru || bb.GetKind() == kBBGoto) {
+    if (!CopyFallthruBBAndRemoveUnreachableEdge(
+        pred, bb, trueBranch, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr)) {
+      return false;
+    }
+  } else {
+    if (!RemoveTheEdgeOfPredBB(pred, bb, trueBranch, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr)) {
+      return false;
+    }
+  }
+  if (ValueRangePropagation::isDebug) {
+    LogInfo::MapleLogger() << "===========delete edge " << pred.GetBBId() << " " << bb.GetBBId() << " " <<
+        trueBranch.GetBBId() << "===========\n";
+  }
+  if (trueBranch.GetPred().size() > 1) {
+    (void)func.GetOrCreateBBLabel(trueBranch);
+  }
+  isCFGChange = true;
+  return true;
+}
+
+bool ValueRangePropagation::ConditionEdgeCanBeDeleted(BB &pred, BB &bb, const ValueRange *leftRange,
+    const ValueRange *rightRange, BB &falseBranch, BB &trueBranch, PrimType opndType, Opcode op,
+    ScalarMeExpr *updateSSAExceptTheScalarExpr, std::map<OStIdx, std::set<BB*>> &ssaupdateCandsForCondExpr) {
+  if (leftRange == nullptr || rightRange == nullptr) {
+    return false;
+  }
+  if (ValueRangePropagation::isDebug) {
+    LogInfo::MapleLogger() << "try to delete edge " << pred.GetBBId() << " " << bb.GetBBId() << " " <<
+        trueBranch.GetBBId() << "\n";
+  }
+  /* Find the first bb with more than one pred */
+  auto *tmpPred = &pred;
+  auto *tmpBB = &bb;
+  while (GetRealPredSize(*tmpBB) == 1 && tmpBB->GetKind() != kBBCondGoto) {
+    tmpPred = tmpBB;
+    tmpBB = tmpBB->GetSucc(0);
+  }
+  Opcode antiOp = GetTheOppositeOp(op);
+  if (BrStmtInRange(bb, *leftRange, *rightRange, op, opndType)) {
+    // opnd, tmpPred, tmpBB, reachableBB
+    // remove falseBranch
+    UpdateProfile(*tmpPred, *tmpBB, trueBranch);
+    return RemoveUnreachableEdge(
+        *tmpPred, *tmpBB, trueBranch, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+  } else if (BrStmtInRange(bb, *leftRange, *rightRange, antiOp, opndType)) {
+    UpdateProfile(*tmpPred, *tmpBB, falseBranch);
+    return RemoveUnreachableEdge(
+        *tmpPred, *tmpBB, falseBranch, updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr);
+  }
+  return false;
+}
+
+bool ValueRangePropagation::MustBeFallthruOrGoto(const BB &defBB, const BB &bb) const {
+  if (&defBB == &bb) {
+    return true;
+  }
+  auto *currBB = &defBB;
+  while (currBB->GetSucc().size() == 1) {
+    if (currBB == &bb) {
+      return true;
+    }
+    currBB = currBB->GetSucc(0);
+  }
+  return false;
+}
+
+std::unique_ptr<ValueRange> ValueRangePropagation::AntiValueRange(ValueRange &valueRange) {
+  RangeType oldType = valueRange.GetRangeType();
+  if (oldType != kEqual && oldType != kNotEqual) {
+    return nullptr;
+  }
+  RangeType newType = (oldType == kEqual) ? kNotEqual : kEqual;
+  return std::make_unique<ValueRange>(Bound(valueRange.GetBound().GetVar(), valueRange.GetBound().GetConstant(),
+      valueRange.GetBound().GetPrimType()), newType);
+}
+
+void ValueRangePropagation::DeleteUnreachableBBs(BB &curBB, BB &falseBranch, BB &trueBranch) {
+  size_t sizeOfUnreachables = 0;
+  for (auto &pred : curBB.GetPred()) {
+    if (unreachableBBs.find(pred) != unreachableBBs.end()) {
+      sizeOfUnreachables++;
+    }
+  }
+  if (curBB.GetPred().size() - sizeOfUnreachables == 0) {
+    // If the preds of curBB which is condgoto and analysised is empty, delete the curBB.
+    Insert2UnreachableBBs(curBB);
+    // If the preds of falseBranch is empty, delete the falseBranch.
+    if (falseBranch.GetPred().size() == 1 && falseBranch.GetPred(0) == &curBB) {
+      Insert2UnreachableBBs(falseBranch);
+    }
+    // If the preds of trueBranch is empty, delete the trueBranch.
+    if (trueBranch.GetPred().size() == 1 && trueBranch.GetPred(0) == &curBB) {
+      Insert2UnreachableBBs(trueBranch);
+    }
+  }
+}
+
+void ValueRangePropagation::PropValueRangeFromCondGotoToTrueAndFalseBranch(
+    const MeExpr &opnd0, ValueRange &rightRange, const BB &falseBranch, const BB &trueBranch) {
+  std::unique_ptr<ValueRange> trueBranchValueRange;
+  std::unique_ptr<ValueRange> falseBranchValueRange;
+  trueBranchValueRange = CopyValueRange(rightRange);
+  falseBranchValueRange = AntiValueRange(rightRange);
+  (void)Insert2Caches(trueBranch.GetBBId(), opnd0.GetExprID(), std::move(trueBranchValueRange));
+  (void)Insert2Caches(falseBranch.GetBBId(), opnd0.GetExprID(), std::move(falseBranchValueRange));
+}
+
+// a: phi(b, c); d: a; e: d
+// currOpnd: e
+// predOpnd: a, rhs of currOpnd in this bb
+// phiOpnds: (b, c), phi rhs of opnd in this bb
+// predOpnd or phiOpnds is uesd to find the valuerange in the pred of bb
+void ValueRangePropagation::ReplaceOpndByDef(const BB &bb, MeExpr &currOpnd, MeExpr *&predOpnd,
+    MePhiNode *&phi, bool &thePhiIsInBB) {
+  /* If currOpnd is not defined in bb, set opnd to currOpnd */
+  predOpnd = &currOpnd;
+  /* find the rhs of opnd */
+  while ((predOpnd->GetMeOp() == kMeOpVar || predOpnd->GetMeOp() == kMeOpReg) &&
+         static_cast<ScalarMeExpr&>(*predOpnd).GetDefBy() == kDefByStmt &&
+         static_cast<ScalarMeExpr&>(*predOpnd).GetDefStmt()->GetBB() == &bb) {
+    predOpnd = static_cast<ScalarMeExpr&>(*predOpnd).GetDefStmt()->GetRHS();
+  }
+  /* find the phi rhs of opnd */
+  if ((predOpnd->GetMeOp() == kMeOpVar || predOpnd->GetMeOp() == kMeOpReg) &&
+      static_cast<ScalarMeExpr&>(*predOpnd).GetDefBy() == kDefByPhi &&
+      static_cast<ScalarMeExpr&>(*predOpnd).GetDefPhi().GetDefBB() == &bb) {
+    phi = &(static_cast<ScalarMeExpr&>(*predOpnd).GetDefPhi());
+    thePhiIsInBB = true;
+  }
+}
+
+// Find the version expr(a2) of a3 in pred bb.
+// If find failed, return expr a3.
+//   pred1(a1) pred(a2)
+//         \  /
+//        succ0(a3 = phi(a1,a2))
+//          |
+//        succ1
+//          |
+//          bb if (a3)
+MeExpr &ValueRangePropagation::GetVersionOfOpndInPred(const BB &pred, const BB &bb, MeExpr &expr) const {
+  if (!expr.IsScalar()) {
+    return expr;
+  }
+  auto &scalar = static_cast<ScalarMeExpr&>(expr);
+  MeStmt *defStmt = nullptr;
+  auto *defBB = scalar.GetDefByBBMeStmt(*func.GetCfg(), defStmt);
+  if (dom.Dominate(*defBB, pred)) {
+    return expr;
+  }
+  auto ostIndex = scalar.GetOstIdx();
+  auto *curPred = &pred;
+  while (curPred->GetSucc().size() == 1) {
+    auto *succ = curPred->GetSucc(0);
+    if (!succ->GetMePhiList().empty()) {
+      auto it = succ->GetMePhiList().find(ostIndex);
+      if (it != succ->GetMePhiList().end()) {
+        int sizeOfPred = succ->GetPredIndex(*curPred);
+        CHECK_FATAL(sizeOfPred != -1, "must find");
+        return *(it->second->GetOpnd(sizeOfPred));
+      }
+    }
+    if (succ == &bb) {
+      break;
+    }
+  }
+  return expr;
+}
+
+// If expr a2 is assigned with b2 in pred bb, the valueRange of expr (a2 - b2) in pred bb is (0, kEqual).
+//   pred1  pred(a2 = b2)
+//        \  /
+//       succ0(a3 = phi(a1,a2), b3 = phi(b1, b2))
+//         |
+//       succ1
+//         |
+//       bb if (a3 - b3 > constant)
+std::unique_ptr<ValueRange> ValueRangePropagation::GetValueRangeOfLHS(const BB &pred, const BB &bb,
+                                                                      MeExpr &expr) const {
+  if (expr.GetMeOp() != kMeOpOp || expr.GetOp() != OP_sub) {
+    return nullptr;
+  }
+  auto &opMeExpr = static_cast<OpMeExpr&>(expr);
+  auto *opnd0 = opMeExpr.GetOpnd(0);
+  auto *opnd1 = opMeExpr.GetOpnd(1);
+  auto &versionOpnd0InPred = GetVersionOfOpndInPred(pred, bb, *opnd0);
+  auto &versionOpnd1InPred = GetVersionOfOpndInPred(pred, bb, *opnd1);
+  // If the vr of versionOpnd0InPred is equal to the vr of versionOpnd1InPred in pred.
+  if (FindPairOfExprs(versionOpnd0InPred, versionOpnd1InPred, pred)) {
+    return CreateValueRangeOfEqualZero(PTY_u1);
+  }
+  return nullptr;
+}
+
+bool ValueRangePropagation::TowCompareOperandsAreInSameIterOfLoop(const MeExpr &lhs, const MeExpr &rhs) const {
+  if (!lhs.IsScalar() || !rhs.IsScalar()) {
+    return false;
+  }
+  auto &lhsScalar = static_cast<const ScalarMeExpr&>(lhs);
+  auto &rhsScalar = static_cast<const ScalarMeExpr&>(rhs);
+  MeStmt *defStmt = nullptr;
+  auto *lhsDefBB = lhsScalar.GetDefByBBMeStmt(*func.GetCfg(), defStmt);
+  auto *rhsDefBB = rhsScalar.GetDefByBBMeStmt(*func.GetCfg(), defStmt);
+  auto *loopOfLHS = loops->GetBBLoopParent(lhsDefBB->GetBBId());
+  auto *loopOfRHS = loops->GetBBLoopParent(rhsDefBB->GetBBId());
+  if (loopOfLHS != nullptr && loopOfLHS == loopOfRHS) {
+    // Two compare operands(tmp and var) are not in same iter of loop, so can not opt bb4 connected with bb4.
+    // bb0: do
+    // bb1:   tmp = a + b
+    // bb2:   if tmp < var
+    // bb3:     ...
+    // bb4:   var = tmp
+    // bb5: while ()
+    return false;
+  }
+  return true;
+}
+
+bool ValueRangePropagation::AnalysisValueRangeInPredsOfCondGotoBB(
+    BB &bb, MeExpr *opnd0, MeExpr &currOpnd, ValueRange *rightRange,
+    BB &falseBranch, BB &trueBranch, PrimType opndType, Opcode op, BB &condGoto) {
+  bool opt = false;
+  /* Records the currOpnd of pred */
+  MeExpr *predOpnd = nullptr;
+  bool thePhiIsInBB = false;
+  MapleVector<ScalarMeExpr*> phiOpnds(mpAllocator.Adapter());
+  MePhiNode *phi = nullptr;
+  MeExpr *realCurrOpnd = &currOpnd;
+  // Deal with the case like:
+  // if cvt(i64 u32(opnd)) != 1
+  // If the value ranges of opnd before cvt and after cvt are equal to each other, use the opnd to opt the if stmt.
+  if (realCurrOpnd->GetOp() == OP_cvt) {
+    auto *opMeExpr = static_cast<OpMeExpr*>(realCurrOpnd);
+    auto *opnd = opMeExpr->GetOpnd(0);
+    auto *valueRangeOfOpnd = FindValueRangeAndInitNumOfRecursion(bb, *opnd);
+    if (valueRangeOfOpnd != nullptr && valueRangeOfOpnd->IsConstantLowerAndUpper()) {
+      auto toType = opMeExpr->GetPrimType();
+      auto fromType = opMeExpr->GetOpndType();
+      if (valueRangeOfOpnd->IsEqualAfterCVT(fromType, toType)) {
+        realCurrOpnd = opnd;
+      }
+    }
+  }
+  // If the value ranges of opnd before zext and after zext are equal to each other, use the opnd to opt the if stmt.
+  // The case like:
+  // VAR:%_160__levVar_116_0{offset:0}<0>[idx:5] mx341 = MEPHI{mx340,mx339}
+  // ||MEIR|| brfalse
+  //     cond:  @@s44OP ne u1 u32 mx343
+  //       opnd[0] = OP zext u32 kPtyInvalid mx342
+  //         opnd[0] = VAR %_160__levVar_116_0{offset:0}<0>[idx:5] (field)0 mx341
+  //     opnd[1] = CONST 0 mx96
+  // The realCurrOpnd is mx341 not mx342.
+  if (realCurrOpnd->GetOp() == OP_zext) {
+    auto *opMeExpr = static_cast<OpMeExpr*>(realCurrOpnd);
+    auto *opnd = opMeExpr->GetOpnd(0);
+    auto *valueRangeOfOpnd = FindValueRangeAndInitNumOfRecursion(bb, *opnd);
+    auto *valueRangeOfOpMeExpr = FindValueRangeAndInitNumOfRecursion(bb, *opMeExpr);
+    if (valueRangeOfOpnd != nullptr && valueRangeOfOpMeExpr != nullptr &&
+        valueRangeOfOpnd->IsEqual(valueRangeOfOpMeExpr)) {
+      realCurrOpnd = opnd;
+    }
+  }
+  /* find the rhs of currOpnd, which is used as the currOpnd of pred */
+  ReplaceOpndByDef(bb, *realCurrOpnd, predOpnd, phi, thePhiIsInBB);
+  if (phi != nullptr) {
+    phiOpnds = static_cast<ScalarMeExpr&>(*predOpnd).GetDefPhi().GetOpnds();
+  }
+  size_t indexOfOpnd = 0;
+  ScalarMeExpr *exprOnlyUsedByCondMeStmt = nullptr;
+  std::map<OStIdx, std::set<BB*>> ssaupdateCandsForCondExpr;
+  if (!thePhiIsInBB) {
+    auto *useListOfPredOpnd = useInfo->GetUseSitesOfExpr(predOpnd);
+    if (useListOfPredOpnd != nullptr && useListOfPredOpnd->size() == 1 && useListOfPredOpnd->front().IsUseByStmt()) {
+      auto *useStmt = useListOfPredOpnd->front().GetStmt();
+      ASSERT_NOT_NULL(condGoto.GetLastMe());
+      if (condGoto.GetKind() == kBBCondGoto && condGoto.GetLastMe()->IsCondBr() && condGoto.GetLastMe() == useStmt &&
+          predOpnd->IsScalar()) {
+        // PredOpnd is only used be condGoto stmt, if the condGoto stmt can be deleted, need not update ssa
+        // of predOpnd and the def point of predOpnd can be deleted.
+        exprOnlyUsedByCondMeStmt = static_cast<ScalarMeExpr*>(predOpnd);
+      }
+    }
+  }
+  for (size_t i = 0; i < bb.GetPred().size();) {
+    predOpnd = thePhiIsInBB ? phiOpnds.at(indexOfOpnd) : predOpnd;
+    indexOfOpnd++;
+    ScalarMeExpr *updateSSAExceptTheScalarExpr = nullptr;
+    if (!thePhiIsInBB) {
+      updateSSAExceptTheScalarExpr = exprOnlyUsedByCondMeStmt;
+    } else {
+      auto *useListOfPredOpnd = useInfo->GetUseSitesOfExpr(predOpnd);
+      if (useListOfPredOpnd != nullptr && useListOfPredOpnd->size() == 1) {
+        if (useListOfPredOpnd->front().IsUseByPhi() && useListOfPredOpnd->front().GetPhi() == phi) {
+          auto *useListOfPhi = useInfo->GetUseSitesOfExpr(phi->GetLHS());
+          if (useListOfPhi != nullptr && useListOfPhi->size() == 1 && useListOfPhi->front().IsUseByStmt() &&
+              !useListOfPhi->front().GetStmt()->GetBB()->GetAttributes(kBBAttrIsInLoop)) {
+            auto *useStmt = useListOfPhi->front().GetStmt();
+            if (condGoto.GetKind() == kBBCondGoto && condGoto.GetLastMe()->IsCondBr() &&
+                condGoto.GetLastMe() == useStmt && predOpnd->IsScalar()) {
+              // PredOpnd is only used be the phi and condGoto stmt, if the pred edge can be opt, need not update ssa
+              // of predOpnd and the def point of predOpnd can be deleted.
+              updateSSAExceptTheScalarExpr = static_cast<ScalarMeExpr*>(predOpnd);
+            }
+          }
+        }
+      }
+    }
+    size_t predSize = bb.GetPred().size();
+    auto *pred = bb.GetPred(i);
+    // The infinite loop path does not occur during actual execution and then optimization is not required.
+    if (pred->GetKind() == kBBIgoto || GetRealPredSize(*pred) == 0 ||
+        unreachableBBs.find(pred) != unreachableBBs.end()) {
+      ++i;
+      continue;
+    }
+    // Resolve the scenario where a outside-pointer points to a loop.
+    //   outside-pointer
+    //      \        /
+    //       \      /
+    //      pred   pred1
+    //       ^ \  /
+    //       |  \/
+    //       |  bb [condgoto]
+    //       |  /\
+    //       | /  \
+    //      true  false
+    if (bb.GetBBId() < dom.GetIterDomFrontierSize() && !dom.Dominate(*pred, bb)) {
+      auto &frontier = dom.GetIterDomFrontier(bb.GetID());
+      if (frontier.find(pred->GetID()) != frontier.end()) {
+        ++i;
+        continue;
+      }
+    }
+    auto *valueRangeInPred = FindValueRangeAndInitNumOfRecursion(*pred, *predOpnd);
+    std::unique_ptr<ValueRange> valueRangeInPredPtr = nullptr;
+    if (valueRangeInPred == nullptr) {
+      valueRangeInPredPtr = GetValueRangeOfLHS(*pred, bb, *predOpnd);
+      valueRangeInPred = valueRangeInPredPtr.get();
+    }
+    if (rightRange == nullptr || valueRangeInPred == nullptr) {
+      // If the vr of versionOpnd0InPred is equal to the vr of versionOpnd1InPred in pred.
+      if (opnd0 != nullptr && FindPairOfExprs(*predOpnd, *opnd0, *pred) &&
+          TowCompareOperandsAreInSameIterOfLoop(currOpnd, *opnd0)) {
+        valueRangeInPredPtr = CreateValueRangeOfEqualZero(predOpnd->GetPrimType());
+        valueRangeInPred = valueRangeInPredPtr.get();
+        rightRange = valueRangeInPredPtr.get();
+      }
+    }
+    if (ConditionEdgeCanBeDeleted(*pred, bb, valueRangeInPred, rightRange, falseBranch, trueBranch, opndType, op,
+        updateSSAExceptTheScalarExpr, ssaupdateCandsForCondExpr)) {
+      if (updateSSAExceptTheScalarExpr != nullptr && phi != nullptr) {
+        if (updateSSAExceptTheScalarExpr->GetDefBy() == kDefByStmt) {
+          // PredOpnd is only used by condGoto stmt and phi, if the condGoto stmt can be deleted, need not update ssa
+          // of predOpnd and the def point of predOpnd can be deleted.
+          phiOpnds[indexOfOpnd - 1] = nullptr;
+          bool opndIsRemovedFromPhi =
+              (std::find(phiOpnds.begin(), phiOpnds.end(), updateSSAExceptTheScalarExpr) == phiOpnds.end());
+          if (opndIsRemovedFromPhi) {
+            updateSSAExceptTheScalarExpr->GetDefStmt()->GetBB()->RemoveMeStmt(
+                updateSSAExceptTheScalarExpr->GetDefStmt());
+            updateSSAExceptTheScalarExpr->SetDefBy(kDefByNo);
+          }
+        }
+      }
+      opt = true;
+    } else {
+      /* avoid infinite loop, pred->GetKind() maybe kBBUnknown */
+      if ((pred->GetKind() == kBBFallthru || pred->GetKind() == kBBGoto) &&
+           pred->GetBBId() != falseBranch.GetBBId() && pred->GetBBId() != trueBranch.GetBBId() &&
+           (opnd0 == nullptr || TowCompareOperandsAreInSameIterOfLoop(currOpnd, *opnd0))) {
+        opt |= AnalysisValueRangeInPredsOfCondGotoBB(
+            *pred, opnd0, *predOpnd, rightRange, falseBranch, trueBranch, opndType, op, condGoto);
+      }
+    }
+    if (bb.GetPred().size() == predSize) {
+      ++i;
+    } else if (bb.GetPred().size() != predSize - 1) {
+      CHECK_FATAL(false, "immpossible");
+    }
+  }
+  if (opt) {
+    if (condGoto.GetKind() == kBBCondGoto) {
+      // vrp modified condgoto, branch probability is no longer trustworthy, so we invalidate it
+      ASSERT_NOT_NULL(condGoto.GetLastMe());
+      static_cast<CondGotoMeStmt*>(condGoto.GetLastMe())->InvalidateBranchProb();
+      // If the condGoto stmt can not be deleted, need update the ssa of conditional expr
+      for (auto &pair : ssaupdateCandsForCondExpr) {
+        for (auto &tempBB : pair.second) {
+          MeSSAUpdate::InsertOstToSSACands(pair.first, *tempBB, &cands);
+          needUpdateSSA = true;
+        }
+      }
+    } else if (condGoto.GetKind() == kBBFallthru && exprOnlyUsedByCondMeStmt) {
+      if (exprOnlyUsedByCondMeStmt->GetDefBy() == kDefByStmt) {
+        // PredOpnd is only used by condGoto stmt, if the pred edge can be opt, need not update ssa
+        // of predOpnd and the def point of predOpnd can be deleted.
+        exprOnlyUsedByCondMeStmt->GetDefStmt()->GetBB()->RemoveMeStmt(exprOnlyUsedByCondMeStmt->GetDefStmt());
+        exprOnlyUsedByCondMeStmt->SetDefBy(kDefByNo);
+      }
+    }
+    ReplaceUsePoints(phi);
+  }
+  ssaupdateCandsForCondExpr.clear();
+  return opt;
+}
+
+// If the opnds of phi are the same, delete the phi node and replace use points of phi node with phi opnds.
+// mx13 = phi(mx12, mx12)
+// if mx13
+// ==>
+// if mx12
+void ValueRangePropagation::ReplaceUsePoints(MePhiNode *phi) {
+  if (phi == nullptr || phi->GetDefBB() == nullptr ||
+      phi->GetDefBB()->GetMePhiList().empty() || phi->GetOpnds().empty()) {
+    return;
+  }
+  auto *opnd = phi->GetOpnd(0);
+  for (size_t i = 1; i < phi->GetOpnds().size(); ++i) {
+    if (phi->GetOpnd(i) != opnd) {
+      return;
+    }
+  }
+  auto *lhs = phi->GetLHS();
+  phi->GetDefBB()->GetMePhiList().erase(lhs->GetOstIdx());
+  auto *replaceMeExpr = static_cast<ScalarMeExpr*>(opnd);
+  auto *useListOfPredOpnd = useInfo->GetUseSitesOfExpr(lhs);
+  ASSERT_NOT_NULL(useListOfPredOpnd);
+  for (auto &useItem : *useListOfPredOpnd) {
+    if (useItem.IsUseByPhi()) {
+      auto *usePhi = useItem.GetPhi();
+      for (size_t i = 0; i < useItem.GetPhi()->GetOpnds().size(); ++i) {
+        if (usePhi->GetOpnd(i) != lhs) {
+          continue;
+        }
+        usePhi->SetOpnd(i, replaceMeExpr);
+      }
+    } else {
+      auto *stmt = useItem.GetStmt();
+      irMap.ReplaceMeExprStmt(*stmt, *lhs, *replaceMeExpr);
+    }
+  }
+}
+
+void ValueRangePropagation::GetSizeOfUnreachableBBsAndReachableBB(BB &bb, size_t &unreachableBB, BB *&reachableBB) {
+  for (size_t i = 0; i < bb.GetPred().size(); ++i) {
+    if (unreachableBBs.find(bb.GetPred(i)) != unreachableBBs.end()) {
+      unreachableBB++;
+    } else {
+      reachableBB = bb.GetPred(i);
+    }
+  }
+}
+
+Opcode ValueRangePropagation::GetOpAfterSwapThePositionsOfTwoOperands(Opcode op) const {
+  if (op == OP_eq) {
+    return OP_eq;
+  } else if (op == OP_ne) {
+    return OP_ne;
+  } else if (op == OP_lt) {
+    return OP_gt;
+  } else if (op == OP_le) {
+    return OP_ge;
+  } else if (op == OP_ge) {
+    return OP_le;
+  } else if (op == OP_gt) {
+    return OP_lt;
+  } else {
+    CHECK_FATAL(false, "can not support");
+  }
+}
+
+bool ValueRangePropagation::ConditionEdgeCanBeDeleted(BB &bb, MeExpr &opnd0, ValueRange *rightRange,
+    PrimType opndType, Opcode op) {
+  if (onlyPropVR) {
+    return false;
+  }
+  auto *currOpnd = &opnd0;
+  if (opnd0.GetOp() == OP_zext) {
+    auto &opMeExpr = static_cast<OpMeExpr&>(opnd0);
+    auto *opnd = opMeExpr.GetOpnd(0);
+    if (opMeExpr.GetBitsSize() >= GetPrimTypeBitSize(opnd->GetPrimType())) {
+      currOpnd = opnd;
+    }
+  }
+  if (bb.GetKind() != kBBCondGoto) {
+    return false;
+  }
+  ASSERT_NOT_NULL(bb.GetLastMe());
+  auto *OpMeExpr = static_cast<CondGotoMeStmt*>(bb.GetLastMe())->GetOpnd();
+  auto *opnd1 = (OpMeExpr->GetNumOpnds() == kNumOperands) ? OpMeExpr->GetOpnd(1) : nullptr;
+  BB *trueBranch = nullptr;
+  BB *falseBranch = nullptr;
+  GetTrueAndFalseBranch(static_cast<CondGotoMeStmt*>(bb.GetLastMe())->GetOp(), bb, trueBranch, falseBranch);
+  bool opt = AnalysisValueRangeInPredsOfCondGotoBB(
+      bb, nullptr, *currOpnd, rightRange, *falseBranch, *trueBranch, opndType, op, bb);
+  if (!opt && bb.GetKind() == kBBCondGoto &&
+      static_cast<CondGotoMeStmt*>(bb.GetLastMe())->GetOpnd()->GetNumOpnds() == kNumOperands) {
+    // Swap the positions of two operands like :
+    // ||MEIR|| brfalse
+    //     cond:  @@m25OP lt u1 i32 mx275
+    //          opnd[0] = CONST 0 mx1
+    //          opnd[1] = REGINDX:3 %3 mx92
+    // ==>
+    // ||MEIR|| brfalse
+    //     cond:  @@m25OP gt u1 i32 mx275
+    //          opnd[0] = REGINDX:3 %3 mx92
+    //          opnd[1] = CONST 0 mx1
+
+    auto *valueRangeOfOpnd0 = FindValueRangeAndInitNumOfRecursion(bb, opnd0);
+    opt = AnalysisValueRangeInPredsOfCondGotoBB(bb, currOpnd, *opnd1, valueRangeOfOpnd0, *falseBranch,
+        *trueBranch, opndType, GetOpAfterSwapThePositionsOfTwoOperands(op), bb);
+  }
+  bool canDeleteBB = false;
+  for (size_t i = 0; i < bb.GetPred().size(); ++i) {
+    if (unreachableBBs.find(bb.GetPred(i)) == unreachableBBs.end()) {
+      return opt;
+    }
+    canDeleteBB = true;
+  }
+  if (canDeleteBB) {
+    Insert2UnreachableBBs(bb);
+    isCFGChange = true;
+  }
+  return opt;
+}
+
+Opcode ValueRangePropagation::GetTheOppositeOp(Opcode op) const {
+  if (op == OP_eq) {
+    return OP_ne;
+  } else if (op == OP_ne) {
+    return OP_eq;
+  } else if (op == OP_lt) {
+    return OP_ge;
+  } else if (op == OP_le) {
+    return OP_gt;
+  } else if (op == OP_ge) {
+    return OP_lt;
+  } else if (op == OP_gt) {
+    return OP_le;
+  } else {
+    CHECK_FATAL(false, "can not support");
+  }
+}
+
+void ValueRangePropagation::CreateValueRangeForCondGoto(const MeExpr &opnd, Opcode op, ValueRange *leftRange,
+    ValueRange &rightRange, const BB &trueBranch, const BB &falseBranch) {
+  auto newRightUpper = rightRange.GetUpper();
+  auto newRightLower = rightRange.GetLower();
+  CHECK_FATAL(IsEqualPrimType(newRightUpper.GetPrimType(), newRightLower.GetPrimType()), "must be equal");
+  if (op == OP_eq) {
+    CreateValueRangeForNeOrEq(opnd, leftRange, rightRange, trueBranch, falseBranch);
+  } else if (op == OP_ne) {
+    CreateValueRangeForNeOrEq(opnd, leftRange, rightRange, falseBranch, trueBranch);
+  }
+  if (rightRange.GetRangeType() == kNotEqual) {
+    return;
+  }
+  if ((op == OP_lt) || (op == OP_ge)) {
+    int64 constant = 0;
+    if (!AddOrSubWithConstant(newRightUpper.GetPrimType(), OP_sub, newRightUpper.GetConstant(), 1, constant)) {
+      return;
+    }
+    newRightUpper = Bound(newRightUpper.GetVar(), constant, newRightUpper.GetPrimType());
+  } else if ((op == OP_le) || (op == OP_gt)) {
+    int64 constant = 0;
+    if (!AddOrSubWithConstant(newRightUpper.GetPrimType(), OP_add, newRightLower.GetConstant(), 1, constant)) {
+      return;
+    }
+    newRightLower = Bound(newRightLower.GetVar(), constant, newRightUpper.GetPrimType());
+  }
+  bool isAccurate = dealWithPhi && (rightRange.GetRangeType() == kEqual || rightRange.IsAccurate());
+  if (op == OP_lt || op == OP_le) {
+    if (leftRange != nullptr && leftRange->GetRangeType() == kNotEqual) {
+      CreateValueRangeForLeOrLt(
+          opnd, nullptr, newRightUpper, newRightLower, trueBranch, falseBranch, isAccurate);
+    } else {
+      CreateValueRangeForLeOrLt(opnd, leftRange, newRightUpper, newRightLower, trueBranch, falseBranch, isAccurate);
+    }
+  } else if (op == OP_gt || op == OP_ge) {
+    if (leftRange != nullptr && leftRange->GetRangeType() == kNotEqual) {
+      CreateValueRangeForGeOrGt(
+          opnd, nullptr, newRightUpper, newRightLower, trueBranch, falseBranch, isAccurate);
+    } else {
+      CreateValueRangeForGeOrGt(opnd, leftRange, newRightUpper, newRightLower, trueBranch, falseBranch, isAccurate);
+    }
+  }
+}
+
+void ValueRangePropagation::DealWithCondGoto(
+    BB &bb, Opcode op, ValueRange *leftRange, ValueRange &rightRange, const CondGotoMeStmt &brMeStmt) {
+  MeExpr *opnd0 = nullptr;
+  PrimType primType;
+  if (IsCompareHasReverseOp(brMeStmt.GetOpnd()->GetOp())) {
+    // deal with the stmt like : brfalse ne (a, b)
+    auto *opMeExpr = static_cast<OpMeExpr*>(brMeStmt.GetOpnd());
+    opnd0 = opMeExpr->GetOpnd(0);
+    primType = opMeExpr->GetOpndType();
+  } else {
+    // deal with the stmt like : brfalse (a)
+    opnd0 = brMeStmt.GetOpnd();
+    primType = opnd0->GetPrimType();
+  }
+  BB *trueBranch = nullptr;
+  BB *falseBranch = nullptr;
+  GetTrueAndFalseBranch(brMeStmt.GetOp(), bb, trueBranch, falseBranch);
+  if (onlyPropVR) {
+    CreateValueRangeForCondGoto(*opnd0, op, leftRange, rightRange, *trueBranch, *falseBranch);
+    return;
+  }
+  // When the redundant branch can be inferred directly from the condGoto stmt
+  Opcode antiOp = GetTheOppositeOp(op);
+  if (leftRange != nullptr && BrStmtInRange(bb, *leftRange, rightRange, op, primType)) {
+    // bb, unreachableBB, succBB
+    AnalysisUnreachableBBOrEdge(bb, *falseBranch, *trueBranch);
+  } else if (leftRange != nullptr && BrStmtInRange(bb, *leftRange, rightRange, antiOp, primType)) {
+    AnalysisUnreachableBBOrEdge(bb, *trueBranch, *falseBranch);
+  } else {
+    ConditionEdgeCanBeDeleted(bb, *opnd0, &rightRange, primType, op);
+  }
+  CreateValueRangeForCondGoto(*opnd0, op, leftRange, rightRange, *trueBranch, *falseBranch);
+}
+
+bool ValueRangePropagation::GetValueRangeOfCondGotoOpnd(const BB &bb, OpMeExpr &opMeExpr, MeExpr &opnd,
+    ValueRange *&valueRange, std::unique_ptr<ValueRange> &rightRangePtr) {
+  valueRange = FindValueRangeAndInitNumOfRecursion(bb, opnd);
+  if (valueRange == nullptr) {
+    if (opnd.GetMeOp() == kMeOpConst && static_cast<ConstMeExpr&>(opnd).GetConstVal()->GetKind() == kConstInt) {
+      rightRangePtr = std::make_unique<ValueRange>(Bound(static_cast<ConstMeExpr&>(opnd).GetExtIntValue(),
+          opnd.GetPrimType()), kEqual);
+      valueRange = rightRangePtr.get();
+      if (!Insert2Caches(bb.GetBBId(), opnd.GetExprID(), std::move(rightRangePtr))) {
+        valueRange = nullptr;
+        return false;
+      }
+    }
+    if (opnd.GetOp() == OP_ne || opnd.GetOp() == OP_eq) {
+      if (static_cast<OpMeExpr&>(opnd).GetNumOpnds() != kNumOperands) {
+        return false;
+      }
+      MeExpr *lhs = static_cast<OpMeExpr&>(opnd).GetOpnd(0);
+      auto *valueRangeOfLHS = FindValueRangeAndInitNumOfRecursion(bb, *lhs);
+      if (valueRangeOfLHS == nullptr || !valueRangeOfLHS->IsConstant()) {
+        valueRange = nullptr;
+        return false;
+      }
+      MeExpr *rhs = static_cast<OpMeExpr&>(opnd).GetOpnd(1);
+      if (rhs->GetMeOp() != kMeOpConst || static_cast<ConstMeExpr*>(rhs)->GetConstVal()->GetKind() != kConstInt) {
+        valueRange = nullptr;
+        return false;
+      }
+      RangeType lhsRangeType = valueRangeOfLHS->GetRangeType();
+      Bound lhsBound = valueRangeOfLHS->GetBound();
+      PrimType rhsPrimType = rhs->GetPrimType();
+      Bound rhsBound = Bound(static_cast<ConstMeExpr*>(rhs)->GetExtIntValue(), rhsPrimType);
+      // If the type of operands is OpMeExpr, need compute the valueRange of operand:
+      // Example: if ((a != c) < b),
+      // a: ValueRange(5, kEqual)
+      // c: ValueRange(6, kEqual)
+      // ===>
+      // (a != c) : ValueRange(1, kEqual)
+      if ((opnd.GetOp() == OP_ne && !lhsBound.IsEqual(rhsBound, rhsPrimType) && lhsRangeType == kEqual) ||
+          (opnd.GetOp() == OP_eq && lhsBound.IsEqual(rhsBound, rhsPrimType) && lhsRangeType == kEqual) ||
+          (opnd.GetOp() == OP_ne && lhsBound.IsEqual(rhsBound, rhsPrimType) && lhsRangeType == kNotEqual)) {
+        rightRangePtr = std::make_unique<ValueRange>(Bound(1, PTY_u1), kEqual);
+        valueRange = rightRangePtr.get();
+        (void)Insert2Caches(bb.GetBBId(), opnd.GetExprID(), std::move(rightRangePtr));
+      } else if ((opnd.GetOp() == OP_ne && lhsBound.IsEqual(rhsBound, rhsPrimType) && lhsRangeType == kEqual) ||
+          (opnd.GetOp() == OP_eq && !lhsBound.IsEqual(rhsBound, rhsPrimType) && lhsRangeType == kEqual) ||
+          (opnd.GetOp() == OP_eq && lhsBound.IsEqual(rhsBound, rhsPrimType) && lhsRangeType == kNotEqual)) {
+        rightRangePtr = std::make_unique<ValueRange>(Bound(nullptr, 0, PTY_u1), kEqual);
+        valueRange = rightRangePtr.get();
+        (void)Insert2Caches(bb.GetBBId(), opnd.GetExprID(), std::move(rightRangePtr));
+      }
+    }
+  }
+  if (valueRange != nullptr && valueRange->GetLower().GetPrimType() != opMeExpr.GetOpndType() &&
+      IsNeededPrimType(opMeExpr.GetOpndType())) {
+    rightRangePtr = CopyValueRange(*valueRange, opMeExpr.GetOpndType());
+    valueRange = rightRangePtr.get();
+  }
+  return true;
+}
+
+MeExpr *ValueRangePropagation::GetDefOfBase(const IvarMeExpr &ivar) const {
+  if (ivar.GetBase()->GetMeOp() != kMeOpVar) {
+    return nullptr;
+  }
+  auto *var = static_cast<const VarMeExpr*>(ivar.GetBase());
+  if (var->GetDefBy() != kDefByStmt) {
+    return nullptr;
+  }
+  return var->GetDefStmt()->GetLHS();
+}
+
+void ValueRangePropagation::DealWithCondGotoWhenRightRangeIsNotExist(
+    BB &bb, const MeExpr &opnd0, MeExpr &opnd1, Opcode opOfBrStmt, Opcode conditionalOp, ValueRange *valueRangeOfLeft) {
+  PrimType prim = opnd1.GetPrimType();
+  if (!IsNeededPrimType(prim)) {
+    return;
+  }
+  BB *trueBranch = nullptr;
+  BB *falseBranch = nullptr;
+  GetTrueAndFalseBranch(opOfBrStmt, bb, trueBranch, falseBranch);
+  switch (conditionalOp) {
+    case OP_ne: {
+      (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(),
+          std::make_unique<ValueRange>(Bound(&opnd1, prim), kNotEqual));
+      (void)Insert2Caches(falseBranch->GetBBId(), opnd0.GetExprID(),
+          std::make_unique<ValueRange>(Bound(&opnd1, prim), kEqual));
+      break;
+    }
+    case OP_eq: {
+      (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(),
+          std::make_unique<ValueRange>(Bound(&opnd1, prim), kEqual));
+      (void)Insert2Caches(falseBranch->GetBBId(), opnd0.GetExprID(),
+          std::make_unique<ValueRange>(Bound(&opnd1, prim), kNotEqual));
+      break;
+    }
+    case OP_le: {
+      if (valueRangeOfLeft != nullptr && valueRangeOfLeft->GetRangeType() == kOnlyHasLowerBound) {
+        (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(),
+                            std::make_unique<ValueRange>(valueRangeOfLeft->GetLower(),
+                                                         Bound(&opnd1, prim), kLowerAndUpper, dealWithPhi));
+      } else {
+        (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(),
+                            std::make_unique<ValueRange>(Bound(GetMinNumber(prim), prim),
+                                                         Bound(&opnd1, prim), kLowerAndUpper));
+      }
+      (void)Insert2Caches(falseBranch->GetBBId(), opnd0.GetExprID(),
+          std::make_unique<ValueRange>(Bound(&opnd1, 1, prim),
+              Bound(GetMaxNumber(prim), prim), kLowerAndUpper));
+      break;
+    }
+    case OP_lt: {
+      if (valueRangeOfLeft != nullptr && valueRangeOfLeft->GetRangeType() == kOnlyHasLowerBound) {
+        (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(),
+                            std::make_unique<ValueRange>(valueRangeOfLeft->GetLower(),
+                                                         Bound(&opnd1, -1, prim), kLowerAndUpper, dealWithPhi));
+      } else {
+        (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(),
+                            std::make_unique<ValueRange>(Bound(GetMinNumber(prim), prim),
+                                                         Bound(&opnd1, -1, prim), kLowerAndUpper));
+      }
+      (void)Insert2Caches(falseBranch->GetBBId(), opnd0.GetExprID(),
+          std::make_unique<ValueRange>(Bound(&opnd1, prim), Bound(GetMaxNumber(prim), prim), kLowerAndUpper));
+      break;
+    }
+    case OP_ge: {
+      if (valueRangeOfLeft != nullptr && valueRangeOfLeft->GetRangeType() == kOnlyHasUpperBound) {
+        (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(), std::make_unique<ValueRange>(
+            Bound(&opnd1, prim), valueRangeOfLeft->GetBound(), kLowerAndUpper, dealWithPhi));
+      } else {
+        (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(),
+            std::make_unique<ValueRange>(Bound(&opnd1, prim),
+                Bound(GetMaxNumber(prim), prim), kLowerAndUpper));
+      }
+      (void)Insert2Caches(falseBranch->GetBBId(), opnd0.GetExprID(),
+          std::make_unique<ValueRange>(Bound(GetMinNumber(prim), prim),
+              Bound(&opnd1, -1, prim), kLowerAndUpper));
+      break;
+    }
+    case OP_gt: {
+      if (valueRangeOfLeft != nullptr && valueRangeOfLeft->GetRangeType() == kOnlyHasUpperBound) {
+        (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(), std::make_unique<ValueRange>(
+            Bound(&opnd1, 1, prim), valueRangeOfLeft->GetBound(), kLowerAndUpper, dealWithPhi));
+      } else {
+        (void)Insert2Caches(trueBranch->GetBBId(), opnd0.GetExprID(),
+            std::make_unique<ValueRange>(Bound(&opnd1, 1, prim), Bound(GetMaxNumber(prim), prim), kLowerAndUpper));
+      }
+      (void)Insert2Caches(falseBranch->GetBBId(), opnd0.GetExprID(),
+          std::make_unique<ValueRange>(Bound(GetMinNumber(prim), prim),
+              Bound(&opnd1, prim), kLowerAndUpper));
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void ValueRangePropagation::GetValueRangeForUnsignedInt(const BB &bb, OpMeExpr &opMeExpr, const MeExpr &opnd,
+    ValueRange *&valueRange, std::unique_ptr<ValueRange> &rightRangePtr) {
+  if (onlyPropVR) {
+    return;
+  }
+  PrimType prim = opMeExpr.GetOpndType();
+  if (prim == PTY_u1 || prim == PTY_u8 || prim == PTY_u16 || prim == PTY_u32 || prim == PTY_a32 ||
+      ((prim == PTY_ref || prim == PTY_ptr) && GetPrimTypeSize(prim) == kFourByte)) {
+    rightRangePtr = std::make_unique<ValueRange>(
+        Bound(nullptr, 0, prim), Bound(GetMaxNumber(prim), prim), kLowerAndUpper);
+    valueRange = rightRangePtr.get();
+    (void)Insert2Caches(bb.GetBBId(), opnd.GetExprID(), std::move(rightRangePtr));
+  }
+}
+
+// This function deals with the case like this:
+// Example: if (a > 0)
+// a: valuerange(0, Max)
+// ==>
+// Example: if (a != 0)
+bool ValueRangePropagation::DealWithSpecialCondGoto(
+    const BB &bb, OpMeExpr &opMeExpr, const ValueRange &leftRange, ValueRange &rightRange, CondGotoMeStmt &brMeStmt) {
+  if (onlyPropVR) {
+    return false;
+  }
+  if (opMeExpr.GetOp() != OP_gt && opMeExpr.GetOp() != OP_lt) {
+    return false;
+  }
+  if (opMeExpr.GetNumOpnds() != kNumOperands) {
+    return false;
+  }
+  if (rightRange.GetRangeType() != kEqual || !rightRange.IsConstant()) {
+    return false;
+  }
+  if (leftRange.GetRangeType() != kLowerAndUpper) {
+    return false;
+  }
+  if (leftRange.GetLower().GetVar() != nullptr || leftRange.GetUpper().GetVar() != nullptr ||
+      leftRange.GetLower().GetConstant() >= leftRange.GetUpper().GetConstant()) {
+    return false;
+  }
+  if (opMeExpr.GetOp() == OP_gt) {
+    if (leftRange.GetLower().GetConstant() != rightRange.GetBound().GetConstant()) {
+      return false;
+    }
+    auto *newExpr = irMap.CreateMeExprCompare(OP_ne, opMeExpr.GetPrimType(),
+                                              opMeExpr.GetOpndType(), *opMeExpr.GetOpnd(0), *opMeExpr.GetOpnd(1));
+    (void)irMap.ReplaceMeExprStmt(brMeStmt, opMeExpr, *newExpr);
+    return true;
+  }
+  auto *loop = loops->GetBBLoopParent(bb.GetBBId());
+  if (loop != nullptr && IsLoopVariable(*loop, *opMeExpr.GetOpnd(0))) {
+    return false;
+  }
+  // Deal with op lt like this case:
+  // if opnd0 < 1
+  // vr(opnd0) : 0, 255
+  // ==>
+  // if opnd0 == 0
+  if (!leftRange.GetUpper().IsGreaterThanOrEqualTo(rightRange.GetBound(), opMeExpr.GetOpndType())) {
+    return false;
+  }
+  int64 res = 0;
+  if (AddOrSubWithConstant(leftRange.GetLower().GetPrimType(), OP_add, leftRange.GetLower().GetConstant(), 1, res)) {
+    if (!Bound(res, opMeExpr.GetOpndType()).IsEqual(rightRange.GetBound(), opMeExpr.GetOpndType())) {
+      return false;
+    }
+  }
+  auto *newConstExpr = irMap.CreateIntConstMeExpr(leftRange.GetLower().GetConstant(), opMeExpr.GetOpndType());
+  auto *newExpr = irMap.CreateMeExprCompare(OP_eq, opMeExpr.GetPrimType(),
+                                            opMeExpr.GetOpndType(), *opMeExpr.GetOpnd(0), *newConstExpr);
+  (void)irMap.ReplaceMeExprStmt(brMeStmt, opMeExpr, *newExpr);
+  return true;
+}
+
+// Deal with the special brstmt, which only has one opnd.
+void ValueRangePropagation::DealWithBrStmtWithOneOpnd(BB &bb, const CondGotoMeStmt &stmt, MeExpr &opnd, Opcode op) {
+  if (op != OP_eq && op != OP_ne) {
+    return;
+  }
+  // brfalse/brtrue a  --->  brfalse ne(a, 0)
+  // brfalse/brtrue 1  --->  brture ne(1,0)
+  // op: OP_ne
+  // rightRange: 0
+  // leftRange: const 1 or var a
+  std::unique_ptr<ValueRange> rightRangePtr = std::make_unique<ValueRange>(
+      Bound(nullptr, 0, opnd.GetPrimType()), kEqual);
+  if (opnd.GetMeOp() == kMeOpConst && static_cast<ConstMeExpr&>(opnd).GetConstVal()->GetKind() == kConstInt) {
+    std::unique_ptr<ValueRange> leftRangePtr = std::make_unique<ValueRange>(
+        Bound(static_cast<ConstMeExpr &>(opnd).GetExtIntValue(), opnd.GetPrimType()), kEqual);
+    DealWithCondGoto(bb, op, leftRangePtr.get(), *rightRangePtr.get(), stmt);
+  } else {
+    ValueRange *leftRange = FindValueRangeAndInitNumOfRecursion(bb, opnd);
+    DealWithCondGoto(bb, op, leftRange, *rightRangePtr.get(), stmt);
+  }
+}
+
+void ValueRangePropagation::InsertValueRangeOfCondExpr2Caches(BB &bb, const MeStmt &stmt) {
+  if (bb.GetKind() != kBBCondGoto) {
+    return;
+  }
+  BB *trueBranch = nullptr;
+  BB *falseBranch = nullptr;
+  const CondGotoMeStmt &brMeStmt = static_cast<const CondGotoMeStmt&>(stmt);
+  GetTrueAndFalseBranch(stmt.GetOp(), bb, trueBranch, falseBranch);
+  (void)Insert2Caches(trueBranch->GetBBId(), brMeStmt.GetOpnd()->GetExprID(),
+                      CreateValueRangeOfNotEqualZero(brMeStmt.GetOpnd()->GetPrimType()));
+  (void)Insert2Caches(falseBranch->GetBBId(), brMeStmt.GetOpnd()->GetExprID(),
+                      CreateValueRangeOfEqualZero(brMeStmt.GetOpnd()->GetPrimType()));
+  if (!IsCompareHasReverseOp(brMeStmt.GetOpnd()->GetOp()) || brMeStmt.GetOpnd()->GetNumOpnds() != kNumOperands) {
+    return;
+  }
+  auto *opMeExpr = static_cast<OpMeExpr*>(brMeStmt.GetOpnd());
+  MeExpr *opnd0 = opMeExpr->GetOpnd(0);
+  MeExpr *opnd1 = opMeExpr->GetOpnd(1);
+  if (opnd0->IsVolatile() || opnd1->IsVolatile()) {
+    return;
+  }
+  auto op = opMeExpr->GetOp();
+  if (op == OP_eq) {
+    Insert2PairOfExprs(*opnd0, *opnd1, *trueBranch);
+    Insert2PairOfExprs(*opnd1, *opnd0, *trueBranch);
+  }
+  if (op == OP_ne) {
+    Insert2PairOfExprs(*opnd0, *opnd1, *falseBranch);
+    Insert2PairOfExprs(*opnd1, *opnd0, *falseBranch);
+  }
+}
+
+// This function deals with the case like this:
+// Example1: first brfalse mx1 ge mx2
+//          second brfalse mx1 ge/lt mx2 ==>  remove falseBranch or trueBranch
+// Example2: first brfalse mx1 gt mx2
+//          second brfalse mx1 gt/le mx2 ==>  remove falseBranch or trueBranch
+// mx1: valuerange [mx2+1, max(mx2_type)] or [mx2, max(mx2_type)]
+// ==>
+// remove falseBranch or trueBranch
+bool ValueRangePropagation::AnalysisUnreachableForGeOrGt(BB &bb, const CondGotoMeStmt &brMeStmt,
+                                                         const ValueRange &leftRange) {
+  Opcode op = static_cast<OpMeExpr*>(brMeStmt.GetOpnd())->GetOp();
+  BB *trueBranch = nullptr;
+  BB *falseBranch = nullptr;
+  GetTrueAndFalseBranch(brMeStmt.GetOp(), bb, trueBranch, falseBranch);
+  // When the redundant branch can be inferred directly from the condGoto stmt
+  if (op == OP_gt && leftRange.GetLower().GetConstant() == 1) {
+    // falseBranch is unreachable
+    AnalysisUnreachableBBOrEdge(bb, *falseBranch, *trueBranch);
+    return true;
+  } else if (op == OP_le && leftRange.GetLower().GetConstant() == 1) {
+    AnalysisUnreachableBBOrEdge(bb, *trueBranch, *falseBranch);
+    return true;
+  } else if (op == OP_ge && leftRange.GetLower().GetConstant() == 0) {
+    AnalysisUnreachableBBOrEdge(bb, *falseBranch, *trueBranch);
+    return true;
+  } else if (op == OP_lt && leftRange.GetLower().GetConstant() == 0) {
+    AnalysisUnreachableBBOrEdge(bb, *trueBranch, *falseBranch);
+    return true;
+  }
+  return false;
+}
+
+// This function deals with the case like this:
+// Example1: first brfalse mx1 le mx2
+//          second brfalse mx1 lt/ge mx2 ==>  remove falseBranch or trueBranch
+// Example2: first brfalse mx1 lt mx2
+//          second brfalse mx1 le/gt mx2 ==>  remove falseBranch or trueBranch
+// mx1: valuerange [min(mx2_type), mx2-1] or [min(mx2_type), mx2]
+// ==>
+// remove falseBranch or trueBranch
+bool ValueRangePropagation::AnalysisUnreachableForLeOrLt(
+    BB &bb, const CondGotoMeStmt &brMeStmt, const ValueRange &leftRange) {
+  Opcode op = static_cast<OpMeExpr*>(brMeStmt.GetOpnd())->GetOp();
+  BB *trueBranch = nullptr;
+  BB *falseBranch = nullptr;
+  GetTrueAndFalseBranch(brMeStmt.GetOp(), bb, trueBranch, falseBranch);
+  // When the redundant branch can be inferred directly from the condGoto stmt
+  if (op == OP_lt && leftRange.GetUpper().GetConstant()  == -1) {
+    // falseBranch is unreachable
+    AnalysisUnreachableBBOrEdge(bb, *falseBranch, *trueBranch);
+    return true;
+  } else if (op == OP_ge && leftRange.GetUpper().GetConstant() == -1) {
+    AnalysisUnreachableBBOrEdge(bb, *trueBranch, *falseBranch);
+    return true;
+  } else if (op == OP_le && leftRange.GetUpper().GetConstant() == 0) {
+    // falseBranch is the unreachableBB
+    AnalysisUnreachableBBOrEdge(bb, *falseBranch, *trueBranch);
+    return true;
+  } else if (op == OP_gt && leftRange.GetUpper().GetConstant() == 0) {
+    AnalysisUnreachableBBOrEdge(bb, *trueBranch, *falseBranch);
+    return true;
+  }
+  return false;
+}
+
+// This function deals with the case like this:
+// Example1: first brfalse mx1 eg mx2
+//          second brfalse mx1 eq/ne mx2 ==>  remove falseBranch or trueBranch
+// Example2: first brfalse mx1 ne mx2
+//          second brfalse mx1 eq/ne mx2 ==>  remove falseBranch or trueBranch
+// mx1: valuerange [mx2, mx2]
+// ==>
+// remove falseBranch or trueBranch
+bool ValueRangePropagation::AnalysisUnreachableForEqOrNe(BB &bb, const CondGotoMeStmt &brMeStmt,
+                                                         const ValueRange &leftRange) {
+  Opcode op = static_cast<OpMeExpr*>(brMeStmt.GetOpnd())->GetOp();
+  BB *trueBranch = nullptr;
+  BB *falseBranch = nullptr;
+  GetTrueAndFalseBranch(brMeStmt.GetOp(), bb, trueBranch, falseBranch);
+  // When the redundant branch can be inferred directly from the condGoto stmt
+  if ((op == OP_eq && leftRange.GetRangeType() == kEqual) ||
+      (op == OP_ne && leftRange.GetRangeType() == kNotEqual)) {
+    // falseBranch is unreachable
+    AnalysisUnreachableBBOrEdge(bb, *falseBranch, *trueBranch);
+    return true;
+  } else if ((op == OP_ne && leftRange.GetRangeType() == kEqual) ||
+             (op == OP_eq && leftRange.GetRangeType() == kNotEqual)) {
+    AnalysisUnreachableBBOrEdge(bb, *trueBranch, *falseBranch);
+    return true;
+  }
+  return false;
+}
+
+// This function deals with the case like this:
+// Example: first brfalse mx1 eq(ne/gt/le/ge/lt) mx2
+//          second brfalse mx1 eq(ne/gt/le/ge/lt) mx2 ==>  remove falseBranch or trueBranch
+bool ValueRangePropagation::DealWithVariableRange(BB &bb, const CondGotoMeStmt &brMeStmt,
+                                                  const ValueRange &leftRange) {
+  MeExpr *opnd1 = static_cast<OpMeExpr*>(brMeStmt.GetOpnd())->GetOpnd(1);
+  // Example1: deal with like if (mx1 > mx2), when the valuerange of mx1 is [mx2+1, max(mx2_type)]
+  // Example2: deal with like if (mx1 >= mx2), when the valuerange of mx1 is [mx2, max(mx2_type)]
+  if (leftRange.GetLower().GetVar() == opnd1 && leftRange.GetUpper().GetVar() == nullptr &&
+      leftRange.UpperIsMax(opnd1->GetPrimType())) {
+    return AnalysisUnreachableForGeOrGt(bb, brMeStmt, leftRange);
+  // Example1: deal with like if (mx1 < mx2), when the valuerange of mx1 is [min(mx2_type), mx2-1]
+  // Example2: deal with like if (mx1 <= mx2), when the valuerange of mx1 is [min(mx2_type), mx2]
+  } else if (leftRange.GetLower().GetVar() == nullptr && leftRange.GetUpper().GetVar() == opnd1 &&
+      leftRange.LowerIsMin(opnd1->GetPrimType())) {
+    return AnalysisUnreachableForLeOrLt(bb, brMeStmt, leftRange);
+  // Example: deal with like if (mx1 == mx2), when the valuerange of mx1 is [mx2, mx2]
+  // Example: deal with like if (mx1 != mx2), when the valuerange of mx1 is [mx2, mx2]
+  } else if (leftRange.GetLower().GetVar() == opnd1 && leftRange.GetLower().GetConstant() == 0 &&
+             leftRange.GetUpper().GetVar() == opnd1 && leftRange.GetUpper().GetConstant() == 0) {
+    return AnalysisUnreachableForEqOrNe(bb, brMeStmt, leftRange);
+  }
+  return false;
+}
+
+void ValueRangePropagation::DealWithCondGoto(BB &bb, MeStmt &stmt) {
+  CondGotoMeStmt &brMeStmt = static_cast<CondGotoMeStmt&>(stmt);
+  const BB *brTarget = bb.GetSucc(1);
+  CHECK_FATAL(brMeStmt.GetOffset() == brTarget->GetBBLabel(), "must be");
+  if (!IsCompareHasReverseOp(brMeStmt.GetOpnd()->GetOp())) {
+    return DealWithBrStmtWithOneOpnd(bb, brMeStmt, *brMeStmt.GetOpnd(), OP_ne);
+  }
+  auto *opMeExpr = static_cast<OpMeExpr*>(brMeStmt.GetOpnd());
+  if (opMeExpr->GetNumOpnds() != kNumOperands) {
+    return;
+  }
+  MeExpr *opnd0 = opMeExpr->GetOpnd(0);
+  MeExpr *opnd1 = opMeExpr->GetOpnd(1);
+  if (opnd0->IsVolatile() || opnd1->IsVolatile()) {
+    return;
+  }
+  ValueRange *rightRange = nullptr;
+  ValueRange *leftRange = nullptr;
+  std::unique_ptr<ValueRange> rightRangePtr;
+  std::unique_ptr<ValueRange> leftRangePtr;
+  if (!GetValueRangeOfCondGotoOpnd(bb, *opMeExpr, *opnd0, leftRange, leftRangePtr)) {
+    return;
+  }
+  // Example: deal with brfalse mx1 eq(ne/gt/le/ge/lt) mx2,
+  //          mx1: valuerange [mx2+1, max(mx2_type)] or [min(mx2_type), mx2] or [mx2,mx2], etc
+  //          remove falseBranch or trueBranch
+  if (leftRange != nullptr && DealWithVariableRange(bb, brMeStmt, *leftRange)) {
+    return;
+  }
+  if (!GetValueRangeOfCondGotoOpnd(bb, *opMeExpr, *opnd1, rightRange, rightRangePtr)) {
+    return;
+  }
+  if (rightRange == nullptr) {
+    if (!ConditionEdgeCanBeDeleted(bb, *opnd0, rightRange, opMeExpr->GetOpndType(), opMeExpr->GetOp())) {
+      DealWithCondGotoWhenRightRangeIsNotExist(bb, *opnd0, *opnd1, brMeStmt.GetOp(), opMeExpr->GetOp(), leftRange);
+    }
+    return;
+  }
+  if (leftRange == nullptr && rightRange->GetRangeType() != kEqual) {
+    return;
+  }
+  if (leftRange == nullptr) {
+    GetValueRangeForUnsignedInt(bb, *opMeExpr, *opnd0, leftRange, leftRangePtr);
+  }
+  if (leftRange != nullptr) {
+    if (opMeExpr->GetOp() == OP_gt && DealWithSpecialCondGoto(bb, *opMeExpr, *leftRange, *rightRange, brMeStmt)) {
+      return DealWithCondGoto(bb, stmt);
+    }
+    if (opMeExpr->GetOp() == OP_lt && DealWithSpecialCondGoto(bb, *opMeExpr, *leftRange, *rightRange, brMeStmt)) {
+      return DealWithCondGoto(bb, stmt);
+    }
+  }
+  DealWithCondGoto(bb, opMeExpr->GetOp(), leftRange, *rightRange, brMeStmt);
+}
+
+void ValueRangePropagation::DumpCaches() {
+  LogInfo::MapleLogger() << "================Dump value range===================" << "\n";
+  for (size_t i = 0; i < caches.size(); ++i) {
+    LogInfo::MapleLogger() << "BBId: " << i << "\n";
+    auto &it = caches[i];
+    for (auto bIt = it.begin(), eIt = it.end(); bIt != eIt; ++bIt) {
+      if (bIt->second == nullptr) {
+        continue;
+      }
+      if (bIt->second->GetRangeType() == kLowerAndUpper ||
+          bIt->second->GetRangeType() == kSpecialLowerForLoop ||
+          bIt->second->GetRangeType() == kSpecialUpperForLoop) {
+        std::string lower = (bIt->second->GetLower().GetVar() == nullptr) ?
+            std::to_string(bIt->second->GetLower().GetConstant()) :
+            "mx" + std::to_string(bIt->second->GetLower().GetVar()->GetExprID()) + " " +
+            std::to_string(bIt->second->GetLower().GetConstant());
+        std::string upper = (bIt->second->GetUpper().GetVar() == nullptr) ?
+            std::to_string(bIt->second->GetUpper().GetConstant()) :
+            "mx" + std::to_string(bIt->second->GetUpper().GetVar()->GetExprID()) + " " +
+            std::to_string(bIt->second->GetUpper().GetConstant());
+        LogInfo::MapleLogger() << "mx" << bIt->first << " lower: " << lower << " upper: " << upper;
+        if (bIt->second->GetRangeType() == kLowerAndUpper) {
+          LogInfo::MapleLogger() << " kLowerAndUpper\n";
+        } else if (bIt->second->GetRangeType() == kSpecialLowerForLoop) {
+          LogInfo::MapleLogger() << " kSpecialLowerForLoop\n";
+        } else {
+          LogInfo::MapleLogger() << " kSpecialUpperForLoop\n";
+        }
+      } else if (bIt->second->GetRangeType() == kOnlyHasLowerBound) {
+        std::string lower = (bIt->second->GetBound().GetVar() == nullptr) ?
+            std::to_string(bIt->second->GetBound().GetConstant()) :
+            "mx" + std::to_string(bIt->second->GetBound().GetVar()->GetExprID()) + " " +
+            std::to_string(bIt->second->GetBound().GetConstant());
+        LogInfo::MapleLogger() << "mx" << bIt->first << " lower: " << lower << " upper: max " << "kOnlyHasLowerBound\n";
+      } else if (bIt->second->GetRangeType() == kOnlyHasUpperBound) {
+        std::string upper = (bIt->second->GetBound().GetVar() == nullptr) ?
+            std::to_string(bIt->second->GetBound().GetConstant()) :
+            "mx" + std::to_string(bIt->second->GetBound().GetVar()->GetExprID()) + " " +
+            std::to_string(bIt->second->GetBound().GetConstant());
+        LogInfo::MapleLogger() << "mx" << bIt->first << " lower: min upper: " << upper << "kOnlyHasUpperBound\n";
+      } else if (bIt->second->GetRangeType() == kEqual || bIt->second->GetRangeType() == kNotEqual) {
+        std::string lower = (bIt->second->GetBound().GetVar() == nullptr) ?
+            std::to_string(bIt->second->GetBound().GetConstant()) :
+            "mx" + std::to_string(bIt->second->GetBound().GetVar()->GetExprID()) + " " +
+            std::to_string(bIt->second->GetBound().GetConstant());
+        LogInfo::MapleLogger() << "mx" << bIt->first << " lower and upper: " << lower;
+        if (bIt->second->GetRangeType() == kEqual) {
+          LogInfo::MapleLogger() << " kEqual\n";
+        } else {
+          LogInfo::MapleLogger() << " kNotEqual\n";
+        }
+      }
+    }
+  }
+  LogInfo::MapleLogger() << "================Dump value range===================" << "\n";
+}
+
+void MEValueRangePropagation::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.AddRequired<MELoopCanon>();
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MELoopAnalysis>();
+  aDep.SetPreservedAll();
+}
+
+bool MEValueRangePropagation::PhaseRun(maple::MeFunction &f) {
+  ValueRangePropagation::isDebug = DEBUGFUNC_NEWPM(f);
+  f.vrpRuns++;
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  CHECK_FATAL(irMap != nullptr, "irMap phase has problem");
+  auto *dom = EXEC_ANALYSIS(MEDominance, f)->GetDomResult();
+  CHECK_FATAL(dom != nullptr, "dominance phase has problem");
+  auto *meLoop = GET_ANALYSIS(MELoopAnalysis, f);
+  if (ValueRangePropagation::isDebug) {
+    LogInfo::MapleLogger() << f.GetName() << "\n";
+    f.Dump(false);
+    f.GetCfg()->DumpToFile("valuerange-before" + std::to_string(f.vrpRuns));
+  }
+  auto *valueRangeMemPool = GetPhaseMemPool();
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> cands((std::less<OStIdx>()));
+  LoopScalarAnalysisResult sa(*irMap, nullptr);
+  sa.SetComputeTripCountForLoopUnroll(false);
+  ValueRangePropagation valueRangePropagation(f, *irMap, *dom, meLoop, *valueRangeMemPool, cands, sa, true);
+
+  SafetyCheck safetyCheck; // dummy
+  valueRangePropagation.SetSafetyBoundaryCheck(safetyCheck);
+  valueRangePropagation.SetSafetyNonnullCheck(safetyCheck);
+
+  valueRangePropagation.Execute();
+  (void)f.GetCfg()->UnreachCodeAnalysis(true);
+  f.GetCfg()->WontExitAnalysis();
+  // split critical edges
+  (void)MeSplitCEdge(false).SplitCriticalEdgeForMeFunc(f);
+  if (valueRangePropagation.IsCFGChange()) {
+    if (ValueRangePropagation::isDebug) {
+      f.GetCfg()->DumpToFile("valuerange-after" + std::to_string(f.vrpRuns));
+    }
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+    dom = FORCE_EXEC(MEDominance)->GetDomResult();
+    if (valueRangePropagation.NeedUpdateSSA()) {
+      MeSSAUpdate ssaUpdate(f, *f.GetMeSSATab(), *dom, cands);
+      MPLTimer timer;
+      timer.Start();
+      if (ValueRangePropagation::isDebug) {
+        LogInfo::MapleLogger() << "***************ssaupdate value range prop***************" << "\n";
+        LogInfo::MapleLogger() << "========size of ost " << cands.size() << " " <<
+            f.GetMeSSATab()->GetOriginalStTableSize() << "========\n";
+      }
+      ssaUpdate.Run();
+      timer.Stop();
+      if (ValueRangePropagation::isDebug) {
+        LogInfo::MapleLogger() << "ssaupdate consumes cumulatively " << timer.Elapsed() << "seconds " << '\n';
+        LogInfo::MapleLogger() << "***************ssaupdate value range prop***************" << "\n";
+      }
+    }
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MELoopAnalysis::id);
+    GetAnalysisInfoHook()->ForceRunTransFormPhase<MeFuncOptTy, MeFunction>(&MELoopCanon::id, f);
+    // update cfg frequency
+    if (f.GetCfg()->UpdateCFGFreq()) {
+      if (f.GetCfg()->DumpIRProfileFile()) {
+        f.GetCfg()->DumpToFile("after-valuerange" + std::to_string(f.vrpRuns), false, true);
+      }
+    }
+  }
+  // Run vrp twice when need check boundary and nullable pointer.
+  if (MeOption::boundaryCheckMode != kNoCheck || MeOption::npeCheckMode != kNoCheck) {
+    auto *hook = GetAnalysisInfoHook();
+    dom = static_cast<MEDominance*>(
+        hook->ForceRunAnalysisPhase<MapleFunctionPhase<MeFunction>>(&MEDominance::id, f))->GetDomResult();
+    meLoop = static_cast<MELoopAnalysis*>(
+        hook->ForceRunAnalysisPhase<MapleFunctionPhase<MeFunction>>(&MELoopAnalysis::id, f))->GetResult();
+    ValueRangePropagation valueRangePropagationWithOPTAssert(
+        f, *irMap, *dom, meLoop, *valueRangeMemPool, cands, sa, true, true);
+    SafetyCheckWithBoundaryError safetyCheckBoundaryError(f, valueRangePropagationWithOPTAssert);
+    SafetyCheckWithNonnullError safetyCheckNonnullError(f);
+    if (MeOption::boundaryCheckMode == kNoCheck) {
+      valueRangePropagationWithOPTAssert.SetSafetyBoundaryCheck(safetyCheck);
+    } else {
+      valueRangePropagationWithOPTAssert.SetSafetyBoundaryCheck(safetyCheckBoundaryError);
+    }
+    if (MeOption::npeCheckMode == kNoCheck || f.vrpRuns == 1) {
+      valueRangePropagationWithOPTAssert.SetSafetyNonnullCheck(safetyCheck);
+    } else {
+      valueRangePropagationWithOPTAssert.SetSafetyNonnullCheck(safetyCheckNonnullError);
+    }
+    valueRangePropagationWithOPTAssert.Execute();
+    CHECK_FATAL(!valueRangePropagationWithOPTAssert.IsCFGChange(), "must not change the cfg!");
+    if (ValueRangePropagation::isDebug) {
+      LogInfo::MapleLogger() << "***************after check***************" << "\n";
+      f.Dump(false);
+      f.GetCfg()->DumpToFile("valuerange-after-safe" + std::to_string(f.vrpRuns));
+    }
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/me_verify.cpp b/src/mapleall/maple_me/src/me_verify.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..57b6c340dd173b383eba6316c3abd0d631d8108a
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_verify.cpp
@@ -0,0 +1,534 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include "me_verify.h"
+#include "me_cfg.h"
+#include "me_dominance.h"
+
+namespace maple {
+bool MeVerify::enableDebug = false;
+
+void MeVerify::VerifyFunction() {
+  if (enableDebug) {
+    LogInfo::MapleLogger() << meFunc.GetName() << "\n";
+  }
+  VerifyCommonExitBB();
+  uint64 i = 0;
+  for (auto &bb : meFunc.GetLaidOutBBs()) {
+    ++i;
+    if (bb->GetSucc().empty() && bb->GetPred().empty()) {
+      continue;
+    }
+    if (bb->GetPred().empty() && !bb->GetAttributes(kBBAttrIsEntry)) {
+      continue;
+    }
+    VerifyBBKind(*bb);
+    VerifySuccAndPredOfBB(*bb);
+    if (bb->GetAttributes(kBBAttrIsTry) && !bb->GetMeStmts().empty() &&
+        bb->GetMeStmts().front().GetOp() == OP_try) {
+      VerifyAttrTryBB(*bb, i - 1);
+    }
+  }
+}
+
+void DealWithPoninterType(const MIRType &type, std::string &str);
+
+void AddTypeKindToStr(const MIRType &type, std::string &str) {
+  if (type.GetKind() != kTypeClass && type.GetKind() != kTypeStruct && type.GetKind() != kTypeInterface &&
+      type.GetKind() != kTypeClassIncomplete && type.GetKind() != kTypeStructIncomplete &&
+      type.GetKind() != kTypeInterfaceIncomplete) {
+    str += "_" + std::to_string(type.GetKind());
+  }
+}
+
+void DealWithFuncType(const MIRType &type, std::string &str) {
+  auto funcType = static_cast<const MIRFuncType&>(type);
+  str += "_" + std::to_string(funcType.GetRetTyIdx().GetIdx());
+  str += "_" + std::to_string(funcType.IsVarargs());
+  for (auto &item : funcType.GetParamTypeList()) {
+    str += "_" + std::to_string(item.GetIdx());
+  }
+  for (auto &item : funcType.GetParamAttrsList()) {
+    str += "_" + std::to_string(item.GetAttrFlag()) + std::to_string(item.GetAlignValue());
+  }
+}
+
+void GetAttrOfType(const MIRType &type, std::string &str) {
+  str += "_" + std::to_string(static_cast<int>(type.GetPrimType()));
+  AddTypeKindToStr(type, str);
+  switch (type.GetKind()) {
+    case kTypePointer: {
+      DealWithPoninterType(type, str);
+      break;
+    }
+    case kTypeFArray:
+    case kTypeJArray: {
+      auto farrayType = static_cast<const MIRFarrayType&>(type);
+      GetAttrOfType(*farrayType.GetElemType(), str);
+      break;
+    }
+    case kTypeArray: {
+      auto arryType = static_cast<const MIRArrayType&>(type);
+      for (uint32 i = 0; i < arryType.GetDim(); ++i) {
+        str += "_" + std::to_string(arryType.GetSizeArrayItem(i));
+        break;
+      }
+      GetAttrOfType(*arryType.GetElemType(), str);
+      break;
+    }
+    case kTypeBitField: {
+      str += "_" + std::to_string(static_cast<const MIRBitFieldType&>(type).GetFieldSize());
+      break;
+    }
+    case kTypeFunction: {
+      DealWithFuncType(type, str);
+      break;
+    }
+    case kTypeInstantVector: {
+      for (auto &item : static_cast<const MIRInstantVectorType&>(type).GetInstantVec()) {
+        str += "_" + std::to_string(item.first.GetIdx());
+        str += "_" + std::to_string(item.second.GetIdx());
+      }
+      break;
+    }
+    case kTypeGenericInstant: {
+      str += "_" + std::to_string(static_cast<const MIRGenericInstantType&>(type).GetGenericTyIdx());
+      break;
+    }
+    case kTypeByName: {
+      str += "_" + std::to_string(type.IsNameIsLocal());
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void DealWithPoninterType(const MIRType &type, std::string &str) {
+  auto ptrType = static_cast<const MIRPtrType&>(type);
+  str += "_" + std::to_string(ptrType.GetTypeAttrs().GetAlignValue()) + "_" +
+         std::to_string(ptrType.GetTypeAttrs().GetAttrFlag());
+  GetAttrOfType(*ptrType.GetPointedType(), str);
+}
+
+// The type must exited in typeHashTable, ptrTypeTable or refTypeTable.
+bool FindTypeInOtherTable(MIRType &mirType) {
+  const auto &typeHashTable = GlobalTables::GetTypeTable().GetTypeHashTable();
+  const auto &ptrTypeTable = GlobalTables::GetTypeTable().GetPtrTypeMap();
+  const auto &refTypeTable = GlobalTables::GetTypeTable().GetRefTypeMap();
+  if (typeHashTable.find(&mirType) != typeHashTable.end()) {
+    return true;
+  }
+  bool inTypeHash = false;
+  for (auto &iter : typeHashTable) {
+    if (iter->GetTypeIndex() == mirType.GetTypeIndex()) {
+      inTypeHash = true;
+    }
+  }
+  if (inTypeHash) {
+    return true;
+  }
+  if (mirType.IsMIRPtrType() &&
+      ptrTypeTable.find(static_cast<const MIRPtrType&>(mirType).GetPointedTyIdx()) != ptrTypeTable.end()) {
+    return true;
+  }
+  if (mirType.IsMIRPtrType() &&
+      refTypeTable.find(static_cast<const MIRPtrType&>(mirType).GetPointedTyIdx()) != refTypeTable.end()) {
+    return true;
+  }
+  return false;
+}
+
+void FindTypeInTypeTable() {
+  const auto &typeHashTable = GlobalTables::GetTypeTable().GetTypeHashTable();
+  const auto &ptrTypeTable = GlobalTables::GetTypeTable().GetPtrTypeMap();
+  const auto &refTypeTable = GlobalTables::GetTypeTable().GetRefTypeMap();
+  std::set<TyIdx> tyIdxs;
+  for (auto &iter : typeHashTable) {
+    if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(iter->GetTypeIndex()) == nullptr) {
+      CHECK_FATAL(false, "%s %d is not exit in typeTable",
+                  iter->GetMplTypeName().c_str(), iter->GetTypeIndex().GetIdx());
+    }
+    size_t size = tyIdxs.size();
+    tyIdxs.insert(iter->GetTypeIndex());
+    if (tyIdxs.size() == size) {
+      CHECK_FATAL(false, "%s %d repeated in typeHashTable",
+                  iter->GetMplTypeName().c_str(), iter->GetTypeIndex().GetIdx());
+    }
+  }
+  tyIdxs.clear();
+  for (auto &iter : ptrTypeTable) {
+    if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(iter.first) == nullptr) {
+      CHECK_FATAL(false, "%d is not exit in typeTable", iter.first.GetIdx());
+    }
+    size_t size = tyIdxs.size();
+    tyIdxs.insert(iter.first);
+    if (tyIdxs.size() == size) {
+      CHECK_FATAL(false, "%d repeated in ptrTypeTable", iter.first.GetIdx());
+    }
+  }
+  tyIdxs.clear();
+  for (auto &iter : refTypeTable) {
+    if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(iter.first) == nullptr) {
+      CHECK_FATAL(false, "%d is not exit in typeTable", iter.first.GetIdx());
+    }
+    size_t size = tyIdxs.size();
+    tyIdxs.insert(iter.first);
+    if (tyIdxs.size() == size) {
+      CHECK_FATAL(false, "%d is repeated in refTypeTable", iter.first.GetIdx());
+    }
+  }
+}
+
+void VerifyGlobalTypeTable() {
+  const auto &typeTable = GlobalTables::GetTypeTable().GetTypeTable();
+  const auto &typeHashTable = GlobalTables::GetTypeTable().GetTypeHashTable();
+  const auto &ptrTypeTable = GlobalTables::GetTypeTable().GetPtrTypeMap();
+  const auto &refTypeTable = GlobalTables::GetTypeTable().GetRefTypeMap();
+  FindTypeInTypeTable();
+  auto sizeOfMIRTypes = typeHashTable.size() + ptrTypeTable.size() + refTypeTable.size();
+  // nullptr and struct mirtype classmeta in typetable but not in other tables.
+  if (sizeOfMIRTypes != typeTable.size() - 1) {
+    if (MeVerify::enableDebug) {
+      LogInfo::MapleLogger() << typeTable.size() << " " << typeHashTable.size() << " " << ptrTypeTable.size() << " " <<
+          refTypeTable.size() << " " << (typeHashTable.size() + ptrTypeTable.size() + refTypeTable.size()) << "\n";
+    }
+    CHECK_FATAL(false, "verify failed, sizeOfMIRTypes: %d, typeTable.size(): %d", sizeOfMIRTypes, typeTable.size());
+  }
+  int i = 0;
+  std::set<std::string> primTypeAndTypeName;
+  std::set<TyIdx> tyIdxs;
+  for (auto &mirType : typeTable) {
+    if (mirType == nullptr) {
+      continue;
+    }
+    size_t idx = tyIdxs.size();
+    tyIdxs.insert(mirType->GetTypeIndex());
+    CHECK_FATAL(idx != tyIdxs.size(), "the same tyidx in type table");
+    size_t size = primTypeAndTypeName.size();
+    std::string currName = mirType->GetMplTypeName();
+    GetAttrOfType(*mirType, currName);
+    primTypeAndTypeName.insert(currName);
+    if (MeVerify::enableDebug) {
+      LogInfo::MapleLogger() << currName << "\n";
+    }
+    if (size == primTypeAndTypeName.size()) {
+      ++i;
+      CHECK_FATAL(false, "the type has been created %s %d", currName.c_str(), mirType->GetTypeIndex().GetIdx());
+    }
+    if (FindTypeInOtherTable(*mirType)) {
+      continue;
+    }
+    if (mirType->GetMplTypeName().find(namemangler::kClassMetadataTypeName) != std::string::npos) {
+      continue;
+    }
+    CHECK_FATAL(false, "%d %s is in typetable,", mirType->GetTypeIndex().GetIdx(), mirType->GetMplTypeName().c_str());
+  }
+  // the first elem of type table is nullptr
+  CHECK_FATAL(tyIdxs.size() == typeTable.size() - 1, "the size of tyIdxs is not equal to typeTable");
+  if (MeVerify::enableDebug) {
+    LogInfo::MapleLogger() << i << "\n";
+  }
+}
+
+void MeVerify::VerifyPhiNode(const BB &bb, const Dominance &dom) const {
+  if (enableDebug) {
+    meFunc.GetCfg()->DumpToFile("meverify");
+  }
+  for (auto &it : bb.GetMePhiList()) {
+    auto *phiNode = it.second;
+    if (phiNode == nullptr) {
+      continue;
+    }
+    if (enableDebug) {
+      LogInfo::MapleLogger() << bb.GetBBId() << " " <<  phiNode->GetLHS()->GetExprID() << "\n";
+    }
+    if (!phiNode->GetIsLive()) {
+      continue;
+    }
+    auto *lhs = phiNode->GetLHS();
+    if (lhs == nullptr) {
+      continue;
+    }
+    CHECK_FATAL(phiNode->GetDefBB() == &bb, "current bb must be def bb");
+    CHECK_FATAL(lhs->GetDefBy() == kDefByPhi, "must be kDefByPhi");
+    CHECK_FATAL(&(lhs->GetDefPhi()) == phiNode, "must be the def phinode");
+    CHECK_FATAL(bb.GetPred().size() == phiNode->GetOpnds().size(), "must be equal");
+    for (size_t i = 0; i < phiNode->GetOpnds().size(); ++i) {
+      auto *opnd = phiNode->GetOpnd(i);
+      if (opnd->IsVolatile()) {
+        continue;
+      }
+      MeStmt *stmt = nullptr;
+      BB *defBB = opnd->GetDefByBBMeStmt(*meFunc.GetCfg(), stmt);
+      if (bb.GetPred(i) != defBB && !dom.Dominate(*defBB, *bb.GetPred(i))) {
+        CHECK_FATAL(false, "the defBB of opnd must be the predBB or dominate the current bb");
+      }
+    }
+  }
+}
+
+void MeVerify::VerifySuccAndPredOfBB(const BB &bb) const {
+  std::set<BBId> temp;
+  for (auto &pred : bb.GetPred()) {
+    size_t size = temp.size();
+    temp.insert(pred->GetBBId());
+    CHECK_FATAL(size != temp.size(), "the bb is already existed");
+  }
+  temp.clear();
+  for (auto &succ : bb.GetSucc()) {
+    size_t size = temp.size();
+    temp.insert(succ->GetBBId());
+    CHECK_FATAL(size != temp.size(), "the bb is already existed");
+  }
+}
+
+void MeVerify::VerifyBBKind(const BB &bb) const {
+  switch (bb.GetKind()) {
+    case kBBCondGoto: {
+      VerifyCondGotoBB(bb);
+      break;
+    }
+    case kBBGoto: {
+      VerifyGotoBB(bb);
+      break;
+    }
+    case kBBFallthru: {
+      VerifyFallthruBB(bb);
+      break;
+    }
+    case kBBReturn: {
+      VerifyReturnBB(bb);
+      break;
+    }
+    case kBBSwitch: {
+      VerifySwitchBB(bb);
+      break;
+    }
+    case kBBUnknown: {
+      if (bb.GetBBId() != 0 && bb.GetBBId() != 1) {
+        CHECK_FATAL(false, "Verify: must be Entry or Exit bb");
+      }
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "Verify: can not support this kind of bb");
+    }
+  }
+}
+
+// Filter the special case which created in the function named RemoveEhEdgesInSyncRegion of mefunction.
+void MeVerify::DealWithSpecialCase(const BB &currBB, const BB &tryBB) const {
+  if (meFunc.GetCfg()->GetEndTryBB2TryBB().size() != 1) {
+    CHECK_FATAL(false, "must be try");
+  }
+  if (currBB.GetAttributes(kBBAttrIsTryEnd)) {
+    auto endTryBB = currBB;
+    if (!(endTryBB.GetAttributes(kBBAttrIsCatch) || endTryBB.GetAttributes(kBBAttrIsJSCatch)) ||
+        endTryBB.GetKind() != kBBFallthru || !endTryBB.GetAttributes(kBBAttrIsTryEnd) ||
+        !endTryBB.GetAttributes(kBBAttrIsJavaFinally) || endTryBB.GetMeStmts().back().GetOp() != OP_syncexit ||
+        tryBB.GetMeStmts().back().GetOp() != OP_try) {
+      CHECK_FATAL(false, "must be try");
+    }
+  }
+  if (&currBB != &tryBB && !currBB.GetAttributes(kBBAttrIsTryEnd)) {
+    for (auto &stmt : currBB.GetMeStmts()) {
+      if (stmt.GetOp() == OP_try || stmt.GetOp() == OP_catch || stmt.GetOp() == OP_throw) {
+        CHECK_FATAL(false, "must be try");
+      }
+    }
+  }
+}
+
+void MeVerify::VerifyNestedTry(const BB &tryBB, const BB &currBB) const {
+  if (&currBB != &tryBB && !currBB.GetAttributes(kBBAttrIsTryEnd)) {
+    for (auto &stmt : currBB.GetMeStmts()) {
+      if (stmt.GetOp() == OP_try) {
+        CHECK_FATAL(false, "nested try");
+      }
+    }
+  }
+}
+
+void MeVerify::VerifyAttrTryBB(BB &tryBB, uint64 index) {
+  auto tryStmt = static_cast<TryMeStmt&>(tryBB.GetMeStmts().front());
+  int i = 0;
+  for (auto offsetIt = tryStmt.GetOffsets().rbegin(), offsetEIt = tryStmt.GetOffsets().rend();
+       offsetIt != offsetEIt; ++offsetIt) {
+    auto offsetBBId = meFunc.GetCfg()->GetLabelBBAt(*offsetIt)->GetBBId();
+    bool needExit = false;
+    for (size_t j = index; j < meFunc.GetLaidOutBBs().size() && !needExit; ++j) {
+      auto currBB = meFunc.GetLaidOutBBs().at(j);
+      if (currBB == nullptr) {
+        continue;
+      }
+      if (currBB->GetAttributes(kBBAttrIsTryEnd)) {
+        needExit = true;
+      }
+      // bb_layout move artificial bb without try-attribute into try
+      if (currBB->GetAttributes(kBBAttrArtificial)) {
+        continue;
+      }
+      // cannot appear nested try
+      VerifyNestedTry(tryBB, *currBB);
+      if (!currBB->GetAttributes(kBBAttrIsTry)) {
+        DealWithSpecialCase(*currBB, tryBB);
+        continue;
+      }
+      // verify try attribute
+      CHECK_FATAL(currBB->GetAttributes(kBBAttrIsTry), "must be try");
+      if (currBB->GetKind() == kBBReturn && currBB->GetAttributes(kBBAttrIsExit) &&
+          currBB->GetMeStmts().back().GetOp() == OP_return) {
+        continue;
+      }
+      // When the curr bb is catch, the preds could not include the eh edge.
+      if (currBB->GetAttributes(kBBAttrIsCatch) && currBB->GetAttributes(kBBAttrIsJavaFinally)) {
+        continue;
+      }
+      // When the size of gotoBB's succs is more than two, one is targetBB, one is  wontExitBB and the other is catchBB.
+      if (currBB->GetKind() == kBBGoto && currBB->GetAttributes(kBBAttrWontExit)) {
+        bool isEqual = false;
+        if ((*(currBB->GetSucc().rbegin() + i + 1)) != nullptr &&
+            offsetBBId == (*(currBB->GetSucc().rbegin() + i + 1))->GetBBId()) {
+          isEqual = true;
+        }
+        if ((*(currBB->GetSucc().rbegin() + i)) != nullptr &&
+            offsetBBId == (*(currBB->GetSucc().rbegin() + i))->GetBBId()) {
+          isEqual = true;
+        }
+        CHECK_FATAL(isEqual, "must be equal");
+      } else {
+        CHECK_FATAL(offsetBBId == (*(currBB->GetSucc().rbegin() + i))->GetBBId(), "must be equal");
+      }
+      if (enableDebug) {
+        LogInfo::MapleLogger() << currBB->GetBBId() << " " <<  (*(currBB->GetSucc().rbegin() + i))->GetBBId() << "\n";
+      }
+    }
+    CHECK_FATAL(needExit, "no tryend bb");
+    ++i;
+  }
+}
+
+void MeVerify::VerifyPredBBOfSuccBB(const BB &bb, const MapleVector<BB*> &succs) const {
+  bool find = false;
+  for (auto &succ : succs) {
+    for (auto &pred : succ->GetPred()) {
+      if (pred->GetBBId() == bb.GetBBId()) {
+        find = true;
+        break;
+      }
+    }
+    CHECK_FATAL(find, "Verify: bb is not pred of succ bb");
+    find = false;
+  }
+}
+
+void MeVerify::VerifyCondGotoBB(const BB &bb) const {
+  if (bb.GetAttributes(kBBAttrIsTry) || bb.GetAttributes(kBBAttrWontExit)) {
+    CHECK_FATAL(bb.GetSucc().size() >= 2, "Verify: condgoto bb must have more than two succ bb");
+  } else {
+    CHECK_FATAL(bb.GetSucc().size() == 2, "Verify: condgoto bb must have two succ bb");
+  }
+  CHECK_FATAL(!bb.GetMeStmts().empty(), "Verify: meStmts of bb should not be empty");
+  if (bb.GetMeStmts().back().GetOp() != OP_brfalse && bb.GetMeStmts().back().GetOp() != OP_brtrue) {
+    CHECK_FATAL(false, "Verify: the opcode of last stmt must be OP_brfalse or OP_brtrue");
+  }
+  CHECK_FATAL(static_cast<const CondGotoMeStmt&>(bb.GetMeStmts().back()).GetOffset() == bb.GetSucc(1)->GetBBLabel(),
+              "Verify: offset of condgoto stmt must equal to the label of second succ bb");
+  VerifyPredBBOfSuccBB(bb, bb.GetSucc());
+}
+
+void MeVerify::VerifyGotoBB(const BB &bb) const {
+  if (bb.GetAttributes(kBBAttrIsTry) || bb.GetAttributes(kBBAttrWontExit)) {
+    CHECK_FATAL(bb.GetSucc().size() >= 1, "Verify: goto bb must have more than one succ bb");
+  } else {
+    CHECK_FATAL(bb.GetSucc().size() == 1, "Verify: goto bb must have one succ bb");
+  }
+  CHECK_FATAL(!bb.GetMeStmts().empty(), "Verify: meStmts of bb should not be empty");
+  if (bb.GetMeStmts().back().GetOp() == OP_goto) {
+    CHECK_FATAL(static_cast<const GotoMeStmt&>(bb.GetMeStmts().back()).GetOffset() == bb.GetSucc(0)->GetBBLabel(),
+                "Verify: offset of goto stmt must equal to the label of succ bb");
+  }
+  VerifyPredBBOfSuccBB(bb, bb.GetSucc());
+}
+
+void MeVerify::VerifyFallthruBB(const BB &bb) const {
+  VerifyPredBBOfSuccBB(bb, bb.GetSucc());
+  if (bb.GetAttributes(kBBAttrIsTry) || bb.GetAttributes(kBBAttrWontExit)) {
+    CHECK_FATAL(bb.GetSucc().size() >= 1, "Verify: fallthru bb must have more than one succ bb");
+  } else {
+    CHECK_FATAL(bb.GetSucc().size() == 1, "Verify: fallthru bb must have one succ bb");
+  }
+}
+
+bool MeVerify::IsOnlyHaveReturnOrThrowStmt(const BB &bb, Opcode op) const {
+  auto stmt = &bb.GetMeStmts().front();
+  CHECK_NULL_FATAL(stmt);
+  while (stmt != nullptr) {
+    if (stmt->GetOp() == op || stmt->GetOp() == OP_decref || stmt->GetOp() == OP_incref ||
+        stmt->GetOp() == OP_decrefreset || stmt->GetOp() == OP_comment) {
+      stmt = stmt->GetNextMeStmt();
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+void MeVerify::VerifyCommonExitBB() const {
+  for (auto &pred : meFunc.GetCfg()->GetCommonExitBB()->GetPred()) {
+    if (pred->GetKind() == kBBReturn) {
+      continue;
+    }
+    if (pred->GetKind() == kBBGoto && IsOnlyHaveReturnOrThrowStmt(*pred, OP_throw)) {
+      continue;
+    }
+    CHECK_FATAL(false, "verify CommonExitBB failed");
+  }
+}
+
+void MeVerify::VerifyReturnBB(const BB &bb) const {
+  for (auto &pred : meFunc.GetCfg()->GetCommonExitBB()->GetPred()) {
+    if (pred == &bb) {
+      return;
+    }
+  }
+  CHECK_FATAL(false, "verify return bb failed");
+}
+
+void MeVerify::VerifySwitchBB(const BB &bb) const {
+  CHECK_FATAL(!bb.GetMeStmts().empty(), "Verify: meStmts of bb should not be empty");
+  auto switchMeStmt = static_cast<const SwitchMeStmt&>(bb.GetMeStmts().back());
+  auto switchTable = switchMeStmt.GetSwitchTable();
+  CHECK_FATAL(switchMeStmt.GetDefaultLabel() == bb.GetSucc(0)->GetBBLabel(),
+              "Verify: defaultlabel of switchstmt must be the label of first succ bb");
+  for (auto &casePair : switchTable) {
+    bool isExit = false;
+    for (auto &succBB : bb.GetSucc()) {
+      if (casePair.second == succBB->GetBBLabel()) {
+        isExit = true;
+        break;
+      }
+    }
+    CHECK_FATAL(isExit, "Verify: case label of switchtable must equal to the succ bb");
+  }
+  VerifyPredBBOfSuccBB(bb, bb.GetSucc());
+}
+
+bool MEVerify::PhaseRun(maple::MeFunction &f) {
+  MeVerify meVerify(f);
+  meVerify.VerifyFunction();
+  return false;
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/meconstprop.cpp b/src/mapleall/maple_me/src/meconstprop.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0bba911187ba5a8225f14cdf059026f6bb0b323
--- /dev/null
+++ b/src/mapleall/maple_me/src/meconstprop.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "meconstprop.h"
+#include <fstream>
+#include <iostream>
+#include "clone.h"
+#include "constantfold.h"
+#include "mir_nodes.h"
+#include "me_function.h"
+#include "ssa_mir_nodes.h"
+#include "mir_builder.h"
+
+namespace maple {
+void MeConstProp::IntraConstProp() const {}
+
+void MeConstProp::InterConstProp() const {}
+
+#ifdef NOT_USED
+AnalysisResult *MeDoIntraConstProp::Run(MeFunction*, MeFuncResultMgr*, ModuleResultMgr*) {
+  return nullptr;
+}
+
+AnalysisResult *MeDoInterConstProp::Run(MeFunction*, MeFuncResultMgr*, ModuleResultMgr*) {
+  return nullptr;
+}
+#endif
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/meexpr_use_info.cpp b/src/mapleall/maple_me/src/meexpr_use_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8cc0ea6bfdd3bdb2652e3a7004374d2d2405b095
--- /dev/null
+++ b/src/mapleall/maple_me/src/meexpr_use_info.cpp
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "meexpr_use_info.h"
+#include "irmap.h"
+#include "dominance.h"
+
+namespace maple {
+template <class T>
+void MeExprUseInfo::AddUseSiteOfExpr(MeExpr *expr, T *useSite) {
+  if (expr->GetExprID() == kInvalidExprID) {
+    return;
+  }
+
+  auto uintExprID = static_cast<uint32>(expr->GetExprID());
+  if (useSites->size() <= uintExprID) {
+    constexpr uint32 bufferSize = 50;
+    useSites->insert(useSites->cend(), uintExprID + bufferSize, {nullptr, nullptr});
+  }
+  if ((*useSites)[uintExprID].second == nullptr) {
+    auto *newList = allocator.New<MapleList<UseItem>>(allocator.Adapter());
+    newList->emplace_front(UseItem(useSite));
+    (*useSites)[uintExprID] = {expr, newList};
+    return;
+  }
+  UseItem use(useSite);
+  if ((*useSites)[uintExprID].second->front() != use) {
+    (*useSites)[uintExprID].second->emplace_front(use);
+  } else {
+    (*useSites)[uintExprID].second->front().IncreaseRef();
+  }
+}
+
+MapleList<UseItem> *MeExprUseInfo::GetUseSitesOfExpr(const MeExpr *expr) const {
+  if (IsInvalid()) {
+    CHECK_FATAL(false, "Expr use info is invalid");
+  } else if (!expr->IsScalar()) {
+    CHECK_FATAL(useInfoState == kUseInfoOfAllExpr, "expr is not scalar, use info has not been collected");
+  }
+
+  if (expr->GetExprID() == kInvalidExprID) {
+    return nullptr;
+  }
+
+  auto uintExprID = static_cast<uint32>(expr->GetExprID());
+  if (useSites->size() <= uintExprID) {
+    return nullptr;
+  }
+  return (*useSites)[uintExprID].second;
+}
+
+void MeExprUseInfo::CollectUseInfoInExpr(MeExpr *expr, MeStmt *stmt) {
+  if (expr == nullptr) {
+    return;
+  }
+  if (expr->IsScalar()) {
+    AddUseSiteOfExpr(static_cast<ScalarMeExpr *>(expr), stmt);
+    return;
+  }
+
+  if (useInfoState == kUseInfoOfAllExpr) {
+    AddUseSiteOfExpr(expr, stmt);
+  }
+
+  if (expr->GetMeOp() == kMeOpIvar) {
+    for (auto *mu : static_cast<IvarMeExpr*>(expr)->GetMuList()) {
+      AddUseSiteOfExpr(mu, stmt);
+    }
+  }
+
+  for (size_t opndId = 0; opndId < expr->GetNumOpnds(); ++opndId) {
+    auto opnd = expr->GetOpnd(opndId);
+    CollectUseInfoInExpr(opnd, stmt);
+  }
+}
+
+void MeExprUseInfo::CollectUseInfoInStmt(MeStmt *stmt) {
+  for (size_t opndId = 0; opndId < stmt->NumMeStmtOpnds(); ++opndId) {
+    auto *opnd = stmt->GetOpnd(opndId);
+    CollectUseInfoInExpr(opnd, stmt);
+  }
+
+  auto *muList = stmt->GetMuList();
+  if (muList != nullptr) {
+    for (auto &ost2mu : std::as_const(*muList)) {
+      AddUseSiteOfExpr(ost2mu.second, stmt);
+    }
+  }
+}
+
+void MeExprUseInfo::CollectUseInfoInBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+
+  auto &phiList = bb->GetMePhiList();
+  for (auto &ost2phi : std::as_const(phiList)) {
+    auto *phi = ost2phi.second;
+    if (!phi->GetIsLive()) {
+      continue;
+    }
+    for (size_t id = 0; id < phi->GetOpnds().size(); ++id) {
+      auto *opnd = phi->GetOpnd(id);
+      AddUseSiteOfExpr(opnd, phi);
+    }
+  }
+
+  for (auto &stmt : bb->GetMeStmts()) {
+    CollectUseInfoInStmt(&stmt);
+  }
+}
+
+void MeExprUseInfo::CollectUseInfoInFunc(IRMap *irMap, Dominance *domTree, MeExprUseInfoState state) {
+  if (!IsInvalid() && (state <= this->useInfoState)) {
+    return;
+  }
+  if (useSites != nullptr) {
+    for (auto &useSite : *useSites) {
+      if (useSite.second != nullptr) {
+        useSite.second->clear();
+      }
+    }
+    useSites->clear();
+  }
+
+  allocator.SetMemPool(irMap->GetIRMapAlloc().GetMemPool());
+  useSites = irMap->New<MapleVector<ExprUseInfoPair>>(allocator.Adapter());
+  if (irMap->GetExprID() >= 0) {
+    useSites->resize(static_cast<size_t>(irMap->GetExprID() + 1));
+  }
+  useInfoState = state;
+
+  for (auto bb : domTree->GetReversePostOrder()) {
+    CollectUseInfoInBB(irMap->GetBB(BBId(bb->GetID())));
+  }
+}
+
+bool MeExprUseInfo::ReplaceScalar(IRMap *irMap, const ScalarMeExpr *scalarA, ScalarMeExpr *scalarB) {
+  auto *useList = GetUseSitesOfExpr(scalarA);
+
+  if (!useList || useList->empty()) {
+    return true;
+  }
+
+  bool replacedAll = true;
+
+  auto end = useList->end();
+  decltype(end) next;
+
+  for (auto it = useList->begin(); it != end; it = next) {
+    next = std::next(it);
+    auto &useSite = *it;
+
+    if (useSite.IsUseByStmt()) {
+      auto *useStmt = useSite.GetStmt();
+
+      if (irMap->ReplaceMeExprStmt(*useStmt, *scalarA, *scalarB)) {
+        AddUseSiteOfExpr(scalarB, useStmt);
+        useList->erase(it);
+      }
+    } else {
+      ASSERT(useSite.IsUseByPhi(), "Invalid use type!");
+
+      if (scalarA->GetOst() != scalarB->GetOst()) {
+        replacedAll = false;
+        continue;
+      }
+
+      auto *phi = useSite.GetPhi();
+
+      for (size_t id = 0; id < phi->GetOpnds().size(); ++id) {
+        if (phi->GetOpnd(id) != scalarA) {
+          continue;
+        }
+
+        phi->GetOpnds()[id] = scalarB;
+        AddUseSiteOfExpr(scalarB, phi);
+        useList->erase(it);
+      }
+    }
+  }
+
+  return replacedAll;
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/occur.cpp b/src/mapleall/maple_me/src/occur.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9a52a85ffe76c6c80bbb0a675945e6ce9c9b0572
--- /dev/null
+++ b/src/mapleall/maple_me/src/occur.cpp
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "occur.h"
+#include "ssa_pre.h"
+
+// The methods associated with the data structures that represent occurrences
+// and work candidates for SSAPRE
+namespace {
+constexpr uint32_t kOffsetMeExprID = 5;
+constexpr uint32_t kOffsetVarMeExprOstIdx = 4;
+constexpr uint32_t kOffsetRegMeExprRegIdx = 6;
+constexpr uint32_t kOffsetIvarMeExprTyIdx = 3;
+constexpr uint32_t kOffsetOpMeExprOpnd = 2;
+constexpr uint32_t kOffsetNaryMeExprOpnd = 2;
+constexpr uint32_t kOffsetMeStmtOpcode = 3;
+constexpr uint32_t kOffsetUnaryMeStmtOpcode = 2;
+constexpr uint32_t kOffsetIntrinsicCallMeStmtIntrinsic = 3;
+constexpr uint32_t kOffsetNaryMeStmtOpnd = 2;
+}
+
+namespace maple {
+void MeOccur::DumpOccur(IRMap &irMap) {
+  MIRModule *mod = &irMap.GetSSATab().GetModule();
+  mod->GetOut() << "MeOccur ";
+  Dump(irMap);
+  mod->GetOut() << "\n  class: " << classID << '\n';
+  if (def != nullptr) {
+    mod->GetOut() << "  def by class: " << def->GetClassID();
+  } else {
+    mod->GetOut() << "  no-def";
+  }
+  mod->GetOut() << '\n';
+}
+
+// return if this occur dominate occ
+bool MeOccur::IsDominate(Dominance &dom, MeOccur &occ) {
+  switch (occTy) {
+    case kOccReal: {
+      switch (occ.GetOccType()) {
+        case kOccCompare:
+        case kOccReal: {
+          if (mirBB == occ.GetBB()) {
+            auto *thisRealOcc = static_cast<MeRealOcc*>(this);
+            auto *domOcc = static_cast<MeRealOcc*>(&occ);
+            return thisRealOcc->GetSequence() <= domOcc->GetSequence();
+          }
+          return dom.Dominate(*mirBB, *occ.GetBB());
+        }
+        case kOccPhiocc: {
+          if (mirBB == occ.GetBB()) {
+            return false;
+          }
+          return dom.Dominate(*mirBB, *occ.GetBB());
+        }
+        case kOccPhiopnd:
+        case kOccExit:
+        case kOccMembar:
+        case kOccUse:
+          return dom.Dominate(*mirBB, *occ.GetBB());
+        default:
+          ASSERT(false, "should not be here");
+          break;
+      }
+      break;
+    }
+    case kOccPhiocc:
+    case kOccMembar:
+    case kOccUse:
+      return dom.Dominate(*mirBB, *occ.GetBB());
+    default:
+      ASSERT(false, "should not be here");
+      return false;
+  }
+
+  return false;
+}
+
+MeExpr *MeOccur::GetSavedExpr() {
+  switch (occTy) {
+    case kOccReal:
+      return static_cast<MeRealOcc*>(this)->GetSavedExpr();
+    case kOccPhiocc: {
+      auto *phiOcc = static_cast<MePhiOcc*>(this);
+      MePhiNode *regPhi = phiOcc->GetRegPhi();
+      if (regPhi != nullptr) {
+        return regPhi->GetLHS();
+      } else {
+        return phiOcc->GetVarPhi()->GetLHS();
+      }
+    }
+    case kOccInserted:
+      return static_cast<MeInsertedOcc*>(this)->GetSavedExpr();
+    default:
+      CHECK_FATAL(false, "error or NYI");
+  }
+}
+
+// return true if either:
+// operand is nullptr (def is null), or
+// hasRealUse is false and defined by a PHI not will be avail
+bool MePhiOpndOcc::IsOkToInsert() const {
+  if (GetDef() == nullptr) {
+    return true;
+  }
+  if (!hasRealUse) {
+    const MeOccur *defOcc = GetDef();
+    if (defOcc->GetOccType() == kOccPhiocc && !static_cast<const MePhiOcc*>(defOcc)->IsWillBeAvail()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MePhiOcc::IsOpndDefByRealOrInserted() const {
+  for (MePhiOpndOcc *phiOpnd : phiOpnds) {
+    MeOccur *defOcc = phiOpnd->GetDef();
+    if (defOcc->GetOccType() == kOccReal || defOcc->GetOccType() == kOccInserted) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void MeOccur::Dump(const IRMap &irMap) const {
+  MIRModule *mod = &irMap.GetSSATab().GetModule();
+  if (occTy == kOccExit) {
+    mod->GetOut() << "ExitOcc at bb" << GetBB()->GetBBId();
+  } else if (occTy == kOccUse) {
+    mod->GetOut() << "UseOcc at bb" << GetBB()->GetBBId();
+  } else {
+    CHECK_FATAL(false, "wrong occur type");
+  }
+}
+
+void MeRealOcc::Dump(const IRMap &irMap) const {
+  MIRModule *mod = &irMap.GetSSATab().GetModule();
+  if (GetOccType() == kOccReal) {
+    if (!isLHS) {
+      mod->GetOut() << "RealOcc ";
+    } else {
+      mod->GetOut() << "RealOcc(LHS) ";
+    }
+    if (meExpr != nullptr) {
+      meExpr->Dump(&irMap);
+    } else {
+      ASSERT_NOT_NULL(meStmt);
+      meStmt->Dump(&irMap);
+    }
+    if (meStmt != nullptr && meStmt->GetBB()) {
+      mod->GetOut() << " at bb" << meStmt->GetBB()->GetBBId() << " seq " << seq << " classID " << GetClassID();
+    } else {
+      mod->GetOut() << " classID " << GetClassID();
+    }
+  } else if (GetOccType() == kOccCompare) {
+    mod->GetOut() << "CompOcc ";
+    meExpr->Dump(&irMap);
+    mod->GetOut() << " at bb" << GetBB()->GetBBId() << " seq " << seq << " classID " << GetClassID();
+  } else {
+    mod->GetOut() << "MembarOcc ";
+    mod->GetOut() << " at bb" << GetBB()->GetBBId() << " seq " << seq;
+  }
+}
+
+void MePhiOcc::Dump(const IRMap &irMap) const {
+  MIRModule *mod = &irMap.GetSSATab().GetModule();
+  mod->GetOut() << "PhiOcc ";
+  mod->GetOut() << "PHI(";
+  size_t size = phiOpnds.size();
+  for (size_t i = 0; i < size; i++) {
+    phiOpnds[i]->Dump(irMap);
+    if (i != size - 1) {
+      mod->GetOut() << ",";
+    }
+  }
+  mod->GetOut() << ")";
+  mod->GetOut() << " at bb" << GetBB()->GetBBId() << " classID " << GetClassID();
+}
+
+void MePhiOpndOcc::Dump(const IRMap &irMap) const {
+  MIRModule *mod = &irMap.GetSSATab().GetModule();
+  mod->GetOut() << "PhiOpndOcc at bb" << GetBB()->GetBBId() << " classID " << GetClassID();
+  if (hasRealUse) {
+    mod->GetOut() << "(hasRealUse) ";
+  }
+}
+
+void MeInsertedOcc::Dump(const IRMap &irMap) const {
+  MIRModule *mod = &irMap.GetSSATab().GetModule();
+  mod->GetOut() << "InsertedOcc at bb" << GetBB()->GetBBId() << " classID " << GetClassID();
+}
+
+// compute bucket index for the work candidate in workCandHashTable
+uint32 PreWorkCandHashTable::ComputeWorkCandHashIndex(const MeExpr &meExpr) {
+  uint32 hashIdx = 0;
+  MeExprOp meOp = meExpr.GetMeOp();
+  switch (meOp) {
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpAddroflabel:
+    case kMeOpGcmalloc:
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpSizeoftype:
+    case kMeOpFieldsDist:
+      hashIdx = (static_cast<uint32>(meExpr.GetExprID())) << kOffsetMeExprID;
+      break;
+    case kMeOpVar: {
+      auto &varMeExpr = static_cast<const VarMeExpr&>(meExpr);
+      hashIdx = static_cast<uint32_t>(varMeExpr.GetOstIdx()) << kOffsetVarMeExprOstIdx;
+      break;
+    }
+    case kMeOpReg: {
+      auto &regMeExpr = static_cast<const RegMeExpr&>(meExpr);
+      hashIdx = (static_cast<uint32>(static_cast<PregIdx>(regMeExpr.GetRegIdx()))) << kOffsetRegMeExprRegIdx;
+      break;
+    }
+    case kMeOpIvar: {
+      auto &iVar = static_cast<const IvarMeExpr&>(meExpr);
+      hashIdx = ComputeWorkCandHashIndex(*iVar.GetBase()) +
+                (static_cast<uint32>(iVar.GetTyIdx()) << kOffsetIvarMeExprTyIdx) +
+                static_cast<uint32>(iVar.GetFieldID()) + static_cast<uint32>(iVar.GetOffset());
+      break;
+    }
+    case kMeOpOp: {
+      hashIdx = static_cast<uint32>(meExpr.GetOp());
+      for (size_t idx = 0; idx < kOperandNumTernary; ++idx) {
+        MeExpr *opnd = meExpr.GetOpnd(idx);
+        if (opnd == nullptr) {
+          break;
+        }
+        hashIdx += ComputeWorkCandHashIndex(*opnd) << kOffsetOpMeExprOpnd;
+      }
+      break;
+    }
+    case kMeOpNary: {
+      hashIdx = static_cast<uint32>(meExpr.GetOp());
+      for (uint8 i = 0; i < meExpr.GetNumOpnds(); ++i) {
+        hashIdx += ComputeWorkCandHashIndex(*meExpr.GetOpnd(i)) << kOffsetNaryMeExprOpnd;
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "MeOP NIY");
+  }
+  return hashIdx % workCandHashLength;
+}
+
+// insert occ as realOccs[pos] after shifting the vector elements further down
+void PreWorkCand::InsertRealOccAt(MeRealOcc &occ, const MapleVector<MeRealOcc*>::iterator it, PUIdx pIdx) {
+  ASSERT(pIdx != 0, "puIdx of realocc cannot be 0");
+  if (pIdx != puIdx) {
+    ASSERT(!hasLocalOpnd, "candidate with local opnd cannot have real occurrences in more than one PU");
+    puIdx = 0;
+  }
+  CHECK(!realOccs.empty(), "realOccs has no element in PreWorkCand::InsertRealOccAt");
+  realOccs.insert(it, &occ);
+}
+
+// insert occ in realOccs maintaining sorted order according to dt_preorder
+void PreWorkCand::AddRealOccSorted(const Dominance &dom, MeRealOcc &occ, PUIdx pIdx) {
+  ASSERT(!realOccs.empty(), "AddRealOccSorted: realOccs is empty");
+  uint32 occDfn = dom.GetDtDfnItem(occ.GetBB()->GetBBId());
+  // check the end of realOccs first because inserting at end is most frequent
+  if (occDfn > dom.GetDtDfnItem(realOccs.back()->GetBB()->GetBBId())) {
+    AddRealOccAsLast(occ, pIdx);
+  } else if (occDfn == dom.GetDtDfnItem(realOccs.back()->GetBB()->GetBBId())) {
+    if (occ.GetSequence() >= realOccs.back()->GetSequence()) {
+      AddRealOccAsLast(occ, pIdx);
+    } else {
+      auto rIt = realOccs.rbegin();
+      ++rIt;
+      while (rIt != realOccs.rend()) {
+        if (occDfn > dom.GetDtDfnItem((*rIt)->GetBB()->GetBBId())) {
+          break;
+        }
+        if (occ.GetSequence() >= (*rIt)->GetSequence()) {
+          break;
+        }
+        ++rIt;
+      }
+      InsertRealOccAt(occ, rIt.base(), pIdx);
+    }
+  } else {
+    // search from beginning of realOccs
+    auto it = realOccs.begin();
+    bool found = false;
+    do {
+      if (occDfn > dom.GetDtDfnItem((*it)->GetBB()->GetBBId())) {
+        ++it;
+      } else if (occDfn == dom.GetDtDfnItem((*it)->GetBB()->GetBBId())) {
+        if (occ.GetSequence() > (*it)->GetSequence()) {
+          ++it;
+        } else {
+          found = true;
+        }
+      } else {
+        found = true;
+      }
+    } while (!found && it != realOccs.end());
+    if (!found) {
+      AddRealOccAsLast(occ, pIdx);
+    } else {
+      InsertRealOccAt(occ, it, pIdx);
+    }
+  }
+}
+
+// compute bucket index for the work candidate in workCandHashTable
+uint32 PreWorkCandHashTable::ComputeStmtWorkCandHashIndex(const MeStmt &stmt) {
+  uint32 hIdx = (static_cast<uint32>(stmt.GetOp())) << kOffsetMeStmtOpcode;
+  switch (stmt.GetOp()) {
+    CASE_OP_ASSERT_NONNULL {
+      hIdx += ComputeWorkCandHashIndex(*stmt.GetOpnd(0)) << kOffsetUnaryMeStmtOpcode;
+      break;
+    }
+    CASE_OP_ASSERT_BOUNDARY {
+      for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+        hIdx += ComputeWorkCandHashIndex(*stmt.GetOpnd(i)) << kOffsetNaryMeStmtOpnd;
+      }
+      break;
+    }
+    case OP_dassign: {
+      CHECK_NULL_FATAL(stmt.GetVarLHS());
+      CHECK_NULL_FATAL(stmt.GetRHS());
+      ScalarMeExpr *varMeExpr = stmt.GetVarLHS();
+      hIdx += static_cast<uint32_t>(varMeExpr->GetOstIdx()) << kOffsetVarMeExprOstIdx;
+      hIdx += ComputeWorkCandHashIndex(*stmt.GetRHS()) << 1;
+      break;
+    }
+    case OP_intrinsiccall:
+    case OP_intrinsiccallwithtype: {
+      auto &intrnStmt = static_cast<const IntrinsiccallMeStmt&>(stmt);
+      hIdx += (static_cast<uint32>(intrnStmt.GetIntrinsic())) << kOffsetIntrinsicCallMeStmtIntrinsic;
+      if (stmt.GetOp() == OP_intrinsiccallwithtype) {
+        hIdx += static_cast<uint32>(intrnStmt.GetTyIdx()) << 1;
+      }
+      for (size_t i = 0; i < intrnStmt.NumMeStmtOpnds(); ++i) {
+        hIdx += ComputeWorkCandHashIndex(*intrnStmt.GetOpnd(i)) << 1;
+      }
+      break;
+    }
+    case OP_callassigned: {
+      auto &callAss = static_cast<const CallMeStmt&>(stmt);
+      hIdx += callAss.GetPUIdx();
+      for (size_t i = 0; i < callAss.NumMeStmtOpnds(); ++i) {
+        hIdx += ComputeWorkCandHashIndex(*callAss.GetOpnd(i)) << kOffsetNaryMeStmtOpnd;
+      }
+      if (!callAss.GetMustDefList().empty()) {
+        const MeExpr *lhs = callAss.GetMustDefList().front().GetLHS();
+        auto *lhsVar = static_cast<const VarMeExpr*>(lhs);
+        hIdx += static_cast<uint32>(lhsVar->GetOstIdx()) << 1;
+      }
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "ComputeStmtWorkCandHashIndex: NYI");
+  }
+  return hIdx % workCandHashLength;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/optimizeCFG.cpp b/src/mapleall/maple_me/src/optimizeCFG.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5a5d02ec196abac42f978ef1431cca5112673fd5
--- /dev/null
+++ b/src/mapleall/maple_me/src/optimizeCFG.cpp
@@ -0,0 +1,2678 @@
+
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "optimizeCFG.h"
+
+#include "bb.h"
+#include "factory.h"
+#include "global_tables.h"
+#include "me_phase_manager.h"
+#include "mir_symbol.h"
+#include "mpl_logging.h"
+#include "orig_symbol.h"
+#include "types_def.h"
+
+namespace maple {
+namespace {
+bool debug = false;
+std::string funcName;
+std::string phaseName;
+
+#define LOG_BBID(BB) ((BB)->GetBBId().GetIdx())
+#define DEBUG_LOG() \
+  if (debug) LogInfo::MapleLogger() << "[" << phaseName << "] "
+
+// return {trueBB, falseBB}
+std::pair<BB*, BB*> GetTrueFalseBrPair(BB *bb) {
+  if (bb == nullptr) {
+    return {nullptr, nullptr};
+  }
+  if (bb->GetKind() == kBBCondGoto) {
+    auto *condBr = static_cast<CondGotoMeStmt*>(bb->GetLastMe());
+    CHECK_FATAL(condBr, "condBr is nullptr!");
+    if (condBr->GetOp() == OP_brtrue) {
+      return {bb->GetSucc(1), bb->GetSucc(0)};
+    } else {
+      ASSERT(condBr->GetOp() == OP_brfalse, "only support brtrue/brfalse");
+      return {bb->GetSucc(0), bb->GetSucc(1)};
+    }
+  } else if (bb->GetKind() == kBBGoto) {
+    return {bb->GetSucc(0), nullptr};
+  }
+  return {nullptr, nullptr};
+}
+
+// Only one fallthru is allowed for a bb at most , but a bb may have be more than one fallthru pred
+// temporarily during optimizing process.
+size_t GetFallthruPredNum(const BB &bb) {
+  size_t num = 0;
+  for (BB *pred : bb.GetPred()) {
+    if (pred->GetKind() == kBBFallthru) {
+      ++num;
+    } else if (pred->GetKind() == kBBCondGoto && pred->GetSucc(0) == &bb) {
+      ++num;
+    }
+  }
+  return num;
+}
+
+// This interface is use to check for every bits of two floating point num, not just their value.
+// example:
+// The result of IsFloatingPointNumBitsSame<double >(16.1 * 100 + 0.9 * 100, 17.0 * 100) is false,
+// althought their value is the same.
+// A = 16.1 * 100 + 0.9 * 100 => bits : 0x409A 9000 0000 0001
+// and
+// B = 17.0 * 100             => bits : 0x409A 9000 0000 0000
+template <class T, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+bool IsFloatingPointNumBitsSame(T val1, T val2) {
+  if (std::is_same<T, float>::value) {
+    return *reinterpret_cast<uint32*>(&val1) == *reinterpret_cast<uint32*>(&val2);
+  } else if (std::is_same<T, double>::value) {
+    return *reinterpret_cast<uint64*>(&val1) == *reinterpret_cast<uint64*>(&val2);
+  }
+  return false;
+}
+
+// Collect expressions that may be unsafe from expr to exprSet
+void CollectUnsafeExpr(MeExpr *expr, std::set<MeExpr*> &exprSet) {
+  if (expr->GetMeOp() == kMeOpConst || expr->GetMeOp() == kMeOpVar) {
+    return;
+  }
+  if (expr->GetMeOp() == kMeOpIvar) {  // do not use HasIvar here for efficiency reasons
+    exprSet.insert(expr);
+  }
+  if (expr->GetOp() == OP_div || expr->GetOp() == OP_rem) {
+    MeExpr *opnd1 = expr->GetOpnd(1);
+    if (opnd1->GetMeOp() == kMeOpConst && !opnd1->IsZero()) {
+      CollectUnsafeExpr(expr->GetOpnd(0), exprSet);
+    }
+    // we are not sure whether opnd1 may be zero
+    exprSet.insert(expr);
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    CollectUnsafeExpr(expr->GetOpnd(i), exprSet);
+  }
+}
+
+// expr not throw exception
+bool IsSafeExpr(const MeExpr *expr) {
+  if (expr->GetMeOp() == kMeOpIvar) {  // do not use HasIvar here for efficiency reasons
+    return false;
+  }
+  if (expr->GetOp() == OP_div || expr->GetOp() == OP_rem) {
+    MeExpr *opnd1 = expr->GetOpnd(1);
+    if (opnd1->GetMeOp() == kMeOpConst && !opnd1->IsZero()) {
+      return IsSafeExpr(expr->GetOpnd(0));
+    }
+    // we are not sure whether opnd1 may be zero
+    return false;
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    if (!IsSafeExpr(expr->GetOpnd(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// simple imm : can be assign to an reg by only one insn
+bool IsSimpleImm(uint64 imm) {
+  return ((imm & (static_cast<uint64>(0xffff) << 48u)) == imm) ||
+         ((imm & (static_cast<uint64>(0xffff) << 32u)) == imm) ||
+         ((imm & (static_cast<uint64>(0xffff) << 16u)) == imm) || ((imm & (static_cast<uint64>(0xffff))) == imm) ||
+         (((~imm) & (static_cast<uint64>(0xffff) << 48u)) == ~imm) ||
+         (((~imm) & (static_cast<uint64>(0xffff) << 32u)) == ~imm) ||
+         (((~imm) & (static_cast<uint64>(0xffff) << 16u)) == ~imm) ||
+         (((~imm) & (static_cast<uint64>(0xffff))) == ~imm);
+}
+
+// this function can only check for expr itself, not iteratively check for opnds
+// if non-simple imm exist, return it, otherwise return 0
+int64 GetNonSimpleImm(MeExpr *expr) {
+  if (expr->GetMeOp() == kMeOpConst && IsPrimitiveInteger(expr->GetPrimType())) {
+    int64 imm = static_cast<MIRIntConst*>(static_cast<ConstMeExpr*>(expr)->GetConstVal())->GetExtValue();
+    if (!IsSimpleImm(static_cast<uint64>(imm))) {
+      return imm;
+    }
+  }
+  return 0;  // 0 is a simple imm
+}
+
+// Check if ftBB has only one regassign stmt, if regassign exists, return it, otherwise return nullptr
+AssignMeStmt *GetSingleAssign(BB *bb) {
+  MeStmt *stmt = bb->GetFirstMe();
+  // Skip comment stmt at the beginning of bb
+  while (stmt != nullptr && stmt->GetOp() == OP_comment) {
+    stmt = stmt->GetNextMeStmt();
+  }
+  if (stmt == nullptr) {  // empty bb or has only comment stmt
+    return nullptr;
+  }
+  if (stmt->GetOp() == OP_regassign || stmt->GetOp() == OP_dassign) {
+    auto *ass = static_cast<AssignMeStmt*>(stmt);
+    // Skip comment stmt under this regassign
+    stmt = stmt->GetNextMeStmt();
+    while (stmt != nullptr && stmt->GetOp() == OP_comment) {
+      stmt = stmt->GetNextMeStmt();
+    }
+    if (stmt == nullptr || stmt->GetOp() == OP_goto) {
+      return ass;
+    }
+  }
+  return nullptr;
+}
+
+bool IsAllOpndsNotDefByCurrBB(const MeExpr &expr, const BB &currBB, std::set<const ScalarMeExpr*> &infLoopCheck) {
+  switch (expr.GetMeOp()) {
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpAddrof:
+    case kMeOpAddroflabel:
+    case kMeOpAddroffunc:
+    case kMeOpSizeoftype:
+      return true;
+    case kMeOpVar:
+    case kMeOpReg: {
+      auto &scalarExpr = static_cast<const ScalarMeExpr&>(expr);
+      MeStmt *stmt = scalarExpr.GetDefByMeStmt();
+      if (stmt == nullptr) {
+        // not def by a stmt, may be def by a phinode.
+        if (scalarExpr.IsDefByPhi()) {
+          const MePhiNode &phiNode = scalarExpr.GetDefPhi();
+          const BB *bb = phiNode.GetDefBB();
+          if (bb == &currBB) {
+            return true;
+          } else {
+            // If phinode is in a bb that has been deleted from cfg, and has only one opnd,
+            // we should find its real def thru use-def chain
+            // If use-def chain in a loop of phinodes, we can be sure that its real def is in its ancestors.
+            auto result = infLoopCheck.emplace(&scalarExpr);
+            if (!result.second) {  // element is in infLoopCheck, all the def are phinode
+              return true;
+            }
+            if (bb->GetPred().empty() && bb->GetSucc().empty() && phiNode.GetOpnds().size() == 1) {
+              ScalarMeExpr *phiOpnd = phiNode.GetOpnd(0);
+              return IsAllOpndsNotDefByCurrBB(*phiOpnd, currBB, infLoopCheck);
+            }
+          }
+        }
+        return true;
+      }
+      return stmt->GetBB() != &currBB;
+    }
+    case kMeOpIvar: {
+      auto &ivar = static_cast<const IvarMeExpr&>(expr);
+      if (!IsAllOpndsNotDefByCurrBB(*ivar.GetBase(), currBB, infLoopCheck)) {
+        return false;
+      }
+      for (auto *mu : ivar.GetMuList()) {
+        if (!IsAllOpndsNotDefByCurrBB(*mu, currBB, infLoopCheck)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case kMeOpNary:
+    case kMeOpOp: {
+      for (size_t i = 0; i < expr.GetNumOpnds(); ++i) {
+        if (!IsAllOpndsNotDefByCurrBB(*expr.GetOpnd(i), currBB, infLoopCheck)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    default:
+      return false;
+  }
+  // never reach here
+  CHECK_FATAL(false, "[FUNC: %s] Should never reach here!", funcName.c_str());
+  return false;
+}
+
+// opnds is defined by stmt not in currBB or defined by phiNode(no matter whether in currBB)
+bool IsAllOpndsNotDefByCurrBB(const MeStmt &stmt) {
+  const BB *currBB = stmt.GetBB();
+  for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
+    std::set<const ScalarMeExpr*> infLoopCheck;
+    if (!IsAllOpndsNotDefByCurrBB(*stmt.GetOpnd(i), *currBB, infLoopCheck)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+MeExpr *GetInvertCond(MeIRMap *irmap, MeExpr *cond) {
+  if (IsCompareHasReverseOp(cond->GetOp())) {
+    return irmap->CreateMeExprBinary(GetReverseCmpOp(cond->GetOp()), cond->GetPrimType(), *cond->GetOpnd(0),
+                                     *cond->GetOpnd(1));
+  }
+  return irmap->CreateMeExprUnary(OP_lnot, cond->GetPrimType(), *cond);
+}
+
+// Is subSet a subset of superSet?
+template <class T>
+inline bool IsSubset(const std::set<T> &subSet, const std::set<T> &superSet) {
+  return std::includes(superSet.begin(), superSet.end(), subSet.begin(), subSet.end());
+}
+
+// before : predCond ---> succCond
+// Is it safe when we use logical operation to merge predCond and succCond together?
+// If unsafe expr in succCond is included in preCond, return true; otherwise return false;
+bool IsSafeToMergeCond(MeExpr *predCond, MeExpr *succCond) {
+  // Make sure succCond is not dependent on predCond
+  // e.g. if (ptr != nullptr) if (*ptr), the second condition depends on the first one
+  if (predCond == succCond) {
+    return true;  // same expr
+  }
+  if (!IsSafeExpr(succCond)) {
+    std::set<MeExpr*> predSet;
+    CollectUnsafeExpr(predCond, predSet);
+    std::set<MeExpr*> succSet;
+    CollectUnsafeExpr(succCond, succSet);
+    if (!IsSubset(succSet, predSet)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IsProfitableToMergeCond(MeExpr *predCond, MeExpr *succCond) {
+  if (predCond == succCond) {
+    return true;
+  }
+  ASSERT(IsSafeToMergeCond(predCond, succCond), "please check for safety first");
+  // no constraint for predCond
+  // Only "cmpop (var/reg/const, var/reg/const)" are allowed for subCond
+  if (IsCompareHasReverseOp(succCond->GetOp())) {
+    MeExprOp opnd0Op = succCond->GetOpnd(0)->GetMeOp();
+    MeExprOp opnd1Op = succCond->GetOpnd(1)->GetMeOp();
+    if ((opnd0Op == kMeOpVar || opnd0Op == kMeOpReg || opnd0Op == kMeOpConst) &&
+        (opnd1Op == kMeOpVar || opnd1Op == kMeOpReg || opnd1Op == kMeOpConst)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// simple cmp expr is "scalarExpr cmp constExpr/scalarExpr"
+std::unique_ptr<ValueRange> GetVRForSimpleCmpExpr(const MeExpr &expr) {
+  Opcode op = expr.GetOp();
+  if (!IsCompareHasReverseOp(op)) {
+    return nullptr;
+  }
+  // only deal with "scalarExpr cmp constExpr"
+  MeExpr *opnd0 = expr.GetOpnd(0);
+  if (!opnd0->IsScalar()) {
+    return nullptr;
+  }
+  PrimType opndType = static_cast<const OpMeExpr&>(expr).GetOpndType();
+  if (!IsPrimitiveInteger(opndType)) {
+    return nullptr;
+  }
+  Bound opnd1Bound(nullptr, 0, opndType);  // bound of expr's opnd1
+  if (expr.GetOpnd(1)->GetMeOp() == kMeOpConst) {
+    MIRConst *constVal = static_cast<ConstMeExpr*>(expr.GetOpnd(1))->GetConstVal();
+    if (constVal->GetKind() != kConstInt) {
+      return nullptr;
+    }
+    int64 val = static_cast<MIRIntConst*>(constVal)->GetExtValue();
+    opnd1Bound.SetConstant(val);
+  } else if (expr.GetOpnd(1)->IsScalar()) {
+    opnd1Bound.SetVar(expr.GetOpnd(1));
+  } else {
+    return nullptr;
+  }
+  Bound maxBound = Bound::MaxBound(opndType);
+  Bound minBound = Bound::MinBound(opndType);
+
+  switch (op) {
+    case OP_gt: {
+      return std::make_unique<ValueRange>(++opnd1Bound, maxBound, kLowerAndUpper);
+    }
+    case OP_ge: {
+      return std::make_unique<ValueRange>(opnd1Bound, maxBound, kLowerAndUpper);
+    }
+    case OP_lt: {
+      return std::make_unique<ValueRange>(minBound, --opnd1Bound, kLowerAndUpper);
+    }
+    case OP_le: {
+      return std::make_unique<ValueRange>(minBound, opnd1Bound, kLowerAndUpper);
+    }
+    case OP_eq: {
+      return std::make_unique<ValueRange>(opnd1Bound, kEqual);
+    }
+    case OP_ne: {
+      return std::make_unique<ValueRange>(opnd1Bound, kNotEqual);
+    }
+    default: {
+      return nullptr;
+    }
+  }
+}
+
+// Check for pattern as below, return commonBB if exit, return nullptr otherwise.
+//        predBB
+//        /  \
+//       /  succBB
+//      /   /   \
+//     commonBB  exitBB
+// note: there may be some empty BB between predBB->commonBB, and succBB->commonBB, we should skip them
+BB *GetCommonDest(BB *predBB, BB *succBB) {
+  if (predBB == nullptr || succBB == nullptr || predBB == succBB) {
+    return nullptr;
+  }
+  if (predBB->GetKind() != kBBCondGoto || succBB->GetKind() != kBBCondGoto) {
+    return nullptr;
+  }
+  BB *psucc0 = FindFirstRealSucc(predBB->GetSucc(0));
+  BB *psucc1 = FindFirstRealSucc(predBB->GetSucc(1));
+  BB *ssucc0 = FindFirstRealSucc(succBB->GetSucc(0));
+  BB *ssucc1 = FindFirstRealSucc(succBB->GetSucc(1));
+  if (psucc0 == nullptr || psucc1 == nullptr || ssucc0 == nullptr || ssucc1 == nullptr) {
+    return nullptr;
+  }
+
+  if (psucc0 != succBB && psucc1 != succBB) {
+    return nullptr;  // predBB has no branch to succBB
+  }
+  BB *commonBB = (psucc0 == succBB) ? psucc1 : psucc0;
+  if (commonBB == nullptr) {
+    return nullptr;
+  }
+  if (ssucc0 == commonBB || ssucc1 == commonBB) {
+    return commonBB;
+  }
+  return nullptr;
+};
+
+// Collect all var expr to varSet iteratively
+bool DoesExprContainSubExpr(const MeExpr *expr, MeExpr *subExpr) {
+  if (expr == subExpr) {
+    return true;
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    if (DoesExprContainSubExpr(expr->GetOpnd(i), subExpr)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// a <- cond ? ftRHS : gtRHS
+// We have tried to get ftRHS/gtRHS from stmt before, if it still nullptr, try to find it from phiNode
+//    a <- mx1
+//      cond
+//     |    \
+//     |    a <- mx2
+//     |    /
+//     a <- phi(mx1, mx2)
+// we turn it to
+// a <- cond ? mx1 : mx2
+// so we should find oldVersion(mx1) from phi in jointBB
+MeExpr *FindCond2SelRHSFromPhiNode(BB *condBB, const BB *ftOrGtBB, BB *jointBB, const OStIdx &ostIdx) {
+  if (ftOrGtBB != jointBB) {
+    return nullptr;
+  }
+  int predIdx = GetRealPredIdx(*jointBB, *condBB);
+  ASSERT(predIdx != -1, "[FUNC: %s]ftBB is not a pred of jointBB", funcName.c_str());
+  auto &phiList = jointBB->GetMePhiList();
+  auto it = phiList.find(ostIdx);
+  if (it == phiList.end()) {
+    return nullptr;
+  }
+  MePhiNode *phi = it->second;
+  ScalarMeExpr *ftOrGtRHS = phi->GetOpnd(static_cast<size_t>(predIdx));
+  while (ftOrGtRHS->IsDefByPhi()) {
+    MePhiNode &phiNode = ftOrGtRHS->GetDefPhi();
+    BB *bb = phiNode.GetDefBB();
+    // bb is a succ of condBB, find the real def thru use-def chain
+    // when we find a version defined by condBB, or condBB's ancestor, we can stop.
+    if (bb->GetBBId() == condBB->GetBBId() || phiNode.GetOpnds().size() != 1 || GetRealSuccIdx(*condBB, *bb) == -1) {
+      break;
+    }
+    ftOrGtRHS = phiNode.GetOpnd(0);
+  }
+  return ftOrGtRHS;
+}
+
+// expr has deref nullptr or div/rem zero, return expr;
+// if it is not sure whether the expr will throw exception, return nullptr
+void MustThrowExceptionExpr(MeExpr *expr, std::set<MeExpr*> &exceptionExpr) {
+  if (expr->GetMeOp() == kMeOpIvar) {
+    // deref nullptr
+    if (static_cast<IvarMeExpr*>(expr)->GetBase()->IsZero()) {
+      exceptionExpr.emplace(static_cast<IvarMeExpr*>(expr));
+      return;
+    }
+  } else if ((expr->GetOp() == OP_div || expr->GetOp() == OP_rem) && expr->GetOpnd(1)->IsIntZero()) {
+    // for float or double zero, this is legal.
+    exceptionExpr.emplace(expr);
+    return;
+  } else if (expr->GetOp() == OP_select) {
+    MustThrowExceptionExpr(expr->GetOpnd(0), exceptionExpr);
+    // for select, if only one result will cause error, we are not sure whether
+    // the actual result of this select expr will cause error
+    std::set<MeExpr*> trueExpr;
+    MustThrowExceptionExpr(expr->GetOpnd(1), trueExpr);
+    if (trueExpr.empty()) {
+      return;
+    }
+    std::set<MeExpr*> falseExpr;
+    MustThrowExceptionExpr(expr->GetOpnd(2), falseExpr);
+    if (falseExpr.empty()) {
+      return;
+    }
+    exceptionExpr.emplace(expr);
+    return;
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    MustThrowExceptionExpr(expr->GetOpnd(i), exceptionExpr);
+  }
+}
+
+// No return stmt :
+//  1. call no-return func
+//  2. stmt with expr that must throw exception
+MeStmt *GetNoReturnStmt(BB *bb) {
+  // iterate all stmt
+  for (auto *stmt = bb->GetFirstMe(); stmt != nullptr; stmt = stmt->GetNextMeStmt()) {
+    std::set<MeExpr*> exceptionExpr;
+    for (size_t i = 0; i < stmt->NumMeStmtOpnds(); ++i) {
+      MustThrowExceptionExpr(stmt->GetOpnd(i), exceptionExpr);
+      if (!exceptionExpr.empty()) {
+        return stmt;
+      }
+    }
+    if (stmt->GetOp() == OP_call) {
+      PUIdx puIdx = static_cast<CallMeStmt*>(stmt)->GetPUIdx();
+      MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+      if (callee->GetAttr(FUNCATTR_noreturn)) {
+        return stmt;
+      }
+    }
+  }
+  return nullptr;
+}
+
+bool SkipOptimizeCFG(const maple::MeFunction &f) {
+  for (auto bbIt = f.GetCfg()->valid_begin(); bbIt != f.GetCfg()->valid_end(); ++bbIt) {
+    if ((*bbIt)->GetKind() == kBBIgoto || (*bbIt)->GetAttributes(kBBAttrIsTry)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool UnreachBBAnalysis(const maple::MeFunction &f) {
+  if (f.GetCfg()->UnreachCodeAnalysis(true)) {
+    DEBUG_LOG() << "Remove unreachable BB\n";
+    return true;
+  }
+  return false;
+}
+}  // anonymous namespace
+
+// contains only one valid goto stmt
+bool HasOnlyMeGotoStmt(BB &bb) {
+  if (IsMeEmptyBB(bb) || !bb.IsGoto()) {
+    return false;
+  }
+  MeStmt *stmt = bb.GetFirstMe();
+  // Skip comment stmt
+  while (stmt != nullptr && stmt->GetOp() == OP_comment) {
+    stmt = stmt->GetNextMeStmt();
+  }
+  return (stmt->GetOp() == OP_goto);
+}
+
+// contains only one valid goto mpl stmt
+bool HasOnlyMplGotoStmt(BB &bb) {
+  if (IsMplEmptyBB(bb) || !bb.IsGoto()) {
+    return false;
+  }
+  StmtNode *stmt = &bb.GetFirst();
+  // Skip comment stmt
+  if (stmt != nullptr && stmt->GetOpCode() == OP_comment) {
+    stmt = stmt->GetRealNext();
+  }
+  return (stmt->GetOpCode() == OP_goto);
+}
+
+// contains only one valid condgoto stmt
+bool HasOnlyMeCondGotoStmt(BB &bb) {
+  if (IsMeEmptyBB(bb) || bb.GetKind() != kBBCondGoto) {
+    return false;
+  }
+  MeStmt *stmt = bb.GetFirstMe();
+  // Skip comment stmt
+  while (stmt != nullptr && stmt->GetOp() == OP_comment) {
+    stmt = stmt->GetNextMeStmt();
+  }
+  return (stmt != nullptr && kOpcodeInfo.IsCondBr(stmt->GetOp()));
+}
+
+// contains only one valid condgoto mpl stmt
+bool HasOnlyMplCondGotoStmt(BB &bb) {
+  if (IsMplEmptyBB(bb) || bb.GetKind() != kBBCondGoto) {
+    return false;
+  }
+  StmtNode *stmt = &bb.GetFirst();
+  // Skip comment stmt
+  if (stmt != nullptr && stmt->GetOpCode() == OP_comment) {
+    stmt = stmt->GetRealNext();
+  }
+  return (stmt != nullptr && kOpcodeInfo.IsCondBr(stmt->GetOpCode()));
+}
+
+bool IsMeEmptyBB(BB &bb) {
+  if (bb.IsMeStmtEmpty()) {
+    return true;
+  }
+  MeStmt *stmt = bb.GetFirstMe();
+  // Skip comment stmt
+  while (stmt != nullptr && stmt->GetOp() == OP_comment) {
+    stmt = stmt->GetNextMeStmt();
+  }
+  return stmt == nullptr;
+}
+
+// contains no valid mpl stmt
+bool IsMplEmptyBB(BB &bb) {
+  if (bb.IsEmpty()) {
+    return true;
+  }
+  StmtNode *stmt = &bb.GetFirst();
+  // Skip comment stmt
+  if (stmt != nullptr && stmt->GetOpCode() == OP_comment) {
+    stmt = stmt->GetRealNext();
+  }
+  return stmt == nullptr;
+}
+
+// pred-connecting-succ
+// connectingBB has only one pred and succ, and has no stmt (except a single gotoStmt) in it
+bool IsConnectingBB(BB &bb) {
+  return (bb.GetPred().size() == 1 && bb.GetSucc().size() == 1) &&
+         (IsMeEmptyBB(bb) || HasOnlyMeGotoStmt(bb)) &&  // for meir, if no meir exist, it is empty
+         (IsMplEmptyBB(bb) || HasOnlyMplGotoStmt(bb));  // for mplir, if no mplir exist, it is empty
+}
+
+// RealSucc is a non-connecting BB which is not empty (or has just a single gotoStmt).
+// If we want to find the non-empty succ of currBB, we start from the succ (i.e. the argument)
+// skip those connecting bb used to connect its pred and succ, like: pred -- connecting -- succ
+// func will stop at first non-connecting BB or stopBB
+BB *FindFirstRealSucc(BB *succ, const BB *stopBB) {
+  while (succ != stopBB && IsConnectingBB(*succ)) {
+    succ = succ->GetSucc(0);
+  }
+  return succ;
+}
+
+// RealPred is a non-connecting BB which is not empty (or has just a single gotoStmt).
+// If we want to find the non-empty pred of currBB, we start from the pred (i.e. the argument)
+// skip those connecting bb used to connect its pred and succ, like: pred -- connecting -- succ
+// func will stop at first non-connecting BB or stopBB
+BB *FindFirstRealPred(BB *pred, const BB *stopBB) {
+  while (pred != stopBB && IsConnectingBB(*pred)) {
+    pred = pred->GetPred(0);
+  }
+  return pred;
+}
+
+int GetRealPredIdx(BB &succ, const BB &realPred) {
+  size_t i = 0;
+  size_t predSize = succ.GetPred().size();
+  while (i < predSize) {
+    if (FindFirstRealPred(succ.GetPred(i), &realPred) == &realPred) {
+      return static_cast<int>(i);
+    }
+    ++i;
+  }
+  // bb not in the vector
+  return -1;
+}
+
+int GetRealSuccIdx(BB &pred, const BB &realSucc) {
+  size_t i = 0;
+  size_t succSize = pred.GetSucc().size();
+  while (i < succSize) {
+    if (FindFirstRealSucc(pred.GetSucc(i), &realSucc) == &realSucc) {
+      return static_cast<int>(i);
+    }
+    ++i;
+  }
+  // bb not in the vector
+  return -1;
+}
+
+// delete all empty bb used to connect its pred and succ, like: pred -- empty -- empty -- succ
+// the result after this will be : pred -- succ
+// if no empty exist, return;
+// we will stop at stopBB(stopBB will not be deleted), if stopBB is nullptr, means no constraint
+void EliminateEmptyConnectingBB(const BB *predBB, BB *emptyBB, const BB *stopBB, MeCFG &cfg) {
+  if (emptyBB == stopBB && emptyBB != nullptr && predBB->IsPredBB(*stopBB)) {
+    return;
+  }
+  // we can only eliminate those emptyBBs that have only one pred and succ
+  while (emptyBB != nullptr && emptyBB != stopBB && IsConnectingBB(*emptyBB)) {
+    BB *succ = emptyBB->GetSucc(0);
+    BB *pred = emptyBB->GetPred(0);
+    DEBUG_LOG() << "Delete empty connecting : BB" << LOG_BBID(pred) << "->BB" << LOG_BBID(emptyBB) << "(deleted)->BB"
+                << LOG_BBID(succ) << "\n";
+    if (pred->IsPredBB(*succ)) {
+      pred->RemoveSucc(*emptyBB, true);
+      emptyBB->RemoveSucc(*succ, true);
+    } else {
+      int predIdx = succ->GetPredIndex(*emptyBB);
+      succ->SetPred(static_cast<size_t>(predIdx), pred);
+      int succIdx = pred->GetSuccIndex(*emptyBB);
+      pred->SetSucc(static_cast<size_t>(succIdx), succ);
+    }
+    cfg.DeleteBasicBlock(*emptyBB);
+    emptyBB = succ;
+  }
+}
+
+bool HasFallthruPred(const BB &bb) {
+  return GetFallthruPredNum(bb) != 0;
+}
+
+// For BB Level optimization
+class OptimizeBB {
+ public:
+  OptimizeBB(BB *bb, MeFunction &func, std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *candidates)
+      : currBB(bb),
+        f(func),
+        cfg(func.GetCfg()),
+        irmap(func.GetIRMap()),
+        irBuilder(func.GetMIRModule().GetMIRBuilder()),
+        isMeIR(irmap != nullptr),
+        cands(candidates) {}
+  // optimize each currBB until no change occur
+  bool OptBBIteratively();
+  // initial factory to create corresponding optimizer for currBB according to BBKind.
+  void InitBBOptFactory();
+
+ private:
+  BB *currBB = nullptr;             // BB we currently perform optimization on
+  MeFunction &f;                    // function we currently perform optimization on
+  MeCFG *cfg = nullptr;             // requiring cfg to find pattern to optimize current BB
+  MeIRMap *irmap = nullptr;         // used to create new MeExpr/MeStmt
+  MIRBuilder *irBuilder = nullptr;  // used to create new BaseNode(expr)/StmtNode
+  bool isMeIR = false;
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *cands = nullptr;  // candidates ost need to be updated ssa
+  std::map<BBId, std::set<OStIdx>> candsOstInBB;                       // bb with ost needed to be updated
+
+  bool repeatOpt = false;  // It will be always set false by OptBBIteratively. If there is some optimization
+                           // opportunity for currBB after a/some optimization, we should set it true.
+                           // Otherwise it will stop after all optimizations finished and continue to nextBB.
+  enum BBErrStat {
+    kBBNoErr,                 // BB is normal
+    kBBErrNull,               // BB is nullptr
+    kBBErrOOB,                // BB id is out-of-bound
+    kBBErrCommonEntryOrExit,  // BB is CommonEntry or CommonExit
+    kBBErrDel                 // BB has been deleted before
+  };
+
+  // For BBChecker, if currBB has error state, do not opt it.
+  BBErrStat bbErrStat = kBBNoErr;
+
+  // Optimize once time on bb, some common cfg opt and peephole cfg opt will be performed on currBB
+  bool OptBBOnce();
+  // elminate BB that is unreachable:
+  // 1.BB has no pred(expect then entry block)
+  // 2.BB has itself as pred
+  bool EliminateDeadBB();
+  // chang condition branch to unconditon branch if possible
+  // 1.condition is a constant
+  // 2.all branches of condition branch is the same BB
+  bool OptimizeCondBB2UnCond();
+  // disconnect predBB and currBB if predBB must cause error(e.g. null ptr deref)
+  // If a expr is always cause error in predBB, predBB will never reach currBB
+  bool RemoveSuccFromNoReturnBB();
+  // currBB has only one pred, and pred has only one succ
+  // try to merge two BB, return true if merged, return false otherwise.
+  bool MergeDistinctBBPair();
+  // Eliminate redundant philist in bb which has only one pred
+  bool EliminateRedundantPhiList();
+
+  // Following function check for BB pattern according to BB's Kind
+  bool OptimizeCondBB();
+  bool OptimizeUncondBB();
+  bool OptimizeFallthruBB();
+  bool OptimizeReturnBB();
+  bool OptimizeSwitchBB();
+
+  // for sub-pattern in OptimizeCondBB
+  MeExpr *TryToSimplifyCombinedCond(const MeExpr &expr);
+  MeExpr *CombineCondByOffset(const MeExpr &expr);
+  bool FoldBranchToCommonDest(BB *pred, BB *succ);
+  bool FoldBranchToCommonDest();
+  bool SkipRedundantCond();
+  bool SkipRedundantCond(BB &pred, BB &succ);
+  // for MergeDistinctBBPair
+  BB *MergeDistinctBBPair(BB *pred, BB *succ);
+  // merge two bb, if merged, return combinedBB, Otherwise return nullptr
+  BB *MergeSuccIntoPred(BB *pred, BB *succ);
+  bool CondBranchToSelect();
+  bool FoldCondBranch();
+  bool IsProfitableForCond2Sel(MeExpr *condExpr, MeExpr *trueExpr, MeExpr *falseExpr);
+  // for OptimizeUncondBB
+  bool MergeGotoBBToPred(BB *gotoBB, BB *pred);
+  // after moving pred from curr to curr's successor (i.e. succ), update the phiList of curr and succ
+  // a phiOpnd will be removed from curr's philist, and a phiOpnd will be inserted to succ's philist
+  // note: when replace pred's succ (i.e. curr) with succ, please DO NOT remove phiOpnd immediately,
+  // otherwise we cannot get phiOpnd in this step
+  void UpdatePhiForMovingPred(int predIdxForCurr, const BB *pred, BB *curr, BB *succ);
+  // for OptimizeCondBB2UnCond
+  bool BranchBB2UncondBB(BB &bb);
+  // Get first return BB
+  BB *GetFirstReturnBB();
+  bool EliminateRedundantPhiList(BB *bb);
+
+  // Check if state of currBB is error.
+  bool CheckCurrBB();
+  // Insert ost of philist in bb to cand, and set ost start from newBB(newBB will be bb itself if not specified)
+  void UpdateSSACandForBBPhiList(BB *bb, const BB *newBB = nullptr);
+  void UpdateSSACandForOst(const OStIdx &ostIdx, const BB *bb);
+  // replace oldBBID in cands with newBBID
+  void UpdateBBIdInSSACand(const BBId &oldBBID, const BBId &newBBID);
+
+  void DeleteBB(BB *bb);
+
+  bool IsEmptyBB(BB &bb) {
+    return isMeIR ? IsMeEmptyBB(bb) : IsMplEmptyBB(bb);
+  }
+
+  void SetBBRunAgain() {
+    repeatOpt = true;
+  }
+  void ResetBBRunAgain() {
+    repeatOpt = false;
+  }
+#define CHECK_CURR_BB() \
+  if (!CheckCurrBB()) { \
+    return false;       \
+  }
+
+#define ONLY_FOR_MEIR() \
+  if (!isMeIR) {        \
+    return false;       \
+  }
+};
+
+using OptBBFatory = FunctionFactory<BBKind, bool, OptimizeBB*>;
+
+bool OptimizeBB::CheckCurrBB() {
+  if (bbErrStat != kBBNoErr) {  // has been checked before
+    return false;
+  }
+  if (currBB == nullptr) {
+    bbErrStat = kBBErrNull;
+    return false;
+  }
+  if (currBB->GetBBId() >= cfg->GetAllBBs().size()) {
+    bbErrStat = kBBErrOOB;
+    return false;
+  }
+  if (currBB == cfg->GetCommonEntryBB() || currBB == cfg->GetCommonExitBB()) {
+    bbErrStat = kBBErrCommonEntryOrExit;
+    return false;
+  }
+  if (cfg->GetBBFromID(currBB->GetBBId()) == nullptr) {
+    // BB is deleted, it will be set nullptr in cfg's bbvec, but currBB has been set before(, so it is not null)
+    bbErrStat = kBBErrDel;
+    return false;
+  }
+  bbErrStat = kBBNoErr;
+  return true;
+}
+
+void OptimizeBB::UpdateBBIdInSSACand(const BBId &oldBBID, const BBId &newBBID) {
+  auto it = candsOstInBB.find(oldBBID);
+  if (it == candsOstInBB.end()) {
+    return;  // no item to update
+  }
+  auto &ostSet = candsOstInBB[newBBID];  // find or create
+  ostSet.insert(it->second.begin(), it->second.end());
+  candsOstInBB.erase(it);
+  for (auto &cand : *cands) {
+    auto item = cand.second->find(oldBBID);
+    if (item != cand.second->end()) {
+      cand.second->erase(item);
+      cand.second->emplace(newBBID);
+    }
+  }
+}
+
+void OptimizeBB::UpdateSSACandForOst(const OStIdx &ostIdx, const BB *bb) {
+  MeSSAUpdate::InsertOstToSSACands(ostIdx, *bb, cands);
+}
+
+void OptimizeBB::UpdateSSACandForBBPhiList(BB *bb, const BB *newBB) {
+  if (!isMeIR || bb == nullptr || bb->GetMePhiList().empty()) {
+    return;
+  }
+  if (newBB == nullptr) {  // if not specified, newBB is bb itself
+    newBB = bb;
+  }
+  std::set<OStIdx> &ostSet = candsOstInBB[newBB->GetBBId()];
+  for (auto phi : bb->GetMePhiList()) {
+    OStIdx ostIdx = phi.first;
+    UpdateSSACandForOst(ostIdx, newBB);
+    ostSet.emplace(ostIdx);
+  }
+  if (bb != newBB) {
+    auto it = candsOstInBB.find(bb->GetBBId());
+    if (it != candsOstInBB.end()) {
+      // ost in bb should be updated, make it updated with newBB
+      for (auto ostIdx : it->second) {
+        UpdateSSACandForOst(ostIdx, newBB);
+        ostSet.emplace(ostIdx);
+      }
+    }
+  }
+}
+
+void OptimizeBB::DeleteBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+  bb->GetSucc().clear();
+  bb->GetPred().clear();
+  cfg->DeleteBasicBlock(*bb);
+  bb->GetSuccFreq().clear();
+}
+
+// eliminate dead BB :
+// 1.BB has no pred(expect then entry block)
+// 2.BB has only itself as pred
+bool OptimizeBB::EliminateDeadBB() {
+  CHECK_CURR_BB();
+  if (currBB->IsSuccBB(*cfg->GetCommonEntryBB())) {
+    return false;
+  }
+  if (currBB->GetPred().empty() || currBB->GetUniquePred() == currBB) {
+    DEBUG_LOG() << "EliminateDeadBB : Delete BB" << LOG_BBID(currBB) << "\n";
+    currBB->RemoveAllSucc();
+    if (currBB->IsPredBB(*cfg->GetCommonExitBB())) {
+      cfg->GetCommonExitBB()->RemoveExit(*currBB);
+    }
+    DeleteBB(currBB);
+    return true;
+  }
+  return false;
+}
+
+// Eliminate redundant philist in bb which has only one pred
+bool OptimizeBB::EliminateRedundantPhiList() {
+  CHECK_CURR_BB();
+  ONLY_FOR_MEIR();
+  return EliminateRedundantPhiList(currBB);
+}
+
+// Eliminate redundant philist in bb which has only one pred
+bool OptimizeBB::EliminateRedundantPhiList(BB *bb) {
+  CHECK_FATAL(bb, "bb is null!");
+  if (bb->GetPred().size() != 1) {
+    return false;
+  }
+  UpdateSSACandForBBPhiList(bb, bb->GetPred(0));
+  bb->GetMePhiList().clear();
+  return true;
+}
+
+// all branches of bb are the same if skipping all empty connecting BB
+// turn it into an unconditional BB (if destBB has other pred, bb->gotoBB, otherwise, bb->fallthruBB)
+//      bb                             bb
+//   /  |  \                            |
+//  A   B   C  (ABC are empty)  ==>     |
+//   \  |  /                            |
+//    destBB                          destBB
+bool OptimizeBB::BranchBB2UncondBB(BB &bb) {
+  if (bb.GetKind() != kBBCondGoto && bb.GetKind() != kBBSwitch) {
+    return false;
+  }
+  // check if all successors of bb branch to the same destination (ignoring all empty bb between bb and destination)
+  BB *destBB = FindFirstRealSucc(bb.GetSucc(0));
+  for (size_t i = 1; i < bb.GetSucc().size(); ++i) {
+    if (FindFirstRealSucc(bb.GetSucc(i)) != destBB) {
+      return false;
+    }
+  }
+
+  DEBUG_LOG() << "BranchBB2UncondBB : " << (bb.GetKind() == kBBCondGoto ? "Conditional " : "Switch ") << "BB"
+              << LOG_BBID(&bb) << " to unconditional BB\n";
+  // delete all empty bb between bb and destBB
+  // note : bb and destBB will be connected after empty BB is deleted
+  for (int i = static_cast<int>(bb.GetSucc().size()) - 1; i >= 0; --i) {
+    EliminateEmptyConnectingBB(&bb, bb.GetSucc(static_cast<size_t>(i)), destBB, *cfg);
+  }
+  while (bb.GetSucc().size() != 1) { // bb is an unconditional bb now, and its successor num should be 1
+    ASSERT(bb.GetSucc().back() == destBB,
+           "[FUNC: %s]Goto BB%d has different destination", funcName.c_str(), LOG_BBID(&bb));
+    bb.RemoveSucc(*bb.GetSucc().back());
+  }
+  if (cfg->UpdateCFGFreq()) {
+    ASSERT(bb.GetSuccFreq().size() == bb.GetSucc().size(), "sanity check");
+    bb.SetSuccFreq(0, bb.GetFrequency());
+  }
+  // bb must be one of fallthru pred of destBB, if there is another one,
+  // we should add gotoStmt to avoid duplicate fallthru pred
+  if (GetFallthruPredNum(*destBB) > 1) {
+    LabelIdx label = f.GetOrCreateBBLabel(*destBB);
+    if (isMeIR) {
+      ASSERT_NOT_NULL(bb.GetLastMe());
+      auto *gotoStmt = irmap->CreateGotoMeStmt(label, &bb, &bb.GetLastMe()->GetSrcPosition());
+      bb.RemoveLastMeStmt();
+      bb.AddMeStmtLast(gotoStmt);
+    } else {
+      auto *gotoStmt = irBuilder->CreateStmtGoto(OP_goto, label);
+      bb.RemoveLastStmt();
+      bb.AddStmtNode(gotoStmt);
+    }
+    bb.SetKind(kBBGoto);
+  } else {
+    if (isMeIR) {
+      bb.RemoveLastMeStmt();
+    } else {
+      bb.RemoveLastStmt();
+    }
+    bb.SetKind(kBBFallthru);
+  }
+  return true;
+}
+
+// chang condition branch to unconditon branch if possible
+// 1.condition is a constant
+// 2.all branches of condition branch is the same BB
+bool OptimizeBB::OptimizeCondBB2UnCond() {
+  CHECK_CURR_BB();
+  if (currBB->GetKind() != kBBCondGoto) {
+    return false;
+  }
+  // case 2
+  if (FindFirstRealSucc(currBB->GetSucc(0)) == FindFirstRealSucc(currBB->GetSucc(1))) {
+    if (BranchBB2UncondBB(*currBB)) {
+      SetBBRunAgain();
+      return true;
+    }
+  }
+
+  // case 1
+  BB *ftBB = currBB->GetSucc(0);
+  BB *gtBB = currBB->GetSucc(1);
+  uint64_t removedSuccFreq = 0;
+  if (isMeIR) {
+    MeStmt *brStmt = currBB->GetLastMe();
+    ASSERT_NOT_NULL(brStmt);
+    MeExpr *condExpr = brStmt->GetOpnd(0);
+    if (condExpr->GetMeOp() == kMeOpConst) {
+      CHECK_FATAL(brStmt, "brStmt is nullptr!");
+      bool isCondTrue = (!condExpr->IsZero());
+      bool isBrtrue = (brStmt->GetOp() == OP_brtrue);
+      if (isCondTrue != isBrtrue) {  // goto fallthru BB
+        currBB->RemoveLastMeStmt();
+        currBB->SetKind(kBBFallthru);
+        if (cfg->UpdateCFGFreq()) {
+          removedSuccFreq = currBB->GetSuccFreq()[1];
+        }
+        currBB->RemoveSucc(*gtBB, true);
+        // update frequency
+        if (cfg->UpdateCFGFreq()) {
+          currBB->SetSuccFreq(0, currBB->GetFrequency());
+          ftBB->SetFrequency(ftBB->GetFrequency() + removedSuccFreq);
+          ftBB->UpdateEdgeFreqs(false);
+        }
+      } else {
+        MeStmt *gotoStmt = irmap->CreateGotoMeStmt(f.GetOrCreateBBLabel(*gtBB), currBB, &brStmt->GetSrcPosition());
+        currBB->ReplaceMeStmt(brStmt, gotoStmt);
+        currBB->SetKind(kBBGoto);
+        // update frequency
+        if (cfg->UpdateCFGFreq()) {
+          removedSuccFreq = currBB->GetSuccFreq()[0];
+        }
+        currBB->RemoveSucc(*ftBB, true);
+        if (cfg->UpdateCFGFreq()) {
+          currBB->SetSuccFreq(0, currBB->GetFrequency());
+          gtBB->SetFrequency(gtBB->GetFrequency() + removedSuccFreq);
+          gtBB->UpdateEdgeFreqs(false);
+        }
+      }
+      SetBBRunAgain();
+      return true;
+    }
+  } else {
+    StmtNode &brStmt = currBB->GetLast();
+    BaseNode *condExpr = brStmt.Opnd(0);
+    if (condExpr->GetOpCode() == OP_constval) {
+      MIRConst *constVal = static_cast<ConstvalNode*>(condExpr)->GetConstVal();
+      bool isCondTrue = (!constVal->IsZero());
+      bool isBrTrue = (brStmt.GetOpCode() == OP_brtrue);
+      if (isCondTrue != isBrTrue) {
+        currBB->RemoveLastStmt();
+        currBB->SetKind(kBBFallthru);
+        if (cfg->UpdateCFGFreq()) {
+          removedSuccFreq = currBB->GetSuccFreq()[1];
+        }
+        currBB->RemoveSucc(*gtBB);
+        if (cfg->UpdateCFGFreq()) {
+          currBB->SetSuccFreq(0, currBB->GetFrequency());
+          ftBB->SetFrequency(ftBB->GetFrequency() + removedSuccFreq);
+          ftBB->UpdateEdgeFreqs(false);
+        }
+      } else {
+        StmtNode *gotoStmt = irBuilder->CreateStmtGoto(OP_goto, f.GetOrCreateBBLabel(*gtBB));
+        currBB->ReplaceStmt(&brStmt, gotoStmt);
+        currBB->SetKind(kBBGoto);
+        if (cfg->UpdateCFGFreq()) {
+          removedSuccFreq = currBB->GetSuccFreq()[0];
+        }
+        currBB->RemoveSucc(*ftBB);
+        if (cfg->UpdateCFGFreq()) {
+          currBB->SetSuccFreq(0, currBB->GetFrequency());
+          gtBB->SetFrequency(gtBB->GetFrequency() + removedSuccFreq);
+          gtBB->UpdateEdgeFreqs(false);
+        }
+      }
+      SetBBRunAgain();
+      return true;
+    }
+  }
+  return false;
+}
+
+// return first return bb
+BB *OptimizeBB::GetFirstReturnBB() {
+  for (auto *bb : cfg->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    if (bb->GetKind() == kBBReturn) {
+      return bb;
+    }
+  }
+  ASSERT(false, "should never reach here");
+  return nullptr;
+}
+
+// Disconnect no-return BB with all its successors. BB is a no-return BB if:
+// case 1: BB has stmt that must throw exception(e.g. deref nullptr, div/rem zero)
+// case 2: BB has call site of func with attribute FUNCATTR_noreturn
+// If a stmt in currBB is no return, currBB will never reach its successors
+bool OptimizeBB::RemoveSuccFromNoReturnBB() {
+  CHECK_CURR_BB();
+  ONLY_FOR_MEIR();
+  if (currBB->IsMeStmtEmpty() || currBB->GetSucc().empty()) {
+    return false;
+  }
+  MeStmt *exceptionStmt = GetNoReturnStmt(currBB);
+  if (exceptionStmt != nullptr) {
+    DEBUG_LOG() << "RemoveSuccFromNoReturnBB : Remove all successors from pred BB" << LOG_BBID(currBB)
+                << ", and remove all stmts after noreturn stmt\n";
+    if ((currBB->IsPredBB(*cfg->GetCommonExitBB()) && currBB->GetLastMe() == exceptionStmt) ||
+        (currBB->GetKind() == kBBNoReturn)) {
+      // it has been dealt with before or it has been connected to commonExit, do nothing
+      return false;
+    }
+    if (!currBB->GetSucc().empty()) {
+      currBB->RemoveAllSucc();
+    }
+    while (currBB->GetLastMe() != exceptionStmt) {
+      CHECK_FATAL(currBB->GetLastMe(), "LastMe is nullptr!");
+      currBB->GetLastMe()->SetIsLive(false);
+      currBB->RemoveLastMeStmt();
+    }
+    // if exceptionStmt not a callsite of exit func, we replace it with a exception-throwing expr.
+    if (exceptionStmt->GetOp() != OP_call) {
+      currBB->RemoveLastMeStmt();
+      // we create a expr that must throw exception
+      std::set<MeExpr*> exceptionExprSet;
+      for (size_t i = 0; i < exceptionStmt->NumMeStmtOpnds(); ++i) {
+        MustThrowExceptionExpr(exceptionStmt->GetOpnd(i), exceptionExprSet);
+      }
+      ASSERT(!exceptionExprSet.empty(), "Exception stmt must have an exception expr");
+      for (auto *exceptionExpr : exceptionExprSet) {
+        UnaryMeStmt *evalStmt = irmap->New<UnaryMeStmt>(OP_eval);
+        evalStmt->SetOpnd(0, exceptionExpr);
+        evalStmt->CopyInfo(*exceptionStmt);
+        currBB->AddMeStmtLast(evalStmt);
+      }
+    }
+    currBB->SetKind(kBBNoReturn);
+    // connect to exit for postdom
+    cfg->GetCommonExitBB()->AddExit(*currBB);
+    currBB->SetAttributes(kBBAttrIsExit);
+    ResetBBRunAgain();
+    // add edge Frequency to exitbb
+    if (cfg->UpdateCFGFreq()) {
+      currBB->PushBackSuccFreq(0);
+    }
+    return true;
+  }
+  return false;
+}
+
+// merge two bb, if merged, return combinedBB, Otherwise return nullptr
+BB *OptimizeBB::MergeSuccIntoPred(BB *pred, BB *succ) {
+  if (pred == cfg->GetCommonEntryBB() || succ == cfg->GetCommonExitBB()) {
+    return nullptr;
+  }
+  if (pred->GetUniqueSucc() != succ || succ->GetUniquePred() != pred) {
+    return nullptr;
+  }
+  if (pred->GetKind() == kBBGoto && (!IsMeEmptyBB(*succ) || !IsMplEmptyBB(*succ))) {
+    if (isMeIR) {
+      // remove last mestmt
+      ASSERT(pred->GetLastMe()->GetOp() == OP_goto,
+             "[FUNC: %s]GotoBB has no goto stmt as its terminator", funcName.c_str());
+      pred->RemoveLastMeStmt();
+    } else {
+      // remove last stmt
+      ASSERT(pred->GetLast().GetOpCode() == OP_goto,
+             "[FUNC: %s]GotoBB has no goto stmt as its terminator", funcName.c_str());
+      pred->RemoveLastStmt();
+    }
+    pred->SetKind(kBBFallthru);
+  }
+  if (pred->GetKind() != kBBFallthru && pred->GetKind() != kBBGoto) {
+    // Only goto and fallthru BB are allowed
+    return nullptr;
+  }
+  bool isSuccEmpty = IsMeEmptyBB(*succ) && IsMplEmptyBB(*succ);
+  if (!isSuccEmpty) {
+    if (isMeIR) {
+      MeStmt *stmt = succ->GetFirstMe();
+      while (stmt != nullptr && (!succ->IsMeStmtEmpty())) {
+        MeStmt *next = stmt->GetNextMeStmt();
+        succ->RemoveMeStmt(stmt);
+        pred->AddMeStmtLast(stmt);
+        stmt = next;
+      }
+    } else {
+      StmtNode *stmt = &succ->GetFirst();
+      while (stmt != nullptr && (!succ->IsEmpty())) {
+        StmtNode *next = stmt->GetNext();
+        succ->RemoveStmtNode(stmt);
+        pred->AddStmtNode(stmt);
+        stmt = next;
+      }
+    }
+  }
+  // update succFreqs before update succs
+  if (cfg->UpdateCFGFreq() && !succ->GetSuccFreq().empty()) {
+    // copy succFreqs of succ to pred
+    for (int i = 0; i < succ->GetSuccFreq().size(); i++) {
+      pred->PushBackSuccFreq(succ->GetSuccFreq()[i]);
+    }
+  }
+  succ->MoveAllSuccToPred(pred, cfg->GetCommonExitBB());
+  pred->RemoveSucc(*succ, false);  // philist will not be associated with pred BB, no need to update phi here.
+  if (!isSuccEmpty) {
+    // only when we move stmt from succ to pred should we set attr and kind here
+    pred->SetAttributes(succ->GetAttributes());
+    pred->SetKind(succ->GetKind());
+  } else if (pred->GetKind() == kBBGoto) {
+    if (pred->IsPredBB(*cfg->GetCommonExitBB())) {
+      if (isMeIR) {
+        pred->RemoveLastMeStmt();
+      } else {
+        pred->RemoveLastStmt();
+      }
+      pred->SetKind(kBBFallthru);
+    } else {
+      // old target of goto is succ, and we merge succ into pred, so we should update it
+      cfg->UpdateBranchTarget(*pred, *succ, *pred->GetSucc(0), f);
+    }
+  }
+  if (pred->GetBBId().GetIdx() > succ->GetBBId().GetIdx()) {
+    DEBUG_LOG() << "Swap BBID : BB" << LOG_BBID(pred) << " <-> BB" << LOG_BBID(succ) << "\n";
+    cfg->SwapBBId(*pred, *succ);
+    // update bbid : tell ssa-updater to update with new BBID
+    UpdateBBIdInSSACand(succ->GetBBId(), pred->GetBBId());
+  }
+  DEBUG_LOG() << "Merge BB" << LOG_BBID(succ) << " to BB" << LOG_BBID(pred) << ", and delete BB" << LOG_BBID(succ)
+              << "\n";
+  UpdateSSACandForBBPhiList(succ, pred);
+  DeleteBB(succ);
+  succ->SetBBId(pred->GetBBId());  // succ has been merged to pred, and reference to succ should be set to pred too.
+  return pred;
+}
+
+BB *OptimizeBB::MergeDistinctBBPair(BB *pred, BB *succ) {
+  if (pred == nullptr || succ == nullptr || succ == pred) {
+    return nullptr;
+  }
+  if (pred != succ->GetUniquePred() || pred == cfg->GetCommonEntryBB() || pred->IsPredBB(*cfg->GetCommonExitBB())) {
+    return nullptr;
+  }
+  if (succ != pred->GetUniqueSucc() || succ == cfg->GetCommonExitBB() || succ->IsSuccBB(*cfg->GetCommonEntryBB())) {
+    return nullptr;
+  }
+  // start merging currBB and predBB
+  return MergeSuccIntoPred(pred, succ);
+}
+
+// currBB has only one pred, and pred has only one succ
+// try to merge two BB, return true if merged, return false otherwise.
+bool OptimizeBB::MergeDistinctBBPair() {
+  CHECK_CURR_BB();
+  bool everChanged = false;
+  BB *combineBB = MergeDistinctBBPair(currBB->GetUniquePred(), currBB);
+  if (combineBB != nullptr) {
+    currBB = combineBB;
+    everChanged = true;
+  }
+  combineBB = MergeDistinctBBPair(currBB, currBB->GetUniqueSucc());
+  if (combineBB != nullptr) {
+    currBB = combineBB;
+    everChanged = true;
+  }
+  if (everChanged) {
+    SetBBRunAgain();
+  }
+  return everChanged;
+}
+
+bool OptimizeBB::IsProfitableForCond2Sel(MeExpr *condExpr, MeExpr *trueExpr, MeExpr *falseExpr) {
+  if (trueExpr == falseExpr) {
+    return true;
+  }
+  ASSERT(IsSafeExpr(trueExpr), "[FUNC: %s]Please check for safety first", funcName.c_str());
+  ASSERT(IsSafeExpr(falseExpr), "[FUNC: %s]Please check for safety first", funcName.c_str());
+  // try to simplify select expr
+  MeExpr *selExpr = irmap->CreateMeExprSelect(trueExpr->GetPrimType(), *condExpr, *trueExpr, *falseExpr);
+  MeExpr *simplifiedSel = irmap->SimplifyMeExpr(selExpr);
+  if (simplifiedSel != selExpr) {
+    return true;  // can be simplified
+  }
+
+  // We can check for every opnd of opndExpr, and calculate their cost according to cg's insn
+  // but optimization in mplbe may change the insn and the result is not correct after that.
+  // Therefore, to make this easier, only reg/const/var are allowed here
+  MeExprOp trueOp = trueExpr->GetMeOp();
+  MeExprOp falseOp = falseExpr->GetMeOp();
+  if (trueOp == kMeOpVar && !DoesExprContainSubExpr(condExpr, trueExpr)) {
+    return false;
+  }
+  if (falseOp == kMeOpVar && !DoesExprContainSubExpr(condExpr, falseExpr)) {
+    return false;
+  }
+  if ((trueOp != kMeOpConst && trueOp != kMeOpReg && trueOp != kMeOpVar) ||
+      (falseOp != kMeOpConst && falseOp != kMeOpReg && falseOp != kMeOpVar)) {
+    return false;
+  }
+  // big integer
+  if (GetNonSimpleImm(trueExpr) != 0 || GetNonSimpleImm(falseExpr) != 0) {
+    return false;
+  }
+  return true;
+}
+
+// Ignoring connecting BB, two cases can be turn into select
+//     condBB        condBB
+//     /   \         /    \
+ //   ftBB  gtBB     |   gtBB/ftBB
+//   x<-   x<-      |     x<-
+//     \   /         \     /
+//     jointBB       jointBB
+bool OptimizeBB::CondBranchToSelect() {
+  CHECK_CURR_BB();
+  BB *ftBB = FindFirstRealSucc(currBB->GetSucc(0));  // fallthruBB
+  BB *gtBB = FindFirstRealSucc(currBB->GetSucc(1));  // gotoBB
+  if (ftBB == gtBB) {
+    (void)BranchBB2UncondBB(*currBB);
+    return true;
+  }
+  // if ftBB or gtBB itself is jointBB, just return itself; otherwise return real succ
+  BB *ftTargetBB =
+      (ftBB->GetPred().size() == 1 && ftBB->GetSucc().size() == 1) ? FindFirstRealSucc(ftBB->GetSucc(0)) : ftBB;
+  BB *gtTargetBB =
+      (gtBB->GetPred().size() == 1 && gtBB->GetSucc().size() == 1) ? FindFirstRealSucc(gtBB->GetSucc(0)) : gtBB;
+  if (ftTargetBB != gtTargetBB) {
+    return false;
+  }
+  BB *jointBB = ftTargetBB;  // common succ
+  // Check if ftBB has only one assign stmt, set ftStmt if a assign stmt exist
+  AssignMeStmt *ftStmt = nullptr;
+  if (ftBB != jointBB) {
+    ftStmt = GetSingleAssign(ftBB);
+    if (ftStmt == nullptr) {
+      return false;
+    }
+  }
+  // Check if gtBB has only one assign stmt, set gtStmt if a assign stmt exist
+  AssignMeStmt *gtStmt = nullptr;
+  if (gtBB != jointBB) {
+    gtStmt = GetSingleAssign(gtBB);
+    if (gtStmt == nullptr) {
+      return false;
+    }
+  }
+  if (ftStmt == nullptr && gtStmt == nullptr) {
+    DEBUG_LOG() << "Abort cond2sel for BB" << LOG_BBID(currBB) << ", because no single assign stmt is found\n";
+    return false;
+  }
+
+  // Here we found a pattern, collect select opnds and result reg
+  ScalarMeExpr *ftLHS = nullptr;
+  MeExpr *ftRHS = nullptr;
+  std::set<ScalarMeExpr*> chiListCands;  // collect chilist if assign stmt has one
+  if (ftStmt != nullptr) {
+    ftLHS = static_cast<ScalarMeExpr*>(ftStmt->GetLHS());
+    ftRHS = ftStmt->GetRHS();
+    if (ftStmt->GetChiList() != nullptr) {
+      for (auto &chiNode : *ftStmt->GetChiList()) {
+        chiListCands.emplace(chiNode.second->GetRHS());
+      }
+    }
+  }
+  ScalarMeExpr *gtLHS = nullptr;
+  MeExpr *gtRHS = nullptr;
+  if (gtStmt != nullptr) {
+    gtLHS = static_cast<ScalarMeExpr*>(gtStmt->GetLHS());
+    gtRHS = gtStmt->GetRHS();
+    if (gtStmt->GetChiList() != nullptr) {
+      for (auto &chiNode : *gtStmt->GetChiList()) {
+        chiListCands.emplace(chiNode.second->GetRHS());
+      }
+    }
+  }
+  // We have tried to get ftRHS/gtRHS from stmt before, if it still nullptr, try to find it from phiNode
+  //    a <- mx1
+  //      cond
+  //     |    \
+  //     |    a <- mx2
+  //     |    /
+  //     a <- phi(mx1, mx2)
+  // we turn it to
+  // a <- cond ? mx1 : mx2
+  if (ftRHS == nullptr) {
+    ftRHS = FindCond2SelRHSFromPhiNode(currBB, ftBB, jointBB, gtLHS->GetOstIdx());
+    if (ftRHS == nullptr) {
+      return false;
+    }
+    ftLHS = gtLHS;
+  } else if (gtRHS == nullptr) {
+    gtRHS = FindCond2SelRHSFromPhiNode(currBB, gtBB, jointBB, ftLHS->GetOstIdx());
+    if (gtRHS == nullptr) {
+      return false;
+    }
+    gtLHS = ftLHS;
+  }
+  // pattern not found
+  if (gtLHS->GetOstIdx() != ftLHS->GetOstIdx()) {
+    DEBUG_LOG() << "Abort cond2sel for BB" << LOG_BBID(currBB) << ", because two ost assigned are not the same\n";
+    return false;
+  }
+  DEBUG_LOG() << "Candidate cond2sel BB" << LOG_BBID(currBB) << "(cond)->{BB" << LOG_BBID(currBB->GetSucc(0)) << ", BB"
+              << LOG_BBID(currBB->GetSucc(1)) << "}->BB" << LOG_BBID(ftTargetBB) << "(jointBB)\n";
+  if (ftRHS != gtRHS) {  // if ftRHS is the same as gtRHS, they can be simplified, and no need to check safety
+    // black list
+    if (!IsSafeExpr(ftRHS) || !IsSafeExpr(gtRHS)) {
+      DEBUG_LOG() << "Abort cond2sel for BB" << LOG_BBID(currBB) << ", because trueExpr or falseExpr is not safe\n";
+      return false;
+    }
+  }
+  MeStmt *condStmt = currBB->GetLastMe();
+  CHECK_FATAL(condStmt, "condStmt is nullptr!");
+  MeExpr *trueExpr = (condStmt->GetOp() == OP_brtrue) ? gtRHS : ftRHS;
+  MeExpr *falseExpr = (trueExpr == gtRHS) ? ftRHS : gtRHS;
+  MeExpr *condExpr = condStmt->GetOpnd(0);
+  if (!IsProfitableForCond2Sel(condExpr, trueExpr, falseExpr)) {
+    DEBUG_LOG() << "Abort cond2sel for BB" << LOG_BBID(currBB) << ", because cond2sel is not profitable\n";
+    return false;
+  }
+  DEBUG_LOG() << "Condition To Select : BB" << LOG_BBID(currBB) << "(cond)->[BB" << LOG_BBID(ftBB) << "(ft), BB"
+              << LOG_BBID(gtBB) << "(gt)]->BB" << LOG_BBID(jointBB) << "(joint)\n";
+  ScalarMeExpr *resLHS = nullptr;
+  if (jointBB->GetPred().size() == 2) {  // if jointBB has only ftBB and gtBB as its pred.
+    // use phinode lhs as result
+    auto it = jointBB->GetMePhiList().find(ftLHS->GetOstIdx());
+    if (it == jointBB->GetMePhiList().end()) {
+      return false;  // volatile ost always has no phi node
+    }
+    resLHS = it->second->GetLHS();
+  } else {
+    // we should create a new version
+    resLHS = irmap->CreateRegOrVarMeExprVersion(ftLHS->GetOstIdx());
+  }
+  // It is profitable for instruction selection if select opnd is a compare expression
+  // select condExpr, trueExpr, falseExpr => select cmpExpr, trueExpr, falseExpr
+  if (condExpr->IsScalar() && condExpr->GetPrimType() != PTY_u1) {
+    auto *scalarExpr = static_cast<ScalarMeExpr*>(condExpr);
+    if (scalarExpr->GetDefBy() == kDefByStmt) {
+      MeStmt *defStmt = scalarExpr->GetDefStmt();
+      MeExpr *rhs = defStmt->GetRHS();
+      if (rhs != nullptr && kOpcodeInfo.IsCompare(rhs->GetOp())) {
+        condExpr = rhs;
+      }
+    }
+  }
+  MeExpr *selExpr = irmap->CreateMeExprSelect(resLHS->GetPrimType(), *condExpr, *trueExpr, *falseExpr);
+  MeExpr *simplifiedSel = irmap->SimplifyMeExpr(selExpr);
+  AssignMeStmt *newAssStmt = irmap->CreateAssignMeStmt(*resLHS, *simplifiedSel, *currBB);
+  CHECK_FATAL(currBB->GetLastMe(), "LastMe is nullptr!");
+  newAssStmt->SetSrcPos(currBB->GetLastMe()->GetSrcPosition());
+  // here we do not remove condStmt, because it will be delete in BranchBB2UncondBB
+  currBB->InsertMeStmtBefore(condStmt, newAssStmt);
+  // we remove assign stmt in ftBB and gtBB to make it an empty BB, so that BranchBB2UncondBB can simplify it.
+  if (gtStmt != nullptr) {
+    gtBB->RemoveMeStmt(gtStmt);
+  }
+  if (ftStmt != nullptr) {
+    ftBB->RemoveMeStmt(ftStmt);
+  }
+  (void)BranchBB2UncondBB(*currBB);
+  // update phi
+  if (jointBB->GetPred().size() == 1) {  // jointBB has only currBB as its pred
+    // just remove phinode
+    jointBB->GetMePhiList().erase(resLHS->GetOstIdx());
+  } else {
+    // set phi opnd as resLHS
+    MePhiNode *phiNode = jointBB->GetMePhiList()[resLHS->GetOstIdx()];
+    int predIdx = GetRealPredIdx(*jointBB, *currBB);
+    ASSERT(predIdx != -1, "[FUNC: %s]currBB is not a pred of jointBB", funcName.c_str());
+    phiNode->SetOpnd(static_cast<size_t>(predIdx), resLHS);
+  }
+  // if newAssStmt is an dassign, copy old chilist to it
+  if (!chiListCands.empty() && newAssStmt->GetOp() == OP_dassign) {
+    MapleMap<OStIdx, ChiMeNode*> *chiList = newAssStmt->GetChiList();
+    for (auto *rhs : chiListCands) {
+      VarMeExpr *newLHS = irmap->CreateVarMeExprVersion(rhs->GetOst());
+      UpdateSSACandForOst(rhs->GetOstIdx(), currBB);
+      auto *newChiNode = irmap->New<ChiMeNode>(newAssStmt);
+      newLHS->SetDefChi(*newChiNode);
+      newLHS->SetDefBy(kDefByChi);
+      newChiNode->SetLHS(newLHS);
+      newChiNode->SetRHS(rhs);
+      chiList->emplace(rhs->GetOstIdx(), newChiNode);
+    }
+  }
+  return true;
+}
+
+static MeExpr *FoldCmpOfBitOps(IRMap &irmap, const MeExpr &cmp1, const MeExpr &cmp2) {
+  if (cmp1.GetOp() != cmp2.GetOp() || cmp1.GetOpnd(1) != cmp2.GetOpnd(1)) {
+    return nullptr;
+  }
+  auto opnd1 = cmp1.GetOpnd(1);
+  if (!opnd1 || opnd1->GetMeOp() != kMeOpConst) {
+    return nullptr;
+  }
+  if (!IsPrimitiveInteger(cmp1.GetOpnd(1)->GetPrimType())) {
+    return nullptr;
+  }
+  auto val = static_cast<ConstMeExpr *>(cmp1.GetOpnd(1))->GetIntValue();
+  if (!(cmp1.GetOp() == OP_ne && val == 0)) {
+    return nullptr;
+  }
+  auto op0OfCmp1 = cmp1.GetOpnd(0);
+  auto op0OfCmp2 = cmp2.GetOpnd(0);
+  return ConstantFold::FoldOrOfAnds(irmap, *op0OfCmp1, *op0OfCmp2);
+}
+
+// fold 2 sequential condbranch if they are semantically logical and/or
+// cond1                cond3
+//   |   \                |\
+// cond2  \      ->       | \
+//   |   \ \          fallth br
+// fallth \|
+//   |    br
+bool OptimizeBB::FoldCondBranch() {
+  CHECK_CURR_BB();
+  auto succBB = currBB->GetSucc(0);
+  if (succBB->GetKind() != kBBCondGoto) {
+    return false;
+  }
+  auto realBrOfCurr = FindFirstRealSucc(currBB->GetSucc(1));
+  auto realBrOfSucc = FindFirstRealSucc(succBB->GetSucc(1));
+  if (realBrOfCurr != realBrOfSucc) {
+    return false;
+  }
+  auto stmt1 = static_cast<CondGotoMeStmt *>(currBB->GetLastMe());
+  auto stmt2 = static_cast<CondGotoMeStmt *>(succBB->GetFirstMe());
+  if (stmt1->GetOp() != stmt2->GetOp()) {
+    return false;
+  }
+  MeExpr *foldExpr = nullptr;
+
+  do {
+    bool isAnd = false;
+    if (stmt1->GetOp() == OP_brfalse) {
+      isAnd = true;
+    }
+
+    if (!isAnd && (foldExpr = FoldCmpOfBitOps(*irmap, *stmt1->GetOpnd(), *stmt2->GetOpnd())) != nullptr) {
+      break;
+    }
+
+    if ((foldExpr = ConstantFold::FoldCmpExpr(*irmap, *stmt1->GetOpnd(), *stmt2->GetOpnd(), isAnd)) != nullptr) {
+      break;
+    }
+  } while (0);
+
+  if (foldExpr) {
+    stmt1->SetOpnd(0, foldExpr);
+    stmt1->SetBranchProb(stmt2->GetBranchProb());
+    succBB->RemoveLastMeStmt();
+    succBB->SetKind(kBBFallthru);
+    if (cfg->UpdateCFGFreq()) {
+      uint64 freqToMove = succBB->GetSuccFreq()[1];
+      currBB->SetSuccFreq(0, currBB->GetSuccFreq()[0] - freqToMove);
+      succBB->SetFrequency(succBB->GetFrequency() - freqToMove);
+      currBB->SetSuccFreq(1, currBB->GetSuccFreq()[1] + freqToMove);
+      currBB->GetSucc(1)->SetFrequency(currBB->GetSucc(1)->GetFrequency() + freqToMove);
+    }
+    BB *succOfSuccBB = succBB->GetSucc(1);
+    succBB->RemoveBBFromSucc(*succOfSuccBB);
+    succOfSuccBB->RemoveBBFromPred(*succBB, true);
+    return true;
+  }
+  return false;
+}
+
+bool IsExprSameLexicalally(MeExpr *expr1, MeExpr *expr2) {
+  if (expr1 == expr2) {
+    return true;
+  }
+  PrimType ptyp1 = expr1->GetPrimType();
+  PrimType ptyp2 = expr2->GetPrimType();
+  if (expr1->GetOp() != expr2->GetOp() || ptyp1 != ptyp2) {
+    return false;
+  }
+  MeExprOp op1 = expr1->GetMeOp();
+  switch (op1) {
+    case kMeOpConst: {
+      MIRConst *const1 = static_cast<ConstMeExpr*>(expr1)->GetConstVal();
+      MIRConst *const2 = static_cast<ConstMeExpr*>(expr2)->GetConstVal();
+      if (const1->GetKind() == kConstInt) {
+        return static_cast<MIRIntConst*>(const1)->GetExtValue() == static_cast<MIRIntConst*>(const2)->GetExtValue();
+      } else if (const1->GetKind() == kConstFloatConst) {
+        return IsFloatingPointNumBitsSame<float>(static_cast<MIRFloatConst*>(const1)->GetValue(),
+                                                 static_cast<MIRFloatConst*>(const2)->GetValue());
+      } else if (const1->GetKind() == kConstDoubleConst) {
+        return IsFloatingPointNumBitsSame<double>(static_cast<MIRDoubleConst*>(const1)->GetValue(),
+                                                  static_cast<MIRDoubleConst*>(const2)->GetValue());
+      }
+      return false;
+    }
+    case kMeOpReg:
+    case kMeOpVar: {
+      return static_cast<ScalarMeExpr*>(expr1)->GetOstIdx() == static_cast<ScalarMeExpr*>(expr2)->GetOstIdx();
+    }
+    case kMeOpAddrof: {
+      return static_cast<AddrofMeExpr*>(expr1)->GetOstIdx() == static_cast<AddrofMeExpr*>(expr2)->GetOstIdx();
+    }
+    case kMeOpOp: {
+      auto *opExpr1 = static_cast<OpMeExpr*>(expr1);
+      auto *opExpr2 = static_cast<OpMeExpr*>(expr2);
+      if (opExpr1->GetOp() != opExpr2->GetOp() || opExpr1->GetTyIdx() != opExpr2->GetTyIdx() ||
+          opExpr1->GetFieldID() != opExpr2->GetFieldID() || opExpr1->GetBitsOffSet() != opExpr2->GetBitsOffSet() ||
+          opExpr1->GetBitsSize() != opExpr2->GetBitsSize() || opExpr1->GetNumOpnds() != opExpr2->GetNumOpnds()) {
+        return false;
+      }
+      for (size_t i = 0; i < expr1->GetNumOpnds(); ++i) {
+        if (!IsExprSameLexicalally(expr1->GetOpnd(i), expr2->GetOpnd(i))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+enum BranchResult {
+  kBrFalse,
+  kBrTrue,
+  kBrUnknown
+};
+
+void SwapCmpOpnds(Opcode &op, MeExpr *&opnd0, MeExpr *&opnd1) {
+  if (!kOpcodeInfo.IsCompare(op)) {
+    return;
+  }
+  MeExpr *tmp = opnd0;
+  opnd0 = opnd1;
+  opnd1 = tmp;
+  // keep the result of succCond the same
+  // for cmp/cmpg/cmpl, only if the opnds are equal, the result is zero, otherwise the result is not zero(-1/+1)
+  switch (op) {
+    case OP_ge:
+      op = OP_le;
+      return;
+    case OP_gt:
+      op = OP_lt;
+      return;
+    case OP_le:
+      op = OP_ge;
+      return;
+    case OP_lt:
+      op = OP_gt;
+      return;
+    default:
+      return;
+  }
+}
+
+// Precondition : predCond branches to succCond
+// isPredTrueBrSucc : predCond->succCond is true branch or false branch
+BranchResult InferSuccCondBrFromPredCond(const MeExpr *predCond, const MeExpr *succCond, bool isPredTrueBrSucc) {
+  if (!kOpcodeInfo.IsCompare(predCond->GetOp()) || !kOpcodeInfo.IsCompare(succCond->GetOp())) {
+    return kBrUnknown;
+  }
+  if (predCond->ContainsVolatile() || succCond->ContainsVolatile()) {
+    return kBrUnknown;
+  }
+  if (predCond == succCond) {
+    return isPredTrueBrSucc ? kBrTrue : kBrFalse;
+  }
+  Opcode op1 = predCond->GetOp();
+  Opcode op2 = succCond->GetOp();
+  MeExpr *opnd10 = predCond->GetOpnd(0);
+  MeExpr *opnd11 = predCond->GetOpnd(1);
+  MeExpr *opnd20 = succCond->GetOpnd(0);
+  MeExpr *opnd21 = succCond->GetOpnd(1);
+  if (IsExprSameLexicalally(opnd10, opnd21) && IsExprSameLexicalally(opnd11, opnd20)) {
+    // swap two opnds ptr of succCond
+    SwapCmpOpnds(op2, opnd20, opnd21);
+  }
+  if (!IsExprSameLexicalally(opnd10, opnd20) || !IsExprSameLexicalally(opnd11, opnd21)) {
+    return kBrUnknown;
+  }
+  if (op1 == op2) {
+    return isPredTrueBrSucc ? kBrTrue : kBrFalse;
+  }
+  if (!isPredTrueBrSucc) {
+    if (IsCompareHasReverseOp(op1)) {
+      // if predCond false br to succCond, we invert its op and assume it true br to succCond
+      op1 = GetReverseCmpOp(op1);
+    }
+  }
+  switch (op1) {
+    case OP_ge: {
+      if (op2 == OP_lt) {
+        return kBrFalse;
+      }
+      return kBrUnknown;
+    }
+    case OP_gt: {
+      if (op2 == OP_ge || op2 == OP_ne || op2 == OP_cmp) {
+        return kBrTrue;
+      } else if (op2 == OP_le || op2 == OP_lt || op2 == OP_eq) {
+        return kBrFalse;
+      }
+      return kBrUnknown;
+    }
+    case OP_eq: {
+      if (op2 == OP_gt || op2 == OP_lt || op2 == OP_ne || op2 == OP_cmp) {
+        return kBrFalse;
+      }
+      return kBrUnknown;
+    }
+    case OP_le: {
+      if (op2 == OP_gt) {
+        return kBrFalse;
+      }
+      return kBrUnknown;
+    }
+    case OP_lt: {
+      if (op2 == OP_ge || op2 == OP_gt || op2 == OP_eq) {
+        return kBrFalse;
+      } else if (op2 == OP_le || op2 == OP_ne || op2 == OP_cmp) {
+        return kBrTrue;
+      }
+      return kBrUnknown;
+    }
+    case OP_ne: {
+      if (op2 == OP_eq) {
+        return kBrFalse;
+      } else if (op2 == OP_cmp) {
+        return kBrTrue;
+      }
+      return kBrUnknown;
+    }
+    case OP_cmp: {
+      if (op2 == OP_eq) {
+        return isPredTrueBrSucc ? kBrFalse : kBrTrue;
+      } else if (op2 == OP_ne) {
+        return isPredTrueBrSucc ? kBrTrue : kBrFalse;
+      }
+      return kBrUnknown;
+    }
+    case OP_cmpg:
+    case OP_cmpl: {
+      return kBrUnknown;
+    }
+    default:
+      return kBrUnknown;
+  }
+}
+
+//    ...  pred
+//      \  /  \
+//      succ  ...
+//      /  \
+//    ftBB  gtBB
+//
+// If succ's cond can be inferred from pred's cond, pred can skip succ and branches to one of succ's successors directly
+// Here we deal with two cases:
+// 1. pred's cond is the same as succ's
+// 2. pred's cond is opposite to succ's
+bool OptimizeBB::SkipRedundantCond(BB &pred, BB &succ) {
+  if (pred.GetKind() != kBBCondGoto || succ.GetKind() != kBBCondGoto || &pred == &succ) {
+    return false;
+  }
+  // try to simplify succ first, if all successors of succ is the same, no need to check the condition
+  if (BranchBB2UncondBB(succ)) {
+    return true;
+  }
+  auto *predBr = static_cast<CondGotoMeStmt*>(pred.GetLastMe());
+  auto *succBr = static_cast<CondGotoMeStmt*>(succ.GetLastMe());
+  CHECK_FATAL(predBr, "predBr is nullptr!");
+  CHECK_FATAL(succBr, "succBr is nullptr!");
+  if (!IsAllOpndsNotDefByCurrBB(*succBr)) {
+    return false;
+  }
+  MeExpr *predCond = predBr->GetOpnd(0);
+  MeExpr *succCond = succBr->GetOpnd(0);
+  auto ptfSucc = GetTrueFalseBrPair(&pred);  // pred true and false
+  auto stfSucc = GetTrueFalseBrPair(&succ);  // succ true and false
+  // Try to infer result of succCond from predCond
+  bool isPredTrueBrSucc = (FindFirstRealSucc(ptfSucc.first) == &succ);
+  BranchResult tfBranch = InferSuccCondBrFromPredCond(predCond, succCond, isPredTrueBrSucc);
+  if (tfBranch == kBrUnknown) {  // succCond cannot be inferred from predCond
+    return false;
+  }
+  // if succ's cond can be inferred from pred's cond, pred can skip succ and branches to newTarget directly
+  BB *newTarget = (tfBranch == kBrTrue) ? FindFirstRealSucc(stfSucc.first) : FindFirstRealSucc(stfSucc.second);
+  if (newTarget == nullptr || newTarget == &succ) {
+    return false;
+  }
+  DEBUG_LOG() << "Condition in BB" << LOG_BBID(&succ) << " is redundant, since it has been checked in BB"
+              << LOG_BBID(&pred) << ", BB" << LOG_BBID(&pred) << " can branch to BB" << LOG_BBID(newTarget) << "\n";
+  // succ has only one pred, turn succ to an uncondBB(fallthru or gotoBB)
+  //         pred
+  //         /  \
+  //      succ  ...
+  //      /  \
+  //    ftBB  gtBB
+  if (succ.GetPred().size() == 1) {  // succ has only one pred
+    // if newTarget is succ's gotoBB, and it has fallthru pred, we should add a goto stmt to succ's last
+    // to replace condGoto stmt. Otherwise, newTarget will have two fallthru pred
+    if (newTarget == FindFirstRealSucc(succ.GetSucc(1)) && HasFallthruPred(*newTarget)) {
+      CHECK_FATAL(succ.GetLastMe(), "LastMe is nullptr!");
+      auto *gotoStmt =
+          irmap->CreateGotoMeStmt(f.GetOrCreateBBLabel(*newTarget), &succ, &succ.GetLastMe()->GetSrcPosition());
+      succ.ReplaceMeStmt(succ.GetLastMe(), gotoStmt);
+      succ.SetKind(kBBGoto);
+      DEBUG_LOG() << "SkipRedundantCond : Replace condBr in BB" << LOG_BBID(&succ) << " with an uncond goto\n";
+      EliminateEmptyConnectingBB(&succ, succ.GetSucc(1), newTarget, *cfg);
+      ASSERT(succ.GetSucc(1) == newTarget, "[FUNC: %s] newTarget should be successor of succ!", funcName.c_str());
+    } else {
+      succ.RemoveLastMeStmt();
+      succ.SetKind(kBBFallthru);
+      DEBUG_LOG() << "SkipRedundantCond : Remove condBr in BB" << LOG_BBID(&succ) << ", turn it to fallthruBB\n";
+    }
+    BB *rmBB = (FindFirstRealSucc(succ.GetSucc(0)) == newTarget) ? succ.GetSucc(1) : succ.GetSucc(0);
+    uint64 deletedSuccFreq = 0;
+    if (cfg->UpdateCFGFreq()) {
+      int idx = succ.GetSuccIndex(*rmBB);
+      deletedSuccFreq = succ.GetSuccFreq()[static_cast<uint32>(idx)];
+    }
+    succ.RemoveSucc(*rmBB, true);
+    if (cfg->UpdateCFGFreq()) {
+      succ.SetSuccFreq(0, succ.GetFrequency());
+      auto *succofSucc = succ.GetSucc(0);
+      succofSucc->SetFrequency(succofSucc->GetFrequency() + deletedSuccFreq);
+    }
+    DEBUG_LOG() << "Remove succ BB" << LOG_BBID(rmBB) << " of pred BB" << LOG_BBID(&succ) << "\n";
+    return true;
+  } else {
+    if (MeOption::optForSize) {
+      return false;
+    }
+    BB *newBB = cfg->NewBasicBlock();
+    // if succ has only last stmt, no need to copy
+    if (!HasOnlyMeCondGotoStmt(succ)) {
+      // succ has more than one pred, clone all stmts in succ (except last stmt) to a new BB
+      DEBUG_LOG() << "Create a new BB" << LOG_BBID(newBB) << ", and copy stmts from BB" << LOG_BBID(&succ) << "\n";
+      // this step will create new def version and collect it to ssa updater
+      f.CloneBBMeStmts(succ, *newBB, cands, true);
+      // we should update use version in newBB as phiopnds in succ
+      // BB succ:
+      //  ...    pred(v2 is def here or its pred)              ...               pred(v2 is def here or its pred)
+      //    \      /                                            \                  /
+      //      succ                                 ==>         succ             newBB
+      //   v3 = phi(..., v2)                               v3 = phi(...)       newBB should use v2 instead of v3
+      //
+      // here we collect ost in philist of succ, and make it defBB as pred, then ssa updater will update it in newBB
+      UpdateSSACandForBBPhiList(&succ, &pred);
+    }
+    newBB->SetAttributes(succ.GetAttributes());
+    if (HasFallthruPred(*newTarget)) {
+      // insert a gotostmt to avoid duplicate fallthru pred
+      CHECK_FATAL(succ.GetLastMe(), "LastMe is nullptr!");
+      auto *gotoStmt =
+          irmap->CreateGotoMeStmt(f.GetOrCreateBBLabel(*newTarget), newBB, &succ.GetLastMe()->GetSrcPosition());
+      newBB->AddMeStmtLast(gotoStmt);
+      newBB->SetKind(kBBGoto);
+    } else {
+      newBB->SetKind(kBBFallthru);
+    }
+    BB *replacedSucc = isPredTrueBrSucc ? ptfSucc.first : ptfSucc.second;
+    EliminateEmptyConnectingBB(&pred, replacedSucc, &succ, *cfg);
+    ASSERT(pred.IsPredBB(succ),
+           "[FUNC: %s]After eliminate connecting BB, pred must be predecessor of succ", funcName.c_str());
+    int predPredIdx = succ.GetPredIndex(pred); // before replace succ, record predidx for UpdatePhiForMovingPred
+    pred.ReplaceSucc(&succ, newBB, false); // do not update phi here, UpdatePhiForMovingPred will do it
+    DEBUG_LOG() << "Replace succ BB" << LOG_BBID(replacedSucc) << " with BB" << LOG_BBID(newBB) << ": BB"
+                << LOG_BBID(&pred) << "->...->BB" << LOG_BBID(&succ) << "(skipped)"
+                << " => BB" << LOG_BBID(&pred) << "->BB" << LOG_BBID(newBB) << "(new)->BB" << LOG_BBID(newTarget)
+                << "\n";
+    if (pred.GetSucc(1) == newBB) {
+      cfg->UpdateBranchTarget(pred, succ, *newBB, f);
+    }
+    newTarget->AddPred(*newBB);
+    UpdatePhiForMovingPred(predPredIdx, newBB, &succ, newTarget);
+    // update newBB frequency : copy predBB succFreq as newBB frequency
+    if (cfg->UpdateCFGFreq()) {
+      int idx = pred.GetSuccIndex(*newBB);
+      ASSERT(idx >= 0 && idx < pred.GetSucc().size(), "sanity check");
+      uint64 freq = pred.GetEdgeFreq(idx);
+      newBB->SetFrequency(freq);
+      newBB->PushBackSuccFreq(freq);
+      // update frequency of succ because one of its pred is removed
+      // frequency of
+      uint64 freqOfSucc = succ.GetFrequency();
+      ASSERT(freqOfSucc >= freq, "sanity check");
+      succ.SetFrequency(freqOfSucc - freq);
+      // update edge frequency
+      BB *affectedBB = (tfBranch == kBrTrue) ? stfSucc.first : stfSucc.second;
+      idx = succ.GetSuccIndex(*affectedBB);
+      ASSERT(idx >= 0 && idx < succ.GetSucc().size(), "sanity check");
+      int64_t oldedgeFreq = static_cast<int64_t>(succ.GetSuccFreq()[static_cast<uint32>(idx)]);
+      ASSERT(oldedgeFreq >= freq, "sanity check");
+      succ.SetSuccFreq(idx, static_cast<uint64>(oldedgeFreq) - freq);
+    }
+    return true;
+  }
+}
+
+bool OptimizeBB::SkipRedundantCond() {
+  CHECK_CURR_BB();
+  if (currBB->GetKind() != kBBCondGoto) {
+    return false;
+  }
+  bool changed = false;
+  // Check for currBB and its successors
+  for (size_t i = 0; i < currBB->GetSucc().size(); ++i) {
+    BB *realSucc = FindFirstRealSucc(currBB->GetSucc(i));
+    changed |= SkipRedundantCond(*currBB, *realSucc);
+  }
+  return changed;
+}
+
+// CurrBB is Condition BB, we will look upward its predBB(s) to see if it can be optimized.
+// 1. currBB is X == constVal, and predBB has checked for the same expr, the result is known for currBB's condition,
+//    so we can make currBB to be an uncondBB.
+// 2. currBB has only one stmt(conditional branch stmt), and the condition's value is calculated by all its predBB
+//    we can hoist currBB's stmt to predBBs if it is profitable
+// 3. predBB is CondBB, one of predBB's succBB is currBB, and another is one of currBB's successors(commonBB)
+//    we can merge currBB to predBB if currBB is simple enough(has only one stmt).
+// 4. condition branch to select
+bool OptimizeBB::OptimizeCondBB() {
+  CHECK_CURR_BB();
+  ONLY_FOR_MEIR();
+  MeStmt *stmt = currBB->GetLastMe();
+  CHECK_FATAL(stmt != nullptr, "[FUNC: %s] CondBB has no stmt", f.GetName().c_str());
+  CHECK_FATAL(kOpcodeInfo.IsCondBr(stmt->GetOp()), "[FUNC: %s] Opcode is error!", f.GetName().c_str());
+  bool change = false;
+  // 2. result of currBB's cond can be inferred from predBB's cond, change predBB's br target
+  if (SkipRedundantCond()) {
+    SetBBRunAgain();
+    change = true;
+  }
+  // 3.fold two continuous condBB to one condBB, use or/and to combine two condition
+  if (FoldBranchToCommonDest()) {
+    ResetBBRunAgain();
+    return true;
+  }
+  // 4. condition branch to select
+  if (CondBranchToSelect()) {
+    SetBBRunAgain();
+    return true;
+  }
+  if (FoldCondBranch()) {
+    SetBBRunAgain();
+    return true;
+  }
+  return change;
+}
+
+// after moving pred from curr to curr's successor (i.e. succ), update the phiList of curr and succ
+// a phiOpnd will be removed from curr's philist, and another phiOpnd will be inserted to succ's philist
+//
+//    ...  pred           ...     pred
+//      \  /  \            \       / \
+//      curr  ...   ==>   curr    /  ...
+//      /  \   ...         /  \  / ...
+//     /    \  /          /    \/ /
+//   ...    succ         ...  succ
+//
+// parameter predIdxForCurr is the index of pred in the predVector of curr
+// note:
+// 1.when replace pred's succ (i.e. curr) with succ, please DO NOT remove phiOpnd immediately,
+// otherwise we cannot get phiOpnd in this step
+// 2.predIdxForCurr should be get before disconnecting pred and curr
+void OptimizeBB::UpdatePhiForMovingPred(int predIdxForCurr, const BB *pred, BB *curr, BB *succ) {
+  auto &succPhiList = succ->GetMePhiList();
+  auto &currPhilist = curr->GetMePhiList();
+  int predPredIdx = succ->GetPredIndex(*pred);
+  if (succPhiList.empty()) {
+    // succ has only one pred(i.e. curr) before
+    // we copy curr's philist to succ, but not with all phiOpnd
+    for (auto &phiNode : currPhilist) {
+      auto *phiMeNode = irmap->NewInPool<MePhiNode>();
+      phiMeNode->SetDefBB(succ);
+      succPhiList.emplace(phiNode.first, phiMeNode);
+      auto &phiOpnds = phiMeNode->GetOpnds();
+      // curr is already pred of succ, so all phiOpnds (except for pred) are phiNode lhs in curr
+      phiOpnds.insert(phiOpnds.end(), succ->GetPred().size(), phiNode.second->GetLHS());
+      // pred is a new pred for succ, we copy its corresponding phiopnd in curr to succ
+      phiMeNode->SetOpnd(static_cast<size_t>(predPredIdx),
+                         phiNode.second->GetOpnd(static_cast<size_t>(predIdxForCurr)));
+      OStIdx ostIdx = phiNode.first;
+      // create a new version for new phi
+      phiMeNode->SetLHS(irmap->CreateRegOrVarMeExprVersion(ostIdx));
+    }
+    UpdateSSACandForBBPhiList(succ);  // new philist has been created in succ
+  } else {
+    // succ has other pred besides curr
+    for (auto &phi : succPhiList) {
+      OStIdx ostIdx = phi.first;
+      auto it = currPhilist.find(ostIdx);
+      ASSERT(predPredIdx != -1,
+             "[FUNC: %s]pred BB%d is not a predecessor of succ BB%d yet", funcName.c_str(),
+             LOG_BBID(pred), LOG_BBID(succ));
+      auto &phiOpnds = phi.second->GetOpnds();
+      if (it != currPhilist.end()) {
+        // curr has phiNode for this ost, we copy pred's corresponding phiOpnd in curr to succ
+        phiOpnds.insert(phiOpnds.begin() + predPredIdx, it->second->GetOpnd(static_cast<size_t>(predIdxForCurr)));
+      } else {
+        // curr has no phiNode for this ost, pred's phiOpnd in succ will be the same as curr's phiOpnd in succ
+        int index = GetRealPredIdx(*succ, *curr);
+        ASSERT(index != -1, "[FUNC: %s]succ is not newTarget's real pred", f.GetName().c_str());
+        // pred's phi opnd is the same as curr.
+        phiOpnds.insert(phiOpnds.begin() + predPredIdx, phi.second->GetOpnd(static_cast<size_t>(index)));
+      }
+    }
+    // search philist in curr for phinode that is not in succ yet
+    for (auto &phi : currPhilist) {
+      OStIdx ostIdx = phi.first;
+      auto resPair = succPhiList.emplace(ostIdx, nullptr);
+      if (!resPair.second) {
+        // phinode is in succ, last step has updated it
+        continue;
+      } else {
+        auto *phiMeNode = irmap->NewInPool<MePhiNode>();
+        phiMeNode->SetDefBB(succ);
+        resPair.first->second = phiMeNode;  // replace nullptr inserted before
+        auto &phiOpnds = phiMeNode->GetOpnds();
+        // insert opnd into New phiNode : all phiOpnds (except for pred) are phiNode lhs in curr
+        phiOpnds.insert(phiOpnds.end(), succ->GetPred().size(), phi.second->GetLHS());
+        // pred is new pred for succ, we copy its corresponding phiopnd in curr to succ
+        phiMeNode->SetOpnd(static_cast<size_t>(predPredIdx), phi.second->GetOpnd(static_cast<size_t>(predIdxForCurr)));
+        // create a new version for new phinode
+        phiMeNode->SetLHS(irmap->CreateRegOrVarMeExprVersion(ostIdx));
+        UpdateSSACandForOst(ostIdx, succ);
+      }
+    }
+  }
+  // remove pred's corresponding phiOpnd from curr's philist
+  curr->RemovePhiOpnd(predIdxForCurr);
+}
+
+// succ must have only one goto statement
+// pred must be three of below:
+// 1. fallthrough BB
+// 2. have a goto stmt
+// 3. conditional branch, and succ must be pred's goto target in this case
+bool OptimizeBB::MergeGotoBBToPred(BB *succ, BB *pred) {
+  if (pred == nullptr || succ == nullptr) {
+    return false;
+  }
+  // If we merge succ to pred, a new BB will be create to split the same critical edge
+  if (MeSplitCEdge::IsCriticalEdgeBB(*pred)) {
+    return false;
+  }
+  if (succ == pred) {
+    return false;
+  }
+  if (succ->GetAttributes(kBBAttrIsEntry) || succ->IsMeStmtEmpty()) {
+    return false;
+  }
+  // BB has only one stmt(i.e. unconditional goto stmt)
+  if (!HasOnlyMeGotoStmt(*succ)) {
+    return false;
+  }
+  BB *newTarget = succ->GetSucc(0);  // succ must have only one succ, because it is uncondBB
+  if (newTarget == succ) {
+    // succ goto itself, no need to update goto target to newTarget
+    return false;
+  }
+  // newTarget has only one pred, skip, because MergeDistinctBBPair will deal with this case
+  if (newTarget->GetPred().size() == 1) {
+    return false;
+  }
+  // pred is moved to newTarget
+  if (pred->GetKind() == kBBFallthru) {
+    CHECK_FATAL(succ->GetLastMe(), "LastMe is nullptr!");
+    GotoMeStmt *gotoMeStmt =
+        irmap->CreateGotoMeStmt(newTarget->GetBBLabel(), pred, &succ->GetLastMe()->GetSrcPosition());
+    pred->AddMeStmtLast(gotoMeStmt);
+    pred->SetKind(kBBGoto);
+    DEBUG_LOG() << "Insert Uncond stmt to fallthru BB" << LOG_BBID(currBB) << ", and goto BB" << LOG_BBID(newTarget)
+                << "\n";
+  }
+  int predIdx = succ->GetPredIndex(*pred);
+  bool needUpdatePhi = false;
+  uint64 removedFreq = 0;
+  if (cfg->UpdateCFGFreq()) {
+    int idx = pred->GetSuccIndex(*succ);
+    removedFreq = pred->GetSuccFreq()[static_cast<uint32>(idx)];
+  }
+  if (pred->IsPredBB(*newTarget)) {
+    pred->RemoveSucc(*succ, true);  // one of pred's succ has been newTarget, avoid duplicate succ here
+    if (cfg->UpdateCFGFreq()) {
+      int idx = pred->GetSuccIndex(*newTarget);
+      pred->SetSuccFreq(idx, pred->GetSuccFreq()[static_cast<uint32>(idx)] + removedFreq);
+    }
+  } else {
+    pred->ReplaceSucc(succ, newTarget);  // phi opnd is not removed from currBB's philist, we will remove it later
+    needUpdatePhi = true;
+  }
+  if (cfg->UpdateCFGFreq()) {
+    uint64 succFreq = succ->GetFrequency();
+    if (succFreq >= removedFreq) {
+      succ->SetFrequency(succFreq - removedFreq);
+      succ->SetSuccFreq(0, succ->GetFrequency());
+    }
+  }
+  DEBUG_LOG() << "Merge Uncond BB" << LOG_BBID(succ) << " to its pred BB" << LOG_BBID(pred) << ": BB" << LOG_BBID(pred)
+              << "->BB" << LOG_BBID(succ) << "(merged)->BB" << LOG_BBID(newTarget) << "\n";
+  cfg->UpdateBranchTarget(*pred, *succ, *newTarget, f);
+  if (needUpdatePhi) {
+    // remove phiOpnd in succ, and add phiOpnd to newTarget
+    UpdatePhiForMovingPred(predIdx, pred, succ, newTarget);
+  }
+  // remove succ if succ has no pred
+  if (succ->GetPred().empty()) {
+    newTarget->RemovePred(*succ, true);
+    DEBUG_LOG() << "Delete Uncond BB" << LOG_BBID(succ) << " after merged to all its preds\n";
+    UpdateSSACandForBBPhiList(succ, newTarget);
+    DeleteBB(succ);
+  }
+  // if all branch destination of pred (condBB or switchBB) are the same, we should turn pred into uncond
+  (void)BranchBB2UncondBB(*pred);
+  return true;
+}
+
+// if unconditional BB has only one uncondBr stmt, we try to merge it to its pred
+// this is different from MergeDistinctBBPair, it is not required that current uncondBB has only one pred
+//   pred1  pred2  pred3
+//        \   |   /
+//         \  |  /
+//           succ
+//            |     other pred
+//            |    /
+//         newTarget
+bool OptimizeBB::OptimizeUncondBB() {
+  CHECK_CURR_BB();
+  ONLY_FOR_MEIR();
+  if (currBB->GetAttributes(kBBAttrIsEntry) || currBB->IsMeStmtEmpty()) {
+    return false;
+  }
+  // BB has only one stmt(i.e. unconditional goto stmt)
+  if (!HasOnlyMeGotoStmt(*currBB)) {
+    return false;
+  }
+  // jump to itself
+  if (currBB->GetSucc(0) == currBB) {
+    return false;
+  }
+  // wont exit BB and has an edge to commonExit, if we merge it to pred and delete it, the egde will be cut off
+  if (currBB->GetSucc().size() == 2) { // 2 succ : first is gotoTarget, second is edge to commonExit
+    ASSERT(currBB->GetAttributes(kBBAttrWontExit),
+           "[FUNC: %s]GotoBB%d is not wontexitBB, but has two succ", funcName.c_str(), LOG_BBID(currBB));
+    return false;
+  }
+  bool changed = false;
+  // try to move pred from currBB to newTarget
+  for (size_t i = 0; i < currBB->GetPred().size();) {
+    BB *pred = currBB->GetPred(i);
+    if (pred == nullptr || pred->GetLastMe() == nullptr || pred->GetPred().empty()) {
+      ++i;
+      continue;
+    }
+    if (pred->IsGoto() || pred->GetKind() == kBBSwitch ||
+        (pred->GetLastMe()->IsCondBr() && currBB == pred->GetSucc(1))) {
+      // pred is moved to newTarget
+      bool merged = MergeGotoBBToPred(currBB, pred);
+      if (merged) {
+        changed = true;
+      } else {
+        ++i;
+      }
+    } else {
+      ++i;
+    }
+  }
+  return changed;
+}
+
+bool OptimizeBB::OptimizeFallthruBB() {
+  CHECK_CURR_BB();
+  ONLY_FOR_MEIR();
+  if (MeSplitCEdge::IsCriticalEdgeBB(*currBB) || currBB->IsPredBB(*cfg->GetCommonExitBB())) {
+    return false;
+  }
+  BB *succ = currBB->GetSucc(0);
+  if (succ == nullptr || succ == currBB) {
+    return false;
+  }
+  if (succ->GetAttributes(kBBAttrIsEntry) || succ->IsMeStmtEmpty()) {
+    return false;
+  }
+  // BB has only one stmt(i.e. unconditional goto stmt)
+  if (!HasOnlyMeGotoStmt(*succ)) {
+    return false;
+  }
+  // BB has only one pred/succ, skip, because MergeDistinctBBPair will deal with this case
+  // note: gotoBB may have two succ, the second succ is inserted by cfg wont exit analysis
+  if (succ->GetPred().size() == 1 || succ->GetSucc().size() == 1) {
+    return false;
+  }
+  return MergeGotoBBToPred(succ, currBB);
+}
+
+bool OptimizeBB::OptimizeSwitchBB() {
+  CHECK_CURR_BB();
+  ONLY_FOR_MEIR();
+  auto *swStmt = static_cast<SwitchMeStmt*>(currBB->GetLastMe());
+  CHECK_FATAL(swStmt, "swStmt is nullptr!");
+  if (swStmt->GetOpnd()->GetMeOp() != kMeOpConst) {
+    return false;
+  }
+  auto *swConstExpr = static_cast<ConstMeExpr*>(swStmt->GetOpnd());
+  MIRConst *swConstVal = swConstExpr->GetConstVal();
+  ASSERT(swConstVal->GetKind() == kConstInt, "[FUNC: %s]switch is only legal for integer val", funcName.c_str());
+  int64 val = static_cast<MIRIntConst*>(swConstVal)->GetExtValue();
+  BB *survivor = currBB->GetSucc(0);  // init as default BB
+  for (size_t i = 0; i < swStmt->GetSwitchTable().size(); ++i) {
+    int64 caseVal = swStmt->GetSwitchTable().at(i).first;
+    if (caseVal == val) {
+      LabelIdx label = swStmt->GetSwitchTable().at(i).second;
+      survivor = cfg->GetLabelBBAt(label);
+    }
+  }
+  // remove all succ expect for survivor
+  for (size_t i = 0; i < currBB->GetSucc().size();) {
+    BB *succ = currBB->GetSucc(i);
+    if (succ != survivor) {
+      succ->RemovePred(*currBB, true);
+      continue;
+    }
+    ++i;
+  }
+  DEBUG_LOG() << "Constant switchBB to Uncond BB : BB" << LOG_BBID(currBB) << "->BB" << LOG_BBID(survivor) << "\n";
+  // replace switch stmt with a goto stmt
+  LabelIdx label = f.GetOrCreateBBLabel(*survivor);
+  auto *gotoStmt = irmap->New<GotoMeStmt>(label);
+  gotoStmt->SetSrcPos(swStmt->GetSrcPosition());
+  gotoStmt->SetBB(currBB);
+  currBB->RemoveLastMeStmt();
+  currBB->AddMeStmtLast(gotoStmt);
+  currBB->SetKind(kBBGoto);
+  SetBBRunAgain();
+  return true;
+}
+
+// deal with expr like:
+// lior ( le/lt (sameExpr, intval1), ge/gt (sameExpr, intval2))
+// We use an offset(i.e. intval1) to make the little num overflow (wrap around)
+// (x < val1 || x > val2) <==> ((unsigned)(x - val1) > (val2 - val1))
+MeExpr *OptimizeBB::CombineCondByOffset(const MeExpr &expr) {
+  if (expr.GetOp() != OP_lior) {
+    return nullptr;
+  }
+  MeExpr *leExpr = expr.GetOpnd(0);
+  MeExpr *geExpr = expr.GetOpnd(1);
+  Opcode leOp = leExpr->GetOp();
+  Opcode geOp = geExpr->GetOp();
+  if ((leOp != OP_le && leOp != OP_lt) || (geOp != OP_ge && geOp != OP_gt)) {
+    return nullptr;
+  }
+  PrimType opndPtyp = static_cast<OpMeExpr*>(leExpr)->GetOpndType();
+  if (opndPtyp != static_cast<OpMeExpr*>(geExpr)->GetOpndType()) {
+    return nullptr;
+  }
+  MeExpr *sameExpr = leExpr->GetOpnd(0);
+  if (sameExpr != geExpr->GetOpnd(0)) {
+    return nullptr;
+  }
+  MeExpr *leConst = leExpr->GetOpnd(1);
+  MeExpr *geConst = geExpr->GetOpnd(1);
+  PrimType lePtyp = leConst->GetPrimType();
+  PrimType gePtyp = geConst->GetPrimType();
+  if (leConst->GetOp() != OP_constval || geConst->GetOp() != OP_constval || lePtyp != gePtyp ||
+      !IsPrimitiveInteger(lePtyp)) {  // only allowed for integer, because float cannot wrap around
+    return nullptr;
+  }
+  int64 leVal = static_cast<MIRIntConst*>(static_cast<ConstMeExpr*>(leConst)->GetConstVal())->GetExtValue();
+  int64 geVal = static_cast<MIRIntConst*>(static_cast<ConstMeExpr*>(geConst)->GetConstVal())->GetExtValue();
+  if (leOp == OP_le) {
+    // (x <= val1) <==> (x < val1 + 1)
+    // if we still use (x <= val1) here, (x - val1) <= 0 may not overflow (if x == val1)
+    ++leVal;
+  }
+  // check if we can simplify it early
+  int64 newGeVal = geOp == OP_ge ? geVal - 1 : geVal;
+  if ((!IsPrimitiveUnsigned(lePtyp) && leVal > newGeVal) ||
+      (IsPrimitiveUnsigned(lePtyp) && static_cast<uint64>(leVal) > static_cast<uint64>(newGeVal))) {
+    // e.g. x < 3 || x > 2 <==> true
+    return irmap->CreateIntConstMeExpr(1, PTY_u1);
+  } else if (leVal == newGeVal) {  // e.g. x < 3 || x > 3 <==> x != 3
+    return irmap->CreateMeExprCompare(OP_ne, PTY_u1, opndPtyp, *sameExpr,
+                                      *irmap->CreateIntConstMeExpr(newGeVal, lePtyp));
+  }
+  // (x < val1 || x > val2) <==> ((unsigned)(x - val1) > (val2 - val1))
+  MeExpr *newLeConst = irmap->CreateIntConstMeExpr(leVal, opndPtyp);
+  PrimType unsignedPtyp = GetUnsignedPrimType(opndPtyp);
+  MeExpr *subExpr = irmap->CreateMeExprBinary(OP_sub, unsignedPtyp, *sameExpr, *newLeConst);
+  MeExpr *newGeConst = irmap->CreateIntConstMeExpr(geVal - leVal, opndPtyp);
+  OpMeExpr *cmpExpr = static_cast<OpMeExpr*>(irmap->CreateMeExprBinary(geOp, PTY_u1, *subExpr, *newGeConst));
+  cmpExpr->SetOpndType(unsignedPtyp);
+  return cmpExpr;
+}
+
+MeExpr *OptimizeBB::TryToSimplifyCombinedCond(const MeExpr &expr) {
+  Opcode op = expr.GetOp();
+  if (op != OP_land && op != OP_lior) {
+    return nullptr;
+  }
+  MeExpr *expr1 = expr.GetOpnd(0);
+  MeExpr *expr2 = expr.GetOpnd(1);
+  // we can only deal with "and/or(cmpop1(sameExpr, constExpr1/scalarExpr), cmpop2(sameExpr, constExpr2/scalarExpr))"
+  if (expr1->GetOpnd(0) != expr2->GetOpnd(0)) {
+    return nullptr;
+  }
+  auto vr1 = GetVRForSimpleCmpExpr(*expr1);
+  auto vr2 = GetVRForSimpleCmpExpr(*expr2);
+  if (vr1.get() == nullptr || vr2.get() == nullptr) {
+    return nullptr;
+  }
+  auto vrRes = MergeVR(*vr1, *vr2, op == OP_land);
+  MeExpr *resExpr = GetCmpExprFromVR(vrRes.get(), *expr1->GetOpnd(0), irmap);
+  if (resExpr != nullptr) {
+    resExpr->SetPtyp(expr.GetPrimType());
+    if (!IsCompareHasReverseOp(resExpr->GetOp())) {
+      return nullptr;
+    }
+  } else {
+    resExpr = CombineCondByOffset(expr);
+  }
+  return resExpr;
+}
+
+// pattern is like:
+//       pred(condBB)
+//       /         \
+//      /     succ(condBB)
+//     /     /       \
+//    commonBB       exitBB
+//
+// note: pred->commonBB and succ->commonBB are critical edge, they may be cut by an empty bb before
+bool OptimizeBB::FoldBranchToCommonDest(BB *pred, BB *succ) {
+  if (!HasOnlyMeCondGotoStmt(*succ)) {
+    // not a simple condBB
+    return false;
+  }
+  // try to simplify realSucc first, if all successors of realSucc is the same, no need to check the condition
+  if (BranchBB2UncondBB(*succ)) {
+    return true;
+  }
+  if (succ->GetPred().size() != 1) {
+    return false;
+  }
+  // Check for pattern : predBB branches to succ, and one of succ's successor(common BB)
+  BB *commonBB = GetCommonDest(pred, succ);
+  if (commonBB == nullptr) {
+    return false;
+  }
+  // we have found a pattern
+  auto *succCondBr = static_cast<CondGotoMeStmt*>(succ->GetLastMe());
+  CHECK_FATAL(succCondBr, "succCondBr is nullptr!");
+  MeExpr *succCond = succCondBr->GetOpnd();
+  auto *predCondBr = static_cast<CondGotoMeStmt*>(pred->GetLastMe());
+  CHECK_FATAL(predCondBr, "predCondBr is nullptr!");
+  MeExpr *predCond = predCondBr->GetOpnd();
+  // Check for safety
+  if (!IsSafeToMergeCond(predCond, succCond)) {
+    DEBUG_LOG() << "Abort Merging Two CondBB : Condition in successor BB" << LOG_BBID(succ) << " is not safe\n";
+    return false;
+  }
+  if (!IsProfitableToMergeCond(predCond, succCond)) {
+    DEBUG_LOG() << "Abort Merging Two CondBB : Condition in successor BB" << LOG_BBID(succ)
+                << " is not simple enough and not profitable\n";
+    return false;
+  }
+  // Start trying to merge two condition together if possible
+  auto ptfBrPair = GetTrueFalseBrPair(pred);  // pred's true and false branches
+  auto stfBrPair = GetTrueFalseBrPair(succ);  // succ's true and false branches
+  Opcode combinedCondOp = OP_undef;
+  bool invertSuccCond = false;  // invert second condition, e.g. (cond1 && !cond2)
+  // all cases are listed as follow:
+  //  | case | predBB -> common | succBB -> common | invertSuccCond | or/and |
+  //  | ---- | ---------------- | ---------------- | -------------- | ------ |
+  //  | 1    | true             | true             |                | or     |
+  //  | 2    | false            | false            |                | and    |
+  //  | 3    | true             | false            | true           | or     |
+  //  | 4    | false            | true             | true           | and    |
+  //
+  // pred's false branch to succ, so true branch to common
+  bool isPredTrueToCommon = (FindFirstRealSucc(ptfBrPair.second) == succ);
+  bool isSuccTrueToCommon = (FindFirstRealSucc(stfBrPair.first) == commonBB);
+  if (isPredTrueToCommon && isSuccTrueToCommon) {  // case 1
+    invertSuccCond = false;
+    combinedCondOp = OP_lior;
+  } else if (!isPredTrueToCommon && !isSuccTrueToCommon) {  // case 2
+    invertSuccCond = false;
+    combinedCondOp = OP_land;
+  } else if (isPredTrueToCommon && !isSuccTrueToCommon) {  // case 3
+    invertSuccCond = true;
+    combinedCondOp = OP_lior;
+  } else if (!isPredTrueToCommon && isSuccTrueToCommon) {  // case 4
+    invertSuccCond = true;
+    combinedCondOp = OP_land;
+  } else {
+    CHECK_FATAL(false, "[FUNC: %s] pred and succ have no common dest", f.GetName().c_str());
+  }
+  if (invertSuccCond) {
+    succCond = GetInvertCond(irmap, succCond);
+  }
+  MeExpr *combinedCond = irmap->CreateMeExprBinary(combinedCondOp, PTY_u1, *predCond, *succCond);
+  // try to simplify combinedCond, if failed, not combine condition
+  combinedCond = TryToSimplifyCombinedCond(*combinedCond);
+  if (combinedCond == nullptr) {
+    // work to do : after enhance instruction select, rm this restriction
+    return false;
+  }
+  // eliminate empty bb between pred and succ.
+  EliminateEmptyConnectingBB(pred, isPredTrueToCommon ? ptfBrPair.second : ptfBrPair.first, succ, *cfg);
+  DEBUG_LOG() << "CondBB Group To Merge : \n  {\n"
+              << "    BB" << LOG_BBID(pred) << " succ : (BB" << LOG_BBID(pred->GetSucc(0)) << ", BB"
+              << LOG_BBID(pred->GetSucc(1)) << ")\n"
+              << "    BB" << LOG_BBID(succ) << " succ : (BB" << LOG_BBID(succ->GetSucc(0)) << ", BB"
+              << LOG_BBID(succ->GetSucc(1)) << ")\n  }\n";
+  predCondBr->SetOpnd(0, combinedCond);
+  // remove succ and update cfg
+  BB *exitBB = isSuccTrueToCommon ? stfBrPair.second : stfBrPair.first;
+  pred->ReplaceSucc(succ, exitBB);
+  exitBB->RemovePred(*succ, false);  // not update phi here, because its phi opnd is the same as before.
+  // we should eliminate edge from succ to commonBB
+  BB *toEliminateBB = isSuccTrueToCommon ? stfBrPair.first : stfBrPair.second;
+  EliminateEmptyConnectingBB(succ, toEliminateBB, commonBB /* stop here */, *cfg);
+  succ->RemoveSucc(*commonBB);
+  // Update target label
+  if (predCondBr->GetOffset() != pred->GetSucc(1)->GetBBLabel()) {
+    LabelIdx label = f.GetOrCreateBBLabel(*pred->GetSucc(1));
+    predCondBr->SetOffset(label);
+  }
+  DEBUG_LOG() << "Delete CondBB BB" << LOG_BBID(succ) << " after merged to CondBB BB" << LOG_BBID(pred) << "\n";
+  DeleteBB(succ);
+  SetBBRunAgain();
+  return true;
+}
+
+// pattern is like:
+//       curr(condBB)
+//       /         \
+//      /     succ(condBB)
+//     /     /       \
+//    commonBB       exitBB
+//
+// note: curr->commonBB and succ->commonBB are critical edge, they may be cut by an empty bb before
+bool OptimizeBB::FoldBranchToCommonDest() {
+  CHECK_CURR_BB();
+  if (currBB->GetKind() != kBBCondGoto) {
+    return false;
+  }
+  bool change = false;
+  for (size_t i = 0; i < currBB->GetSucc().size(); ++i) {
+    BB *realSucc = FindFirstRealSucc(currBB->GetSucc(i));
+    if (realSucc == nullptr) {
+      continue;
+    }
+    change |= FoldBranchToCommonDest(currBB, realSucc);
+  }
+  return change;
+}
+
+bool OptimizeBB::OptBBOnce() {
+  CHECK_CURR_BB();
+  DEBUG_LOG() << "Try to optimize BB" << LOG_BBID(currBB) << "...\n";
+  // bb frequency may be updated, make bb frequency and succs frequency consistent
+  // skip deadBB
+  if (cfg->UpdateCFGFreq() && (!currBB->GetPred().empty()) && (currBB->GetUniquePred() != currBB)) {
+    currBB->UpdateEdgeFreqs(false);
+  }
+  bool everChanged = false;
+  // eliminate dead BB :
+  // 1.BB has no pred(expect then entry block)
+  // 2.BB has only itself as pred
+  if (EliminateDeadBB()) {
+    return true;
+  }
+
+  // chang condition branch to unconditon branch if possible
+  // 1.condition is a constant
+  // 2.all branches of condition branch is the same BB
+  everChanged |= OptimizeCondBB2UnCond();
+
+  // disconnect predBB and currBB if predBB must cause error(e.g. null ptr deref)
+  // If a expr is always cause error in predBB, predBB will never reach currBB
+  if (RemoveSuccFromNoReturnBB()) {
+    // all succ will be removed from currBB, no need to run on this BB.
+    return true;
+  }
+
+  // merge currBB to predBB if currBB has only one predBB and predBB has only one succBB
+  everChanged |= MergeDistinctBBPair();
+
+  // Eliminate redundant philist in bb which has only one pred
+  (void)EliminateRedundantPhiList();
+
+  auto optimizer = CreateProductFunction<OptBBFatory>(currBB->GetKind());
+  if (optimizer != nullptr) {
+    everChanged |= optimizer(this);
+  }
+  return everChanged;
+}
+
+void OptimizeBB::InitBBOptFactory() {
+  RegisterFactoryFunction<OptBBFatory>(kBBCondGoto, &OptimizeBB::OptimizeCondBB);
+  RegisterFactoryFunction<OptBBFatory>(kBBGoto, &OptimizeBB::OptimizeUncondBB);
+  RegisterFactoryFunction<OptBBFatory>(kBBFallthru, &OptimizeBB::OptimizeFallthruBB);
+  RegisterFactoryFunction<OptBBFatory>(kBBSwitch, &OptimizeBB::OptimizeSwitchBB);
+}
+
+// run on each BB until no more change for currBB
+bool OptimizeBB::OptBBIteratively() {
+  bool changed = false;
+  do {
+    repeatOpt = false;
+    // optimize currBB only once, if we should reopt on this BB, repeatOpt will be set by optimization
+    changed |= OptBBOnce();
+  } while (repeatOpt);
+  return changed;
+}
+
+// For function Level optimization
+class OptimizeFuntionCFG {
+ public:
+  OptimizeFuntionCFG(maple::MeFunction &func, std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *candidates)
+      : f(func), cands(candidates) {}
+
+  bool OptimizeOnFunc();
+
+ private:
+  MeFunction &f;
+
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *cands = nullptr;  // candidates ost need to update ssa
+  bool OptimizeFuncCFGIteratively();
+  bool OptimizeCFGForBB(BB *currBB);
+};
+
+bool OptimizeFuntionCFG::OptimizeCFGForBB(BB *currBB) {
+  OptimizeBB bbOptimizer(currBB, f, cands);
+  bbOptimizer.InitBBOptFactory();
+  return bbOptimizer.OptBBIteratively();
+}
+// run until no changes happened
+bool OptimizeFuntionCFG::OptimizeFuncCFGIteratively() {
+  bool everChanged = false;
+  bool changed = true;
+  while (changed) {
+    changed = false;
+    // Since we may delete BB during traversal, we cannot use iterator here.
+    auto &bbVec = f.GetCfg()->GetAllBBs();
+    for (size_t idx = 0; idx < bbVec.size(); ++idx) {
+      BB *currBB = bbVec[idx];
+      if (currBB == nullptr) {
+        continue;
+      }
+      changed |= OptimizeCFGForBB(currBB);
+    }
+    everChanged |= changed;
+  }
+  return everChanged;
+}
+
+bool OptimizeFuntionCFG::OptimizeOnFunc() {
+  bool everChanged = UnreachBBAnalysis(f);
+  everChanged |= OptimizeFuncCFGIteratively();
+  if (!everChanged) {
+    return false;
+  }
+  // OptimizeFuncCFGIteratively may generate unreachable BB.
+  // So UnreachBBAnalysis should be called to check for and
+  // remove dead BB. And UnreachBBAnalysis may also generate
+  // other optimize opportunity for OptimizeFuncCFGIteratively.
+  // Hench we should iterate between these two optimizations.
+  // Here, we call UnreachBBAnalysis first to avoid running
+  // OptimizeFuncCFGIteratively for no changed situation.
+  if (!UnreachBBAnalysis(f)) {
+    return true;
+  }
+  do {
+    everChanged = OptimizeFuncCFGIteratively();
+    everChanged |= UnreachBBAnalysis(f);
+  } while (everChanged);
+  return true;
+}
+
+// An Interface to optimizing cfg for func with MeIR (INSTEAD OF MPLIR),
+// so that if irmap is not built, this interface will do nothing.
+// ssaCand, mp, ma are used to collect ost whose version need to be updated for ssa-updater
+bool OptimizeMeFuncCFG(maple::MeFunction &f, std::map<OStIdx, std::unique_ptr<std::set<BBId>>> *ssaCand = nullptr) {
+  funcName = f.GetName();
+  if (SkipOptimizeCFG(f)) {
+    DEBUG_LOG() << "Skip OptimizeBB phase because of igotoBB\n";
+    return false;
+  }
+  DEBUG_LOG() << "Start Optimizing Function : " << f.GetName() << "\n";
+  if (debug) {
+    f.GetCfg()->DumpToFile("Before_" + phaseName);
+  }
+  uint32 bbNumBefore = f.GetCfg()->ValidBBNum();
+  // optimization entry
+  bool change = OptimizeFuntionCFG(f, ssaCand).OptimizeOnFunc();
+  if (change) {
+    f.GetCfg()->WontExitAnalysis();
+    if (debug) {
+      uint32 bbNumAfter = f.GetCfg()->ValidBBNum();
+      if (bbNumBefore != bbNumAfter) {
+        DEBUG_LOG() << "BBs' number " << (bbNumBefore > bbNumAfter ? "reduce" : "increase") << " from " << bbNumBefore
+                    << " to " << bbNumAfter << "\n";
+      } else {
+        DEBUG_LOG() << "BBs' number keep the same as before (num = " << bbNumAfter << ")\n";
+      }
+      f.GetCfg()->DumpToFile("After_" + phaseName);
+      f.Dump(f.GetIRMap() == nullptr);
+    }
+  }
+  return change;
+}
+
+// phase for MPLIR, without SSA info
+void MEOptimizeCFGNoSSA::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEMeCfg>();
+  aDep.SetPreservedAll();
+}
+
+bool MEOptimizeCFGNoSSA::PhaseRun(MeFunction &f) {
+  debug = DEBUGFUNC_NEWPM(f);
+  phaseName = PhaseName();
+  bool change = OptimizeMeFuncCFG(f, nullptr);
+  if (change && f.GetCfg()->DumpIRProfileFile()) {
+    f.GetCfg()->DumpToFile("after-OptimizeCFGNOSSA", false, f.GetCfg()->UpdateCFGFreq());
+  }
+  return change;
+}
+
+// phase for MEIR, should maintain ssa info and split critical edge
+void MEOptimizeCFG::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEDominance>();
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.PreservedAllExcept<MELoopAnalysis>();
+}
+
+bool MEOptimizeCFG::PhaseRun(maple::MeFunction &f) {
+  debug = DEBUGFUNC_NEWPM(f);
+  std::map<OStIdx, std::unique_ptr<std::set<BBId>>> cands((std::less<OStIdx>()));
+  phaseName = PhaseName();
+  // optimization entry
+  bool change = OptimizeMeFuncCFG(f, &cands);
+  if (change) {
+    // split critical edges
+    (void)MeSplitCEdge(debug).SplitCriticalEdgeForMeFunc(f);
+    FORCE_INVALID(MEDominance, f);
+    Dominance *dom = FORCE_EXEC(MEDominance)->GetDomResult();
+    if (!cands.empty()) {
+      MeSSAUpdate ssaUpdate(f, *f.GetMeSSATab(), *dom, cands);
+      ssaUpdate.Run();
+    }
+    if (f.GetCfg()->DumpIRProfileFile()) {
+      f.GetCfg()->DumpToFile("after-OptimizeCFG", false, f.GetCfg()->UpdateCFGFreq());
+    }
+  }
+  return change;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/orig_symbol.cpp b/src/mapleall/maple_me/src/orig_symbol.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dbe8669cc669e4e6e42d9c1d5357735b4f354d06
--- /dev/null
+++ b/src/mapleall/maple_me/src/orig_symbol.cpp
@@ -0,0 +1,374 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "orig_symbol.h"
+#include "ver_symbol.h"
+#include "class_hierarchy.h"
+
+namespace maple {
+bool OriginalSt::Equal(const OriginalSt &ost) const {
+  if (IsSymbolOst()) {
+    return symOrPreg.mirSt == ost.symOrPreg.mirSt &&
+           fieldID == ost.GetFieldID() &&
+           GetIndirectLev() == ost.GetIndirectLev();
+  }
+  if (IsPregOst()) {
+    return symOrPreg.pregIdx == ost.symOrPreg.pregIdx && GetIndirectLev() == ost.GetIndirectLev();
+  }
+  return false;
+}
+
+// current ost can not be define by MayDef, or used by mayUse
+bool OriginalSt::IsTopLevelOst() const {
+  // 1. pregs, exclude special-pregs, are top-level.
+  if (IsPregOst()) {
+    if (IsSpecialPreg()) {
+      return false;
+    }
+    return true;
+  }
+  // 2. address taken symbols, may be defined via dereference, are not top-level.
+  if (addressTaken) {
+    return false;
+  }
+  // 3. global symbols, can be defined by callees, are not top-level.
+  if (!isLocal) {
+    return false;
+  }
+  // 4. local static symbols, can be defined by recursive callees, are not top-level.
+  if (GetMIRSymbol()->IsPUStatic()) {
+    return false;
+  }
+  return true;
+}
+
+void OriginalSt::SetPointerVst(const VersionSt *vst) {
+  ASSERT(pointerVstIdx == 0 || pointerVstIdx == vst->GetIndex(), "wrong pointee");
+  pointerVstIdx = vst->GetIndex();
+  prevLevOst = vst->GetOst();
+  SetPointerTyIdx(vst->GetOst()->GetTyIdx());
+}
+
+void OriginalSt::Dump() const {
+  if (indirectLev > 0) {
+    GetPrevLevelOst()->Dump();
+    LogInfo::MapleLogger() << "(vstIdx:" << pointerVstIdx << ")";
+    LogInfo::MapleLogger() << "->" << "{" << fieldID << "/" << offset.val << "}" << "[idx:" << GetIndex() <<"]";
+    if (IsFinal()) {
+      LogInfo::MapleLogger() << "F";
+    }
+    if (IsPrivate()) {
+      LogInfo::MapleLogger() << "P";
+    }
+    return;
+  }
+
+  if (IsSymbolOst()) {
+    LogInfo::MapleLogger() << (symOrPreg.mirSt->IsGlobal() ? "$" : "%") << symOrPreg.mirSt->GetName();
+    LogInfo::MapleLogger() << "{" << "offset:" << (offset.IsInvalid() ? "UND" : std::to_string(offset.val)) << "}";
+    if (fieldID != 0) {
+      LogInfo::MapleLogger() << "{" << fieldID << "}";
+    }
+    LogInfo::MapleLogger() << "<" << static_cast<int32>(GetIndirectLev()) << ">";
+    if (IsFinal()) {
+      LogInfo::MapleLogger() << "F";
+    }
+    if (IsPrivate()) {
+      LogInfo::MapleLogger() << "P";
+    }
+  } else if (IsPregOst()) {
+    LogInfo::MapleLogger() << "%" << GetMIRPreg()->GetPregNo();
+    LogInfo::MapleLogger() << "<" << static_cast<int32>(indirectLev) << ">";
+  }
+  LogInfo::MapleLogger() << "[idx:" << GetIndex() <<"]";
+}
+
+OriginalStTable::OriginalStTable(MemPool &memPool, MIRModule &mod)
+    : alloc(&memPool),
+      mirModule(mod),
+      originalStVector({ nullptr }, alloc.Adapter()),
+      mirSt2Ost(alloc.Adapter()),
+      addrofSt2Ost(alloc.Adapter()),
+      preg2Ost(alloc.Adapter()),
+      pType2Ost(std::less<TyIdx>(), alloc.Adapter()),
+      malloc2Ost(alloc.Adapter()),
+      thisField2Ost(std::less<uint32>(), alloc.Adapter()),
+      nextLevelOstsOfVst(alloc.Adapter()) {}
+
+void OriginalStTable::Dump() {
+  mirModule.GetOut() << "==========original st table===========\n";
+  for (size_t i = 1; i < Size(); ++i) {
+    const OriginalSt *oriSt = GetOriginalStFromID(OStIdx(i));
+    if (oriSt == nullptr) {
+      continue;
+    }
+    oriSt->Dump();
+  }
+  mirModule.GetOut() << "\n=======end original st table===========\n";
+}
+
+OriginalSt *OriginalStTable::FindOrCreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld) {
+  OffsetType offset(mirSt.GetType()->GetBitOffsetFromBaseAddr(fld));
+  auto ostType = mirSt.GetType();
+  if (fld != 0) {
+    CHECK_FATAL(ostType->IsStructType(), "must be structure type");
+    ostType = static_cast<MIRStructType*>(ostType)->GetFieldType(fld);
+  }
+  auto it = mirSt2Ost.find(SymbolFieldPair(mirSt.GetStIdx(), fld, ostType->GetTypeIndex(), offset));
+  if (it == mirSt2Ost.end()) {
+    // create a new OriginalSt
+    return CreateSymbolOriginalSt(mirSt, puIdx, fld);
+  }
+  CHECK_FATAL(it->second < originalStVector.size(),
+              "index out of range in OriginalStTable::FindOrCreateSymbolOriginalSt");
+  return originalStVector[it->second];
+}
+
+OriginalSt *OriginalStTable::CreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld, const TyIdx &tyIdx,
+                                                    const OffsetType &offset) {
+  auto *ost = alloc.GetMemPool()->New<OriginalSt>(originalStVector.size(), mirSt, puIdx, fld, alloc);
+  ost->SetOffset(offset);
+  ost->SetIsFinal(mirSt.IsFinal());
+  ost->SetIsPrivate(mirSt.IsPrivate());
+  ost->SetTyIdx(tyIdx);
+  originalStVector.push_back(ost);
+  mirSt2Ost[SymbolFieldPair(mirSt.GetStIdx(), fld, tyIdx, offset)] = ost->GetIndex();
+  return ost;
+}
+
+std::pair<OriginalSt*, bool> OriginalStTable::FindOrCreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx,
+                                                                           FieldID fld, const TyIdx &tyIdx,
+                                                                           const OffsetType &offset) {
+  auto it = mirSt2Ost.find(SymbolFieldPair(mirSt.GetStIdx(), fld, tyIdx, offset));
+  if (it == mirSt2Ost.end()) {
+    // create a new OriginalSt
+    auto *newOst = CreateSymbolOriginalSt(mirSt, puIdx, fld, tyIdx, offset);
+    return std::make_pair(newOst, true);
+  }
+  CHECK_FATAL(it->second < originalStVector.size(),
+              "index out of range in OriginalStTable::FindOrCreateSymbolOriginalSt");
+  return std::make_pair(originalStVector[it->second], false);
+}
+
+OriginalSt *OriginalStTable::FindOrCreatePregOriginalSt(PregIdx pregIdx, PUIdx puIdx) {
+  auto it = preg2Ost.find(pregIdx);
+  return (it == preg2Ost.end()) ? CreatePregOriginalSt(pregIdx, puIdx)
+                                : originalStVector.at(it->second);
+}
+
+OriginalSt *OriginalStTable::CreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx pidx, FieldID fld) {
+  auto *ost = alloc.GetMemPool()->New<OriginalSt>(originalStVector.size(), mirSt, pidx, fld, alloc);
+  if (fld == 0) {
+    ost->SetTyIdx(mirSt.GetTyIdx());
+    ost->SetIsFinal(mirSt.IsFinal());
+    ost->SetIsPrivate(mirSt.IsPrivate());
+  } else {
+    auto *structType = static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirSt.GetTyIdx()));
+    ASSERT(structType, "CreateSymbolOriginalSt: non-zero fieldID for non-structure");
+    ost->SetTyIdx(structType->GetFieldTyIdx(fld));
+    FieldAttrs fattrs = structType->GetFieldAttrs(fld);
+    ost->SetIsFinal(fattrs.GetAttr(FLDATTR_final) && !mirModule.CurFunction()->IsConstructor());
+    ost->SetIsPrivate(fattrs.GetAttr(FLDATTR_private));
+  }
+  OffsetType offset(mirSt.GetType()->GetBitOffsetFromBaseAddr(fld));
+  ost->SetOffset(offset);
+  originalStVector.push_back(ost);
+  mirSt2Ost[SymbolFieldPair(mirSt.GetStIdx(), fld, ost->GetTyIdx(), offset)] = ost->GetIndex();
+  return ost;
+}
+
+OriginalSt *OriginalStTable::CreatePregOriginalSt(PregIdx pregIdx, PUIdx puIdx) {
+  auto *ost = alloc.GetMemPool()->New<OriginalSt>(originalStVector.size(), pregIdx, puIdx, alloc);
+  if (pregIdx < 0) {
+    ost->SetTyIdx(TyIdx(PTY_unknown));
+  } else {
+    ost->SetTyIdx(GlobalTables::GetTypeTable().GetPrimType(ost->GetMIRPreg()->GetPrimType())->GetTypeIndex());
+  }
+  originalStVector.push_back(ost);
+  preg2Ost[pregIdx] = ost->GetIndex();
+  return ost;
+}
+
+OriginalSt *OriginalStTable::FindSymbolOriginalSt(const MIRSymbol &mirSt, FieldID fld, const TyIdx &tyIdx,
+                                                  const OffsetType &offset) {
+  const auto it = mirSt2Ost.find(SymbolFieldPair(mirSt.GetStIdx(), fld, tyIdx, offset));
+  if (it == mirSt2Ost.end()) {
+    return nullptr;
+  }
+  return GetOriginalStFromID(it->second);
+}
+
+OriginalSt *OriginalStTable::FindSymbolOriginalSt(const MIRSymbol &mirSt) {
+  return FindSymbolOriginalSt(mirSt, 0, mirSt.GetTyIdx(), OffsetType(0));
+}
+
+OriginalSt *OriginalStTable::FindOrCreateAddrofSymbolOriginalSt(OriginalSt *ost) {
+  if (ost->GetPrevLevelOst() != nullptr) {
+    return ost->GetPrevLevelOst();
+  }
+  OriginalSt *prevLevelOst = nullptr;
+  auto it = addrofSt2Ost.find(ost->GetMIRSymbol()->GetStIdx());
+  if (it != addrofSt2Ost.end()) {
+    prevLevelOst = originalStVector[it->second];
+  } else {
+    // create a new node
+    prevLevelOst = alloc.GetMemPool()->New<OriginalSt>(
+        originalStVector.size(), *ost->GetMIRSymbol(), ost->GetPuIdx(), 0, alloc);
+    originalStVector.push_back(prevLevelOst);
+    prevLevelOst->SetIndirectLev(-1);
+    MIRPtrType pointType(ost->GetMIRSymbol()->GetTyIdx(), PTY_ptr);
+
+    TyIdx newTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&pointType);
+    prevLevelOst->SetTyIdx(newTyIdx);
+    prevLevelOst->SetFieldID(0);
+    addrofSt2Ost[ost->GetMIRSymbol()->GetStIdx()] = prevLevelOst->GetIndex();
+  }
+  return prevLevelOst;
+}
+
+OriginalSt *OriginalStTable::FindOrCreateExtraLevSymOrRegOriginalSt(const VersionSt *vst, TyIdx tyIdx,
+    FieldID fld, const OffsetType &offset, const KlassHierarchy *klassHierarchy) {
+  MIRType *typeOfExtraLevOst = GlobalTables::GetTypeTable().GetVoid();
+  auto ost = vst->GetOst();
+  tyIdx = (tyIdx == 0u) ? ost->GetTyIdx() : tyIdx;
+  if (tyIdx != 0u) {
+    // use the tyIdx info from the instruction
+    const MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    if (mirType->GetKind() == kTypePointer) {
+      const auto *ptType = static_cast<const MIRPtrType*>(mirType);
+      auto *pointedType = ptType->GetPointedType();
+      if (fld == 0) {
+        typeOfExtraLevOst = pointedType;
+      } else if (static_cast<uint32>(fld) <= pointedType->NumberOfFieldIDs()) {
+        CHECK_FATAL(pointedType->IsStructType(), "must be struct type");
+        typeOfExtraLevOst = static_cast<MIRStructType*>(pointedType)->GetFieldType(fld);
+      }
+    }
+  }
+
+  TyIdx ptyIdxOfOst = ost->GetTyIdx();
+  FieldID fldIDInOst = fld;
+  if (ptyIdxOfOst != tyIdx) {
+    if (klassHierarchy != nullptr) {
+      (void)klassHierarchy->UpdateFieldID(tyIdx, ptyIdxOfOst, fldIDInOst);
+    }
+  }
+  OriginalSt *nextLevOst =
+      FindExtraLevOriginalSt(vst, tyIdx, typeOfExtraLevOst, fldIDInOst, offset);
+  if (nextLevOst != nullptr) {
+    return nextLevOst;
+  }
+
+  // create a new node
+  if (ost->IsSymbolOst()) {
+    nextLevOst = alloc.GetMemPool()->New<OriginalSt>(originalStVector.size(), *ost->GetMIRSymbol(),
+        ost->GetPuIdx(), fldIDInOst, alloc);
+  } else {
+    nextLevOst = alloc.GetMemPool()->New<OriginalSt>(originalStVector.size(), ost->GetPregIdx(),
+        ost->GetPuIdx(), alloc);
+    nextLevOst->SetFieldID(fldIDInOst);
+  }
+  originalStVector.push_back(nextLevOst);
+  CHECK_FATAL(ost->GetIndirectLev() < INT8_MAX, "boundary check");
+  nextLevOst->SetIndirectLev(ost->GetIndirectLev() + 1);
+  nextLevOst->SetPointerVst(vst);
+  nextLevOst->SetOffset(offset);
+  nextLevOst->SetPointerTyIdx(tyIdx);
+  nextLevOst->SetAddressTaken(true);
+  tyIdx = (tyIdx == 0u) ? ost->GetTyIdx() : tyIdx;
+  if (tyIdx != 0u) {
+    // use the tyIdx info from the instruction
+    const MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    if (mirType->GetKind() == kTypePointer) {
+      const auto *ptType = static_cast<const MIRPtrType*>(mirType);
+      TyIdxFieldAttrPair fieldPair = ptType->GetPointedTyIdxFldAttrPairWithFieldID(fld);
+      nextLevOst->SetIsFinal(fieldPair.second.GetAttr(FLDATTR_final));
+      nextLevOst->SetIsPrivate(fieldPair.second.GetAttr(FLDATTR_private));
+    }
+    nextLevOst->SetTyIdx(typeOfExtraLevOst->GetTypeIndex());
+  }
+  ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check");
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx())->PointsToConstString()) {
+    nextLevOst->SetIsFinal(true);
+  }
+  AddNextLevelOstOfVst(vst, nextLevOst);
+  return nextLevOst;
+}
+
+OriginalSt *OriginalStTable::FindOrCreateExtraLevOriginalSt(const VersionSt *vst, const TyIdx &ptyIdx, FieldID fld,
+                                                            const OffsetType &offset) {
+  if (vst->GetOst()->IsSymbolOst() || vst->GetOst()->IsPregOst()) {
+    return FindOrCreateExtraLevSymOrRegOriginalSt(vst, ptyIdx, fld, offset);
+  }
+  return nullptr;
+}
+
+OriginalSt *OriginalStTable::FindExtraLevOriginalSt(const MapleVector<OriginalSt*> &nextLevelOsts,
+                                                    const TyIdx &tyIdxOfPtr, const MIRType *type,
+                                                    FieldID fld, const OffsetType &offset) const {
+  for (OriginalSt *nextLevelOst : nextLevelOsts) {
+    if (tyIdxOfPtr != nextLevelOst->GetPointerTyIdx()) {
+      continue;
+    }
+    if (nextLevelOst->GetType() != type) {
+      continue;
+    }
+    if (nextLevelOst->GetOffset() != offset) {
+      continue;
+    }
+    if (nextLevelOst->GetFieldID() == fld || fld == 0) {
+      return nextLevelOst;
+    }
+  }
+  return nullptr;
+}
+
+void OriginalStTable::AddNextLevelOstOfVst(size_t vstIdx, OriginalSt *ost) {
+  if (vstIdx >= nextLevelOstsOfVst.size()) {
+    size_t bufferSize = 10;
+    size_t incNum = vstIdx - nextLevelOstsOfVst.size() + bufferSize;
+    (void)nextLevelOstsOfVst.insert(nextLevelOstsOfVst.cend(), incNum, nullptr);
+  }
+  if (nextLevelOstsOfVst[vstIdx] == nullptr) {
+    nextLevelOstsOfVst[vstIdx] = alloc.New<MapleVector<OriginalSt*>>(alloc.Adapter());
+  }
+  nextLevelOstsOfVst[vstIdx]->push_back(ost);
+}
+
+void OriginalStTable::AddNextLevelOstOfVst(const VersionSt *vst, OriginalSt *ost) {
+  AddNextLevelOstOfVst(vst->GetIndex(), ost);
+}
+
+MapleVector<OriginalSt*> *OriginalStTable::GetNextLevelOstsOfVst(size_t vstIdx) const {
+  if (vstIdx >= nextLevelOstsOfVst.size()) {
+    return nullptr;
+  }
+  return nextLevelOstsOfVst[vstIdx];
+}
+
+MapleVector<OriginalSt*> *OriginalStTable::GetNextLevelOstsOfVst(const VersionSt *vst) const {
+  return GetNextLevelOstsOfVst(vst->GetIndex());
+}
+
+OriginalSt *OriginalStTable::FindExtraLevOriginalSt(const VersionSt *vst, const TyIdx &tyIdxOfPtr,
+                                                    const MIRType *typeOfOst, FieldID fld,
+                                                    const OffsetType &offset) const {
+  auto *nextLevelOsts = GetNextLevelOstsOfVst(vst);
+  if (nextLevelOsts == nullptr) {
+    return nullptr;
+  }
+
+  return FindExtraLevOriginalSt(*nextLevelOsts, tyIdxOfPtr, typeOfOst, fld, offset);
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/pme_emit.cpp b/src/mapleall/maple_me/src/pme_emit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5a9fa5e4c4df2f3144703bf4552c267b16146bbc
--- /dev/null
+++ b/src/mapleall/maple_me/src/pme_emit.cpp
@@ -0,0 +1,1167 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "pme_emit.h"
+#include "me_irmap.h"
+#include "pme_function.h"
+#include "mir_lower.h"
+#include "constantfold.h"
+#include "inline_summary.h"
+#include "ipa_phase_manager.h"
+
+namespace maple {
+// convert x to use OP_array if possible; return nullptr if unsuccessful;
+// ptrTyIdx is the high level pointer type of x
+ArrayNode *PreMeEmitter::ConvertToArray(BaseNode *x, TyIdx ptrTyIdx) {
+  if (x->GetOpCode() != OP_add) {
+    return nullptr;
+  }
+  MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTyIdx);
+  if (mirType->GetKind() != kTypePointer) {
+    return nullptr;
+  }
+  BaseNode *opnd0 = x->Opnd(0);
+  ASSERT_NOT_NULL(GetMexpr(opnd0));
+  if (!GetMexpr(opnd0)->HasAddressValue()) {
+    return nullptr;
+  }
+  BaseNode *opnd1 = x->Opnd(1);
+  MIRType *elemType = static_cast<MIRPtrType *>(mirType)->GetPointedType();
+  size_t elemSize = elemType->GetSize();
+  BaseNode *indexOpnd = opnd1;
+  if (elemSize > 1) {
+    if (opnd1->GetOpCode() != OP_mul) {
+      return nullptr;
+    }
+    BaseNode *mulopnd1 = opnd1->Opnd(1);
+    if (mulopnd1->GetOpCode() != OP_constval) {
+      return nullptr;
+    }
+    MIRConst *constVal = static_cast<ConstvalNode *>(mulopnd1)->GetConstVal();
+    if (constVal->GetKind() != kConstInt) {
+      return nullptr;
+    }
+    if (static_cast<MIRIntConst *>(constVal)->GetValue() != static_cast<int64>(elemSize)) {
+      return nullptr;
+    }
+    indexOpnd = opnd1->Opnd(0);
+  }
+  if (indexOpnd->GetOpCode() == OP_cvt) {
+    if (IsPrimitiveInteger(static_cast<TypeCvtNode *>(indexOpnd)->FromType())) {
+      indexOpnd = indexOpnd->Opnd(0);
+    }
+  }
+  // form the pointer to array type
+  MIRArrayType *arryType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*elemType, 0);
+  MIRType *ptArryType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*arryType);
+  ArrayNode *arryNode = codeMP->New<ArrayNode>(*codeMPAlloc, x->GetPrimType(), ptArryType->GetTypeIndex());
+  arryNode->SetBoundsCheck(false);
+  arryNode->GetNopnd().push_back(opnd0);
+  arryNode->GetNopnd().push_back(indexOpnd);
+  // The number of operands of arryNode is set to 2
+  arryNode->SetNumOpnds(2);
+  preMeExprExtensionMap[arryNode] = preMeExprExtensionMap[x];
+  // update opnds' parent info if it has
+  if (preMeExprExtensionMap[opnd0]) {
+    preMeExprExtensionMap[opnd0]->SetParent(arryNode);
+  }
+  if (preMeExprExtensionMap[indexOpnd]) {
+    preMeExprExtensionMap[indexOpnd]->SetParent(arryNode);
+  }
+  return arryNode;
+}
+
+BaseNode *PreMeEmitter::EmitPreMeExpr(MeExpr *meExpr, BaseNode *parent) {
+  PreMeMIRExtension *pmeExt = preMeMP->New<PreMeMIRExtension>(parent, meExpr);
+  switch (meExpr->GetOp()) {
+    case OP_constval: {
+      MIRConst *constval = static_cast<ConstMeExpr *>(meExpr)->GetConstVal();
+      ConstvalNode *lcvlNode = codeMP->New<ConstvalNode>(constval->GetType().GetPrimType(), constval);
+      preMeExprExtensionMap[lcvlNode] = pmeExt;
+      return lcvlNode;
+    }
+    case OP_dread: {
+      VarMeExpr *varmeexpr = static_cast<VarMeExpr *>(meExpr);
+      MIRSymbol *sym = varmeexpr->GetOst()->GetMIRSymbol();
+      if (sym->IsLocal()) {
+        sym->ResetIsDeleted();
+      }
+      AddrofNode *dreadnode = codeMP->New<AddrofNode>(OP_dread, GetRegPrimType(varmeexpr->GetPrimType()),
+                                                      sym->GetStIdx(), varmeexpr->GetOst()->GetFieldID());
+      preMeExprExtensionMap[dreadnode] = pmeExt;
+      return dreadnode;
+    }
+    case OP_eq:
+    case OP_ne:
+    case OP_ge:
+    case OP_gt:
+    case OP_le:
+    case OP_cmp:
+    case OP_cmpl:
+    case OP_cmpg:
+    case OP_lt: {
+      OpMeExpr *cmpexpr = static_cast<OpMeExpr *>(meExpr);
+      CompareNode *cmpNode =
+          codeMP->New<CompareNode>(meExpr->GetOp(), cmpexpr->GetPrimType(), cmpexpr->GetOpndType(), nullptr, nullptr);
+      BaseNode *opnd0 = EmitPreMeExpr(cmpexpr->GetOpnd(0), cmpNode);
+      BaseNode *opnd1 = EmitPreMeExpr(cmpexpr->GetOpnd(1), cmpNode);
+      cmpNode->SetBOpnd(opnd0, 0);
+      cmpNode->SetBOpnd(opnd1, 1);
+      cmpNode->SetOpndType(cmpNode->GetOpndType());
+      preMeExprExtensionMap[cmpNode] = pmeExt;
+      return cmpNode;
+    }
+    case OP_array: {
+      NaryMeExpr *arrExpr = static_cast<NaryMeExpr *>(meExpr);
+      ArrayNode *arrNode =
+        codeMP->New<ArrayNode>(*codeMPAlloc, arrExpr->GetPrimType(), arrExpr->GetTyIdx());
+      arrNode->SetBoundsCheck(arrExpr->GetBoundCheck());
+      for (uint32 i = 0; i < arrExpr->GetNumOpnds(); i++) {
+        BaseNode *opnd = EmitPreMeExpr(arrExpr->GetOpnd(i), arrNode);
+        arrNode->GetNopnd().push_back(opnd);
+      }
+      arrNode->SetNumOpnds(meExpr->GetNumOpnds());
+      preMeExprExtensionMap[arrNode] = pmeExt;
+      return arrNode;
+    }
+    case OP_ashr:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_cand:
+    case OP_cior:
+    case OP_div:
+    case OP_land:
+    case OP_lior:
+    case OP_lshr:
+    case OP_max:
+    case OP_min:
+    case OP_mul:
+    case OP_rem:
+    case OP_shl:
+    case OP_sub:
+    case OP_add: {
+      OpMeExpr *opExpr = static_cast<OpMeExpr *>(meExpr);
+      BinaryNode *binNode = codeMP->New<BinaryNode>(meExpr->GetOp(), meExpr->GetPrimType());
+      binNode->SetBOpnd(EmitPreMeExpr(opExpr->GetOpnd(0), binNode), 0);
+      binNode->SetBOpnd(EmitPreMeExpr(opExpr->GetOpnd(1), binNode), 1);
+      preMeExprExtensionMap[binNode] = pmeExt;
+      return binNode;
+    }
+    case OP_iread: {
+      IvarMeExpr *ivarExpr = static_cast<IvarMeExpr *>(meExpr);
+      IreadNode *irdNode = codeMP->New<IreadNode>(meExpr->GetOp(), meExpr->GetPrimType());
+      ASSERT(ivarExpr->GetOffset() == 0, "offset in iread should be 0");
+      irdNode->SetOpnd(EmitPreMeExpr(ivarExpr->GetBase(), irdNode), 0);
+      irdNode->SetTyIdx(ivarExpr->GetTyIdx());
+      irdNode->SetFieldID(ivarExpr->GetFieldID());
+      preMeExprExtensionMap[irdNode] = pmeExt;
+      if (irdNode->Opnd(0)->GetOpCode() != OP_array) {
+        ArrayNode *arryNode = ConvertToArray(irdNode->Opnd(0), irdNode->GetTyIdx());
+        if (arryNode != nullptr) {
+          irdNode->SetOpnd(arryNode, 0);
+        }
+      }
+      return irdNode;
+    }
+    case OP_ireadoff: {
+      IvarMeExpr *ivarExpr = static_cast<IvarMeExpr *>(meExpr);
+      IreadNode *irdNode = codeMP->New<IreadNode>(OP_iread, meExpr->GetPrimType());
+      MeExpr *baseexpr = ivarExpr->GetBase();
+      if (ivarExpr->GetOffset() == 0) {
+        irdNode->SetOpnd(EmitPreMeExpr(baseexpr, irdNode), 0);
+      } else {
+        MIRType *mirType = GlobalTables::GetTypeTable().GetInt32();
+        MIRIntConst *mirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+            static_cast<uint64>(static_cast<uint32>(ivarExpr->GetOffset())), *mirType);
+        ConstvalNode *constValNode = codeMP->New<ConstvalNode>(mirType->GetPrimType(), mirConst);
+        PreMeMIRExtension *pmeExt2 = preMeMP->New<PreMeMIRExtension>(irdNode, baseexpr);
+        preMeExprExtensionMap[constValNode] = pmeExt2;
+        BinaryNode *newAddrNode =
+            codeMP->New<BinaryNode>(OP_add, baseexpr->GetPrimType(), EmitPreMeExpr(baseexpr, irdNode), constValNode);
+        preMeExprExtensionMap[newAddrNode] = pmeExt2;
+        irdNode->SetOpnd(newAddrNode, 0);
+      }
+      irdNode->SetTyIdx(ivarExpr->GetTyIdx());
+      irdNode->SetFieldID(ivarExpr->GetFieldID());
+      preMeExprExtensionMap[irdNode] = pmeExt;
+      return irdNode;
+    }
+    case OP_addrof: {
+      AddrofMeExpr *addrMeexpr = static_cast<AddrofMeExpr *>(meExpr);
+      OriginalSt *ost = addrMeexpr->GetOst();
+      MIRSymbol *sym = ost->GetMIRSymbol();
+      AddrofNode *addrofNode =
+          codeMP->New<AddrofNode>(OP_addrof, addrMeexpr->GetPrimType(), sym->GetStIdx(), ost->GetFieldID());
+      preMeExprExtensionMap[addrofNode] = pmeExt;
+      return addrofNode;
+    }
+    case OP_addroflabel: {
+      AddroflabelMeExpr *addroflabelexpr = static_cast<AddroflabelMeExpr *>(meExpr);
+      AddroflabelNode *addroflabel = codeMP->New<AddroflabelNode>(addroflabelexpr->labelIdx);
+      addroflabel->SetPrimType(meExpr->GetPrimType());
+      preMeExprExtensionMap[addroflabel] = pmeExt;
+      return addroflabel;
+    }
+    case OP_addroffunc: {
+      AddroffuncMeExpr *addrMeexpr = static_cast<AddroffuncMeExpr *>(meExpr);
+      AddroffuncNode *addrfunNode = codeMP->New<AddroffuncNode>(addrMeexpr->GetPrimType(), addrMeexpr->GetPuIdx());
+      preMeExprExtensionMap[addrfunNode] = pmeExt;
+      return addrfunNode;
+    }
+    case OP_gcmalloc:
+    case OP_gcpermalloc:
+    case OP_stackmalloc: {
+      GcmallocMeExpr *gcMeexpr = static_cast<GcmallocMeExpr *>(meExpr);
+      GCMallocNode *gcMnode =
+          codeMP->New<GCMallocNode>(meExpr->GetOp(), meExpr->GetPrimType(), gcMeexpr->GetTyIdx());
+      gcMnode->SetTyIdx(gcMeexpr->GetTyIdx());
+      preMeExprExtensionMap[gcMnode] = pmeExt;
+      return gcMnode;
+    }
+    case OP_retype: {
+      OpMeExpr *opMeexpr = static_cast<OpMeExpr *>(meExpr);
+      RetypeNode *retypeNode = codeMP->New<RetypeNode>(meExpr->GetPrimType());
+      retypeNode->SetFromType(opMeexpr->GetOpndType());
+      retypeNode->SetTyIdx(opMeexpr->GetTyIdx());
+      retypeNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(0), retypeNode), 0);
+      preMeExprExtensionMap[retypeNode] = pmeExt;
+      return retypeNode;
+    }
+    case OP_ceil:
+    case OP_cvt:
+    case OP_floor:
+    case OP_trunc: {
+      OpMeExpr *opMeexpr = static_cast<OpMeExpr *>(meExpr);
+      TypeCvtNode *tycvtNode = codeMP->New<TypeCvtNode>(meExpr->GetOp(), meExpr->GetPrimType());
+      tycvtNode->SetFromType(opMeexpr->GetOpndType());
+      tycvtNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(0), tycvtNode), 0);
+      preMeExprExtensionMap[tycvtNode] = pmeExt;
+      return tycvtNode;
+    }
+    case OP_sext:
+    case OP_zext:
+    case OP_extractbits: {
+      OpMeExpr *opMeexpr = static_cast<OpMeExpr *>(meExpr);
+      ExtractbitsNode *extNode = codeMP->New<ExtractbitsNode>(meExpr->GetOp(), meExpr->GetPrimType());
+      extNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(0), extNode), 0);
+      extNode->SetBitsOffset(opMeexpr->GetBitsOffSet());
+      extNode->SetBitsSize(opMeexpr->GetBitsSize());
+      preMeExprExtensionMap[extNode] = pmeExt;
+      return extNode;
+    }
+    case OP_depositbits: {
+      OpMeExpr *opMeexpr = static_cast<OpMeExpr *>(meExpr);
+      DepositbitsNode *depNode = codeMP->New<DepositbitsNode>(meExpr->GetOp(), meExpr->GetPrimType());
+      depNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(0), depNode), 0);
+      depNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(1), depNode), 1);
+      depNode->SetBitsOffset(opMeexpr->GetBitsOffSet());
+      depNode->SetBitsSize(opMeexpr->GetBitsSize());
+      preMeExprExtensionMap[depNode] = pmeExt;
+      return depNode;
+    }
+    case OP_regread: {
+      RegMeExpr *regMeexpr = static_cast<RegMeExpr *>(meExpr);
+      RegreadNode *regNode = codeMP->New<RegreadNode>();
+      regNode->SetPrimType(regMeexpr->GetPrimType());
+      regNode->SetRegIdx(regMeexpr->GetRegIdx());
+      preMeExprExtensionMap[regNode] = pmeExt;
+      return regNode;
+    }
+    case OP_sizeoftype: {
+      SizeoftypeMeExpr *sizeofMeexpr = static_cast<SizeoftypeMeExpr *>(meExpr);
+      SizeoftypeNode *sizeofTynode =
+          codeMP->New<SizeoftypeNode>(sizeofMeexpr->GetPrimType(), sizeofMeexpr->GetTyIdx());
+      preMeExprExtensionMap[sizeofTynode] = pmeExt;
+      return sizeofTynode;
+    }
+    case OP_fieldsdist: {
+      FieldsDistMeExpr *fdMeexpr = static_cast<FieldsDistMeExpr *>(meExpr);
+      FieldsDistNode *fieldsNode =
+          codeMP->New<FieldsDistNode>(fdMeexpr->GetPrimType(), fdMeexpr->GetTyIdx(), fdMeexpr->GetFieldID1(),
+                                      fdMeexpr->GetFieldID2());
+      preMeExprExtensionMap[fieldsNode] = pmeExt;
+      return fieldsNode;
+    }
+    case OP_conststr: {
+      ConststrMeExpr *constrMeexpr = static_cast<ConststrMeExpr *>(meExpr);
+      ConststrNode *constrNode =
+          codeMP->New<ConststrNode>(constrMeexpr->GetPrimType(), constrMeexpr->GetStrIdx());
+      preMeExprExtensionMap[constrNode] = pmeExt;
+      return constrNode;
+    }
+    case OP_conststr16: {
+      Conststr16MeExpr *constr16Meexpr = static_cast<Conststr16MeExpr *>(meExpr);
+      Conststr16Node *constr16Node =
+          codeMP->New<Conststr16Node>(constr16Meexpr->GetPrimType(), constr16Meexpr->GetStrIdx());
+      preMeExprExtensionMap[constr16Node] = pmeExt;
+      return constr16Node;
+    }
+    case OP_abs:
+    case OP_bnot:
+    case OP_lnot:
+    case OP_neg:
+    case OP_recip:
+    case OP_sqrt:
+    case OP_alloca:
+    case OP_malloc: {
+      OpMeExpr *opMeexpr = static_cast<OpMeExpr *>(meExpr);
+      UnaryNode *unNode = codeMP->New<UnaryNode>(meExpr->GetOp(), meExpr->GetPrimType());
+      unNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(0), unNode), 0);
+      preMeExprExtensionMap[unNode] = pmeExt;
+      return unNode;
+    }
+    case OP_iaddrof: {
+      OpMeExpr *opMeexpr = static_cast<OpMeExpr *>(meExpr);
+      IreadNode *ireadNode = codeMP->New<IreadNode>(meExpr->GetOp(), meExpr->GetPrimType());
+      ireadNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(0), ireadNode), 0);
+      ireadNode->SetTyIdx(opMeexpr->GetTyIdx());
+      ireadNode->SetFieldID(opMeexpr->GetFieldID());
+      preMeExprExtensionMap[ireadNode] = pmeExt;
+      return ireadNode;
+    }
+    case OP_select: {
+      OpMeExpr *opMeexpr = static_cast<OpMeExpr *>(meExpr);
+      TernaryNode *tNode = codeMP->New<TernaryNode>(OP_select, meExpr->GetPrimType());
+      tNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(0), tNode), 0);
+      tNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(1), tNode), 1);
+      tNode->SetOpnd(EmitPreMeExpr(opMeexpr->GetOpnd(2), tNode), 2);
+      preMeExprExtensionMap[tNode] = pmeExt;
+      return tNode;
+    }
+    case OP_intrinsicop:
+    case OP_intrinsicopwithtype: {
+      NaryMeExpr *nMeexpr = static_cast<NaryMeExpr *>(meExpr);
+      IntrinsicopNode *intrnNode =
+          codeMP->New<IntrinsicopNode>(*codeMPAlloc, meExpr->GetOp(), meExpr->GetPrimType(), nMeexpr->GetTyIdx());
+      intrnNode->SetIntrinsic(nMeexpr->GetIntrinsic());
+      for (uint32 i = 0; i < nMeexpr->GetNumOpnds(); i++) {
+        BaseNode *opnd = EmitPreMeExpr(nMeexpr->GetOpnd(i), intrnNode);
+        intrnNode->GetNopnd().push_back(opnd);
+      }
+      intrnNode->SetNumOpnds(nMeexpr->GetNumOpnds());
+      preMeExprExtensionMap[intrnNode] = pmeExt;
+      return intrnNode;
+    }
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+}
+
+StmtNode* PreMeEmitter::EmitPreMeStmt(MeStmt *meStmt, BaseNode *parent) {
+  PreMeMIRExtension *pmeExt = preMeMP->New<PreMeMIRExtension>(parent, meStmt);
+  switch (meStmt->GetOp()) {
+    case OP_dassign: {
+      DassignMeStmt *dsmestmt = static_cast<DassignMeStmt *>(meStmt);
+      DassignNode *dass = codeMP->New<DassignNode>();
+      MIRSymbol *sym = dsmestmt->GetLHS()->GetOst()->GetMIRSymbol();
+      dass->SetStIdx(sym->GetStIdx());
+      dass->SetFieldID(static_cast<VarMeExpr *>(dsmestmt->GetLHS())->GetOst()->GetFieldID());
+      dass->SetOpnd(EmitPreMeExpr(dsmestmt->GetRHS(), dass), 0);
+      dass->SetSrcPos(dsmestmt->GetSrcPosition());
+      dass->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      dass->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[dass->GetStmtID()] = pmeExt;
+      return dass;
+    }
+    case OP_regassign: {
+      AssignMeStmt *asMestmt = static_cast<AssignMeStmt *>(meStmt);
+      RegassignNode *rssnode = codeMP->New<RegassignNode>();
+      rssnode->SetPrimType(asMestmt->GetLHS()->GetPrimType());
+      rssnode->SetRegIdx(asMestmt->GetLHS()->GetRegIdx());
+      rssnode->SetOpnd(EmitPreMeExpr(asMestmt->GetRHS(), rssnode), 0);
+      rssnode->SetSrcPos(asMestmt->GetSrcPosition());
+      rssnode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      rssnode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[rssnode->GetStmtID()] = pmeExt;
+      return rssnode;
+    }
+    case OP_iassign: {
+      IassignMeStmt *iass = static_cast<IassignMeStmt *>(meStmt);
+      IvarMeExpr *lhsVar = iass->GetLHSVal();
+      IassignNode *iassignNode = codeMP->New<IassignNode>();
+      iassignNode->SetTyIdx(iass->GetTyIdx());
+      iassignNode->SetFieldID(lhsVar->GetFieldID());
+      if (lhsVar->GetOffset() == 0) {
+        iassignNode->SetAddrExpr(EmitPreMeExpr(lhsVar->GetBase(), iassignNode));
+      } else {
+        auto *mirType = GlobalTables::GetTypeTable().GetInt32();
+        auto *mirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+            static_cast<uint64>(static_cast<uint32>(lhsVar->GetOffset())), *mirType);
+        auto *constValNode = codeMP->New<ConstvalNode>(mirType->GetPrimType(), mirConst);
+        auto *newAddrNode =
+            codeMP->New<BinaryNode>(OP_add, lhsVar->GetBase()->GetPrimType(),
+                                    EmitPreMeExpr(lhsVar->GetBase(), iassignNode), constValNode);
+        iassignNode->SetAddrExpr(newAddrNode);
+      }
+      if (iassignNode->Opnd(0)->GetOpCode() != OP_array) {
+        ArrayNode *arryNode = ConvertToArray(iassignNode->Opnd(0), iassignNode->GetTyIdx());
+        if (arryNode != nullptr) {
+          iassignNode->SetAddrExpr(arryNode);
+        }
+      }
+      iassignNode->rhs = EmitPreMeExpr(iass->GetRHS(), iassignNode);
+      iassignNode->SetSrcPos(iass->GetSrcPosition());
+      iassignNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      iassignNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[iassignNode->GetStmtID()] = pmeExt;
+      iassignNode->SetExpandFromArrayOfCharFunc(iass->IsExpandedFromArrayOfCharFunc());
+      return iassignNode;
+    }
+    case OP_return: {
+      RetMeStmt *retMestmt = static_cast<RetMeStmt *>(meStmt);
+      NaryStmtNode *retNode = codeMP->New<NaryStmtNode>(*codeMPAlloc, OP_return);
+      for (uint32 i = 0; i < retMestmt->GetOpnds().size(); i++) {
+        retNode->GetNopnd().push_back(EmitPreMeExpr(retMestmt->GetOpnd(i), retNode));
+      }
+      retNode->SetNumOpnds(static_cast<uint8>(retMestmt->GetOpnds().size()));
+      retNode->SetSrcPos(retMestmt->GetSrcPosition());
+      retNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      retNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[retNode->GetStmtID()] = pmeExt;
+      return retNode;
+    }
+    case OP_goto: {
+      GotoMeStmt *gotoStmt = static_cast<GotoMeStmt *>(meStmt);
+      if (preMeFunc->WhileLabelCreatedByPreMe(gotoStmt->GetOffset())) {
+        return nullptr;
+      }
+      if (preMeFunc->IfLabelCreatedByPreMe(gotoStmt->GetOffset())) {
+        return nullptr;
+      }
+      GotoNode *gto = codeMP->New<GotoNode>(OP_goto);
+      gto->SetOffset(gotoStmt->GetOffset());
+      gto->SetSrcPos(gotoStmt->GetSrcPosition());
+      gto->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      gto->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[gto->GetStmtID()] = pmeExt;
+      return gto;
+    }
+    case OP_igoto: {
+      UnaryMeStmt *igotoMeStmt = static_cast<UnaryMeStmt *>(meStmt);
+      UnaryStmtNode *igto = codeMP->New<UnaryStmtNode>(OP_igoto);
+      igto->SetOpnd(EmitPreMeExpr(igotoMeStmt->GetOpnd(), igto), 0);
+      igto->SetSrcPos(igotoMeStmt->GetSrcPosition());
+      igto->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      igto->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[igto->GetStmtID()] = pmeExt;
+      return igto;
+    }
+    case OP_comment: {
+      CommentMeStmt *cmtmeNode = static_cast<CommentMeStmt *>(meStmt);
+      CommentNode *cmtNode = codeMP->New<CommentNode>(*codeMPAlloc);
+      cmtNode->SetComment(cmtmeNode->GetComment());
+      cmtNode->SetSrcPos(cmtmeNode->GetSrcPosition());
+      cmtNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      cmtNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[cmtNode->GetStmtID()] = pmeExt;
+      return cmtNode;
+    }
+    case OP_call:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccall:
+    case OP_polymorphiccallassigned: {
+      CallMeStmt *callMeStmt = static_cast<CallMeStmt *>(meStmt);
+      CallNode *callnode = codeMP->New<CallNode>(*codeMPAlloc, meStmt->GetOp());
+      callnode->SetPUIdx(callMeStmt->GetPUIdx());
+      callnode->SetTyIdx(callMeStmt->GetTyIdx());
+      callnode->SetNumOpnds(static_cast<uint8>(callMeStmt->GetOpnds().size()));
+      callnode->SetSrcPos(callMeStmt->GetSrcPosition());
+      meStmt->EmitCallReturnVector(callnode->GetReturnVec());
+      for (uint32 i = 0; i < callMeStmt->GetOpnds().size(); i++) {
+        callnode->GetNopnd().push_back(EmitPreMeExpr(callMeStmt->GetOpnd(i), callnode));
+      }
+      callnode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      callnode->SetOriginalID(meStmt->GetOriginalId());
+      callnode->SetMeStmtID(callMeStmt->GetMeStmtId());
+      preMeStmtExtensionMap[callnode->GetStmtID()] = pmeExt;
+      callnode->SetEnclosingBlock(static_cast<BlockNode *>(parent));
+      return callnode;
+    }
+    case OP_icall:
+    case OP_icallassigned:
+    case OP_icallproto:
+    case OP_icallprotoassigned: {
+      IcallMeStmt *icallMeStmt = static_cast<IcallMeStmt *>(meStmt);
+      IcallNode *icallnode =
+          codeMP->New<IcallNode>(*codeMPAlloc, OP_icallprotoassigned, icallMeStmt->GetRetTyIdx());
+      for (uint32 i = 0; i < icallMeStmt->GetOpnds().size(); i++) {
+        icallnode->GetNopnd().push_back(EmitPreMeExpr(icallMeStmt->GetOpnd(i), icallnode));
+      }
+      icallnode->SetNumOpnds(static_cast<uint8>(icallMeStmt->GetOpnds().size()));
+      icallnode->SetSrcPos(meStmt->GetSrcPosition());
+      meStmt->EmitCallReturnVector(icallnode->GetReturnVec());
+      icallnode->SetRetTyIdx(TyIdx(PTY_void));
+      for (uint32 j = 0; j < icallnode->GetReturnVec().size(); j++) {
+        CallReturnPair retpair = icallnode->GetReturnVec()[j];
+        if (!retpair.second.IsReg()) {
+          StIdx stIdx = retpair.first;
+          MIRSymbolTable *symtab = mirFunc->GetSymTab();
+          MIRSymbol *sym = symtab->GetSymbolFromStIdx(stIdx.Idx());
+          ASSERT_NOT_NULL(sym);
+          icallnode->SetRetTyIdx(sym->GetType()->GetTypeIndex());
+        } else {
+          PregIdx pregidx(retpair.second.GetPregIdx());
+          MIRPreg *preg = mirFunc->GetPregTab()->PregFromPregIdx(pregidx);
+          icallnode->SetRetTyIdx(TyIdx(preg->GetPrimType()));
+        }
+      }
+      if (meStmt->GetOp() == OP_icallproto || meStmt->GetOp() == OP_icallprotoassigned) {
+        icallnode->SetRetTyIdx(icallMeStmt->GetRetTyIdx());
+      }
+      icallnode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      icallnode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[icallnode->GetStmtID()] = pmeExt;
+      return icallnode;
+    }
+    case OP_intrinsiccall:
+    case OP_xintrinsiccall:
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned:
+    case OP_intrinsiccallwithtype:
+    case OP_intrinsiccallwithtypeassigned: {
+      IntrinsiccallMeStmt *callMeStmt = static_cast<IntrinsiccallMeStmt *>(meStmt);
+      IntrinsiccallNode *callnode =
+          codeMP->New<IntrinsiccallNode>(*codeMPAlloc, meStmt->GetOp(), callMeStmt->GetIntrinsic());
+      callnode->SetIntrinsic(callMeStmt->GetIntrinsic());
+      callnode->SetTyIdx(callMeStmt->GetTyIdx());
+      for (uint32 i = 0; i < callMeStmt->GetOpnds().size(); i++) {
+        callnode->GetNopnd().push_back(EmitPreMeExpr(callMeStmt->GetOpnd(i), callnode));
+      }
+      callnode->SetNumOpnds(static_cast<uint8>(callnode->GetNopndSize()));
+      callnode->SetSrcPos(meStmt->GetSrcPosition());
+      if (kOpcodeInfo.IsCallAssigned(meStmt->GetOp())) {
+        meStmt->EmitCallReturnVector(callnode->GetReturnVec());
+      }
+      callnode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      callnode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[callnode->GetStmtID()] = pmeExt;
+      return callnode;
+    }
+    case OP_asm: {
+      AsmMeStmt *asmMeStmt = static_cast<AsmMeStmt *>(meStmt);
+      AsmNode *asmNode = codeMP->New<AsmNode>(codeMPAlloc);
+      for (size_t i = 0; i < asmMeStmt->NumMeStmtOpnds(); ++i) {
+        asmNode->GetNopnd().push_back(EmitPreMeExpr(asmMeStmt->GetOpnd(i), asmNode));
+      }
+      asmNode->SetNumOpnds(static_cast<uint8>(asmNode->GetNopndSize()));
+      asmNode->SetSrcPos(meStmt->GetSrcPosition());
+      meStmt->EmitCallReturnVector(*asmNode->GetCallReturnVector());
+      asmNode->asmString = asmMeStmt->asmString;
+      asmNode->inputConstraints = asmMeStmt->inputConstraints;
+      asmNode->outputConstraints = asmMeStmt->outputConstraints;
+      asmNode->clobberList = asmMeStmt->clobberList;
+      asmNode->gotoLabels = asmMeStmt->gotoLabels;
+      asmNode->SetOriginalID(meStmt->GetOriginalId());
+      asmNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      return asmNode;
+    }
+    case OP_jscatch:
+    case OP_finally:
+    case OP_endtry:
+    case OP_cleanuptry:
+    case OP_membaracquire:
+    case OP_membarrelease:
+    case OP_membarstorestore:
+    case OP_membarstoreload: {
+      StmtNode *stmtNode = codeMP->New<StmtNode>(meStmt->GetOp());
+      stmtNode->SetSrcPos(meStmt->GetSrcPosition());
+      stmtNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      stmtNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[stmtNode->GetStmtID()] = pmeExt;
+      return stmtNode;
+    }
+    case OP_retsub: {
+      StmtNode *usesStmtNode = codeMP->New<StmtNode>(meStmt->GetOp());
+      usesStmtNode->SetSrcPos(meStmt->GetSrcPosition());
+      usesStmtNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      usesStmtNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[usesStmtNode->GetStmtID()] = pmeExt;
+      return usesStmtNode;
+    }
+    case OP_brfalse:
+    case OP_brtrue: {
+      CondGotoNode *CondNode = codeMP->New<CondGotoNode>(meStmt->GetOp());
+      CondGotoMeStmt *condMeStmt = static_cast<CondGotoMeStmt *>(meStmt);
+      CondNode->SetBranchProb(condMeStmt->GetBranchProb());
+      CondNode->SetOffset(condMeStmt->GetOffset());
+      CondNode->SetSrcPos(meStmt->GetSrcPosition());
+      CondNode->SetOpnd(EmitPreMeExpr(condMeStmt->GetOpnd(), CondNode), 0);
+      CondNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      CondNode->SetOriginalID(meStmt->GetOriginalId());
+      CondNode->SetMeStmtID(meStmt->GetMeStmtId());
+      preMeStmtExtensionMap[CondNode->GetStmtID()] = pmeExt;
+      return CondNode;
+    }
+    case OP_cpptry:
+    case OP_try: {
+      TryNode *jvTryNode = codeMP->New<TryNode>(*codeMPAlloc);
+      TryMeStmt *tryMeStmt = static_cast<TryMeStmt *>(meStmt);
+      size_t offsetsSize = tryMeStmt->GetOffsets().size();
+      jvTryNode->ResizeOffsets(offsetsSize);
+      for (size_t i = 0; i < offsetsSize; i++) {
+        jvTryNode->SetOffset(tryMeStmt->GetOffsets()[i], i);
+      }
+      jvTryNode->SetSrcPos(tryMeStmt->GetSrcPosition());
+      jvTryNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      jvTryNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[jvTryNode->GetStmtID()] = pmeExt;
+      return jvTryNode;
+    }
+    case OP_cppcatch: {
+      CppCatchNode *cppCatchNode = codeMP->New<CppCatchNode>();
+      CppCatchMeStmt *catchMestmt = static_cast<CppCatchMeStmt *>(meStmt);
+      cppCatchNode->exceptionTyIdx = catchMestmt->exceptionTyIdx;
+      cppCatchNode->SetSrcPos(catchMestmt->GetSrcPosition());
+      cppCatchNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      cppCatchNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[cppCatchNode->GetStmtID()] = pmeExt;
+      return cppCatchNode;
+    }
+    case OP_catch: {
+      CatchNode *jvCatchNode = codeMP->New<CatchNode>(*codeMPAlloc);
+      CatchMeStmt *catchMestmt = static_cast<CatchMeStmt *>(meStmt);
+      jvCatchNode->SetExceptionTyIdxVec(catchMestmt->GetExceptionTyIdxVec());
+      jvCatchNode->SetSrcPos(catchMestmt->GetSrcPosition());
+      jvCatchNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      jvCatchNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[jvCatchNode->GetStmtID()] = pmeExt;
+      return jvCatchNode;
+    }
+    case OP_throw: {
+      UnaryStmtNode *throwStmtNode = codeMP->New<UnaryStmtNode>(meStmt->GetOp());
+      ThrowMeStmt *throwMeStmt = static_cast<ThrowMeStmt *>(meStmt);
+      throwStmtNode->SetOpnd(EmitPreMeExpr(throwMeStmt->GetOpnd(), throwStmtNode), 0);
+      throwStmtNode->SetSrcPos(throwMeStmt->GetSrcPosition());
+      throwStmtNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      throwStmtNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[throwStmtNode->GetStmtID()] = pmeExt;
+      return throwStmtNode;
+    }
+    case OP_callassertnonnull: {
+      CallAssertNonnullMeStmt *assertNullStmt = static_cast<CallAssertNonnullMeStmt *>(meStmt);
+      CallAssertNonnullStmtNode *assertNullNode = codeMP->New<CallAssertNonnullStmtNode>(meStmt->GetOp(),
+          assertNullStmt->GetFuncNameIdx(), assertNullStmt->GetParamIndex(), assertNullStmt->GetStmtFuncNameIdx());
+      assertNullNode->SetSrcPos(meStmt->GetSrcPosition());
+      assertNullNode->SetOpnd(EmitPreMeExpr(assertNullStmt->GetOpnd(), assertNullNode), 0);
+      assertNullNode->SetNumOpnds(1);
+      assertNullNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      assertNullNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[assertNullNode->GetStmtID()] = pmeExt;
+      return assertNullNode;
+    }
+    case OP_callassertle: {
+      CallAssertBoundaryMeStmt *assertBoundaryStmt = static_cast<CallAssertBoundaryMeStmt *>(meStmt);
+      CallAssertBoundaryStmtNode *assertBoundaryNode = codeMP->New<CallAssertBoundaryStmtNode>(
+          *codeMPAlloc, meStmt->GetOp(), assertBoundaryStmt->GetFuncNameIdx(), assertBoundaryStmt->GetParamIndex(),
+          assertBoundaryStmt->GetStmtFuncNameIdx());
+      assertBoundaryNode->SetSrcPos(meStmt->GetSrcPosition());
+      for (uint32 i = 0; i < assertBoundaryStmt->GetOpnds().size(); i++) {
+        assertBoundaryNode->GetNopnd().push_back(EmitPreMeExpr(assertBoundaryStmt->GetOpnd(i), assertBoundaryNode));
+      }
+      assertBoundaryNode->SetNumOpnds(static_cast<uint8>(assertBoundaryNode->GetNopndSize()));
+      assertBoundaryNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      assertBoundaryNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[assertBoundaryNode->GetStmtID()] = pmeExt;
+      return assertBoundaryNode;
+    }
+    case OP_eval:
+    case OP_free: {
+      UnaryStmtNode *unaryStmtNode = codeMP->New<UnaryStmtNode>(meStmt->GetOp());
+      UnaryMeStmt *uMeStmt = static_cast<UnaryMeStmt *>(meStmt);
+      unaryStmtNode->SetOpnd(EmitPreMeExpr(uMeStmt->GetOpnd(), unaryStmtNode), 0);
+      unaryStmtNode->SetSrcPos(uMeStmt->GetSrcPosition());
+      unaryStmtNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      unaryStmtNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[unaryStmtNode->GetStmtID()] = pmeExt;
+      return unaryStmtNode;
+    }
+    case OP_switch: {
+      SwitchNode *switchNode = codeMP->New<SwitchNode>(*codeMPAlloc);
+      SwitchMeStmt *meSwitch = static_cast<SwitchMeStmt *>(meStmt);
+      switchNode->SetSwitchOpnd(EmitPreMeExpr(meSwitch->GetOpnd(), switchNode));
+      switchNode->SetDefaultLabel(meSwitch->GetDefaultLabel());
+      switchNode->SetSwitchTable(meSwitch->GetSwitchTable());
+      switchNode->SetSrcPos(meSwitch->GetSrcPosition());
+      switchNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      switchNode->SetOriginalID(meStmt->GetOriginalId());
+      switchNode->SetMeStmtID(meStmt->GetMeStmtId());
+      preMeStmtExtensionMap[switchNode->GetStmtID()] = pmeExt;
+      return switchNode;
+    }
+    case OP_assertnonnull:
+    case OP_assignassertnonnull:
+    case OP_returnassertnonnull: {
+      AssertNonnullMeStmt *assertNullStmt = static_cast<AssertNonnullMeStmt *>(meStmt);
+      AssertNonnullStmtNode *assertNullNode = codeMP->New<AssertNonnullStmtNode>(
+          meStmt->GetOp(), assertNullStmt->GetFuncNameIdx());
+      assertNullNode->SetSrcPos(meStmt->GetSrcPosition());
+      assertNullNode->SetOpnd(EmitPreMeExpr(assertNullStmt->GetOpnd(), assertNullNode), 0);
+      assertNullNode->SetNumOpnds(1);
+      assertNullNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      assertNullNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[assertNullNode->GetStmtID()] = pmeExt;
+      return assertNullNode;
+    }
+    case OP_calcassertge:
+    case OP_calcassertlt:
+    case OP_assertge:
+    case OP_assertlt:
+    case OP_assignassertle:
+    case OP_returnassertle: {
+      AssertBoundaryMeStmt *assertBoundaryStmt = static_cast<AssertBoundaryMeStmt *>(meStmt);
+      AssertBoundaryStmtNode *assertBoundaryNode = codeMP->New<AssertBoundaryStmtNode>(
+          *codeMPAlloc, meStmt->GetOp(), assertBoundaryStmt->GetFuncNameIdx());
+      assertBoundaryNode->SetSrcPos(meStmt->GetSrcPosition());
+      for (uint32 i = 0; i < assertBoundaryStmt->GetOpnds().size(); i++) {
+        assertBoundaryNode->GetNopnd().push_back(EmitPreMeExpr(assertBoundaryStmt->GetOpnd(i), assertBoundaryNode));
+      }
+      assertBoundaryNode->SetNumOpnds(static_cast<uint8>(assertBoundaryNode->GetNopndSize()));
+      assertBoundaryNode->CopySafeRegionAttr(meStmt->GetStmtAttr());
+      assertBoundaryNode->SetOriginalID(meStmt->GetOriginalId());
+      preMeStmtExtensionMap[assertBoundaryNode->GetStmtID()] = pmeExt;
+      return assertBoundaryNode;
+    }
+    case OP_syncenter:
+    case OP_syncexit: {
+      auto naryMeStmt = static_cast<NaryMeStmt *>(meStmt);
+      auto syncStmt = codeMP->New<NaryStmtNode>(*codeMPAlloc, meStmt->GetOp());
+      for (uint32 i = 0; i < naryMeStmt->GetOpnds().size(); i++) {
+        syncStmt->GetNopnd().push_back(EmitPreMeExpr(naryMeStmt->GetOpnd(i), syncStmt));
+      }
+      syncStmt->SetNumOpnds(syncStmt->GetNopndSize());
+      return syncStmt;
+    }
+    default:
+      CHECK_FATAL(false, "nyi");
+  }
+}
+
+void PreMeEmitter::UpdateStmtInfoForLabelNode(LabelNode &label, BB &bb) {
+  if (ipaInfo == nullptr) {
+    return;
+  }
+  label.SetStmtInfoId(ipaInfo->GetRealFirstStmtInfoId(bb));
+}
+
+void PreMeEmitter::UpdateStmtInfo(const MeStmt &meStmt, StmtNode &stmt, BlockNode &currBlock, uint64 frequency) {
+  if (ipaInfo == nullptr || meStmt.GetStmtInfoId() == kInvalidIndex) {
+    return;
+  }
+  auto &stmtInfo = ipaInfo->GetStmtInfo()[meStmt.GetStmtInfoId()];
+  stmtInfo.SetStmtNode(&stmt);
+  stmtInfo.SetCurrBlock(&currBlock);
+  stmtInfo.SetFrequency(frequency);
+  stmt.SetStmtInfoId(meStmt.GetStmtInfoId());
+}
+
+void PreMeEmitter::EmitBB(BB *bb, BlockNode *curBlk) {
+  CHECK_FATAL(curBlk != nullptr, "null ptr check");
+  bool setFirstFreq = (GetFuncProfData() != nullptr);
+  bool setLastFreq = false;
+  bool bbIsEmpty = bb->GetMeStmts().empty();
+  // emit head. label
+  LabelIdx labidx = bb->GetBBLabel();
+  if (labidx != 0 && !preMeFunc->WhileLabelCreatedByPreMe(labidx) && !preMeFunc->IfLabelCreatedByPreMe(labidx)) {
+    // not a empty bb
+    LabelNode *lbnode = codeMP->New<LabelNode>();
+    UpdateStmtInfoForLabelNode(*lbnode, *bb);
+    lbnode->SetLabelIdx(labidx);
+    curBlk->AddStatement(lbnode);
+    PreMeMIRExtension *pmeExt = preMeMP->New<PreMeMIRExtension>(curBlk);
+    preMeStmtExtensionMap[lbnode->GetStmtID()] = pmeExt;
+    if (GetFuncProfData()) {
+      GetFuncProfData()->SetStmtFreq(lbnode->GetStmtID(), bb->GetFrequency());
+    }
+  }
+  for (auto& mestmt : bb->GetMeStmts()) {
+    StmtNode *stmt = EmitPreMeStmt(&mestmt, curBlk);
+    if (!stmt) {
+      // can be null i.e, a goto to a label that was created by lno lower
+      continue;
+    }
+    UpdateStmtInfo(mestmt, *stmt, *curBlk, bb->GetFrequency());
+    curBlk->AddStatement(stmt);
+    // add <stmtID, freq> for first stmt in bb in curblk
+    if (GetFuncProfData() != nullptr) {
+      if (setFirstFreq || (stmt->GetOpCode() == OP_call) || IsCallAssigned(stmt->GetOpCode())) {
+        GetFuncProfData()->SetStmtFreq(stmt->GetStmtID(), bb->GetFrequency());
+        setFirstFreq = false;
+      } else {
+        setLastFreq = true;
+      }
+    }
+  }
+  if (bb->GetAttributes(kBBAttrIsTryEnd)) {
+    /* generate op_endtry */
+    StmtNode *endtry = codeMP->New<StmtNode>(OP_endtry);
+    curBlk->AddStatement(endtry);
+    PreMeMIRExtension *pmeExt = preMeMP->New<PreMeMIRExtension>(curBlk);
+    preMeStmtExtensionMap[endtry->GetStmtID()] = pmeExt;
+    setLastFreq = true;
+  }
+  // add stmtnode to last
+  if (GetFuncProfData()) {
+    if (setLastFreq) {
+      GetFuncProfData()->SetStmtFreq(curBlk->GetLast()->GetStmtID(), bb->GetFrequency());
+    } else if (bbIsEmpty) {
+      LogInfo::MapleLogger() << " bb " << bb->GetBBId() << "no stmt used to add frequency, add commentnode\n";
+      CommentNode *commentNode = codeMP->New<CommentNode>(*(mirFunc->GetModule()));
+      commentNode->SetComment("freqStmt"+std::to_string(commentNode->GetStmtID()));
+      GetFuncProfData()->SetStmtFreq(commentNode->GetStmtID(), bb->GetFrequency());
+      curBlk->AddStatement(commentNode);
+    }
+  }
+}
+
+DoloopNode *PreMeEmitter::EmitPreMeDoloop(BB *meWhileBB, BlockNode *curBlk, PreMeWhileInfo *whileInfo) {
+  MeStmt *lastmestmt = meWhileBB->GetLastMe();
+  ASSERT_NOT_NULL(lastmestmt);
+  CHECK_FATAL(lastmestmt->GetPrev() == nullptr || dynamic_cast<AssignMeStmt *>(lastmestmt->GetPrev()) == nullptr,
+              "EmitPreMeDoLoop: there are other statements at while header bb");
+  DoloopNode *Doloopnode = codeMP->New<DoloopNode>();
+  PreMeMIRExtension *pmeExt = preMeMP->New<PreMeMIRExtension>(curBlk);
+  pmeExt->mestmt = lastmestmt;
+  preMeStmtExtensionMap[Doloopnode->GetStmtID()] = pmeExt;
+  Doloopnode->SetDoVarStIdx(whileInfo->ivOst->GetMIRSymbol()->GetStIdx());
+  CondGotoMeStmt *condGotostmt = static_cast<CondGotoMeStmt *>(lastmestmt);
+  Doloopnode->SetStartExpr(EmitPreMeExpr(whileInfo->initExpr, Doloopnode));
+  Doloopnode->SetContExpr(EmitPreMeExpr(condGotostmt->GetOpnd(), Doloopnode));
+  CompareNode *compare = static_cast<CompareNode *>(Doloopnode->GetCondExpr());
+  if (compare->Opnd(0)->GetOpCode() == OP_cvt && compare->Opnd(0)->Opnd(0)->GetOpCode() == OP_cvt) {
+    PrimType resPrimType = compare->Opnd(0)->GetPrimType();
+    PrimType opndPrimType = static_cast<TypeCvtNode*>(compare->Opnd(0))->FromType();
+    TypeCvtNode *secondCvtX = static_cast<TypeCvtNode*>(compare->Opnd(0)->Opnd(0));
+    if (IsNoCvtNeeded(resPrimType, secondCvtX->FromType()) &&
+        IsNoCvtNeeded(opndPrimType, secondCvtX->GetPrimType())) {
+      compare->SetOpnd(secondCvtX->Opnd(0), 0);
+    }
+  }
+  BlockNode *dobodyNode = codeMP->New<BlockNode>();
+  Doloopnode->SetDoBody(dobodyNode);
+  PreMeMIRExtension *doloopExt = preMeMP->New<PreMeMIRExtension>(Doloopnode);
+  preMeStmtExtensionMap[dobodyNode->GetStmtID()] = doloopExt;
+  MIRIntConst *intConst =
+      mirFunc->GetModule()->GetMemPool()->New<MIRIntConst>(whileInfo->stepValue, *whileInfo->ivOst->GetType());
+  ConstvalNode *constnode = codeMP->New<ConstvalNode>(intConst->GetType().GetPrimType(), intConst);
+  preMeExprExtensionMap[constnode] = doloopExt;
+  Doloopnode->SetIncrExpr(constnode);
+  Doloopnode->SetIsPreg(false);
+  curBlk->AddStatement(Doloopnode);
+  // add stmtfreq
+  if (GetFuncProfData()) {
+    GetFuncProfData()->SetStmtFreq(Doloopnode->GetStmtID(), meWhileBB->GetFrequency());
+  }
+  return Doloopnode;
+}
+
+WhileStmtNode *PreMeEmitter::EmitPreMeWhile(BB *meWhileBB, BlockNode *curBlk) {
+  MeStmt *lastmestmt = meWhileBB->GetLastMe();
+  ASSERT_NOT_NULL(lastmestmt);
+  CHECK_FATAL(lastmestmt->GetPrev() == nullptr || dynamic_cast<AssignMeStmt *>(lastmestmt->GetPrev()) == nullptr,
+              "EmitPreMeWhile: there are other statements at while header bb");
+  WhileStmtNode *Whilestmt = codeMP->New<WhileStmtNode>(OP_while);
+  PreMeMIRExtension *pmeExt = preMeMP->New<PreMeMIRExtension>(curBlk);
+  preMeStmtExtensionMap[Whilestmt->GetStmtID()] = pmeExt;
+  CondGotoMeStmt *condGotostmt = static_cast<CondGotoMeStmt *>(lastmestmt);
+  Whilestmt->SetOpnd(EmitPreMeExpr(condGotostmt->GetOpnd(), Whilestmt), 0);
+  BlockNode *whilebodyNode = codeMP->New<BlockNode>();
+  PreMeMIRExtension *whilenodeExt = preMeMP->New<PreMeMIRExtension>(Whilestmt);
+  preMeStmtExtensionMap[whilebodyNode->GetStmtID()] = whilenodeExt;
+  Whilestmt->SetBody(whilebodyNode);
+  // add stmtfreq
+  if (GetFuncProfData()) {
+    GetFuncProfData()->SetStmtFreq(Whilestmt->GetStmtID(), meWhileBB->GetFrequency());
+  }
+  curBlk->AddStatement(Whilestmt);
+  return Whilestmt;
+}
+
+uint32 PreMeEmitter::Raise2PreMeWhile(uint32 curJ, BlockNode *curBlk) {
+  MapleVector<BB *> &bbvec = cfg->GetAllBBs();
+  BB *curbb = bbvec[curJ];
+  LabelIdx whilelabidx = curbb->GetBBLabel();
+  PreMeWhileInfo *whileInfo = preMeFunc->label2WhileInfo[whilelabidx];
+
+  // find the end label bb
+  BB *suc0 = curbb->GetSucc(0);
+  BB *suc1 = curbb->GetSucc(1);
+  MeStmt *laststmt = curbb->GetLastMe();
+  CHECK_FATAL(laststmt->GetOp() == OP_brfalse, "Riase2While: NYI");
+  CondGotoMeStmt *condgotomestmt = static_cast<CondGotoMeStmt *>(laststmt);
+  BB *endlblbb = condgotomestmt->GetOffset() == suc1->GetBBLabel() ? suc1 : suc0;
+  BlockNode *dobody = nullptr;
+  StmtNode *loop = nullptr;
+  ++curJ;
+  if (whileInfo->canConvertDoloop) {  // emit doloop
+    auto *doloopNode = EmitPreMeDoloop(curbb, curBlk, whileInfo);
+    loop = doloopNode;
+    dobody = doloopNode->GetDoBody();
+  } else { // emit while loop
+    auto *whileNode = EmitPreMeWhile(curbb, curBlk);
+    loop = whileNode;
+    dobody = whileNode->GetBody();
+  }
+  UpdateStmtInfo(*laststmt, *loop, *curBlk, curbb->GetFrequency());
+
+  // emit loop body
+  while (bbvec[curJ]->GetBBId() != endlblbb->GetBBId()) {
+    curJ = EmitPreMeBB(curJ, dobody);
+    while (bbvec[curJ] == nullptr) {
+      ++curJ;
+    }
+  }
+  if (whileInfo->canConvertDoloop) {  // delete the increment statement
+    StmtNode *bodylaststmt = dobody->GetLast();
+    CHECK_FATAL(bodylaststmt->GetOpCode() == OP_dassign, "Raise2PreMeWhile: cannot find increment stmt");
+    DassignNode *dassnode = static_cast<DassignNode *>(bodylaststmt);
+    CHECK_FATAL(dassnode->GetStIdx() == whileInfo->ivOst->GetMIRSymbol()->GetStIdx(),
+                "Raise2PreMeWhile: cannot find IV increment");
+    dobody->RemoveStmt(dassnode);
+  }
+  // set dobody freq
+  if (GetFuncProfData()) {
+    int64_t freq = (endlblbb == suc0) ? suc1->GetFrequency() : suc0->GetFrequency();
+    GetFuncProfData()->SetStmtFreq(dobody->GetStmtID(), static_cast<uint64>(freq));
+  }
+  return curJ;
+}
+
+uint32 PreMeEmitter::Raise2PreMeIf(uint32 curJ, BlockNode *curBlk) {
+  MapleVector<BB *> &bbvec = cfg->GetAllBBs();
+  BB *curbb = bbvec[curJ];
+  bool setFirstFreq = (GetFuncProfData() != nullptr);
+  // emit BB contents before the if statement
+  LabelIdx labidx = curbb->GetBBLabel();
+  if (labidx != 0 && !preMeFunc->IfLabelCreatedByPreMe(labidx)) {
+    LabelNode *lbnode = mirFunc->GetCodeMempool()->New<LabelNode>();
+    UpdateStmtInfoForLabelNode(*lbnode, *curbb);
+    lbnode->SetLabelIdx(labidx);
+    curBlk->AddStatement(lbnode);
+    PreMeMIRExtension *pmeExt = preMeMP->New<PreMeMIRExtension>(curBlk);
+    preMeStmtExtensionMap[lbnode->GetStmtID()] = pmeExt;
+  }
+  MeStmt *mestmt = curbb->GetFirstMe();
+  while (mestmt->GetOp() != OP_brfalse && mestmt->GetOp() != OP_brtrue) {
+    StmtNode *stmt = EmitPreMeStmt(mestmt, curBlk);
+    UpdateStmtInfo(*mestmt, *stmt, *curBlk, curbb->GetFrequency());
+    curBlk->AddStatement(stmt);
+    if (GetFuncProfData() &&
+        (setFirstFreq || (stmt->GetOpCode() == OP_call) || IsCallAssigned(stmt->GetOpCode()))) {
+      // add frequency of first/call stmt of curbb
+      GetFuncProfData()->SetStmtFreq(stmt->GetStmtID(), curbb->GetFrequency());
+      setFirstFreq = false;
+    }
+    mestmt = mestmt->GetNext();
+  }
+  // emit the if statement
+  CHECK_FATAL(mestmt != nullptr && (mestmt->GetOp() == OP_brfalse || mestmt->GetOp() == OP_brtrue),
+              "Raise2PreMeIf: cannot find conditional branch");
+  CondGotoMeStmt *condgoto = static_cast <CondGotoMeStmt *>(mestmt);
+  PreMeIfInfo *ifInfo = preMeFunc->label2IfInfo[condgoto->GetOffset()];
+  CHECK_FATAL(ifInfo->endLabel != 0, "Raise2PreMeIf: endLabel not found");
+  IfStmtNode *ifStmtNode = mirFunc->GetCodeMempool()->New<IfStmtNode>();
+  PreMeMIRExtension *pmeExt = preMeMP->New<PreMeMIRExtension>(curBlk);
+  preMeStmtExtensionMap[ifStmtNode->GetStmtID()] = pmeExt;
+  BaseNode *condnode = EmitPreMeExpr(condgoto->GetOpnd(), ifStmtNode);
+  if (condgoto->IsBranchProbValid() && (condgoto->GetBranchProb() == kProbLikely ||
+                                        condgoto->GetBranchProb() == kProbUnlikely)) {
+    IntrinsicopNode *expectNode = codeMP->New<IntrinsicopNode>(*mirFunc->GetModule(), OP_intrinsicop, PTY_i64);
+    expectNode->SetIntrinsic(INTRN_C___builtin_expect);
+    expectNode->GetNopnd().push_back(condnode);
+    MIRType *type = GlobalTables::GetTypeTable().GetPrimType(PTY_i64);
+    // | op\jmpProp | likelyJump (1) | unlikelyJump(0) |
+    // +-----------------------------------------------+
+    // | brtrue (1) | expectTrue (1) | expectFalse (0) |
+    // | brfalse(0) | expectFalse(0) | expectTrue  (1) |
+    // XNOR
+    uint32 val = !(static_cast<uint32>(mestmt->GetOp() == OP_brtrue) ^ (condgoto->GetBranchProb() == kProbLikely));
+    MIRIntConst *constVal = GlobalTables::GetIntConstTable().GetOrCreateIntConst(val, *type);
+    ConstvalNode *constNode = codeMP->New<ConstvalNode>(constVal->GetType().GetPrimType(), constVal);
+    expectNode->GetNopnd().push_back(constNode);
+    expectNode->SetNumOpnds(expectNode->GetNopnd().size());
+    MIRIntConst *constZeroVal = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *type);
+    ConstvalNode *constZeroNode = codeMP->New<ConstvalNode>(constVal->GetType().GetPrimType(), constZeroVal);
+    CompareNode *cmpNode =
+        codeMP->New<CompareNode>(OP_ne, PTY_i32, PTY_i32, expectNode, constZeroNode);
+    condnode = cmpNode;
+  }
+  ifStmtNode->SetOpnd(condnode, 0);
+  ifStmtNode->SetMeStmtID(condgoto->GetMeStmtId());
+  UpdateStmtInfo(*mestmt, *ifStmtNode, *curBlk, curbb->GetFrequency());
+  curBlk->AddStatement(ifStmtNode);
+  if (GetFuncProfData()) {
+    // set ifstmt freq
+    GetFuncProfData()->SetStmtFreq(ifStmtNode->GetStmtID(), curbb->GetFrequency());
+  }
+  PreMeMIRExtension *ifpmeExt = preMeMP->New<PreMeMIRExtension>(ifStmtNode);
+  if (ifInfo->elseLabel != 0) {  // both else and then are not empty;
+    BlockNode *elseBlk = codeMP->New<BlockNode>();
+    preMeStmtExtensionMap[elseBlk->GetStmtID()] = ifpmeExt;
+    BlockNode *thenBlk = codeMP->New<BlockNode>();
+    preMeStmtExtensionMap[thenBlk->GetStmtID()] = ifpmeExt;
+    ifStmtNode->SetThenPart(thenBlk);
+    ifStmtNode->SetElsePart(elseBlk);
+    BB *elsemebb = cfg->GetLabelBBAt(ifInfo->elseLabel);
+    BB *endmebb = cfg->GetLabelBBAt(ifInfo->endLabel);
+    CHECK_FATAL(elsemebb, "Raise2PreMeIf: cannot find else BB");
+    CHECK_FATAL(endmebb, "Raise2PreMeIf: cannot find BB at end of IF");
+    // emit then branch;
+    uint32 j = curJ + 1;
+    while (j != elsemebb->GetBBId()) {
+      j = EmitPreMeBB(j, thenBlk);
+    }
+    CHECK_FATAL(j < bbvec.size(), "");
+    while (j != endmebb->GetBBId()) {
+      j = EmitPreMeBB(j, elseBlk);
+    }
+    if (GetFuncProfData()) {
+      // set then part/else part frequency
+      GetFuncProfData()->SetStmtFreq(thenBlk->GetStmtID(), bbvec[curJ + 1]->GetFrequency());
+      GetFuncProfData()->SetStmtFreq(elseBlk->GetStmtID(), elsemebb->GetFrequency());
+    }
+    CHECK_FATAL(j < bbvec.size(), "");
+    return j;
+  } else {  // there is only then or else part in this if stmt
+    BlockNode *branchBlock = codeMP->New<BlockNode>();
+    preMeStmtExtensionMap[branchBlock->GetStmtID()] = ifpmeExt;
+    BlockNode *emptyBlock = codeMP->New<BlockNode>();
+    preMeStmtExtensionMap[emptyBlock->GetStmtID()] = ifpmeExt;
+    if (condgoto->GetOp() == OP_brtrue) {
+      ifStmtNode->SetElsePart(branchBlock);
+      ifStmtNode->SetThenPart(emptyBlock);
+    } else {
+      ifStmtNode->SetThenPart(branchBlock);
+      ifStmtNode->SetElsePart(emptyBlock);
+    }
+    BB *endmebb = cfg->GetLabelBBAt(ifInfo->endLabel);
+    uint32 j = curJ + 1;
+    ASSERT_NOT_NULL(endmebb);
+    while (j != endmebb->GetBBId()) {
+      j = EmitPreMeBB(j, branchBlock);
+    }
+    CHECK_FATAL(j < bbvec.size(), "");
+    if (GetFuncProfData()) {
+      // set then part/else part frequency
+      uint64 ifFreq = GetFuncProfData()->GetStmtFreq(ifStmtNode->GetStmtID());
+      uint64 branchFreq = bbvec[curJ + 1]->GetFrequency();
+      GetFuncProfData()->SetStmtFreq(branchBlock->GetStmtID(), branchFreq);
+      GetFuncProfData()->SetStmtFreq(emptyBlock->GetStmtID(), ifFreq - branchFreq);
+    }
+    return j;
+  }
+}
+
+uint32 PreMeEmitter::EmitPreMeBB(uint32 curJ, BlockNode *curBlk) {
+  MapleVector<BB *> &bbvec = cfg->GetAllBBs();
+  BB *mebb = bbvec[curJ];
+  if (!mebb || mebb == cfg->GetCommonEntryBB() || mebb == cfg->GetCommonExitBB()) {
+    return curJ + 1;
+  }
+  if (mebb->GetBBLabel() != 0) {
+    MapleMap<LabelIdx, PreMeWhileInfo*>::const_iterator it = preMeFunc->label2WhileInfo.find(mebb->GetBBLabel());
+    if (it != preMeFunc->label2WhileInfo.end()) {
+      if (mebb->GetSucc().size() == 2) {
+        curJ = Raise2PreMeWhile(curJ, curBlk);
+        return curJ;
+      } else {
+        preMeFunc->pmeCreatedWhileLabelSet.erase(mebb->GetBBLabel());
+      }
+    }
+  }
+  if (!mebb->GetMeStmts().empty() &&
+      (mebb->GetLastMe()->GetOp() == OP_brfalse ||
+       mebb->GetLastMe()->GetOp() == OP_brtrue)) {
+    CondGotoMeStmt *condgoto = static_cast<CondGotoMeStmt *>(mebb->GetLastMe());
+    MapleMap<LabelIdx, PreMeIfInfo*>::const_iterator it = preMeFunc->label2IfInfo.find(condgoto->GetOffset());
+    if (it != preMeFunc->label2IfInfo.end()) {
+      curJ = Raise2PreMeIf(curJ, curBlk);
+      return curJ;
+    }
+  }
+  EmitBB(mebb, curBlk);
+  return ++curJ;
+}
+
+void MEPreMeEmission::SetIpaInfo(MIRFunction &mirFunc) {
+  if (!mirFunc.GetModule()->IsInIPA() || !Options::doOutline) {
+    return;
+  }
+  auto sccEmitPm = dynamic_cast<MaplePhase*>(GetAnalysisInfoHook()->GetBindingPM());
+  auto *ipaInfo = static_cast<IpaSccPM*>(sccEmitPm->GetAnalysisInfoHook()->GetBindingPM())->GetResult();
+  emitter->SetIpaInfo(ipaInfo);
+}
+
+bool MEPreMeEmission::PhaseRun(MeFunction &f) {
+  if (f.GetCfg()->NumBBs() == 0) {
+    f.SetLfo(false);
+    f.SetPme(false);
+    return false;
+  }
+  MeIRMap *hmap = GET_ANALYSIS(MEIRMapBuild, f);
+  ASSERT(hmap != nullptr, "irmapbuild has problem");
+
+  MIRFunction *mirfunction = f.GetMirFunc();
+  mirfunction->ReleaseCodeMemory();
+  mirfunction->SetMemPool(new ThreadLocalMemPool(memPoolCtrler, "IR from preemission::Emit()"));
+  MemPool *preMeMP = GetPhaseMemPool();
+  emitter = preMeMP->New<PreMeEmitter>(hmap, f.GetPreMeFunc(), preMeMP);
+  SetIpaInfo(*mirfunction);
+  BlockNode *curblk = mirfunction->GetCodeMempool()->New<BlockNode>();
+  mirfunction->SetBody(curblk);
+  // restore bb frequency to stmt
+  if (Options::profileUse && emitter->GetFuncProfData()) {
+    emitter->GetFuncProfData()->SetStmtFreq(curblk->GetStmtID(), emitter->GetFuncProfData()->entryFreq);
+  }
+  uint32 i = 0;
+  while (i < f.GetCfg()->GetAllBBs().size()) {
+    i = emitter->EmitPreMeBB(i, curblk);
+  }
+
+  f.SetLfo(false);
+  f.SetPme(false);
+
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "\n**** After premeemit phase ****\n";
+    mirfunction->Dump(false);
+  }
+
+  if (Options::enableGInline) {
+    auto *inlineSummary = f.GetMirFunc()->GetInlineSummary();
+    if (inlineSummary != nullptr) {
+      inlineSummary->RefreshMapKeyIfNeeded();
+    }
+  }
+
+  return emitter;
+}
+
+void MEPreMeEmission::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/pme_mir_lower.cpp b/src/mapleall/maple_me/src/pme_mir_lower.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e2a45d62d4ed2f5a34c819d2f02b15dbdd3ba273
--- /dev/null
+++ b/src/mapleall/maple_me/src/pme_mir_lower.cpp
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "mir_builder.h"
+#include "pme_mir_lower.h"
+
+using namespace maple;
+
+// is lowered to :
+// label <whilelabel>
+// brfalse <cond> <endlabel>
+// <body>
+// goto <whilelabel>
+// label <endlabel>
+BlockNode *PreMeMIRLower::LowerWhileStmt(WhileStmtNode &whileStmt) {
+  MIRBuilder *mirbuilder = mirModule.GetMIRBuilder();
+  whileStmt.SetBody(LowerBlock(*whileStmt.GetBody()));
+  BlockNode *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  LabelIdx whilelblidx = func->GetMirFunc()->GetLabelTab()->CreateLabelWithPrefix('w');
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(whilelblidx);
+  LabelNode *whilelblstmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  whilelblstmt->SetLabelIdx(whilelblidx);
+  PreMeWhileInfo *whileInfo = preMeFunc->pmemp->New<PreMeWhileInfo>();
+  preMeFunc->SetWhileLabelCreatedByPreMe(whilelblidx);
+  preMeFunc->label2WhileInfo.insert(std::make_pair(whilelblidx, whileInfo));
+  blk->AddStatement(whilelblstmt);
+  CondGotoNode *brfalsestmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brfalse);
+  brfalsestmt->SetOpnd(whileStmt.Opnd(), 0);
+  brfalsestmt->SetSrcPos(whileStmt.GetSrcPos());
+  // add jump label target later
+  blk->AddStatement(brfalsestmt);
+  // update frequency
+  if (GetFuncProfData()) {
+    ASSERT(GetFuncProfData()->GetStmtFreq(whileStmt.GetStmtID()) >= 0, "while stmt should has freq");
+    GetFuncProfData()->CopyStmtFreq(whilelblstmt->GetStmtID(), whileStmt.GetStmtID());
+    GetFuncProfData()->CopyStmtFreq(brfalsestmt->GetStmtID(), whileStmt.GetStmtID());
+  }
+  // create body
+  CHECK_FATAL(whileStmt.GetBody(), "null ptr check");
+  blk->AppendStatementsFromBlock(*whileStmt.GetBody());
+  GotoNode *whilegotonode = mirbuilder->CreateStmtGoto(OP_goto, whilelblidx);
+  if (GetFuncProfData() && blk->GetLast()) {
+    ASSERT(GetFuncProfData()->GetStmtFreq(blk->GetLast()->GetStmtID()) >= 0,
+        "last stmt of while body should has freq");
+    GetFuncProfData()->CopyStmtFreq(whilegotonode->GetStmtID(), blk->GetLast()->GetStmtID());
+  }
+  blk->AddStatement(whilegotonode);
+  // create endlabel
+  LabelIdx endlblidx = mirModule.CurFunction()->GetLabelTab()->CreateLabelWithPrefix('w');
+  preMeFunc->SetWhileLabelCreatedByPreMe(endlblidx);
+  mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(endlblidx);
+  LabelNode *endlblstmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+  endlblstmt->SetLabelIdx(endlblidx);
+  brfalsestmt->SetOffset(endlblidx);
+  SrcPosition pos = func->GetMirFunc()->GetScope()->GetScopeEndPos(whileStmt.GetBody()->GetSrcPos());
+  if (!pos.IsValid()) {
+    pos = func->GetMirFunc()->GetScope()->GetScopeEndPos(whileStmt.GetSrcPos());
+  }
+  endlblstmt->SetSrcPos(pos);
+  blk->AddStatement(endlblstmt);
+  if (GetFuncProfData()) {
+    int64_t freq = GetFuncProfData()->GetStmtFreq(whileStmt.GetStmtID()) -
+                   GetFuncProfData()->GetStmtFreq(whilegotonode->GetStmtID());
+    ASSERT(freq >= 0, "sanity check");
+    GetFuncProfData()->SetStmtFreq(endlblstmt->GetStmtID(), freq);
+  }
+  return blk;
+}
+
+static bool BlockHasLabel(BlockNode *blk) {
+  for (StmtNode &stmt : blk->GetStmtNodes()) {
+    if (stmt.GetOpCode() == OP_label) {
+      return true;
+    }
+  }
+  return false;
+}
+
+BlockNode *PreMeMIRLower::LowerIfStmt(IfStmtNode &ifstmt, bool recursive) {
+  bool thenempty = ifstmt.GetThenPart() == nullptr || ifstmt.GetThenPart()->GetFirst() == nullptr;
+  bool elseempty = ifstmt.GetElsePart() == nullptr || ifstmt.GetElsePart()->GetFirst() == nullptr;
+  bool canRaiseBack = true;
+
+  if (recursive) {
+    if (!thenempty) {
+      if (BlockHasLabel(ifstmt.GetThenPart())) {
+        canRaiseBack = false;
+      }
+      ifstmt.SetThenPart(LowerBlock(*ifstmt.GetThenPart()));
+    }
+    if (!elseempty) {
+      if (BlockHasLabel(ifstmt.GetElsePart())) {
+        canRaiseBack = false;
+      }
+      ifstmt.SetElsePart(LowerBlock(*ifstmt.GetElsePart()));
+    }
+  }
+
+  BlockNode *blk = mirModule.CurFuncCodeMemPool()->New<BlockNode>();
+  MIRFunction *mirFunc = func->GetMirFunc();
+  MIRBuilder *mirbuilder = mirModule.GetMIRBuilder();
+
+  if (thenempty && elseempty) {
+    // generate EVAL <cond> statement
+    UnaryStmtNode *evalstmt = mirModule.CurFuncCodeMemPool()->New<UnaryStmtNode>(OP_eval);
+    evalstmt->SetOpnd(ifstmt.Opnd(), 0);
+    evalstmt->SetSrcPos(ifstmt.GetSrcPos());
+    blk->AddStatement(evalstmt);
+    if (GetFuncProfData()) {
+      GetFuncProfData()->CopyStmtFreq(evalstmt->GetStmtID(), ifstmt.GetStmtID());
+    }
+  } else if (elseempty) {
+    // brfalse <cond> <endlabel>
+    // <thenPart>
+    // label <endlabel>
+    CondGotoNode *brfalsestmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brfalse);
+    brfalsestmt->SetOpnd(ifstmt.Opnd(), 0);
+    brfalsestmt->SetSrcPos(ifstmt.GetSrcPos());
+    LabelIdx endlabelidx = mirFunc->GetLabelTab()->CreateLabelWithPrefix('e');
+    mirFunc->GetLabelTab()->AddToStringLabelMap(endlabelidx);
+    if (canRaiseBack) {
+      preMeFunc->SetIfLabelCreatedByPreMe(endlabelidx);
+    }
+    PreMeIfInfo *ifInfo = preMeFunc->pmemp->New<PreMeIfInfo>();
+    brfalsestmt->SetOffset(endlabelidx);
+    blk->AddStatement(brfalsestmt);
+    // set stmtfreqs
+    if (GetFuncProfData()) {
+      GetFuncProfData()->CopyStmtFreq(brfalsestmt->GetStmtID(), ifstmt.GetStmtID());
+    }
+    blk->AppendStatementsFromBlock(*ifstmt.GetThenPart());
+
+    LabelNode *labstmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+    labstmt->SetLabelIdx(endlabelidx);
+    ifInfo->endLabel = endlabelidx;
+    if (canRaiseBack) {
+      preMeFunc->label2IfInfo.insert(std::make_pair(endlabelidx, ifInfo));
+    }
+    SrcPosition pos = func->GetMirFunc()->GetScope()->GetScopeEndPos(ifstmt.GetThenPart()->GetSrcPos());
+    labstmt->SetSrcPos(pos);
+    blk->AddStatement(labstmt);
+    // set stmtfreqs
+    if (GetFuncProfData()) {
+      ASSERT(GetFuncProfData()->GetStmtFreq(ifstmt.GetThenPart()->GetStmtID()) >= 0, "sanity check");
+      int64_t freq = GetFuncProfData()->GetStmtFreq(ifstmt.GetStmtID()) -
+                        GetFuncProfData()->GetStmtFreq(ifstmt.GetThenPart()->GetStmtID());
+      GetFuncProfData()->SetStmtFreq(labstmt->GetStmtID(), freq);
+    }
+  } else if (thenempty) {
+    // brtrue <cond> <endlabel>
+    // <elsePart>
+    // label <endlabel>
+    CondGotoNode *brtruestmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brtrue);
+    brtruestmt->SetOpnd(ifstmt.Opnd(), 0);
+    brtruestmt->SetSrcPos(ifstmt.GetSrcPos());
+    LabelIdx endlabelidx = mirFunc->GetLabelTab()->CreateLabelWithPrefix('e');
+    if (canRaiseBack) {
+      preMeFunc->SetIfLabelCreatedByPreMe(endlabelidx);
+    }
+    PreMeIfInfo *ifInfo = preMeFunc->pmemp->New<PreMeIfInfo>();
+    mirFunc->GetLabelTab()->AddToStringLabelMap(endlabelidx);
+    brtruestmt->SetOffset(endlabelidx);
+    blk->AddStatement(brtruestmt);
+
+    // set stmtfreqs
+    if (GetFuncProfData()) {
+      GetFuncProfData()->CopyStmtFreq(brtruestmt->GetStmtID(), ifstmt.GetStmtID());
+    }
+    blk->AppendStatementsFromBlock(*ifstmt.GetElsePart());
+    LabelNode *labstmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+    labstmt->SetLabelIdx(endlabelidx);
+    ifInfo->endLabel = endlabelidx;
+    if (canRaiseBack) {
+      preMeFunc->label2IfInfo.insert(std::make_pair(endlabelidx, ifInfo));
+    }
+    SrcPosition pos = func->GetMirFunc()->GetScope()->GetScopeEndPos(ifstmt.GetElsePart()->GetSrcPos());
+    labstmt->SetSrcPos(pos);
+    blk->AddStatement(labstmt);
+    // set stmtfreqs
+    if (GetFuncProfData()) {
+      ASSERT(GetFuncProfData()->GetStmtFreq(ifstmt.GetElsePart()->GetStmtID()) > 0, "sanity check");
+      int64_t freq = GetFuncProfData()->GetStmtFreq(ifstmt.GetStmtID()) -
+                        GetFuncProfData()->GetStmtFreq(ifstmt.GetElsePart()->GetStmtID());
+      GetFuncProfData()->SetStmtFreq(labstmt->GetStmtID(), freq);
+    }
+  } else {
+    // brfalse <cond> <elselabel>
+    // <thenPart>
+    // goto <endlabel>
+    // label <elselabel>
+    // <elsePart>
+    // label <endlabel>
+    CondGotoNode *brfalsestmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brfalse);
+    brfalsestmt->SetOpnd(ifstmt.Opnd(), 0);
+    brfalsestmt->SetSrcPos(ifstmt.GetSrcPos());
+   // set stmtfreqs
+    if (GetFuncProfData()) {
+      GetFuncProfData()->CopyStmtFreq(brfalsestmt->GetStmtID(), ifstmt.GetStmtID());
+    }
+    LabelIdx elselabelidx = mirFunc->GetLabelTab()->CreateLabelWithPrefix('s');
+    mirFunc->GetLabelTab()->AddToStringLabelMap(elselabelidx);
+    if (canRaiseBack) {
+      preMeFunc->SetIfLabelCreatedByPreMe(elselabelidx);
+    }
+    PreMeIfInfo *ifInfo = preMeFunc->pmemp->New<PreMeIfInfo>();
+    brfalsestmt->SetOffset(elselabelidx);
+    blk->AddStatement(brfalsestmt);
+    ifInfo->elseLabel = elselabelidx;
+    if (canRaiseBack) {
+      preMeFunc->label2IfInfo.insert(std::make_pair(elselabelidx, ifInfo));
+    }
+
+    blk->AppendStatementsFromBlock(*ifstmt.GetThenPart());
+    bool fallthru_from_then = !OpCodeNoFallThrough(ifstmt.GetThenPart()->GetLast()->GetOpCode());
+    LabelIdx endlabelidx = 0;
+
+    if (fallthru_from_then) {
+      GotoNode *gotostmt = mirModule.CurFuncCodeMemPool()->New<GotoNode>(OP_goto);
+      endlabelidx = mirFunc->GetLabelTab()->CreateLabelWithPrefix('e');
+      mirFunc->GetLabelTab()->AddToStringLabelMap(endlabelidx);
+      if (canRaiseBack) {
+        preMeFunc->SetIfLabelCreatedByPreMe(endlabelidx);
+      }
+      gotostmt->SetOffset(endlabelidx);
+      blk->AddStatement(gotostmt);
+      // set stmtfreqs
+      if (GetFuncProfData()) {
+        GetFuncProfData()->CopyStmtFreq(gotostmt->GetStmtID(), ifstmt.GetThenPart()->GetStmtID());
+      }
+    }
+
+    LabelNode *labstmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+    labstmt->SetLabelIdx(elselabelidx);
+    SrcPosition pos = func->GetMirFunc()->GetScope()->GetScopeEndPos(ifstmt.GetThenPart()->GetSrcPos());
+    labstmt->SetSrcPos(pos);
+    blk->AddStatement(labstmt);
+
+    blk->AppendStatementsFromBlock(*ifstmt.GetElsePart());
+
+    if (fallthru_from_then) {
+      labstmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
+      labstmt->SetLabelIdx(endlabelidx);
+      SrcPosition position = func->GetMirFunc()->GetScope()->GetScopeEndPos(ifstmt.GetElsePart()->GetSrcPos());
+      labstmt->SetSrcPos(position);
+      blk->AddStatement(labstmt);
+      // set stmtfreqs
+      if (GetFuncProfData()) {
+        GetFuncProfData()->CopyStmtFreq(labstmt->GetStmtID(), ifstmt.GetElsePart()->GetStmtID());
+      }
+    }
+    if (endlabelidx == 0) {  // create end label
+      endlabelidx = mirFunc->GetLabelTab()->CreateLabelWithPrefix('e');
+      if (canRaiseBack) {
+        preMeFunc->SetIfLabelCreatedByPreMe(endlabelidx);
+      }
+      LabelNode *endlabelnode = mirbuilder->CreateStmtLabel(endlabelidx);
+      SrcPosition position = func->GetMirFunc()->GetScope()->GetScopeEndPos(ifstmt.GetElsePart()->GetSrcPos());
+      endlabelnode->SetSrcPos(position);
+      blk->AddStatement(endlabelnode);
+      // set stmtfreqs
+      if (GetFuncProfData()) {
+        GetFuncProfData()->CopyStmtFreq(endlabelnode->GetStmtID(), ifstmt.GetStmtID());
+      }
+    }
+    ifInfo->endLabel = endlabelidx;
+  }
+  return blk;
+}
diff --git a/src/mapleall/maple_me/src/preg_renamer.cpp b/src/mapleall/maple_me/src/preg_renamer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..464fe32e0c9aabcbe157307d5214d1585e9e617d
--- /dev/null
+++ b/src/mapleall/maple_me/src/preg_renamer.cpp
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "alias_class.h"
+#include "mir_builder.h"
+#include "me_irmap_build.h"
+#include "union_find.h"
+#include "me_verify.h"
+#include "me_dominance.h"
+#include "me_phase_manager.h"
+#include "preg_renamer.h"
+
+namespace maple {
+void PregRenamer::RunSelf() {
+  // BFS the graph of register phi node;
+  const MapleVector<MeExpr *> &regMeExprTable = meirmap->GetVerst2MeExprTable();
+  MIRPregTable *pregTab = func->GetMirFunc()->GetPregTab();
+  std::vector<bool> firstAppearTable(pregTab->GetPregTable().size());
+  UnionFind unionFind(*mp, regMeExprTable.size());
+  auto *cfg = func->GetCfg();
+  // iterate all the bbs' phi to setup the union
+  for (BB *bb : cfg->GetAllBBs()) {
+    if (bb == nullptr || bb == cfg->GetCommonEntryBB() || bb == cfg->GetCommonExitBB()) {
+      continue;
+    }
+    MapleMap<OStIdx, MePhiNode *> &mePhiList =  bb->GetMePhiList();
+    for (auto it = mePhiList.cbegin(); it != mePhiList.cend(); ++it) {
+      if (!it->second->GetIsLive()) {
+        continue;
+      }
+      OriginalSt *ost = func->GetMeSSATab()->GetOriginalStTable().GetOriginalStFromID(it->first);
+      ASSERT_NOT_NULL(ost);
+      if (!ost->IsPregOst()) { // only handle reg phi
+        continue;
+      }
+      if (ost->GetIndirectLev() != 0) {
+        continue;
+      }
+      MePhiNode *meRegPhi = it->second;
+      size_t vstIdx = meRegPhi->GetLHS()->GetVstIdx();
+      size_t nOpnds = meRegPhi->GetOpnds().size();
+      for (size_t i = 0; i < nOpnds; ++i) {
+        unionFind.Union(vstIdx, meRegPhi->GetOpnd(i)->GetVstIdx());
+      }
+    }
+  }
+  std::map<uint32, std::vector<uint32> > root2childrenMap;
+  for (uint32 i = 0; i < regMeExprTable.size(); ++i) {
+    MeExpr *meExpr = regMeExprTable[i];
+    if (meExpr == nullptr || meExpr->GetMeOp() != kMeOpReg) {
+      continue;
+    }
+    auto *regMeExpr = static_cast<RegMeExpr*>(meExpr);
+    auto *defStmt = regMeExpr->GetDefByMeStmt();
+    if (defStmt != nullptr && defStmt->GetOp() == OP_asm) {
+      continue;  // it could be binded with other regs or vars in asm so keep them in original format
+    }
+    if (regMeExpr->GetRegIdx() < 0) {
+      continue;  // special register
+    }
+    if (PrimitiveType(regMeExpr->GetPrimType()).IsVector()) {
+      // can be removed after mplbe support this
+      continue;
+    }
+    if (regMeExpr->GetOst()->GetIndirectLev() != 0) {
+      continue;
+    }
+    uint32 rootVstIdx = unionFind.Root(i);
+
+    auto mpIt = root2childrenMap.find(rootVstIdx);
+    if (mpIt == root2childrenMap.end()) {
+      std::vector<uint32> vec(1, i);
+      root2childrenMap[rootVstIdx] = vec;
+    } else {
+      std::vector<uint32> &vec = mpIt->second;
+      vec.push_back(i);
+    }
+  }
+  for (auto it = root2childrenMap.begin(); it != root2childrenMap.end(); ++it) {
+    std::vector<uint32> &vec = it->second;
+    bool isIntryOrZerov = false; // in try block or zero version
+    for (uint32 i = 0; i < vec.size(); ++i) {
+      uint32 vstIdx = vec[i];
+      ASSERT(vstIdx < regMeExprTable.size(), "over size");
+      auto *tregMeExpr = static_cast<RegMeExpr*>(regMeExprTable[vstIdx]);
+      if (tregMeExpr->GetDefBy() == kDefByNo ||
+          (tregMeExpr->DefByBB() != nullptr && tregMeExpr->DefByBB()->GetAttributes(kBBAttrIsTry))) {
+        isIntryOrZerov = true;
+        break;
+      }
+    }
+    if (isIntryOrZerov) {
+      continue;
+    }
+
+    if (vec.size() == 1) { // if by itself, make sure it is live
+      uint32 vstIdx = it->first;
+      RegMeExpr *regMeExpr = static_cast<RegMeExpr*>(regMeExprTable[vstIdx]);
+      if (regMeExpr->GetDefBy() == kDefByNo) {
+        continue;  // will not rename if there is no def
+      }
+      if (regMeExpr->GetDefBy() == kDefByPhi) {
+        MePhiNode *defPhi = &regMeExpr->GetDefPhi();
+        if (!defPhi->GetIsLive()) {
+          continue;
+        }
+      } else if (regMeExpr->GetDefBy() == kDefByStmt) {
+        MeStmt *defStmt = regMeExpr->GetDefStmt();
+        if (defStmt == nullptr || !defStmt->GetIsLive()) {
+          continue;
+        }
+      } else if (regMeExpr->GetDefBy() == kDefByMustDef) {
+        MustDefMeNode *mustDef = &regMeExpr->GetDefMustDef();
+        if (!mustDef->GetIsLive()) {
+          continue;
+        }
+      } else {
+        continue;
+      }
+    }
+
+    // get all the nodes in candidates the same register
+    auto *regMeexpr = static_cast<RegMeExpr*>(regMeExprTable[it->first]);
+    PregIdx oldPredIdx = regMeexpr->GetRegIdx();
+    ASSERT(static_cast<uint32>(oldPredIdx) < firstAppearTable.size(), "oversize ");
+    if (!firstAppearTable[static_cast<size_t>(oldPredIdx)]) {
+      // use the previous register
+      firstAppearTable[static_cast<size_t>(oldPredIdx)] = true;
+      continue;
+    }
+    PregIdx newPregIdx = pregTab->ClonePreg(*pregTab->PregFromPregIdx(oldPredIdx));
+    OriginalStTable &ostTab = func->GetMeSSATab()->GetOriginalStTable();
+    // no need to find here, because the newPregIdx is the newest
+    OriginalSt *newOst = ostTab.CreatePregOriginalSt(newPregIdx, func->GetMirFunc()->GetPuidx());
+    MIRPreg *oldPreg = pregTab->PregFromPregIdx(oldPredIdx);
+    if (oldPreg->GetOp() != OP_undef) {
+      // carry over fields in MIRPreg to support rematerialization
+      MIRPreg *newPreg = pregTab->PregFromPregIdx(newPregIdx);
+      newPreg->SetOp(oldPreg->GetOp());
+      newPreg->rematInfo = oldPreg->rematInfo;
+      newPreg->fieldID = oldPreg->fieldID;
+    }
+    if (DEBUGFUNC(func)) {
+      LogInfo::MapleLogger() << "%" << pregTab->PregFromPregIdx(regMeexpr->GetRegIdx())->GetPregNo();
+      LogInfo::MapleLogger() << " renamed to %" << pregTab->PregFromPregIdx(newPregIdx)->GetPregNo() << std::endl;
+    }
+    // reneme all the register
+    for (uint32 i = 0; i < vec.size(); ++i) {
+      auto *canRegNode =  static_cast<RegMeExpr*>(regMeExprTable[vec[i]]);
+      canRegNode->SetOst(newOst);  // rename it to a new register
+      if (canRegNode->IsDefByPhi()) {
+        // update philist key with new ost index
+        MePhiNode &phiNode = canRegNode->GetDefPhi();
+        BB *bb = phiNode.GetDefBB();
+        OriginalSt *oldOst = ostTab.FindOrCreatePregOriginalSt(oldPredIdx, func->GetMirFunc()->GetPuidx());
+        bb->GetMePhiList().erase(oldOst->GetIndex());
+        bb->GetMePhiList().emplace(newOst->GetIndex(), &phiNode);
+      }
+    }
+  }
+}
+
+void MEPregRename::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<MEIRMapBuild>();
+  aDep.SetPreservedAll();
+}
+
+bool MEPregRename::PhaseRun(maple::MeFunction &f) {
+  if (f.HasWriteInputAsmNode()) {
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "  == " << PhaseName() << " skipped due to inline asm with wirting input operand\n";
+    }
+    return false;
+  }
+  auto *irMap = GET_ANALYSIS(MEIRMapBuild, f);
+  PregRenamer pregRenamer(GetPhaseMemPool(), &f, irMap);
+  pregRenamer.RunSelf();
+  if (DEBUGFUNC_NEWPM(f)) {
+    LogInfo::MapleLogger() << "------------after pregrename:-------------------\n";
+    f.Dump(false);
+  }
+  if (MeOption::meVerify) {
+    GetAnalysisInfoHook()->ForceEraseAnalysisPhase(f.GetUniqueID(), &MEDominance::id);
+    auto *dom = FORCE_EXEC(MEDominance)->GetDomResult();
+    ASSERT(dom != nullptr, "dominance phase has problem");
+    MeVerify verify(f);
+    for (auto &bb : f.GetCfg()->GetAllBBs()) {
+      if (bb == nullptr) {
+        continue;
+      }
+      verify.VerifyPhiNode(*bb, *dom);
+    }
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/prop.cpp b/src/mapleall/maple_me/src/prop.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2bd15f5c98c8ba12e7bb8087aa929cc82b4a359e
--- /dev/null
+++ b/src/mapleall/maple_me/src/prop.cpp
@@ -0,0 +1,1387 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "prop.h"
+#include "me_irmap.h"
+#include "dominance.h"
+
+#define JAVALANG (mirModule.IsJavaModule())
+
+using namespace maple;
+
+static const uint32 kPropTreeLevel = 15;   // tree height threshold to increase to
+static const uint32 kTreeNodeLimit = 5000; // tree node threshold to decide propagatable.
+
+namespace maple {
+#ifdef USE_ARM32_MACRO
+static constexpr uint32 kMaxRegParamNum = 4;
+#else
+static constexpr uint32 kMaxRegParamNum = 8;
+#endif
+
+Prop::Prop(IRMap &irMap, Dominance &dom, Dominance &pdom, MemPool &memPool, uint32 bbvecsize, const PropConfig &config,
+           uint32 limit)
+    : propLimit(limit),
+      dom(dom),
+      pdom(pdom),
+      irMap(irMap),
+      ssaTab(irMap.GetSSATab()),
+      mirModule(irMap.GetSSATab().GetModule()),
+      propMapAlloc(&memPool),
+      vstLiveStackVec(propMapAlloc.Adapter()),
+      bbVisited(bbvecsize, false),
+      config(config),
+      candsForSSAUpdate() {
+  const MapleVector<OriginalSt *> &originalStVec = ssaTab.GetOriginalStTable().GetOriginalStVector();
+  vstLiveStackVec.resize(originalStVec.size());
+  for (size_t i = 1; i < originalStVec.size(); ++i) {
+    OriginalSt *ost = originalStVec[i];
+    ASSERT(ost->GetIndex() == i, "inconsistent originalst_table index");
+    MapleStack<MeExpr *> *verstStack = propMapAlloc.GetMemPool()->New<MapleStack<MeExpr *>>(propMapAlloc.Adapter());
+    MeExpr *expr = irMap.GetMeExpr(ost->GetZeroVersionIndex());
+    if (expr != nullptr) {
+      verstStack->push(expr);
+    }
+    vstLiveStackVec[i] = verstStack;
+  }
+}
+
+void Prop::ReplaceVstLiveStackTop(size_t ostIdx, MeExpr &newTopExpr) {
+  auto &vstStack = vstLiveStackVec[ostIdx];
+  ASSERT(!vstStack->empty(), "Cannot replace top element of an empty stack!");
+  vstStack->pop();
+  vstStack->push(&newTopExpr);
+}
+
+void Prop::PropUpdateDef(MeExpr &meExpr) {
+  ASSERT(meExpr.GetMeOp() == kMeOpVar || meExpr.GetMeOp() == kMeOpReg, "meExpr error");
+  OStIdx ostIdx;
+  if (meExpr.GetMeOp() == kMeOpVar) {
+    ostIdx = static_cast<VarMeExpr&>(meExpr).GetOstIdx();
+  } else {
+    auto &regExpr = static_cast<RegMeExpr&>(meExpr);
+    if (!regExpr.IsNormalReg()) {
+      return;
+    }
+    ostIdx = regExpr.GetOstIdx();
+  }
+  ReplaceVstLiveStackTop(ostIdx.GetIdx(), meExpr);
+}
+
+void Prop::PropUpdateChiListDef(const MapleMap<OStIdx, ChiMeNode*> &chiList) {
+  for (auto it = chiList.begin(); it != chiList.end(); ++it) {
+    PropUpdateDef(*static_cast<VarMeExpr*>(it->second->GetLHS()));
+  }
+}
+
+void Prop::PropUpdateMustDefList(MeStmt *mestmt) {
+  MapleVector<MustDefMeNode> *mustDefList = mestmt->GetMustDefList();
+  for (auto &node : utils::ToRef(mustDefList)) {
+    MeExpr *melhs = node.GetLHS();
+    PropUpdateDef(*melhs);
+  }
+}
+
+void Prop::CollectSubVarMeExpr(const MeExpr &meExpr, std::vector<const MeExpr*> &varVec) const {
+  switch (meExpr.GetMeOp()) {
+    case kMeOpReg:
+    case kMeOpVar:
+      varVec.push_back(&meExpr);
+      break;
+    case kMeOpIvar: {
+      auto &ivarMeExpr = static_cast<const IvarMeExpr&>(meExpr);
+      for (auto *mu : ivarMeExpr.GetMuList()) {
+        if (mu != nullptr) {
+          varVec.push_back(mu);
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+// check at the current statement, if the version symbol is consistent with its definition in the top of the stack
+// for example:
+// x1 <- a1 + b1;
+// a2 <-
+//  <-x1
+// the version of progation of x1 is a1, but the top of the stack of symbol a is a2, so it's not consistent
+// warning: I suppose the vector vervec is on the stack, otherwise would cause memory leak
+bool Prop::IsVersionConsistent(const std::vector<const MeExpr*> &vstVec,
+                               const MapleVector<MapleStack<MeExpr *>*> &vstLiveStack) const {
+  for (auto it = vstVec.begin(); it != vstVec.end(); ++it) {
+    // iterate each cur defintion of related symbols of rhs, check the version
+    const MeExpr *subExpr = *it;
+    CHECK_FATAL(subExpr->GetMeOp() == kMeOpVar || subExpr->GetMeOp() == kMeOpReg, "error: sub expr error");
+    uint32 stackIdx = static_cast<const ScalarMeExpr *>(subExpr)->GetOstIdx();
+    auto *pStack = vstLiveStack.at(stackIdx);
+    ASSERT(!pStack->empty(), "When enter BB, one element will be pushed to top!");
+    if (pStack->top() == nullptr) {
+      // no definition so far go ahead
+      continue;
+    }
+    MeExpr *curDef = pStack->top();
+    CHECK_FATAL(curDef->GetMeOp() == kMeOpVar || curDef->GetMeOp() == kMeOpReg, "error: cur def error");
+    if (subExpr != curDef) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool Prop::IvarIsFinalField(const IvarMeExpr &ivarMeExpr) const {
+  if (!config.propagateFinalIloadRef) {
+    return false;
+  }
+  if (ivarMeExpr.GetFieldID() == 0) {
+    return false;
+  }
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr.GetTyIdx());
+  ASSERT(ty->GetKind() == kTypePointer, "IvarIsFinalField: pointer type expected");
+  MIRType *pointedType = static_cast<MIRPtrType*>(ty)->GetPointedType();
+  auto *structType = static_cast<MIRStructType*>(pointedType);
+  FieldID fieldID = ivarMeExpr.GetFieldID();
+  return structType->IsFieldFinal(fieldID) && !structType->IsFieldRCUnownedRef(fieldID);
+}
+
+// if x contains operations that has no accurate inverse, return -1; also return
+// -1 if x contains any scalar other than x that is not current version;
+// otherwise, the return value is the number of occurrences of scalar.
+int32 Prop::InvertibleOccurrences(ScalarMeExpr *scalar, MeExpr *x) {
+  switch (x->GetMeOp()) {
+    case kMeOpConst:
+      return 0;
+    case kMeOpReg: {
+      RegMeExpr *regreadx = static_cast<RegMeExpr *>(x);
+      if (regreadx->GetRegIdx() < 0) {
+        return -1;
+      }
+    }
+      // fall thru
+      [[clang::fallthrough]];
+    case kMeOpVar: {
+      if (x == scalar) {
+        return 1;
+      }
+      if (Propagatable(x, nullptr, false, false, nullptr) == kPropYes) {
+        return 0;
+      }
+      return -1;
+    }
+    case kMeOpOp: {
+      if (!IsPrimitiveInteger(x->GetPrimType())) {
+        return -1;
+      }
+      if (x->GetOp() == OP_neg) {
+        return InvertibleOccurrences(scalar, x->GetOpnd(0));
+      }
+      if (x->GetOp() == OP_add || x->GetOp() == OP_sub) {
+        int32 invertibleOccs0 = InvertibleOccurrences(scalar, x->GetOpnd(0));
+        if (invertibleOccs0 == -1) {
+          return -1;
+        }
+        int32 invertibleOccs1 = InvertibleOccurrences(scalar, x->GetOpnd(1));
+        if (invertibleOccs1 == -1 || (invertibleOccs0 + invertibleOccs1 > 1)) {
+          return -1;
+        }
+        return invertibleOccs0 + invertibleOccs1;
+      }
+    }
+      // fall thru
+      [[clang::fallthrough]];
+    default:
+      return -1;
+  }
+}
+
+// return true if scalar can be expressed as a function of current version cur
+bool Prop::IsFunctionOfCurVersion(ScalarMeExpr *scalar, const ScalarMeExpr *cur) {
+  if (!config.propagateWithInverse) {
+    return false;
+  }
+  if (cur == nullptr || cur->GetDefBy() != kDefByStmt) {
+    return false;
+  }
+  AssignMeStmt *ass = static_cast<AssignMeStmt *>(cur->GetDefStmt());
+  return InvertibleOccurrences(scalar, ass->GetRHS()) == 1;
+}
+
+static void Calc(const MeExpr *x, uint32 &count) {
+  count++;
+  for (uint32 i = 0; i < x->GetNumOpnds(); i++) {
+    Calc(x->GetOpnd(i), count);
+  }
+}
+
+// check if the expression x can legally forward-substitute the variable that it
+// was assigned to; x is from bb; if checkInverse is true and there is live range
+// overlap for a scalar within x, do the additional check of whether the scalar's
+// previous version can be expressed in terms of its current version.
+// propagatingScalar is used only if checkInverse is true; it gives the
+// propagating scalar so we can avoid doing the checkInverse checking for it.
+Propagatability Prop::Propagatable(MeExpr *x, BB *fromBB, bool atParm, bool checkInverse,
+                                   ScalarMeExpr *propagatingScalar) {
+  uint32 count = 0;
+  Calc(x, count);
+  if (count > kTreeNodeLimit) {
+    return kPropNo;
+  }
+  MeExprOp meOp = x->GetMeOp();
+  switch (meOp) {
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpAddroflabel:
+    case kMeOpConst:
+    case kMeOpSizeoftype:
+      return kPropYes;
+    case kMeOpGcmalloc:
+      return kPropNo;
+    case kMeOpNary: {
+      if (x->GetOp() == OP_intrinsicop || x->GetOp() == OP_intrinsicopwithtype) {
+        return kPropNo;
+      }
+      NaryMeExpr *narymeexpr = static_cast<NaryMeExpr *>(x);
+      Propagatability propmin = kPropYes;
+      for (uint32 i = 0; i < narymeexpr->GetNumOpnds(); i++) {
+        Propagatability prop = Propagatable(narymeexpr->GetOpnd(i), fromBB, false, checkInverse, propagatingScalar);
+        if (prop == kPropNo) {
+          return kPropNo;
+        }
+        propmin = std::min(propmin, prop);
+      }
+      return propmin;
+    }
+    case kMeOpReg: {
+      RegMeExpr *regRead = static_cast<RegMeExpr*>(x);
+      if (regRead->GetRegIdx() < 0) {
+        return kPropNo;
+      }
+      // get the current definition version
+      std::vector<const MeExpr*> regReadVec;
+      CollectSubVarMeExpr(*x, regReadVec);
+      if (IsVersionConsistent(regReadVec, vstLiveStackVec)) {
+        return kPropYes;
+      } else if (checkInverse && regRead->GetOst() != propagatingScalar->GetOst()) {
+        auto &pstack = vstLiveStackVec[regRead->GetOst()->GetIndex()];
+        return IsFunctionOfCurVersion(regRead, static_cast<ScalarMeExpr *>(pstack->top())) ?
+            kPropOnlyWithInverse : kPropNo;
+      } else {
+        return kPropNo;
+      }
+    }
+    case kMeOpVar: {
+      VarMeExpr *varMeExpr = static_cast<VarMeExpr*>(x);
+      if (varMeExpr->IsVolatile()) {
+        return kPropNo;
+      }
+      const MIRSymbol *st = varMeExpr->GetOst()->GetMIRSymbol();
+      if (!config.propagateGlobalRef && st->IsGlobal() && !st->IsFinal() && !st->IgnoreRC()) {
+        return kPropNo;
+      }
+      if (LocalToDifferentPU(st->GetStIdx(), *fromBB)) {
+        return kPropNo;
+      }
+      // for <void *>, stop prop here, and back-substitution will use declared var to replace this return value.
+      // <void *> has no effective type, we will use the type as declared type var assigned by this return value.
+      if (varMeExpr->GetDefBy() == kDefByMustDef && (varMeExpr->GetType()->GetPrimType() == PTY_agg ||
+                                                     varMeExpr->GetType()->IsVoidPointer())) {
+        return kPropNo;  // keep temps for storing call return values single use
+      }
+      // get the current definition version
+      std::vector<const MeExpr*> varMeExprVec;
+      CollectSubVarMeExpr(*x, varMeExprVec);
+      if (IsVersionConsistent(varMeExprVec, vstLiveStackVec)) {
+        return kPropYes;
+      } else if (checkInverse && varMeExpr->GetOst() != propagatingScalar->GetOst() &&
+                 varMeExpr->GetType()->GetKind() != kTypeBitField) {
+        auto &pstack = vstLiveStackVec[varMeExpr->GetOst()->GetIndex()];
+        return IsFunctionOfCurVersion(varMeExpr, static_cast<ScalarMeExpr *>(pstack->top())) ?
+            kPropOnlyWithInverse : kPropNo;
+      } else {
+        return kPropNo;
+      }
+    }
+    case kMeOpIvar: {
+      IvarMeExpr *ivarMeExpr = static_cast<IvarMeExpr*>(x);
+      if (!IvarIsFinalField(*ivarMeExpr) &&
+          !GetTypeFromTyIdx(ivarMeExpr->GetTyIdx()).PointsToConstString()) {
+        if ((!config.propagateIloadRef || (config.propagateIloadRefNonParm && atParm)) &&
+            ivarMeExpr->GetPrimType() == PTY_ref) {
+          return kPropNo;
+        }
+      }
+      ASSERT_NOT_NULL(curBB);
+      if (fromBB->GetAttributes(kBBAttrIsTry) && !curBB->GetAttributes(kBBAttrIsTry)) {
+        return kPropNo;
+      }
+      if (ivarMeExpr->IsVolatile() || ivarMeExpr->IsRCWeak()) {
+        return kPropNo;
+      }
+      Propagatability prop0 = Propagatable(ivarMeExpr->GetBase(), fromBB, false, false, nullptr);
+      if (prop0 == kPropNo) {
+        return kPropNo;
+      }
+      // get the current definition version
+      std::vector<const MeExpr*> varMeExprVec;
+      CollectSubVarMeExpr(*x, varMeExprVec);
+      return IsVersionConsistent(varMeExprVec, vstLiveStackVec) ? prop0 : kPropNo;
+    }
+    case kMeOpOp: {
+      if (kOpcodeInfo.NotPure(x->GetOp())) {
+        return kPropNo;
+      }
+      if (x->GetOp() == OP_gcmallocjarray) {
+        return kPropNo;
+      }
+      OpMeExpr *meopexpr = static_cast<OpMeExpr *>(x);
+      MeExpr *opnd0 = meopexpr->GetOpnd(0);
+      Propagatability prop0 = Propagatable(opnd0, fromBB, false, checkInverse, propagatingScalar);
+      if (prop0 == kPropNo) {
+        return kPropNo;
+      }
+      MeExpr *opnd1 = meopexpr->GetOpnd(1);
+      if (opnd1 == nullptr) {
+        return prop0;
+      }
+      Propagatability prop1 = Propagatable(opnd1, fromBB, false, checkInverse, propagatingScalar);
+      if (prop1 == kPropNo) {
+        return kPropNo;
+      }
+      prop1 = std::min(prop0, prop1);
+      MeExpr *opnd2 = meopexpr->GetOpnd(2);
+      if (opnd2 == nullptr) {
+        return prop1;
+      }
+      Propagatability prop2 = Propagatable(opnd2, fromBB, false, checkInverse, propagatingScalar);
+      return std::min(prop1, prop2);
+    }
+    case kMeOpConststr:
+    case kMeOpConststr16: {
+      if (mirModule.IsCModule()) {
+        return kPropNo;
+      }
+      return kPropYes;
+    }
+    default: {
+      CHECK_FATAL(false, "MeProp::Propagatable() NYI");
+      return kPropNo;
+    }
+  }
+}
+
+// Expression x contains v; form and return the inverse of this expression based
+// on the current version of v by descending x; formingExp is the tree being
+// constructed during the descent; x must contain one and only one occurrence of
+// v; work is done when it reaches the v node inside x.
+MeExpr *Prop::FormInverse(ScalarMeExpr *v, MeExpr *x, MeExpr *formingExp) {
+  MeExpr *newx = nullptr;
+  switch (x->GetMeOp()) {
+    case kMeOpVar:
+    case kMeOpReg: {
+      if (x == v) {
+        return formingExp;
+      };
+      return x;
+    }
+    case kMeOpOp: {
+      OpMeExpr *opx = static_cast<OpMeExpr *>(x);
+      if (opx->GetOp() == OP_neg) {  // negate formingExp and recurse down
+        OpMeExpr negx(-1, OP_neg, opx->GetPrimType(), formingExp);
+        newx = irMap.HashMeExpr(negx);
+        return FormInverse(v, opx->GetOpnd(0), newx);
+      }
+      if (opx->GetOp() == OP_add) {  // 2 patterns depending on which side contains v
+        OpMeExpr subx(-1, OP_sub, opx->GetPrimType(), 2);
+        subx.SetOpnd(0, formingExp);
+        if (InvertibleOccurrences(v, opx->GetOpnd(0)) == 0) {
+          // ( ..i2.. ) = y + ( ..i1.. ) becomes  ( ..i2.. ) - y = ( ..i1.. )
+          // form formingExp - opx->GetOpnd(0)
+          subx.SetOpnd(1, opx->GetOpnd(0));
+          subx.SetHasAddressValue();
+          newx = irMap.HashMeExpr(subx);
+          return FormInverse(v, opx->GetOpnd(1), newx);
+        } else {
+          // ( ..i2.. ) = ( ..i1.. ) + y  becomes  ( ..i2.. ) - y = ( ..i1.. )
+          // form formingExp - opx->GetOpnd(1)
+          subx.SetOpnd(1, opx->GetOpnd(1));
+          subx.SetHasAddressValue();
+          newx = irMap.HashMeExpr(subx);
+          return FormInverse(v, opx->GetOpnd(0), newx);
+        }
+      }
+      if (opx->GetOp() == OP_sub) {
+        if (InvertibleOccurrences(v, opx->GetOpnd(0)) == 0) {
+          // ( ..i2.. ) = y - ( ..i1.. ) becomes y - ( ..i2.. ) = ( ..i1.. )
+          // form opx->GetOpnd(0) - formingExp
+          OpMeExpr subx(-1, OP_sub, opx->GetPrimType(), 2);
+          subx.SetOpnd(0, opx->GetOpnd(0));
+          subx.SetOpnd(1, formingExp);
+          subx.SetHasAddressValue();
+          newx = irMap.HashMeExpr(subx);
+          return FormInverse(v, opx->GetOpnd(1), newx);
+        } else {
+          // ( ..i2.. ) = ( ..i1.. ) - y  becomes  ( ..i2.. ) + y = ( ..i1.. )
+          // form formingExp + opx->GetOpnd(1)
+          OpMeExpr addx(-1, OP_add, opx->GetPrimType(), 2);
+          addx.SetOpnd(0, formingExp);
+          addx.SetOpnd(1, opx->GetOpnd(1));
+          addx.SetHasAddressValue();
+          newx = irMap.HashMeExpr(addx);
+          return FormInverse(v, opx->GetOpnd(0), newx);
+        }
+      }
+      // fall-thru
+    }
+      [[clang::fallthrough]];
+    default:
+      CHECK_FATAL(false, "FormInverse: should not see these nodes");
+  }
+}
+
+// recurse down the expression tree x; at the scalar whose version is different
+// from the current version, replace it by an expression corresponding to the
+// inverse of how its current version is computed from it; if there is no change
+// return NULL; if there is change, rehash on the way back
+MeExpr *Prop::RehashUsingInverse(MeExpr *x) {
+  switch (x->GetMeOp()) {
+    case kMeOpVar:
+    case kMeOpReg: {
+      ScalarMeExpr *scalar = static_cast<ScalarMeExpr *>(x);
+      auto &pstack = vstLiveStackVec[scalar->GetOst()->GetIndex()];
+      if (pstack == nullptr) {
+        return nullptr;
+      }
+      ASSERT(!pstack->empty(), "When enter BB, one element will be pushed to top!");
+      if (pstack->top() == nullptr || pstack->top() == scalar) {
+        return nullptr;
+      }
+      ScalarMeExpr *curScalar = static_cast<ScalarMeExpr *>(pstack->top());
+      return FormInverse(scalar, curScalar->GetDefStmt()->GetRHS(), curScalar);
+    }
+    case kMeOpIvar: {
+      IvarMeExpr *ivarx = static_cast<IvarMeExpr *>(x);
+      MeExpr *result = RehashUsingInverse(ivarx->GetBase());
+      if (result != nullptr) {
+        IvarMeExpr newivarx(&irMap.GetIRMapAlloc(), -1, ivarx->GetPrimType(), ivarx->GetTyIdx(), ivarx->GetFieldID());
+        newivarx.SetOffset(ivarx->GetOffset());
+        newivarx.SetBase(result);
+        newivarx.SetMuList(ivarx->GetMuList());
+        return irMap.HashMeExpr(newivarx);
+      }
+      return nullptr;
+    }
+    case kMeOpOp: {
+      OpMeExpr *opx = static_cast<OpMeExpr *>(x);
+      MeExpr *res0 = RehashUsingInverse(opx->GetOpnd(0));
+      MeExpr *res1 = nullptr;
+      MeExpr *res2 = nullptr;
+      if (opx->GetNumOpnds() > 1) {
+        res1 = RehashUsingInverse(opx->GetOpnd(1));
+        if (opx->GetNumOpnds() > 2) {
+          res2 = RehashUsingInverse(opx->GetOpnd(2));
+        }
+      }
+      if (res0 == nullptr && res1 == nullptr && res2 == nullptr) {
+        return nullptr;
+      }
+      OpMeExpr newopx(-1, opx->GetOp(), opx->GetPrimType(), opx->GetNumOpnds());
+      newopx.SetOpndType(opx->GetOpndType());
+      newopx.SetBitsOffSet(opx->GetBitsOffSet());
+      newopx.SetBitsSize(opx->GetBitsSize());
+      newopx.SetTyIdx(opx->GetTyIdx());
+      newopx.SetFieldID(opx->GetFieldID());
+      if (res0 != nullptr) {
+        newopx.SetOpnd(0, res0);
+      } else {
+        newopx.SetOpnd(0, opx->GetOpnd(0));
+      }
+      if (opx->GetNumOpnds() > 1) {
+        if (res1 != nullptr) {
+          newopx.SetOpnd(1, res1);
+        } else {
+          newopx.SetOpnd(1, opx->GetOpnd(1));
+        }
+        if (opx->GetNumOpnds() > 2) {
+          if (res1 != nullptr) {
+            newopx.SetOpnd(2, res2);
+          } else {
+            newopx.SetOpnd(2, opx->GetOpnd(2));
+          }
+        }
+      }
+      newopx.SetHasAddressValue();
+      return irMap.HashMeExpr(newopx);
+    }
+    case kMeOpNary: {
+      NaryMeExpr *naryx = static_cast<NaryMeExpr *>(x);
+      std::vector<MeExpr *> results(naryx->GetNumOpnds(), nullptr);
+      bool needRehash = false;
+      uint32 i;
+      for (i = 0; i < naryx->GetNumOpnds(); i++) {
+        results[i] = RehashUsingInverse(naryx->GetOpnd(i));
+        if (results[i] != nullptr) {
+          needRehash = true;
+        }
+      }
+      if (!needRehash) {
+        return nullptr;
+      }
+      NaryMeExpr newnaryx(&propMapAlloc, -1, naryx->GetOp(), naryx->GetPrimType(),
+                          naryx->GetNumOpnds(), naryx->GetTyIdx(), naryx->GetIntrinsic(), naryx->GetBoundCheck());
+      for (i = 0; i < naryx->GetNumOpnds(); i++) {
+        if (results[i] != nullptr) {
+          newnaryx.PushOpnd(results[i]);
+        } else {
+          newnaryx.PushOpnd(naryx->GetOpnd(i));
+        }
+      }
+      return irMap.HashMeExpr(newnaryx);
+    }
+    default:
+      return nullptr;
+  }
+}
+
+// if lhs is smaller than rhs, insert operation to simulate the truncation
+// effect of rhs being stored into lhs; otherwise, just return rhs
+MeExpr *Prop::CheckTruncation(MeExpr *lhs, MeExpr *rhs) const {
+  if (JAVALANG || !IsPrimitiveInteger(rhs->GetPrimType())) {
+    return rhs;
+  }
+  TyIdx lhsTyIdx(0);
+  MIRType *lhsTy = nullptr;
+  if (lhs->GetMeOp() == kMeOpVar) {
+    VarMeExpr *varx = static_cast<VarMeExpr *>(lhs);
+    lhsTyIdx = varx->GetOst()->GetTyIdx();
+    lhsTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx);
+  } else if (lhs->GetMeOp() == kMeOpIvar) {
+    IvarMeExpr *ivarx = static_cast<IvarMeExpr *>(lhs);
+    MIRPtrType *ptType = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarx->GetTyIdx()));
+    lhsTyIdx = ptType->GetPointedTyIdx();
+    lhsTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx);
+    if (ivarx->GetFieldID() != 0) {
+      lhsTy = static_cast<MIRStructType *>(lhsTy)->GetFieldType(ivarx->GetFieldID());
+    }
+  } else {
+    return rhs;
+  }
+  if (lhsTy->GetKind() == kTypeBitField) {
+    MIRBitFieldType *bitfieldTy = static_cast<MIRBitFieldType *>(lhsTy);
+    if (GetPrimTypeBitSize(rhs->GetPrimType()) <= bitfieldTy->GetFieldSize()) {
+      return rhs;
+    }
+    // insert OP_zext or OP_sext
+    Opcode extOp = IsSignedInteger(lhsTy->GetPrimType()) ? OP_sext : OP_zext;
+    PrimType newPrimType = PTY_u32;
+    if (bitfieldTy->GetFieldSize() <= 32) {
+      if (IsSignedInteger(lhsTy->GetPrimType())) {
+        newPrimType = PTY_i32;
+      }
+    } else {
+      if (IsSignedInteger(lhsTy->GetPrimType())) {
+        newPrimType = PTY_i64;
+      } else {
+        newPrimType = PTY_u64;
+      }
+    }
+    auto extExpr = std::make_unique<OpMeExpr>(-1, extOp, newPrimType, 1);
+    extExpr->SetBitsSize(bitfieldTy->GetFieldSize());
+    extExpr->SetOpnd(0, rhs);
+    if (lhsTy->GetPrimType() != newPrimType) {
+      // need another z/sext to cvt explicitly
+      // Example : bitfield is i64 : 22
+      // first cvt => sext i32 22 (bitfield)
+      // second cvt => sext i64 22 (sext i32 22 (bitfield))
+      MeExpr *hashedExtExpr = irMap.HashMeExpr(*extExpr);
+      extExpr = std::make_unique<OpMeExpr>(-1, extOp, lhsTy->GetPrimType(), 1);
+      extExpr->SetBitsSize(bitfieldTy->GetFieldSize());
+      extExpr->SetOpnd(0, hashedExtExpr);
+    }
+    auto *simplifiedExpr = irMap.SimplifyOpMeExpr(extExpr.get());
+    return simplifiedExpr != nullptr ? simplifiedExpr : irMap.HashMeExpr(*extExpr);
+  }
+  if (IsPrimitiveInteger(lhsTy->GetPrimType()) &&
+      lhsTy->GetPrimType() != PTY_ptr && lhsTy->GetPrimType() != PTY_ref) {
+    if (GetPrimTypeSize(lhsTy->GetPrimType()) < GetPrimTypeSize(GetRegPrimType(rhs->GetPrimType()))) {
+      if (GetPrimTypeSize(lhsTy->GetPrimType()) >= 4) {
+        return irMap.CreateMeExprTypeCvt(lhsTy->GetPrimType(), rhs->GetPrimType(), *rhs);
+      } else {
+        Opcode extOp = IsSignedInteger(lhsTy->GetPrimType()) ? OP_sext : OP_zext;
+        PrimType newPrimType = PTY_u32;
+        if (IsSignedInteger(lhsTy->GetPrimType())) {
+          newPrimType = PTY_i32;
+        }
+        OpMeExpr opmeexpr(-1, extOp, newPrimType, 1);
+        opmeexpr.SetBitsSize(static_cast<uint8>(GetPrimTypeSize(lhsTy->GetPrimType()) * 8));
+        opmeexpr.SetOpnd(0, rhs);
+        auto *simplifiedExpr = irMap.SimplifyOpMeExpr(&opmeexpr);
+        return simplifiedExpr != nullptr ? simplifiedExpr : irMap.HashMeExpr(opmeexpr);
+      }
+    } else if (GetPrimTypeSize(lhsTy->GetPrimType()) == GetPrimTypeSize(rhs->GetPrimType()) &&
+               IsSignedInteger(lhsTy->GetPrimType()) != IsSignedInteger(rhs->GetPrimType())) {
+      // need to add a cvt
+      return irMap.CreateMeExprTypeCvt(lhsTy->GetPrimType(), rhs->GetPrimType(), *rhs);
+    }
+  }
+  // if lhs is function pointer and rhs is not, insert a retype
+  if (lhsTy->GetKind() == kTypePointer) {
+    MIRPtrType *lhsPtrType = static_cast<MIRPtrType *>(lhsTy);
+    if (lhsPtrType->GetPointedType()->GetKind() == kTypeFunction) {
+      bool needRetype = true;
+      MIRType *rhsTy = nullptr;
+      if (rhs->GetMeOp() == kMeOpVar) {
+        VarMeExpr *rhsvarx = static_cast<VarMeExpr *>(rhs);
+        rhsTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(rhsvarx->GetOst()->GetTyIdx());
+      } else if (rhs->GetMeOp() == kMeOpIvar) {
+        IvarMeExpr *rhsivarx = static_cast<IvarMeExpr *>(rhs);
+        MIRPtrType *rhsPtrType =
+            static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(rhsivarx->GetTyIdx()));
+        rhsTy = rhsPtrType->GetPointedType();
+        if (rhsivarx->GetFieldID() != 0) {
+          rhsTy = static_cast<MIRStructType *>(rhsTy)->GetFieldType(rhsivarx->GetFieldID());
+        }
+      }
+      if (rhsTy != nullptr && rhsTy == lhsPtrType) {
+        needRetype = false;
+      }
+      if (needRetype) {
+        OpMeExpr opmeexpr(-1, OP_retype, lhsPtrType->GetPrimType(), 1);
+        opmeexpr.SetTyIdx(lhsPtrType->GetTypeIndex());
+        opmeexpr.SetOpnd(0, rhs);
+        auto *simplifiedExpr = irMap.SimplifyOpMeExpr(&opmeexpr);
+        return simplifiedExpr != nullptr ? simplifiedExpr : irMap.HashMeExpr(opmeexpr);
+      }
+    }
+  }
+  return rhs;
+}
+
+MeExpr &Prop::TryPropUnionVar(VarMeExpr &var) {
+  if (!IsPrimitiveInteger(var.GetPrimType())) {
+    return var;
+  }
+  MeStmt *defStmt = var.GetDefByMeStmt();
+  CHECK_NULL_FATAL(defStmt);
+  MeExpr *lhs = defStmt->GetLHS();
+  if (!lhs || !IsPrimitiveInteger(lhs->GetPrimType())) {
+    return var;
+  }
+  auto *realDef = static_cast<VarMeExpr*>(lhs);
+  if (realDef->GetOst()->GetMIRSymbol() != var.GetOst()->GetMIRSymbol()) {
+    return var;
+  }
+  auto *topType = static_cast<MIRStructType*>(var.GetOst()->GetMIRSymbol()->GetType());
+  // check if is covered by def
+  auto defStart = topType->GetBitOffsetFromBaseAddr(realDef->GetFieldID());
+  auto useStart = topType->GetBitOffsetFromBaseAddr(var.GetFieldID());
+  auto *defFieldType = topType->GetFieldType(realDef->GetFieldID());
+  auto *useFieldType = topType->GetFieldType(var.GetFieldID());
+
+  if (!defFieldType->IsScalarType() || !useFieldType->IsScalarType()) {
+    return var;
+  }
+
+  auto defSize = defFieldType->GetSize() * CHAR_BIT;
+  auto useSize = useFieldType->GetSize() * CHAR_BIT;
+
+  if (MeOption::IsBigEndian()) {
+    auto unionSize = static_cast<int64>(topType->GetSize()) * CHAR_BIT;
+    defStart = unionSize - (static_cast<int64>(defSize) + defStart);
+    useStart = unionSize - (static_cast<int64>(useSize) + useStart);
+  }
+
+  if ((useStart < defStart) || (static_cast<uint64>(defStart) + defSize < static_cast<uint64>(useStart) + useSize)) {
+    return var;
+  }
+  OpMeExpr extr(kInvalidExprID, OP_extractbits, topType->GetFieldType(var.GetFieldID())->GetPrimType(), lhs);
+  extr.SetBitsOffSet(static_cast<uint8>(useStart - defStart));
+  extr.SetBitsSize(static_cast<uint8>(useSize));
+  auto *hashed = irMap.HashMeExpr(extr);
+  if (hashed->GetPrimType() != var.GetPrimType()) {
+    hashed = irMap.CreateMeExprTypeCvt(var.GetPrimType(), hashed->GetPrimType(), *hashed);
+  }
+  return *hashed;
+}
+
+// return varMeExpr itself if no propagation opportunity
+MeExpr &Prop::PropVar(VarMeExpr &varMeExpr, bool atParm, bool checkPhi) {
+  const MIRSymbol *st = varMeExpr.GetOst()->GetMIRSymbol();
+  if (st->IsInstrumented() || varMeExpr.IsVolatile() || varMeExpr.GetOst()->HasOneElemSimdAttr() ||
+      propsPerformed >= propLimit) {
+    return varMeExpr;
+  }
+
+  if (varMeExpr.GetDefBy() == kDefByStmt) {
+    DassignMeStmt *defStmt = static_cast<DassignMeStmt*>(varMeExpr.GetDefStmt());
+    ASSERT(defStmt != nullptr, "dynamic cast result is nullptr");
+    MeExpr *rhs = defStmt->GetRHS();
+    if (st->GetType() && st->GetType()->GetKind() == kTypePointer) {
+      if (static_cast<MIRPtrType *>(st->GetType())->IsFunctionPtr()) {
+        if (rhs->GetMeOp() != kMeOpAddroffunc) {
+          return varMeExpr;
+        }
+      }
+    }
+    uint32 treeLevelLimitUsed = kPropTreeLevel;
+    if (varMeExpr.GetOst()->storesIVInitValue) {
+      treeLevelLimitUsed = treeLevelLimitUsed >> 2;
+    }
+    if (rhs->GetDepth() > treeLevelLimitUsed) {
+      return varMeExpr;
+    }
+    if (rhs->GetOp() == OP_select) {
+      // select will generate many insn in cg, do not prop
+      return varMeExpr;
+    }
+    Propagatability propagatable = Propagatable(rhs, defStmt->GetBB(), atParm, true, &varMeExpr);
+    if (propagatable != kPropNo) {
+      // mark propagated for iread ref
+      if (rhs->GetMeOp() == kMeOpIvar && rhs->GetPrimType() == PTY_ref) {
+        defStmt->SetPropagated(true);
+      }
+      if (propagatable == kPropOnlyWithInverse) {
+        rhs = RehashUsingInverse(rhs);
+      }
+      propsPerformed++;
+      return *CheckTruncation(&varMeExpr, rhs);
+    } else {
+      return varMeExpr;
+    }
+  } else if (checkPhi && varMeExpr.GetDefBy() == kDefByPhi && config.propagateAtPhi) {
+    MePhiNode &defPhi = varMeExpr.GetDefPhi();
+    VarMeExpr* phiOpndLast = static_cast<VarMeExpr*>(defPhi.GetOpnds().back());
+    MeExpr *opndLastProp = &PropVar(utils::ToRef(phiOpndLast), atParm, false);
+    if (opndLastProp != &varMeExpr && opndLastProp != phiOpndLast && opndLastProp->GetMeOp() == kMeOpVar) {
+      // one more call
+      opndLastProp = &PropVar(static_cast<VarMeExpr&>(*opndLastProp), atParm, false);
+    }
+    if (opndLastProp == &varMeExpr) {
+      return varMeExpr;
+    }
+    MapleVector<ScalarMeExpr *> opndsVec = defPhi.GetOpnds();
+    for (auto it = opndsVec.crbegin() + 1; it != opndsVec.crend(); ++it) {
+      VarMeExpr *phiOpnd = static_cast<VarMeExpr*>(*it);
+      MeExpr &opndProp = PropVar(utils::ToRef(phiOpnd), atParm, false);
+      if (&opndProp != opndLastProp) {
+        return varMeExpr;
+      }
+    }
+    propsPerformed++;
+    return *opndLastProp;
+  } else if (varMeExpr.GetDefBy() == kDefByChi && varMeExpr.GetFieldID() != 0) {
+    return TryPropUnionVar(varMeExpr);
+  }
+  return varMeExpr;
+}
+
+MeExpr &Prop::PropReg(RegMeExpr &regMeExpr, bool atParm, bool checkPhi) {
+  if (propsPerformed >= propLimit) {
+    return regMeExpr;
+  }
+  if (regMeExpr.GetDefBy() == kDefByStmt) {
+    AssignMeStmt *defStmt = static_cast<AssignMeStmt*>(regMeExpr.GetDefStmt());
+    MeExpr *rhs = defStmt->GetRHS();
+    if (rhs->GetDepth() > kPropTreeLevel) {
+      return regMeExpr;
+    }
+    Propagatability propagatable =  Propagatable(rhs, defStmt->GetBB(), atParm, true, &regMeExpr);
+    if (propagatable != kPropNo) {
+      if (propagatable == kPropOnlyWithInverse) {
+        rhs = RehashUsingInverse(rhs);
+      }
+      propsPerformed++;
+      return *rhs;
+    }
+  } else if (checkPhi && regMeExpr.GetDefBy() == kDefByPhi && config.propagateAtPhi) {
+    MePhiNode &defPhi = regMeExpr.GetDefPhi();
+    auto *phiOpndLast = defPhi.GetOpnds().back();
+    MeExpr *opndLastProp = &PropReg(utils::ToRef(phiOpndLast), atParm, false);
+    if (opndLastProp == &regMeExpr) {
+      return regMeExpr;
+    }
+    const auto &opndsVec = defPhi.GetOpnds();
+    for (auto it = opndsVec.rbegin() + 1; it != opndsVec.rend(); ++it) {
+      auto *phiOpnd = *it;
+      MeExpr &opndProp = PropReg(utils::ToRef(phiOpnd), atParm, false);
+      if (&opndProp != opndLastProp) {
+        return regMeExpr;
+      }
+    }
+    propsPerformed++;
+    return *opndLastProp;
+  }
+  return regMeExpr;
+}
+
+// Iassign (lhs, rhs)
+// =>
+// regassign tmp rhs;
+// Iassign (lhs, tmp)
+ScalarMeExpr *Prop::CreateTmpAssignForIassignRHS(IvarMeExpr &ivarMeExpr, IassignMeStmt &defStmt) {
+  auto *tmpReg = irMap.CreateRegMeExpr(ivarMeExpr);
+
+  // create new verstStack for new RegMeExpr
+  ASSERT(vstLiveStackVec.size() == tmpReg->GetOstIdx(), "there is prev created ost not tracked");
+  auto *verstStack = propMapAlloc.GetMemPool()->New<MapleStack<MeExpr *>>(propMapAlloc.Adapter());
+  vstLiveStackVec.push_back(verstStack);
+  verstStack->push(tmpReg);
+  MeExpr *rhs = defStmt.GetRHS();
+  auto newRHS = CheckTruncation(&ivarMeExpr, rhs);
+  auto *regassign = irMap.CreateAssignMeStmt(*tmpReg, *newRHS, *defStmt.GetBB());
+  defStmt.SetRHS(tmpReg);
+  defStmt.GetBB()->InsertMeStmtBefore(&defStmt, regassign);
+  RecordSSAUpdateCandidate(tmpReg->GetOstIdx(), *defStmt.GetBB());
+  return tmpReg;
+}
+
+MeExpr &Prop::TryPropUnionIvar(IvarMeExpr &ivar) {
+  if (ivar.GetFieldID() == 0 || ivar.GetOffset() != 0 || ivar.GetMuList().size() > 1 ||
+      !IsPrimitiveInteger(ivar.GetPrimType())) {
+    return ivar;  // not handle multi mu
+  }
+  auto *mu = ivar.GetUniqueMu();
+  if (!mu || !mu->IsDefByChi()) { return ivar; }
+  MeStmt *defStmt = mu->GetDefByMeStmt();
+  CHECK_NULL_FATAL(defStmt);
+  if (defStmt->GetOp() != OP_iassign) {
+    return ivar;  // only find mustdef by its union
+  }
+  IvarMeExpr *realDef = static_cast<IassignMeStmt*>(defStmt)->GetLHSVal();
+  if (realDef->GetFieldID() == 0 || realDef->GetOffset() != 0 || realDef->GetBase() != ivar.GetBase() ||
+      !IsPrimitiveInteger(realDef->GetPrimType())) {
+    return ivar;
+  }
+  auto *defType = static_cast<MIRStructType*>(
+      static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(realDef->GetTyIdx()))->GetPointedType());
+  auto *useType = static_cast<MIRStructType*>(
+      static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx()))->GetPointedType());
+  // check if is covered by def
+  if (defType->GetFieldsSize() <= static_cast<uint64>(static_cast<uint32>(realDef->GetFieldID())) ||
+      useType->GetFieldsSize() <= static_cast<uint64>(static_cast<uint32>(ivar.GetFieldID()))) {
+    return ivar;  // skip some retyped cases
+  }
+  auto defStart = defType->GetBitOffsetFromBaseAddr(realDef->GetFieldID());
+  auto useStart = useType->GetBitOffsetFromBaseAddr(ivar.GetFieldID());
+  if (useStart < defStart) { return ivar; }
+  auto *defFieldType = defType->GetFieldType(realDef->GetFieldID());
+  auto *useFieldType = useType->GetFieldType(ivar.GetFieldID());
+  if (!defFieldType->IsScalarType() || !useFieldType->IsScalarType()) {
+    return ivar;
+  }
+  auto defSize = defFieldType->GetSize() * CHAR_BIT;
+  auto useSize = useFieldType->GetSize() * CHAR_BIT;
+  if (static_cast<uint64>(defStart) + defSize < static_cast<uint64>(useStart) + useSize) {
+    return ivar;
+  }
+  MeExpr *newExpr = (realDef->GetUniqueMu() == nullptr) ?
+      static_cast<MeExpr *>(CreateTmpAssignForIassignRHS(*realDef, *static_cast<IassignMeStmt*>(defStmt))) :
+      static_cast<MeExpr *>(realDef);
+  OpMeExpr extr(kInvalidExprID, OP_extractbits, useFieldType->GetPrimType(), newExpr);
+  extr.SetBitsOffSet(static_cast<uint8>(useStart - defStart));
+  extr.SetBitsSize(static_cast<uint8>(useSize));
+  auto *hashed = irMap.HashMeExpr(extr);
+  if (hashed->GetPrimType() != ivar.GetPrimType()) {
+    hashed = irMap.CreateMeExprTypeCvt(ivar.GetPrimType(), hashed->GetPrimType(), *hashed);
+  }
+  return *hashed;
+}
+
+MeExpr &Prop::PropIvar(IvarMeExpr &ivarMeExpr) {
+  if (propsPerformed >= propLimit || ivarMeExpr.IsVolatile()) {
+    return ivarMeExpr;
+  }
+  IassignMeStmt *defStmt = ivarMeExpr.GetDefStmt();
+  if (defStmt == nullptr) {
+    return TryPropUnionIvar(ivarMeExpr);
+  }
+  MeExpr &rhs = utils::ToRef(defStmt->GetRHS());
+  if (rhs.GetDepth() <= kPropTreeLevel && Propagatable(&rhs, defStmt->GetBB(), false) != kPropNo) {
+    propsPerformed++;
+    return *CheckTruncation(&ivarMeExpr, &rhs);
+  }
+  if (!isLfo && mirModule.IsCModule() && ivarMeExpr.GetPrimType() != PTY_agg) {
+    return *CreateTmpAssignForIassignRHS(ivarMeExpr, *defStmt);
+  }
+  return ivarMeExpr;
+}
+
+bool Prop::CanBeReplacedByConst(const MIRSymbol &symbol) const {
+  PrimType primType = symbol.GetType()->GetPrimType();
+  return (symbol.GetStorageClass() == kScFstatic) && (!symbol.HasPotentialAssignment()) &&
+         !IsPrimitivePoint(primType) && (IsPrimitiveInteger(primType) || IsPrimitiveFloat(primType));
+}
+
+MeExpr &Prop::PropMeExpr(MeExpr &meExpr, bool &isProped, bool atParm) {
+  MeExprOp meOp = meExpr.GetMeOp();
+
+  bool subProped = false;
+  switch (meOp) {
+    case kMeOpVar: {
+      auto &varExpr = static_cast<VarMeExpr&>(meExpr);
+      MeExpr *propMeExpr = &meExpr;
+      MIRSymbol *symbol = varExpr.GetOst()->GetMIRSymbol();
+      if (mirModule.IsCModule() && CanBeReplacedByConst(*symbol) && symbol->GetKonst() != nullptr) {
+        propMeExpr = irMap.CreateConstMeExpr(varExpr.GetPrimType(), *symbol->GetKonst());
+      } else {
+        propMeExpr = &PropVar(varExpr, atParm, true);
+      }
+      if (propMeExpr != &varExpr) {
+        isProped = true;
+      }
+      return *propMeExpr;
+    }
+    case kMeOpReg: {
+      auto &regExpr = static_cast<RegMeExpr&>(meExpr);
+      if (regExpr.GetRegIdx() < 0) {
+        return meExpr;
+      }
+      MeExpr &propMeExpr = PropReg(regExpr, atParm, true);
+      if (&propMeExpr != &regExpr) {
+        isProped = true;
+      }
+      return propMeExpr;
+    }
+    case kMeOpIvar: {
+      auto *ivarMeExpr = static_cast<IvarMeExpr*>(&meExpr);
+      if (ivarMeExpr->HasMultipleMu()) {
+        return meExpr;
+      }
+      ASSERT(ivarMeExpr->GetUniqueMu() != nullptr, "PropMeExpr: ivar has mu == nullptr");
+      bool baseProped = false;
+      MeExpr *base = nullptr;
+      if (ivarMeExpr->GetBase()->GetMeOp() != kMeOpVar || config.propagateBase) {
+        base = &PropMeExpr(utils::ToRef(ivarMeExpr->GetBase()), baseProped, false);
+      }
+
+      if (baseProped) {
+        isProped = true;
+        IvarMeExpr newMeExpr(&irMap.GetIRMapAlloc(), -1, *ivarMeExpr);
+        newMeExpr.SetBase(base);
+        newMeExpr.SetDefStmt(nullptr);
+        ivarMeExpr = static_cast<IvarMeExpr*>(irMap.HashMeExpr(newMeExpr));
+      }
+      MeExpr *propIvarExpr = &PropIvar(utils::ToRef(ivarMeExpr));
+      if (propIvarExpr != ivarMeExpr) {
+        isProped = true;
+        // Exmaple:
+        //   ivarMeExpr: iread u32 <* u8> ... (ivar primType is u8)
+        //   propIvarExpr: trunc i8 f64   ... (prop primType is i8)
+        // If the two types are not equal, we need add cvt
+        PrimType ivarPrimType = ivarMeExpr->GetType()->GetPrimType();
+        PrimType propPrimType = propIvarExpr->GetPrimType();
+        if (ivarPrimType != propPrimType) {
+          propIvarExpr = irMap.CreateMeExprTypeCvt(ivarPrimType, propPrimType, *propIvarExpr);
+        }
+      }
+      ASSERT_NOT_NULL(propIvarExpr);
+      if (propIvarExpr->GetMeOp() == kMeOpIvar) {
+        auto *equivalentVar = irMap.SimplifyIvar(ivarMeExpr, false);
+        if (equivalentVar != nullptr) {
+          MeExpr *propedExpr = &PropMeExpr(utils::ToRef(equivalentVar), subProped, false);
+          auto ivarPrimType = ivarMeExpr->GetPrimType();
+          auto propPrimType = propedExpr->GetPrimType();
+          if (ivarPrimType != propPrimType) {
+            propedExpr = irMap.CreateMeExprTypeCvt(ivarPrimType, propPrimType, *propedExpr);
+          }
+          isProped = true;
+          return *propedExpr;
+        }
+      }
+      return *propIvarExpr;
+    }
+    case kMeOpOp: {
+      auto &meOpExpr = static_cast<OpMeExpr&>(meExpr);
+      OpMeExpr newMeExpr(-1, meOpExpr.GetOp(), meOpExpr.GetPrimType(), meOpExpr.GetNumOpnds());
+
+      for (size_t i = 0; i < newMeExpr.GetNumOpnds(); ++i) {
+        MeExpr *opnd = meOpExpr.GetOpnd(i);
+        MeExpr *meExprProped = &PropMeExpr(*opnd, subProped, false);
+        // If type is not equal, use cvt
+        if (!IsNoCvtNeeded(opnd->GetPrimType(), meExprProped->GetPrimType())) {
+          CHECK_FATAL(IsPrimitiveScalar(opnd->GetPrimType()), "should be scalar");
+          CHECK_FATAL(IsPrimitiveScalar(meExprProped->GetPrimType()), "should be scalar");
+          meExprProped = irMap.CreateMeExprTypeCvt(opnd->GetPrimType(), meExprProped->GetPrimType(), *meExprProped);
+          // Try simplify new generated cvt
+          MeExpr *simplified = irMap.SimplifyMeExpr(meExprProped);
+          if (simplified != nullptr) {
+            meExprProped = simplified;
+          }
+        }
+        newMeExpr.SetOpnd(i, meExprProped);
+      }
+      newMeExpr.SetHasAddressValue();
+
+      if (subProped) {
+        isProped = true;
+        newMeExpr.SetOpndType(meOpExpr.GetOpndType());
+        newMeExpr.SetBitsOffSet(meOpExpr.GetBitsOffSet());
+        newMeExpr.SetBitsSize(meOpExpr.GetBitsSize());
+        newMeExpr.SetTyIdx(meOpExpr.GetTyIdx());
+        newMeExpr.SetFieldID(meOpExpr.GetFieldID());
+        MeExpr *simplifyExpr = irMap.SimplifyOpMeExpr(&newMeExpr);
+        return simplifyExpr != nullptr ? *simplifyExpr : utils::ToRef(irMap.HashMeExpr(newMeExpr));
+      } else {
+        return meOpExpr;
+      }
+    }
+    case kMeOpNary: {
+      auto &naryMeExpr = static_cast<NaryMeExpr&>(meExpr);
+      NaryMeExpr newMeExpr(&propMapAlloc, -1, naryMeExpr);
+
+      for (size_t i = 0; i < naryMeExpr.GetOpnds().size(); ++i) {
+        if (i == 0 && naryMeExpr.GetOp() == OP_array && !config.propagateBase) {
+          continue;
+        }
+        newMeExpr.SetOpnd(i, &PropMeExpr(utils::ToRef(naryMeExpr.GetOpnd(i)), subProped, false));
+      }
+
+      if (subProped) {
+        isProped = true;
+        return utils::ToRef(irMap.HashMeExpr(newMeExpr));
+      } else {
+        return naryMeExpr;
+      }
+    }
+    default:
+      return meExpr;
+  }
+}
+
+// Check whether we should used propedRHS to replace mestmt's original RHS or not,
+// return false if we can replace it, and true otherwise.
+bool Prop::NoPropUnionAggField(const MeStmt *meStmt, const StmtNode *stmt, const MeExpr *propedRHS) const {
+  if (meStmt->GetOp() != OP_dassign) {
+    return false;
+  }
+  OriginalSt *lhsOst = meStmt->GetLHS()->GetOst();
+  // if a union's field is an agg field, and we copy it forward, it may cause storage overlapping
+  // e.g.
+  // Example: union {
+  // Example:   struct { i32 fill; <i16 x 16> array; } fld1;
+  // Example:   struct { <i16 x 16> array; i32 fill; } fld2;
+  // Example: }
+  // its storage layout is like :
+  //      0    4                                36
+  // fld1:|----|--------------------------------|
+  //      0                                32   36
+  // fld2:|--------------------------------|----|
+  // if we copy fld2.array to fld1.array directly, elements at the back of fld2.array
+  // will be modified before they are copied. If we copy fld2.array to a temporary memory
+  // and copy this memory to fld1.array, the storage overlapping will not occur.
+  // Hence, when we find that after propagation, the rhs and lhs is a agg field of an union,
+  // and lhs is behind rhs from the perspective of memory layout, we should not propagate to
+  // avoid that a tempory memory assign may be eliminated after propagation.
+  if (lhsOst->GetMIRSymbol()->GetType()->GetKind() == kTypeUnion && lhsOst->GetType()->GetPrimType() == PTY_agg) {
+    if ((meStmt->GetRHS() != nullptr && meStmt->GetRHS()->GetOp() == OP_dread) ||
+        (stmt != nullptr && stmt->GetRHS()->GetOpCode() == OP_dread)) {
+      return true;
+    }
+    OriginalSt *rhsOst = nullptr;
+    ASSERT_NOT_NULL(propedRHS);
+    if (propedRHS->GetMeOp() == kMeOpIvar) {
+      const auto *ivar = static_cast<const IvarMeExpr*>(propedRHS);
+      const MeExpr *base = ivar->GetBase();
+      if (base->GetOp() == OP_addrof) {
+        rhsOst = static_cast<const AddrofMeExpr*>(base)->GetOst();
+      }
+    } else if (propedRHS->GetMeOp() == kMeOpVar) {
+      rhsOst = static_cast<const VarMeExpr*>(propedRHS)->GetOst();
+    }
+    if (rhsOst != nullptr && lhsOst->GetMIRSymbol() == rhsOst->GetMIRSymbol()) {
+      if (lhsOst->GetOffset().IsInvalid() ||
+          rhsOst->GetOffset().IsInvalid() ||
+          rhsOst->GetOffset() < lhsOst->GetOffset()) { // backward copy agg field
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+static bool ContainVolatile(const MeExpr *exprA) {
+  switch (exprA->GetMeOp()) {
+    case kMeOpReg:
+      return false;
+    case kMeOpVar:
+      return exprA->IsVolatile();
+    case kMeOpIvar:
+      return exprA->IsVolatile() || ContainVolatile(exprA->GetOpnd(0));
+    default: {
+      for (uint32 id = 0; id < exprA->GetNumOpnds(); ++id) {
+        auto opnd = exprA->GetOpnd(id);
+        if (opnd == nullptr) {
+          return false;
+        }
+        bool containVolatile = ContainVolatile(opnd);
+        if (containVolatile) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+}
+
+void Prop::PropEqualExpr(const MeExpr *replacedExpr, ConstMeExpr *constExpr, BB *fromBB) {
+  if (fromBB == nullptr) {
+    return;
+  }
+
+  for (auto &meStmt : fromBB->GetMeStmts()) {
+    MeExpr *eqExpr = constExpr;
+    if (replacedExpr->GetPrimType() != constExpr->GetPrimType()) {
+      eqExpr = irMap.CreateMeExprTypeCvt(replacedExpr->GetPrimType(), constExpr->GetPrimType(), *constExpr);
+    }
+    bool replaced = irMap.ReplaceMeExprStmt(meStmt, *replacedExpr, *eqExpr);
+    if (replaced) {
+      irMap.UpdateIncDecAttr(meStmt);
+    }
+  }
+
+  for (const auto &bbId : dom.GetDomChildren(fromBB->GetID())) {
+    PropEqualExpr(replacedExpr, constExpr, irMap.GetBB(BBId(bbId)));
+  }
+}
+
+static bool CheckFloatZero(const MeExpr *expr) {
+  if (IsPrimitiveFloat(expr->GetPrimType()) &&
+      expr->GetMeOp() == kMeOpConst &&
+      static_cast<const ConstMeExpr*>(expr)->IsZero()) {
+    return true;
+  }
+  return false;
+}
+
+void Prop::PropConditionBranchStmt(MeStmt *condBranchStmt) {
+  CHECK_FATAL(kOpcodeInfo.IsCondBr(condBranchStmt->GetOp()), "must be brtrue/brfalse stmt");
+  bool proped = false;
+  MeExpr *expr = &PropMeExpr(utils::ToRef(condBranchStmt->GetOpnd(0)), proped, false);
+  (void)proped;
+  condBranchStmt->SetOpnd(0, expr);
+
+  auto *opnd = condBranchStmt->GetOpnd(0);
+  if (ContainVolatile(opnd)) {
+    return;
+  }
+  if (opnd->GetMeOp() == kMeOpConst) {
+    return;
+  }
+
+  uint8 trueBranchId = condBranchStmt->GetOp() == OP_brtrue ? 1 : 0;
+  auto trueBranch = curBB->GetSucc(trueBranchId);
+  if (trueBranch->GetPred().size() == 1) {
+    auto *mirTypeOfU1 = GlobalTables::GetTypeTable().GetUInt1();
+    auto *constTrue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(1, *mirTypeOfU1);
+    auto *constExpr = static_cast<ConstMeExpr *>(irMap.CreateConstMeExpr(PTY_u1, *constTrue));
+    PropEqualExpr(opnd, constExpr, trueBranch);
+  }
+
+  uint8 falseBranchId = condBranchStmt->GetOp() == OP_brfalse ? 1 : 0;
+  auto falseBranch = curBB->GetSucc(falseBranchId);
+  if (falseBranch->GetPred().size() == 1) {
+    auto *mirTypeOfU1 = GlobalTables::GetTypeTable().GetUInt1();
+    auto *constFalse = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *mirTypeOfU1);
+    auto *constExpr = static_cast<ConstMeExpr *>(irMap.CreateConstMeExpr(PTY_u1, *constFalse));
+    PropEqualExpr(opnd, constExpr, falseBranch);
+  }
+  if (opnd->GetOp() != OP_eq && opnd->GetOp() != OP_ne) {
+    return;
+  }
+
+  auto subOpnd0 = opnd->GetOpnd(0);
+  auto subOpnd1 = opnd->GetOpnd(1);
+  if (subOpnd0->GetMeOp() == kMeOpConst && subOpnd1->GetMeOp() == kMeOpConst) {
+    return;
+  }
+  if (CheckFloatZero(subOpnd0) || CheckFloatZero(subOpnd1)) {
+    return;
+  }
+  BB *propFromBB = (opnd->GetOp() == OP_eq) ? trueBranch : ((opnd->GetOp() == OP_ne) ? falseBranch : nullptr);
+  if (propFromBB == nullptr || propFromBB->GetPred().size() != 1) {
+    return;
+  }
+
+  if (subOpnd0->GetMeOp() == kMeOpConst) {
+    PropEqualExpr(subOpnd1, static_cast<ConstMeExpr *>(subOpnd0), propFromBB);
+  } else if (subOpnd1->GetMeOp() == kMeOpConst) {
+    PropEqualExpr(subOpnd0, static_cast<ConstMeExpr *>(subOpnd1), propFromBB);
+  }
+}
+
+void Prop::TraversalMeStmt(MeStmt &meStmt) {
+  Opcode op = meStmt.GetOp();
+
+  bool subProped = false;
+  // prop operand
+  switch (op) {
+    case OP_iassign: {
+      auto &ivarStmt = static_cast<IassignMeStmt&>(meStmt);
+      ivarStmt.SetRHS(&PropMeExpr(utils::ToRef(ivarStmt.GetRHS()), subProped, false));
+      if (ivarStmt.GetLHSVal()->GetBase()->GetMeOp() != kMeOpVar || config.propagateBase) {
+        auto *baseOfIvar = ivarStmt.GetLHSVal()->GetBase();
+        MeExpr *propedExpr = &PropMeExpr(utils::ToRef(baseOfIvar), subProped, false);
+        if (propedExpr == baseOfIvar || propedExpr->GetOp() == OP_constval) {
+          subProped = false;
+        } else {
+          IvarMeExpr *lhsExpr = ivarStmt.GetLHSVal();
+          lhsExpr->SetBase(propedExpr);
+          auto *simplifiedIvar = irMap.SimplifyIvar(lhsExpr, true);
+          if (simplifiedIvar != nullptr) {
+            if (simplifiedIvar->GetMeOp() == kMeOpVar) {
+              auto *lhsVar = static_cast<ScalarMeExpr *>(simplifiedIvar);
+              auto newDassign = irMap.CreateAssignMeStmt(*lhsVar, *ivarStmt.GetRHS(), *ivarStmt.GetBB());
+              newDassign->GetChiList()->insert(ivarStmt.GetChiList()->cbegin(), ivarStmt.GetChiList()->cend());
+              newDassign->GetChiList()->erase(lhsVar->GetOstIdx());
+              ivarStmt.GetBB()->InsertMeStmtBefore(&ivarStmt, newDassign);
+              ivarStmt.GetBB()->RemoveMeStmt(&ivarStmt);
+              lhsExpr->SetDefStmt(nullptr);
+              for (auto &ostIdx2Chi : std::as_const(*newDassign->GetChiList())) {
+                auto chi = ostIdx2Chi.second;
+                chi->SetBase(newDassign);
+              }
+              lhsVar->SetDefBy(kDefByStmt);
+              lhsVar->SetDefByStmt(*newDassign);
+              PropUpdateDef(*lhsVar);
+            } else if (simplifiedIvar->GetMeOp() == kMeOpIvar) {
+              ivarStmt.SetLHSVal(static_cast<IvarMeExpr *>(simplifiedIvar));
+            }
+          }
+        }
+      }
+      if (subProped) {
+        ivarStmt.SetLHSVal(irMap.BuildLHSIvarFromIassMeStmt(ivarStmt));
+      }
+      break;
+    }
+    case OP_return: {
+      RetMeStmt *retmestmt = &static_cast<RetMeStmt&>(meStmt);
+      const MapleVector<MeExpr *> &opnds = retmestmt->GetOpnds();
+      // java return operand cannot be expression because cleanup intrinsic is
+      // inserted before the return statement
+      if (JAVALANG && opnds.size() == 1 && opnds[0]->GetMeOp() == kMeOpVar) {
+        break;
+      }
+      for (size_t i = 0; i < opnds.size(); i++) {
+        MeExpr *opnd = opnds[i];
+        retmestmt->SetOpnd(i, &PropMeExpr(*opnd, subProped, false));
+      }
+      break;
+    }
+    case OP_dassign:
+    case OP_regassign: {
+      AssignMeStmt *asmestmt = static_cast<AssignMeStmt *>(&meStmt);
+      MeExpr &propedRHS = PropMeExpr(*asmestmt->GetRHS(), subProped, false);
+      if (NoPropUnionAggField(asmestmt, nullptr, &propedRHS)) {
+        break;
+      }
+      asmestmt->SetRHS(&propedRHS);
+      if (subProped) {
+        asmestmt->isIncDecStmt = false;
+      }
+      PropUpdateDef(*asmestmt->GetLHS());
+      break;
+    }
+    case OP_asm: break;
+    case OP_brtrue:
+    case OP_brfalse: {
+      PropConditionBranchStmt(&meStmt);
+      break;
+    }
+    default:
+      for (size_t i = 0; i != meStmt.NumMeStmtOpnds(); ++i) {
+        MeExpr *expr = &PropMeExpr(utils::ToRef(meStmt.GetOpnd(i)), subProped, kOpcodeInfo.IsCall(op));
+        if (kOpcodeInfo.IsCallAssigned(op) && i >= kMaxRegParamNum) {
+          PrimType exprOrigType = meStmt.GetOpnd(i)->GetPrimType();
+          PrimType exprPropType = expr->GetPrimType();
+          if (GetPrimTypeSize(exprOrigType) != GetPrimTypeSize(exprPropType)) {
+            // When we pass parameters by stack, cvt is needed for call opnds if type size changes
+            expr = irMap.CreateMeExprTypeCvt(exprOrigType, exprPropType, *expr);
+          }
+        }
+        meStmt.SetOpnd(i, expr);
+      }
+      break;
+  }
+
+  // update chi
+  auto *chiList = meStmt.GetChiList();
+  if (chiList != nullptr) {
+    switch (op) {
+      case OP_syncenter:
+      case OP_syncexit: {
+        break;
+      }
+      default:
+        PropUpdateChiListDef(*chiList);
+        break;
+    }
+  }
+
+  // update must def
+  if (kOpcodeInfo.IsCallAssigned(op)) {
+    MapleVector<MustDefMeNode> *mustDefList = meStmt.GetMustDefList();
+    for (auto &node : utils::ToRef(mustDefList)) {
+      MeExpr *meLhs = node.GetLHS();
+      PropUpdateDef(utils::ToRef(static_cast<VarMeExpr*>(meLhs)));
+    }
+  }
+}
+
+// Enter BB : every stack in vstLiveStackVec grows 1 layer as its top.
+// when update def, just replace the top element with new vst.
+void Prop::GrowVstLiveStack() {
+  for (size_t i = 1; i < vstLiveStackVec.size(); ++i) {
+    vstLiveStackVec[i]->push(vstLiveStackVec[i]->empty() ? nullptr : vstLiveStackVec[i]->top());
+  }
+}
+// Exit BB : recover vstLiveStackVec as before when enter BB
+void Prop::RecoverVstLiveStack() {
+  for (size_t i = 1; i < vstLiveStackVec.size(); ++i) {
+    if (!vstLiveStackVec[i]->empty()) {
+      vstLiveStackVec[i]->pop();
+    }
+  }
+}
+
+void Prop::TraversalBB(BB &bb) {
+  if (bbVisited[bb.GetBBId()]) {
+    return;
+  }
+  bbVisited[bb.GetBBId()] = true;
+
+  SetCurBB(&bb);
+
+  // every vstLiveStack grows one layer, assuming that there would be new def later
+  GrowVstLiveStack();
+
+  // update var phi nodes
+  for (auto &it : std::as_const(bb.GetMePhiList())) {
+    PropUpdateDef(utils::ToRef(it.second->GetLHS()));
+  }
+
+  // traversal on stmt
+  for (auto &meStmt : bb.GetMeStmts()) {
+    TraversalMeStmt(meStmt);
+  }
+
+  auto &domChildren = dom.GetDomChildren(bb.GetID());
+  for (auto &childbbid : std::as_const(domChildren)) {
+    TraversalBB(*GetBB(BBId(childbbid)));
+  }
+  // every vstLiveStack pop one layer to recover as before when entering BB.
+  RecoverVstLiveStack();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/seqvec.cpp b/src/mapleall/maple_me/src/seqvec.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d9788f6c0a7442c68ce60554606682396d11a0af
--- /dev/null
+++ b/src/mapleall/maple_me/src/seqvec.cpp
@@ -0,0 +1,739 @@
+/*
+ * Copyright (c) [2021-2022] Futurewei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <iostream>
+#include <algorithm>
+#include "me_option.h"
+#include "seqvec.h"
+
+namespace maple {
+uint32_t SeqVectorize::seqVecStores = 0;
+
+// copy from loopvec: generate instrinsic node to copy scalar to vector type
+RegassignNode *SeqVectorize::GenDupScalarStmt(BaseNode *scalar, PrimType vecPrimType) {
+  MIRIntrinsicID intrnID = INTRN_vector_from_scalar_v4i32;
+  MIRType *vecType = nullptr;
+  switch (vecPrimType) {
+    case PTY_v4i32: {
+      intrnID = INTRN_vector_from_scalar_v4i32;
+      vecType = GlobalTables::GetTypeTable().GetV4Int32();
+      break;
+    }
+    case PTY_v2i32: {
+      intrnID = INTRN_vector_from_scalar_v2i32;
+      vecType = GlobalTables::GetTypeTable().GetV2Int32();
+      break;
+    }
+    case PTY_v4u32: {
+      intrnID = INTRN_vector_from_scalar_v4u32;
+      vecType = GlobalTables::GetTypeTable().GetV4UInt32();
+      break;
+    }
+    case PTY_v2u32: {
+      intrnID = INTRN_vector_from_scalar_v2u32;
+      vecType = GlobalTables::GetTypeTable().GetV2UInt32();
+      break;
+    }
+    case PTY_v8i16: {
+      intrnID = INTRN_vector_from_scalar_v8i16;
+      vecType = GlobalTables::GetTypeTable().GetV8Int16();
+      break;
+    }
+    case PTY_v8u16: {
+      intrnID = INTRN_vector_from_scalar_v8u16;
+      vecType = GlobalTables::GetTypeTable().GetV8UInt16();
+      break;
+    }
+    case PTY_v4i16: {
+      intrnID = INTRN_vector_from_scalar_v4i16;
+      vecType = GlobalTables::GetTypeTable().GetV4Int16();
+      break;
+    }
+    case PTY_v4u16: {
+      intrnID = INTRN_vector_from_scalar_v4u16;
+      vecType = GlobalTables::GetTypeTable().GetV4UInt16();
+      break;
+    }
+    case PTY_v16i8: {
+      intrnID = INTRN_vector_from_scalar_v16i8;
+      vecType = GlobalTables::GetTypeTable().GetV16Int8();
+      break;
+    }
+    case PTY_v16u8: {
+      intrnID = INTRN_vector_from_scalar_v16u8;
+      vecType = GlobalTables::GetTypeTable().GetV16UInt8();
+      break;
+    }
+    case PTY_v8i8: {
+      intrnID = INTRN_vector_from_scalar_v8i8;
+      vecType = GlobalTables::GetTypeTable().GetV8Int8();
+      break;
+    }
+    case PTY_v8u8: {
+      intrnID = INTRN_vector_from_scalar_v8u8;
+      vecType = GlobalTables::GetTypeTable().GetV8UInt8();
+      break;
+    }
+    case PTY_v2i64: {
+      intrnID = INTRN_vector_from_scalar_v2i64;
+      vecType = GlobalTables::GetTypeTable().GetV2Int64();
+      break;
+    }
+    case PTY_v2u64: {
+      intrnID = INTRN_vector_from_scalar_v2u64;
+      vecType = GlobalTables::GetTypeTable().GetV2UInt64();
+      break;
+    }
+    default: {
+      ASSERT(0, "NIY");
+    }
+  }
+  // generate instrinsic op
+  IntrinsicopNode *rhs = codeMP->New<IntrinsicopNode>(*codeMPAlloc, OP_intrinsicop, vecPrimType);
+  rhs->SetIntrinsic(intrnID);
+  rhs->SetNumOpnds(1);
+  rhs->GetNopnd().push_back(scalar);
+  rhs->SetTyIdx(vecType->GetTypeIndex());
+  PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(vecPrimType);
+  RegassignNode *stmtNode = codeMP->New<RegassignNode>(vecPrimType, regIdx, rhs);
+  return stmtNode;
+}
+
+// v2uint8 v2int8 v2uint16 v2int16 are not added to prim type
+bool SeqVectorize::HasVecType(PrimType sPrimType, uint8 lanes) const {
+  if (lanes == 1) {
+    return false;
+  }
+  if ((GetPrimTypeSize(sPrimType) == 1 && lanes < 8) ||
+      (GetPrimTypeSize(sPrimType) == 2 && lanes < 4)) {
+    return false;
+  }
+  return true;
+}
+
+MIRType* SeqVectorize::GenVecType(PrimType sPrimType, uint8 lanes) const {
+  MIRType *vecType = nullptr;
+  CHECK_FATAL(IsPrimitiveInteger(sPrimType), "primtype should be integer");
+  switch (sPrimType) {
+    case PTY_i32: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4Int32();
+      } else if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2Int32();
+      } else {
+        CHECK_FATAL(0, "unsupported int32 vectory lanes");
+      }
+      break;
+    }
+    case PTY_u32: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4UInt32();
+      } else if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2UInt32();
+      } else {
+        CHECK_FATAL(0, "unsupported uint32 vectory lanes");
+      }
+      break;
+    }
+    case PTY_i16: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4Int16();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8Int16();
+      } else {
+        CHECK_FATAL(0, "unsupported int16 vector lanes");
+      }
+      break;
+    }
+    case PTY_u16: {
+      if (lanes == 4) {
+        vecType = GlobalTables::GetTypeTable().GetV4UInt16();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8UInt16();
+      } else {
+        CHECK_FATAL(0, "unsupported uint16 vector lanes");
+      }
+      break;
+    }
+    case PTY_i8: {
+      if (lanes == 16) {
+        vecType = GlobalTables::GetTypeTable().GetV16Int8();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8Int8();
+      } else {
+        CHECK_FATAL(0, "unsupported int8 vector lanes");
+      }
+      break;
+    }
+    case PTY_u8: {
+      if (lanes == 16) {
+        vecType = GlobalTables::GetTypeTable().GetV16UInt8();
+      } else if (lanes == 8) {
+        vecType = GlobalTables::GetTypeTable().GetV8UInt8();
+      } else {
+        CHECK_FATAL(0, "unsupported uint8 vector lanes");
+      }
+      break;
+    }
+    case PTY_i64: {
+      if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2Int64();
+      } else {
+        ASSERT(0, "unsupported i64 vector lanes");
+      }
+    }
+    [[clang::fallthrough]];
+    case PTY_u64:
+    case PTY_a64: {
+      if (lanes == 2) {
+        vecType = GlobalTables::GetTypeTable().GetV2UInt64();
+      } else {
+        ASSERT(0, "unsupported a64/u64 vector lanes");
+      }
+    }
+    [[clang::fallthrough]];
+    case PTY_ptr: {
+      if (GetPrimTypeSize(sPrimType) == 4) {
+        if (lanes == 4)  {
+          vecType = GlobalTables::GetTypeTable().GetV4UInt32();
+        } else if (lanes == 2) {
+          vecType = GlobalTables::GetTypeTable().GetV2UInt32();
+        } else {
+          ASSERT(0, "unsupported ptr vector lanes");
+        }
+      } else if (GetPrimTypeSize(sPrimType) == 8) {
+        if (lanes == 2) {
+          vecType = GlobalTables::GetTypeTable().GetV2UInt64();
+        } else {
+          ASSERT(0, "unsupported ptr vector lanes");
+        }
+      }
+      break;
+    }
+    default:
+      ASSERT(0, "NIY");
+  }
+  return vecType;
+}
+
+bool SeqVectorize::CanAdjustRhsType(PrimType targetType, const ConstvalNode *rhs) const {
+  const MIRIntConst *intConst = static_cast<const MIRIntConst*>(rhs->GetConstVal());
+  int64 v = intConst->GetExtValue();
+  bool res = false;
+  switch (targetType) {
+    case PTY_i32: {
+      res = (v >= INT_MIN && v <= INT_MAX);
+      break;
+    }
+    case PTY_u32: {
+      res = (v >= 0 && v <= UINT_MAX);
+      break;
+    }
+    case PTY_i16: {
+      res = (v >= SHRT_MIN && v <= SHRT_MAX);
+      break;
+    }
+    case PTY_u16: {
+      res = (v >= 0 && v <=  USHRT_MAX);
+      break;
+    }
+    case PTY_i8: {
+      res = (v >= SCHAR_MIN && v <= SCHAR_MAX);
+      break;
+    }
+    case PTY_u8: {
+      res = (v >= 0 && v <= UCHAR_MAX);
+      break;
+    }
+    case PTY_i64:
+    case PTY_u64: {
+      res = true;
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  return res;
+}
+
+void SeqVectorize::DumpCandidates(const MeExpr *base, const StoreList *storelist) const {
+  LogInfo::MapleLogger() << "Dump base node \t";
+  base->Dump(meIRMap, 0);
+  for (uint32_t i = 0; i < (*storelist).size(); i++) {
+    (*storelist)[i]->Dump(0);
+  }
+  return;
+}
+
+void SeqVectorize::CollectStores(IassignNode *iassign) {
+  // if no hass information, the node may be changed by loopvec, skip
+  if ((*PreMeStmtExtensionMap)[iassign->GetStmtID()] == nullptr) {
+    return;
+  }
+  // if point to type is not integer, skip
+  MIRType &mirType = GetTypeFromTyIdx(iassign->GetTyIdx());
+  CHECK_FATAL(mirType.GetKind() == kTypePointer, "iassign must have pointer type");
+  MIRPtrType *ptrType = static_cast<MIRPtrType*>(&mirType);
+  PrimType stmtpt = ptrType->GetPointedType()->GetPrimType();
+  if (!IsPrimitiveInteger(stmtpt)) {
+    return;
+  }
+  // check lhs and rhs type
+  if (iassign->GetRHS()->IsConstval() &&
+      (stmtpt != iassign->GetRHS()->GetPrimType()) &&
+      (!CanAdjustRhsType(stmtpt, static_cast<ConstvalNode *>(iassign->GetRHS())))) {
+    return;
+  }
+  // compare base address with store list
+  PreMeMIRExtension *lfoP = (*PreMeStmtExtensionMap)[iassign->GetStmtID()];
+  IassignMeStmt *iassMeStmt = static_cast<IassignMeStmt *>(lfoP->GetMeStmt());
+  IvarMeExpr *ivarMeExpr = iassMeStmt->GetLHSVal();
+  MeExpr *base = ivarMeExpr->GetBase();
+  if (ivarMeExpr->GetOp() == OP_iread ||
+      ivarMeExpr->GetOp() == OP_ireadoff) {
+    if (base->GetOp() == OP_array) {
+      NaryMeExpr *baseNary = static_cast<NaryMeExpr *>(base);
+      base = baseNary->GetOpnd(0);
+    }
+  } else {
+    CHECK_FATAL(0, "NIY:: iassign addrExpr op");
+  }
+
+  if (stores.count(base) > 0) {
+    StoreList *list = stores[base];
+    (*list).push_back(iassign);
+    return;
+  }
+  // new array
+  StoreList *storelist = localMP->New<StoreList>(localAlloc.Adapter());
+  storelist->push_back(iassign);
+  stores[base] = storelist;
+}
+
+bool SeqVectorize::SameIntConstValue(const MeExpr *e1, const MeExpr *e2) const {
+  if (e1->GetOp() == maple::OP_constval && e2->GetOp() == maple::OP_constval &&
+      IsPrimitiveInteger(e1->GetPrimType()) &&
+      IsPrimitiveInteger(e2->GetPrimType())) {
+    const MIRConst *const1 =  (static_cast<const ConstMeExpr *>(e1))->GetConstVal();
+    const MIRIntConst *intc1 =  static_cast<const MIRIntConst *>(const1);
+    const MIRConst *const2 =  (static_cast<const ConstMeExpr *>(e2))->GetConstVal();
+    const MIRIntConst *intc2 =  static_cast<const MIRIntConst *>(const2);
+    return (intc1->GetExtValue() == intc2->GetExtValue());
+  }
+  return false;
+}
+
+bool SeqVectorize::CanSeqVecRhs(MeExpr *rhs1, MeExpr *rhs2) {
+  // case 1: rhs1 and rhs2 are constval and same value
+  if ((rhs1 == rhs2) || SameIntConstValue(rhs1, rhs2)) {
+    if (IsRhsConst() || IsRhsStatusUnset()) {
+      SetRhsConst();
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // current rhs is not same status
+  if (IsRhsConst()) {
+    return false;
+  }
+  // case 2: iread consecutive memory
+  if (rhs1->GetMeOp() == rhs2->GetMeOp()) {
+    if (rhs1->GetMeOp() == maple::kMeOpIvar) {
+      IvarMeExpr *rhs1Ivar = static_cast<IvarMeExpr *>(rhs1);
+      IvarMeExpr *rhs2Ivar = static_cast<IvarMeExpr *>(rhs2);
+      MIRType &mirType = GetTypeFromTyIdx(rhs1Ivar->GetTyIdx());
+      CHECK_FATAL(mirType.GetKind() == kTypePointer, "iassign must have pointer type");
+      MIRPtrType *ptrType = static_cast<MIRPtrType*>(&mirType);
+      // skip vectorize if pointto type is agg, offset between
+      // arr[i] and arr[i+1] may be larger than vector width
+      if (!IsPrimitiveInteger(ptrType->GetPointedType()->GetPrimType())) {
+        return false;
+      }
+      PrimType diffType = ptrType->GetPointedType()->GetPrimType();
+      if (IsIvarExprConsecutiveMem(rhs1Ivar, rhs2Ivar, diffType)) {
+        SetRhsConsercutiveMem();
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool SeqVectorize::IsOpExprConsecutiveMem(MeExpr *off1, MeExpr *off2, int32_t diff) const {
+  if (off1->GetOp() == off2->GetOp() &&
+      off1->GetOp() == OP_add) {
+    if (off1->GetOpnd(0) == off2->GetOpnd(0) &&
+        (off1->GetOpnd(1)->GetOp() == OP_constval) &&
+        (off2->GetOpnd(1)->GetOp() == OP_constval)) {
+      MIRConst *constoff1 =  static_cast<ConstMeExpr *>(off1->GetOpnd(1))->GetConstVal();
+      MIRIntConst *intoff1 =  static_cast<MIRIntConst *>(constoff1);
+      MIRConst *constoff2 =  static_cast<ConstMeExpr *>(off2->GetOpnd(1))->GetConstVal();
+      MIRIntConst *intoff2 =  static_cast<MIRIntConst *>(constoff2);
+      if (intoff2->GetExtValue() - intoff1->GetExtValue() == diff) {
+        return true;
+      }
+    }
+  } else if (off1->GetOp() == OP_mul && off2->GetOp() == OP_add) {
+    if (off1 == off2->GetOpnd(0) && off2->GetOpnd(1)->GetOp() == OP_constval) {
+      MIRConst *constoff2 = static_cast<ConstMeExpr *>(off2->GetOpnd(1))->GetConstVal();
+      MIRIntConst *intoff2 = static_cast<MIRIntConst *>(constoff2);
+      if (intoff2->GetValue() == diff) {
+        return true;
+      }
+    }
+  } else if (off1->GetOp() == off2->GetOp() && off1->GetOp() == OP_constval) {
+    MIRConst *const1 = static_cast<ConstMeExpr *>(off1)->GetConstVal();
+    MIRIntConst *intc1 = static_cast<MIRIntConst *>(const1);
+    MIRConst *const2 = static_cast<ConstMeExpr *>(off2)->GetConstVal();
+    MIRIntConst *intc2 = static_cast<MIRIntConst *>(const2);
+    if (intc2->GetExtValue() - intc1->GetExtValue() == diff) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool SeqVectorize::IsIvarExprConsecutiveMem(IvarMeExpr *ivar1, IvarMeExpr *ivar2, PrimType ptrType) {
+  MeExpr *base1 = ivar1->GetBase();
+  MeExpr *base2 = ivar2->GetBase();
+  uint32_t base1NumOpnds = base1->GetNumOpnds();
+  uint32_t base2NumOpnds = base2->GetNumOpnds();
+
+  // check type
+  if (ivar1->GetPrimType() != ivar2->GetPrimType()) {
+    return false;
+  }
+  // check opcode
+  if (base1->GetOp() != base2->GetOp()) {
+    return false;
+  }
+  // check filedID should same
+  if (ivar1->GetFieldID() != ivar2->GetFieldID()) {
+    return false;
+  }
+  // base is array: check array dimensions are same and lower dimension exprs are same
+  if (base1->GetOp() == OP_array) {
+    // check base opnds number are same
+    if (base1NumOpnds != base2NumOpnds) {
+      return false;
+    }
+    // check base low dimensions expr are same
+    for (uint32_t i = 1; i < base1NumOpnds - 1; i++) {
+      if (base1->GetOpnd(i) != base2->GetOpnd(i)) {
+        return false;
+      }
+    }
+    // check lhs: highest dimension offset is consecutive
+    MeExpr *off1 = base1->GetOpnd(base1NumOpnds - 1);
+    MeExpr *off2 = base2->GetOpnd(base2NumOpnds - 1);
+    if (!IsOpExprConsecutiveMem(off1, off2, 1)) {
+      return false;
+    }
+  } else {
+    // check base opcode should be ptr here
+    if (base2->GetOp() == OP_array) {
+      return false;
+    }
+    // base is symbol
+    uint32_t diff = GetPrimTypeSize(ptrType);
+    if (static_cast<uint32>(ivar2->GetOffset() - ivar1->GetOffset()) != diff) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// check if expr is independent on defStmt.
+bool SeqVectorize::IsExprDataIndependent(const MeExpr *expr, const IassignMeStmt *defStmt) {
+  if (expr->IsScalar()) {
+    MeStmt *stmt = static_cast<const ScalarMeExpr *>(expr)->GetDefByMeStmt();
+    if (stmt == defStmt) {
+      return false;
+    }
+  } else if (expr->GetMeOp() == kMeOpIvar) {
+    auto *iass = static_cast<const IvarMeExpr *>(expr)->GetDefStmt();
+    if (iass == defStmt) {
+      return false;
+    }
+    for (auto *mu : static_cast<const IvarMeExpr *>(expr)->GetMuList()) {
+      if (!IsExprDataIndependent(mu, defStmt)) {
+        return false;
+      }
+    }
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    if (!IsExprDataIndependent(expr->GetOpnd(i), defStmt)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// check if s2 is independent on def of s1
+bool SeqVectorize::IsStmtDataIndependent(const IassignMeStmt *s1, const IassignMeStmt *s2) {
+  IvarMeExpr *lhs1 = s1->GetLHSVal();
+  MeExpr *rhs2 = s2->GetRHS();
+  if (lhs1 == rhs2) {
+    return false;
+  }
+  for (size_t i = 0; i < s2->NumMeStmtOpnds(); ++i) {
+    if (!IsExprDataIndependent(s2->GetOpnd(i), s1)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SeqVectorize::CanSeqVec(const IassignNode *s1, const IassignNode *s2, bool reverse) {
+  PreMeMIRExtension *lfoP1 = (*PreMeStmtExtensionMap)[s1->GetStmtID()];
+  IassignMeStmt *iassMeStmt1 = static_cast<IassignMeStmt *>(lfoP1->GetMeStmt());
+  IvarMeExpr *lhsMeExpr1 = iassMeStmt1->GetLHSVal();
+  PreMeMIRExtension *lfoP2 = (*PreMeStmtExtensionMap)[s2->GetStmtID()];
+  IassignMeStmt *iassMeStmt2 = static_cast<IassignMeStmt *>(lfoP2->GetMeStmt());
+  IvarMeExpr *lhsMeExpr2 = iassMeStmt2->GetLHSVal();
+  MIRType &mirType = GetTypeFromTyIdx(s1->GetTyIdx());
+  CHECK_FATAL(mirType.GetKind() == kTypePointer, "iassign must have pointer type");
+  MIRPtrType *ptrType = static_cast<MIRPtrType*>(&mirType);
+  // check lhs ivar expression
+  if (!IsIvarExprConsecutiveMem(lhsMeExpr1, lhsMeExpr2, ptrType->GetPointedType()->GetPrimType())) {
+    return false;
+  }
+  // check rhs
+  MeExpr *rhs1 = iassMeStmt1->GetRHS();
+  MeExpr *rhs2 = iassMeStmt2->GetRHS();
+  if (!CanSeqVecRhs(rhs1, rhs2)) {
+    return false;
+  }
+  // check lhs and rhs size consistent
+  if (rhs1->GetMeOp() == maple::kMeOpIvar && rhs2->GetMeOp() == maple::kMeOpIvar) {
+    MIRType *rhsType = static_cast<IvarMeExpr*>(rhs1)->GetType();
+    if (rhsType->GetSize() != ptrType->GetPointedType()->GetSize()) {
+      return false;
+    }
+  }
+  // check data dependency, example
+  // S1: a[1] <- a[2]
+  // S2: a[0] <- a[1]
+  // rhs of S2 is dependent on S1, we can not merge them
+  if ((!reverse && !IsStmtDataIndependent(iassMeStmt1, iassMeStmt2)) ||
+      (reverse && !IsStmtDataIndependent(iassMeStmt2, iassMeStmt1))) {
+    return false;
+  }
+  return true;
+}
+
+static uint32 PreviousPowerOfTwo(unsigned int x) {
+  return 1U << ((sizeof(x) * 8 - 1) - static_cast<uint64>(__builtin_clz(x)));
+}
+
+void SeqVectorize::MergeIassigns(MapleVector<IassignNode *> &cands) {
+  MIRType &mirType = GetTypeFromTyIdx(cands[0]->GetTyIdx());
+  CHECK_FATAL(mirType.GetKind() == kTypePointer, "iassign must have pointer type");
+  MIRPtrType *ptrType = static_cast<MIRPtrType*>(&mirType);
+  PrimType ptType = ptrType->GetPointedType()->GetPrimType();
+  uint32_t maxLanes = 16 / GetPrimTypeSize((ptrType->GetPointedType()->GetPrimType()));
+  auto len = static_cast<uint32>(cands.size());
+  uint32 start = 0;
+  do {
+    IassignNode *iassign = cands[start];
+    uint32_t candCountP2 = PreviousPowerOfTwo(len);
+    uint32_t lanes = (candCountP2 <  maxLanes) ? candCountP2 : maxLanes;
+    if (!HasVecType(ptType, static_cast<uint8>(lanes))) {
+      break; // early quit if ptType and lanes has no vectype
+    }
+    // update lhs type
+    MIRType *vecType = GenVecType(ptType, static_cast<uint8>(lanes));
+    ASSERT(vecType != nullptr, "vector type should not be null");
+    MIRType *pvecType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*vecType, PTY_ptr);
+    iassign->SetTyIdx(pvecType->GetTypeIndex());
+
+    PreMeMIRExtension *lfoP = (*PreMeStmtExtensionMap)[iassign->GetStmtID()];
+    BaseNode *parent = lfoP->GetParent();
+    CHECK_FATAL(parent && parent->GetOpCode() == OP_block, "unexpect parent type");
+    BlockNode *blockParent = static_cast<BlockNode *>(parent);
+    // update rhs
+    if (IsRhsConst()) {
+      // rhs is constant
+      RegassignNode *dupScalarStmt = GenDupScalarStmt(iassign->GetRHS(), vecType->GetPrimType());
+      RegreadNode *regreadNode = codeMP->New<RegreadNode>(vecType->GetPrimType(), dupScalarStmt->GetRegIdx());
+      blockParent->InsertBefore(iassign, dupScalarStmt);
+      iassign->SetRHS(regreadNode);
+      if (Options::profileUse && mirFunc->GetFuncProfData()) {
+        mirFunc->GetFuncProfData()->CopyStmtFreq(dupScalarStmt->GetStmtID(), iassign->GetStmtID());
+      }
+    } else if (iassign->GetRHS()->GetOpCode() == OP_iread) {
+      // rhs is iread
+      IreadNode *ireadnode = static_cast<IreadNode *>(iassign->GetRHS());
+      MIRType *ireadType = ireadnode->GetType();
+      MIRType *rhsvecType = nullptr;
+      if (ireadType->GetPrimType() == PTY_agg) {
+        // iread variable from a struct, use iread type
+        rhsvecType = GenVecType(ireadnode->GetPrimType(), static_cast<uint8>(lanes));
+        ASSERT(rhsvecType != nullptr, "vector type should not be null");
+      } else {
+        rhsvecType = GenVecType(ireadType->GetPrimType(), static_cast<uint8>(lanes));
+        ASSERT(rhsvecType != nullptr, "vector type should not be null");
+        MIRType *rhspvecType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*rhsvecType, PTY_ptr);
+        ireadnode->SetTyIdx(rhspvecType->GetTypeIndex()); // update ptr type
+      }
+      ireadnode->SetPrimType(rhsvecType->GetPrimType());
+    } else {
+      CHECK_FATAL(0, "NIY:: rhs opcode is not supported yet ");
+    }
+
+    // delete merged iassignode
+    for (uint32 i = start + 1; i < start + lanes; ++i) {
+      blockParent->RemoveStmt(cands[i]);
+    }
+    len = len - lanes;
+    start = start + lanes;
+  } while (len > 1);
+  // update couter
+  SeqVectorize::seqVecStores++;
+}
+
+void SeqVectorize::LegalityCheckAndTransform(const StoreList *storelist) {
+  MapleVector<IassignNode *> cands(localAlloc.Adapter());
+  size_t len = storelist->size();
+  bool needReverse = true;
+  cands.clear();
+  ResetRhsStatus(); // reset rhs is const flag
+  for (size_t i = 0; i < len; ++i) {
+    IassignNode *store1 = (*storelist)[i];
+    MIRPtrType *ptrType = static_cast<MIRPtrType*>(&GetTypeFromTyIdx(store1->GetTyIdx()));
+    cands.push_back(store1);
+    for (size_t j = i + 1; j < len; ++j) {
+      IassignNode *store2 = (*storelist)[j];
+      if (CanSeqVec(cands.back(), store2, false)) {
+        cands.push_back(store2);
+      }
+    }
+    if (HasVecType(ptrType->GetPointedType()->GetPrimType(), static_cast<uint8>(cands.size()))) {
+      MergeIassigns(cands);
+      needReverse = false;
+      break;
+    }
+    cands.clear();
+  }
+
+  if (!needReverse) {
+    return;
+  }
+  ResetRhsStatus(); // reset rhs is const flag
+  for (int i = static_cast<int>(len) - 1; i >= 0; --i) {
+    IassignNode *store1 = (*storelist)[i];
+    MIRPtrType *ptrType = static_cast<MIRPtrType*>(&GetTypeFromTyIdx(store1->GetTyIdx()));
+    cands.push_back(store1);
+    for (int j = i - 1; j >= 0; --j) {
+      IassignNode *store2 = (*storelist)[j];
+      if (CanSeqVec(cands.back(), store2, true)) {
+        cands.push_back(store2);
+      }
+    }
+    if (HasVecType(ptrType->GetPointedType()->GetPrimType(), static_cast<uint8>(cands.size()))) {
+      MergeIassigns(cands);
+      break;
+    }
+    cands.clear();
+  }
+}
+
+// transform collected iassign nodes
+void SeqVectorize::CheckAndTransform() {
+  if (stores.size() == 0) {
+    return;
+  }
+  // legality check and merge nodes
+  StoreListMap::const_iterator mapit = stores.cbegin();
+  for (; mapit != stores.end(); ++mapit) {
+    if (enableDebug) {
+      DumpCandidates(mapit->first, mapit->second);
+    }
+    LegalityCheckAndTransform(mapit->second);
+  }
+
+  // clear list
+  mapit = stores.begin();
+  for (; mapit != stores.end(); ++mapit) {
+    mapit->second->clear();
+  }
+  stores.clear();
+}
+
+void SeqVectorize::VisitNode(StmtNode *stmt) {
+  if (stmt == nullptr) {
+    return;
+  }
+  do {
+    StmtNode *nextStmt = stmt->GetNext();
+    switch (stmt->GetOpCode()) {
+      case OP_if: {
+        CheckAndTransform();
+        IfStmtNode *ifStmt = static_cast<IfStmtNode *>(stmt);
+        // visit then body
+        VisitNode(ifStmt->GetThenPart());
+        // visit else body
+        VisitNode(ifStmt->GetElsePart());
+        break;
+      }
+      case OP_block: {
+        CHECK_FATAL(stores.size() == 0, "store list should be empty");
+        BlockNode *block = static_cast<BlockNode *>(stmt);
+        VisitNode(block->GetFirst());
+        // deal with list in block
+        CheckAndTransform();
+        break;
+      }
+      case OP_doloop: {
+        CheckAndTransform();
+        VisitNode(static_cast<DoloopNode *>(stmt)->GetDoBody());
+        break;
+      }
+      case OP_dowhile:
+      case OP_while: {
+        CheckAndTransform();
+        VisitNode(static_cast<WhileStmtNode *>(stmt)->GetBody());
+        break;
+      }
+      case OP_iassign: {
+        IassignNode *iassign = static_cast<IassignNode *>(stmt);
+        CollectStores(iassign);
+        break;
+      }
+      case OP_label:
+      case OP_brfalse:
+      case OP_brtrue:
+      case OP_return:
+      case OP_switch:
+      case OP_igoto:
+      case OP_goto: {
+        // end of block
+        CheckAndTransform();
+        break;
+      }
+      default: {
+        break; // do nothing
+      }
+    }
+    stmt = nextStmt;
+  } while (stmt != nullptr);
+  return;
+}
+
+void SeqVectorize::Perform() {
+  VisitNode(mirFunc->GetBody());
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/ssa.cpp b/src/mapleall/maple_me/src/ssa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b1a4152fb12c6777fb262e2bf58b2ba6cb46b83e
--- /dev/null
+++ b/src/mapleall/maple_me/src/ssa.cpp
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ssa.h"
+#include "ssa_tab.h"
+#include "ssa_mir_nodes.h"
+#include "ver_symbol.h"
+#include "dominance.h"
+#include "me_cfg.h"
+
+namespace maple {
+bool IsLocalTopLevelOst(const OriginalSt &ost) {
+  if (ost.IsVolatile()) {
+    return false;
+  }
+  if (ost.IsSymbolOst()) {
+    MIRSymbol *sym = ost.GetMIRSymbol();
+    // global/local static ost can be modified whenever an assign to it appear.
+    if (sym->GetStorageClass() == kScPstatic || sym->GetStorageClass() == kScFstatic) {
+      return false;
+    }
+    // sym is agg, ost may alias with other ost
+    if (sym->GetType()->GetPrimType() == PTY_agg) {
+      return false;
+    }
+  } else {
+    ASSERT(ost.IsPregOst(), "OriginalSt can only be symbol or preg");
+    if (ost.GetPregIdx() < 0) {
+      return false;
+    }
+  }
+  return (ost.IsLocal() && !ost.IsAddressTaken() && ost.GetIndirectLev() == 0);
+}
+
+void SSA::InsertPhiForDefBB(size_t bbid, VersionSt *vst) {
+  for (auto dfBBId : dom->GetDomFrontier(bbid)) {
+    BB *phiBB = bbVec[dfBBId];
+    CHECK_FATAL(phiBB != nullptr, "MeSSA::InsertPhiNode: non-existent BB for definition");
+    auto successTag = phiBB->InsertPhi(&ssaTab->GetVersAlloc(), vst);
+    if (!successTag) {
+      continue;
+    }
+    InsertPhiForDefBB(dfBBId, vst);
+  }
+}
+
+void SSA::InsertPhiNode() {
+  for (size_t i = 1; i < ssaTab->GetOriginalStTable().Size(); ++i) {
+    OriginalSt *ost = ssaTab->GetOriginalStFromID(OStIdx(i));
+    ASSERT_NOT_NULL(ost);
+    if (ost->GetIndirectLev() < 0) {
+      continue;
+    }
+    if (!ssaTab->HasDefBB(ost->GetIndex())) {
+      continue;
+    }
+    if (ost->IsVolatile()) { // volatile variables will not have ssa form.
+      continue;
+    }
+    if (!ShouldProcessOst(*ost)) {
+      continue;
+    }
+    VersionSt *vst = ssaTab->GetVersionStTable().GetZeroVersionSt(ost);
+    for (BBId bbid : *ssaTab->GetDefBBs4Ost(ost->GetIndex())) {
+      InsertPhiForDefBB(bbid, vst);
+    }
+  }
+}
+
+void SSA::InitRenameStack(const OriginalStTable &oTable, const VersionStTable &verStTab, MapleAllocator &alloc) {
+  vstStacks = alloc.New<MapleVector<MapleStack<VersionSt*>*>>(alloc.Adapter());
+  vstStacks->resize(oTable.Size());
+  for (size_t i = 1; i < oTable.Size(); ++i) {
+    const OriginalSt *ost = oTable.GetOriginalStFromID(OStIdx(i));
+    ASSERT_NOT_NULL(ost);
+    if (ost->GetIndirectLev() < 0) {
+      continue;
+    }
+    MapleStack<VersionSt*> *vStack = alloc.New<MapleStack<VersionSt*>>(alloc.Adapter());
+    VersionSt *temp = verStTab.GetVersionStVectorItem(ost->GetZeroVersionIndex());
+    vStack->push(temp);
+    (*vstStacks)[i] = vStack;
+  }
+}
+
+void SSA::ReplaceRenameStackTop(VersionSt &newTop) const {
+  auto *vstStack = GetVstStacks()[newTop.GetOrigIdx()];
+  ASSERT(!vstStack->empty(), "Cannot replace top element of an empty stack!");
+  vstStack->pop();
+  vstStack->push(&newTop);
+}
+
+void SSA::PushToRenameStack(VersionSt *vSym) {
+  if (vSym == nullptr || vSym->IsInitVersion()) {
+    return;
+  }
+  // If a new version is pushed to the top before, replace it with the newest one;
+  // otherwise, push the newest version to the top.
+  if (IsNewVstPushed(vSym->GetOrigIdx())) {
+    ReplaceRenameStackTop(*vSym);
+  } else {
+    GetVstStacks()[vSym->GetOrigIdx()]->push(vSym);
+    SetNewVstPushed(vSym->GetOrigIdx());
+  }
+}
+
+VersionSt *SSA::CreateNewVersion(VersionSt &vSym, BB &defBB) {
+  // volatile variables will keep zero version.
+  const OriginalSt *oSt = vSym.GetOst();
+  if (oSt->IsVolatile() || oSt->IsSpecialPreg()) {
+    return &vSym;
+  }
+  VersionSt *newVersionSym = nullptr;
+  if (!runRenameOnly) {
+    newVersionSym = ssaTab->GetVersionStTable().CreateNextVersionSt(vSym.GetOst());
+  } else {
+    newVersionSym = &vSym;
+  }
+  PushToRenameStack(newVersionSym);
+  newVersionSym->SetDefBB(&defBB);
+  return newVersionSym;
+}
+
+void SSA::RenamePhi(BB &bb) {
+  for (auto phiIt = bb.GetPhiList().begin(); phiIt != bb.GetPhiList().end(); ++phiIt) {
+    VersionSt *vSym = phiIt->second.GetResult();
+    if (!ShouldRenameVst(vSym)) {
+      PushToRenameStack(vSym); // no need to create next version, just use the vst rename before.
+      continue;
+    }
+    VersionSt *newVersionSym = CreateNewVersion(*vSym, bb);
+    phiIt->second.SetResult(*newVersionSym);
+    newVersionSym->SetDefType(VersionSt::kPhi);
+    newVersionSym->SetPhi(&(*phiIt).second);
+  }
+}
+
+void SSA::RenameDefs(StmtNode &stmt, BB &defBB) {
+  Opcode opcode = stmt.GetOpCode();
+  AccessSSANodes *theSSAPart = ssaTab->GetStmtsSSAPart().SSAPartOf(stmt);
+  if (kOpcodeInfo.AssignActualVar(opcode)) {
+    VersionSt *vSym = theSSAPart->GetSSAVar();
+    if (ShouldRenameVst(vSym)) {
+      VersionSt *newVersionSym = CreateNewVersion(*vSym, defBB);
+      newVersionSym->SetDefType(VersionSt::kAssign);
+      newVersionSym->SetAssignNode(&stmt);
+      theSSAPart->SetSSAVar(*newVersionSym);
+    } else {
+      PushToRenameStack(vSym);
+    }
+  }
+  if (kOpcodeInfo.HasSSADef(opcode) && opcode != OP_regassign) {
+    TypeOfMayDefList &mayDefList = theSSAPart->GetMayDefNodes();
+    for (auto it = mayDefList.begin(); it != mayDefList.end(); ++it) {
+      MayDefNode &mayDef = it->second;
+      VersionSt *vSym = mayDef.GetResult();
+      CHECK_FATAL(vSym->GetOrigIdx() < GetVstStacks().size(), "index out of range in SSA::RenameMayDefs");
+      if (!ShouldRenameVst(vSym)) { // maydassign will insert maydefNode, if it is top-level, we should process it.
+        PushToRenameStack(vSym);
+        continue;
+      }
+      mayDef.SetOpnd(GetVstStackTop(vSym->GetOrigIdx()));
+      VersionSt *newVersionSym = CreateNewVersion(*vSym, defBB);
+      mayDef.SetResult(newVersionSym);
+      newVersionSym->SetDefType(VersionSt::kMayDef);
+      newVersionSym->SetMayDef(&mayDef);
+      if (opcode == OP_iassign && mayDef.base != nullptr) {
+        mayDef.base = GetVstStackTop(mayDef.base->GetOrigIdx());
+      }
+    }
+  }
+}
+
+void SSA::RenameMustDefs(const StmtNode &stmt, BB &defBB) {
+  Opcode opcode = stmt.GetOpCode();
+  if (kOpcodeInfo.IsCallAssigned(opcode)) {
+    MapleVector<MustDefNode> &mustDefs = ssaTab->GetStmtsSSAPart().GetMustDefNodesOf(stmt);
+    for (MustDefNode &mustDefNode : mustDefs) {
+      VersionSt *vSym = mustDefNode.GetResult();
+      if (!ShouldRenameVst(vSym)) {
+        PushToRenameStack(vSym);
+        continue;
+      }
+      VersionSt *newVersionSym = CreateNewVersion(*vSym, defBB);
+      mustDefNode.SetResult(newVersionSym);
+      newVersionSym->SetDefType(VersionSt::kMustDef);
+      newVersionSym->SetMustDef(&(mustDefNode));
+    }
+  }
+}
+
+void SSA::RenameMayUses(const BaseNode &node) const {
+  TypeOfMayUseList &mayUseList = ssaTab->GetStmtsSSAPart().GetMayUseNodesOf(static_cast<const StmtNode&>(node));
+  auto it = mayUseList.begin();
+  for (; it != mayUseList.end(); ++it) {
+    MayUseNode &mayUse = it->second;
+    VersionSt *vSym = mayUse.GetOpnd();
+    CHECK_FATAL(vSym->GetOrigIdx() < GetVstStacks().size(), "index out of range in SSA::RenameMayUses");
+    mayUse.SetOpnd(GetVstStackTop(vSym->GetOrigIdx()));
+  }
+}
+
+void SSA::RenameExpr(BaseNode &expr) {
+  if (expr.IsSSANode()) {
+    auto &ssaNode = static_cast<SSANode&>(expr);
+    VersionSt *vSym = ssaNode.GetSSAVar();
+    if (ShouldRenameVst(vSym)) {
+      CHECK_FATAL(vSym->GetOrigIdx() < GetVstStacks().size(), "index out of range in SSA::RenameExpr");
+      ssaNode.SetSSAVar(*GetVstStackTop(vSym->GetOrigIdx()));
+    }
+  }
+  for (size_t i = 0; i < expr.NumOpnds(); ++i) {
+    RenameExpr(*expr.Opnd(i));
+  }
+}
+
+void SSA::RenameUses(const StmtNode &stmt) {
+  if (BuildSSAAddrTaken() && kOpcodeInfo.HasSSAUse(stmt.GetOpCode())) {
+    RenameMayUses(stmt);
+  }
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+    RenameExpr(*stmt.Opnd(i));
+  }
+}
+
+void SSA::RenamePhiUseInSucc(const BB &bb) const {
+  for (BB *succBB : bb.GetSucc()) {
+    // find index of bb in succ_bb->pred[]
+    size_t index = 0;
+    while (index < succBB->GetPred().size()) {
+      if (succBB->GetPred(index) == &bb) {
+        break;
+      }
+      index++;
+    }
+    CHECK_FATAL(index < succBB->GetPred().size(), "RenamePhiUseInSucc: cannot find corresponding pred");
+    // rename the phiOpnds[index] in all the phis in succ_bb
+    for (auto phiIt = succBB->GetPhiList().begin(); phiIt != succBB->GetPhiList().end(); ++phiIt) {
+      PhiNode &phiNode = phiIt->second;
+      VersionSt *vSym = phiNode.GetPhiOpnd(index);
+      CHECK_FATAL(vSym->GetOrigIdx() < GetVstStacks().size(), "out of range SSA::RenamePhiUseInSucc");
+      if (!ShouldRenameVst(vSym)) {
+        continue;
+      }
+      phiNode.SetPhiOpnd(index, *GetVstStackTop(phiNode.GetPhiOpnd(index)->GetOrigIdx()));
+    }
+  }
+}
+
+void SSA::RenameAllBBs(const MeCFG *cfg) {
+  // renameMP is a tmp mempool, will be release after rename.
+  auto renameMP = std::make_unique<ThreadLocalMemPool>(memPoolCtrler, "ssa-rename-mempool");
+  MapleAllocator renameAlloc(renameMP.get());
+  InitRenameStack(ssaTab->GetOriginalStTable(), ssaTab->GetVersionStTable(), renameAlloc);
+  // recurse down dominator tree in pre-order traversal
+  auto *children = &dom->GetDomChildren(cfg->GetCommonEntryBB()->GetID());
+  for (auto child : *children) {
+    RenameBB(*cfg->GetBBFromID(BBId(child)));
+  }
+  vstStacks = nullptr;
+}
+
+void SSA::RenameBB(BB &bb) {
+  // record if a new version is pushed to renameStack. It is used for new version pushed checking and recovering.
+  auto tmpNewVstPushed = std::make_unique<std::vector<bool>>(GetVstStacks().size(), false);
+  std::vector<bool> *backupPtr = isNewVstPushed; // for recovering before leave this BB
+  isNewVstPushed = tmpNewVstPushed.get();
+
+  RenamePhi(bb);
+  for (auto &stmt : bb.GetStmtNodes()) {
+    RenameUses(stmt);
+    RenameDefs(stmt, bb);
+    RenameMustDefs(stmt, bb);
+  }
+  RenamePhiUseInSucc(bb);
+  // Rename child in Dominator Tree.
+  ASSERT(bb.GetBBId() < dom->GetDomChildrenSize(), "index out of range in MeSSA::RenameBB");
+  const auto &children = dom->GetDomChildren(bb.GetID());
+  for (const auto &child : children) {
+    RenameBB(*bbVec[child]);
+  }
+  for (size_t i = 1; i < GetVstStacks().size(); ++i) {
+    if (GetVstStacks()[i] == nullptr || !IsNewVstPushed(i)) {
+      continue;
+    }
+    // only need to pop top, because we only keep the newest version on the top
+    vstStacks->at(i)->pop();
+  }
+
+  isNewVstPushed = backupPtr;
+}
+
+// Check if ost should be processed according to target ssa level set before
+bool SSA::ShouldProcessOst(const OriginalSt &ost) const {
+  // for memory ssa, all ost should be processed
+  if (BuildSSAAllLevel()) {
+    return true;
+  }
+  // for local ssa, check if ost is local top-level
+  if (BuildSSATopLevel()) {
+    return IsLocalTopLevelOst(ost);
+  }
+  // for addr-taken ssa, check if ost is non local top-level
+  if (BuildSSAAddrTaken()) {
+    return !IsLocalTopLevelOst(ost);
+  }
+  return false;
+}
+
+bool SSA::ShouldRenameVst(const VersionSt *vst) const {
+  if (vst == nullptr) {
+    return false;
+  }
+  if (runRenameOnly) {
+    return true;
+  }
+  return ShouldProcessOst(*vst->GetOst());
+}
+
+void PhiNode::Dump() {
+  GetResult()->Dump();
+  LogInfo::MapleLogger() << " = PHI(";
+  for (size_t i = 0; i < GetPhiOpnds().size(); ++i) {
+    GetPhiOpnd(i)->Dump();
+    if (i < GetPhiOpnds().size() - 1) {
+      LogInfo::MapleLogger() << ',';
+    }
+  }
+  LogInfo::MapleLogger() << ")" << '\n';
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/ssa_devirtual.cpp b/src/mapleall/maple_me/src/ssa_devirtual.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb11e6c90e537a6eb2d3fc05d9f8c910999fa63d
--- /dev/null
+++ b/src/mapleall/maple_me/src/ssa_devirtual.cpp
@@ -0,0 +1,694 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ssa_devirtual.h"
+
+// This phase performs devirtualization based on SSA. Ideally, we should have
+// precise alias information, so that for each reference we know exactly the
+// objects it refers to, then the exact method it calls. However, precise alias
+// analysis costs a lot.
+//
+// For now, we only use a simple policy to help devirtualize, E.g.
+// Base b is defined as new Derived(), and b.foo() denotes b invokes method foo().
+// We can devirtual the b.foo() to be Derived::foo().
+namespace maple {
+bool SSADevirtual::debug = false;
+static bool NonNullRetValue(const MIRFunction &called) {
+  static const std::unordered_set<std::string> nonNullRetValueFuncs = {
+      "Ljava_2Futil_2FArrayList_3B_7Citerator_7C_28_29Ljava_2Futil_2FIterator_3B",
+      "Ljava_2Futil_2FHashSet_3B_7Citerator_7C_28_29Ljava_2Futil_2FIterator_3B",
+      "Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_3B_7Citerator_7C_28_29Ljava_2Futil_2FIterator_3B",
+      "Ljava_2Futil_2FServiceLoader_3B_7Citerator_7C_28_29Ljava_2Futil_2FIterator_3B",
+      "Ljava_2Futil_2FCollections_24UnmodifiableCollection_3B_7Citerator_7C_28_29Ljava_2Futil_2FIterator_3B",
+      "Ljava_2Futil_2FAbstractList_3B_7Citerator_7C_28_29Ljava_2Futil_2FIterator_3B",
+      "Ljava_2Futil_2FTreeSet_3B_7Citerator_7C_28_29Ljava_2Futil_2FIterator_3B",
+      "Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24KeySet_3B_7Citerator_7C_28_29Ljava_2Futil_2FIterator_3B",
+      "Ljava_2Futil_2FCollections_24CheckedCollection_3B_7Citerator_7C_28_29Ljava_2Futil_2FIterator_3B"
+  };
+  return nonNullRetValueFuncs.find(called.GetName()) != nonNullRetValueFuncs.end();
+}
+
+static bool MaybeNull(const MeExpr &expr) {
+  if (expr.GetMeOp() == kMeOpVar) {
+    return static_cast<const VarMeExpr*>(&expr)->GetMaybeNull();
+  }
+  if (expr.GetMeOp() == kMeOpIvar) {
+    return static_cast<const IvarMeExpr*>(&expr)->GetMaybeNull();
+  }
+  if (expr.GetOp() == OP_retype) {
+    MeExpr *retypeRHS = (static_cast<const OpMeExpr*>(&expr))->GetOpnd(0);
+    if (retypeRHS->GetMeOp() == kMeOpVar) {
+      return static_cast<VarMeExpr*>(retypeRHS)->GetMaybeNull();
+    }
+  }
+  return true;
+}
+
+static bool IsFinalMethod(const MIRFunction *mirFunc) {
+  if (mirFunc == nullptr) {
+    return false;
+  }
+  const auto *classType = static_cast<const MIRClassType*>(mirFunc->GetClassType());
+  // Return true if the method or its class is declared as final
+  return (classType != nullptr && (mirFunc->IsFinal() || classType->IsFinal()));
+}
+
+TyIdx SSADevirtual::GetInferredTyIdx(MeExpr &expr) const {
+  if (expr.GetMeOp() == kMeOpVar) {
+    auto *varMeExpr = static_cast<VarMeExpr*>(&expr);
+    if (varMeExpr->GetInferredTyIdx() == 0u) {
+      // If varMeExpr->inferredTyIdx has not been set, we can double check
+      // if it is coming from a static final field
+      const OriginalSt *ost = varMeExpr->GetOst();
+      const MIRSymbol *mirSym = ost->GetMIRSymbol();
+      if (mirSym->IsStatic() && mirSym->IsFinal() && mirSym->GetInferredTyIdx() != kInitTyIdx &&
+          mirSym->GetInferredTyIdx() != kNoneTyIdx) {
+        varMeExpr->SetInferredTyIdx(mirSym->GetInferredTyIdx());
+      }
+      if (mirSym->GetType()->GetKind() == kTypePointer) {
+        MIRType *pointedType = (static_cast<MIRPtrType*>(mirSym->GetType()))->GetPointedType();
+        if (pointedType->GetKind() == kTypeClass) {
+          if ((static_cast<MIRClassType*>(pointedType))->IsFinal()) {
+            varMeExpr->SetInferredTyIdx(pointedType->GetTypeIndex());
+          }
+        }
+      }
+    }
+    return varMeExpr->GetInferredTyIdx();
+  }
+  if (expr.GetMeOp() == kMeOpIvar) {
+    return static_cast<IvarMeExpr*>(&expr)->GetInferredTyIdx();
+  }
+  if (expr.GetOp() == OP_retype) {
+    MeExpr *retypeRHS = (static_cast<OpMeExpr*>(&expr))->GetOpnd(0);
+    if (retypeRHS->GetMeOp() == kMeOpVar) {
+      return static_cast<VarMeExpr*>(retypeRHS)->GetInferredTyIdx();
+    }
+  }
+  return TyIdx(0);
+}
+
+void SSADevirtual::ReplaceCall(CallMeStmt &callStmt, const MIRFunction &targetFunc) {
+  if (SSADevirtual::debug) {
+    MIRFunction &mirFunc = callStmt.GetTargetFunction();
+    LogInfo::MapleLogger() << "[SSA-DEVIRT] " << kOpcodeInfo.GetTableItemAt(callStmt.GetOp()).name << " " <<
+        namemangler::DecodeName(mirFunc.GetName());
+  }
+  if (callStmt.GetOp() == OP_virtualicall || callStmt.GetOp() == OP_virtualicallassigned ||
+      callStmt.GetOp() == OP_interfaceicall || callStmt.GetOp() == OP_interfaceicallassigned) {
+    // delete 1st argument
+    callStmt.EraseOpnds(callStmt.GetOpnds().begin());
+  }
+  MeExpr *receiver = callStmt.GetOpnd(0);
+  if (NeedNullCheck(*receiver)) {
+    InsertNullCheck(callStmt, *receiver);
+    ++nullCheckCount;
+  }
+  // Set the actuall callee puIdx
+  callStmt.SetPUIdx(targetFunc.GetPuidx());
+  if (callStmt.GetOp() == OP_virtualcall || callStmt.GetOp() == OP_virtualicall) {
+    callStmt.SetOp(OP_call);
+    ++optedVirtualCalls;
+  } else if (callStmt.GetOp() == OP_virtualcallassigned || callStmt.GetOp() == OP_virtualicallassigned) {
+    callStmt.SetOp(OP_callassigned);
+    ++optedVirtualCalls;
+  } else if (callStmt.GetOp() == OP_interfacecall || callStmt.GetOp() == OP_interfaceicall) {
+    callStmt.SetOp(OP_call);
+    ++optedInterfaceCalls;
+  } else if (callStmt.GetOp() == OP_interfacecallassigned || callStmt.GetOp() == OP_interfaceicallassigned) {
+    callStmt.SetOp(OP_callassigned);
+    ++optedInterfaceCalls;
+  }
+  if (clone != nullptr && callStmt.GetOp() == OP_callassigned) {
+    clone->UpdateReturnVoidIfPossible(&callStmt, targetFunc);
+  }
+  if (SSADevirtual::debug) {
+    LogInfo::MapleLogger() << "\t -> \t" << kOpcodeInfo.GetTableItemAt(callStmt.GetOp()).name << " " <<
+        namemangler::DecodeName(targetFunc.GetName());
+    if (NeedNullCheck(*receiver)) {
+      LogInfo::MapleLogger() << " with null-check ";
+    }
+    LogInfo::MapleLogger() << "\t at " << mod->GetFileNameFromFileNum(callStmt.GetSrcPosition().FileNum()) << ":" <<
+        callStmt.GetSrcPosition().LineNum() << '\n';
+  }
+}
+
+bool SSADevirtual::DevirtualizeCall(CallMeStmt &callStmt) {
+  switch (callStmt.GetOp()) {
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+      totalInterfaceCalls++;  // FALLTHROUGH
+    [[clang::fallthrough]];
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned: {
+      totalVirtualCalls++;  // actually the number of interfacecalls + virtualcalls
+      const MapleVector<MeExpr*> &parms = callStmt.GetOpnds();
+      if (parms.empty() || parms[0] == nullptr) {
+        break;
+      }
+      MeExpr *thisParm = parms[0];
+      if (callStmt.GetOp() == OP_interfaceicall || callStmt.GetOp() == OP_interfaceicallassigned ||
+          callStmt.GetOp() == OP_virtualicall || callStmt.GetOp() == OP_virtualicallassigned) {
+        thisParm = parms[1];
+      }
+      TyIdx receiverInferredTyIdx = GetInferredTyIdx(*thisParm);
+      MIRFunction &mirFunc = callStmt.GetTargetFunction();
+      if (thisParm->GetPrimType() == PTY_ref && receiverInferredTyIdx != 0u) {
+        Klass *inferredKlass = kh->GetKlassFromTyIdx(receiverInferredTyIdx);
+        if (inferredKlass == nullptr) {
+          break;
+        }
+        GStrIdx funcName = mirFunc.GetBaseFuncNameWithTypeStrIdx();
+        MIRFunction *inferredFunction = inferredKlass->GetClosestMethod(funcName);
+        if (inferredFunction == nullptr) {
+          if (SSADevirtual::debug) {
+            LogInfo::MapleLogger() << "Can not get function for " << inferredKlass->GetKlassName() <<
+                mirFunc.GetBaseFuncNameWithType() << '\n';
+          }
+          break;
+        }
+        if (thisParm->GetMeOp() != kMeOpVar && thisParm->GetMeOp() != kMeOpIvar) {
+          break;
+        }
+        ReplaceCall(callStmt, *inferredFunction);
+        return true;
+      } else if (IsFinalMethod(&mirFunc)) {
+        GStrIdx uniqFuncNameStrIdx = mirFunc.GetNameStrIdx();
+        CHECK_FATAL(uniqFuncNameStrIdx != 0u, "check");
+        MIRSymbol *uniqFuncSym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(uniqFuncNameStrIdx);
+        ASSERT(uniqFuncSym != nullptr, "The real callee %s has not been seen in any imported .mplt file",
+               mirFunc.GetName().c_str());
+        MIRFunction *uniqFunc = uniqFuncSym->GetFunction();
+        ASSERT(mirFunc.GetBaseFuncNameWithType() == uniqFunc->GetBaseFuncNameWithType(),
+               "Invalid function replacement in devirtualization");
+        ReplaceCall(callStmt, *uniqFunc);
+        return true;
+      } else {
+        if (thisParm->GetMeOp() == kMeOpVar) {
+          auto *varMeExpr = static_cast<VarMeExpr*>(thisParm);
+          MapleMap<int, MapleVector<TyIdx>*>::iterator mapit = inferredTypeCandidatesMap.find(varMeExpr->GetExprID());
+          if (mapit != inferredTypeCandidatesMap.end() && mapit->second->size() > 0) {
+            const MapleVector<TyIdx> &inferredTypeCandidates = *mapit->second;
+            GStrIdx funcName = mirFunc.GetBaseFuncNameWithTypeStrIdx();
+            MIRFunction *inferredFunction = nullptr;
+            size_t i = 0;
+            for (; i < inferredTypeCandidates.size(); ++i) {
+              Klass *inferredKlass = kh->GetKlassFromTyIdx(inferredTypeCandidates.at(i));
+              if (inferredKlass == nullptr) {
+                break;
+              }
+              MIRFunction *tmpFunction = inferredKlass->GetClosestMethod(funcName);
+              if (tmpFunction == nullptr) {
+                break;
+              }
+              if (inferredFunction == nullptr) {
+                inferredFunction = tmpFunction;
+              } else if (inferredFunction != tmpFunction) {
+                break;
+              }
+            }
+            if (i == inferredTypeCandidates.size() && inferredFunction != nullptr) {
+              if (SSADevirtual::debug) {
+                ASSERT_NOT_NULL(GetMIRFunction());
+                LogInfo::MapleLogger() << "Devirutalize based on set of inferred types: In " <<
+                    GetMIRFunction()->GetName() << "; Devirtualize: " << mirFunc.GetName() << '\n';
+              }
+              ReplaceCall(callStmt, *inferredFunction);
+              return true;
+            }
+          }
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+bool SSADevirtual::NeedNullCheck(const MeExpr &receiver) const {
+  return MaybeNull(receiver);
+}
+
+// Java requires to throw Null-Pointer-Execption if the receiver of
+// the virtualcall is null. We insert an eval(iread recevier, 0)
+// statment perform the null-check.
+void SSADevirtual::InsertNullCheck(CallMeStmt &callStmt, MeExpr &receiver) const {
+  UnaryMeStmt *nullCheck = irMap->New<UnaryMeStmt>(OP_assertnonnull);
+  nullCheck->SetBB(callStmt.GetBB());
+  nullCheck->SetSrcPos(callStmt.GetSrcPosition());
+  nullCheck->SetMeStmtOpndValue(&receiver);
+  callStmt.GetBB()->InsertMeStmtBefore(&callStmt, nullCheck);
+}
+
+void SSADevirtual::PropVarInferredType(VarMeExpr &varMeExpr) const {
+  if (varMeExpr.GetInferredTyIdx() != 0u) {
+    return;
+  }
+  if (varMeExpr.GetDefBy() == kDefByStmt) {
+    DassignMeStmt &defStmt = utils::ToRef(safe_cast<DassignMeStmt>(varMeExpr.GetDefStmt()));
+    MeExpr *rhs = defStmt.GetRHS();
+    if (rhs->GetOp() == OP_gcmalloc) {
+      varMeExpr.SetInferredTyIdx(static_cast<GcmallocMeExpr*>(rhs)->GetTyIdx());
+      varMeExpr.SetMaybeNull(false);
+      if (SSADevirtual::debug) {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(varMeExpr.GetInferredTyIdx());
+        LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << varMeExpr.GetExprID() << " ";
+        type->Dump(0, false);
+        LogInfo::MapleLogger() << '\n';
+      }
+    } else if (rhs->GetOp() == OP_gcmallocjarray) {
+      varMeExpr.SetInferredTyIdx(static_cast<OpMeExpr*>(rhs)->GetTyIdx());
+      varMeExpr.SetMaybeNull(false);
+      if (SSADevirtual::debug) {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(varMeExpr.GetInferredTyIdx());
+        LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << varMeExpr.GetExprID() << " ";
+        type->Dump(0, false);
+        LogInfo::MapleLogger() << '\n';
+      }
+    } else {
+      TyIdx tyIdx = GetInferredTyIdx(*rhs);
+      varMeExpr.SetMaybeNull(MaybeNull(*rhs));
+      if (tyIdx != 0u) {
+        varMeExpr.SetInferredTyIdx(tyIdx);
+        if (SSADevirtual::debug) {
+          MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(varMeExpr.GetInferredTyIdx());
+          LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << varMeExpr.GetExprID() << " ";
+          type->Dump(0, false);
+          LogInfo::MapleLogger() << '\n';
+        }
+      }
+    }
+    // Parallel me will skip the setting for symbol's inferredTyIdx because it is independent of the function
+    // optimization order
+    if (!skipReturnTypeOpt && varMeExpr.GetInferredTyIdx() != 0u) {
+      OriginalSt *ost = defStmt.GetVarLHS()->GetOst();
+      MIRSymbol *mirSym = ost->GetMIRSymbol();
+      if (mirSym->IsStatic() && mirSym->IsFinal()) {
+        // static final field can store and propagate inferred typeinfo
+        if (mirSym->GetInferredTyIdx() == kInitTyIdx) {
+          // mirSym->_inferred_tyIdx has not been set before
+          mirSym->SetInferredTyIdx(varMeExpr.GetInferredTyIdx());
+        } else if (mirSym->GetInferredTyIdx() != varMeExpr.GetInferredTyIdx()) {
+          // If mirSym->_inferred_tyIdx has been set before, it means we have
+          // seen a divergence on control flow. Set to NONE if not all
+          // branches reach the same conclusion.
+          mirSym->SetInferredTyIdx(kNoneTyIdx);
+        }
+      }
+    }
+  } else if (varMeExpr.GetDefBy() == kDefByPhi) {
+    if (SSADevirtual::debug) {
+      LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] " << "Def by phi " << '\n';
+    }
+  }
+}
+
+void SSADevirtual::PropIvarInferredType(IvarMeExpr &ivar) const {
+  if (ivar.GetInferredTyIdx() != 0u) {
+    return;
+  }
+  IassignMeStmt *defStmt = ivar.GetDefStmt();
+  if (defStmt == nullptr) {
+    return;
+  }
+  MeExpr *rhs = defStmt->GetRHS();
+  CHECK_NULL_FATAL(rhs);
+  if (rhs->GetOp() == OP_gcmalloc) {
+    ivar.GetInferredTyIdx() = static_cast<GcmallocMeExpr*>(rhs)->GetTyIdx();
+    ivar.SetMaybeNull(false);
+    if (SSADevirtual::debug) {
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetInferredTyIdx());
+      LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << ivar.GetExprID() << " ";
+      type->Dump(0, false);
+      LogInfo::MapleLogger() << '\n';
+    }
+  } else {
+    TyIdx tyIdx = GetInferredTyIdx(*rhs);
+    ivar.SetMaybeNull(MaybeNull(*rhs));
+    if (tyIdx != 0u) {
+      ivar.SetInferredTyidx(tyIdx);
+      if (SSADevirtual::debug) {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetInferredTyIdx());
+        LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << ivar.GetExprID() << " ";
+        type->Dump(0, false);
+        LogInfo::MapleLogger() << '\n';
+      }
+    }
+  }
+}
+
+void SSADevirtual::VisitVarPhiNode(MePhiNode &varPhi) {
+  MapleVector<ScalarMeExpr*> opnds = varPhi.GetOpnds();
+  auto *lhs = varPhi.GetLHS();
+  // RegPhiNode cases NYI
+  if (lhs == nullptr || lhs->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  VarMeExpr *lhsVar = static_cast<VarMeExpr*>(varPhi.GetLHS());
+
+  auto mapit = inferredTypeCandidatesMap.find(lhsVar->GetExprID());
+  if (mapit == inferredTypeCandidatesMap.cend()) {
+    auto tyIdxCandidates = devirtualAlloc.GetMemPool()->New<MapleVector<TyIdx>>(devirtualAlloc.Adapter());
+    inferredTypeCandidatesMap[lhsVar->GetExprID()] = tyIdxCandidates;
+  }
+  MapleVector<TyIdx> &inferredTypeCandidates = *inferredTypeCandidatesMap[lhsVar->GetExprID()];
+  for (size_t i = 0; i < opnds.size(); ++i) {
+    VarMeExpr *opnd = static_cast<VarMeExpr *>(opnds[i]);
+    PropVarInferredType(*opnd);
+    if (opnd->GetInferredTyIdx() != 0u) {
+      size_t j = 0;
+      for (; j < inferredTypeCandidates.size(); j++) {
+        if (inferredTypeCandidates.at(j) == opnd->GetInferredTyIdx()) {
+          break;
+        }
+      }
+      if (j == inferredTypeCandidates.size()) {
+        inferredTypeCandidates.push_back(opnd->GetInferredTyIdx());
+      }
+    } else {
+      inferredTypeCandidates.clear();
+      break;
+    }
+  }
+}
+
+void SSADevirtual::VisitMeExpr(MeExpr *meExpr) const {
+  if (meExpr == nullptr) {
+    return;
+  }
+  MeExprOp meOp = meExpr->GetMeOp();
+  switch (meOp) {
+    case kMeOpVar: {
+      auto *varExpr = static_cast<VarMeExpr*>(meExpr);
+      PropVarInferredType(*varExpr);
+      break;
+    }
+    case kMeOpReg:
+      break;
+    case kMeOpIvar: {
+      auto *iVar = static_cast<IvarMeExpr*>(meExpr);
+      PropIvarInferredType(*iVar);
+      break;
+    }
+    case kMeOpOp: {
+      auto *meOpExpr = static_cast<OpMeExpr*>(meExpr);
+      for (uint32 i = 0; i < kOperandNumTernary; ++i) {
+        VisitMeExpr(meOpExpr->GetOpnd(i));
+      }
+      break;
+    }
+    case kMeOpNary: {
+      auto *naryMeExpr = static_cast<NaryMeExpr*>(meExpr);
+      for (MeExpr *opnd : naryMeExpr->GetOpnds()) {
+        VisitMeExpr(opnd);
+      }
+      break;
+    }
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpAddroflabel:
+    case kMeOpGcmalloc:
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpSizeoftype:
+    case kMeOpFieldsDist:
+      break;
+    default:
+      CHECK_FATAL(false, "MeOP NIY");
+      break;
+  }
+}
+
+void SSADevirtual::ReturnTyIdxInferring(const RetMeStmt &retMeStmt) {
+  const MapleVector<MeExpr*> &opnds = retMeStmt.GetOpnds();
+  CHECK_FATAL(opnds.size() <= 1, "Assume at most one return value for now");
+  for (size_t i = 0; i < opnds.size(); ++i) {
+    MeExpr *opnd = opnds[i];
+    TyIdx tyIdx = GetInferredTyIdx(*opnd);
+    if (retTy == kNotSeen) {
+      // seen the first return stmt
+      retTy = kSeen;
+      inferredRetTyIdx = tyIdx;
+    } else if (retTy == kSeen) {
+      // has seen an inferred type before, check if they agreed
+      if (inferredRetTyIdx != tyIdx) {
+        retTy = kFailed;
+        inferredRetTyIdx = TyIdx(0);  // not agreed, cleared.
+      }
+    }
+  }
+}
+
+void SSADevirtual::TraversalMeStmt(MeStmt &meStmt) {
+  Opcode op = meStmt.GetOp();
+  switch (op) {
+    case OP_dassign: {
+      auto *varMeStmt = static_cast<DassignMeStmt*>(&meStmt);
+      VisitMeExpr(varMeStmt->GetRHS());
+      break;
+    }
+    case OP_regassign: {
+      auto *regMeStmt = static_cast<AssignMeStmt*>(&meStmt);
+      VisitMeExpr(regMeStmt->GetRHS());
+      break;
+    }
+    case OP_maydassign: {
+      auto *maydStmt = static_cast<MaydassignMeStmt*>(&meStmt);
+      VisitMeExpr(maydStmt->GetRHS());
+      break;
+    }
+    case OP_iassign: {
+      auto *ivarStmt = static_cast<IassignMeStmt*>(&meStmt);
+      VisitMeExpr(ivarStmt->GetRHS());
+      break;
+    }
+    case OP_syncenter:
+    case OP_syncexit: {
+      auto *syncMeStmt = static_cast<SyncMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = syncMeStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      break;
+    }
+    case OP_throw: {
+      auto *thrMeStmt = static_cast<ThrowMeStmt*>(&meStmt);
+      VisitMeExpr(thrMeStmt->GetOpnd());
+      break;
+    }
+    CASE_OP_ASSERT_NONNULL
+    case OP_eval:
+    case OP_igoto:
+    case OP_free: {
+      auto *unaryStmt = static_cast<UnaryMeStmt*>(&meStmt);
+      VisitMeExpr(unaryStmt->GetOpnd());
+      break;
+    }
+    case OP_asm:
+    case OP_call:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned: {
+      auto *callMeStmt = static_cast<CallMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = callMeStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      (void)DevirtualizeCall(*callMeStmt);
+      if (clone != nullptr && callMeStmt->GetOp() == OP_callassigned) {
+        MIRFunction &targetFunc = callMeStmt->GetTargetFunction();
+        clone->UpdateReturnVoidIfPossible(callMeStmt, targetFunc);
+      }
+      break;
+    }
+    case OP_icall:
+    case OP_icallassigned:
+    case OP_icallproto:
+    case OP_icallprotoassigned: {
+      auto *icallMeStmt = static_cast<IcallMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = icallMeStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      break;
+    }
+    case OP_intrinsiccallwithtype:
+    case OP_intrinsiccall:
+    case OP_xintrinsiccall:
+    case OP_intrinsiccallwithtypeassigned:
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned: {
+      auto *intrinCallStmt = static_cast<IntrinsiccallMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = intrinCallStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      break;
+    }
+    case OP_brtrue:
+    case OP_brfalse: {
+      auto *condGotoStmt = static_cast<CondGotoMeStmt*>(&meStmt);
+      VisitMeExpr(condGotoStmt->GetOpnd());
+      break;
+    }
+    case OP_switch: {
+      auto *switchStmt = static_cast<SwitchMeStmt*>(&meStmt);
+      VisitMeExpr(switchStmt->GetOpnd());
+      break;
+    }
+    case OP_return: {
+      auto *retMeStmt = static_cast<RetMeStmt*>(&meStmt);
+      const MapleVector<MeExpr*> &opnds = retMeStmt->GetOpnds();
+      for (size_t i = 0; i < opnds.size(); ++i) {
+        MeExpr *opnd = opnds[i];
+        VisitMeExpr(opnd);
+      }
+      ReturnTyIdxInferring(*retMeStmt);
+      break;
+    }
+    CASE_OP_ASSERT_BOUNDARY {
+      auto *assMeStmt = static_cast<NaryMeStmt*>(&meStmt);
+      VisitMeExpr(assMeStmt->GetOpnd(0));
+      VisitMeExpr(assMeStmt->GetOpnd(1));
+      break;
+    }
+    case OP_jstry:
+    case OP_jscatch:
+    case OP_finally:
+    case OP_endtry:
+    case OP_cleanuptry:
+    case OP_try:
+    case OP_catch:
+    case OP_goto:
+    case OP_gosub:
+    case OP_retsub:
+    case OP_comment:
+    case OP_membaracquire:
+    case OP_membarrelease:
+    case OP_membarstoreload:
+    case OP_membarstorestore:
+      break;
+    default:
+      CHECK_FATAL(false, "unexpected stmt in ssadevirt or NYI");
+  }
+  if (meStmt.GetOp() != OP_callassigned) {
+    return;
+  }
+  MapleVector<MustDefMeNode> *mustDefList = meStmt.GetMustDefList();
+  if (mustDefList->empty()) {
+    return;
+  }
+  MeExpr *meLHS = mustDefList->front().GetLHS();
+  if (meLHS->GetMeOp() != kMeOpVar) {
+    return;
+  }
+  auto *lhsVar = static_cast<VarMeExpr*>(meLHS);
+  auto *callMeStmt = static_cast<CallMeStmt*>(&meStmt);
+  MIRFunction &called = callMeStmt->GetTargetFunction();
+  if (called.GetInferredReturnTyIdx() != 0u) {
+    lhsVar->SetInferredTyIdx(called.GetInferredReturnTyIdx());
+    if (NonNullRetValue(called)) {
+      lhsVar->SetMaybeNull(false);
+    }
+    if (SSADevirtual::debug) {
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsVar->GetInferredTyIdx());
+      LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << lhsVar->GetExprID() << " ";
+      type->Dump(0, false);
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+
+void SSADevirtual::TraversalBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+  if (bbVisited[bb->GetBBId()]) {
+    return;
+  }
+  bbVisited[bb->GetBBId()] = true;
+  // traversal var phi nodes
+  MapleMap<OStIdx, MePhiNode*> &mePhiList = bb->GetMePhiList();
+  for (auto it = mePhiList.cbegin(); it != mePhiList.cend(); ++it) {
+    MePhiNode *phiMeNode = it->second;
+    if (phiMeNode == nullptr || phiMeNode->GetLHS()->GetMeOp() != kMeOpVar) {
+      continue;
+    }
+    VisitVarPhiNode(*phiMeNode);
+  }
+  // traversal reg phi nodes (NYI)
+  // traversal on stmt
+  for (auto &meStmt : bb->GetMeStmts()) {
+    TraversalMeStmt(meStmt);
+  }
+}
+
+void SSADevirtual::Perform(BB &entryBB) {
+  // Pre-order traverse the cominance tree, so that each def is traversed
+  // before its use
+  std::queue<BB*> bbList;
+  bbList.push(&entryBB);
+  while (!bbList.empty()) {
+    BB *bb = bbList.front();
+    bbList.pop();
+    TraversalBB(bb);
+    const auto &domChildren = dom->GetDomChildren(bb->GetID());
+    for (const auto &bbId : domChildren) {
+      bbList.push(GetBB(BBId(bbId)));
+    }
+  }
+  MIRFunction *mirFunc = GetMIRFunction();
+  if (mirFunc == nullptr) {
+    return;  // maybe wpo
+  }
+  if (!skipReturnTypeOpt && retTy == kSeen) {
+    mirFunc->SetInferredReturnTyIdx(this->inferredRetTyIdx);
+  }
+  if (SSADevirtual::debug) {
+    LogInfo::MapleLogger() << "[SSA-DEVIRT]" << " {virtualcalls: total " << (totalVirtualCalls - totalInterfaceCalls) <<
+        ", devirtualized " << optedVirtualCalls << "}" << " {interfacecalls: total " <<
+        totalInterfaceCalls << ", devirtualized " << optedInterfaceCalls << "}" <<
+        ", {null-checks: " << nullCheckCount << "}" << "\t" << mirFunc->GetName() << '\n';
+    if (mirFunc != nullptr && mirFunc->GetInferredReturnTyIdx() != 0u) {
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirFunc->GetInferredReturnTyIdx());
+      LogInfo::MapleLogger() << "[SSA-DEVIRT] [FUNC-RETTYPE] ";
+      type->Dump(0, false);
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/ssa_epre.cpp b/src/mapleall/maple_me/src/ssa_epre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..553e74548e46662bdc8eb4e3fbedee3fb3a23070
--- /dev/null
+++ b/src/mapleall/maple_me/src/ssa_epre.cpp
@@ -0,0 +1,541 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ssa_epre.h"
+
+namespace maple {
+MeExpr *SSAEPre::GetTruncExpr(const IvarMeExpr &theLHS, MeExpr &savedRHS) const {
+  MIRType *lhsType = theLHS.GetType();
+  if (lhsType->GetKind() != kTypeBitField) {
+    return &savedRHS;
+  }
+  MIRBitFieldType *bitfieldTy = static_cast<MIRBitFieldType *>(lhsType);
+  if (GetPrimTypeBitSize(savedRHS.GetPrimType()) <= bitfieldTy->GetFieldSize()) {
+    return &savedRHS;
+  }
+  // insert OP_zext or OP_sext
+  Opcode extOp = IsSignedInteger(savedRHS.GetPrimType()) ? OP_sext : OP_zext;
+  PrimType newPrimType = PTY_u32;
+  if (bitfieldTy->GetFieldSize() <= GetPrimTypeBitSize(PTY_u32)) {
+    if (IsSignedInteger(lhsType->GetPrimType())) {
+      newPrimType = PTY_i32;
+    }
+  } else {
+    if (IsSignedInteger(lhsType->GetPrimType())) {
+      newPrimType = PTY_i64;
+    } else {
+      newPrimType = PTY_u64;
+    }
+  }
+  OpMeExpr opmeexpr(-1, extOp, newPrimType, 1);
+  opmeexpr.SetBitsSize(bitfieldTy->GetFieldSize());
+  opmeexpr.SetOpnd(0, &savedRHS);
+  return irMap->HashMeExpr(opmeexpr);
+}
+
+void SSAEPre::GenerateSaveLHSRealocc(MeRealOcc &realOcc, ScalarMeExpr &regOrVar) {
+  CHECK_FATAL(realOcc.GetOpcodeOfMeStmt() == OP_iassign, "GenerateSaveLHSReal: only iassign expected");
+  auto *iass = static_cast<IassignMeStmt*>(realOcc.GetMeStmt());
+  IvarMeExpr *theLHS = iass->GetLHSVal();
+  MeExpr *savedRHS = iass->GetRHS();
+  TyIdx savedTyIdx = iass->GetTyIdx();
+  MapleMap<OStIdx, ChiMeNode*> savedChiList = *iass->GetChiList();
+  iass->GetChiList()->clear();
+  SrcPosition savedSrcPos = iass->GetSrcPosition();
+  BB *savedBB = iass->GetBB();
+  MeStmt *savedPrev = iass->GetPrev();
+  MeStmt *savedNext = iass->GetNext();
+  AssignMeStmt *rass = nullptr;
+  // update rhs if the iassign need extension
+  savedRHS = GetTruncExpr(*theLHS, *savedRHS);
+  if (!workCand->NeedLocalRefVar() || GetPlacementRCOn()) {
+    CHECK_FATAL(regOrVar.GetMeOp() == kMeOpReg, "GenerateSaveLHSRealocc: EPRE temp must b e preg here");
+    PrimType lhsPrimType = theLHS->GetType()->GetPrimType();
+    if (GetPrimTypeSize(savedRHS->GetPrimType()) > GetPrimTypeSize(lhsPrimType)) {
+      // insert integer truncation to the rhs
+      if (GetPrimTypeSize(lhsPrimType) >= 4) {
+        savedRHS = irMap->CreateMeExprTypeCvt(lhsPrimType, savedRHS->GetPrimType(), *savedRHS);
+      } else {
+        Opcode extOp = IsSignedInteger(lhsPrimType) ? OP_sext : OP_zext;
+        PrimType newPrimType = PTY_u32;
+        if (IsSignedInteger(lhsPrimType)) {
+          newPrimType = PTY_i32;
+        }
+        OpMeExpr opmeexpr(-1, extOp, newPrimType, 1);
+        opmeexpr.SetBitsSize(static_cast<uint8>(GetPrimTypeSize(lhsPrimType) * 8));
+        opmeexpr.SetOpnd(0, savedRHS);
+        savedRHS = irMap->HashMeExpr(opmeexpr);
+      }
+    }
+    // change original iassign to regassign;
+    // use placement new to modify in place, because other occ nodes are pointing
+    // to this statement in order to get to the rhs expression;
+    // this assumes AssignMeStmt has smaller size then IassignMeStmt
+    rass = new (iass) AssignMeStmt(OP_regassign, static_cast<RegMeExpr*>(&regOrVar), savedRHS);
+    rass->SetSrcPos(savedSrcPos);
+    rass->SetBB(savedBB);
+    rass->SetPrev(savedPrev);
+    rass->SetNext(savedNext);
+    regOrVar.SetDefByStmt(*rass);
+  } else {
+    // regOrVar is kMeOpReg and localRefVar is kMeOpVar
+    VarMeExpr *localRefVar = CreateNewCurLocalRefVar();
+    temp2LocalRefVarMap[static_cast<RegMeExpr*>(&regOrVar)] = localRefVar;
+    // generate localRefVar = saved_rhs by changing original iassign to dassign;
+    // use placement new to modify in place, because other occ nodes are pointing
+    // to this statement in order to get to the rhs expression;
+    // this assumes DassignMeStmt has smaller size then IassignMeStmt
+    DassignMeStmt *dass = new (iass) DassignMeStmt(&irMap->GetIRMapAlloc(), localRefVar, savedRHS);
+    dass->SetSrcPos(savedSrcPos);
+    dass->SetBB(savedBB);
+    dass->SetPrev(savedPrev);
+    dass->SetNext(savedNext);
+    localRefVar->SetDefByStmt(*dass);
+
+    // generate regOrVar = localRefVar
+    rass = irMap->CreateAssignMeStmt(regOrVar, *localRefVar, *savedBB);
+    regOrVar.SetDefByStmt(*rass);
+    savedBB->InsertMeStmtAfter(dass, rass);
+    EnterCandsForSSAUpdate(localRefVar->GetOstIdx(), *savedBB);
+  }
+  // create new iassign for original lhs
+  IassignMeStmt *newIass = irMap->NewInPool<IassignMeStmt>(savedTyIdx, theLHS, &regOrVar, &savedChiList);
+  theLHS->SetDefStmt(newIass);
+  newIass->SetBB(savedBB);
+  savedBB->InsertMeStmtAfter(rass, newIass);
+  // go throu saved_Chi_List to update each chi base to point to newIass
+  for (auto it = newIass->GetChiList()->cbegin(); it != newIass->GetChiList()->cend(); ++it) {
+    ChiMeNode *chi = it->second;
+    chi->SetBase(newIass);
+  }
+  realOcc.SetSavedExpr(regOrVar);
+}
+
+void SSAEPre::GenerateSaveRealOcc(MeRealOcc &realOcc) {
+  ASSERT(GetPUIdx() == workCand->GetPUIdx() || workCand->GetPUIdx() == 0,
+         "GenerateSaveRealOcc: inconsistent puIdx");
+  ScalarMeExpr *regOrVar = CreateNewCurTemp(*realOcc.GetMeExpr());
+  if (realOcc.IsLHS()) {
+    GenerateSaveLHSRealocc(realOcc, *regOrVar);
+    return;
+  }
+  // create a new meStmt before realOcc->GetMeStmt()
+  MeStmt *newMeStmt = nullptr;
+  bool isRHSOfDassign = false;
+  if (workCand->NeedLocalRefVar() && (realOcc.GetOpcodeOfMeStmt() == OP_dassign) &&
+      (realOcc.GetMeStmt()->GetOpnd(0) == realOcc.GetMeExpr())) {
+    isRHSOfDassign = true;
+    // setting flag so delegaterc will skip
+    static_cast<VarMeExpr*>(static_cast<DassignMeStmt*>(realOcc.GetMeStmt())->GetVarLHS())->SetNoDelegateRC(true);
+  }
+  if (!workCand->NeedLocalRefVar() || isRHSOfDassign || GetPlacementRCOn()) {
+    newMeStmt = irMap->CreateAssignMeStmt(*regOrVar, *realOcc.GetMeExpr(), *realOcc.GetMeStmt()->GetBB());
+    regOrVar->SetDefByStmt(*newMeStmt);
+    realOcc.GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc.GetMeStmt(), newMeStmt);
+  } else {
+    // regOrVar is MeOp_reg and localRefVar is kMeOpVar
+    VarMeExpr *localRefVar = CreateNewCurLocalRefVar();
+    temp2LocalRefVarMap[static_cast<RegMeExpr*>(regOrVar)] = localRefVar;
+    newMeStmt = irMap->CreateAssignMeStmt(*localRefVar, *realOcc.GetMeExpr(), *realOcc.GetMeStmt()->GetBB());
+    localRefVar->SetDefByStmt(*newMeStmt);
+    realOcc.GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc.GetMeStmt(), newMeStmt);
+    newMeStmt = irMap->CreateAssignMeStmt(*regOrVar, *localRefVar, *realOcc.GetMeStmt()->GetBB());
+    regOrVar->SetDefByStmt(*newMeStmt);
+    realOcc.GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc.GetMeStmt(), newMeStmt);
+    EnterCandsForSSAUpdate(localRefVar->GetOstIdx(), *realOcc.GetMeStmt()->GetBB());
+  }
+  newMeStmt->CopyInfo(*realOcc.GetMeStmt());
+  EnterCandsForSSAUpdate(regOrVar->GetOstIdx(), *realOcc.GetMeStmt()->GetBB());
+  // replace realOcc->GetMeStmt()'s occ with regOrVar
+  bool isReplaced = irMap->ReplaceMeExprStmt(*realOcc.GetMeStmt(), *realOcc.GetMeExpr(), *regOrVar);
+  // rebuild worklist
+  if (isReplaced  && !ReserveCalFuncAddrForDecouple(*realOcc.GetMeExpr())) {
+    BuildWorkListStmt(*realOcc.GetMeStmt(), static_cast<uint32>(realOcc.GetSequence()), true, regOrVar);
+  }
+  realOcc.SetSavedExpr(*regOrVar);
+}
+
+#ifdef USE_32BIT_REF
+static constexpr int kFieldIDOfFuncAddrInClassMeta = 8;
+#else
+static constexpr int kFieldIDOfFuncAddrInClassMeta = 6;
+#endif
+bool SSAEPre::ReserveCalFuncAddrForDecouple(MeExpr &meExpr) const {
+  if (!Options::buildApp) {
+    return false;
+  }
+  bool virtualFuncAddr = false;
+  if (meExpr.GetMeOp() == kMeOpIvar) {
+    auto &ivar = static_cast<IvarMeExpr&>(meExpr);
+    auto ptrTyIdx = ivar.GetTyIdx();
+    auto *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTyIdx);
+    virtualFuncAddr =
+        (static_cast<MIRPtrType*>(ptrType)->GetPointedType()->GetName() == namemangler::kClassMetadataTypeName) &&
+        (ivar.GetFieldID() == kFieldIDOfFuncAddrInClassMeta);
+  }
+  return virtualFuncAddr;
+}
+
+void SSAEPre::GenerateReloadRealOcc(MeRealOcc &realOcc) {
+  CHECK_FATAL(!realOcc.IsLHS(), "GenerateReloadRealOcc: cannot be LHS occurrence");
+  MeExpr *regOrVar = nullptr;
+  MeOccur *defOcc = realOcc.GetDef();
+  if (defOcc->GetOccType() == kOccReal) {
+    auto *defRealOcc = static_cast<MeRealOcc*>(defOcc);
+    regOrVar = defRealOcc->GetSavedExpr();
+  } else if (defOcc->GetOccType() == kOccPhiocc) {
+    auto *defPhiOcc = static_cast<MePhiOcc*>(defOcc);
+    MePhiNode *regPhi = defPhiOcc->GetRegPhi();
+    if (regPhi != nullptr) {
+      regOrVar = regPhi->GetLHS();
+    } else {
+      regOrVar = defPhiOcc->GetVarPhi()->GetLHS();
+    }
+  } else if (defOcc->GetOccType() == kOccInserted) {
+    auto *defInsertedOcc = static_cast<MeInsertedOcc*>(defOcc);
+    regOrVar = defInsertedOcc->GetSavedExpr();
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+  ASSERT(regOrVar != nullptr, "temp not yet generated");
+  // replace realOcc->GetMeStmt()'s occ with regOrVar
+  bool isReplaced = irMap->ReplaceMeExprStmt(*realOcc.GetMeStmt(), *realOcc.GetMeExpr(), *regOrVar);
+  // update worklist
+  if (isReplaced && !ReserveCalFuncAddrForDecouple(*realOcc.GetMeExpr())) {
+    BuildWorkListStmt(*realOcc.GetMeStmt(), static_cast<uint32>(realOcc.GetSequence()), true, regOrVar);
+  }
+}
+
+// for each variable in realz that is defined by a phi, replace it by the jth phi opnd
+MeExpr *SSAEPre::PhiOpndFromRes(MeRealOcc &realZ, size_t j) const {
+  MeOccur *defZ = realZ.GetDef();
+  CHECK_FATAL(defZ != nullptr, "must be def by phiocc");
+  CHECK_FATAL(defZ->GetOccType() == kOccPhiocc, "must be def by phiocc");
+  BB *ePhiBB = defZ->GetBB();
+  switch (realZ.GetMeExpr()->GetMeOp()) {
+    case kMeOpOp: {
+      OpMeExpr opMeExpr(*static_cast<OpMeExpr*>(realZ.GetMeExpr()), -1);
+      for (size_t i = 0; i < opMeExpr.GetNumOpnds(); ++i) {
+        MeExpr *retOpnd = GetReplaceMeExpr(*opMeExpr.GetOpnd(i), *ePhiBB, j);
+        if (retOpnd != nullptr) {
+          opMeExpr.SetOpnd(i, retOpnd);
+        } else if (workCand->isSRCand) {
+          ScalarMeExpr *curScalar = dynamic_cast<ScalarMeExpr *>(opMeExpr.GetOpnd(i));
+          if (curScalar != nullptr) {
+            while (!DefVarDominateOcc(curScalar, *defZ)) {
+              curScalar = ResolveOneInjuringDef(curScalar);
+              opMeExpr.SetOpnd(i, curScalar);
+            }
+          }
+        }
+      }
+      opMeExpr.SetHasAddressValue();
+      return irMap->HashMeExpr(opMeExpr);
+    }
+    case kMeOpNary: {
+      NaryMeExpr naryMeExpr(&irMap->GetIRMapAlloc(), -1, *static_cast<NaryMeExpr*>(realZ.GetMeExpr()));
+      for (size_t i = 0; i < naryMeExpr.GetNumOpnds(); i++) {
+        MeExpr *retOpnd = GetReplaceMeExpr(*naryMeExpr.GetOpnd(i), *ePhiBB, j);
+        if (retOpnd != nullptr) {
+          naryMeExpr.SetOpnd(i, retOpnd);
+        }
+      }
+      return irMap->HashMeExpr(naryMeExpr);
+    }
+    case kMeOpIvar: {
+      IvarMeExpr ivarMeExpr(&irMap->GetIRMapAlloc(), -1, *static_cast<IvarMeExpr*>(realZ.GetMeExpr()));
+      MeExpr *retOpnd = GetReplaceMeExpr(*ivarMeExpr.GetBase(), *ePhiBB, j);
+      if (retOpnd != nullptr) {
+        ivarMeExpr.SetBase(retOpnd);
+      }
+      for (size_t i = 0; i < ivarMeExpr.GetMuList().size(); ++i) {
+        auto *mu = ivarMeExpr.GetMuList()[i];
+        MeExpr *muOpnd = GetReplaceMeExpr(*mu, *ePhiBB, j);
+        if (muOpnd != nullptr) {
+          ivarMeExpr.SetMuItem(i, static_cast<VarMeExpr*>(muOpnd));
+        }
+      }
+      return irMap->HashMeExpr(ivarMeExpr);
+    }
+    default:
+      ASSERT(false, "NYI");
+  }
+  return nullptr;
+}
+
+bool SSAEPre::AllVarsSameVersion(const MeRealOcc &realocc1, const MeRealOcc &realocc2) const {
+  if (realocc1.GetMeExpr() == realocc2.GetMeExpr()) {
+    return true;
+  } else if (!workCand->isSRCand) {
+    return false;
+  }
+  // for each var operand in realocc2, check if it can resolve to the
+  // corresponding operand in realocc1 via ResolveOneInjuringDef()
+  for (uint8 i = 0; i < realocc2.GetMeExpr()->GetNumOpnds(); i++) {
+    MeExpr *curopnd = realocc2.GetMeExpr()->GetOpnd(i);
+    if (curopnd->GetMeOp() != kMeOpVar && curopnd->GetMeOp() != kMeOpReg) {
+      continue;
+    }
+    if (curopnd == realocc1.GetMeExpr()->GetOpnd(i)) {
+      continue;
+    }
+    MeExpr *resolvedOpnd = ResolveAllInjuringDefs(curopnd);
+    if (resolvedOpnd == curopnd || resolvedOpnd != realocc1.GetMeExpr()->GetOpnd(i)) {
+      return false;
+    }
+    else {
+      continue;
+    }
+  }
+  return true;
+}
+
+// Df phis are computed into the df_phis set; Var Phis in the var_phis set
+void SSAEPre::ComputeVarAndDfPhis() {
+  varPhiDfns.clear();
+  dfPhiDfns.clear();
+  const MapleVector<MeRealOcc*> &realOccList = workCand->GetRealOccs();
+  CHECK_FATAL(!dom->IsNodeVecEmpty(), "size to be allocated is 0");
+  for (auto it = realOccList.begin(); it != realOccList.end(); ++it) {
+    MeRealOcc *realOcc = *it;
+    if (realOcc->GetOccType() == kOccCompare) {
+      continue;
+    }
+    BB *defBB = realOcc->GetBB();
+    GetIterDomFrontier(defBB, &dfPhiDfns);
+    MeExpr *meExpr = realOcc->GetMeExpr();
+    for (uint8 i = 0; i < meExpr->GetNumOpnds(); i++) {
+      SetVarPhis(meExpr->GetOpnd(i));
+    }
+    // for ivar, compute mu's phi too
+    if (meExpr->GetMeOp() == kMeOpIvar) {
+      for (auto *mu : static_cast<IvarMeExpr*>(meExpr)->GetMuList()) {
+        if (mu == nullptr) {
+          continue;
+        }
+        SetVarPhis(mu);
+      }
+    }
+  }
+  std::set<uint32> tmpVarPhi(varPhiDfns.begin(), varPhiDfns.end());
+  for (uint32 dfn : tmpVarPhi) {
+    GetIterDomFrontier(GetBB(BBId(dom->GetDtPreOrderItem(dfn))), &varPhiDfns);
+  }
+}
+
+// build worklist for each expression;
+// isRebuild means the expression is not built in step 0, in which case,
+// tempVar is not nullptr, and it matches only expressions with tempVar as one of
+// its operands; isRebuild is true only when called from the code motion phase.
+// insertSorted is for passing to CreateRealOcc.  Most of the time, isRebuild implies insertSorted,
+// except when invoked from LFTR.
+void SSAEPre::BuildWorkListExpr(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool isRebuild, MeExpr *tempVar,
+                                bool isRootExpr, bool insertSorted) {
+  if (meExpr.GetTreeID() == (curTreeId + 1)) {
+    return;  // already visited twice in the same tree
+  }
+  MeExprOp meOp = meExpr.GetMeOp();
+  switch (meOp) {
+    case kMeOpOp: {
+      auto *meOpExpr = static_cast<OpMeExpr*>(&meExpr);
+      bool isFirstOrder = true;
+      bool hasTempVarAs1Opnd = false;
+      for (uint32 i = 0; i < meOpExpr->GetNumOpnds(); i++) {
+        MeExpr *opnd = meOpExpr->GetOpnd(i);
+        if (!opnd->IsLeaf()) {
+          BuildWorkListExpr(meStmt, seqStmt, *opnd, isRebuild, tempVar, false, insertSorted);
+          isFirstOrder = false;
+        } else if (LeafIsVolatile(opnd)) {
+          isFirstOrder = false;
+        } else if (tempVar != nullptr && opnd->IsUseSameSymbol(*tempVar)) {
+          hasTempVarAs1Opnd = true;
+        }
+      }
+      if (!isFirstOrder) {
+        break;
+      }
+      if (meExpr.GetPrimType() == PTY_agg) {
+        break;
+      }
+      if (isRootExpr && kOpcodeInfo.IsCompare(meOpExpr->GetOp())) {
+        if (doLFTR) {
+          CreateCompOcc(&meStmt, seqStmt, meOpExpr, isRebuild);
+        }
+        break;
+      }
+      if (!epreIncludeRef && meOpExpr->GetPrimType() == PTY_ref) {
+        break;
+      }
+      if (meOpExpr->GetOp() == OP_gcmallocjarray || meOpExpr->GetOp() == OP_gcmalloc ||
+          meOpExpr->GetOp() == OP_retype) {
+        break;
+      }
+      if (isRebuild && !hasTempVarAs1Opnd) {
+        break;
+      }
+      CreateRealOcc(meStmt, seqStmt, meExpr, insertSorted);
+      break;
+    }
+    case kMeOpNary: {
+      auto *naryMeExpr = static_cast<NaryMeExpr*>(&meExpr);
+      bool isFirstOrder = true;
+      bool hasTempVarAs1Opnd = false;
+      MapleVector<MeExpr*> &opnds = naryMeExpr->GetOpnds();
+      for (auto it = opnds.begin(); it != opnds.end(); ++it) {
+        MeExpr *opnd = *it;
+        if (!opnd->IsLeaf()) {
+          BuildWorkListExpr(meStmt, seqStmt, *opnd, isRebuild, tempVar, false, insertSorted);
+          isFirstOrder = false;
+        } else if (LeafIsVolatile(opnd)) {
+          isFirstOrder = false;
+        } else if (tempVar != nullptr && opnd->IsUseSameSymbol(*tempVar)) {
+          hasTempVarAs1Opnd = true;
+        }
+      }
+      if (meExpr.GetPrimType() == PTY_agg) {
+        isFirstOrder = false;
+      }
+      constexpr uint32 minTypeSizeRequired = 4;
+      if (isFirstOrder && (!isRebuild || hasTempVarAs1Opnd) && naryMeExpr->GetPrimType() != PTY_u1 &&
+          (GetPrimTypeSize(naryMeExpr->GetPrimType()) >= minTypeSizeRequired ||
+           IsPrimitivePoint(naryMeExpr->GetPrimType()) ||
+           (naryMeExpr->GetOp() == OP_intrinsicop && IntrinDesc::intrinTable[naryMeExpr->GetIntrinsic()].IsPure())) &&
+          (epreIncludeRef || naryMeExpr->GetPrimType() != PTY_ref)) {
+        if (meExpr.GetOp() == OP_array) {
+          MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(naryMeExpr->GetTyIdx());
+          CHECK_FATAL(mirType->GetKind() == kTypePointer, "array must have pointer type");
+          auto *ptrMIRType = static_cast<MIRPtrType*>(mirType);
+          MIRJarrayType *arryType = safe_cast<MIRJarrayType>(ptrMIRType->GetPointedType());
+          if (arryType == nullptr) {
+            CreateRealOcc(meStmt, seqStmt, meExpr, insertSorted);
+          } else {
+            int dim = arryType->GetDim();  // to compute the dim field
+            if (dim <= 1) {
+              CreateRealOcc(meStmt, seqStmt, meExpr, insertSorted);
+            } else {
+              if (GetSSAPreDebug()) {
+                mirModule->GetOut() << "----- real occ suppressed for jarray with dim " << dim << '\n';
+              }
+            }
+          }
+        } else {
+          IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[naryMeExpr->GetIntrinsic()];
+          if (CfgHasDoWhile() && naryMeExpr->GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH) {
+            auto *varOpnd = safe_cast<VarMeExpr>(naryMeExpr->GetOpnd(0));
+            if (varOpnd != nullptr) {
+              const OriginalSt *ost = varOpnd->GetOst();
+              if (ost->IsFormal()) {
+                break;
+              }
+            }
+          }
+          if (!intrinDesc->IsLoadMem()) {
+            CreateRealOcc(meStmt, seqStmt, meExpr, insertSorted);
+          }
+        }
+      }
+      break;
+    }
+    case kMeOpIvar: {
+      auto *ivarMeExpr = static_cast<IvarMeExpr*>(&meExpr);
+      MeExpr *base = ivarMeExpr->GetBase();
+      if (!base->IsLeaf()) {
+        BuildWorkListExpr(meStmt, seqStmt, *ivarMeExpr->GetBase(), isRebuild, tempVar, false, insertSorted);
+      } else if (meExpr.GetPrimType() == PTY_agg) {
+        break;
+      } else if (ivarMeExpr->IsVolatile()) {
+        break;
+      } else if (IsThreadObjField(*ivarMeExpr)) {
+        break;
+      } else if (base->GetMeOp() == kMeOpConststr || base->GetMeOp() == kMeOpConststr16) {
+        break;
+      } else if (!epreIncludeRef && ivarMeExpr->GetPrimType() == PTY_ref) {
+        break;
+      } else if (!isRebuild || base->IsUseSameSymbol(*tempVar)) {
+        CreateRealOcc(meStmt, seqStmt, meExpr, insertSorted);
+      }
+      break;
+    }
+    case kMeOpVar:
+    case kMeOpReg:
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+    case kMeOpAddroflabel:
+    case kMeOpGcmalloc:
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpSizeoftype:
+    case kMeOpFieldsDist:
+      break;
+    default:
+      CHECK_FATAL(false, "MeOP NIY");
+  }
+  if (meExpr.GetTreeID() == curTreeId) {
+    meExpr.SetTreeID(curTreeId + 1);  // just processed 2nd time; not
+  } else {  // to be processed again in this tree
+    meExpr.SetTreeID(curTreeId);  // just processed 1st time; willing to process one more time
+  }
+}
+
+void SSAEPre::BuildWorkListIvarLHSOcc(MeStmt &meStmt, int32 seqStmt, bool isRebuild, MeExpr *tempVar) {
+  if (!enableLHSIvar || GetPlacementRCOn()) {
+    return;
+  }
+  if (meStmt.GetOp() != OP_iassign) {
+    return;
+  }
+  auto *iass = static_cast<IassignMeStmt*>(&meStmt);
+  IvarMeExpr *ivarMeExpr = iass->GetLHSVal();
+  if (ivarMeExpr->GetPrimType() == PTY_agg) {
+    return;
+  }
+  if (ivarMeExpr->IsVolatile()) {
+    return;
+  }
+  if (!epreIncludeRef && ivarMeExpr->GetPrimType() == PTY_ref) {
+    return;
+  }
+  MeExpr *base = ivarMeExpr->GetBase();
+  if (!base->IsLeaf()) {
+    return;
+  }
+  if (base->GetMeOp() == kMeOpConststr || base->GetMeOp() == kMeOpConststr16) {
+    return;
+  }
+  if (!isRebuild || base->IsUseSameSymbol(*tempVar)) {
+    CreateRealOcc(meStmt, seqStmt, *ivarMeExpr, isRebuild, true);
+  }
+}
+
+// collect meExpr's variables and put them into varVec
+// varVec can only store RegMeExpr and VarMeExpr
+void SSAEPre::CollectVarForMeExpr(MeExpr &meExpr, std::vector<MeExpr*> &varVec) const {
+  for (uint8 i = 0; i < meExpr.GetNumOpnds(); i++) {
+    MeExpr *opnd = meExpr.GetOpnd(i);
+    if (opnd->GetMeOp() == kMeOpVar || opnd->GetMeOp() == kMeOpReg) {
+      varVec.push_back(opnd);
+    }
+  }
+  if (meExpr.GetMeOp() == kMeOpIvar) {
+    for (auto *mu : static_cast<IvarMeExpr&>(meExpr).GetMuList()) {
+      varVec.push_back(mu);
+    }
+  }
+}
+
+void SSAEPre::CollectVarForCand(MeRealOcc &realOcc, std::vector<MeExpr*> &varVec) const {
+  CollectVarForMeExpr(*realOcc.GetMeExpr(), varVec);
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/ssa_epre_for_lftr.cpp b/src/mapleall/maple_me/src/ssa_epre_for_lftr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7e10036a9e34d3379d3101f1e34ba33cbd44856a
--- /dev/null
+++ b/src/mapleall/maple_me/src/ssa_epre_for_lftr.cpp
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "ssa_epre.h"
+
+namespace maple {
+
+// Find the SSA version of scalar at stmt by search backward for its def.
+// When reaching the beginning of BB, continue with parent BB in the dominator
+// tree.  It is assumed that scalarOst has no alias, so chi lists are skipped.
+ScalarMeExpr *SSAEPre::FindScalarVersion(ScalarMeExpr *scalar, MeStmt *stmt) const {
+  if (scalar->GetOst()->NumSSAVersions() == 1) {
+    return scalar;
+  }
+  BB *bb = stmt->GetBB();
+  stmt = stmt->GetPrev();
+  ScalarMeExpr *lhs = nullptr;
+  do {
+    // go thru the statements in reverse order
+    while (stmt != nullptr) {
+      AssignMeStmt *asStmt = dynamic_cast<AssignMeStmt*>(stmt);
+      if (asStmt != nullptr) {
+        lhs = asStmt->GetLHS();
+        if (lhs->GetOst() == scalar->GetOst()) {
+          return lhs;
+        }
+      } else {
+        CallMeStmt *callStmt = dynamic_cast<CallMeStmt*>(stmt);
+        if (callStmt != nullptr) {
+          lhs = callStmt->GetAssignedLHS();
+          if (lhs != nullptr && lhs->GetOst() == scalar->GetOst()) {
+            return lhs;
+          }
+        }
+      }
+      stmt = stmt->GetPrev();
+    }
+    // check if there is phi
+    MapleMap<OStIdx, MePhiNode*> &mePhiList = bb->GetMePhiList();
+    auto it = mePhiList.find(scalar->GetOst()->GetIndex());
+    if (it != mePhiList.cend()) {
+      return it->second->GetLHS();
+    }
+    // set bb to its parent in dominator tree
+    bb = GetBB(BBId(dom->GetDom(bb->GetID())->GetID()));
+    // make stmt point to last statement in bb
+    stmt = to_ptr(bb->GetMeStmts().rbegin());
+  } while (true);
+  CHECK_FATAL(false, "FindScalarVersion: fail to find SSA version for scalar");
+  return nullptr;
+}
+
+// one side of compare is an operand x in workCand->GetTheMeExpr() with current
+// occurrence occExpr; replace that side of the compare by regorvar; replace the
+// other side of compare by the expression formed by substituting x in occExpr
+// by that side of the compare; if the new compare side cannot be folded to a
+// leaf, enter into EPRE work list
+// EXAMPLE 1: INPUT: workCand is (i + 4), compare is (i < n)
+//            RETURN: regorvar < (n + 4)
+//            (n + 4) added to EPRE work list
+// EXAMPLE 2: INPUT: workCand is (i * 3), compare is (n == i)
+//            RETURN: n * 3 == regorvar
+//            (n * 3) added to EPRE work list
+// EXAMPLE 3: INPUT: workCand is (i + &A), compare is (i < 100)
+//            RETURN: regorvar < 100 + &A
+//            100 + &A is folded to an OP_addrof node
+// EXAMPLE 4: INPUT: workCand is (i + p), compare is (i < 100)
+//            RETURN: regorvar < 100 + p (need to find p's SSA version there)
+//            100 + p is added to EPRE work list
+OpMeExpr *SSAEPre::FormLFTRCompare(MeRealOcc *compOcc, MeExpr *regorvar) {
+  auto *compare = static_cast<OpMeExpr*>(compOcc->GetMeExpr());
+  // determine the ith operand of workCand that is the jth operand of compare
+  OpMeExpr *x = static_cast<OpMeExpr *>(workCand->GetTheMeExpr());
+  size_t i;
+  size_t j = 0;
+  for (i = 0; i < x->GetNumOpnds(); i++) {
+    ScalarMeExpr *iv = dynamic_cast<ScalarMeExpr *>(x->GetOpnd(i));
+    if (iv == nullptr) {
+      continue;
+    }
+    ScalarMeExpr *compareOpnd = dynamic_cast<ScalarMeExpr *>(compare->GetOpnd(0));
+    if (compareOpnd != nullptr && iv->GetOst() == compareOpnd->GetOst()) {
+      j = 0;
+      break;
+    }
+    compareOpnd = dynamic_cast<ScalarMeExpr *>(compare->GetOpnd(1));
+    if (compareOpnd != nullptr && iv->GetOst() == compareOpnd->GetOst()) {
+      j = 1;
+      break;
+    }
+  }
+  ASSERT(j == 0 || j == 1, "FormLFTRCompare: cannot correspond comp occ to workcand");
+  // handle the ops corresponding to OpMeExpr::StrengthReducible()
+  OpMeExpr newSide(-1, x->GetOp(), x->GetPrimType(), x->GetNumOpnds());
+  newSide.SetOpnd(i, compare->GetOpnd(1 - j));
+  switch (x->GetOp()) {
+    case OP_cvt: {
+      newSide.SetOpndType(x->GetOpndType());
+      break;
+    }
+    case OP_mul: {
+      newSide.SetOpnd(1 - i, x->GetOpnd(1 - i));
+      break;
+    }
+    case OP_add:
+    case OP_sub: {
+      ScalarMeExpr *scalarOpnd = dynamic_cast<ScalarMeExpr *>(x->GetOpnd(1 - i));
+      if (scalarOpnd == nullptr) {
+        newSide.SetOpnd(1 - i, x->GetOpnd(1 - i));
+      } else {
+        scalarOpnd = FindScalarVersion(scalarOpnd, compOcc->GetMeStmt());
+        newSide.SetOpnd(1 - i, scalarOpnd);
+      }
+      break;
+    }
+    default: {
+      ASSERT(false, "FormLFTRCompare: unrecognized strength reduction operation");
+      return nullptr;
+    }
+  }
+  newSide.SetHasAddressValue();
+  // check if newSide can be folded
+  MeExpr *simplifyExpr = irMap->SimplifyOpMeExpr(&newSide);
+  MeExpr *hashedSide = nullptr;
+  if (simplifyExpr != nullptr) {
+    hashedSide = simplifyExpr;
+  } else {
+    hashedSide = irMap->HashMeExpr(newSide);
+    BuildWorkListExpr(*compOcc->GetMeStmt(), compOcc->GetSequence(), *hashedSide, false, nullptr, true, true);
+  }
+  // try to preserve the opndtype signedness of the original comparison
+  PrimType newCmpOpndType = regorvar->GetPrimType();
+  if (IsSignedInteger(regorvar->GetPrimType()) != IsSignedInteger(compare->GetOpndType()) &&
+      compare->GetOp() != OP_ne && compare->GetOp() != OP_eq) {
+    newCmpOpndType = IsSignedInteger(regorvar->GetPrimType()) ? GetUnsignedPrimType(regorvar->GetPrimType()) :
+                                                                GetSignedPrimType(regorvar->GetPrimType());
+  }
+  OpMeExpr newcompare(-1, compare->GetOp(), compare->GetPrimType(), 2);
+  newcompare.SetOpndType(newCmpOpndType);
+  newcompare.SetOpnd(j, regorvar);
+  newcompare.SetOpnd(1 - j, hashedSide);
+  return static_cast<OpMeExpr *>(irMap->HashMeExpr(newcompare));
+}
+
+static bool IsLargeInteger(ConstMeExpr *constOpnd) {
+  MIRIntConst *intconst = dynamic_cast<MIRIntConst *>(constOpnd->GetConstVal());
+  if (intconst == nullptr) {
+    return false;
+  }
+  return intconst->GetExtValue() > 0x8000000;
+}
+
+void SSAEPre::CreateCompOcc(MeStmt *meStmt, int seqStmt, OpMeExpr *compare, bool isRebuilt) {
+  if (compare->GetOpnd(0)->GetNumOpnds() > 0 &&
+      compare->GetOpnd(1)->GetNumOpnds() > 0) {
+    // one side of compare must be leaf
+    return;
+  }
+  if (!IsPrimitiveInteger(compare->GetPrimType())) {
+    return;
+  }
+  ScalarMeExpr *compareLHS = dynamic_cast<ScalarMeExpr *>(compare->GetOpnd(0));
+  ScalarMeExpr *compareRHS = dynamic_cast<ScalarMeExpr *>(compare->GetOpnd(1));
+  if (compareLHS == nullptr && compareRHS == nullptr) {
+    return;
+  }
+  // see if either side is a large integer
+  bool largeIntLimit = false;
+  ConstMeExpr *constopnd = dynamic_cast<ConstMeExpr *>(compare->GetOpnd(0));
+  if (constopnd == nullptr) {
+    constopnd = dynamic_cast<ConstMeExpr *>(compare->GetOpnd(1));
+  }
+  if (constopnd) {
+    largeIntLimit = IsLargeInteger(constopnd);
+  }
+  // search for worklist candidates set isSRCand such that one of its operands
+  // is either compareLHS or compareRHS, and create MeRealOcc for each of them
+  for (PreWorkCand *wkCand : std::as_const(workList)) {
+    if (!wkCand->isSRCand) {
+      continue;
+    }
+    if (wkCand->GetTheMeExpr()->GetOp() == OP_add || wkCand->GetTheMeExpr()->GetOp() == OP_sub) {
+      if (largeIntLimit) {
+        continue;
+      }
+      // skip if it has a larger integer operand
+      ConstMeExpr *candConstOpnd = dynamic_cast<ConstMeExpr *>(wkCand->GetTheMeExpr()->GetOpnd(0));
+      if (candConstOpnd == nullptr) {
+        candConstOpnd = dynamic_cast<ConstMeExpr *>(wkCand->GetTheMeExpr()->GetOpnd(1));
+      }
+      if (candConstOpnd && IsLargeInteger(candConstOpnd)) {
+        continue;
+      }
+    }
+
+    if (wkCand->GetTheMeExpr()->GetOp() == OP_sub && IsUnsignedInteger(compare->GetOpndType())) {
+      continue;
+    }
+    MeExpr *x = wkCand->GetTheMeExpr();
+    uint32 numRelevantOpnds = 0;
+    bool isRelevant = true;
+    for (size_t i = 0; i < x->GetNumOpnds(); i++) {
+      ScalarMeExpr *iv = dynamic_cast<ScalarMeExpr *>(x->GetOpnd(i));
+      if (iv == nullptr) {
+        continue;
+      }
+      if (x->GetOp() == OP_sub && i == 1) {  // disqualify if subtracting a var
+        isRelevant = false;
+        break;
+      }
+      if ((compareLHS && iv->GetOst() == compareLHS->GetOst()) ||
+          (compareRHS && iv->GetOst() == compareRHS->GetOst())) {
+        numRelevantOpnds++;
+      } else {
+        // disqualify as compocc if x has a scalar which is not used in the comparison and has multiple SSA versions
+        // and is not preg
+        if (iv->GetOst()->NumSSAVersions() > 1 && !iv->GetOst()->IsPregOst()) {
+          isRelevant = false;
+          break;
+        }
+      }
+    }
+    if (isRelevant && numRelevantOpnds == 1) {
+      MeRealOcc *compOcc = ssaPreMemPool->New<MeRealOcc>(meStmt, seqStmt, compare);
+      compOcc->SetOccType(kOccCompare);
+      if (isRebuilt) {
+        // insert to realOccs in dt_preorder of the BBs and seq in each BB
+        wkCand->AddRealOccSorted(*dom, *compOcc, GetPUIdx());
+      } else {
+        wkCand->AddRealOccAsLast(*compOcc, GetPUIdx());
+      }
+    }
+  }
+}
+}
diff --git a/src/mapleall/maple_me/src/ssa_epre_for_sr.cpp b/src/mapleall/maple_me/src/ssa_epre_for_sr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..15e8f30fee958650eb81442ba3cd323be58f254b
--- /dev/null
+++ b/src/mapleall/maple_me/src/ssa_epre_for_sr.cpp
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "ssa_epre.h"
+
+namespace maple {
+
+ScalarMeExpr* SSAEPre::ResolveOneInjuringDef(ScalarMeExpr *regx) const {
+  if (regx->GetDefBy() != kDefByStmt) {
+    return regx;
+  }
+  AssignMeStmt *rass = static_cast<AssignMeStmt *>(regx->GetDefStmt());
+  CHECK_FATAL(rass->GetLHS() == regx, "ResolveInjuringDefs: defStmt has different lhs");
+  if (!rass->isIncDecStmt) {
+    return regx;
+  }
+  CHECK_FATAL(rass->GetRHS()->GetMeOp() == kMeOpOp,
+              "ResolveOneInjuringDef: regassign marked isIncDecStmt has unexpected rhs form.");
+  OpMeExpr *oprhs = static_cast<OpMeExpr *>(rass->GetRHS());
+  CHECK_FATAL(oprhs->GetOpnd(0)->GetMeOp() == kMeOpVar || oprhs->GetOpnd(0)->GetMeOp() == kMeOpReg,
+              "ResolveOneInjuringDef: regassign marked isIncDecStmt has unexpected form.");
+  RegMeExpr *rhsreg = static_cast<RegMeExpr *>(oprhs->GetOpnd(0));
+  CHECK_FATAL(rhsreg->GetOst() == regx->GetOst(),
+              "ResolveOneInjuringDef: regassign marked isIncDecStmt has unexpected rhs reg.");
+  return rhsreg;
+}
+
+ScalarMeExpr* SSAEPre::ResolveAllInjuringDefs(ScalarMeExpr *regx) const {
+  if (!workCand->isSRCand) {
+    return regx;
+  }
+  RegMeExpr *answer = ResolveOneInjuringDef(regx);
+  while (answer != regx) {
+    regx = answer;
+    answer = ResolveOneInjuringDef(regx);
+  }
+  return answer;
+}
+
+bool SSAEPre::OpndInDefOcc(const MeExpr *opnd, MeOccur *defocc, uint32 i) const {
+  if (defocc->GetOccType() == kOccReal) {
+    MeRealOcc *defrealocc = static_cast<MeRealOcc *>(defocc);
+    MeExpr *defexpr = defrealocc->GetMeExpr();
+    return opnd == defexpr->GetOpnd(i);
+  } else { // kOccPhi
+    return DefVarDominateOcc(opnd, *defocc);
+  }
+}
+
+void SSAEPre::SubstituteOpnd(MeExpr *x, MeExpr *oldopnd, MeExpr *newopnd) {
+  CHECK_FATAL(x->GetMeOp() == kMeOpOp, "SSAEPre::SubstituteOpnd: unexpected expr kind");
+  OpMeExpr *opexpr = static_cast<OpMeExpr *>(x);
+  for (uint32 i = 0; i < opexpr->GetNumOpnds(); i++) {
+    if (opexpr->GetOpnd(i) == oldopnd) {
+      opexpr->SetOpnd(i, newopnd);
+    }
+  }
+}
+
+void SSAEPre::SRSetNeedRepair(MeOccur *useocc, std::set<MeStmt *> *needRepairInjuringDefs) {
+  MeOccur *defocc = useocc->GetDef();
+  CHECK_FATAL(defocc != nullptr, "SRSetNeedRepair: occ->def must not be null");
+  if (defocc->GetOccType() == kOccInserted) {
+    CHECK_FATAL(defocc->GetBB() == useocc->GetBB(), "SRSetNeedRepair: unexpected inserted occ");
+    return;
+  }
+  MeExpr *useexpr = nullptr;
+  if (useocc->GetOccType() == kOccReal) {
+    MeRealOcc *realocc = static_cast<MeRealOcc *>(useocc);
+    useexpr = realocc->GetMeExpr();
+  } else {
+    MePhiOpndOcc *phiopndocc = static_cast<MePhiOpndOcc *>(useocc);
+    useexpr = phiopndocc->GetCurrentMeExpr();
+    if (useexpr == nullptr) {
+      return;
+    }
+  }
+  for (uint8 i = 0; i < useexpr->GetNumOpnds(); i++) {
+    MeExpr *curopnd = useexpr->GetOpnd(i);
+    if (curopnd->GetMeOp() != kMeOpVar && curopnd->GetMeOp() != kMeOpReg) {
+      continue;
+    }
+    if (!OpndInDefOcc(curopnd, defocc, i)) {
+      ScalarMeExpr *varx = static_cast<ScalarMeExpr *>(curopnd);
+      needRepairInjuringDefs->insert(varx->GetDefStmt());
+    }
+  }
+}
+
+static int64 GetIncreAmtAndRhsScalar(MeExpr *x, ScalarMeExpr *&rhsScalar) {
+  OpMeExpr *opexpr = static_cast<OpMeExpr *>(x);
+  rhsScalar = dynamic_cast<ScalarMeExpr *>(opexpr->GetOpnd(0));
+  CHECK_FATAL(rhsScalar != nullptr, "GetIncreAmtAndRhsScalar: cannot find scalar operand");
+  CHECK_FATAL(opexpr->GetOpnd(1)->GetMeOp() == kMeOpConst,
+              "GetIncreAmtAndRhsScalar: cannot find constant inc/dec amount");
+  MIRConst *constVal = static_cast<ConstMeExpr *>(opexpr->GetOpnd(1))->GetConstVal();
+  CHECK_FATAL(constVal->GetKind() == kConstInt, "GetIncreAmtAndRhsScalar: unexpected constant type");
+  int64 amt = static_cast<MIRIntConst *>(constVal)->GetExtValue();
+  return (opexpr->GetOp() == OP_sub) ? -amt : amt;
+}
+
+MeExpr* SSAEPre::InsertRepairStmt(MeExpr *temp, int64 increAmt, MeStmt *injuringDef) const {
+  MeExpr *rhs = nullptr;
+  if (increAmt >= 0) {
+    rhs = irMap->CreateMeExprBinary(OP_add, temp->GetPrimType(), *temp,
+                                    *irMap->CreateIntConstMeExpr(increAmt, temp->GetPrimType()));
+  } else {
+    rhs = irMap->CreateMeExprBinary(OP_sub, temp->GetPrimType(), *temp,
+                                    *irMap->CreateIntConstMeExpr(-increAmt, temp->GetPrimType()));
+  }
+  BB *bb = injuringDef->GetBB();
+  MeStmt *newstmt = nullptr;
+  if (temp->GetMeOp() == kMeOpReg) {
+    RegMeExpr *newreg = irMap->CreateRegMeExprVersion(*static_cast<RegMeExpr *>(temp));
+    newstmt = irMap->CreateAssignMeStmt(*newreg, *rhs, *bb);
+    static_cast<AssignMeStmt *>(newstmt)->isIncDecStmt = true;
+    bb->InsertMeStmtAfter(injuringDef, newstmt);
+    return newreg;
+  } else {
+    VarMeExpr *newvar = irMap->CreateVarMeExprVersion(*static_cast<VarMeExpr *>(temp));
+    newstmt = irMap->CreateAssignMeStmt(*newvar, *rhs, *bb);
+    static_cast<DassignMeStmt *>(newstmt)->isIncDecStmt = true;
+    bb->InsertMeStmtAfter(injuringDef, newstmt);
+    return newvar;
+  }
+}
+
+static MeExpr *FindLaterRepairedTemp(const MeExpr *temp, const MeStmt *injuringDef) {
+  AssignMeStmt *ass = static_cast<AssignMeStmt *>(injuringDef->GetNext());
+  while (ass != nullptr) {
+    CHECK_FATAL(ass->isIncDecStmt, "FindLaterRepairedTemp: failed to find repair statement");
+    if (ass->GetLHS()->GetOst() == static_cast<const ScalarMeExpr *>(temp)->GetOst()) {
+      return ass->GetLHS();
+    }
+    ass = static_cast<AssignMeStmt *>(ass->GetNext());
+  }
+  CHECK_FATAL(false, "FindLaterRepairedTemp: failed to find repair statement");
+  return nullptr;
+}
+
+MeExpr* SSAEPre::SRRepairOpndInjuries(MeExpr *curopnd, MeOccur *defocc, int32 i,
+                                      MeExpr *tempAtDef,
+                                      std::set<MeStmt *> *needRepairInjuringDefs,
+                                      std::set<MeStmt *> *repairedInjuringDefs) {
+  MeExpr *repairedTemp = tempAtDef;
+  ScalarMeExpr *scalarx = static_cast<ScalarMeExpr *>(curopnd);
+  AssignMeStmt *ass = static_cast<AssignMeStmt *>(scalarx->GetDefStmt());
+  CHECK_FATAL(ass->isIncDecStmt, "SRRepairOpndInjuries: not an inc/dec statement");
+  MeStmt *latestInjuringDef = ass;
+  if (repairedInjuringDefs->count(ass) == 0) {
+    repairedInjuringDefs->insert(ass);
+    bool done = false;
+    int64 increAmt = 0;
+    ScalarMeExpr *rhsScalar = nullptr;
+    do {
+      increAmt += GetIncreAmtAndRhsScalar(ass->GetRHS(), rhsScalar);
+      if (OpndInDefOcc(rhsScalar, defocc, static_cast<uint32>(i))) {
+        done = true;
+      } else {
+        scalarx = rhsScalar;
+        ass = static_cast<AssignMeStmt *>(scalarx->GetDefStmt());
+        CHECK_FATAL(ass->isIncDecStmt, "SRRepairOpndInjuries: not an inc/dec statement");
+        done = needRepairInjuringDefs->count(ass) == 1;
+        if (done) {
+          if (repairedInjuringDefs->count(ass) == 0) {
+            repairedTemp = SRRepairOpndInjuries(scalarx, defocc, i, tempAtDef, needRepairInjuringDefs,
+                                                repairedInjuringDefs);
+          }
+          repairedTemp = FindLaterRepairedTemp(repairedTemp, ass);
+        }
+      }
+    } while (!done);
+    // generate the increment statement at latestInjuringDef
+    repairedTemp = InsertRepairStmt(repairedTemp, increAmt * workCand->GetTheMeExpr()->SRMultiplier(scalarx->GetOst()),
+                                    latestInjuringDef);
+  } else {
+    // find the last repair increment statement
+    repairedTemp = FindLaterRepairedTemp(repairedTemp, latestInjuringDef);
+  }
+  return repairedTemp;
+}
+
+static bool IsScalarInWorkCandExpr(const ScalarMeExpr *scalar, const OpMeExpr *theMeExpr) {
+  ScalarMeExpr *iv = dynamic_cast<ScalarMeExpr *>(theMeExpr->GetOpnd(0));
+  if (iv && iv->GetOst() == scalar->GetOst()) {
+    return true;
+  }
+  iv = dynamic_cast<ScalarMeExpr *>(theMeExpr->GetOpnd(1));
+  return iv != nullptr && iv->GetOst() == scalar->GetOst();
+}
+
+MeExpr* SSAEPre::SRRepairInjuries(MeOccur *useocc,
+                                  std::set<MeStmt *> *needRepairInjuringDefs,
+                                  std::set<MeStmt *> *repairedInjuringDefs) {
+  MeExpr *useexpr = nullptr;
+  if (useocc->GetOccType() == kOccReal || useocc->GetOccType() == kOccCompare) {
+    MeRealOcc *realocc = static_cast<MeRealOcc *>(useocc);
+    useexpr = realocc->GetMeExpr();
+  } else {
+    MePhiOpndOcc *phiopndocc = static_cast<MePhiOpndOcc *>(useocc);
+    useexpr = phiopndocc->GetCurrentMeExpr();
+  }
+  MeOccur *defocc = useocc->GetDef();
+  MeExpr *repairedTemp = nullptr;
+  if (defocc->GetOccType() == kOccInserted) {
+    CHECK_FATAL(defocc->GetBB() == useocc->GetBB(), "SRRepairInjuries: unexpected inserted occ");
+    return static_cast<MeInsertedOcc *>(defocc)->GetSavedExpr();
+  }
+  if (defocc->GetOccType() == kOccReal) {
+    MeRealOcc *defrealocc = static_cast<MeRealOcc *>(defocc);
+    repairedTemp = defrealocc->GetSavedExpr();
+  } else { // kOccPhiocc
+    MePhiOcc *defphiocc = static_cast<MePhiOcc *>(defocc);
+    MePhiNode *scalarPhi = (defphiocc->GetRegPhi() ? defphiocc->GetRegPhi() : defphiocc->GetVarPhi());
+    repairedTemp = scalarPhi->GetLHS();
+  }
+  if (useexpr == nullptr || repairedTemp == nullptr) {
+    return repairedTemp;
+  }
+  for (uint8 i = 0; i < useexpr->GetNumOpnds(); i++) {
+    MeExpr *curopnd = useexpr->GetOpnd(i);
+    if (curopnd->GetMeOp() != kMeOpVar && curopnd->GetMeOp() != kMeOpReg) {
+      continue;
+    }
+    if (useocc->GetOccType() == kOccCompare) {
+      if (!IsScalarInWorkCandExpr(static_cast<ScalarMeExpr*>(curopnd),
+                                  static_cast<OpMeExpr*>(workCand->GetTheMeExpr()))) {
+        continue;
+      }
+    }
+    if (!OpndInDefOcc(curopnd, defocc, i)) {
+      repairedTemp = SRRepairOpndInjuries(curopnd, defocc, i, repairedTemp, needRepairInjuringDefs,
+                                          repairedInjuringDefs);
+    }
+  } // for
+  return repairedTemp;
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/ssa_mir_nodes.cpp b/src/mapleall/maple_me/src/ssa_mir_nodes.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd01f718d21ee509ed490bdc0d982c177a360cd7
--- /dev/null
+++ b/src/mapleall/maple_me/src/ssa_mir_nodes.cpp
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ssa_mir_nodes.h"
+#include "opcode_info.h"
+#include "mir_function.h"
+#include "printing.h"
+#include "ssa_tab.h"
+
+namespace maple {
+void GenericSSAPrint(const MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart) {
+  stmtNode.Dump(indent);
+  // print SSAPart
+  Opcode op = stmtNode.GetOpCode();
+  AccessSSANodes *ssaPart = stmtsSSAPart.SSAPartOf(stmtNode);
+  switch (op) {
+    case OP_maydassign:
+    case OP_dassign: {
+      mod.GetOut() << " ";
+      CHECK_NULL_FATAL(ssaPart->GetSSAVar());
+      ssaPart->GetSSAVar()->Dump();
+      LogInfo::MapleLogger() << "\n";
+      ssaPart->DumpMayDefNodes(mod);
+      return;
+    }
+    case OP_regassign: {
+      mod.GetOut() << "  ";
+      CHECK_NULL_FATAL(ssaPart->GetSSAVar());
+      ssaPart->GetSSAVar()->Dump();
+      LogInfo::MapleLogger() << "\n";
+      return;
+    }
+    case OP_iassign: {
+      ssaPart->DumpMayDefNodes(mod);
+      return;
+    }
+    case OP_throw:
+    case OP_retsub:
+    case OP_return: {
+      ssaPart->DumpMayUseNodes(mod);
+      mod.GetOut() << '\n';
+      return;
+    }
+    default: {
+      if (kOpcodeInfo.IsCallAssigned(op)) {
+        ssaPart->DumpMayUseNodes(mod);
+        ssaPart->DumpMustDefNodes(mod);
+        ssaPart->DumpMayDefNodes(mod);
+      } else if (kOpcodeInfo.HasSSADef(op) && kOpcodeInfo.HasSSAUse(op)) {
+        ssaPart->DumpMayUseNodes(mod);
+        mod.GetOut() << '\n';
+        ssaPart->DumpMayDefNodes(mod);
+      }
+      return;
+    }
+  }
+}
+
+static TypeOfMayDefList *SSAGenericGetMayDefsFromVersionSt(const VersionSt &vst,
+    StmtsSSAPart &stmtsSSAPart, std::unordered_set<const VersionSt*> &visited) {
+  if (vst.IsInitVersion() || visited.find(&vst) != visited.end()) {
+    return nullptr;
+  }
+  visited.insert(&vst);
+  if (vst.GetDefType() == VersionSt::kPhi) {
+    const PhiNode *phi = vst.GetPhi();
+    for (size_t i = 0; i < phi->GetPhiOpnds().size(); ++i) {
+      const VersionSt *vSym = phi->GetPhiOpnd(i);
+      TypeOfMayDefList *mayDefs = SSAGenericGetMayDefsFromVersionSt(*vSym, stmtsSSAPart, visited);
+      if (mayDefs != nullptr) {
+        return mayDefs;
+      }
+    }
+  } else if (vst.GetDefType() == VersionSt::kMayDef) {
+    const MayDefNode *mayDef = vst.GetMayDef();
+    return &stmtsSSAPart.GetMayDefNodesOf(*mayDef->GetStmt());
+  }
+  return nullptr;
+}
+
+TypeOfMayDefList *SSAGenericGetMayDefsFromVersionSt(const VersionSt &sym, StmtsSSAPart &stmtsSSAPart) {
+  std::unordered_set<const VersionSt*> visited;
+  return SSAGenericGetMayDefsFromVersionSt(sym, stmtsSSAPart, visited);
+}
+
+bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func) {
+  const auto &stmtNode = static_cast<const StmtNode&>(baseNode);
+  if (kOpcodeInfo.HasSSAUse(stmtNode.GetOpCode())) {
+    TypeOfMayUseList &mayUses = func.GetStmtsSSAPart().GetMayUseNodesOf(stmtNode);
+    if (!mayUses.empty()) {
+      return true;
+    }
+  }
+  for (size_t i = 0; i < baseNode.NumOpnds(); ++i) {
+    if (HasMayUseOpnd(*baseNode.Opnd(i), func)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool IsSameContent(const BaseNode *exprA, const BaseNode *exprB, bool isZeroVstEqual) {
+  if (exprA == nullptr || exprB == nullptr) {
+    return false;
+  }
+  if (exprA == exprB) {
+    return true;
+  }
+  Opcode opA = exprA->GetOpCode();
+  Opcode opB = exprB->GetOpCode();
+  PrimType ptypA = exprA->GetPrimType();
+  PrimType ptypB = exprB->GetPrimType();
+  size_t opndNumA = exprA->NumOpnds();
+  size_t opndNumB = exprB->NumOpnds();
+  // 1. compare common field for all kinds of expr
+  if (opA != opB || ptypA != ptypB || opndNumA != opndNumB) {
+    return false;
+  }
+  if (exprA->IsSSANode()) {
+    const VersionSt *vstA = static_cast<const SSANode *>(exprA)->GetSSAVar();
+    const VersionSt *vstB = static_cast<const SSANode *>(exprB)->GetSSAVar();
+    if (vstA != nullptr && vstB != nullptr) {
+      return vstA == vstB && (isZeroVstEqual || !vstA->IsInitVersion());
+    }
+  } else if (exprA->IsLeaf()) {
+    // leaf node has no SSANode inside it, we can compare them by IsSameContent.
+    return exprA->IsSameContent(exprB);
+  }
+  // if any leaf nodes of these two expr are different, return false
+  for (size_t i = 0; i < opndNumA; ++i) {
+    if (!IsSameContent(exprA->Opnd(i), exprB->Opnd(i), isZeroVstEqual)) {
+      return false;
+    }
+  }
+  // 2. compare extra fields of some kinds of expr
+  switch (opA) {
+    case OP_extractbits:
+    case OP_zext:
+    case OP_sext: {
+      auto *nodeA = static_cast<const ExtractbitsNode *>(exprA);
+      auto *nodeB = static_cast<const ExtractbitsNode *>(exprB);
+      return nodeA->GetBitsOffset() == nodeB->GetBitsOffset() && nodeA->GetBitsSize() == nodeB->GetBitsSize();
+    }
+    case OP_depositbits: {
+      auto *nodeA = static_cast<const DepositbitsNode *>(exprA);
+      auto *nodeB = static_cast<const DepositbitsNode *>(exprB);
+      return nodeA->GetBitsOffset() == nodeB->GetBitsOffset() && nodeA->GetBitsSize() == nodeB->GetBitsSize();
+    }
+    case OP_array: {
+      auto *nodeA = static_cast<const ArrayNode *>(exprA);
+      auto *nodeB = static_cast<const ArrayNode *>(exprB);
+      return nodeA->GetBoundsCheck() == nodeB->GetBoundsCheck() && nodeA->GetTyIdx() == nodeB->GetTyIdx();
+    }
+    case OP_iread: {
+      if (!exprA->IsSSANode()) { // no ssa version has been set (i.e. ssa_tab not run)
+        return exprA->IsSameContent(exprB);
+      }
+      BaseNode *nodeA = const_cast<IreadSSANode *>(static_cast<const IreadSSANode *>(exprA))->GetNoSSANode();
+      BaseNode *nodeB = const_cast<IreadSSANode *>(static_cast<const IreadSSANode *>(exprB))->GetNoSSANode();
+      auto *ireadA = static_cast<IreadNode *>(nodeA);
+      auto *ireadB = static_cast<IreadNode *>(nodeB);
+      return ireadA->GetTyIdx() == ireadB->GetTyIdx() && ireadA->GetFieldID() == ireadB->GetFieldID();
+    }
+    case OP_iaddrof: {
+      auto *ireadA = static_cast<const IreadNode *>(exprA);
+      auto *ireadB = static_cast<const IreadNode *>(exprB);
+      return ireadA->GetTyIdx() == ireadB->GetTyIdx() && ireadA->GetFieldID() == ireadB->GetFieldID();
+    }
+    case OP_ireadoff: {
+      return static_cast<const IreadoffNode *>(exprA)->GetOffset() ==
+             static_cast<const IreadoffNode *>(exprB)->GetOffset();
+    }
+    case OP_ireadfpoff: {
+      return static_cast<const IreadFPoffNode *>(exprA)->GetOffset() ==
+             static_cast<const IreadFPoffNode *>(exprB)->GetOffset();
+    }
+    case OP_ireadpcoff: {
+      return static_cast<const IreadPCoffNode *>(exprA)->GetOffset() ==
+             static_cast<const IreadPCoffNode *>(exprB)->GetOffset();
+    }
+    case OP_intrinsicop:
+    case OP_intrinsicopwithtype: {
+      auto *nodeA = static_cast<const IntrinsicopNode *>(exprA);
+      auto *nodeB = static_cast<const IntrinsicopNode *>(exprB);
+      return nodeA->GetIntrinsic() == nodeB->GetIntrinsic() && nodeA->GetTyIdx() == nodeB->GetTyIdx();
+    }
+    case OP_resolveinterfacefunc:
+    case OP_resolvevirtualfunc: {
+      auto *nodeA = static_cast<const ResolveFuncNode *>(exprA);
+      auto *nodeB = static_cast<const ResolveFuncNode *>(exprB);
+      return nodeA->GetPuIdx() == nodeB->GetPuIdx();
+    }
+    default: {
+      if (kOpcodeInfo.IsTypeCvt(opA)) {
+        if (opA == OP_retype) {
+          if (static_cast<const RetypeNode *>(exprA)->GetTyIdx() !=
+              static_cast<const RetypeNode *>(exprB)->GetTyIdx()) {
+            return false;
+          }
+        }
+        return static_cast<const TypeCvtNode *>(exprA)->FromType() ==
+               static_cast<const TypeCvtNode *>(exprB)->FromType();
+      }
+      if (kOpcodeInfo.IsCompare(opA)) {
+        return static_cast<const CompareNode *>(exprA)->GetOpndType() ==
+               static_cast<const CompareNode *>(exprB)->GetOpndType();
+      }
+      return true;
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/ssa_pre.cpp b/src/mapleall/maple_me/src/ssa_pre.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a94b544c20f37af49a7738dd30114485ff401731
--- /dev/null
+++ b/src/mapleall/maple_me/src/ssa_pre.cpp
@@ -0,0 +1,1883 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ssa_pre.h"
+#include "dominance.h"
+#include "mir_builder.h"
+
+namespace maple {
+// Implementation of SSAPRE based on the paper "Partial Redundancy Elimination
+// in SSA Form" Kennedy et al.
+// This file represents the base SSAPRE implementation.  There are different
+// variants of SSAPRE-based optimizations, and they are derived from this base
+// implementation and implemented in additional files.  The optimizations are
+// and the files they are implemented in are:
+// 1. EPRE (PRE for Expressions) - ssa_epre.cpp, me_ssa_epre.cpp
+// 2. LPRE (PRE for Loads) - me_ssa_lpre.cpp
+// 3. STMTPRE (PRE for Statements) - me_stmt_pre.cpp
+// 4. STMTFRE (Full Redundancy Elimination for Statements) - me_stmt_fre.cpp
+//    (called when performing STMTPRE).
+
+
+// ================ Step 6: Code Motion =================
+ScalarMeExpr *SSAPre::CreateNewCurTemp(const MeExpr &meExpr) {
+  if (workCand->NeedLocalRefVar() && GetPlacementRCOn()) {
+    curTemp = CreateNewCurLocalRefVar();
+    return curTemp;
+  }
+  if (curTemp != nullptr) {
+    // only need to create a new version
+    if (curTemp->GetMeOp() == kMeOpReg) {
+      RegMeExpr *regVar = irMap->CreateRegMeExprVersion(static_cast<RegMeExpr&>(*curTemp));
+      return regVar;
+    } else {
+      VarMeExpr *tempVar = irMap->CreateVarMeExprVersion(static_cast<VarMeExpr&>(*curTemp));
+      return tempVar;
+    }
+  }
+  if (workCand->GetPUIdx() != 0) {
+    // allocate a new temp
+    SetCurFunction(workCand->GetPUIdx());
+    RegMeExpr *regVar = irMap->CreateRegMeExpr(meExpr);
+    curTemp = regVar;
+    if (preKind == kLoadPre) {
+      irMap->SetLpreTmps(static_cast<const VarMeExpr*>(&meExpr)->GetOstIdx(), *regVar);
+      // set fields in MIRPreg to support rematerialization
+      MIRPreg *preg = regVar->GetOst()->GetMIRPreg();
+      VarMeExpr *varMeExpr = static_cast<VarMeExpr *>(workCand->GetTheMeExpr());
+      CHECK_FATAL(varMeExpr->GetMeOp() == kMeOpVar, "CreateNewCurTemp: unexpected meOp");
+      OriginalSt *ost = varMeExpr->GetOst();
+      preg->SetOp(OP_dread);
+      preg->rematInfo.sym = ost->GetMIRSymbol();
+      preg->fieldID = ost->GetFieldID();
+    } else if (preKind == kAddrPre) {
+      // set fields in MIRPreg to support rematerialization
+      MIRPreg *preg = regVar->GetOst()->GetMIRPreg();
+      if (workCand->GetTheMeExpr()->GetMeOp() == kMeOpAddrof) {
+        AddrofMeExpr *addrof = static_cast<AddrofMeExpr *>(workCand->GetTheMeExpr());
+        OriginalSt *ost = addrof->GetOst();
+        preg->SetOp(OP_addrof);
+        ASSERT_NOT_NULL(ost);
+        preg->rematInfo.sym = ost->GetMIRSymbol();
+        preg->fieldID = addrof->GetFieldID();
+      } else if (workCand->GetTheMeExpr()->GetMeOp() == kMeOpConst) {
+        ConstMeExpr *constMeExpr = static_cast<ConstMeExpr *>(workCand->GetTheMeExpr());
+        preg->SetOp(OP_constval);
+        preg->rematInfo.mirConst = constMeExpr->GetConstVal();
+      }
+    }
+    return regVar;
+  } else {
+    curTemp = irMap->CreateNewVar(NewTempStrIdx(), meExpr.GetPrimType(), true);
+    return curTemp;
+  }
+}
+
+VarMeExpr *SSAPre::CreateNewCurLocalRefVar() {
+  if (curLocalRefVar != nullptr) {
+    // only need to create a new version
+    VarMeExpr *tempVar = irMap->CreateVarMeExprVersion(static_cast<VarMeExpr&>(*curLocalRefVar));
+    return tempVar;
+  } else {
+    // allocate a new temp
+    auto *ivarMeExpr = static_cast<IvarMeExpr*>(workCand->GetTheMeExpr());
+    MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr->GetTyIdx());
+    CHECK_FATAL(mirType->GetKind() == kTypePointer, "must be point type for ivar");
+    auto *realMIRType = static_cast<MIRPtrType*>(mirType);
+    FieldID fieldID = ivarMeExpr->GetFieldID();
+    curLocalRefVar = irMap->CreateNewLocalRefVarTmp(NewTempStrIdx(), realMIRType->GetPointedTyIdxWithFieldID(fieldID));
+    ASSERT_NOT_NULL(curLocalRefVar);
+    ssaTab->SetEPreLocalRefVar(curLocalRefVar->GetOstIdx(), true);
+    SetAddedNewLocalRefVars(true);
+    return curLocalRefVar;
+  }
+}
+
+void SSAPre::GenerateSaveInsertedOcc(MeInsertedOcc &insertedOcc) {
+  ASSERT(GetPUIdx() == workCand->GetPUIdx() || workCand->GetPUIdx() == 0,
+         "GenerateSaveInsertedOcc: inconsistent puIdx");
+  ScalarMeExpr *regOrVar = CreateNewCurTemp(*insertedOcc.GetMeExpr());
+  MeStmt *newMeStmt = nullptr;
+  ASSERT_NOT_NULL(workCand);
+  if (!workCand->NeedLocalRefVar() || GetPlacementRCOn()) {
+    newMeStmt = irMap->CreateAssignMeStmt(*regOrVar, *insertedOcc.GetMeExpr(), *insertedOcc.GetBB());
+    regOrVar->SetDefByStmt(*newMeStmt);
+    insertedOcc.GetBB()->InsertMeStmtLastBr(newMeStmt);
+    insertedOcc.SetSavedExpr(*regOrVar);
+  } else {
+    // regOrVar is MeOp_reg and lcoalrefvar is kMeOpVar
+    VarMeExpr *localRefVar = CreateNewCurLocalRefVar();
+    temp2LocalRefVarMap[static_cast<RegMeExpr*>(regOrVar)] = localRefVar;
+    newMeStmt = irMap->CreateAssignMeStmt(*localRefVar, *insertedOcc.GetMeExpr(), *insertedOcc.GetBB());
+    localRefVar->SetDefByStmt(*newMeStmt);
+    insertedOcc.GetBB()->InsertMeStmtLastBr(newMeStmt);
+    EnterCandsForSSAUpdate(localRefVar->GetOstIdx(), *insertedOcc.GetBB());
+    newMeStmt = irMap->CreateAssignMeStmt(*regOrVar, *localRefVar, *insertedOcc.GetBB());
+    regOrVar->SetDefByStmt(*newMeStmt);
+    insertedOcc.GetBB()->InsertMeStmtLastBr(newMeStmt);
+    insertedOcc.SetSavedExpr(*regOrVar);
+  }
+  EnterCandsForSSAUpdate(regOrVar->GetOstIdx(), *insertedOcc.GetBB());
+}
+
+void SSAPre::GenerateSavePhiOcc(MePhiOcc &phiOcc) {
+  // generate a regOrVar
+  ASSERT(GetPUIdx() == workCand->GetPUIdx() || workCand->GetPUIdx() == 0,
+         "GenerateSavePhiOcc: inconsistent puIdx");
+  MeExpr *regOrVar = CreateNewCurTemp(*workCand->GetTheMeExpr());
+  CHECK_NULL_FATAL(regOrVar);
+  MePhiNode *phiNode = irMap->CreateMePhi(static_cast<ScalarMeExpr&>(*regOrVar));
+  phiNode->SetDefBB(phiOcc.GetBB());
+
+  if (instance_of<RegMeExpr>(regOrVar)) {
+    // create a reg phi
+    phiOcc.SetRegPhi(*phiNode);
+  } else {
+    CHECK_NULL_FATAL(phiNode);
+    phiNode->SetDefBB(phiOcc.GetBB());
+    phiOcc.SetVarPhi(*phiNode);
+  }
+  // update the phi opnds later
+  ASSERT_NOT_NULL(workCand);
+  if (workCand->NeedLocalRefVar() && !GetPlacementRCOn()) {
+    VarMeExpr *localRefVar = CreateNewCurLocalRefVar();
+    temp2LocalRefVarMap[static_cast<RegMeExpr*>(regOrVar)] = localRefVar;
+    // create a var phi
+    MePhiNode *phiVar = irMap->CreateMePhi(*localRefVar);
+    phiVar->SetDefBB(phiOcc.GetBB());
+    phiOcc.SetVarPhi(*phiVar);
+    // update the phi opnds later
+    EnterCandsForSSAUpdate(localRefVar->GetOstIdx(), *phiOcc.GetBB());
+  }
+}
+
+void SSAPre::UpdateInsertedPhiOccOpnd() {
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    if (!phiOcc->IsWillBeAvail() || phiOcc->IsRemoved()) {
+      continue;
+    }
+    if (phiOcc->GetRegPhi()) {
+      MePhiNode *phiReg = phiOcc->GetRegPhi();
+      const MapleVector<MePhiOpndOcc *> &phiopnds = phiOcc->GetPhiOpnds();
+      for (uint32 i = 0; i < phiopnds.size(); i++) {
+        RegMeExpr *regOpnd = static_cast<RegMeExpr *>(phiopnds[i]->phiOpnd4Temp);
+        if (regOpnd == nullptr) {
+          // create a zero version
+          CHECK_FATAL(curTemp != nullptr, "curTemp can't be null in SSAPre::UpdateInsertedPhiOccOpnd");
+          regOpnd = irMap->CreateRegMeExprVersion(static_cast<RegMeExpr&>(*curTemp));
+        }
+        phiReg->GetOpnds().push_back(regOpnd);
+      }
+      (void)phiOcc->GetBB()->GetMePhiList().insert(std::make_pair(phiReg->GetOpnd(0)->GetOstIdx(), phiReg));
+      if (workCand->NeedLocalRefVar() && phiOcc->GetVarPhi() != nullptr) {
+        MePhiNode *phiVar = phiOcc->GetVarPhi();
+        const MapleVector<MePhiOpndOcc *> &phiOpnds = phiOcc->GetPhiOpnds();
+        for (uint32 i = 0; i < phiOpnds.size(); i++) {
+          RegMeExpr *regOpnd = static_cast<RegMeExpr *>(phiOpnds[i]->phiOpnd4Temp);
+          VarMeExpr *localRefVarOpnd = nullptr;
+          if (regOpnd == nullptr) {
+            // create a zero version
+            CHECK_FATAL(curLocalRefVar != nullptr, "null ptr check");
+            OriginalSt *ost = curLocalRefVar->GetOst();
+            localRefVarOpnd = irMap->GetOrCreateZeroVersionVarMeExpr(*ost);
+          } else {
+            auto mapIt = temp2LocalRefVarMap.find(regOpnd);
+            if (mapIt == temp2LocalRefVarMap.end()) {
+              CHECK_FATAL(curLocalRefVar != nullptr, "null ptr check");
+              OriginalSt *ost = curLocalRefVar->GetOst();
+              localRefVarOpnd = irMap->GetOrCreateZeroVersionVarMeExpr(*ost);
+            } else {
+              localRefVarOpnd = mapIt->second;
+            }
+          }
+          phiVar->GetOpnds().push_back(localRefVarOpnd);
+        }
+        (void)phiOcc->GetBB()->GetMePhiList().insert(std::make_pair(phiVar->GetOpnd(0)->GetOstIdx(), phiVar));
+      }
+    } else {
+      MePhiNode *phiVar = phiOcc->GetVarPhi();
+      const MapleVector<MePhiOpndOcc *> &phiopnds = phiOcc->GetPhiOpnds();
+      for (uint32 i = 0; i < phiopnds.size(); i++) {
+        VarMeExpr *varOpnd = static_cast<VarMeExpr *>(phiopnds[i]->phiOpnd4Temp);
+        if (varOpnd == nullptr) {
+          CHECK_FATAL(curTemp != nullptr, "curTemp can't be null in SSAPre::UpdateInsertedPhiOccOpnd");
+          varOpnd = irMap->CreateVarMeExprVersion(static_cast<VarMeExpr&>(*curTemp));
+        }
+        phiVar->GetOpnds().push_back(varOpnd);
+      }
+      (void)phiOcc->GetBB()->GetMePhiList().insert(std::make_pair(phiVar->GetOpnd(0)->GetOstIdx(), phiVar));
+    }
+  }
+}
+
+void SSAPre::CodeMotion() {
+  std::set<MeStmt *> needRepairInjuringDefs; // for marking injuring defs that need repair
+
+  if (workCand->isSRCand) {  // pre-pass needed by strength reduction
+    for (MeOccur *occ : allOccs) {
+      switch (occ->GetOccType()) {
+        case kOccReal: {
+          MeRealOcc *realocc = static_cast<MeRealOcc *>(occ);
+          if (realocc->IsReload()) {
+            SRSetNeedRepair(realocc, &needRepairInjuringDefs);
+          }
+          break;
+        }
+        case kOccPhiopnd: {
+          MePhiOpndOcc *phiopnd = static_cast<MePhiOpndOcc *>(occ);
+          if (phiopnd->GetDefPhiOcc()->IsRemoved() || !phiopnd->GetDefPhiOcc()->IsWillBeAvail()) {
+            break;
+          }
+          if (phiopnd->GetDef()->GetOccType() == kOccInserted) {
+            break;
+          }
+          SRSetNeedRepair(phiopnd, &needRepairInjuringDefs);
+          break;
+        }
+        default: ;
+      }
+    }
+  }
+
+  curTemp = nullptr;
+  curLocalRefVar = nullptr;
+  temp2LocalRefVarMap.clear();
+  reBuiltOccIndex = static_cast<int32>(workList.size());  // so we know the elements added due to rebuilding
+  std::set<MeStmt *> repairedInjuringDefs;   // for marking injuring defs that have been repaired
+
+  for (MeOccur *occ : allOccs) {
+    switch (occ->GetOccType()) {
+      case kOccReal: {
+        auto *realOcc = static_cast<MeRealOcc*>(occ);
+        if (realOcc->IsSave()) {
+          CHECK_FATAL(!(realOcc->IsReload()), "reload failed");
+          GenerateSaveRealOcc(*realOcc);
+          if (realOcc->IsHoisted()) {
+            // remove fake stmt
+            realOcc->GetMeStmt()->GetBB()->RemoveMeStmt(realOcc->GetMeStmt());
+          }
+        } else if (realOcc->IsReload()) {
+          if (!workCand->isSRCand) {
+            GenerateReloadRealOcc(*realOcc);
+          } else {
+            MeExpr *regorvar = SRRepairInjuries(realOcc, &needRepairInjuringDefs, &repairedInjuringDefs);
+            // replace realOcc->mestmt's occ with regorvar
+            bool isreplaced = irMap->ReplaceMeExprStmt(*realOcc->GetMeStmt(), *realOcc->GetMeExpr(), *regorvar);
+            // update worklist
+            if (isreplaced) {
+              BuildWorkListStmt(*realOcc->GetMeStmt(), static_cast<uint32>(realOcc->GetSequence()), true, regorvar);
+            }
+          }
+        }
+        break;
+      }
+      case kOccPhiopnd: {
+        auto *phiOpnd = static_cast<MePhiOpndOcc*>(occ);
+        if (phiOpnd->GetDefPhiOcc()->IsRemoved() || !phiOpnd->GetDefPhiOcc()->IsWillBeAvail()) {
+          break;
+        }
+        MeOccur *defOcc = phiOpnd->GetDef();
+        if (defOcc->GetOccType() == kOccInserted) {
+          // generate a save of the result in to a new version of t
+          if (!phiOpnd->IsPhiOpndReload()) {
+            GenerateSaveInsertedOcc(*static_cast<MeInsertedOcc*>(defOcc));
+            phiOpnd->phiOpnd4Temp = static_cast<MeInsertedOcc *>(defOcc)->GetSavedExpr();
+          }
+        } else {
+          // set phiOpnd4Temp needed in the temp's phi
+          if (workCand->isSRCand) {
+            phiOpnd->phiOpnd4Temp = SRRepairInjuries(phiOpnd, &needRepairInjuringDefs, &repairedInjuringDefs);
+          } else {
+            if (defOcc->GetOccType() == kOccReal) {
+              phiOpnd->phiOpnd4Temp = static_cast<MeRealOcc *>(defOcc)->GetSavedExpr();
+            } else {
+              MePhiOcc *defphiocc = static_cast<MePhiOcc *>(defOcc);
+              MePhiNode *scalarPhi = (defphiocc->GetRegPhi() ? defphiocc->GetRegPhi() : defphiocc->GetVarPhi());
+              phiOpnd->phiOpnd4Temp = scalarPhi->GetLHS();
+            }
+          }
+        }
+        break;
+      }
+      case kOccPhiocc: {
+        auto *phiOcc = static_cast<MePhiOcc*>(occ);
+        if (phiOcc->IsRemoved() || !phiOcc->IsWillBeAvail()) {
+          break;
+        }
+        GenerateSavePhiOcc(*phiOcc);
+        break;
+      }
+      case kOccCompare: {
+        MeRealOcc *compOcc = static_cast<MeRealOcc*>(occ);
+        if (!compOcc->IsReload()) {
+          break;
+        }
+        if (compOcc->GetDef()->GetOccType() == kOccReal) {
+          MeRealOcc *defRealOcc = static_cast<MeRealOcc *>(compOcc->GetDef());
+          if (!defRealOcc->IsReload() && !defRealOcc->IsSave()) {
+            break;
+          }
+        } else {
+          MePhiOcc *phiOcc = static_cast<MePhiOcc*>(compOcc->GetDef());
+          if (phiOcc->IsRemoved() || !phiOcc->IsWillBeAvail() || !phiOcc->IsDownSafe()) {
+            break;
+          }
+        }
+        MeExpr *regorvar = SRRepairInjuries(compOcc, &needRepairInjuringDefs, &repairedInjuringDefs);
+        OpMeExpr *newCompare = FormLFTRCompare(compOcc, regorvar);
+        // replace compOcc->mestmt's occ with newCompare
+        (void)irMap->ReplaceMeExprStmt(*compOcc->GetMeStmt(), *compOcc->GetMeExpr(), *newCompare);
+        CreateCompOcc(compOcc->GetMeStmt(), compOcc->GetSequence(), newCompare, true);
+        break;
+      }
+      case kOccExit:
+        break;
+      case kOccMembar:
+      case kOccUse:
+        break;
+      default:
+        ASSERT(false, "should not be here");
+        break;
+    }
+  }
+  // update the inserted phiOcc's operand
+  UpdateInsertedPhiOccOpnd();
+  if (GetSSAPreDebug()) {
+    mirModule->GetOut() << "========ssapre candidate " << workCand->GetIndex() <<
+        " after CodeMotion ===================\n";
+    if (curTemp != nullptr) {
+      mirModule->GetOut() << "curTemp is";
+      curTemp->Dump(irMap, 0);
+      mirModule->GetOut() << "\n";
+    }
+  }
+}
+
+// ================ Step 5: Finalize =================
+void SSAPre::Finalize1() {
+  std::vector<MeOccur*> availDefVec(classCount, nullptr);
+  // traversal in preoder DT
+  for (MeOccur *occ : allOccs) {
+    auto classX = static_cast<size_t>(occ->GetClassID());
+    switch (occ->GetOccType()) {
+      case kOccPhiocc: {
+        auto *phiOcc = static_cast<MePhiOcc*>(occ);
+        if (phiOcc->IsWillBeAvail()) {
+          availDefVec[classX] = phiOcc;
+        }
+        break;
+      }
+      case kOccReal: {
+        MeOccur *availDef = availDefVec[classX];
+        auto *realOcc = static_cast<MeRealOcc*>(occ);
+        if (availDef == nullptr || !availDef->IsDominate(*dom, *occ)) {
+          realOcc->SetIsReload(false);
+          availDefVec[classX] = realOcc;
+        } else {
+          realOcc->SetIsReload(true);
+          ASSERT(!realOcc->IsSave(), "real occ with isSave cannot be set isReload");
+          realOcc->SetDef(availDefVec[classX]);
+        }
+        break;
+      }
+      case kOccCompare: {
+        if (classX == 0) {
+          break;
+        }
+        MeOccur *availDef = availDefVec[classX];
+        if (availDef == nullptr) {
+          occ->SetClassID(0);
+          break;
+        }
+        if (availDef->GetOccType() == kOccReal) {
+          MeRealOcc *realOcc = static_cast<MeRealOcc*>(availDef);
+          if (!realOcc->IsReload() && !realOcc->IsSave()) {
+            occ->SetClassID(0);
+            break;
+          }
+        }
+        CHECK_FATAL(availDef->IsDominate(*dom, *occ), "compare occ's available def not dominating it");
+        MeRealOcc *compOcc = static_cast<MeRealOcc*>(occ);
+        compOcc->SetIsReload(true);
+        compOcc->SetDef(availDefVec[classX]);
+        break;
+      }
+      case kOccPhiopnd: {
+        // we assume one phiOpnd has only one phiOcc use because critical edge split the blocks
+        auto *phiOpnd = static_cast<MePhiOpndOcc*>(occ);
+        MePhiOcc *phiOcc = phiOpnd->GetDefPhiOcc();
+        if (!phiOcc->IsWillBeAvail()) {
+          break;
+        }
+        if (phiOpnd->IsOkToInsert()) {
+          // insert the current expression at the end of the block containing phiOpnd
+          if (phiOpnd->GetBB()->GetSucc().size() > 1) {
+            CHECK_FATAL(!workCand->Redo2HandleCritEdges(), "Finalize1: insertion at critical edge, aborting");
+            workCand->SetRedo2HandleCritEdges(true);
+            if (GetSSAPreDebug()) {
+              mirModule->GetOut() << "<<<<< Re-doing this candidate due to existence of critical edge >>>>>\n";
+            }
+            return;
+          }
+          MeExpr *insertedExpr = phiOpnd->GetCurrentMeExpr();
+          ASSERT(insertedExpr != nullptr, "NYI");
+          MeInsertedOcc *insertedOcc =
+              perCandMemPool->New<MeInsertedOcc>(insertedExpr, static_cast<MeStmt*>(nullptr), *phiOpnd->GetBB());
+          insertedOcc->SetClassID(classCount++);
+          phiOpnd->SetDef(insertedOcc);
+          phiOpnd->SetClassID(insertedOcc->GetClassID());
+          if (workCand->GetPUIdx() != GetPUIdx()) {
+            ASSERT(!workCand->HasLocalOpnd(), "candidate with local opnd cannot be inserted outside its PU");
+            workCand->SetPUIdx(0);
+          }
+          phiOpnd->SetIsInsertedOcc(true);
+        } else {
+          phiOpnd->SetDef(availDefVec[classX]);
+        }
+        break;
+      }
+      case kOccExit:
+        break;
+      case kOccMembar:
+      case kOccUse:
+        break;
+      default:
+        ASSERT(false, "should not be here");
+        break;
+    }
+  }
+  if (!GetSSAPreDebug()) {
+    return;
+  }
+  PreWorkCand *curCand = workCand;
+  mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() <<
+      " after Finalize1===================\n";
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    if (!phiOcc->IsWillBeAvail()) {
+      continue;
+    }
+    for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+      ASSERT(phiOpnd->GetDef() != nullptr, "EPhiFinalizer::DumpFinalize1: phiopndocc cannot have no def");
+      MeOccur *defOcc = phiOpnd->GetDef();
+      if (defOcc->GetOccType() == kOccInserted) {
+        auto *realDefOcc = static_cast<MeInsertedOcc*>(defOcc);
+        phiOpnd->Dump(*irMap);
+        mirModule->GetOut() << " was inserted by ";
+        realDefOcc->Dump(*irMap);
+        mirModule->GetOut() << "\n";
+      }
+    }
+  }
+}
+
+// set save the real occurrence of definition to register
+// set the PHI occurence to be needed (extraneous being false)
+void SSAPre::SetSave(MeOccur &defX) {
+  if (defX.GetOccType() == kOccReal) {
+    auto *realOcc = static_cast<MeRealOcc*>(&defX);
+    realOcc->SetIsSave(true);
+    ASSERT(!realOcc->IsReload(), "real occ with isReload cannot be set isSave");
+  } else if (defX.GetOccType() == kOccPhiocc) {
+    for (MePhiOpndOcc *phiOpnd : static_cast<MePhiOcc*>(&defX)->GetPhiOpnds()) {
+      if (!phiOpnd->IsProcessed()) {
+        phiOpnd->SetIsProcessed(true);
+        SetSave(*phiOpnd->GetDef());
+      }
+    }
+  }
+  if (defX.GetOccType() == kOccReal || defX.GetOccType() == kOccInserted) {
+    BB *fromBb = defX.GetBB();
+    MapleSet<uint32> itFrontier(perCandAllocator.Adapter());
+    CHECK_FATAL(!dom->IsNodeVecEmpty(), "the size to be allocated is 0");
+    GetIterDomFrontier(fromBb, &itFrontier);
+    for (MePhiOcc *phiOcc : phiOccs) {
+      if (!phiOcc->IsWillBeAvail()) {
+        continue;
+      }
+      if (itFrontier.find(dom->GetDtDfnItem(phiOcc->GetBB()->GetBBId())) == itFrontier.end()) {
+        continue;
+      }
+      phiOcc->SetIsExtraneous(false);
+    }
+  }
+}
+
+void SSAPre::SetReplacement(MePhiOcc &occ, MeOccur &repDef) {
+  occ.SetIsRemoved(true);  // exclude recursive PhiOcc
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    if (phiOcc->IsRemoved()) {
+      continue;
+    }
+    for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+      if (phiOpnd->GetDef() == &occ) {
+        if (phiOcc->IsExtraneous()) {
+          // exclude recursive def
+          SetReplacement(*phiOcc, repDef);
+        } else {
+          phiOpnd->SetDef(&repDef);  // replace phiOpnd of phiOcc by replacing def repDef
+          phiOpnd->SetClassID(repDef.GetClassID());
+          phiOpnd->SetIsPhiOpndReload(true);
+        }
+      }
+    }
+  }
+  ASSERT_NOT_NULL(workCand);
+  for (auto it = workCand->GetRealOccs().begin(); it != workCand->GetRealOccs().end(); ++it) {
+    MeRealOcc *realOcc = *it;
+    // when realOcc satisfying reload and def of it is occ, do the replacement
+    if (realOcc->IsReload() && realOcc->GetDef() == &occ) {
+      realOcc->SetDef(&repDef);
+      realOcc->SetClassID(repDef.GetClassID());
+    }
+  }
+}
+
+void SSAPre::Finalize2() {
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    // initialize extraneouse for each MePhiOcc
+    if (!workCand->isSRCand) {
+      phiOcc->SetIsExtraneous(phiOcc->IsWillBeAvail());
+    }
+
+    // initialize each operand of phiOcc
+    for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+      phiOpnd->SetIsProcessed(false);
+    }
+  }
+  for (auto it = workCand->GetRealOccs().begin(); it != workCand->GetRealOccs().end(); ++it) {
+    MeRealOcc *realOcc = *it;
+    if (realOcc->IsReload()) {
+      SetSave(*realOcc->GetDef());
+    }
+  }
+  if (!workCand->isSRCand) {
+    for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+      MePhiOcc *phiOcc = *it;
+      if (phiOcc->IsRemoved() || !phiOcc->IsExtraneous()) {
+        continue;
+      }
+      if (!phiOcc->IsWillBeAvail()) {
+        phiOcc->SetIsRemoved(true);
+        continue;
+      }
+      for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+        MeOccur *defOcc = phiOpnd->GetDef();
+        switch (defOcc->GetOccType()) {
+          case kOccReal:
+            SetReplacement(*phiOcc, *defOcc);
+            break;
+          case kOccInserted:
+            break;
+          case kOccPhiocc:
+            if (!static_cast<MePhiOcc*>(defOcc)->IsExtraneous()) {
+              SetReplacement(*phiOcc, *defOcc);
+            }
+            break;
+          default:
+            CHECK_FATAL(false, "unexpected phiOpnd");
+        }
+      }
+    }
+  }
+
+  if (GetSSAPreDebug()) {
+    mirModule->GetOut() << "========after Finalize2====================\n";
+    for (MeOccur *occ : allOccs) {
+      if (occ->GetOccType() == kOccPhiocc) {
+        auto *phiOcc = static_cast<MePhiOcc*>(occ);
+        phiOcc->Dump(*irMap);
+        if (phiOcc->IsRemoved()) {
+          mirModule->GetOut() << "was removed in Finalize2";
+        }
+        mirModule->GetOut() << std::endl;
+      } else if (occ->GetOccType() == kOccReal) {
+        auto *realOcc = static_cast<MeRealOcc*>(occ);
+        if (realOcc->IsReload()) {
+          realOcc->Dump(*irMap);
+          mirModule->GetOut() << " isReload\n";
+        }
+        if (realOcc->IsSave()) {
+          realOcc->Dump(*irMap);
+          mirModule->GetOut() << " isSave\n";
+        }
+      } else if (occ->GetOccType() == kOccPhiopnd) {
+        auto *phiOpndOcc = static_cast<MePhiOpndOcc*>(occ);
+        if (phiOpndOcc->IsInsertedOcc()) {
+          phiOpndOcc->Dump(*irMap);
+          mirModule->GetOut() << " inserthere\n";
+        }
+      }
+    }
+  }
+}
+
+// ================ Step 4: WillBeAvail Computation =================
+// propagate not-can_be_avail attribute forward
+// along def-use chain to not-downsafety nodes
+void SSAPre::ResetCanBeAvail(MePhiOcc &occ) const {
+  occ.SetIsCanBeAvail(false);
+  // the following loop is to find occ's use list and reset them
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+      if (phiOpnd->GetDef() != nullptr && phiOpnd->GetDef() == &occ) {
+        // when comes here, phiOpnd->GetDef() is a use of occ
+        if (!phiOpnd->HasRealUse() && !phiOcc->IsDownSafe() && phiOcc->IsCanBeAvail()) {
+          ResetCanBeAvail(*phiOcc);
+        }
+      }
+    }
+  }
+}
+
+void SSAPre::ComputeCanBeAvail() const {
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    if (!phiOcc->IsDownSafe() && phiOcc->IsCanBeAvail()) {
+      bool existNullDef = false;
+      for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+        if (phiOpnd->GetDef() == nullptr) {
+          existNullDef = true;
+          break;
+        }
+      }
+      if (existNullDef) {
+        ResetCanBeAvail(*phiOcc);
+      }
+    }
+    ASSERT_NOT_NULL(workCand);
+    if (workCand->Redo2HandleCritEdges() && phiOcc->IsCanBeAvail()) {
+      // check critical edges
+      bool existCritEdge = false;
+      for (BB *pred : phiOcc->GetBB()->GetPred()) {
+        if (pred->GetSucc().size() > 1) {
+          existCritEdge = true;
+          break;
+        }
+      }
+      if (existCritEdge) {
+        ResetCanBeAvail(*phiOcc);
+      }
+    }
+  }
+}
+
+void SSAPre::ResetLater(MePhiOcc &occ) const {
+  occ.SetIsLater(false);
+  // the following loop is to find occ's use list and reset them
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+      if (phiOpnd->GetDef() != nullptr && phiOpnd->GetDef() == &occ) {
+        // when comes here, phiOpnd->GetDef() is a use of occ
+        if (phiOcc->IsLater()) {
+          ResetLater(*phiOcc);
+        }
+      }
+    }
+  }
+}
+
+void SSAPre::ComputeLater() const {
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    phiOcc->SetIsLater(phiOcc->IsCanBeAvail());
+  }
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    if (phiOcc->IsLater()) {
+      bool existNonNullDef = false;
+      for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+        if (phiOpnd->GetDef() != nullptr && phiOpnd->HasRealUse()) {
+          existNonNullDef = true;
+          break;
+        }
+      }
+      if (existNonNullDef || phiOcc->SpeculativeDownSafe()) {
+        ResetLater(*phiOcc);
+      }
+    }
+  }
+  if (GetSSAPreDebug()) {
+    mirModule->GetOut() << "========ssapre candidate " << workCand->GetIndex()
+                        << " after WillBeAvail===================\n";
+    for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+      MePhiOcc *phiOcc = *it;
+      phiOcc->Dump(*irMap);
+      if (phiOcc->IsCanBeAvail()) {
+        mirModule->GetOut() << " can be avail;";
+      } else {
+        mirModule->GetOut() << " not can be avail;";
+      }
+      if (phiOcc->IsLater()) {
+        mirModule->GetOut() << " later;";
+      } else {
+        mirModule->GetOut() << " not later;";
+      }
+      if (phiOcc->IsCanBeAvail() && !phiOcc->IsLater()) {
+        mirModule->GetOut() << " will be avail";
+      } else {
+        mirModule->GetOut() << " not will be avail";
+      }
+      mirModule->GetOut() << "\n";
+    }
+  }
+}
+
+// ================ Step 3: Downsafe Computation =================
+// reset downsafety
+void SSAPre::ResetDS(MePhiOpndOcc &phiOpnd) const {
+  if (phiOpnd.HasRealUse()) {
+    return;
+  }
+  MeOccur *defOcc = phiOpnd.GetDef();
+  if (defOcc == nullptr || defOcc->GetOccType() != kOccPhiocc) {
+    return;
+  }
+  auto *defPhiOcc = static_cast<MePhiOcc*>(defOcc);
+  if (defPhiOcc->SpeculativeDownSafe()) {
+    return;
+  }
+  if (!defPhiOcc->IsDownSafe()) {
+    return;
+  }
+  defPhiOcc->SetIsDownSafe(false);
+  for (MePhiOpndOcc *mePhiOpnd : defPhiOcc->GetPhiOpnds()) {
+    ResetDS(*mePhiOpnd);
+  }
+}
+
+// compute downsafety for each PHI
+void SSAPre::ComputeDS() const {
+  for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+    MePhiOcc *phiOcc = *it;
+    if (!phiOcc->IsDownSafe()) {
+      // propagate not-downsafety along use-def edges
+      for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+        ResetDS(*phiOpnd);
+      }
+    }
+  }
+  if (GetSSAPreDebug()) {
+    mirModule->GetOut() << "========ssapre candidate " << workCand->GetIndex()
+                        << " after DownSafety===================\n";
+    for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) {
+      MePhiOcc *phiOcc = *it;
+      phiOcc->Dump(*irMap);
+      if (phiOcc->SpeculativeDownSafe()) {
+        mirModule->GetOut() << " spec_downsafe /";
+      }
+      if (phiOcc->IsDownSafe()) {
+        mirModule->GetOut() << " is downsafe\n";
+        for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) {
+          if (!phiOpnd->IsProcessed()) {
+            phiOpnd->Dump(*irMap);
+            mirModule->GetOut() << " has not been processed by Rename2\n";
+          }
+        }
+      } else {
+        mirModule->GetOut() << " is not downsafe\n";
+      }
+    }
+  }
+}
+
+// ================ Step 2: Renaming =================
+void SSAPre::Rename1() {
+  std::stack<MeOccur*> occStack;
+  rename2Set.clear();
+  classCount = 1;
+  // iterate the occurrence according to its preorder dominator tree
+  for (MeOccur *occ : allOccs) {
+    while (!occStack.empty() && !occStack.top()->IsDominate(*dom, *occ)) {
+      occStack.pop();
+    }
+    switch (occ->GetOccType()) {
+      case kOccReal: {
+        if (occStack.empty()) {
+          // assign new class
+          occ->SetClassID(classCount++);
+          occStack.push(occ);
+          break;
+        }
+        MeOccur *topOccur = occStack.top();
+        if (topOccur->GetOccType() == kOccUse || topOccur->GetOccType() == kOccMembar) {
+          occ->SetClassID(classCount++);
+          occStack.push(occ);
+          break;
+        }
+        auto *realOcc = static_cast<MeRealOcc*>(occ);
+        if (topOccur->GetOccType() == kOccReal) {
+          auto *realTopOccur = static_cast<MeRealOcc*>(topOccur);
+          if (AllVarsSameVersion(*realTopOccur, *realOcc)) {
+            // all corresponding variables are the same
+            realOcc->SetClassID(realTopOccur->GetClassID());
+            if (realTopOccur->GetDef() != nullptr) {
+              realOcc->SetDef(realTopOccur->GetDef());
+            } else {
+              realOcc->SetDef(realTopOccur);
+            }
+          } else {
+            // assign new class
+            occ->SetClassID(classCount++);
+            occStack.push(occ);
+          }
+        } else {
+          // top of stack is a PHI occurrence
+          ASSERT(topOccur->GetOccType() == kOccPhiocc, "invalid kOccPhiocc");
+          std::vector<MeExpr*> varVec;
+          CollectVarForCand(*realOcc, varVec);
+          bool isAllDom = true;
+          if (realOcc->IsLHS()) {
+            isAllDom = false;
+          } else {
+            for (auto varIt = varVec.begin(); varIt != varVec.end(); ++varIt) {
+              MeExpr *varMeExpr = *varIt;
+              if (workCand->isSRCand) {
+                varMeExpr = ResolveAllInjuringDefs(varMeExpr);
+              }
+              if (!DefVarDominateOcc(varMeExpr, *topOccur)) {
+                isAllDom = false;
+              }
+            }
+          }
+          if (isAllDom) {
+            realOcc->SetClassID(topOccur->GetClassID());
+            realOcc->SetDef(topOccur);
+            (void)rename2Set.insert(realOcc->GetPosition());
+            occStack.push(realOcc);
+            if (IsLoopHeadBB(topOccur->GetBB()->GetBBId())) {
+              static_cast<MePhiOcc*>(topOccur)->SetSpeculativeDownSafe(true);
+              static_cast<MePhiOcc*>(topOccur)->SetIsDownSafe(true);
+            }
+          } else {
+            auto *phiTopOccur = static_cast<MePhiOcc*>(topOccur);
+            if (!phiTopOccur->SpeculativeDownSafe()) {
+              phiTopOccur->SetIsDownSafe(false);
+            }
+            // assign new class
+            occ->SetClassID(classCount++);
+            occStack.push(occ);
+          }
+        }
+        break;
+      }
+      case kOccCompare: {
+        if (occStack.empty()) {
+          break;
+        }
+        MeOccur *topOccur = occStack.top();
+        if (topOccur->GetOccType() == kOccUse || topOccur->GetOccType() == kOccMembar) {
+          break;
+        }
+        MeRealOcc *realOcc = static_cast<MeRealOcc *>(occ);
+        ScalarMeExpr *scalarOpnd0 = dynamic_cast<ScalarMeExpr *>(workCand->GetTheMeExpr()->GetOpnd(0));
+        ScalarMeExpr *scalarOpnd1 = dynamic_cast<ScalarMeExpr *>(workCand->GetTheMeExpr()->GetOpnd(1));
+        ScalarMeExpr *compareOpnd0 = dynamic_cast<ScalarMeExpr *>(realOcc->GetMeExpr()->GetOpnd(0));
+        ScalarMeExpr *compareOpnd1 = dynamic_cast<ScalarMeExpr *>(realOcc->GetMeExpr()->GetOpnd(1));
+        // set compareOpnd to be the scalar operand that is common to
+        // workCand->theMeExpr and realOcc->meExpr
+        ScalarMeExpr *compareOpnd = nullptr;
+        uint32 scalarOpndNo = 0;
+        if (scalarOpnd0 != nullptr) {
+          if (compareOpnd0 != nullptr && scalarOpnd0->GetOst() == compareOpnd0->GetOst()) {
+            compareOpnd = compareOpnd0;
+            scalarOpndNo = 0;
+          } else if (compareOpnd1 != nullptr && scalarOpnd0->GetOst() == compareOpnd1->GetOst()) {
+            compareOpnd = compareOpnd1;
+            scalarOpndNo = 0;
+          }
+        }
+        if (scalarOpnd1 != nullptr) {
+          if (compareOpnd0 != nullptr && scalarOpnd1->GetOst() == compareOpnd0->GetOst()) {
+            compareOpnd = compareOpnd0;
+            scalarOpndNo = 1;
+          } else if (compareOpnd1 != nullptr && scalarOpnd1->GetOst() == compareOpnd1->GetOst()) {
+            compareOpnd = compareOpnd1;
+            scalarOpndNo = 1;
+          }
+        }
+        CHECK_FATAL(compareOpnd != nullptr, "Rename1: compOcc does not correspond to realOcc");
+        ScalarMeExpr *resolvedCompareOpnd = ResolveAllInjuringDefs(compareOpnd);
+        if (topOccur->GetOccType() == kOccReal) {
+          MeRealOcc *realTopOccur = static_cast<MeRealOcc *>(topOccur);
+          ScalarMeExpr *topOccurOpnd = static_cast<ScalarMeExpr *>(realTopOccur->GetMeExpr()->GetOpnd(scalarOpndNo));
+          if (compareOpnd == topOccurOpnd || resolvedCompareOpnd == topOccurOpnd) {
+            realOcc->SetClassID(realTopOccur->GetClassID());
+            if (realTopOccur->GetDef() != nullptr) {
+              realOcc->SetDef(realTopOccur->GetDef());
+            } else {
+              realOcc->SetDef(realTopOccur);
+            }
+          }
+          break;
+        }
+        // top of stack is a PHI occurrence
+        ASSERT(topOccur->GetOccType() == kOccPhiocc, "invalid kOccPhiocc");
+        if (DefVarDominateOcc(compareOpnd, *topOccur)) {
+          realOcc->SetClassID(topOccur->GetClassID());
+          realOcc->SetDef(topOccur);
+        }
+        break;
+      }
+      case kOccPhiocc: {
+        // assign new class
+        occ->SetClassID(classCount++);
+        occStack.push(occ);
+        break;
+      }
+      case kOccPhiopnd: {
+        // stow away the use occurrences at the stack top
+        MeOccur *stowedUseOcc = nullptr;
+        if (!occStack.empty() && occStack.top()->GetOccType() == kOccUse) {
+          stowedUseOcc = occStack.top();
+          occStack.pop();
+          CHECK_FATAL(occStack.empty() || occStack.top()->GetOccType() != kOccUse,
+                      "Rename1: cannot have 2 consecutive use occurs on stack");
+        }
+        if (occStack.empty() || occStack.top()->GetOccType() == kOccMembar) {
+          occ->SetDef(nullptr);
+        } else {
+          MeOccur *topOccur = occStack.top();
+          occ->SetDef(topOccur);
+          occ->SetClassID(topOccur->GetClassID());
+          if (topOccur->GetOccType() == kOccReal) {
+            static_cast<MePhiOpndOcc*>(occ)->SetHasRealUse(true);
+          }
+        }
+        // push stowed use_occ back
+        if (stowedUseOcc != nullptr) {
+          occStack.push(stowedUseOcc);
+        }
+        break;
+      }
+      case kOccExit: {
+        if (occStack.empty()) {
+          break;
+        }
+        MeOccur *topOccur = occStack.top();
+        if (topOccur->GetOccType() == kOccPhiocc) {
+          auto *phiTopOccur = static_cast<MePhiOcc*>(topOccur);
+          if (!phiTopOccur->SpeculativeDownSafe()) {
+            phiTopOccur->SetIsDownSafe(false);
+          }
+        }
+        break;
+      }
+      case kOccMembar:
+      case kOccUse: {
+        if (!occStack.empty()) {
+          MeOccur *topOccur = occStack.top();
+          if (topOccur->GetOccType() == kOccPhiocc) {
+            auto *phiTopOccur = static_cast<MePhiOcc*>(topOccur);
+            phiTopOccur->SetIsDownSafe(false);
+          } else if (topOccur->GetOccType() != occ->GetOccType()) {
+            occStack.push(occ);
+          }
+        } else {
+          occStack.push(occ);
+        }
+        break;
+      }
+      default:
+        ASSERT(false, "should not be here");
+        break;
+    }
+  }
+  if (GetSSAPreDebug()) {
+    PreWorkCand *curCand = workCand;
+    mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() << " after rename1===================\n";
+    for (MeOccur *occ : allOccs) {
+      occ->Dump(*irMap);
+      mirModule->GetOut() << '\n';
+    }
+    mirModule->GetOut() << "\n" << "rename2 set:\n";
+    for (uint32 pos : rename2Set) {
+      MeRealOcc *occur = workCand->GetRealOcc(pos);
+      occur->Dump(*irMap);
+      mirModule->GetOut() << " with def at\n";
+      occur->GetDef()->Dump(*irMap);
+      mirModule->GetOut() << "\n";
+    }
+    mirModule->GetOut() << "\n";
+  }
+}
+
+// if opnd has a phi definition at ePhiBB, return the jth opnd of the phi;
+// return nullptr otherwise
+MeExpr *SSAPre::GetReplaceMeExpr(const MeExpr &opnd, const BB &ePhiBB, size_t j) const {
+  if (opnd.GetMeOp() != kMeOpVar && opnd.GetMeOp() != kMeOpReg) {
+    return nullptr;
+  }
+
+  const ScalarMeExpr *expr = static_cast<const ScalarMeExpr*>(&opnd);
+  auto it = ePhiBB.GetMePhiList().find(expr->GetOst()->GetIndex());
+  if (it == ePhiBB.GetMePhiList().end()) {
+    return nullptr;
+  }
+  MePhiNode *defPhi = it->second;
+  MeExpr *retExpr = defPhi->GetOpnds()[j];
+  if (retExpr->GetPrimType() == kPtyInvalid) {
+    ASSERT_NOT_NULL(workCand);
+    retExpr->SetPtyp(workCand->GetPrimType());
+  }
+  return retExpr;
+}
+
+void SSAPre::Rename2() {
+  while (!rename2Set.empty()) {
+    MapleSet<uint32>::iterator it = rename2Set.begin();
+    MeRealOcc *realOcc = workCand->GetRealOcc(*it);
+    (void)rename2Set.erase(it);
+    MeOccur *defOcc = realOcc->GetDef();
+    if (defOcc == nullptr || defOcc->GetOccType() != kOccPhiocc) {
+      CHECK_FATAL(false, "should be def by phiOcc");
+    }
+    auto *defPhiOcc = static_cast<MePhiOcc*>(defOcc);
+    auto &phiOpnds = defPhiOcc->GetPhiOpnds();
+    for (size_t i = 0; i < phiOpnds.size(); i++) {
+      MePhiOpndOcc *phiOpnd = phiOpnds[i];
+      if (phiOpnd->IsProcessed()) {
+        continue;
+      }
+      phiOpnd->SetIsProcessed(true);
+      MeExpr *exprY = PhiOpndFromRes(*realOcc, i);
+      phiOpnd->SetCurrentMeExpr(*exprY);  // expr_y might be inserted at the end of the block
+      MeOccur *defX = phiOpnd->GetDef();
+      if (defX == nullptr) {
+        continue;
+      }
+      if (defX->GetOccType() == kOccReal) {
+        auto *realDefX = static_cast<MeRealOcc*>(defX);
+        std::vector<MeExpr*> varVecX;
+        std::vector<MeExpr*> varVecY;
+        CollectVarForMeExpr(*realDefX->GetMeExpr(), varVecX);
+        CollectVarForMeExpr(*exprY, varVecY);
+        CHECK_FATAL(varVecX.size() == varVecY.size(), "invalid size of varVecY");
+        bool hasSameVersion = true;
+        for (size_t ii = 0; ii < varVecX.size(); ii++) {
+          MeExpr *resolvedY = ResolveAllInjuringDefs(varVecY[ii]);
+          if (varVecX[ii] != resolvedY && varVecX[ii] != varVecY[ii]) {
+            hasSameVersion = false;
+          }
+        }
+        if (!hasSameVersion) {
+          phiOpnd->SetDef(nullptr);
+          phiOpnd->SetHasRealUse(false);
+          phiOpnd->SetClassID(static_cast<int32>(classCount++));
+        }
+      } else if (defX->GetOccType() == kOccPhiocc) {
+        std::vector<MeExpr*> varVecY;
+        bool alldom = true;
+        CollectVarForMeExpr(*exprY, varVecY);
+        if (exprY->GetMeOp() == kMeOpOp) {
+          OpMeExpr opmeexpr(*static_cast<OpMeExpr *>(exprY), -1);
+          for (uint32 ii = 0; ii < varVecY.size(); ii++) {
+            MeExpr *resolvedY = ResolveAllInjuringDefs(varVecY[ii]);
+            if (!DefVarDominateOcc(resolvedY, *defX)) {
+              alldom = false;
+            }
+          }
+          opmeexpr.SetHasAddressValue();
+          exprY = irMap->HashMeExpr(opmeexpr);
+        } else {
+          for (size_t ii = 0; ii < varVecY.size(); ++ii) {
+            if (!DefVarDominateOcc(varVecY[ii], *defX)) {
+              alldom = false;
+            }
+          }
+        }
+        if (alldom) {
+          // create a realOcc and add to rename2 set
+          MeRealOcc *occY = perCandMemPool->New<MeRealOcc>(static_cast<MeStmt*>(nullptr), 0, exprY);
+          occY->SetPosition(workCand->GetRealOccs().size());
+          workCand->GetRealOccs().push_back(occY);
+          occY->SetDef(defX);
+          occY->SetClassID(defX->GetClassID());
+          occY->SetBB(*phiOpnd->GetBB());  // used for AddRealOccSorted
+          (void)rename2Set.insert(occY->GetPosition());
+          if (GetSSAPreDebug()) {
+            mirModule->GetOut() << "--- rename2 adds to rename2Set manufactured ";
+            occY->Dump(*irMap);
+            mirModule->GetOut() << '\n';
+            mirModule->GetOut() << "             with def at\n";
+            occY->GetDef()->Dump(*irMap);
+            mirModule->GetOut() << "\n";
+          }
+        } else {
+          phiOpnd->SetDef(nullptr);
+          phiOpnd->SetHasRealUse(false);
+          auto *phidefx = static_cast<MePhiOcc*>(defX);
+          if (!phidefx->SpeculativeDownSafe()) {
+            phidefx->SetIsDownSafe(false);
+          }
+        }
+      }
+    }
+  }
+  if (GetSSAPreDebug()) {
+    PreWorkCand *curCand = workCand;
+    mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() << " after rename2===================\n";
+    for (MeOccur *occ : allOccs) {
+      occ->Dump(*irMap);
+      mirModule->GetOut() << '\n';
+    }
+  }
+}
+
+// ================ Step 1: Phi Insertion =================
+void SSAPre::SetVarPhis(MeExpr *meExpr) {
+  MeExprOp meOp = meExpr->GetMeOp();
+  if (meOp != kMeOpVar && meOp != kMeOpReg) {
+    return;
+  }
+
+  ScalarMeExpr *scalar = static_cast<ScalarMeExpr*>(meExpr);
+  if (workCand->isSRCand) {
+    scalar = ResolveAllInjuringDefs(scalar);
+  }
+  if (scalar->IsDefByPhi()) {
+    MePhiNode *phiMeNode = scalar->GetMePhiDef();
+    BBId defBBId = phiMeNode->GetDefBB()->GetBBId();
+    CHECK(defBBId < dom->GetDtDfnSize(), "defBBId.idx out of range in SSAPre::SetVarPhis");
+    if (varPhiDfns.find(dom->GetDtDfnItem(defBBId)) == varPhiDfns.end() && ScreenPhiBB(defBBId)) {
+      (void)varPhiDfns.insert(dom->GetDtDfnItem(defBBId));
+      for (auto opndIt = phiMeNode->GetOpnds().begin(); opndIt != phiMeNode->GetOpnds().end(); ++opndIt) {
+        ScalarMeExpr *opnd = *opndIt;
+        SetVarPhis(opnd);
+      }
+    }
+  }
+}
+
+// based on ssapre->workCand's realOccs and dfPhiDfns (which now privides all
+// the inserted phis), create the phi and phiOpnd occ nodes; link them all up in
+// order of dt_preorder in ssapre->allOccs; the phi occ nodes are in addition
+// provided in order of dt_preorder in ssapre->phiOccs
+void SSAPre::CreateSortedOccs() {
+  // merge varPhiDfns to dfPhiDfns
+  dfPhiDfns.insert(varPhiDfns.cbegin(), varPhiDfns.cend());
+  // form phiOpnd_dfns
+  std::multiset<uint32> phiOpndDfns;
+  for (uint32 dfn : dfPhiDfns) {
+    auto bbId = BBId(dom->GetDtPreOrderItem(dfn));
+    BB *bb = GetBB(bbId);
+    ASSERT(bb != nullptr, "GetBB return null in SSAPre::CreateSortedOccs");
+    for (BB *pred : bb->GetPred()) {
+      (void)phiOpndDfns.insert(dom->GetDtDfnItem(pred->GetBBId()));
+    }
+  }
+  // under lpre, form lhs occ for formals at function entry
+  if (GetRcLoweringOn()) {
+    BuildEntryLHSOcc4Formals();
+  }
+  std::unordered_map<BBId, std::forward_list<MePhiOpndOcc*>> bb2PhiOpndMap;
+  MapleVector<MeRealOcc*>::iterator realOccIt = workCand->GetRealOccs().begin();
+  MapleVector<MeOccur*>::iterator exitOccIt = exitOccs.begin();
+  auto phiDfnIt = dfPhiDfns.begin();
+  auto phiOpndDfnIt = phiOpndDfns.begin();
+  MeRealOcc *nextRealOcc = nullptr;
+  if (realOccIt != workCand->GetRealOccs().end()) {
+    nextRealOcc = *realOccIt;
+  }
+  MeOccur *nextExitOcc = nullptr;
+  if (exitOccIt != exitOccs.end()) {
+    nextExitOcc = *exitOccIt;
+  }
+  MePhiOcc *nextPhiOcc = nullptr;
+  if (phiDfnIt != dfPhiDfns.end()) {
+    nextPhiOcc = perCandMemPool->New<MePhiOcc>(*GetBB(BBId(dom->GetDtPreOrderItem(*phiDfnIt))), perCandAllocator);
+  }
+  MePhiOpndOcc *nextPhiOpndOcc = nullptr;
+  if (phiOpndDfnIt != phiOpndDfns.end()) {
+    nextPhiOpndOcc = perCandMemPool->New<MePhiOpndOcc>(*GetBB(BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt))));
+    auto it = bb2PhiOpndMap.find(BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt)));
+    if (it == bb2PhiOpndMap.end()) {
+      std::forward_list<MePhiOpndOcc*> newlist = { nextPhiOpndOcc };
+      CHECK(*phiOpndDfnIt < dom->GetDtPreOrderSize(), "index out of range in SSAPre::CreateSortedOccs");
+      bb2PhiOpndMap[BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt))] = newlist;
+    } else {
+      it->second.push_front(nextPhiOpndOcc);
+    }
+  }
+  MeOccur *pickedOcc;  // the next picked occ in order of preorder traveral of dominator tree
+  do {
+    pickedOcc = nullptr;
+    // the 4 kinds of occ must be checked in this order, so it will be right
+    // if more than 1 has the same dfn
+    if (nextPhiOcc != nullptr) {
+      pickedOcc = nextPhiOcc;
+    }
+    if (nextRealOcc != nullptr && (pickedOcc == nullptr ||
+                                   dom->GetDtDfnItem(nextRealOcc->GetBB()->GetBBId()) <
+                                   dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) {
+      pickedOcc = nextRealOcc;
+    }
+    if (nextExitOcc != nullptr && (pickedOcc == nullptr ||
+                                   dom->GetDtDfnItem(nextExitOcc->GetBB()->GetBBId()) <
+                                   dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) {
+      pickedOcc = nextExitOcc;
+    }
+    if (nextPhiOpndOcc != nullptr &&
+        (pickedOcc == nullptr || *phiOpndDfnIt < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) {
+      pickedOcc = nextPhiOpndOcc;
+    }
+    if (pickedOcc != nullptr) {
+      allOccs.push_back(pickedOcc);
+      switch (pickedOcc->GetOccType()) {
+        case kOccReal:
+        case kOccMembar:
+        case kOccCompare:
+          ++realOccIt;
+          if (realOccIt != workCand->GetRealOccs().end()) {
+            nextRealOcc = *realOccIt;
+          } else {
+            nextRealOcc = nullptr;
+          }
+          break;
+        case kOccExit:
+          ++exitOccIt;
+          if (exitOccIt != exitOccs.end()) {
+            nextExitOcc = *exitOccIt;
+          } else {
+            nextExitOcc = nullptr;
+          }
+          break;
+        case kOccPhiocc:
+          phiOccs.push_back(static_cast<MePhiOcc*>(pickedOcc));
+          ++phiDfnIt;
+          if (phiDfnIt != dfPhiDfns.end()) {
+            nextPhiOcc = perCandMemPool->New<MePhiOcc>(
+                *GetBB(BBId(dom->GetDtPreOrderItem(*phiDfnIt))), perCandAllocator);
+          } else {
+            nextPhiOcc = nullptr;
+          }
+          break;
+        case kOccPhiopnd:
+          ++phiOpndDfnIt;
+          if (phiOpndDfnIt != phiOpndDfns.end()) {
+            nextPhiOpndOcc = perCandMemPool->New<MePhiOpndOcc>(*GetBB(BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt))));
+            auto it = bb2PhiOpndMap.find(BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt)));
+            if (it == bb2PhiOpndMap.end()) {
+              std::forward_list<MePhiOpndOcc*> newList = { nextPhiOpndOcc };
+              bb2PhiOpndMap[BBId(dom->GetDtPreOrderItem(*phiOpndDfnIt))] = newList;
+            } else {
+              it->second.push_front(nextPhiOpndOcc);
+            }
+          } else {
+            nextPhiOpndOcc = nullptr;
+          }
+          break;
+        default:
+          ASSERT(false, "CreateSortedOccs: unexpected occty");
+          break;
+      }
+    }
+  } while (pickedOcc != nullptr);
+  // initialize phiOpnds vector in each MePhiOcc node and defPhiOcc field in
+  // each MePhiOpndOcc node
+  for (MePhiOcc *phiOcc : phiOccs) {
+    for (BB *pred : phiOcc->GetBB()->GetPred()) {
+      MePhiOpndOcc *phiOpndOcc = bb2PhiOpndMap[pred->GetBBId()].front();
+      phiOcc->AddPhiOpnd(*phiOpndOcc);
+      phiOpndOcc->SetDefPhiOcc(*phiOcc);
+      bb2PhiOpndMap[pred->GetBBId()].pop_front();
+    }
+  }
+  if (GetSSAPreDebug()) {
+    mirModule->GetOut() << "========ssapre candidate " << workCand->GetIndex() <<
+        " after phi insert===================\n";
+    for (MeOccur *occ : allOccs) {
+      occ->Dump(*irMap);
+      mirModule->GetOut() << '\n';
+    }
+  }
+}
+
+// ================ End of Step 1: Phi Insertion =================
+IassignMeStmt *SSAPre::CopyIassignMeStmt(const IassignMeStmt &iaStmt) const {
+  IassignMeStmt *meStmt = irMap->NewInPool<IassignMeStmt>(iaStmt);
+  return meStmt;
+}
+
+// if the definition of varMeExpr dominate meocc then return true. otherwise return false;
+bool SSAPre::DefVarDominateOcc(const MeExpr *meExpr, const MeOccur &meOcc) const {
+  if (meExpr == nullptr) {
+    // can be nullptr in the case of LHS occurrence
+    return false;
+  }
+  CHECK_FATAL(meOcc.GetOccType() == kOccPhiocc, "invalid value of meOcc->GetOccType()");
+  const BB *occBB = (static_cast<const MePhiOcc*>(&meOcc))->GetBB();
+  const ScalarMeExpr *scMeExpr = static_cast<const ScalarMeExpr*>(meExpr);
+  switch (scMeExpr->GetDefBy()) {
+    case kDefByNo:
+      return true;  // original version dominates everything
+    case kDefByStmt: {
+      MeStmt *meStmt = scMeExpr->GetDefStmt();
+      CHECK_FATAL(meStmt != nullptr, "should have a def meStmt");
+      BB *defBB = meStmt->GetBB();
+      if (occBB == defBB) {
+        return false;
+      }
+      return dom->Dominate(*defBB, *occBB);
+    }
+    case kDefByPhi: {
+      const MePhiNode &phiMeNode = scMeExpr->GetDefPhi();
+      const BB *defBB = phiMeNode.GetDefBB();
+      if (defBB->GetBBId() == occBB->GetBBId()) {
+        return true;
+      }
+      return dom->Dominate(*defBB, *occBB);
+    }
+    case kDefByMustDef: {
+      const MeStmt *meStmt = scMeExpr->GetDefMustDef().GetBase();
+      if (meStmt == nullptr) {
+        return true;  // it's a original variable dominate everything
+      }
+      const BB *defBB = meStmt->GetBB();
+      if (occBB == defBB) {
+        return false;
+      }
+      return dom->Dominate(*defBB, *occBB);
+    }
+    case kDefByChi: {
+      MeStmt *meStmt = scMeExpr->GetDefChi().GetBase();
+      if (meStmt == nullptr) {
+        return true;  // it's a original variable dominate everything
+      }
+      BB *defBB = meStmt->GetBB();
+      if (occBB == defBB) {
+        return false;
+      }
+      return dom->Dominate(*defBB, *occBB);
+    }
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+  return false;
+}
+
+bool SSAPre::CheckIfAnyLocalOpnd(const MeExpr &meExpr) const {
+  switch (meExpr.GetMeOp()) {
+    case kMeOpReg:
+      return true;
+    case kMeOpVar: {
+      auto *varMeExpr = static_cast<const VarMeExpr*>(&meExpr);
+      const MIRSymbol *st = varMeExpr->GetOst()->GetMIRSymbol();
+      return st->IsLocal();
+    }
+    case kMeOpIvar: {
+      auto *ivarMeExpr = static_cast<const IvarMeExpr*>(&meExpr);
+      return CheckIfAnyLocalOpnd(*ivarMeExpr->GetBase());
+    }
+    case kMeOpOp: {
+      auto *opMeExpr = static_cast<const OpMeExpr*>(&meExpr);
+      constexpr size_t firstOpnd = 0;
+      if (CheckIfAnyLocalOpnd(*opMeExpr->GetOpnd(firstOpnd))) {
+        return true;
+      }
+      constexpr size_t secondOpnd = 1;
+      if (opMeExpr->GetOpnd(secondOpnd) == nullptr) {
+        return false;
+      }
+      if (CheckIfAnyLocalOpnd(*opMeExpr->GetOpnd(secondOpnd))) {
+        return true;
+      }
+      constexpr size_t thirdOpnd = 2;
+      if (opMeExpr->GetOpnd(thirdOpnd) == nullptr) {
+        return false;
+      }
+      return CheckIfAnyLocalOpnd(*opMeExpr->GetOpnd(thirdOpnd));
+    }
+    case kMeOpNary: {
+      auto *naryMeExpr = static_cast<const NaryMeExpr*>(&meExpr);
+      for (MeExpr *opnd : naryMeExpr->GetOpnds()) {
+        if (CheckIfAnyLocalOpnd(*opnd)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+
+// create a new realOcc based on the meStmt and meExpr
+void SSAPre::CreateRealOcc(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool insertSorted, bool isLHS) {
+  uint32 hashIdx = PreWorkCandHashTable::ComputeWorkCandHashIndex(meExpr);
+  PreWorkCand *wkCand = preWorkCandHashTable.GetWorkcandFromIndex(hashIdx);
+  while (wkCand != nullptr) {
+    MeExpr *currMeExpr = wkCand->GetTheMeExpr();
+    ASSERT(currMeExpr != nullptr, "CreateRealOcc: found workcand with theMeExpr as nullptr");
+    if (currMeExpr->IsTheSameWorkcand(meExpr)) {
+      break;
+    }
+    wkCand = static_cast<PreWorkCand*>(wkCand->GetNext());
+  }
+  MeRealOcc *newOcc = ssaPreMemPool->New<MeRealOcc>(&meStmt, seqStmt, &meExpr);
+  newOcc->SetIsLHS(isLHS);
+  if (wkCand != nullptr) {
+    if (wkCand->deletedFromWorkList) {
+      return;  // processed earlier; skip doing it again
+    }
+    if (insertSorted) {
+      // insert to realOccs in dt_preorder of the BBs and seq in each BB
+      wkCand->AddRealOccSorted(*dom, *newOcc, GetPUIdx());
+    } else {
+      wkCand->AddRealOccAsLast(*newOcc, GetPUIdx());
+    }
+    if (strengthReduction && !wkCand->isSRCand && meExpr.StrengthReducible() &&
+        meStmt.GetBB()->GetAttributes(kBBAttrIsInLoop)) {
+      wkCand->isSRCand = true;
+    }
+    return;
+  }
+  // workcand not yet created; create a new one and add to worklist
+  wkCand = ssaPreMemPool->New<PreWorkCand>(ssaPreAllocator, &meExpr, GetPUIdx());
+  wkCand->SetHasLocalOpnd(CheckIfAnyLocalOpnd(meExpr));
+  if (EpreLocalRefVar() && wkCand->GetTheMeExpr()->GetMeOp() == kMeOpIvar) {
+    // set wkCand->NeedLocalRefVar() flag
+    auto *ivarMeExpr = static_cast<IvarMeExpr*>(wkCand->GetTheMeExpr());
+    MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr->GetTyIdx());
+    CHECK_FATAL(mirType->GetKind() == kTypePointer, "must be point type for ivar");
+    auto *ptrMIRType = static_cast<MIRPtrType*>(mirType);
+    FieldID fieldId = ivarMeExpr->GetFieldID();
+    TyIdxFieldAttrPair fldPair = ptrMIRType->GetPointedTyIdxFldAttrPairWithFieldID(fieldId);
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fldPair.first);
+    bool isFinal = fldPair.second.GetAttr(FLDATTR_final);
+    wkCand->SetNeedLocalRefVar(ty->GetPrimType() == PTY_ref && !isFinal);
+  } else if (strengthReduction && meExpr.StrengthReducible() && meStmt.GetBB()->GetAttributes(kBBAttrIsInLoop)) {
+    wkCand->isSRCand = true;
+  }
+  // determine onlyInvariantOpnds flag
+  wkCand->onlyInvariantOpnds = true;
+  for (uint8 i = 0; i < meExpr.GetNumOpnds(); i++) {
+    ScalarMeExpr *scalarOpnd = dynamic_cast<ScalarMeExpr *>(meExpr.GetOpnd(i));
+    if (scalarOpnd != nullptr && scalarOpnd->GetOst()->NumSSAVersions() > 1) {
+      wkCand->onlyInvariantOpnds = false;
+      break;
+    }
+  }
+  if (wkCand->onlyInvariantOpnds) {
+    workList.push_front(wkCand);
+  } else {
+    workList.push_back(wkCand);
+  }
+  wkCand->AddRealOccAsLast(*newOcc, GetPUIdx());
+  // add to bucket at workcandHashTable[hashIdx]
+  wkCand->SetNext(*preWorkCandHashTable.GetWorkcandFromIndex(hashIdx));
+  preWorkCandHashTable.SetWorkCandAt(hashIdx, *wkCand);
+  return;
+}
+
+void SSAPre::CreateMembarOcc(MeStmt &meStmt, int seqStmt) {
+  if (preKind == kLoadPre || preKind == kAddrPre) {
+    return;
+  }
+  // go thru all workcands and insert a membar occurrence for each of them
+  uint32 cnt = 0;
+  for (PreWorkCand *wkCand : std::as_const(workList)) {
+    ++cnt;
+    if (cnt > preLimit) {
+      break;
+    }
+    if (preKind == kExprPre) {
+      if (wkCand->GetTheMeExpr()->GetMeOp() != kMeOpIvar) {
+        continue;
+      }
+    } else if (preKind == kStmtPre) {
+      if (static_cast<PreStmtWorkCand*>(wkCand)->GetTheMeStmt()->GetOp() != OP_dassign) {
+        continue;
+      }
+    }
+    MeRealOcc *newOcc = ssaPreMemPool->New<MeRealOcc>(&meStmt, seqStmt, wkCand->GetTheMeExpr());
+    newOcc->SetOccType(kOccMembar);
+    wkCand->AddRealOccAsLast(*newOcc, GetPUIdx());
+  }
+}
+
+void SSAPre::CreateMembarOccAtCatch(BB &bb) {
+  // go thru all workcands and insert a membar occurrence for each of them
+  uint32 cnt = 0;
+  for (PreWorkCand *wkCand : std::as_const(workList)) {
+    ++cnt;
+    if (cnt > preLimit) {
+      break;
+    }
+    MeRealOcc *newOcc = ssaPreMemPool->New<MeRealOcc>(nullptr, 0, wkCand->GetTheMeExpr());
+    newOcc->SetOccType(kOccMembar);
+    newOcc->SetBB(bb);
+    wkCand->AddRealOccAsLast(*newOcc, GetPUIdx());
+  }
+}
+
+void SSAPre::BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeExpr *tempVar) {
+  IncTreeid();
+  MeStmt *meStmt = &stmt;
+  Opcode op = meStmt->GetOp();
+  switch (op) {
+    case OP_jstry:
+    case OP_jscatch:
+    case OP_finally:
+    case OP_endtry:
+    case OP_cleanuptry:
+    case OP_try:
+    case OP_catch:
+    case OP_goto:
+    case OP_comment:
+      break;
+    case OP_membaracquire:
+    case OP_membarrelease:
+    case OP_membarstoreload:
+    case OP_membarstorestore:
+      CreateMembarOcc(*meStmt, seqStmt);
+      break;
+    case OP_gosub:
+    case OP_retsub:
+      break;
+    case OP_throw: {
+      auto *thrMeStmt = static_cast<ThrowMeStmt*>(meStmt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *thrMeStmt->GetOpnd(), isRebuilt,
+                        tempVar, true, isRebuilt);
+      break;
+    }
+    case OP_iassign:
+    case OP_iassignoff: {
+      auto *ivarStmt = static_cast<IassignMeStmt*>(meStmt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *ivarStmt->GetRHS(), isRebuilt,
+                        tempVar, true, isRebuilt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt),
+                        *ivarStmt->GetLHSVal()->GetBase(), isRebuilt, tempVar, true, isRebuilt);
+      BuildWorkListIvarLHSOcc(*meStmt, static_cast<int32>(seqStmt), isRebuilt, tempVar);
+      break;
+    }
+    case OP_brtrue:
+    case OP_brfalse: {
+      auto *condGotoStmt = static_cast<CondGotoMeStmt*>(meStmt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *condGotoStmt->GetOpnd(), isRebuilt,
+                        tempVar, true, isRebuilt);
+      break;
+    }
+    case OP_switch: {
+      auto *switchStmt = static_cast<SwitchMeStmt*>(meStmt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *switchStmt->GetOpnd(), isRebuilt,
+                        tempVar, true, isRebuilt);
+      break;
+    }
+    case OP_dassign: {
+      auto *dassMeStmt = static_cast<DassignMeStmt*>(meStmt);
+      if (dassMeStmt->isIncDecStmt && preKind == kExprPre) {
+        break;
+      }
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *dassMeStmt->GetRHS(), isRebuilt,
+                        tempVar, true, isRebuilt);
+      BuildWorkListLHSOcc(*meStmt, static_cast<int32>(seqStmt));
+      break;
+    }
+    case OP_regassign: {
+      auto *rassMeStmt = static_cast<AssignMeStmt*>(meStmt);
+      if (rassMeStmt->isIncDecStmt && preKind == kExprPre) {
+        break;
+      }
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *rassMeStmt->GetRHS(), isRebuilt,
+                        tempVar, true, isRebuilt);
+      break;
+    }
+    case OP_maydassign: {
+      auto *dassMeStmt = static_cast<MaydassignMeStmt*>(meStmt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *dassMeStmt->GetRHS(), isRebuilt,
+                        tempVar, true, isRebuilt);
+      BuildWorkListLHSOcc(*meStmt, static_cast<int32>(seqStmt));
+      break;
+    }
+    case OP_decref: {
+      auto *unaryStmt = static_cast<UnaryMeStmt*>(meStmt);
+      if (!GetRcLoweringOn() && unaryStmt->GetOpnd()->IsLeaf() && unaryStmt->GetOpnd()->GetPrimType() == PTY_ref) {
+        // affects LPRE only; will cause CI failure if this is allowed
+        break;
+      }
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *unaryStmt->GetOpnd(), isRebuilt,
+                        tempVar, true, isRebuilt);
+      break;
+    }
+    case OP_incref:
+    case OP_decrefreset:
+    case OP_eval:
+    case OP_igoto:
+    CASE_OP_ASSERT_NONNULL
+    case OP_free: {
+      auto *unaryStmt = static_cast<UnaryMeStmt*>(meStmt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *unaryStmt->GetOpnd(), isRebuilt,
+                        tempVar, true, isRebuilt);
+      break;
+    }
+    case OP_syncenter:
+    case OP_syncexit: {
+      auto *syncMeStmt = static_cast<SyncMeStmt*>(meStmt);
+      const MapleVector<MeExpr*> &opnds = syncMeStmt->GetOpnds();
+      for (auto it = opnds.begin(); it != opnds.end(); ++it) {
+        BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), **it, isRebuilt, tempVar, true, isRebuilt);
+      }
+      break;
+    }
+    case OP_return: {
+      auto *retMeStmt = static_cast<RetMeStmt*>(meStmt);
+      const MapleVector<MeExpr*> &opnds = retMeStmt->GetOpnds();
+      for (auto it = opnds.begin(); it != opnds.end(); ++it) {
+        if ((*it)->IsLeaf() && (*it)->GetPrimType() == PTY_ref) {
+          // affects LPRE only; will cause CI failure if this is allowed
+          if (!GetRcLoweringOn()) {
+            continue;
+          }
+          if (!GetRegReadAtReturn()) {
+            if ((*it)->GetMeOp() == kMeOpVar) {
+              auto *varMeExpr = static_cast<VarMeExpr*>(*it);
+              const OriginalSt *ost = varMeExpr->GetOst();
+              if (!ost->IsFormal()) {
+                continue;
+              }
+            }
+          }
+        }
+        BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), **it, isRebuilt, tempVar, true, isRebuilt);
+      }
+      break;
+    }
+    case OP_call:
+    case OP_virtualcall:
+    case OP_virtualicall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_interfaceicall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_icall:
+    case OP_icallproto:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_icallassigned:
+    case OP_icallprotoassigned:
+    case OP_asm: {
+      auto *naryMeStmt = static_cast<NaryMeStmt*>(meStmt);
+      const MapleVector<MeExpr*> &opnds = naryMeStmt->GetOpnds();
+      for (auto it = opnds.begin(); it != opnds.end(); ++it) {
+        BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), **it, isRebuilt, tempVar, true, isRebuilt);
+      }
+      break;
+    }
+    case OP_intrinsiccall: {
+      auto *intrn = static_cast<IntrinsiccallMeStmt*>(meStmt);
+      if (intrn->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS ||
+          intrn->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP ||
+          intrn->GetIntrinsic() == INTRN_MPL_CLEANUP_NORETESCOBJS ||
+          intrn->GetIntrinsic() == INTRN_MCCSetObjectPermanent) {
+        break;
+      }
+    // fall thru
+    }
+    [[clang::fallthrough]];
+    case OP_xintrinsiccall:
+    case OP_intrinsiccallwithtype:
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned:
+    case OP_intrinsiccallwithtypeassigned: {
+      auto *naryMeStmt = static_cast<NaryMeStmt*>(meStmt);
+      const MapleVector<MeExpr*> &opnds = naryMeStmt->GetOpnds();
+      for (auto it = opnds.begin(); it != opnds.end(); ++it) {
+        if (!GetRcLoweringOn() && (*it)->IsLeaf() && (*it)->GetMeOp() == kMeOpVar) {
+          // affects LPRE only; some later phase needs to transform dread to addrof
+          auto *varMeExpr = static_cast<VarMeExpr*>(*it);
+          const MIRSymbol *sym = varMeExpr->GetOst()->GetMIRSymbol();
+          if (sym->GetAttr(ATTR_static)) {
+            // its address may be taken
+            continue;
+          }
+        }
+        BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), **it, isRebuilt, tempVar, true, isRebuilt);
+      }
+      break;
+    }
+    CASE_OP_ASSERT_BOUNDARY {
+      auto *assMeStmt = static_cast<NaryMeStmt*>(meStmt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *assMeStmt->GetOpnd(0), isRebuilt,
+                        tempVar, true, isRebuilt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *assMeStmt->GetOpnd(1), isRebuilt,
+                        tempVar, true, isRebuilt);
+      break;
+    }
+    default:
+      CHECK_FATAL(op == OP_comment, "invalid value of opcode");
+      break;
+  }
+  if (kOpcodeInfo.IsCallAssigned(op)) {
+    BuildWorkListLHSOcc(*meStmt, static_cast<int32>(seqStmt));
+  }
+}
+
+void SSAPre::BuildWorkListBB(BB *bb) {
+  ASSERT_NOT_NULL(bb);
+  if (GetSpillAtCatch() && bb->GetAttributes(kBBAttrIsCatch)) {
+    CreateMembarOccAtCatch(*bb);
+  }
+  uint32 seqStmt = 0;
+  for (auto &stmt : bb->GetMeStmts()) {
+    BuildWorkListStmt(stmt, ++seqStmt, false);
+  }
+  if (bb->GetAttributes(kBBAttrIsExit) || bb->GetAttributes(kBBAttrWontExit)) {
+    CreateExitOcc(*bb);
+  }
+}
+
+void SSAPre::DumpWorkListWrap() const {
+  if (GetSSAPreDebug()) {
+    DumpWorkList();
+  }
+}
+
+void SSAPre::DumpWorkList() const {
+  mirModule->GetOut() << "======== in SSAPRE worklist==============\n";
+  for (PreWorkCand *workListCand : workList) {
+    workListCand->Dump(*irMap);
+  }
+}
+
+GStrIdx SSAPre::NewTempStrIdx() {
+  std::string preStr("ssapre_tempvar");
+  (void)preStr.append(std::to_string(strIdxCount++));
+  return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(preStr);
+}
+
+void SSAPre::ApplySSAPRE() {
+  // #0 build worklist
+  BuildWorkList();
+  if (GetSSAPreDebug()) {
+    mirModule->GetOut() << " worklist initial size " << workList.size() << '\n';
+  }
+  ConstructUseOccurMap();
+  uint32 cnt = 0;
+  if (MeOption::optForSize && !workList.empty()) {
+    // prepare expr hoist
+    ExprHoistPrepare();
+  }
+  while (!workList.empty()) {
+    ++cnt;
+    if (cnt > preLimit) {
+      break;
+    }
+    workCand = workList.front();
+    workCand->SetIndex(static_cast<int32>(cnt));
+    workList.pop_front();
+    if (workCand->GetRealOccs().empty()) {
+      workCand->deletedFromWorkList = true;
+      continue;
+    }
+    if ((preKind == kExprPre && workCand->GetTheMeExpr()->GetMeOp() == kMeOpIvar) || (preKind == kLoadPre)) {
+      // if only LHS real occur, skip this candidate
+      bool hasNonLHS = false;
+      for (MeRealOcc *realOcc : workCand->GetRealOccs()) {
+        if (realOcc->GetOccType() == kOccReal && !realOcc->IsLHS()) {
+          hasNonLHS = true;
+          break;
+        }
+      }
+      if (!hasNonLHS) {
+        workCand->deletedFromWorkList = true;
+        continue;
+      }
+    }
+    if (GetSSAPreDebug()) {
+      mirModule->GetOut() << "||||||| SSAPRE candidate " << cnt << " at worklist index "
+                          << workCand->GetIndex() << ": ";
+      workCand->DumpCand(*irMap);
+      if (workCand->isSRCand) {
+        mirModule->GetOut() << " srCand";
+      }
+      if (workCand->onlyInvariantOpnds) {
+        mirModule->GetOut() << " onlyInvairantOpnds";
+      }
+      mirModule->GetOut() << '\n';
+    }
+    allOccs.clear();
+    phiOccs.clear();
+    // #1 Insert PHI; results in allOccs and phiOccs
+    ComputeVarAndDfPhis();
+    CreateSortedOccs();
+    if (workCand->GetRealOccs().empty()) {
+      workCand->deletedFromWorkList = true;
+      continue;
+    }
+    // set the position field in the MeRealOcc nodes
+    for (size_t j = 0; j < workCand->GetRealOccs().size(); j++) {
+      workCand->GetRealOcc(j)->SetPosition(j);
+    }
+    // #2 Rename
+    Rename1();
+    Rename2();
+    if (!phiOccs.empty()) {
+      // if no PHI inserted, no need to compute DSafety, WBAvail
+      // #3 DownSafty
+      ComputeDS();
+      // #4 WillBeAvail
+      ComputeCanBeAvail();
+      ComputeLater();
+    }
+    if (MeOption::optForSize) {
+      // do epxr hoist
+      HoistExpr();
+    }
+    // #5 Finalize
+    Finalize1();
+    if (workCand->Redo2HandleCritEdges()) {
+      // reinitialize def field to nullptr
+      for (MeOccur *occ : allOccs) {
+        occ->SetDef(nullptr);
+        if (occ->GetOccType() == kOccPhiopnd) {
+          auto *phiOpndOcc = static_cast<MePhiOpndOcc*>(occ);
+          phiOpndOcc->SetIsProcessed(false);
+        }
+      }
+      Rename1();
+      Rename2();
+      ComputeDS();
+      ComputeCanBeAvail();
+      ComputeLater();
+      Finalize1();
+    }
+    Finalize2();
+    workCand->deletedFromWorkList = true;
+    // #6 CodeMotion and recompute worklist based on newly occurrence
+    CodeMotion();
+    if (preKind == kStmtPre && (workCand->GetRealOccs().front()->GetOpcodeOfMeStmt() == OP_dassign ||
+        workCand->GetRealOccs().front()->GetOpcodeOfMeStmt() == OP_callassigned)) {
+      // apply full redundancy elimination
+      DoSSAFRE();
+    }
+    perCandMemPool->ReleaseContainingMem();
+  }
+  if (MeOption::optForSize) {
+    HoistClean();
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/ssa_pre_for_hoist.cpp b/src/mapleall/maple_me/src/ssa_pre_for_hoist.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3a0266558ec75da2a13f4e133f47b86120d7e560
--- /dev/null
+++ b/src/mapleall/maple_me/src/ssa_pre_for_hoist.cpp
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "ssa_epre.h"
+#include "me_cfg.h"
+
+namespace maple {
+const static Dominance *fDom = nullptr;
+const static Dominance *fPdom = nullptr;
+static MeCFG *fCfg = nullptr;
+class ExprHoist;
+
+class HoistSummary {
+ public:
+  friend class ExprHoist;
+  HoistSummary() = default;
+  void Init(BB *curBB, MapleVector<HoistSummary> &summaries);
+  void InitCand(int32 newCandId);
+  bool AvailableAtCD(MeExpr *expr);
+  bool DefoccAllowHoist(MeOccur *defocc) const;
+  bool SuccProcessed(uint32 whichSucc) const {
+    return (succCount & (static_cast<uint32>(1) << whichSucc)) == 0;
+  }
+
+  void SetProcessed(uint32 whichSucc) {
+    succCount &= ~(static_cast<uint32>(1) << whichSucc);
+  }
+
+  bool FullyAnticipated() const {
+    return succCount == 0;
+  }
+
+ private:
+  BB *bb = nullptr;
+  uint32 succMask = 0;
+  uint32 succCount = 0;
+  MeOccur *occ = nullptr;
+  MeOccur *hoistedOcc = nullptr;
+  HoistSummary *next = nullptr;
+  HoistSummary *cdHS = nullptr;
+  uint32 whichCDSucc = -1;
+  int32 candId = -1;
+};
+
+void HoistSummary::Init(BB *curBB, MapleVector<HoistSummary> &summaries) {
+  bb = curBB;
+  succMask = (static_cast<uint32>(1) << bb->GetSucc().size()) - 1;
+  if (fPdom->GetDomFrontier(bb->GetID()).size() != 1) {
+    return;
+  }
+  // init cd info
+  auto *cdBB = fCfg->GetBBFromID(BBId(*fPdom->GetDomFrontier(bb->GetID()).begin()));
+  if (!fDom->Dominate(*cdBB, *bb)) {
+    return;
+  }
+  if (cdBB->GetSucc().size() >= sizeof(succMask) * 4) {  // if the cdBB has more than 32 succs, skip hoist
+    return;
+  }
+  for (uint32 i = 0; i < cdBB->GetSucc().size(); ++i) {
+    if (fPdom->Dominate(*bb, *cdBB->GetSucc(i))) {
+      whichCDSucc = i;
+      break;
+    }
+  }
+  ASSERT(whichCDSucc != -1, "Init: wrong cfg/dom info.");
+  cdHS = &summaries[cdBB->GetBBId().GetIdx()];
+}
+
+void HoistSummary::InitCand(int32 newCandId) {
+  candId = newCandId;
+  succCount = succMask;
+  occ = nullptr;
+  hoistedOcc = nullptr;
+  next = nullptr;
+}
+
+bool HoistSummary::AvailableAtCD(MeExpr *expr) {
+  if (expr == nullptr) {
+    return false;
+  }
+  switch (expr->GetMeOp()) {
+    case kMeOpConst:
+    case kMeOpConststr:
+    case kMeOpConststr16:
+    case kMeOpAddrof:
+    case kMeOpAddroffunc:
+      return true;
+    case kMeOpReg:
+    case kMeOpVar: {
+      auto *defBB = static_cast<ScalarMeExpr*>(expr)->DefByBB();
+      if (defBB) {
+        return fDom->Dominate(*defBB, *cdHS->bb);
+      }
+      return true;
+    }
+    case kMeOpIvar: {
+      auto *base = static_cast<IvarMeExpr*>(expr)->GetBase();
+      if (!AvailableAtCD(base)) {
+        return false;
+      }
+      auto &mu = static_cast<IvarMeExpr*>(expr)->GetMuList();
+      for (auto *muVal : mu) {
+        if (!AvailableAtCD(muVal)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case kMeOpOp: {
+      for (size_t i = 0; i < static_cast<OpMeExpr*>(expr)->GetNumOpnds(); i++) {
+        auto *opnd = static_cast<OpMeExpr*>(expr)->GetOpnd(i);
+        if (!AvailableAtCD(opnd)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case kMeOpNary: {
+      for (auto *opnd : static_cast<NaryMeExpr*>(expr)->GetOpnds()) {
+        if (!AvailableAtCD(opnd)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+bool HoistSummary::DefoccAllowHoist(MeOccur *defocc) const {
+  if (defocc == nullptr) {
+    return true;
+  }
+  if (defocc->GetOccType() != kOccPhiocc) {
+    return true;
+  }
+  return fDom->Dominate(*defocc->GetBB(), *cdHS->bb);
+}
+
+class ExprHoist {
+ public:
+  ExprHoist(SSAPre *p, MapleAllocator &alloc, bool debug)
+      : parent(p), dumpDetail(debug), summaries(fCfg->GetAllBBs().size(), HoistSummary(), alloc.Adapter()) {
+    Init();
+  }
+
+  void Init() {
+    for (auto *bb : fCfg->GetAllBBs()) {
+      if (bb == nullptr) {
+        continue;
+      }
+      auto *hs = &summaries[bb->GetBBId()];
+      hs->Init(bb, summaries);
+    }
+    if (dumpDetail) {
+      LogInfo::MapleLogger() << "\n\\\\\\\\HOIST PREPARE\\\\\\\\\n";
+      for (auto &hs : summaries) {
+        if (hs.cdHS != nullptr) {
+          LogInfo::MapleLogger() << "HOSTING: BB" << hs.bb->GetBBId() << " has control dependence at BB"
+                                 << hs.cdHS->bb->GetBBId() << "'s succ " << hs.whichCDSucc << "\n";
+        }
+      }
+    }
+  }
+
+  void UpdateSuccCount(HoistSummary *hs, uint32 whichSucc, MeExpr *expr, MeOccur *occ);
+  void AddToHoistWorklist(HoistSummary *hs);
+  MeOccur *GetHoistedOcc(HoistSummary *hs, MeExpr *expr, MeOccur *defOcc);
+  void HoistExpr(const MapleVector<MeOccur*> &allOccs, int32 candId);
+  int32 GetHoistedCount() const {
+    return hoistedCount;
+  }
+
+ private:
+  SSAPre *parent = nullptr;
+  bool dumpDetail = false;
+  MapleVector<HoistSummary> summaries;
+  int32 curCandId = -1;
+  const MapleVector<MeOccur*> *occs = nullptr;
+  HoistSummary *begin = nullptr;  // used to record hs worklist
+  HoistSummary *end = nullptr;    // used to record hs worklist
+  int32 hoistedCount = 0;
+};
+
+void ExprHoist::AddToHoistWorklist(HoistSummary *hs) {
+  hs->next = nullptr;
+  if (begin == nullptr) {
+    begin = hs;
+    end = hs;
+  } else {
+    end->next = hs;
+    end = hs;
+  }
+}
+
+void ExprHoist::UpdateSuccCount(HoistSummary *hs, uint32 whichSucc, MeExpr *expr, MeOccur *occ) {
+  if (hs->candId != curCandId) {  // clean the old record
+    hs->InitCand(curCandId);
+  }
+  ASSERT(whichSucc < hs->bb->GetSucc().size(), "UpdateSuccCount: check succ.");
+  if (!hs->occ && occ) {
+    hs->occ = occ;
+  }
+  if (hs->SuccProcessed(whichSucc)) {
+    return;
+  }
+  hs->SetProcessed(whichSucc);
+  if (hs->FullyAnticipated() && hs->cdHS &&
+      (occ || hs->cdHS->occ) &&
+      hs->AvailableAtCD(expr) &&
+      hs->DefoccAllowHoist(occ)) {
+    // continue to update this HS 's cd
+    UpdateSuccCount(hs->cdHS, hs->whichCDSucc, expr, occ);
+  }
+}
+
+static MeExpr *GetRealExpr(MeOccur &occ) {
+  switch (occ.GetOccType()) {
+    case kOccReal:
+      return static_cast<MeRealOcc&>(occ).GetMeExpr();
+    case kOccPhiopnd:
+      return static_cast<MePhiOpndOcc&>(occ).GetCurrentMeExpr();
+    default:
+      CHECK_FATAL(false, "error or NYI");
+  }
+}
+
+MeOccur *ExprHoist::GetHoistedOcc(HoistSummary *hs, MeExpr *expr, MeOccur *defOcc) {
+  ASSERT(hs->FullyAnticipated(), "GetHoistedOcc: cd is not fully anticipated.");
+  ASSERT(hs->candId == curCandId, "GetHoistedOcc: wrong cand.");
+  if (hs->candId == curCandId && hs->hoistedOcc) {
+    return hs->hoistedOcc;
+  }
+  MeOccur *hoistedOcc = nullptr;
+  // loop up the cd chain
+  if (hs->cdHS &&
+      hs->cdHS->candId == curCandId &&
+      (hs->cdHS->occ == nullptr || (GetRealExpr(*hs->cdHS->occ) == expr)) &&
+      hs->cdHS->FullyAnticipated() &&
+      hs->DefoccAllowHoist(defOcc)) {
+    hoistedOcc = GetHoistedOcc(hs->cdHS, expr, defOcc);
+  } else {  // already at cd chain's root
+    if (defOcc &&
+        fDom->Dominate(*defOcc->GetBB(), *hs->bb) &&
+        (defOcc->GetOccType() == kOccReal ||
+         (defOcc->GetOccType() == kOccPhiocc &&
+          static_cast<MePhiOcc*>(defOcc)->IsWillBeAvail()))) {  // use defOcc
+      hoistedOcc = defOcc;
+    } else {  // insert a new one
+      ASSERT(expr->GetExprID() != kInvalidExprID, "GetHoistedOcc: check expr hashed.");
+      auto *fakeStmt = parent->irMap->CreateAssignMeStmt(*parent->irMap->CreateRegMeExpr(expr->GetPrimType()),
+                                                         *expr, *hs->bb);
+      hs->bb->InsertMeStmtLastBr(fakeStmt);
+      auto seqStmt = 0;
+      for (auto &stmt : hs->bb->GetMeStmts()) {
+        ++seqStmt;
+        if (&stmt == fakeStmt) {
+          break;
+        }
+      }
+      parent->CreateRealOcc(*fakeStmt, seqStmt, *expr, true);
+      MeRealOcc *newRealocc = nullptr;
+      // reset realocc's pos
+      for (size_t j = 0; j < parent->workCand->GetRealOccs().size(); j++) {
+        auto *realocc = parent->workCand->GetRealOcc(j);
+        if (realocc->GetMeStmt() == fakeStmt) {
+          newRealocc = realocc;
+        }
+        realocc->SetPosition(j);
+      }
+      CHECK_NULL_FATAL(newRealocc);
+      // keep dt_preorder
+      for (auto iter = parent->allOccs.begin(); iter != parent->allOccs.end(); ++iter) {
+        auto *occ = *iter;
+        if (fDom->GetDtDfnItem(occ->GetBB()->GetBBId()) <
+            fDom->GetDtDfnItem(newRealocc->GetBB()->GetBBId())) {
+          continue;
+        }
+        if (fDom->Dominate(*occ->GetBB(), *newRealocc->GetBB())) {
+          continue;
+        }
+        if (!fDom->Dominate(*newRealocc->GetBB(), *occ->GetBB())) {
+          continue;
+        }
+        parent->allOccs.insert(iter, newRealocc);
+        break;
+      }
+      newRealocc->SetIsHoisted(true);
+      if (defOcc &&
+          fDom->Dominate(*defOcc->GetBB(), *hs->bb) &&
+          defOcc->GetOccType() == kOccPhiocc) {
+        newRealocc->SetClassID(defOcc->GetClassID());
+        newRealocc->SetDef(defOcc);
+      } else {
+        newRealocc->SetClassID(static_cast<int32>(parent->classCount++));
+        newRealocc->SetDef(nullptr);
+      }
+      hoistedOcc = newRealocc;
+    }
+  }
+  hs->hoistedOcc = hoistedOcc;
+  return hoistedOcc;
+}
+
+void ExprHoist::HoistExpr(const MapleVector<MeOccur*> &allOccs, int32 candId) {
+  occs = &allOccs;
+  curCandId = candId;
+  begin = nullptr;
+  end = nullptr;
+  hoistedCount = 0;
+  // process realocc first because we need processed info when process phiopndocc
+  for (auto *occ : *occs) {
+    if (occ->GetOccType() == kOccReal) {
+      auto *hs = &summaries[occ->GetBB()->GetBBId()];
+      if (hs->candId != curCandId) {  // clean the old record
+        hs->InitCand(curCandId);
+      }
+      auto *realocc = static_cast<MeRealOcc*>(occ);
+      if (!realocc->IsLHS() &&  // do not hoist lhs
+          hs->cdHS &&  // need a cd to hoist
+          hs->occ == nullptr &&  // if not null, hs has been inserted
+          hs->AvailableAtCD(realocc->GetMeExpr()) &&  // should be available at cd
+          hs->DefoccAllowHoist(realocc->GetDef())) {
+        hs->occ = realocc;
+        AddToHoistWorklist(hs);
+        UpdateSuccCount(hs->cdHS, hs->whichCDSucc, realocc->GetMeExpr(), realocc);
+      }
+    }
+  }
+  // process phiond occ
+  for (auto *occ : *occs) {
+    if (occ->GetOccType() == kOccPhiopnd) {
+      auto *hs = &summaries[occ->GetBB()->GetBBId()];
+      if (hs->candId != curCandId) {  // clean the old record
+        hs->InitCand(curCandId);
+      }
+      auto *phiOpndocc = static_cast<MePhiOpndOcc*>(occ);
+      auto *phiOcc = phiOpndocc->GetDefPhiOcc();
+      if (phiOcc->IsWillBeAvail() && phiOpndocc->IsOkToInsert()) {
+        if (hs->cdHS &&  // need a cd to hoist
+            hs->occ == nullptr &&  // if not null, hs has been inserted
+            hs->cdHS->occ != nullptr &&  // make sure there's at least one realocc at cd
+            hs->AvailableAtCD(phiOpndocc->GetCurrentMeExpr()) &&
+            hs->DefoccAllowHoist(phiOpndocc->GetDef())) {
+          hs->occ = phiOpndocc;
+          AddToHoistWorklist(hs);
+          UpdateSuccCount(hs->cdHS, hs->whichCDSucc, phiOpndocc->GetCurrentMeExpr(), nullptr);
+        }
+      }
+    }
+  }
+
+  HoistSummary *hs = nullptr;  // used to iterate over the worklist
+  // also process realocc first
+  for (hs = begin; hs; hs = hs->next) {
+    ASSERT(hs->candId == curCandId, "HoistExpr: can not have old record.");
+    if (hs->occ->GetOccType() != kOccReal) {
+      continue;
+    }
+    if (hs->cdHS == nullptr || hs->cdHS->candId != curCandId || !hs->cdHS->FullyAnticipated()) {
+      continue;
+    }
+    auto *realocc = static_cast<MeRealOcc*>(hs->occ);
+    if (hs->cdHS->hoistedOcc) {
+      if (hs->cdHS->hoistedOcc->GetOccType() == kOccReal &&
+          GetRealExpr(*hs->cdHS->hoistedOcc) != realocc->GetMeExpr()) {
+        continue;
+      }
+    }
+    auto *hoistedOcc = GetHoistedOcc(hs->cdHS, realocc->GetMeExpr(), realocc->GetDef());
+    auto *hoistedOccDef = (hoistedOcc->GetOccType() == kOccReal && hoistedOcc->GetDef()) ? hoistedOcc->GetDef()
+                                                                                         : hoistedOcc;
+    if (hoistedOccDef->GetClassID() != realocc->GetClassID()) {
+      auto iter = occs->begin();
+      while (*iter != realocc) {
+        ++iter;
+      }
+      auto *occ = *iter;
+      auto classId = realocc->GetClassID();
+      auto *bb = realocc->GetBB();
+      do {
+        occ->SetClassID(hoistedOccDef->GetClassID());
+        occ->SetDef(hoistedOccDef);
+        occ = *(++iter);
+        ++hoistedCount;
+      } while (occ && occ->GetBB() == bb && occ->GetClassID() == classId);
+    }
+  }
+
+  // process phiopnd occ
+  for (hs = begin; hs; hs = hs->next) {
+    ASSERT(hs->candId == curCandId, "HoistExpr: can not have old record.");
+    if (hs->occ->GetOccType() != kOccPhiopnd) {
+      continue;
+    }
+    if (hs->cdHS == nullptr || hs->cdHS->candId != curCandId || !hs->cdHS->FullyAnticipated()) {
+      continue;
+    }
+    auto *phiopndocc = static_cast<MePhiOpndOcc*>(hs->occ);
+    if (hs->cdHS->hoistedOcc) {
+      if (hs->cdHS->hoistedOcc->GetOccType() == kOccReal &&
+          GetRealExpr(*hs->cdHS->hoistedOcc) != phiopndocc->GetCurrentMeExpr()) {
+        continue;
+      }
+    }
+    auto *hoistedOcc = GetHoistedOcc(hs->cdHS, phiopndocc->GetCurrentMeExpr(), nullptr);
+    auto *hoistedOccDef = (hoistedOcc->GetOccType() == kOccReal && hoistedOcc->GetDef()) ? hoistedOcc->GetDef()
+                                                                                         : hoistedOcc;
+    phiopndocc->SetDef(hoistedOccDef);
+    phiopndocc->SetHasRealUse(true);
+    phiopndocc->SetClassID(hoistedOccDef->GetClassID());
+    ++hoistedCount;
+  }
+
+  // fix overlapped live range beacuse we skip some cases such as multi-cds
+  for (auto *occ : *occs) {
+    if (occ->GetOccType() != kOccReal && occ->GetOccType() != kOccPhiopnd) {
+      continue;
+    }
+    if (occ->GetOccType() == kOccReal && !static_cast<MeRealOcc*>(occ)->IsLHS()) {
+      continue;
+    }
+    if (occ->GetDef() &&
+        occ->GetDef()->GetClassID() != occ->GetClassID()) {
+      occ->SetClassID(occ->GetDef()->GetClassID());
+    }
+  }
+}
+
+void SSAPre::HoistExpr() {
+  if (preKind == kStmtPre || strengthReduction) {
+    // need add injuring occ processing
+    return;
+  }
+  eh->HoistExpr(allOccs, workCand->GetIndex());
+  if (GetSSAPreDebug()) {
+    LogInfo::MapleLogger() << "========ssapre candidate " << workCand->GetIndex()
+                           << " after Hoist===================\n";
+    if (eh->GetHoistedCount() > 0) {
+      for (MeOccur *occ : allOccs) {
+        occ->Dump(*irMap);
+        if (occ->GetOccType() == kOccReal && static_cast<MeRealOcc*>(occ)->IsHoisted()) {
+          LogInfo::MapleLogger() << " >>> hoist insert <<<";
+        }
+        LogInfo::MapleLogger() << '\n';
+      }
+    }
+  }
+}
+
+void SSAPre::ExprHoistPrepare() {
+  fCfg = mirModule->CurFunction()->GetMeFunc()->GetCfg();
+  fDom = dom;
+  fPdom = pdom;
+  if (preKind == kStmtPre || strengthReduction) {
+    // need add injuring occ processing
+    return;
+  }
+  eh = ssaPreMemPool->New<ExprHoist>(this, ssaPreAllocator, GetSSAPreDebug());
+}
+
+void SSAPre::HoistClean() {
+  fCfg = nullptr;
+  fDom = nullptr;
+  fPdom = nullptr;
+}
+}
diff --git a/src/mapleall/maple_me/src/ssa_tab.cpp b/src/mapleall/maple_me/src/ssa_tab.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cd143c4513310bce5e559ffdcc2364fcca4eb9dc
--- /dev/null
+++ b/src/mapleall/maple_me/src/ssa_tab.cpp
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ssa_tab.h"
+#include "ssa_mir_nodes.h"
+#include "opcode_info.h"
+#include "mir_function.h"
+#include "mir_lower.h"
+#include "me_option.h"
+#include "me_function.h"
+
+// Allocate data structures to store SSA information. Only statement nodes and
+// tree nodes that incur defs and uses are relevant. Tree nodes are made larger
+// by allocating the larger SSANodes.  Statement nodes' SSA information is
+// stored in class SSATab's StmtsSSAPart, which has an array of pointers indexed
+// by the stmtID field of each statement node.
+namespace maple {
+// iteratively collect next level of vst
+void SSATab::CollectIterNextLevel(size_t vstIdx, OstPtrSet &resultOsts) {
+  auto *nextLevelOsts = GetNextLevelOsts(vstIdx);
+  if (nextLevelOsts == nullptr) {
+    return;
+  }
+  resultOsts.insert(nextLevelOsts->cbegin(), nextLevelOsts->cend());
+  for (OriginalSt *nextLevelOst : *nextLevelOsts) {
+    for (auto allVstOfOst : nextLevelOst->GetVersionsIndices()) {
+      CollectIterNextLevel(allVstOfOst, resultOsts);
+    }
+  }
+}
+
+BaseNode *SSATab::CreateSSAExpr(BaseNode *expr) {
+  bool arrayLowered = false;
+  while (expr->GetOpCode() == OP_array && !mirModule.IsJavaModule() && !func->IsPme()) {
+    MIRLower mirLower(mirModule, mirModule.CurFunction());
+    expr = mirLower.LowerCArray(static_cast<ArrayNode*>(expr));
+    arrayLowered = true;
+  }
+  if (expr->GetOpCode() == OP_addrof || expr->GetOpCode() == OP_dread) {
+    if (expr->IsSSANode()) {
+      return mirModule.CurFunction()->GetCodeMemPool()->New<AddrofSSANode>(*static_cast<AddrofSSANode*>(expr));
+    }
+    AddrofNode *addrofNode = static_cast<AddrofNode*>(expr);
+    AddrofSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New<AddrofSSANode>(*addrofNode);
+    MIRSymbol *st = mirModule.CurFunction()->GetLocalOrGlobalSymbol(ssaNode->GetStIdx());
+    OriginalSt *ost = FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), ssaNode->GetFieldID());
+    if (expr->GetOpCode() == OP_addrof) {
+      ost->SetAddressTaken(true);
+    }
+    versionStTable.CreateZeroVersionSt(ost);
+    ssaNode->SetSSAVar(*versionStTable.GetZeroVersionSt(ost));
+    return ssaNode;
+  } else if (expr->GetOpCode() == OP_regread) {
+    if (expr->IsSSANode()) {
+      return mirModule.CurFunction()->GetCodeMemPool()->New<RegreadSSANode>(*static_cast<RegreadSSANode*>(expr));
+    }
+    RegreadNode *regReadNode = static_cast<RegreadNode*>(expr);
+    RegreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New<RegreadSSANode>(*regReadNode);
+    OriginalSt *ost =
+        originalStTable.FindOrCreatePregOriginalSt(ssaNode->GetRegIdx(), mirModule.CurFunction()->GetPuidx());
+    versionStTable.CreateZeroVersionSt(ost);
+    ssaNode->SetSSAVar(*versionStTable.GetZeroVersionSt(ost));
+    return ssaNode;
+  } else if (expr->GetOpCode() == OP_iread) {
+    if (expr->IsSSANode()) {
+      return mirModule.CurFunction()->GetCodeMemPool()->New<IreadSSANode>(*static_cast<IreadSSANode*>(expr));
+    }
+    IreadNode *ireadNode = static_cast<IreadNode*>(expr);
+    IreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMempool()->New<IreadSSANode>(*ireadNode);
+    BaseNode *newOpnd = CreateSSAExpr(ireadNode->Opnd(0));
+    if (newOpnd != nullptr) {
+      ssaNode->SetOpnd(newOpnd, 0);
+    }
+    return ssaNode;
+  }
+  for (size_t i = 0; i < expr->NumOpnds(); ++i) {
+    BaseNode *newOpnd = CreateSSAExpr(expr->Opnd(i));
+    if (newOpnd != nullptr) {
+      expr->SetOpnd(newOpnd, i);
+    }
+  }
+  // special lowering for trunc whose result has size less than 4 bytes
+  if (expr->GetOpCode() == OP_trunc && GetPrimTypeSize(expr->GetPrimType()) < 4) {
+    Opcode extOp = IsSignedInteger(expr->GetPrimType()) ? OP_sext : OP_zext;
+    uint32 extSize = GetPrimTypeBitSize(expr->GetPrimType());
+    PrimType newPrimType = GetRegPrimType(expr->GetPrimType());
+    expr->SetPrimType(newPrimType);
+    BaseNode *extNode = mirModule.CurFunction()->GetCodeMemPool()->New<ExtractbitsNode>(extOp, newPrimType, 0, extSize);
+    extNode->SetOpnd(expr, 0);
+    return extNode;
+  }
+  return arrayLowered ? expr : nullptr;
+}
+
+void SSATab::CreateSSAStmt(StmtNode &stmt, const BB *curbb) {
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+    BaseNode *newOpnd = CreateSSAExpr(stmt.Opnd(i));
+    if (newOpnd != nullptr) {
+      stmt.SetOpnd(newOpnd, i);
+    }
+  }
+  switch (stmt.GetOpCode()) {
+    case OP_maydassign:
+    case OP_dassign: {
+      MayDefPartWithVersionSt *theSSAPart =
+          stmtsSSAPart.GetSSAPartMp()->New<MayDefPartWithVersionSt>(&stmtsSSAPart.GetSSAPartAlloc());
+      stmtsSSAPart.SetSSAPartOf(stmt, theSSAPart);
+      auto &dNode = static_cast<DassignNode&>(stmt);
+      MIRSymbol *st = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dNode.GetStIdx());
+      CHECK_FATAL(st != nullptr, "null ptr check");
+
+      OriginalSt *ost = FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), dNode.GetFieldID());
+      AddDefBB4Ost(ost->GetIndex(), curbb->GetBBId());
+      versionStTable.CreateZeroVersionSt(ost);
+      theSSAPart->SetSSAVar(*versionStTable.GetZeroVersionSt(ost));
+      // if the rhs may throw exception, we insert MayDef of the lhs var
+      if (stmt.GetOpCode() == OP_maydassign) {
+        theSSAPart->InsertMayDefNode(MayDefNode(theSSAPart->GetSSAVar(), &dNode));
+      }
+      // set ost->isPtrWithIncDec
+      if (ost->GetType()->IsMIRPtrType()) {
+        if (dNode.GetRHS()->GetOpCode() == OP_add || dNode.GetRHS()->GetOpCode() == OP_sub) {
+          BinaryNode *rhs = static_cast<BinaryNode *>(dNode.GetRHS());
+          if (rhs->Opnd(0)->GetOpCode() == OP_dread && rhs->Opnd(1)->GetOpCode() == OP_constval) {
+            AddrofSSANode *dread = static_cast<AddrofSSANode *>(rhs->Opnd(0));
+            MIRSymbol *st2 = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dread->GetStIdx());
+            CHECK_FATAL(st2 != nullptr, "null ptr check");
+            OriginalSt *ost2 = FindOrCreateSymbolOriginalSt(*st2, mirModule.CurFunction()->GetPuidx(),
+                                                            dread->GetFieldID());
+            if (ost == ost2) {
+              ost->isPtrWithIncDec = true;
+            }
+          }
+        }
+      }
+      return;
+    }
+    case OP_regassign: {
+      auto &regNode = static_cast<RegassignNode&>(stmt);
+      OriginalSt *ost =
+          originalStTable.FindOrCreatePregOriginalSt(regNode.GetRegIdx(), mirModule.CurFunction()->GetPuidx());
+      AddDefBB4Ost(ost->GetIndex(), curbb->GetBBId());
+      versionStTable.CreateZeroVersionSt(ost);
+      VersionSt *vst = versionStTable.GetZeroVersionSt(ost);
+      stmtsSSAPart.SetSSAPartOf(stmt, vst);
+      // set ost->isPtrWithIncDec
+      if (ost->GetType()->IsMIRPtrType()) {
+        if (regNode.GetRHS()->GetOpCode() == OP_add || regNode.GetRHS()->GetOpCode() == OP_sub) {
+          BinaryNode *rhs = static_cast<BinaryNode *>(regNode.GetRHS());
+          if (rhs->Opnd(0)->GetOpCode() == OP_regread && rhs->Opnd(1)->GetOpCode() == OP_constval) {
+            RegreadSSANode *regread = static_cast<RegreadSSANode *>(rhs->Opnd(0));
+            if (regNode.GetRegIdx() == regread->GetRegIdx()) {
+              ost->isPtrWithIncDec = true;
+            }
+          }
+        }
+      }
+      return;
+    }
+    case OP_return:
+    case OP_throw:
+    case OP_gosub:
+    case OP_retsub:
+      stmtsSSAPart.SetSSAPartOf(stmt, stmtsSSAPart.GetSSAPartMp()->New<MayUsePart>(&stmtsSSAPart.GetSSAPartAlloc()));
+      return;
+    case OP_syncenter:
+    case OP_syncexit:
+      stmtsSSAPart.SetSSAPartOf(stmt,
+                                stmtsSSAPart.GetSSAPartMp()->New<MayDefMayUsePart>(&stmtsSSAPart.GetSSAPartAlloc()));
+      return;
+    case OP_iassign:
+      stmtsSSAPart.SetSSAPartOf(stmt, stmtsSSAPart.GetSSAPartMp()->New<MayDefPart>(&stmtsSSAPart.GetSSAPartAlloc()));
+      return;
+    default: {
+      if (stmt.GetOpCode() == OP_asm) {
+        if (static_cast<AsmNode&>(stmt).HasWriteInputs()) {
+          func->SetHasWriteInputAsmNode();
+        }
+      }
+      if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
+        MayDefMayUseMustDefPart *theSSAPart =
+            stmtsSSAPart.GetSSAPartMp()->New<MayDefMayUseMustDefPart>(&stmtsSSAPart.GetSSAPartAlloc());
+        stmtsSSAPart.SetSSAPartOf(stmt, theSSAPart);
+        // insert the mustdefs
+        CallReturnVector *nrets = static_cast<NaryStmtNode&>(stmt).GetCallReturnVector();
+        CHECK_FATAL(nrets != nullptr, "CreateSSAStmt: failed to retrieve call return vector");
+        if (nrets->empty()) {
+          return;
+        }
+        for (CallReturnPair &retPair : *nrets) {
+          OriginalSt *ost = nullptr;
+          if (!retPair.second.IsReg()) {
+            StIdx stidx = retPair.first;
+            MIRSymbol *st = mirModule.CurFunction()->GetLocalOrGlobalSymbol(stidx);
+            ost = FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), retPair.second.GetFieldID());
+          } else {
+            ost = originalStTable.FindOrCreatePregOriginalSt(retPair.second.GetPregIdx(),
+                                                             mirModule.CurFunction()->GetPuidx());
+          }
+          versionStTable.CreateZeroVersionSt(ost);
+          VersionSt *vst = versionStTable.GetZeroVersionSt(ost);
+          AddDefBB4Ost(ost->GetIndex(), curbb->GetBBId());
+          theSSAPart->InsertMustDefNode(vst, &stmt);
+        }
+      } else if (kOpcodeInfo.IsCall(stmt.GetOpCode())) {
+        stmtsSSAPart.SetSSAPartOf(stmt,
+                                  stmtsSSAPart.GetSSAPartMp()->New<MayDefMayUsePart>(&stmtsSSAPart.GetSSAPartAlloc()));
+      }
+    }
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/sync_select.cpp b/src/mapleall/maple_me/src/sync_select.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cc2f2611af65c13fcd3bb6888911bf615531d3e7
--- /dev/null
+++ b/src/mapleall/maple_me/src/sync_select.cpp
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "sync_select.h"
+#include "safe_cast.h"
+#include "mpl_logging.h"
+#include "me_cfg.h"
+
+namespace {
+using namespace maple;
+
+enum class SyncKind : uint8 {
+  kSpinLock = 0,
+  kDefault = 2,
+  kSysCall = 3
+};
+
+class SyncSelect {
+ public:
+  explicit SyncSelect(MeFunction &func) : func(func) {
+    AddFunc(SyncKind::kDefault, "Landroid_2Fos_2FParcel_3B_7Crecycle_7C_28_29V");
+  }
+  ~SyncSelect() = default;
+
+  void SyncOptimization() {
+    // deal with func white list where all syncenter use same version
+    auto it = syncMap.find(func.GetName());
+    if (it != syncMap.cend()) {
+      SetAllSyncKind(it->second);
+    }
+  }
+ private:
+  void AddFunc(SyncKind kind, const std::string &funcName) {
+    syncMap[funcName] = kind;
+  }
+
+  void SetAllSyncKind(SyncKind kind) {
+    auto cfg = func.GetCfg();
+    for (auto bIt = cfg->valid_begin(), eIt = cfg->valid_end(); bIt != eIt; ++bIt) {
+      for (auto &stmt : (*bIt)->GetStmtNodes()) {
+        if (stmt.GetOpCode() == OP_syncenter) {
+          SetSyncKind(stmt, kind);
+        }
+      }
+    }
+  }
+
+  void SetSyncKind(StmtNode &stmt, SyncKind kind) const {
+    CHECK_FATAL(stmt.GetOpCode() == OP_syncenter, "expect syncenter in SetSyncKind");
+    auto &nd = static_cast<NaryStmtNode&>(stmt);
+    CHECK_FATAL(nd.GetNopndSize() > 1, "access nd->nOpnd failed");
+    auto *cst = static_cast<ConstvalNode*>(nd.GetNopndAt(1));
+    auto *intConst = safe_cast<MIRIntConst>(cst->GetConstVal());
+    utils::ToRef(intConst).SetValue(static_cast<int64>(kind));
+  }
+
+  MeFunction &func;
+  std::map<const std::string, SyncKind> syncMap;
+};
+}
+
+namespace maple {
+bool MESyncSelect::PhaseRun(MeFunction &f) {
+  SyncSelect(f).SyncOptimization();
+  if (DEBUGFUNC_NEWPM(f)) {
+    f.Dump(true);
+  }
+  return true;
+}
+
+void MESyncSelect::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/type_based_alias_analysis.cpp b/src/mapleall/maple_me/src/type_based_alias_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac4919fd88b5a48dc3f169275512761bfc5db4fe
--- /dev/null
+++ b/src/mapleall/maple_me/src/type_based_alias_analysis.cpp
@@ -0,0 +1,851 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "type_based_alias_analysis.h"
+#include "me_option.h"
+#include "mir_type.h"
+namespace maple {
+namespace {
+std::unordered_map<MIRStructType *, std::vector<MIRType *>> fieldsTypeCache; // map structType to all its fieldType
+bool IsTypeCompatible(MIRType *typeA, MIRType *typeB);
+
+MIRType *GetFieldType(MIRStructType *strucType, FieldID fieldId) {
+  if (strucType == nullptr) {
+    return nullptr;
+  }
+  std::vector<MIRType *> &fieldsType = fieldsTypeCache[strucType];
+  if (!fieldsType.empty()) {
+    ASSERT(fieldId < fieldsType.size(), "field id out of range!");
+    return fieldsType[static_cast<uint64>(static_cast<uint32>(fieldId))];
+  }
+  // construct all fields Info here, not only for fieldId
+  size_t fieldNum = strucType->NumberOfFieldIDs() + 1;
+  fieldsType.resize(fieldNum, nullptr);
+  fieldsType[0] = strucType;
+  size_t i = 1;
+  while (i < fieldNum) {
+    MIRType *fieldType = strucType->GetFieldType(i);
+    MIRStructType *structFieldType = fieldType->EmbeddedStructType();
+    if (structFieldType != nullptr) {
+      (void)GetFieldType(structFieldType, 0); // build sub-struct
+      std::vector<MIRType *> &subFieldsType = fieldsTypeCache[structFieldType];
+      std::copy(subFieldsType.begin(), subFieldsType.end(), fieldsType.begin() + i);
+      i += subFieldsType.size();
+      continue;
+    }
+    fieldsType[i] = fieldType;
+    ++i;
+  }
+  ASSERT(fieldId < fieldsType.size(), "field id out of range!");
+  ASSERT(fieldsType[fieldId] != nullptr, "field type has not been get before!");
+  return fieldsType[static_cast<uint64>(static_cast<uint32>(fieldId))];
+}
+
+// if ost is a field of an aggregate type, return the aggregate type, otherwise return nullptr
+MIRType *GetAggTypeOstEmbedded(const OriginalSt *ost) {
+  if (ost == nullptr) {
+    return nullptr;
+  }
+  MIRType *aggType = nullptr;
+  if (ost->GetPrevLevelOst() != nullptr) {
+    MIRType *prevTypeA = ost->GetPrevLevelPointerType();
+    if (prevTypeA->IsMIRPtrType()) {
+      aggType = static_cast<MIRPtrType *>(prevTypeA)->GetPointedType();
+    }
+
+    if (aggType == nullptr || aggType->GetPrimType() != PTY_agg) {
+      prevTypeA = ost->GetPrevLevelOst()->GetType();
+      if (!prevTypeA->IsMIRPtrType()) {
+        return nullptr;
+      }
+      aggType = static_cast<MIRPtrType *>(prevTypeA)->GetPointedType();
+      constexpr int32 bitNumPerByte = 8;
+      // offset is out of current AggType, return nullptr
+      if (static_cast<int32>(aggType->GetSize()) * bitNumPerByte <= ost->GetOffset().val) {
+        return nullptr;
+      }
+    }
+  } else if (ost->GetIndirectLev() == 0 && ost->IsSymbolOst()) {
+    // ost is a field of aggType, but has no prevType, we can get this info from its symbol.
+    // notice that ost like `i32 a` will get i32 here, we should filter this case later.
+    aggType = ost->GetMIRSymbol()->GetType();
+  }
+  if (aggType != nullptr && aggType->GetPrimType() != PTY_agg) {
+    return nullptr;
+  }
+  return aggType;
+}
+
+// u8/i8 is special, because it can alias with any other type.
+bool IsByteType(const MIRType *type) {
+  return (type != nullptr && GetPrimTypeActualBitSize(type->GetPrimType()) == 8);
+}
+
+// if offset is greater than typeBitSize, canonicalize offset.
+// The root cause of this is array index offset, like:
+// example : structA *a; and a[2].fld offset will be greater than size of structA
+void CanonicalizeOffset(OffsetType &offset, int64 typeBitSize) {
+  if (offset.IsInvalid()) {
+    return;
+  }
+  if (typeBitSize == 0) {
+    return;
+  }
+  offset.Set(offset.val % typeBitSize);
+}
+
+bool IsArrayTypeCompatible(MIRType *arrayTypeA, MIRType *arrayTypeB) {
+  if (arrayTypeA == nullptr || arrayTypeB == nullptr) {
+    return false;
+  }
+  if (arrayTypeA == arrayTypeB) {
+    // if arrayTypeA is kTypeFArray and arrayTypeB is kTypeFArray, they are compatible only when they equal.
+    return true;
+  }
+  return GetElemType(*arrayTypeA) == GetElemType(*arrayTypeB);
+}
+
+// forward declare
+bool IsFieldTypeOfAggType(MIRType *aggType, MIRType *checkedType);
+bool IsFieldTypeOfStructType(MIRStructType *structType, MIRType *checkedType);
+
+// Check if checkedType is a fieldType of MIRArrayType or MIRFarrayType
+template <typename ArrayType,
+          typename = typename std::enable_if<std::is_same<ArrayType, MIRArrayType>::value ||
+                                             std::is_same<ArrayType, MIRFarrayType>::value>::type>
+bool IsFieldTypeOfArrayType(ArrayType *arrayType, MIRType *checkedType) {
+  if (arrayType == nullptr || checkedType == nullptr) {
+    return false;
+  }
+  if (arrayType == checkedType) {
+    return true;
+  }
+  MIRType *elemType = arrayType->GetElemType();
+  if (elemType == checkedType) {
+    return true;
+  }
+  if (checkedType->GetKind() == kTypeArray || checkedType->GetKind() == kTypeFArray) {
+    return IsArrayTypeCompatible(arrayType, checkedType);
+  }
+  // check if checkedType is simd type, e.g. v4i32 and <[N] i32> may be the same.
+  if (elemType->IsScalarType() && checkedType->IsScalarType()) {
+    return IsTypeCompatible(elemType, checkedType);
+  }
+  // Only need to check if elemType is a MIRArrayType or MIRStructType, elemType will never be MIRFarrayType
+  if (IsFieldTypeOfStructType(elemType->EmbeddedStructType(), checkedType)) {
+    return true;
+  }
+  return false;
+}
+
+bool IsFieldOfUnion(MIRStructType *unionType, MIRType *checkedType) {
+  if (unionType == checkedType) {
+    return true;
+  }
+  if (unionType->GetKind() != kTypeUnion) {
+    return false;
+  }
+  (void)GetFieldType(unionType, 0); // init fields type of unionType
+  const auto &fieldsType = fieldsTypeCache[unionType];
+  return std::find(fieldsType.begin(), fieldsType.end(), checkedType) != fieldsType.end();
+}
+
+// checkType has same size as structType
+bool IsFieldOfStructWithSameSize(MIRStructType *structType, MIRType *checkedType) {
+  if (structType->GetKind() == kTypeUnion) {
+    return IsFieldOfUnion(structType, checkedType);
+  }
+  if (structType == checkedType) {
+    return true;
+  }
+  MIRType *fieldType = structType->GetFieldType(1);
+  size_t checkedSize = checkedType->GetSize();
+  // always compare checkedType and type of field 1
+  while (fieldType->GetSize() == checkedSize) {
+    if (fieldType == checkedType) {
+      return true;
+    }
+    if (fieldType->GetKind() == kTypeUnion) {
+      return IsFieldOfUnion(static_cast<MIRStructType *>(fieldType), checkedType);
+    }
+    if (fieldType->IsStructType()) {
+      fieldType = static_cast<MIRStructType*>(fieldType)->GetFieldType(1);
+    } else if (fieldType->GetKind() == kTypeArray) {
+      fieldType = static_cast<MIRArrayType*>(fieldType)->GetElemType();
+    } else {
+      return false;
+    }
+  }
+  return false;
+}
+
+// checkType has same size as arrayType
+bool IsFieldTypeOfArrayTypeWithSameSize(MIRArrayType *arrayType, MIRType *checkedType) {
+  ASSERT_NOT_NULL(arrayType);
+  if (arrayType == checkedType) {
+    return true;
+  }
+  MIRType *elemType = arrayType->GetElemType();
+  if (elemType == checkedType) {
+    return true;
+  }
+  ASSERT_NOT_NULL(checkedType);
+  if (checkedType->GetKind() == kTypeArray) {
+    return IsArrayTypeCompatible(arrayType, checkedType);
+  }
+  if (elemType->GetSize() != checkedType->GetSize()) {
+    return false;
+  }
+  if (elemType->IsStructType()) {
+    return IsFieldOfStructWithSameSize(static_cast<MIRStructType *>(elemType), checkedType);
+  }
+  if (elemType->GetKind() == kTypeArray) {
+    return IsFieldTypeOfArrayTypeWithSameSize(static_cast<MIRArrayType*>(elemType), checkedType);
+  }
+  return false;
+}
+
+// Check if checkedType is a fieldType of structType
+bool IsFieldTypeOfStructType(MIRStructType *structType, MIRType *checkedType) {
+  if (structType == nullptr || checkedType == nullptr) {
+    return false;
+  }
+  if (structType == checkedType) {
+    return true;
+  }
+  size_t fieldsNum = structType->NumberOfFieldIDs();
+  size_t checkedFieldsNum = checkedType->NumberOfFieldIDs();
+  size_t checkedSize = checkedType->GetSize();
+  // if checkType is a field of structType, fieldsNum is at least 1 larger than checkedFieldsNum
+  if (structType->GetSize() < checkedSize || fieldsNum <= checkedFieldsNum) {
+    return false;
+  }
+  if (structType->GetSize() == checkedSize) {
+    return IsFieldOfStructWithSameSize(structType, checkedType);
+  }
+
+  (void) GetFieldType(structType, 0); // init fields type of structType
+  const auto &fieldsType = fieldsTypeCache[structType];
+  return std::find(fieldsType.begin(), fieldsType.end(), checkedType) != fieldsType.end();
+}
+
+static std::unordered_map<MIRType *, std::unordered_map<MIRType *, bool>> compatibleTypeCache;
+
+bool IsFieldTypeOfAggType(MIRType *aggType, MIRType *checkedType) {
+  ASSERT_NOT_NULL(aggType);
+  if (aggType == checkedType) {
+    return true;
+  }
+  if (aggType->GetPrimType() != PTY_agg) {
+    return false;
+  }
+  ASSERT_NOT_NULL(checkedType);
+  if (aggType->GetSize() < checkedType->GetSize() || aggType->NumberOfFieldIDs() < checkedType->NumberOfFieldIDs()) {
+    return false;
+  }
+  if (compatibleTypeCache.find(aggType) != compatibleTypeCache.end()) {
+    auto &fieldsTypeMap = compatibleTypeCache[aggType];
+    if (fieldsTypeMap.find(checkedType) != fieldsTypeMap.end()) {
+      return fieldsTypeMap[checkedType];
+    }
+  }
+  bool res = false;
+  if (aggType->IsStructType()) {
+    res = IsFieldTypeOfStructType(static_cast<MIRStructType*>(aggType), checkedType);
+  } else if (aggType->GetKind() == kTypeArray) {
+    res = IsFieldTypeOfArrayType(static_cast<MIRArrayType*>(aggType), checkedType);
+  } else if (aggType->GetKind() == kTypeFArray) {
+    res = IsFieldTypeOfArrayType(static_cast<MIRFarrayType*>(aggType), checkedType);
+  }
+  compatibleTypeCache[aggType].emplace(checkedType, res);
+  return res;
+}
+
+void GetInitialMemType(const MIRType &type, std::set<const MIRType *> &zeroOffsetType);
+
+// C99 6.7.2.1
+// 13) A pointer to a structure object, suitably converted, points to its initial member (or if that member is a
+//     bit-field, then to the unit in which it resides),, and vice versa
+// 14) A pointer to a union object, suitably converted, points to each of its members (or if a member is a
+//     bit-field, then to the unit in which it resides), and vice versa.
+void GetInitialMemTypeForStruct(const MIRStructType &structType, std::set<const MIRType *> &zeroOffsetType) {
+  const FieldVector &fields = structType.GetFields();
+  if (structType.GetKind() == kTypeUnion) {
+    for (auto field : fields) {
+      TyIdx tyIdx = field.second.first;
+      MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+      GetInitialMemType(*fieldType, zeroOffsetType);
+    }
+  } else if (structType.GetKind() == kTypeStruct) {
+    TyIdx tyIdx = fields.front().second.first;
+    MIRType *initialMemberType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    GetInitialMemType(*initialMemberType, zeroOffsetType);
+  }
+  (void)zeroOffsetType.emplace(&structType);
+}
+
+// For multi-dimensional array, we only collect element type here, ignoring the lower dimensional array type
+// For example, <*<[][] i32>> will get i32, and ignore <[] i32>
+void GetInitialMemTypeForArray(const MIRArrayType &arrayType, std::set<const MIRType *> &zeroOffsetType) {
+  GetInitialMemType(*arrayType.GetElemType(), zeroOffsetType);
+  (void)zeroOffsetType.emplace(&arrayType);
+}
+
+// get member fields with zero offset
+void GetInitialMemType(const MIRType &type, std::set<const MIRType *> &zeroOffsetType) {
+  if (type.IsStructType()) {
+    GetInitialMemTypeForStruct(static_cast<const MIRStructType &>(type), zeroOffsetType);
+  } else if (type.IsMIRArrayType()) {
+    GetInitialMemTypeForArray(static_cast<const MIRArrayType &>(type), zeroOffsetType);
+  } else if (type.IsMIRBitFieldType()) {
+    MIRType *residesType = GlobalTables::GetTypeTable().GetPrimType(type.GetPrimType());
+    (void)zeroOffsetType.emplace(residesType);
+  }
+  (void)zeroOffsetType.emplace(&type);
+}
+
+// Example: struct A { int a; }; struct B { A a; int b; }; struct C { B b[2]; int c; }
+// Pointer to C can convert to type of fields with offset = 0. That is:
+// <* <$struct C>> cvt to <* <$[] <$struct B>>>, <* <$struct B>>, <* <$struct A>>, <* int>
+bool IsPointerInterconvertible(const MIRPtrType &ptrTypeA, const MIRPtrType &ptrTypeB) {
+  if (ptrTypeA.GetTypeIndex() == ptrTypeB.GetTypeIndex()) {
+    return true;
+  }
+  // C99 6.3.2.3
+  // 1) A pointer to void may be converted to or from a pointer to any incomplete or object type.
+  if (ptrTypeA.IsVoidPointer() || ptrTypeB.IsVoidPointer()) {
+    return true;
+  }
+  MIRType *pointedTypeA = ptrTypeA.GetPointedType();
+  MIRType *pointedTypeB = ptrTypeB.GetPointedType();
+  if (!IsTypeCompatible(pointedTypeA, pointedTypeB)) {
+    return false;
+  }
+  if (pointedTypeA->IsScalarType() && pointedTypeB->IsScalarType()) {
+    return true;
+  }
+  if (pointedTypeA->IsMIRArrayType() && pointedTypeB->IsMIRArrayType()) {
+    return IsArrayTypeCompatible(pointedTypeA, pointedTypeB);
+  }
+  // We get element type here to avoid checking lower array type for multi-dimensional array
+  if (pointedTypeA->IsMIRArrayType()) {
+    pointedTypeA = static_cast<MIRArrayType *>(pointedTypeA)->GetElemType();
+  }
+  if (pointedTypeB->IsMIRArrayType()) {
+    pointedTypeB = static_cast<MIRArrayType *>(pointedTypeB)->GetElemType();
+  }
+  // C99 6.7.2.1
+  // 13) A pointer to a structure object, suitably converted, points to its initial member (or if that member is a
+  //     bit-field, then to the unit in which it resides),, and vice versa
+  // 14) A pointer to a union object, suitably converted, points to each of its members (or if a member is a
+  //     bit-field, then to the unit in which it resides), and vice versa.
+  std::set<const MIRType *> initialMemType;
+  GetInitialMemType(*pointedTypeA, initialMemType);
+  if (initialMemType.count(pointedTypeB)) {
+    return true;
+  }
+  initialMemType.clear();
+  GetInitialMemType(*pointedTypeB, initialMemType);
+  if (initialMemType.count(pointedTypeA)) {
+    return true;
+  }
+  return false;
+}
+
+bool IsTypeCompatible(MIRType *typeA, MIRType *typeB) {
+  if (typeA == nullptr || typeB == nullptr) {
+    return false;
+  }
+  if (typeA == typeB) {
+    return true;
+  }
+
+  if (typeA->IsMIRPtrType() && typeB->IsMIRPtrType()) {
+    return IsPointerInterconvertible(static_cast<MIRPtrType &>(*typeA), static_cast<MIRPtrType &>(*typeB));
+  }
+
+  if (IsPrimitiveScalar(typeA->GetPrimType()) &&
+      IsPrimitiveScalar(typeB->GetPrimType())) {
+    // e.g. i32 and v4i32 can be alias, since i32 can be part of v4i32
+    if ((IsPrimitiveVector(typeA->GetPrimType()) && IsPrimitiveInteger(typeB->GetPrimType())) ||
+        (IsPrimitiveInteger(typeA->GetPrimType()) && IsPrimitiveVector(typeB->GetPrimType()))) {
+      return true;
+    }
+    if (IsPrimitiveInteger(typeA->GetPrimType()) && IsPrimitiveInteger(typeB->GetPrimType()) &&
+        typeA->GetSize() == typeB->GetSize()) {
+      // i64/u64/ptr/a64, i32/u32/a32, i16/u16
+      return true;
+    }
+    return false;
+  }
+  if (IsFieldTypeOfAggType(typeA, typeB) || IsFieldTypeOfAggType(typeB, typeA)) {
+    return true;
+  }
+  return false;
+}
+
+static void GetPossibleFieldID(MIRType *aggType, MIRType *checkedType, std::vector<FieldID> &fieldIDs) {
+  if (aggType == checkedType) {
+    fieldIDs.push_back(0);
+    return;
+  }
+  size_t checkedSize = checkedType->GetSize();
+  if (aggType->GetSize() < checkedSize) {
+    return;
+  }
+  MIRStructType *structType = aggType->EmbeddedStructType();
+  if (structType == checkedType) {
+    fieldIDs.push_back(0);
+    return;
+  }
+  if (structType == nullptr) {
+    if (aggType->GetKind() == kTypeArray) {
+      if (static_cast<MIRArrayType*>(aggType)->GetElemType() == checkedType) {
+        fieldIDs.push_back(0);
+      }
+    }
+    return;
+  }
+  size_t fieldsNum = aggType->NumberOfFieldIDs();
+  (void) GetFieldType(structType, 0); // init fields Type of structType
+  auto &fieldsTypeVec = fieldsTypeCache[structType];
+  for (size_t i = 1; i <= fieldsNum; ++i) {
+    MIRType *fieldType = fieldsTypeVec[i];
+
+    if (fieldType == checkedType) {
+      fieldIDs.emplace_back(i);
+      continue;
+    }
+    if (IsPrimitiveScalar(checkedType->GetPrimType()) &&
+        fieldType->GetPrimType() == checkedType->GetPrimType()) {
+      fieldIDs.emplace_back(i);
+      continue;
+    }
+    if (fieldType->IsMIRArrayType()) {
+      if (static_cast<MIRArrayType *>(fieldType)->GetElemType() == checkedType ||
+          (checkedType->IsMIRArrayType() && IsArrayTypeCompatible(fieldType, checkedType))) {
+        fieldIDs.emplace_back(i);
+      }
+    }
+  }
+}
+
+// check if fields of aggType may overlap memory (specified by memStart and memBitSize)
+bool MayAliasFieldsAndMem(MIRType *aggType, std::vector<FieldID> &fields, int64 memStart, int64 memBitSize) {
+  if (fields.empty()) {
+    return false;
+  }
+  if (!aggType->HasFields()) {
+    if (fields.size() == 1 && fields.front() == 0) {
+      return true;
+    }
+    return false;
+  }
+  if (aggType->GetKind() == kTypeArray) {
+    aggType = static_cast<MIRArrayType *>(aggType)->GetElemType();
+    // fields specify the id of first element of aggType, so we should make memStart to the first element
+    memStart %= GetTypeBitSize(aggType);
+  }
+  ASSERT(aggType->IsStructType(), "Aggtype must be MIRStructType");
+  auto *structType = static_cast<MIRStructType *>(aggType);
+  for (auto fieldID : fields) {
+    ASSERT(fieldID <= aggType->NumberOfFieldIDs(), "Field id is out of range of aggType's field number");
+    MIRType *fieldType = GetFieldType(structType, fieldID);
+    size_t typeBitSize = static_cast<uint64>(GetTypeBitSize(fieldType));
+    int64 offsetA = structType->GetBitOffsetFromBaseAddr(fieldID);
+    if (IsMemoryOverlap(OffsetType(offsetA), typeBitSize, OffsetType(memStart), memBitSize)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Check if fields (specified by fieldsA and fieldsB) in aggType may overlap each other.
+bool MayAliasFieldsAndFields(MIRType *aggType, std::vector<FieldID> &fieldsA, std::vector<FieldID> &fieldsB) {
+  if (fieldsA.empty() || fieldsB.empty()) {
+    return false;
+  }
+  if (!aggType->HasFields()) {
+    if (fieldsA.size() == 1 && fieldsA.front() == 0 && fieldsB.size() == 1 && fieldsB.front() == 0) {
+      return true;
+    }
+    return false;
+  }
+  if (aggType->GetKind() == kTypeArray) {
+    aggType = static_cast<MIRArrayType *>(aggType)->GetElemType();
+  }
+  ASSERT(aggType->IsStructType(), "Aggtype must be MIRStructType");
+  auto *structType = static_cast<MIRStructType *>(aggType);
+  // Operation `GetBitOffsetFromBaseAddr` is time consuming, we cache it first.
+  std::vector<std::pair<int64, size_t>> offsetSizeVecA(fieldsA.size(), {0, 0 });
+  for (size_t i = 0; i < fieldsA.size(); ++i) {
+    FieldID idA = fieldsA[i];
+    ASSERT(idA <= structType->NumberOfFieldIDs(), "Field id is out of range of aggType's field number");
+    MIRType *fieldTypeA = GetFieldType(structType, idA);
+    offsetSizeVecA[i].first = structType->GetBitOffsetFromBaseAddr(idA);
+    offsetSizeVecA[i].second = static_cast<uint64>(GetTypeBitSize(fieldTypeA));
+  }
+  for (auto idB : fieldsB) {
+    MIRType *fieldTypeB = GetFieldType(structType, idB);
+    size_t typeBBitSize = static_cast<uint64>(GetTypeBitSize(fieldTypeB));
+    int64 offsetB = structType->GetBitOffsetFromBaseAddr(idB);
+    for (const auto &offsetSizePair : offsetSizeVecA) {
+      if (IsMemoryOverlap(OffsetType(offsetSizePair.first), offsetSizePair.second, OffsetType(offsetB), typeBBitSize)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// ost is embedded in aggType, check if ost may overlap the memory specified by fields of aggType
+bool MayAliasOstAndFields(const OriginalSt *ost, MIRType *aggType, std::vector<FieldID> &fields) {
+  if (GetAggTypeOstEmbedded(ost) != aggType) {
+    return false;
+  }
+  MIRType *type = ost->GetType();
+  OffsetType offset = ost->GetOffset();
+  CanonicalizeOffset(offset, GetTypeBitSize(aggType));
+  if (offset.IsInvalid() && ost->GetFieldID() != 0) { // if fieldID is valid, calculate offset from fieldID
+    offset = OffsetType(aggType->GetBitOffsetFromBaseAddr(ost->GetFieldID()));
+  }
+  if (offset.IsInvalid()) {
+    std::vector<FieldID> ostFields{};
+    GetPossibleFieldID(aggType, type, ostFields);
+    return MayAliasFieldsAndFields(aggType, fields, ostFields);
+  } else {
+    return MayAliasFieldsAndMem(aggType, fields, offset.val, GetTypeBitSize(type));
+  }
+}
+
+// TypeA (with fieldNumA and sizeA) can never be embedded in TypeB(with fieldNumB and sizeB) and vice versa.
+inline bool TypeNeverEmbedded(size_t fieldNumA, size_t sizeA, size_t fieldNumB, size_t sizeB) {
+  // check (fieldNumA != 0 || fieldNumB != 0) is necessary here, an example is taken to explain why:
+  // <[1] i32> and <[2] i32> : both have 0 fieldNum, and sizeA < sizeB, but typeA can embedded in typeB
+  return (fieldNumA != 0 || fieldNumB != 0) &&
+      ((sizeA < sizeB && fieldNumA >= fieldNumB) || (sizeA > sizeB && fieldNumA <= fieldNumB));
+}
+
+// aggType has same size as checkedType, check if checkedType may be embedded in aggType.
+bool TypeWithSameSizeEmbedded(MIRType *aggType, MIRType *checkedType) {
+  if (aggType == checkedType) {
+    return true;
+  }
+  ASSERT_NOT_NULL(aggType);
+  if (aggType->GetSize() != checkedType->GetSize()) {
+    return false;
+  }
+  switch (aggType->GetKind()) {
+    case kTypeUnion:
+      return IsFieldOfUnion(static_cast<MIRStructType*>(aggType), checkedType);
+    case kTypeStruct:
+      return IsFieldOfStructWithSameSize(static_cast<MIRStructType *>(aggType), checkedType);
+    case kTypeArray:
+      return IsFieldTypeOfArrayTypeWithSameSize(static_cast<MIRArrayType*>(aggType), checkedType);
+    default:
+      return false;
+  }
+}
+
+// when aggTypeB is embedded in aggTypeA, check if ostA alias with ostB.
+bool MayAliasForAggTypeNest(MIRType *aggTypeA, const OriginalSt *ostA, MIRType *aggTypeB, const OriginalSt *ostB) {
+  MIRType *typeA = ostA->GetType();
+  if (IsFieldTypeOfAggType(typeA, aggTypeB)) { // aggTypeB is field type of typeA
+    return true;
+  }
+  FieldID fieldIdB = ostB->GetFieldID();
+  std::vector<FieldID> possibleFieldIDs{};
+  GetPossibleFieldID(aggTypeA, aggTypeB, possibleFieldIDs); // all possible fields that may embeded in aggTypeB
+  if (fieldIdB != 0) {
+    std::for_each(possibleFieldIDs.begin(), possibleFieldIDs.end(), [fieldIdB](FieldID &id) {
+      id += fieldIdB;
+    });
+  }
+  return MayAliasOstAndFields(ostA, aggTypeA, possibleFieldIDs);
+}
+
+// No info about where checkedType is embedded, so we ASSUME ost and checkedType
+// might be embedded in the same TopType conservatively
+bool MayAliasOstAndType(const OriginalSt *ost, MIRType *checkedType) {
+  if (IsPrimitiveVector(checkedType->GetPrimType())) {
+    return true;
+  }
+
+  MIRType *ostType = ost->GetType();
+  if (ostType == checkedType) {
+    return true;
+  }
+
+  MIRType *aggType = GetAggTypeOstEmbedded(ost);
+  if (checkedType == aggType) {
+    return true;
+  }
+  ASSERT_NOT_NULL(aggType);
+  size_t sizeA = aggType->GetSize();
+  size_t sizeB = checkedType->GetSize();
+  size_t fieldNumA = aggType->NumberOfFieldIDs();
+  size_t fieldNumB = checkedType->NumberOfFieldIDs();
+  if (TypeNeverEmbedded(sizeA, fieldNumA, sizeB, fieldNumB)) {
+    return false;
+  }
+  if (sizeA < sizeB) { // fieldNumA <= fieldNumB is also true implicitly.
+    // check if aggType can be embedded in checkedType
+    return IsFieldTypeOfAggType(checkedType, aggType);
+  } else if (sizeA == sizeB) {
+    if (fieldNumA == fieldNumB) { // <[1] <$struct>> and <$struct> has same size and fldNum
+      if (aggType->GetKind() == kTypeArray) {
+        return IsFieldTypeOfArrayTypeWithSameSize(static_cast<MIRArrayType*>(aggType), checkedType);
+      } else if (checkedType->GetKind() == kTypeArray) {
+        return IsFieldTypeOfArrayTypeWithSameSize(static_cast<MIRArrayType*>(checkedType), aggType);
+      }
+      return false;
+    } else {
+      return (fieldNumA > fieldNumB) ?
+          TypeWithSameSizeEmbedded(aggType, checkedType) : TypeWithSameSizeEmbedded(checkedType, aggType);
+    }
+  } else { // sizeA > sizeB (fieldNumA >= fieldNumB is also true implicitly)
+    // check if checkedType can be embedded in aggType, and overlap with ost
+    if ((ostType->GetPrimType() == PTY_agg && IsFieldTypeOfAggType(ostType, checkedType)) ||
+        (checkedType->GetPrimType() == PTY_agg && IsFieldTypeOfAggType(checkedType, ostType))) {
+      return true;
+    }
+    MIRStructType *structType = aggType->EmbeddedStructType();
+    if (structType == nullptr) { // array of non-struct type
+      ASSERT(aggType->GetKind() == kTypeArray, "Must be array type of non-struct type!");
+      return IsFieldTypeOfArrayType(static_cast<MIRArrayType*>(aggType), checkedType);
+    }
+    // find every field that checkedType may be embedded in, and check if this field can overlap ost.
+    std::vector<FieldID> possibleField;
+    GetPossibleFieldID(structType, checkedType, possibleField);
+    return MayAliasOstAndFields(ost, structType, possibleField);
+  }
+}
+} // anonymous namespace
+
+std::vector<bool> TypeBasedAliasAnalysis::ptrValueTypeUnsafe{};
+
+bool MustAliasAccordingOffset(const OriginalSt &ostA, const OriginalSt &ostB) {
+  if (ostA.GetIndex() == ostB.GetIndex()) {
+    return true;
+  }
+  if (ostA.GetPointerVstIdx() != ostB.GetPointerVstIdx() || ostA.GetPointerVstIdx() == 0) {
+    return false;
+  }
+  if (ostA.GetOffset().IsInvalid() || ostB.GetOffset().IsInvalid()) {
+    return false;
+  }
+
+  auto canCheckAliasFromOffset = [](const OriginalSt *prevLevOst) -> bool {
+    if (prevLevOst == nullptr) {
+      return true;
+    }
+    if (prevLevOst->GetIndirectLev() < 0) {
+      return true;
+    }
+    if (prevLevOst->GetIndirectLev() > 0) {
+      return false;
+    }
+    return prevLevOst->IsTopLevelOst();
+  };
+  if (!canCheckAliasFromOffset(ostA.GetPrevLevelOst())) {
+    return false;
+  }
+
+  constexpr uint32 bitNumPerByte = 8;
+  auto typeSizeA = ostA.GetType()->GetSize() * bitNumPerByte;
+  auto typeSizeB = ostB.GetType()->GetSize() * bitNumPerByte;
+  return IsMemoryOverlap(ostA.GetOffset(), static_cast<int64>(typeSizeA),
+                         ostB.GetOffset(), static_cast<int64>(typeSizeB));
+}
+
+static bool IsMemoryOverlap(const OriginalSt &ostA, const OriginalSt &ostB, const MIRType &aggType) {
+  auto fieldNumInAgg = static_cast<int32>(aggType.NumberOfFieldIDs());
+  if (fieldNumInAgg < ostA.GetFieldID() || fieldNumInAgg < ostB.GetFieldID()) {
+    return true;
+  }
+
+  OffsetType offsetA(OffsetType::InvalidOffset());
+  if (ostA.GetFieldID() == 0) {
+    offsetA.Set(ostA.GetOffset().val);
+  } else {
+    offsetA.Set(aggType.GetBitOffsetFromBaseAddr(ostA.GetFieldID()));
+  }
+
+  OffsetType offsetB(OffsetType::InvalidOffset());
+  if (ostB.GetFieldID() == 0) {
+    offsetB.Set(ostB.GetOffset().val);
+  } else {
+    offsetB.Set(aggType.GetBitOffsetFromBaseAddr(ostB.GetFieldID()));
+  }
+
+  int32 bitSizeA = static_cast<int32>(GetTypeBitSize(ostA.GetType()));
+  int32 bitSizeB = static_cast<int32>(GetTypeBitSize(ostB.GetType()));
+  return IsMemoryOverlap(offsetA, bitSizeA, offsetB, bitSizeB);
+}
+
+bool TypeBasedAliasAnalysis::MayAlias(const OriginalSt *ostA, const OriginalSt *ostB) {
+  if (!MeOption::tbaa) {
+    return true; // deal with alias relation conservatively for non-type-safe
+  }
+  if (ostA == nullptr || ostB == nullptr) {
+    return false;
+  }
+  if (ostA == ostB) {
+    return true;
+  }
+
+  if (MustAliasAccordingOffset(*ostA, *ostB)) {
+    return true;
+  }
+
+  // Check field alias - If both of ost are fields of the same agg type, check if they overlap
+  if (ostA->GetFieldID() != 0 && ostB->GetFieldID() != 0) {
+    MIRType *aggTypeA = GetAggTypeOstEmbedded(ostA);
+    MIRType *aggTypeB = GetAggTypeOstEmbedded(ostB);
+    // We should check type compatibility here actually
+    if (aggTypeA == aggTypeB && aggTypeA != nullptr) {
+      return IsMemoryOverlap(*ostA, *ostB, *aggTypeA);
+    }
+  }
+  return true;
+}
+
+void TypeBasedAliasAnalysis::ClearOstTypeUnsafeInfo() {
+  if (!MeOption::tbaa || ptrValueTypeUnsafe.empty()) {
+    return;
+  }
+  ptrValueTypeUnsafe.clear();
+}
+
+static std::pair<MIRStructType*, FieldID> GetInnerMostAggType(MIRStructType &structType, FieldID fieldId) {
+  FieldID innerFieldId = 0;
+  while (fieldId >= innerFieldId) {
+    auto *innerType = structType.GetFieldType(fieldId - innerFieldId);
+    if (innerType->IsStructType() &&
+        innerType->NumberOfFieldIDs() >= static_cast<uint32>(innerFieldId)) {
+      return std::make_pair(static_cast<MIRStructType*>(innerType), innerFieldId);
+    }
+    ++innerFieldId;
+  }
+  return std::make_pair(&structType, fieldId);
+}
+
+static bool MayAliasForVirtualOstOfVoidPtr(const OriginalSt &ostA, MIRType &aggTypeA,
+                                           const OriginalSt &ostB, MIRType &aggTypeB) {
+  // not analyze candidate of cur method, return false
+  if (!aggTypeA.IsStructType() || !aggTypeB.IsStructType()) {
+    return false;
+  }
+
+  // not analyze candidate of cur method, return false
+  auto *prevLevOstA = ostA.GetPrevLevelOst();
+  if (prevLevOstA == nullptr || !prevLevOstA->GetType()->IsVoidPointer()) {
+    auto *prevLevOstB = ostB.GetPrevLevelOst();
+    if (prevLevOstB == nullptr || !prevLevOstB->GetType()->IsVoidPointer()) {
+      return false;
+    }
+  }
+
+  auto fieldIdA = ostA.GetFieldID();
+  auto fieldIdB = ostB.GetFieldID();
+  const auto &typePairA = GetInnerMostAggType(static_cast<MIRStructType&>(aggTypeA), fieldIdA);
+  const auto &typePairB = GetInnerMostAggType(static_cast<MIRStructType&>(aggTypeB), fieldIdB);
+  if (typePairA.first != typePairB.first) {
+    return false;
+  }
+  // to be conservative, return true for out-of-bound fld
+  if (typePairA.first->NumberOfFieldIDs() < static_cast<uint32>(typePairA.second) ||
+      typePairB.first->NumberOfFieldIDs() < static_cast<uint32>(typePairB.second)) {
+    return true;
+  }
+  OffsetType offsetA(typePairA.first->GetBitOffsetFromBaseAddr(typePairA.second));
+  OffsetType offsetB(typePairB.first->GetBitOffsetFromBaseAddr(typePairB.second));
+  return IsMemoryOverlap(offsetA, GetTypeBitSize(ostA.GetType()), offsetB, GetTypeBitSize(ostB.GetType()));
+}
+
+bool TypeBasedAliasAnalysis::MayAliasTBAAForC(const OriginalSt *ostA, const OriginalSt *ostB) {
+  if (!MeOption::tbaa) {
+    return true;
+  }
+  if (ostA == nullptr || ostB == nullptr) {
+    return false;
+  }
+  if (MustAliasAccordingOffset(*ostA, *ostB)) {
+    return true;
+  }
+  if (IsMemTypeUnsafe(*ostA) || IsMemTypeUnsafe(*ostB)) {
+    return true; // type unsafe, process conservatively
+  }
+  MIRType *typeA = ostA->GetType();
+  MIRType *typeB = ostB->GetType();
+  MIRType *aggTypeA = GetAggTypeOstEmbedded(ostA);
+  MIRType *aggTypeB = GetAggTypeOstEmbedded(ostB);
+  // using an lvalue expression (typically, dereferencing a pointer) of character type is legal
+  // which means an object derefereced from (char *) may alias with any other type
+  auto dereferencedByteType = [](const OriginalSt &ost) {
+    if (ost.GetPointerTyIdx() == 0) {
+      return false;
+    }
+    auto *prevLevelPointerType = static_cast<MIRPtrType *>(ost.GetPrevLevelPointerType());
+    auto *prevLevelPointToType = prevLevelPointerType->GetPointedType();
+    return IsByteType(prevLevelPointToType);
+  };
+  if (dereferencedByteType(*ostA) || dereferencedByteType(*ostB)) {
+    return true;
+  }
+  // We are not sure where they are embedded, check if they are compatible.
+  if (aggTypeA == nullptr && aggTypeB == nullptr) {
+    return IsTypeCompatible(typeA, typeB);
+  }
+  if (aggTypeB == nullptr) { // aggTypeA must be non-nullptr here
+    return MayAliasOstAndType(ostA, typeB);
+  }
+  if (aggTypeA == nullptr) { // aggTypeB must be non-nullptr here
+    return MayAliasOstAndType(ostB, typeA);
+  }
+  // aggTypeA and aggTypeB are not nullptr after here.
+  // Two array has same elemType, may be casted to each other.
+  if ((aggTypeA->GetKind() == kTypeArray || aggTypeA->GetKind() == kTypeFArray) &&
+      (aggTypeB->GetKind() == kTypeArray || aggTypeB->GetKind() == kTypeFArray)) {
+    return IsArrayTypeCompatible(aggTypeA, aggTypeB);
+  }
+
+  if (aggTypeA == aggTypeB) {
+    return IsMemoryOverlap(*ostA, *ostB, *aggTypeA);
+  }
+  if (MayAliasForVirtualOstOfVoidPtr(*ostA, *aggTypeA, *ostB, *aggTypeB)) {
+    return true;
+  }
+  if (IsFieldTypeOfAggType(aggTypeA, aggTypeB)) { // aggTypeB is embedded in aggTypeA
+    return MayAliasForAggTypeNest(aggTypeA, ostA, aggTypeB, ostB);
+  } else if (IsFieldTypeOfAggType(aggTypeB, aggTypeA)) {
+    return MayAliasForAggTypeNest(aggTypeB, ostB, aggTypeA, ostA);
+  }
+  return false;
+}
+
+// return true if can filter this aliasElemOst, otherwise return false;
+bool TypeBasedAliasAnalysis::FilterAliasElemOfRHSForIassign(const OriginalSt *aliasElemOst, const OriginalSt *lhsOst,
+                                                            const OriginalSt *rhsOst) {
+  if (!MeOption::tbaa) {
+    return false;
+  }
+  // only for type-safe : iassign (lhs, rhs),
+  // if rhs is alias with lhs, their memories overlap completely (not partially);
+  // if rhs is not alias with rhs, their memories completely not overlap.
+  // Rhs may def itself if they overlap, but its value is the same as before.
+  // So we skip inserting maydef for ost the same as rhs here
+  return (aliasElemOst == rhsOst && rhsOst->GetTyIdx() == lhsOst->GetTyIdx());
+}
+} // namespace maple
diff --git a/src/mapleall/maple_me/src/ver_symbol.cpp b/src/mapleall/maple_me/src/ver_symbol.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..52635d011c6757757d1dccab904e77d6d920daad
--- /dev/null
+++ b/src/mapleall/maple_me/src/ver_symbol.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ver_symbol.h"
+#include "bb.h"
+#include "me_ssa.h"
+#include "ssa_mir_nodes.h"
+
+namespace maple {
+void VersionSt::DumpDefStmt() const {
+  if (version <= 0) {
+    return;
+  }
+  switch (defType) {
+    case kAssign:
+      defStmt.assign->Dump(0);
+      return;
+    case kPhi:
+      defStmt.phi->Dump();
+      return;
+    case kMayDef:
+      defStmt.mayDef->Dump();
+      return;
+    case kMustDef:
+      defStmt.mustDef->Dump();
+      return;
+    default:
+      ASSERT(false, "not yet implement");
+  }
+}
+
+VersionSt *VersionStTable::CreateNextVersionSt(OriginalSt *ost) {
+  ASSERT(ost->GetVersionsIndices().size() != 0, "CreateNextVersionSt: zero version must have been created first");
+  VersionSt *vst = vstAlloc.GetMemPool()->New<VersionSt>(versionStVector.size(), ost->GetVersionsIndices().size(), ost);
+  versionStVector.push_back(vst);
+  ost->PushbackVersionsIndices(vst->GetIndex());
+  vst->SetOst(ost);
+  return vst;
+}
+
+void VersionStTable::CreateZeroVersionSt(OriginalSt *ost) {
+  ASSERT_NOT_NULL(ost);
+  if (ost->GetZeroVersionIndex() != 0) {
+    return;  // already created
+  }
+  ASSERT(ost->GetVersionsIndices().size() == 0, "ssa version need to be created incrementally!");
+  VersionSt *vst = vstAlloc.GetMemPool()->New<VersionSt>(versionStVector.size(), kInitVersion, ost);
+  versionStVector.push_back(vst);
+  ost->PushbackVersionsIndices(vst->GetIndex());
+  ost->SetZeroVersionIndex(vst->GetIndex());
+  vst->SetOst(ost);
+  return;
+}
+
+VersionSt *VersionStTable::GetOrCreateZeroVersionSt(OriginalSt &ost) {
+  auto zeroVersionIndex = ost.GetZeroVersionIndex();
+  if (zeroVersionIndex == kInvalidVstIdx) {
+    CreateZeroVersionSt(&ost);
+  }
+  auto *zeroVersionVst = GetVersionStVectorItem(ost.GetZeroVersionIndex());
+  ASSERT(zeroVersionVst != nullptr, "failed in creating zero-version-vst of ost");
+  return zeroVersionVst;
+}
+
+void VersionStTable::Dump(const MIRModule *mod) const {
+  ASSERT(mod != nullptr, "nullptr check");
+  LogInfo::MapleLogger() << "=======version st table entries=======\n";
+  for (size_t i = 1; i < versionStVector.size(); ++i) {
+    const VersionSt *vst = versionStVector[i];
+    if (vst == nullptr) {
+      continue;
+    }
+    vst->Dump();
+    if (vst->GetVersion() > 0) {
+      LogInfo::MapleLogger() << " defined BB" << vst->GetDefBB()->GetBBId() << ": ";
+      vst->DumpDefStmt();
+    } else {
+      LogInfo::MapleLogger() << '\n';
+    }
+  }
+  mod->GetOut() << "=======end version st table===========\n";
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_me/src/vst_use_info.cpp b/src/mapleall/maple_me/src/vst_use_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac4818b09a21eaa8a7eafd516ceaec0c4ab6c10e
--- /dev/null
+++ b/src/mapleall/maple_me/src/vst_use_info.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "vst_use_info.h"
+#include "ssa.h"
+#include "me_cfg.h"
+
+namespace maple {
+void VstUseInfo::CollectUseInfoInExpr(BaseNode *expr, StmtNode *stmt) {
+  if (expr == nullptr) {
+    return;
+  }
+  if (expr->IsSSANode()) {
+    VersionSt *vst = static_cast<SSANode*>(expr)->GetSSAVar();
+    AddUseSiteOfVst(vst, stmt);
+  }
+  // collect from opnds
+  for (size_t i = 0; i < expr->NumOpnds(); ++i) {
+    auto *opnd = expr->Opnd(i);
+    CollectUseInfoInExpr(opnd, stmt);
+  }
+}
+
+void VstUseInfo::CollectUseInfoInStmt(StmtNode *stmt) {
+  // collect from muList
+  if (useInfoState > kVstUseInfoTopLevelVst && kOpcodeInfo.HasSSAUse(stmt->GetOpCode())) {
+    TypeOfMayUseList &mayUseList = ssaTab->GetStmtsSSAPart().GetMayUseNodesOf(*stmt);
+    for (auto it = mayUseList.begin(); it != mayUseList.end(); ++it) {
+      MayUseNode &mayUse = it->second;
+      VersionSt *vst = mayUse.GetOpnd();
+      AddUseSiteOfVst(vst, &mayUse);
+    }
+  }
+  // collect from opnds
+  for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+    auto *opnd = stmt->Opnd(i);
+    CollectUseInfoInExpr(opnd, stmt);
+  }
+}
+
+void VstUseInfo::CollectUseInfoInBB(BB *bb) {
+  if (bb == nullptr) {
+    return;
+  }
+  // collect from philist
+  const auto &phiList = bb->GetPhiList();
+  for (const auto &ost2phi : phiList) {
+    PhiNode phi = ost2phi.second;
+    for (size_t i = 0; i < phi.GetPhiOpnds().size(); ++i) {
+      AddUseSiteOfVst(phi.GetPhiOpnd(i), &phi);
+    }
+  }
+  // collect from stmts
+  for (StmtNode &stmt : bb->GetStmtNodes()) {
+    CollectUseInfoInStmt(&stmt);
+  }
+}
+
+void VstUseInfo::CollectUseInfoInFunc(MeFunction *f, Dominance *dom, VstUnseInfoState state) {
+  if (!IsUseInfoInvalid() && state <= useInfoState) { // use info has been collected before
+    return;
+  }
+  useInfoState = state; // update state
+  if (useSites == nullptr) {
+    useSites = allocator.New<MapleVector<VstUseSiteList*>>(allocator.Adapter());
+  }
+  ssaTab = f->GetMeSSATab();
+  useSites->resize(ssaTab->GetVersionStTable().GetVersionStVectorSize());
+
+  for (auto *bb : dom->GetReversePostOrder()) {
+    CollectUseInfoInBB(f->GetCfg()->GetBBFromID(BBId(bb->GetID())));
+  }
+}
+} // namespace maple
\ No newline at end of file
diff --git a/src/mapleall/maple_pgo/BUILD.gn b/src/mapleall/maple_pgo/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..268705283f198f92dac1cb7b345e3aa32d3077b6
--- /dev/null
+++ b/src/mapleall/maple_pgo/BUILD.gn
@@ -0,0 +1,30 @@
+include_libmplpgo =
+    [
+      "${MAPLEALL_ROOT}/maple_me/include",
+      "${MAPLEALL_ROOT}/maple_pgo/include",
+      "${MAPLEALL_ROOT}/maple_ipa/include",
+      "${MAPLEALL_ROOT}/maple_ipa/include/old",
+      "${MAPLEALL_ROOT}/maple_util/include",
+      "${MAPLEALL_ROOT}/mempool/include",
+      "${MAPLEALL_ROOT}/maple_ir/include",
+      "${MAPLEALL_ROOT}/mpl2mpl/include",
+      "${MAPLEALL_ROOT}/maple_be/include/cg",
+      "${MAPLEALL_ROOT}/maple_be/include/be",
+      "${MAPLEALL_ROOT}/maple_be/include/ad",
+      "${MAPLEALL_ROOT}/maple_be/include/ad/target",
+      "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+      "${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat",
+      "${MAPLEALL_ROOT}/maple_driver/include",
+    ]
+
+src_libmplpgo =
+    [
+      "src/cfg_mst.cpp",
+      "src/instrument.cpp",
+    ]
+
+configs = ["${MAPLEALL_ROOT}:mapleallcompilecfg"]
+
+static_library("libmplpgo") {
+  sources = src_libmplpgo include_dirs = include_libmplpgo output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
diff --git a/src/mapleall/maple_pgo/CMakeLists.txt b/src/mapleall/maple_pgo/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f9cfd28c683e3deddf1ca9249f57e8d39a3b1b6b
--- /dev/null
+++ b/src/mapleall/maple_pgo/CMakeLists.txt
@@ -0,0 +1,51 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#   http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN AS IS BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(inc_dirs
+  ${MAPLEALL_ROOT}
+  ${MAPLEALL_ROOT}/maple_be/include
+  ${MAPLEALL_ROOT}/maple_be/include/cg
+  ${MAPLEALL_ROOT}/maple_be/include/be
+  ${MAPLEALL_ROOT}/maple_be/include/ad
+  ${MAPLEALL_ROOT}/maple_pgo/include/
+  ${MAPLE_BUILD_OUTPUT}/common/target
+  ${MAPLEALL_ROOT}/maple_driver/defs
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${MAPLEALL_ROOT}/maple_util/include
+  ${MAPLEALL_ROOT}/mpl2mpl/include
+  ${MAPLEALL_ROOT}/maple_me/include
+  ${MAPLEALL_ROOT}/maple_ipa/include
+  ${MAPLEALL_ROOT}/maple_ipa/include/old
+  ${MAPLEALL_ROOT}/maple_phase/include
+  ${MAPLEALL_ROOT}/maple_ir/include
+  ${MAPLEALL_ROOT}/mempool/include
+  ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+  ${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat
+)
+
+set(src_libmaplepgo
+  src/instrument.cpp
+  src/cfg_mst.cpp
+)
+
+#libmaplepgo
+add_library(libmaplepgo STATIC ${src_libmaplepgo})
+
+set_target_properties(libmaplepgo PROPERTIES
+  COMPILE_FLAGS ""
+  INCLUDE_DIRECTORIES "${inc_dirs}"
+  LINK_LIBRARIES ""
+  RUNTIME_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}"
+)
diff --git a/src/mapleall/maple_pgo/include/cfg_mst.h b/src/mapleall/maple_pgo/include/cfg_mst.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a3f3614bfe71d35e47397a0ec4953aa3483d28c
--- /dev/null
+++ b/src/mapleall/maple_pgo/include/cfg_mst.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_PGO_INCLUDE_CFG_MST_H
+#define MAPLE_PGO_INCLUDE_CFG_MST_H
+
+#include "types_def.h"
+#include "mempool.h"
+
+namespace maple {
+template <class Edge, class BB>
+class CFGMST {
+ public:
+  explicit CFGMST(MemPool &mp) : mp(&mp) {}
+  virtual ~CFGMST() = default;
+  void ComputeMST(BB *commonEntry, BB *commonExit);
+  void BuildEdges(BB *commonEntry, BB *commonExit);
+  void SortEdges();
+  void AddEdge(BB *src, BB *dest, uint64 w, bool isCritical = false, bool isFake = false);
+  bool IsCritialEdge(const BB *src, const BB *dest) const {
+    return src->GetSuccs().size() > 1 && dest->GetPreds().size() > 1;
+  }
+  const std::vector<Edge*> &GetAllEdges() const {
+    return allEdges;
+  }
+
+  size_t GetAllEdgesSize() const {
+    return allEdges.size();
+  }
+
+  uint32 GetAllBBs() const {
+    return totalBB;
+  }
+
+  void GetInstrumentEdges(std::vector<Edge*> &instrumentEdges) const {
+    for (const auto &e : allEdges) {
+      if (!e->IsInMST()) {
+        instrumentEdges.push_back(e);
+      }
+    }
+  }
+  void DumpEdgesInfo() const;
+ private:
+  uint32 FindGroup(uint32 bbId);
+  bool UnionGroups(uint32 srcId, uint32 destId);
+  static constexpr int normalEdgeWeight = 2;
+  static constexpr int exitEdgeWeight = 3;
+  static constexpr int fakeExitEdgeWeight = 4;
+  static constexpr int criticalEdgeWeight = 4;
+  MemPool *mp;
+  std::vector<Edge*> allEdges;
+  std::map<uint32, uint32> bbGroups; // bbId - gourpId
+  uint32 totalBB = 0;
+};
+} /* namespace maple */
+#endif // MAPLE_PGO_INCLUDE_CFG_MST_H
diff --git a/src/mapleall/maple_pgo/include/instrument.h b/src/mapleall/maple_pgo/include/instrument.h
new file mode 100644
index 0000000000000000000000000000000000000000..1166d20db812c72eec008c9e480fcb153eacc0dc
--- /dev/null
+++ b/src/mapleall/maple_pgo/include/instrument.h
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_PGO_INCLUDE_INSTRUMENT_H
+#define MAPLE_PGO_INCLUDE_INSTRUMENT_H
+
+#include "types_def.h"
+#include "cfg_mst.h"
+#include "mir_function.h"
+
+namespace maple {
+MIRSymbol *GetOrCreateProfSymForFunc(MIRFunction &func, uint32 elemCnt);
+
+template<typename BB>
+class BBEdge {
+ public:
+  BBEdge(BB *src, BB *dest, uint64 w = 1, bool isCritical = false, bool isFake = false)
+      : srcBB(src), destBB(dest), weight(w), inMST(false), isCritical(isCritical), isFake(isFake) {}
+
+  ~BBEdge() = default;
+
+  BB *GetSrcBB() const {
+    return srcBB;
+  }
+
+  BB *GetDestBB() const {
+    return destBB;
+  }
+
+  uint64 GetWeight() const {
+    return weight;
+  }
+
+  void SetWeight(uint64 w) {
+    weight = w;
+  }
+
+  bool IsCritical() const {
+    return isCritical;
+  }
+
+  bool IsFake() const {
+    return isFake;
+  }
+
+  bool IsInMST() const {
+    return inMST;
+  }
+
+  void SetInMST() {
+    inMST = true;
+  }
+
+  int32 GetCondition() const {
+    return condition;
+  }
+
+  void SetCondition(int32 cond) {
+    condition = cond;
+  }
+
+  bool IsBackEdge() const {
+    return isBackEdge;
+  }
+
+  void SetIsBackEdge() {
+    isBackEdge = true;
+  }
+
+ private:
+  BB *srcBB;
+  BB *destBB;
+  uint64 weight;
+  bool inMST;
+  bool isCritical;
+  bool isFake;
+  int32 condition = -1;
+  bool isBackEdge = false;
+};
+
+template<typename BB>
+class BBUseEdge : public BBEdge<BB> {
+ public:
+  BBUseEdge(BB *src, BB *dest, uint64 w = 1, bool isCritical = false, bool isFake = false)
+      : BBEdge<BB>(src, dest, w, isCritical, isFake) {}
+  virtual ~BBUseEdge() = default;
+  void SetCount(uint64 value) {
+    countValue = value;
+    valid = true;
+  }
+
+  uint64 GetCount() const {
+    return countValue;
+  }
+
+  bool GetStatus() const {
+    return valid;
+  }
+ private:
+  bool valid = false;
+  uint64 countValue = 0;
+};
+
+template<class IRBB, class Edge>
+class PGOInstrumentTemplate {
+ public:
+  explicit PGOInstrumentTemplate(MemPool &mp) : mst(mp) {}
+
+  void GetInstrumentBBs(std::vector<IRBB*> &bbs, IRBB *commonEnty) const;
+  void PrepareInstrumentInfo(IRBB *commonEntry, IRBB* commmonExit) {
+    mst.ComputeMST(commonEntry, commmonExit);
+  }
+  const std::vector<Edge*> &GetAllEdges() {
+    return mst.GetAllEdges();
+  }
+ private:
+  CFGMST<Edge, IRBB> mst;
+};
+
+template<typename BB>
+class BBUseInfo {
+ public:
+  explicit BBUseInfo(MemPool &tmpPool)
+      : innerAlloc(&tmpPool), inEdges(innerAlloc.Adapter()), outEdges(innerAlloc.Adapter()) {}
+  virtual ~BBUseInfo() = default;
+  void SetCount(uint64 value) {
+    countValue = value;
+    valid = true;
+  }
+  uint64 GetCount() const {
+    return countValue;
+  }
+
+  bool GetStatus() const {
+    return valid;
+  }
+
+  void AddOutEdge(BBUseEdge<BB> *e) {
+    outEdges.push_back(e);
+    if (!e->GetStatus()) {
+      unknownOutEdges++;
+    }
+  }
+
+  void AddInEdge(BBUseEdge<BB> *e) {
+    inEdges.push_back(e);
+    if (!e->GetStatus()) {
+      unknownInEdges++;
+    }
+  }
+
+  const MapleVector<BBUseEdge<BB>*> &GetInEdges() const {
+    return inEdges;
+  }
+
+  MapleVector<BBUseEdge<BB>*> &GetInEdges() {
+    return inEdges;
+  }
+
+  size_t GetInEdgeSize() const {
+    return inEdges.size();
+  }
+
+  const MapleVector<BBUseEdge<BB>*> &GetOutEdges() const {
+    return outEdges;
+  }
+
+  MapleVector<BBUseEdge<BB>*> &GetOutEdges() {
+    return outEdges;
+  }
+
+  size_t GetOutEdgeSize() const {
+    return outEdges.size();
+  }
+
+  void DecreaseUnKnownOutEdges() {
+    unknownOutEdges--;
+  }
+
+  void DecreaseUnKnownInEdges() {
+    unknownInEdges--;
+  }
+
+  uint32 GetUnknownOutEdges() const {
+    return unknownOutEdges;
+  }
+
+  BBUseEdge<BB> *GetOnlyUnknownOutEdges();
+
+  uint32 GetUnknownInEdges() const {
+    return unknownInEdges;
+  }
+
+  BBUseEdge<BB> *GetOnlyUnknownInEdges();
+
+ private:
+  bool valid = false;
+  uint64 countValue = 0;
+  uint32 unknownInEdges = 0;
+  uint32 unknownOutEdges = 0;
+  MapleAllocator innerAlloc;
+  MapleVector<BBUseEdge<BB>*> inEdges;
+  MapleVector<BBUseEdge<BB>*> outEdges;
+};
+} /* namespace maple */
+#endif // MAPLE_PGO_INCLUDE_INSTRUMENT_H
diff --git a/src/mapleall/maple_pgo/src/cfg_mst.cpp b/src/mapleall/maple_pgo/src/cfg_mst.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..82223ed80b944150fd268a0a5ad8a52f09a72aa5
--- /dev/null
+++ b/src/mapleall/maple_pgo/src/cfg_mst.cpp
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "cfg_mst.h"
+#include "cgbb.h"
+#include "instrument.h"
+namespace maple {
+template <class Edge, class BB>
+void CFGMST<Edge, BB>::BuildEdges(BB *commonEntry, BB *commonExit) {
+  for (auto *curbb = commonEntry; curbb != nullptr; curbb = curbb->GetNext()) {
+    bbGroups[curbb->GetId()] = curbb->GetId();
+    if (curbb == commonExit) {
+      continue;
+    }
+    totalBB++;
+    for (auto *succBB : curbb->GetSuccs()) {
+      // exitBB incoming edge allocate high weight
+      if (succBB->GetKind() == BB::BBKind::kBBReturn) {
+        AddEdge(curbb, succBB, exitEdgeWeight);
+        continue;
+      }
+      if (IsCritialEdge(curbb, succBB)) {
+        AddEdge(curbb, succBB, criticalEdgeWeight, true);
+        continue;
+      }
+      AddEdge(curbb, succBB, normalEdgeWeight);
+    }
+  }
+
+  for (BB *bb : commonExit->GetPreds()) {
+    AddEdge(bb, commonExit, fakeExitEdgeWeight, false, true);
+  }
+  bbGroups[commonExit->GetId()] = commonExit->GetId();
+  // insert fake edge to keep consistent
+  AddEdge(commonExit, commonEntry, UINT64_MAX, false, true);
+}
+
+template <class Edge, class BB>
+void CFGMST<Edge, BB>::ComputeMST(BB *commonEntry, BB *commonExit) {
+  BuildEdges(commonEntry, commonExit);
+  SortEdges();
+  /* only one edge means only one bb */
+  if (allEdges.size() == 1) {
+    LogInfo::MapleLogger() << "only one edge find " << std::endl;
+    return;
+  }
+  // first,put all critial edge,with destBB is eh-handle
+  // in mst,because current doesn't support split that edge
+  for (auto &e : allEdges) {
+    if (UnionGroups(e->GetSrcBB()->GetId(), e->GetDestBB()->GetId())) {
+      e->SetInMST();
+    }
+  }
+}
+
+template <class Edge, class BB>
+void CFGMST<Edge, BB>::AddEdge(BB *src, BB *dest, uint64 w, bool isCritical, bool isFake) {
+  if (src == nullptr || dest == nullptr) {
+    return;
+  }
+  bool found = false;
+  for (auto &edge : allEdges) {
+    if (edge->GetSrcBB() == src && edge->GetDestBB() == dest) {
+      uint64 weight = edge->GetWeight();
+      weight++;
+      edge->SetWeight(weight);
+      found = true;
+    }
+  }
+  if (!found) {
+    (void)allEdges.emplace_back(mp->New<Edge>(src, dest, w, isCritical, isFake));
+  }
+}
+
+template <class Edge, class BB>
+void CFGMST<Edge, BB>::SortEdges() {
+  std::stable_sort(allEdges.begin(), allEdges.end(),
+                   [](const Edge *edge1, const Edge *edge2) { return edge1->GetWeight() > edge2->GetWeight(); });
+}
+
+template <class Edge, class BB>
+uint32 CFGMST<Edge, BB>::FindGroup(uint32 bbId) {
+  CHECK_FATAL(bbGroups.count(bbId), "unRegister bb");
+  if (bbGroups[bbId] != bbId) {
+    bbGroups[bbId] = FindGroup(bbGroups[bbId]);
+  }
+  return bbGroups[bbId];
+}
+
+template <class Edge, class BB>
+bool CFGMST<Edge, BB>::UnionGroups(uint32 srcId, uint32 destId) {
+  uint32 srcGroupId = FindGroup(srcId);
+  uint32 destGroupId = FindGroup(destId);
+  if (srcGroupId == destGroupId) {
+    return false;
+  }
+  bbGroups[srcGroupId] = destGroupId;
+  return true;
+}
+template <class Edge, class BB>
+void CFGMST<Edge, BB>::DumpEdgesInfo() const {
+  for (auto &edge : allEdges) {
+    BB *src = edge->GetSrcBB();
+    BB *dest = edge->GetDestBB();
+    LogInfo::MapleLogger() << "BB" << src->GetId() << "->"
+                           << "BB" << dest->GetId() << " weight " << edge->GetWeight();
+    if (edge->IsInMST()) {
+      LogInfo::MapleLogger() << " in Mst\n";
+    } else {
+      LogInfo::MapleLogger() << " not in  Mst\n";
+    }
+  }
+}
+
+template class CFGMST<maple::BBEdge<maplebe::BB>, maplebe::BB>;
+template class CFGMST<maple::BBUseEdge<maplebe::BB>, maplebe::BB>;
+}
diff --git a/src/mapleall/maple_pgo/src/instrument.cpp b/src/mapleall/maple_pgo/src/instrument.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..34dca8974454ea5416bc554fa85cb9b359ae2193
--- /dev/null
+++ b/src/mapleall/maple_pgo/src/instrument.cpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "instrument.h"
+#include "cgbb.h"
+#include "itab_util.h"
+#include "mir_builder.h"
+namespace maple {
+std::string GetProfCntSymbolName(const std::string &moduleName, const std::string &funcName) {
+  std::string moduleHashStr = std::to_string(DJBHash(moduleName.c_str()));
+  std::string joiner("$$");
+  return namemangler::kBBProfileTabPrefixStr + joiner + moduleHashStr + joiner + funcName;
+}
+
+MIRSymbol *GetOrCreateProfSymForFunc(MIRFunction &func, uint32 elemCnt) {
+  auto *mirModule = func.GetModule();
+  std::string name = GetProfCntSymbolName(mirModule->GetFileName(), func.GetName());
+  auto nameStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(name);
+  MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(nameStrIdx);
+  if (sym != nullptr) {
+    return sym;
+  }
+  auto *elemType = GlobalTables::GetTypeTable().GetUInt64();
+  MIRArrayType &arrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*elemType, elemCnt);
+  sym = mirModule->GetMIRBuilder()->CreateGlobalDecl(name.c_str(), arrayType);
+  MIRAggConst *profTab = mirModule->GetMemPool()->New<MIRAggConst>(
+      *mirModule, *elemType);
+  MIRIntConst *indexConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *elemType);
+  MIRIntConst *ibbSizeConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(elemCnt, *elemType);
+  profTab->AddItem(ibbSizeConst, 0);
+  for (uint32 i = 1; i < elemCnt; ++i) {
+    profTab->AddItem(indexConst, i);
+  }
+  sym->SetKonst(profTab);
+  sym->SetStorageClass(kScGlobal);
+  return sym;
+}
+
+template<class IRBB, class Edge>
+void PGOInstrumentTemplate<IRBB, Edge>::GetInstrumentBBs(std::vector<IRBB*> &bbs, IRBB* commonEntry) const {
+  std::vector<Edge*> iEdges;
+  mst.GetInstrumentEdges(iEdges);
+  std::unordered_set<IRBB*> visitedBBs;
+  for (auto &edge : iEdges) {
+    IRBB *src = edge->GetSrcBB();
+    IRBB *dest = edge->GetDestBB();
+    if (src->GetSuccs().size() <= 1) {
+      if (src == commonEntry) {
+        bbs.push_back(dest);
+      } else {
+        bbs.push_back(src);
+      }
+    } else if (!edge->IsCritical()) {
+      bbs.push_back(dest);
+    } else {
+      if (src->GetKind() == IRBB::kBBIgoto) {
+        if (visitedBBs.find(dest) == visitedBBs.end()) {
+          // In this case, we have to instrument it anyway
+          bbs.push_back(dest);
+          (void)visitedBBs.insert(dest);
+        }
+      } else {
+        CHECK_FATAL(false, "Unexpected case %d -> %d", src->GetId(), dest->GetId());
+      }
+    }
+  }
+}
+
+template<typename BB>
+BBUseEdge<BB> *BBUseInfo<BB>::GetOnlyUnknownOutEdges() {
+  BBUseEdge<BB> *ouEdge = nullptr;
+  for (auto *e : outEdges) {
+    if (!e->GetStatus()) {
+      CHECK_FATAL(!ouEdge, "have multiple unknown out edges");
+      ouEdge = e;
+    }
+  }
+  return ouEdge;
+}
+
+template<typename BB>
+BBUseEdge<BB> *BBUseInfo<BB>::GetOnlyUnknownInEdges() {
+  BBUseEdge<BB> *ouEdge = nullptr;
+  for (auto *e : inEdges) {
+    if (!e->GetStatus()) {
+      CHECK_FATAL(!ouEdge, "have multiple unknown in edges");
+      ouEdge = e;
+    }
+  }
+  return ouEdge;
+}
+
+template class PGOInstrumentTemplate<maplebe::BB, maple::BBEdge<maplebe::BB>>;
+template class PGOInstrumentTemplate<maplebe::BB, maple::BBUseEdge<maplebe::BB>>;
+template class BBUseInfo<maplebe::BB>;
+} /* namespace maple */
diff --git a/src/mapleall/maple_phase/BUILD.gn b/src/mapleall/maple_phase/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..ea1b01b876fd4c08587e4d7c6c0199490bf22f63
--- /dev/null
+++ b/src/mapleall/maple_phase/BUILD.gn
@@ -0,0 +1,48 @@
+#
+#Copyright(c)[2020 - 2021] Huawei Technologies Co., Ltd.All rights reserved.
+#
+#OpenArkCompiler is licensed under Mulan PSL v2.
+#You can use this software according to the terms and conditions of the Mulan PSL v2.
+#You may obtain a copy of Mulan PSL v2 at:
+#
+#http:  // license.coscl.org.cn/MulanPSL2
+#
+#THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+#EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON - INFRINGEMENT, MERCHANTABILITY OR
+#FIT FOR A PARTICULAR PURPOSE.
+#See the Mulan PSL v2 for more details.
+#
+include_libmplphase =
+    [
+      "${MAPLEALL_ROOT}/maple_me/include",
+      "${MAPLEALL_ROOT}/maple_ipa/include",
+      "${MAPLEALL_ROOT}/maple_ipa/include/old",
+      "${MAPLEALL_ROOT}/maple_util/include",
+      "${MAPLEALL_ROOT}/mempool/include",
+      "${MAPLEALL_ROOT}/maple_phase/include",
+      "${MAPLEALL_ROOT}/maple_ir/include",
+      "${MAPLEALL_ROOT}/mpl2mpl/include",
+      "${MAPLEALL_ROOT}/maple_be/include/cg",
+      "${MAPLEALL_ROOT}/maple_be/include/be",
+      "${MAPLEALL_ROOT}/maple_be/include/ad",
+      "${MAPLEALL_ROOT}/maple_be/include/ad/target",
+      "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+      "${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat",
+      "${MAPLEALL_ROOT}/maple_driver/include",
+    ]
+
+src_libmplphase =
+    [
+      "src/phase_impl.cpp",
+      "src/maple_phase.cpp",
+      "src/maple_phase_manager.cpp",
+      "src/phase_driver.cpp",
+      "src/maple_phase_support.cpp",
+    ]
+
+configs = ["${MAPLEALL_ROOT}:mapleallcompilecfg"]
+
+static_library("libmplphase") {
+  sources = src_libmplphase include_dirs = include_libmplphase output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
+
diff --git a/src/mapleall/maple_phase/CMakeLists.txt b/src/mapleall/maple_phase/CMakeLists.txt
new file mode 100755
index 0000000000000000000000000000000000000000..0f8f3d5d2ffe32fc64e3c8958e1d8ddab884c27e
--- /dev/null
+++ b/src/mapleall/maple_phase/CMakeLists.txt
@@ -0,0 +1,49 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+# http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN AS IS BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(inc_libmplphase
+    ${MAPLEALL_ROOT}/maple_me/include
+    ${MAPLEALL_ROOT}/maple_ipa/include
+    ${MAPLEALL_ROOT}/maple_ipa/include/old
+    ${MAPLEALL_ROOT}/maple_util/include
+    ${MAPLEALL_ROOT}/mempool/include
+    ${MAPLEALL_ROOT}/maple_phase/include
+    ${MAPLEALL_ROOT}/maple_ir/include
+    ${MAPLEALL_ROOT}/mpl2mpl/include
+    ${MAPLEALL_ROOT}/maple_be/include/cg
+    ${MAPLEALL_ROOT}/maple_be/include/be
+    ${MAPLEALL_ROOT}/maple_be/include/ad
+    ${MAPLEALL_ROOT}/maple_be/include/ad/target
+    ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+    ${THIRD_PARTY_ROOT}/llvm_modified/llvm/include/llvm/BinaryFormat
+    ${MAPLEALL_ROOT}/maple_driver/include
+)
+
+set(src_libmplphase
+    src/phase_impl.cpp
+    src/maple_phase.cpp
+    src/maple_phase_manager.cpp
+    src/phase_driver.cpp
+    src/maple_phase_support.cpp
+)
+
+#libmplphase
+add_library(libmplphase STATIC ${src_libmplphase})
+set_target_properties(libmplphase PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${inc_libmplphase}"
+    LINK_LIBRARIES ""
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
diff --git a/src/mapleall/maple_phase/include/maple_phase.h b/src/mapleall/maple_phase/include/maple_phase.h
new file mode 100644
index 0000000000000000000000000000000000000000..b5df219bf38e46fdd22de7b4006461557e319949
--- /dev/null
+++ b/src/mapleall/maple_phase/include/maple_phase.h
@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_PHASE_INCLUDE_MAPLE_PHASE_H
+#define MAPLE_PHASE_INCLUDE_MAPLE_PHASE_H
+#include "maple_phase_support.h"
+namespace maple {
+class MaplePhase;
+class AnalysisInfoHook;
+class MIRModule;
+enum MaplePhaseKind : uint8 {
+    kModulePM,
+    kModulePhase,
+    kFunctionPM,
+    kFunctionPhase,
+    kSccPhasePM,
+    kSccPhase
+};
+
+class MaplePhase {
+ public:
+  MaplePhase(MaplePhaseKind kind, MaplePhaseID id, MemPool &mp)
+      : phaseAllocator(&mp),
+        phaseKind(kind),
+        phaseID(id),
+        tempMemPools(phaseAllocator.Adapter()) {}
+  virtual ~MaplePhase() {
+    if (analysisInfo != nullptr) {
+      analysisInfo = nullptr;
+    }
+  };
+  void Dump() const;
+  const MaplePhaseID GetPhaseID() const {
+    return phaseID;
+  }
+  void SetPhaseID(MaplePhaseID id) {
+    phaseID = id;
+  }
+  virtual std::string PhaseName() const = 0;
+  void SetAnalysisInfoHook(AnalysisInfoHook *hook);
+  AnalysisInfoHook *GetAnalysisInfoHook();
+
+  void AnalysisDepInit(AnalysisDep &aDep) const;
+  MapleAllocator *GetPhaseAllocator() {
+    return &phaseAllocator;
+  }
+  MemPool *GetPhaseMemPool() {
+    return phaseAllocator.GetMemPool();
+  }
+
+  MemPool *ApplyTempMemPool();
+  void ClearTempMemPool();
+
+ private:
+  MapleAllocator phaseAllocator;  //  mempool for phase
+  AnalysisInfoHook *analysisInfo = nullptr;
+  virtual void GetAnalysisDependence(AnalysisDep &aDep) const;
+  MaplePhaseKind phaseKind;
+  MaplePhaseID phaseID;
+  MapleVector<MemPool*> tempMemPools; // delete after phase Run  [Thread Local]
+};
+
+class MapleModulePhase : public MaplePhase {
+ public:
+  MapleModulePhase(MaplePhaseID id, MemPool *mp) : MaplePhase(kModulePhase, id, *mp) {}
+  ~MapleModulePhase() override = default;
+
+  virtual bool PhaseRun(MIRModule &m) = 0;
+};
+
+template <class funcT>
+class MapleFunctionPhase : public MaplePhase {
+ public:
+  MapleFunctionPhase(MaplePhaseID id, MemPool *mp) : MaplePhase(kFunctionPhase, id, *mp) {}
+  ~MapleFunctionPhase() override = default;
+  virtual bool PhaseRun(funcT &f) = 0;
+};
+
+template <class SccT>
+class MapleSccPhase : public MaplePhase {
+ public:
+  MapleSccPhase(MaplePhaseID id, MemPool *mp) : MaplePhase(kSccPhase, id, *mp) {}
+  ~MapleSccPhase() override = default;
+  virtual bool PhaseRun(SccT &scc) = 0;
+  template <class funcT>
+  void Dump(funcT &f, const std::string phaseName);
+};
+
+class MaplePhaseRegister {
+ public:
+  MaplePhaseRegister() = default;
+  ~MaplePhaseRegister() = default;
+
+  static MaplePhaseRegister *GetMaplePhaseRegister();
+  void RegisterPhase(const MaplePhaseInfo &pi);
+  const MaplePhaseInfo *GetPhaseByID(MaplePhaseID id);
+  const auto &GetAllPassInfo() const {
+    return passInfoMap;
+  }
+ private:
+  std::map<MaplePhaseID, const MaplePhaseInfo*> passInfoMap;
+};
+
+template<typename phaseNameT>
+class RegisterPhase : public MaplePhaseInfo {
+ public:
+  explicit RegisterPhase(const std::string name, bool isAnalysis = false, bool cfgOnly = false, bool canSkip = false)
+      : MaplePhaseInfo(name, &phaseNameT::id, isAnalysis, cfgOnly, canSkip) {
+    SetConstructor(phaseNameT::CreatePhase);
+    auto globalRegistry = maple::MaplePhaseRegister::GetMaplePhaseRegister();
+    globalRegistry->RegisterPhase(*this);
+  }
+  ~RegisterPhase() = default;
+};
+
+#define PHASECONSTRUCTOR(PHASENAME)                                  \
+  static unsigned int id;                                            \
+  static MaplePhase *CreatePhase(MemPool *createMP){                 \
+    return createMP->New<PHASENAME>(createMP);                       \
+  }
+
+#define OVERRIDE_DEPENDENCE                                             \
+ private:                                                               \
+  void GetAnalysisDependence(maple::AnalysisDep &aDep) const override;
+
+#define MAPLE_FUNC_PHASE_DECLARE_BEGIN(PHASENAME, IRTYPE)                  \
+class PHASENAME : public MapleFunctionPhase<IRTYPE> {                      \
+ public:                                                                   \
+  explicit PHASENAME(MemPool *mp) : MapleFunctionPhase<IRTYPE>(&id, mp) {} \
+  ~PHASENAME() override = default;                                         \
+  std::string PhaseName() const override;                                  \
+  static unsigned int id;                                                  \
+  static MaplePhase *CreatePhase(MemPool *createMP) {                      \
+    return createMP->New<PHASENAME>(createMP);                             \
+  }                                                                        \
+  bool PhaseRun(IRTYPE &f) override;
+
+#define MAPLE_FUNC_PHASE_DECLARE_END \
+};
+
+#define MAPLE_SCC_PHASE_DECLARE_BEGIN(PHASENAME, IRTYPE)                   \
+class PHASENAME : public MapleSccPhase<IRTYPE> {                           \
+ public:                                                                   \
+  explicit PHASENAME(MemPool *mp) : MapleSccPhase<IRTYPE>(&id, mp) {}      \
+  ~PHASENAME() override = default;                                         \
+  std::string PhaseName() const override;                                  \
+  static unsigned int id;                                                  \
+  static MaplePhase *CreatePhase(MemPool *createMP) {                      \
+    return createMP->New<PHASENAME>(createMP);                             \
+  }                                                                        \
+  bool PhaseRun(IRTYPE &scc) override;
+
+#define MAPLE_SCC_PHASE_DECLARE_END \
+};
+
+#define MAPLE_FUNC_PHASE_DECLARE(PHASENAME, IRTYPE)                \
+MAPLE_FUNC_PHASE_DECLARE_BEGIN(PHASENAME, IRTYPE)                  \
+OVERRIDE_DEPENDENCE                                                \
+MAPLE_FUNC_PHASE_DECLARE_END
+
+#define MAPLE_MODULE_PHASE_DECLARE_BEGIN(PHASENAME)                \
+class PHASENAME : public MapleModulePhase {                        \
+ public:                                                           \
+  explicit PHASENAME(MemPool *mp) : MapleModulePhase(&id, mp) {}   \
+  ~PHASENAME() override = default;                                 \
+  std::string PhaseName() const override;                          \
+  static unsigned int id;                                          \
+  static MaplePhase *CreatePhase(MemPool *createMP) {              \
+    return createMP->New<PHASENAME>(createMP);                     \
+  }                                                                \
+  bool PhaseRun(MIRModule &m) override;
+
+#define MAPLE_MODULE_PHASE_DECLARE_END \
+};
+
+#define MAPLE_MODULE_PHASE_DECLARE(PHASENAME)             \
+MAPLE_MODULE_PHASE_DECLARE_BEGIN(PHASENAME)               \
+OVERRIDE_DEPENDENCE                                       \
+MAPLE_MODULE_PHASE_DECLARE_END
+
+#define MAPLE_ANALYSIS_PHASE_REGISTER(CLASSNAME, PHASENAME)               \
+unsigned int CLASSNAME::id = 0;                                           \
+std::string CLASSNAME::PhaseName() const { return #PHASENAME; }           \
+static RegisterPhase<CLASSNAME> MAPLEPHASE_##PHASENAME(#PHASENAME, true);
+
+#define MAPLE_TRANSFORM_PHASE_REGISTER(CLASSNAME, PHASENAME)              \
+unsigned int CLASSNAME::id = 0;                                           \
+std::string CLASSNAME::PhaseName() const { return #PHASENAME; }           \
+static RegisterPhase<CLASSNAME> MAPLEPHASE_##PHASENAME(#PHASENAME, false);
+
+#define MAPLE_ANALYSIS_PHASE_REGISTER_CANSKIP(CLASSNAME, PHASENAME)                    \
+unsigned int CLASSNAME::id = 0;                                                        \
+std::string CLASSNAME::PhaseName() const { return #PHASENAME; }                        \
+static RegisterPhase<CLASSNAME> MAPLEPHASE_##PHASENAME(#PHASENAME, true, false, true);
+
+#define MAPLE_TRANSFORM_PHASE_REGISTER_CANSKIP(CLASSNAME, PHASENAME)                    \
+unsigned int CLASSNAME::id = 0;                                                         \
+std::string CLASSNAME::PhaseName() const { return #PHASENAME; }                         \
+static RegisterPhase<CLASSNAME> MAPLEPHASE_##PHASENAME(#PHASENAME, false, false, true);
+
+#define GET_ANALYSIS(PHASENAME, PHASEKEY)                               \
+static_cast<PHASENAME*>(                                                \
+    GetAnalysisInfoHook()->FindAnalysisData((PHASEKEY).GetUniqueID(), this, &PHASENAME::id))->GetResult()
+
+#define EXEC_ANALYSIS(PHASENAME, PHASEKEY)                               \
+static_cast<PHASENAME*>(GetAnalysisInfoHook()->FindAnalysisData((PHASEKEY).GetUniqueID(), this, &PHASENAME::id))
+
+#define FORCE_GET(PHASENAME) \
+static_cast<PHASENAME*>(     \
+    GetAnalysisInfoHook()->ForceRunAnalysisPhase<MeFuncOptTy, MeFunction>(&PHASENAME::id, f))->GetResult()
+
+#define FORCE_EXEC(PHASENAME) \
+static_cast<PHASENAME*>(GetAnalysisInfoHook()->ForceRunAnalysisPhase<MeFuncOptTy, MeFunction>(&PHASENAME::id, f))
+
+#define FORCE_INVALID(PHASENAME, PHASEKEY) \
+GetAnalysisInfoHook()->ForceEraseAnalysisPhase(PHASEKEY.GetUniqueID(), &PHASENAME::id)
+}
+
+#endif  // MAPLE_ME_INCLUDE_ME_PHASE_MANAGER_H
diff --git a/src/mapleall/maple_phase/include/maple_phase_manager.h b/src/mapleall/maple_phase/include/maple_phase_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..6cdc8d9545ab63cb9fd8da73b0309afd7a2f740c
--- /dev/null
+++ b/src/mapleall/maple_phase/include/maple_phase_manager.h
@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_PHASE_INCLUDE_MAPLE_PHASE_MANAGER_H
+#define MAPLE_PHASE_INCLUDE_MAPLE_PHASE_MANAGER_H
+#include "maple_phase.h"
+#include "me_option.h"
+#include "call_graph.h"
+
+namespace maple {
+class MaplePhase;
+using AnalysisMemKey = std::pair<uint32, MaplePhaseID>;
+class AnalysisDataManager {
+ public:
+  explicit AnalysisDataManager(MemPool &mempool)
+      : allocator(&mempool),
+        analysisPhaseMemPool(allocator.Adapter()),
+        availableAnalysisPhases(allocator.Adapter()) {
+    innerCtrler = &mempool.GetCtrler();
+  }
+
+  ~AnalysisDataManager() = default;
+
+  bool UseGlobalMpCtrler() const {
+    return useGlobalMpCtrler;
+  }
+
+  void CopyAnalysisResultFrom(const AnalysisDataManager &other) {
+    analysisPhaseMemPool = other.analysisPhaseMemPool;
+    availableAnalysisPhases = other.availableAnalysisPhases;
+  }
+
+  MemPool *ApplyMemPoolForAnalysisPhase(uint32 phaseKey, const MaplePhaseInfo &pi);
+  void AddAnalysisPhase(uint32 phaseKey, MaplePhase *p);
+  bool CheckAnalysisInfoEmpty() const {
+    return analysisPhaseMemPool.empty() && availableAnalysisPhases.empty();
+  }
+  void EraseAnalysisPhase(uint32 phaseKey, MaplePhaseID pid);
+  void EraseAllAnalysisPhase();
+  void EraseAnalysisPhase(MapleMap<AnalysisMemKey, MaplePhase*>::iterator &anaPhaseMapIt);
+  void ClearInVaildAnalysisPhase(uint32 phaseKey, AnalysisDep &aDep);                      // do after transform phase;
+  MaplePhase *GetVaildAnalysisPhase(uint32 phaseKey, MaplePhaseID pid);
+  bool IsAnalysisPhaseAvailable(uint32 phaseKey, MaplePhaseID pid);
+  void Dump();
+ private:
+  MapleAllocator allocator;  // thread local
+  MemPoolCtrler* innerCtrler = nullptr;
+  MapleMap<AnalysisMemKey, MemPool*> analysisPhaseMemPool;
+  MapleMap<AnalysisMemKey, MaplePhase*> availableAnalysisPhases;
+  bool useGlobalMpCtrler = false;
+};
+
+/* top level manager [manages phase managers/ immutable pass(not implement yet)] */
+class MaplePhaseManager {
+ public:
+  explicit MaplePhaseManager(MemPool &memPool)
+      : allocator(&memPool),
+        phasesSequence(allocator.Adapter()),
+        analysisDepMap(allocator.Adapter()),
+        threadMemPools(allocator.Adapter()),
+        analysisDataManagers(allocator.Adapter()) {}
+
+  virtual ~MaplePhaseManager() {
+    phaseTh = nullptr;
+  }
+
+  MemPool *GetManagerMemPool() {
+    return allocator.GetMemPool();
+  }
+
+  void ClearAllPhases() {
+    phasesSequence.clear();
+  }
+
+#define ADDMAPLEPHASE(PhaseName, condition) \
+  AddPhase(PhaseName, condition);
+#define ADDMAPLEMEPHASE(PhaseName, condition)   \
+  if (!MeOption::IsSkipPhase(PhaseName)) {      \
+    AddPhase(PhaseName, condition);             \
+  }
+#define ADDMODULEPHASE(PhaseName, condition)                  \
+  if (!Options::IsSkipPhase(PhaseName) && IsRunMpl2Mpl()) {   \
+    AddPhase(PhaseName, condition);                           \
+  }
+  void AddPhase(const std::string &phaseName, bool condition);
+  AnalysisDep *FindAnalysisDep(const MaplePhase &phase);
+
+  void SetQuiet(bool value) {
+    quiet = value;
+  }
+
+  bool IsQuiet() const {
+    return quiet;
+  }
+
+  void LogDependence(const MaplePhaseInfo &curPhase, int depLev) const {
+    std::string prefix = "";
+    while (depLev > 0) {
+      prefix += "  ";
+      depLev--;
+    }
+    if (!IsQuiet()) {
+      LogInfo::MapleLogger() << prefix << "  ++ trigger phase [ " << curPhase.PhaseName() << " ]\n";
+    }
+  }
+
+  void SolveSkipFrom(const std::string &phaseName, size_t &i);
+  void SolveSkipAfter(const std::string &phaseName, size_t &i);
+
+  /* phase time record */
+  void InitTimeHandler(uint32 threadNum = 1) {
+    phaseTh = GetManagerMemPool()->New<PhaseTimeHandler>(*GetManagerMemPool(), threadNum);
+  }
+  void DumpPhaseTime();
+
+  /* threadMP is given by thread local mempool */
+  AnalysisDataManager *ApplyAnalysisDataManager(const std::thread::id threadID, MemPool &threadMP);
+  AnalysisDataManager *GetAnalysisDataManager(const std::thread::id threadID, MemPool &threadMP);
+
+  /* mempool */
+  std::unique_ptr<ThreadLocalMemPool> AllocateMemPoolInPhaseManager(const std::string &mempoolName);
+  bool UseGlobalMpCtrler() const {
+    return useGlobalMpCtrler;
+  }
+
+  template <typename phaseT, typename IRTemplate>
+  void RunDependentPhase(const MaplePhase &phase, AnalysisDataManager &adm, IRTemplate &irUnit, int lev = 0);
+  template <typename phaseT, typename IRTemplate>
+  bool RunTransformPhase(const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, IRTemplate &irUnit, int lev = 0);
+  template <typename phaseT, typename IRTemplate>
+  bool RunAnalysisPhase(const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, IRTemplate &irUnit, int lev = 0);
+
+ protected:
+  MapleAllocator allocator;
+  MapleVector<MaplePhaseID> phasesSequence;
+  // write in multithread once. read any time
+  MapleMap<MaplePhaseID, AnalysisDep*> analysisDepMap;
+  // thread mempool for analysisDataManger and analysis info hook
+  MapleUnorderedMap<std::thread::id, MemPool*> threadMemPools;
+
+ private:
+  // in serial model. there is no analysisataManager.
+  MapleUnorderedMap<std::thread::id, AnalysisDataManager*> analysisDataManagers;
+  PhaseTimeHandler *phaseTh = nullptr;
+  bool skipFromFlag = false;
+  bool skipAfterFlag = false;
+  bool quiet = false;
+
+  /*
+   * use global/local mempool controller to allocate mempool
+   * Use global mempool : memPoolCtrler  [reduce memory occupancy]
+   * Use local mempool : innerCtrler     [reduce compiling time]
+   * Can be deleted after testing
+   */
+  bool useGlobalMpCtrler = true;
+};
+
+class AnalysisInfoHook {
+ public:
+  AnalysisInfoHook(MemPool &memPool, AnalysisDataManager &adm, MaplePhaseManager *bpm)
+      : allocator(&memPool),
+        adManager(adm),
+        bindingPM(bpm),
+        analysisPhasesData(allocator.Adapter()) {}
+  virtual ~AnalysisInfoHook() = default;
+  void AddAnalysisData(uint32 phaseKey, MaplePhaseID id, MaplePhase *phaseImpl) {
+    (void)analysisPhasesData.emplace(std::pair<AnalysisMemKey, MaplePhase*>(AnalysisMemKey(phaseKey, id), phaseImpl));
+  }
+
+  MaplePhase *GetAnalysisData(uint32 phaseKey, MaplePhaseID id) {
+    return adManager.GetVaildAnalysisPhase(phaseKey, id);
+  }
+
+  MaplePhase *FindAnalysisData(uint32 phaseKey, const MaplePhase *p, MaplePhaseID id) {
+    const auto anaPhaseInfoIt = analysisPhasesData.find(AnalysisMemKey(phaseKey, id));
+    if (anaPhaseInfoIt != analysisPhasesData.end()) {
+      return anaPhaseInfoIt->second;
+    } else {
+      /* fill all required analysis phase at first time */
+      AnalysisDep *anaDependence = bindingPM->FindAnalysisDep(*p);
+      for (auto requiredAnaPhase : anaDependence->GetRequiredPhase()) {
+        const MaplePhaseInfo *requiredPhase =
+            MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(requiredAnaPhase);
+        if (!requiredPhase->IsAnalysis()) {
+          continue;
+        }
+        AddAnalysisData(phaseKey, requiredAnaPhase, adManager.GetVaildAnalysisPhase(phaseKey, requiredAnaPhase));
+      }
+      ASSERT(analysisPhasesData.find(AnalysisMemKey(phaseKey, id)) != analysisPhasesData.end(),
+             "Need Analysis Dependence info");
+      return analysisPhasesData[AnalysisMemKey(phaseKey, id)];
+    }
+  }
+
+  /* Search analysis data from dependence phases which is at higher IR level */
+  template <typename AIMPHASE, typename IRUnit>
+  MaplePhase *FindOverIRAnalyisData(const IRUnit &u) const {
+    MaplePhase *it = dynamic_cast<MaplePhase*>(bindingPM);
+    ASSERT(it != nullptr, "find Over IR info failed");
+    return it->GetAnalysisInfoHook()->FindAnalysisData(u.GetUniqueID(), it, &AIMPHASE::id);
+  }
+
+  /* Get analysis data directly which is at higher IR level */
+  template <typename AIMPHASE, typename IRUnit>
+  MaplePhase *GetOverIRAnalyisData(const IRUnit &u) {
+    MaplePhase *it = dynamic_cast<MaplePhase*>(bindingPM);
+    ASSERT(it != nullptr, "find Over IR info failed");
+    return it->GetAnalysisInfoHook()->GetAnalysisData(u.GetUniqueID(), &AIMPHASE::id);
+  }
+
+  /* Find analysis Data which is at highest IR level */
+  template <typename AIMPHASE, typename IRUnit>
+  MaplePhase *GetTopLevelAnalyisData(const IRUnit &u) {
+    MaplePhase *curPhase = nullptr;
+    MaplePhase *upperPhase = dynamic_cast<MaplePhase*>(bindingPM);
+    ASSERT(upperPhase != nullptr, "find Over IR info failed");
+    AnalysisInfoHook *curHook = this;
+    AnalysisInfoHook *upperHook = upperPhase->GetAnalysisInfoHook();
+    while (upperHook != nullptr) {
+      curPhase = upperPhase;
+      curHook = upperHook;
+      upperPhase = dynamic_cast<MaplePhase*>(upperHook->bindingPM);
+      upperHook = upperPhase->GetAnalysisInfoHook();
+    }
+    return curHook->FindAnalysisData(u.GetUniqueID(), curPhase, &AIMPHASE::id);
+  }
+
+  MemPool *GetOverIRMempool() const {
+    return bindingPM->GetManagerMemPool();
+  }
+
+  /* Use In O2 carefully */
+  template <typename PHASEType, typename IRTemplate>
+  MaplePhase *ForceRunAnalysisPhase(MaplePhaseID anaPid, IRTemplate &irUnit, int depLev = 1) {
+    const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(anaPid);
+    if (adManager.IsAnalysisPhaseAvailable(irUnit.GetUniqueID(), curPhase->GetPhaseID())) {
+      return adManager.GetVaildAnalysisPhase(irUnit.GetUniqueID(), anaPid);
+    }
+    bindingPM->LogDependence(*curPhase, depLev);
+    (void)bindingPM->RunAnalysisPhase<PHASEType, IRTemplate>(*curPhase, adManager, irUnit, depLev);
+    return adManager.GetVaildAnalysisPhase(irUnit.GetUniqueID(), anaPid);
+  }
+
+  template <typename PHASEType, typename IRTemplate>
+  void ForceRunTransFormPhase(MaplePhaseID anaPid, IRTemplate &irUnit, int depLev = 1) {
+    const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(anaPid);
+    bindingPM->LogDependence(*curPhase, depLev);
+    (void)bindingPM->RunTransformPhase<PHASEType, IRTemplate>(*curPhase, adManager, irUnit, depLev);
+  }
+
+  /* Use In O2 carefully */
+  void ForceEraseAnalysisPhase(uint32 phaseKey, MaplePhaseID anaPid) {
+    adManager.EraseAnalysisPhase(phaseKey, anaPid);
+  }
+
+  /* Use In O2 carefully */
+  void ForceEraseAllAnalysisPhase() {
+    adManager.EraseAllAnalysisPhase();
+  }
+
+  MaplePhaseManager *GetBindingPM() {
+    return bindingPM;
+  }
+
+ private:
+  MapleAllocator allocator;
+  AnalysisDataManager &adManager;
+  MaplePhaseManager *bindingPM;
+  MapleMap<AnalysisMemKey, MaplePhase*> analysisPhasesData;
+};
+
+/* manages (module phases) & (funtion phase managers) */
+class ModulePM : public MaplePhase, public MaplePhaseManager {
+ public:
+  ModulePM(MemPool *mp, MaplePhaseID id) : MaplePhase(kModulePM, id, *mp), MaplePhaseManager(*mp) {}
+  virtual ~ModulePM() = default;
+};
+
+/* manages (function phases) & (loop/region phase managers) */
+class FunctionPM : public MapleModulePhase, public MaplePhaseManager {
+ public:
+  FunctionPM(MemPool *mp, MaplePhaseID id) : MapleModulePhase(id, mp), MaplePhaseManager(*mp) {}
+  virtual ~FunctionPM() = default;
+};
+
+/* manages (scc phases) */
+class SccPM : public MapleModulePhase, public MaplePhaseManager {
+ public:
+  SccPM(MemPool *mp, MaplePhaseID id) : MapleModulePhase(id, mp), MaplePhaseManager(*mp) {}
+  virtual ~SccPM() = default;
+};
+
+/* manages (function phases in function phase) */
+template <typename IRType>
+class FunctionPhaseGroup : public MapleFunctionPhase<IRType>, public MaplePhaseManager {
+ public:
+  FunctionPhaseGroup(MemPool *mp, MaplePhaseID id) : MapleFunctionPhase<IRType>(&id, mp), MaplePhaseManager(*mp) {}
+  virtual ~FunctionPhaseGroup() = default;
+};
+}
+#endif // MAPLE_PHASE_MANAGER_H
diff --git a/src/mapleall/maple_phase/include/maple_phase_support.h b/src/mapleall/maple_phase/include/maple_phase_support.h
new file mode 100644
index 0000000000000000000000000000000000000000..f175af19bb220c2c6b0557ff85609458d4e8a16f
--- /dev/null
+++ b/src/mapleall/maple_phase/include/maple_phase_support.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_PHASE_INCLUDE_MAPLE_PHASE_SUPPORT_H
+#define MAPLE_PHASE_INCLUDE_MAPLE_PHASE_SUPPORT_H
+#include <map>
+#include <string>
+#include <iostream>
+#include "mempool.h"
+#include "maple_string.h"
+#include "mpl_timer.h"
+#include "mempool_allocator.h"
+#include "option.h"
+
+namespace maple {
+using MaplePhaseID = const unsigned int *;
+class MaplePhase;
+using MaplePhaseT = MaplePhase* (*) (MemPool*);
+
+// base class of analysisPhase's result
+class AnalysisResult {
+ public:
+  explicit AnalysisResult(MemPool *memPoolParam) {
+    ASSERT(memPoolParam != nullptr, "memPoolParam is null in AnalysisResult::AnalysisResult");
+    memPool = memPoolParam;
+  }
+
+  virtual ~AnalysisResult() = default;
+
+  MemPool *GetMempool() const {
+    return memPool;
+  }
+
+  void EraseMemPool() {
+    delete memPool;
+    memPool = nullptr;
+  }
+
+ protected:
+  MemPool *memPool = nullptr;
+};
+
+/* record every phase known by the system */
+class MaplePhaseInfo {
+ public:
+  MaplePhaseInfo(const std::string &pName, MaplePhaseID pID, bool isAS, bool isCFGonly, bool canSkip)
+      : phaseName(pName),
+        phaseID(pID),
+        isAnalysis(isAS),
+        isCFGOnlyPass(isCFGonly),
+        canSkip(canSkip) {}
+
+  ~MaplePhaseInfo() {
+    constructor = nullptr;
+    phaseID = nullptr;
+  };
+  MaplePhaseID GetPhaseID() {
+    return phaseID;
+  }
+  const MaplePhaseID GetPhaseID() const {
+    return phaseID;
+  }
+  void SetConstructor(MaplePhaseT newConstructor) {
+    constructor = newConstructor;
+  }
+  MaplePhaseT GetConstructor() {
+    return constructor;
+  }
+  const MaplePhaseT GetConstructor() const {
+    return constructor;
+  }
+  bool IsAnalysis() const {
+    return isAnalysis;
+  };
+  bool IsCFGonly() const {
+    return isCFGOnlyPass;
+  };
+  std::string PhaseName() const {
+    return phaseName;
+  }
+  bool CanSkip() const {
+    return canSkip;
+  }
+  MaplePhaseT constructor = nullptr;
+ private:
+  std::string phaseName;
+  MaplePhaseID phaseID;
+  const bool isAnalysis ;
+  const bool isCFGOnlyPass;
+  const bool canSkip;
+};
+
+class PhaseTimeHandler {
+ public:
+  explicit PhaseTimeHandler(MemPool &memPool, uint32 threadNum = 1)
+      : allocator(&memPool),
+        phaseTimeRecord(allocator.Adapter()),
+        originOrder(allocator.Adapter()),
+        multiTimers(allocator.Adapter()) {
+    if (threadNum > 1) {
+      isMultithread = true;
+    }
+  }
+  virtual ~PhaseTimeHandler() = default;
+  void RunBeforePhase(const MaplePhaseInfo &pi);
+  void RunAfterPhase(const MaplePhaseInfo &pi);
+  void DumpPhasesTime();
+  void Clear() {
+    multiTimers.clear();
+    originOrder.clear();
+    phaseTimeRecord.clear();
+  }
+ private:
+  MapleAllocator allocator;
+  MapleMap<std::string, long> phaseTimeRecord;
+  MapleVector<MapleMap<std::string, long>::iterator> originOrder;
+  long phaseTotalTime = 0;
+  MPLTimer timer;
+  bool isMultithread = false;
+  MapleMap<std::thread::id, MPLTimer*> multiTimers;
+};
+
+// usasge :: analysis dependency
+class AnalysisDep {
+ public:
+  explicit AnalysisDep(MemPool &mp)
+      : allocator(&mp),
+        required(allocator.Adapter()),
+        preserved(allocator.Adapter()),
+        preservedExcept(allocator.Adapter()) {}
+  virtual ~AnalysisDep() = default;
+  template<class PhaseT>
+  void AddRequired() {
+    required.emplace_back(&PhaseT::id);
+  }
+  template<class PhaseT>
+  void AddPreserved() {
+    (void)preserved.emplace(&PhaseT::id);
+  }
+  template<class PhaseT>
+  void PreservedAllExcept() {
+    SetPreservedAll();
+    (void)preservedExcept.emplace(&PhaseT::id);
+  }
+  void SetPreservedAll() {
+    preservedAll = true;
+  }
+  bool GetPreservedAll() const {
+    return preservedAll;
+  }
+  bool FindIsPreserved(const MaplePhaseID pid) {
+    return preserved.find(pid) != preserved.end();
+  }
+  const MapleVector<MaplePhaseID> &GetRequiredPhase() const;
+  const MapleSet<MaplePhaseID> &GetPreservedPhase() const;
+  const MapleSet<MaplePhaseID> &GetPreservedExceptPhase() const;
+ private:
+  MapleAllocator allocator;
+  MapleVector<MaplePhaseID> required;
+  MapleSet<MaplePhaseID> preserved;  // keep analysis result as it is
+  MapleSet<MaplePhaseID> preservedExcept;  // keep analysis result except
+  bool preservedAll = false;
+};
+}
+#endif // MAPLE_PHASE_SUPPORT_H
diff --git a/src/mapleall/maple_phase/include/phase_driver.h b/src/mapleall/maple_phase/include/phase_driver.h
new file mode 100644
index 0000000000000000000000000000000000000000..40d65fde58fcb869ae6dab291107bfd33255eb19
--- /dev/null
+++ b/src/mapleall/maple_phase/include/phase_driver.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_PHASE_INCLUDE_PHASEDRIVER_H
+#define MAPLE_PHASE_INCLUDE_PHASEDRIVER_H
+#include "mir_module.h"
+#include "mir_function.h"
+#include "mpl_scheduler.h"
+
+namespace maple {
+class PhaseDriverImpl : public MplTaskParam {
+ public:
+  PhaseDriverImpl() = default;
+  virtual ~PhaseDriverImpl() = default;
+
+  virtual void GlobalInit() {}
+
+  virtual void LocalInit() {}
+
+  virtual void ProcessRun(uint32, void*, void*) {}
+
+  virtual void ProcessFinish(uint32, void*, void*) {}
+};
+
+class PhaseDriver : public MplScheduler {
+ public:
+  class Task : public MplTask {
+   public:
+    explicit Task(void *currTarget, void *currParamEx = nullptr) : target(currTarget), paramException(currParamEx) {}
+
+    ~Task() = default;
+
+   protected:
+    int RunImpl(MplTaskParam *param) override {
+      CHECK_NULL_FATAL(param);
+      static_cast<PhaseDriverImpl*>(param)->ProcessRun(taskId, target, paramException);
+      return 0;
+    }
+
+    int FinishImpl(MplTaskParam *param) override {
+      CHECK_NULL_FATAL(param);
+      static_cast<PhaseDriverImpl*>(param)->ProcessFinish(taskId, target, paramException);
+      return 0;
+    }
+    void *target;
+    void *paramException;
+  };
+
+  explicit PhaseDriver(const std::string &phaseName);
+  virtual ~PhaseDriver() = default;
+
+  void RunAll(MIRModule *currModule, int thread, bool bSeq = false);
+  virtual void RunSerial();
+  virtual void RunParallel(int thread, bool bSeq = false);
+  virtual PhaseDriverImpl *NewPhase() = 0;
+  virtual void RegisterTasks() = 0;
+
+ protected:
+  void CallbackThreadMainStart() override;
+  void CallbackThreadMainEnd() override;
+  MplTaskParam *CallbackGetTaskRunParam() const override {
+    return phaseImplLocal;
+  }
+
+  MplTaskParam *CallbackGetTaskFinishParam() const override {
+    return phaseImplLocal;
+  }
+
+  MIRModule *module;
+  PhaseDriverImpl *phaseImpl;
+  thread_local static PhaseDriverImpl *phaseImplLocal;
+  std::string phaseName;
+};
+}  // namespace maple
+#endif  // MAPLE_PHASE_INCLUDE_PHASEDRIVER_H
diff --git a/src/mapleall/maple_phase/include/phase_impl.h b/src/mapleall/maple_phase/include/phase_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..ceb6e229fa3f07bddf2eac5730020d2edbaaf101
--- /dev/null
+++ b/src/mapleall/maple_phase/include/phase_impl.h
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_PHASE_INCLUDE_PHASE_IMPL_H
+#define MAPLE_PHASE_INCLUDE_PHASE_IMPL_H
+#include "class_hierarchy_phase.h"
+#include "mir_builder.h"
+#include "mpl_scheduler.h"
+#include "utils.h"
+
+namespace maple {
+class FuncOptimizeImpl : public MplTaskParam {
+ public:
+  explicit FuncOptimizeImpl(MIRModule &mod, KlassHierarchy *kh = nullptr, bool currTrace = false);
+  ~FuncOptimizeImpl();
+  // Each phase needs to implement its own Clone
+  virtual FuncOptimizeImpl *Clone() = 0;
+  MIRModule &GetMIRModule() {
+    return *module;
+  }
+
+  const MIRModule &GetMIRModule() const {
+    return *module;
+  }
+
+  void SetDump(bool dumpFunc) {
+    dump = dumpFunc;
+  }
+
+  virtual void CreateLocalBuilder(pthread_mutex_t &mtx);
+  virtual void ProcessFunc(MIRFunction *func);
+  virtual void Finish() {}
+
+ protected:
+  void SetCurrentFunction(MIRFunction &func) {
+    currFunc = &func;
+    ASSERT(builder != nullptr, "builder is null in FuncOptimizeImpl::SetCurrentFunction");
+    builder->SetCurrentFunction(func);
+    module->SetCurFunction(&func);
+  }
+
+  void SetCurrentBlock(BlockNode &block) {
+    currBlock = &block;
+  }
+
+  virtual void ProcessBlock(StmtNode &stmt);
+  // Each phase needs to implement its own ProcessStmt
+  virtual void ProcessStmt(StmtNode&) {}
+
+  KlassHierarchy *klassHierarchy = nullptr;
+  MIRFunction *currFunc = nullptr;
+  BlockNode *currBlock = nullptr;
+  MIRBuilderExt *builder = nullptr;
+  bool trace = false;
+  bool dump = false;
+
+ private:
+  MIRModule *module = nullptr;
+};
+
+class FuncOptimizeIterator : public MplScheduler {
+ public:
+  class Task : public MplTask {
+   public:
+    explicit Task(MIRFunction &func) : function(&func) {}
+
+    ~Task() = default;
+
+   protected:
+    int RunImpl(MplTaskParam *param) override {
+      auto &impl = static_cast<FuncOptimizeImpl&>(utils::ToRef(param));
+      impl.ProcessFunc(function);
+      return 0;
+    }
+
+    int FinishImpl(MplTaskParam*) override {
+      return 0;
+    }
+
+   private:
+    MIRFunction *function;
+  };
+
+  FuncOptimizeIterator(const std::string &phaseName, std::unique_ptr<FuncOptimizeImpl> phaseImpl);
+  ~FuncOptimizeIterator();
+  virtual void Run(uint32 threadNum = 1, bool isSeq = false);
+
+ protected:
+  thread_local static FuncOptimizeImpl *phaseImplLocal;
+  void RunSerial();
+  void RunParallel(uint32 threadNum, bool isSeq = false);
+  MplTaskParam *CallbackGetTaskRunParam() const override {
+    return phaseImplLocal;
+  }
+
+  MplTaskParam *CallbackGetTaskFinishParam() const override {
+    return phaseImplLocal;
+  }
+
+  void CallbackThreadMainStart() override {
+    phaseImplLocal = phaseImpl->Clone();
+    utils::ToRef(phaseImplLocal).CreateLocalBuilder(mutexGlobal);
+  }
+
+  void CallbackThreadMainEnd() override {
+    delete phaseImplLocal;
+    phaseImplLocal = nullptr;
+  }
+
+ private:
+  bool mplDumpTime = false;
+  std::unique_ptr<FuncOptimizeImpl> phaseImpl;
+  std::vector<std::unique_ptr<MplTask>> tasksUniquePtr;
+};
+
+#define OPT_TEMPLATE(OPT_NAME)                                                                       \
+  auto *kh = static_cast<KlassHierarchy*>(mrm->GetAnalysisResult(MoPhase_CHA, mod));                 \
+  ASSERT_NOT_NULL(kh);                                                                               \
+  std::unique_ptr<FuncOptimizeImpl> funcOptImpl = std::make_unique<OPT_NAME>(*mod, kh, TRACE_PHASE); \
+  ASSERT_NOT_NULL(funcOptImpl);                                                                      \
+  FuncOptimizeIterator opt(PhaseName(), std::move(funcOptImpl));                                     \
+  opt.Init();                                                                                        \
+  opt.Run();
+
+
+#define OPT_TEMPLATE_NEWPM(OPT_NAME, PHASEKEY)                                  \
+  auto *kh = GET_ANALYSIS(M2MKlassHierarchy, PHASEKEY); \
+  ASSERT_NOT_NULL((kh));                                                                                     \
+  std::unique_ptr<FuncOptimizeImpl> funcOptImpl = std::make_unique<OPT_NAME>(m, (kh), TRACE_MAPLE_PHASE);    \
+  ASSERT_NOT_NULL(funcOptImpl);                                                                              \
+  FuncOptimizeIterator opt(PhaseName(), std::move(funcOptImpl));                                             \
+  opt.Init();                                                                                                \
+  opt.Run();
+}  // namespace maple
+#endif  // MAPLE_PHASE_INCLUDE_PHASE_IMPL_H
diff --git a/src/mapleall/maple_phase/include/phases.def b/src/mapleall/maple_phase/include/phases.def
new file mode 100644
index 0000000000000000000000000000000000000000..d0df67abb4da5e1eb24fd679b14342d99265dd82
--- /dev/null
+++ b/src/mapleall/maple_phase/include/phases.def
@@ -0,0 +1,115 @@
+#ifdef MODULE_PHASE
+ADDMODULEPHASE("clone", JAVALANG)
+ADDMODULEPHASE("classhierarchy", JAVALANG)
+ADDMODULEPHASE("callgraph", JAVALANG)
+ADDMODULEPHASE("vtableanalysis", JAVALANG)
+ADDMODULEPHASE("reflectionanalysis", JAVALANG)
+ADDMODULEPHASE("GenNativeStubFunc", JAVALANG)
+ADDMODULEPHASE("gencheckcast", JAVALANG)
+ADDMODULEPHASE("javaintrnlowering", JAVALANG)
+ADDMODULEPHASE("callgraph", !Options::profileUse)
+ADDMODULEPHASE("inline", Options::O2 && Options::useInline && !Options::profileUse)
+// run callgraph again to delete fully inlined static function
+ADDMODULEPHASE("callgraph", Options::O2 && Options::useInline && !Options::profileUse)
+ADDMODULEPHASE("simplify", (Options::O2 && !Options::genLMBC) || (CLANG && Options::profileGen))
+ADDMODULEPHASE("ConstantFold", Options::O2)
+// ipa phase manager
+ADDMODULEPHASE("IpaSccPM", CLANG && (Options::O2 || Options::profileGen || Options::profileUse))
+ADDMODULEPHASE("outline", CLANG && Options::doOutline)
+
+// ginline
+ADDMODULEPHASE("ginline", CLANG && Options::O2 && Options::useInline && !Options::profileUse && Options::enableGInline)
+// run callgraph, simplify, constantfold again after ginline
+ADDMODULEPHASE("callgraph", CLANG && Options::O2 && Options::useInline && Options::enableGInline)
+ADDMODULEPHASE("simplify", CLANG && Options::O2 && !Options::genLMBC && Options::enableGInline)
+ADDMODULEPHASE("ConstantFold", CLANG && Options::O2 && Options::enableGInline)
+
+ADDMODULEPHASE("inline", CLANG && (Options::O2 && Options::useInline && Options::profileUse))
+ADDMODULEPHASE("ipaclone", CLANG && Options::O2 && Options::enableIPAClone)
+ADDMODULEPHASE("ProfileGenPM", CLANG && Options::profileGen)
+// me phase manager is also a phase itself.
+ADDMAPLEPHASE("meFuncPM", IsRunMe());
+ADDMODULEPHASE("clinit", JAVALANG)
+ADDMODULEPHASE("VtableImpl", JAVALANG)
+ADDMODULEPHASE("CodeReLayout", MeOption::optLevel == 2 && JAVALANG)
+ADDMODULEPHASE("javaehlower", JAVALANG)
+ADDMODULEPHASE("MUIDReplacement", JAVALANG)
+ADDMODULEPHASE("ConstantFold", JAVALANG || Options::O2)
+#endif
+
+#ifdef ME_PHASE
+// me phases belong to MeFuncPM phase.
+ADDMAPLEMEPHASE("mecfgbuild", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                              MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("injectiv", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                            MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("ssatab", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                          MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("aliasclass", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                              MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("ssa", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                       MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("dse", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                       MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("irmapbuild", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                              MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("ivcanon", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                           MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("hprop", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                         MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("hdse", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                        MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("premeemit", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                             MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("deptest", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                           MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("autovec", CLANG && MeOption::optLevel >= 3 && MeOption::enableLFO &&
+                           MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("lfounroll", CLANG && MeOption::optLevel >= 2 && MeOption::enableLFO &&
+                             MeOption::boundaryCheckMode == SafetyCheckMode::kNoCheck)
+ADDMAPLEMEPHASE("mecfgbuild", MeOption::optLevel >= 2 || JAVALANG)
+ADDMAPLEMEPHASE("optimizeCFGNoSSA", CLANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("codefactoring", CLANG && MeOption::optForSize)
+ADDMAPLEMEPHASE("bypatheh", JAVALANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("loopinversion", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("splitcriticaledge", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("ssatab", MeOption::optLevel >= 2 || JAVALANG)
+ADDMAPLEMEPHASE("toplevelssa", MeOption::optLevel >= 2 || JAVALANG)
+ADDMAPLEMEPHASE("ssaprop", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("aliasclass", MeOption::optLevel >= 2 || JAVALANG)
+ADDMAPLEMEPHASE("ssa", MeOption::optLevel >= 2 || JAVALANG)
+ADDMAPLEMEPHASE("dse", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("analyzector", JAVALANG)
+ADDMAPLEMEPHASE("abcopt", false && JAVALANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("loopcanon", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("loopunrolling", !JAVALANG && MeOption::optLevel == 2)
+ADDMAPLEMEPHASE("ssadevirt", JAVALANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("valueRangePropagation", CLANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("jumpThreading", CLANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("hprop", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("hdse", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("may2dassign", JAVALANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("condbasednpc", JAVALANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("epre", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("stmtpre", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("analyzerc", MeOption::optLevel != 0 && JAVALANG && !MeOption::noRC && !MeOption::gcOnly)
+ADDMAPLEMEPHASE("rclowering", JAVALANG && !MeOption::noRC && MeOption::rcLowering && !MeOption::gcOnly)
+ADDMAPLEMEPHASE("gclowering", JAVALANG && MeOption::gcOnly)
+ADDMAPLEMEPHASE("rename2preg", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("lpre", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("slp", !JAVALANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("storepre", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("ivopts", !JAVALANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("optimizeCFG", CLANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("copyprop", MeOption::optLevel >= 2 && !JAVALANG)
+ADDMAPLEMEPHASE("valueRangePropagation", CLANG && MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("safetyWarning", CLANG && MeOption::optLevel >= 2 &&
+    (MeOption::npeCheckMode != SafetyCheckMode::kNoCheck || MeOption::boundaryCheckMode != SafetyCheckMode::kNoCheck))
+ADDMAPLEMEPHASE("sink", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("copyprop", MeOption::optLevel >= 2 && !JAVALANG)
+ADDMAPLEMEPHASE("hdse", MeOption::optLevel >= 2 && !JAVALANG)
+ADDMAPLEMEPHASE("pregrename", MeOption::optLevel >= 2)
+ADDMAPLEMEPHASE("bblayout", MeOption::optLevel >= 2 || JAVALANG)
+ADDMAPLEMEPHASE("meemit", MeOption::optLevel >= 2 || JAVALANG)
+ADDMAPLEMEPHASE("meverify", JAVALANG && MeOption::meVerify)
+#endif
diff --git a/src/mapleall/maple_phase/src/maple_phase.cpp b/src/mapleall/maple_phase/src/maple_phase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d85340a37ce163596281fcbae46cb56b620072e0
--- /dev/null
+++ b/src/mapleall/maple_phase/src/maple_phase.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "maple_phase.h"
+namespace maple {
+MaplePhaseRegister *MaplePhaseRegister::GetMaplePhaseRegister() {
+  static MaplePhaseRegister *globalRegister = new MaplePhaseRegister();
+  return globalRegister;
+}
+
+void MaplePhaseRegister::RegisterPhase(const MaplePhaseInfo &pi) {
+  bool checkSucc = passInfoMap.emplace(std::pair<MaplePhaseID, const MaplePhaseInfo*>(pi.GetPhaseID(), &pi)).second;
+  CHECK_FATAL(checkSucc, "Register Phase failed");
+}
+
+const MaplePhaseInfo* MaplePhaseRegister::GetPhaseByID(MaplePhaseID id) {
+  if (passInfoMap.count(id) > 0) {
+    return passInfoMap.find(id)->second;
+  } else  {
+    CHECK_FATAL(false, "This phase has not been registered");
+    return passInfoMap.end()->second;
+  }
+}
+
+void MaplePhase::Dump() const {
+  LogInfo::MapleLogger() << "this is Phase : " << PhaseName() << " Kind : " << phaseKind << " ID : " << phaseID << "\n";
+}
+
+MemPool *MaplePhase::ApplyTempMemPool() {
+  MemPool *res = memPoolCtrler.NewMemPool("temp Mempool", true);
+  tempMemPools.emplace_back(res);
+  return res;
+}
+
+void MaplePhase::ClearTempMemPool() {
+#ifdef DEBUG
+  int maxMemPoolNum = 5;
+  ASSERT(tempMemPools.size() <= maxMemPoolNum, " maple phase uses too many temp mempool");
+#endif
+  if (!tempMemPools.empty()) {
+    for (auto mpIt : tempMemPools) {
+      delete mpIt;
+      mpIt = nullptr;
+    }
+    tempMemPools.clear();
+  }
+}
+
+/* default : do not require any phases */
+void MaplePhase::AnalysisDepInit(AnalysisDep &aDep) const {
+  GetAnalysisDependence(aDep);
+}
+
+void MaplePhase::GetAnalysisDependence(AnalysisDep &aDep) const {
+  (void)aDep;
+  // do nothing if derived class not defined analysis dependence
+}
+
+void MaplePhase::SetAnalysisInfoHook(AnalysisInfoHook *hook) {
+  analysisInfo = hook;
+}
+
+AnalysisInfoHook *MaplePhase::GetAnalysisInfoHook() {
+  return analysisInfo;
+}
+}
diff --git a/src/mapleall/maple_phase/src/maple_phase_manager.cpp b/src/mapleall/maple_phase/src/maple_phase_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a8010008af8ce1772f540642b04425ddcbae5326
--- /dev/null
+++ b/src/mapleall/maple_phase/src/maple_phase_manager.cpp
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "maple_phase_manager.h"
+#include "cgfunc.h"
+#include "mpl_timer.h"
+#include "me_function.h"
+
+namespace maple {
+using MeFuncOptTy = MapleFunctionPhase<MeFunction>;
+using CgFuncOptTy = MapleFunctionPhase<maplebe::CGFunc>;
+MemPool *AnalysisDataManager::ApplyMemPoolForAnalysisPhase(uint32 phaseKey, const MaplePhaseInfo &pi) {
+  std::string mempoolName = pi.PhaseName() + " memPool";
+  MemPool *phaseMempool = nullptr;
+  if (UseGlobalMpCtrler()) {
+    phaseMempool = memPoolCtrler.NewMemPool(mempoolName, true);
+  } else {
+    phaseMempool = innerCtrler->NewMemPool(mempoolName, true);
+  }
+  (void)analysisPhaseMemPool.emplace(std::pair<AnalysisMemKey, MemPool*>(AnalysisMemKey(phaseKey, pi.GetPhaseID()),
+                                                                         phaseMempool));
+  return phaseMempool;
+}
+
+void AnalysisDataManager::AddAnalysisPhase(uint32 phaseKey, MaplePhase *p) {
+  CHECK_FATAL(p != nullptr, "invalid phase when AddAnalysisPhase"); // change to assert after testing
+  (void)availableAnalysisPhases.emplace(std::pair<AnalysisMemKey, MaplePhase*>(AnalysisMemKey(phaseKey,
+      p->GetPhaseID()), p));
+}
+
+// Erase phase at O2
+// This is for the actully phase
+void AnalysisDataManager::EraseAnalysisPhase(uint32 phaseKey, MaplePhaseID pid) {
+  auto it = analysisPhaseMemPool.find(AnalysisMemKey(phaseKey, pid));
+  const auto itanother = availableAnalysisPhases.find(AnalysisMemKey(phaseKey, pid));
+  if (it != analysisPhaseMemPool.cend() && itanother != availableAnalysisPhases.cend()) {
+    auto resultanother = availableAnalysisPhases.erase(AnalysisMemKey(phaseKey, pid));
+    CHECK_FATAL(resultanother > 0, "Release Failed");
+    delete it->second;
+    it->second = nullptr;
+    auto result = analysisPhaseMemPool.erase(AnalysisMemKey(phaseKey, pid));  // erase to release mempool ?
+    CHECK_FATAL(result > 0, "Release Failed");
+  }
+}
+
+// Erase all safely
+void AnalysisDataManager::EraseAllAnalysisPhase() {
+  for (auto it = availableAnalysisPhases.begin(); it != availableAnalysisPhases.end();) {
+    EraseAnalysisPhase(it);
+  }
+}
+
+// Erase safely
+void AnalysisDataManager::EraseAnalysisPhase(MapleMap<AnalysisMemKey, MaplePhase*>::iterator &anaPhaseMapIt) {
+  auto it = analysisPhaseMemPool.find(anaPhaseMapIt->first);
+  if (it != analysisPhaseMemPool.end()) {
+    anaPhaseMapIt = availableAnalysisPhases.erase(anaPhaseMapIt);
+    delete it->second;
+    it->second = nullptr;
+#ifdef DEBUG
+    bool result = analysisPhaseMemPool.erase(it->first);  // erase to release mempool
+#else
+    (void)analysisPhaseMemPool.erase(it->first);
+#endif
+    ASSERT(result, "Release Failed");
+#ifdef DEBUG
+  } else {
+    ASSERT(false, "cannot delete phase which is not exist  &&  mempool is not create TOO");
+#endif
+  }
+}
+
+void AnalysisDataManager::ClearInVaildAnalysisPhase(uint32 phaseKey, AnalysisDep &aDep) {
+  if (!aDep.GetPreservedAll()) {
+    // delete phases which are not preserved
+    if (aDep.GetPreservedPhase().empty()) {
+      for (auto it = availableAnalysisPhases.begin(); it != availableAnalysisPhases.end();) {
+        if (it->first.first == phaseKey) {
+          EraseAnalysisPhase(it);
+        } else {
+          ++it;
+        }
+      }
+    }
+    for (auto it = availableAnalysisPhases.begin(); it != availableAnalysisPhases.end();) {
+      if (!aDep.FindIsPreserved((it->first).second) && it->first.first == phaseKey) {
+        EraseAnalysisPhase(it);
+      } else {
+        ++it;
+      }
+    }
+  } else {
+    if (!aDep.GetPreservedExceptPhase().empty()) {
+      for (auto exceptPhaseID : aDep.GetPreservedExceptPhase()) {
+        auto it = availableAnalysisPhases.find(AnalysisMemKey(phaseKey, exceptPhaseID));
+        if (it != availableAnalysisPhases.end()) {
+          EraseAnalysisPhase(it);
+        }
+      }
+    }
+  }
+}
+
+MaplePhase *AnalysisDataManager::GetVaildAnalysisPhase(uint32 phaseKey, MaplePhaseID pid) {
+  const auto it = availableAnalysisPhases.find(AnalysisMemKey(phaseKey, pid));
+  if (it == availableAnalysisPhases.cend()) {
+    LogInfo::MapleLogger() << "Required " <<
+        MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(pid)->PhaseName() << " running before \n";
+    CHECK_FATAL(false, "find analysis phase failed");
+    return nullptr;
+  } else {
+    return it->second;
+  }
+}
+
+bool AnalysisDataManager::IsAnalysisPhaseAvailable(uint32 phaseKey, MaplePhaseID pid) {
+  const auto it = availableAnalysisPhases.find(AnalysisMemKey(phaseKey, pid));
+  return it != availableAnalysisPhases.cend();
+}
+
+void AnalysisDataManager::Dump() {
+  LogInfo::MapleLogger() << "availableAnalysisPhases: \n";
+  for (auto &it : std::as_const(availableAnalysisPhases)) {
+    LogInfo::MapleLogger() << "<"
+                           << it.first.first
+                           << ", "
+                           << MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(it.first.second)->PhaseName()
+                           << "> : "
+                           << it.second
+                           << "\n";
+  }
+  LogInfo::MapleLogger() << "analysisPhaseMemPool: \n";
+  for (auto &it : std::as_const(analysisPhaseMemPool)) {
+    LogInfo::MapleLogger() << "<"
+                           << it.first.first
+                           << ", "
+                           << MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(it.first.second)->PhaseName()
+                           << "> : "
+                           << it.second
+                           << "\n";
+  }
+}
+
+void MaplePhaseManager::AddPhase(const std::string &phaseName, bool condition) {
+  if (!condition) {
+    return;
+  }
+  bool found = false;
+  for (auto &it : MaplePhaseRegister::GetMaplePhaseRegister()->GetAllPassInfo()) {
+    if (it.second->PhaseName() == phaseName) {
+      phasesSequence.emplace_back(it.first);
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    CHECK_FATAL(false, "%s not found !", phaseName.c_str());
+  }
+}
+
+void MaplePhaseManager::DumpPhaseTime() {
+  if (phaseTh != nullptr) {
+    phaseTh->DumpPhasesTime();
+    phaseTh->Clear();
+  }
+}
+
+void MaplePhaseManager::SolveSkipFrom(const std::string &phaseName, size_t &i) {
+  const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+  if (!skipFromFlag && curPhase->PhaseName() == phaseName) {
+    CHECK_FATAL(curPhase->CanSkip(), "%s cannot be skipped!", phaseName.c_str());
+    skipFromFlag = true;
+  }
+  if (skipFromFlag) {
+    while (curPhase->CanSkip() && (++i != phasesSequence.size())) {
+      curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+      CHECK_FATAL(curPhase != nullptr, "null ptr check ");
+    }
+  }
+  skipFromFlag = false;
+}
+
+void MaplePhaseManager::SolveSkipAfter(const std::string &phaseName, size_t &i) {
+  const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+  if (!skipAfterFlag && curPhase->PhaseName() == phaseName) {
+    skipAfterFlag = true;
+  }
+  if (skipAfterFlag) {
+    while (++i != phasesSequence.size()) {
+      curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+      CHECK_FATAL(curPhase != nullptr, "null ptr check ");
+      if (!curPhase->CanSkip()) {
+        break;
+      }
+    }
+    --i;  /* restore iterator */
+  }
+  skipAfterFlag = false;
+}
+
+AnalysisDep *MaplePhaseManager::FindAnalysisDep(const MaplePhase &phase) {
+  AnalysisDep *anDependence = nullptr;
+  const auto anDepIt = analysisDepMap.find(phase.GetPhaseID());
+  if (anDepIt != analysisDepMap.cend()) {
+    anDependence = anDepIt->second;
+  } else {
+    anDependence = allocator.New<AnalysisDep>(*GetManagerMemPool());
+    phase.AnalysisDepInit(*anDependence);
+    (void)analysisDepMap.emplace(std::pair<MaplePhaseID, AnalysisDep*>(phase.GetPhaseID(), anDependence));
+  }
+  return anDependence;
+}
+
+AnalysisDataManager *MaplePhaseManager::ApplyAnalysisDataManager(const std::thread::id threadID, MemPool &threadMP) {
+  auto *adm = threadMP.New<AnalysisDataManager>(threadMP);
+#ifdef DEBUG
+  auto result = analysisDataManagers.emplace(std::pair<std::thread::id, AnalysisDataManager*>(threadID, adm));
+#else
+  (void)analysisDataManagers.emplace(std::pair<std::thread::id, AnalysisDataManager*>(threadID, adm));
+#endif
+  ASSERT(adm != nullptr && result.second, "apply AnalysisDataManager failed");
+  return adm;
+}
+
+AnalysisDataManager *MaplePhaseManager::GetAnalysisDataManager(const std::thread::id threadID, MemPool &threadMP) {
+  auto admIt = analysisDataManagers.find(threadID);
+  if (admIt != analysisDataManagers.end()) {
+    return admIt->second;
+  } else {
+    return ApplyAnalysisDataManager(threadID, threadMP);
+  }
+}
+
+std::unique_ptr<ThreadLocalMemPool> MaplePhaseManager::AllocateMemPoolInPhaseManager(const std::string &mempoolName) {
+  if (!UseGlobalMpCtrler()) {
+    LogInfo::MapleLogger() << " Inner Ctrler has not been supported yet \n";
+  }
+  return std::make_unique<ThreadLocalMemPool>(memPoolCtrler, mempoolName);
+}
+
+template <typename phaseT, typename IRTemplate>
+void MaplePhaseManager::RunDependentPhase(const MaplePhase &phase, AnalysisDataManager &adm,
+                                          IRTemplate &irUnit, int lev) {
+  AnalysisDep *anaDependence = FindAnalysisDep(phase);
+  for (auto requiredPhase : anaDependence->GetRequiredPhase()) {
+    const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(requiredPhase);
+    if (adm.IsAnalysisPhaseAvailable(irUnit.GetUniqueID(), curPhase->GetPhaseID())) {
+      continue;
+    }
+    LogDependence(*curPhase, lev);
+    if (curPhase->IsAnalysis()) {
+      (void)RunAnalysisPhase<phaseT, IRTemplate>(*curPhase, adm, irUnit, lev);
+    } else {
+      (void)RunTransformPhase<phaseT, IRTemplate>(*curPhase, adm, irUnit, lev);
+    }
+  }
+}
+
+/* live range of a phase should be short than mempool */
+template <typename phaseT, typename IRTemplate>
+bool MaplePhaseManager::RunTransformPhase(const MaplePhaseInfo &phaseInfo,
+                                          AnalysisDataManager &adm, IRTemplate &irUnit, int lev) {
+  bool result = false;
+  auto transformPhaseMempool = AllocateMemPoolInPhaseManager(phaseInfo.PhaseName() + "'s mempool");
+  auto *phase = static_cast<phaseT*>(phaseInfo.GetConstructor()(transformPhaseMempool.get()));
+  phase->SetAnalysisInfoHook(transformPhaseMempool->New<AnalysisInfoHook>(*(transformPhaseMempool.get()), adm, this));
+  RunDependentPhase<phaseT, IRTemplate>(*phase, adm, irUnit, lev + 1);
+  if (phaseTh != nullptr) {
+    phaseTh->RunBeforePhase(phaseInfo);
+    result = phase->PhaseRun(irUnit);
+    phaseTh->RunAfterPhase(phaseInfo);
+  } else  {
+    result = phase->PhaseRun(irUnit);
+  }
+  phase->ClearTempMemPool();
+  adm.ClearInVaildAnalysisPhase(irUnit.GetUniqueID(), *FindAnalysisDep(*phase));
+  return result;
+}
+
+template <typename phaseT, typename IRTemplate>
+bool MaplePhaseManager::RunAnalysisPhase(
+    const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, IRTemplate &irUnit, int lev) {
+  bool result = false;
+  phaseT *phase = nullptr;
+  if (adm.IsAnalysisPhaseAvailable(irUnit.GetUniqueID(), phaseInfo.GetPhaseID())) {
+    return result;
+  }
+  MemPool *anasPhaseMempool = adm.ApplyMemPoolForAnalysisPhase(irUnit.GetUniqueID(), phaseInfo);
+  phase = static_cast<phaseT*>(phaseInfo.GetConstructor()(anasPhaseMempool));
+  // change analysis info hook mempool from ADM Allocator to phase allocator?
+  phase->SetAnalysisInfoHook(anasPhaseMempool->New<AnalysisInfoHook>(*anasPhaseMempool, adm, this));
+  RunDependentPhase<phaseT, IRTemplate>(*phase, adm, irUnit, lev + 1);
+  if (phaseTh != nullptr) {
+    phaseTh->RunBeforePhase(phaseInfo);
+    result = phase->PhaseRun(irUnit);
+    phaseTh->RunAfterPhase(phaseInfo);
+  } else  {
+    result = phase->PhaseRun(irUnit);
+  }
+  phase->ClearTempMemPool();
+  adm.AddAnalysisPhase(irUnit.GetUniqueID(), phase);
+  return result;
+}
+
+// declaration for functionPhase (template only)
+template bool MaplePhaseManager::RunTransformPhase<MapleModulePhase, MIRModule>(
+    const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, MIRModule &irUnit, int lev);
+template bool MaplePhaseManager::RunTransformPhase<MapleSccPhase<SCCNode<CGNode>>, SCCNode<CGNode>>(
+    const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, SCCNode<CGNode> &irUnit, int lev);
+template bool MaplePhaseManager::RunAnalysisPhase<MapleModulePhase, MIRModule>(
+    const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, MIRModule &irUnit, int lev);
+template bool MaplePhaseManager::RunTransformPhase<MeFuncOptTy, MeFunction>(
+    const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, MeFunction &irUnit, int lev);
+template bool MaplePhaseManager::RunAnalysisPhase<MeFuncOptTy, MeFunction>(
+    const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, MeFunction &irUnit, int lev);
+template bool MaplePhaseManager::RunTransformPhase<CgFuncOptTy, maplebe::CGFunc>(
+    const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, maplebe::CGFunc &irUnit, int lev);
+template bool MaplePhaseManager::RunAnalysisPhase<CgFuncOptTy, maplebe::CGFunc>(
+    const MaplePhaseInfo &phaseInfo, AnalysisDataManager &adm, maplebe::CGFunc &irUnit, int lev);
+}
diff --git a/src/mapleall/maple_phase/src/maple_phase_support.cpp b/src/mapleall/maple_phase/src/maple_phase_support.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..528ff3abc14dab223bf3a20aa9bb4174a005015a
--- /dev/null
+++ b/src/mapleall/maple_phase/src/maple_phase_support.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "maple_phase_support.h"
+
+#include "cgfunc.h"
+namespace maple {
+void PhaseTimeHandler::RunBeforePhase(const MaplePhaseInfo &pi) {
+  (void)pi;
+  if (isMultithread) {
+    static std::mutex mtx;
+    ParallelGuard guard(mtx, true);
+    std::thread::id tid = std::this_thread::get_id();
+    if (multiTimers.count(tid) == 0) {
+      multiTimers.emplace(std::make_pair(tid, allocator.New<MPLTimer>()));
+    }
+    multiTimers[tid]->Start();
+  } else {
+    timer.Start();
+  }
+}
+
+void PhaseTimeHandler::RunAfterPhase(const MaplePhaseInfo &pi) {
+  static std::mutex mtx;
+  ParallelGuard guard(mtx, true);
+  long usedTime = 0;
+  if (isMultithread) {
+    std::thread::id tid = std::this_thread::get_id();
+    if (multiTimers.count(tid) > 0) {
+      multiTimers[tid]->Stop();
+      usedTime += multiTimers[tid]->ElapsedMicroseconds();
+    } else {
+      ASSERT(false, " phase time handler create failed");
+    }
+  } else {
+    timer.Stop();
+    usedTime = timer.ElapsedMicroseconds();
+  }
+  std::string phaseName = pi.PhaseName();
+  if (phaseTimeRecord.count(phaseName) > 0) {
+    phaseTimeRecord[phaseName] += usedTime;
+  } else {
+    auto ret = phaseTimeRecord.emplace(std::make_pair(phaseName, usedTime));
+    if (ret.second) {
+      originOrder.push_back(ret.first);
+    }
+  }
+  phaseTotalTime += usedTime;
+}
+
+void PhaseTimeHandler::DumpPhasesTime() {
+  auto timeLogger = [](const std::string &itemName, time_t itemTimeUs, time_t totalTimeUs) {
+    LogInfo::MapleLogger() << std::left << std::setw(25) << std::setfill(' ') << itemName << std::setw(10)
+                           << std::setfill(' ') << std::right << std::fixed << std::setprecision(2)
+                           << (maplebe::kPercent * itemTimeUs / totalTimeUs) << "%" << std::setw(10)
+                           << std::setfill(' ') << std::setprecision(0) << (itemTimeUs / maplebe::kMicroSecPerMilliSec)
+                           << "ms\n";
+  };
+
+  LogInfo::MapleLogger() << "\n================== TIMEPHASES ==================\n";
+  LogInfo::MapleLogger() << "================================================\n";
+  for (auto phaseIt : std::as_const(originOrder)) {
+    /*
+     * output information by specified format, setw function parameter specifies show width
+     * setprecision function parameter specifies precision
+     */
+    timeLogger(phaseIt->first, phaseIt->second, phaseTotalTime);
+  }
+  LogInfo::MapleLogger() << "================================================\n";
+  timeLogger("Total", phaseTotalTime, phaseTotalTime);
+  LogInfo::MapleLogger() << "================================================\n\n";
+  LogInfo::MapleLogger().unsetf(std::ios::fixed);
+}
+
+const MapleVector<MaplePhaseID> &AnalysisDep::GetRequiredPhase() const {
+  return required;
+}
+const MapleSet<MaplePhaseID> &AnalysisDep::GetPreservedPhase() const {
+  return preserved;
+}
+const MapleSet<MaplePhaseID> &AnalysisDep::GetPreservedExceptPhase() const {
+  return preservedExcept;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_phase/src/phase_driver.cpp b/src/mapleall/maple_phase/src/phase_driver.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e5d8e722457258232fba09a87e8950d1c63de508
--- /dev/null
+++ b/src/mapleall/maple_phase/src/phase_driver.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "phase_driver.h"
+#include "mpl_timer.h"
+
+namespace maple {
+constexpr long kAlternateUnits = 1000;
+thread_local PhaseDriverImpl *PhaseDriver::phaseImplLocal = nullptr;
+PhaseDriver::PhaseDriver(const std::string &phaseName)
+    : MplScheduler(phaseName), module(nullptr), phaseImpl(nullptr), phaseName(phaseName) {}
+
+void PhaseDriver::RunAll(MIRModule *currModule, int thread, bool bSeq) {
+  module = currModule;
+  phaseImpl = NewPhase();
+  CHECK_FATAL(phaseImpl != nullptr, "null ptr check");
+  phaseImpl->GlobalInit();
+  if (thread == 1) {
+    RunSerial();
+  } else {
+    RunParallel(thread, bSeq);
+  }
+  delete phaseImpl;
+  phaseImpl = nullptr;
+}
+
+void PhaseDriver::RunSerial() {
+  phaseImplLocal = NewPhase();
+  CHECK_FATAL(phaseImplLocal != nullptr, "null ptr check");
+  phaseImplLocal->LocalInit();
+  MPLTimer timer;
+  if (dumpTime) {
+    timer.Start();
+  }
+  RegisterTasks();
+  if (dumpTime) {
+    timer.Stop();
+    INFO(kLncInfo, "PhaseDriver::RegisterTasks (%s): %lf ms",
+         phaseName.c_str(), timer.ElapsedMicroseconds() / kAlternateUnits);
+    timer.Start();
+  }
+  MplTask *task = GetTaskToRun();
+  while (task != nullptr) {
+    MplTaskParam *paramRun = CallbackGetTaskRunParam();
+    (void)task->Run(paramRun);
+    MplTaskParam *paramFinish = CallbackGetTaskFinishParam();
+    (void)task->Run(paramFinish);
+  }
+  if (dumpTime) {
+    timer.Stop();
+    INFO(kLncInfo, "PhaseDriver::RunTask (%s): %lf ms",
+         phaseName.c_str(), timer.ElapsedMicroseconds() / kAlternateUnits);
+  }
+}
+
+void PhaseDriver::RunParallel(int thread, bool bSeq) {
+  MPLTimer timer;
+  if (dumpTime) {
+    timer.Start();
+  }
+  RegisterTasks();
+  if (dumpTime) {
+    timer.Stop();
+    INFO(kLncInfo, "PhaseDriver::RegisterTasks (%s): %lf ms",
+         phaseName.c_str(), timer.ElapsedMicroseconds() / kAlternateUnits);
+  }
+  if (dumpTime) {
+    timer.Start();
+  }
+  int ret = RunTask(static_cast<uint32>(thread), bSeq);
+  CHECK_FATAL(ret == 0, "RunTask failed");
+  if (dumpTime) {
+    timer.Stop();
+    INFO(kLncInfo, "PhaseDriver::RunTask (%s): %lf ms",
+         phaseName.c_str(), timer.ElapsedMicroseconds() / kAlternateUnits);
+  }
+}
+
+void PhaseDriver::CallbackThreadMainStart() {
+  phaseImplLocal = NewPhase();
+  CHECK_FATAL(phaseImplLocal != nullptr, "null ptr check");
+  phaseImplLocal->LocalInit();
+}
+
+void PhaseDriver::CallbackThreadMainEnd() {
+  delete phaseImplLocal;
+  phaseImplLocal = nullptr;
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_phase/src/phase_impl.cpp b/src/mapleall/maple_phase/src/phase_impl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e68037f73e31f6048b136289709a36cd9e71a386
--- /dev/null
+++ b/src/mapleall/maple_phase/src/phase_impl.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "phase_impl.h"
+#include "mpl_timer.h"
+
+namespace maple {
+// ========== FuncOptimizeImpl ==========
+FuncOptimizeImpl::FuncOptimizeImpl(MIRModule &mod, KlassHierarchy *kh, bool currTrace)
+    : klassHierarchy(kh), trace(currTrace), module(&mod) {
+  builder = new (std::nothrow) MIRBuilderExt(module);
+  CHECK_FATAL(builder != nullptr, "New fail in FuncOptimizeImpl ctor!");
+}
+
+FuncOptimizeImpl::~FuncOptimizeImpl() {
+  if (builder != nullptr) {
+    delete builder;
+    builder = nullptr;
+  }
+  klassHierarchy = nullptr;
+  currFunc = nullptr;
+  currBlock = nullptr;
+  module = nullptr;
+}
+
+void FuncOptimizeImpl::CreateLocalBuilder(pthread_mutex_t &mtx) {
+  // Each thread needs to use its own MIRBuilderExt.
+  builder = new (std::nothrow) MIRBuilderExt(module, &mtx);
+  CHECK_FATAL(builder != nullptr, "New fail in CreateLocalBuilder ctor!");
+}
+
+void FuncOptimizeImpl::ProcessFunc(MIRFunction *func) {
+  currFunc = func;
+  SetCurrentFunction(*func);
+  if (func->GetBody() != nullptr) {
+    ProcessBlock(*func->GetBody());
+  }
+}
+
+void FuncOptimizeImpl::ProcessBlock(StmtNode &stmt) {
+  switch (stmt.GetOpCode()) {
+    case OP_if: {
+      ProcessStmt(stmt);
+      IfStmtNode &ifStmtNode = static_cast<IfStmtNode&>(stmt);
+      if (ifStmtNode.GetThenPart() != nullptr) {
+        ProcessBlock(*ifStmtNode.GetThenPart());
+      }
+      if (ifStmtNode.GetElsePart() != nullptr) {
+        ProcessBlock(*ifStmtNode.GetElsePart());
+      }
+      break;
+    }
+    case OP_while:
+    case OP_dowhile: {
+      ProcessStmt(stmt);
+      WhileStmtNode &whileStmtNode = static_cast<WhileStmtNode&>(stmt);
+      if (whileStmtNode.GetBody() != nullptr) {
+        ProcessBlock(*whileStmtNode.GetBody());
+      }
+      break;
+    }
+    case OP_block: {
+      BlockNode &block = static_cast<BlockNode&>(stmt);
+      for (StmtNode *stmtNode = block.GetFirst(), *next = nullptr; stmtNode != nullptr; stmtNode = next) {
+        SetCurrentBlock(block);
+        ProcessBlock(*stmtNode);
+        next = stmtNode->GetNext();
+      }
+      break;
+    }
+    default: {
+      ProcessStmt(stmt);
+      break;
+    }
+  }
+}
+
+// ========== FuncOptimizeIterator ==========
+thread_local FuncOptimizeImpl *FuncOptimizeIterator::phaseImplLocal = nullptr;
+
+FuncOptimizeIterator::FuncOptimizeIterator(const std::string &phaseName, std::unique_ptr<FuncOptimizeImpl> phaseImpl)
+    : MplScheduler(phaseName), phaseImpl(std::move(phaseImpl)) {
+  char *envStr = getenv("MP_DUMPTIME");
+  mplDumpTime = (envStr != nullptr && atoi(envStr) == 1);
+}
+
+FuncOptimizeIterator::~FuncOptimizeIterator() = default;
+
+void FuncOptimizeIterator::Run(uint32 threadNum, bool isSeq) {
+  if (threadNum == 1) {
+    RunSerial();
+  } else {
+    RunParallel(threadNum, isSeq);
+  }
+}
+
+void FuncOptimizeIterator::RunSerial() {
+  MPLTimer timer;
+  if (mplDumpTime) {
+    timer.Start();
+  }
+
+  CHECK_NULL_FATAL(phaseImpl);
+  for (MIRFunction *func : std::as_const(phaseImpl->GetMIRModule().GetFunctionList())) {
+    auto dumpPhase = [this, func](bool dumpOption, std::string &&s) {
+      if (dumpOption) {
+        LogInfo::MapleLogger() << ">>>>> Dump " << s << schedulerName << " <<<<<\n";
+        func->Dump();
+        LogInfo::MapleLogger() << ">>>>> Dump " << s << schedulerName << " end <<<<<\n";
+      }
+    };
+    bool dumpFunc = (Options::dumpFunc == "*" || Options::dumpFunc == func->GetName()) &&
+                    (Options::dumpPhase == "*" || Options::dumpPhase == schedulerName);
+    dumpPhase(Options::dumpBefore && dumpFunc, "before ");
+    phaseImpl->SetDump(dumpFunc);
+    phaseImpl->ProcessFunc(func);
+    dumpPhase(Options::dumpAfter && dumpFunc, "after ");
+  }
+
+  phaseImpl->Finish();
+
+  if (mplDumpTime) {
+    timer.Stop();
+    INFO(kLncInfo, "FuncOptimizeIterator::RunSerial (%s): %lf ms", schedulerName.c_str(),
+         timer.ElapsedMicroseconds() / 1000.0);
+  }
+}
+
+void FuncOptimizeIterator::RunParallel(uint32 threadNum, bool isSeq) {
+  MPLTimer timer;
+  if (mplDumpTime) {
+    timer.Start();
+  }
+  Reset();
+
+  CHECK_NULL_FATAL(phaseImpl);
+  for (MIRFunction *func : std::as_const(phaseImpl->GetMIRModule().GetFunctionList())) {
+    std::unique_ptr<Task> task = std::make_unique<Task>(*func);
+    ASSERT_NOT_NULL(task);
+    AddTask(*task.get());
+    tasksUniquePtr.emplace_back(std::move(task));
+  }
+
+  if (mplDumpTime) {
+    timer.Stop();
+    INFO(kLncInfo, "FuncOptimizeIterator::RunParallel (%s): AddTask() = %lf ms", schedulerName.c_str(),
+         timer.ElapsedMicroseconds() / 1000.0);
+
+    timer.Start();
+  }
+
+  int ret = RunTask(threadNum, isSeq);
+  CHECK_FATAL(ret == 0, "RunTask failed");
+  phaseImpl->Finish();
+  Reset();
+
+  if (mplDumpTime) {
+    timer.Stop();
+    INFO(kLncInfo, "FuncOptimizeIterator::RunParallel (%s): RunTask() = %lf ms", schedulerName.c_str(),
+         timer.ElapsedMicroseconds() / 1000.0);
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_util/BUILD.gn b/src/mapleall/maple_util/BUILD.gn
new file mode 100755
index 0000000000000000000000000000000000000000..2c824f7730c6654cff469e5273f1baa81b785509
--- /dev/null
+++ b/src/mapleall/maple_util/BUILD.gn
@@ -0,0 +1,66 @@
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+src_libmplutil = [
+  "src/mpl_logging.cpp",
+  "src/muid.cpp",
+  "src/namemangler.cpp",
+  "src/literalstrname.cpp",
+  "src/file_layout.cpp",
+  "src/file_utils.cpp",
+  "src/mpl_scheduler.cpp",
+  "src/itab_util.cpp",
+  "src/mpl_timer.cpp",
+  "src/profile.cpp",
+  "src/string_utils.cpp",
+  "src/error_code.cpp",
+  "src/thread_env.cpp",
+  "src/mpl_int_val.cpp",
+  "src/mpl_profdata.cpp",
+  "src/suffix_array.cpp",
+  "src/mpl_posix_sighandler.cpp"
+]
+
+src_libcommandline = [
+  "src/cl_option.cpp",
+  "src/cl_option_parser.cpp",
+  "src/cl_parser.cpp",
+]
+
+include_libmplutil = [
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+]
+
+include_libcommandline = [
+  "${MAPLEALL_ROOT}/maple_util/include",
+]
+
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+
+static_library("libmplutil") {
+  sources = src_libmplutil
+  include_dirs = include_libmplutil
+  libs = [ "pthread", "dl" ]
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
+
+static_library("libcommandline") {
+  sources = src_libcommandline
+  include_dirs = include_libcommandline
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
diff --git a/src/mapleall/maple_util/CMakeLists.txt b/src/mapleall/maple_util/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..52df33156ba9b840911a7131e2a3ccdf626b1aa2
--- /dev/null
+++ b/src/mapleall/maple_util/CMakeLists.txt
@@ -0,0 +1,80 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(src_libmplutil
+    src/mpl_logging.cpp
+    src/muid.cpp
+    src/namemangler.cpp
+    src/literalstrname.cpp
+    src/file_layout.cpp
+    src/file_utils.cpp
+    src/mpl_scheduler.cpp
+    src/itab_util.cpp
+    src/mpl_timer.cpp
+    src/profile.cpp
+    src/string_utils.cpp
+    src/error_code.cpp
+    src/thread_env.cpp
+    src/mpl_int_val.cpp
+    src/mpl_profdata.cpp
+    src/suffix_array.cpp
+    src/mpl_posix_sighandler.cpp
+)
+
+set(src_libcommandline
+    src/cl_option.cpp
+    src/cl_option_parser.cpp
+    src/cl_parser.cpp
+)
+
+# libmplutil
+add_library(libmplutil STATIC ${src_libmplutil})
+target_include_directories(libmplutil PRIVATE
+  ${MAPLEALL_ROOT}/maple_util/include
+  ${MAPLEALL_ROOT}/maple_ir/include
+  ${MAPLEALL_ROOT}/mempool/include
+  ${MAPLEALL_ROOT}/maple_driver/include
+  ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+  include
+)
+#set(THREADS_PREFER_PTHREAD_FLAG ON) # -pthread
+set(CMAKE_THREAD_LIBS_INIT "-lpthread")
+set(CMAKE_HAVE_THREADS_LIBRARY 1)
+set(CMAKE_USE_WIN32_THREADS_INIT 0)
+set(CMAKE_USE_PTHREADS_INIT 1)
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+#target_link_libraries(libmplutil pthread)
+set_target_properties(libmplutil PROPERTIES 
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+    #    STATIC_LIBRARY_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} -lpthread -ldl"
+)
+
+
+#libcommandline
+add_library(libcommandline STATIC ${src_libcommandline})
+target_include_directories(libcommandline PRIVATE
+    ${MAPLEALL_ROOT}/maple_util/include
+    include
+)
+set_target_properties(libcommandline PROPERTIES 
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
+
+
+
+
+
+
diff --git a/src/mapleall/maple_util/include/base_graph_node.h b/src/mapleall/maple_util/include/base_graph_node.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae168a48a5909ff7b3af15eaf5fcb910fb3b080f
--- /dev/null
+++ b/src/mapleall/maple_util/include/base_graph_node.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_BASE_GRAPH_NODE_H
+#define MAPLE_UTIL_INCLUDE_BASE_GRAPH_NODE_H
+#include "types_def.h"
+#include "mempool_allocator.h"
+namespace maple {
+class BaseGraphNode {
+ public:
+  explicit BaseGraphNode(uint32 index) : id(index) {}
+  virtual ~BaseGraphNode() = default;
+  virtual void GetOutNodes(std::vector<BaseGraphNode*> &outNodes) = 0;
+  virtual void GetOutNodes(std::vector<BaseGraphNode*> &outNodes) const = 0;
+  virtual void GetInNodes(std::vector<BaseGraphNode*> &outNodes) = 0;
+  virtual void GetInNodes(std::vector<BaseGraphNode*> &outNodes) const = 0;
+  virtual const std::string GetIdentity() = 0;
+
+  uint32 GetID() const {
+    return id;
+  }
+ protected:
+  void SetID(uint32 newIdx) {
+    id = newIdx;
+  }
+ private:
+  uint32 id;
+};
+
+// BaseGraphNode needs to be the base class of T
+template<typename T, std::enable_if_t<std::is_base_of<BaseGraphNode, T>::value, bool> = true>
+void ConvertToVectorOfBasePtr(const MapleVector<T*> &originVec, MapleVector<BaseGraphNode*> &targetVec) {
+  for (auto &item : originVec) {
+    targetVec.emplace_back(item);
+  }
+}
+}
+#endif /* MAPLE_UTIL_INCLUDE_BASE_GRAPH_NODE_H */
diff --git a/src/mapleall/maple_util/include/cl_option.h b/src/mapleall/maple_util/include/cl_option.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8ac8025a002232952a9de1ad654f8d20e40fb2e
--- /dev/null
+++ b/src/mapleall/maple_util/include/cl_option.h
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_OPTION_H
+#define MAPLE_UTIL_INCLUDE_OPTION_H
+
+#include "cl_parser.h"
+
+#include <any>
+#include <cassert>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+#include <iostream>
+#include "mpl_logging.h"
+
+namespace maplecl {
+
+template <typename T>
+constexpr inline bool digitalCheck = (std::is_same_v<std::uint8_t, T> ||
+                                      std::is_same_v<std::uint16_t, T> ||
+                                      std::is_same_v<std::uint32_t, T> ||
+                                      std::is_same_v<std::uint64_t, T> ||
+                                      std::is_same_v<std::int64_t, T> ||
+                                      std::is_same_v<std::int32_t, T> ||
+                                      std::is_same_v<std::int16_t, T> ||
+                                      std::is_same_v<std::int8_t, T>);
+
+/* is key VALUE needed ? */
+enum class ValueExpectedType {
+  kValueOptional, /* "--key VALUE" and "--key" are allowed */
+  kValueRequired,     /* only "--key VALUE" is allowed */
+  kValueDisallowed,   /* only "--key" is allowed */
+};
+
+/* is "joined option" (like -DMACRO) allowed ? */
+enum class ValueJoinedType {
+  kValueSeparated,
+  kValueJoined,      /* joined option (like -DMACRO) is allowed */
+};
+
+/* is option visible from Help ? */
+enum class OptionVisibilityType {
+  kVisibleOption, /* an Option will be visible in Help */
+  kHidedOption    /* an Option will be NOT visible in Help */
+};
+
+/* This enum is used as the option attribute to detect "=" in the original option.
+ * It can be useful to forward original option in an external tool.
+ * As example: user sets maple -std=gnu11 ; In this case, maple will forward -std
+ * option in clang, but clang can detect this option only with "=":
+ * clang -std=gnu11 (NOT clang -std gnu11). So this attribute is used for correct forwarding.
+ */
+enum class EqualType {
+  kWithEqual,
+  kWithoutEqual
+};
+
+/* These constexpr are needed to use short name in option description, like this:
+ * maplecl::Option<int32_t> option({"--option"}, "Description", optionalValue);
+ * instead of:
+ * maplecl::Option<int32_t> option({"--option"}, "Description", ValueExpectedType::kValueOptional);
+ */
+constexpr ValueExpectedType optionalValue = ValueExpectedType::kValueOptional;
+constexpr ValueExpectedType requiredValue = ValueExpectedType::kValueRequired;
+constexpr ValueExpectedType disallowedValue = ValueExpectedType::kValueDisallowed;
+constexpr ValueJoinedType joinedValue = ValueJoinedType::kValueJoined;
+constexpr ValueJoinedType separatedValue = ValueJoinedType::kValueSeparated;
+constexpr OptionVisibilityType visible = OptionVisibilityType::kVisibleOption;
+constexpr OptionVisibilityType hide = OptionVisibilityType::kHidedOption;
+
+/* Initializer is used to set default value for an option */
+template <typename T> struct Init {
+  const T &defaultVal;
+  explicit Init(const T &val) : defaultVal(val) {}
+};
+
+/* DisableWithData is used to set additional option name to disable this option.
+ * Example: Base option: --opt; Additional option: --no-opt.
+ * --no-opt will disable this option in this example.
+ */
+struct DisableWith {
+  const std::string &disableWith;
+  explicit DisableWith(const std::string &val) : disableWith(val) {}
+};
+struct DisableEvery {
+  const std::vector<std::string> &disableEvery;
+  explicit DisableEvery(const std::vector<std::string> &val) : disableEvery(val) {}
+};
+
+using OptionCategoryRefWrp = std::reference_wrapper<OptionCategory>;
+
+class OptionWrp {
+ public:
+  template <typename T>
+  /* implicit */
+  OptionWrp(T v) : val(v) {}
+
+  template <typename T>
+  operator T() const {
+    const T *pval = std::any_cast<const T>(&val);
+    ASSERT_NOT_NULL(pval);
+    return *pval;
+  }
+
+  std::any val;
+};
+
+/* Interface for templated Option class */
+class OptionInterface {
+ public:
+  virtual ~OptionInterface() = default;
+
+  virtual RetCode Parse(size_t &argsIndex,
+                        const std::deque<std::string_view> &args, KeyArg &keyArg) = 0;
+  virtual void Clear() = 0;
+  virtual std::vector<std::string> GetRawValues() = 0;
+  virtual const OptionWrp GetCommonValue() const = 0;
+
+  void FinalizeInitialization(const std::vector<std::string> &optnames,
+                              const std::string &descr,
+                              const std::vector<OptionCategoryRefWrp> &optionCategories);
+
+  bool IsEnabledByUser() const {
+    return isEnabledByUser;
+  }
+
+  ValueExpectedType ExpectedVal() const {
+    return valueExpected;
+  }
+
+  bool IsJoinedValPermitted() const {
+    return (valueJoined == ValueJoinedType::kValueJoined);
+  }
+
+  bool IsVisibleOption() const {
+    return (visibleOption == OptionVisibilityType::kVisibleOption);
+  }
+
+  const std::vector<std::string> &GetDisabledName() const {
+    return disableWith;
+  }
+
+  virtual std::string GetName() const {
+    assert(names.size() > 0);
+    return names[0];
+  }
+
+  const std::string &GetDescription() const {
+    return optDescription;
+  }
+
+  EqualType GetEqualType() const {
+    return equalSign;
+  }
+
+  void SetEqualType(EqualType equal) {
+    equalSign = equal;
+  }
+
+  std::string rawKey;
+  std::vector<OptionCategory *> optCategories; // The option is registred in these categories
+
+ protected:
+  std::vector<std::string> names; // names of the option
+  std::string optDescription;     // overview of option
+  std::vector<std::string> disableWith;        // name to disable the option
+
+  bool isEnabledByUser = false;   // it's set if the option is in command line
+
+  ValueExpectedType valueExpected = ValueExpectedType::kValueRequired;  // whether the value is expected
+  ValueJoinedType valueJoined = ValueJoinedType::kValueSeparated;     // Joined option like -DMACRO
+  OptionVisibilityType visibleOption = OptionVisibilityType::kVisibleOption; // Visible in Help
+
+  EqualType equalSign = EqualType::kWithoutEqual;
+};
+
+/* Option class describes command line option */
+template <typename T>
+class Option : public OptionInterface {
+ public:
+  /* variadic template is used to apply any number of options parameters in any order */
+  template <typename... ArgsT>
+  explicit Option(const std::vector<std::string> &optnames,
+                  const std::string &descr,
+                  const ArgsT &... args) {
+    /* It's needed to avoid empty Apply() */
+    if constexpr (sizeof...(ArgsT) > 0) {
+      Apply(args...);
+    }
+    FinalizeInitialization(optnames, descr, {});
+  }
+
+  /* variadic template is used to apply any number of options parameters in any order */
+  template <typename... ArgsT>
+  explicit Option(const std::vector<std::string> &optnames,
+                  const std::string &descr,
+                  const std::vector<OptionCategoryRefWrp> &optionCategories,
+                  const ArgsT &... args) {
+    /* It's needed to avoid empty Apply() */
+    if constexpr (sizeof...(ArgsT) > 0) {
+        Apply(args...);
+    }
+    FinalizeInitialization(optnames, descr, optionCategories);
+  }
+
+  // options must not be copyable and assignment
+  Option(const Option &) = delete;
+  Option &operator=(const Option &) = delete;
+
+  /* Conversation operator is needed to use the option like this:
+   * strding test = option1; or int dig = option2 - here will be implicit conversation.
+   */
+  /* implicit */
+  operator T() {
+    return GetValue();
+  }
+
+  RetCode Parse(size_t &argsIndex, const std::deque<std::string_view> &args,
+                KeyArg &keyArg) override {
+    RetCode err = RetCode::noError;
+    auto &key = args[argsIndex];
+    if constexpr(digitalCheck<T>) {
+      err = ParseDigit(argsIndex, args, keyArg);
+    } else if constexpr(std::is_same_v<std::string, T>) {
+      err = ParseString(argsIndex, args, keyArg);
+    } else if constexpr(std::is_same_v<bool, T>) {
+      err = ParseBool(argsIndex, args);
+    } else {
+      /* Type dependent static_assert. Simple static_assert(false") does not work */
+      static_assert(false && (sizeof(T) != 0), "T not supported");
+    }
+
+    if (err == RetCode::noError) {
+      isEnabledByUser = true;
+      rawKey = key;
+    }
+    return err;
+  }
+
+  void Clear() override {
+    if (defaultValue.isSet) {
+      value = defaultValue.defaultValue;
+    } else {
+      if constexpr(digitalCheck<T>) {
+        value = 0;
+      } else if constexpr(std::is_same_v<std::string, T>) {
+        value = "";
+      } else if constexpr(std::is_same_v<bool, T>) {
+        value = false;
+      } else {
+        /* Type dependent static_assert. Simple static_assert(false") does not work */
+        static_assert(false && (sizeof(T) != 0), "T not supported");
+      }
+    }
+
+    for (auto &category : optCategories) {
+      category->Remove(this);
+    }
+
+    isEnabledByUser = false;
+  }
+
+  std::vector<std::string> GetRawValues() override {
+    std::vector<std::string> rawVals;
+    FillVal(value, rawVals);
+    return rawVals;
+  }
+
+  std::string GetName() const override {
+    if constexpr (std::is_same_v<bool, T>) {
+      assert(names.size() > 0);
+      return (value ? names[0] : this->GetDisabledName()[0]);
+    } else {
+      return OptionInterface::GetName();
+    }
+  }
+
+  const T &GetValue() const {
+    return value;
+  }
+
+  const OptionWrp GetCommonValue() const override {
+    return value;
+  }
+
+  virtual void SetValue(const T &val) {
+    value = val;
+  }
+
+ protected:
+  RetCode ParseDigit(size_t &argsIndex, const std::deque<std::string_view> &args, KeyArg &keyArg);
+  RetCode ParseString(size_t &argsIndex, const std::deque<std::string_view> &args, KeyArg &keyArg);
+  RetCode ParseBool(size_t &argsIndex, const std::deque<std::string_view> &args);
+
+  void FillVal(const T &val, std::vector<std::string> &vals) {
+    if constexpr(digitalCheck<T>) {
+      (void)vals.emplace_back(std::to_string(val));
+    } else if constexpr (std::is_same_v<std::string, T>) {
+      (void)vals.emplace_back(val);
+    } else if constexpr (std::is_same_v<bool, T>) {
+      (void)vals.emplace_back("");
+    } else {
+      /* Type dependent static_assert. Simple static_assert(false") does not work */
+      static_assert(false && (sizeof(T) != 0), "T not supported");
+    }
+  }
+
+  struct DefaultValue {
+    T defaultValue;
+    bool isSet = false;
+  } defaultValue;
+
+ private:
+  /* To apply input arguments in any order */
+  template <typename ArgT, typename... ArgsT>
+  void Apply(const ArgT &arg, const ArgsT &...args) {
+    if constexpr (std::is_same_v<ValueExpectedType, ArgT>) {
+      SetExpectingAttribute(arg);
+    } else if constexpr (std::is_same_v<ValueJoinedType, ArgT>) {
+      SetJoinAttribute(arg);
+    } else if constexpr (std::is_same_v<OptionVisibilityType, ArgT>) {
+      SetVisibilityAttribute(arg);
+    } else if constexpr (std::is_same_v<DisableWith, ArgT>) {
+      SetDisablingAttribute(arg);
+    } else if constexpr (std::is_same_v<DisableEvery, ArgT>) {
+      SetDisablingAttribute(arg);
+    } else {
+      SetDefaultAttribute(arg);
+    }
+
+    /* It's needed to avoid empty Apply() */
+    if constexpr (sizeof...(ArgsT) > 0) {
+      Apply(args...);
+    }
+  }
+
+  template <typename InitT>
+  void SetDefaultAttribute(const Init<InitT> &initializer) {
+    SetValue(initializer.defaultVal);
+    defaultValue.isSet = true;
+    defaultValue.defaultValue = value;
+  }
+
+  void SetExpectingAttribute(ValueExpectedType valueExpectedType) {
+    valueExpected = valueExpectedType;
+  }
+
+  void SetJoinAttribute(ValueJoinedType valueJoinedType) {
+    valueJoined = valueJoinedType;
+  }
+
+  void SetVisibilityAttribute(OptionVisibilityType optionVisibilityType) {
+    visibleOption = optionVisibilityType;
+  }
+
+  void SetDisablingAttribute(const DisableWith &disableWithArg) {
+    disableWith.push_back(disableWithArg.disableWith);
+  }
+
+  void SetDisablingAttribute(const DisableEvery &disableWithArg) {
+    for (auto &val : disableWithArg.disableEvery) {
+      disableWith.push_back(val);
+    }
+  }
+
+  T value;
+};
+
+template <typename T>
+bool operator==(Option<T>& opt, const T& arg) {
+  return (opt.GetValue() == arg);
+}
+
+template <typename T>
+bool operator==(const T& arg, Option<T>& opt) {
+  return opt == arg;
+}
+
+/* To handle the comparation of "const char *" and "Option<string>".
+ * This comparation can not be handled with comparation template above! */
+template <typename T>
+bool operator==(Option<T>& opt, const char *arg) {
+  return (opt.GetValue() == arg);
+}
+
+template <typename T>
+bool operator==(const char *arg, Option<T>& opt) {
+  return opt == arg;
+}
+
+template <typename T>
+void CopyIfEnabled(T &dst, maplecl::Option<T> &src) {
+  if (src.IsEnabledByUser()) {
+    dst = src;
+  }
+}
+
+template <typename T>
+void CopyIfEnabled(T &dst, const T &src, const OptionInterface &opt) {
+  if (opt.IsEnabledByUser()) {
+    dst = src;
+  }
+}
+
+template <typename T>
+class List : public Option<T> {
+ public:
+  // options must not be copyable and assignment
+  List(const List &) = delete;
+  List &operator=(const List &) = delete;
+
+  /* variadic template is used to apply any number of options parameters in any order */
+  template <typename... ArgsT>
+  explicit List(const std::vector<std::string> &optnames,
+                const std::string &descr,
+                const ArgsT &... args) : Option<T>(optnames, descr, args...) {};
+
+  template <typename... ArgsT>
+  explicit List(const std::vector<std::string> &optnames,
+                const std::string &descr,
+                const std::vector<OptionCategoryRefWrp> &optionCategories,
+                const ArgsT &... args) : Option<T>(optnames, descr, optionCategories, args...) {};
+
+  void Clear() override {
+    values.clear();
+    if (this->defaultValue.isSet) {
+      SetValue(this->defaultValue.defaultValue);
+    }
+    this->isEnabledByUser = false;
+
+    for (auto &category : this->optCategories) {
+      category->Remove(this);
+    }
+  }
+
+  void SetValue(const T &val) override {
+    values.push_back(val);
+  }
+
+  const T &GetValue() const {
+    static_assert(false && (sizeof(T) != 0), "GetValue must be not used for List");
+    return T();
+  }
+
+  const std::vector<T> &GetValues() const {
+    return values;
+  }
+
+  std::vector<std::string> GetRawValues() override {
+    std::vector<std::string> rawVals;
+    for (const auto &val : values) {
+      this->FillVal(val, rawVals);
+    }
+
+    return rawVals;
+  }
+
+ private:
+  std::vector<T> values;
+};
+
+}
+
+#endif /* MAPLE_UTIL_INCLUDE_OPTION_H */
diff --git a/src/mapleall/maple_util/include/cl_parser.h b/src/mapleall/maple_util/include/cl_parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b03e929795b1055681de8599712a5b68c17bb72
--- /dev/null
+++ b/src/mapleall/maple_util/include/cl_parser.h
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_PARSER_H
+#define MAPLE_UTIL_INCLUDE_PARSER_H
+
+#include <algorithm>
+#include <map>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <deque>
+
+namespace maplecl {
+
+enum class RetCode {
+  noError,
+  notRegistered,
+  incorrectValue,
+  unnecessaryValue,
+  outOfRange,
+  notSupportedOptionType,
+  valueEmpty,
+  parsingErr,
+};
+
+class OptionInterface;
+
+using OptionsMapType = std::unordered_map<std::string, OptionInterface *>;
+
+/* This structure is used to aggregate option information during option parsing.
+ * It's a string view from original input command line string. */
+struct KeyArg {
+  explicit KeyArg(const std::string_view &arg) : rawArg(arg) {}
+  const std::string_view rawArg; /* full option, like "--key=value" */
+  std::string_view key; /* Extracted key, like "--key" */
+  std::string_view val; /* Extracted value, like "value" */
+  bool isEqualOpt = false; /* indicates whether the parsed option contained "=" symbol.
+                              For options like --key=value, it's true. For options like --key value, it's false */
+  bool isJoinedOpt = false; /* indicates whether the parsed option was a joined option, like: --optValue */
+};
+
+struct OptionCategory {
+  OptionsMapType options;
+  OptionsMapType joinedOptions;
+  std::vector<OptionInterface *> registredOptions;
+
+  void AddEnabledOption(OptionInterface *opt) {
+    if (enabledOptionsSet.find(opt) == enabledOptionsSet.end()) {
+      enabledOptionsSet.insert(opt);
+      enabledOptions.push_back(opt);
+    }
+  }
+
+  const std::vector<OptionInterface *> &GetEnabledOptions() {
+    return enabledOptions;
+  }
+
+  void Remove(OptionInterface *opt) {
+    enabledOptionsSet.erase(opt);
+    auto it = std::find(enabledOptions.begin(), enabledOptions.end(), opt);
+    if (it != enabledOptions.end()) {
+      (void)enabledOptions.erase(it);
+    }
+  }
+
+ private:
+  std::unordered_set<OptionInterface *> enabledOptionsSet;
+  std::vector<OptionInterface *> enabledOptions;
+};
+
+class CommandLine {
+ public:
+  CommandLine() {}
+  ~CommandLine() = default;
+
+  /* singleton */
+  static CommandLine &GetCommandLine();
+
+  // CommandLine must not be copyable
+  CommandLine(const CommandLine &) = delete;
+  CommandLine &operator=(const CommandLine &) = delete;
+
+  RetCode Parse(int argc, char **argv, OptionCategory &optCategory);
+  RetCode Parse(int argc, char **argv) {
+    return Parse(argc, argv, defaultCategory);
+  }
+
+  RetCode HandleInputArgs(const std::deque<std::string_view> &args,
+                          OptionCategory &optCategory);
+  void Register(const std::vector<std::string> &optNames, OptionInterface &opt,
+                OptionCategory &optCategory);
+
+  void Clear(OptionCategory &optCategory);
+  void Clear() {
+    return Clear(defaultCategory);
+  }
+
+  void BashCompletionPrinter(const OptionCategory &optCategory) const;
+  void BashCompletionPrinter() const {
+    return BashCompletionPrinter(defaultCategory);
+  }
+
+  void HelpPrinter(const OptionCategory &optCategory) const;
+  void HelpPrinter() const {
+    return HelpPrinter(defaultCategory);
+  }
+
+  std::vector<std::pair<std::string, RetCode>> badCLArgs;
+  OptionCategory defaultCategory;
+
+  /* NOTE: categories must be constructed before options.
+   * It's the reason why they are inside CommandLine.
+   * Looks like ugly architecture, but we need it */
+  OptionCategory clangCategory;
+  OptionCategory hir2mplCategory;
+  OptionCategory mpl2mplCategory;
+  OptionCategory meCategory;
+  OptionCategory cgCategory;
+  OptionCategory asCategory;
+  OptionCategory ldCategory;
+
+  OptionCategory dex2mplCategory;
+  OptionCategory jbc2mplCategory;
+  OptionCategory ipaCategory;
+
+ private:
+  OptionInterface *CheckJoinedOption(KeyArg &keyArg, OptionCategory &optCategory);
+  RetCode ParseJoinedOption(size_t &argsIndex,
+                            const std::deque<std::string_view> &args,
+                            KeyArg &keyArg, OptionCategory &optCategory);
+  RetCode ParseOption(size_t &argsIndex,
+                      const std::deque<std::string_view> &args,
+                      KeyArg &keyArg, const OptionCategory &optCategory,
+                      OptionInterface *opt);
+  RetCode ParseEqualOption(size_t &argsIndex,
+                           const std::deque<std::string_view> &args,
+                           KeyArg &keyArg, OptionCategory &optCategory,
+                           const OptionsMapType &optMap, ssize_t pos);
+  RetCode ParseSimpleOption(size_t &argsIndex,
+                            const std::deque<std::string_view> &args,
+                            KeyArg &keyArg, OptionCategory &optCategory,
+                            const OptionsMapType &optMap);
+};
+
+}
+
+#endif /* MAPLE_UTIL_INCLUDE_PARSER_H */
diff --git a/src/mapleall/maple_util/include/dominance.h b/src/mapleall/maple_util/include/dominance.h
new file mode 100644
index 0000000000000000000000000000000000000000..284e2ca252c2f73e219d3e40a7dc36ae3880f2b8
--- /dev/null
+++ b/src/mapleall/maple_util/include/dominance.h
@@ -0,0 +1,428 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_DOMINANCE_H
+#define MAPLE_UTIL_INCLUDE_DOMINANCE_H
+#include "mpl_number.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "types_def.h"
+#include "base_graph_node.h"
+namespace maple {
+class Dominance {
+ public:
+  using NodeId = uint32;
+
+  Dominance(MemPool &memPool, MapleVector<BaseGraphNode*> &nodeVec, BaseGraphNode &commonEntryNode,
+            BaseGraphNode &commonExitNode, bool isPdom)
+      : domAllocator(&memPool),
+        nodeVec(nodeVec),
+        commonEntryNode(commonEntryNode),
+        commonExitNode(commonExitNode),
+        isPdom(isPdom),
+        postOrderIDVec(nodeVec.size(), -1, domAllocator.Adapter()),
+        reversePostOrder(domAllocator.Adapter()),
+        reversePostOrderId(domAllocator.Adapter()),
+        doms(domAllocator.Adapter()),
+        domFrontier(nodeVec.size(), MapleSet<NodeId>(domAllocator.Adapter()), domAllocator.Adapter()),
+        domChildren(nodeVec.size(), MapleVector<NodeId>(domAllocator.Adapter()), domAllocator.Adapter()),
+        iterDomFrontier(nodeVec.size(), MapleSet<NodeId>(domAllocator.Adapter()), domAllocator.Adapter()),
+        dtPreOrder(nodeVec.size(), NodeId(0), domAllocator.Adapter()),
+        dtDfn(nodeVec.size(), -1, domAllocator.Adapter()) {}
+
+  ~Dominance() = default;
+
+  const MapleVector<BaseGraphNode*> &GetNodeVec() const {
+    return nodeVec;
+  }
+
+  bool IsNodeVecEmpty() const {
+    return nodeVec.empty();
+  }
+
+  size_t GetNodeVecSize() const {
+    return nodeVec.size();
+  }
+
+  BaseGraphNode *GetNodeAt(size_t i) const {
+    return nodeVec.at(i);
+  }
+
+  BaseGraphNode &GetCommonEntryNode() const {
+    return commonEntryNode;
+  }
+
+  BaseGraphNode &GetCommonExitNode() const {
+    return commonExitNode;
+  }
+
+  const BaseGraphNode *GetReversePostOrder(size_t idx) const {
+    return reversePostOrder[idx];
+  }
+
+  const MapleVector<BaseGraphNode*> &GetReversePostOrder() const {
+    return reversePostOrder;
+  }
+
+  MapleVector<BaseGraphNode*> &GetReversePostOrder() {
+    return reversePostOrder;
+  }
+
+  const MapleVector<uint32> &GetReversePostOrderId() {
+    if (reversePostOrderId.empty()) {
+      reversePostOrderId.resize(nodeVec.size(), 0);
+      for (size_t id = 0; id < reversePostOrder.size(); ++id) {
+        reversePostOrderId[reversePostOrder[id]->GetID()] = static_cast<uint32>(id);
+      }
+    }
+    return reversePostOrderId;
+  }
+
+  BaseGraphNode *GetDom(NodeId id) {
+    auto it = doms.find(id);
+    if (it == doms.end()) {
+      return nullptr;
+    }
+    return it->second;
+  }
+
+  MapleSet<NodeId> &GetDomFrontier(size_t idx) {
+    return domFrontier[idx];
+  }
+
+  const MapleSet<NodeId> &GetDomFrontier(size_t idx) const {
+    return domFrontier.at(idx);
+  }
+
+  size_t GetDomFrontierSize() const {
+    return domFrontier.size();
+  }
+
+  const MapleSet<NodeId> &GetIterDomFrontier(const NodeId &idx) const {
+    return iterDomFrontier[idx];
+  }
+
+  MapleSet<NodeId> &GetIterDomFrontier(const NodeId &idx) {
+    return iterDomFrontier[idx];
+  }
+
+  size_t GetIterDomFrontierSize() const {
+    return iterDomFrontier.size();
+  }
+
+  const MapleVector<NodeId> &GetDomChildren(const NodeId &idx) const {
+    return domChildren[idx];
+  }
+
+  MapleVector<NodeId> &GetDomChildren(const NodeId &idx) {
+    return domChildren[idx];
+  }
+
+  size_t GetDomChildrenSize() const {
+    return domChildren.size();
+  }
+
+  const NodeId &GetDtPreOrderItem(size_t idx) const {
+    return dtPreOrder[idx];
+  }
+
+  const MapleVector<NodeId> &GetDtPreOrder() const {
+    return dtPreOrder;
+  }
+
+  size_t GetDtPreOrderSize() const {
+    return dtPreOrder.size();
+  }
+
+  uint32 GetDtDfnItem(size_t idx) const {
+    return dtDfn[idx];
+  }
+
+  size_t GetDtDfnSize() const {
+    return dtDfn.size();
+  }
+
+  void DumpDoms() const {
+    const std::string tag = isPdom ? "pdom" : "dom";
+    for (auto &node : reversePostOrder) {
+      auto nodeId = node->GetID();
+      LogInfo::MapleLogger() << tag << "_postorder no " << postOrderIDVec[nodeId];
+      LogInfo::MapleLogger() << " is node:" << nodeId;
+      LogInfo::MapleLogger() << " im_" << tag << " is node:" << doms.at(nodeId)->GetID();
+      LogInfo::MapleLogger() << " " << tag << "frontier: [";
+      for (auto &id : domFrontier[nodeId]) {
+        LogInfo::MapleLogger() << id << " ";
+      }
+      LogInfo::MapleLogger() << "] iter" << tag << "Frontier: [";
+      for (auto &id : iterDomFrontier[nodeId]) {
+        LogInfo::MapleLogger() << id << " ";
+      }
+      LogInfo::MapleLogger() << "] " << tag << "children: [";
+      for (auto &id : domChildren[nodeId]) {
+        LogInfo::MapleLogger() << id << " ";
+      }
+      LogInfo::MapleLogger() << "]\n";
+    }
+    LogInfo::MapleLogger() << "\npreorder traversal of " << tag << " tree:";
+    for (auto &id : dtPreOrder) {
+      LogInfo::MapleLogger() << id << " ";
+    }
+    LogInfo::MapleLogger() << "\n\n";
+  }
+
+  void Init() {
+    GenPostOrderID();
+    ComputeDominance();
+    ComputeDomFrontiers();
+    ComputeDomChildren();
+    ComputeIterDomFrontiers();
+    size_t num = 0;
+    ComputeDtPreorder(num);
+    dtPreOrder.resize(num);
+    ComputeDtDfn();
+  }
+
+  // true if b1 dominates b2
+  bool Dominate(const BaseGraphNode &node1, const BaseGraphNode &node2) const {
+    if (&node1 == &node2) {
+      return true;
+    }
+    const auto *iDom = &node2;
+    while (iDom != &commonEntryNode) {
+      auto it = doms.find(iDom->GetID());
+      if (it == doms.end() || it->second == nullptr) {
+        return false;
+      }
+      iDom = it->second;
+      if (iDom == &node1) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+ private:
+  void GenPostOrderID() {
+    ASSERT(!nodeVec.empty(), "size to be allocated is 0");
+    std::vector<bool> visitedMap(nodeVec.size(), false);
+    int32 postOrderID = 0;
+    PostOrderWalk(commonEntryNode, postOrderID, visitedMap);
+    // initialize reversePostOrder
+    reversePostOrder.resize(postOrderID);
+    auto maxPostOrderID = postOrderID - 1;
+    for (size_t i = 0; i < postOrderIDVec.size(); ++i) {
+      auto postOrderNo = postOrderIDVec[i];
+      if (postOrderNo == -1) {
+        continue;
+      }
+      reversePostOrder[maxPostOrderID - postOrderNo] = nodeVec[i];
+    }
+  }
+
+  // Figure 5 in "A Simple, Fast Dominance Algorithm" by Keith Cooper et al.
+  void ComputeDomFrontiers() {
+    constexpr uint32 kNodeVectorInitialSize = 2;
+    for (const auto node : nodeVec) {
+      if (node == nullptr || node == &commonExitNode) {
+        continue;
+      }
+      std::vector<BaseGraphNode*> prevNodes;
+      GetPrevNodesToVisit(*node, prevNodes);
+
+      if (prevNodes.size() < kNodeVectorInitialSize) {
+        continue;
+      }
+      for (auto *pre : prevNodes) {
+        auto runner = pre;
+        while (runner != doms.at(node->GetID()) && runner != &commonEntryNode) {
+          (void)domFrontier[runner->GetID()].insert(node->GetID());
+          runner = doms.at(runner->GetID());
+        }
+      }
+    }
+  }
+
+  void ComputeDomChildren() {
+    for (const auto node : reversePostOrder) {
+      if (node == nullptr) {
+        continue;
+      }
+      auto *parent = doms.at(node->GetID());
+      if (parent == nullptr || parent == node) {
+        continue;
+      }
+      domChildren[parent->GetID()].push_back(node->GetID());
+    }
+  }
+
+  void ComputeIterDomFrontiers() {
+    for (auto &node : nodeVec) {
+      if (node == nullptr || node == &commonExitNode) {
+        continue;
+      }
+      std::vector<bool> visitedMap(nodeVec.size(), false);
+      GetIterDomFrontier(*node, iterDomFrontier[node->GetID()], node->GetID(), visitedMap);
+    }
+  }
+
+  void ComputeDtPreorder(size_t &num) {
+    ComputeDtPreorder(commonEntryNode, num);
+  }
+
+  void ComputeDtDfn() {
+    for (size_t i = 0; i < dtPreOrder.size(); ++i) {
+      dtDfn[dtPreOrder[i]] = i;
+    }
+  }
+
+  // Figure 3 in "A Simple, Fast Dominance Algorithm" by Keith Cooper et al.
+  void ComputeDominance() {
+    doms[commonEntryNode.GetID()] = &commonEntryNode;
+    bool changed;
+    do {
+      changed = false;
+      for (size_t i = 1; i < reversePostOrder.size(); ++i) {
+        auto node = reversePostOrder[i];
+        BaseGraphNode *pre = nullptr;
+        std::vector<BaseGraphNode*> prevNodes;
+        GetPrevNodesToVisit(*node, prevNodes);
+        auto numOfPrevNodes = prevNodes.size();
+        if (InitNodeIsPred(*node) || numOfPrevNodes == 0) {
+          pre = &commonEntryNode;
+        } else {
+          pre = prevNodes[0];
+        }
+        size_t j = 1;
+        while ((doms[pre->GetID()] == nullptr || pre == node) && j < numOfPrevNodes) {
+          pre = prevNodes[j];
+          ++j;
+        }
+        BaseGraphNode *newIDom = pre;
+        for (; j < numOfPrevNodes; ++j) {
+          pre = prevNodes[j];
+          if (doms[pre->GetID()] != nullptr && pre != node) {
+            newIDom = Intersect(*pre, *newIDom);
+          }
+        }
+        if (doms[node->GetID()] != newIDom) {
+          doms[node->GetID()] = newIDom;
+          changed = true;
+        }
+      }
+    } while (changed);
+  }
+
+  BaseGraphNode *Intersect(BaseGraphNode &node1, const BaseGraphNode &node2) const {
+    auto *ptrNode1 = &node1;
+    auto *ptrNode2 = &node2;
+    while (ptrNode1 != ptrNode2) {
+      while (postOrderIDVec[ptrNode1->GetID()] < postOrderIDVec[ptrNode2->GetID()]) {
+        ptrNode1 = doms.at(ptrNode1->GetID());
+      }
+      while (postOrderIDVec[ptrNode2->GetID()] < postOrderIDVec[ptrNode1->GetID()]) {
+        ptrNode2 = doms.at(ptrNode2->GetID());
+      }
+    }
+    return ptrNode1;
+  }
+
+  bool InitNodeIsPred(const BaseGraphNode &node) const {
+    std::vector<BaseGraphNode*> succNodes;
+    GetNextNodesToVisit(commonEntryNode, succNodes);
+    for (const auto &suc : succNodes) {
+      if (suc == &node) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  void PostOrderWalk(const BaseGraphNode &node, int32 &pid, std::vector<bool> &visitedMap) {
+    auto nodeId = node.GetID();
+    ASSERT(nodeId < visitedMap.size(), "index out of range");
+    if (nodeVec[nodeId] == nullptr || visitedMap[nodeId]) {
+      return;
+    }
+    visitedMap[nodeId] = true;
+    std::vector<BaseGraphNode*> succNodes;
+    GetNextNodesToVisit(node, succNodes);
+    for (const auto &suc : succNodes) {
+      PostOrderWalk(*suc, pid, visitedMap);
+    }
+    ASSERT(nodeId < postOrderIDVec.size(), "index out of range");
+    postOrderIDVec[nodeId] = pid++;
+  }
+
+  void ComputeDtPreorder(const BaseGraphNode &node, size_t &num) {
+    CHECK_FATAL(num < dtPreOrder.size(), "index out of range");
+    dtPreOrder[num++] = node.GetID();
+    for (auto &k : domChildren[node.GetID()]) {
+      ComputeDtPreorder(*nodeVec[k], num);
+    }
+  }
+
+  void GetNextNodesToVisit(const BaseGraphNode &node, std::vector<BaseGraphNode*> &nodesToVisit) const {
+    if (isPdom) {
+      node.GetInNodes(nodesToVisit);
+    } else {
+      node.GetOutNodes(nodesToVisit);
+    }
+  }
+
+  void GetPrevNodesToVisit(const BaseGraphNode &node, std::vector<BaseGraphNode*> &nodesToVisit) const {
+    if (isPdom) {
+      node.GetOutNodes(nodesToVisit);
+    } else {
+      node.GetInNodes(nodesToVisit);
+    }
+  }
+
+  // nodeIdMarker indicates that the iterDomFrontier results for nodeId < nodeIdMarker have been computed
+  void GetIterDomFrontier(const BaseGraphNode &node, MapleSet<NodeId> &dfSet, const NodeId &nodeIdMarker,
+                          std::vector<bool> &visitedMap) {
+    if (visitedMap[node.GetID()]) {
+      return;
+    }
+    visitedMap[node.GetID()] = true;
+    for (auto frontierNodeId : domFrontier[node.GetID()]) {
+      (void)dfSet.insert(frontierNodeId);
+      if (frontierNodeId < nodeIdMarker) {  // union with its computed result
+        (void)dfSet.insert(iterDomFrontier[frontierNodeId].cbegin(), iterDomFrontier[frontierNodeId].cend());
+      } else {  // recursive call
+        auto frontierNode = nodeVec[frontierNodeId];
+        if (frontierNode == nullptr) {
+          continue;
+        }
+        GetIterDomFrontier(*frontierNode, dfSet, nodeIdMarker, visitedMap);
+      }
+    }
+  }
+
+  MapleAllocator domAllocator;  // stores the analysis results
+  MapleVector<BaseGraphNode*> &nodeVec;
+  BaseGraphNode &commonEntryNode;
+  BaseGraphNode &commonExitNode;
+  bool isPdom;
+  MapleVector<int32> postOrderIDVec;  // index is node id
+  MapleVector<BaseGraphNode*> reversePostOrder;  // an ordering of the node in reverse postorder
+  MapleVector<uint32> reversePostOrderId;  // gives position of each node in reversePostOrder
+  MapleUnorderedMap<NodeId, BaseGraphNode*> doms;  // index is node id; immediate dominator for each node
+  MapleVector<MapleSet<NodeId>> domFrontier;   // index is node id
+  MapleVector<MapleVector<NodeId>> domChildren;   // index is node id; for dom tree
+  MapleVector<MapleSet<NodeId>> iterDomFrontier;   // index is node id
+  MapleVector<NodeId> dtPreOrder;              // ordering of the nodes in a preorder traversal of the dominator tree
+  MapleVector<uint32> dtDfn;                 // gives position of each node in dt_preorder
+};
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_DOMINANCE_H
diff --git a/src/mapleall/maple_util/include/error_code.h b/src/mapleall/maple_util/include/error_code.h
new file mode 100644
index 0000000000000000000000000000000000000000..64f9b0f1440614ad334be99f5bd82c0c1bd7798a
--- /dev/null
+++ b/src/mapleall/maple_util/include/error_code.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_ERROR_CODE_H
+#define MAPLE_UTIL_INCLUDE_ERROR_CODE_H
+
+namespace maple {
+enum ErrorCode {
+  kErrorNoError,
+  kErrorExit,
+  kErrorExitHelp,
+  kErrorInvalidParameter,
+  kErrorInitFail,
+  kErrorFileNotFound,
+  kErrorToolNotFound,
+  kErrorCompileFail,
+  kErrorNotImplement
+};
+
+void PrintErrorMessage(int ret);
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_ERROR_CODE_H
diff --git a/src/mapleall/maple_util/include/factory.h b/src/mapleall/maple_util/include/factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e7e74b3b577eb5c940dac59a6f92151429309fb
--- /dev/null
+++ b/src/mapleall/maple_util/include/factory.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_FACTORY_H
+#define MAPLE_UTIL_INCLUDE_FACTORY_H
+#include <map>
+#include <memory>
+#include <functional>
+#include <mutex>
+#include "thread_env.h"
+
+namespace maple {
+template <typename TKey, typename TObject, typename... TArgs>
+class ObjectFactory final {
+ public:
+  using KeyType = TKey;
+  using CreatorType = std::function<std::unique_ptr<TObject>(TArgs...)>;
+
+  void Register(const KeyType &key, CreatorType func) {
+    if (creator.find(key) == creator.end()) {
+      creator[key] = func;
+    }
+  }
+
+  std::unique_ptr<TObject> Create(const KeyType &key, TArgs ...args) const {
+    auto it = creator.find(key);
+    return it == creator.end() ? std::unique_ptr<TObject>() : (it->second)(std::forward<TArgs>(args)...);
+  }
+
+  template <typename TObjectImpl>
+  static std::unique_ptr<TObject> DefaultCreator(TArgs ...args) {
+    return std::make_unique<TObjectImpl>(std::forward<TArgs>(args)...);
+  }
+
+  static ObjectFactory &Ins() {
+    static ObjectFactory factory;
+    return factory;
+  }
+
+  ObjectFactory(const ObjectFactory&) = delete;
+  ObjectFactory &operator=(const ObjectFactory&) = delete;
+  ObjectFactory(const ObjectFactory&&) = delete;
+  ObjectFactory &operator=(const ObjectFactory&&) = delete;
+
+ private:
+  ObjectFactory() = default;
+  ~ObjectFactory() = default;
+
+ private:
+  using CreatorHolder = std::map<KeyType, CreatorType>;
+  CreatorHolder creator;
+};
+
+template <typename TFactory, typename TFactory::KeyType Key, typename TObjectImpl>
+inline void RegisterFactoryObject() {
+  TFactory::Ins().Register(Key, TFactory::template DefaultCreator<TObjectImpl>);
+}
+
+template <typename TFactory, typename... TArgs>
+inline auto CreateProductObject(const typename TFactory::KeyType &key, TArgs &&...args) {
+  return TFactory::Ins().Create(key, std::forward<TArgs>(args)...);
+}
+
+template <typename TKey, typename TRet, typename... TArgs>
+class FunctionFactory final {
+ public:
+  using KeyType = TKey;
+  using CreatorType = std::function<TRet(TArgs...)>;
+
+  void Register(const KeyType &key, CreatorType func) {
+    static std::mutex mtx;
+    ParallelGuard guard(mtx, ThreadEnv::IsMeParallel());
+    if (creator.find(key) == creator.end()) {
+      creator[key] = func;
+    }
+  }
+
+  CreatorType Create(const KeyType &key) const {
+    static std::mutex mtx;
+    ParallelGuard guard(mtx, ThreadEnv::IsMeParallel());
+    auto it = creator.find(key);
+    return it == creator.end() ? nullptr : it->second;
+  }
+
+  static FunctionFactory &Ins() {
+    static FunctionFactory factory;
+    return factory;
+  }
+
+  FunctionFactory(const FunctionFactory&) = delete;
+  FunctionFactory &operator=(const FunctionFactory&) = delete;
+  FunctionFactory(const FunctionFactory&&) = delete;
+  FunctionFactory &operator=(const FunctionFactory&&) = delete;
+
+ private:
+  FunctionFactory() = default;
+  ~FunctionFactory() = default;
+
+ private:
+  using CreatorHolder = std::map<KeyType, CreatorType>;
+  CreatorHolder creator;
+};
+
+template <typename TFactory>
+inline void RegisterFactoryFunction(const typename TFactory::KeyType &key, typename TFactory::CreatorType func) {
+  TFactory::Ins().Register(key, func);
+}
+
+template <typename TFactory>
+inline auto CreateProductFunction(const typename TFactory::KeyType &key) {
+  return TFactory::Ins().Create(key);
+}
+}  // namespace maple
+
+#endif  // MAPLE_UTIL_INCLUDE_FACTORY_H
diff --git a/src/mapleall/maple_util/include/file_layout.h b/src/mapleall/maple_util/include/file_layout.h
new file mode 100644
index 0000000000000000000000000000000000000000..6acfff746ffa6a8213b1b47a9c84b4869d57aacc
--- /dev/null
+++ b/src/mapleall/maple_util/include/file_layout.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MIRLAYOUT_H
+#define MIRLAYOUT_H
+#include <iostream>
+
+namespace maple {
+// file-layout is shared between maple compiler and runtime, thus not in namespace maplert
+enum LayoutType : uint8_t {
+  kLayoutBootHot,
+  kLayoutBothHot,
+  kLayoutRunHot,
+  kLayoutStartupOnly,
+  kLayoutUsedOnce,
+  kLayoutExecuted, // method excuted in some condition
+  kLayoutUnused,
+  kLayoutTypeCount
+};
+
+// this used for c string layout
+static constexpr uint8_t kCStringShift = 1;
+std::string GetLayoutTypeString(uint32_t type);
+} // namespace maple
+#endif
diff --git a/src/mapleall/maple_util/include/file_utils.h b/src/mapleall/maple_util/include/file_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..141fca9d9a9d3bbc186fe99bbe949e90dd8185b3
--- /dev/null
+++ b/src/mapleall/maple_util/include/file_utils.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_DRIVER_INCLUDE_FILE_UTILS_H
+#define MAPLE_DRIVER_INCLUDE_FILE_UTILS_H
+#include <string>
+
+namespace maple {
+extern const std::string kFileSeperatorStr;
+extern const char kFileSeperatorChar;
+// Use char[] since getenv receives char* as parameter
+constexpr char kMapleRoot[] = "MAPLE_ROOT";
+
+class FileUtils {
+ public:
+  static std::string SafeGetenv(const char *envVar);
+  static std::string GetRealPath(const std::string &filePath);
+  static std::string GetFileName(const std::string &filePath, bool isWithExtension);
+  static std::string GetFileExtension(const std::string &filePath);
+  static std::string GetFileFolder(const std::string &filePath);
+  static std::string GetExecutable();
+  static int Remove(const std::string &filePath);
+  static bool IsFileExists(const std::string &filePath);
+  static std::string AppendMapleRootIfNeeded(bool needRootPath, const std::string &path,
+                                             const std::string &defaultRoot = "." + kFileSeperatorStr);
+};
+}  // namespace maple
+#endif  // MAPLE_DRIVER_INCLUDE_FILE_UTILS_H
diff --git a/src/mapleall/maple_util/include/itab_util.h b/src/mapleall/maple_util/include/itab_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..d4c44eaa36f5cdc02bfa48c9afbae82c9b659db8
--- /dev/null
+++ b/src/mapleall/maple_util/include/itab_util.h
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_ITAB_HOT_METHOD_H
+#define MRT_ITAB_HOT_METHOD_H
+
+namespace maple {
+constexpr int kHashSize = 23;
+constexpr int kHeadSizeOfSecondHash = 3;
+constexpr int kFlagAgInHeadOfSecondHash = 1;
+constexpr unsigned int kItabSecondHashSize = 0x1fff;
+constexpr int kFlagFirstHashConflict = 0;
+constexpr int kFlagSecondHashConflict = 1;
+#define ITAB_HOTMETHOD_SIZE (sizeof(itabHotMethod) / sizeof(itabHotMethod[0]))
+
+constexpr int kItabFirstHashSize = kHashSize;
+
+unsigned int DJBHash(const char *str);
+unsigned int GetHashIndex(const char *name);
+unsigned int GetSecondHashIndex(const char *name);
+
+static const char *itabHotMethod[] = {
+    "hasNext_7C_28_29Z",
+    "next_7C_28_29Ljava_2Flang_2FObject_3B",
+    "asBinder_7C_28_29Landroid_2Fos_2FIBinder_3B",
+    "gettid_7C_28_29I",
+    "get_7C_28I_29Ljava_2Flang_2FObject_3B",
+    "size_7C_28_29I",
+    "next_7C_28_29I",
+    "get_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "length_7C_28_29I",
+    "isUidPrivileged_7C_28I_29Z",
+    "sendBehavior_7C_28Lhuawei_2Fandroid_2Fsecurity_2FIHwBehaviorCollectManager_24BehaviorId_3BALjava_2Flang_2FObject_3B_29V",
+    "sendBehavior_7C_28Lhuawei_2Fandroid_2Fsecurity_2FIHwBehaviorCollectManager_24BehaviorId_3B_29V",
+    "iterator_7C_28_29Ljava_2Futil_2FIterator_3B",
+    "attribute_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "getAttributeValue_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B",
+    "index_7C_28_29I",
+    "toString_7C_28_29Ljava_2Flang_2FString_3B",
+    "print_7C_28Ljava_2Flang_2FObject_3BLjava_2Futil_2FLocale_3B_29V",
+    "append_7C_28Ljava_2Flang_2FCharSequence_3B_29Ljava_2Flang_2FAppendable_3B",
+    "add_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "containsKey_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "onReadFromDisk_7C_28_29V",
+    "apply_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "getDepth_7C_28_29I",
+    "accept_7C_28Ljava_2Flang_2FObject_3B_29V",
+    "getName_7C_28_29Ljava_2Flang_2FString_3B",
+    "writeToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V",
+    "getuid_7C_28_29I",
+    "charAt_7C_28I_29C",
+    "read_7C_28Ljava_2Fio_2FFileDescriptor_3BABII_29I",
+    "test_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "contains_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "isEmpty_7C_28_29Z",
+    "createFromParcel_7C_28Landroid_2Fos_2FParcel_3B_29Ljava_2Flang_2FObject_3B",
+    "toJavaFormatString_7C_28_29Ljava_2Flang_2FString_3B",
+    "endTag_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "getHwHandler_7C_28_29Landroid_2Fos_2FIHwHandler_3B",
+    "startTag_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "resetMessageDelayMillis_7C_28Landroid_2Fos_2FMessage_3BJ_29J",
+    "close_7C_28Ljava_2Fio_2FFileDescriptor_3B_29V",
+    "iterator_7C_28_29Ljava_2Futil_2FIterator_3B",
+    "transact_7C_28ILandroid_2Fos_2FParcel_3BLandroid_2Fos_2FParcel_3BI_29Z",
+    "getValue_7C_28_29Ljava_2Flang_2FObject_3B",
+    "checkPermission_7C_28Ljava_2Flang_2FString_3BII_29I",
+    "getKey_7C_28_29Ljava_2Flang_2FObject_3B",
+    "compare_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29I",
+    "getAttrs_7C_28_29Landroid_2Fview_2FWindowManager_24LayoutParams_3B",
+    "run_7C_28_29V",
+    "getpid_7C_28_29I",
+    "isEmpty_7C_28_29Z",
+    "checkUidPermission_7C_28Ljava_2Flang_2FString_3BI_29I",
+    "close_7C_28Ljava_2Flang_2FThrowable_3B_29V",
+    "queryLocalInterface_7C_28Ljava_2Flang_2FString_3B_29Landroid_2Fos_2FIInterface_3B",
+    "getService_7C_28Landroid_2Fapp_2FContextImpl_3B_29Ljava_2Flang_2FObject_3B",
+    "getInt_7C_28I_29I",
+    "stat_7C_28Ljava_2Flang_2FString_3B_29Landroid_2Fsystem_2FStructStat_3B",
+    "getHwConfiguration_7C_28_29Landroid_2Fcontent_2Fres_2FIHwConfiguration_3B",
+    "process_7C_28Lcom_2Fandroid_2Fserver_2Fjob_2Fcontrollers_2FJobStatus_3B_29V",
+    "put_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "getWinFreezeScreenMonitor_7C_28_29Lcom_2Fandroid_2Fserver_2Fos_2FIFreezeScreenWindowMonitor_3B",
+    "setTo_7C_28Landroid_2Fcontent_2Fres_2FIHwConfiguration_3B_29V",
+    "getWindowLayerFromTypeLw_7C_28IZ_29I",
+    "getString_7C_28I_29Ljava_2Flang_2FString_3B",
+    "isVisibleLw_7C_28_29Z",
+    "toArray_7C_28_29ALjava_2Flang_2FObject_3B",
+    "getPolicyMask_7C_28_29I",
+    "close_7C_28_29V",
+    "compareTo_7C_28Landroid_2Fcontent_2Fres_2FIHwConfiguration_3B_29I",
+    "setToDefaults_7C_28_29V",
+    "getEventType_7C_28_29I",
+    "contains_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "remove_7C_28I_29Ljava_2Flang_2FObject_3B",
+    "checkIntent_7C_28ILjava_2Flang_2FString_3BIILjava_2Flang_2FString_3BI_29Z",
+    "getStackId_7C_28_29I",
+    "hashCode_7C_28_29I",
+    "applyPostLayoutPolicyLw_7C_28Landroid_2Fview_2FWindowManagerPolicy_24WindowState_3BLandroid_2Fview_2FWindowManager_24LayoutParams_3BLandroid_2Fview_2FWindowManagerPolicy_24WindowState_3BLandroid_2Fview_2FWindowManagerPolicy_24WindowState_3B_29V",
+    "getHwFlogManager_7C_28_29Landroid_2Fcommon_2FHwFlogManager_3B",
+    "canAffectSystemUiFlags_7C_28_29Z",
+    "isKeyguardLocked_7C_28_29Z",
+    "slog_7C_28IILjava_2Flang_2FString_3B_29I",
+    "values_7C_28_29Ljava_2Futil_2FCollection_3B",
+    "checkFreezeScreen_7C_28Landroid_2Futil_2FArrayMap_3B_29V",
+    "moveToNext_7C_28_29Z",
+    "getResolution_7C_28Ljava_2Flang_2FString_3B_29F",
+    "resolveContentProvider_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FProviderInfo_3B",
+    "uptimeMillis_7C_28_29J",
+    "getApplicationInfo_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FApplicationInfo_3B",
+    "canAddInternalSystemWindow_7C_28_29Z",
+    "append_7C_28Ljava_2Flang_2FCharSequence_3B_29Ljava_2Flang_2FAppendable_3B",
+    "getBaseType_7C_28_29I",
+    "onWriteToDisk_7C_28_29V",
+    "isCustedCouldStopped_7C_28Ljava_2Flang_2FString_3BZZ_29Z",
+    "size_7C_28_29I",
+    "write_7C_28Ljava_2Fio_2FFileDescriptor_3BABII_29I",
+    "getIntentForIntentSender_7C_28Landroid_2Fcontent_2FIIntentSender_3B_29Landroid_2Fcontent_2FIntent_3B",
+    "getApsManager_7C_28_29Landroid_2Faps_2FIApsManager_3B",
+    "getConfigItem_7C_28I_29I",
+    "getAppToken_7C_28_29Landroid_2Fview_2FIApplicationToken_3B",
+    "linkToDeath_7C_28Landroid_2Fos_2FIBinder_24DeathRecipient_3BI_29V",
+    "packageHasActiveAdmins_7C_28Ljava_2Flang_2FString_3BI_29Z",
+    "getPackagesForUid_7C_28I_29ALjava_2Flang_2FString_3B",
+    "elapsedRealtime_7C_28_29J",
+    "isBoundWidgetPackage_7C_28Ljava_2Flang_2FString_3BI_29Z",
+    "getIntentForIntentSender_7C_28Landroid_2Fcontent_2FIIntentSender_3B_29Landroid_2Fcontent_2FIntent_3B",
+    "getPackageUid_7C_28Ljava_2Flang_2FString_3BII_29I",
+    "getWinFreezeScreenMonitor_7C_28_29Lcom_2Fandroid_2Fserver_2Fos_2FIFreezeScreenWindowMonitor_3B",
+    "stat_7C_28Ljava_2Flang_2FString_3B_29Landroid_2Fsystem_2FStructStat_3B",
+    "isKeyguardLocked_7C_28_29Z",
+    "applyPostLayoutPolicyLw_7C_28Landroid_2Fview_2FWindowManagerPolicy_24WindowState_3BLandroid_2Fview_2FWindowManager_24LayoutParams_3BLandroid_2Fview_2FWindowManagerPolicy_24WindowState_3BLandroid_2Fview_2FWindowManagerPolicy_24WindowState_3B_29V",
+    "getPackagesForUid_7C_28I_29ALjava_2Flang_2FString_3B",
+    "compare_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29I",
+    "next_7C_28_29Ljava_2Flang_2FObject_3B",
+    "getApplicationInfo_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FApplicationInfo_3B",
+    "registerReceiver_7C_28Landroid_2Fapp_2FIApplicationThread_3BLjava_2Flang_2FString_3BLandroid_2Fcontent_2FIIntentReceiver_3BLandroid_2Fcontent_2FIntentFilter_3BLjava_2Flang_2FString_3BII_29Landroid_2Fcontent_2FIntent_3B",
+    "iterator_7C_28_29Ljava_2Futil_2FIterator_3B",
+    "getHwFlogManager_7C_28_29Landroid_2Fcommon_2FHwFlogManager_3B",
+    "getString_7C_28I_29Ljava_2Flang_2FString_3B",
+    "getppid_7C_28_29I",
+    "getNameForUid_7C_28I_29Ljava_2Flang_2FString_3B",
+    "isProtectedBroadcast_7C_28Ljava_2Flang_2FString_3B_29Z",
+    "getEventType_7C_28_29I",
+    "packageHasActiveAdmins_7C_28Ljava_2Flang_2FString_3BI_29Z",
+    "getApplicationEnabledSetting_7C_28Ljava_2Flang_2FString_3BI_29I",
+    "handleIncomingUser_7C_28IIIZZLjava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29I",
+    "write_7C_28Ljava_2Fio_2FFileDescriptor_3BABII_29I",
+    "getApsManager_7C_28_29Landroid_2Faps_2FIApsManager_3B",
+    "getBaseType_7C_28_29I",
+    "size_7C_28_29I",
+    "getPackageInfo_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FPackageInfo_3B",
+    "remove_7C_28I_29Ljava_2Flang_2FObject_3B",
+    "resolveContentProvider_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FProviderInfo_3B",
+    "fstat_7C_28Ljava_2Fio_2FFileDescriptor_3B_29Landroid_2Fsystem_2FStructStat_3B",
+    "getName_7C_28_29Ljava_2Flang_2FString_3B",
+    "isEmpty_7C_28_29Z",
+    "queryIntentReceivers_7C_28Landroid_2Fcontent_2FIntent_3BLjava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FParceledListSlice_3B",
+    "print_7C_28Ljava_2Flang_2FObject_3BLjava_2Futil_2FLocale_3B_29V",
+    "getStackId_7C_28_29I",
+    "iterator_7C_28_29Ljava_2Futil_2FIterator_3B",
+    "get_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "checkUidSignatures_7C_28II_29I",
+    "add_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "containsKey_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "endTag_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "getResolution_7C_28Ljava_2Flang_2FString_3B_29F",
+    "getDepth_7C_28_29I",
+    "canAddInternalSystemWindow_7C_28_29Z",
+    "getResolution_7C_28Ljava_2Flang_2FString_3B_29F",
+    "values_7C_28_29Ljava_2Futil_2FCollection_3B",
+    "moveToNext_7C_28_29Z",
+    "getCurrentUser_7C_28_29Landroid_2Fcontent_2Fpm_2FUserInfo_3B",
+    "close_7C_28_29V",
+    "getInt_7C_28I_29I",
+    "charAt_7C_28I_29C",
+    "read_7C_28Ljava_2Fio_2FFileDescriptor_3BABII_29I",
+    "getRunningAppProcesses_7C_28_29Ljava_2Futil_2FList_3B",
+    "setPackageStoppedState_7C_28Ljava_2Flang_2FString_3BZI_29V",
+    "getNonDecorDisplayWidth_7C_28IIIII_29I",
+    "startTag_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "finishLayoutLw_7C_28_29V",
+    "contains_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "setFirewallUidRule_7C_28III_29V",
+    "getForceRotationManager_7C_28_29Lcom_2Fhuawei_2Fforcerotation_2FIForceRotationManager_3B",
+    "ioctlInt_7C_28Ljava_2Fio_2FFileDescriptor_3BILandroid_2Futil_2FMutableInt_3B_29I",
+    "close_7C_28Ljava_2Fio_2FFileDescriptor_3B_29V",
+    "isResourceNeeded_7C_28I_29Z",
+    "isAppStartModeDisabled_7C_28ILjava_2Flang_2FString_3B_29Z",
+    "getpid_7C_28_29I",
+    "beginPostLayoutPolicyLw_7C_28II_29V",
+    "getAttributeValue_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B",
+    "getUserInfo_7C_28I_29Landroid_2Fcontent_2Fpm_2FUserInfo_3B",
+    "getActiveScorerPackage_7C_28_29Ljava_2Flang_2FString_3B",
+    "isPowerSaveWhitelistExceptIdleApp_7C_28Ljava_2Flang_2FString_3B_29Z",
+    "open_7C_28Ljava_2Flang_2FString_3BII_29Ljava_2Fio_2FFileDescriptor_3B",
+    "index_7C_28_29I",
+    "toString_7C_28_29Ljava_2Flang_2FString_3B",
+    "isPackageAvailable_7C_28Ljava_2Flang_2FString_3BI_29Z",
+    "append_7C_28Ljava_2Flang_2FCharSequence_3B_29Ljava_2Flang_2FAppendable_3B",
+    "scheduleRegisteredReceiver_7C_28Landroid_2Fcontent_2FIIntentReceiver_3BLandroid_2Fcontent_2FIntent_3BILjava_2Flang_2FString_3BLandroid_2Fos_2FBundle_3BZZII_29V",
+    "getPackageForIntentSender_7C_28Landroid_2Fcontent_2FIIntentSender_3B_29Ljava_2Flang_2FString_3B",
+    "toArray_7C_28_29ALjava_2Flang_2FObject_3B",
+    "setToDefaults_7C_28_29V",
+    "isEmpty_7C_28_29Z",
+    "put_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "getStackBounds_7C_28ILandroid_2Fgraphics_2FRect_3B_29V",
+    "checkPackageStartable_7C_28Ljava_2Flang_2FString_3BI_29V",
+    "checkPackage_7C_28ILjava_2Flang_2FString_3B_29I",
+    "notifyPackageUse_7C_28Ljava_2Flang_2FString_3BI_29V",
+    "getAppToken_7C_28_29Landroid_2Fview_2FIApplicationToken_3B",
+    "isScreenOn_7C_28_29Z",
+    "computeFrameLw_7C_28Landroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3B_29V",
+    "getPolicy_7C_28Landroid_2Fcontent_2FComponentName_3BLjava_2Flang_2FString_3BI_29Landroid_2Fos_2FBundle_3B",
+    "getAttributeNameResource_7C_28I_29I",
+    "getuid_7C_28_29I",
+    "getConfigDisplayHeight_7C_28IIIII_29I",
+    "set_7C_28ILjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "finishPostLayoutPolicyLw_7C_28_29I",
+    "isNetworkMetered_7C_28Landroid_2Fnet_2FNetworkState_3B_29Z",
+    "getResources_7C_28Ljava_2Flang_2FClassLoader_3B_29Landroid_2Fcontent_2Fres_2FResources_3B",
+    "refContentProvider_7C_28Landroid_2Fos_2FIBinder_3BII_29Z",
+    "queryIntentServices_7C_28Landroid_2Fcontent_2FIntent_3BLjava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FParceledListSlice_3B",
+    "bindService_7C_28Landroid_2Fapp_2FIApplicationThread_3BLandroid_2Fos_2FIBinder_3BLandroid_2Fcontent_2FIntent_3BLjava_2Flang_2FString_3BLandroid_2Fapp_2FIServiceConnection_3BILjava_2Flang_2FString_3BI_29I",
+    "appendChild_7C_28Lorg_2Fw3c_2Fdom_2FNode_3B_29Lorg_2Fw3c_2Fdom_2FNode_3B",
+    "getHwNsdImpl_7C_28_29Landroid_2Fview_2FIHwNsdImpl_3B",
+    "getenv_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"
+};
+}  // namespace maple
+#endif
diff --git a/src/mapleall/maple_util/include/literalstrname.h b/src/mapleall/maple_util/include/literalstrname.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbb5e7a3b6706bb013229e097fb1bb252a9e01c2
--- /dev/null
+++ b/src/mapleall/maple_util/include/literalstrname.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_INCLUDE_LITERALSTRNAME_H
+#define MRT_INCLUDE_LITERALSTRNAME_H
+#include <map>
+#include "muid.h"
+
+// literal string naming is shared between maple compiler and runtime, thus not in namespace maplert
+const std::string kConstString = "_C_STR_";
+const std::string kConstStringPtr = "_PTR_C_STR_";
+const std::string kLocalStringPrefix = "L_STR_";
+constexpr int kConstStringLen = 7;
+
+class LiteralStrName {
+ public:
+  static int32_t CalculateHashSwapByte(const char16_t *data, uint32_t len);
+  static uint32_t CalculateHash(const char16_t *data, uint32_t len, bool dataIsCompress) {
+    uint32_t hash = 0;
+    if (dataIsCompress) {
+      const char *dataStart = reinterpret_cast<const char*>(data);
+      const char *end = dataStart + len;
+      while (dataStart < end) {
+        hash = (hash << 5) - hash + static_cast<uint32_t>(*dataStart++); // calculate the hash code of data
+      }
+    } else {
+      const char16_t *end = data + len;
+      while (data < end) {
+        hash = (static_cast<unsigned int>(hash) << 5) - hash + *data++; // calculate the hash code of data
+      }
+    }
+    return hash;
+  }
+
+  static std::string GetHexStr(const uint8_t *bytes, uint32_t len);
+  static std::string GetLiteralStrName(const uint8_t *bytes, uint32_t len);
+  static std::string ComputeMuid(const uint8_t *bytes, uint32_t len);
+};
+
+#endif
diff --git a/src/mapleall/maple_util/include/mpl_int_val.h b/src/mapleall/maple_util/include/mpl_int_val.h
new file mode 100644
index 0000000000000000000000000000000000000000..dec9ecb2d16adb9061262d5c5806fe82abbf2d2e
--- /dev/null
+++ b/src/mapleall/maple_util/include/mpl_int_val.h
@@ -0,0 +1,555 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_MPL_INT_VAL_H
+#define MAPLE_UTIL_INCLUDE_MPL_INT_VAL_H
+
+#include "mir_type.h"
+
+namespace maple {
+
+/// @brief this class provides different operations on signed and unsigned integers with arbitrary bit-width
+class IntVal {
+ public:
+  /// @brief create zero value with zero bit-width
+  IntVal() : value(0), width(0), sign(false) {}
+
+  IntVal(uint64 val, uint8 bitWidth, bool isSigned) : value(val), width(bitWidth), sign(isSigned) {
+    ASSERT(width <= valBitSize && width != 0, "bit-width is too wide");
+    TruncInPlace();
+  }
+
+  IntVal(uint64 val, PrimType type) : IntVal(val, GetPrimTypeActualBitSize(type), IsSignedInteger(type)) {
+    ASSERT(IsPrimitiveInteger(type), "Type must be integral");
+  }
+
+  IntVal(const IntVal &val, PrimType type) : IntVal(val.value, type) {}
+
+  IntVal(const IntVal &val, uint8 bitWidth, bool isSigned) : IntVal(val.value, bitWidth, isSigned) {}
+
+  IntVal(const IntVal &val, bool isSigned) : IntVal(val.value, val.width, isSigned) {}
+
+  IntVal &operator=(const IntVal &other) {
+    if (width == 0) {
+      // Allow 'this' to be assigned with new bit-width and sign iff
+      // its original bit-width is zero (i.e. the value was created by the default ctor)
+      Assign(other);
+    } else {
+      // Otherwise, assign only new value, but sign and width must be the same
+      ASSERT(width == other.width && sign == other.sign, "different bit-width or sign");
+      value = other.value;
+    }
+
+    return *this;
+  }
+
+  IntVal &operator=(uint64 other) {
+    ASSERT(width != 0, "can't be assigned to value with unknown size");
+    value = other;
+    TruncInPlace();
+
+    return *this;
+  }
+
+  void Assign(const IntVal &other) {
+    value = other.value;
+    width = other.width;
+    sign = other.sign;
+  }
+
+  /// @return bit-width of the value
+  uint8 GetBitWidth() const {
+    return width;
+  }
+
+  /// @return true if the value is signed
+  bool IsSigned() const {
+    return sign;
+  }
+
+  /// @return sign or zero extended value depending on its signedness
+  int64 GetExtValue(uint8 size = 0) const {
+    return sign ? GetSXTValue(size) : GetZXTValue(size);
+  }
+
+  /// @return zero extended value
+  uint64 GetZXTValue(uint8 size = 0) const {
+    // if size == 0, just return the value itself because it's already truncated for an appropriate width
+    return size ? (value << (valBitSize - size)) >> (valBitSize - size) : value;
+  }
+
+  /// @return sign extended value
+  int64 GetSXTValue(uint8 size = 0) const {
+    uint8 bitWidth = size ? size : width;
+    return static_cast<int64>(value << (valBitSize - bitWidth)) >> (valBitSize - bitWidth);
+  }
+
+  /// @return true if the (most significant bit) MSB is set
+  bool GetSignBit() const {
+    return GetBit(width - 1);
+  }
+
+  /// @return true if all bits are 1
+  bool AreAllBitsOne() const {
+    return value == (allOnes >> (valBitSize - width));
+  }
+
+  /// @return true if value is a power of 2 > 0
+  bool IsPowerOf2() {
+    return value && !(value & (value - 1));
+  }
+
+  /// @return true if the value is maximum considering its signedness
+  bool IsMaxValue() const {
+    return sign ? value == ((uint64(1) << (width - 1)) - 1) : AreAllBitsOne();
+  }
+
+  /// @return true if the value is minimum considering its signedness
+  bool IsMinValue() const {
+    return sign ? value == (uint64(1) << (width - 1)) : value == 0;
+  }
+
+  void SetMaxValue() {
+    value = sign ? ((uint64(1) << (width - 1)) - 1) : (allOnes >> (valBitSize - width));
+  }
+
+  void SetMaxValue(bool isSigned, uint8 bitWidth) {
+    sign = isSigned;
+    width = bitWidth;
+    value = sign ? ((uint64(1) << (width - 1)) - 1) : (allOnes >> (valBitSize - width));
+  }
+
+  void SetMinValue() {
+    value = sign ? (uint64(1) << (width - 1)) : 0;
+  }
+
+  void SetMinValue(bool isSigned, uint8 bitWidth) {
+    sign = isSigned;
+    width = bitWidth;
+    value = sign ? (uint64(1) << (width - 1)) : 0;
+  }
+
+  //
+  // Comparison operators that manipulate on values with the same sign and bit-width
+  //
+  bool operator==(const IntVal &rhs) const {
+    ASSERT(width == rhs.width && sign == rhs.sign, "bit-width and sign must be the same");
+    return value == rhs.value;
+  }
+
+  bool operator!=(const IntVal &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator<(const IntVal &rhs) const {
+    ASSERT(width == rhs.width && sign == rhs.sign, "bit-width and sign must be the same");
+    return sign ? GetSXTValue() < rhs.GetSXTValue() : value < rhs.value;
+  }
+
+  bool operator>(const IntVal &rhs) const {
+    ASSERT(width == rhs.width && sign == rhs.sign, "bit-width and sign must be the same");
+    return sign ? GetSXTValue() > rhs.GetSXTValue() : value > rhs.value;
+  }
+
+  bool operator<=(const IntVal &rhs) const {
+    return !(*this > rhs);
+  }
+
+  bool operator>=(const IntVal &rhs) const {
+    return !(*this < rhs);
+  }
+
+  //
+  // Arithmetic and bitwise operators that manipulate on values with the same sign and bit-width
+  //
+  IntVal operator+(const IntVal &val) const {
+    ASSERT(width == val.width && sign == val.sign, "bit-width and sign must be the same");
+    return IntVal(value + val.value, width, sign);
+  }
+
+  IntVal operator-(const IntVal &val) const {
+    ASSERT(width == val.width && sign == val.sign, "bit-width and sign must be the same");
+    return IntVal(value - val.value, width, sign);
+  }
+
+  IntVal &operator++() {
+    ++value;
+    TruncInPlace();
+    return *this;
+  }
+
+  IntVal operator++(int) {
+    IntVal tmp(*this);
+    ++*this;
+    return tmp;
+  }
+
+  IntVal &operator--() {
+    --value;
+    TruncInPlace();
+    return *this;
+  }
+
+  IntVal operator--(int) {
+    IntVal tmp(*this);
+    --*this;
+    return tmp;
+  }
+
+  IntVal operator*(const IntVal &val) const {
+    ASSERT(width == val.width && sign == val.sign, "bit-width and sign must be the same");
+    return IntVal(value * val.value, width, sign);
+  }
+
+  IntVal operator/(const IntVal &divisor) const;
+
+  IntVal operator%(const IntVal &divisor) const;
+
+  IntVal operator&(const IntVal &val) const {
+    ASSERT(width == val.width && sign == val.sign, "bit-width and sign must be the same");
+    return IntVal(value & val.value, width, sign);
+  }
+
+  IntVal operator|(const IntVal &val) const {
+    ASSERT(width == val.width && sign == val.sign, "bit-width and sign must be the same");
+    return IntVal(value | val.value, width, sign);
+  }
+
+  IntVal operator^(const IntVal &val) const {
+    ASSERT(width == val.width && sign == val.sign, "bit-width and sign must be the same");
+    return IntVal(value ^ val.value, width, sign);
+  }
+
+  /// @brief shift-left operator
+  IntVal operator<<(uint64 bits) const {
+    ASSERT(bits <= width, "invalid shift value");
+    return IntVal(value << bits, width, sign);
+  }
+
+  IntVal operator<<(const IntVal &bits) const {
+    return *this << bits.value;
+  }
+
+  /// @brief shift-right operator
+  /// @note if value is signed this operator works as arithmetic shift-right operator,
+  ///       otherwise it's logical shift-right operator
+  IntVal operator>>(uint64 bits) const {
+    ASSERT(bits <= width, "invalid shift value");
+    return IntVal(sign ? GetSXTValue() >> bits : value >> bits, width, sign);
+  }
+
+  IntVal operator>>(const IntVal &bits) const {
+    return *this >> bits.value;
+  }
+
+  //
+  // Comparison operators that compare values obtained from primitive type.
+  //
+  /// @note Note that these functions work as follows:
+  ///          1) sign or zero extend both values (*this and/or rhs) to the new bit-width
+  ///             obtained from pType depending on their original signedness;
+  ///             or truncate the values if their original bit-width is greater than new one
+  ///          2) then perform the operation itself on new given values that have the same bit-width and sign
+  ///
+  /// @warning it's better to avoid using these function in favor of operator==, operator< etc
+  ///
+  bool Equal(const IntVal &rhs, PrimType pType) const {
+    return TruncOrExtend(pType) == rhs.TruncOrExtend(pType);
+  }
+
+  bool Less(const IntVal &rhs, PrimType pType) const {
+    return TruncOrExtend(pType) < rhs.TruncOrExtend(pType);
+  }
+
+  bool Greater(const IntVal &rhs, PrimType pType) const {
+    return TruncOrExtend(pType) > rhs.TruncOrExtend(pType);
+  }
+
+  //
+  // Arithmetic and bitwise operators that allow creating a new value
+  // with the bit-width and sign obtained from primitive type
+  //
+  /// @note Note that these functions work as follows:
+  ///          1) sign or zero extend both values (*this and rhs) to the new bit-width
+  ///             obtained from pType depending on their original signedness;
+  ///             or truncate the values if their original bit-width is greater than new one
+  ///          2) then perform the operation itself on new given values that have the same bit-width and sign
+  ///
+  /// @warning it's better to avoid using these function in favor of operator+, operator- etc
+  ///
+  IntVal Add(const IntVal &val, PrimType pType) const {
+    return TruncOrExtend(pType) + val.TruncOrExtend(pType);
+  }
+
+  IntVal Sub(const IntVal &val, PrimType pType) const {
+    return TruncOrExtend(pType) - val.TruncOrExtend(pType);
+  }
+
+  IntVal Mul(const IntVal &val, PrimType pType) const {
+    return TruncOrExtend(pType) * val.TruncOrExtend(pType);
+  }
+
+  IntVal Div(const IntVal &divisor, PrimType pType) const {
+    return TruncOrExtend(pType) / divisor.TruncOrExtend(pType);
+  }
+
+  // sign division in terms of new bitWidth
+  IntVal SDiv(const IntVal &divisor, uint8 bitWidth) const {
+    return TruncOrExtend(bitWidth, true) / divisor.TruncOrExtend(bitWidth, true);
+  }
+
+  // unsigned division in terms of new bitWidth
+  IntVal UDiv(const IntVal &divisor, uint8 bitWidth) const {
+    return TruncOrExtend(bitWidth, false) / divisor.TruncOrExtend(bitWidth, false);
+  }
+
+  // unsigned division in terms of new bitWidth
+  IntVal Rem(const IntVal &divisor, PrimType pType) const {
+    return TruncOrExtend(pType) % divisor.TruncOrExtend(pType);
+  }
+
+  // signed modulo in terms of new bitWidth
+  IntVal SRem(const IntVal &divisor, uint8 bitWidth) const {
+    return TruncOrExtend(bitWidth, true) % divisor.TruncOrExtend(bitWidth, true);
+  }
+
+  // unsigned modulo in terms of new bitWidth
+  IntVal URem(const IntVal &divisor, uint8 bitWidth) const {
+    return TruncOrExtend(bitWidth, false) % divisor.TruncOrExtend(bitWidth, false);
+  }
+
+  IntVal And(const IntVal &val, PrimType pType) const {
+    return TruncOrExtend(pType) & val.TruncOrExtend(pType);
+  }
+
+  IntVal Or(const IntVal &val, PrimType pType) const {
+    return TruncOrExtend(pType) | val.TruncOrExtend(pType);
+  }
+
+  IntVal Xor(const IntVal &val, PrimType pType) const {
+    return TruncOrExtend(pType) ^ val.TruncOrExtend(pType);
+  }
+
+  // left-shift operators
+  IntVal Shl(const IntVal &shift, PrimType pType) const {
+    return Shl(shift.value, pType);
+  }
+
+  IntVal Shl(uint64 shift, PrimType pType) const {
+    return TruncOrExtend(pType) << shift;
+  }
+
+  // logical right-shift operators (MSB is zero extended)
+  IntVal LShr(const IntVal &shift, PrimType pType) const {
+    return LShr(shift.value, pType);
+  }
+
+  IntVal LShr(uint64 shift, PrimType pType) const {
+    IntVal ret = TruncOrExtend(pType);
+
+    ASSERT(shift <= ret.width, "invalid shift value");
+    ret.value >>= shift;
+
+    return ret;
+  }
+
+  IntVal LShr(uint64 shift) const {
+    ASSERT(shift <= width, "invalid shift value");
+    return IntVal(value >> shift, width, sign);
+  }
+
+  // arithmetic right-shift operators (MSB is sign extended)
+  IntVal AShr(const IntVal &shift, PrimType pType) const {
+    return AShr(shift.value, pType);
+  }
+
+  IntVal AShr(uint64 shift, PrimType pType) const {
+    IntVal ret = TruncOrExtend(pType);
+
+    ASSERT(shift <= ret.width, "invalid shift value");
+    ret.value = ret.GetSXTValue() >> shift;
+    ret.TruncInPlace();
+
+    return ret;
+  }
+
+  /// @brief invert all bits of value
+  IntVal operator~() const {
+    return IntVal(~value, width, sign);
+  }
+
+  /// @return negated value
+  IntVal operator-() const {
+    return IntVal(~value + 1, width, sign);
+  }
+
+  /// @brief truncate value to the given bit-width in-place.
+  /// @note if bitWidth is not passed (or zero), the original
+  ///       bit-width is preserved and the value is truncated to the original bit-width
+  void TruncInPlace(uint8 bitWidth = 0) {
+    ASSERT(valBitSize >= bitWidth, "invalid bit-width for truncate");
+
+    value &= allOnes >> (valBitSize - (bitWidth ? bitWidth : width));
+
+    if (bitWidth) {
+      width = bitWidth;
+    }
+  }
+
+  /// @return truncated value to the given bit-width
+  /// @note returned value will have bit-width and sign obtained from newType
+  IntVal Trunc(PrimType newType) const {
+    return Trunc(GetPrimTypeActualBitSize(newType), IsSignedInteger(newType));
+  }
+
+  IntVal Trunc(uint8 newWidth, bool isSigned) const {
+    return { value, newWidth, isSigned };
+  }
+
+  /// @return sign or zero extended value depending on its signedness
+  /// @note returned value will have bit-width and sign obtained from newType
+  IntVal Extend(PrimType newType) const {
+    return Extend(GetPrimTypeActualBitSize(newType), IsSignedInteger(newType));
+  }
+
+  /// @return sign/zero extended value or truncated value depending on bit-width
+  /// @note returned value will have bit-width and sign obtained from newType
+  IntVal TruncOrExtend(PrimType newType) const {
+    return TruncOrExtend(GetPrimTypeActualBitSize(newType), IsSignedInteger(newType));
+  }
+
+  IntVal TruncOrExtend(uint8 newWidth, bool isSigned) const {
+    return newWidth <= width ? Trunc(newWidth, isSigned) : Extend(newWidth, isSigned);
+  }
+
+ private:
+  bool GetBit(uint8 bit) const {
+    ASSERT(bit < width, "Required bit is out of value range");
+    return (value & (uint64(1) << bit)) != 0;
+  }
+
+  IntVal Extend(uint8 newWidth, bool isSigned) const {
+    ASSERT(newWidth > width, "invalid size for extension");
+    return IntVal(GetExtValue(), newWidth, isSigned);
+  }
+
+  static constexpr uint8 valBitSize = sizeof(uint64) * CHAR_BIT;
+  static constexpr uint64 allOnes = uint64(~0);
+
+  uint64 value;
+  uint8 width;
+  bool sign;
+};
+
+//
+// Additional comparison operators
+//
+inline bool operator==(const IntVal &v1, int64 v2) {
+  return v1.GetExtValue() == v2;
+}
+
+inline bool operator==(int64 v1, const IntVal &v2) {
+  return v2 == v1;
+}
+
+inline bool operator!=(const IntVal &v1, int64 v2) {
+  return !(v1 == v2);
+}
+
+inline bool operator!=(int64 v1, const IntVal &v2) {
+  return !(v2 == v1);
+}
+
+/// @return the smaller of two values
+/// @note bit-width and sign must be the same for both parameters
+inline IntVal Min(const IntVal &a, const IntVal &b) {
+  return a < b ? a : b;
+}
+
+/// @return the smaller of two values in terms of newType
+/// @note returned value will have bit-width and sign obtained from newType
+inline IntVal Min(const IntVal &a, const IntVal &b, PrimType newType) {
+  return a.Less(b, newType) ? IntVal(a, newType) : IntVal(b, newType);
+}
+
+/// @return the larger of two values
+/// @note bit-width and sign must be the same for both parameters
+inline IntVal Max(const IntVal &a, const IntVal &b) {
+  return Min(a, b) == a ? b : a;
+}
+
+/// @return the larger of two values in terms of newType
+/// @note returned value will have bit-width and sign obtained from newType
+inline IntVal Max(const IntVal &a, const IntVal &b, PrimType newType) {
+  return Min(a, b, newType) == a ? b : a;
+}
+
+/// @brief dump IntVal object to the output stream
+std::ostream &operator<<(std::ostream &os, const IntVal &value);
+
+//
+// Arithmetic operators that manipulate on scalar (uint64) value and IntVal object
+// in terms of sign and bit-width of IntVal object
+//
+inline IntVal operator+(const IntVal &v1, uint64 v2) {
+  return v1 + IntVal(v2, v1.GetBitWidth(), v1.IsSigned());
+}
+
+inline IntVal operator+(uint64 v1, const IntVal& v2) {
+  return v2 + v1;
+}
+
+inline IntVal operator-(const IntVal &v1, uint64 v2) {
+  return v1 - IntVal(v2, v1.GetBitWidth(), v1.IsSigned());
+}
+
+inline IntVal operator-(uint64 v1, const IntVal &v2) {
+  return IntVal(v1, v2.GetBitWidth(), v2.IsSigned()) - v2;
+}
+
+inline IntVal operator*(const IntVal &v1, uint64 v2) {
+  return v1 * IntVal(v2, v1.GetBitWidth(), v1.IsSigned());
+}
+
+inline IntVal operator*(uint64 v1, const IntVal& v2) {
+  return v2 * v1;
+}
+
+inline IntVal operator/(const IntVal &v1, uint64 v2) {
+  return v1 / IntVal(v2, v1.GetBitWidth(), v1.IsSigned());
+}
+
+inline IntVal operator/(uint64 v1, const IntVal& v2) {
+  return IntVal(v1, v2.GetBitWidth(), v2.IsSigned()) / v2;
+}
+
+inline IntVal operator%(const IntVal &v1, uint64 v2) {
+  return v1 % IntVal(v2, v1.GetBitWidth(), v1.IsSigned());
+}
+
+inline IntVal operator%(uint64 v1, const IntVal& v2) {
+  return IntVal(v1, v2.GetBitWidth(), v2.IsSigned()) % v2;
+}
+
+inline IntVal operator&(const IntVal &v1, uint64 v2) {
+  return v1 & IntVal(v2, v1.GetBitWidth(), v1.IsSigned());
+}
+
+inline IntVal operator&(uint64 v1, const IntVal &v2) {
+  return v2 & v1;
+}
+
+}  // namespace maple
+
+#endif  // MAPLE_UTIL_INCLUDE_MPL_INT_VAL_H
diff --git a/src/mapleall/maple_util/include/mpl_logging.h b/src/mapleall/maple_util/include/mpl_logging.h
new file mode 100644
index 0000000000000000000000000000000000000000..b62e3f724086ca07c60e10107d4779016ab29ed0
--- /dev/null
+++ b/src/mapleall/maple_util/include/mpl_logging.h
@@ -0,0 +1,376 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_MPL_LOGGING_H
+#define MAPLE_UTIL_INCLUDE_MPL_LOGGING_H
+
+#include <string>
+#include <cstdio>
+#include <sstream>
+#include <iostream>
+#include <vector>
+#include <map>
+#include <cstdint>
+#include <mutex>
+
+// This file defines the APIs that govern all messaging-styled output from
+// a running program under MAPLE, which can be a compiler or a runtime component.
+//
+// There are two overall classes of messages:
+//
+// (1) Those of interest only to developers, and thus should be suppressed in the
+// production release version of the software.  The message content will include
+// the source file and line number of the trigger point of the message.
+//
+// (2) Those intended to be visible to users of the software in general,  in
+// addition to the developers.
+//
+// Messages are divided into 6 types, or levels, from 0 to 5.  Conceptually,
+// the lower the level, the higher the frequency of occurrences, the larger the
+// output volume, the smaller the audience of interest and the more often they need
+// to be filtered out. In addition, the higher the level, the greater the severity.
+//
+// Level 0 (DBG) - These are messages for debugging purposes, used by the
+// developer during development to debug his code.
+//
+// Level 1 (LOG) - These are log messages, also for helping the developer in
+// debugging, but at a higher level of algorithmic operation.
+//
+// Level 2 (INFO) - These provide information that are of general usefulness in
+// the normal operation of the SW.
+//
+// Level 3 (WARN) - These provide warning messages.
+//
+// Level 4 (ERR) - These provide error messages.
+//
+// Level 5 (FATAL) - These indicate errors of such severity that the program r
+// execution cannot continue.
+//
+// DBG and LOG are only for developers' use.  INFO, WARN, ERR and FATAL are
+// intended for general visibility.  There is an additional type of ERR that
+// designate developer errors that arise out of checking code inserted by the
+// developers, which has the following 4 usage patterns:
+//
+// CHECK - If the specified program condition is not satisfied, output the error
+// message. The program will continue execution.
+//
+// DCHECK - Same as CHECK, but the check is suppressed in the release version of
+// the SW.
+//
+// CHECK_FATAL - If the specified program condition is not satisfied, output the error
+// message. The program will stop execution at that point.
+//
+// ASSERT - Same as CHECK_FATAL, but the check is suppressed in the release version of
+// the SW.
+//
+// The macro setting DEBUG=1 picks developer and DEBUG=0 picks release builds.
+//
+// the macro PRINT_LEVEL_DEV is a filter for DBG messages in developer builds.
+// When PRINT_LEVEL_DEV is set to kLlLog, DBG messages are not printed.
+//
+// Instantiated object c_logInfo, of class LogInfo, provides finer control of
+// the logging behavior during execution.  Use emitLogDevice() to change the
+// message destination.  Use setLogMode() to change the verbosity of the messages.
+//
+// In the case of DBG and LOG, the message needs to print the name of the SW
+// component as the volume of messages can be huge.  Use enum LOG_TAGS to define
+// the component ID and its name string.
+//
+// Since INFO, WARN, ERR and FATAL are for general consumption, each message
+// should provide an number code under enum LogNumberCode.
+//
+// Following are usage of logging actions supported:
+//
+// GDB,LOG,INFO,WARN,ERR,FATAL can be invoked as method.
+//   parameters:
+//     TAG
+//     formatted string
+//     variadic list
+//
+// CHECK,DCHECK,CHECK_FATAL,ASSERT also can be invoked as method.
+//   parameters:
+//     condition
+//     formatted string
+//     variadic list
+//
+// Each of the above are mapped to one of the following 3 methods in class LogInfo:
+//
+// EmitLogForDev() - for DBG and LOG
+//
+// EmitLogForUser() - for INFO, WARN, ERR and FATAL
+//
+// EmitErrorMessage() - for CHECK, DCHECK, CHECK_FATAL and ASSERT
+//
+// DBG and LOG send their messages to stdout, and provide additional date and time
+// information.  For the rest, the messages are sent to stderr.
+//
+// In debugging the program, the developer can set breakpoint in one of the above
+// 3 methods depending on the type of message. For ASSERT, abort() is called
+// instead of exit(1) so that the program will not completely exit, to allow the
+// developer to print stack trace and peruse the program environment at the point
+// of the assertion.
+namespace maple {
+extern class LogInfo logInfo;
+extern class LogInfo &log;
+
+enum LogLevel {
+  kLlDbg,
+  kLlLog,
+  kLlInfo,
+  kLlWarn,
+  kLlErr,
+  kLlFatal,
+  kLlMax
+};
+
+enum LogTags {
+  kLtThread,
+  kLtLooper,
+  kLtAll
+};
+
+enum LogMode {
+  kLmSimple,
+  kLmComplex,
+  kLmMax
+};
+
+enum LogNumberCode {
+  kLncInfo = 0,
+  kLncWarn = 20,
+  kLncErr = 40,
+  kLncFatal = 60,
+  kLncMax = 99
+};
+
+struct Loc {
+  std::uint32_t fileIdx;
+  std::uint32_t line;
+  std::uint32_t column;
+  Loc(std::uint32_t fileIdxIn, std::uint32_t lineIn, std::uint32_t columnIn)
+      : fileIdx(fileIdxIn),  line(lineIn), column(columnIn) {}
+
+  bool operator<(Loc const &loc) const {
+    if (fileIdx != loc.fileIdx) {
+      return fileIdx < loc.fileIdx;
+    } else if (line != loc.line) {
+      return line < loc.line;
+    } else {
+      return column < loc.column;
+    }
+  }
+
+  bool operator==(Loc const &loc) const {
+    return (fileIdx == loc.fileIdx) && (line == loc.line) && (column == loc.column);
+  }
+
+  std::string Dump() const {
+    std::stringstream ss;
+    ss << "fileIdx:" << fileIdx << ", line:" << line << ", column:" << column << "\n";
+    return ss.str();
+  }
+};
+
+class LogInfo {
+ public:
+  LogInfo() : outStream(stdout), outMode(kLmComplex) {}
+  LogInfo(const LogInfo &p) = delete;
+  static std::ostream &Info();
+  static std::ostream &Err();
+  LogInfo &operator=(const LogInfo &p) = delete;
+
+  ~LogInfo() {
+    fclose(outStream);
+  }
+
+  static std::ostream &MapleLogger(LogLevel level = kLlLog);
+  static std::ios::fmtflags Flags();
+  void EmitLogForUser(enum LogNumberCode num, enum LogLevel ll, const char *fmt, ...) const;
+  std::string EmitLogToStringForUser(enum LogNumberCode num, enum LogLevel ll, const char *fmt, ...) const;
+  void EmitLogForUser(enum LogNumberCode num, enum LogLevel ll, const std::string &message) const;
+  void EmitErrorMessage(const std::string &cond, const std::string &file, unsigned int line,
+                        const char *fmt, ...) const;
+  void InsertUserWarnMessage(const Loc &loc, const std::string &message);
+  void PrintUserWarnMessages();
+  void InsertUserErrorMessage(const Loc &loc, const std::string &err);
+  void PrintUserErrorMessages();
+  uint GetUserWarnsNum() const {
+    return warnsNum;
+  }
+
+  uint GetUserErrorsNum() const {
+    return errsNum;
+  }
+
+ private:
+  void SetLogDevice(FILE *stream) {
+    outStream = stream;
+  }
+  void SetLogMode(LogMode lm) {
+    outMode = lm;
+  }
+  void EmitLogForDevelop(enum LogTags tag, enum LogLevel ll, const std::string &file, const std::string &func,
+                         int line, const char *fmt, ...);
+  FILE *outStream;
+  LogMode outMode;
+  std::map<Loc, std::vector<std::string>> userErrsMap;
+  std::map<Loc, std::vector<std::string>> userWarnsMap;
+  uint errsNum = 0;
+  uint warnsNum = 0;
+  std::mutex warnsMtx;
+  std::mutex errsMtx;
+};
+
+#ifdef DEBUG
+#define DEBUG_STMT(x) x
+#define DEBUG_TEST 1
+#define ENABLE_ASSERT 1
+#define EXCEPTION_QUIT abort()
+#else
+#define DEBUG_STMT(x)
+#define DEBUG_TEST 0
+#define ENABLE_ASSERT 0
+#define EXCEPTION_QUIT exit(1)
+#endif  // DEBUG
+
+// for developer
+#define PRINT_LEVEL_DEV kLlLog
+
+#define DBG(tag, fmt, ...)                                                                      \
+  do {                                                                                          \
+    if (PRINT_LEVEL_DEV <= kLlLog) {                                                             \
+      logInfo.EmitLogForDev(tag, kLlLog, __FILE__, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__); \
+    }                                                                                           \
+  } while (0)
+
+#ifdef LOG
+#undef LOG
+#endif
+#define LOG(tag, fmt, ...)                                                                      \
+  do {                                                                                          \
+    if (PRINT_LEVEL_DEV <= kLlLog) {                                                            \
+      logInfo.EmitLogForDev(tag, kLlLog, __FILE__, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__); \
+    }                                                                                                \
+  } while (0)
+
+#ifdef CHECK
+#undef CHECK
+#endif
+#define CHECK(cond, fmt, ...)                                                       \
+  do {                                                                              \
+    if (!(cond)) {                                                                  \
+      logInfo.EmitErrorMessage(#cond, __FILE__, __LINE__, fmt "\n", ##__VA_ARGS__); \
+    }                                                                                  \
+  } while (0)
+
+#ifdef DCHECK
+#undef DCHECK
+#endif
+#define DCHECK(cond, fmt, ...)                   \
+  do {                                           \
+    DEBUG_STMT(CHECK(cond, fmt, ##__VA_ARGS__)); \
+  } while (0)
+
+// To shut down the codecheck warning: boolean condition for 'if' always evaluates to 'true'
+#define CHECK_FATAL_FALSE(fmt, ...)                                                        \
+  do {                                                                                     \
+    maple::logInfo.EmitErrorMessage("false", __FILE__, __LINE__, fmt "\n", ##__VA_ARGS__); \
+    maple::logInfo.PrintUserWarnMessages();                                                \
+    maple::logInfo.PrintUserErrorMessages();                                               \
+    EXCEPTION_QUIT;                                                                        \
+  } while (0)
+
+#define CHECK_FATAL(cond, fmt, ...)                                                        \
+  do {                                                                                     \
+    if (!(cond)) {                                                                         \
+      maple::logInfo.EmitErrorMessage(#cond, __FILE__, __LINE__, fmt "\n", ##__VA_ARGS__); \
+      maple::logInfo.PrintUserWarnMessages();                                              \
+      maple::logInfo.PrintUserErrorMessages();                                             \
+      EXCEPTION_QUIT;                                                                      \
+    }                                                                                      \
+  } while (0)
+
+#define CHECK_NULL_FATAL(ptr) CHECK_FATAL(ptr != nullptr, "Failed with nullptr.")
+
+#if ENABLE_ASSERT
+#define ASSERT(cond, fmt, ...)                                                      \
+  do {                                                                              \
+    if (!(cond)) {                                                                  \
+      maple::logInfo.EmitErrorMessage(#cond, __FILE__, __LINE__, fmt "\n", ##__VA_ARGS__); \
+      abort();                                                                      \
+    }                                                                               \
+  } while (0)
+
+#define ASSERT_NOT_NULL(ptr) ASSERT(ptr != nullptr, "Failed with nullptr.")
+#else
+#define ASSERT(cond, fmt, ...)
+#define ASSERT_NOT_NULL(ptr)
+#endif  // ENABLE_ASSERT
+
+// for user
+#define PRINT_LEVEL_USER kLlInfo
+
+#define INFO(num, fmt, ...)                                     \
+  do {                                                          \
+    if (PRINT_LEVEL_USER <= kLlInfo) {                          \
+      logInfo.EmitLogForUser(num, kLlInfo, fmt, ##__VA_ARGS__); \
+    }                                                              \
+  } while (0)
+
+#define INFO_V(verbose, num, fmt, ...)                          \
+  if (verbose) {                                                \
+    if (PRINT_LEVEL_USER <= kLlInfo) {                          \
+      logInfo.EmitLogForUser(num, kLlInfo, fmt, ##__VA_ARGS__); \
+    }                                                           \
+  }
+
+#define WARN_USER(num, pos, mod, fmt, ...)                                                                         \
+  do {                                                                                                             \
+    if (PRINT_LEVEL_USER <= kLlWarn) {                                                                             \
+      std::ostringstream ss;                                                                                       \
+      ss << mod.GetFileNameFromFileNum(pos.FileNum()) << ":" << pos.LineNum() << " warning: " << fmt;              \
+      logInfo.InsertUserWarnMessage(                                                                               \
+          pos.GetSrcLoc(), logInfo.EmitLogToStringForUser(num, kLlWarn, ss.str().c_str(), ##__VA_ARGS__));         \
+    }                                                                                                              \
+  } while (0)
+
+#define WARN(num, fmt, ...)                                                                                        \
+  do {                                                                                                             \
+    if (PRINT_LEVEL_USER <= kLlWarn) {                                                                             \
+      logInfo.EmitLogForUser(num, kLlWarn, fmt, ##__VA_ARGS__);                                                    \
+    }                                                                                                              \
+  } while (0)
+
+#define ERR(num, fmt, ...)                                     \
+  do {                                                         \
+    if (PRINT_LEVEL_USER <= kLlErr) {                          \
+      logInfo.EmitLogForUser(num, kLlErr, fmt, ##__VA_ARGS__); \
+    }                                                          \
+  } while (0)
+
+#define FATAL(num, fmt, ...)                                     \
+  do {                                                           \
+    logInfo.PrintUserWarnMessages();                             \
+    logInfo.PrintUserErrorMessages();                            \
+    if (PRINT_LEVEL_USER <= kLlFatal) {                          \
+      logInfo.EmitLogForUser(num, kLlFatal, fmt, ##__VA_ARGS__); \
+    }                                                            \
+    if (DEBUG_TEST != 0) {                                       \
+      abort();                                                   \
+    } else {                                                     \
+      exit(1);                                                   \
+    }                                                            \
+  } while (0)
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_MPL_LOGGING_H
diff --git a/src/mapleall/maple_util/include/mpl_number.h b/src/mapleall/maple_util/include/mpl_number.h
new file mode 100644
index 0000000000000000000000000000000000000000..27395925e79da70c52b30e3af085c5d1b833d403
--- /dev/null
+++ b/src/mapleall/maple_util/include/mpl_number.h
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_MPL_NUMBER_H
+#define MAPLE_UTIL_INCLUDE_MPL_NUMBER_H
+#include <algorithm>
+#include <string>
+#include "utils/meta.h"
+
+namespace maple {
+namespace utils {
+template<typename T, typename = void>
+class Number {
+ public:
+  static_assert(std::is_integral<T>::value, "Type for Number should be an integral.");
+
+  using ElementType = T;
+
+  Number() = default;
+
+  explicit Number(ElementType data) : val(data) {}
+
+  template<typename U, typename = std::enable_if_t<std::is_integral<U>::value>>
+  explicit Number(U data) : val(static_cast<T>(data)) {}
+
+  Number(const Number &num) : val(num.val) {}
+
+  Number(Number &&num) noexcept : val(std::move(num.val)) {}
+
+  ~Number() = default;
+
+  // As the implicit T cast is enabled, disable it to avoid implicit cast for `Number<T, Tag1> num = Number<T, Tag2>()`
+  // which should be two types and should not be able to neither convert to each other nor compare with each other.
+  Number &operator=(ElementType data) = delete;
+
+  Number &operator=(const Number &num) noexcept {
+    if (&num != this) {
+      val = num.val;
+    }
+    return *this;
+  }
+
+  Number &operator=(Number &&num) noexcept {
+    if (&num != this) {
+      val = std::move(num.val);
+    }
+    return *this;
+  }
+
+  void reset(ElementType data = 0) noexcept {
+    val = data;
+  }
+
+  void swap(Number &other) noexcept {
+    std::swap(val, other.val);
+  }
+
+  ElementType get() const noexcept {
+    return val;
+  }
+
+  template<typename U = T>
+  operator std::enable_if_t<std::is_same<U, T>::value, U>() const noexcept {
+    return val;
+  }
+
+  template<typename U = size_t>
+  operator
+      std::enable_if_t<meta_and<meta_not<std::is_same<U, T>>, std::is_same<U, size_t>>::value, U>() const noexcept {
+    return static_cast<size_t>(val);
+  }
+
+  template<typename U, typename = std::enable_if_t<meta_and<meta_not<std::is_same<U, T>>,
+                                                            meta_not<std::is_same<U, size_t>>>::value>>
+  explicit operator U() const noexcept {
+    return static_cast<U>(val);
+  }
+
+  Number &operator+=(const T &data) noexcept {
+    val += data;
+  }
+
+  Number &operator+=(const Number &num) noexcept {
+    val += num.val;
+  }
+
+  Number &operator-=(const T &data) noexcept {
+    val -= data;
+  }
+
+  Number &operator-=(const Number &num) noexcept {
+    val -= num.val;
+  }
+
+  Number &operator++() noexcept {
+    ++val;
+    return *this;
+  }
+
+  const Number operator++(int) {
+    auto tmp = val;
+    this->operator++();
+    return Number(tmp);
+  }
+
+  Number &operator--() noexcept {
+    --val;
+    return *this;
+  }
+
+  const Number operator--(int) {
+    auto tmp = val;
+    this->operator--;
+    return Number(tmp);
+  }
+
+  T GetIdx() const {
+    return val;
+  }
+
+  void SetIdx(T i) {
+    val = i;
+  }
+
+ private:
+  ElementType val = 0;
+};
+
+template<typename T, typename Tag>
+inline bool operator==(const Number<T, Tag> &lhs, const Number<T, Tag> &rhs) {
+  return lhs.get() == rhs.get();
+}
+
+template<typename T, typename Tag>
+inline bool operator!=(const Number<T, Tag> &lhs, const Number<T, Tag> &rhs) {
+  return !(lhs == rhs);
+}
+
+template<typename T, typename Tag>
+inline bool operator<(const Number<T, Tag> &lhs, const Number<T, Tag> &rhs) {
+  return lhs.get() < rhs.get();
+}
+
+template<typename T, typename Tag>
+inline bool operator<=(const Number<T, Tag> &lhs, const Number<T, Tag> &rhs) {
+  return lhs.get() <= rhs.get();
+}
+
+template<typename T, typename Tag>
+inline bool operator>(const Number<T, Tag> &lhs, const Number<T, Tag> &rhs) {
+  return !(lhs <= rhs);
+}
+
+template<typename T, typename Tag>
+inline bool operator>=(const Number<T, Tag> &lhs, const Number<T, Tag> &rhs) {
+  return !(lhs < rhs);
+}
+
+template<typename T, typename Tag>
+inline Number<T, Tag> operator+(const Number<T, Tag> &lhs, const Number<T, Tag> &rhs) {
+  return Number<T, Tag>(lhs.get() + rhs.get());
+}
+
+
+template<typename T, typename Tag>
+inline Number<T, Tag> operator-(const Number<T, Tag> &lhs, const Number<T, Tag> &rhs) {
+  return Number<T, Tag>(lhs.get() - rhs.get());
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator==(const Number<T, Tag> &lhs, const U &rhs) {
+  return lhs.get() == rhs;
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator==(const U &lhs, const Number<T, Tag> &rhs) {
+  return lhs == rhs.get();
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator!=(const Number<T, Tag> &lhs, const U &rhs) {
+  return !(lhs == rhs);
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator!=(const U &lhs, const Number<T, Tag> &rhs) {
+  return !(lhs == rhs);
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator<(const Number<T, Tag> &lhs, const U &rhs) {
+  return lhs.get() < rhs;
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator<(const U &lhs, const Number<T, Tag> &rhs) {
+  return lhs < rhs.get();
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator<=(const Number<T, Tag> &lhs, const U &rhs) {
+  return lhs.get() <= rhs;
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator<=(const U &lhs, const Number<T, Tag> &rhs) {
+  return lhs <= rhs.get();
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator>(const Number<T, Tag> &lhs, const U &rhs) {
+  return !(lhs <= rhs);
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator>(const U &lhs, const Number<T, Tag> &rhs) {
+  return !(lhs <= rhs);
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator>=(const Number<T, Tag> &lhs, const U &rhs) {
+  return !(lhs < rhs);
+}
+
+template<typename T, typename Tag, typename U,
+         typename = std::enable_if_t<meta_or<std::is_integral<U>, std::is_enum<U>>::value>>
+inline bool operator>=(const U &lhs, const Number<T, Tag> &rhs) {
+  return !(lhs < rhs);
+}
+
+template<typename T, typename Tag, typename U, typename = std::enable_if_t<std::is_integral<U>::value>>
+inline Number<T, Tag> operator+(const Number<T, Tag> &lhs, const U &rhs) {
+  return Number<T, Tag>(lhs.get() + rhs);
+}
+
+template<typename T, typename Tag, typename U, typename = std::enable_if_t<std::is_integral<U>::value>>
+inline Number<T, Tag> operator+(const U &lhs, const Number<T, Tag> &rhs) {
+  return Number<T, Tag>(lhs + rhs.get());
+}
+
+template<typename T, typename Tag, typename U, typename = std::enable_if_t<std::is_integral<U>::value>>
+inline Number<T, Tag> operator-(const Number<T, Tag> &lhs, const U &rhs) {
+  return Number<T, Tag>(lhs.get() - rhs);
+}
+
+template<typename T, typename Tag, typename U, typename = std::enable_if_t<std::is_integral<U>::value>>
+inline Number<T, Tag> operator-(const U &lhs, const Number<T, Tag> &rhs) {
+  return Number<T, Tag>(lhs - rhs.get());
+}
+
+template<typename T, typename Tag, typename OS>
+inline OS &operator<<(OS &os, const Number<T, Tag> &num) {
+  os << num.get();
+  return os;
+}
+
+template<typename Type, typename T = size_t>
+using Index = Number<T, Type>;
+}
+}
+
+namespace std {
+  template<typename T, typename Type>
+  inline string to_string(maple::utils::Number<T, Type> val) {
+    return std::to_string(val.get());
+  }
+
+template <class T>
+inline void hash_combine(std::size_t& seed, const T& v) {
+  std::hash<T> hasher;
+  size_t hasecode = 0x9e3779b9;
+  size_t leftShift = 6;
+  size_t rightShift = 2;
+  seed ^= hasher(v) + hasecode + (seed << leftShift) + (seed >> rightShift);
+}
+}
+#endif // MAPLE_UTIL_INCLUDE_MPL_NUMBER_H
\ No newline at end of file
diff --git a/src/mapleall/maple_util/include/mpl_profdata.h b/src/mapleall/maple_util/include/mpl_profdata.h
new file mode 100644
index 0000000000000000000000000000000000000000..23cf6f99b95eaef8c63518ea7c486478075acf9b
--- /dev/null
+++ b/src/mapleall/maple_util/include/mpl_profdata.h
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_UTIL_INCLUDE_MPL_PROFDATA_H
+#define MAPLE_UTIL_INCLUDE_MPL_PROFDATA_H
+#include <unordered_map>
+#include <string>
+#include "mempool_allocator.h"
+
+namespace maple {
+constexpr uint32_t HOTCALLSITEFREQ = 100;
+enum UpdateFreqOp {
+  kKeepOrigFreq = 0,
+  kUpdateOrigFreq = 0x1,
+  kUpdateFreqbyScale = 0x2,
+  kUpdateUnrolledFreq = 0x4,
+  kUpdateUnrollRemainderFreq = 0x8,
+};
+
+// used for record cumulative datas
+struct ProfileSummaryHistogram {
+  uint32_t countRatio;
+  uint32_t startValue;     // count value range in [startValue, nextHistogramStart)
+  uint32_t countNums;      // Number of counters whose profile count falls in countValue range.
+  uint64_t countMinVal;    // Smallest profile count included in this range.
+  uint64_t countCumValue;  // Cumulative value of the profile counts
+
+  ProfileSummaryHistogram(uint32_t s, uint32_t num, uint64_t mincount, uint64_t cumcounts)
+      : countRatio(0), startValue(s), countNums(num), countMinVal(mincount), countCumValue(cumcounts) {}
+};
+
+class ProfileSummary {
+ public:
+  explicit ProfileSummary(MapleAllocator *alloc) : histogram(alloc->Adapter()) {}
+  ProfileSummary(MapleAllocator *alloc, uint64_t checksum, uint32_t runtimes, uint32_t totalcount, uint64_t maxcount,
+                 uint64_t sumcount)
+      : checkSum(checksum),
+        run(runtimes),
+        totalCount(totalcount),
+        maxCount(maxcount),
+        sumCount(sumcount),
+        histogram(alloc->Adapter()) {}
+
+  void SetSummary(uint64_t checksum, uint32_t runtimes, uint32_t totalcount, uint64_t maxcount, uint64_t sumcount) {
+    checkSum = checksum;
+    run = runtimes;
+    totalCount = totalcount;
+    maxCount = maxcount;
+    sumCount = sumcount;
+  }
+  void AddHistogramRecord(uint32_t s, uint32_t num, uint64_t mincount, uint64_t cumcounts) {
+    histogram.push_back(ProfileSummaryHistogram(s, num, mincount, cumcounts));
+  }
+  void DumpSummary();
+  uint64_t GetCheckSum() {
+    return checkSum;
+  }
+  uint32_t GetRun() {
+    return run;
+  }
+  uint32_t GetTotalCount() {
+    return totalCount;
+  }
+  uint64_t GetMaxCount() {
+    return maxCount;
+  }
+  uint64_t GetSumCount() {
+    return sumCount;
+  }
+  uint32_t GetHistogramLength() {
+    return histogram.size();
+  }
+  void ProcessHistogram();
+  MapleVector<ProfileSummaryHistogram> &GetHistogram() {
+    return histogram;
+  }
+
+ private:
+  uint64_t checkSum;                               // checksum value of module
+  uint32_t run;                                    // run times
+  uint32_t totalCount;                             // number of counters
+  uint64_t maxCount;                               // max counter value in single run
+  uint64_t sumCount;                               // sum of all counters accumulated.
+  MapleVector<ProfileSummaryHistogram> histogram;  // record gcov_bucket_type histogram[GCOV_HISTOGRAM_SIZE];
+};
+
+class FuncProfInfo {
+ public:
+  FuncProfInfo(MapleAllocator *alloc, unsigned funcIdent, unsigned linenoCs, unsigned cfgCs, unsigned countnum = 0)
+      : ident(funcIdent),
+        linenoChecksum(linenoCs),
+        cfgChecksum(cfgCs),
+        edgeCounts(countnum),
+        counts(alloc->Adapter()){};
+  ~FuncProfInfo() = default;
+
+  uint64_t GetFuncFrequency() const {
+    return entryFreq;
+  }
+  void SetFuncFrequency(uint64_t freq) {
+    entryFreq = freq;
+  }
+
+  uint64_t GetFuncRealFrequency() const {
+    return realEntryfreq;
+  }
+  void SetFuncRealFrequency(uint64_t freq) {
+    realEntryfreq = freq;
+  }
+
+  std::unordered_map<uint32_t, uint64_t> &GetStmtFreqs() {
+    return stmtFreqs;
+  }
+  uint64_t GetStmtFreq(uint32_t stmtID) {
+    if (stmtFreqs.count(stmtID) > 0) {
+      return stmtFreqs[stmtID];
+    }
+    return -1;  // unstored
+  }
+  void SetStmtFreq(uint32_t stmtID, uint64_t freq) {
+    stmtFreqs[stmtID] = freq;
+  }
+  void EraseStmtFreq(uint32_t stmtID) {
+    stmtFreqs.erase(stmtID);
+  }
+  void CopyStmtFreq(uint32_t newStmtID, uint32_t origStmtId, bool deleteOld = false) {
+    ASSERT(GetStmtFreq(origStmtId) >= 0, "origStmtId no freq record");
+    SetStmtFreq(newStmtID, GetStmtFreq(origStmtId));
+    if (deleteOld) {
+      EraseStmtFreq(origStmtId);
+    }
+  }
+  bool IsHotCallSite(uint32_t stmtID) {
+    if (stmtFreqs.count(stmtID) > 0) {
+      uint64_t freq = stmtFreqs[stmtID];
+      return (freq >= HOTCALLSITEFREQ);
+    }
+    ASSERT(0, "should not be here");
+    return false;
+  }
+  void DumpFunctionProfile();
+
+  unsigned ident;
+  unsigned linenoChecksum;
+  unsigned cfgChecksum;
+
+  // Raw arc coverage counts.
+  unsigned edgeCounts;
+  MapleVector<uint64_t> counts;
+  uint64_t entryFreq;                               // record entry bb frequence
+  std::unordered_map<uint32_t, uint64_t> stmtFreqs;  // stmt_id is key, counter value
+  uint64_t realEntryfreq;                           // function prof data may be modified after clone/inline
+};
+
+class MplProfileData {
+ public:
+  MplProfileData(MemPool *m, MapleAllocator *a) : funcsCounter(a->Adapter()), summary(a), mp(m), alloc(a) {}
+
+  FuncProfInfo *GetFuncProfile(unsigned puidx) {
+    if (funcsCounter.count(puidx) > 0) {
+      return funcsCounter[puidx];
+    }
+    return nullptr;
+  }
+  FuncProfInfo *AddNewFuncProfile(unsigned puidx, unsigned linoCs, unsigned cfgCs, unsigned countnum) {
+    FuncProfInfo *funcProf = mp->New<FuncProfInfo>(alloc, puidx, linoCs, cfgCs, countnum);
+    ASSERT(funcsCounter.count(puidx) == 0, "sanity check");
+    funcsCounter[puidx] = funcProf;
+    return funcProf;
+  }
+  void AddFuncProfile(unsigned puidx, FuncProfInfo *funcData) {
+    ASSERT(funcsCounter.count(puidx) == 0, "sanity check");
+    funcsCounter[puidx] = funcData;
+  }
+  void DumpProfileData();
+  void DumpFunctionsProfile();
+  bool IsHotCallSite(uint64_t freq);
+
+  MapleUnorderedMap<unsigned, FuncProfInfo*> funcsCounter;  // use puidx as key
+  // record module profile information and statistics of count information
+  ProfileSummary summary;
+  uint64_t hotCountThreshold = 0;
+
+ private:
+  uint64_t GetHotThreshold();
+
+  MemPool *mp;
+  MapleAllocator *alloc;
+};
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_MPL_PROFDATA_H
diff --git a/src/mapleall/maple_util/include/mpl_scheduler.h b/src/mapleall/maple_util/include/mpl_scheduler.h
new file mode 100644
index 0000000000000000000000000000000000000000..97e9043cd6d29888249c9fceaa8b1af5784c72ff
--- /dev/null
+++ b/src/mapleall/maple_util/include/mpl_scheduler.h
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_MPLSCHEDULER_H
+#define MAPLE_UTIL_INCLUDE_MPLSCHEDULER_H
+
+#include <vector>
+#include <set>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <pthread.h>
+#include <cinttypes>
+#include <iostream>
+#include <string>
+#include "types_def.h"
+
+namespace maple {
+class MplTaskParam {
+ public:
+  MplTaskParam() = default;
+  virtual ~MplTaskParam() = default;
+};
+
+class MplTask {
+ public:
+  MplTask() : taskId(0) {}
+
+  virtual ~MplTask() = default;
+
+  void SetTaskId(uint32 id) {
+    taskId = id;
+  }
+
+  uint32 GetTaskId() const {
+    return taskId;
+  }
+
+  int Run(MplTaskParam *param = nullptr) {
+    return RunImpl(param);
+  }
+
+  int Finish(MplTaskParam *param = nullptr) {
+    return FinishImpl(param);
+  }
+
+ protected:
+  virtual int RunImpl(MplTaskParam*) {
+    return 0;
+  }
+
+  virtual int FinishImpl(MplTaskParam*) {
+    return 0;
+  }
+
+  uint32 taskId;
+};
+
+class MplSchedulerParam {
+ public:
+  MplSchedulerParam() = default;
+  ~MplSchedulerParam() = default;
+};
+
+class MplScheduler {
+ public:
+  explicit MplScheduler(const std::string &name);
+  virtual ~MplScheduler() = default;
+
+  void Init();
+  virtual void AddTask(MplTask &task);
+  virtual int RunTask(uint32 threadsNum, bool seq = false);
+  virtual MplSchedulerParam *EncodeThreadMainEnvironment(uint32) {
+    return nullptr;
+  }
+
+  virtual void DecodeThreadMainEnvironment(MplSchedulerParam*) {}
+
+  virtual MplSchedulerParam *EncodeThreadFinishEnvironment() {
+    return nullptr;
+  }
+
+  virtual void DecodeThreadFinishEnvironment(MplSchedulerParam*) {}
+
+  void GlobalLock() {
+    pthread_mutex_lock(&mutexGlobal);
+  }
+
+  void GlobalUnlock() {
+    pthread_mutex_unlock(&mutexGlobal);
+  }
+
+  void Reset();
+
+ protected:
+  std::string schedulerName;
+  std::vector<MplTask*> tbTasks;
+  std::set<uint32> tbTaskIdsToFinish;
+  uint32 taskIdForAdd;
+  uint32 taskIdToRun;
+  uint32 taskIdExpected;
+  uint32 numberTasks;
+  uint32 numberTasksFinish;
+  pthread_mutex_t mutexTaskIdsToRun;
+  pthread_mutex_t mutexTaskIdsToFinish;
+  pthread_mutex_t mutexTaskFinishProcess;
+  pthread_mutex_t mutexGlobal;
+  pthread_cond_t conditionFinishProcess;
+  bool isSchedulerSeq;
+  bool dumpTime;
+
+  enum ThreadStatus {
+    kThreadStop,
+    kThreadRun,
+    kThreadPause
+  };
+
+  ThreadStatus statusFinish;
+  virtual int FinishTask(const MplTask &task);
+  virtual MplTask *GetTaskToRun();
+  virtual size_t GetTaskIdsFinishSize();
+  virtual MplTask *GetTaskFinishFirst();
+  virtual void RemoveTaskFinish(uint32 id);
+  virtual void TaskIdFinish(uint32 id);
+  void ThreadMain(uint32 threadID, MplSchedulerParam *env);
+  void ThreadFinishNoSequence(MplSchedulerParam *env);
+  void ThreadFinishSequence(MplSchedulerParam *env);
+  void ThreadFinish(MplSchedulerParam *env);
+  // Callback Function
+  virtual void CallbackThreadMainStart() {}
+
+  virtual void CallbackThreadMainEnd() {}
+
+  virtual void CallbackThreadFinishStart() {}
+
+  virtual void CallbackThreadFinishEnd() {}
+
+  virtual MplTaskParam *CallbackGetTaskRunParam() const {
+    return nullptr;
+  }
+
+  virtual MplTaskParam *CallbackGetTaskFinishParam() const {
+    return nullptr;
+  }
+};
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_MPLSCHEDULER_H
diff --git a/src/mapleall/maple_util/include/mpl_sighandler.h b/src/mapleall/maple_util/include/mpl_sighandler.h
new file mode 100644
index 0000000000000000000000000000000000000000..b9f516ca6df2e8b21ad97c9bbec4670b7663c3e3
--- /dev/null
+++ b/src/mapleall/maple_util/include/mpl_sighandler.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_UTIL_INCLUDE_MPL_SIGHANDLER
+#define MAPLE_UTIL_INCLUDE_MPL_SIGHANDLER
+
+#include <csignal>
+#include <map>
+
+namespace maple {
+
+class SigHandler {
+ public:
+  SigHandler() = delete;
+  ~SigHandler(){};
+
+  /// @brief enable handlig all supported signals
+  static void EnableAll();
+  /// @brief enable handlig signal "sig"
+  static void EnableSig(int sig);
+
+  /// @brief disable handling all supported signals
+  static void DisableAll();
+  /// @brief disable handling signal with num 'sig'
+  static void DisableSig(int sig);
+
+  /// @brief this function will be called in case that programm received signal
+  static void Handler(int sig, siginfo_t *info, void *ucontext) noexcept;
+
+  [[maybe_unused]] static void (*emptyFuncPtr)(int, siginfo_t *, void *) noexcept;
+  using FuncPtr = decltype(emptyFuncPtr);
+
+  /// @brief set user-defined signal callback
+  /// 'callback' will be called at the end of handler function
+  static void SetCallback(int sig, FuncPtr callback);
+
+  /// @brief set alarm timer
+  static void SetTimer(int seconds);
+
+  /// @return true if signal is supported, otherwise -- false
+  static bool IsSupportedSig(int sig);
+
+ private:
+  static void SetSigaction(int sig, FuncPtr callback);
+  static void SetDefaultSigaction(int sig);
+
+  // map of user-defined callbacks
+  static std::map<int, FuncPtr> sig2callback;
+};
+}  // namespace maple
+
+#endif  // MAPLE_UTIL_INCLUDE_MPL_SIGHANDLER
diff --git a/src/mapleall/maple_util/include/mpl_stacktrace.h b/src/mapleall/maple_util/include/mpl_stacktrace.h
new file mode 100644
index 0000000000000000000000000000000000000000..ef3b0526805ef0ea0872d103ea6e482dfa38cde9
--- /dev/null
+++ b/src/mapleall/maple_util/include/mpl_stacktrace.h
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_UTIL_INCLUDE_MPL_STACKTRACE
+#define MAPLE_UTIL_INCLUDE_MPL_STACKTRACE
+
+#ifdef __unix__
+#include <cxxabi.h>
+#include <dlfcn.h>
+#include <execinfo.h>
+#include <link.h>
+#endif
+
+#include <iomanip>
+#include <string>
+#include <vector>
+
+#include "mpl_logging.h"
+
+namespace maple {
+
+namespace stacktrace {
+
+static std::string demangle(const char *mangledName) {
+#ifdef __unix__
+  int status = 0;
+  char *name = abi::__cxa_demangle(mangledName, NULL, NULL, &status);
+
+  if (status != 0) {
+    return mangledName;
+  }
+
+  std::string res = std::string(name);
+  std::free(name);
+
+  return res;
+#else
+  return std::string();
+#endif
+}
+
+class Frame {
+ public:
+  explicit Frame(void *addr) : addr(addr) {
+    init();
+  }
+
+  Frame(const Frame &) = default;
+  Frame &operator=(const Frame &) = default;
+  ~Frame(){};
+
+ public:
+  std::string getFilename() const {
+    return filename;
+  }
+
+  std::string getName() const {
+    return name;
+  }
+
+  /* return addr in memory */
+  const void *getAddr() const {
+    return addr;
+  }
+
+  /* return the difference between the addr in the ELF file and the addr in memory */
+  uintptr_t getLinkAddr() const {
+    return linkAddr;
+  }
+
+  /* return addr in the ELF file */
+  uintptr_t getElfAddr() const {
+    uintptr_t castedAddr = reinterpret_cast<uintptr_t>(addr);
+    ASSERT(castedAddr >= linkAddr, "invalid Frame");
+    return castedAddr - linkAddr;
+  }
+
+  friend std::string to_string(const Frame &fr) {
+    std::stringstream ss;
+    if (fr.getName().empty())
+      ss << fr.getAddr();
+    else
+      ss << fr.getName();
+    ss << " ["
+       << "0x" << std::hex << fr.getElfAddr() << "]";
+    ss << (" in " + fr.getFilename());
+    return ss.str();
+  }
+
+  friend std::ostream &operator<<(std::ostream &os, const Frame &fr) {
+    os << to_string(fr);
+    return os;
+  }
+
+ private:
+  void init() {
+#ifdef __unix__
+    Dl_info info;
+    void *extraInfo = nullptr;
+
+    int status = dladdr1(addr, &info, &extraInfo, RTLD_DL_LINKMAP);
+    if (status != 1) {
+      LogInfo::MapleLogger() << "maple::Stacktrace: dladdr can't resolve address " << addr << std::endl;
+      return;
+    }
+
+    link_map *linkMap = static_cast<link_map *>(extraInfo);
+
+    filename = info.dli_fname ? std::string(info.dli_fname) : "??";
+    name = info.dli_sname ? demangle(info.dli_sname) : "??";
+    linkAddr = reinterpret_cast<uintptr_t>(linkMap->l_addr);
+#else
+    return;
+#endif
+  }
+
+ private:
+  const void *addr;
+
+  uintptr_t linkAddr;
+  std::string filename;
+  std::string name;
+};
+
+template <class Allocator>
+class Stacktrace {
+ public:
+  __attribute__((noinline)) Stacktrace(size_t maxDepth = 256) {
+    init(1, maxDepth);
+  }
+
+  Stacktrace(const Stacktrace &st) : frames(st.frames) {}
+
+  Stacktrace &operator=(const Stacktrace &st) {
+    frames = st.frames;
+    return *this;
+  }
+
+  Stacktrace(const Stacktrace &&st) : frames(std::move(st.frames)) {}
+
+  Stacktrace &operator=(const Stacktrace &&st) {
+    frames = std::move(st.frames);
+    return *this;
+  }
+
+  ~Stacktrace() = default;
+
+  friend std::string to_string(const Stacktrace &st) {
+    std::stringstream ss;
+    size_t count = 0;
+    constexpr size_t width = 2;
+    for (auto it = st.cbegin(); it != st.cend(); ++it) {
+      ss << std::setw(width) << count++ << "# " << *it << std::endl;
+    }
+    return ss.str();
+  }
+
+  friend std::ostream &operator<<(std::ostream &os, const Stacktrace &st) {
+    os << to_string(st);
+    return os;
+  }
+
+ public:
+  using iterator = typename std::vector<Frame, Allocator>::iterator;
+  using const_iterator = typename std::vector<Frame, Allocator>::const_iterator;
+  using reverse_iterator = typename std::reverse_iterator<iterator>;
+  using const_reverse_iterator = typename std::reverse_iterator<const_iterator>;
+
+  const_iterator cbegin() const {
+    return frames.cbegin();
+  }
+
+  const_iterator cend() const {
+    return frames.cend();
+  }
+
+  const_reverse_iterator crbegin() const {
+    return frames.crbegin();
+  }
+
+  const_reverse_iterator crend() const {
+    return frames.crend();
+  }
+
+  size_t size() const {
+    return frames.size();
+  }
+
+ private:
+  std::vector<Frame, Allocator> frames;
+
+ private:
+  void __attribute__((noinline)) init(size_t nskip, size_t maxDepth) {
+    ++nskip;  // skip current frame
+
+    typedef typename std::allocator_traits<Allocator>::template rebind_alloc<void *> allocator_void_ptr;
+    allocator_void_ptr allocator;
+    size_t bufferSize = maxDepth;
+    void **buffer = allocator.allocate(bufferSize);
+
+    size_t nframes = collectFrames(buffer, maxDepth);
+    ++nskip;  // skip frame of call "colectFrames(...)"
+
+    if (nskip <= nframes) {
+      for (size_t i = 0; i < nframes - nskip; ++i) {
+        frames.emplace_back(buffer[nskip + i]);
+      }
+    }
+
+    allocator.deallocate(buffer, bufferSize);
+  }
+
+  static size_t __attribute__((noinline)) collectFrames(void **outbuf, int maxFrames) {
+#ifdef __unix__
+    return backtrace(outbuf, maxFrames);
+#else
+    return 0;
+#endif
+  }
+};
+
+}  // namespace stacktrace
+
+template <class Allocator = std::allocator<stacktrace::Frame> >
+using Stacktrace = stacktrace::Stacktrace<Allocator>;
+
+}  // namespace maple
+
+#endif  //MAPLE_UTIL_INCLUDE_MPL_STACKTRACE
diff --git a/src/mapleall/maple_util/include/mpl_timer.h b/src/mapleall/maple_util/include/mpl_timer.h
new file mode 100644
index 0000000000000000000000000000000000000000..256329157af9b66d5cb5f6c21ecab63fd4ad3d47
--- /dev/null
+++ b/src/mapleall/maple_util/include/mpl_timer.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_MPL_TIMER_H
+#define MAPLE_UTIL_INCLUDE_MPL_TIMER_H
+
+#include <chrono>
+
+namespace maple {
+class MPLTimer {
+ public:
+  MPLTimer();
+  ~MPLTimer();
+  void Start();
+  void Stop();
+  long Elapsed();
+  long ElapsedMilliseconds();
+  long ElapsedMicroseconds();
+
+ private:
+  std::chrono::system_clock::time_point startTime;
+  std::chrono::system_clock::time_point endTime;
+};
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_MPL_TIMER_H
diff --git a/src/mapleall/maple_util/include/mrt_direct_classinfo_list.def b/src/mapleall/maple_util/include/mrt_direct_classinfo_list.def
new file mode 100644
index 0000000000000000000000000000000000000000..7b43e193d4859b52d3e1eb8905e6e5b7f7585fa8
--- /dev/null
+++ b/src/mapleall/maple_util/include/mrt_direct_classinfo_list.def
@@ -0,0 +1,43 @@
+"__cinf_Ljava_2Flang_2FBoolean_3B",
+"__cinf_Ljava_2Flang_2FByte_3B",
+"__cinf_Ljava_2Flang_2FCharacter_3B",
+"__cinf_Ljava_2Flang_2FShort_3B",
+"__cinf_Ljava_2Flang_2FInteger_3B",
+"__cinf_Ljava_2Flang_2FLong_3B",
+"__cinf_Ljava_2Flang_2FFloat_3B",
+"__cinf_Ljava_2Flang_2FDouble_3B",
+"__cinf_Ljava_2Flang_2FObject_3B",
+"__cinf_Ljava_2Flang_2FClass_3B",
+"__cinf_Ljava_2Flang_2Freflect_2FField_3B",
+"__cinf_Ljava_2Flang_2Freflect_2FConstructor_3B",
+"__cinf_Ljava_2Flang_2Freflect_2FMethod_3B",
+"__cinf_Ljava_2Flang_2FCloneable_3B",
+"__cinf_Ljava_2Fio_2FSerializable_3B",
+"__cinf_Ljava_2Flang_2FEnum_3B",
+"__cinf_Ljava_2Flang_2FString_3B",
+"__cinf_Ljava_2Flang_2Freflect_2FProxy_3B",
+"__cinf_Ljava_2Flang_2Freflect_2FParameter_3B",
+"__cinf_Ljava_2Flang_2FError_3B",
+"__cinf_Ljava_2Flang_2FNoClassDefFoundError_3B",
+"__cinf_Ljava_2Flang_2FExceptionInInitializerError_3B",
+"__cinf_Ljava_2Flang_2FRuntimeException_3B",
+"__cinf_Ljava_2Flang_2Freflect_2FUndeclaredThrowableException_3B",
+"__cinf_Ljava_2Flang_2FArrayStoreException_3B",
+"__cinf_Ljava_2Flang_2FArrayIndexOutOfBoundsException_3B",
+"__cinf_Ljava_2Flang_2FThrowable_3B",
+"__cinf_Ljava_2Flang_2FNullPointerException_3B",
+"__cinf_Ljava_2Flang_2FArithmeticException_3B",
+"__cinf_Ljava_2Flang_2FInterruptedException_3B",
+"__cinf_Ljava_2Flang_2FClassCastException_3B",
+"__cinf_Ljava_2Flang_2FUnsatisfiedLinkError_3B",
+"__cinf_Ljava_2Flang_2FStringIndexOutOfBoundsException_3B",
+"__cinf_Ljava_2Flang_2FNullPointerException_3B",
+"__cinf_Ljava_2Flang_2FArithmeticException_3B",
+"__cinf_Ljava_2Flang_2FInterruptedException_3B",
+"__cinf_Ljava_2Futil_2FHashMap_24Node_3B",
+"__cinf_Ljava_2Futil_2FFormatter_24FormatString_3B",
+"__cinf_Ljava_2Flang_2FCharSequence_3B",
+"__cinf_Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B",
+"__cinf_Ljava_2Futil_2FHashtable_24HashtableEntry_3B",
+"__cinf_Ljava_2Futil_2FHashtable_24Entry_3B",
+"__cinf_Ljava_2Flang_2FSecurityException_3B"
diff --git a/src/mapleall/maple_util/include/muid.h b/src/mapleall/maple_util/include/muid.h
new file mode 100644
index 0000000000000000000000000000000000000000..8fa6889594e1ddb83c6ce2041648980d0bbf8ad9
--- /dev/null
+++ b/src/mapleall/maple_util/include/muid.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MUID_H
+#define MUID_H
+
+// This is shared between maple compiler and runtime.
+#include <cstdint>
+#include <string>
+#include <sstream>
+#include <iomanip>
+
+#ifdef USE_32BIT_REF
+#define USE_64BIT_MUID
+#endif // USE_32BIT_REF
+
+constexpr unsigned int kSystemNamespace = 0xc0;
+constexpr unsigned int kApkNamespace = 0x80;
+constexpr unsigned int kBitMask = 0x3f;
+constexpr unsigned int kGroupSize = 64;
+constexpr unsigned int kShiftAmount = 32;
+constexpr unsigned int kBlockLength = 16;
+constexpr unsigned int kByteLength = 8;
+constexpr unsigned int kNumLowAndHigh = 2;
+
+#ifdef USE_64BIT_MUID
+constexpr unsigned int kMuidLength = 8;
+#else
+constexpr unsigned int kMuidLength = 16;
+#endif // USE_64BIT_MUID
+
+constexpr unsigned int kDigestShortHashLength = 8;
+constexpr unsigned int kDigestHashLength = 16;
+union DigestHash {
+  uint8_t bytes[kDigestHashLength];
+  struct {
+    uint64_t first;
+    uint64_t second;
+  } data;
+};
+
+// muid-related files are shared between maple compiler and runtime, thus not in
+// namespace maplert
+struct MuidContext {
+  unsigned int a;
+  unsigned int b;
+  unsigned int c;
+  unsigned int d;
+  unsigned int count[kNumLowAndHigh];
+  unsigned int block[kBlockLength];
+  unsigned char buffer[kGroupSize];
+};
+
+class MUID {
+ public:
+  union {
+#ifdef USE_64BIT_MUID
+    uint32_t words[kNumLowAndHigh] = { 0 };
+    uint8_t bytes[kMuidLength];
+    uint64_t raw;
+#else
+    uint64_t words[kNumLowAndHigh] = { 0 };
+    uint8_t bytes[kMuidLength];
+#endif // USE_64BIT_MUID
+  } data;
+
+  inline bool IsSystemNameSpace() const {
+    return (data.bytes[kMuidLength - 1] & ~kBitMask) == kSystemNamespace;
+  }
+  inline bool IsApkNameSpace() const {
+    return (data.bytes[kMuidLength - 1] & ~kBitMask) == kApkNamespace;
+  }
+  inline void SetSystemNameSpace() {
+    data.bytes[kMuidLength - 1] &= kBitMask;
+    data.bytes[kMuidLength - 1] |= kSystemNamespace;
+  }
+  inline void SetApkNameSpace() {
+    data.bytes[kMuidLength - 1] &= kBitMask;
+    data.bytes[kMuidLength - 1] |= kApkNamespace;
+  }
+  bool operator<(const MUID &muid) const {
+    return (data.words[1] < muid.data.words[1] ||
+            (data.words[1] == muid.data.words[1] && data.words[0] < muid.data.words[0]));
+  }
+  bool operator>(const MUID &muid) const {
+    return (data.words[1] > muid.data.words[1] ||
+            (data.words[1] == muid.data.words[1] && data.words[0] > muid.data.words[0]));
+  }
+  bool operator==(const MUID &muid) const {
+    return data.words[1] == muid.data.words[1] && data.words[0] == muid.data.words[0];
+  }
+  bool operator!=(const MUID &muid) const {
+    return data.words[1] != muid.data.words[1] || data.words[0] != muid.data.words[0];
+  }
+  std::string ToStr() const {
+    std::stringstream sbuf;
+#ifdef USE_64BIT_MUID
+    // 8 spaces to 64 bit
+    sbuf << std::setfill('0') << std::setw(8) << std::hex << data.words[1] << std::setfill('0') << std::setw(8) <<
+        std::hex << data.words[0];
+#else
+    // 16 spaces to 32 bit
+    sbuf << std::setfill('0') << std::setw(16) << std::hex << data.words[1] << std::setfill('0') << std::setw(16) <<
+        std::hex << data.words[0];
+#endif // USE_64BIT_MUID
+    return sbuf.str();
+  }
+};
+
+void MuidInit(MuidContext &status);
+void MuidDecode(MuidContext &status, const unsigned char &data, uint64_t size);
+
+template<typename T>
+void FullEncode(T &result, MuidContext &status);
+void MuidEncode(unsigned char (&result)[kDigestShortHashLength], MuidContext &status);
+void MuidEncode(unsigned char (&result)[kDigestHashLength], MuidContext &status, bool use64Bit = false);
+
+void GetMUIDHash(const unsigned char &data, size_t size, MUID &muid);
+DigestHash GetDigestHash(const unsigned char &bytes, uint32_t len);
+MUID GetMUID(const std::string &symbolName, bool forSystem = true);
+#endif
diff --git a/src/mapleall/maple_util/include/namemangler.h b/src/mapleall/maple_util/include/namemangler.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdc0f96022261b2b1ff5437e607f7a7192b93187
--- /dev/null
+++ b/src/mapleall/maple_util/include/namemangler.h
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef NAMEMANGLER_H
+#define NAMEMANGLER_H
+#include <string>
+#include <vector>
+
+// This is a general name mangler which is shared between maple compiler and runtime.
+// maple-compiler-specific data structure may NOT be used here.
+namespace namemangler {
+#define TO_STR(s)  TO_STR2(s)
+#define TO_STR2(s) #s
+
+
+#define VTAB_PREFIX               __vtb_
+#define ITAB_PREFIX               __itb_
+#define VTAB_AND_ITAB_PREFIX      __vtb_and_itb_
+#define ITAB_CONFLICT_PREFIX      __itbC_
+#define CLASSINFO_PREFIX          __cinf_
+#define CLASSINFO_RO_PREFIX       __classinforo__
+#define SUPERCLASSINFO_PREFIX     __superclasses__
+#define PRIMITIVECLASSINFO_PREFIX __pinf_
+#define CLASS_INIT_BRIDGE_PREFIX  __ClassInitBridge__
+#define GCTIB_PREFIX              MCC_GCTIB__
+#define REF_PREFIX                REF_
+#define JARRAY_PREFIX             A
+
+#define VTAB_PREFIX_STR               TO_STR(VTAB_PREFIX)
+#define ITAB_PREFIX_STR               TO_STR(ITAB_PREFIX)
+#define VTAB_AND_ITAB_PREFIX_STR      TO_STR(VTAB_AND_ITAB_PREFIX)
+#define ITAB_CONFLICT_PREFIX_STR      TO_STR(ITAB_CONFLICT_PREFIX)
+#define CLASSINFO_PREFIX_STR          TO_STR(CLASSINFO_PREFIX)
+#define CLASSINFO_RO_PREFIX_STR       TO_STR(CLASSINFO_RO_PREFIX)
+#define SUPERCLASSINFO_PREFIX_STR     TO_STR(SUPERCLASSINFO_PREFIX)
+#define PRIMITIVECLASSINFO_PREFIX_STR TO_STR(PRIMITIVECLASSINFO_PREFIX)
+#define CLASS_INIT_BRIDGE_PREFIX_STR  TO_STR(CLASS_INIT_BRIDGE_PREFIX)
+#define GCTIB_PREFIX_STR              TO_STR(GCTIB_PREFIX)
+#define REF_PREFIX_STR                TO_STR(REF_PREFIX)
+#define JARRAY_PREFIX_STR             TO_STR(JARRAY_PREFIX)
+
+// Names of all compiler-generated tables and accessed by runtime
+static constexpr const char kMuidPrefixStr[] = "__muid_";
+static constexpr const char kMuidRoPrefixStr[] = "__muid_ro";
+static constexpr const char kMuidFuncDefTabPrefixStr[] = "__muid_func_def_tab";
+static constexpr const char kMuidFuncDefOrigTabPrefixStr[] = "__muid_ro_func_def_orig_tab";
+static constexpr const char kMuidFuncInfTabPrefixStr[] = "__muid_ro_func_inf_tab";
+static constexpr const char kMuidFuncMuidIdxTabPrefixStr[] = "__muid_ro_func_muid_idx_tab";
+static constexpr const char kMuidDataDefTabPrefixStr[] = "__muid_data_def_tab";
+static constexpr const char kMuidDataDefOrigTabPrefixStr[] = "__muid_ro_data_def_orig_tab";
+static constexpr const char kMuidFuncUndefTabPrefixStr[] = "__muid_func_undef_tab";
+static constexpr const char kMuidDataUndefTabPrefixStr[] = "__muid_data_undef_tab";
+static constexpr const char kMuidFuncDefMuidTabPrefixStr[] = "__muid_ro_func_def_muid_tab";
+static constexpr const char kMuidDataDefMuidTabPrefixStr[] = "__muid_ro_data_def_muid_tab";
+static constexpr const char kMuidFuncUndefMuidTabPrefixStr[] = "__muid_ro_func_undef_muid_tab";
+static constexpr const char kMuidDataUndefMuidTabPrefixStr[] = "__muid_ro_data_undef_muid_tab";
+static constexpr const char kMuidVtabAndItabPrefixStr[] = "__muid_vtab_and_itab";
+static constexpr const char kMuidItabConflictPrefixStr[] = "__muid_itab_conflict";
+static constexpr const char kMuidColdVtabAndItabPrefixStr[] = "__muid_cold_vtab_and_itab";
+static constexpr const char kMuidColdItabConflictPrefixStr[] = "__muid_cold_itab_conflict";
+static constexpr const char kMuidVtabOffsetPrefixStr[] = "__muid_vtab_offset_tab";
+static constexpr const char kMuidFieldOffsetPrefixStr[] = "__muid_field_offset_tab";
+static constexpr const char kMuidVtabOffsetKeyPrefixStr[] = "__muid_vtable_offset_key_tab";
+static constexpr const char kMuidFieldOffsetKeyPrefixStr[] = "__muid_field_offset_key_tab";
+static constexpr const char kMuidValueOffsetPrefixStr[] = "__muid_offset_value_table";
+static constexpr const char kMuidLocalClassInfoStr[] = "__muid_local_classinfo_tab";
+static constexpr const char kMuidSuperclassPrefixStr[] = "__muid_superclass";
+static constexpr const char kMuidGlobalRootlistPrefixStr[] = "__muid_globalrootlist";
+static constexpr const char kMuidClassMetadataPrefixStr[] = "__muid_classmetadata";
+static constexpr const char kMuidClassMetadataBucketPrefixStr[] = "__muid_classmetadata_bucket";
+static constexpr const char kMuidJavatextPrefixStr[] = "java_text";
+static constexpr const char kMuidDataSectionStr[] = "__data_section";
+static constexpr const char kMuidRangeTabPrefixStr[] = "__muid_range_tab";
+static constexpr const char kMuidConststrPrefixStr[] = "__muid_conststr";
+static constexpr const char kVtabOffsetTabStr[] = "__vtable_offset_table";
+static constexpr const char kFieldOffsetTabKeyStr[] = "__field_offset_key_table";
+static constexpr const char kFieldOffsetTabStr[] = "__field_offset_table";
+static constexpr const char kVtableKeyOffsetTabStr[] = "__vtable_offset_key_table";
+static constexpr const char kVtableOffsetTabKeyStr[] = "__vtable_offset_key_table";
+static constexpr const char kFieldKeyOffsetTabStr[] = "__field_offset_table";
+static constexpr const char kOffsetTabStr[] = "__offset_value_table";
+static constexpr const char kInlineCacheTabStr[] = "__inline_cache_table";
+static constexpr const char kLocalClassInfoStr[] = "__local_classinfo_table";
+static constexpr const char kMethodsInfoPrefixStr[] = "__methods_info__";
+static constexpr const char kMethodsInfoCompactPrefixStr[] = "__methods_infocompact__";
+static constexpr const char kFieldsInfoPrefixStr[] = "__fields_info__";
+static constexpr const char kFieldsInfoCompactPrefixStr[] = "__fields_infocompact__";
+static constexpr const char kFieldOffsetDataPrefixStr[] = "__fieldOffsetData__";
+static constexpr const char kMethodAddrDataPrefixStr[] = "__methodAddrData__";
+static constexpr const char kMethodSignaturePrefixStr[] = "__methodSignature__";
+static constexpr const char kParameterTypesPrefixStr[] = "__parameterTypes__";
+static constexpr const char kRegJNITabPrefixStr[] = "__reg_jni_tab";
+static constexpr const char kRegJNIFuncTabPrefixStr[] = "__reg_jni_func_tab";
+static constexpr const char kReflectionStrtabPrefixStr[] = "__reflection_strtab";
+static constexpr const char kReflectionStartHotStrtabPrefixStr[] = "__reflection_start_hot_strtab";
+static constexpr const char kReflectionBothHotStrTabPrefixStr[] = "__reflection_both_hot_strtab";
+static constexpr const char kReflectionRunHotStrtabPrefixStr[] = "__reflection_run_hot_strtab";
+static constexpr const char kReflectionNoEmitStrtabPrefixStr[] = "__reflection_no_emit_strtab";
+static constexpr const char kMarkMuidFuncDefStr[] = "muid_func_def:";
+static constexpr const char kMarkMuidFuncUndefStr[] = "muid_func_undef:";
+static constexpr const char kGcRootList[] = "gcRootNewList";
+static constexpr const char kDecoupleOption[] = "__decouple_option";
+static constexpr const char kDecoupleStr[] = "__decouple";
+static constexpr const char kCompilerVersionNum[] = "__compilerVersionNum";
+static constexpr const char kCompilerVersionNumStr[] = "__compilerVersionNumTab";
+static constexpr const char kCompilerMfileStatus[]  = "__compiler_mfile_status";
+static constexpr const char kMapleGlobalVariable[]  = "maple_global_variable";
+static constexpr const char kMapleLiteralString[]  = "maple_literal_string";
+
+static constexpr const char kSourceMuid[] = "__sourceMuid";
+static constexpr const char kSourceMuidSectionStr[] = "__sourceMuidTab";
+static constexpr const char kDecoupleStaticKeyStr[] = "__staticDecoupleKeyOffset";
+static constexpr const char kDecoupleStaticValueStr[] = "__staticDecoupleValueOffset";
+static constexpr const char kMarkDecoupleStaticStr[] = "decouple_static:";
+static constexpr const char kClassInfoPrefix[] = "__cinf";
+static constexpr const char kBssSectionStr[] = "__bss_section";
+static constexpr const char kLinkerHashSoStr[] = "__linkerHashSo";
+
+static constexpr const char kStaticFieldNamePrefixStr[] = "__static_field_name";
+static constexpr const char kMplSuffix[] = ".mpl";
+static constexpr const char kClinvocation[] = ".clinvocation";
+static constexpr const char kPackageNameSplitterStr[] = "_2F";
+static constexpr const char kFileNameSplitterStr[] = "$$";
+static constexpr const char kNameSplitterStr[] = "_7C";  // 7C is the ascii code for |
+static constexpr const char kRightBracketStr[] = "_29";  // 29 is the ascii code for )
+static constexpr const char kClassNameSplitterStr[] = "_3B_7C";
+static constexpr const char kJavaLangClassStr[] = "Ljava_2Flang_2FClass_3B";
+static constexpr const char kJavaLangObjectStr[] = "Ljava_2Flang_2FObject_3B";
+static constexpr const char kJavaLangClassloader[] = "Ljava_2Flang_2FClassLoader_3B";
+static constexpr const char kJavaLangObjectStrJVersion[] = "Ljava/lang/Object;";
+static constexpr const char kJavaLangStringStr[] = "Ljava_2Flang_2FString_3B";
+static constexpr const char kJavaLangExceptionStr[] = "Ljava_2Flang_2FException_3B";
+static constexpr const char kThrowClassStr[] = "Ljava_2Flang_2FThrowable_3B";
+static constexpr const char kReflectionClassesPrefixStr[] = "Ljava_2Flang_2Freflect_2F";
+static constexpr const char kReflectionClassMethodStr[] = "Ljava_2Flang_2Freflect_2FMethod_241_3B";
+static constexpr const char kClassMetadataTypeName[] = "__class_meta__";
+static constexpr const char kPtrPrefixStr[] = "_PTR";
+static constexpr const char kClassINfoPtrPrefixStr[] = "_PTR__cinf_";
+static constexpr const char kArrayClassInfoPrefixStr[] = "__cinf_A";
+static constexpr const char kShadowClassName[] = "shadow_24__klass__";
+static constexpr const char kClinitSuffix[] = "_7C_3Cclinit_3E_7C_28_29V";
+static constexpr const char kCinitStr[] = "_7C_3Cinit_3E_7C_28";
+static constexpr const char kClinitSubStr[] = "7C_3Cinit_3E_7C";
+
+static constexpr const char kPreNativeFunc[] = "MCC_PreNativeCall";
+static constexpr const char kPostNativeFunc[] = "MCC_PostNativeCall";
+static constexpr const char kDecodeRefFunc[] = "MCC_DecodeReference";
+static constexpr const char kFindNativeFunc[] = "MCC_FindNativeMethodPtr";
+static constexpr const char kFindNativeFuncNoeh[] = "MCC_FindNativeMethodPtrWithoutException";
+static constexpr const char kDummyNativeFunc[] = "MCC_DummyNativeMethodPtr";
+static constexpr const char kCheckThrowPendingExceptionFunc[] = "MCC_CheckThrowPendingException";
+static constexpr const char kCallFastNative[] = "MCC_CallFastNative";
+static constexpr const char kCallFastNativeExt[] = "MCC_CallFastNativeExt";
+static constexpr const char kCallSlowNativeExt[] = "MCC_CallSlowNativeExt";
+static constexpr const char kSetReliableUnwindContextFunc[] = "MCC_SetReliableUnwindContext";
+
+static constexpr const char kArrayClassCacheTable[] = "__arrayClassCacheTable";
+static constexpr const char kArrayClassCacheNameTable[] = "__muid_ro_arrayClassCacheNameTable";
+static constexpr const char kFunctionLayoutStr[] = "__func_layout__";
+
+static constexpr const char kFunctionProfileTabPrefixStr[] = "__muid_profile_func_tab";
+
+static constexpr const char kBBProfileTabPrefixStr[] = "__muid_prof_counter_tab";
+static constexpr const char kFuncIRProfInfTabPrefixStr[] = "__muid_prof_ir_desc_tab";
+
+static constexpr const char kprefixProfModDesc[] = "__mpl_prof_moddesc_";
+static constexpr const char kprefixProfCtrTbl[] = "__mpl_prof_ctrtbl_";
+static constexpr const char kprefixProfFuncDesc[] = "__mpl_prof_funcdesc_";
+static constexpr const char kprefixProfFuncDescTbl[] = "__mpl_func_prof_desc_tbl_";
+static constexpr const char kprefixProfInit[] = "__mpl_prof_init_";
+static constexpr const char kprefixProfExit[] = "__mpl_prof_exit_";
+static constexpr const char kGCCProfInit[] = "__gcov_init";
+static constexpr const char kGCCProfExit[] = "__gcov_exit";
+static constexpr const char kMplMergeFuncAdd[] = "__gcov_merge_add";
+static constexpr const char kProfFileNameExt[] = ".gcda";
+
+static constexpr const char kBindingProtectedRegionStr[] = "__BindingProtectRegion__";
+
+static constexpr const char kClassNamePrefixStr[] = "L";
+static constexpr const char kClassMethodSplitterStr[] = "_3B";
+static constexpr const char kFuncGetCurrentCl[] = "MCC_GetCurrentClassLoader";
+static constexpr const char kMplProfFileNameExt[] = ".mprofdata";
+// Serve as a global flag to indicate whether frequent strings have been compressed
+extern bool doCompression;
+
+// Return the input string if the compression is not on; otherwise, return its compressed version
+std::string GetInternalNameLiteral(std::string name);
+std::string GetOriginalNameLiteral(std::string name);
+
+std::string EncodeName(const std::string &name);
+std::string DecodeName(const std::string &name);
+void DecodeMapleNameToJavaDescriptor(const std::string &nameIn, std::string &nameOut);
+
+std::string NativeJavaName(const std::string &name, bool overLoaded = true);
+
+__attribute__((visibility("default"))) unsigned UTF16ToUTF8(std::string &str, const std::u16string &str16,
+                                                            unsigned short num = 0, bool isBigEndian = false);
+__attribute__((visibility("default"))) unsigned UTF8ToUTF16(std::u16string &str16, const std::string &str,
+                                                            unsigned short num = 0, bool isBigEndian = false);
+void GetUnsignedLeb128Encode(std::vector<uint8_t> &dest, uint32_t value);
+uint32_t GetUnsignedLeb128Decode(const uint8_t **data);
+size_t GetUleb128Size(uint64_t val);
+size_t GetSleb128Size(int32_t val);
+bool NeedConvertUTF16(const std::string &str8);
+uint32_t EncodeSLEB128(uint64_t value, std::ofstream &out);
+uint32_t EncodeULEB128(uint64_t value, std::ofstream &out);
+uint64_t DecodeULEB128(const uint8_t *p, unsigned *n = nullptr, const uint8_t *end = nullptr);
+int64_t DecodeSLEB128(const uint8_t *p, unsigned *n = nullptr, const uint8_t *end = nullptr);
+} // namespace namemangler
+
+#endif
diff --git a/src/mapleall/maple_util/include/profile.h b/src/mapleall/maple_util/include/profile.h
new file mode 100644
index 0000000000000000000000000000000000000000..c41f93845a2efce58b5e5bf802f0d104746b3719
--- /dev/null
+++ b/src/mapleall/maple_util/include/profile.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_PROFILE_H
+#define MAPLE_UTIL_INCLUDE_PROFILE_H
+#include <string>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+#include "profile_type.h"
+#include "mpl_logging.h"
+#include "types_def.h"
+#include "option.h"
+
+namespace maple {
+struct IRProfileDesc {
+  uint32 counterStart = 0;
+  uint32 counterEnd = 0;
+  uint64 funcHash = 0;
+  IRProfileDesc() = default;
+  IRProfileDesc(uint64 hash, uint32 start, uint32 end) : counterStart(start), counterEnd(end), funcHash(hash) {}
+  ~IRProfileDesc() = default;
+};
+
+class Profile {
+ public:
+  struct FuncItem {
+    uint32 callTimes;
+    uint8 type;
+  };
+  // function ir profile info
+  struct BBInfo {
+    uint64 funcHash = 0;
+    uint32 totalCounter = 0;
+    std::vector<uint32> counter;
+    BBInfo() = default;
+    BBInfo(uint64 hash, uint32 num, std::vector<uint32> &&counter)
+        : funcHash(hash), totalCounter(num), counter(counter) {}
+    BBInfo(uint64 hash, uint32 num, const std::initializer_list<uint32> &iList)
+        : funcHash(hash), totalCounter(num), counter(iList) {}
+    ~BBInfo() = default;
+  };
+
+  static const uint8 stringEnd;
+  void InitTestData();
+  bool CheckFuncHot(const std::string &className) const;
+  bool CheckMethodHot(const std::string &className) const;
+  bool CheckMethodSigHot(const std::string &methodSigStr) const;
+  bool CheckFieldHot(const std::string &className) const;
+  bool CheckClassHot(const std::string &className) const;
+  bool CheckLiteralHot(const std::string &literal) const;
+  bool CheckReflectionStrHot(const std::string &str, uint8 &layoutType) const;
+  void InitPreHot();
+  // default get all kind profile
+  bool DeCompress(const std::string &fileName, const std::string &dexName, ProfileType type = kAll);
+  const std::unordered_map<std::string, FuncItem> &GetFunctionProf() const;
+  bool GetFunctionBBProf(const std::string &funcName, BBInfo &result);
+  size_t GetLiteralProfileSize() const;
+  bool CheckProfValid() const;
+  bool CheckDexValid(uint32 idx) const;
+  void SetProfileMode();
+  void Dump() const;
+  void DumpFuncIRProfUseInfo() const;
+  void SetFuncStatus(const std::string &funcName, bool succ);
+  Profile();
+  ~Profile() = default;
+
+  bool IsValid() const {
+    return valid;
+  }
+
+ private:
+  bool valid = false;
+  bool profileMode = false;
+  bool isCoreSo = false;
+  bool isAppProfile = false;
+  static bool debug;
+  static uint32 hotFuncCountThreshold;
+  static bool initialized;
+  std::vector<std::string> strMap;
+  std::string dexName;
+  std::string appPackageName;
+  std::unordered_set<std::string> classMeta;
+  std::unordered_set<std::string> methodMeta;
+  std::unordered_set<std::string> fieldMeta;
+  std::unordered_set<std::string> methodSigMeta;
+  std::unordered_set<std::string> literal;
+  std::unordered_map<std::string, uint8> reflectionStrData;
+  std::unordered_map<std::string, Profile::FuncItem> funcProfData;
+  std::unordered_set<std::string> &GetMeta(uint8 type);
+  std::unordered_map<std::string, BBInfo> funcBBProfData;
+  std::unordered_map<std::string, bool> funcBBProfUseInfo;
+  std::unordered_map<std::string, IRProfileDesc> funcDesc;
+  std::vector<uint32> counterTab;
+  static const std::string preClassHot[];
+  static const std::string preMethodHot[];
+  bool CheckProfileHeader(const Header &header) const;
+  std::string GetProfileNameByType(uint8 type) const;
+  std::string GetFunctionName(uint32 classIdx, uint32 methodIdx, uint32 sigIdx) const;
+  std::string GetMethodSigStr(uint32 methodIdx, uint32 sigIdx) const;
+  void ParseMethodSignature(const char *data, int fileNum, std::unordered_set<std::string> &metaData) const;
+  void ParseMeta(const char *data, int fileNum, std::unordered_set<std::string> &metaData) const;
+  void ParseReflectionStr(const char *data, int fileNum);
+  void ParseFunc(const char *data, int fileNum);
+  void ParseLiteral(const char *data, const char *end);
+  void ParseIRFuncDesc(const char *data, int fileNum);
+  void ParseCounterTab(const char *data, int fileNum);
+};
+
+class LiteProfile {
+ public:
+  struct BBInfo {
+    uint64 funcHash = 0;
+    std::vector<uint32> counter;
+    BBInfo() = default;
+    BBInfo(uint64 hash, std::vector<uint32> &&counter)
+        : funcHash(hash), counter(counter) {}
+    BBInfo(uint64 hash, const std::initializer_list<uint32> &iList)
+        : funcHash(hash), counter(iList) {}
+    ~BBInfo() = default;
+  };
+  // default get all kind profile
+  bool HandleLitePGOFile(const std::string &fileName, const std::string &moduleName);
+  bool HandleInstrumentationWhiteList(const std::string &fileName);
+  BBInfo *GetFuncBBProf(const std::string &funcName);
+  static bool IsInWhiteList(const std::string &funcName) {
+    return whiteList.empty() ? true : whiteList.count(funcName);
+  }
+  static uint32 GetBBNoThreshold() {
+    return bbNoThreshold;
+  }
+
+ private:
+  static std::set<std::string> whiteList;
+  static uint32 bbNoThreshold;
+  static bool loaded;
+  std::unordered_map<std::string, BBInfo> funcBBProfData;
+  void ParseFuncBBData(const std::string &line, std::string &curFile, const std::string &moduleHash);
+};
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_PROFILE_H
diff --git a/src/mapleall/maple_util/include/profile_type.h b/src/mapleall/maple_util/include/profile_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..7311cab13e104d437909cb1a87b66bcbb283955e
--- /dev/null
+++ b/src/mapleall/maple_util/include/profile_type.h
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef PROFILE_TYPE_H
+#define PROFILE_TYPE_H
+
+static constexpr uint8_t kProfileMagic[] = { 'm', 'a', 'p', 'l', 'e', '.', 'p', 'r', 'o', 'f', 'i', 'l', 'e', '\0' };
+static constexpr uint8_t kVer[] = { 0, 0, 1 };
+
+enum ProfileFileType : uint8_t {
+  kSystemServer = 0x00,
+  kApp = 0x01
+};
+
+enum ProfileType : uint8_t {
+  kFunction = 0x00,
+  kClassMeta = 0x01,
+  kFieldMeta = 0x02,
+  kMethodMeta = 0x03,
+  kReflectionStr = 0x04,
+  kLiteral = 0x05,
+  kBBInfo = 0x06,
+  kIRCounter = 0x07,
+  kAll = 0x08,
+  kMethodSig = 0x09,
+  kFileDesc = 0xFF
+};
+
+enum FuncIRItemIndex : uint8_t {
+  kFuncIRItemNameIndex,
+  kCounterStartIndex,
+  kCounterEndIndex,
+  kHashIndex
+};
+
+enum FuncItemIndex : uint8_t {
+  kFuncItemNameIndex,
+  kFuncTypeIndex,
+  kFuncCallTimesIndex
+};
+
+enum FuncNameIndex : uint8_t {
+  kClassNameIndex,
+  kFuncNameIndex,
+  kSignatureNameIndex,
+};
+
+struct ProfileDataInfo {
+  uint32_t profileDataOff;
+  uint8_t profileType;
+  uint8_t mapleFileNum;
+  uint16_t pad = 0;
+  ProfileDataInfo() = default;
+  ProfileDataInfo(uint32_t profileDataOff, uint8_t profileType, uint8_t mapleFileNum)
+      : profileDataOff(profileDataOff), profileType(profileType), mapleFileNum(mapleFileNum) {}
+};
+
+struct FunctionItem {
+  uint32_t classIdx;
+  uint32_t methodIdx;
+  uint32_t sigIdx;
+  uint32_t callTimes;
+  uint8_t type;
+  FunctionItem(uint32_t classIdx, uint32_t methodIdx, uint32_t sigIdx, uint32_t callTimes, uint8_t type)
+      : classIdx(classIdx), methodIdx(methodIdx), sigIdx(sigIdx), callTimes(callTimes), type(type) {}
+};
+
+struct FunctionIRProfItem {
+  uint64_t hash;
+  uint32_t classIdx;
+  uint32_t methodIdx;
+  uint32_t sigIdx;
+  uint32_t counterStart;
+  uint32_t counterEnd;
+  FunctionIRProfItem(uint64_t hash, uint32_t classIdx, uint32_t methodIdx, uint32_t sigIdx, uint32_t start,
+                     uint32_t end)
+      : hash(hash), classIdx(classIdx), methodIdx(methodIdx), sigIdx(sigIdx), counterStart(start), counterEnd(end) {}
+};
+
+struct FuncCounterItem {
+  uint32_t callTimes;
+  FuncCounterItem(uint32_t callTimes) : callTimes(callTimes) {}
+};
+
+struct MetaItem {
+  uint32_t idx;
+  MetaItem(uint32_t idx) : idx(idx) {}
+};
+
+struct MethodSignatureItem {
+  uint32_t methodIdx;
+  uint32_t sigIdx;
+  MethodSignatureItem(uint32_t methodIdx, uint32_t sigIdx) : methodIdx(methodIdx), sigIdx(sigIdx) {}
+};
+
+struct ReflectionStrItem {
+  uint8_t type;
+  uint32_t idx;
+  ReflectionStrItem(uint32_t idx, uint8_t type) : type(type), idx(idx) {}
+};
+
+struct MapleFileProf {
+  uint32_t idx;
+  uint32_t num;
+  uint32_t size;
+  MapleFileProf(uint32_t idx, uint32_t num, uint32_t size) : idx(idx), num(num), size(size) {}
+};
+
+constexpr int kMagicNum = 14;
+constexpr int kVerNum = 3;
+constexpr int kCheckSumNum = 4;
+struct Header {
+  uint8_t magic[kMagicNum] = {};
+  uint8_t ver[kVerNum] = {};
+  uint8_t checkSum[kCheckSumNum] = {};
+  uint8_t profileNum = 0;
+  uint8_t profileFileType = 0;
+  uint8_t pad = 0;
+  uint32_t headerSize = 0;
+  uint32_t stringCount = 0;
+  uint32_t stringTabOff = 0;
+  ProfileDataInfo data[1] = {}; // profile data info detemined by runtime
+};
+
+#endif
diff --git a/src/mapleall/maple_util/include/ptr.h b/src/mapleall/maple_util/include/ptr.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e1df7353b61f64c0f22b3cdd720f6e3a5109da1
--- /dev/null
+++ b/src/mapleall/maple_util/include/ptr.h
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_PTR_H
+#define MAPLE_UTIL_PTR_H
+#include <functional>
+
+namespace maple {
+namespace utils {
+template<typename T>
+using PtrCheckerType = void(*)(const T*);
+
+template<typename T>
+inline constexpr void CheckNothing(const T*) {}
+
+template<typename T, PtrCheckerType<T> Check = CheckNothing<T>>
+class Ptr {
+ public:
+  using Pointer = T*;
+  using ElementType = T;
+
+  constexpr Ptr() noexcept
+      : pointer(nullptr) {
+    Check(nullptr);
+  }
+
+  constexpr explicit Ptr(std::nullptr_t) noexcept
+      : pointer(nullptr) {
+    Check(nullptr);
+  }
+
+  explicit Ptr(Pointer ptr)
+      : pointer(ptr) {
+    Check(ptr);
+  }
+
+  Ptr(Pointer ref, PtrCheckerType<T> checker)
+      : pointer(ref) {
+    checker(pointer);
+  }
+
+  explicit Ptr(T &ref)
+      : pointer(&ref) {
+    Check(pointer);
+  }
+
+  Ptr(T &ref, PtrCheckerType<T> checker)
+      : pointer(&ref) {
+    checker(pointer);
+  }
+
+  explicit Ptr(T &&ref) = delete;
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  explicit Ptr(U *ptr)
+      : pointer(ptr) {
+    Check(pointer);
+  }
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  explicit Ptr(U &ref)
+      : pointer(&ref) {
+    Check(pointer);
+  }
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  Ptr(U &ref, PtrCheckerType<T> checker)
+      : pointer(&ref) {
+    checker(pointer);
+  }
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  explicit Ptr(U &&ref) = delete;
+
+  explicit Ptr(const Ptr &other)
+      : pointer(other.get()) {}
+
+  explicit Ptr(Ptr &&other) noexcept
+      : pointer(other.get()) {}
+
+  template<typename U, PtrCheckerType<U> CheckU, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  explicit Ptr(const Ptr<U, CheckU> &other)
+      : pointer(other.get()) {
+    Check(pointer);
+  }
+
+  template<typename U, PtrCheckerType<U> CheckU, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  Ptr(const Ptr<U, CheckU> &other, PtrCheckerType<T> checker)
+      : pointer(other.get()) {
+    checker(pointer);
+  }
+
+  template<typename U, PtrCheckerType<U> CheckU, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  explicit Ptr(Ptr<U, CheckU> &&other)
+      : pointer(other.get()) {
+    Check(pointer);
+  }
+
+  template<typename U, PtrCheckerType<U> CheckU, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  Ptr(Ptr<U, CheckU> &&other, PtrCheckerType<T> checker)
+      : pointer(other.get()) {
+    checker(pointer);
+  }
+
+  ~Ptr() = default;
+
+  Ptr &operator=(Pointer ptr) noexcept {
+    Check(ptr);
+    pointer = ptr;
+    return *this;
+  }
+
+  Ptr &operator=(std::nullptr_t) noexcept {
+    Check(nullptr);
+    reset();
+    return *this;
+  }
+
+  Ptr &operator=(const Ptr &ptr) noexcept {
+    if (&ptr != this) {
+      pointer = ptr.pointer;
+    }
+    return *this;
+  }
+
+  Ptr &operator=(Ptr &&ptr) noexcept {
+    if (&ptr != this) {
+      pointer = std::move(ptr.pointer);
+    }
+    return *this;
+  }
+
+  template<typename U, PtrCheckerType<U> CheckU, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  Ptr &operator=(const Ptr<U, CheckU> &ptr) noexcept {
+    if (this->get() != ptr.get()) {
+      Check(ptr.get());
+      pointer = ptr.get();
+    }
+    return *this;
+  }
+
+  template<typename U, PtrCheckerType<U> CheckU, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  Ptr &operator=(Ptr<U, CheckU> &&ptr) noexcept {
+    if (this->get() != ptr.get()) {
+      Check(ptr.get());
+      pointer = std::move(ptr.get());
+    }
+    return *this;
+  }
+
+  Pointer release() noexcept = delete;
+
+  void reset(Pointer ptr = Pointer()) noexcept {
+    Check(ptr);
+    pointer = ptr;
+  }
+
+  void swap(Ptr &other) noexcept {
+    std::swap(pointer, other.pointer);
+  }
+
+  T *get() const noexcept {
+    return pointer;
+  }
+
+  explicit operator bool() const noexcept {
+    return get() != nullptr;
+  }
+
+  T &operator*() const {
+    return *get();
+  }
+
+  T *operator->() const noexcept {
+    return get();
+  }
+
+  T &operator[](size_t i) const = delete;
+
+  Ptr &operator++() = delete;
+
+  const Ptr operator++(int) = delete;
+
+  Ptr &operator--() = delete;
+
+  const Ptr operator--(int) = delete;
+
+  Ptr &operator+=(std::ptrdiff_t) = delete;
+
+  Ptr &operator-=(std::ptrdiff_t) = delete;
+
+ private:
+  T *pointer;
+};
+
+template<typename T, PtrCheckerType<T> CheckT, typename U, PtrCheckerType<U> CheckU>
+inline bool operator==(const Ptr<T, CheckT> &lhs, const Ptr<U, CheckU> &rhs) {
+  return lhs.get() == rhs.get();
+}
+
+template<typename T, PtrCheckerType<T> CheckT, typename U, PtrCheckerType<U> CheckU>
+inline bool operator!=(const Ptr<T, CheckT> &lhs, const Ptr<U, CheckU> &rhs) {
+  return !(lhs == rhs);
+}
+
+template<typename T, PtrCheckerType<T> CheckT, typename U, PtrCheckerType<U> CheckU>
+inline bool operator<(const Ptr<T, CheckT> &lhs, const Ptr<U, CheckU> &rhs) {
+  return lhs.get() < rhs.get();
+}
+
+template<typename T, PtrCheckerType<T> CheckT, typename U, PtrCheckerType<U> CheckU>
+inline bool operator<=(const Ptr<T, CheckT> &lhs, const Ptr<U, CheckU> &rhs) {
+  return lhs.get() <= rhs.get();
+}
+
+template<typename T, PtrCheckerType<T> CheckT, typename U, PtrCheckerType<U> CheckU>
+inline bool operator>(const Ptr<T, CheckT> &lhs, const Ptr<U, CheckU> &rhs) {
+  return !(lhs <= rhs);
+}
+
+template<typename T, PtrCheckerType<T> CheckT, typename U, PtrCheckerType<U> CheckU>
+inline bool operator>=(const Ptr<T, CheckT> &lhs, const Ptr<U, CheckU> &rhs) {
+  return !(lhs < rhs);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator==(const Ptr<T, CheckT> &lhs, std::nullptr_t) {
+  return !static_cast<bool>(lhs);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator==(std::nullptr_t, const Ptr<T, CheckT> &rhs) {
+  return !static_cast<bool>(rhs);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator!=(const Ptr<T, CheckT> &lhs, std::nullptr_t) {
+  return static_cast<bool>(lhs);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator!=(std::nullptr_t, const Ptr<T, CheckT> &rhs) {
+  return static_cast<bool>(rhs);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator<(const Ptr<T, CheckT> &lhs, std::nullptr_t) {
+  return std::less<typename Ptr<T, CheckT>::Pointer>()(lhs.get(), nullptr);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator<(std::nullptr_t, const Ptr<T, CheckT> &rhs) {
+  return std::less<typename Ptr<T, CheckT>::Pointer>()(nullptr, rhs.get());
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator<=(const Ptr<T, CheckT> &lhs, std::nullptr_t) {
+  return !(lhs > nullptr);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator<=(std::nullptr_t, const Ptr<T, CheckT> &rhs) {
+  return !(rhs < nullptr);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator>(const Ptr<T, CheckT> &lhs, std::nullptr_t) {
+  return !(lhs <= nullptr);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator>(std::nullptr_t, const Ptr<T, CheckT> &rhs) {
+  return !(rhs >= nullptr);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator>=(const Ptr<T, CheckT> &lhs, std::nullptr_t) {
+  return !(lhs < nullptr);
+}
+
+template<typename T, PtrCheckerType<T> CheckT>
+inline bool operator>=(std::nullptr_t, const Ptr<T, CheckT> &rhs) {
+  return !(rhs > nullptr);
+}
+}
+}
+#endif // DIY_CPLUSPLUS_SAFE_PTR_H
\ No newline at end of file
diff --git a/src/mapleall/maple_util/include/ptr_list_ref.h b/src/mapleall/maple_util/include/ptr_list_ref.h
new file mode 100644
index 0000000000000000000000000000000000000000..05721d9b4ea92948b04a3cde00e14c7286f856c6
--- /dev/null
+++ b/src/mapleall/maple_util/include/ptr_list_ref.h
@@ -0,0 +1,465 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_PTR_LIST_REF_H
+#define MAPLE_UTIL_INCLUDE_PTR_LIST_REF_H
+#include <iterator>
+
+#include "mpl_logging.h"
+
+namespace maple {
+template <typename T>
+class PtrListNodeBase {
+ public:
+  PtrListNodeBase() = default;
+  ~PtrListNodeBase() = default;
+  T *GetPrev() const {
+    return prev;
+  }
+
+  T *GetNext() const {
+    return next;
+  }
+
+  void SetPrev(T *ptr) {
+    prev = ptr;
+  }
+
+  void SetNext(T *ptr) {
+    next = ptr;
+  }
+
+ private:
+  T *prev = nullptr;
+  T *next = nullptr;
+};
+
+// wrap iterator to run it backwards
+template <typename T>
+class ReversePtrListRefIterator {
+ public:
+  using iterator_category = typename std::iterator_traits<T>::iterator_category;
+  using value_type = typename std::iterator_traits<T>::value_type;
+  using difference_type = typename std::iterator_traits<T>::difference_type;
+  using pointer = typename std::iterator_traits<T>::pointer;
+  using reference = typename std::iterator_traits<T>::reference;
+
+  using iterator_type = T;
+
+  ReversePtrListRefIterator() : current() {}
+
+  explicit ReversePtrListRefIterator(T right) : current(right) {}
+
+  template <class Other>
+  ReversePtrListRefIterator(const ReversePtrListRefIterator<Other> &right) : current(right.base()) {}
+
+  template <class Other>
+  ReversePtrListRefIterator &operator=(const ReversePtrListRefIterator<Other> &right) {
+    current = right.base();
+    return (*this);
+  }
+
+  ~ReversePtrListRefIterator() = default;
+
+  T base() const {
+    return current;
+  }
+
+  reference operator*() const {
+    return *current;
+  }
+
+  pointer operator->() const {
+    return &(operator*());
+  }
+
+  ReversePtrListRefIterator &operator++() {
+    --current;
+    return (*this);
+  }
+
+  ReversePtrListRefIterator operator++(int) {
+    ReversePtrListRefIterator tmp = *this;
+    --current;
+    return (tmp);
+  }
+
+  ReversePtrListRefIterator &operator--() {
+    ++current;
+    return (*this);
+  }
+
+  ReversePtrListRefIterator operator--(int) {
+    ReversePtrListRefIterator tmp = *this;
+    ++current;
+    return (tmp);
+  }
+
+  bool operator==(const ReversePtrListRefIterator &Iterator) const {
+    return this->base() == Iterator.base();
+  }
+
+  bool operator!=(const ReversePtrListRefIterator &Iterator) const {
+    return !(*this == Iterator);
+  }
+
+ protected:
+  T current;
+};
+
+template <typename T>
+class PtrListRefIterator {
+ public:
+  using iterator_category = std::bidirectional_iterator_tag;
+  using value_type = T;
+  using difference_type = std::ptrdiff_t;
+  using pointer = T*;
+  using reference = T&;
+  using const_pointer = const T*;
+  using const_reference = const T&;
+
+  PtrListRefIterator() = default;
+
+  explicit PtrListRefIterator(pointer _Ptr) : ptr(_Ptr) {}
+
+  template <typename U, typename = std::enable_if_t<std::is_same<U, std::remove_const_t<T>>::value>>
+  PtrListRefIterator(const PtrListRefIterator<U> &_Iter) : ptr(_Iter.d()) {}
+
+  ~PtrListRefIterator() = default;
+
+  pointer d() const {
+    return ptr;
+  }
+
+  reference operator*() const {
+    return *ptr;
+  }
+
+  pointer operator->() const {
+    return ptr;
+  }
+
+  PtrListRefIterator &operator++() {
+    this->ptr = this->ptr->GetNext();
+    return *this;
+  }
+
+  PtrListRefIterator &operator--() {
+    this->ptr = this->ptr->GetPrev();
+    return *this;
+  }
+
+  PtrListRefIterator operator++(int) {
+    PtrListRefIterator it = *this;
+    ++(*this);
+    return it;
+  }
+
+  PtrListRefIterator operator--(int) {
+    PtrListRefIterator it = *this;
+    --(*this);
+    return it;
+  }
+
+  bool operator==(const PtrListRefIterator &Iterator) const {
+    return this->ptr == Iterator.ptr;
+  }
+
+  bool operator!=(const PtrListRefIterator &Iterator) const {
+    return !(*this == Iterator);
+  }
+
+ private:
+  pointer ptr = nullptr;
+};
+
+template <typename T>
+class PtrListRef {
+ public:
+  using value_type = T;
+  using size_type = size_t;
+  using difference_type = std::ptrdiff_t;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+
+  using iterator = PtrListRefIterator<T>;
+  using const_iterator = PtrListRefIterator<const T>;
+  using reverse_iterator = ReversePtrListRefIterator<iterator>;
+  using const_reverse_iterator = ReversePtrListRefIterator<const_iterator>;
+
+  PtrListRef() = default;
+  explicit PtrListRef(pointer _Value) : first(_Value), last(_Value) {}
+
+  PtrListRef(pointer _First, pointer _Last) : first(_First), last(_Last == nullptr ? _First : _Last) {}
+
+  ~PtrListRef() = default;
+
+  iterator begin() {
+    return iterator(this->first);
+  }
+
+  const_iterator begin() const {
+    return const_iterator(this->first);
+  }
+
+  const_iterator cbegin() const {
+    return const_iterator(this->first);
+  }
+
+  iterator end() {
+    return iterator(this->last == nullptr ? nullptr : this->last->GetNext());
+  }
+
+  const_iterator end() const {
+    return const_iterator(this->last == nullptr ? nullptr : this->last->GetNext());
+  }
+
+  const_iterator cend() const {
+    return const_iterator(this->last == nullptr ? nullptr : this->last->GetNext());
+  }
+
+  reverse_iterator rbegin() {
+    return reverse_iterator(iterator(this->last));
+  }
+
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(const_iterator(this->last));
+  }
+
+  const_reverse_iterator crbegin() const {
+    return const_reverse_iterator(const_iterator(this->last));
+  }
+
+  reverse_iterator rend() {
+    return reverse_iterator(iterator(this->first == nullptr ? nullptr : this->first->GetPrev()));
+  }
+
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(const_iterator(this->first == nullptr ? nullptr : this->first->GetPrev()));
+  }
+
+  const_reverse_iterator crend() const {
+    return const_reverse_iterator(const_iterator(this->first == nullptr ? nullptr : this->first->GetPrev()));
+  }
+
+  reference front() {
+    return *(this->first);
+  }
+
+  reference back() {
+    return *(this->last);
+  }
+
+  const_reference front() const {
+    return *(this->first);
+  }
+
+  const_reference back() const {
+    return *(this->last);
+  }
+
+  bool empty() const {
+    return first == nullptr;
+  }
+
+  void update_front(pointer _Value) {
+    if (_Value != nullptr) {
+      _Value->SetPrev(nullptr);
+    }
+    this->first = _Value;
+  }
+
+  void push_front(pointer _Value) {
+    if (this->last == nullptr) {
+      this->first = _Value;
+      this->last = _Value;
+      _Value->SetPrev(nullptr);
+      _Value->SetNext(nullptr);
+    } else {
+      ASSERT(this->first != nullptr, "null ptr check");
+      this->first->SetPrev(_Value);
+      _Value->SetPrev(nullptr);
+      _Value->SetNext(this->first);
+      this->first = _Value;
+    }
+  }
+
+  void pop_front() {
+    if (this->first == nullptr) {
+      return;
+    }
+
+    this->first = this->first->GetNext();
+    if (this->first != nullptr) {
+      this->first->SetPrev(nullptr);
+    }
+  }
+
+  void update_back(pointer _Value) {
+    if (_Value != nullptr) {
+      _Value->SetNext(nullptr);
+    }
+    this->last = _Value;
+  }
+
+  void push_back(pointer _Value) {
+    if (this->last == nullptr) {
+      this->first = _Value;
+      this->last = _Value;
+      _Value->SetPrev(nullptr);
+    } else {
+      this->last->SetNext(_Value);
+      _Value->SetPrev(this->last);
+      this->last = _Value;
+    }
+    _Value->SetNext(nullptr);
+  }
+
+  void pop_back() {
+    if (this->last == nullptr) {
+      return;
+    }
+
+    if (this->last->GetPrev() == nullptr) {
+      this->first = nullptr;
+      this->last = nullptr;
+    } else {
+      this->last = this->last->GetPrev();
+      this->last->SetNext(nullptr);
+    }
+  }
+
+  void insert(const_iterator _Where, pointer _Value) {
+    if (_Where == const_iterator(this->first)) {
+      this->push_front(_Value);
+    } else if (_Where == this->cend()) {
+      this->push_back(_Value);
+    } else {
+      // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed.
+      auto *ptr = const_cast<T*>(&*_Where);
+      _Value->SetPrev(ptr->GetPrev());
+      _Value->SetNext(ptr);
+      _Value->GetPrev()->SetNext(_Value);
+      ptr->SetPrev(_Value);
+    }
+  }
+
+  void insert(const_pointer _Where, pointer _Value) {
+    this->insert(const_iterator(_Where), _Value);
+  }
+
+  void insertAfter(const_iterator _Where, pointer _Value) {
+    if (_Where == const_iterator(nullptr)) {
+      this->push_front(_Value);
+    } else if (_Where == const_iterator(this->last)) {
+      this->push_back(_Value);
+    } else {
+      // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed.
+      auto *ptr = const_cast<T*>(&*_Where);
+      _Value->SetPrev(ptr);
+      _Value->SetNext(ptr->GetNext());
+      _Value->GetNext()->SetPrev(_Value);
+      ptr->SetNext(_Value);
+    }
+  }
+
+  void insertAfter(const_pointer _Where, pointer _Value) {
+    this->insertAfter(const_iterator(_Where), _Value);
+  }
+
+  void splice(const_iterator _Where, PtrListRef &_Other) {
+    ASSERT(!_Other.empty(), "NYI");
+    if (this->empty()) {
+      this->first = &(_Other.front());
+      this->last = &(_Other.back());
+    } else if (_Where == this->cend() || _Where == const_iterator(this->last)) {
+      ASSERT(this->last != nullptr, "null ptr check");
+      this->last->SetNext(&(_Other.front()));
+      _Other.front().SetPrev(this->last);
+      this->last = &(_Other.back());
+    } else {
+      ASSERT(to_ptr(_Where) != nullptr, "null ptr check");
+      ASSERT(_Where->GetNext() != nullptr, "null ptr check");
+      // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed.
+      auto *ptr = const_cast<T*>(&*_Where);
+      _Other.front().SetPrev(ptr);
+      _Other.back().SetNext(ptr->GetNext());
+      ptr->GetNext()->SetPrev(&(_Other.back()));
+      ptr->SetNext(&(_Other.front()));
+    }
+  }
+
+  void splice(const_pointer _Where, PtrListRef &_Other) {
+    splice(const_iterator(_Where), _Other);
+  }
+
+  void clear() {
+    this->first = nullptr;
+    this->last = nullptr;
+  }
+
+  iterator erase(const_iterator _Where) {
+    if (_Where == this->cbegin() && _Where == this->rbegin().base()) {
+      this->first = nullptr;
+      this->last = nullptr;
+    } else if (_Where == this->cbegin()) {
+      // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed.
+      auto *ptr = const_cast<T*>(&*_Where);
+      this->first = ptr->GetNext();
+      ASSERT(this->first != nullptr, "null ptr check");
+      this->first->SetPrev(nullptr);
+    } else if (_Where == this->rbegin().base()) {
+      pop_back();
+    } else {
+      ASSERT(_Where->GetPrev() != nullptr, "null ptr check");
+      // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed.
+      auto *ptr = const_cast<T*>(&*_Where);
+      ptr->GetPrev()->SetNext(ptr->GetNext());
+      if (ptr->GetNext()) {
+        ptr->GetNext()->SetPrev(ptr->GetPrev());
+      }
+    }
+    return iterator(nullptr);
+  }
+
+  iterator erase(const_pointer _Where) {
+    return this->erase(const_iterator(_Where));
+  }
+
+  void set_first(T *f) {
+    this->first = f;
+  }
+
+  void set_last(T *f) {
+    this->last = f;
+  }
+
+ private:
+  T *first = nullptr;
+  T *last = nullptr;
+};
+
+template <typename Iterator>
+auto to_ptr(Iterator it) -> typename std::iterator_traits<Iterator>::pointer {
+  return it.d();
+}
+
+template <typename Iterator>
+auto to_ptr(ReversePtrListRefIterator<Iterator> it) -> typename std::iterator_traits<Iterator>::pointer {
+  return it.base().d();
+}
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_PTR_LIST_REF_H
diff --git a/src/mapleall/maple_util/include/reflection_list.def b/src/mapleall/maple_util/include/reflection_list.def
new file mode 100644
index 0000000000000000000000000000000000000000..3f339ba88b2bb683695282bdcfa2e4f7362ae70c
--- /dev/null
+++ b/src/mapleall/maple_util/include/reflection_list.def
@@ -0,0 +1,30 @@
+"Ljava_2Flang_2FClass_3B_7CfindInterfaceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetAccessFlags_7C_28_29I",
+"Ljava_2Flang_2FClass_3B_7CgetClasses_7C_28_29ALjava_2Flang_2FClass_3B",
+"Ljava_2Flang_2FClass_3B_7CgetClassLoader_7C_28_29Ljava_2Flang_2FClassLoader_3B",
+"Ljava_2Flang_2FClass_3B_7CgetComponentType_7C_28_29Ljava_2Flang_2FClass_3B",
+"Ljava_2Flang_2FClass_3B_7CgetConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B",
+"Ljava_2Flang_2FClass_3B_7CgetConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B",
+"Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B",
+"Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B",
+"Ljava_2Flang_2FClass_3B_7CgetDeclaredMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetDeclaredMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetField_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2Freflect_2FField_3B",
+"Ljava_2Flang_2FClass_3B_7CgetFields_7C_28_29ALjava_2Flang_2Freflect_2FField_3B",
+"Ljava_2Flang_2FClass_3B_7CgetInstanceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetInterfaces_7C_28_29ALjava_2Flang_2FClass_3B",
+"Ljava_2Flang_2FClass_3B_7CgetMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetModifiers_7C_28_29I",
+"Ljava_2Flang_2FClass_3B_7CgetName_7C_28_29Ljava_2Flang_2FString_3B",
+"Ljava_2Flang_2FClass_3B_7CgetPublicFieldsRecursive_7C_28Ljava_2Futil_2FList_3B_29V",
+"Ljava_2Flang_2FClass_3B_7CgetPublicMethodsInternal_7C_28Ljava_2Futil_2FList_3B_29V",
+"Ljava_2Flang_2FClass_3B_7CgetSuperclass_7C_28_29Ljava_2Flang_2FClass_3B",
+"Ljava_2Flang_2FClass_3B_7CisAssignableFrom_7C_28Ljava_2Flang_2FClass_3B_29Z",
+"Ljava_2Flang_2FClass_3B_7CisInterface_7C_28_29Z",
+"Ljava_2Flang_2FClass_3B_7CisPrimitive_7C_28_29Z",
+"Ljava_2Flang_2FClass_3B_7CisProxy_7C_28_29Z",
+"Ljava_2Flang_2FClass_3B_7CisMemberClass_7C_28_29Z",
+"Ljava_2Flang_2FClass_3B_7CisLocalClass_7C_28_29Z",
+"Ljava_2Flang_2Fref_2FReference_3B_7Cget_7C_28_29Ljava_2Flang_2FObject_3B",
+"Ljava_2Flang_2Fref_2FReference_3B_7Cclear_7C_28_29V",
diff --git a/src/mapleall/maple_util/include/safe_cast.h b/src/mapleall/maple_util/include/safe_cast.h
new file mode 100644
index 0000000000000000000000000000000000000000..964341a0164b863e2b10769b0e9cdcc724331700
--- /dev/null
+++ b/src/mapleall/maple_util/include/safe_cast.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_SAFE_CAST_H
+#define MAPLE_UTIL_INCLUDE_SAFE_CAST_H
+#include "utils/meta.h"
+
+namespace maple {
+template<typename ToT>
+struct SafeCastCondition : public std::false_type {};
+
+#define REGISTER_SAFE_CAST(type, condition)                             \
+template<>                                                             \
+struct SafeCastCondition<type> : public std::true_type {               \
+  template<typename FromT>                                             \
+  static inline bool DoIt(const FromT &from) {                          \
+    return (condition);                                                 \
+  }                                                                     \
+}
+
+namespace impl {
+template<typename ToT, typename FromT,
+    typename = std::enable_if_t<std::is_base_of<FromT, ToT>::value>>
+struct InstanceOfImpl {
+  static inline bool DoIt(const FromT &from) {
+    return (SafeCastCondition<ToT>::DoIt(from));
+  }
+};
+
+template<typename ToT, typename FromT>
+struct InstanceOfImpl<ToT, FromT, typename std::enable_if_t<std::is_base_of<ToT, FromT>::value>> {
+  static inline bool DoIt(const FromT&) {
+    return true;
+  }
+};
+
+template<typename ToT, typename FromT>
+struct EnabledSafeCast : public utils::meta_or<std::is_base_of<ToT, FromT>, SafeCastCondition<ToT>>::type {};
+}
+
+template<typename ToT, typename FromT,
+    typename = std::enable_if_t<impl::EnabledSafeCast<ToT, FromT>::value>>
+inline bool instance_of(FromT &from) {
+  return impl::InstanceOfImpl<ToT, FromT>::DoIt(from);
+}
+
+template<typename ToT, typename FromT,
+    typename = std::enable_if_t<impl::EnabledSafeCast<ToT, FromT>::value>>
+inline bool instance_of(FromT *from) {
+  return (from != nullptr && instance_of<ToT>(*from));
+}
+
+template<typename ToT, typename FromT,
+    typename RetT = std::conditional_t<
+        std::is_const<FromT>::value || std::is_const<std::remove_pointer_t<ToT>>::value,
+        std::add_pointer_t<std::add_const_t<std::remove_cv_t<ToT>>>,
+        std::add_pointer_t<std::remove_cv_t<ToT>>>,
+    typename = std::enable_if_t<impl::EnabledSafeCast<ToT, FromT>::value>>
+inline RetT safe_cast(FromT &from) {
+  return (instance_of<ToT>(from) ? static_cast<RetT>(&from) : nullptr);
+}
+
+template<typename ToT, typename FromT,
+    typename RetT = std::conditional_t<
+        std::is_const<FromT>::value || std::is_const<std::remove_pointer_t<ToT>>::value,
+        std::add_pointer_t<std::add_const_t<std::remove_cv_t<ToT>>>,
+        std::add_pointer_t<std::remove_cv_t<ToT>>>,
+    typename = std::enable_if_t<impl::EnabledSafeCast<ToT, FromT>::value>>
+inline RetT safe_cast(FromT *from) {
+  return (instance_of<ToT>(from) ? static_cast<RetT>(from) : nullptr);
+}
+}
+#endif // MAPLE_UTIL_INCLUDE_SAFE_CAST_H
\ No newline at end of file
diff --git a/src/mapleall/maple_util/include/safe_ptr.h b/src/mapleall/maple_util/include/safe_ptr.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e087e06ae4516e97a263c128546436cde40e54f
--- /dev/null
+++ b/src/mapleall/maple_util/include/safe_ptr.h
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_SAFE_PTR_H
+#define MAPLE_UTIL_SAFE_PTR_H
+#include "mpl_logging.h"
+#include "ptr.h"
+
+namespace maple {
+namespace utils {
+template<typename T>
+inline void AssertNotNull(const T *ptr) {
+  CHECK_FATAL(ptr != nullptr, "nullptr was assigned to SafePtr.");
+}
+
+template<typename T>
+class SafePtr {
+  using Base = Ptr<T, AssertNotNull<T>>;
+ public:
+  using pointer = typename Base::Pointer;
+  using ElementType = typename Base::ElementType;
+
+  constexpr SafePtr() noexcept = delete;
+
+  constexpr SafePtr(std::nullptr_t) noexcept = delete;
+
+  SafePtr(pointer ptr) : base(ptr) {}
+
+  SafePtr(T &ref) : base(ref, CheckNothing<T>) {}
+
+  SafePtr(T &&ref) = delete;
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  SafePtr(U *ptr) : base(ptr) {}
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  SafePtr(U &ref) : base(ref, CheckNothing<T>) {}
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  SafePtr(U &&ref) = delete;
+
+  SafePtr(const SafePtr &other) : base(other.base) {}
+
+  SafePtr(SafePtr &&other) noexcept : base(std::move(other.base)) {}
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  explicit SafePtr(const SafePtr<U> &other) : base(other.get(), CheckNothing<T>) {}
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  explicit SafePtr(SafePtr<U> &&other) : base(other.get(), CheckNothing<T>) {}
+
+  ~SafePtr() = default;
+
+  SafePtr &operator=(pointer ptr) noexcept {
+    base = ptr;
+    return *this;
+  }
+
+  SafePtr &operator=(std::nullptr_t) noexcept = delete;
+
+  SafePtr &operator=(const SafePtr &ptr) noexcept {
+    base = ptr.base;
+    return *this;
+  }
+
+  SafePtr &operator=(SafePtr &&ptr) noexcept {
+    base = std::move(ptr.base);
+    return *this;
+  }
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  SafePtr &operator=(const SafePtr<U> &ptr) noexcept {
+    base = Base(static_cast<T*>(ptr.get()), CheckNothing<T>);
+    return *this;
+  }
+
+  template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+  SafePtr &operator=(SafePtr<U> &&ptr) noexcept {
+    base = Base(static_cast<T*>(ptr.get()), CheckNothing<T>);
+    return *this;
+  }
+
+  pointer release() noexcept = delete;
+
+  void reset(std::nullptr_t) noexcept = delete;
+
+  void reset(pointer ptr) noexcept {
+    AssertNotNull(ptr);
+    base.reset(ptr);
+  }
+
+  void swap(SafePtr &other) noexcept {
+    std::swap(base, other.base);
+  }
+
+  T *get() const noexcept {
+    return base.get();
+  }
+
+  explicit operator bool() const noexcept = delete;
+
+  T &operator*() const {
+    return *get();
+  }
+
+  T *operator->() const noexcept {
+    return get();
+  }
+
+  SafePtr &operator++() = delete;
+
+  const SafePtr operator++(int) = delete;
+
+  SafePtr &operator--() = delete;
+
+  const SafePtr operator--(int) = delete;
+
+  SafePtr &operator+=(std::ptrdiff_t) = delete;
+
+  SafePtr &operator-=(std::ptrdiff_t) = delete;
+
+ private:
+  Base base;
+};
+
+template<typename T, typename U>
+inline bool operator==(const SafePtr<T> &lhs, const SafePtr<U> &rhs) {
+  return lhs.get() == rhs.get();
+}
+
+template<typename T, typename U>
+inline bool operator!=(const SafePtr<T> &lhs, const SafePtr<U> &rhs) {
+  return !(lhs == rhs);
+}
+
+template<typename T, typename U>
+inline bool operator<(const SafePtr<T> &lhs, const SafePtr<U> &rhs) = delete;
+
+template<typename T, typename U>
+inline bool operator<=(const SafePtr<T> &lhs, const SafePtr<U> &rhs) = delete;
+
+template<typename T, typename U>
+inline bool operator>(const SafePtr<T> &lhs, const SafePtr<U> &rhs) = delete;
+
+template<typename T, typename U>
+inline bool operator>=(const SafePtr<T> &lhs, const SafePtr<U> &rhs) = delete;
+
+template<typename T>
+inline bool operator==(const SafePtr<T> &lhs, std::nullptr_t) = delete;
+
+template<typename T>
+inline bool operator==(std::nullptr_t, const SafePtr<T> &rhs) = delete;
+
+template<typename T>
+inline bool operator!=(const SafePtr<T> &lhs, std::nullptr_t) = delete;
+
+template<typename T>
+inline bool operator!=(std::nullptr_t, const SafePtr<T> &rhs) = delete;
+
+template<typename T>
+inline bool operator<(const SafePtr<T> &lhs, std::nullptr_t) = delete;
+
+template<typename T>
+inline bool operator<(std::nullptr_t, const SafePtr<T> &rhs) = delete;
+
+template<typename T>
+inline bool operator<=(const SafePtr<T> &lhs, std::nullptr_t) = delete;
+
+template<typename T>
+inline bool operator<=(std::nullptr_t, const SafePtr<T> &rhs) = delete;
+
+template<typename T>
+inline bool operator>(const SafePtr<T> &lhs, std::nullptr_t) = delete;
+
+template<typename T>
+inline bool operator>(std::nullptr_t, const SafePtr<T> &rhs) = delete;
+
+template<typename T>
+inline bool operator>=(const SafePtr<T> &lhs, std::nullptr_t) = delete;
+
+template<typename T>
+inline bool operator>=(std::nullptr_t, const SafePtr<T> &rhs) = delete;
+
+template<typename T>
+inline T &ToRef(SafePtr<T> ptr) {
+  return *ptr;
+}
+}
+}
+
+namespace std {
+template<class T>
+struct hash<maple::utils::SafePtr<T>> {
+  std::size_t operator()(const maple::utils::SafePtr<T> &safePtr) const {
+    return hash<typename maple::utils::SafePtr<T>::pointer>()(safePtr.get());
+  }
+};
+} // namespace std
+#endif // DIY_CPLUSPLUS_SAFE_PTR_H
diff --git a/src/mapleall/maple_util/include/string_utils.h b/src/mapleall/maple_util/include/string_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..a392238a818d24beb6b59828e307670a9f6378f2
--- /dev/null
+++ b/src/mapleall/maple_util/include/string_utils.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_STRING_UTILS_H
+#define MAPLE_UTIL_INCLUDE_STRING_UTILS_H
+#include <string>
+#include <vector>
+#include <sstream>
+#include <unordered_set>
+#include <regex>
+
+namespace maple {
+class StringUtils {
+ public:
+  template <class Container>
+  static void Split(const std::string &src, Container &container, char delim) {
+    if (Trim(src).empty()) {
+      return;
+    }
+
+    std::stringstream strStream(src + delim);
+    std::string item;
+    while (std::getline(strStream, item, delim)) {
+      container.emplace_back(item);
+    }
+  }
+
+  template <typename Container>
+  static void SplitSV(const std::string_view &src, Container &container, char delim) {
+    size_t startInd = 0;
+    while (startInd < src.size()) {
+      if (src[startInd] == delim) {
+        ++startInd;
+        continue;
+      }
+
+      size_t endInd = src.find_first_of(delim, startInd);
+      if (startInd != endInd) {
+        container.emplace_back(src.substr(startInd,  endInd - startInd));
+      }
+
+      if (endInd == std::string_view::npos) {
+        break;
+      }
+      startInd = endInd + 1;
+    }
+  }
+
+  static void Split(const std::string &src, std::unordered_set<std::string> &container, char delim);
+
+  static std::string Trim(const std::string &s);
+  static std::string Replace(const std::string &src, const std::string &target, const std::string &replacement);
+  static std::string Append(const std::string &src, const std::string &target, const std::string &spliter);
+  static std::string GetStrAfterLast(const std::string &src, const std::string &target,
+                                     bool isReturnEmpty = false);
+  static std::string GetStrBeforeLast(const std::string &src, const std::string &target,
+                                      bool isReturnEmpty = false);
+  static bool HasCommandInjectionChar(const std::string &s) {
+    return std::regex_search(s, kCommandInjectionRegex);
+  }
+
+  static bool EndsWith(const std::string &str, const std::string &end) {
+    if (end.size() > str.size()) {
+      return false;
+    }
+
+    return std::equal(end.rbegin(), end.rend(), str.rbegin());
+  }
+
+  static bool StartsWith(const std::string &str, const std::string &start) {
+    if (start.size() > str.size()) {
+      return false;
+    }
+
+    return std::equal(start.cbegin(), start.cend(), str.cbegin());
+  }
+
+ private:
+  static std::regex kCommandInjectionRegex;
+};
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_STRING_UTILS_H
diff --git a/src/mapleall/maple_util/include/suffix_array.h b/src/mapleall/maple_util/include/suffix_array.h
new file mode 100644
index 0000000000000000000000000000000000000000..52181a040523379713052bd42f1d981fa1de16f8
--- /dev/null
+++ b/src/mapleall/maple_util/include/suffix_array.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTILS_INCLUDE_SUFFIX_ARRAY_H
+#define MAPLE_UTILS_INCLUDE_SUFFIX_ARRAY_H
+#include <sys/types.h>
+#include <array>
+#include <cstddef>
+#include <utility>
+#include <vector>
+#include "mpl_logging.h"
+namespace maple {
+using SubStringPair = std::pair<size_t, size_t>;
+constexpr size_t kInvalidPosition = std::numeric_limits<size_t>::max();
+
+class SubStringOccurrences {
+ public:
+  friend class SuffixArray;
+  explicit SubStringOccurrences(size_t length) : length(length) {}
+  virtual ~SubStringOccurrences() = default;
+  std::vector<SubStringPair> &GetOccurrences() {
+    return occurrences;
+  }
+ private:
+  std::vector<SubStringPair> occurrences;
+  size_t length;
+};
+
+class SuffixArray {
+ public:
+  SuffixArray(std::vector<size_t> src, size_t length, size_t size)
+      : length(length),
+        alphabetSize(size),
+        src(src),
+        suffixType(length, false),
+        lmsSubStringPosition(length, 0),
+        lmsCharacterString(length, kInvalidPosition),
+        suffixArray(length, kInvalidPosition),
+        rankArray(length, 0),
+        heightArray(length, 0),
+        bucket(size + 1, 0),
+        lBucket(size + 1, 0),
+        sBucket(size + 1, 0) {}
+  bool IsLmsCharacter(size_t pos);
+  bool IsSubStringEqual(size_t lhs, size_t rhs);
+  void InducedSort();
+  void BucketInit();
+  void ComputeSuffixType();
+  void FindLmsSubString();
+  void RenameLmsSubString();
+  void ConstructSuffixArray();
+  void ComputeLcpArray();
+  void FindRepeatedSubStrings();
+  void Run(bool needLcp = false);
+  void Dump();
+
+  std::vector<size_t> &GetSuffixArray() {
+    return suffixArray;
+  }
+
+  std::vector<size_t> &GetHeightArray() {
+    return heightArray;
+  }
+
+  std::vector<SubStringOccurrences *> &GetRepeatedSubStrings() {
+    return repeatedSubStrings;
+  }
+
+ private:
+  size_t length;
+  size_t alphabetSize;
+  size_t lmsSubStringCount = 0;
+  size_t lmsCharacterCount = 1;
+  bool hasSameLmsSubstring = false;
+  std::vector<size_t> src;
+  std::vector<bool> suffixType;
+  std::vector<size_t> lmsSubStringPosition;
+  std::vector<size_t> lmsCharacterString;
+  std::vector<size_t> suffixArray;
+  std::vector<size_t> rankArray;
+  std::vector<size_t> heightArray;
+  std::vector<size_t> bucket;
+  std::vector<size_t> lBucket;
+  std::vector<size_t> sBucket;
+  std::vector<SubStringOccurrences *> repeatedSubStrings;
+};
+}
+#endif
diff --git a/src/mapleall/maple_util/include/thread_env.h b/src/mapleall/maple_util/include/thread_env.h
new file mode 100644
index 0000000000000000000000000000000000000000..7540ac137d6077ec707c5718ce3982fecbf7622c
--- /dev/null
+++ b/src/mapleall/maple_util/include/thread_env.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_THREAD_STATUS_H
+#define MAPLE_UTIL_INCLUDE_THREAD_STATUS_H
+#include <thread>
+#include <mutex>
+#include <unordered_map>
+
+namespace maple {
+class ThreadEnv {
+ public:
+  static bool IsMeParallel() {
+    return threadEnv.isMeParallel;
+  }
+
+  static void SetMeParallel(bool status) {
+    threadEnv.isMeParallel = status;
+  }
+
+  static size_t GetThreadIndex(const std::thread::id &tid) {
+    static std::mutex mtx;
+    std::lock_guard<std::mutex> guard(mtx);
+    auto it = threadEnv.threadIndexMap.find(tid);
+    if (it != threadEnv.threadIndexMap.end()) {
+      return it->second;
+    }
+    return 0;  // the index of main thread is 0
+  }
+
+  static void InitThreadIndex(const std::thread::id &tid) {
+    static std::mutex mtx;
+    std::lock_guard<std::mutex> guard(mtx);
+    size_t currThreadCnt = threadEnv.threadIndexMap.size();
+    threadEnv.threadIndexMap[tid] = (currThreadCnt + 1);
+  }
+
+ private:
+  static ThreadEnv threadEnv;
+  bool isMeParallel = false;  // whether me is under multithreading (optimize separate functions in parallel)
+  // thread index begins from 1. 0 is reserved for main thread, which is not in the map
+  std::unordered_map<std::thread::id, size_t> threadIndexMap;
+};
+
+class ParallelGuard {
+ public:
+  explicit ParallelGuard(std::mutex &mtxInput, bool cond = true) : mtx(mtxInput), condition(cond) {
+    if (condition) {
+      mtx.lock();
+    }
+  }
+
+  ParallelGuard(const ParallelGuard&) = delete;
+  ParallelGuard &operator=(const ParallelGuard&) = delete;
+
+  ~ParallelGuard() {
+    if (condition) {
+      mtx.unlock();
+    }
+  }
+
+ private:
+  std::mutex &mtx;
+  const bool condition;
+};
+}  // namespace maple
+#endif  // MAPLE_UTIL_INCLUDE_THREAD_STATUS_H
diff --git a/src/mapleall/maple_util/include/utils.h b/src/mapleall/maple_util/include/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b74cee1661ba368ff4913f3b21d258387e8d3b8
--- /dev/null
+++ b/src/mapleall/maple_util/include/utils.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_UTILS_H
+#define MAPLE_UTIL_INCLUDE_UTILS_H
+
+#include <vector>
+#include "mpl_logging.h"
+
+namespace maple {
+namespace utils {
+// Operations on char
+constexpr bool IsDigit(char c) {
+  return (c >= '0' && c <= '9');
+}
+
+constexpr bool IsLower(char c) {
+  return (c >= 'a' && c <= 'z');
+}
+
+constexpr bool IsUpper(char c) {
+  return (c >= 'A' && c <= 'Z');
+}
+
+constexpr bool IsAlpha(char c) {
+  return (IsLower(c) || IsUpper(c));
+}
+
+constexpr bool IsAlnum(char c) {
+  return (IsAlpha(c) || IsDigit(c));
+}
+
+namespace __ToDigitImpl {
+template <uint8_t Scale, typename T>
+struct ToDigitImpl {};
+
+template <typename T>
+struct ToDigitImpl<10, T> {
+  static T DoIt(char c) {
+    if (utils::IsDigit(c)) {
+      return c - '0';
+    }
+    return std::numeric_limits<T>::max();
+  }
+};
+
+template <typename T>
+struct ToDigitImpl<8, T> {
+  static T DoIt(char c) {
+    if (c >= '0' && c < '8') {
+      return c - '0';
+    }
+    return std::numeric_limits<T>::max();
+  }
+};
+
+template <typename T>
+struct ToDigitImpl<16, T> {
+  static T DoIt(char c) {
+    if (utils::IsDigit(c)) {
+      return c - '0';
+    }
+    if (c >= 'a' && c <= 'f') {
+      return c - 'a' + 10;
+    }
+    if (c >= 'A' && c <= 'F') {
+      return c - 'A' + 10;
+    }
+    return std::numeric_limits<T>::max();
+  }
+};
+}
+
+template <uint8_t Scale = 10, typename T = uint8_t>
+constexpr T ToDigit(char c) {
+  return __ToDigitImpl::ToDigitImpl<Scale, T>::DoIt(c);
+}
+
+// Operations on pointer
+template <typename T>
+inline T &ToRef(T *ptr) {
+  CHECK_NULL_FATAL(ptr);
+  return *ptr;
+}
+
+template <typename T, typename = decltype(&T::get)>
+inline typename T::element_type &ToRef(T &ptr) {
+  return ToRef(ptr.get());
+}
+
+template <size_t pos, typename = std::enable_if_t<pos < 32>>
+struct bit_field {
+  static constexpr uint32_t value = 1U << pos;
+};
+
+template <size_t pos>
+constexpr uint32_t bit_field_v = bit_field<pos>::value;
+
+template <size_t pos, typename = std::enable_if_t<pos < 64>>
+struct lbit_field {
+  static constexpr uint64_t value = 1ULL << pos;
+};
+
+template <size_t pos>
+constexpr uint64_t lbit_field_v = bit_field<pos>::value;
+
+template <typename T>
+bool Contains(const std::vector<T> &container, const T &data) {
+  return (std::find(std::begin(container), std::end(container), data) != container.end());
+}
+
+}} // namespace maple::utils
+#endif  // MAPLE_UTIL_INCLUDE_UTILS_H
diff --git a/src/mapleall/maple_util/include/utils/iterator.h b/src/mapleall/maple_util/include/utils/iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..4eaef63fd9592cb9db56af40e344316d26a593fc
--- /dev/null
+++ b/src/mapleall/maple_util/include/utils/iterator.h
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_ITERATOR_H
+#define MAPLE_UTIL_INCLUDE_ITERATOR_H
+#include <iterator>
+#include "meta.h"
+
+namespace maple {
+namespace utils {
+template <typename Iterator, typename Container>
+struct mpl_iterator_traits {
+  using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
+  using value_type = typename std::iterator_traits<Iterator>::value_type;
+  using difference_type = typename std::iterator_traits<Iterator>::difference_type;
+  using pointer = typename std::iterator_traits<Iterator>::pointer;
+  using reference = typename std::iterator_traits<Iterator>::reference;
+
+  static reference operator_dereference(Iterator iter) {
+    return *iter;
+  };
+
+  static Iterator operator_arrow(Iterator iter) {
+    return iter;
+  }
+
+  static reference operator_bracket(Iterator iter, difference_type n) {
+    return iter[n];
+  }
+};
+
+template <typename Iterator, typename Container>
+class mpl_iterator {
+  using Traits = mpl_iterator_traits<Iterator, Container>;
+ public:
+  using iterator_category = typename Traits::iterator_category;
+  using value_type = typename Traits::value_type;
+  using difference_type = typename Traits::difference_type;
+  using pointer = typename Traits::pointer;
+  using reference = typename Traits::reference;
+
+  explicit mpl_iterator(Iterator iter)
+      : iter(iter) {}
+
+  template <typename U, typename = std::enable_if_t<ptr::const_of_v<U, pointer>>>
+  mpl_iterator(const mpl_iterator<U, Container> &iter)
+      : iter(iter.base()) {}
+
+  ~mpl_iterator() noexcept = default;
+
+  reference operator*() const noexcept {
+    return Traits::operator_dereference(iter);
+  }
+
+  pointer operator->() const noexcept {
+    return Traits::operator_arrow(iter);
+  }
+
+  mpl_iterator &operator++() noexcept {
+    ++iter;
+    return *this;
+  }
+
+  mpl_iterator operator++(int) noexcept {
+    return mpl_iterator(iter++);
+  }
+
+  mpl_iterator &operator--() noexcept {
+    --iter;
+    return *this;
+  }
+
+  mpl_iterator operator--(int) noexcept {
+    return mpl_iterator(iter--);
+  }
+
+  reference operator[](difference_type n) const noexcept {
+    return Traits::operator_bracket(iter, n);
+  }
+
+  mpl_iterator &operator+=(difference_type n) noexcept {
+    iter += n;
+    return *this;
+  }
+
+  mpl_iterator &operator-=(difference_type n) noexcept {
+    iter -= n;
+    return *this;
+  }
+
+  Iterator base() const noexcept {
+    return iter;
+  }
+
+ private:
+  Iterator iter;
+};
+
+template <typename T, typename Container>
+inline bool operator==(const mpl_iterator<T, Container> &lhs, const mpl_iterator<T, Container> &rhs) noexcept {
+  return lhs.base() == rhs.base();
+}
+
+template <typename T, typename U, typename Container, typename = std::enable_if_t<ptr::is_ncv_same_v<T, U>>>
+inline bool operator==(const mpl_iterator<T, Container> &lhs, const mpl_iterator<U, Container> &rhs) noexcept {
+  return lhs.base() == rhs.base();
+}
+
+template <typename T, typename Container>
+inline bool operator!=(const mpl_iterator<T, Container> &lhs, const mpl_iterator<T, Container> &rhs) noexcept {
+  return !(lhs == rhs);
+}
+
+template <typename T, typename U, typename Container, typename = std::enable_if_t<ptr::is_ncv_same_v<T, U>>>
+inline bool operator!=(const mpl_iterator<T, Container> &lhs, const mpl_iterator<U, Container> &rhs) noexcept {
+  return !(lhs == rhs);
+}
+
+template <typename T, typename Container>
+inline bool operator<(const mpl_iterator<T, Container> &lhs, const mpl_iterator<T, Container> &rhs) noexcept {
+  return lhs.base() < rhs.base();
+}
+
+template <typename T, typename U, typename Container, typename = std::enable_if_t<ptr::is_ncv_same_v<T, U>>>
+inline bool operator<(const mpl_iterator<T, Container> &lhs, const mpl_iterator<U, Container> &rhs) noexcept {
+  return lhs.base() < rhs.base();
+}
+
+template <typename T, typename Container>
+inline bool operator<=(const mpl_iterator<T, Container> &lhs, const mpl_iterator<T, Container> &rhs) noexcept {
+  return lhs.base() <= rhs.base();
+}
+
+template <typename T, typename U, typename Container, typename = std::enable_if_t<ptr::is_ncv_same_v<T, U>>>
+inline bool operator<=(const mpl_iterator<T, Container> &lhs, const mpl_iterator<U, Container> &rhs) noexcept {
+  return lhs.base() <= rhs.base();
+}
+
+template <typename T, typename Container>
+inline bool operator>(const mpl_iterator<T, Container> &lhs, const mpl_iterator<T, Container> &rhs) noexcept {
+  return lhs.base() > rhs.base();
+}
+
+template <typename T, typename U, typename Container, typename = std::enable_if_t<ptr::is_ncv_same_v<T, U>>>
+inline bool operator>(const mpl_iterator<T, Container> &lhs, const mpl_iterator<U, Container> &rhs) noexcept {
+  return lhs.base() > rhs.base();
+}
+
+template <typename T, typename Container>
+inline bool operator>=(const mpl_iterator<T, Container> &lhs, const mpl_iterator<T, Container> &rhs) noexcept {
+  return lhs.base() >= rhs.base();
+}
+
+template <typename T, typename U, typename Container, typename = std::enable_if_t<ptr::is_ncv_same_v<T, U>>>
+inline bool operator>=(const mpl_iterator<T, Container> &lhs, const mpl_iterator<U, Container> &rhs) noexcept {
+  return lhs.base() >= rhs.base();
+}
+
+template <typename T, typename Container>
+mpl_iterator<T, Container> operator+(const mpl_iterator<T, Container> &iter,
+                                     typename mpl_iterator<T, Container>::difference_type n) noexcept {
+  return mpl_iterator<T, Container>(iter.base() + n);
+}
+
+template <typename T, typename Container>
+mpl_iterator<T, Container> operator+(typename mpl_iterator<T, Container>::difference_type n,
+                                     const mpl_iterator<T, Container> &iter) noexcept {
+  return mpl_iterator<T, Container>(n + iter.base());
+}
+
+template <typename T, typename Container>
+mpl_iterator<T, Container> operator-(const mpl_iterator<T, Container> &iter,
+                                     typename mpl_iterator<T, Container>::difference_type n) noexcept {
+  return mpl_iterator<T, Container>(iter.base() - n);
+}
+
+template <typename T, typename Container>
+inline auto operator-(const mpl_iterator<T, Container> &lhs, const mpl_iterator<T, Container> &rhs) noexcept
+-> typename mpl_iterator<T, Container>::difference_type {
+  return lhs.base() - rhs.base();
+}
+
+template <typename T, typename U, typename Container, typename = std::enable_if_t<ptr::is_ncv_same_v<T, U>>>
+inline auto operator-(const mpl_iterator<T, Container> &lhs, const mpl_iterator<U, Container> &rhs) noexcept
+-> decltype(lhs.base() - rhs.base()) {
+  return lhs.base() - rhs.base();
+}
+}}
+
+#endif // MAPLE_UTIL_INCLUDE_ITERATOR_H
diff --git a/src/mapleall/maple_util/include/utils/meta.h b/src/mapleall/maple_util/include/utils/meta.h
new file mode 100644
index 0000000000000000000000000000000000000000..cc09ba766691e239db6ec7e5024aa18f2dc96992
--- /dev/null
+++ b/src/mapleall/maple_util/include/utils/meta.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_UTILS_META_H
+#define MAPLE_UTIL_INCLUDE_UTILS_META_H
+
+namespace maple {
+namespace utils {
+template <typename T, typename U>
+struct meta_and
+    : public std::conditional_t<T::value, U, T> {};
+
+template <typename T, typename U>
+struct meta_or
+    : public std::conditional_t<T::value, T, U> {};
+
+template <typename T>
+struct meta_not
+    : public std::integral_constant<bool, !static_cast<bool>(T::value)>::type {};
+
+template <typename ...>
+struct is_signed;
+
+template <typename T>
+struct is_signed<T>
+    : public std::is_signed<T>::type {};
+
+template <typename T, typename U>
+struct is_signed<T, U>
+    : public meta_and<std::is_signed<T>, std::is_signed<U>>::type {};
+
+template <typename ...T>
+constexpr bool is_signed_v = is_signed<T...>::value;
+
+template <typename ...>
+struct is_unsigned;
+
+template <typename T>
+struct is_unsigned<T>
+    : public std::is_unsigned<T>::type {};
+
+template <typename T, typename U>
+struct is_unsigned<T, U>
+    : public meta_and<std::is_unsigned<T>, std::is_unsigned<U>>::type {};
+
+template <typename ...T>
+constexpr bool is_unsigned_v = is_unsigned<T...>::value;
+
+template <typename T, typename U>
+struct is_same_sign
+    : public meta_or<is_signed<T, U>, is_unsigned<T, U>>::type {};
+
+template <typename T, typename U>
+struct is_diff_sign
+    : public meta_not<is_same_sign<T, U>>::type {};
+
+template <typename ...>
+struct is_pointer;
+
+template <typename T>
+struct is_pointer<T>
+    : public std::is_pointer<T>::type {};
+
+template <typename T, typename U>
+struct is_pointer<T, U>
+    : public meta_and<is_pointer<T>, is_pointer<U>>::type {};
+
+template <typename ...T>
+constexpr bool is_pointer_v = is_pointer<T...>::value;
+
+template <typename T, typename U>
+struct const_of
+    : public meta_and<std::is_const<U>, std::is_same<std::add_const_t<T>, U>>::type {};
+
+template <typename T, typename U>
+constexpr bool const_of_v = const_of<T, U>::value;
+
+template <typename T, typename U>
+struct is_ncv_same
+    : public std::is_same<std::remove_cv_t<T>, std::remove_cv_t<U>>::type {};
+
+template <typename T, typename U>
+constexpr bool is_ncv_same_v = is_ncv_same<T, U>::value;
+
+namespace ptr {
+template <typename T, typename U, typename = std::enable_if_t<is_pointer_v<T, U>>>
+struct const_of
+    : public utils::const_of<std::remove_pointer_t<T>, std::remove_pointer_t<U>>::type {};
+
+template <typename T, typename U, typename = std::enable_if_t<is_pointer_v<T, U>>>
+constexpr bool const_of_v = const_of<T, U>::value;
+
+template <typename T, typename U, typename = std::enable_if_t<is_pointer_v<T, U>>>
+struct is_ncv_same
+    : public utils::is_ncv_same<std::remove_pointer_t<T>, std::remove_pointer_t<U>>::type {};
+
+template <typename T, typename U, typename = std::enable_if_t<is_pointer_v<T, U>>>
+constexpr bool is_ncv_same_v = is_ncv_same<T, U>::value;
+}
+}}
+#endif // MAPLE_UTIL_INCLUDE_UTILS_META_H
diff --git a/src/mapleall/maple_util/include/utils/ref_vector.h b/src/mapleall/maple_util/include/utils/ref_vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..7958609462f4139e9521dad9f7f143cac4e128e6
--- /dev/null
+++ b/src/mapleall/maple_util/include/utils/ref_vector.h
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_UTIL_INCLUDE_REF_VECTOR_H
+#define MAPLE_UTIL_INCLUDE_REF_VECTOR_H
+#include <vector>
+#include "iterator.h"
+
+// The `utils::ref_vector<T>` is a decorator of `std::vector<T*>` which won't destory any `T`s and just refer to them.
+//
+// It is designed mainly to solve the problem that only the owner who is very familiar can tell whether the `T*` can be
+// nullptr. As time goes by, the others, even the owner may forget it. Or with more coding base on it, some will start
+// to check nullptr, it will make the code more confusion and hard to maintain.
+// Based on that, the ref_vector picks up the meaning of keeping objects' reference, it won't destory any of its
+// elements or require to check null(Never to be nullptr).
+namespace maple {
+namespace utils {
+class ref_vector_tag;
+template <typename Iterator>
+struct mpl_iterator_traits<Iterator, ref_vector_tag> {
+  using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
+  using value_type = std::remove_pointer_t<typename std::iterator_traits<Iterator>::value_type>;
+  using difference_type = typename std::iterator_traits<Iterator>::difference_type;
+  using pointer = value_type*;
+  using reference = value_type&;
+
+  static constexpr reference operator_dereference(Iterator iter) {
+    return *(*iter);
+  };
+
+  static constexpr Iterator operator_arrow(Iterator iter) {
+    return *iter;
+  }
+
+  static reference operator_bracket(Iterator iter, difference_type n) {
+    return *(iter[n]);
+  }
+};
+
+template <typename T, typename Alloc = std::allocator<T>>
+class ref_vector {
+  using base_vector = std::vector<T*, Alloc>;
+ public:
+  using value_type = T;
+  using allocator_type = Alloc;
+  using size_type = typename base_vector::size_type;
+  using difference_type = typename base_vector::difference_type;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using pointer = value_type*;
+  using const_pointer = const value_type*;
+  using iterator = mpl_iterator<typename base_vector::pointer, ref_vector_tag>;
+  using const_iterator = mpl_iterator<typename base_vector::const_pointer, ref_vector_tag>;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  ref_vector() noexcept = default;
+
+  explicit ref_vector(const allocator_type &alloc) noexcept
+      : base(alloc) {}
+
+  // There shouldn't be any situation that initialize this with all the same reference. Maybe an initial small size.
+  explicit ref_vector(size_type count, const value_type &value,
+                      const allocator_type &alloc = allocator_type()) = delete;
+  explicit ref_vector(size_type count, const allocator_type &alloc = allocator_type()) = delete;
+
+  // The pointer is stored in the base, and the Iter owns objects instead of their pointers.
+  template <typename Iter>
+  ref_vector(Iter first, Iter last, const allocator_type &alloc = allocator_type()) = delete;
+
+  ref_vector(const ref_vector &other)
+      : base(other.base) {}
+
+  ref_vector(const ref_vector &other, const allocator_type &alloc)
+      : base(other.base, alloc) {}
+
+  ref_vector(ref_vector &&other) noexcept
+      : base(std::move(other)) {}
+
+  ref_vector(ref_vector &&other, const allocator_type &alloc) noexcept
+      : base(std::move(other), alloc) {}
+
+  ref_vector(std::initializer_list<value_type> init, const allocator_type &alloc = allocator_type()) = delete;
+
+  ~ref_vector() noexcept = default;
+
+  ref_vector &operator=(const ref_vector &other) {
+    base = other.base;
+    return *this;
+  }
+
+  ref_vector &operator=(ref_vector &&other) noexcept {
+    base = std::move(other);
+  }
+
+  ref_vector &operator=(std::initializer_list<value_type> init) = delete;
+
+  void assign(size_type count, const value_type &value) = delete;
+
+  // The pointer is stored in the base, and the Iter owns objects instead of their pointers.
+  template <typename Iter>
+  void assign(Iter first, Iter last) = delete;
+
+  void assign(std::initializer_list<value_type> init) = delete;
+
+  allocator_type get_allocator() const {
+    return base.get_allocator();
+  }
+
+  iterator begin() noexcept {
+    return iterator(base.begin());
+  }
+
+  const_iterator begin() const noexcept {
+    return const_iterator(base.begin());
+  }
+
+  iterator end() noexcept {
+    return iterator(base.end());
+  }
+
+  const_iterator end() const noexcept {
+    return const_iterator(base.end());
+  }
+
+  reverse_iterator rbegin() noexcept {
+    return reverse_iterator(base.rbegin());
+  }
+
+  const_reverse_iterator rbegin() const noexcept {
+    return const_reverse_iterator(base.rbegin());
+  }
+
+  reverse_iterator rend() noexcept {
+    return reverse_iterator(base.rend());
+  }
+
+  const_reverse_iterator rend() const noexcept {
+    return const_reverse_iterator(base.rend());
+  }
+
+  const_iterator cbegin() const noexcept {
+    return const_iterator(base.cbegin());
+  }
+
+  const_iterator cend() const noexcept {
+    return const_iterator(base.cend());
+  }
+
+  const_reverse_iterator crbegin() const noexcept {
+    return const_reverse_iterator(base.crbegin());
+  }
+
+  const_reverse_iterator crend() const noexcept {
+    return const_reverse_iterator(base.crend());
+  }
+
+  reference front() noexcept {
+    return *begin();
+  }
+
+  const_reference front() const noexcept {
+    return *begin();
+  }
+
+  reference back() noexcept {
+    return *(end() - 1);
+  }
+
+  const_reference back() const noexcept {
+    return *(end() - 1);
+  }
+
+  pointer data() noexcept = delete;
+
+  const_pointer data() const noexcept = delete;
+
+  reference at(size_type pos) {
+    return *(base.at(pos));
+  }
+
+  const_reference at(size_type pos) const {
+    return *(base.at(pos));
+  }
+
+  reference operator[](size_type pos) noexcept {
+    return *(base[pos]);
+  }
+
+  const_reference operator[](size_type pos) const noexcept {
+    return *(base[pos]);
+  }
+
+  bool empty() const noexcept {
+    return base.empty();
+  }
+
+  size_type size() const noexcept {
+    return base.size();
+  }
+
+  size_type max_size() const noexcept {
+    return base.max_size();
+  }
+
+  size_type capacity() const noexcept {
+    return base.capacity();
+  }
+
+  void resize(size_type n) {
+    base.resize(n);
+  }
+
+  void resize(size_type n, value_type &value) = delete;
+
+  void reserve(size_type n) {
+    base.reserve(n);
+  }
+
+  void shrink_to_fit() {
+    base.shrink_to_fit();
+  }
+
+  void push_back(value_type &value) {
+    base.push_back(&value);
+  }
+
+  void push_back(value_type &&value) = delete;
+
+  template <typename... Args>
+  void emplace_back(Args &&... args) = delete;
+
+  void pop_back() noexcept {
+    base.pop_back();
+  }
+
+  iterator insert(const_iterator pos, value_type &value) {
+    return base.insert(pos, &value);
+  }
+
+  iterator insert(const_iterator pos, value_type &&value) = delete;
+
+  template <typename Iter>
+  iterator insert(const_iterator pos, Iter first, Iter last) = delete;
+
+  iterator insert(const_iterator pos, std::initializer_list<value_type> init) = delete;
+
+  template <typename... Args>
+  iterator emplace(const_iterator pos, Args &&... args) = delete;
+
+  iterator erase(const_iterator pos) {
+    return iterator(base.erase(pos));
+  }
+
+  iterator erase(const_iterator first, const_iterator last) {
+    return iterator(first.base(), last.base());
+  }
+
+  void swap(ref_vector &other) noexcept {
+    base.swap(other.base);
+  }
+
+  void clear() noexcept {
+    base.clear();
+  }
+
+ private:
+  base_vector base;
+};
+
+template <typename T, typename Alloc>
+inline bool operator==(const ref_vector<T, Alloc> &lhs, const ref_vector<T, Alloc> &rhs) {
+  return (lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin()));
+}
+
+template <typename T, typename Alloc>
+inline bool operator!=(const ref_vector<T, Alloc> &lhs, const ref_vector<T, Alloc> &rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename T, typename Alloc>
+inline bool operator<(const ref_vector<T, Alloc> &lhs, const ref_vector<T, Alloc> &rhs) {
+  return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+template <typename T, typename Alloc>
+inline bool operator>(const ref_vector<T, Alloc> &lhs, const ref_vector<T, Alloc> &rhs) {
+  return rhs < lhs;
+}
+
+template <typename T, typename Alloc>
+inline bool operator<=(const ref_vector<T, Alloc> &lhs, const ref_vector<T, Alloc> &rhs) {
+  return !(rhs < lhs);
+}
+
+template <typename T, typename Alloc>
+inline bool operator>=(const ref_vector<T, Alloc> &lhs, const ref_vector<T, Alloc> &rhs) {
+  return !(lhs < rhs);
+}
+}}
+
+namespace std {
+template <typename T, typename Alloc>
+inline void swap(maple::utils::ref_vector<T, Alloc> &lhs, maple::utils::ref_vector<T, Alloc> &rhs) noexcept {
+  lhs.swap(rhs);
+}
+}
+#endif
diff --git a/src/mapleall/maple_util/include/version.h b/src/mapleall/maple_util/include/version.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a4a47b09df4ab425be31d16d8d5afe045e48e46
--- /dev/null
+++ b/src/mapleall/maple_util/include/version.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef VERSION_H
+#define VERSION_H
+#include <cstdint>
+#include <string>
+#include "securec.h"
+class Version {
+ public:
+  static std::string GetVersionStr() {
+    std::ostringstream oss;
+    oss << kMajorVersion << "." << kMinorVersion << "." << kReleaseVersion;
+
+#ifdef BUILD_VERSION
+    constexpr int BUILD_VERSION_LEN = 5;
+    char buffer[BUILD_VERSION_LEN] = {0};
+    int ret = sprintf_s(buffer, BUILD_VERSION_LEN, "B%03u", kBuildVersion);
+    if (ret >= 0) {
+      oss << "." << buffer;
+    }
+#endif // BUILD_VERSION
+
+#ifdef GIT_REVISION
+    oss << " " << kGitRevision;
+#endif // GIT_REVISION
+    return oss.str();
+  }
+
+  static inline uint32_t GetMajorVersion() {
+    return kMajorVersion;
+  }
+
+  static inline uint32_t GetMinorVersion() {
+    return kMinorVersion;
+  }
+
+  static inline const char* GetReleaseVersion() {
+    return kReleaseVersion;
+  }
+
+  static inline uint32_t GetRuntimeVersion() {
+    return kMinorRuntimeVersion;
+  }
+ private:
+#ifdef ANDROID
+  // compatible for Android build script
+  static constexpr const uint32_t kMajorMplVersion = 4;
+#endif
+
+#ifdef ANDROID
+  // compatible for Android build script
+  static constexpr const uint32_t kMajorVersion = 4;
+#elif MAJOR_VERSION
+  static constexpr const uint32_t kMajorVersion = MAJOR_VERSION;
+#else // MAJOR_VERSION
+  static constexpr const uint32_t kMajorVersion = 1;
+#endif // ANDROID
+
+#ifdef MINOR_VERSION
+  static constexpr const uint32_t kMinorVersion = MINOR_VERSION;
+#else
+  static constexpr const uint32_t kMinorVersion = 0;
+#endif // MINOR_VERSION
+
+// [a-zA-Z0-9_\-]+
+#ifdef RELEASE_VERSION
+  static constexpr const char* kReleaseVersion = RELEASE_VERSION;
+#else
+  static constexpr const char* kReleaseVersion = "0";
+#endif // RELEASE_VERSION
+
+// B[0-9]{3}
+#ifdef BUILD_VERSION
+  static constexpr const uint32_t kBuildVersion = BUILD_VERSION;
+#endif // BUILD_VERSION
+
+#ifdef GIT_REVISION
+  static constexpr const char* kGitRevision = GIT_REVISION;
+#endif // GIT_REVISION
+
+#ifdef MINOR_RUNTIME_VERSION
+  static constexpr const uint32_t kMinorRuntimeVersion = MINOR_RUNTIME_VERSION;
+#else
+  static constexpr const uint32_t kMinorRuntimeVersion = 0;
+#endif // kMinorRuntimeVersion
+};
+#endif // VERSION_H
diff --git a/src/mapleall/maple_util/include/white_list.def b/src/mapleall/maple_util/include/white_list.def
new file mode 100644
index 0000000000000000000000000000000000000000..7ea27fede38d15e6317f912915c2880a3aac8d00
--- /dev/null
+++ b/src/mapleall/maple_util/include/white_list.def
@@ -0,0 +1,496 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+CLASS_PREFIX(Ljava_2Flang_2FOutOfMemoryError_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThreadGroup_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThread_3B)
+CLASS_PREFIX(Llibcore_2Futil_2FEmptyArray_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_3B)
+CLASS_PREFIX(Ljava_2Flang_2FFloat_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FDirectByteBuffer_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FVMRuntime_3B)
+CLASS_PREFIX(Ljava_2Futil_2FProperties_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDouble_3B)
+CLASS_PREFIX(Ljava_2Flang_2FMath_3B)
+CLASS_PREFIX(Llibcore_2Fio_2FLibcore_3B)
+CLASS_PREFIX(Llibcore_2Ficu_2FICU_3B)
+CLASS_PREFIX(Ljava_2Flang_2FAndroidHardcodedSystemProperties_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FReferenceQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2FArrayList_3B)
+CLASS_PREFIX(Ljava_2Flang_2FRuntime_3B)
+CLASS_PREFIX(Landroid_2Fsystem_2FOsConstants_3B)
+CLASS_PREFIX(Ljava_2Flang_2FInteger_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FUnsafe_3B)
+//CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B)
+//CLASS_PREFIX(Lsun_2Futil_2Flocale_2FBaseLocale_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flocale_2FBaseLocale_24Key_3B)
+//CLASS_PREFIX(Ljava_2Futil_2FLocale_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flocale_2FLanguageTag_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FVersion_3B)
+CLASS_PREFIX(Ljava_2Fio_2FFileDescriptor_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FCloseGuard_3B)
+CLASS_PREFIX(Ljava_2Flang_2FEnum_3B)
+CLASS_PREFIX(Llibcore_2Fio_2FIoTracker_24Mode_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceFieldUpdater_24AtomicReferenceFieldUpdaterImpl_3B)
+CLASS_PREFIX(Ljava_2Fio_2FBufferedInputStream_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FVM_3B)
+CLASS_PREFIX(Ljava_2Flang_2FSystem_3B)
+CLASS_PREFIX(Ljava_2Fio_2FFileSystem_3B)
+CLASS_PREFIX(Ljava_2Fio_2FUnixFileSystem_3B)
+CLASS_PREFIX(Ljava_2Fio_2FFile_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fregex_2FPattern_3B)
+CLASS_PREFIX(Ljava_2Fio_2FFile_24PathStatus_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThreadLocal_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FBlockGuard_3B)
+CLASS_PREFIX(Ljava_2Flang_2FString_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FBaseDexClassLoader_3B)
+CLASS_PREFIX(Ljava_2Flang_2FClassLoader_24SystemClassLoader_3B)
+CLASS_PREFIX(Ljava_2Flang_2FByte_3B)
+CLASS_PREFIX(Ljava_2Flang_2FInteger_24IntegerCache_3B)
+CLASS_PREFIX(Ljava_2Futil_2FUUID_3B)
+CLASS_PREFIX(Ljava_2Futil_2FHashSet_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharset_3B)
+CLASS_PREFIX(Llibcore_2Ficu_2FNativeConverter_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCodingErrorAction_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FCleaner_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteOrder_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FBits_3B)
+CLASS_PREFIX(Ljava_2Fio_2FBufferedReader_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCoderResult_3B)
+CLASS_PREFIX(Ljava_2Flang_2FLong_3B)
+CLASS_PREFIX(Ljava_2Flang_2FShort_3B)
+CLASS_PREFIX(Ljava_2Flang_2FCharacter_3B)
+CLASS_PREFIX(Ljava_2Flang_2FBoolean_3B)
+CLASS_PREFIX(Ljava_2Flang_2FStringBuffer_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FChunkHandler_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FDdmServer_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicBoolean_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCacheValue_24Strength_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCacheValue_3B)
+CLASS_PREFIX(Ljava_2Futil_2FLocale_24NoImagePreloadHolder_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FULocale_24Category_3B)
+CLASS_PREFIX(Ljava_2Futil_2FLocale_24Category_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FULocale_24JDKLocaleHelper_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FULocale_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNumberingSystem_3B)
+CLASS_PREFIX(Ljava_2Futil_2FResourceBundle_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FUResourceBundle_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeBin_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FVersionInfo_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUDebug_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24OpenType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FURI_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FZipFile_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fjar_2FJarFile_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FStandardCharsets_3B)
+CLASS_PREFIX(Ljava_2Futil_2FWeakHashMap_3B)
+CLASS_PREFIX(Ljava_2Futil_2FArrayDeque_3B)
+CLASS_PREFIX(Ljava_2Flang_2FVMClassLoader_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B)
+CLASS_PREFIX(Ljava_2Futil_2FBitSet_3B)
+CLASS_PREFIX(Lsun_2Fnet_2Fwww_2FParseUtil_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FURL_3B)
+CLASS_PREFIX(Ljava_2Flang_2FCaseMapper_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FURLConnection_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FInflater_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUConfig_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fchannels_2FFileChannel_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FNativeThreadSet_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fchannels_2FFileChannel_24MapMode_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FFileChannelImpl_24Unmapper_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUBinary_24DatPackageReader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUBinary_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsCharBuffer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FUResourceBundle_24RootType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUResource_24Key_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCurrencyData_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTreeSet_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTreeMap_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FBMPSet_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FMeasureUnit_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FLocaleIDs_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FCurrency_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUtility_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyFilter_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_24SpacingType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_24SpacingPattern_3B)
+CLASS_PREFIX(Ljava_2Flang_2FVoid_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThread_24State_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FAnnotationMember_24DefaultValues_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FAnnotationMember_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fannotation_2FAnnotation_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FAnnotationFactory_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLong_3B)
+//CLASS_PREFIX(Ljava_2Flang_2Freflect_2FProxy_24ProxyClassFactory_3B)
+CLASS_PREFIX(Ljava_2Flang_2Freflect_2FProxy_3B)
+//CLASS_PREFIX(Ljava_2Flang_2Freflect_2FWeakCache_24CacheKey_3B)
+CLASS_PREFIX(Ljava_2Flang_2Freflect_2FWeakCache_24Factory_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTimSort_3B)
+CLASS_PREFIX(Ljava_2Flang_2Freflect_2FMethod_3B)
+CLASS_PREFIX(Ljava_2Futil_2FHashMap_24TreeNode_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24EmptyIterator_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Flang_2FUScript_24ScriptUsage_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Flang_2FUScript_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsIntBuffer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUPropertyAliases_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FBytesTrie_24Result_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Flang_2FUScript_24ScriptMetadata_3B)
+CLASS_PREFIX(Lorg_2Fxmlpull_2Fv1_2FXmlPullParser_3B)
+//CLASS_PREFIX(Lorg_2Fkxml2_2Fio_2FKXmlParser_3B)
+//CLASS_PREFIX(Lorg_2Fkxml2_2Fio_2FKXmlParser_24ValueContext_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fregex_2FMatcher_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFloatingDecimal_24ExceptionalBinaryToASCIIBuffer_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFloatingDecimal_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFloatingDecimal_24ASCIIToBinaryBuffer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FTrie_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCharTrie_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUCache_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_24Level_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUService_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FStringPrep_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FStringPrepDataReader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FTrie2_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FTrie2_24ValueWidth_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUBiDiProps_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FIDNA2003_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24NFKCSingleton_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FPatternProps_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FStandardPlural_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FPluralRulesLoader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUCaseProps_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fmath_2FMathContext_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fmath_2FBigDecimal_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FBreakIterator_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FBreakIteratorFactory_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FCaseMap_24Upper_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNumberFormat_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDisplayContext_24Type_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDisplayContext_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNormalizer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNormalizer_24NFKDModeImpl_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNumberFormat_24Field_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_24Operand_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_24PluralType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_24SampleType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_24SimpleTokenizer_3B)
+//CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FRBBIDataWrapper_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24LookAheadResults_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FStringPrepParseException_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24NameType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FCurrency_24CurrencyUsage_3B)
+CLASS_PREFIX(Ljava_2Futil_2FEnumMap_3B)
+//CLASS_PREFIX(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FProxySelector_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FSSLSocketFactory_3B)
+CLASS_PREFIX(Landroid_2Fsystem_2FUnixSocketAddress_3B)
+CLASS_PREFIX(Ljava_2Flang_2FLong_24LongCache_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLevel_24KnownLevel_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLevel_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FHandler_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FReference_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FWeakReference_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_3B)
+CLASS_PREFIX(Llibcore_2Fnet_2Fevent_2FNetworkEventDispatcher_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FAbstractExecutorService_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReference_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FHttpURLConnection_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDebug_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FProvider_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCalendar_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FSocketTagger_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FVMDebug_3B)
+CLASS_PREFIX(Ljava_2Fio_2FConsole_3B)
+CLASS_PREFIX(Ljava_2Fio_2FObjectStreamConstants_3B)
+CLASS_PREFIX(Ljava_2Fio_2FObjectInputStream_3B)
+CLASS_PREFIX(Ljava_2Fio_2FObjectStreamClass_3B)
+CLASS_PREFIX(Ljava_2Flang_2FByte_24ByteCache_3B)
+CLASS_PREFIX(Ljava_2Flang_2FCharacter_24CharacterCache_3B)
+CLASS_PREFIX(Ljava_2Flang_2FCharacter_24UnicodeBlock_3B)
+CLASS_PREFIX(Ljava_2Flang_2FClass_24Caches_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FFinalizerReference_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDaemons_24FinalizerDaemon_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDaemons_24FinalizerWatchdogDaemon_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDaemons_24HeapTaskDaemon_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDaemons_24ReferenceQueueDaemon_3B)
+CLASS_PREFIX(Ljava_2Futil_2FRandom_3B)
+CLASS_PREFIX(Ljava_2Flang_2FMath_24RandomNumberGeneratorHolder_3B)
+CLASS_PREFIX(Ljava_2Flang_2FPackage_3B)
+CLASS_PREFIX(Ljava_2Flang_2FProcessBuilder_3B)
+CLASS_PREFIX(Ljava_2Flang_2FProcessEnvironment_3B)
+CLASS_PREFIX(Ljava_2Flang_2FShort_24ShortCache_3B)
+CLASS_PREFIX(Ljava_2Flang_2FStrictMath_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThread_24Caches_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThrowable_24SentinelHolder_3B)
+CLASS_PREFIX(Ljava_2Flang_2FUNIXProcess_24ProcessReaperThreadFactory_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_3B)
+CLASS_PREFIX(Ljava_2Flang_2FUNIXProcess_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodHandleStatics_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FCallSite_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodHandle_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodHandles_24Lookup_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodType_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodTypeForm_3B)
+CLASS_PREFIX(Ljava_2Flang_2Freflect_2FMethod_241_3B)
+CLASS_PREFIX(Llibcore_2Fmath_2FMathUtils_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FBigInt_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FBigInteger_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FMultiplication_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FBigDecimal_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FRoundingMode_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInet6AddressImpl_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInetAddress_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInet4Address_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInet6Address_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInetSocketAddress_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FNetworkInterface_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FProxy_24Type_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FProxy_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FServerSocket_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FSocket_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FSocksSocketImpl_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FURLEncoder_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsDoubleBuffer_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsFloatBuffer_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsLongBuffer_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsShortBuffer_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fchannels_2FSocketChannel_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FCryptoPrimitive_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FKeyFactory_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FProvider_24Service_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FSecureRandom_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FSecurity_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FSignature_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FSignature_24Delegate_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FObjectIdentifier_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2Fspec_2FECPoint_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FAttributedCharacterIterator_24Attribute_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDateFormat_24Field_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDateFormatSymbols_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FNumberFormat_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDecimalFormat_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDecimalFormatSymbols_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDontCareFieldPosition_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FNormalizer_24Form_3B)
+CLASS_PREFIX(Ljava_2Futil_2FEnumSet_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FSimpleDateFormat_3B)
+CLASS_PREFIX(Ljava_2Futil_2FArrays_24NaturalOrder_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24CopiesList_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24EmptyEnumeration_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24EmptyListIterator_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24ReverseComparator_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24ReverseComparator2_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24UnmodifiableNavigableMap_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24UnmodifiableNavigableSet_3B)
+CLASS_PREFIX(Ljava_2Futil_2FComparableTimSort_3B)
+CLASS_PREFIX(Ljava_2Futil_2FComparators_24NaturalOrderComparator_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCurrency_3B)
+CLASS_PREFIX(Lsun_2Futil_2Fcalendar_2FCalendarSystem_3B)
+CLASS_PREFIX(Ljava_2Futil_2FDate_3B)
+CLASS_PREFIX(Ljava_2Futil_2FFormatter_24Flags_3B)
+CLASS_PREFIX(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B)
+CLASS_PREFIX(Ljava_2Futil_2FGregorianCalendar_3B)
+CLASS_PREFIX(Ljava_2Futil_2FLocale_24FilteringMode_3B)
+CLASS_PREFIX(Ljava_2Futil_2FSimpleTimeZone_3B)
+CLASS_PREFIX(Ljava_2Futil_2FSpliterators_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24Node_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FExecutors_24DefaultThreadFactory_3B)
+// CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FFutureTask_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_24SNode_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceArray_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24Node_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Flocks_2FLockSupport_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_3B)
+//CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogManager_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogManager_242_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogRecord_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogger_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLoggingProxyImpl_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fprefs_2FPreferences_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B)
+//CLASS_PREFIX(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fregex_2FPatternSyntaxException_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FStreamOpFlag_24Type_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FStreamOpFlag_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FStreamShape_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FAdler32_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FCRC32_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FDeflater_3B)
+CLASS_PREFIX(Ljavax_2Fcrypto_2FCipher_24InitType_3B)
+CLASS_PREFIX(Ljavax_2Fcrypto_2FCipher_24NeedToSet_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FHttpsURLConnection_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FSNIServerName_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FSSLServerSocketFactory_3B)
+CLASS_PREFIX(Ljavax_2Fsecurity_2Fcert_2FX509Certificate_3B)
+CLASS_PREFIX(Llibcore_2Ficu_2FLocaleData_3B)
+//CLASS_PREFIX(Llibcore_2Fio_2FDropBox_3B)
+//CLASS_PREFIX(Llibcore_2Fio_2FEventLogger_3B)
+CLASS_PREFIX(Llibcore_2Fnet_2FNetworkSecurityPolicy_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FListOfTypes_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FTypes_3B)
+CLASS_PREFIX(Llibcore_2Futil_2FZoneInfo_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B)
+CLASS_PREFIX(Lorg_2Fjson_2FJSONObject_3B)
+CLASS_PREFIX(Lorg_2Fjson_2FJSONStringer_24Scope_3B)
+CLASS_PREFIX(Lsun_2Finvoke_2Futil_2FVerifyAccess_3B)
+CLASS_PREFIX(Lsun_2Finvoke_2Futil_2FWrapper_24Format_3B)
+CLASS_PREFIX(Lsun_2Finvoke_2Futil_2FWrapper_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFDBigInteger_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFormattedFloatingDecimal_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFormattedFloatingDecimal_24Form_3B)
+CLASS_PREFIX(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_24NonProxyInfo_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FFileLockImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FIOUtil_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FNet_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FSharedFileLockTable_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FUtil_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FUtil_24BufferCache_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fjca_2FProviderConfig_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fjca_2FProviderList_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FCertificateExtensions_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attribute_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FAlgorithmDecomposer_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraints_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2FX509Factory_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdaptableX509CertSelector_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraint_24Operator_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FConstraintsChecker_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FKeyChecker_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIXCertPathValidator_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIXMasterCertPathValidator_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FBitArray_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDerOutputStream_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FAVA_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FX500Name_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FAVAKeyword_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FAccessDescription_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FAlgorithmId_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2Fcert_2FCRLReason_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FCRLReasonCodeExtension_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FDistributionPoint_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FExtendedKeyUsageExtension_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FInhibitAnyPolicyExtension_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FNetscapeCertTypeExtension_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FPKIXExtensions_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FOIDMap_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B)
+CLASS_PREFIX(Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flogging_2FLoggingSupport_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flogging_2FPlatformLogger_24Level_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flogging_2FPlatformLogger_3B)
+CLASS_PREFIX(Ljava_2Fio_2FBufferedWriter_3B)
+//CLASS_PREFIX(Lsun_2Fsecurity_2Fjca_2FProviders_3B)
+//CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_3B)
+CLASS_PREFIX(Ljava_2Futil_2FScanner_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FCollectors_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FNodes_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FReferencePipeline_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTaskQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTimer_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTimerThread_3B)
+//CLASS_PREFIX(Ljavax_2Fcrypto_2FJceSecurity_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FSNIHostName_3B)
+CLASS_PREFIX(Ljavax_2Fxml_2Fparsers_2FFilePathToURI_3B)
+//CLASS_PREFIX(Llibcore_2Ficu_2FTimeZoneNames_3B)
+CLASS_PREFIX(Llibcore_2Futil_2FHexEncoding_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FCommentImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentTypeImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FTextImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderImpl_3B)
+CLASS_PREFIX(Lsun_2Fnet_2FNetProperties_3B)
+CLASS_PREFIX(Lsun_2Fnet_2FProgressMonitor_3B)
+CLASS_PREFIX(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FNativeBuffer_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FNativeBuffers_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataReader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatin_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationLoader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRoot_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FCollator_3B)
+//CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDigitList_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FBytesTrie_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FTimeUnit_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FPathClassLoader_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FMessageFormat_3B)
+CLASS_PREFIX(Llibcore_2Fio_2FStreams_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FUnixNativeDispatcher_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FUnixPath_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FUtil_3B)
+CLASS_PREFIX(Lsun_2Futil_2Fcalendar_2FGregorian_3B)
+CLASS_PREFIX(Ljava_2Flang_2FInheritableThreadLocal_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FPhantomReference_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Ffile_2FFiles_3B)
+CLASS_PREFIX(Ljava_2Futil_2FIdentityHashMap_3B)
+CLASS_PREFIX(Ljava_2Futil_2FLinkedHashSet_3B)
+CLASS_PREFIX(Ljava_2Futil_2FRegularEnumSet_3B)
+//CLASS_PREFIX(Llibcore_2Futil_2FZoneInfoDB_3B)
+//CLASS_PREFIX(Ljava_2Flang_2FBootClassLoader_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodType_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B)
+CLASS_PREFIX(Ljava_2Flang_2FStringFactory_3B)
+CLASS_PREFIX(Ljava_2Flang_2FNumber_3B)
+CLASS_PREFIX(Ljava_2Futil_2FHashMap_3B)
diff --git a/src/mapleall/maple_util/src/cl_option.cpp b/src/mapleall/maple_util/src/cl_option.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad178ce0af7507cefccc18b802baf22c4edcb4e2
--- /dev/null
+++ b/src/mapleall/maple_util/src/cl_option.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cl_option.h"
+#include "cl_parser.h"
+
+using namespace maplecl;
+
+void OptionInterface::FinalizeInitialization(const std::vector<std::string> &optnames,
+                                             const std::string &descr,
+                                             const std::vector<OptionCategoryRefWrp> &optionCategories) {
+  optDescription = descr;
+  auto &cl = CommandLine::GetCommandLine();
+
+  std::copy(optnames.begin(), optnames.end(), std::back_inserter(names));
+
+  if (optionCategories.empty()) {
+    cl.Register(optnames, *this, cl.defaultCategory);
+  } else {
+    for (auto &cat : optionCategories) {
+      cl.Register(optnames, *this, cat.get());
+    }
+  }
+}
diff --git a/src/mapleall/maple_util/src/cl_option_parser.cpp b/src/mapleall/maple_util/src/cl_option_parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b25ec393123ad09209f288999cc87b9cf1ff911a
--- /dev/null
+++ b/src/mapleall/maple_util/src/cl_option_parser.cpp
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cl_option.h"
+#include "cl_parser.h"
+
+#include <cstdint>
+#include <ostream>
+#include <string>
+
+using namespace maplecl;
+
+/* ################################################################
+ * Utility Fuctions
+ * ################################################################ */
+
+/* Anonymous namespace to restrict visibility of utility functions */
+namespace {
+
+bool IsPrefixDetected(const std::string_view &opt) {
+  if (opt.substr(0, 2) == "--") {
+    return true;
+  }
+
+  /* It should be "--" or "-" */
+  return (opt[0] == '-');
+}
+
+/* NOTE: Returning ssize_t parameter is used to show how many command line arguments
+ * handled with this key. argsIndex must be incremented with this parameter outside of ExtractValue. */
+std::pair<RetCode, size_t> ExtractValue(size_t argsIndex,
+                                        const std::deque<std::string_view> &args,
+                                        const OptionInterface &opt, KeyArg &keyArg) {
+  /* The option like "--key= " does not contain a value after equal symbol */
+  if (keyArg.isEqualOpt && keyArg.val.empty()) {
+    return {RetCode::valueEmpty, 0};
+  }
+
+  bool canValBeSet = (keyArg.isEqualOpt || opt.IsJoinedValPermitted());
+  /* Value is parsed outside OptionType::Parse because it's the option
+   * like "--key=val" or joined option like -DValue */
+  if (canValBeSet && !keyArg.val.empty()) {
+    if (opt.ExpectedVal() == ValueExpectedType::kValueDisallowed) {
+      return {RetCode::unnecessaryValue, 0};
+    }
+    return {RetCode::noError, 0};
+  }
+
+  /* Need to parse second command line argument to check options value */
+  else {
+    /* Optional value can be set only with "=" like this --key=value  */
+    if (opt.ExpectedVal() == ValueExpectedType::kValueDisallowed ||
+        opt.ExpectedVal() == ValueExpectedType::kValueOptional) {
+      return {RetCode::noError, 0};
+    }
+
+    /* localArgsIndex is used to be sure that nobody breaks the logic by
+     * changing argsIndex to reference. original argsIndex must be not changed here. */
+    size_t localArgsIndex = argsIndex + 1;
+    /* Second command line argument does not exist */
+    if (localArgsIndex >= args.size() || args[localArgsIndex].empty()) {
+      RetCode ret = (opt.ExpectedVal() == ValueExpectedType::kValueRequired) ?
+        RetCode::valueEmpty : RetCode::noError;
+      return {ret, 0};
+    }
+
+    keyArg.val = args[localArgsIndex];
+    return {RetCode::noError, 1};
+  }
+}
+
+} /* Anonymous namespace  */
+
+/* ################################################################
+ * Option Value Parsers Implementation
+ * ################################################################ */
+
+template <> RetCode Option<bool>::ParseBool(size_t &argsIndex,
+                                            const std::deque<std::string_view> &args) {
+  /* DisabledName should set it to false, like --fno-omit-framepointer vs --fomit-framepointer */
+  auto disabledNames = GetDisabledName();
+  auto it = std::find(disabledNames.begin(), disabledNames.end(), args[argsIndex]);
+  SetValue(it == disabledNames.end());
+
+  ++argsIndex;
+  return RetCode::noError;
+}
+
+/* NOTE: argsIndex must be incremented only if option is handled successfully */
+template <> RetCode Option<std::string>::ParseString(size_t &argsIndex,
+                                                     const std::deque<std::string_view> &args,
+                                                     KeyArg &keyArg) {
+  RetCode err = RetCode::noError;
+  size_t indexIncCnt = 0;
+  std::tie(err, indexIncCnt) = ExtractValue(argsIndex, args, *this, keyArg);
+  if (err != RetCode::noError) {
+    return err;
+  }
+
+  if (keyArg.val.empty()) {
+    if (ExpectedVal() == ValueExpectedType::kValueRequired) {
+      return RetCode::valueEmpty;
+    }
+    ++argsIndex;
+    return RetCode::noError;
+  }
+
+  /* Value is not empty but ValueDisallowed is set */
+  if (ExpectedVal() == ValueExpectedType::kValueDisallowed) {
+    return RetCode::unnecessaryValue;
+  }
+
+  if (!keyArg.isEqualOpt && IsPrefixDetected(keyArg.val)) {
+    if (ExpectedVal() == ValueExpectedType::kValueRequired) {
+      return RetCode::valueEmpty;
+    }
+    ++argsIndex;
+    return RetCode::noError;
+  }
+
+  SetValue(std::string(keyArg.val));
+  if (keyArg.isEqualOpt && !keyArg.isJoinedOpt) {
+    /* isJoinedOpt is used to prevent -DMACRO=VALUE.
+     * -DMACRO=VALUE uses "=" sign but it's not the separator between Option and Value,
+     * In this case it's a part of Value.
+     */
+    SetEqualType(EqualType::kWithEqual);
+  }
+
+  argsIndex += 1 + indexIncCnt; // 1 for key, indexIncCnt for Key Value from ExtractValue
+  return RetCode::noError;
+}
+
+/* NOTE: argsIndex must be incremented only if option is handled successfully */
+template <typename T>
+RetCode Option<T>::ParseDigit(size_t &argsIndex,
+                              const std::deque<std::string_view> &args,
+                              KeyArg &keyArg) {
+  static_assert(digitalCheck<T>, "Expected (u)intXX types");
+
+  RetCode err = RetCode::noError;
+  size_t indexIncCnt = 0;
+  std::tie(err, indexIncCnt) = ExtractValue(argsIndex, args, *this, keyArg);
+  if (err != RetCode::noError) {
+    return err;
+  }
+
+  if (keyArg.val.empty()) {
+    if (ExpectedVal() == ValueExpectedType::kValueRequired) {
+      return RetCode::valueEmpty;
+    }
+    ++argsIndex;
+    return RetCode::noError;
+  }
+
+  /* Value is not empty but ValueDisallowed is set */
+  if (ExpectedVal() == ValueExpectedType::kValueDisallowed) {
+    return RetCode::unnecessaryValue;
+  }
+
+  T resDig = 0;
+  uint64_t udig = 0;
+  int64_t dig = 0;
+  char *endStrPtr;
+  errno = 0;
+  if constexpr(std::is_same_v<uint64_t, T> ||
+               std::is_same_v<uint32_t, T> ||
+               std::is_same_v<uint16_t, T> ||
+               std::is_same_v<uint8_t, T>) {
+    if (keyArg.val.data()[0] == '-') {
+      return RetCode::incorrectValue;
+    }
+
+    udig = std::strtoull(keyArg.val.data(), &endStrPtr, 0);
+    resDig = static_cast<T>(udig);
+  } else {
+    dig = std::strtoll(keyArg.val.data(), &endStrPtr, 0);
+    resDig = static_cast<T>(dig);
+  }
+
+  bool u32Type = std::is_same<T, uint32_t>::value;
+  bool i32Type = std::is_same<T, int32_t>::value;
+  bool u16Type = std::is_same<T, uint16_t>::value;
+  bool u8Type = std::is_same<T, uint8_t>::value;
+  bool i16Type = std::is_same<T, int16_t>::value;
+  bool i8Type = std::is_same<T, int8_t>::value;
+
+  if (*endStrPtr != '\0') {
+    return RetCode::incorrectValue;
+  }
+
+  if (errno != 0) {
+    return RetCode::outOfRange;
+  }
+
+  if (u32Type && udig > UINT32_MAX) {
+    return RetCode::outOfRange;
+  }
+
+  if (i32Type && (dig > INT32_MAX || dig < INT32_MIN)) {
+    return RetCode::outOfRange;
+  }
+
+  if (u16Type && udig > UINT16_MAX) {
+    return RetCode::outOfRange;
+  }
+
+  if (i16Type && (dig > INT16_MAX || dig < INT16_MIN)) {
+    return RetCode::outOfRange;
+  }
+
+  if (u8Type && udig > UINT8_MAX) {
+    return RetCode::outOfRange;
+  }
+
+  if (i8Type && (dig > INT8_MAX || dig < INT8_MIN)) {
+    return RetCode::outOfRange;
+  }
+
+  SetValue(resDig);
+  if (keyArg.isEqualOpt && !keyArg.isJoinedOpt) {
+    /* isJoinedOpt is used to prevent -DMACRO=VALUE.
+     * -DMACRO=VALUE uses "=" sign but it's not the separator between Option and Value,
+     * In this case it's a part of Value.
+     */
+    SetEqualType(EqualType::kWithEqual);
+  }
+
+  argsIndex += 1 + indexIncCnt; // 1 for key, indexIncCnt for Key Value from ExtractValue
+  return RetCode::noError;
+}
+
+/* Needed to describe OptionType<>::Parse template in this .cpp file */
+template class maplecl::Option<uint8_t>;
+template class maplecl::Option<uint16_t>;
+template class maplecl::Option<uint32_t>;
+template class maplecl::Option<uint64_t>;
+template class maplecl::Option<int8_t>;
+template class maplecl::Option<int16_t>;
+template class maplecl::Option<int32_t>;
+template class maplecl::Option<int64_t>;
\ No newline at end of file
diff --git a/src/mapleall/maple_util/src/cl_parser.cpp b/src/mapleall/maple_util/src/cl_parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d9c3eca06690417ef08784364a517e8785e265a
--- /dev/null
+++ b/src/mapleall/maple_util/src/cl_parser.cpp
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "cl_option.h"
+#include "cl_parser.h"
+
+#include "mpl_logging.h"
+
+
+using namespace maplecl;
+
+CommandLine &CommandLine::GetCommandLine() {
+  static CommandLine cl;
+  return cl;
+}
+
+OptionInterface *CommandLine::CheckJoinedOption(KeyArg &keyArg, OptionCategory &optCategory) {
+  auto &str = keyArg.rawArg;
+
+  for (auto joinedOption : optCategory.joinedOptions) {
+    /* Joined Option (like -DMACRO) can be detected as substring (-D) in the option string */
+    if (str.find(joinedOption.first) == 0) {
+      size_t keySize = joinedOption.first.size();
+
+      keyArg.val = str.substr(keySize);
+      keyArg.key = str.substr(0, keySize);
+      keyArg.isJoinedOpt = true;
+      return joinedOption.second;
+    }
+  }
+
+  return nullptr;
+}
+
+RetCode CommandLine::ParseJoinedOption(size_t &argsIndex,
+                                       const std::deque<std::string_view> &args,
+                                       KeyArg &keyArg, OptionCategory &optCategory) {
+  OptionInterface *option = CheckJoinedOption(keyArg, optCategory);
+  if (option != nullptr) {
+    RetCode err = option->Parse(argsIndex, args, keyArg);
+    if (err != RetCode::noError) {
+      return err;
+    }
+
+    /* Set Option in all categories registering for this option */
+    for (auto &category : option->optCategories) {
+      category->AddEnabledOption(option);
+    }
+  } else {
+    return RetCode::notRegistered;
+  }
+
+  return RetCode::noError;
+}
+
+RetCode CommandLine::ParseOption(size_t &argsIndex,
+                                 const std::deque<std::string_view> &args,
+                                 KeyArg &keyArg, const OptionCategory &optCategory,
+                                 OptionInterface *opt) {
+  RetCode err = opt->Parse(argsIndex, args, keyArg);
+  if (err != RetCode::noError) {
+    return err;
+  }
+
+  /* Set Option in all categories registering for this option */
+  for (auto &category : opt->optCategories) {
+    category->AddEnabledOption(opt);
+  }
+
+  return RetCode::noError;
+}
+
+RetCode CommandLine::ParseEqualOption(size_t &argsIndex,
+                                      const std::deque<std::string_view> &args,
+                                      KeyArg &keyArg, OptionCategory &optCategory,
+                                      const OptionsMapType &optMap, ssize_t pos) {
+  keyArg.isEqualOpt = true;
+  auto &arg = args[argsIndex];
+
+  /* To handle joined option, we must have full (not splitted key),
+   * because joined option splitting is different:
+   * As example for -Dkey=value: default splitting key="Dkey" value="value",
+   * Joined option splitting key="D" value="key=value"
+   */
+  auto item = optMap.find(std::string(arg.substr(0, pos)));
+  if (item != optMap.end()) {
+    /* equal option, like --key=value */
+    keyArg.key = arg.substr(0, pos);
+    keyArg.val = arg.substr(pos + 1);
+    return ParseOption(argsIndex, args, keyArg, optCategory, item->second);
+  } else {
+    /* It can be joined option, like: -DMACRO=VALUE */
+    return ParseJoinedOption(argsIndex, args, keyArg, optCategory);
+  }
+}
+
+RetCode CommandLine::ParseSimpleOption(size_t &argsIndex,
+                                       const std::deque<std::string_view> &args,
+                                       KeyArg &keyArg, OptionCategory &optCategory,
+                                       const OptionsMapType &optMap) {
+  keyArg.isEqualOpt = false;
+  auto &arg = args[argsIndex];
+
+  auto item = optMap.find(std::string(arg));
+  if (item != optMap.end()) {
+    /* --key or --key value */
+    return ParseOption(argsIndex, args, keyArg, optCategory, item->second);
+  } else {
+    /* It can be joined option, like: -DMACRO */
+    return ParseJoinedOption(argsIndex, args, keyArg, optCategory);
+  }
+}
+
+RetCode CommandLine::HandleInputArgs(const std::deque<std::string_view> &args,
+                                     OptionCategory &optCategory) {
+  RetCode err = RetCode::noError;
+
+  /* badCLArgs contains option parsing errors for each incorrect option.
+   * We should clear old badCLArgs results. */
+  badCLArgs.clear();
+
+  bool wasError = false;
+  for (size_t argsIndex = 0; argsIndex < args.size();) {
+    auto &arg = args[argsIndex];
+    if (arg == "") {
+      ++argsIndex;
+      continue;
+    }
+
+    KeyArg keyArg(arg);
+
+    auto pos = arg.find('=');
+    /* option like --key=value */
+    if (pos != std::string::npos) {
+      ASSERT(pos > 0, "CG internal error, composite unit with less than 2 unit elements.");
+      err = ParseEqualOption(argsIndex, args, keyArg, optCategory, optCategory.options, pos);
+      if (err != RetCode::noError) {
+        badCLArgs.emplace_back(args[argsIndex], err);
+        ++argsIndex;
+        wasError = true;
+      }
+      continue;
+    }
+
+    /* option like "--key value" or "--key" */
+    else {
+      err = ParseSimpleOption(argsIndex, args, keyArg, optCategory, optCategory.options);
+      if (err != RetCode::noError) {
+        badCLArgs.emplace_back(args[argsIndex], err);
+        ++argsIndex;
+        wasError = true;
+      }
+      continue;
+    }
+    continue;
+  }
+
+  if (wasError) {
+    return RetCode::parsingErr;
+  }
+
+  return err;
+}
+
+RetCode CommandLine::Parse(int argc, char **argv, OptionCategory &optCategory) {
+  if (argc > 0) {
+    --argc;
+    ++argv;  // skip program name argv[0] if present
+  }
+
+  if (argc == 0 || *argv == nullptr) {
+    return RetCode::noError;
+  }
+
+  std::deque<std::string_view> args;
+  while (argc != 0 && *argv != nullptr) {
+    args.emplace_back(*argv);
+    ++argv;
+    --argc;
+  }
+
+  return HandleInputArgs(args, optCategory);
+}
+
+void CommandLine::Register(const std::vector<std::string> &optNames,
+                           OptionInterface &opt, OptionCategory &optCategory) {
+  for (auto &optName : optNames) {
+    if (optName.empty()) {
+      continue;
+    }
+
+    ASSERT(optCategory.options.count(optName) == 0, "Duplicated options name %s", optName.data());
+    optCategory.options.emplace(optName, &opt);
+
+    if (opt.IsJoinedValPermitted()) {
+      optCategory.joinedOptions.emplace(optName, &opt);
+    }
+  }
+
+  auto &disabledWith = opt.GetDisabledName();
+  if (!disabledWith.empty()) {
+    for (auto &disabledName : disabledWith) {
+      ASSERT(optCategory.options.count(disabledName) == 0, "Duplicated options name %s", disabledName.data());
+      optCategory.options.emplace(disabledName, &opt);
+    }
+  }
+
+  optCategory.registredOptions.push_back(&opt);
+  opt.optCategories.push_back(&optCategory);
+}
+
+void CommandLine::Clear(OptionCategory &optCategory) {
+  for (auto &opt : optCategory.registredOptions) {
+    opt->Clear();
+  }
+}
+
+void CommandLine::BashCompletionPrinter(const OptionCategory &optCategory) const {
+  for (auto &opt : optCategory.options) {
+    maple::LogInfo::MapleLogger() << opt.first << '\n';
+  }
+}
+
+void CommandLine::HelpPrinter(const OptionCategory &optCategory) const {
+  for (auto &opt : optCategory.registredOptions) {
+    if (opt->IsVisibleOption()) {
+      maple::LogInfo::MapleLogger() << opt->GetDescription() << '\n';
+    }
+  }
+}
diff --git a/src/mapleall/maple_util/src/error_code.cpp b/src/mapleall/maple_util/src/error_code.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..63ce5f25485754ffd45716165ecf90d72a73c2e7
--- /dev/null
+++ b/src/mapleall/maple_util/src/error_code.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include<error_code.h>
+#include "mpl_logging.h"
+
+namespace maple {
+void PrintErrorMessage(int ret) {
+  switch (ret) {
+    case kErrorNoError:
+    case kErrorExitHelp:
+      break;
+    case kErrorExit:
+      ERR(kLncErr, "Error Exit!");
+      break;
+    case kErrorInvalidParameter:
+      ERR(kLncErr, "Invalid Parameter!");
+      break;
+    case kErrorInitFail:
+      ERR(kLncErr, "Init Fail!");
+      break;
+    case kErrorFileNotFound:
+      ERR(kLncErr, "File Not Found!");
+      break;
+    case kErrorToolNotFound:
+      ERR(kLncErr, "Tool Not Found!");
+      break;
+    case kErrorCompileFail:
+      ERR(kLncErr, "Compile Fail!");
+      break;
+    case kErrorNotImplement:
+      ERR(kLncErr, "Not Implement!");
+      break;
+    default:
+      break;
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_util/src/file_layout.cpp b/src/mapleall/maple_util/src/file_layout.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..584dc595ff0101371072b13ca16f7f148b4540da
--- /dev/null
+++ b/src/mapleall/maple_util/src/file_layout.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "file_layout.h"
+
+namespace maple {
+std::string GetLayoutTypeString(uint32_t type) {
+  switch (type) {
+    case kLayoutBootHot:
+      return "BootHot";
+    case kLayoutBothHot:
+      return "BothHot";
+    case kLayoutRunHot:
+      return "RunHot";
+    case kLayoutStartupOnly:
+      return "StartupOnly";
+    case kLayoutUsedOnce:
+      return "UsedOnce";
+    case kLayoutExecuted:
+      return "UsedMaybe";
+    case kLayoutUnused:
+      return "Unused";
+    default:
+      std::cerr << "no such type" << std::endl;
+      return "";
+  }
+}
+} // namespace maple
diff --git a/src/mapleall/maple_util/src/file_utils.cpp b/src/mapleall/maple_util/src/file_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f3d97a60d20d89e9d8232a595e3d7db8ccf945fe
--- /dev/null
+++ b/src/mapleall/maple_util/src/file_utils.cpp
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <cstdio>
+#include <cstring>
+#include <climits>
+#include <fstream>
+#include <unistd.h>
+#include "string_utils.h"
+#include "mpl_logging.h"
+#include "file_utils.h"
+
+#ifdef _WIN32
+#include <shlwapi.h>
+#endif
+
+namespace {
+const char kFileSeperatorLinuxStyleChar = '/';
+const char kFileSeperatorWindowsStyleChar = '\\';
+const std::string kFileSeperatorLinuxStyleStr = std::string(1, kFileSeperatorLinuxStyleChar);
+const std::string kFileSeperatorWindowsStyleStr = std::string(1, kFileSeperatorWindowsStyleChar);
+} // namespace
+
+namespace maple {
+#if __WIN32
+const char kFileSeperatorChar = kFileSeperatorWindowsStyleChar;
+#else
+const char kFileSeperatorChar = kFileSeperatorLinuxStyleChar;
+#endif
+
+#if __WIN32
+const std::string kFileSeperatorStr = kFileSeperatorWindowsStyleStr;
+#else
+const std::string kFileSeperatorStr = kFileSeperatorLinuxStyleStr;
+#endif
+
+std::string FileUtils::SafeGetenv(const char *envVar) {
+  const char *tmpEnvPtr = std::getenv(envVar);
+  CHECK_FATAL((tmpEnvPtr != nullptr), "Failed! Unable to find environment variable %s \n", envVar);
+
+  std::string tmpStr(tmpEnvPtr);
+  return tmpStr;
+}
+
+std::string FileUtils::GetRealPath(const std::string &filePath) {
+#ifdef _WIN32
+  char *path = nullptr;
+  if (filePath.size() > PATH_MAX  || !PathCanonicalize(path, filePath.c_str())) {
+    CHECK_FATAL(false, "invalid file path");
+  }
+#else
+  char path[PATH_MAX] = {0};
+  if (filePath.size() > PATH_MAX  || realpath(filePath.c_str(), path) == nullptr) {
+    CHECK_FATAL(false, "invalid file path");
+  }
+#endif
+  std::string result(path, path + strlen(path));
+  return result;
+}
+
+std::string FileUtils::GetFileName(const std::string &filePath, bool isWithExtension) {
+  std::string fullFileName = StringUtils::GetStrAfterLast(filePath, kFileSeperatorStr);
+#ifdef _WIN32
+  fullFileName = StringUtils::GetStrAfterLast(fullFileName, kFileSeperatorLinuxStyleStr);
+#endif
+  if (isWithExtension) {
+    return fullFileName;
+  }
+  return StringUtils::GetStrBeforeLast(fullFileName, ".");
+}
+
+std::string FileUtils::GetFileExtension(const std::string &filePath) {
+  return StringUtils::GetStrAfterLast(filePath, ".", true);
+}
+
+std::string FileUtils::GetExecutable() {
+#ifdef _WIN32
+  static_assert(false, "Implement me for Windows");
+
+#else /* _WIN32 */
+  /* Linux Implementation */
+  char exePath[PATH_MAX];
+  const char *symLinkToCurrentExe = "/proc/self/exe";
+
+  int len = static_cast<int>(readlink(symLinkToCurrentExe, exePath, sizeof(exePath)));
+  if (len < 0) {
+    LogInfo::MapleLogger(kLlErr) << "Currently toolchain supports only Linux System\n";
+    return "";
+  }
+
+  /* Add Null terminate for the string: readlink does not
+   * append a terminating null byte to buf */
+  len = std::min(len, static_cast<int>(sizeof(exePath) - 1));
+  exePath[len] = '\0';
+
+  /* On Linux, /proc/self/exe always looks through symlinks. However, on
+   * GNU/Hurd, /proc/self/exe is a symlink to the path that was used to start
+   * the program, and not the eventual binary file. Therefore, call realpath
+   * so this behaves the same on all platforms.
+   */
+  if (char *realPath = realpath(exePath, nullptr)) {
+    std::string ret = std::string(realPath);
+    free(realPath);
+    return ret;
+  }
+  ASSERT(false, "Something wrong: %s\n", exePath);
+
+  return "";
+#endif /* _WIN32 */
+}
+
+std::string FileUtils::GetFileFolder(const std::string &filePath) {
+  std::string folder = StringUtils::GetStrBeforeLast(filePath, kFileSeperatorStr, true);
+  std::string curSlashType = kFileSeperatorStr;
+#ifdef _WIN32
+  if (folder.empty()) {
+    curSlashType = kFileSeperatorLinuxStyleStr;
+    folder = StringUtils::GetStrBeforeLast(filePath, curSlashType, true);
+  }
+#endif
+  return folder.empty() ? ("." + curSlashType) : (folder + curSlashType);
+}
+
+int FileUtils::Remove(const std::string &filePath) {
+  return remove(filePath.c_str());
+}
+
+bool FileUtils::IsFileExists(const std::string &filePath) {
+  std::ifstream f(filePath);
+  return f.good();
+}
+
+std::string FileUtils::AppendMapleRootIfNeeded(bool needRootPath, const std::string &path,
+                                               const std::string &defaultRoot) {
+  if (!needRootPath) {
+    return path;
+  }
+  std::ostringstream ostrStream;
+  if (getenv(kMapleRoot) == nullptr) {
+    ostrStream << defaultRoot << path;
+  } else {
+    ostrStream << getenv(kMapleRoot) << kFileSeperatorStr << path;
+  }
+  return ostrStream.str();
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_util/src/itab_util.cpp b/src/mapleall/maple_util/src/itab_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1983bdd2a64baa4cc06641c6638e2d29f56db42a
--- /dev/null
+++ b/src/mapleall/maple_util/src/itab_util.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "itab_util.h"
+#include <map>
+#include <mutex>
+#include <cstring>
+
+namespace maple {
+unsigned int DJBHash(const char *str) {
+  unsigned int hash = 5381; // initial value for DJB hash algorithm
+  while (*str) {
+    hash += (hash << 5) + static_cast<unsigned char>(*str++); // calculate the hash code of data
+  }
+  return (hash & 0x7FFFFFFF);
+}
+
+unsigned int GetHashIndex(const char *name) {
+  unsigned int hashcode = DJBHash(name);
+  return (hashcode % kHashSize);
+}
+struct CmpStr {
+  bool operator()(char const *a, char const *b) const {
+    return std::strcmp(a, b) < 0;
+  }
+};
+
+// optimization for hot method retrival.
+// check risk incurred by multi-threads.
+std::map<const char*, unsigned int, CmpStr> hotMethodCache;
+std::map<const char*, unsigned int>::const_iterator it;
+std::mutex mapLock;
+
+unsigned int GetSecondHashIndex(const char *name) {
+  std::lock_guard<std::mutex> guard(mapLock);
+  if (hotMethodCache.size() == 0) {
+    for (unsigned int i = 0; i < ITAB_HOTMETHOD_SIZE; ++i) {
+      hotMethodCache.emplace(itabHotMethod[i], i);
+    }
+  }
+
+  it = hotMethodCache.find(name);
+  if (it != hotMethodCache.end()) {
+    return it->second;
+  }
+  unsigned int hashcode = DJBHash(name);
+  return ITAB_HOTMETHOD_SIZE + (hashcode % (kItabSecondHashSize - ITAB_HOTMETHOD_SIZE));
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_util/src/literalstrname.cpp b/src/mapleall/maple_util/src/literalstrname.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d770982767532aaba4ca7fd5e457a50ade7e2a3d
--- /dev/null
+++ b/src/mapleall/maple_util/src/literalstrname.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "literalstrname.h"
+
+// literal string name is shared between maple compiler and runtime, thus not in namespace maplert
+// note there is a macor kConstString "_C_STR_" in literalstrname.h
+// which need to match
+static const std::string mplConstStr("_C_STR_00000000000000000000000000000000");
+const uint32_t kMaxBytesLength = 15;
+
+namespace {
+const char *kMplDigits = "0123456789abcdef";
+}
+
+// Return the hex string of bytes. The result is the combination of prefix "_C_STR_" and hex string of bytes.
+// The upper 4 bits and lower 4 bits of bytes[i] are transformed to hex form and restored separately in hex string.
+std::string LiteralStrName::GetHexStr(const uint8_t *bytes, uint32_t len) {
+  if (bytes == nullptr) {
+    return std::string();
+  }
+  std::string str(mplConstStr, 0, (len << 1) + kConstStringLen);
+  for (unsigned i = 0; i < len; ++i) {
+    str[2 * i + kConstStringLen] = kMplDigits[(bytes[i] & 0xf0) >> 4]; // get the hex value of upper 4 bits of bytes[i]
+    str[2 * i + kConstStringLen + 1] = kMplDigits[bytes[i] & 0x0f]; // get the hex value of lower 4 bits of bytes[i]
+  }
+  return str;
+}
+
+// Return the hash code of data. The hash code is computed as
+// s[0] * 31 ^ (len - 1) + s[1] * 31 ^ (len - 2) + ... + s[len - 1],
+// where s[i] is the value of swapping the upper 8 bits and lower 8 bits of data[i].
+int32_t LiteralStrName::CalculateHashSwapByte(const char16_t *data, uint32_t len) {
+  uint32_t hash = 0;
+  const char16_t *end = data + len;
+  while (data < end) {
+    hash = (hash << 5) - hash;
+    char16_t val = *data++;
+    hash += (((val << 8) & 0xff00) | ((val >> 8) & 0xff));
+  }
+  return static_cast<int32_t>(hash);
+}
+
+std::string LiteralStrName::GetLiteralStrName(const uint8_t *bytes, uint32_t len) {
+  if (len <= kMaxBytesLength) {
+    return GetHexStr(bytes, len);
+  }
+  return ComputeMuid(bytes, len);
+}
+
+std::string LiteralStrName::ComputeMuid(const uint8_t *bytes, uint32_t len) {
+  DigestHash digestHash = GetDigestHash(*bytes, len);
+  return GetHexStr(digestHash.bytes, kDigestHashLength);
+}
\ No newline at end of file
diff --git a/src/mapleall/maple_util/src/mpl_int_val.cpp b/src/mapleall/maple_util/src/mpl_int_val.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ce246cb4740317e8b165ecf757968d6845b2b3c
--- /dev/null
+++ b/src/mapleall/maple_util/src/mpl_int_val.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "mpl_int_val.h"
+
+namespace maple {
+
+IntVal IntVal::operator/(const IntVal &divisor) const {
+  ASSERT(width == divisor.width && sign == divisor.sign, "bit-width and sign must be the same");
+  ASSERT(divisor.value != 0, "division by zero");
+  ASSERT(!sign || (!IsMinValue() || !divisor.AreAllBitsOne()), "minValue / -1 leads to overflow");
+
+  bool isNeg = sign && GetSignBit();
+  bool isDivisorNeg = divisor.sign && divisor.GetSignBit();
+
+  uint64 dividendVal = isNeg ? (-*this).value : value;
+  uint64 divisorVal = isDivisorNeg ? (-divisor).value : divisor.value;
+
+  return isNeg != isDivisorNeg ? -IntVal(dividendVal / divisorVal, width, sign)
+                               : IntVal(dividendVal / divisorVal, width, sign);
+}
+
+IntVal IntVal::operator%(const IntVal &divisor) const {
+  ASSERT(width == divisor.width && sign == divisor.sign, "bit-width and sign must be the same");
+  ASSERT(divisor.value != 0, "division by zero");
+  ASSERT(!sign || (!IsMinValue() || !divisor.AreAllBitsOne()), "minValue % -1 leads to overflow");
+
+  bool isNeg = sign && GetSignBit();
+  bool isDivisorNeg = divisor.sign && divisor.GetSignBit();
+
+  uint64 dividendVal = isNeg ? (-*this).value : value;
+  uint64 divisorVal = isDivisorNeg ? (-divisor).value : divisor.value;
+
+  return isNeg ? -IntVal(dividendVal % divisorVal, width, sign) : IntVal(dividendVal % divisorVal, width, sign);
+}
+
+std::ostream &operator<<(std::ostream &os, const IntVal &value) {
+  int64 val = value.GetExtValue();
+  constexpr int64 valThreshold = 1024;
+
+  if (val <= valThreshold) {
+    os << val;
+  } else {
+    os << std::hex << "0x" << val << std::dec;
+  }
+
+  return os;
+}
+
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mapleall/maple_util/src/mpl_logging.cpp b/src/mapleall/maple_util/src/mpl_logging.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4a01d0d9f87835b6c6e8c16f76247d247ec23e7a
--- /dev/null
+++ b/src/mapleall/maple_util/src/mpl_logging.cpp
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mpl_logging.h"
+#include <unistd.h>
+#include <cstring>
+#include <ctime>
+#ifndef _WIN32
+#include <sys/syscall.h>
+#endif
+#include "securec.h"
+
+namespace {
+constexpr uint32_t kMaxLogLen = 10000;
+}
+
+namespace maple {
+LogInfo logInfo;
+LogInfo &log = logInfo;
+
+const char *kLongLogLevels[] = { [kLlDbg] = "D",      [kLlLog] = "L",     [kLlInfo] = "Info ",
+                                 [kLlWarn] = "Warn ", [kLlErr] = "Error", [kLlFatal] = "Fatal" };
+
+const char *tags[] = {
+  [kLtThread] = "TR",
+  [kLtLooper] = "LP",
+};
+
+SECUREC_ATTRIBUTE(7, 8) void LogInfo::EmitLogForDevelop(enum LogTags tag, enum LogLevel ll, const std::string &file,
+                                                        const std::string &func, int line, const char *fmt, ...) {
+  char buf[kMaxLogLen];
+  ASSERT(tag < kLtAll, "illegal log tag");
+
+#ifndef _WIN32
+  pid_t tid = syscall(SYS_gettid);
+#endif
+
+  time_t timeSeconds = time(nullptr);
+  struct tm *nowTime = localtime(&timeSeconds);
+  CHECK_FATAL(nowTime != nullptr, "(nowTime) null ptr check");
+  int month = nowTime->tm_mon + 1;
+  int day = nowTime->tm_mday;
+  int hour = nowTime->tm_hour;
+  int min = nowTime->tm_min;
+  int sec = nowTime->tm_sec;
+
+#ifdef _WIN32
+  int lenFront = snprintf_s(buf, kMaxLogLen, kMaxLogLen - 1, "%02d-%02d %02d:%02d:%02d %s %s ",
+                            month, day, hour, min, sec, tags[tag], kLongLogLevels[ll]);
+#else
+  int lenFront = snprintf_s(buf, kMaxLogLen, kMaxLogLen - 1, "%02d-%02d %02d:%02d:%02d %s %d %s ",
+                            month, day, hour, min, sec, tags[tag], tid, kLongLogLevels[ll]);
+#endif
+
+  if (lenFront == -1) {
+    WARN(kLncWarn, "snprintf_s failed in mpl_logging.cpp");
+    return;
+  }
+  va_list l;
+  va_start(l, fmt);
+
+  int lenBack = vsnprintf_s(buf + lenFront, kMaxLogLen - lenFront,
+                            static_cast<size_t>(kMaxLogLen - lenFront - 1), fmt, l);
+  if (lenBack == -1) {
+    WARN(kLncWarn, "vsnprintf_s  failed ");
+    va_end(l);
+    return;
+  }
+  if (outMode != 0) {
+    int eNum = snprintf_s(buf + lenFront + lenBack, kMaxLogLen - lenFront - lenBack,
+                          kMaxLogLen - lenFront - lenBack - 1, " [%s] [%s:%d]", func.c_str(), file.c_str(), line);
+    if (eNum == -1) {
+      WARN(kLncWarn, "snprintf_s failed");
+      va_end(l);
+      return;
+    }
+  } else {
+    int eNum = snprintf_s(buf + lenFront + lenBack, kMaxLogLen - lenFront - lenBack,
+                          kMaxLogLen - lenFront - lenBack - 1, " [%s]", func.c_str());
+    if (eNum == -1) {
+      WARN(kLncWarn, "snprintf_s failed");
+      va_end(l);
+      return;
+    }
+  }
+  va_end(l);
+  fprintf(outStream, "%s\n", buf);
+  return;
+}
+
+SECUREC_ATTRIBUTE(4, 5) std::string LogInfo::EmitLogToStringForUser(enum LogNumberCode num, enum LogLevel ll,
+                                                                    const char *fmt, ...) const {
+  char buf[kMaxLogLen];
+  int len = snprintf_s(buf, kMaxLogLen, kMaxLogLen - 1, "%s %02d: ", kLongLogLevels[ll], num);
+  if (len == -1) {
+    WARN(kLncWarn, "snprintf_s failed");
+    return "";
+  }
+  if (outMode != 0) {
+    va_list l;
+    va_start(l, fmt);
+    int eNum = vsnprintf_s(buf + len, kMaxLogLen - len, static_cast<size_t>(kMaxLogLen - len - 1), fmt, l);
+    if (eNum == -1) {
+      WARN(kLncWarn, "vsnprintf_s failed");
+      va_end(l);
+      return "";
+    }
+    va_end(l);
+  }
+  std::string logStr(buf);
+  return logStr;
+}
+
+SECUREC_ATTRIBUTE(4, 5) void LogInfo::EmitLogForUser(enum LogNumberCode num, enum LogLevel ll, const char *fmt,
+                                                     ...) const {
+  char buf[kMaxLogLen];
+  int len = snprintf_s(buf, kMaxLogLen, kMaxLogLen - 1, "%s %02d: ", kLongLogLevels[ll], num);
+  if (len == -1) {
+    WARN(kLncWarn, "snprintf_s failed");
+    return;
+  }
+  if (outMode != 0) {
+    va_list l;
+    va_start(l, fmt);
+    int eNum = vsnprintf_s(buf + len, kMaxLogLen - len, static_cast<size_t>(kMaxLogLen - len - 1), fmt, l);
+    if (eNum == -1) {
+      WARN(kLncWarn, "vsnprintf_s failed");
+      va_end(l);
+      return;
+    }
+    va_end(l);
+  }
+  std::cerr << buf << '\n';
+  return;
+}
+
+void LogInfo::EmitLogForUser(enum LogNumberCode num, enum LogLevel ll, const std::string &message) const {
+  EmitLogForUser(num, ll, "%s", message.c_str());
+}
+
+SECUREC_ATTRIBUTE(5, 6) void LogInfo::EmitErrorMessage(const std::string &cond, const std::string &file,
+                                                       unsigned int line, const char *fmt, ...) const {
+  char buf[kMaxLogLen];
+#ifdef _WIN32
+  int len = snprintf_s(buf, kMaxLogLen, kMaxLogLen - 1, "CHECK/CHECK_FATAL failure: %s at [%s:%d] ",
+                       cond.c_str(), file.c_str(), line);
+#else
+  pid_t tid = syscall(SYS_gettid);
+  int len = snprintf_s(buf, kMaxLogLen, kMaxLogLen - 1, "Tid(%d): CHECK/CHECK_FATAL failure: %s at [%s:%d] ",
+                       tid, cond.c_str(), file.c_str(), line);
+#endif
+  if (len == -1) {
+    WARN(kLncWarn, "snprintf_s failed");
+    return;
+  }
+  va_list l;
+  va_start(l, fmt);
+  int eNum = vsnprintf_s(buf + len, kMaxLogLen - len, static_cast<size_t>(kMaxLogLen - len - 1), fmt, l);
+  if (eNum == -1) {
+    WARN(kLncWarn, "vsnprintf_s failed");
+    va_end(l);
+    return;
+  }
+  va_end(l);
+  std::cerr << buf;
+}
+
+std::ios::fmtflags LogInfo::Flags() {
+  std::ios::fmtflags flag(std::cout.flags());
+  return std::cout.flags(flag);
+}
+
+std::ostream &LogInfo::MapleLogger(LogLevel level) {
+  if (level == kLlLog) {
+    return std::cout;
+  } else {
+    return std::cerr;
+  }
+}
+std::ostream &LogInfo::Info() {
+  return std::cout;
+}
+std::ostream &LogInfo::Err() {
+  return std::cerr;
+}
+
+void LogInfo::InsertUserWarnMessage(const Loc &loc, const std::string &message) {
+  std::lock_guard<std::mutex> lk(warnsMtx);
+  userWarnsMap[loc].emplace_back(message);
+  ++warnsNum;
+}
+
+void LogInfo::PrintUserWarnMessages() {
+  std::lock_guard<std::mutex> lk(warnsMtx);
+  for (auto it = userWarnsMap.cbegin(); it != userWarnsMap.cend(); ++it) {
+    std::vector<std::string> warns = it->second;
+    for (size_t i = 0; i < warns.size(); ++i) {
+      std::cerr << warns[i] << '\n';
+    }
+  }
+  if (!userWarnsMap.empty()) {
+    INFO(kLncInfo, "%d warn(s) generated.", warnsNum);
+    userWarnsMap.clear();
+  }
+}
+
+void LogInfo::InsertUserErrorMessage(const Loc &loc, const std::string &err) {
+  std::lock_guard<std::mutex> lk(errsMtx);
+  userErrsMap[loc].emplace_back(err);
+  ++errsNum;
+}
+
+void LogInfo::PrintUserErrorMessages() {
+  std::lock_guard<std::mutex> lk(errsMtx);
+  for (auto it = userErrsMap.cbegin(); it != userErrsMap.cend(); ++it) {
+    std::vector<std::string> errs = it->second;
+    for (size_t i = 0; i < errs.size(); ++i) {
+      std::cerr << errs[i] << '\n';
+    }
+  }
+  if (!userErrsMap.empty()) {
+    INFO(kLncInfo, "%d error(s) generated.", errsNum);
+    userErrsMap.clear();
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/maple_util/src/mpl_posix_sighandler.cpp b/src/mapleall/maple_util/src/mpl_posix_sighandler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48f8841ed5d4f6fac8e0d82d3ba86fd4a8c86e21
--- /dev/null
+++ b/src/mapleall/maple_util/src/mpl_posix_sighandler.cpp
@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "mpl_sighandler.h"
+
+#ifdef __unix__
+#include <dlfcn.h>
+#include <link.h>
+#include <sys/time.h>
+#endif
+
+#include <cerrno>
+#include <cstdlib>
+
+#include "mpl_logging.h"
+#include "mpl_stacktrace.h"
+
+namespace maple {
+
+std::map<int, SigHandler::FuncPtr> SigHandler::sig2callback =
+#ifdef __unix__
+    {{SIGINT, nullptr},  {SIGINT, nullptr},  {SIGTERM, nullptr}, {SIGSEGV, nullptr},
+     {SIGBUS, nullptr},  {SIGABRT, nullptr}, {SIGILL, nullptr},  {SIGFPE, nullptr},
+     {SIGXFSZ, nullptr}, {SIGUSR1, nullptr}, {SIGUSR2, nullptr}, {SIGALRM, nullptr}};
+#else
+    {};
+#endif
+
+void SigHandler::EnableAll() {
+#ifdef __unix__
+  for (auto it = sig2callback.cbegin(); it != sig2callback.cend(); ++it) {
+    SetSigaction(it->first, Handler);
+  }
+#else
+  LogInfo::MapleLogger(kLlWarn) << "Sighandler : signal handler isn't implemented for non-unix os" << std::endl;
+#endif
+}
+
+void SigHandler::EnableSig(int sig) {
+#ifdef __unix__
+  if (!IsSupportedSig(sig)) {
+    LogInfo::MapleLogger(kLlWarn) << "SigHandler::enable(...) : signum " << sig << " isn't supported" << std::endl;
+    return;
+  }
+
+  SetSigaction(sig, Handler);
+#else
+  LogInfo::MapleLogger(kLlWarn) << "Sighandler : signal handler isn't implemented for non-unix os" << std::endl;
+#endif
+}
+
+void SigHandler::DisableAll() {
+  for (auto it = sig2callback.cbegin(); it != sig2callback.cend(); ++it) {
+    SetDefaultSigaction(it->first);
+  }
+}
+
+void SigHandler::DisableSig(int sig) {
+  if (!IsSupportedSig(sig)) {
+    return;
+  }
+
+  SetDefaultSigaction(sig);
+}
+
+void SigHandler::SetTimer(int seconds) {
+#ifdef __unix__
+  struct itimerval timeValue {
+    {seconds, 0}, {
+      seconds, 0
+    }
+  };
+
+  if (setitimer(ITIMER_REAL, &timeValue, nullptr)) {
+    LogInfo::MapleLogger(kLlErr) << "setitimer failed with " << errno << std::endl;
+    exit(EXIT_FAILURE);
+  }
+#endif
+}
+
+void SigHandler::SetCallback(int sig, SigHandler::FuncPtr callback) {
+  if (!IsSupportedSig(sig)) {
+    LogInfo::MapleLogger(kLlWarn) << "SigHandler :" << sig << " isn't supported" << std::endl;
+    return;
+  }
+
+  sig2callback[sig] = callback;
+}
+
+bool SigHandler::IsSupportedSig(int sig) {
+  return sig2callback.count(sig) > 0;
+}
+
+static std::string SEGVcodename(int code) {
+#ifdef __unix__
+  switch (code) {
+    case SEGV_MAPERR:
+      return "Address not mapped";
+    case SEGV_ACCERR:
+      return "Invalid permissions";
+    default:
+      return "unknown SEGV code";
+  }
+#else
+  return std::string();
+#endif
+}
+
+static std::string BUScodename(int code) {
+#ifdef __unux__
+  switch (code) {
+    case BUS_ADRALN:
+      return "Invalid address alignment";
+    case BUS_ADRERR:
+      return "Non-existent physical address";
+    case BUS_OBJERR:
+      return "Object-specific hardware error";
+    default:
+      return "unknown BUS code";
+  }
+#else
+  return std::string();
+#endif
+}
+
+static std::string ILLcodename(int code) {
+#ifdef __unix__
+  switch (code) {
+    case ILL_ILLOPC:
+      return "Illegal opcode";
+    case ILL_ILLOPN:
+      return "Illegal operand";
+    case ILL_ILLADR:
+      return "Illegal addressing mode";
+    case ILL_ILLTRP:
+      return "Illegal trap";
+    case ILL_PRVOPC:
+      return "Privileged opcode";
+    case ILL_PRVREG:
+      return "Privileged register";
+    case ILL_COPROC:
+      return "Coprocessor error";
+    case ILL_BADSTK:
+      return "Internal stack error";
+    default:
+      return "unknown ILL code";
+  }
+#else
+  return std::string();
+#endif
+}
+
+static std::string FPEcodename(int code) noexcept {
+#ifdef __unix__
+  switch (code) {
+    case FPE_INTDIV:
+      return "Integer divide-by-zero";
+    case FPE_INTOVF:
+      return "Integer overflow";
+    case FPE_FLTDIV:
+      return "Floating point divide-by-zero";
+    case FPE_FLTOVF:
+      return "Floating point overflow";
+    case FPE_FLTUND:
+      return "Floating point underflow";
+    case FPE_FLTRES:
+      return "Floating point inexact result";
+    case FPE_FLTINV:
+      return "Invalid floating point operation";
+    case FPE_FLTSUB:
+      return "Subscript out of range";
+    default:
+      return "unknown FPE code";
+  }
+#else
+  return std::string();
+#endif
+}
+
+static std::string XFSZcodename(int code) {
+#ifdef __unix__
+  switch (code) {
+    case SEGV_MAPERR:
+      return "Address not mapped";
+    case SEGV_ACCERR:
+      return "Invalid permissions";
+    default:
+      return "unknown XFSZ code";
+  }
+#else
+  return std::string();
+#endif
+}
+
+static bool NeedDumpFaultingAddr(int sig) {
+#ifdef __unix__
+  return (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || sig == SIGFPE || sig == SIGXFSZ);
+#else
+  return false;
+#endif
+}
+
+static void DumpErrorMsg(int sig, int code) {
+#ifdef __unix__
+  LogInfo::MapleLogger(kLlErr) << "Program ends with ";
+  switch (sig) {
+    case SIGINT:
+      LogInfo::MapleLogger(kLlErr) << "interrupt";
+      break;
+    case SIGTERM:
+      LogInfo::MapleLogger(kLlErr) << "terminate()";
+      break;
+    case SIGSEGV:
+      LogInfo::MapleLogger(kLlErr) << "SEGV signal: " << SEGVcodename(code);
+      break;
+    case SIGBUS:
+      LogInfo::MapleLogger(kLlErr) << "BUS signal: " << BUScodename(code);
+      break;
+    case SIGABRT:
+      LogInfo::MapleLogger(kLlErr) << "abort()";
+      break;
+    case SIGILL:
+      LogInfo::MapleLogger(kLlErr) << "ILL signal: " << ILLcodename(code);
+      break;
+    case SIGFPE:
+      LogInfo::MapleLogger(kLlErr) << "FPE signal: " << FPEcodename(code);
+      break;
+    case SIGXFSZ:
+      LogInfo::MapleLogger(kLlErr) << "XFSZ signal: " << XFSZcodename(code);
+      break;
+    case SIGUSR1:
+    case SIGUSR2:
+      LogInfo::MapleLogger(kLlErr) << "USR signal";
+      break;
+    case SIGALRM:
+      LogInfo::MapleLogger(kLlErr) << "ALRM signal";
+      break;
+    default:
+      LogInfo::MapleLogger(kLlErr) << "unknown signal";
+      break;
+  }
+
+  LogInfo::MapleLogger(kLlErr) << std::endl;
+#endif
+}
+
+static uintptr_t GetLinkAddr(uintptr_t addr) {
+#ifdef __unix__
+  Dl_info info;
+  void *extraInfo = nullptr;
+  int status = dladdr1(reinterpret_cast<void *>(addr), &info, &extraInfo, static_cast<int>(RTLD_DL_LINKMAP));
+  link_map *linkMap = static_cast<link_map *>(extraInfo);
+
+  if (status != 1) {
+    return 0;
+  }
+
+  return reinterpret_cast<uintptr_t>(linkMap->l_addr);
+#else
+  return 0;
+#endif
+}
+
+static void InitAlternativeStack() {
+#ifdef __unix__
+  stack_t oldStack;
+  if (sigaltstack(nullptr, &oldStack) == -1) {
+    LogInfo::MapleLogger(kLlErr) << "sigaltstack failed with " << errno << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  if (oldStack.ss_sp) {
+    return;
+  }
+
+  stack_t stack;
+  constexpr size_t stackSizeMultiplier = 4;
+  size_t stackSize = stackSizeMultiplier * SIGSTKSZ;
+  stack.ss_size = stackSize;
+  stack.ss_sp = std::malloc(stackSize);
+  if (stack.ss_sp == nullptr) {
+    LogInfo::MapleLogger(kLlErr) << "malloc failed with " << errno << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  stack.ss_flags = 0;
+
+  if (sigaltstack(&stack, nullptr) == -1) {
+    LogInfo::MapleLogger(kLlErr) << "sigaltstack faled with " << errno << std::endl;
+    exit(EXIT_FAILURE);
+  }
+#else
+  return;
+#endif
+}
+
+void SigHandler::SetSigaction(int sig, SigHandler::FuncPtr callback) {
+#ifdef __unix__
+  InitAlternativeStack();
+
+  struct sigaction sigact = {};
+  sigact.sa_flags = SA_SIGINFO | SA_ONSTACK;
+  sigact.sa_sigaction = callback;
+
+  if (sigaction(sig, &sigact, nullptr)) {
+    LogInfo::MapleLogger(kLlErr) << "sigacton failed with " << errno << std::endl;
+    exit(EXIT_FAILURE);
+  }
+#else
+  return;
+#endif
+}
+
+void SigHandler::SetDefaultSigaction(int sig) {
+#ifdef __unix__
+  struct sigaction sigact = {};
+  sigact.sa_handler = SIG_DFL;
+  if (sigaction(sig, &sigact, nullptr)) {
+    LogInfo::MapleLogger(kLlErr) << "sigacton failed with " << errno << std::endl;
+    exit(EXIT_FAILURE);
+  }
+#else
+  return;
+#endif
+}
+
+void DumpFaultingAddr(uintptr_t addr) {
+  uintptr_t linkAddr = GetLinkAddr(addr);
+  LogInfo::MapleLogger(kLlErr) << "faulting address: ";
+  if (linkAddr) {
+    LogInfo::MapleLogger(kLlErr) << "0x" << std::hex << addr - linkAddr << " (0x" << std::hex << addr << ")"
+                                 << std::endl;
+  } else {
+    LogInfo::MapleLogger(kLlErr) << "0x" << std::hex << addr << std::endl;
+  }
+}
+
+void SigHandler::Handler(int sig, siginfo_t *info, void *ucontext) noexcept {
+  DumpErrorMsg(sig, info->si_code);
+
+  if (NeedDumpFaultingAddr(sig)) {
+    DumpFaultingAddr(reinterpret_cast<uintptr_t>(info->si_addr));
+  }
+
+  LogInfo::MapleLogger(kLlErr) << Stacktrace<>() << std::endl;
+
+  if (FuncPtr callback = sig2callback.at(sig)) {
+    callback(sig, info, ucontext);
+  }
+
+  exit(EXIT_FAILURE);
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_util/src/mpl_profdata.cpp b/src/mapleall/maple_util/src/mpl_profdata.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..49fd87cc3fa97c5ceac13410debf938f46b2335d
--- /dev/null
+++ b/src/mapleall/maple_util/src/mpl_profdata.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mpl_profdata.h"
+#include <cmath>
+#include "mpl_logging.h"
+#include "option.h"
+
+namespace maple {
+void ProfileSummary::DumpSummary() {
+  LogInfo::MapleLogger() << "---------ProfileSummary-------------- \n";
+  LogInfo::MapleLogger() << "             checkSum: " << std::hex << "0x" << checkSum << "\n";
+  LogInfo::MapleLogger() << "             runtimes:  " << std::dec << run << "\n";
+  LogInfo::MapleLogger() << "             totalCounts: " << std::dec << totalCount << "\n";
+  LogInfo::MapleLogger() << "             maxCount:    " << std::dec << maxCount << "\n";
+  LogInfo::MapleLogger() << "             count histogram:   countRange countNum minCount cumCount \n";
+  for (auto &it : histogram) {
+    LogInfo::MapleLogger() << "                                 " << std::dec << it.startValue << "\t";
+    LogInfo::MapleLogger() << std::dec << it.countNums << "\t" << it.countMinVal << "\t" << it.countCumValue << "\n";
+  }
+}
+
+void FuncProfInfo::DumpFunctionProfile() {
+  LogInfo::MapleLogger() << "function ident " << std::dec << ident;
+  LogInfo::MapleLogger() << "  lino_checksum 0x" << std::hex << linenoChecksum << ", ";
+  LogInfo::MapleLogger() << "  cfg_checksum 0x" << std::hex << cfgChecksum << "\n";
+  LogInfo::MapleLogger() << "  num_counts " << std::dec << edgeCounts << " : ";
+  for (unsigned i = 0; i < edgeCounts; i++) {
+    LogInfo::MapleLogger() << std::dec << "  " << counts[i];
+  }
+  LogInfo::MapleLogger() << "\n";
+}
+
+void MplProfileData::DumpFunctionsProfile() {
+  LogInfo::MapleLogger() << "---------FunctionProfile-------------- \n";
+  for (auto &it : funcsCounter) {
+    it.second->DumpFunctionProfile();
+  }
+}
+
+void MplProfileData::DumpProfileData() {
+  summary.DumpSummary();
+  DumpFunctionsProfile();
+}
+
+void ProfileSummary::ProcessHistogram() {
+  int countsum = 0;
+  int n = static_cast<int>(histogram.size());
+  enum Percentage {
+    kPercent = 100
+  };
+  for (int32 i = n - 1; i >= 0; --i) {
+    countsum += static_cast<int>(histogram[static_cast<uint32>(i)].countNums);
+    histogram[static_cast<uint32>(i)].countRatio = static_cast<uint32_t>(std::round(
+        (static_cast<float>(countsum) / static_cast<float>(totalCount)) * kPercent));
+  }
+}
+
+uint64_t MplProfileData::GetHotThreshold() {
+  enum Hotness {
+    kHotratio = 90
+  };
+  for (auto &it : summary.GetHistogram()) {
+    if (it.countRatio >= kHotratio) {
+      hotCountThreshold = it.startValue;
+    } else {
+      if (hotCountThreshold == 0) {
+        hotCountThreshold = it.countMinVal;  // set minValue in currentRange which satisfy hot ratio
+      }
+      return hotCountThreshold;
+    }
+  }
+  // should not be here
+  const int unlikelyHot = 100;
+  return unlikelyHot;
+}
+
+bool MplProfileData::IsHotCallSite(uint64_t freq) {
+  auto &h = summary.GetHistogram();
+  if (hotCountThreshold == 0) {
+    if (Options::profileHotCountSeted) {
+      hotCountThreshold = Options::profileHotCount;
+    } else if (summary.GetTotalCount() > 0 && !h.empty() && h[0].countRatio == 0) {
+      // init countRatio and compute hotCountThreshold
+      summary.ProcessHistogram();
+      hotCountThreshold = GetHotThreshold();
+    } else if (h.empty()) {
+      // should not be here
+      ASSERT(0, "should not be here");
+      hotCountThreshold = 1;
+    }
+  }
+  return freq >= hotCountThreshold;
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_util/src/mpl_scheduler.cpp b/src/mapleall/maple_util/src/mpl_scheduler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cda36d76072006adb94a73f5ed8f98cc51a08a27
--- /dev/null
+++ b/src/mapleall/maple_util/src/mpl_scheduler.cpp
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mpl_scheduler.h"
+#include "mpl_timer.h"
+#include "mpl_logging.h"
+namespace maple {
+constexpr double kAlternateUnits = 1000.0;
+// ========== MplScheduler ==========
+MplScheduler::MplScheduler(const std::string &name)
+    : schedulerName(name),
+      taskIdForAdd(0),
+      taskIdToRun(0),
+      taskIdExpected(0),
+      numberTasks(0),
+      numberTasksFinish(0),
+      isSchedulerSeq(false),
+      dumpTime(false),
+      statusFinish(kThreadRun) {}
+
+void MplScheduler::Init() {
+  char *envStr = getenv("MP_DUMPTIME");
+  if (envStr != nullptr && atoi(envStr) == 1) {
+    dumpTime = true;
+  }
+  int ret = pthread_mutex_init(&mutexTaskIdsToRun, nullptr);
+  CHECK_FATAL(ret == 0, "pthread_mutex_init failed");
+  ret = pthread_mutex_init(&mutexTaskIdsToFinish, nullptr);
+  CHECK_FATAL(ret == 0, "pthread_mutex_init failed");
+  ret = pthread_mutex_init(&mutexGlobal, nullptr);
+  CHECK_FATAL(ret == 0, "pthread_mutex_init failed");
+  mutexTaskFinishProcess = PTHREAD_MUTEX_INITIALIZER;
+  conditionFinishProcess = PTHREAD_COND_INITIALIZER;
+}
+
+void MplScheduler::AddTask(MplTask &task) {
+  task.SetTaskId(taskIdForAdd);
+  tbTasks.push_back(&task);
+  ++taskIdForAdd;
+  ++numberTasks;
+}
+
+MplTask *MplScheduler::GetTaskToRun() {
+  MplTask *task = nullptr;
+  int ret = pthread_mutex_lock(&mutexTaskIdsToRun);
+  CHECK_FATAL(ret == 0, "pthread_mutex_lock failed");
+  if (taskIdToRun < numberTasks) {
+    task = tbTasks[taskIdToRun++];
+  }
+  ret = pthread_mutex_unlock(&mutexTaskIdsToRun);
+  CHECK_FATAL(ret == 0, "pthread_mutex_unlock failed");
+  return task;
+}
+
+size_t MplScheduler::GetTaskIdsFinishSize() {
+  int ret = pthread_mutex_lock(&mutexTaskIdsToFinish);
+  CHECK_FATAL(ret == 0, "pthread_mutex_lock failed");
+  size_t size = tbTaskIdsToFinish.size();
+  ret = pthread_mutex_unlock(&mutexTaskIdsToFinish);
+  CHECK_FATAL(ret == 0, "pthread_mutex_unlock failed");
+  return size;
+}
+
+MplTask *MplScheduler::GetTaskFinishFirst() {
+  MplTask *task = nullptr;
+  int ret = pthread_mutex_lock(&mutexTaskIdsToFinish);
+  CHECK_FATAL(ret == 0, "pthread_mutex_lock failed");
+  if (!tbTaskIdsToFinish.empty()) {
+    task = tbTasks[*(tbTaskIdsToFinish.begin())];
+  }
+  ret = pthread_mutex_unlock(&mutexTaskIdsToFinish);
+  CHECK_FATAL(ret == 0, "pthread_mutex_unlock failed");
+  return task;
+}
+
+void MplScheduler::RemoveTaskFinish(uint32 id) {
+  int ret = pthread_mutex_lock(&mutexTaskIdsToFinish);
+  CHECK_FATAL(ret == 0, "pthread_mutex_lock failed");
+  tbTaskIdsToFinish.erase(id);
+  ret = pthread_mutex_unlock(&mutexTaskIdsToFinish);
+  CHECK_FATAL(ret == 0, "pthread_mutex_unlock failed");
+}
+
+void MplScheduler::TaskIdFinish(uint32 id) {
+  int ret = pthread_mutex_lock(&mutexTaskIdsToFinish);
+  CHECK_FATAL(ret == 0, "pthread_mutex_lock failed");
+  tbTaskIdsToFinish.insert(id);
+  ret = pthread_mutex_unlock(&mutexTaskIdsToFinish);
+  CHECK_FATAL(ret == 0, "pthread_mutex_unlock failed");
+}
+
+int MplScheduler::RunTask(uint32 threadsNum, bool seq) {
+  isSchedulerSeq = seq;
+  if (threadsNum > 0) {
+    taskIdExpected = 0;
+    std::thread threads[threadsNum];
+    std::thread threadFinish;
+    for (uint32 i = 0; i < threadsNum; ++i) {
+      threads[i] = std::thread(&MplScheduler::ThreadMain, this, i, EncodeThreadMainEnvironment(i));
+    }
+    if (isSchedulerSeq) {
+      threadFinish = std::thread(&MplScheduler::ThreadFinish, this, EncodeThreadFinishEnvironment());
+    }
+    for (uint32 i = 0; i < threadsNum; ++i) {
+      threads[i].join();
+    }
+    if (isSchedulerSeq) {
+      threadFinish.join();
+    }
+  }
+  return 0;
+}
+
+int MplScheduler::FinishTask(const MplTask &task) {
+  TaskIdFinish(task.GetTaskId());
+  return 0;
+}
+
+void MplScheduler::Reset() {
+  tbTasks.clear();
+  tbTaskIdsToFinish.clear();
+  taskIdForAdd = 0;
+  taskIdToRun = 0;
+  taskIdExpected = 0;
+  numberTasks = 0;
+  numberTasksFinish = 0;
+  isSchedulerSeq = false;
+}
+
+void MplScheduler::ThreadMain(uint32 threadID, MplSchedulerParam *env) {
+  MPLTimer timerTotal;
+  MPLTimer timerRun;
+  MPLTimer timerToRun;
+  MPLTimer timerFinish;
+  double timeRun = 0.0;
+  double timeToRun = 0.0;
+  double timeFinish = 0.0;
+  if (dumpTime) {
+    timerTotal.Start();
+  }
+  DecodeThreadMainEnvironment(env);
+  CallbackThreadMainStart();
+  if (dumpTime) {
+    timerToRun.Start();
+  }
+  MplTask *task = GetTaskToRun();
+  if (dumpTime) {
+    timerToRun.Stop();
+    timeToRun += timerRun.ElapsedMicroseconds();
+  }
+  int ret = 0;
+  while (task != nullptr) {
+    if (dumpTime) {
+      timerRun.Start();
+    }
+    MplTaskParam *paramRun = CallbackGetTaskRunParam();
+    (void)task->Run(paramRun);
+    if (dumpTime) {
+      timerRun.Stop();
+      timeRun += timerRun.ElapsedMicroseconds();
+      timerFinish.Start();
+    }
+    if (isSchedulerSeq) {
+      ret = FinishTask(*task);
+      CHECK_FATAL(ret == 0, "task finish failed");
+    } else {
+      MplTaskParam *paramFinish = CallbackGetTaskFinishParam();
+      ret = task->Finish(paramFinish);
+      CHECK_FATAL(ret == 0, "task finish failed");
+    }
+    if (dumpTime) {
+      timerFinish.Stop();
+      timeFinish += timerFinish.ElapsedMicroseconds();
+      timerToRun.Start();
+    }
+    task = GetTaskToRun();
+    if (dumpTime) {
+      timerToRun.Stop();
+      timeToRun += timerToRun.ElapsedMicroseconds();
+    }
+  }
+  CallbackThreadMainEnd();
+  if (dumpTime) {
+    timerTotal.Stop();
+    GlobalLock();
+    LogInfo::MapleLogger() << "MP TimeDump(" << schedulerName << ")::Thread" << threadID << "::ThreadMain " <<
+        (timerTotal.ElapsedMicroseconds() / kAlternateUnits) << "ms" << std::endl;
+    LogInfo::MapleLogger() << "MP TimeDump(" << schedulerName << ")::Thread" << threadID <<
+        "::ThreadMain::Task::Run " << (timeRun / kAlternateUnits) << "ms" << std::endl;
+    LogInfo::MapleLogger() << "MP TimeDump(" << schedulerName << ")::Thread" << threadID <<
+        "::ThreadMain::Task::ToRun " << (timeToRun / kAlternateUnits) << "ms" << std::endl;
+    LogInfo::MapleLogger() << "MP TimeDump(" << schedulerName << ")::Thread" << threadID <<
+        "::ThreadMain::Task::Finish " << (timeFinish / kAlternateUnits) << "ms" << std::endl;
+    GlobalUnlock();
+  }
+}
+
+void MplScheduler::ThreadFinish(MplSchedulerParam *env) {
+  statusFinish = kThreadRun;
+  DecodeThreadFinishEnvironment(env);
+  CallbackThreadFinishStart();
+  MplTask *task = nullptr;
+  int ret = 0;
+  uint32 taskId;
+  while (numberTasksFinish < numberTasks) {
+    while (true) {
+      if (GetTaskIdsFinishSize() == 0) {
+        break;
+      }
+      task = GetTaskFinishFirst();
+      CHECK_FATAL(task != nullptr, "null ptr check");
+      taskId = task->GetTaskId();
+      if (isSchedulerSeq) {
+        if (taskId != taskIdExpected) {
+          break;
+        }
+      }
+      MplTaskParam *paramFinish = CallbackGetTaskFinishParam();
+      ret = task->Finish(paramFinish);
+      CHECK_FATAL(ret == 0, "task finish failed");
+      ++numberTasksFinish;
+      if (isSchedulerSeq) {
+        ++taskIdExpected;
+      }
+      RemoveTaskFinish(task->GetTaskId());
+    }
+  }
+  CallbackThreadFinishEnd();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mapleall/maple_util/src/mpl_timer.cpp b/src/mapleall/maple_util/src/mpl_timer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d36ee2188a7b8e302e25daa725faf6ad5c5a371e
--- /dev/null
+++ b/src/mapleall/maple_util/src/mpl_timer.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mpl_timer.h"
+
+namespace maple {
+MPLTimer::MPLTimer() = default;
+
+MPLTimer::~MPLTimer() = default;
+
+void MPLTimer::Start() {
+  startTime = std::chrono::system_clock::now();
+}
+
+void MPLTimer::Stop() {
+  endTime = std::chrono::system_clock::now();
+}
+
+long MPLTimer::Elapsed() {
+  return std::chrono::duration_cast<std::chrono::seconds>(endTime - startTime).count();
+}
+
+long MPLTimer::ElapsedMilliseconds() {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
+}
+
+long MPLTimer::ElapsedMicroseconds() {
+  return std::chrono::duration_cast<std::chrono::microseconds>(endTime - startTime).count();
+}
+}
diff --git a/src/mapleall/maple_util/src/muid.cpp b/src/mapleall/maple_util/src/muid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..85dc12ee3752330b42ea09d8693f6286ee9905b5
--- /dev/null
+++ b/src/mapleall/maple_util/src/muid.cpp
@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/*
+ * We generate muid-hashcode according to the MD5 Message-Digest Algorithm here.
+ */
+#include "muid.h"
+#include <cstring>
+#include "securec.h"
+/*
+ * Basic MUID functions.
+ */
+#define F(x, y, z) (((x) & (y)) | ((~(x)) & (z)))
+#define G(x, y, z) (((x) & (z)) | ((y) & (~(z))))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define I(x, y, z) ((y) ^ ((x) | (~(z))))
+
+/*
+ * Muid Transformation function.
+ */
+#define TRANS(f, a, b, c, d, x, t, s) \
+    (a) += f((b), (c), (d)) + (x) + (t); \
+    (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
+    (a) += (b);
+
+/*
+ * Divide the whole input data into sevral groups with kGroupSizebit each and decode them.
+ */
+#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
+#define DECODE(n, input, output) \
+    ((output)[(n)] = \
+    (*reinterpret_cast<unsigned int*>(const_cast<unsigned char*>(&(input)[(n) * 4]))))
+#else
+#define DECODE(n, input, output) \
+    ((output)[(n)] = \
+    (unsigned int)input[(n) * 4] | \
+    ((unsigned int)input[(n) * 4 + 1] << 8) | \
+    ((unsigned int)input[(n) * 4 + 2] << 16) | \
+    ((unsigned int)input[(n) * 4 + 3] << 24))
+#endif
+
+/*
+ * Encode function.
+ */
+#define ENCODE(dst, src) \
+    (dst)[0] = static_cast<unsigned char>(src); \
+    (dst)[1] = static_cast<unsigned char>((src) >> 8); \
+    (dst)[2] = static_cast<unsigned char>((src) >> 16); \
+    (dst)[3] = static_cast<unsigned char>((src) >> 24);
+
+/*
+ * Body of transformation.
+ */
+static const unsigned char *MuidTransform(MuidContext &status, const unsigned char &data, uint64_t count) {
+  unsigned int a, b, c, d;
+  auto *result = &data;
+
+  while ((count--) != 0) {
+    for (unsigned int i = 0; i < kBlockLength; i++) {
+      DECODE(i, result, status.block);
+    }
+
+    a = status.a;
+    b = status.b;
+    c = status.c;
+    d = status.d;
+
+    /* Round 1 */
+    TRANS(F, a, b, c, d, status.block[0], 0xd76aa478, 7)
+    TRANS(F, d, a, b, c, status.block[1], 0xe8c7b756, 12)
+    TRANS(F, c, d, a, b, status.block[2], 0x242070db, 17)
+    TRANS(F, b, c, d, a, status.block[3], 0xc1bdceee, 22)
+    TRANS(F, a, b, c, d, status.block[4], 0xf57c0faf, 7)
+    TRANS(F, d, a, b, c, status.block[5], 0x4787c62a, 12)
+    TRANS(F, c, d, a, b, status.block[6], 0xa8304613, 17)
+    TRANS(F, b, c, d, a, status.block[7], 0xfd469501, 22)
+    TRANS(F, a, b, c, d, status.block[8], 0x698098d8, 7)
+    TRANS(F, d, a, b, c, status.block[9], 0x8b44f7af, 12)
+    TRANS(F, c, d, a, b, status.block[10], 0xffff5bb1, 17)
+    TRANS(F, b, c, d, a, status.block[11], 0x895cd7be, 22)
+    TRANS(F, a, b, c, d, status.block[12], 0x6b901122, 7)
+    TRANS(F, d, a, b, c, status.block[13], 0xfd987193, 12)
+    TRANS(F, c, d, a, b, status.block[14], 0xa679438e, 17)
+    TRANS(F, b, c, d, a, status.block[15], 0x49b40821, 22)
+
+    /* Round 2 */
+    TRANS(G, a, b, c, d, status.block[1], 0xf61e2562, 5)
+    TRANS(G, d, a, b, c, status.block[6], 0xc040b340, 9)
+    TRANS(G, c, d, a, b, status.block[11], 0x265e5a51, 14)
+    TRANS(G, b, c, d, a, status.block[0], 0xe9b6c7aa, 20)
+    TRANS(G, a, b, c, d, status.block[5], 0xd62f105d, 5)
+    TRANS(G, d, a, b, c, status.block[10], 0x02441453, 9)
+    TRANS(G, c, d, a, b, status.block[15], 0xd8a1e681, 14)
+    TRANS(G, b, c, d, a, status.block[4], 0xe7d3fbc8, 20)
+    TRANS(G, a, b, c, d, status.block[9], 0x21e1cde6, 5)
+    TRANS(G, d, a, b, c, status.block[14], 0xc33707d6, 9)
+    TRANS(G, c, d, a, b, status.block[3], 0xf4d50d87, 14)
+    TRANS(G, b, c, d, a, status.block[8], 0x455a14ed, 20)
+    TRANS(G, a, b, c, d, status.block[13], 0xa9e3e905, 5)
+    TRANS(G, d, a, b, c, status.block[2], 0xfcefa3f8, 9)
+    TRANS(G, c, d, a, b, status.block[7], 0x676f02d9, 14)
+    TRANS(G, b, c, d, a, status.block[12], 0x8d2a4c8a, 20)
+
+    /* Round 3 */
+    TRANS(H, a, b, c, d, status.block[5], 0xfffa3942, 4)
+    TRANS(H, d, a, b, c, status.block[8], 0x8771f681, 11)
+    TRANS(H, c, d, a, b, status.block[11], 0x6d9d6122, 16)
+    TRANS(H, b, c, d, a, status.block[14], 0xfde5380c, 23)
+    TRANS(H, a, b, c, d, status.block[1], 0xa4beea44, 4)
+    TRANS(H, d, a, b, c, status.block[4], 0x4bdecfa9, 11)
+    TRANS(H, c, d, a, b, status.block[7], 0xf6bb4b60, 16)
+    TRANS(H, b, c, d, a, status.block[10], 0xbebfbc70, 23)
+    TRANS(H, a, b, c, d, status.block[13], 0x289b7ec6, 4)
+    TRANS(H, d, a, b, c, status.block[0], 0xeaa127fa, 11)
+    TRANS(H, c, d, a, b, status.block[3], 0xd4ef3085, 16)
+    TRANS(H, b, c, d, a, status.block[6], 0x04881d05, 23)
+    TRANS(H, a, b, c, d, status.block[9], 0xd9d4d039, 4)
+    TRANS(H, d, a, b, c, status.block[12], 0xe6db99e5, 11)
+    TRANS(H, c, d, a, b, status.block[15], 0x1fa27cf8, 16)
+    TRANS(H, b, c, d, a, status.block[2], 0xc4ac5665, 23)
+
+    /* Round 4 */
+    TRANS(I, a, b, c, d, status.block[0], 0xf4292244, 6)
+    TRANS(I, d, a, b, c, status.block[7], 0x432aff97, 10)
+    TRANS(I, c, d, a, b, status.block[14], 0xab9423a7, 15)
+    TRANS(I, b, c, d, a, status.block[5], 0xfc93a039, 21)
+    TRANS(I, a, b, c, d, status.block[12], 0x655b59c3, 6)
+    TRANS(I, d, a, b, c, status.block[3], 0x8f0ccc92, 10)
+    TRANS(I, c, d, a, b, status.block[10], 0xffeff47d, 15)
+    TRANS(I, b, c, d, a, status.block[1], 0x85845dd1, 21)
+    TRANS(I, a, b, c, d, status.block[8], 0x6fa87e4f, 6)
+    TRANS(I, d, a, b, c, status.block[15], 0xfe2ce6e0, 10)
+    TRANS(I, c, d, a, b, status.block[6], 0xa3014314, 15)
+    TRANS(I, b, c, d, a, status.block[13], 0x4e0811a1, 21)
+    TRANS(I, a, b, c, d, status.block[4], 0xf7537e82, 6)
+    TRANS(I, d, a, b, c, status.block[11], 0xbd3af235, 10)
+    TRANS(I, c, d, a, b, status.block[2], 0x2ad7d2bb, 15)
+    TRANS(I, b, c, d, a, status.block[9], 0xeb86d391, 21)
+
+    status.a += a;
+    status.b += b;
+    status.c += c;
+    status.d += d;
+
+    result += kGroupSize;
+  }
+
+  return result;
+}
+
+/*
+ * Initialize constants here.
+ */
+void MuidInit(MuidContext &status) {
+  status.a = 0x67452301;
+  status.b = 0xefcdab89;
+  status.c = 0x98badcfe;
+  status.d = 0x10325476;
+
+  status.count[0] = 0;
+  status.count[1] = 0;
+}
+
+/*
+ * Decoding part(byte to unsigned int).
+ */
+void MuidDecode(MuidContext &status, const unsigned char &data, size_t size) {
+  unsigned int tmp = status.count[0];
+  status.count[0] = (tmp + size) & 0x1fffffff;
+  if (status.count[0] < tmp) {
+    status.count[1]++;
+  }
+  uint32_t higherBits = static_cast<uint64_t>(size) >> kShiftAmount;
+  status.count[1] += higherBits * kByteLength;
+
+  size_t idx = tmp & kBitMask;
+  size_t remain = kGroupSize - idx;
+  auto *position = &data;
+
+  if (idx != 0) {
+    if (size < remain) {
+      if (memcpy_s(&status.buffer[idx], kGroupSize, &data, size) != EOK) {
+        return;
+      }
+      return;
+    }
+
+    if (memcpy_s(&status.buffer[idx], kGroupSize, &data, remain) != EOK) {
+      return;
+    }
+    (void)MuidTransform(status, *status.buffer, 1);
+
+    size -= remain;
+    position += remain;
+  }
+
+  if (size >= kGroupSize) {
+    position = MuidTransform(status, *position, size / kGroupSize);
+    size &= kBitMask;
+  }
+
+  if (memcpy_s(status.buffer, kGroupSize, position, size) != EOK) {
+    return;
+  }
+}
+
+/*
+ * Encoding part(unsigned int to byte).
+ */
+template<typename T>
+void FullEncode(T &result, MuidContext &status) {
+  size_t idx = status.count[0] & kBitMask;
+  status.buffer[idx++] = 0x80;
+
+  size_t remain = kGroupSize - idx;
+
+  if (remain < kByteLength) {
+    if (memset_s(&status.buffer[idx], kGroupSize, 0, remain) != EOK) {
+      return;
+    }
+    (void)MuidTransform(status, *status.buffer, 1);
+    idx = 0;
+    remain = kGroupSize;
+  }
+
+  if (memset_s(&status.buffer[idx], kGroupSize, 0, remain - kByteLength) != EOK) {
+    return;
+  }
+  status.count[0] *= kByteLength;
+  const unsigned int indexOfLastEight = 56;
+  const unsigned int indexOfLastFour = 60;
+  ENCODE(&status.buffer[indexOfLastEight], status.count[0])
+  ENCODE(&status.buffer[indexOfLastFour], status.count[1])
+
+  (void)MuidTransform(status, *status.buffer, 1);
+  ENCODE(&result[0], status.a)
+  ENCODE(&result[4], status.b)
+}
+
+void MuidEncode(unsigned char (&result)[kDigestShortHashLength], MuidContext &status) {
+  FullEncode(result, status);
+  if (memset_s(&status, sizeof(status), 0, sizeof(status)) != EOK) {
+    return;
+  }
+}
+
+void MuidEncode(unsigned char (&result)[kDigestHashLength], MuidContext &status, bool use64Bit) {
+  FullEncode(result, status);
+  if (!use64Bit) {
+    ENCODE(&result[8], status.c)
+    ENCODE(&result[12], status.d)
+  }
+  if (memset_s(&status, sizeof(status), 0, sizeof(status)) != EOK) {
+    return;
+  }
+}
+
+/*
+ * The entrance functions.
+ */
+void GetMUIDHash(const unsigned char &data, size_t size, MUID &muid) {
+  MuidContext status;
+  MuidInit(status);
+  MuidDecode(status, data, size);
+  MuidEncode(muid.data.bytes, status);
+}
+
+DigestHash GetDigestHash(const unsigned char &bytes, uint32_t len) {
+  DigestHash digestHash;
+  MuidContext digestContext;
+
+  digestHash.data.first = 0;
+  digestHash.data.second = 0;
+
+  MuidInit(digestContext);
+  MuidDecode(digestContext, bytes, len);
+  MuidEncode(digestHash.bytes, digestContext);
+
+  return digestHash;
+}
+
+MUID GetMUID(const std::string &symbolName, bool forSystem) {
+  MUID muid;
+  auto *data = reinterpret_cast<const unsigned char*>(symbolName.c_str());
+  GetMUIDHash(*data, symbolName.length(), muid);
+  if (forSystem) {
+    muid.SetSystemNameSpace();
+  } else {
+    muid.SetApkNameSpace();
+  }
+  return muid;
+}
\ No newline at end of file
diff --git a/src/mapleall/maple_util/src/namemangler.cpp b/src/mapleall/maple_util/src/namemangler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c7c32d35e4b01d08e49518edb35f1d7cef2a5d2
--- /dev/null
+++ b/src/mapleall/maple_util/src/namemangler.cpp
@@ -0,0 +1,705 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "namemangler.h"
+#include <regex>
+#include <cassert>
+#include <map>
+#include <fstream>
+
+namespace namemangler {
+#ifdef __MRT_DEBUG
+#define ASSERT(f) assert(f)
+#else
+#define ASSERT(f) ((void)0)
+#endif
+
+const int kLocalCodebufSize = 1024;
+const int kMaxCodecbufSize = (1 << 16); // Java spec support a max name length of 64K.
+
+#define GETHEXCHAR(n) static_cast<char>((n) < 10 ? (n) + '0' : (n) - 10 + 'a')
+#define GETHEXCHARU(n) static_cast<char>((n) < 10 ? (n) + '0' : (n) - 10 + 'A')
+
+bool doCompression = false;
+
+// Store a mapping between full string and its compressed version
+// More frequent and specific strings go before  general ones,
+// e.g. Ljava_2Flang_2FObject_3B goes before Ljava_2Flang_2F
+//
+using StringMap = std::map<const std::string, const std::string>;
+
+const StringMap kInternalMangleTable = {
+    { "Ljava_2Flang_2FObject_3B", "L0_3B" },
+    { "Ljava_2Flang_2FClass_3B",  "L1_3B" },
+    { "Ljava_2Flang_2FString_3B", "L2_3B" }
+};
+
+// This mapping is mainly used for compressing annotation strings
+const StringMap kOriginalMangleTable = {
+    { "Ljava/lang/Object", "L0" },
+    { "Ljava/lang/Class",  "L1" },
+    { "Ljava/lang/String", "L2" }
+};
+
+// The returned buffer needs to be explicitly freed
+static inline char *AllocCodecBuf(size_t maxLen) {
+  if (maxLen == 0) {
+    return nullptr;
+  }
+  // each char may have 2 more char, so give out the max space buffer
+  return reinterpret_cast<char*>(malloc((maxLen <= kLocalCodebufSize) ? 3 * maxLen : 3 * kMaxCodecbufSize));
+}
+
+static inline void FreeCodecBuf(char *buf) {
+  free(buf);
+}
+
+static std::string CompressName(std::string &name, const StringMap &mapping = kInternalMangleTable) {
+  for (auto &entry : mapping) {
+    if (name.find(entry.first) != std::string::npos) {
+      name = std::regex_replace(name, std::regex(entry.first), entry.second);
+    }
+  }
+  return name;
+}
+
+static std::string DecompressName(std::string &name, const StringMap &mapping = kInternalMangleTable) {
+  for (auto &entry : mapping) {
+    if (name.find(entry.second) != std::string::npos) {
+      name = std::regex_replace(name, std::regex(entry.second), entry.first);
+    }
+  }
+  return name;
+}
+
+std::string GetInternalNameLiteral(std::string name) {
+  return (doCompression ? CompressName(name) : name);
+}
+
+std::string GetOriginalNameLiteral(std::string name) {
+  return (doCompression ? CompressName(name, kOriginalMangleTable) : name);
+}
+
+std::string EncodeName(const std::string &name) {
+  // name is guaranteed to be null-terminated
+  size_t nameLen = name.length();
+  nameLen = nameLen > kMaxCodecbufSize ? kMaxCodecbufSize : nameLen;
+  char *buf = AllocCodecBuf(nameLen);
+  if (buf == nullptr) {
+    return std::string(name);
+  }
+
+  size_t pos = 0;
+  size_t i = 0;
+  std::string str(name);
+  std::u16string str16;
+  while (i < nameLen) {
+    unsigned char c = static_cast<unsigned char>(name[i]);
+    if (c == '_') {
+      buf[pos++] = '_';
+      buf[pos++] = '_';
+    } else if (c == '[') {
+      buf[pos++] = 'A';
+    } else if (isalnum(c)) {
+      buf[pos++] = static_cast<char>(c);
+    } else if (c <= 0x7F) {
+      // _XX: '_' followed by ascii code in hex
+      if (c == '.') {
+        c = '/'; // use / in package name
+      }
+      buf[pos++] = '_';
+      unsigned char n = c >> 4; // get the high 4 bit and calculate
+      buf[pos++] = GETHEXCHARU(n);
+      n = static_cast<unsigned char>(c - static_cast<unsigned char>(n << 4)); // revert
+      buf[pos++] = GETHEXCHARU(n);
+    } else {
+      str16.clear();
+      // process one 16-bit char at a time
+      unsigned int n = UTF8ToUTF16(str16, str.substr(i), 1, false);
+      buf[pos++] = '_';
+      if ((n >> 16) == 1) { // if n is 16-bit
+        unsigned short m = str16[0];
+        buf[pos++] = 'u';
+        buf[pos++] = GETHEXCHAR((m & 0xF000) >> 12);
+        buf[pos++] = GETHEXCHAR((m & 0x0F00) >> 8);
+        buf[pos++] = GETHEXCHAR((m & 0x00F0) >> 4);
+        buf[pos++] = GETHEXCHAR(m & 0x000F);
+      } else {
+        unsigned short m = str16[0];
+        buf[pos++] = 'U';
+        buf[pos++] = GETHEXCHAR((m & 0xF000) >> 12);
+        buf[pos++] = GETHEXCHAR((m & 0x0F00) >> 8);
+        buf[pos++] = GETHEXCHAR((m & 0x00F0) >> 4);
+        buf[pos++] = GETHEXCHAR(m & 0x000F);
+        m = str16[1];
+        buf[pos++] = GETHEXCHAR((m & 0xF000) >> 12);
+        buf[pos++] = GETHEXCHAR((m & 0x0F00) >> 8);
+        buf[pos++] = GETHEXCHAR((m & 0x00F0) >> 4);
+        buf[pos++] = GETHEXCHAR(m & 0x000F);
+      }
+      i += static_cast<size_t>(int32_t(n & 0xFFFF) - 1);
+    }
+    i++;
+  }
+
+  buf[pos] = '\0';
+  std::string newName = std::string(buf, pos);
+  FreeCodecBuf(buf);
+  if (doCompression) {
+    newName = CompressName(newName);
+  }
+  return newName;
+}
+
+static inline bool UpdatePrimType(bool primType, int splitNo, uint32_t ch) {
+  if (ch == 'L') {
+    return false;
+  }
+
+  if (((ch == ';') || (ch == '(') || (ch == ')')) && (splitNo > 1)) {
+    return true;
+  }
+
+  return primType;
+}
+
+const int kNumLimit = 10;
+const int kCodeOffset3 = 12;
+const int kCodeOffset2 = 8;
+const int kCodeOffset = 4;
+const int kJavaStrLength = 5;
+
+std::string DecodeName(const std::string &name) {
+  if (name.find(';') != std::string::npos) { // no need Decoding a non-encoded string
+    return name;
+  }
+  std::string decompressedName;
+  const char *namePtr = nullptr;
+  size_t nameLen;
+
+  if (doCompression) {
+    decompressedName = name;
+    decompressedName = DecompressName(decompressedName);
+    namePtr = decompressedName.c_str();
+    nameLen = decompressedName.length();
+  }
+  else {
+    namePtr = name.c_str();
+    nameLen = name.length();
+  }
+
+  // Demangled name is supposed to be shorter. No buffer overflow issue here.
+  std::string newName(nameLen, '\0');
+
+  bool primType = true;
+  int splitNo = 0; // split: class 0 | method 1 | signature 2
+  size_t pos = 0;
+  std::string str;
+  std::u16string str16;
+  for (size_t i = 0; i < nameLen;) {
+    unsigned char c = static_cast<unsigned char>(namePtr[i]);
+    ++i;
+    if (c == '_') { // _XX: '_' followed by ascii code in hex
+      if (i >= nameLen) {
+        break;
+      }
+      if (namePtr[i] == '_') {
+        newName[pos++] = namePtr[i++];
+      } else if (namePtr[i] == 'u') {
+        str.clear();
+        str16.clear();
+        i++;
+        c = static_cast<unsigned char>(namePtr[i++]);
+        uint8_t b1 = (c <= '9') ? c - '0' : c - 'a' + kNumLimit;
+        c = static_cast<unsigned char>(namePtr[i++]);
+        uint8_t b2 = (c <= '9') ? c - '0' : c - 'a' + kNumLimit;
+        c = static_cast<unsigned char>(namePtr[i++]);
+        uint8_t b3 = (c <= '9') ? c - '0' : c - 'a' + kNumLimit;
+        c = static_cast<unsigned char>(namePtr[i++]);
+        uint8_t b4 = (c <= '9') ? c - '0' : c - 'a' + kNumLimit;
+        uint32_t codepoint = (b1 << kCodeOffset3) | (b2 << kCodeOffset2) | (b3 << kCodeOffset) | b4;
+        str16 += static_cast<char16_t>(codepoint);
+        unsigned int n = UTF16ToUTF8(str, str16, 1, false);
+        if ((n >> 16) == 2) { // the count of str equal 2 to 4, use array to save the utf8 results
+          newName[pos++] = str[0];
+          newName[pos++] = str[1];
+        } else if ((n >> 16) == 3) {
+          newName[pos++] = str[0];
+          newName[pos++] = str[1];
+          newName[pos++] = str[2];
+        } else if ((n >> 16) == 4) {
+          newName[pos++] = str[0];
+          newName[pos++] = str[1];
+          newName[pos++] = str[2];
+          newName[pos++] = str[3];
+        }
+      } else {
+        c = static_cast<unsigned char>(namePtr[i++]);
+        unsigned int v = (c <= '9') ? c - '0' : c - 'A' + kNumLimit;
+        unsigned int asc = v << kCodeOffset;
+        if (i >= nameLen) {
+          break;
+        }
+        c = static_cast<unsigned char>(namePtr[i++]);
+        v = (c <= '9') ? c - '0' : c - 'A' + kNumLimit;
+        asc += v;
+
+        newName[pos++] = static_cast<char>(asc);
+
+        if (asc == '|') {
+          splitNo++;
+        }
+
+        primType = UpdatePrimType(primType, splitNo, asc);
+      }
+    } else {
+      if (splitNo < 2) { // split: class 0 | method 1 | signature 2
+        newName[pos++] = static_cast<char>(c);
+        continue;
+      }
+
+      primType = UpdatePrimType(primType, splitNo, c);
+      if (primType) {
+        newName[pos++] = (c == 'A') ? '[' : static_cast<char>(c);
+      } else {
+        newName[pos++] = static_cast<char>(c);
+      }
+    }
+  }
+
+  newName.resize(pos);
+  return newName;
+}
+
+// input: maple name
+// output: Ljava/lang/Object;  [Ljava/lang/Object;
+void DecodeMapleNameToJavaDescriptor(const std::string &nameIn, std::string &nameOut) {
+  nameOut = DecodeName(nameIn);
+  if (nameOut[0] == 'A') {
+    size_t i = 0;
+    while (nameOut[i] == 'A') {
+      nameOut[i++] = '[';
+    }
+  }
+}
+
+// convert maple name to java name
+// http://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/design.html#resolving_native_method_names
+std::string NativeJavaName(const std::string &name, bool overLoaded) {
+  // Decompress name first because the generated native function name needs
+  // to follow certain spec, not something maple can control.
+  std::string decompressedName(name);
+  if (doCompression) {
+    decompressedName = DecompressName(decompressedName);
+  }
+
+  unsigned int nameLen = static_cast<unsigned int>(decompressedName.length()) + kJavaStrLength;
+  std::string newName = "Java_";
+  unsigned int i = 0;
+
+  // leading A's are array
+  while (i < nameLen && name[i] == 'A') {
+    newName += "_3";
+    i++;
+  }
+
+  bool isProto = false; // class names in prototype have 'L' and ';'
+  bool isFuncname = false;
+  bool isTypename = false;
+  while (i < nameLen) {
+    char c = decompressedName[i];
+    if (c == '_') {
+      i++;
+      // UTF16 unicode
+      if (decompressedName[i] == 'u') {
+        newName += "_0";
+        i++;
+      } else if (decompressedName[i] == '_') {
+        newName += "_1";
+        i++;
+      } else {
+        // _XX: '_' followed by ascii code in hex
+        c = decompressedName[i++];
+        unsigned char v =
+            (c <= '9') ? static_cast<unsigned char>(c - '0') : static_cast<unsigned char>((c - 'A') + kNumLimit);
+        unsigned char asc = v << kCodeOffset;
+        c = decompressedName[i++];
+        v = (c <= '9') ? c - '0' : static_cast<unsigned char>((c - 'A') + kNumLimit);
+        asc += v;
+        if (asc == '/') {
+          newName += "_";
+        } else if (asc == '|' && !isFuncname) {
+          newName += "_";
+          isFuncname = true;
+        } else if (asc == '|' && isFuncname) {
+          if (!overLoaded) {
+            break;
+          }
+          newName += "_";
+          isFuncname = false;
+        } else if (asc == '(') {
+          newName += "_";
+          isProto = true;
+        } else if (asc == ')') {
+          break;
+        } else if (asc == ';' && !isFuncname) {
+          if (isProto) {
+            newName += "_2";
+          }
+          isTypename = false;
+        } else if (asc == '$') {
+          newName += "_00024";
+        } else if (asc == '-') {
+          newName += "_0002d";
+        } else {
+          printf("name = %s\n", decompressedName.c_str());
+          printf("c = %c\n", asc);
+          ASSERT(false && "more cases in NativeJavaName");
+        }
+      }
+    } else {
+      if (c == 'L' && !isFuncname && !isTypename) {
+        if (isProto) {
+          newName += c;
+        }
+        isTypename = true;
+        i++;
+      } else if (c == 'A' && !isTypename && !isFuncname) {
+        while (name[i] == 'A') {
+          newName += "_3";
+          i++;
+        }
+      } else {
+        newName += c;
+        i++;
+      }
+    }
+  }
+  return newName;
+}
+
+static uint16_t ChangeEndian16(uint16_t u16) {
+  return ((u16 & 0xFF00) >> kCodeOffset2) | ((u16 & 0xFF) << kCodeOffset2);
+}
+
+/* UTF8
+ * U+0000 - U+007F   0xxxxxxx
+ * U+0080 - U+07FF   110xxxxx 10xxxxxx
+ * U+0800 - U+FFFF   1110xxxx 10xxxxxx 10xxxxxx
+ * U+10000- U+10FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ *
+ * UTF16
+ * U+0000 - U+D7FF   codePoint
+ * U+E000 - U+FFFF   codePoint
+ * U+10000- U+10FFFF XXXX YYYY
+ *   code = codePoint - 0x010000, ie, 20-bit number in the range 0x000000..0x0FFFFF
+ *   XXXX: top 10 bits of code + 0xD800: 0xD800..0xDBFF
+ *   YYYY: low 10 bits of code + 0xDC00: 0xDC00..0xDFFF
+ *
+ * convert upto num UTF8 elements
+ * return two 16-bit values: return_number_of_elements | consumed_input_number_of_elements
+ */
+const int kCodepointOffset1 = 6; // U+0080 - U+07FF   110xxxxx 10xxxxxx
+const int kCodepointOffset2 = 12; // U+0800 - U+FFFF   1110xxxx 10xxxxxx 10xxxxxx
+const int kCodepointOffset3 = 18; // U+10000- U+10FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+const int kCountOffset = 16;
+const int kCodeAfterMinusOffset = 10; // codePoint equals itself minus 0x10000
+
+unsigned UTF16ToUTF8(std::string &str, const std::u16string &str16, unsigned short num, bool isBigEndian) {
+  uint32_t codePoint = 0;
+  uint32_t i = 0;
+  unsigned short count = 0;
+  unsigned short retNum = 0;
+  while (i < str16.length()) {
+    if (isBigEndian || num == 1) {
+      codePoint = str16[i++];
+    } else {
+      codePoint = ChangeEndian16(str16[i++]);
+    }
+    if (codePoint > 0xFFFF) {
+      codePoint &= 0x3FF;
+      codePoint <<= kNumLimit;
+      if (isBigEndian) {
+        codePoint += str16[i++] & 0x3FF;
+      } else {
+        codePoint += ChangeEndian16(str16[i++]) & 0x3FF;
+      }
+    }
+    if (codePoint <= 0x7F) {
+      str += static_cast<char>(codePoint);
+      retNum += 1; // one UTF8 char
+    } else if (codePoint <= 0x7FF) {
+      str += static_cast<char>(0xC0 + (codePoint >> kCodepointOffset1));
+      str += static_cast<char>(0x80 + (codePoint & 0x3F));
+      retNum += 2; // two UTF8 chars
+    } else if (codePoint <= 0xFFFF) {
+      str += static_cast<char>(0xE0 + ((codePoint >> kCodepointOffset2) & 0xF));
+      str += static_cast<char>(0x80 + ((codePoint >> kCodepointOffset1) & 0x3F));
+      str += static_cast<char>(0x80 + (codePoint & 0x3F));
+      retNum += 3; // three UTF8 chars
+    } else {
+      str += static_cast<char>(0xF0 + ((codePoint >> kCodepointOffset3) & 0x7));
+      str += static_cast<char>(0x80 + ((codePoint >> kCodepointOffset2) & 0x3F));
+      str += static_cast<char>(0x80 + ((codePoint >> kCodepointOffset1) & 0x3F));
+      str += static_cast<char>(0x80 + (codePoint & 0x3F));
+      retNum += 4; // four UTF8 chars
+    }
+    count++;
+    if (num == count) {
+      return ((static_cast<unsigned>(retNum)) << kCountOffset) | static_cast<unsigned>(i);
+    }
+  }
+  return i;
+}
+
+bool NeedConvertUTF16(const std::string &str8) {
+  uint32_t a = 0;
+  size_t i = 0;
+  size_t size = str8.length();
+  while (i < size) {
+    a = static_cast<uint8_t>(str8[i++]);
+    constexpr uint8_t maxValidAscii = 0x7F;
+    if (a > maxValidAscii) {
+      return true;
+    }
+  }
+  return false;
+}
+
+uint32_t GetCodePoint(const std::string &str8, uint32_t &i) {
+  uint32_t b;
+  uint32_t c;
+  uint32_t d;
+  uint32_t codePoint = 0;
+  uint32_t a = static_cast<uint8_t>(str8[i++]);
+  if (a <= 0x7F) { // 0...
+    codePoint = a;
+  } else if (a >= 0xF0) { // 11110...
+    b = static_cast<uint32_t>(str8[i++]);
+    c = static_cast<uint32_t>(str8[i++]);
+    d = static_cast<uint32_t>(str8[i++]);
+    codePoint = ((a & 0x7) << kCodepointOffset3) | ((b & 0x3F) << kCodepointOffset2) |
+                ((c & 0x3F) << kCodepointOffset1) | (d & 0x3F);
+  } else if (a >= 0xE0) { // 1110...
+    b = static_cast<uint32_t>(str8[i++]);
+    c = static_cast<uint32_t>(str8[i++]);
+    codePoint = ((a & 0xF) << kCodepointOffset2) | ((b & 0x3F) << kCodepointOffset1) | (c & 0x3F);
+  } else if (a >= 0xC0) { // 110...
+    b = static_cast<uint32_t>(str8[i++]);
+    codePoint = ((a & 0x1F) << kCodepointOffset1) | (b & 0x3F);
+  } else {
+    ASSERT(false && "invalid UTF-8");
+  }
+  return codePoint;
+}
+
+// convert upto num UTF16 elements
+// two 16-bit values: return_number_of_elements | consumed_input_number_of_elements
+unsigned UTF8ToUTF16(std::u16string &str16, const std::string &str8, unsigned short num, bool isBigEndian) {
+  uint32_t i = 0;
+  unsigned short count = 0;
+  unsigned short retNum = 0;
+  while (i < str8.length()) {
+    uint32_t codePoint = GetCodePoint(str8, i);
+    if (codePoint <= 0xFFFF) {
+      if (isBigEndian || num == 1) {
+        str16 += static_cast<char16_t>(codePoint);
+      } else {
+        str16 += static_cast<char16_t>(ChangeEndian16(static_cast<uint16_t>(codePoint)));
+      }
+      retNum += 1; // one utf16
+    } else {
+      codePoint -= 0x10000;
+      if (isBigEndian || num == 1) {
+        str16 += static_cast<char16_t>((codePoint >> kCodeAfterMinusOffset) | 0xD800);
+        str16 += static_cast<char16_t>((codePoint & 0x3FF) | 0xDC00);
+      } else {
+        str16 += static_cast<char16_t>(
+            ChangeEndian16(static_cast<uint16_t>((codePoint >> kCodeAfterMinusOffset) | 0xD800)));
+        str16 += static_cast<char16_t>(ChangeEndian16((codePoint & 0x3FF) | 0xDC00));
+      }
+      retNum += 2; // two utf16
+    }
+    count++;
+    // only convert num elmements
+    if (num == count) {
+      return (static_cast<char16_t>(retNum) << kCountOffset) | static_cast<char16_t>(i);
+    }
+  }
+  return i;
+}
+
+const uint32_t kGreybackOffset = 7;
+void GetUnsignedLeb128Encode(std::vector<uint8_t> &dest, uint32_t value) {
+  bool done = false;
+  do {
+    uint8_t byte = value & 0x7f;
+    value >>= kGreybackOffset;
+    done = (value == 0);
+    if (!done) {
+      byte |= 0x80;
+    }
+    dest.push_back(byte);
+  } while (!done);
+}
+
+uint32_t GetUnsignedLeb128Decode(const uint8_t **data) {
+  ASSERT(data != nullptr && "data in GetUnsignedLeb128Decode() is nullptr");
+  const uint8_t *ptr = *data;
+  uint32_t result = 0;
+  uint32_t shift = 0;
+  uint8_t byte = 0;
+  while (true) {
+    byte = *(ptr++);
+    result |= static_cast<uint8_t>(byte & 0x7f) << shift;
+    if ((byte & 0x80) == 0) {
+      break;
+    }
+    shift += kGreybackOffset;
+  }
+  *data = ptr;
+  return result;
+}
+
+size_t GetUleb128Size(uint64_t v) {
+  ASSERT(v && "if v == 0, __builtin_clzll(v) is not defined");
+  size_t clz = static_cast<size_t>(__builtin_clzll(v));
+  // num of 7-bit groups
+  return size_t((64 - clz + 6) / 7);
+}
+
+size_t GetSleb128Size(int32_t v) {
+  size_t size = 0;
+  int rem = v >> kGreybackOffset;
+  bool hasMore = true;
+  int end = ((v >= 0) ? 0 : -1);
+
+  while (hasMore) {
+    // judege whether has more valid rem
+    hasMore = (rem != end) || ((static_cast<uint32_t>(rem) & 1) !=
+        (static_cast<uint>((static_cast<uint32_t>(v) >> 6)) & 1));
+    size++;
+    v = rem;
+    rem >>= static_cast<int>(kGreybackOffset); // intended signed shift: block codedex here
+  }
+  return size;
+}
+
+// encode signed to output stream
+uint32_t EncodeSLEB128(uint64_t value, std::ofstream &out) {
+  bool more;
+  uint32_t count = 0;
+  do {
+    uint8_t byte = value & 0x7f;
+    // NOTE: this assumes that this signed shift is an arithmetic right shift.
+    value >>= kGreybackOffset;
+    more = !((((value == 0) && ((byte & 0x40) == 0)) ||
+             ((value == static_cast<uint64_t>(-1)) && ((byte & 0x40) != 0))));
+    count++;
+    if (more) {
+      byte |= 0x80; // Mark this byte to show that more bytes will follow.
+    }
+    out << static_cast<char>(byte);
+  } while (more);
+  return count;
+}
+
+uint32_t EncodeULEB128(uint64_t value, std::ofstream &out) {
+  uint32_t count = 0;
+  do {
+    uint8_t byte = value & 0x7f;
+    value >>= kGreybackOffset;
+    count++;
+    if (value != 0) {
+      byte |= 0x80; // Mark this byte to show that more bytes will follow.
+    }
+    out << char(byte);
+  } while (value != 0);
+  return count;
+}
+
+// decode a ULEB128 value.
+uint64_t DecodeULEB128(const uint8_t *p, unsigned *n, const uint8_t *end) {
+  const uint8_t *origP = p;
+  uint64_t value = 0;
+  unsigned shift = 0;
+  enum Literals {
+    kOneHundredTwentyEight = 128,
+    kSixtyFour = 64
+  };
+  do {
+    if (p == end) {
+      if (n) {
+        *n = static_cast<unsigned>(p - origP);
+      }
+      return 0;
+    }
+    uint64_t slice = *p & 0x7f;
+    if ((shift >= kSixtyFour && slice != 0) || ((slice << shift) >> shift) != slice) {
+      if (n) {
+        *n = static_cast<unsigned>(p - origP);
+      }
+      return 0;
+    }
+    value += slice << shift;
+    shift += kGreybackOffset;
+  } while (*p++ >= kOneHundredTwentyEight);
+  if (n) {
+    *n = static_cast<unsigned>(p - origP);
+  }
+  return value;
+}
+
+// decode a SLEB128 value.
+int64_t DecodeSLEB128(const uint8_t *p, unsigned *n, const uint8_t *end) {
+  const uint8_t *origP = p;
+  int64_t value = 0;
+  unsigned shift = 0;
+  uint8_t byte;
+  enum Literals {
+    kOneHundredTwentyEight = 128,
+    kSixtyFour = 64,
+    kSixtyThree = 63
+  };
+  do {
+    if (p == end) {
+      if (n) {
+        *n = static_cast<unsigned>(p - origP);
+      }
+      return 0;
+    }
+    byte = *p;
+    uint64_t slice = byte & 0x7f;
+    if ((shift >= kSixtyFour && slice != (value < static_cast<int64_t>(0) ? 0x7f : 0x00)) ||
+        (shift == kSixtyThree && slice != 0 && slice != 0x7f)) {
+      if (n) {
+        *n = static_cast<unsigned>(p - origP);
+      }
+      return 0;
+    }
+    value |= static_cast<int64_t>(slice << shift);
+    shift += kGreybackOffset;
+    ++p;
+  } while (byte >= kOneHundredTwentyEight);
+  // Sign extend negative numbers if needed.
+  if (shift < kSixtyFour && (byte & 0x40)) {
+    value = static_cast<int64_t>(static_cast<uint64_t>(value) | static_cast<uint64_t>(0xffffffffffffffff << shift));
+  }
+  if (n) {
+    *n = static_cast<unsigned>(p - origP);
+  }
+  return value;
+}
+
+} // namespace namemangler
diff --git a/src/mapleall/maple_util/src/profile.cpp b/src/mapleall/maple_util/src/profile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9787b9aabb85272cc196fdff50c6563cfb786c74
--- /dev/null
+++ b/src/mapleall/maple_util/src/profile.cpp
@@ -0,0 +1,687 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "profile.h"
+#include <cassert>
+#include <cstring>
+#include <fstream>
+#include <istream>
+#include <iostream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <sys/types.h>
+#include <cerrno>
+#include <algorithm>
+#include <sstream>
+#include "namemangler.h"
+#include "file_layout.h"
+#include "types_def.h"
+#include "itab_util.h"
+
+namespace maple {
+constexpr uint8 Profile::stringEnd = 0x00;
+uint32 Profile::hotFuncCountThreshold = 0;
+bool Profile::debug = false;
+bool Profile::initialized = false;
+constexpr uint32 kPrecision = 1000000;
+// preHot data
+const std::string Profile::preClassHot[] = {
+    "Ljava/lang/Class;",
+    "Ljava/lang/Object;",
+    "Ljava/lang/reflect/Field;",
+    "Ljava/lang/reflect/Constructor;",
+    "Ljava/lang/reflect/Method;",
+    "Ljava/lang/reflect/Executable;",
+    "Ljava/lang/String;"
+};
+
+const std::string Profile::preMethodHot[] = {
+    "Landroid/util/ContainerHelpers;",
+    "Landroid/util/SparseArray;"
+};
+
+Profile::Profile() {}
+
+bool Profile::CheckProfileHeader(const Header &header) const {
+  return (memcmp(header.magic, kProfileMagic, sizeof(kProfileMagic)) == 0);
+}
+
+std::string Profile::GetProfileNameByType(uint8 type) const {
+  switch (type) {
+    case kFunction:
+      return "FUNCTION";
+    case kClassMeta:
+      return "CLASSMETA";
+    case kFieldMeta:
+      return "FIELDMETA";
+    case kMethodMeta:
+      return "METHODMETA";
+    case kReflectionStr:
+      return "ReflectionStr";
+    case kLiteral:
+      return "Literal";
+    case kBBInfo:
+      return "IRProfDescption";
+    case kIRCounter:
+      return "IRProfCounter";
+    case kFileDesc:
+      return "FileDescription";
+    default:
+      CHECK_FATAL(false, "type not found");
+  }
+}
+
+bool Profile::CheckDexValid(uint32 idx) const {
+  if (isAppProfile) {
+    return true; // for app dont't check dexName
+  }
+  return (dexName.empty() || dexName.find(strMap.at(idx)) != std::string::npos);
+}
+
+void Profile::ParseLiteral(const char *data, const char *end) {
+  if (data > end) {
+    LogInfo::MapleLogger() << "parse Literal error" << '\n';
+  }
+  const std::string str(data, end - data);
+  std::stringstream ss;
+  ss.str(str);
+  std::string item;
+  while (std::getline(ss, item)) {
+    literal.insert(item);
+  }
+  if (debug) {
+    LogInfo::MapleLogger() << "parse Literal succ literal size " << literal.size() << "\n";
+  }
+}
+
+std::string Profile::GetFunctionName(uint32 classIdx, uint32 methodIdx, uint32 sigIdx) const {
+  const std::string className = namemangler::EncodeName(strMap.at(classIdx));
+  const std::string methodName = namemangler::EncodeName(strMap.at(methodIdx));
+  const std::string sigName = namemangler::EncodeName(strMap.at(sigIdx));
+  const std::string funcName = className + "_7C" + methodName + "_7C" + sigName;
+  return funcName;
+}
+
+std::string Profile::GetMethodSigStr(uint32 methodIdx, uint32 sigIdx) const {
+  const std::string methodName = namemangler::EncodeName(strMap.at(methodIdx));
+  const std::string sigName = namemangler::EncodeName(strMap.at(sigIdx));
+  const std::string methodSigStr = methodName + "_7C" + sigName;
+  return methodSigStr;
+}
+
+void Profile::ParseFunc(const char *data, int32 fileNum) {
+  const MapleFileProf *funcProf = nullptr;
+  const FunctionItem *funcItem = nullptr;
+  size_t offset = 0;
+  for (int32 mapleFileIdx = 0; mapleFileIdx < fileNum; ++mapleFileIdx) {
+    funcProf = reinterpret_cast<const MapleFileProf*>(data + offset);
+    if (CheckDexValid(funcProf->idx)) {
+      if (debug) {
+        LogInfo::MapleLogger() << "FuncProfile" << ":" << strMap.at(funcProf->idx) << ":" << funcProf->num << "\n";
+      }
+      funcItem = reinterpret_cast<const FunctionItem*>(data + offset + sizeof(MapleFileProf));
+      for (uint32 item = 0; item < funcProf->num; ++item, ++funcItem) {
+        if (funcItem->type >= kLayoutTypeCount) {
+          if (debug) {
+            LogInfo::MapleLogger() << "ParseFunc Error usupport type " << funcItem->type << "\n";
+          }
+          continue;
+        }
+        std::string funcName = GetFunctionName(funcItem->classIdx, funcItem->methodIdx, funcItem->sigIdx);
+        funcProfData.insert(
+            std::make_pair(funcName, (FuncItem){ .callTimes = funcItem->callTimes, .type = funcItem->type }));
+      }
+    }
+    // new maple file's profile
+    offset += sizeof(MapleFileProf) + funcProf->size;
+  }
+}
+
+void Profile::ParseMethodSignature(const char *data, int fileNum, std::unordered_set<std::string> &metaData) const {
+  const MapleFileProf *methodSigProf = nullptr;
+  const MethodSignatureItem *methodSigItem = nullptr;
+  uint32_t offset = 0;
+  for (int32 mapleFileIdx = 0; mapleFileIdx < fileNum; ++mapleFileIdx) {
+    methodSigProf = reinterpret_cast<const MapleFileProf*>(data + offset);
+    if (CheckDexValid(methodSigProf->idx)) {
+      if (debug) {
+        LogInfo::MapleLogger() << "MethodSignatureProfile" << ":"
+                               << strMap.at(methodSigProf->idx) << ":" << methodSigProf->num << "\n";
+      }
+      methodSigItem = reinterpret_cast<const MethodSignatureItem*>(data + offset + sizeof(MapleFileProf));
+      for (uint32 item = 0; item < methodSigProf->num; ++item, ++methodSigItem) {
+        std::string methodSigStr = GetMethodSigStr(methodSigItem->methodIdx, methodSigItem->sigIdx);
+        metaData.insert(methodSigStr);
+      }
+      // new maple file's profile
+    }
+    offset += sizeof(MapleFileProf) + methodSigProf->size;
+  }
+}
+
+void Profile::ParseIRFuncDesc(const char *data, int32 fileNum) {
+  const MapleFileProf *funcProf = nullptr;
+  const FunctionIRProfItem *funcItem = nullptr;
+  size_t offset = 0;
+  for (int32 mapleFileIdx = 0; mapleFileIdx < fileNum; ++mapleFileIdx) {
+    funcProf = reinterpret_cast<const MapleFileProf*>(data + offset);
+    if (CheckDexValid(funcProf->idx)) {
+      if (debug) {
+        LogInfo::MapleLogger() << "IRFuncProfile" << ":" << strMap.at(funcProf->idx) << ":" << funcProf->num << "\n";
+      }
+      funcItem = reinterpret_cast<const FunctionIRProfItem*>(data + offset + sizeof(MapleFileProf));
+      for (uint32 item = 0; item < funcProf->num; ++item, ++funcItem) {
+        if ((funcItem->counterStart <= counterTab.size()) && (funcItem->counterEnd <= counterTab.size())) {
+          auto begin = counterTab.begin() + funcItem->counterStart;
+          auto end = counterTab.begin() + funcItem->counterEnd + 1;
+          std::vector<uint32> tempCounter(begin, end);
+          BBInfo bbInfo(funcItem->hash, tempCounter.size(), std::move(tempCounter));
+          std::string funcName = GetFunctionName(funcItem->classIdx, funcItem->methodIdx, funcItem->sigIdx);
+          funcBBProfData.emplace(std::make_pair(funcName, bbInfo));
+        }
+      }
+    }
+    // new maple file's profile
+    offset += sizeof(MapleFileProf) + funcProf->size;
+  }
+}
+
+void Profile::ParseCounterTab(const char *data, int32 fileNum) {
+  const MapleFileProf *counterProf = nullptr;
+  size_t offset = 0;
+  for (int32 mapleFileIdx = 0; mapleFileIdx < fileNum; ++mapleFileIdx) {
+    counterProf = reinterpret_cast<const MapleFileProf*>(data + offset);
+    if (CheckDexValid(counterProf->idx)) {
+      if (debug) {
+        LogInfo::MapleLogger() << "module name " << strMap.at(counterProf->idx) << std::endl;
+      }
+      const FuncCounterItem *item = reinterpret_cast<const FuncCounterItem*>(data + offset + sizeof(MapleFileProf));
+      for (uint32 i = 0; i < counterProf->num; ++i, ++item) {
+        counterTab.emplace_back(item->callTimes);
+      }
+    }
+    offset += sizeof(MapleFileProf) + counterProf->size;
+  }
+}
+
+void Profile::ParseMeta(const char *data, int32 fileNum, std::unordered_set<std::string> &metaData) const {
+  const MapleFileProf *metaProf = nullptr;
+  size_t offset = 0;
+  for (int32 mapleFileIdx = 0; mapleFileIdx < fileNum; ++mapleFileIdx) {
+    metaProf = reinterpret_cast<const MapleFileProf*>(data + offset);
+    if (CheckDexValid(metaProf->idx)) {
+      if (debug) {
+        LogInfo::MapleLogger() << "module name " << strMap.at(metaProf->idx) << '\n';
+      }
+      const MetaItem *metaItem = reinterpret_cast<const MetaItem*>(data + offset + sizeof(MapleFileProf));
+      for (uint32 item = 0; item < metaProf->num; ++item, ++metaItem) {
+        metaData.insert(strMap.at(metaItem->idx));
+      }
+    }
+    offset += sizeof(MapleFileProf) + metaProf->size;
+  }
+}
+
+void Profile::ParseReflectionStr(const char *data, int32 fileNum) {
+  const MapleFileProf *metaProf = nullptr;
+  size_t offset = 0;
+  for (int32 mapleFileIdx = 0; mapleFileIdx < fileNum; ++mapleFileIdx) {
+    metaProf = reinterpret_cast<const MapleFileProf*>(data + offset);
+    if (CheckDexValid(metaProf->idx)) {
+      if (debug) {
+        LogInfo::MapleLogger() << "module name " << strMap.at(metaProf->idx) << '\n';
+      }
+
+      const ReflectionStrItem *strItem =
+          reinterpret_cast<const ReflectionStrItem*>(data + offset + sizeof(MapleFileProf));
+      for (uint32 item = 0; item < metaProf->num; ++item, ++strItem) {
+        reflectionStrData.insert(std::make_pair(strMap.at(strItem->idx), strItem->type));
+      }
+    }
+    offset += sizeof(MapleFileProf) + metaProf->size;
+  }
+}
+
+void Profile::InitPreHot() {
+  std::string frameworkDexName = "framework";
+  std::string coreDexName = "core-all";
+  if (dexName.find(frameworkDexName) != std::string::npos) {
+    for (auto &item : preMethodHot) {
+      methodMeta.insert(item);
+    }
+  } else if (dexName.find(coreDexName) != std::string::npos) {
+    for (auto &item : preClassHot) {
+      classMeta.insert(item);
+    }
+    isCoreSo = true;
+  }
+}
+
+bool Profile::DeCompress(const std::string &path, const std::string &dexNameInner, ProfileType type) {
+  if (initialized) {
+    LogInfo::MapleLogger() << "System server Profile has been decompressed before" << '\n';
+    return valid;
+  }
+  initialized = true;
+
+  this->dexName = dexNameInner;
+  InitPreHot();
+  bool res = true;
+  std::ifstream in(path, std::ios::binary);
+  if (!in.is_open()) {
+    if (errno != ENOENT && errno != EACCES) {
+      LogInfo::MapleLogger() << "WARN: DeCompress(" << "), failed to open " << path << '\n';
+    }
+    res = false;
+    return res;
+  }
+  in.seekg(0, std::ios::end);
+  size_t byteCount = static_cast<size_t>(in.tellg());
+  in.seekg(0, std::ios::beg);
+  std::vector<char> bufVector;
+  bufVector.resize(byteCount);
+  char *buf = reinterpret_cast<char*>(bufVector.data());
+  if (!in.read(buf, byteCount)) {
+    LogInfo::MapleLogger() << "WARN: DeCompress(" << "), failed to read all data for " << path << '\n';
+    res = false;
+    in.close();
+    return res;
+  }
+  if (byteCount < sizeof(Header)) {
+    LogInfo::MapleLogger() << "WARN: DeCompress(" << "), failed, read no data for " << path << '\n';
+    res = false;
+    in.close();
+    return res;
+  }
+  Header *header = reinterpret_cast<Header*>(buf);
+  if (!CheckProfileHeader(*header)) {
+    if (debug) {
+      LogInfo::MapleLogger() << "invalid maigc number " << header->magic << '\n';
+    }
+    res = false;
+    in.close();
+    return res;
+  }
+  this->isAppProfile = (header->profileFileType == kApp) ? true : false;
+  size_t stringTabSize = byteCount - header->stringTabOff;
+  if (debug) {
+    LogInfo::MapleLogger() << "Header summary " << "profile num " << static_cast<uint32>(header->profileNum) <<
+        "string table size" << stringTabSize << '\n';
+  }
+  const char *strBuf = buf + header->stringTabOff;
+  const char *cursor = strBuf;
+  const char *sentinel = strBuf + stringTabSize;
+  while (cursor < sentinel) {
+    size_t len = std::strlen(cursor);
+    const char *next = cursor + len + 1;
+    strMap.emplace_back(cursor);
+    cursor = next;
+  }
+  ASSERT(strMap.size() == header->stringCount, "string count doesn't match");
+  if (debug) {
+    LogInfo::MapleLogger() << "str size " << strMap.size() << '\n';
+    for (const auto &item : strMap) {
+      LogInfo::MapleLogger() << item << '\n';
+    }
+    LogInfo::MapleLogger() << "str size print end  " << '\n';
+  }
+  uint8_t idx = 0;
+  for (idx = 0; idx < header->profileNum; ++idx) {
+    ProfileDataInfo *profileDataInfo = &(header->data[idx]);
+    if (debug) {
+      LogInfo::MapleLogger() << "profile file num for type  " << GetProfileNameByType(profileDataInfo->profileType) <<
+          " " << static_cast<uint32>(profileDataInfo->mapleFileNum) << '\n';
+      }
+    if (debug) {
+      LogInfo::MapleLogger() << GetProfileNameByType(profileDataInfo->profileType) << " Start" << '\n';
+    }
+    char *proFileData = buf + profileDataInfo->profileDataOff;
+    if (type != kAll && type != profileDataInfo->profileType) {
+      continue; // only parse the indicated type
+    }
+    switch (profileDataInfo->profileType) {
+      case kFunction:
+        ParseFunc(proFileData, profileDataInfo->mapleFileNum);
+        break;
+      case kClassMeta:
+        ParseMeta(proFileData, profileDataInfo->mapleFileNum, classMeta);
+        break;
+      case kFieldMeta:
+        ParseMeta(proFileData, profileDataInfo->mapleFileNum, fieldMeta);
+        break;
+      case kMethodMeta:
+        ParseMeta(proFileData, profileDataInfo->mapleFileNum, methodMeta);
+        break;
+      case kReflectionStr:
+        ParseReflectionStr(proFileData, profileDataInfo->mapleFileNum);
+        break;
+      case kLiteral:
+        ParseLiteral(proFileData, strBuf);
+        break;
+      case kBBInfo:
+        ParseIRFuncDesc(proFileData, profileDataInfo->mapleFileNum);
+        break;
+      case kIRCounter:
+        ParseCounterTab(proFileData, profileDataInfo->mapleFileNum);
+        break;
+      case kMethodSig:
+        ParseMethodSignature(proFileData, profileDataInfo->mapleFileNum, methodSigMeta);
+        break;
+      case kFileDesc: {
+        uint32_t appPackageNameIdx = *reinterpret_cast<uint32_t*>(proFileData);
+        this->appPackageName = strMap.at(appPackageNameIdx);
+        if (!appPackageName.empty() && this->appPackageName != appPackageName) {
+          LogInfo::MapleLogger() << "app profile doesnt match expect " << this->appPackageName <<
+              " but got " << appPackageName << '\n';
+          return false;
+        }
+        break;
+      }
+      default:
+        LogInfo::MapleLogger() << "unsupported tag " << profileDataInfo->profileType << '\n';
+        break;
+    }
+  }
+  LogInfo::MapleLogger() << "SUCC parse " << path << '\n';
+  valid = true;
+  in.close();
+  return res;
+}
+
+void Profile::SetProfileMode() {
+  profileMode = true;
+}
+
+bool Profile::CheckFuncHot(const std::string &funcName) const {
+  if (funcProfData.empty()) {
+    return false;
+  }
+  if (valid) {
+    auto iter = funcProfData.find(funcName);
+    if (iter == funcProfData.end()) {
+      return false;
+    }
+    if (hotFuncCountThreshold == 0) {
+      if (Options::profileHotCountSeted) {
+        hotFuncCountThreshold = Options::profileHotCount;
+      } else {
+        std::vector<uint32> times;
+        for (auto &item : funcProfData) {
+          times.push_back((item.second).callTimes);
+        }
+        std::sort(times.begin(), times.end(), std::greater<uint32>());
+        size_t index = static_cast<size_t>((static_cast<double>(times.size()) / kPrecision) *
+            (Options::profileHotRate));
+        hotFuncCountThreshold = times.at(index);
+      }
+    }
+    return (iter->second).callTimes >= hotFuncCountThreshold;
+  }
+  return false;
+}
+
+bool Profile::CheckMethodHot(const std::string &className) const {
+  if (methodMeta.empty()) {
+    return true;
+  }
+  if (valid) {
+    if (methodMeta.find(className) == methodMeta.end()) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+bool Profile::CheckMethodSigHot(const std::string &methodSigStr) const {
+  if (methodSigMeta.empty()) {
+    return false;
+  }
+  if (valid) {
+    if (methodSigMeta.find(methodSigStr) == methodSigMeta.end()) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+bool Profile::CheckFieldHot(const std::string &className) const {
+  if (fieldMeta.empty()) {
+    return true;
+  }
+  if (valid) {
+    if (fieldMeta.find(className) == fieldMeta.end()) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+bool Profile::CheckClassHot(const std::string &className) const {
+  // If in mode sample all class set to cold, except for core-all so,core-all have
+  // some hot class pre defined
+  if (profileMode && !isCoreSo) {
+    return false;
+  }
+  if (classMeta.empty()) {
+    return true;
+  }
+  if (valid || isCoreSo) {
+    return classMeta.find(className) != classMeta.end();
+  }
+  return false;
+}
+
+bool Profile::CheckLiteralHot(const std::string &literalInner) const {
+  if (valid) {
+    if ((this->literal).find(literalInner) == (this->literal).end()) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+size_t Profile::GetLiteralProfileSize() const {
+  if (valid) {
+    return literal.size();
+  }
+  return 0;
+}
+
+bool Profile::CheckReflectionStrHot(const std::string &str, uint8 &layoutType) const {
+  if (valid) {
+    auto item = reflectionStrData.find(str);
+    if (item == reflectionStrData.end()) {
+      return false;
+    }
+    layoutType = item->second;
+    return true;
+  }
+  return false;
+}
+
+const std::unordered_map<std::string, Profile::FuncItem>& Profile::GetFunctionProf() const {
+  return funcProfData;
+}
+
+bool Profile::GetFunctionBBProf(const std::string &funcName, Profile::BBInfo &result) {
+  auto item = funcBBProfData.find(funcName);
+  if (item == funcBBProfData.end()) {
+    return false;
+  }
+  result = item->second;
+  return true;
+}
+
+std::unordered_set<std::string> &Profile::GetMeta(uint8 type) {
+  switch (type) {
+    case kClassMeta:
+      return classMeta;
+    case kFieldMeta:
+      return fieldMeta;
+    case kMethodMeta:
+      return methodMeta;
+    default:
+      CHECK_FATAL(false, "type not found");
+  }
+}
+
+void Profile::SetFuncStatus(const std::string &funcName, bool succ) {
+  if (succ) {
+    funcBBProfUseInfo[funcName] = true;
+  }
+}
+
+void Profile::DumpFuncIRProfUseInfo() const {
+  if (funcBBProfData.empty()) {
+    return;
+  }
+  LogInfo::MapleLogger() << "ir profile succ  " << funcBBProfUseInfo.size() << " total func " <<
+      funcBBProfData.size() << '\n';
+}
+
+void Profile::Dump() const {
+  std::ofstream outFile;
+  outFile.open("prof.dump");
+  CHECK_FATAL(!outFile.is_open(), "open file failed");
+  outFile << "classMeta profile start " << '\n';
+  for (const auto &item : classMeta) {
+    outFile << item << '\n';
+  }
+
+  outFile << "fieldMeta profile start " << '\n';
+  for (const auto &item : fieldMeta) {
+    outFile << item << '\n';
+  }
+
+  outFile << "methodMeta profile start " << '\n';
+  for (const auto &item : methodMeta) {
+    outFile << item << '\n';
+  }
+
+  outFile << "literal profile start " << '\n';
+  for (const auto &item : literal) {
+    outFile << item << '\n';
+  }
+
+  outFile << "func profile start " << '\n';
+  for (const auto &item : funcProfData) {
+    outFile << item.first << " " << static_cast<uint32>((item.second).type) << " " << (item.second).callTimes << '\n';
+  }
+
+  outFile << "reflectStr profile start " << '\n';
+  for (const auto &item : reflectionStrData) {
+    outFile << item.first << " " << static_cast<uint32>(item.second) << '\n';
+  }
+  outFile.close();
+}
+
+bool LiteProfile::loaded = false;
+LiteProfile::BBInfo *LiteProfile::GetFuncBBProf(const std::string &funcName) {
+  auto item = funcBBProfData.find(funcName);
+  if (item == funcBBProfData.end()) {
+    return nullptr;
+  }
+  return &item->second;
+}
+
+bool LiteProfile::HandleLitePGOFile(const std::string &fileName, const std::string &moduleName) {
+  if (loaded) {
+    LogInfo::MapleLogger() << "this Profile has been handled before" << '\n';
+    return false;
+  }
+  loaded = true;
+  std::ifstream in(fileName);
+  if (!in.is_open()) {
+    if (errno != ENOENT && errno != EACCES) {
+      LogInfo::MapleLogger() << "WARN: Open lite pgo file (" << "), failed to open " << fileName << '\n';
+    }
+    return false;
+  }
+  std::string line;
+  std::string curfile = "";
+  std::string moduleHashStr = std::to_string(DJBHash(moduleName.c_str()));
+  while (std::getline(in, line)) {
+    ParseFuncBBData(line, curfile, moduleHashStr);
+  }
+  return true;
+}
+
+bool LiteProfile::HandleInstrumentationWhiteList(const std::string &fileName) {
+  std::ifstream in(fileName);
+  if (!in.is_open()) {
+    if (errno != ENOENT && errno != EACCES) {
+      LogInfo::MapleLogger() << "WARN: instrumentation white list(" << "), failed to open " << fileName << '\n';
+    }
+    return false;
+  }
+  std::string line;
+  while (std::getline(in, line)) {
+    std::vector<std::string> context;
+    std::istringstream iss(line);
+    std::string word;
+    while (iss >> word) {
+      context.push_back(word);
+    }
+    if (context.size() == 1) {
+      (void)whiteList.insert(context[0]);
+    } else {
+      CHECK_FATAL(false, "unexpected format in instrumentation white list");
+    }
+  }
+  return true;
+}
+
+std::set<std::string> LiteProfile::whiteList = {};
+uint32 LiteProfile::bbNoThreshold = 100000;
+
+void LiteProfile::ParseFuncBBData(const std::string &line, std::string &curFile, const std::string &moduleHash) {
+  std::vector<std::string> context;
+  std::istringstream iss(line);
+  std::string word;
+  while (iss >> word) {
+    context.push_back(word);
+  }
+
+  int profileCallTime = std::stoi(context[0]);
+  CHECK_FATAL(profileCallTime <= 1, "have not support multiple profile");
+  /* profile file name */
+  std::string fileNameHash = context[1];
+  size_t pos = fileNameHash.find("$$");
+  std::string funcName = fileNameHash.substr(pos + 2);
+  std::string inputModuleHash = fileNameHash.substr(0, pos);
+
+  if (curFile != funcName) {
+    /* skip bb size */
+    curFile = funcName;
+  } else if (moduleHash == inputModuleHash) {
+    /* profile BB count */
+    uint32 bbcounter = static_cast<uint32>(std::stoul(context[2]));
+    if (funcBBProfData.find(funcName) != funcBBProfData.end()) {
+      (void)funcBBProfData.find(funcName)->second.counter.emplace_back(bbcounter);
+    } else {
+      std::vector<uint32> temp;
+      (void)temp.emplace_back(bbcounter);
+      int funcHash = 0x10; /* not implement function hash yet */
+      BBInfo bbInfo(funcHash, std::move(temp));
+      (void)funcBBProfData.emplace(funcName, bbInfo);
+    }
+  }
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_util/src/string_utils.cpp b/src/mapleall/maple_util/src/string_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d8afdb5765354605343f2c591818e9802a846e91
--- /dev/null
+++ b/src/mapleall/maple_util/src/string_utils.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "string_utils.h"
+
+namespace maple {
+std::string StringUtils::Trim(const std::string &src) {
+  // remove space
+  return std::regex_replace(src, std::regex("\\s+"), "");
+}
+
+std::string StringUtils::Replace(const std::string &src, const std::string &target,
+                                 const std::string &replacement) {
+  std::string::size_type replaceLen = replacement.size();
+  std::string::size_type targetLen = target.size();
+  std::string temp = src;
+  std::string::size_type index = 0;
+  index = temp.find(target, index);
+  while (index != std::string::npos) {
+    temp.replace(index, targetLen, replacement);
+    index += replaceLen;
+    index = temp.find(target, index);
+  }
+  return temp;
+}
+
+std::string StringUtils::Append(const std::string &src, const std::string &target, const std::string &spliter) {
+  return src + spliter + target;
+}
+
+std::string StringUtils::GetStrAfterLast(const std::string &src, const std::string &target,
+                                         bool isReturnEmpty) {
+  size_t pos = src.find_last_of(target);
+  if (pos == std::string::npos) {
+    return isReturnEmpty ? "" : src;
+  }
+  return src.substr(pos + 1);
+}
+
+std::string StringUtils::GetStrBeforeLast(const std::string &src, const std::string &target, bool isReturnEmpty) {
+  size_t pos = src.find_last_of(target);
+  if (pos == std::string::npos) {
+    return isReturnEmpty ? "" : src;
+  }
+  return src.substr(0, pos);
+}
+
+void StringUtils::Split(const std::string &src, std::unordered_set<std::string> &container, char delim) {
+  if (Trim(src).empty()) {
+    return;
+  }
+  std::stringstream strStream(src + delim);
+  std::string item;
+  while (std::getline(strStream, item, delim)) {
+    container.insert(item);
+  }
+}
+
+std::regex StringUtils::kCommandInjectionRegex("[;\\|\\&\\$\\>\\<`]");
+}  // namespace maple
diff --git a/src/mapleall/maple_util/src/suffix_array.cpp b/src/mapleall/maple_util/src/suffix_array.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b2e9d9d1197c2a8b9d9914eb86458574245ae97
--- /dev/null
+++ b/src/mapleall/maple_util/src/suffix_array.cpp
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "suffix_array.h"
+#include <cstddef>
+#include <iostream>
+#include <utility>
+#include <vector>
+#include <set>
+
+namespace {
+  constexpr bool kLType = false;
+  constexpr bool kSType = true;
+  constexpr size_t kMinimumRegionLength = 4;
+}
+
+namespace maple {
+bool SuffixArray::IsLmsCharacter(size_t pos) {
+  return pos + 1 > 1 && pos != 0 && suffixType[pos] == kSType && suffixType[pos - 1] == kLType;
+}
+
+bool SuffixArray::IsSubStringEqual(size_t lhs, size_t rhs) {
+  do {
+    if (src[lhs] != src[rhs]) {
+      return false;
+    }
+    ++lhs;
+    ++rhs;
+  } while (!IsLmsCharacter(lhs) && !IsLmsCharacter(rhs));
+  return src[lhs] == src[rhs];
+}
+
+void SuffixArray::InducedSort() {
+  for (size_t i = 0; i < length; ++i) {
+    if (suffixArray[i] + 1 > 1 && suffixType[suffixArray[i] - 1] == kLType) {
+      suffixArray[lBucket[src[suffixArray[i] - 1]]++] = suffixArray[i] - 1;
+    }
+  }
+  for (size_t i = 1; i <= alphabetSize; ++i) {
+    sBucket[i] = bucket[i] - 1;
+  }
+  for (auto i = length - 1; i + 1 > 0; --i) {
+    if (suffixArray[i] + 1 > 1 && suffixType[suffixArray[i] - 1] == kSType) {
+      suffixArray[sBucket[src[suffixArray[i] - 1]]--] = suffixArray[i] - 1;
+    }
+  }
+}
+
+void SuffixArray::BucketInit() {
+  for (size_t i = 0; i < length; ++i) {
+    ++bucket[src[i]];
+  }
+  for (size_t i = 1; i <= alphabetSize; ++i) {
+    bucket[i] += bucket[i - 1];
+    lBucket[i] = bucket[i - 1];
+    sBucket[i] = bucket[i] - 1;
+  }
+}
+
+void SuffixArray::ComputeSuffixType() {
+  suffixType[length - 1] = kSType;
+  for (auto i = length - 2; i + 1 > 0; --i) {
+    if (src[i] < src[i + 1]) {
+      suffixType[i] = kSType;
+    } else if (src[i] > src[i + 1]) {
+      suffixType[i] = kLType;
+    } else {
+      suffixType[i] = suffixType[i + 1];
+    }
+  }
+}
+
+void SuffixArray::FindLmsSubString() {
+  for (size_t i = 1; i < length; ++i) {
+    if (suffixType[i] == kSType && suffixType[i - 1] == kLType) {
+      lmsSubStringPosition[lmsSubStringCount++] = i;
+    }
+  }
+}
+
+void SuffixArray::RenameLmsSubString() {
+  auto lastLmsPos = kInvalidPosition;
+  for (size_t i = 1; i < length; ++i) {
+    if (IsLmsCharacter(suffixArray[i])) {
+      if (lastLmsPos != kInvalidPosition && !IsSubStringEqual(lastLmsPos, suffixArray[i])) {
+        ++lmsCharacterCount;
+      }
+      if (lastLmsPos != kInvalidPosition && lmsCharacterCount == lmsCharacterString[lastLmsPos]) {
+        hasSameLmsSubstring = true;
+      }
+      lmsCharacterString[suffixArray[i]] = lmsCharacterCount;
+      lastLmsPos = suffixArray[i];
+    }
+  }
+  lmsCharacterString[length - 1] = 0;
+}
+
+void SuffixArray::ConstructSuffixArray() {
+  std::vector<size_t> lmsString(lmsSubStringCount, 0);
+  std::vector<size_t> lmsSuffixArray(lmsSubStringCount + 1, 0);
+  size_t position = 0;
+  for (size_t i = 0; i < length; ++i) {
+    if (lmsCharacterString[i] != kInvalidPosition) {
+      lmsString[position++] = lmsCharacterString[i];
+    }
+  }
+  if (hasSameLmsSubstring) {
+    SuffixArray subSA(lmsString, lmsSubStringCount, lmsCharacterCount);
+    subSA.Run();
+    lmsSuffixArray.assign(subSA.GetSuffixArray().begin(), subSA.GetSuffixArray().end());
+  } else {
+    for (size_t i = 0; i < lmsSubStringCount; ++i) {
+      lmsSuffixArray[lmsString[i]] = i;
+    }
+  }
+  lBucket[0] = sBucket[0] = 0;
+  for (size_t i = 1; i <= alphabetSize; ++i) {
+    lBucket[i] = bucket[i - 1];
+    sBucket[i] = bucket[i] - 1;
+  }
+  std::fill(suffixArray.begin(), suffixArray.end(), kInvalidPosition);
+  for (auto i = lmsSubStringCount - 1; i + 1 > 0; --i) {
+    auto lmsSuffix = lmsSuffixArray[i];
+    suffixArray[sBucket[src[lmsSubStringPosition[lmsSuffix]]]--] = lmsSubStringPosition[lmsSuffix];
+  }
+  InducedSort();
+}
+
+void SuffixArray::ComputeLcpArray() {
+  for (size_t i = 0; i < suffixArray.size(); ++i) {
+    rankArray[suffixArray[i]] = i;
+  }
+  for (size_t i = 0, k = 0; i < rankArray.size(); ++i) {
+    if (rankArray[i] == 0) {
+      continue;
+    }
+    k = k ? k - 1 : k;
+    size_t j = suffixArray[rankArray[i] - 1];
+    while (src[i + k] == src[j + k]) {
+      ++k;
+    }
+    heightArray[rankArray[i]] = k;
+  }
+}
+
+void SuffixArray::FindRepeatedSubStrings() {
+  std::vector<SubStringOccurrences *> window;
+  for (size_t i = 1; i < suffixArray.size(); ++i) {
+    auto currLcpLength = heightArray[i];
+    auto currStartPos = suffixArray[i];
+    auto prevStartPos = suffixArray[i - 1];
+    if (currLcpLength < kMinimumRegionLength) {
+      window.clear();
+      continue;
+    }
+    size_t index = 0;
+    for (; index < window.size(); ++index) {
+      auto *tempOccurrences = window[index];
+      auto eleLength = tempOccurrences->length;
+      if (eleLength > currLcpLength) {
+        break;
+      }
+      (void)tempOccurrences->occurrences.emplace_back(std::make_pair(currStartPos, currStartPos + eleLength - 1));
+    }
+    if (index < window.size()) {
+      window.resize(index);
+    } else if (window.empty() || window.back()->length < currLcpLength) {
+      auto startPoint = window.empty() ? kMinimumRegionLength - 1 : window.back()->length;
+      for (auto j = startPoint; j < currLcpLength; ++j) {
+        auto *newOccurrences = new SubStringOccurrences(j + 1);
+        repeatedSubStrings.push_back(newOccurrences);
+        (void)newOccurrences->occurrences.emplace_back(std::make_pair(currStartPos, currStartPos + j));
+        (void)newOccurrences->occurrences.emplace_back(std::make_pair(prevStartPos, prevStartPos + j));
+        (void)window.emplace_back(newOccurrences);
+      }
+    }
+  }
+}
+
+void SuffixArray::Run(bool collectSubString) {
+  BucketInit();
+  ComputeSuffixType();
+  FindLmsSubString();
+  for (size_t i = 0; i < lmsSubStringCount; ++i) {
+    suffixArray[sBucket[src[lmsSubStringPosition[i]]]--] = lmsSubStringPosition[i];
+  }
+  InducedSort();
+  RenameLmsSubString();
+  ConstructSuffixArray();
+  if (collectSubString) {
+    ComputeLcpArray();
+    FindRepeatedSubStrings();
+  }
+}
+
+void SuffixArray::Dump() {
+  LogInfo::MapleLogger() << "suffix array: ";
+  for (auto ele : suffixArray) {
+    LogInfo::MapleLogger() << ele << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+
+  LogInfo::MapleLogger() << "rank array: ";
+  for (auto ele : rankArray) {
+    LogInfo::MapleLogger() << ele << " ";
+  }
+  LogInfo::MapleLogger() << "\n";
+
+  for (size_t i = 0; i < heightArray.size(); ++i) {
+    LogInfo::MapleLogger() << i << ": ";
+    LogInfo::MapleLogger() << "sa[i]: "<< suffixArray[i] << " ";
+    LogInfo::MapleLogger() << "height[i]: "<< heightArray[i] << " ";
+    for (size_t j = 0; j < heightArray[i]; ++j) {
+      LogInfo::MapleLogger() << src[suffixArray[i] + j] << " ";
+    }
+    LogInfo::MapleLogger() << "\n";
+  }
+}
+}
diff --git a/src/mapleall/maple_util/src/thread_env.cpp b/src/mapleall/maple_util/src/thread_env.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5dcae88fbc1a350a8db7ead48ea2361e041e32d5
--- /dev/null
+++ b/src/mapleall/maple_util/src/thread_env.cpp
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "thread_env.h"
+
+namespace maple {
+ThreadEnv ThreadEnv::threadEnv;
+}  // namespace maple
diff --git a/src/mapleall/mempool/BUILD.gn b/src/mapleall/mempool/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..67e1edf1a30b9653b613e7e80711984d37c445fb
--- /dev/null
+++ b/src/mapleall/mempool/BUILD.gn
@@ -0,0 +1,32 @@
+src_libmempool = [
+  "src/maple_string.cpp",
+  "src/mempool.cpp",
+]
+include_directories = [
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+]
+
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+
+static_library("libmempool") {
+  sources = src_libmempool
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
+
+executable("MemPool") {
+  sources = [ "src/MPTest.cpp" ]
+
+  include_dirs = include_directories
+
+  deps = [
+    ":libmempool",
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/maple_util:libcommandline",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
+  ]
+}
diff --git a/src/mapleall/mempool/CMakeLists.txt b/src/mapleall/mempool/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2126c1041590cf1da56e8bf2bc31fb7d4139cb83
--- /dev/null
+++ b/src/mapleall/mempool/CMakeLists.txt
@@ -0,0 +1,54 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+
+set(src_libmempool
+  src/maple_string.cpp
+  src/mempool.cpp
+)
+
+add_library(libmempool STATIC ${src_libmempool})
+target_include_directories(libmempool PRIVATE
+    ${MAPLEALL_ROOT}/maple_ir/include
+    ${MAPLEALL_ROOT}/maple_util/include
+    ${MAPLEALL_ROOT}/maple_driver/include
+    ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+    include 
+)
+
+set_target_properties(libmempool PROPERTIES 
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
+
+add_executable(MemPool src/MPTest.cpp)
+target_include_directories(MemPool PRIVATE
+    ${MAPLEALL_ROOT}/maple_ir/include
+    ${MAPLEALL_ROOT}/maple_util/include
+    ${MAPLEALL_ROOT}/maple_driver/include
+    ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+    include
+)
+
+set(deps_MemPool
+    libmempool
+    libmplutil
+    libcommandline
+    libHWSecureC
+)
+add_dependencies(MemPool ${deps_MemPool})
+target_link_libraries(MemPool ${deps_MemPool})
+set_target_properties(MemPool PROPERTIES
+     RUNTIME_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/bin
+)
diff --git a/src/mapleall/mempool/include/maple_sparse_bitvector.h b/src/mapleall/mempool/include/maple_sparse_bitvector.h
new file mode 100644
index 0000000000000000000000000000000000000000..223d4b1a09fa6ce0b75bf2213ef1f30adb5b8547
--- /dev/null
+++ b/src/mapleall/mempool/include/maple_sparse_bitvector.h
@@ -0,0 +1,445 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MEMPOOL_INCLUDE_MAPLE_SPARSE_BITVECTOR_H
+#define MEMPOOL_INCLUDE_MAPLE_SPARSE_BITVECTOR_H
+#include <climits>
+#include <cstring>
+#include <iterator>
+#include <list>
+#include <iostream>
+#include <bitset>
+#include <set>
+
+namespace maple {
+template <unsigned bitVectorSize = 64> struct MapleSparseBitVectorElement {
+  using BitWord =  unsigned long long;
+  enum {
+    kBitWordSize  = sizeof(BitWord) * CHAR_BIT,
+    kBitWordNum = (bitVectorSize + kBitWordSize - 1) / kBitWordSize
+  };
+
+  explicit MapleSparseBitVectorElement(unsigned idx) : index(idx), bitVector{0} {}
+
+  BitWord GetWord(unsigned idx) const {
+    return bitVector[idx];
+  }
+
+  unsigned GetIndex() const {
+    return index;
+  }
+
+  void Set(unsigned idx) {
+    bitVector[idx / kBitWordSize] |= 1ULL <<(idx % kBitWordSize);
+  }
+
+  void Reset(unsigned idx) {
+    bitVector[idx / kBitWordSize] &= ~(1ULL << (idx % kBitWordSize));
+  }
+
+  bool Test(unsigned idx) const {
+    return bitVector[idx / kBitWordSize] & (1ULL << (idx % kBitWordSize));
+  }
+
+  bool Empty() const {
+    for (unsigned i = 0; i < kBitWordNum; i++) {
+      if (bitVector[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  void ConvertToSet(MapleSet<uint32>& res, unsigned base) const {
+    for (unsigned i = 0; i < kBitWordNum; i++) {
+      BitWord tmp = bitVector[i];
+      unsigned bitPos = 0;
+      while (tmp) {
+        unsigned trailingZeroNum = __builtin_ctzll(tmp);
+        bitPos += trailingZeroNum;
+        tmp >>= trailingZeroNum;
+        tmp -= 1;
+        res.insert(base + bitPos + i * kBitWordSize);
+      }
+    }
+  }
+
+  void ConvertToSet(std::set<uint32> &res, unsigned base) const {
+    for (unsigned i = 0; i < kBitWordNum; i++) {
+      BitWord tmp = bitVector[i];
+      unsigned bitPos = 0;
+      while (tmp) {
+        unsigned trailingZeroNum = __builtin_ctzll(tmp);
+        bitPos += trailingZeroNum;
+        tmp >>= trailingZeroNum;
+        tmp -= 1;
+        res.insert(base + bitPos + i * kBitWordSize);
+      }
+    }
+  }
+
+  bool And(const MapleSparseBitVectorElement &rhs, bool &becameZero) {
+    bool changed = false;
+    bool allzero = true;
+    becameZero = false;
+    for (unsigned i = 0; i < kBitWordNum; i++) {
+      BitWord oldBitWord = bitVector[i];
+      bitVector[i] &= rhs.bitVector[i];
+      changed |= (oldBitWord != bitVector[i]);
+      if (bitVector[i] != 0) {
+        allzero = false;
+      }
+    }
+    becameZero = allzero;
+    return changed;
+  }
+
+  bool Or(const MapleSparseBitVectorElement &rhs) {
+    bool changed = false;
+    for (unsigned i = 0; i < kBitWordNum; i++) {
+      BitWord oldBitWord = bitVector[i];
+      bitVector[i] |= rhs.bitVector[i];
+      changed |= (oldBitWord != bitVector[i]);
+    }
+    return changed;
+  }
+
+  bool Diff(const MapleSparseBitVectorElement &rhs, bool &becameZero) {
+    bool changed = false;
+    bool allzero = true;
+    becameZero = false;
+    for (unsigned i = 0; i < kBitWordNum; i++) {
+      BitWord oldBitWord = bitVector[i];
+      bitVector[i] &= ~rhs.bitVector[i];
+      changed |= (oldBitWord != bitVector[i]);
+      if (bitVector[i] != 0) {
+        allzero = false;
+      }
+    }
+    becameZero = allzero;
+    return changed;
+  }
+
+  bool operator==(const MapleSparseBitVectorElement &rhs) const {
+    if (index != rhs.GetIndex()) {
+      return false;
+    }
+    for (unsigned i = 0; i < kBitWordNum; i++) {
+      if (bitVector[i] != rhs.bitVector[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool operator!=(const MapleSparseBitVectorElement &rhs) const {
+    return !(*this == rhs);
+  }
+
+ private:
+  unsigned index;
+  BitWord bitVector[kBitWordNum];
+};
+
+template <unsigned bitVectorSize = 64>
+class MapleSparseBitVector {
+  using ElementList = MapleList<MapleSparseBitVectorElement<bitVectorSize>>;
+  using ElementListIterator = typename ElementList::iterator;
+  using ElementListConstIterator = typename ElementList::const_iterator;
+  using BitWord =  unsigned long long;
+
+ public:
+  explicit MapleSparseBitVector(MapleAllocator &alloc)
+      : allocator(alloc),
+        elementList(allocator.Adapter()),
+        currIter(elementList.begin()) {}
+
+  explicit MapleSparseBitVector(const MapleSparseBitVector &rhs, MapleAllocator &alloc)
+      : allocator(alloc),
+        elementList(rhs.elementList, allocator.Adapter()),
+        currIter(elementList.begin()) {}
+
+  MapleSparseBitVector(const MapleSparseBitVector &rhs)
+      : allocator(rhs.allocator),
+        elementList(rhs.elementList, allocator.Adapter()),
+        currIter(elementList.begin()) {}
+
+  void Set(unsigned bitNO) {
+    unsigned idx = bitNO / bitVectorSize;
+    ElementListIterator iter;
+    if (elementList.empty()) {
+      iter = elementList.emplace(elementList.end(), idx);
+    } else {
+      iter = LowerBoundFor(idx);
+      if (iter == elementList.end() || iter->GetIndex() != idx) {
+        if (iter != elementList.end() && iter->GetIndex() < idx) {
+          ++iter;
+        }
+        iter = elementList.emplace(iter, idx);
+      }
+    }
+    currIter = iter;
+    iter->Set(bitNO % bitVectorSize);
+  }
+
+  void Reset(unsigned bitNO) {
+    if (elementList.empty()) {
+      return;
+    }
+    unsigned idx = bitNO / bitVectorSize;
+    ElementListIterator iter = LowerBoundFor(idx);
+    if (iter == elementList.end() || iter->GetIndex() != idx) {
+      return;
+    }
+    iter->Reset(bitNO % bitVectorSize);
+    if (iter->Empty()) {
+      ++currIter;
+      elementList.erase(iter);
+    }
+  }
+
+  bool Test(unsigned bitNO) const {
+    if (elementList.empty()) {
+      return false;
+    }
+    unsigned idx = bitNO / bitVectorSize;
+    ElementListConstIterator iter = LowerBoundForConst(idx);
+    if (iter == elementList.end() || iter->GetIndex() != idx) {
+      return false;
+    }
+    return (iter->Test(bitNO % bitVectorSize));
+  }
+
+  MapleSparseBitVector& operator=(const MapleSparseBitVector& rhs) {
+    if (this == &rhs) {
+      return *this;
+    }
+    allocator = rhs.allocator;
+    elementList = rhs.elementList;
+    currIter = elementList.begin();
+    return *this;
+  }
+
+  bool operator&=(const MapleSparseBitVector& rhs) {
+    if (this == &rhs) {
+      return false;
+    }
+
+    bool changed = false;
+    ElementListIterator iter1 = elementList.begin();
+    ElementListConstIterator iter2 = rhs.elementList.begin();
+
+    if (elementList.empty() || rhs.elementList.empty()) {
+      return false;
+    }
+
+    while (iter2 != rhs.elementList.end()) {
+      if (iter1 == elementList.end()) {
+        currIter = elementList.begin();
+        return changed;
+      }
+
+      if (iter1->GetIndex() > iter2->GetIndex()) {
+        ++iter2;
+      } else if (iter1->GetIndex() == iter2->GetIndex()) {
+        bool becameZero;
+        changed |= iter1->And(*iter2, becameZero);
+        if (becameZero) {
+          ElementListIterator iterTmp = iter1;
+          ++iter1;
+          elementList.erase(iterTmp);
+        } else {
+          ++iter1;
+        }
+        ++iter2;
+      } else {
+        ElementListIterator iterTmp = iter1;
+        ++iter1;
+        elementList.erase(iterTmp);
+        changed = true;
+      }
+    }
+    if (iter1 != elementList.end()) {
+      elementList.erase(iter1, elementList.end());
+      changed = true;
+    }
+    currIter = elementList.begin();
+    return changed;
+  }
+
+  bool operator|=(const MapleSparseBitVector& rhs) {
+    if (this == &rhs) {
+      return false;
+    }
+
+    bool changed = false;
+    ElementListIterator iter1 = elementList.begin();
+    ElementListConstIterator iter2 = rhs.elementList.begin();
+
+    if (rhs.elementList.empty()) {
+      return false;
+    }
+
+    while (iter2 != rhs.elementList.end()) {
+      if (iter1 == elementList.end() || iter1->GetIndex() > iter2->GetIndex()) {
+        elementList.insert(iter1, *iter2);
+        ++iter2;
+        changed = true;
+      } else if (iter1->GetIndex() == iter2->GetIndex()) {
+        changed |= iter1->Or(*iter2);
+        ++iter1;
+        ++iter2;
+      } else {
+        ++iter1;
+      }
+    }
+    currIter = elementList.begin();
+    return changed;
+  }
+
+  void Clear() {
+    elementList.clear();
+    currIter = elementList.begin();
+  }
+
+  bool operator==(const MapleSparseBitVector &rhs) const {
+    ElementListConstIterator iter1 = elementList.begin();
+    ElementListConstIterator iter2 = rhs.elementList.begin();
+    for (; iter1 != elementList.end() && iter2 != rhs.elementList.end(); ++iter1, ++iter2) {
+      if (*iter1 != *iter2) {
+        return false;
+      }
+    }
+    return iter1 == elementList.end() && iter2 == rhs.elementList.end();
+  }
+
+  bool operator!=(const MapleSparseBitVector &rhs) {
+    return !(*this == rhs);
+  }
+
+  bool Empty() const {
+    if (elementList.empty()) {
+      return true;
+    }
+    ElementListConstIterator iter1 = elementList.begin();
+    for (; iter1 != elementList.end(); ++iter1) {
+      if (!iter1->Empty()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool Diff(const MapleSparseBitVector &rhs) {
+    if (this == &rhs) {
+      if (!Empty()) {
+        Clear();
+        return true;
+      }
+      return false;
+    }
+
+    bool changed = false;
+    ElementListIterator iter1 = elementList.begin();
+    ElementListConstIterator iter2 = rhs.elementList.begin();
+
+    if (elementList.empty() || rhs.elementList.empty()) {
+      return false;
+    }
+
+    while (iter2 != rhs.elementList.end()) {
+      if (iter1 == elementList.end()) {
+        currIter = elementList.begin();
+        return changed;
+      }
+
+      if (iter1->GetIndex() > iter2->GetIndex()) {
+        ++iter2;
+      } else if (iter1->GetIndex() == iter2->GetIndex()) {
+        bool becameZero;
+        changed |= iter1->Diff(*iter2, becameZero);
+        if (becameZero) {
+          ElementListIterator iterTmp = iter1;
+          ++iter1;
+          elementList.erase(iterTmp);
+        } else {
+          ++iter1;
+        }
+        ++iter2;
+      } else {
+        ++iter1;
+      }
+    }
+    currIter = elementList.begin();
+    return changed;
+  }
+
+  void ConvertToSet(MapleSet<uint32> &res) const {
+    for (auto &element : elementList) {
+      unsigned pos = bitVectorSize * element.GetIndex();
+      element.ConvertToSet(res, pos);
+    }
+  }
+
+  void ConvertToSet(std::set<uint32> &res) const {
+    for (auto &element : elementList) {
+      unsigned pos = bitVectorSize * element.GetIndex();
+      element.ConvertToSet(res, pos);
+    }
+  }
+
+ private:
+  ElementListIterator LowerBoundForImpl(unsigned idx) const {
+    ElementListIterator begin = const_cast<MapleSparseBitVector*>(this)->elementList.begin();
+    ElementListIterator end = const_cast<MapleSparseBitVector*>(this)->elementList.end();
+
+    if (elementList.empty()) {
+      currIter = begin;
+      return currIter;
+    }
+
+    if (currIter == end) {
+      --currIter;
+    }
+
+    ElementListIterator iter = currIter;
+    if (iter->GetIndex() == idx) {
+      return iter;
+    } else if (iter->GetIndex() > idx) {
+      while (iter != begin && iter->GetIndex() > idx) {
+        --iter;
+      }
+    } else {
+      while (iter != end && iter->GetIndex() < idx) {
+        ++iter;
+      }
+    }
+    currIter = iter;
+    return iter;
+  }
+
+  ElementListConstIterator LowerBoundForConst(unsigned idx) const {
+    return LowerBoundForImpl(idx);
+  }
+
+  ElementListIterator LowerBoundFor(unsigned idx) {
+    return LowerBoundForImpl(idx);
+  }
+
+  MapleAllocator allocator;
+  ElementList elementList;
+  mutable ElementListIterator currIter;
+};
+}  // namespace maple
+#endif  /* MAPLEBE_INCLUDE_CG_SPARSE_BITVECTOR_H */
\ No newline at end of file
diff --git a/src/mapleall/mempool/include/maple_string.h b/src/mapleall/mempool/include/maple_string.h
new file mode 100644
index 0000000000000000000000000000000000000000..4530aecdfc2b8874e2f7e92fe6f3b954ecda9a0b
--- /dev/null
+++ b/src/mapleall/mempool/include/maple_string.h
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MEMPOOL_INCLUDE_MAPLE_STRING_H
+#define MEMPOOL_INCLUDE_MAPLE_STRING_H
+#include <cstring>
+#include <climits>
+#include "mempool.h"
+#include "securec.h"
+#include "mpl_logging.h"
+
+namespace maple {
+class MapleString {
+ public:
+  MapleString() = default;
+  explicit MapleString(MemPool *currMp) : memPool(currMp) {}
+  MapleString(const MapleString &str);
+  MapleString(const char *str, MemPool *currMp);
+  MapleString(const char *str, size_t size, MemPool *currMp);  // copyin
+  MapleString(size_t size, MemPool *currMp);
+  MapleString(const MapleString &str, MemPool *currMp);
+  MapleString(const std::string &str, MemPool *currMp);
+  ~MapleString() = default;
+
+  size_t length() const {
+    return dataLength;
+  }
+
+  char *c_str() {
+    return data;
+  }
+
+  const char *c_str() const {
+    if (dataLength <= 0) {
+      return nullptr;
+    }
+    return data;
+  }
+
+  char &operator[](const size_t x) {
+    return data[x];
+  }
+
+  const char &operator[](const size_t x) const {
+    return data[x];
+  }
+
+  MapleString &operator=(const char c) {
+    data = static_cast<char*>(memPool->Malloc(2 * sizeof(char)));
+    CHECK_FATAL(data != nullptr, "nullptr check");
+    data[0] = c;
+    data[1] = '\0';
+    dataLength = 1;
+    return *this;
+  }
+
+  MapleString &operator=(const char *str) {
+    if (str == nullptr) {
+      return *this;
+    }
+    size_t size = strlen(str);
+    CHECK_FATAL(size <= UINT_MAX - 1, "str too large");
+
+    // if data is null, old_size = 0, else +1
+    size_t oldSize = ((data == nullptr) ? 0 : (dataLength + 1));
+    if (oldSize < (1 + size)) {
+      data = static_cast<char*>(memPool->Realloc(data, oldSize * sizeof(char), (1 + size) * sizeof(char)));
+    }
+    CHECK_FATAL(data != nullptr, "null ptr check ");
+    if (size == 0) {
+      data[0] = '\0';
+      return *this;
+    }
+    errno_t eNum = memcpy_s(data, size + 1, str, size);
+    CHECK_FATAL(eNum == EOK, "memcpy_s failed");
+    dataLength = size;
+    CHECK_FATAL(data != nullptr, "null ptr check ");
+    data[dataLength] = '\0';
+    return *this;
+  }
+
+  MapleString &operator=(const std::string &str) {
+    size_t size = str.length();
+    CHECK_FATAL(size <= UINT_MAX - 1, "str too large");
+
+    size_t oldSize = (data == nullptr) ? 0 : (dataLength + 1);
+    if (oldSize < (1 + size)) {
+      data = static_cast<char*>(memPool->Realloc(data, oldSize * sizeof(char), (1 + size) * sizeof(char)));
+    }
+    CHECK_FATAL(data != nullptr, "null ptr check ");
+    if (size == 0) {
+      data[0] = '\0';
+      return *this;
+    }
+    errno_t eNum = memcpy_s(data, size, str.data(), size);
+    CHECK_FATAL(eNum == EOK, "memcpy_s failed");
+    dataLength = size;
+    data[dataLength] = '\0';
+    return *this;
+  }
+
+  MapleString &operator=(const MapleString &str) {
+    if (&str == this) {
+      return *this;
+    }
+    size_t size = str.dataLength;
+    CHECK_FATAL(size <= UINT_MAX - 1, "str too large");
+
+    size_t oldSize = (data == nullptr) ? 0 : (dataLength + 1);
+    data = static_cast<char*>(memPool->Realloc(data, oldSize * sizeof(char), (1 + size) * sizeof(char)));
+    CHECK_FATAL(data != nullptr, "null ptr check");
+    if (size == 0) {
+      data[0] = '\0';
+      return *this;
+    }
+    errno_t eNum = memcpy_s(data, size, str.data, size);
+    CHECK_FATAL(eNum == EOK, "memcpy_s failed");
+    dataLength = size;
+    data[dataLength] = '\0';
+    return *this;
+  }
+
+  MapleString &operator+=(const char c) {
+    size_t oldSize = ((data == nullptr) ? 0 : (dataLength + 1));
+    CHECK_FATAL(oldSize <= UINT_MAX - 1, "str too large");
+
+    data = static_cast<char*>(memPool->Realloc(data, oldSize * sizeof(char), (dataLength + 1 + 1) * sizeof(char)));
+    ++dataLength;
+    data[dataLength - 1] = c;
+    data[dataLength] = '\0';
+    return *this;
+  }
+
+  MapleString &operator+=(const char *str) {
+    if (str == nullptr) {
+      return *this;
+    }
+    size_t size = strlen(str);
+    size_t oldSize = ((data == nullptr) ? 0 : (dataLength + 1));
+    CHECK_FATAL(size <= UINT_MAX - oldSize, "str too large");
+
+    data = static_cast<char*>(memPool->Realloc(data, oldSize * sizeof(char), (dataLength + size + 1) * sizeof(char)));
+    CHECK_FATAL(data != nullptr, "null ptr check");
+    errno_t eNum = memcpy_s(data + dataLength, size, str, size);
+    CHECK_FATAL(eNum == EOK, "memcpy_s failed");
+    dataLength += size;
+    data[dataLength] = '\0';
+    return *this;
+  }
+
+  MapleString &operator+=(const MapleString &str) {
+    size_t oldSize = ((data == nullptr) ? 0 : (dataLength + 1));
+    CHECK_FATAL(str.dataLength <= UINT_MAX - oldSize, "str too large");
+
+    data = static_cast<char*>(
+        memPool->Realloc(data, oldSize * sizeof(char), (dataLength + str.dataLength + 1) * sizeof(char)));
+    errno_t eNum = memcpy_s(data + dataLength, str.dataLength, str.data, str.dataLength);
+    CHECK_FATAL(eNum == EOK, "memcpy_s failed");
+    dataLength += str.dataLength;
+    data[dataLength] = '\0';
+    return *this;
+  }
+
+  MapleString &operator+=(const std::string &str) {
+    size_t size = str.length();
+    size_t oldSize = ((data == nullptr) ? 0 : (dataLength + 1));
+    CHECK_FATAL(size <= UINT_MAX - oldSize, "str too large");
+
+    data = static_cast<char*>(memPool->Realloc(data, oldSize * sizeof(char), (dataLength + size + 1) * sizeof(char)));
+    CHECK_FATAL(data != nullptr, " null ptr check");
+    errno_t eNum = memcpy_s(data + dataLength, size, str.data(), size);
+    CHECK_FATAL(eNum == EOK, "memcpy_s failed");
+    dataLength += size;
+    data[dataLength] = '\0';
+    return *this;
+  }
+
+  void clear();
+  bool empty() const {
+    if (dataLength <= 0 || data == nullptr) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  MapleString &push_back(const char c);
+  MapleString &append(const MapleString &str);
+  MapleString &append(const MapleString &str, size_t subPos, size_t subLen);
+  MapleString &append(const char *s);
+  MapleString &append(const char *s, size_t n);
+  MapleString &append(size_t n, char c);
+  MapleString &append(const std::string &str);
+  size_t find(const MapleString &str, size_t pos = 0) const;
+  size_t find(const char *str, size_t pos = 0) const;
+  size_t find(const char *str, size_t pos, size_t n) const;
+  size_t find(char c, size_t pos = 0) const;
+  size_t find_last_of(const char *str, size_t pos = 0) const;
+  MapleString substr(size_t pos, size_t len) const;
+  MapleString &insert(size_t pos, const MapleString &str);
+  MapleString &insert(size_t pos, const MapleString &str, size_t subPos, size_t subLen);
+  MapleString &insert(size_t pos, const char *s);
+  MapleString &insert(size_t pos, const char *s, size_t n);
+  MapleString &insert(size_t pos, size_t n, char c);
+  MapleString &assign(const MapleString &str);
+  MapleString &assign(const MapleString &str, size_t subPos, size_t subLen);
+  MapleString &assign(const char *s);
+  MapleString &assign(const char *s, size_t n);
+  MapleString &assign(size_t n, char c);
+
+ private:
+  inline static size_t StrLen(const char *s) {
+    if (s == nullptr) {
+      return 0;
+    }
+    return ::strlen(s);
+  }
+
+  inline static char *NewData(MemPool *memPool, const char *source, size_t len);
+
+  inline size_t UnsafeFind(const char *str, size_t pos, size_t n) const {
+    if ((dataLength - pos) < n) {
+      return std::string::npos;
+    }
+    char *matchStart = data + pos;
+    char *end = data + dataLength;
+    for (; matchStart < end; ++matchStart) {
+      matchStart = strchr(matchStart, str[0]);
+      if (matchStart == nullptr) {
+        return std::string::npos;
+      }
+      size_t i = matchStart - data;
+      if ((dataLength - i) < n) {
+        return std::string::npos;
+      }
+      int ret = memcmp(matchStart, str, n);
+      if (ret == 0) {
+        return i;
+      }
+    }
+    return std::string::npos;
+  }
+
+  friend bool operator==(const MapleString &str1, const MapleString &str2);
+  friend bool operator==(const MapleString &str1, const char *str2);
+  friend bool operator==(const char *str1, const MapleString &str2);
+  friend bool operator<(const MapleString &str1, const MapleString &str2);
+
+  char *data = nullptr;
+  MemPool *memPool = nullptr;
+  size_t dataLength = 0;
+};
+
+template <typename OS>
+inline OS &operator<<(OS &os, const MapleString &data) {
+  os << data.c_str();
+  return os;
+}
+
+// global operators
+bool operator==(const MapleString &str1, const MapleString &str2);
+bool operator==(const MapleString &str1, const char *str2);
+bool operator==(const char *str1, const MapleString &str2);
+bool operator!=(const MapleString &str1, const MapleString &str2);
+bool operator!=(const MapleString &str1, const char *str2);
+bool operator!=(const char *str1, const MapleString &str2);
+bool operator<(const MapleString &str1, const MapleString &str2);
+}  // namespace maple
+#endif  // MEMPOOL_INCLUDE_MAPLE_STRING_H
diff --git a/src/mapleall/mempool/include/mempool.h b/src/mapleall/mempool/include/mempool.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8b8e8d63bf751af0f096a5930782f2a4433d81f
--- /dev/null
+++ b/src/mapleall/mempool/include/mempool.h
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MEMPOOL_INCLUDE_MEMPOOL_H
+#define MEMPOOL_INCLUDE_MEMPOOL_H
+#include <list>
+#include <set>
+#include <forward_list>
+#include <unordered_set>
+#include <stack>
+#include <map>
+#include <string>
+#include <mutex>
+#include "mir_config.h"
+#include "mpl_logging.h"
+#include "thread_env.h"
+
+namespace maple {
+struct MemBlock {
+  MemBlock(uint8_t *startPtr, size_t size) : startPtr(startPtr), memSize(size) {}
+  ~MemBlock() = default;
+
+  uint8_t *EndPtr() const {
+    return startPtr + memSize;
+  }
+
+  uint8_t *startPtr = nullptr;
+  size_t memSize = 0;
+  MemBlock *nextMemBlock = nullptr;
+};
+
+constexpr size_t kMemBlockStructSize = sizeof(MemBlock);
+constexpr size_t kMemBlockSizeMin = 2 * 1024;
+constexpr size_t kMemBlockMallocSize = kMemBlockSizeMin + kMemBlockStructSize;
+constexpr size_t kMemBlockRealMallocSize = kMemBlockMallocSize * 512;
+
+// Class declaration
+class MemPool;
+class MemPoolCtrler;
+extern MemPoolCtrler memPoolCtrler;
+
+// memory backend
+class SysMemoryManager {
+ public:
+  virtual ~SysMemoryManager() = default;
+  virtual uint8_t *RealAllocMemory(size_t size) = 0;
+};
+
+class MallocSysMemoryManager : public SysMemoryManager {
+ public:
+  uint8_t *RealAllocMemory(size_t size) override {
+    if (size == 0) {
+      return nullptr;
+    }
+    void *block = malloc(size);
+    CHECK_FATAL(block != nullptr, "malloc failed");
+
+    mallocMemories.push_front(block);
+    return reinterpret_cast<uint8_t *>(block);
+  }
+  ~MallocSysMemoryManager() override {
+    for (void *ptr : mallocMemories) {
+      free(ptr);
+    }
+  }
+  std::forward_list<void *> mallocMemories;
+};
+
+// memory middle end
+class MemPoolCtrler {
+  friend MemPool;
+
+ public:
+  static bool freeMemInTime;
+  MemPoolCtrler() : sysMemoryMgr(new MallocSysMemoryManager()) {}
+
+  ~MemPoolCtrler();
+
+  MemPool *NewMemPool(const std::string &name, bool isLocalPool);
+  void DeleteMemPool(MemPool *memPool) const;
+  bool HaveRace() const {
+    return ThreadEnv::IsMeParallel() && (this == &maple::memPoolCtrler);
+  }
+
+  MemBlock *AllocMemBlock(const MemPool &pool, size_t size);
+  MemBlock *AllocFixMemBlock(const MemPool &pool);
+  MemBlock *AllocBigMemBlock(const MemPool &pool, size_t size) const;
+
+ private:
+  struct MemBlockCmp {
+    bool operator()(const MemBlock *l, const MemBlock *r) const {
+      return l->memSize > r->memSize;
+    }
+  };
+
+  void FreeMem();
+  void FreeMemBlocks(const MemPool &pool, MemBlock *fixedMemHead, MemBlock *bigMemHead);
+
+  std::mutex ctrlerMutex;  // this mutex is used to protect memPools
+  MemBlock *fixedFreeMemBlocks = nullptr;
+  std::unique_ptr<SysMemoryManager> sysMemoryMgr;
+};
+
+#ifdef MP_DEUG
+class MemPoolStat {
+ public:
+  ~MemPoolStat() = default;
+
+ protected:
+  void SetName(const std::string &name) {
+    this->name = name;
+  }
+  void SetName(const char *name) {
+    this->name = name;
+  }
+  std::string name;
+};
+#else
+class MemPoolStat {
+ public:
+  virtual ~MemPoolStat() = default;
+
+ protected:
+  void SetName(const std::string & /* name */) const {}
+  void SetName(const char /* name */) const {}
+};
+#endif
+
+// memory front end
+class MemPool : private MemPoolStat {
+  friend MemPoolCtrler;
+
+ public:
+  MemPool(MemPoolCtrler &ctl, const std::string &name) : ctrler(ctl) {
+    SetName(name);
+  }
+  MemPool(MemPoolCtrler &ctl, const char *name) : ctrler(ctl) {
+    SetName(name);
+  }
+
+  ~MemPool() override;
+
+  virtual void *Malloc(size_t size);
+  void *Calloc(size_t size);
+  void *Realloc(const void *ptr, size_t oldSize, size_t newSize);
+  virtual void ReleaseContainingMem();
+
+  MemPoolCtrler &GetCtrler() {
+    return ctrler;
+  }
+
+  const MemPoolCtrler &GetCtrler() const {
+    return ctrler;
+  }
+
+  template <class T>
+  T *Clone(const T &t) {
+    void *p = Malloc(sizeof(T));
+    ASSERT(p != nullptr, "ERROR: New error");
+    p = new (p) T(t);
+    return static_cast<T *>(p);
+  }
+
+  template <class T, typename... Arguments>
+  T *New(Arguments &&... args) {
+    void *p = Malloc(sizeof(T));
+    ASSERT(p != nullptr, "ERROR: New error");
+    p = new (p) T(std::forward<Arguments>(args)...);
+    return static_cast<T *>(p);
+  }
+
+  template <class T>
+  T *NewArray(size_t num) {
+    void *p = Malloc(sizeof(T) * num);
+    ASSERT(p != nullptr, "ERROR: NewArray error");
+    p = new (p) T[num];
+    return static_cast<T *>(p);
+  }
+
+ protected:
+  MemPoolCtrler &ctrler;  // Hookup controller object
+  uint8_t *endPtr = nullptr;
+  uint8_t *curPtr = nullptr;
+  MemBlock *fixedMemHead = nullptr;
+  MemBlock *bigMemHead = nullptr;
+
+  uint8_t *AllocNewMemBlock(size_t byteSize);
+};
+
+using ThreadLocalMemPool = MemPool;
+
+class ThreadShareMemPool : public MemPool {
+ public:
+  using MemPool::MemPool;
+  virtual ~ThreadShareMemPool() = default;
+  void *Malloc(size_t size) override {
+    ParallelGuard guard(poolMutex, ctrler.HaveRace());
+    return MemPool::Malloc(size);
+  }
+  void ReleaseContainingMem() override {
+    ParallelGuard guard(poolMutex, ctrler.HaveRace());
+    MemPool::ReleaseContainingMem();
+  }
+
+ private:
+  std::mutex poolMutex;  // this mutex is used to protect memPools
+};
+
+class LocalMapleAllocator;
+#ifdef MP_DEBUG
+class StackMemPoolDebug {
+ protected:
+  void PushAllocator(const LocalMapleAllocator *alloc) {
+    allocators.push(alloc);
+  }
+  void CheckTopAllocator(const LocalMapleAllocator *alloc) const {
+    CHECK_FATAL(alloc == allocators.top(), "only top allocator allowed");
+  }
+  void PopAllocator() {
+    allocators.pop();
+  }
+  std::stack<const LocalMapleAllocator *> allocators;
+};
+#else
+class StackMemPoolDebug {
+ protected:
+  void PushAllocator(const LocalMapleAllocator * /* alloc */) const {}
+  void PopAllocator() const {}
+  void CheckTopAllocator(const LocalMapleAllocator * /* alloc */) const {}
+};
+#endif
+
+class StackMemPool : public MemPool, private StackMemPoolDebug {
+ public:
+  using MemPool::MemPool;
+  friend LocalMapleAllocator;
+
+ private:
+  // all malloc requested from LocalMapleAllocator
+  void *Malloc(size_t size) override;
+  uint8_t *AllocTailMemBlock(size_t size);
+
+  // these methods should be called from LocalMapleAllocator
+  template <class T>
+  T *Clone(const T &t) = delete;
+
+  template <class T, typename... Arguments>
+  T *New(Arguments &&... args) = delete;
+
+  template <class T>
+  T *NewArray(size_t num) = delete;
+
+  // reuse mempool fixedMemHead, bigMemHead, (curPtr, endPtr for fixed memory)
+  MemBlock *fixedMemStackTop = nullptr;
+  MemBlock *bigMemStackTop = nullptr;
+  uint8_t *bigCurPtr = nullptr;
+  uint8_t *bigEndPtr = nullptr;
+  MemBlock *AllocMemBlockBySize(size_t size);
+  void ResetStackTop(const LocalMapleAllocator *alloc, uint8_t *fixedCurPtrMark, MemBlock *fixedStackTopMark,
+                     uint8_t *bigCurPtrMark, MemBlock *bigStackTopMark) noexcept;
+};
+}  // namespace maple
+#endif  // MEMPOOL_INCLUDE_MEMPOOL_H
diff --git a/src/mapleall/mempool/include/mempool_allocator.h b/src/mapleall/mempool/include/mempool_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..19a958fe219fae446854053817ce2ec28d7d37cd
--- /dev/null
+++ b/src/mapleall/mempool/include/mempool_allocator.h
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MEMPOOL_INCLUDE_MEMPOOL_ALLOCATOR_H
+#define MEMPOOL_INCLUDE_MEMPOOL_ALLOCATOR_H
+#include <cstddef>
+#include <limits>
+#include <vector>
+#include <deque>
+#include <queue>
+#include <set>
+#include <unordered_set>
+#include <map>
+#include <unordered_map>
+#include <forward_list>
+#include "mempool.h"
+
+namespace maple {
+template <typename T>
+class MapleAllocatorAdapter;  // circular dependency exists, no other choice
+class MapleAllocator {
+ public:
+  explicit MapleAllocator(MemPool *m) : memPool(m) {}
+  virtual ~MapleAllocator() = default;
+
+  // Get adapter for use in STL containers. See arena_containers.h .
+  MapleAllocatorAdapter<void> Adapter();
+  virtual void *Alloc(size_t bytes) {
+    return (memPool != nullptr) ? memPool->Malloc(bytes) : nullptr;
+  }
+
+  template <class T, typename... Arguments>
+  T *New(Arguments &&... args) const {
+    void *p = memPool->Malloc(sizeof(T));
+    ASSERT(p != nullptr, "ERROR: New error");
+    p = new (p) T(std::forward<Arguments>(args)...);
+    return static_cast<T *>(p);
+  }
+
+  MemPool *GetMemPool() const {
+    return memPool;
+  }
+
+  void SetMemPool(MemPool *m) {
+    memPool = m;
+  }
+
+ protected:
+  MemPool *memPool;
+  template <typename U>
+  friend class MapleAllocatorAdapter;
+};  // MapleAllocator
+
+// must be destroyed, otherwise there will be memory leak
+// only one allocater can be used at the same time
+class LocalMapleAllocator : public MapleAllocator {
+ public:
+  explicit LocalMapleAllocator(StackMemPool &m)
+      : MapleAllocator(&m),
+        fixedStackTopMark(m.fixedMemStackTop),
+        bigStackTopMark(m.bigMemStackTop),
+        fixedCurPtrMark(m.curPtr),
+        bigCurPtrMark(m.bigCurPtr) {
+    m.PushAllocator(this);
+  }
+  ~LocalMapleAllocator() override {
+    static_cast<StackMemPool *>(memPool)->ResetStackTop(this, fixedCurPtrMark, fixedStackTopMark, bigCurPtrMark,
+                                                        bigStackTopMark);
+  };
+
+  StackMemPool &GetStackMemPool() const {
+    return static_cast<StackMemPool &>(*memPool);
+  }
+
+  MemPool *GetMemPool() const = delete;
+
+  void *Alloc(size_t bytes) override {
+    static_cast<StackMemPool *>(memPool)->CheckTopAllocator(this);
+    return memPool->Malloc(bytes);
+  }
+
+ private:
+  using MapleAllocator::MapleAllocator;
+  MemBlock *const fixedStackTopMark;
+  MemBlock *const bigStackTopMark;
+  uint8_t *const fixedCurPtrMark;
+  uint8_t *const bigCurPtrMark;
+};
+
+template <typename T>
+class MapleAllocatorAdapter;  // circular dependency exists, no other choice
+
+template <typename T>
+using MapleQueue = std::deque<T, MapleAllocatorAdapter<T>>;
+
+template <typename T>
+using MapleVector = std::vector<T, MapleAllocatorAdapter<T>>;
+
+using MapleBitVector = std::vector<bool, MapleAllocatorAdapter<bool>>;
+
+template <typename T>
+class MapleStack {
+ public:
+  using size_type = typename MapleVector<T>::size_type;
+  using iterator = typename MapleVector<T>::iterator;
+
+  explicit MapleStack(MapleAllocatorAdapter<T> adapter) : vect(adapter) {}
+
+  ~MapleStack() = default;
+
+  MapleVector<T> &GetVector() {
+    return vect;
+  }
+
+  bool empty() const {
+    return vect.empty();
+  }
+
+  size_type size() const {
+    return vect.size();
+  }
+
+  iterator begin() {
+    return vect.begin();
+  }
+
+  iterator end() {
+    return vect.end();
+  }
+
+  void push(T x) {
+    vect.push_back(x);
+  }
+
+  void pop() {
+    vect.pop_back();
+  }
+
+  T top() {
+    return vect.back();
+  }
+
+  void clear() {
+    vect.resize(0);
+  }
+
+ private:
+  MapleVector<T> vect;
+};
+
+template <typename T>
+using MapleList = std::list<T, MapleAllocatorAdapter<T>>;
+
+template <typename T>
+using MapleForwardList = std::forward_list<T, MapleAllocatorAdapter<T>>;
+
+template <typename T, typename Comparator = std::less<T>>
+using MapleSet = std::set<T, Comparator, MapleAllocatorAdapter<T>>;
+
+template <typename T, typename Hash = std::hash<T>, typename Equal = std::equal_to<T>>
+using MapleUnorderedSet = std::unordered_set<T, Hash, Equal, MapleAllocatorAdapter<T>>;
+
+template <typename K, typename V, typename Comparator = std::less<K>>
+using MapleMap = std::map<K, V, Comparator, MapleAllocatorAdapter<std::pair<const K, V>>>;
+
+template <typename K, typename V, typename Comparator = std::less<K>>
+using MapleMultiMap = std::multimap<K, V, Comparator, MapleAllocatorAdapter<std::pair<const K, V>>>;
+
+template <typename T, typename Comparator = std::less<T>>
+using MapleMultiSet = std::multiset<T, Comparator, MapleAllocatorAdapter<T>>;
+
+template <typename K, typename V, typename Hash = std::hash<K>, typename Equal = std::equal_to<K>>
+using MapleUnorderedMap = std::unordered_map<K, V, Hash, Equal, MapleAllocatorAdapter<std::pair<const K, V>>>;
+
+template <typename K, typename V, typename Hash = std::hash<K>, typename Equal = std::equal_to<K>>
+using MapleUnorderedMultiMap = std::unordered_multimap<K, V, Hash, Equal, MapleAllocatorAdapter<std::pair<const K, V>>>;
+
+// Implementation details below.
+template <>
+class MapleAllocatorAdapter<void> {
+ public:
+  using value_type = void;
+  using pointer = void*;
+  using const_pointer = const void*;
+  template <typename U>
+  struct rebind {
+    using other = MapleAllocatorAdapter<U>;
+  };
+
+  explicit MapleAllocatorAdapter(MapleAllocator &currMapleAllocator) : mapleAllocator(&currMapleAllocator) {}
+
+  template <typename U>
+  explicit MapleAllocatorAdapter(const MapleAllocatorAdapter<U> &other) : mapleAllocator(other.mapleAllocator) {}
+
+  MapleAllocatorAdapter(const MapleAllocatorAdapter &other) = default;
+  MapleAllocatorAdapter &operator=(const MapleAllocatorAdapter &other) = default;
+  ~MapleAllocatorAdapter() = default;
+
+ private:
+  template <typename U>
+  friend class MapleAllocatorAdapter;
+  MapleAllocator *mapleAllocator;
+};
+
+template <typename T>
+class MapleAllocatorAdapter {
+ public:
+  using value_type = T;
+  using pointer = T*;
+  using reference = T&;
+  using const_pointer = const T*;
+  using const_reference = const T&;
+  using size_type = size_t;
+  using difference_type = std::ptrdiff_t;
+  template <typename U>
+  struct rebind {
+    using other = MapleAllocatorAdapter<U>;
+  };
+
+  explicit MapleAllocatorAdapter(MapleAllocator &currMapleAllocator) : mapleAllocator(&currMapleAllocator) {}
+
+  template <typename U>
+  MapleAllocatorAdapter(const MapleAllocatorAdapter<U> &other) : mapleAllocator(other.mapleAllocator) {}
+
+  MapleAllocatorAdapter(const MapleAllocatorAdapter &other) = default;
+  MapleAllocatorAdapter &operator=(const MapleAllocatorAdapter &other) = default;
+  ~MapleAllocatorAdapter() = default;
+  size_type max_size() const {
+    return static_cast<size_type>(-1) / sizeof(T);
+  }
+
+  pointer address(reference x) const {
+    return &x;
+  }
+
+  const_pointer address(const_reference x) const {
+    return &x;
+  }
+
+  pointer allocate(size_type n) const {
+    return reinterpret_cast<T*>(mapleAllocator->Alloc(n * sizeof(T)));
+  }
+
+  void deallocate(pointer, size_type) const {}
+
+  void construct(const pointer p, const_reference val) const {
+    new (static_cast<void*>(p)) value_type(val);
+  }
+
+  void destroy(const pointer p) const {
+    CHECK_NULL_FATAL(p);
+    p->~value_type();
+  }
+
+ private:
+  template <typename U>
+  friend class MapleAllocatorAdapter;
+  template <typename U>
+  friend bool operator==(const MapleAllocatorAdapter<U> &lhs, const MapleAllocatorAdapter<U> &rhs);
+  MapleAllocator *mapleAllocator;
+};
+
+template <typename T>
+inline bool operator==(const MapleAllocatorAdapter<T> &lhs, const MapleAllocatorAdapter<T> &rhs) {
+  return lhs.mapleAllocator == rhs.mapleAllocator;
+}
+
+template <typename T>
+inline bool operator!=(const MapleAllocatorAdapter<T> &lhs, const MapleAllocatorAdapter<T> &rhs) {
+  return !(lhs == rhs);
+}
+
+inline MapleAllocatorAdapter<void> MapleAllocator::Adapter() {
+  return MapleAllocatorAdapter<void>(*this);
+}
+}  // namespace maple
+#endif  // MEMPOOL_INCLUDE_MEMPOOL_ALLOCATOR_H
diff --git a/src/mapleall/mempool/src/MPTest.cpp b/src/mapleall/mempool/src/MPTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..12a2faeb4280e6bca70a330bc09a3c8aa8a4101b
--- /dev/null
+++ b/src/mapleall/mempool/src/MPTest.cpp
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <iostream>
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "maple_string.h"
+#include "mpl_logging.h"
+#include "securec.h"
+using namespace maple;
+struct Structure {
+  int id;
+  float height;
+};
+
+class MyClass {
+ public:
+  MyClass(int currId, const std::string &currName) {
+    id = currId;
+    name = currName;
+  };
+  ~MyClass(){};
+  int id;
+  std::string name;
+};
+
+void TestLocalAllocater() {
+  MemPoolCtrler mpc;
+  auto mp = std::unique_ptr<StackMemPool>(new StackMemPool(mpc, ""));
+  LocalMapleAllocator alloc1(*mp);
+  MapleVector<int> v1({ 1, 2, 3, 4, 5 }, alloc1.Adapter());
+  {
+    LocalMapleAllocator alloc2(*mp);
+    MapleVector<int> v2({ 1, 2, 3, 4, 5 }, alloc2.Adapter());
+    {
+      LocalMapleAllocator alloc3(*mp);
+      MapleVector<int> v3({ 1, 2, 3, 4, 5 }, alloc3.Adapter());
+    }
+  }
+}
+
+int main() {
+  // 1. Create a memory pool controler instance;
+  MemPoolCtrler mpc;
+  // 2. Create two memory pools on mpc
+  MemPool *mp1 = mpc.NewMemPool("Test Memory Pool 1", true /* isLocalPool */);
+  MemPool *mp2 = mpc.NewMemPool("Test Memory Pool 2", true /* isLocalPool */);
+  // 3. Usage of memory pool, Malloc/Call on primitive types
+  // char string
+  constexpr int lengthOfHelloWorld = 12;
+  char *charP = static_cast<char *>(mp1->Malloc(lengthOfHelloWorld * sizeof(char)));
+  errno_t cpyRes = strcpy_s(charP, lengthOfHelloWorld, "Hello world");
+  if (cpyRes != 0) {
+    LogInfo::MapleLogger() << "call strcpy_s failed" << std::endl;
+    return 0;
+  }
+  LogInfo::MapleLogger() << charP << std::endl;
+  // int, float, double
+  constexpr int arrayLen = 10;
+  int *intP = static_cast<int *>(mp1->Calloc(arrayLen * sizeof(int)));
+  CHECK_FATAL(intP, "null ptr check  ");
+  for (int i = 0; i < arrayLen; ++i) {
+    intP[i] = i * i;
+  }
+  for (int i = 0; i < arrayLen - 1; ++i) {
+    LogInfo::MapleLogger() << intP[i] << " ,";
+  }
+  LogInfo::MapleLogger() << intP[arrayLen - 1] << std::endl;
+  float *floatP = static_cast<float *>(mp1->Malloc(arrayLen * sizeof(float)));
+  for (int i = 0; i < arrayLen; ++i) {
+    floatP[i] = 10.0 / (i + 1);  // test float num is 10.0
+  }
+  for (int i = 0; i < arrayLen - 1; ++i) {
+    LogInfo::MapleLogger() << floatP[i] << " ,";
+  }
+  LogInfo::MapleLogger() << floatP[arrayLen - 1] << std::endl;
+  // 4. Allocate memory on struct
+  Structure *structP = mp1->New<Structure>();
+  structP->height = 1024;  // test num is 1024.
+  structP->id = 0;
+  LogInfo::MapleLogger() << "Structure: my_struct height=" << structP->height << " feet,"
+                         << "id=    x" << structP->id << std::endl;
+  // 5. Allocate memory on class constructor
+  MyClass *myClass = mp1->New<MyClass>(1, "class name");
+  LogInfo::MapleLogger() << "Class: my_class id=" << myClass->id << " , name=" << myClass->name << std::endl;
+  // 7. Memory Pool supports std library such list, vector, string, map, set.
+  // using mempool
+  MapleAllocator mpAllocator(mp2);
+  // vector
+  MapleVector<int> myVector(mpAllocator.Adapter());
+  for (int i = 0; i < arrayLen; ++i) {
+    myVector.push_back(i * i * i);
+  }
+  MapleVector<int>::iterator itr;
+  for (itr = myVector.begin(); itr != myVector.end(); ++itr) {
+    LogInfo::MapleLogger() << *itr << " ,";
+  }
+  LogInfo::MapleLogger() << std::endl;
+  // stack
+  MapleQueue<int> myQueue(mpAllocator.Adapter());
+  myQueue.push_back(1);
+  myQueue.push_back(2);
+  myQueue.push_back(3);
+  LogInfo::MapleLogger() << "Queue front is" << myQueue.front() << std::endl;
+  LogInfo::MapleLogger() << "Queue back is" << myQueue.back() << std::endl;
+  myQueue.pop_back();
+  LogInfo::MapleLogger() << "after pop() vector top is" << myQueue.back() << std::endl;
+  // String
+  MapleString myString(mp2);
+  myString = "Using my mempool";
+  myString += " example";
+  LogInfo::MapleLogger() << myString << std::endl;
+  // list
+  MapleList<float> myList(mpAllocator.Adapter());
+  for (int i = 0; i < arrayLen; ++i) {
+    myList.push_back(1000.0 / (i + 1));  // test float num is 1000.0
+  }
+  MapleList<float>::iterator listItr;
+  for (listItr = myList.begin(); listItr != myList.end(); ++listItr) {
+    LogInfo::MapleLogger() << *listItr << " ,";
+  }
+  LogInfo::MapleLogger() << std::endl;
+  // Map
+  MapleMap<int, MapleString> myMap(std::less<int>(), mpAllocator.Adapter());
+  for (int i = 0; i < arrayLen; ++i) {
+    MapleString temp(mp2);
+    temp += std::to_string(i);
+    temp += " value";
+    myMap.insert(std::pair<int, MapleString>(i, temp));
+  }
+  MapleMap<int, MapleString>::iterator mapItr;
+  for (mapItr = myMap.begin(); mapItr != myMap.end(); ++mapItr) {
+    LogInfo::MapleLogger() << "key= " << mapItr->first << ", value=" << mapItr->second << std::endl;
+  }
+  // Set
+  MapleSet<MapleString> mySet(std::less<MapleString>(), mpAllocator.Adapter());
+  for (int i = 0; i < arrayLen; ++i) {
+    MapleString temp(mp2);
+    temp += std::to_string(i * i);
+    temp.append(" set values");
+    mySet.insert(temp);
+  }
+  MapleSet<MapleString>::iterator setItr;
+  for (setItr = mySet.begin(); setItr != mySet.end(); ++setItr) {
+    LogInfo::MapleLogger() << "set value =" << *setItr << std::endl;
+  }
+  // Delete memory pool
+  delete mp1;
+  delete mp2;
+
+  TestLocalAllocater();
+  return 1;
+}
diff --git a/src/mapleall/mempool/src/maple_string.cpp b/src/mapleall/mempool/src/maple_string.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b75d90dd757be2658ff189671be577a17a1a184
--- /dev/null
+++ b/src/mapleall/mempool/src/maple_string.cpp
@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "maple_string.h"
+#include "securec.h"
+namespace maple {
+MapleString::MapleString(const char *str, size_t size, MemPool *currMp)
+    : data(NewData(currMp, str, size)),
+      memPool(currMp),
+      dataLength(size) {}
+
+MapleString::MapleString(const char *str, MemPool *currMp)
+    : MapleString(str, StrLen(str), currMp) {}
+
+MapleString::MapleString(size_t size, MemPool *currMp)
+    : MapleString(nullptr, size, currMp) {}
+
+MapleString::MapleString(const MapleString &str, MemPool *currMp)
+    : MapleString(str.data, str.dataLength, currMp) {}
+
+MapleString::MapleString(const MapleString &str)
+    : MapleString(str, str.memPool) {}
+
+MapleString::MapleString(const std::string &str, MemPool *currMp)
+    : MapleString(str.data(), str.length(), currMp) {}
+
+char *MapleString::NewData(MemPool *currMp, const char *source, size_t len) {
+  MIR_ASSERT(currMp != nullptr);
+  if (source == nullptr && len == 0) {
+    return nullptr;
+  }
+  char *str = static_cast<char*>(currMp->Malloc((len + 1) * sizeof(char)));
+  CHECK_FATAL(str != nullptr, "MemPool::Malloc failed");
+  if (source != nullptr && len != 0) {
+    errno_t err = memcpy_s(str, len, source, len);
+    CHECK_FATAL(err == EOK, "memcpy_s failed");
+  }
+  str[len] = 0;
+  return str;
+}
+
+void MapleString::clear() {
+  data = nullptr;
+  dataLength = 0;
+}
+
+size_t MapleString::find(const MapleString &str, size_t pos) const {
+  return UnsafeFind(str.c_str(), pos, str.dataLength);
+}
+
+size_t MapleString::find(const char *str, size_t pos) const {
+  if (str == nullptr) {
+    return std::string::npos;
+  }
+  size_t strLen = strlen(str);
+  return UnsafeFind(str, pos, strLen);
+}
+
+size_t MapleString::find_last_of(const char *str, size_t pos) const {
+  if (str == nullptr) {
+    return std::string::npos;
+  }
+  size_t strLen = strlen(str);
+  if ((dataLength - pos) < strLen) {
+    return std::string::npos;
+  }
+  for (ssize_t i = static_cast<ssize_t>(dataLength - strLen); i >= static_cast<ssize_t>(pos); --i) {
+    if (data[static_cast<size_t>(i)] == str[0]) {
+      size_t j = 0;
+      for (; j < strLen; ++j) {
+        if (data[static_cast<size_t>(i) + j] == str[j]) {
+          continue;
+        } else {
+          break;
+        }
+      }
+      if (j == strLen) {
+        return i;
+      }
+    }
+  }
+  return std::string::npos;
+}
+
+size_t MapleString::find(const char *str, size_t pos, size_t n) const {
+  if (str == nullptr) {
+    return std::string::npos;
+  }
+  return UnsafeFind(str, pos, n);
+}
+
+size_t MapleString::find(char c, size_t pos) const {
+  if (dataLength == 0 || pos >= dataLength) {
+    return std::string::npos;
+  }
+  size_t i = pos;
+  for (; i < dataLength; ++i) {
+    if (data[i] == c) {
+      return i;
+    }
+  }
+  return std::string::npos;
+}
+
+MapleString MapleString::substr(size_t pos, size_t len) const {
+  if (len == 0) {
+    MIR_FATAL("Error: MapleString substr len is 0");
+  }
+  if (pos > dataLength) {
+    MIR_FATAL("Error: MapleString substr pos is out of boundary");
+  }
+  len = (len + pos) > dataLength ? (dataLength - pos) : len;
+  MapleString newStr(memPool);
+  newStr.data = static_cast<char*>(newStr.memPool->Malloc((1 + len) * sizeof(char)));
+  for (size_t i = 0; i < len; ++i) {
+    newStr[i] = this->data[i + pos];
+  }
+  newStr.dataLength = len;
+  newStr.data[newStr.dataLength] = '\0';
+  return newStr;
+}
+
+MapleString &MapleString::insert(size_t pos, const MapleString &str) {
+  if (pos > dataLength || str.dataLength == 0) {
+    return *this;
+  }
+  data = static_cast<char*>(
+      memPool->Realloc(data, (1 + dataLength) * sizeof(char), (1 + dataLength + str.dataLength) * sizeof(char)));
+  CHECK_FATAL(data != nullptr, "null ptr check ");
+  MapleString temp(memPool);
+  if (dataLength != pos) {
+    temp = this->substr(pos, dataLength - pos);
+  } else {
+    temp = "";
+  }
+  dataLength += str.dataLength;
+  for (size_t i = 0; i < str.dataLength; ++i) {
+    data[pos + i] = str.data[i];
+  }
+  if (temp == nullptr) {
+    CHECK_FATAL(false, "temp null ptr check");
+  }
+  for (size_t j = 0; j < temp.dataLength; ++j) {
+    data[pos + str.dataLength + j] = temp.data[j];
+  }
+  data[dataLength] = '\0';
+  return *this;
+}
+
+MapleString &MapleString::insert(size_t pos, const MapleString &str, size_t subPos, size_t subLen) {
+  MapleString subStr = str.substr(subPos, subLen);
+  this->insert(pos, subStr);
+  return *this;
+}
+
+MapleString &MapleString::insert(size_t pos, const char *s) {
+  if (s == nullptr) {
+    return *this;
+  }
+  size_t sLen = strlen(s);
+  if (pos > dataLength || sLen == 0) {
+    return *this;
+  }
+  MapleString subStr(s, memPool);
+  this->insert(pos, subStr);
+  return *this;
+}
+
+MapleString &MapleString::insert(size_t pos, const char *s, size_t n) {
+  if (s == nullptr) {
+    return *this;
+  }
+  size_t sLen = strlen(s);
+  if (pos > dataLength || sLen == 0) {
+    return *this;
+  }
+  n = ((n > sLen) ? sLen : n);
+  MapleString subStr(s, memPool);
+  subStr = subStr.substr(0, n);
+  this->insert(pos, subStr);
+  return *this;
+}
+
+MapleString &MapleString::insert(size_t pos, size_t n, char c) {
+  if (pos > dataLength) {
+    return *this;
+  }
+  MapleString subStr(n, memPool);
+  for (size_t i = 0; i < n; ++i) {
+    subStr[i] = c;
+  }
+  this->insert(pos, subStr);
+  return *this;
+}
+
+MapleString &MapleString::push_back(const char c) {
+  this->append(1, c);
+  return *this;
+}
+
+MapleString &MapleString::append(const MapleString &str) {
+  if (str.empty()) {
+    return *this;
+  }
+  this->insert(dataLength, str);
+  return *this;
+}
+
+MapleString &MapleString::append(const std::string &str) {
+  if (str.length() <= 0) {
+    return *this;
+  }
+  this->insert(dataLength, str.c_str());
+  return *this;
+}
+
+MapleString &MapleString::append(const MapleString &str, size_t subPos, size_t subLen) {
+  this->append(str.substr(subPos, subLen));
+  return *this;
+}
+
+MapleString &MapleString::append(const char *s) {
+  if (s == nullptr) {
+    return *this;
+  }
+  MapleString subStr(s, memPool);
+  this->append(subStr);
+  return *this;
+}
+
+MapleString &MapleString::append(const char *s, size_t n) {
+  if (s == nullptr) {
+    return *this;
+  }
+  MapleString subStr(s, memPool);
+  this->append(subStr, 0, n);
+  return *this;
+}
+
+MapleString &MapleString::append(size_t n, char c) {
+  MapleString subStr(n, memPool);
+  for (size_t i = 0; i < n; ++i) {
+    subStr[i] = c;
+  }
+  this->append(subStr);
+  return *this;
+}
+
+MapleString &MapleString::assign(const MapleString &str) {
+  *this = str;
+  return *this;
+}
+
+MapleString &MapleString::assign(const MapleString &str, size_t subPos, size_t subLen) {
+  *this = str.substr(subPos, subLen);
+  return *this;
+}
+
+MapleString &MapleString::assign(const char *s) {
+  *this = s;
+  return *this;
+}
+
+MapleString &MapleString::assign(const char *s, size_t n) {
+  MapleString subStr(s, memPool);
+  subStr = subStr.substr(0, n);
+  *this = subStr;
+  return *this;
+}
+
+MapleString &MapleString::assign(size_t n, char c) {
+  MapleString subStr(n, memPool);
+  for (size_t i = 0; i < n; ++i) {
+    subStr[i] = c;
+  }
+  this->assign(subStr);
+  return *this;
+}
+
+// global operators
+bool operator==(const MapleString &str1, const MapleString &str2) {
+  if (str1.dataLength != str2.dataLength) {
+    return false;
+  }
+  char *tmp1 = str1.data;
+  char *tmp2 = str2.data;
+  while (*tmp1 != 0) {
+    if (*tmp1 != *tmp2) {
+      return false;
+    }
+    ++tmp1;
+    ++tmp2;
+  }
+  return true;
+}
+
+bool operator==(const MapleString &str1, const char *str2) {
+  if (str2 == nullptr) {
+    return false;  // Should we return str1.dataLength==0 ?
+  }
+  size_t size = strlen(str2);
+  if (str1.dataLength != size) {
+    return false;
+  }
+  char *tmp = str1.data;
+  CHECK_NULL_FATAL(tmp);
+  while (*tmp != 0) {
+    if (*tmp != *str2) {
+      return false;
+    }
+    ++tmp;
+    ++str2;
+  }
+  return true;
+}
+
+bool operator==(const char *str1, const MapleString &str2) {
+  size_t size = strlen(str1);
+  if (str2.dataLength != size) {
+    return false;
+  }
+  char *tmp = str2.data;
+  CHECK_NULL_FATAL(tmp);
+  while (*tmp != 0) {
+    if (*tmp != *str1) {
+      return false;
+    }
+    ++tmp;
+    ++str1;
+  }
+  return true;
+}
+
+bool operator!=(const MapleString &str1, const MapleString &str2) {
+  return !(str1 == str2);
+}
+
+bool operator!=(const MapleString &str1, const char *str2) {
+  return !(str1 == str2);
+}
+
+bool operator!=(const char *str1, const MapleString &str2) {
+  return !(str1 == str2);
+}
+
+bool operator<(const MapleString &str1, const MapleString &str2) {
+  CHECK_FATAL(!str1.empty(), "empty string check");
+  CHECK_FATAL(!str2.empty(), "empty string check");
+  return (strcmp(str1.c_str(), str2.c_str()) < 0);
+}
+}  // namespace maple
diff --git a/src/mapleall/mempool/src/mempool.cpp b/src/mapleall/mempool/src/mempool.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b65befe182cc68265868bbccf9b1d1d84c645cce
--- /dev/null
+++ b/src/mapleall/mempool/src/mempool.cpp
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mempool.h"
+#include "thread_env.h"
+#include "securec.h"
+#include "mpl_logging.h"
+
+namespace maple {
+MemPoolCtrler memPoolCtrler;
+bool MemPoolCtrler::freeMemInTime = false;
+
+size_t BitsAlign(size_t size) {
+  size_t kAlign8FillSize = 7;
+  return ((size) + kAlign8FillSize) & (0xFFFFFFF8);
+}
+
+void MemPoolCtrler::FreeMemBlocks(const MemPool &pool, MemBlock *fixedMemHead, MemBlock *bigMemHead) {
+  (void)(pool);
+
+  MemBlock *fixedTail = nullptr;
+
+  if (fixedMemHead != nullptr) {
+    fixedTail = fixedMemHead;
+    while (fixedTail->nextMemBlock != nullptr) {
+      fixedTail = fixedTail->nextMemBlock;
+    }
+  }
+
+  while (bigMemHead != nullptr) {
+    auto *cur = bigMemHead;
+    bigMemHead = bigMemHead->nextMemBlock;
+    cur->~MemBlock();
+    free(cur);
+  }
+
+  ParallelGuard guard(ctrlerMutex, HaveRace());
+  if (fixedTail != nullptr) {
+    fixedTail->nextMemBlock = fixedFreeMemBlocks;
+    ASSERT(fixedTail->nextMemBlock != fixedTail, "error");
+    fixedFreeMemBlocks = fixedMemHead;
+  }
+}
+
+// Destructor, free all allocated memories
+MemPoolCtrler::~MemPoolCtrler() {
+  FreeMem();
+}
+
+// Allocate a new memory pool and register it in controller
+MemPool *MemPoolCtrler::NewMemPool(const std::string &name, bool isLocalPool) {
+  MemPool *memPool = nullptr;
+
+  if (isLocalPool) {
+    memPool = new ThreadLocalMemPool(*this, name);
+  } else {
+    memPool = new ThreadShareMemPool(*this, name);
+  }
+
+  return memPool;
+}
+
+// This function will be removed soon, DO NOT call it, just use delete memPool
+void MemPoolCtrler::DeleteMemPool(MemPool *memPool) const {
+  delete memPool;
+}
+
+void MemPoolCtrler::FreeMem() {
+  ParallelGuard guard(ctrlerMutex, HaveRace());
+
+  while (fixedFreeMemBlocks != nullptr) {
+    MemBlock *arena = fixedFreeMemBlocks;
+    fixedFreeMemBlocks = fixedFreeMemBlocks->nextMemBlock;
+    arena->~MemBlock();
+  }
+}
+
+MemBlock *MemPoolCtrler::AllocMemBlock(const MemPool &pool, size_t size) {
+  if (size <= kMemBlockSizeMin) {
+    return AllocFixMemBlock(pool);
+  } else {
+    return AllocBigMemBlock(pool, size);
+  }
+}
+
+MemBlock *MemPoolCtrler::AllocFixMemBlock(const MemPool &pool) {
+  (void)(pool);
+  ParallelGuard guard(ctrlerMutex, HaveRace());
+  if (fixedFreeMemBlocks == nullptr) {
+    uint8_t *ptr = sysMemoryMgr->RealAllocMemory(kMemBlockRealMallocSize);
+    // leave one MemBlock to return
+    for (size_t i = 0; i < kMemBlockRealMallocSize / kMemBlockMallocSize; ++i) {
+      auto *block = new (ptr) MemBlock(ptr + kMemBlockStructSize, kMemBlockSizeMin);
+      ptr += kMemBlockMallocSize;
+      block->nextMemBlock = fixedFreeMemBlocks;
+      fixedFreeMemBlocks = block;
+    }
+  }
+
+  MemBlock *ret = fixedFreeMemBlocks;
+  fixedFreeMemBlocks = fixedFreeMemBlocks->nextMemBlock;
+  return ret;
+}
+
+MemBlock *MemPoolCtrler::AllocBigMemBlock(const MemPool &pool, size_t size) const {
+  ASSERT(size > kMemBlockSizeMin, "Big memory block must be bigger than fixed memory block");
+  (void)(pool);
+
+  uint8_t *block = reinterpret_cast<uint8_t*>(malloc(size + kMemBlockStructSize));
+  CHECK_FATAL(block != nullptr, "malloc failed");
+  return new (block) MemBlock(block + kMemBlockStructSize, size);
+}
+
+MemPool::~MemPool() {
+  ctrler.FreeMemBlocks(*this, fixedMemHead, bigMemHead);
+}
+
+void *MemPool::Malloc(size_t size) {
+  size = BitsAlign(size);
+  ASSERT(endPtr >= curPtr, "endPtr should >= curPtr");
+  if (size > static_cast<size_t>(endPtr - curPtr)) {
+    return AllocNewMemBlock(size);
+  }
+  uint8_t *retPtr = curPtr;
+  curPtr += size;
+  return retPtr;
+}
+
+void MemPool::ReleaseContainingMem() {
+  ctrler.FreeMemBlocks(*this, fixedMemHead, bigMemHead);
+
+  fixedMemHead = nullptr;
+  bigMemHead = nullptr;
+  endPtr = nullptr;
+  curPtr = nullptr;
+}
+
+// Malloc size of memory from memory pool, then set 0
+void *MemPool::Calloc(size_t size) {
+  void *p = Malloc(BitsAlign(size));
+  ASSERT(p != nullptr, "ERROR: Calloc error");
+  errno_t eNum = memset_s(p, BitsAlign(size), 0, BitsAlign(size));
+  CHECK_FATAL(eNum == EOK, "memset_s failed");
+  return p;
+}
+
+// Realloc new size of memory
+void *MemPool::Realloc(const void *ptr, size_t oldSize, size_t newSize) {
+  void *result = Malloc(newSize);
+  ASSERT(result != nullptr, "ERROR: Realloc error");
+  size_t copySize = ((newSize > oldSize) ? oldSize : newSize);
+  if (copySize != 0 && ptr != nullptr) {
+    errno_t eNum = memcpy_s(result, copySize, ptr, copySize);
+    CHECK_FATAL(eNum == EOK, "memcpy_s failed");
+  }
+  return result;
+}
+
+uint8_t *MemPool::AllocNewMemBlock(size_t byteSize) {
+  MemBlock **head = nullptr;
+  MemBlock *newMemBlock = ctrler.AllocMemBlock(*this, byteSize);
+  if (newMemBlock->memSize <= kMemBlockSizeMin) {
+    head = &fixedMemHead;
+  } else {
+    head = &bigMemHead;
+  }
+
+  newMemBlock->nextMemBlock = *head;
+  *head = newMemBlock;
+  CHECK_FATAL(newMemBlock->nextMemBlock != newMemBlock, "error");
+
+  curPtr = newMemBlock->startPtr + byteSize;
+  endPtr = newMemBlock->startPtr + newMemBlock->memSize;
+  ASSERT(curPtr <= endPtr, "must be");
+
+  return newMemBlock->startPtr;
+}
+
+void *StackMemPool::Malloc(size_t size) {
+  size = BitsAlign(size);
+  uint8_t **curPtrPtr = nullptr;
+  uint8_t *curEndPtr = nullptr;
+  if (size <= kMemBlockSizeMin) {
+    curPtrPtr = &curPtr;
+    curEndPtr = endPtr;
+  } else {
+    curPtrPtr = &bigCurPtr;
+    curEndPtr = bigEndPtr;
+  }
+  uint8_t *retPtr = *curPtrPtr;
+  ASSERT(curEndPtr >= *curPtrPtr, "endPtr should >= curPtr");
+  if (size > static_cast<size_t>(curEndPtr - *curPtrPtr)) {
+    retPtr = AllocTailMemBlock(size);
+  }
+  *curPtrPtr = retPtr + size;
+  return retPtr;
+}
+
+// scoped mem pool don't use big mem block for small size, different with normal mempool
+MemBlock *StackMemPool::AllocMemBlockBySize(size_t size) {
+  if (size <= kMemBlockSizeMin) {
+    return ctrler.AllocFixMemBlock(*this);
+  } else {
+    return ctrler.AllocBigMemBlock(*this, size);
+  }
+}
+
+void StackMemPool::ResetStackTop(const LocalMapleAllocator *alloc, uint8_t *fixedCurPtrMark,
+                                 MemBlock *fixedStackTopMark, uint8_t *bigCurPtrMark,
+                                 MemBlock *bigStackTopMark) noexcept {
+  CheckTopAllocator(alloc);
+  PopAllocator();
+
+  if (fixedStackTopMark != nullptr) {
+    fixedMemStackTop = fixedStackTopMark;
+    curPtr = fixedCurPtrMark;
+    endPtr = fixedMemStackTop->EndPtr();
+  } else if (fixedMemHead != nullptr) {
+    fixedMemStackTop = fixedMemHead;
+    curPtr = fixedMemStackTop->startPtr;
+    endPtr = fixedMemStackTop->EndPtr();
+  }
+
+  if (bigStackTopMark != nullptr) {
+    bigMemStackTop = bigStackTopMark;
+    bigCurPtr = bigCurPtrMark;
+    bigEndPtr = bigMemStackTop->EndPtr();
+  } else if (bigMemHead != nullptr) {
+    bigMemStackTop = bigMemHead;
+    bigCurPtr = bigMemStackTop->startPtr;
+    bigEndPtr = bigMemStackTop->EndPtr();
+  }
+}
+
+uint8_t *StackMemPool::AllocTailMemBlock(size_t size) {
+  MemBlock **head = nullptr;
+  MemBlock **stackTop = nullptr;
+  uint8_t **endPtrPtr = nullptr;
+
+  if (size <= kMemBlockSizeMin) {
+    head = &fixedMemHead;
+    stackTop = &fixedMemStackTop;
+    endPtrPtr = &endPtr;
+  } else {
+    head = &bigMemHead;
+    stackTop = &bigMemStackTop;
+    endPtrPtr = &bigEndPtr;
+  }
+
+  if (*stackTop == nullptr) {
+    MemBlock *newMemBlock = AllocMemBlockBySize(size);
+    *stackTop = newMemBlock;
+    *head = newMemBlock;
+    (*stackTop)->nextMemBlock = nullptr;
+  } else {
+    if ((*stackTop)->nextMemBlock != nullptr && (*stackTop)->nextMemBlock->memSize >= size) {
+      *stackTop = (*stackTop)->nextMemBlock;
+    } else {
+      MemBlock *newMemBlock = AllocMemBlockBySize(size);
+      auto *tmp = (*stackTop)->nextMemBlock;
+      (*stackTop)->nextMemBlock = newMemBlock;
+      *stackTop = newMemBlock;
+      newMemBlock->nextMemBlock = tmp;
+    }
+  }
+  *endPtrPtr = (*stackTop)->EndPtr();
+  return (*stackTop)->startPtr;
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/BUILD.gn b/src/mapleall/mpl2mpl/BUILD.gn
new file mode 100755
index 0000000000000000000000000000000000000000..9ac1eafb1035eb531ea87177a045692ea352b194
--- /dev/null
+++ b/src/mapleall/mpl2mpl/BUILD.gn
@@ -0,0 +1,75 @@
+#
+# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+include_directories = [
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_me/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include",
+  "${MAPLEALL_ROOT}/maple_ipa/include/old",
+  "${MAPLEALL_ROOT}/maple_phase/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/mpl2mpl/include",
+  "${MAPLEALL_ROOT}/mpl2mpl/include/aarch64",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+]
+
+src_libmpl2mpl = [
+  "src/class_init.cpp",
+  "src/gen_check_cast.cpp",
+  "src/barrierinsertion.cpp",
+  "src/muid_replacement.cpp",
+  "src/reflection_analysis.cpp",
+  "src/vtable_analysis.cpp",
+  "src/java_intrn_lowering.cpp",
+  "src/simplify.cpp",
+  "src/openProfile.cpp",
+  "src/update_mplt.cpp",
+  "src/java_eh_lower.cpp",
+  "src/native_stub_func.cpp",
+  "src/vtable_impl.cpp",
+  "src/class_hierarchy.cpp",
+  "src/class_hierarchy_phase.cpp",
+  "src/constantfold.cpp",
+  "src/ext_constantfold.cpp",
+  "src/coderelayout.cpp",
+  "src/annotation_analysis.cpp",
+  "src/gen_profile.cpp",
+  "src/preme.cpp",
+  "src/scalarreplacement.cpp",
+  "src/module_phase_manager.cpp",
+  "src/inline_summary.cpp",
+  "src/clone.cpp",
+  "src/retype.cpp",
+  "src/call_graph.cpp",
+  "src/inline.cpp",
+  "src/ginline.cpp",
+  "src/stmt_cost_analyzer.cpp",
+  "src/inline_analyzer.cpp",
+  "src/inline_transformer.cpp",
+  "src/inline_mplt.cpp",
+  "src/outline.cpp",
+  "src/method_replace.cpp",
+  "src/mpl_profdata_parser.cpp",
+  "src/target_info.cpp",
+]
+
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+
+static_library("libmpl2mpl") {
+  sources = src_libmpl2mpl
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
diff --git a/src/mapleall/mpl2mpl/CMakeLists.txt b/src/mapleall/mpl2mpl/CMakeLists.txt
new file mode 100755
index 0000000000000000000000000000000000000000..0cb41e867681c18b236c9f316465f22d2feedb9b
--- /dev/null
+++ b/src/mapleall/mpl2mpl/CMakeLists.txt
@@ -0,0 +1,77 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+# http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN AS IS BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(inc_libmpl2mpl
+    ${MAPLEALL_ROOT}/maple_ir/include
+    ${MAPLEALL_ROOT}/maple_me/include
+    ${MAPLEALL_ROOT}/maple_ipa/include
+    ${MAPLEALL_ROOT}/maple_ipa/include/old
+    ${MAPLEALL_ROOT}/maple_phase/include
+    ${MAPLEALL_ROOT}/maple_util/include
+    ${MAPLEALL_ROOT}/maple_driver/include
+    ${MAPLEALL_ROOT}/mpl2mpl/include
+    ${MAPLEALL_ROOT}/mpl2mpl/include/aarch64
+    ${MAPLEALL_ROOT}/mempool/include
+    ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+)
+
+set(src_libmpl2mpl
+    src/class_init.cpp
+    src/gen_check_cast.cpp
+    src/barrierinsertion.cpp
+    src/muid_replacement.cpp
+    src/reflection_analysis.cpp
+    src/vtable_analysis.cpp
+    src/java_intrn_lowering.cpp
+    src/simplify.cpp
+    src/openProfile.cpp
+    src/update_mplt.cpp
+    src/java_eh_lower.cpp
+    src/native_stub_func.cpp
+    src/vtable_impl.cpp
+    src/class_hierarchy.cpp
+    src/class_hierarchy_phase.cpp
+    src/constantfold.cpp
+    src/ext_constantfold.cpp
+    src/coderelayout.cpp
+    src/annotation_analysis.cpp
+    src/gen_profile.cpp
+    src/preme.cpp
+    src/scalarreplacement.cpp
+    src/module_phase_manager.cpp
+    src/inline_summary.cpp
+    src/clone.cpp
+    src/retype.cpp
+    src/call_graph.cpp
+    src/inline.cpp
+    src/ginline.cpp
+    src/stmt_cost_analyzer.cpp
+    src/inline_analyzer.cpp
+    src/inline_transformer.cpp
+    src/inline_mplt.cpp
+    src/outline.cpp
+    src/method_replace.cpp
+    src/mpl_profdata_parser.cpp
+    src/target_info.cpp
+)
+
+#libmpl2mpl
+add_library(libmpl2mpl STATIC ${src_libmpl2mpl})
+set_target_properties(libmpl2mpl PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${inc_libmpl2mpl}"
+    LINK_LIBRARIES ""
+    ARCHIVE_OUTPUT_DIRECTORY ${MAPLE_BUILD_OUTPUT}/lib/${HOST_ARCH}
+)
diff --git a/src/mapleall/mpl2mpl/include/annotation_analysis.h b/src/mapleall/mpl2mpl/include/annotation_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8343ce668a8cedbe09f71bff529bc693263f0d3
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/annotation_analysis.h
@@ -0,0 +1,302 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_ANNOTATION_ANALYSIS_H
+#define MPL2MPL_INCLUDE_ANNOTATION_ANALYSIS_H
+#include "class_hierarchy_phase.h"
+#include "namemangler.h"
+
+namespace maple {
+enum ATokenKind {
+  kEnd,
+  kChar,
+  kTemplateStart,
+  kTemplateEnd,
+  kAClassName,
+  kPrimeTypeName,
+  kTemplateName,
+  kExtend,
+  kSuper,
+  kArgumentStart,
+  kArgumentEnd,
+  kMatch,
+  kArray,
+  kString,
+  kSubClass,
+  kSemiComma
+};
+
+enum AKind {
+  kGenericType,
+  kGenericDeclare,
+  kGenericMatch,
+  kPrimeType,
+  kExtendType
+};
+
+enum EInfo {
+  kHierarchyExtend,
+  kHierarchyHSuper,
+  kArrayType
+};
+
+class AnnotationType {
+ public:
+  static int atime;
+  AnnotationType(AKind ak, const GStrIdx &strIdx) : id(atime++), kind(ak), typeName(strIdx) {}
+  virtual ~AnnotationType() = default;
+  virtual const std::string GetName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(typeName);
+  }
+
+  GStrIdx GetGStrIdx() {
+    return typeName;
+  }
+
+  AKind GetKind() const {
+    return kind;
+  }
+
+  int GetId() const {
+    return id;
+  }
+
+  virtual void Dump();
+  virtual void ReWriteType(std::string &) {
+    CHECK_FATAL(false, "impossible");
+  }
+
+ protected:
+  int id;
+  AKind kind;
+  GStrIdx typeName;
+};
+
+class GenericDeclare;
+class GenericType : public AnnotationType {
+ public:
+  GenericType(const GStrIdx &strIdx, MIRType *ms, MapleAllocator &alloc)
+      : AnnotationType(kGenericType, strIdx),
+        mirStructType(ms),
+        GenericArg(alloc.Adapter()),
+        ArgOrder(alloc.Adapter()) {}
+  virtual ~GenericType() = default;
+  void AddGenericPair(GenericDeclare * const k, AnnotationType *v) {
+    GenericArg[k] = v;
+    ArgOrder.push_back(v);
+  }
+
+  MIRStructType *GetMIRStructType() const {
+    if (mirStructType->IsInstanceOfMIRStructType()) {
+      return static_cast<MIRStructType*>(mirStructType);
+    }
+    CHECK_FATAL(false, "must be");
+    return nullptr;
+  }
+
+  MIRType *GetMIRType() {
+    return mirStructType;
+  }
+  const MIRType *GetMIRType() const {
+    return mirStructType;
+  }
+
+  const std::string GetName() const override {
+    return mirStructType->GetMplTypeName();
+  }
+
+  MapleMap<GenericDeclare*, AnnotationType*> &GetGenericMap() {
+    return GenericArg;
+  }
+
+  MapleVector<AnnotationType*> &GetGenericArg() {
+    return ArgOrder;
+  }
+
+  void Dump() override;
+  void ReWriteType(std::string &subClass) override;
+ private:
+  MIRType *mirStructType;
+  MapleMap<GenericDeclare*, AnnotationType*> GenericArg;
+  MapleVector<AnnotationType*> ArgOrder;
+};
+
+class GenericDeclare : public AnnotationType {
+ public:
+  explicit GenericDeclare(const GStrIdx &strIdx)
+      : AnnotationType(kGenericDeclare, strIdx),
+        defaultType(nullptr) {}
+  virtual ~GenericDeclare() = default;
+  AnnotationType *GetDefaultType() {
+    return defaultType;
+  }
+  const AnnotationType *GetDefaultType() const {
+    return defaultType;
+  }
+
+  void SetDefaultType(AnnotationType *gt) {
+    defaultType = gt;
+  }
+
+  std::string GetBelongToName() const {
+    if (defKind == defByStruct) {
+      return belongsTo.structType->GetName();
+    } else {
+      return belongsTo.func->GetName();
+    }
+  }
+
+  void Dump() override;
+
+  void SetBelongToStruct(MIRStructType *s) {
+    defKind = defByStruct;
+    belongsTo.structType = s;
+  }
+
+  void SetBelongToFunc(MIRFunction *f) {
+    defKind = defByFunc;
+    belongsTo.func = f;
+  }
+
+ private:
+  AnnotationType *defaultType;
+  union DefPoint {
+    MIRStructType *structType;
+    MIRFunction *func;
+  };
+  DefPoint belongsTo;
+  enum DefKind {
+    defByNone,
+    defByStruct,
+    defByFunc
+  };
+  DefKind defKind = defByNone;
+};
+
+class ExtendGeneric : public AnnotationType {
+ public:
+  ExtendGeneric(AnnotationType &c, EInfo h) : AnnotationType(kExtendType, GStrIdx(0)), contains(&c), eInfo(h) {
+    CHECK_FATAL(c.GetKind() != kGenericMatch, "must be");
+  }
+  virtual ~ExtendGeneric() = default;
+
+  void Dump() override {
+    std::cout << (eInfo == kHierarchyExtend ? '+' : (eInfo == kArrayType ? '[' : '-'));
+    if (contains->GetKind() == kGenericDeclare) {
+      std::cout << "T" << contains->GetName() << ";";
+    } else {
+      contains->Dump();
+    }
+  }
+
+  EInfo GetExtendInfo() const {
+    return eInfo;
+  }
+
+  AnnotationType *GetContainsGeneric() {
+    return contains;
+  }
+  const AnnotationType *GetContainsGeneric() const {
+    return contains;
+  }
+ private:
+  AnnotationType *contains;
+  EInfo eInfo;
+};
+
+class AnnotationParser {
+ public:
+  explicit AnnotationParser(std::string &s) : signature(s), curIndex(0) {}
+  ~AnnotationParser() = default;
+  ATokenKind GetNextToken(const char *endC = nullptr);
+  GenericDeclare *GetOrCreateDeclare(GStrIdx gStrIdx, MemPool &mp, bool check = false, MIRStructType *sType = nullptr);
+  AnnotationType *GetOrCreateArrayType(AnnotationType &containsType, MemPool &pragmaMemPool);
+  void BackOne() {
+    --curIndex;
+  }
+
+  std::string GetCurIndexStr() const {
+    return signature.substr(0, curIndex < signature.size() ? curIndex : signature.size());
+  }
+
+  void InitClassGenericDeclare(MemPool &pragmaMemPool, MIRStructType &mirStruct);
+  void InitFuncGenericDeclare(MemPool &pragmaMemPool, MIRFunction &mirFunc);
+  std::string GetNextClassName(bool forSubClass = false);
+  std::string GetCurStrToken() {
+    return curStrToken;
+  }
+
+  void ReplaceSignature(const std::string &s) {
+    signature = s;
+    curIndex = 0;
+  }
+
+ private:
+  std::string &signature;
+  size_t curIndex;
+  std::map<GStrIdx, GenericDeclare*> created;
+  std::map<AnnotationType*, ExtendGeneric*> createdArrayType;
+  std::string curStrToken;
+};
+
+class AnnotationAnalysis : public AnalysisResult {
+ public:
+  static char annoDeclare;
+  static char annoSemiColon;
+  AnnotationAnalysis(MIRModule *mod, MemPool *tmpMp, MemPool &pragmaMp, KlassHierarchy *kh)
+      : AnalysisResult(&pragmaMp),
+        mirModule(mod),
+        tmpAllocator(tmpMp),
+        pragmaMemPool(&pragmaMp),
+        pragmaAllocator(&pragmaMp),
+        klassH(kh) {
+          genericMatch = pragmaMp.New<AnnotationType>(kGenericMatch, GStrIdx(0));
+          GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName("Ljava_2Flang_2FObject_3B");
+          MIRType &classType = GetTypeFromTyIdx(GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(strIdx));
+          dummyObj = pragmaMp.New<GenericType>(strIdx, &static_cast<MIRStructType&>(classType), pragmaAllocator);
+        };
+  ~AnnotationAnalysis() = default;
+  void Run();
+ private:
+  void AnalysisAnnotation();
+  void AnalysisAnnotationForClass(const MIRPragma &classPragma);
+  void AnalysisAnnotationForVar(const MIRPragma &varPragma, MIRStructType &structType);
+  void AnalysisAnnotationForFunc(const MIRPragma &funcPragma, MIRStructType &structType);
+  AnnotationType *ReadInGenericType(AnnotationParser &aParser, MIRStructType *sType);
+  GenericDeclare *ReadInGenericDeclare(AnnotationParser &aParser, MIRStructType *mirStructType = nullptr);
+  std::string ReadInAllSubString(const MIRPragma &classPragma);
+  void AAForClassInfo(MIRStructType &structType);
+  void AAForFuncVarInfo(MIRStructType &structType);
+  void AnalysisAnnotationForFuncLocalVar(MIRFunction &func, AnnotationParser &aParser, MIRStructType &structType);
+  void ByPassFollowingInfo(AnnotationParser &aParser, MIRStructType *sType);
+  MIRModule *mirModule;
+  MapleAllocator tmpAllocator;
+  MemPool *pragmaMemPool;
+  MapleAllocator pragmaAllocator;
+  KlassHierarchy *klassH;
+  MapleSet<MIRStructType*> analysised{tmpAllocator.Adapter()};
+  MapleSet<MIRFunction*> analysisedFunc{tmpAllocator.Adapter()};
+  AnnotationType *genericMatch = nullptr;
+  GenericType *dummyObj = nullptr;
+};
+
+MAPLE_MODULE_PHASE_DECLARE_BEGIN(M2MAnnotationAnalysis)
+  AnnotationAnalysis *GetResult() {
+    return aa;
+  }
+  AnnotationAnalysis *aa = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_MODULE_PHASE_DECLARE_END
+}
+#endif
diff --git a/src/mapleall/mpl2mpl/include/array_hotfunclist.def b/src/mapleall/mpl2mpl/include/array_hotfunclist.def
new file mode 100644
index 0000000000000000000000000000000000000000..eb367cd0d0b0fe0a7dbf0b35084523fb367e8357
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/array_hotfunclist.def
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+"Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormat_3B_7CformatDuration_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FString_3B",
+"Landroid_2Fapp_2FIActivityManager_24Stub_3B_7ConTransact_7C_28ILandroid_2Fos_2FParcel_3BLandroid_2Fos_2FParcel_3BI_29Z",
+"Landroid_2Fcontent_2Fpm_2FIPackageManager_24Stub_3B_7ConTransact_7C_28ILandroid_2Fos_2FParcel_3BLandroid_2Fos_2FParcel_3BI_29Z",
+"Landroid_2Fcontent_2FIContentService_24Stub_3B_7ConTransact_7C_28ILandroid_2Fos_2FParcel_3BLandroid_2Fos_2FParcel_3BI_29Z",
+"Lcom_2Fandroid_2Fserver_2Fam_2FHwActivityManagerService_3B_7ConTransact_7C_28ILandroid_2Fos_2FParcel_3BLandroid_2Fos_2FParcel_3BI_29Z",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7ConTransact_7C_28ILandroid_2Fos_2FParcel_3BLandroid_2Fos_2FParcel_3BI_29Z",
+"Ljava_2Flang_2Freflect_2FMethod_3B_7Cinvoke_7C_28Ljava_2Flang_2FObject_3BALjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+"Lcom_2Fandroid_2Fserver_2FSystemServer_3B_7Crun_7C_28_29V",
+"Lcom_2Fandroid_2Finternal_2Ftelephony_2FIPhoneStateListener_24Stub_24Proxy_3B_7ConMessageWaitingIndicatorChanged_7C_28Z_29V",
+"Landroid_2Fview_2Fanimation_2FTransformation_3B_7C_3Cinit_3E_7C_28_29V",
+"Lcom_2Fandroid_2Fserver_2FSystemServer_3B_7CstartOtherServices_7C_28_29V",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FSettings_3B_7CreadLPw_7C_28Ljava_2Futil_2FList_3B_29Z",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CupdateOomAdjLocked_7C_28_29V",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FHwPackageManagerService_3B_7ConTransact_7C_28ILandroid_2Fos_2FParcel_3BLandroid_2Fos_2FParcel_3BI_29Z",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CgeneratePackageInfo_7C_28Lcom_2Fandroid_2Fserver_2Fpm_2FPackageSetting_3BII_29Landroid_2Fcontent_2Fpm_2FPackageInfo_3B",
+"Ljava_2Flang_2FThrowable_3B_7CprintStackTrace_7C_28Ljava_2Flang_2FThrowable_24PrintStreamOrWriter_3B_29V",
+"Lcom_2Fandroid_2Fserver_2FSystemServer_3B_7CstartBootstrapServices_7C_28_29V",
+"Ljava_2Flang_2FThrowable_3B_7CgetOurStackTrace_7C_28_29ALjava_2Flang_2FStackTraceElement_3B",
+"Ldalvik_2Fsystem_2FVMStack_3B_7CgetStackClass2_7C_28_29Ljava_2Flang_2FClass_3B",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CattachApplicationLocked_7C_28Landroid_2Fapp_2FIApplicationThread_3BI_29Z",
+"Lcom_2Fandroid_2Fserver_2FInputMethodManagerService_3B_7ChideCurrentInputLocked_7C_28ILandroid_2Fos_2FResultReceiver_3B_29Z"
diff --git a/src/mapleall/mpl2mpl/include/asm_map.def b/src/mapleall/mpl2mpl/include/asm_map.def
new file mode 100644
index 0000000000000000000000000000000000000000..429864e9e841a13f26d29bee98bae8a6fe2b20af
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/asm_map.def
@@ -0,0 +1,2 @@
+// {"old_funcName", "replaced_funcName"},
+{"memcpy", "memcpy_mpl"},
diff --git a/src/mapleall/mpl2mpl/include/barrierinsertion.h b/src/mapleall/mpl2mpl/include/barrierinsertion.h
new file mode 100644
index 0000000000000000000000000000000000000000..86d9810f6c789f7ea2fceb70fc04fa57ac0e9cba
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/barrierinsertion.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_BARRIERINSERTION_H
+#define MPL2MPL_INCLUDE_BARRIERINSERTION_H
+
+namespace maple {
+#ifdef NOT_USED
+class BarrierInsertion : public ModulePhase {
+ public:
+  explicit BarrierInsertion(ModulePhaseID id) : ModulePhase(id) {}
+
+  ~BarrierInsertion() = default;
+
+  AnalysisResult *Run(MIRModule *module, ModuleResultMgr *m) override;
+  std::string PhaseName() const override {
+    return "barrierinsertion";
+  }
+
+ private:
+  class RunFunction;
+  friend RunFunction;
+  class RunFunction {
+    friend BarrierInsertion;
+    RunFunction(BarrierInsertion &phase, MIRModule &module, MIRFunction &func)
+        : phase(&phase), mirModule(&module), mirFunc(&func), builder(module.GetMIRBuilder()), backupVarCount(0) {}
+
+    ~RunFunction() = default;
+
+    CallNode *CreateWriteRefVarCall(BaseNode &var, BaseNode &value) const;
+    CallNode *CreateWriteRefFieldCall(BaseNode &obj, BaseNode &field, BaseNode &value) const;
+    CallNode *CreateReleaseRefVarCall(BaseNode &var) const;
+    // MCC_CheckObjMem(address_t obj)
+    CallNode *CreateMemCheckCall(BaseNode &obj) const;
+    void HandleBlock(BlockNode &block) const;
+    StmtNode *HandleStmt(StmtNode &stmt, BlockNode &block) const;
+    StmtNode *CheckRefRead(BaseNode *opnd, const StmtNode &stmt, BlockNode &block) const;
+    void InsertPrologue();
+    void HandleReturn(const NaryStmtNode &retNode);
+    MIRSymbol *NewBackupVariable(const std::string &suffix);
+    void Run();
+    std::string PhaseName() const {
+      return phase->PhaseName();
+    }
+
+    bool SkipRHS(const BaseNode &rhs) const;
+    BarrierInsertion *phase;
+    MIRModule *mirModule;
+    MIRFunction *mirFunc;
+    MIRBuilder *builder;
+    int backupVarCount;
+    std::set<StIdx> backupVarIndices;
+    std::set<StIdx> assignedParams;
+    std::set<NaryStmtNode*> rets;  // there could be multiple return in the function
+  };
+
+  void EnsureLibraryFunction(MIRModule &module, const char &name, const MIRType &retType, const ArgVector &args);
+  void EnsureLibraryFunctions(MIRModule &module);
+};
+#endif
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_BARRIERINSERTION_H
diff --git a/src/mapleall/mpl2mpl/include/call_graph.h b/src/mapleall/mpl2mpl/include/call_graph.h
new file mode 100644
index 0000000000000000000000000000000000000000..932be4a4077a6cd98ea93f192245e01bad0ca855
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/call_graph.h
@@ -0,0 +1,692 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_CALL_GRAPH_H
+#define MPL2MPL_INCLUDE_CALL_GRAPH_H
+#include "class_hierarchy_phase.h"
+#include "mir_builder.h"
+#include "mir_nodes.h"
+#include "scc.h"
+#include "base_graph_node.h"
+namespace maple {
+enum CallType {
+  kCallTypeInvalid,
+  kCallTypeCall,
+  kCallTypeVirtualCall,
+  kCallTypeSuperCall,
+  kCallTypeInterfaceCall,
+  kCallTypeIcall,
+  kCallTypeIntrinsicCall,
+  kCallTypeXinitrinsicCall,
+  kCallTypeIntrinsicCallWithType,
+  kCallTypeCustomCall,
+  kCallTypePolymorphicCall,
+  kCallTypeFakeThreadStartRun
+};
+
+struct NodeComparator {
+  bool operator()(const MIRFunction *lhs, const MIRFunction *rhs) const {
+    return lhs->GetPuidx() < rhs->GetPuidx();
+  }
+};
+
+#define DEF_IF(code, type, desc) code,
+enum InlineFailedCode {
+#include "inline_failed.def"
+  kIFC_End
+};
+#undef DEF_IF
+
+enum InlineFailedType {
+  kIFT_Mutable,
+  kIFT_FinalFail,
+  kIFT_FinalOk,
+};
+
+const char *GetInlineFailedStr(InlineFailedCode code);
+InlineFailedType GetInlineFailedType(InlineFailedCode code);
+
+struct InlineResult {  // isInlinable result
+  bool canInline = false;
+  std::string reason;
+  bool wantToInline = false;
+
+  InlineResult() = default;
+  InlineResult(bool canInline, const std::string &reason, bool wantToInline = false)
+      : canInline(canInline), reason(reason), wantToInline(wantToInline) {}
+  ~InlineResult() = default;
+};
+
+inline bool IsExternGnuInline(const MIRFunction &func) {
+  return func.IsExtern() && func.GetAttr(FUNCATTR_gnu_inline);
+}
+
+template <typename T>
+struct Comparator {
+  bool operator()(const T *lhs, const T *rhs) const {
+    return lhs->GetID() < rhs->GetID();
+  }
+};
+template <>
+struct Comparator<StmtNode> {
+  bool operator()(const StmtNode *lhs, const StmtNode *rhs) const {
+    return lhs->GetStmtID() < rhs->GetStmtID();
+  }
+};
+
+// Information description of each callsite
+class CallInfo {
+ public:
+  CallInfo(CallType type, MIRFunction *callee, StmtNode *node, uint32 ld, uint32 stmtId, bool local = false)
+      : areAllArgsLocal(local), cType(type), callee(callee), callStmt(node), loopDepth(ld), id(stmtId) {}
+  CallInfo(CallType type, MIRFunction &caller, MIRFunction &callee, StmtNode *node, uint32 ld, uint32 stmtId,
+           bool local = false)
+      : areAllArgsLocal(local),
+        cType(type),
+        caller(&caller),
+        callee(&callee),
+        callStmt(node),
+        loopDepth(ld),
+        id(stmtId) {}
+  // For fake callInfo, only id needed
+  explicit CallInfo(uint32 stmtId) : id(stmtId) {}
+  ~CallInfo() = default;
+
+  uint32 GetID() const {
+    return id;
+  }
+
+  const std::string GetCalleeName() const;
+  CallType GetCallType() const {
+    return cType;
+  }
+
+  uint32 GetLoopDepth() const {
+    return loopDepth;
+  }
+
+  const std::string GetCallTypeName() const;
+  const StmtNode *GetCallStmt() const {
+    return callStmt;
+  }
+  StmtNode *GetCallStmt() {
+    return callStmt;
+  }
+
+  void SetCallStmt(StmtNode *value) {
+    callStmt = value;
+  }
+
+  MIRFunction *GetFunc() {
+    return callee;
+  }
+
+  MIRFunction *GetCaller() const {
+    return caller;
+  }
+
+  MIRFunction *GetCallee() const {
+    return callee;
+  }
+
+  bool AreAllArgsLocal() const {
+    return areAllArgsLocal;
+  }
+
+  void SetAllArgsLocal() {
+    areAllArgsLocal = true;
+  }
+
+  InlineFailedCode GetInlineFailedCode() const {
+    return inlineFailedCode;
+  }
+
+  void SetInlineFailedCode(InlineFailedCode code) {
+    inlineFailedCode = code;
+  }
+
+  void Dump() const;
+
+ private:
+  bool areAllArgsLocal = false;
+  InlineFailedCode inlineFailedCode = kIFC_NeedFurtherAnalysis;
+  CallType cType = kCallTypeInvalid;  // Call type
+  MIRFunction *caller = nullptr;
+  MIRFunction *callee = nullptr;
+  StmtNode *callStmt = nullptr;  // Call statement
+  uint32 loopDepth = 0;
+  uint32 id = 0;
+};
+
+// Node in callgraph
+class CGNode : public BaseGraphNode {
+ public:
+  using CallStmtsType = MapleSet<StmtNode*, Comparator<StmtNode>>;
+
+  void AddNumRefs() {
+    ++numReferences;
+  }
+
+  void DecreaseNumRefs() {
+    --numReferences;
+  }
+
+  uint32 NumReferences() const {
+    return numReferences;
+  }
+
+  CGNode(MIRFunction *func, MapleAllocator &allocater, uint32 index)
+      : BaseGraphNode(index),
+        alloc(&allocater),
+        sccNode(nullptr),
+        mirFunc(func),
+        callees(alloc->Adapter()),
+        vcallCandidates(alloc->Adapter()),
+        isVcallCandidatesValid(false),
+        icallCandidates(alloc->Adapter()),
+        isIcallCandidatesValid(false),
+        numReferences(0),
+        callers(alloc->Adapter()),
+        stmtCount(0),
+        nodeCount(0),
+        mustNotBeInlined(false),
+        vcallCands(alloc->Adapter()) {}
+
+  ~CGNode() override {
+    alloc = nullptr;
+    sccNode = nullptr;
+    mirFunc = nullptr;
+    originBody = nullptr;
+  }
+
+  void Dump(std::ofstream &fout) const;
+  void DumpDetail() const;
+
+  MIRFunction *GetMIRFunction() const {
+    return mirFunc;
+  }
+
+  void AddCallsite(CallInfo&, CGNode*);
+  void AddCallsite(CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*);
+  void RemoveCallsite(const CallInfo*);
+  void RemoveCallsite(uint32);
+
+  uint32 GetInlinedTimes() const {
+    return inlinedTimes;
+  }
+
+  void SetInlinedTimes(uint32 value) {
+    inlinedTimes = value;
+  }
+
+  void IncreaseInlinedTimes() {
+    inlinedTimes += 1;
+  }
+
+  uint32 GetRecursiveLevel() const {
+    return recursiveLevel;
+  }
+
+  void SetRecursiveLevel(uint32 value) {
+    recursiveLevel = value;
+  }
+
+  void IncreaseRecursiveLevel() {
+    recursiveLevel += 1;
+  }
+
+  BlockNode *GetOriginBody() {
+    return originBody;
+  }
+
+  void SetOriginBody(BlockNode *body) {
+    originBody = body;
+  }
+
+  SCCNode<CGNode> *GetSCCNode() {
+    return sccNode;
+  }
+
+  void SetSCCNode(SCCNode<CGNode> *node) {
+    sccNode = node;
+  }
+
+  int32 GetPuIdx() const {
+    return (mirFunc != nullptr) ? static_cast<int32>(mirFunc->GetPuidx()) : -1;  // -1 is invalid idx
+  }
+
+  const std::string &GetMIRFuncName() const {
+    return (mirFunc != nullptr) ? mirFunc->GetName() : GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(0));
+  }
+
+  void AddCandsForCallNode(const KlassHierarchy &kh);
+  void AddVCallCandidate(MIRFunction *func) {
+    vcallCands.push_back(func);
+  }
+
+  bool HasSetVCallCandidates() const {
+    return !vcallCands.empty();
+  }
+
+  MIRFunction *HasOneCandidate() const;
+  const MapleVector<MIRFunction*> &GetVCallCandidates() const {
+    return vcallCands;
+  }
+
+  // add caller to CGNode
+  void AddCaller(CGNode *caller, StmtNode *stmt) {
+    if (callers.find(caller) == callers.end()) {
+      auto *callStmts = alloc->New<CallStmtsType>(alloc->Adapter());
+      callers.emplace(caller, callStmts);
+    }
+    callers[caller]->emplace(stmt);
+  }
+
+  void DelCaller(CGNode * const caller) {
+    if (callers.find(caller) != callers.end()) {
+      callers.erase(caller);
+    }
+  }
+
+  void DelCallee(CallInfo *callInfo, CGNode *callee) {
+    (void)callees[callInfo]->erase(callee);
+  }
+
+  bool HasCaller() const {
+    return (!callers.empty());
+  }
+
+  uint32 NumberOfUses() const {
+    return static_cast<uint32>(callers.size());
+  }
+
+  bool IsCalleeOf(CGNode *func) const;
+  void IncrStmtCount() {
+    ++stmtCount;
+  }
+
+  void IncrNodeCountBy(uint32 x) {
+    nodeCount += x;
+  }
+
+  uint32 GetStmtCount() const {
+    return stmtCount;
+  }
+
+  uint32 GetNodeCount() const {
+    return nodeCount;
+  }
+
+  void Reset() {
+    stmtCount = 0;
+    nodeCount = 0;
+    numReferences = 0;
+    callees.clear();
+    vcallCands.clear();
+  }
+
+  uint32 NumberOfCallSites() const {
+    return static_cast<uint32>(callees.size());
+  }
+
+  const MapleMap<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*, Comparator<CallInfo>> &GetCallee() const {
+    return callees;
+  }
+
+  MapleMap<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*, Comparator<CallInfo>> &GetCallee() {
+    return callees;
+  }
+
+  const MapleMap<CGNode*, CallStmtsType*, Comparator<CGNode>> &GetCaller() const {
+    return callers;
+  }
+
+  MapleMap<CGNode*, CallStmtsType*, Comparator<CGNode>> &GetCaller() {
+    return callers;
+  }
+
+  void GetCaller(std::vector<CallInfo*> &callInfos) {
+    for (auto &pair : callers) {
+      auto *callerNode = pair.first;
+      auto *callStmts = pair.second;
+      for (auto *callStmt : *callStmts) {
+        auto *callInfo = callerNode->GetCallInfo(*callStmt);
+        CHECK_NULL_FATAL(callInfo);
+        callInfos.push_back(callInfo);
+      }
+    }
+  }
+
+  CallInfo *GetCallInfo(StmtNode &stmtNode) {
+    return GetCallInfoByStmtId(stmtNode.GetStmtID());
+  }
+
+  CallInfo *GetCallInfoByStmtId(uint32 stmtId) {
+    for (auto calleeIt = callees.begin(); calleeIt != callees.end(); ++calleeIt) {
+      if ((*calleeIt).first->GetCallStmt()->GetStmtID() == stmtId) {
+        return (*calleeIt).first;
+      }
+    }
+    return nullptr;
+  }
+
+  const SCCNode<CGNode> *GetSCCNode() const {
+    return sccNode;
+  }
+
+  bool IsMustNotBeInlined() const {
+    return mustNotBeInlined;
+  }
+
+  void SetMustNotBeInlined() {
+    mustNotBeInlined = true;
+  }
+
+  bool IsVcallCandidatesValid() const {
+    return isVcallCandidatesValid;
+  }
+
+  void SetVcallCandidatesValid() {
+    isVcallCandidatesValid = true;
+  }
+
+  void AddVcallCandidate(CGNode *item) {
+    (void)vcallCandidates.insert(item);
+  }
+
+  MapleSet<CGNode*, Comparator<CGNode>> &GetVcallCandidates() {
+    return vcallCandidates;
+  }
+
+  bool IsIcallCandidatesValid() const {
+    return isIcallCandidatesValid;
+  }
+
+  void SetIcallCandidatesValid() {
+    isIcallCandidatesValid = true;
+  }
+
+  void AddIcallCandidate(CGNode *item) {
+    (void)icallCandidates.insert(item);
+  }
+
+  MapleSet<CGNode*, Comparator<CGNode>> &GetIcallCandidates() {
+    return icallCandidates;
+  }
+
+  bool IsAddrTaken() const {
+    return addrTaken;
+  }
+
+  void SetAddrTaken() {
+    addrTaken = true;
+  }
+
+  void GetOutNodes(std::vector<BaseGraphNode*> &outNodes) final {
+    for (auto &callSite : std::as_const(GetCallee())) {
+      for (auto &cgIt : *callSite.second) {
+        CGNode *calleeNode = cgIt;
+        outNodes.emplace_back(calleeNode);
+      }
+    }
+  }
+
+  void GetOutNodes(std::vector<BaseGraphNode*> &outNodes) const final {
+    for (auto &callSite : std::as_const(GetCallee())) {
+      for (auto &cgIt : *callSite.second) {
+        CGNode *calleeNode = cgIt;
+        outNodes.emplace_back(calleeNode);
+      }
+    }
+  }
+
+  void GetInNodes(std::vector<BaseGraphNode*> &inNodes) final {
+    for (auto pair : std::as_const(GetCaller())) {
+      CGNode *callerNode = pair.first;
+      inNodes.emplace_back(callerNode);
+    }
+  }
+
+  void GetInNodes(std::vector<BaseGraphNode*> &inNodes) const final {
+    for (auto pair : std::as_const(GetCaller())) {
+      CGNode *callerNode = pair.first;
+      inNodes.emplace_back(callerNode);
+    }
+  }
+
+  const std::string GetIdentity() final {
+    std::string sccIdentity;
+    if (GetMIRFunction() != nullptr) {
+      sccIdentity = "function(" + std::to_string(GetMIRFunction()->GetPuidx()) + "): " + GetMIRFunction()->GetName();
+    } else {
+      sccIdentity = "function: external";
+    }
+    return sccIdentity;
+  }
+  // check frequency
+  uint64_t GetFuncFrequency() const;
+  uint64_t GetCallsiteFrequency(const StmtNode *callstmt) const;
+
+ private:
+  // mirFunc is generated from callStmt's puIdx from mpl instruction
+  // mirFunc will be nullptr if CGNode represents an external/intrinsic call
+  MapleAllocator *alloc;
+  SCCNode<CGNode> *sccNode;  // the id of the scc where this cgnode belongs to
+  MIRFunction *mirFunc;
+  // Each callsite corresponds to one element
+  MapleMap<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*, Comparator<CallInfo>> callees;
+  MapleSet<CGNode*, Comparator<CGNode>> vcallCandidates;  // vcall candidates of mirFunc
+  bool isVcallCandidatesValid;
+  MapleSet<CGNode*, Comparator<CGNode>> icallCandidates;  // icall candidates of mirFunc
+  bool isIcallCandidatesValid;
+  uint32 numReferences;  // The number of the node in this or other CGNode's callees
+  // function candidate for virtual call
+  // now the candidates would be same function name from base class to subclass
+  // with type inference, the candidates would be reduced
+  MapleMap<CGNode*, CallStmtsType*, Comparator<CGNode>> callers;
+  uint32 stmtCount;  // count number of statements in the function, reuse this as callsite id
+  uint32 nodeCount;  // count number of MIR nodes in the function/
+  // this flag is used to mark the function which will read the current method invocation stack or something else,
+  // so it cannot be inlined and all the parent nodes which contain this node should not be inlined, either.
+  bool mustNotBeInlined;
+  MapleVector<MIRFunction*> vcallCands;
+  uint32 inlinedTimes = 0;
+  uint32 recursiveLevel = 0;        // the inlined level when this func is a self-recursive func.
+  BlockNode *originBody = nullptr;  // the originnal body of the func when it's a self-recursive func.
+
+  bool addrTaken = false;  // whether this function is taken address
+};
+
+using Callsite = std::pair<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*>;
+using CalleeIt = MapleMap<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*, Comparator<CallInfo>>::iterator;
+using Caller2Cands = std::pair<PUIdx, Callsite>;
+
+class CallGraph : public AnalysisResult {
+ public:
+  CallGraph(MIRModule &m, MemPool &memPool, MemPool &tempPool, const KlassHierarchy &kh, const std::string &fn);
+  ~CallGraph() = default;
+
+  void InitCallExternal() {
+    callExternal = cgAlloc.GetMemPool()->New<CGNode>(static_cast<MIRFunction*>(nullptr), cgAlloc, numOfNodes++);
+  }
+
+  const CGNode *CallExternal() const {
+    return callExternal;
+  }
+
+  void BuildCallGraph();
+  const CGNode *GetEntryNode() const {
+    return entryNode;
+  }
+
+  const MapleVector<CGNode*> &GetRootNodes() const {
+    return rootNodes;
+  }
+
+  const KlassHierarchy *GetKlassh() const {
+    return klassh;
+  }
+
+  const MapleVector<SCCNode<CGNode>*> &GetSCCTopVec() const {
+    return sccTopologicalVec;
+  }
+
+  const MapleMap<MIRFunction*, CGNode*, NodeComparator> &GetNodesMap() const {
+    return nodesMap;
+  }
+
+  void HandleBody(MIRFunction&, BlockNode&, CGNode&, uint32);
+  void HandleCall(BlockNode&, CGNode&, StmtNode*, uint32);
+  void HandleICall(BlockNode&, CGNode&, StmtNode*, uint32);
+  MIRType *GetFuncTypeFromFuncAddr(const BaseNode*);
+  void RecordLocalConstValue(const StmtNode *stmt);
+  CallNode *ReplaceIcallToCall(BlockNode &body, IcallNode *icall, PUIdx newPUIdx);
+  void CollectAddroffuncFromExpr(const BaseNode *expr);
+  void CollectAddroffuncFromStmt(const StmtNode *stmt);
+  void CollectAddroffuncFromConst(MIRConst *mirConst);
+  void AddCallGraphNode(MIRFunction&);
+  void DumpToFile(bool dumpAll = true) const;
+  void Dump() const;
+  CGNode *GetCGNode(MIRFunction *func) const;
+  CGNode *GetCGNode(PUIdx puIdx) const;
+  void UpdateCaleeCandidate(PUIdx callerPuIdx, const IcallNode *icall, PUIdx calleePuidx, CallNode *call);
+  void UpdateCaleeCandidate(PUIdx callerPuIdx, const IcallNode *icall, std::set<PUIdx> &candidate);
+  SCCNode<CGNode> *GetSCCNode(MIRFunction *func) const;
+  bool IsRootNode(MIRFunction *func) const;
+  void UpdateCallGraphNode(CGNode &node);
+  void RecomputeSCC();
+  CallInfo *AddCallsite(CallType, CGNode&, CGNode&, CallNode&);
+  MIRFunction *CurFunction() const {
+    return mirModule->CurFunction();
+  }
+
+  bool IsInIPA() const {
+    return mirModule->IsInIPA();
+  }
+
+  // iterator
+  using iterator = MapleMap<MIRFunction*, CGNode*>::iterator;
+  using iterator_const = MapleMap<MIRFunction*, CGNode*>::const_iterator;
+  iterator Begin() {
+    return nodesMap.begin();
+  }
+
+  iterator_const CBegin() {
+    return nodesMap.cbegin();
+  }
+
+  iterator End() {
+    return nodesMap.end();
+  }
+
+  iterator_const CEnd() {
+    return nodesMap.cend();
+  }
+
+  MIRFunction *GetMIRFunction(const iterator &it) const {
+    return (*it).first;
+  }
+
+  CGNode *GetCGNode(const iterator &it) const {
+    return (*it).second;
+  }
+
+  void DelNode(CGNode &node);
+  void ClearFunctionList();
+
+  void SetDebugFlag(bool flag) {
+    debugFlag = flag;
+  }
+
+  void GetNodes(std::vector<CGNode*> &nodes) {
+    for (auto &it : std::as_const(nodesMap)) {
+      CGNode *node = it.second;
+      nodes.emplace_back(node);
+    }
+  }
+
+ private:
+  void GenCallGraph();
+  void ReadCallGraphFromMplt();
+  void GenCallGraphFromFunctionBody();
+  void FixIcallCallee();
+  void GetMatchedCGNode(const TyIdx &idx, std::vector<CGNode*> &result);
+
+  CGNode *GetOrGenCGNode(PUIdx puIdx, bool isVcall = false, bool isIcall = false);
+  CallType GetCallType(Opcode op) const;
+  void FindRootNodes();
+  void RemoveFileStaticRootNodes();  // file static and inline but not extern root nodes can be removed
+  void RemoveFileStaticSCC();        // SCC can be removed if it has no caller and all its nodes is file static
+  void SetCompilationFunclist() const;
+  void IncrNodesCount(CGNode *cgNode, BaseNode *bn);
+
+  CallInfo *GenCallInfo(CallType type, MIRFunction *call, StmtNode *s, uint32 loopDepth, uint32 callsiteID) {
+    MIRFunction *caller = mirModule->CurFunction();
+    return cgAlloc.GetMemPool()->New<CallInfo>(type, *caller, *call, s, loopDepth, callsiteID);
+  }
+
+  CallInfo *GenCallInfo(CallType type, MIRFunction &caller, MIRFunction &callee, StmtNode &s) {
+    return cgAlloc.GetMemPool()->New<CallInfo>(type, caller, callee, &s, 0, s.GetStmtID());
+  }
+
+  bool debugFlag = false;
+  MIRModule *mirModule;
+  MapleAllocator cgAlloc;
+  MapleAllocator tempAlloc;
+  MIRBuilder *mirBuilder;
+  CGNode *entryNode;  // For main function, nullptr if there is multiple entries
+  MapleVector<CGNode*> rootNodes;
+  MapleString fileName;  // used for output dot file
+  const KlassHierarchy *klassh;
+  MapleMap<MIRFunction*, CGNode*, NodeComparator> nodesMap;
+  MapleVector<SCCNode<CGNode>*> sccTopologicalVec;
+  MapleMap<StIdx, BaseNode*> localConstValueMap;  // used to record the local constant value
+  MapleMap<TyIdx, MapleSet<Caller2Cands>*> icallToFix;
+  MapleSet<PUIdx> addressTakenPuidxs;
+  CGNode *callExternal = nullptr;  // Auxiliary node used in icall/intrinsic call
+  uint32 numOfNodes;
+  uint32 numOfSccs;
+  std::unordered_set<uint64> callsiteHash;
+};
+
+class IPODevirtulize {
+ public:
+  IPODevirtulize(MIRModule *m, MemPool *memPool, KlassHierarchy *kh)
+      : cgAlloc(memPool), mirBuilder(cgAlloc.GetMemPool()->New<MIRBuilder>(m)), klassh(kh), debugFlag(false) {}
+
+  ~IPODevirtulize() = default;
+  void DevirtualFinal();
+  const KlassHierarchy *GetKlassh() const {
+    return klassh;
+  }
+
+ private:
+  void SearchDefInMemberMethods(const Klass &klass);
+  void SearchDefInClinit(const Klass &klass);
+  MapleAllocator cgAlloc;
+  MIRBuilder *mirBuilder;
+  KlassHierarchy *klassh;
+  bool debugFlag;
+};
+
+MAPLE_MODULE_PHASE_DECLARE_BEGIN(M2MCallGraph)
+CallGraph *GetResult() {
+  return cg;
+}
+CallGraph *cg = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_MODULE_PHASE_DECLARE_END
+MAPLE_MODULE_PHASE_DECLARE(M2MIPODevirtualize)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_CALLGRAPH_H
diff --git a/src/mapleall/mpl2mpl/include/castcheck_whitelist.def b/src/mapleall/mpl2mpl/include/castcheck_whitelist.def
new file mode 100644
index 0000000000000000000000000000000000000000..59ce7a414d41a17c89e96481b58b80f1b68b55cb
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/castcheck_whitelist.def
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CcomputeOomAdjLocked_7C_28Lcom_2Fandroid_2Fserver_2Fam_2FProcessRecord_3BILcom_2Fandroid_2Fserver_2Fam_2FProcessRecord_3BZJ_29I",
+"Ldalvik_2Fsystem_2FBlockGuard_3B_7CgetThreadPolicy_7C_28_29Ldalvik_2Fsystem_2FBlockGuard_24Policy_3B",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPermissionsState_3B_7CgetPermissions_7C_28I_29Ljava_2Futil_2FSet_3B",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CupdateOomAdjLocked_7C_28_29V",
+"Lcom_2Fandroid_2Fserver_2Fcontent_2FContentService_24ObserverNode_3B_7CremoveObserverLocked_7C_28Landroid_2Fdatabase_2FIContentObserver_3B_29Z",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPermissionsState_3B_7ChasPermission_7C_28Ljava_2Flang_2FString_3BI_29Z",
+"Landroid_2Fos_2FParcel_3B_7CreadParcelableCreator_7C_28Ljava_2Flang_2FClassLoader_3B_29Landroid_2Fos_2FParcelable_24Creator_3B",
+"Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_3B_7Cset_7C_28Ljava_2Flang_2FThreadLocal_3BLjava_2Flang_2FObject_3B_29V",
+"Landroid_2Fos_2FParcel_3B_7CreadParcelable_7C_28Ljava_2Flang_2FClassLoader_3B_29Landroid_2Fos_2FParcelable_3B",
+"Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_3B_7CgetEntryAfterMiss_7C_28Ljava_2Flang_2FThreadLocal_3BILjava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B_29Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B",
+"Lcom_2Fandroid_2Fserver_2Fwm_2FWindowContainer_3B_7CforAllWindows_7C_28Lcom_2Fandroid_2Finternal_2Futil_2FToBooleanFunction_3BZ_29Z",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPermissionsState_24PermissionData_3B_7CisGranted_7C_28I_29Z",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7ChasSystemFeature_7C_28Ljava_2Flang_2FString_3BI_29Z",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CgetRunningAppProcesses_7C_28_29Ljava_2Futil_2FList_3B",
+"Lcom_2Fandroid_2Fserver_2Fwm_2FWindowContainer_3B_7CstepAppWindowsAnimation_7C_28J_29V",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FUserManagerService_3B_7CgetUserInfoNoChecks_7C_28I_29Landroid_2Fcontent_2Fpm_2FUserInfo_3B",
+"Landroid_2Fapp_2FActivityManager_3B_7CgetService_7C_28_29Landroid_2Fapp_2FIActivityManager_3B",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FHwPackageManagerService_3B_7CgetCust_7C_28_29Lcom_2Fandroid_2Fserver_2Fpm_2FHwCustPackageManagerService_3B",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CcheckUidPermission_7C_28Ljava_2Flang_2FString_3BI_29I",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActiveServices_3B_7CgetRunningServiceInfoLocked_7C_28IIIZZ_29Ljava_2Futil_2FList_3B",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPermissionsState_24PermissionData_3B_7CgetPermissionState_7C_28I_29Lcom_2Fandroid_2Fserver_2Fpm_2FPermissionsState_24PermissionState_3B",
+"Lcom_2Fxunmeng_2Frouter_2FRealRouter_3B_7CgetFragment_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+"Lcom_2Fandroid_2Fserver_2Fam_2FProcessRecord_3B_7CgetPackageList_7C_28_29ALjava_2Flang_2FString_3B",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CdispatchUidsChanged_7C_28_29V",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CgetLRURecordIndexForAppLocked_7C_28Landroid_2Fapp_2FIApplicationThread_3B_29I",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CgetRecordForAppLocked_7C_28Landroid_2Fapp_2FIApplicationThread_3B_29Lcom_2Fandroid_2Fserver_2Fam_2FProcessRecord_3B",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityDisplay_3B_7CgetChildAt_7C_28I_29Lcom_2Fandroid_2Fserver_2Fam_2FActivityStack_3B",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityStack_3B_7CgetRunningTasks_7C_28Ljava_2Futil_2FList_3BIIIZ_29V",
+"Lcom_2Fandroid_2Fserver_2Fam_2FRunningTasks_3B_7CgetTasks_7C_28ILjava_2Futil_2FList_3BIILandroid_2Futil_2FSparseArray_3BIZ_29V",
+"Lcom_2Fandroid_2Fserver_2Fam_2FTaskRecord_3B_7CgetTopActivity_7C_28Z_29Lcom_2Fandroid_2Fserver_2Fam_2FActivityRecord_3B",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CgetInstalledApplications_7C_28II_29Landroid_2Fcontent_2Fpm_2FParceledListSlice_3B",
+"Lcom_2Fandroid_2Fserver_2Fwm_2FWindowContainer_3B_7CisSelfOrChildAnimating_7C_28_29Z",
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPackageSettingBase_3B_7CreadUserState_7C_28I_29Landroid_2Fcontent_2Fpm_2FPackageUserState_3B",
+"Lcom_2Fandroid_2Fserver_2Fpm_2Fpermission_2FPermissionsState_3B_7ChasPermission_7C_28Ljava_2Flang_2FString_3BI_29Z",
+"Lcom_2Fandroid_2Fserver_2Fpm_2Fpermission_2FPermissionsState_24PermissionData_3B_7CisGranted_7C_28I_29Z",
+"Lcom_2Fandroid_2Fserver_2Fdisplay_2FBackLightMonitorManager_3B_7CisParamOwner_7C_28Ljava_2Flang_2FString_3B_29Z",
+"Lcom_2Fandroid_2Fserver_2Fwm_2FWindowContainer_3B_7CgetChildAt_7C_28I_29Lcom_2Fandroid_2Fserver_2Fwm_2FWindowContainer_3B",
+"Lcom_2Fandroid_2Fserver_2Fwm_2FWindowContainer_3B_7CcheckCompleteDeferredRemoval_7C_28_29Z",
+"Lcom_2Fandroid_2Fserver_2Fwm_2FWindowContainer_3B_7CprepareSurfaces_7C_28_29V",
+"Lcom_2Fandroid_2Fserver_2Fwm_2FWindowContainer_3B_7CisAppAnimating_7C_28_29Z",
+"Landroid_2Fcontent_2Fpm_2FParceledListSlice_3B_7CwriteElement_7C_28Ljava_2Flang_2FObject_3BLandroid_2Fos_2FParcel_3BI_29V",
+"Landroid_2Fcontent_2Fpm_2FParceledListSlice_3B_7CwriteParcelableCreator_7C_28Ljava_2Flang_2FObject_3BLandroid_2Fos_2FParcel_3B_29V",
+"Landroid_2Fcontent_2Fpm_2FPackageParser_3B_7CgeneratePackageInfo_7C_28Landroid_2Fcontent_2Fpm_2FPackageParser_24Package_3BAIIJJLjava_2Futil_2FSet_3BLandroid_2Fcontent_2Fpm_2FPackageUserState_3BI_29Landroid_2Fcontent_2Fpm_2FPackageInfo_3B",
+"Landroid_2Fos_2FParcel_3B_7CwriteTypedList_7C_28Ljava_2Futil_2FList_3BI_29V",
+"Lcom_2Fandroid_2Fserver_2Fsecurity_2Fsecurityprofile_2FPolicyEngine_3B_7CfindRulesAndEvaluate_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3BLjava_2Flang_2FString_3BLjava_2Flang_2FString_3BLjava_2Flang_2FString_3BZI_29Z",
+"Lcom_2Fandroid_2Fserver_2Fsecurity_2Fsecurityprofile_2FSecurityProfileControllerImpl_3B_7CshouldPreventInteraction_7C_28ILjava_2Flang_2FString_3BIILjava_2Flang_2FString_3BI_29Z",
+"Lcom_2Fandroid_2Finternal_2Fos_2FBinderCallsStats_3B_7CcallStarted_7C_28Landroid_2Fos_2FBinder_3BI_29Lcom_2Fandroid_2Finternal_2Fos_2FBinderCallsStats_24CallSession_3B",
+
+"Lcom_2Fandroid_2Fserver_2Fcontent_2FContentService_3B_7CregisterContentObserver_7C_28Landroid_2Fnet_2FUri_3BZLandroid_2Fdatabase_2FIContentObserver_3BII_29V",
+"Lcom_2Fandroid_2Fserver_2Fam_2FActivityManagerService_3B_7CcomputeOomAdjLocked_7C_28Lcom_2Fandroid_2Fserver_2Fam_2FProcessRecord_3BILcom_2Fandroid_2Fserver_2Fam_2FProcessRecord_3BZJ_29Z",
+"Lcom_2Fandroid_2Fserver_2Fcontent_2FContentService_3B_7CnotifyChange_7C_28Landroid_2Fnet_2FUri_3BLandroid_2Fdatabase_2FIContentObserver_3BZIII_29V",
+"Lcom_2Fandroid_2Fserver_2Fcontent_2FContentService_24ObserverNode_3B_7CaddObserverLocked_7C_28Landroid_2Fnet_2FUri_3BILandroid_2Fdatabase_2FIContentObserver_3BZLjava_2Flang_2FObject_3BIII_29V",
+
+"Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_3B_7CgetUidTargetSdkVersionLockedLPr_7C_28I_29I",
diff --git a/src/mapleall/mpl2mpl/include/class_hierarchy.h b/src/mapleall/mpl2mpl/include/class_hierarchy.h
new file mode 100644
index 0000000000000000000000000000000000000000..97d6d64450e5690d488d153576f4d872957ac58e
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/class_hierarchy.h
@@ -0,0 +1,414 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_CLASS_HIERARCHY_H
+#define MPL2MPL_INCLUDE_CLASS_HIERARCHY_H
+#include "mir_function.h"
+#include "maple_phase.h"
+
+namespace maple {
+class KlassHierarchy;  // circular dependency exists, no other choice
+// should be consistent with runtime
+constexpr uint32 kClassPrim = 0x0001;
+constexpr uint32 kClassArray = 0x0002;
+constexpr uint32 kClassHasFinalizer = 0x0004;
+constexpr uint32 kClassSoftreference = 0x0008;
+constexpr uint32 kClassWeakreference = 0x0010;
+constexpr uint32 kClassPhantomreference = 0x0020;
+constexpr uint32 kClassFinalizereference = 0x0040;
+constexpr uint32 kClassCleaner = 0x0080;
+constexpr uint32 kClassFinalizerreferenceSentinel = 0x0100;
+constexpr uint32 kClassIsExceptionKlass = 0x0200;
+constexpr uint32 kClassIsanonymousclass = 0x0400;
+constexpr uint32 kClassIscoldclass = 0x0800;
+constexpr uint32 kClassNeedDecouple = 0x1000;
+constexpr uint32 kClassLazyBindingClass = 0x2000;
+constexpr uint32 kClassLazyBoundClass = 0x4000; // Only used in runtime, occupancy.
+constexpr uint32 kClassRuntimeVerify = 0x8000; // True if need verifier in runtime (error or deferred check).
+constexpr char kJavaLangNoMethodStr[] = "Ljava_2Flang_2FNoSuchMethodException_3B";
+constexpr uint32 kClassReference = (kClassSoftreference | kClassWeakreference | kClassCleaner |
+                                    kClassFinalizereference | kClassPhantomreference);
+
+bool IsSystemPreloadedClass(const std::string &className);
+
+// Klass is the basic node for building class hierarchy
+class Klass {
+ public:
+  struct KlassComparator {
+    bool operator()(const Klass *lhs, const Klass *rhs) const {
+      CHECK_NULL_FATAL(rhs);
+      CHECK_NULL_FATAL(lhs);
+      return lhs->GetKlassName() < rhs->GetKlassName();
+    }
+  };
+
+  Klass(MIRStructType *type, MapleAllocator *alc);
+  ~Klass() = default;
+
+  // Return true if Klass represents an interface
+  bool IsInterface() const {
+    return structType->GetKind() == kTypeInterface;
+  }
+
+  bool IsInterfaceIncomplete() const {
+    return structType->GetKind() == kTypeInterfaceIncomplete;
+  }
+
+  // Return true if Klass represents a normal java class
+  bool IsClass() const {
+    return structType->GetKind() == kTypeClass;
+  }
+
+  bool IsClassIncomplete() const {
+    return structType->GetKind() == kTypeClassIncomplete;
+  }
+
+  // Return true if found in the member methods
+  bool IsKlassMethod(const MIRFunction *func) const;
+  // Return MIRFunction if has method
+  const MIRFunction *HasMethod(const std::string &funcname) const;
+  const MapleList<MIRFunction*> &GetMethods() const {
+    return methods;
+  }
+
+  const MIRFunction *GetMethod(GStrIdx idx) const {
+    MapleMap<GStrIdx, MIRFunction*>::const_iterator it = strIdx2Method.find(idx);
+    return it != strIdx2Method.end() ? it->second : nullptr;
+  }
+  GStrIdx GetKlassNameStrIdx() const {
+    return structType->GetNameStrIdx();
+  }
+
+  const std::string &GetKlassName() const {
+    return structType->GetName();
+  }
+
+  TyIdx GetTypeIdx() const {
+    return structType->GetTypeIndex();
+  }
+
+  MIRStructType *GetMIRStructType() const {
+    return structType;
+  }
+
+  MIRClassType *GetMIRClassType() const {
+    CHECK_FATAL(IsClass() || IsClassIncomplete(), "must");
+    return static_cast<MIRClassType*>(structType);
+  }
+
+  MIRInterfaceType *GetMIRInterfaceType() const {
+    CHECK_FATAL(IsInterface() || IsInterfaceIncomplete(), "must be");
+    return static_cast<MIRInterfaceType*>(structType);
+  }
+
+  bool HasSuperKlass() const {
+    return !superKlasses.empty();
+  }
+
+  bool HasSubKlass() const {
+    return !subKlasses.empty();
+  }
+
+  bool HasImplementInterfaces() const {
+    return !implInterfaces.empty();
+  }
+
+  bool ImplementsKlass() const;
+  void SetFlag(uint32 flag) {
+    flags |= flag;
+  }
+
+  uint32 GetFlag(uint32 flag) const {
+    return flags & flag;
+  }
+
+  bool HasFlag(uint32 flag) const {
+    return GetFlag(flag) != 0;
+  }
+
+  bool IsExceptionKlass() const {
+    return HasFlag(kClassIsExceptionKlass);
+  }
+
+  void SetExceptionKlass() {
+    SetFlag(kClassIsExceptionKlass);
+  }
+
+  bool HasFinalizer() const {
+    return HasFlag(kClassHasFinalizer);
+  }
+
+  void SetHasFinalizer() {
+    SetFlag(kClassHasFinalizer);
+  }
+
+  bool HasNativeMethod() const {
+    return hasNativeMethods;
+  }
+
+  void SetHasNativeMethod(bool flag) {
+    hasNativeMethods = flag;
+  }
+
+  bool IsReference(uint32 flag) const {
+    return HasFlag(flag);
+  }
+
+  bool IsReference() const {
+    return HasFlag(kClassReference);
+  }
+
+  bool IsArray() const {
+    return (structType->GetName().find(JARRAY_PREFIX_STR) == 0);
+  }
+
+  bool IsPrivateInnerAndNoSubClass() const {
+    return isPrivateInnerAndNoSubClassFlag;
+  }
+
+  void SetPrivateInnerAndNoSubClass(bool flag) {
+    isPrivateInnerAndNoSubClassFlag = flag;
+  }
+
+  bool GetNeedDecoupling() const {
+    return needDecoupling;
+  }
+
+  void SetNeedDecoupling(bool flag) {
+    needDecoupling = flag;
+  }
+
+  const MIRFunction *GetClinit() const {
+    return clinitMethod;
+  }
+  void SetClinit(MIRFunction *m) {
+    clinitMethod = m;
+  }
+
+  MIRSymbol *GetClassInitBridge() const {
+    return classInitBridge;
+  }
+
+  void SetClassInitBridge(MIRSymbol *s) {
+    classInitBridge = s;
+  }
+
+  // Return the function defined in the current class, or the inherited
+  // function if it is not defined in the current class.
+  MIRFunction *GetClosestMethod(GStrIdx) const;
+  // This for class only, which only has 0 or 1 super class
+  Klass *GetSuperKlass() const;
+  const MapleList<Klass*> &GetSuperKlasses() const {
+    return superKlasses;
+  }
+
+  const MapleSet<Klass*, KlassComparator> &GetSubKlasses() const {
+    return subKlasses;
+  }
+
+  const MapleSet<Klass*, KlassComparator> &GetImplKlasses() const {
+    return implKlasses;
+  }
+
+  const MapleSet<Klass*, KlassComparator> &GetImplInterfaces() const {
+    return implInterfaces;
+  }
+
+  // Return a vector of possible functions
+  MapleVector<MIRFunction*> *GetCandidates(GStrIdx mnameNoklassStrIdx) const;
+  // Return the unique method if there is only one target virtual function.
+  // Return nullptr if there are multiple targets.
+  MIRFunction *GetUniqueMethod(GStrIdx mnameNoklassStrIdx) const;
+  void AddSuperKlass(Klass *superclass) {
+    superKlasses.push_back(superclass);
+  }
+
+  void AddSubKlass(Klass *subclass) {
+    subKlasses.insert(subclass);
+  }
+
+  void AddImplKlass(Klass *implclass) {
+    implKlasses.insert(implclass);
+  }
+
+  void AddImplInterface(Klass *interfaceKlass) {
+    implInterfaces.insert(interfaceKlass);
+  }
+
+  void AddMethod(MIRFunction &func) {
+    methods.push_front(&func);
+    strIdx2Method.insert({ func.GetBaseFuncNameWithTypeStrIdx(), &func });
+  }
+
+  void DelMethod(const MIRFunction &func);
+  // Collect the virtual methods from parent class and interfaces
+  void CountVirtMethTopDown(const KlassHierarchy &kh);
+  // Count the virtual methods for subclasses and merge with itself
+  void CountVirtMethBottomUp();
+  void Dump() const;
+
+ private:
+  void DumpKlassImplInterfaces() const;
+  void DumpKlassImplKlasses() const;
+  void DumpKlassSuperKlasses() const;
+  void DumpKlassSubKlasses() const;
+  void DumpKlassMethods() const;
+  bool IsVirtualMethod(const MIRFunction &func) const;
+  // structType can be class or interface
+  MIRStructType *structType;
+  MapleAllocator *alloc;
+  // A collection of super classes.
+  // superklass is nullptr if it is not defined in the module.
+  MapleList<Klass*> superKlasses;
+  // A collection of sub classes
+  MapleSet<Klass*, KlassComparator> subKlasses;
+  // a collection of classes which implement the current interface
+  MapleSet<Klass*, KlassComparator> implKlasses;
+  // a collection of interfaces which is implemented by the current klass
+  MapleSet<Klass*, KlassComparator> implInterfaces;
+  // A collection of class member methods
+  MapleList<MIRFunction*> methods;
+  // A mapping to track every method to its baseFuncNameWithType
+  MapleMap<GStrIdx, MIRFunction*> strIdx2Method;
+  MIRFunction *clinitMethod = nullptr;
+  MIRSymbol *classInitBridge = nullptr;
+  // A mapping to track possible implementations for each virtual function
+  MapleMap<GStrIdx, MapleVector<MIRFunction*>*> strIdx2CandidateMap;
+  // flags of this class.
+  // Now contains whether this class is exception, reference or has finalizer.
+  uint32 flags = 0;
+  bool isPrivateInnerAndNoSubClassFlag = false;
+  bool hasNativeMethods = false;
+  bool needDecoupling = true;
+};
+
+// Some well known types like java.lang.Object. They may be commonly referenced.
+// j - java
+// jl - java lang
+// jlr - java lang reflect
+class WKTypes {
+ public:
+  class Util {
+   public:
+    static bool MayRefString(const BaseNode &n, MIRType &type);
+    static bool MayRefMeta(const BaseNode &n, MIRType &type);
+    static bool MayNotRefCyclicly(const BaseNode &n, MIRType &type);
+    static MIRType *GetJavaLangObjectType() {
+      return javaLangObject;
+    }
+
+   private:
+    static bool NotCyclicType(MIRType &type, std::set<MIRType*> &workList);
+  };
+  static void Init();
+
+ private:
+  static MIRType *javaLangObject;
+  static MIRType *javaLangString;
+  static MIRType *javaLangObjectSerializable;
+  static MIRType *javaLangComparable;
+  static MIRType *javaLangCharSequence;
+  static MIRType *javaLangClass;
+  static MIRType *javaLangRefGenericDeclaration;
+  static MIRType *javaLangRefAnnotatedElement;
+  static MIRType *javaLangRefType;
+  static MIRType *javaLangRefMethod;
+  static MIRType *javaLangRefExecutable;
+  static MIRType *javaLangRefAccessibleObject;
+  static MIRType *javaLangRefMember;
+  static MIRType *javaLangRefField;
+  static MIRType *javaLangRefConstructor;
+};
+
+// data structure to represent class information defined in the module
+class KlassHierarchy : public AnalysisResult {
+ public:
+  KlassHierarchy(MIRModule *mirmodule, MemPool *memPool);
+  virtual ~KlassHierarchy() = default;
+
+  // Get a class. Return nullptr it does not exist.
+  Klass *GetKlassFromStrIdx(GStrIdx strIdx) const;
+  Klass *GetKlassFromTyIdx(TyIdx tyIdx) const;
+  Klass *GetKlassFromFunc(const MIRFunction *func) const;
+  Klass *GetKlassFromName(const std::string &name) const;
+  Klass *GetKlassFromLiteral(const std::string &name) const;
+  const MapleMap<GStrIdx, Klass*> &GetKlasses() const {
+    return strIdx2KlassMap;
+  }
+
+  // Get lowest common ancestor for two classes
+  Klass *GetLCA(Klass *klass1, Klass *klass2) const;
+  TyIdx GetLCA(TyIdx ty1, TyIdx ty2) const;
+  GStrIdx GetLCA(GStrIdx str1, GStrIdx str2) const;
+  const std::string &GetLCA(const std::string &name1, const std::string &name2) const;
+  // 1/0/-1: true/false/unknown
+  int IsSuperKlass(TyIdx superTyIdx, TyIdx baseTyIdx) const;
+  bool IsSuperKlass(const Klass *super, const Klass *base) const;
+  bool IsSuperKlassForInterface(const Klass *super, const Klass *base) const;
+  bool IsInterfaceImplemented(Klass *interface, const Klass *base) const;
+  bool UpdateFieldID(TyIdx baseTypeIdx, TyIdx targetTypeIdx, FieldID &fldID) const;
+  // return true if class, its super or interfaces have at least one clinit function
+  bool NeedClinitCheckRecursively(const Klass &kl) const;
+
+  void CountVirtualMethods() const;
+  void BuildHierarchy();
+  void Dump() const;
+
+  const MapleVector<Klass*> &GetTopoSortedKlasses() const {
+    return topoWorkList;
+  }
+
+  const MIRModule *GetModule() const {
+    return mirModule;
+  }
+  static bool traceFlag;
+ private:
+  // New all klass
+  void AddKlasses();
+  // Add superklass/subclass edge and class methods for each class
+  void AddKlassRelationAndMethods();
+  void TagThrowableKlasses();
+  // Connect all class<->interface edges based on Depth-First Search
+  void UpdateImplementedInterfaces();
+  // Get a vector of parent class and implementing interface
+  void GetParentKlasses(const Klass &klass, std::vector<Klass*> &parentKlasses) const;
+  // Get a vector of child class and implemented class
+  void GetChildKlasses(const Klass &klass, std::vector<Klass*> &childKlasses) const;
+  void ExceptionFlagProp(Klass &klass);
+  Klass *AddClassFlag(const std::string &name, uint32 flag);
+  int GetFieldIDOffsetBetweenClasses(const Klass &super, const Klass &base) const;
+  void TopologicalSortKlasses();
+  void MarkClassFlags();
+  // Return the unique method if there is only one target virtual function.
+  // Return 0 if there are multiple targets or the targets are unclear.
+  GStrIdx GetUniqueMethod(GStrIdx) const;
+  bool IsDevirtualListEmpty() const;
+  void DumpDevirtualList(const std::string &outputFileName) const;
+  void ReadDevirtualList(const std::string &inputFileName);
+  MapleAllocator alloc;
+  MIRModule *mirModule;
+  // Map from class name to klass. Use name as the key because the type
+  // information is incomplete, e.g.
+  // method to class link, e.g.
+  //    class A { void foo(); void bar(); }
+  //    class B extends A { void foo(); }
+  //    In this case, there is no link from B.bar to B in the maple file.
+  MapleMap<GStrIdx, Klass*> strIdx2KlassMap;
+  // Map from a virtual method name to its corresponding real method name
+  // This is used for devirtualization and has to be built with a closed-world view
+  MapleMap<GStrIdx, GStrIdx> vfunc2RfuncMap;
+  MapleVector<Klass*> topoWorkList;
+};
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_CLASS_HIERARCHY_H
diff --git a/src/mapleall/mpl2mpl/include/class_hierarchy_phase.h b/src/mapleall/mpl2mpl/include/class_hierarchy_phase.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab4f9470dc87edb242b3a6dc60a3d2aea9dcca01
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/class_hierarchy_phase.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_CLASS_HIERARCHY_PHASE_H
+#define MPL2MPL_INCLUDE_CLASS_HIERARCHY_PHASE_H
+#include "class_hierarchy.h"
+#include "maple_phase.h"
+
+namespace maple {
+MAPLE_MODULE_PHASE_DECLARE_BEGIN(M2MKlassHierarchy)
+  KlassHierarchy *GetResult() {
+    return kh;
+  }
+  KlassHierarchy *kh = nullptr;
+MAPLE_MODULE_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_CLASS_HIERARCHY_H
+
diff --git a/src/mapleall/mpl2mpl/include/class_init.h b/src/mapleall/mpl2mpl/include/class_init.h
new file mode 100644
index 0000000000000000000000000000000000000000..a40800d3a24f657e5ade18cab811bab82c356153
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/class_init.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_CLASS_INIT_H
+#define MPL2MPL_INCLUDE_CLASS_INIT_H
+#include "phase_impl.h"
+#include "class_hierarchy_phase.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+class ClassInit : public FuncOptimizeImpl {
+ public:
+  ClassInit(MIRModule &mod, KlassHierarchy *kh, bool dump) : FuncOptimizeImpl(mod, kh, dump) {}
+  ~ClassInit() = default;
+
+  FuncOptimizeImpl *Clone() override {
+    return new ClassInit(*this);
+  }
+
+  void ProcessFunc(MIRFunction *func) override;
+
+ private:
+  void GenClassInitCheckProfile(MIRFunction &func, const MIRSymbol &classInfo, StmtNode *clinit) const;
+  void GenPreClassInitCheck(MIRFunction &func, const MIRSymbol &classInfo, const StmtNode *clinit) const;
+  void GenPostClassInitCheck(MIRFunction &func, const MIRSymbol &classInfo, const StmtNode *clinit) const;
+  MIRSymbol *GetClassInfo(const std::string &classname);
+  bool CanRemoveClinitCheck(const std::string &clinitClassname) const;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MClassInit)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_CLASS_INIT_H
diff --git a/src/mapleall/mpl2mpl/include/clone.h b/src/mapleall/mpl2mpl/include/clone.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c28b8e103333e1c04dd078ab89e718474df6226
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/clone.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_CLONE_H
+#define MPL2MPL_INCLUDE_CLONE_H
+#include "mir_module.h"
+#include "mir_function.h"
+#include "mir_builder.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "class_hierarchy_phase.h"
+#include "me_ir.h"
+#include "maple_phase_manager.h"
+
+static constexpr char kFullNameStr[] = "INFO_fullname";
+static constexpr char kClassNameStr[] = "INFO_classname";
+static constexpr char kFuncNameStr[] = "INFO_funcname";
+static constexpr char kVoidRetSuffix[] = "CLONEDignoreret";
+namespace maple {
+class ReplaceRetIgnored {
+ public:
+  explicit ReplaceRetIgnored(MemPool *memPool);
+  ~ReplaceRetIgnored() = default;
+
+  bool ShouldReplaceWithVoidFunc(const CallMeStmt &stmt, const MIRFunction &calleeFunc) const;
+  std::string GenerateNewBaseName(const MIRFunction &originalFunc) const;
+  std::string GenerateNewFullName(const MIRFunction &originalFunc) const;
+  const MapleSet<MapleString> *GetTobeClonedFuncNames() const {
+    return &toBeClonedFuncNames;
+  }
+
+  bool IsInCloneList(const std::string &funcName) const {
+    return toBeClonedFuncNames.find(MapleString(funcName, memPool)) != toBeClonedFuncNames.end();
+  }
+
+  static bool IsClonedFunc(const std::string &funcName) {
+    return funcName.find(kVoidRetSuffix) != std::string::npos;
+  }
+
+ private:
+  MemPool *memPool;
+  maple::MapleAllocator allocator;
+  MapleSet<MapleString> toBeClonedFuncNames;
+  bool RealShouldReplaceWithVoidFunc(Opcode op, size_t nRetSize, const MIRFunction &calleeFunc) const;
+};
+
+class Clone : public AnalysisResult {
+ public:
+  Clone(MIRModule *mod, MemPool *memPool, MIRBuilder &builder, KlassHierarchy *kh)
+      : AnalysisResult(memPool), mirModule(mod), allocator(memPool), mirBuilder(builder), kh(kh),
+        replaceRetIgnored(memPool->New<ReplaceRetIgnored>(memPool)) {}
+
+  ~Clone() = default;
+
+  static MIRSymbol *CloneLocalSymbol(const MIRSymbol &oldSym, const MIRFunction &newFunc);
+  static void CloneSymbols(MIRFunction &newFunc, const MIRFunction &oldFunc);
+  static void CloneLabels(MIRFunction &newFunc, const MIRFunction &oldFunc);
+  MIRFunction *CloneFunction(MIRFunction &originalFunction, const std::string &newBaseFuncName,
+      MIRType *returnType = nullptr) const;
+  MIRFunction *CloneFunctionNoReturn(MIRFunction &originalFunction);
+  void DoClone();
+  void CopyFuncInfo(MIRFunction &originalFunction, MIRFunction &newFunc) const;
+  void UpdateFuncInfo(MIRFunction &newFunc);
+  void CloneArgument(MIRFunction &originalFunction, ArgVector &argument) const;
+  const ReplaceRetIgnored *GetReplaceRetIgnored() const {
+    return replaceRetIgnored;
+  }
+
+  void UpdateReturnVoidIfPossible(CallMeStmt *callMeStmt, const MIRFunction &targetFunc);
+
+ private:
+  MIRModule *mirModule;
+  MapleAllocator allocator;
+  MIRBuilder &mirBuilder;
+  KlassHierarchy *kh;
+  ReplaceRetIgnored *replaceRetIgnored;
+};
+
+MAPLE_MODULE_PHASE_DECLARE_BEGIN(M2MClone)
+  Clone *GetResult() {
+    return cl;
+  }
+  Clone *cl = nullptr;
+OVERRIDE_DEPENDENCE
+MAPLE_MODULE_PHASE_DECLARE_END
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_CLONE_H
diff --git a/src/mapleall/mpl2mpl/include/coderelayout.h b/src/mapleall/mpl2mpl/include/coderelayout.h
new file mode 100644
index 0000000000000000000000000000000000000000..32416f797940972b0a4966781cbcea82816cbce6
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/coderelayout.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_CODERELAYOUT_H
+#define MPL2MPL_INCLUDE_CODERELAYOUT_H
+#include <fstream>
+#include "phase_impl.h"
+#include "file_layout.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+class CodeReLayout : public FuncOptimizeImpl {
+ public:
+  CodeReLayout(MIRModule &mod, KlassHierarchy *kh, bool dump);
+  ~CodeReLayout() = default;
+
+  FuncOptimizeImpl *Clone() override {
+    return new CodeReLayout(*this);
+  }
+
+  void ProcessFunc(MIRFunction *func) override;
+  void Finish() override;
+
+ private:
+  std::string StaticFieldFilename(const std::string &mplFile) const;
+  void GenLayoutSym();
+  void AddStaticFieldRecord();
+  CallNode *CreateRecordFieldStaticCall(BaseNode *node, const std::string &name);
+  void FindDreadRecur(const StmtNode *stmt, BaseNode *node);
+  void InsertProfileBeforeDread(const StmtNode *stmt, BaseNode *opnd);
+  MIRSymbol *GetorCreateStaticFieldSym(const std::string &fieldName);
+  MIRSymbol *GenStrSym(const std::string &str);
+  std::unordered_map<std::string, MIRSymbol*> str2SymMap;
+  uint32 layoutCount[static_cast<uint32>(LayoutType::kLayoutTypeCount)] = {};
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MCodeReLayout)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_CODERELAYOUT_H
diff --git a/src/mapleall/mpl2mpl/include/constantfold.h b/src/mapleall/mpl2mpl/include/constantfold.h
new file mode 100644
index 0000000000000000000000000000000000000000..75cce8e08cdf4916433d0462e7f1f9bcaa84d2d0
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/constantfold.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_CONSTANTFOLD_H
+#define MPL2MPL_INCLUDE_CONSTANTFOLD_H
+#include "mir_nodes.h"
+#include "phase_impl.h"
+#include "me_verify.h"
+
+#include <optional>
+
+namespace maple {
+class ConstantFold : public FuncOptimizeImpl {
+ public:
+  struct CFConfig {
+    bool expandIaddrof;
+  };
+
+  ConstantFold(MIRModule &mod, KlassHierarchy *kh, bool trace)
+      : FuncOptimizeImpl(mod, kh, trace), mirModule(&mod), cfc({false}) {}
+
+  explicit ConstantFold(MIRModule &mod, CFConfig conf = { false })
+      : FuncOptimizeImpl(mod, nullptr, false), mirModule(&mod), cfc(conf) {}
+
+  // Fold an expression.
+  // It returns a new expression if there was something to fold, or
+  // nullptr otherwise.
+  BaseNode *Fold(BaseNode *node);
+
+  // Simplify a statement
+  // It returns the original statement or the changed statement if a
+  // simplification happened. If the statement can be deleted after a
+  // simplification, it returns nullptr.
+  StmtNode *Simplify(StmtNode *node);
+  StmtNode *SimplifyIassignWithAddrofBaseNode(IassignNode &node, const AddrofNode &base);
+
+  FuncOptimizeImpl *Clone() override {
+    return new ConstantFold(*this);
+  }
+
+  void ProcessFunc(MIRFunction *func) override;
+  ~ConstantFold() override {
+    mirModule = nullptr;
+  }
+
+  template <class T> T CalIntValueFromFloatValue(T value, const MIRType &resultType) const;
+  MIRConst *FoldFloorMIRConst(const MIRConst&, PrimType, PrimType, bool isFloor = true) const;
+  MIRConst *FoldRoundMIRConst(const MIRConst&, PrimType, PrimType) const;
+  MIRConst *FoldTypeCvtMIRConst(const MIRConst&, PrimType, PrimType) const;
+  MIRConst *FoldSignExtendMIRConst(Opcode, PrimType, uint8, const IntVal&) const;
+  static MIRConst *FoldIntConstBinaryMIRConst(Opcode opcode, PrimType resultType, const MIRIntConst *intConst0,
+                                              const MIRIntConst *intConst1);
+  MIRConst *FoldConstComparisonMIRConst(Opcode, PrimType, PrimType, const MIRConst&, const MIRConst&);
+  static bool IntegerOpIsOverflow(Opcode op, PrimType primType, int64 cstA, int64 cstB);
+  static MIRIntConst *FoldIntConstUnaryMIRConst(Opcode opcode, PrimType resultType, const MIRIntConst *constNode);
+
+  static MeExpr *FoldCmpExpr(IRMap &irMap, const MeExpr &cmp1, const MeExpr &cmp2, bool isAnd);
+  static MeExpr *FoldOrOfAnds(IRMap &irMap, const MeExpr &and1, const MeExpr &and2);
+ private:
+  StmtNode *SimplifyBinary(BinaryStmtNode *node);
+  StmtNode *SimplifyBlock(BlockNode *node);
+  StmtNode *SimplifyCondGoto(CondGotoNode *node);
+  StmtNode *SimplifyCondGotoSelect(CondGotoNode *node) const;
+  StmtNode *SimplifyDassign(DassignNode *node);
+  StmtNode *SimplifyIassignWithIaddrofBaseNode(IassignNode &node, const IaddrofNode &base);
+  StmtNode *SimplifyIassign(IassignNode *node);
+  StmtNode *SimplifyNary(NaryStmtNode *node);
+  StmtNode *SimplifyIcall(IcallNode *node);
+  StmtNode *SimplifyIf(IfStmtNode *node);
+  StmtNode *SimplifySwitch(SwitchNode *node);
+  StmtNode *SimplifyUnary(UnaryStmtNode *node);
+  StmtNode *SimplifyAsm(AsmNode* node);
+  StmtNode *SimplifyWhile(WhileStmtNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldArray(ArrayNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldBase(BaseNode *node) const;
+  std::pair<BaseNode*, std::optional<IntVal>> FoldBinary(BinaryNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldCompare(CompareNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldDepositbits(DepositbitsNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldExtractbits(ExtractbitsNode *node);
+  ConstvalNode *FoldSignExtend(Opcode opcode, PrimType resultType, uint8 size, const ConstvalNode &cst) const;
+  std::pair<BaseNode*, std::optional<IntVal>> FoldIread(IreadNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldSizeoftype(SizeoftypeNode *node) const;
+  std::pair<BaseNode*, std::optional<IntVal>> FoldRetype(RetypeNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldGcmallocjarray(JarrayMallocNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldUnary(UnaryNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldTernary(TernaryNode *node);
+  std::pair<BaseNode*, std::optional<IntVal>> FoldTypeCvt(TypeCvtNode *node);
+  ConstvalNode *FoldCeil(const ConstvalNode &cst, PrimType fromType, PrimType toType) const;
+  ConstvalNode *FoldFloor(const ConstvalNode &cst, PrimType fromType, PrimType toType) const;
+  ConstvalNode *FoldRound(const ConstvalNode &cst, PrimType fromType, PrimType toType) const;
+  ConstvalNode *FoldTrunk(const ConstvalNode &cst, PrimType fromType, PrimType toType) const;
+  ConstvalNode *FoldTypeCvt(const ConstvalNode &cst, PrimType fromType, PrimType toType) const;
+  ConstvalNode *FoldConstComparison(Opcode opcode, PrimType resultType, PrimType opndType, const ConstvalNode &const0,
+                                    const ConstvalNode &const1) const;
+  ConstvalNode *FoldConstBinary(Opcode opcode, PrimType resultType, const ConstvalNode &const0,
+                                const ConstvalNode &const1) const;
+  ConstvalNode *FoldIntConstComparison(Opcode opcode, PrimType resultType, PrimType opndType,
+                                       const ConstvalNode &const0, const ConstvalNode &const1) const;
+  MIRIntConst *FoldIntConstComparisonMIRConst(Opcode, PrimType, PrimType, const MIRIntConst&,
+                                              const MIRIntConst&) const;
+  ConstvalNode *FoldIntConstBinary(Opcode opcode, PrimType resultType, const ConstvalNode &const0,
+                                   const ConstvalNode &const1) const;
+  ConstvalNode *FoldFPConstComparison(Opcode opcode, PrimType resultType, PrimType opndType, const ConstvalNode &const0,
+                                      const ConstvalNode &const1) const;
+  bool ConstValueEqual(int64 leftValue, int64 rightValue) const;
+  bool ConstValueEqual(float leftValue, float rightValue) const;
+  bool ConstValueEqual(double leftValue, double rightValue) const;
+  template<typename T>
+  bool FullyEqual(T leftValue, T rightValue) const;
+  template<typename T>
+  int64 ComparisonResult(Opcode op, T *leftConst, T *rightConst) const;
+  MIRIntConst *FoldFPConstComparisonMIRConst(Opcode opcode, PrimType resultType, PrimType opndType,
+                                             const MIRConst &leftConst, const MIRConst &rightConst) const;
+  ConstvalNode *FoldFPConstBinary(Opcode opcode, PrimType resultType, const ConstvalNode &const0,
+                                  const ConstvalNode &const1) const;
+  ConstvalNode *FoldConstUnary(Opcode opcode, PrimType resultType, ConstvalNode &constNode) const;
+  template <typename T>
+  ConstvalNode *FoldFPConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *constNode) const;
+  BaseNode *NegateTree(BaseNode *node) const;
+  BaseNode *Negate(BaseNode *node) const;
+  BaseNode *Negate(UnaryNode *node) const;
+  BaseNode *Negate(const ConstvalNode *node) const;
+  BinaryNode *NewBinaryNode(BinaryNode *old, Opcode op, PrimType primeType, BaseNode *lhs, BaseNode *rhs) const;
+  UnaryNode *NewUnaryNode(UnaryNode *old, Opcode op, PrimType primeType, BaseNode *expr) const;
+  std::pair<BaseNode*, std::optional<IntVal>> DispatchFold(BaseNode *node);
+  BaseNode *PairToExpr(PrimType resultType, const std::pair<BaseNode*, std::optional<IntVal>> &pair) const;
+  BaseNode *SimplifyDoubleCompare(CompareNode &node) const;
+  CompareNode *FoldConstComparisonReverse(Opcode opcode, PrimType resultType, PrimType opndType,
+                                          BaseNode &l, BaseNode &r);
+  MIRModule *mirModule;
+  CFConfig cfc;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MConstantFold)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_CONSTANTFOLD_H
diff --git a/src/mapleall/mpl2mpl/include/ext_constantfold.h b/src/mapleall/mpl2mpl/include/ext_constantfold.h
new file mode 100644
index 0000000000000000000000000000000000000000..bdaf517cb421ae35b565c7fa557b15c9dae8eb3b
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/ext_constantfold.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_EXTCONSTANTFOLD_H
+#define MPL2MPL_INCLUDE_EXTCONSTANTFOLD_H
+#include "mir_nodes.h"
+#include "phase_impl.h"
+
+namespace maple {
+class ExtConstantFold {
+ public:
+  explicit ExtConstantFold(MIRModule *mod) : mirModule(mod) {}
+  BaseNode *ExtFoldUnary(UnaryNode *node);
+  BaseNode *ExtFoldBinary(BinaryNode *node);
+  BaseNode* ExtFoldTernary(TernaryNode *node);
+  StmtNode *ExtSimplify(StmtNode *node);
+  BaseNode *ExtFold(BaseNode *node);
+  BaseNode *ExtFoldIor(BinaryNode *node);
+  BaseNode *ExtFoldXand(BinaryNode *node);
+  StmtNode *ExtSimplifyBlock(BlockNode *node);
+  StmtNode *ExtSimplifyIf(IfStmtNode *node);
+  StmtNode *ExtSimplifyDassign(DassignNode *node);
+  StmtNode *ExtSimplifyIassign(IassignNode *node);
+  StmtNode *ExtSimplifyWhile(WhileStmtNode *node);
+  BaseNode* DispatchFold(BaseNode *node);
+
+  MIRModule *mirModule;
+};
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_EXTCONSTANTFOLD_H
diff --git a/src/mapleall/mpl2mpl/include/gen_check_cast.h b/src/mapleall/mpl2mpl/include/gen_check_cast.h
new file mode 100644
index 0000000000000000000000000000000000000000..1894a97da221ebdafcdcad81bbf497be5b7f247d
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/gen_check_cast.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_GEN_CHECK_CAST_H
+#define MPL2MPL_INCLUDE_GEN_CHECK_CAST_H
+#include "class_hierarchy.h"
+#include "me_option.h"
+#include "phase_impl.h"
+#include "maple_phase_manager.h"
+#include "annotation_analysis.h"
+
+namespace maple {
+class PreCheckCast : public FuncOptimizeImpl {
+ public:
+  PreCheckCast(MIRModule &mod, KlassHierarchy *kh, bool dump);
+  ~PreCheckCast() override = default;
+  FuncOptimizeImpl *Clone() override {
+    return new PreCheckCast(*this);
+  }
+
+  void ProcessFunc(MIRFunction *func) override;
+};
+
+class CheckCastGenerator : public FuncOptimizeImpl {
+ public:
+  CheckCastGenerator(MIRModule &mod, KlassHierarchy *kh, bool dump);
+  ~CheckCastGenerator() override {
+    pointerObjType = nullptr;
+    pointerClassMetaType = nullptr;
+    classinfoType = nullptr;
+    throwCastException = nullptr;
+    checkCastingNoArray = nullptr;
+    checkCastingArray = nullptr;
+    mccIsAssignableFrom = nullptr;
+    castExceptionFunc = nullptr;
+  }
+
+  FuncOptimizeImpl *Clone() override {
+    return new CheckCastGenerator(*this);
+  }
+
+  void ProcessFunc(MIRFunction *func) override;
+
+ private:
+  void InitTypes();
+  void InitFuncs();
+  void GenAllCheckCast();
+  void GenCheckCast(StmtNode &stmt);
+  BaseNode *GetObjectShadow(BaseNode *opnd);
+  MIRSymbol *GetOrCreateClassInfoSymbol(const std::string &className);
+  void GenAllCheckCast(bool isHotFunc);
+  void OptimizeInstanceof();
+  void OptimizeIsAssignableFrom();
+  void CheckIsAssignableFrom(BlockNode &blockNode, StmtNode &stmt, const IntrinsicopNode &intrinsicNode);
+  void ConvertCheckCastToIsAssignableFrom(StmtNode &stmt);
+  void AssignedCastValue(StmtNode &stmt);
+  void ConvertInstanceofToIsAssignableFrom(StmtNode &stmt, const IntrinsicopNode &intrinsicNode);
+  void ReplaceNoSubClassIsAssignableFrom(BlockNode &blockNode, StmtNode &stmt, const MIRPtrType &ptrType,
+                                         const IntrinsicopNode &intrinsicNode);
+  void ReplaceIsAssignableFromUsingCache(BlockNode &blockNode, StmtNode &stmt, const MIRPtrType &targetClassType,
+                                         const IntrinsicopNode &intrinsicNode);
+  bool IsDefinedConstClass(const StmtNode &stmt, const MIRPtrType &targetClassType,
+                           PregIdx &classSymPregIdx, MIRSymbol *&classSym);
+  MIRType *pointerObjType = nullptr;
+  MIRType *pointerClassMetaType = nullptr;
+  MIRType *classinfoType = nullptr;
+  MIRFunction *throwCastException = nullptr;
+  MIRFunction *checkCastingNoArray = nullptr;
+  MIRFunction *checkCastingArray = nullptr;
+  const std::unordered_set<std::string> funcWithoutCastCheck{
+#include "castcheck_whitelist.def"
+  };
+  MIRFunction *mccIsAssignableFrom = nullptr;
+  MIRFunction *castExceptionFunc = nullptr;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MCheckCastGeneration)
+MAPLE_MODULE_PHASE_DECLARE(M2MPreCheckCast)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_GEN_CHECK_CAST_H
diff --git a/src/mapleall/mpl2mpl/include/gen_profile.h b/src/mapleall/mpl2mpl/include/gen_profile.h
new file mode 100644
index 0000000000000000000000000000000000000000..954d5a54207b6e8acbd7d7d3a64dc1f4d503e6e1
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/gen_profile.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_MPL2MPL_INCLUDE_PROFILEGEN_H
+#define MAPLE_MPL2MPL_INCLUDE_PROFILEGEN_H
+#include <algorithm>
+#include "module_phase_manager.h"
+#include "me_pgo_instrument.h"
+#include "bb.h"
+#include "me_irmap.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+static constexpr const uint32_t kMplModProfMergeFuncs = 9;  // gcov reserves 9 slots
+static constexpr const uint32_t kGCCVersion = 0x4137352A;   // gcc v7.5 under tools
+// static constexpr const uint32_t kGCCVersion = 0x4139342A; // GCC V9.3/9.4
+// anything other than merge_add will be supported supported in future
+static constexpr const uint32_t kMplFuncProfCtrInfoNum = 1;
+
+class ProfileGenPM : public SccPM {
+ public:
+  explicit ProfileGenPM(MemPool *memPool) : SccPM(memPool, &id) {}
+  bool PhaseRun(MIRModule &m) override;
+  PHASECONSTRUCTOR(ProfileGenPM);
+  ~ProfileGenPM() override {}
+  std::string PhaseName() const override;
+ private:
+  void GetAnalysisDependence(AnalysisDep &aDep) const override;
+};
+
+class ProfileGen {
+ public:
+  explicit ProfileGen(MIRModule &module) : mod(module) {
+    for (MIRFunction *f : std::as_const(mod.GetFunctionList())) {
+      if (!f->IsEmpty()) { validFuncs.push_back(f); }
+    }
+  }
+
+  std::string FlatenName(const std::string &name) const {
+    std::string filteredName = name;
+    std::replace(filteredName.begin(), filteredName.end(), '.', '_');
+    std::replace(filteredName.begin(), filteredName.end(), '-', '_');
+    std::replace(filteredName.begin(), filteredName.end(), '/', '_');
+    return filteredName;
+  }
+
+  void CreateModProfDesc();
+  void CreateFuncProfDesc();
+  void CreateFuncProfDescTbl();
+  void FixupDesc();
+  void CreateInitProc();
+  void CreateExitProc();
+  void GenFuncCtrTbl();
+  void Run();
+  std::vector<MIRFunction *> getValidFuncs() { return validFuncs; }
+
+ private:
+    MIRModule &mod;
+    MIRSymbol *modProfDesc = nullptr;
+    // Keep order of funcs visited
+    MIRSymbol *funcProfDescTbl = nullptr;
+    std::vector<MIRSymbol *> funcProfDescs;
+    std::vector<MIRFunction *> validFuncs;
+};
+}  // namespace maple
+#endif  // MAPLE_MPL2MPL_INCLUDE_PROFILEGEN_H
diff --git a/src/mapleall/mpl2mpl/include/ginline.h b/src/mapleall/mpl2mpl/include/ginline.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ff7479c586559d23b1776f21bb5ab862b8db3ac
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/ginline.h
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_GINLINE_H
+#define MPL2MPL_INCLUDE_GINLINE_H
+#include <queue>
+#include <vector>
+
+#include "call_graph.h"
+#include "inline_analyzer.h"
+#include "inline_transformer.h"
+#include "maple_phase_manager.h"
+#include "me_option.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_builder.h"
+#include "mir_function.h"
+#include "mir_parser.h"
+#include "opcode_info.h"
+#include "string_utils.h"
+#include "inline_summary.h"
+
+namespace maple {
+class CallSiteNode {
+ public:
+  CallSiteNode(CallInfo &info, BadnessInfo &badnessInfo, uint32 inlineDepth)
+      : callInfo(&info), badInfo(badnessInfo), depth(inlineDepth) {}
+
+  auto *GetCallInfo() const {
+    return callInfo;
+  }
+
+  const BadnessInfo &GetBadInfo() const {
+    return badInfo;
+  }
+
+  double GetBadness() const {
+    return badInfo.badness;
+  }
+
+  uint32 GetDepth() const {
+    return depth;
+  }
+
+  int32 GetGrowth() const {
+    return badInfo.growth;
+  }
+
+  double GetCallFreqPercent() const {
+    return badInfo.freqPercent;
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << "[" << depth << "] ";
+    callInfo->Dump();
+    LogInfo::MapleLogger() << " ";
+    badInfo.Dump();
+  }
+
+  void DumpBrief() const {
+    // lineno col caller callee callerId calleeId badInfo
+    const auto &srcPos = callInfo->GetCallStmt()->GetSrcPos();
+    auto lineno = srcPos.LineNum();
+    auto col = srcPos.Column();
+    auto *caller = callInfo->GetCaller();
+    auto *callee = callInfo->GetCallee();
+    LogInfo::MapleLogger() << callInfo->GetID() << "\t" << lineno << "\t" << col << "\t" << caller->GetName() << "\t"
+        << callee->GetName() << "\t" << caller->GetPuidx() << "\t" << callee->GetPuidx() << "\t";
+    badInfo.DumpWithoutKey();
+  }
+
+ private:
+  CallInfo *callInfo;
+  const BadnessInfo &badInfo;
+  uint32 depth = 0;  // ginline callsite depth, default depth is 0
+};
+
+struct CallSiteNodeCmp {
+  bool operator()(const CallSiteNode *lhs, const CallSiteNode *rhs) const {
+    if (std::equal_to<double>()(lhs->GetBadness(), rhs->GetBadness())) {
+      return lhs->GetCallInfo()->GetID() < rhs->GetCallInfo()->GetID();
+    }
+    return lhs->GetBadness() < rhs->GetBadness();
+  }
+};
+
+class GInline {
+ public:
+  GInline(MIRModule &mod, MemPool *memPool, CallGraph *cg = nullptr)
+      : alloc(memPool), module(mod), builder(*mod.GetMIRBuilder()), callSiteSet(alloc.Adapter()), cg(cg),
+        funcsToBeRemoved(alloc.Adapter()), inlineStat(kIFC_End, 0, alloc.Adapter()) {
+    Init();
+  };
+
+  ~GInline() {
+    CleanupInline();
+  }
+
+  void Inline();
+
+ protected:
+  MapleAllocator alloc;
+  MIRModule &module;
+  MIRBuilder &builder;
+  MapleSet<CallSiteNode*, CallSiteNodeCmp> callSiteSet;
+  CallGraph *cg;
+
+ private:
+  void Init();
+  void CleanupInline();
+  void InitParams();
+  void PrepareCallsiteSet();
+  void AfterInlineSuccess(const CallSiteNode &heapNode, const std::vector<CallInfo*> &newCallInfo, bool canBeRemoved,
+      int64 lastSize);
+  void InlineCallsiteSet();
+  bool FuncInlinable(const MIRFunction&) const;
+  bool IsSafeToInline(const MIRFunction*, const CallNode&) const;
+
+  void TryInlineToAllCallers();
+  void TryInlineToAllCallers(const CGNode &calleeNode);
+  bool ConsiderInlineCallsite(CallInfo &info, uint32 depth);
+  void AddNewEdge(const std::vector<CallInfo*> &newCallInfo, uint32 depth);
+  MapleSet<CallSiteNode*, CallSiteNodeCmp>::iterator FindCallsiteInSet(uint32 callId) const;
+  void UpdateCaller(CGNode &callerNode);
+  int64 ComputeTotalSize() const;
+  int64 ComputeMaxSize(bool enableMoreGrowthForSmallModule) const;
+  int64 GetFunctionStaticInsns(MIRFunction &func) const;
+  BadnessInfo *CalcBadness(CallInfo &info);
+  void InsertNewCallSite(CallInfo &info, uint32 depth);
+  void UpdateCallSite(CallInfo &info);
+  bool CanIgnoreGrowthLimit(const CallSiteNode &callSiteNode);
+  void PrintGInlineReport() const;
+
+  MapleSet<MIRFunction*> funcsToBeRemoved;
+  MapleVector<uint32> inlineStat;  // index is InlineFailedCode, value is count
+  uint32 totalSuccessCnt = 0;
+  int64 initSize = 0;  // the initial size of the module.
+  int64 curSize = 0;   // current size of the module.
+  int64 finalSize = 0; // the final size after ginline.
+  int64 maxSize = 0;   // the maximal size that this module can reach when doing inline.
+  bool dumpDetail = false;
+  std::string dumpFunc = "";
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MGInline)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_GINLINE_H
diff --git a/src/mapleall/mpl2mpl/include/inline.h b/src/mapleall/mpl2mpl/include/inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..efb4433dac98974f7fe399112c8a2bf1e96fe996
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/inline.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_INLINE_H
+#define MPL2MPL_INCLUDE_INLINE_H
+#include "call_graph.h"
+#include "inline_transformer.h"
+#include "maple_phase_manager.h"
+#include "me_option.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_builder.h"
+#include "mir_function.h"
+#include "mir_parser.h"
+#include "opcode_info.h"
+#include "string_utils.h"
+
+namespace maple {
+
+enum FuncCostResultType {
+  kNotAllowedNode,
+  kFuncBodyTooBig,
+  kSmallFuncBody
+};
+
+enum ThresholdType {
+  kSmallFuncThreshold,
+  kHotFuncThreshold,
+  kRecursiveFuncThreshold,
+  kHotAndRecursiveFuncThreshold
+};
+
+class MInline {
+ public:
+  MInline(MIRModule &mod, MemPool *memPool, CallGraph *cg = nullptr)
+      : alloc(memPool),
+        module(mod),
+        builder(*mod.GetMIRBuilder()),
+        funcToCostMap(alloc.Adapter()),
+        cg(cg),
+        performEarlyInline(Options::enableGInline && module.GetSrcLang() == kSrcLangC) {
+    Init();
+  };
+
+  virtual ~MInline() {
+    CleanupInline();
+    cg = nullptr;
+  }
+
+  void Inline();
+
+ protected:
+  MapleAllocator alloc;
+  MIRModule &module;
+  MIRBuilder &builder;
+  // save the cost of calculated func to reduce the amount of calculation
+  MapleMap<MIRFunction*, uint32> funcToCostMap;
+  CallGraph *cg;
+
+ private:
+  void Init();
+  void InitParams();
+  void InitProfile() const;
+  void CleanupInline();
+  FuncCostResultType GetFuncCost(const MIRFunction&, const BaseNode&, uint32&, uint32) const;
+  bool IsHotCallSite(const MIRFunction &caller, const MIRFunction &callee, const CallNode &callStmt) const;
+  InlineResult AnalyzeCallee(const MIRFunction &caller, MIRFunction &callee, const CallNode &callStmt);
+  void AdjustInlineThreshold(const MIRFunction &caller, MIRFunction &callee, const CallNode &callStmt,
+      uint32 &threshold, uint32 &thresholdType);
+  bool IsSmallCalleeForEarlyInline(MIRFunction &callee, int32 *outInsns);
+  virtual bool CanInline(CGNode*, std::unordered_map<MIRFunction*, bool>&) {
+    return false;
+  }
+
+  bool CheckCalleeAndInline(MIRFunction*, BlockNode *enclosingBlk, CallNode*, MIRFunction*);
+  bool SuitableForTailCallOpt(BaseNode &enclosingBlk, const StmtNode &stmtNode, CallNode &callStmt);
+  bool CalleeReturnValueCheck(StmtNode &stmtNode, CallNode &callStmt);
+  void InlineCalls(CGNode&);
+  void PostInline(MIRFunction&);
+  void InlineCallsBlock(MIRFunction&, BlockNode&, BaseNode&, bool&, BaseNode&);
+  void InlineCallsBlockInternal(MIRFunction &func, BaseNode &baseNode, bool &changed);
+  GotoNode *UpdateReturnStmts(const MIRFunction&, BlockNode&, LabelIdx, const CallReturnVector&, int&) const;
+  void ComputeTotalSize();
+  void MarkSymbolUsed(const StIdx&) const;
+  void MarkUsedSymbols(const BaseNode*) const;
+  void MarkFunctionUsed(MIRFunction *func, bool inlined = false) const;
+  void MarkUnInlinableFunction() const;
+  bool HasAccessStatic(const BaseNode&) const;
+  uint64 totalSize = 0;
+  bool dumpDetail = false;
+  std::string dumpFunc = "";
+  uint32 smallFuncThreshold = 0;
+  uint32 hotFuncThreshold = 0;
+  uint32 recursiveFuncThreshold = 0;
+  bool inlineWithProfile = false;
+  const bool performEarlyInline;  // open it only if ginline is enabled and srcLang is C
+  uint32 maxRecursiveLevel = 4;  // for recursive function, allow inline 4 levels at most.
+  uint32 currInlineDepth = 0;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MInline)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_INLINE_H
diff --git a/src/mapleall/mpl2mpl/include/inline_analyzer.h b/src/mapleall/mpl2mpl/include/inline_analyzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc1cf8b86fbdc9c9f2971fc70461ed62ca17070d
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/inline_analyzer.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_INLINE_ANALYZER_H
+#define MPL2MPL_INCLUDE_INLINE_ANALYZER_H
+#include "call_graph.h"
+#include "maple_phase_manager.h"
+#include "me_ir.h"
+#include "me_option.h"
+#include "inline_summary.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_builder.h"
+#include "mir_function.h"
+#include "mir_parser.h"
+#include "opcode_info.h"
+#include "string_utils.h"
+
+namespace maple {
+bool CalleeCanBeRemovedIfInlined(const CallInfo &info, const CallGraph &cg);
+bool CanCGNodeBeRemovedIfNoDirectCalls(const CGNode &cgNode);
+bool ShouldBeInlinedToAllCallers(const CGNode &calleeCgNode, std::vector<CallInfo*> &callInfos, const CallGraph &cg);
+std::pair<bool, int32> EstimateGrowthIfInlinedToAllCallers(const CGNode &calleeCgNode, const CallGraph &cg,
+    std::vector<CallInfo*> *callInfos);
+bool IsFuncForbiddenToCopy(const MIRFunction &func);
+std::optional<uint32> GetFuncSize(const MIRFunction &func);
+double GetCallFreqPercent(const CallInfo &info);
+
+// All kinds of information related to callsite badness calculation
+struct BadnessInfo {
+  double origBadness = 0;
+  double badness = 0;
+  double freqPercent = 0;
+  NumInsns growth = 0;
+  NumCycles time = 0;
+  NumCycles uninlinedTime = 0;
+  NumCycles inlinedTime = 0;
+  NumInsns overallGrowth = 0;
+
+  double GetSpeedup() const {
+    return (uninlinedTime - inlinedTime) / uninlinedTime;
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << "obadness: " << origBadness << ", badness: " << badness << ", freq: " << freqPercent <<
+        ", growth: " << growth << ", time: " << time << ", utime: " << uninlinedTime <<
+        ", itime: " << inlinedTime << ", ogrowth: " << overallGrowth << ", speedup: " << GetSpeedup();
+  }
+
+  void DumpWithoutKey() const {
+    LogInfo::MapleLogger() << origBadness << "\t" << badness << "\t" << freqPercent << "\t" << growth <<
+        "\t" << time << "\t" << uninlinedTime << "\t" << inlinedTime << "\t" << overallGrowth << "\t" <<
+        GetSpeedup() << std::endl;
+  }
+};
+
+bool IgnoreNonDeclaredInlineSizeGrow(CallInfo &callInfo, const CallGraph &cg, const BadnessInfo *inputBadInfo);
+void CalcBadnessImpl(CallInfo &info, const CallGraph &cg, BadnessInfo &outBadInfo);
+
+// key: caller-callee pair, value: sampling cnt
+using CallsiteProfile = std::map<std::pair<GStrIdx, GStrIdx>, uint32>;
+
+enum CallsiteProfileType {
+  kCallsiteProfileNone,
+  kCallsiteProfileNormal,
+  kCallsiteProfileHot,
+  kCallsiteProfileCold
+};
+
+class InlineListInfo {
+ public:
+  static void Prepare();
+  static void Clear();
+  static bool IsValid();
+  static const std::map<GStrIdx, std::set<GStrIdx>*> &GetInlineList();
+  static const std::map<GStrIdx, std::set<GStrIdx>*> &GetNoInlineList();
+  static const CallsiteProfile &GetCallsiteProfile();
+  static const std::set<GStrIdx> &GetHardCodedCallees();
+  static const std::set<GStrIdx> &GetExcludedCallers();
+  static const std::set<GStrIdx> &GetExcludedCallees();
+  static const std::set<GStrIdx> &GetRCWhiteList();
+
+ private:
+  static void ApplyInlineListInfo(const std::string &path, std::map<GStrIdx, std::set<GStrIdx>*> &list);
+  static void ReadCallsiteProfile(const std::string &path, CallsiteProfile &callsiteProfile);
+  static bool valid;
+  static std::map<GStrIdx, std::set<GStrIdx>*> inlineList;
+  static std::map<GStrIdx, std::set<GStrIdx>*> noInlineList;
+  static CallsiteProfile callsiteProfile;
+  static std::set<GStrIdx> hardCodedCallees;
+  static std::set<GStrIdx> excludedCallers;
+  static std::set<GStrIdx> excludedCallees;
+  static std::set<GStrIdx> rcWhiteList;
+};
+
+class InlineAnalyzer {
+ public:
+  static bool CanInline(CallInfo &callInfo, const CallGraph &cg, uint32 depth);
+  static std::pair<bool, InlineFailedCode> CanInlineImpl(std::pair<const MIRFunction*, MIRFunction*> callPair,
+      const CallNode &callStmt, const CallGraph &cg, uint32 depth, bool earlyInline);
+  static bool WantInline(CallInfo &callInfo, const CallGraph &cg, uint32 depth);
+  static std::pair<bool, InlineFailedCode> WantInlineImpl(CallInfo &callInfo, const CallGraph &cg, uint32 depth);
+ private:
+  static bool FuncInlinable(const MIRFunction&);
+  static bool SizeWillGrow(const CGNode &calleeNode, const CallGraph &cg);
+  static bool IsSafeToInline(const MIRFunction &callee, const CallNode &callStmt);
+};
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_INLINE_ANALYZER_H
diff --git a/src/mapleall/mpl2mpl/include/inline_failed.def b/src/mapleall/mpl2mpl/include/inline_failed.def
new file mode 100644
index 0000000000000000000000000000000000000000..41be29a42443f6dd3a602a2120facf803efd2282
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/inline_failed.def
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+// (code, type, desc)
+// final ok
+// we should mark kIFT_FinalOk carefully, because it will ignore most size limits
+DEF_IF(kIFC_Ok, kIFT_FinalOk, "[ok] normally inlined")
+
+DEF_IF(kIFC_DeclaredExternInline, kIFT_FinalOk, "[ok] callee is declared 'extern inline'")
+
+DEF_IF(kIFC_DeclaredAlwaysInline, kIFT_FinalOk, "[ok] callee is declared 'always_inline'")
+
+DEF_IF(kIFC_HardCoded, kIFT_FinalOk, "[ok] callee is hard coded to be inlined")
+
+DEF_IF(kIFC_InlineList, kIFT_FinalOk, "[ok] callee is in the inline list")
+
+DEF_IF(kIFC_InlineListCallsite, kIFT_FinalOk, "[ok] callsite is in the inline list")
+
+DEF_IF(kIFC_ProfileHotCallsite, kIFT_FinalOk, "[ok] profile shows this is a hot callsite")
+
+DEF_IF(kIFC_ExternGnuInlineCalleeDepth0, kIFT_FinalOk, "[ok] depth == 0 'extern gnu_inline' should always be inlined")
+
+// mutate
+DEF_IF(kIFC_NeedFurtherAnalysis, kIFT_Mutable, "need further analysis")
+
+DEF_IF(kIFC_NotDeclaredInlineTooBig, kIFT_Mutable, "callee is not declared 'inline' and callee size is too big")
+
+DEF_IF(kIFC_NotDeclaredInlineGrow, kIFT_Mutable, "callee is not declared 'inline' and size will grow")
+
+DEF_IF(kIFC_UnlikelyCall, kIFT_Mutable, "unlikely callsite")
+
+DEF_IF(kIFC_OutOfEarlyInline, kIFT_Mutable, "early inlining is not responsible for it")
+
+DEF_IF(kIFC_OutOfGreedyInline, kIFT_Mutable, "greedy inlining is not responsible for it")
+
+// final fail
+DEF_IF(kIFC_EmptyCallee, kIFT_FinalFail, "callee's body is not available")
+
+DEF_IF(kIFC_ProfileColdCallsite, kIFT_FinalFail, "profile shows this is a cold callsite")
+
+DEF_IF(kIFC_Unsafe, kIFT_FinalFail, "unsafe inline")
+
+DEF_IF(kIFC_UnsafeRegion, kIFT_FinalFail, "callee is unsafe but callStmt is in safe region")
+
+DEF_IF(kIFC_DeclaredNoinline, kIFT_FinalFail, "callee is declared 'noinline'")
+
+DEF_IF(kIFC_ExcludedCaller, kIFT_FinalFail, "caller is in the excluded list")
+
+DEF_IF(kIFC_ExcludedCallee, kIFT_FinalFail, "callee is in the excluded list")
+
+DEF_IF(kIFC_MCCFunc, kIFT_FinalFail, "callee is MCC runtime func")
+
+DEF_IF(kIFC_RCUnsafe, kIFT_FinalFail, "RC unsafe")
+
+DEF_IF(kIFC_Attr, kIFT_FinalFail, "callee has uninlinable attributes")
+
+DEF_IF(kIFC_ArgToFormalError, kIFT_FinalFail, "incompatible type conversion from arguments to formals")
+
+DEF_IF(kIFC_SetjmpCallee, kIFT_FinalFail, "callee is setjmp")
+
+DEF_IF(kIFC_SetjmpInCallee, kIFT_FinalFail, "callee contains setjmp call")
+
+DEF_IF(kIFC_AddrTakenLabel, kIFT_FinalFail, "callee has address taken labels")
+
+// mark uninlinable such as recursive level too much, VMStack
+DEF_IF(kIFC_MarkUninlinable, kIFT_FinalFail, "callee was marked uninlinable")
+
+DEF_IF(kIFC_GinlineRecursiveCall, kIFT_FinalFail, "resursive inlining has not been supported by ginline")
+
+DEF_IF(kIFC_TooBigForEInline, kIFT_FinalFail, "callee is too big for early inline")
+
+DEF_IF(kIFC_TooBigForGInline, kIFT_FinalFail, "callee is too big for greedy inline")
+
+DEF_IF(kIFC_NoinlineList, kIFT_FinalFail, "callee is in the noinline list")
+
+DEF_IF(kIFC_NoinlineListCallsite, kIFT_FinalFail, "callsite is in the noinline list")
+
+DEF_IF(kIFC_IndirectCall, kIFT_FinalFail, "inlining indirect call is not supported")
+
+DEF_IF(kIFC_NotInCallgraph, kIFT_FinalFail, "callee is not in the callgraph")
+
+DEF_IF(kIFC_ExternGnuInlineCaller, kIFT_FinalFail, "caller is declared 'extern gnu_inline'")
+
+DEF_IF(kIFC_ExternGnuInlineCalleeDepthN, kIFT_FinalFail, "depth >= 1 'extern gnu_inline' should not be inlined")
+
+DEF_IF(kIFC_Outlined, kIFT_FinalFail, "outlined func will not be inlined any more")
+
+DEF_IF(kIFC_PreventedBySameHotCall, kIFT_FinalFail, "same callsites with hot freq have been inlined")
+
+DEF_IF(kIFC_PreventedBySPS, kIFT_FinalFail, "callsite is prevented from inlining by --stack-protector-strong")
+
diff --git a/src/mapleall/mpl2mpl/include/inline_mplt.h b/src/mapleall/mpl2mpl/include/inline_mplt.h
new file mode 100644
index 0000000000000000000000000000000000000000..372c65922c32b24e0d6fb2c04ac35679f840942e
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/inline_mplt.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INLINE_MPLT_H
+#define MPL2MPL_INLINE_MPLT_H
+#include "types_def.h"
+#include "mir_type.h"
+#include "mir_symbol.h"
+#include "mir_module.h"
+#include "mir_function.h"
+
+namespace maple {
+class InlineMplt {
+ public:
+  explicit InlineMplt(MIRModule &module) : mirModule(module) {}
+  virtual ~InlineMplt() = default;
+
+  // level: the max level that we export static function.
+  // 1 means that if a small global function invokes a static leaf function
+  // or a static function which never invoke other static fucntions, we will export this static function too.
+  bool CollectInlineInfo(uint32 inlineSize, uint32 level = 1);
+  bool Forbidden(BaseNode *node, const std::pair<uint32, uint32> &inlineConditions,
+                 std::vector<MIRFunction*> &staticFuncs, std::set<uint32_t> &globalSymbols);
+  void CollectStructOrUnionTypes(const MIRType *baseType);
+  void GetElememtTypesFromDerivedType(const MIRType *baseType, std::set<const MIRType*> &elementTypes);
+  void CollectTypesForOptimizedFunctions();
+  void CollectTypesForInliningGlobals();
+  void CollectTypesForSingleFunction(const MIRFunction &func);
+  void CollectTypesForGlobalVar(const MIRSymbol &globalSymbol);
+  void DumpInlineCandidateToFile(const std::string &fileNameStr);
+  void DumpOptimizedFunctionTypes();
+  uint32 GetFunctionSize(MIRFunction &mirFunc);
+
+ private:
+  std::set<MIRFunction*> optimizedFuncs;
+  std::set<TyIdx> optimizedFuncsType;
+  std::set<uint32_t> inliningGlobals;
+  MIRModule &mirModule;
+};
+} // namespace maple
+#endif // MPL2MPL_INLINE_MPLT_H
\ No newline at end of file
diff --git a/src/mapleall/mpl2mpl/include/inline_summary.h b/src/mapleall/mpl2mpl/include/inline_summary.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ef7f7786979cc280e9c006006189738f9f1841d
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/inline_summary.h
@@ -0,0 +1,995 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_MPL2MPL_INCLUDE_INLINE_SUMMARY_H
+#define MAPLE_MPL2MPL_INCLUDE_INLINE_SUMMARY_H
+#include "me_function.h"
+#include "cast_opt.h"
+#include "stmt_cost_analyzer.h"
+#include "me_loop_analysis.h"
+#include "me_predict.h"
+
+#include <optional>
+
+namespace maple {
+enum ExprKind : uint32 {
+  kExprKindParam = 0x01,        // expr is a unmodified parameter
+  kExprKindConst = 0x02,        // expr is a constant
+  kExprKindConstNumber = 0x04,  // expr is a constant with number type (integer, float or double)
+                                // a kExprKindConstNumber must be a kExprKindConst
+};
+
+enum ExprBoolResult {
+  kExprResUnknown,
+  kExprResTrue,
+  kExprResFalse
+};
+
+constexpr double kColdFreqPercent = 0.01;
+constexpr int32 kCallFreqBase = 1000;
+constexpr int32 kCallFreqMax = 100000;
+constexpr int32 kCallFreqDefault = 1;   // based on kCallFreqBase
+
+inline double CallFreqPercent(int32 callFreq) {
+  return static_cast<double>(callFreq) / static_cast<double>(kCallFreqBase);
+}
+
+using NumInsns = int32;
+using NumCycles = double;
+class InlineCost {
+ public:
+  InlineCost() = default;
+  InlineCost(NumInsns numInsns, NumCycles numCycles) : insns(numInsns), cycles(numCycles) {}
+
+  void Reset(NumInsns numInsns, NumCycles numCycles) {
+    insns = numInsns;
+    cycles = numCycles;
+  }
+
+  NumInsns GetInsns() const {
+    return insns;
+  }
+
+  NumCycles GetCycles() const {
+    return cycles;
+  }
+
+  void AddInsns(NumInsns detInsns) {
+    insns += detInsns;
+  }
+
+  void AddCycles(NumCycles detCycles) {
+    cycles += detCycles;
+  }
+
+  void Add(NumInsns detInsns, NumCycles detCycles) {
+    insns += detInsns;
+    cycles += detCycles;
+  }
+
+  void Add(const InlineCost &rhs) {
+    insns += rhs.insns;
+    cycles += rhs.cycles;
+  }
+
+  void Add(const InlineCost &rhs, int32 frequency) {
+    insns += rhs.insns;
+    auto detTime = rhs.cycles;
+    if (frequency > 0) {
+      detTime *= CallFreqPercent(frequency);
+    }
+    cycles += detTime;
+  }
+
+  InlineCost Scale(int32 frequency) const {
+    InlineCost cost(0, 0);
+    cost.Add(*this, frequency);
+    return cost;
+  }
+
+ private:
+  NumInsns insns = 0;     // The dimension is number of instructions
+  NumCycles cycles = 0;   // The dimension is cycles
+};
+
+ExprBoolResult GetReverseExprBoolResult(ExprBoolResult res);
+void DumpStmtSafe(const StmtNode &stmtNode, MIRFunction &func);
+std::pair<PrimType, int64> TryFoldConst(BaseNode &expr);
+std::optional<uint32> GetZeroVersionParamIndex(const MeExpr &expr, MeFunction &func);
+bool IsExprSpecifiedKinds(const MeExpr &expr, uint32 kinds, MeFunction &func);
+bool IsExprOnlyComposedOf(const MeExpr &expr, uint32 kinds, MeFunction &func);
+MIRConst *EvaluateMeExpr(MeExpr &meExpr, MeFunction &func, MapleAllocator &alloc);
+InlineSummary *GetSummaryByPuIdx(uint32 puIdx);
+int32 CostSize2NumInsn(int32 costSize);
+InlineCost GetCondInlineCost(const MIRFunction &caller, MIRFunction &callee, const CallNode &callStmt);
+
+// Real argument info of a callsite, including the following info:
+// (1) real argument value range: [lower, upper], it is a single value if lower == upper. lower and upper
+// will be reinterpreted according to `valueType`.
+// (2) pass through info of caller's formals
+class ArgInfo {
+ public:
+  // ctor for value range argInfo
+  ArgInfo(MIRConst *low, MIRConst *up) : lower(low), upper(up) {}
+
+  // ctor for pass through argInfo
+  explicit ArgInfo(int32 index) : callerFormalIdx(index) {}
+
+  bool IsSingleValue() const {
+    return lower == upper && lower != nullptr;
+  }
+
+  const MIRConst *GetLower() const {
+    return lower;
+  }
+
+  MIRConst *GetLower() {
+    return lower;
+  }
+
+  const MIRConst *GetUpper() const {
+    return upper;
+  }
+  MIRConst *GetUpper() {
+    return upper;
+  }
+
+  int32 GetCallerFormalIdx() const {
+    return callerFormalIdx;
+  }
+
+  bool IsParamPassThrough() const {
+    return callerFormalIdx != -1;
+  }
+
+ private:
+  // (1) value range
+  // Init with an invalid range
+  MIRConst *lower = nullptr;
+  MIRConst *upper = nullptr;
+  // (2) pass through
+  // callerFormalIdx means which caller's formal is passed to current arg, -1 is invalid
+  // Example: foo(int a, int b) { bar(b); }
+  // Then we have a param index mapping: for 'bar(b)' from 0 (call argument index) to 1 (caller parameter index)
+  int32 callerFormalIdx = -1;
+};
+
+using ArgInfoVec = MapleVector<ArgInfo*>;  // index is real arguments index
+
+// A simple expression representation for condition expr (in the condgoto stmt and the switch stmt).
+// LiteExpr is a lightweight expression used to pass information between MEIR and mapleIR.
+// Currently it is used to pass conditional expr for inline summary. The memory cost is quite considerable
+// because all function's inline summary will occupy memory at the same time. Using LiteExpr is good for saving memory
+// Leaf nodes of LiteExpr must be "constant expr" or "parameter expr" currently.
+class LiteExpr {
+ public:
+  static LiteExpr *TryBuildLiteExpr(MeExpr &expr, uint32 kinds, MeFunction &func, MapleAllocator &alloc,
+      uint32 *paramsUsed = nullptr);
+  static LiteExpr &DoBuildLiteExpr(MeExpr &expr, MeFunction &func, MapleAllocator &alloc, uint32 *paramsUsed);
+
+  // Construct parameter liteExpr
+  // we use OP_dread to mark parameter liteExpr
+  LiteExpr(MapleAllocator &alloc, PrimType primType, uint32 paramIndex)
+      : op(OP_dread), type(primType), opnds(alloc.Adapter()) {
+    data.paramIdx = paramIndex;
+  }
+
+  // Construct constval liteExpr
+  LiteExpr(MapleAllocator &alloc, PrimType primType, MIRConst *mirConst)
+      : op(OP_constval), type(primType), opnds(alloc.Adapter()) {
+    data.cst = mirConst;
+  }
+
+  // For other liteExpr, use SetXXX member function to init `data` field
+  LiteExpr(MapleAllocator &alloc, Opcode opcode, PrimType primType)
+      : op(opcode), type(primType), opnds(alloc.Adapter()) {}
+
+  LiteExpr(MapleAllocator &alloc, const LiteExpr &rhs)
+      :op(rhs.op), type(rhs.type), opnds(rhs.opnds, alloc.Adapter()) {
+    data = rhs.data;
+  }
+
+  void Dump(uint32 indent = 0) const;
+  void DumpWithoutEndl(uint32 indent = 0) const;
+  LiteExpr *Clone(MapleAllocator &newAlloc) const;
+  BaseNode *ConvertToMapleIR(MapleAllocator &alloc, const ArgInfoVec *argInfoVec) const;
+  MIRConst *Evaluate(MapleAllocator &alloc, const ArgInfoVec *argInfoVec) const;
+  ExprBoolResult EvaluateToBool(MapleAllocator &alloc, const ArgInfoVec *argInfoVec) const;
+
+  void RemapParamIdx(const std::vector<int32> &paramMapping) {
+    if (IsParam()) {
+      uint32 oldIdx = GetParamIndex();
+      if (oldIdx >= paramMapping.size()) {  // index out of range, no need to remap
+        return;
+      }
+      int32 newIdx = paramMapping[oldIdx];
+      if (newIdx != -1) {
+        SetParamIndex(static_cast<uint32>(newIdx));
+      }
+      return;
+    }
+    for (auto *opnd : opnds) {
+      opnd->RemapParamIdx(paramMapping);
+    }
+  }
+
+  PrimType GetType() const {
+    return type;
+  }
+
+  bool IsConst() const {
+    return op == OP_constval;
+  }
+
+  bool IsParam() const {
+    return op == OP_dread;
+  }
+
+  bool IsCmp() const {
+    return CastOpt::IsCompareOp(op);
+  }
+
+  bool IsCvt() const {
+    return op == OP_cvt;
+  }
+
+  bool IsExtractbits() const {
+    return op == OP_zext || op == OP_sext || op == OP_extractbits;
+  }
+
+  int64 GetInt() const {
+    ASSERT(IsConst(), "must be");
+    ASSERT(IsPrimitiveInteger(type), "must be");
+    return static_cast<MIRIntConst*>(data.cst)->GetSXTValue();
+  }
+
+  float GetFloat() const {
+    ASSERT(IsConst(), "must be");
+    ASSERT(type == PTY_f32, "must be");
+    return static_cast<MIRFloatConst*>(data.cst)->GetValue();
+  }
+
+  double GetDouble() const {
+    ASSERT(IsConst(), "must be");
+    ASSERT(type == PTY_f64, "must be");
+    return static_cast<MIRDoubleConst*>(data.cst)->GetValue();
+  }
+
+  uint32 GetParamIndex() const {
+    ASSERT(IsParam(), "must be");
+    return data.paramIdx;
+  }
+
+  void SetParamIndex(uint32 newParamIdx) {
+    ASSERT(IsParam(), "must be");
+    data.paramIdx = static_cast<int64>(static_cast<int32>(newParamIdx));
+  }
+
+  MIRConst *GetMIRConst() {
+    return data.cst;
+  }
+
+  PrimType GetOpndType() const {
+    return data.opndType;
+  }
+
+  void SetOpndType(PrimType ty) {
+    data.opndType = ty;
+  }
+
+  uint8 GetBitsOffset() const {
+    return data.bitData.bitsOffset;
+  }
+
+  uint8 GetBitsSize() const {
+    return data.bitData.bitsSize;
+  }
+
+  void SetBitsOffset(uint8 offset) {
+    data.bitData.bitsOffset = offset;
+  }
+
+  void SetBitsSize(uint8 size) {
+    data.bitData.bitsSize = size;
+  }
+
+  MapleVector<LiteExpr*> &GetOpnds() {
+    return opnds;
+  }
+
+ private:
+  Opcode op = OP_undef;
+  PrimType type = PTY_unknown;
+  // `data` field has different meaning for different op, see the following comment:
+  union {
+    MIRConst *cst = nullptr;  // (1) mirConst for const expr with opcode OP_constval
+    uint32 paramIdx;          // (2) parameter index for parameter expr with opcode OP_dread
+    PrimType opndType;        // (3) opngType for TypeCvtNode and CompareNode
+    struct {                  // (4) bitData for ExtractbitsNode
+      uint8 bitsOffset;
+      uint8 bitsSize;
+    } bitData;
+  } data;
+  MapleVector<LiteExpr*> opnds;
+};
+
+class Condition {
+ public:
+  explicit Condition(uint32 index, LiteExpr *liteExpr, bool rev, uint32 params)
+      : idx(index),
+        paramsUsed(params),
+        reverse(rev),
+        expr(liteExpr) {}
+
+  Condition *Clone(MapleAllocator &newAlloc) const {
+    auto *exprCloned = expr->Clone(newAlloc);
+    return newAlloc.New<Condition>(idx, exprCloned, reverse, paramsUsed);
+  }
+
+  ExprBoolResult EvaluateToBool(MapleAllocator &alloc, const ArgInfoVec *argInfoVec) const {
+    ExprBoolResult res = expr->EvaluateToBool(alloc, argInfoVec);
+    if (IsReverse()) {
+      res = GetReverseExprBoolResult(res);
+    }
+    return res;
+  }
+
+  void Dump() const;
+
+  uint32 GetIndex() const {
+    return idx;
+  }
+
+  LiteExpr *GetExpr() {
+    return expr;
+  }
+
+  bool IsReverse() const {
+    return reverse;
+  }
+
+  bool Equal(const Condition &rhs) const {
+    if (expr == rhs.expr && reverse == rhs.reverse) {
+      return true;
+    }
+    return false;
+  }
+
+  bool IsReverseWithCondition(const Condition &rhs) const {
+    if (expr == rhs.expr && reverse != rhs.reverse) {
+      return true;
+    }
+    return false;
+  }
+
+  uint32 GetParamsUsed() const {
+    return paramsUsed;
+  }
+
+ private:
+  const uint32 idx = 0;  // position in summary conditions vector
+  uint32 paramsUsed = 0; // This is a bit map, indicates which formal parameters are used
+  bool reverse = false;
+  LiteExpr *expr = nullptr;
+};
+
+using Assert = uint64;
+constexpr Assert kAssertOne = 1;
+constexpr uint32 kNumBitsPerByte = 8;
+constexpr uint32 kMaxNumCondition = sizeof(Assert) * kNumBitsPerByte;
+constexpr uint32 kCondIdxNotInline = 1;
+constexpr uint32 kCondIdxRealBegin = 2;
+constexpr uint32 kCondIdxOverflow = kMaxNumCondition;
+
+class Predicate {
+ public:
+  static const Predicate *TruePredicate();
+  static const Predicate *FalsePredicate();
+  static const Predicate *NotInlinePredicate();
+  static const Predicate *And(const Predicate &a, const Predicate &b, MapleAllocator &alloc);
+  static const Predicate *Or(const Predicate &a, const Predicate &b, const MapleVector<Condition*> &conditions,
+      MapleAllocator &alloc);
+
+  explicit Predicate(MapleAllocator &alloc) : asserts(alloc.Adapter()) {}
+
+  Predicate(std::initializer_list<Assert> assertList, MapleAllocator &alloc)
+      : asserts(assertList, alloc.Adapter()) {}
+
+  Predicate(const MapleSet<Assert> &assertList, MapleAllocator &alloc)
+      : Predicate(alloc) {
+    for (auto assert : assertList) {
+      (void)asserts.insert(assert);
+    }
+  }
+
+  Predicate(const std::vector<Assert> &assertList, MapleAllocator &alloc)
+      : Predicate(alloc) {
+    for (auto assert : assertList) {
+      (void)asserts.insert(assert);
+    }
+  }
+
+  Predicate(uint32 condIdx, MapleAllocator &alloc)
+      : Predicate(alloc) {
+    (void)asserts.insert(kAssertOne << condIdx);
+  }
+
+  bool operator==(const Predicate &rhs) const {
+    return asserts == rhs.asserts;
+  }
+
+  const Predicate *Clone(MapleAllocator &newAlloc) const;
+
+  // True predicate asserts: { 0 }
+  bool IsTruePredicate() const {
+    return asserts.size() == 1 && *asserts.begin() == 0;
+  }
+
+  // False predicate asserts: { 1 }
+  bool IsFalsePredicate() const {
+    return asserts.size() == 1 && *asserts.begin() == 1;
+  }
+
+  // NotInline predicate asserts: { 2 }
+  bool IsNotInlinePredicate() const {
+    const Assert notInlineAssertVal = 2;
+    return asserts.size() == 1 && *asserts.begin() == notInlineAssertVal;
+  }
+
+  MapleSet<Assert> &GetAsserts() {
+    return asserts;
+  }
+
+  void AddAssert(Assert newAssert, const MapleVector<Condition*> &conditions);
+
+  // predicateResult = assertResult0 && assertResult1 && ... && assertResultN
+  ExprBoolResult Evaluate(const std::vector<ExprBoolResult> &condResultVec) const {
+    if (IsTruePredicate()) {
+      return kExprResTrue;
+    }
+    if (IsFalsePredicate()) {
+      return kExprResFalse;
+    }
+    bool foundUnknown = false;
+    for (auto assert : asserts) {
+      auto res = EvaluateAssert(assert, condResultVec);
+      if (res == kExprResFalse) {
+        return res;
+      } else if (res == kExprResUnknown) {
+        foundUnknown = true;
+      }
+    }
+    if (foundUnknown) {
+      return kExprResUnknown;
+    }
+    return kExprResTrue;
+  }
+
+  const Predicate *RemapCondIdx(const std::array<int8, kMaxNumCondition> &oldCondIdx2New,
+      MapleAllocator &alloc) const {
+    if (IsTruePredicate() || IsFalsePredicate()) {
+      return this;
+    }
+    std::vector<Assert> newAssertVec;
+    for (auto assert : asserts) {
+      Assert newAssert = 0;
+      for (uint32 j = 0; j < kMaxNumCondition; ++j) {
+        if ((assert & (kAssertOne << j)) == 0) {
+          continue;
+        }
+        auto newCondIdx = oldCondIdx2New[j];
+        if (newCondIdx == static_cast<int32>(kCondIdxOverflow)) {
+          // condition out of range, we treat it as true condition
+          newAssert = 0;
+          break;
+        }
+        newAssert |= (kAssertOne << newCondIdx);
+      }
+      if (newAssert != 0) {
+        newAssertVec.push_back(newAssert);
+      }
+    }
+    if (newAssertVec.empty()) {
+      return Predicate::TruePredicate();
+    }
+    return alloc.New<Predicate>(newAssertVec, alloc);
+  }
+
+  Assert GetCondsUsed() const {
+    Assert condsUsed = 0;
+    for (auto assert : asserts) {
+      condsUsed |= assert;
+    }
+    return condsUsed;
+  }
+
+  uint32 GetParamsUsed(const MapleVector<Condition*> &conditions) const {
+    uint32 paramsUsed = 0;
+    for (auto assert : asserts) {
+      // Skip the first element that is a placeholder for falsePredicate and the second
+      // element for notInline
+      for (uint32 i = kCondIdxRealBegin; i < kMaxNumCondition; ++i) {
+        if ((assert & (kAssertOne << i)) == 0) {
+          continue;
+        }
+        paramsUsed |= conditions[i]->GetParamsUsed();
+      }
+    }
+    return paramsUsed;
+  }
+
+  bool AreAllUsedParamsInParamMapping(const std::vector<int32> &paramMapping,
+      const MapleVector<Condition*> &conditions) const;
+  void Dump(const MapleVector<Condition*> &conditions) const;
+
+ private:
+  // assertResult = condResult0 || condResult1 || ... || condResultN
+  ExprBoolResult EvaluateAssert(Assert assert, const std::vector<ExprBoolResult> &condResultVec) const {
+    bool foundUnknown = false;
+    for (uint32 i = 0; i < kMaxNumCondition; ++i) {
+      if ((assert & (kAssertOne << i)) == 0) {
+        continue;
+      }
+      auto res = condResultVec[i];
+      if (res == kExprResTrue) {
+        return res;
+      } else if (res == kExprResUnknown) {
+        foundUnknown = true;
+      }
+    }
+    if (foundUnknown) {
+      return kExprResUnknown;
+    }
+    return kExprResFalse;
+  }
+
+  MapleSet<Assert> asserts;
+};
+
+struct InlineEdgeSummary {
+  InlineEdgeSummary(const Predicate *pred, int32 freq, int32 stmtSz, int32 stmtTm)
+      : predicate(pred), frequency(freq), callCost(stmtSz, stmtTm) {}
+  const Predicate *predicate = nullptr;  // predicate of the bb that contains the callStmt
+  int32 frequency = -1;   // frequency of the bb that contains the callStmt, -1 means invalid frequency
+  InlineCost callCost;
+};
+
+class InlineSummary {
+ public:
+  InlineSummary(MapleAllocator &allocater, MIRFunction *f)
+      : summaryAlloc(allocater),
+        func(f),
+        conditions(kCondIdxRealBegin, nullptr, summaryAlloc.Adapter()), // The 1st is a placeholder for falsePredicate
+        costTable(summaryAlloc.Adapter()),                              // The 2ed is a placeholder for notInline
+        edgeSummaryMap(summaryAlloc.Adapter()),
+        argInfosMap(summaryAlloc.Adapter()) {
+    // Init the first cost item: truePredicate
+    (void)costTable.emplace_back(Predicate::TruePredicate(), InlineCost{ 0, 0 });
+  }
+
+  void Dump() const;
+  void DumpConditions() const;
+  void DumpCostTable() const;
+  void DumpArgInfosMap() const;
+  void DumpEdgeSummaryMap() const;
+
+  MapleAllocator &GetSummaryAlloc() {
+    return summaryAlloc;
+  }
+
+  NumInsns GetStaticInsns() const {
+    return staticCost.GetInsns();
+  }
+
+  NumCycles GetStaticCycles() const {
+    return staticCost.GetCycles();
+  }
+
+  void AddStaticInsns(NumInsns detInsns) {
+    staticCost.AddInsns(detInsns);
+  }
+
+  void AddStaticCycles(NumCycles detCycles) {
+    staticCost.AddCycles(detCycles);
+  }
+
+  void SetStaticCost(int32 insns, double cycles) {
+    staticCost.Reset(insns, cycles);
+  }
+
+  const MapleVector<Condition*> &GetConditions() const {
+    return conditions;
+  }
+
+  // Given arguments info, evalutate all conditions. The result will be saved in `condResultVec` indexed by condIdx
+  void EvaluateConditions(MapleAllocator &alloc, const ArgInfoVec *argInfoVec,
+      std::vector<ExprBoolResult> &condResultVec, bool willInline) const {
+    condResultVec.resize(conditions.size(), kExprResUnknown);
+    for (uint32 i = 0; i < conditions.size(); ++i) {
+      auto *cond = conditions[i];
+      if (cond == nullptr) {
+        continue;
+      }
+      ExprBoolResult res = cond->EvaluateToBool(alloc, argInfoVec);
+      if (res != kExprResUnknown) {
+        condResultVec[i] = res;
+      }
+    }
+    condResultVec[kCondIdxNotInline] = !willInline ? kExprResTrue : kExprResFalse;
+  }
+
+  // Return a predicate with single condition spcified by `liteExpr` and `reverse`
+  const Predicate *AddCondition(LiteExpr *liteExpr, bool reverse, uint32 params, MapleAllocator &tmpAlloc) {
+    if (liteExpr->IsConst() && IsPrimitiveInteger(liteExpr->GetType())) {
+      // liteExpr can be evaluated now
+      bool isTrue = liteExpr->GetInt() != 0;
+      if (reverse) {
+        isTrue = !isTrue;
+      }
+      return isTrue ? Predicate::TruePredicate() : Predicate::FalsePredicate();
+    }
+    Condition *targetCond = nullptr;
+    // Find cond in conditions first
+    for (uint32 i = 0; i < conditions.size(); ++i) {
+      auto *cond = conditions[i];
+      if (cond == nullptr) {
+        continue;
+      }
+      if (cond->GetExpr() == liteExpr && cond->IsReverse() == reverse) {
+        targetCond = cond;
+        break;
+      }
+    }
+    if (targetCond == nullptr) {
+      if (conditions.size() == kMaxNumCondition) {
+        // conditions out of range
+        return Predicate::TruePredicate();
+      }
+      targetCond = summaryAlloc.New<Condition>(conditions.size(), liteExpr, reverse, params);
+      conditions.push_back(targetCond);
+    }
+    // Create a single condition predicate.
+    // New generated predicate is always allocated in tmpAlloc because we are not sure how long it will live
+    return tmpAlloc.New<Predicate>(targetCond->GetIndex(), tmpAlloc);
+  }
+
+  void CloneAllPredicatesToSummaryAlloc() {
+    for (auto &pair : costTable) {
+      pair.first = pair.first->Clone(summaryAlloc);
+    }
+  }
+
+  void AddCondCostItem(const Predicate &predicate, maple::NumInsns insns, NumCycles cycles, bool debug) {
+    if (predicate.IsFalsePredicate()) {
+      return;  // Adding false predicate make no sense
+    }
+    if (debug) {
+      LogInfo::MapleLogger() << "  Accounting insns: " << insns << ", cycles: " << cycles << " on predicate: ";
+      predicate.Dump(conditions);
+    }
+    ASSERT(costTable[0].first->IsTruePredicate(), "The first item of costTable must be truePredicate");
+    if (predicate.IsTruePredicate()) {
+      costTable[0].second.Add(insns, cycles);
+      return;
+    }
+    for (size_t i = costTable.size() - 1; i > 0; --i) {  // look from back to front, skip the first item
+      if (costTable[i].first == &predicate) {
+        costTable[i].second.Add(insns, cycles);
+        return;
+      }
+    }
+    (void)costTable.emplace_back(&predicate, InlineCost{ insns, cycles });
+  }
+
+  void AddArgInfo(uint32 callStmtId, uint32 argIndex, ArgInfo *argInfo) {
+    const auto &res = argInfosMap.try_emplace(callStmtId, nullptr);
+    if (res.second) {
+      res.first->second = summaryAlloc.New<ArgInfoVec>(summaryAlloc.Adapter());
+    }
+    auto &argInfoVec = *res.first->second;
+    if (argIndex >= argInfoVec.size()) {
+      argInfoVec.resize(argIndex + 1, nullptr);
+    }
+    argInfoVec[argIndex] = argInfo;
+  }
+
+  void AddEdgeSummary(uint32 callStmtId, const Predicate *bbPredicate, int32 frequency,
+                      int32 insns, int32 cycles) {
+    const auto &res = edgeSummaryMap.try_emplace(callStmtId, nullptr);
+    if (res.second) {
+      res.first->second = summaryAlloc.New<InlineEdgeSummary>(bbPredicate, frequency, insns, cycles);
+    }
+  }
+
+  void RemoveEdgeSummary(uint32 callStmtId) {
+    (void)edgeSummaryMap.erase(callStmtId);
+  }
+
+  InlineEdgeSummary *GetEdgeSummary(uint32 callStmtId) const {
+    if (edgeSummaryMap.find(callStmtId) == edgeSummaryMap.end()) {
+      return nullptr;
+    }
+    return edgeSummaryMap.at(callStmtId);
+  }
+
+  bool IsUnlikelyCallsite(uint32 callStmtId) const {
+    auto it = edgeSummaryMap.find(callStmtId);
+    if (it == edgeSummaryMap.end()) {
+      return false;
+    }
+    auto callFreq = it->second->frequency;
+    // Attention: sometimes freq 0 is also invalid
+    if (callFreq == -1 || callFreq == 0) {
+      return false;
+    }
+    double freqPercent = static_cast<double>(callFreq) / static_cast<double>(kCallFreqBase);
+    return freqPercent <= kColdFreqPercent;
+  }
+
+  MapleVector<std::pair<const Predicate*, InlineCost>> &GetCostTable() {
+    return costTable;
+  }
+
+  const MapleVector<std::pair<const Predicate*, InlineCost>> &GetCostTable() const {
+    return costTable;
+  }
+
+  MapleMap<uint32, ArgInfoVec*> &GetArgInfosMap() {
+    return argInfosMap;
+  }
+
+  const MapleMap<uint32, ArgInfoVec*> &GetArgInfosMap() const {
+    return argInfosMap;
+  }
+
+  bool IsArgInfoCollected() const {
+    return argInfoCollected;
+  }
+
+  void SetArgInfoCollected(bool flag) {
+    argInfoCollected = flag;
+  }
+
+  const char *GetMustNotInlineReason() const {
+    return mustNotInlineReason;
+  }
+
+  void SetMustNotInlineReason(const char *reason) {
+    mustNotInlineReason = reason;
+  }
+
+  InlineFailedCode GetInlineFailedCode() const {
+    return inlineFailedCode;
+  }
+
+  void SetInlineFailedCode(InlineFailedCode code) {
+    inlineFailedCode = code;
+  }
+
+  bool HasBigSwitch() const {
+    return hasBigSwitch;
+  }
+
+  void SetHasBigSwitch(bool val) {
+    hasBigSwitch = val;
+  }
+
+  void GetParamMappingForCallsite(uint32 callStmtId, std::vector<int32> &paramMapping) const {
+    auto it = argInfosMap.find(callStmtId);
+    if (it == argInfosMap.end()) {
+      return;
+    }
+    auto &argInfoVec = *it->second;
+    for (uint32 i = 0; i < argInfoVec.size(); ++i) {
+      if (argInfoVec[i] == nullptr || !argInfoVec[i]->IsParamPassThrough()) {
+        continue;
+      }
+      paramMapping.resize(argInfoVec.size(), -1);
+      paramMapping[i] = argInfoVec[i]->GetCallerFormalIdx();
+    }
+  }
+
+  // Inline summary hold some callsite-level information such as arguments info (argInfosMap), one of the most
+  // important issue is how we indexed these information. Inline summaries are generated based on MEIR in IPA
+  // and consumed by inline based on maple IR in mpl2mpl. We can not use callMeStmt as callsite-level info key
+  // because MEIR will be released after IPA. So we use callMeStmt id as key. However, inline summary merging
+  // during inlining is based on mapleIR (we need clone callee's maple IR body), callMeStmt id is invalid at
+  // that time. Finally, we solve it by using a wired solution: Using callMeStmt id as key when generating summary
+  // in IPA. After pemit, we call the followinig `RefreshMapKeyIfNeeded` to refresh the key with callMapleStmt id.
+  void RefreshMapKeyIfNeeded() {
+    if (keyRefreshed) {
+      return;
+    }
+    keyRefreshed = true;
+    std::vector<std::pair<uint32, ArgInfoVec*>> copyArgInfos;
+    for (const auto &pair : std::as_const(argInfosMap)) {
+      auto meStmtId = pair.first;
+      auto *callStmt = func->GetStmtNodeFromMeId(meStmtId);
+      CHECK_NULL_FATAL(callStmt);
+      (void)copyArgInfos.emplace_back(callStmt->GetStmtID(), pair.second);
+    }
+    argInfosMap.clear();
+    for (const auto &pair : copyArgInfos) {
+      (void)argInfosMap.emplace(pair.first, pair.second);
+    }
+
+    std::vector<std::pair<uint32, InlineEdgeSummary*>> copyEdgeSummaries;
+    for (const auto &pair : std::as_const(edgeSummaryMap)) {
+      auto meStmtId = pair.first;
+      auto *callStmt = func->GetStmtNodeFromMeId(meStmtId);
+      CHECK_NULL_FATAL(callStmt);
+      (void)copyEdgeSummaries.emplace_back(callStmt->GetStmtID(), pair.second);
+    }
+    // clear old data and push new data
+    edgeSummaryMap.clear();
+    for (const auto &pair : copyEdgeSummaries) {
+      (void)edgeSummaryMap.emplace(pair.first, pair.second);
+    }
+  }
+
+  bool IsTrustworthy() const {
+    return trustworthy;
+  }
+
+  void MergeSummary(const InlineSummary &fromSummary, uint32 callStmtId, MapleAllocator &tmpAlloc,
+      const std::vector<ExprBoolResult> &condResultVec, const std::map<uint32, uint32> &callMeStmtIdMap);
+
+ private:
+  void MergeAndRemapConditions(const InlineSummary &fromSummary, Assert condsNeedCopy,
+      const std::vector<int32> &paramMapping, std::array<int8, kMaxNumCondition> &oldCondIdx2New);
+
+  void MergeEdgeSummary(const InlineSummary &fromSummary, std::pair<uint32, InlineEdgeSummary*> callEdgeSummaryPair,
+      MapleAllocator &tmpAlloc, const std::array<int8, kMaxNumCondition> &oldCondIdx2New,
+      const std::map<uint32, uint32> &callMeStmtIdMap);
+
+  void MergeArgInfosMap(const InlineSummary &fromSummary, uint32 callStmtId,
+      const std::map<uint32, uint32> &callMeStmtIdMap);
+
+  // Return condIdx bitMap that need be copied to toSummary
+  Assert SpecializeCostTable(const std::vector<ExprBoolResult> &condResultVec, const std::vector<int32> &paramMapping,
+      int32 callFrequency, std::vector<std::pair<const Predicate*, InlineCost>> &spCostTable,
+      InlineCost &unnecessaryCost) const;
+
+  // Do not add too many unnecessary fields unless you want to MergeSummary more and more complicated
+  MapleAllocator &summaryAlloc;
+  MIRFunction *func = nullptr;
+  InlineCost staticCost;  // callsite-insensitive static cost
+
+  MapleVector<Condition*> conditions;
+  MapleVector<std::pair<const Predicate*, InlineCost>> costTable;  // The first element is always truePredicate
+
+  // key: callStmtId, value: inline edge summary of callsite
+  MapleMap<uint32, InlineEdgeSummary*> edgeSummaryMap;
+
+  // key: callStmtId, value: argInfoVec for current callsite, see `ArgInfo` for details
+  MapleMap<uint32, ArgInfoVec*> argInfosMap;
+  const char *mustNotInlineReason = nullptr;  // If not null, the function must not be inlined
+  InlineFailedCode inlineFailedCode = kIFC_NeedFurtherAnalysis;
+  bool hasBigSwitch = false;
+  bool argInfoCollected = false;
+  bool keyRefreshed = false;
+  bool trustworthy = true;
+};
+
+void MergeInlineSummary(MIRFunction &caller, MIRFunction &callee, const StmtNode &callStmt,
+    const std::map<uint32, uint32> &callMeStmtIdMap);
+
+struct BBPredicate {
+  const Predicate *predicate = nullptr;
+  MapleVector<const Predicate*> succEdgePredicates;
+  explicit BBPredicate(MapleAllocator &alloc) : succEdgePredicates(alloc.Adapter()) {}
+};
+
+// Function level inline summary collector
+class InlineSummaryCollector {
+ public:
+  static void CollectArgInfo(MeFunction &meFunc);
+
+  InlineSummaryCollector(MapleAllocator &allocator, MeFunction &meFunc, Dominance &dominance, Dominance &postDominance,
+                         IdentifyLoops &loop)
+      : summaryAlloc(allocator),
+        tmpAlloc(memPoolCtrler.NewMemPool("tmp alloc", true)),
+        func(&meFunc),
+        stmtCostAnalyzer(tmpAlloc.GetMemPool(), func->GetMirFunc()),
+        dom(dominance),
+        pdom(postDominance),
+        meLoop(loop),
+        allBBPred(tmpAlloc.Adapter()) {}
+
+  ~InlineSummaryCollector() {
+    memPoolCtrler.DeleteMemPool(tmpAlloc.GetMemPool());
+  }
+
+  bool IsDebug() const {
+    return debug;
+  }
+
+  void SetDebug(bool dbg) {
+    debug = dbg;
+  }
+
+  void PrepareSummary() {
+    if (inlineSummary != nullptr) {
+      return;
+    }
+    inlineSummary = func->GetMirFunc()->GetOrCreateInlineSummary();
+  }
+
+  void PreparePredicateForBB(BB &bb) {
+    auto bbId = bb.GetBBId().get();
+    if (allBBPred[bbId] == nullptr) {
+      allBBPred[bbId] = tmpAlloc.New<BBPredicate>(tmpAlloc);
+    }
+  }
+
+  void ComputeEdgePredicate();
+  void PropBBPredicate();
+  void ComputeConditionalCost();
+  std::pair<int32, double> AnalyzeCondCostForStmt(MeStmt &stmt, int32 callFrequency, const Predicate *bbPredClone,
+      const BBPredicate &bbPredicate);
+
+  void CollectInlineSummary() {
+    InlineSummaryCollector::CollectArgInfo(*func);
+    BuiltinExpectInfo savedExpectInfo;
+    MePrediction::RebuildFreq(*func, dom, pdom, meLoop, &savedExpectInfo);  // ipa prepare should rebuild freq before
+    PrepareSummary();
+    if (debug) {
+      LogInfo::MapleLogger() << "Collect inline summary for function: " << func->GetName() << "/" <<
+          func->GetMirFunc()->GetPuidx() << std::endl;
+    }
+    ComputeEdgePredicate();
+    PropBBPredicate();
+    ComputeConditionalCost();
+    MePrediction::RecoverBuiltinExpectInfo(savedExpectInfo);
+    if (IsDebug()) {
+      inlineSummary->Dump();
+    }
+  }
+
+  // See comment for LiteExpr::TryBuildLiteExpr
+  LiteExpr *GetOrCreateLiteExpr(MeExpr &meExpr, uint32 kinds, uint32 &paramsUsed) {
+    // search cache first
+    auto it = exprCache.find(&meExpr);
+    if (it != exprCache.end()) {
+      paramsUsed = it->second.second;
+      return it->second.first;
+    }
+    // All liteExprs should be allocated in summaryAlloc
+    auto *liteExpr = LiteExpr::TryBuildLiteExpr(meExpr, kinds, *func, summaryAlloc, &paramsUsed);
+    if (liteExpr == nullptr) {
+      return nullptr;
+    }
+    (void)exprCache.emplace(&meExpr, std::pair<LiteExpr*, uint32>(liteExpr, paramsUsed));
+    return liteExpr;
+  }
+
+ private:
+  MapleAllocator &summaryAlloc; // summaryAlloc will not be released util ipa-inlining finish
+  MapleAllocator tmpAlloc;      // tmpAlloc will be released once inlineSummaryCollector is destructed
+  MeFunction *func = nullptr;
+  StmtCostAnalyzer stmtCostAnalyzer;
+  Dominance &dom;
+  Dominance &pdom;
+  IdentifyLoops &meLoop;
+  InlineSummary *inlineSummary = nullptr;
+  // All bb predicates are allocated in tmpAlloc, necessary predicates will be cloned into summaryAlloc
+  MapleVector<BBPredicate*> allBBPred;
+  // We use `exprCache` to avoid build multiple different liteExpr for a single meExpr
+  // key: meExpr, value: liteExpr and paramsUsed
+  std::unordered_map<MeExpr*, std::pair<LiteExpr*, uint32>> exprCache;
+  bool debug = false;
+};
+}  // namespace maple
+#endif  // MAPLE_MPL2MPL_INCLUDE_INLINE_SUMMARY_H
+
diff --git a/src/mapleall/mpl2mpl/include/inline_transformer.h b/src/mapleall/mpl2mpl/include/inline_transformer.h
new file mode 100644
index 0000000000000000000000000000000000000000..c4ead6565f1da370744605e010437ae2b587047c
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/inline_transformer.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_INLINE_TRANSFORMER_H
+#define MPL2MPL_INCLUDE_INLINE_TRANSFORMER_H
+#include "call_graph.h"
+#include "maple_phase_manager.h"
+#include "me_option.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_builder.h"
+#include "mir_function.h"
+#include "mir_parser.h"
+#include "opcode_info.h"
+#include "string_utils.h"
+
+namespace maple {
+constexpr char kSpaceTabStr[] = " \t";
+constexpr char kCommentsignStr[] = "#";
+constexpr char kHyphenStr[] = "-";
+constexpr char kAppointStr[] = "->";
+constexpr char kUnderlineStr[] = "_";
+constexpr char kVerticalLineStr[] = "__";
+constexpr char kNumberZeroStr[] = "0";
+constexpr char kReturnlocStr[] = "return_loc_";
+constexpr char kThisStr[] = "_this";
+constexpr char kPstatic[] = "__pstatic__";
+constexpr char kDalvikSystemStr[] = "Ldalvik_2Fsystem_2FVMStack_3B_7C";
+constexpr char kJavaLangThreadStr[] = "Ljava_2Flang_2FThread_3B_7C";
+constexpr char kReflectionClassStr[] = "Ljava_2Flang_2Freflect";
+constexpr char kJavaLangClassesStr[] = "Ljava_2Flang_2FClass_3B_7C";
+constexpr char kJavaLangReferenceStr[] = "Ljava_2Flang_2Fref_2FReference_3B_7C";
+constexpr char kInlineBeginComment[] = "inlining begin: FUNC ";
+constexpr char kInlineEndComment[] = "inlining end: FUNC ";
+constexpr char kSecondInlineSymbolSuffix[] = "SECOND_";
+constexpr char kSecondInlineBeginComment[] = "second inlining begin: FUNC ";
+constexpr char kSecondInlineEndComment[] = "second inlining end: FUNC ";
+
+void UpdateEnclosingBlockCallback(const BlockNode &oldBlock, BlockNode &newBlock, const StmtNode &oldStmt,
+    StmtNode &newStmt, CallBackData *data);
+
+enum InlineStage {
+  kEarlyInline,
+  kGreedyInline
+};
+
+class InlineTransformer {
+ public:
+  InlineTransformer(InlineStage inlineStage, MIRFunction &caller, MIRFunction &callee,
+      CallNode &callStmt, bool dumpDetail, CallGraph *cg)
+      : builder(*theMIRModule->GetMIRBuilder()),
+        caller(caller),
+        callee(callee),
+        callStmt(callStmt),
+        enclosingBlk(*callStmt.GetEnclosingBlock()),
+        stage(inlineStage),
+        dumpDetail(dumpDetail),
+        cg(cg),
+        updateFreq(Options::profileUse && caller.GetFuncProfData() && callee.GetFuncProfData()) {
+    theMIRModule->SetCurFunction(&caller);
+  }
+
+  bool PerformInline(BlockNode &enclosingBlk);
+  bool PerformInline(std::vector<CallInfo*> *newCallInfo = nullptr);
+  static void ReplaceSymbols(BaseNode*, uint32, const std::vector<uint32>*);
+  static void ConvertPStaticToFStatic(MIRFunction &func);
+  void SetDumpDetail(bool value) {
+    dumpDetail = value;
+  }
+  ~InlineTransformer() = default;
+
+ private:
+  BlockNode *CloneFuncBody(BlockNode &funcBody, bool recursiveFirstClone);
+  BlockNode *GetClonedCalleeBody();
+  uint32 RenameSymbols(uint32) const;
+  uint32 RenameLabels(uint32) const;
+  uint32 RenamePregs(std::unordered_map<PregIdx, PregIdx>&) const;
+  void ReplaceLabels(BaseNode&, uint32) const;
+  void ReplacePregs(BaseNode*, std::unordered_map<PregIdx, PregIdx>&) const;
+  void UpdateEnclosingBlock(BlockNode&) const;
+  void CollectNewCallInfo(BaseNode*, std::vector<CallInfo*>*) const;
+  void AssignActualsToFormals(BlockNode&, uint32, uint32);
+  void AssignActualToFormal(BlockNode&, uint32, uint32, BaseNode&, const MIRSymbol&);
+  void GenReturnLabel(BlockNode &newBody, uint32 inlinedTimes);
+  void HandleReturn(BlockNode &newBody);
+  void ReplaceCalleeBody(BlockNode &enclosingBlk, BlockNode &newBody);
+  LabelIdx CreateReturnLabel(uint32) const;
+  GotoNode *UpdateReturnStmts(BlockNode&, const CallReturnVector*, int&) const;
+  GotoNode *DoUpdateReturnStmts(BlockNode&, StmtNode&, const CallReturnVector*, int&) const;
+  void HandleTryBlock(StmtNode*, StmtNode*);
+  bool ResolveNestedTryBlock(BlockNode&, TryNode&, const StmtNode*) const;
+
+  MIRBuilder &builder;
+  MIRFunction &caller;
+  MIRFunction &callee;
+  CallNode &callStmt;
+  BlockNode &enclosingBlk;
+  const InlineStage stage;
+  bool dumpDetail = false;
+  LabelIdx returnLabelIdx = 0;    // The lableidx where the code will jump when the callee returns.
+  StmtNode *labelStmt = nullptr;  // The LabelNode we created for the callee, if needed.
+  CallGraph *cg = nullptr;
+  bool updateFreq = false;
+};
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_INLINE_TRANSFORMER_H
diff --git a/src/mapleall/mpl2mpl/include/java_intrn_lowering.h b/src/mapleall/mpl2mpl/include/java_intrn_lowering.h
new file mode 100644
index 0000000000000000000000000000000000000000..dd073eed994261bcc14ab3ed28bfa77486e761fc
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/java_intrn_lowering.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_JAVA_INTRN_LOWERING_H
+#define MPL2MPL_INCLUDE_JAVA_INTRN_LOWERING_H
+#include <map>
+#include <unordered_set>
+#include "phase_impl.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+class JavaIntrnLowering : public FuncOptimizeImpl {
+ public:
+  JavaIntrnLowering(MIRModule &mod, KlassHierarchy *kh, bool dump);
+  ~JavaIntrnLowering() = default;
+
+  FuncOptimizeImpl *Clone() override {
+    return new JavaIntrnLowering(*this);
+  }
+
+ private:
+  void InitTypes();
+  void InitFuncs();
+  void InitLists();
+  void ProcessStmt(StmtNode &stmt) override;
+  void ProcessJavaIntrnMerge(StmtNode &assignNode, const IntrinsicopNode &intrinNode);
+  BaseNode *JavaIntrnMergeToCvtType(PrimType dtyp, PrimType styp, BaseNode *src);
+  void LoadClassLoaderInvocation(const std::string &list);
+  void CheckClassLoaderInvocation(const CallNode &callNode) const;
+  void DumpClassLoaderInvocation(const CallNode &callNode);
+  void ProcessForNameClassLoader(CallNode &callnode);
+  void ProcessJavaIntrnFillNewArray(IntrinsiccallNode &intrinCall);
+  std::string outFileName;
+  std::unordered_set<std::string> clInterfaceSet;
+  std::multimap<std::string, std::string> clInvocationMap;
+  MIRFunction *classForName1Func = nullptr;
+  MIRFunction *classForName3Func = nullptr;
+  MIRFunction *getCurrentClassLoaderFunc = nullptr;
+  MIRType *classLoaderPointerToType = nullptr;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MJavaIntrnLowering)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_JAVA_INTRN_LOWERING_H
diff --git a/src/mapleall/mpl2mpl/include/method_replace.h b/src/mapleall/mpl2mpl/include/method_replace.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7e9af53e266f4ee7b10a2a2e49338859eeca98f
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/method_replace.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEIPA_INCLUDE_METHODREPLACE_H
+#define MAPLEIPA_INCLUDE_METHODREPLACE_H
+#include "mir_module.h"
+#include "mir_function.h"
+#include "mir_builder.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "maple_phase.h"
+
+namespace maple {
+using StrStrMap = std::unordered_map<std::string, std::string>;
+using ReplaceMethodMapType = std::unordered_map<std::string, StrStrMap>;
+
+class MethodReplace : public AnalysisResult {
+ public:
+  MethodReplace(MIRModule *mod, MemPool *mp, MIRBuilder &builder)
+      : AnalysisResult(mp), mirModule(mod), allocator(mp), mBuilder(builder) {}
+
+  ~MethodReplace() = default;
+
+  void DoMethodReplace();
+  void Init();
+
+ private:
+  MIRModule *mirModule;
+  MapleAllocator allocator;
+  MIRBuilder &mBuilder;
+  ReplaceMethodMapType replaceMethodMap;
+
+  void InsertRecord(const std::string &caller, const std::string &origCallee, const std::string &newCallee);
+  void FindCalleeAndReplace(MIRFunction &callerFunc, StrStrMap &calleeMap) const;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MMethodReplace)
+}  // namespace maple
+#endif
\ No newline at end of file
diff --git a/src/mapleall/mpl2mpl/include/module_phase_manager.h b/src/mapleall/mpl2mpl/include/module_phase_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..780cd3dc347c7d8026307aedf381d8ba7649afed
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/module_phase_manager.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_MODULE_PHASE_MANAGER_H
+#define MPL2MPL_INCLUDE_MODULE_PHASE_MANAGER_H
+#include "maple_phase_manager.h"
+#include "class_hierarchy_phase.h"
+#include "class_init.h"
+#include "bin_mpl_export.h"
+#include "clone.h"
+#include "ipa_clone.h"
+#include "call_graph.h"
+#include "verification.h"
+#include "verify_mark.h"
+#include "inline.h"
+#include "ginline.h"
+#include "outline.h"
+#include "method_replace.h"
+#include "gen_profile.h"
+#if MIR_JAVA
+#include "native_stub_func.h"
+#include "vtable_analysis.h"
+#include "reflection_analysis.h"
+#include "annotation_analysis.h"
+#include "vtable_impl.h"
+#include "java_intrn_lowering.h"
+#include "simplify.h"
+#include "java_eh_lower.h"
+#include "muid_replacement.h"
+#include "gen_check_cast.h"
+#include "coderelayout.h"
+#include "constantfold.h"
+#include "preme.h"
+#include "scalarreplacement.h"
+#include "openProfile.h"
+#include "update_mplt.h"
+#endif  // ~MIR_JAVA
+#include "option.h"
+#include "me_option.h"
+
+namespace maple {
+class MEBETopLevelManager : public ModulePM {
+ public:
+  explicit MEBETopLevelManager(MemPool *mp) : ModulePM(mp, &id) {}
+  ~MEBETopLevelManager() override {};
+  PHASECONSTRUCTOR(MEBETopLevelManager)
+  std::string PhaseName() const override;
+  void DoPhasesPopulate(const MIRModule &m);
+  void Run(MIRModule &mod);
+  void InitFuncDescWithWhiteList(const MIRModule &mod);
+  bool IsRunMpl2Mpl() const {
+    return runMpl2mpl;
+  }
+  void SetRunMpl2Mpl(bool value) {
+    runMpl2mpl = value;
+  }
+  bool IsRunMe() const {
+    return runMe;
+  }
+  void SetRunMe(bool value) {
+    runMe = value;
+  }
+ private:
+  bool runMpl2mpl = false;
+  bool runMe = false;
+};
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_MODULE_PHASE_MANAGER_H
diff --git a/src/mapleall/mpl2mpl/include/mpl_profdata_parser.h b/src/mapleall/mpl2mpl/include/mpl_profdata_parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..386895da8a566288f2678fd7b97d737fcb0bc63c
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/mpl_profdata_parser.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_MPL2MPL_INCLUDE_GCOVPROFUSE_H
+#define MAPLE_MPL2MPL_INCLUDE_GCOVPROFUSE_H
+#include "bb.h"
+#include "maple_phase_manager.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mpl_profdata.h"
+
+namespace maple {
+// maple profile data format
+//  Summary layout
+//    MagicNumber
+//    chesum
+//    run times
+//    counts number
+//    count Maxium value
+//    accumulated count sum
+//    cout histogram size (count statistic information used for hot function check)
+//      count lower bound      <-- begin of histogram details
+//      countNum in current range
+//      minium value in count range
+//      accumulated count sum
+//      count range            <-- another histogram element
+//      countNum
+//      minium value in cout range
+//      accumulated count sum
+//  Function profile layout (now only including edge profiling counts)
+//    function numbers
+//    function Ident (key number to identify each function(now use mirfunction->puidx)
+//    function line number checksum
+//    function cfg checksum
+//    counts number in function 0
+//      count  <-- begin of count value
+//      count
+//    counts number in function 1
+//      count
+//      ...
+// now only unsigned number in profile data, use ULEB128 to encode/decode value for file size
+
+const uint32_t kMapleProfDataMagicNumber = 0xA0EFEF;
+
+class ProfDataBinaryImportBase {
+ public:
+  ProfDataBinaryImportBase(std::string &filename, std::ifstream &input) : fileName(filename), inputStream(input) {}
+  template <typename T>
+  T ReadNum();
+  std::ifstream &GetInputStream() {
+    return inputStream;
+  }
+  std::string &GetProfDataFileName() {
+    return fileName;
+  }
+  void SetPosition(uint8_t *p) {
+    pos = p;
+  }
+  uint8_t *GetPosition() {
+    return pos;
+  }
+
+ private:
+  std::string &fileName;
+  std::ifstream &inputStream;
+  uint8_t *pos = nullptr;
+};
+
+class ProfileSummaryImport : public ProfDataBinaryImportBase {
+ public:
+  ProfileSummaryImport(std::string &outputFile, std::ifstream &input) : ProfDataBinaryImportBase(outputFile, input) {}
+  void ReadSummary(MplProfileData*);
+
+ private:
+  void ReadMProfMagic();
+};
+
+class FunctionProfileImport : public ProfDataBinaryImportBase {
+ public:
+  FunctionProfileImport(std::string &inputFile, std::ifstream &input) : ProfDataBinaryImportBase(inputFile, input) {}
+  int ReadFuncProfile(MplProfileData *profData);
+};
+
+class MplProfDataParser : public AnalysisResult {
+ public:
+  MplProfDataParser(MIRModule &mirmod, MemPool *mp, bool debug)
+      : AnalysisResult(mp), m(mirmod), alloc(memPool), mempool(mp), dumpDetail(debug) {}
+  ~MplProfDataParser() = default;
+  MplProfileData *GetProfData() {
+    return profData;
+  }
+  int ReadMapleProfileData();
+
+ private:
+  MIRModule &m;
+  MapleAllocator alloc;
+  MemPool *mempool;
+  MplProfileData *profData = nullptr;
+  bool dumpDetail = false;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(MMplProfDataParser)
+
+}  // end of namespace maple
+
+#endif  // MAPLE_MPL2MPL_INCLUDE_GCOVPROFUSE_H
diff --git a/src/mapleall/mpl2mpl/include/muid_replacement.h b/src/mapleall/mpl2mpl/include/muid_replacement.h
new file mode 100644
index 0000000000000000000000000000000000000000..382ac44468f48e8a07fbb260596a2a4179b97711
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/muid_replacement.h
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_MUID_REPLACEMENT_H
+#define MPL2MPL_INCLUDE_MUID_REPLACEMENT_H
+#include "phase_impl.h"
+#include "muid.h"
+#include "version.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+// For func def table.
+constexpr uint32 kFuncDefAddrIndex = 0;
+// For data def table.
+constexpr uint32 kDataDefAddrIndex = 0;
+// For func def info. table.
+constexpr uint32 kFuncDefSizeIndex = 0;
+constexpr uint32 kFuncDefNameIndex = 1;
+constexpr uint32 kRangeBeginIndex = 0;
+constexpr int32_t kDecoupleAndLazy = 3;
+constexpr uint32_t kShiftBit16 = 16;
+constexpr uint32_t kShiftBit15 = 15;
+
+enum RangeIdx {
+  // 0,1 entry is reserved for a stamp
+  kVtabAndItab = 2,
+  kItabConflict = 3,
+  kVtabOffset = 4,
+  kFieldOffset = 5,
+  kValueOffset = 6,
+  kLocalClassInfo = 7,
+  kConststr = 8,
+  kSuperclass = 9,
+  kGlobalRootlist = 10,
+  kClassmetaData = 11,
+  kClassBucket = 12,
+  kJavatext = 13,
+  kJavajni = 14,
+  kJavajniFunc = 15,
+  kOldMaxNum = 16, // Old num
+  kDataSection = 17,
+  kDecoupleStaticKey = 18,
+  kDecoupleStaticValue = 19,
+  kBssStart = 20,
+  kLinkerSoHash = 21,
+  kArrayClassCache = 22,
+  kArrayClassCacheName = 23,
+  kNewMaxNum = 24 // New num
+};
+
+struct SourceFileMethod {
+  uint32 sourceFileIndex;
+  uint32 sourceClassIndex;
+  uint32 sourceMethodIndex;
+  bool isVirtual;
+};
+
+struct SourceFileField {
+  uint32 sourceFileIndex;
+  uint32 sourceClassIndex;
+  uint32 sourceFieldIndex;
+};
+
+class MUIDReplacement : public FuncOptimizeImpl {
+ public:
+  MUIDReplacement(MIRModule &mod, KlassHierarchy *kh, bool dump);
+  ~MUIDReplacement() = default;
+
+  FuncOptimizeImpl *Clone() override {
+    return new MUIDReplacement(*this);
+  }
+
+  void ProcessFunc(MIRFunction *func) override;
+
+  static void SetMplMd5(MUID muid) {
+    mplMuid = muid;
+  }
+
+  static MUID &GetMplMd5() {
+    return mplMuid;
+  }
+
+ private:
+  using SymIdxPair = std::pair<MIRSymbol*, uint32>;
+  using SourceIndexPair = std::pair<uint32, uint32>;
+  enum LazyBindingOption : uint32 {
+    kNoLazyBinding = 0,
+    kConservativeLazyBinding = 1,
+    kRadicalLazyBinding = 2
+  };
+
+  void InitRangeTabUseSym(std::vector<MIRSymbol*> &workList, MIRStructType &rangeTabEntryType,
+                          MIRAggConst &rangeTabConst);
+  void GenerateTables();
+  void GenerateFuncDefTable();
+  void GenerateDataDefTable();
+  void GenerateUnifiedUndefTable();
+  void GenerateRangeTable();
+  uint32 FindIndexFromDefTable(const MIRSymbol &mirSymbol, bool isFunc);
+  uint32 FindIndexFromUndefTable(const MIRSymbol &mirSymbol, bool isFunc);
+  void ReplaceAddroffuncConst(MIRConst *&entry, uint32 fieldID, bool isVtab);
+  void ReplaceFuncTable(const std::string &name);
+  void ReplaceAddrofConst(MIRConst *&entry, bool muidIndex32Mod = false);
+  void ReplaceDataTable(const std::string &name);
+  void ReplaceDirectInvokeOrAddroffunc(MIRFunction &currentFunc, StmtNode &stmt);
+  void ReplaceDassign(MIRFunction &currentFunc, const DassignNode &dassignNode);
+  void ReplaceDreadStmt(MIRFunction *currentFunc, StmtNode *stmt);
+  void ClearVtabItab(const std::string &name);
+  void ReplaceDecoupleKeyTable(MIRAggConst *oldConst);
+  void ReplaceFieldTypeTable(const std::string &name);
+  BaseNode *ReplaceDreadExpr(MIRFunction *currentFunc, StmtNode *stmt, BaseNode *expr);
+  BaseNode *ReplaceDread(MIRFunction &currentFunc, const StmtNode *stmt, BaseNode *opnd);
+  void CollectFieldCallSite();
+  void CollectDreadStmt(MIRFunction *currentFunc, BlockNode *block, StmtNode *stmt);
+  BaseNode *CollectDreadExpr(MIRFunction *currentFunc, BlockNode &block, StmtNode *stmt, BaseNode *expr);
+  void CollectDread(MIRFunction &currentFunc, StmtNode &stmt, BaseNode &opnd);
+  void DumpMUIDFile(bool isFunc);
+  void ReplaceStmts();
+  void GenerateGlobalRootList();
+  void CollectImplicitUndefClassInfo(StmtNode &stmt);
+  void CollectFuncAndData();
+  void InsertFunctionProfile(MIRFunction &currentFunc, int64 index);
+  void GenericSourceMuid();
+  void GenCompilerMfileStatus();
+  bool FindFuncNameInSimplfy(const std::string &name);
+  bool CheckFunctionIsUsed(const MIRFunction &mirFunc) const;
+  void ReplaceMethodMetaFuncAddr(const MIRSymbol &funcSymbol, int64 index);
+  void ReplaceFieldMetaStaticAddr(const MIRSymbol &mirSymbol, uint32 index);
+  void CollectFuncAndDataFromKlasses();
+  void CollectFuncAndDataFromGlobalTab();
+  void CollectFuncAndDataFromFuncList();
+  void GenerateCompilerVersionNum();
+  int64 GetDefOrUndefOffsetWithMask(uint64, bool isDef, bool muidIndex32Mod = false) const;
+  void CollectSuperClassArraySymbolData();
+  void GenerateSourceInfo();
+  static MIRSymbol *GetSymbolFromName(const std::string &name);
+  ConstvalNode* GetConstvalNode(int64 index);
+  void InsertArrayClassSet(const MIRType &type);
+  MIRType *GetIntrinsicConstArrayClass(StmtNode &stmt);
+  void CollectArrayClass();
+  void GenArrayClassCache();
+  void ReleasePragmaMemPool();
+  std::unordered_set<std::string> arrayClassSet;
+  // The following sets are for internal uses. Sorting order does not matter here.
+  std::unordered_set<MIRFunction*> funcDefSet;
+  std::unordered_set<MIRFunction*> funcUndefSet;
+  std::unordered_set<MIRSymbol*> dataDefSet;
+  std::unordered_set<MIRSymbol*> dataUndefSet;
+  std::unordered_set<MIRSymbol*> superClassArraySymbolSet;
+  void AddDefFunc(MIRFunction *func) {
+    funcDefSet.insert(func);
+  }
+
+  void AddUndefFunc(MIRFunction *func) {
+    funcUndefSet.insert(func);
+  }
+
+  void AddDefData(MIRSymbol *sym) {
+    dataDefSet.insert(sym);
+  }
+
+  void AddUndefData(MIRSymbol *sym) {
+    dataUndefSet.insert(sym);
+  }
+
+#define __MRT_MAGIC_PASTE(x, y) __MRT_MAGIC_PASTE2(x, y)
+#define __MRT_MAGIC_PASTE2(x, y) x##y
+#define CLASS_PREFIX(classname) TO_STR(__MRT_MAGIC_PASTE(CLASSINFO_PREFIX, classname)),
+  const std::unordered_set<std::string> preloadedClassInfo = {
+#include "white_list.def"
+  };
+#undef CLASS_PREFIX
+#undef __MRT_MAGIC_PASTE2
+#undef __MRT_MAGIC_PASTE
+  const std::unordered_set<std::string> reflectionList = {
+#include "reflection_list.def"
+  };
+  bool isLibcore = false;
+  MIRSymbol *funcDefTabSym = nullptr;
+  MIRSymbol *funcDefOrigTabSym = nullptr;
+  MIRSymbol *funcInfTabSym = nullptr;
+  MIRSymbol *funcUndefTabSym = nullptr;
+  MIRSymbol *dataDefTabSym = nullptr;
+  MIRSymbol *dataDefOrigTabSym = nullptr;
+  MIRSymbol *dataUndefTabSym = nullptr;
+  MIRSymbol *funcDefMuidTabSym = nullptr;
+  MIRSymbol *funcUndefMuidTabSym = nullptr;
+  MIRSymbol *dataDefMuidTabSym = nullptr;
+  MIRSymbol *dataUndefMuidTabSym = nullptr;
+  MIRSymbol *funcMuidIdxTabSym = nullptr;
+  MIRSymbol *rangeTabSym = nullptr;
+  MIRSymbol *funcProfileTabSym = nullptr;
+  MIRSymbol *funcProfInfTabSym = nullptr;
+  std::map<MUID, SymIdxPair> funcDefMap;
+  std::map<MUID, SymIdxPair> dataDefMap;
+  std::map<MUID, SymIdxPair> funcUndefMap;
+  std::map<MUID, SymIdxPair> dataUndefMap;
+  std::map<MUID, uint32> defMuidIdxMap;
+  std::map<MUID, SourceIndexPair> sourceIndexMap;
+  std::map<MUID, const SourceFileMethod> sourceFileMethodMap;
+  std::map<MUID, const SourceFileField> sourceFileFieldMap;
+  static MUID mplMuid;
+  std::string mplMuidStr;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MMuidReplacement)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_MUID_REPLACEMENT_H
diff --git a/src/mapleall/mpl2mpl/include/native_stub_func.h b/src/mapleall/mpl2mpl/include/native_stub_func.h
new file mode 100644
index 0000000000000000000000000000000000000000..a54f938cd3d67f20d4be0e304bad5d16d6006ac6
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/native_stub_func.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_NATIVE_STUB_FUNC_H
+#define MPL2MPL_INCLUDE_NATIVE_STUB_FUNC_H
+#include "phase_impl.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+#ifdef USE_ARM32_MACRO
+constexpr int kSlownativeFuncnum = 5;
+#else
+constexpr int kSlownativeFuncnum = 9;
+#endif
+// May not use Env or ClassObj
+constexpr int kJniTypeNormal = 0;
+// Not equal to real critical native, but no need for pre/post/eh.
+// Need SetReliableUnwindContext, because the native code may call other java code
+constexpr int kJniTypeMapleCriticalNative = 1;
+// Equal to real critical native, func will be set critical attribute.
+// In theory it's incorrect because passing incorrect args. Ex. Linux.getuid
+constexpr int kJniTypeCriticalNative = 2;
+// Equal to critical native but need to pass env and classObj. Ex. Character.isDigitImpl
+constexpr int kJniTypeCriticalNeedArg = 3;
+constexpr int kInvalidCode = 0x01;
+
+class NativeFuncProperty {
+ public:
+  NativeFuncProperty() = default;
+  ~NativeFuncProperty() = default;
+
+ private:
+  std::string javaFunc;
+  std::string nativeFile;
+  std::string nativeFunc;
+  int jniType = kJniTypeNormal;
+  int useEnv = 1;
+  int useClassObj = 1;
+
+  friend class NativeStubFuncGeneration;
+};
+
+class NativeStubFuncGeneration : public FuncOptimizeImpl {
+ public:
+  NativeStubFuncGeneration(MIRModule &mod, KlassHierarchy *kh, bool dump);
+  ~NativeStubFuncGeneration() = default;
+
+  void ProcessFunc(MIRFunction *func) override;
+  void Finish() override;
+  FuncOptimizeImpl *Clone() override {
+    return new NativeStubFuncGeneration(*this);
+  }
+
+ private:
+  bool IsStaticBindingListMode() const;
+  bool ReturnsJstr(TyIdx retType) {
+    return retType == jstrPointerTypeIdx;
+  }
+  void InitStaticBindingMethodList();
+  bool IsStaticBindingMethod(const std::string &methodName) const;
+  void LoadNativeFuncProperty();
+  bool GetNativeFuncProperty(const std::string &funcName, NativeFuncProperty &property);
+  MIRFunction &GetOrCreateDefaultNativeFunc(MIRFunction &stubFunc);
+  void GenerateRegisteredNativeFuncCall(MIRFunction &func, const MIRFunction &nativeFunc, MapleVector<BaseNode*> &args,
+                                        const MIRSymbol *ret);
+  StmtNode *CreateNativeWrapperCallNode(MIRFunction &func, BaseNode *funcPtr, MapleVector<BaseNode*> &args,
+                                        const MIRSymbol *ret, bool needIndirectCall);
+  void GenerateNativeWrapperFuncCall(MIRFunction &func, const MIRFunction &nativeFunc, MapleVector<BaseNode*> &args,
+                                     const MIRSymbol *ret);
+  void GenerateHelperFuncDecl();
+  void GenerateRegTabEntry(const MIRFunction &func);
+  void GenerateRegTableEntryType();
+  void GenerateRegTable();
+  void GenerateRegFuncTabEntryType();
+  void GenerateRegFuncTabEntry();
+  void GenerateRegFuncTab();
+  std::unordered_map<std::string, NativeFuncProperty> nativeFuncPropertyMap;
+  // a static binding function list
+  std::unordered_set<std::string> staticBindingMethodsSet;
+  TyIdx jstrPointerTypeIdx = TyIdx(0);
+  MIRAggConst *regTableConst = nullptr;
+  MIRSymbol *regFuncSymbol = nullptr;
+  MIRAggConst *regFuncTabConst = nullptr;
+  MIRFunction *MRTPreNativeFunc = nullptr;
+  MIRFunction *MRTPostNativeFunc = nullptr;
+  MIRFunction *MRTDecodeRefFunc = nullptr;
+  MIRFunction *MRTCheckThrowPendingExceptionFunc = nullptr;
+  MIRFunction *MRTCallSlowNativeFunc[kSlownativeFuncnum] = { nullptr };  // for native func which args <=8, use x0-x7
+  MIRFunction *MRTCallSlowNativeExtFunc = nullptr;
+  MIRFunction *MCCSetReliableUnwindContextFunc = nullptr;
+  static const std::string callSlowNativeFuncs[kSlownativeFuncnum];
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MGenerateNativeStubFunc)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_NATIVE_STUB_FUNC_H
diff --git a/src/mapleall/mpl2mpl/include/openProfile.h b/src/mapleall/mpl2mpl/include/openProfile.h
new file mode 100644
index 0000000000000000000000000000000000000000..53af193358f7c8d24517f228d9684658300b006d
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/openProfile.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_MPL2MPL_INCLUDE_OPENPROFILE_H
+#define MAPLE_MPL2MPL_INCLUDE_OPENPROFILE_H
+#include "module_phase_manager.h"
+
+namespace maple {
+MAPLE_MODULE_PHASE_DECLARE(M2MOpenprofile)
+}  // namespace maple
+#endif  // MAPLE_MPL2MPL_INCLUDE_OPENPROFILE_H
diff --git a/src/mapleall/mpl2mpl/include/outline.h b/src/mapleall/mpl2mpl/include/outline.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd29eb678ca8868a0d0383d0a3b9c77720c9d7b7
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/outline.h
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_OUTLINE_H
+#define MPL2MPL_INCLUDE_OUTLINE_H
+#include "mir_builder.h"
+#include "ipa_collect.h"
+#include "region_identify.h"
+
+namespace maple {
+class OutlineCandidate {
+ public:
+  explicit OutlineCandidate(RegionCandidate *candidate) : regionCandidate(candidate) {}
+  virtual ~OutlineCandidate() = default;
+
+  size_t InsertIntoParameterList(BaseNode &expr);
+
+  RegionCandidate *GetRegionCandidate() {
+    return regionCandidate;
+  }
+
+  std::vector<BaseNode*> &GetParameters() {
+    return parameters;
+  }
+
+  std::vector<BaseNode*> &GetRegionValueNumberToSrcExprMap() {
+    return valueNumberToConstexpr;
+  }
+
+  std::unordered_map<BaseNode*, size_t> &GetExprToParameterIndexMap() {
+    return exprToParameterIndex;
+  }
+
+  std::unordered_map<StIdx, size_t> &GetStIdxToParameterIndexMap() {
+    return stIdxToParameterIndex;
+  }
+
+  std::unordered_map<BaseNode*, StmtNode*> &GetReplacedStmtMap() {
+    return replacedStmtMap;
+  }
+
+  void Dump() {
+    regionCandidate->GetFunction()->SetCurrentFunctionToThis();
+    for (auto *parameter : parameters) {
+      LogInfo::MapleLogger() << "input: ";
+      parameter->Dump();
+    }
+    regionCandidate->Dump();
+  }
+
+  BaseNode *GetReturnExpr() {
+    return returnValue;
+  }
+
+  void CreateReturnExpr(SymbolRegPair &outputPair) {
+    if (returnValue != nullptr) {
+      return;
+    }
+    auto *function = regionCandidate->GetFunction();
+    function->GetModule()->SetCurFunction(function);
+    auto *builder = function->GetModule()->GetMIRBuilder();
+    if (outputPair.second != 0) {
+      auto pregIdx = outputPair.second;
+      returnValue = builder->CreateExprRegread(function->GetPregItem(pregIdx)->GetPrimType(), pregIdx);
+    } else {
+      returnValue = builder->CreateExprDread(*function->GetSymbolTabItem(outputPair.first.Idx()));
+    }
+  }
+
+ private:
+  RegionCandidate *regionCandidate;
+  BaseNode *returnValue = nullptr;
+  std::vector<BaseNode*> valueNumberToConstexpr;
+  std::vector<BaseNode*> parameters;
+  std::unordered_map<BaseNode*, size_t> exprToParameterIndex;
+  std::unordered_map<StIdx, size_t> stIdxToParameterIndex;
+  std::unordered_map<BaseNode*, StmtNode*> replacedStmtMap;
+};
+
+class OutlineGroup {
+ public:
+  explicit OutlineGroup(RegionGroup &group) : groupId(group.GetGroupId()) {
+    for (auto &region : group.GetGroups()) {
+      regionGroup.emplace_back(&region);
+    }
+  }
+  virtual ~OutlineGroup() = default;
+
+  void PrepareParameterLists() {
+    CollectOutlineInfo();
+    PrepareExtraParameterLists();
+  }
+
+  void ReplaceOutlineRegions() {
+    ReplaceOutlineCandidateWithCall();
+    CompleteOutlineFunction();
+    EraseOutlineRegion();
+  }
+
+  std::vector<OutlineCandidate> &GetOutlineRegions() {
+    return regionGroup;
+  }
+
+  void SetOutlineFunction(MIRFunction *func) {
+    outlineFunc = func;
+  }
+
+  MIRFunction *GetOutlineFunction() {
+    return outlineFunc;
+  }
+
+  size_t GetParameterSize() {
+    return regionGroup.front().GetParameters().size();
+  }
+
+  void Dump() {
+    LogInfo::MapleLogger() << "region group: " << groupId << "\n";
+    LogInfo::MapleLogger() << "region number: " << regionGroup.size() << "\n";
+    for (auto &region : regionGroup) {
+      region.Dump();
+    }
+  }
+
+ private:
+  void CollectOutlineInfo();
+  void PrepareExtraParameterLists();
+  void ReplaceOutlineCandidateWithCall();
+  void CompleteOutlineFunction();
+  void EraseOutlineRegion();
+
+  std::vector<OutlineCandidate> regionGroup;
+  std::vector<BaseNode*> parameterList;
+  std::vector<uint32> extraParameterValueNumber;
+  MIRFunction *outlineFunc;
+  GroupId groupId;
+};
+
+class OutLine {
+ public:
+  OutLine(CollectIpaInfo *ipaInfo, MIRModule *module, MemPool *memPool) :
+    ipaInfo(ipaInfo), module(module), memPool(memPool) {}
+  virtual ~OutLine() = default;
+  void Run();
+ private:
+  MIRFunction *CreateNewOutlineFunction(PrimType returnType);
+  void PruneCandidateRegionsOverlapWithOutlinedRegion(RegionGroup &group);
+  void DoOutline(OutlineGroup &outlineGroup);
+  CollectIpaInfo *ipaInfo;
+  MIRModule *module;
+  MemPool *memPool;
+  uint32 newFuncIndex = 0;
+  std::vector<RegionCandidate*> outlinedRegion;
+};
+MAPLE_MODULE_PHASE_DECLARE(M2MOutline)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_OUTLINE_H
diff --git a/src/mapleall/mpl2mpl/include/preme.h b/src/mapleall/mpl2mpl/include/preme.h
new file mode 100644
index 0000000000000000000000000000000000000000..382cb665c6d50672657dda22523e43c188578c5b
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/preme.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_PREME_H
+#define MPL2MPL_INCLUDE_PREME_H
+#include "phase_impl.h"
+#include "me_option.h"
+
+namespace maple {
+class Preme : public FuncOptimizeImpl {
+ public:
+  Preme(MIRModule &mod, KlassHierarchy *kh, bool dump) : FuncOptimizeImpl(mod, kh, dump) {}
+  ~Preme() = default;
+  // Create global symbols and functions here when iterating mirFunc is needed
+  void ProcessFunc(MIRFunction *func) override;
+  FuncOptimizeImpl *Clone() override {
+    return new Preme(*this);
+  }
+  static void CreateMIRTypeForLowerGlobalDreads();
+
+ private:
+  void CreateMIRTypeForAddrof(const MIRFunction &func, const BaseNode *baseNode) const;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MPreme)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_PREME_H
diff --git a/src/mapleall/mpl2mpl/include/rcwhitelist.def b/src/mapleall/mpl2mpl/include/rcwhitelist.def
new file mode 100644
index 0000000000000000000000000000000000000000..610ad9f5588f343893fd7c648a57802d1961cf14
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/rcwhitelist.def
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+  "Landroid_2Futil_2FArraySet_3B_7CindexOf_7C_28Ljava_2Flang_2FObject_3BI_29I", //#1124
+  "Landroid_2Futil_2FArraySet_3B_7CvalueAtUnchecked_7C_28I_29Ljava_2Flang_2FObject_3B",
+  "Landroid_2Futil_2FArraySet_3B_7CindexOfNull_7C_28_29I",
+  "Landroid_2Futil_2FArrayMap_3B_7Cget_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B", //#797
+  "Landroid_2Futil_2FArrayMap_3B_7CindexOf_7C_28Ljava_2Flang_2FObject_3BI_29I", //#794
+  "Landroid_2Futil_2FArrayMap_3B_7CkeyAt_7C_28I_29Ljava_2Flang_2FObject_3B", //#803
+  "Landroid_2Futil_2FArrayMap_3B_7CvalueAt_7C_28I_29Ljava_2Flang_2FObject_3B", //#806
+  "Landroid_2Futil_2FSparseArray_3B_7Cget_7C_28ILjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B", //#799
+  "Landroid_2Futil_2FSparseArray_3B_7CvalueAt_7C_28I_29Ljava_2Flang_2FObject_3B", //#817
+  "Landroid_2Futil_2FSparseArray_3B_7Cdelete_7C_28I_29V",
+  "Landroid_2Futil_2FSparseArray_3B_7CindexOfValue_7C_28Ljava_2Flang_2FObject_3B_29I",
+  "Landroid_2Futil_2FSparseArray_3B_7CindexOfValueByValue_7C_28Ljava_2Flang_2FObject_3B_29I",
+  "Landroid_2Futil_2FSparseArray_3B_7CindexOfKey_7C_28I_29I",
+  "Landroid_2Futil_2FSparseArray_3B_7Cput_7C_28ILjava_2Flang_2FObject_3B_29V",
+  "Ljava_2Futil_2FArrayList_3B_7Cget_7C_28I_29Ljava_2Flang_2FObject_3B", //#748
+  "Ljava_2Futil_2FArrayList_3B_7CindexOf_7C_28Ljava_2Flang_2FObject_3B_29I",
+  "Ljava_2Futil_2FArrayList_3B_7ClastIndexOf_7C_28Ljava_2Flang_2FObject_3B_29I",
+  "Ljava_2Futil_2FArrayList_3B_7Cremove_7C_28Ljava_2Flang_2FObject_3B_29Z",
+  "Ljava_2Futil_2FHashMap_24TreeNode_3B_7Cfind_7C_28ILjava_2Flang_2FObject_3BLjava_2Flang_2FClass_3B_29Ljava_2Futil_2FHashMap_24TreeNode_3B", //#770
+  "Landroid_2Fos_2FMessageQueue_3B_7CenqueueMessage_7C_28Landroid_2Fos_2FMessage_3BJ_29Z", //#2227
+  "Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B_7CgetIntPropertyValue_7C_28II_29I", // #2899
+  "Lcom_2Fandroid_2Fserver_2Fpm_2Fpermission_2FPermissionsState_3B_7ChasPermission_7C_28Ljava_2Flang_2FString_3BI_29Z",
+  "Lcom_2Fandroid_2Fserver_2Fpm_2Fpermission_2FPermissionsState_24PermissionData_3B_7CisGranted_7C_28I_29Z",
+  "Lcom_2Fandroid_2Fserver_2Fpm_2Fpermission_2FPermissionsState_24PermissionData_3B_7CisInstallPermission_7C_28_29Z",
+  "Ljava_2Futil_2FIdentityHashMap_3B_7Cget_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B"
diff --git a/src/mapleall/mpl2mpl/include/reflection_analysis.h b/src/mapleall/mpl2mpl/include/reflection_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cec4286366658017a74390c3dc978235d883eb9
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/reflection_analysis.h
@@ -0,0 +1,310 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_REFLECTION_ANALYSIS_H
+#define MPL2MPL_INCLUDE_REFLECTION_ANALYSIS_H
+#include "class_hierarchy_phase.h"
+
+namespace maple {
+// maple field index definition
+enum class ClassRO : uint32 {
+  kClassName,
+  kIfields,
+  kMethods,
+  kSuperclass,
+  kNumOfFields,
+  kNumofMethods,
+#ifndef USE_32BIT_REF
+  kFlag,
+  kNumOfSup,
+  kPadding,
+#endif  //! USE_32BIT_REF
+  kMod,
+  kAnnotation,
+  kClinitAddr
+};
+
+enum StaticFieldName {
+  kClassName = 0,
+  kFieldName = 1,
+  kTypeName = 2,
+};
+
+enum class ClassProperty : uint32 {
+  kShadow,
+  kMonitor,
+  kClassloader,
+  kObjsize,
+#ifdef USE_32BIT_REF
+  FLAG,
+  NUMOFSUP,
+#endif  // USE_32BIT_REF
+  kItab,
+  kVtab,
+  kGctib,
+  kInfoRo,
+#ifdef USE_32BIT_REF
+  kInstanceOfCacheFalse,
+#endif
+  kClint
+};
+
+enum class MethodProperty : uint32 {
+  kVtabIndex,
+  kDeclarclass,
+  kPaddrData,
+  kMod,
+  kMethodName,
+  kSigName,
+  kAnnotation,
+  kFlag,
+  kArgsize,
+#ifndef USE_32BIT_REF
+  padding
+#endif
+};
+
+enum class MethodInfoCompact : uint32 {
+  kVtabIndex,
+  kPaddrData
+};
+
+enum class FieldProperty : uint32 {
+  kPOffset,
+  kMod,
+  kFlag,
+  kIndex,
+  kTypeName,
+  kName,
+  kAnnotation,
+  kDeclarclass,
+  kPClassType
+};
+
+enum class FieldPropertyCompact : uint32 {
+  kPOffset,
+  kMod,
+  kTypeName,
+  kIndex,
+  kName,
+  kAnnotation
+};
+
+enum class MethodSignatureProperty : uint32 {
+  kSignatureOffset,
+  kParameterTypes
+};
+
+class ReflectionAnalysis : public AnalysisResult {
+ public:
+  ReflectionAnalysis(MIRModule *mod, MemPool *memPool, KlassHierarchy *kh, MIRBuilder &builder)
+      : AnalysisResult(memPool),
+        mirModule(mod),
+        allocator(memPool),
+        klassH(kh),
+        mirBuilder(builder),
+        classTab(allocator.Adapter()),
+        isLibcore(false),
+        isLazyBindingOrDecouple(false) {
+    Klass *objectKlass = kh->GetKlassFromLiteral(namemangler::kJavaLangObjectStr);
+    if (objectKlass != nullptr && objectKlass->GetMIRStructType()->IsLocal()) {
+      isLibcore = true;
+    }
+  }
+  ~ReflectionAnalysis() = default;
+
+  static void GenStrTab(MIRModule &module);
+  static uint32 FindOrInsertRepeatString(const std::string &str, bool isHot = false, uint8 hotType = kLayoutUnused);
+  static BaseNode *GenClassInfoAddr(BaseNode *obj, MIRBuilder &builder);
+  void Run();
+  static void ConvertMethodSig(std::string &signature);
+  static TyIdx GetClassMetaDataTyIdx() {
+    return classMetadataTyIdx;
+  }
+  void DumpPGOSummary();
+
+ private:
+  static std::unordered_map<std::string, uint32> &GetStr2IdxMap() {
+    return str2IdxMap;
+  }
+
+  static void SetStr2IdxMap(const std::string &str, uint32 index) {
+    str2IdxMap[str] = index;
+  }
+
+  static const std::string &GetStrTab() {
+    return strTab;
+  }
+
+  static const std::string &GetStrTabStartHot() {
+    return strTabStartHot;
+  }
+
+  static const std::string &GetStrTabBothHot() {
+    return strTabBothHot;
+  }
+
+  static const std::string &GetStrTabRunHot() {
+    return strTabRunHot;
+  }
+
+  static void AddStrTab(const std::string &str) {
+    strTab += str;
+  }
+
+  static void AddStrTabStartHot(const std::string &str) {
+    strTabStartHot += str;
+  }
+
+  static void AddStrTabBothHot(const std::string &str) {
+    strTabBothHot += str;
+  }
+
+  static void AddStrTabRunHot(const std::string &str) {
+    strTabRunHot += str;
+  }
+
+  static uint32 FirstFindOrInsertRepeatString(const std::string &str, bool isHot, uint8 hotType);
+  MIRSymbol *GetOrCreateSymbol(const std::string &name, TyIdx tyIdx, bool needInit);
+  MIRSymbol *GetSymbol(const std::string &name, TyIdx tyIdx);
+  MIRSymbol *CreateSymbol(GStrIdx strIdx, TyIdx tyIdx);
+  MIRSymbol *GetSymbol(GStrIdx strIdx, TyIdx tyIdx);
+  void GenClassMetaData(Klass &klass);
+  std::string GetAnnoValueNoArray(const MIRPragmaElement &annoElem);
+  std::string GetArrayValue(const MapleVector<MIRPragmaElement*> &subElemVector);
+  std::string GetAnnotationValue(const MapleVector<MIRPragmaElement*> &subElemVector, GStrIdx typeStrIdx);
+  MIRSymbol *GenSuperClassMetaData(std::list<Klass*> superClassList);
+  MIRSymbol *GenFieldOffsetData(const Klass &klass, const std::pair<FieldPair, int> &fieldInfo);
+  MIRSymbol *GetMethodSignatureSymbol(std::string signature);
+  MIRSymbol *GetParameterTypesSymbol(uint32 size, uint32 index);
+  MIRSymbol *GenFieldsMetaData(const Klass &klass, bool isHot);
+  MIRSymbol *GenMethodsMetaData(const Klass &klass, bool isHot);
+  MIRSymbol *GenFieldsMetaCompact(const Klass &klass, std::vector<std::pair<FieldPair, int>> &fieldsVector);
+  void GenFieldMetaCompact(const Klass &klass, MIRStructType &fieldsInfoCompactType,
+                           const std::pair<FieldPair, int> &fieldInfo,
+                           MIRAggConst &aggConstCompact);
+  void GenMethodMetaCompact(const Klass &klass, MIRStructType &methodsInfoType, int idx,
+                            const MIRSymbol &funcSym, MIRAggConst &aggConst,
+                            int &allDeclaringClassOffset,
+                            std::unordered_map<uint32, std::string> &baseNameMp,
+                            std::unordered_map<uint32, std::string> &fullNameMp);
+  MIRSymbol *GenMethodsMetaCompact(const Klass &klass,
+                                   std::vector<std::pair<MethodPair*, int>> &methodInfoVec,
+                                   std::unordered_map<uint32, std::string> &baseNameMp,
+                                   std::unordered_map<uint32, std::string> &fullNameMp);
+  MIRSymbol *GenFieldsMeta(const Klass &klass, std::vector<std::pair<FieldPair, int>> &fieldsVector,
+                           const std::vector<std::pair<FieldPair, uint16>> &fieldHashvec);
+  void GenFieldMeta(const Klass &klass, MIRStructType &fieldsInfoType,
+                    const std::pair<FieldPair, int> &fieldInfo, MIRAggConst &aggConst,
+                    int idx, const std::vector<std::pair<FieldPair, uint16>> &fieldHashVec);
+  MIRSymbol *GenMethodsMeta(const Klass &klass, std::vector<std::pair<MethodPair*, int>> &methodInfoVec,
+                            std::unordered_map<uint32, std::string> &baseNameMp,
+                            std::unordered_map<uint32, std::string> &fullNameMp);
+  void GenMethodMeta(const Klass &klass, MIRStructType &methodsInfoType,
+                     const MIRSymbol &funcSym, MIRAggConst &aggConst, int idx,
+                     std::unordered_map<uint32, std::string> &baseNameMp,
+                     std::unordered_map<uint32, std::string> &fullNameMp);
+  uint32 GetMethodModifier(const Klass &klass, const MIRFunction &func) const;
+  uint32 GetMethodFlag(const MIRFunction &func) const;
+  void GenFieldOffsetConst(MIRAggConst &newConst, const Klass &klass, const MIRStructType &type,
+                           const std::pair<FieldPair, int> &fieldInfo, uint32 metaFieldID);
+  MIRSymbol *GenMethodAddrData(const MIRSymbol &funcSym);
+  static void GenMetadataType(MIRModule &module);
+  static MIRType *GetRefFieldType();
+  static TyIdx GenMetaStructType(MIRModule &module, MIRStructType &metaType, const std::string &str);
+  uint32 GetHashIndex(const std::string &strName);
+  static void GenHotClassNameString(const Klass &klass);
+  uint32 FindOrInsertReflectString(const std::string &str);
+  static void InitReflectString();
+  uint32 BKDRHash(const std::string &strName, uint32 seed);
+  void GenClassHashMetaData();
+  void MarkWeakMethods();
+
+  bool VtableFunc(const MIRFunction &func) const;
+  void GenPrimitiveClass();
+  void GenAllMethodHash(std::vector<std::pair<MethodPair*, int>> &methodInfoVec,
+                        std::unordered_map<uint32, std::string> &baseNameMap,
+                        std::unordered_map<uint32, std::string> &fullNameMap);
+  void GenAllFieldHash(std::vector<std::pair<FieldPair, uint16>> &fieldV) const;
+  void GenAnnotation(std::map<int, int> &idxNumMap, std::string &annoArr, MIRStructType &classType,
+                      PragmaKind paragKind, const std::string &paragName, TyIdx fieldTypeIdx,
+                      std::map<int, int> *paramNumArray = nullptr, int *paramIndex = nullptr);
+  void AppendValueByType(std::string &annoArr, const MIRPragmaElement &elem);
+  bool IsAnonymousClass(const std::string &annotationString);
+  bool IsLocalClass(const std::string annotationString);
+  bool IsPrivateClass(const MIRClassType &classType) const;
+  bool IsStaticClass(const MIRStructType &classType) const;
+  int8 JudgePara(MIRStructType &ctype);
+  void CheckPrivateInnerAndNoSubClass(Klass &clazz, const std::string &annoArr);
+  void ConvertMapleClassName(const std::string &mplClassName, std::string &javaDsp);
+
+  int GetDeflateStringIdx(const std::string &subStr, bool needSpecialFlag);
+  uint32 GetAnnoCstrIndex(std::map<int, int> &idxNumMap, const std::string &annoArr, bool isField);
+  uint16 GetMethodInVtabIndex(const Klass &clazz, const MIRFunction &func) const;
+  void GetSignatureTypeNames(std::string &signature, std::vector<std::string> &typeNames);
+  MIRSymbol *GetClinitFuncSymbol(const Klass &klass);
+  int SolveAnnotation(MIRStructType &classType, const MIRFunction &func);
+  uint32 GetTypeNameIdxFromType(const MIRType &type, const Klass &klass, const std::string &fieldName);
+  bool IsMemberClass(const std::string &annotationString);
+  int8_t GetAnnoFlag(const std::string &annotationString);
+  void GenFieldTypeClassInfo(const MIRType &type, const Klass &klass, std::string &classInfo,
+                             const std::string fieldName, bool &isClass);
+
+  MIRModule *mirModule;
+  MapleAllocator allocator;
+  KlassHierarchy *klassH;
+  MIRBuilder &mirBuilder;
+  MapleVector<MIRSymbol*> classTab;
+  std::map<std::string, MIRSymbol*>mapMethodSignature;
+  bool isLibcore;
+  bool isLazyBindingOrDecouple;
+  std::string reflectionMuidStr;
+  static const char *klassPtrName;
+  static TyIdx classMetadataTyIdx;
+  static TyIdx classMetadataRoTyIdx;
+  static TyIdx methodsInfoTyIdx;
+  static TyIdx methodsInfoCompactTyIdx;
+  static TyIdx fieldsInfoTyIdx;
+  static TyIdx fieldsInfoCompactTyIdx;
+  static TyIdx superclassMetadataTyIdx;
+  static TyIdx fieldOffsetDataTyIdx;
+  static TyIdx methodAddrDataTyIdx;
+  static TyIdx methodSignatureTyIdx;
+  static std::string strTab;
+  static std::unordered_map<std::string, uint32> str2IdxMap;
+  static std::string strTabStartHot;
+  static std::string strTabBothHot;
+  static std::string strTabRunHot;
+  static bool strTabInited;
+  static TyIdx invalidIdx;
+  static constexpr uint16 kNoHashBits = 6u;
+  // profile statistics
+  static uint32_t hotMethodMeta;
+  static uint32_t totalMethodMeta;
+  static uint32_t hotClassMeta;
+  static uint32_t totalClassMeta;
+  static uint32_t hotFieldMeta;
+  static uint32_t totalFieldMeta;
+  static uint32_t hotCStr;
+  static uint32_t totalCStr;
+  static constexpr char annoDelimiterPrefix = '`';
+  static constexpr char annoDelimiter = '!';
+  static constexpr char annoArrayStartDelimiter = '{';
+  static constexpr char annoArrayEndDelimiter = '}';
+  static std::map<std::list<Klass*>, std::string> superClasesIdxMap;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MReflectionAnalysis)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_REFLECTION_ANALYSIS_H
diff --git a/src/mapleall/mpl2mpl/include/retype.h b/src/mapleall/mpl2mpl/include/retype.h
new file mode 100644
index 0000000000000000000000000000000000000000..22aa8b138757023bae89839b4b8959e2dda40f47
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/retype.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_RETYPE_H
+#define MPL2MPL_INCLUDE_RETYPE_H
+#include "mir_nodes.h"
+#include "inline.h"
+
+namespace maple {
+class Retype {
+ public:
+  Retype(MIRModule *mod, MemPool *memPool) : mirModule(mod), allocator(memPool) {}
+
+  ~Retype() = default;
+
+  void ReplaceRetypeExpr(const BaseNode &opnd);
+  void RetypeStmt(MIRFunction &func);
+  void DoRetype();
+
+ private:
+  MIRModule *mirModule;
+  MapleAllocator allocator;
+  std::map<GStrIdx, MIRAliasVars> reg2varGenericInfo;
+  void TransmitGenericInfo(MIRFunction &func, StmtNode &stmt);
+};
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_RETYPE_H
diff --git a/src/mapleall/mpl2mpl/include/scalarreplacement.h b/src/mapleall/mpl2mpl/include/scalarreplacement.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1298eb85e6fb8b8ec2db08462d6f35c9ec15de8
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/scalarreplacement.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_SCALARREPLACEMENT_H
+#define MPL2MPL_INCLUDE_SCALARREPLACEMENT_H
+#include "phase_impl.h"
+namespace maple {
+using StmtVec = std::vector<StmtNode*>;
+using FldRefMap = std::unordered_map<FieldID, StmtVec>;
+class ScalarReplacement : public FuncOptimizeImpl {
+ public:
+  ScalarReplacement(MIRModule &mod, KlassHierarchy *kh, bool trace) : FuncOptimizeImpl(mod, kh, trace) {}
+
+  ~ScalarReplacement() override {
+    curSym = nullptr;
+    newScalarSym = nullptr;
+  }
+
+  FuncOptimizeImpl *Clone() override {
+    return new ScalarReplacement(*this);
+  }
+
+  void ProcessFunc(MIRFunction *func) override;
+
+ private:
+  MIRSymbol *curSym = nullptr;
+  MIRSymbol *newScalarSym = nullptr;
+  FieldID curFieldid = 0;
+  std::vector<IntrinsiccallNode*> localRefCleanup;
+  std::unordered_map<MIRSymbol*, FldRefMap> localVarMap;
+  template <typename Func>
+  BaseNode *IterateExpr(StmtNode *stmt, BaseNode *expr, Func const &applyFunc);
+  template <typename Func>
+  void IterateStmt(StmtNode *stmt, Func const &applyFunc);
+  BaseNode *MarkDassignDread(StmtNode *stmt, BaseNode *expr);
+  void CollectCandidates();
+  void DumpCandidates() const;
+  bool IsMemsetLocalvar(StmtNode *stmt) const;
+  bool IsSetClass(StmtNode *stmt) const;
+  bool IsCCWriteRefField(StmtNode *stmt) const;
+  bool CanBeReplaced(const StmtVec *refs) const;
+  BaseNode *ReplaceDassignDread(StmtNode *stmt, BaseNode *expr);
+  void AppendLocalRefCleanup(const MIRSymbol *sym);
+  void ReplaceWithScalar(const StmtVec *refs);
+  void FixRCCalls(const StmtVec *refs);
+  void ReplaceLocalVars();
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MScalarReplacement)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_SCALARREPLACEMENT_H
diff --git a/src/mapleall/mpl2mpl/include/scc.h b/src/mapleall/mpl2mpl/include/scc.h
new file mode 100644
index 0000000000000000000000000000000000000000..345cc765f05b22cd77edc3dfecd2cf1be718503f
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/scc.h
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_SCC_H
+#define MPL2MPL_INCLUDE_SCC_H
+#include "base_graph_node.h"
+namespace maple {
+class BaseGraphNode;
+
+template<typename T>
+struct Comparator;
+
+constexpr uint32 kShiftSccUniqueIDNum = 16;
+
+// Note that T is the type of the graph node.
+template<typename T>
+class SCCNode {
+ public:
+  SCCNode(uint32 index, MapleAllocator &alloc)
+      : id(index),
+        nodes(alloc.Adapter()),
+        inScc(alloc.Adapter()),
+        outScc(alloc.Adapter()) {}
+
+  ~SCCNode() = default;
+
+  void AddNode(T *node) {
+    nodes.push_back(node);
+  }
+
+  void Dump() const {
+    LogInfo::MapleLogger() << "SCC " << id << " contains " << nodes.size() << " node(s)\n";
+    for (auto const kIt : nodes) {
+      T *node = kIt;
+      LogInfo::MapleLogger() << "  " << node->GetIdentity() << "\n";
+    }
+  }
+
+  void DumpCycle() const {
+    T *currNode = nodes[0];
+    std::vector<T*> searched;
+    searched.push_back(currNode);
+    std::vector<T*> invalidNodes;
+    std::vector<BaseGraphNode*> outNodes;
+    while (true) {
+      bool findNewOut = false;
+      currNode->GetOutNodes(outNodes);
+      for (auto outIt : outNodes) {
+        auto outNode = static_cast<T*>(outIt);
+        if (outNode->GetSCCNode() == this) {
+          size_t j = 0;
+          for (; j < invalidNodes.size(); ++j) {
+            if (invalidNodes[j] == outNode) {
+              break;
+            }
+          }
+          // Find a invalid node
+          if (j < invalidNodes.size()) {
+            continue;
+          }
+          for (j = 0; j < searched.size(); ++j) {
+            if (searched[j] == outNode) {
+              break;
+            }
+          }
+          if (j == searched.size()) {
+            currNode = outNode;
+            searched.push_back(currNode);
+            findNewOut = true;
+            break;
+          }
+        }
+      }
+      outNodes.clear();
+      if (searched.size() == nodes.size()) {
+        break;
+      }
+      if (!findNewOut) {
+        invalidNodes.push_back(searched[searched.size() - 1]);
+        searched.pop_back();
+        currNode = searched[searched.size() - 1];
+      }
+    }
+    for (auto it = searched.begin(); it != searched.end(); ++it) {
+      LogInfo::MapleLogger() << (*it)->GetIdentity() << '\n';
+    }
+  }
+
+  void Verify() const {
+    CHECK_FATAL(!nodes.empty(), "the size of nodes less than zero");
+    for (T * const &node : nodes) {
+      if (node->GetSCCNode() != this) {
+        CHECK_FATAL(false, "must equal this");
+      }
+    }
+  }
+
+  void Setup() {
+    std::vector<BaseGraphNode*> outNodes;
+    std::vector<BaseGraphNode*> inNodes;
+    for (T * const &node : nodes) {
+      node->GetOutNodes(outNodes);
+      for (auto outIt : outNodes) {
+        auto outNode = static_cast<T*>(outIt);
+        if (outNode == nullptr) {
+          continue;
+        }
+        auto outNodeScc = outNode->GetSCCNode();
+        if (outNodeScc == this) {
+          continue;
+        }
+        outScc.insert(outNodeScc);
+        outNodeScc->inScc.insert(this);
+      }
+      outNodes.clear();
+    }
+  }
+
+  const MapleVector<T*> &GetNodes() const {
+    return nodes;
+  }
+
+  MapleVector<T*> &GetNodes() {
+    return nodes;
+  }
+
+  const MapleSet<SCCNode<T>*, Comparator<SCCNode<T>>> &GetOutScc() const {
+    return outScc;
+  }
+
+  const MapleSet<SCCNode<T>*, Comparator<SCCNode<T>>> &GetInScc() const {
+    return inScc;
+  }
+
+  void RemoveInScc(SCCNode<T> *const sccNode) {
+    inScc.erase(sccNode);
+  }
+
+  bool HasRecursion() const {
+    if (nodes.empty()) {
+      return false;
+    }
+    if (nodes.size() > 1) {
+      return true;
+    }
+    T *node = nodes[0];
+    std::vector<BaseGraphNode*> outNodes;
+    node->GetOutNodes(outNodes);
+    for (auto outIt : outNodes) {
+      auto outNode = static_cast<T*>(outIt);
+      if (outNode == nullptr) {
+        continue;
+      }
+      if (node == outNode) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool HasInScc() const {
+    return (!inScc.empty());
+  }
+
+  uint32 GetID() const {
+    return id;
+  }
+
+  uint32 GetUniqueID() const {
+    return GetID() << maple::kShiftSccUniqueIDNum;
+  }
+ private:
+  uint32 id;
+  MapleVector<T*> nodes;
+  MapleSet<SCCNode<T>*, Comparator<SCCNode<T>>> inScc;
+  MapleSet<SCCNode<T>*, Comparator<SCCNode<T>>> outScc;
+};
+
+template<typename T>
+void BuildSCCDFS(T &rootNode, uint32 &visitIndex, MapleVector<SCCNode<T>*> &sccNodes,
+                 std::vector<T*> &nodes, std::vector<uint32> &visitedOrder,
+                 std::vector<uint32> &lowestOrder, std::vector<bool> &inStack,
+                 std::vector<uint32> &visitStack, uint32 &numOfSccs, MapleAllocator &cgAlloc) {
+  uint32 id = rootNode.GetID();
+  nodes.at(id) = &rootNode;
+  visitedOrder.at(id) = visitIndex;
+  lowestOrder.at(id) = visitIndex;
+  ++visitIndex;
+  inStack.at(id) = true;
+
+  std::vector<BaseGraphNode*> outNodes;
+  rootNode.GetOutNodes(outNodes);
+  for (auto outIt : outNodes) {
+    auto outNode = static_cast<T*>(outIt);
+    if (outNode == nullptr) {
+      continue;
+    }
+    uint32 outNodeId = outNode->GetID();
+    if (visitedOrder.at(outNodeId) == 0) {
+      // callee has not been processed yet
+      BuildSCCDFS(*outNode, visitIndex, sccNodes, nodes, visitedOrder, lowestOrder, inStack,
+                  visitStack, numOfSccs, cgAlloc);
+      if (lowestOrder.at(outNodeId) < lowestOrder.at(id)) {
+        lowestOrder.at(id) = lowestOrder.at(outNodeId);
+      }
+    } else if (inStack.at(outNodeId) && (visitedOrder.at(outNodeId) < lowestOrder.at(id))) {
+      // back edge
+      lowestOrder.at(id) = visitedOrder.at(outNodeId);
+    }
+  }
+
+  if (visitedOrder.at(id) == lowestOrder.at(id)) {
+    SCCNode<T> *sccNode = cgAlloc.GetMemPool()->New<SCCNode<T>>(numOfSccs++, cgAlloc);
+    inStack.at(id) = false;
+    T *node = nodes.at(id);
+    node->SetSCCNode(sccNode);
+    sccNode->AddNode(node);
+    while (!visitStack.empty()) {
+      auto stackTopId = visitStack.back();
+      if (visitedOrder.at(stackTopId) < visitedOrder.at(id)) {
+        break;
+      }
+      visitStack.pop_back();
+      inStack.at(stackTopId) = false;
+      T *topNode = nodes.at(stackTopId);
+      topNode->SetSCCNode(sccNode);
+      sccNode->AddNode(topNode);
+    }
+    sccNodes.push_back(sccNode);
+  } else {
+    visitStack.push_back(id);
+  }
+}
+
+template<typename T>
+void VerifySCC(std::vector<T*> nodes) {
+  for (auto node : nodes) {
+    if (node->GetSCCNode() == nullptr) {
+      CHECK_FATAL(false, "nullptr check in VerifySCC()");
+    }
+  }
+}
+
+template<typename T>
+uint32 BuildSCC(MapleAllocator &cgAlloc, uint32 numOfNodes,
+                std::vector<T*> &allNodes, bool debugScc, MapleVector<SCCNode<T>*> &topologicalVec) {
+  // This is the mapping between cg_id to node.
+  std::vector<T*> id2NodeMap(numOfNodes, nullptr);
+  std::vector<uint32> visitedOrder(numOfNodes, 0);
+  std::vector<uint32> lowestOrder(numOfNodes, 0);
+  std::vector<bool> inStack(numOfNodes, false);
+  std::vector<uint32> visitStack;
+  uint32 visitIndex = 1;
+  uint32 numOfSccs = 0;
+  // However, not all SCC can be reached from roots.
+  // E.g. foo()->foo(), foo is not considered as a root.
+  for (auto node : allNodes) {
+    if (node->GetSCCNode() == nullptr) {
+      BuildSCCDFS(*node, visitIndex, topologicalVec, id2NodeMap, visitedOrder, lowestOrder, inStack,
+                  visitStack, numOfSccs, cgAlloc);
+    }
+  }
+  for (auto scc : topologicalVec) {
+    scc->Verify();
+    scc->Setup();  // fix caller and callee info.
+    if (debugScc && scc->HasRecursion()) {
+      scc->Dump();
+    }
+  }
+  std::reverse(topologicalVec.begin(), topologicalVec.end());
+  return numOfSccs;
+}
+}
+#endif  // MPL2MPL_INCLUDE_SCC_H
\ No newline at end of file
diff --git a/src/mapleall/mpl2mpl/include/simplify.h b/src/mapleall/mpl2mpl/include/simplify.h
new file mode 100644
index 0000000000000000000000000000000000000000..bebafe32f9d1510281616a67fa4365773d8b8564
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/simplify.h
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_SIMPLIFY_H
+#define MPL2MPL_INCLUDE_SIMPLIFY_H
+#include "phase_impl.h"
+#include "factory.h"
+#include "maple_phase_manager.h"
+namespace maple {
+
+const std::map<std::string, std::string> asmMap = {
+#include "asm_map.def"
+};
+
+enum ErrorNumber : int32 {
+  ERRNO_OK = EOK,
+  ERRNO_INVAL = EINVAL,
+  ERRNO_RANGE = ERANGE,
+  ERRNO_INVAL_AND_RESET = EINVAL_AND_RESET,
+  ERRNO_RANGE_AND_RESET = ERANGE_AND_RESET,
+  ERRNO_OVERLAP_AND_RESET = EOVERLAP_AND_RESET
+};
+
+enum OpKind {
+  MEM_OP_unknown,
+  MEM_OP_memset,
+  MEM_OP_memcpy,
+  MEM_OP_memset_s,
+  MEM_OP_memcpy_s,
+  SPRINTF_OP_sprintf,
+  SPRINTF_OP_sprintf_s,
+  SPRINTF_OP_snprintf_s,
+  SPRINTF_OP_vsnprintf_s
+};
+
+// MemEntry models a memory entry with high level type information.
+struct MemEntry {
+  enum MemEntryKind {
+    kMemEntryUnknown,
+    kMemEntryPrimitive,
+    kMemEntryStruct,
+    kMemEntryArray
+  };
+
+  static bool ComputeMemEntry(BaseNode &expr, MIRFunction &func, MemEntry &memEntry, bool isLowLevel);
+  MemEntry() = default;
+  MemEntry(BaseNode *addrExpr, MIRType *memType) : addrExpr(addrExpr), memType(memType) {}
+
+  MemEntryKind GetKind() const {
+    if (memType == nullptr) {
+      return kMemEntryUnknown;
+    }
+    auto typeKind = memType->GetKind();
+    if (typeKind == kTypeScalar || typeKind == kTypePointer) {
+      return kMemEntryPrimitive;
+    } else if (typeKind == kTypeArray) {
+      return kMemEntryArray;
+    } else if (memType->IsStructType()) {
+      return kMemEntryStruct;
+    }
+    return kMemEntryUnknown;
+  }
+
+  BaseNode *BuildAsRhsExpr(MIRFunction &func, MIRType *accessType = nullptr) const;
+  bool ExpandMemset(int64 byte, uint64 size, MIRFunction &func,
+                    StmtNode &stmt, BlockNode &block, bool isLowLevel, bool debug, ErrorNumber errorNumber) const;
+  void ExpandMemsetLowLevel(int64 byte, uint64 size, MIRFunction &func, StmtNode &stmt, BlockNode &block,
+                            OpKind memOpKind, bool debug, ErrorNumber errorNumber) const;
+  bool ExpandMemcpy(const MemEntry &srcMem, uint64 copySize, MIRFunction &func,
+                    StmtNode &stmt, BlockNode &block, bool isLowLevel, bool debug, ErrorNumber errorNumber) const;
+  void ExpandMemcpyLowLevel(const MemEntry &srcMem, uint64 copySize, MIRFunction &func, StmtNode &stmt,
+                            BlockNode &block, OpKind memOpKind, bool debug, ErrorNumber errorNumber) const;
+  static StmtNode *GenRetAssign(StmtNode &stmt, MIRFunction &func, bool isLowLevel, OpKind memOpKind,
+                                int32 returnVal = ERRNO_OK);
+  StmtNode *GenEndZeroAssign(StmtNode &stmt, MIRFunction &func, bool isLowLevel, uint64 count) const;
+  BaseNode *addrExpr = nullptr;   // memory address
+  MIRType *memType = nullptr;     // memory type, this may be nullptr for low level memory entry
+};
+
+class ProxyMemOp {
+ public:
+  ProxyMemOp() = default;
+  virtual ~ProxyMemOp() = default;
+  virtual bool SimplifyMemcpy(StmtNode &stmt, BlockNode &block, bool isLowLevel) = 0;
+  virtual MIRFunction *GetFunction() = 0;
+  virtual bool IsDebug() const = 0;
+};
+
+class SprintfBaseOper {
+ public:
+  explicit SprintfBaseOper(ProxyMemOp &op) : op(op) {}
+  void ProcessRetValue(StmtNode &stmt, BlockNode &block, OpKind opKind, int32 retVal, bool isLowLevel);
+  bool DealWithFmtConstStr(StmtNode &stmt, BaseNode *fmt, BlockNode &block, bool isLowLevel);
+  static bool CheckCondIfNeedReplace(const StmtNode &stmt, uint32_t opIdx);
+  static bool IsCountConst(StmtNode &stmt, uint64 &count, uint32_t opndIdx);
+  StmtNode *InsertMemcpyCallStmt(const MapleVector<BaseNode *> &args, StmtNode &stmt,
+                                 BlockNode &block, int32 retVal, bool isLowLevel);
+  virtual bool GetDstMaxOrCountSize(StmtNode &stmt, uint64 &dstMax, uint64 &count) {
+    CHECK_FATAL(false, "NEVER REACH");
+  };
+  bool ReplaceSprintfWithMemcpy(StmtNode &stmt, BlockNode &block, uint32 fmtOpndIdx, uint64 copySize, bool isLowLevel);
+  bool CompareDstMaxSrcSize(StmtNode &stmt, BlockNode &block, uint64 dstMax, uint64 srcSize, bool isLowLevel);
+  bool CompareCountSrcSize(StmtNode &stmt, BlockNode &block, uint64 count, uint64 srcSize, bool isLowLevel);
+    bool DealWithDstOrEndZero(StmtNode &stmt, BlockNode &block, bool isLowLevel, uint64 count);
+    static bool CheckInvalidPara(uint64 count, uint64 dstMax, uint64 srcSize);
+  virtual bool ReplaceSprintfIfNeeded(StmtNode &stmt, BlockNode &block, bool isLowLevel, const OpKind &opKind) {
+    CHECK_FATAL(false, "NEVER REACH");
+  };
+  virtual ~SprintfBaseOper() = default;
+ protected:
+  ProxyMemOp &op;
+};
+
+class SimplifySprintf : public SprintfBaseOper {
+ public:
+  explicit SimplifySprintf(ProxyMemOp &op) : SprintfBaseOper(op) {}
+  ~SimplifySprintf() = default;
+  bool ReplaceSprintfIfNeeded(StmtNode &stmt, BlockNode &block, bool isLowLevel, const OpKind &opKind) override;
+};
+
+class SimplifySprintfS : public SprintfBaseOper {
+ public:
+  explicit SimplifySprintfS(ProxyMemOp &op) : SprintfBaseOper(op) {}
+  ~SimplifySprintfS() = default;
+  bool ReplaceSprintfIfNeeded(StmtNode &stmt, BlockNode &block, bool isLowLevel, const OpKind &opKind) override;
+  bool GetDstMaxOrCountSize(StmtNode &stmt, uint64 &dstMax, uint64 &count) override;
+};
+
+class SimplifySnprintfS : public SprintfBaseOper {
+ public:
+  explicit SimplifySnprintfS(ProxyMemOp &op) : SprintfBaseOper(op) {}
+  ~SimplifySnprintfS() = default;
+  bool ReplaceSprintfIfNeeded(StmtNode &stmt, BlockNode &block, bool isLowLevel, const OpKind &opKind) override;
+  bool GetDstMaxOrCountSize(StmtNode &stmt, uint64 &dstMax, uint64 &count) override;
+};
+
+// For simplifying operation.
+class SimplifyOp : public ProxyMemOp {
+ public:
+  static OpKind ComputeOpKind(StmtNode &stmt);
+  ~SimplifyOp() = default;
+
+  explicit SimplifyOp(MemPool &memPool) : sprintfAlloc(&memPool), sprintfMap(sprintfAlloc.Adapter()) {
+    auto simplifySnprintfs = sprintfAlloc.New<SimplifySnprintfS>(*this);
+    sprintfMap.emplace(SPRINTF_OP_sprintf, sprintfAlloc.New<SimplifySprintf>(*this));
+    sprintfMap.emplace(SPRINTF_OP_sprintf_s, sprintfAlloc.New<SimplifySprintfS>(*this));
+    sprintfMap.emplace(SPRINTF_OP_snprintf_s, simplifySnprintfs);
+    sprintfMap.emplace(SPRINTF_OP_vsnprintf_s, simplifySnprintfs);
+  }
+  void SetFunction(MIRFunction *f) {
+    func = f;
+  }
+
+  MIRFunction *GetFunction() override {
+    return func;
+  }
+
+  bool IsDebug() const override {
+    return debug;
+  }
+
+  void SetDebug(bool dbg) {
+    debug = dbg;
+  }
+
+  bool AutoSimplify(StmtNode &stmt, BlockNode &block, bool isLowLevel);
+  bool SimplifyMemset(StmtNode &stmt, BlockNode &block, bool isLowLevel);
+  bool SimplifyMemcpy(StmtNode &stmt, BlockNode &block, bool isLowLevel) override;
+ private:
+  StmtNode *PartiallyExpandMemsetS(StmtNode &stmt, BlockNode &block) const;
+  StmtNode *PartiallyExpandMemcpyS(StmtNode &stmt, BlockNode &block);
+
+  static const uint32 thresholdMemsetExpand;
+  static const uint32 thresholdMemsetSExpand;
+  static const uint32 thresholdMemcpyExpand;
+  static const uint32 thresholdMemcpySExpand;
+  MIRFunction *func = nullptr;
+  bool debug = false;
+  MapleAllocator sprintfAlloc;
+  MapleMap<OpKind, SprintfBaseOper*> sprintfMap;
+};
+
+class Simplify : public FuncOptimizeImpl {
+ public:
+  Simplify(MIRModule &mod, KlassHierarchy *kh, MemPool &memPool, bool dump)
+      : FuncOptimizeImpl(mod, kh, dump), mirMod(mod), simplifyMemOp(memPool) {
+  }
+  Simplify(const Simplify &other) = delete;
+  Simplify &operator=(const Simplify &other) = delete;
+  ~Simplify() = default;
+  FuncOptimizeImpl *Clone() override {
+    CHECK_FATAL(false, "Simplify has pointer, should not be Cloned");
+  }
+
+  void Finish() override;
+
+ protected:
+  void ProcessStmt(StmtNode &stmt) override;
+
+ private:
+  MIRModule &mirMod;
+  SimplifyOp simplifyMemOp;
+  bool IsMathSqrt(const std::string funcName);
+  bool IsMathAbs(const std::string funcName);
+  bool IsMathMin(const std::string funcName);
+  bool IsMathMax(const std::string funcName);
+  bool IsSymbolReplaceableWithConst(const MIRSymbol &symbol) const;
+  bool IsConstRepalceable(const MIRConst &mirConst) const;
+  bool SimplifyMathMethod(const StmtNode &stmt, BlockNode &block);
+  void SimplifyCallAssigned(StmtNode &stmt, BlockNode &block);
+  StmtNode *SimplifyBitFieldWrite(const IassignNode &iass);
+  BaseNode *SimplifyBitFieldRead(IreadNode &iread);
+  StmtNode *SimplifyToSelect(MIRFunction *func, IfStmtNode *ifNode, BlockNode *block);
+  BaseNode *SimplifyExpr(BaseNode &expr);
+  BaseNode *ReplaceExprWithConst(DreadNode &dread);
+  MIRConst *GetElementConstFromFieldId(FieldID fieldId, MIRConst *mirConst);
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MSimplify)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_SIMPLIFY_H
diff --git a/src/mapleall/mpl2mpl/include/stmt_cost_analyzer.h b/src/mapleall/mpl2mpl/include/stmt_cost_analyzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..994b74ebee51cac9586d855895d1109898e06127
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/stmt_cost_analyzer.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_STMT_COST_H
+#define MPL2MPL_INCLUDE_STMT_COST_H
+#include "call_graph.h"
+#include "maple_phase_manager.h"
+#include "me_ir.h"
+#include "me_option.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_builder.h"
+#include "mir_function.h"
+#include "mir_parser.h"
+#include "opcode_info.h"
+#include "string_utils.h"
+#include "target_info.h"
+
+namespace maple {
+constexpr size_t kSizeScale = 100;
+constexpr size_t kInsn2Threshold = 2;
+constexpr int32 kNumInsnsOfCall = 3;  // default value when edgeSummary is absent
+
+enum CostKind {
+  kCostKindInsn,
+  kCostKindCycle
+};
+
+// An stmt cost analyzer binds to a function to be analyzed.
+// That's to say, each time you want to analyze a function,
+// a new StmtCostAnalyzer object should be created.
+class StmtCostAnalyzer {
+ public:
+  explicit StmtCostAnalyzer(MemPool *tempMemPool) : alloc(tempMemPool) {
+    Init();
+  }
+
+  StmtCostAnalyzer(MemPool *tempMemPool, MIRFunction *func)
+      : alloc(tempMemPool), curFunc(func) {
+    Init();
+  };
+
+  void Init();
+  int32 EstimateNumInsns(MeStmt *meStmt);
+  int32 EstimateNumCycles(MeStmt *meStmt);
+  int32 EstimateNumInsns(StmtNode *stmt);
+  int32 EstimateNumCycles(StmtNode *stmt);
+  int64 GetStmtsCost(BlockNode *block);
+  int64 GetStmtCost(StmtNode *stmt);
+  int64 GetExprCost(BaseNode *expr);
+  int64 GetMeStmtCost(MeStmt *meStmt);
+  int64 GetMeExprCost(MeExpr *meExpr);
+  int64 GetMoveCost(size_t sizeInByte);
+  TargetInfo *GetTargetInfo() { return ti; }
+  MIRType *GetMIRTypeFromStIdxAndField(const StIdx idx, FieldID fieldID);
+  void SetFunction(MIRFunction *func) { curFunc = func; }
+
+  ~StmtCostAnalyzer() {
+    curFunc = nullptr;
+    ti = nullptr;
+  }
+
+ private:
+  MapleAllocator alloc;
+  MIRFunction *curFunc = nullptr;  // the current function that being analyzed.
+  TargetInfo *ti = nullptr;
+};
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_STMT_COST_H
+
diff --git a/src/mapleall/mpl2mpl/include/target_info.h b/src/mapleall/mpl2mpl/include/target_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..d39a4ab90ef14b8fd5e0899f6f185d639f442cf1
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/target_info.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_TARGET_INFO_H
+#define MPL2MPL_INCLUDE_TARGET_INFO_H
+#include <map>
+#include <stack>
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "mir_function.h"
+#include "intrinsic_op.h"
+
+namespace maple {
+constexpr size_t kMaxMoveBytes = 8;
+enum class BackEnd {
+  AARCH64,
+  ARM32,
+  RISCV64,
+  X86_64
+};
+
+// ---------- TargetInfo ----------
+class TargetInfo {
+ public:
+  TargetInfo() {}
+  virtual ~TargetInfo() = default;
+
+  static TargetInfo *CreateTargetInfo(MapleAllocator &alloca, BackEnd backEnd = BackEnd::AARCH64);
+  virtual size_t GetMaxMoveBytes() = 0;
+  virtual size_t GetIntrinsicInsnNum(MIRIntrinsicID id) = 0;
+};
+
+// ---------- AArch64TargetInfo ----------
+class AArch64TargetInfo : public TargetInfo {
+ public:
+  AArch64TargetInfo() : TargetInfo() {}
+  ~AArch64TargetInfo() override = default;
+
+  size_t GetMaxMoveBytes() override { return kMaxMoveBytes; }
+  size_t GetIntrinsicInsnNum(MIRIntrinsicID id) override;
+};
+
+// ---------- X64TargetInfo ----------
+class X64TargetInfo : public TargetInfo {
+ public:
+  X64TargetInfo() : TargetInfo() {}
+  ~X64TargetInfo() override = default;
+
+  size_t GetMaxMoveBytes() override { return kMaxMoveBytes; }
+  size_t GetIntrinsicInsnNum(MIRIntrinsicID id) override;
+};
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_TARGET_INFO_H
diff --git a/src/mapleall/mpl2mpl/include/tobe_cloned_funcs.def b/src/mapleall/mpl2mpl/include/tobe_cloned_funcs.def
new file mode 100644
index 0000000000000000000000000000000000000000..1da06daba97bfadc64031d3e451f5bb4f523f4cd
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/tobe_cloned_funcs.def
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+/**
+  ===================================================== FORMAT ======================================================
+  ORIFUNC(origin, cloned)
+ */
+
+ORIFUNC(Ljava_2Flang_2FAbstractStringBuilder_3B_7Cappend_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FAbstractStringBuilder_3B,
+        Ljava_2Flang_2FAbstractStringBuilder_3B_7CappendCLONEDignoreret_7C_28Ljava_2Flang_2FString_3B_29V)
diff --git a/src/mapleall/mpl2mpl/include/tobe_replaced_funcs.def b/src/mapleall/mpl2mpl/include/tobe_replaced_funcs.def
new file mode 100644
index 0000000000000000000000000000000000000000..97da39412c604ac5ffdd2455f1d2f2033d19cd1f
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/tobe_replaced_funcs.def
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+/**
+  ===================================================== FORMAT ======================================================
+  ORIFUNC(caller, origCallee, newCallee)
+ */
+ORIFUNC(Ljava_2Flang_2FRuntime_3B_7CrunFinalization_7C_28_29V,
+        Ldalvik_2Fsystem_2FVMRuntime_3B_7CrunFinalization_7C_28J_29V,
+        MCC_RunFinalization)
+
diff --git a/src/mapleall/mpl2mpl/include/update_mplt.h b/src/mapleall/mpl2mpl/include/update_mplt.h
new file mode 100644
index 0000000000000000000000000000000000000000..3aae58be7d6129525d0e23885884fef051bb835e
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/update_mplt.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_MPL2MPL_INCLUDE_UPDATE_MPLT_H
+#define MAPLE_MPL2MPL_INCLUDE_UPDATE_MPLT_H
+#include "module_phase_manager.h"
+
+namespace maple {
+MAPLE_MODULE_PHASE_DECLARE(M2MUpdateMplt)
+}  // namespace maple
+#endif  // MAPLE_MPL2MPL_INCLUDE_UPDATE_MPLT_H
diff --git a/src/mapleall/mpl2mpl/include/vtable_analysis.h b/src/mapleall/mpl2mpl/include/vtable_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..3934c6d68f961d91625bb2b6480f8c82bb22fa4f
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/vtable_analysis.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_VTABLE_ANALYSIS_H
+#define MPL2MPL_INCLUDE_VTABLE_ANALYSIS_H
+#include "phase_impl.h"
+
+namespace maple {
+#ifdef USE_32BIT_REF
+constexpr unsigned int kTabEntrySize = 4;
+constexpr unsigned int kShiftCountBit = 4 * 4;  // Get the low 16bit
+#else   // !USE_32BIT_REF
+constexpr unsigned int kTabEntrySize = 8;
+constexpr unsigned int kShiftCountBit = 8 * 4;  // Get the low 32bit
+#endif  // USE_32BIT_REF
+
+class VtableAnalysis : public FuncOptimizeImpl {
+ public:
+  VtableAnalysis(MIRModule &mod, KlassHierarchy *kh, bool dump);
+  ~VtableAnalysis() = default;
+  static std::string DecodeBaseNameWithType(const MIRFunction &func);
+  static bool IsVtableCandidate(const MIRFunction &func);
+  void ProcessFunc(MIRFunction *func) override;
+  FuncOptimizeImpl *Clone() override {
+    return new VtableAnalysis(*this);
+  }
+
+ private:
+  bool CheckInterfaceSpecification(const Klass &baseKlass, const Klass &currKlass) const;
+  bool CheckOverrideForCrossPackage(const MIRFunction &baseMethod, const MIRFunction &currMethod) const;
+  void AddMethodToTable(MethodPtrVector &methodTable, MethodPair &methodPair);
+  void GenVtableList(const Klass &klass);
+  void DumpVtableList(const Klass &klass) const;
+  void GenTableSymbol(const std::string &prefix, const std::string klassName, MIRAggConst &newConst) const;
+  void GenVtableDefinition(const Klass &klass);
+  void GenItableDefinition(const Klass &klass);
+  void AddNullPointExceptionCheck(MIRFunction &func, StmtNode &stmt) const;
+  BaseNode *GenVtabItabBaseAddr(BaseNode &obj, bool isVirtual);
+  size_t SearchWithoutRettype(const MIRFunction &callee, const MIRStructType &structType) const;
+  bool CheckInterfaceImplemented(const CallNode &stmt) const;
+  void ReplaceVirtualInvoke(CallNode &stmt);
+  void ReplaceInterfaceInvoke(CallNode &stmt);
+  void ReplaceSuperclassInvoke(CallNode &stmt);
+  void ReplacePolymorphicInvoke(CallNode &stmt);
+
+  std::unordered_map<PUIdx, int> puidxToVtabIndex;
+  MIRType *voidPtrType;
+  MIRIntConst *zeroConst;
+  MIRIntConst *oneConst;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MVtableAnalysis)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_VTABLE_ANALYSIS_H
diff --git a/src/mapleall/mpl2mpl/include/vtable_impl.h b/src/mapleall/mpl2mpl/include/vtable_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..0926bbdc94c9963092b78377eed1a9d05693b1af
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/vtable_impl.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_VTABLE_IMPL_H
+#define MPL2MPL_INCLUDE_VTABLE_IMPL_H
+#include "phase_impl.h"
+
+namespace maple {
+enum CallKind {
+  kStaticCall = 0,
+  kVirtualCall = 1,
+  kSuperCall = 2
+};
+
+class VtableImpl : public FuncOptimizeImpl {
+ public:
+  VtableImpl(MIRModule &mod, KlassHierarchy *kh, bool dump);
+  ~VtableImpl() = default;
+
+  void ProcessFunc(MIRFunction *func) override;
+  FuncOptimizeImpl *Clone() override {
+    return new VtableImpl(*this);
+  }
+#ifndef USE_ARM32_MACRO
+#ifdef USE_32BIT_REF
+  void Finish() override;
+#endif  // ~USE_32BIT_REF
+#endif  // ~USE_ARM32_MACRO
+
+ private:
+  void ReplaceResolveInterface(StmtNode &stmt, const ResolveFuncNode &resolveNode);
+  void ItabProcess(const StmtNode &stmt, const ResolveFuncNode &resolveNode, const std::string &signature,
+                   const PregIdx &pregFuncPtr, const MIRType &compactPtrType, const PrimType &compactPtrPrim);
+  bool Intrinsify(MIRFunction &func, CallNode &cnode);
+#ifndef USE_ARM32_MACRO
+#ifdef USE_32BIT_REF
+  void InlineCacheinit();
+  void GenInlineCacheTableSymbol();
+  void InlineCacheProcess(StmtNode &stmt, const ResolveFuncNode &resolveNode,
+                          const std::string &signature, PregIdx &pregFuncPtr);
+  void CallMrtInlineCacheFun(StmtNode &stmt, const ResolveFuncNode &resolveNode,
+                             RegreadNode &regReadNodeTmp, int64 hashCode, uint64 secondHashCode,
+                             const std::string &signature, PregIdx &pregFuncPtr, IfStmtNode &ifStmt);
+  void ResolveInlineCacheTable();
+#endif  // ~USE_32BIT_REF
+#endif  // ~USE_ARM32_MACRO
+  void DeferredVisit(CallNode &stmt, CallKind n);
+  void DeferredVisitCheckFloat(CallNode &stmt, const MIRFunction &mirFunc);
+  MIRModule *mirModule;
+  KlassHierarchy *klassHierarchy;
+#ifndef USE_ARM32_MACRO
+#ifdef USE_32BIT_REF
+  MIRFunction *mccItabFuncInlineCache;
+  uint32 numOfInterfaceCallSite = 0;
+  MIRStructType *inlineCacheTableEntryType = nullptr;
+  MIRArrayType *inlineCacheTableType = nullptr;
+  MIRSymbol *inlineCacheTableSym = nullptr;
+#endif  // ~USE_32BIT_REF
+#endif  // ~USE_ARM32_MACRO
+  MIRFunction *mccItabFunc;
+};
+
+MAPLE_MODULE_PHASE_DECLARE(M2MVtableImpl)
+}  // namespace maple
+#endif  // MPL2MPL_INCLUDE_VTABLE_IMPL_H
diff --git a/src/mapleall/mpl2mpl/src/annotation_analysis.cpp b/src/mapleall/mpl2mpl/src/annotation_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1a412e1cb0ff0db51a33cd893f0bcd93e3f27f31
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/annotation_analysis.cpp
@@ -0,0 +1,538 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "annotation_analysis.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+char AnnotationAnalysis::annoDeclare = ':';
+char AnnotationAnalysis::annoSemiColon = ';';
+int AnnotationType::atime = 0;
+MIRStructType *GetClassTypeFromName(const std::string &className) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(className);
+  if (strIdx == 0) {
+    strIdx = GlobalTables::GetStrTable().GetStrIdxFromName("Ljava_2Flang_2FObject_3B");
+  }
+  TyIdx classTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(strIdx);
+  MIRType &classType = GetTypeFromTyIdx(classTyIdx);
+  return &static_cast<MIRStructType&>(classType);
+}
+
+void GenericDeclare::Dump() {
+  std::cout << GetName() << ":";
+  if (defaultType->GetKind() == kGenericDeclare) {
+    std::cout << "T" << defaultType->GetName() << ";";
+  } else if (defaultType->GetKind() == kGenericType) {
+    defaultType->Dump();
+  } else {
+    CHECK_FATAL(false, "must be");
+  }
+}
+
+void GenericType::Dump() {
+  std::string s = namemangler::DecodeName(GetName());
+  s.pop_back();
+  std::cout << s;
+  if (GenericArg.size() != 0) {
+    std::cout << "<";
+    for (AnnotationType *real : ArgOrder) {
+      if (real->GetKind() == kGenericType) {
+        real->Dump();
+      } else if (real->GetKind() == kGenericDeclare) {
+        std::cout << "T" << real->GetName() << ";";
+      } else {
+        real->Dump();
+      }
+    }
+    std::cout << ">";
+  }
+  std::cout << ";";
+}
+
+void AnnotationType::Dump() {
+  if (kind == kGenericMatch) {
+    std::cout << "*";
+  } else {
+    std::cout << GetName();
+  }
+}
+
+void GenericType::ReWriteType(std::string &subClass) {
+  std::string className = mirStructType->GetName();
+  size_t ClassMethodSplitterStrSize = strlen(namemangler::kClassMethodSplitterStr);
+  (void)className.replace(className.size() - ClassMethodSplitterStrSize, ClassMethodSplitterStrSize, subClass);
+  mirStructType = GetClassTypeFromName(className);
+  typeName = GlobalTables::GetStrTable().GetStrIdxFromName(className);
+  GenericArg.clear();
+  ArgOrder.clear();
+}
+
+GenericDeclare *AnnotationParser::GetOrCreateDeclare(GStrIdx gStrIdx, MemPool &mp, bool check, MIRStructType *sType) {
+  if (created.find(gStrIdx) != created.end()) {
+    return created[gStrIdx];
+  }
+  if (check) {
+    if (sType != nullptr) {
+      for (GenericDeclare *gd : sType->GetGenericDeclare()) {
+        if (gd->GetGStrIdx() == gStrIdx) {
+          return gd;
+        }
+      }
+    }
+    return nullptr;
+  }
+  GenericDeclare *gd = mp.New<GenericDeclare>(gStrIdx);
+  created[gStrIdx] = gd;
+  return gd;
+}
+
+ATokenKind AnnotationParser::GetNextToken(const char *endC) {
+  if (curIndex == signature.size()) {
+    ++curIndex;
+    return kEnd;
+  }
+  CHECK_FATAL(curIndex < signature.size(), "must be");
+  if (endC == nullptr) {
+    switch (signature[curIndex++]) {
+      case '<':
+        return kTemplateStart;
+      case '>':
+        return kTemplateEnd;
+      case '(':
+        return kArgumentStart;
+      case ')':
+        return kArgumentEnd;
+      case '+':
+        return kExtend;
+      case '-':
+        return kSuper;
+      case '*':
+        return kMatch;
+      case '[':
+        return kArray;
+      case 'L':
+        return kAClassName;
+      case 'T':
+        return kTemplateName;
+      case 'I':
+      case 'Z':
+      case 'D':
+      case 'F':
+      case 'V':
+      case 'S':
+      case 'C':
+      case 'B':
+      case 'J':
+        curStrToken = signature[curIndex - 1];
+        return kPrimeTypeName;
+      case '.':
+        return kSubClass;
+      case ';':
+        return kSemiComma;
+      default:
+        curStrToken = signature[curIndex - 1];
+        return kChar;
+    }
+  }
+  size_t endPos = signature.find_first_of(endC, curIndex);
+  CHECK_FATAL(endPos != std::string::npos, "must be");
+  curStrToken = signature.substr(curIndex, endPos - curIndex);
+  curIndex = endPos + 1u;
+  if (*endC == ':' && signature[curIndex] == ':') {
+    ++curIndex;
+  }
+  return kString;
+}
+
+// read until ; or <, whatever end of classname is ;
+std::string AnnotationParser::GetNextClassName(bool forSubClass) {
+  size_t pos1 = signature.find_first_of(';', curIndex);
+  size_t pos2 = signature.find_first_of('<', curIndex);
+  CHECK_FATAL(pos1 != pos2, "must be");
+  size_t pos = pos1 < pos2 ? pos1 : pos2;
+  curStrToken = signature.substr(curIndex - 1, pos - curIndex + 1);
+  curStrToken += ";";
+  curIndex = pos;
+  if (forSubClass) {
+    for (size_t i = 0; i < curStrToken.size(); ++i) {
+      if (curStrToken[i] == '.') {
+        curStrToken[i] = '$';
+      }
+    }
+  }
+  std::string className = namemangler::EncodeName(curStrToken);
+  return className;
+}
+
+void AnnotationParser::InitFuncGenericDeclare(MemPool &pragmaMemPool, MIRFunction &mirFunc) {
+  size_t declarePos = signature.find_first_of(':', curIndex);
+  size_t prev = 1;
+  size_t next = 0;
+  while (declarePos != std::string::npos) {
+    std::string declareName = signature.substr(prev, declarePos - prev);
+    if (declareName != "") {
+      GStrIdx gStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(declareName);
+      GenericDeclare *tmp = GetOrCreateDeclare(gStrIdx, pragmaMemPool);
+      tmp->SetBelongToFunc(&mirFunc);
+      mirFunc.AddFuncGenericDeclare(tmp);
+    }
+    if (signature[declarePos + 1] == ':') {
+      ++declarePos;
+    }
+    next = declarePos + 1;
+    declarePos = signature.find_first_of(':', next);
+    prev = signature.find_last_of (';', declarePos) + 1;
+  }
+}
+
+void AnnotationParser::InitClassGenericDeclare(MemPool &pragmaMemPool, MIRStructType &mirStruct) {
+  size_t declarePos = signature.find_first_of(':', curIndex);
+  size_t prev = 1;
+  size_t next = 0;
+  while (declarePos != std::string::npos) {
+    std::string declareName = signature.substr(prev, declarePos - prev);
+    if (declareName != "") {
+      GStrIdx gStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(declareName);
+      GenericDeclare *tmp = GetOrCreateDeclare(gStrIdx, pragmaMemPool);
+      tmp->SetBelongToStruct(&mirStruct);
+      mirStruct.AddClassGenericDeclare(tmp);
+    }
+    if (signature[declarePos + 1] == ':') {
+      ++declarePos;
+    }
+    next = declarePos + 1;
+    declarePos = signature.find_first_of(':', next);
+    prev = signature.find_last_of (';', declarePos) + 1;
+  }
+}
+
+void AnnotationAnalysis::ByPassFollowingInfo(AnnotationParser &aParser, MIRStructType *sType) {
+  ATokenKind t = aParser.GetNextToken();
+  if (t == kTemplateStart) {
+    t = aParser.GetNextToken();
+    while (t != kTemplateEnd) {
+      aParser.BackOne();
+      (void)ReadInGenericType(aParser, sType);
+      t = aParser.GetNextToken();
+    }
+    CHECK_FATAL(t == kTemplateEnd, "must be");
+    t = aParser.GetNextToken();
+  }
+  while (t == kSubClass) {
+    (void)aParser.GetNextClassName(true);
+    t = aParser.GetNextToken();
+    if (t == kTemplateStart) {
+      t = aParser.GetNextToken();
+      while (t != kTemplateEnd) {
+        aParser.BackOne();
+        (void)ReadInGenericType(aParser, sType);
+        t = aParser.GetNextToken();
+      }
+      CHECK_FATAL(t == kTemplateEnd, "must be");
+      t = aParser.GetNextToken();
+    }
+  }
+  CHECK_FATAL(t == kSemiComma, "must be");
+}
+
+AnnotationType *AnnotationParser::GetOrCreateArrayType(AnnotationType &containsType, MemPool &pragmaMemPool) {
+  if (createdArrayType.find(&containsType) != createdArrayType.end()) {
+    return createdArrayType[&containsType];
+  }
+  ExtendGeneric *retType = pragmaMemPool.New<ExtendGeneric>(containsType, kArrayType);
+  createdArrayType[&containsType] = retType;
+  return retType;
+}
+
+AnnotationType *AnnotationAnalysis::ReadInGenericType(AnnotationParser &aParser, MIRStructType *sType) {
+  ATokenKind tk = aParser.GetNextToken();
+  AnnotationType *retType = nullptr;
+  switch (tk) {
+    case kAClassName: {
+      std::string className = aParser.GetNextClassName();
+      GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(className);
+      MIRStructType *mirStruct = GetClassTypeFromName(className);
+      if (mirStruct == nullptr) {
+        ByPassFollowingInfo(aParser, sType);
+        retType = dummyObj;
+        break;
+      }
+      std::vector<GenericDeclare*>& gdVector = mirStruct->GetGenericDeclare();
+      GenericType *gt = pragmaMemPool->New<GenericType>(gStrIdx, mirStruct, pragmaAllocator);
+      ATokenKind t = aParser.GetNextToken();
+      if (t == kTemplateStart) {
+        AAForClassInfo(*mirStruct);
+        for (size_t i = 0; i < gdVector.size(); ++i) {
+          AnnotationType *tmp = ReadInGenericType(aParser, sType);
+          gt->AddGenericPair(gdVector[i], tmp);
+        }
+        t = aParser.GetNextToken();
+        while (t != kTemplateEnd) {
+          aParser.BackOne();
+          (void)ReadInGenericType(aParser, sType);
+          t = aParser.GetNextToken();
+        }
+        CHECK_FATAL(t == kTemplateEnd, "must be");
+        t = aParser.GetNextToken();
+      }
+      while (t == kSubClass) {
+        std::string subClassName = aParser.GetNextClassName(true);
+        gt->ReWriteType(subClassName);
+        t = aParser.GetNextToken();
+        if (t == kTemplateStart) {
+          AAForClassInfo(*gt->GetMIRStructType());
+          std::vector<GenericDeclare*>& gdTmpVector = gt->GetMIRStructType()->GetGenericDeclare();
+          for (size_t i = 0; i < gdTmpVector.size(); ++i) {
+            AnnotationType *tmp = ReadInGenericType(aParser, sType);
+            gt->AddGenericPair(gdTmpVector[i], tmp);
+          }
+          t = aParser.GetNextToken();
+          while (t != kTemplateEnd) {
+            aParser.BackOne();
+            (void)ReadInGenericType(aParser, sType);
+            t = aParser.GetNextToken();
+          }
+          CHECK_FATAL(t == kTemplateEnd, "must be");
+          t = aParser.GetNextToken();
+        }
+      }
+      CHECK_FATAL(t == kSemiComma, "must be");
+      retType = gt;
+      break;
+    }
+    case kTemplateName: {
+      (void)aParser.GetNextToken(&annoSemiColon);
+      GStrIdx s = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(aParser.GetCurStrToken());
+      retType = aParser.GetOrCreateDeclare(s, *pragmaMemPool, true, sType);
+      if (retType == nullptr) {
+        retType = dummyObj;
+      }
+      break;
+    }
+    case kExtend:
+      retType = ReadInGenericType(aParser, sType);
+      retType = pragmaMemPool->New<ExtendGeneric>(*retType, kHierarchyExtend);
+      break;
+    case kSuper:
+      retType = ReadInGenericType(aParser, sType);
+      retType = pragmaMemPool->New<ExtendGeneric>(*retType, kHierarchyHSuper);
+      break;
+    case kArray:
+      retType = ReadInGenericType(aParser, sType);
+      retType = aParser.GetOrCreateArrayType(*retType, *pragmaMemPool);
+      break;
+    case kMatch:
+      return genericMatch;
+    case kPrimeTypeName: {
+      GStrIdx primeStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(aParser.GetCurStrToken());
+      retType = pragmaMemPool->New<AnnotationType>(kPrimeType, primeStrIdx);
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "must be");
+  }
+  return retType;
+}
+
+GenericDeclare *AnnotationAnalysis::ReadInGenericDeclare(AnnotationParser &aParser, MIRStructType *mirStructType) {
+  (void)aParser.GetNextToken(&annoDeclare);
+  GenericDeclare *gDeclare = nullptr;
+  if (aParser.GetCurStrToken() != "") {
+    GStrIdx gStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(aParser.GetCurStrToken());
+    gDeclare = aParser.GetOrCreateDeclare(gStrIdx, *pragmaMemPool, true, mirStructType);
+    ASSERT_NOT_NULL(gDeclare);
+    CHECK_FATAL(gDeclare->GetDefaultType() == nullptr, "must be");
+  }
+  AnnotationType *at = ReadInGenericType(aParser, mirStructType);
+  if (gDeclare != nullptr) {
+    gDeclare->SetDefaultType(at);
+  }
+  return gDeclare;
+}
+
+std::string AnnotationAnalysis::ReadInAllSubString(const MIRPragma &classPragma) {
+  GStrIdx gStrIdx;
+  std::string signature;
+  CHECK_FATAL(classPragma.GetElementVector().size() == 1, "must be");
+  for (MIRPragmaElement *pragmaElement : classPragma.GetElementVector()) {
+    CHECK_FATAL(pragmaElement->GetType() == kValueArray, "must be");
+    for (MIRPragmaElement *subPragmaEle : pragmaElement->GetSubElemVec()) {
+      CHECK_FATAL(subPragmaEle->GetType() == kValueString, "must be");
+      gStrIdx.reset(static_cast<uint32>(subPragmaEle->GetU64Val()));
+      const std::string &str = GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx);
+      signature += str;
+    }
+  }
+  return signature;
+}
+
+void AnnotationAnalysis::AnalysisAnnotationForFuncLocalVar(MIRFunction &func, AnnotationParser &aParser,
+                                                           MIRStructType &structType) {
+  for (auto &pair : std::as_const(func.GetAliasVarMap())) {
+    MIRAliasVars aliasVar = pair.second;
+    if (aliasVar.sigStrIdx) {
+      std::string newSig = GlobalTables::GetStrTable().GetStringFromStrIdx(aliasVar.sigStrIdx);
+      aParser.ReplaceSignature(newSig);
+      AnnotationType *var = ReadInGenericType(aParser, &structType);
+      func.AddFuncLocalGenericVar(aliasVar.mplStrIdx, var);
+    }
+  }
+}
+
+void AnnotationAnalysis::AnalysisAnnotationForFunc(const MIRPragma &funcPragma, MIRStructType &structType) {
+  MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(funcPragma.GetStrIdx());
+  MIRFunction *func = funcSymbol->GetFunction();
+  (void)analysisedFunc.insert(func);
+  CHECK_FATAL(func->GetFuncGenericDeclare().size() == 0, "must be");
+  CHECK_FATAL(func->GetFuncGenericArg().size() == 0, "must be");
+  std::string signature = ReadInAllSubString(funcPragma);
+  AnnotationParser aParser(signature);
+  ATokenKind tk = aParser.GetNextToken();
+  if (tk == kTemplateStart) {
+    aParser.InitFuncGenericDeclare(*pragmaMemPool, *func);
+    while (aParser.GetNextToken() != kTemplateEnd) {
+      aParser.BackOne();
+      (void)ReadInGenericDeclare(aParser, &structType);
+    }
+    tk = aParser.GetNextToken();
+  }
+  CHECK_FATAL(tk == kArgumentStart, "must be");
+  tk = aParser.GetNextToken();
+  while (tk != kArgumentEnd) {
+    aParser.BackOne();
+    AnnotationType *arg = ReadInGenericType(aParser, &structType);
+    func->AddFuncGenericArg(arg);
+    tk = aParser.GetNextToken();
+  }
+  AnnotationType *ret = ReadInGenericType(aParser, &structType);
+  func->AddFuncGenericRet(ret);
+  AnalysisAnnotationForFuncLocalVar(*func, aParser, structType);
+}
+
+void AnnotationAnalysis::AnalysisAnnotationForVar(const MIRPragma &varPragma, MIRStructType &structType) {
+  std::string signature = ReadInAllSubString(varPragma);
+  AnnotationParser aParser(signature);
+  ATokenKind tk = aParser.GetNextToken();
+  CHECK_FATAL(tk == kAClassName || tk == kTemplateName || tk == kArray, "must be");
+  aParser.BackOne();
+  AnnotationType *at = ReadInGenericType(aParser, &structType);
+  structType.AddFieldGenericDeclare(varPragma.GetStrIdx(), at);
+}
+
+void AnnotationAnalysis::AnalysisAnnotationForClass(const MIRPragma &classPragma) {
+  TyIdx classTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(classPragma.GetStrIdx());
+  MIRType &classType = GetTypeFromTyIdx(classTyIdx);
+  CHECK_FATAL(classType.GetKind() == kTypeClass || classType.GetKind() == kTypeInterface, "must be");
+  std::string signature = ReadInAllSubString(classPragma);
+  AnnotationParser aParser(signature);
+  ATokenKind tk = aParser.GetNextToken();
+  if (tk != kTemplateStart) {
+    return;
+  }
+  aParser.InitClassGenericDeclare(*pragmaMemPool, static_cast<MIRStructType&>(classType));
+  while (aParser.GetNextToken() != kTemplateEnd) {
+    aParser.BackOne();
+    (void)ReadInGenericDeclare(aParser);
+  }
+  while (aParser.GetNextToken() != kEnd) {
+    aParser.BackOne();
+    AnnotationType *at = ReadInGenericType(aParser, nullptr);
+    CHECK_FATAL(at->GetKind() == kGenericType, "must be");
+    if (static_cast<GenericType*>(at)->GetMIRStructType() != &classType) {
+      static_cast<MIRStructType&>(classType).AddInheritaceGeneric(static_cast<GenericType*>(at));
+    }
+  }
+  return;
+}
+
+void AnnotationAnalysis::AAForClassInfo(MIRStructType &structType) {
+  if (analysised.find(&structType) != analysised.end() || structType.IsIncomplete()) {
+    return;
+  }
+  (void)analysised.insert(&structType);
+  std::vector<MIRPragma*> &pragmaVec = structType.GetPragmaVec();
+  for (MIRPragma *pragma : pragmaVec) {
+    MIRType *pragmaType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pragma->GetTyIdx());
+    if (pragmaType->GetName() != "Lark_2Fannotation_2FSignature_3B") {
+      continue;
+    }
+    if (pragma->GetKind() != kPragmaClass) {
+      continue;
+    }
+    AnalysisAnnotationForClass(*pragma);
+  }
+}
+
+void AnnotationAnalysis::AAForFuncVarInfo(MIRStructType &structType) {
+  std::vector<MIRPragma*> &pragmaVec = structType.GetPragmaVec();
+  for (MIRPragma *pragma : pragmaVec) {
+    MIRType *pragmaType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pragma->GetTyIdx());
+    if (pragmaType->GetName() != "Lark_2Fannotation_2FSignature_3B") {
+      continue;
+    }
+    if (pragma->GetKind() == kPragmaVar) {
+      AnalysisAnnotationForVar(*pragma, structType);
+    } else if (pragma->GetKind() == kPragmaFunc) {
+      AnalysisAnnotationForFunc(*pragma, structType);
+    }
+  }
+}
+
+void AnnotationAnalysis::AnalysisAnnotation() {
+  const MapleVector<Klass*> &klasses = klassH->GetTopoSortedKlasses();
+  for (Klass *klass : klasses) {
+    if (klass->IsInterfaceIncomplete() || klass->IsClassIncomplete()) {
+      continue;
+    }
+    MIRStructType *structType = klass->GetMIRStructType();
+    AAForClassInfo(*structType);
+  }
+  for (Klass *klass : klasses) {
+    if (klass->IsInterfaceIncomplete() || klass->IsClassIncomplete()) {
+      continue;
+    }
+    MIRStructType *structType = klass->GetMIRStructType();
+    AAForFuncVarInfo(*structType);
+  }
+  for (MIRFunction *func : std::as_const(mirModule->GetFunctionList())) {
+    if (func->IsEmpty() || analysisedFunc.find(func) != analysisedFunc.end()) {
+      continue;
+    }
+    MIRType *classType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(func->GetClassTyIdx());
+    if (classType == nullptr) {
+      continue;
+    }
+    std::string tmp;
+    AnnotationParser aParser(tmp);
+    AnalysisAnnotationForFuncLocalVar(*func, aParser, static_cast<MIRStructType&>(*classType));
+  }
+}
+
+void AnnotationAnalysis::Run() {
+  AnalysisAnnotation();
+}
+
+void M2MAnnotationAnalysis::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+}
+
+bool M2MAnnotationAnalysis::PhaseRun(maple::MIRModule &m) {
+  auto *kh = GET_ANALYSIS(M2MKlassHierarchy, m);
+  ASSERT_NOT_NULL(kh);
+  MemPool *pragmaMemPool = GetPhaseMemPool();
+  aa = pragmaMemPool->New<AnnotationAnalysis>(&m, ApplyTempMemPool(), *pragmaMemPool, kh);
+  aa->Run();
+  return false;
+}
+}
diff --git a/src/mapleall/mpl2mpl/src/barrierinsertion.cpp b/src/mapleall/mpl2mpl/src/barrierinsertion.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..22908697f49a4cac222fc2ed397c515e442c5a31
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/barrierinsertion.cpp
@@ -0,0 +1,440 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "barrierinsertion.h"
+#include <set>
+#include "vtable_impl.h"
+#include "mir_function.h"
+#include "mir_builder.h"
+#include "global_tables.h"
+#include "option.h"
+#include "mpl_logging.h"
+#include "opcode_info.h"
+
+// BARDEBUG is turned on by passing -dump-phase=barrierinsertion to mpl2mpl
+#define BARDEBUG (Options::dumpPhase.compare(PhaseName()) == 0)
+// use this pass just for memory verification
+#define MEMVERIFY
+
+namespace maple {
+#ifdef NOT_USED
+CallNode *BarrierInsertion::RunFunction::CreateWriteRefVarCall(BaseNode &var, BaseNode &value) const {
+  MIRFunction *callee = builder->GetOrCreateFunction("MCC_WriteRefVar", static_cast<TyIdx>(PTY_void));
+  MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.push_back(&var);
+  args.push_back(&value);
+  return builder->CreateStmtCall(callee->GetPuidx(), args);
+}
+
+CallNode *BarrierInsertion::RunFunction::CreateWriteRefFieldCall(BaseNode &obj, BaseNode &field,
+                                                                 BaseNode &value) const {
+  MIRFunction *callee = builder->GetOrCreateFunction("MCC_WriteRefField", static_cast<TyIdx>(PTY_void));
+  MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.push_back(&obj);
+  args.push_back(&field);
+  args.push_back(&value);
+  return builder->CreateStmtCall(callee->GetPuidx(), args);
+}
+
+CallNode *BarrierInsertion::RunFunction::CreateReleaseRefVarCall(BaseNode &var) const {
+  MIRFunction *callee = builder->GetOrCreateFunction("MCC_ReleaseRefVar", TyIdx(PTY_void));
+  MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.push_back(&var);
+  return builder->CreateStmtCall(callee->GetPuidx(), args);
+}
+
+CallNode *BarrierInsertion::RunFunction::CreateMemCheckCall(BaseNode &var) const {
+  MIRFunction *callee = builder->GetOrCreateFunction("MCC_CheckObjMem", TyIdx(PTY_void));
+  MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.push_back(&var);
+  return builder->CreateStmtCall(callee->GetPuidx(), args);
+}
+
+bool BarrierInsertion::RunFunction::SkipRHS(const BaseNode &rhs) const {
+  // only consider reference
+  if (rhs.GetPrimType() != PTY_ref) {
+    return true;
+  }
+  if (rhs.GetOpCode() == OP_conststr16) {
+    return true;  // conststr
+  }
+  if (rhs.GetOpCode() == OP_intrinsicopwithtype) {
+    auto *node = static_cast<const IntrinsicopNode*>(&rhs);
+    if (node->GetIntrinsic() == INTRN_JAVA_CONST_CLASS) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// create a backup variable symbol using a counter inside its name
+MIRSymbol *BarrierInsertion::RunFunction::NewBackupVariable(const std::string &suffix) {
+  std::ostringstream oss;
+  oss << "__backup" << backupVarCount << "_" << suffix << "__";
+  ++backupVarCount;
+  std::string name = oss.str();
+  MIRSymbol *backupSym =
+      builder->GetOrCreateLocalDecl(name, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_ref)));
+  backupVarIndices.insert(backupSym->GetStIdx());
+  return backupSym;
+}
+
+// go through each stmt in the block, memory check for all
+// iread and iassign of PTY_ref type , i.e., read/write to heap objects
+void BarrierInsertion::RunFunction::HandleBlock(BlockNode &block) const {
+  for (StmtNode *stmt = block.GetFirst(); stmt != nullptr; stmt = stmt->GetNext()) {
+    stmt = HandleStmt(*stmt, block);
+  }
+}
+
+GStrIdx reflectClassNameIdx;
+GStrIdx reflectMethodNameIdx;
+GStrIdx reflectFieldNameIdx;
+// This function exams one operand of a StmtNode and insert memory check calls
+// when it is iread of PTY_ref
+StmtNode *BarrierInsertion::RunFunction::CheckRefRead(BaseNode *opnd, const StmtNode &stmt, BlockNode &block) const {
+  if (opnd == nullptr || opnd->GetPrimType() != PTY_ref) {
+    return nullptr;
+  }
+  if (opnd->GetOpCode() == OP_dread) {
+    DreadNode *val = static_cast<DreadNode*>(opnd);
+    MIRSymbol *sym = mirFunc->GetLocalOrGlobalSymbol((static_cast<DreadNode*>(val))->GetStIdx());
+    if (sym != nullptr && sym->IgnoreRC()) {
+      return nullptr;
+    }
+    CallNode *checkStmt = CreateMemCheckCall(*opnd);
+    block.InsertBefore(&stmt, checkStmt);
+    return checkStmt;
+  }
+  if (opnd->GetOpCode() == OP_iread) {
+    IreadNode *iread = static_cast<IreadNode*>(opnd);
+    // after the reference value is read from heap, call for verification
+    MIRPtrType *ptrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx()));
+    GStrIdx strIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrType->GetPointedTyIdx())->GetNameStrIdx();
+    if (reflectClassNameIdx == 0u) {
+      reflectClassNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::GetInternalNameLiteral("Ljava_2Flang_2FClass_3B"));
+      reflectMethodNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::GetInternalNameLiteral("Ljava_2Flang_2Freflect_2FMethod_3B"));
+      reflectFieldNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+          namemangler::GetInternalNameLiteral("Ljava_2Flang_2Freflect_2FField_3B"));
+    }
+    if (strIdx == reflectClassNameIdx || strIdx == reflectMethodNameIdx || strIdx == reflectFieldNameIdx) {
+      return nullptr;
+    }
+    CallNode *checkStmt = CreateMemCheckCall(*opnd);
+    block.InsertBefore(&stmt, checkStmt);
+    return checkStmt;
+  } else if (opnd->GetOpCode() == OP_retype) {
+    return nullptr;
+  }
+  return nullptr;
+}
+
+// This function exams one StmtNode and carrys out necessary operations for
+// reference counting or memory verification.
+// For barrier RC, below are the opcodes related and how they are handled:
+// [dassign]
+// Condition: 1) rhs is reference (other than conststr16, global symbols)
+//            2) symbols not ignored
+//            3) Not a self-assignment (dassign v (dread v))
+// Handling:  1) Replace dassign with a call to MCC_WriteRefVar.
+//            2) If assigned to a formal parameter, make a backup variable in the
+//               prologue after processing all statements.
+//
+// [iassign]
+// Condition: 1) rhs is not addressof symbols with names starting "__vtab__" or
+//               "__itab__" (vtab, itab initialization
+// Handling:  1) Replace iassign with a call to CC_WriteRefField.
+//
+// [[|i|intrinsic]callassigned]
+// Condition: 1) Return type is ref.
+// Handling:  1) Assign return values to temporary variables, use
+//               MCC_ReleaseRefVar on the original return variable, and then
+//               dassign the tmp variable to the actual return var.
+//
+// [call]
+// Condition: 1) Return type is ref.
+// Handling:  1) Assign return values to temporary variables, and then call
+//               MCC_ReleaseRefVar on them.
+//
+// [return]
+// Assumption: 1) If the return type is ref, assume it is the result of a dread.
+// Handling:   1) If the return value is a reference, consider it as if it is
+//                assigned to.
+//             2) Call MCC_ReleaseRefVar on all local vars except un-assigned
+//                parameters and the return value. this is processed after
+//                procesing all statements.
+//
+// This function returns the last stmt it generated or visited.  HandleBlock
+// shall continue with the next statement after the return value, if any.
+StmtNode *BarrierInsertion::RunFunction::HandleStmt(StmtNode &stmt, BlockNode &block) const {
+  Opcode opcode = stmt.GetOpCode();
+#ifdef MEMVERIFY
+  // ignore decref opcode due to missing initialization in whitelist func
+  if (opcode != OP_decref && opcode != OP_intrinsiccall) {
+    for (size_t i = (opcode == OP_iassign ? 1 : 0); i < stmt.NumOpnds(); ++i) {
+      (void)CheckRefRead(stmt.Opnd(i), stmt, block);
+    }
+  }
+#endif
+  switch (opcode) {
+    case OP_dassign: {
+      DassignNode *dassign = static_cast<DassignNode*>(&stmt);
+      BaseNode *rhs = dassign->GetRHS();
+      if (SkipRHS(*rhs)) {
+        break;
+      }
+      MIRSymbol *refSym = mirFunc->GetLocalOrGlobalSymbol(dassign->GetStIdx());
+      CHECK_FATAL(refSym != nullptr, "Symbol is nullptr");
+      if (refSym->IgnoreRC()) {
+        break;
+      }
+      if (BARDEBUG) {
+        dassign->Dump(0);
+      }
+#ifdef MEMVERIFY
+      DreadNode *checkObjRead =
+          builder->CreateExprDread(*GlobalTables::GetTypeTable().GetRef(), dassign->GetFieldID(), *refSym);
+      CallNode *checkStmt = CreateMemCheckCall(*checkObjRead);
+      block.InsertAfter(&stmt, checkStmt);
+      return checkStmt;
+#endif
+    }
+    case OP_iassign: {
+      IassignNode *iassign = static_cast<IassignNode*>(&stmt);
+      BaseNode *rhs = iassign->GetRHS();
+      if (SkipRHS(*rhs)) {
+        break;
+      }
+      if (rhs->GetOpCode() == OP_addrof) {
+        // ignore $__vtab__ such as in
+        // iassign <* <$LPoint_3B>> 3 (dread ptr %_this, addrof ptr $__vtab__LPoint_3B)
+        AddrofNode *aNode = static_cast<AddrofNode*>(rhs);
+        MIRSymbol *curSt = mirFunc->GetLocalOrGlobalSymbol(aNode->GetStIdx());
+        if (curSt->HasAddrOfValues()) {
+          break;
+        }
+      }
+      if (BARDEBUG) {
+        iassign->Dump(0);
+      }
+#ifdef MEMVERIFY
+      // Call memory verification
+      CallNode *newStmt = CreateMemCheckCall(*rhs);
+      block.InsertAfter(&stmt, newStmt);
+      return newStmt;
+#endif
+    }
+    default:
+      break;
+  }
+  return &stmt;
+}
+
+// this function handles local ref var initialization
+// and formal ref parameters backup
+void BarrierInsertion::RunFunction::InsertPrologue() {
+  StmtNode *firstStmt = mirFunc->GetBody()->GetFirst();
+  // Copy assigned formal parameters to backup variables using MCC_WriteRefVar.
+  // This will inc those parameters, and those parameters will be dec-ed before
+  // returning.
+  for (StIdx asgnParam : assignedParams) {
+    MIRSymbol *backupSym = NewBackupVariable("modified_param");
+    // Clear the temporary variable
+    ConstvalNode *rhsZero = builder->CreateIntConst(0, PTY_ref);
+    DassignNode *dassignClear = builder->CreateStmtDassign(*backupSym, 0, rhsZero);
+    mirFunc->GetBody()->InsertBefore(firstStmt, dassignClear);
+    // Backup the parameter
+    AddrofNode *lhsAddr = builder->CreateExprAddrof(0, backupSym->GetStIdx());
+    DreadNode *rhs = builder->CreateDread(*mirFunc->GetSymTab()->GetSymbolFromStIdx(asgnParam.Idx()), PTY_ref);
+    CallNode *newStmt = CreateWriteRefVarCall(*lhsAddr, *rhs);
+    mirFunc->GetBody()->InsertBefore(firstStmt, newStmt);
+  }
+  // Initialize local variables (but not formal parameters) of ref type to 0.
+  size_t bSize = mirFunc->GetSymTab()->GetSymbolTableSize();
+  for (size_t i = 1; i < bSize; ++i) {
+    // 0 is a reserved stIdx.
+    MIRSymbol *sym = mirFunc->GetSymTab()->GetSymbolFromStIdx(i);
+    CHECK_FATAL(sym != nullptr, "sym is nullptr");
+    if (sym->GetStorageClass() != kScAuto ||
+        (GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx())->GetPrimType() != PTY_ref)) {
+      continue;
+    }
+    if (sym->IgnoreRC()) {
+      continue;
+    }
+    if (backupVarIndices.find(sym->GetStIdx()) != backupVarIndices.end()) {
+      continue;
+    }
+    if (BARDEBUG) {
+      LogInfo::MapleLogger() << "Local variable " << sym->GetName() << " set to null\n";
+    }
+    mirFunc->GetBody()->InsertBefore(firstStmt,
+                                     builder->CreateStmtDassign(*sym, 0, builder->CreateIntConst(0, PTY_ref)));
+  }
+}
+
+void BarrierInsertion::RunFunction::HandleReturn(const NaryStmtNode &retNode) {
+  std::set<StIdx> retValStIdxs;
+  for (size_t i = 0; i < retNode.NumOpnds(); ++i) {
+    BaseNode *val = retNode.Opnd(i);
+    if (val->GetOpCode() == OP_constval && static_cast<ConstvalNode*>(val)->GetConstVal()->IsMagicNum()) {
+      if (BARDEBUG) {
+        LogInfo::MapleLogger() << "BARDEBUG: Ignoring magic number return\n";
+      }
+      continue;
+    }
+    if (val->GetPrimType() != PTY_ref) {
+      continue;
+    }
+    if (val->GetOpCode() != OP_dread) {
+      if (val->GetOpCode() == OP_constval) {
+        auto constvalNode = static_cast<ConstvalNode*>(val);
+        MIRConst *con = constvalNode->GetConstVal();
+        if (con->GetKind() == kConstInt) {
+          auto intConst = safe_cast<MIRIntConst>(con);
+          if (intConst->IsZero()) {
+            // It is a nullptr.  Skip this return value.
+            continue;
+          }
+        }
+      }
+      CHECK_FATAL(false,
+                  "Found a return statement that returns a ref but is not from a dread.  Please enable the code below"
+                  "this line.");
+    } else {
+      // It is a dassign.  Blacklist this symbol for this return.
+      DreadNode *dreadNode = static_cast<DreadNode*>(val);
+      MIRSymbol *sym = mirFunc->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+      CHECK_FATAL(sym != nullptr, "sym is null");
+      if (sym->IgnoreRC()) {
+        continue;
+      }
+      if (sym->GetStorageClass() == kScFormal && assignedParams.find(sym->GetStIdx()) == assignedParams.end()) {
+        // If returning a parameter that is never assigned to,
+        // insert a MCC_WriteRefVar to a temp var before returning.
+        MIRSymbol *backupSym = NewBackupVariable("ret_prarm_unassigned");
+        // Clear the temporary variable
+        ConstvalNode *rhsZero = builder->CreateIntConst(0, PTY_ref);
+        DassignNode *dassignClear = builder->CreateStmtDassign(*backupSym, 0, rhsZero);
+        mirFunc->GetBody()->InsertBefore(&retNode, dassignClear);
+        // Assign the parameter to the temporary variable
+        AddrofNode *lhsAddr = builder->CreateExprAddrof(0, backupSym->GetStIdx());
+        DreadNode *newDreadNode = builder->CreateDread(*sym, PTY_ref);
+        CallNode *newStmt = CreateWriteRefVarCall(*lhsAddr, *newDreadNode);
+        mirFunc->GetBody()->InsertBefore(&retNode, newStmt);
+      }
+      (void)retValStIdxs.insert(dreadNode->GetStIdx());
+    }
+  }
+  // now release all local reference except return values
+  size_t size = mirFunc->GetSymTab()->GetSymbolTableSize();
+  for (size_t i = 1; i < size; ++i) {
+    // 0 is a reserved stIdx.
+    MIRSymbol *localSym = mirFunc->GetSymTab()->GetSymbolFromStIdx(i);
+    CHECK_FATAL(localSym != nullptr, "local_sym is nullptr");
+    if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(localSym->GetTyIdx())->GetPrimType() == PTY_ref &&
+        (localSym->GetStorageClass() == kScAuto || assignedParams.find(localSym->GetStIdx()) != assignedParams.end())) {
+      if (localSym->IgnoreRC()) {
+        continue;
+      }
+      if (backupVarIndices.find(localSym->GetStIdx()) != backupVarIndices.end()) {
+        continue;
+      }
+      if (retValStIdxs.find(localSym->GetStIdx()) != retValStIdxs.end()) {
+        continue;
+      }
+      if (BARDEBUG) {
+        LogInfo::MapleLogger() << "Local variable " << localSym->GetName() << " going out of scope\n";
+      }
+      // Attempt to release var if it is not the return value.
+      DreadNode *localVar = builder->CreateDread(*localSym, PTY_ref);
+      mirFunc->GetBody()->InsertBefore(&retNode, CreateReleaseRefVarCall(*localVar));
+    }
+  }
+}
+
+void BarrierInsertion::RunFunction::Run() {
+  mirModule->SetCurFunction(mirFunc);
+  backupVarCount = 0;
+  HandleBlock(*mirFunc->GetBody());
+}
+
+void BarrierInsertion::EnsureLibraryFunction(MIRModule &module, const char &name, const MIRType &retType,
+                                             const ArgVector &args) {
+  MIRFunction *func = module.GetMIRBuilder()->CreateFunction(&name, retType, args);
+  CHECK_FATAL(func != nullptr, "func is null in BarrierInsertion::EnsureLibraryFunction");
+  func->SetBody(nullptr);
+  module.AddFunction(func);
+}
+
+void BarrierInsertion::EnsureLibraryFunctions(MIRModule &module) {
+  {
+    constexpr const char *name = "MCC_WriteRefVar";
+    MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_void));
+    ArgVector args(module.GetMPAllocator().Adapter());
+    args.push_back(ArgPair("var", GlobalTables::GetTypeTable().GetVoidPtr()));
+    args.push_back(ArgPair("value", GlobalTables::GetTypeTable().GetVoidPtr()));
+    EnsureLibraryFunction(module, *name, *retType, args);
+  }
+  {
+    constexpr const char *name = "MCC_WriteRefField";
+    MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_void));
+    ArgVector args(module.GetMPAllocator().Adapter());
+    args.push_back(ArgPair("obj", GlobalTables::GetTypeTable().GetVoidPtr()));
+    args.push_back(ArgPair("field", GlobalTables::GetTypeTable().GetVoidPtr()));
+    args.push_back(ArgPair("value", GlobalTables::GetTypeTable().GetVoidPtr()));
+    EnsureLibraryFunction(module, *name, *retType, args);
+  }
+  {
+    constexpr const char *name = "MCC_ReleaseRefVar";
+    MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_void));
+    ArgVector args(module.GetMPAllocator().Adapter());
+    args.push_back(ArgPair("var", GlobalTables::GetTypeTable().GetVoidPtr()));
+    EnsureLibraryFunction(module, *name, *retType, args);
+  }
+  {
+    constexpr const char *name = "MCC_CheckObjMem";
+    MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_void));
+    ArgVector args(module.GetMPAllocator().Adapter());
+    args.push_back(ArgPair("var", GlobalTables::GetTypeTable().GetVoidPtr()));
+    EnsureLibraryFunction(module, *name, *retType, args);
+  }
+}
+
+AnalysisResult *BarrierInsertion::Run(MIRModule *module, ModuleResultMgr*) {
+#ifndef MEMVERIFY
+  return nullptr;
+#endif
+  for (MIRFunction *func : module->GetFunctionList()) {
+    if (PhaseName().empty()) {
+      continue;
+    }
+    if (BARDEBUG) {
+      LogInfo::MapleLogger() << " Handling function " << func->GetName() << "\n";
+    }
+    if (Options::dumpFunc == func->GetName()) {
+      LogInfo::MapleLogger() << "Function found" << "\n";
+    }
+    if (func->GetBody() == nullptr) {
+      continue;
+    }
+    RunFunction runFunction(*this, *module, *func);
+    runFunction.Run();
+  }
+  return nullptr;
+}
+#endif
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/call_graph.cpp b/src/mapleall/mpl2mpl/src/call_graph.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f8e0697c30c351ddb3bd4049cf566d5d520be36d
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/call_graph.cpp
@@ -0,0 +1,2038 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "call_graph.h"
+
+#include "option.h"
+#include "retype.h"
+#include "string_utils.h"
+#include "inline_summary.h"
+
+//                   Call Graph Analysis
+// This phase is a foundation phase of compilation. This phase build
+// the call graph not only for this module also for the modules it
+// depends on when this phase is running for IPA.
+// The main procedure shows as following.
+// A. Devirtual virtual call of private final static and none-static
+//    variable. This step aims to reduce the callee set for each call
+//    which can benefit IPA analysis.
+// B. Build Call Graph.
+//    i)  For IPA, it rebuild all the call graph of the modules this
+//        module depends on. All necessary information is stored in mplt.
+//    ii) Analysis each function in this module. For each call statement
+//        create a CGNode, and collect potential callee functions to
+//        generate Call Graph.
+// C. Find All Root Node for the Call Graph.
+// D. Construct SCC based on Tarjan Algorithm
+// E. Set compilation order as the bottom-up order of callgraph. So callee
+//    is always compiled before caller. This benefits those optimizations
+//    need interprocedure information like escape analysis.
+namespace maple {
+const std::string CallInfo::GetCallTypeName() const {
+  switch (cType) {
+    case kCallTypeCall:
+      return "c";
+    case kCallTypeVirtualCall:
+      return "v";
+    case kCallTypeSuperCall:
+      return "s";
+    case kCallTypeInterfaceCall:
+      return "i";
+    case kCallTypeIcall:
+      return "icall";
+    case kCallTypeIntrinsicCall:
+      return "intrinsiccall";
+    case kCallTypeXinitrinsicCall:
+      return "xintrinsiccall";
+    case kCallTypeIntrinsicCallWithType:
+      return "intrinsiccallwithtype";
+    case kCallTypeFakeThreadStartRun:
+      return "fakecallstartrun";
+    case kCallTypeCustomCall:
+      return "customcall";
+    case kCallTypePolymorphicCall:
+      return "polymorphiccall";
+    default:
+      CHECK_FATAL(false, "unsupport CALL type");
+      return "";
+  }
+}
+
+void CallInfo::Dump() const {
+  if (caller->GetInlineSummary()) {
+    LogInfo::MapleLogger() << "<" << caller->GetInlineSummary()->GetStaticInsns() << ">";
+  }
+  LogInfo::MapleLogger() << caller->GetName() << "->" << callee->GetName();
+  if (callee->GetInlineSummary()) {
+    LogInfo::MapleLogger() << "<" << callee->GetInlineSummary()->GetStaticInsns() << ">";
+  }
+  LogInfo::MapleLogger() << "/id:" << id;
+}
+
+const char *GetInlineFailedStr(InlineFailedCode code) {
+#undef DEF_IF
+#define DEF_IF(code, type, desc) (desc),
+  static const char *inlineFailedStrTable[kIFC_End] = {
+#include "inline_failed.def"
+  };
+#undef DEF_IF
+  ASSERT(static_cast<uint32>(code) < static_cast<uint32>(kIFC_End), "out of range");
+  return inlineFailedStrTable[code];
+}
+
+InlineFailedType GetInlineFailedType(InlineFailedCode code) {
+#undef DEF_IF
+#define DEF_IF(code, type, desc) (type),
+  static InlineFailedType inlineFailedTypeTable[kIFC_End] = {
+#include "inline_failed.def"
+  };
+#undef DEF_IF
+  ASSERT(static_cast<uint32>(code) < static_cast<uint32>(kIFC_End), "out of range");
+  return inlineFailedTypeTable[code];
+}
+
+const std::string CallInfo::GetCalleeName() const {
+  if ((cType >= kCallTypeCall) && (cType <= kCallTypeInterfaceCall)) {
+    MIRFunction &mirf = *GetCallee();
+    return mirf.GetName();
+  } else if (cType == kCallTypeIcall) {
+    return "IcallUnknown";
+  } else if ((cType >= kCallTypeIntrinsicCall) && (cType <= kCallTypeIntrinsicCallWithType)) {
+    return "IntrinsicCall";
+  } else if (cType == kCallTypeCustomCall) {
+    return "CustomCall";
+  } else if (cType == kCallTypePolymorphicCall) {
+    return "PolymorphicCall";
+  }
+  CHECK_FATAL(false, "should not be here");
+  return "";
+}
+
+void CGNode::DumpDetail() const {
+  LogInfo::MapleLogger() << "---CGNode  @" << this << ": " << mirFunc->GetName() << "\t";
+  if (Options::profileUse && mirFunc->GetFuncProfData()) {
+    LogInfo::MapleLogger() << " Ffreq " << GetFuncFrequency() << "\t";
+  }
+  if (HasOneCandidate() != nullptr) {
+    LogInfo::MapleLogger() << "@One Candidate\n";
+  } else {
+    LogInfo::MapleLogger() << std::endl;
+  }
+  if (HasSetVCallCandidates()) {
+    for (uint32 i = 0; i < vcallCands.size(); ++i) {
+      LogInfo::MapleLogger() << "   virtual call candidates: " << vcallCands[i]->GetName() << "\n";
+    }
+  }
+  for (auto &callSite : callees) {
+    for (auto &cgIt : *callSite.second) {
+      CallInfo *ci = callSite.first;
+      CGNode *node = cgIt;
+      MIRFunction *mf = node->GetMIRFunction();
+      if (mf != nullptr) {
+        LogInfo::MapleLogger() << "\tcallee in module : " << mf->GetName() << "  ";
+      } else {
+        LogInfo::MapleLogger() << "\tcallee external: " << ci->GetCalleeName();
+      }
+      if (Options::profileUse) {
+        LogInfo::MapleLogger() << " callsite freq" << GetCallsiteFrequency(ci->GetCallStmt());
+      }
+      LogInfo::MapleLogger() << "\n";
+    }
+  }
+  // dump caller
+  for (auto const &callerNode : GetCaller()) {
+    CHECK_NULL_FATAL(callerNode.first);
+    CHECK_NULL_FATAL(callerNode.first->mirFunc);
+    LogInfo::MapleLogger() << "\tcaller : " << callerNode.first->mirFunc->GetName() << std::endl;
+  }
+}
+
+void CGNode::Dump(std::ofstream &fout) const {
+  // if dumpall == 1, dump whole call graph
+  // else dump callgraph with function defined in same module
+  CHECK_NULL_FATAL(mirFunc);
+  constexpr size_t withoutRingNodeSize = 1;
+  if (callees.empty()) {
+    fout << "\"" << mirFunc->GetName() << "\";\n";
+    return;
+  }
+  for (auto &callSite : callees) {
+    for (auto &cgIt : *callSite.second) {
+      CallInfo *ci = callSite.first;
+      CGNode *node = cgIt;
+      if (node == nullptr) {
+        continue;
+      }
+      MIRFunction *func = node->GetMIRFunction();
+      fout << "\"" << mirFunc->GetName() << "\" -> ";
+      if (func != nullptr) {
+        if (node->GetSCCNode() != nullptr && node->GetSCCNode()->GetNodes().size() > withoutRingNodeSize) {
+          fout << "\"" << func->GetName() << "\"[label=" << node->GetSCCNode()->GetID() << " color=red];\n";
+        } else {
+          fout << "\"" << func->GetName() << "\"[label=" << 0 << " color=blue];\n";
+        }
+      } else {
+        // unknown / external function with empty function body
+        fout << "\"" << ci->GetCalleeName() << "\"[label=" << ci->GetCallTypeName() << " color=blue];\n";
+      }
+    }
+  }
+}
+
+CallInfo *CallGraph::AddCallsite(CallType type, CGNode &caller, CGNode &callee, CallNode &call) {
+  auto *callInfo = GenCallInfo(type, *caller.GetMIRFunction(), *callee.GetMIRFunction(), call);
+  caller.AddCallsite(*callInfo, &callee);
+  return callInfo;
+}
+
+void CGNode::AddCallsite(CallInfo *ci, MapleSet<CGNode*, Comparator<CGNode>> *callee) {
+  (void)callees.insert(std::pair<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*>(ci, callee));
+}
+
+void CGNode::AddCallsite(CallInfo &ci, CGNode *node) {
+  CHECK_FATAL(ci.GetCallType() != kCallTypeInterfaceCall, "must be true");
+  CHECK_FATAL(ci.GetCallType() != kCallTypeVirtualCall, "must be true");
+  auto *cgVector = alloc->GetMemPool()->New<MapleSet<CGNode*, Comparator<CGNode>>>(alloc->Adapter());
+  if (node != nullptr) {
+    node->AddNumRefs();
+    cgVector->insert(node);
+  }
+  (void)callees.emplace(&ci, cgVector);
+}
+
+void CGNode::RemoveCallsite(uint32 stmtID) {
+  for (auto &callSite : std::as_const(GetCallee())) {
+    if (callSite.first->GetID() != stmtID) {
+      continue;
+    }
+    for (auto *node : *callSite.second) {
+      node->DelCaller(this);
+      node->DecreaseNumRefs();
+    }
+    callSite.second->clear();
+    return;
+  }
+  CHECK_FATAL_FALSE("node doesn't exist.");
+}
+
+void CGNode::RemoveCallsite(const CallInfo *ci) {
+  for (auto &callSite : std::as_const(GetCallee())) {
+    if (callSite.first != ci) {
+      continue;
+    }
+    for (auto *node : *callSite.second) {
+      node->DelCaller(this);
+      node->DecreaseNumRefs();
+    }
+    callSite.second->clear();
+    return;
+  }
+  CHECK_FATAL_FALSE("node isn't in ci");
+}
+
+bool CGNode::IsCalleeOf(CGNode *func) const {
+  return callers.find(func) != callers.end();
+}
+
+uint64_t CGNode::GetCallsiteFrequency(const StmtNode *callstmt) const {
+  FuncProfInfo *funcInfo = mirFunc->GetFuncProfData();
+  if (funcInfo->stmtFreqs.count(callstmt->GetStmtID()) > 0) {
+    return funcInfo->stmtFreqs[callstmt->GetStmtID()];
+  }
+  ASSERT(0, "should not be here");
+  return UINT64_MAX;
+}
+
+uint64_t CGNode::GetFuncFrequency() const {
+  FuncProfInfo *funcInfo = mirFunc->GetFuncProfData();
+  if (funcInfo) {
+    return funcInfo->GetFuncRealFrequency();
+  }
+  ASSERT(0, "should not be here");
+  return 0;
+}
+
+void CallGraph::ClearFunctionList() {
+  for (auto iter = mirModule->GetFunctionList().begin(); iter != mirModule->GetFunctionList().end();) {
+    if (GlobalTables::GetFunctionTable().GetFunctionFromPuidx((*iter)->GetPuidx()) == nullptr) {
+      (*iter)->ReleaseCodeMemory();
+      (*iter)->ReleaseMemory();
+      iter = mirModule->GetFunctionList().erase(iter);
+    } else {
+      ++iter;
+    }
+  }
+}
+
+void CallGraph::DelNode(CGNode &node) {
+  if (node.GetMIRFunction() == nullptr) {
+    return;
+  }
+  for (auto &callSite : std::as_const(node.GetCallee())) {
+    for (auto &cgIt : *callSite.second) {
+      cgIt->DelCaller(&node);
+      node.DelCallee(callSite.first, cgIt);
+      if (!cgIt->HasCaller() && cgIt->GetMIRFunction()->IsStatic() && !cgIt->IsAddrTaken()) {
+        DelNode(*cgIt);
+      }
+    }
+  }
+  MIRFunction *func = node.GetMIRFunction();
+  // Delete the method of class info
+  if (func->GetClassTyIdx() != 0u) {
+    MIRType *classType = GlobalTables::GetTypeTable().GetTypeTable().at(func->GetClassTyIdx());
+    auto *mirStructType = static_cast<MIRStructType*>(classType);
+    size_t j = 0;
+    for (; j < mirStructType->GetMethods().size(); ++j) {
+      if (mirStructType->GetMethodsElement(j).first == func->GetStIdx()) {
+        mirStructType->GetMethods().erase(mirStructType->GetMethods().cbegin() + static_cast<ssize_t>(j));
+        break;
+      }
+    }
+  }
+  func->SetBody(nullptr);
+  // func will be erased, so the coressponding symbol should be set as Deleted
+  ASSERT_NOT_NULL(func);
+  ASSERT_NOT_NULL(func->GetFuncSymbol());
+  func->GetFuncSymbol()->SetIsDeleted();
+  nodesMap.erase(func);
+  // Update Klass info as it has been built
+  if (klassh->GetKlassFromFunc(func) != nullptr) {
+    klassh->GetKlassFromFunc(func)->DelMethod(*func);
+  }
+}
+
+CallGraph::CallGraph(MIRModule &m, MemPool &memPool, MemPool &templPool, const KlassHierarchy &kh,
+                     const std::string &fn)
+    : AnalysisResult(&memPool),
+      mirModule(&m),
+      cgAlloc(&memPool),
+      tempAlloc(&templPool),
+      mirBuilder(cgAlloc.GetMemPool()->New<MIRBuilder>(&m)),
+      entryNode(nullptr),
+      rootNodes(cgAlloc.Adapter()),
+      fileName(fn, &memPool),
+      klassh(&kh),
+      nodesMap(cgAlloc.Adapter()),
+      sccTopologicalVec(cgAlloc.Adapter()),
+      localConstValueMap(tempAlloc.Adapter()),
+      icallToFix(tempAlloc.Adapter()),
+      addressTakenPuidxs(tempAlloc.Adapter()),
+      numOfNodes(0),
+      numOfSccs(0) {}
+
+CallType CallGraph::GetCallType(Opcode op) const {
+  CallType typeTemp = kCallTypeInvalid;
+  switch (op) {
+    case OP_call:
+    case OP_callassigned:
+      typeTemp = kCallTypeCall;
+      break;
+    case OP_virtualcall:
+    case OP_virtualcallassigned:
+      typeTemp = kCallTypeVirtualCall;
+      break;
+    case OP_superclasscall:
+    case OP_superclasscallassigned:
+      typeTemp = kCallTypeSuperCall;
+      break;
+    case OP_interfacecall:
+    case OP_interfacecallassigned:
+      typeTemp = kCallTypeInterfaceCall;
+      break;
+    case OP_icall:
+    case OP_icallassigned:
+      typeTemp = kCallTypeIcall;
+      break;
+    case OP_intrinsiccall:
+    case OP_intrinsiccallassigned:
+      typeTemp = kCallTypeIntrinsicCall;
+      break;
+    case OP_xintrinsiccall:
+    case OP_xintrinsiccallassigned:
+      typeTemp = kCallTypeXinitrinsicCall;
+      break;
+    case OP_intrinsiccallwithtype:
+    case OP_intrinsiccallwithtypeassigned:
+      typeTemp = kCallTypeIntrinsicCallWithType;
+      break;
+    case OP_customcall:
+    case OP_customcallassigned:
+      typeTemp = kCallTypeCustomCall;
+      break;
+    case OP_polymorphiccall:
+    case OP_polymorphiccallassigned:
+      typeTemp = kCallTypePolymorphicCall;
+      break;
+    default:
+      break;
+  }
+  return typeTemp;
+}
+
+CGNode *CallGraph::GetCGNode(MIRFunction *func) const {
+  if (nodesMap.find(func) != nodesMap.end()) {
+    return nodesMap.at(func);
+  }
+  return nullptr;
+}
+
+CGNode *CallGraph::GetCGNode(const PUIdx puIdx) const {
+  return GetCGNode(GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx));
+}
+
+SCCNode<CGNode> *CallGraph::GetSCCNode(MIRFunction *func) const {
+  CGNode *cgNode = GetCGNode(func);
+  return (cgNode != nullptr) ? cgNode->GetSCCNode() : nullptr;
+}
+
+void CallGraph::UpdateCaleeCandidate(PUIdx callerPuIdx, const IcallNode *icall, std::set<PUIdx> &candidate) {
+  CGNode *caller = GetCGNode(callerPuIdx);
+  for (auto &pair : std::as_const(caller->GetCallee())) {
+    auto *callsite = pair.first;
+    if (callsite->GetCallStmt() == icall) {
+      auto *calleeSet = pair.second;
+      calleeSet->clear();
+      std::for_each(candidate.begin(), candidate.end(), [this, &calleeSet](PUIdx idx) {
+        CGNode *callee = GetCGNode(idx);
+        calleeSet->insert(callee);
+      });
+      return;
+    }
+  }
+}
+
+void CallGraph::UpdateCaleeCandidate(PUIdx callerPuIdx, const IcallNode *icall, PUIdx calleePuidx, CallNode *call) {
+  CGNode *caller = GetCGNode(callerPuIdx);
+  for (auto &pair : std::as_const(caller->GetCallee())) {
+    auto *callsite = pair.first;
+    if (callsite->GetCallStmt() == icall) {
+      callsite->SetCallStmt(call);
+      auto *calleeSet = pair.second;
+      calleeSet->clear();
+      calleeSet->insert(GetCGNode(calleePuidx));
+    }
+  }
+}
+
+bool CallGraph::IsRootNode(MIRFunction *func) const {
+  if (GetCGNode(func) != nullptr) {
+    return (!GetCGNode(func)->HasCaller());
+  } else {
+    return false;
+  }
+}
+
+CGNode *CallGraph::GetOrGenCGNode(PUIdx puIdx, bool isVcall, bool isIcall) {
+  CGNode *node = GetCGNode(puIdx);
+  if (node == nullptr) {
+    MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+    node = cgAlloc.GetMemPool()->New<CGNode>(mirFunc, cgAlloc, numOfNodes++);
+    (void)nodesMap.insert(std::make_pair(mirFunc, node));
+  }
+  if (isVcall && !node->IsVcallCandidatesValid()) {
+    MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+    Klass *klass = nullptr;
+    CHECK_NULL_FATAL(mirFunc);
+    if (StringUtils::StartsWith(mirFunc->GetBaseClassName(), JARRAY_PREFIX_STR)) {  // Array
+      klass = klassh->GetKlassFromName(namemangler::kJavaLangObjectStr);
+    } else {
+      klass = klassh->GetKlassFromStrIdx(mirFunc->GetBaseClassNameStrIdx());
+    }
+    if (klass == nullptr) {  // Incomplete
+      node->SetVcallCandidatesValid();
+      return node;
+    }
+    // Traverse all subclasses
+    std::vector<Klass*> klassVector;
+    klassVector.push_back(klass);
+    GStrIdx calleeFuncStrIdx = mirFunc->GetBaseFuncNameWithTypeStrIdx();
+    for (Klass *currKlass : klassVector) {
+      const MIRFunction *method = currKlass->GetMethod(calleeFuncStrIdx);
+      if (method != nullptr) {
+        node->AddVcallCandidate(GetOrGenCGNode(method->GetPuidx()));
+      }
+      // add subclass of currKlass into vector
+      for (Klass *subKlass : currKlass->GetSubKlasses()) {
+        klassVector.push_back(subKlass);
+      }
+    }
+    if (klass->IsClass() && !klass->GetMIRClassType()->IsAbstract()) {
+      // If klass.foo does not exist, search superclass and find the nearest one
+      // klass.foo does not exist
+      auto &klassMethods = klass->GetMethods();
+      if (std::find(klassMethods.begin(), klassMethods.end(), mirFunc) == klassMethods.end()) {
+        Klass *superKlass = klass->GetSuperKlass();
+        while (superKlass != nullptr) {
+          const MIRFunction *method = superKlass->GetMethod(calleeFuncStrIdx);
+          if (method != nullptr) {
+            node->AddVcallCandidate(GetOrGenCGNode(method->GetPuidx()));
+            break;
+          }
+          superKlass = superKlass->GetSuperKlass();
+        }
+      }
+    }
+    node->SetVcallCandidatesValid();
+  }
+  if (isIcall && !node->IsIcallCandidatesValid()) {
+    Klass *CallerKlass = nullptr;
+    if (StringUtils::StartsWith(CurFunction()->GetBaseClassName(), JARRAY_PREFIX_STR)) {  // Array
+      CallerKlass = klassh->GetKlassFromName(namemangler::kJavaLangObjectStr);
+    } else {
+      CallerKlass = klassh->GetKlassFromStrIdx(CurFunction()->GetBaseClassNameStrIdx());
+    }
+    if (CallerKlass == nullptr) {  // Incomplete
+      CHECK_FATAL(false, "class is incomplete, impossible.");
+      return node;
+    }
+    MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+    Klass *klass = nullptr;
+    if (StringUtils::StartsWith(mirFunc->GetBaseClassName(), JARRAY_PREFIX_STR)) {  // Array
+      klass = klassh->GetKlassFromName(namemangler::kJavaLangObjectStr);
+    } else {
+      klass = klassh->GetKlassFromStrIdx(mirFunc->GetBaseClassNameStrIdx());
+    }
+    if (klass == nullptr) {  // Incomplete
+      node->SetIcallCandidatesValid();
+      return node;
+    }
+    GStrIdx calleeFuncStrIdx = mirFunc->GetBaseFuncNameWithTypeStrIdx();
+    // Traverse all classes which implement the interface
+    for (Klass *implKlass : klass->GetImplKlasses()) {
+      const MIRFunction *method = implKlass->GetMethod(calleeFuncStrIdx);
+      if (method != nullptr) {
+        node->AddIcallCandidate(GetOrGenCGNode(method->GetPuidx()));
+      } else if (!implKlass->GetMIRClassType()->IsAbstract()) {
+        // Search in its parent class
+        Klass *superKlass = implKlass->GetSuperKlass();
+        while (superKlass != nullptr) {
+          const MIRFunction *methodT = superKlass->GetMethod(calleeFuncStrIdx);
+          if (methodT != nullptr) {
+            node->AddIcallCandidate(GetOrGenCGNode(methodT->GetPuidx()));
+            break;
+          }
+          superKlass = superKlass->GetSuperKlass();
+        }
+      }
+    }
+    node->SetIcallCandidatesValid();
+  }
+  return node;
+}
+
+// if expr has addroffunc expr as its opnd, store all the addroffunc puidx into result
+void CallGraph::CollectAddroffuncFromExpr(const BaseNode *expr) {
+  if (expr->GetOpCode() == OP_addroffunc) {
+    addressTakenPuidxs.insert(static_cast<const AddroffuncNode*>(expr)->GetPUIdx());
+    return;
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    CollectAddroffuncFromExpr(expr->Opnd(i));
+  }
+}
+
+void CallGraph::CollectAddroffuncFromStmt(const StmtNode *stmt) {
+  for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+    CollectAddroffuncFromExpr(stmt->Opnd(i));
+  }
+}
+
+void CallGraph::CollectAddroffuncFromConst(MIRConst *mirConst) {
+  if (mirConst->GetKind() == kConstAddrofFunc) {
+    addressTakenPuidxs.insert(static_cast<MIRAddroffuncConst*>(mirConst)->GetValue());
+  } else if (mirConst->GetKind() == kConstAggConst) {
+    auto &constVec = static_cast<MIRAggConst*>(mirConst)->GetConstVec();
+    for (auto &cst : constVec) {
+      CollectAddroffuncFromConst(cst);
+    }
+  }
+}
+
+void CallGraph::RecordLocalConstValue(const StmtNode *stmt) {
+  if (stmt->GetOpCode() != OP_dassign) {
+    return;
+  }
+  auto *dassign = static_cast<const DassignNode*>(stmt);
+  MIRSymbol *lhs = CurFunction()->GetLocalOrGlobalSymbol(dassign->GetStIdx());
+  ASSERT_NOT_NULL(lhs);
+  if (!lhs->IsLocal() || !lhs->GetAttr(ATTR_const) || dassign->GetFieldID() != 0) {
+    return;
+  }
+  if (localConstValueMap.find(lhs->GetStIdx()) != localConstValueMap.end()) {
+    // Multi def found, put nullptr to indicate that we cannot handle this.
+    localConstValueMap[lhs->GetStIdx()] = nullptr;
+    return;
+  }
+  localConstValueMap[lhs->GetStIdx()] = dassign->GetRHS();
+}
+
+CallNode *CallGraph::ReplaceIcallToCall(BlockNode &body, IcallNode *icall, PUIdx newPUIdx) {
+  MapleVector<BaseNode*> opnds(icall->GetNopnd().begin() + 1, icall->GetNopnd().end(),
+                                CurFunction()->GetCodeMPAllocator().Adapter());
+  CallNode *newCall = nullptr;
+  if (icall->GetOpCode() == OP_icall) {
+    newCall = mirBuilder->CreateStmtCall(newPUIdx, opnds, OP_call);
+  } else if (icall->GetOpCode() == OP_icallassigned) {
+    newCall = mirBuilder->CreateStmtCallAssigned(
+        newPUIdx, opnds, icall->GetCallReturnSymbol(mirBuilder->GetMirModule()), OP_callassigned, icall->GetRetTyIdx());
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+  body.ReplaceStmt1WithStmt2(icall, newCall);
+  newCall->SetSrcPos(icall->GetSrcPos());
+  if (debugFlag) {
+    icall->Dump(0);
+    newCall->Dump(0);
+    LogInfo::MapleLogger() << "replace icall successfully!\n";
+  }
+  return newCall;
+}
+
+void CallGraph::HandleCall(BlockNode &body, CGNode &node, StmtNode *stmt, uint32 loopDepth) {
+  PUIdx calleePUIdx = (static_cast<CallNode*>(stmt))->GetPUIdx();
+  MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleePUIdx);
+  // Ignore clinit
+  if (!calleeFunc->IsClinit()) {
+    CallInfo *callInfo = GenCallInfo(kCallTypeCall, calleeFunc, stmt, loopDepth, stmt->GetStmtID());
+    CGNode *calleeNode = GetOrGenCGNode(calleeFunc->GetPuidx());
+    ASSERT(calleeNode != nullptr, "calleenode is null");
+    calleeNode->AddCaller(&node, stmt);
+    node.AddCallsite(*callInfo, calleeNode);
+  }
+  // record the enclosingblock of callstmt
+  static_cast<CallNode*>(stmt)->SetEnclosingBlock(&body);
+}
+
+MIRType *CallGraph::GetFuncTypeFromFuncAddr(const BaseNode *base) {
+  MIRType *funcType = nullptr;
+  switch (base->GetOpCode()) {
+    case OP_dread: {
+      auto *dread = static_cast<const DreadNode*>(base);
+      const MIRSymbol *st = CurFunction()->GetLocalOrGlobalSymbol(dread->GetStIdx());
+      funcType = st->GetType();
+      if (funcType->IsStructType()) {
+        funcType = static_cast<MIRStructType*>(funcType)->GetFieldType(dread->GetFieldID());
+      }
+      break;
+    }
+    case OP_iread: {
+      auto *iread = static_cast<const IreadNode*>(base);
+      funcType = iread->GetType();
+      break;
+    }
+    case OP_select: {
+      auto *select = static_cast<const TernaryNode*>(base);
+      funcType = GetFuncTypeFromFuncAddr(select->Opnd(1));
+      if (funcType == nullptr) {
+        funcType = GetFuncTypeFromFuncAddr(select->Opnd(2));
+      }
+      break;
+    }
+    case OP_addroffunc: {
+      auto *funcNode = static_cast<const AddroffuncNode*>(base);
+      auto *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(funcNode->GetPUIdx());
+      funcType = func->GetMIRFuncType();
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "NYI");
+      break;
+    }
+  }
+  CHECK_FATAL(funcType != nullptr, "Error");
+  return funcType;
+}
+
+void CallGraph::HandleICall(BlockNode &body, CGNode &node, StmtNode *stmt, uint32 loopDepth) {
+  IcallNode *icall = static_cast<IcallNode*>(stmt);
+  auto *funcAddr = icall->GetNopndAt(0);
+  MIRType *funcType = nullptr;
+  CHECK_FATAL(IsPrimitivePoint(funcAddr->GetPrimType()), "Error");
+  switch (funcAddr->GetOpCode()) {
+    case OP_dread: {
+      auto *dread = static_cast<DreadNode*>(funcAddr);
+      MIRSymbol *symbol = CurFunction()->GetLocalOrGlobalSymbol(dread->GetStIdx());
+      ASSERT_NOT_NULL(symbol);
+      funcType = symbol->GetType();
+      if (funcType->IsStructType()) {
+        funcType = static_cast<MIRStructType*>(funcType)->GetFieldType(dread->GetFieldID());
+      }
+      if (symbol->IsGlobal()) {
+        // Global symbol
+        if (!symbol->GetAttr(ATTR_const) || !symbol->IsConst()) {
+          break;
+        }
+        if (symbol->GetKonst()->GetKind() == kConstAddrofFunc) {
+          auto *addrofFuncConst = static_cast<MIRAddroffuncConst*>(symbol->GetKonst());
+          stmt = ReplaceIcallToCall(body, icall, addrofFuncConst->GetValue());
+          HandleCall(body, node, stmt, loopDepth);
+          return;
+        }
+        if (symbol->GetKonst()->GetKind() == kConstAggConst) {
+          auto *aggConst = static_cast<MIRAggConst*>(symbol->GetKonst());
+          auto *elem = aggConst->GetAggConstElement(dread->GetFieldID());
+          if (elem->GetKind() == kConstAddrofFunc) {
+            auto *addrofFuncConst = static_cast<MIRAddroffuncConst*>(elem);
+            stmt = ReplaceIcallToCall(body, icall, addrofFuncConst->GetValue());
+            HandleCall(body, node, stmt, loopDepth);
+            return;
+          }
+        }
+      } else {
+        // Local symbol
+        if (!symbol->GetAttr(ATTR_const)) {
+          break;
+        }
+        if (localConstValueMap.find(symbol->GetStIdx()) != localConstValueMap.end()) {
+          auto *rhsNode = localConstValueMap[symbol->GetStIdx()];
+          if (rhsNode != nullptr && rhsNode->GetOpCode() == OP_addroffunc) {
+            auto *funcNode = static_cast<AddroffuncNode*>(rhsNode);
+            stmt = ReplaceIcallToCall(body, icall, funcNode->GetPUIdx());
+            HandleCall(body, node, stmt, loopDepth);
+            return;
+          }
+        }
+      }
+      break;
+    }
+    case OP_iread: {
+      auto *iread = static_cast<IreadNode*>(funcAddr);
+      funcType = iread->GetType();
+      if (iread->Opnd(0)->GetOpCode() != OP_array) {
+        break;
+      }
+      auto *arrayNode = static_cast<ArrayNode*>(iread->Opnd(0));
+      if (arrayNode->GetBase()->GetOpCode() != OP_addrof) {
+        break;
+      }
+      bool hasVarIndex = false;
+      for (size_t i = 1; i < arrayNode->numOpnds; ++i) {
+        if (!arrayNode->GetNopndAt(i)->IsConstval() ||
+            static_cast<ConstvalNode*>(arrayNode->GetNopndAt(i))->GetConstVal()->GetKind() != kConstInt) {
+          hasVarIndex = true;
+          break;
+        }
+      }
+      if (hasVarIndex) {
+        break;
+      }
+      MIRSymbol *symbol =
+          CurFunction()->GetLocalOrGlobalSymbol(static_cast<AddrofNode*>(arrayNode->GetBase())->GetStIdx());
+      if (symbol->IsGlobal()) {
+        // Global array.
+        if (!symbol->GetAttr(ATTR_const) || !symbol->IsConst()) {
+          break;
+        }
+        // Solve multi-dim array.
+        if (symbol->GetKonst()->GetKind() == kConstAggConst) {
+          auto *aggConst = static_cast<MIRAggConst*>(symbol->GetKonst());
+          MIRConst *result = aggConst;
+          for (size_t i = 1; i < arrayNode->GetNumOpnds(); ++i) {
+            auto *konst = static_cast<ConstvalNode*>(arrayNode->GetNopndAt(i))->GetConstVal();
+            auto index = static_cast<MIRIntConst*>(konst)->GetExtValue();
+            if (result->GetKind() == kConstAggConst) {
+              result = static_cast<MIRAggConst*>(result)->GetConstVecItem(index);
+            }
+          }
+          CHECK_FATAL(result->GetKind() == kConstAddrofFunc, "Must be");
+          auto *constValue = static_cast<MIRAddroffuncConst*>(result);
+          stmt = ReplaceIcallToCall(body, icall, constValue->GetValue());
+          HandleCall(body, node, stmt, loopDepth);
+          return;
+        }
+      }
+      break;
+    }
+    case OP_select: {
+      auto *select = static_cast<const TernaryNode*>(funcAddr);
+      auto *leftValue = select->Opnd(1);
+      auto *rightValue = select->Opnd(2);
+      if (leftValue->GetOpCode() == OP_addroffunc && rightValue->GetOpCode() == OP_addroffunc) {
+        auto *funcNode1 = static_cast<AddroffuncNode*>(leftValue);
+        auto *funcNode2 = static_cast<AddroffuncNode*>(rightValue);
+        CallInfo *callInfo = GenCallInfo(kCallTypeIcall, nullptr, stmt, loopDepth, stmt->GetStmtID());
+        CGNode *calleeNode1 = GetOrGenCGNode(funcNode1->GetPUIdx());
+        CGNode *calleeNode2 = GetOrGenCGNode(funcNode2->GetPUIdx());
+        CHECK_FATAL(calleeNode1 != nullptr && calleeNode2 != nullptr, "calleenode is null");
+        auto *cgVector = cgAlloc.GetMemPool()->New<MapleSet<CGNode*, Comparator<CGNode>>>(cgAlloc.Adapter());
+        cgVector->insert(calleeNode1);
+        cgVector->insert(calleeNode2);
+        calleeNode1->AddCaller(&node, stmt);
+        calleeNode2->AddCaller(&node, stmt);
+        node.AddCallsite(callInfo, cgVector);
+        return;
+      } else {
+        funcType = GetFuncTypeFromFuncAddr(funcAddr);
+      }
+      break;
+    }
+    case OP_addroffunc: {
+      auto *funcNode = static_cast<AddroffuncNode*>(funcAddr);
+      stmt = ReplaceIcallToCall(body, icall, funcNode->GetPUIdx());
+      HandleCall(body, node, stmt, loopDepth);
+      return;
+    }
+    default: {
+      break;
+    }
+  }
+  if (!Options::wpaa) {
+    // Do not handle icall if Options::wpaa is false.
+    return;
+  }
+  CHECK_FATAL(funcType != nullptr, "Failed to get the function type.");
+  while (funcType != nullptr && funcType->IsMIRPtrType()) {
+    funcType = static_cast<MIRPtrType*>(funcType)->GetPointedType();
+  }
+
+  // Add a fake callsite here, need to fix it after all the function is visited.
+  CallInfo *callInfo = GenCallInfo(kCallTypeIcall, nullptr, stmt, loopDepth, stmt->GetStmtID());
+  node.AddCallsite(*callInfo, nullptr);
+  if (icallToFix.find(funcType->GetTypeIndex()) == icallToFix.end()) {
+    auto *tempSet = tempAlloc.GetMemPool()->New<MapleSet<Caller2Cands>>(tempAlloc.Adapter());
+    icallToFix.insert({funcType->GetTypeIndex(), tempSet});
+  }
+  CHECK_FATAL(CurFunction()->GetPuidx() == node.GetPuIdx(), "Error");
+  Callsite callSite = {callInfo, node.GetCallee().at(callInfo)};
+  icallToFix.at(funcType->GetTypeIndex())->insert({node.GetPuIdx(), callSite});
+}
+
+void CallGraph::HandleBody(MIRFunction &func, BlockNode &body, CGNode &node, uint32 loopDepth) {
+  StmtNode *stmtNext = nullptr;
+  for (StmtNode *stmt = body.GetFirst(); stmt != nullptr; stmt = stmtNext) {
+    CollectAddroffuncFromStmt(stmt);
+    RecordLocalConstValue(stmt);
+    stmtNext = static_cast<StmtNode*>(stmt)->GetNext();
+    Opcode op = stmt->GetOpCode();
+    if (op == OP_comment) {
+      continue;
+    } else if (op == OP_doloop) {
+      DoloopNode *doloopNode = static_cast<DoloopNode*>(stmt);
+      HandleBody(func, *doloopNode->GetDoBody(), node, loopDepth + 1);
+    } else if (op == OP_dowhile || op == OP_while) {
+      WhileStmtNode *whileStmt = static_cast<WhileStmtNode*>(stmt);
+      HandleBody(func, *whileStmt->GetBody(), node, loopDepth + 1);
+    } else if (op == OP_if) {
+      IfStmtNode *n = static_cast<IfStmtNode*>(stmt);
+      HandleBody(func, *n->GetThenPart(), node, loopDepth);
+      if (n->GetElsePart() != nullptr) {
+        HandleBody(func, *n->GetElsePart(), node, loopDepth);
+      }
+    } else {
+      node.IncrStmtCount();
+      CallType ct = GetCallType(op);
+      switch (ct) {
+        case kCallTypeVirtualCall: {
+          PUIdx calleePUIdx = (static_cast<CallNode*>(stmt))->GetPUIdx();
+          // init CallNode enclosingBlock for inlininig
+          static_cast<CallNode*>(stmt)->SetEnclosingBlock(&body);
+          MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleePUIdx);
+          CallInfo *callInfo = GenCallInfo(kCallTypeVirtualCall, calleeFunc, stmt, loopDepth, stmt->GetStmtID());
+          // Retype makes object type more inaccurate.
+          StmtNode *stmtPrev = static_cast<StmtNode*>(stmt)->GetPrev();
+          if (stmtPrev != nullptr && stmtPrev->GetOpCode() == OP_dassign) {
+            DassignNode *dassignNode = static_cast<DassignNode*>(stmtPrev);
+            if (dassignNode->GetRHS()->GetOpCode() == OP_retype) {
+              CallNode *callNode = static_cast<CallNode*>(stmt);
+              CHECK_FATAL(callNode->Opnd(0)->GetOpCode() == OP_dread, "Must be dread.");
+              AddrofNode *dread = static_cast<AddrofNode*>(callNode->Opnd(0));
+              if (dassignNode->GetStIdx() == dread->GetStIdx()) {
+                RetypeNode *retypeNode = static_cast<RetypeNode*>(dassignNode->GetRHS());
+                CHECK_FATAL(retypeNode->Opnd(0)->GetOpCode() == OP_dread, "Must be dread.");
+                AddrofNode *dreadT = static_cast<AddrofNode*>(retypeNode->Opnd(0));
+                ASSERT_NOT_NULL(dreadT);
+                ASSERT_NOT_NULL(func.GetLocalOrGlobalSymbol(dreadT->GetStIdx()));
+                MIRType *type = func.GetLocalOrGlobalSymbol(dreadT->GetStIdx())->GetType();
+                CHECK_FATAL(type->IsMIRPtrType(), "Must be ptr type.");
+                MIRPtrType *ptrType = static_cast<MIRPtrType*>(type);
+                MIRType *targetType = ptrType->GetPointedType();
+                MIRFunction *calleeFuncT = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleePUIdx);
+                GStrIdx calleeFuncStrIdx = calleeFuncT->GetBaseFuncNameWithTypeStrIdx();
+                Klass *klass = klassh->GetKlassFromTyIdx(targetType->GetTypeIndex());
+                if (klass != nullptr) {
+                  const MIRFunction *method = klass->GetMethod(calleeFuncStrIdx);
+                  if (method != nullptr) {
+                    calleePUIdx = method->GetPuidx();
+                  } else {
+                    std::string funcName = klass->GetKlassName();
+                    funcName.append((namemangler::kNameSplitterStr));
+                    funcName.append(calleeFuncT->GetBaseFuncNameWithType());
+                    MIRFunction *methodT = mirBuilder->GetOrCreateFunction(funcName, static_cast<TyIdx>(PTY_void));
+                    methodT->SetBaseClassNameStrIdx(klass->GetKlassNameStrIdx());
+                    methodT->SetBaseFuncNameWithTypeStrIdx(calleeFuncStrIdx);
+                    calleePUIdx = methodT->GetPuidx();
+                  }
+                }
+              }
+            }
+          }
+          // Add a call node whether or not the calleeFunc has its body
+          CGNode *calleeNode = GetOrGenCGNode(calleePUIdx, true);
+          CHECK_FATAL(calleeNode != nullptr, "calleenode is null");
+          CHECK_FATAL(calleeNode->IsVcallCandidatesValid(), "vcall candidate must be valid");
+          node.AddCallsite(callInfo, &calleeNode->GetVcallCandidates());
+          for (auto &cgIt : calleeNode->GetVcallCandidates()) {
+            CGNode *calleeNodeT = cgIt;
+            calleeNodeT->AddCaller(&node, stmt);
+          }
+          break;
+        }
+        case kCallTypeInterfaceCall: {
+          PUIdx calleePUIdx = (static_cast<CallNode*>(stmt))->GetPUIdx();
+          // init CallNode enclosingBlock for inlininig
+          static_cast<CallNode*>(stmt)->SetEnclosingBlock(&body);
+          MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleePUIdx);
+          CallInfo *callInfo = GenCallInfo(kCallTypeInterfaceCall, calleeFunc, stmt, loopDepth, stmt->GetStmtID());
+          // Add a call node whether or not the calleeFunc has its body
+          CGNode *calleeNode = GetOrGenCGNode(calleeFunc->GetPuidx(), false, true);
+          CHECK_FATAL(calleeNode != nullptr, "calleenode is null");
+          CHECK_FATAL(calleeNode->IsIcallCandidatesValid(), "icall candidate must be valid");
+          node.AddCallsite(callInfo, &calleeNode->GetIcallCandidates());
+          for (auto &cgIt : calleeNode->GetIcallCandidates()) {
+            CGNode *calleeNodeT = cgIt;
+            calleeNodeT->AddCaller(&node, stmt);
+          }
+          break;
+        }
+        case kCallTypeIcall: {
+          if (mirModule->IsCModule()) {
+            HandleICall(body, node, stmt, loopDepth);
+          }
+          break;
+        }
+        case kCallTypeCall: {
+          HandleCall(body, node, stmt, loopDepth);
+          break;
+        }
+        case kCallTypeSuperCall: {
+          PUIdx calleePUIdx = (static_cast<CallNode*>(stmt))->GetPUIdx();
+          // init CallNode enclosingBlock for inlininig
+          static_cast<CallNode*>(stmt)->SetEnclosingBlock(&body);
+          MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleePUIdx);
+          Klass *klass = klassh->GetKlassFromFunc(calleeFunc);
+          if (klass == nullptr) {  // Fix CI
+            continue;
+          }
+          MapleVector<MIRFunction*> *cands = klass->GetCandidates(calleeFunc->GetBaseFuncNameWithTypeStrIdx());
+          // continue to search its implinterfaces
+          if (cands == nullptr) {
+            for (Klass *implInterface : klass->GetImplInterfaces()) {
+              cands = implInterface->GetCandidates(calleeFunc->GetBaseFuncNameWithTypeStrIdx());
+              if (cands != nullptr && !cands->empty()) {
+                break;
+              }
+            }
+          }
+          if (cands == nullptr || cands->empty()) {
+            continue;  // Fix CI
+          }
+          MIRFunction *actualMirfunc = cands->at(0);
+          CallInfo *callInfo = GenCallInfo(kCallTypeCall, actualMirfunc, stmt, loopDepth, stmt->GetStmtID());
+          CGNode *calleeNode = GetOrGenCGNode(actualMirfunc->GetPuidx());
+          ASSERT(calleeNode != nullptr, "calleenode is null");
+          calleeNode->AddCaller(&node, stmt);
+          (static_cast<CallNode*>(stmt))->SetPUIdx(actualMirfunc->GetPuidx());
+          node.AddCallsite(*callInfo, calleeNode);
+          break;
+        }
+        case kCallTypeIntrinsicCall:
+        case kCallTypeIntrinsicCallWithType:
+        case kCallTypeCustomCall:
+        case kCallTypePolymorphicCall:
+        case kCallTypeXinitrinsicCall:
+        case kCallTypeInvalid: {
+          break;
+        }
+        default: {
+          CHECK_FATAL(false, "NYI::unsupport call type");
+        }
+      }
+    }
+  }
+}
+
+void CallGraph::UpdateCallGraphNode(CGNode &node) {
+  node.Reset();
+  MIRFunction *func = node.GetMIRFunction();
+  CHECK_NULL_FATAL(func);
+  BlockNode *body = func->GetBody();
+  HandleBody(*func, *body, node, 0);
+}
+
+void CallGraph::RecomputeSCC() {
+  sccTopologicalVec.clear();
+  std::vector<CGNode*> allNodes;
+  GetNodes(allNodes);
+  numOfSccs = BuildSCC(cgAlloc, numOfNodes, allNodes, debugFlag, sccTopologicalVec);
+}
+
+void CallGraph::AddCallGraphNode(MIRFunction &func) {
+  CGNode *node = GetOrGenCGNode(func.GetPuidx());
+  CHECK_FATAL(node != nullptr, "node is null in CallGraph::GenCallGraph");
+  BlockNode *body = func.GetBody();
+  HandleBody(func, *body, *node, 0);
+  // set root if current function is static main
+  if (func.GetName() == mirModule->GetEntryFuncName()) {
+    mirModule->SetEntryFunction(&func);
+    entryNode = node;
+  }
+  // collect addroffunc from local symbol
+  size_t symTabSize = func.GetSymbolTabSize();
+  for (size_t i = 0; i < symTabSize; ++i) {
+    MIRSymbol *sym = func.GetSymbolTabItem(static_cast<uint32>(i));
+    if (sym != nullptr && sym->IsConst()) {
+      MIRConst *mirConst = sym->GetKonst();
+      CollectAddroffuncFromConst(mirConst);
+    }
+  }
+}
+
+static void ResetInferredType(std::vector<MIRSymbol*> &inferredSymbols) {
+  for (size_t i = 0; i < inferredSymbols.size(); ++i) {
+    inferredSymbols[i]->SetInferredTyIdx(TyIdx());
+  }
+  inferredSymbols.clear();
+}
+
+static void ResetInferredType(std::vector<MIRSymbol*> &inferredSymbols, MIRSymbol *symbol) {
+  if (symbol == nullptr) {
+    return;
+  }
+  if (symbol->GetInferredTyIdx() == kInitTyIdx || symbol->GetInferredTyIdx() == kNoneTyIdx) {
+    return;
+  }
+  size_t i = 0;
+  for (; i < inferredSymbols.size(); ++i) {
+    if (inferredSymbols[i] == symbol) {
+      symbol->SetInferredTyIdx(TyIdx());
+      inferredSymbols.erase(inferredSymbols.cbegin() + static_cast<ssize_t>(i));
+      break;
+    }
+  }
+}
+
+static void SetInferredType(std::vector<MIRSymbol*> &inferredSymbols, MIRSymbol &symbol, const TyIdx &idx) {
+  symbol.SetInferredTyIdx(idx);
+  size_t i = 0;
+  for (; i < inferredSymbols.size(); ++i) {
+    if (inferredSymbols[i] == &symbol) {
+      break;
+    }
+  }
+  if (i == inferredSymbols.size()) {
+    inferredSymbols.push_back(&symbol);
+  }
+}
+
+void IPODevirtulize::SearchDefInClinit(const Klass &klass) {
+  MIRClassType *classType = static_cast<MIRClassType*>(klass.GetMIRStructType());
+  std::vector<MIRSymbol*> staticFinalPrivateSymbols;
+  for (uint32 i = 0; i < classType->GetStaticFields().size(); ++i) {
+    FieldAttrs attribute = classType->GetStaticFieldsPair(i).second.second;
+    if (attribute.GetAttr(FLDATTR_final)) {
+      staticFinalPrivateSymbols.push_back(
+          GlobalTables::GetGsymTable().GetSymbolFromStrIdx(classType->GetStaticFieldsGStrIdx(i)));
+    }
+  }
+  std::string typeName = klass.GetKlassName();
+  typeName.append(namemangler::kClinitSuffix);
+  GStrIdx clinitFuncGstrIdx =
+      GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::GetInternalNameLiteral(typeName));
+  if (clinitFuncGstrIdx == 0u) {
+    return;
+  }
+  MIRFunction *func = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(clinitFuncGstrIdx)->GetFunction();
+  if (func->GetBody() == nullptr) {
+    return;
+  }
+  StmtNode *stmtNext = nullptr;
+  std::vector<MIRSymbol*> gcmallocSymbols;
+  for (StmtNode *stmt = func->GetBody()->GetFirst(); stmt != nullptr; stmt = stmtNext) {
+    stmtNext = stmt->GetNext();
+    Opcode op = stmt->GetOpCode();
+    switch (op) {
+      case OP_comment:
+        break;
+      case OP_dassign: {
+        DassignNode *dassignNode = static_cast<DassignNode*>(stmt);
+        MIRSymbol *leftSymbol = func->GetLocalOrGlobalSymbol(dassignNode->GetStIdx());
+        size_t i = 0;
+        for (; i < staticFinalPrivateSymbols.size(); ++i) {
+          if (staticFinalPrivateSymbols[i] == leftSymbol) {
+            break;
+          }
+        }
+        if (i < staticFinalPrivateSymbols.size()) {
+          if (dassignNode->GetRHS()->GetOpCode() == OP_dread) {
+            DreadNode *dreadNode = static_cast<DreadNode*>(dassignNode->GetRHS());
+            MIRSymbol *rightSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+            if (rightSymbol->GetInferredTyIdx() != kInitTyIdx && rightSymbol->GetInferredTyIdx() != kNoneTyIdx &&
+                (staticFinalPrivateSymbols[i]->GetInferredTyIdx() == kInitTyIdx ||
+                 (staticFinalPrivateSymbols[i]->GetInferredTyIdx() == rightSymbol->GetInferredTyIdx()))) {
+              staticFinalPrivateSymbols[i]->SetInferredTyIdx(rightSymbol->GetInferredTyIdx());
+            } else {
+              staticFinalPrivateSymbols[i]->SetInferredTyIdx(kInitTyIdx);
+              staticFinalPrivateSymbols.erase(staticFinalPrivateSymbols.cbegin() + static_cast<ssize_t>(i));
+            }
+          } else {
+            staticFinalPrivateSymbols[i]->SetInferredTyIdx(kInitTyIdx);
+            staticFinalPrivateSymbols.erase(staticFinalPrivateSymbols.cbegin() + static_cast<ssize_t>(i));
+          }
+        } else if (dassignNode->GetRHS()->GetOpCode() == OP_gcmalloc) {
+          GCMallocNode *gcmallocNode = static_cast<GCMallocNode*>(dassignNode->GetRHS());
+          TyIdx inferredTypeIdx = gcmallocNode->GetTyIdx();
+          SetInferredType(gcmallocSymbols, *leftSymbol, inferredTypeIdx);
+        } else if (dassignNode->GetRHS()->GetOpCode() == OP_retype) {
+          if (dassignNode->GetRHS()->Opnd(0)->GetOpCode() == OP_dread) {
+            DreadNode *dreadNode = static_cast<DreadNode*>(dassignNode->GetRHS()->Opnd(0));
+            MIRSymbol *rightSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+            if (rightSymbol->GetInferredTyIdx() != kInitTyIdx && rightSymbol->GetInferredTyIdx() != kNoneTyIdx) {
+              SetInferredType(gcmallocSymbols, *leftSymbol, rightSymbol->GetInferredTyIdx());
+            }
+          }
+        } else {
+          ResetInferredType(gcmallocSymbols, leftSymbol);
+        }
+        break;
+      }
+      case OP_call:
+      case OP_callassigned: {
+        CallNode *callNode = static_cast<CallNode*>(stmt);
+        MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+        if (calleeFunc->GetName().find(namemangler::kClinitSubStr, 0) != std::string::npos ||
+            calleeFunc->GetName().find("MCC_", 0) == 0) {
+          // ignore all side effect of initizlizor
+          continue;
+        }
+        for (size_t i = 0; i < callNode->GetReturnVec().size(); ++i) {
+          StIdx stIdx = callNode->GetReturnPair(i).first;
+          MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(stIdx);
+          ResetInferredType(gcmallocSymbols, tmpSymbol);
+        }
+        for (size_t i = 0; i < callNode->GetNopndSize(); ++i) {
+          BaseNode *node = callNode->GetNopndAt(i);
+          CHECK_NULL_FATAL(node);
+          if (node->GetOpCode() != OP_dread) {
+            continue;
+          }
+          DreadNode *dreadNode = static_cast<DreadNode*>(node);
+          MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+          ResetInferredType(gcmallocSymbols, tmpSymbol);
+        }
+        break;
+      }
+      case OP_intrinsiccallwithtype: {
+        IntrinsiccallNode *callNode = static_cast<IntrinsiccallNode*>(stmt);
+        if (callNode->GetIntrinsic() != INTRN_JAVA_CLINIT_CHECK) {
+          ResetInferredType(gcmallocSymbols);
+        }
+        break;
+      }
+      default:
+        ResetInferredType(gcmallocSymbols);
+        break;
+    }
+  }
+}
+
+void IPODevirtulize::SearchDefInMemberMethods(const Klass &klass) {
+  SearchDefInClinit(klass);
+  MIRClassType *classType = static_cast<MIRClassType*>(klass.GetMIRStructType());
+  std::vector<FieldID> finalPrivateFieldID;
+  for (size_t i = 0; i < classType->GetFieldsSize(); ++i) {
+    FieldAttrs attribute = classType->GetFieldsElemt(i).second.second;
+    if (attribute.GetAttr(FLDATTR_final)) {
+      // Conflict with simplify
+      if (strcmp(klass.GetKlassName().c_str(),
+                 "Lcom_2Fandroid_2Fserver_2Fpm_2FPackageManagerService_24ActivityIntentResolver_3B") == 0 &&
+          strcmp(GlobalTables::GetStrTable().GetStringFromStrIdx(classType->GetFieldsElemt(i).first).c_str(),
+                 "mActivities") == 0) {
+        continue;
+      }
+      FieldID id = mirBuilder->GetStructFieldIDFromFieldNameParentFirst(
+          classType, GlobalTables::GetStrTable().GetStringFromStrIdx(classType->GetFieldsElemt(i).first));
+      finalPrivateFieldID.push_back(id);
+    }
+  }
+  std::vector<MIRFunction*> initMethods;
+  std::string typeName = klass.GetKlassName();
+  typeName.append(namemangler::kCinitStr);
+  for (MIRFunction *const &method : klass.GetMethods()) {
+    if (strncmp(method->GetName().c_str(), typeName.c_str(), typeName.length()) == 0) {
+      initMethods.push_back(method);
+    }
+  }
+  if (initMethods.empty()) {
+    return;
+  }
+  ASSERT(!initMethods.empty(), "Must have initializor");
+  StmtNode *stmtNext = nullptr;
+  for (size_t i = 0; i < initMethods.size(); ++i) {
+    MIRFunction *func = initMethods[i];
+    if (func->GetBody() == nullptr) {
+      continue;
+    }
+    std::vector<MIRSymbol*> gcmallocSymbols;
+    for (StmtNode *stmt = func->GetBody()->GetFirst(); stmt != nullptr; stmt = stmtNext) {
+      stmtNext = stmt->GetNext();
+      Opcode op = stmt->GetOpCode();
+      switch (op) {
+        case OP_comment:
+          break;
+        case OP_dassign: {
+          DassignNode *dassignNode = static_cast<DassignNode*>(stmt);
+          MIRSymbol *leftSymbol = func->GetLocalOrGlobalSymbol(dassignNode->GetStIdx());
+          if (dassignNode->GetRHS()->GetOpCode() == OP_gcmalloc) {
+            GCMallocNode *gcmallocNode = static_cast<GCMallocNode*>(dassignNode->GetRHS());
+            SetInferredType(gcmallocSymbols, *leftSymbol, gcmallocNode->GetTyIdx());
+          } else if (dassignNode->GetRHS()->GetOpCode() == OP_retype) {
+            RetypeNode *retyStmt = static_cast<RetypeNode*>(dassignNode->GetRHS());
+            BaseNode *fromNode = retyStmt->Opnd(0);
+            if (fromNode->GetOpCode() == OP_dread) {
+              DreadNode *dreadNode = static_cast<DreadNode*>(fromNode);
+              MIRSymbol *fromSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+              SetInferredType(gcmallocSymbols, *leftSymbol, fromSymbol->GetInferredTyIdx());
+            } else {
+              ResetInferredType(gcmallocSymbols, leftSymbol);
+            }
+          } else {
+            ResetInferredType(gcmallocSymbols, leftSymbol);
+          }
+          break;
+        }
+        case OP_call:
+        case OP_callassigned: {
+          CallNode *callNode = static_cast<CallNode*>(stmt);
+          MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+          if (calleeFunc->GetName().find(namemangler::kClinitSubStr, 0) != std::string::npos) {
+            // ignore all side effect of initizlizor
+            continue;
+          }
+          for (size_t j = 0; j < callNode->GetReturnVec().size(); ++j) {
+            StIdx stIdx = callNode->GetReturnPair(j).first;
+            MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(stIdx);
+            ResetInferredType(gcmallocSymbols, tmpSymbol);
+          }
+          for (size_t j = 0; j < callNode->GetNopndSize(); ++j) {
+            BaseNode *node = callNode->GetNopndAt(j);
+            if (node->GetOpCode() != OP_dread) {
+              continue;
+            }
+            DreadNode *dreadNode = static_cast<DreadNode*>(node);
+            MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+            ResetInferredType(gcmallocSymbols, tmpSymbol);
+          }
+          break;
+        }
+        case OP_intrinsiccallwithtype: {
+          IntrinsiccallNode *callNode = static_cast<IntrinsiccallNode*>(stmt);
+          if (callNode->GetIntrinsic() != INTRN_JAVA_CLINIT_CHECK) {
+            ResetInferredType(gcmallocSymbols);
+          }
+          break;
+        }
+        case OP_iassign: {
+          IassignNode *iassignNode = static_cast<IassignNode*>(stmt);
+          MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iassignNode->GetTyIdx());
+          ASSERT(type->GetKind() == kTypePointer, "Must be pointer type");
+          MIRPtrType *pointedType = static_cast<MIRPtrType*>(type);
+          if (pointedType->GetPointedTyIdx() == classType->GetTypeIndex()) {
+            // set field of current class
+            FieldID fieldID = iassignNode->GetFieldID();
+            size_t j = 0;
+            for (; j < finalPrivateFieldID.size(); ++j) {
+              if (finalPrivateFieldID[j] == fieldID) {
+                break;
+              }
+            }
+            if (j < finalPrivateFieldID.size()) {
+              if (iassignNode->GetRHS()->GetOpCode() == OP_dread) {
+                DreadNode *dreadNode = static_cast<DreadNode*>(iassignNode->GetRHS());
+                CHECK_FATAL(dreadNode != nullptr, "Impossible");
+                MIRSymbol *rightSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+                if (rightSymbol->GetInferredTyIdx() != kInitTyIdx && rightSymbol->GetInferredTyIdx() != kNoneTyIdx &&
+                    (classType->GetElemInferredTyIdx(fieldID) == kInitTyIdx ||
+                     (classType->GetElemInferredTyIdx(fieldID) == rightSymbol->GetInferredTyIdx()))) {
+                  classType->SetElemInferredTyIdx(fieldID, rightSymbol->GetInferredTyIdx());
+                } else {
+                  classType->SetElemInferredTyIdx(fieldID, kInitTyIdx);
+                  finalPrivateFieldID.erase(finalPrivateFieldID.cbegin() + static_cast<ssize_t>(j));
+                }
+              } else {
+                classType->SetElemInferredTyIdx(fieldID, kInitTyIdx);
+                finalPrivateFieldID.erase(finalPrivateFieldID.cbegin() + static_cast<ssize_t>(j));
+              }
+            }
+          }
+          break;
+        }
+        default:
+          ResetInferredType(gcmallocSymbols);
+          break;
+      }
+    }
+  }
+}
+
+void DoDevirtual(const Klass &klass, const KlassHierarchy &klassh) {
+  MIRClassType *classType = static_cast<MIRClassType*>(klass.GetMIRStructType());
+  for (auto &func : klass.GetMethods()) {
+    if (func->GetBody() == nullptr) {
+      continue;
+    }
+    StmtNode *stmtNext = nullptr;
+    std::vector<MIRSymbol*> inferredSymbols;
+    for (StmtNode *stmt = func->GetBody()->GetFirst(); stmt != nullptr; stmt = stmtNext) {
+      stmtNext = stmt->GetNext();
+      Opcode op = stmt->GetOpCode();
+      switch (op) {
+        case OP_comment:
+          CASE_OP_ASSERT_NONNULL
+        case OP_brtrue:
+        case OP_brfalse:
+        case OP_try:
+        case OP_endtry:
+          break;
+        case OP_dassign: {
+          DassignNode *dassignNode = static_cast<DassignNode*>(stmt);
+          MIRSymbol *leftSymbol = func->GetLocalOrGlobalSymbol(dassignNode->GetStIdx());
+          if (dassignNode->GetRHS()->GetOpCode() == OP_dread) {
+            DreadNode *dreadNode = static_cast<DreadNode*>(dassignNode->GetRHS());
+            if (func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx())->GetInferredTyIdx() != kInitTyIdx) {
+              SetInferredType(inferredSymbols, *leftSymbol,
+                              func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx())->GetInferredTyIdx());
+            }
+          } else if (dassignNode->GetRHS()->GetOpCode() == OP_iread) {
+            IreadNode *ireadNode = static_cast<IreadNode*>(dassignNode->GetRHS());
+            MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ireadNode->GetTyIdx());
+            ASSERT(type->GetKind() == kTypePointer, "Must be pointer type");
+            MIRPtrType *pointedType = static_cast<MIRPtrType*>(type);
+            if (pointedType->GetPointedTyIdx() == classType->GetTypeIndex()) {
+              FieldID fieldID = ireadNode->GetFieldID();
+              FieldID tmpID = fieldID;
+              TyIdx tmpTyIdx = classType->GetElemInferredTyIdx(static_cast<size_t>(tmpID));
+              if (tmpTyIdx != kInitTyIdx && tmpTyIdx != kNoneTyIdx) {
+                SetInferredType(inferredSymbols, *leftSymbol,
+                                classType->GetElemInferredTyIdx(static_cast<size_t>(fieldID)));
+              }
+            }
+          } else {
+            ResetInferredType(inferredSymbols, leftSymbol);
+          }
+          break;
+        }
+        case OP_interfacecall:
+        case OP_interfacecallassigned:
+        case OP_virtualcall:
+        case OP_virtualcallassigned: {
+          CallNode *calleeNode = static_cast<CallNode*>(stmt);
+          MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleeNode->GetPUIdx());
+          if (calleeNode->GetNopndAt(0)->GetOpCode() == OP_dread) {
+            DreadNode *dreadNode = static_cast<DreadNode*>(calleeNode->GetNopndAt(0));
+            MIRSymbol *rightSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+            if (rightSymbol->GetInferredTyIdx() != kInitTyIdx && rightSymbol->GetInferredTyIdx() != kNoneTyIdx) {
+              // Devirtual
+              Klass *currKlass = klassh.GetKlassFromTyIdx(rightSymbol->GetInferredTyIdx());
+              if (op == OP_interfacecall || op == OP_interfacecallassigned || op == OP_virtualcall ||
+                  op == OP_virtualcallassigned) {
+                std::vector<Klass*> klassVector;
+                klassVector.push_back(currKlass);
+                bool hasDevirtualed = false;
+                for (size_t index = 0; index < klassVector.size(); ++index) {
+                  Klass *tmpKlass = klassVector[index];
+                  for (MIRFunction *const &method : tmpKlass->GetMethods()) {
+                    if (calleeFunc->GetBaseFuncNameWithTypeStrIdx() == method->GetBaseFuncNameWithTypeStrIdx()) {
+                      calleeNode->SetPUIdx(method->GetPuidx());
+                      if (op == OP_virtualcall || op == OP_interfacecall) {
+                        calleeNode->SetOpCode(OP_call);
+                      }
+                      if (op == OP_virtualcallassigned || op == OP_interfacecallassigned) {
+                        calleeNode->SetOpCode(OP_callassigned);
+                      }
+                      hasDevirtualed = true;
+                      if (false) {
+                        LogInfo::MapleLogger() << ("Devirtualize In function:" + func->GetName()) << '\n';
+                        LogInfo::MapleLogger() << calleeNode->GetOpCode() << '\n';
+                        LogInfo::MapleLogger() << "    From:" << calleeFunc->GetName() << '\n';
+                        LogInfo::MapleLogger()
+                            << "    To  :"
+                            << GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleeNode->GetPUIdx())->GetName()
+                            << '\n';
+                      }
+                      break;
+                    }
+                  }
+                  if (hasDevirtualed) {
+                    break;
+                  }
+                  // add subclass of currKlass into vecotr
+                  for (Klass *superKlass : tmpKlass->GetSuperKlasses()) {
+                    klassVector.push_back(superKlass);
+                  }
+                }
+                if (hasDevirtualed) {
+                  for (size_t i = 0; i < calleeNode->GetNopndSize(); ++i) {
+                    BaseNode *node = calleeNode->GetNopndAt(i);
+                    CHECK_NULL_FATAL(node);
+                    if (node->GetOpCode() != OP_dread) {
+                      continue;
+                    }
+                    dreadNode = static_cast<DreadNode*>(node);
+                    MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+                    ResetInferredType(inferredSymbols, tmpSymbol);
+                  }
+                  if (op == OP_interfacecallassigned || op == OP_virtualcallassigned) {
+                    CallNode *callNode = static_cast<CallNode*>(stmt);
+                    for (size_t i = 0; i < callNode->GetReturnVec().size(); ++i) {
+                      StIdx stIdx = callNode->GetReturnPair(i).first;
+                      MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(stIdx);
+                      ResetInferredType(inferredSymbols, tmpSymbol);
+                    }
+                  }
+                  break;
+                }
+                // Search default function in interfaces
+                Klass *tmpInterface = nullptr;
+                MIRFunction *tmpMethod = nullptr;
+                for (Klass *iKlass : currKlass->GetImplInterfaces()) {
+                  for (MIRFunction *const &method : iKlass->GetMethods()) {
+                    if (calleeFunc->GetBaseFuncNameWithTypeStrIdx() == method->GetBaseFuncNameWithTypeStrIdx() &&
+                        !method->GetFuncAttrs().GetAttr(FUNCATTR_abstract)) {
+                      if (tmpInterface == nullptr || klassh.IsSuperKlassForInterface(tmpInterface, iKlass)) {
+                        tmpInterface = iKlass;
+                        tmpMethod = method;
+                      }
+                      break;
+                    }
+                  }
+                }
+                // Add this check for the thirdparty APP compile
+                if (tmpMethod == nullptr) {
+                  if (Options::deferredVisit) {
+                    return;
+                  }
+                  Klass *parentKlass = klassh.GetKlassFromName(calleeFunc->GetBaseClassName());
+                  CHECK_FATAL(parentKlass != nullptr, "null ptr check");
+                  bool flag = false;
+                  if (parentKlass->GetKlassName() == currKlass->GetKlassName()) {
+                    flag = true;
+                  } else {
+                    for (Klass *const &superclass : currKlass->GetSuperKlasses()) {
+                      if (parentKlass->GetKlassName() == superclass->GetKlassName()) {
+                        flag = true;
+                        break;
+                      }
+                    }
+                    if (!flag && parentKlass->IsInterface()) {
+                      for (Klass *const &implClass : currKlass->GetImplKlasses()) {
+                        if (parentKlass->GetKlassName() == implClass->GetKlassName()) {
+                          flag = true;
+                          break;
+                        }
+                      }
+                    }
+                  }
+                  if (!flag) {
+                    LogInfo::MapleLogger()
+                        << "warning: func " << calleeFunc->GetName() << " is not found in DeVirtual!" << std::endl;
+                    LogInfo::MapleLogger() << "warning: " << calleeFunc->GetBaseClassName() << " is not the parent of "
+                                           << currKlass->GetKlassName() << std::endl;
+                  }
+                }
+                if (tmpMethod == nullptr) {  // SearchWithoutRettype, search only in current class now.
+                  MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(calleeFunc->GetReturnTyIdx());
+                  Klass *targetKlass = nullptr;
+                  bool isCalleeScalar = false;
+                  if (retType->GetKind() == kTypePointer && retType->GetPrimType() == PTY_ref) {
+                    MIRType *ptrType = (static_cast<MIRPtrType*>(retType))->GetPointedType();
+                    targetKlass = klassh.GetKlassFromTyIdx(ptrType->GetTypeIndex());
+                  } else if (retType->GetKind() == kTypeScalar) {
+                    isCalleeScalar = true;
+                  } else {
+                    targetKlass = klassh.GetKlassFromTyIdx(retType->GetTypeIndex());
+                  }
+                  if (targetKlass == nullptr && !isCalleeScalar) {
+                    CHECK_FATAL(false, "null ptr check");
+                  }
+                  Klass *curRetKlass = nullptr;
+                  bool isCurrVtabScalar = false;
+                  bool isFindMethod = false;
+                  for (MIRFunction *const &method : currKlass->GetMethods()) {
+                    if (calleeFunc->GetBaseFuncSigStrIdx() == method->GetBaseFuncSigStrIdx()) {
+                      Klass *tmpKlass = nullptr;
+                      MIRType *tmpType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(method->GetReturnTyIdx());
+                      if (tmpType->GetKind() == kTypePointer && tmpType->GetPrimType() == PTY_ref) {
+                        MIRType *ptrType = (static_cast<MIRPtrType*>(tmpType))->GetPointedType();
+                        tmpKlass = klassh.GetKlassFromTyIdx(ptrType->GetTypeIndex());
+                      } else if (tmpType->GetKind() == kTypeScalar) {
+                        isCurrVtabScalar = true;
+                      } else {
+                        tmpKlass = klassh.GetKlassFromTyIdx(tmpType->GetTypeIndex());
+                      }
+                      if (tmpKlass == nullptr && !isCurrVtabScalar) {
+                        CHECK_FATAL(false, "null ptr check");
+                      }
+                      if (isCalleeScalar || isCurrVtabScalar) {
+                        if (isFindMethod) {
+                          LogInfo::MapleLogger()
+                              << "warning: this " << currKlass->GetKlassName()
+                              << " has mult methods with the same function name but with different return type!"
+                              << std::endl;
+                          break;
+                        }
+                        tmpMethod = method;
+                        isFindMethod = true;
+                        continue;
+                      }
+                      if (targetKlass->IsClass() && klassh.IsSuperKlass(tmpKlass, targetKlass) &&
+                          (curRetKlass == nullptr || klassh.IsSuperKlass(curRetKlass, tmpKlass))) {
+                        curRetKlass = tmpKlass;
+                        tmpMethod = method;
+                      }
+                      if (targetKlass->IsClass() && klassh.IsInterfaceImplemented(tmpKlass, targetKlass)) {
+                        tmpMethod = method;
+                        break;
+                      }
+                      if (!targetKlass->IsClass()) {
+                        CHECK_FATAL(tmpKlass != nullptr, "Klass null ptr check");
+                        if (tmpKlass->IsClass() && klassh.IsInterfaceImplemented(targetKlass, tmpKlass) &&
+                            (curRetKlass == nullptr || klassh.IsSuperKlass(curRetKlass, tmpKlass))) {
+                          curRetKlass = tmpKlass;
+                          tmpMethod = method;
+                        }
+                        if (!tmpKlass->IsClass() && klassh.IsSuperKlassForInterface(tmpKlass, targetKlass) &&
+                            (curRetKlass == nullptr || klassh.IsSuperKlass(curRetKlass, tmpKlass))) {
+                          curRetKlass = tmpKlass;
+                          tmpMethod = method;
+                        }
+                      }
+                    }
+                  }
+                }
+                if (tmpMethod == nullptr && (currKlass->IsClass() || currKlass->IsInterface())) {
+                  LogInfo::MapleLogger() << "warning: func " << calleeFunc->GetName() << " is not found in DeVirtual!"
+                                         << std::endl;
+                  stmt->SetOpCode(OP_callassigned);
+                  break;
+                } else if (tmpMethod == nullptr) {
+                  LogInfo::MapleLogger() << "Error: func " << calleeFunc->GetName() << " is not found!" << std::endl;
+                  ASSERT(tmpMethod != nullptr, "Must not be null");
+                }
+                calleeNode->SetPUIdx(tmpMethod->GetPuidx());
+                if (op == OP_virtualcall || op == OP_interfacecall) {
+                  calleeNode->SetOpCode(OP_call);
+                }
+                if (op == OP_virtualcallassigned || op == OP_interfacecallassigned) {
+                  calleeNode->SetOpCode(OP_callassigned);
+                }
+                if (false) {
+                  LogInfo::MapleLogger() << ("Devirtualize In function:" + func->GetName()) << '\n';
+                  LogInfo::MapleLogger() << calleeNode->GetOpCode() << '\n';
+                  LogInfo::MapleLogger() << "    From:" << calleeFunc->GetName() << '\n';
+                  LogInfo::MapleLogger()
+                      << "    To  :"
+                      << GlobalTables::GetFunctionTable().GetFunctionFromPuidx(calleeNode->GetPUIdx())->GetName()
+                      << '\n';
+                }
+                for (size_t i = 0; i < calleeNode->GetNopndSize(); ++i) {
+                  BaseNode *node = calleeNode->GetNopndAt(i);
+                  if (node->GetOpCode() != OP_dread) {
+                    continue;
+                  }
+                  dreadNode = static_cast<DreadNode*>(node);
+                  MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+                  ResetInferredType(inferredSymbols, tmpSymbol);
+                }
+                if (op == OP_interfacecallassigned || op == OP_virtualcallassigned) {
+                  CallNode *callNode = static_cast<CallNode*>(stmt);
+                  for (size_t i = 0; i < callNode->GetReturnVec().size(); ++i) {
+                    StIdx stIdx = callNode->GetReturnPair(i).first;
+                    MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(stIdx);
+                    ResetInferredType(inferredSymbols, tmpSymbol);
+                  }
+                }
+                break;
+              }
+            }
+          }
+        }
+        [[clang::fallthrough]];
+        case OP_call:
+        case OP_callassigned: {
+          CallNode *callNode = static_cast<CallNode*>(stmt);
+          for (size_t i = 0; i < callNode->GetReturnVec().size(); ++i) {
+            StIdx stIdx = callNode->GetReturnPair(i).first;
+            MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(stIdx);
+            ResetInferredType(inferredSymbols, tmpSymbol);
+          }
+          for (size_t i = 0; i < callNode->GetNopndSize(); ++i) {
+            BaseNode *node = callNode->GetNopndAt(i);
+            if (node->GetOpCode() != OP_dread) {
+              continue;
+            }
+            DreadNode *dreadNode = static_cast<DreadNode*>(node);
+            MIRSymbol *tmpSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+            ResetInferredType(inferredSymbols, tmpSymbol);
+          }
+          break;
+        }
+        default:
+          ResetInferredType(inferredSymbols);
+          break;
+      }
+    }
+  }
+}
+
+void IPODevirtulize::DevirtualFinal() {
+  // Search all klass in order to find final variables
+  MapleMap<GStrIdx, Klass*>::const_iterator it = klassh->GetKlasses().begin();
+  for (; it != klassh->GetKlasses().end(); ++it) {
+    Klass *klass = it->second;
+    if (klass->IsClass()) {
+      MIRClassType *classType = static_cast<MIRClassType*>(klass->GetMIRStructType());
+      // Initialize inferred type of member fileds as kInitTyidx
+      for (size_t i = 0; i < classType->GetFieldsSize(); ++i) {  // Don't include parent's field
+        classType->SetElemInferredTyIdx(i, kInitTyIdx);
+      }
+      SearchDefInMemberMethods(*klass);
+      for (size_t i = 0; i < classType->GetFieldInferredTyIdx().size(); ++i) {
+        if (classType->GetElemInferredTyIdx(i) != kInitTyIdx && classType->GetElemInferredTyIdx(i) != kNoneTyIdx &&
+            debugFlag) {
+          FieldID tmpID = static_cast<FieldID>(i);
+          FieldPair pair = classType->TraverseToFieldRef(tmpID);
+          LogInfo::MapleLogger() << ("Inferred Final Private None-Static Variable:" + klass->GetKlassName() + ":" +
+                                     GlobalTables::GetStrTable().GetStringFromStrIdx(pair.first))
+                                 << '\n';
+        }
+      }
+      for (size_t i = 0; i < classType->GetStaticFields().size(); ++i) {
+        FieldAttrs attribute = classType->GetStaticFieldsPair(i).second.second;
+        if (GlobalTables::GetGsymTable().GetSymbolFromStrIdx(classType->GetStaticFieldsGStrIdx(i)) == nullptr) {
+          continue;
+        }
+        TyIdx tyIdx = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+            classType->GetStaticFieldsPair(i).first)->GetInferredTyIdx();
+        if (tyIdx != kInitTyIdx && tyIdx != kNoneTyIdx) {
+          CHECK_FATAL(attribute.GetAttr(FLDATTR_final), "Must be final private");
+          if (debugFlag) {
+            LogInfo::MapleLogger() << ("Final Private Static Variable:" +
+                                       GlobalTables::GetStrTable().GetStringFromStrIdx(
+                                           classType->GetStaticFieldsPair(i).first))
+                                   << '\n';
+          }
+        }
+      }
+      DoDevirtual(*klass, *GetKlassh());
+    }
+  }
+}
+
+void CallGraph::ReadCallGraphFromMplt() {
+  // Read existing call graph from mplt, std::map<PUIdx, std::vector<CallInfo*> >
+  // caller_PUIdx and all call site info are needed. Rebuild all other info of CGNode using CHA
+  for (auto const &it : mirModule->GetMethod2TargetMap()) {
+    CGNode *node = GetOrGenCGNode(it.first);
+    CHECK_FATAL(node != nullptr, "node is null");
+    std::vector<CallInfo*> callees = it.second;
+    for (auto itInner = callees.begin(); itInner != callees.end(); ++itInner) {
+      CallInfo *info = *itInner;
+      CGNode *calleeNode = GetOrGenCGNode(info->GetFunc()->GetPuidx(), info->GetCallType() == kCallTypeVirtualCall,
+                                          info->GetCallType() == kCallTypeInterfaceCall);
+      CHECK_FATAL(calleeNode != nullptr, "calleeNode is null");
+      if (info->GetCallType() == kCallTypeVirtualCall) {
+        node->AddCallsite(*itInner, &calleeNode->GetVcallCandidates());
+      } else if (info->GetCallType() == kCallTypeInterfaceCall) {
+        node->AddCallsite(*itInner, &calleeNode->GetIcallCandidates());
+      } else if (info->GetCallType() == kCallTypeCall) {
+        node->AddCallsite(**itInner, calleeNode);
+      } else if (info->GetCallType() == kCallTypeSuperCall) {
+        const MIRFunction *calleeFunc = info->GetFunc();
+        Klass *klass = klassh->GetKlassFromFunc(calleeFunc);
+        if (klass == nullptr) {  // Fix CI
+          continue;
+        }
+        MapleVector<MIRFunction*> *cands = klass->GetCandidates(calleeFunc->GetBaseFuncNameWithTypeStrIdx());
+        // continue to search its implinterfaces
+        if (cands == nullptr) {
+          for (Klass *implInterface : klass->GetImplInterfaces()) {
+            cands = implInterface->GetCandidates(calleeFunc->GetBaseFuncNameWithTypeStrIdx());
+            if (cands != nullptr && !cands->empty()) {
+              break;
+            }
+          }
+        }
+        if (cands == nullptr || cands->empty()) {
+          continue;  // Fix CI
+        }
+        MIRFunction *actualMirFunc = cands->at(0);
+        CGNode *tempNode = GetOrGenCGNode(actualMirFunc->GetPuidx());
+        ASSERT(tempNode != nullptr, "calleenode is null in CallGraph::HandleBody");
+        node->AddCallsite(*info, tempNode);
+      }
+      for (auto &callSite : std::as_const(node->GetCallee())) {
+        if (callSite.first == info) {
+          for (auto &cgIt : *callSite.second) {
+            CGNode *tempNode = cgIt;
+            tempNode->AddCaller(node, info->GetCallStmt());
+          }
+          break;
+        }
+      }
+    }
+  }
+}
+
+void CallGraph::GenCallGraphFromFunctionBody() {
+  // Deal with function override, function in current module override functions from mplt.
+  // Don't need anymore as we rebuild candidate base on the latest CHA.
+  std::vector<MIRFunction*> &funcTable = GlobalTables::GetFunctionTable().GetFuncTable();
+  // don't optimize this loop to iterator or range-base loop
+  // because AddCallGraphNode(mirFunc) will change GlobalTables::GetFunctionTable().GetFuncTable()
+  for (size_t index = 0; index < funcTable.size(); ++index) {
+    MIRFunction *mirFunc = funcTable.at(index);
+    if (mirFunc == nullptr || mirFunc->GetBody() == nullptr) {
+      continue;
+    }
+    mirModule->SetCurFunction(mirFunc);
+    AddCallGraphNode(*mirFunc);
+    // No need to record information of last function.
+    localConstValueMap.clear();
+  }
+}
+
+void CallGraph::GetMatchedCGNode(const TyIdx &idx, std::vector<CGNode*> &result) {
+  auto *funcType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(idx);
+  for (auto puidx : addressTakenPuidxs) {
+    auto *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puidx);
+    if (func == nullptr) {
+      continue;
+    }
+    if (func->GetMIRFuncType()->CompatibleWith(*funcType)) {
+      result.push_back(GetOrGenCGNode(puidx));
+    }
+  }
+}
+
+void CallGraph::FixIcallCallee() {
+  for (auto &pair : std::as_const(icallToFix)) {
+    std::vector<CGNode*> funcs;
+    GetMatchedCGNode(pair.first, funcs);
+    for (auto &callerCallee : *pair.second) {
+      auto puidx = callerCallee.first;
+      auto candidate = callerCallee.second;
+      CHECK_FATAL(candidate.second->empty(), "Error");
+      candidate.second->insert(funcs.cbegin(), funcs.cend());
+      StmtNode *stmt = candidate.first->GetCallStmt();
+      std::for_each(funcs.begin(), funcs.end(), [puidx, stmt, this](CGNode *elem) {
+        CGNode *callerNode = GetOrGenCGNode(puidx);
+        elem->AddCaller(callerNode, stmt);
+      });
+    }
+  }
+}
+
+void CallGraph::GenCallGraph() {
+  ReadCallGraphFromMplt();
+  GenCallGraphFromFunctionBody();
+  // collect addroffunc from global symbol
+  auto &symbolSet = mirModule->GetSymbolSet();
+  for (auto sit = symbolSet.begin(); sit != symbolSet.end(); ++sit) {
+    MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx(sit->Idx());
+    ASSERT_NOT_NULL(s);
+    if (s->IsConst()) {
+      MIRConst *mirConst = s->GetKonst();
+      CollectAddroffuncFromConst(mirConst);
+    }
+  }
+  // Mark all address taken functions.
+  for (auto puidx : addressTakenPuidxs) {
+    auto *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puidx);
+    if (func == nullptr) {
+      continue;
+    }
+    CGNode *calleeNode = GetOrGenCGNode(puidx);
+    calleeNode->SetAddrTaken();
+  }
+  // After collecting all the address taken func info, we can add candidate for icall stmt.
+  if (mirModule->IsCModule() && Options::wpaa) {
+    FixIcallCallee();
+  }
+  // Add all root nodes
+  FindRootNodes();
+  // Remove root nodes if it is file static
+  // A file static function can only be accessed directly by function or variable
+  // in the same file. If a file static func is never used, we can rm it.
+  // A static func can be used in:
+  // 1. caller
+  // 2. addroffunc
+  if (mirModule->IsCModule() && Options::rmNoUseFunc) {
+    RemoveFileStaticRootNodes();
+  }
+
+  // Finding SCC
+  std::vector<CGNode*> allNodes;
+  GetNodes(allNodes);
+  numOfSccs = BuildSCC(cgAlloc, numOfNodes, allNodes, debugFlag, sccTopologicalVec);
+  // Remove SCC if it has no used and all nodes is static
+  if (mirModule->IsCModule() && Options::rmNoUseFunc) {
+    RemoveFileStaticSCC();
+  }
+}
+
+void CallGraph::FindRootNodes() {
+  if (!rootNodes.empty()) {
+    CHECK_FATAL(false, "rootNodes has already been set");
+  }
+  for (auto &it : std::as_const(nodesMap)) {
+    CGNode *node = it.second;
+    // once early inline finished, extern gnu_inline has no use anymore, we should remove it
+    bool unusedExternGnuInline = !mirModule->firstInline && IsExternGnuInline(*node->GetMIRFunction());
+    if (!node->HasCaller() || unusedExternGnuInline) {
+      rootNodes.push_back(node);
+    }
+  }
+}
+
+void CallGraph::RemoveFileStaticRootNodes() {
+  std::vector<CGNode*> staticRoots;
+  bool firstInline = mirModule->firstInline;
+  std::copy_if(rootNodes.begin(), rootNodes.end(), std::inserter(staticRoots, staticRoots.begin()),
+               [firstInline](const CGNode *root) {
+    // root means no caller, we should also make sure that root is not be used in addroffunc
+    auto mirFunc = root->GetMIRFunction();
+    bool unusedExternGnuInline = !firstInline && IsExternGnuInline(*mirFunc);
+    return root != nullptr && mirFunc != nullptr && // remove before
+    // if static functions or inline but not extern modified functions are not used anymore,
+    // they can be removed safely.
+    ((!root->IsAddrTaken() && (mirFunc->IsStatic() || (mirFunc->IsInline() && mirFunc->IsExtern()))) ||
+     unusedExternGnuInline);
+  });
+  for (auto *root : staticRoots) {
+    // DFS delete root and its callee that is static and have no caller after root is deleted
+    DelNode(*root);
+  }
+  ClearFunctionList();
+  // rebuild rootNodes
+  rootNodes.clear();
+  FindRootNodes();
+}
+
+void CallGraph::RemoveFileStaticSCC() {
+  for (size_t idx = 0; idx < sccTopologicalVec.size();) {
+    SCCNode<CGNode> *sccNode = sccTopologicalVec[idx];
+    if (sccNode->HasInScc() || sccNode == nullptr) {
+      ++idx;
+      continue;
+    }
+    bool canBeDel = true;
+    for (auto *node : sccNode->GetNodes()) {
+      // If the function is not static, it may be referred in other module;
+      // If the function is taken address, we should deal with this situation conservatively,
+      // because we are not sure whether the func pointer may escape from this SCC
+      if (!node->GetMIRFunction()->IsStatic() || node->IsAddrTaken()) {
+        canBeDel = false;
+        break;
+      }
+    }
+    if (canBeDel) {
+      sccTopologicalVec.erase(sccTopologicalVec.cbegin() + static_cast<ssize_t>(idx));
+      for (auto *calleeSCC : sccNode->GetOutScc()) {
+        calleeSCC->RemoveInScc(sccNode);
+      }
+      for (auto *cgnode : sccNode->GetNodes()) {
+        DelNode(*cgnode);
+      }
+      // this sccnode is deleted from sccTopologicalVec, so we don't inc idx here
+      continue;
+    }
+    ++idx;
+  }
+  ClearFunctionList();
+}
+
+void CallGraph::Dump() const {
+  for (auto const &it : nodesMap) {
+    CGNode *node = it.second;
+    node->DumpDetail();
+  }
+}
+
+void CallGraph::DumpToFile(bool dumpAll) const {
+  if (Options::noDot) {
+    return;
+  }
+  std::ofstream cgFile;
+  std::string outName;
+  MapleString outfile(fileName, GetMempool());
+  if (dumpAll) {
+    outName = (outfile.append("-callgraph.dot")).c_str();
+  } else {
+    outName = (outfile.append("-callgraphlight.dot")).c_str();
+  }
+  cgFile.open(outName, std::ios::trunc);
+  CHECK_FATAL(cgFile.is_open(), "open file fail in call graph");
+  cgFile << "digraph graphname {\n";
+  for (auto const &it : nodesMap) {
+    CGNode *node = it.second;
+    // dump user defined function
+    if (dumpAll) {
+      node->Dump(cgFile);
+    } else {
+      if ((node->GetMIRFunction() != nullptr) && (!node->GetMIRFunction()->IsEmpty())) {
+        node->Dump(cgFile);
+      }
+    }
+  }
+  cgFile << "}\n";
+  cgFile.close();
+}
+
+void CallGraph::BuildCallGraph() {
+  GenCallGraph();
+  // Dump callgraph to dot file
+  if (debugFlag) {
+    DumpToFile(true);
+  }
+  if (mirModule->firstInline) {
+    SetCompilationFunclist();
+  } else {
+    auto iter = mirModule->GetFunctionList().begin();
+    while (iter != mirModule->GetFunctionList().end()) {
+      if (*iter == nullptr ||
+          (((*iter)->GetFuncSymbol() != nullptr) && (*iter)->GetFuncSymbol()->GetStorageClass() == kScUnused)) {
+        iter = mirModule->GetFunctionList().erase(iter);
+      } else {
+        ++iter;
+      }
+    }
+  }
+}
+
+// Sort CGNode within an SCC. Try best to arrange callee appears before
+// its (direct) caller, so that caller can benefit from summary info.
+// If we have iterative inter-procedure analysis, then would not bother
+// do this.
+static bool CGNodeCompare(CGNode *left, CGNode *right) {
+  // special case: left calls right and right calls left, then compare by id
+  if (left->IsCalleeOf(right) && right->IsCalleeOf(left)) {
+    return left->GetID() < right->GetID();
+  }
+  // left is right's direct callee, then make left appears first
+  if (left->IsCalleeOf(right)) {
+    return true;
+  } else if (right->IsCalleeOf(left)) {
+    return false;
+  }
+  return left->GetID() < right->GetID();
+}
+
+// Set compilation order as the bottom-up order of callgraph. So callee
+// is always compiled before caller. This benifits thoses optimizations
+// need interprocedure information like escape analysis.
+void CallGraph::SetCompilationFunclist() const {
+  std::set<MIRFunction*> unusedFuncSet(mirModule->GetFunctionList().begin(),
+      mirModule->GetFunctionList().end());
+  mirModule->GetFunctionList().clear();
+  const MapleVector<SCCNode<CGNode>*> &sccTopVec = GetSCCTopVec();
+  for (MapleVector<SCCNode<CGNode>*>::const_reverse_iterator it = sccTopVec.rbegin(); it != sccTopVec.rend(); ++it) {
+    SCCNode<CGNode> *sccNode = *it;
+    std::sort(sccNode->GetNodes().begin(), sccNode->GetNodes().end(), CGNodeCompare);
+    for (auto const kIt : sccNode->GetNodes()) {
+      CGNode *node = kIt;
+      MIRFunction *func = node->GetMIRFunction();
+      if ((func != nullptr && func->GetBody() != nullptr && !IsInIPA()) || (func != nullptr && !func->IsNative())) {
+        mirModule->GetFunctionList().push_back(func);
+        (void)unusedFuncSet.erase(func);
+      }
+    }
+  }
+  for (auto unusedFunc : unusedFuncSet) {
+    unusedFunc->ReleaseCodeMemory();
+    unusedFunc->ReleaseMemory();
+  }
+}
+
+void CGNode::AddCandsForCallNode(const KlassHierarchy &kh) {
+  // already set vcall candidates information
+  if (HasSetVCallCandidates()) {
+    return;
+  }
+  CHECK_NULL_FATAL(mirFunc);
+  Klass *klass = kh.GetKlassFromFunc(mirFunc);
+  if (klass != nullptr) {
+    MapleVector<MIRFunction*> *vec = klass->GetCandidates(mirFunc->GetBaseFuncNameWithTypeStrIdx());
+    if (vec != nullptr) {
+      vcallCands = *vec;  // Vector copy
+    }
+  }
+}
+
+MIRFunction *CGNode::HasOneCandidate() const {
+  int count = 0;
+  MIRFunction *cand = nullptr;
+  if (!mirFunc->IsEmpty()) {
+    ++count;
+    cand = mirFunc;
+  }
+  // scan candidates
+  for (size_t i = 0; i < vcallCands.size(); ++i) {
+    if (vcallCands[i] == nullptr) {
+      CHECK_FATAL(false, "must not be nullptr");
+    }
+    if (!vcallCands[i]->IsEmpty()) {
+      ++count;
+      if (cand == nullptr) {
+        cand = vcallCands[i];
+      }
+    }
+  }
+  return (count == 1) ? cand : nullptr;
+}
+
+bool M2MCallGraph::PhaseRun(maple::MIRModule &m) {
+  KlassHierarchy *klassh = GET_ANALYSIS(M2MKlassHierarchy, m);
+  CHECK_NULL_FATAL(klassh);
+  cg = GetPhaseAllocator()->New<CallGraph>(m, *GetPhaseMemPool(), *ApplyTempMemPool(), *klassh, m.GetFileName());
+  cg->InitCallExternal();
+  cg->SetDebugFlag(TRACE_MAPLE_PHASE);
+  cg->BuildCallGraph();
+  if (m.IsJavaModule() && !m.IsInIPA() && m.firstInline) {
+    // do retype
+    Retype retype(&m, ApplyTempMemPool());
+    retype.DoRetype();
+  }
+  return true;
+}
+
+void M2MCallGraph::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+
+bool M2MIPODevirtualize::PhaseRun(maple::MIRModule &m) {
+  KlassHierarchy *klassh = GET_ANALYSIS(M2MKlassHierarchy, m);
+  CHECK_NULL_FATAL(klassh);
+  IPODevirtulize *dev = GetPhaseAllocator()->New<IPODevirtulize>(&m, GetPhaseMemPool(), klassh);
+  // Devirtualize vcall of final variable
+  dev->DevirtualFinal();
+  return true;
+}
+
+void M2MIPODevirtualize::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/class_hierarchy.cpp b/src/mapleall/mpl2mpl/src/class_hierarchy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..686d57a5a5c18803d5801aba8aba45461add624d
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/class_hierarchy.cpp
@@ -0,0 +1,1060 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "class_hierarchy.h"
+#include <iostream>
+#include <fstream>
+#include "option.h"
+
+// Class Hierarchy Analysis
+// This phase is a foundation phase of compilation. This phase build
+// the class hierarchy for both this module and all modules it depends
+// on. So many phases rely on this phase's analysis result, such as
+// call graph, ssa and so on.
+// The main procedure shows as following.
+// A. Based on the information read from mplts, it collects all class that
+//    declared in modules. And creates a Klass for each class.
+// B. Fill class method info. Connect superclass<->subclass and
+//    interface->implementation edges.
+// C. Tag All Throwable class and its child class.
+// D. In the case of "class C implements B; interface B extends A;",
+//    we need to add a link between C and A. So we recursively traverse
+//    Klass and collect all interfaces it implements.
+// E. Topological Sort
+// F. Based on Topological Sort Order, for each virtual method in a class,
+//    we collect all its potential implementation. If the number of
+//    potential implementations is 1, it means all virtual calls to this
+//    method can be easily devirtualized.
+namespace maple {
+bool KlassHierarchy::traceFlag = false;
+
+bool IsSystemPreloadedClass(const std::string &className) {
+  if (!Options::usePreloadedClass) {
+    return false;
+  }
+  static const std::unordered_set<std::string> preloadedClass = {
+#define CLASS_PREFIX(classname) #classname,
+#include "white_list.def"
+#undef CLASS_PREFIX
+  };
+  return preloadedClass.find(className) != preloadedClass.end();
+}
+
+Klass::Klass(MIRStructType *type, MapleAllocator *alc)
+    : structType(type),
+      alloc(alc),
+      superKlasses(alloc->Adapter()),
+      subKlasses(alloc->Adapter()),
+      implKlasses(alloc->Adapter()),
+      implInterfaces(alloc->Adapter()),
+      methods(alloc->Adapter()),
+      strIdx2Method(alloc->Adapter()),
+      strIdx2CandidateMap(alloc->Adapter()) {
+  ASSERT(type != nullptr, "type is nullptr in Klass::Klass!");
+  ASSERT(type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface ||
+         type->IsIncomplete(), "runtime check error");
+}
+
+void Klass::DumpKlassMethods() const {
+  if (methods.empty()) {
+    return;
+  }
+  LogInfo::MapleLogger() << "   class member methods:\n";
+  for (MIRFunction *method : methods) {
+    LogInfo::MapleLogger() << "   \t" << method->GetName() << " , ";
+    ASSERT_NOT_NULL(method);
+    ASSERT_NOT_NULL(method->GetFuncSymbol());
+    method->GetFuncSymbol()->GetAttrs().DumpAttributes();
+    LogInfo::MapleLogger() << "\n";
+  }
+  for (const auto &m2cPair : strIdx2CandidateMap) {
+    LogInfo::MapleLogger() << "   \t" << GlobalTables::GetStrTable().GetStringFromStrIdx(m2cPair.first)
+                           << "   , # of target:" << m2cPair.second->size() << "\n";
+  }
+}
+
+void Klass::DumpKlassImplKlasses() const {
+  if (implKlasses.empty()) {
+    return;
+  }
+  LogInfo::MapleLogger() << "  implemented by:\n";
+  for (Klass *implKlass : implKlasses) {
+    LogInfo::MapleLogger() << "   \t@implbyclass_idx " << implKlass->structType->GetTypeIndex() << "\n";
+  }
+}
+
+void Klass::DumpKlassImplInterfaces() const {
+  if (implInterfaces.empty()) {
+    return;
+  }
+  LogInfo::MapleLogger() << "  implements:\n";
+  for (Klass *interface : implInterfaces) {
+    LogInfo::MapleLogger() << "   \t@implinterface_idx " << interface->structType->GetTypeIndex() << "\n";
+  }
+}
+
+void Klass::DumpKlassSuperKlasses() const {
+  if (superKlasses.empty()) {
+    return;
+  }
+  LogInfo::MapleLogger() << "   superclasses:\n";
+  for (Klass *superKlass : superKlasses) {
+    LogInfo::MapleLogger() << "   \t@superclass_idx " << superKlass->structType->GetTypeIndex() << "\n";
+  }
+}
+
+void Klass::DumpKlassSubKlasses() const {
+  if (subKlasses.empty()) {
+    return;
+  }
+  LogInfo::MapleLogger() << "   subclasses:\n";
+  for (Klass *subKlass : subKlasses) {
+    LogInfo::MapleLogger() << "   \t@subclass_idx " << subKlass->structType->GetTypeIndex() << "\n";
+  }
+}
+
+void Klass::Dump() const {
+  // Dump detailed class info
+  LogInfo::MapleLogger() << "class \" " << GetKlassName() << " \" @class_id " << structType->GetTypeIndex()
+                         << "\n";
+  DumpKlassSuperKlasses();
+  DumpKlassSubKlasses();
+  DumpKlassImplInterfaces();
+  DumpKlassImplKlasses();
+  DumpKlassMethods();
+}
+
+MIRFunction *Klass::GetClosestMethod(GStrIdx funcName) const {
+  MapleVector<MIRFunction*> *cands = GetCandidates(funcName);
+  if (cands != nullptr && !cands->empty()) {
+    return cands->at(0);
+  }
+  return nullptr;
+}
+
+void Klass::DelMethod(const MIRFunction &func) {
+  if (GetMethod(func.GetBaseFuncNameWithTypeStrIdx()) == &func) {
+    strIdx2Method.erase(func.GetBaseFuncNameWithTypeStrIdx());
+  }
+  for (auto it = methods.begin(); it != methods.end(); ++it) {
+    if (*it == &func) {
+      methods.erase(it--);
+      return;
+    }
+  }
+}
+
+// This for class only, which only has 0 or 1 super class
+Klass *Klass::GetSuperKlass() const {
+  switch (superKlasses.size()) {
+    case 0:
+      return nullptr;
+    case 1:
+      return *superKlasses.begin();
+    default:
+      LogInfo::MapleLogger() << GetKlassName() << "\n";
+      CHECK_FATAL(false, "GetSuperKlass expects less than one super class");
+  }
+}
+
+bool Klass::IsKlassMethod(const MIRFunction *func) const {
+  if (func == nullptr) {
+    return false;
+  }
+  for (MIRFunction *method : methods) {
+    if (method == func) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool Klass::ImplementsKlass() const {
+  if (IsInterface() || IsInterfaceIncomplete()) {
+    return false;
+  }
+  MIRClassType *classType = GetMIRClassType();
+  ASSERT(classType != nullptr, "null ptr check");
+  return (!classType->GetInterfaceImplemented().empty());
+}
+
+MapleVector<MIRFunction*> *Klass::GetCandidates(GStrIdx mnameNoklassStrIdx) const {
+  auto it = strIdx2CandidateMap.find(mnameNoklassStrIdx);
+  return ((it != strIdx2CandidateMap.end()) ? (it->second) : nullptr);
+}
+
+MIRFunction *Klass::GetUniqueMethod(GStrIdx mnameNoklassStrIdx) const {
+  if (structType->IsIncomplete()) {
+    return nullptr;
+  }
+  auto it = strIdx2CandidateMap.find(mnameNoklassStrIdx);
+  if (it != strIdx2CandidateMap.end()) {
+    MapleVector<MIRFunction*> *fv = it->second;
+    if (fv != nullptr && fv->size() == 1) {
+      return fv->at(0);
+    }
+  }
+  return nullptr;
+}
+
+bool Klass::IsVirtualMethod(const MIRFunction &func) const {
+  // May add other checking conditions in future
+  return (func.GetAttr(FUNCATTR_virtual) && !func.GetAttr(FUNCATTR_private) && !func.GetAttr(FUNCATTR_abstract));
+}
+
+void Klass::CountVirtMethTopDown(const KlassHierarchy &kh) {
+  MapleVector<MIRFunction*> *vec, *pvec;
+  GStrIdx strIdx;
+  auto *superAndImplClasses = alloc->GetMemPool()->New<MapleVector<Klass*>>(alloc->Adapter());
+  // Add default methods of interface. Add them first because they have lowest
+  // priorities compared with methods defined in classes
+  if (IsClass() || IsClassIncomplete()) {
+    for (TyIdx tyIdx : GetMIRClassType()->GetInterfaceImplemented()) {
+      Klass *interface = kh.GetKlassFromTyIdx(tyIdx);
+      if (interface != nullptr) {
+        superAndImplClasses->push_back(interface);
+      }
+    }
+  }
+
+  // Then add methods from superclasses
+  for (Klass *superKlass : std::as_const(superKlasses)) {
+    superAndImplClasses->push_back(superKlass);
+  }
+  // Initialize strIdx2CandidateMap based on the superclass methods
+  for (Klass *superAndImplClass : *superAndImplClasses) {
+    ASSERT(superAndImplClass != nullptr, "Not a valid super class of interface");
+    for (auto &pair : std::as_const(superAndImplClass->strIdx2CandidateMap)) {
+      strIdx = pair.first;
+      pvec = pair.second;
+      ASSERT(pvec->size() == 1, "Expect exactly one method definition from parent class");
+      if (strIdx2CandidateMap.find(strIdx) == strIdx2CandidateMap.end()) {
+        vec = alloc->GetMemPool()->New<MapleVector<MIRFunction*>>(alloc->Adapter());
+        vec->push_back(pvec->at(0));
+        strIdx2CandidateMap[strIdx] = vec;
+      } else {
+        // Override the method coming from previous klass (must be an interface)
+        ASSERT(strIdx2CandidateMap[strIdx]->size() == 1, "Expect exactly one method definition");
+        ASSERT(kh.GetKlassFromStrIdx(strIdx2CandidateMap[strIdx]->at(0)->GetBaseClassNameStrIdx())->IsInterface(),
+               "Override interface default methods");
+        // Interfaces implemented methods override, need to determine the inherit relation.
+        // class method can override interface method, interface method can override its parent's methods
+        vec = strIdx2CandidateMap[strIdx];
+        ASSERT(vec != nullptr, "nullptr check!");
+        ASSERT(vec->size() == 1, "Expect exactly one method definition from parent class");
+        Klass *parentKlass = kh.GetKlassFromFunc((*vec)[0]);
+        Klass *childKlass = kh.GetKlassFromFunc((*pvec)[0]);
+        CHECK_FATAL(childKlass != nullptr, "childKlass is null in Klass::CountVirtMethTopDown");
+        if (childKlass->IsInterface() && !kh.IsSuperKlassForInterface(parentKlass, childKlass)) {
+          continue;
+        }
+        (*vec)[0] = (*pvec)[0];
+      }
+    }
+  }
+  // Initialize mstridx2count_map based on the current class methods
+  for (MIRFunction *method : std::as_const(methods)) {
+    ASSERT(method != nullptr, "null ptr check!");
+    if (!IsVirtualMethod(*method)) {
+      continue;
+    }
+    strIdx = method->GetBaseFuncNameWithTypeStrIdx();
+    if (strIdx2CandidateMap.find(strIdx) != strIdx2CandidateMap.end()) {
+      // Override the method coming from parent
+      vec = strIdx2CandidateMap[strIdx];
+      ASSERT(vec != nullptr, "nullptr check!");
+      ASSERT(vec->size() == 1, "Expect exactly one method definition from parent class");
+      (*vec)[0] = method;
+    } else {
+      // Newly declared and defined
+      vec = alloc->GetMemPool()->New<MapleVector<MIRFunction*>>(alloc->Adapter());
+      vec->push_back(method);
+      strIdx2CandidateMap[strIdx] = vec;
+    }
+  }
+}
+
+void Klass::CountVirtMethBottomUp() {
+  MapleVector<MIRFunction*> *vec;
+  GStrIdx strIdx;
+  for (Klass *subKlass : subKlasses) {
+    CHECK_FATAL(subKlass != nullptr, "nullptr check failed");
+    for (auto &pair : std::as_const(subKlass->strIdx2CandidateMap)) {
+      strIdx = pair.first;
+      if (strIdx2CandidateMap.find(strIdx) == strIdx2CandidateMap.end()) {
+        continue;
+      }
+      vec = strIdx2CandidateMap[strIdx];
+      MapleVector<MIRFunction*> *subv = pair.second;
+      if (!vec->empty() && !subv->empty() && vec->at(0) == subv->at(0)) {
+        // If this class and subclass share the same default implementation,
+        // then we have to avoid duplicated counting.
+        vec->insert(vec->cend(), subv->cbegin() + 1, subv->cend());
+      } else {
+        vec->insert(vec->cend(), subv->cbegin(), subv->cend());
+      }
+    }
+  }
+}
+
+const MIRFunction *Klass::HasMethod(const std::string &funcname) const {
+  for (auto *method : methods) {
+    if (method->GetBaseFuncNameWithType().find(funcname) != std::string::npos) {
+      return method;
+    }
+  }
+  return nullptr;
+}
+
+Klass *KlassHierarchy::GetKlassFromStrIdx(GStrIdx strIdx) const {
+  auto it = strIdx2KlassMap.find(strIdx);
+  return ((it != strIdx2KlassMap.end()) ? (it->second) : nullptr);
+}
+
+Klass *KlassHierarchy::GetKlassFromTyIdx(TyIdx tyIdx) const {
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+  return (type != nullptr ? GetKlassFromStrIdx(type->GetNameStrIdx()) : nullptr);
+}
+
+Klass *KlassHierarchy::GetKlassFromFunc(const MIRFunction *func) const {
+  return (func != nullptr ? GetKlassFromStrIdx(func->GetBaseClassNameStrIdx()) : nullptr);
+}
+
+Klass *KlassHierarchy::GetKlassFromName(const std::string &name) const {
+  return GetKlassFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(name));
+}
+
+Klass *KlassHierarchy::GetKlassFromLiteral(const std::string &name) const {
+  return GetKlassFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::GetInternalNameLiteral(name)));
+}
+
+// check if super is a superclass of base
+// 1/0/-1: true/false/unknown
+int KlassHierarchy::IsSuperKlass(TyIdx superTyIdx, TyIdx baseTyIdx) const {
+  if (superTyIdx == 0u || baseTyIdx == 0u) {
+    return -1;
+  }
+  if (superTyIdx == baseTyIdx) {
+    return 1;
+  }
+  Klass *super = GetKlassFromTyIdx(superTyIdx);
+  Klass *base = GetKlassFromTyIdx(baseTyIdx);
+  if (super == nullptr || base == nullptr) {
+    return -1;
+  }
+  while (base != nullptr) {
+    if (base == super) {
+      return 1;
+    }
+    base = base->GetSuperKlass();
+  }
+  return 0;
+}
+
+bool KlassHierarchy::IsSuperKlass(const Klass *super, const Klass *base) const {
+  if (super == nullptr || base == nullptr || base->IsInterface()) {
+    return false;
+  }
+  while (base != nullptr) {
+    if (base == super) {
+      return true;
+    }
+    base = base->GetSuperKlass();
+  }
+  return false;
+}
+
+// Interface
+bool KlassHierarchy::IsSuperKlassForInterface(const Klass *super, const Klass *base) const {
+  if (super == nullptr || base == nullptr) {
+    return false;
+  }
+  if (!super->IsInterface() || !base->IsInterface()) {
+    return false;
+  }
+  std::vector<const Klass*> tmpVector;
+  tmpVector.push_back(base);
+  for (size_t idx = 0; idx < tmpVector.size(); ++idx) {
+    if (tmpVector[idx] == super) {
+      return true;
+    }
+    for (const Klass *superKlass : tmpVector[idx]->GetSuperKlasses()) {
+      tmpVector.push_back(superKlass);
+    }
+  }
+  return false;
+}
+
+bool KlassHierarchy::IsInterfaceImplemented(Klass *interface, const Klass *base) const {
+  if (interface == nullptr || base == nullptr) {
+    return false;
+  }
+  if (!interface->IsInterface() || !base->IsClass()) {
+    return false;
+  }
+  // All the implemented interfaces and their parent interfaces
+  // are directly stored in this set, so no need to look up super
+  return (base->GetImplInterfaces().find(interface) != base->GetImplInterfaces().end());
+}
+
+int KlassHierarchy::GetFieldIDOffsetBetweenClasses(const Klass &super, const Klass &base) const {
+  int offset = 0;
+  const Klass *superPtr = &super;
+  const Klass *basePtr = &base;
+  while (basePtr != superPtr) {
+    basePtr = basePtr->GetSuperKlass();
+    CHECK_FATAL(basePtr != nullptr, "null ptr check");
+    offset++;
+  }
+  return offset;
+}
+
+bool KlassHierarchy::UpdateFieldID(TyIdx baseTypeIdx, TyIdx targetTypeIdx, FieldID &fldID) const {
+  MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(baseTypeIdx);
+  MIRType *targetType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(targetTypeIdx);
+  if (baseType->GetKind() == kTypePointer && targetType->GetKind() == kTypePointer) {
+    baseType = static_cast<const MIRPtrType*>(baseType)->GetPointedType();
+    targetType = static_cast<const MIRPtrType*>(targetType)->GetPointedType();
+  }
+  if (baseType->GetKind() != kTypeClass || targetType->GetKind() != kTypeClass) {
+    return false;
+  }
+  Klass *baseKlass = GetKlassFromTyIdx(baseType->GetTypeIndex());
+  ASSERT(baseKlass != nullptr, "null ptr check");
+  Klass *targetKlass = GetKlassFromTyIdx(targetType->GetTypeIndex());
+  ASSERT(targetKlass != nullptr, "null ptr check");
+  if (IsSuperKlass(baseKlass, targetKlass)) {
+    fldID += GetFieldIDOffsetBetweenClasses(*baseKlass, *targetKlass);
+    return true;
+  } else if (IsSuperKlass(targetKlass, baseKlass)) {
+    fldID -= GetFieldIDOffsetBetweenClasses(*targetKlass, *baseKlass);
+    return true;
+  }
+  return false;
+}
+
+bool KlassHierarchy::NeedClinitCheckRecursively(const Klass &kl) const {
+  if (kl.HasFlag(kClassRuntimeVerify)) {
+    return true;
+  }
+  const Klass *klass = &kl;
+  if (klass->IsClass()) {
+    while (klass != nullptr) {
+      if (klass->GetClinit()) {
+        return true;
+      }
+      klass = klass->GetSuperKlass();
+    }
+    for (Klass *implInterface : kl.GetImplInterfaces()) {
+      if (implInterface->GetClinit()) {
+        for (auto &func : implInterface->GetMethods()) {
+          if (!func->GetAttr(FUNCATTR_abstract) && !func->GetAttr(FUNCATTR_static)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  if (klass->IsInterface()) {
+    return klass->GetClinit();
+  }
+  return true;
+}
+
+// Get lowest common ancestor for two classes
+Klass *KlassHierarchy::GetLCA(Klass *klass1, Klass *klass2) const {
+  std::vector<Klass*> v1, v2;
+  while (klass1 != nullptr) {
+    v1.push_back(klass1);
+    klass1 = klass1->GetSuperKlass();
+  }
+  while (klass2 != nullptr) {
+    v2.push_back(klass2);
+    klass2 = klass2->GetSuperKlass();
+  }
+  Klass *result = nullptr;
+  size_t size1 = v1.size();
+  size_t size2 = v2.size();
+  size_t min = (size1 < size2) ? size1 : size2;
+  for (size_t i = 1; i <= min; ++i) {
+    if (v1[size1 - i] != v2[size2 - i]) {
+      break;
+    }
+    result = v1[size1 - i];
+  }
+  return result;
+}
+
+TyIdx KlassHierarchy::GetLCA(TyIdx ty1, TyIdx ty2) const {
+  Klass *result = GetLCA(GetKlassFromTyIdx(ty1), GetKlassFromTyIdx(ty2));
+  return (result != nullptr ? result->GetTypeIdx() : TyIdx(0));
+}
+
+GStrIdx KlassHierarchy::GetLCA(GStrIdx str1, GStrIdx str2) const {
+  Klass *result = GetLCA(GetKlassFromStrIdx(str1), GetKlassFromStrIdx(str2));
+  return (result != nullptr ? result->GetKlassNameStrIdx() : GStrIdx(0));
+}
+
+const std::string &KlassHierarchy::GetLCA(const std::string &name1, const std::string &name2) const {
+  Klass *result = GetLCA(GetKlassFromName(name1), GetKlassFromName(name2));
+  return (result != nullptr ? result->GetKlassName() : GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(0)));
+}
+
+void KlassHierarchy::AddKlasses() {
+  for (MIRType *type : GlobalTables::GetTypeTable().GetTypeTable()) {
+#if DEBUG
+    if (type != nullptr) {
+      MIRTypeKind kd = type->GetKind();
+      if (kd == kTypeStructIncomplete || kd == kTypeClassIncomplete || kd == kTypeInterfaceIncomplete)
+        LogInfo::MapleLogger() << "Warning: KlassHierarchy::AddKlasses "
+                               << GlobalTables::GetStrTable().GetStringFromStrIdx(type->GetNameStrIdx())
+                               << " INCOMPLETE \n";
+    }
+#endif
+    if (Options::deferredVisit2 && type && (type->IsIncomplete())) {
+      GStrIdx stridx = type->GetNameStrIdx();
+      std::string strName = GlobalTables::GetStrTable().GetStringFromStrIdx(stridx);
+#if DEBUG
+      LogInfo::MapleLogger() << "Waring: " << strName << " INCOMPLETE \n";
+#endif
+      if (strName == namemangler::kClassMetadataTypeName) {
+        continue;
+      }
+    } else if (type == nullptr || (type->GetKind() != kTypeClass && type->GetKind() != kTypeInterface)) {
+      continue;
+    }
+    GStrIdx strIdx = type->GetNameStrIdx();
+    Klass *klass = GetKlassFromStrIdx(strIdx);
+    if (klass != nullptr) {
+      if (klass->GetKlassName().compare(namemangler::kThrowClassStr) == 0) {
+        klass->SetExceptionKlass();
+      }
+      continue;
+    }
+    auto *stype = static_cast<MIRStructType*>(type);
+    klass = GetMempool()->New<Klass>(stype, &alloc);
+    strIdx2KlassMap[strIdx] = klass;
+  }
+}
+
+void KlassHierarchy::ExceptionFlagProp(Klass &klass) {
+  klass.SetExceptionKlass();
+  for (Klass *subClass : klass.GetSubKlasses()) {
+    ASSERT(subClass != nullptr, "null ptr check!");
+    subClass->SetExceptionKlass();
+    ExceptionFlagProp(*subClass);
+  }
+}
+
+void KlassHierarchy::AddKlassRelationAndMethods() {
+  for (auto &pair : std::as_const(strIdx2KlassMap)) {
+    Klass *klass = pair.second;
+    ASSERT(klass, "null ptr check");
+    Klass *superKlass = nullptr;
+    if (klass->IsInterface() || klass->IsInterfaceIncomplete()) {
+      MIRInterfaceType *itype = klass->GetMIRInterfaceType();
+      ASSERT(itype != nullptr, "null ptr check");
+      // Java interface supports multiple inheritance
+      for (TyIdx superTyIdx : itype->GetParentsTyIdx()) {
+        superKlass = GetKlassFromTyIdx(superTyIdx);
+        if (superKlass != nullptr) {
+          klass->AddSuperKlass(superKlass);
+          superKlass->AddSubKlass(klass);
+        }
+      }
+    } else if (klass->IsClass() || klass->IsClassIncomplete()) {
+      // Class
+      MIRClassType *classType = klass->GetMIRClassType();
+      ASSERT(classType != nullptr, "null ptr check");
+      // Add interface relationship
+      for (TyIdx intfTyIdx : classType->GetInterfaceImplemented()) {
+        Klass *intfKlass = GetKlassFromTyIdx(intfTyIdx);
+        if (intfKlass != nullptr) {
+          intfKlass->AddImplKlass(klass);
+          klass->AddImplInterface(intfKlass);
+        }
+      }
+      superKlass = GetKlassFromTyIdx(classType->GetParentTyIdx());
+      // Add superclass/subclass for each class.
+      if (superKlass != nullptr) {
+        klass->AddSuperKlass(superKlass);
+        superKlass->AddSubKlass(klass);
+        // klass implements same interfaces inherited from its parent
+        for (Klass *intfklass : superKlass->GetImplInterfaces()) {
+          intfklass->AddImplKlass(klass);
+          klass->AddImplInterface(intfklass);
+        }
+      }
+    }
+    // Add method info
+    for (const auto &methodPair : klass->GetMIRStructType()->GetMethods()) {
+      MIRSymbol *funcSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodPair.first.Idx());
+      MIRFunction *method = funcSym->GetFunction();
+      klass->AddMethod(*method);
+      if (method->GetName().compare(klass->GetKlassName() + namemangler::kClinitSuffix) == 0) {
+        klass->SetClinit(method);
+      }
+    }
+  }
+  // Propagate isExceptionKlass flag
+  if (GetKlassFromLiteral(namemangler::kThrowClassStr) != nullptr) {
+    ExceptionFlagProp(*GetKlassFromLiteral(namemangler::kThrowClassStr));
+    CHECK_FATAL(GetKlassFromLiteral(namemangler::kThrowClassStr)->IsExceptionKlass(), "must be exception class");
+  }
+  if (GetKlassFromLiteral(kJavaLangNoMethodStr) != nullptr) {
+    CHECK_FATAL(GetKlassFromLiteral(kJavaLangNoMethodStr)->IsExceptionKlass(), "must be exception class");
+  }
+}
+
+void KlassHierarchy::TagThrowableKlasses() {
+  Klass *throwable = GetKlassFromName(namemangler::kThrowClassStr);
+  if (throwable == nullptr) {
+    return;
+  }
+  for (auto &pair : std::as_const(strIdx2KlassMap)) {
+    Klass *klass = pair.second;
+    ASSERT(klass != nullptr, "unexpeced null klass");
+    if (!klass->IsInterface() && IsSuperKlass(throwable, klass)) {
+      klass->SetExceptionKlass();
+    }
+  }
+}
+
+static void CollectImplInterfaces(const Klass &klass, std::set<Klass*> &implInterfaceSet) {
+  for (Klass *superKlass : klass.GetSuperKlasses()) {
+    if (implInterfaceSet.find(superKlass) == implInterfaceSet.end()) {
+      ASSERT(superKlass != nullptr, "null ptr check!");
+      if (superKlass->IsInterface()) {
+        implInterfaceSet.insert(superKlass);
+      }
+      CollectImplInterfaces(*superKlass, implInterfaceSet);
+    }
+  }
+  for (Klass *interfaceKlass : klass.GetImplInterfaces()) {
+    if (implInterfaceSet.find(interfaceKlass) == implInterfaceSet.end()) {
+      implInterfaceSet.insert(interfaceKlass);
+      ASSERT(interfaceKlass != nullptr, "null ptr check!");
+      CollectImplInterfaces(*interfaceKlass, implInterfaceSet);
+    }
+  }
+}
+
+void KlassHierarchy::UpdateImplementedInterfaces() {
+  for (auto &pair : std::as_const(strIdx2KlassMap)) {
+    Klass *klass = pair.second;
+    ASSERT(klass != nullptr, "null ptr check");
+    if (!klass->IsInterface()) {
+      std::set<Klass*> implInterfaceSet;
+      CollectImplInterfaces(*klass, implInterfaceSet);
+      for (auto interface : implInterfaceSet) {
+        // Add missing parent interface to class link
+        interface->AddImplKlass(klass);
+        klass->AddImplInterface(interface);
+      }
+    }
+  }
+}
+
+void KlassHierarchy::GetParentKlasses(const Klass &klass, std::vector<Klass*> &parentKlasses) const {
+  for (Klass *superKlass : klass.GetSuperKlasses()) {
+    parentKlasses.push_back(superKlass);
+  }
+  if (!klass.IsInterface()) {
+    for (Klass *iklass : klass.GetImplInterfaces()) {
+      parentKlasses.push_back(iklass);
+    }
+  }
+}
+
+void KlassHierarchy::GetChildKlasses(const Klass &klass, std::vector<Klass*> &childKlasses) const {
+  for (Klass *subKlass : klass.GetSubKlasses()) {
+    childKlasses.push_back(subKlass);
+  }
+  if (klass.IsInterface()) {
+    for (Klass *implKlass : klass.GetImplKlasses()) {
+      childKlasses.push_back(implKlass);
+    }
+  }
+}
+
+void KlassHierarchy::TopologicalSortKlasses() {
+  std::set<Klass*> inQueue;  // Local variable, no need to use MapleSet
+  for (auto &pair : std::as_const(strIdx2KlassMap)) {
+    Klass *klass = pair.second;
+    ASSERT(klass != nullptr, "klass can not be nullptr");
+    if (!klass->HasSuperKlass() && !klass->ImplementsKlass()) {
+      topoWorkList.push_back(klass);
+      inQueue.insert(klass);
+    }
+  }
+  // Top-down iterates all nodes
+  for (size_t i = 0; i < topoWorkList.size(); ++i) {
+    Klass *klass = topoWorkList[i];
+    std::vector<Klass*> childklasses;
+    ASSERT(klass != nullptr, "null ptr check!");
+    GetChildKlasses(*klass, childklasses);
+    for (Klass *childklass : childklasses) {
+      if (inQueue.find(childklass) == inQueue.end()) {
+        // callee has not been visited
+        bool parentKlassAllVisited = true;
+        std::vector<Klass*> parentKlasses;
+        ASSERT(childklass != nullptr, "null ptr check!");
+        GetParentKlasses(*childklass, parentKlasses);
+        // Check whether all callers of the current callee have been visited
+        for (Klass *parentKlass : parentKlasses) {
+          if (inQueue.find(parentKlass) == inQueue.end()) {
+            parentKlassAllVisited = false;
+            break;
+          }
+        }
+        if (parentKlassAllVisited) {
+          topoWorkList.push_back(childklass);
+          inQueue.insert(childklass);
+        }
+      }
+    }
+  }
+}
+
+void KlassHierarchy::CountVirtualMethods() const {
+  // Top-down iterates all klass nodes
+  for (Klass *klass : topoWorkList) {
+    klass->CountVirtMethTopDown(*this);
+  }
+  // Bottom-up iterates all klass nodes
+  for (size_t i = topoWorkList.size(); i != 0; --i) {
+    topoWorkList[i - 1]->CountVirtMethBottomUp();
+  }
+}
+
+Klass *KlassHierarchy::AddClassFlag(const std::string &name, uint32 flag) {
+  Klass *refKlass = GetKlassFromLiteral(name);
+  if (refKlass != nullptr) {
+    refKlass->SetFlag(flag);
+  }
+  return refKlass;
+}
+
+// Mark klasses those implement the finalize method, or inherit
+// from super klass (except java.lang.Object).
+// Mark klasses those or superclasses are references.
+void KlassHierarchy::MarkClassFlags() {
+  Klass *cleanerKlass = AddClassFlag("Lsun_2Fmisc_2FCleaner_3B", kClassCleaner);
+  AddClassFlag("Ljava_2Flang_2Fref_2FSoftReference_3B", kClassSoftreference);
+  AddClassFlag("Ljava_2Flang_2Fref_2FWeakReference_3B", kClassWeakreference);
+  AddClassFlag("Ljava_2Flang_2Fref_2FPhantomReference_3B", kClassPhantomreference);
+  AddClassFlag("Ljava_2Flang_2Fref_2FFinalizerReference_3B", kClassFinalizereference);
+  AddClassFlag("Ljava_2Flang_2Fref_2FFinalizerReference_24Sentinel_3B", kClassFinalizerreferenceSentinel);
+  Klass *klassObject = GetKlassFromLiteral(namemangler::kJavaLangObjectStr);
+  GStrIdx finalize = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("finalize_7C_28_29V");
+  for (Klass *klass : topoWorkList) {
+    if (klass == klassObject) {
+      continue;
+    }
+    if (klass->IsInterface()) {
+      continue;
+    }
+    Klass *super = klass->GetSuperKlass();
+    // Mark Reference
+    // sun.misc.Cleaner's superclass is PhantomReference.
+    // Break this chain to process Cleaner correctly.
+    if (super != nullptr && super->IsReference() && klass != cleanerKlass) {
+      klass->SetFlag(super->GetFlag(kClassReference));
+    }
+    // Mark Finalizer
+    if (super != nullptr && super->HasFinalizer()) {
+      klass->SetHasFinalizer();
+    } else {
+      for (auto &method : klass->GetMethods()) {
+        if (method->GetBaseFuncNameWithTypeStrIdx() == finalize) {
+          klass->SetHasFinalizer();
+          break;
+        }
+      }
+    }
+    // Mark native function info
+    for (auto &method : klass->GetMethods()) {
+      if (method->GetAttr(FUNCATTR_native)) {
+        klass->SetHasNativeMethod(true);
+        break;
+      }
+    }
+  }
+}
+
+void KlassHierarchy::Dump() const {
+  for (Klass *klass : topoWorkList) {
+    klass->Dump();
+  }
+}
+
+GStrIdx KlassHierarchy::GetUniqueMethod(GStrIdx vfuncNameStridx) const {
+  auto it = vfunc2RfuncMap.find(vfuncNameStridx);
+  return (it != vfunc2RfuncMap.end() ? it->second : GStrIdx(0));
+}
+
+bool KlassHierarchy::IsDevirtualListEmpty() const {
+  return vfunc2RfuncMap.empty();
+}
+
+void KlassHierarchy::DumpDevirtualList(const std::string &outputFileName) const {
+  std::unordered_map<std::string, std::string> funcMap;
+  for (Klass *klass : topoWorkList) {
+    for (MIRFunction *func : klass->GetMethods()) {
+      MIRFunction *uniqCand = klass->GetUniqueMethod(func->GetBaseFuncNameWithTypeStrIdx());
+      if (uniqCand != nullptr) {
+        funcMap[func->GetName()] = uniqCand->GetName();
+      }
+    }
+  }
+  std::ofstream outputFile;
+  outputFile.open(outputFileName);
+  for (auto it : funcMap) {
+    outputFile << it.first << "\t" << it.second << "\n";
+  }
+  outputFile.close();
+}
+
+void KlassHierarchy::ReadDevirtualList(const std::string &inputFileName) {
+  std::ifstream inputFile;
+  inputFile.open(inputFileName);
+  std::string vfuncName;
+  std::string rfuncName;
+  while (inputFile >> vfuncName >> rfuncName) {
+    vfunc2RfuncMap[GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(vfuncName)] =
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(rfuncName);
+  }
+  inputFile.close();
+}
+
+void KlassHierarchy::BuildHierarchy() {
+  // Scan class list and generate Klass without method information
+  AddKlasses();
+  // Fill class method info. Connect superclass<->subclass and
+  // interface->implementation edges.
+  AddKlassRelationAndMethods();
+  TagThrowableKlasses();
+  // In the case of "class C implements B; interface B extends A;",
+  // we need to add a link between C and A.
+  UpdateImplementedInterfaces();
+  TopologicalSortKlasses();
+  MarkClassFlags();
+  if (!strIdx2KlassMap.empty()) {
+    WKTypes::Init();
+  }
+  // Use --dump-devirtual-list=... to dump a closed-wolrd analysis result into a file
+  if (!Options::dumpDevirtualList.empty()) {
+    DumpDevirtualList(Options::dumpDevirtualList);
+  }
+  // Use --read-devirtual-list=... to read in a closed-world analysis result
+  if (!Options::readDevirtualList.empty()) {
+    ReadDevirtualList(Options::readDevirtualList);
+  }
+}
+
+KlassHierarchy::KlassHierarchy(MIRModule *mirmodule, MemPool *memPool)
+    : AnalysisResult(memPool),
+      alloc(memPool),
+      mirModule(mirmodule),
+      strIdx2KlassMap(std::less<GStrIdx>(), alloc.Adapter()),
+      vfunc2RfuncMap(std::less<GStrIdx>(), alloc.Adapter()),
+      topoWorkList(alloc.Adapter()) {}
+
+MIRType *WKTypes::javaLangObject;
+MIRType *WKTypes::javaLangString;
+MIRType *WKTypes::javaLangObjectSerializable;
+MIRType *WKTypes::javaLangComparable;
+MIRType *WKTypes::javaLangCharSequence;
+MIRType *WKTypes::javaLangClass;
+MIRType *WKTypes::javaLangRefGenericDeclaration;
+MIRType *WKTypes::javaLangRefAnnotatedElement;
+MIRType *WKTypes::javaLangRefType;
+MIRType *WKTypes::javaLangRefMethod;
+MIRType *WKTypes::javaLangRefExecutable;
+MIRType *WKTypes::javaLangRefAccessibleObject;
+MIRType *WKTypes::javaLangRefMember;
+MIRType *WKTypes::javaLangRefField;
+MIRType *WKTypes::javaLangRefConstructor;
+inline static MIRType *GetMIRTypeFromName(const std::string &name) {
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::GetInternalNameLiteral(name));
+  return GlobalTables::GetTypeTable().GetTypeFromTyIdx(GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(gStrIdx));
+}
+
+void WKTypes::Init() {
+  javaLangObject = GetMIRTypeFromName(namemangler::kJavaLangObjectStr);
+  javaLangString = GetMIRTypeFromName("Ljava_2Flang_2FString_3B");
+  javaLangObjectSerializable = GetMIRTypeFromName("Ljava_2Fio_2FSerializable_3B");
+  javaLangComparable = GetMIRTypeFromName("Ljava_2Flang_2FComparable_3B");
+  javaLangCharSequence = GetMIRTypeFromName("Ljava_2Flang_2FCharSequence_3B");
+  javaLangClass = GetMIRTypeFromName("Ljava_2Flang_2FClass_3B");
+  javaLangRefGenericDeclaration = GetMIRTypeFromName("Ljava_2Flang_2Freflect_2FGenericDeclaration_3B");
+  javaLangRefAnnotatedElement = GetMIRTypeFromName("Ljava_2Flang_2Freflect_2FAnnotatedElement_3B");
+  javaLangRefType = GetMIRTypeFromName("Ljava_2Flang_2Freflect_2FType_3B");
+  javaLangRefMethod = GetMIRTypeFromName("Ljava_2Flang_2Freflect_2FMethod_3B");
+  javaLangRefExecutable = GetMIRTypeFromName("Ljava_2Flang_2Freflect_2FExecutable_3B");
+  javaLangRefAccessibleObject = GetMIRTypeFromName("Ljava_2Flang_2Freflect_2FAccessibleObject_3B");
+  javaLangRefMember = GetMIRTypeFromName("Ljava_2Flang_2Freflect_2FMember_3B");
+  javaLangRefField = GetMIRTypeFromName("Ljava_2Flang_2Freflect_2FField_3B");
+  javaLangRefConstructor = GetMIRTypeFromName("Ljava_2Flang_2Freflect_2FConstructor_3B");
+}
+
+// Return true if node n may point to a String object.
+// String is declared as:
+//   public final class String implements java.io.Serializable, Comparable<String>, CharSequence
+// So n can point to String only if n's type is a ref to String or Object, or is an interface
+// type of java.io.Serializable, Comparable or CharSequence
+bool WKTypes::Util::MayRefString(const BaseNode &n, MIRType &type) {
+  if ((n.GetPrimType() == PTY_ref || n.GetPrimType() == PTY_ptr) && type.GetKind() == kTypePointer) {
+    auto *pointType = static_cast<MIRPtrType*>(&type);
+    MIRType *pointedType = pointType->GetPointedType();
+    if (pointedType == javaLangString || pointedType == javaLangObjectSerializable ||
+        pointedType == javaLangComparable ||
+        pointedType == javaLangCharSequence || pointedType == javaLangObject) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Return true if node n may point to Meta object, i.e, n is a reference
+// of java.lang.Class, java.lang.reflect.Method, java.lang.reflect.Field,
+// java.lang.reflect.Constructor
+bool WKTypes::Util::MayRefMeta(const BaseNode &n, MIRType &type) {
+  if ((n.GetPrimType() == PTY_ref || n.GetPrimType() == PTY_ptr) && type.GetKind() == kTypePointer) {
+    auto *pointType = static_cast<MIRPtrType*>(&type);
+    MIRType *pointedType = pointType->GetPointedType();
+    // Definition of java.lang.Class:
+    // public final class Class<T> implements java.io.Serializable,
+    // GenericDeclaration,
+    // Type,
+    // AnnotatedElement {...}
+    // public interface Serializable {}
+    // public interface GenericDeclaration extends AnnotatedElement {...}
+    // public interface AnnotatedElement {...}
+    // public interface Type {...}
+    // public interface AnnotatedElement {...}
+    if (pointedType == javaLangClass || pointedType == javaLangObjectSerializable ||
+        pointedType == javaLangRefGenericDeclaration || pointedType == javaLangRefAnnotatedElement ||
+        pointedType == javaLangRefType || pointedType == javaLangObject) {
+      return true;
+    }
+    // Definition of java.lang.reflect.Method:
+    // public final class Method extends Executable {...}
+    // public abstract class Executable extends AccessibleObject
+    // implements Member, GenericDeclaration {...}
+    // public class AccessibleObject implements AnnotatedElement {...}
+    // public interface AnnotatedElement {...}
+    // public interface Member {...}
+    // public interface GenericDeclaration extends AnnotatedElement {...}
+    // public interface AnnotatedElement {...}
+    if (pointedType == javaLangRefMethod || pointedType == javaLangRefExecutable ||
+        pointedType == javaLangRefAccessibleObject ||
+        pointedType == javaLangRefMember || pointedType == javaLangRefGenericDeclaration ||
+        pointedType == javaLangRefAnnotatedElement || pointedType == javaLangObject) {
+      return true;
+    }
+    // Definition of java.lang.reflect.Field:
+    // public final class Field extends AccessibleObject implements Member {...}
+    if (pointedType == javaLangRefField) {  // super classes/interfaces are checked by javaLangRefMethod
+      return true;
+    }
+    // Definition of java.lang.reflect.Constructor:
+    // public final class Constructor<T> extends Executable {...}
+    if (pointedType == javaLangRefConstructor) {  // super classes are checked by javaLangRefMethod
+      return true;
+    }
+  }
+  return false;
+}
+
+// Return true if node 'n', whose type is 'type', can not form a reference cycle.
+// E.g, all fields are primitive types, String, array of primitive, etc.
+bool WKTypes::Util::MayNotRefCyclicly(const BaseNode &n, MIRType &type) {
+  CHECK_FATAL((n.GetPrimType() == PTY_ref || n.GetPrimType() == PTY_ptr) && type.GetKind() == kTypePointer,
+              "n must be a reference");
+  std::set<MIRType*> workList;
+  workList.insert(&type);
+  return NotCyclicType(type, workList);
+}
+
+// Helper function of WKTypes::Util::MayNotRefCyclicly.
+bool WKTypes::Util::NotCyclicType(MIRType &type, std::set<MIRType*> &workList) {
+  // Fast path for special cases: String, Class
+  if (&type == javaLangString || &type == javaLangClass) {
+    return true;
+  }
+  if (type.GetKind() == kTypeScalar) {  // primitive type
+    return true;
+  }
+  if (type.GetKind() == kTypePointer) {
+    auto *pointedType = static_cast<MIRPtrType*>(&type)->GetPointedType();
+    ASSERT(pointedType != nullptr, "null ptr check!");
+    return NotCyclicType(*pointedType, workList);
+  }
+  if (type.GetKind() == kTypeJArray) {
+    MIRType *elemType =
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<MIRJarrayType*>(&type)->GetElemTyIdx());
+    ASSERT(elemType != nullptr, "null ptr check!");
+    return NotCyclicType(*elemType, workList);
+  }
+  if (type.GetKind() == kTypeClass) {
+    auto *classType = static_cast<MIRClassType*>(&type);
+    if (!classType->IsFinal()) {  // Not sure what actual class it refers to
+      return false;
+    }
+    std::vector<FieldPair> allFields;
+    allFields.insert(allFields.cend(), classType->GetFields().cbegin(), classType->GetFields().cend());
+    // ignore static fields for now, they are not recycled anyway
+    MIRType *parentType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType->GetParentTyIdx());
+    while (parentType != nullptr) {
+      CHECK_FATAL(parentType->GetKind() == kTypeClass, "parent class");
+      auto *parentclass = static_cast<MIRClassType*>(parentType);
+      allFields.insert(allFields.cend(), parentclass->GetFields().cbegin(), parentclass->GetFields().cend());
+      // ignore static fields for now, they are not recycled anyway
+      parentType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentclass->GetParentTyIdx());
+    }
+    // Ignore interface fields, as they are all static final (constant) variables
+    for (FieldPair &fieldPair : allFields) {
+      MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first);
+      ASSERT(fieldType != nullptr, "null ptr check!");
+      if (fieldType->GetKind() == kTypePointer) {
+        // Strictly, we should check whether fieldType is 'assignable' from any type
+        // recorded in worklist, which means a cycle may be formed. However, this
+        // function returns false for any non-final calss (see above), so we only
+        // check if fieldType is 'equal' to any type recorded in the worklist.
+        // An example:
+        // class B extends A {
+        //    A field_a;
+        // }
+        // field_a may point to an instance of B and henceforce a possible cycle.
+        // Since A is not a final class, we can recognize it as a cycle candidate.
+        if (workList.find(fieldType) != workList.end()) {
+          return false;
+        }
+        workList.insert(fieldType);
+      }
+      if (!NotCyclicType(*fieldType, workList)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (type.GetKind() == kTypeInterface) {
+    // Perhaps something more can do.
+    return false;
+  }
+  return false;
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/class_hierarchy_phase.cpp b/src/mapleall/mpl2mpl/src/class_hierarchy_phase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9ff97ab401edbe3ad562d28c1edcb40e9efe50ff
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/class_hierarchy_phase.cpp
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include "class_hierarchy_phase.h"
+namespace maple {
+bool M2MKlassHierarchy::PhaseRun(maple::MIRModule &m) {
+  kh = GetPhaseMemPool()->New<KlassHierarchy>(&m, GetPhaseMemPool());
+  KlassHierarchy::traceFlag = Options::dumpPhase.compare(PhaseName()) == 0;
+  kh->BuildHierarchy();
+#if MIR_JAVA
+  if (!Options::skipVirtualMethod) {
+    kh->CountVirtualMethods();
+  }
+#else
+  kh->CountVirtualMethods();
+#endif
+  if (KlassHierarchy::traceFlag) {
+    kh->Dump();
+  }
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/class_init.cpp b/src/mapleall/mpl2mpl/src/class_init.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dfb20a0bb0ded766319e2d8a2655d7a94cbe099c
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/class_init.cpp
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "class_init.h"
+#include <iostream>
+#include <fstream>
+
+namespace {
+constexpr char kCinfString[] = "__cinf_Ljava_2Flang_2FString_3B";
+constexpr char kINFOFilename[] = "INFO_filename";
+constexpr char kCoreAll[] = "core-all";
+constexpr char kMCCPreClinitCheck[] = "MCC_PreClinitCheck";
+constexpr char kMCCPostClinitCheck[] = "MCC_PostClinitCheck";
+} // namespace
+
+// This phase does two things.
+// 1. Insert clinit(class initialization) check, a intrinsic call INTRN_MPL_CLINIT_CHECK
+//   for place where needed.
+//   Insert clinit check for static native methods which are not private.
+// 2. Lower JAVA_CLINIT_CHECK to MPL_CLINIT_CHECK.
+//   Before insert or tranform the clinit check, we used a optimise based on
+//   white list. When the dexname is core-all and the class is in the white list
+//   we dont't insert clinit check.Because the class in the white list is intialized
+//   in the system bootup.
+namespace maple {
+bool ClassInit::CanRemoveClinitCheck(const std::string &clinitClassname) const {
+  if (!Options::usePreloadedClass) {
+    return false;
+  }
+  if (clinitClassname.empty()) {
+    return false;
+  }
+  if (clinitClassname == kCinfString) {
+    return true;
+  }
+  uint32 dexNameIdx = GetMIRModule().GetFileinfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kINFOFilename));
+  const std::string &dexName = GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(dexNameIdx));
+  if (dexName.find(kCoreAll) != std::string::npos) {
+    return false;
+  }
+  return IsSystemPreloadedClass(clinitClassname);
+}
+
+void ClassInit::GenClassInitCheckProfile(MIRFunction &func, const MIRSymbol &classInfo, StmtNode *clinit) const {
+  GenPreClassInitCheck(func, classInfo, clinit);
+  GenPostClassInitCheck(func, classInfo, clinit);
+}
+
+void ClassInit::GenPreClassInitCheck(MIRFunction &func, const MIRSymbol &classInfo, const StmtNode *clinit) const {
+  MIRFunction *preClinit = builder->GetOrCreateFunction(kMCCPreClinitCheck, TyIdx(PTY_void));
+  BaseNode *classInfoNode = builder->CreateExprAddrof(0, classInfo);
+  MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.push_back(classInfoNode);
+  CallNode *callPreclinit = builder->CreateStmtCall(preClinit->GetPuidx(), args);
+  func.GetBody()->InsertBefore(clinit, callPreclinit);
+}
+
+void ClassInit::GenPostClassInitCheck(MIRFunction &func, const MIRSymbol &classInfo, const StmtNode *clinit) const {
+  MIRFunction *postClinit = builder->GetOrCreateFunction(kMCCPostClinitCheck, static_cast<TyIdx>(PTY_void));
+  BaseNode *classInfoNode = builder->CreateExprAddrof(0, classInfo);
+  MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.push_back(classInfoNode);
+  CallNode *callPostClinit = builder->CreateStmtCall(postClinit->GetPuidx(), args);
+  func.GetBody()->InsertAfter(clinit, callPostClinit);
+}
+
+void ClassInit::ProcessFunc(MIRFunction *func) {
+  // No field will be involved in critical native funcs.
+  ASSERT(func != nullptr, "null ptr check!");
+  if (func->IsEmpty() || func->GetAttr(FUNCATTR_critical_native)) {
+    return;
+  }
+  currFunc = func;
+  builder->SetCurrentFunction(*func);
+  // Insert clinit check for static methods.
+  MIRType *selfClassType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(func->GetClassTyIdx());
+  std::string selfClassName;
+  if (selfClassType != nullptr) {
+    selfClassName = GlobalTables::GetStrTable().GetStringFromStrIdx(selfClassType->GetNameStrIdx());
+  } else {
+    const std::string &funcName = func->GetName();
+    size_t pos = funcName.find(namemangler::kNameSplitterStr);
+    constexpr size_t prePos = 2;
+    constexpr size_t ligalPos = 2;
+    while (pos != std::string::npos &&
+           (pos >= ligalPos && funcName[pos - 1] == '_' && funcName[pos - prePos] != '_')) {
+      constexpr size_t nextPos = 3;
+      pos = funcName.find(namemangler::kNameSplitterStr, pos + nextPos);
+    }
+    selfClassName = funcName.substr(0, pos);
+  }
+  // Insert clinit check for static native methods which are not private.
+  // We have to do this here because native methods are generated as empty by maplefe,
+  // If we simply insert clinit-check (which does not have return value), there will
+  // be no return statement for native methods which do hava a return value.
+  // clinit check for static java (non-native) methods which are not private is
+  // already inserted by maplefe.
+  if (func->IsStatic() && !func->IsPrivate() && !func->IsClinit() && func->IsNative()) {
+    MIRType *classType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(func->GetClassTyIdx());
+    CHECK_FATAL(classType != nullptr, "class type is nullptr");
+    const std::string &className = GlobalTables::GetStrTable().GetStringFromStrIdx(classType->GetNameStrIdx());
+    if (!CanRemoveClinitCheck(className)) {
+      Klass *klass = klassHierarchy->GetKlassFromName(className);
+      CHECK_FATAL(klass != nullptr, "klass is nullptr in ClassInit::ProcessFunc");
+      if (klass->GetClinit() && func != klass->GetClinit()) {
+        MIRSymbol *classInfo = GetClassInfo(className);
+        BaseNode *classInfoNode = builder->CreateExprAddrof(0, *classInfo);
+        if (trace) {
+          LogInfo::MapleLogger() << "\t- low-cost clinit - insert check in static method " << func->GetName()
+                                 << "clasname " << className << "\n";
+        }
+        MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+        args.push_back(classInfoNode);
+        StmtNode *intrinsicCall = builder->CreateStmtIntrinsicCall(INTRN_MPL_CLINIT_CHECK, args);
+        func->GetBody()->InsertFirst(intrinsicCall);
+        ASSERT(classInfo != nullptr, "null ptr check!");
+#ifdef CLINIT_CHECK
+        GenClassInitCheckProfile(*func, *classInfo, intrinsicCall);
+#endif  // CLINIT_CHECK
+      }
+    }
+  }
+  // Lower JAVA_CLINIT_CHECK to MPL_CLINIT_CHECK.
+  StmtNode *stmt = func->GetBody()->GetFirst();
+  while (stmt != nullptr) {
+    if (stmt->GetOpCode() == OP_intrinsiccallwithtype) {
+      auto *intrinsicCall = static_cast<IntrinsiccallNode*>(stmt);
+      if (intrinsicCall->GetIntrinsic() == INTRN_JAVA_CLINIT_CHECK) {
+        // intrinsiccallwithtype <$LTest_3B> JAVA_CLINIT_CHECK ()        -->
+        // intrinsiccall MPL_CLINIT_CHECK (addrof ptr $__cinf_LTest_3B)
+        CHECK_FATAL(intrinsicCall->GetNopndSize() == 0, "wrong arg vectors");
+        CHECK_FATAL(intrinsicCall->GetTyIdx() < GlobalTables::GetTypeTable().GetTypeTable().size(),
+                    "index out of range");
+        MIRType *classType = GlobalTables::GetTypeTable().GetTypeTable()[intrinsicCall->GetTyIdx()];
+        ASSERT(classType != nullptr, "null ptr check!");
+        CHECK_FATAL(classType->GetNameStrIdx() != 0u, "symbol name is null for type index %d",
+                    static_cast<uint32>(intrinsicCall->GetTyIdx()));
+        const std::string &className = GlobalTables::GetStrTable().GetStringFromStrIdx(classType->GetNameStrIdx());
+        Klass *klass = klassHierarchy->GetKlassFromName(className);
+        bool doClinitCheck = false;
+        if (klass == nullptr) {
+          WARN(kLncWarn, "ClassInit::ProcessFunc: Skip INCOMPLETE type %s", className.c_str());
+          doClinitCheck = true;
+        } else {
+          doClinitCheck = !CanRemoveClinitCheck(className) && klassHierarchy->NeedClinitCheckRecursively(*klass);
+        }
+        if (Options::buildApp != 0) {
+          doClinitCheck = true;
+        }
+        if (doClinitCheck) {
+          MIRSymbol *classInfo = GetClassInfo(className);
+          AddrofNode *classInfoNode = builder->CreateExprAddrof(0, *classInfo);
+          MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+          args.push_back(classInfoNode);
+          StmtNode *mplIntrinsicCall = builder->CreateStmtIntrinsicCall(INTRN_MPL_CLINIT_CHECK, args);
+          func->GetBody()->ReplaceStmt1WithStmt2(stmt, mplIntrinsicCall);
+          if (trace) {
+            LogInfo::MapleLogger() << "\t- low-cost clinit - lower JAVA_CLINIT_CHECK " << className << " in "
+                                   << func->GetName() << "()\n";
+          }
+          ASSERT(classInfo != nullptr, "null ptr check!");
+#ifdef CLINIT_CHECK
+          GenClassInitCheckProfile(*func, *classInfo, mplIntrinsicCall);
+#endif  // CLINIT_CHECK
+        } else {
+          func->GetBody()->RemoveStmt(stmt);
+        }
+      }
+    }
+    stmt = stmt->GetNext();
+  }
+}
+
+MIRSymbol *ClassInit::GetClassInfo(const std::string &classname) {
+  const std::string &classInfoName = CLASSINFO_PREFIX_STR + classname;
+  MIRType *classInfoType =
+      GlobalTables::GetTypeTable().GetOrCreateClassType(namemangler::kClassMetadataTypeName, GetMIRModule());
+  MIRSymbol *classInfo = builder->GetOrCreateGlobalDecl(classInfoName, *classInfoType);
+  ASSERT_NOT_NULL(classInfo);
+  Klass *klass = klassHierarchy->GetKlassFromName(classname);
+  if (klass == nullptr || !klass->GetMIRStructType()->IsLocal()) {
+    ASSERT_NOT_NULL(classInfo);
+    classInfo->SetStorageClass(kScExtern);
+  }
+  return classInfo;
+}
+
+bool M2MClassInit::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(ClassInit, m);
+  return true;
+}
+
+void M2MClassInit::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/clone.cpp b/src/mapleall/mpl2mpl/src/clone.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ee912e947ef2b3becfac7a13036d782da47e12b4
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/clone.cpp
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "clone.h"
+#include <iostream>
+#include <algorithm>
+#include "mir_symbol.h"
+
+// For some funcs, when we can ignore their return-values, we clone a new func of
+// them without return-values. We configure a list to save these funcs and clone
+// at the very beginning so that clones can also enjoy the optimizations after.
+// This mainly contains the clone of funcbody(include labels, symbols, arguments,
+// etc.) and the update of the new func infomation.
+namespace maple {
+ReplaceRetIgnored::ReplaceRetIgnored(MemPool *memPool)
+    : memPool(memPool), allocator(memPool), toBeClonedFuncNames(allocator.Adapter()) {
+#define ORIFUNC(ORIGINAL, CLONED) toBeClonedFuncNames.insert(MapleString(#ORIGINAL, memPool));
+#include "tobe_cloned_funcs.def"
+#undef ORIFUNC
+}
+
+bool ReplaceRetIgnored::RealShouldReplaceWithVoidFunc(Opcode op, size_t nRetSize,
+    const MIRFunction &calleeFunc) const {
+  MIRType *returnType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(calleeFunc.GetReturnTyIdx());
+  return nRetSize == 0 && (op == OP_virtualcallassigned || op == OP_callassigned || op == OP_superclasscallassigned) &&
+         !calleeFunc.IsNative() && (returnType->GetKind() == kTypePointer) && (returnType->GetPrimType() == PTY_ref);
+}
+
+bool ReplaceRetIgnored::ShouldReplaceWithVoidFunc(const CallMeStmt &stmt, const MIRFunction &calleeFunc) const {
+  return RealShouldReplaceWithVoidFunc(stmt.GetOp(), stmt.MustDefListSize(), calleeFunc);
+}
+
+std::string ReplaceRetIgnored::GenerateNewBaseName(const MIRFunction &originalFunc) const {
+  return std::string(originalFunc.GetBaseFuncName()).append(kVoidRetSuffix);
+}
+
+std::string ReplaceRetIgnored::GenerateNewFullName(const MIRFunction &originalFunc) const {
+  const std::string &oldSignature = originalFunc.GetSignature();
+  auto retPos = oldSignature.find("_29");
+  constexpr auto retPosIndex = 3;
+  return std::string(originalFunc.GetBaseClassName()).append(namemangler::kNameSplitterStr).
+      append(GenerateNewBaseName(originalFunc)).append(namemangler::kNameSplitterStr).
+      append(oldSignature.substr(0, retPos + retPosIndex)).append("V");
+}
+
+MIRSymbol *Clone::CloneLocalSymbol(const MIRSymbol &oldSym, const MIRFunction &newFunc) {
+  MemPool *newMP = newFunc.GetDataMemPool();
+  MIRSymbol *newSym = newMP->New<MIRSymbol>(oldSym);
+  if (oldSym.GetSKind() == kStConst) {
+    newSym->SetKonst(oldSym.GetKonst()->Clone(*newMP));
+  } else if (oldSym.GetSKind() == kStPreg) {
+    newSym->SetPreg(newMP->New<MIRPreg>(*oldSym.GetPreg()));
+  } else if (oldSym.GetSKind() == kStFunc) {
+    CHECK_FATAL(false, "%s has unexpected local func symbol", oldSym.GetName().c_str());
+  }
+  return newSym;
+}
+
+void Clone::CloneSymbols(MIRFunction &newFunc, const MIRFunction &oldFunc) {
+  size_t symTabSize = oldFunc.GetSymbolTabSize();
+  for (size_t i = oldFunc.GetFormalCount() + 1; i < symTabSize; ++i) {
+    MIRSymbol *sym = oldFunc.GetSymbolTabItem(static_cast<uint32>(i));
+    if (sym == nullptr) {
+      continue;
+    }
+    MIRSymbol *newSym = CloneLocalSymbol(*sym, newFunc);
+    if (!newFunc.GetSymTab()->AddStOutside(newSym)) {
+      CHECK_FATAL(false, "%s already existed in func %s", sym->GetName().c_str(), newFunc.GetName().c_str());
+    }
+  }
+}
+
+void Clone::CloneLabels(MIRFunction &newFunc, const MIRFunction &oldFunc) {
+  size_t labelTabSize = oldFunc.GetLabelTab()->GetLabelTableSize();
+  for (size_t i = 1; i < labelTabSize; ++i) {
+    const std::string &labelName = oldFunc.GetLabelTabItem(static_cast<uint32>(i));
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(labelName);
+    (void)newFunc.GetLabelTab()->AddLabel(strIdx);
+  }
+}
+
+// Clone a function
+MIRFunction *Clone::CloneFunction(MIRFunction &originalFunction, const std::string &newBaseFuncName,
+    MIRType *returnType) const {
+  MapleAllocator cgAlloc(originalFunction.GetCodeMempool());
+  ArgVector argument(cgAlloc.Adapter());
+  CloneArgument(originalFunction, argument);
+  MIRType *retType = returnType;
+  if (retType == nullptr) {
+    retType = originalFunction.GetReturnType();
+  }
+  std::string fullName = originalFunction.GetBaseClassName();
+  const std::string &signature = originalFunction.GetSignature();
+  fullName = fullName.append(
+      namemangler::kNameSplitterStr).append(newBaseFuncName).append(namemangler::kNameSplitterStr).append(signature);
+  MIRFunction *newFunc =
+      mirBuilder.CreateFunction(fullName, *retType, argument, false, originalFunction.GetBody() != nullptr);
+  CHECK_FATAL(newFunc != nullptr, "create cloned function failed");
+  mirBuilder.GetMirModule().AddFunction(newFunc);
+  Klass *klass = kh->GetKlassFromName(originalFunction.GetBaseClassName());
+  CHECK_FATAL(klass != nullptr, "getklass failed");
+  klass->AddMethod(*newFunc);
+  newFunc->SetClassTyIdx(originalFunction.GetClassTyIdx());
+  MIRClassType *classType = klass->GetMIRClassType();
+  classType->GetMethods().push_back(
+      MethodPair(newFunc->GetStIdx(), TyidxFuncAttrPair(newFunc->GetFuncSymbol()->GetTyIdx(),
+          originalFunction.GetFuncAttrs())));
+  newFunc->SetFlag(originalFunction.GetFlag());
+  newFunc->SetSrcPosition(originalFunction.GetSrcPosition());
+  newFunc->SetFuncAttrs(originalFunction.GetFuncAttrs());
+  newFunc->SetBaseClassFuncNames(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName));
+  if (originalFunction.GetBody() != nullptr) {
+    CopyFuncInfo(originalFunction, *newFunc);
+    MIRFunction *originalCurrFunction = mirBuilder.GetCurrentFunctionNotNull();
+    mirBuilder.SetCurrentFunction(*newFunc);
+    newFunc->SetBody(
+        originalFunction.GetBody()->CloneTree(originalFunction.GetModule()->GetCurFuncCodeMPAllocator()));
+    CloneSymbols(*newFunc, originalFunction);
+    CloneLabels(*newFunc, originalFunction);
+    mirBuilder.SetCurrentFunction(*originalCurrFunction);
+  }
+  return newFunc;
+}
+
+void Clone::CloneArgument(MIRFunction &originalFunction, ArgVector &argument) const {
+  for (size_t i = 0; i < originalFunction.GetFormalCount(); ++i) {
+    auto &formalName = originalFunction.GetFormalName(i);
+    argument.push_back(ArgPair(formalName, originalFunction.GetNthParamType(i)));
+  }
+}
+
+void Clone::CopyFuncInfo(MIRFunction &originalFunction, MIRFunction &newFunc) const {
+  auto funcNameIdx = newFunc.GetBaseFuncNameStrIdx();
+  auto fullNameIdx = newFunc.GetNameStrIdx();
+  auto classNameIdx = newFunc.GetBaseClassNameStrIdx();
+  auto metaFullNameIdx = mirBuilder.GetOrCreateStringIndex(kFullNameStr);
+  auto metaClassNameIdx = mirBuilder.GetOrCreateStringIndex(kClassNameStr);
+  auto metaFuncNameIdx = mirBuilder.GetOrCreateStringIndex(kFuncNameStr);
+  MIRInfoVector &fnInfo = originalFunction.GetInfoVector();
+  const MapleVector<bool> &infoIsString = originalFunction.InfoIsString();
+  size_t size = fnInfo.size();
+  for (size_t i = 0; i < size; ++i) {
+    if (fnInfo[i].first == metaFullNameIdx) {
+      newFunc.PushbackMIRInfo(std::pair<GStrIdx, uint32>(fnInfo[i].first, fullNameIdx));
+    } else if (fnInfo[i].first == metaFuncNameIdx) {
+      newFunc.PushbackMIRInfo(std::pair<GStrIdx, uint32>(fnInfo[i].first, funcNameIdx));
+    } else if (fnInfo[i].first == metaClassNameIdx) {
+      newFunc.PushbackMIRInfo(std::pair<GStrIdx, uint32>(fnInfo[i].first, classNameIdx));
+    } else {
+      newFunc.PushbackMIRInfo(std::pair<GStrIdx, uint32>(fnInfo[i].first, fnInfo[i].second));
+    }
+    newFunc.PushbackIsString(infoIsString[i]);
+  }
+}
+
+void Clone::UpdateFuncInfo(MIRFunction &newFunc) {
+  auto fullNameIdx = newFunc.GetNameStrIdx();
+  auto metaFullNameIdx = mirBuilder.GetOrCreateStringIndex(kFullNameStr);
+  size_t size = newFunc.GetInfoVector().size();
+  for (size_t i = 0; i < size; ++i) {
+    if (newFunc.GetInfoPair(i).first == metaFullNameIdx) {
+      newFunc.SetMIRInfoNum(i, fullNameIdx);
+      break;
+    }
+  }
+}
+
+// Clone all functions that would be invoked with their return value ignored
+// @param original_function The original function to be cloned
+// @param mirBuilder A helper object
+// @return Pointer to the newly cloned function
+MIRFunction *Clone::CloneFunctionNoReturn(MIRFunction &originalFunction) {
+  const std::string kNewMethodBaseName = replaceRetIgnored->GenerateNewBaseName(originalFunction);
+  MIRFunction *originalCurrFunction = mirBuilder.GetMirModule().CurFunction();
+  MIRFunction *newFunction =
+      CloneFunction(originalFunction, kNewMethodBaseName, GlobalTables::GetTypeTable().GetTypeFromTyIdx(1));
+
+  // new stmt should be located in the newFunction->codemp, mirBuilder.CreateStmtReturn will use CurFunction().codemp
+  // to assign space for the new stmt. So we set it correctly here.
+  mirBuilder.GetMirModule().SetCurFunction(newFunction);
+  if (originalFunction.GetBody() != nullptr) {
+    auto *body = newFunction->GetBody();
+    for (auto &stmt : body->GetStmtNodes()) {
+      if (stmt.GetOpCode() == OP_return) {
+        body->ReplaceStmt1WithStmt2(&stmt, mirBuilder.CreateStmtReturn(nullptr));
+      }
+    }
+  }
+  // setup new names for the newly cloned function
+  std::string newFuncFullName = replaceRetIgnored->GenerateNewFullName(originalFunction);
+  GStrIdx fullNameStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(newFuncFullName);
+  newFunction->OverrideBaseClassFuncNames(fullNameStrIdx);
+  MIRSymbol *funcSt = newFunction->GetFuncSymbol();
+  ASSERT_NOT_NULL(funcSt);
+  GlobalTables::GetGsymTable().RemoveFromStringSymbolMap(*funcSt);
+  funcSt->SetNameStrIdx(fullNameStrIdx);
+  GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcSt);
+  UpdateFuncInfo(*newFunction);
+  mirBuilder.GetMirModule().SetCurFunction(originalCurrFunction);
+  return newFunction;
+}
+
+void Clone::UpdateReturnVoidIfPossible(CallMeStmt *callMeStmt, const MIRFunction &targetFunc) {
+  if (callMeStmt == nullptr) {
+    return;
+  }
+  if (replaceRetIgnored->ShouldReplaceWithVoidFunc(*callMeStmt, targetFunc) &&
+      replaceRetIgnored->IsInCloneList(targetFunc.GetName())) {
+    std::string funcNameReturnVoid = replaceRetIgnored->GenerateNewFullName(targetFunc);
+    GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(funcNameReturnVoid);
+    MIRFunction *funcReturnVoid = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(gStrIdx)->GetFunction();
+    CHECK_FATAL(funcReturnVoid != nullptr, "target function not found at ssadevirtual");
+    callMeStmt->SetPUIdx(funcReturnVoid->GetPuidx());
+  }
+}
+
+void Clone::DoClone() {
+  std::set<std::string> clonedNewFuncMap;
+  for (const MapleString &funcName : *(replaceRetIgnored->GetTobeClonedFuncNames())) {
+    GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(std::string(funcName.c_str()));
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(gStrIdx);
+    if (symbol != nullptr) {
+      GStrIdx gStrIdxOfFunc = GlobalTables::GetStrTable().GetStrIdxFromName(std::string(funcName.c_str()));
+      MIRFunction *oriFunc = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(gStrIdxOfFunc)->GetFunction();
+      mirModule->SetCurFunction(oriFunc);
+      (void)clonedNewFuncMap.insert(CloneFunctionNoReturn(*oriFunc)->GetName());
+    }
+  }
+}
+
+void M2MClone::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+}
+
+bool M2MClone::PhaseRun(maple::MIRModule &m) {
+  maple::MIRBuilder dexMirBuilder(&m);
+  KlassHierarchy *kh = GET_ANALYSIS(M2MKlassHierarchy, m);
+  cl = GetPhaseAllocator()->New<Clone>(&m, GetPhaseMemPool(), dexMirBuilder, kh);
+  cl->DoClone();
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/coderelayout.cpp b/src/mapleall/mpl2mpl/src/coderelayout.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cdd13d6d539ce166cbb21eef9ee8f54672f49ed6
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/coderelayout.cpp
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "coderelayout.h"
+#include "profile.h"
+
+// This phase layout the function according the profile.
+// First parse the profile,find the corresponding dex file's
+// function type info,the profile file give three function type
+//  1.boot-only-hot  function which is only hot in phone boot phase
+//  2.both-hot       function which is hot in phone run phase and phone boot phase
+//  3.run-hot        function which is only hot in phone run phase
+// Every functon have just one layout type,layout the function
+// together according there layout type.Currently the layout is below
+//
+// [BootHot]
+// [BothHot]
+// [RunHot]
+// [StartupOnly]
+// [UsedOnce]
+// [Executed] function excuted in some condition
+// [Unused]
+namespace maple {
+CodeReLayout::CodeReLayout(MIRModule &mod, KlassHierarchy *kh, bool dump) : FuncOptimizeImpl(mod, kh, dump) {
+  if (!Options::proFileData.empty()) {
+    size_t pos = 0;
+    if ((pos = Options::proFileData.find(':')) != std::string::npos) {
+      Options::proFileFuncData = Options::proFileData.substr(0, pos);
+      Options::proFileClassData = Options::proFileData.substr(pos + 1);
+    }
+    Options::proFileFuncData = Options::proFileData;
+    LogInfo::MapleLogger() << "func profile " << Options::proFileFuncData << " class profile "
+                           << Options::proFileClassData << "\n";
+  }
+  if (Options::profileStaticFields) {
+    std::string staticFieldsFile = StaticFieldFilename(GetMIRModule().GetFileName());
+    LogInfo::MapleLogger() << staticFieldsFile << "\n";
+    std::ofstream staticFields;
+    staticFields.open(staticFieldsFile, std::ofstream::trunc);
+    if (!staticFields.is_open()) {
+      ERR(kLncErr, " %s open failed!", staticFieldsFile.c_str());
+    }
+  }
+}
+
+CallNode *CodeReLayout::CreateRecordFieldStaticCall(BaseNode *node, const std::string &name) {
+  MIRFunction *callee = builder->GetOrCreateFunction("MCC_RecordStaticField", static_cast<TyIdx>(PTY_void));
+  BaseNode *nameAddr = builder->CreateExprAddrof(0, *GetorCreateStaticFieldSym(name));
+  MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.push_back(node);
+  args.push_back(nameAddr);
+  return builder->CreateStmtCall(callee->GetPuidx(), args);
+}
+
+std::string CodeReLayout::StaticFieldFilename(const std::string &mplFile) const {
+  size_t pos = mplFile.rfind(".mpl");
+  size_t postfixSize = 4;
+  CHECK_FATAL(pos != std::string::npos, "Not found .mpl postfix");
+  CHECK_FATAL(pos == mplFile.length() - postfixSize, "Not compiling .mpl file?");
+  std::string smryFileName = mplFile.substr(0, pos) + ".staticfields";
+  return smryFileName;
+}
+
+void CodeReLayout::AddStaticFieldRecord() {
+  StmtNode *stmt = currFunc->GetBody()->GetFirst();
+  StmtNode *next = nullptr;
+  while (stmt != nullptr) {
+    next = stmt->GetNext();
+    FindDreadRecur(stmt, stmt);
+    if (stmt->GetOpCode() == OP_dassign) {
+      MIRSymbol *mirSym = currFunc->GetLocalOrGlobalSymbol(static_cast<DassignNode*>(stmt)->GetStIdx());
+      ASSERT_NOT_NULL(mirSym);
+      if (mirSym->IsStatic()) {
+        BaseNode *node = builder->CreateExprAddrof((static_cast<DassignNode*>(stmt))->GetFieldID(),
+                                                   (static_cast<DassignNode*>(stmt))->GetStIdx());
+        CallNode *call = CreateRecordFieldStaticCall(node, mirSym->GetName());
+        currFunc->GetBody()->InsertBefore(stmt, call);
+      }
+    }
+    stmt = next;
+  }
+}
+
+void CodeReLayout::FindDreadRecur(const StmtNode *stmt, BaseNode *node) {
+  if (node == nullptr) {
+    return;
+  }
+  BinaryOpnds *bOpnds = nullptr;
+  switch (node->GetOpCode()) {
+    case OP_dread:
+    case OP_addrof: {
+      return InsertProfileBeforeDread(stmt, node);
+    }
+    case OP_array:
+    case OP_intrinsicop:
+    case OP_intrinsicopwithtype:
+    case OP_call:
+    case OP_callassigned:
+    case OP_icall:
+    case OP_icallassigned:
+    case OP_intrinsiccall:
+    case OP_intrinsiccallwithtype:
+    case OP_return:
+    case OP_switch:
+    case OP_dassign:
+    case OP_iassign: {
+      for (size_t i = 0; i < node->NumOpnds(); i++) {
+        FindDreadRecur(stmt, node->Opnd(i));
+      }
+      break;
+    }
+    default: {
+      if (node->IsUnaryNode()) {
+        UnaryNode *uNode = static_cast<UnaryNode*>(node);
+        FindDreadRecur(stmt, uNode->Opnd(0));
+      } else if (node->IsBinaryNode()) {
+        BinaryNode *bNode = static_cast<BinaryNode*>(node);
+        bOpnds = static_cast<BinaryOpnds*>(bNode);
+        FindDreadRecur(stmt, bOpnds->GetBOpnd(0));
+        FindDreadRecur(stmt, bOpnds->GetBOpnd(1));
+      }
+      break;
+    }
+  }
+}
+
+void CodeReLayout::InsertProfileBeforeDread(const StmtNode *stmt, BaseNode *opnd) {
+  if (opnd == nullptr || (opnd->GetOpCode() != OP_dread && opnd->GetOpCode() != OP_addrof)) {
+    return;
+  }
+  DreadNode *dreadNode = static_cast<DreadNode*>(opnd);
+  MIRSymbol *mirSym = currFunc->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+  ASSERT_NOT_NULL(mirSym);
+  if (mirSym->IsStatic()) {
+    BaseNode *node = opnd;
+    if (opnd->GetOpCode() == OP_dread) {
+      node = builder->CreateExprAddrof(dreadNode->GetFieldID(), dreadNode->GetStIdx());
+    }
+    CallNode *call = CreateRecordFieldStaticCall(node, mirSym->GetName());
+    currFunc->GetBody()->InsertBefore(stmt, call);
+  }
+}
+
+void CodeReLayout::ProcessFunc(MIRFunction *func) {
+  if (func->IsEmpty()) {
+    return;
+  }
+  SetCurrentFunction(*func);
+  if (Options::profileStaticFields) {
+    AddStaticFieldRecord();
+  }
+  if (func->IsClinit()) {
+    func->SetLayoutType(kLayoutUsedOnce);
+  }
+}
+
+void CodeReLayout::Finish() {
+  const auto &proFileData = GetMIRModule().GetProfile().GetFunctionProf();
+  for (auto &item : proFileData) {
+    std::string funcName = item.first;
+    MIRFunction *sortFunction = builder->GetFunctionFromName(funcName);
+    if (sortFunction != nullptr && sortFunction->GetBody()) {
+      sortFunction->SetCallTimes((item.second).callTimes);
+      sortFunction->SetLayoutType((item.second).type);
+    }
+  }
+  for (auto &function : std::as_const(GetMIRModule().GetFunctionList())) {
+    ++layoutCount[static_cast<size_t>(function->GetLayoutType())];
+  }
+  if (Options::genPGOReport || trace) {
+    GetMIRModule().GetProfile().DumpFuncIRProfUseInfo();
+    for (uint32 i = 0; i < static_cast<uint32>(LayoutType::kLayoutTypeCount); ++i) {
+      LogInfo::MapleLogger() << "function in category\t" << GetLayoutTypeString(i)
+                             << "\tcount=" << layoutCount[i] << "\n";
+    }
+  }
+  std::vector<MIRFunction*> temp(GetMIRModule().GetFunctionList().cbegin(),
+                                 GetMIRModule().GetFunctionList().cend());
+  std::stable_sort(temp.begin(), temp.end(), [](const MIRFunction *a, const MIRFunction *b) {
+    ASSERT_NOT_NULL(a);
+    ASSERT_NOT_NULL(b);
+    return a->GetLayoutType() < b->GetLayoutType();
+  });
+  uint32 last = 0;
+  for (uint32 i = 0; i <= static_cast<uint32>(LayoutType::kLayoutRunHot); i++) {
+    if (trace) {
+      LogInfo::MapleLogger() << "last\t" << last << "\tcount\t" << layoutCount[i] << "\n";
+    }
+    std::stable_sort(temp.begin() + last, temp.begin() + last + layoutCount[i],
+                     [](const MIRFunction *a, const MIRFunction *b) {
+      ASSERT_NOT_NULL(a);
+      ASSERT_NOT_NULL(b);
+      return a->GetCallTimes() < b->GetCallTimes();
+    });
+    last += layoutCount[i];
+  }
+  std::copy(temp.begin(), temp.end(), GetMIRModule().GetFunctionList().begin());
+  // Create layoutInfo
+  GenLayoutSym();
+}
+
+MIRSymbol *CodeReLayout::GenStrSym(const std::string &str) {
+  std::string newStr = str + '\0';
+  MIRArrayType &strTabType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(
+      *GlobalTables::GetTypeTable().GetUInt8(), static_cast<uint32>(newStr.length()));
+  std::string strTabName = namemangler::kStaticFieldNamePrefixStr + str;
+  MIRSymbol *staticSym = builder->CreateGlobalDecl(strTabName, strTabType);
+  MIRAggConst *strTabAggConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), strTabType);
+  staticSym->SetStorageClass(kScFstatic);
+  for (const char &c : newStr) {
+    MIRConst *newConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        c, *GlobalTables::GetTypeTable().GetUInt8());
+    strTabAggConst->AddItem(newConst, 0);
+  }
+  staticSym->SetKonst(strTabAggConst);
+  return staticSym;
+}
+
+MIRSymbol *CodeReLayout::GetorCreateStaticFieldSym(const std::string &fieldName) {
+  auto it = str2SymMap.find(fieldName);
+  if (it != str2SymMap.end()) {
+    return it->second;
+  } else {
+    MIRSymbol *sym = GenStrSym(fieldName);
+    (void)str2SymMap.insert(std::make_pair(fieldName, sym));
+    return sym;
+  }
+}
+
+void CodeReLayout::GenLayoutSym() {
+  MIRArrayType &arrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetVoidPtr(), 1);
+  MIRAggConst *funcLayoutConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), arrayType);
+  uint32 funcIdx = 0;
+  auto funcIter = GetMIRModule().GetFunctionList().cbegin();
+  MIRConst *fieldConst = nullptr;
+  MIRFunction *method = nullptr;
+  for (uint32 i = 0; i < static_cast<uint32>(LayoutType::kLayoutTypeCount); ++i) {
+    if (funcIdx < GetMIRModule().GetFunctionList().size()) {
+      if (i > 0) {
+        std::advance(funcIter, layoutCount[i - 1]);
+      }
+      method = *funcIter;
+    } else {
+      std::cerr << "no method for codelayout type " << GetLayoutTypeString(i) << "\n";
+      return;
+    }
+    while (method->IsAbstract() || method->GetBody() == nullptr) {
+      // find the function not Abstract
+      if (trace) {
+        LogInfo::MapleLogger() << "encounter valid method " << funcIdx << "\n";
+      }
+      ++funcIdx;
+      if (funcIdx < GetMIRModule().GetFunctionList().size()) {
+        ++funcIter;
+        method = *funcIter;
+      } else {
+        std::cerr << "no method for codelayout" << GetLayoutTypeString(i) << "\n";
+        return;
+      }
+    }
+    if (trace) {
+      LogInfo::MapleLogger() << "Start of category " << i << " in funcIdx " << funcIdx << " "
+                             << method->GetName() << "\n";
+    }
+    AddroffuncNode *addroffuncExpr = builder->CreateExprAddroffunc(method->GetPuidx(), GetMIRModule().GetMemPool());
+    fieldConst =
+        GetMIRModule().GetMemPool()->New<MIRAddroffuncConst>(addroffuncExpr->GetPUIdx(),
+                                                             *GlobalTables::GetTypeTable().GetVoidPtr());
+    funcLayoutConst->AddItem(fieldConst, 0);
+    funcIdx += layoutCount[i];
+  }
+  std::string funcLayoutSymName = namemangler::kFunctionLayoutStr + GetMIRModule().GetFileNameAsPostfix();
+  MIRSymbol *funcLayoutSym = builder->CreateGlobalDecl(funcLayoutSymName, arrayType);
+  funcLayoutSym->SetKonst(funcLayoutConst);
+  funcLayoutSym->SetStorageClass(kScFstatic);
+}
+
+void M2MCodeReLayout::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+
+bool M2MCodeReLayout::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(CodeReLayout, m);
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/constantfold.cpp b/src/mapleall/mpl2mpl/src/constantfold.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..783aaf82c8ce57d8b3f742ab2a35e1768d89178d
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/constantfold.cpp
@@ -0,0 +1,2838 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "constantfold.h"
+#include <cmath>
+#include <cfloat>
+#include <climits>
+#include <type_traits>
+#include "mpl_logging.h"
+#include "mir_function.h"
+#include "mir_builder.h"
+#include "global_tables.h"
+#include "me_option.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+
+namespace {
+
+constexpr uint64 kJsTypeNumber = 4;
+constexpr uint64 kJsTypeNumberInHigh32Bit = kJsTypeNumber << 32; // set high 32 bit as JSTYPE_NUMBER
+constexpr uint32 kByteSizeOfBit64 = 8; // byte number for 64 bit
+constexpr uint32 kBitSizePerByte = 8;
+constexpr maple::int32 kMaxOffset = INT_MAX - 8;
+
+enum CompareRes : int64 {
+  kLess = -1,
+  kEqual = 0,
+  kGreater = 1
+};
+
+std::optional<IntVal> operator*(const std::optional<IntVal> &v1, const std::optional<IntVal> &v2) {
+  if (!v1 && !v2) {
+    return std::nullopt;
+  }
+
+  // Perform all calculations in terms of the maximum available signed type.
+  // The value will be truncated for an appropriate type when constant is created in PairToExpr function
+  return v1 && v2 ? v1->Mul(*v2, PTY_i64) : IntVal(0, PTY_i64);
+}
+
+// Perform all calculations in terms of the maximum available signed type.
+// The value will be truncated for an appropriate type when constant is created in PairToExpr function
+std::optional<IntVal> AddSub(const std::optional<IntVal> &v1, const std::optional<IntVal> &v2, bool isAdd) {
+  if (!v1 && !v2) {
+    return std::nullopt;
+  }
+
+  if (v1 && v2) {
+    return isAdd ? v1->Add(*v2, PTY_i64) : v1->Sub(*v2, PTY_i64);
+  }
+
+  if (v1) {
+    return v1->TruncOrExtend(PTY_i64);
+  }
+
+  // !v1 && v2
+  return isAdd ? v2->TruncOrExtend(PTY_i64) : -(v2->TruncOrExtend(PTY_i64));
+}
+
+std::optional<IntVal> operator+(const std::optional<IntVal> &v1, const std::optional<IntVal> &v2) {
+  return AddSub(v1, v2, true);
+}
+
+std::optional<IntVal> operator-(const std::optional<IntVal> &v1, const std::optional<IntVal> &v2) {
+  return AddSub(v1, v2, false);
+}
+
+} // anonymous namespace
+
+// This phase is designed to achieve compiler optimization by
+// simplifying constant expressions. The constant expression
+// is evaluated and replaced by the value calculated on compile
+// time to save time on runtime.
+// The main procedure shows as following:
+// A. Analyze expression type
+// B. Analysis operator type
+// C. Replace the expression with the result of the operation
+
+// true if the constant's bits are made of only one group of contiguous 1's
+// starting at bit 0
+static bool ContiguousBitsOf1(uint64 x) {
+  if (x == 0) {
+    return false;
+  }
+  return (~x & (x + 1)) == (x + 1);
+}
+
+inline bool IsPowerOf2(uint64 num) {
+  if (num == 0) {
+    return false;
+  }
+  return (~(num - 1) & num) == num;
+}
+
+BinaryNode *ConstantFold::NewBinaryNode(BinaryNode *old, Opcode op, PrimType primType,
+                                        BaseNode *lhs, BaseNode *rhs) const {
+  CHECK_NULL_FATAL(old);
+  BinaryNode *result = nullptr;
+  if (old->GetOpCode() == op && old->GetPrimType() == primType && old->Opnd(0) == lhs && old->Opnd(1) == rhs) {
+    result = old;
+  } else {
+    result = mirModule->CurFuncCodeMemPool()->New<BinaryNode>(op, primType, lhs, rhs);
+  }
+  return result;
+}
+
+UnaryNode *ConstantFold::NewUnaryNode(UnaryNode *old, Opcode op, PrimType primType, BaseNode *expr) const {
+  CHECK_NULL_FATAL(old);
+  UnaryNode *result = nullptr;
+  if (old->GetOpCode() == op && old->GetPrimType() == primType && old->Opnd(0) == expr) {
+    result = old;
+  } else {
+    result = mirModule->CurFuncCodeMemPool()->New<UnaryNode>(op, primType, expr);
+  }
+  return result;
+}
+
+BaseNode *ConstantFold::PairToExpr(PrimType resultType, const std::pair<BaseNode*, std::optional<IntVal>> &pair) const {
+  CHECK_NULL_FATAL(pair.first);
+  BaseNode *result = pair.first;
+  if (!pair.second || *pair.second == 0) {
+    return result;
+  }
+  if (pair.first->GetOpCode() == OP_neg && !pair.second->GetSignBit()) {
+    // -a, 5 -> 5 - a
+    ConstvalNode *val = mirModule->GetMIRBuilder()->CreateIntConst(pair.second->GetExtValue(), resultType);
+    BaseNode *r = static_cast<UnaryNode*>(pair.first)->Opnd(0);
+    result = mirModule->CurFuncCodeMemPool()->New<BinaryNode>(OP_sub, resultType, val, r);
+  } else {
+    if ((!pair.second->GetSignBit() && pair.second->GetSXTValue(GetPrimTypeBitSize(resultType)) > 0) ||
+        pair.second->GetSXTValue() == INT64_MIN) {
+      // +-a, 5 -> a + 5
+      ConstvalNode *val = mirModule->GetMIRBuilder()->CreateIntConst(pair.second->GetExtValue(), resultType);
+      result = mirModule->CurFuncCodeMemPool()->New<BinaryNode>(OP_add, resultType, pair.first, val);
+    } else {
+      // +-a, -5 -> a + -5
+      ConstvalNode *val = mirModule->GetMIRBuilder()->CreateIntConst((-pair.second.value()).GetExtValue(), resultType);
+      result = mirModule->CurFuncCodeMemPool()->New<BinaryNode>(OP_sub, resultType, pair.first, val);
+    }
+  }
+  return result;
+}
+
+std::pair<BaseNode *, std::optional<IntVal>> ConstantFold::FoldBase(BaseNode *node) const {
+  return std::make_pair(node, std::nullopt);
+}
+
+StmtNode *ConstantFold::Simplify(StmtNode *node) {
+  CHECK_NULL_FATAL(node);
+  switch (node->GetOpCode()) {
+    case OP_dassign:
+    case OP_maydassign:
+      return SimplifyDassign(static_cast<DassignNode*>(node));
+    case OP_iassign:
+      return SimplifyIassign(static_cast<IassignNode*>(node));
+    case OP_block:
+      return SimplifyBlock(static_cast<BlockNode*>(node));
+    case OP_if:
+      return SimplifyIf(static_cast<IfStmtNode*>(node));
+    case OP_dowhile:
+    case OP_while:
+      return SimplifyWhile(static_cast<WhileStmtNode*>(node));
+    case OP_switch:
+      return SimplifySwitch(static_cast<SwitchNode*>(node));
+    case OP_eval:
+    case OP_throw:
+    case OP_free:
+    case OP_decref:
+    case OP_incref:
+    case OP_decrefreset:
+    case OP_regassign:
+    CASE_OP_ASSERT_NONNULL
+    case OP_igoto:
+      return SimplifyUnary(static_cast<UnaryStmtNode*>(node));
+    case OP_brfalse:
+    case OP_brtrue:
+      return SimplifyCondGoto(static_cast<CondGotoNode*>(node));
+    case OP_return:
+    case OP_syncenter:
+    case OP_syncexit:
+    case OP_call:
+    case OP_virtualcall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_intrinsiccall:
+    case OP_xintrinsiccall:
+    case OP_intrinsiccallwithtype:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_intrinsiccallassigned:
+    case OP_intrinsiccallwithtypeassigned:
+    case OP_xintrinsiccallassigned:
+    case OP_callinstant:
+    case OP_callinstantassigned:
+    case OP_virtualcallinstant:
+    case OP_virtualcallinstantassigned:
+    case OP_superclasscallinstant:
+    case OP_superclasscallinstantassigned:
+    case OP_interfacecallinstant:
+    case OP_interfacecallinstantassigned:
+    CASE_OP_ASSERT_BOUNDARY
+      return SimplifyNary(static_cast<NaryStmtNode*>(node));
+    case OP_icall:
+    case OP_icallassigned:
+    case OP_icallproto:
+    case OP_icallprotoassigned:
+      return SimplifyIcall(static_cast<IcallNode*>(node));
+    case OP_asm:
+      return SimplifyAsm(static_cast<AsmNode*>(node));
+    default:
+      return node;
+  }
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::DispatchFold(BaseNode *node) {
+  CHECK_NULL_FATAL(node);
+  switch (node->GetOpCode()) {
+    case OP_sizeoftype:
+      return FoldSizeoftype(static_cast<SizeoftypeNode*>(node));
+    case OP_abs:
+    case OP_bnot:
+    case OP_lnot:
+    case OP_neg:
+    case OP_recip:
+    case OP_sqrt:
+      return FoldUnary(static_cast<UnaryNode*>(node));
+    case OP_ceil:
+    case OP_floor:
+    case OP_round:
+    case OP_trunc:
+    case OP_cvt:
+      return FoldTypeCvt(static_cast<TypeCvtNode*>(node));
+    case OP_sext:
+    case OP_zext:
+    case OP_extractbits:
+      return FoldExtractbits(static_cast<ExtractbitsNode*>(node));
+    case OP_iaddrof:
+    case OP_iread:
+      return FoldIread(static_cast<IreadNode*>(node));
+    case OP_add:
+    case OP_ashr:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_cand:
+    case OP_cior:
+    case OP_div:
+    case OP_land:
+    case OP_lior:
+    case OP_lshr:
+    case OP_max:
+    case OP_min:
+    case OP_mul:
+    case OP_rem:
+    case OP_shl:
+    case OP_sub:
+      return FoldBinary(static_cast<BinaryNode*>(node));
+    case OP_eq:
+    case OP_ne:
+    case OP_ge:
+    case OP_gt:
+    case OP_le:
+    case OP_lt:
+    case OP_cmp:
+      return FoldCompare(static_cast<CompareNode*>(node));
+    case OP_depositbits:
+      return FoldDepositbits(static_cast<DepositbitsNode*>(node));
+    case OP_select:
+      return FoldTernary(static_cast<TernaryNode*>(node));
+    case OP_array:
+      return FoldArray(static_cast<ArrayNode*>(node));
+    case OP_retype:
+      return FoldRetype(static_cast<RetypeNode*>(node));
+    case OP_gcmallocjarray:
+    case OP_gcpermallocjarray:
+      return FoldGcmallocjarray(static_cast<JarrayMallocNode*>(node));
+    default:
+      return FoldBase(static_cast<BaseNode*>(node));
+  }
+}
+
+BaseNode *ConstantFold::Negate(BaseNode *node) const {
+  CHECK_NULL_FATAL(node);
+  return mirModule->CurFuncCodeMemPool()->New<UnaryNode>(OP_neg, PrimType(node->GetPrimType()), node);
+}
+
+BaseNode *ConstantFold::Negate(UnaryNode *node) const {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  if (node->GetOpCode() == OP_neg) {
+    result = static_cast<BaseNode*>(node->Opnd(0));
+  } else {
+    BaseNode *n = static_cast<BaseNode*>(node);
+    result = NewUnaryNode(node, OP_neg, node->GetPrimType(), n);
+  }
+  return result;
+}
+
+BaseNode *ConstantFold::Negate(const ConstvalNode *node) const {
+  CHECK_NULL_FATAL(node);
+  ConstvalNode *copy = node->CloneTree(mirModule->GetCurFuncCodeMPAllocator());
+  CHECK_NULL_FATAL(copy);
+  copy->GetConstVal()->Neg();
+  return copy;
+}
+
+BaseNode *ConstantFold::NegateTree(BaseNode *node) const {
+  CHECK_NULL_FATAL(node);
+  if (node->IsUnaryNode()) {
+    return Negate(static_cast<UnaryNode*>(node));
+  } else if (node->GetOpCode() == OP_constval) {
+    return Negate(static_cast<ConstvalNode*>(node));
+  } else {
+    return Negate(static_cast<BaseNode*>(node));
+  }
+}
+
+MIRIntConst *ConstantFold::FoldIntConstComparisonMIRConst(Opcode opcode, PrimType resultType, PrimType opndType,
+                                                          const MIRIntConst &intConst0,
+                                                          const MIRIntConst &intConst1) const {
+  uint64 result = 0;
+
+  bool greater = intConst0.GetValue().Greater(intConst1.GetValue(), opndType);
+  bool equal = intConst0.GetValue().Equal(intConst1.GetValue(), opndType);
+  bool less = intConst0.GetValue().Less(intConst1.GetValue(), opndType);
+
+  switch (opcode) {
+    case OP_eq: {
+      result = equal;
+      break;
+    }
+    case OP_ge: {
+      result = greater || equal;
+      break;
+    }
+    case OP_gt: {
+      result = greater;
+      break;
+    }
+    case OP_le: {
+      result = less || equal;
+      break;
+    }
+    case OP_lt: {
+      result = less;
+      break;
+    }
+    case OP_ne: {
+      result = !equal;
+      break;
+    }
+    case OP_cmp: {
+      if (greater) {
+        result = kGreater;
+      } else if (equal) {
+        result = kEqual;
+      } else if (less) {
+        result = kLess;
+      }
+      break;
+    }
+    default:
+      ASSERT(false, "Unknown opcode for FoldIntConstComparison");
+      break;
+  }
+  // determine the type
+  MIRType &type = *GlobalTables::GetTypeTable().GetPrimType(resultType);
+  // form the constant
+  MIRIntConst *constValue = nullptr;
+  if (type.GetPrimType() == PTY_dyni32) {
+    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, type);
+    constValue->SetValue(static_cast<int64>(kJsTypeNumberInHigh32Bit | result));
+  } else {
+    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(result, type);
+  }
+  return constValue;
+}
+
+ConstvalNode *ConstantFold::FoldIntConstComparison(Opcode opcode, PrimType resultType, PrimType opndType,
+                                                   const ConstvalNode &const0, const ConstvalNode &const1) const {
+  const MIRIntConst *intConst0 = safe_cast<MIRIntConst>(const0.GetConstVal());
+  const MIRIntConst *intConst1 = safe_cast<MIRIntConst>(const1.GetConstVal());
+  CHECK_NULL_FATAL(intConst0);
+  CHECK_NULL_FATAL(intConst1);
+  MIRIntConst *constValue = FoldIntConstComparisonMIRConst(opcode, resultType, opndType, *intConst0, *intConst1);
+  // form the ConstvalNode
+  ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  resultConst->SetPrimType(resultType);
+  resultConst->SetConstVal(constValue);
+  return resultConst;
+}
+
+MIRConst *ConstantFold::FoldIntConstBinaryMIRConst(Opcode opcode, PrimType resultType, const MIRIntConst *intConst0,
+                                                   const MIRIntConst *intConst1) {
+  IntVal intVal0 = intConst0->GetValue();
+  IntVal intVal1 = intConst1->GetValue();
+  IntVal result(0, resultType);
+
+  switch (opcode) {
+    case OP_add: {
+      result = intVal0.Add(intVal1, resultType);
+      break;
+    }
+    case OP_sub: {
+      result = intVal0.Sub(intVal1, resultType);
+      break;
+    }
+    case OP_mul: {
+      result = intVal0.Mul(intVal1, resultType);
+      break;
+    }
+    case OP_div: {
+      result = intVal0.Div(intVal1, resultType);
+      break;
+    }
+    case OP_rem: {
+      result = intVal0.Rem(intVal1, resultType);
+      break;
+    }
+    case OP_ashr: {
+      result = intVal0.AShr(intVal1.GetZXTValue() % GetAlignedPrimTypeBitSize(resultType), resultType);
+      break;
+    }
+    case OP_lshr: {
+      result = intVal0.LShr(intVal1.GetZXTValue() % GetAlignedPrimTypeBitSize(resultType), resultType);
+      break;
+    }
+    case OP_shl: {
+      result = intVal0.Shl(intVal1.GetZXTValue() % GetAlignedPrimTypeBitSize(resultType), resultType);
+      break;
+    }
+    case OP_max: {
+      result = Max(intVal0, intVal1, resultType);
+      break;
+    }
+    case OP_min: {
+      result = Min(intVal0, intVal1, resultType);
+      break;
+    }
+    case OP_band: {
+      result = intVal0.And(intVal1, resultType);
+      break;
+    }
+    case OP_bior: {
+      result = intVal0.Or(intVal1, resultType);
+      break;
+    }
+    case OP_bxor: {
+      result = intVal0.Xor(intVal1, resultType);
+      break;
+    }
+    case OP_cand:
+    case OP_land: {
+      result = IntVal(intVal0.GetExtValue() && intVal1.GetExtValue(), resultType);
+      break;
+    }
+    case OP_cior:
+    case OP_lior: {
+      result = IntVal(intVal0.GetExtValue() || intVal1.GetExtValue(), resultType);
+      break;
+    }
+    case OP_depositbits: {
+      // handled in FoldDepositbits
+      ASSERT(false, "Unexpected opcode in FoldIntConstBinary");
+      break;
+    }
+    default:
+      ASSERT(false, "Unknown opcode for FoldIntConstBinary");
+      break;
+  }
+  // determine the type
+  MIRType &type = *GlobalTables::GetTypeTable().GetPrimType(resultType);
+  // form the constant
+  MIRIntConst *constValue = nullptr;
+  if (type.GetPrimType() == PTY_dyni32) {
+    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, type);
+    constValue->SetValue(kJsTypeNumberInHigh32Bit | static_cast<uint64>(result.GetExtValue()));
+  } else {
+    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(result.GetExtValue(), type);
+  }
+  return constValue;
+}
+
+ConstvalNode *ConstantFold::FoldIntConstBinary(Opcode opcode, PrimType resultType, const ConstvalNode &const0,
+                                               const ConstvalNode &const1) const {
+  const MIRIntConst *intConst0 = safe_cast<MIRIntConst>(const0.GetConstVal());
+  const MIRIntConst *intConst1 = safe_cast<MIRIntConst>(const1.GetConstVal());
+  CHECK_NULL_FATAL(intConst0);
+  CHECK_NULL_FATAL(intConst1);
+  MIRConst *constValue = FoldIntConstBinaryMIRConst(opcode, resultType, intConst0, intConst1);
+  // form the ConstvalNode
+  ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  resultConst->SetPrimType(resultType);
+  resultConst->SetConstVal(constValue);
+  return resultConst;
+}
+
+ConstvalNode *ConstantFold::FoldFPConstBinary(Opcode opcode, PrimType resultType, const ConstvalNode &const0,
+                                              const ConstvalNode &const1) const {
+  ASSERT(const0.GetPrimType() == const1.GetPrimType(), "The types of the operands must match");
+  const MIRDoubleConst *doubleConst0 = nullptr;
+  const MIRDoubleConst *doubleConst1 = nullptr;
+  const MIRFloatConst *floatConst0 = nullptr;
+  const MIRFloatConst *floatConst1 = nullptr;
+  bool useDouble = (const0.GetPrimType() == PTY_f64);
+  ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  resultConst->SetPrimType(resultType);
+  if (useDouble) {
+    doubleConst0 = safe_cast<MIRDoubleConst>(const0.GetConstVal());
+    doubleConst1 = safe_cast<MIRDoubleConst>(const1.GetConstVal());
+    CHECK_NULL_FATAL(doubleConst0);
+    CHECK_NULL_FATAL(doubleConst1);
+  } else {
+    floatConst0 = safe_cast<MIRFloatConst>(const0.GetConstVal());
+    floatConst1 = safe_cast<MIRFloatConst>(const1.GetConstVal());
+    CHECK_NULL_FATAL(floatConst0);
+    CHECK_NULL_FATAL(floatConst1);
+  }
+  float constValueFloat = 0.0;
+  double constValueDouble = 0.0;
+  switch (opcode) {
+    case OP_add: {
+      if (useDouble) {
+        constValueDouble = doubleConst0->GetValue() + doubleConst1->GetValue();
+      } else {
+        constValueFloat = floatConst0->GetValue() + floatConst1->GetValue();
+      }
+      break;
+    }
+    case OP_sub: {
+      if (useDouble) {
+        constValueDouble = doubleConst0->GetValue() - doubleConst1->GetValue();
+      } else {
+        constValueFloat = floatConst0->GetValue() - floatConst1->GetValue();
+      }
+      break;
+    }
+    case OP_mul: {
+      if (useDouble) {
+        constValueDouble = doubleConst0->GetValue() * doubleConst1->GetValue();
+      } else {
+        constValueFloat = floatConst0->GetValue() * floatConst1->GetValue();
+      }
+      break;
+    }
+    case OP_div: {
+      // for floats div by 0 is well defined
+      if (useDouble) {
+        constValueDouble = doubleConst0->GetValue() / doubleConst1->GetValue();
+      } else {
+        constValueFloat = floatConst0->GetValue() / floatConst1->GetValue();
+      }
+      break;
+    }
+    case OP_max: {
+      if (useDouble) {
+        constValueDouble = (doubleConst0->GetValue() >= doubleConst1->GetValue()) ? doubleConst0->GetValue()
+                                                                                  : doubleConst1->GetValue();
+      } else {
+        constValueFloat = (floatConst0->GetValue() >= floatConst1->GetValue()) ? floatConst0->GetValue()
+                                                                               : floatConst1->GetValue();
+      }
+      break;
+    }
+    case OP_min: {
+      if (useDouble) {
+        constValueDouble = (doubleConst0->GetValue() <= doubleConst1->GetValue()) ? doubleConst0->GetValue()
+                                                                                  : doubleConst1->GetValue();
+      } else {
+        constValueFloat = (floatConst0->GetValue() <= floatConst1->GetValue()) ? floatConst0->GetValue()
+                                                                               : floatConst1->GetValue();
+      }
+      break;
+    }
+    case OP_rem:
+    case OP_ashr:
+    case OP_lshr:
+    case OP_shl:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_cand:
+    case OP_land:
+    case OP_cior:
+    case OP_lior:
+    case OP_depositbits: {
+      ASSERT(false, "Unexpected opcode in FoldFPConstBinary");
+      break;
+    }
+    default:
+      ASSERT(false, "Unknown opcode for FoldFPConstBinary");
+      break;
+  }
+  if (resultType == PTY_f64) {
+    resultConst->SetConstVal(GlobalTables::GetFpConstTable().GetOrCreateDoubleConst(constValueDouble));
+  } else {
+    resultConst->SetConstVal(GlobalTables::GetFpConstTable().GetOrCreateFloatConst(constValueFloat));
+  }
+  return resultConst;
+}
+
+bool ConstantFold::ConstValueEqual(int64 leftValue, int64 rightValue) const {
+  return (leftValue == rightValue);
+}
+
+bool ConstantFold::ConstValueEqual(float leftValue, float rightValue) const {
+  return fabs(leftValue - rightValue) <= FLT_MIN;
+}
+
+bool ConstantFold::ConstValueEqual(double leftValue, double rightValue) const {
+  return fabs(leftValue - rightValue) <= DBL_MIN;
+}
+
+template<typename T>
+bool ConstantFold::FullyEqual(T leftValue, T rightValue) const {
+  if (isinf(leftValue) && isinf(rightValue)) {
+    // (inf == inf), add the judgement here in case of the subtraction between float type inf
+    return true;
+  } else {
+    return ConstValueEqual(leftValue, rightValue);
+  }
+}
+
+template<typename T>
+int64 ConstantFold::ComparisonResult(Opcode op, T *leftConst, T *rightConst) const {
+  typename T::value_type leftValue = leftConst->GetValue();
+  typename T::value_type rightValue = rightConst->GetValue();
+  int64 result = 0;
+  switch (op) {
+    case OP_eq: {
+      result = FullyEqual(leftValue, rightValue);
+      break;
+    }
+    case OP_ge: {
+      result = (leftValue > rightValue) || FullyEqual(leftValue, rightValue);
+      break;
+    }
+    case OP_gt: {
+      result = (leftValue > rightValue);
+      break;
+    }
+    case OP_le: {
+      result = (leftValue < rightValue) || FullyEqual(leftValue, rightValue);
+      break;
+    }
+    case OP_lt: {
+      result = (leftValue < rightValue);
+      break;
+    }
+    case OP_ne: {
+      result = !FullyEqual(leftValue, rightValue);
+      break;
+    }
+    case OP_cmpl:
+    case OP_cmpg: {
+      if (std::isnan(leftValue) || std::isnan(rightValue)) {
+        result = (op == OP_cmpg) ? kGreater : kLess;
+        break;
+      }
+    }
+    [[clang::fallthrough]];
+    case OP_cmp: {
+      if (leftValue > rightValue) {
+        result = kGreater;
+      } else if (FullyEqual(leftValue, rightValue)) {
+        result = kEqual;
+      } else {
+        result = kLess;
+      }
+      break;
+    }
+    default:
+      ASSERT(false, "Unknown opcode for Comparison");
+      break;
+  }
+  return result;
+}
+
+MIRIntConst *ConstantFold::FoldFPConstComparisonMIRConst(Opcode opcode, PrimType resultType, PrimType opndType,
+                                                         const MIRConst &leftConst, const MIRConst &rightConst) const {
+  int64 result = 0;
+  bool useDouble = (opndType == PTY_f64);
+  if (useDouble) {
+    result = ComparisonResult(opcode, safe_cast<MIRDoubleConst>(&leftConst), safe_cast<MIRDoubleConst>(&rightConst));
+  } else {
+    result = ComparisonResult(opcode, safe_cast<MIRFloatConst>(&leftConst), safe_cast<MIRFloatConst>(&rightConst));
+  }
+  MIRType &type = *GlobalTables::GetTypeTable().GetPrimType(resultType);
+  MIRIntConst *resultConst =
+      GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<uint64>(result), type);
+  return resultConst;
+}
+
+ConstvalNode *ConstantFold::FoldFPConstComparison(Opcode opcode, PrimType resultType, PrimType opndType,
+                                                  const ConstvalNode &const0, const ConstvalNode &const1) const {
+  ASSERT(const0.GetPrimType() == const1.GetPrimType(), "The types of the operands must match");
+  ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  resultConst->SetPrimType(resultType);
+  resultConst->SetConstVal(FoldFPConstComparisonMIRConst(opcode, resultType, opndType, *const0.GetConstVal(),
+                                                         *const1.GetConstVal()));
+  return resultConst;
+}
+
+MIRConst *ConstantFold::FoldConstComparisonMIRConst(Opcode opcode, PrimType resultType, PrimType opndType,
+                                                    const MIRConst &const0, const MIRConst &const1) {
+  MIRConst *returnValue = nullptr;
+  if (IsPrimitiveInteger(opndType) || IsPrimitiveDynInteger(opndType)) {
+    const auto *intConst0 = safe_cast<MIRIntConst>(&const0);
+    const auto *intConst1 = safe_cast<MIRIntConst>(&const1);
+    ASSERT_NOT_NULL(intConst0);
+    ASSERT_NOT_NULL(intConst1);
+    returnValue = FoldIntConstComparisonMIRConst(opcode, resultType, opndType, *intConst0, *intConst1);
+  } else if (opndType == PTY_f32 || opndType == PTY_f64) {
+    returnValue = FoldFPConstComparisonMIRConst(opcode, resultType, opndType, const0, const1);
+  } else {
+    ASSERT(false, "Unhandled case for FoldConstComparisonMIRConst");
+  }
+  return returnValue;
+}
+
+ConstvalNode *ConstantFold::FoldConstComparison(Opcode opcode, PrimType resultType, PrimType opndType,
+                                                const ConstvalNode &const0, const ConstvalNode &const1) const {
+  ConstvalNode *returnValue = nullptr;
+  if (IsPrimitiveInteger(opndType) || IsPrimitiveDynInteger(opndType)) {
+    returnValue = FoldIntConstComparison(opcode, resultType, opndType, const0, const1);
+  } else if (opndType == PTY_f32 || opndType == PTY_f64) {
+    returnValue = FoldFPConstComparison(opcode, resultType, opndType, const0, const1);
+  } else {
+    ASSERT(false, "Unhandled case for FoldConstComparison");
+  }
+  return returnValue;
+}
+
+CompareNode *ConstantFold::FoldConstComparisonReverse(Opcode opcode, PrimType resultType, PrimType opndType,
+                                                      BaseNode &l, BaseNode &r) {
+  CompareNode *result = nullptr;
+  Opcode op = opcode;
+  switch (opcode) {
+    case OP_gt: {
+      op = OP_lt;
+      break;
+    }
+    case OP_lt: {
+      op = OP_gt;
+      break;
+    }
+    case OP_ge: {
+      op = OP_le;
+      break;
+    }
+    case OP_le: {
+      op = OP_ge;
+      break;
+    }
+    case OP_eq: {
+      break;
+    }
+    case OP_ne: {
+      break;
+    }
+    default:
+      ASSERT(false, "Unknown opcode for FoldConstComparisonReverse");
+      break;
+  }
+
+  result = mirModule->CurFuncCodeMemPool()->New<CompareNode>(
+      Opcode(op), PrimType(resultType), PrimType(opndType), &r, &l);
+  return result;
+}
+
+ConstvalNode *ConstantFold::FoldConstBinary(Opcode opcode, PrimType resultType, const ConstvalNode &const0,
+                                            const ConstvalNode &const1) const {
+  ConstvalNode *returnValue = nullptr;
+  if (IsPrimitiveInteger(resultType) || IsPrimitiveDynInteger(resultType)) {
+    returnValue = FoldIntConstBinary(opcode, resultType, const0, const1);
+  } else if (resultType == PTY_f32 || resultType == PTY_f64) {
+    returnValue = FoldFPConstBinary(opcode, resultType, const0, const1);
+  } else {
+    ASSERT(false, "Unhandled case for FoldConstBinary");
+  }
+  return returnValue;
+}
+
+MIRIntConst *ConstantFold::FoldIntConstUnaryMIRConst(Opcode opcode, PrimType resultType, const MIRIntConst *cst) {
+  CHECK_NULL_FATAL(cst);
+  IntVal result = cst->GetValue().TruncOrExtend(resultType);
+  switch (opcode) {
+    case OP_abs: {
+      if (IsSignedInteger(cst->GetType().GetPrimType()) && result.GetSignBit()) {
+        result = -result;
+      }
+      break;
+    }
+    case OP_bnot: {
+      result = ~result;
+      break;
+    }
+    case OP_lnot: {
+      result = { result == 0, resultType };
+      break;
+    }
+    case OP_neg: {
+      result = -result;
+      break;
+    }
+    case OP_sext:         // handled in FoldExtractbits
+    case OP_zext:         // handled in FoldExtractbits
+    case OP_extractbits:  // handled in FoldExtractbits
+    case OP_recip:
+    case OP_sqrt: {
+      ASSERT(false, "Unexpected opcode in FoldIntConstUnaryMIRConst");
+      break;
+    }
+    default:
+      ASSERT(false, "Unknown opcode for FoldIntConstUnaryMIRConst");
+      break;
+  }
+  // determine the type
+  MIRType &type = *GlobalTables::GetTypeTable().GetPrimType(resultType);
+  // form the constant
+  MIRIntConst *constValue = nullptr;
+  if (type.GetPrimType() == PTY_dyni32) {
+    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, type);
+    constValue->SetValue(kJsTypeNumberInHigh32Bit | static_cast<uint64>(result.GetExtValue()));
+  } else {
+    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(result.GetExtValue(), type);
+  }
+  return constValue;
+}
+
+template <typename T>
+ConstvalNode *ConstantFold::FoldFPConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *constNode) const {
+  CHECK_NULL_FATAL(constNode);
+  typename T::value_type constValue = 0.0;
+  T *fpCst = static_cast<T*>(constNode->GetConstVal());
+  switch (opcode) {
+    case OP_recip:
+    case OP_neg:
+    case OP_abs: {
+      if (opcode == OP_recip) {
+        constValue = typename T::value_type(1.0 / fpCst->GetValue());
+      } else if (opcode == OP_neg) {
+        constValue = typename T::value_type(-fpCst->GetValue());
+      } else if (opcode == OP_abs) {
+        constValue = typename T::value_type(fabs(fpCst->GetValue()));
+      }
+      break;
+    }
+    case OP_sqrt: {
+      constValue = typename T::value_type(sqrt(fpCst->GetValue()));
+      break;
+    }
+    case OP_bnot:
+    case OP_lnot:
+    case OP_sext:
+    case OP_zext:
+    case OP_extractbits: {
+      ASSERT(false, "Unexpected opcode in FoldFPConstUnary");
+      break;
+    }
+    default:
+      ASSERT(false, "Unknown opcode for FoldFPConstUnary");
+      break;
+  }
+  auto *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  resultConst->SetPrimType(resultType);
+  if (resultType == PTY_f32) {
+    resultConst->SetConstVal(GlobalTables::GetFpConstTable().GetOrCreateFloatConst(constValue));
+  } else {
+    resultConst->SetConstVal(GlobalTables::GetFpConstTable().GetOrCreateDoubleConst(constValue));
+  }
+  return resultConst;
+}
+
+ConstvalNode *ConstantFold::FoldConstUnary(Opcode opcode, PrimType resultType, ConstvalNode &constNode) const {
+  ConstvalNode *returnValue = nullptr;
+  if (IsPrimitiveInteger(resultType) || IsPrimitiveDynInteger(resultType)) {
+    const MIRIntConst *cst = safe_cast<MIRIntConst>(constNode.GetConstVal());
+    auto constValue = FoldIntConstUnaryMIRConst(opcode, resultType, cst);
+    returnValue = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+    returnValue->SetPrimType(resultType);
+    returnValue->SetConstVal(constValue);
+  } else if (resultType == PTY_f32) {
+    returnValue = FoldFPConstUnary<MIRFloatConst>(opcode, resultType, &constNode);
+  } else if (resultType == PTY_f64) {
+    returnValue = FoldFPConstUnary<MIRDoubleConst>(opcode, resultType, &constNode);
+  } else if (resultType == PTY_f128) {
+  } else {
+    ASSERT(false, "Unhandled case for FoldConstUnary");
+  }
+  return returnValue;
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldSizeoftype(SizeoftypeNode *node) const {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = node;
+  MIRType *argType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(node->GetTyIdx());
+  if (argType->GetKind() == kTypeScalar) {
+    MIRType &resultType = *GlobalTables::GetTypeTable().GetPrimType(node->GetPrimType());
+    uint32 size = GetPrimTypeSize(argType->GetPrimType());
+    ConstvalNode *constValueNode = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+    constValueNode->SetPrimType(node->GetPrimType());
+    constValueNode->SetConstVal(GlobalTables::GetIntConstTable().GetOrCreateIntConst(size, resultType));
+    result = constValueNode;
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldRetype(RetypeNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = node;
+  std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(node->Opnd(0));
+  if (node->Opnd(0) != p.first) {
+    RetypeNode *newRetNode = node->CloneTree(mirModule->GetCurFuncCodeMPAllocator());
+    CHECK_FATAL(newRetNode != nullptr, "newRetNode is null in ConstantFold::FoldRetype");
+    newRetNode->SetOpnd(PairToExpr(node->Opnd(0)->GetPrimType(), p), 0);
+    result = newRetNode;
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldGcmallocjarray(JarrayMallocNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = node;
+  std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(node->Opnd(0));
+  if (node->Opnd(0) != p.first) {
+    JarrayMallocNode *newRetNode = node->CloneTree(mirModule->GetCurFuncCodeMPAllocator());
+    CHECK_FATAL(newRetNode != nullptr, "newRetNode is null in ConstantFold::FoldGcmallocjarray");
+    newRetNode->SetOpnd(PairToExpr(node->Opnd(0)->GetPrimType(), p), 0);
+    result = newRetNode;
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldUnary(UnaryNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  std::optional<IntVal> sum = std::nullopt;
+  std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(node->Opnd(0));
+  ConstvalNode *cst = safe_cast<ConstvalNode>(p.first);
+  if (cst != nullptr) {
+    result = FoldConstUnary(node->GetOpCode(), node->GetPrimType(), *cst);
+  } else {
+    bool isInt = IsPrimitiveInteger(node->GetPrimType());
+    // The neg node will be recreated regardless of whether the folding is successful or not. And the neg node's
+    // primType will be set to opnd type. There will be problems in some cases. For example:
+    // before cf:
+    //   neg i32 (eq u1 f32 (dread f32 %f_4_2, constval f32 0f))
+    // after cf:
+    //   neg u1 (eq u1 f32 (dread f32 %f_4_2, constval f32 0f))  # wrong!
+    // As a workaround, we exclude u1 opnd type
+    if (isInt && node->GetOpCode() == OP_neg && p.first->GetPrimType() != PTY_u1) {
+      result = NegateTree(p.first);
+      if (result->GetOpCode() == OP_neg) {
+        PrimType origPtyp = node->GetPrimType();
+        PrimType newPtyp = result->GetPrimType();
+        if (newPtyp == origPtyp) {
+          if (static_cast<UnaryNode*>(result)->Opnd(0) == node->Opnd(0)) {
+            // NegateTree returned an UnaryNode quivalent to `n`, so keep the
+            // original UnaryNode to preserve identity
+            result = node;
+          }
+        } else {
+          if (GetPrimTypeSize(newPtyp) != GetPrimTypeSize(origPtyp)) {
+            // do not fold explicit cvt
+            return std::make_pair(node, std::nullopt);
+          } else {
+            result->SetPrimType(origPtyp);
+          }
+        }
+      }
+      if (p.second) {
+        sum = -(*p.second);
+      }
+    } else {
+      result = NewUnaryNode(node, node->GetOpCode(), node->GetPrimType(), PairToExpr(node->Opnd(0)->GetPrimType(), p));
+    }
+  }
+  return std::make_pair(result, sum);
+}
+
+static bool FloatToIntOverflow(float fval, PrimType totype) {
+  static const float safeFloatMaxToInt32 = 2147483520.0f; // 2^31 - 128
+  static const float safeFloatMinToInt32 = -2147483520.0f;
+  static const float safeFloatMaxToInt64 = 9223372036854775680.0f; // 2^63 - 128
+  static const float safeFloatMinToInt64 = -9223372036854775680.0f;
+  if (!std::isfinite(fval)) {
+    return true;
+  }
+  if (totype == PTY_i64 || totype == PTY_u64) {
+    if (fval < safeFloatMinToInt64 || fval > safeFloatMaxToInt64) {
+      return true;
+    }
+  } else {
+    if (fval < safeFloatMinToInt32 || fval > safeFloatMaxToInt32) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool DoubleToIntOverflow(double dval, PrimType totype) {
+  static const double safeDoubleMaxToInt32 = 2147482624.0; // 2^31 - 1024
+  static const double safeDoubleMinToInt32 = -2147482624.0;
+  static const double safeDoubleMaxToInt64 = 9223372036854774784.0; // 2^63 - 1024
+  static const double safeDoubleMinToInt64 = -9223372036854774784.0;
+  if (!std::isfinite(dval)) {
+    return true;
+  }
+  if (totype == PTY_i64 || totype == PTY_u64) {
+    if (dval < safeDoubleMinToInt64 || dval > safeDoubleMaxToInt64) {
+      return true;
+    }
+  } else {
+    if (dval < safeDoubleMinToInt32 || dval > safeDoubleMaxToInt32) {
+      return true;
+    }
+  }
+  return false;
+}
+
+ConstvalNode *ConstantFold::FoldCeil(const ConstvalNode &cst, PrimType fromType, PrimType toType) const {
+  ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  resultConst->SetPrimType(toType);
+  MIRType &resultType = *GlobalTables::GetTypeTable().GetPrimType(toType);
+  if (fromType == PTY_f32) {
+    const MIRFloatConst *constValue = safe_cast<MIRFloatConst>(cst.GetConstVal());
+    ASSERT_NOT_NULL(constValue);
+    float floatValue = ceil(constValue->GetValue());
+    if (FloatToIntOverflow(floatValue, toType)) {
+      return nullptr;
+    }
+    resultConst->SetConstVal(GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        static_cast<int64>(floatValue), resultType));
+  } else {
+    const MIRDoubleConst *constValue = safe_cast<MIRDoubleConst>(cst.GetConstVal());
+    ASSERT_NOT_NULL(constValue);
+    double doubleValue = ceil(constValue->GetValue());
+    if (DoubleToIntOverflow(doubleValue, toType)) {
+      return nullptr;
+    }
+    resultConst->SetConstVal(GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        static_cast<int64>(doubleValue), resultType));
+  }
+  return resultConst;
+}
+
+template <class T>
+T ConstantFold::CalIntValueFromFloatValue(T value, const MIRType &resultType) const {
+  ASSERT(kByteSizeOfBit64 >= resultType.GetSize(), "unsupported type");
+  size_t shiftNum = (kByteSizeOfBit64 - resultType.GetSize()) * kBitSizePerByte;
+  bool isSigned = IsSignedInteger(resultType.GetPrimType());
+  int64 max = LONG_LONG_MAX >> shiftNum;
+  uint64 umax = ULONG_LONG_MAX >> shiftNum;
+  int64 min = isSigned ? (LONG_LONG_MIN >> shiftNum) : 0;
+  if (isSigned && (value > max)) {
+    return static_cast<T>(max);
+  } else if (!isSigned && (value > umax)) {
+    return static_cast<T>(umax);
+  } else if (value < min) {
+    return static_cast<T>(min);
+  }
+  return value;
+}
+
+MIRConst *ConstantFold::FoldFloorMIRConst(const MIRConst &cst, PrimType fromType, PrimType toType, bool isFloor) const {
+  MIRType &resultType = *GlobalTables::GetTypeTable().GetPrimType(toType);
+  if (fromType == PTY_f32) {
+    const auto &constValue = static_cast<const MIRFloatConst&>(cst);
+    float floatValue = constValue.GetValue();
+    if (isFloor) {
+      floatValue = floor(constValue.GetValue());
+    }
+    if (FloatToIntOverflow(floatValue, toType)) {
+      return nullptr;
+    }
+    floatValue = CalIntValueFromFloatValue(floatValue, resultType);
+    return GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(floatValue), resultType);
+  } else {
+    const auto &constValue = static_cast<const MIRDoubleConst&>(cst);
+    double doubleValue = constValue.GetValue();
+    if (isFloor) {
+      doubleValue = floor(constValue.GetValue());
+    }
+    if (DoubleToIntOverflow(doubleValue, toType)) {
+      return nullptr;
+    }
+    doubleValue = CalIntValueFromFloatValue(doubleValue, resultType);
+    return GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(doubleValue), resultType);
+  }
+}
+
+ConstvalNode *ConstantFold::FoldFloor(const ConstvalNode &cst, PrimType fromType, PrimType toType) const {
+  ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  resultConst->SetPrimType(toType);
+  resultConst->SetConstVal(FoldFloorMIRConst(*cst.GetConstVal(), fromType, toType));
+  return resultConst;
+}
+
+MIRConst *ConstantFold::FoldRoundMIRConst(const MIRConst &cst, PrimType fromType, PrimType toType) const {
+  MIRType &resultType = *GlobalTables::GetTypeTable().GetPrimType(toType);
+  if (fromType == PTY_f32) {
+    const auto &constValue = static_cast<const MIRFloatConst&>(cst);
+    float floatValue = round(constValue.GetValue());
+    if (FloatToIntOverflow(floatValue, toType)) {
+      return nullptr;
+    }
+    return GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(floatValue), resultType);
+  } else if (fromType == PTY_f64) {
+    const auto &constValue = static_cast<const MIRDoubleConst&>(cst);
+    double doubleValue = round(constValue.GetValue());
+    if (DoubleToIntOverflow(doubleValue, toType)) {
+      return nullptr;
+    }
+    return GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(doubleValue), resultType);
+  } else if (toType == PTY_f32 && IsPrimitiveInteger(fromType)) {
+    const auto &constValue = static_cast<const MIRIntConst&>(cst);
+    if (IsSignedInteger(fromType)) {
+      int64 fromValue = constValue.GetExtValue();
+      float floatValue = round(static_cast<float>(fromValue));
+      if (static_cast<int64>(floatValue) == fromValue) {
+        return GlobalTables::GetFpConstTable().GetOrCreateFloatConst(floatValue);
+      }
+    } else {
+      uint64 fromValue = constValue.GetExtValue();
+      float floatValue = round(static_cast<float>(fromValue));
+      if (static_cast<uint64>(floatValue) == fromValue) {
+        return GlobalTables::GetFpConstTable().GetOrCreateFloatConst(floatValue);
+      }
+    }
+  } else if (toType == PTY_f64 && IsPrimitiveInteger(fromType)) {
+    const auto &constValue = static_cast<const MIRIntConst&>(cst);
+    if (IsSignedInteger(fromType)) {
+      int64 fromValue = constValue.GetExtValue();
+      double doubleValue = round(static_cast<double>(fromValue));
+      if (static_cast<int64>(doubleValue) == fromValue) {
+        return GlobalTables::GetFpConstTable().GetOrCreateDoubleConst(doubleValue);
+      }
+    } else {
+      uint64 fromValue = constValue.GetExtValue();
+      double doubleValue = round(static_cast<double>(fromValue));
+      if (static_cast<uint64>(doubleValue) == fromValue) {
+        return GlobalTables::GetFpConstTable().GetOrCreateDoubleConst(doubleValue);
+      }
+    }
+  }
+  return nullptr;
+}
+
+ConstvalNode *ConstantFold::FoldRound(const ConstvalNode &cst, PrimType fromType, PrimType toType) const {
+  ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  resultConst->SetPrimType(toType);
+  resultConst->SetConstVal(FoldRoundMIRConst(*cst.GetConstVal(), fromType, toType));
+  return resultConst;
+}
+
+ConstvalNode *ConstantFold::FoldTrunk(const ConstvalNode &cst, PrimType fromType, PrimType toType) const {
+  ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  resultConst->SetPrimType(toType);
+  MIRType &resultType = *GlobalTables::GetTypeTable().GetPrimType(toType);
+  if (fromType == PTY_f32) {
+    const MIRFloatConst *constValue = safe_cast<MIRFloatConst>(cst.GetConstVal());
+    CHECK_NULL_FATAL(constValue);
+    float floatValue = trunc(constValue->GetValue());
+    if (FloatToIntOverflow(floatValue, toType)) {
+      return nullptr;
+    }
+    resultConst->SetConstVal(GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        static_cast<int64>(floatValue), resultType));
+  } else {
+    const MIRDoubleConst *constValue = safe_cast<MIRDoubleConst>(cst.GetConstVal());
+    CHECK_NULL_FATAL(constValue);
+    double doubleValue = trunc(constValue->GetValue());
+    if (DoubleToIntOverflow(doubleValue, toType)) {
+      return nullptr;
+    }
+    resultConst->SetConstVal(GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        static_cast<int64>(doubleValue), resultType));
+  }
+  return resultConst;
+}
+
+MIRConst *ConstantFold::FoldTypeCvtMIRConst(const MIRConst &cst, PrimType fromType, PrimType toType) const {
+  if (IsPrimitiveDynType(fromType) || IsPrimitiveDynType(toType)) {
+    // do not fold
+    return nullptr;
+  }
+  if (IsPrimitiveInteger(fromType) && IsPrimitiveInteger(toType)) {
+    MIRConst *toConst = nullptr;
+    uint32 fromSize = GetPrimTypeBitSize(fromType);
+    uint32 toSize = GetPrimTypeBitSize(toType);
+    // GetPrimTypeBitSize(PTY_u1) will return 8, which is not expected here.
+    if (fromType == PTY_u1) {
+      fromSize = 1;
+    }
+    if (toType == PTY_u1) {
+      toSize = 1;
+    }
+    if (toSize > fromSize) {
+      Opcode op = OP_zext;
+      if (IsSignedInteger(fromType)) {
+        op = OP_sext;
+      }
+      const MIRIntConst *constVal = safe_cast<MIRIntConst>(cst);
+      ASSERT_NOT_NULL(constVal);
+      toConst = FoldSignExtendMIRConst(op, toType, fromSize, constVal->GetValue().TruncOrExtend(fromType));
+    } else {
+      const MIRIntConst *constVal = safe_cast<MIRIntConst>(cst);
+      ASSERT_NOT_NULL(constVal);
+      MIRType &type = *GlobalTables::GetTypeTable().GetPrimType(toType);
+      toConst =
+          GlobalTables::GetIntConstTable().GetOrCreateIntConst(constVal->GetExtValue(), type);
+    }
+    return toConst;
+  }
+  if (IsPrimitiveFloat(fromType) && IsPrimitiveFloat(toType)) {
+    MIRConst *toConst = nullptr;
+    if (GetPrimTypeBitSize(toType) < GetPrimTypeBitSize(fromType)) {
+      ASSERT(GetPrimTypeBitSize(toType) == 32, "We suppot F32 and F64");
+      const MIRDoubleConst *fromValue = safe_cast<MIRDoubleConst>(cst);
+      ASSERT_NOT_NULL(fromValue);
+      float floatValue = static_cast<float>(fromValue->GetValue());
+      MIRFloatConst *toValue = GlobalTables::GetFpConstTable().GetOrCreateFloatConst(floatValue);
+      toConst = toValue;
+    } else {
+      ASSERT(GetPrimTypeBitSize(toType) == 64, "We suppot F32 and F64");
+      const MIRFloatConst *fromValue = safe_cast<MIRFloatConst>(cst);
+      ASSERT_NOT_NULL(fromValue);
+      double doubleValue = static_cast<double>(fromValue->GetValue());
+      MIRDoubleConst *toValue = GlobalTables::GetFpConstTable().GetOrCreateDoubleConst(doubleValue);
+      toConst = toValue;
+    }
+    return toConst;
+  }
+  if (IsPrimitiveFloat(fromType) && IsPrimitiveInteger(toType)) {
+    return FoldFloorMIRConst(cst, fromType, toType, false);
+  }
+  if (IsPrimitiveInteger(fromType) && IsPrimitiveFloat(toType)) {
+    return FoldRoundMIRConst(cst, fromType, toType);
+  }
+  CHECK_FATAL(false, "Unexpected case in ConstFoldTypeCvt");
+  return nullptr;
+}
+
+ConstvalNode *ConstantFold::FoldTypeCvt(const ConstvalNode &cst, PrimType fromType, PrimType toType) const {
+  MIRConst *toConstValue = FoldTypeCvtMIRConst(*cst.GetConstVal(), fromType, toType);
+  if (toConstValue == nullptr) {
+    return nullptr;
+  }
+  ConstvalNode *toConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  toConst->SetPrimType(toConstValue->GetType().GetPrimType());
+  toConst->SetConstVal(toConstValue);
+  return toConst;
+}
+
+// return a primType with bit size >= bitSize (and the nearest one),
+// and its signed/float type is the same as ptyp
+PrimType GetNearestSizePtyp(uint8 bitSize, PrimType ptyp) {
+  bool isSigned = IsSignedInteger(ptyp);
+  bool isFloat = IsPrimitiveFloat(ptyp);
+  if (bitSize == 1) {
+    return PTY_u1;
+  }
+  if (bitSize <= 8) {
+    return isSigned ? PTY_i8 : PTY_u8;
+  }
+  if (bitSize <= 16) {
+    return isSigned ? PTY_i16 : PTY_u16;
+  }
+  if (bitSize <= 32) {
+    return isFloat ? PTY_f32
+                   : (isSigned ? PTY_i32 : PTY_u32);
+  }
+  if (bitSize <= 64) {
+    return isFloat ? PTY_f64
+                   : (isSigned ? PTY_i64 : PTY_u64);
+  }
+  if (bitSize <= 128) {
+    return isFloat ? PTY_f128
+                   : (isSigned ? PTY_i128 : PTY_u128);
+  }
+  return ptyp;
+}
+
+size_t GetIntPrimTypeMax(PrimType ptyp) {
+  switch (ptyp) {
+    case PTY_u1:
+      return 1;
+    case PTY_u8:
+      return UINT8_MAX;
+    case PTY_i8:
+      return INT8_MAX;
+    case PTY_u16:
+      return UINT16_MAX;
+    case PTY_i16:
+      return INT16_MAX;
+    case PTY_u32:
+      return UINT32_MAX;
+    case PTY_i32:
+      return INT32_MAX;
+    case PTY_u64:
+      return UINT64_MAX;
+    case PTY_i64:
+      return INT64_MAX;
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+}
+
+ssize_t GetIntPrimTypeMin(PrimType ptyp) {
+  if (IsUnsignedInteger(ptyp)) {
+    return 0;
+  }
+  switch (ptyp) {
+    case PTY_i8:
+      return INT8_MIN;
+    case PTY_i16:
+      return INT16_MIN;
+    case PTY_i32:
+      return INT32_MIN;
+    case PTY_i64:
+      return INT64_MIN;
+    default:
+      CHECK_FATAL(false, "NYI");
+  }
+}
+
+// return a primtype to represent value range of expr
+PrimType GetExprValueRangePtyp(BaseNode *expr) {
+  PrimType ptyp = expr->GetPrimType();
+  Opcode op = expr->GetOpCode();
+  if (expr->IsLeaf()) {
+    return ptyp;
+  }
+  if (kOpcodeInfo.IsTypeCvt(op)) {
+    auto *node = static_cast<TypeCvtNode *>(expr);
+    if (GetPrimTypeSize(node->FromType()) < GetPrimTypeSize(node->GetPrimType())) {
+      return GetExprValueRangePtyp(expr->Opnd(0));
+    }
+    return ptyp;
+  }
+  if (op == OP_sext || op == OP_zext || op == OP_extractbits) {
+    auto *node = static_cast<ExtractbitsNode *>(expr);
+    uint8 size = node->GetBitsSize();
+    return GetNearestSizePtyp(size, expr->GetPrimType());
+  }
+  // find max size primtype of opnds.
+  size_t maxTypeSize = 1;
+  size_t ptypSize = GetPrimTypeSize(ptyp);
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    PrimType opndPtyp = GetExprValueRangePtyp(expr->Opnd(i));
+    size_t opndSize = GetPrimTypeSize(opndPtyp);
+    if (ptypSize <= opndSize) {
+      return ptyp;
+    }
+    if (maxTypeSize < opndSize) {
+      maxTypeSize = opndSize;
+      constexpr size_t intMaxSize = 8;
+      if (maxTypeSize == intMaxSize) {
+        break;
+      }
+    }
+  }
+  return GetNearestSizePtyp(maxTypeSize, ptyp);
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldTypeCvt(TypeCvtNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(node->Opnd(0));
+  ConstvalNode *cst = safe_cast<ConstvalNode>(p.first);
+  PrimType destPtyp = node->GetPrimType();
+  PrimType fromPtyp = node->FromType();
+  if (cst != nullptr) {
+    switch (node->GetOpCode()) {
+      case OP_ceil: {
+        result = FoldCeil(*cst, fromPtyp, destPtyp);
+        break;
+      }
+      case OP_cvt: {
+        result = FoldTypeCvt(*cst, fromPtyp, destPtyp);
+        break;
+      }
+      case OP_floor: {
+        result = FoldFloor(*cst, fromPtyp, destPtyp);
+        break;
+      }
+      case OP_round: {
+        result = FoldRound(*cst, fromPtyp, destPtyp);
+        break;
+      }
+      case OP_trunc: {
+        result = FoldTrunk(*cst, fromPtyp, destPtyp);
+        break;
+      }
+      default:
+        ASSERT(false, "Unexpected opcode in TypeCvtNodeConstFold");
+        break;
+    }
+  } else if (node->GetOpCode() == OP_cvt && GetPrimTypeSize(fromPtyp) == GetPrimTypeSize(destPtyp)) {
+    if ((IsPossible64BitAddress(fromPtyp) && IsPossible64BitAddress(destPtyp)) ||
+        (IsPossible32BitAddress(fromPtyp) && IsPossible32BitAddress(destPtyp)) ||
+         (IsPrimitivePureScalar(fromPtyp) && IsPrimitivePureScalar(destPtyp) &&
+          GetPrimTypeSize(fromPtyp) == GetPrimTypeSize(destPtyp))) {
+      // the cvt is redundant
+      return std::make_pair(p.first, p.second ? IntVal(*p.second, node->GetPrimType()) : p.second);
+    }
+  }
+  if (result == nullptr) {
+    BaseNode *e = PairToExpr(node->Opnd(0)->GetPrimType(), p);
+    if (e != node->Opnd(0)) {
+      result = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(Opcode(node->GetOpCode()),
+                                                                 PrimType(node->GetPrimType()),
+                                                                 PrimType(node->FromType()), e);
+    } else {
+      result = node;
+    }
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+MIRConst *ConstantFold::FoldSignExtendMIRConst(Opcode opcode, PrimType resultType, uint8 size,
+                                               const IntVal &val) const {
+  uint64 result = opcode == OP_sext ? val.GetSXTValue(size) : val.GetZXTValue(size);
+  MIRType &type = *GlobalTables::GetTypeTable().GetPrimType(resultType);
+  MIRIntConst *constValue =
+      GlobalTables::GetIntConstTable().GetOrCreateIntConst(result, type);
+  return constValue;
+}
+
+ConstvalNode *ConstantFold::FoldSignExtend(Opcode opcode, PrimType resultType, uint8 size,
+                                           const ConstvalNode &cst) const {
+  ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+  const auto* intCst = safe_cast<MIRIntConst>(cst.GetConstVal());
+  ASSERT_NOT_NULL(intCst);
+  IntVal val = intCst->GetValue().TruncOrExtend(size, opcode == OP_sext);
+  MIRConst *toConst = FoldSignExtendMIRConst(opcode, resultType, size, val);
+  resultConst->SetPrimType(toConst->GetType().GetPrimType());
+  resultConst->SetConstVal(toConst);
+  return resultConst;
+}
+
+// check if truncation is redundant due to dread or iread having same effect
+static bool ExtractbitsRedundant(const ExtractbitsNode *x, MIRFunction *f) {
+  if (GetPrimTypeSize(x->GetPrimType()) == 8) {
+    return false;  // this is trying to be conservative
+  }
+  BaseNode *opnd = x->Opnd(0);
+  MIRType *mirType = nullptr;
+  if (opnd->GetOpCode() == OP_dread) {
+    DreadNode *dread = static_cast<DreadNode *>(opnd);
+    MIRSymbol *sym = f->GetLocalOrGlobalSymbol(dread->GetStIdx());
+    ASSERT_NOT_NULL(sym);
+    mirType = sym->GetType();
+    if (dread->GetFieldID() != 0) {
+      MIRStructType *structType = dynamic_cast<MIRStructType*>(mirType);
+      if (structType == nullptr) {
+        return false;
+      }
+      mirType = structType->GetFieldType(dread->GetFieldID());
+    }
+  } else if (opnd->GetOpCode() == OP_iread) {
+    IreadNode *iread = static_cast<IreadNode *>(opnd);
+    MIRPtrType *ptrType = dynamic_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx()));
+    if (ptrType == nullptr) {
+      return false;
+    }
+    mirType = ptrType->GetPointedType();
+    if (iread->GetFieldID() != 0) {
+      MIRStructType *structType = dynamic_cast<MIRStructType*>(mirType);
+      if (structType == nullptr) {
+        return false;
+      }
+      mirType = structType->GetFieldType(iread->GetFieldID());
+    }
+  } else if (opnd->GetOpCode() == OP_extractbits &&
+             x->GetBitsSize() > static_cast<ExtractbitsNode*>(opnd)->GetBitsSize()) {
+    if (x->GetOpCode() == OP_zext && x->GetPrimType() == opnd->GetPrimType() &&
+        IsUnsignedInteger(opnd->GetPrimType())) {
+      return true;
+    }
+    return false;
+  } else {
+    return false;
+  }
+  return IsPrimitiveInteger(mirType->GetPrimType()) &&
+         mirType->GetSize() * 8 == x->GetBitsSize() &&
+         mirType->GetPrimType() == x->GetPrimType();
+}
+
+// sext and zext also handled automatically
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldExtractbits(ExtractbitsNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  uint8 offset = node->GetBitsOffset();
+  uint8 size = node->GetBitsSize();
+  Opcode opcode = node->GetOpCode();
+  std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(node->Opnd(0));
+  ConstvalNode *cst = safe_cast<ConstvalNode>(p.first);
+  if (cst != nullptr && (opcode == OP_sext || opcode == OP_zext)) {
+    result = FoldSignExtend(opcode, node->GetPrimType(), size, *cst);
+    return std::make_pair(result, std::nullopt);
+  }
+  BaseNode *e = PairToExpr(node->Opnd(0)->GetPrimType(), p);
+  if (e != node->Opnd(0)) {
+    result = mirModule->CurFuncCodeMemPool()->New<ExtractbitsNode>(opcode, PrimType(node->GetPrimType()),
+                                                                   offset, size, e);
+  } else {
+    result = node;
+  }
+  // check for consecutive and redundant extraction of same bits
+  BaseNode *opnd = result->Opnd(0);
+  Opcode opndOp = opnd->GetOpCode();
+  if (opndOp == OP_extractbits || opndOp == OP_sext || opndOp == OP_zext) {
+    uint8 opndOffset = static_cast<ExtractbitsNode*>(opnd)->GetBitsOffset();
+    uint8 opndSize = static_cast<ExtractbitsNode*>(opnd)->GetBitsSize();
+    if (offset == opndOffset && size == opndSize) {
+      result->SetOpnd(opnd->Opnd(0), 0);  // delete the redundant extraction
+    }
+  }
+  if (offset == 0 && size >= 8 && IsPowerOf2(size)) {
+    if (ExtractbitsRedundant(static_cast<ExtractbitsNode *>(result), mirModule->CurFunction())) {
+      return std::make_pair(result->Opnd(0), std::nullopt);
+    }
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldIread(IreadNode *node) {
+  CHECK_NULL_FATAL(node);
+  std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(node->Opnd(0));
+  BaseNode *e = PairToExpr(node->Opnd(0)->GetPrimType(), p);
+  node->SetOpnd(e, 0);
+  BaseNode *result = node;
+  if (e->GetOpCode() != OP_addrof || node->IsVolatile()) {
+    if (cfc.expandIaddrof && node->GetOpCode() == OP_iaddrof) {
+      auto *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(node->GetTyIdx());
+      auto *pointedType = static_cast<MIRPtrType*>(type)->GetPointedType();
+      CHECK_FATAL(pointedType != nullptr, "expect a pointed type of iaddrof");
+      auto offset = pointedType->GetBitOffsetFromBaseAddr(node->GetFieldID()) / 8;
+      return std::make_pair(p.first, p.second + IntVal(offset, GetExactPtrPrimType()));
+    }
+    return std::make_pair(result, std::nullopt);
+  }
+
+  AddrofNode *addrofNode = static_cast<AddrofNode*>(e);
+  MIRSymbol *msy = mirModule->CurFunction()->GetLocalOrGlobalSymbol(addrofNode->GetStIdx());
+  TyIdx typeId = msy->GetTyIdx();
+  CHECK_FATAL(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check");
+  MIRType *msyType = GlobalTables::GetTypeTable().GetTypeTable()[typeId];
+  if (addrofNode->GetFieldID() != 0 &&
+      (msyType->GetKind() == kTypeStruct || msyType->GetKind() == kTypeClass)) {
+    msyType = static_cast<MIRStructType *>(msyType)->GetFieldType(addrofNode->GetFieldID());
+  }
+  MIRPtrType *ptrType = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(node->GetTyIdx()));
+  // If the high level type of iaddrof/iread doesn't match
+  // the type of addrof's rhs, this optimization cannot be done.
+  if (ptrType->GetPointedType() != msyType) {
+    return std::make_pair(result, std::nullopt);
+  }
+
+  Opcode op = node->GetOpCode();
+  FieldID fieldID = node->GetFieldID();
+  if (op == OP_iaddrof) {
+    AddrofNode *newAddrof = addrofNode->CloneTree(mirModule->GetCurFuncCodeMPAllocator());
+    CHECK_NULL_FATAL(newAddrof);
+    newAddrof->SetFieldID(newAddrof->GetFieldID() + fieldID);
+    result = newAddrof;
+  } else if (op == OP_iread) {
+    result = mirModule->CurFuncCodeMemPool()->New<AddrofNode>(
+          OP_dread, node->GetPrimType(), addrofNode->GetStIdx(), node->GetFieldID() + addrofNode->GetFieldID());
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+bool ConstantFold::IntegerOpIsOverflow(Opcode op, PrimType primType, int64 cstA, int64 cstB) {
+  switch (op) {
+    case OP_add: {
+      int64 res = static_cast<int64>(static_cast<uint64>(cstA) + static_cast<uint64>(cstB));
+      if (IsUnsignedInteger(primType)) {
+        return static_cast<uint64>(res) < static_cast<uint64>(cstA);
+      }
+      auto rightShiftNumToGetSignFlag = GetPrimTypeBitSize(primType) - 1;
+      return (static_cast<uint64>(res) >> rightShiftNumToGetSignFlag !=
+              static_cast<uint64>(cstA) >> rightShiftNumToGetSignFlag) &&
+             (static_cast<uint64>(res) >> rightShiftNumToGetSignFlag !=
+              static_cast<uint64>(cstB) >> rightShiftNumToGetSignFlag);
+    }
+    case OP_sub: {
+      if (IsUnsignedInteger(primType)) {
+        return cstA < cstB;
+      }
+      int64 res = static_cast<int64>(static_cast<uint64>(cstA) - static_cast<uint64>(cstB));
+      auto rightShiftNumToGetSignFlag = GetPrimTypeBitSize(primType) - 1;
+      return (static_cast<uint64>(cstA) >> rightShiftNumToGetSignFlag !=
+              static_cast<uint64>(cstB) >> rightShiftNumToGetSignFlag) &&
+             (static_cast<uint64>(res) >> rightShiftNumToGetSignFlag !=
+              static_cast<uint64>(cstA) >> rightShiftNumToGetSignFlag);
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldBinary(BinaryNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  std::optional<IntVal> sum = std::nullopt;
+  Opcode op = node->GetOpCode();
+  PrimType primType = node->GetPrimType();
+  PrimType lPrimTypes = node->Opnd(0)->GetPrimType();
+  PrimType rPrimTypes = node->Opnd(1)->GetPrimType();
+  std::pair<BaseNode*, std::optional<IntVal>> lp = DispatchFold(node->Opnd(0));
+  std::pair<BaseNode*, std::optional<IntVal>> rp = DispatchFold(node->Opnd(1));
+  BaseNode *l = lp.first;
+  BaseNode *r = rp.first;
+  ConstvalNode *lConst = safe_cast<ConstvalNode>(l);
+  ConstvalNode *rConst = safe_cast<ConstvalNode>(r);
+  bool isInt = IsPrimitiveInteger(primType);
+
+  if (lConst != nullptr && rConst != nullptr) {
+    MIRConst *lConstVal = lConst->GetConstVal();
+    MIRConst *rConstVal = rConst->GetConstVal();
+    ASSERT_NOT_NULL(lConstVal);
+    ASSERT_NOT_NULL(rConstVal);
+    // Don't fold div by 0, for floats div by 0 is well defined.
+    if ((op == OP_div || op == OP_rem) && isInt &&
+        !IsDivSafe(static_cast<MIRIntConst &>(*lConstVal), static_cast<MIRIntConst &>(*rConstVal), primType)) {
+      result = NewBinaryNode(node, op, primType, lConst, rConst);
+    } else {
+      // 4 + 2 -> return a pair(result = ConstValNode(6), sum = 0)
+      // Create a new ConstvalNode for 6 but keep the sum = 0. This simplify the
+      // logic since the alternative is to return pair(result = nullptr, sum = 6).
+      // Doing so would introduce many nullptr checks in the code. See previous
+      // commits that implemented that logic for a comparison.
+      result = FoldConstBinary(op, primType, *lConst, *rConst);
+    }
+  } else if (lConst != nullptr && isInt) {
+    MIRIntConst *mcst = safe_cast<MIRIntConst>(lConst->GetConstVal());
+    ASSERT_NOT_NULL(mcst);
+    PrimType cstTyp = mcst->GetType().GetPrimType();
+    IntVal cst = mcst->GetValue();
+    if (op == OP_add) {
+      sum = cst + rp.second;
+      result = r;
+    } else if (op == OP_sub && r->GetPrimType() != PTY_u1) {
+      // We exclude u1 type for fixing the following wrong example:
+      // before cf:
+      //   sub i32 (constval i32 17, eq u1 i32 (dread i32 %i, constval i32 16)))
+      // after cf:
+      //   add i32 (cvt i32 u1 (neg u1 (eq u1 i32 (dread i32 %i, constval i32 16))), constval i32 17))
+      sum = cst - rp.second;
+      result = NegateTree(r);
+    } else if ((op == OP_mul || op == OP_div || op == OP_rem || op == OP_ashr || op == OP_lshr || op == OP_shl ||
+                op == OP_band || op == OP_cand || op == OP_land) &&
+               cst == 0) {
+      // 0 * X -> 0
+      // 0 / X -> 0
+      // 0 % X -> 0
+      // 0 >> X -> 0
+      // 0 << X -> 0
+      // 0 & X -> 0
+      // 0 && X -> 0
+      result = mirModule->GetMIRBuilder()->CreateIntConst(0, cstTyp);
+    } else if (op == OP_mul && cst == 1) {
+      // 1 * X --> X
+      sum = rp.second;
+      result = r;
+    } else if (op == OP_bior && cst == -1) {
+      // (-1) | X -> -1
+      result = mirModule->GetMIRBuilder()->CreateIntConst(-1, cstTyp);
+    } else if (op == OP_mul && rp.second.has_value() && *rp.second != 0) {
+      // lConst * (X + konst) -> the pair [(lConst*X), (lConst*konst)]
+      sum = cst * rp.second;
+      if (GetPrimTypeSize(primType) > GetPrimTypeSize(rp.first->GetPrimType())) {
+        rp.first = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, primType, PTY_i32, rp.first);
+      }
+      result = NewBinaryNode(node, OP_mul, primType, lConst, rp.first);
+    } else if (op == OP_lior || op == OP_cior) {
+      if (cst != 0) {
+        // 5 || X -> 1
+        result = mirModule->GetMIRBuilder()->CreateIntConst(1, cstTyp);
+      } else {
+        // when cst is zero
+        // 0 || X -> (X != 0);
+        result = mirModule->CurFuncCodeMemPool()->New<CompareNode>(
+            OP_ne, primType, r->GetPrimType(), r, mirModule->GetMIRBuilder()->CreateIntConst(0, r->GetPrimType()));
+      }
+    } else if ((op == OP_cand || op == OP_land) && cst != 0) {
+      // 5 && X -> (X != 0)
+      result = mirModule->CurFuncCodeMemPool()->New<CompareNode>(
+          OP_ne, primType, r->GetPrimType(), r, mirModule->GetMIRBuilder()->CreateIntConst(0, r->GetPrimType()));
+    } else if ((op == OP_bior || op == OP_bxor) && cst == 0) {
+      // 0 | X -> X
+      // 0 ^ X -> X
+      sum = rp.second;
+      result = r;
+    } else {
+      result = NewBinaryNode(node, op, primType, l, PairToExpr(rPrimTypes, rp));
+    }
+    if (!IsNoCvtNeeded(result->GetPrimType(), primType)) {
+      result = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, primType, result->GetPrimType(), result);
+    }
+  } else if (rConst != nullptr && isInt) {
+    MIRIntConst *mcst = safe_cast<MIRIntConst>(rConst->GetConstVal());
+    ASSERT_NOT_NULL(mcst);
+    PrimType cstTyp = mcst->GetType().GetPrimType();
+    IntVal cst = mcst->GetValue();
+    if (op == OP_add) {
+      if (lp.second && IntegerOpIsOverflow(op, cstTyp, lp.second->GetExtValue(), cst.GetExtValue())) {
+        result = NewBinaryNode(node, op, primType, PairToExpr(lPrimTypes, lp), PairToExpr(rPrimTypes, rp));
+      } else {
+        result = l;
+        sum = lp.second + cst;
+      }
+    } else if (op == OP_sub && (!cst.IsSigned() || !cst.IsMinValue())) {
+      {
+        result = l;
+        sum = lp.second - cst;
+      }
+    } else if ((op == OP_mul || op == OP_band || op == OP_cand || op == OP_land) && cst == 0) {
+      // X * 0 -> 0
+      // X & 0 -> 0
+      // X && 0 -> 0
+      result = mirModule->GetMIRBuilder()->CreateIntConst(0, cstTyp);
+    } else if ((op == OP_mul || op == OP_div) && cst == 1) {
+      // case [X * 1 -> X]
+      // case [X / 1 = X]
+      sum = lp.second;
+      result = l;
+    } else if (op == OP_mul && lp.second.has_value() && *lp.second != 0 && lp.second->GetSXTValue() > -kMaxOffset) {
+      // (X + konst) * rConst -> the pair [(X*rConst), (konst*rConst)]
+      sum = lp.second * cst;
+      if (GetPrimTypeSize(primType) > GetPrimTypeSize(lp.first->GetPrimType())) {
+        lp.first = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, primType, PTY_i32, lp.first);
+      }
+      if (lp.first->GetOpCode() == OP_neg && cst == -1) {
+        // special case: ((-X) + konst) * (-1) -> the pair [(X), -konst]
+        result = lp.first->Opnd(0);
+      } else {
+        result = NewBinaryNode(node, OP_mul, primType, lp.first, rConst);
+      }
+    } else if (op == OP_band && cst == -1) {
+      // X & (-1) -> X
+      sum = lp.second;
+      result = l;
+    } else if (op == OP_band && ContiguousBitsOf1(cst.GetZXTValue()) && (!lp.second.has_value() || lp.second == 0)) {
+      bool fold2extractbits = false;
+      if (l->GetOpCode() == OP_ashr || l->GetOpCode() == OP_lshr) {
+        BinaryNode *shrNode = static_cast<BinaryNode *>(l);
+        if (shrNode->Opnd(1)->GetOpCode() == OP_constval) {
+          ConstvalNode *shrOpnd = static_cast<ConstvalNode *>(shrNode->Opnd(1));
+          int64 shrAmt = static_cast<MIRIntConst*>(shrOpnd->GetConstVal())->GetExtValue();
+          uint64 ucst = cst.GetZXTValue();
+          uint64 bsize = 0;
+          do {
+            bsize++;
+            ucst >>= 1;
+          } while (ucst != 0);
+          if (shrAmt + bsize <= GetPrimTypeSize(primType) * k8BitSize &&
+              static_cast<uint64>(shrAmt) < GetPrimTypeSize(primType) * k8BitSize) {
+            fold2extractbits = true;
+            // change to use extractbits
+            result = mirModule->GetMIRBuilder()->CreateExprExtractbits(OP_extractbits,
+                GetUnsignedPrimType(primType), shrAmt, bsize, shrNode->Opnd(0));
+            sum = std::nullopt;
+          }
+        }
+      }
+      if (!fold2extractbits) {
+        result = NewBinaryNode(node, op, primType, PairToExpr(lPrimTypes, lp), r);
+        sum = std::nullopt;
+      }
+    } else if (op == OP_bior && cst == -1) {
+      // X | (-1) -> -1
+      result = mirModule->GetMIRBuilder()->CreateIntConst(-1, cstTyp);
+    } else if ((op == OP_lior || op == OP_cior)) {
+      if (cst == 0) {
+        // X || 0 -> X
+        sum = lp.second;
+        result = l;
+      } else if (!cst.GetSignBit()) {
+        // X || 5 -> 1
+        result = mirModule->GetMIRBuilder()->CreateIntConst(1, cstTyp);
+      } else {
+        result = NewBinaryNode(node, op, primType, PairToExpr(lPrimTypes, lp), r);
+      }
+    } else if ((op == OP_ashr || op == OP_lshr || op == OP_shl || op == OP_bior || op == OP_bxor) && cst == 0) {
+      // X >> 0 -> X
+      // X << 0 -> X
+      // X | 0 -> X
+      // X ^ 0 -> X
+      sum = lp.second;
+      result = l;
+    } else if (op == OP_bxor && cst == 1 && primType != PTY_u1) {
+      // bxor i32 (
+      //   cvt i32 u1 (regread u1 %13),
+      //  constValue i32 1),
+      result = NewBinaryNode(node, op, primType, PairToExpr(lPrimTypes, lp), PairToExpr(rPrimTypes, rp));
+      if (l->GetOpCode() == OP_cvt && (!lp.second || lp.second == 0)) {
+        TypeCvtNode *cvtNode = static_cast<TypeCvtNode*>(l);
+        if (cvtNode->Opnd(0)->GetPrimType() == PTY_u1) {
+          BaseNode *base = cvtNode->Opnd(0);
+          BaseNode *constValue = mirModule->GetMIRBuilder()->CreateIntConst(1, base->GetPrimType());
+          std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(base);
+          BinaryNode *temp = NewBinaryNode(node, op, PTY_u1, PairToExpr(base->GetPrimType(), p), constValue);
+          result = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, primType, PTY_u1, temp);
+        }
+      }
+    } else if (op == OP_rem && cst == 1) {
+      // X % 1 -> 0
+      result = mirModule->GetMIRBuilder()->CreateIntConst(0, cstTyp);
+    } else {
+      result = NewBinaryNode(node, op, primType, PairToExpr(lPrimTypes, lp), r);
+    }
+    if (!IsNoCvtNeeded(result->GetPrimType(), primType)) {
+      result = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(OP_cvt, primType, result->GetPrimType(), result);
+    }
+  } else if (isInt && (op == OP_add || op == OP_sub)) {
+    if (op == OP_add) {
+      result = NewBinaryNode(node, op, primType, l, r);
+      sum = lp.second + rp.second;
+    } else if (node->Opnd(1)->GetOpCode() == OP_sub && r->GetOpCode() == OP_neg) {
+      // if fold is (x - (y - z))    ->     (x - neg(z)) - y
+      // (x - neg(z)) Could cross the int limit
+      // return node
+      result = node;
+    } else {
+      result = NewBinaryNode(node, op, primType, l, r);
+      sum = lp.second - rp.second;
+    }
+  } else {
+    result = NewBinaryNode(node, op, primType, PairToExpr(lPrimTypes, lp), PairToExpr(rPrimTypes, rp));
+  }
+  return std::make_pair(result, sum);
+}
+
+BaseNode *ConstantFold::SimplifyDoubleCompare(CompareNode &compareNode) const {
+  // See arm manual B.cond(P2993) and FCMP(P1091)
+  CompareNode *node = &compareNode;
+  BaseNode *result = node;
+  BaseNode *l = node->Opnd(0);
+  BaseNode *r = node->Opnd(1);
+  if (node->GetOpCode() == OP_ne || node->GetOpCode() == OP_eq) {
+    if (l->GetOpCode() == OP_cmp && r->GetOpCode() == OP_constval) {
+      ConstvalNode *constNode = static_cast<ConstvalNode*>(r);
+      if (constNode->GetConstVal()->GetKind() == kConstInt && constNode->GetConstVal()->IsZero()) {
+        const CompareNode *compNode = static_cast<CompareNode*>(l);
+        result = mirModule->CurFuncCodeMemPool()->New<CompareNode>(Opcode(node->GetOpCode()),
+                                                                   PrimType(node->GetPrimType()),
+                                                                   compNode->GetOpndType(),
+                                                                   compNode->Opnd(0),
+                                                                   compNode->Opnd(1));
+      }
+    } else if (r->GetOpCode() == OP_cmp && l->GetOpCode() == OP_constval) {
+      ConstvalNode *constNode = static_cast<ConstvalNode*>(l);
+      if (constNode->GetConstVal()->GetKind() == kConstInt && constNode->GetConstVal()->IsZero()) {
+        const CompareNode *compNode = static_cast<CompareNode*>(r);
+        result = mirModule->CurFuncCodeMemPool()->New<CompareNode>(Opcode(node->GetOpCode()),
+                                                                   PrimType(node->GetPrimType()),
+                                                                   compNode->GetOpndType(),
+                                                                   compNode->Opnd(0),
+                                                                   compNode->Opnd(1));
+      }
+    } else if (node->GetOpCode() == OP_ne && r->GetOpCode() == OP_constval) {
+      // ne (u1 x, constValue 0)  <==> x
+      ConstvalNode *constNode = static_cast<ConstvalNode*>(r);
+      if (constNode->GetConstVal()->GetKind() == kConstInt && constNode->GetConstVal()->IsZero()) {
+        BaseNode *opnd = l;
+        do {
+          if (opnd->GetPrimType() == PTY_u1 || (l->GetOpCode() == OP_ne || l->GetOpCode() == OP_eq)) {
+            result = opnd;
+            break;
+          } else if (opnd->GetOpCode() == OP_cvt) {
+            TypeCvtNode *cvtNode = static_cast<TypeCvtNode*>(opnd);
+            opnd = cvtNode->Opnd(0);
+          } else {
+            opnd = nullptr;
+          }
+        } while (opnd != nullptr);
+      }
+    } else if (node->GetOpCode() == OP_eq && r->GetOpCode() == OP_constval) {
+      ConstvalNode *constNode = static_cast<ConstvalNode*>(r);
+      if (constNode->GetConstVal()->GetKind() == kConstInt && constNode->GetConstVal()->IsZero() &&
+          (l->GetOpCode() == OP_ne || l->GetOpCode() == OP_eq)) {
+        result = l;
+        result->SetOpCode(l->GetOpCode() == OP_ne ? OP_eq : OP_ne);
+      }
+    }
+  } else if (node->GetOpCode() == OP_gt || node->GetOpCode() == OP_lt) {
+    if (l->GetOpCode() == OP_cmp && r->GetOpCode() == OP_constval) {
+      ConstvalNode *constNode = static_cast<ConstvalNode*>(r);
+      if (constNode->GetConstVal()->GetKind() == kConstInt && constNode->GetConstVal()->IsZero()) {
+        const CompareNode *compNode = static_cast<CompareNode*>(l);
+        result = mirModule->CurFuncCodeMemPool()->New<CompareNode>(Opcode(node->GetOpCode()),
+                                                                   PrimType(node->GetPrimType()),
+                                                                   compNode->GetOpndType(),
+                                                                   compNode->Opnd(0),
+                                                                   compNode->Opnd(1));
+      }
+    } else if (r->GetOpCode() == OP_cmp && l->GetOpCode() == OP_constval) {
+      ConstvalNode *constNode = static_cast<ConstvalNode*>(l);
+      if (constNode->GetConstVal()->GetKind() == kConstInt && constNode->GetConstVal()->IsZero()) {
+        const CompareNode *compNode = static_cast<CompareNode*>(r);
+        result = mirModule->CurFuncCodeMemPool()->New<CompareNode>(Opcode(node->GetOpCode()),
+                                                                   PrimType(node->GetPrimType()),
+                                                                   compNode->GetOpndType(),
+                                                                   compNode->Opnd(1),
+                                                                   compNode->Opnd(0));
+      }
+    }
+  }
+  return result;
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldCompare(CompareNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  std::pair<BaseNode*, std::optional<IntVal>> lp = DispatchFold(node->Opnd(0));
+  std::pair<BaseNode*, std::optional<IntVal>> rp = DispatchFold(node->Opnd(1));
+  ConstvalNode *lConst = safe_cast<ConstvalNode>(lp.first);
+  ConstvalNode *rConst = safe_cast<ConstvalNode>(rp.first);
+  Opcode opcode = node->GetOpCode();
+  if (lConst != nullptr && rConst != nullptr && !IsPrimitiveDynType(node->GetOpndType())) {
+    result = FoldConstComparison(node->GetOpCode(), node->GetPrimType(), node->GetOpndType(),
+                                 *lConst, *rConst);
+  } else if (lConst != nullptr && rConst == nullptr && opcode != OP_cmp &&
+             lConst->GetConstVal()->GetKind() == kConstInt) {
+    BaseNode *l = lp.first;
+    BaseNode *r = PairToExpr(node->Opnd(1)->GetPrimType(), rp);
+    result = FoldConstComparisonReverse(opcode, node->GetPrimType(), node->GetOpndType(),
+                                        *l, *r);
+  } else {
+    BaseNode *l = PairToExpr(node->Opnd(0)->GetPrimType(), lp);
+    BaseNode *r = PairToExpr(node->Opnd(1)->GetPrimType(), rp);
+    if (l != node->Opnd(0) || r != node->Opnd(1)) {
+      result = mirModule->CurFuncCodeMemPool()->New<CompareNode>(
+          Opcode(node->GetOpCode()), PrimType(node->GetPrimType()), PrimType(node->GetOpndType()), l, r);
+    } else {
+      result = node;
+    }
+    auto *compareNode = static_cast<CompareNode*>(result);
+    CHECK_NULL_FATAL(compareNode);
+    result = SimplifyDoubleCompare(*compareNode);
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+BaseNode *ConstantFold::Fold(BaseNode *node) {
+  if (node == nullptr || kOpcodeInfo.IsStmt(node->GetOpCode())) {
+    return nullptr;
+  }
+  std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(node);
+  BaseNode *result = PairToExpr(node->GetPrimType(), p);
+  if (result == node) {
+    result = nullptr;
+  }
+  return result;
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldDepositbits(DepositbitsNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  uint8 bitsOffset = node->GetBitsOffset();
+  uint8 bitsSize = node->GetBitsSize();
+  std::pair<BaseNode*, std::optional<IntVal>> leftPair = DispatchFold(node->Opnd(0));
+  std::pair<BaseNode*, std::optional<IntVal>> rightPair = DispatchFold(node->Opnd(1));
+  ConstvalNode *leftConst = safe_cast<ConstvalNode>(leftPair.first);
+  ConstvalNode *rightConst = safe_cast<ConstvalNode>(rightPair.first);
+  if (leftConst != nullptr && rightConst != nullptr) {
+    MIRIntConst *intConst0 = safe_cast<MIRIntConst>(leftConst->GetConstVal());
+    MIRIntConst *intConst1 = safe_cast<MIRIntConst>(rightConst->GetConstVal());
+    ASSERT_NOT_NULL(intConst0);
+    ASSERT_NOT_NULL(intConst1);
+    ConstvalNode *resultConst = mirModule->CurFuncCodeMemPool()->New<ConstvalNode>();
+    resultConst->SetPrimType(node->GetPrimType());
+    MIRType &type = *GlobalTables::GetTypeTable().GetPrimType(node->GetPrimType());
+    MIRIntConst *constValue =
+        GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, type);
+    uint64 op0ExtractVal = 0;
+    uint64 op1ExtractVal = 0;
+    uint64 mask0 = (1LLU << (bitsSize + bitsOffset)) - 1;
+    uint64 mask1 = (1LLU << bitsOffset) - 1;
+    uint64 op0Mask = ~(mask0 ^ mask1);
+    op0ExtractVal = (static_cast<uint64>(intConst0->GetExtValue()) & op0Mask);
+    op1ExtractVal = (static_cast<uint64>(intConst1->GetExtValue()) << bitsOffset) &
+                    ((1ULL << (bitsSize + bitsOffset)) - 1);
+    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        static_cast<int64>(op0ExtractVal | op1ExtractVal), constValue->GetType());
+    resultConst->SetConstVal(constValue);
+    result = resultConst;
+  } else {
+    BaseNode *l = PairToExpr(node->Opnd(0)->GetPrimType(), leftPair);
+    BaseNode *r = PairToExpr(node->Opnd(1)->GetPrimType(), rightPair);
+    if (l != node->Opnd(0) || r != node->Opnd(1)) {
+      result = mirModule->CurFuncCodeMemPool()->New<DepositbitsNode>(Opcode(node->GetOpCode()),
+                                                                     PrimType(node->GetPrimType()),
+                                                                     bitsOffset, bitsSize, l, r);
+    } else {
+      result = node;
+    }
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldArray(ArrayNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  size_t i = 0;
+  bool isFolded = false;
+  ArrayNode *arrNode =
+      mirModule->CurFuncCodeMemPool()->New<ArrayNode>(*mirModule,
+                                                      PrimType(node->GetPrimType()),
+                                                      node->GetTyIdx(),
+                                                      node->GetBoundsCheck());
+  for (i = 0; i < node->GetNopndSize(); i++) {
+    std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(node->GetNopndAt(i));
+    BaseNode *tmpNode = PairToExpr(node->GetNopndAt(i)->GetPrimType(), p);
+    if (tmpNode != node->GetNopndAt(i)) {
+      isFolded = true;
+    }
+    arrNode->GetNopnd().push_back(tmpNode);
+    arrNode->SetNumOpnds(arrNode->GetNumOpnds() + 1);
+  }
+  if (isFolded) {
+    result = arrNode;
+  } else {
+    result = node;
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+std::pair<BaseNode*, std::optional<IntVal>> ConstantFold::FoldTernary(TernaryNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = node;
+  std::vector<PrimType> primTypes;
+  std::vector<std::pair<BaseNode*, std::optional<IntVal>>> p;
+  for (size_t i = 0; i < node->NumOpnds(); i++) {
+    BaseNode *tempNopnd = node->Opnd(i);
+    CHECK_NULL_FATAL(tempNopnd);
+    primTypes.push_back(tempNopnd->GetPrimType());
+    p.push_back(DispatchFold(tempNopnd));
+  }
+  if (node->GetOpCode() == OP_select) {
+    ConstvalNode *const0 = safe_cast<ConstvalNode>(p[0].first);
+    if (const0 != nullptr) {
+      MIRIntConst *intConst0 = safe_cast<MIRIntConst>(const0->GetConstVal());
+      ASSERT_NOT_NULL(intConst0);
+      // Selecting the first value if not 0, selecting the second value otherwise.
+      if (!intConst0->IsZero()) {
+        result = PairToExpr(primTypes[1], p[1]);
+      } else {
+        result = PairToExpr(primTypes[2], p[2]);
+      }
+    } else {
+      ConstvalNode *const1 = safe_cast<ConstvalNode>(p[1].first);
+      ConstvalNode *const2 = safe_cast<ConstvalNode>(p[2].first);
+      if (const1 != nullptr && const2 != nullptr) {
+        MIRIntConst *intConst1 = safe_cast<MIRIntConst>(const1->GetConstVal());
+        MIRIntConst *intConst2 = safe_cast<MIRIntConst>(const2->GetConstVal());
+        double dconst1 = 0.0;
+        double dconst2 = 0.0;
+        // for fpconst
+        if (intConst1 == nullptr || intConst2 == nullptr) {
+          PrimType ptyp = const1->GetPrimType();
+          if (ptyp == PTY_f64) {
+            MIRDoubleConst *dConst1 = safe_cast<MIRDoubleConst>(const1->GetConstVal());
+            dconst1 = dConst1->GetValue();
+            MIRDoubleConst *dConst2 = safe_cast<MIRDoubleConst>(const2->GetConstVal());
+            dconst2 = dConst2->GetValue();
+          } else if (ptyp == PTY_f32) {
+            MIRFloatConst *fConst1 = safe_cast<MIRFloatConst>(const1->GetConstVal());
+            dconst1 = static_cast<double>(fConst1->GetFloatValue());
+            MIRFloatConst *fConst2 = safe_cast<MIRFloatConst>(const2->GetConstVal());
+            dconst2 = static_cast<double>(fConst2->GetFloatValue());
+          }
+        } else {
+          dconst1 = static_cast<double>(intConst1->GetExtValue());
+          dconst2 = static_cast<double>(intConst2->GetExtValue());
+        }
+        PrimType foldedPrimType = primTypes[1];
+        if (!IsPrimitiveInteger(foldedPrimType)) {
+          foldedPrimType = primTypes[2];
+        }
+        if (dconst1 == 1.0 && dconst2 == 0.0) {
+          if (IsPrimitiveInteger(foldedPrimType)) {
+            result = PairToExpr(foldedPrimType, p[0]);
+          } else {
+            result = PairToExpr(primTypes[0], p[0]);
+            result = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(
+                OP_cvt, foldedPrimType, primTypes[0], result);
+          }
+          return std::make_pair(result, std::nullopt);
+        }
+        if (dconst1 == 0.0 && dconst2 == 1.0) {
+          BaseNode *lnot = mirModule->CurFuncCodeMemPool()->New<CompareNode>(
+              OP_eq, primTypes[0], primTypes[0], PairToExpr(primTypes[0], p[0]),
+              mirModule->GetMIRBuilder()->CreateIntConst(0, primTypes[0]));
+          std::pair<BaseNode*, std::optional<IntVal>> pairTemp = DispatchFold(lnot);
+          if (IsPrimitiveInteger(foldedPrimType)) {
+            result = PairToExpr(foldedPrimType, pairTemp);
+          } else {
+            result = PairToExpr(primTypes[0], pairTemp);
+            result = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(
+                OP_cvt, foldedPrimType, primTypes[0], result);
+          }
+          return std::make_pair(result, std::nullopt);
+        }
+      }
+    }
+  }
+  BaseNode *e0 = PairToExpr(primTypes[0], p[0]);
+  BaseNode *e1 = PairToExpr(primTypes[1], p[1]);
+  BaseNode *e2 = PairToExpr(primTypes[2], p[2]); // count up to 3 for ternary node
+  if (e0 != node->Opnd(0) || e1 != node->Opnd(1) || e2 != node->Opnd(2)) {
+    result = mirModule->CurFuncCodeMemPool()->New<TernaryNode>(Opcode(node->GetOpCode()),
+                                                                PrimType(node->GetPrimType()),
+                                                                e0, e1, e2);
+  }
+  return std::make_pair(result, std::nullopt);
+}
+
+StmtNode *ConstantFold::SimplifyDassign(DassignNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue = nullptr;
+  returnValue = Fold(node->GetRHS());
+  if (returnValue != nullptr) {
+    node->SetRHS(returnValue);
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyIassignWithAddrofBaseNode(IassignNode &node, const AddrofNode &base) {
+  auto *mirTypeOfIass = GlobalTables::GetTypeTable().GetTypeFromTyIdx(node.GetTyIdx());
+  if (!mirTypeOfIass->IsMIRPtrType()) {
+    return &node;
+  }
+  auto *iassPtType = static_cast<MIRPtrType*>(mirTypeOfIass);
+
+  MIRSymbol *lhsSym = mirModule->CurFunction()->GetLocalOrGlobalSymbol(base.GetStIdx());
+  TyIdx lhsTyIdx = lhsSym->GetTyIdx();
+  if (base.GetFieldID() != 0) {
+    auto *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsTyIdx);
+    if (!mirType->IsStructType()) {
+      return &node;
+    }
+    lhsTyIdx = static_cast<MIRStructType*>(mirType)->GetFieldType(base.GetFieldID())->GetTypeIndex();
+  }
+  if (iassPtType->GetPointedTyIdx() == lhsTyIdx) {
+    DassignNode *dassignNode = mirModule->CurFuncCodeMemPool()->New<DassignNode>();
+    dassignNode->SetStIdx(base.GetStIdx());
+    dassignNode->SetRHS(node.GetRHS());
+    dassignNode->SetFieldID(base.GetFieldID() + node.GetFieldID());
+    // reuse stmtid to maintain stmtFreqs if profileUse is on
+    dassignNode->SetStmtID(node.GetStmtID());
+    return dassignNode;
+  }
+  return &node;
+}
+
+StmtNode *ConstantFold::SimplifyIassignWithIaddrofBaseNode(IassignNode &node, const IaddrofNode &base) {
+  auto *mirTypeOfIass = GlobalTables::GetTypeTable().GetTypeFromTyIdx(node.GetTyIdx());
+  if (!mirTypeOfIass->IsMIRPtrType()) {
+    return &node;
+  }
+  auto *iassPtType = static_cast<MIRPtrType*>(mirTypeOfIass);
+
+  if (base.GetFieldID() == 0) {
+    // this iaddrof is redundant
+    node.SetAddrExpr(base.Opnd(0));
+    return &node;
+  }
+
+  auto *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(base.GetTyIdx());
+  if (!mirType->IsMIRPtrType()) {
+    return &node;
+  }
+  auto *iaddrofPtType = static_cast<MIRPtrType*>(mirType);
+
+  MIRStructType *lhsStructTy =
+    static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iaddrofPtType->GetPointedTyIdx()));
+  TyIdx lhsTyIdx = lhsStructTy->GetFieldType(base.GetFieldID())->GetTypeIndex();
+  if (iassPtType->GetPointedTyIdx() == lhsTyIdx) {
+    // eliminate the iaddrof by updating the iassign's fieldID and tyIdx
+    node.SetFieldID(node.GetFieldID() + base.GetFieldID());
+    node.SetTyIdx(base.GetTyIdx());
+    node.SetOpnd(base.Opnd(0), 0);
+    // recursive call for the new iassign
+    return SimplifyIassign(&node);
+  }
+  return &node;
+}
+
+StmtNode *ConstantFold::SimplifyIassign(IassignNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue = nullptr;
+  returnValue = Fold(node->Opnd(0));
+  if (returnValue != nullptr) {
+    node->SetOpnd(returnValue, 0);
+  }
+  returnValue = Fold(node->GetRHS());
+  if (returnValue != nullptr) {
+    node->SetRHS(returnValue);
+  }
+  auto *mirTypeOfIass = GlobalTables::GetTypeTable().GetTypeFromTyIdx(node->GetTyIdx());
+  if (!mirTypeOfIass->IsMIRPtrType()) {
+    return node;
+  }
+
+  auto *opnd = node->Opnd(0);
+  ASSERT_NOT_NULL(opnd);
+  switch (opnd->GetOpCode()) {
+    case OP_addrof: {
+      return SimplifyIassignWithAddrofBaseNode(*node, static_cast<AddrofNode&>(*opnd));
+    }
+    case OP_iaddrof: {
+      return SimplifyIassignWithIaddrofBaseNode(*node, static_cast<IreadNode&>(*opnd));
+    }
+    default:
+      break;
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyCondGoto(CondGotoNode *node) {
+  CHECK_NULL_FATAL(node);
+  // optimize condgoto need to update frequency, skip here
+  if (Options::profileUse && mirModule->CurFunction()->GetFuncProfData()) {
+    return node;
+  }
+  BaseNode *returnValue = nullptr;
+  returnValue = Fold(node->Opnd(0));
+  returnValue = (returnValue == nullptr) ? node : returnValue;
+  if (returnValue == node && node->Opnd(0)->GetOpCode() == OP_select) {
+    return SimplifyCondGotoSelect(node);
+  } else {
+    if (returnValue != node) {
+      node->SetOpnd(returnValue, 0);
+    }
+    ConstvalNode *cst = safe_cast<ConstvalNode>(node->Opnd(0));
+    if (cst == nullptr) {
+      return node;
+    }
+    MIRIntConst *intConst = safe_cast<MIRIntConst>(cst->GetConstVal());
+    ASSERT_NOT_NULL(intConst);
+    if ((node->GetOpCode() == OP_brtrue && !intConst->IsZero()) ||
+        (node->GetOpCode() == OP_brfalse && intConst->IsZero())) {
+      uint32 freq = mirModule->CurFunction()->GetFreqFromLastStmt(node->GetStmtID());
+      GotoNode *gotoNode = mirModule->CurFuncCodeMemPool()->New<GotoNode>(OP_goto);
+      gotoNode->SetOffset(node->GetOffset());
+      if (Options::profileUse && mirModule->CurFunction()->GetFuncProfData()) {
+        gotoNode->SetStmtID(node->GetStmtID()); // reuse condnode stmtid
+      }
+      mirModule->CurFunction()->SetLastFreqMap(gotoNode->GetStmtID(), freq);
+      return gotoNode;
+    } else {
+      return nullptr;
+    }
+  }
+}
+
+StmtNode *ConstantFold::SimplifyCondGotoSelect(CondGotoNode *node) const {
+  CHECK_NULL_FATAL(node);
+  TernaryNode *sel = static_cast<TernaryNode*>(node->Opnd(0));
+  if (sel == nullptr || sel->GetOpCode() != OP_select) {
+    return node;
+  }
+  ConstvalNode *const1 = safe_cast<ConstvalNode>(sel->Opnd(1));
+  ConstvalNode *const2 = safe_cast<ConstvalNode>(sel->Opnd(2));
+  if (const1 != nullptr && const2 != nullptr) {
+    MIRIntConst *intConst1 = safe_cast<MIRIntConst>(const1->GetConstVal());
+    MIRIntConst *intConst2 = safe_cast<MIRIntConst>(const2->GetConstVal());
+    ASSERT_NOT_NULL(intConst1);
+    ASSERT_NOT_NULL(intConst2);
+    if (intConst1->GetValue() == 1 && intConst2->GetValue() == 0) {
+      node->SetOpnd(sel->Opnd(0), 0);
+    } else if (intConst1->GetValue() == 0 && intConst2->GetValue() == 1) {
+      node->SetOpCode((node->GetOpCode() == OP_brfalse) ? OP_brtrue : OP_brfalse);
+      node->SetOpnd(sel->Opnd(0), 0);
+    }
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifySwitch(SwitchNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue = nullptr;
+  returnValue = Fold(node->GetSwitchOpnd());
+  if (returnValue != nullptr) {
+    node->SetSwitchOpnd(returnValue);
+    ConstvalNode *cst = safe_cast<ConstvalNode>(node->GetSwitchOpnd());
+    if (cst == nullptr) {
+      return node;
+    }
+    MIRIntConst *intConst = safe_cast<MIRIntConst>(cst->GetConstVal());
+    ASSERT_NOT_NULL(intConst);
+    GotoNode *gotoNode = mirModule->CurFuncCodeMemPool()->New<GotoNode>(OP_goto);
+    bool isdefault = true;
+    for (unsigned i = 0; i < node->GetSwitchTable().size(); i++) {
+      if (node->GetCasePair(i).first == intConst->GetValue()) {
+        isdefault = false;
+        gotoNode->SetOffset(static_cast<LabelIdx>(node->GetCasePair(i).second));
+        break;
+      }
+    }
+    if (isdefault) {
+      gotoNode->SetOffset(node->GetDefaultLabel());
+    }
+    return gotoNode;
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyUnary(UnaryStmtNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue = nullptr;
+  if (node->Opnd(0) == nullptr) {
+    return node;
+  }
+  returnValue = Fold(node->Opnd(0));
+  if (returnValue != nullptr) {
+    node->SetOpnd(returnValue, 0);
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyBinary(BinaryStmtNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue = nullptr;
+  returnValue = Fold(node->GetBOpnd(0));
+  if (returnValue != nullptr) {
+    node->SetBOpnd(returnValue, 0);
+  }
+  returnValue = Fold(node->GetBOpnd(1));
+  if (returnValue != nullptr) {
+    node->SetBOpnd(returnValue, 1);
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyBlock(BlockNode *node) {
+  CHECK_NULL_FATAL(node);
+  if (node->GetFirst() == nullptr) {
+    return node;
+  }
+  StmtNode *s = node->GetFirst();
+  StmtNode *prevStmt = nullptr;
+  do {
+    StmtNode *returnValue = Simplify(s);
+    if (returnValue != nullptr) {
+      if (returnValue->GetOpCode() == OP_block) {
+        BlockNode *blk = static_cast<BlockNode*>(returnValue);
+        node->ReplaceStmtWithBlock(*s, *blk);
+      } else {
+        node->ReplaceStmt1WithStmt2(s, returnValue);
+      }
+      prevStmt = s;
+      s = s->GetNext();
+    } else {
+      // delete s from block
+      StmtNode *nextStmt = s->GetNext();
+      if (s == node->GetFirst()) {
+        node->SetFirst(nextStmt);
+        if (nextStmt != nullptr) {
+          nextStmt->SetPrev(nullptr);
+        }
+      } else {
+        CHECK_NULL_FATAL(prevStmt);
+        prevStmt->SetNext(nextStmt);
+        if (nextStmt != nullptr) {
+          nextStmt->SetPrev(prevStmt);
+        }
+      }
+      if (s == node->GetLast()) {
+        node->SetLast(prevStmt);
+      }
+      s = nextStmt;
+    }
+  } while (s != nullptr);
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyAsm(AsmNode* node) {
+  CHECK_NULL_FATAL(node);
+  /* fold constval in input */
+  for (size_t i = 0; i < node->NumOpnds(); i++) {
+    const std::string &str = GlobalTables::GetUStrTable().GetStringFromStrIdx(node->inputConstraints[i]);
+    if (str == "i") {
+      std::pair<BaseNode*, std::optional<IntVal>> p = DispatchFold(node->Opnd(i));
+      node->SetOpnd(p.first, i);
+      continue;
+    }
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyIf(IfStmtNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue = nullptr;
+  (void)Simplify(node->GetThenPart());
+  if (node->GetElsePart()) {
+    (void)Simplify(node->GetElsePart());
+  }
+  returnValue = Fold(node->Opnd());
+  if (returnValue != nullptr) {
+    node->SetOpnd(returnValue, 0);
+    ConstvalNode *cst = safe_cast<ConstvalNode>(node->Opnd());
+    // do not delete c/c++ dead if-body here
+    if (cst == nullptr || (!mirModule->IsJavaModule())) {
+      return node;
+    }
+    MIRIntConst *intConst = safe_cast<MIRIntConst>(cst->GetConstVal());
+    ASSERT_NOT_NULL(intConst);
+    if (intConst->GetValue() == 0) {
+      return node->GetElsePart();
+    } else {
+      return node->GetThenPart();
+    }
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyWhile(WhileStmtNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue = nullptr;
+  if (node->Opnd(0) == nullptr) {
+    return node;
+  }
+  if (node->GetBody()) {
+    (void)Simplify(node->GetBody());
+  }
+  returnValue = Fold(node->Opnd(0));
+  if (returnValue != nullptr) {
+    node->SetOpnd(returnValue, 0);
+    ConstvalNode *cst = safe_cast<ConstvalNode>(node->Opnd(0));
+    // do not delete c/c++ dead while-body here
+    if (cst == nullptr || (!mirModule->IsJavaModule())) {
+      return node;
+    }
+    if (cst->GetConstVal()->IsZero()) {
+      if (node->GetOpCode() == OP_while) {
+        return nullptr;
+      } else {
+        return node->GetBody();
+      }
+    }
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyNary(NaryStmtNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue = nullptr;
+  for (size_t i = 0; i < node->NumOpnds(); i++) {
+    returnValue = Fold(node->GetNopndAt(i));
+    if (returnValue != nullptr) {
+      node->SetNOpndAt(i, returnValue);
+    }
+  }
+  return node;
+}
+
+StmtNode *ConstantFold::SimplifyIcall(IcallNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue = nullptr;
+  for (size_t i = 0; i < node->NumOpnds(); i++) {
+    returnValue = Fold(node->GetNopndAt(i));
+    if (returnValue != nullptr) {
+      node->SetNOpndAt(i, returnValue);
+    }
+  }
+  // icall node transform to call node
+  CHECK_FATAL(!node->GetNopnd().empty(), "container check");
+  switch (node->GetNopndAt(0)->GetOpCode()) {
+    case OP_addroffunc: {
+      AddroffuncNode *addrofNode = static_cast<AddroffuncNode*>(node->GetNopndAt(0));
+      CallNode *callNode =
+          mirModule->CurFuncCodeMemPool()->New<CallNode>(*mirModule,
+             (node->GetOpCode() == OP_icall || node->GetOpCode() == OP_icallproto) ? OP_call : OP_callassigned);
+      if (node->GetOpCode() == OP_icallassigned || node->GetOpCode() == OP_icallprotoassigned) {
+        callNode->SetReturnVec(node->GetReturnVec());
+      }
+      callNode->SetPUIdx(addrofNode->GetPUIdx());
+      for (size_t i = 1; i < node->GetNopndSize(); i++) {
+        callNode->GetNopnd().push_back(node->GetNopndAt(i));
+      }
+      callNode->SetNumOpnds(callNode->GetNopndSize());
+      // reuse stmtID to skip update stmtFreqs when profileUse is on
+      callNode->SetStmtID(node->GetStmtID());
+      return callNode;
+    }
+    default:
+      break;
+  }
+  return node;
+}
+
+void ConstantFold::ProcessFunc(MIRFunction *func) {
+  if (func->IsEmpty()) {
+    return;
+  }
+  mirModule->SetCurFunction(func);
+  (void)Simplify(func->GetBody());
+}
+
+void M2MConstantFold::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+
+bool M2MConstantFold::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(ConstantFold, m);
+  if (MeOption::meVerify) {
+    VerifyGlobalTypeTable();
+  }
+  return true;
+}
+
+// an interval of [lower, upper)
+// particularly, when lower = upper = INT_MAX, it represent for a single INT_MAX
+class ConstIntSet {
+ public:
+  void DoNegation() {
+    if (isEmpty || isFull) {
+      std::swap(isEmpty, isFull);
+    } else if (lower.IsMinValue()) {
+      lower = upper;
+      upper.SetMaxValue();
+    } else if (upper.IsMaxValue()) {
+      upper = lower;
+      lower.SetMinValue();
+    } else {
+      std::swap(lower, upper);
+    }
+  }
+
+  IntVal lower;
+  IntVal upper;
+  bool isFull = false;
+  bool isEmpty = false;
+};
+
+// generate an interval from meExpr
+std::optional<ConstIntSet> GenerateIntSet(const OpMeExpr &meExpr, PrimType type) {
+  auto opnd1 = meExpr.GetOpnd(1);
+  auto intVal = static_cast<ConstMeExpr *>(opnd1)->GetIntValue().TruncOrExtend(type);
+  auto res = std::make_optional<ConstIntSet>();
+  bool isSigned = intVal.IsSigned();
+  uint8 width = intVal.GetBitWidth();
+  switch (meExpr.GetOp()) {
+    case OP_lt:
+      if (intVal.IsMinValue()) {
+        res->isEmpty = true;
+      } else {
+        res->lower.SetMinValue(isSigned, width);
+        res->upper = intVal;
+      }
+      break;
+    case OP_le:
+      if (intVal.IsMaxValue()) {
+        res->isFull = true;
+      } else {
+        res->lower.SetMinValue(isSigned, width);
+        res->upper = intVal + 1;
+      }
+      break;
+    case OP_gt:
+      if (intVal.IsMaxValue()) {
+        res->isEmpty = true;
+      } else {
+        res->lower = intVal + 1;
+        res->upper.SetMaxValue(isSigned, width);
+      }
+      break;
+    case OP_ge:
+      if (intVal.IsMinValue()) {
+        res->isFull = true;
+      } else {
+        res->lower = intVal;
+        res->upper.SetMaxValue(isSigned, width);
+      }
+      break;
+    case OP_eq:
+      res->lower = intVal;
+      res->upper = intVal.IsMaxValue() ? intVal : intVal + 1;
+      break;
+    case OP_ne:
+      if (intVal.IsMaxValue()) {
+        res->lower.SetMinValue(isSigned, width);
+      } else {
+        res->lower = intVal + 1;
+      }
+      res->upper = intVal;
+      break;
+    default:
+      CHECK_FATAL(false, "unexpected op");
+      break;
+  }
+  return res;
+}
+
+// calculate union of two interval
+std::optional<ConstIntSet> Union(ConstIntSet s1, ConstIntSet s2) {
+  std::optional<ConstIntSet> s3 = std::make_optional<ConstIntSet>();
+  if (s1.isFull || s2.isFull) {
+    s3->isFull = true;
+    return s3;
+  }
+  if (s1.isEmpty || s2.isEmpty) {
+    s3 = s1.isEmpty ? s2 : s1;
+    return s3;
+  }
+
+  if (s2.lower > s2.upper || s1.upper.IsMaxValue()) {
+    std::swap(s1, s2);
+  }
+
+  if (s2.lower == s2.upper && s2.upper.IsMaxValue()) {
+    if (s1.upper == s2.upper || s1.upper + 1 == s2.upper) {
+      s3->upper = s2.upper;
+      s3->lower = s1.lower;
+      return s3;
+    }
+    return std::nullopt;
+  }
+
+  if (s1.lower.IsMinValue() && s2.upper.IsMaxValue()) {
+    // ----l
+    //        u----
+    s3->upper = s1.upper;
+    s3->lower = s2.lower;
+    if (s3->lower <= s3->upper) {
+      // ----l
+      //   u----
+      s3->isFull = true;
+    }
+    return s3;
+  }
+  if (s1.lower < s1.upper && s2.lower < s2.upper) {
+    if (s1.upper < s2.lower || s1.lower > s2.upper) {
+      // l------u
+      //            l------u
+      // not continuous, return null
+      return std::nullopt;
+    } else {
+      // l------u
+      //    l------u
+      s3->lower = std::min(s1.lower, s2.lower);
+      s3->upper = std::max(s1.upper, s2.upper);
+    }
+  } else if (s1.lower > s1.upper && s2.lower < s2.upper) {
+    if (s2.upper <= s1.upper || s2.lower >= s1.lower) {
+      //       ---u  l---
+      // l------u      l------u
+      s3 = s1;
+    } else if (s2.lower <= s1.upper && s2.upper >= s1.lower) {
+      //  ---u   l---
+      //   l------u
+      s3->isFull = true;
+    } else if (s2.lower > s1.upper && s2.upper >= s1.lower) {
+      // ---u    l---
+      //       l------u
+      s3->lower = s2.lower;
+      s3->upper = s1.upper;
+    } else if (s2.lower <= s1.upper && s2.upper < s1.lower) {
+      //   ---u    l---
+      //  l------u
+      s3->lower = s1.lower;
+      s3->upper = s2.upper;
+    } else {
+      // not continuous, return null
+      return std::nullopt;
+    }
+  } else if (s1.lower > s1.upper && s2.lower > s2.upper) {
+    if (s2.lower <= s1.upper || s2.upper >= s1.lower) {
+      // ---u l---             ---u l---
+      //    ---u l---     ---u l---
+      s3->isFull = true;
+    } else {
+      s3->lower = std::min(s1.lower, s2.lower);
+      s3->upper = std::max(s1.upper, s2.upper);
+    }
+  }
+  return s3;
+}
+
+// generate a MeExpr according to the interval @s and use @value as the first opnd
+MeExpr *IntSet2MeExpr(IRMap &irMap, MeExpr &value, const ConstIntSet &s) {
+  if (s.isFull) {
+    return irMap.CreateIntConstMeExpr(1, PTY_u1);
+  }
+  if (s.isEmpty) {
+    return irMap.CreateIntConstMeExpr(0, PTY_u1);
+  }
+  auto primType = value.GetPrimType();
+  auto lowerValExpr = irMap.CreateIntConstMeExpr(s.lower, primType);
+  auto upperValExpr = irMap.CreateIntConstMeExpr(s.upper, primType);
+  if (s.upper == s.lower + 1) {
+    return irMap.CreateMeExprCompare(OP_eq, PTY_u1, primType, value, *lowerValExpr);
+  }
+  if (s.lower == s.upper + 1) {
+    return irMap.CreateMeExprCompare(OP_ne, PTY_u1, primType, value, *upperValExpr);
+  }
+  if (s.lower.IsMinValue()) {
+    return irMap.CreateMeExprCompare(OP_lt, PTY_u1, primType, value, *upperValExpr);
+  }
+  if (s.upper.IsMaxValue()) {
+    return irMap.CreateMeExprCompare(OP_ge, PTY_u1, primType, value, *lowerValExpr);
+  }
+  MeExpr *newValue = nullptr;
+  MeExpr *newConstVal = nullptr;
+  Opcode op;
+  if (s.upper >= s.lower + 1) {
+    newValue = irMap.CreateMeExprBinary(OP_sub, primType, value, *lowerValExpr);
+    newConstVal = irMap.CreateIntConstMeExpr(s.upper - s.lower - 1, primType);
+    op = OP_le;
+  } else {
+    newValue = irMap.CreateMeExprBinary(OP_sub, primType, value, *upperValExpr);
+    newConstVal = irMap.CreateIntConstMeExpr(s.lower - s.upper, primType);
+    op = OP_ge;
+  }
+  return irMap.CreateMeExprCompare(op, PTY_u1, GetUnsignedPrimType(primType), *newValue, *newConstVal);
+}
+
+static bool CmpFoldCondCHeck(const MeExpr &cmp1, const MeExpr &cmp2) {
+  if (!IsCompareHasReverseOp(cmp1.GetOp()) || !IsCompareHasReverseOp(cmp2.GetOp())) {
+    return false;
+  }
+  // the first opnd of cmp1 and cmp2 must be same
+  if (cmp1.GetOpnd(0) != cmp2.GetOpnd(0)) {
+    return false;
+  }
+  if (!IsPrimitiveInteger(cmp1.GetOpnd(0)->GetPrimType())) {
+    return false;
+  }
+  if (cmp1.GetOpnd(kSecondOpnd)->GetMeOp() != kMeOpConst || cmp2.GetOpnd(kSecondOpnd)->GetMeOp() != kMeOpConst) {
+    return false;
+  }
+  return true;
+}
+
+// fold and/or of two compare exprs to one if possible
+// for example:
+// cmp (v, n1) && cmp (v, n2) -> cmp (v', n3)
+MeExpr *ConstantFold::FoldCmpExpr(IRMap &irMap, const MeExpr &cmp1, const MeExpr &cmp2, bool isAnd) {
+  if (!CmpFoldCondCHeck(cmp1, cmp2)) {
+    return nullptr;
+  }
+  auto value = cmp1.GetOpnd(0);
+  auto type = value->GetPrimType();
+  auto constValType = cmp1.GetOpnd(1)->GetPrimType();
+  if (type != constValType && IsUnsignedInteger(constValType)) {
+    type = constValType;
+  }
+  auto s1 = GenerateIntSet(static_cast<const OpMeExpr &>(cmp1), type);
+  auto s2 = GenerateIntSet(static_cast<const OpMeExpr &>(cmp2), type);
+  if (!s1 || !s2) {
+    return nullptr;
+  }
+  if (s1->lower.IsSigned() != s2->lower.IsSigned()) {
+    return nullptr;
+  }
+  // if foldType is AND, we could do union instead of intersection
+  if (isAnd) {
+    s1->DoNegation();
+    s2->DoNegation();
+  }
+  auto s3 = Union(*s1, *s2);
+  if (!s3) {
+    // s3 is not continuous, the size of s1 and s2 must be same
+    if (s1->upper - s1->lower != s2->upper - s2->lower) {
+      return nullptr;
+    }
+    if (s1->lower >= s1->upper || s2->lower >= s2->upper) {
+      return nullptr;
+    }
+    if (s1->lower.GetZXTValue() > s2->lower.GetZXTValue()) {
+      std::swap(s1, s2);
+    }
+    auto diff = s2->lower - s1->lower;
+    // if diff is power of 2, there may be only one bit difference between the second opnd of cmp1 and cmp2
+    if (!diff.IsPowerOf2()) {
+      return nullptr;
+    }
+    IntVal offset(0, type);
+    if ((s1->lower ^ diff) != s2->lower) {
+      offset = s1->lower;
+    }
+    s3 = std::make_optional<ConstIntSet>();
+    s3->lower = s1->lower - offset;
+    s3->upper = s1->upper - offset;
+    value = irMap.CreateMeExprBinary(OP_sub, type, *value, *irMap.CreateIntConstMeExpr(offset, type));
+    value = irMap.CreateMeExprBinary(OP_band, type, *value, *irMap.CreateIntConstMeExpr(~diff, type));
+  }
+  if (isAnd) {
+    s3->DoNegation();
+  }
+  return IntSet2MeExpr(irMap, *value, *s3);
+}
+
+MeExpr *ConstantFold::FoldOrOfAnds(IRMap &irMap, const MeExpr &and1, const MeExpr &and2) {
+  if (and1.GetOp() != and2.GetOp() || and1.GetOp() != OP_band) {
+    return nullptr;
+  }
+  if (and1.GetOpnd(0) != and2.GetOpnd(0)) {
+    return nullptr;
+  }
+  if (and1.GetOpnd(1)->GetMeOp() != kMeOpConst || and2.GetOpnd(1)->GetMeOp() != kMeOpConst) {
+    return nullptr;
+  }
+  auto value = and1.GetOpnd(0);
+  auto c1 = static_cast<ConstMeExpr*>(and1.GetOpnd(1))->GetIntValue();
+  auto c2 = static_cast<ConstMeExpr*>(and2.GetOpnd(1))->GetIntValue();
+  auto c3 = c1 | c2;
+  return irMap.CreateMeExprBinary(OP_band, value->GetPrimType(), *value,
+                                  *irMap.CreateIntConstMeExpr(c3, value->GetPrimType()));
+}
+
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/ext_constantfold.cpp b/src/mapleall/mpl2mpl/src/ext_constantfold.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eef1c3cd092459f48c5fa7dd12e2943d5a365d2e
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/ext_constantfold.cpp
@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) [2021] Futurewei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ext_constantfold.h"
+#include <climits>
+
+namespace maple {
+// This class is designed to further identify simplification
+// patterns that have not been covered in ConstantFold.
+
+StmtNode *ExtConstantFold::ExtSimplify(StmtNode *node) {
+  CHECK_NULL_FATAL(node);
+  switch (node->GetOpCode()) {
+    case OP_block:
+      return ExtSimplifyBlock(static_cast<BlockNode*>(node));
+    case OP_if:
+      return ExtSimplifyIf(static_cast<IfStmtNode*>(node));
+    case OP_dassign:
+      return ExtSimplifyDassign(static_cast<DassignNode*>(node));
+    case OP_iassign:
+      return ExtSimplifyIassign(static_cast<IassignNode*>(node));
+    case OP_dowhile:
+    case OP_while:
+      return ExtSimplifyWhile(static_cast<WhileStmtNode*>(node));
+    default:
+      return node;
+  }
+}
+
+BaseNode* ExtConstantFold::DispatchFold(BaseNode *node) {
+  // Not trying all possiblities.
+  // For simplicity, stop looking further down the expression once OP_OP_cior/OP_cand (etc) are seen
+  CHECK_NULL_FATAL(node);
+  switch (node->GetOpCode()) {
+    case OP_cior:
+    case OP_lior:
+      return ExtFoldIor(static_cast<BinaryNode*>(node));
+    case OP_cand:
+    case OP_land:
+      return ExtFoldXand(static_cast<BinaryNode*>(node));
+    case OP_abs:
+    case OP_bnot:
+    case OP_lnot:
+    case OP_neg:
+    case OP_recip:
+    case OP_sqrt:
+      return ExtFoldUnary(static_cast<UnaryNode*>(node));
+    case OP_add:
+    case OP_ashr:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor:
+    case OP_div:
+    case OP_lshr:
+    case OP_max:
+    case OP_min:
+    case OP_mul:
+    case OP_rem:
+    case OP_shl:
+    case OP_sub:
+    case OP_eq:
+    case OP_ne:
+    case OP_ge:
+    case OP_gt:
+    case OP_le:
+    case OP_lt:
+    case OP_cmp:
+      return ExtFoldBinary(static_cast<BinaryNode*>(node));
+    case OP_select:
+      return ExtFoldTernary(static_cast<TernaryNode*>(node));
+    default:
+      return node;
+  }
+}
+
+BaseNode *ExtConstantFold::ExtFoldUnary(UnaryNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  result = DispatchFold(node->Opnd(0));
+  if (result != node->Opnd(0)) {
+    node->SetOpnd(result, 0);
+  }
+  return node;
+}
+
+BaseNode *ExtConstantFold::ExtFoldBinary(BinaryNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  result = DispatchFold(node->Opnd(0));
+  if (result != node->Opnd(0)) {
+    node->SetOpnd(result, 0);
+  }
+  result = DispatchFold(node->Opnd(1));
+  if (result != node->Opnd(1)) {
+    node->SetOpnd(result, 1);
+  }
+  return node;
+}
+
+BaseNode* ExtConstantFold::ExtFoldTernary(TernaryNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *result = nullptr;
+  result = DispatchFold(node->Opnd(0));
+  if (result != node->Opnd(0)) {
+    node->SetOpnd(result, 0);
+  }
+  result = DispatchFold(node->Opnd(1));
+  if (result != node->Opnd(1)) {
+    node->SetOpnd(result, 1);
+  }
+  result = DispatchFold(node->Opnd(2));
+  if (result != node->Opnd(2)) {
+    node->SetOpnd(result, 2);
+  }
+  return node;
+}
+
+BaseNode *ExtConstantFold::ExtFold(BaseNode *node) {
+  if (node == nullptr || kOpcodeInfo.IsStmt(node->GetOpCode())) {
+    return nullptr;
+  }
+  return DispatchFold(node);
+}
+
+BaseNode *ExtConstantFold::ExtFoldIor(BinaryNode *node) {
+  CHECK_NULL_FATAL(node);
+  // The target pattern (Cior, Lior):
+  // x == c || x == c+1 || ... || x == c+k
+  // ==> le (x - c), k
+  // where c is int. i
+  // Leave other cases for future including extended simplification of partial expressions
+  std::queue<BaseNode *> operands;
+  std::vector<int64> uniqOperands;
+  operands.push(node);
+  int64 minVal = LLONG_MAX;
+  bool isWorkable = true;
+  BaseNode* lNode = nullptr;
+
+  while (!operands.empty()) {
+    BaseNode *operand = operands.front();
+    operands.pop();
+    Opcode op = operand->GetOpCode();
+    if (op == OP_cior || op == OP_lior) {
+      operands.push(static_cast<BinaryNode *>(operand)->GetBOpnd(0));
+      operands.push(static_cast<BinaryNode *>(operand)->GetBOpnd(1));
+    } else if (op == OP_eq) {
+      BinaryNode *bNode = static_cast<BinaryNode *>(operand);
+      if (lNode == nullptr) {
+        if (bNode->Opnd(0)->GetOpCode() == OP_dread ||
+            bNode->Opnd(0)->GetOpCode() == OP_iread) {
+          lNode = bNode->Opnd(0);
+        } else {
+          // Consider other cases in future
+          isWorkable = false;
+          break;
+        }
+      }
+      ASSERT_NOT_NULL(lNode);
+
+      if ((lNode->IsSameContent(bNode->Opnd(0))) &&
+          (bNode->Opnd(1)->GetOpCode() == OP_constval) &&
+          (IsPrimitiveInteger(bNode->Opnd(1)->GetPrimType()))) {
+        MIRConst *rConstVal = safe_cast<ConstvalNode>(bNode->Opnd(1))->GetConstVal();
+        int64 rVal = static_cast<MIRIntConst*>(rConstVal)->GetExtValue();
+        minVal = std::min(minVal, rVal);
+        uniqOperands.push_back(rVal);
+      } else {
+        isWorkable = false;
+        break;
+      }
+    } else {
+      isWorkable = false;
+      break;
+    }
+  }
+
+  if (isWorkable) {
+    std::sort(uniqOperands.begin(), uniqOperands.end());
+    uniqOperands.erase(std::unique(uniqOperands.begin(), uniqOperands.end()), uniqOperands.cend());
+    if ((uniqOperands.size() >= 2) &&
+        (uniqOperands[uniqOperands.size() - 1] == uniqOperands[0] + static_cast<int64>(uniqOperands.size()) - 1)) {
+      PrimType nPrimType = node->GetPrimType();
+      BaseNode* diffVal;
+      ConstvalNode *lowVal = mirModule->GetMIRBuilder()->CreateIntConst(minVal, nPrimType);
+      diffVal = mirModule->CurFuncCodeMemPool()->New<BinaryNode>(OP_sub, nPrimType, lNode, lowVal);
+      PrimType cmpPrimType = (nPrimType == PTY_i64 || nPrimType == PTY_u64) ? PTY_u64 : PTY_u32;
+      MIRType *cmpMirType = (nPrimType == PTY_i64 || nPrimType == PTY_u64) ?
+                            GlobalTables::GetTypeTable().GetUInt64() :
+                            GlobalTables::GetTypeTable().GetUInt32();
+      ConstvalNode *deltaVal = mirModule->GetMIRBuilder()->CreateIntConst(
+          static_cast<int64>(uniqOperands.size()) - 1, cmpPrimType);
+      CompareNode *result;
+      result = mirModule->GetMIRBuilder()->CreateExprCompare(OP_le, *cmpMirType, *cmpMirType, diffVal, deltaVal);
+      return result;
+    } else {
+      return node;
+    }
+  } else {
+    return node;
+  }
+}
+
+BaseNode *ExtConstantFold::ExtFoldXand(BinaryNode *node) {
+  // The target pattern (Cand, Land):
+  // (x & m1) == c1 && (x & m2) == c2 && ... && (x & Mk) == ck
+  // where mi and ci shall be all int constants
+  // ==> (x & M) == C
+
+  CHECK_NULL_FATAL(node);
+  CHECK_FATAL(node->GetOpCode() == OP_cand || node->GetOpCode() == OP_land, "Operator is neither OP_cand nor OP_land");
+
+  BaseNode *lnode = DispatchFold(node->Opnd(0));
+  if (lnode != node->Opnd(0)) {
+    node->SetOpnd(lnode, 0);
+  }
+
+  BaseNode *rnode = DispatchFold(node->Opnd(1));
+  if (rnode != node->Opnd(1)) {
+    node->SetOpnd(rnode, 1);
+  }
+
+  // Check if it is of the form of (x & m) == c cand (x & m') == c'
+  if ((lnode->GetOpCode() == OP_eq) && (rnode->GetOpCode() == OP_eq) &&
+      (lnode->Opnd(0)->GetOpCode() == OP_band) &&
+      (lnode->Opnd(0)->Opnd(1)->GetOpCode() == OP_constval) &&
+      (IsPrimitiveInteger(lnode->Opnd(0)->Opnd(1)->GetPrimType())) &&
+      (lnode->Opnd(1)->GetOpCode() == OP_constval) &&
+      (IsPrimitiveInteger(lnode->Opnd(1)->GetPrimType())) &&
+      (rnode->Opnd(0)->GetOpCode() == OP_band) &&
+      (rnode->Opnd(0)->Opnd(1)->GetOpCode() == OP_constval) &&
+      (IsPrimitiveInteger(rnode->Opnd(0)->Opnd(1)->GetPrimType())) &&
+      (rnode->Opnd(1)->GetOpCode() == OP_constval) &&
+      (IsPrimitiveInteger(rnode->Opnd(1)->GetPrimType())) &&
+      (lnode->Opnd(0)->Opnd(0)->IsSameContent(rnode->Opnd(0)->Opnd(0)))) {
+    MIRConst *lmConstVal = safe_cast<ConstvalNode>(lnode->Opnd(0)->Opnd(1))->GetConstVal();
+    uint64 lmVal = static_cast<MIRIntConst*>(lmConstVal)->GetExtValue();
+    MIRConst *rmConstVal = safe_cast<ConstvalNode>(rnode->Opnd(0)->Opnd(1))->GetConstVal();
+    uint64 rmVal = static_cast<MIRIntConst*>(rmConstVal)->GetExtValue();
+    MIRConst *lcConstVal = safe_cast<ConstvalNode>(lnode->Opnd(1))->GetConstVal();
+    uint64 lcVal = static_cast<MIRIntConst*>(lcConstVal)->GetExtValue();
+    MIRConst *rcConstVal = safe_cast<ConstvalNode>(rnode->Opnd(1))->GetConstVal();
+    uint64 rcVal = static_cast<MIRIntConst*>(rcConstVal)->GetExtValue();
+
+    bool isWorkable = true;
+    for (uint64 i = 0; i < 64; i++) {
+      if ((lmVal & (1UL << i)) == (rmVal & (1UL << i)) &&
+          (lcVal & (1UL << i)) != (rcVal & (1UL << i))) {
+        isWorkable = false;
+        break;
+      }
+    }
+
+    if (isWorkable) {
+      uint64 mVal = lmVal | rmVal;
+      uint64 cVal = lcVal | rcVal;
+      PrimType mPrimType = lnode->Opnd(0)->Opnd(1)->GetPrimType();
+      ConstvalNode *mIntConst = mirModule->GetMIRBuilder()->CreateIntConst(static_cast<int64>(mVal), mPrimType);
+      PrimType cPrimType = lnode->Opnd(1)->GetPrimType();
+      ConstvalNode *cIntConst = mirModule->GetMIRBuilder()->CreateIntConst(static_cast<int64>(cVal), cPrimType);
+      BinaryNode *eqNode = static_cast<BinaryNode *>(lnode);
+      BinaryNode *bandNode = static_cast<BinaryNode *>(eqNode->Opnd(0));
+      bandNode->SetOpnd(mIntConst, 1);
+      eqNode->SetOpnd(cIntConst, 1);
+      return eqNode;
+    }
+  }
+  return node;
+}
+
+StmtNode *ExtConstantFold::ExtSimplifyBlock(BlockNode *node) {
+  CHECK_NULL_FATAL(node);
+  if (node->GetFirst() == nullptr) {
+    return node;
+  }
+  StmtNode *s = node->GetFirst();
+  do {
+    (void)ExtSimplify(s);
+    s = s->GetNext();;
+  } while (s != nullptr);
+  return node;
+}
+
+StmtNode *ExtConstantFold::ExtSimplifyIf(IfStmtNode *node) {
+  CHECK_NULL_FATAL(node);
+  (void)ExtSimplify(node->GetThenPart());
+  if (node->GetElsePart()) {
+    (void)ExtSimplify(node->GetElsePart());
+  }
+  BaseNode *origTest = node->Opnd();
+  BaseNode *returnValue = ExtFold(node->Opnd());
+  if (returnValue != origTest) {
+    node->SetOpnd(returnValue, 0);
+  }
+  return node;
+}
+
+StmtNode *ExtConstantFold::ExtSimplifyDassign(DassignNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue;
+  returnValue = ExtFold(node->GetRHS());
+  if (returnValue != node->GetRHS()) {
+    node->SetRHS(returnValue);
+  }
+  return node;
+}
+
+StmtNode *ExtConstantFold::ExtSimplifyIassign(IassignNode *node) {
+  CHECK_NULL_FATAL(node);
+  BaseNode *returnValue;
+  returnValue = ExtFold(node->GetRHS());
+  if (returnValue != node->GetRHS()) {
+    node->SetRHS(returnValue);
+  }
+  return node;
+}
+
+StmtNode *ExtConstantFold::ExtSimplifyWhile(WhileStmtNode *node) {
+  CHECK_NULL_FATAL(node);
+  if (node->Opnd(0) == nullptr) {
+    return node;
+  }
+  BaseNode *returnValue = ExtFold(node->Opnd(0));
+  if (returnValue != node->Opnd(0)) {
+    node->SetOpnd(returnValue, 0);
+  }
+  return node;
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/gen_check_cast.cpp b/src/mapleall/mpl2mpl/src/gen_check_cast.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..af8d33d15d6c4021e8b974c9d977de51aa5b8b3a
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/gen_check_cast.cpp
@@ -0,0 +1,963 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "gen_check_cast.h"
+#include <iostream>
+#include <algorithm>
+#include "reflection_analysis.h"
+#include "mir_lower.h"
+
+namespace {
+constexpr char kMCCReflectThrowCastException[] = "MCC_Reflect_ThrowCastException";
+constexpr char kMCCReflectCheckCastingNoArray[] = "MCC_Reflect_Check_Casting_NoArray";
+constexpr char kMCCReflectCheckCastingArray[] = "MCC_Reflect_Check_Casting_Array";
+constexpr char kCastTargetClass[] = "castTargetClass";
+constexpr char kObjectClassSym[] = "_objectClassSym";
+constexpr char kMCCIsAssignableFrom[] = "MCC_IsAssignableFrom";
+constexpr char kMCCThrowCastException[] = "MCC_ThrowCastException";
+constexpr char kClinitBridge[] = "clinitbridge";
+constexpr char kInstanceOfCacheFalse[] = "instanceOfCacheFalse";
+constexpr char kCacheTrueClass[] = "cacheTrueClass";
+constexpr char kCacheFalseClass[] = "cacheFalseClass";
+constexpr char kTargetClass[] = "targetClass";
+constexpr char kIsAssignableFromResult[] = "isAssignableFromResult";
+} // namespace
+
+// This phase does two things:
+// #1 implement the opcode check-cast vx, type_id
+//    according to the check-cast definition:
+//    Checks whether the object reference in vx can be cast
+//    to an instance of a class referenced by type_id.
+//    Throws ClassCastException if the cast is not possible, continues execution otherwise.
+//    in our case check if object can be cast or insert MCC_Reflect_ThrowCastException
+//    before the stmt.
+// #2 optimise instance-of && cast
+namespace maple {
+CheckCastGenerator::CheckCastGenerator(MIRModule &mod, KlassHierarchy *kh, bool dump)
+    : FuncOptimizeImpl(mod, kh, dump) {
+  InitTypes();
+  InitFuncs();
+}
+
+PreCheckCast::PreCheckCast(MIRModule &mod, KlassHierarchy *kh, bool dump) : FuncOptimizeImpl(mod, kh, dump) {}
+
+void CheckCastGenerator::InitTypes() {
+  const MIRType *javaLangObjectType = WKTypes::Util::GetJavaLangObjectType();
+  CHECK_FATAL(javaLangObjectType != nullptr, "The pointerObjType in InitTypes is null!");
+  pointerObjType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*javaLangObjectType);
+  classinfoType = GlobalTables::GetTypeTable().GetOrCreateClassType(namemangler::kClassMetadataTypeName,
+                                                                    GetMIRModule());
+  pointerClassMetaType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*classinfoType);
+}
+
+void CheckCastGenerator::InitFuncs() {
+  throwCastException = builder->GetOrCreateFunction(kMCCReflectThrowCastException, TyIdx(PTY_void));
+  throwCastException->SetAttr(FUNCATTR_nosideeffect);
+  checkCastingNoArray = builder->GetOrCreateFunction(kMCCReflectCheckCastingNoArray, TyIdx(PTY_void));
+  checkCastingNoArray->SetAttr(FUNCATTR_nosideeffect);
+  checkCastingArray = builder->GetOrCreateFunction(kMCCReflectCheckCastingArray, TyIdx(PTY_void));
+  checkCastingArray->SetAttr(FUNCATTR_nosideeffect);
+
+  mccIsAssignableFrom =
+      builder->GetOrCreateFunction(kMCCIsAssignableFrom, GlobalTables::GetTypeTable().GetUInt1()->GetTypeIndex());
+  castExceptionFunc = builder->GetOrCreateFunction(kMCCThrowCastException, TyIdx(PTY_void));
+  castExceptionFunc->SetAttr(FUNCATTR_nosideeffect);
+}
+
+MIRSymbol *CheckCastGenerator::GetOrCreateClassInfoSymbol(const std::string &className) {
+  std::string classInfoName = CLASSINFO_PREFIX_STR + className;
+  builder->GlobalLock();
+  MIRSymbol *classInfoSymbol = builder->GetGlobalDecl(classInfoName);
+  if (classInfoSymbol == nullptr) {
+    GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(className);
+    MIRType *classType =
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(gStrIdx));
+    MIRStorageClass sclass = (classType != nullptr && static_cast<MIRClassType*>(classType)->IsLocal()) ? kScGlobal
+                                                                                                        : kScExtern;
+    // Creating global symbol needs synchronization.
+    classInfoSymbol = builder->CreateGlobalDecl(classInfoName, *GlobalTables::GetTypeTable().GetPtr(), sclass);
+  }
+  builder->GlobalUnlock();
+  return classInfoSymbol;
+}
+
+void CheckCastGenerator::GenCheckCast(StmtNode &stmt) {
+  // Handle the special case like (Type)null, we don't need a checkcast.
+  if (stmt.GetOpCode() == OP_intrinsiccallwithtypeassigned) {
+    auto *callNode = static_cast<IntrinsiccallNode*>(&stmt);
+    ASSERT(callNode->GetNopndSize() == 1, "array size error");
+    BaseNode *opnd = callNode->Opnd(0);
+    if (opnd->GetOpCode() == OP_constval) {
+      const size_t callNodeNretsSize = callNode->GetReturnVec().size();
+      CHECK_FATAL(callNodeNretsSize > 0, "container check");
+      CallReturnPair callReturnPair = callNode->GetReturnVec()[0];
+      StmtNode *assignReturnTypeNode = nullptr;
+      if (!callReturnPair.second.IsReg()) {
+        assignReturnTypeNode =
+            builder->CreateStmtDassign(callReturnPair.first, callReturnPair.second.GetFieldID(), opnd);
+      } else {
+        PregIdx pregIdx = callReturnPair.second.GetPregIdx();
+        MIRPreg *mirPreg = currFunc->GetPregTab()->PregFromPregIdx(pregIdx);
+        assignReturnTypeNode = builder->CreateStmtRegassign(mirPreg->GetPrimType(), pregIdx, opnd);
+      }
+      currFunc->GetBody()->ReplaceStmt1WithStmt2(&stmt, assignReturnTypeNode);
+      return;
+    }
+  }
+  // Do type check first.
+  auto *callNode = static_cast<IntrinsiccallNode*>(&stmt);
+  ASSERT(callNode->GetNopndSize() == 1, "array size error");
+  TyIdx checkTyidx = callNode->GetTyIdx();
+  MIRType *checkType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(checkTyidx);
+  Klass *checkKlass = klassHierarchy->GetKlassFromTyIdx(static_cast<MIRPtrType*>(checkType)->GetPointedTyIdx());
+
+  if (funcWithoutCastCheck.find(currFunc->GetName()) == funcWithoutCastCheck.end()) {
+    if ((checkKlass != nullptr) && (checkKlass->GetKlassName() != "")) {
+      if (checkKlass->GetKlassName() == namemangler::kJavaLangObjectStr) {
+        const size_t callNodeNopndSize1 = callNode->GetNopndSize();
+        CHECK_FATAL(callNodeNopndSize1 > 0, "container check");
+        if (callNode->GetNopndAt(0)->GetPrimType() != PTY_ref && callNode->GetNopndAt(0)->GetPrimType() != PTY_ptr) {
+          // If source = Ljava_2Flang_2FObject_3B, sub = primitive type then throw CastException.
+          MIRSymbol *classSt = GetOrCreateClassInfoSymbol(checkKlass->GetKlassName());
+          BaseNode *valueExpr = builder->CreateExprAddrof(0, *classSt);
+          MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+          args.push_back(valueExpr);
+          args.push_back(callNode->GetNopndAt(0));
+          args.push_back(builder->CreateIntConst(0, PTY_ptr));
+          StmtNode *dassignStmt = builder->CreateStmtCall(throwCastException->GetPuidx(), args);
+          currFunc->GetBody()->InsertBefore(&stmt, dassignStmt);
+        }
+      } else {
+        MIRSymbol *classSt = GetOrCreateClassInfoSymbol(checkKlass->GetKlassName());
+        BaseNode *valueExpr = builder->CreateExprAddrof(0, *classSt);
+
+        BaseNode *castClassReadNode = nullptr;
+        StmtNode *castClassAssign = nullptr;
+        BaseNode *opnd0 = callNode->GetNopndAt(0);
+        if ((opnd0 != nullptr) && (opnd0->GetOpCode() == OP_regread)) {
+          PregIdx castClassSymPregIdx = currFunc->GetPregTab()->CreatePreg(PTY_ref);
+          castClassAssign = builder->CreateStmtRegassign(PTY_ref, castClassSymPregIdx, valueExpr);
+          castClassReadNode = builder->CreateExprRegread(PTY_ref, castClassSymPregIdx);
+        } else {
+          MIRSymbol *castClassSym =
+              builder->GetOrCreateLocalDecl(kCastTargetClass, *GlobalTables::GetTypeTable().GetRef());
+          castClassAssign = builder->CreateStmtDassign(*castClassSym, 0, valueExpr);
+          castClassReadNode = builder->CreateExprDread(*castClassSym);
+        }
+        BaseNode *nullPtrConst = builder->CreateIntConst(0, PTY_ptr);
+        const size_t callNodeNopndSize2 = callNode->GetNopndSize();
+        CHECK_FATAL(callNodeNopndSize2 > 0, "container check");
+        BaseNode *cond =
+            builder->CreateExprCompare(OP_ne, *GlobalTables::GetTypeTable().GetUInt1(),
+                                       *GlobalTables::GetTypeTable().GetPtrType(), callNode->GetNopndAt(0),
+                                       nullPtrConst);
+        auto *ifStmt = static_cast<IfStmtNode*>(builder->CreateStmtIf(cond));
+        MIRType *mVoidPtr = GlobalTables::GetTypeTable().GetVoidPtr();
+        CHECK_FATAL(mVoidPtr != nullptr, "builder->GetVoidPtr() is null in CheckCastGenerator::GenCheckCast");
+        BaseNode *opnd = callNode->GetNopndAt(0);
+        BaseNode *ireadExpr = GetObjectShadow(opnd);
+        BaseNode *innerCond = builder->CreateExprCompare(OP_ne, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                         *GlobalTables::GetTypeTable().GetPtrType(), castClassReadNode,
+                                                         ireadExpr);
+        auto *innerIfStmt = static_cast<IfStmtNode*>(builder->CreateStmtIf(innerCond));
+        MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+        args.push_back(castClassReadNode);
+        args.push_back(opnd);
+        StmtNode *dassignStmt = builder->CreateStmtCall(checkCastingNoArray->GetPuidx(), args);
+        innerIfStmt->GetThenPart()->AddStatement(dassignStmt);
+        ifStmt->GetThenPart()->AddStatement(castClassAssign);
+        ifStmt->GetThenPart()->AddStatement(innerIfStmt);
+        currFunc->GetBody()->InsertBefore(&stmt, ifStmt);
+      }
+    } else {
+      MIRType *pointedType =
+          GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<MIRPtrType*>(checkType)->GetPointedTyIdx());
+      if (pointedType->GetKind() == kTypeJArray) {
+        // Java array.
+        auto *jarrayType = static_cast<MIRJarrayType*>(pointedType);
+        std::string arrayName = jarrayType->GetJavaName();
+        int dim = 0;
+        while (arrayName[dim] == 'A') {
+          ++dim;
+        }
+        MIRSymbol *elemClassSt = nullptr;
+        std::string elementName = arrayName.substr(dim, arrayName.size() - dim);
+        MIRType *mVoidPtr2 = GlobalTables::GetTypeTable().GetVoidPtr();
+        CHECK_FATAL(mVoidPtr2 != nullptr, "null ptr check");
+        if (elementName == "I" || elementName == "F" || elementName == "B" || elementName == "C" ||
+            elementName == "S" || elementName == "J" || elementName == "D" || elementName == "Z" ||
+            elementName == "V") {
+          std::string primClassinfoName = PRIMITIVECLASSINFO_PREFIX_STR + elementName;
+          builder->GlobalUnlock();
+          elemClassSt = builder->GetGlobalDecl(primClassinfoName);
+          if (elemClassSt == nullptr) {
+            elemClassSt = builder->CreateGlobalDecl(primClassinfoName, *GlobalTables::GetTypeTable().GetPtr());
+          }
+          builder->GlobalUnlock();
+        } else {
+          elemClassSt = GetOrCreateClassInfoSymbol(elementName);
+        }
+        BaseNode *valueExpr = builder->CreateExprAddrof(0, *elemClassSt);
+        builder->GlobalLock();
+        builder->GlobalUnlock();
+        MapleVector<BaseNode*> opnds(currFunc->GetCodeMempoolAllocator().Adapter());
+        opnds.push_back(valueExpr);
+        const size_t callNodeNopndSize3 = callNode->GetNopndSize();
+        CHECK_FATAL(callNodeNopndSize3 > 0, "container check");
+        opnds.push_back(callNode->GetNopndAt(0));
+        opnds.push_back(builder->CreateIntConst(dim, PTY_ptr));
+        StmtNode *dassignStmt = builder->CreateStmtCall(checkCastingArray->GetPuidx(), opnds);
+        currFunc->GetBody()->InsertBefore(&stmt, dassignStmt);
+      } else {
+        MIRTypeKind kd = pointedType->GetKind();
+        if (kd == kTypeStructIncomplete || kd == kTypeClassIncomplete || kd == kTypeInterfaceIncomplete) {
+          LogInfo::MapleLogger() << "Warining: CheckCastGenerator::GenCheckCast "
+                                 << GlobalTables::GetStrTable().GetStringFromStrIdx(pointedType->GetNameStrIdx())
+                                 << " INCOMPLETE \n";
+        } else {
+          CHECK_FATAL(false, "unsupport kind");
+        }
+      }
+    }
+  }
+  if (callNode->GetOpCode() == OP_intrinsiccallwithtype) {
+    return;
+  }
+  BaseNode *opnd = callNode->Opnd(0);
+  ASSERT(opnd->GetOpCode() == OP_dread || opnd->GetOpCode() == OP_regread || opnd->GetOpCode() == OP_iread ||
+         opnd->GetOpCode() == OP_retype, "unknown calltype! check it!");
+  MIRType *fromType = nullptr;
+  if (opnd->GetOpCode() == OP_dread) {
+    fromType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(
+        currFunc->GetLocalOrGlobalSymbol(static_cast<AddrofNode*>(opnd)->GetStIdx())->GetTyIdx());
+  } else if (opnd->GetOpCode() == OP_retype) {
+    fromType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(static_cast<RetypeNode*>(opnd)->GetTyIdx());
+  } else if (opnd->GetOpCode() == OP_iread) {
+    auto *irnode = static_cast<IreadNode*>(opnd);
+    auto *ptrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(irnode->GetTyIdx()));
+    if (irnode->GetFieldID() != 0) {
+      MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrType->GetPointedTyIdx());
+      MIRStructType *structType = nullptr;
+      if (pointedType->GetKind() != kTypeJArray) {
+        structType = static_cast<MIRStructType*>(pointedType);
+      } else {
+        // It's a Jarray type. Using it's parent's field info: java.lang.Object.
+        structType = static_cast<MIRJarrayType*>(pointedType)->GetParentType();
+      }
+      CHECK_FATAL(structType != nullptr, "null ptr check");
+      fromType = structType->GetFieldType(irnode->GetFieldID());
+    } else {
+      fromType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrType->GetPointedTyIdx());
+    }
+  } else if (opnd->GetOpCode() == OP_regread) {
+    auto *regReadNode = static_cast<RegreadNode*>(opnd);
+    MIRPreg *mirPreg = currFunc->GetPregTab()->PregFromPregIdx(regReadNode->GetRegIdx());
+    CHECK_FATAL(mirPreg->GetPrimType() == PTY_ref || mirPreg->GetPrimType() == PTY_ptr,
+                "must be reference or ptr type for preg");
+    if (opnd->GetPrimType() == PTY_ref) {
+      fromType = mirPreg->GetMIRType();
+    } else {
+      const size_t gTypeTableSize = GlobalTables::GetTypeTable().GetTypeTable().size();
+      CHECK_FATAL(gTypeTableSize > PTY_ptr, "container check");
+      fromType = GlobalTables::GetTypeTable().GetTypeTable()[PTY_ptr];
+    }
+  }
+  ASSERT((fromType->GetPrimType() == maple::PTY_ptr || fromType->GetPrimType() == maple::PTY_ref),
+         "unknown fromType! check it!");
+  ASSERT(GlobalTables::GetTypeTable().GetTypeFromTyIdx(callNode->GetTyIdx())->GetPrimType() == maple::PTY_ptr ||
+         GlobalTables::GetTypeTable().GetTypeFromTyIdx(callNode->GetTyIdx())->GetPrimType() == maple::PTY_ref,
+         "unknown fromType! check it!");
+  CHECK_FATAL(!callNode->GetReturnVec().empty(), "container check");
+  CallReturnPair callReturnPair = callNode->GetReturnVec()[0];
+  StmtNode *assignReturnTypeNode = nullptr;
+  if (!callReturnPair.second.IsReg()) {
+    assignReturnTypeNode = builder->CreateStmtDassign(callReturnPair.first, callReturnPair.second.GetFieldID(), opnd);
+  } else {
+    PregIdx pregIdx = callReturnPair.second.GetPregIdx();
+    MIRPreg *mirPreg = currFunc->GetPregTab()->PregFromPregIdx(pregIdx);
+    assignReturnTypeNode = builder->CreateStmtRegassign(mirPreg->GetPrimType(), pregIdx, opnd);
+  }
+  currFunc->GetBody()->ReplaceStmt1WithStmt2(&stmt, assignReturnTypeNode);
+}
+
+void CheckCastGenerator::GenAllCheckCast() {
+  auto &stmtNodes = currFunc->GetBody()->GetStmtNodes();
+  for (auto &stmt : stmtNodes) {
+    if (stmt.GetOpCode() == OP_intrinsiccallwithtypeassigned || stmt.GetOpCode() == OP_intrinsiccallwithtype) {
+      auto &callNode = static_cast<IntrinsiccallNode&>(stmt);
+      if (callNode.GetIntrinsic() == INTRN_JAVA_CHECK_CAST) {
+        GenCheckCast(stmt);
+        if (stmt.GetOpCode() == OP_intrinsiccallwithtype) {
+          currFunc->GetBody()->RemoveStmt(&stmt);
+        }
+      }
+    }
+  }
+}
+
+BaseNode *CheckCastGenerator::GetObjectShadow(BaseNode *opnd) {
+  FieldID fieldID = builder->GetStructFieldIDFromFieldNameParentFirst(WKTypes::Util::GetJavaLangObjectType(),
+                                                                      namemangler::kShadowClassName);
+  BaseNode *ireadExpr =
+      builder->CreateExprIread(*GlobalTables::GetTypeTable().GetPtr(), *pointerObjType, fieldID, opnd);
+  return ireadExpr;
+}
+
+// optimise instance-of && cast
+// #1 convert instance-of, cast to check IsAssignableFrom
+//   1) check nullptr
+//   2) check type, call IsAssignableFrom(targetClass, objClass)
+// eg:
+//   (1). cast:
+//   intrinsiccallwithtypeassigned <* <$targetClass>> JAVA_CHECK_CAST (dread ref %Reg2_R45718) { dassign %Reg2_R45709 0}
+//   ==>
+//   ## check nullptr
+//   Example: if (ne u1 ptr (dread ref %Reg2_R45718, constval ptr 0)) {
+//     dassign %objClass 0 (iread ptr <* <$Ljava_2Flang_2FObject_3B>> 1 (dread ref %Reg2_R45718))
+//     dassign %targetClass 0 (intrinsicopwithtype ref <* <$targetClass>> JAVA_CONST_CLASS ())
+//   ## check type
+//     dassign %isAssignableFromResult 0
+//        (intrinsicopwithtype ref <* <$targetClass>> JAVA_ISASSIGNABLEFROM (dread ptr %objClass))
+//     Example: if (eq u1 ptr (dread u1 %isAssignableFromResult, constval u1 0)) {
+//       call &MCC_ThrowCastException (dread ptr %targetClass, dread ref %Reg2_R45718)
+//     }
+//   }
+//   dassign %Reg2_R45709 0 (dread ref %Reg2_R45718)
+//
+//   (2) instance-of
+//   dassign %Reg0_Z 0 (intrinsicopwithtype u1 <* <$targetClass>> JAVA_INSTANCE_OF (dread ref %Reg0_R45718))
+//   ==>
+//   ## check nullptr
+//   Example: if (ne u1 ptr (dread ref %Reg0_R45718, constval ptr 0)) {
+//     dassign %objClass 0 (iread ptr <* <$Ljava_2Flang_2FObject_3B>> 1 (dread ref %Reg0_R45718))
+//     dassign %Reg0_Z 0 (intrinsicopwithtype ref <* <$targetClass>> JAVA_ISASSIGNABLEFROM (dread ptr %objClass))
+//   Example: } else {
+//     dassign %Reg0_Z 0 (constval u1 0)
+//   }
+//
+// #2 optimise type check(IsAssignableFrom(targetClass, objClass))
+//     1) slow path, invoke runtime api to check
+//     2) fast path, use cache to check type first, if fail, then go to slow path
+//     fast path implement:
+//       (1) target class is is final class or is private and inner class and has no subclass
+//           it means there can't be subclass of target class,so if  a obj is instance of target
+//           class , the obj must be referred the target class,replace the instance-of with
+//           maple IR,the IR do the things check if obj.getClass() == target_class,below is the detail
+//           suppose the obj is %obj, target-class is T,result is saved in reg %1
+//           regassign u1 %1 (constval u1 0)
+//           brfalse (ne u1 ptr (regread ref %obj, constval ptr 0))  #check if obj is null
+//           #check if obj's class is equal the target class ,if equal set the result 1
+//           brflase (eq u1 ptr(
+//             iread ptr <* <$Ljava_2Flang_2FObject_3B>> 1 (regread ref %obj),
+//             addrof ptr T))
+//           regassign u1 %1 (constval u1 1)
+//
+//       (2) check cache
+//         a. check objClass equal to targetClass, if fail, then
+//         b. check objClass.cacheTrueClass equal to targetClass, if fail, then
+//         c. check objClass.cacheTFalseClass equal to targetClass, if fail, then
+//         b. go to slow path
+// eg:
+//   dassign %Reg0_Z 0 (intrinsicopwithtype ref <* <$targetClass>> JAVA_ISASSIGNABLEFROM (dread ptr %objClass))
+//   ==>
+//   ##set result true first
+//   dassign %Reg0_Z 0 (constval u1 1)
+//   Example: if (ne u1 ptr (dread ptr %objClass, dread ptr %targetClass)) {
+//     // load cacheTrueClass, it stored in runtime
+//     dassign %cacheTrueClass 0 (iread u64 <* <$__class_meta__>> 11 (dread ptr %objClass))
+//     Example: if (ne u1 ptr (dread ptr %targetClass, dread u64 %cacheTrueClass)) {
+//       ##load cacheFalseClass, it stored in runtime
+//       dassign %cacheFalseClass 0 (iread u64 <* <$__class_meta__>> 10 (dread ptr %objClass))
+//       Example: if (eq u1 ptr (
+//         dread ptr %targetClass,
+//         lshr u64 (dread u64 %cacheFalseClass, constval u8 32))) {
+//         dassign %Reg0_Z 0 (constval u1 0)
+//       Example: } else {
+//         ##check cache fail, got to slow path, check in runtime
+//         callassigned &MCC_IsAssignableFrom (dread ptr %objClass, dread ptr %targetClass) { dassign %Reg0_Z 0 }
+//       }
+//     }
+//   }
+void CheckCastGenerator::AssignedCastValue(StmtNode &stmt) {
+  if (stmt.GetOpCode() == OP_intrinsiccallwithtype) {
+    return;
+  }
+  // Assigned
+  auto *assignedCallNode = static_cast<IntrinsiccallNode*>(&stmt);
+  MapleVector<BaseNode*> nopnd = assignedCallNode->GetNopnd();
+  BaseNode *opnd = nopnd[0];
+  ASSERT(!assignedCallNode->GetReturnVec().empty(), "container check");
+  CallReturnPair callReturnPair = assignedCallNode->GetCallReturnPair(0);
+  StmtNode *assignReturnTypeNode = nullptr;
+  if (!callReturnPair.second.IsReg()) {
+    assignReturnTypeNode = builder->CreateStmtDassign(callReturnPair.first, callReturnPair.second.GetFieldID(), opnd);
+  } else {
+    PregIdx pregIdx = callReturnPair.second.GetPregIdx();
+    MIRPreg *mirpreg = currFunc->GetPregTab()->PregFromPregIdx(pregIdx);
+    assignReturnTypeNode = builder->CreateStmtRegassign(mirpreg->GetPrimType(), pregIdx, opnd);
+  }
+  currFunc->GetBody()->InsertAfter(&stmt, assignReturnTypeNode);
+}
+
+void CheckCastGenerator::ConvertCheckCastToIsAssignableFrom(StmtNode &stmt) {
+  AssignedCastValue(stmt);
+
+  auto *callNode = static_cast<IntrinsiccallNode*>(&stmt);
+  MIRType *checkType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(callNode->GetTyIdx());
+  auto *ptrCheckType = static_cast<MIRPtrType*>(checkType);
+  MIRType *ptype = ptrCheckType->GetPointedType();
+  MIRTypeKind kd = ptype->GetKind();
+  if (kd == kTypeClass || kd == kTypeInterface || kd == kTypeJArray) {
+    if (funcWithoutCastCheck.find(currFunc->GetName()) != funcWithoutCastCheck.end()) {
+      currFunc->GetBody()->RemoveStmt(&stmt);
+      return;
+    }
+
+    StmtNode *objectClassAssign = nullptr;
+    StmtNode *isAssignableFromResultAssign = nullptr;
+    BaseNode *objectClassReadNode = nullptr;
+    BaseNode *checkTypeReadNode = nullptr;
+    StmtNode *checkTypeAssign = nullptr;
+    BaseNode *isAssignableFromResultReadNode = nullptr;
+    BaseNode *isAssignableFromNode = nullptr;
+    MapleVector<BaseNode*> nopnd = callNode->GetNopnd();
+    BaseNode *opnd = nopnd[0];
+    BaseNode *ireadShadowExpr = GetObjectShadow(opnd);
+
+    MapleVector<BaseNode*> arguments(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    BaseNode *checkTypeNode = builder->CreateExprIntrinsicop(INTRN_JAVA_CONST_CLASS, OP_intrinsicopwithtype,
+                                                             *checkType, arguments);
+    ConstvalNode *falseVal = builder->GetConstUInt1(false);
+    BaseNode *nullVal = builder->CreateIntConst(0, PTY_ptr);
+    if (opnd->op == OP_regread) {
+      PrimType classPrimType =  ireadShadowExpr->GetPrimType();
+      PregIdx objectClassSymPregIdx = currFunc->GetPregTab()->CreatePreg(classPrimType);
+      objectClassAssign = builder->CreateStmtRegassign(classPrimType, objectClassSymPregIdx, ireadShadowExpr);
+      objectClassReadNode = builder->CreateExprRegread(PTY_ptr, objectClassSymPregIdx);
+
+      PregIdx checkTypePregIdx = currFunc->GetPregTab()->CreatePreg(classPrimType);
+      checkTypeAssign = builder->CreateStmtRegassign(classPrimType, checkTypePregIdx, checkTypeNode);
+      checkTypeReadNode = builder->CreateExprRegread(PTY_ptr, checkTypePregIdx);
+
+      MapleVector<BaseNode*> opndArgs(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+      opndArgs.push_back(objectClassReadNode);
+      isAssignableFromNode =
+          builder->CreateExprIntrinsicop(INTRN_JAVA_ISASSIGNABLEFROM, OP_intrinsicopwithtype, *checkType, opndArgs);
+      PregIdx IsAssignableFromResultIdx = currFunc->GetPregTab()->CreatePreg(PTY_u1);
+      isAssignableFromResultAssign =
+          builder->CreateStmtRegassign(PTY_u1, IsAssignableFromResultIdx, isAssignableFromNode);
+      isAssignableFromResultReadNode = builder->CreateExprRegread(PTY_u1, IsAssignableFromResultIdx);
+    } else {
+      MIRSymbol *objectClassSym =
+          builder->GetOrCreateLocalDecl(kObjectClassSym, *GlobalTables::GetTypeTable().GetPtr());
+      objectClassAssign = builder->CreateStmtDassign(*objectClassSym, 0, ireadShadowExpr);
+      objectClassReadNode = builder->CreateExprDread(*objectClassSym);
+
+      MIRSymbol *checkTypeSym = builder->GetOrCreateLocalDecl(kTargetClass, *GlobalTables::GetTypeTable().GetPtr());
+      checkTypeAssign = builder->CreateStmtDassign(*checkTypeSym, 0, checkTypeNode);
+      checkTypeReadNode = builder->CreateExprDread(*checkTypeSym);
+      MapleVector<BaseNode*> opndArgs(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+      opndArgs.push_back(objectClassReadNode);
+      isAssignableFromNode =
+          builder->CreateExprIntrinsicop(INTRN_JAVA_ISASSIGNABLEFROM, OP_intrinsicopwithtype, *checkType, opndArgs);
+      MIRSymbol *IsAssignableFromResultSym =
+          builder->GetOrCreateLocalDecl(kIsAssignableFromResult, *GlobalTables::GetTypeTable().GetUInt1());
+      isAssignableFromResultAssign = builder->CreateStmtDassign(*IsAssignableFromResultSym, 0, isAssignableFromNode);
+      isAssignableFromResultReadNode = builder->CreateExprDread(*IsAssignableFromResultSym);
+    }
+
+    BaseNode *condZero = builder->CreateExprCompare(
+        OP_ne, *GlobalTables::GetTypeTable().GetUInt1(), *GlobalTables::GetTypeTable().GetPtrType(), opnd, nullVal);
+    IfStmtNode *ifObjZeroNode = builder->CreateStmtIf(condZero);
+
+    BaseNode *condIsAssignableFrom = builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                                *GlobalTables::GetTypeTable().GetPtrType(),
+                                                                isAssignableFromResultReadNode, falseVal);
+    IfStmtNode *ifIsAssignableFromNode = builder->CreateStmtIf(condIsAssignableFrom);
+
+    MapleVector<BaseNode*> throwArguments(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    throwArguments.push_back(checkTypeReadNode);
+    throwArguments.push_back(opnd);
+    StmtNode *callThrowCastException = builder->CreateStmtCall(castExceptionFunc->GetPuidx(), throwArguments);
+    ifIsAssignableFromNode->GetThenPart()->AddStatement(callThrowCastException);
+
+    ifObjZeroNode->GetThenPart()->AddStatement(objectClassAssign);
+    ifObjZeroNode->GetThenPart()->AddStatement(checkTypeAssign);
+    ifObjZeroNode->GetThenPart()->AddStatement(isAssignableFromResultAssign);
+    ifObjZeroNode->GetThenPart()->AddStatement(ifIsAssignableFromNode);
+
+    currFunc->GetBody()->ReplaceStmt1WithStmt2(&stmt, ifObjZeroNode);
+  } else if (kd == kTypeStructIncomplete || kd == kTypeClassIncomplete || kd == kTypeInterfaceIncomplete) {
+    std::cout << "Warining: CheckCastGenerator::GenCheckCast " <<
+        GlobalTables::GetStrTable().GetStringFromStrIdx(ptype->GetNameStrIdx()) <<
+        " INCOMPLETE \n";
+    currFunc->GetBody()->RemoveStmt(&stmt);
+  } else {
+    ASSERT(false, "unsupport kind");
+  }
+}
+
+void CheckCastGenerator::GenAllCheckCast(bool isHotFunc) {
+  auto &stmtNodes = currFunc->GetBody()->GetStmtNodes();
+  for (auto &stmt : stmtNodes) {
+    if (stmt.GetOpCode() == OP_intrinsiccallwithtypeassigned || stmt.GetOpCode() == OP_intrinsiccallwithtype) {
+      auto &callNode = static_cast<IntrinsiccallNode&>(stmt);
+      if (callNode.GetIntrinsic() == INTRN_JAVA_CHECK_CAST) {
+        if (isHotFunc) {
+          ConvertCheckCastToIsAssignableFrom(stmt);
+        } else {
+          GenCheckCast(stmt);
+          if (stmt.GetOpCode() == OP_intrinsiccallwithtype) {
+            currFunc->GetBody()->RemoveStmt(&stmt);
+          }
+        }
+      }
+    }
+  }
+}
+
+// Use "srcclass == targetclass" replace instanceof if target class is final.
+void CheckCastGenerator::ReplaceNoSubClassIsAssignableFrom(BlockNode &blockNode, StmtNode &stmt,
+                                                           const MIRPtrType &ptrType,
+                                                           const IntrinsicopNode &intrinsicNode) {
+  MapleVector<BaseNode*> nopnd = intrinsicNode.GetNopnd();
+  BaseNode *subClassNode = nopnd[0];
+  MIRClassType &targetClassType = static_cast<MIRClassType&>(*ptrType.GetPointedType());
+  const std::string &className = GlobalTables::GetStrTable().GetStringFromStrIdx(targetClassType.GetNameStrIdx());
+  PregIdx targetClassSymPregIdx = 0;
+  MIRSymbol *targetClassSym = nullptr;
+  BaseNode *targetClassNode = nullptr;
+  // this pattern:
+  //   regassign ptr %6 (intrinsicopwithtype ref <* <$Ljava_lang_String_3B>> JAVA_CONST_CLASS ())
+  //   regassign u1 %2 (intrinsicopwithtype ref <* <$Ljava_2Flang_2FString_3B>> JAVA_ISASSIGNABLEFROM (regread ptr %1))
+  // for intrinsic JAVA_ISASSIGNABLEFROM, we can reuse JAVA_CONST_CLASS result(%6),
+  // rathe than define symbol again(CreateExprAddrof).
+  bool isPreDefinedConstClass = IsDefinedConstClass(stmt, ptrType, targetClassSymPregIdx, targetClassSym);
+  if (!isPreDefinedConstClass) {
+    MIRSymbol *targetClassSy = GetOrCreateClassInfoSymbol(className);
+    targetClassNode = builder->CreateExprAddrof(0, *targetClassSy);
+  } else {
+    if (targetClassSym == nullptr) {
+      targetClassNode = builder->CreateExprRegread(PTY_ref, targetClassSymPregIdx);
+    } else {
+      targetClassNode = builder->CreateExprDread(*targetClassSym);
+    }
+  }
+  BaseNode *innerCond = builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                   *GlobalTables::GetTypeTable().GetPtrType(),
+                                                   subClassNode, targetClassNode);
+  auto *innerIfStmt = static_cast<IfStmtNode*>(builder->CreateStmtIfThenElse(innerCond));
+
+  StmtNode *retFalseNode = nullptr;
+  StmtNode *retTrueNode = nullptr;
+  ConstvalNode *falseVal = builder->GetConstUInt1(false);
+  ConstvalNode *trueVal = builder->GetConstUInt1(true);
+  if (stmt.op == OP_regassign) {
+    auto *regAssignNode = static_cast<RegassignNode*>(&stmt);
+    MIRPreg *mirPreg = currFunc->GetPregTab()->PregFromPregIdx(regAssignNode->GetRegIdx());
+    retFalseNode = builder->CreateStmtRegassign(mirPreg->GetPrimType(), regAssignNode->GetRegIdx(), falseVal);
+    retTrueNode = builder->CreateStmtRegassign(mirPreg->GetPrimType(), regAssignNode->GetRegIdx(), trueVal);
+  } else {
+    auto *dAssignNode = static_cast<DassignNode*>(&stmt);
+    MIRSymbol *instanceOfRet = currFunc->GetLocalOrGlobalSymbol(dAssignNode->GetStIdx());
+    retFalseNode = builder->CreateStmtDassign(*instanceOfRet, 0, falseVal);
+    retTrueNode = builder->CreateStmtDassign(*instanceOfRet, 0, trueVal);
+  }
+  innerIfStmt->GetThenPart()->AddStatement(retTrueNode);
+  innerIfStmt->GetElsePart()->AddStatement(retFalseNode);
+  blockNode.ReplaceStmt1WithStmt2(&stmt, innerIfStmt);
+}
+
+bool CheckCastGenerator::IsDefinedConstClass(const StmtNode &stmt, const MIRPtrType &targetClassType,
+                                             PregIdx &classSymPregIdx, MIRSymbol *&classSym) {
+  StmtNode *stmtPre = stmt.GetPrev();
+  Opcode opPre = stmtPre->GetOpCode();
+  if ((opPre != OP_dassign) && (opPre != OP_regassign)) {
+    return false;
+  }
+
+  auto *unode = static_cast<UnaryStmtNode*>(stmtPre);
+  ASSERT(unode->GetRHS() != nullptr, "null ptr check!");
+  if (unode->GetRHS()->GetOpCode() != OP_intrinsicopwithtype) {
+    return false;
+  }
+  auto *preIntrinsicNode = static_cast<IntrinsicopNode*>(unode->GetRHS());
+  if (preIntrinsicNode->GetIntrinsic() != INTRN_JAVA_CONST_CLASS) {
+    return false;
+  }
+
+  MIRType *classType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(preIntrinsicNode->GetTyIdx());
+  if (!classType->EqualTo(targetClassType)) {
+    return false;
+  }
+
+  if (opPre == OP_regassign) {
+    auto *regAssignNodePre = static_cast<RegassignNode*>(stmtPre);
+    classSymPregIdx = regAssignNodePre->GetRegIdx();
+  } else {
+    auto *dAssignNode = static_cast<DassignNode*>(stmtPre);
+    classSym = currFunc->GetLocalOrGlobalSymbol(dAssignNode->GetStIdx());
+  }
+  return true;
+}
+
+// inline check cache, it implements __MRT_IsAssignableFromCheckCache
+void CheckCastGenerator::ReplaceIsAssignableFromUsingCache(BlockNode &blockNode, StmtNode &stmt,
+                                                           const MIRPtrType &targetClassType,
+                                                           const IntrinsicopNode &intrinsicNode) {
+  StmtNode *resultFalse = nullptr;
+  StmtNode *resultTrue = nullptr;
+  StmtNode *cacheFalseClassesAssign = nullptr;
+  StmtNode *cacheTrueClassesAssign = nullptr;
+  StmtNode *targetClassAssign = nullptr;
+  BaseNode *targetClassReadNode = nullptr;
+  BaseNode *cacheFalseClassesReadNode = nullptr;
+  BaseNode *cacheTrueClassesReadNode = nullptr;
+  BaseNode *cacheFalseClasses = nullptr;
+  BaseNode *cacheTrueClasses = nullptr;
+  StmtNode *callMCCIsAssignableFromStmt = nullptr;
+  PregIdx targetClassSymPregIdx = 0;
+  MIRSymbol *targetClassSym = nullptr;
+  bool isDefinedConstClass = IsDefinedConstClass(stmt, targetClassType, targetClassSymPregIdx, targetClassSym);
+
+  MapleVector<BaseNode*> nopnd = intrinsicNode.GetNopnd();
+  BaseNode *objectClassNode = nopnd[0];
+  MapleVector<BaseNode*> arguments(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  BaseNode *targetClassNode =
+      builder->CreateExprIntrinsicop(INTRN_JAVA_CONST_CLASS, OP_intrinsicopwithtype, targetClassType, arguments);
+  FieldID superCacheTrueFldid = builder->GetStructFieldIDFromFieldName(*classinfoType, kClinitBridge);
+  FieldID superCacheFalseFldid = builder->GetStructFieldIDFromFieldName(*classinfoType, kInstanceOfCacheFalse);
+
+  ConstvalNode *falseVal = builder->GetConstUInt1(false);
+  ConstvalNode *trueVal = builder->GetConstUInt1(true);
+  if (stmt.op == OP_regassign) {
+    auto *regAssignNode = static_cast<RegassignNode*>(&stmt);
+    PrimType classPrimType = objectClassNode->GetPrimType();
+    MIRPreg *mirPreg = currFunc->GetPregTab()->PregFromPregIdx(regAssignNode->GetRegIdx());
+    resultFalse = builder->CreateStmtRegassign(mirPreg->GetPrimType(), regAssignNode->GetRegIdx(), falseVal);
+    resultTrue = builder->CreateStmtRegassign(mirPreg->GetPrimType(), regAssignNode->GetRegIdx(), trueVal);
+
+    if (!isDefinedConstClass) {
+      targetClassSymPregIdx = currFunc->GetPregTab()->CreatePreg(classPrimType);
+      targetClassAssign = builder->CreateStmtRegassign(classPrimType, targetClassSymPregIdx, targetClassNode);
+    }
+    targetClassReadNode = builder->CreateExprRegread(PTY_ptr, targetClassSymPregIdx);
+    cacheTrueClasses = builder->CreateExprIread(*GlobalTables::GetTypeTable().GetPtr(), *pointerClassMetaType,
+                                                superCacheTrueFldid, objectClassNode);
+    cacheFalseClasses = builder->CreateExprIread(*GlobalTables::GetTypeTable().GetPtr(), *pointerClassMetaType,
+                                                 superCacheFalseFldid, objectClassNode);
+
+    // cache true class
+    PregIdx cacheTrueClassSymPregIdx = currFunc->GetPregTab()->CreatePreg(classPrimType);
+    cacheTrueClassesAssign = builder->CreateStmtRegassign(classPrimType, cacheTrueClassSymPregIdx, cacheTrueClasses);
+    cacheTrueClassesReadNode = builder->CreateExprRegread(PTY_ptr, cacheTrueClassSymPregIdx);
+    // cache false class
+    PregIdx cacheFalseClassSymPregIdx = currFunc->GetPregTab()->CreatePreg(classPrimType);
+    cacheFalseClassesAssign =
+        builder->CreateStmtRegassign(classPrimType, cacheFalseClassSymPregIdx, cacheFalseClasses);
+    cacheFalseClassesReadNode = builder->CreateExprRegread(PTY_ptr, cacheFalseClassSymPregIdx);
+
+    MapleVector<BaseNode*> opnds(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    opnds.push_back(objectClassNode);
+    opnds.push_back(targetClassReadNode);
+    callMCCIsAssignableFromStmt = builder->CreateStmtCallRegassigned(mccIsAssignableFrom->GetPuidx(), opnds,
+                                                                     regAssignNode->GetRegIdx(), OP_callassigned);
+  } else {
+    MIRSymbol *cacheTrueClassSym =
+        builder->GetOrCreateLocalDecl(kCacheTrueClass, *GlobalTables::GetTypeTable().GetPtr());
+    MIRSymbol *cacheFalseClassSym =
+        builder->GetOrCreateLocalDecl(kCacheFalseClass, *GlobalTables::GetTypeTable().GetPtr());
+    auto *dAssignNode = static_cast<DassignNode*>(&stmt);
+    MIRSymbol *instanceOfRet = currFunc->GetLocalOrGlobalSymbol(dAssignNode->GetStIdx());
+    resultFalse = builder->CreateStmtDassign(*instanceOfRet, 0, falseVal);
+    resultTrue = builder->CreateStmtDassign(*instanceOfRet, 0, trueVal);
+
+    if (isDefinedConstClass == false) {
+      targetClassSym = builder->GetOrCreateLocalDecl(kTargetClass, *GlobalTables::GetTypeTable().GetUIntType());
+      targetClassAssign = builder->CreateStmtDassign(*targetClassSym, 0, targetClassNode);
+    }
+    ASSERT(targetClassSym != nullptr, "null ptr check!");
+    targetClassReadNode = builder->CreateExprDread(*targetClassSym);
+    cacheTrueClasses = builder->CreateExprIread(*GlobalTables::GetTypeTable().GetPtr(), *pointerClassMetaType,
+                                                superCacheTrueFldid, objectClassNode);
+    cacheFalseClasses = builder->CreateExprIread(*GlobalTables::GetTypeTable().GetPtr(), *pointerClassMetaType,
+                                                 superCacheFalseFldid, objectClassNode);
+    // cache true class
+    cacheTrueClassesAssign = builder->CreateStmtDassign(*cacheTrueClassSym, 0, cacheTrueClasses);
+    cacheTrueClassesReadNode = builder->CreateExprDread(*cacheTrueClassSym);
+
+    // cache false class
+    cacheFalseClassesAssign = builder->CreateStmtDassign(*cacheFalseClassSym, 0, cacheFalseClasses);
+    cacheFalseClassesReadNode = builder->CreateExprDread(*cacheFalseClassSym);
+
+    MapleVector<BaseNode*> opnds(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    opnds.push_back(objectClassNode);
+    opnds.push_back(targetClassReadNode);
+    callMCCIsAssignableFromStmt =
+        builder->CreateStmtCallAssigned(mccIsAssignableFrom->GetPuidx(), opnds, instanceOfRet, OP_callassigned);
+  }
+
+  BaseNode *classEqualCond = builder->CreateExprCompare(OP_ne, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                        *GlobalTables::GetTypeTable().GetPtrType(),
+                                                        objectClassNode, targetClassReadNode);
+  auto *classEqualCondIfStmt = static_cast<IfStmtNode*>(builder->CreateStmtIf(classEqualCond));
+  classEqualCondIfStmt->GetThenPart()->AddStatement(cacheTrueClassesAssign);
+
+  BaseNode *classCacheTrueEqualCond = builder->CreateExprCompare(OP_ne, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                                 *GlobalTables::GetTypeTable().GetPtrType(),
+                                                                 targetClassReadNode, cacheTrueClassesReadNode);
+  auto *classCacheTrueEqualCondIfStmt = static_cast<IfStmtNode*>(builder->CreateStmtIf(classCacheTrueEqualCond));
+  classEqualCondIfStmt->GetThenPart()->AddStatement(classCacheTrueEqualCondIfStmt);
+
+  BaseNode *classCacheFalseEqualCond = builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(),
+                                                                  *GlobalTables::GetTypeTable().GetPtrType(),
+                                                                  targetClassReadNode, cacheFalseClassesReadNode);
+  auto *classCacheFalseEqualCondIfStmt =
+      static_cast<IfStmtNode*>(builder->CreateStmtIfThenElse(classCacheFalseEqualCond));
+  classCacheFalseEqualCondIfStmt->GetThenPart()->AddStatement(resultFalse);
+  classCacheFalseEqualCondIfStmt->GetElsePart()->AddStatement(callMCCIsAssignableFromStmt);
+
+  classCacheTrueEqualCondIfStmt->GetThenPart()->AddStatement(cacheFalseClassesAssign);
+  classCacheTrueEqualCondIfStmt->GetThenPart()->AddStatement(classCacheFalseEqualCondIfStmt);
+
+  blockNode.InsertBefore(&stmt, resultTrue);
+  if (isDefinedConstClass == false) {
+    blockNode.InsertBefore(&stmt, targetClassAssign);
+  }
+  blockNode.ReplaceStmt1WithStmt2(&stmt, classEqualCondIfStmt);
+}
+
+void CheckCastGenerator::CheckIsAssignableFrom(BlockNode &blockNode, StmtNode &stmt,
+                                               const IntrinsicopNode &intrinsicNode) {
+  MIRType *targetClassType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(intrinsicNode.GetTyIdx());
+  auto *ptrType = static_cast<MIRPtrType*>(targetClassType);
+  MIRType *ptype = ptrType->GetPointedType();
+  MIRTypeKind kd = ptype->GetKind();
+  if (Options::buildApp == 0 && kd == kTypeClass) {
+    auto *classType = static_cast<MIRClassType*>(ptype);
+    Klass *clazz = klassHierarchy->GetKlassFromTyIdx(classType->GetTypeIndex());
+    if (classType->IsFinal() || (clazz && clazz->IsPrivateInnerAndNoSubClass())) {
+      ReplaceNoSubClassIsAssignableFrom(blockNode, stmt, *ptrType, intrinsicNode);
+      return;
+    }
+  }
+  ReplaceIsAssignableFromUsingCache(blockNode, stmt, *ptrType, intrinsicNode);
+}
+
+void CheckCastGenerator::ConvertInstanceofToIsAssignableFrom(StmtNode &stmt, const IntrinsicopNode &intrinsicNode) {
+  MIRType *targetClassType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(intrinsicNode.GetTyIdx());
+  StmtNode *resultFalse = nullptr;
+  StmtNode *result = nullptr;
+  StmtNode *objectClassAssign = nullptr;
+  BaseNode *objectClassReadNode = nullptr;
+
+  MapleVector<BaseNode*> nopnd = intrinsicNode.GetNopnd();
+  BaseNode *opnd = nopnd[0];
+  BaseNode *ireadShadowExpr = GetObjectShadow(opnd);
+
+  ConstvalNode *falseVal = builder->GetConstUInt1(false);
+  BaseNode *nullVal = builder->CreateIntConst(0, PTY_ptr);
+  if (stmt.op == OP_regassign) {
+    auto *regAssignNode = static_cast<RegassignNode*>(&stmt);
+    PrimType classPrimType = ireadShadowExpr->GetPrimType();
+    MIRPreg *mirPreg = currFunc->GetPregTab()->PregFromPregIdx(regAssignNode->GetRegIdx());
+    resultFalse = builder->CreateStmtRegassign(mirPreg->GetPrimType(), regAssignNode->GetRegIdx(), falseVal);
+
+    PregIdx objectClassSymPregIdx = currFunc->GetPregTab()->CreatePreg(classPrimType);
+    objectClassAssign = builder->CreateStmtRegassign(classPrimType, objectClassSymPregIdx, ireadShadowExpr);
+    objectClassReadNode = builder->CreateExprRegread(PTY_ptr, objectClassSymPregIdx);
+
+    MapleVector<BaseNode*> arguments(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    arguments.push_back(objectClassReadNode);
+    BaseNode *assignableFromNode = builder->CreateExprIntrinsicop(INTRN_JAVA_ISASSIGNABLEFROM, OP_intrinsicopwithtype,
+                                                                  *targetClassType, arguments);
+    result = builder->CreateStmtRegassign(mirPreg->GetPrimType(), regAssignNode->GetRegIdx(), assignableFromNode);
+  } else {
+    auto *regAssignNode = static_cast<DassignNode*>(&stmt);
+    MIRSymbol *instanceOfRet = currFunc->GetLocalOrGlobalSymbol(regAssignNode->GetStIdx());
+    resultFalse = builder->CreateStmtDassign(*instanceOfRet, 0, falseVal);
+
+    MIRSymbol *objectClassSym = builder->GetOrCreateLocalDecl(kObjectClassSym, *GlobalTables::GetTypeTable().GetPtr());
+    objectClassAssign = builder->CreateStmtDassign(*objectClassSym, 0, ireadShadowExpr);
+    objectClassReadNode = builder->CreateExprDread(*objectClassSym);
+    MapleVector<BaseNode*> arguments(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    arguments.push_back(objectClassReadNode);
+    BaseNode *assignableFromNode = builder->CreateExprIntrinsicop(INTRN_JAVA_ISASSIGNABLEFROM, OP_intrinsicopwithtype,
+                                                                  *targetClassType, arguments);
+    result = builder->CreateStmtDassign(*instanceOfRet, 0, assignableFromNode);
+  }
+
+  BaseNode *condZero = builder->CreateExprCompare(
+      OP_ne, *GlobalTables::GetTypeTable().GetUInt1(), *GlobalTables::GetTypeTable().GetPtrType(), opnd, nullVal);
+  IfStmtNode *ifObjZeroNode = builder->CreateStmtIfThenElse(condZero);
+
+  ifObjZeroNode->GetThenPart()->AddStatement(objectClassAssign);
+  ifObjZeroNode->GetThenPart()->InsertLast(result);
+  ifObjZeroNode->GetElsePart()->AddStatement(resultFalse);
+
+  currFunc->GetBody()->InsertBefore(&stmt, ifObjZeroNode);
+  currFunc->GetBody()->RemoveStmt(&stmt);
+}
+
+void CheckCastGenerator::OptimizeInstanceof() {
+  StmtNode *stmt = currFunc->GetBody()->GetFirst();
+  StmtNode *next = nullptr;
+  while (stmt != nullptr) {
+    next = stmt->GetNext();
+    Opcode op = stmt->GetOpCode();
+    if (op == OP_dassign || op == OP_regassign) {
+      auto *unode = static_cast<UnaryStmtNode*>(stmt);
+      if (unode->GetRHS() != nullptr && unode->GetRHS()->GetOpCode() == OP_intrinsicopwithtype) {
+        auto *intrinsicNode = static_cast<IntrinsicopNode*>(unode->GetRHS());
+        ASSERT(intrinsicNode != nullptr, "null ptr check!");
+        if (intrinsicNode->GetIntrinsic() == INTRN_JAVA_INSTANCE_OF) {
+          ConvertInstanceofToIsAssignableFrom(*stmt, *intrinsicNode);
+        }
+      }
+    }
+    stmt = next;
+  }
+}
+
+void CheckCastGenerator::OptimizeIsAssignableFrom() {
+  StmtNode *stmt = currFunc->GetBody()->GetFirst();
+  StmtNode *next = nullptr;
+  while (stmt != nullptr) {
+    next = stmt->GetNext();
+    Opcode op = stmt->GetOpCode();
+    if (op == OP_if) {
+      auto *ifStmtNode = static_cast<IfStmtNode*>(stmt);
+      BlockNode *thenpart = ifStmtNode->GetThenPart();
+      ASSERT(thenpart != nullptr, "null ptr check!");
+      StmtNode *thenStmt = thenpart->GetFirst();
+      while (thenStmt != nullptr) {
+        if (thenStmt->GetOpCode() == OP_dassign || thenStmt->GetOpCode() == OP_regassign) {
+          auto *unode = static_cast<UnaryStmtNode*>(thenStmt);
+          ASSERT(unode->GetRHS() != nullptr, "null ptr check!");
+          if (unode->GetRHS()->GetOpCode() == OP_intrinsicopwithtype) {
+            auto *intrinsicNode = static_cast<IntrinsicopNode*>(unode->GetRHS());
+            if (intrinsicNode->GetIntrinsic() == INTRN_JAVA_ISASSIGNABLEFROM) {
+              CheckIsAssignableFrom(*thenpart, *thenStmt, *intrinsicNode);
+              break;
+            }
+          }
+        }
+        thenStmt = thenStmt->GetNext();
+      }
+    }
+    stmt = next;
+  }
+}
+
+void PreCheckCast::ProcessFunc(MIRFunction *func) {
+  if (func->IsEmpty()) {
+    return;
+  }
+  SetCurrentFunction(*func);
+  StmtNode *next = nullptr;
+  for (StmtNode *stmt = currFunc->GetBody()->GetFirst(); stmt != nullptr; stmt = next) {
+    next = stmt->GetNext();
+    if (stmt->GetOpCode() != OP_intrinsiccallwithtypeassigned) {
+      continue;
+    }
+
+    auto *callnode = static_cast<IntrinsiccallNode*>(stmt);
+    if (callnode == nullptr || callnode->GetIntrinsic() != INTRN_JAVA_CHECK_CAST) {
+      continue;
+    }
+
+    // handle the special case like (Type)null, we dont need a checkcast.
+    ASSERT(callnode->GetNopndSize() == 1, "");
+    BaseNode *opnd = callnode->Opnd(0);
+    if (opnd->op == OP_constval) {
+      ASSERT(!callnode->GetReturnVec().empty(), "container check");
+      CallReturnPair callretpair = callnode->GetCallReturnPair(0);
+      StmtNode *assignRet = nullptr;
+      if (!callretpair.second.IsReg()) {
+        assignRet = builder->CreateStmtDassign(callretpair.first, callretpair.second.GetFieldID(), opnd);
+      } else {
+        PregIdx pregidx = callretpair.second.GetPregIdx();
+        MIRPreg *mirpreg = currFunc->GetPregTab()->PregFromPregIdx(pregidx);
+        assignRet = builder->CreateStmtRegassign(mirpreg->GetPrimType(), pregidx, opnd);
+      }
+      func->GetBody()->ReplaceStmt1WithStmt2(stmt, assignRet);
+      continue;
+    }
+    // split OP_intrinsiccallwithtypeassigned to OP_intrinsiccall + dassign.
+    if (opnd->GetPrimType() != PTY_ref && opnd->GetPrimType() != PTY_ptr) {
+      continue;
+    }
+    ASSERT(!callnode->GetReturnVec().empty(), "container check");
+    CallReturnPair callretpair = callnode->GetCallReturnPair(0);
+    StmtNode *assignRet = nullptr;
+    if (!callretpair.second.IsReg()) {
+      assignRet = builder->CreateStmtDassign(callretpair.first, callretpair.second.GetFieldID(), opnd);
+    } else {
+      PregIdx pregidx = callretpair.second.GetPregIdx();
+      MIRPreg *mirpreg = currFunc->GetPregTab()->PregFromPregIdx(pregidx);
+      assignRet = builder->CreateStmtRegassign(mirpreg->GetPrimType(), pregidx, opnd);
+    }
+    func->GetBody()->InsertAfter(stmt, assignRet);
+    StmtNode *newCall = builder->CreateStmtIntrinsicCall(callnode->GetIntrinsic(), callnode->GetNopnd(),
+                                                         callnode->GetTyIdx());
+    func->GetBody()->ReplaceStmt1WithStmt2(stmt, newCall);
+  }
+}
+
+bool M2MPreCheckCast::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(PreCheckCast, m);
+  return true;
+}
+
+void M2MPreCheckCast::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+
+
+void CheckCastGenerator::ProcessFunc(MIRFunction *func) {
+  if (func->IsEmpty()) {
+    return;
+  }
+  SetCurrentFunction(*func);
+  bool isHotFunc = false;
+
+#ifdef USE_32BIT_REF
+  const auto &proFileData = GetMIRModule().GetProfile().GetFunctionProf();
+  const auto &funcItem = proFileData.find(func->GetName());
+  if (funcItem != proFileData.end()) {
+    int callTimes = (funcItem->second).callTimes;
+    isHotFunc = callTimes > 0;
+  }
+#endif
+
+  GenAllCheckCast(isHotFunc);
+  if (isHotFunc) {
+    OptimizeInstanceof();
+    OptimizeIsAssignableFrom();
+  }
+  MIRLower mirlowerer(GetMIRModule(), func);
+  mirlowerer.LowerFunc(*func);
+}
+
+bool M2MCheckCastGeneration::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(CheckCastGenerator, m);
+  return true;
+}
+
+void M2MCheckCastGeneration::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/gen_profile.cpp b/src/mapleall/mpl2mpl/src/gen_profile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a54af1b99d5379195bc3598a7f6605dd75186058
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/gen_profile.cpp
@@ -0,0 +1,410 @@
+/*
+ * Copyright (c) [2021-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "gen_profile.h"
+#include <ctime>
+#include "ipa_phase_manager.h"
+#include "namemangler.h"
+
+// namespace maple
+namespace maple {
+void ProfileGen::CreateModProfDesc() {
+  // Ref gcov_info
+  MIRBuilder *mirBuilder = mod.GetMIRBuilder();
+  MemPool *modMP = mod.GetMemPool();
+  FieldVector modProfDescFields;                                                   // Field
+  GStrIdx verStrIdx = mirBuilder->GetOrCreateStringIndex("version");               // 1
+  GStrIdx pad4b1StrIdx = mirBuilder->GetOrCreateStringIndex("pad4b1");             // 2
+  GStrIdx nextStrIdx = mirBuilder->GetOrCreateStringIndex("next");                 // 3
+  GStrIdx stampStrIdx = mirBuilder->GetOrCreateStringIndex("stamp");               // 4
+  GStrIdx chksumStrIdx = mirBuilder->GetOrCreateStringIndex("checksum");           // 5
+  GStrIdx outputFNStrIdx = mirBuilder->GetOrCreateStringIndex("outputfile_name");  // 6
+  GStrIdx mergeFuncsStrIdx = mirBuilder->GetOrCreateStringIndex("merge_funcs");    // 7
+  GStrIdx nFuncsStrIdx = mirBuilder->GetOrCreateStringIndex("n_funcs");            // 8
+  GStrIdx pad4b2StrIdx = mirBuilder->GetOrCreateStringIndex("pad4b2");             // 9
+  GStrIdx funcDescTblStrIdx = mirBuilder->GetOrCreateStringIndex("func_desc_tbl"); // 10
+
+  TyIdx i16TyIdx = GlobalTables::GetTypeTable().GetInt16()->GetTypeIndex();
+  MIRType *u32Ty = GlobalTables::GetTypeTable().GetUInt32();
+  TyIdx u32TyIdx = u32Ty->GetTypeIndex();
+  TyIdx ptrTyIdx = GlobalTables::GetTypeTable().GetPtr()->GetTypeIndex();
+  MIRType *voidTy = GlobalTables::GetTypeTable().GetVoid();
+  MIRType *voidPtrTy = GlobalTables::GetTypeTable().GetVoidPtr();
+  TyIdx charPtrTyIdx = GlobalTables::GetTypeTable().
+                           GetOrCreatePointerType(TyIdx(PTY_u8))->GetTypeIndex();
+
+  // Ref: __gcov_merge_add (gcov_type *, unsigned)
+  MIRType *retTy = GlobalTables::GetTypeTable().GetVoid();
+  std::vector<TyIdx> argTys;
+  std::vector<TypeAttrs> argAttrs;
+  MIRType *arg1Ty = GlobalTables::GetTypeTable().GetOrCreatePointerType(i16TyIdx); // need to verify on 7.5
+  MIRType *arg2Ty = GlobalTables::GetTypeTable().GetUInt16();
+  argTys.push_back(arg1Ty->GetTypeIndex());
+  argTys.push_back(arg2Ty->GetTypeIndex());
+  MIRType *funcTy = GlobalTables::GetTypeTable().GetOrCreateFunctionType(retTy->GetTypeIndex(), argTys, argAttrs);
+  MIRType *funcPtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(*funcTy, PTY_ptr);
+  MIRType *arrOfPtrsTy = GlobalTables::GetTypeTable().GetOrCreateArrayType(*funcPtrTy, kMplModProfMergeFuncs);
+  TyIdx arrOfPtrsTyIdx = arrOfPtrsTy->GetTypeIndex();
+
+  /* Form descriptor type                                                                                      Field */
+  modProfDescFields.emplace_back(FieldPair(verStrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));          // 1
+  modProfDescFields.emplace_back(FieldPair(pad4b1StrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));       // 2
+  modProfDescFields.emplace_back(FieldPair(nextStrIdx, TyIdxFieldAttrPair(ptrTyIdx, FieldAttrs())));         // 3
+  modProfDescFields.emplace_back(FieldPair(stampStrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));        // 4
+  modProfDescFields.emplace_back(FieldPair(chksumStrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));       // 5
+  modProfDescFields.emplace_back(FieldPair(outputFNStrIdx, TyIdxFieldAttrPair(charPtrTyIdx, FieldAttrs()))); // 6
+  modProfDescFields.emplace_back(
+      FieldPair(mergeFuncsStrIdx, TyIdxFieldAttrPair(arrOfPtrsTyIdx, FieldAttrs())));                     // 7
+  modProfDescFields.emplace_back(FieldPair(nFuncsStrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));       // 8
+  modProfDescFields.emplace_back(FieldPair(pad4b2StrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));       // 9
+  modProfDescFields.emplace_back(FieldPair(funcDescTblStrIdx, TyIdxFieldAttrPair(ptrTyIdx, FieldAttrs())));  // 10
+  FieldVector parentFields;
+
+  std::string srcFN = mod.GetFileName();
+  std::string useName = FlatenName(srcFN);
+
+  MIRType *modProfDescTy = GlobalTables::GetTypeTable().GetOrCreateStructType(
+      namemangler::kprefixProfModDesc + useName + "_ty", modProfDescFields, parentFields, mod);
+
+  MIRSymbol *modProfDescSym = mod.GetMIRBuilder()->CreateGlobalDecl(
+      namemangler::kprefixProfModDesc + useName, *modProfDescTy, kScFstatic);
+
+  // Initialization
+  MIRAggConst *modProfDescSymMirConst = modMP->New<MIRAggConst>(mod, *modProfDescTy);
+
+  MIRIntConst *verMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(kGCCVersion, *u32Ty);
+  modProfDescSymMirConst->AddItem(verMirConst, 1); // checked by gcov
+
+  MIRIntConst *zeroMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *u32Ty);
+  modProfDescSymMirConst->AddItem(zeroMirConst, 2);
+
+  MIRIntConst *nextMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *voidPtrTy);
+  modProfDescSymMirConst->AddItem(nextMirConst, 3);
+
+  uint32 timeStamp = time(nullptr);
+  MIRIntConst *stampMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(timeStamp, *u32Ty);
+  modProfDescSymMirConst->AddItem(stampMirConst, 4);
+
+  uint32 cfgChkSum = 0;
+  for (MIRFunction *f : validFuncs) {
+    cfgChkSum ^= static_cast<uint32>((f->GetCFGChksum() >> 32) ^ (f->GetCFGChksum() & 0xffffffff));
+  }
+  MIRIntConst *checksumMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(cfgChkSum, *u32Ty);
+  modProfDescSymMirConst->AddItem(checksumMirConst, 5);
+
+  // Make the profile file name as fileName.gcda
+  std::string profFileName = mod.GetFileName().substr(0, mod.GetFileName().find_last_of(".")) +
+      namemangler::kProfFileNameExt;
+  auto *profileFNMirConst =
+    modMP->New<MIRStrConst>(profFileName, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_a64)));
+  modProfDescSymMirConst->AddItem(profileFNMirConst, 6);
+
+  // Additional profiling (in addition to frequency profiling) should be added here
+  MIRFunction *profFuncProtoTy =
+      mod.GetMIRBuilder()->GetOrCreateFunction(namemangler::kMplMergeFuncAdd, voidTy->GetTypeIndex());
+  profFuncProtoTy->AllocSymTab();
+  MIRSymbol *profFuncArg1Sym = profFuncProtoTy->GetSymTab()->CreateSymbol(kScopeLocal);
+  profFuncArg1Sym->SetTyIdx(arg1Ty->GetTypeIndex());
+  profFuncProtoTy->AddArgument(profFuncArg1Sym);
+  MIRSymbol *profFuncArg2Sym = profFuncProtoTy->GetSymTab()->CreateSymbol(kScopeLocal);
+  profFuncArg2Sym->SetTyIdx(arg2Ty->GetTypeIndex());
+  profFuncProtoTy->AddArgument(profFuncArg2Sym);
+  MIRAddroffuncConst *profEdgeCountMirConst =
+      modMP->New<MIRAddroffuncConst>(profFuncProtoTy->GetPuidx(), *funcPtrTy);
+  MIRAggConst *mergeFuncsMirConst = modMP->New<MIRAggConst>(mod, *arrOfPtrsTy);
+
+  mergeFuncsMirConst->AddItem(profEdgeCountMirConst, 0);
+  mergeFuncsMirConst->AddItem(nextMirConst, 1);
+  mergeFuncsMirConst->AddItem(nextMirConst, 2);
+  mergeFuncsMirConst->AddItem(nextMirConst, 3);
+  mergeFuncsMirConst->AddItem(nextMirConst, 4);
+  mergeFuncsMirConst->AddItem(nextMirConst, 5);
+  mergeFuncsMirConst->AddItem(nextMirConst, 6);
+  mergeFuncsMirConst->AddItem(nextMirConst, 7);
+  mergeFuncsMirConst->AddItem(nextMirConst, 8);
+
+  modProfDescSymMirConst->AddItem(mergeFuncsMirConst, 7);
+
+  uint32 numOfFunc = validFuncs.size();
+  MIRIntConst *nfuncsMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(numOfFunc, *u32Ty);
+  modProfDescSymMirConst->AddItem(nfuncsMirConst, 8);
+
+  modProfDescSymMirConst->AddItem(zeroMirConst, 9);
+
+  // func_desc_tbl will be fixed up later in fixup
+  MIRAddrofConst *addrofConst = modMP->New<MIRAddrofConst>(
+      modProfDescSym->GetStIdx(), 0, *GlobalTables::GetTypeTable().GetPtr());
+  modProfDescSymMirConst->AddItem(addrofConst, 10);
+
+  modProfDescSym->SetKonst(modProfDescSymMirConst);
+  modProfDesc = modProfDescSym;
+}
+
+void ProfileGen::CreateFuncProfDesc() {
+  // Ref: gcov_ctr_info
+  //      gcov_fn_info
+  MIRBuilder *mirBuilder = mod.GetMIRBuilder();
+  MemPool *modMP = mod.GetMemPool();
+  FieldVector parentFields;
+  MIRType *u32Ty = GlobalTables::GetTypeTable().GetUInt32();
+  MIRType *i64Ty = GlobalTables::GetTypeTable().GetInt64();
+  MIRType *i64PtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(i64Ty->GetTypeIndex());
+
+  // Create counter info type                                            // Field
+  GStrIdx nCtrStrIdx = mirBuilder->GetOrCreateStringIndex("num_ctr");    // 1
+  GStrIdx ctrTblStrIdx = mirBuilder->GetOrCreateStringIndex("ctr_tbl");  // 2
+
+  FieldVector ctrInfoFields;
+  ctrInfoFields.emplace_back(FieldPair(nCtrStrIdx, TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));      // 1
+  ctrInfoFields.emplace_back(FieldPair(ctrTblStrIdx, TyIdxFieldAttrPair(i64PtrTy->GetTypeIndex(), FieldAttrs()))); // 2
+  MIRType *ctrDescTy = GlobalTables::GetTypeTable().GetOrCreateStructType(
+      "__mpl_ctr_desc_ty", ctrInfoFields, parentFields, mod);
+
+  // Create function profile descriptor type                                 // Field
+  GStrIdx modDescStrIdx = mirBuilder->GetOrCreateStringIndex("mod_desc");    // 1
+  GStrIdx funcIDStrIdx = mirBuilder->GetOrCreateStringIndex("func_id");      // 2
+  GStrIdx lnChkStrIdx = mirBuilder->GetOrCreateStringIndex("lineno_chksum"); // 3
+  GStrIdx cfgChkStrIdx = mirBuilder->GetOrCreateStringIndex("cfg_chksum");   // 4
+  GStrIdx pad4bStrIdx = mirBuilder->GetOrCreateStringIndex("pad4b");         // 5
+  GStrIdx ctrDescStrIdx = mirBuilder->GetOrCreateStringIndex("ctr_desc");    // 6
+
+  MIRType *modProfDescPtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(modProfDesc->GetTyIdx());
+  MIRType *arrOfCtrDescTy = GlobalTables::GetTypeTable().GetOrCreateArrayType(*ctrDescTy, kMplFuncProfCtrInfoNum);
+
+  FieldVector funcProfDescFields;                                                                             // Field
+  funcProfDescFields.emplace_back(
+      FieldPair(modDescStrIdx, TyIdxFieldAttrPair(modProfDescPtrTy->GetTypeIndex(), FieldAttrs())));    // 1
+  funcProfDescFields.emplace_back(FieldPair(funcIDStrIdx,
+                                            TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));  // 2
+  funcProfDescFields.emplace_back(FieldPair(lnChkStrIdx,
+                                            TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));  // 3
+  funcProfDescFields.emplace_back(FieldPair(cfgChkStrIdx,
+                                            TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));  // 4
+  funcProfDescFields.emplace_back(FieldPair(pad4bStrIdx,
+                                            TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));  // 5
+  funcProfDescFields.emplace_back(
+      FieldPair(ctrDescStrIdx, TyIdxFieldAttrPair(arrOfCtrDescTy->GetTypeIndex(), FieldAttrs())));      // 6
+
+  MIRType *funcProfDescTy =
+      GlobalTables::GetTypeTable().GetOrCreateStructType("__mpl_prof_desc_ty", funcProfDescFields, parentFields, mod);
+
+  for (MIRFunction *f : validFuncs) {
+    if (f->GetBody() == nullptr) {
+      continue;
+    }
+
+    uint64  nCtrs = f->GetNumCtrs();
+    MIRSymbol *ctrTblSym = f->GetProfCtrTbl();
+
+    // Initialization of counter table
+    MIRType *u64Ty = GlobalTables::GetTypeTable().GetUInt64();
+    MIRIntConst *zeroMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *u64Ty);
+    MIRType *arrOfUInt64Ty = GlobalTables::GetTypeTable().GetOrCreateArrayType(*u64Ty, nCtrs);
+    MIRAggConst *initCtrTblMirConst = modMP->New<MIRAggConst>(mod, *arrOfUInt64Ty);
+
+    if (ctrTblSym && nCtrs > 0) {
+      for (uint32 i = 0; i < nCtrs; ++i) {
+        initCtrTblMirConst->AddItem(zeroMirConst, i);
+      }
+      ctrTblSym->SetKonst(initCtrTblMirConst);
+    }
+
+    PUIdx puID = f->GetPuidx();
+
+    // Create const func profile descriptor
+    MIRAggConst *funcProfDescMirConst = modMP->New<MIRAggConst>(mod, *funcProfDescTy);
+
+    MIRAddrofConst *modDescMirConst = modMP->New<MIRAddrofConst>(modProfDesc->GetStIdx(), 0,
+                                                                 *GlobalTables::GetTypeTable().GetPtr());
+    funcProfDescMirConst->AddItem(modDescMirConst, 1);
+
+    uint32 funcID = puID;
+    MIRIntConst *funcIDMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(funcID, *u32Ty);
+    funcProfDescMirConst->AddItem(funcIDMirConst, 2);
+
+    uint32 lineNoChkSum = static_cast<uint32>((
+        f->GetFileLineNoChksum() >> 32) ^ (f->GetFileLineNoChksum() & 0xffffffff));
+    MIRIntConst *lineNoChkSumMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(lineNoChkSum, *u32Ty);
+    funcProfDescMirConst->AddItem(lineNoChkSumMirConst, 3);
+
+    uint32 cfgChkSum = static_cast<uint32>((f->GetCFGChksum() >> 32) ^ (f->GetCFGChksum() & 0xffffffff));
+    MIRIntConst *cfgChkSumMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(cfgChkSum, *u32Ty);
+    funcProfDescMirConst->AddItem(cfgChkSumMirConst, 4);
+
+    uint32 pad4b = 0;
+    MIRIntConst *pad4bMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(pad4b, *u32Ty);
+    funcProfDescMirConst->AddItem(pad4bMirConst, 5);
+
+    MIRAggConst *ctrDescMirConst = modMP->New<MIRAggConst>(mod, *ctrDescTy);
+
+    MIRIntConst *nCtrMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(nCtrs, *u32Ty);
+    ctrDescMirConst->AddItem(nCtrMirConst, 1);
+
+    MIRAddrofConst *ctrTblMirConst;
+    if (ctrTblSym) {
+      ctrTblMirConst = modMP->New<MIRAddrofConst>(ctrTblSym->GetStIdx(), 0, *GlobalTables::GetTypeTable().GetPtr());
+      ctrDescMirConst->AddItem(ctrTblMirConst, 2);
+    } else {
+      MIRType *voidPtrTy = GlobalTables::GetTypeTable().GetVoidPtr();
+      MIRIntConst *nullPtrMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *voidPtrTy);
+      ctrDescMirConst->AddItem(nullPtrMirConst, 2);
+    }
+
+    MIRType *mirType =
+        GlobalTables::GetTypeTable().GetOrCreateArrayType(*ctrDescTy, kMplFuncProfCtrInfoNum);
+    MIRAggConst *arrOfCtrDescMirConst = modMP->New<MIRAggConst>(mod, *mirType);
+
+    // if kMplFuncProfCtrInfoNum > 1, more counter descriptors need to add
+    arrOfCtrDescMirConst->AddItem(ctrDescMirConst, 0);
+    funcProfDescMirConst->AddItem(arrOfCtrDescMirConst, 6);
+
+    MIRSymbol *funcProfDescSym = mod.GetMIRBuilder()->CreateGlobalDecl(
+        namemangler::kprefixProfFuncDesc + FlatenName(mod.GetFileName() + "_" + f->GetName()),
+        *funcProfDescTy, kScFstatic);
+    funcProfDescSym->SetKonst(funcProfDescMirConst);
+    funcProfDescs.push_back(funcProfDescSym);
+  }
+}
+
+void ProfileGen::CreateFuncProfDescTbl() {
+  uint tblSize = validFuncs.size();
+  if (tblSize == 0) {
+    funcProfDescTbl = nullptr;
+    return;
+  }
+
+  // Create function descriptor table
+  MIRType *funcProfDescPtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(funcProfDescs[0]->GetTyIdx());
+  MIRType *arrOffuncProfDescPtrTy = GlobalTables::GetTypeTable().GetOrCreateArrayType(*funcProfDescPtrTy, tblSize);
+  std::string fileName = mod.GetFileName();
+  MIRSymbol *funcProfDescTblSym = mod.GetMIRBuilder()->CreateGlobalDecl(
+      namemangler::kprefixProfFuncDescTbl + FlatenName(fileName), *arrOffuncProfDescPtrTy, kScFstatic);
+  MIRAggConst *funcDescTblMirConst = mod.GetMemPool()->New<MIRAggConst>(mod, *arrOffuncProfDescPtrTy);
+
+  for (size_t i = 0; i < tblSize; ++i) {
+    MIRAddrofConst *funcProfDescMirConst = mod.GetMemPool()->New<MIRAddrofConst>(
+        funcProfDescs[i]->GetStIdx(), 0, *GlobalTables::GetTypeTable().GetPtr());
+    funcDescTblMirConst->AddItem(funcProfDescMirConst, i);
+  }
+
+  funcProfDescTblSym->SetKonst(funcDescTblMirConst);
+  funcProfDescTbl = funcProfDescTblSym;
+}
+
+void ProfileGen::FixupDesc() {
+  if (funcProfDescTbl == nullptr) {
+    return;
+  }
+
+  MIRAggConst *modProfDescMirConst = static_cast<MIRAggConst *>(modProfDesc->GetKonst());
+  MIRAddrofConst *funcProfDescTblAddr = mod.GetMemPool()->New<MIRAddrofConst>(
+      funcProfDescTbl->GetStIdx(), 0, *GlobalTables::GetTypeTable().GetPtr());
+  modProfDescMirConst->SetItem(9, funcProfDescTblAddr, 10);
+}
+
+// Ref: void gcov_init (struct gcov_info *info);
+void ProfileGen::CreateInitProc() {
+  MIRBuilder *mirBuilder = mod.GetMIRBuilder();
+  MIRFunction *origFunc = mirBuilder->GetCurrentFunction();
+
+  MIRType *voidTy = GlobalTables::GetTypeTable().GetVoid();
+  ArgVector formals(mod.GetMPAllocator().Adapter());
+  MIRFunction *mplProfInit = mirBuilder->CreateFunction(
+      namemangler::kprefixProfInit + FlatenName(mod.GetFileName()), *voidTy, formals);
+  mplProfInit->SetPuidxOrigin(mplProfInit->GetPuidx());
+  mplProfInit->SetAttr(FUNCATTR_initialization);
+  mirBuilder->SetCurrentFunction(*mplProfInit);
+
+  MIRFunction *gccProfInitProtoTy = mirBuilder->GetOrCreateFunction(
+      namemangler::kGCCProfInit, voidTy->GetTypeIndex());
+  gccProfInitProtoTy->AllocSymTab();
+  MIRSymbol *gccProfInitArgSym = gccProfInitProtoTy->GetSymTab()->CreateSymbol(kScopeLocal);
+  MIRType *argPtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(modProfDesc->GetTyIdx());
+  gccProfInitArgSym->SetTyIdx(argPtrTy->GetTypeIndex());
+  gccProfInitProtoTy->AddArgument(gccProfInitArgSym);
+
+  MapleVector<BaseNode*> ActArg(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  AddrofNode *addrModProfDesc = mirBuilder->CreateExprAddrof(0, *modProfDesc);
+  ActArg.push_back(addrModProfDesc);
+  CallNode *callGInit = mirBuilder->CreateStmtCall(gccProfInitProtoTy->GetPuidx(), ActArg);
+
+  BlockNode *block = mplProfInit->GetCodeMemPool()->New<BlockNode>();
+  block->AddStatement(callGInit);
+  mplProfInit->SetBody(block);
+  mod.AddFunction(mplProfInit);
+
+  mirBuilder->SetCurrentFunction(*origFunc);
+}
+
+// Ref: void gcov_exit ();
+void ProfileGen::CreateExitProc() {
+  MIRBuilder *mirBuilder = mod.GetMIRBuilder();
+  MIRFunction *origFunc = mirBuilder->GetCurrentFunction();
+  MIRType *voidTy = GlobalTables::GetTypeTable().GetVoid();
+
+  ArgVector formals(mod.GetMPAllocator().Adapter());
+  MIRFunction *mplProfExit = mirBuilder->CreateFunction(
+      namemangler::kprefixProfExit + FlatenName(mod.GetFileName()), *voidTy, formals);
+  mplProfExit->SetPuidxOrigin(mplProfExit->GetPuidx());
+  mplProfExit->SetAttr(FUNCATTR_termination);
+  mirBuilder->SetCurrentFunction(*mplProfExit);
+
+  MIRFunction *gccProfExitProtoTy = mirBuilder->GetOrCreateFunction(namemangler::kGCCProfExit, voidTy->GetTypeIndex());
+  gccProfExitProtoTy->AllocSymTab();
+
+  MapleVector<BaseNode*> ActArg(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  CallNode *callGExit = mirBuilder->CreateStmtCall(gccProfExitProtoTy->GetPuidx(), ActArg);
+
+  BlockNode *block = mplProfExit->GetCodeMemPool()->New<BlockNode>();
+  block->AddStatement(callGExit);
+  mplProfExit->SetBody(block);
+  mod.AddFunction(mplProfExit);
+
+  mirBuilder->SetCurrentFunction(*origFunc);
+}
+
+void ProfileGen::Run() {
+  // Note: all internal symbols are named as prefix+mplfilename (+ funcname)
+
+  // Create module profile descriptor (.LPBX0)
+  CreateModProfDesc();
+
+  // Create function profile descriptor including counter table
+  CreateFuncProfDesc();
+
+  // Create function profile descriptor table (.LPBX1)
+  CreateFuncProfDescTbl();
+
+  // Fixup symbol references among descriptors
+  FixupDesc();
+
+  // Create module profile init proc (_sub_I_00100_0)
+  CreateInitProc();
+
+  // Create module profiling exit proc (_sub_D_00100_1)
+  CreateExitProc();
+}
+
+bool ProfileGenPM::PhaseRun(MIRModule &mod) {
+  ProfileGen profileGen(mod);
+  profileGen.Run();
+  return false;
+}
+
+void ProfileGenPM::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  // Note: IpaSccPM calls MeProfGen to finish instrumentation based on MST
+  aDep.AddRequired<IpaSccPM>();
+  aDep.AddPreserved<IpaSccPM>();
+}
+}
diff --git a/src/mapleall/mpl2mpl/src/ginline.cpp b/src/mapleall/mpl2mpl/src/ginline.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d204cf31f9e94d3cb2ebaaa0f9db1d53aa9b1176
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/ginline.cpp
@@ -0,0 +1,436 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ginline.h"
+
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include "global_tables.h"
+#include "inline_analyzer.h"
+#include "inline_summary.h"
+#include "inline_transformer.h"
+#include "mpl_logging.h"
+#include "me_predict.h"
+
+namespace maple {
+// This phase performs greedy or global inline.
+static constexpr double kHundredPercent = 100.0;
+void GInline::Init() {
+  InitParams();
+}
+
+void GInline::InitParams() {
+  dumpDetail = (Options::dumpPhase == "ginline");
+  dumpFunc = Options::dumpFunc;
+}
+
+// Return false if callsite will not be inlined
+bool GInline::ConsiderInlineCallsite(CallInfo &info, uint32 depth) {
+  bool canInline = InlineAnalyzer::CanInline(info, *cg, depth);
+  bool result = canInline && InlineAnalyzer::WantInline(info, *cg, depth);
+  auto ifCode = static_cast<uint32>(info.GetInlineFailedCode());
+  ++inlineStat[ifCode];
+  if (!result) {
+    bool skipPrint = info.GetInlineFailedCode() == kIFC_EmptyCallee;
+    if (dumpDetail && !skipPrint) {
+      const char *flag = !canInline ? "can not inline" : "don't want inline";
+      LogInfo::MapleLogger() << "[" << flag << "] " << " " << info.GetCaller()->GetName() << "->" <<
+          info.GetCallee()->GetName() << " because: " << GetInlineFailedStr(info.GetInlineFailedCode()) << std::endl;
+      // for debug
+      if (info.GetInlineFailedCode() == kIFC_NotDeclaredInlineGrow) {
+        auto *badInfo = CalcBadness(info);
+        auto *callsiteNode = alloc.New<CallSiteNode>(info, *badInfo, depth);
+        callsiteNode->Dump();
+        LogInfo::MapleLogger() << std::endl;
+      }
+    }
+  }
+  return result;
+}
+
+void GInline::AddNewEdge(const std::vector<CallInfo*> &newCallInfo, uint32 depth) {
+  for (CallInfo *callInfo : newCallInfo) {
+    if (!ConsiderInlineCallsite(*callInfo, depth)) {
+      continue;
+    }
+    InsertNewCallSite(*callInfo, depth);
+  }
+}
+
+// recompute the badness of src of the callsite after inlining.
+void GInline::UpdateCaller(CGNode &callerNode) {
+  std::vector<CallInfo*> callers;
+  callerNode.GetCaller(callers);
+  for (auto *callInfo : callers) {
+    UpdateCallSite(*callInfo);
+  }
+}
+
+int64 GInline::GetFunctionStaticInsns(MIRFunction &func) const {
+  auto *summary = func.GetInlineSummary();
+  if (summary == nullptr || !summary->IsTrustworthy()) {
+    StmtCostAnalyzer stmtCostAnalyzer(alloc.GetMemPool(), &func);
+    auto cost = stmtCostAnalyzer.GetStmtsCost(func.GetBody());
+    return static_cast<int64>(cost / kHundredPercent);
+  }
+  return static_cast<int64>(summary->GetStaticInsns());
+}
+
+int64 GInline::ComputeTotalSize() const {
+  int64 total = 0;
+  for (auto it = cg->Begin(); it != cg->End(); ++it) {
+    MIRFunction *func = it->first;
+    if (func->GetBody() == nullptr) {
+      continue;
+    }
+    int64 cost = GetFunctionStaticInsns(*func);
+    total += cost;
+  }
+  return total;
+}
+
+int64 GInline::ComputeMaxSize(bool enableMoreGrowthForSmallModule = false) const {
+  constexpr int64 kSmallModuleTreshold = 10000;
+  auto moduleGrowthPercent = Options::inlineModuleGrowth;
+  int64 max = 0;
+  if (enableMoreGrowthForSmallModule && initSize < kSmallModuleTreshold) {
+    max = kSmallModuleTreshold;
+  } else {
+    max = static_cast<int64>(initSize * (moduleGrowthPercent + kHundredPercent) / kHundredPercent);
+  }
+  return max;
+}
+
+// + callee cost; - callstmt cost.
+BadnessInfo *GInline::CalcBadness(CallInfo &info) {
+  auto *badInfo = alloc.New<BadnessInfo>();
+  CalcBadnessImpl(info, *cg, *badInfo);
+  return badInfo;
+}
+
+void GInline::InsertNewCallSite(CallInfo &info, uint32 depth) {
+  MIRFunction *caller = info.GetCaller();
+  MIRFunction *callee = info.GetCallee();
+  CHECK_NULL_FATAL(caller);
+  CHECK_NULL_FATAL(callee);
+
+  auto *badInfo = CalcBadness(info);
+  auto *callsiteNode = alloc.New<CallSiteNode>(info, *badInfo, depth);
+  (void)callSiteSet.emplace(callsiteNode);
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "Enqueue ";
+    callsiteNode->Dump();
+    LogInfo::MapleLogger() << std::endl;
+  }
+}
+
+MapleSet<CallSiteNode*, CallSiteNodeCmp>::iterator GInline::FindCallsiteInSet(uint32 callId) const {
+  for (auto it = callSiteSet.begin(); it != callSiteSet.end(); ++it) {
+    if ((*it)->GetCallInfo()->GetID() == callId) {
+      return it;
+    }
+  }
+  return callSiteSet.end();
+}
+
+void GInline::UpdateCallSite(CallInfo &info) {
+  MIRFunction *caller = info.GetCaller();
+  MIRFunction *callee = info.GetCallee();
+  CHECK_NULL_FATAL(caller);
+  CHECK_NULL_FATAL(callee);
+
+  auto it = FindCallsiteInSet(info.GetID());
+  if (it == callSiteSet.end()) {
+    return;  // the callsite is not a candidate
+  }
+  auto *badInfo = CalcBadness(info);
+  auto *newNode = alloc.New<CallSiteNode>(info, *badInfo, (*it)->GetDepth());
+  (void)callSiteSet.erase(it);
+  (void)callSiteSet.emplace(newNode);
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "Update ";
+    newNode->Dump();
+    LogInfo::MapleLogger() << std::endl;
+  }
+}
+
+static void PrintAll(MapleSet<CallSiteNode*, CallSiteNodeCmp> &set) {
+  LogInfo::MapleLogger() << "print all" << std::endl;
+  LogInfo::MapleLogger() <<
+      "id\tlineno\tcol\tcaller\tcallee\tcallerId\tcalleeId\torigBadness\tbadness\tfreq\tgrowth\ttime\t";
+  LogInfo::MapleLogger() << "uninlinedTime\tinlinedTime\toverallGrowth" << std::endl;
+  for (auto *callSite : set) {
+    callSite->DumpBrief();
+  }
+}
+
+void PrintInlineFailedDistribution(const MapleVector<uint32> &inlineStat, uint32 total, bool success) {
+  if (total == 0) {
+    return;
+  }
+  for (size_t i = 0; i < inlineStat.size(); ++i) {
+    auto cnt = inlineStat[i];
+    if (cnt == 0) {
+      continue;
+    }
+    auto code = InlineFailedCode(i);
+    auto type = GetInlineFailedType(code);
+    bool print = (success && type == kIFT_FinalOk) || (!success && type != kIFT_FinalOk);
+    if (!print) {
+      continue;
+    }
+    const char *failStr = GetInlineFailedStr(code);
+    double percent = kHundredPercent * cnt / total;
+    LogInfo::MapleLogger() << "  [" << cnt << ", " << percent << "%] " << failStr << std::endl;
+  }
+}
+
+void GInline::PrintGInlineReport() const {
+  LogInfo::MapleLogger() << "===== GInline Report =====" << std::endl;
+  int64 netChangeSum = static_cast<int32>(curSize) - static_cast<int32>(initSize);
+  LogInfo::MapleLogger() << "Growth after ginline: " << initSize << "->" << curSize << " (" <<
+      (netChangeSum * kHundredPercent / initSize) << "%)" << std::endl;
+  uint32 totalFailCnt = 0;
+  for (auto cnt : inlineStat) {
+    if (cnt == 0) {
+      continue;
+    }
+    totalFailCnt += cnt;
+  }
+  LogInfo::MapleLogger() << "Total inline success: " << totalSuccessCnt << std::endl;
+  PrintInlineFailedDistribution(inlineStat, totalSuccessCnt, true);
+  LogInfo::MapleLogger() << "Total inline failed: " << totalFailCnt << std::endl;
+  PrintInlineFailedDistribution(inlineStat, totalFailCnt, false);
+  LogInfo::MapleLogger() << std::endl;
+}
+
+// We try to inline shallow small callee (especially with inline attr), ignoring overall growth limit
+bool GInline::CanIgnoreGrowthLimit(const CallSiteNode &callSiteNode) {
+  auto ifCode = callSiteNode.GetCallInfo()->GetInlineFailedCode();
+  if (ifCode == kIFC_InlineList || ifCode == kIFC_InlineListCallsite || ifCode == kIFC_HardCoded ||
+      ifCode == kIFC_ProfileHotCallsite) {
+    return true;
+  }
+  if (!Options::ginlineAllowIgnoreGrowthLimit) {
+    return false;
+  }
+  auto depth = callSiteNode.GetDepth();
+  if (depth > Options::ginlineMaxDepthIgnoreGrowthLimit) {
+    return false;
+  }
+  auto *callee = callSiteNode.GetCallInfo()->GetCallee();
+  uint32 thresholdSmallFunc = Options::ginlineSmallFunc;
+  uint32 relaxThreshold = 1;
+  if (CalleeCanBeRemovedIfInlined(*callSiteNode.GetCallInfo(), *cg)) {
+    relaxThreshold = Options::ginlineRelaxSmallFuncCanbeRemoved;
+  } else if (callee->IsInline()) {
+    constexpr uint32 defaultRelaxForInlineNormalFreq = 2;
+    relaxThreshold = callSiteNode.GetCallFreqPercent() >= 1 ?
+        Options::ginlineRelaxSmallFuncDecalredInline : defaultRelaxForInlineNormalFreq;
+        // caller is small enough and non-declared inline, relax threshold further
+    auto *caller = callSiteNode.GetCallInfo()->GetCaller();
+    std::optional<uint32> callerSize = GetFuncSize(*caller);
+    if (!callerSize && callerSize.value() <= thresholdSmallFunc && !caller->IsInline()) {
+      relaxThreshold += thresholdSmallFunc;
+    }
+  }
+  thresholdSmallFunc *= relaxThreshold;
+  auto growth = callSiteNode.GetGrowth();
+  return growth <= static_cast<int32>(thresholdSmallFunc);
+}
+
+void GInline::PrepareCallsiteSet() {
+  // Init callsite set
+  for (auto it = cg->Begin(); it != cg->End(); ++it) {
+    CGNode *node = it->second;
+    for (auto &edge : node->GetCallee()) {
+      CallInfo *info = edge.first;
+      if (!ConsiderInlineCallsite(*info, 0)) {
+        continue;
+      }
+      CHECK_FATAL(edge.second->size() == 1, "Call stmt has only one candidate.");
+      InsertNewCallSite(*info, 0);
+    }
+  }
+  if (dumpDetail) {
+    PrintAll(callSiteSet);
+    LogInfo::MapleLogger() << "Ready to pick up inline candidate. CurSize: " << curSize <<
+        ", MaxSize: " << maxSize << ", Allow growth: " << (maxSize - curSize) * kHundredPercent / curSize << "%\n";
+  }
+}
+
+void GInline::AfterInlineSuccess(const CallSiteNode &heapNode, const std::vector<CallInfo*> &newCallInfo,
+    bool canBeRemoved, int64 lastSize) {
+  ++totalSuccessCnt;
+  CallInfo *callsite = heapNode.GetCallInfo();
+  if (callsite->GetInlineFailedCode() == kIFC_NeedFurtherAnalysis) {
+    callsite->SetInlineFailedCode(kIFC_Ok);
+    --inlineStat[static_cast<uint32>(kIFC_NeedFurtherAnalysis)];
+    ++inlineStat[static_cast<uint32>(kIFC_Ok)];
+  }
+  auto growth = heapNode.GetGrowth();
+  curSize += growth;
+  MIRFunction *callee = callsite->GetCallee();
+  auto calleeStaticSize = callee->GetInlineSummary()->GetStaticInsns();
+  if (canBeRemoved) {
+    curSize -= calleeStaticSize;
+  }
+  if (dumpDetail) {
+    auto netChange = static_cast<int64>(curSize) - lastSize;
+    LogInfo::MapleLogger() << "size net change of " << netChange << ", curSize: " << curSize << std::endl;
+  }
+  auto depth = heapNode.GetDepth();
+  AddNewEdge(newCallInfo, depth + 1);
+  MIRFunction *caller = callsite->GetCaller();
+  auto *callerNode = cg->GetCGNode(caller);
+  CHECK_NULL_FATAL(callerNode);
+  UpdateCaller(*callerNode);
+}
+
+void GInline::InlineCallsiteSet() {
+  while (!callSiteSet.empty()) {
+    auto *heapNode = *callSiteSet.begin();
+    (void)callSiteSet.erase(callSiteSet.begin());
+    int64 lastSize = curSize;
+    bool ignoreLimit = CanIgnoreGrowthLimit(*heapNode);
+    if (curSize > maxSize && !ignoreLimit) {
+      // reach limit, continue.
+      if (dumpDetail) {
+        LogInfo::MapleLogger() << "Reach growth limit(" << maxSize << "), continue. ";
+        heapNode->Dump();
+        LogInfo::MapleLogger() << std::endl;
+      }
+      continue;
+    }
+    CallInfo *callsite = heapNode->GetCallInfo();
+    CallNode *callNode = safe_cast<CallNode>(callsite->GetCallStmt());
+    CHECK_NULL_FATAL(callNode);
+    CHECK_NULL_FATAL(callNode->GetEnclosingBlock());
+    MIRFunction *caller = callsite->GetCaller();
+    MIRFunction *callee = callsite->GetCallee();
+    CHECK_NULL_FATAL(caller);
+    CHECK_NULL_FATAL(callee);
+    // `canBeRemoved` must be calculated before PerformInline
+    bool canBeRemoved = CalleeCanBeRemovedIfInlined(*callsite, *cg);
+    if (dumpDetail) {
+      LogInfo::MapleLogger() << "Pick ";
+      heapNode->Dump();
+      LogInfo::MapleLogger() << (ignoreLimit ? " ignoreLimit\n" : "\n");
+    }
+    auto *transformer = alloc.New<InlineTransformer>(kGreedyInline, *caller, *callee, *callNode, true, cg);
+    std::vector<CallInfo*> newCallInfo;
+    bool inlined = transformer->PerformInline(&newCallInfo);
+    if (dumpDetail && !newCallInfo.empty()) {
+      LogInfo::MapleLogger() << "new call info:" << std::endl;
+      for (auto *callInfo : newCallInfo) {
+        callInfo->Dump();
+        LogInfo::MapleLogger() << std::endl;
+      }
+    }
+    if (inlined) {
+      AfterInlineSuccess(*heapNode, newCallInfo, canBeRemoved, lastSize);
+    }
+  }
+}
+
+void GInline::Inline() {
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "===== ginline begin =====" << std::endl;
+  }
+  BlockCallBackMgr::AddCallBack(UpdateEnclosingBlockCallback, nullptr);
+  initSize = ComputeTotalSize();
+  curSize = initSize;
+  maxSize = ComputeMaxSize();
+  PrepareCallsiteSet();
+  InlineCallsiteSet();
+  if (dumpDetail) {
+    PrintGInlineReport();
+  }
+  if (Options::inlineToAllCallers) {
+    TryInlineToAllCallers();
+  }
+  Options::dumpPhase = "";  // FOR DEBUG
+}
+
+void GInline::TryInlineToAllCallers() {
+  const MapleVector<SCCNode<CGNode>*> &topVec = cg->GetSCCTopVec();
+  for (auto it = topVec.rbegin(); it != topVec.rend(); ++it) {
+    for (CGNode *node : (*it)->GetNodes()) {
+      TryInlineToAllCallers(*node);
+    }
+  }
+}
+
+// Inline `calleeCgNode` into it's all callers if possible
+void GInline::TryInlineToAllCallers(const CGNode &calleeCgNode) {
+  std::vector<CallInfo*> callInfos;
+  if (!ShouldBeInlinedToAllCallers(calleeCgNode, callInfos, *cg)) {
+    return;
+  }
+  auto *callee = calleeCgNode.GetMIRFunction();
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "inline " << callee->GetName() << " to all callers" << std::endl;
+  }
+  for (auto *callInfo : callInfos) {
+    auto *caller = callInfo->GetCaller();
+    if (dumpDetail) {
+      LogInfo::MapleLogger() << "  [toCallers] " << caller->GetName() << "(insns: " <<
+          caller->GetInlineSummary()->GetStaticInsns() <<  ") -> " << callee->GetName() << "(insns: " <<
+          callee->GetInlineSummary()->GetStaticInsns() << ")" << std::endl;
+    }
+    CallNode *callNode = static_cast<CallNode*>(callInfo->GetCallStmt());
+    auto *transformer = alloc.New<InlineTransformer>(kGreedyInline, *caller, *callee, *callNode, true, cg);
+    std::vector<CallInfo*> newCallInfos;
+    (void)transformer->PerformInline(&newCallInfos);
+  }
+}
+
+void GInline::CleanupInline() {
+  InlineListInfo::Clear();
+  BlockCallBackMgr::ClearCallBacks();
+  // Release all inline summary
+  for (auto *func : module.GetFunctionList()) {
+    if (func != nullptr) {
+      func->DiscardInlineSummary();
+    }
+  }
+  module.ReleaseInlineSummaryAlloc();
+  return;
+}
+
+// Unified interface to run minline module phase.
+bool M2MGInline::PhaseRun(maple::MIRModule &m) {
+  MemPool *tempMemPool = ApplyTempMemPool();
+  CHECK_NULL_FATAL(tempMemPool);
+  GetAnalysisInfoHook()->ForceEraseAnalysisPhase(m.GetUniqueID(), &M2MCallGraph::id);
+  (void)GetAnalysisInfoHook()->ForceRunAnalysisPhase<MapleModulePhase, MIRModule>(&M2MCallGraph::id, m);
+
+  CallGraph *cg = GET_ANALYSIS(M2MCallGraph, m);
+  CHECK_FATAL(cg != nullptr, "Expecting a valid CallGraph, found nullptr");
+  GInline gInline(m, tempMemPool, cg);
+  gInline.Inline();
+  if (m.firstInline) {
+    m.firstInline = false;
+  }
+  return true;
+}
+
+void M2MGInline::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MCallGraph>();
+  aDep.PreservedAllExcept<M2MCallGraph>();
+}
+}  // namespace maple
+
diff --git a/src/mapleall/mpl2mpl/src/inline.cpp b/src/mapleall/mpl2mpl/src/inline.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3c7a5871cf8880978682517f5a43b910ec2064cb
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/inline.cpp
@@ -0,0 +1,810 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "inline.h"
+
+#include <fstream>
+#include <iostream>
+
+#include "global_tables.h"
+#include "inline_analyzer.h"
+#include "inline_summary.h"
+#include "mpl_logging.h"
+
+namespace maple {
+constexpr uint32 kHalfInsn = 1;
+constexpr uint32 kOneInsn = 2;
+constexpr uint32 kDoubleInsn = 4;
+constexpr uint32 kPentupleInsn = 10;
+constexpr uint32 kBigFuncNumStmts = 1000;
+static constexpr uint32 kRelaxThresholdForInlineHint = 3;
+static constexpr uint32 kRelaxThresholdForCalledOnce = 5;
+static constexpr uint32 kInlineSmallFunctionThresholdForJava = 15;
+static constexpr uint32 kInlineHotFunctionThresholdForJava = 30;
+static constexpr uint32 kThresholdForOs = 10;
+static constexpr uint32 kScaleDownForNewCostModel = 5;
+
+static uint32 GetNumStmtsOfFunc(const MIRFunction &func) {
+  if (func.GetBody() == nullptr) {
+    return 0;
+  }
+  const auto &stmtNodes = func.GetBody()->GetStmtNodes();
+  if (stmtNodes.empty()) {
+    return 0;
+  }
+  return stmtNodes.back().GetStmtID() - stmtNodes.front().GetStmtID();
+}
+
+void MInline::Init() {
+  InitParams();
+  if (inlineWithProfile) {
+    InitProfile();
+  }
+  BlockCallBackMgr::AddCallBack(UpdateEnclosingBlockCallback, nullptr);
+}
+
+void MInline::InitParams() {
+  dumpDetail = (Options::dumpPhase == "inline");
+  dumpFunc = Options::dumpFunc;
+  if (Options::optForSize) {
+    smallFuncThreshold = kThresholdForOs;
+  } else {
+    smallFuncThreshold = Options::inlineSmallFunctionThreshold;
+  }
+  hotFuncThreshold = Options::inlineHotFunctionThreshold;
+  // Reset inlining threshold for other srcLang, especially for srcLangJava. Because those methods related to
+  // reflection in Java cannot be inlined safely.
+  if (module.GetSrcLang() != kSrcLangC) {
+    smallFuncThreshold = kInlineSmallFunctionThresholdForJava;
+    hotFuncThreshold = kInlineHotFunctionThresholdForJava;
+  } else if (performEarlyInline) {
+    // use new cost model, scale down the thresholds
+    constexpr uint32 smallFuncIfEnableGInline = 14;
+    smallFuncThreshold = smallFuncIfEnableGInline;
+    hotFuncThreshold /= kScaleDownForNewCostModel;
+  }
+  recursiveFuncThreshold = Options::inlineRecursiveFunctionThreshold;
+  inlineWithProfile = Options::inlineWithProfile;
+}
+
+void MInline::InitProfile() const {
+  // maple profile use different profile data, return
+  if (Options::profileUse) {
+    return;
+  }
+  uint32 dexNameIdx = module.GetFileinfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_filename"));
+  const std::string &dexName = GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(dexNameIdx));
+  bool deCompressSucc = module.GetProfile().DeCompress(Options::profile, dexName);
+  LogInfo::MapleLogger() << "dexName: " << dexName << '\n';
+  if (!deCompressSucc) {
+    LogInfo::MapleLogger() << "WARN: DeCompress() failed in DoInline::Run()\n";
+  }
+}
+
+// Here, one insn's cost is 2.
+FuncCostResultType MInline::GetFuncCost(const MIRFunction &func, const BaseNode &baseNode, uint32 &cost,
+                                        uint32 threshold) const {
+  if (cost > threshold) {
+    return kFuncBodyTooBig;
+  }
+  Opcode op = baseNode.GetOpCode();
+  switch (op) {
+    case OP_block: {
+      const BlockNode &blk = static_cast<const BlockNode&>(baseNode);
+      for (auto &stmt : blk.GetStmtNodes()) {
+        FuncCostResultType funcCostResultType = GetFuncCost(func, stmt, cost, threshold);
+        if (funcCostResultType != kSmallFuncBody) {
+          return funcCostResultType;
+        }
+      }
+      break;
+    }
+    case OP_switch: {
+      const SwitchNode &switchNode = static_cast<const SwitchNode&>(baseNode);
+      cost += static_cast<uint32>(switchNode.GetSwitchTable().size() + 1);
+      break;
+    }
+    case OP_call:
+    case OP_callassigned: {
+      PUIdx puIdx = static_cast<const CallNode&>(baseNode).GetPUIdx();
+      MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+      if (callee->GetName().find("setjmp") != std::string::npos) {
+        cost += smallFuncThreshold;
+        break;
+      }
+    }
+    [[clang::fallthrough]];
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_customcall:
+    case OP_polymorphiccall:
+    case OP_intrinsiccall:
+    case OP_intrinsiccallwithtype:
+    case OP_xintrinsiccall:
+    case OP_intrinsiccallassigned:
+    case OP_intrinsiccallwithtypeassigned:
+    case OP_xintrinsiccallassigned:
+    case OP_virtualcall:
+    case OP_superclasscall:
+    case OP_interfacecall:
+    case OP_virtualcallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_throw: {
+      cost += kPentupleInsn;
+      break;
+    }
+    case OP_intrinsicop:
+    case OP_intrinsicopwithtype: {
+      const IntrinsicopNode &node = static_cast<const IntrinsicopNode&>(baseNode);
+      switch (node.GetIntrinsic()) {
+        case INTRN_JAVA_CONST_CLASS:
+        case INTRN_JAVA_ARRAY_LENGTH:
+          cost += kOneInsn;
+          break;
+        case INTRN_JAVA_MERGE:
+          cost += kHalfInsn;
+          break;
+        case INTRN_JAVA_INSTANCE_OF:
+          cost += kPentupleInsn;
+          break;
+        case INTRN_MPL_READ_OVTABLE_ENTRY:
+          cost += kDoubleInsn;
+          break;
+        case INTRN_C_ctz32:
+        case INTRN_C_clz32:
+        case INTRN_C_clz64:
+        case INTRN_C_constant_p:
+          cost += kOneInsn;
+          break;
+        case INTRN_C___builtin_expect:
+          break;  // builtin_expect has no cost
+        default:
+          // Other intrinsics generate a call
+          cost += kPentupleInsn;
+          break;
+      }
+      break;
+    }
+    case OP_jstry:
+    case OP_try:
+    case OP_jscatch:
+    case OP_catch:
+    case OP_finally:
+    case OP_cleanuptry:
+    case OP_endtry:
+    case OP_syncenter:
+    case OP_syncexit: {
+      return kNotAllowedNode;
+    }
+    case OP_membaracquire:
+    case OP_membarrelease:
+    case OP_membarstoreload:
+    case OP_membarstorestore: {
+      cost += kOneInsn;
+      break;
+    }
+    case OP_comment:
+    case OP_return:
+    case OP_label:
+      break;
+    case OP_dread: {
+      const DreadNode &dread = static_cast<const DreadNode&>(baseNode);
+      bool isLocal = dread.GetStIdx().Islocal();
+      if (!isLocal) {
+        cost += kDoubleInsn;
+      }
+      break;
+    }
+    case OP_dassign: {
+      const DassignNode &dassign = static_cast<const DassignNode&>(baseNode);
+      bool isLocal = dassign.GetStIdx().Islocal();
+      if (!isLocal) {
+        cost += kDoubleInsn;
+      }
+      break;
+    }
+    case OP_cvt: {
+      cost += kHalfInsn;
+      break;
+    }
+    case OP_alloca: {
+      cost += smallFuncThreshold;
+      break;
+    }
+    default: {
+      cost += kOneInsn;
+      break;
+    }
+  }
+  for (size_t i = 0; i < baseNode.NumOpnds(); ++i) {
+    FuncCostResultType funcCostResultType = GetFuncCost(func, *(baseNode.Opnd(i)), cost, threshold);
+    if (funcCostResultType != kSmallFuncBody) {
+      return funcCostResultType;
+    }
+  }
+  return kSmallFuncBody;
+}
+
+bool MInline::HasAccessStatic(const BaseNode &baseNode) const {
+  Opcode op = baseNode.GetOpCode();
+  switch (op) {
+    case OP_block: {
+      const BlockNode &blk = static_cast<const BlockNode&>(baseNode);
+      for (auto &stmt : blk.GetStmtNodes()) {
+        bool ret = HasAccessStatic(stmt);
+        if (ret) {
+          return true;
+        }
+      }
+      break;
+    }
+    case OP_addrof:
+    case OP_dread: {
+      const DreadNode &dread = static_cast<const DreadNode&>(baseNode);
+      bool isLocal = dread.GetStIdx().Islocal();
+      if (!isLocal) {
+        MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(dread.GetStIdx().Idx());
+        return symbol->IsStatic();
+      }
+      break;
+    }
+    case OP_dassign: {
+      const DassignNode &dassign = static_cast<const DassignNode&>(baseNode);
+      bool isLocal = dassign.GetStIdx().Islocal();
+      if (!isLocal) {
+        MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(dassign.GetStIdx().Idx());
+        return symbol->IsStatic();
+      }
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  for (size_t i = 0; i < baseNode.NumOpnds(); ++i) {
+    bool ret = HasAccessStatic(*(baseNode.Opnd(i)));
+    if (ret) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static void MarkParent(const CGNode &node) {
+  for (auto &pair : node.GetCaller()) {
+    CGNode *parent = pair.first;
+    parent->SetMustNotBeInlined();
+  }
+}
+
+bool MInline::IsHotCallSite(const MIRFunction &caller, const MIRFunction &callee, const CallNode &callStmt) const {
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "[CHECK_HOT] " << callee.GetName() << " to " << caller.GetName() << " op "
+                           << callStmt.GetOpCode() << '\n';
+  }
+  // use maple instrument profile
+  if (Options::profileUse) {
+    if (!caller.GetFuncProfData()) {return false;}
+    int64_t freq = static_cast<int64_t>(caller.GetFuncProfData()->GetStmtFreq(callStmt.GetStmtID()));
+    ASSERT(freq > 0, "sanity check");
+    return module.GetMapleProfile()->IsHotCallSite(static_cast<uint64_t>(freq));
+  }
+  return module.GetProfile().CheckFuncHot(caller.GetName());
+}
+
+void MInline::InlineCalls(CGNode &node) {
+  currInlineDepth = 0;  // reset inline depth for each new caller
+  MIRFunction *func = node.GetMIRFunction();
+  if (func == nullptr || func->GetBody() == nullptr || func->IsFromMpltInline()) {
+    return;
+  }
+  // The caller is big enough, we don't inline any callees more
+  if (GetNumStmtsOfFunc(*func) > kBigFuncNumStmts) {
+    return;
+  }
+  bool changed = false;
+  do {
+    changed = false;
+    // We use bfs to solve all the callsites.
+    // For recursive func, we use the original body in one level, even though the real body has changed.
+    // However, in order to make the recursive inline stop quickly, we will update the original body in next level.
+    node.SetOriginBody(nullptr);
+    InlineCallsBlock(*func, *(func->GetBody()), *(func->GetBody()), changed, *(func->GetBody()));
+    ++currInlineDepth;
+  } while (changed && currInlineDepth < Options::inlineDepth);
+}
+
+bool MInline::CalleeReturnValueCheck(StmtNode &stmtNode, CallNode &callStmt) {
+  NaryStmtNode &returnNode = static_cast<NaryStmtNode&>(stmtNode);
+  if (!kOpcodeInfo.IsCallAssigned(callStmt.GetOpCode()) && returnNode.NumOpnds() == 0) {
+    return true;
+  }
+  if (returnNode.NumOpnds() != 1 || returnNode.NumOpnds() != callStmt.GetCallReturnVector()->size()) {
+    return false;
+  } else {
+    if (returnNode.Opnd(0)->GetOpCode() != OP_dread) {
+      return false;
+    }
+    AddrofNode *retNode = static_cast<AddrofNode*>(returnNode.Opnd(0));
+    RegFieldPair &tmp = callStmt.GetCallReturnVector()->at(0).second;
+    if (retNode->GetFieldID() != 0 || tmp.IsReg() || tmp.GetFieldID() != 0) {
+      return false;
+    }
+    if (static_cast<AddrofNode*>(retNode)->GetStIdx() == callStmt.GetCallReturnVector()->at(0).first) {
+      return true;
+    }
+  }
+  return false;
+}
+bool MInline::SuitableForTailCallOpt(BaseNode &enclosingBlk, const StmtNode &stmtNode, CallNode &callStmt) {
+  // if call stmt have arguments, it may be better to be inlined
+  if (!module.IsCModule() || callStmt.GetNumOpnds() != 0) {
+    return false;
+  }
+  if (stmtNode.GetRealNext() != nullptr && stmtNode.GetRealNext()->GetOpCode() == OP_return) {
+    return CalleeReturnValueCheck(static_cast<StmtNode&>(*stmtNode.GetRealNext()), callStmt);
+  }
+  if (enclosingBlk.GetOpCode() == OP_if) {
+    IfStmtNode &ifStmt = static_cast<IfStmtNode&>(enclosingBlk);
+    if (ifStmt.GetRealNext() != nullptr && ifStmt.GetRealNext()->GetOpCode() == OP_return &&
+        stmtNode.GetRealNext() == nullptr) {
+      return CalleeReturnValueCheck(static_cast<StmtNode&>(*ifStmt.GetRealNext()), callStmt);
+    }
+  }
+  return false;
+}
+void MInline::InlineCallsBlock(MIRFunction &func, BlockNode &enclosingBlk, BaseNode &baseNode, bool &changed,
+                               BaseNode &prevStmt) {
+  if (baseNode.GetOpCode() == OP_block) {
+    BlockNode &blk = static_cast<BlockNode&>(baseNode);
+    for (auto &stmt : blk.GetStmtNodes()) {
+      InlineCallsBlock(func, blk, stmt, changed, prevStmt);
+    }
+  } else if (baseNode.GetOpCode() == OP_callassigned || baseNode.GetOpCode() == OP_call ||
+             baseNode.GetOpCode() == OP_virtualcallassigned || baseNode.GetOpCode() == OP_superclasscallassigned ||
+             baseNode.GetOpCode() == OP_interfacecallassigned) {
+    CallNode &callStmt = static_cast<CallNode&>(baseNode);
+    if (SuitableForTailCallOpt(prevStmt, static_cast<StmtNode&>(baseNode), callStmt)) {
+      return;
+    }
+    InlineCallsBlockInternal(func, baseNode, changed);
+  } else if (baseNode.GetOpCode() == OP_doloop) {
+    BlockNode *blk = static_cast<DoloopNode&>(baseNode).GetDoBody();
+    InlineCallsBlock(func, enclosingBlk, *blk, changed, baseNode);
+  } else if (baseNode.GetOpCode() == OP_foreachelem) {
+    BlockNode *blk = static_cast<ForeachelemNode&>(baseNode).GetLoopBody();
+    InlineCallsBlock(func, enclosingBlk, *blk, changed, baseNode);
+  } else if (baseNode.GetOpCode() == OP_dowhile || baseNode.GetOpCode() == OP_while) {
+    BlockNode *blk = static_cast<WhileStmtNode&>(baseNode).GetBody();
+    InlineCallsBlock(func, enclosingBlk, *blk, changed, baseNode);
+  } else if (baseNode.GetOpCode() == OP_if) {
+    BlockNode *blk = static_cast<IfStmtNode&>(baseNode).GetThenPart();
+    InlineCallsBlock(func, enclosingBlk, *blk, changed, baseNode);
+    blk = static_cast<IfStmtNode&>(baseNode).GetElsePart();
+    if (blk != nullptr) {
+      InlineCallsBlock(func, enclosingBlk, *blk, changed, baseNode);
+    }
+  }
+}
+
+static InlineResult GetInlineResult(uint32 threshold, uint32 thresholdType, uint32 cost) {
+  if (cost == UINT32_MAX) {
+    return InlineResult(false, "NOT_ALLOWED_NODE");
+  }
+
+  if (cost <= threshold) {
+    switch (thresholdType) {
+      case kSmallFuncThreshold:
+        return InlineResult(true, "AUTO_INLINE");
+      case kHotFuncThreshold:
+        return InlineResult(true, "AUTO_INLINE_HOT");
+      case kRecursiveFuncThreshold:
+        return InlineResult(true, "AUTO_INLINE_RECURSIVE_FUNCTION");
+      case kHotAndRecursiveFuncThreshold:
+        return InlineResult(true, "AUTO_INLINE_HOT_RECURSIVE_FUNCTION");
+      default:
+        break;
+    }
+  }
+  switch (thresholdType) {
+    case kSmallFuncThreshold:
+      return InlineResult(false, "TOO_BIG " + std::to_string(cost));
+    case kHotFuncThreshold:
+      return InlineResult(false, "HOT_METHOD_TOO_BIG " + std::to_string(cost));
+    case kRecursiveFuncThreshold:
+      return InlineResult(false, "RECURSIVE_FUNCTION_TOO_BIG " + std::to_string(cost));
+    case kHotAndRecursiveFuncThreshold:
+      return InlineResult(false, "HOT_RECURSIVE_FUNCTION_TOO_BIG " + std::to_string(cost));
+    default:
+      break;
+  }
+  return InlineResult(false, "IMPOSSIBLE SITUATION!!!");
+}
+
+void MInline::AdjustInlineThreshold(const MIRFunction &caller, MIRFunction &callee, const CallNode &callStmt,
+                                    uint32 &threshold, uint32 &thresholdType) {
+  // Update threshold if this callsite is hot, or dealing with recursive function
+  if (inlineWithProfile && IsHotCallSite(caller, callee, callStmt)) {
+    threshold = hotFuncThreshold;
+    thresholdType = kHotFuncThreshold;
+  }
+  if (&caller == &callee) {
+    threshold = (threshold > recursiveFuncThreshold) ? threshold : recursiveFuncThreshold;
+    if (thresholdType != kHotFuncThreshold) {
+      thresholdType = kRecursiveFuncThreshold;
+    } else {
+      thresholdType = kHotAndRecursiveFuncThreshold;
+    }
+  }
+  // More tolerant of functions with inline attr
+  if (callee.GetAttr(FUNCATTR_inline)) {
+    threshold <<= kRelaxThresholdForInlineHint;
+  }
+  // We don't always inline called_once callee to avoid super big caller
+  auto *calleeCgNode = cg->GetCGNode(&callee);
+  CHECK_NULL_FATAL(calleeCgNode);
+  if (module.GetSrcLang() == kSrcLangC && callee.GetAttr(FUNCATTR_called_once) &&
+      CanCGNodeBeRemovedIfNoDirectCalls(*calleeCgNode)) {
+    threshold <<= kRelaxThresholdForCalledOnce;
+  }
+}
+
+bool MInline::IsSmallCalleeForEarlyInline(MIRFunction &callee, int32 *outInsns = nullptr) {
+  MemPool tempMemPool(memPoolCtrler, "");
+  StmtCostAnalyzer stmtCostAnalyzer(&tempMemPool, &callee);
+  int32 insns = 0;
+  for (auto &stmt : callee.GetBody()->GetStmtNodes()) {
+    insns += stmtCostAnalyzer.EstimateNumInsns(&stmt);
+    if (static_cast<uint32>(insns) > smallFuncThreshold) {
+      return false;
+    }
+  }
+  if (outInsns != nullptr) {
+    *outInsns = insns;
+  }
+  return true;
+}
+
+InlineResult MInline::AnalyzeCallee(const MIRFunction &caller, MIRFunction &callee, const CallNode &callStmt) {
+  uint32 thresholdType = kSmallFuncThreshold;
+  uint32 threshold = smallFuncThreshold;
+  AdjustInlineThreshold(caller, callee, callStmt, threshold, thresholdType);
+  uint32 cost = 0;
+  BlockNode *calleeBody = callee.GetBody();
+  auto *calleeNode = cg->GetCGNode(&callee);
+  CHECK_NULL_FATAL(calleeNode);
+  if (&caller == &callee && calleeNode->GetOriginBody() != nullptr) {
+    // This is self recursive inline
+    calleeBody = calleeNode->GetOriginBody();
+  }
+  if (performEarlyInline) {
+    NumInsns calleeInsns = 0;
+    if (IsSmallCalleeForEarlyInline(callee, &calleeInsns)) {
+      return InlineResult(true, "EARLY_INLINE");
+    }
+    return InlineResult(false, "CALLEE TOO BIG FOR EINLINE " + std::to_string(calleeInsns));
+  } else {
+    if (funcToCostMap.find(&callee) != funcToCostMap.end()) {
+      cost = funcToCostMap[&callee];
+    } else {
+      FuncCostResultType checkResult = GetFuncCost(callee, *calleeBody, cost, threshold);
+      if (checkResult == kNotAllowedNode) {
+        funcToCostMap[&callee] = UINT32_MAX;
+        return InlineResult(false, "NOT_ALLOWED_NODE");
+      } else {
+        funcToCostMap[&callee] = cost;
+      }
+    }
+  }
+  auto ret = GetInlineResult(threshold, thresholdType, cost);
+  return ret;
+}
+
+void MInline::PostInline(MIRFunction &caller) {
+  auto it = funcToCostMap.find(&caller);
+  if (it != funcToCostMap.end()) {
+    (void)funcToCostMap.erase(it);
+  }
+}
+
+static inline void DumpCallsiteAndLoc(const MIRFunction &caller, const MIRFunction &callee, const CallNode &callStmt) {
+  auto lineNum = callStmt.GetSrcPos().LineNum();
+  LogInfo::MapleLogger() << callee.GetName() << " to " << caller.GetName() << " (line " << lineNum << ")\n";
+}
+
+void MInline::InlineCallsBlockInternal(MIRFunction &func, BaseNode &baseNode, bool &changed) {
+  CallNode &callStmt = static_cast<CallNode&>(baseNode);
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt.GetPUIdx());
+  CGNode *cgNode = cg->GetCGNode(&func);
+  CallInfo *callInfo  = cgNode->GetCallInfo(callStmt);
+  std::pair<bool, InlineFailedCode> canInlineRet =
+      InlineAnalyzer::CanInlineImpl({&func, callee}, callStmt, *cg, currInlineDepth, true);  // earlyInline: true
+  bool canInline = canInlineRet.first;
+  InlineFailedCode failCode = canInlineRet.second;
+  if (callInfo != nullptr) {  // cache result to avoid recompute
+    callInfo->SetInlineFailedCode(failCode);
+  }
+  InlineResult result;
+  result.reason = GetInlineFailedStr(failCode);
+  if (canInline) {
+    result = AnalyzeCallee(func, *callee, callStmt);
+    canInline = result.canInline;
+  }
+  if (canInline) {
+    module.SetCurFunction(&func);
+    if (dumpDetail && dumpFunc == func.GetName()) {
+      LogInfo::MapleLogger() << "[Dump before inline ] " << func.GetName() << '\n';
+      func.Dump(false);
+    }
+    auto *transformer = alloc.New<InlineTransformer>(kEarlyInline, func, *callee, callStmt, dumpDetail, cg);
+    bool inlined = transformer->PerformInline();
+    if (inlined) {
+      PostInline(func);
+    }
+    // A inlined callee is never regarded as called_once
+    callee->UnSetAttr(FUNCATTR_called_once);
+    if (dumpDetail && dumpFunc == func.GetName()) {
+      LogInfo::MapleLogger() << "[Dump after inline ] " << func.GetName() << '\n';
+      func.Dump(false);
+    }
+    changed = (inlined ? true : changed);
+    if (inlined && callee->IsFromMpltInline()) {
+      LogInfo::MapleLogger() << "[CROSS_MODULE] [" << result.reason << "] ";
+      DumpCallsiteAndLoc(func, *callee, callStmt);
+    }
+    if (dumpDetail && inlined) {
+      if (callee->IsFromMpltInline()) {
+        LogInfo::MapleLogger() << "[CROSS_MODULE] [" << result.reason << "] ";
+        DumpCallsiteAndLoc(func, *callee, callStmt);
+      } else {
+        LogInfo::MapleLogger() << "[" << result.reason << "] ";
+        DumpCallsiteAndLoc(func, *callee, callStmt);
+      }
+    }
+  } else {
+    if (dumpDetail) {
+      LogInfo::MapleLogger() << "[INLINE_FAILED] " << "[" << result.reason << "] ";
+      DumpCallsiteAndLoc(func, *callee, callStmt);
+    }
+  }
+}
+
+void MInline::ComputeTotalSize() {
+  for (auto it = cg->CBegin(); it != cg->CEnd(); ++it) {
+    CGNode *caller = it->second;
+    totalSize += caller->GetNodeCount();
+  }
+}
+
+void MInline::MarkUnInlinableFunction() const {
+  const MapleVector<SCCNode<CGNode>*> &topVec = cg->GetSCCTopVec();
+  for (auto it = topVec.rbegin(); it != topVec.rend(); ++it) {
+    for (CGNode *node : (*it)->GetNodes()) {
+      MIRFunction *func = node->GetMIRFunction();
+      if (!func->IsEmpty() && func->IsFromMpltInline() &&
+          (node->IsMustNotBeInlined() || HasAccessStatic(*func->GetBody()))) {
+        node->SetMustNotBeInlined();
+        if (func->IsStatic() && node->HasCaller()) {
+          MarkParent(*node);
+        }
+        continue;
+      }
+
+      const std::string &name = func->GetName();
+      if (node->IsMustNotBeInlined() || StringUtils::StartsWith(name, kDalvikSystemStr) ||
+          StringUtils::StartsWith(name, kJavaLangThreadStr)) {
+        node->SetMustNotBeInlined();
+        if (node->HasCaller()) {
+          MarkParent(*node);
+        }
+      }
+    }
+  }
+}
+
+void MInline::Inline() {
+  ComputeTotalSize();
+  MarkUnInlinableFunction();
+  const MapleVector<SCCNode<CGNode>*> &topVec = cg->GetSCCTopVec();
+  for (MapleVector<SCCNode<CGNode>*>::const_reverse_iterator it = topVec.rbegin(); it != topVec.rend(); ++it) {
+    for (CGNode *node : (*it)->GetNodes()) {
+      // If a function is called only once by a single caller, we set the func called_once. Callee will be set first.
+      if (node->NumberOfUses() == 1 && node->NumReferences() == 1 && !node->IsAddrTaken()) {
+        node->GetMIRFunction()->SetAttr(FUNCATTR_called_once);
+      }
+      InlineCalls(*node);
+    }
+  }
+  return;
+}
+
+void MInline::CleanupInline() {
+  InlineListInfo::Clear();
+  BlockCallBackMgr::ClearCallBacks();
+  const MapleVector<SCCNode<CGNode>*> &topVec = cg->GetSCCTopVec();
+  for (MapleVector<SCCNode<CGNode>*>::const_reverse_iterator it = topVec.rbegin(); it != topVec.rend(); ++it) {
+    for (CGNode *node : (*it)->GetNodes()) {
+      MIRFunction *func = node->GetMIRFunction();
+      if (func != nullptr && func->IsFromMpltInline()) {
+        // visit all the func which has been inlined, mark the static symbol, string symbol and function symbol as used.
+        if (node->GetInlinedTimes() > 0) {
+          MarkFunctionUsed(func, true);
+        }
+        if (!func->IsStatic()) {
+          func->SetBody(nullptr);
+          func->ReleaseCodeMemory();
+          func->ReleaseMemory();
+        }
+      }
+    }
+  }
+  // after marking all the used symbols, set the other symbols as unused.
+  for (size_t i = 1; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(static_cast<uint32>(i));
+    if (symbol != nullptr && symbol->IsTmpUnused()) {
+      symbol->SetStorageClass(kScUnused);
+      if (dumpDetail) {
+        LogInfo::MapleLogger() << "[INLINE_UNUSED_SYMBOL] " << symbol->GetName() << '\n';
+      }
+    }
+  }
+  if (dumpDetail) {
+    LogInfo::MapleLogger() << "[INLINE_SUMMARY] " << module.GetFileName() << '\n';
+    for (auto &it : cg->GetNodesMap()) {
+      auto times = it.second->GetInlinedTimes();
+      if (times == 0) {
+        continue;
+      }
+      LogInfo::MapleLogger() << "[INLINE_SUMMARY] " << it.first->GetName() << " => " << times << '\n';
+    }
+    LogInfo::MapleLogger() << "[INLINE_SUMMARY] " << module.GetFileName() << '\n';
+  }
+  return;
+}
+
+void MInline::MarkSymbolUsed(const StIdx &symbolIdx) const {
+  MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolIdx.Idx());
+  symbol->SetIsTmpUnused(false);
+  if (symbol->IsConst()) {
+    auto *konst = symbol->GetKonst();
+    switch (konst->GetKind()) {
+      case kConstAddrof: {
+        auto *addrofKonst = static_cast<MIRAddrofConst*>(konst);
+        MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(addrofKonst->GetSymbolIndex().Idx());
+        MarkSymbolUsed(sym->GetStIdx());
+        break;
+      }
+      case kConstAddrofFunc: {
+        auto *addrofFuncKonst = static_cast<MIRAddroffuncConst*>(konst);
+        auto *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(addrofFuncKonst->GetValue());
+        MarkFunctionUsed(func);
+        break;
+      }
+      case kConstAggConst: {
+        auto &constVec = static_cast<MIRAggConst*>(konst)->GetConstVec();
+        for (auto *cst : constVec) {
+          if (cst == nullptr) {
+            continue;
+          }
+          if (cst->GetKind() == kConstAddrofFunc) {
+            auto *addrofFuncKonst = static_cast<MIRAddroffuncConst*>(cst);
+            auto *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(addrofFuncKonst->GetValue());
+            MarkFunctionUsed(func);
+          }
+        }
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+  std::string syName = symbol->GetName();
+  // when _PTR_C_STR_XXXX is used, mark _C_STR_XXXX as used too.
+  if (StringUtils::StartsWith(syName, namemangler::kPtrPrefixStr)) {
+    GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(syName.substr(strlen(namemangler::kPtrPrefixStr)));
+    MIRSymbol *anotherSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(gStrIdx);
+    anotherSymbol->SetIsTmpUnused(false);
+  }
+}
+
+void MInline::MarkFunctionUsed(MIRFunction *func, bool inlined) const {
+  if (func == nullptr) {
+    return;
+  }
+  if (func->IsVisited()) {
+    return;
+  }
+  func->SetIsVisited();
+  ASSERT_NOT_NULL(func->GetFuncSymbol());
+  func->GetFuncSymbol()->SetIsTmpUnused(false);
+  // We should visit the body if the function is static or it has been inlined for at least one time.
+  if (func->IsStatic() || inlined) {
+    MarkUsedSymbols(func->GetBody());
+  }
+}
+
+void MInline::MarkUsedSymbols(const BaseNode *baseNode) const {
+  if (baseNode == nullptr) {
+    return;
+  }
+  Opcode op = baseNode->GetOpCode();
+  switch (op) {
+    case OP_block: {
+      const BlockNode *blk = static_cast<const BlockNode*>(baseNode);
+      for (auto &stmt : blk->GetStmtNodes()) {
+        MarkUsedSymbols(&stmt);
+      }
+      break;
+    }
+    case OP_dassign: {
+      const DassignNode *dassignNode = static_cast<const DassignNode*>(baseNode);
+      MarkSymbolUsed(dassignNode->GetStIdx());
+      break;
+    }
+    case OP_addrof:
+    case OP_dread: {
+      const AddrofNode *dreadNode = static_cast<const AddrofNode*>(baseNode);
+      MarkSymbolUsed(dreadNode->GetStIdx());
+      break;
+    }
+    case OP_addroffunc: {
+      auto *addroffunc = static_cast<const AddroffuncNode*>(baseNode);
+      MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(addroffunc->GetPUIdx());
+      MarkFunctionUsed(func);
+      break;
+    }
+    case OP_call:
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned:
+    case OP_intrinsiccallwithtypeassigned: {
+      const CallNode *callStmt = static_cast<const CallNode*>(baseNode);
+      MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt->GetPUIdx());
+      MarkFunctionUsed(callee);
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  for (size_t i = 0; i < baseNode->NumOpnds(); ++i) {
+    MarkUsedSymbols(baseNode->Opnd(i));
+  }
+}
+
+// Unified interface to run inline module phase.
+bool M2MInline::PhaseRun(maple::MIRModule &m) {
+  MemPool *memPool = ApplyTempMemPool();
+  CallGraph *cg = GET_ANALYSIS(M2MCallGraph, m);
+  CHECK_FATAL(cg != nullptr, "Expecting a valid CallGraph, found nullptr");
+  MInline mInline(m, memPool, cg);
+  mInline.Inline();
+  if (m.firstInline) {
+    m.firstInline = false;
+  }
+  return true;
+}
+
+void M2MInline::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MCallGraph>();
+  aDep.PreservedAllExcept<M2MCallGraph>();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/inline_analyzer.cpp b/src/mapleall/mpl2mpl/src/inline_analyzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c08be8fb17bc8c1d4c69ababb6b72648a64ecebe
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/inline_analyzer.cpp
@@ -0,0 +1,941 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "inline_analyzer.h"
+#include <fstream>
+#include <iostream>
+#include "factory.h"
+#include "global_tables.h"
+#include "mpl_logging.h"
+#include "ssa_tab.h"
+#include "inline_transformer.h"
+#include "inline_summary.h"
+#include "inline.h"
+
+namespace maple {
+static bool IsOrContainsAddrofLabel(const MIRConst &mirConst) {
+  auto constKind = mirConst.GetKind();
+  if (constKind == kConstLblConst) {
+    return true;
+  }
+  if (constKind == kConstAggConst) {
+    // Example code: static void *b[] = { &&addr }
+    const auto &aggConst = static_cast<const MIRAggConst&>(mirConst);
+    for (const auto *subMirConst : aggConst.GetConstVec()) {
+      if (IsOrContainsAddrofLabel(*subMirConst)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool IsFuncForbiddenToCopy(const MIRFunction &func) {
+  if (!func.GetLabelTab()->GetAddrTakenLabels().empty()) {
+    return true;
+  }
+  // func can not be copied when it save local label address in a local static variable
+  for (size_t i = 0; i < func.GetSymbolTabSize(); ++i) {
+    MIRSymbol *sym = func.GetSymbolTabItem(static_cast<uint32>(i));
+    if (sym == nullptr || sym->GetStorageClass() != kScPstatic) {
+      continue;
+    }
+    bool hasInitValue = (sym->GetSKind() == kStConst || sym->GetSKind() == kStVar) && sym->GetKonst() != nullptr;
+    if (!hasInitValue) {
+      continue;
+    }
+    if (IsOrContainsAddrofLabel(*sym->GetKonst())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static constexpr int32 kHugeFuncNumInsns = 1800;
+
+bool InlineListInfo::valid = false;
+std::map<GStrIdx, std::set<GStrIdx>*> InlineListInfo::inlineList;
+std::map<GStrIdx, std::set<GStrIdx>*> InlineListInfo::noInlineList;
+std::map<std::pair<GStrIdx, GStrIdx>, uint32> InlineListInfo::callsiteProfile;
+std::set<GStrIdx> InlineListInfo::hardCodedCallees;
+std::set<GStrIdx> InlineListInfo::excludedCallers;
+std::set<GStrIdx> InlineListInfo::excludedCallees;
+std::set<GStrIdx> InlineListInfo::rcWhiteList;
+
+const std::map<GStrIdx, std::set<GStrIdx>*> &InlineListInfo::GetInlineList() {
+  Prepare();
+  return inlineList;
+}
+
+const std::map<GStrIdx, std::set<GStrIdx>*> &InlineListInfo::GetNoInlineList() {
+  Prepare();
+  return noInlineList;
+}
+
+const CallsiteProfile &InlineListInfo::GetCallsiteProfile() {
+  Prepare();
+  return callsiteProfile;
+}
+
+const std::set<GStrIdx> &InlineListInfo::GetHardCodedCallees() {
+  Prepare();
+  return hardCodedCallees;
+}
+
+const std::set<GStrIdx> &InlineListInfo::GetExcludedCallers() {
+  Prepare();
+  return excludedCallers;
+}
+
+const std::set<GStrIdx> &InlineListInfo::GetExcludedCallees() {
+  Prepare();
+  return excludedCallees;
+}
+
+const std::set<GStrIdx> &InlineListInfo::GetRCWhiteList() {
+  Prepare();
+  return rcWhiteList;
+}
+
+// trim both leading and trailing space and tab
+static void TrimString(std::string &str) {
+  size_t pos = str.find_first_not_of(kSpaceTabStr);
+  if (pos != std::string::npos) {
+    str = str.substr(pos);
+  } else {
+    str.clear();
+  }
+  pos = str.find_last_not_of(kSpaceTabStr);
+  if (pos != std::string::npos) {
+    str = str.substr(0, pos + 1);
+  }
+}
+
+void InlineListInfo::ApplyInlineListInfo(const std::string &path, std::map<GStrIdx, std::set<GStrIdx>*> &listCallee) {
+  if (path.empty()) {
+    return;
+  }
+  std::ifstream infile(path);
+  if (!infile.is_open()) {
+    LogInfo::MapleLogger(kLlErr) << "Cannot open function list file " << path << '\n';
+    return;
+  }
+  LogInfo::MapleLogger() << "[INLINE] read function from list: " << path << '\n';
+  std::string str;
+  GStrIdx calleeStrIdx;
+  while (getline(infile, str)) {
+    TrimString(str);
+    if (str.empty() || str[0] == kCommentsignStr[0]) {
+      continue;
+    }
+    if (str[0] != kHyphenStr[0]) {
+      calleeStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(str);
+      auto it = listCallee.find(calleeStrIdx);
+      if (it == listCallee.end()) {
+        auto *callerList = new std::set<GStrIdx>();
+        (void)listCallee.emplace(calleeStrIdx, callerList);
+      }
+    } else {
+      size_t pos = str.find_first_not_of(kAppointStr);
+      CHECK_FATAL(pos != std::string::npos, "cannot find '->' ");
+      str = str.substr(pos);
+      GStrIdx callerStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(str);
+      auto it = listCallee.find(calleeStrIdx);
+      CHECK_FATAL(it != listCallee.end(), "illegal configuration for inlineList");
+      (void)it->second->insert(callerStrIdx);
+    }
+  }
+  infile.close();
+}
+
+void InlineListInfo::ReadCallsiteProfile(const std::string &path, CallsiteProfile &callProfile) {
+  if (path.empty()) {
+    return;
+  }
+  std::ifstream infile(path);
+  if (!infile.is_open()) {
+    LogInfo::MapleLogger(kLlErr) << "Cannot open callsite profile: " << path << '\n';
+    return;
+  }
+  LogInfo::MapleLogger() << "[INLINE] read callsite profile: " << path << '\n';
+  std::string str;
+  while (getline(infile, str)) {
+    TrimString(str);
+    if (str.empty() || str[0] == kCommentsignStr[0]) {
+      continue;
+    }
+    const char delimiter = ' ';
+    auto first = str.find_first_of(delimiter);
+    auto last = str.find_last_of(delimiter);
+    auto caller = str.substr(0, first);
+    auto callerStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(caller);
+    auto callee = str.substr(first + 1, (last - first) - 1);
+    auto calleeStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(callee);
+    auto cnt = std::stoul(str.substr(last + 1));
+    (void)callProfile.emplace(std::pair<GStrIdx, GStrIdx>(callerStrIdx, calleeStrIdx), cnt);
+  }
+  LogInfo::MapleLogger() << "callsite profile total items: " << callProfile.size() << std::endl;
+}
+
+CallsiteProfileType GetCallsiteProfileType(const MIRFunction &caller, const MIRFunction &callee,
+    const CallsiteProfile &callsiteProfile) {
+  // tuning further
+  constexpr uint32 hotCallsiteCount = 2000;
+  constexpr uint32 coldCallsiteCount = 10;
+  auto callerStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(caller.GetName());
+  auto calleeStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(callee.GetName());
+  auto it = callsiteProfile.find(std::pair<GStrIdx, GStrIdx>(callerStrIdx, calleeStrIdx));
+  if (it == callsiteProfile.end()) {
+    return kCallsiteProfileNone;
+  }
+  uint32 count = it->second;
+  if (count >= hotCallsiteCount) {
+    return kCallsiteProfileHot;
+  }
+  if (count <= coldCallsiteCount) {
+    return kCallsiteProfileCold;
+  }
+  return kCallsiteProfileNormal;
+}
+
+bool InlineListInfo::IsValid() {
+  return valid;
+}
+
+void InlineListInfo::Clear() {
+  if (!IsValid()) {
+    return;
+  }
+  valid = false;
+
+  for (auto &pair : inlineList) {
+    delete pair.second;
+  }
+  inlineList.clear();
+
+  for (auto &pair : noInlineList) {
+    delete pair.second;
+  }
+  noInlineList.clear();
+
+  hardCodedCallees.clear();
+  excludedCallees.clear();
+  excludedCallers.clear();
+  rcWhiteList.clear();
+}
+
+void InlineListInfo::Prepare() {
+  if (IsValid()) {
+    return;
+  }
+
+  valid = true;
+  ApplyInlineListInfo(MeOption::inlineFuncList, inlineList);
+  ApplyInlineListInfo(Options::noInlineFuncList, noInlineList);
+  ReadCallsiteProfile(Options::callsiteProfilePath, callsiteProfile);
+  if (!inlineList.empty()) {
+    LogInfo::MapleLogger() << "inlineList size: " << inlineList.size() << std::endl;
+  }
+  if (!noInlineList.empty()) {
+    LogInfo::MapleLogger() << "noInlineList size: " << noInlineList.size() << std::endl;
+  }
+  if (!callsiteProfile.empty()) {
+    LogInfo::MapleLogger() << "callsiteProfile size: " << callsiteProfile.size() << std::endl;
+  }
+
+  std::set<std::string> specialfunc = {
+    std::string("Landroid_2Fcontent_2Fpm_2FFallbackCategoryProvider_3B_7CloadFallbacks_7C_28_29V"),
+  };
+  for (auto it = specialfunc.begin(); it != specialfunc.end(); ++it) {
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(*it);
+    (void)excludedCallers.insert(strIdx);
+  }
+
+  std::set<std::string> excludedFunc {
+#include "castcheck_whitelist.def"
+#include "array_hotfunclist.def"
+#define PROPILOAD(funcname) #funcname,
+#include "propiloadlist.def"
+#undef PROPILOAD
+#define DEF_MIR_INTRINSIC(X, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ...) NAME,
+#include "simplifyintrinsics.def"
+#undef DEF_MIR_INTRINSIC
+  };
+  for (auto it = excludedFunc.begin(); it != excludedFunc.end(); ++it) {
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(*it);
+    (void)excludedCallees.insert(strIdx);
+  }
+
+  std::set<std::string> whitelistFunc {
+#include "rcwhitelist.def"
+  };
+  for (auto it = whitelistFunc.begin(); it != whitelistFunc.end(); ++it) {
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(*it);
+    (void)rcWhiteList.insert(strIdx);
+  }
+}
+
+bool InlineAnalyzer::FuncInlinable(const MIRFunction &func) {
+  std::string name = func.GetName();
+  if (StringUtils::StartsWith(name, kReflectionClassStr) ||
+      StringUtils::StartsWith(name, kJavaLangClassesStr) ||
+      StringUtils::StartsWith(name, kJavaLangReferenceStr)) {
+    return false;
+  }
+  if (func.GetAttr(FUNCATTR_abstract) || func.GetAttr(FUNCATTR_const) || func.GetAttr(FUNCATTR_declared_synchronized) ||
+      func.GetAttr(FUNCATTR_synchronized) || func.GetAttr(FUNCATTR_weak) || func.GetAttr(FUNCATTR_varargs) ||
+      ((func.GetAttr(FUNCATTR_critical_native) || func.GetAttr(FUNCATTR_fast_native) ||
+        func.GetAttr(FUNCATTR_native)) &&
+       (func.GetBody() == nullptr || func.GetBody()->GetFirst() == nullptr))) {
+    return false;
+  }
+  if (IsFuncForbiddenToCopy(func)) {
+    return false;
+  }
+  const BlockNode *body = func.GetBody();
+  for (auto &stmt : body->GetStmtNodes()) {
+    if (stmt.GetOpCode() == OP_iassign) {
+      const IassignNode &assign = static_cast<const IassignNode&>(stmt);
+      MIRPtrType *ptrType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(assign.GetTyIdx()));
+      TyIdxFieldAttrPair fieldPair = ptrType->GetPointedTyIdxFldAttrPairWithFieldID(assign.GetFieldID());
+      if (fieldPair.second.GetAttr(FLDATTR_final)) {
+        return false;
+      }
+      if (assign.Opnd(1)->GetPrimType() == PTY_ref) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+static inline bool IsExternInlineFunc(const MIRFunction &func) {
+  return func.GetAttr(FUNCATTR_extern) && func.GetAttr(FUNCATTR_inline);
+}
+
+static bool IsFinalMethod(const MIRFunction &mirFunc) {
+  const auto *cType = static_cast<const MIRClassType*>(mirFunc.GetClassType());
+  // Return true if the method or its class is declared as final
+  return (cType != nullptr && (mirFunc.IsFinal() || cType->IsFinal()));
+}
+
+bool InlineAnalyzer::IsSafeToInline(const MIRFunction &callee, const CallNode &callStmt) {
+  Opcode op = callStmt.GetOpCode();
+  if (op == OP_callassigned || op == OP_call) {
+    return true;
+  }
+  if (IsFinalMethod(callee)) {
+    return true;
+  }
+  return false;
+}
+
+static bool WillCauseHugeFuncByInline(const MIRFunction &caller, const MIRFunction &callee) {
+  auto *callerSummary = caller.GetInlineSummary();
+  CHECK_NULL_FATAL(callerSummary);
+  auto *calleeSummary = callee.GetInlineSummary();
+  CHECK_NULL_FATAL(calleeSummary);
+  auto estimatedSize = callerSummary->GetStaticInsns() + calleeSummary->GetStaticInsns();
+  return estimatedSize > kHugeFuncNumInsns;
+}
+
+// return a pair, we should never inline the callee to all callers if pair.first is false.
+// pair.second is estimated growth if inline the callee to all callers
+std::pair<bool, int32> EstimateGrowthIfInlinedToAllCallers(const CGNode &calleeCgNode, const CallGraph &cg,
+    std::vector<CallInfo*> *callInfos) {
+  int32 growth = 0;
+  auto *callee = calleeCgNode.GetMIRFunction();
+  auto *calleeSummary = callee->GetInlineSummary();
+  if (calleeSummary == nullptr) {
+    CHECK_FATAL(callee->GetAttr(FUNCATTR_outlined), "All functions should have inline summary except outlined ones");
+    constexpr int32 bigGrowth = 10000;
+    return {false, bigGrowth};
+  }
+  auto calleeStaticSize = calleeSummary->GetStaticInsns();
+  for (auto &pair : calleeCgNode.GetCaller()) {
+    auto *caller = pair.first->GetMIRFunction();
+    // self recursive callee can not be removed
+    // avoid huge function that cause compiler build time explosion
+    if (caller == callee || caller->GetAttr(FUNCATTR_outlined) || WillCauseHugeFuncByInline(*caller, *callee)) {
+      if (callInfos != nullptr) {
+        callInfos->clear();
+      }
+      return {false, calleeStaticSize};  // we just use a positive growth
+    }
+    auto *callStmtSet = pair.second;
+    CHECK_NULL_FATAL(callStmtSet);
+    for (auto *stmt : *callStmtSet) {
+      CHECK_FATAL(kOpcodeInfo.IsCall(stmt->GetOpCode()), "icall should has been filtered out");
+      auto *callStmt = static_cast<CallNode*>(stmt);
+      auto *callInfo = pair.first->GetCallInfo(*callStmt);
+      if (!InlineAnalyzer::CanInline(*callInfo, cg, 0)) {   // depth is not important here
+        if (callInfos != nullptr) {
+          callInfos->clear();
+        }
+        return {false, calleeStaticSize};  // we just use a positive growth
+      }
+      if (callInfos != nullptr) {
+        (void)callInfos->emplace_back(callInfo);
+      }
+      InlineCost inlineCost = GetCondInlineCost(*caller, *callee, *callStmt);
+      growth += inlineCost.GetInsns();
+      auto *edgeSummary = caller->GetInlineSummary()->GetEdgeSummary(callStmt->GetStmtID());
+      // edgeSummary may be null in this case: icall (ipa collect summary) ==> call (ginline)
+      auto callInsns = edgeSummary != nullptr ? edgeSummary->callCost.GetInsns() : kNumInsnsOfCall;
+      growth -= static_cast<int32>(callInsns);
+    }
+  }
+  if (callee->IsStatic() || (callee->IsInline() && !callee->IsExtern())) {
+    growth -= calleeStaticSize;
+  }
+  return {true, growth};
+}
+
+bool CanCGNodeBeRemovedIfNoDirectCalls(const CGNode &cgNode) {
+  if (cgNode.IsAddrTaken()) {
+    return false;
+  }
+  auto *func = cgNode.GetMIRFunction();
+  return func->IsStatic() || (func->IsInline() && !func->IsExtern());
+}
+
+// If code size can be reduced after inlining `calleeCgNode` to all callers and eliminating the
+// `calleeCgNode`, the function will return true. Otherwise return false
+// `callInfos` is out parameters that will be filled with all callsite pointing to `calleeCgNode`
+bool ShouldBeInlinedToAllCallers(const CGNode &calleeCgNode, std::vector<CallInfo*> &callInfos, const CallGraph &cg) {
+  if (!calleeCgNode.HasCaller()) {
+    return false;
+  }
+  if (calleeCgNode.IsAddrTaken()) {
+    return false;
+  }
+  if (calleeCgNode.GetMIRFunction()->GetBody() == nullptr) {
+    return false;
+  }
+  auto resultPair = EstimateGrowthIfInlinedToAllCallers(calleeCgNode, cg, &callInfos);
+  bool canInline = resultPair.first;
+  if (!canInline) {
+    return false;
+  }
+  int32 growth = resultPair.second;
+  if (growth <= 0) {
+    return true;
+  }
+  // If a callee with 'static inline' attr is called twice, and growth is small enough, we still inline it to all
+  // callers. Because it brings 2 callsite inline performance benifit at the cost of only 1 callsite size increase
+  // It is more tolerant for all hot callsites.
+  if (callInfos.empty()) {
+    return false;
+  }
+  constexpr int32 growthThresh = 91;
+  constexpr size_t numCallsitesThresh = 2;
+  constexpr size_t numCallsitesHotThresh = 5;
+  bool isAllHotCallsites = true;
+  for (auto *callInfo : callInfos) {
+    auto *callerSummary = callInfo->GetCaller()->GetInlineSummary();
+    CHECK_NULL_FATAL(callerSummary);
+    auto *edgeSummary = callerSummary->GetEdgeSummary(callInfo->GetID());
+    int32 freq = kCallFreqDefault;
+    if (edgeSummary != nullptr && edgeSummary->frequency >= 0) {
+      freq = edgeSummary->frequency;
+    }
+    if (CallFreqPercent(freq) <= 1.0) {
+      isAllHotCallsites = false;
+      break;
+    }
+  }
+  size_t numCalls = callInfos.size();
+  auto *callee = callInfos[0]->GetCallee();
+  bool fewSmallCallsites = growth <= growthThresh && numCalls <= numCallsitesThresh;
+  bool fewSmallHotCallsites = (growth <= growthThresh * static_cast<int32>(numCalls)) &&
+      (isAllHotCallsites && callee->IsInline() && numCalls <= numCallsitesHotThresh);
+  if ((fewSmallCallsites || fewSmallHotCallsites) &&
+      CanCGNodeBeRemovedIfNoDirectCalls(calleeCgNode)) {
+    return true;
+  }
+  return false;
+}
+
+bool InlineAnalyzer::SizeWillGrow(const CGNode &calleeNode, const CallGraph &cg) {
+  if (!CanCGNodeBeRemovedIfNoDirectCalls(calleeNode)) {
+    return true;
+  }
+  auto numCallers = calleeNode.GetCaller().size();
+  constexpr uint32 maxNumCallersToEstimate = 6;
+  if (numCallers > maxNumCallersToEstimate) {
+    return true;
+  }
+  return EstimateGrowthIfInlinedToAllCallers(calleeNode, cg, nullptr).second > 0;
+}
+
+std::pair<bool, InlineFailedCode> InlineAnalyzer::CanInlineImpl(std::pair<const MIRFunction*, MIRFunction*> callPair,
+    const CallNode &callStmt, const CallGraph &cg, uint32 depth, bool earlyInline) {
+  const MIRFunction &caller = *callPair.first;
+  MIRFunction &callee = *callPair.second;
+  if (callee.GetBody() == nullptr) {
+    return {false, kIFC_EmptyCallee};
+  }
+  GStrIdx calleeStrIdx = callee.GetNameStrIdx();
+  GStrIdx callerStrIdx = caller.GetNameStrIdx();
+  const auto &noInlineList = InlineListInfo::GetNoInlineList();
+  if (noInlineList.find(calleeStrIdx) != noInlineList.end()) {
+    auto it = noInlineList.find(calleeStrIdx);
+    if (it == noInlineList.end()) {
+      return {false, kIFC_NoinlineList};
+    }
+    auto *callerList = it->second;
+    if (callerList->find(callerStrIdx) != callerList->end()) {
+      return {false, kIFC_NoinlineListCallsite};
+    }
+  }
+  if (callee.GetAttr(FUNCATTR_noinline)) {
+    return {false, kIFC_DeclaredNoinline};
+  }
+  if (IsExternGnuInline(callee)) {
+    if (earlyInline) {
+      return depth == 0 ? std::pair{true, kIFC_ExternGnuInlineCalleeDepth0} :
+                          std::pair{false, kIFC_ExternGnuInlineCalleeDepthN};
+    } else {
+      return std::pair{false, kIFC_OutOfGreedyInline};
+    }
+  }
+  if (callee.GetAttr(FUNCATTR_outlined) || caller.GetAttr(FUNCATTR_outlined)) {
+    return {false, kIFC_Outlined};
+  }
+  // When callee is unsafe but callStmt is in safe region
+  if (MeOption::safeRegionMode && (callStmt.IsInSafeRegion() || caller.IsSafe()) && (callee.IsUnSafe())) {
+    return {false, kIFC_UnsafeRegion};
+  }
+  // For extern inline function, we check nothing
+  if (IsExternInlineFunc(callee)) {
+    return {true, kIFC_DeclaredExternInline};
+  }
+  // For hardCoded function, we check nothing.
+  const auto &hardCodedCallee = InlineListInfo::GetHardCodedCallees();
+  if (hardCodedCallee.find(calleeStrIdx) != hardCodedCallee.end()) {
+    return {true, kIFC_HardCoded};
+  }
+  // For excluded callee function.
+  const auto &excludedCaller = InlineListInfo::GetExcludedCallers();
+  if (excludedCaller.find(callerStrIdx) != excludedCaller.end()) {
+    return {false, kIFC_ExcludedCaller};
+  }
+  const auto &excludedCallee = InlineListInfo::GetExcludedCallees();
+  if (excludedCallee.find(calleeStrIdx) != excludedCallee.end()) {
+    return {false, kIFC_ExcludedCallee};
+  }
+  if (StringUtils::StartsWith(callee.GetName(), "MCC_")) {
+    return {false, kIFC_MCCFunc};
+  }
+  // For rcWhiteList function.
+  const auto &rcWhiteList = InlineListInfo::GetRCWhiteList();
+  auto itCaller = rcWhiteList.find(callerStrIdx);
+  auto itCallee = rcWhiteList.find(calleeStrIdx);
+  if (itCaller != rcWhiteList.end() && itCallee == rcWhiteList.end()) {
+    return {false, kIFC_RCUnsafe};
+  }
+  if (!FuncInlinable(callee)) {
+    return {false, kIFC_Attr};
+  }
+  // Incompatible type conversion from arguments to formals
+  size_t realArgNum = std::min(callStmt.NumOpnds(), callee.GetFormalCount());
+  for (size_t i = 0; i < realArgNum; ++i) {
+    PrimType formalPrimType = callee.GetFormal(i)->GetType()->GetPrimType();
+    PrimType realArgPrimType = callStmt.Opnd(i)->GetPrimType();
+    bool formalIsAgg = (formalPrimType == PTY_agg);
+    bool realArgIsAgg = (realArgPrimType == PTY_agg);
+    if (formalIsAgg != realArgIsAgg) {   // xor
+      return {false, kIFC_ArgToFormalError};
+    }
+  }
+  if (!callee.GetLabelTab()->GetAddrTakenLabels().empty()) {
+    return {false, kIFC_AddrTakenLabel};
+  }
+  // For inlineList function.
+  const auto &inlineList = InlineListInfo::GetInlineList();
+  auto it = inlineList.find(calleeStrIdx);
+  if (it != inlineList.end()) {
+    auto callerList = it->second;
+    if (callerList->empty()) {
+      return {true, kIFC_InlineList};
+    }
+    if (callerList->find(callerStrIdx) != callerList->end()) {
+      return {true, kIFC_InlineListCallsite};
+    }
+  }
+  // for always_inline
+  if (Options::respectAlwaysInline && callee.GetAttr(FUNCATTR_always_inline)) {
+    return {true, kIFC_DeclaredAlwaysInline};
+  }
+  CGNode *cgNode = cg.GetCGNode(&callee);
+  if (cgNode == nullptr) {
+    return {false, kIFC_NotInCallgraph};
+  }
+  if (cgNode->IsMustNotBeInlined()) {
+    return {false, kIFC_MarkUninlinable};
+  }
+  if (!IsSafeToInline(callee, callStmt)) {
+    return {false, kIFC_Unsafe};
+  }
+  if (callee.GetInlineSummary() != nullptr) {
+    auto codeFromSummary = callee.GetInlineSummary()->GetInlineFailedCode();
+    auto codeType = GetInlineFailedType(codeFromSummary);
+    if (codeType == kIFT_FinalFail) {
+      return {false, codeFromSummary};
+    } else if (codeType == kIFT_FinalOk) {
+      return {true, codeFromSummary};
+    }
+  }
+  return {true, kIFC_NeedFurtherAnalysis};
+}
+
+// The function maybe update callInfo.inlineFailedCode
+// This function only called by ginline. einline will call CanInlineImpl directly
+bool InlineAnalyzer::CanInline(CallInfo &callInfo, const CallGraph &cg, uint32 depth) {
+  auto failedCode = callInfo.GetInlineFailedCode();
+  auto failedType = GetInlineFailedType(failedCode);
+  // If there is final cache, no need to recompute
+  if (failedType == kIFT_FinalFail) {
+    return false;
+  } else if (failedType == kIFT_FinalOk) {
+    return true;
+  }
+  if (callInfo.GetCallType() != kCallTypeCall) {
+    callInfo.SetInlineFailedCode(kIFC_IndirectCall);
+    return false;
+  }
+
+  const auto &caller = *callInfo.GetCaller();
+  auto &callee = *callInfo.GetCallee();
+  const auto &callStmt = static_cast<const CallNode&>(*callInfo.GetCallStmt());
+  auto ret = CanInlineImpl({&caller, &callee}, callStmt, cg, depth, false);  // earlyInline: false
+  auto canInline = ret.first;
+  auto failCode = ret.second;
+  callInfo.SetInlineFailedCode(failCode);
+  return canInline;
+}
+
+static bool ObviouselyNotInline(const MIRFunction &caller, const MIRFunction &callee) {
+  if (caller.IsInline() || &caller == &callee) {
+    return true;
+  }
+  constexpr int32 callerThresh = 170;
+  constexpr int32 calleeThresh = 40;
+  auto callerSize = GetFuncSize(caller);
+  auto calleeSize = GetFuncSize(callee);
+  if (!callerSize || callerSize > callerThresh) {
+    return true;
+  }
+  if (!calleeSize || calleeSize > calleeThresh) {
+    return true;
+  }
+  constexpr int32 nonStaticThresh = 10;
+  if (!callee.IsStatic() && callerSize >= nonStaticThresh) {
+    return true;
+  }
+  // callee with big switch will introduce too many control dependencies
+  if (callee.GetInlineSummary() != nullptr && callee.GetInlineSummary()->HasBigSwitch()) {
+    return true;
+  }
+  return false;
+}
+
+static int32 GetAllowedMaxScore(const BadnessInfo &badInfo) {
+  constexpr int32 tinyGrowth = 21;
+  constexpr int32 smallGrowth = 33;
+  int32 allowedMaxScore = 1;
+  // If growth is small enough, allow more violations
+  if (badInfo.growth <= tinyGrowth) {
+    constexpr int32 tinyGrowthBonus = 3;
+    allowedMaxScore += tinyGrowthBonus;
+  } else if (badInfo.growth <= smallGrowth) {
+    constexpr int32 smallGrowthBonus = 2;
+    allowedMaxScore += smallGrowthBonus;
+  }
+  return allowedMaxScore;
+}
+
+// If input badInfo is null, badInfo will be recomputed
+bool IgnoreNonDeclaredInlineSizeGrow(CallInfo &callInfo, const CallGraph &cg, const BadnessInfo *inputBadInfo) {
+  auto *caller = callInfo.GetCaller();
+  auto *callee = callInfo.GetCallee();
+  if (ObviouselyNotInline(*caller, *callee)) {
+    return false;
+  }
+
+  constexpr int32 growthLimit = 46;
+  constexpr double bigSpeedup = 0.09;
+  constexpr double maxAllowBadness = -1.0e-8;
+  constexpr double freqLimit = 0.4;
+
+  // recompute badInfo if needed
+  BadnessInfo tmpBadInfo;
+  const BadnessInfo *badInfo = inputBadInfo;
+  if (badInfo == nullptr) {
+    CalcBadnessImpl(callInfo, cg, tmpBadInfo);
+    badInfo = &tmpBadInfo;
+  }
+
+  int32 score = 0;  // the higher the score, the less inclined to inline
+  int32 allowedMaxScore = GetAllowedMaxScore(*badInfo);
+  if (GetCallFreqPercent(callInfo) < freqLimit) {
+    ++score;
+  }
+  if (badInfo->growth > growthLimit) {
+    ++score;
+  }
+  if (badInfo->badness > maxAllowBadness) {
+    ++score;
+  }
+  if (badInfo->GetSpeedup() < bigSpeedup) {
+    ++score;
+  }
+  return score <= allowedMaxScore;
+}
+
+// print all kinds of info for a specified callsite
+void DebugCallInfo(CallInfo &callInfo, const CallGraph &cg) {
+  auto *caller = callInfo.GetCaller();
+  auto *callee = callInfo.GetCallee();
+  auto *calleeNode = cg.GetCGNode(callee);
+  auto callerCnt = calleeNode->GetCaller().size();
+  BadnessInfo badInfo;
+  CalcBadnessImpl(callInfo, cg, badInfo);
+  callInfo.Dump();
+  LogInfo::MapleLogger() << ", caller cnt: " << callerCnt << std::endl;
+  LogInfo::MapleLogger() << "  ";
+  caller->Dump(true);
+  LogInfo::MapleLogger() << "  ";
+  callee->Dump(true);
+  LogInfo::MapleLogger() << "  ";
+  badInfo.Dump();
+  LogInfo::MapleLogger() << std::endl;
+}
+
+std::pair<bool, InlineFailedCode> InlineAnalyzer::WantInlineImpl(CallInfo &callInfo,
+    const CallGraph &cg, uint32 depth) {
+  auto &caller = *callInfo.GetCaller();
+  auto &callee = *callInfo.GetCallee();
+  // Avoid big callee
+  bool declaredInline = callee.GetAttr(FUNCATTR_inline);
+  auto *calleeSummary = callee.GetInlineSummary();
+  CHECK_NULL_FATAL(calleeSummary);
+  auto calleeSize = static_cast<uint32>(calleeSummary->GetStaticInsns());
+  if (!declaredInline && calleeSize >= Options::ginlineMaxNondeclaredInlineCallee) {
+    return {false, kIFC_NotDeclaredInlineTooBig};
+  }
+  auto *callerSummary = caller.GetInlineSummary();
+  if (callerSummary == nullptr) {
+    CHECK_FATAL(caller.GetAttr(FUNCATTR_outlined), "must be");
+    return {false, kIFC_Outlined};
+  }
+  auto *calleeNode = cg.GetCGNode(&callee);
+  CHECK_NULL_FATAL(calleeNode);
+  if (Options::stackProtectorStrong && !caller.GetMayWriteToAddrofStack() && callee.GetMayWriteToAddrofStack()) {
+    auto resultPair = EstimateGrowthIfInlinedToAllCallers(*calleeNode, cg, nullptr);
+    bool canInlineToAllCallers = resultPair.first;
+    auto growth = resultPair.second;
+    bool calleeWillBeRemoved = canInlineToAllCallers && growth < 0;
+    if (!calleeWillBeRemoved) {
+      return {false, kIFC_PreventedBySPS};
+    }
+  }
+  // 0 level callsite, both caller and callee are small enough
+  auto callerSize = static_cast<uint32>(callerSummary->GetStaticInsns());
+  constexpr int32 smallCaller = 9;
+  constexpr int32 smallCallee = 22;
+  bool smallCallsite = (calleeSize <= smallCallee && callerSize <= smallCaller);
+  if (depth == 0 && !declaredInline && smallCallsite) {
+    return {true, kIFC_NeedFurtherAnalysis};
+  }
+  if (!Options::ginlineAllowNondeclaredInlineSizeGrow && !declaredInline && SizeWillGrow(*calleeNode, cg)) {
+    // Give another chance
+    bool ignoreSizeGrow = IgnoreNonDeclaredInlineSizeGrow(callInfo, cg, nullptr);
+    if (!ignoreSizeGrow) {
+      return {false, kIFC_NotDeclaredInlineGrow};
+    }
+  }
+  return {true, kIFC_NeedFurtherAnalysis};
+}
+
+bool InlineAnalyzer::WantInline(CallInfo &callInfo, const CallGraph &cg, uint32 depth) {
+  auto failedCode = callInfo.GetInlineFailedCode();
+  auto failedType = GetInlineFailedType(failedCode);
+  // If there is final cache, no need to recompute
+  if (failedType == kIFT_FinalFail) {
+    return false;
+  } else if (failedType == kIFT_FinalOk) {
+    return true;  // We always repsect FinalOk, that means it can ignore size limits implmented by WantInline
+  }
+
+  // whether callsite profile is valid
+  auto *callee = callInfo.GetCallee();
+  const auto &callsiteProfile = InlineListInfo::GetCallsiteProfile();
+  if (!callsiteProfile.empty()) {
+    auto profileType = GetCallsiteProfileType(*callInfo.GetCaller(), *callee, callsiteProfile);
+    if (profileType == kCallsiteProfileHot) {
+      callInfo.SetInlineFailedCode(kIFC_ProfileHotCallsite);
+      return true;
+    } else if (profileType == kCallsiteProfileCold) {
+      callInfo.SetInlineFailedCode(kIFC_ProfileColdCallsite);
+      return false;
+    }
+  }
+
+  auto ret = WantInlineImpl(callInfo, cg, depth);
+  auto wantInline = ret.first;
+  auto failCode = ret.second;
+  callInfo.SetInlineFailedCode(failCode);
+  return wantInline;
+}
+
+double GetCallFreqPercent(const CallInfo &info) {
+  auto *callerSummary = info.GetCaller()->GetInlineSummary();
+  CHECK_NULL_FATAL(callerSummary);
+  auto *edgeSummary = callerSummary->GetEdgeSummary(info.GetID());
+  int32 freq = kCallFreqDefault;
+  if (edgeSummary != nullptr && edgeSummary->frequency >= 0) {
+    freq = edgeSummary->frequency;
+  }
+  double freqPercent = CallFreqPercent(freq);
+  return freqPercent;
+}
+
+std::optional<uint32> GetFuncSize(const MIRFunction &func) {
+  auto *inlineSummary = func.GetInlineSummary();
+  if (inlineSummary == nullptr) {
+    return {};
+  }
+  return static_cast<uint32>(inlineSummary->GetStaticInsns());
+}
+
+// called before performing inline
+bool CalleeCanBeRemovedIfInlined(const CallInfo &info, const CallGraph &cg) {
+  auto *callee = info.GetCallee();
+  auto *calleeNode = cg.GetCGNode(callee);
+  bool calledOnce = calleeNode->NumberOfUses() == 1 && calleeNode->NumReferences() == 1 && !calleeNode->IsAddrTaken();
+  if (!calledOnce) {
+    return false;
+  }
+  bool localAccess = callee->IsStatic() || (callee->IsInline() && !callee->IsExtern());
+  return localAccess;
+}
+
+double ComputeUninlinedTimeCost(const CallInfo &callInfo, double callFreqPercent) {
+  auto *callerSummary = callInfo.GetCaller()->GetInlineSummary();
+  CHECK_NULL_FATAL(callerSummary);
+  auto *calleeSummary = callInfo.GetCallee()->GetInlineSummary();
+  CHECK_NULL_FATAL(calleeSummary);
+  // `callerTime` includes time for preparing call
+  const double callerTime = callerSummary->GetStaticCycles();
+  const double calleeTime = calleeSummary->GetStaticCycles();
+  double result = callerTime + calleeTime * callFreqPercent;
+  return result;
+}
+
+double ComputeInlinedTimeCost(CallInfo &callInfo, NumCycles inlinedCalleeTime) {
+  auto *callerSummary = callInfo.GetCaller()->GetInlineSummary();
+  CHECK_NULL_FATAL(callerSummary);
+  const double callerTime = callerSummary->GetStaticCycles();
+  int32 callFreq = kCallFreqDefault;
+  NumCycles callStmtCycles = 0;
+  auto *edgeSummary = callerSummary->GetEdgeSummary(callInfo.GetID());
+  if (edgeSummary != nullptr) {
+    if (edgeSummary->frequency != -1) {
+      callFreq = edgeSummary->frequency;
+    }
+    callStmtCycles = edgeSummary->callCost.GetCycles();
+  } else {
+    auto *memPool = memPoolCtrler.NewMemPool("", true);
+    MapleAllocator alloc(memPool);
+    StmtCostAnalyzer stmtCostAnalyzer(alloc.GetMemPool(), callInfo.GetCaller());
+    callStmtCycles = stmtCostAnalyzer.EstimateNumCycles(callInfo.GetCallStmt());
+    memPoolCtrler.DeleteMemPool(memPool);
+  }
+  double result =
+      callerTime + inlinedCalleeTime * CallFreqPercent(callFreq) - callStmtCycles * CallFreqPercent(callFreq);
+  CHECK_FATAL(result >= 0, "overflow?");
+  return result;
+}
+
+// timeSaved may be over estimated, so we scale it.
+static double ScaleTimeSaved(double time) {
+  // The more trustworthy the profile is, the higher value the boundary can be set to.
+  double boundary = 1024;
+  double result = time;
+  if (result > boundary) {
+    result = std::log2(result) + boundary - std::log2(boundary);
+  }
+  return result;
+}
+
+static int32 ComputeOverallFactor(int32 overallGrowth) {
+  int32 overallFactor = 1;
+  if (overallGrowth > 0) {
+    constexpr int32 smallGrowth = 256;
+    if (overallGrowth < smallGrowth) {
+      overallFactor = overallGrowth * overallGrowth;
+    } else {
+      overallFactor = overallGrowth + smallGrowth * smallGrowth - smallGrowth;
+    }
+  }
+  return overallFactor;
+}
+
+// + callee cost; - callstmt cost.
+void CalcBadnessImpl(CallInfo &info, const CallGraph &cg, BadnessInfo &outBadInfo) {
+  BadnessInfo *badInfo = &outBadInfo;
+  const CallNode &callNode = static_cast<const CallNode&>(*info.GetCallStmt());
+  InlineCost inlineCost = GetCondInlineCost(*info.GetCaller(), *info.GetCallee(), callNode);
+  int64 sizeGrowth = static_cast<int64>(inlineCost.GetInsns());
+  auto timeGrowth = inlineCost.GetCycles();
+  badInfo->growth = inlineCost.GetInsns();
+  badInfo->time = timeGrowth;
+  if (sizeGrowth <= 0) {
+    constexpr double minBadness = -999999;
+    badInfo->origBadness = minBadness;
+    badInfo->badness = badInfo->origBadness;   // No need to adjust
+    return;
+  }
+  auto *callerSummary = info.GetCaller()->GetInlineSummary();
+  CHECK_NULL_FATAL(callerSummary);
+  int64 combinedSize = callerSummary->GetStaticInsns() + sizeGrowth;
+  badInfo->freqPercent = GetCallFreqPercent(info);
+  auto uninlinedTime = ComputeUninlinedTimeCost(info, badInfo->freqPercent);
+  auto inlinedTime = ComputeInlinedTimeCost(info, timeGrowth);
+  badInfo->uninlinedTime = uninlinedTime;
+  badInfo->inlinedTime = inlinedTime;
+  auto timeSaved = uninlinedTime - inlinedTime;
+  CHECK_FATAL(timeSaved >= 0, "should be");
+  double scaledTimeSaved = ScaleTimeSaved(timeSaved);
+
+  auto *calleeNode = cg.GetCGNode(info.GetCallee());
+  int32 overallGrowth = EstimateGrowthIfInlinedToAllCallers(*calleeNode, cg, nullptr).second;
+  int32 overallFactor = ComputeOverallFactor(overallGrowth);
+  auto badness = -scaledTimeSaved / (static_cast<double>(sizeGrowth) * combinedSize * overallFactor);
+  badInfo->origBadness = badness;
+  badInfo->overallGrowth = overallGrowth;
+  if (info.GetCallee()->GetAttr(FUNCATTR_inline)) {
+    // decrease badness for decalared_inline callee
+    constexpr int32 factor = 4;
+    if (badness > 0) {
+      badness /= factor;
+    } else {
+      badness *= factor;
+    }
+  }
+  badInfo->badness = badness;
+}
+}  // namespace maple
+
diff --git a/src/mapleall/mpl2mpl/src/inline_mplt.cpp b/src/mapleall/mpl2mpl/src/inline_mplt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8836ba7cb5868918145ce31e98c3a21b0845b133
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/inline_mplt.cpp
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "inline_mplt.h"
+#include <fstream>
+#include "stmt_cost_analyzer.h"
+
+namespace maple {
+bool InlineMplt::CollectInlineInfo(uint32 inlineSize, uint32 level) {
+  auto tempSet = mirModule.GetFunctionList();
+  if (tempSet.empty()) {
+    return false;
+  }
+  for (auto *func : tempSet) {
+    if (func == nullptr || func->GetBody() == nullptr || func->IsStatic() ||
+        func->GetAttr(FUNCATTR_noinline) || GetFunctionSize(*func) > inlineSize) {
+      continue;
+    }
+    std::vector<MIRFunction*> tmpStaticFuncs;
+    std::set<uint32_t> tmpInliningGlobals;
+    bool forbidden = Forbidden(func->GetBody(), std::make_pair(inlineSize, level), tmpStaticFuncs, tmpInliningGlobals);
+    if (forbidden) {
+      continue;
+    }
+    (void)optimizedFuncs.emplace(func);
+    optimizedFuncs.insert(tmpStaticFuncs.cbegin(), tmpStaticFuncs.cend());
+    inliningGlobals.insert(tmpInliningGlobals.cbegin(), tmpInliningGlobals.cend());
+  }
+  if (optimizedFuncs.empty()) {
+    return false;
+  }
+  CollectTypesForOptimizedFunctions();
+  CollectTypesForInliningGlobals();
+  return true;
+}
+
+bool InlineMplt::Forbidden(BaseNode *node, const std::pair<uint32, uint32> &inlineConditions,
+                           std::vector<MIRFunction*> &staticFuncs, std::set<uint32_t> &globalSymbols) {
+  if (node == nullptr) {
+    return false;
+  }
+  uint32 inlineSize = inlineConditions.first;
+  uint32 level = inlineConditions.second;
+  bool ret = false;
+  if (node->GetOpCode() == OP_block) {
+    auto *block = static_cast<BlockNode*>(node);
+    for (auto &stmt : block->GetStmtNodes()) {
+      ret |= Forbidden(&stmt, inlineConditions, staticFuncs, globalSymbols);
+    }
+  } else if (node->GetOpCode() == OP_callassigned || node->GetOpCode() == OP_call ||
+             node->GetOpCode() == OP_addroffunc) {
+    PUIdx puiIdx = (node->GetOpCode() == OP_callassigned || node->GetOpCode() == OP_call) ?
+        static_cast<CallNode*>(node)->GetPUIdx() : static_cast<AddroffuncNode*>(node)->GetPUIdx();
+    MIRFunction *newCallee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puiIdx);
+    (void)globalSymbols.insert(newCallee->GetFuncSymbol()->GetStIndex());
+    if (newCallee->IsStatic()) {
+      if (level == 0 || GetFunctionSize(*newCallee) > inlineSize || newCallee->GetAttr(FUNCATTR_noinline)) {
+        return true;
+      }
+      staticFuncs.push_back(newCallee);
+      ret |= Forbidden(newCallee->GetBody(), std::make_pair(inlineSize, level - 1), staticFuncs, globalSymbols);
+    }
+  } else if (node->GetOpCode() == OP_iread) {
+    IreadNode *opNode = static_cast<IreadNode*>(node);
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(opNode->GetTyIdx());
+    CollectStructOrUnionTypes(type);
+  } else if (node->GetOpCode() == OP_dassign || node->GetOpCode() == OP_dread || node->GetOpCode() == OP_addrof) {
+    uint32 stIdx = 0;
+    if (node->GetOpCode() == OP_dread) {
+      stIdx = static_cast<DreadNode*>(node)->GetStIdx().Idx();
+    } else if (node->GetOpCode() == OP_addrof) {
+      stIdx = static_cast<AddrofNode*>(node)->GetStIdx().Idx();
+    } else {
+      stIdx = static_cast<DassignNode*>(node)->GetStIdx().Idx();
+    }
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx, true);
+    if (symbol != nullptr && symbol->IsVar() && symbol->IsGlobal()) {
+      (void)globalSymbols.insert(stIdx);
+    }
+  }
+  for (size_t i = 0; i < node->NumOpnds(); ++i) {
+    ret |= Forbidden(node->Opnd(i), inlineConditions, staticFuncs, globalSymbols);
+  }
+  return ret;
+}
+
+// should consider nested conditions, such as struct nests struct, struct nests func pointer and the func's
+// paramters type or return type is also struct type.
+void InlineMplt::CollectStructOrUnionTypes(const MIRType *baseType) {
+  if (baseType == nullptr) {
+    return;
+  }
+  std::set<const MIRType*> tmpTypes;
+  GetElememtTypesFromDerivedType(baseType, tmpTypes);
+  for (const auto type : tmpTypes) {
+    if ((type->IsMIRStructType() || type->IsMIRUnionType()) && (optimizedFuncsType.count(type->GetTypeIndex()) == 0)) {
+      (void)optimizedFuncsType.insert(type->GetTypeIndex());
+      const MIRStructType *structType = static_cast<const MIRStructType*>(type);
+      for (size_t i = 0; i < structType->GetFieldsSize(); ++i) {
+        MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(structType->GetFieldsElemt(i).second.first);
+        CollectStructOrUnionTypes(fieldType);
+      }
+    }
+  }
+}
+
+void InlineMplt::GetElememtTypesFromDerivedType(const MIRType *baseType, std::set<const MIRType*> &elementTypes) {
+  if (baseType->GetKind() == kTypePointer) {
+    GetElememtTypesFromDerivedType(static_cast<const MIRPtrType*>(baseType)->GetPointedType(), elementTypes);
+  } else if (baseType->GetKind() == kTypeArray) {
+    GetElememtTypesFromDerivedType(static_cast<const MIRArrayType*>(baseType)->GetElemType(), elementTypes);
+  } else if (baseType->GetKind() == kTypeFunction) {
+    const MIRFuncType *funcType = static_cast<const MIRFuncType*>(baseType);
+    MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx());
+    GetElememtTypesFromDerivedType(retType, elementTypes);
+    for (auto paramTyIdx : funcType->GetParamTypeList()) {
+      MIRType *paramType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(paramTyIdx);
+      GetElememtTypesFromDerivedType(paramType, elementTypes);
+    }
+  } else if (baseType != nullptr) {
+    (void)elementTypes.insert(baseType);
+  }
+}
+
+void InlineMplt::CollectTypesForOptimizedFunctions() {
+  for (auto *func : optimizedFuncs) {
+    CollectTypesForSingleFunction(*func);
+  }
+}
+
+void InlineMplt::CollectTypesForInliningGlobals() {
+  for (auto stIdx : inliningGlobals) {
+    MIRSymbol *globalSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx);
+    if (globalSymbol->IsVar()) {
+      CollectTypesForGlobalVar(*globalSymbol);
+    } else if (globalSymbol->IsFunction()) {
+      CollectTypesForSingleFunction(*(globalSymbol->GetFunction()));
+    }
+  }
+}
+
+void InlineMplt::CollectTypesForSingleFunction(const MIRFunction &func) {
+  for (uint32 k = 1; k < func.GetSymTab()->GetSymbolTableSize(); ++k) {
+    MIRSymbol *localSymbol = func.GetSymTab()->GetSymbolFromStIdx(k);
+    MIRType *type = localSymbol->GetType();
+    CollectStructOrUnionTypes(type);
+  }
+}
+
+void InlineMplt::CollectTypesForGlobalVar(const MIRSymbol &globalSymbol) {
+  MIRType *type = globalSymbol.GetType();
+  CollectStructOrUnionTypes(type);
+}
+
+void InlineMplt::DumpInlineCandidateToFile(const std::string &fileNameStr) {
+  std::ofstream file;
+  // Change cout's buffer to file.
+  std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
+  (void)LogInfo::MapleLogger().rdbuf(file.rdbuf());
+  file.open(fileNameStr, std::ios::trunc);
+  DumpOptimizedFunctionTypes();
+  // dump global variables needed for inlining file
+  for (auto symbolIdx : inliningGlobals) {
+    MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolIdx);
+    ASSERT(s != nullptr, "null ptr check");
+    if (s->GetStorageClass() == kScFstatic) {
+      if (s->IsNeedForwDecl()) {
+        // const string, including initialization
+        s->Dump(false, 0, false);
+      }
+    }
+  }
+  for (auto symbolIdx : inliningGlobals) {
+    MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolIdx);
+    ASSERT(s != nullptr, "null ptr check");
+    MIRStorageClass sc = s->GetStorageClass();
+    if (s->GetStorageClass() == kScFstatic) {
+      if (!s->IsNeedForwDecl()) {
+        // const string, including initialization
+        s->Dump(false, 0, false);
+      }
+    } else if (s->GetSKind() == kStFunc) {
+      s->GetFunction()->Dump(true);
+    } else {
+      // static fields as extern
+      s->SetStorageClass(kScExtern);
+      s->Dump(false, 0, true);
+    }
+    s->SetStorageClass(sc);
+  }
+  for (auto *func : optimizedFuncs) {
+    func->SetWithLocInfo(false);
+    func->Dump();
+  }
+  // Restore cout's buffer.
+  (void)LogInfo::MapleLogger().rdbuf(backup);
+  file.close();
+}
+
+void InlineMplt::DumpOptimizedFunctionTypes() {
+  for (auto it = optimizedFuncsType.begin(); it != optimizedFuncsType.end(); ++it) {
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(*it);
+    std::string name = type->GetName();
+    ASSERT(type != nullptr, "type should not be nullptr here");
+    bool isStructType = type->IsStructType();
+    if (isStructType) {
+      auto *structType = static_cast<MIRStructType*>(type);
+      if (structType->IsImported()) {
+        continue;
+      }
+    }
+    LogInfo::MapleLogger() << "type $" << name << " ";
+    if (type->GetKind() == kTypeByName) {
+      LogInfo::MapleLogger() << "void";
+    } else {
+      type->Dump(1, true);
+    }
+    LogInfo::MapleLogger() << '\n';
+  }
+}
+
+uint32 InlineMplt::GetFunctionSize(MIRFunction &mirFunc) {
+  auto *tempMemPool = memPoolCtrler.NewMemPool("temp mempool", false);
+  StmtCostAnalyzer sca(tempMemPool, &mirFunc);
+  uint32 funcSize = static_cast<uint32>(sca.GetStmtsCost(mirFunc.GetBody())) / static_cast<uint32>(kSizeScale);
+  delete tempMemPool;
+  tempMemPool = nullptr;
+  return funcSize;
+}
+} // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/inline_summary.cpp b/src/mapleall/mpl2mpl/src/inline_summary.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..82ec55895c137c17163ac8d18eef8f428eaddf34
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/inline_summary.cpp
@@ -0,0 +1,1104 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "inline_summary.h"
+#include "constantfold.h"
+#include "dominance.h"
+
+namespace {
+using maple::int32;
+constexpr int32 kRemoveStmtNone = 0;
+constexpr int32 kRemoveStmtHalf = 1;
+constexpr int32 kRemoveStmtAll = 2;
+}
+
+namespace maple {
+// This is a convenient function for debugging
+InlineSummary *GetSummaryByPuIdx(uint32 puIdx) {
+  auto *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  return func->GetInlineSummary();
+}
+
+int32 CostSize2NumInsn(int32 costSize) {
+  return costSize * static_cast<int32>(kInsn2Threshold) / static_cast<int32>(kSizeScale);
+}
+
+ExprBoolResult GetReverseExprBoolResult(ExprBoolResult res) {
+  if (res == kExprResTrue) {
+    return kExprResFalse;
+  }
+  if (res == kExprResFalse) {
+    return kExprResTrue;
+  }
+  return res;
+}
+
+void DumpStmtSafe(const StmtNode &stmtNode, MIRFunction &func) {
+  auto *oldFunc = theMIRModule->CurFunction();
+  theMIRModule->SetCurFunction(&func);
+  stmtNode.Dump();
+  theMIRModule->SetCurFunction(oldFunc);
+}
+
+// return <type, constVal> pair if `expr` can be folded into a constantant.
+// return { PTY_unknown, 0 } otherwise.
+std::pair<PrimType, int64> TryFoldConst(BaseNode &expr) {
+  MIRConst *resConst = nullptr;
+  if (expr.GetOpCode() == OP_constval) {
+    resConst = static_cast<ConstvalNode&>(expr).GetConstVal();
+  } else {
+    static ConstantFold cf(*theMIRModule);
+    auto *foldExpr = cf.Fold(&expr);
+    if (foldExpr != nullptr && foldExpr->GetOpCode() == OP_constval) {
+      resConst = static_cast<ConstvalNode*>(foldExpr)->GetConstVal();
+    }
+  }
+  if (resConst == nullptr) {
+    return { PTY_unknown, 0 };
+  }
+  int64 val = 0;
+  auto type = resConst->GetType().GetPrimType();
+  if (IsPrimitiveInteger(type)) {
+    val = static_cast<MIRIntConst*>(resConst)->GetExtValue();
+  } else if (type == PTY_f32) {
+    val = static_cast<MIRFloatConst*>(resConst)->GetIntValue();
+  } else if (type == PTY_f64) {
+    val = static_cast<MIRDoubleConst*>(resConst)->GetIntValue();
+  } else {
+    return { PTY_unknown, 0 };
+  }
+  return { type, val };
+}
+
+// If `expr` is an unmodified formal parameter (zero version), return formal index, otherwise return none.
+std::optional<uint32> GetZeroVersionParamIndex(const MeExpr &expr, MeFunction &func) {
+  if (expr.GetMeOp() != kMeOpVar) {
+    return {};
+  }
+  auto &varExpr = static_cast<const VarMeExpr&>(expr);
+  if (varExpr.IsVolatile() || !varExpr.IsZeroVersion()) {
+    return {};
+  }
+  auto *ost = varExpr.GetOst();
+  if (ost->GetFieldID() != 0 || !ost->IsFormal() || ost->GetIndirectLev() != 0) {
+    return {};
+  }
+  auto *symbol = ost->GetMIRSymbol();
+  for (uint32 i = 0; i < func.GetMirFunc()->GetFormalCount(); ++i) {
+    auto *formalSt = func.GetMirFunc()->GetFormal(i);
+    if (formalSt != nullptr && symbol->GetNameStrIdx() == formalSt->GetNameStrIdx()) {
+      return i;
+    }
+  }
+  return {};
+}
+
+// Return true if the `expr` is the leaf expr with one of the specified `kinds`
+bool IsExprSpecifiedKinds(const MeExpr &expr, uint32 kinds, MeFunction &func) {
+  if ((kinds & kExprKindConstNumber) && expr.GetOp() == OP_constval) {
+    auto constKind = static_cast<const ConstMeExpr&>(expr).GetConstVal()->GetKind();
+    if (constKind == kConstInt || constKind == kConstFloatConst || constKind == kConstDoubleConst) {
+      return true;
+    }
+  }
+  if ((kinds & kExprKindConst) && expr.GetOp() == OP_constval) {
+    return true;
+  }
+  if ((kinds & kExprKindParam) && GetZeroVersionParamIndex(expr, func).has_value()) {
+    return true;
+  }
+  return false;
+}
+
+// Return true if the `expr` is only composed of specified `kinds`
+bool IsExprOnlyComposedOf(const MeExpr &expr, uint32 kinds, MeFunction &func) {
+  if (expr.IsLeaf()) {
+    return IsExprSpecifiedKinds(expr, kinds, func);
+  }
+  static const std::vector<Opcode> unsupportedOps = { OP_iread, OP_ireadoff, OP_array };
+  if (std::find(unsupportedOps.begin(), unsupportedOps.end(), expr.GetOp()) != unsupportedOps.end()) {
+    return false;
+  }
+  for (uint32 i = 0; i < expr.GetNumOpnds(); ++i) {
+    if (!IsExprOnlyComposedOf(*expr.GetOpnd(i), kinds, func)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Return a new generated liteExpr allocated in `alloc` for `expr` if `expr` is only composed of
+// specified `kinds` (see enum ExprKind). Return nullptr otherwise.
+// `paramsUsed` is an out parameter that is a param index bitMap indicating which parameters are used by `expr`
+LiteExpr *LiteExpr::TryBuildLiteExpr(MeExpr &expr, uint32 kinds, MeFunction &func, MapleAllocator &alloc,
+    uint32 *paramsUsed) {
+  if (!IsExprOnlyComposedOf(expr, kinds, func)) {
+    return nullptr;
+  }
+  return &DoBuildLiteExpr(expr, func, alloc, paramsUsed);
+}
+
+LiteExpr &LiteExpr::DoBuildLiteExpr(MeExpr &expr, MeFunction &func, MapleAllocator &alloc, uint32 *paramsUsed) {
+  auto opcode = expr.GetOp();
+  // Build liteExpr for constant number
+  if (opcode == OP_constval) {
+    auto *mirConst = static_cast<ConstMeExpr&>(expr).GetConstVal();
+    auto kind = mirConst->GetKind();
+    CHECK_FATAL(kind == kConstInt || kind == kConstFloatConst || kind == kConstDoubleConst, "must be const number");
+    auto *liteExpr = alloc.New<LiteExpr>(alloc, mirConst->GetType().GetPrimType(), mirConst);
+    return *liteExpr;
+  }
+  // Build liteExpr for parameter
+  if (auto ret = GetZeroVersionParamIndex(expr, func)) {
+    auto paramIndex = ret.value();
+    if (paramsUsed != nullptr) {
+      (*paramsUsed) |= (1u << paramIndex);  // record parameters used by current expr
+    }
+    auto *liteExpr = alloc.New<LiteExpr>(alloc, expr.GetPrimType(), paramIndex);
+    return *liteExpr;
+  }
+  auto *resultExpr = alloc.New<LiteExpr>(alloc, opcode, expr.GetPrimType());
+  // Append extra info for special opcodes
+  if (resultExpr->IsCvt() || resultExpr->IsCmp()) {
+    resultExpr->SetOpndType(static_cast<OpMeExpr&>(expr).GetOpndType());
+  } else if (resultExpr->IsExtractbits()) {
+    auto &opMeExpr = static_cast<OpMeExpr&>(expr);
+    resultExpr->SetBitsSize(opMeExpr.GetBitsSize());
+    resultExpr->SetBitsOffset(opMeExpr.GetBitsOffSet());
+  }
+  // Build liteExpr for opnds recursively
+  auto numOpnds = expr.GetNumOpnds();
+  resultExpr->GetOpnds().resize(numOpnds, nullptr);
+  for (uint32 i = 0; i < numOpnds; ++i) {
+    auto &liteExpr = DoBuildLiteExpr(*expr.GetOpnd(i), func, alloc, paramsUsed);
+    resultExpr->GetOpnds()[i] = &liteExpr;
+  }
+  return *resultExpr;
+}
+
+// Clone liteExpr deeply into `newAlloc`
+LiteExpr *LiteExpr::Clone(MapleAllocator &newAlloc) const {
+  auto *copy = newAlloc.New<LiteExpr>(newAlloc, *this);
+  for (uint32 i = 0; i < opnds.size(); ++i) {
+    auto *opndCopy = opnds[i]->Clone(newAlloc);
+    copy->opnds[i] = opndCopy;
+  }
+  return copy;
+}
+
+void LiteExpr::DumpWithoutEndl(uint32 indent) const {
+  auto &os = LogInfo::MapleLogger();
+  os << kOpcodeInfo.GetTableItemAt(op).name << " " << GetPrimTypeName(type) << " ";
+  if (IsCvt() || IsCmp()) {
+    os << GetPrimTypeName(GetOpndType()) << " ";
+  } else if (IsExtractbits()) {
+    os << static_cast<uint32>(GetBitsSize()) << "[offset:" <<
+        static_cast<uint32>(GetBitsOffset()) << "] ";
+  } else if (IsConst()) {
+    if (IsPrimitiveInteger(type)) {
+      os << GetInt();
+    } else if (type == PTY_f32) {
+      os << GetFloat();
+    } else if (type == PTY_f64) {
+      os << GetDouble();
+    } else {
+      CHECK_FATAL(false, "should not be here");
+    }
+  } else if (IsParam()) {
+    os << "param" << GetParamIndex();
+  }
+
+  if (opnds.empty()) {
+    return;
+  }
+  constexpr uint32 indentStep = 2;
+  for (uint32 i = 0; i < opnds.size(); ++i) {
+    os << std::endl;
+    os << std::string(indent + indentStep, ' ') << "opnd[" << i << "] = ";
+    opnds[i]->DumpWithoutEndl(indent + indentStep);
+  }
+}
+
+void LiteExpr::Dump(uint32 indent) const {
+  DumpWithoutEndl(indent);
+  LogInfo::MapleLogger() << std::endl;
+}
+
+// If any param can not be evaluated, return nullptr
+BaseNode *LiteExpr::ConvertToMapleIR(MapleAllocator &alloc, const ArgInfoVec *argInfoVec) const {
+  if (IsConst()) {
+    return alloc.New<ConstvalNode>(type, data.cst);
+  }
+  // Substitute constant real arguments into parameter expressions
+  if (IsParam()) {
+    uint32 paramIndex = GetParamIndex();
+    if (argInfoVec == nullptr || paramIndex >= argInfoVec->size() || (*argInfoVec)[paramIndex] == nullptr) {
+      // no valid real arg value
+      return nullptr;
+    }
+    auto *argInfo = (*argInfoVec)[paramIndex];
+    if (!argInfo->IsSingleValue()) {
+      // value range has not been supported for now
+      return nullptr;
+    }
+    MIRConst *mirConst = argInfo->GetLower();
+    return alloc.New<ConstvalNode>(mirConst->GetType().GetPrimType(), mirConst);
+  }
+  CHECK_FATAL(!opnds.empty(), "there is other leaf node other than const and param?");
+  std::vector<BaseNode*> opndNodes(opnds.size(), nullptr);
+  BaseNode *node0 = opnds[0]->ConvertToMapleIR(alloc, argInfoVec);
+  if (node0 == nullptr) {
+    return nullptr;
+  }
+  if (opndNodes.size() == kOperandNumUnary) {
+    if (IsCvt()) {
+      return alloc.New<TypeCvtNode>(op, type, GetOpndType(), node0);
+    }
+    if (IsExtractbits()) {
+      return alloc.New<ExtractbitsNode>(op, type, GetBitsOffset(), GetBitsSize(), node0);
+    }
+  } else if (opndNodes.size() == kOperandNumBinary) {
+    auto *node1 = opnds[1]->ConvertToMapleIR(alloc, argInfoVec);
+    if (node1 == nullptr) {
+      return nullptr;
+    }
+    if (IsCmp()) {
+      return alloc.New<CompareNode>(op, type, GetOpndType(), node0, node1);
+    }
+    return alloc.New<BinaryNode>(op, type, node0, node1);
+  } else {
+    CHECK_FATAL(false, "NYI");
+  }
+  return nullptr;
+}
+
+// Evaluate `liteExpr` if possible.
+// `liteExpr` should not be changed because it is shared by all callsites.
+// Implementation: liteExpr is converted to maple IR first (so we need specify an allocator),
+// then maple IR is folded into const if possible
+MIRConst *LiteExpr::Evaluate(MapleAllocator &alloc, const ArgInfoVec *argInfoVec) const {
+  auto *baseNode = ConvertToMapleIR(alloc, argInfoVec);
+  if (baseNode == nullptr) {
+    return nullptr;
+  }
+  MIRConst *resConst = nullptr;
+  if (baseNode->GetOpCode() == OP_constval) {
+    resConst = static_cast<ConstvalNode&>(*baseNode).GetConstVal();
+  } else {
+    static ConstantFold cf(*theMIRModule);
+    auto *foldExpr = cf.Fold(baseNode);
+    if (foldExpr != nullptr && foldExpr->GetOpCode() == OP_constval) {
+      resConst = static_cast<ConstvalNode*>(foldExpr)->GetConstVal();
+    }
+  }
+  return resConst;
+}
+
+ExprBoolResult LiteExpr::EvaluateToBool(MapleAllocator &alloc, const ArgInfoVec *argInfoVec) const {
+  auto *mirConst = Evaluate(alloc, argInfoVec);
+  if (mirConst == nullptr) {
+    return kExprResUnknown;
+  }
+  CHECK_FATAL(mirConst->GetKind() == kConstInt, "condition type is not integer?");
+  return mirConst->IsZero() ? kExprResFalse : kExprResTrue;
+}
+
+// convert meExpr to liteExpr, then evaluate liteExpr
+MIRConst *EvaluateMeExpr(MeExpr &meExpr, MeFunction &func, MapleAllocator &alloc) {
+  // Only care meExpr that is composed of const expr
+  auto *liteExpr = LiteExpr::TryBuildLiteExpr(meExpr, kExprKindConstNumber, func, alloc);
+  if (liteExpr != nullptr) {
+    return liteExpr->Evaluate(alloc, nullptr);
+  }
+  return nullptr;
+}
+
+void Condition::Dump() const {
+  if (reverse) {
+    LogInfo::MapleLogger() << "!";
+  }
+  expr->Dump();
+}
+
+void Predicate::AddAssert(Assert newAssert, const MapleVector<Condition*> &conditions) {
+  if (newAssert == 0) {  // (true)
+    return;
+  }
+  if (newAssert == 1) {  // (false)
+    // False assert makes the whole predicate false.
+    asserts = { 1 };
+    return;
+  }
+  if (IsFalsePredicate()) {
+    return;
+  }
+
+  // Try to insert newAssert
+  std::vector<std::pair<Assert, Assert>> replaceList;
+  for (auto assert : asserts) {
+    // `assert` implies `newAssert`, add nothing
+    // For example:
+    //   `assert`    : (cond1 || cond2)
+    //   `newAssert` : (cond1 || cond2 || cond3)
+    if ((assert & newAssert) == assert) {
+      return;
+    }
+    // `newAssert` implies `assert`, replace `assert` with `newAssert`
+    if ((assert & newAssert) == newAssert) {
+      (void)replaceList.emplace_back(assert, newAssert);
+    }
+  }
+
+  // Try to find out asserts that are obviously true such ass (x == 42 || x != 42)
+  for (uint32 i = 0; i < kMaxNumCondition; ++i) {
+    if (!(newAssert & (kAssertOne << i))) {
+      continue;
+    }
+    auto *cond1 = conditions[i];
+    for (uint32 j = i + 1; j < kMaxNumCondition; ++j) {
+      if (!(newAssert & (kAssertOne << j))) {
+        continue;
+      }
+      auto *cond2 = conditions[j];
+      if (cond1->IsReverseWithCondition(*cond2)) {
+        return;
+      }
+    }
+  }
+
+  if (!replaceList.empty()) {
+    for (const auto &r : replaceList) {
+      (void)asserts.erase(r.first);
+      (void)asserts.insert(r.second);
+    }
+  } else {
+    (void)asserts.insert(newAssert);
+  }
+}
+
+const Predicate *Predicate::And(const Predicate &a, const Predicate &b, MapleAllocator &alloc) {
+  if (b.IsFalsePredicate() || a.IsTruePredicate()) {
+    return &b;
+  }
+  if (a.IsFalsePredicate() || b.IsTruePredicate()) {
+    return &a;
+  }
+  std::vector<Assert> mergedAsserts;
+  mergedAsserts.reserve(a.asserts.size() + b.asserts.size());
+  for (auto assert : a.asserts) {
+    mergedAsserts.push_back(assert);
+  }
+  for (auto assert : b.asserts) {
+    mergedAsserts.push_back(assert);
+  }
+  return alloc.New<Predicate>(mergedAsserts, alloc);
+}
+
+const Predicate *Predicate::Or(const Predicate &a, const Predicate &b, const MapleVector<Condition*> &conditions,
+    MapleAllocator &alloc) {
+  if (b.IsFalsePredicate() || a.IsTruePredicate()) {
+    return &a;
+  }
+  if (a.IsFalsePredicate() || b.IsTruePredicate()) {
+    return &b;
+  }
+  if (a == b) {
+    return &a;
+  }
+
+  auto *result = alloc.New<Predicate>(alloc);
+  for (auto it = a.asserts.begin(); it != a.asserts.end(); ++it) {
+    for (auto jt = b.asserts.begin(); jt != b.asserts.end(); ++jt) {
+      auto newAssert = *it | *jt;
+      result->AddAssert(newAssert, conditions);
+    }
+  }
+  if (result->asserts.empty()) {
+    return TruePredicate();  // There is no any assert, return true predicate
+  }
+  return result;
+}
+
+const Predicate *Predicate::Clone(MapleAllocator &newAlloc) const {
+  // truePredicate and falsePredicate are globally unique, no need to clone
+  if (IsTruePredicate()) {
+    return Predicate::TruePredicate();
+  }
+  if (IsFalsePredicate()) {
+    return Predicate::FalsePredicate();
+  }
+  if (IsNotInlinePredicate()) {
+    return Predicate::NotInlinePredicate();
+  }
+  auto *copy = newAlloc.New<Predicate>(asserts, newAlloc);
+  return copy;
+}
+
+void Predicate::Dump(const MapleVector<Condition*> &conditions) const {
+  auto &os(LogInfo::MapleLogger());
+  if (IsTruePredicate()) {
+    os << "(true)\n";
+    return;
+  }
+  if (IsFalsePredicate()) {
+    os << "(false)\n";
+    return;
+  }
+  uint32 idx = 0;
+  for (auto assert : asserts) {
+    bool firstItem = true;
+    if (idx != 0) {
+      os << " && ";
+    }
+    os << "(";
+    for (uint32 i = 0; i < kMaxNumCondition; ++i) {
+      if (assert & (kAssertOne << i)) {
+        if (!firstItem) {
+          os << " || ";
+        }
+        if (i == kCondIdxNotInline) {
+          os << "not inline";
+          continue;
+        }
+        firstItem = false;
+        conditions[i]->Dump();
+      }
+    }
+    os << ")";
+    ++idx;
+  }
+  LogInfo::MapleLogger() << std::endl;
+}
+
+// Return true if all parameters used by current predicate are in `paramMapping`
+bool Predicate::AreAllUsedParamsInParamMapping(const std::vector<int32> &paramMapping,
+    const MapleVector<Condition*> &conditions) const {
+  if (paramMapping.empty()) {
+    return false;
+  }
+  uint32 paramsUsed = GetParamsUsed(conditions);
+  if (paramsUsed == 0) {
+    return false;
+  }
+  bool allMapping = true;
+  uint32 paramsNum = std::min(sizeof(paramsUsed) * kNumBitsPerByte, paramMapping.size());
+  for (uint32 i = 0; i < paramsNum; ++i) {
+    if ((paramsUsed & (1u << i)) && paramMapping[i] == -1) {
+      allMapping = false;  // found parameter that has no mapping item
+      break;
+    }
+  }
+  return allMapping;
+}
+
+void MergeInlineSummary(MIRFunction &caller, MIRFunction &callee, const StmtNode &callStmt,
+    const std::map<uint32, uint32> &callMeStmtIdMap) {
+  // Merge inline summary
+  auto *callerSummary = caller.GetInlineSummary();
+  CHECK_NULL_FATAL(callerSummary);
+  auto *calleeSummary = callee.GetInlineSummary();
+  CHECK_NULL_FATAL(calleeSummary);
+  auto callStmtId = callStmt.GetStmtID();
+  auto &argInfosMap = callerSummary->GetArgInfosMap();
+  ArgInfoVec *argInfoVec = nullptr;
+  auto it = argInfosMap.find(callStmtId);
+  if (it != argInfosMap.end()) {
+    argInfoVec = it->second;
+  }
+  std::vector<ExprBoolResult> condResultVec;
+  // argInfoVec may be nullptr
+  auto tmpMp = std::make_unique<MemPool>(memPoolCtrler, "");
+  MapleAllocator tmpAlloc(tmpMp.get());
+  calleeSummary->EvaluateConditions(tmpAlloc, argInfoVec, condResultVec, true);
+  callerSummary->MergeSummary(*calleeSummary, callStmt.GetStmtID(), tmpAlloc, condResultVec, callMeStmtIdMap);
+}
+
+void InlineSummary::MergeSummary(const InlineSummary &fromSummary, uint32 callStmtId, MapleAllocator &tmpAlloc,
+    const std::vector<ExprBoolResult> &condResultVec, const std::map<uint32, uint32> &callMeStmtIdMap) {
+  if (func == fromSummary.func) {
+    // recursive inlining MergeSummary is not supported for now, we mark inline summary untrustworthy
+    trustworthy = false;
+    return;
+  }
+  // (1) find paramMapping for current callsite
+  std::vector<int32> paramMapping;
+  GetParamMappingForCallsite(callStmtId, paramMapping);
+
+  InlineEdgeSummary *callEdgeSummary = nullptr;
+  int32 callFrequency = -1;
+  auto *callBBPredicate = Predicate::TruePredicate();
+  auto eit = edgeSummaryMap.find(callStmtId);
+  if (eit != edgeSummaryMap.end()) {
+    callEdgeSummary = eit->second;
+    callFrequency = callEdgeSummary->frequency;
+    callBBPredicate = callEdgeSummary->predicate;
+  }
+
+  // (2) specialization for costTable in the fromSummary
+  InlineCost unnecessaryCost{0, 0};
+  std::vector<std::pair<const Predicate*, InlineCost>> spCostTable;  // specialized costTable
+  auto condsNeedCopy
+      = fromSummary.SpecializeCostTable(condResultVec, paramMapping, callFrequency, spCostTable, unnecessaryCost);
+  // update static cost
+  auto sizeGrowth = fromSummary.GetStaticInsns() - unnecessaryCost.GetInsns();
+  AddStaticInsns(sizeGrowth);
+  auto timeGrowth = fromSummary.GetStaticCycles() - unnecessaryCost.GetCycles();
+  if (callFrequency > 0) {
+    timeGrowth *= CallFreqPercent(callFrequency);
+  }
+  AddStaticCycles(timeGrowth);
+
+  // (3) merge conditions, remap condition index, replace param index
+  std::array<int8, kMaxNumCondition> oldCondIdx2New;
+  MergeAndRemapConditions(fromSummary, condsNeedCopy, paramMapping, oldCondIdx2New);
+
+  // Remap condition index
+  for (uint32 i = 1; i < spCostTable.size(); ++i) {  // Skip the first truePredicate
+    const Predicate *pred = spCostTable[i].first;
+    const Predicate *newPred = nullptr;
+    if (callBBPredicate->IsTruePredicate()) {
+      newPred = pred->RemapCondIdx(oldCondIdx2New, summaryAlloc);
+    } else {
+      newPred = pred->RemapCondIdx(oldCondIdx2New, tmpAlloc);  // avoid meory leak
+      newPred = Predicate::And(*newPred, *callBBPredicate, summaryAlloc);
+    }
+    spCostTable[i].first = newPred;
+  }
+
+  // Merge spCostTable into toSummary costTable
+  costTable[0].second.Add(spCostTable[0].second);
+  for (uint32 i = 1; i < spCostTable.size(); ++i) {
+    costTable.push_back(spCostTable[i]);
+  }
+  MergeEdgeSummary(fromSummary, { callStmtId, callEdgeSummary }, tmpAlloc, oldCondIdx2New, callMeStmtIdMap);
+  MergeArgInfosMap(fromSummary, callStmtId, callMeStmtIdMap);
+}
+
+// Return condIdx bitMap that need be copied to toSummary
+Assert InlineSummary::SpecializeCostTable(const std::vector<ExprBoolResult> &condResultVec,
+    const std::vector<int32> &paramMapping, int32 callFrequency,
+    std::vector<std::pair<const Predicate*, InlineCost>> &spCostTable,
+    InlineCost &unnecessaryCost) const {
+  // The first costTable item is always truePredicate
+  (void)spCostTable.emplace_back(Predicate::TruePredicate(), InlineCost{0, 0});
+  Assert condsNeedCopy = 0;
+  for (const auto &costPair : costTable) {
+    auto *predicate = costPair.first;
+    const auto &cost = costPair.second;
+    auto res = predicate->Evaluate(condResultVec);
+    if (res == kExprResFalse) {
+      unnecessaryCost.Add(cost);  // unnecessaryCost will be scaled outside the function
+      continue;  // There is no need to consider cost if predicate evaluates to false
+    }
+    if (res == kExprResTrue) {
+      spCostTable[0].second.Add(cost, callFrequency);  // Accumulate cost for predicate with true result
+      continue;
+    }
+    // Now we need handle predicates with "unknown" value
+    if (!predicate->AreAllUsedParamsInParamMapping(paramMapping, conditions)) {
+      // These predicates are "really unknown". To be conservative, we treat them as true predicates
+      spCostTable[0].second.Add(cost, callFrequency);
+      continue;
+    }
+    // These predicates are "maybe known", we will replace param index of these predicates later
+    (void)spCostTable.emplace_back(predicate, cost.Scale(callFrequency));
+    condsNeedCopy |= predicate->GetCondsUsed();
+  }
+  return condsNeedCopy;
+}
+
+void InlineSummary::MergeAndRemapConditions(const InlineSummary &fromSummary, Assert condsNeedCopy,
+    const std::vector<int32> &paramMapping, std::array<int8, kMaxNumCondition> &oldCondIdx2New) {
+  const auto newCondBeginIdx = conditions.size();
+  auto currCondIdx = newCondBeginIdx;
+  // Map old conditon index (in the fromSummary) to new condition index (in the toSummary)
+  oldCondIdx2New.fill(-1);  // Init all elements with invalid value
+  for (uint32 i = kCondIdxRealBegin; i < kMaxNumCondition; ++i) {
+    if (!(condsNeedCopy & (kAssertOne << i))) {
+      continue;
+    }
+    if (currCondIdx >= kMaxNumCondition) {
+      oldCondIdx2New[i] = kCondIdxOverflow;
+      break;
+    }
+    oldCondIdx2New[i] = static_cast<int8>(currCondIdx);
+    ++currCondIdx;
+    Condition *fromCond = fromSummary.conditions[i];
+    if (fromCond->GetParamsUsed() != 0) {
+      // Clone a new cond and replace param index for new cond
+      fromCond = fromCond->Clone(summaryAlloc);
+      fromCond->GetExpr()->RemapParamIdx(paramMapping);
+    }
+    conditions.push_back(fromCond);
+  }
+}
+
+void InlineSummary::MergeEdgeSummary(const InlineSummary &fromSummary,
+    std::pair<uint32, InlineEdgeSummary*> callEdgeSummaryPair,
+    MapleAllocator &tmpAlloc, const std::array<int8, kMaxNumCondition> &oldCondIdx2New,
+    const std::map<uint32, uint32> &callMeStmtIdMap) {
+  // Merge callStmtPredicates
+  uint32 callStmtId = callEdgeSummaryPair.first;
+  InlineEdgeSummary *callEdgeSummary = callEdgeSummaryPair.second;
+  auto *callBBPredicate = callEdgeSummary ? callEdgeSummary->predicate : Predicate::TruePredicate();
+  int64 callBBFreq = callEdgeSummary ? callEdgeSummary->frequency : -1;
+  for (auto &pair : fromSummary.edgeSummaryMap) {
+    auto fromCallId = pair.first;
+    auto jt = callMeStmtIdMap.find(fromCallId);
+    if (jt == callMeStmtIdMap.end()) {
+      // callStmt with fromCallId may be removed from callee by other phases (such as outline)
+      continue;
+    }
+    fromCallId = jt->second;
+    InlineEdgeSummary *newEdgeSummary = pair.second;
+    CHECK_NULL_FATAL(newEdgeSummary);
+    auto *newPred = newEdgeSummary->predicate;
+    if (callBBPredicate->IsTruePredicate()) {
+      newPred = newPred->RemapCondIdx(oldCondIdx2New, summaryAlloc);
+    } else {
+      newPred = newPred->RemapCondIdx(oldCondIdx2New, tmpAlloc);
+      newPred = Predicate::And(*newPred, *callBBPredicate, summaryAlloc);
+    }
+    int32 newFrequency = newEdgeSummary->frequency;
+    if (newFrequency == -1 || callBBFreq == -1) {
+      newFrequency = -1;
+    } else {
+      newFrequency = static_cast<int32>(callBBFreq * newFrequency / static_cast<int64>(kFreqBase));
+      if (newFrequency > kCallFreqMax) {
+        newFrequency = kCallFreqMax;
+      }
+    }
+    AddEdgeSummary(fromCallId, newPred, newFrequency, newEdgeSummary->callCost.GetInsns(),
+        static_cast<int32>(newEdgeSummary->callCost.GetCycles()));
+  }
+  RemoveEdgeSummary(callStmtId);
+}
+
+void InlineSummary::MergeArgInfosMap(const InlineSummary &fromSummary, uint32 callStmtId,
+    const std::map<uint32, uint32> &callMeStmtIdMap) {
+  auto it = argInfosMap.find(callStmtId);
+  if (it == argInfosMap.end()) {
+    // The callsite has no real arguments, no need to remap param index.
+    // Just simplely merge arg info and return
+    for (const auto &pair : fromSummary.argInfosMap) {
+      auto fromCallId = pair.first;
+      auto jt = callMeStmtIdMap.find(fromCallId);
+      if (jt != callMeStmtIdMap.end()) {
+        fromCallId = jt->second;
+      }
+      (void)argInfosMap.emplace(fromCallId, pair.second);
+    }
+    return;
+  }
+  ArgInfoVec &currArgInfos = *it->second;
+  for (const auto &pair : fromSummary.argInfosMap) {
+    auto fromCallId = pair.first;
+    auto cit = callMeStmtIdMap.find(fromCallId);
+    if (cit == callMeStmtIdMap.end()) {
+      // callStmt with fromCallId may be removed from callee by other phases (such as outline)
+      continue;
+    }
+    fromCallId = cit->second;
+    auto *argInfoVec = pair.second;
+    CHECK_FATAL(argInfoVec != nullptr, "there should not be null argInfos");
+    // key: callsite arg index, value: caller formal index
+    auto *newArgInfoVec = summaryAlloc.New<ArgInfoVec>(summaryAlloc.Adapter());
+    for (uint32 innerIdx = 0; innerIdx < argInfoVec->size(); ++innerIdx) {
+      auto *argInfo = (*argInfoVec)[innerIdx];
+      if (argInfo == nullptr) {
+        newArgInfoVec->push_back(nullptr);
+        continue;
+      }
+      if (!argInfo->IsParamPassThrough()) {
+        newArgInfoVec->push_back(argInfo);  // keep argInfo with known value range
+        continue;
+      }
+      // Param index remap example:
+      // foo(int x, int y) {                   ... outerIdx = 1
+      //   bar(41, 42, y); }                   ... midIdx   = 2
+      // bar(int a, int b, int c) { hi(c); }   ... innerIdx = 0
+      // when bar is inlined into foo, the formalIdx of hi(c) should be change from innerIdx to outerIdx.
+      // If outerIdx is -1, this means hi(c) has no matters with new caller's formals, its argInfo has no use now.
+      auto midIdx = static_cast<size_t>(static_cast<uint32>(argInfo->GetCallerFormalIdx()));
+      if (midIdx >= currArgInfos.size() || currArgInfos[midIdx] == nullptr) {
+        newArgInfoVec->push_back(nullptr);
+        continue;
+      }
+      int32 outerIdx = currArgInfos[midIdx]->GetCallerFormalIdx();
+      if (outerIdx == -1) {
+        newArgInfoVec->push_back(nullptr);
+        continue;
+      }
+      newArgInfoVec->push_back(summaryAlloc.New<ArgInfo>(outerIdx));
+    }
+    CHECK_FATAL(newArgInfoVec->size() == argInfoVec->size(), "must be");
+    auto result = argInfosMap.emplace(fromCallId, newArgInfoVec);
+    // Inline a same func twice
+    CHECK_FATAL(result.second, "callStmtId conflicts");
+  }
+  (void)argInfosMap.erase(callStmtId);
+}
+
+void InlineSummary::DumpConditions() const {
+  LogInfo::MapleLogger() << "===== DumpConditions =====\n";
+  for (auto *cond : conditions) {
+    if (cond == nullptr) {
+      continue;
+    }
+    cond->Dump();
+    LogInfo::MapleLogger() << "expr address: " << cond->GetExpr() << std::endl;
+    LogInfo::MapleLogger() << std::endl;
+  }
+}
+
+void InlineSummary::DumpCostTable() const {
+  LogInfo::MapleLogger() << "===== DumpCostTable =====\n";
+  uint32 i = 0;
+  for (const auto &pair : costTable) {
+    LogInfo::MapleLogger() << "[" << i++ << "] " << pair.first << ", insns: " << pair.second.GetInsns() <<
+        ", cycles: " << pair.second.GetCycles() << std::endl;
+    pair.first->Dump(conditions);
+  }
+}
+
+void InlineSummary::DumpArgInfosMap() const {
+  LogInfo::MapleLogger() << "===== DumpArgInfosMap =====\n";
+  for (const auto &pair : argInfosMap) {
+    auto callStmtId = pair.first;
+    LogInfo::MapleLogger() << "callStmtId: " << callStmtId << std::endl;
+    const auto &argValTable = *pair.second;
+    for (uint32 i = 0; i < argValTable.size(); ++i) {
+      const auto *argRange = argValTable[i];
+      if (argRange == nullptr) {
+        continue;
+      }
+      LogInfo::MapleLogger() << "  arg" << i << ": ";
+      if (argRange->IsSingleValue()) {
+        argRange->GetLower()->Dump(nullptr);
+      } else {
+        LogInfo::MapleLogger() << "[" << argRange->GetLower() << ", " << argRange->GetUpper() << "]";
+      }
+      LogInfo::MapleLogger() << std::endl;
+    }
+  }
+}
+
+void InlineSummary::DumpEdgeSummaryMap() const {
+  LogInfo::MapleLogger() << "===== DumpEdgeSummaryMap =====\n";
+  for (auto &pair : edgeSummaryMap) {
+    auto *edgeSummary = pair.second;
+    LogInfo::MapleLogger() << " callId: " << pair.first << ", freq: " << edgeSummary->frequency << std::endl;
+  }
+}
+
+void InlineSummary::Dump() const {
+  LogInfo::MapleLogger() << "Inline summary for func: " << func->GetName() << std::endl;
+  LogInfo::MapleLogger() << "static insns: " << staticCost.GetInsns() <<
+      ", static cycles: " << staticCost.GetCycles() << std::endl;
+  DumpArgInfosMap();
+  DumpCostTable();
+  DumpConditions();
+  DumpEdgeSummaryMap();
+}
+
+// All collected real arg values will be saved into inline summary.
+void InlineSummaryCollector::CollectArgInfo(MeFunction &meFunc) {
+  InlineSummary *summary = meFunc.GetMirFunc()->GetOrCreateInlineSummary();
+  if (summary->IsArgInfoCollected()) {
+    return;
+  }
+  summary->SetArgInfoCollected(true);
+  // tmpAllocator is only used by EvaluateMeExpr.
+  LocalMapleAllocator tmpAllocator(meFunc.GetStackMemPool());
+  auto &sumAlloc = summary->GetSummaryAlloc();
+  for (auto *bb : meFunc.GetCfg()->GetAllBBs()) {
+    if (bb == nullptr) {
+      continue;
+    }
+    for (auto &stmt : bb->GetMeStmts()) {
+      if (stmt.GetOp() != OP_call && stmt.GetOp() != OP_callassigned) {
+        continue;
+      }
+      auto &callStmt = static_cast<CallMeStmt&>(stmt);
+      auto &callee = callStmt.GetTargetFunction();
+      bool recursiveCall = meFunc.GetMirFunc()->GetPuidx() == callee.GetPuidx();
+      (void)callee;  // filter by callee if necessary
+      for (uint32 i = 0; i < callStmt.GetOpnds().size(); ++i) {
+        auto *argOpnd = callStmt.GetOpnd(i);
+        // (1) Record mapping from argument index to caller parameter index
+        // To improv: simple operation can be allowed to perform on caller's formals. such as (formal + constant)
+        if (!recursiveCall) {  // param mapping not work for recursive call currently
+          auto paramIndex = GetZeroVersionParamIndex(*argOpnd, meFunc);
+          if (paramIndex.has_value()) {
+            auto *argInfo = sumAlloc.New<ArgInfo>(paramIndex.value());
+            summary->AddArgInfo(callStmt.GetMeStmtId(), i, argInfo);
+          }
+        }
+        // (2) Evaluate arguments value
+        auto *mirConst = EvaluateMeExpr(*argOpnd, meFunc, tmpAllocator);
+        if (mirConst == nullptr) {
+          continue;  // argOpnd is not a constant number
+        }
+        auto *argInfo = sumAlloc.New<ArgInfo>(mirConst, mirConst);
+        summary->AddArgInfo(callStmt.GetMeStmtId(), i, argInfo);
+      }
+    }
+  }
+}
+
+// First iteration: compute succ edge predicate for condgoto bb and switch bb
+void InlineSummaryCollector::ComputeEdgePredicate() {
+  uint32 numBBs = func->GetCfg()->NumBBs();
+  allBBPred.resize(numBBs, nullptr);
+  for (uint32 i = 0; i < numBBs; ++i) {
+    auto *bb = func->GetCfg()->GetAllBBs()[i];
+    // We need also consider Switch BB in the future
+    if (bb == nullptr || bb->GetKind() != kBBCondGoto) {
+      continue;
+    }
+    // for CondGoto bb
+    auto *lastStmt = bb->GetLastMe();
+    ASSERT_NOT_NULL(lastStmt);
+    CHECK_FATAL(lastStmt->GetOp() == OP_brtrue || lastStmt->GetOp() == OP_brfalse, "must be");
+    auto *condStmt = static_cast<CondGotoMeStmt*>(lastStmt);
+    auto *condExpr = condStmt->GetOpnd(0);
+    uint32 paramsUsed = 0;
+    auto *condLiteExpr = GetOrCreateLiteExpr(*condExpr, kExprKindConstNumber | kExprKindParam, paramsUsed);
+    if (condLiteExpr == nullptr) {
+      continue;
+    }
+    // set succ edge predicates for current bb
+    PreparePredicateForBB(*bb);
+    allBBPred[i]->succEdgePredicates.resize(bb->GetSucc().size(), nullptr);
+    for (uint32 j = 0; j < bb->GetSucc().size(); ++j) {
+      auto *succ = bb->GetSucc(j);
+      bool isBrtrue = condStmt->GetOp() == OP_brtrue;
+      bool isJump = condStmt->GetOffset() == succ->GetBBLabel();
+      bool isTrueBranch = (isBrtrue == isJump);
+      allBBPred[i]->succEdgePredicates[j] =
+          inlineSummary->AddCondition(condLiteExpr, !isTrueBranch, paramsUsed, tmpAlloc);
+    }
+  }
+}
+
+// Second iteration: propagate bb predicate in the CFG
+// All predicates generated by this function are allocated in tmpAlloc
+// All liteExprs and conditions are allocated in summaryAlloc
+void InlineSummaryCollector::PropBBPredicate() {
+  auto *commonEntry = func->GetCfg()->GetCommonEntryBB();
+  CHECK_FATAL(commonEntry->GetSucc().size() == 1, "must be");
+  auto *startBB = commonEntry->GetSucc(0);
+  PreparePredicateForBB(*startBB);
+  allBBPred[startBB->GetBBId()]->predicate = Predicate::TruePredicate();
+  for (auto *node : dom.GetReversePostOrder()) {  // What about loops?
+    auto bb = func->GetCfg()->GetBBFromID(BBId(node->GetID()));
+    if (bb == nullptr || bb->GetBBId() <= 1) {
+      continue;
+    }
+    uint32 bbId = bb->GetBBId().get();
+    auto *p = Predicate::FalsePredicate();
+    for (uint32 i = 0; i < bb->GetPred().size(); ++i) {
+      auto *pred = bb->GetPred(i);
+      auto *srcBBAux = allBBPred[pred->GetBBId()];
+      if (srcBBAux != nullptr && srcBBAux->predicate != nullptr) {
+        const Predicate *destBBPredicate = srcBBAux->predicate;
+        int retIndex = pred->GetSuccIndex(*bb);
+        CHECK_FATAL(retIndex >= 0, "must be");
+        auto succIndex = static_cast<size_t>(static_cast<uint32>(retIndex));
+        if (succIndex < srcBBAux->succEdgePredicates.size()) {
+          auto *succEdgePredicate = srcBBAux->succEdgePredicates[succIndex];
+          CHECK_NULL_FATAL(succEdgePredicate);
+          destBBPredicate = Predicate::And(*destBBPredicate, *succEdgePredicate, tmpAlloc);
+        }
+        p = Predicate::Or(*destBBPredicate, *p, inlineSummary->GetConditions(), tmpAlloc);
+        if (p->IsTruePredicate()) {
+          break;
+        }
+      }
+    }
+    PreparePredicateForBB(*bb);
+    if (allBBPred[bbId]->predicate == nullptr) {
+      allBBPred[bbId]->predicate = p;
+    }
+  }
+}
+
+// Returned callFrequency value range: [0, kCallFreqMax]
+static int32 ComputeCallFrequency(const BB &bb) {
+  auto bbFreq = bb.GetFrequency();
+  if (bbFreq == 0) {  // bb freq is invalid
+    return kCallFreqBase;
+  }
+  auto freq = static_cast<int32>(bbFreq * 1.0 * kCallFreqBase / kFreqBase);
+  if (freq > kCallFreqMax) {
+    freq = kCallFreqMax;
+  }
+  return freq;
+}
+
+// Get approximated probability of `stmt` might be remove after inlining
+int32 GetRemoveStmtProbAfterInlining(const MeStmt &stmt) {
+  auto op = stmt.GetOp();
+  if (op == OP_return) {
+    return kRemoveStmtAll;
+  }
+  (void)kRemoveStmtHalf;
+  return kRemoveStmtNone;
+}
+
+static void PrintStmtFreqAndCost(MeFunction &func, const MeStmt &stmt,
+    int32 callFrequency, int32 stmtInsns, int32 stmtCycles) {
+  auto &module = func.GetMIRModule();
+  auto *oldFunc = module.CurFunction();
+  module.SetCurFunction(func.GetMirFunc());
+  stmt.GetSrcPosition().Dump();
+  stmt.Dump(func.GetIRMap());
+  module.SetCurFunction(oldFunc);
+  LogInfo::MapleLogger() << "  freq: " << CallFreqPercent(callFrequency) << ", insns: " << stmtInsns <<
+      ", cycles: " << stmtCycles << std::endl;
+}
+
+static void InlineAnalysisForCallStmt(const CallMeStmt &callStmt, const MIRFunction &caller,
+    InlineSummary &callerSummary) {
+  auto &targetFunc = callStmt.GetTargetFunction();
+  if (targetFunc.GetName().find("setjmp") != std::string::npos) {
+    callerSummary.SetInlineFailedCode(kIFC_SetjmpInCallee);
+  }
+  // Recursive call is not supported by ginline for now.
+  // Small recursive callee are supposed to be inlined by einline.
+  if (targetFunc.GetPuidx() == caller.GetPuidx()) {
+    callerSummary.SetInlineFailedCode(kIFC_GinlineRecursiveCall);
+  }
+}
+
+std::pair<int32, double> InlineSummaryCollector::AnalyzeCondCostForStmt(MeStmt &stmt, int32 callFrequency,
+    const Predicate *bbPredClone, const BBPredicate &bbPredicate) {
+  Opcode op = stmt.GetOp();
+  const auto stmtInsns = stmtCostAnalyzer.EstimateNumInsns(&stmt);  // Estimated number of instructions
+  const auto stmtCycles = stmtCostAnalyzer.EstimateNumCycles(&stmt);
+  const auto stmtCyclesWithFreq = stmtCycles * CallFreqPercent(callFrequency);
+  CHECK_FATAL(stmtInsns >= 0, "must be");
+  CHECK_FATAL(stmtCyclesWithFreq >= 0, "must be");
+  if (debug) {
+    PrintStmtFreqAndCost(*func, stmt, callFrequency, stmtInsns, stmtCycles);
+  }
+  // Record inline edge summary
+  bool isCall = op == OP_call || op == OP_callassigned;
+  if (isCall) {
+    if (bbPredClone == nullptr) {
+      // We need clone call bb predicate from tmpAlloc to summaryAlloc
+      bbPredClone = bbPredicate.predicate->Clone(summaryAlloc);
+    }
+    // Init inline edge summary
+    // Does edge summary need loop depth info of callBB?
+    inlineSummary->AddEdgeSummary(stmt.GetMeStmtId(), bbPredClone, callFrequency, stmtInsns, stmtCycles);
+    InlineAnalysisForCallStmt(static_cast<CallMeStmt&>(stmt), *func->GetMirFunc(), *inlineSummary);
+  } else if (op == OP_switch) {
+    auto &switchStmt = static_cast<SwitchMeStmt&>(stmt);
+    constexpr size_t numSwitchCases = 4;
+    if (switchStmt.GetSwitchTable().size() >= numSwitchCases) {
+      inlineSummary->SetHasBigSwitch(true);
+    }
+  }
+  if (stmtInsns != 0 || stmtCyclesWithFreq > 0) {
+    int32 removeProb = GetRemoveStmtProbAfterInlining(stmt);
+    if (removeProb == kRemoveStmtAll) {
+      auto *notInlinePredicate = Predicate::NotInlinePredicate();
+      auto *predicate = Predicate::And(*bbPredicate.predicate, *notInlinePredicate, tmpAlloc);
+      inlineSummary->AddCondCostItem(*predicate, stmtInsns, stmtCyclesWithFreq, debug);
+    } else {
+      inlineSummary->AddCondCostItem(*bbPredicate.predicate, stmtInsns, stmtCyclesWithFreq, debug);
+    }
+  }
+  return { stmtInsns, stmtCyclesWithFreq };
+}
+
+void InlineSummaryCollector::ComputeConditionalCost() {
+  ASSERT(inlineSummary != nullptr, "should be created before");
+  NumInsns staticSize = 0;
+  NumCycles staticTime = 0;
+  // Init notInline size cost
+  constexpr NumInsns notInlineSizeCost = 2;
+  inlineSummary->AddCondCostItem(*Predicate::NotInlinePredicate(), notInlineSizeCost, 0, debug);
+  const auto &rpoBBs = dom.GetReversePostOrder();
+  for (auto *node : rpoBBs) {
+    if (node == nullptr || node->GetID() <= 1) {
+      continue;
+    }
+    auto bb = func->GetCfg()->GetBBFromID(BBId(node->GetID()));
+    BBPredicate *bbPredicate = allBBPred[bb->GetBBId()];
+    const Predicate *bbPredClone = nullptr;
+    if (debug) {
+      LogInfo::MapleLogger() << "\nBB " << bb->GetBBId() << " predicate: ";
+      bbPredicate->predicate->Dump(inlineSummary->GetConditions());
+    }
+    int32 callFrequency = ComputeCallFrequency(*bb);
+    CHECK_FATAL(callFrequency >= 0, "must be");
+    MeStmt *stmt = bb->GetFirstMe();
+    while (stmt != nullptr) {
+      auto *next = stmt->GetNextMeStmt();
+      auto op = stmt->GetOp();
+      if (op == OP_comment) {
+        stmt = next;
+        continue;
+      }
+      auto cost = AnalyzeCondCostForStmt(*stmt, callFrequency, bbPredClone, *bbPredicate);
+      // Record static cost
+      const auto stmtInsns = cost.first;
+      const auto stmtCyclesWithFreq = cost.second;
+      staticSize += stmtInsns;
+      staticTime += stmtCyclesWithFreq;
+      // CondgotoStmt can be ignored if the condition expr is constant
+      // we can use 'true' succ edge predicate of current bb
+      stmt = next;
+    }
+  }
+  inlineSummary->SetStaticCost(staticSize, staticTime);
+  // Clone necessary predicates from tmpAlloc to summaryAlloc
+  inlineSummary->CloneAllPredicatesToSummaryAlloc();
+}
+
+InlineCost GetCondInlineCost(const MIRFunction &caller, MIRFunction &callee, const CallNode &callStmt) {
+  auto *memPool = memPoolCtrler.NewMemPool("", true);
+  MapleAllocator tmpAlloc(memPool);
+  auto *callerSummary = caller.GetInlineSummary();
+  CHECK_NULL_FATAL(callerSummary);
+  auto *calleeSummary = callee.GetInlineSummary();
+  CHECK_NULL_FATAL(calleeSummary);
+  auto callStmtId = callStmt.GetStmtID();
+  const auto &argInfosMap = callerSummary->GetArgInfosMap();
+  auto &conditionalCostTable = calleeSummary->GetCostTable();
+  ArgInfoVec *argInfoVec = nullptr;
+  auto it = argInfosMap.find(callStmtId);
+  if (it != argInfosMap.end()) {
+    argInfoVec = it->second;
+  }
+  std::vector<ExprBoolResult> condResultVec;
+  calleeSummary->EvaluateConditions(tmpAlloc, argInfoVec, condResultVec, true);
+  int32 condSize = 0;
+  double condTime = 0;
+  for (const auto &pair : conditionalCostTable) {
+    const auto *predicate = pair.first;
+    // If predicate is TRUE or UNKNOWN, cost should be appended
+    if (predicate->Evaluate(condResultVec) != kExprResFalse) {
+      const auto &inlineCost = pair.second;
+      condSize += inlineCost.GetInsns();
+      condTime += inlineCost.GetCycles();
+    }
+  }
+  memPoolCtrler.DeleteMemPool(memPool);
+  return { condSize, condTime };
+}
+}  // namespace maple
+
diff --git a/src/mapleall/mpl2mpl/src/inline_transformer.cpp b/src/mapleall/mpl2mpl/src/inline_transformer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..62e96db7636f03cb702394b003fe833a691fc105
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/inline_transformer.cpp
@@ -0,0 +1,957 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "inline_transformer.h"
+
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include "global_tables.h"
+#include "mpl_logging.h"
+#include "inline_summary.h"
+
+namespace maple {
+// This phase replaces a function call site with the body of the called function.
+//   Step 0: See if CALLEE have been inlined to CALLER once.
+//   Step 1: Clone CALLEE's body.
+//   Step 2: Rename symbols, labels, pregs.
+//   Step 3: Replace symbols, labels, pregs.
+//   Step 4: Null check 'this' and assign actuals to formals.
+//   Step 5: Insert the callee'return jump dest label.
+//   Step 6: Handle return values.
+//   Step 7: Remove the successive goto statement and label statement in some circumstances.
+//   Step 8: Replace the call-stmt with new CALLEE'body.
+//   Step 9: Update inlined_times.
+
+// mapping stmtId of orig callStmt to stmtId of cloned callStmt
+struct CallStmtIdMap : public CallBackData {
+  // we did not override CallBackData::Free() because callIdMap is managed by caller
+  std::map<uint32, uint32> callIdMap;
+};
+
+void RecordCallStmtIdMap(const BlockNode &oldBlock, BlockNode &newBlock, const StmtNode &oldStmt,
+    StmtNode &newStmt, CallBackData *data) {
+  (void)oldBlock;
+  (void)newBlock;
+  if (newStmt.GetOpCode() != OP_call && newStmt.GetOpCode() != OP_callassigned) {
+    return;
+  }
+  CHECK_NULL_FATAL(data);
+  auto &callIdMap = static_cast<CallStmtIdMap*>(data)->callIdMap;
+  (void)callIdMap.emplace(oldStmt.GetStmtID(), newStmt.GetStmtID());
+}
+
+void UpdateEnclosingBlockCallback(const BlockNode &oldBlock, BlockNode &newBlock, const StmtNode &oldStmt,
+    StmtNode &newStmt, CallBackData *data) {
+  (void)oldBlock;
+  (void)oldStmt;
+  CHECK_FATAL(data == nullptr, "Should be null");
+  CallNode *callNode = safe_cast<CallNode>(&newStmt);
+  if (callNode == nullptr) {
+    return;
+  }
+  callNode->SetEnclosingBlock(&newBlock);
+}
+
+// Common rename function
+uint32 InlineTransformer::RenameSymbols(uint32 inlinedTimes) const {
+  uint32 symTabSize = static_cast<uint32>(callee.GetSymbolTabSize());
+  uint32 stIdxOff = static_cast<uint32>(caller.GetSymTab()->GetSymbolTableSize()) - 1;
+  for (uint32 i = 0; i < symTabSize; ++i) {
+    const MIRSymbol *sym = callee.GetSymbolTabItem(i);
+    if (sym == nullptr) {
+      continue;
+    }
+    CHECK_FATAL(sym->GetStorageClass() != kScPstatic, "pstatic symbols should have been converted to fstatic ones");
+    std::string syName(kUnderlineStr);
+    // Use puIdx here instead of func name because our mangled func name can be
+    // really long.
+    (void)syName.append(std::to_string(callee.GetPuidx()))
+        .append(kVerticalLineStr)
+        .append((sym->GetName() == "") ? std::to_string(i) : sym->GetName())
+        .append(kUnderlineStr);
+    if (!theMIRModule->firstInline) {
+      syName += kSecondInlineSymbolSuffix;
+    }
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(syName + std::to_string(inlinedTimes));
+    if (sym->GetScopeIdx() == 0) {
+      CHECK_FATAL(false, "sym->GetScopeIdx() should be != 0");
+    }
+    MIRSymbol *newSym = nullptr;
+    newSym = caller.GetSymTab()->CloneLocalSymbol(*sym);
+    newSym->SetNameStrIdx(strIdx);
+    if (newSym->GetStorageClass() == kScFormal) {
+      newSym->SetStorageClass(kScAuto);
+    }
+    newSym->SetIsTmp(true);
+    newSym->ResetIsDeleted();
+    if (!caller.GetSymTab()->AddStOutside(newSym)) {
+      CHECK_FATAL(false, "Reduplicate names.");
+    }
+    if (newSym->GetStIndex() != (i + stIdxOff)) {
+      CHECK_FATAL(false, "wrong symbol table index");
+    }
+    CHECK_FATAL(caller.GetSymTab()->IsValidIdx(newSym->GetStIndex()), "symbol table index out of range");
+  }
+  return stIdxOff;
+}
+
+static StIdx UpdateIdx(const StIdx &stIdx, uint32 stIdxOff, const std::vector<uint32> *oldStIdx2New) {
+  // If the callee has pstatic symbols, we will save all symbol mapping info in the oldStIdx2New.
+  // So if this oldStIdx2New is nullptr, we only use stIdxOff to update stIdx, otherwise we only use oldStIdx2New.
+  StIdx newStIdx = stIdx;
+  if (oldStIdx2New == nullptr) {
+    newStIdx.SetIdx(newStIdx.Idx() + stIdxOff);
+  } else {
+    CHECK_FATAL(newStIdx.Idx() < oldStIdx2New->size(), "stIdx out of range");
+    newStIdx.SetFullIdx((*oldStIdx2New)[newStIdx.Idx()]);
+  }
+  return newStIdx;
+}
+
+void InlineTransformer::ReplaceSymbols(BaseNode *baseNode, uint32 stIdxOff, const std::vector<uint32> *oldStIdx2New) {
+  if (baseNode == nullptr) {
+    return;
+  }
+  CallReturnVector *returnVector = baseNode->GetCallReturnVector();
+  if (baseNode->GetOpCode() == OP_block) {
+    BlockNode *blockNode = static_cast<BlockNode*>(baseNode);
+    for (auto &stmt : blockNode->GetStmtNodes()) {
+      ReplaceSymbols(&stmt, stIdxOff, oldStIdx2New);
+    }
+  } else if (baseNode->GetOpCode() == OP_dassign) {
+    DassignNode *dassNode = static_cast<DassignNode*>(baseNode);
+    // Skip globals.
+    if (dassNode->GetStIdx().Islocal()) {
+      dassNode->SetStIdx(UpdateIdx(dassNode->GetStIdx(), stIdxOff, oldStIdx2New));
+    }
+  } else if ((baseNode->GetOpCode() == OP_addrof || baseNode->GetOpCode() == OP_dread)) {
+    AddrofNode *addrNode = static_cast<AddrofNode*>(baseNode);
+    // Skip globals.
+    if (addrNode->GetStIdx().Islocal()) {
+      addrNode->SetStIdx(UpdateIdx(addrNode->GetStIdx(), stIdxOff, oldStIdx2New));
+    }
+  } else if (returnVector != nullptr) {
+    // Skip globals.
+    for (size_t i = 0; i < returnVector->size(); ++i) {
+      if (!(*returnVector).at(i).second.IsReg() && (*returnVector).at(i).first.Islocal()) {
+        (*returnVector)[i].first = UpdateIdx((*returnVector).at(i).first, stIdxOff, oldStIdx2New);
+      }
+    }
+  } else if (baseNode->GetOpCode() == OP_foreachelem) {
+    ForeachelemNode *forEachNode = static_cast<ForeachelemNode*>(baseNode);
+    // Skip globals.
+    if (forEachNode->GetElemStIdx().Idx() != 0) {
+      forEachNode->SetElemStIdx(UpdateIdx(forEachNode->GetElemStIdx(), stIdxOff, oldStIdx2New));
+    }
+    if (forEachNode->GetArrayStIdx().Idx() != 0) {
+      forEachNode->SetArrayStIdx(UpdateIdx(forEachNode->GetArrayStIdx(), stIdxOff, oldStIdx2New));
+    }
+  } else if (baseNode->GetOpCode() == OP_doloop) {
+    DoloopNode *doLoopNode = static_cast<DoloopNode*>(baseNode);
+    // Skip globals.
+    if (!doLoopNode->IsPreg() && doLoopNode->GetDoVarStIdx().Idx()) {
+      doLoopNode->SetDoVarStIdx(UpdateIdx(doLoopNode->GetDoVarStIdx(), stIdxOff, oldStIdx2New));
+    }
+  }
+  // Search for nested dassign/dread/addrof node that may include a symbol index.
+  for (size_t i = 0; i < baseNode->NumOpnds(); ++i) {
+    ReplaceSymbols(baseNode->Opnd(i), stIdxOff, oldStIdx2New);
+  }
+}
+
+uint32 InlineTransformer::RenameLabels(uint32 inlinedTimes) const {
+  size_t labelTabSize = callee.GetLabelTab()->GetLabelTableSize();
+  uint32 labIdxOff = static_cast<uint32>(caller.GetLabelTab()->GetLabelTableSize()) - 1;
+  // label table start at 1.
+  for (size_t i = 1; i < labelTabSize; ++i) {
+    std::string labelName = callee.GetLabelTabItem(static_cast<LabelIdx>(i));
+    std::string newLableName(kUnderlineStr);
+    (void)newLableName.append(std::to_string(callee.GetPuidx()))
+        .append(kVerticalLineStr)
+        .append(labelName)
+        .append(kUnderlineStr)
+        .append(std::to_string(inlinedTimes));
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(newLableName);
+    LabelIdx labIdx = caller.GetLabelTab()->AddLabel(strIdx);
+    CHECK_FATAL(labIdx == (i + labIdxOff), "wrong label index");
+  }
+  return labIdxOff;
+}
+
+#define MPLTOOL
+void InlineTransformer::ReplaceLabels(BaseNode &baseNode, uint32 labIdxOff) const {
+  // Now only mpltool would allow try in the callee.
+#ifdef MPLTOOL
+  if (baseNode.GetOpCode() == OP_try) {
+    TryNode *tryNode = static_cast<TryNode*>(&baseNode);
+    for (size_t i = 0; i < tryNode->GetOffsetsCount(); ++i) {
+      tryNode->SetOffset(tryNode->GetOffset(i) + labIdxOff, i);
+    }
+  }
+#else
+  CHECK_FATAL(baseNode->op != OP_try, "Java `try` not allowed");
+#endif
+  if (baseNode.GetOpCode() == OP_block) {
+    BlockNode *blockNode = static_cast<BlockNode*>(&baseNode);
+    for (auto &stmt : blockNode->GetStmtNodes()) {
+      ReplaceLabels(stmt, labIdxOff);
+    }
+  } else if (baseNode.IsCondBr()) {
+    CondGotoNode *temp = static_cast<CondGotoNode*>(&baseNode);
+    temp->SetOffset(temp->GetOffset() + labIdxOff);
+  } else if (baseNode.GetOpCode() == OP_label) {
+    static_cast<LabelNode*>(&baseNode)->SetLabelIdx(static_cast<LabelNode*>(&baseNode)->GetLabelIdx() + labIdxOff);
+  } else if (baseNode.GetOpCode() == OP_addroflabel) {
+    uint32 offset = static_cast<AddroflabelNode*>(&baseNode)->GetOffset();
+    static_cast<AddroflabelNode*>(&baseNode)->SetOffset(offset + labIdxOff);
+  } else if (baseNode.GetOpCode() == OP_goto) {
+    static_cast<GotoNode*>(&baseNode)->SetOffset(static_cast<GotoNode*>(&baseNode)->GetOffset() + labIdxOff);
+  } else if (baseNode.GetOpCode() == OP_multiway || baseNode.GetOpCode() == OP_rangegoto) {
+    ASSERT(false, "InlineTransformer::ReplaceLabels: OP_multiway and OP_rangegoto are not supported");
+  } else if (baseNode.GetOpCode() == OP_switch) {
+    SwitchNode *switchNode = static_cast<SwitchNode*>(&baseNode);
+    // defaultLabel with value 0 is invalid, we should keep its value
+    if (switchNode->GetDefaultLabel() != 0) {
+      switchNode->SetDefaultLabel(switchNode->GetDefaultLabel() + labIdxOff);
+    }
+    for (uint32_t i = 0; i < switchNode->GetSwitchTable().size(); ++i) {
+      LabelIdx idx = switchNode->GetSwitchTable()[i].second + labIdxOff;
+      switchNode->UpdateCaseLabelAt(i, idx);
+    }
+  } else if (baseNode.GetOpCode() == OP_doloop) {
+    ReplaceLabels(*static_cast<DoloopNode&>(baseNode).GetDoBody(), labIdxOff);
+  } else if (baseNode.GetOpCode() == OP_foreachelem) {
+    ReplaceLabels(*static_cast<ForeachelemNode&>(baseNode).GetLoopBody(), labIdxOff);
+  } else if (baseNode.GetOpCode() == OP_dowhile || baseNode.GetOpCode() == OP_while) {
+    ReplaceLabels(*static_cast<WhileStmtNode&>(baseNode).GetBody(), labIdxOff);
+  } else if (baseNode.GetOpCode() == OP_if) {
+    ReplaceLabels(*static_cast<IfStmtNode&>(baseNode).GetThenPart(), labIdxOff);
+    if (static_cast<IfStmtNode*>(&baseNode)->GetElsePart()) {
+      ReplaceLabels(*static_cast<IfStmtNode&>(baseNode).GetElsePart(), labIdxOff);
+    }
+  }
+}
+
+uint32 InlineTransformer::RenamePregs(std::unordered_map<PregIdx, PregIdx> &pregOld2new) const {
+  const MapleVector<MIRPreg*> &tab = callee.GetPregTab()->GetPregTable();
+  size_t tableSize = tab.size();
+  uint32 regIdxOff = static_cast<uint32>(caller.GetPregTab()->Size()) - 1;
+  for (size_t i = 1; i < tableSize; ++i) {
+    MIRPreg *mirPreg = tab[i];
+    PregIdx idx = 0;
+    if (mirPreg->GetPrimType() == PTY_ptr || mirPreg->GetPrimType() == PTY_ref) {
+      idx = caller.GetPregTab()->ClonePreg(*mirPreg);
+    } else {
+      idx = caller.GetPregTab()->CreatePreg(mirPreg->GetPrimType());
+    }
+    pregOld2new[i] = idx;
+  }
+  return regIdxOff;
+}
+
+static PregIdx GetNewPregIdx(PregIdx regIdx, std::unordered_map<PregIdx, PregIdx> &pregOld2New) {
+  if (regIdx < 0) {
+    return regIdx;
+  }
+  auto it = pregOld2New.find(regIdx);
+  CHECK_FATAL(it != pregOld2New.end(), "Unable to find the regIdx to replace");
+  return it->second;
+}
+
+void InlineTransformer::ReplacePregs(BaseNode *baseNode, std::unordered_map<PregIdx, PregIdx> &pregOld2New) const {
+  if (baseNode == nullptr) {
+    return;
+  }
+  auto op = baseNode->GetOpCode();
+  if (op == OP_block) {
+    for (auto &stmt : static_cast<BlockNode*>(baseNode)->GetStmtNodes()) {
+      ReplacePregs(&stmt, pregOld2New);
+    }
+  } else if (op == OP_regassign) {
+    RegassignNode *regassign = static_cast<RegassignNode*>(baseNode);
+    regassign->SetRegIdx(GetNewPregIdx(regassign->GetRegIdx(), pregOld2New));
+  } else if (op == OP_regread) {
+    RegreadNode *regread = static_cast<RegreadNode*>(baseNode);
+    regread->SetRegIdx(GetNewPregIdx(regread->GetRegIdx(), pregOld2New));
+  } else if (op == OP_doloop) {
+    DoloopNode *doloop = static_cast<DoloopNode*>(baseNode);
+    if (doloop->IsPreg()) {
+      PregIdx oldIdx = static_cast<PregIdx>(doloop->GetDoVarStIdx().FullIdx());
+      doloop->SetDoVarStFullIdx(static_cast<uint32>(GetNewPregIdx(oldIdx, pregOld2New)));
+    }
+  } else if (op == OP_callassigned || op == OP_virtualcallassigned || op == OP_superclasscallassigned ||
+             op == OP_interfacecallassigned || op == OP_customcallassigned || op == OP_polymorphiccallassigned ||
+             op == OP_icallassigned || op == OP_intrinsiccallassigned || op == OP_xintrinsiccallassigned ||
+             op == OP_intrinsiccallwithtypeassigned) {
+    CallReturnVector *retVec = baseNode->GetCallReturnVector();
+    CHECK_FATAL(retVec != nullptr, "retVec is nullptr in InlineTransformer::ReplacePregs");
+    for (size_t i = 0; i < retVec->size(); ++i) {
+      CallReturnPair &callPair = (*retVec).at(i);
+      if (callPair.second.IsReg()) {
+        PregIdx oldIdx = callPair.second.GetPregIdx();
+        callPair.second.SetPregIdx(GetNewPregIdx(oldIdx, pregOld2New));
+      }
+    }
+  }
+  for (size_t i = 0; i < baseNode->NumOpnds(); ++i) {
+    ReplacePregs(baseNode->Opnd(i), pregOld2New);
+  }
+}
+
+LabelIdx InlineTransformer::CreateReturnLabel(uint32 inlinedTimes) const {
+  std::string labelName(kUnderlineStr);
+  (void)labelName.append(std::to_string(callee.GetPuidx()))
+      .append(kVerticalLineStr)
+      .append(kReturnlocStr)
+      .append(std::to_string(inlinedTimes));
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(labelName);
+  LabelIdx labIdx = caller.GetLabelTab()->AddLabel(strIdx);
+  return labIdx;
+}
+
+GotoNode *InlineTransformer::DoUpdateReturnStmts(BlockNode &newBody, StmtNode &stmt,
+                                                 const CallReturnVector *callReturnVector, int &retCount) const {
+  if (callReturnVector != nullptr && callReturnVector->size() > 1) {
+    CHECK_FATAL(false, "multiple return values are not supported");
+  }
+  ++retCount;
+  GotoNode *gotoNode = builder.CreateStmtGoto(OP_goto, returnLabelIdx);
+  if (callReturnVector != nullptr && callReturnVector->size() == 1 && stmt.GetNumOpnds() == 1) {
+    BaseNode *currBaseNode = static_cast<NaryStmtNode&>(stmt).Opnd(0);
+    StmtNode *dStmt = nullptr;
+    if (!callReturnVector->at(0).second.IsReg()) {
+      dStmt = builder.CreateStmtDassign(callReturnVector->at(0).first, callReturnVector->at(0).second.GetFieldID(),
+                                        currBaseNode);
+    } else {
+      PregIdx pregIdx = callReturnVector->at(0).second.GetPregIdx();
+      const MIRPreg *mirPreg = caller.GetPregTab()->PregFromPregIdx(pregIdx);
+      dStmt = builder.CreateStmtRegassign(mirPreg->GetPrimType(), pregIdx, currBaseNode);
+    }
+    dStmt->SetSrcPos(stmt.GetSrcPos());
+    if (updateFreq) {
+      caller.GetFuncProfData()->CopyStmtFreq(dStmt->GetStmtID(), stmt.GetStmtID());
+      caller.GetFuncProfData()->CopyStmtFreq(gotoNode->GetStmtID(), stmt.GetStmtID());
+      caller.GetFuncProfData()->EraseStmtFreq(stmt.GetStmtID());
+    }
+    newBody.ReplaceStmt1WithStmt2(&stmt, dStmt);
+    newBody.InsertAfter(dStmt, gotoNode);
+  } else {
+    if (updateFreq) {
+      caller.GetFuncProfData()->CopyStmtFreq(gotoNode->GetStmtID(), stmt.GetStmtID());
+      caller.GetFuncProfData()->EraseStmtFreq(stmt.GetStmtID());
+    }
+    newBody.ReplaceStmt1WithStmt2(&stmt, gotoNode);
+  }
+  return gotoNode;
+}
+
+GotoNode *InlineTransformer::UpdateReturnStmts(BlockNode &newBody, const CallReturnVector *callReturnVector,
+                                               int &retCount) const {
+  // Examples:
+  // For callee: return f ==>
+  //             rval = f; goto label x;
+  GotoNode *resultGoto = nullptr;
+  for (auto &stmt : newBody.GetStmtNodes()) {
+    GotoNode *lastGoto = nullptr;
+    switch (stmt.GetOpCode()) {
+      case OP_foreachelem:
+        lastGoto = UpdateReturnStmts(*static_cast<ForeachelemNode&>(stmt).GetLoopBody(), callReturnVector, retCount);
+        break;
+      case OP_doloop:
+        lastGoto = UpdateReturnStmts(*static_cast<DoloopNode&>(stmt).GetDoBody(), callReturnVector, retCount);
+        break;
+      case OP_dowhile:
+      case OP_while:
+        lastGoto = UpdateReturnStmts(*static_cast<WhileStmtNode&>(stmt).GetBody(), callReturnVector, retCount);
+        break;
+      case OP_if: {
+        IfStmtNode &ifStmt = static_cast<IfStmtNode&>(stmt);
+        lastGoto = UpdateReturnStmts(*ifStmt.GetThenPart(), callReturnVector, retCount);
+        if (ifStmt.GetElsePart() != nullptr) {
+          auto *temp = UpdateReturnStmts(*ifStmt.GetElsePart(), callReturnVector, retCount);
+          lastGoto = temp != nullptr ? temp : lastGoto;
+        }
+        break;
+      }
+      case OP_return: {
+        lastGoto = DoUpdateReturnStmts(newBody, stmt, callReturnVector, retCount);
+        break;
+      }
+      default:
+        break;
+    }
+    if (lastGoto != nullptr) {
+      resultGoto = lastGoto;
+    }
+  }
+  return resultGoto;
+}
+
+static void UpdateAddrofConstForPStatic(MIRConst &mirConst, MIRFunction &func,
+                                        const std::vector<uint32> &oldStIdx2New) {
+  auto constKind = mirConst.GetKind();
+  CHECK_FATAL(constKind != kConstLblConst, "should not be here");
+  if (constKind == kConstAddrof) {
+    auto *addrofConst = static_cast<MIRAddrofConst*>(&mirConst);
+    StIdx valueStIdx = addrofConst->GetSymbolIndex();
+    if (!valueStIdx.IsGlobal()) {
+      MIRSymbol *valueSym = func.GetSymbolTabItem(valueStIdx.Idx());
+      if (valueSym->GetStorageClass() == kScPstatic) {
+        valueStIdx.SetFullIdx(oldStIdx2New[valueStIdx.Idx()]);
+        addrofConst->SetSymbolIndex(valueStIdx);
+      }
+    }
+  } else if (constKind == kConstAggConst) {
+    // Example code: static struct tag1 { struct tag1 *next; } s1 = {&s1}
+    auto *aggConst = static_cast<MIRAggConst*>(&mirConst);
+    for (auto *subMirConst : aggConst->GetConstVec()) {
+      UpdateAddrofConstForPStatic(*subMirConst, func, oldStIdx2New);
+    }
+  }
+}
+
+static MIRSymbol *CreateFstaticFromPstatic(const MIRFunction &func, const MIRSymbol &oldSymbol) {
+  // convert pu-static to file-static
+  // pstatic symbol name mangling example: "foo_bar" --> "__pstatic__125__foo_bar"
+  const auto &symNameOrig = oldSymbol.GetName();
+  std::string symNameMangling = kPstatic + std::to_string(func.GetPuidx()) + kVerticalLineStr + symNameOrig;
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(symNameMangling);
+  MIRSymbol *newSym = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  newSym->SetNameStrIdx(strIdx);
+  newSym->SetStorageClass(kScFstatic);
+  newSym->SetTyIdx(oldSymbol.GetTyIdx());
+  newSym->SetSKind(oldSymbol.GetSKind());
+  newSym->SetAttrs(oldSymbol.GetAttrs());
+  newSym->SetValue(oldSymbol.GetValue());
+  // avoid pstatic vars to be replaced by const
+  newSym->SetHasPotentialAssignment();
+  return newSym;
+}
+
+void InlineTransformer::ConvertPStaticToFStatic(MIRFunction &func) {
+  bool hasPStatic = false;
+  for (size_t i = 0; i < func.GetSymbolTabSize(); ++i) {
+    MIRSymbol *sym = func.GetSymbolTabItem(static_cast<uint32>(i));
+    if (sym != nullptr && sym->GetStorageClass() == kScPstatic) {
+      hasPStatic = true;
+      break;
+    }
+  }
+  if (!hasPStatic) {
+    return;  // No pu-static symbols, just return
+  }
+  std::vector<MIRSymbol*> localSymbols;
+  std::vector<uint32> oldStIdx2New(func.GetSymbolTabSize(), 0);
+  uint32 pstaticNum = 0;
+  for (size_t i = 0; i < func.GetSymbolTabSize(); ++i) {
+    MIRSymbol *sym = func.GetSymbolTabItem(static_cast<uint32>(i));
+    if (sym == nullptr) {
+      continue;
+    }
+    StIdx oldStIdx = sym->GetStIdx();
+    if (sym->GetStorageClass() == kScPstatic) {
+      ++pstaticNum;
+      MIRSymbol *newSym = CreateFstaticFromPstatic(func, *sym);
+      bool success = GlobalTables::GetGsymTable().AddToStringSymbolMap(*newSym);
+      CHECK_FATAL(success, "Found repeated global symbols!");
+      oldStIdx2New[i] = newSym->GetStIdx().FullIdx();
+      // Examples:
+      // If a pstatic symbol `foo` is initialized by address of another pstatic symbol `bar`, we need update the stIdx
+      // of foo's initial value. Example code:
+      //   static int bar = 42;
+      //   static int *foo = &bar;
+      if ((newSym->GetSKind() == kStConst || newSym->GetSKind() == kStVar) && newSym->GetKonst() != nullptr) {
+        UpdateAddrofConstForPStatic(*newSym->GetKonst(), func, oldStIdx2New);
+      }
+    } else {
+      StIdx newStIdx(oldStIdx);
+      newStIdx.SetIdx(oldStIdx.Idx() - pstaticNum);
+      oldStIdx2New[i] = newStIdx.FullIdx();
+      sym->SetStIdx(newStIdx);
+      localSymbols.push_back(sym);
+    }
+  }
+  func.GetSymTab()->Clear();
+  func.GetSymTab()->PushNullSymbol();
+  for (MIRSymbol *sym : localSymbols) {
+    (void)func.GetSymTab()->AddStOutside(sym);
+  }
+  // The stIdxOff will be ignored, 0 is just a placeholder
+  ReplaceSymbols(func.GetBody(), 0, &oldStIdx2New);
+}
+
+BlockNode *InlineTransformer::CloneFuncBody(BlockNode &funcBody, bool recursiveFirstClone) {
+  if (callee.IsFromMpltInline()) {
+    return funcBody.CloneTree(theMIRModule->GetCurFuncCodeMPAllocator());
+  }
+  if (updateFreq) {
+    auto *callerProfData = caller.GetFuncProfData();
+    auto *calleeProfData = callee.GetFuncProfData();
+    uint64_t callsiteFreq = callerProfData->GetStmtFreq(callStmt.GetStmtID());
+    uint64_t calleeEntryFreq = calleeProfData->GetFuncFrequency();
+    uint32_t updateOp = (kKeepOrigFreq | kUpdateFreqbyScale);
+    BlockNode *blockNode;
+    if (recursiveFirstClone) {
+      blockNode = funcBody.CloneTreeWithFreqs(theMIRModule->GetCurFuncCodeMPAllocator(), callerProfData->GetStmtFreqs(),
+                                              calleeProfData->GetStmtFreqs(), 1, 1, updateOp);
+    } else {
+      blockNode = funcBody.CloneTreeWithFreqs(theMIRModule->GetCurFuncCodeMPAllocator(), callerProfData->GetStmtFreqs(),
+                                              calleeProfData->GetStmtFreqs(), callsiteFreq, calleeEntryFreq, updateOp);
+      // update callee left entry Frequency
+      uint64_t calleeFreq = calleeProfData->GetFuncRealFrequency();
+      calleeProfData->SetFuncRealFrequency(calleeFreq - callsiteFreq);
+    }
+    return blockNode;
+  } else {
+    std::set<std::string> funcName = {
+        "memcpy", "memset", "strncpy", "strcpy", "stpcpy", "vsprintf", "vsnprintf", "snprintf", "sprintf", "strcat",
+        "strncat", "mempcpy", "memmove", "__mempcpy_inline"};
+    if (funcName.find(callee.GetName()) != funcName.end() && callee.GetBody() != nullptr) {
+      return funcBody.CloneTreeWithSrcPosition(*theMIRModule, caller.GetNameStrIdx(), true, callStmt.GetSrcPos());
+    }
+    return funcBody.CloneTreeWithSrcPosition(*theMIRModule);
+  }
+}
+
+BlockNode *InlineTransformer::GetClonedCalleeBody() {
+  auto *calleeNode = cg->GetCGNode(&callee);
+  CHECK_NULL_FATAL(calleeNode);
+  if (&caller == &callee) {
+    if (dumpDetail) {
+      LogInfo::MapleLogger() << "[INLINE Recursive]: " << caller.GetName() << '\n';
+      constexpr int32 dumpIndent = 4;
+      callStmt.Dump(dumpIndent);
+    }
+    auto *currFuncBody = calleeNode->GetOriginBody();
+    if (currFuncBody == nullptr) {
+      currFuncBody = CloneFuncBody(*callee.GetBody(), true);
+      // For Inline recursive, we save the original function body before first inline.
+      calleeNode->SetOriginBody(currFuncBody);
+      // update inlining levels
+      calleeNode->IncreaseRecursiveLevel();
+    }
+    return CloneFuncBody(*currFuncBody, false);
+  } else {
+    return CloneFuncBody(*callee.GetBody(), false);
+  }
+}
+
+void InlineTransformer::AssignActualToFormal(BlockNode &newBody, uint32 stIdxOff, uint32 regIdxOff, BaseNode &oldActual,
+                                             const MIRSymbol &formal) {
+  BaseNode *actual = &oldActual;
+  if (formal.IsPreg()) {
+    PregIdx idx = callee.GetPregTab()->GetPregIdxFromPregno(static_cast<uint32>(formal.GetPreg()->GetPregNo()));
+    RegassignNode *regAssign =
+        builder.CreateStmtRegassign(formal.GetPreg()->GetPrimType(), idx + static_cast<int32>(regIdxOff), actual);
+    newBody.InsertFirst(regAssign);
+    return;
+  }
+
+  MIRSymbol *newFormal = caller.GetSymTab()->GetSymbolFromStIdx(formal.GetStIndex() + stIdxOff);
+  ASSERT_NOT_NULL(newFormal);
+  ASSERT_NOT_NULL(newFormal->GetType());
+  PrimType formalPrimType = newFormal->GetType()->GetPrimType();
+  PrimType realArgPrimType = actual->GetPrimType();
+  // If realArg's type is different from formal's type, use cvt
+  if (formalPrimType != realArgPrimType) {
+    bool fpTrunc = (IsPrimitiveFloat(formalPrimType) && IsPrimitiveFloat(realArgPrimType) &&
+                    GetPrimTypeSize(realArgPrimType) > GetPrimTypeSize(formalPrimType));
+    // fpTrunc always needs explicit cvt, for example: cvt f32 f64 (dread f32 xxx)
+    if (fpTrunc) {
+      actual = builder.CreateExprTypeCvt(OP_cvt, formalPrimType, realArgPrimType, *actual);
+    } else if (MustBeAddress(formalPrimType) != MustBeAddress(realArgPrimType)) {
+      bool intTrunc = (IsPrimitiveInteger(formalPrimType) && IsPrimitiveInteger(realArgPrimType) &&
+                       GetPrimTypeSize(realArgPrimType) > GetPrimTypeSize(formalPrimType));
+      // For dassign, if rhs-expr is a primitive integer type, the assigned variable may be smaller, resulting in a
+      // truncation. In this case, explicit cvt is not necessary
+      if (!intTrunc) {
+        actual = builder.CreateExprTypeCvt(OP_cvt, formalPrimType, realArgPrimType, *actual);
+      }
+    }
+  }
+  DassignNode *stmt = builder.CreateStmtDassign(*newFormal, 0, actual);
+  newBody.InsertFirst(stmt);
+  return;
+}
+
+void InlineTransformer::AssignActualsToFormals(BlockNode &newBody, uint32 stIdxOff, uint32 regIdxOff) {
+  if (static_cast<uint32>(callStmt.NumOpnds()) != callee.GetFormalCount()) {
+    LogInfo::MapleLogger() << "warning: # formal arguments != # actual arguments in the function " << callee.GetName()
+                           << ". [formal count] " << callee.GetFormalCount() << ", "
+                           << "[argument count] " << callStmt.NumOpnds() << std::endl;
+  }
+  if (callee.GetFormalCount() > 0 && callee.GetFormal(0)->GetName() == kThisStr) {
+    UnaryStmtNode *nullCheck = theMIRModule->CurFuncCodeMemPool()->New<UnaryStmtNode>(OP_assertnonnull);
+    nullCheck->SetOpnd(callStmt.Opnd(0), 0);
+    newBody.InsertFirst(nullCheck);
+  }
+  // The number of formals and realArg are not always equal
+  size_t realArgNum = std::min(callStmt.NumOpnds(), callee.GetFormalCount());
+  for (size_t i = 0; i < realArgNum; ++i) {
+    BaseNode *currBaseNode = callStmt.Opnd(i);
+    MIRSymbol *formal = callee.GetFormal(i);
+    CHECK_NULL_FATAL(currBaseNode);
+    CHECK_NULL_FATAL(formal);
+    AssignActualToFormal(newBody, stIdxOff, regIdxOff, *currBaseNode, *formal);
+    if (updateFreq) {
+      caller.GetFuncProfData()->CopyStmtFreq(newBody.GetFirst()->GetStmtID(), callStmt.GetStmtID());
+    }
+  }
+}
+
+void InlineTransformer::HandleReturn(BlockNode &newBody) {
+  // Find the rval of call-stmt
+  // calcute number of return stmt in CALLEE'body
+  int retCount = 0;
+  // record the last return stmt in CALLEE'body
+  GotoNode *lastGoto = nullptr;
+  CallReturnVector *currReturnVec = nullptr;
+  if (callStmt.GetOpCode() == OP_callassigned || callStmt.GetOpCode() == OP_virtualcallassigned ||
+      callStmt.GetOpCode() == OP_superclasscallassigned || callStmt.GetOpCode() == OP_interfacecallassigned) {
+    currReturnVec = &callStmt.GetReturnVec();
+    CHECK_FATAL(currReturnVec->size() <= 1, "multiple return values are not supported");
+  }
+  lastGoto = UpdateReturnStmts(newBody, currReturnVec, retCount);
+  // Step 6.5: remove the successive goto statement and label statement in some circumstances.
+  // There is no return stmt in CALLEE'body, if we have create a new label in Step5, remove it.
+  if (retCount == 0) {
+    if (labelStmt != nullptr) {
+      newBody.RemoveStmt(labelStmt);
+    }
+  } else {
+    // There are one or more goto stmt, remove the successive goto stmt and label stmt,
+    // if there is only one return stmt, we can remove the label created in Step5, too.
+    CHECK_FATAL(lastGoto != nullptr, "there should be at least one goto statement");
+    if (labelStmt == nullptr) {
+      // if we haven't created a new label in Step5, then newBody->GetLast == lastGoto means they are successive.
+      if (newBody.GetLast() == lastGoto) {
+        newBody.RemoveStmt(lastGoto);
+      }
+      return;
+    }
+    // if we have created a new label in Step5, then lastGoto->GetNext == labelStmt means they are successive.
+    if (lastGoto->GetNext() == labelStmt) {
+      newBody.RemoveStmt(lastGoto);
+      if (retCount == 1) {
+        newBody.RemoveStmt(labelStmt);
+      }
+    }
+  }
+  if (updateFreq && (labelStmt != nullptr) && (newBody.GetLast() == labelStmt)) {
+    caller.GetFuncProfData()->CopyStmtFreq(labelStmt->GetStmtID(), callStmt.GetStmtID());
+  }
+}
+
+void InlineTransformer::ReplaceCalleeBody(BlockNode &enclosingBlock, BlockNode &newBody) {
+  // begin inlining function
+  if (!Options::noComment) {
+    MapleString beginCmt(theMIRModule->CurFuncCodeMemPool());
+    if (theMIRModule->firstInline) {
+      beginCmt += kInlineBeginComment;
+    } else {
+      beginCmt += kSecondInlineBeginComment;
+    }
+    beginCmt += callee.GetName();
+    StmtNode *commNode = builder.CreateStmtComment(beginCmt.c_str());
+    enclosingBlock.InsertBefore(&callStmt, commNode);
+    if (updateFreq) {
+      caller.GetFuncProfData()->CopyStmtFreq(commNode->GetStmtID(), callStmt.GetStmtID());
+    }
+    // end inlining function
+    MapleString endCmt(theMIRModule->CurFuncCodeMemPool());
+    if (theMIRModule->firstInline) {
+      endCmt += kInlineEndComment;
+    } else {
+      endCmt += kSecondInlineEndComment;
+    }
+    endCmt += callee.GetName();
+    if (enclosingBlock.GetLast() != nullptr && &callStmt != enclosingBlock.GetLast()) {
+      CHECK_FATAL(callStmt.GetNext() != nullptr, "null ptr check");
+    }
+    commNode = builder.CreateStmtComment(endCmt.c_str());
+    enclosingBlock.InsertAfter(&callStmt, commNode);
+    if (updateFreq) {
+      caller.GetFuncProfData()->CopyStmtFreq(commNode->GetStmtID(), callStmt.GetStmtID());
+    }
+    CHECK_FATAL(callStmt.GetNext() != nullptr, "null ptr check");
+  }
+  if (newBody.IsEmpty()) {
+    enclosingBlock.RemoveStmt(&callStmt);
+  } else {
+    enclosingBlock.ReplaceStmtWithBlock(callStmt, newBody);
+  }
+}
+
+void InlineTransformer::GenReturnLabel(BlockNode &newBody, uint32 inlinedTimes) {
+  // For caller: a = foo() ==>
+  //             a = foo(), label x.
+  if (callStmt.GetNext() != nullptr && callStmt.GetNext()->GetOpCode() == OP_label) {
+    // if the next stmt is a label, just reuse it
+    LabelNode *nextLabel = static_cast<LabelNode*>(callStmt.GetNext());
+    returnLabelIdx = nextLabel->GetLabelIdx();
+  } else {
+    returnLabelIdx = CreateReturnLabel(inlinedTimes);
+    // record the created label
+    labelStmt = builder.CreateStmtLabel(returnLabelIdx);
+    newBody.AddStatement(labelStmt);
+    if (updateFreq) {
+      caller.GetFuncProfData()->CopyStmtFreq(labelStmt->GetStmtID(), callStmt.GetStmtID());
+    }
+  }
+}
+
+// Should be called before merge function body.
+void RecordCallId(BaseNode &baseNode, std::map<uint32, uint32> &callMeStmtIdMap) {
+  auto op = baseNode.GetOpCode();
+  if (op == OP_call || op == OP_callassigned) {
+    auto &callNode = static_cast<CallNode&>(baseNode);
+    (void)callMeStmtIdMap.emplace(callNode.GetMeStmtID(), callNode.GetStmtID());
+    return;
+  }
+  if (baseNode.GetOpCode() == OP_block) {
+    BlockNode &blk = static_cast<BlockNode&>(baseNode);
+    for (auto &stmt : blk.GetStmtNodes()) {
+      RecordCallId(stmt, callMeStmtIdMap);
+    }
+  } else if (baseNode.GetOpCode() == OP_doloop) {
+    BlockNode *blk = static_cast<DoloopNode&>(baseNode).GetDoBody();
+    RecordCallId(*blk, callMeStmtIdMap);
+  } else if (baseNode.GetOpCode() == OP_foreachelem) {
+    BlockNode *blk = static_cast<ForeachelemNode&>(baseNode).GetLoopBody();
+    RecordCallId(*blk, callMeStmtIdMap);
+  } else if (baseNode.GetOpCode() == OP_dowhile || baseNode.GetOpCode() == OP_while) {
+    BlockNode *blk = static_cast<WhileStmtNode&>(baseNode).GetBody();
+    RecordCallId(*blk, callMeStmtIdMap);
+  } else if (baseNode.GetOpCode() == OP_if) {
+    BlockNode *blk = static_cast<IfStmtNode&>(baseNode).GetThenPart();
+    RecordCallId(*blk, callMeStmtIdMap);
+    blk = static_cast<IfStmtNode&>(baseNode).GetElsePart();
+    if (blk != nullptr) {
+      RecordCallId(*blk, callMeStmtIdMap);
+    }
+  }
+}
+
+// Inline CALLEE into CALLER.
+bool InlineTransformer::PerformInline(std::vector<CallInfo*> *newCallInfo) {
+  if (callee.IsEmpty()) {
+    enclosingBlk.RemoveStmt(&callStmt);
+    return false;
+  }
+  auto *calleeNode = cg->GetCGNode(&callee);
+  CHECK_NULL_FATAL(calleeNode);
+  // Record stmt right before and after the callStmt.
+  StmtNode *stmtBeforeCall = callStmt.GetPrev();
+  StmtNode *stmtAfterCall = callStmt.GetNext();
+  // Step 0: See if CALLEE have been inlined to CALLER once.
+  uint32 inlinedTimes = calleeNode->GetInlinedTimes();
+  // If the callee has local static variables, We convert local pu-static symbols to global file-static symbol to avoid
+  // multiple definition for these static symbols
+  ConvertPStaticToFStatic(callee);
+  // Step 1: Clone CALLEE's body.
+  // Record callStmtId mapping from callee orig body to callee cloned body for merging inline summary
+  CallStmtIdMap mapWrapper;
+  if (stage == kGreedyInline) {
+    BlockCallBackMgr::AddCallBack(RecordCallStmtIdMap, &mapWrapper);
+  }
+  const std::map<uint32, uint32> &callIdMap = mapWrapper.callIdMap;
+  BlockNode *newBody = GetClonedCalleeBody();
+  CHECK_NULL_FATAL(newBody);
+  if (stage == kGreedyInline) {
+    BlockCallBackMgr::RemoveCallBack(RecordCallStmtIdMap);
+  }
+
+  // Step 2: Rename symbols, labels, pregs
+  uint32 stIdxOff = RenameSymbols(inlinedTimes);
+  uint32 labIdxOff = RenameLabels(inlinedTimes);
+  std::unordered_map<PregIdx, PregIdx> pregOld2New;
+  uint32 regIdxOff = RenamePregs(pregOld2New);
+  // Step 3: Replace symbols, labels, pregs
+  // Callee has no pu-static symbols now, so we only use stIdxOff to update stIdx, set oldStIdx2New nullptr
+  ReplaceSymbols(newBody, stIdxOff, nullptr);
+  ReplaceLabels(*newBody, labIdxOff);
+  ReplacePregs(newBody, pregOld2New);
+  // Step 4: Null check 'this' and assign actuals to formals.
+  AssignActualsToFormals(*newBody, stIdxOff, regIdxOff);
+  // Step 5: Insert the callee'return jump dest label.
+  GenReturnLabel(*newBody, inlinedTimes);
+  // Step 6: Handle return values.
+  HandleReturn(*newBody);
+  // Step 7: Replace the call-stmt with new CALLEE'body. And do some update work.
+  ReplaceCalleeBody(enclosingBlk, *newBody);
+  // replace the enclosingBlk of callsite in newbody with the enclosingBlk of current callStmt.
+  UpdateEnclosingBlock(*newBody);
+  if (stage == kGreedyInline) {
+    // Create new edges
+    CollectNewCallInfo(newBody, newCallInfo);
+    // and delete the inlined edge.
+    auto *callerNode = cg->GetCGNode(&caller);
+    CHECK_NULL_FATAL(callerNode);
+    callerNode->RemoveCallsite(callStmt.GetStmtID());
+  }
+
+  // Step 8: Update inlined_times.
+  calleeNode->IncreaseInlinedTimes();
+  // Step 9: After inlining, if there exists nested try-catch block, flatten them all.
+  HandleTryBlock(stmtBeforeCall, stmtAfterCall);
+  // Step 10: Merge inline summary
+  if (stage == kGreedyInline) {
+    MergeInlineSummary(caller, callee, callStmt, callIdMap);
+  }
+  // Step 11: Merge other attributes
+  if (Options::stackProtectorStrong) {
+    if (callee.GetMayWriteToAddrofStack()) {
+      caller.SetMayWriteToAddrofStack();
+    }
+  }
+  return true;
+}
+
+void InlineTransformer::CollectNewCallInfo(BaseNode *node, std::vector<CallInfo*> *newCallInfo) const {
+  if (node == nullptr) {
+    return;
+  }
+  if (node->GetOpCode() == OP_block) {
+    auto *block = static_cast<BlockNode*>(node);
+    for (auto &stmt : block->GetStmtNodes()) {
+      CollectNewCallInfo(&stmt, newCallInfo);
+    }
+  } else if (node->GetOpCode() == OP_callassigned || node->GetOpCode() == OP_call) {
+    CallNode *callNode = static_cast<CallNode*>(node);
+    if (callNode != nullptr) {
+      MIRFunction *newCallee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+      CGNode *cgCallee = cg->GetCGNode(newCallee);
+      CGNode *cgCaller = cg->GetCGNode(&caller);
+      auto *callInfo = cg->AddCallsite(kCallTypeCall, *cgCaller, *cgCallee, *callNode);
+      if (newCallInfo != nullptr) {
+        newCallInfo->push_back(callInfo);
+      }
+      return;
+    }
+  }
+  for (size_t i = 0; i < node->NumOpnds(); ++i) {
+    CollectNewCallInfo(node->Opnd(i), newCallInfo);
+  }
+}
+
+void InlineTransformer::UpdateEnclosingBlock(BlockNode &body) const {
+  for (StmtNode &stmt : body.GetStmtNodes()) {
+    CallNode *callNode = safe_cast<CallNode>(stmt);
+    if (callNode == nullptr) {
+      continue;
+    }
+    callNode->SetEnclosingBlock(callStmt.GetEnclosingBlock());
+  }
+}
+
+void InlineTransformer::HandleTryBlock(StmtNode *stmtBeforeCall, StmtNode *stmtAfterCall) {
+  // Step 9.1 Find whether there is a javatry before callStmt.
+  bool hasOuterTry = false;
+  TryNode *outerTry = nullptr;
+  StmtNode *outerEndTry = nullptr;
+  for (StmtNode *stmt = stmtBeforeCall; stmt != nullptr; stmt = stmt->GetPrev()) {
+    if (stmt->op == OP_endtry) {
+      break;
+    }
+    if (stmt->op == OP_try) {
+      hasOuterTry = true;
+      outerTry = static_cast<TryNode*>(stmt);
+      break;
+    }
+  }
+  if (!hasOuterTry) {
+    return;
+  }
+  for (StmtNode *stmt = stmtAfterCall; stmt != nullptr; stmt = stmt->GetNext()) {
+    if (stmt->op == OP_endtry) {
+      outerEndTry = stmt;
+      break;
+    }
+    if (stmt->op == OP_try) {
+      ASSERT(false, "Impossible, caller: [%s] callee: [%s]", caller.GetName().c_str(), callee.GetName().c_str());
+      break;
+    }
+  }
+  ASSERT(outerTry != nullptr, "Impossible, caller: [%s] callee: [%s]", caller.GetName().c_str(),
+         callee.GetName().c_str());
+  ASSERT(outerEndTry != nullptr, "Impossible, caller: [%s] callee: [%s]", caller.GetName().c_str(),
+         callee.GetName().c_str());
+
+  // Step 9.2 We have found outerTry and outerEndTry node, resolve the nested try-catch blocks between them.
+  bool hasInnerTry = ResolveNestedTryBlock(*caller.GetBody(), *outerTry, outerEndTry);
+  if (hasOuterTry && hasInnerTry) {
+    if (dumpDetail) {
+      LogInfo::MapleLogger() << "[NESTED_TRY_CATCH]" << callee.GetName() << " to " << caller.GetName() << '\n';
+    }
+  }
+}
+
+bool InlineTransformer::ResolveNestedTryBlock(BlockNode &body, TryNode &outerTryNode,
+                                              const StmtNode *outerEndTryNode) const {
+  StmtNode *stmt = outerTryNode.GetNext();
+  StmtNode *next = nullptr;
+  bool changed = false;
+  while (stmt != outerEndTryNode) {
+    next = stmt->GetNext();
+    switch (stmt->op) {
+      case OP_try: {
+        // Find previous meaningful stmt.
+        StmtNode *last = stmt->GetPrev();
+        while (last->op == OP_comment || last->op == OP_label) {
+          last = last->GetPrev();
+        }
+        ASSERT(last->op != OP_endtry, "Impossible");
+        ASSERT(last->op != OP_try, "Impossible");
+        StmtNode *newEnd = theMIRModule->CurFuncCodeMemPool()->New<StmtNode>(OP_endtry);
+        body.InsertAfter(last, newEnd);
+        TryNode *tryNode = static_cast<TryNode*>(stmt);
+        tryNode->OffsetsInsert(tryNode->GetOffsetsEnd(), outerTryNode.GetOffsetsBegin(), outerTryNode.GetOffsetsEnd());
+        changed = true;
+        break;
+      }
+      case OP_endtry: {
+        // Find next meaningful stmt.
+        StmtNode *first = stmt->GetNext();
+        while (first->op == OP_comment || first->op == OP_label) {
+          first = first->GetNext();
+        }
+        ASSERT(first != outerEndTryNode, "Impossible");
+        next = first->GetNext();
+        if (first->op == OP_try) {
+          // In this case, there are no meaningful statements between last endtry and the next try,
+          // we just solve the trynode and move the cursor to the statement right after the trynode.
+          TryNode *tryNode = static_cast<TryNode*>(first);
+          tryNode->OffsetsInsert(tryNode->GetOffsetsEnd(), outerTryNode.GetOffsetsBegin(),
+                                 outerTryNode.GetOffsetsEnd());
+          changed = true;
+          break;
+        } else {
+          TryNode *node = outerTryNode.CloneTree(theMIRModule->GetCurFuncCodeMPAllocator());
+          CHECK_FATAL(node != nullptr, "Impossible");
+          body.InsertBefore(first, node);
+          changed = true;
+          break;
+        }
+      }
+      default: {
+        break;
+      }
+    }
+    stmt = next;
+  }
+  return changed;
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/java_eh_lower.cpp b/src/mapleall/mpl2mpl/src/java_eh_lower.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..744cfdaf6ac6cc4ecaf8b2c05aec7f0a59d2490d
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/java_eh_lower.cpp
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_eh_lower.h"
+#include "mir_function.h"
+#include "mir_builder.h"
+#include "global_tables.h"
+#include "option.h"
+
+namespace {
+const std::string strDivOpnd = "__div_opnd1";
+const std::string strDivRes = "__div_res";
+const std::string strMCCThrowArrayIndexOutOfBoundsException = "MCC_ThrowArrayIndexOutOfBoundsException";
+const std::string strMCCThrowNullPointerException = "MCC_ThrowNullPointerException";
+} // namespace
+
+// Do exception handling runtime insertion of runtime function call
+// scan the entire function body once to lookup expression that
+// could potentially raise exceptions such as division,
+// for example:
+// if we have x = a/b
+// and we don't know the value of b during compile time
+// then we will insert the test for exception:
+// if b == 0,
+//  call MCC_ThrowArithmeticException()
+// x = a/b
+namespace maple {
+BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode &expr, BlockNode &blknode) {
+  PrimType ptype = expr.GetPrimType();
+  MIRBuilder *mirBuilder = GetMIRModule().GetMIRBuilder();
+  MIRFunction *func = GetMIRModule().CurFunction();
+  if (!IsPrimitiveInteger(ptype)) {
+    return &expr;
+  }
+
+  // Store divopnd to a tmp st if not a leaf node.
+  BaseNode *divOpnd = expr.Opnd(1);
+  if (!divOpnd->IsLeaf()) {
+    std::string opnd1name(strDivOpnd);
+    opnd1name.append(std::to_string(divSTIndex));
+    if (useRegTmp) {
+      PregIdx pregIdx = func->GetPregTab()->CreatePreg(ptype);
+      RegassignNode *regassDivnode = mirBuilder->CreateStmtRegassign(ptype, pregIdx, divOpnd);
+      blknode.AddStatement(regassDivnode);
+      divOpnd = mirBuilder->CreateExprRegread(ptype, pregIdx);
+    } else {
+      MIRSymbol *divOpndSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), opnd1name, kStVar, kScAuto,
+                                                          GetMIRModule().CurFunction(), kScopeLocal);
+      DassignNode *dssDivNode = mirBuilder->CreateStmtDassign(*divOpndSymbol, 0, divOpnd);
+      blknode.AddStatement(dssDivNode);
+      divOpnd = mirBuilder->CreateExprDread(*divOpndSymbol);
+    }
+    expr.SetBOpnd(divOpnd, 1);
+  }
+  BaseNode *retExprNode = nullptr;
+  StmtNode *divStmt = nullptr;
+  if (useRegTmp) {
+    PregIdx resPregIdx = func->GetPregTab()->CreatePreg(ptype);
+    divStmt = mirBuilder->CreateStmtRegassign(ptype, resPregIdx, &expr);
+    retExprNode = GetMIRModule().GetMIRBuilder()->CreateExprRegread(ptype, resPregIdx);
+  } else {
+    std::string resName(strDivRes);
+    resName.append(std::to_string(divSTIndex++));
+    MIRSymbol *divResSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), resName, kStVar, kScAuto,
+                                                       GetMIRModule().CurFunction(), kScopeLocal);
+    // Put expr result to dssnode.
+    divStmt = mirBuilder->CreateStmtDassign(*divResSymbol, 0, &expr);
+    retExprNode = GetMIRModule().GetMIRBuilder()->CreateExprDread(*divResSymbol, 0);
+  }
+  // Check if the second operand of the div expression is 0.
+  // Inser if statement for high level ir.
+  CompareNode *cmpNode = mirBuilder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetInt32(),
+                                                       *GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(ptype)),
+                                                       divOpnd, mirBuilder->CreateIntConst(0, ptype));
+  IfStmtNode *ifStmtNode = mirBuilder->CreateStmtIf(cmpNode);
+  blknode.AddStatement(ifStmtNode);
+  // Call the MCC_ThrowArithmeticException() that will never return.
+  MapleVector<BaseNode*> args(GetMIRModule().GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
+  IntrinsiccallNode *intrinCallNode = mirBuilder->CreateStmtIntrinsicCall(INTRN_JAVA_THROW_ARITHMETIC, args);
+  ifStmtNode->GetThenPart()->AddStatement(intrinCallNode);
+  blknode.AddStatement(divStmt);
+  // Make dread from the divresst and return it as new expression for this function.
+  return retExprNode;
+}
+
+BaseNode *JavaEHLowerer::DoLowerExpr(BaseNode &expr, BlockNode &curblk) {
+  for (size_t i = 0; i < expr.NumOpnds(); ++i) {
+    expr.SetOpnd(DoLowerExpr(*(expr.Opnd(i)), curblk), i);
+  }
+  switch (expr.GetOpCode()) {
+    case OP_div: {
+      return DoLowerDiv(static_cast<BinaryNode&>(expr), curblk);
+    }
+    case OP_rem: {
+      return DoLowerRem(static_cast<BinaryNode&>(expr), curblk);
+    }
+    default:
+      return &expr;
+  }
+}
+
+void JavaEHLowerer::DoLowerBoundaryCheck(IntrinsiccallNode &intrincall, BlockNode &newblk) {
+  const size_t intrincallNopndSize = intrincall.GetNopndSize();
+  CHECK_FATAL(intrincallNopndSize > 0, "null ptr check");
+  CondGotoNode *brFalseStmt = GetMIRModule().CurFuncCodeMemPool()->New<CondGotoNode>(OP_brfalse);
+  brFalseStmt->SetOpnd(DoLowerExpr(*(intrincall.GetNopndAt(0)), newblk), 0);
+  brFalseStmt->SetSrcPos(intrincall.GetSrcPos());
+  LabelIdx lbidx = GetMIRModule().CurFunction()->GetLabelTab()->CreateLabel();
+  GetMIRModule().CurFunction()->GetLabelTab()->AddToStringLabelMap(lbidx);
+  brFalseStmt->SetOffset(lbidx);
+  newblk.AddStatement(brFalseStmt);
+  LabelNode *labStmt = GetMIRModule().CurFuncCodeMemPool()->New<LabelNode>();
+  labStmt->SetLabelIdx(lbidx);
+  MIRFunction *func =
+    GetMIRModule().GetMIRBuilder()->GetOrCreateFunction(strMCCThrowArrayIndexOutOfBoundsException, TyIdx(PTY_void));
+  MapleVector<BaseNode*> args(GetMIRModule().GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
+  CallNode *callStmt = GetMIRModule().GetMIRBuilder()->CreateStmtCall(func->GetPuidx(), args);
+  newblk.AddStatement(callStmt);
+  newblk.AddStatement(labStmt);
+}
+
+BlockNode *JavaEHLowerer::DoLowerBlock(BlockNode &block) {
+  BlockNode *newBlock = GetMIRModule().CurFuncCodeMemPool()->New<BlockNode>();
+  StmtNode *nextStmt = block.GetFirst();
+  if (nextStmt == nullptr) {
+    return newBlock;
+  }
+
+  do {
+    StmtNode *stmt = nextStmt;
+    nextStmt = stmt->GetNext();
+    stmt->SetNext(nullptr);
+
+    switch (stmt->GetOpCode()) {
+      case OP_switch: {
+        auto *switchNode = static_cast<SwitchNode*>(stmt);
+        switchNode->SetSwitchOpnd(DoLowerExpr(*(switchNode->GetSwitchOpnd()), *newBlock));
+        newBlock->AddStatement(switchNode);
+        break;
+      }
+      case OP_if: {
+        auto *ifStmtNode = static_cast<IfStmtNode*>(stmt);
+        BlockNode *thenPart = ifStmtNode->GetThenPart();
+        BlockNode *elsePart = ifStmtNode->GetElsePart();
+        ASSERT(ifStmtNode->Opnd() != nullptr, "null ptr check!");
+        ifStmtNode->SetOpnd(DoLowerExpr(*(ifStmtNode->Opnd()), *newBlock), 0);
+        ifStmtNode->SetThenPart(DoLowerBlock(*thenPart));
+        if (elsePart != nullptr) {
+          ifStmtNode->SetElsePart(DoLowerBlock(*elsePart));
+        }
+        newBlock->AddStatement(ifStmtNode);
+        break;
+      }
+      case OP_while:
+      case OP_dowhile: {
+        auto *whileStmtNode = static_cast<WhileStmtNode*>(stmt);
+        BaseNode *testOpnd = whileStmtNode->Opnd(0);
+        whileStmtNode->SetOpnd(DoLowerExpr(*testOpnd, *newBlock), 0);
+        whileStmtNode->SetBody(DoLowerBlock(*(whileStmtNode->GetBody())));
+        newBlock->AddStatement(whileStmtNode);
+        break;
+      }
+      case OP_doloop: {
+        auto *doLoopNode = static_cast<DoloopNode*>(stmt);
+        doLoopNode->SetStartExpr(DoLowerExpr(*(doLoopNode->GetStartExpr()), *newBlock));
+        doLoopNode->SetContExpr(DoLowerExpr(*(doLoopNode->GetCondExpr()), *newBlock));
+        doLoopNode->SetIncrExpr(DoLowerExpr(*(doLoopNode->GetIncrExpr()), *newBlock));
+        doLoopNode->SetDoBody(DoLowerBlock(*(doLoopNode->GetDoBody())));
+        newBlock->AddStatement(doLoopNode);
+        break;
+      }
+      case OP_block: {
+        auto *tmp = DoLowerBlock(*(static_cast<BlockNode*>(stmt)));
+        CHECK_FATAL(tmp != nullptr, "null ptr check");
+        newBlock->AddStatement(tmp);
+        break;
+      }
+      case OP_throw: {
+        auto *tstmt = static_cast<UnaryStmtNode*>(stmt);
+        BaseNode *opnd0 = DoLowerExpr(*(tstmt->Opnd(0)), *newBlock);
+        if (opnd0->GetOpCode() == OP_constval) {
+          CHECK_FATAL(IsPrimitiveInteger(opnd0->GetPrimType()), "must be integer or something wrong");
+          auto *intConst = safe_cast<MIRIntConst>(static_cast<ConstvalNode*>(opnd0)->GetConstVal());
+          CHECK_FATAL(intConst->IsZero(), "can only be zero");
+          MIRFunction *func =
+            GetMIRModule().GetMIRBuilder()->GetOrCreateFunction(strMCCThrowNullPointerException, TyIdx(PTY_void));
+          func->SetNoReturn();
+          MapleVector<BaseNode*> args(GetMIRModule().GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
+          CallNode *callStmt = GetMIRModule().GetMIRBuilder()->CreateStmtCall(func->GetPuidx(), args);
+          newBlock->AddStatement(callStmt);
+        } else {
+          tstmt->SetOpnd(opnd0, 0);
+          newBlock->AddStatement(tstmt);
+        }
+        break;
+      }
+      case OP_intrinsiccall: {
+        auto *intrinCall = static_cast<IntrinsiccallNode*>(stmt);
+        if (intrinCall->GetIntrinsic() == INTRN_MPL_BOUNDARY_CHECK) {
+          DoLowerBoundaryCheck(*intrinCall, *newBlock);
+          break;
+        }
+        // fallthrough;
+      }
+      [[clang::fallthrough]];
+      default: {
+        for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+          stmt->SetOpnd(DoLowerExpr(*(stmt->Opnd(i)), *newBlock), i);
+        }
+        newBlock->AddStatement(stmt);
+        break;
+      }
+    }
+  } while (nextStmt != nullptr);
+  return newBlock;
+}
+
+void JavaEHLowerer::ProcessFunc(MIRFunction *func) {
+  GetMIRModule().SetCurFunction(func);
+  if (func->GetBody() == nullptr) {
+    return;
+  }
+  divSTIndex = 0;  // Init it to 0.
+  BlockNode *newBody = DoLowerBlock(*(func->GetBody()));
+  func->SetBody(newBody);
+}
+
+bool M2MJavaEHLowerer::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(JavaEHLowerer, m);
+  return true;
+}
+
+void M2MJavaEHLowerer::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/java_intrn_lowering.cpp b/src/mapleall/mpl2mpl/src/java_intrn_lowering.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..73fe8eb89e6d264babc40aa7cdf11788fd903498
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/java_intrn_lowering.cpp
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_intrn_lowering.h"
+#include <fstream>
+#include <algorithm>
+#include <cstdio>
+
+namespace {
+constexpr char kMplSuffix[] = ".mpl";
+constexpr char kClinvocation[] = ".clinvocation";
+constexpr char kJavaLangClassloader[] = "Ljava_2Flang_2FClassLoader_3B";
+constexpr char kFuncClassForname1[] =
+    "Ljava_2Flang_2FClass_3B_7CforName_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FClass_3B";
+constexpr char kFuncClassForname3[] =
+    "Ljava_2Flang_2FClass_3B_7CforName_7C_28Ljava_2Flang_2FString_3BZLjava_2Flang_2FClassLoader_3B_29Ljava_2Flang_"
+    "2FClass_3B";
+constexpr char kFuncGetCurrentCl[] = "MCC_GetCurrentClassLoader";
+constexpr char kRetvarCurrentClassloader[] = "retvar_current_classloader";
+} // namespace
+
+// JavaIntrnLowering lowers several kinds of intrinsics:
+// 1. INTRN_JAVA_MERGE
+//    Check if INTRN_JAVA_MERGE is legal:
+//    if yes, turn it into a Retype or CvtType; if no, assert
+// 2. INTRN_JAVA_FILL_NEW_ARRAY
+//    Turn it into a jarray malloc and jarray element-wise assignment
+//
+// JavaIntrnLowering also performs the following optimizations:
+// 1. Turn single-parameter Class.forName call into three-parameter
+//    Class.forName call, where the third-parameter points to the
+//    current class loader being used.
+namespace maple {
+inline bool IsConstvalZero(BaseNode &node) {
+  return (node.GetOpCode() == OP_constval) && (static_cast<ConstvalNode&>(node).GetConstVal()->IsZero());
+}
+
+JavaIntrnLowering::JavaIntrnLowering(MIRModule &mod, KlassHierarchy *kh, bool dump)
+    : FuncOptimizeImpl(mod, kh, dump) {
+  InitTypes();
+  InitFuncs();
+  InitLists();
+}
+
+void JavaIntrnLowering::InitLists() {
+  if (Options::dumpClassLoaderInvocation || !Options::classLoaderInvocationList.empty()) {
+    LoadClassLoaderInvocation(Options::classLoaderInvocationList);
+  }
+  if (Options::dumpClassLoaderInvocation) {
+    // Remove any existing output file.
+    const std::string &mplName = GetMIRModule().GetFileName();
+    CHECK_FATAL(mplName.rfind(kMplSuffix) != std::string::npos, "File name %s does not contain .mpl", mplName.c_str());
+    std::string prefix = mplName.substr(0, mplName.rfind(kMplSuffix));
+    outFileName = prefix + kClinvocation;
+    std::remove(outFileName.c_str());
+  }
+}
+
+void JavaIntrnLowering::InitTypes() {
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(kJavaLangClassloader);
+  MIRType *classLoaderType =
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(gStrIdx));
+  CHECK_FATAL(classLoaderType != nullptr, "Ljava_2Flang_2FClassLoader_3B type can not be null");
+  classLoaderPointerToType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*classLoaderType, PTY_ref);
+}
+
+void JavaIntrnLowering::InitFuncs() {
+  classForName1Func = builder->GetFunctionFromName(kFuncClassForname1);
+  CHECK_FATAL(classForName1Func != nullptr, "classForName1Func is null in JavaIntrnLowering::InitFuncs");
+  classForName3Func = builder->GetFunctionFromName(kFuncClassForname3);
+  CHECK_FATAL(classForName3Func != nullptr, "classForName3Func is null in JavaIntrnLowering::InitFuncs");
+  // MCC_GetCurrentClassLoader.
+  getCurrentClassLoaderFunc = builder->GetFunctionFromName(kFuncGetCurrentCl);
+  if (!getCurrentClassLoaderFunc) {
+    ArgVector clArgs(GetMIRModule().GetMPAllocator().Adapter());
+    MIRType *refTy = GlobalTables::GetTypeTable().GetRef();
+    clArgs.push_back(ArgPair("caller", refTy));
+    getCurrentClassLoaderFunc = builder->CreateFunction(kFuncGetCurrentCl, *refTy, clArgs);
+    CHECK_FATAL(getCurrentClassLoaderFunc != nullptr,
+                "getCurrentClassLoaderFunc is null in JavaIntrnLowering::InitFuncs");
+  }
+}
+
+void JavaIntrnLowering::ProcessStmt(StmtNode &stmt) {
+  Opcode opcode = stmt.GetOpCode();
+  switch (opcode) {
+    case OP_dassign:
+    case OP_regassign: {
+      BaseNode *rhs = nullptr;
+      if (opcode == OP_dassign) {
+        auto &dassign = static_cast<DassignNode&>(stmt);
+        rhs = dassign.GetRHS();
+      } else {
+        auto &regassign = static_cast<RegassignNode&>(stmt);
+        rhs = regassign.GetRHS();
+      }
+      if (rhs != nullptr && rhs->GetOpCode() == OP_intrinsicop) {
+        auto *intrinNode = static_cast<IntrinsicopNode*>(rhs);
+        if (intrinNode->GetIntrinsic() == INTRN_JAVA_MERGE) {
+          ProcessJavaIntrnMerge(stmt, *intrinNode);
+        }
+      }
+      break;
+    }
+    case OP_callassigned: {
+      auto &call = static_cast<CallNode&>(stmt);
+      // Currently it's only for classloader.
+      ProcessForNameClassLoader(call);
+      break;
+    }
+    case OP_intrinsiccallwithtypeassigned: {
+      IntrinsiccallNode &intrinCall = static_cast<IntrinsiccallNode&>(stmt);
+      if (intrinCall.GetIntrinsic() == INTRN_JAVA_FILL_NEW_ARRAY) {
+        ProcessJavaIntrnFillNewArray(intrinCall);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void JavaIntrnLowering::CheckClassLoaderInvocation(const CallNode &callNode) const {
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode.GetPUIdx());
+  if (clInterfaceSet.find(callee->GetName()) != clInterfaceSet.end()) {
+    auto range = clInvocationMap.equal_range(currFunc->GetName());
+    for (auto i = range.first; i != range.second; ++i) {
+      const std::string &val = i->second;
+      if (val == callee->GetName()) {
+        return;
+      }
+    }
+    CHECK_FATAL(false,
+                "Check ClassLoader Invocation, failed. \
+                 Please copy \"%s,%s\" into %s, and submit it to review. mpl file:%s",
+                namemangler::DecodeName(currFunc->GetName()).c_str(),
+                namemangler::DecodeName(callee->GetName()).c_str(), Options::classLoaderInvocationList.c_str(),
+                GetMIRModule().GetFileName().c_str());
+  }
+}
+
+void JavaIntrnLowering::DumpClassLoaderInvocation(const CallNode &callNode) {
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode.GetPUIdx());
+  if (clInterfaceSet.find(callee->GetName()) != clInterfaceSet.end()) {
+    builder->GlobalLock();
+    std::ofstream outfile;
+    outfile.open(outFileName, std::ios::out | std::ios::app);
+    CHECK_FATAL(!outfile.fail(), "Dump ClassLoader Invocation, open file failed.");
+    outfile << namemangler::DecodeName(currFunc->GetName()) << "," << namemangler::DecodeName(callee->GetName())
+            << "\n";
+    outfile.close();
+    LogInfo::MapleLogger() << "Dump ClassLoader Invocation, \"" << namemangler::DecodeName(currFunc->GetName()) << ","
+                           << namemangler::DecodeName(callee->GetName()) << "\", " << GetMIRModule().GetFileName()
+                           << "\n";
+    builder->GlobalUnlock();
+  }
+}
+
+void JavaIntrnLowering::LoadClassLoaderInvocation(const std::string &list) {
+  std::ifstream infile;
+  infile.open(list);
+  CHECK_FATAL(!infile.fail(), "Load ClassLoader Invocation, open file %s failed.", list.c_str());
+
+  bool reachInvocation = false;
+  std::string line;
+  // Load ClassLoader Interface&Invocation Config.
+  // There're two parts: interfaces and invocations in the list.
+  // Firstly loading interfaces, then loading invocations.
+  while (getline(infile, line)) {
+    if (line.empty()) {
+      continue;  // Ignore empty line.
+    }
+    if (line.front() == '#') {
+      continue;  // Ignore comment line.
+    }
+    // Check if reach invocation parts by searching ','
+    if (!reachInvocation && (line.find(',') != std::string::npos)) {
+      reachInvocation = true;
+    }
+    if (!reachInvocation) {
+      // Load interface.
+      (void)clInterfaceSet.insert(namemangler::EncodeName(line));
+    } else {
+      // Load invocation, which has 2 elements seperated by ','.
+      std::stringstream ss(line);
+      std::string caller;
+      std::string callee;
+      if (!getline(ss, caller, ',')) {
+        CHECK_FATAL(false, "Load ClassLoader Invocation, wrong format.");
+      }
+      if (!getline(ss, callee, ',')) {
+        CHECK_FATAL(false, "Load ClassLoader Invocation, wrong format.");
+      }
+      (void)clInvocationMap.insert(make_pair(namemangler::EncodeName(caller), namemangler::EncodeName(callee)));
+    }
+  }
+  infile.close();
+}
+
+void JavaIntrnLowering::ProcessForNameClassLoader(CallNode &callNode) {
+  if (callNode.GetPUIdx() != classForName1Func->GetPuidx()) {
+    return;
+  }
+  BaseNode *arg = nullptr;
+  if (currFunc->IsStatic()) {
+    // It's a static function,
+    // pass caller functions's classinfo directly.
+    std::string callerName = CLASSINFO_PREFIX_STR;
+    callerName += currFunc->GetBaseClassName();
+    builder->GlobalLock();
+    MIRSymbol *callerClassinfoSym =
+        GlobalTables::GetGsymTable().GetSymbolFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(callerName));
+    if (callerClassinfoSym == nullptr) {
+      callerClassinfoSym = builder->CreateGlobalDecl(callerName, *GlobalTables::GetTypeTable().GetPtr(), kScExtern);
+    }
+    builder->GlobalUnlock();
+    arg = builder->CreateExprAddrof(0, *callerClassinfoSym);
+  } else {
+    // It's an instance function,
+    // pass caller function's this pointer
+    CHECK_FATAL(currFunc->GetFormalCount() > 0, "index out of range in JavaIntrnLowering::ProcessForNameClassLoader");
+    MIRSymbol *formalst = currFunc->GetFormal(0);
+    if (formalst->GetSKind() != kStPreg) {
+      arg = builder->CreateExprDread(*formalst);
+    } else {
+      arg = builder->CreateExprRegread(formalst->GetType()->GetPrimType(), currFunc->GetPregTab()->GetPregIdxFromPregno(
+          formalst->GetValue().preg->GetPregNo()));
+    }
+  }
+  MIRSymbol *currentCL = builder->GetOrCreateLocalDecl(kRetvarCurrentClassloader, *classLoaderPointerToType);
+  MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.push_back(arg);
+  CallNode *clCall = builder->CreateStmtCallAssigned(getCurrentClassLoaderFunc->GetPuidx(), args, currentCL);
+  currFunc->GetBody()->InsertBefore(&callNode, clCall);
+  // Class.forName(jstring name) ==>
+  // Class.forName(jstring name, jboolean 1, jobject current_cl)
+  // Ensure initialized is true.
+  callNode.GetNopnd().push_back(builder->GetConstUInt1(true));
+  // Classloader.
+  callNode.GetNopnd().push_back(builder->CreateExprDread(*currentCL));
+  callNode.numOpnds = callNode.GetNopndSize();
+  callNode.SetPUIdx(classForName3Func->GetPuidx());
+  if (!Options::dumpClassLoaderInvocation && !Options::classLoaderInvocationList.empty()) {
+    CheckClassLoaderInvocation(callNode);
+  }
+  if (Options::dumpClassLoaderInvocation) {
+    DumpClassLoaderInvocation(callNode);
+  }
+}
+
+void JavaIntrnLowering::ProcessJavaIntrnMerge(StmtNode &assignNode, const IntrinsicopNode &intrinNode) {
+  CHECK_FATAL(intrinNode.GetNumOpnds() == 1, "invalid JAVA_MERGE intrinsic node");
+  PrimType destType;
+  DassignNode *dassign = nullptr;
+  RegassignNode *regassign = nullptr;
+  if (assignNode.GetOpCode() == OP_dassign) {
+    dassign = static_cast<DassignNode*>(&assignNode);
+    MIRSymbol *dest = currFunc->GetLocalOrGlobalSymbol(dassign->GetStIdx());
+    ASSERT_NOT_NULL(dest);
+    ASSERT_NOT_NULL(dest->GetType());
+    destType = dest->GetType()->GetPrimType();
+  } else {
+    regassign = static_cast<RegassignNode*>(&assignNode);
+    destType = regassign->GetPrimType();
+  }
+  BaseNode *resNode = intrinNode.Opnd(0);
+  CHECK_FATAL(resNode != nullptr, "null ptr check");
+  PrimType srcType = resNode->GetPrimType();
+  if (destType != srcType) {
+    resNode = JavaIntrnMergeToCvtType(destType, srcType, resNode);
+  }
+  if (assignNode.GetOpCode() == OP_dassign) {
+    CHECK_FATAL(dassign != nullptr, "null ptr check");
+    dassign->SetRHS(resNode);
+  } else {
+    CHECK_FATAL(regassign != nullptr, "null ptr check");
+    regassign->SetRHS(resNode);
+  }
+}
+
+BaseNode *JavaIntrnLowering::JavaIntrnMergeToCvtType(PrimType destType, PrimType srcType, BaseNode *src) {
+  CHECK_FATAL(IsPrimitiveInteger(destType) || IsPrimitiveFloat(destType),
+              "typemerge source type is not a primitive type");
+  CHECK_FATAL(IsPrimitiveInteger(srcType) || IsPrimitiveFloat(srcType),
+              "typemerge destination type is not a primitive type");
+  // src i32, dest f32; src i64, dest f64.
+  bool isPrimitive = IsPrimitiveInteger(srcType) && IsPrimitiveFloat(destType) &&
+      GetPrimTypeBitSize(srcType) <= GetPrimTypeBitSize(destType);
+  if (!(isPrimitive || (IsPrimitiveInteger(srcType) && IsPrimitiveInteger(destType)))) {
+    CHECK_FATAL(false, "Wrong type in typemerge: srcType is %d; destType is %d", srcType, destType);
+  }
+  // src & dest are both of float type.
+  MIRType *toType = GlobalTables::GetTypeTable().GetPrimType(destType);
+  MIRType *fromType = GlobalTables::GetTypeTable().GetPrimType(srcType);
+  if (IsPrimitiveInteger(srcType) && IsPrimitiveFloat(destType)) {
+    if (GetPrimTypeBitSize(srcType) == GetPrimTypeBitSize(destType)) {
+      return builder->CreateExprRetype(*toType, *fromType, src);
+    }
+    return builder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, src);
+  } else if (IsPrimitiveInteger(srcType) && IsPrimitiveInteger(destType)) {
+    if (GetPrimTypeBitSize(srcType) >= GetPrimTypeBitSize(destType)) {
+      if (destType == PTY_u1) {  // e.g., type _Bool.
+        return builder->CreateExprCompare(OP_ne, *toType, *fromType, src, builder->CreateIntConst(0, srcType));
+      }
+      if (GetPrimTypeBitSize(srcType) > GetPrimTypeBitSize(destType)) {
+        return builder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, src);
+      }
+      if (IsSignedInteger(srcType) != IsSignedInteger(destType)) {
+        return builder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, src);
+      }
+      src->SetPrimType(destType);
+      return src;
+    }
+    // Force type cvt here because we currently do not run constant folding
+    // or contanst propagation before CG. We may revisit this decision later.
+    if (GetPrimTypeBitSize(srcType) < GetPrimTypeBitSize(destType)) {
+      return builder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, src);
+    }
+    if (IsConstvalZero(*src)) {
+      return builder->CreateIntConst(0, destType);
+    }
+    CHECK_FATAL(false, "NYI. Don't know what to do");
+  }
+  CHECK_FATAL(false, "NYI. Don't know what to do");
+}
+
+void JavaIntrnLowering::ProcessJavaIntrnFillNewArray(IntrinsiccallNode &intrinCall) {
+  // First create a new array.
+  CHECK_FATAL(intrinCall.GetReturnVec().size() == 1, "INTRN_JAVA_FILL_NEW_ARRAY should have 1 return value");
+  CallReturnPair retPair = intrinCall.GetCallReturnPair(0);
+  bool isReg = retPair.second.IsReg();
+  MIRType *retType = nullptr;
+  if (!isReg) {
+    retType = currFunc->GetLocalOrGlobalSymbol(retPair.first)->GetType();
+  } else {
+    PregIdx pregIdx = retPair.second.GetPregIdx();
+    MIRPreg *mirPreg = currFunc->GetPregTab()->PregFromPregIdx(pregIdx);
+    CHECK_FATAL(mirPreg->GetPrimType() == PTY_ref || mirPreg->GetPrimType() == PTY_ptr,
+                "Dst preg needs to be a pointer or reference type");
+    retType = mirPreg->GetMIRType();
+  }
+  ASSERT_NOT_NULL(retType);
+  CHECK_FATAL(retType->GetKind() == kTypePointer,
+              "Return type of INTRN_JAVA_FILL_NEW_ARRAY should point to a Jarray");
+  auto *arrayType = static_cast<MIRPtrType*>(retType)->GetPointedType();
+  BaseNode *lenNode = builder->CreateIntConst(static_cast<int64>(intrinCall.NumOpnds()), PTY_i32);
+  JarrayMallocNode *newArrayNode = builder->CreateExprJarrayMalloc(OP_gcmallocjarray, *retType, *arrayType, lenNode);
+  // Then fill each array element one by one.
+  BaseNode *addrExpr = nullptr;
+  StmtNode *assignStmt = nullptr;
+  if (!isReg) {
+    MIRSymbol *retSym = currFunc->GetLocalOrGlobalSymbol(retPair.first);
+    assignStmt = builder->CreateStmtDassign(*retSym, retPair.second.GetFieldID(), newArrayNode);
+    currFunc->GetBody()->ReplaceStmt1WithStmt2(&intrinCall, assignStmt);
+    addrExpr = builder->CreateExprDread(*retSym);
+  } else {
+    PregIdx pregIdx = retPair.second.GetPregIdx();
+    MIRPreg *mirPreg = currFunc->GetPregTab()->PregFromPregIdx(pregIdx);
+    assignStmt = builder->CreateStmtRegassign(mirPreg->GetPrimType(), pregIdx, newArrayNode);
+    currFunc->GetBody()->ReplaceStmt1WithStmt2(&intrinCall, assignStmt);
+    addrExpr = builder->CreateExprRegread(mirPreg->GetPrimType(), pregIdx);
+  }
+  assignStmt->SetSrcPos(intrinCall.GetSrcPos());
+  StmtNode *stmt = assignStmt;
+  for (size_t i = 0; i < intrinCall.NumOpnds(); ++i) {
+    ArrayNode *arrayexpr = builder->CreateExprArray(*arrayType, addrExpr,
+                                                    builder->CreateIntConst(static_cast<int64>(i), PTY_i32));
+    arrayexpr->SetBoundsCheck(false);
+    StmtNode *storeStmt = builder->CreateStmtIassign(*retType, 0, arrayexpr, intrinCall.Opnd(i));
+    currFunc->GetBody()->InsertAfter(stmt, storeStmt);
+    stmt = storeStmt;
+  }
+}
+
+bool M2MJavaIntrnLowering::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(JavaIntrnLowering, m);
+  return true;
+}
+
+void M2MJavaIntrnLowering::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/method_replace.cpp b/src/mapleall/mpl2mpl/src/method_replace.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b0385795eddbcaf92cdcc2eecf9907121033e63b
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/method_replace.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "method_replace.h"
+#include <mir_symbol.h>
+
+// Replace some method with new method call, signature and return value not changed
+// def format (caller origCallee newCallee).
+namespace maple {
+void MethodReplace::InsertRecord(const std::string &caller, const std::string &origCallee,
+                                 const std::string &newCallee) {
+  auto callerIt = replaceMethodMap.find(caller);
+  if (callerIt == replaceMethodMap.end()) {
+    replaceMethodMap[caller] = { { origCallee, newCallee } };
+    return;
+  }
+  std::unordered_map<std::string, std::string> &calleeMap = callerIt->second;
+  calleeMap[origCallee] = newCallee;
+}
+
+void MethodReplace::Init() {
+#define ORIFUNC(CALLER, ORIGINAL, NEWFUNC) InsertRecord(#CALLER, #ORIGINAL, #NEWFUNC);
+
+#include "tobe_replaced_funcs.def"
+
+#undef ORIFUNC
+}
+
+void MethodReplace::FindCalleeAndReplace(MIRFunction &callerFunc, StrStrMap &calleeMap) const {
+  // iterate get callassignstmt to original callee, exclude virtual call interface call
+  StmtNode *stmt = callerFunc.GetBody()->GetFirst();
+  while (stmt != nullptr) {
+    Opcode op = stmt->op;
+    if (op != OP_callassigned) {
+      stmt = stmt->GetNext();
+      continue;
+    }
+    CallNode *callNode = static_cast<CallNode*>(stmt);
+    MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+    std::string calleeName = calleeFunc->GetName();
+    auto it = calleeMap.find(calleeName);
+    if (it == calleeMap.end()) {
+      stmt = stmt->GetNext();
+      continue;
+    }
+    std::string &newCalleeName = it->second;
+    MIRFunction *newCalleeFunc = mBuilder.GetOrCreateFunction(newCalleeName, TyIdx(PTY_void));
+    callNode->SetPUIdx(newCalleeFunc->GetPuidx());
+    stmt = stmt->GetNext();
+  }
+}
+
+// iterate callers in ReplaceMethod, find callee and replace
+void MethodReplace::DoMethodReplace() {
+  for (auto it = replaceMethodMap.begin(); it != replaceMethodMap.end(); ++it) {
+    const std::string &callerName = it->first;
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+        GlobalTables::GetStrTable().GetStrIdxFromName(callerName));
+    if (symbol == nullptr || symbol->GetSKind() != kStFunc) {
+      continue;
+    }
+    MIRFunction *callerFunc = symbol->GetValue().mirFunc;
+    if (callerFunc == nullptr || callerFunc->GetBody() == nullptr) {
+      continue;
+    }
+    mirModule->SetCurFunction(callerFunc);
+    FindCalleeAndReplace(*callerFunc, it->second);
+  }
+}
+
+bool M2MMethodReplace::PhaseRun(maple::MIRModule &m) {
+  maple::MIRBuilder builder(&m);
+  MethodReplace methodReplace(&m, GetPhaseMemPool(), builder);
+  methodReplace.Init();
+  methodReplace.DoMethodReplace();
+  return true;
+}
+
+void M2MMethodReplace::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
+
diff --git a/src/mapleall/mpl2mpl/src/module_phase_manager.cpp b/src/mapleall/mpl2mpl/src/module_phase_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..47ad50ad747240ee5bb8fa5f54da579ae21c15d2
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/module_phase_manager.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2019-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "module_phase_manager.h"
+#include "me_phase_manager.h"
+#include "ipa_phase_manager.h"
+#include "ipa_side_effect.h"
+#include "mpl_profdata_parser.h"
+
+#define JAVALANG (mirModule.IsJavaModule())
+#define CLANG (mirModule.IsCModule())
+
+namespace maple {
+void DumpModule(const MIRModule &mod, const std::string phaseName, bool isBefore) {
+  MIRFunction *func = nullptr;
+  if (Options::DumpFunc()) {
+    GStrIdx gStrIdxOfFunc = GlobalTables::GetStrTable().GetStrIdxFromName(Options::dumpFunc);
+    func = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(gStrIdxOfFunc)->GetFunction();
+  }
+  bool dumpPhase = Options::DumpPhase(phaseName);
+  if (Options::dumpBefore && dumpPhase && isBefore) {
+    LogInfo::MapleLogger() << ">>>>> Dump before " << phaseName << " <<<<<\n";
+    if (func != nullptr) {
+      func->Dump(false);
+    } else {
+      mod.Dump();
+    }
+    LogInfo::MapleLogger() << ">>>>> Dump before End <<<<<\n";
+    return;
+  }
+  if ((Options::dumpAfter || dumpPhase) && !isBefore) {
+    LogInfo::MapleLogger() << ">>>>> Dump after " << phaseName << " <<<<<\n";
+    if (func != nullptr) {
+      func->Dump(false);
+    } else {
+      mod.Dump();
+    }
+    LogInfo::MapleLogger() << ">>>>> Dump after End <<<<<\n\n";
+  }
+}
+
+void MEBETopLevelManager::InitFuncDescWithWhiteList(const maple::MIRModule &mod) {
+  for (auto &pair : SideEffect::GetWhiteList()) {
+    auto *funcSymbol =
+        GlobalTables::GetGsymTable().GetSymbolFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(pair.first));
+    MIRFunction *func = nullptr;
+    if (funcSymbol != nullptr && funcSymbol->GetSKind() == kStFunc) {
+      func = mod.GetMIRBuilder()->GetFunctionFromSymbol(*funcSymbol);
+    }
+    if (func == nullptr) {
+      continue;
+    }
+    const FuncDesc &desc = pair.second;
+    func->SetFuncDesc(desc);
+    func->GetFuncDesc().SetConfiged();
+    if (desc.IsPure() || desc.IsConst()) {
+      func->SetAttr(FUNCATTR_pure);
+      func->SetAttr(FUNCATTR_nodefargeffect);
+      func->SetAttr(FUNCATTR_nodefeffect);
+      func->SetAttr(FUNCATTR_nothrow_exception);
+    }
+  }
+}
+
+void MEBETopLevelManager::Run(maple::MIRModule &mod) {
+  InitFuncDescWithWhiteList(mod);
+  auto admMempool = AllocateMemPoolInPhaseManager("MEBETopLevelManager's Analysis Data Manager mempool");
+  auto *serialADM = GetManagerMemPool()->New<AnalysisDataManager>(*(admMempool.get()));
+  for (size_t i = 0; i < phasesSequence.size(); ++i) {
+    const MaplePhaseInfo *curPhase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+    if (!IsQuiet()) {
+      LogInfo::MapleLogger() << "<<<Run Module " << (curPhase->IsAnalysis() ? "analysis" : "transform")
+                             << " Phase [ " << curPhase->PhaseName()  << " ]>>>\n";
+    }
+    DumpModule(mod, curPhase->PhaseName(), true);
+    if (curPhase->IsAnalysis()) {
+      (void)RunAnalysisPhase<MapleModulePhase, MIRModule>(*curPhase, *serialADM, mod);
+    } else {
+      (void)RunTransformPhase<MapleModulePhase, MIRModule>(*curPhase, *serialADM, mod);
+    }
+    DumpModule(mod, curPhase->PhaseName(), false);
+  }
+  serialADM->EraseAllAnalysisPhase();
+}
+
+void MEBETopLevelManager::DoPhasesPopulate(const maple::MIRModule &mirModule) {
+#define MODULE_PHASE
+#include "phases.def"
+#undef MODULE_PHASE
+}
+
+MAPLE_TRANSFORM_PHASE_REGISTER(MEBETopLevelManager, TopLevelManager)
+
+MAPLE_ANALYSIS_PHASE_REGISTER(IpaSccPM, IpaSccPM)
+MAPLE_ANALYSIS_PHASE_REGISTER(M2MClone, clone)
+MAPLE_ANALYSIS_PHASE_REGISTER(M2MIpaClone, ipaclone)
+MAPLE_ANALYSIS_PHASE_REGISTER(M2MCallGraph, callgraph)
+MAPLE_ANALYSIS_PHASE_REGISTER(M2MKlassHierarchy, classhierarchy)
+MAPLE_ANALYSIS_PHASE_REGISTER(M2MAnnotationAnalysis, annotationanalysis)
+MAPLE_ANALYSIS_PHASE_REGISTER(ProfileGenPM, ProfileGenPM)
+MAPLE_ANALYSIS_PHASE_REGISTER(MMplProfDataParser, grofDataParser)
+
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MInline, inline)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MGInline, ginline)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MOutline, outline)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MIPODevirtualize, ipodevirtulize)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MMethodReplace, methodreplace)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MScalarReplacement, ScalarReplacement)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MOpenprofile, openprofile)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MPreme, preme)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MPreCheckCast, precheckcast)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MCheckCastGeneration, gencheckcast)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MMuidReplacement, MUIDReplacement)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MGenerateNativeStubFunc, GenNativeStubFunc)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MJavaEHLowerer, javaehlower)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MCodeReLayout, CodeReLayout)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MClassInit, clinit)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MJavaIntrnLowering, javaintrnlowering)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MSimplify, simplify)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MUpdateMplt, updatemplt)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MReflectionAnalysis, reflectionanalysis)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MVtableImpl, VtableImpl)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MConstantFold, ConstantFold)
+MAPLE_TRANSFORM_PHASE_REGISTER(M2MVtableAnalysis, vtableanalysis)
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/mpl_profdata_parser.cpp b/src/mapleall/mpl2mpl/src/mpl_profdata_parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1d0ed18d7f155b55d00d872e38bcc6a51d95eb5d
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/mpl_profdata_parser.cpp
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "mpl_profdata_parser.h"
+
+#include <getopt.h>
+
+#include <cassert>
+#include <cinttypes>
+#include <cstdarg>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+
+#include "mpl_logging.h"
+#include "option.h"
+
+namespace maple {
+
+template <typename T>
+T ProfDataBinaryImportBase::ReadNum() {
+  unsigned numBytesRead = 0;
+  uint64_t val = namemangler::DecodeULEB128(pos, &numBytesRead);
+
+  pos += numBytesRead;
+  return static_cast<T>(val);
+}
+
+void ProfileSummaryImport::ReadSummary(MplProfileData *profData) {
+  CHECK_FATAL(profData != nullptr, "sanity check");
+  uint64_t magicNum = ReadNum<uint64_t>();
+  CHECK_FATAL(magicNum == kMapleProfDataMagicNumber, "magic number error, quit\n");
+  uint64_t checksum = ReadNum<uint64_t>();
+  uint32_t runtimes = ReadNum<uint32_t>();
+  uint32_t numofCounts = ReadNum<uint32_t>();
+  uint64_t maxCount = ReadNum<uint64_t>();
+  uint64_t sumCount = ReadNum<uint64_t>();
+  profData->summary.SetSummary(checksum, runtimes, numofCounts, maxCount, sumCount);
+  uint32_t veclen = ReadNum<uint32_t>();
+
+  for (uint32_t i = 0; i < veclen; i++) {
+    uint32_t r1 = ReadNum<uint32_t>();
+    uint32_t r2 = ReadNum<uint32_t>();
+    uint64_t r3 = ReadNum<uint64_t>();
+    uint64_t r4 = ReadNum<uint64_t>();
+    profData->summary.AddHistogramRecord(r1, r2, r3, r4);
+  }
+}
+
+int FunctionProfileImport::ReadFuncProfile(MplProfileData *profData) {
+  CHECK_FATAL(profData != nullptr, "sanity check");
+  uint32_t funcNums = ReadNum<uint32_t>();
+  if (funcNums == 0) {
+    return 1;
+  }
+
+  for (uint32_t i = 0; i < funcNums; i++) {
+    uint32_t funcIdent = ReadNum<uint32_t>();
+    uint32_t linocheckSum = ReadNum<uint32_t>();
+    uint32_t cfgcheckSum = ReadNum<uint32_t>();
+    uint32_t countNum = ReadNum<uint32_t>();
+    FuncProfInfo *funcProf = profData->AddNewFuncProfile(funcIdent, linocheckSum, cfgcheckSum, countNum);
+    CHECK_FATAL(funcProf != nullptr, "nullptr check");
+    funcProf->counts.resize(countNum);
+    for (uint32_t j = 0; j < countNum; j++) {
+      funcProf->counts[j] = ReadNum<uint64_t>();
+    }
+  }
+  return 0;
+}
+
+int MplProfDataParser::ReadMapleProfileData() {
+  std::string mprofDataFile = Options::profile;
+  if (mprofDataFile.empty()) {
+    if (const char *envGcovprefix = std::getenv("GCOV_PREFIX")) {
+      static_cast<void>(mprofDataFile.append(envGcovprefix));
+      if (mprofDataFile.back() != '/') {
+        static_cast<void>(mprofDataFile.append("/"));
+      }
+      if (dumpDetail) {
+        LogInfo::MapleLogger() << "set env GCOV_PREFIX= " << mprofDataFile << std::endl;
+      }
+      uint32_t stripnum = 0;
+      if (const char *envGcovprefixstrip = std::getenv("GCOV_PREFIX_STRIP")) {
+        std::string strip(envGcovprefixstrip);
+        stripnum = static_cast<uint32>(std::stoi(strip));
+        if (dumpDetail) {
+          LogInfo::MapleLogger() << "set env GCOV_PREFIX_STRIP=" << strip << std::endl;
+        }
+      }
+      std::string profDataFileName = m.GetProfileDataFileName();
+      if (dumpDetail) {
+        LogInfo::MapleLogger() << "profdata file stem before strip: " << profDataFileName << std::endl;
+      }
+      // reduce path in profDataFileName
+      while (stripnum > 0 && profDataFileName.size() > 1) {
+        size_t pos = profDataFileName.find_first_of("/", 1);
+        if (pos == std::string::npos) {
+          break;
+        }
+        profDataFileName = profDataFileName.substr(pos);
+        stripnum--;
+      }
+      if (dumpDetail) {
+        LogInfo::MapleLogger() << "profdata file stem after strip: " << profDataFileName << std::endl;
+      }
+      CHECK_FATAL(profDataFileName.size() > 0, "sanity check");
+      static_cast<void>(mprofDataFile.append(profDataFileName));
+    } else {
+      // if gcov_prefix is not set, find .mprofdata according to m.profiledata
+      mprofDataFile = m.GetProfileDataFileName();
+      if (dumpDetail) {
+        LogInfo::MapleLogger() << "NO ENV, profdata file stem: " << mprofDataFile << std::endl;
+      }
+    }
+    // add .mprofdata
+    static_cast<void>(mprofDataFile.append(namemangler::kMplProfFileNameExt));
+  }
+  ASSERT(!mprofDataFile.empty(), "null check");
+  LogInfo::MapleLogger() << "profileUse will open " << mprofDataFile << std::endl;
+  // create mpl profdata
+  profData = mempool->New<MplProfileData>(mempool, &alloc);
+  // read .mprofdata
+  std::ifstream inputStream(mprofDataFile, (std::ios::in | std::ios::binary));
+  CHECK_FATAL(inputStream, "Could not open the file %s, quit\n", mprofDataFile.c_str());
+  // get length of file
+  static_cast<void>(inputStream.seekg(0, std::ios::end));
+  uint32_t length = static_cast<uint32>(inputStream.tellg());
+  static_cast<void>(inputStream.seekg(0, std::ios::beg));
+  const uint32_t sizeThreshold = 1024 * 10;
+  CHECK_FATAL(length <= sizeThreshold, "NYI::large .mprofdata file size is larger than threashold, do chunk memory\n");
+
+  std::unique_ptr<char[]> buffer = std::make_unique<char[]>(length);
+  static_cast<void>(inputStream.read(buffer.get(), length));
+  inputStream.close();
+  // read 1st part summary
+  ProfileSummaryImport summaryImport(mprofDataFile, inputStream);
+  summaryImport.SetPosition(static_cast<uint8_t*>(static_cast<void*>(buffer.get())));
+  summaryImport.ReadSummary(profData);
+  if (dumpDetail) {
+    profData->summary.DumpSummary();
+  }
+  // read 2nd part function profile data
+  FunctionProfileImport funcImport(mprofDataFile, inputStream);
+  funcImport.SetPosition(summaryImport.GetPosition());
+  int res = funcImport.ReadFuncProfile(profData);
+  if (res) {
+    LogInfo::MapleLogger() << "no function profile part\n";
+    return 1;
+  }
+  if (dumpDetail) {
+    profData->DumpFunctionsProfile();
+  }
+  return 0;
+}
+
+void MMplProfDataParser::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.SetPreservedAll();
+}
+
+bool MMplProfDataParser::PhaseRun(maple::MIRModule &m) {
+  MemPool *memPool = m.GetMemPool();  // use global pool to store profile data
+  bool enableDebug = false;            // true to dump trace
+  MplProfDataParser parser(m, memPool, enableDebug);
+  int res = parser.ReadMapleProfileData();
+  if (res) {
+    // something wrong
+    LogInfo::MapleLogger() << " parse .mprofdata error\n";
+    return false;
+  }
+  m.SetMapleProfile(parser.GetProfData());
+
+  return true;
+}
+
+}  // end namespace maple
diff --git a/src/mapleall/mpl2mpl/src/muid_replacement.cpp b/src/mapleall/mpl2mpl/src/muid_replacement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3529b243ea8a488778c8e1a03a12f8a30f8c2a60
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/muid_replacement.cpp
@@ -0,0 +1,2004 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "muid_replacement.h"
+#include <fstream>
+#include "reflection_analysis.h"
+#include "me_profile_gen.h"
+#include "phase_impl.h"
+
+namespace {
+// Version for the mpl linker
+constexpr char kMplLinkerVersionNumber[] = "MPL-LINKER V1.1";
+constexpr char kMuidFuncPtrStr[] = "__muid_funcptr";
+constexpr char kMuidSymPtrStr[] = "__muid_symptr";
+
+#ifdef USE_ARM32_MACRO
+enum LinkerRefFormat {
+  kLinkerRefAddress   = 0, // must be 0
+  kLinkerRefDef       = 1, // def
+  kLinkerRefUnDef     = 2, // undef
+  kLinkerRefOffset    = 3  // offset
+};
+#else
+constexpr maple::uint64 kFromUndefIndexMask = 0x4000000000000000;
+constexpr maple::uint64 kFromDefIndexMask = 0x2000000000000000;
+#endif
+constexpr maple::uint64 KReservedBits = 2u;
+constexpr maple::uint32 kFromUndefIndexMask32Mod = 0x80000000;
+constexpr maple::uint32 kFromDefIndexMask32Mod = 0x40000000;
+} // namespace
+
+// MUIDReplacement
+// This phase is mainly to enable the maple linker about the text and data structure.
+// It will do the following things:
+// A) It collect the methods, classinfo, vtable, itable , and etc.And then it will generate the
+// basic data structures like func_def, func_undef, data_def, data_undef using these symbols.
+//
+// B) It will replace the relevant reference about the methods and static variable with def or undef
+// table.And then we can close these symbols to reduce the code size.
+namespace maple {
+MUID MUIDReplacement::mplMuid;
+
+MUIDReplacement::MUIDReplacement(MIRModule &mod, KlassHierarchy *kh, bool dump)
+    : FuncOptimizeImpl(mod, kh, dump) {
+  isLibcore = (GetSymbolFromName(namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr)) != nullptr);
+  GenerateTables();
+}
+
+MIRSymbol *MUIDReplacement::GetSymbolFromName(const std::string &name) {
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(name);
+  return GlobalTables::GetGsymTable().GetSymbolFromStrIdx(gStrIdx);
+}
+
+ConstvalNode* MUIDReplacement::GetConstvalNode(int64 index) {
+#ifdef USE_ARM32_MACRO
+  return builder->CreateIntConst(index, PTY_i32);
+#else
+  return builder->CreateIntConst(index, PTY_i64);
+#endif
+}
+
+bool MUIDReplacement::CheckFunctionIsUsed(const MIRFunction &mirFunc) const {
+  if (Options::decoupleStatic && mirFunc.GetAttr(FUNCATTR_static)) {
+    return false;
+  } else {
+    return true;
+  }
+}
+
+void MUIDReplacement::DumpMUIDFile(bool isFunc) {
+  std::ofstream outFile;
+  const std::string &mplName = GetMIRModule().GetFileName();
+  size_t index = mplName.rfind(".");
+  CHECK_FATAL(index != std::string::npos, "can not find src file");
+  std::string prefix = mplName.substr(0, index);
+  std::string outFileName;
+  if (isFunc) {
+    outFileName = prefix + ".func.muid";
+  } else {
+    outFileName = prefix + ".data.muid";
+  }
+  outFile.open(outFileName);
+  if (outFile.fail()) {
+    return;
+  }
+  size_t begin = mplName.find("libmaple");
+  size_t end = mplName.find("_", begin);
+  std::string outName;
+  if (begin != std::string::npos && end != std::string::npos && end > begin) {
+    outName = mplName.substr(begin, end - begin);
+  } else {
+    outName = mplName;
+  }
+  if (isFunc) {
+    for (auto &keyVal : std::as_const(funcDefMap)) {
+      outFile << outName << " ";
+      MIRSymbol *mirFunc = keyVal.second.first;
+      outFile << mirFunc->GetName() << " ";
+      outFile << keyVal.first.ToStr() << "\n";
+    }
+  } else {
+    for (auto &keyVal : std::as_const(dataDefMap)) {
+      outFile << outName << " ";
+      MIRSymbol *mirSymbol = keyVal.second.first;
+      outFile << mirSymbol->GetName() << " ";
+      outFile << keyVal.first.ToStr() << "\n";
+    }
+  }
+  outFile.close();
+}
+
+void MUIDReplacement::InsertArrayClassSet(const MIRType &type) {
+  auto jArrayType = static_cast<const MIRJarrayType&>(type);
+  std::string klassJavaDescriptor;
+  namemangler::DecodeMapleNameToJavaDescriptor(jArrayType.GetJavaName(), klassJavaDescriptor);
+  arrayClassSet.insert(klassJavaDescriptor);
+}
+
+MIRType *MUIDReplacement::GetIntrinsicConstArrayClass(StmtNode &stmt) {
+  Opcode op = stmt.GetOpCode();
+  if (op == OP_dassign || op == OP_regassign) {
+    auto &unode = static_cast<UnaryStmtNode&>(stmt);
+    BaseNode &rhsOpnd = *(unode.GetRHS());
+    Opcode rhsOp = rhsOpnd.GetOpCode();
+    if (rhsOp == OP_intrinsicopwithtype) {
+      auto &intrinNode = static_cast<IntrinsicopNode&>(rhsOpnd);
+      MIRIntrinsicID intrinsicID = intrinNode.GetIntrinsic();
+      if (intrinsicID == INTRN_JAVA_CONST_CLASS || intrinsicID == INTRN_JAVA_INSTANCE_OF) {
+        TyIdx tyIdx = intrinNode.GetTyIdx();
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+        MIRPtrType *ptrType = static_cast<MIRPtrType*>(type);
+        MIRType *jArrayTy = ptrType->GetPointedType();
+        if (jArrayTy->GetKind() == kTypeArray || jArrayTy->GetKind() == kTypeJArray) {
+          return jArrayTy;
+        }
+      }
+    } else if ((rhsOp == OP_gcmallocjarray) || (rhsOp == OP_gcpermallocjarray)) {
+      JarrayMallocNode &jarrayMallocNode = static_cast<JarrayMallocNode&>(rhsOpnd);
+      TyIdx tyIdx = jarrayMallocNode.GetTyIdx();
+      MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+      if (type->GetKind() == kTypeArray || type->GetKind() == kTypeJArray) {
+        return type;
+      }
+    }
+  }
+  return nullptr;
+}
+
+void MUIDReplacement::CollectArrayClass() {
+  for (MIRFunction *mirFunc : std::as_const(GetMIRModule().GetFunctionList())) {
+    if (mirFunc->GetBody() == nullptr) {
+      continue;
+    }
+    StmtNode *stmt = mirFunc->GetBody()->GetFirst();
+    StmtNode *nextStmt = nullptr;
+    while (stmt) {
+      nextStmt = stmt->GetNext();
+      MIRType *jArrayTy = GetIntrinsicConstArrayClass(*stmt);
+      if (jArrayTy != nullptr) {
+        InsertArrayClassSet(*jArrayTy);
+      }
+      stmt = nextStmt;
+    }
+  }
+}
+
+void MUIDReplacement::GenArrayClassCache() {
+  if (arrayClassSet.size() == 0) {
+    return;
+  }
+#ifdef USE_32BIT_REF
+  MIRType *mType = GlobalTables::GetTypeTable().GetUInt32();
+#else
+  MIRType *mType = GlobalTables::GetTypeTable().GetUInt64();
+#endif
+  auto arrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*mType, static_cast<uint32>(arrayClassSet.size()));
+  auto *arrayClassNameConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *arrayType);
+  auto *arrayClassConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *arrayType);
+  ASSERT_NOT_NULL(arrayClassNameConst);
+  ASSERT_NOT_NULL(arrayClassConst);
+  // magic number, must consistent with kMplArrayClassCacheMagicNumber(0x1a3) in runtime, defined in mrt_common.h.
+  constexpr int32 arrayClassCacheMagicNumber = 0x1a3;
+  for (auto arrayClassName : arrayClassSet) {
+    uint32 typeNameIdx = ReflectionAnalysis::FindOrInsertRepeatString(arrayClassName);
+    MIRIntConst *nameConstValue =
+        GlobalTables::GetIntConstTable().GetOrCreateIntConst(typeNameIdx, *mType);
+    arrayClassNameConst->AddItem(nameConstValue, 0);
+    MIRIntConst *constValue =
+        GlobalTables::GetIntConstTable().GetOrCreateIntConst(arrayClassCacheMagicNumber, *mType);
+    arrayClassConst->AddItem(constValue, 0);
+  }
+  MIRSymbol *arrayClassNameSt = GetMIRModule().GetMIRBuilder()->CreateGlobalDecl(
+      namemangler::kArrayClassCacheNameTable + GetMIRModule().GetFileNameAsPostfix(), *arrayType);
+  arrayClassNameSt->SetStorageClass(kScFstatic);
+  arrayClassNameSt->SetKonst(arrayClassNameConst);
+
+  MIRSymbol *arrayClassCacheSt = GetMIRModule().GetMIRBuilder()->CreateGlobalDecl(
+      namemangler::kArrayClassCacheTable + GetMIRModule().GetFileNameAsPostfix(), *arrayType);
+  arrayClassCacheSt->SetStorageClass(kScFstatic);
+  arrayClassCacheSt->SetKonst(arrayClassConst);
+}
+
+void MUIDReplacement::CollectFuncAndDataFromKlasses() {
+  // Iterate klasses
+  for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
+    MIRStructType *sType = klass->GetMIRStructType();
+    // DefTable and UndefTable are placed where a class is defined
+    if (sType == nullptr || !sType->IsLocal()) {
+      continue;
+    }
+    // Collect FuncDefSet
+    for (MethodPair &methodPair : sType->GetMethods()) {
+      MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodPair.first.Idx());
+      MIRFunction *mirFunc = funcSymbol->GetFunction();
+      if (mirFunc != nullptr && mirFunc->GetBody()) {
+        AddDefFunc(mirFunc);
+      }
+    }
+    // Cases where an external method can be referred:
+    // 1. vtable entry (what we are dealing with here)
+    // 2. direct call (collected later when iterating function bodies)
+    if (!klass->IsInterface()) {
+      for (MethodPair *vMethodPair : sType->GetVTableMethods()) {
+        if (vMethodPair != nullptr) {
+          MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(vMethodPair->first.Idx());
+          MIRFunction *mirFunc = funcSymbol->GetFunction();
+          if (mirFunc != nullptr && mirFunc->GetBody() == nullptr && !mirFunc->IsAbstract()) {
+            if (!CheckFunctionIsUsed(*mirFunc)) {
+              continue;
+            }
+            AddUndefFunc(mirFunc);
+          }
+        }
+      }
+    }
+  }
+}
+
+void MUIDReplacement::CollectFuncAndDataFromGlobalTab() {
+  // Iterate global symbols
+  for (size_t i = 1; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
+    // entry 0 is reserved as nullptr
+    MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
+    CHECK_FATAL(mirSymbol != nullptr, "Invalid global data symbol at index %u", i);
+    if (mirSymbol->GetStorageClass() == kScGlobal) {
+      if (mirSymbol->IsReflectionClassInfo()) {
+        if (!mirSymbol->IsForcedGlobalClassinfo() &&
+            preloadedClassInfo.find(mirSymbol->GetName()) == preloadedClassInfo.end()) {
+          // With maple linker, global data can be declared as local
+          mirSymbol->SetStorageClass(kScFstatic);
+        }
+        if (mirSymbol->GetKonst() != nullptr) {
+          // Use this to exclude forward-declared classinfo symbol
+          AddDefData(mirSymbol);
+        }
+      } else if (mirSymbol->IsStatic()) {
+        mirSymbol->SetStorageClass(kScFstatic);
+        AddDefData(mirSymbol);
+      }
+    } else if (mirSymbol->GetStorageClass() == kScExtern &&
+               (mirSymbol->IsReflectionClassInfo() || mirSymbol->IsStatic())) {
+      AddUndefData(mirSymbol);
+    }
+  }
+}
+
+void MUIDReplacement::CollectSuperClassArraySymbolData() {
+  // Iterate global symbols
+  for (size_t i = 0; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
+    MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
+    if ((mirSymbol != nullptr) && mirSymbol->IsReflectionSuperclassInfo()) {
+      (void)superClassArraySymbolSet.insert(mirSymbol);
+    }
+  }
+}
+
+void MUIDReplacement::CollectFuncAndDataFromFuncList() {
+  // Iterate function bodies
+  for (MIRFunction *mirFunc : std::as_const(GetMIRModule().GetFunctionList())) {
+    if (mirFunc->GetBody() == nullptr) {
+      continue;
+    }
+    StmtNode *stmt = mirFunc->GetBody()->GetFirst();
+    while (stmt != nullptr) {
+      PUIdx puidx = 0;
+      switch (stmt->GetOpCode()) {
+        case OP_call:
+        case OP_callassigned: {
+          puidx = static_cast<CallNode*>(stmt)->GetPUIdx();
+          break;
+        }
+        case OP_dassign: {
+          // epre in ME may have splitted a direct call into addroffunc and an indirect call
+          auto *rhs = static_cast<DassignNode*>(stmt)->GetRHS();
+          if (rhs != nullptr && rhs->GetOpCode() == OP_addroffunc) {
+            puidx = static_cast<AddroffuncNode*>(rhs)->GetPUIdx();
+          }
+          break;
+        }
+        case OP_regassign: {
+          auto *rhs = static_cast<RegassignNode*>(stmt)->Opnd(0);
+          if (rhs != nullptr && rhs->GetOpCode() == OP_addroffunc) {
+            puidx = static_cast<AddroffuncNode*>(rhs)->GetPUIdx();
+          }
+          break;
+        }
+        default:
+          break;
+      }
+      if (puidx != 0) {
+        MIRFunction *undefMIRFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puidx);
+        if (undefMIRFunc->GetBody() == nullptr &&
+            (undefMIRFunc->IsJava() || !undefMIRFunc->GetBaseClassName().empty())) {
+          if (CheckFunctionIsUsed(*undefMIRFunc)) {
+            AddUndefFunc(undefMIRFunc);
+          }
+        }
+      }
+      // Some stmt requires classinfo but is lowered in CG. Handle them here.
+      CollectImplicitUndefClassInfo(*stmt);
+      stmt = stmt->GetNext();
+    }
+  }
+}
+
+void MUIDReplacement::CollectFuncAndData() {
+  // Iterate klasses
+  for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
+    MIRStructType *sType = klass->GetMIRStructType();
+    // DefTable and UndefTable are placed where a class is defined
+    if (sType == nullptr || !sType->IsLocal()) {
+      continue;
+    }
+    // Collect FuncDefSet
+    for (MethodPair &methodPair : sType->GetMethods()) {
+      MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodPair.first.Idx());
+      MIRFunction *mirFunc = funcSymbol->GetFunction();
+      CHECK_FATAL(mirFunc != nullptr, "Invalid function symbol for Class %s", sType->GetName().c_str());
+      if (mirFunc != nullptr && mirFunc->GetBody()) {
+        AddDefFunc(mirFunc);
+      }
+    }
+    // Cases where an external method can be referred:
+    // 1. vtable entry (what we are dealing with here)
+    // 2. direct call (collected later when iterating function bodies)
+    if (!klass->IsInterface()) {
+      for (MethodPair *vMethodPair : sType->GetVTableMethods()) {
+        CHECK_FATAL(vMethodPair != nullptr, "Invalid vtable_methods entry for Class %s", sType->GetName().c_str());
+
+        MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(vMethodPair->first.Idx());
+        MIRFunction *mirFunc = funcSymbol->GetFunction();
+        if (mirFunc != nullptr && !mirFunc->GetBody() && !mirFunc->IsAbstract()) {
+          if (CheckFunctionIsUsed(*mirFunc)) {
+            AddUndefFunc(mirFunc);
+          }
+        }
+      }
+    }
+  }
+  // Iterate global symbols
+  for (size_t i = 1; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
+    // entry 0 is reserved as nullptr
+    MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
+    CHECK_FATAL(mirSymbol != nullptr, "Invalid global data symbol at index %u", i);
+    if (mirSymbol->GetStorageClass() == kScGlobal) {
+      if (mirSymbol->IsReflectionClassInfo()) {
+        if (!mirSymbol->IsForcedGlobalClassinfo() &&
+            preloadedClassInfo.find(mirSymbol->GetName()) == preloadedClassInfo.end()) {
+          // With maple linker, global data can be declared as local
+          mirSymbol->SetStorageClass(kScFstatic);
+        }
+        if (mirSymbol->GetKonst() != nullptr) {
+          // Use this to exclude forward-declared classinfo symbol
+          AddDefData(mirSymbol);
+        }
+      } else if (mirSymbol->IsStatic()) {
+        mirSymbol->SetStorageClass(kScFstatic);
+        AddDefData(mirSymbol);
+      }
+    } else if (mirSymbol->GetStorageClass() == kScExtern &&
+               (mirSymbol->IsReflectionClassInfo() || mirSymbol->IsStatic())) {
+      AddUndefData(mirSymbol);
+    }
+  }
+  // Iterate function bodies
+  for (MIRFunction *mirFunc : std::as_const(GetMIRModule().GetFunctionList())) {
+    if (mirFunc->GetBody() == nullptr) {
+      continue;
+    }
+    StmtNode *stmt = mirFunc->GetBody()->GetFirst();
+    while (stmt != nullptr) {
+      PUIdx puidx = 0;
+      switch (stmt->GetOpCode()) {
+        case OP_call:
+        case OP_callassigned: {
+          puidx = static_cast<CallNode*>(stmt)->GetPUIdx();
+          break;
+        }
+        case OP_dassign: {
+          // epre in ME may have splitted a direct call into addroffunc and an indirect call
+          BaseNode *rhs = static_cast<DassignNode*>(stmt)->GetRHS();
+          if (rhs != nullptr && rhs->GetOpCode() == OP_addroffunc) {
+            puidx = static_cast<AddroffuncNode*>(rhs)->GetPUIdx();
+          }
+          break;
+        }
+        case OP_regassign: {
+          BaseNode *rhs = static_cast<RegassignNode*>(stmt)->Opnd(0);
+          if (rhs != nullptr && rhs->GetOpCode() == OP_addroffunc) {
+            puidx = static_cast<AddroffuncNode*>(rhs)->GetPUIdx();
+          }
+          break;
+        }
+        case OP_catch: {
+          auto &catchNode = static_cast<CatchNode&>(*stmt);
+          if (catchNode.GetExceptionTyIdxVec().size() != 1) {
+            break;
+          }
+          MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchNode.GetExceptionTyIdxVecElement(0));
+          ASSERT(type->GetKind() == kTypePointer, "Must be pointer");
+          auto *pType = static_cast<MIRPtrType*>(type);
+          Klass *catchClass = nullptr;
+          if (pType->GetPointedTyIdx() == PTY_void) {
+            catchClass = klassHierarchy->GetKlassFromName(namemangler::kJavaLangExceptionStr);
+          } else {
+            catchClass = klassHierarchy->GetKlassFromTyIdx(pType->GetPointedTyIdx());
+          }
+          if (catchClass != nullptr) {
+            std::string classInfoName = CLASSINFO_PREFIX_STR + catchClass->GetKlassName();
+            MIRSymbol *classSym = GetSymbolFromName(classInfoName);
+            if (classSym == nullptr) {
+              classSym = builder->CreateGlobalDecl(classInfoName, *GlobalTables::GetTypeTable().GetPtr());
+              classSym->SetStorageClass(kScExtern);
+              AddUndefData(classSym);
+            }
+          }
+          break;
+        }
+        default:
+          break;
+      }
+      if (puidx != 0) {
+        MIRFunction *undefMIRFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puidx);
+        if (!undefMIRFunc->GetBody() && (undefMIRFunc->IsJava() || !undefMIRFunc->GetBaseClassName().empty())) {
+          if (CheckFunctionIsUsed(*undefMIRFunc)) {
+            AddUndefFunc(undefMIRFunc);
+          }
+        }
+      }
+      // Some stmt requires classinfo but is lowered in CG. Handle them here.
+      CollectImplicitUndefClassInfo(*stmt);
+      stmt = stmt->GetNext();
+    }
+  }
+}
+
+void MUIDReplacement::CollectImplicitUndefClassInfo(StmtNode &stmt) {
+  BaseNode *rhs = nullptr;
+  std::vector<MIRStructType*> classTyVec;
+  if (stmt.GetOpCode() == OP_dassign) {
+    auto *dNode = static_cast<DassignNode*>(&stmt);
+    rhs = dNode->GetRHS();
+  } else if (stmt.GetOpCode() == OP_regassign) {
+    auto *rNode = static_cast<RegassignNode*>(&stmt);
+    rhs = rNode->Opnd(0);
+  } else if (stmt.GetOpCode() == OP_catch) {
+    auto *jNode = static_cast<CatchNode*>(&stmt);
+    for (TyIdx typeIdx : jNode->GetExceptionTyIdxVec()) {
+      auto *pointerType = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx));
+      MIRType *type = pointerType->GetPointedType();
+      if (type != nullptr) {
+        if (type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface) {
+          classTyVec.push_back(static_cast<MIRStructType*>(type));
+        } else if (type == GlobalTables::GetTypeTable().GetVoid()) {
+          Klass *objectKlass = klassHierarchy->GetKlassFromLiteral(namemangler::kJavaLangObjectStr);
+          if (objectKlass != nullptr) {
+            classTyVec.push_back(objectKlass->GetMIRStructType());
+          }
+        }
+      }
+    }
+  }
+  if (rhs != nullptr && rhs->GetOpCode() == OP_gcmalloc) {
+    // GCMalloc may require more classinfo than what we have seen so far
+    auto *gcMalloc = static_cast<GCMallocNode*>(rhs);
+    classTyVec.push_back(
+        static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(gcMalloc->GetTyIdx())));
+  } else if (rhs != nullptr && rhs->GetOpCode() == OP_intrinsicopwithtype) {
+    auto *intrinNode = static_cast<IntrinsicopNode*>(rhs);
+    if (intrinNode->GetIntrinsic() == INTRN_JAVA_CONST_CLASS || intrinNode->GetIntrinsic() == INTRN_JAVA_INSTANCE_OF) {
+      auto *pointerType =
+          static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(intrinNode->GetTyIdx()));
+      MIRType *type = pointerType->GetPointedType();
+      if (type != nullptr && (type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface)) {
+        classTyVec.push_back(static_cast<MIRStructType*>(type));
+      }
+    }
+  }
+  for (MIRStructType *classType : classTyVec) {
+    if (classType == nullptr) {
+      continue;
+    }
+    std::string classInfoName = CLASSINFO_PREFIX_STR + classType->GetName();
+    MIRSymbol *classSym = GetSymbolFromName(classInfoName);
+    if (classSym == nullptr) {
+      classSym = builder->CreateGlobalDecl(classInfoName, *GlobalTables::GetTypeTable().GetPtr());
+      classSym->SetStorageClass(kScExtern);
+      AddUndefData(classSym);
+    }
+  }
+}
+
+void MUIDReplacement::InsertFunctionProfile(MIRFunction &currentFunc, int64 index) {
+  // Insert profile code  __profile_func_tab[idx] = __profile_func_tab[idx] + 1
+  SetCurrentFunction(currentFunc);
+  AddrofNode *baseExpr = nullptr;
+  MIRArrayType *arrayType = nullptr;
+  baseExpr = builder->CreateExprAddrof(0, *funcProfileTabSym, GetMIRModule().GetMemPool());
+  arrayType = static_cast<MIRArrayType*>(funcProfileTabSym->GetType());
+  ConstvalNode *offsetExpr = GetConstvalNode(index);
+  ConstvalNode *incExpr = GetConstvalNode(1);
+  ArrayNode *arrayExpr = builder->CreateExprArray(*arrayType, baseExpr, offsetExpr);
+  arrayExpr->SetBoundsCheck(false);
+  MIRType *elemType = arrayType->GetElemType();
+  BaseNode *ireadPtrExpr =
+      builder->CreateExprIread(*GlobalTables::GetTypeTable().GetVoidPtr(),
+                               *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 0, arrayExpr);
+  BaseNode *addExpr =
+      builder->CreateExprBinary(OP_add, *GlobalTables::GetTypeTable().GetUInt32(), ireadPtrExpr, incExpr);
+  MIRType *destPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(TyIdx(PTY_u32));
+  StmtNode *funcProfileIAssign = builder->CreateStmtIassign(*destPtrType, 0, arrayExpr, addExpr);
+  currentFunc.GetBody()->InsertFirst(funcProfileIAssign);
+}
+
+void MUIDReplacement::GenerateFuncDefTable() {
+  // Use funcDefMap to make sure funcDefTab is sorted by an increasing order of MUID
+  for (MIRFunction *mirFunc : funcDefSet) {
+    MUID muid = GetMUID(mirFunc->GetName());
+    CHECK_FATAL(funcDefMap.find(muid) == funcDefMap.end(), "MUID has been used before, possible collision");
+    // Use 0 as the index for now. It will be back-filled once we have the whole map.
+    funcDefMap[muid] = SymIdxPair(mirFunc->GetFuncSymbol(), 0);
+  }
+  uint32 idx = 0;
+  uint32 arraySize = static_cast<uint32>(funcDefMap.size());
+  MIRArrayType &muidIdxArrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetUInt32(), arraySize);
+  MIRAggConst *muidIdxTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), muidIdxArrayType);
+  for (auto &keyVal : funcDefMap) {
+    // Fill in the real index
+    keyVal.second.second = idx++;
+    // Use the muid index for now. It will be back-filled once we have the whole vector.
+    MIRIntConst *indexConst =
+        GlobalTables::GetIntConstTable().GetOrCreateIntConst(keyVal.second.second,
+                                                             *GlobalTables::GetTypeTable().GetUInt32());
+    muidIdxTabConst->AddItem(indexConst, 0);
+  }
+  FieldVector parentFields;
+  FieldVector fields;
+  GlobalTables::GetTypeTable().PushIntoFieldVector(fields, "funcUnifiedAddr",
+                                                   *GlobalTables::GetTypeTable().GetCompactPtr());
+  auto *funcDefTabEntryType = static_cast<MIRStructType*>(
+      GlobalTables::GetTypeTable().GetOrCreateStructType("MUIDFuncDefTabEntry", fields, parentFields, GetMIRModule()));
+  FieldVector funcinffields;
+  GlobalTables::GetTypeTable().PushIntoFieldVector(funcinffields, "funcSize",
+                                                   *GlobalTables::GetTypeTable().GetUInt32());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(funcinffields, "funcName",
+                                                   *GlobalTables::GetTypeTable().GetUInt32());
+  auto *funcInfTabEntryType = static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetOrCreateStructType(
+      "MUIDFuncInfTabEntry", funcinffields, parentFields, GetMIRModule()));
+
+  FieldVector funcProfinffields;
+  GlobalTables::GetTypeTable().PushIntoFieldVector(funcProfinffields, "hash",
+                                                   *GlobalTables::GetTypeTable().GetUInt64());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(funcProfinffields, "start",
+                                                   *GlobalTables::GetTypeTable().GetUInt32());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(funcProfinffields, "end",
+                                                   *GlobalTables::GetTypeTable().GetUInt32());
+  auto *funcProfInfTabEntryType = static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetOrCreateStructType(
+      "FuncProfInfTabEntry", funcProfinffields, parentFields, GetMIRModule()));
+  FieldVector muidFields;
+#ifdef USE_64BIT_MUID
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidLow", *GlobalTables::GetTypeTable().GetUInt32());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidHigh", *GlobalTables::GetTypeTable().GetUInt32());
+#else
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidLow", *GlobalTables::GetTypeTable().GetUInt64());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidHigh", *GlobalTables::GetTypeTable().GetUInt64());
+#endif  // USE_64BIT_MUID
+  auto *funcDefMuidTabEntryType =
+      static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetOrCreateStructType(
+          "MUIDFuncDefMuidTabEntry", muidFields, parentFields, GetMIRModule()));
+  MIRArrayType &arrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*funcDefTabEntryType, arraySize);
+  MIRAggConst *funcDefTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), arrayType);
+  MIRArrayType &funcInfArrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*funcInfTabEntryType, arraySize);
+  MIRAggConst *funcInfTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), funcInfArrayType);
+  MIRArrayType &muidArrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*funcDefMuidTabEntryType, arraySize);
+  MIRAggConst *funcDefMuidTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), muidArrayType);
+  MIRArrayType &funcProfInfArrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*funcProfInfTabEntryType, arraySize);
+  MIRAggConst *funcProfInfTabConst =
+      GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), funcProfInfArrayType);
+  if (Options::profileFunc) {
+    // create a table each field is 4 byte record the call times
+    MIRAggConst *funcCallTimesConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), muidIdxArrayType);
+    for (uint32 start = 0; start < arraySize; ++start) {
+      MIRIntConst *indexConst =
+          GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *GlobalTables::GetTypeTable().GetUInt32());
+      funcCallTimesConst->AddItem(indexConst, 0);
+    }
+    if (arraySize) {
+      std::string funcProfileName = namemangler::kFunctionProfileTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+      funcProfileTabSym = builder->CreateGlobalDecl(funcProfileName, muidIdxArrayType);
+      funcProfileTabSym->SetKonst(funcCallTimesConst);
+      funcProfileTabSym->SetStorageClass(kScFstatic);
+    }
+  }
+  // Create funcDefSet to store functions sorted by address
+  std::vector<std::pair<MIRSymbol*, MUID>> funcDefArray;
+  idx = 0;
+  for (MIRFunction *mirFunc : std::as_const(GetMIRModule().GetFunctionList())) {
+    ASSERT(mirFunc != nullptr, "null ptr check!");
+    MUID muid = GetMUID(mirFunc->GetName());
+    auto iter = funcDefMap.find(muid);
+    if (mirFunc->GetBody() == nullptr || iter == funcDefMap.end()) {
+      continue;
+    }
+    funcDefArray.push_back(std::make_pair(mirFunc->GetFuncSymbol(), muid));
+    // Create muidIdxTab to store the index in funcDefTab and funcDefMuidTab
+    // With muidIdxTab, we can use index sorted by muid to find the index in funcDefTab and funcDefMuidTab
+    // Use the left 1 bit of muidIdx to mark whether the function is weak or not. 1 is for weak
+    uint32 muidIdx = iter->second.second;
+    constexpr uint32 weakFuncFlag = 0x80000000; // 0b10000000 00000000 00000000 00000000
+    auto *indexConst = safe_cast<MIRIntConst>(muidIdxTabConst->GetConstVecItem(muidIdx));
+    uint32 tempIdx = (indexConst->GetExtValue() & weakFuncFlag) | idx;
+    indexConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(tempIdx,
+                                                                      *GlobalTables::GetTypeTable().GetUInt32());
+    muidIdxTabConst->SetItem(muidIdx, indexConst, 0);
+    if (reflectionList.find(mirFunc->GetName()) != reflectionList.end()) {
+      auto *tempConst = safe_cast<MIRIntConst>(muidIdxTabConst->GetConstVecItem(idx));
+      tempIdx = weakFuncFlag | tempConst->GetExtValue();
+      tempConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(tempIdx,
+                                                                       *GlobalTables::GetTypeTable().GetUInt32());
+      muidIdxTabConst->SetItem(idx, tempConst, 0);
+    }
+    if (Options::profileFunc) {
+      InsertFunctionProfile(*mirFunc, idx);
+    }
+    if (Options::lazyBinding && !isLibcore) {
+      ReplaceMethodMetaFuncAddr(*mirFunc->GetFuncSymbol(), idx);
+    }
+    if (Options::genIRProfile || Options::profileFunc) {
+      auto funcProfInf = mirFunc->GetProfInf();
+      MIRAggConst *funcProfInfEntryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(),
+          *funcProfInfTabEntryType);
+      uint32 funcProfInfFieldID = 1;
+
+      builder->AddIntFieldConst(*funcProfInfTabEntryType,
+          *funcProfInfEntryConst, funcProfInfFieldID++, static_cast<int64>(funcProfInf->funcHash));
+      builder->AddIntFieldConst(*funcProfInfTabEntryType,
+          *funcProfInfEntryConst, funcProfInfFieldID++, funcProfInf->counterStart);
+      builder->AddIntFieldConst(*funcProfInfTabEntryType,
+          *funcProfInfEntryConst, funcProfInfFieldID++, funcProfInf->counterEnd);
+      funcProfInfTabConst->AddItem(funcProfInfEntryConst, 0);
+    }
+        // Store the real idx of funcdefTab, for ReplaceAddroffuncConst->FindIndexFromDefTable
+    defMuidIdxMap[muid] = idx;
+    idx++;
+    if (trace) {
+      LogInfo::MapleLogger() << "funcDefMap, MUID: " << muid.ToStr()
+                             << ", Function Name: " << iter->second.first->GetName()
+                             << ", Offset in addr order: " << (idx - 1)
+                             << ", Offset in muid order: " << iter->second.second << "\n";
+    }
+  }
+  if (Options::genIRProfile || Options::profileFunc) {
+    MeProfGen::DumpSummary();
+  }
+  // Create funcDefTab, funcInfoTab and funcMuidTab sorted by address, funcMuidIdxTab sorted by muid
+  for (auto keyVal : funcDefArray) {
+    MIRSymbol *funcSymbol = keyVal.first;
+    MUID muid = keyVal.second;
+    MIRAggConst *entryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *funcDefTabEntryType);
+    uint32 fieldID = 1;
+    MIRAggConst *funcInfEntryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(),
+                                                                                   *funcInfTabEntryType);
+    uint32 funcInfFieldID = 1;
+    MIRAggConst *muidEntryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(),
+                                                                                *funcDefMuidTabEntryType);
+    uint32 muidFieldID = 1;
+    // To be processed by runtime
+    builder->AddAddroffuncFieldConst(*funcDefTabEntryType, *entryConst, fieldID++, *funcSymbol);
+    funcDefTabConst->AddItem(entryConst, 0);
+    // To be emitted as method size by CG
+    builder->AddAddroffuncFieldConst(*funcInfTabEntryType, *funcInfEntryConst, funcInfFieldID++, *funcSymbol);
+    // To be emitted as method name by CG
+    builder->AddAddroffuncFieldConst(*funcInfTabEntryType, *funcInfEntryConst, funcInfFieldID++, *funcSymbol);
+    funcInfTabConst->AddItem(funcInfEntryConst, 0);
+    builder->AddIntFieldConst(*funcDefMuidTabEntryType, *muidEntryConst, muidFieldID++, muid.data.words[0]);
+    builder->AddIntFieldConst(*funcDefMuidTabEntryType, *muidEntryConst, muidFieldID++, muid.data.words[1]);
+    funcDefMuidTabConst->AddItem(muidEntryConst, 0);
+    mplMuidStr += muid.ToStr();
+  }
+  if (!funcDefTabConst->GetConstVec().empty()) {
+    std::string funcDefTabName = namemangler::kMuidFuncDefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    funcDefTabSym = builder->CreateGlobalDecl(funcDefTabName, arrayType);
+    funcDefTabSym->SetKonst(funcDefTabConst);
+    funcDefTabSym->SetStorageClass(kScFstatic);
+    // We add the original def tab for lazy binding, and emit them by CG.
+    if (Options::lazyBinding) {
+      std::string funcDefOrigTabName = namemangler::kMuidFuncDefOrigTabPrefixStr +
+                                       GetMIRModule().GetFileNameAsPostfix();
+      funcDefOrigTabSym = builder->CreateGlobalDecl(funcDefOrigTabName,
+                                                    arrayType);
+      funcDefOrigTabSym->SetKonst(funcDefTabConst);
+      funcDefOrigTabSym->SetStorageClass(kScFstatic);
+    }
+  }
+  if (!funcInfTabConst->GetConstVec().empty()) {
+    std::string funcInfTabName = namemangler::kMuidFuncInfTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    funcInfTabSym = builder->CreateGlobalDecl(funcInfTabName, funcInfArrayType);
+    funcInfTabSym->SetKonst(funcInfTabConst);
+    funcInfTabSym->SetStorageClass(kScFstatic);
+  }
+  if (!funcDefMuidTabConst->GetConstVec().empty()) {
+    std::string funcDefMuidTabName = namemangler::kMuidFuncDefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    funcDefMuidTabSym = builder->CreateGlobalDecl(funcDefMuidTabName, muidArrayType);
+    funcDefMuidTabSym->SetKonst(funcDefMuidTabConst);
+    funcDefMuidTabSym->SetStorageClass(kScFstatic);
+  }
+  if (!muidIdxTabConst->GetConstVec().empty()) {
+    std::string muidIdxTabName = namemangler::kMuidFuncMuidIdxTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    funcMuidIdxTabSym = builder->CreateGlobalDecl(muidIdxTabName, muidIdxArrayType);
+    funcMuidIdxTabSym->SetKonst(muidIdxTabConst);
+    funcMuidIdxTabSym->SetStorageClass(kScFstatic);
+  }
+
+  if (!funcProfInfTabConst->GetConstVec().empty()) {
+    std::string profInfTabName = namemangler::kFuncIRProfInfTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    funcProfInfTabSym = builder->CreateGlobalDecl(profInfTabName, funcProfInfArrayType);
+    funcProfInfTabSym->SetKonst(funcProfInfTabConst);
+    funcProfInfTabSym->SetStorageClass(kScFstatic);
+  }
+  if (Options::dumpMuidFile) {
+    DumpMUIDFile(true);
+  }
+}
+
+void MUIDReplacement::ReplaceMethodMetaFuncAddr(const MIRSymbol &funcSymbol, int64 index) {
+  std::string symbolName = funcSymbol.GetName();
+  MIRSymbol *methodAddrDataSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kMethodAddrDataPrefixStr + symbolName));
+  CHECK_FATAL(methodAddrDataSt != nullptr, "methodAddrDataSt symbol is null.");
+  MIRConst *mirConst = methodAddrDataSt->GetKonst();
+  MIRAggConst *aggConst = safe_cast<MIRAggConst>(mirConst);
+  MIRAggConst *agg = safe_cast<MIRAggConst>(aggConst->GetConstVecItem(0));
+  MIRConst *elem = agg->GetConstVecItem(0);
+  if (elem->GetKind() == kConstAddrofFunc) {
+    MIRType &type = elem->GetType();
+    MIRConst *constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(index, type);
+    agg->SetItem(0, constNode, 1);
+  }
+}
+
+void MUIDReplacement::GenerateDataDefTable() {
+  // Use dataDefMap to make sure dataDefTab is sorted by an increasing order of MUID
+  for (MIRSymbol *mirSymbol : dataDefSet) {
+    MUID muid = GetMUID(mirSymbol->GetName());
+    CHECK_FATAL(dataDefMap.find(muid) == dataDefMap.end(), "MUID has been used before, possible collision");
+    // Use 0 as the index for now. It will be back-filled once we have the whole map.
+    dataDefMap[muid] = SymIdxPair(mirSymbol, 0);
+  }
+  uint32 idx = 0;
+  for (auto &keyVal : dataDefMap) {
+    // Fill in the real index
+    keyVal.second.second = idx++;
+    // Add the def index of cinf for lazy binding.
+    if (Options::lazyBinding && !isLibcore) {
+      MIRSymbol *mirSymbol = keyVal.second.first;
+      if (mirSymbol->IsReflectionClassInfo()) {
+        MIRConst *mirConst = mirSymbol->GetKonst();
+        auto *aggConst = safe_cast<MIRAggConst>(mirConst);
+        // CLASS::kShadow holds a field of uint32 size, for def index.
+        // Should we extend it later?
+        CHECK_NULL_FATAL(aggConst);
+        MIRConst *elemConst = aggConst->GetConstVecItem(static_cast<size_t>(ClassProperty::kShadow));
+        auto *intConst = safe_cast<MIRIntConst>(elemConst);
+        // We use 0 as flag of not lazy.
+        intConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(idx, intConst->GetType());
+        aggConst->SetItem(static_cast<size_t>(ClassProperty::kShadow), intConst,
+                          aggConst->GetFieldIdItem(static_cast<size_t>(ClassProperty::kShadow)));
+      } else {
+        ReplaceFieldMetaStaticAddr(*mirSymbol, idx - 1);
+      }
+    }
+  }
+  FieldVector parentFields;
+  FieldVector fields;
+  GlobalTables::GetTypeTable().PushIntoFieldVector(fields, "dataUnifiedAddr",
+                                                   *GlobalTables::GetTypeTable().GetCompactPtr());
+  auto *dataDefTabEntryType = static_cast<MIRStructType*>(
+      GlobalTables::GetTypeTable().GetOrCreateStructType("MUIDDataDefTabEntry", fields, parentFields, GetMIRModule()));
+  FieldVector muidFields;
+#ifdef USE_64BIT_MUID  // USE_64BIT_MUID
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidLow", *GlobalTables::GetTypeTable().GetUInt32());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidHigh", *GlobalTables::GetTypeTable().GetUInt32());
+#else  // USE_128BIT_MUID
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidLow", *GlobalTables::GetTypeTable().GetUInt64());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidHigh", *GlobalTables::GetTypeTable().GetUInt64());
+#endif
+  auto *dataDefMuidTabEntryType =
+      static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetOrCreateStructType(
+          std::string("MUIDDataDefMuidTabEntry"), muidFields, parentFields, GetMIRModule()));
+  size_t arraySize = dataDefMap.size();
+  MIRArrayType &arrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*dataDefTabEntryType, arraySize);
+  MIRAggConst *dataDefTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), arrayType);
+  MIRArrayType &muidArrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*dataDefMuidTabEntryType, arraySize);
+  MIRAggConst *dataDefMuidTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), muidArrayType);
+  for (auto &keyVal : std::as_const(dataDefMap)) {
+    MIRSymbol *mirSymbol = keyVal.second.first;
+    MIRAggConst *entryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *dataDefTabEntryType);
+    uint32 fieldID = 1;
+    MUID muid = keyVal.first;
+    MIRAggConst *muidEntryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(),
+                                                                                *dataDefMuidTabEntryType);
+    uint32 muidFieldID = 1;
+    // Will be emitted as 0 and processed by runtime
+    builder->AddAddrofFieldConst(*dataDefTabEntryType, *entryConst, fieldID++, *mirSymbol);
+    dataDefTabConst->AddItem(entryConst, 0);
+    builder->AddIntFieldConst(*dataDefMuidTabEntryType, *muidEntryConst, muidFieldID++, muid.data.words[0]);
+    builder->AddIntFieldConst(*dataDefMuidTabEntryType, *muidEntryConst, muidFieldID++, muid.data.words[1]);
+    dataDefMuidTabConst->AddItem(muidEntryConst, 0);
+    mplMuidStr += muid.ToStr();
+    if (trace) {
+      LogInfo::MapleLogger() << "dataDefMap, MUID: " << muid.ToStr() << ", Variable Name: " << mirSymbol->GetName()
+                             << ", Offset: " << keyVal.second.second << "\n";
+    }
+  }
+  if (Options::dumpMuidFile) {
+    DumpMUIDFile(false);
+  }
+  if (!dataDefTabConst->GetConstVec().empty()) {
+    std::string dataDefTabName = namemangler::kMuidDataDefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    dataDefTabSym = builder->CreateGlobalDecl(dataDefTabName, arrayType);
+    dataDefTabSym->SetKonst(dataDefTabConst);
+    dataDefTabSym->SetStorageClass(kScFstatic);
+    // We add the original def tab for lazy binding, and emit them by CG.
+    if (Options::lazyBinding) {
+      std::string dataDefOrigTabName = namemangler::kMuidDataDefOrigTabPrefixStr +
+                                       GetMIRModule().GetFileNameAsPostfix();
+      dataDefOrigTabSym = builder->CreateGlobalDecl(dataDefOrigTabName, arrayType);
+      dataDefOrigTabSym->SetKonst(dataDefTabConst);
+      dataDefOrigTabSym->SetStorageClass(kScFstatic);
+    }
+  }
+  if (!dataDefMuidTabConst->GetConstVec().empty()) {
+    std::string dataDefMuidTabName = namemangler::kMuidDataDefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    dataDefMuidTabSym = builder->CreateGlobalDecl(dataDefMuidTabName, muidArrayType);
+    dataDefMuidTabSym->SetKonst(dataDefMuidTabConst);
+    dataDefMuidTabSym->SetStorageClass(kScFstatic);
+  }
+}
+
+void MUIDReplacement::ReplaceFieldMetaStaticAddr(const MIRSymbol &mirSymbol, uint32 index) {
+  std::string symbolName = mirSymbol.GetName();
+  MIRSymbol *fieldOffsetDataSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kFieldOffsetDataPrefixStr + symbolName));
+  if (fieldOffsetDataSt == nullptr) {
+    if (trace) {
+      LogInfo::MapleLogger() << "fieldOffsetDataSt is nullptr, symbolName=" << symbolName << "\n";
+    }
+    return;
+  }
+  MIRAggConst *aggConst = safe_cast<MIRAggConst>(fieldOffsetDataSt->GetKonst());
+  CHECK_NULL_FATAL(aggConst);
+  MIRAggConst *agg = safe_cast<MIRAggConst>(aggConst->GetConstVecItem(0));
+  CHECK_NULL_FATAL(agg);
+  MIRConst *elem = agg->GetConstVecItem(0);
+  CHECK_NULL_FATAL(elem);
+  CHECK_FATAL(elem->GetKind() == kConstAddrof, "static field must kConstAddrof.");
+
+  MIRType &type = elem->GetType();
+  int64 idx = index * 2 + 1; // add flag to indicate that it's def tab index for emit.
+  MIRConst *constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(idx, type);
+  agg->SetItem(0, constNode, 1);
+  (void)idx;
+}
+
+void MUIDReplacement::GenerateUnifiedUndefTable() {
+  for (MIRFunction *mirFunc : funcUndefSet) {
+    MUID muid = GetMUID(mirFunc->GetName());
+    CHECK_FATAL(funcUndefMap.find(muid) == funcUndefMap.end(), "MUID has been used before, possible collision");
+    // Use 0 as the index for now. It will be back-filled once we have the whole map.
+    funcUndefMap[muid] = SymIdxPair(mirFunc->GetFuncSymbol(), 0);
+  }
+  for (MIRSymbol *mirSymbol : dataUndefSet) {
+    MUID muid = GetMUID(mirSymbol->GetName());
+    CHECK_FATAL(dataUndefMap.find(muid) == dataUndefMap.end(), "MUID has been used before, possible collision");
+    // Use 0 as the index for now. It will be back-filled once we have the whole map.
+    dataUndefMap[muid] = SymIdxPair(mirSymbol, 0);
+  }
+  // Fill in the real index.
+  uint32 idx = 0;
+  for (auto &keyVal : funcUndefMap) {
+    keyVal.second.second = idx++;
+  }
+  idx = 0;
+  for (auto &keyVal : dataUndefMap) {
+    keyVal.second.second = idx++;
+  }
+  FieldVector parentFields;
+  FieldVector fields;
+  GlobalTables::GetTypeTable().PushIntoFieldVector(fields, "globalAddress",
+                                                   *GlobalTables::GetTypeTable().GetCompactPtr());
+  auto *unifiedUndefTabEntryType =
+      static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetOrCreateStructType(
+          std::string("MUIDUnifiedUndefTabEntry"), fields, parentFields, GetMIRModule()));
+  FieldVector muidFields;
+#ifdef USE_64BIT_MUID
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidLow", *GlobalTables::GetTypeTable().GetUInt32());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidHigh", *GlobalTables::GetTypeTable().GetUInt32());
+#else
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidLow", *GlobalTables::GetTypeTable().GetUInt64());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(muidFields, "muidHigh", *GlobalTables::GetTypeTable().GetUInt64());
+#endif
+  auto *unifiedUndefMuidTabEntryType =
+      static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetOrCreateStructType(
+          "MUIDUnifiedUndefMuidTabEntry", muidFields, parentFields, GetMIRModule()));
+  size_t arraySize = funcUndefMap.size();
+  MIRArrayType &funcArrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*unifiedUndefTabEntryType,
+                                                                                   arraySize);
+  MIRAggConst *funcUndefTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), funcArrayType);
+  MIRArrayType &funcMuidArrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*unifiedUndefMuidTabEntryType, arraySize);
+  MIRAggConst *funcUndefMuidTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), funcMuidArrayType);
+  for (auto &keyVal : std::as_const(funcUndefMap)) {
+    MUID muid = keyVal.first;
+    mplMuidStr += muid.ToStr();
+    if (trace) {
+      LogInfo::MapleLogger() << "funcUndefMap, MUID: " << muid.ToStr()
+                             << ", Function Name: " << keyVal.second.first->GetName()
+                             << ", Offset: " << keyVal.second.second << "\n";
+    }
+    MIRAggConst *entryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *unifiedUndefTabEntryType);
+    uint32 fieldID = 1;
+    MIRAggConst *muidEntryConst =
+      GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *unifiedUndefMuidTabEntryType);
+    uint32 muidFieldID = 1;
+    // to be filled by runtime
+    builder->AddIntFieldConst(*unifiedUndefTabEntryType, *entryConst, fieldID++, 0);
+    funcUndefTabConst->AddItem(entryConst, 0);
+    if (sourceFileMethodMap.find(muid) != sourceFileMethodMap.end()) {
+      uint32 fileIndex = sourceFileMethodMap[muid].sourceFileIndex;
+      uint32 classIndex = sourceFileMethodMap[muid].sourceClassIndex;
+      uint32 methodIndex = sourceFileMethodMap[muid].sourceMethodIndex << 1;
+      if (sourceFileMethodMap[muid].isVirtual) {
+        methodIndex |= 0x1;
+      }
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++,
+                                ((fileIndex << kShiftBit16) | classIndex));
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++,
+                                (methodIndex << kShiftBit15) | 0x7FFF);
+    } else {
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++, muid.data.words[0]);
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++, muid.data.words[1]);
+    }
+    funcUndefMuidTabConst->AddItem(muidEntryConst, 0);
+  }
+  if (!funcUndefTabConst->GetConstVec().empty()) {
+    std::string funcUndefTabName = namemangler::kMuidFuncUndefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    funcUndefTabSym = builder->CreateGlobalDecl(funcUndefTabName, funcArrayType);
+    funcUndefTabSym->SetKonst(funcUndefTabConst);
+    funcUndefTabSym->SetStorageClass(kScFstatic);
+  }
+  if (!funcUndefMuidTabConst->GetConstVec().empty()) {
+    std::string funcUndefMuidTabName =
+      namemangler::kMuidFuncUndefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    funcUndefMuidTabSym = builder->CreateGlobalDecl(funcUndefMuidTabName, funcMuidArrayType);
+    funcUndefMuidTabSym->SetKonst(funcUndefMuidTabConst);
+    funcUndefMuidTabSym->SetStorageClass(kScFstatic);
+  }
+  // Continue to generate dataUndefTab
+  arraySize = dataUndefMap.size();
+  MIRArrayType &dataArrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*unifiedUndefTabEntryType,
+                                                                                   arraySize);
+  MIRAggConst *dataUndefTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), dataArrayType);
+  MIRArrayType &dataMuidArrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*unifiedUndefMuidTabEntryType, arraySize);
+  MIRAggConst *dataUndefMuidTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), dataMuidArrayType);
+  for (auto &keyVal : std::as_const(dataUndefMap)) {
+    MIRAggConst *entryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *unifiedUndefTabEntryType);
+    uint32 fieldID = 1;
+    MIRSymbol *mirSymbol = keyVal.second.first;
+    MUID muid = keyVal.first;
+    MIRAggConst *muidEntryConst =
+        GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *unifiedUndefMuidTabEntryType);
+    uint32 muidFieldID = 1;
+    // Will be emitted as 0 and filled by runtime
+    builder->AddAddrofFieldConst(*unifiedUndefTabEntryType, *entryConst, fieldID++, *mirSymbol);
+    dataUndefTabConst->AddItem(entryConst, 0);
+    if (sourceIndexMap.find(muid) != sourceIndexMap.end()) {
+      SourceIndexPair pairIndex = sourceIndexMap[muid];
+      uint32 value =  (pairIndex.first << kShiftBit16) + pairIndex.second;
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++, value);
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++, 0xFFFFFFFF);
+    } else if (sourceFileFieldMap.find(muid) != sourceFileFieldMap.end()) {
+      uint32 sourceFileIndex = sourceFileFieldMap[muid].sourceFileIndex;
+      uint32 sourceClassIndex = sourceFileFieldMap[muid].sourceClassIndex;
+      uint32 sourceFieldIndex = sourceFileFieldMap[muid].sourceFieldIndex;
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++,
+                                (sourceFileIndex << kShiftBit16) | sourceClassIndex);
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++,
+                                (sourceFieldIndex << kShiftBit16) | 0xFFFF);
+    } else {
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++, muid.data.words[0]);
+      builder->AddIntFieldConst(*unifiedUndefMuidTabEntryType, *muidEntryConst, muidFieldID++, muid.data.words[1]);
+    }
+    dataUndefMuidTabConst->AddItem(muidEntryConst, 0);
+    mplMuidStr += muid.ToStr();
+    if (trace) {
+      LogInfo::MapleLogger() << "dataUndefMap, MUID: " << muid.ToStr() << ", Variable Name: " << mirSymbol->GetName()
+                             << ", Offset: " << keyVal.second.second << "\n";
+    }
+  }
+  if (!dataUndefTabConst->GetConstVec().empty()) {
+    std::string dataUndefTabName = namemangler::kMuidDataUndefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    dataUndefTabSym = builder->CreateGlobalDecl(dataUndefTabName, dataArrayType);
+    dataUndefTabSym->SetKonst(dataUndefTabConst);
+    dataUndefTabSym->SetStorageClass(kScFstatic);
+  }
+  if (!dataUndefMuidTabConst->GetConstVec().empty()) {
+    std::string dataUndefMuidTabName =
+      namemangler::kMuidDataUndefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    dataUndefMuidTabSym = builder->CreateGlobalDecl(dataUndefMuidTabName, dataMuidArrayType);
+    dataUndefMuidTabSym->SetKonst(dataUndefMuidTabConst);
+    dataUndefMuidTabSym->SetStorageClass(kScFstatic);
+  }
+}
+
+void MUIDReplacement::InitRangeTabUseSym(std::vector<MIRSymbol*> &workList, MIRStructType &rangeTabEntryType,
+                                         MIRAggConst &rangeTabConst) {
+  for (MIRSymbol *mirSymbol : workList) {
+    MIRAggConst *entryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), rangeTabEntryType);
+    uint32 fieldID = 1;
+    if (mirSymbol != nullptr) {
+      builder->AddAddrofFieldConst(rangeTabEntryType, *entryConst, fieldID++, *mirSymbol);
+      builder->AddAddrofFieldConst(rangeTabEntryType, *entryConst, fieldID++, *mirSymbol);
+    } else {
+      builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, 0);
+      builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, 0);
+    }
+    rangeTabConst.AddItem(entryConst, 0);
+  }
+}
+
+// RangeTable stores begin and end of all MUID tables
+void MUIDReplacement::GenerateRangeTable() {
+  FieldVector parentFields;
+  FieldVector fields;
+  GlobalTables::GetTypeTable().PushIntoFieldVector(fields, "tabBegin", *GlobalTables::GetTypeTable().GetVoidPtr());
+  GlobalTables::GetTypeTable().PushIntoFieldVector(fields, "tabEnd", *GlobalTables::GetTypeTable().GetVoidPtr());
+  auto &rangeTabEntryType = static_cast<MIRStructType&>(
+      *GlobalTables::GetTypeTable().GetOrCreateStructType("MUIDRangeTabEntry", fields, parentFields, GetMIRModule()));
+  MIRArrayType &rangeArrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(rangeTabEntryType, 0);
+  MIRAggConst *rangeTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), rangeArrayType);
+  // First entry is reserved for a compile-time-stamp
+  // Second entry is reserved for a decouple-stamp
+  mplMuidStr += kMplLinkerVersionNumber;
+  const std::string muidStr[2] = { mplMuidStr, mplMuidStr + GetMplMd5().ToStr() };
+  for (auto &item : muidStr) {
+    uint32 fieldID = 1;
+    MIRAggConst *entryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), rangeTabEntryType);
+    MUID mplMd5 = GetMUID(item);
+    builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, mplMd5.data.words[0]);
+    builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, mplMd5.data.words[1]);
+    rangeTabConst->AddItem(entryConst, 0);
+  }
+  for (uint32 i = RangeIdx::kVtabAndItab; i < RangeIdx::kOldMaxNum; ++i) {
+    // Use an integer to mark which entry is for which table
+    MIRAggConst *entryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), rangeTabEntryType);
+    uint32 fieldID = 1;
+    if (i == RangeIdx::kGlobalRootlist) {
+      MIRSymbol *st = GetSymbolFromName(namemangler::kGcRootList);
+      if (st == nullptr) {
+        builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, 0);
+        builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, 0);
+        rangeTabConst->AddItem(entryConst, 0);
+        continue;
+      }
+    }
+    builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, i);
+    builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, i);
+    rangeTabConst->AddItem(entryConst, 0);
+  }
+  // Please refer to mrt/compiler-rt/include/mpl_linker.h for the layout
+  std::vector<MIRSymbol*> workList = {
+      funcDefTabSym,
+      funcDefOrigTabSym,
+      funcInfTabSym,
+      funcUndefTabSym,
+      dataDefTabSym,
+      dataDefOrigTabSym,
+      dataUndefTabSym,
+      funcDefMuidTabSym,
+      funcUndefMuidTabSym,
+      dataDefMuidTabSym,
+      dataUndefMuidTabSym,
+      funcMuidIdxTabSym,
+      funcProfileTabSym
+  };
+  InitRangeTabUseSym(workList, rangeTabEntryType, *rangeTabConst);
+  for (int i = RangeIdx::kOldMaxNum + 1; i < RangeIdx::kNewMaxNum; ++i) {
+    uint32 fieldID = 1;
+    MIRAggConst *entryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), rangeTabEntryType);
+    builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, i);
+    builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, i);
+    rangeTabConst->AddItem(entryConst, 0);
+  }
+  std::string bbProfileName = namemangler::kBBProfileTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+  MIRSymbol *funcProfCounterTabSym = GetSymbolFromName(bbProfileName);
+  std::vector<MIRSymbol*> irProfWorkList = {
+    funcProfInfTabSym,
+    funcProfCounterTabSym
+  };
+  InitRangeTabUseSym(irProfWorkList, rangeTabEntryType, *rangeTabConst);
+  if (!rangeTabConst->GetConstVec().empty()) {
+    rangeArrayType.SetSizeArrayItem(0, rangeTabConst->GetConstVec().size());
+    std::string rangeTabName = namemangler::kMuidRangeTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    rangeTabSym = builder->CreateGlobalDecl(rangeTabName, rangeArrayType);
+    rangeTabSym->SetKonst(rangeTabConst);
+    rangeTabSym->SetStorageClass(kScFstatic);
+  }
+}
+
+uint32 MUIDReplacement::FindIndexFromDefTable(const MIRSymbol &mirSymbol, bool isFunc) {
+  MUID muid = GetMUID(mirSymbol.GetName());
+  if (isFunc) {
+    CHECK_FATAL(defMuidIdxMap.find(muid) != defMuidIdxMap.end(), "Local function %s not found in funcDefMap",
+                mirSymbol.GetName().c_str());
+    return defMuidIdxMap[muid];
+  } else {
+    CHECK_FATAL(dataDefMap.find(muid) != dataDefMap.end(), "Local variable %s not found in dataDefMap",
+                mirSymbol.GetName().c_str());
+    return dataDefMap[muid].second;
+  }
+}
+
+uint32 MUIDReplacement::FindIndexFromUndefTable(const MIRSymbol &mirSymbol, bool isFunc) {
+  MUID muid = GetMUID(mirSymbol.GetName());
+  if (isFunc) {
+    CHECK_FATAL(funcUndefMap.find(muid) != funcUndefMap.end(), "Extern function %s not found in funcUndefMap",
+                mirSymbol.GetName().c_str());
+    return funcUndefMap[muid].second;
+  } else {
+    CHECK_FATAL(dataUndefMap.find(muid) != dataUndefMap.end(), "Extern variable %s not found in dataUndefMap",
+                mirSymbol.GetName().c_str());
+    return dataUndefMap[muid].second;
+  }
+}
+
+void MUIDReplacement::ClearVtabItab(const std::string &name) {
+  MIRSymbol *tabSym = GetSymbolFromName(name);
+  if (tabSym == nullptr) {
+    return;
+  }
+  auto *oldConst = tabSym->GetKonst();
+  if (oldConst == nullptr || oldConst->GetKind() != kConstAggConst) {
+    return;
+  }
+  safe_cast<MIRAggConst>(oldConst)->GetConstVec().clear();
+}
+
+void MUIDReplacement::ReplaceFuncTable(const std::string &name) {
+  MIRSymbol *tabSym = GetSymbolFromName(name);
+  if (tabSym == nullptr) {
+    return;
+  }
+  auto *oldConst = tabSym->GetKonst();
+  if (oldConst == nullptr || oldConst->GetKind() != kConstAggConst) {
+    return;
+  }
+  bool isVtab = false;
+  if (tabSym->GetName().find(VTAB_PREFIX_STR) == 0) {
+    isVtab = true;
+  }
+  for (auto *&oldTabEntry : safe_cast<MIRAggConst>(oldConst)->GetConstVec()) {
+    CHECK_NULL_FATAL(oldTabEntry);
+    if (oldTabEntry->GetKind() == kConstAggConst) {
+      auto *aggrC = static_cast<MIRAggConst*>(oldTabEntry);
+      for (size_t i = 0; i < aggrC->GetConstVec().size(); ++i) {
+        ReplaceAddroffuncConst(aggrC->GetConstVecItem(i), i + 1, isVtab);
+      }
+    } else if (oldTabEntry->GetKind() == kConstAddrofFunc) {
+      ReplaceAddroffuncConst(oldTabEntry, 0xffffffff, isVtab);
+    }
+  }
+}
+
+void MUIDReplacement::ReplaceAddroffuncConst(MIRConst *&entry, uint32 fieldID, bool isVtab = false) {
+  CHECK_NULL_FATAL(entry);
+  if (entry->GetKind() != kConstAddrofFunc) {
+    return;
+  }
+  MIRType &voidType = *GlobalTables::GetTypeTable().GetVoidPtr();
+  auto *funcAddr = static_cast<MIRAddroffuncConst*>(entry);
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(funcAddr->GetValue());
+  uint64 offset = 0;
+  MIRIntConst *constNode = nullptr;
+  if (func->GetBody() != nullptr) {
+    ASSERT(func->GetFuncSymbol() != nullptr, "null ptr check!");
+    offset = FindIndexFromDefTable(*(func->GetFuncSymbol()), true);
+    // Left shifting is needed because in itable 0 and 1 are reserved.
+    // 0 marks no entry and 1 marks a conflict.
+    // The second least significant bit is set to 1, indicating
+    // this is an index into the funcDefTab
+    constexpr uint64 idxIntoFuncDefTabFlag = 2u;
+    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        static_cast<int64>(((offset + 1) << KReservedBits) + idxIntoFuncDefTabFlag), voidType);
+  } else if (isVtab && func->IsAbstract()) {
+    MIRType &type = *GlobalTables::GetTypeTable().GetVoidPtr();
+    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, type);
+  } else {
+    ASSERT(func->GetFuncSymbol() != nullptr, "null ptr check!");
+    offset = FindIndexFromUndefTable(*(func->GetFuncSymbol()), true);
+    // The second least significant bit is set to 0, indicating
+    // this is an index into the funcUndefTab
+    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>((offset + 1) << KReservedBits),
+                                                                     voidType);
+  }
+  if (fieldID != 0xffffffff) {
+    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(constNode->GetExtValue(),
+                                                                     constNode->GetType());
+  }
+  entry = constNode;
+}
+
+void MUIDReplacement::ReplaceFieldTypeTable(const std::string &name) {
+  MIRSymbol *tabSym = GetSymbolFromName(name);
+  if (tabSym == nullptr) {
+    return;
+  }
+  auto *oldConst = safe_cast<MIRAggConst>(tabSym->GetKonst());
+  if (oldConst == nullptr) {
+    return;
+  }
+  for (MIRConst *&oldTabEntry : oldConst->GetConstVec()) {
+    CHECK_NULL_FATAL(oldTabEntry);
+    if (oldTabEntry->GetKind() == kConstAggConst) {
+      uint32 index = static_cast<uint32>(FieldProperty::kPClassType);
+      auto *aggrC = static_cast<MIRAggConst*>(oldTabEntry);
+      CHECK_NULL_FATAL(aggrC->GetConstVecItem(index));
+      if (aggrC->GetConstVecItem(index)->GetKind() == kConstInt) {
+        continue;
+      } else {
+        ReplaceAddrofConst(aggrC->GetConstVecItem(index), true);
+        MIRConstPtr mirConst = aggrC->GetConstVecItem(index);
+        CHECK_NULL_FATAL(mirConst);
+        if (mirConst->GetKind() == kConstInt) {
+          MIRIntConst *newIntConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+              static_cast<MIRIntConst*>(mirConst)->GetExtValue(), mirConst->GetType());
+          aggrC->SetItem(index, newIntConst, index + 1);
+        } else {
+          aggrC->SetFieldIdOfElement(index, index + 1);
+        }
+      }
+    } else if (oldTabEntry->GetKind() == kConstAddrof) {
+      ReplaceAddrofConst(oldTabEntry, true);
+    }
+  }
+}
+
+void MUIDReplacement::ReplaceDataTable(const std::string &name) {
+  MIRSymbol *tabSym = GetSymbolFromName(name);
+  if (tabSym == nullptr) {
+    return;
+  }
+  auto *oldConst = safe_cast<MIRAggConst>(tabSym->GetKonst());
+  if (oldConst == nullptr) {
+    return;
+  }
+  for (MIRConst *&oldTabEntry : oldConst->GetConstVec()) {
+    CHECK_NULL_FATAL(oldTabEntry);
+    if (oldTabEntry->GetKind() == kConstAggConst) {
+      auto *aggrC = static_cast<MIRAggConst*>(oldTabEntry);
+      for (uint32 i = 0; i < static_cast<uint32>(aggrC->GetConstVec().size()); ++i) {
+        CHECK_NULL_FATAL(aggrC->GetConstVecItem(i));
+        ReplaceAddrofConst(aggrC->GetConstVecItem(i));
+        MIRConstPtr mirConst = aggrC->GetConstVecItem(i);
+        if (mirConst->GetKind() == kConstInt) {
+          MIRIntConst *newIntConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+              static_cast<MIRIntConst*>(mirConst)->GetExtValue(), mirConst->GetType());
+          aggrC->SetItem(i, newIntConst, i + 1);
+        } else {
+          aggrC->SetFieldIdOfElement(i, i + 1);
+        }
+      }
+    } else if (oldTabEntry->GetKind() == kConstAddrof) {
+      ReplaceAddrofConst(oldTabEntry);
+    }
+  }
+}
+
+void MUIDReplacement::ReplaceDecoupleKeyTable(MIRAggConst* oldConst) {
+  if (oldConst == nullptr) {
+    return;
+  }
+  for (MIRConst *&oldTabEntry : oldConst->GetConstVec()) {
+    CHECK_NULL_FATAL(oldTabEntry);
+    if (oldTabEntry->GetKind() == kConstAggConst) {
+      auto *aggrC = static_cast<MIRAggConst*>(oldTabEntry);
+      for (uint32 i = 0; i < static_cast<uint32>(aggrC->GetConstVec().size()); ++i) {
+        CHECK_NULL_FATAL(aggrC->GetConstVecItem(i));
+        if (aggrC->GetConstVecItem(i)->GetKind() == kConstAggConst) {
+          ReplaceDecoupleKeyTable(safe_cast<MIRAggConst>(aggrC->GetConstVecItem(i)));
+        } else {
+          ReplaceAddrofConst(aggrC->GetConstVecItem(i));
+          MIRConstPtr mirConst = aggrC->GetConstVecItem(i);
+          if (mirConst->GetKind() == kConstInt) {
+            MIRIntConst *newIntConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+                static_cast<MIRIntConst*>(mirConst)->GetExtValue(), mirConst->GetType());
+            aggrC->SetItem(i, newIntConst, i + 1);
+          } else {
+            aggrC->SetFieldIdOfElement(i, i + 1);
+          }
+        }
+      }
+    } else if (oldTabEntry->GetKind() == kConstAddrof) {
+      ReplaceAddrofConst(oldTabEntry);
+    }
+  }
+}
+
+void MUIDReplacement::ReplaceAddrofConst(MIRConst *&entry, bool muidIndex32Mod) {
+  if (entry->GetKind() != kConstAddrof) {
+    return;
+  }
+  MIRType &voidType = *GlobalTables::GetTypeTable().GetVoidPtr();
+  auto *addr = static_cast<MIRAddrofConst*>(entry);
+  MIRSymbol *addrSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(addr->GetSymbolIndex().Idx());
+  CHECK_NULL_FATAL(addrSym);
+  if (!addrSym->IsReflectionClassInfo() && !addrSym->IsStatic()) {
+    return;
+  }
+  uint64 offset = 0;
+  MIRIntConst *constNode = nullptr;
+  if (addrSym->GetStorageClass() != kScExtern) {
+    offset = FindIndexFromDefTable(*addrSym, false);
+    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(GetDefOrUndefOffsetWithMask(offset, true,
+                                                                     muidIndex32Mod), voidType);
+  } else {
+    offset = FindIndexFromUndefTable(*addrSym, false);
+    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(GetDefOrUndefOffsetWithMask(offset, false,
+                                                                     muidIndex32Mod), voidType);
+  }
+  entry = constNode;
+}
+
+int64 MUIDReplacement::GetDefOrUndefOffsetWithMask(uint64 offset, bool isDef, bool muidIndex32Mod) const {
+  if (isDef) {
+    if (muidIndex32Mod) {
+      return static_cast<int64>(static_cast<uint32>(offset) | kFromDefIndexMask32Mod);
+    } else {
+#ifdef USE_ARM32_MACRO
+      return static_cast<int64>((offset << KReservedBits) + kLinkerRefDef);
+#else
+      return static_cast<int64>(offset | kFromDefIndexMask);
+#endif
+    }
+  } else {
+    if (muidIndex32Mod) {
+      return static_cast<int64>(static_cast<uint32>(offset) | kFromUndefIndexMask32Mod);
+    } else {
+#ifdef USE_ARM32_MACRO
+      return static_cast<int64>((offset << KReservedBits) + kLinkerRefUnDef);
+#else
+      return static_cast<int64>(offset | kFromUndefIndexMask);
+#endif
+    }
+  }
+}
+
+void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction &currentFunc, StmtNode &stmt) {
+  PUIdx puidx;
+  CallNode *callNode = nullptr;
+  DassignNode *dassignNode = nullptr;
+  RegassignNode *regassignNode = nullptr;
+  if (stmt.GetOpCode() == OP_callassigned || stmt.GetOpCode() == OP_call) {
+    callNode = static_cast<CallNode*>(&stmt);
+    puidx = callNode->GetPUIdx();
+  } else if (stmt.GetOpCode() == OP_dassign) {
+    dassignNode = static_cast<DassignNode*>(&stmt);
+    if (dassignNode->GetRHS()->GetOpCode() != OP_addroffunc) {
+      return;
+    }
+    puidx = static_cast<AddroffuncNode*>(dassignNode->GetRHS())->GetPUIdx();
+  } else if (stmt.GetOpCode() == OP_regassign) {
+    regassignNode = static_cast<RegassignNode*>(&stmt);
+    if (regassignNode->Opnd(0)->GetOpCode() != OP_addroffunc) {
+      return;
+    }
+    puidx = static_cast<AddroffuncNode*>(regassignNode->Opnd(0))->GetPUIdx();
+  } else {
+    CHECK_FATAL(false, "unexpected stmt type in ReplaceDirectInvokeOrAddroffunc");
+  }
+  MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puidx);
+  if (!calleeFunc->IsJava() && calleeFunc->GetBaseClassName().empty()) {
+    return;
+  }
+  // Load the function pointer
+  AddrofNode *baseExpr = nullptr;
+  uint32 index = 0;
+  MIRArrayType *arrayType = nullptr;
+  if (calleeFunc->GetBody() != nullptr) {
+    // Local function is accessed through funcDefTab
+    // Add a comment to store the original function name
+    std::string commentLabel = namemangler::kMarkMuidFuncDefStr + calleeFunc->GetName();
+    currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel));
+
+    std::string moduleName = GetMIRModule().GetFileNameAsPostfix();
+    std::string baseName = calleeFunc->GetBaseClassName();
+    ASSERT(funcDefTabSym != nullptr, "null ptr check!");
+    baseExpr = builder->CreateExprAddrof(0, *funcDefTabSym, GetMIRModule().GetMemPool());
+    ASSERT(calleeFunc->GetFuncSymbol() != nullptr, "null ptr check!");
+    index = FindIndexFromDefTable(*(calleeFunc->GetFuncSymbol()), true);
+    arrayType = static_cast<MIRArrayType*>(funcDefTabSym->GetType());
+  } else {
+    // External function is accessed through funcUndefTab
+    // Add a comment to store the original function name
+    std::string commentLabel = namemangler::kMarkMuidFuncUndefStr + calleeFunc->GetName();
+    currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel));
+
+    ASSERT(funcUndefTabSym != nullptr, "null ptr check!");
+    baseExpr = builder->CreateExprAddrof(0, *funcUndefTabSym, GetMIRModule().GetMemPool());
+    ASSERT(calleeFunc->GetFuncSymbol() != nullptr, "null ptr check!");
+    index = FindIndexFromUndefTable(*(calleeFunc->GetFuncSymbol()), true);
+    arrayType = static_cast<MIRArrayType*>(funcUndefTabSym->GetType());
+  }
+  ConstvalNode *offsetExpr = GetConstvalNode(index);
+  ArrayNode *arrayExpr = builder->CreateExprArray(*arrayType, baseExpr, offsetExpr);
+  arrayExpr->SetBoundsCheck(false);
+  MIRType *elemType = arrayType->GetElemType();
+  BaseNode *ireadPtrExpr =
+      builder->CreateExprIread(*GlobalTables::GetTypeTable().GetVoidPtr(),
+                               *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 1, arrayExpr);
+  PregIdx funcPtrPreg = 0;
+  MIRSymbol *funcPtrSym = nullptr;
+  BaseNode *readFuncPtr = nullptr;
+  if (Options::usePreg) {
+    funcPtrPreg = currentFunc.GetPregTab()->CreatePreg(PTY_ptr);
+    RegassignNode *funcPtrPregAssign = builder->CreateStmtRegassign(PTY_ptr, funcPtrPreg, ireadPtrExpr);
+    currentFunc.GetBody()->InsertBefore(&stmt, funcPtrPregAssign);
+    readFuncPtr = builder->CreateExprRegread(PTY_ptr, funcPtrPreg);
+  } else {
+    funcPtrSym = builder->GetOrCreateLocalDecl(kMuidSymPtrStr, *GlobalTables::GetTypeTable().GetVoidPtr());
+    DassignNode *addrNode = builder->CreateStmtDassign(*funcPtrSym, 0, ireadPtrExpr);
+    currentFunc.GetBody()->InsertBefore(&stmt, addrNode);
+    readFuncPtr = builder->CreateExprDread(*funcPtrSym);
+  }
+  if (callNode != nullptr) {
+    // Create icallNode to replace callNode
+    IcallNode *icallNode = GetMIRModule().CurFuncCodeMemPool()->New<IcallNode>(
+      GetMIRModule(), callNode->GetOpCode() == OP_call ? OP_icall : OP_icallassigned);
+    icallNode->SetNumOpnds(callNode->GetNumOpnds() + 1);
+    icallNode->GetNopnd().resize(icallNode->GetNumOpnds());
+    icallNode->SetNOpndAt(0, readFuncPtr);
+    for (size_t i = 1; i < icallNode->GetNopndSize(); ++i) {
+      icallNode->SetNOpndAt(i, callNode->GetNopnd()[i - 1]->CloneTree(GetMIRModule().GetCurFuncCodeMPAllocator()));
+    }
+    icallNode->SetRetTyIdx(calleeFunc->GetReturnTyIdx());
+    if (callNode->GetOpCode() == OP_callassigned) {
+      icallNode->SetReturnVec(callNode->GetReturnVec());
+    }
+    currentFunc.GetBody()->ReplaceStmt1WithStmt2(callNode, icallNode);
+  } else if (dassignNode != nullptr) {
+    dassignNode->SetRHS(readFuncPtr);
+  } else if (regassignNode != nullptr) {
+    regassignNode->SetOpnd(readFuncPtr, 0);
+  }
+}
+
+void MUIDReplacement::ReplaceDassign(MIRFunction &currentFunc, const DassignNode &dassignNode) {
+  MIRSymbol *mirSymbol = currentFunc.GetLocalOrGlobalSymbol(dassignNode.GetStIdx());
+  ASSERT_NOT_NULL(mirSymbol);
+  if (!mirSymbol->IsStatic()) {
+    return;
+  }
+  // Add a comment to store the original symbol name
+  currentFunc.GetBody()->InsertBefore(&dassignNode, builder->CreateStmtComment("Assign to: " + mirSymbol->GetName()));
+  // Load the symbol pointer
+  AddrofNode *baseExpr = nullptr;
+  uint32 index = 0;
+  MIRArrayType *arrayType = nullptr;
+  if (mirSymbol->GetStorageClass() != kScExtern) {
+    // Local static member is accessed through dataDefTab
+    baseExpr = builder->CreateExprAddrof(0, *dataDefTabSym);
+    index = FindIndexFromDefTable(*mirSymbol, false);
+    arrayType = static_cast<MIRArrayType*>(dataDefTabSym->GetType());
+  } else {
+    // External static member is accessed through dataUndefTab
+    baseExpr = builder->CreateExprAddrof(0, *dataUndefTabSym);
+    index = FindIndexFromUndefTable(*mirSymbol, false);
+    arrayType = static_cast<MIRArrayType*>(dataUndefTabSym->GetType());
+  }
+  ConstvalNode *offsetExpr = GetConstvalNode(index);
+  ArrayNode *arrayExpr = builder->CreateExprArray(*arrayType, baseExpr, offsetExpr);
+  arrayExpr->SetBoundsCheck(false);
+  MIRType *elemType = arrayType->GetElemType();
+  MIRType *mVoidPtr = GlobalTables::GetTypeTable().GetVoidPtr();
+  CHECK_FATAL(mVoidPtr != nullptr, "null ptr check");
+  BaseNode *ireadPtrExpr =
+      builder->CreateExprIread(*mVoidPtr, *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType),
+                               1, arrayExpr);
+  PregIdx symPtrPreg = 0;
+  MIRSymbol *symPtrSym = nullptr;
+  BaseNode *destExpr = nullptr;
+  if (Options::usePreg) {
+    symPtrPreg = currentFunc.GetPregTab()->CreatePreg(PTY_ptr);
+    RegassignNode *symPtrPregAssign = builder->CreateStmtRegassign(PTY_ptr, symPtrPreg, ireadPtrExpr);
+    currentFunc.GetBody()->InsertBefore(&dassignNode, symPtrPregAssign);
+    destExpr = builder->CreateExprRegread(PTY_ptr, symPtrPreg);
+  } else {
+    symPtrSym = builder->GetOrCreateLocalDecl(kMuidFuncPtrStr, *mVoidPtr);
+    DassignNode *addrNode = builder->CreateStmtDassign(*symPtrSym, 0, ireadPtrExpr);
+    currentFunc.GetBody()->InsertBefore(&dassignNode, addrNode);
+    destExpr = builder->CreateExprDread(*symPtrSym);
+  }
+  // Replace dassignNode with iassignNode
+  TypeAttrs attrs;
+  if (mirSymbol->IsVolatile()) {
+    attrs.SetAttr(ATTR_volatile);
+  }
+  MIRType *destPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirSymbol->GetType(), PTY_ptr, attrs);
+  StmtNode *iassignNode = builder->CreateStmtIassign(*destPtrType, 0, destExpr, dassignNode.Opnd(0));
+  currentFunc.GetBody()->ReplaceStmt1WithStmt2(&dassignNode, iassignNode);
+}
+
+void MUIDReplacement::CollectFieldCallSite() {
+  for (MIRFunction *mirFunc : GetMIRModule().GetFunctionList()) {
+    if (mirFunc->GetBody() == nullptr) {
+      continue;
+    }
+    SetCurrentFunction(*mirFunc);
+    StmtNode *stmt = mirFunc->GetBody()->GetFirst();
+    StmtNode *next = nullptr;
+    while (stmt != nullptr) {
+      next = stmt->GetNext();
+      CollectDreadStmt(mirFunc, mirFunc->GetBody(), stmt);
+      stmt = next;
+    }
+  }
+}
+
+void MUIDReplacement::CollectDreadStmt(MIRFunction *currentFunc, BlockNode *block, StmtNode *stmt) {
+  if (currentFunc == nullptr || stmt == nullptr) {
+    return;
+  }
+  switch (stmt->GetOpCode()) {
+    case OP_if: {
+      auto *iNode = static_cast<IfStmtNode*>(stmt);
+      ASSERT(block != nullptr, "null ptr check!");
+      iNode->SetOpnd(CollectDreadExpr(currentFunc, *block, stmt, iNode->Opnd(0)), 0);
+      CollectDreadStmt(currentFunc, nullptr, iNode->GetThenPart());
+      CollectDreadStmt(currentFunc, nullptr, iNode->GetElsePart());
+      break;
+    }
+    case OP_while: {
+      auto *wNode = static_cast<WhileStmtNode*>(stmt);
+      ASSERT(block != nullptr, "null ptr check!");
+      wNode->SetOpnd(CollectDreadExpr(currentFunc, *block, stmt, wNode->Opnd(0)), 0);
+      CollectDreadStmt(currentFunc, nullptr, wNode->GetBody());
+      break;
+    }
+    case OP_block: {
+      auto *bNode = static_cast<BlockNode*>(stmt);
+      for (auto &stmtNode : bNode->GetStmtNodes()) {
+        CollectDreadStmt(currentFunc, bNode, &stmtNode);
+      }
+      break;
+    }
+    default:
+      ASSERT(block != nullptr, "null ptr check!");
+      for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+        stmt->SetOpnd(CollectDreadExpr(currentFunc, *block, stmt, stmt->Opnd(i)), i);
+      }
+  }
+}
+
+void MUIDReplacement::ReplaceDreadStmt(MIRFunction *currentFunc, StmtNode *stmt) {
+  if (currentFunc == nullptr || stmt == nullptr) {
+    return;
+  }
+  switch (stmt->GetOpCode()) {
+    case OP_if: {
+      auto *iNode = static_cast<IfStmtNode*>(stmt);
+      iNode->SetOpnd(ReplaceDreadExpr(currentFunc, stmt, iNode->Opnd(0)), 0);
+      ReplaceDreadStmt(currentFunc, iNode->GetThenPart());
+      ReplaceDreadStmt(currentFunc, iNode->GetElsePart());
+      break;
+    }
+    case OP_while: {
+      auto *wNode = static_cast<WhileStmtNode*>(stmt);
+      wNode->SetOpnd(ReplaceDreadExpr(currentFunc, stmt, wNode->Opnd(0)), 0);
+      ReplaceDreadStmt(currentFunc, wNode->GetBody());
+      break;
+    }
+    case OP_block: {
+      auto *bNode = static_cast<BlockNode*>(stmt);
+      for (auto &s : bNode->GetStmtNodes()) {
+        ReplaceDreadStmt(currentFunc, &s);
+      }
+      break;
+    }
+    default: {
+      for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+        stmt->SetOpnd(ReplaceDreadExpr(currentFunc, stmt, stmt->Opnd(i)), i);
+      }
+      break;
+    }
+  }
+}
+
+BaseNode *MUIDReplacement::CollectDreadExpr(MIRFunction *currentFunc, BlockNode &block, StmtNode *stmt,
+                                            BaseNode *expr) {
+  if (currentFunc == nullptr || stmt == nullptr || expr == nullptr) {
+    return nullptr;
+  }
+  if (expr->GetOpCode() == OP_intrinsicop) {
+    auto *intrinsicsNode = static_cast<IntrinsicopNode*>(expr);
+    if (intrinsicsNode->GetIntrinsic() == INTRN_MPL_READ_OVTABLE_ENTRY ||
+        intrinsicsNode->GetIntrinsic() == INTRN_MPL_READ_OVTABLE_ENTRY2) {
+      std::string valueSymName = namemangler::kOffsetTabStr + GetMIRModule().GetFileNameAsPostfix();
+      MIRSymbol *offsetTableSym = GetSymbolFromName(valueSymName);
+      ASSERT(offsetTableSym != nullptr, "null ptr check");
+      auto *arrayType = static_cast<MIRArrayType*>(offsetTableSym->GetType());
+      MIRType *elemType = arrayType->GetElemType();
+      IreadNode *iread = builder->CreateExprIread(*GlobalTables::GetTypeTable().GetUInt32(),
+                                                  *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 1,
+                                                  intrinsicsNode->GetNopndAt(0));
+      if (intrinsicsNode->GetIntrinsic() == INTRN_MPL_READ_OVTABLE_ENTRY ||
+          intrinsicsNode->GetIntrinsic() == INTRN_MPL_READ_OVTABLE_ENTRY2) {
+        return iread;
+      } else {
+        ASSERT(false, "Wrong lazy binding option");
+      }
+    }
+  }
+  for (size_t i = 0; i < expr->NumOpnds(); ++i) {
+    expr->SetOpnd(CollectDreadExpr(currentFunc, block, stmt, expr->Opnd(i)), i);
+  }
+  return expr;
+}
+
+// Turn dread into iread
+BaseNode *MUIDReplacement::ReplaceDreadExpr(MIRFunction *currentFunc, StmtNode *stmt, BaseNode *expr) {
+  if (currentFunc == nullptr || stmt == nullptr || expr == nullptr) {
+    return nullptr;
+  }
+  size_t i = 0;
+  UnaryNode *uOpnd = nullptr;
+  BinaryNode *bopnds = nullptr;
+  TernaryNode *topnds = nullptr;
+  switch (expr->GetOpCode()) {
+    case OP_dread:
+    case OP_addrof: {
+      return ReplaceDread(*currentFunc, stmt, expr);
+    }
+    case OP_select: {
+      topnds = static_cast<TernaryNode*>(expr);
+      for (i = 0; i < topnds->NumOpnds(); ++i) {
+        topnds->SetOpnd(ReplaceDreadExpr(currentFunc, stmt, topnds->Opnd(i)), i);
+      }
+      break;
+    }
+    default: {
+      if (expr->IsUnaryNode()) {
+        uOpnd = static_cast<UnaryNode*>(expr);
+        uOpnd->SetOpnd(ReplaceDreadExpr(currentFunc, stmt, uOpnd->Opnd(0)), i);
+      } else if (expr->IsBinaryNode()) {
+        bopnds = static_cast<BinaryNode*>(expr);
+        for (i = 0; i < bopnds->NumOpnds(); ++i) {
+          bopnds->SetOpnd(ReplaceDreadExpr(currentFunc, stmt, bopnds->GetBOpnd(i)), i);
+        }
+      } else {
+        for (i = 0; i < expr->NumOpnds(); ++i) {
+          expr->SetOpnd(ReplaceDreadExpr(currentFunc, stmt, expr->Opnd(i)), i);
+        }
+      }
+      break;
+    }
+  }
+  return expr;
+}
+
+BaseNode *MUIDReplacement::ReplaceDread(MIRFunction &currentFunc, const StmtNode *stmt, BaseNode *opnd) {
+  if (opnd == nullptr || (opnd->GetOpCode() != OP_dread && opnd->GetOpCode() != OP_addrof)) {
+    return opnd;
+  }
+  auto *dreadNode = static_cast<DreadNode*>(opnd);
+  MIRSymbol *mirSymbol = currentFunc.GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+  ASSERT(mirSymbol != nullptr, "null ptr check!");
+  if (!mirSymbol->IsStatic()) {
+    return opnd;
+  }
+  // Add a comment to store the original symbol name
+  currentFunc.GetBody()->InsertBefore(stmt, builder->CreateStmtComment("Read from: " + mirSymbol->GetName()));
+  // Load the symbol pointer
+  AddrofNode *baseExpr = nullptr;
+  uint32 index = 0;
+  MIRArrayType *arrayType = nullptr;
+  if (mirSymbol->GetStorageClass() != kScExtern) {
+    // Local static member is accessed through dataDefTab
+    baseExpr = builder->CreateExprAddrof(0, *dataDefTabSym);
+    index = FindIndexFromDefTable(*mirSymbol, false);
+    arrayType = static_cast<MIRArrayType*>(dataDefTabSym->GetType());
+  } else {
+    // External static member is accessed through dataUndefTab
+    baseExpr = builder->CreateExprAddrof(0, *dataUndefTabSym);
+    index = FindIndexFromUndefTable(*mirSymbol, false);
+    arrayType = static_cast<MIRArrayType*>(dataUndefTabSym->GetType());
+  }
+  ConstvalNode *offsetExpr = GetConstvalNode(index);
+  ArrayNode *arrayExpr = builder->CreateExprArray(*arrayType, baseExpr, offsetExpr);
+  arrayExpr->SetBoundsCheck(false);
+  MIRType *elemType = arrayType->GetElemType();
+  BaseNode *ireadPtrExpr =
+      builder->CreateExprIread(*GlobalTables::GetTypeTable().GetVoidPtr(),
+                               *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 1, arrayExpr);
+  if (opnd->GetOpCode() == OP_addrof) {
+    return ireadPtrExpr;
+  }
+  MIRType *destType = mirSymbol->GetType();
+  ASSERT_NOT_NULL(destType);
+  MIRType *destPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*destType);
+  return builder->CreateExprIread(*destType, *destPtrType, 0, ireadPtrExpr);
+}
+
+void MUIDReplacement::ProcessFunc(MIRFunction *func) {
+  // Libcore-all module is self-contained, so no need to do all these replacement
+  ASSERT(func != nullptr, "null ptr check!");
+  if (isLibcore || func->IsEmpty()) {
+    return;
+  }
+  SetCurrentFunction(*func);
+  StmtNode *stmt = func->GetBody()->GetFirst();
+  StmtNode *next = nullptr;
+  while (stmt != nullptr) {
+    next = stmt->GetNext();
+    ReplaceDreadStmt(func, stmt);
+    // Replace direct func invoke
+    if (stmt->GetOpCode() == OP_callassigned || stmt->GetOpCode() == OP_call) {
+      ReplaceDirectInvokeOrAddroffunc(*func, *stmt);
+    } else if (stmt->GetOpCode() == OP_dassign) {
+      ReplaceDirectInvokeOrAddroffunc(*func, *stmt);
+      auto *dassignNode = static_cast<DassignNode*>(stmt);
+      ReplaceDassign(*func, *dassignNode);
+    } else if (stmt->GetOpCode() == OP_regassign) {
+      ReplaceDirectInvokeOrAddroffunc(*func, *stmt);
+    }
+    stmt = next;
+  }
+}
+
+// Create GC Root
+void MUIDReplacement::GenerateGlobalRootList() {
+  MIRType *voidType = GlobalTables::GetTypeTable().GetVoidPtr();
+  MIRArrayType *arrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*voidType, 0);
+  MIRAggConst *newConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *arrayType);
+  for (StIdx stidx : GetMIRModule().GetSymbolSet()) {
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx());
+    CHECK_FATAL(symbol != nullptr, "symbol is nullptr!");
+    MIRSymKind st = symbol->GetSKind();
+    MIRStorageClass sc = symbol->GetStorageClass();
+    if (!(st == kStVar && sc == kScGlobal)) {
+      continue;
+    }
+    TyIdx typeIdx = symbol->GetTyIdx();
+    MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx);
+    PrimType pty = type->GetPrimType();
+    if (!(pty == PTY_ptr || pty == PTY_ref)) {
+      continue;
+    }
+    // It is a pointer/ref type.  Check its pointed type.
+    if (pty == PTY_ptr) {
+      if (type->GetKind() != kTypePointer) {
+        continue;
+      }
+      auto *pointType = static_cast<MIRPtrType*>(type);
+      MIRType *pointedType = pointType->GetPointedType();
+      if (!(pointedType->GetKind() == kTypeClass)) {
+        continue;
+      }
+    }
+    // Now it is a pointer/ref to a class.  Record it for GC scanning.
+    ASSERT(PTY_ptr < GlobalTables::GetTypeTable().GetTypeTable().size(), "index out of bound");
+    MIRType &ptrType = *GlobalTables::GetTypeTable().GetTypeTable()[PTY_ptr];
+    MIRConst *constNode = GetMIRModule().GetMemPool()->New<MIRAddrofConst>(symbol->GetStIdx(), 0, ptrType);
+    CHECK_FATAL(constNode != nullptr, "constNode is nullptr!");
+    newConst->AddItem(constNode, 0);
+  }
+  std::string gcRootsName = namemangler::kGcRootList;
+  if (!newConst->GetConstVec().empty()) {
+    MIRSymbol *gcRootsSt = builder->CreateSymbol(newConst->GetType().GetTypeIndex(), gcRootsName, kStVar,
+                                                 kScAuto, nullptr, kScopeGlobal);
+    arrayType->SetSizeArrayItem(0, newConst->GetConstVec().size());
+    gcRootsSt->SetKonst(newConst);
+  }
+}
+
+// should use a new pass to generate these information
+void MUIDReplacement::GenerateCompilerVersionNum() {
+  MIRType *ptrType = GlobalTables::GetTypeTable().GetVoidPtr();
+  MIRArrayType &arrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*ptrType, 0);
+  MIRAggConst *newConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), arrayType);
+  MIRType &type = *GlobalTables::GetTypeTable().GetInt32();
+  MIRConst *firstConst =
+      GlobalTables::GetIntConstTable().GetOrCreateIntConst(Version::GetMajorVersion(), type);
+  MIRConst *secondConst =
+      GlobalTables::GetIntConstTable().GetOrCreateIntConst(Version::GetMinorVersion(), type);
+  newConst->AddItem(firstConst, 0);
+  newConst->AddItem(secondConst, 0);
+  std::string symName = namemangler::kCompilerVersionNum + GetMIRModule().GetFileNameAsPostfix();
+  MIRSymbol *versionNum = builder->CreateGlobalDecl(symName, arrayType);
+  versionNum->SetKonst(newConst);
+}
+
+void MUIDReplacement::GenericSourceMuid() {
+  if (Options::sourceMuid != "") {
+    MIRArrayType &arrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetUInt8(), 0);
+    MIRAggConst *newConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), arrayType);
+    for (const char &c : Options::sourceMuid) {
+      MIRConst *charConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          c, *GlobalTables::GetTypeTable().GetUInt8());
+      newConst->AddItem(charConst, 0);
+    }
+
+    MIRType &type = *GlobalTables::GetTypeTable().GetInt64();
+    MIRConst *slotConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, type);
+    newConst->AddItem(slotConst, 0);
+    newConst->AddItem(slotConst, 0);
+    std::string symName = namemangler::kSourceMuid + GetMIRModule().GetFileNameAsPostfix();
+    MIRSymbol *sourceMuid = builder->CreateGlobalDecl(symName, arrayType);
+    sourceMuid->SetKonst(newConst);
+  }
+}
+
+void MUIDReplacement::GenCompilerMfileStatus() {
+  MIRType &type = *GlobalTables::GetTypeTable().GetInt32();
+  MIRConst *intConst =
+      GlobalTables::GetIntConstTable().GetOrCreateIntConst(Options::gcOnly ? 1 : 0, type);
+  std::string symName = namemangler::kCompilerMfileStatus + GetMIRModule().GetFileNameAsPostfix();
+  MIRSymbol *mfileStatus = builder->CreateGlobalDecl(symName.c_str(), type);
+  mfileStatus->SetKonst(intConst);
+}
+
+void MUIDReplacement::GenerateSourceInfo() {
+  for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
+    if (klass->IsClassIncomplete() || klass->IsInterfaceIncomplete()) {
+      continue;
+    }
+    MIRStructType *structType = klass->GetMIRStructType();
+    ASSERT(structType != nullptr, "null ptr check!");
+    if (klass->GetMIRStructType()->IsLocal()) {
+      continue;
+    }
+    for (const MIRPragma *prag : structType->GetPragmaVec()) {
+      const MapleVector<MIRPragmaElement*> &elemVector = prag->GetElementVector();
+      GStrIdx typeStrIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetNameStrIdx();
+      std::string typeName = GlobalTables::GetStrTable().GetStringFromStrIdx(typeStrIdx);
+      if (typeName == "Lharmonyos_2Fannotation_2FInterpreter_3B") {
+        if (prag->GetKind() == kPragmaClass) {
+          int64 firstVal = elemVector[0]->GetI64Val();
+          int64 secondVal = elemVector[1]->GetI64Val();
+          std::string symbolName = CLASSINFO_PREFIX_STR + klass->GetKlassName();
+          MUID muid = GetMUID(symbolName);
+          sourceIndexMap[muid] = SourceIndexPair(firstVal, secondVal);
+        } else if (prag->GetKind() == kPragmaFunc) {
+          std::string funcName = GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx());
+          MUID muid = GetMUID(funcName);
+          uint32 sourceFileIndex = static_cast<uint32>(elemVector[0]->GetI64Val());
+          uint32 sourceClassIndex = static_cast<uint32>(elemVector[1]->GetI64Val());
+          uint32 sourceMethodIndex = static_cast<uint32>(elemVector[2]->GetI64Val());
+          bool isVirtual = elemVector[3]->GetI64Val() == 1 ? true : false;
+          SourceFileMethod methodInf = {sourceFileIndex, sourceClassIndex, sourceMethodIndex, isVirtual};
+          (void)sourceFileMethodMap.emplace(std::pair<MUID, SourceFileMethod>(muid, methodInf));
+        } else if (prag->GetKind() == kPragmaField) {
+          std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx());
+          MUID muid = GetMUID(fieldName);
+          uint32 sourceFileIndex = static_cast<uint32>(elemVector[0]->GetI64Val());
+          uint32 sourceClassIndex = static_cast<uint32>(elemVector[1]->GetI64Val());
+          uint32 sourceFieldIndex = static_cast<uint32>(elemVector[2]->GetI64Val());
+          SourceFileField fieldInf = {sourceFileIndex, sourceClassIndex, sourceFieldIndex};
+          (void)sourceFileFieldMap.emplace(std::pair<MUID, SourceFileField>(muid, fieldInf));
+        }
+      }
+    }
+  }
+}
+
+void MUIDReplacement::ReleasePragmaMemPool() {
+  for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
+    MIRStructType *mirStruct = klass->GetMIRStructType();
+    mirStruct->GetPragmaVec().clear();
+    mirStruct->GetPragmaVec().shrink_to_fit();
+  }
+}
+
+void MUIDReplacement::GenerateTables() {
+  GenerateGlobalRootList();
+  if (Options::partialAot) {
+    GenerateSourceInfo();
+  }
+  if (Options::buildApp) {
+    CollectFieldCallSite();
+  }
+  CollectFuncAndData();
+  ReleasePragmaMemPool();
+  CollectSuperClassArraySymbolData();
+  CollectArrayClass();
+  GenArrayClassCache();
+
+  GenerateFuncDefTable();
+  GenerateDataDefTable();
+  GenerateUnifiedUndefTable();
+  GenerateRangeTable();
+  // When MapleLinker is enabled, MUIDReplacement becomes the last
+  // phase that updates the reflection string table, thus the table
+  // is emitted here.
+  ReflectionAnalysis::GenStrTab(GetMIRModule());
+
+  // Replace super class array
+  for (auto superArraySymbol : superClassArraySymbolSet) {
+    ReplaceDataTable(superArraySymbol->GetName());
+  }
+  // Replace undef entries in vtab/itab/reflectionMetaData
+  for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
+    ReplaceFieldTypeTable(namemangler::kFieldsInfoPrefixStr + klass->GetKlassName());
+    if (Options::buildApp && !Options::genVtabAndItabForDecouple && klass->GetNeedDecoupling()) {
+      ClearVtabItab(VTAB_PREFIX_STR + klass->GetKlassName());
+      ClearVtabItab(ITAB_PREFIX_STR + klass->GetKlassName());
+      ClearVtabItab(ITAB_CONFLICT_PREFIX_STR + klass->GetKlassName());
+    } else {
+      ReplaceFuncTable(VTAB_PREFIX_STR + klass->GetKlassName());
+      ReplaceFuncTable(ITAB_PREFIX_STR + klass->GetKlassName());
+      ReplaceFuncTable(ITAB_CONFLICT_PREFIX_STR + klass->GetKlassName());
+    }
+  }
+  ReplaceDataTable(namemangler::kGcRootList);
+  if (Options::buildApp) {
+    // ReplaceVtableOffsetTable
+    ReplaceDataTable(namemangler::kVtabOffsetTabStr + GetMIRModule().GetFileNameAsPostfix());
+    // ReplaceFieldOffsetTable
+    ReplaceDataTable(namemangler::kFieldOffsetTabStr + GetMIRModule().GetFileNameAsPostfix());
+  }
+  if (Options::decoupleStatic) {
+    MIRSymbol *tabSym = GetSymbolFromName(namemangler::kDecoupleStaticKeyStr + GetMIRModule().GetFileNameAsPostfix());
+    if (tabSym == nullptr) {
+      return;
+    }
+    ReplaceDecoupleKeyTable(static_cast<MIRAggConst*>(tabSym->GetKonst()));
+  }
+  // Set the flag for decouple
+  {
+    MIRType &type = *GlobalTables::GetTypeTable().GetVoidPtr();
+    uint64 value = 0;
+    if (Options::buildApp) {
+      value = Options::buildApp;
+      if (Options::lazyBinding) {
+        value = kDecoupleAndLazy;
+      }
+    }
+    if (Options::decoupleStatic) {
+      value |= 0x4;
+    }
+    MIRConst *newConst =
+        GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(value), type);
+    std::string decoupleOption = namemangler::kDecoupleOption + GetMIRModule().GetFileNameAsPostfix();
+    MIRSymbol *decoupleSt = builder->CreateGlobalDecl(decoupleOption, type);
+    decoupleSt->SetKonst(newConst);
+  }
+  GenericSourceMuid();
+  GenCompilerMfileStatus();
+  GenerateCompilerVersionNum();
+}
+
+bool M2MMuidReplacement::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(MUIDReplacement, m)
+  return true;
+}
+
+void M2MMuidReplacement::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/native_stub_func.cpp b/src/mapleall/mpl2mpl/src/native_stub_func.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0aaf7b750597f4814a4d427ad660a92a50eabbe7
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/native_stub_func.cpp
@@ -0,0 +1,724 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "native_stub_func.h"
+#include <iostream>
+#include <fstream>
+#include "namemangler.h"
+#include "vtable_analysis.h"
+#include "reflection_analysis.h"
+#include "metadata_layout.h"
+
+// NativeStubFunc
+// This phase is the processing of the java native function. It
+// generates an extra stubFunc for each native function, preparing
+// for the preparations before the actual native function is called,
+// including the parameter mapping, GC preparation, and so on.
+namespace maple {
+NativeStubFuncGeneration::NativeStubFuncGeneration(MIRModule &mod, KlassHierarchy *kh, bool dump)
+    : FuncOptimizeImpl(mod, kh, dump) {
+  MIRType *jstrType = GlobalTables::GetTypeTable().GetOrCreateClassType(
+      namemangler::GetInternalNameLiteral(namemangler::kJavaLangStringStr), mod);
+  auto *jstrPointerType =
+      static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetOrCreatePointerType(*jstrType, PTY_ref));
+  jstrPointerTypeIdx = jstrPointerType->GetTypeIndex();
+  LoadNativeFuncProperty();
+  GenerateRegTableEntryType();
+  GenerateHelperFuncDecl();
+  GenerateRegFuncTabEntryType();
+  InitStaticBindingMethodList();
+}
+
+MIRFunction &NativeStubFuncGeneration::GetOrCreateDefaultNativeFunc(MIRFunction &stubFunc) {
+  // If only support dynamic binding , we won't stub any weak symbols
+  if (Options::regNativeDynamicOnly && !(IsStaticBindingMethod(stubFunc.GetName()))) {
+    return stubFunc;
+  }
+  std::string nativeName = namemangler::NativeJavaName(stubFunc.GetName().c_str());
+  // No need to create a default function with exact arguments here
+  MIRFunction *nativeFunc = builder->GetOrCreateFunction(nativeName, stubFunc.GetReturnTyIdx());
+  ASSERT(nativeFunc != nullptr, "null ptr check!");
+  nativeFunc->GetSrcPosition().SetMplLineNum(stubFunc.GetSrcPosition().MplLineNum());
+  if (nativeFunc->GetBody() == nullptr) {
+    builder->SetCurrentFunction(*nativeFunc);
+    nativeFunc->SetAttr(FUNCATTR_weak);
+    nativeFunc->NewBody();
+    // We would not throw exception here.
+    // Use regnative-dynamic-only option when run case expr14301a_setFields__IF as qemu solution.
+    MIRType *voidPointerType = GlobalTables::GetTypeTable().GetVoidPtr();
+    // It will throw java.lang.UnsatisfiedLinkError, while issue a runtime
+    // warning on Qemu/arm64-server (because it lacks most of the required native libraries)
+    MIRFunction *findNativeFunc = nullptr;
+    if (ReturnsJstr(stubFunc.GetReturnTyIdx())) {
+      // a dialet for string
+      findNativeFunc = builder->GetOrCreateFunction("MCC_CannotFindNativeMethod_S", voidPointerType->GetTypeIndex());
+    } else {
+      MIRType *returnType = stubFunc.GetReturnType();
+      if ((returnType->GetKind() == kTypePointer) &&
+          ((static_cast<MIRPtrType*>(returnType))->GetPointedType()->GetKind() == kTypeJArray)) {
+        // a dialet for array
+        findNativeFunc = builder->GetOrCreateFunction("MCC_CannotFindNativeMethod_A", voidPointerType->GetTypeIndex());
+      }
+    }
+    // default callback
+    if (findNativeFunc == nullptr) {
+      findNativeFunc = builder->GetOrCreateFunction("MCC_CannotFindNativeMethod", voidPointerType->GetTypeIndex());
+    }
+    findNativeFunc->SetAttr(FUNCATTR_nosideeffect);
+    // fatal message parameter
+    std::string nativeSymbolName = stubFunc.GetName();
+    UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(nativeSymbolName);
+    auto *signatureNode = nativeFunc->GetCodeMempool()->New<ConststrNode>(strIdx);
+    signatureNode->SetPrimType(PTY_ptr);
+    MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    args.push_back(signatureNode);
+    CallNode *callGetFindNativeFunc =
+        builder->CreateStmtCallAssigned(findNativeFunc->GetPuidx(), args, nullptr, OP_callassigned);
+    nativeFunc->GetBody()->AddStatement(callGetFindNativeFunc);
+    GetMIRModule().AddFunction(nativeFunc);
+    builder->SetCurrentFunction(stubFunc);
+  }
+  return *nativeFunc;
+}
+
+//   Create function body of the stub func.
+//   syncenter (dread ref %_this or classinfo) // if native func is synchronized
+//   Example: if (not critical_native)
+//     callassigned MCC_PreNativeCall() {Env}
+//     call native_func(Env, [classinfo], oringinal_args){retv}
+//   else
+//     call native_func(oringinal_args){}
+//   if (type of retv is ref)
+//     callassigned &MCC_DecodeReference(dread ref %retv) {dassign ref %retv}
+//   Example: if (not critical_native)
+//     callassigned &__MRT_PostNativeCall (dread ptr %env_ptr) {}
+//   syncexit (dread ref %_this or classinfo) // if native func is synchronized
+//   Example: if (not critical_native)
+//     callassigned &MCC_CheckThrowPendingException () {}
+void NativeStubFuncGeneration::ProcessFunc(MIRFunction *func) {
+  // FUNCATTR_bridge for function to exclude
+  ASSERT(func != nullptr, "null ptr check!");
+  if (func->GetBody() == nullptr || func->GetAttr(FUNCATTR_bridge) ||
+      (!func->GetAttr(FUNCATTR_native) &&
+       !func->GetAttr(FUNCATTR_fast_native) &&
+       !func->GetAttr(FUNCATTR_critical_native))) {
+    return;
+  }
+  SetCurrentFunction(*func);
+  // Has been processed by previous phases, such as simplify.
+  if (func->GetBody()->GetFirst()) {
+    GenerateRegTabEntry(*func);
+    GenerateRegFuncTabEntry();
+    func->UnSetAttr(FUNCATTR_native);
+    func->UnSetAttr(FUNCATTR_fast_native);
+    func->UnSetAttr(FUNCATTR_critical_native);
+    return;
+  }
+  func->GetBody()->ResetBlock();
+  NativeFuncProperty funcProperty;
+  bool isStaticBindingNative = IsStaticBindingMethod(func->GetName());
+  bool existsFuncProperty = GetNativeFuncProperty(func->GetName(), funcProperty);
+  if (existsFuncProperty && funcProperty.jniType == kJniTypeCriticalNative) {
+    func->SetAttr(FUNCATTR_critical_native);
+  }
+  bool needNativeCall = (!func->GetAttr(FUNCATTR_critical_native)) &&
+                        (!existsFuncProperty || funcProperty.jniType == kJniTypeNormal) && !isStaticBindingNative;
+  GStrIdx classObjSymStrIdx =
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(CLASSINFO_PREFIX_STR + func->GetBaseClassName());
+  MIRSymbol *classObjSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(classObjSymStrIdx);
+  ASSERT(classObjSymbol != nullptr, "Classinfo for %s is not found", func->GetBaseClassName().c_str());
+  // Generate MonitorEnter if this is a synchronized method
+  if (func->GetAttr(FUNCATTR_synchronized)) {
+    BaseNode *monitor = nullptr;
+    if (func->GetAttr(FUNCATTR_static)) {
+      // Grab class object
+      monitor = builder->CreateExprAddrof(0, *classObjSymbol);
+    } else {
+      // Grab _this pointer
+      const size_t funcFormalsSize = func->GetFormalCount();
+      CHECK_FATAL(funcFormalsSize > 0, "container check");
+      MIRSymbol *formal0St = func->GetFormal(0);
+      if (formal0St->GetSKind() == kStPreg) {
+        monitor =
+            builder->CreateExprRegread(formal0St->GetType()->GetPrimType(),
+                                       func->GetPregTab()->GetPregIdxFromPregno(formal0St->GetPreg()->GetPregNo()));
+      } else {
+        monitor = builder->CreateExprDread(*formal0St);
+      }
+    }
+    NaryStmtNode *syncEnter = builder->CreateStmtNary(OP_syncenter, monitor);
+    func->GetBody()->AddStatement(syncEnter);
+  }
+  // Get Env pointer through MCC_PreNativeCall(){Env}
+  MIRSymbol *envPtrSym = nullptr;
+  PregIdx envPregIdx = 0;
+  if (Options::usePreg) {
+    envPregIdx = func->GetPregTab()->CreatePreg(PTY_ptr);
+  } else {
+    envPtrSym = builder->CreateSymbol(GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex(), "env_ptr", kStVar,
+                                      kScAuto, func, kScopeLocal);
+  }
+  MapleVector<BaseNode*> args(func->GetCodeMempoolAllocator().Adapter());
+  CallNode *preFuncCall =
+      Options::usePreg
+      ? builder->CreateStmtCallRegassigned(MRTPreNativeFunc->GetPuidx(), args, envPregIdx, OP_callassigned)
+      : builder->CreateStmtCallAssigned(MRTPreNativeFunc->GetPuidx(), args, envPtrSym, OP_callassigned);
+  // Use Env as an arg, MCC_PostNativeCall(Env)
+  args.push_back(Options::usePreg ? (static_cast<BaseNode*>(builder->CreateExprRegread(PTY_ptr, envPregIdx)))
+                                  : (static_cast<BaseNode*>(builder->CreateExprDread(*envPtrSym))));
+  CallNode *postFuncCall =
+      builder->CreateStmtCallAssigned(MRTPostNativeFunc->GetPuidx(), args, nullptr, OP_callassigned);
+
+  MapleVector<BaseNode*> allocCallArgs(func->GetCodeMempoolAllocator().Adapter());
+  if (!func->GetAttr(FUNCATTR_critical_native)) {
+    if (needNativeCall) {
+      func->GetBody()->AddStatement(preFuncCall);
+      if (existsFuncProperty && funcProperty.useEnv == 0) {
+        // set up env
+        allocCallArgs.push_back(builder->CreateIntConst(0, PTY_i32));
+      } else {
+        // set up env
+        allocCallArgs.push_back(Options::usePreg
+                                ? (static_cast<BaseNode*>(builder->CreateExprRegread(PTY_ptr, envPregIdx)))
+                                : (static_cast<BaseNode*>(builder->CreateExprDread(*envPtrSym))));
+      }
+    } else {
+      // set up env
+      allocCallArgs.push_back(builder->CreateIntConst(0, PTY_i32));
+    }
+    // set up class
+    if (func->GetAttr(FUNCATTR_static)) {
+      if (existsFuncProperty && funcProperty.useClassObj == 0) {
+        allocCallArgs.push_back(builder->CreateIntConst(0, PTY_i32));
+      } else {
+        allocCallArgs.push_back(builder->CreateExprAddrof(0, *classObjSymbol));
+      }
+    }
+  }
+  for (uint32 i = 0; i < func->GetFormalCount(); ++i) {
+    auto argSt = func->GetFormal(i);
+    BaseNode *argExpr = nullptr;
+    if (argSt->GetSKind() == kStPreg) {
+      argExpr = builder->CreateExprRegread(argSt->GetType()->GetPrimType(),
+                                           func->GetPregTab()->GetPregIdxFromPregno(argSt->GetPreg()->GetPregNo()));
+    } else {
+      argExpr = builder->CreateExprDread(*argSt);
+    }
+    allocCallArgs.push_back(argExpr);
+  }
+  bool voidRet = (func->GetReturnType()->GetPrimType() == PTY_void);
+  MIRSymbol *stubFuncRet = nullptr;
+  if (!voidRet) {
+    stubFuncRet = builder->CreateSymbol(func->GetReturnTyIdx(), "retvar_stubfunc", kStVar, kScAuto, func, kScopeLocal);
+  }
+  MIRFunction &nativeFunc = GetOrCreateDefaultNativeFunc(*func);
+  if (Options::regNativeFunc) {
+    GenerateRegisteredNativeFuncCall(*func, nativeFunc, allocCallArgs, stubFuncRet);
+  }
+  bool needDecodeRef = (func->GetReturnType()->GetPrimType() == PTY_ref) && !isStaticBindingNative;
+  if (needDecodeRef) {
+    MapleVector<BaseNode*> decodeArgs(func->GetCodeMempoolAllocator().Adapter());
+    CHECK_FATAL(stubFuncRet != nullptr, "stubfunc_ret is nullptr");
+    decodeArgs.push_back(builder->CreateExprDread(*stubFuncRet));
+    CallNode *decodeFuncCall =
+        builder->CreateStmtCallAssigned(MRTDecodeRefFunc->GetPuidx(), decodeArgs, stubFuncRet, OP_callassigned);
+    func->GetBody()->AddStatement(decodeFuncCall);
+  }
+  if (needNativeCall) {
+    func->GetBody()->AddStatement(postFuncCall);
+  }
+  // Generate MonitorExit if this is a synchronized method
+  if (func->GetAttr(FUNCATTR_synchronized)) {
+    BaseNode *monitor = nullptr;
+    if (func->GetAttr(FUNCATTR_static)) {
+      // Grab class object
+      monitor = builder->CreateExprAddrof(0, *classObjSymbol);
+    } else {
+      // Grab _this pointer
+      MIRSymbol *formal0St = func->GetFormal(0);
+      if (formal0St->GetSKind() == kStPreg) {
+        monitor =
+            builder->CreateExprRegread(formal0St->GetType()->GetPrimType(),
+                                       func->GetPregTab()->GetPregIdxFromPregno(formal0St->GetPreg()->GetPregNo()));
+      } else {
+        monitor = builder->CreateExprDread(*formal0St);
+      }
+    }
+    NaryStmtNode *syncExit = builder->CreateStmtNary(OP_syncexit, monitor);
+    func->GetBody()->AddStatement(syncExit);
+  }
+  bool needCheckExceptionCall = needNativeCall || isStaticBindingNative;
+  // check pending exception just before leaving this stub frame except for critical natives
+  if (needCheckExceptionCall) {
+    MapleVector<BaseNode*> getExceptArgs(func->GetCodeMempoolAllocator().Adapter());
+    CallNode *callGetExceptFunc = builder->CreateStmtCallAssigned(MRTCheckThrowPendingExceptionFunc->GetPuidx(),
+                                                                  getExceptArgs, nullptr, OP_callassigned);
+    func->GetBody()->AddStatement(callGetExceptFunc);
+  } else if (!func->GetAttr(FUNCATTR_critical_native) &&
+             !(existsFuncProperty && funcProperty.jniType == kJniTypeCriticalNeedArg)) {
+    MapleVector<BaseNode*> frameStatusArgs(func->GetCodeMempoolAllocator().Adapter());
+    CallNode *callSetFrameStatusFunc = builder->CreateStmtCallAssigned(MCCSetReliableUnwindContextFunc->GetPuidx(),
+                                                                       frameStatusArgs, nullptr, OP_callassigned);
+    func->GetBody()->AddStatement(callSetFrameStatusFunc);
+  }
+  if (!voidRet) {
+    StmtNode *stmt = builder->CreateStmtReturn(builder->CreateExprDread(*stubFuncRet));
+    func->GetBody()->AddStatement(stmt);
+  }
+  if (existsFuncProperty && funcProperty.jniType == kJniTypeCriticalNeedArg) {
+    func->UnSetAttr(FUNCATTR_fast_native);
+    func->SetAttr(FUNCATTR_critical_native);
+  }
+}
+
+void NativeStubFuncGeneration::GenerateRegFuncTabEntryType() {
+  MIRArrayType &arrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetVoidPtr(), 0);
+  regFuncTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), arrayType);
+  std::string regFuncTab = namemangler::kRegJNIFuncTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+  regFuncSymbol = builder->CreateSymbol(regFuncTabConst->GetType().GetTypeIndex(), regFuncTab, kStVar,
+                                        kScGlobal, nullptr, kScopeGlobal);
+}
+
+void NativeStubFuncGeneration::GenerateRegFuncTabEntry() {
+#ifdef USE_ARM32_MACRO
+  constexpr int locIdxShift = 3;
+#else
+  constexpr int locIdxShift = 4;
+#endif
+
+#ifdef TARGARM32
+  // LSB can not be used to mark unresolved entries in java native method table for arm, since this bit
+  // is used to switch arm mode and thumb mode (when LSB of pc is set to 1)
+  constexpr uint64 locIdxMask = 0;
+#else
+  constexpr uint64 locIdxMask = 0x01;
+#endif
+
+  uint64 locIdx = regFuncTabConst->GetConstVec().size();
+  auto *newConst =
+    GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>((locIdx << locIdxShift) | locIdxMask),
+                                                         *GlobalTables::GetTypeTable().GetVoidPtr());
+  regFuncTabConst->AddItem(newConst, 0);
+}
+
+void NativeStubFuncGeneration::GenerateRegFuncTab() {
+  auto &arrayType = static_cast<MIRArrayType&>(regFuncTabConst->GetType());
+  arrayType.SetSizeArrayItem(0, regFuncTabConst->GetConstVec().size());
+  regFuncSymbol->SetKonst(regFuncTabConst);
+}
+
+void NativeStubFuncGeneration::GenerateRegTabEntry(const MIRFunction &func) {
+  std::string tmp = func.GetName();
+  tmp = namemangler::DecodeName(tmp);
+  std::string base = func.GetBaseClassName();
+  base = namemangler::DecodeName(base);
+  if (tmp.length() > base.length() && tmp.find(base) != std::string::npos) {
+    tmp.replace(tmp.find(base), base.length() + 1, "");
+  }
+  uint32 baseFuncNameWithTypeIdx = ReflectionAnalysis::FindOrInsertRepeatString(tmp, true);    // always used
+  uint32 classIdx = ReflectionAnalysis::FindOrInsertRepeatString(base, true);  // always used
+  // Using MIRIntConst instead of MIRStruct for RegTable.
+  auto *baseConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+      classIdx, *GlobalTables::GetTypeTable().GetVoidPtr());
+  regTableConst->AddItem(baseConst, 0);
+  auto *newConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+      baseFuncNameWithTypeIdx, *GlobalTables::GetTypeTable().GetVoidPtr());
+  regTableConst->AddItem(newConst, 0);
+}
+
+void NativeStubFuncGeneration::GenerateRegisteredNativeFuncCall(MIRFunction &func, const MIRFunction &nativeFunc,
+                                                                MapleVector<BaseNode*> &args, const MIRSymbol *ret) {
+  GenerateRegTabEntry(func);
+  GenerateRegFuncTabEntry();
+  CallReturnVector nrets(func.GetCodeMempoolAllocator().Adapter());
+  if (ret != nullptr) {
+    CHECK_FATAL((ret->GetStorageClass() == kScAuto || ret->GetStorageClass() == kScFormal ||
+                 ret->GetStorageClass() == kScExtern || ret->GetStorageClass() == kScGlobal),
+                "unknow classtype! check it!");
+    nrets.push_back(CallReturnPair(ret->GetStIdx(), RegFieldPair(0, 0)));
+  }
+  size_t loc = regFuncTabConst->GetConstVec().size();
+  auto &arrayType = static_cast<MIRArrayType&>(regFuncTabConst->GetType());
+  AddrofNode *regFuncExpr = builder->CreateExprAddrof(0, *regFuncSymbol);
+  ArrayNode *arrayExpr = builder->CreateExprArray(arrayType, regFuncExpr,
+                                                  builder->CreateIntConst(static_cast<int64>(loc) - 1, PTY_i32));
+  arrayExpr->SetBoundsCheck(false);
+  auto *elemType = static_cast<MIRArrayType&>(arrayType).GetElemType();
+  BaseNode *ireadExpr =
+      builder->CreateExprIread(*elemType, *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType),
+                               0, arrayExpr);
+  // assign registered func ptr to a symbol.
+  auto funcPtrSym = builder->CreateSymbol(GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex(), "func_ptr",
+                                          kStVar, kScAuto, &func, kScopeLocal);
+  DassignNode *funcPtrAssign = builder->CreateStmtDassign(*funcPtrSym, 0, ireadExpr);
+  // read func ptr from symbol
+  auto readFuncPtr = builder->CreateExprDread(*funcPtrSym);
+  NativeFuncProperty funcProperty;
+  bool existsFuncProperty = GetNativeFuncProperty(func.GetName(), funcProperty);
+  bool needCheckThrowPendingExceptionFunc = (!func.GetAttr(FUNCATTR_critical_native)) &&
+                                            (!existsFuncProperty || funcProperty.jniType == kJniTypeNormal);
+  bool needIndirectCall = func.GetAttr(FUNCATTR_critical_native) || func.GetAttr(FUNCATTR_fast_native) ||
+                          (existsFuncProperty && funcProperty.jniType == kJniTypeCriticalNeedArg);
+
+  // Get current native method function ptr from reg_jni_func_tab slot
+  BaseNode *regReadExpr = builder->CreateExprDread(*funcPtrSym);
+#ifdef TARGARM32
+  BaseNode *checkRegExpr =
+      builder->CreateExprCompare(OP_lt, *GlobalTables::GetTypeTable().GetUInt1(),
+                                 *GlobalTables::GetTypeTable().GetPtr(),
+                                 regReadExpr, builder->CreateIntConst(MByteRef::kPositiveOffsetBias, PTY_ptr));
+#elif defined(TARGAARCH64) || defined(TARGRISCV64)
+  // define a temp register for bitwise-and operation
+  constexpr int intConstLength = 1;
+  BaseNode *andExpr = builder->CreateExprBinary(OP_band, *GlobalTables::GetTypeTable().GetPtr(), regReadExpr,
+                                                builder->CreateIntConst(intConstLength, PTY_u32));
+  auto flagSym = builder->CreateSymbol(GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex(), "flag",
+                                       kStVar, kScAuto, &func, kScopeLocal);
+  auto flagSymAssign = builder->CreateStmtDassign(*flagSym, 0, andExpr);
+  auto readFlag = builder->CreateExprDread(*flagSym);
+  BaseNode *checkRegExpr =
+      builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(),
+                                 *GlobalTables::GetTypeTable().GetPtr(),
+                                 readFlag, builder->CreateIntConst(kInvalidCode, PTY_ptr));
+#elif defined(TARGX86_64)
+  regReadExpr = nullptr;
+  BaseNode *checkRegExpr = nullptr;
+  return;
+#endif
+
+  auto *ifStmt = static_cast<IfStmtNode*>(builder->CreateStmtIf(checkRegExpr));
+  // get find_native_func function
+  MIRType *voidPointerType = GlobalTables::GetTypeTable().GetVoidPtr();
+  // set parameter of find_native_func
+  MapleVector<BaseNode*> dynamicStubOpnds(func.GetCodeMempoolAllocator().Adapter());
+  dynamicStubOpnds.push_back(arrayExpr);
+  // Use native wrapper if required.
+  if (Options::nativeWrapper) {
+    // Now native binding have three mode: default mode, dynamic-only mode, static binding list mode
+    // default mode, it will generate a weak function, which can link in compile time
+    // dynamic only mode, it won't generate any weak function, it can't link in compile time
+    // static binding list mode, it will generate a weak function only in list
+    if (IsStaticBindingMethod(func.GetName())) {
+      // Get current func_ptr (strong/weak symbol address)
+      auto *nativeFuncAddr = builder->CreateExprAddroffunc(nativeFunc.GetPuidx());
+      funcPtrAssign = builder->CreateStmtDassign(*funcPtrSym, 0, nativeFuncAddr);
+      func.GetBody()->AddStatement(funcPtrAssign);
+      // Define wrapper function call
+      StmtNode *wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret, needIndirectCall);
+      func.GetBody()->AddStatement(wrapperCall);
+    } else if (!Options::regNativeDynamicOnly) { // Qemu
+      func.GetBody()->AddStatement(funcPtrAssign);
+#if TARGAARCH64 || TARGRISCV64
+      func.GetBody()->AddStatement(flagSymAssign);
+#endif
+      // Get find_native_func function
+      MIRFunction *findNativeFunc = builder->GetOrCreateFunction(namemangler::kFindNativeFuncNoeh,
+                                                                 voidPointerType->GetTypeIndex());
+      findNativeFunc->SetAttr(FUNCATTR_nosideeffect);
+      // CallAssigned statement for unregistered situation
+      CallNode *callGetFindNativeFunc = builder->CreateStmtCallAssigned(findNativeFunc->GetPuidx(), dynamicStubOpnds,
+                                                                        funcPtrSym, OP_callassigned);
+      // Check return value of dynamic linking stub
+      MIRFunction *dummyNativeFunc = builder->GetOrCreateFunction(namemangler::kDummyNativeFunc,
+                                                                  voidPointerType->GetTypeIndex());
+      dummyNativeFunc->SetAttr(FUNCATTR_nosideeffect);
+      auto dummyFuncSym = builder->CreateSymbol(voidPointerType->GetTypeIndex(), "dummy_ret",
+                                                kStVar, kScAuto, &func, kScopeLocal);
+      auto readDummyFuncPtr = builder->CreateExprDread(*dummyFuncSym);
+      MapleVector<BaseNode*> dummyFuncOpnds(func.GetCodeMempoolAllocator().Adapter());
+      CallNode *callDummyNativeFunc = builder->CreateStmtCallAssigned(dummyNativeFunc->GetPuidx(), dummyFuncOpnds,
+                                                                      dummyFuncSym, OP_callassigned);
+      BaseNode *checkStubReturnExpr =
+          builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(),
+                                     *GlobalTables::GetTypeTable().GetPtr(), readFuncPtr, readDummyFuncPtr);
+      auto *subIfStmt = static_cast<IfStmtNode*>(builder->CreateStmtIf(checkStubReturnExpr));
+      // Assign with address of strong/weak symbol
+      auto *nativeFuncAddr = builder->CreateExprAddroffunc(nativeFunc.GetPuidx());
+      funcPtrAssign = builder->CreateStmtDassign(*funcPtrSym, 0, nativeFuncAddr);
+      subIfStmt->GetThenPart()->AddStatement(funcPtrAssign);
+      // Rewrite reg_jni_func_tab with current funcIdx_ptr(weak/strong symbol address)
+      auto nativeMethodPtr = builder->CreateExprDread(*funcPtrSym);
+      IassignNode *nativeFuncTableEntry = builder->CreateStmtIassign(
+          *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 0, arrayExpr, nativeMethodPtr);
+      subIfStmt->GetThenPart()->AddStatement(nativeFuncTableEntry);
+      // Add if-statement to function body
+      ifStmt->GetThenPart()->AddStatement(callGetFindNativeFunc);
+      ifStmt->GetThenPart()->AddStatement(callDummyNativeFunc);
+      ifStmt->GetThenPart()->AddStatement(subIfStmt);
+      if (needCheckThrowPendingExceptionFunc) {
+        func.GetBody()->AddStatement(ifStmt);
+        StmtNode *wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret, needIndirectCall);
+        func.GetBody()->AddStatement(wrapperCall);
+      } else {
+        StmtNode *wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret, needIndirectCall);
+        ifStmt->GetThenPart()->AddStatement(wrapperCall);
+        MapleVector<BaseNode*> opnds(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+        CallNode *callGetExceptFunc = builder->CreateStmtCallAssigned(MRTCheckThrowPendingExceptionFunc->GetPuidx(),
+                                                                      opnds, nullptr, OP_callassigned);
+        ifStmt->GetThenPart()->AddStatement(callGetExceptFunc);
+        auto *elseBlock = func.GetCodeMempool()->New<BlockNode>();
+        ifStmt->SetElsePart(elseBlock);
+        ifStmt->SetNumOpnds(kOperandNumTernary);
+        wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret, needIndirectCall);
+        elseBlock->AddStatement(wrapperCall);
+        func.GetBody()->AddStatement(ifStmt);
+      }
+    } else { // EMUI
+      func.GetBody()->AddStatement(funcPtrAssign);
+#if TARGAARCH64 || TARGRISCV64
+      func.GetBody()->AddStatement(flagSymAssign);
+#endif
+      MIRFunction *findNativeFunc = builder->GetOrCreateFunction(namemangler::kFindNativeFunc,
+                                                                 voidPointerType->GetTypeIndex());
+      findNativeFunc->SetAttr(FUNCATTR_nosideeffect);
+      // CallAssigned statement for unregistered situation
+      CallNode *callGetFindNativeFunc = builder->CreateStmtCallAssigned(findNativeFunc->GetPuidx(), dynamicStubOpnds,
+                                                                        funcPtrSym, OP_callassigned);
+      // Add if-statement to function body
+      ifStmt->GetThenPart()->AddStatement(callGetFindNativeFunc);
+      if (!needCheckThrowPendingExceptionFunc) {
+        MapleVector<BaseNode*> opnds(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+        CallNode *callGetExceptFunc = builder->CreateStmtCallAssigned(MRTCheckThrowPendingExceptionFunc->GetPuidx(),
+                                                                      opnds, nullptr, OP_callassigned);
+        ifStmt->GetThenPart()->AddStatement(callGetExceptFunc);
+      }
+      func.GetBody()->AddStatement(ifStmt);
+      StmtNode *wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret, needIndirectCall);
+      func.GetBody()->AddStatement(wrapperCall);
+    }
+    return;
+  }
+  // Without native wrapper
+  auto *icall = func.GetCodeMempool()->New<IcallNode>(GetMIRModule(), OP_icallassigned);
+  icall->SetNumOpnds(args.size() + 1);
+  icall->GetNopnd().resize(icall->GetNumOpnds());
+  icall->SetReturnVec(nrets);
+  for (size_t i = 1; i < icall->GetNopndSize(); ++i) {
+    icall->SetNOpndAt(i, args[i - 1]->CloneTree(GetMIRModule().GetCurFuncCodeMPAllocator()));
+  }
+  icall->SetNOpndAt(0, readFuncPtr);
+  icall->SetRetTyIdx(nativeFunc.GetReturnTyIdx());
+  // Check if funcptr is Invalid
+  MIRFunction *findNativeFunc = builder->GetOrCreateFunction(namemangler::kFindNativeFunc,
+                                                             voidPointerType->GetTypeIndex());
+  findNativeFunc->SetAttr(FUNCATTR_nosideeffect);
+  // CallAssigned statement for unregistered situation
+  CallNode *callGetFindNativeFunc =
+      builder->CreateStmtCallAssigned(findNativeFunc->GetPuidx(), dynamicStubOpnds, funcPtrSym, OP_callassigned);
+  ifStmt->GetThenPart()->AddStatement(callGetFindNativeFunc);
+  if (!needCheckThrowPendingExceptionFunc) {
+    MapleVector<BaseNode*> opnds(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    CallNode *callGetExceptFunc =
+        builder->CreateStmtCallAssigned(MRTCheckThrowPendingExceptionFunc->GetPuidx(), opnds, nullptr, OP_callassigned);
+    ifStmt->GetThenPart()->AddStatement(callGetExceptFunc);
+  }
+  func.GetBody()->AddStatement(ifStmt);
+  func.GetBody()->AddStatement(icall);
+}
+
+// Use wrapper to call the native function, the logic is:
+//     if func is fast_native or critical_native {
+//      icall[assigned](args, ...)[{ret}]
+//    Example: } else {
+//      if num_of_args < 8 {
+//        call MCC_CallSlowNative(nativeFunc, ...)
+//      Example: } else {
+//        call MCC_CallSlowNativeExt(nativeFunc, num_of_args, ...)
+//      }
+//    }
+StmtNode *NativeStubFuncGeneration::CreateNativeWrapperCallNode(MIRFunction &func, BaseNode *funcPtr,
+                                                                MapleVector<BaseNode*> &args, const MIRSymbol *ret,
+                                                                bool needIndirectCall) {
+#ifdef USE_ARM32_MACRO
+  constexpr size_t numOfArgs = 4;
+#else
+  constexpr size_t numOfArgs = 8;
+#endif
+  MIRFunction *wrapperFunc = nullptr;
+  MapleVector<BaseNode*> wrapperArgs(func.GetCodeMPAllocator().Adapter());
+  // The first arg is the natvie function pointer.
+  wrapperArgs.push_back(funcPtr);
+  // Push back all original args.
+  wrapperArgs.insert(wrapperArgs.cend(), args.cbegin(), args.cend());
+  // Do not need native wrapper for fast natives or critical natives.
+  if (needIndirectCall) {
+    if (ret == nullptr) {
+      return builder->CreateStmtIcall(wrapperArgs);
+    } else {
+      return builder->CreateStmtIcallAssigned(wrapperArgs, *ret);
+    }
+  }
+  if (args.size() > numOfArgs) {
+    wrapperFunc = MRTCallSlowNativeExtFunc;
+  } else {
+    wrapperFunc = MRTCallSlowNativeFunc[args.size()];
+  }
+  if (ret == nullptr) {
+    return builder->CreateStmtCall(wrapperFunc->GetPuidx(), wrapperArgs);
+  } else {
+    return builder->CreateStmtCallAssigned(wrapperFunc->GetPuidx(), wrapperArgs, ret, OP_callassigned);
+  }
+}
+
+void NativeStubFuncGeneration::GenerateRegTableEntryType() {
+  MIRArrayType &arrayType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetVoidPtr(), 0);
+  regTableConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), arrayType);
+}
+
+void NativeStubFuncGeneration::GenerateHelperFuncDecl() {
+  MIRType *voidType = GlobalTables::GetTypeTable().GetVoid();
+  MIRType *voidPointerType = GlobalTables::GetTypeTable().GetVoidPtr();
+  MIRType *refType = GlobalTables::GetTypeTable().GetRef();
+  // MRT_PendingException
+  MRTCheckThrowPendingExceptionFunc =
+      builder->GetOrCreateFunction(namemangler::kCheckThrowPendingExceptionFunc, voidType->GetTypeIndex());
+  CHECK_FATAL(MRTCheckThrowPendingExceptionFunc != nullptr, "MRTCheckThrowPendingExceptionFunc is null.");
+  MRTCheckThrowPendingExceptionFunc->SetAttr(FUNCATTR_nosideeffect);
+  MRTCheckThrowPendingExceptionFunc->SetBody(nullptr);
+  // MRT_PreNativeCall
+  MRTPreNativeFunc = builder->GetOrCreateFunction(namemangler::kPreNativeFunc, voidType->GetTypeIndex());
+  CHECK_FATAL(MRTPreNativeFunc != nullptr, "MRTPreNativeFunc is null.");
+  MRTPreNativeFunc->SetBody(nullptr);
+  // MRT_PostNativeCall
+  ArgVector postArgs(GetMIRModule().GetMPAllocator().Adapter());
+  postArgs.push_back(ArgPair("env", voidPointerType));
+  MRTPostNativeFunc = builder->GetOrCreateFunction(namemangler::kPostNativeFunc, voidType->GetTypeIndex());
+  CHECK_FATAL(MRTPostNativeFunc != nullptr, "MRTPostNativeFunc is null.");
+  MRTPostNativeFunc->SetBody(nullptr);
+  // MRT_DecodeReference
+  ArgVector decodeArgs(GetMIRModule().GetMPAllocator().Adapter());
+  decodeArgs.push_back(ArgPair("obj", refType));
+  MRTDecodeRefFunc = builder->CreateFunction(namemangler::kDecodeRefFunc, *refType, decodeArgs);
+  CHECK_FATAL(MRTDecodeRefFunc != nullptr, "MRTDecodeRefFunc is null.");
+  MRTDecodeRefFunc->SetAttr(FUNCATTR_nosideeffect);
+  MRTDecodeRefFunc->SetBody(nullptr);
+  // MCC_CallSlowNative
+  ArgVector callArgs(GetMIRModule().GetMPAllocator().Adapter());
+  callArgs.push_back(ArgPair("func", voidPointerType));
+  for (int i = 0; i < kSlownativeFuncnum; ++i) {
+    MRTCallSlowNativeFunc[i] = builder->CreateFunction(callSlowNativeFuncs[i], *voidPointerType, callArgs);
+    CHECK_FATAL(MRTCallSlowNativeFunc[i] != nullptr, "MRTCallSlowNativeFunc is null.");
+    MRTCallSlowNativeFunc[i]->SetBody(nullptr);
+  }
+  // MCC_CallSlowNativeExt
+  ArgVector callExtArgs(GetMIRModule().GetMPAllocator().Adapter());
+  callExtArgs.push_back(ArgPair("func", voidPointerType));
+  MRTCallSlowNativeExtFunc = builder->CreateFunction(namemangler::kCallSlowNativeExt, *voidPointerType, callExtArgs);
+  CHECK_FATAL(MRTCallSlowNativeExtFunc != nullptr, "MRTCallSlowNativeExtFunc is null.");
+  MRTCallSlowNativeExtFunc->SetBody(nullptr);
+  // MCC_SetReliableUnwindContext
+  MCCSetReliableUnwindContextFunc =
+      builder->GetOrCreateFunction(namemangler::kSetReliableUnwindContextFunc, voidType->GetTypeIndex());
+  CHECK_FATAL(MCCSetReliableUnwindContextFunc != nullptr, "MCCSetReliableUnwindContextFunc is null");
+  MCCSetReliableUnwindContextFunc->SetAttr(FUNCATTR_nosideeffect);
+  MCCSetReliableUnwindContextFunc->SetBody(nullptr);
+}
+
+void NativeStubFuncGeneration::GenerateRegTable() {
+  auto &arrayType = static_cast<MIRArrayType&>(regTableConst->GetType());
+  arrayType.SetSizeArrayItem(0, regTableConst->GetConstVec().size());
+  std::string regJniTabName = namemangler::kRegJNITabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+  MIRSymbol *regJNISt = builder->CreateSymbol(regTableConst->GetType().GetTypeIndex(), regJniTabName, kStVar,
+                                              kScGlobal, nullptr, kScopeGlobal);
+  regJNISt->SetKonst(regTableConst);
+}
+
+bool NativeStubFuncGeneration::IsStaticBindingListMode() const {
+  return (Options::staticBindingList != "" && Options::staticBindingList.length());
+}
+
+void NativeStubFuncGeneration::InitStaticBindingMethodList() {
+  if (!IsStaticBindingListMode()) {
+    return;
+  }
+  std::fstream file(Options::staticBindingList);
+  std::string content;
+  while (std::getline(file, content)) {
+    staticBindingMethodsSet.insert(content);
+  }
+}
+
+bool NativeStubFuncGeneration::IsStaticBindingMethod(const std::string &methodName) const {
+  if (!IsStaticBindingListMode()) {
+    return false;
+  }
+  return (staticBindingMethodsSet.find(namemangler::NativeJavaName(methodName.c_str())) !=
+          staticBindingMethodsSet.end());
+}
+
+bool NativeStubFuncGeneration::GetNativeFuncProperty(const std::string &funcName, NativeFuncProperty &property) {
+  auto it = nativeFuncPropertyMap.find(funcName);
+  if (it != nativeFuncPropertyMap.end()) {
+    property = it->second;
+    return true;
+  }
+  return false;
+}
+
+void NativeStubFuncGeneration::LoadNativeFuncProperty() {
+  const std::string kNativeFuncPropertyFile = Options::nativeFuncPropertyFile;
+  std::ifstream in(kNativeFuncPropertyFile, std::ios::in | std::ios::binary);
+  if (!in.is_open()) {
+    std::cerr << "Cannot Open native function property file " << kNativeFuncPropertyFile << "\n";
+    return;
+  }
+  // Mangled name of java function to native function name
+  while (!in.eof()) {
+    NativeFuncProperty property;
+    in >> property.javaFunc >> property.nativeFile >> property.nativeFunc >>
+          property.jniType >> property.useEnv >> property.useClassObj;
+    if (!property.javaFunc.empty()) {
+      nativeFuncPropertyMap[property.javaFunc] = property;
+    }
+  }
+  in.close();
+}
+
+void NativeStubFuncGeneration::Finish() {
+  if (!regTableConst->GetConstVec().empty()) {
+    GenerateRegTable();
+    GenerateRegFuncTab();
+  }
+  if (!Options::mapleLinker) {
+    // If use maplelinker, we postpone this generation to MUIDReplacement
+    ReflectionAnalysis::GenStrTab(GetMIRModule());
+  }
+}
+
+#ifdef USE_ARM32_MACRO
+const std::string NativeStubFuncGeneration::callSlowNativeFuncs[kSlownativeFuncnum] = {
+    "MCC_CallSlowNative0", "MCC_CallSlowNative1", "MCC_CallSlowNative2", "MCC_CallSlowNative3", "MCC_CallSlowNative4"
+};
+#else
+const std::string NativeStubFuncGeneration::callSlowNativeFuncs[kSlownativeFuncnum] = {
+    "MCC_CallSlowNative0", "MCC_CallSlowNative1", "MCC_CallSlowNative2", "MCC_CallSlowNative3", "MCC_CallSlowNative4",
+    "MCC_CallSlowNative5", "MCC_CallSlowNative6", "MCC_CallSlowNative7", "MCC_CallSlowNative8"
+};
+#endif
+
+bool M2MGenerateNativeStubFunc::PhaseRun(maple::MIRModule &m) {
+  bool origUsePreg = Options::usePreg;
+  Options::usePreg = false;  // As a pre mpl2mpl phase, NativeStubFunc always use symbols
+  OPT_TEMPLATE_NEWPM(NativeStubFuncGeneration, m);
+  Options::usePreg = origUsePreg;
+  return true;
+}
+
+void M2MGenerateNativeStubFunc::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/openProfile.cpp b/src/mapleall/mpl2mpl/src/openProfile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8b06a9d0ef22996ed253d4ed6e3cd971556ef62
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/openProfile.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "openProfile.h"
+#include "bin_mpl_export.h"
+#include "bin_mplt.h"
+
+  // namespace maple
+namespace maple {
+void M2MOpenprofile::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.SetPreservedAll();
+}
+
+bool M2MOpenprofile::PhaseRun(maple::MIRModule &m) {
+  uint32 dexNameIdx = m.GetFileinfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_filename"));
+  const std::string &dexName = GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(dexNameIdx));
+  bool deCompressSucc = m.GetProfile().DeCompress(Options::profile, dexName);
+  if (!deCompressSucc) {
+    LogInfo::MapleLogger() << "WARN: DeCompress() failed in DoOpenProfile::Run()\n";
+  }
+  return false;
+}
+
+
+bool M2MUpdateMplt::PhaseRun(MIRModule &m) {
+  auto *cg = GET_ANALYSIS(M2MCallGraph, m);
+  CHECK_FATAL(cg != nullptr, "Expecting a valid CallGraph, found nullptr.");
+  BinaryMplt *binMplt = m.GetBinMplt();
+  CHECK_FATAL(binMplt != nullptr, "Expecting a valid binMplt, found nullptr.");
+  UpdateMplt update;
+  update.UpdateCgField(*binMplt, *cg);
+  delete m.GetBinMplt();
+  m.SetBinMplt(nullptr);
+  return false;
+}
+
+void M2MUpdateMplt::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MCallGraph>();
+}
+}
\ No newline at end of file
diff --git a/src/mapleall/mpl2mpl/src/outline.cpp b/src/mapleall/mpl2mpl/src/outline.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d0a435722e14c35d299138309a1fe0571a81cb1e
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/outline.cpp
@@ -0,0 +1,641 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "outline.h"
+#include "ipa_collect.h"
+#include "ipa_phase_manager.h"
+#include "region_identify.h"
+#include "stmt_cost_analyzer.h"
+
+namespace maple {
+static constexpr size_t kParameterNumberLimit = 8;
+static constexpr size_t kOneInsn = 100;
+static constexpr char kOutlinePhase[] = "outline";
+
+static bool ShareSameParameter(const BaseNode &lhs, const BaseNode &rhs) {
+  if (lhs.GetOpCode() == OP_addrof) {
+    return static_cast<const AddrofNode &>(lhs).MayAccessSameMemory(&rhs);
+  }
+  if (rhs.GetOpCode() == OP_addrof) {
+    return static_cast<const AddrofNode &>(rhs).MayAccessSameMemory(&lhs);
+  }
+  if (lhs.GetOpCode() == OP_constval) {
+    return static_cast<const ConstvalNode &>(lhs).GetConstVal() == static_cast<const ConstvalNode &>(rhs).GetConstVal();
+  }
+  return lhs.IsSameContent(&rhs);
+}
+
+template<typename Functor>
+static void ForEachOpnd(BaseNode &opnd, BaseNode &parent, Functor &opndProcessor) {
+  if (opnd.GetOpCode() == OP_block) {
+    auto &stmtList = static_cast<BlockNode &>(opnd).GetStmtNodes();
+    for (auto it = stmtList.begin(); it != stmtList.end(); ++it) {
+      ForEachOpnd(*to_ptr(it), opnd, opndProcessor);
+    }
+    return;
+  }
+  for (size_t i = 0; i < opnd.GetNumOpnds(); ++i) {
+    ForEachOpnd(*opnd.Opnd(i), opnd, opndProcessor);
+  }
+  opndProcessor(opnd, parent);
+}
+
+size_t OutlineCandidate::InsertIntoParameterList(BaseNode &expr) {
+  for (size_t i = 0; i < parameters.size(); ++i) {
+    if (!ShareSameParameter(expr, *parameters[i])) {
+      continue;
+    }
+    exprToParameterIndex[&expr] = i;
+    if (expr.GetOpCode() == OP_addrof) {
+      parameters[i]->SetOpCode(OP_addrof);
+      parameters[i]->SetPrimType(expr.GetPrimType());
+    }
+    return i;
+  }
+  auto newIndex = parameters.size();
+  exprToParameterIndex[&expr] = newIndex;
+  (void)parameters.emplace_back(expr.CloneTree(regionCandidate->GetFunction()->GetCodeMempoolAllocator()));
+  return newIndex;
+}
+
+class OutlineInfoCollector {
+ public:
+  explicit OutlineInfoCollector(OutlineCandidate *candidate) : candidate(candidate) {}
+  ~OutlineInfoCollector() {
+    candidate = nullptr;
+  }
+  void operator() (BaseNode &node, const BaseNode &parent) {
+    (void)parent;
+    switch (node.GetOpCode()) {
+      case OP_callassigned:
+      case OP_icallassigned:
+      case OP_icallprotoassigned:
+      case OP_intrinsiccallassigned:
+      case OP_callinstantassigned:
+      case OP_regassign:
+      case OP_dassign: {
+        auto &regionOutPuts = candidate->GetRegionCandidate()->GetRegionOutPuts();
+        auto symbolRegPair = RegionCandidate::GetSymbolRegPair(node);
+        if (regionOutPuts.find(symbolRegPair) != regionOutPuts.end()) {
+          candidate->CreateReturnExpr(symbolRegPair);
+          CollectParameter(*candidate->GetReturnExpr());
+        }
+        break;
+      }
+      case OP_addrof: {
+        auto stIdx = static_cast<AddrofNode &>(node).GetStIdx();
+        if (stIdx.Islocal()) {
+          auto index = candidate->InsertIntoParameterList(node);
+          candidate->GetStIdxToParameterIndexMap()[stIdx] = index;
+        }
+        break;
+      }
+      case OP_dread:
+      case OP_regread: {
+        CollectParameter(node);
+        break;
+      }
+      case OP_constval:
+      case OP_conststr:
+      case OP_conststr16: {
+        auto &valueNumberToExprMap = candidate->GetRegionValueNumberToSrcExprMap();
+        (void)valueNumberToExprMap.emplace_back(&node);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+ private:
+  void CollectParameter(BaseNode &node) {
+    auto &regionInputs = candidate->GetRegionCandidate()->GetRegionInPuts();
+    auto symbolRegPair = RegionCandidate::GetSymbolRegPair(node);
+    if (regionInputs.find(symbolRegPair) == regionInputs.end()) {
+      return;
+    }
+    (void)candidate->InsertIntoParameterList(node);
+  }
+  OutlineCandidate *candidate;
+};
+
+class OutlineRegionExtractor {
+ public:
+  OutlineRegionExtractor(OutlineCandidate *candidate, MIRFunction *func)
+      : candidate(candidate), newFunc(func),
+        oldFunc(candidate->GetRegionCandidate()->GetFunction()),
+        builder(oldFunc->GetModule()->GetMIRBuilder()) {
+    oldFunc->SetCurrentFunctionToThis();
+  }
+  ~OutlineRegionExtractor() {
+    candidate = nullptr;
+    newFunc = nullptr;
+    oldFunc = nullptr;
+    builder = nullptr;
+  };
+
+  void operator() (BaseNode &node, BaseNode &parent) {
+    auto &stIdxToParameterIndexMap = candidate->GetStIdxToParameterIndexMap();
+    switch (node.GetOpCode()) {
+      case OP_addrof:
+      case OP_dread: {
+        auto stIdx = static_cast<DreadNode &>(node).GetStIdx();
+        if (stIdxToParameterIndexMap.find(stIdx)!= stIdxToParameterIndexMap.end()) {
+          ReplaceExpr(node, parent);
+        } else {
+          ReplaceStIdx<DreadNode>(node);
+        }
+        break;
+      }
+      case OP_dassign: {
+        auto stIdx = static_cast<DassignNode &>(node).GetStIdx();
+        if (stIdxToParameterIndexMap.find(stIdx) != stIdxToParameterIndexMap.end()) {
+          RestoreBase(node, parent);
+        } else {
+          ReplaceStIdx<DassignNode>(node);
+        }
+        break;
+      }
+      case OP_regread: {
+        ReplacePregIdx<RegreadNode>(node);
+        break;
+      }
+      case OP_regassign: {
+        ReplacePregIdx<RegassignNode>(node);
+        break;
+      }
+      case OP_asm:
+      case OP_callassigned:
+      case OP_icallassigned:
+      case OP_icallprotoassigned:
+      case OP_intrinsiccallassigned: {
+        ReplaceCallReturnVector(node);
+        break;
+      }
+      case OP_brtrue:
+      case OP_brfalse: {
+        ReplaceLableIdx<CondGotoNode>(node);
+        break;
+      }
+      case OP_goto: {
+        ReplaceLableIdx<GotoNode>(node);
+        break;
+      }
+      case OP_label: {
+        auto &labelNode = static_cast<LabelNode&>(node);
+        labelNode.SetLabelIdx(GetOrCreateNewLabelIdx(labelNode.GetLabelIdx()));
+        break;
+      }
+      default: {
+        auto exprToParameterMap = candidate->GetExprToParameterIndexMap();
+        if (exprToParameterMap.find(&node) != exprToParameterMap.end()) {
+          ReplaceExpr(node, parent);
+        }
+        break;
+      }
+    }
+  }
+
+  void GenerateInput() {
+    for (auto *parameter : candidate->GetParameters()) {
+      MIRSymbol *symbol = nullptr;
+      switch (parameter->GetOpCode()) {
+        case OP_dread: {
+          auto *dread = static_cast<DreadNode *>(parameter);
+          auto stIdx = GetOrCreateNewStIdx(dread->GetStIdx());
+          symbol = newFunc->GetSymbolTabItem(stIdx.Idx());
+          symbol->SetStorageClass(kScFormal);
+          break;
+        }
+        case OP_regread: {
+          auto *regRead = static_cast<RegreadNode *>(parameter);
+          auto pregIdx = GetOrCreateNewPregIdx(regRead->GetRegIdx());
+          symbol = builder->CreatePregFormalSymbol(TyIdx(regRead->GetPrimType()), pregIdx, *newFunc);
+          break;
+        }
+        case OP_addrof:
+        case OP_constval:
+        case OP_conststr:
+        case OP_conststr16: {
+          auto *dread = static_cast<DreadNode *>(CreateNewExpr(*parameter));
+          auto stIdx = dread->GetStIdx();
+          symbol = newFunc->GetSymbolTabItem(stIdx.Idx());
+          symbol->SetStorageClass(kScFormal);
+          break;
+        }
+        default: {
+          CHECK_FATAL(false, "unexpected op code for formal symbol creation");
+          break;
+        }
+      }
+      (void)newFunc->GetFormalDefVec().emplace_back(FormalDef(symbol, symbol->GetTyIdx(), symbol->GetAttrs()));
+      (void)newFunc->GetMIRFuncType()->GetParamTypeList().emplace_back(symbol->GetTyIdx());
+      (void)newFunc->GetMIRFuncType()->GetParamAttrsList().emplace_back(symbol->GetAttrs());
+    }
+  }
+
+  void DealWithReturn() {
+    ReplaceOutput();
+    GenerateOutput();
+  }
+
+ private:
+  void RestoreBase(BaseNode &node, BaseNode &parent) {
+    auto &dassign = static_cast<DassignNode &>(node);
+    auto stIdx = dassign.GetStIdx();
+    if (stIdx.IsGlobal()) {
+      return;
+    }
+    auto *parameter = candidate->GetParameters()[candidate->GetStIdxToParameterIndexMap()[stIdx]];
+    auto *newParameter = exprMap[parameter];
+    auto *symbol = oldFunc->GetSymbolTabItem(stIdx.Idx());
+    auto *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*symbol->GetType());
+    auto *iassign = builder->CreateStmtIassign(*ptrType, dassign.GetFieldID(), newParameter, dassign.GetRHS());
+    static_cast<BlockNode &>(parent).ReplaceStmt1WithStmt2(&dassign, iassign);
+    candidate->GetReplacedStmtMap()[&node] = iassign;
+  }
+
+  StIdx CreateNewStIdx(const StIdx oldStIdx) {
+    auto *oldSym = oldFunc->GetSymbolTabItem(oldStIdx.Idx());
+    auto *newSym = newFunc->GetSymTab()->CloneLocalSymbol(*oldSym);
+    newSym->SetIsTmp(true);
+    newSym->ResetIsDeleted();
+    if (newSym->IsFormal() || newSym->IsPUStatic()) {
+      newSym->SetStorageClass(kScAuto);
+    }
+    auto flag = newFunc->GetSymTab()->AddStOutside(newSym);
+    CHECK_FATAL(flag, "symbol clone failed");
+    return newSym->GetStIdx();
+  }
+
+  StIdx GetOrCreateNewStIdx(const StIdx stIdx) {
+    if (stIdx.IsGlobal()) {
+      return stIdx;
+    }
+    if (symbolMap.find(stIdx) == symbolMap.end()) {
+      auto newStIdx = CreateNewStIdx(stIdx);
+      symbolMap[stIdx] = newStIdx;
+    }
+    return symbolMap[stIdx];
+  }
+
+  PregIdx GetOrCreateNewPregIdx(PregIdx pregIdx) {
+    if (regMap.find(pregIdx) == regMap.end()) {
+      auto *preg = oldFunc->GetPregItem(pregIdx);
+      auto newPregIdx = newFunc->GetPregTab()->ClonePreg(*preg);
+      regMap[pregIdx] = newPregIdx;
+    }
+    return regMap[pregIdx];
+  }
+
+  LabelIdx GetOrCreateEndLabelIdx() {
+    if (endLabel == kInvalidLabelIdx) {
+      endLabel = newFunc->GetLabelTab()->CreateLabel();
+    }
+    return endLabel;
+  }
+
+  LabelIdx GetOrCreateNewLabelIdx(LabelIdx labelIdx) {
+    if (labelMap.find(labelIdx) == labelMap.end()) {
+      auto newLabelIdx = newFunc->GetLabelTab()->CreateLabel();
+      labelMap[labelIdx] = newLabelIdx;
+    }
+    return labelMap[labelIdx];
+  }
+
+  MIRSymbol *CreateNewSymbolForParameter(PrimType primType) {
+    auto symbolNameString = "parameter_" + std::to_string(++newParameterSymbolCount);
+    bool created = false;
+    auto *symbol = builder->GetOrCreateLocalDecl(symbolNameString, TyIdx(primType), *newFunc->GetSymTab(), created);
+    CHECK_FATAL(created, "parameter created before when outlining");
+    symbol->SetSKind(kStVar);
+    return symbol;
+  }
+
+  BaseNode *ReloadVar(BaseNode &originNode, BaseNode &newBase) {
+    auto &dread = static_cast<DreadNode&>(originNode);
+    auto *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(TyIdx(dread.GetPrimType()));
+    return builder->CreateExprIread(dread.GetPrimType(), ptrType->GetTypeIndex(), 0, &newBase);
+  }
+
+  BaseNode *CreateNewExpr(BaseNode &node) {
+    auto primType = node.IsConstExpr() ? node.GetPrimType() : GetExactPtrPrimType();
+    auto *newSymbol = CreateNewSymbolForParameter(primType);
+    auto *returnNode = builder->CreateExprDread(*newSymbol);
+    exprMap[&node] = returnNode;
+    return returnNode;
+  }
+
+  BaseNode *GetNewExpr(BaseNode &node) {
+    auto *srcNode = &node;
+    auto &exprToParameterMap = candidate->GetExprToParameterIndexMap();
+    if (exprToParameterMap.find(&node) == exprToParameterMap.end()) {
+      return srcNode;
+    }
+    srcNode = candidate->GetParameters()[exprToParameterMap[srcNode]];
+    auto *returnNode = exprMap[srcNode]->CloneTree(oldFunc->GetCodeMemPoolAllocator());
+    return (node.GetOpCode() == OP_dread) ? ReloadVar(node, *returnNode) : returnNode;
+  }
+
+  template<typename T>
+  void ReplaceStIdx(BaseNode &node) {
+    auto &srcNode = static_cast<T&>(node);
+    auto stIdx = srcNode.GetStIdx();
+    if (stIdx.IsGlobal()) {
+      return;
+    }
+    srcNode.SetStIdx(GetOrCreateNewStIdx(stIdx));
+  }
+
+  template<typename T>
+  void ReplacePregIdx(BaseNode &node) {
+    auto &srcNode = static_cast<T&>(node);
+    auto pregIdx = srcNode.GetRegIdx();
+    srcNode.SetRegIdx(GetOrCreateNewPregIdx(pregIdx));
+  }
+
+  void ReplaceCallReturnVector(BaseNode &node) {
+    auto *callReturnVector = node.GetCallReturnVector();
+    if (callReturnVector->empty()) {
+      return;
+    }
+    for (auto &returnPair : *callReturnVector) {
+      if (returnPair.second.IsReg()) {
+        auto pregIdx = returnPair.second.GetPregIdx();
+        returnPair.second.SetPregIdx(GetOrCreateNewPregIdx(pregIdx));
+      } else {
+        auto stIdx = returnPair.first;
+        returnPair.first = GetOrCreateNewStIdx(stIdx);
+      }
+    }
+  }
+
+  template<typename T>
+  void ReplaceLableIdx(BaseNode &node) {
+    auto &srcNode = static_cast<T&>(node);
+    auto labelIdx = srcNode.GetOffset();
+    auto &stmtJumpToEnd = candidate->GetRegionCandidate()->GetStmtJumpToEnd();
+    if (stmtJumpToEnd.find(&node) != stmtJumpToEnd.end()) {
+      srcNode.SetOffset(GetOrCreateEndLabelIdx());
+    } else {
+      srcNode.SetOffset(GetOrCreateNewLabelIdx(labelIdx));
+    }
+  }
+
+  void ReplaceExpr(BaseNode &node, BaseNode &parent) {
+    for (size_t i = 0; i < parent.NumOpnds(); ++i) {
+      if (parent.Opnd(i) == &node) {
+        parent.SetOpnd(GetNewExpr(node), i);
+      }
+    }
+  }
+
+  void ReplaceOutput() {
+    auto *node = candidate->GetReturnExpr();
+    if (node == nullptr) {
+      return;
+    }
+    switch (node->GetOpCode()) {
+      case OP_dread: {
+        ReplaceStIdx<DreadNode>(*node);
+        break;
+      }
+      case OP_regread: {
+        ReplacePregIdx<RegreadNode>(*node);
+        break;
+      }
+      default: {
+        CHECK_FATAL(false, "unexpected op for return value");
+        break;
+      }
+    }
+  }
+
+  void GenerateOutput() {
+    newFunc->GetModule()->SetCurFunction(newFunc);
+    if (endLabel != kInvalidLabelIdx) {
+      newFunc->GetBody()->AddStatement(builder->CreateStmtLabel(endLabel));
+    }
+    auto *returnNode = newFunc->GetCodeMemPool()->New<NaryStmtNode>(newFunc->GetCodeMempoolAllocator(), OP_return);
+    newFunc->GetBody()->AddStatement(returnNode);
+    if (candidate->GetReturnExpr() != nullptr) {
+      returnNode->PushOpnd(candidate->GetReturnExpr()->CloneTree(newFunc->GetCodeMempoolAllocator()));
+    }
+  }
+
+  OutlineCandidate *candidate;
+  MIRFunction *newFunc;
+  MIRFunction *oldFunc;
+  MIRBuilder *builder;
+  LabelIdx endLabel = kInvalidLabelIdx;
+  uint32 newParameterSymbolCount = 0;
+  std::unordered_map<StIdx, StIdx> symbolMap;
+  std::unordered_map<PregIdx, PregIdx> regMap;
+  std::unordered_map<LabelIdx, LabelIdx> labelMap;
+  std::unordered_map<BaseNode*, BaseNode*> exprMap;
+};
+
+void OutlineGroup::CollectOutlineInfo() {
+  for (auto &outlineCandidate : regionGroup) {
+    auto *region = outlineCandidate.GetRegionCandidate();
+    auto collector = OutlineInfoCollector(&outlineCandidate);
+    region->TraverseRegion([&collector] (const StmtIterator &it) {
+      ForEachOpnd(*to_ptr(it), *to_ptr(it), collector);
+    });
+  }
+}
+
+void OutlineGroup::PrepareExtraParameterLists() {
+  auto candidateStart = regionGroup.begin();
+  for (size_t i = 0; i < candidateStart->GetRegionValueNumberToSrcExprMap().size(); ++i) {
+    for (auto candidateIter = std::next(candidateStart); candidateIter != regionGroup.end(); ++candidateIter) {
+      auto *leftConst = candidateStart->GetRegionValueNumberToSrcExprMap()[i];
+      auto *rightConst = candidateIter->GetRegionValueNumberToSrcExprMap()[i];
+      if (!leftConst->IsSameContent(rightConst)) {
+        extraParameterValueNumber.push_back(i);
+        break;
+      }
+    }
+  }
+  for (auto &candidate : regionGroup) {
+    for (auto valueNumber : extraParameterValueNumber) {
+      auto *expr = candidate.GetRegionValueNumberToSrcExprMap()[valueNumber];
+      (void)candidate.InsertIntoParameterList(*expr);
+    }
+  }
+}
+
+void OutlineGroup::ReplaceOutlineCandidateWithCall() {
+  for (auto &candidate : regionGroup) {
+    auto *region = candidate.GetRegionCandidate();
+    auto *block = region->GetStart()->GetCurrBlock();
+    auto hasReturnvalue = !candidate.GetRegionCandidate()->GetRegionOutPuts().empty();
+    auto op = hasReturnvalue ? OP_callassigned : OP_call;
+    auto &alloc = outlineFunc->GetCodeMempoolAllocator();
+    auto *stmt = outlineFunc->GetCodeMemPool()->New<CallNode>(alloc, op, outlineFunc->GetPuidx());
+    stmt->SetNumOpnds(static_cast<uint8>(candidate.GetParameters().size()));
+    if (hasReturnvalue) {
+      auto symbolRegPair = candidate.GetRegionCandidate()->GetRegionOutPuts().begin();
+      auto stIdx = symbolRegPair->first;
+      auto pregIdx = symbolRegPair->second;
+      (void)stmt->GetCallReturnVector()->emplace_back(CallReturnPair(stIdx, RegFieldPair(0, pregIdx)));
+    }
+    for (auto *parameter : candidate.GetParameters()) {
+      (void)stmt->GetNopnd().emplace_back(parameter->CloneTree(alloc));
+    }
+    block->InsertBefore(region->GetStart()->GetStmtNode(), stmt);
+  }
+}
+
+void OutlineGroup::CompleteOutlineFunction() {
+  auto &candidate = regionGroup.front();
+  auto extractor = OutlineRegionExtractor(&candidate, outlineFunc);
+  extractor.GenerateInput();
+  candidate.GetRegionCandidate()->TraverseRegion([&extractor, &candidate, this] (const StmtIterator &it) {
+    auto *stmt = to_ptr(it);
+    auto *region = candidate.GetRegionCandidate();
+    auto &replacedStmtMap = candidate.GetReplacedStmtMap();
+    ForEachOpnd(*stmt, *region->GetStart()->GetCurrBlock(), extractor);
+    auto replaced = replacedStmtMap.find(stmt) != replacedStmtMap.end();
+    auto *replacedStmt = replaced ? candidate.GetReplacedStmtMap()[stmt] : stmt;
+    auto *newStmt = replacedStmt->CloneTree(outlineFunc->GetCodeMempoolAllocator());
+    outlineFunc->GetBody()->AddStatement(newStmt);
+    region->GetStart()->GetCurrBlock()->RemoveStmt(replacedStmt);
+  });
+  extractor.DealWithReturn();
+}
+
+void OutlineGroup::EraseOutlineRegion() {
+  for (auto &candidate : regionGroup) {
+    auto *region = candidate.GetRegionCandidate();
+    auto *block = region->GetStart()->GetCurrBlock();
+    region->TraverseRegion([block] (const StmtIterator &it) {
+      block->RemoveStmt(to_ptr(it));
+    });
+  }
+}
+
+static size_t GetBenefit(OutlineGroup &group, StmtCostAnalyzer &stmtCostAnalyzer) {
+  auto &outlineCandidate = group.GetOutlineRegions().front();
+  auto *region = outlineCandidate.GetRegionCandidate();
+  stmtCostAnalyzer.SetFunction(region->GetFunction());
+  size_t cost = 0;
+  for (auto *currStmt = region->GetStart()->GetStmtNode(); currStmt != nullptr; currStmt = currStmt->GetNext()) {
+    if (currStmt->GetStmtInfoId() > region->GetEndId()) {
+      break;
+    }
+    cost += static_cast<size_t>(stmtCostAnalyzer.GetStmtCost(currStmt));
+  }
+  return cost * (group.GetOutlineRegions().size() - 1);
+}
+
+static size_t GetCost(OutlineGroup &group, StmtCostAnalyzer &stmtCostAnalyzer) {
+  auto &outlineCandidate = group.GetOutlineRegions().front();
+  auto *region = outlineCandidate.GetRegionCandidate();
+  stmtCostAnalyzer.SetFunction(region->GetFunction());
+  size_t cost = kOneInsn;
+  for (auto *expr : outlineCandidate.GetParameters()) {
+    cost += static_cast<size_t>(stmtCostAnalyzer.GetExprCost(expr));
+  }
+  return cost * group.GetOutlineRegions().size();
+}
+
+static bool RegionGroupComparator(RegionGroup &lhs, RegionGroup &rhs) {
+  auto leftPotentialBenefit = lhs.GetGroups().size() * lhs.GetGroups().front().GetLength();
+  auto rightPotentialBenefit = rhs.GetGroups().size() * rhs.GetGroups().front().GetLength();
+  return leftPotentialBenefit > rightPotentialBenefit;
+}
+
+void OutLine::PruneCandidateRegionsOverlapWithOutlinedRegion(RegionGroup &group) {
+  auto &groupVector = group.GetGroups();
+  auto it = groupVector.begin();
+  while (it != groupVector.end()) {
+    bool isOverlaped = false;
+    for (auto *region : outlinedRegion) {
+      if (!it->IsOverlapWith(*region)) {
+        continue;
+      }
+      isOverlaped = true;
+      (void)groupVector.erase(it);
+      break;
+    }
+    if (!isOverlaped) {
+      ++it;
+    }
+  }
+  groupVector.shrink_to_fit();
+}
+
+void OutLine::Run() {
+  RegionIdentify identifier(ipaInfo);
+  identifier.RegionInit();
+  auto &candidateGroups = identifier.GetRegionGroups();
+  auto stmtCostAnalyzer = StmtCostAnalyzer(memPool);
+  std::sort(candidateGroups.begin(), candidateGroups.end(), RegionGroupComparator);
+  for (auto &group : candidateGroups) {
+    PruneCandidateRegionsOverlapWithOutlinedRegion(group);
+    if (group.GetGroups().size() < kGroupSizeLimit) {
+      continue;
+    }
+
+    auto outlineGroup = OutlineGroup(group);
+    outlineGroup.PrepareParameterLists();
+    if (outlineGroup.GetParameterSize() > kParameterNumberLimit) {
+      continue;
+    }
+
+    auto cost = GetCost(outlineGroup, stmtCostAnalyzer);
+    auto benefit = GetBenefit(outlineGroup, stmtCostAnalyzer);
+    if (benefit < cost || benefit - cost < Options::outlineThreshold) {
+      continue;
+    }
+
+    for (auto &region : group.GetGroups()) {
+      (void)outlinedRegion.emplace_back(&region);
+    }
+
+    if (Options::dumpPhase == kOutlinePhase) {
+      outlineGroup.Dump();
+    }
+
+    auto *outlineFunc = CreateNewOutlineFunction(group.GetGroups().front().GetOutputPrimType());
+    outlineGroup.SetOutlineFunction(outlineFunc);
+    outlineGroup.ReplaceOutlineRegions();
+  }
+}
+
+MIRFunction *OutLine::CreateNewOutlineFunction(PrimType returnType) {
+  auto newFuncName = std::string("outlined_func." + std::to_string(++newFuncIndex));
+  auto *newFunc = module->GetMIRBuilder()->GetOrCreateFunction(newFuncName, TyIdx(returnType));
+  (void)module->GetFunctionList().emplace_back(newFunc);
+  newFunc->SetBody(newFunc->GetCodeMempool()->New<BlockNode>());
+  newFunc->SetAttr(FUNCATTR_static);
+  newFunc->SetAttr(FUNCATTR_outlined);
+  newFunc->AllocSymTab();
+  newFunc->AllocPregTab();
+  newFunc->AllocLabelTab();
+  return newFunc;
+}
+
+bool M2MOutline::PhaseRun(MIRModule &m) {
+  auto *ipaInfo = GET_ANALYSIS(IpaSccPM, m);
+  MemPool *memPool = ApplyTempMemPool();
+  OutLine outline(ipaInfo, &m, memPool);
+  outline.Run();
+  return true;
+}
+
+void M2MOutline::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<IpaSccPM>();
+}
+}
diff --git a/src/mapleall/mpl2mpl/src/preme.cpp b/src/mapleall/mpl2mpl/src/preme.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..87625ff6755b72f26245c45a01e34c4d963bfced
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/preme.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include "preme.h"
+#include "me_option.h"
+#include "me_function.h"
+#include "me_verify.h"
+#include "mir_symbol_builder.h"
+#include "maple_phase_manager.h"
+
+namespace maple {
+void Preme::CreateMIRTypeForAddrof(const MIRFunction &func, const BaseNode *baseNode) const {
+  if (baseNode == nullptr) {
+    return;
+  }
+  if (baseNode->GetOpCode() == OP_block) {
+    const BlockNode *blockNode = static_cast<const BlockNode*>(baseNode);
+    for (auto &stmt : blockNode->GetStmtNodes()) {
+      CreateMIRTypeForAddrof(func, &stmt);
+    }
+  } else if (baseNode->GetOpCode() == OP_if) {
+    auto *ifStmtNode = static_cast<const IfStmtNode*>(baseNode);
+    CreateMIRTypeForAddrof(func, ifStmtNode->GetThenPart());
+    CreateMIRTypeForAddrof(func, ifStmtNode->GetElsePart());
+  } else if (baseNode->GetOpCode() == OP_addrof) {
+    const AddrofNode *addrNode = static_cast<const AddrofNode*>(baseNode);
+    const MIRSymbol *mirSymbol = func.GetLocalOrGlobalSymbol(addrNode->GetStIdx());
+    MIRPtrType ptrType(mirSymbol->GetTyIdx(), PTY_ptr);
+    (void)GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+  }
+  // Search for nested dread node that may include a symbol index.
+  for (size_t i = 0; i < baseNode->NumOpnds(); ++i) {
+    CreateMIRTypeForAddrof(func, baseNode->Opnd(i));
+  }
+}
+
+void Preme::ProcessFunc(MIRFunction *func) {
+  if (func == nullptr || func->IsEmpty()) {
+    return;
+  }
+  StmtNode *stmt = func->GetBody()->GetFirst();
+  while (stmt != nullptr) {
+    CreateMIRTypeForAddrof(*func, stmt);
+    stmt = stmt->GetNext();
+  }
+}
+
+void Preme::CreateMIRTypeForLowerGlobalDreads() {
+  for (uint32 i = 0; i < MIRSymbolBuilder::Instance().GetSymbolTableSize(); ++i) {
+    auto *symbol = MIRSymbolBuilder::Instance().GetSymbolFromStIdx(i);
+    if (symbol == nullptr) {
+      continue;
+    }
+    if (!symbol->IsVar()) {
+      continue;
+    }
+    MIRPtrType ptrType(symbol->GetTyIdx(), PTY_ptr);
+    if (symbol->IsVolatile()) {
+      TypeAttrs attrs;
+      attrs.SetAttr(ATTR_volatile);
+      ptrType.SetTypeAttrs(attrs);
+    }
+    (void)GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
+  }
+}
+
+bool M2MPreme::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(Preme, m);
+  if (MeOption::optLevel == 2) {
+    Preme::CreateMIRTypeForLowerGlobalDreads();
+  }
+  return true;
+}
+
+void M2MPreme::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/reflection_analysis.cpp b/src/mapleall/mpl2mpl/src/reflection_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0d45216fb60b81ce8d0ecb888f832a92d81ca2f7
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/reflection_analysis.cpp
@@ -0,0 +1,2273 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "reflection_analysis.h"
+#include <unordered_map>
+#include <algorithm>
+#include <functional>
+#include <iomanip>
+#include <fstream>
+#include "vtable_analysis.h"
+#include "vtable_impl.h"
+#include "option.h"
+#include "muid_replacement.h"
+#include "mir_builder.h"
+#include "namemangler.h"
+#include "itab_util.h"
+#include "string_utils.h"
+#include "metadata_layout.h"
+#include "maple_phase_manager.h"
+
+namespace {
+using namespace maple;
+// If needed, we can make field type in two bits.
+constexpr uint64 kMethodNotVirtual = 0x00000001;
+constexpr uint64 kMethodFinalize = 0x00000002;
+constexpr uint64 kMethodSignature = 0x00000008;
+constexpr uint64 kMethodMetaCompact = 0x00000004;
+constexpr uint64 kMethodAbstract = 0x00000010;
+constexpr uint64 kFieldOffsetIspOffset = 0x00000001;
+
+constexpr int kModPublic = 1;                 // 0x00000001
+constexpr int kModPrivate = 2;                // 0x00000002
+constexpr int kModProtected = 3;              // 0x00000004
+constexpr int kModStatic = 4;                 // 0x00000008
+constexpr int kModFinal = 5;                  // 0x00000010
+constexpr int kModSynchronized = 6;           // 0x00000020
+constexpr int kModVolatile = 7;               // 0x00000040
+constexpr int kModTransient = 8;              // 0x00000080
+constexpr int kModNative = 9;                 // 0x00000100
+constexpr int kModAbstract = 11;              // 0x00000400
+constexpr int kModStrict = 12;                // 0x00000800
+constexpr int kModSynthetic = 13;             // 0x00001000
+constexpr int kModConstructor = 17;           // 0x00010000
+constexpr int kModDefault = 22;               // 0x00400000
+constexpr int kModBridge = 7;                 // 0x00000040
+constexpr int kModVarargs = 8;                // 0x00000080
+constexpr int kModEnum = 15;                  // 0x00004000
+constexpr int kModDeclaredSynchronized = 18;  // 0x00020000
+constexpr int kModifierRCUnowned = 24;        // 0x00800000
+constexpr int kModifierRCWeak = 25;           // 0x01000000
+constexpr int kModifierHiddenApiGrey = 26;    // 0x02000000
+constexpr int kModifierHiddenApiBlack = 27;   // 0x04000000
+constexpr int kModifierAFOriginPublic = 28;   // 0x08000000
+constexpr int kModifierLocalClass = 29;       // 0x10000000
+constexpr int kModifierLocalClassVaild = 30;  // 0x20000000 for compatibility
+
+// +1 is needed here because our field id starts with 0 pointing to the struct itself
+constexpr uint32 kObjKlassFieldID = static_cast<uint32>(ClassProperty::kShadow) + 1;
+constexpr uint32 kMetaDataKlassFieldID = static_cast<uint32>(ClassProperty::kShadow) + 1;
+constexpr bool kRADebug = false;
+constexpr uint32 kMethodFieldHashSize = 1022;
+constexpr uint16 kHashConflictFlag = 1023;
+constexpr int16 kMethodNotFound = -10;
+
+constexpr char kModStr[] = "mod";
+constexpr char kAddrStr[] = "addr";
+constexpr char kFlagStr[] = "flag";
+constexpr char kItabStr[] = "itab";
+constexpr char kVtabStr[] = "vtab";
+constexpr char kGctibStr[] = "gctib";
+constexpr char kIndexStr[] = "index";
+constexpr char kOffsetStr[] = "offset";
+constexpr char kShadowStr[] = "shadow";
+constexpr char kClassSuffix[] = "_3B";
+constexpr char kArgsizeStr[] = "argsize";
+constexpr char kIfieldsStr[] = "ifields";
+constexpr char kMethodsStr[] = "methods";
+constexpr char kMonitorStr[] = "monitor";
+constexpr char kObjsizeStr[] = "objsize";
+#ifndef USE_32BIT_REF
+constexpr char kPaddingStr[] = "padding";
+#else
+constexpr char kInstanceOfCacheFalseStr[] = "instanceOfCacheFalse";
+#endif // ~USE_32BIT_REF
+constexpr char kTypeNameStr[] = "typeName";
+constexpr char kPClassTypeStr[] = "pClassType";
+constexpr char kClassNameStr[] = "classname";
+constexpr char kFieldNameStr[] = "fieldname";
+constexpr char kAccessFlags[] = "accessFlags";
+constexpr char kAnnotationStr[] = "annotation";
+constexpr char kClinitAddrStr[] = "clinitAddr";
+constexpr char kMethodNameStr[] = "methodname";
+constexpr char kInitFuntionStr[] = "_3Cinit_3E";
+constexpr char kClassinforoStr[] = "classinforo";
+constexpr char kClassloaderStr[] = "classloader";
+constexpr char kINFOFileName[] = "INFO_filename";
+constexpr char kLebPadding0Str[] = "lebPadding0";
+constexpr char kNumOfFieldsStr[] = "numoffields";
+constexpr char kClinitbridgeStr[] = "clinitbridge";
+constexpr char kNumOfMethodsStr[] = "numofmethods";
+constexpr char kSignatureNameStr[] = "signaturename";
+constexpr char kDeclaringclassStr[] = "declaringclass";
+constexpr char kFieldInfoTypeName[] = "__field_info__";
+constexpr char kINFOAccessFlags[] = "INFO_access_flags";
+constexpr char kSuperclassinfoStr[] = "superclassinfo";
+constexpr char kFieldOffsetDataStr[] = "fieldOffsetData";
+constexpr char kMethodAddrDataStr[] = "methodAddrData";
+constexpr char kAnnotationvalueStr[] = "annotationvalue";
+constexpr char kMethodInfoTypeName[] = "__method_info__";
+constexpr char kClinitSuffixStr[] = "_3Cclinit_3E_7C_28_29V";
+constexpr char kJavaLangEnumStr[] = "Ljava_2Flang_2FEnum_3B";
+constexpr char kNumOfSuperclassesStr[] = "numofsuperclasses";
+constexpr char kClassMetadataRoTypeName[] = "__class_meta_ro__";
+constexpr char kMethodInVtabIndexStr[] = "method_in_vtab_index";
+constexpr char kSuperclassMetadataTypeName[] = "__superclass_meta__";
+constexpr char kFieldOffsetDataTypeName[] = "__fieldOffsetDataType__";
+constexpr char kMethodAddrDataTypeName[] = "__methodAddrDataType__";
+constexpr char kFieldInfoCompactTypeName[] = "__field_info_compact__";
+constexpr char kMethodInfoCompactTypeName[] = "__method_info_compact__";
+constexpr char kSuperclassOrComponentclassStr[] = "superclass_or_componentclass";
+constexpr char kReflectionReferencePrefixStr[] = "Ljava_2Flang_2Fref_2FReference_3B";
+constexpr char kJavaLangAnnotationRetentionStr[] = "Ljava_2Flang_2Fannotation_2FRetention_3B";
+constexpr char kMethodSignatureOffsetName[] = "signatureOffset";
+constexpr char kMethodSignatureParameterName[] = "signatureParameter";
+constexpr char kParameterTypeItemName[] = "parameterTypeItem";
+constexpr char kParameterTypesName[] = "parameterTypes";
+constexpr char kMethodSignatureTypeName[] = "__methodSignatureType__";
+constexpr int kAnonymousClassIndex = 5;
+constexpr char kAnonymousClassSuffix[] = "30";
+constexpr char kInnerClassStr[] = "Lark/annotation/InnerClass;";
+constexpr char kEnclosingClassStr[] = "Lark/annotation/EnclosingClass;";
+constexpr char kEnclosingMethod[] = "Lark/annotation/EnclosingMethod;";
+constexpr char kArkAnnotationEnclosingClassStr[] = "Lark_2Fannotation_2FEnclosingClass_3B";
+} // namespace
+
+// Reflection metadata
+// This file is used to generate the classmetadata and classhashmetadata.
+//
+// A. Classmetadata is consists of three parts:classinfo, fields, methods,
+//    and we generates these data according to the structure which defined in
+//    the reflection_analysis.h && metadata_layout.h and then add their address
+//    to mirbuilder.
+namespace maple {
+std::string ReflectionAnalysis::strTab = std::string(1, '\0');
+std::unordered_map<std::string, uint32> ReflectionAnalysis::str2IdxMap;
+std::string ReflectionAnalysis::strTabStartHot = std::string(1, '\0');
+std::string ReflectionAnalysis::strTabBothHot = std::string(1, '\0');
+std::string ReflectionAnalysis::strTabRunHot = std::string(1, '\0');
+bool ReflectionAnalysis::strTabInited = false;
+uint32_t ReflectionAnalysis::hotMethodMeta = 0;
+uint32_t ReflectionAnalysis::totalMethodMeta = 0;
+uint32_t ReflectionAnalysis::hotClassMeta = 0;
+uint32_t ReflectionAnalysis::totalClassMeta = 0;
+uint32_t ReflectionAnalysis::hotFieldMeta = 0;
+uint32_t ReflectionAnalysis::totalFieldMeta = 0;
+uint32_t ReflectionAnalysis::hotCStr = 0;
+uint32_t ReflectionAnalysis::totalCStr = 0;
+std::map<std::list<Klass*>, std::string> ReflectionAnalysis::superClasesIdxMap{};
+
+void ReflectionAnalysis::GenFieldTypeClassInfo(const MIRType &type, const Klass &klass, std::string &classInfo,
+                                               const std::string fieldName, bool &isClass) {
+  switch (type.GetKind()) {
+    case kTypeScalar: {
+      isClass = false;
+      break;
+    }
+    case kTypePointer: {
+      auto *ptype = static_cast<const MIRPtrType&>(type).GetPointedType();
+      CHECK_NULL_FATAL(ptype);
+      if (ptype->GetKind() == kTypeArray || ptype->GetKind() == kTypeJArray ||
+          ptype->GetKind() == kTypeClassIncomplete || ptype->GetKind() == kTypeInterfaceIncomplete) {
+        isClass = false;
+      } else if (ptype->GetKind() == kTypeByName || ptype->GetKind() == kTypeClass ||
+                 ptype->GetKind() == kTypeInterface || ptype->GetKind() == kTypeConstString) {
+        MIRStructType *classTypeSecond = static_cast<MIRStructType*>(ptype);
+        classInfo = CLASSINFO_PREFIX_STR + classTypeSecond->GetName();
+        isClass = true;
+      } else {
+        CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass.GetKlassName().c_str(),
+                    fieldName.c_str());
+      }
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass.GetKlassName().c_str(), fieldName.c_str());
+    }
+  }
+}
+
+bool ReflectionAnalysis::IsMemberClass(const std::string &annotationString) {
+  uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(kEnclosingClassStr);
+  std::string target = annoDelimiterPrefix + std::to_string(idx) + annoDelimiter;
+  if (annotationString.find(target, 0) != std::string::npos) {
+    return true;
+  }
+  return false;
+}
+
+int8_t ReflectionAnalysis::GetAnnoFlag(const std::string &annotationString) {
+  constexpr int8_t kMemberPosValid = 1;
+  constexpr int8_t kMemberPosValidOffset = 2;
+  constexpr int8_t kIsMemberClassOffset = 1;
+  constexpr int8_t kNewMeta = 1;
+  bool isMemberClass = IsMemberClass(annotationString);
+  int8_t value = (kMemberPosValid << kMemberPosValidOffset) +
+                 (static_cast<uint8_t>(isMemberClass) << kIsMemberClassOffset) + kNewMeta;
+  return value;
+}
+
+int ReflectionAnalysis::GetDeflateStringIdx(const std::string &subStr, bool needSpecialFlag) {
+  std::string flag = needSpecialFlag ? (std::to_string(GetAnnoFlag(subStr)) + annoDelimiter) : "1!";
+  return FindOrInsertReflectString(flag + subStr);
+}
+
+uint32 ReflectionAnalysis::FirstFindOrInsertRepeatString(const std::string &str, bool isHot, uint8 hotType) {
+  auto it = ReflectionAnalysis::GetStr2IdxMap().find(str);
+  if (it != ReflectionAnalysis::GetStr2IdxMap().end()) {
+    return it->second;
+  }
+
+  uint32 index = 0;
+  constexpr uint32 lengthShift = 2u;
+  if (isHot) {
+    if (hotType == kLayoutBootHot) {
+      uint32 length = ReflectionAnalysis::GetStrTabStartHot().length();
+      index = (length << lengthShift) | (kLayoutBootHot + kCStringShift);  // Use the LSB to indicate hotness.
+      ReflectionAnalysis::AddStrTabStartHot(str + '\0');
+    } else if (hotType == kLayoutBothHot) {
+      uint32 length = ReflectionAnalysis::GetStrTabBothHot().length();
+      index = (length << lengthShift) | (kLayoutBothHot + kCStringShift);  // Use the LSB to indicate hotness.
+      ReflectionAnalysis::AddStrTabBothHot(str + '\0');
+    } else {
+      uint32 length = ReflectionAnalysis::GetStrTabRunHot().length();
+      index = (length << lengthShift) | (kLayoutRunHot + kCStringShift);  // Use the LSB to indicate hotness.
+      ReflectionAnalysis::AddStrTabRunHot(str + '\0');
+    }
+  } else {
+    uint32 length = ReflectionAnalysis::GetStrTab().length();
+    index = length << lengthShift;
+    ReflectionAnalysis::AddStrTab(str + '\0');
+  }
+  ReflectionAnalysis::SetStr2IdxMap(str, index);
+
+  return index;
+}
+
+void ReflectionAnalysis::InitReflectString() {
+  std::string initHot[] = { "V", "Z", "B", "C", "S", "I", "J", "F", "D", "Ljava/lang/String;", "Ljava/lang/Object;" };
+  for (auto const &innerType : initHot) {
+    (void)FirstFindOrInsertRepeatString(innerType, true, kLayoutBothHot);
+  }
+}
+
+uint32 ReflectionAnalysis::FindOrInsertRepeatString(const std::string &str, bool isHot, uint8 hotType) {
+  if (!strTabInited) {
+    // Add default hot strings.
+    InitReflectString();
+    strTabInited = true;
+  }
+  return FirstFindOrInsertRepeatString(str, isHot, hotType);
+}
+
+BaseNode *ReflectionAnalysis::GenClassInfoAddr(BaseNode *obj, MIRBuilder &builder) {
+  GenMetadataType(builder.GetMirModule());
+  auto *objectType = static_cast<MIRClassType*>(WKTypes::Util::GetJavaLangObjectType());
+  BaseNode *classinfoAddress = nullptr;
+  if (objectType != nullptr && objectType->GetKind() != kTypeClassIncomplete) {
+    classinfoAddress = builder.CreateExprIread(*GlobalTables::GetTypeTable().GetRef(),
+                                               *GlobalTables::GetTypeTable().GetOrCreatePointerType(*objectType),
+                                               kObjKlassFieldID, obj);
+  } else {
+    // If java.lang.Object type is not defined, fall back to use the classinfo struct to retrieve the first field.
+    auto *classMetadataType = static_cast<MIRStructType*>(
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(ReflectionAnalysis::classMetadataTyIdx));
+    classinfoAddress = builder.CreateExprIread(*GlobalTables::GetTypeTable().GetRef(),
+                                               *GlobalTables::GetTypeTable().GetOrCreatePointerType(*classMetadataType),
+                                               kMetaDataKlassFieldID, obj);
+  }
+  return classinfoAddress;
+}
+
+const char *ReflectionAnalysis::klassPtrName = namemangler::kShadowClassName;
+TyIdx ReflectionAnalysis::classMetadataTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::classMetadataRoTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::methodsInfoTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::methodsInfoCompactTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::fieldsInfoTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::fieldsInfoCompactTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::superclassMetadataTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::fieldOffsetDataTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::methodAddrDataTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::methodSignatureTyIdx = TyIdx(0);
+TyIdx ReflectionAnalysis::invalidIdx = TyIdx(-1);
+
+uint32 ReflectionAnalysis::GetMethodModifier(const Klass &klass, const MIRFunction &func) const {
+  const FuncAttrs &fa = func.GetFuncAttrs();
+  uint32 mod =
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_public)) << (kModPublic - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_protected)) << (kModProtected - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_private)) << (kModPrivate - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_abstract)) << (kModAbstract - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_static)) << (kModStatic - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_final)) << (kModFinal - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_declared_synchronized)) << (kModSynchronized - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_declared_synchronized)) << (kModDeclaredSynchronized - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_native)) << (kModNative - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_strict)) << (kModStrict - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_synthetic)) << (kModSynthetic - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_bridge)) << (kModBridge - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_constructor)) << (kModConstructor - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_varargs)) << (kModVarargs - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_hiddenapigrey)) << (kModifierHiddenApiGrey - 1)) |
+      (static_cast<unsigned char>(fa.GetAttr(FUNCATTR_hiddenapiblack)) << (kModifierHiddenApiBlack - 1));
+  // Add default attribute.
+  if (klass.IsInterface() && !func.GetAttr(FUNCATTR_abstract) && !func.GetAttr(FUNCATTR_static)) {
+    mod |= (1 << (kModDefault));
+  }
+  return mod;
+}
+
+uint32 GetFieldModifier(const FieldAttrs &fa) {
+  return (static_cast<unsigned char>(fa.GetAttr(FLDATTR_public)) << (kModPublic - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_protected)) << (kModProtected - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_private)) << (kModPrivate - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_static)) << (kModStatic - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_final)) << (kModFinal - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_transient)) << (kModTransient - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_volatile)) << (kModVolatile - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_synthetic)) << (kModSynthetic - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_enum)) << (kModEnum - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_rcunowned)) << (kModifierRCUnowned - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_rcweak)) << (kModifierRCWeak - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_hiddenapigrey)) << (kModifierHiddenApiGrey - 1)) |
+         (static_cast<unsigned char>(fa.GetAttr(FLDATTR_hiddenapiblack)) << (kModifierHiddenApiBlack - 1));
+}
+
+uint32 GetClassAccessFlags(const MIRStructType &classType) {
+  uint32 originAF = 0;
+  size_t size = classType.GetInfo().size();
+  for (size_t i = 0; i < size; ++i) {
+    if (GlobalTables::GetStrTable().GetStringFromStrIdx(classType.GetInfoElemt(i).first) == kINFOAccessFlags) {
+      originAF = classType.GetInfoElemt(i).second;
+    }
+  }
+
+  int32 accessFlag = 0;
+  for (const MIRPragma *prag : classType.GetPragmaVec()) {
+    if (prag->GetKind() == kPragmaClass) {
+      const MapleVector<MIRPragmaElement*> elemVector = prag->GetElementVector();
+      for (MIRPragmaElement *elem : elemVector) {
+        const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(elem->GetNameStrIdx());
+        if (name == kAccessFlags) {
+          accessFlag = elem->GetI32Val();
+          accessFlag |= static_cast<int32>((originAF & static_cast<uint32>(kModPublic)) <<
+                                           static_cast<uint32>(kModifierAFOriginPublic - 1));
+          return static_cast<uint32>(accessFlag);
+        }
+      }
+    }
+  }
+  return originAF;
+}
+
+bool ReflectionAnalysis::IsStaticClass(const MIRStructType &classType) const {
+  return GetClassAccessFlags(classType) & 0x00000008;  // #  Modifier_Static 0x00000008;
+}
+
+bool ReflectionAnalysis::IsPrivateClass(const MIRClassType &classType) const {
+  return GetClassAccessFlags(classType) & 0x00000002;  // #  Modifier_Private 0x00000002;
+}
+
+static inline GStrIdx GetOrCreateGStrIdxFromName(const std::string &name) {
+  return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::GetInternalNameLiteral(name));
+}
+
+static bool IsFinalize(const std::string &funcName, const std::string &signature) {
+  return funcName == "finalize" && signature == "()V";
+}
+
+static std::string GetSignatureFromFullName(const std::string &fullname) {
+  size_t pos = fullname.find("|");
+  if (pos != std::string::npos) {
+    return fullname.substr(pos + 1);
+  }
+  FATAL(kLncFatal, "can not find \"|\" in fullname");
+}
+
+int ReflectionAnalysis::SolveAnnotation(MIRStructType &classType, const MIRFunction &func) {
+  std::string annoArray1;
+  std::map<int, int> idxNumMap;
+  GenAnnotation(idxNumMap, annoArray1, classType, kPragmaFunc, func.GetName(), invalidIdx);
+  // Parameter annotation.
+  std::string annoArray2;
+  std::map<int, int> paramNumArray;
+  int paramIndex = 0;
+  std::map<int, int> paramIdxNumMap;
+  GenAnnotation(paramIdxNumMap, annoArray2, classType, kPragmaParam, func.GetName(), invalidIdx, &paramNumArray,
+                &paramIndex);
+  std::string subStr = "";
+  if (idxNumMap.empty() && paramIdxNumMap.empty()) {
+    subStr += "0";
+  } else {
+    subStr += std::to_string(idxNumMap.size());
+    subStr += "!";
+    std::for_each(idxNumMap.begin(), idxNumMap.end(), [&subStr](const std::pair<const int, int> p) {
+      subStr += std::to_string(p.second);
+      subStr += "!";
+    });
+    subStr += annoArray1;
+    // Parameter.
+    subStr += '|';
+    subStr += std::to_string(paramIdxNumMap.size());
+    subStr += "!";
+    std::for_each(paramIdxNumMap.begin(), paramIdxNumMap.end(), [&subStr](const std::pair<const int, int> p) {
+      subStr += std::to_string(p.second);
+      subStr += "!";
+    });
+    for (int z = 0; z < paramIndex; ++z) {
+      subStr += std::to_string(paramNumArray[z]);
+      subStr += "!";
+    }
+    subStr += annoArray2;
+  }
+  return GetDeflateStringIdx(subStr, false);
+}
+
+uint32 ReflectionAnalysis::GetTypeNameIdxFromType(const MIRType &type, const Klass &klass,
+    const std::string &fieldName) {
+  uint32 typeNameIdx = 0;
+  switch (type.GetKind()) {
+    case kTypeScalar: {
+      std::string name(GetPrimTypeJavaName(type.GetPrimType()));
+      typeNameIdx = FindOrInsertReflectString(name);
+      break;
+    }
+    case kTypePointer: {
+      auto *ptype = static_cast<const MIRPtrType&>(type).GetPointedType();
+      if (ptype->GetKind() == kTypeArray || ptype->GetKind() == kTypeJArray) {
+        if (kRADebug && 0) {
+          ptype->Dump(0, false);
+        }
+        CHECK_NULL_FATAL(ptype);
+        const std::string &javaName = static_cast<MIRJarrayType*>(ptype)->GetJavaName();
+        std::string klassJavaDescriptor;
+        namemangler::DecodeMapleNameToJavaDescriptor(javaName, klassJavaDescriptor);
+        typeNameIdx = FindOrInsertReflectString(klassJavaDescriptor);
+      } else if (ptype->GetKind() == kTypeByName || ptype->GetKind() == kTypeClass ||
+                 ptype->GetKind() == kTypeInterface || ptype->GetKind() == kTypeClassIncomplete ||
+                 ptype->GetKind() == kTypeInterfaceIncomplete || ptype->GetKind() == kTypeConstString) {
+        std::string javaName = ptype->GetName();
+        std::string klassJavaDescriptor;
+        namemangler::DecodeMapleNameToJavaDescriptor(javaName, klassJavaDescriptor);
+        typeNameIdx = FindOrInsertReflectString(klassJavaDescriptor);
+      } else {
+        CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass.GetKlassName().c_str(),
+                    fieldName.c_str());
+      }
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass.GetKlassName().c_str(), fieldName.c_str());
+    }
+  }
+  return typeNameIdx;
+}
+
+void ReflectionAnalysis::CheckPrivateInnerAndNoSubClass(Klass &clazz, const std::string &annoArr) {
+  // LMain_24A_3B  `EC!`VL!24!LMain_3B!`IC!`AF!4!2!name!23!A!
+  uint32_t idx = FindOrInsertReflectString(kEnclosingClassStr);
+  std::string target = annoDelimiterPrefix + std::to_string(idx) + annoDelimiter;
+  size_t pos = annoArr.find(kEnclosingClassStr, 0);
+  if (pos == std::string::npos) {
+    return;
+  }
+  ASSERT_NOT_NULL(clazz.GetMIRClassType());
+  if (!IsPrivateClass(*clazz.GetMIRClassType())) {
+    return;  // Check private.
+  }
+  if (clazz.HasSubKlass()) {
+    clazz.SetPrivateInnerAndNoSubClass(false);
+  } else {
+    clazz.SetPrivateInnerAndNoSubClass(true);
+  }
+}
+
+uint16 GetCharHashIndex(const std::string &name) {
+  unsigned int hashCode = DJBHash(name.c_str());
+  return static_cast<uint16>(hashCode % kMethodFieldHashSize);
+}
+
+uint16 GenMethodHashIndex(const std::string &name, const std::string &signature) {
+  std::string fullName = name + signature;
+  size_t p = fullName.find(')');
+  CHECK_FATAL(p != std::string::npos, "can not find )");
+  std::string subName = fullName.substr(0, p + 1);
+  uint16 h = GetCharHashIndex(subName);
+  return h;
+}
+
+void ReflectionAnalysis::ConvertMethodSig(std::string &signature) {
+  size_t signatureSize = signature.size();
+  for (size_t i = 1; i < signatureSize; ++i) {
+    if (signature[i] == 'L') {
+      while (++i < signatureSize && signature[i] != ';') {}
+    } else if (signature[i] == 'A') {
+      signature[i] = '[';
+    }
+  }
+}
+
+void ReflectionAnalysis::GenAllMethodHash(std::vector<std::pair<MethodPair*, int>> &methodInfoVec,
+                                          std::unordered_map<uint32, std::string> &baseNameMap,
+                                          std::unordered_map<uint32, std::string> &fullNameMap) {
+  std::vector<MIRFunction*> methodVector;
+  std::vector<uint16> hashVector;
+  for (auto &methodInfo : methodInfoVec) {
+    MIRSymbol *funcSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodInfo.first->first.Idx());
+    MIRFunction *func = funcSym->GetFunction();
+    std::string baseName = func->GetBaseFuncName();
+    baseName = namemangler::DecodeName(baseName);
+    baseNameMap[func->GetBaseFuncNameStrIdx()] = baseName;
+    std::string fullName = func->GetBaseFuncNameWithType();
+    fullName = namemangler::DecodeName(fullName);
+    fullNameMap[func->GetBaseFuncNameWithTypeStrIdx()] = fullName;
+    CHECK_FATAL(fullName.find("|") != std::string::npos, "can not find |");
+    std::string signature = fullName.substr(fullName.find("|") + 1);
+    ConvertMethodSig(signature);
+    uint16 h = GenMethodHashIndex(baseName, signature);
+    if (IsFinalize(baseName, signature)) {
+      h = kHashConflictFlag;
+    }
+    func->SetHashCode(h);
+    hashVector.push_back(h);
+  }
+}
+
+void ReflectionAnalysis::GenAllFieldHash(std::vector<std::pair<FieldPair, uint16>> &fieldV) const {
+  std::vector<MIRFunction*> methodVector;
+  std::vector<uint16> hashVector;
+  for (auto &field : fieldV) {
+    uint16 h = field.second;
+    hashVector.push_back(h);
+  }
+}
+
+uint16 GetFieldHash(const std::vector<std::pair<FieldPair, uint16>> &fieldV, const FieldPair &fieldSources) {
+  for (const auto &field : fieldV) {
+    const FieldPair &f = field.first;
+    if (f == fieldSources) {
+      return field.second;
+    }
+  }
+  return 0;
+}
+
+MIRSymbol *ReflectionAnalysis::GetOrCreateSymbol(const std::string &name, TyIdx tyIdx, bool needInit = false) {
+  const GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  MIRSymbol *st = GetSymbol(strIdx, tyIdx);
+  if (st != nullptr && !needInit) {
+    // Previous symbol is a forward declaration, create a new symbol for definiton.
+    return st;
+  }
+  st = CreateSymbol(strIdx, tyIdx);
+  // Set classinfo symbol as extern if not defined locally.
+  if (StringUtils::StartsWith(name, CLASSINFO_PREFIX_STR)) {
+    std::string className = name.substr(strlen(CLASSINFO_PREFIX_STR));
+    Klass *klass = klassH->GetKlassFromName(className);
+    if (klass != nullptr && !klass->GetMIRStructType()->IsLocal()) {
+      st->SetStorageClass(kScExtern);
+    }
+  }
+  return st;
+}
+
+MIRSymbol *ReflectionAnalysis::GetSymbol(const std::string &name, TyIdx tyIdx) {
+  const GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
+  MIRSymbol *st = GetSymbol(strIdx, tyIdx);
+  return st;
+}
+
+static bool IsSameType(TyIdx tyIdx1, TyIdx tyIdx2) {
+  if (tyIdx1 == tyIdx2) {
+    return true;
+  }
+  MIRType *type1 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx1);
+  MIRType *type2 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx2);
+  return type1->EqualTo(*type2);
+}
+
+MIRSymbol *ReflectionAnalysis::GetSymbol(GStrIdx strIdx, TyIdx tyIdx) {
+  MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+  if (st != nullptr && st->GetSKind() == kStVar) {
+    if (IsSameType(st->GetTyIdx(), tyIdx)) {
+      return st;
+    } else {
+      auto *type1 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+      auto *type2 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(st->GetTyIdx());
+      if (type1->GetKind() == kTypeStruct && type2->GetKind() == kTypeStructIncomplete) {
+        st->SetTyIdx(tyIdx);
+        return st;
+      }
+    }
+  }
+  return nullptr;
+}
+
+MIRSymbol *ReflectionAnalysis::CreateSymbol(GStrIdx strIdx, TyIdx tyIdx) {
+  MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+  st->SetStorageClass(kScGlobal);
+  st->SetSKind(kStVar);
+  st->SetNameStrIdx(strIdx);
+  GlobalTables::GetGsymTable().AddToStringSymbolMap(*st);
+  st->SetAttr(ATTR_public);
+  st->SetTyIdx(tyIdx);
+  return st;
+}
+
+bool ReflectionAnalysis::VtableFunc(const MIRFunction &func) const {
+  return (func.GetAttr(FUNCATTR_virtual) && !func.GetAttr(FUNCATTR_private) && !func.GetAttr(FUNCATTR_static));
+}
+
+bool RtRetentionPolicyCheck(const MIRSymbol &clInfo) {
+  GStrIdx strIdx;
+  auto *annoType =
+      static_cast<MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(clInfo.GetTyIdx()));
+  for (MIRPragma *p : annoType->GetPragmaVec()) {
+    if (GlobalTables::GetStrTable().GetStringFromStrIdx(
+            GlobalTables::GetTypeTable().GetTypeFromTyIdx(p->GetTyIdx())->GetNameStrIdx()) ==
+        (kJavaLangAnnotationRetentionStr)) {
+      strIdx.reset(p->GetNthElement(0)->GetU64Val());
+      std::string retentionType = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+      if (retentionType != "RUNTIME") {
+        return false;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+uint16 ReflectionAnalysis::GetMethodInVtabIndex(const Klass &klass, const MIRFunction &func) const {
+  uint16 methodInVtabIndex = 0;
+  bool findMethod = false;
+  const MIRStructType *classType = klass.GetMIRStructType();
+  const MIRSymbol *vtableSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+      GlobalTables::GetStrTable().GetStrIdxFromName(VTAB_PREFIX_STR + klass.GetKlassName()));
+  if (klass.IsClass() && vtableSymbol != nullptr) {
+    const auto *vtableConst = static_cast<const MIRAggConst*>(vtableSymbol->GetKonst());
+    for (const MIRConstPtr &node : vtableConst->GetConstVec()) {
+      if (node->GetKind() == kConstAddrofFunc) {
+        const auto *addr = static_cast<const MIRAddroffuncConst*>(node);
+        MIRFunction *vtableFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(addr->GetValue());
+        if (func.GetNameStrIdx() == vtableFunc->GetNameStrIdx()) {
+          findMethod = true;
+          break;
+        }
+      }
+      ++methodInVtabIndex;
+    }
+  } else if (klass.IsInterface()) {
+    methodInVtabIndex = 0;
+    for (const MethodPair &methodPair : classType->GetMethods()) {
+      const MIRSymbol *currSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodPair.first.Idx());
+      const MIRFunction *currFunc = currSym->GetFunction();
+      if (func.GetNameStrIdx() == currFunc->GetNameStrIdx()) {
+        findMethod = true;
+        break;
+      }
+      ++methodInVtabIndex;
+    }
+  }
+  if (!findMethod) {
+    methodInVtabIndex = static_cast<uint16>(kMethodNotFound);
+  }
+  return methodInVtabIndex;
+}
+
+void ReflectionAnalysis::GetSignatureTypeNames(std::string &signature, std::vector<std::string> &typeNames) {
+  ConvertMethodSig(signature);
+  size_t sigLen = signature.length();
+  size_t i = 0;
+  ++i;
+  while (i < sigLen && signature.at(i) != ')') {
+    std::string descriptor;
+    if (signature.at(i) != 'L' && signature.at(i) != '[') {
+      descriptor += signature.at(i);
+    } else {
+      if (signature.at(i) == '[') {
+        while (signature.at(i) == '[') {
+          descriptor += signature.at(i++);
+        }
+      }
+      if (signature.at(i) != 'L') {
+        descriptor += signature.at(i);
+      } else {
+        while (signature.at(i) != ';') {
+          descriptor += signature.at(i++);
+        }
+        descriptor += ';';
+      }
+    }
+    typeNames.push_back(descriptor);
+    ++i;
+  }
+  // Return type.
+  ++i;
+  typeNames.emplace_back(signature.c_str() + i);
+}
+
+struct HashCodeComparator {
+  const std::unordered_map<uint32, std::string> &basenameMp;
+  const std::unordered_map<uint32, std::string> &fullnameMp;
+  HashCodeComparator(const std::unordered_map<uint32, std::string> &arg1,
+                     const std::unordered_map<uint32, std::string> &arg2)
+      : basenameMp(arg1), fullnameMp(arg2) {}
+
+  bool operator()(std::pair<MethodPair*, int> a, std::pair<MethodPair*, int> b) {
+    const MIRSymbol *funcSymA = GlobalTables::GetGsymTable().GetSymbolFromStidx(a.first->first.Idx());
+    const MIRFunction *funcA = funcSymA->GetFunction();
+    auto itB = basenameMp.find(funcA->GetBaseFuncNameStrIdx());
+    ASSERT(itB != basenameMp.end(), "check funcAname!");
+    const std::string &funcAName = itB->second;
+    auto itF = fullnameMp.find(funcA->GetBaseFuncNameWithTypeStrIdx());
+    ASSERT(itF != fullnameMp.end(), "check funcAname!");
+    const std::string &fullNameA = itF->second;
+    CHECK_FATAL(fullNameA.find("|") != fullNameA.npos, "not found |");
+    const std::string &signatureA = fullNameA.substr(fullNameA.find("|") + 1);
+    const MIRSymbol *funcSymB = GlobalTables::GetGsymTable().GetSymbolFromStidx(b.first->first.Idx());
+    const MIRFunction *funcB = funcSymB->GetFunction();
+    itB = basenameMp.find(funcB->GetBaseFuncNameStrIdx());
+    ASSERT(itB != basenameMp.end(), "check funcBname!");
+    const std::string &funcBName = itB->second;
+    itF = fullnameMp.find(funcB->GetBaseFuncNameWithTypeStrIdx());
+    ASSERT(itF != fullnameMp.end(), "check funcBname!");
+    const std::string &fullNameB = itF->second;
+    CHECK_FATAL(fullNameB.find("|") != std::string::npos, "not found |");
+    const std::string &signatureB = fullNameB.substr(fullNameB.find("|") + 1);
+    // Make bridge the end.
+    if (funcA->GetHashCode() == funcB->GetHashCode() && funcA->GetBaseFuncName() == funcB->GetBaseFuncName())  {
+      // Only deal with return type is different.
+      if ((funcA->GetAttr(FUNCATTR_bridge)) && !(funcB->GetAttr(FUNCATTR_bridge))) {
+        return true;
+      }
+      if (!(funcA->GetAttr(FUNCATTR_bridge)) && (funcB->GetAttr(FUNCATTR_bridge))) {
+        return false;
+      }
+    }
+    // As finalize()V is frequency, check it first, we put it at the end method_s.
+    if (IsFinalize(funcAName, signatureA) && !IsFinalize(funcBName, signatureB)) {
+      return false;
+    }
+    if (!IsFinalize(funcAName, signatureA) && IsFinalize(funcBName, signatureB)) {
+      return true;
+    }
+    return funcA->GetHashCode() < funcB->GetHashCode();
+  }
+};
+
+uint32 ReflectionAnalysis::GetMethodFlag(const MIRFunction &func) const {
+  uint32 flag = 0;
+  if (!VtableFunc(func)) {
+    flag |= kMethodNotVirtual;
+  }
+  GStrIdx finalizeMethod = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("finalize_7C_28_29V");
+  if (func.GetBaseFuncNameWithTypeStrIdx() == finalizeMethod) {
+    flag |= kMethodFinalize;
+  }
+  if (func.GetAttr(FUNCATTR_abstract)) {
+    flag |= kMethodAbstract;
+  }
+  uint16 hash = func.GetHashCode();
+  flag |= (hash << kNoHashBits);  // hash 10 bit
+
+  bool isProfHotMethod = (*mirModule).GetProfile().CheckMethodSigHot(func.GetBaseFuncNameWithType());
+  if (isProfHotMethod) {
+    flag |= kMethodSignature; // check profile
+  }
+  return flag;
+}
+
+void ReflectionAnalysis::GenMethodMeta(const Klass &klass, MIRStructType &methodsInfoType,
+                                       const MIRSymbol &funcSym, MIRAggConst &aggConst, int idx,
+                                       std::unordered_map<uint32, std::string> &baseNameMp,
+                                       std::unordered_map<uint32, std::string> &fullNameMp) {
+  MIRFunction &func = *funcSym.GetFunction();
+  MIRAggConst &newConst = *mirModule->GetMemPool()->New<MIRAggConst>(*mirModule, methodsInfoType);
+  uint32 fieldID = 1;
+  // @method_in_vtable_index
+  uint32 methodInVtabIndex = GetMethodInVtabIndex(klass, func);
+  if (Options::deferredVisit2 && VtableAnalysis::IsVtableCandidate(func)) {
+    // We generate new vtable index in the order of idx instead of -10 when DAI2.0 is open.
+    // As idx begins at 0, we add 1 to vtable index so it would be starting with 1.
+    methodInVtabIndex = (methodInVtabIndex != static_cast<uint16>(kMethodNotFound)) ? methodInVtabIndex
+                                                                                    : static_cast<uint32>(idx + 1);
+  }
+  mirBuilder.AddIntFieldConst(methodsInfoType, newConst, fieldID++, methodInVtabIndex);
+  // @declaringclass
+  MIRSymbol *dklassSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + func.GetBaseClassName(), classMetadataTyIdx);
+  mirBuilder.AddAddrofFieldConst(methodsInfoType, newConst, fieldID++, *dklassSt);
+  // @addr : Function address or point function addr if lazyBinding or decouple
+  if (isLazyBindingOrDecouple) {
+    MIRSymbol *methodAddrSt = GenMethodAddrData(funcSym);
+    if (methodAddrSt != nullptr) {
+      mirBuilder.AddAddrofFieldConst(methodsInfoType, newConst, fieldID++, *methodAddrSt);
+    } else {
+      mirBuilder.AddIntFieldConst(methodsInfoType, newConst, fieldID++, 0);
+    }
+  } else {
+    mirBuilder.AddAddroffuncFieldConst(methodsInfoType, newConst, fieldID++, funcSym);
+  }
+
+  // @modifier
+  uint32 mod = GetMethodModifier(klass, func);
+  mirBuilder.AddIntFieldConst(methodsInfoType, newConst, fieldID++, mod);
+  // @methodname
+  std::string baseName = baseNameMp[func.GetBaseFuncNameStrIdx()];
+  uint32 methodnameIdx = FindOrInsertReflectString(baseName);
+  mirBuilder.AddIntFieldConst(methodsInfoType, newConst, fieldID++, methodnameIdx);
+  // @methodsignature
+  std::string fullname = fullNameMp[func.GetBaseFuncNameWithTypeStrIdx()];
+  std::string signature = GetSignatureFromFullName(fullname);
+  ConvertMethodSig(signature);
+
+  uint32 flag = GetMethodFlag(func);
+  // if enable MethodSignature, will generate MethodSignatureSymbol with signature and parameter types cache,
+  // otherwise we generate signatureoffset directly.
+  bool isEnableMethodSignature = (flag & kMethodSignature) == kMethodSignature;
+  if (isEnableMethodSignature) {
+    MIRSymbol *methodSignatureSymbol = GetMethodSignatureSymbol(signature);
+    mirBuilder.AddAddrofFieldConst(methodsInfoType, newConst, fieldID++, *methodSignatureSymbol);
+  } else {
+    uint32 signatureIdx = FindOrInsertReflectString(signature);
+    mirBuilder.AddIntFieldConst(methodsInfoType, newConst, fieldID++, signatureIdx);
+  }
+
+  // @annotation
+  MIRStructType *classType = klass.GetMIRStructType();
+  int annotationIdx = SolveAnnotation(*classType, func);
+  mirBuilder.AddIntFieldConst(methodsInfoType, newConst, fieldID++, annotationIdx);
+  // @flag
+  mirBuilder.AddIntFieldConst(methodsInfoType, newConst, fieldID++, flag);
+  // @argsize: Number of arguments.
+  size_t argsSize = func.GetParamSize();
+  mirBuilder.AddIntFieldConst(methodsInfoType, newConst, fieldID++, argsSize);
+#ifndef USE_32BIT_REF
+  // @padding
+  mirBuilder.AddIntFieldConst(methodsInfoType, newConst, fieldID, 0);
+#endif
+  aggConst.AddItem(&newConst, 0);
+}
+
+MIRSymbol *ReflectionAnalysis::GenMethodsMeta(const Klass &klass,
+                                              std::vector<std::pair<MethodPair*, int>> &methodInfoVec,
+                                              std::unordered_map<uint32, std::string> &baseNameMp,
+                                              std::unordered_map<uint32, std::string> &fullNameMp) {
+  MIRStructType *classType = klass.GetMIRStructType();
+  size_t arraySize = classType->GetMethods().size();
+  auto &methodsInfoType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(methodsInfoTyIdx));
+  MIRArrayType &arrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(methodsInfoType, arraySize);
+  MIRAggConst *aggConst = mirModule->GetMemPool()->New<MIRAggConst>(*mirModule, arrayType);
+  ASSERT(aggConst != nullptr, "null ptr check!");
+  int idx = 0;
+  for (auto &methodInfo : methodInfoVec) {
+    MIRSymbol *funcSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodInfo.first->first.Idx());
+    ASSERT_NOT_NULL(funcSym);
+    reflectionMuidStr += funcSym->GetName();
+    GenMethodMeta(klass, methodsInfoType, *funcSym, *aggConst, idx++, baseNameMp, fullNameMp);
+  }
+  MIRSymbol *methodsArraySt =
+      GetOrCreateSymbol(namemangler::kMethodsInfoPrefixStr + klass.GetKlassName(), arrayType.GetTypeIndex(), true);
+  methodsArraySt->SetStorageClass(kScFstatic);
+  methodsArraySt->SetKonst(aggConst);
+  return methodsArraySt;
+}
+
+MIRSymbol *ReflectionAnalysis::GenMethodAddrData(const MIRSymbol &funcSym) {
+  MIRModule &module = *mirModule;
+  MIRStructType &methodAddrType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(methodAddrDataTyIdx));
+  MIRArrayType &methodAddrArrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(methodAddrType, 1);
+  MIRAggConst *aggconst = module.GetMemPool()->New<MIRAggConst>(module, methodAddrArrayType);
+  MIRAggConst *newconst = module.GetMemPool()->New<MIRAggConst>(module, methodAddrType);
+  MIRFunction *func = funcSym.GetFunction();
+  MIRSymbol *methodAddrSt = nullptr;
+  // skip abstract func.
+  if (!func->IsAbstract()) {
+    mirBuilder.AddAddroffuncFieldConst(methodAddrType, *newconst, 1, funcSym);
+    aggconst->AddItem(newconst, 0);
+    methodAddrSt = GetOrCreateSymbol(namemangler::kMethodAddrDataPrefixStr + func->GetName(),
+                                     methodAddrArrayType.GetTypeIndex(), true);
+    methodAddrSt->SetStorageClass(kScFstatic);
+    methodAddrSt->SetKonst(aggconst);
+  }
+  return methodAddrSt;
+}
+
+MIRSymbol *ReflectionAnalysis::GetParameterTypesSymbol(uint32 size, uint32 index) {
+  MIRModule &module = *mirModule;
+  MIRStructType parameterTypesType(kTypeStruct);
+#ifndef USE_32BIT_REF
+  MIRType *type = GlobalTables::GetTypeTable().GetUInt64();
+#else
+  MIRType *type = GlobalTables::GetTypeTable().GetUInt32();
+#endif
+  for (uint32 i = 0; i < size; i++) {
+    GlobalTables::GetTypeTable().AddFieldToStructType(parameterTypesType, kParameterTypeItemName, *type);
+  }
+
+  TyIdx parameterTypesTyIdx = GenMetaStructType(module, parameterTypesType,
+                                                kParameterTypesName + std::to_string(index));
+  MIRStructType &parameterTypes =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(parameterTypesTyIdx));
+  MIRSymbol *parameterTypesSt =
+      GetOrCreateSymbol(namemangler::kParameterTypesPrefixStr + std::to_string(index),
+      parameterTypes.GetTypeIndex(), true);
+  parameterTypesSt->SetStorageClass(kScFstatic);
+  return parameterTypesSt;
+}
+
+MIRSymbol *ReflectionAnalysis::GetMethodSignatureSymbol(std::string signature) {
+  if (mapMethodSignature.find(signature) != mapMethodSignature.end()) {
+    return mapMethodSignature[signature];
+  }
+
+  std::vector<std::string> typeNames;
+  GetSignatureTypeNames(signature, typeNames);
+  MIRModule &module = *mirModule;
+  MIRStructType &methodSignatureType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(methodSignatureTyIdx));
+  MIRAggConst *newConst = module.GetMemPool()->New<MIRAggConst>(module, methodSignatureType);
+
+  uint32 fieldID = 1;
+  uint32 signatureIdx = FindOrInsertReflectString(signature);
+  mirBuilder.AddIntFieldConst(methodSignatureType, *newConst, fieldID++, signatureIdx);
+  MIRSymbol *parameterTypesSymbol = GetParameterTypesSymbol(static_cast<uint32>(typeNames.size()),
+                                                            static_cast<uint32>(mapMethodSignature.size()));
+  mirBuilder.AddAddrofFieldConst(methodSignatureType, *newConst, fieldID++, *parameterTypesSymbol);
+
+  MIRSymbol *methodSignatureSt =
+      GetOrCreateSymbol(namemangler::kMethodSignaturePrefixStr + std::to_string(mapMethodSignature.size()),
+      methodSignatureType.GetTypeIndex(), true);
+  methodSignatureSt->SetStorageClass(kScFstatic);
+  methodSignatureSt->SetKonst(newConst);
+  mapMethodSignature[signature] = methodSignatureSt;
+  return methodSignatureSt;
+}
+
+void ReflectionAnalysis::GenMethodMetaCompact(const Klass &klass, MIRStructType &methodsInfoCompactType, int idx,
+                                              const MIRSymbol &funcSym, MIRAggConst &aggConst,
+                                              int &allDeclaringClassOffset,
+                                              std::unordered_map<uint32, std::string> &baseNameMp,
+                                              std::unordered_map<uint32, std::string> &fullNameMp) {
+  MIRFunction &func = *funcSym.GetFunction();
+  MIRAggConst &newConstCompact = *mirModule->GetMemPool()->New<MIRAggConst>(*mirModule, methodsInfoCompactType);
+  std::vector<uint8> methodsCompactLeb128Vec;
+  uint32 fieldIDCompact = 1;
+
+  // @vtableIndex && flag
+  uint32 methodInVtabIndex = GetMethodInVtabIndex(klass, func);
+  if (Options::deferredVisit2 && VtableAnalysis::IsVtableCandidate(func)) {
+    // We generate new vtable index in the order of idx instead of -10 when DAI2.0 is open.
+    // As idx begins at 0, we add 1 to vtable index so it would be starting with 1.
+    methodInVtabIndex = (methodInVtabIndex != static_cast<uint16>(kMethodNotFound)) ? methodInVtabIndex
+                                                                                    : static_cast<uint32>(idx + 1);
+  }
+  constexpr int methodInVtabShift = 16;
+  uint32 flag = GetMethodFlag(func);
+  int32 methodInVtabIndexAndFlag = ((flag | kMethodMetaCompact) << methodInVtabShift) | methodInVtabIndex;
+  mirBuilder.AddIntFieldConst(methodsInfoCompactType, newConstCompact, fieldIDCompact++, methodInVtabIndexAndFlag);
+  int sizeOfMethodMetaCompactLeb128 = sizeof(int32);
+  int declaringClassOffset = allDeclaringClassOffset + sizeof(int32);
+
+  // @addr: point function addr
+  MIRSymbol *methodAddrSt = GenMethodAddrData(funcSym);
+  if (methodAddrSt != nullptr) {
+    mirBuilder.AddAddrofFieldConst(methodsInfoCompactType, newConstCompact, fieldIDCompact++, *methodAddrSt);
+    sizeOfMethodMetaCompactLeb128 += sizeof(int32);
+    declaringClassOffset += sizeof(int32);
+  } else {
+    mirBuilder.AddIntFieldConst(methodsInfoCompactType, newConstCompact, fieldIDCompact++, 0);
+  }
+
+  // @declaringclass offset, leb128
+  namemangler::GetUnsignedLeb128Encode(methodsCompactLeb128Vec, static_cast<uint32>(declaringClassOffset));
+
+  // @modifier
+  uint32 mod = GetMethodModifier(klass, func);
+  namemangler::GetUnsignedLeb128Encode(methodsCompactLeb128Vec, mod);
+
+  // @methodname
+  std::string baseName = baseNameMp[func.GetBaseFuncNameStrIdx()];
+  uint32 methodnameIdx = FindOrInsertReflectString(baseName);
+  namemangler::GetUnsignedLeb128Encode(methodsCompactLeb128Vec, methodnameIdx);
+
+  // @argsize: Number of arguments.
+  size_t argsSize = func.GetParamSize();
+  namemangler::GetUnsignedLeb128Encode(methodsCompactLeb128Vec, static_cast<uint32_t>(argsSize));
+
+  // @methodsignature
+  std::string fullname = fullNameMp[func.GetBaseFuncNameWithTypeStrIdx()];
+  std::string signature = GetSignatureFromFullName(fullname);
+  std::vector<std::string> typeNames;
+  GetSignatureTypeNames(signature, typeNames);
+  for (auto typeName : typeNames) {
+    uint32 typeNameIdx = FindOrInsertReflectString(typeName);
+    namemangler::GetUnsignedLeb128Encode(methodsCompactLeb128Vec, typeNameIdx);
+  }
+
+  // @annotation
+  int annotationIdx = SolveAnnotation(*klass.GetMIRStructType(), func);
+  namemangler::GetUnsignedLeb128Encode(methodsCompactLeb128Vec, static_cast<uint32>(annotationIdx));
+
+  // @leb128
+  sizeOfMethodMetaCompactLeb128 += methodsCompactLeb128Vec.size();
+  allDeclaringClassOffset += sizeOfMethodMetaCompactLeb128;
+  for (auto byte : methodsCompactLeb128Vec) {
+    uint8 byteValue = byte;
+    mirBuilder.AddIntFieldConst(methodsInfoCompactType, newConstCompact, fieldIDCompact, byteValue);
+  }
+  aggConst.AddItem(&newConstCompact, 0);
+}
+
+MIRSymbol *ReflectionAnalysis::GenMethodsMetaCompact(const Klass &klass,
+                                                     std::vector<std::pair<MethodPair*, int>> &methodInfoVec,
+                                                     std::unordered_map<uint32, std::string> &baseNameMp,
+                                                     std::unordered_map<uint32, std::string> &fullNameMp) {
+  MIRStructType *classType = klass.GetMIRStructType();
+  size_t arraySize = classType->GetMethods().size();
+  auto &methodsInfoCompactType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(methodsInfoCompactTyIdx));
+  MIRArrayType &arrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(methodsInfoCompactType, arraySize);
+  MIRAggConst *aggConst = mirModule->GetMemPool()->New<MIRAggConst>(*mirModule, arrayType);
+  ASSERT(aggConst != nullptr, "null ptr check!");
+  int allDeclaringClassOffset = sizeof(int32);
+  int idx = 0;
+  for (auto &methodInfo : methodInfoVec) {
+    MIRSymbol *funcSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodInfo.first->first.Idx());
+    ASSERT_NOT_NULL(funcSym);
+    reflectionMuidStr += funcSym->GetName();
+    GenMethodMetaCompact(klass, methodsInfoCompactType, idx++, *funcSym, *aggConst,
+                         allDeclaringClassOffset, baseNameMp, fullNameMp);
+  }
+  MIRSymbol *methodsArraySt = GetOrCreateSymbol(namemangler::kMethodsInfoCompactPrefixStr + klass.GetKlassName(),
+                                                arrayType.GetTypeIndex(), true);
+  methodsArraySt->SetStorageClass(kScFstatic);
+  methodsArraySt->SetKonst(aggConst);
+  return methodsArraySt;
+}
+
+MIRSymbol *ReflectionAnalysis::GenMethodsMetaData(const Klass &klass, bool isHot) {
+  MIRStructType *classType = klass.GetMIRStructType();
+  if (classType == nullptr || classType->GetMethods().empty()) {
+    return nullptr;
+  }
+
+  std::vector<std::pair<MethodPair*, int>> methodinfoVec;
+  for (MethodPair &methodPair : classType->GetMethods()) {
+    methodinfoVec.push_back(std::make_pair(&methodPair, -1));
+  }
+
+  std::unordered_map<uint32, std::string> baseNameMp, fullNameMp;
+  GenAllMethodHash(methodinfoVec, baseNameMp, fullNameMp);
+  // Sort constVec by hashcode.
+  HashCodeComparator comparator(baseNameMp, fullNameMp);
+  std::sort(methodinfoVec.begin(), methodinfoVec.end(), comparator);
+  MIRSymbol *methodsArraySt = isHot ? GenMethodsMeta(klass, methodinfoVec, baseNameMp, fullNameMp) :
+                                      GenMethodsMetaCompact(klass, methodinfoVec, baseNameMp, fullNameMp);
+  return methodsArraySt;
+}
+
+void ReflectionAnalysis::GenFieldOffsetConst(MIRAggConst &newConst, const Klass &klass,
+                                             const MIRStructType &type, const std::pair<FieldPair, int> &fieldInfo,
+                                             uint32 metaFieldID) {
+  bool isStaticField = (fieldInfo.second == -1);
+  FieldPair fieldP = fieldInfo.first;
+  TyIdx fieldTyidx = fieldP.second.first;
+  std::string originFieldname = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldP.first);
+  if (isStaticField) {
+    // Offset of the static field, we fill the global var address.
+    const GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        GlobalTables::GetStrTable().GetStringFromStrIdx(fieldP.first));
+    MIRSymbol *gvarSt = GetSymbol(stridx, fieldTyidx);
+    if (gvarSt == nullptr) {
+      // If this static field is not used, the symbol will not be generated,
+      // so we just generate a weak one here.
+      gvarSt = CreateSymbol(stridx, fieldTyidx);
+      gvarSt->SetAttr(ATTR_weak);
+      gvarSt->SetAttr(ATTR_static);
+    }
+    mirBuilder.AddAddrofFieldConst(type, newConst, metaFieldID, *gvarSt);
+  } else {
+    // Offset of the instance field, we fill the index of fields here and let CG to fill in.
+    MIRStructType *mirClassType = klass.GetMIRStructType();
+    ASSERT(mirClassType != nullptr, "GetMIRClassType() returns null");
+    FieldID fldID = mirBuilder.GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(
+        *mirClassType, originFieldname, fieldP.second.first);
+    // set LSB 0, and set LSB 1 in muid_replacement
+    CHECK_FATAL(fldID <= INT32_MAX, "filedId out of range");
+    fldID = fldID * 2;
+    mirBuilder.AddIntFieldConst(type, newConst, metaFieldID, fldID);
+  }
+}
+
+MIRSymbol *ReflectionAnalysis::GenFieldOffsetData(const Klass &klass,
+                                                  const std::pair<FieldPair, int> &fieldInfo) {
+  MIRModule &module = *mirModule;
+  auto &fieldOffsetType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldOffsetDataTyIdx));
+  MIRArrayType &fieldOffsetArrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(fieldOffsetType, 1);
+  MIRAggConst *aggConst = module.GetMemPool()->New<MIRAggConst>(module, fieldOffsetArrayType);
+
+  MIRAggConst *newConst = module.GetMemPool()->New<MIRAggConst>(module, fieldOffsetType);
+  constexpr uint32_t fieldId = 1;
+  GenFieldOffsetConst(*newConst, klass, fieldOffsetType, fieldInfo, fieldId);
+  aggConst->AddItem(newConst, 0);
+
+  FieldPair fieldP = fieldInfo.first;
+  std::string originFieldname = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldP.first);
+  std::string fieldOffsetSymbolName = namemangler::kFieldOffsetDataPrefixStr;
+  bool isStaticField = (fieldInfo.second == -1);
+  if (isStaticField) {
+    fieldOffsetSymbolName += originFieldname;
+  } else {
+    MIRStructType *mirClassType = klass.GetMIRStructType();
+    FieldID fldID = mirBuilder.GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(
+        *mirClassType, originFieldname, fieldP.second.first);
+    fieldOffsetSymbolName += klass.GetKlassName() + "_FieldID_" + std::to_string(fldID);
+  }
+  MIRSymbol *fieldsOffsetSt = GetOrCreateSymbol(fieldOffsetSymbolName, fieldOffsetArrayType.GetTypeIndex(), true);
+  fieldsOffsetSt->SetStorageClass(kScFstatic);
+  fieldsOffsetSt->SetKonst(aggConst);
+  return fieldsOffsetSt;
+}
+
+MIRSymbol *ReflectionAnalysis::GenSuperClassMetaData(std::list<Klass*> superClassList) {
+  MIRModule &module = *mirModule;
+  size_t size = superClassList.size();
+  auto &superclassMetadataType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(superclassMetadataTyIdx));
+  MIRArrayType &arrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(superclassMetadataType, size);
+  MIRSymbol *superclassArraySt = nullptr;
+
+  auto itFindSuper = superClasesIdxMap.find(superClassList);
+  if (itFindSuper == superClasesIdxMap.end()) {
+    std::string superClassArrayInfo = SUPERCLASSINFO_PREFIX_STR + std::to_string(superClasesIdxMap.size());
+    superClasesIdxMap[superClassList] = superClassArrayInfo;
+
+    MIRAggConst *aggconst = module.GetMemPool()->New<MIRAggConst>(module, arrayType);
+    for (auto it = superClassList.begin(); it != superClassList.end(); ++it) {
+      MIRSymbol *dklassSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + (*it)->GetKlassName(), classMetadataTyIdx);
+      MIRAggConst *newConst = module.GetMemPool()->New<MIRAggConst>(module, superclassMetadataType);
+      mirBuilder.AddAddrofFieldConst(superclassMetadataType, *newConst, 1, *dklassSt);
+      aggconst->AddItem(newConst, 0);
+    }
+    superclassArraySt = GetOrCreateSymbol(superClassArrayInfo, arrayType.GetTypeIndex(), true);
+    // Direct access to superclassinfo is only possible within a .so.
+    superclassArraySt->SetStorageClass(kScFstatic);
+    superclassArraySt->SetKonst(aggconst);
+  } else {
+    std::string superClassArrayInfo = superClasesIdxMap[superClassList];
+    superclassArraySt = GetOrCreateSymbol(superClassArrayInfo, arrayType.GetTypeIndex());
+  }
+  return superclassArraySt;
+}
+
+static void ConvertFieldName(std::string &fieldname, bool staticfield) {
+  // Convert field name to java define name.
+  if (staticfield) {
+    // Remove class name prefix.
+    std::string decodeFieldName;
+    namemangler::DecodeMapleNameToJavaDescriptor(fieldname, decodeFieldName);
+    std::stringstream ss(decodeFieldName);
+    std::string item;
+    std::vector<std::string> res;
+    while (std::getline(ss, item, '|')) {
+      res.push_back(item);
+    }
+    CHECK_FATAL(res.size() > 1, "fieldname not found");
+    fieldname = res[StaticFieldName::kFieldName];
+  } else {
+    fieldname = namemangler::DecodeName(fieldname);
+  }
+}
+
+void ReflectionAnalysis::GenFieldMeta(const Klass &klass, MIRStructType &fieldsInfoType,
+                                      const std::pair<FieldPair, int> &fieldInfo,
+                                      MIRAggConst &aggConst, int idx,
+                                      const std::vector<std::pair<FieldPair, uint16>> &fieldHashVec) {
+  FieldPair fieldP = fieldInfo.first;
+  MIRAggConst *newConst = mirModule->GetMemPool()->New<MIRAggConst>(*mirModule, fieldsInfoType);
+  ASSERT(newConst != nullptr, "null ptr check!");
+  uint32 fieldID = 1;
+  uint16 hash = GetFieldHash(fieldHashVec, fieldP);
+  uint16 flag = (hash << kNoHashBits);  // Hash 10 bit.
+
+  // @offset or pOffset
+  if (isLazyBindingOrDecouple) {
+    flag |= kFieldOffsetIspOffset;
+    MIRSymbol *fieldsOffsetSt = GenFieldOffsetData(klass, fieldInfo);
+    mirBuilder.AddAddrofFieldConst(fieldsInfoType, *newConst, fieldID++, *fieldsOffsetSt);
+  } else {
+    GenFieldOffsetConst(*newConst, klass, fieldsInfoType, fieldInfo, fieldID++);
+  }
+
+  // @modifier
+  FieldAttrs fa = fieldP.second.second;
+  uint32 modifier = GetFieldModifier(fa);
+  mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID++, modifier);
+  // @flag
+  mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID++, flag);
+  // @index
+  mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID++, idx);
+  // @typeName
+  TyIdx fieldTyIdx = fieldP.second.first;
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldP.first);
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+  uint32 typeNameIdx = GetTypeNameIdxFromType(*ty, klass, fieldName);
+  mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID++, typeNameIdx);
+  // @fieldName
+  bool isStaticField = (fieldInfo.second == -1);
+  ConvertFieldName(fieldName, isStaticField);
+  uint32 fieldname32Idx = FindOrInsertReflectString(fieldName);
+  mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID++, fieldname32Idx);
+  // @annotation
+  MIRStructType *classType = klass.GetMIRStructType();
+  std::string annoArr;
+  std::map<int, int> idxNumMap;
+  GenAnnotation(idxNumMap, annoArr, *classType, kPragmaVar, fieldName, ty->GetTypeIndex());
+  uint32 annotationIdx = GetAnnoCstrIndex(idxNumMap, annoArr, true);
+  mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID++, annotationIdx);
+  // @declaring class
+  MIRSymbol *dklassSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + klass.GetKlassName(), classMetadataTyIdx);
+  mirBuilder.AddAddrofFieldConst(fieldsInfoType, *newConst, fieldID++, *dklassSt);
+  // @class type
+  std::string classInfo;
+  bool isClass = false;
+  GenFieldTypeClassInfo(*ty, klass, classInfo, fieldName, isClass);
+  if (isClass) {
+    MIRSymbol *typeSym = GetOrCreateSymbol(classInfo, classMetadataTyIdx);
+    mirBuilder.AddAddrofFieldConst(fieldsInfoType, *newConst, fieldID, *typeSym);
+  } else {
+    mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID, 0);
+  }
+  aggConst.AddItem(newConst, 0);
+}
+
+MIRSymbol *ReflectionAnalysis::GenFieldsMeta(
+    const Klass &klass, std::vector<std::pair<FieldPair, int>> &fieldsVector,
+    const std::vector<std::pair<FieldPair, uint16>> &fieldHashVec) {
+  size_t size = fieldsVector.size();
+  auto &fieldsInfoType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldsInfoTyIdx));
+  MIRArrayType *arraytype = GlobalTables::GetTypeTable().GetOrCreateArrayType(fieldsInfoType, size);
+  MIRAggConst *aggConst = mirModule->GetMemPool()->New<MIRAggConst>(*mirModule, *arraytype);
+  ASSERT(aggConst != nullptr, "null ptr check!");
+  int idx = 0;
+  for (auto &fieldInfo : fieldsVector) {
+    FieldPair fieldP = fieldInfo.first;
+    std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldP.first);
+    TyIdx fieldTyIdx = fieldP.second.first;
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    ASSERT(ty != nullptr, "null ptr check!");
+    // Collect the the information about the fieldName and fieldtyidx.
+    reflectionMuidStr += fieldName;
+    reflectionMuidStr += ty->GetName();
+    GenFieldMeta(klass, fieldsInfoType, fieldInfo, *aggConst, idx++, fieldHashVec);
+  }
+  MIRSymbol *fieldsArraySt =
+      GetOrCreateSymbol(namemangler::kFieldsInfoPrefixStr + klass.GetKlassName(), arraytype->GetTypeIndex(), true);
+  fieldsArraySt->SetStorageClass(kScFstatic);
+  fieldsArraySt->SetKonst(aggConst);
+  return fieldsArraySt;
+}
+
+void ReflectionAnalysis::GenFieldMetaCompact(const Klass &klass, MIRStructType &fieldsInfoCompactType,
+                                             const std::pair<FieldPair, int> &fieldInfo,
+                                             MIRAggConst &aggConstCompact) {
+  MIRModule &module = *mirModule;
+  std::vector<uint8> fieldCompactLeb128Vec;
+  FieldPair fieldP = fieldInfo.first;
+  MIRAggConst *newConstCompact = module.GetMemPool()->New<MIRAggConst>(module, fieldsInfoCompactType);
+  ASSERT(newConstCompact != nullptr, "null ptr check!");
+  uint32 fieldIDCompact = 1;
+
+  // @pOffset
+  MIRSymbol *fieldsOffsetSt = GenFieldOffsetData(klass, fieldInfo);
+  mirBuilder.AddAddrofFieldConst(fieldsInfoCompactType, *newConstCompact, fieldIDCompact++, *fieldsOffsetSt);
+  // @modifier
+  FieldAttrs fa = fieldP.second.second;
+  uint32 modifier = GetFieldModifier(fa);
+  namemangler::GetUnsignedLeb128Encode(fieldCompactLeb128Vec, modifier);
+  // @type
+  TyIdx fieldTyIdx = fieldP.second.first;
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldP.first);
+  MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+  uint32 typeNameIdx = GetTypeNameIdxFromType(*ty, klass, fieldName);
+  namemangler::GetUnsignedLeb128Encode(fieldCompactLeb128Vec, typeNameIdx);
+  // @fieldName
+  bool isStaticField = (fieldInfo.second == -1);
+  ConvertFieldName(fieldName, isStaticField);
+  uint32 fieldname32Idx = FindOrInsertReflectString(fieldName);
+  namemangler::GetUnsignedLeb128Encode(fieldCompactLeb128Vec, fieldname32Idx);
+  // @annotation
+  MIRStructType *classType = klass.GetMIRStructType();
+  std::string annoArr;
+  std::map<int, int> idxNumMap;
+  GenAnnotation(idxNumMap, annoArr, *classType, kPragmaVar, fieldName, ty->GetTypeIndex());
+  uint32 annotationIdx = GetAnnoCstrIndex(idxNumMap, annoArr, true);
+  namemangler::GetUnsignedLeb128Encode(fieldCompactLeb128Vec, annotationIdx);
+
+  constexpr uint32 lebpaddingIdx = 2u;
+  uint32 fieldID = lebpaddingIdx;  // lebpadding index
+  for (auto byte : fieldCompactLeb128Vec) {
+    uint8 byteValue = byte;
+    mirBuilder.AddIntFieldConst(fieldsInfoCompactType, *newConstCompact, fieldID, byteValue);
+  }
+  aggConstCompact.AddItem(newConstCompact, 0);
+  (void)fieldIDCompact;
+}
+
+MIRSymbol *ReflectionAnalysis::GenFieldsMetaCompact(const Klass &klass,
+                                                    std::vector<std::pair<FieldPair, int>> &fieldsVector) {
+  size_t size = fieldsVector.size();
+  auto &fieldsInfoCompactType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldsInfoCompactTyIdx));
+  MIRArrayType *arrayTypeCompact = GlobalTables::GetTypeTable().GetOrCreateArrayType(fieldsInfoCompactType, size);
+  MIRAggConst *aggConstCompact = mirModule->GetMemPool()->New<MIRAggConst>(*mirModule, *arrayTypeCompact);
+  ASSERT(aggConstCompact != nullptr, "null ptr check!");
+  for (auto &fieldInfo : fieldsVector) {
+    FieldPair fieldP = fieldInfo.first;
+    std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldInfo.first.first);
+    TyIdx fieldTyIdx = fieldP.second.first;
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
+    ASSERT(ty != nullptr, "null ptr check!");
+    // Collect the the information about the fieldName and fieldtyidx.
+    reflectionMuidStr += fieldName;
+    reflectionMuidStr += ty->GetName();
+    GenFieldMetaCompact(klass, fieldsInfoCompactType, fieldInfo, *aggConstCompact);
+  }
+  MIRSymbol *fieldsArrayStCompact = GetOrCreateSymbol(
+      namemangler::kFieldsInfoCompactPrefixStr + klass.GetKlassName(), arrayTypeCompact->GetTypeIndex(), true);
+  fieldsArrayStCompact->SetStorageClass(kScFstatic);
+  fieldsArrayStCompact->SetKonst(aggConstCompact);
+  return fieldsArrayStCompact;
+}
+
+MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass &klass, bool isHot) {
+  MIRStructType *classType = klass.GetMIRStructType();
+  ASSERT(classType != nullptr, "null ptr check!");
+  FieldVector fields = classType->GetFields();
+  FieldVector staticFields = classType->GetStaticFields();
+  ASSERT(fields.size() < fields.max_size() - staticFields.size(), "size too large");
+  size_t size = fields.size() + staticFields.size();
+  if (size == 0) {
+    return nullptr;
+  }
+
+  std::vector<std::pair<FieldPair, uint16>> fieldHashvec(size);
+  size_t i = 0;
+  for (; i < fields.size(); ++i) {
+    std::string fieldname = GlobalTables::GetStrTable().GetStringFromStrIdx(fields[i].first);
+    ConvertFieldName(fieldname, false);
+    uint32 hashcode = GetCharHashIndex(fieldname);
+    fieldHashvec[i] = std::make_pair(fields[i], hashcode);
+  }
+  for (size_t j = 0; j < staticFields.size(); ++j) {
+    std::string fieldname = GlobalTables::GetStrTable().GetStringFromStrIdx(staticFields[j].first);
+    ConvertFieldName(fieldname, true);
+    uint32 hashcode = GetCharHashIndex(fieldname);
+    fieldHashvec[i++] = std::make_pair(staticFields[j], hashcode);
+  }
+  GenAllFieldHash(fieldHashvec);
+  // Sort field_hashvec by hashcode.
+  std::sort(fieldHashvec.begin(), fieldHashvec.end(),
+            [](std::pair<FieldPair, uint16> a, std::pair<FieldPair, uint16> b) {
+              maple::uint16 fieldHashA = a.second;
+              maple::uint16 fieldHashB = b.second;
+              return fieldHashA < fieldHashB;
+            });
+  std::vector<std::pair<FieldPair, int>> fieldinfoVec(size);
+  size_t j = 0;
+  size_t k = 0;
+  for (auto it = fieldHashvec.begin(); it != fieldHashvec.end(); ++it) {
+    FieldPair f = (*it).first;
+    if (f.second.second.GetAttr(FLDATTR_static)) {
+      fieldinfoVec[j] = std::make_pair(f, -1);
+    } else {
+      fieldinfoVec[j] = std::make_pair(f, k++);
+    }
+    ++j;
+  }
+  ASSERT(i == size, "In class %s: %d fields seen, BUT %d fields declared", klass.GetKlassName().c_str(), i, size);
+  MIRSymbol *fieldsArraySt = isHot ? GenFieldsMeta(klass, fieldinfoVec, fieldHashvec) :
+                                     GenFieldsMetaCompact(klass, fieldinfoVec);
+  return fieldsArraySt;
+}
+
+void ReflectionAnalysis::ConvertMapleClassName(const std::string &mplClassName, std::string &javaDsp) {
+  // Convert classname end with _3B, 3 is strlen("_3B")
+  unsigned int len = strlen(kClassSuffix);
+  if (mplClassName.size() > len && mplClassName.rfind(kClassSuffix, mplClassName.size() - len) != std::string::npos) {
+    namemangler::DecodeMapleNameToJavaDescriptor(mplClassName, javaDsp);
+  } else {
+    javaDsp = mplClassName;
+  }
+}
+
+void ReflectionAnalysis::AppendValueByType(std::string &annoArr, const MIRPragmaElement &elem) {
+  std::ostringstream oss;
+  std::string tmp;
+  switch (elem.GetType()) {
+    case kValueInt:
+    case kValueByte:
+    case kValueShort:
+      annoArr += std::to_string(elem.GetI32Val());
+      break;
+    case kValueLong:
+      annoArr += std::to_string(elem.GetI64Val());
+      break;
+    case kValueDouble:
+      oss << tmp << std::setiosflags(std::ios::scientific) << std::setprecision(16) << elem.GetDoubleVal();
+      annoArr += oss.str();
+      break;
+    case kValueFloat:
+      oss << tmp << std::setiosflags(std::ios::scientific) << std::setprecision(7) << elem.GetFloatVal();
+      annoArr += oss.str();
+      break;
+    case kValueBoolean:
+    case kValueChar:
+      annoArr += std::to_string(elem.GetU64Val());
+      break;
+    default: { // kValueString kValueEnum kValueType
+      GStrIdx strIdx;
+      strIdx.reset(elem.GetU64Val());
+      std::string s = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx);
+      uint32 idx = ReflectionAnalysis::FindOrInsertReflectString(s);
+      annoArr += annoDelimiterPrefix;
+      annoArr += std::to_string(idx);
+    }
+  }
+}
+
+#define COMMON_CASE \
+case kValueInt:     \
+case kValueLong:    \
+case kValueDouble:  \
+case kValueFloat:   \
+case kValueString:  \
+case kValueBoolean: \
+case kValueByte:    \
+case kValueShort:   \
+case kValueChar:    \
+case kValueEnum:    \
+case kValueType:
+
+std::string ReflectionAnalysis::GetAnnotationValue(const MapleVector<MIRPragmaElement*> &subelemVector,
+                                                   GStrIdx typeStrIdx) {
+  std::string annoArray;
+  annoArray += (annoArrayStartDelimiter + std::to_string(subelemVector.size()) + annoDelimiter);
+  std::string javaDscp;
+  ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(typeStrIdx), javaDscp);
+  uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(javaDscp);
+  javaDscp = annoDelimiterPrefix + std::to_string(idx);
+  annoArray += javaDscp;
+  for (MIRPragmaElement *arrayElem : subelemVector) {
+    annoArray += annoDelimiter;
+    idx = FindOrInsertReflectString(GlobalTables::GetStrTable().GetStringFromStrIdx(arrayElem->GetNameStrIdx()));
+    annoArray += (annoDelimiterPrefix + std::to_string(idx) + annoDelimiter + std::to_string(arrayElem->GetType()));
+    annoArray += annoDelimiter;
+    annoArray += GetAnnoValueNoArray(*arrayElem);
+  }
+  annoArray += annoDelimiter;
+  annoArray += annoArrayEndDelimiter;
+  return annoArray;
+}
+
+std::string ReflectionAnalysis::GetArrayValue(const MapleVector<MIRPragmaElement*> &subelemVector) {
+  std::string annoArray;
+  GStrIdx strIdx;
+  uint32_t idx;
+  annoArray += (annoArrayStartDelimiter + std::to_string(subelemVector.size()) + annoDelimiter);
+  if (!subelemVector.empty()) {
+    annoArray += std::to_string(subelemVector[0]->GetType());
+    annoArray += annoDelimiter;
+
+    std::string javaDsp;
+    ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(subelemVector[0]->GetTypeStrIdx()), javaDsp);
+    std::string typeStr = javaDsp;
+    idx = ReflectionAnalysis::FindOrInsertReflectString(typeStr);
+    annoArray += (annoDelimiterPrefix + std::to_string(idx) + annoDelimiter);
+  }
+
+  for (MIRPragmaElement *arrayElem : subelemVector) {
+    MapleVector<MIRPragmaElement*> arrayElemVector = arrayElem->GetSubElemVec();
+    switch (arrayElem->GetType()) {
+      COMMON_CASE
+        AppendValueByType(annoArray, *arrayElem);
+        break;
+      case kValueAnnotation: {
+        annoArray += std::to_string(arrayElemVector.size());
+        annoArray += annoDelimiter;
+        for (MIRPragmaElement *annoElem : arrayElemVector) {
+          std::string tt = GlobalTables::GetStrTable().GetStringFromStrIdx(annoElem->GetNameStrIdx());
+          idx = ReflectionAnalysis::FindOrInsertReflectString(tt);
+          tt = annoDelimiterPrefix + std::to_string(idx) + annoDelimiter + std::to_string(annoElem->GetType()) +
+              annoDelimiter + GetAnnoValueNoArray(*annoElem) + annoDelimiter;
+          annoArray += tt;
+        }
+        break;
+      }
+      default: {
+        annoArray += (std::to_string(arrayElem->GetU64Val()) + annoDelimiter);
+        annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(arrayElem->GetNameStrIdx());
+        strIdx.reset(arrayElem->GetU64Val());
+        annoArray += (GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx) + annoDelimiter);
+      }
+    }
+    annoArray += annoDelimiter;
+  }
+  annoArray += annoArrayEndDelimiter;
+  return annoArray;
+}
+
+std::string ReflectionAnalysis::GetAnnoValueNoArray(const MIRPragmaElement &annoElem) {
+  std::string annoArray;
+  switch (annoElem.GetType()) {
+    COMMON_CASE
+      AppendValueByType(annoArray, annoElem);
+      break;
+    case kValueArray:
+      annoArray += GetArrayValue(annoElem.GetSubElemVec());
+      break;
+    case kValueAnnotation:
+      annoArray += GetAnnotationValue(annoElem.GetSubElemVec(), annoElem.GetTypeStrIdx());
+      break;
+    default: {
+      GStrIdx strIdx;
+      strIdx.reset(annoElem.GetU64Val());
+      std::string javaDescriptor;
+      ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx), javaDescriptor);
+      uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(javaDescriptor);
+      annoArray += annoDelimiterPrefix;
+      annoArray += std::to_string(idx);
+    }
+  }
+  return annoArray;
+}
+
+void ReflectionAnalysis::GenAnnotation(std::map<int, int> &idxNumMap, std::string &annoArr, MIRStructType &classType,
+                                       PragmaKind paragKind, const std::string &paragName, TyIdx fieldTypeIdx,
+                                       std::map<int, int> *paramnumArray, int *paramIndex) {
+  int annoNum = 0;
+  for (MIRPragma *prag : classType.GetPragmaVec()) {
+    std::string cmpString = (paragKind == kPragmaVar) ? namemangler::DecodeName(
+        GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx())) :
+        GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx());
+    bool validTypeFlag = false;
+    if (prag->GetTyIdxEx() == fieldTypeIdx || fieldTypeIdx == invalidIdx) {
+      validTypeFlag = true;
+    }
+    if ((prag->GetKind() == paragKind) && (cmpString == paragName) && validTypeFlag) {
+      const MapleVector<MIRPragmaElement*> &elemVector = prag->GetElementVector();
+      MIRSymbol *classInfo = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
+          GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetNameStrIdx());
+      if (classInfo != nullptr && !RtRetentionPolicyCheck(*classInfo)) {
+        continue;
+      }
+      annoNum++;
+      idxNumMap[annoNum - 1] = 0;
+      GStrIdx gindex = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetNameStrIdx();
+      std::string pregTypeString = GlobalTables::GetStrTable().GetStringFromStrIdx(gindex);
+      std::string klassJavaDescriptor;
+      ConvertMapleClassName(pregTypeString, klassJavaDescriptor);
+      uint32 idx = ReflectionAnalysis::FindOrInsertReflectString(klassJavaDescriptor);
+      annoArr += annoDelimiterPrefix;
+      annoArr += std::to_string(idx);
+      annoArr += annoDelimiter;
+      if (paramnumArray != nullptr) {
+        int8 x = JudgePara(classType);
+        CHECK_FATAL(paramIndex != nullptr, "null ptr check");
+        if (x && paragName.find(kInitFuntionStr) != std::string::npos) {
+          (*paramnumArray)[(*paramIndex)++] = prag->GetParamNum() + x;
+        } else {
+          (*paramnumArray)[(*paramIndex)++] = prag->GetParamNum();
+        }
+      }
+      for (MIRPragmaElement *elem : elemVector) {
+        idxNumMap[annoNum - 1]++;
+        std::string convertTmp =
+            namemangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(elem->GetNameStrIdx()));
+        idx = ReflectionAnalysis::FindOrInsertReflectString(convertTmp);
+        annoArr += (annoDelimiterPrefix + std::to_string(idx) + annoDelimiter +
+            std::to_string(elem->GetType()) + annoDelimiter);
+        annoArr += GetAnnoValueNoArray(*elem);
+        annoArr += annoDelimiter;
+      }
+    }
+  }
+}
+
+uint32 ReflectionAnalysis::GetAnnoCstrIndex(std::map<int, int> &idxNumMap, const std::string &annoArr, bool isField) {
+  size_t annoNum = idxNumMap.size();
+  uint32 signatureIdx = 0;
+  if (annoNum == 0) {
+    std::string flag = isField ? "1!" : std::to_string(GetAnnoFlag(annoArr)) + annoDelimiter;
+    std::string subStr = flag + "0";
+    signatureIdx = FindOrInsertReflectString(subStr);
+  } else {
+    std::string subStr = std::to_string(annoNum);
+    subStr += annoDelimiter;
+    std::for_each(idxNumMap.begin(), idxNumMap.end(), [&subStr](const std::pair<const int, int> p) {
+      subStr += std::to_string(p.second);
+      subStr += annoDelimiter;
+    });
+    subStr += annoArr;
+    signatureIdx = static_cast<uint32>(GetDeflateStringIdx(subStr, !isField));
+  }
+  return signatureIdx;
+}
+
+uint32 ReflectionAnalysis::BKDRHash(const std::string &strName, uint32 seed) {
+  uint32 hash = 0;
+  for (auto name : strName) {
+    auto uName = static_cast<uint8_t>(name);
+    hash = hash * seed + uName;
+  }
+  return hash;
+}
+
+uint32 ReflectionAnalysis::GetHashIndex(const std::string &strName) {
+  constexpr int hashSeed = 211;
+  return BKDRHash(strName, hashSeed);
+}
+
+void ReflectionAnalysis::GenHotClassNameString(const Klass &klass) {
+  if (klass.IsInterface()) {
+    return;
+  }
+  MIRStructType *classType = klass.GetMIRStructType();
+  if (!classType->IsLocal()) {
+    // External class.
+    return;
+  }
+  if (!klass.HasNativeMethod()) {
+    return;  // It's a cold class, we don't care.
+  }
+  std::string klassName = klass.GetKlassName();
+  std::string klassJavaDescriptor;
+  namemangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
+  (void)ReflectionAnalysis::FindOrInsertRepeatString(klassJavaDescriptor, true);  // Always used.
+}
+
+uint32 ReflectionAnalysis::FindOrInsertReflectString(const std::string &str) {
+  uint8 hotType = 0;
+  bool isHot = mirModule->GetProfile().CheckReflectionStrHot(str, hotType);
+  if (isHot) {
+    hotCStr++;
+  }
+  totalCStr++;
+  return ReflectionAnalysis::FindOrInsertRepeatString(str, isHot, hotType);
+}
+
+MIRSymbol *ReflectionAnalysis::GetClinitFuncSymbol(const Klass &klass) {
+  MIRStructType *classType = klass.GetMIRStructType();
+  if (classType == nullptr || classType->GetMethods().empty()) {
+    return nullptr;
+  }
+  MIRSymbol *clinitFuncSymbol = nullptr;
+  for (MethodPair &methodPair : classType->GetMethods()) {
+    MIRSymbol *funcSymA = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodPair.first.Idx());
+    MIRFunction *funcA = funcSymA->GetFunction();
+    std::string funcName = funcA->GetBaseFuncNameWithType();
+    if (funcName == kClinitSuffixStr) {
+      clinitFuncSymbol = funcSymA;
+      break;
+    }
+  }
+  return clinitFuncSymbol;
+}
+
+void ReflectionAnalysis::GenClassMetaData(Klass &klass) {
+  MIRModule &module = *mirModule;
+  MIRStructType *structType = klass.GetMIRStructType();
+  ASSERT(structType != nullptr, "null ptr check!");
+  if (!structType->IsLocal()) {
+    // External class.
+    return;
+  }
+
+  bool compactMeta = Options::compactMeta;
+  std::string klassName = klass.GetKlassName();
+  reflectionMuidStr += klassName;
+  std::string klassJavaDescriptor;
+  namemangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
+  uint32 hashIndex = GetHashIndex(klassJavaDescriptor);
+  if (kRADebug) {
+    LogInfo::MapleLogger(kLlErr) << "========= Gen Class: " << klassJavaDescriptor
+                                 << " (" << hashIndex << ") ========\n";
+  }
+  auto &classMetadataROType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(classMetadataRoTyIdx));
+  MIRAggConst *newConst = module.GetMemPool()->New<MIRAggConst>(module, classMetadataROType);
+  uint32 fieldID = 1;
+  // @classname
+  uint32 nameIdx = FindOrInsertReflectString(klassJavaDescriptor);
+  mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, nameIdx);
+  // @iFields: All instance fields.
+  uint32 numOfFields = 0;
+  bool hasAdded = false;
+  if (klass.GetKlassName() == namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr)) {
+    const GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
+        namemangler::kFieldsInfoPrefixStr + namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr));
+    MIRSymbol *fieldsSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(stridx);
+    if (fieldsSt != nullptr) {
+      mirBuilder.AddAddrofFieldConst(classMetadataROType, *newConst, fieldID++, *fieldsSt);
+      hasAdded = true;
+    }
+  }
+  if (!hasAdded) {
+    bool profilFieldeHot = module.GetProfile().CheckFieldHot(klassJavaDescriptor);
+    bool isHotFields = compactMeta ? profilFieldeHot : true;
+    if (profilFieldeHot) {
+      hotFieldMeta++;
+    }
+    totalFieldMeta++;
+    MIRSymbol *fieldsSt = GenFieldsMetaData(klass, isHotFields);
+    if (fieldsSt != nullptr) {
+      numOfFields = safe_cast<MIRAggConst>(fieldsSt->GetKonst())->GetConstVec().size();
+      // All meta data will be weak if dummy constructors.
+      mirBuilder.AddAddrofFieldConst(classMetadataROType, *newConst, fieldID++, *fieldsSt);
+    } else {
+      mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, 0);
+    }
+  }
+  // @methods: All methods.
+  uint32 numOfMethods = 0;
+  MIRSymbol *methodsSt;
+  bool isProfHotMethod = module.GetProfile().CheckMethodHot(klassJavaDescriptor);
+  bool isHotMethods = compactMeta ? isProfHotMethod : true;
+  if (isProfHotMethod) {
+    hotMethodMeta++;
+  }
+  totalMethodMeta++;
+  methodsSt = GenMethodsMetaData(klass, isHotMethods);
+  if (methodsSt != nullptr) {
+    numOfMethods = safe_cast<MIRAggConst>(methodsSt->GetKonst())->GetConstVec().size();
+    mirBuilder.AddAddrofFieldConst(classMetadataROType, *newConst, fieldID++, *methodsSt);
+  } else {
+    mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, 0);
+  }
+  // @superclass: Super class and a list of implemented interfaces.
+  std::list<Klass*> superClassList;
+  for (Klass *superClass : klass.GetSuperKlasses()) {
+    superClassList.push_back(superClass);
+  }
+  if (structType->IsMIRClassType()) {
+    MIRClassType *classType = static_cast<MIRClassType*>(structType);
+    for (TyIdx const &kTyIdx : classType->GetInterfaceImplemented()) {
+      Klass *interface = klassH->GetKlassFromTyIdx(kTyIdx);
+      if (interface == nullptr) {
+        MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(kTyIdx);
+        LogInfo::MapleLogger() << "Error: Interface " << static_cast<MIRStructType*>(type)->GetName() << " is not found"
+                               << "\n";
+        LogInfo::MapleLogger(kLlErr) << "Error: Missing interface for " << klass.GetKlassName() << "\n";
+        CHECK_FATAL(false, "Missing interface");
+      }
+      auto it = std::find(superClassList.cbegin(), superClassList.cend(), interface);
+      if (it == superClassList.end()) {
+        superClassList.push_back(interface);
+      }
+    }
+  }
+
+  size_t superClassSize = superClassList.size();
+  if (superClassSize >= 1) {
+    MIRSymbol *superClassSymbolType = GenSuperClassMetaData(superClassList);
+    mirBuilder.AddAddrofFieldConst(classMetadataROType, *newConst, fieldID++, *superClassSymbolType);
+  } else {
+    mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, 0);
+  }
+  // @numoffields: Num of fields (own).
+  CHECK_FATAL(numOfFields <= 0xffff, "Error:the num of fields is too large");
+  mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, numOfFields);
+  // @numofmethods: Num of methods in vtable.
+  CHECK_FATAL(numOfMethods <= 0xffff, "Error:the num of methods is too large");
+  mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, numOfMethods);
+  // Do annotation.
+  std::string annoArray;
+  std::map<int, int> idxNumMap;
+  GenAnnotation(idxNumMap, annoArray, *structType, kPragmaClass, klass.GetKlassName(), invalidIdx);
+  bool isAnonymous = IsAnonymousClass(annoArray);
+  bool isLocalClass = IsLocalClass(annoArray);
+  CheckPrivateInnerAndNoSubClass(klass, annoArray);
+
+  bool isColdClass = !(module.GetProfile().CheckClassHot(klassJavaDescriptor));
+  if ((Options::lazyBinding || Options::hotFix) && !isLibcore) {
+    isColdClass = true;
+  }
+  if (!isColdClass) {
+    hotClassMeta++;
+  }
+  totalClassMeta++;
+#ifndef USE_32BIT_REF
+  // @flag
+  // Array class and primitive class is not generated by compiler.
+  uint32 flag = klass.GetFlag(kClassHasFinalizer | kClassReference | kClassFinalizerreferenceSentinel);
+  flag = isAnonymous ? (flag | kClassIsanonymousclass) : flag;
+  flag = isColdClass ? (flag | kClassIscoldclass) : flag;
+  flag = klass.HasFlag(kClassRuntimeVerify) ? (flag | kClassRuntimeVerify) : flag;
+  flag = (Options::lazyBinding && !isLibcore) ? (flag | kClassLazyBindingClass) : flag;
+  flag = Options::buildApp ? flag | kClassNeedDecouple : flag;
+  mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, flag);
+  // @numofsuperclasses
+  CHECK_FATAL(superClassSize <= 0xffff, "Error:the size of superClass is too big");
+  mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, superClassSize);
+  // @padding
+  mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, 0);
+#endif  // USE_32BIT_REF
+  // @modifier: For class fill ClassAccessFlags.
+  uint32 modifier = GetClassAccessFlags(*structType);
+  modifier |= (isLocalClass << (kModifierLocalClass - 1));
+  modifier |= (1 << (kModifierLocalClassVaild - 1));
+
+  mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, modifier);
+  // @annotation: Set annotation field.
+  uint32_t signatureIdx = GetAnnoCstrIndex(idxNumMap, annoArray, false);
+  mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, signatureIdx);
+  // @ClinitFuncAddr
+  MIRSymbol *clinitFuncSym = GetClinitFuncSymbol(klass);
+  if (clinitFuncSym != nullptr) {
+    mirBuilder.AddAddroffuncFieldConst(classMetadataROType, *newConst, fieldID++, *clinitFuncSym);
+  } else {
+    mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, 0);
+  }
+  MIRSymbol *classMetadataROSymbolType =
+      GetOrCreateSymbol(CLASSINFO_RO_PREFIX_STR + klass.GetKlassName(), classMetadataRoTyIdx, true);
+  classMetadataROSymbolType->SetStorageClass(kScFstatic);
+  classMetadataROSymbolType->SetKonst(newConst);
+  // Class Metadata definition start here.
+  auto &classMetadataType =
+      static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(classMetadataTyIdx));
+  newConst = module.GetMemPool()->New<MIRAggConst>(module, classMetadataType);
+  fieldID = 1;
+  // @shadow: multiplex used for def index.
+  mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, 0);
+  // @monitor: multiplex used for class hash.
+  mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, hashIndex);
+  // @class loader: Use maximum value unsigned(-1) as non-initialized flag.
+  mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, static_cast<uint16>(-1));
+  // @objsize: Fill this in the CG.
+  mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, 0);
+#ifdef USE_32BIT_REF
+  // @flag
+  // Array class and primitive class is not generated by compiler.
+  uint32 flag = klass.GetFlag(kClassHasFinalizer | kClassReference | kClassFinalizerreferenceSentinel);
+  flag = isAnonymous ? (flag | kClassIsanonymousclass) : flag;
+  flag = isColdClass ? (flag | kClassIscoldclass) : flag;
+  flag = klass.HasFlag(kClassRuntimeVerify) ? (flag | kClassRuntimeVerify) : flag;
+  flag = (Options::lazyBinding && !isLibcore) ? (flag | kClassLazyBindingClass) : flag;
+  flag = Options::buildApp ? flag | kClassNeedDecouple : flag;
+  mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, flag);
+  // @numofsuperclasses
+  CHECK_FATAL(superClassSize <= 0xffff, "Error:the size of superClass is too big");
+  mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, superClassSize);
+#endif  // USE_32BIT_REF
+  // @itab
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(ITAB_PREFIX_STR + klass.GetKlassName());
+  if (strIdx != 0u && !Options::buildApp) {
+    MIRSymbol *itableSymbolType = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+    mirBuilder.AddAddrofFieldConst(classMetadataType, *newConst, fieldID++, *itableSymbolType);
+  } else {
+    mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, 0);
+  }
+  // @vtab
+  strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(VTAB_PREFIX_STR + klass.GetKlassName());
+  if (strIdx != 0u && !Options::buildApp) {
+    MIRSymbol *vtableSymbolType = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+    mirBuilder.AddAddrofFieldConst(classMetadataType, *newConst, fieldID++, *vtableSymbolType);
+  } else {
+    mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, 0);
+  }
+  // @gctib
+  MIRSymbol *gctibSt = GetOrCreateSymbol(GCTIB_PREFIX_STR + klass.GetKlassName(),
+                                         GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex(), false);
+  if (klass.GetKlassName() != namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr)) {
+    // Direct access to gctib is only possible within a .so, for most classes.
+    gctibSt->SetStorageClass(kScFstatic);
+  }
+  mirBuilder.AddAddrofFieldConst(classMetadataType, *newConst, fieldID++, *gctibSt);
+  // @classinfo ro.
+  mirBuilder.AddAddrofFieldConst(classMetadataType, *newConst, fieldID++, *classMetadataROSymbolType);
+#ifdef USE_32BIT_REF
+  mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, 0);
+#endif
+
+  // Set default value to class initialization state.
+  if (klassH->NeedClinitCheckRecursively(klass)) {
+    mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, kSEGVAddrForClassUninitialized);
+  } else {
+    // If this class and its parents do not have <clinit> method, we do not do clinit-check for this class,
+    // thus the class initialization state is modified to "Initialized".
+    mirBuilder.AddIntFieldConst(classMetadataType, *newConst, fieldID++, kClassInitializedState);
+  }
+
+  // Finally generate class metadata here.
+  MIRSymbol *classSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + klass.GetKlassName(), classMetadataTyIdx, true);
+  classSt->SetKonst(newConst);
+  classTab.push_back(classSt);
+}
+
+int8 ReflectionAnalysis::JudgePara(MIRStructType &classType) {
+  for (MIRPragma *prag : classType.GetPragmaVec()) {
+    if (prag->GetKind() == kPragmaClass) {
+      if ((GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetName() ==
+           kArkAnnotationEnclosingClassStr) &&
+          !IsStaticClass(classType) && (classType.GetName() != kJavaLangEnumStr)) {
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+bool ReflectionAnalysis::IsAnonymousClass(const std::string &annotationString) {
+  // eg: `IC!`AF!4!0!name!30!!
+  uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(kInnerClassStr);
+  std::string target = annoDelimiterPrefix + std::to_string(idx) + annoDelimiter;
+  size_t pos = annotationString.find(target, 0);
+  if (pos != std::string::npos) {
+    int i = kAnonymousClassIndex;
+    while (i--) {
+      pos = annotationString.find("!", pos + 1);
+      CHECK_FATAL(pos != std::string::npos, "Error:annotationString in func: isAnonymousClass()");
+    }
+    int annotationLength = strlen(kAnonymousClassSuffix);
+    if (annotationString.substr(pos + 1, annotationLength) == kAnonymousClassSuffix) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ReflectionAnalysis::IsLocalClass(const std::string annotationString) {
+  uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(kEnclosingMethod);
+  std::string target = annoDelimiterPrefix + std::to_string(idx) + annoDelimiter;
+  size_t pos = annotationString.find(target, 0);
+  if (pos != std::string::npos) {
+    return true;
+  }
+  return false;
+}
+
+TyIdx ReflectionAnalysis::GenMetaStructType(MIRModule &module, MIRStructType &metaType, const std::string &str) {
+  const GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
+  TyIdx tyIdx = module.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
+  // A corresponding dummy type has been created in previous phases, update it with metaType.
+  if (tyIdx != kInitTyIdx) {
+    GlobalTables::GetTypeTable().UpdateMIRType(metaType, tyIdx);
+  } else {
+    tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&metaType);
+  }
+  module.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx);
+  module.PushbackTypeDefOrder(strIdx);
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->GetNameStrIdx() == 0u) {
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->SetNameStrIdx(strIdx);
+  }
+  return tyIdx;
+}
+
+MIRType *ReflectionAnalysis::GetRefFieldType() {
+#ifdef USE_32BIT_REF
+  return GlobalTables::GetTypeTable().GetUInt32();
+#else
+  return GlobalTables::GetTypeTable().GetVoidPtr();
+#endif  // USE_32BIT_REF
+}
+
+void ReflectionAnalysis::GenMetadataType(MIRModule &module) {
+  if (classMetadataTyIdx != 0u) { // Types have been generated.
+    return;
+  }
+  // ClassMetaType
+  MIRType *typeU8 = GlobalTables::GetTypeTable().GetUInt8();
+  MIRType *typeU16 = GlobalTables::GetTypeTable().GetUInt16();
+  MIRType *typeI32 = GlobalTables::GetTypeTable().GetInt32();
+  MIRType *typeU32 = GlobalTables::GetTypeTable().GetUInt32();
+#ifndef USE_32BIT_REF
+  MIRType *typeI64 = GlobalTables::GetTypeTable().GetInt64();
+  MIRType *typeU64 = GlobalTables::GetTypeTable().GetUInt64();
+#endif
+  MIRType *typeVoidPtr = GlobalTables::GetTypeTable().GetVoidPtr();
+  MIRStructType classMetadataType(kTypeStruct);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kShadowStr, *GetRefFieldType());
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kMonitorStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kClassloaderStr, *typeU16);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kObjsizeStr, *typeU16);
+#ifdef USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kFlagStr, *typeU16);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kNumOfSuperclassesStr, *typeU16);
+#endif  // USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kItabStr, *typeVoidPtr);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kVtabStr, *typeVoidPtr);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kGctibStr, *typeVoidPtr);
+#ifdef USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kClassinforoStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kInstanceOfCacheFalseStr, *typeU32);
+#else
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kClassinforoStr, *typeVoidPtr);
+#endif  // USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kClinitbridgeStr, *typeVoidPtr);
+  classMetadataTyIdx = GenMetaStructType(module, classMetadataType, namemangler::kClassMetadataTypeName);
+  MIRStructType classMetadataROType(kTypeStruct);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kClassNameStr, *typeVoidPtr);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kIfieldsStr, *typeVoidPtr);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kMethodsStr, *typeVoidPtr);
+  // For array, this is component class; For primitive type, this is nullptr;
+  // For general class, this is superclass (only one superclass), this is a pointer to a superclass&interface array.
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kSuperclassOrComponentclassStr, *typeVoidPtr);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kNumOfFieldsStr, *typeU16);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kNumOfMethodsStr, *typeU16);
+#ifndef USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kFlagStr, *typeU16);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kNumOfSuperclassesStr, *typeU16);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kPaddingStr, *typeU32);
+#endif  // USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kModStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kAnnotationStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kClinitAddrStr, *typeI32);
+  classMetadataRoTyIdx = GenMetaStructType(module, classMetadataROType, kClassMetadataRoTypeName);
+  // MethodInfoType.
+  MIRStructType methodInfoType(kTypeStruct);
+#ifdef USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kMethodInVtabIndexStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kDeclaringclassStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kAddrStr, *typeI32);
+#else
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kMethodInVtabIndexStr, *typeI64);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kDeclaringclassStr, *typeI64);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kAddrStr, *typeI64);
+#endif
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kModStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kMethodNameStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kSignatureNameStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kAnnotationvalueStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kFlagStr, *typeU16);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kArgsizeStr, *typeU16);
+#ifndef USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoType, kPaddingStr, *typeU32);
+#endif  // USE_32BIT_REF
+  methodsInfoTyIdx = GenMetaStructType(module, methodInfoType, kMethodInfoTypeName);
+  // MethodInfoCompactType.
+  MIRStructType methodInfoCompactType(kTypeStruct);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoCompactType, kMethodInVtabIndexStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoCompactType, kAddrStr, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodInfoCompactType, kLebPadding0Str, *typeU8);
+  methodsInfoCompactTyIdx = GenMetaStructType(module, methodInfoCompactType, kMethodInfoCompactTypeName);
+  // FieldInfoType.
+  MIRStructType fieldInfoType(kTypeStruct);
+#ifndef USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kOffsetStr, *typeU64);
+#else
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kOffsetStr, *typeI32);
+#endif  // USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kModStr, *typeU32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kFlagStr, *typeU16);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kIndexStr, *typeU16);
+#ifndef USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kTypeNameStr, *typeI64);
+#else
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kTypeNameStr, *typeI32);
+#endif  // USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kFieldNameStr, *typeU32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kAnnotationStr, *typeU32);
+#ifndef USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kDeclaringclassStr, *typeU64);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kPClassTypeStr, *typeU64);
+#else
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kDeclaringclassStr, *typeU32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kPClassTypeStr, *typeU32);
+#endif  // USE_32BIT_REF
+  fieldsInfoTyIdx = GenMetaStructType(module, fieldInfoType, kFieldInfoTypeName);
+  // FieldInfoType Compact.
+  MIRStructType fieldInfoCompactType(kTypeStruct);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoCompactType, kOffsetStr, *typeU32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoCompactType, kLebPadding0Str, *typeU8);
+  fieldsInfoCompactTyIdx = GenMetaStructType(module, fieldInfoCompactType, kFieldInfoCompactTypeName);
+  // SuperClassMetaType.
+  MIRStructType superclassMetadataType(kTypeStruct);
+  GlobalTables::GetTypeTable().AddFieldToStructType(superclassMetadataType, kSuperclassinfoStr, *typeVoidPtr);
+  superclassMetadataTyIdx = GenMetaStructType(module, superclassMetadataType, kSuperclassMetadataTypeName);
+  // FieldOffsetDataType.
+  MIRStructType fieldOffsetDataType(kTypeStruct);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldOffsetDataType, kFieldOffsetDataStr, *typeVoidPtr);
+  fieldOffsetDataTyIdx = GenMetaStructType(module, fieldOffsetDataType, kFieldOffsetDataTypeName);
+  // MethodAddrDataType.
+  MIRStructType methodAddrDataType(kTypeStruct);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodAddrDataType, kMethodAddrDataStr, *typeVoidPtr);
+  methodAddrDataTyIdx = GenMetaStructType(module, methodAddrDataType, kMethodAddrDataTypeName);
+
+  // MethodSignature
+  MIRStructType methodSignatureType(kTypeStruct);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodSignatureType, kMethodSignatureOffsetName, *typeI32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(methodSignatureType, kMethodSignatureParameterName, *typeVoidPtr);
+  methodSignatureTyIdx = GenMetaStructType(module, methodSignatureType, kMethodSignatureTypeName);
+}
+
+void ReflectionAnalysis::GenClassHashMetaData() {
+  MIRType *type = GlobalTables::GetTypeTable().GetVoidPtr();
+  MIRModule &module = *mirModule;
+  CHECK_FATAL(type != nullptr, "type is null in ReflectionAnalysis::GenClassHashMetaData");
+  if (kRADebug) {
+    LogInfo::MapleLogger(kLlErr) << "========= HASH TABLE ========\n";
+  }
+  if (classTab.empty()) {
+    return;
+  }
+  std::string bucketName = namemangler::kMuidClassMetadataBucketPrefixStr + module.GetFileNameAsPostfix();
+  size_t bucketArraySize = classTab.size();
+  MIRArrayType &bucketArraytype = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*type, bucketArraySize);
+  MIRSymbol *bucketSt = GetOrCreateSymbol(bucketName, bucketArraytype.GetTypeIndex(), true);
+  MIRAggConst *bucketAggconst = module.GetMemPool()->New<MIRAggConst>(module, bucketArraytype);
+  if (bucketAggconst == nullptr) {
+    return;
+  }
+  for (MIRSymbol *classSt : classTab) {
+    AddrofNode *classExpr = mirBuilder.CreateExprAddrof(0, *classSt);
+    MIRType *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(PTY_ptr);
+    MIRConst *classConst =
+        module.GetMemPool()->New<MIRAddrofConst>(classExpr->GetStIdx(), classExpr->GetFieldID(), *ptrType);
+    bucketAggconst->AddItem(classConst, 0);
+  }
+  bucketSt->SetKonst(bucketAggconst);
+}
+
+static void ReflectionAnalysisGenStrTab(MIRModule &mirModule, const std::string &strTab,
+                                        const std::string &strTabName) {
+  MIRBuilder *mirBuilder = mirModule.GetMIRBuilder();
+  size_t strTabSize = strTab.length();
+  MIRArrayType &strTabType =
+      *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetUInt8(), strTabSize);
+  MIRSymbol *strTabSt = mirBuilder->CreateGlobalDecl(strTabName, strTabType);
+  MIRAggConst *strTabAggconst = mirModule.GetMemPool()->New<MIRAggConst>(mirModule, strTabType);
+  if (strTabAggconst == nullptr) {
+    return;
+  }
+  strTabSt->SetStorageClass(kScFstatic);
+  for (char c : strTab) {
+    MIRConst *newConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+        c, *GlobalTables::GetTypeTable().GetUInt8());
+    strTabAggconst->AddItem(newConst, 0);
+  }
+  strTabSt->SetKonst(strTabAggconst);
+}
+
+void ReflectionAnalysis::GenStrTab(MIRModule &module) {
+  // Hot string tab.
+  std::string hotStrtabName = namemangler::kReflectionStartHotStrtabPrefixStr + module.GetFileNameAsPostfix();
+  ReflectionAnalysisGenStrTab(module, strTabStartHot, hotStrtabName);
+  hotStrtabName = namemangler::kReflectionBothHotStrTabPrefixStr + module.GetFileNameAsPostfix();
+  ReflectionAnalysisGenStrTab(module, strTabBothHot, hotStrtabName);
+  hotStrtabName = namemangler::kReflectionRunHotStrtabPrefixStr + module.GetFileNameAsPostfix();
+  ReflectionAnalysisGenStrTab(module, strTabRunHot, hotStrtabName);
+  // Cold string tab.
+  std::string strTabName = namemangler::kReflectionStrtabPrefixStr + module.GetFileNameAsPostfix();
+  ReflectionAnalysisGenStrTab(module, strTab, strTabName);
+}
+
+void ReflectionAnalysis::MarkWeakMethods() {
+  if (!isLibcore) {
+    return;
+  }
+
+  GStrIdx classNames[] = { GetOrCreateGStrIdxFromName(namemangler::kJavaLangClassStr),
+                           GetOrCreateGStrIdxFromName(namemangler::kJavaLangObjectStr),
+                           GetOrCreateGStrIdxFromName(namemangler::kReflectionClassMethodStr),
+                           GetOrCreateGStrIdxFromName(kReflectionReferencePrefixStr) };
+  for (GStrIdx nameIdx : classNames) {
+    Klass *klass = klassH->GetKlassFromStrIdx(nameIdx);
+    if (klass == nullptr) {
+      continue;
+    }
+    MIRClassType *classType = klass->GetMIRClassType();
+    for (const MethodPair &methodPair : classType->GetMethods()) {
+      MIRSymbol *funcSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodPair.first.Idx());
+      MIRFunction *mirfunc = funcSym->GetFunction();
+      if (mirfunc != nullptr) {
+        mirfunc->SetAttr(FUNCATTR_weak);  // It's marked weak since RT-first.
+      }
+    }
+  }
+}
+
+void ReflectionAnalysis::DumpPGOSummary() {
+  LogInfo::MapleLogger() << "PGO summary \n";
+  LogInfo::MapleLogger() << "hot method meta " << ReflectionAnalysis::hotMethodMeta << " total "
+                         << ReflectionAnalysis::totalMethodMeta << std::setprecision(2) << " ratio "
+                         << (static_cast<float>(hotMethodMeta) / totalMethodMeta) << "\n";
+  LogInfo::MapleLogger() << "hot field meta " << ReflectionAnalysis::hotFieldMeta << " total "
+                         << ReflectionAnalysis::totalFieldMeta << std::setprecision(2) << " ratio "
+                         << (static_cast<float>(hotFieldMeta) / totalFieldMeta) << "\n";
+  LogInfo::MapleLogger() << "hot c-str meta " << ReflectionAnalysis::hotCStr << " total "
+                         << ReflectionAnalysis::totalCStr  << std::setprecision(2) << " ratio "
+                         << (static_cast<float>(hotCStr) / totalCStr) << "\n";
+  LogInfo::MapleLogger() << "hot class " << ReflectionAnalysis::hotClassMeta << " total "
+                         << ReflectionAnalysis::totalClassMeta  << std::setprecision(2) << " ratio "
+                         << (static_cast<float>(hotClassMeta) / totalClassMeta) << "\n";
+}
+
+void ReflectionAnalysis::Run() {
+  uint32 dexNameIdx = mirModule->GetFileinfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(kINFOFileName));
+  const std::string &dexName = GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(dexNameIdx));
+  bool deCompressSucc = mirModule->GetProfile().DeCompress(Options::profile, dexName, kAll);
+  if (!deCompressSucc) {
+    LogInfo::MapleLogger() << "WARN: DeCompress() failed in ReflectionAnalysis::Run()\n";
+  }
+  if (Options::profileFunc) {
+    mirModule->GetProfile().SetProfileMode();
+  }
+  isLazyBindingOrDecouple = (Options::lazyBinding && !isLibcore) || Options::buildApp;
+  MarkWeakMethods();
+  GenMetadataType(*mirModule);
+  const MapleVector<Klass*> &klasses = klassH->GetTopoSortedKlasses();
+  if (kRADebug) {
+    LogInfo::MapleLogger(kLlErr) << "========= Gen Class: Total " << klasses.size() << " ========\n";
+  }
+  // Cluster classname together in reflection string table to improve the locality.
+  for (Klass *klass : klasses) {
+    ASSERT_NOT_NULL(klass);
+    GenHotClassNameString(*klass);
+  }
+  for (Klass *klass : klasses) {
+    GenClassMetaData(*klass);
+    // Collect the full information about the classmetadata.
+    reflectionMuidStr = GetMUID(reflectionMuidStr).ToStr();
+  }
+  reflectionMuidStr += MUIDReplacement::GetMplMd5().ToStr();
+  MUIDReplacement::SetMplMd5(GetMUID(reflectionMuidStr));
+  reflectionMuidStr.clear();
+  reflectionMuidStr.shrink_to_fit();
+  GenClassHashMetaData();
+}
+
+bool M2MReflectionAnalysis::PhaseRun(maple::MIRModule &m) {
+  auto *memPool = GetPhaseMemPool();
+  auto *kh = GET_ANALYSIS(M2MKlassHierarchy, m);
+  ASSERT_NOT_NULL(kh);
+  maple::MIRBuilder mirBuilder(&m);
+  ReflectionAnalysis *rv = memPool->New<ReflectionAnalysis>(&m, memPool, kh, mirBuilder);
+  rv->Run();
+  if (Options::genPGOReport) {
+    rv->DumpPGOSummary();
+  }
+  return true;
+}
+
+void M2MReflectionAnalysis::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/retype.cpp b/src/mapleall/mpl2mpl/src/retype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5b74b145a1b462ef674cb9fd8a6b9c75e4bd9e14
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/retype.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "retype.h"
+#include <algorithm>
+
+namespace maple {
+class AnnotationType;
+void Retype::ReplaceRetypeExpr(const BaseNode &expr) {
+  if (expr.NumOpnds() == 0) {
+    return;
+  }
+  for (size_t i = 0; i < expr.NumOpnds(); ++i) {
+    BaseNode *opnd = expr.Opnd(i);
+    if (opnd->GetOpCode() == OP_retype) {
+      opnd->SetOpnd(opnd->Opnd(0), i);
+      continue;
+    }
+    ReplaceRetypeExpr(*opnd);
+  }
+}
+
+void Retype::TransmitGenericInfo(MIRFunction &func, StmtNode &stmt) {
+  if (stmt.GetOpCode() != OP_dassign) {
+    return;
+  }
+  DassignNode &dassignNode = static_cast<DassignNode&>(stmt);
+  BaseNode *rhs = static_cast<DassignNode&>(stmt).GetRHS();
+  if (!rhs->IsLeaf()) {
+    return;
+  }
+  GStrIdx lhsNameStrIdx = func.GetLocalOrGlobalSymbol(dassignNode.GetStIdx())->GetNameStrIdx();
+  GStrIdx rhsNameStrIdx = func.GetLocalOrGlobalSymbol(static_cast<AddrofNode*>(rhs)->GetStIdx())->GetNameStrIdx();
+  const MapleMap<GStrIdx, MIRAliasVars> &map = func.GetAliasVarMap();
+  if (reg2varGenericInfo.find(lhsNameStrIdx) == reg2varGenericInfo.end() ||
+      reg2varGenericInfo[lhsNameStrIdx].sigStrIdx == 0) {
+    return;
+  }
+  if (reg2varGenericInfo.find(rhsNameStrIdx) != reg2varGenericInfo.end() &&
+      reg2varGenericInfo[rhsNameStrIdx].sigStrIdx != 0) {
+    return;
+  }
+  MIRAliasVars aliasVar = reg2varGenericInfo[lhsNameStrIdx];
+  aliasVar.mplStrIdx = rhsNameStrIdx;
+  if (map.find(rhsNameStrIdx) != map.end() && map.at(rhsNameStrIdx).mplStrIdx != rhsNameStrIdx) {
+    CHECK_FATAL(false, "must be");
+  }
+  func.SetAliasVarMap(rhsNameStrIdx, aliasVar);
+}
+
+void Retype::RetypeStmt(MIRFunction &func) {
+  if (func.IsEmpty()) {
+    return;
+  }
+  for (auto &stmt : func.GetBody()->GetStmtNodes()) {
+    if (stmt.GetOpCode() == OP_comment) {
+      continue;
+    }
+    for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+      BaseNode *opnd = stmt.Opnd(i);
+      if (opnd->GetOpCode() == OP_retype) {
+        stmt.SetOpnd(opnd->Opnd(0), i);
+        TransmitGenericInfo(func, stmt);
+        continue;
+      } else {
+        ReplaceRetypeExpr(*opnd);
+      }
+    }
+  }
+}
+
+void Retype::DoRetype() {
+  for (MIRFunction *func : std::as_const(mirModule->GetFunctionList())) {
+    if (func->IsEmpty()) {
+      continue;
+    }
+    for (auto pair : func->GetAliasVarMap()) {
+      GStrIdx regNameStrIdx = pair.second.mplStrIdx;
+      reg2varGenericInfo[regNameStrIdx] = pair.second;
+    }
+    RetypeStmt(*func);
+    reg2varGenericInfo.clear();
+  }
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/scalarreplacement.cpp b/src/mapleall/mpl2mpl/src/scalarreplacement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8784d0196827be54c8e3a81b9c4ddc6c45e4e958
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/scalarreplacement.cpp
@@ -0,0 +1,348 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "scalarreplacement.h"
+#include "maple_phase_manager.h"
+// ScalarReplacement works together with EscapeAnalysis. If EA has decided
+// to allocate a certain object on the stack, ScalarReplacement will further
+// break down that object into several fields if possible, thus the object
+// does not need to be created at all.
+// The algorithm has two passes: CollectCandidates iterates all stmt to collect
+// suitable candidate stmt, and ReplaceLocalVars iterates candidate stmt to
+// perform the actual optimization.
+namespace maple {
+template <typename Func>
+void ScalarReplacement::IterateStmt(StmtNode *stmt, Func const &applyFunc) {
+  if (!stmt) {
+    return;
+  }
+  switch (stmt->GetOpCode()) {
+    case OP_if: {
+      IfStmtNode *inode = static_cast<IfStmtNode*>(stmt);
+      inode->SetOpnd(IterateExpr(stmt, inode->Opnd(0), applyFunc), 0);
+      IterateStmt(inode->GetThenPart(), applyFunc);
+      IterateStmt(inode->GetElsePart(), applyFunc);
+      break;
+    }
+    case OP_while: {
+      WhileStmtNode *wnode = static_cast<WhileStmtNode*>(stmt);
+      wnode->SetOpnd(IterateExpr(stmt, wnode->Opnd(0), applyFunc), 0);
+      IterateStmt(wnode->GetBody(), applyFunc);
+      break;
+    }
+    case OP_block: {
+      BlockNode *bnode = static_cast<BlockNode*>(stmt);
+      for (auto &stmtNode : bnode->GetStmtNodes()) {
+        IterateStmt(&stmtNode, applyFunc);
+      }
+      break;
+    }
+    default: {
+      applyFunc(stmt, nullptr);  // Handle the statement itself
+      for (size_t i = 0; i < stmt->NumOpnds(); i++) {
+        stmt->SetOpnd(IterateExpr(stmt, stmt->Opnd(i), applyFunc), i);
+      }
+      break;
+    }
+  }
+}
+
+template <typename Func>
+BaseNode *ScalarReplacement::IterateExpr(StmtNode *stmt, BaseNode *expr, Func const &applyFunc) {
+  if (!expr) {
+    return expr;
+  }
+  size_t i = 0;
+  switch (expr->GetOpCode()) {
+    case OP_dread:
+    case OP_addrof: {
+      return applyFunc(stmt, expr);
+    }
+    case OP_select: {
+      TernaryNode *topnds = static_cast<TernaryNode*>(expr);
+      for (i = 0; i < topnds->NumOpnds(); i++) {
+        topnds->SetOpnd(IterateExpr(stmt, topnds->Opnd(i), applyFunc), i);
+      }
+      return expr;
+    }
+    default: {
+      if (expr->IsUnaryNode()) {
+        UnaryNode *uOpnd = static_cast<UnaryNode*>(expr);
+        uOpnd->SetOpnd(IterateExpr(stmt, uOpnd->Opnd(0), applyFunc), i);
+      } else if (expr->IsBinaryNode()) {
+        BinaryNode *bopnds = static_cast<BinaryNode*>(expr);
+        for (i = 0; i < bopnds->NumOpnds(); i++) {
+          bopnds->SetOpnd(IterateExpr(stmt, bopnds->GetBOpnd(i), applyFunc), i);
+        }
+      } else {
+        for (i = 0; i < expr->NumOpnds(); i++) {
+          expr->SetOpnd(IterateExpr(stmt, expr->Opnd(i), applyFunc), i);
+        }
+      }
+      break;
+    }
+  }
+  return expr;
+}
+
+BaseNode *ScalarReplacement::MarkDassignDread(StmtNode *stmt, BaseNode *opnd) {
+  ASSERT(stmt != nullptr, "null ptr check");
+  MIRSymbol *sym = nullptr;
+  FieldID fldid = 0;
+  if (!opnd) {
+    // opnd nullptr means to handle the statment itself
+    if (stmt->GetOpCode() == OP_dassign) {
+      DassignNode *dassignNode = static_cast<DassignNode*>(stmt);
+      sym = currFunc->GetLocalOrGlobalSymbol(dassignNode->GetStIdx());
+      fldid = dassignNode->GetFieldID();
+    } else if (stmt->GetOpCode() == OP_intrinsiccall) {
+      IntrinsiccallNode *inode = static_cast<IntrinsiccallNode*>(stmt);
+      if (inode->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS ||
+          inode->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP) {
+        localRefCleanup.push_back(inode);
+      }
+    }
+  } else if (opnd->GetOpCode() == OP_dread || opnd->GetOpCode() == OP_addrof) {
+    DreadNode *dreadNode = static_cast<DreadNode*>(opnd);
+    sym = currFunc->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+    fldid = dreadNode->GetFieldID();
+  }
+  if (sym != nullptr) {
+    if (localVarMap.find(sym) != localVarMap.end()) {
+      FldRefMap &fld2ref = localVarMap[sym];
+      if (fld2ref.find(fldid) == fld2ref.end()) {
+        fld2ref[fldid] = {};
+      }
+      fld2ref[fldid].push_back(stmt);
+    }
+  }
+  return opnd;
+}
+
+void ScalarReplacement::CollectCandidates() {
+  // Analyze and transform use the same iterator, but
+  // with different function parameters
+  IterateStmt(currFunc->GetBody(),
+              [this](StmtNode *stmt, BaseNode *expr) { return this->MarkDassignDread(stmt, expr); });
+}
+
+void ScalarReplacement::DumpCandidates() const {
+  LogInfo::MapleLogger() << "Dump ScalarReplacement candidates:\n";
+  for (auto localvalKeyVal : localVarMap) {
+    LogInfo::MapleLogger() << localvalKeyVal.first->GetName() << "\n";
+    for (auto fldrefKeyVal : localvalKeyVal.second) {
+      LogInfo::MapleLogger() << "\tfield id: " << fldrefKeyVal.first << "\n";
+      for (StmtNode *snode : fldrefKeyVal.second) {
+        LogInfo::MapleLogger() << "\t\t";
+        snode->Dump(0);
+      }
+    }
+  }
+}
+
+bool ScalarReplacement::IsMemsetLocalvar(StmtNode *stmt) const {
+  if (stmt->GetOpCode() == OP_intrinsiccallwithtypeassigned) {
+    IntrinsiccallNode *inode = static_cast<IntrinsiccallNode*>(stmt);
+    if (inode->GetIntrinsic() == INTRN_MPL_MEMSET_LOCALVAR) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ScalarReplacement::IsSetClass(StmtNode *stmt) const {
+  if (stmt->GetOpCode() == OP_intrinsiccallassigned) {
+    IntrinsiccallNode *inode = static_cast<IntrinsiccallNode*>(stmt);
+    if (inode->GetIntrinsic() == INTRN_MPL_SET_CLASS) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ScalarReplacement::IsCCWriteRefField(StmtNode *stmt) const {
+  if (stmt->GetOpCode() == OP_call) {
+    CallNode *cnode = static_cast<CallNode*>(stmt);
+    MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(cnode->GetPUIdx());
+    if (func->GetName().find("MCC_WriteRefFieldNoInc") == 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ScalarReplacement::CanBeReplaced(const StmtVec *refs) const {
+  // If a localVar is never referenced by fieldID 0,
+  // we can perform the scalar replacement. There are
+  // a few exceptions:
+  // 1. MPL_MEMSET_LOCALVAR
+  // 2. MPL_SET_CLASS
+  // 3. CC_WriteRefField*
+  CHECK_FATAL(refs, "missing fieldID 0 accesses");
+  for (StmtNode *stmt : (*refs)) {
+    if (!IsMemsetLocalvar(stmt) && !IsSetClass(stmt) && !IsCCWriteRefField(stmt)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+BaseNode *ScalarReplacement::ReplaceDassignDread(StmtNode *stmt, BaseNode *opnd) {
+  if (!opnd) {
+    // opnd nullptr means to handle the statment itself
+    if (stmt->GetOpCode() == OP_dassign) {
+      DassignNode *dassignNode = static_cast<DassignNode*>(stmt);
+      if (dassignNode->GetStIdx() == curSym->GetStIdx() && dassignNode->GetFieldID() == curFieldid) {
+        // Update to the new scalar
+        dassignNode->SetStIdx(newScalarSym->GetStIdx());
+        dassignNode->SetFieldID(0);
+      }
+    }
+  } else if (opnd->GetOpCode() == OP_dread || opnd->GetOpCode() == OP_addrof) {
+    DreadNode *dreadNode = static_cast<DreadNode*>(opnd);
+    if (dreadNode->GetStIdx() == curSym->GetStIdx() && dreadNode->GetFieldID() == curFieldid) {
+      // Update to the new scalar
+      dreadNode->SetStIdx(newScalarSym->GetStIdx());
+      dreadNode->SetFieldID(0);
+    }
+  }
+  return opnd;
+}
+
+void ScalarReplacement::AppendLocalRefCleanup(const MIRSymbol *sym) {
+  if (!sym) {
+    return;
+  }
+  for (IntrinsiccallNode *inode : localRefCleanup) {
+    // do not push back as last one could be skipped
+    inode->GetNopnd().insert(inode->GetNopnd().cbegin(), builder->CreateDread(*sym, PTY_ref));
+  }
+}
+
+void ScalarReplacement::ReplaceWithScalar(const StmtVec *refs) {
+  if (!refs) {
+    return;
+  }
+  if (curFieldid == 0) {
+    for (StmtNode *stmt : (*refs)) {
+      if (IsMemsetLocalvar(stmt) || IsSetClass(stmt)) {
+        currFunc->GetBody()->RemoveStmt(stmt);
+      }
+    }
+  } else {
+    MIRType *type = curSym->GetType();
+    CHECK_FATAL(type && (type->GetKind() == kTypeClass), "Expect a class typed symbol");
+    MIRClassType *classtype = static_cast<MIRClassType*>(type);
+    MIRType *fldtype = classtype->GetFieldType(curFieldid);
+    std::string localScalarName = curSym->GetName() + "_" + std::to_string(curFieldid);
+    newScalarSym = builder->CreateLocalDecl(localScalarName, *fldtype);
+    if (fldtype->GetPrimType() == PTY_ref) {
+      newScalarSym->SetLocalRefVar();
+      AppendLocalRefCleanup(newScalarSym);
+    }
+    for (StmtNode *stmt : (*refs)) {
+      IterateStmt(stmt, [this](StmtNode *stmt, BaseNode *expr) { return this->ReplaceDassignDread(stmt, expr); });
+    }
+  }
+}
+
+void ScalarReplacement::FixRCCalls(const StmtVec *refs) {
+  if (!refs) {
+    return;
+  }
+  for (StmtNode *stmt : (*refs)) {
+    if (!IsCCWriteRefField(stmt)) {
+      continue;
+    }
+    // After all the replacement is done, turn calls like,
+    //   call &MCC_WriteRefFieldNoInc (addrof ptr %__localVar__0, addrof ptr %__localVar__0_5, regread ref %11)
+    // into,
+    //   call &MCC_DecRef_NaiveRCFast(dread ref %__localVar__0_5)
+    //   dassign %__localVar__0_5 0 (regread ref %11)
+    CallNode *cnode = static_cast<CallNode*>(stmt);
+    BaseNode *firstParameter = cnode->GetNopndAt(0);
+    CHECK_FATAL(firstParameter && firstParameter->GetOpCode() == OP_addrof, "Invalid first parameter");
+    AddrofNode *firstAddrof = static_cast<AddrofNode*>(firstParameter);
+    CHECK_FATAL(curSym != nullptr, "curSym is null");
+    CHECK_FATAL(firstAddrof->GetStIdx() == curSym->GetStIdx() && firstAddrof->GetFieldID() == 0,
+                "First parameter does not match");
+    BaseNode *secondParameter = cnode->GetNopndAt(1);
+    CHECK_FATAL(secondParameter && secondParameter->GetOpCode() == OP_addrof, "Invalid second parameter");
+    BaseNode *arg = secondParameter->CloneTree(GetMIRModule().GetCurFuncCodeMPAllocator());
+    CHECK_FATAL(arg != nullptr, "null ptr check");
+    arg->SetOpCode(OP_dread);
+    MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    args.push_back(arg);
+    CallNode *rccall = builder->CreateStmtCall("MCC_DecRef_NaiveRCFast", args);
+    currFunc->GetBody()->InsertBefore(stmt, rccall);
+    AddrofNode *secondAddrof = static_cast<AddrofNode*>(secondParameter);
+    StmtNode *dassign = builder->CreateStmtDassign(
+        secondAddrof->GetStIdx(), secondAddrof->GetFieldID(),
+        cnode->GetNopndAt(2)->CloneTree(GetMIRModule().GetCurFuncCodeMPAllocator()));
+    currFunc->GetBody()->InsertBefore(stmt, dassign);
+    currFunc->GetBody()->RemoveStmt(stmt);
+  }
+}
+
+void ScalarReplacement::ReplaceLocalVars() {
+  for (auto localvalKeyVal : localVarMap) {
+    // Check all the fieldID == 0 references to see if the transformation is legal
+    FldRefMap &fldrefMap = localvalKeyVal.second;
+    if (CanBeReplaced(&fldrefMap.at(0))) {
+      curSym = localvalKeyVal.first;
+      curSym->SetIsDeleted();
+      for (auto fldrefKeyVal : fldrefMap) {
+        curFieldid = fldrefKeyVal.first;
+        ReplaceWithScalar(&fldrefKeyVal.second);
+      }
+      FixRCCalls(&fldrefMap.at(0));
+    }
+  }
+  // Cleanup to make sure the next func gets a fresh start
+  localVarMap.clear();
+  localRefCleanup.clear();
+}
+
+void ScalarReplacement::ProcessFunc(MIRFunction *func) {
+  if (func->IsEmpty()) {
+    return;
+  }
+  SetCurrentFunction(*func);
+  // Iterate function symbol table to find allocated-on-stack variables
+  for (size_t i = 1; i < func->GetSymTab()->GetSymbolTableSize(); i++) {
+    MIRSymbol *sym = func->GetSymTab()->GetSymbolFromStIdx(i);
+    if (sym != nullptr && sym->GetType() && sym->GetType()->GetKind() == kTypeClass) {
+      localVarMap[sym] = {};
+    }
+  }
+  if (localVarMap.empty()) {
+    return;
+  }
+  CollectCandidates();
+  if (trace) {
+    DumpCandidates();
+  }
+  ReplaceLocalVars();
+}
+
+void M2MScalarReplacement::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+
+bool M2MScalarReplacement::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(ScalarReplacement, m);
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/simplify.cpp b/src/mapleall/mpl2mpl/src/simplify.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1ae6cde9806bdcc250efb1b77c62198bebb585d9
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/simplify.cpp
@@ -0,0 +1,2362 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include "triple.h"
+#include "simplify.h"
+#include <functional>
+#include <initializer_list>
+#include <iostream>
+#include <algorithm>
+#include "constantfold.h"
+
+namespace maple {
+
+namespace {
+
+constexpr char kClassNameOfMath[] = "Ljava_2Flang_2FMath_3B";
+constexpr char kFuncNamePrefixOfMathSqrt[] = "Ljava_2Flang_2FMath_3B_7Csqrt_7C_28D_29D";
+constexpr char kFuncNamePrefixOfMathAbs[] = "Ljava_2Flang_2FMath_3B_7Cabs_7C";
+constexpr char kFuncNamePrefixOfMathMax[] = "Ljava_2Flang_2FMath_3B_7Cmax_7C";
+constexpr char kFuncNamePrefixOfMathMin[] = "Ljava_2Flang_2FMath_3B_7Cmin_7C";
+constexpr char kFuncNameOfMathAbs[] = "abs";
+constexpr char kFuncNameOfMemset[] = "memset";
+constexpr char kFuncNameOfMemcpy[] = "memcpy";
+constexpr char kFuncNameOfMemsetS[] = "memset_s";
+constexpr char kFuncNameOfMemcpyS[] = "memcpy_s";
+constexpr char kFuncNameOfSprintf[] = "sprintf";
+constexpr char kFuncNameOfSprintfS[] = "sprintf_s";
+constexpr char kFuncNameOfSnprintfS[] = "snprintf_s";
+constexpr char kFuncNameOfVsnprintfS[] = "vsnprintf_s";
+constexpr uint64_t kSecurecMemMaxLen = 0x7fffffffUL;
+static constexpr int32 kProbUnlikely = 1000;
+constexpr uint32_t kMemOpDstOpndIdx = 0;
+constexpr uint32_t kMemOpSDstSizeOpndIdx = 1;
+constexpr uint32_t kMemOpSrcOpndIdx = 2;
+constexpr uint32_t kMemOpSSrcOpndIdx = 2;
+constexpr uint32_t kMemOpSSrcSizeOpndIdx = 3;
+constexpr uint32_t kSprintfFmtOpndIdx = 1;
+constexpr uint32_t kSprintfOrigOpndIdx = 2;
+constexpr uint32_t kSprintfSOrigOpndIdx = 3;
+constexpr uint32_t kSnprintfSFmtOpndIdx = 3;
+constexpr uint32_t kSnprintfSOrigOpndIdx = 4;
+constexpr uint32_t kFmtSizeOpndIdx = 2;
+constexpr uint32_t kDstSizeOpndIdx = 1;
+constexpr uint32_t kSprintfDstOpndIdx = 0;
+constexpr int32 kSprintfErrNum = -1;
+constexpr int32 kTruncate = -1;
+constexpr std::string_view kTempAddrStr = "tempAddr";
+constexpr std::string_view kUnderlineStr = "_";
+constexpr std::string_view kVerticalLineStr = "__";
+// Truncate the constant field of 'union' if it's written as scalar type (e.g. int),
+// but accessed as bit-field type with smaller size.
+// Return the truncated constant or the original constant 'fieldCst' if the constant doesn't need to be truncated.
+MIRConst *TruncateUnionConstant(const MIRStructType &unionType, MIRConst *fieldCst, const MIRType &unionFieldType) {
+  if (!fieldCst || unionType.GetKind() != kTypeUnion) {
+    return fieldCst;
+  }
+
+  auto *bitFieldType = safe_cast<MIRBitFieldType>(unionFieldType);
+  auto *intCst = safe_cast<MIRIntConst>(fieldCst);
+
+  if (!bitFieldType || !intCst) {
+    return fieldCst;
+  }
+
+  bool isBigEndian = MeOption::IsBigEndian() || Options::IsBigEndian();
+
+  IntVal val = intCst->GetValue();
+  uint8 bitSize = bitFieldType->GetFieldSize();
+
+  if (bitSize >= val.GetBitWidth()) {
+    return fieldCst;
+  }
+
+  if (isBigEndian) {
+    val = val.LShr(val.GetBitWidth() - bitSize);
+  } else {
+    val = val & ((uint64(1) << bitSize) - 1);
+  }
+
+  return GlobalTables::GetIntConstTable().GetOrCreateIntConst(val, fieldCst->GetType());
+}
+
+} // namespace
+
+// If size (in byte) is bigger than this threshold, we won't expand memop
+const uint32 SimplifyOp::thresholdMemsetExpand = 512;
+const uint32 SimplifyOp::thresholdMemcpyExpand = 512;
+const uint32 SimplifyOp::thresholdMemsetSExpand = 1024;
+const uint32 SimplifyOp::thresholdMemcpySExpand = 1024;
+static const uint32 kMaxMemoryBlockSizeToAssign = 8;  // in byte
+
+static void MayPrintLog(bool debug, bool success, OpKind opKind, const char *str) {
+  if (!debug) {
+    return;
+  }
+  const char *op = "";
+  if (opKind == MEM_OP_memset) {
+    op = "memset";
+  } else if (opKind == MEM_OP_memcpy) {
+    op = "memcpy";
+  } else if (opKind == MEM_OP_memset_s) {
+    op = "memset_s";
+  } else if (opKind == MEM_OP_memcpy_s) {
+    op = "memcpy_s";
+  }
+  LogInfo::MapleLogger() << op << " expand " << (success ? "success: " : "failure: ") << str << std::endl;
+}
+
+bool Simplify::IsMathSqrt(const std::string funcName) {
+  return (mirMod.IsJavaModule() && (strcmp(funcName.c_str(), kFuncNamePrefixOfMathSqrt) == 0));
+}
+
+bool Simplify::IsMathAbs(const std::string funcName) {
+  return (mirMod.IsCModule() && (strcmp(funcName.c_str(), kFuncNameOfMathAbs) == 0)) ||
+         (mirMod.IsJavaModule() && (strcmp(funcName.c_str(), kFuncNamePrefixOfMathAbs) == 0));
+}
+
+bool Simplify::IsMathMax(const std::string funcName) {
+  return (mirMod.IsJavaModule() && (strcmp(funcName.c_str(), kFuncNamePrefixOfMathMax) == 0));
+}
+
+bool Simplify::IsMathMin(const std::string funcName) {
+  return (mirMod.IsJavaModule() && (strcmp(funcName.c_str(), kFuncNamePrefixOfMathMin) == 0));
+}
+
+bool Simplify::SimplifyMathMethod(const StmtNode &stmt, BlockNode &block) {
+  if (stmt.GetOpCode() != OP_callassigned) {
+    return false;
+  }
+  auto &cnode = static_cast<const CallNode&>(stmt);
+  MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(cnode.GetPUIdx());
+  ASSERT(calleeFunc != nullptr, "null ptr check");
+  const std::string &funcName = calleeFunc->GetName();
+  if (funcName.empty()) {
+    return false;
+  }
+  if (!mirMod.IsCModule() && !mirMod.IsJavaModule()) {
+    return false;
+  }
+  if (mirMod.IsJavaModule() && funcName.find(kClassNameOfMath) == std::string::npos) {
+    return false;
+  }
+  if (cnode.GetNumOpnds() == 0 || cnode.GetReturnVec().empty()) {
+    return false;
+  }
+
+  auto *opnd0 = cnode.Opnd(0);
+  ASSERT(opnd0 != nullptr, "null ptr check");
+  auto *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(opnd0->GetPrimType());
+
+  BaseNode *opExpr = nullptr;
+  if (IsMathSqrt(funcName) && !IsPrimitiveFloat(opnd0->GetPrimType())) {
+    opExpr = builder->CreateExprUnary(OP_sqrt, *type, opnd0);
+  } else if (IsMathAbs(funcName)) {
+    opExpr = builder->CreateExprUnary(OP_abs, *type, opnd0);
+  } else if (IsMathMax(funcName)) {
+    opExpr = builder->CreateExprBinary(OP_max, *type, opnd0, cnode.Opnd(1));
+  } else if (IsMathMin(funcName)) {
+    opExpr = builder->CreateExprBinary(OP_min, *type, opnd0, cnode.Opnd(1));
+  }
+  if (opExpr != nullptr) {
+    auto stIdx = cnode.GetNthReturnVec(0).first;
+    auto *dassign = builder->CreateStmtDassign(stIdx, 0, opExpr);
+    block.ReplaceStmt1WithStmt2(&stmt, dassign);
+    return true;
+  }
+  return false;
+}
+
+void Simplify::SimplifyCallAssigned(StmtNode &stmt, BlockNode &block) {
+  if (SimplifyMathMethod(stmt, block)) {
+    return;
+  }
+  simplifyMemOp.SetDebug(dump);
+  simplifyMemOp.SetFunction(currFunc);
+  if (simplifyMemOp.AutoSimplify(stmt, block, false)) {
+    return;
+  }
+}
+
+constexpr uint32 kUpperLimitOfFieldNum = 10;
+static MIRStructType *GetDassignedStructType(const DassignNode *dassign, MIRFunction *func) {
+  const auto &lhsStIdx = dassign->GetStIdx();
+  auto lhsSymbol = func->GetLocalOrGlobalSymbol(lhsStIdx);
+  ASSERT_NOT_NULL(lhsSymbol);
+  auto lhsAggType = lhsSymbol->GetType();
+  ASSERT_NOT_NULL(lhsAggType);
+  if (!lhsAggType->IsStructType()) {
+    return nullptr;
+  }
+  if (lhsAggType->GetKind() == kTypeUnion) {  // no need to split union's field
+    return nullptr;
+  }
+  auto lhsFieldID = dassign->GetFieldID();
+  if (lhsFieldID != 0) {
+    CHECK_FATAL(lhsAggType->IsStructType(), "only struct has non-zero fieldID");
+    lhsAggType = static_cast<MIRStructType *>(lhsAggType)->GetFieldType(lhsFieldID);
+    if (!lhsAggType->IsStructType()) {
+      return nullptr;
+    }
+    if (lhsAggType->GetKind() == kTypeUnion) {  // no need to split union's field
+      return nullptr;
+    }
+  }
+  if (static_cast<MIRStructType *>(lhsAggType)->NumberOfFieldIDs() > kUpperLimitOfFieldNum) {
+    return nullptr;
+  }
+  return static_cast<MIRStructType *>(lhsAggType);
+}
+
+static MIRStructType *GetIassignedStructType(const IassignNode *iassign) {
+  auto ptrTyIdx = iassign->GetTyIdx();
+  auto *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTyIdx);
+  CHECK_FATAL(ptrType->IsMIRPtrType(), "must be pointer type");
+  auto aggTyIdx = static_cast<MIRPtrType *>(ptrType)->GetPointedTyIdxWithFieldID(iassign->GetFieldID());
+  auto *lhsAggType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(aggTyIdx);
+  if (!lhsAggType->IsStructType()) {
+    return nullptr;
+  }
+  if (lhsAggType->GetKind() == kTypeUnion) {
+    return nullptr;
+  }
+  if (static_cast<MIRStructType *>(lhsAggType)->NumberOfFieldIDs() > kUpperLimitOfFieldNum) {
+    return nullptr;
+  }
+  return static_cast<MIRStructType *>(lhsAggType);
+}
+
+static MIRStructType *GetReadedStructureType(const DreadNode *dread, const MIRFunction *func) {
+  const auto &rhsStIdx = dread->GetStIdx();
+  auto rhsSymbol = func->GetLocalOrGlobalSymbol(rhsStIdx);
+  ASSERT_NOT_NULL(rhsSymbol);
+  auto rhsAggType = rhsSymbol->GetType();
+  auto rhsFieldID = dread->GetFieldID();
+  if (rhsFieldID != 0) {
+    CHECK_FATAL(rhsAggType->IsStructType(), "only struct has non-zero fieldID");
+    rhsAggType = static_cast<MIRStructType *>(rhsAggType)->GetFieldType(rhsFieldID);
+  }
+  if (!rhsAggType->IsStructType()) {
+    return nullptr;
+  }
+  return static_cast<MIRStructType *>(rhsAggType);
+}
+
+static MIRStructType *GetReadedStructureType(const IreadNode *iread, const MIRFunction*) {
+  auto rhsPtrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread->GetTyIdx());
+  CHECK_FATAL(rhsPtrType->IsMIRPtrType(), "must be pointer type");
+  auto rhsAggType = static_cast<MIRPtrType*>(rhsPtrType)->GetPointedType();
+  auto rhsFieldID = iread->GetFieldID();
+  if (rhsFieldID != 0) {
+    CHECK_FATAL(rhsAggType->IsStructType(), "only struct has non-zero fieldID");
+    rhsAggType = static_cast<MIRStructType *>(rhsAggType)->GetFieldType(rhsFieldID);
+  }
+  if (!rhsAggType->IsStructType()) {
+    return nullptr;
+  }
+  return static_cast<MIRStructType *>(rhsAggType);
+}
+
+template <class RhsType, class AssignType>
+static StmtNode *SplitAggCopy(const AssignType *assignNode, MIRStructType *structureType,
+                              BlockNode *block, MIRFunction *func) {
+  auto *readNode = static_cast<RhsType *>(assignNode->GetRHS());
+  auto rhsFieldID = readNode->GetFieldID();
+  auto *rhsAggType = GetReadedStructureType(readNode, func);
+  if (structureType != rhsAggType) {
+    return nullptr;
+  }
+
+  for (FieldID id = 1; id <= static_cast<FieldID>(structureType->NumberOfFieldIDs()); ++id) {
+    MIRType *fieldType = structureType->GetFieldType(id);
+    if (fieldType->GetSize() == 0) {
+      continue; // field size is zero for empty struct/union;
+    }
+    if (fieldType->GetKind() == kTypeBitField && static_cast<MIRBitFieldType *>(fieldType)->GetFieldSize() == 0) {
+      continue; // bitfield size is zero
+    }
+    auto *newAssign = assignNode->CloneTree(func->GetCodeMemPoolAllocator());
+    newAssign->SetFieldID(assignNode->GetFieldID() + id);
+    auto *newRHS = static_cast<RhsType *>(newAssign->GetRHS());
+    newRHS->SetFieldID(rhsFieldID + id);
+    newRHS->SetPrimType(fieldType->GetPrimType());
+    block->InsertAfter(assignNode, newAssign);
+    newAssign->SetExpandFromArrayOfCharFunc(assignNode->IsExpandedFromArrayOfCharFunc());
+    if (fieldType->IsMIRUnionType()) {
+      id += fieldType->NumberOfFieldIDs();
+    }
+  }
+  auto newAssign = assignNode->GetNext();
+  block->RemoveStmt(assignNode);
+  return newAssign;
+}
+
+static StmtNode *SplitDassignAggCopy(DassignNode *dassign, BlockNode *block, MIRFunction *func) {
+  auto *rhs = dassign->GetRHS();
+  if (rhs->GetPrimType() != PTY_agg) {
+    return nullptr;
+  }
+
+  auto *lhsAggType = GetDassignedStructType(dassign, func);
+  if (lhsAggType == nullptr) {
+    return nullptr;
+  }
+
+  if (rhs->GetOpCode() == OP_dread) {
+    auto *lhsSymbol = func->GetLocalOrGlobalSymbol(dassign->GetStIdx());
+    auto *rhsSymbol = func->GetLocalOrGlobalSymbol(static_cast<DreadNode *>(rhs)->GetStIdx());
+    ASSERT_NOT_NULL(lhsSymbol);
+    ASSERT_NOT_NULL(rhsSymbol);
+    if (!lhsSymbol->IsLocal() && !rhsSymbol->IsLocal()) {
+      return nullptr;
+    }
+
+    return SplitAggCopy<DreadNode>(dassign, lhsAggType, block, func);
+  } else if (rhs->GetOpCode() == OP_iread) {
+    return SplitAggCopy<IreadNode>(dassign, lhsAggType, block, func);
+  }
+  return nullptr;
+}
+
+static StmtNode *SplitIassignAggCopy(IassignNode *iassign, BlockNode *block, MIRFunction *func) {
+  auto rhs = iassign->GetRHS();
+  if (rhs->GetPrimType() != PTY_agg) {
+    return nullptr;
+  }
+
+  auto *lhsAggType = GetIassignedStructType(iassign);
+  if (lhsAggType == nullptr) {
+    return nullptr;
+  }
+
+  if (rhs->GetOpCode() == OP_dread) {
+    return SplitAggCopy<DreadNode>(iassign, lhsAggType, block, func);
+  } else if (rhs->GetOpCode() == OP_iread) {
+    return SplitAggCopy<IreadNode>(iassign, lhsAggType, block, func);
+  }
+  return nullptr;
+}
+
+bool UseGlobalVar(const BaseNode *expr) {
+  if (expr->GetOpCode() == OP_addrof || expr->GetOpCode() == OP_dread) {
+    StIdx stIdx = static_cast<const AddrofNode*>(expr)->GetStIdx();
+    if (stIdx.IsGlobal()) {
+      return true;
+    }
+  }
+  for (size_t i = 0; i < expr->GetNumOpnds(); ++i) {
+    if (UseGlobalVar(expr->Opnd(i))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+StmtNode *Simplify::SimplifyToSelect(MIRFunction *func, IfStmtNode *ifNode, BlockNode *block) {
+  // Example: if (condition) {
+  //   Example: res = trueRes
+  // Example: }
+  // Example: else {
+  //   Example: res = falseRes
+  // Example: }
+  // =================
+  // res = select condition ? trueRes : falseRes
+  if (ifNode->GetPrev() != nullptr && ifNode->GetPrev()->GetOpCode() == OP_label) {
+    // simplify shortCircuit will stop opt in cfg_opt, and generate extra compare
+    auto *labelNode = static_cast<LabelNode*>(ifNode->GetPrev());
+    const std::string &labelName = func->GetLabelTabItem(labelNode->GetLabelIdx());
+    if (labelName.find("shortCircuit") != std::string::npos) {
+      return nullptr;
+    }
+  }
+  if (ifNode->GetThenPart() == nullptr || ifNode->GetElsePart() == nullptr) {
+    return nullptr;
+  }
+  StmtNode *thenFirst = ifNode->GetThenPart()->GetFirst();
+  StmtNode *elseFirst = ifNode->GetElsePart()->GetFirst();
+  if (thenFirst == nullptr || elseFirst == nullptr) {
+    return nullptr;
+  }
+  // thenpart and elsepart has only one stmt
+  if (thenFirst->GetNext() != nullptr || elseFirst->GetNext() != nullptr) {
+    return nullptr;
+  }
+  if (thenFirst->GetOpCode() != OP_dassign || elseFirst->GetOpCode() != OP_dassign) {
+    return nullptr;
+  }
+  auto *thenDass = static_cast<DassignNode*>(thenFirst);
+  auto *elseDass = static_cast<DassignNode*>(elseFirst);
+  if (thenDass->GetStIdx() != elseDass->GetStIdx() || thenDass->GetFieldID() != elseDass->GetFieldID()) {
+    return nullptr;
+  }
+  // iread has sideeffect : may cause deref error
+  if (HasIreadExpr(thenDass->GetRHS()) || HasIreadExpr(elseDass->GetRHS())) {
+    return nullptr;
+  }
+  // Check if the operand of the select node is complex enough
+  // we should not simplify it to if-then-else for either functionality or performance reason
+  if (thenDass->GetRHS()->GetPrimType() == PTY_agg || elseDass->GetRHS()->GetPrimType() == PTY_agg) {
+    return nullptr;
+  }
+  constexpr size_t maxDepth = 3;
+  if (MaxDepth(thenDass->GetRHS()) > maxDepth || MaxDepth(elseDass->GetRHS()) > maxDepth) {
+    return nullptr;
+  }
+  if (UseGlobalVar(thenDass->GetRHS()) || UseGlobalVar(elseDass->GetRHS())) {
+    return nullptr;
+  }
+  MIRBuilder *mirBuiler = func->GetModule()->GetMIRBuilder();
+  MIRType *type = GlobalTables::GetTypeTable().GetPrimType(thenDass->GetRHS()->GetPrimType());
+  auto *selectExpr =
+      mirBuiler->CreateExprTernary(OP_select, *type, ifNode->Opnd(0), thenDass->GetRHS(), elseDass->GetRHS());
+  auto *newDassign = mirBuiler->CreateStmtDassign(thenDass->GetStIdx(), thenDass->GetFieldID(), selectExpr);
+  newDassign->SetSrcPos(ifNode->GetSrcPos());
+  block->InsertBefore(ifNode, newDassign);
+  block->RemoveStmt(ifNode);
+  return newDassign;
+}
+
+struct BitFieldExtract {
+  int64 byteOffset = 0;
+  int64 extractStart = 0;
+  int64 extractSize = 0;
+  MIRType *extractType = nullptr;
+};
+
+static bool ExtractBitField(const MIRPtrType &type, FieldID fldID, BitFieldExtract &bfe) {
+  // skip volatile field and packed struct
+  if (type.IsPointedTypeVolatile(fldID)) {
+    return false;
+  }
+  auto *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(type.GetPointedTyIdxWithFieldID(fldID));
+  ASSERT_NOT_NULL(fieldType);
+  if (fieldType->GetKind() != kTypeBitField || GetPrimTypeSize(fieldType->GetPrimType()) > GetPrimTypeSize(PTY_u64)) {
+    return false;
+  }
+  auto bitOffset = type.GetPointedType()->GetBitOffsetFromBaseAddr(fldID);
+  auto extractSize = static_cast<MIRBitFieldType*>(fieldType)->GetFieldSize();
+  if ((bitOffset / LLONG_WIDTH) != ((bitOffset + extractSize) / LLONG_WIDTH)) {
+    return false;
+  }
+  if (bitOffset % CHAR_WIDTH == 0 && (extractSize == CHAR_WIDTH || extractSize == SHRT_WIDTH ||
+                                      extractSize == INT_WIDTH || extractSize == LLONG_WIDTH)) {
+    return false;
+  }
+  auto byteOffset = (bitOffset / LLONG_WIDTH) * CHAR_WIDTH;  // expand the read length to 64 bit
+  auto *readType = GlobalTables::GetTypeTable().GetUInt64();
+  if ((bitOffset / INT_WIDTH) == ((bitOffset + extractSize) / INT_WIDTH)) {
+    byteOffset = (bitOffset / INT_WIDTH) * INT_WIDTH / CHAR_WIDTH;  // expand the read length to 32 bit
+    readType = GlobalTables::GetTypeTable().GetUInt32();
+  }
+  bfe.byteOffset = byteOffset;
+  bfe.extractStart = bitOffset - byteOffset * CHAR_WIDTH;
+  bfe.extractSize = extractSize;
+  bfe.extractType = readType;
+  return true;
+}
+
+// Bitfield can not write directly, when write 2 bitfields that belong to the same 4-bytes memory,
+// we can expose the 4-bytes memory's read & write to remove partial/fully redundant. This function
+// lowers bitfield write to `4-bytes memory's read + bits insert + 4-bytes memory write`.
+StmtNode *Simplify::SimplifyBitFieldWrite(const IassignNode &iass) {
+  if (iass.GetFieldID() == 0) {
+    return nullptr;
+  }
+  auto *type = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iass.GetTyIdx()));
+  BitFieldExtract bfe;
+  if (!ExtractBitField(*type, iass.GetFieldID(), bfe)) {
+    return nullptr;
+  }
+  CHECK_NULL_FATAL(bfe.extractType);
+  auto *newIvarType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*bfe.extractType);
+  auto *base = iass.Opnd(0);
+  MIRBuilder *mirBuiler = currFunc->GetModule()->GetMIRBuilder();
+  if (bfe.byteOffset != 0) {
+    base = mirBuiler->CreateExprBinary(OP_add, PTY_a64, base,
+        mirBuiler->CreateIntConst(static_cast<uint64>(bfe.byteOffset), PTY_a64));
+  }
+  auto *readIvar = mirBuiler->CreateExprIread(*bfe.extractType, *newIvarType, 0, base);
+
+  if (MeOption::IsBigEndian()) {
+    auto extractSize = GetPrimTypeBitSize(bfe.extractType->GetPrimType());
+    ASSERT(bfe.extractStart + bfe.extractSize <= extractSize, "bit offset is out-of-range");
+    bfe.extractStart = extractSize - (bfe.extractStart + bfe.extractSize);
+  }
+
+  auto *deposit = mirBuiler->CreateExprDepositbits(OP_depositbits, bfe.extractType->GetPrimType(),
+      static_cast<uint32>(bfe.extractStart), static_cast<uint32>(bfe.extractSize), readIvar, iass.GetRHS());
+  auto *newIass = mirBuiler->CreateStmtIassign(*newIvarType, 0, base, deposit);
+  currBlock->ReplaceStmt1WithStmt2(&iass, newIass);
+  return newIass;
+}
+
+void Simplify::ProcessStmt(StmtNode &stmt) {
+  switch (stmt.GetOpCode()) {
+    case OP_callassigned: {
+      SimplifyCallAssigned(stmt, *currBlock);
+      break;
+    }
+    case OP_intrinsiccall: {
+      simplifyMemOp.SetDebug(dump);
+      simplifyMemOp.SetFunction(currFunc);
+      (void)simplifyMemOp.AutoSimplify(stmt, *currBlock, false);
+      break;
+    }
+    case OP_dassign: {
+      auto *newStmt = SplitDassignAggCopy(static_cast<DassignNode *>(&stmt), currBlock, currFunc);
+      if (newStmt) {
+        ProcessBlock(*newStmt);
+      }
+      break;
+    }
+    case OP_iassign: {
+      auto *newStmt = SimplifyBitFieldWrite(static_cast<IassignNode&>(stmt));
+      if (newStmt) {
+        break;
+      }
+      newStmt = SplitIassignAggCopy(static_cast<IassignNode *>(&stmt), currBlock, currFunc);
+      if (newStmt) {
+        ProcessBlock(*newStmt);
+      }
+      break;
+    }
+    case OP_if:
+    case OP_while:
+    case OP_dowhile: {
+      auto unaryStmt = static_cast<UnaryStmtNode&>(stmt);
+      unaryStmt.SetRHS(SimplifyExpr(*unaryStmt.GetRHS()));
+      return;
+    }
+    default: {
+      break;
+    }
+  }
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+    if (stmt.Opnd(i)) {
+      stmt.SetOpnd(SimplifyExpr(*stmt.Opnd(i)), i);
+    }
+  }
+}
+
+BaseNode *Simplify::SimplifyExpr(BaseNode &expr) {
+  switch (expr.GetOpCode()) {
+    case OP_dread: {
+      auto &dread = static_cast<DreadNode&>(expr);
+      return ReplaceExprWithConst(dread);
+    }
+    case OP_iread: {
+      return SimplifyBitFieldRead(static_cast<IreadNode&>(expr));
+    }
+    default: {
+      for (auto i = 0; i < expr.GetNumOpnds(); i++) {
+        if (expr.Opnd(i)) {
+          expr.SetOpnd(SimplifyExpr(*expr.Opnd(i)), i);
+        }
+      }
+      break;
+    }
+  }
+  return &expr;
+}
+
+// Bitfield can not read directly, when read 2 bitfields that belong to the same 4-bytes memory,
+// we can expose the 4-bytes memory's read to remove partial/fully redundant. This function lowers
+// bitfield read to `4-bytes memory's read + bits extract.
+BaseNode *Simplify::SimplifyBitFieldRead(IreadNode &iread) {
+  if (iread.GetFieldID() == 0) {
+    return &iread;
+  }
+  auto *type = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iread.GetTyIdx()));
+  BitFieldExtract bfe;
+  if (!ExtractBitField(*type, iread.GetFieldID(), bfe)) {
+    return &iread;
+  }
+  CHECK_NULL_FATAL(bfe.extractType);
+  auto *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(type->GetPointedTyIdxWithFieldID(iread.GetFieldID()));
+  auto extractPtyp = IsSignedInteger(fieldType->GetPrimType()) ?
+      GetSignedPrimType(bfe.extractType->GetPrimType()) : bfe.extractType->GetPrimType();
+  auto *newIvarType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*bfe.extractType);
+  auto *base = iread.Opnd(0);
+  MIRBuilder *mirBuiler = currFunc->GetModule()->GetMIRBuilder();
+  if (bfe.byteOffset != 0) {
+    base = mirBuiler->CreateExprBinary(OP_add, PTY_a64, base,
+        mirBuiler->CreateIntConst(static_cast<uint64>(bfe.byteOffset), PTY_a64));
+  }
+  auto *readIvar = mirBuiler->CreateExprIread(*bfe.extractType, *newIvarType, 0, base);
+
+  if (MeOption::IsBigEndian()) {
+    ASSERT(bfe.extractStart + bfe.extractSize <= GetPrimTypeBitSize(extractPtyp), "bit offset is out-of-range");
+    bfe.extractStart = GetPrimTypeBitSize(extractPtyp) - (bfe.extractStart + bfe.extractSize);
+  }
+
+  auto *extract = mirBuiler->CreateExprExtractbits(OP_extractbits, extractPtyp, static_cast<uint32>(bfe.extractStart),
+                                                   static_cast<uint32>(bfe.extractSize), readIvar);
+  if (extractPtyp != iread.GetPrimType()) {
+    return mirBuiler->CreateExprTypeCvt(OP_cvt, iread.GetPrimType(), extractPtyp, *extract);
+  }
+  return extract;
+}
+
+BaseNode *Simplify::ReplaceExprWithConst(DreadNode &dread) {
+  auto stIdx = dread.GetStIdx();
+  auto fieldId = dread.GetFieldID();
+  auto *symbol = currFunc->GetLocalOrGlobalSymbol(stIdx);
+  ASSERT_NOT_NULL(symbol);
+  auto *symbolConst = symbol->GetKonst();
+  if (!currFunc->GetModule()->IsCModule() || !symbolConst ||
+      !stIdx.IsGlobal() || !IsSymbolReplaceableWithConst(*symbol)) {
+    return &dread;
+  }
+  if (fieldId != 0) {
+    symbolConst = GetElementConstFromFieldId(fieldId, symbolConst);
+  }
+  if (!symbolConst || !IsConstRepalceable(*symbolConst)) {
+    return &dread;
+  }
+  return currFunc->GetModule()->GetMIRBuilder()->CreateConstval(symbolConst);
+}
+
+bool Simplify::IsSymbolReplaceableWithConst(const MIRSymbol &symbol) const {
+  return (symbol.GetStorageClass() == kScFstatic && !symbol.HasPotentialAssignment()) ||
+      symbol.GetAttrs().GetAttr(ATTR_const);
+}
+
+bool Simplify::IsConstRepalceable(const MIRConst &mirConst) const {
+  switch (mirConst.GetKind()) {
+    case kConstInt:
+    case kConstFloatConst:
+    case kConstDoubleConst:
+    case kConstFloat128Const:
+    case kConstLblConst:
+      return true;
+    default:
+      return false;
+  }
+}
+
+MIRConst *Simplify::GetElementConstFromFieldId(FieldID fieldId, MIRConst *mirConst) {
+  FieldID currFieldId = 1;
+  MIRConst *resultConst = nullptr;
+  auto originAggConst = static_cast<MIRAggConst *>(mirConst);
+  auto originAggType = static_cast<MIRStructType &>(originAggConst->GetType());
+  bool reached = false;
+  bool isUpperLayerUnion = false;
+  std::function<void(MIRConst *)> traverseAgg = [&] (MIRConst *currConst) {
+    if (isUpperLayerUnion && (!currConst || currConst->GetKind() != kConstAggConst)) {
+      reached = currFieldId == fieldId;
+      resultConst = reached ? currConst : resultConst;
+      return;
+    }
+    auto *currAggConst = safe_cast<MIRAggConst>(currConst);
+    ASSERT_NOT_NULL(currAggConst);
+    auto *currAggType = safe_cast<MIRStructType>(currAggConst->GetType());
+    ASSERT_NOT_NULL(currAggType);
+    for (size_t iter = 0; iter < currAggType->GetFieldsSize() && !reached; ++iter) {
+      size_t constIdx = currAggType->GetKind() == kTypeUnion ? 1 : iter + 1;
+      auto *fieldConst = currAggConst->GetAggConstElement(constIdx);
+      auto *fieldType = originAggType.GetFieldType(currFieldId);
+
+      if (currFieldId == fieldId) {
+        if (auto *truncCst = TruncateUnionConstant(*currAggType, fieldConst, *fieldType)) {
+          resultConst = truncCst;
+        } else {
+          resultConst = TruncateUnionConstant(*currAggType, fieldConst, *fieldType);
+        }
+        reached = true;
+        return;
+      }
+
+      ++currFieldId;
+      if (fieldType->GetKind() == kTypeUnion || fieldType->GetKind() == kTypeStruct) {
+        bool isPrevUpperLayerUnion = isUpperLayerUnion;
+        isUpperLayerUnion = currAggType->GetKind() == kTypeUnion;
+        traverseAgg(fieldConst);
+        isUpperLayerUnion = isPrevUpperLayerUnion;
+      }
+    }
+  };
+  traverseAgg(mirConst);
+  if (!reached) {
+    auto fieldPrimType = originAggType.GetFieldType(fieldId)->GetPrimType();
+    auto resultPrimType = IsPrimitiveInteger(fieldPrimType) ? fieldPrimType :
+        GetPrimTypeBitSize(fieldPrimType) > k32BitSize ? PTY_u64 : PTY_u32;
+    auto *resultType = GlobalTables::GetTypeTable().GetPrimType(resultPrimType);
+    resultConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *resultType);
+  }
+  return resultConst;
+}
+
+void Simplify::Finish() {
+}
+
+// Join `num` `byte`s into a number
+// Example:
+//   byte   num                output
+//   0x0a    2                 0x0a0a
+//   0x12    4             0x12121212
+//   0xff    8     0xffffffffffffffff
+static uint64 JoinBytes(int byte, uint32 num) {
+  CHECK_FATAL(num <= 8, "not support");
+  uint64 realByte = static_cast<uint64>(byte % 256);
+  if (realByte == 0) {
+    return 0;
+  }
+  uint64 result = 0;
+  for (uint32 i = 0; i < num; ++i) {
+    result += (realByte << (i * 8));
+  }
+  return result;
+}
+
+// Return Fold result expr, does not always return a constant expr
+// Attention: Fold may modify the input expr, if foldExpr is not a nullptr, we should always replace expr with foldExpr
+static BaseNode *FoldIntConst(BaseNode *expr, uint64 &out, bool &isIntConst) {
+  if (expr->GetOpCode() == OP_constval) {
+    MIRConst *mirConst = static_cast<ConstvalNode*>(expr)->GetConstVal();
+    if (mirConst->GetKind() == kConstInt) {
+      out = static_cast<MIRIntConst*>(mirConst)->GetExtValue();
+      isIntConst = true;
+    }
+    return nullptr;
+  }
+  BaseNode *foldExpr = nullptr;
+  static ConstantFold cf(*theMIRModule);
+  foldExpr = cf.Fold(expr);
+  if (foldExpr != nullptr && foldExpr->GetOpCode() == OP_constval) {
+    MIRConst *mirConst = static_cast<ConstvalNode*>(foldExpr)->GetConstVal();
+    if (mirConst->GetKind() == kConstInt) {
+      out = static_cast<MIRIntConst*>(mirConst)->GetExtValue();
+      isIntConst = true;
+    }
+  }
+  return foldExpr;
+}
+
+static BaseNode *ConstructConstvalNode(uint64 val, PrimType primType, MIRBuilder &mirBuilder) {
+  PrimType constPrimType = primType;
+  if (IsPrimitiveFloat(primType)) {
+    constPrimType = GetIntegerPrimTypeBySizeAndSign(GetPrimTypeBitSize(primType), false);
+  }
+  MIRType *constType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(constPrimType));
+  MIRConst *mirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(val, *constType);
+  BaseNode *ret = mirBuilder.CreateConstval(mirConst);
+  if (IsPrimitiveFloat(primType)) {
+    MIRType *floatType =  GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(primType));
+    ret = mirBuilder.CreateExprRetype(*floatType, constPrimType, ret);
+  }
+  return ret;
+}
+
+static BaseNode *ConstructConstvalNode(int64 byte, uint64 num, PrimType primType, MIRBuilder &mirBuilder) {
+  auto val = JoinBytes(byte, static_cast<uint32>(num));
+  return ConstructConstvalNode(val, primType, mirBuilder);
+}
+
+// Input total size of memory, split the memory into several blocks, the max block size is 8 bytes
+// Example:
+//   input        output
+//     40     [ 8, 8, 8, 8, 8 ]
+//     31     [ 8, 8, 8, 4, 2, 1 ]
+static void SplitMemoryIntoBlocks(size_t totalMemorySize, std::vector<uint32> &blocks) {
+  size_t leftSize = totalMemorySize;
+  size_t curBlockSize = kMaxMemoryBlockSizeToAssign;  // max block size in byte
+  while (curBlockSize > 0) {
+    size_t n = leftSize / curBlockSize;
+    blocks.insert(blocks.cend(), n, curBlockSize);
+    leftSize -= (n * curBlockSize);
+    curBlockSize = curBlockSize >> 1;
+  }
+}
+
+static bool IsComplexExpr(const BaseNode *expr, MIRFunction &func) {
+  Opcode op = expr->GetOpCode();
+  if (op == OP_regread) {
+    return false;
+  }
+  if (op == OP_dread) {
+    auto *symbol = func.GetLocalOrGlobalSymbol(static_cast<const DreadNode*>(expr)->GetStIdx());
+    ASSERT_NOT_NULL(symbol);
+    if (symbol->IsGlobal() || symbol->GetStorageClass() == kScPstatic) {
+      return true;  // dread global/static var is complex expr because it will be lowered to adrp + add
+    } else {
+      return false;
+    }
+  }
+  if (op == OP_addrof) {
+    auto *symbol = func.GetLocalOrGlobalSymbol(static_cast<const AddrofNode*>(expr)->GetStIdx());
+    ASSERT_NOT_NULL(symbol);
+    if (symbol->IsGlobal() || symbol->GetStorageClass() == kScPstatic) {
+      return true;  // addrof global/static var is complex expr because it will be lowered to adrp + add
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+// if addr is never nullptr
+static bool IsAddrSafe(const BaseNode &expr) {
+  if (expr.GetOpCode() == OP_addrof) {
+    return true;
+  }
+  if (expr.GetOpCode() == OP_iaddrof) {
+    auto iaddrExpr = static_cast<const IaddrofNode &>(expr);
+    auto type = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iaddrExpr.GetTyIdx()))
+                    ->GetPointedType();
+    if (type->IsMIRStructType()) {
+      return static_cast<MIRStructType *>(type)->GetBitOffsetFromBaseAddr(iaddrExpr.GetFieldID()) != 0;
+    }
+  }
+  return false;
+}
+
+// Input a address expr, output a memEntry to abstract this expr
+bool MemEntry::ComputeMemEntry(BaseNode &expr, MIRFunction &func, MemEntry &memEntry, bool isLowLevel) {
+  Opcode op = expr.GetOpCode();
+  MIRType *mirType = nullptr;
+  switch (op) {
+    case OP_dread: {
+      const auto &concreteExpr = static_cast<const DreadNode&>(expr);
+      auto *symbol = func.GetLocalOrGlobalSymbol(concreteExpr.GetStIdx());
+      MIRType *curType = symbol->GetType();
+      if (concreteExpr.GetFieldID() != 0) {
+        curType = static_cast<MIRStructType*>(curType)->GetFieldType(concreteExpr.GetFieldID());
+      }
+      // Support kTypeScalar ptr if possible
+      if (curType->GetKind() == kTypePointer) {
+        mirType = static_cast<MIRPtrType*>(curType)->GetPointedType();
+      }
+      break;
+    }
+    case OP_addrof: {
+      const auto &concreteExpr = static_cast<const AddrofNode&>(expr);
+      auto *symbol = func.GetLocalOrGlobalSymbol(concreteExpr.GetStIdx());
+      MIRType *curType = symbol->GetType();
+      if (concreteExpr.GetFieldID() != 0) {
+        ASSERT_NOT_NULL(curType);
+        curType = static_cast<MIRStructType*>(curType)->GetFieldType(concreteExpr.GetFieldID());
+      }
+      mirType = curType;
+      break;
+    }
+    case OP_iread: {
+      const auto &concreteExpr = static_cast<const IreadNode&>(expr);
+      mirType = concreteExpr.GetType();
+      break;
+    }
+    case OP_iaddrof: {  // Do NOT call GetType because it is for OP_iread
+      const auto &concreteExpr = static_cast<const IaddrofNode&>(expr);
+      MIRType *curType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(concreteExpr.GetTyIdx());
+      CHECK_FATAL(curType->IsMIRPtrType(), "must be MIRPtrType");
+      curType = static_cast<MIRPtrType*>(curType)->GetPointedType();
+      CHECK_FATAL(curType->IsStructType(), "must be MIRStructType");
+      mirType = static_cast<MIRStructType*>(curType)->GetFieldType(concreteExpr.GetFieldID());
+      break;
+    }
+    case OP_regread: {
+      if (isLowLevel && IsPrimitivePoint(expr.GetPrimType())) {
+        memEntry.addrExpr = &expr;
+        memEntry.memType = nullptr;  // we cannot infer high level memory type, this is allowed for low level expand
+        return true;
+      }
+      const auto &concreteExpr = static_cast<const RegreadNode&>(expr);
+      MIRPreg *preg = func.GetPregItem(concreteExpr.GetRegIdx());
+      bool isFromDread = (preg->GetOp() == OP_dread);
+      bool isFromAddrof = (preg->GetOp() == OP_addrof);
+      if (isFromDread || isFromAddrof) {
+        auto *symbol = preg->rematInfo.sym;
+        auto fieldId = preg->fieldID;
+        MIRType *curType = symbol->GetType();
+        if (fieldId != 0) {
+          curType = static_cast<MIRStructType*>(symbol->GetType())->GetFieldType(fieldId);
+        }
+        if (isFromDread && curType->GetKind() == kTypePointer) {
+          curType = static_cast<MIRPtrType*>(curType)->GetPointedType();
+        }
+        mirType = curType;
+      }
+      break;
+    }
+    default: {
+      if (isLowLevel && IsPrimitivePoint(expr.GetPrimType())) {
+        memEntry.addrExpr = &expr;
+        memEntry.memType = nullptr;  // we cannot infer high level memory type, this is allowed for low level expand
+        return true;
+      }
+      break;
+    }
+  }
+  if (mirType == nullptr) {
+    return false;
+  }
+  memEntry.addrExpr = &expr;
+  memEntry.memType = mirType;
+  return true;
+}
+
+BaseNode *MemEntry::BuildAsRhsExpr(MIRFunction &func, MIRType *accessType) const {
+  BaseNode *expr = nullptr;
+  MIRBuilder *mirBuilder = func.GetModule()->GetMIRBuilder();
+  if (addrExpr->GetOpCode() == OP_addrof) {
+    // We prefer dread to iread
+    // consider iaddrof if possible
+    auto *addrof = static_cast<AddrofNode*>(addrExpr);
+    auto *symbol = func.GetLocalOrGlobalSymbol(addrof->GetStIdx());
+    expr = mirBuilder->CreateExprDread(*memType, addrof->GetFieldID(), *symbol);
+  } else {
+    if (accessType == nullptr) {
+      accessType = memType;
+    }
+    MIRType *structPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*accessType);
+    expr = mirBuilder->CreateExprIread(*accessType, *structPtrType, 0, addrExpr);
+  }
+  return expr;
+}
+
+static void InsertBeforeAndMayPrintStmt(BlockNode &block, const StmtNode &anchor, bool debug, StmtNode *stmt) {
+  if (stmt == nullptr) {
+    return;
+  }
+  block.InsertBefore(&anchor, stmt);
+  if (debug) {
+    stmt->Dump(0);
+  }
+}
+
+static void InsertBeforeAndMayPrintStmtList(BlockNode &block, const StmtNode &anchor,
+                                      bool debug, std::initializer_list<StmtNode*> stmtList) {
+  for (StmtNode *stmt : stmtList) {
+    if (stmt == nullptr) {
+      continue;
+    }
+    block.InsertBefore(&anchor, stmt);
+    if (debug) {
+      stmt->Dump(0);
+    }
+  }
+}
+
+class BlockOperationHelper {
+ public:
+  BlockOperationHelper(StmtNode &stmtNode, MIRFunction &mirFunc, BlockNode &blockNode, bool lowLevel, bool isDebug)
+      : stmt(stmtNode),
+        func(mirFunc),
+        block(blockNode),
+        mirBuilder(func.GetModule()->GetMIRBuilder()),
+        isLowLevel(lowLevel),
+        debug(isDebug) {}
+
+  void InsertLableNode(LabelIdx labIdx) {
+    auto *labelNode = mirBuilder->CreateStmtLabel(labIdx);
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, labelNode);
+  }
+
+  // dassign %ret (constval i32 errNumber)
+  // goto @labIdx
+  void InsertRetAssignAndGoto(LabelIdx labIdx, OpKind memOpKind, ErrorNumber errNumber) {
+    auto retAssign = MemEntry::GenRetAssign(stmt, func, isLowLevel, memOpKind, errNumber);
+    auto *gotoLabel = mirBuilder->CreateStmtGoto(OP_goto, labIdx);
+    InsertBeforeAndMayPrintStmtList(block, stmt, debug, {retAssign, gotoLabel});
+  }
+
+  // memset of the addrExpr with c
+  StmtNode *InsertMemsetCallStmt(BaseNode *addrExpr, BaseNode *c) {
+    MapleVector<BaseNode *> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+    args.push_back(addrExpr);
+    args.push_back(c);
+    args.push_back(stmt.Opnd(kMemOpSDstSizeOpndIdx));
+    auto memsetFunc = mirBuilder->GetOrCreateFunction(kFuncNameOfMemset, TyIdx(PTY_void));
+    auto *callMemset = mirBuilder->CreateStmtCallAssigned(memsetFunc->GetPuidx(), args, nullptr, OP_callassigned);
+    callMemset->SetSrcPos(stmt.GetSrcPos());
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, callMemset);
+    return callMemset;
+  }
+
+  // brtrue @label (op lhs rhs)
+  void CreateAndInsertCheckStmt(Opcode op, BaseNode *lhs, BaseNode *rhs, LabelIdx label) {
+    auto cmpResType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_u8));
+    auto cmpU64Type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_u64));
+    auto cmpStmt = mirBuilder->CreateExprCompare(op, *cmpResType, *cmpU64Type, lhs, rhs);
+    auto checkStmt = mirBuilder->CreateStmtCondGoto(cmpStmt, OP_brtrue, label);
+    checkStmt->SetBranchProb(kProbUnlikely);
+    checkStmt->SetSrcPos(stmt.GetSrcPos());
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, checkStmt);
+  }
+
+  // @label
+  // dassign %ret (constval i32 errnNumber)
+  // goto @finalLab
+  void HandleError(LabelIdx branchLabIdx, LabelIdx finalLabIdx, ErrorNumber errNumber, OpKind memOpKind) {
+    InsertLableNode(branchLabIdx);
+    InsertRetAssignAndGoto(finalLabIdx, memOpKind, errNumber);
+  }
+
+  // @curLab
+  // brture @condLab (eq (dread dstSizeOpnd, constval u64 0))
+  // dassign %ret (constval i32 errnNumber)
+  // goto @finalLab
+  void HandleErrorWithDstSizeCheck(LabelIdx curLabIdx, LabelIdx condLabIdx, LabelIdx finalLabIdx, OpKind memOpKind,
+                                   ErrorNumber errNumer, bool isDstSizeConst, int64 dstSize) {
+    InsertLableNode(curLabIdx);
+    if (!isDstSizeConst) {
+      CreateAndInsertCheckStmt(OP_eq, stmt.Opnd(kMemOpSDstSizeOpndIdx), ConstructConstvalNode(0, PTY_u64, *mirBuilder),
+                               condLabIdx);
+    } else if (dstSize == 0) {
+      InsertRetAssignAndGoto(finalLabIdx, memOpKind, ERRNO_RANGE);
+    }
+    InsertRetAssignAndGoto(finalLabIdx, memOpKind, errNumer);
+  }
+
+  // @label
+  // brture @condLab (eq (dstSizeOpnd, constval u64 0))
+  // call &memset()
+  // dassign %ret (constval i32 errnNumber)
+  // goto @finalLab
+  void HandleErrorWithDstSizeCheckAndReset(LabelIdx curLabIdx, LabelIdx condLabIdx, LabelIdx finalLabIdx,
+                                           OpKind memOpKind, ErrorNumber errNumer, bool isDstSizeConst, int64 dstSize) {
+    InsertLableNode(curLabIdx);
+    if (!isDstSizeConst) {
+      CreateAndInsertCheckStmt(OP_eq, stmt.Opnd(kMemOpSDstSizeOpndIdx), ConstructConstvalNode(0, PTY_u64, *mirBuilder),
+                               condLabIdx);
+    } else if (dstSize == 0) {
+      InsertRetAssignAndGoto(finalLabIdx, memOpKind, ERRNO_RANGE);
+    }
+    (void)InsertMemsetCallStmt(stmt.Opnd(kMemOpDstOpndIdx), stmt.Opnd(kMemOpSSrcOpndIdx));
+    InsertRetAssignAndGoto(finalLabIdx, memOpKind, errNumer);
+  }
+
+  // @label
+  // call &memset()
+  // dassign %ret (constval i32 errnNumber)
+  // goto @finalLab
+  void HandleErrorAndReset(LabelIdx curLabIdx, LabelIdx finalLabIdx, OpKind memOpKind, ErrorNumber errNumer) {
+    InsertLableNode(curLabIdx);
+    (void)InsertMemsetCallStmt(stmt.Opnd(kMemOpDstOpndIdx), ConstructConstvalNode(0, PTY_i32, *mirBuilder));
+    InsertRetAssignAndGoto(finalLabIdx, memOpKind, errNumer);
+  }
+
+ private:
+  StmtNode &stmt;
+  MIRFunction &func;
+  BlockNode &block;
+  MIRBuilder *mirBuilder;
+  bool isLowLevel;
+  bool debug;
+};
+
+// Create maple IR to check whether `expr1` and `expr2` are overlapped
+// brfalse @@o1 (ge u8 ptr (
+//   abs ptr (sub ptr (regread ptr %1, regread ptr %2)),
+//   constval u64 xxx))
+static CondGotoNode *CreateOverlapCheckStmt(BaseNode &expr1, BaseNode &expr2, BaseNode &size, LabelIdx labIdx,
+    MIRBuilder *mirBuilder) {
+  auto cmpResType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_u8));
+  auto cmpU64Type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_ptr));
+  auto cmpI64Type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_i64));
+  auto *checkExpr = mirBuilder->CreateExprCompare(OP_ge, *cmpResType, *cmpU64Type,
+      mirBuilder->CreateExprUnary(OP_abs, *cmpU64Type,
+          mirBuilder->CreateExprBinary(OP_sub, *cmpI64Type, &expr1, &expr2)),
+      &size);
+  auto *checkStmt = mirBuilder->CreateStmtCondGoto(checkExpr, OP_brfalse, labIdx);
+  return checkStmt;
+}
+
+static BaseNode *TryToExtractComplexExpr(BaseNode *expr, MIRFunction &func, BlockNode &block,
+                                         const StmtNode &anchor, bool debug) {
+  if (!IsComplexExpr(expr, func)) {
+    return expr;
+  }
+  MIRBuilder *mirBuilder = func.GetModule()->GetMIRBuilder();
+  auto pregIdx = func.GetPregTab()->CreatePreg(PTY_ptr);
+  StmtNode *regassign = mirBuilder->CreateStmtRegassign(PTY_ptr, pregIdx, expr);
+  InsertBeforeAndMayPrintStmt(block, anchor, debug, regassign);
+  auto *extractedExpr = mirBuilder->CreateExprRegread(PTY_ptr, pregIdx);
+  return extractedExpr;
+}
+
+static BaseNode *TryExtractExpr(BaseNode &expr, MIRFunction &func, BlockNode &block, const StmtNode &anchor, bool isSrc,
+                                bool debug) {
+  static int extractIdx = 0;
+  if (IsComplexExpr(&expr, func)) {
+    auto mirBuilder = func.GetModule()->GetMIRBuilder();
+    MemEntry dstMemEntry;
+    bool valid = MemEntry::ComputeMemEntry(expr, func, dstMemEntry, false);
+    if (!valid) {
+      return nullptr;
+    }
+    // if src expr is array type, do not extract it to avoid redundant inst
+    if (isSrc && dstMemEntry.memType->IsMIRArrayType()) {
+      return nullptr;
+    }
+    std::string tempAddrName(kUnderlineStr);
+    (void)tempAddrName.append(std::to_string(func.GetPuidx()))
+        .append(kUnderlineStr)
+        .append(std::to_string(anchor.GetStmtID()))
+        .append(kVerticalLineStr)
+        .append(kTempAddrStr)
+        .append(kUnderlineStr)
+        .append(std::to_string(extractIdx++));
+    if (GlobalTables::GetStrTable().GetStrIdxFromName(tempAddrName) != 0) {
+      return nullptr;
+    }
+    MIRPtrType ty(dstMemEntry.memType->GetTypeIndex());
+    auto tIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ty);
+    auto symb = mirBuilder->CreateSymbol(tIdx, tempAddrName, kStVar, kScAuto, &func, kScopeLocal);
+    symb->SetIsTmp(true);
+    auto dAssignStmt = mirBuilder->CreateStmtDassign(symb->GetStIdx(), 0, &expr);
+    InsertBeforeAndMayPrintStmt(block, anchor, debug, dAssignStmt);
+    return mirBuilder->CreateExprDread(*symb);
+  }
+  return nullptr;
+}
+
+void MemEntry::ExpandMemsetLowLevel(int64 byte, uint64 size, MIRFunction &func, StmtNode &stmt, BlockNode &block,
+                                    OpKind memOpKind, bool debug, ErrorNumber errorNumber) const {
+  MIRBuilder *mirBuilder = func.GetModule()->GetMIRBuilder();
+  std::vector<uint32> blocks;
+  SplitMemoryIntoBlocks(size, blocks);
+  int32 offset = 0;
+  // If blocks.size() > 1 and `dst` is not a leaf node,
+  // we should extract common expr to avoid redundant expression
+  BaseNode *realDstExpr = addrExpr;
+  if (blocks.size() > 1) {
+    realDstExpr = TryToExtractComplexExpr(addrExpr, func, block, stmt, debug);
+  }
+  BaseNode *readConst = nullptr;
+  // rhs const is big, extract it to avoid redundant expression
+  bool shouldExtractRhs = blocks.size() > 1 && (byte & 0xff) != 0;
+  for (auto curSize : blocks) {
+    // low level memset expand result:
+    //   iassignoff <prim-type> <offset> (dstAddrExpr, constval <prim-type> xx)
+    PrimType constType = GetIntegerPrimTypeBySizeAndSign(curSize * 8, false);
+    BaseNode *rhsExpr = ConstructConstvalNode(byte, curSize, constType, *mirBuilder);
+    if (shouldExtractRhs) {
+      // we only need to extract u64 const once
+      PregIdx pregIdx = func.GetPregTab()->CreatePreg(constType);
+      auto *constAssign = mirBuilder->CreateStmtRegassign(constType, pregIdx, rhsExpr);
+      InsertBeforeAndMayPrintStmt(block, stmt, debug, constAssign);
+      readConst = mirBuilder->CreateExprRegread(constType, pregIdx);
+      shouldExtractRhs = false;
+    }
+    if (readConst != nullptr && curSize == kMaxMemoryBlockSizeToAssign) {
+      rhsExpr = readConst;
+    }
+    auto *iassignoff = mirBuilder->CreateStmtIassignoff(constType, offset, realDstExpr, rhsExpr);
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, iassignoff);
+    if (debug) {
+      iassignoff->Dump(0);
+    }
+    offset += static_cast<int32>(curSize);
+  }
+  // handle memset return val
+  auto *retAssign = GenRetAssign(stmt, func, true, memOpKind, errorNumber);
+  InsertBeforeAndMayPrintStmt(block, stmt, debug, retAssign);
+  // return ERRNO_INVAL if memset_s dest is NULL
+  block.RemoveStmt(&stmt);
+}
+
+// Lower memset(MemEntry, byte, size) into a series of assign stmts and replace callStmt in the block
+// with these assign stmts
+bool MemEntry::ExpandMemset(int64 byte, uint64 size, MIRFunction &func,
+                            StmtNode &stmt, BlockNode &block, bool isLowLevel, bool debug,
+                            ErrorNumber errorNumber) const {
+  OpKind memOpKind = SimplifyOp::ComputeOpKind(stmt) ;
+  MemEntryKind memKind = GetKind();
+  // we don't check size equality in the low level expand
+  if (!isLowLevel) {
+    if (memKind == kMemEntryUnknown) {
+      MayPrintLog(debug, false, memOpKind, "unsupported dst memory type, is it a bitfield?");
+      return false;
+    }
+    if (memType->GetSize() != size) {
+      MayPrintLog(debug, false, memOpKind, "dst size and size arg are not equal");
+      return false;
+    }
+  }
+  MIRBuilder *mirBuilder = func.GetModule()->GetMIRBuilder();
+
+  if (isLowLevel) {  // For cglower, replace memset with a series of low-level iassignoff
+    ExpandMemsetLowLevel(byte, size, func, stmt, block, memOpKind, debug, errorNumber);
+    return true;
+  }
+
+  if (memKind == kMemEntryPrimitive) {
+    BaseNode *rhsExpr = ConstructConstvalNode(byte, size, memType->GetPrimType(), *mirBuilder);
+    StmtNode *newAssign = nullptr;
+    if (addrExpr->GetOpCode() == OP_addrof) {  // We prefer dassign to iassign
+      auto *addrof = static_cast<AddrofNode*>(addrExpr);
+      auto *symbol = func.GetLocalOrGlobalSymbol(addrof->GetStIdx());
+      newAssign = mirBuilder->CreateStmtDassign(*symbol, addrof->GetFieldID(), rhsExpr);
+    } else {
+      MIRType *memPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*memType);
+      newAssign = mirBuilder->CreateStmtIassign(*memPtrType, 0, addrExpr, rhsExpr);
+      static_cast<IassignNode *>(newAssign)->SetExpandFromArrayOfCharFunc(true);
+    }
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, newAssign);
+  } else if (memKind == kMemEntryStruct) {
+    auto *structType = static_cast<MIRStructType*>(memType);
+    // struct size should be small enough, struct field size should be big enough
+    constexpr uint32 maxStructSize = 64;  // in byte
+    constexpr uint32 minFieldSize = 4;    // in byte
+    size_t structSize = structType->GetSize();
+    size_t numFields = structType->NumberOfFieldIDs();
+    // Relax restrictions when store-merge is powerful enough
+    bool expandIt = (structSize <= maxStructSize && (structSize / numFields >= minFieldSize) &&
+                     !structType->HasPadding());
+    if (!expandIt) {
+      // We only expand memset for no-padding struct, because only in this case, element-wise and byte-wise
+      // are equivalent
+      MayPrintLog(debug, false, memOpKind,
+                  "struct type has padding, or struct sum size is too big, or filed size is too small");
+      return false;
+    }
+    bool hasArrayField = false;
+    for (uint32 id = 1; id <= numFields; ++id) {
+      auto *fieldType = structType->GetFieldType(id);
+      if (fieldType->GetKind() == kTypeArray) {
+        hasArrayField = true;
+        break;
+      }
+    }
+    if (hasArrayField) {
+      // struct with array fields is not supported to expand for now, enhance it when needed
+      MayPrintLog(debug, false, memOpKind, "struct with array fields is not supported to expand");
+      return false;
+    }
+
+    // Build assign for each fields in the struct type
+    // We should skip union fields
+    for (FieldID id = 1; static_cast<size_t>(id) <= numFields; ++id) {
+      MIRType *fieldType = structType->GetFieldType(id);
+      // We only consider leaf field with valid type size
+      if (fieldType->GetSize() == 0 || fieldType->GetPrimType() == PTY_agg) {
+        continue;
+      }
+      if (fieldType->GetKind() == kTypeBitField && static_cast<MIRBitFieldType*>(fieldType)->GetFieldSize() == 0) {
+        continue;
+      }
+      // now the fieldType is primitive type
+      BaseNode *rhsExpr = ConstructConstvalNode(byte, fieldType->GetSize(),
+                                                fieldType->GetPrimType(), *mirBuilder);
+      StmtNode *fieldAssign = nullptr;
+      if (addrExpr->GetOpCode() == OP_addrof) {
+        auto *addrof = static_cast<AddrofNode*>(addrExpr);
+        auto *symbol = func.GetLocalOrGlobalSymbol(addrof->GetStIdx());
+        fieldAssign = mirBuilder->CreateStmtDassign(*symbol, addrof->GetFieldID() + id, rhsExpr);
+      } else {
+        MIRType *memPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*memType);
+        fieldAssign = mirBuilder->CreateStmtIassign(*memPtrType, id, addrExpr, rhsExpr);
+        static_cast<IassignNode *>(fieldAssign)->SetExpandFromArrayOfCharFunc(true);
+      }
+      InsertBeforeAndMayPrintStmt(block, stmt, debug, fieldAssign);
+    }
+  } else if (memKind == kMemEntryArray) {
+    // We only consider array with dim == 1 now, and element type must be primitive type
+    auto *arrayType = static_cast<MIRArrayType*>(memType);
+    if (arrayType->GetDim() != 1 || (arrayType->GetElemType()->GetKind() != kTypeScalar &&
+        arrayType->GetElemType()->GetKind() != kTypePointer)) {
+      MayPrintLog(debug, false, memOpKind, "array dim != 1 or array elements are not primtive type");
+      return false;
+    }
+    MIRType *elemType = arrayType->GetElemType();
+    if (elemType->GetSize() < 4) {
+      MayPrintLog(debug, false, memOpKind, "element size < 4, don't expand it to  avoid to genearte lots of strb/strh");
+      return false;
+    }
+    uint64 elemCnt = static_cast<uint64>(arrayType->GetSizeArrayItem(0));
+    if (elemType->GetSize() * elemCnt != size) {
+      MayPrintLog(debug, false, memOpKind, "array size not equal");
+      return false;
+    }
+    for (size_t i = 0; i < elemCnt; ++i) {
+      BaseNode *indexExpr = ConstructConstvalNode(i, PTY_u32, *mirBuilder);
+      auto *arrayExpr = mirBuilder->CreateExprArray(*arrayType, addrExpr, indexExpr);
+      auto *newValOpnd = ConstructConstvalNode(byte, elemType->GetSize(),
+                                               elemType->GetPrimType(), *mirBuilder);
+      MIRType *elemPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType);
+      auto *arrayElementAssign = mirBuilder->CreateStmtIassign(*elemPtrType, 0, arrayExpr, newValOpnd);
+      arrayElementAssign->SetExpandFromArrayOfCharFunc(true);
+      InsertBeforeAndMayPrintStmt(block, stmt, debug, arrayElementAssign);
+    }
+  } else {
+    CHECK_FATAL(false, "impossible");
+  }
+
+  // handle memset return val
+  auto *retAssign = GenRetAssign(stmt, func, isLowLevel, memOpKind, errorNumber);
+  InsertBeforeAndMayPrintStmt(block, stmt, debug, retAssign);
+  block.RemoveStmt(&stmt);
+  return true;
+}
+
+static std::pair<StmtNode*, StmtNode*> GenerateMemoryCopyPair(MIRBuilder *mirBuilder, BaseNode *rhs,
+    BaseNode *lhs, uint32 offset, uint32 curSize, PregIdx tmpRegIdx) {
+  auto *ptrType = GlobalTables::GetTypeTable().GetPtrType();
+  PrimType constType = GetIntegerPrimTypeBySizeAndSign(curSize * 8, false);
+  MIRType *constMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(constType));
+  auto *constMIRPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*constMIRType);
+  BaseNode *rhsAddrExpr = rhs;
+  if (offset != 0) {
+    auto *offsetConstExpr = ConstructConstvalNode(offset, PTY_u64, *mirBuilder);
+    rhsAddrExpr = mirBuilder->CreateExprBinary(OP_add, *ptrType, rhs, offsetConstExpr);
+  }
+  BaseNode *rhsExpr = mirBuilder->CreateExprIread(*constMIRType, *constMIRPtrType, 0, rhsAddrExpr);
+  auto *regassign = mirBuilder->CreateStmtRegassign(PTY_u64, tmpRegIdx, rhsExpr);
+  auto *iassignoff = mirBuilder->CreateStmtIassignoff(constType, static_cast<int32>(offset), lhs,
+      mirBuilder->CreateExprRegread(PTY_u64, tmpRegIdx));
+  return { regassign, iassignoff };
+}
+
+void MemEntry::ExpandMemcpyLowLevel(const MemEntry &srcMem, uint64 copySize, MIRFunction &func,
+                                    StmtNode &stmt, BlockNode &block, OpKind memOpKind, bool debug,
+                                    ErrorNumber errorNumber) const {
+  if (errorNumber == ERRNO_RANGE) {
+    auto *retAssign = GenRetAssign(stmt, func, true, memOpKind, errorNumber);
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, retAssign);
+    block.RemoveStmt(&stmt);
+    return;
+  }
+  MIRBuilder *mirBuilder = func.GetModule()->GetMIRBuilder();
+  std::vector<uint32> blocks;
+  SplitMemoryIntoBlocks(copySize, blocks);
+  uint32 offset = 0;
+  // If blocks.size() > 1 and `src` or `dst` is not a leaf node,
+  // we should extract common expr to avoid redundant expression
+  BaseNode *realSrcExpr = srcMem.addrExpr;
+  BaseNode *realDstExpr = addrExpr;
+  if (blocks.size() > 1) {
+    realDstExpr = TryToExtractComplexExpr(addrExpr, func, block, stmt, debug);
+    realSrcExpr = TryToExtractComplexExpr(srcMem.addrExpr, func, block, stmt, debug);
+  }
+  auto *ptrType = GlobalTables::GetTypeTable().GetPtrType();
+  // memory copy optimization
+  PregIdx tmpRegIdx1 = 0;
+  PregIdx tmpRegIdx2 = 0;
+  for (uint32 i = 0; i < blocks.size(); ++i) {
+    uint32 curSize = blocks[i];
+    bool canMergedWithNextSize = (i + 1 < blocks.size()) && blocks[i + 1] == curSize;
+    if (!canMergedWithNextSize) {
+      // low level memcpy expand result:
+      // It seems ireadoff has not been supported by cg HandleFunction, so we use iread instead of ireadoff
+      // [not support] iassignoff <prim-type> <offset> (dstAddrExpr, ireadoff <prim-type> <offset> (srcAddrExpr))
+      // [ok] iassignoff <prim-type> <offset> (dstAddrExpr, iread <prim-type> <type> (add ptr (srcAddrExpr, offset)))
+      PrimType constType = GetIntegerPrimTypeBySizeAndSign(curSize * 8, false);
+      MIRType *constMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(constType));
+      auto *constMIRPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*constMIRType);
+      BaseNode *rhsAddrExpr = realSrcExpr;
+      if (offset != 0) {
+        auto *offsetConstExpr = ConstructConstvalNode(offset, PTY_u64, *mirBuilder);
+        rhsAddrExpr = mirBuilder->CreateExprBinary(OP_add, *ptrType, realSrcExpr, offsetConstExpr);
+      }
+      BaseNode *rhsExpr = mirBuilder->CreateExprIread(*constMIRType, *constMIRPtrType, 0, rhsAddrExpr);
+      auto *iassignoff = mirBuilder->CreateStmtIassignoff(constType, offset, realDstExpr, rhsExpr);
+      InsertBeforeAndMayPrintStmt(block, stmt, debug, iassignoff);
+      offset += curSize;
+      continue;
+    }
+
+    // merge two str/ldr into a stp/ldp
+    if (tmpRegIdx1 == 0 || tmpRegIdx2 == 0) {
+      tmpRegIdx1 = func.GetPregTab()->CreatePreg(PTY_u64);
+      tmpRegIdx2 = func.GetPregTab()->CreatePreg(PTY_u64);
+    }
+    auto pair1 = GenerateMemoryCopyPair(mirBuilder, realSrcExpr, realDstExpr, offset, curSize, tmpRegIdx1);
+    auto pair2 = GenerateMemoryCopyPair(mirBuilder, realSrcExpr, realDstExpr, offset + curSize, curSize, tmpRegIdx2);
+    // insert order: regassign1, regassign2, iassignoff1, iassignoff2
+    InsertBeforeAndMayPrintStmtList(block, stmt, debug, {pair1.first, pair2.first, pair1.second, pair2.second});
+    offset += (2 * curSize);
+    ++i;
+  }
+  // handle memcpy return val
+  auto *retAssign = GenRetAssign(stmt, func, true, memOpKind, errorNumber);
+  InsertBeforeAndMayPrintStmt(block, stmt, debug, retAssign);
+  block.RemoveStmt(&stmt);
+}
+
+bool MemEntry::ExpandMemcpy(const MemEntry &srcMem, uint64 copySize, MIRFunction &func,
+                            StmtNode &stmt, BlockNode &block, bool isLowLevel, bool debug,
+                            ErrorNumber errorNumber) const {
+  OpKind memOpKind = SimplifyOp::ComputeOpKind(stmt);
+  MemEntryKind memKind = GetKind();
+  MIRType *accessType = nullptr;
+  if (!isLowLevel) {  // check type consistency and memKind only for high level expand
+    if (memType != srcMem.memType) {
+      if (srcMem.memType->GetPrimType() != PTY_void) {
+        return false;
+      }
+      accessType = memType;
+    }
+    CHECK_FATAL(memKind != kMemEntryUnknown, "invalid memKind");
+  }
+  MIRBuilder *mirBuilder = func.GetModule()->GetMIRBuilder();
+  StmtNode *newAssign = nullptr;
+  if (isLowLevel) {  // For cglower, replace memcpy with a series of low-level iassignoff
+    ExpandMemcpyLowLevel(srcMem, copySize, func, stmt, block, memOpKind, debug, errorNumber);
+    return true;
+  }
+
+  // Do low level expand for all struct memcpy for now
+  if (memKind == kMemEntryStruct) {
+    MayPrintLog(debug, false, memOpKind, "Do low level expand for all struct memcpy for now");
+    return false;
+  }
+
+  if (memKind == kMemEntryPrimitive) {
+    if (addrExpr->GetOpCode() == OP_addrof) {  // We prefer dassign to iassign
+      auto *addrof = static_cast<AddrofNode*>(addrExpr);
+      auto *symbol = func.GetLocalOrGlobalSymbol(addrof->GetStIdx());
+      newAssign = mirBuilder->CreateStmtDassign(*symbol, addrof->GetFieldID(),
+                                                srcMem.BuildAsRhsExpr(func, accessType));
+    } else {
+      MIRType *memPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*memType);
+      newAssign = mirBuilder->CreateStmtIassign(*memPtrType, 0, addrExpr,
+                                                srcMem.BuildAsRhsExpr(func, accessType));
+      static_cast<IassignNode *>(newAssign)->SetExpandFromArrayOfCharFunc(true);
+    }
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, newAssign);
+  } else if (memKind == kMemEntryArray) {
+    // We only consider array with dim == 1 now, and element type must be primitive type
+    auto *arrayType = static_cast<MIRArrayType*>(memType);
+    if (arrayType->GetDim() != 1 || (arrayType->GetElemType()->GetKind() != kTypeScalar &&
+        arrayType->GetElemType()->GetKind() != kTypePointer)) {
+      MayPrintLog(debug, false, memOpKind, "array dim != 1 or array elements are not primtive type");
+      return false;
+    }
+    MIRType *elemType = arrayType->GetElemType();
+    if (elemType->GetSize() < 4) {
+      MayPrintLog(debug, false, memOpKind, "element size < 4, don't expand it to  avoid to genearte lots of strb/strh");
+      return false;
+    }
+    size_t elemCnt = arrayType->GetSizeArrayItem(0);
+    if (elemType->GetSize() * elemCnt != copySize) {
+      MayPrintLog(debug, false, memOpKind, "array size not equal");
+      return false;
+    }
+    // if srcExpr is too complex (for example: addrof expr of global/static array), let cg expand it
+    if (elemCnt > 1 && IsComplexExpr(srcMem.addrExpr, func)) {
+      MayPrintLog(debug, false, memOpKind,
+                  "srcExpr is too complex, let cg expand it to avoid redundant inst");
+      return false;
+    }
+    MIRType *elemPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType);
+    MIRType *u32Type = GlobalTables::GetTypeTable().GetUInt32();
+    for (size_t i = 0; i < elemCnt; ++i) {
+      ConstvalNode *indexExpr = mirBuilder->CreateConstval(
+          GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(i), *u32Type));
+      auto *arrayExpr = mirBuilder->CreateExprArray(*arrayType, addrExpr, indexExpr);
+      auto *rhsArrayExpr = mirBuilder->CreateExprArray(*arrayType, srcMem.addrExpr, indexExpr);
+      auto *rhsIreadExpr = mirBuilder->CreateExprIread(*elemType, *elemPtrType, 0, rhsArrayExpr);
+      auto *arrayElemAssign = mirBuilder->CreateStmtIassign(*elemPtrType, 0, arrayExpr, rhsIreadExpr);
+      arrayElemAssign->SetExpandFromArrayOfCharFunc(true);
+      InsertBeforeAndMayPrintStmt(block, stmt, debug, arrayElemAssign);
+    }
+  } else {
+    CHECK_FATAL(false, "impossible");
+  }
+
+  // handle memcpy return val
+  auto *retAssign = GenRetAssign(stmt, func, isLowLevel, memOpKind, errorNumber);
+  InsertBeforeAndMayPrintStmt(block, stmt, debug, retAssign);
+  block.RemoveStmt(&stmt);
+  return true;
+}
+
+StmtNode *MemEntry::GenEndZeroAssign(StmtNode &stmt, MIRFunction &func, bool isLowLevel, uint64 count) const {
+  MIRBuilder *mirBuilder = func.GetModule()->GetMIRBuilder();
+  StmtNode *newAssign = nullptr;
+  if (isLowLevel) {
+    newAssign = mirBuilder->CreateStmtIassignoff(PTY_u8, count, addrExpr,
+                                                 ConstructConstvalNode(0, PTY_u8, *mirBuilder));
+    return newAssign;
+  }
+  MemEntryKind memKind = GetKind();
+  auto *base = mirBuilder->CreateExprBinary(OP_add, PTY_a64, static_cast<IassignNode&>(stmt).Opnd(0),
+                                            mirBuilder->CreateIntConst(count, PTY_a64));
+  if (memKind == kMemEntryArray) {
+    auto *arrayType = static_cast<MIRArrayType *>(memType);
+    MIRType *elemType = arrayType->GetElemType();
+    MIRType *elemPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType);
+    /* if size check not success, we assign '\0' to dst[count] */
+    newAssign = mirBuilder->CreateStmtIassign(*elemPtrType, 0, base,
+                                              ConstructConstvalNode(0, elemType->GetSize(), elemType->GetPrimType(),
+                                                                    *mirBuilder));
+  } else if (memKind == kMemEntryPrimitive) {
+    if (base->GetOpCode() == OP_addrof) {
+      auto *addrof = static_cast<AddrofNode*>(static_cast<BaseNode *>(base));
+      auto *symbol = func.GetLocalOrGlobalSymbol(addrof->GetStIdx());
+      newAssign = mirBuilder->CreateStmtDassign(*symbol, addrof->GetFieldID(),
+                                                ConstructConstvalNode(0, PTY_u8, *mirBuilder));
+    } else {
+      MIRType *memPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*memType);
+      newAssign = mirBuilder->CreateStmtIassign(*memPtrType, 0, base,
+                                                ConstructConstvalNode(0, PTY_u8, *mirBuilder));
+    }
+  }
+  return newAssign;
+}
+
+// handle memset, memcpy, sprintf return val
+StmtNode *MemEntry::GenRetAssign(StmtNode &stmt, MIRFunction &func, bool isLowLevel, OpKind opKind, int32 returnVal) {
+  if (stmt.GetOpCode() != OP_call && stmt.GetOpCode() != OP_callassigned) {
+    return nullptr;
+  }
+  auto &callStmt = static_cast<CallNode&>(stmt);
+  const auto &retVec = callStmt.GetReturnVec();
+  if (retVec.empty()) {
+    return nullptr;
+  }
+  MIRBuilder *mirBuilder = func.GetModule()->GetMIRBuilder();
+  BaseNode *rhs = callStmt.Opnd(0);  // for memset, memcpy
+  switch (opKind) {
+    case MEM_OP_memset_s:
+    case MEM_OP_memcpy_s:
+    case SPRINTF_OP_sprintf:
+    case SPRINTF_OP_sprintf_s:{
+      // memset_s memcpy_s sprintf_s must return an returnVal
+      MIRType *constType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_i32));
+      MIRConst *mirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+          static_cast<uint64>(static_cast<int64>(returnVal)),
+          *constType);
+      rhs = mirBuilder->CreateConstval(mirConst);
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+
+  if (!retVec[0].second.IsReg()) {
+    auto *retAssign = mirBuilder->CreateStmtDassign(retVec[0].first, 0, rhs);
+    return retAssign;
+  }
+  PregIdx pregIdx = retVec[0].second.GetPregIdx();
+  auto pregType = func.GetPregTab()->GetPregTableItem(static_cast<uint32>(pregIdx))->GetPrimType();
+  auto *retAssign = mirBuilder->CreateStmtRegassign(pregType, pregIdx, rhs);
+  if (isLowLevel) {
+    retAssign->GetRHS()->SetPrimType(pregType);
+  }
+  return retAssign;
+}
+
+OpKind SimplifyOp::ComputeOpKind(StmtNode &stmt) {
+  if (stmt.GetOpCode() == OP_intrinsiccall) {
+    auto intrinsicID = static_cast<IntrinsiccallNode&>(stmt).GetIntrinsic();
+    if (intrinsicID == INTRN_C_memset) {
+      return MEM_OP_memset;
+    } else if (intrinsicID == INTRN_C_memcpy) {
+      return MEM_OP_memcpy;
+    }
+  }
+  // lowered memop function (such as memset) may be a call, not callassigned
+  if (stmt.GetOpCode() != OP_callassigned && stmt.GetOpCode() != OP_call) {
+    return MEM_OP_unknown;
+  }
+  auto &callStmt = static_cast<CallNode&>(stmt);
+  MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt.GetPUIdx());
+  const char *funcName = mirFunc->GetName().c_str();
+  static const std::unordered_map<std::string, OpKind> hashFuncName = {
+      {kFuncNameOfMemset, MEM_OP_memset},
+      {kFuncNameOfMemcpy, MEM_OP_memcpy},
+      {kFuncNameOfMemsetS, MEM_OP_memset_s},
+      {kFuncNameOfMemcpyS, MEM_OP_memcpy_s},
+      {kFuncNameOfSprintf, SPRINTF_OP_sprintf},
+      {kFuncNameOfSprintfS, SPRINTF_OP_sprintf_s},
+      {kFuncNameOfSnprintfS, SPRINTF_OP_snprintf_s},
+      {kFuncNameOfVsnprintfS, SPRINTF_OP_vsnprintf_s}
+  };
+  auto iter = hashFuncName.find(funcName);
+  if (iter != hashFuncName.end()) {
+    return iter->second;
+  }
+  return MEM_OP_unknown;
+}
+
+bool SimplifyOp::AutoSimplify(StmtNode &stmt, BlockNode &block, bool isLowLevel) {
+  OpKind opKind = ComputeOpKind(stmt);
+  switch (opKind) {
+    case MEM_OP_memset:
+    case MEM_OP_memset_s: {
+      return SimplifyMemset(stmt, block, isLowLevel);
+    }
+    case MEM_OP_memcpy:
+    case MEM_OP_memcpy_s: {
+      return SimplifyMemcpy(stmt, block, isLowLevel);
+    }
+    case SPRINTF_OP_sprintf:
+    case SPRINTF_OP_sprintf_s:
+    case SPRINTF_OP_snprintf_s:
+    case SPRINTF_OP_vsnprintf_s:{
+      auto simplifySprintf = sprintfMap.find(opKind)->second;
+      return simplifySprintf->ReplaceSprintfIfNeeded(stmt, block, isLowLevel, opKind);
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+StmtNode *SprintfBaseOper::InsertMemcpyCallStmt(const MapleVector<BaseNode *> &args, StmtNode &stmt,
+                                                BlockNode &block, int32 retVal, bool isLowLevel) {
+  MIRBuilder *mirBuilder = op.GetFunction()->GetModule()->GetMIRBuilder();
+  auto memcpyFunc = mirBuilder->GetOrCreateFunction(kFuncNameOfMemcpy, TyIdx(PTY_void));
+  auto memcpyCallStmt = mirBuilder->CreateStmtCallAssigned(memcpyFunc->GetPuidx(), args, nullptr, OP_callassigned);
+  memcpyCallStmt->SetSrcPos(stmt.GetSrcPos());
+  memcpyFunc->GetFuncSymbol()->SetAppearsInCode(true);
+  memcpyFunc->AllocSymTab();
+  // handle memcpy return val
+  auto *retAssign = MemEntry::GenRetAssign(stmt, *op.GetFunction(), isLowLevel, MEM_OP_memcpy, retVal);
+  InsertBeforeAndMayPrintStmtList(block, stmt, op.IsDebug(), {memcpyCallStmt, retAssign});
+  return memcpyCallStmt;
+}
+
+static bool GetFmtSrcSize(const StmtNode &stmt, const ConststrNode &fmt, uint32 &fmtOpndIdx, const OpKind &opKind,
+                          uint64 &srcSize) {
+  uint32 origOpndIdx = (opKind == SPRINTF_OP_snprintf_s || opKind == SPRINTF_OP_vsnprintf_s) ?
+      kSnprintfSOrigOpndIdx : kSprintfSOrigOpndIdx;
+  const std::string fmtStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(fmt.GetStrIdx());
+  if (strchr(fmtStr.c_str(), '%') == nullptr) { /* eg: snprintf_s(dst, dstMax, count, constStr) */
+    srcSize = strlen(fmtStr.c_str());
+    return true;
+  } else if (strcmp (fmtStr.c_str(), "%s") == 0) { /* eg: snprintf_s(dst, dstMax, count, "%s", constStr) */
+    BaseNode *orig = stmt.Opnd(origOpndIdx);
+    if (orig->GetOpCode() == OP_conststr) {
+      auto cs = static_cast<ConststrNode *>(orig);
+      const std::string origStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(cs->GetStrIdx());
+      srcSize = strlen(origStr.c_str());
+      fmtOpndIdx = origOpndIdx;
+      return true;
+    }
+  }
+  return false;
+}
+
+void SprintfBaseOper::ProcessRetValue(StmtNode &stmt, BlockNode &block, OpKind opKind, int32 retVal, bool isLowLevel) {
+  auto retAssign = MemEntry::GenRetAssign(stmt, *op.GetFunction(), isLowLevel, opKind, retVal);
+  InsertBeforeAndMayPrintStmt(block, stmt, op.IsDebug(), retAssign);
+}
+
+bool SprintfBaseOper::CheckInvalidPara(uint64 count, uint64 dstMax, uint64 srcSize) {
+  if (count == 0 || srcSize == 0 || dstMax== 0 || dstMax > kSecurecMemMaxLen|| count > kSecurecMemMaxLen) {
+    return false;
+  }
+  return true;
+}
+
+bool SprintfBaseOper::DealWithDstOrEndZero(StmtNode &stmt, BlockNode &block, bool isLowLevel, uint64 count) {
+  MemEntry dstMemEntry;
+  bool valid = MemEntry::ComputeMemEntry(*(stmt.Opnd(0)), *op.GetFunction(), dstMemEntry, isLowLevel);
+  if (!valid) {
+    return false;
+  }
+  auto newAssign = dstMemEntry.GenEndZeroAssign(stmt, *op.GetFunction(), isLowLevel, count);
+  if (newAssign == nullptr) {
+    return false;
+  }
+  InsertBeforeAndMayPrintStmt(block, stmt, op.IsDebug(), newAssign);
+  return true;
+}
+
+bool SprintfBaseOper::CompareDstMaxSrcSize(StmtNode &stmt, BlockNode &block, uint64 dstMax, uint64 srcSize,
+                                           bool isLowLevel) {
+  uint64 count = srcSize >= dstMax ? 0 : srcSize;
+  if (!DealWithDstOrEndZero(stmt, block, isLowLevel, count)) {
+    return false;
+  }
+  int32 retVal = srcSize >= dstMax ? kTruncate : static_cast<int32>(srcSize);
+  ProcessRetValue(stmt, block, SPRINTF_OP_sprintf_s, retVal, isLowLevel);
+  return true;
+}
+
+bool SprintfBaseOper::CompareCountSrcSize(StmtNode &stmt, BlockNode &block, uint64 count, uint64 srcSize,
+                                          bool isLowLevel) {
+  if (!DealWithDstOrEndZero(stmt, block, isLowLevel, std::min(count, srcSize))) {
+    return false;
+  }
+  int32 retVal = srcSize > count ? kTruncate : static_cast<int32>(std::min(srcSize, count));
+  ProcessRetValue(stmt, block, SPRINTF_OP_sprintf_s, retVal, isLowLevel);
+  return true;
+}
+
+bool SprintfBaseOper::DealWithFmtConstStr(StmtNode &stmt, BaseNode *fmt, BlockNode &block, bool isLowLevel) {
+  StmtNode *sprintfCallStmt = &stmt;
+  const std::string fmtStr =
+      GlobalTables::GetUStrTable().GetStringFromStrIdx(static_cast<ConststrNode*>(fmt)->GetStrIdx());
+  uint64 srcSize = strlen(fmtStr.c_str());
+  /* If the format doesn't contain % args or %%, the format is a literal string constant. use memcpy */
+  if (strchr(fmtStr.c_str(), '%') == nullptr) {
+    if (!ReplaceSprintfWithMemcpy(stmt, block, kSprintfFmtOpndIdx, srcSize, isLowLevel)) {
+      return false;
+    }
+  } else if (strcmp (fmtStr.c_str(), "%s") == 0) {
+    BaseNode *orig = sprintfCallStmt->Opnd(kSprintfOrigOpndIdx);
+    if (orig == nullptr || orig->GetOpCode() != OP_conststr) {
+      return false;
+    } else {
+      const std::string origStr =
+          GlobalTables::GetUStrTable().GetStringFromStrIdx(static_cast<ConststrNode*>(orig)->GetStrIdx());
+      srcSize = strlen(origStr.c_str());
+      if (!ReplaceSprintfWithMemcpy(stmt, block, kSprintfOrigOpndIdx, srcSize, isLowLevel)) {
+        return false;
+      }
+    }
+  } else {
+    return false;
+  }
+  if (!DealWithDstOrEndZero(stmt, block, isLowLevel, srcSize)) {
+    return false;
+  }
+  block.RemoveStmt(&stmt);
+  return true;
+}
+
+bool SprintfBaseOper::CheckCondIfNeedReplace(const StmtNode &stmt, uint32_t opIdx) {
+  return stmt.NumOpnds() <= (opIdx + 1);
+}
+
+bool SprintfBaseOper::IsCountConst(StmtNode &stmt, uint64 &count, uint32_t opndIdx) {
+  bool isConst = false;
+  BaseNode *foldCountExpr = FoldIntConst(stmt.Opnd(opndIdx), count, isConst);
+  if (foldCountExpr != nullptr) {
+    stmt.SetOpnd(foldCountExpr, opndIdx);
+  }
+  return isConst;
+}
+
+bool SimplifySnprintfS::GetDstMaxOrCountSize(StmtNode &stmt, uint64 &dstMax, uint64 &count) {
+  return IsCountConst(stmt, count, kFmtSizeOpndIdx) && IsCountConst(stmt, dstMax, kDstSizeOpndIdx);
+}
+
+bool SimplifySprintfS::GetDstMaxOrCountSize(StmtNode &stmt, uint64 &dstMax, uint64 &count __attribute__((unused))) {
+  return IsCountConst(stmt, dstMax, kDstSizeOpndIdx);
+}
+
+bool SprintfBaseOper::ReplaceSprintfWithMemcpy(StmtNode &stmt, BlockNode &block, uint32 opndIdx, uint64 copySize,
+                                               bool isLowLevel) {
+  MapleVector<BaseNode *> args(op.GetFunction()->GetCodeMempoolAllocator().Adapter());
+  MIRBuilder *mirBuilder = op.GetFunction()->GetModule()->GetMIRBuilder();
+  /* size check success, Convert sprintf into memcpy */
+  args.push_back(stmt.Opnd(kSprintfDstOpndIdx));
+  args.push_back(stmt.Opnd(opndIdx));
+  args.push_back(ConstructConstvalNode(copySize, PTY_u64, *mirBuilder));
+  auto memcpyCallStmt = InsertMemcpyCallStmt(args, stmt, block, static_cast<int32>(copySize), isLowLevel);
+  if (memcpyCallStmt == nullptr) {
+    return false;
+  }
+  ProcessRetValue(stmt, block, SPRINTF_OP_sprintf, static_cast<int32>(copySize), isLowLevel);
+  (void)op.SimplifyMemcpy(*memcpyCallStmt, block, isLowLevel);
+
+  return true;
+}
+
+/* Simplify a call to the sprintf  with arguments DEST, FMT, and ORIG.
+   ORIG may be null if this is a 2-argument call.  We don't attempt to
+   simplify calls with more than 3 arguments.
+   Return true if simplification was possible, otherwise false. */
+bool SimplifySprintf::ReplaceSprintfIfNeeded(StmtNode &stmt, BlockNode &block, bool isLowLevel, const OpKind &opKind) {
+  if (!CheckCondIfNeedReplace(stmt, kSprintfOrigOpndIdx)) {
+    return false;
+  }
+  StmtNode *sprintfCallStmt = &stmt;
+  if (op.IsDebug()) {
+    LogInfo::MapleLogger() << "[funcName] " << op.GetFunction()->GetName() << std::endl;
+    sprintfCallStmt->Dump(0);
+  }
+  BaseNode *fmt = sprintfCallStmt->Opnd(kSprintfFmtOpndIdx);
+  // sprintf's fmt must be a const string, otherwise we can not optimize it
+  if (fmt->GetOpCode() == OP_conststr) {
+    return DealWithFmtConstStr(stmt, fmt, block, isLowLevel);
+  }
+  return false;
+}
+
+// expand snprintf_s and vsnprintf_s call statement
+bool SimplifySnprintfS::ReplaceSprintfIfNeeded(StmtNode &stmt, BlockNode &block, bool isLowLevel,
+                                               const OpKind &opKind) {
+  if (!CheckCondIfNeedReplace(stmt, kSnprintfSOrigOpndIdx)) {
+    return false;
+  }
+  uint32 fmtOpndIdx = 3;
+  uint64 srcSize = 0;
+  uint64 dstMax = 0;
+  uint64 count = 0;
+  if (!GetDstMaxOrCountSize(stmt, dstMax, count)) {
+    return false;
+  }
+  BaseNode *fmt = stmt.Opnd(kSnprintfSFmtOpndIdx);
+  if (fmt->GetOpCode() == OP_conststr) {
+    if (!GetFmtSrcSize(stmt, static_cast<const ConststrNode &>(*fmt), fmtOpndIdx, opKind, srcSize)) {
+      return false;
+    }
+    if (!CheckInvalidPara(count, dstMax, srcSize)) {
+      if (!DealWithDstOrEndZero(stmt, block, isLowLevel, 0)) {
+        return false;
+      }
+      if (!isLowLevel) {
+        ProcessRetValue(stmt, block, SPRINTF_OP_sprintf_s, kSprintfErrNum, isLowLevel);
+        return false;
+      }
+      ProcessRetValue(stmt, block, SPRINTF_OP_sprintf_s, kSprintfErrNum, isLowLevel);
+    } else if (dstMax <= count) {
+      /* if dstMax <= count, we need compare dstMax and srcSize */
+      if (!ReplaceSprintfWithMemcpy(stmt, block, fmtOpndIdx, dstMax, isLowLevel)) {
+        return false;
+      }
+      bool isSuccess = CompareDstMaxSrcSize(stmt, block, dstMax, srcSize, isLowLevel);
+      if (!isSuccess) {
+        block.RemoveStmt(&stmt);
+        return false;
+      }
+    } else {
+      /* if dstMax > count, we need compare count and srcSize */
+      if (!ReplaceSprintfWithMemcpy(stmt, block, fmtOpndIdx, std::min(count, srcSize), isLowLevel)) {
+        return false;
+      }
+      bool isSuccess = CompareCountSrcSize(stmt, block, count, srcSize, isLowLevel);
+      if (!isSuccess) {
+        block.RemoveStmt(&stmt);
+        return false;
+      }
+    }
+  } else {
+    // We do not support non-constant str.
+    return false;
+  }
+  block.RemoveStmt(&stmt);
+  return true;
+}
+
+// expand sprintf_s call statement
+bool SimplifySprintfS::ReplaceSprintfIfNeeded(StmtNode &stmt, BlockNode &block, bool isLowLevel,
+                                              const OpKind &opKind) {
+  if (!CheckCondIfNeedReplace(stmt, kSprintfSOrigOpndIdx)) {
+    return false;
+  }
+  uint32 fmtOpndIdx = 2;
+  uint64 srcSize = 0;
+  uint64 dstMax = 0;
+  uint64 count = 0;
+  if (!GetDstMaxOrCountSize(stmt, dstMax, count)) {
+    return false;
+  }
+  /* count is unused, give 1 to pass CheckInvalidPara */
+  count = 1;
+  BaseNode *fmt = stmt.Opnd(fmtOpndIdx);
+  if (fmt->GetOpCode() == OP_conststr) {
+    if (!GetFmtSrcSize(stmt, static_cast<const ConststrNode &>(*fmt), fmtOpndIdx, opKind, srcSize)) {
+      return false;
+    }
+    if (!CheckInvalidPara(count, dstMax, srcSize)) {
+      if (!DealWithDstOrEndZero(stmt, block, isLowLevel, 0)) {
+        return false;
+      }
+      if (!isLowLevel) {
+        ProcessRetValue(stmt, block, SPRINTF_OP_sprintf_s, kSprintfErrNum, isLowLevel);
+        return false;
+      }
+      ProcessRetValue(stmt, block, SPRINTF_OP_sprintf_s, kSprintfErrNum, isLowLevel);
+    } else {
+      uint64 copySize = dstMax <= srcSize ? dstMax : srcSize;
+      if (!ReplaceSprintfWithMemcpy(stmt, block, fmtOpndIdx, copySize, isLowLevel)) {
+        return false;
+      }
+      bool isSuccess = CompareDstMaxSrcSize(stmt, block, dstMax, srcSize, isLowLevel);
+      if (!isSuccess) {
+        block.RemoveStmt(&stmt);
+        return false;
+      }
+      int32 retVal = dstMax <= srcSize ? kTruncate : static_cast<int32>(srcSize);
+      ProcessRetValue(stmt, block, SPRINTF_OP_sprintf_s, retVal, isLowLevel);
+    }
+  } else {
+    // We do not support non-constant str.
+    return false;
+  }
+  block.RemoveStmt(&stmt);
+  return true;
+}
+
+// expand memset_s call statement, return pointer of memset call statement node to be expanded in the next step, return
+// nullptr if memset_s is expanded completely.
+StmtNode *SimplifyOp::PartiallyExpandMemsetS(StmtNode &stmt, BlockNode &block) const{
+  ErrorNumber errNum = ERRNO_OK;
+
+  uint64 srcSize = 0;
+  bool isSrcSizeConst = false;
+  BaseNode *foldSrcSizeExpr = FoldIntConst(stmt.Opnd(kMemOpSSrcSizeOpndIdx), srcSize, isSrcSizeConst);
+  if (foldSrcSizeExpr != nullptr) {
+    stmt.SetOpnd(foldSrcSizeExpr, kMemOpSDstSizeOpndIdx);
+  }
+
+  uint64 dstSize = 0;
+  bool isDstSizeConst = false;
+  BaseNode *foldDstSizeExpr = FoldIntConst(stmt.Opnd(kMemOpSDstSizeOpndIdx), dstSize, isDstSizeConst);
+  if (foldDstSizeExpr != nullptr) {
+    stmt.SetOpnd(foldDstSizeExpr, kMemOpSDstSizeOpndIdx);
+  }
+  if (isDstSizeConst) {
+    if ((srcSize > dstSize && dstSize == 0) || dstSize > kSecurecMemMaxLen) {
+      errNum = ERRNO_RANGE;
+    }
+  }
+
+  MIRBuilder *mirBuilder = func->GetModule()->GetMIRBuilder();
+  auto dstOpnd = stmt.Opnd(kMemOpDstOpndIdx);
+  bool isDstAddrSafe = IsAddrSafe(*dstOpnd);
+  auto newExpr = TryExtractExpr(*dstOpnd, *func, block, stmt, false, debug);
+  if (newExpr) {
+    stmt.SetOpnd(newExpr, kMemOpDstOpndIdx);
+  }
+
+  BlockOperationHelper helper(stmt, *func, block, false, debug);
+  LabelIdx finalLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('f');
+  if (errNum != ERRNO_OK || (isSrcSizeConst && isDstSizeConst && dstSize == 0 && srcSize == 0)) {
+    auto errnoAssign = MemEntry::GenRetAssign(stmt, *func, true, MEM_OP_memset_s, errNum);
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, errnoAssign);
+    block.RemoveStmt(&stmt);
+    return nullptr;
+  } else {
+    LabelIdx dstSizeCheckLabIdx, srcSizeCheckLabIdx, nullPtrLabIdx;
+    if (!isDstSizeConst) {
+      // check if dst size is greater than maxlen
+      dstSizeCheckLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('n');  // 'n' means nullptr
+      helper.CreateAndInsertCheckStmt(OP_gt, stmt.Opnd(kMemOpSDstSizeOpndIdx),
+                                      ConstructConstvalNode(kSecurecMemMaxLen, PTY_u64, *mirBuilder),
+                                      dstSizeCheckLabIdx);
+    }
+
+    // check if dst is nullptr
+    if (!isDstAddrSafe) {
+      nullPtrLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('n');  // 'n' means nullptr
+      helper.CreateAndInsertCheckStmt(OP_eq, stmt.Opnd(kMemOpDstOpndIdx),
+                                      ConstructConstvalNode(0, PTY_u64, *mirBuilder), nullPtrLabIdx);
+    }
+
+    if (isDstSizeConst && isSrcSizeConst) {
+      if (srcSize > dstSize) {
+        auto *callStmt = helper.InsertMemsetCallStmt(stmt.Opnd(kMemOpDstOpndIdx), stmt.Opnd(kMemOpSSrcOpndIdx));
+        helper.InsertRetAssignAndGoto(finalLabIdx, MEM_OP_memset_s, ERRNO_RANGE_AND_RESET);
+        if (!isDstAddrSafe) {
+          helper.HandleError(nullPtrLabIdx, finalLabIdx, ERRNO_INVAL, MEM_OP_memset_s);
+        }
+        helper.InsertLableNode(finalLabIdx);
+        block.RemoveStmt(&stmt);
+        return callStmt;
+      }
+    } else {
+      // check if src size is greater than dst size
+      srcSizeCheckLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('n');  // 'n' means nullptr
+      helper.CreateAndInsertCheckStmt(OP_gt, stmt.Opnd(kMemOpSSrcSizeOpndIdx), stmt.Opnd(kMemOpSDstSizeOpndIdx),
+                                      srcSizeCheckLabIdx);
+    }
+
+    MapleVector<BaseNode *> args(func->GetCodeMempoolAllocator().Adapter());
+    args.push_back(stmt.Opnd(kMemOpDstOpndIdx));
+    args.push_back(stmt.Opnd(kMemOpSSrcOpndIdx));
+    args.push_back(stmt.Opnd(kMemOpSSrcSizeOpndIdx));
+    auto memFunc = mirBuilder->GetOrCreateFunction(kFuncNameOfMemset, TyIdx(PTY_void));
+    auto memCallStmt = mirBuilder->CreateStmtCallAssigned(memFunc->GetPuidx(), args, nullptr, OP_callassigned);
+    memCallStmt->SetSrcPos(stmt.GetSrcPos());
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, memCallStmt);
+    helper.InsertRetAssignAndGoto(finalLabIdx, MEM_OP_memset_s, errNum);
+
+    if (!isSrcSizeConst || !isDstSizeConst) {
+      // handle src size error
+      // in memset_s, we need check if dstSize is 0 before handle srcSize > dstSize, and memset dst to zero
+      helper.HandleErrorWithDstSizeCheckAndReset(srcSizeCheckLabIdx, dstSizeCheckLabIdx, finalLabIdx, MEM_OP_memset_s,
+                                                 ERRNO_RANGE_AND_RESET, isDstSizeConst, dstSize);
+    }
+
+    // handle dst nullptr error
+    // in memset_s, we need check if dstSize is 0 before handle dst == nullptr
+    if (!isDstAddrSafe) {
+      helper.HandleErrorWithDstSizeCheck(nullPtrLabIdx, dstSizeCheckLabIdx, finalLabIdx, MEM_OP_memset_s, ERRNO_INVAL,
+                                         isDstSizeConst, dstSize);
+    }
+
+    if (!isDstSizeConst) {
+      // handle dst size error
+      helper.HandleError(dstSizeCheckLabIdx, finalLabIdx, ERRNO_RANGE, MEM_OP_memset_s);
+    }
+    auto *finalLabelNode = mirBuilder->CreateStmtLabel(finalLabIdx);
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, finalLabelNode);
+    block.RemoveStmt(&stmt);
+    return memCallStmt;
+  }
+}
+
+// Try to replace the call to memset with a series of assign operations (including dassign, iassign, iassignoff), which
+// is usually profitable for small memory size.
+// This function is called in two places, one in mpl2mpl simplify, another in cglower:
+// (1) mpl2mpl memset expand (isLowLevel == false)
+//   for primitive type, array type with element size < 4 bytes and struct type without padding
+// (2) cglower memset expand
+//   for array type with element size >= 4 bytes and struct type with paddings
+bool SimplifyOp::SimplifyMemset(StmtNode &stmt, BlockNode &block, bool isLowLevel) {
+  OpKind memOpKind = ComputeOpKind(stmt);
+  if (memOpKind != MEM_OP_memset && memOpKind != MEM_OP_memset_s) {
+    return false;
+  }
+  uint32 dstOpndIdx = 0;
+  uint32 srcOpndIdx = 1;
+  uint32 srcSizeOpndIdx = 2;
+  bool isSafeVersion = memOpKind == MEM_OP_memset_s;
+  if (debug) {
+    LogInfo::MapleLogger() << "[funcName] " << func->GetName() << std::endl;
+    stmt.Dump(0);
+  }
+
+  StmtNode *memsetCallStmt = &stmt;
+  if (memOpKind == MEM_OP_memset_s && !isLowLevel) {
+    memsetCallStmt = PartiallyExpandMemsetS(stmt, block);
+    if (!memsetCallStmt) {
+      return true;  // Expand memset_s completely, no extra memset is generated, so just return true
+    }
+  } else if (!isLowLevel) {
+    auto newExpr = TryExtractExpr(*stmt.Opnd(kMemOpDstOpndIdx), *func, block, stmt, false, debug);
+    if (newExpr) {
+      stmt.SetOpnd(newExpr, kMemOpDstOpndIdx);
+    }
+  }
+
+  uint64 srcSize = 0;
+  bool isSrcSizeConst = false;
+  BaseNode *foldSrcSizeExpr = FoldIntConst(memsetCallStmt->Opnd(srcSizeOpndIdx), srcSize, isSrcSizeConst);
+  if (foldSrcSizeExpr != nullptr) {
+    memsetCallStmt->SetOpnd(foldSrcSizeExpr, srcSizeOpndIdx);
+  }
+
+  if (isSrcSizeConst) {
+    // If the size is too big, we won't expand it
+    uint32 thresholdExpand = (isSafeVersion ? thresholdMemsetSExpand : thresholdMemsetExpand);
+    if (srcSize > thresholdExpand) {
+      MayPrintLog(debug, false, memOpKind, "size is too big");
+      return false;
+    }
+    if (srcSize == 0) {
+      if (memOpKind == MEM_OP_memset) {
+        auto *retAssign = MemEntry::GenRetAssign(stmt, *func, isLowLevel, memOpKind);
+        InsertBeforeAndMayPrintStmt(block, *memsetCallStmt, debug, retAssign);
+      }
+      block.RemoveStmt(memsetCallStmt);
+      return true;
+    }
+  }
+
+  // memset's 'src size' must be a const value, otherwise we can not expand it
+  if (!isSrcSizeConst) {
+    MayPrintLog(debug, false, memOpKind, "size is not int const");
+    return false;
+  }
+
+  ErrorNumber errNum = ERRNO_OK;
+
+  uint64 val = 0;
+  bool isIntConst = false;
+  BaseNode *foldValExpr = FoldIntConst(memsetCallStmt->Opnd(srcOpndIdx), val, isIntConst);
+  if (foldValExpr != nullptr) {
+    memsetCallStmt->SetOpnd(foldValExpr, srcOpndIdx);
+  }
+  // memset's second argument 'val' should also be a const value
+  if (!isIntConst) {
+    MayPrintLog(debug, false, memOpKind, "val is not int const");
+    return false;
+  }
+
+  MemEntry dstMemEntry;
+  bool valid = MemEntry::ComputeMemEntry(*(memsetCallStmt->Opnd(dstOpndIdx)), *func, dstMemEntry, isLowLevel);
+  if (!valid) {
+    MayPrintLog(debug, false, memOpKind, "dstMemEntry is invalid");
+    return false;
+  }
+  bool ret = false;
+  if (srcSize != 0) {
+    ret = dstMemEntry.ExpandMemset(val, static_cast<uint64>(srcSize), *func, *memsetCallStmt, block, isLowLevel,
+                                   debug, errNum);
+  } else {
+    // if size == 0, no need to set memory, just return error nummber
+    auto *retAssign = MemEntry::GenRetAssign(*memsetCallStmt, *func, isLowLevel, memOpKind, errNum);
+    InsertBeforeAndMayPrintStmt(block, *memsetCallStmt, debug, retAssign);
+    block.RemoveStmt(memsetCallStmt);
+    ret = true;
+  }
+  if (ret) {
+    MayPrintLog(debug, true, memOpKind, "well done");
+  }
+  return ret;
+}
+
+StmtNode *SimplifyOp::PartiallyExpandMemcpyS(StmtNode &stmt, BlockNode &block) {
+  ErrorNumber errNum = ERRNO_OK;
+
+  uint64 srcSize = 0;
+  bool isSrcSizeConst = false;
+  BaseNode *foldSrcSizeExpr = FoldIntConst(stmt.Opnd(kMemOpSSrcSizeOpndIdx), srcSize, isSrcSizeConst);
+  if (foldSrcSizeExpr != nullptr) {
+    stmt.SetOpnd(foldSrcSizeExpr, kMemOpSDstSizeOpndIdx);
+  }
+
+  uint64 dstSize = 0;
+  bool isDstSizeConst = false;
+  BaseNode *foldDstSizeExpr = FoldIntConst(stmt.Opnd(kMemOpSDstSizeOpndIdx), dstSize, isDstSizeConst);
+  if (foldDstSizeExpr != nullptr) {
+    stmt.SetOpnd(foldDstSizeExpr, kMemOpSDstSizeOpndIdx);
+  }
+  if (isDstSizeConst) {
+    if ((dstSize == 0) || static_cast<uint64>(dstSize) > kSecurecMemMaxLen) {
+      errNum = ERRNO_RANGE;
+    }
+  }
+
+  MIRBuilder *mirBuilder = func->GetModule()->GetMIRBuilder();
+  auto dstOpnd = stmt.Opnd(kMemOpDstOpndIdx);
+  auto srcOpnd = stmt.Opnd(kMemOpSSrcOpndIdx);
+  bool isDstAddrSafe = IsAddrSafe(*dstOpnd);
+  bool isSrcAddrSafe = IsAddrSafe(*srcOpnd);
+  auto newDst = TryExtractExpr(*dstOpnd, *func, block, stmt, false, debug);
+  if (newDst) {
+    stmt.SetOpnd(newDst, kMemOpDstOpndIdx);
+  }
+  auto newSrc = TryExtractExpr(*srcOpnd, *func, block, stmt, true, debug);
+  if (newSrc) {
+    stmt.SetOpnd(newSrc, kMemOpSSrcOpndIdx);
+  }
+
+  BlockOperationHelper helper(stmt, *func, block, false, debug);
+  LabelIdx finalLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('f');
+  if (errNum != ERRNO_OK || (isSrcSizeConst && isDstSizeConst && dstSize == 0 && srcSize == 0)) {
+    auto errnoAssign = MemEntry::GenRetAssign(stmt, *func, true, MEM_OP_memcpy_s, errNum);
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, errnoAssign);
+    block.RemoveStmt(&stmt);
+    return nullptr;
+  } else {
+    LabelIdx dstSizeCheckLabIdx, srcSizeCheckLabIdx, dstNullPtrLabIdx, srcNullPtrLabIdx, addrEqLabIdx, overlapLabIdx;
+    if (!isDstSizeConst) {
+      // check if dst size is greater than maxlen or equal to 0
+      dstSizeCheckLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('n');  // 'n' means nullptr
+
+      helper.CreateAndInsertCheckStmt(OP_eq, stmt.Opnd(kMemOpSDstSizeOpndIdx),
+                                      ConstructConstvalNode(0, PTY_u64, *mirBuilder),
+                                      dstSizeCheckLabIdx);
+      helper.CreateAndInsertCheckStmt(OP_gt, stmt.Opnd(kMemOpSDstSizeOpndIdx),
+                                      ConstructConstvalNode(kSecurecMemMaxLen, PTY_u64, *mirBuilder),
+                                      dstSizeCheckLabIdx);
+    }
+
+    // check if dst is nullptr
+    if (!isDstAddrSafe) {
+      dstNullPtrLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('n');  // 'n' means nullptr
+      helper.CreateAndInsertCheckStmt(OP_eq, stmt.Opnd(kMemOpDstOpndIdx),
+                                      ConstructConstvalNode(0, PTY_u64, *mirBuilder), dstNullPtrLabIdx);
+    }
+    // check if src is nullptr
+    if (!isSrcAddrSafe) {
+      srcNullPtrLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('n');  // 'n' means nullptr
+      helper.CreateAndInsertCheckStmt(OP_eq, stmt.Opnd(kMemOpSSrcOpndIdx),
+                                      ConstructConstvalNode(0, PTY_u64, *mirBuilder), srcNullPtrLabIdx);
+    }
+
+    if (isDstSizeConst && isSrcSizeConst) {
+      if (srcSize > dstSize) {
+        // handle srcsize > dstsize
+        auto *callStmt =
+            helper.InsertMemsetCallStmt(stmt.Opnd(kMemOpDstOpndIdx), ConstructConstvalNode(0, PTY_i32, *mirBuilder));
+        helper.InsertRetAssignAndGoto(finalLabIdx, MEM_OP_memcpy_s, ERRNO_RANGE_AND_RESET);
+        // handle src = nullptr
+        if (!isSrcAddrSafe) {
+          helper.HandleErrorAndReset(srcNullPtrLabIdx, finalLabIdx, MEM_OP_memcpy_s, ERRNO_INVAL_AND_RESET);
+        }
+        // handle dst = nullptr
+        if (!isDstAddrSafe) {
+          helper.HandleError(dstNullPtrLabIdx, finalLabIdx, ERRNO_INVAL, MEM_OP_memcpy_s);
+        }
+        helper.InsertLableNode(finalLabIdx);
+        block.RemoveStmt(&stmt);
+        return callStmt;
+      }
+    } else {
+      // check if src size is greater than dst size
+      srcSizeCheckLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('n');  // 'n' means nullptr
+      helper.CreateAndInsertCheckStmt(OP_gt, stmt.Opnd(kMemOpSSrcSizeOpndIdx), stmt.Opnd(kMemOpSDstSizeOpndIdx),
+                                      srcSizeCheckLabIdx);
+    }
+
+    // check addr equal
+    addrEqLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('e');
+    helper.CreateAndInsertCheckStmt(OP_eq, stmt.Opnd(kMemOpDstOpndIdx), stmt.Opnd(kMemOpSSrcOpndIdx), addrEqLabIdx);
+
+    // check overlap
+    overlapLabIdx = func->GetLabelTab()->CreateLabelWithPrefix('o');  // 'o' means overlap
+    auto *checkOverlapStmt = CreateOverlapCheckStmt(*stmt.Opnd(kMemOpDstOpndIdx), *stmt.Opnd(kMemOpSSrcOpndIdx),
+                                                    *stmt.Opnd(kMemOpSSrcSizeOpndIdx), overlapLabIdx, mirBuilder);
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, checkOverlapStmt);
+
+    // insert memcpy call
+    MapleVector<BaseNode *> args(func->GetCodeMempoolAllocator().Adapter());
+    args.push_back(stmt.Opnd(kMemOpDstOpndIdx));
+    args.push_back(stmt.Opnd(kMemOpSSrcOpndIdx));
+    args.push_back(stmt.Opnd(kMemOpSSrcSizeOpndIdx));
+    auto memFunc = mirBuilder->GetOrCreateFunction(kFuncNameOfMemcpy, TyIdx(PTY_void));
+    auto memCallStmt = mirBuilder->CreateStmtCallAssigned(memFunc->GetPuidx(), args, nullptr, OP_callassigned);
+    memCallStmt->SetSrcPos(stmt.GetSrcPos());
+    InsertBeforeAndMayPrintStmt(block, stmt, debug, memCallStmt);
+    helper.InsertRetAssignAndGoto(finalLabIdx, MEM_OP_memcpy_s, errNum);
+
+    // Add handler IR if dst and src are overlapped
+    helper.HandleErrorAndReset(overlapLabIdx, finalLabIdx, MEM_OP_memcpy_s, ERRNO_OVERLAP_AND_RESET);
+
+    // handle addr equal
+    helper.HandleError(addrEqLabIdx, finalLabIdx, ERRNO_OK, MEM_OP_memcpy_s);
+
+    if (!isSrcSizeConst || !isDstSizeConst) {
+      // handle src size error
+      helper.HandleErrorAndReset(srcSizeCheckLabIdx, finalLabIdx, MEM_OP_memcpy_s, ERRNO_RANGE_AND_RESET);
+    }
+
+    // handle src nullptr error
+    if (!isSrcAddrSafe) {
+      helper.HandleErrorAndReset(srcNullPtrLabIdx, finalLabIdx, MEM_OP_memcpy_s, ERRNO_INVAL_AND_RESET);
+    }
+
+    // handle dst nullptr error
+    if (!isDstAddrSafe) {
+      helper.HandleError(dstNullPtrLabIdx, finalLabIdx, ERRNO_INVAL, MEM_OP_memcpy_s);
+    }
+
+    if (!isDstSizeConst) {
+      // handle dst size error
+      helper.HandleError(dstSizeCheckLabIdx, finalLabIdx, ERRNO_RANGE, MEM_OP_memcpy_s);
+    }
+    helper.InsertLableNode(finalLabIdx);
+    block.RemoveStmt(&stmt);
+    return memCallStmt;
+  }
+}
+
+bool SimplifyOp::SimplifyMemcpy(StmtNode &stmt, BlockNode &block, bool isLowLevel) {
+  OpKind memOpKind = ComputeOpKind(stmt);
+  if (memOpKind != MEM_OP_memcpy && memOpKind != MEM_OP_memcpy_s) {
+    return false;
+  }
+  uint32 dstOpndIdx = 0;
+  uint32 srcOpndIdx = 1;
+  uint32 srcSizeOpndIdx = 2;
+  bool isSafeVersion = memOpKind == MEM_OP_memcpy_s;
+  if (debug) {
+    LogInfo::MapleLogger() << "[funcName] " << func->GetName() << std::endl;
+    stmt.Dump(0);
+  }
+
+  StmtNode* memcpyCallStmt = &stmt;
+  if (memOpKind == MEM_OP_memcpy_s) {
+    memcpyCallStmt = PartiallyExpandMemcpyS(stmt, block);
+    if (!memcpyCallStmt) {
+      return true;  // Expand memcpy_s completely, no extra memcpy is generated, so just return true
+    }
+  } else if (!isLowLevel) {
+    auto newDst = TryExtractExpr(*stmt.Opnd(kMemOpDstOpndIdx), *func, block, stmt, false, debug);
+    if (newDst) {
+      stmt.SetOpnd(newDst, kMemOpDstOpndIdx);
+    }
+    auto newSrc = TryExtractExpr(*stmt.Opnd(kMemOpSrcOpndIdx), *func, block, stmt, true, debug);
+    if (newSrc) {
+      stmt.SetOpnd(newSrc, kMemOpSrcOpndIdx);
+    }
+  }
+
+  uint64 srcSize = 0;
+  bool isIntConst = false;
+  BaseNode *foldCopySizeExpr = FoldIntConst(memcpyCallStmt->Opnd(srcSizeOpndIdx), srcSize, isIntConst);
+  if (foldCopySizeExpr != nullptr) {
+    memcpyCallStmt->SetOpnd(foldCopySizeExpr, srcSizeOpndIdx);
+  }
+  if (!isIntConst) {
+    MayPrintLog(debug, false, memOpKind, "src size is not an int const");
+    return false;
+  }
+  uint32 thresholdExpand = (isSafeVersion ? thresholdMemcpySExpand : thresholdMemcpyExpand);
+  if (srcSize > thresholdExpand) {
+    MayPrintLog(debug, false, memOpKind, "size is too big");
+    return false;
+  }
+  if (srcSize == 0) {
+    if (memOpKind == MEM_OP_memcpy) {
+      auto *retAssign = MemEntry::GenRetAssign(stmt, *func, isLowLevel, memOpKind);
+      InsertBeforeAndMayPrintStmt(block, *memcpyCallStmt, debug, retAssign);
+    }
+    block.RemoveStmt(memcpyCallStmt);
+    return true;
+  }
+  int64 copySize = srcSize;
+  ErrorNumber errNum = ERRNO_OK;
+
+  MemEntry dstMemEntry;
+  bool valid = MemEntry::ComputeMemEntry(*memcpyCallStmt->Opnd(dstOpndIdx), *func, dstMemEntry, isLowLevel);
+  if (!valid) {
+    MayPrintLog(debug, false, memOpKind, "dstMemEntry is invalid");
+    return false;
+  }
+  MemEntry srcMemEntry;
+  valid = MemEntry::ComputeMemEntry(*memcpyCallStmt->Opnd(srcOpndIdx), *func, srcMemEntry, isLowLevel);
+  if (!valid) {
+    MayPrintLog(debug, false, memOpKind, "srcMemEntry is invalid");
+    return false;
+  }
+  // We don't check type consistency when doing low level expand
+  if (!isLowLevel) {
+    if (dstMemEntry.memType != srcMemEntry.memType) {
+      // any type <-- void (feasible)
+      if (srcMemEntry.memType->GetPrimType() != PTY_void) {
+        MayPrintLog(debug, false, memOpKind, "dst and src have different type");
+        return false;   // entryType must be identical
+      }
+    }
+    if (dstMemEntry.memType->GetSize() != static_cast<uint64>(srcSize)) {
+      MayPrintLog(debug, false, memOpKind, "copy size != dst memory size");
+      return false;  // copy size should equal to dst memory size, we maybe allow smaller copy size later
+    }
+  }
+  bool ret = false;
+  if (copySize != 0) {
+    ret = dstMemEntry.ExpandMemcpy(srcMemEntry, static_cast<uint64>(copySize), *func, *memcpyCallStmt, block,
+                                   isLowLevel, debug, errNum);
+  } else {
+    // if copySize == 0, no need to copy memory, just return error number
+    auto *retAssign = MemEntry::GenRetAssign(*memcpyCallStmt, *func, isLowLevel, memOpKind, errNum);
+    InsertBeforeAndMayPrintStmt(block, *memcpyCallStmt, debug, retAssign);
+    block.RemoveStmt(memcpyCallStmt);
+    ret = true;
+  }
+  if (ret) {
+    MayPrintLog(debug, true, memOpKind, "well done");
+  }
+  return ret;
+}
+
+void M2MSimplify::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+
+bool M2MSimplify::PhaseRun(maple::MIRModule &m) {
+  auto *kh = GET_ANALYSIS(M2MKlassHierarchy, m);
+  ASSERT_NOT_NULL((kh));
+  std::unique_ptr<FuncOptimizeImpl> funcOptImpl = std::make_unique<Simplify>(m, kh, *GetPhaseMemPool(),
+                                                                             TRACE_MAPLE_PHASE);
+  ASSERT_NOT_NULL(funcOptImpl);
+  FuncOptimizeIterator opt(PhaseName(), std::move(funcOptImpl));
+  opt.Init();
+  opt.Run();
+  return true;
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/stmt_cost_analyzer.cpp b/src/mapleall/mpl2mpl/src/stmt_cost_analyzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb8831c3fb26d42b862c7408483161e37cc414a9
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/stmt_cost_analyzer.cpp
@@ -0,0 +1,448 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stmt_cost_analyzer.h"
+#include <fstream>
+#include <iostream>
+#include "factory.h"
+#include "global_tables.h"
+#include "mpl_logging.h"
+#include "ssa_tab.h"
+
+namespace maple {
+static constexpr int64 kFreeInsn = 10;
+static constexpr int64 kHalfInsn = 50;
+static constexpr int64 kOneInsn = 100;
+static constexpr int64 kDoubleInsn = 200;
+static constexpr int64 kInfinityFuncNumInsns = 100000;
+
+static int64 HandleSwitch(StmtNode &stmt, StmtCostAnalyzer&) {
+  SwitchNode &switchNode = static_cast<SwitchNode&>(stmt);
+  return static_cast<int64>((switchNode.GetSwitchTable().size() + 1) * kSizeScale);
+}
+
+static int64 HandleCall(StmtNode &stmt, StmtCostAnalyzer &ia) {
+  int64 cost = 0;
+  CallNode &callNode = static_cast<CallNode&>(stmt);
+  // call insn itself.
+  cost += kOneInsn;
+  // handle all the params.
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+    cost += ia.GetExprCost(stmt.Opnd(i));
+  }
+  // solve assign
+  auto &returnVector = callNode.GetReturnVec();
+  if (returnVector.empty()) {
+    return cost;
+  }
+  CHECK_FATAL(returnVector.size() == 1, "Error.");
+  auto stIdx = returnVector.at(0).first;
+  auto fieldID = returnVector.at(0).second.GetFieldID();
+  if (returnVector.at(0).second.IsReg()) {
+    return kOneInsn;
+  }
+  auto *mirType = ia.GetMIRTypeFromStIdxAndField(stIdx, fieldID);
+  cost += ia.GetMoveCost(mirType->GetSize());
+  return cost;
+}
+
+static int64 HandleIcall(StmtNode &stmt, StmtCostAnalyzer &ia) {
+  int64 cost = 0;
+  IcallNode &icall = static_cast<IcallNode&>(stmt);
+  // call insn itself.
+  cost += kOneInsn;
+  // handle all the params.
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
+    cost += ia.GetExprCost(stmt.Opnd(i));
+  }
+  // solve assign
+  auto &returnVector = icall.GetReturnVec();
+  if (returnVector.empty()) {
+    return cost;
+  }
+  CHECK_FATAL(returnVector.size() == 1, "Error.");
+  auto stIdx = returnVector.at(0).first;
+  auto fieldID = returnVector.at(0).second.GetFieldID();
+  auto *mirType = ia.GetMIRTypeFromStIdxAndField(stIdx, fieldID);
+  cost += ia.GetMoveCost(mirType->GetSize());
+  return cost;
+}
+
+static int64 HandleDassign(StmtNode &stmt, StmtCostAnalyzer &ia) {
+  int64 cost = 0;
+  DassignNode &dassign = static_cast<DassignNode&>(stmt);
+  auto stIdx = dassign.GetStIdx();
+  bool isGlobal = stIdx.IsGlobal();
+  if (isGlobal) {
+    // need 2 insn to find the addr of global.
+    cost += kDoubleInsn;
+  }
+  auto *mirType = ia.GetMIRTypeFromStIdxAndField(stIdx, dassign.GetFieldID());
+  bool needStore = isGlobal || mirType->GetSize() > ia.GetTargetInfo()->GetMaxMoveBytes();
+  if (needStore) {
+    cost += ia.GetMoveCost(mirType->GetSize());
+  } else {
+    cost += kFreeInsn;
+  }
+  cost += ia.GetExprCost(dassign.GetRHS());
+  return cost;
+}
+
+static int64 HandleIassign(StmtNode &stmt, StmtCostAnalyzer &ia) {
+  int64 cost = 0;
+  IassignNode &iassign = static_cast<IassignNode&>(stmt);
+  auto *type = static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(iassign.GetTyIdx()));
+  auto *mirType =
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(type->GetPointedTyIdxWithFieldID(iassign.GetFieldID()));
+  cost += ia.GetMoveCost(mirType->GetSize());
+  cost += ia.GetExprCost(iassign.GetRHS());
+  return cost;
+}
+
+static int64 HandleIf(StmtNode &stmt, StmtCostAnalyzer &ia) {
+  int64 cost = 0;
+  IfStmtNode &ifNode = static_cast<IfStmtNode&>(stmt);
+  // one insn for brtrue or brfalse.
+  cost += kOneInsn;
+  cost += ia.GetExprCost(ifNode.Opnd(0));
+  cost += ia.GetStmtsCost(ifNode.GetThenPart());
+  cost += ia.GetStmtsCost(ifNode.GetElsePart());
+  return cost;
+}
+
+static int64 HandleWhile(StmtNode &stmt, StmtCostAnalyzer &ia) {
+  int64 cost = 0;
+  WhileStmtNode &whileNode = static_cast<WhileStmtNode&>(stmt);
+  cost += ia.GetExprCost(whileNode.Opnd(0));
+  cost += ia.GetStmtsCost(whileNode.GetBody());
+  return cost;
+}
+
+static int64 HandleIntrinsicCall(StmtNode &stmt, StmtCostAnalyzer &ia) {
+  IntrinsiccallNode &intrinsic = static_cast<IntrinsiccallNode&>(stmt);
+  return static_cast<int64>(ia.GetTargetInfo()->GetIntrinsicInsnNum(intrinsic.GetIntrinsic()) * kSizeScale);
+}
+
+using GetStmtCostFactory = FunctionFactory<Opcode, int64, StmtNode&, StmtCostAnalyzer&>;
+static void InitStmtCostFactory() {
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_switch, HandleSwitch);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_call, HandleCall);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_callassigned, HandleCall);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_icall, HandleIcall);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_icallassigned, HandleIcall);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_dassign, HandleDassign);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_iassign, HandleIassign);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_if, HandleIf);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_while, HandleWhile);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_dowhile, HandleWhile);
+  RegisterFactoryFunction<GetStmtCostFactory>(OP_intrinsiccall, HandleIntrinsicCall);
+}
+
+void StmtCostAnalyzer::Init() {
+  ti = TargetInfo::CreateTargetInfo(alloc);
+  InitStmtCostFactory();
+}
+
+int64 StmtCostAnalyzer::GetStmtsCost(BlockNode *block) {
+  if (block == nullptr) {
+    return 0;
+  }
+  int64 cost = 0;
+  for (auto &stmt : block->GetStmtNodes()) {
+    cost += GetStmtCost(&stmt);
+  }
+  return cost;
+}
+
+int64 StmtCostAnalyzer::GetMoveCost(size_t sizeInByte) {
+  return static_cast<int64>(((sizeInByte + ti->GetMaxMoveBytes() - 1) / ti->GetMaxMoveBytes()) * kSizeScale);
+}
+
+static bool IsConstZero(const BaseNode *opnd) {
+  CHECK_FATAL(opnd != nullptr, "Null pointer check.");
+  while (opnd->GetOpCode() == OP_cvt) {
+    opnd = opnd->Opnd(0);
+    CHECK_FATAL(opnd != nullptr, "Null pointer check.");
+  }
+  if (opnd->GetOpCode() == OP_constval) {
+    return static_cast<const ConstvalNode*>(opnd)->GetConstVal()->IsZero();
+  }
+  return false;
+}
+
+int64 StmtCostAnalyzer::GetMeExprCost(MeExpr *meExpr) {
+  if (meExpr == nullptr) {
+    return 0;
+  }
+  BaseNode &expr = meExpr->EmitExpr(alloc);
+  return GetExprCost(&expr);
+}
+
+int64 StmtCostAnalyzer::GetMeStmtCost(MeStmt *meStmt) {
+  if (meStmt == nullptr) {
+    return 0;
+  }
+  // We need save and update module curFunc before emit because
+  // some Emit (such as VarMeExpr::Emit) will call module.CurFunction()
+  MIRModule *mirModule = curFunc->GetModule();
+  MIRFunction *oldCurFunc = mirModule->CurFunction();
+  mirModule->SetCurFunction(curFunc);
+  StmtNode &stmt = meStmt->EmitStmt(alloc);
+  // Recover module curFunc after emit
+  mirModule->SetCurFunction(oldCurFunc);
+  return GetStmtCost(&stmt);
+}
+
+int32 StmtCostAnalyzer::EstimateNumInsns(MeStmt *meStmt) {
+  auto stmtSizeCost = GetMeStmtCost(meStmt);
+  // 100 cost per insn
+  return static_cast<int32>(stmtSizeCost) / static_cast<int32>(kSizeScale);
+}
+
+int32 StmtCostAnalyzer::EstimateNumCycles(MeStmt *meStmt) {
+  // we should use more accurate cycle model if needed
+  return EstimateNumInsns(meStmt);
+}
+
+int32 StmtCostAnalyzer::EstimateNumInsns(StmtNode *stmt) {
+  auto stmtSizeCost = GetStmtCost(stmt);
+  // 100 cost per insn
+  return static_cast<int32>(stmtSizeCost) / static_cast<int32>(kSizeScale);
+}
+
+int32 StmtCostAnalyzer::EstimateNumCycles(StmtNode *stmt) {
+  // we should use more accurate cycle model if needed
+  return EstimateNumInsns(stmt);
+}
+
+int64 StmtCostAnalyzer::GetExprCost(BaseNode *expr) {
+  if (expr == nullptr) {
+    return 0;
+  }
+  int64 cost = 0;
+  Opcode op = expr->GetOpCode();
+  switch (op) {
+    case OP_dread: {
+      DreadNode *dread = static_cast<DreadNode*>(expr);
+      auto stIdx = dread->GetStIdx();
+      bool isGlobal = stIdx.IsGlobal();
+      if (isGlobal) {
+        // need 2 insn to find the addr of global.
+        cost += kDoubleInsn;
+      }
+      auto *mirType = GetMIRTypeFromStIdxAndField(stIdx, dread->GetFieldID());
+      bool needStore = isGlobal || mirType->GetSize() > ti->GetMaxMoveBytes();
+      if (needStore) {
+        cost += GetMoveCost(mirType->GetSize());
+      } else {
+        cost += kFreeInsn;
+      }
+      break;
+    }
+    case OP_iread: {
+      IreadNode *iread = static_cast<IreadNode*>(expr);
+      auto *mirType = iread->GetType();
+      cost += GetMoveCost(mirType->GetSize());
+      break;
+    }
+    case OP_addrof: {
+      AddrofNode *addrofNode = static_cast<AddrofNode*>(expr);
+      auto stIdx = addrofNode->GetStIdx();
+      if (stIdx.IsGlobal()) {
+        cost += kDoubleInsn;
+      } else {
+        cost += kOneInsn;
+      }
+      break;
+    }
+    case OP_iaddrof: {
+      // it's usually an add insn.
+      cost += kOneInsn;
+      break;
+    }
+    case OP_addroffunc: {
+      cost += kDoubleInsn;
+      break;
+    }
+    case OP_constval: {
+      MIRConst *mirConst = static_cast<ConstvalNode*>(expr)->GetConstVal();
+      if (mirConst->IsZero()) {
+        break;
+      }
+      if (mirConst->GetKind() == kConstInt) {
+        cost += kFreeInsn;
+        break;
+      }
+      cost += kDoubleInsn;
+      break;
+    }
+    case OP_conststr:
+    case OP_conststr16: {
+      cost += kDoubleInsn;
+      break;
+    }
+    case OP_cvt: {
+      TypeCvtNode *cvt = static_cast<TypeCvtNode*>(expr);
+      PrimType fromType = cvt->FromType();
+      PrimType toType = cvt->GetPrimType();
+      if (IsPrimitiveFloat(fromType) || IsPrimitiveFloat(toType)) {
+        cost += kOneInsn;
+      }
+      break;
+    }
+    case OP_retype:
+    case OP_trunc:
+    case OP_ceil:
+    case OP_floor:
+    case OP_round: {
+      cost += kFreeInsn;
+      break;
+    }
+    case OP_bnot:
+    case OP_abs: {
+      cost += kOneInsn;
+      break;
+    }
+    case OP_intrinsicop:
+    case OP_intrinsicopwithtype: {
+      IntrinsicopNode *intrin = static_cast<IntrinsicopNode*>(expr);
+      cost += static_cast<int64>(ti->GetIntrinsicInsnNum(intrin->GetIntrinsic()) * kSizeScale);
+      break;
+    }
+    case OP_add:
+    case OP_sub: {
+      cost += kHalfInsn;
+      break;
+    }
+    case OP_mul:
+    case OP_div: {
+      cost += kOneInsn;
+      break;
+    }
+    case OP_rem: {
+      cost += kDoubleInsn;
+      break;
+    }
+    case OP_land:
+    case OP_lior:
+    case OP_cand:
+    case OP_cior:
+    case OP_band:
+    case OP_bior:
+    case OP_bxor: {
+      cost += kHalfInsn;
+      break;
+    }
+    case OP_sext:
+    case OP_zext:
+    case OP_ashr:
+    case OP_lshr:
+    case OP_shl:
+    case OP_ror: {
+      cost += kHalfInsn;
+      break;
+    }
+    case OP_eq:
+    case OP_ge:
+    case OP_gt:
+    case OP_le:
+    case OP_lt:
+    case OP_ne:
+    case OP_cmp:
+    case OP_cmpl:
+    case OP_cmpg: {
+      CompareNode *cmp = static_cast<CompareNode*>(expr);
+      bool cmpWithZero = IsConstZero(cmp->Opnd(0)) || IsConstZero(cmp->Opnd(1));
+      cost += cmpWithZero ? 0 : kOneInsn;
+      break;
+    }
+    case OP_jstry:
+    case OP_try:
+    case OP_jscatch:
+    case OP_catch:
+    case OP_finally:
+    case OP_cleanuptry:
+    case OP_endtry:
+    case OP_syncenter:
+    case OP_syncexit: {
+      return kInfinityFuncNumInsns;
+    }
+    default: {
+      cost += kOneInsn;
+      break;
+    }
+  }
+  for (size_t i = 0; i < expr->NumOpnds(); ++i) {
+    cost += GetExprCost(expr->Opnd(i));
+  }
+  return cost;
+}
+
+MIRType *StmtCostAnalyzer::GetMIRTypeFromStIdxAndField(const StIdx idx, FieldID fieldID) {
+  auto *symbol = curFunc->GetLocalOrGlobalSymbol(idx);
+  ASSERT_NOT_NULL(symbol);
+  auto *mirType = symbol->GetType();
+  if (fieldID != 0) {
+    ASSERT_NOT_NULL(mirType);
+    mirType = static_cast<MIRStructType*>(mirType)->GetFieldType(fieldID);
+  }
+  return mirType;
+}
+
+int64 StmtCostAnalyzer::GetStmtCost(StmtNode *stmt) {
+  if (stmt == nullptr) {
+    return 0;
+  }
+  Opcode op = stmt->GetOpCode();
+  auto function = CreateProductFunction<GetStmtCostFactory>(op);
+  if (function != nullptr) {
+    // Update module curFunc
+    MIRModule *mirModule = curFunc->GetModule();
+    MIRFunction *oldCurFunc = mirModule->CurFunction();
+    mirModule->SetCurFunction(curFunc);
+    auto ret = function(*stmt, *this);
+    // Recover module curFunc
+    mirModule->SetCurFunction(oldCurFunc);
+    return ret;
+  }
+  int64 cost = 0;
+  switch (op) {
+    case OP_brtrue:
+    case OP_brfalse: {
+      cost += kOneInsn;
+      break;
+    }
+    case OP_eval:
+    case OP_free:
+    case OP_abort:
+    case OP_goto:
+    case OP_label: {
+      return 0;
+    }
+    case OP_return: {
+      cost += kOneInsn;
+      // opnd need to be analyzed.
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  for (size_t i = 0; i < stmt->NumOpnds(); ++i) {
+    cost += GetExprCost(stmt->Opnd(i));
+  }
+  return cost;
+}
+}  // namespace maple
+
diff --git a/src/mapleall/mpl2mpl/src/target_info.cpp b/src/mapleall/mpl2mpl/src/target_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e8cbeb51489c5e11731355c2678105d7d2e13312
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/target_info.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "target_info.h"
+
+namespace maple {
+
+// ---------- TargetInfo ----------
+TargetInfo *TargetInfo::CreateTargetInfo(MapleAllocator &alloc, BackEnd backEnd) {
+  // now we use macro to choose target.
+  (void)backEnd;
+  TargetInfo *ret = nullptr;
+#if TARGAARCH64 || TARGRISCV64
+  ret = alloc.New<AArch64TargetInfo>();
+#elif TARGX86_64
+  ret = alloc.New<X64TargetInfo>();
+#else
+#error "unknown platform"
+#endif
+  return ret;
+}
+
+// ---------- AArch64TargetInfo ----------
+size_t AArch64TargetInfo::GetIntrinsicInsnNum(MIRIntrinsicID id) {
+  // A simple way to get insn number of intrinsicop/intrinsiccall.
+  return IntrinDesc::intrinTable[id].GetNumInsn();
+}
+
+// ---------- X64TargetInfo ----------
+size_t X64TargetInfo::GetIntrinsicInsnNum(MIRIntrinsicID id) {
+  // A simple way to get insn number of intrinsicop/intrinsiccall.
+  return IntrinDesc::intrinTable[id].GetNumInsn();
+}
+}  /* namespace maple */
diff --git a/src/mapleall/mpl2mpl/src/update_mplt.cpp b/src/mapleall/mpl2mpl/src/update_mplt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9c5e9783b34dc82a81e5c7d36f680d10372defc0
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/update_mplt.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "update_mplt.h"
+#include "bin_mpl_export.h"
+#include "bin_mplt.h"
+
+namespace maple {
+bool M2MUpdateMplt::PhaseRun(MIRModule &m) {
+  auto *cg = GET_ANALYSIS(M2MCallGraph, m);
+  CHECK_FATAL(cg != nullptr, "Expecting a valid CallGraph, found nullptr.");
+  BinaryMplt *binMplt = m.GetBinMplt();
+  CHECK_FATAL(binMplt != nullptr, "Expecting a valid binMplt, found nullptr.");
+  UpdateMplt update;
+  update.UpdateCgField(*binMplt, *cg);
+  delete m.GetBinMplt();
+  m.SetBinMplt(nullptr);
+  return false;
+}
+
+void M2MUpdateMplt::GetAnalysisDependence(AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MCallGraph>();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/vtable_analysis.cpp b/src/mapleall/mpl2mpl/src/vtable_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b79a0cc4de0db222c638781cfb9d228046a1b2c9
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/vtable_analysis.cpp
@@ -0,0 +1,826 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "vtable_analysis.h"
+#include "reflection_analysis.h"
+#include "itab_util.h"
+#include "maple_phase_manager.h"
+
+namespace {
+using namespace maple;
+// +1 is needed here because our field id starts with 0 pointing to the struct itself
+constexpr uint32 kKlassItabFieldID = static_cast<uint32>(ClassProperty::kItab) + 1;
+constexpr uint32 kKlassVtabFieldID = static_cast<uint32>(ClassProperty::kVtab) + 1;
+} // namespace
+
+// Vtableanalysis
+// This phase is mainly to generate the virtual table && iterface table.
+// The virtual table just store the virtual method address. And the interface
+// table structure is a litter more complicated.we stored the hash number of methodname
+// and function address.And we also move the hot function to the front iterface
+// table.If the hash number is conflicted,we stored the whole completed methodname at the
+// end of interface table.
+namespace maple {
+VtableAnalysis::VtableAnalysis(MIRModule &mod, KlassHierarchy *kh, bool dump) : FuncOptimizeImpl(mod, kh, dump) {
+  voidPtrType = GlobalTables::GetTypeTable().GetVoidPtr();
+  // zeroConst and oneConst are shared amony itab entries. It is safe to share them because
+  // they are never removed by anybody.
+  zeroConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *voidPtrType);
+  oneConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(1, *voidPtrType);
+  for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
+    ASSERT(klass != nullptr, "null ptr check!");
+    GenVtableList(*klass);
+    if (klass->IsClass() && klass->GetMIRStructType()->IsLocal()) {
+      // We generate itable/vtable definition in the same place where the class is defined
+      // We generate vtable of the class if DAI2.0 is off or its only superclass is object
+      if (!Options::deferredVisit2) {
+        GenVtableDefinition(*klass);
+        GenItableDefinition(*klass);
+      } else if ((klass->GetSuperKlasses().size() == 1) &&
+                 (klass->GetSuperKlass()->GetKlassName() == namemangler::kJavaLangObjectStr)) {
+        GenVtableDefinition(*klass);
+      }
+    }
+    if (trace) {
+      DumpVtableList(*klass);
+    }
+  }
+}
+
+bool VtableAnalysis::IsVtableCandidate(const MIRFunction &func) {
+  return func.GetAttr(FUNCATTR_virtual) && !func.GetAttr(FUNCATTR_private) && !func.GetAttr(FUNCATTR_static);
+}
+
+// Return true if currMethod is more specific than baseMethod
+bool VtableAnalysis::CheckInterfaceSpecification(const Klass &baseKlass, const Klass &currKlass) const {
+  return !(klassHierarchy->IsSuperKlassForInterface(&currKlass, &baseKlass));
+}
+
+// Return true if virtual functions can be set override relationship cross package
+bool VtableAnalysis::CheckOverrideForCrossPackage(const MIRFunction &baseMethod,
+    const MIRFunction &currMethod) const {
+  const std::string &baseClassName = baseMethod.GetBaseClassName();
+  size_t basePos = baseClassName.rfind(namemangler::kPackageNameSplitterStr);
+  std::string basePackageName = (basePos != std::string::npos) ? baseClassName.substr(0, basePos) : "";
+  const std::string &currClassName = currMethod.GetBaseClassName();
+  size_t currPos = currClassName.rfind(namemangler::kPackageNameSplitterStr);
+  std::string currPackageName = (currPos != std::string::npos) ? currClassName.substr(0, currPos) : "";
+  // 1. For the cross package inheritance, only if the base func is declared
+  // as either 'public' or 'protected', we shall set override relationship.
+  // 2. For interface methods, override relationship would be set only if
+  // currMethod is more specific.
+  Klass *baseKlass = klassHierarchy->GetKlassFromFunc(&baseMethod);
+  Klass *currKlass = klassHierarchy->GetKlassFromFunc(&currMethod);
+  return ((currPackageName == basePackageName) || baseMethod.GetAttr(FUNCATTR_public) ||
+          baseMethod.GetAttr(FUNCATTR_protected)) && (CheckInterfaceSpecification(*baseKlass, *currKlass));
+}
+
+// If the method is not in method_table yet, add it in, otherwise update it.
+// Note: the method to add should already pass VtableCandidate test
+void VtableAnalysis::AddMethodToTable(MethodPtrVector &methodTable, MethodPair &methodPair) {
+  MIRFunction *method = builder->GetFunctionFromStidx(methodPair.first);
+  ASSERT_NOT_NULL(method);
+  GStrIdx strIdx = method->GetBaseFuncNameWithTypeStrIdx();
+  for (size_t i = 0; i < methodTable.size(); ++i) {
+    MIRFunction *currFunc = builder->GetFunctionFromStidx(methodTable[i]->first);
+    ASSERT_NOT_NULL(currFunc);
+    GStrIdx currStrIdx = currFunc->GetBaseFuncNameWithTypeStrIdx();
+    if (strIdx == currStrIdx) {
+      if (CheckOverrideForCrossPackage(*currFunc, *method)) {
+        methodTable[i] = &methodPair;
+        return;
+      }
+    }
+  }
+  methodTable.push_back(&methodPair);
+}
+
+void VtableAnalysis::GenVtableList(const Klass &klass) {
+  if (klass.IsInterface() || klass.IsInterfaceIncomplete()) {
+    MIRInterfaceType *iType = klass.GetMIRInterfaceType();
+    for (const Klass *parentKlass : klass.GetSuperKlasses()) {
+      MIRInterfaceType *parentInterfaceType = parentKlass->GetMIRInterfaceType();
+      for (MethodPair *methodPair : parentInterfaceType->GetVTableMethods()) {
+        ASSERT_NOT_NULL(methodPair);
+        AddMethodToTable(iType->GetVTableMethods(), *methodPair);
+      }
+    }
+    // add in methods from this interface, note it can override methods of parents
+    for (MethodPair &methodPair : iType->GetMethods()) {
+      AddMethodToTable(iType->GetVTableMethods(), methodPair);
+    }
+  } else {  // it's a class
+    MIRClassType *curType = klass.GetMIRClassType();
+    // prepare vtable_methods
+    // first is vtable from parents. since it's single inheritance, we copy it directly
+    if (klass.HasSuperKlass()) {
+      Klass *superKlass = klass.GetSuperKlass();
+      ASSERT_NOT_NULL(superKlass);
+      MIRStructType *partenType = superKlass->GetMIRStructType();
+      curType->GetVTableMethods() = partenType->GetVTableMethods();
+    }
+    // vtable from implemented interfaces, need to merge in. both default or none-default
+    // Note, all interface methods are also virtual methods, need to be in vtable too.
+    for (TyIdx tyIdx : curType->GetInterfaceImplemented()) {
+      auto *iType = static_cast<MIRInterfaceType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx));
+      for (MethodPair *methodPair : iType->GetVTableMethods()) {
+        MIRFunction *method = builder->GetFunctionFromStidx(methodPair->first);
+        GStrIdx strIdx = method->GetBaseFuncNameWithTypeStrIdx();
+        Klass *iklass = klassHierarchy->GetKlassFromFunc(method);
+        bool found = false;
+        for (size_t i = 0; i < curType->GetVTableMethods().size(); ++i) {
+          MIRFunction *curMethod = builder->GetFunctionFromStidx(curType->GetVTableMethods()[i]->first);
+          GStrIdx currStrIdx = curMethod->GetBaseFuncNameWithTypeStrIdx();
+          Klass *currKlass = klassHierarchy->GetKlassFromFunc(curMethod);
+          // Interfaces implemented methods can't override methods from parent,
+          // except the methods comes from another interface which is a parent of current interface
+          if (strIdx == currStrIdx) {
+            if (klassHierarchy->IsSuperKlassForInterface(currKlass, iklass)) {
+              curType->GetVTableMethods()[i] = methodPair;
+            }
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          curType->GetVTableMethods().push_back(methodPair);
+        }
+      }
+    }
+    // then methods defined in this class
+    for (MethodPair &methodPair : curType->GetMethods()) {
+      MIRFunction *curMethod = builder->GetFunctionFromStidx(methodPair.first);
+      ASSERT_NOT_NULL(curMethod);
+      if (IsVtableCandidate(*curMethod)) {
+        AddMethodToTable(curType->GetVTableMethods(), methodPair);
+      }
+      // Optimization: mark private methods as local
+      if (curType->IsLocal() && curMethod->IsPrivate() && !curMethod->IsConstructor()) {
+        curMethod->SetAttr(FUNCATTR_local);
+      }
+    }
+    // Create initial cached vtable mapping
+    for (size_t i = 0; i < curType->GetVTableMethods().size(); ++i) {
+      MIRFunction *curMethod = builder->GetFunctionFromStidx(curType->GetVTableMethods()[i]->first);
+      ASSERT_NOT_NULL(curMethod);
+      puidxToVtabIndex[curMethod->GetPuidx()] = i;
+    }
+  }
+}
+
+void VtableAnalysis::GenVtableDefinition(const Klass &klass) {
+  MIRStructType *curType = klass.GetMIRStructType();
+  auto *newConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *voidPtrType);
+  ASSERT_NOT_NULL(newConst);
+  for (MethodPair *methodPair : curType->GetVTableMethods()) {
+    MIRFunction *vtabMethod = builder->GetFunctionFromStidx(methodPair->first);
+    ASSERT_NOT_NULL(vtabMethod);
+    AddroffuncNode *addrofFuncNode = builder->CreateExprAddroffunc(vtabMethod->GetPuidx(),
+                                                                   GetMIRModule().GetMemPool());
+    auto *constNode = GetMIRModule().GetMemPool()->New<MIRAddroffuncConst>(addrofFuncNode->GetPUIdx(),
+                                                                           *voidPtrType);
+    newConst->AddItem(constNode, 0);
+  }
+  // We also need to generate vtable and itable even if the class does not
+  // have any virtual method, or does not implement any interface.  Such a
+  // class needs a TRIVIAL vtable, or a TRIVIAL itable, because we need to
+  // inform the OBJECT ALLOCATOR that such a class does not need any
+  // (non-trivial) vtable or itable.  One way (and the most uniform way) to
+  // convey this information is having a trivial table.  Alternatively, we can
+  // postpone this step to mplcg, where mplcg discovers all classes that does
+  // not have any vtable or itable.
+  if (newConst->GetConstVec().empty()) {
+    newConst->AddItem(zeroConst, 0);
+  }
+  GenTableSymbol(VTAB_PREFIX_STR, klass.GetKlassName(), *newConst);
+}
+
+std::string VtableAnalysis::DecodeBaseNameWithType(const MIRFunction &func) {
+  const std::string &baseName = namemangler::DecodeName(func.GetBaseFuncName());
+  std::string signatureName = namemangler::DecodeName(func.GetSignature());
+  ReflectionAnalysis::ConvertMethodSig(signatureName);
+  std::string baseNameWithType = baseName + "|" + signatureName;
+  return baseNameWithType;
+}
+
+void VtableAnalysis::GenItableDefinition(const Klass &klass) {
+  MIRStructType *curType = klass.GetMIRStructType();
+  std::set<GStrIdx> signatureVisited;
+  std::vector<MIRFunction*> firstItabVec(kItabFirstHashSize, nullptr);
+  std::vector<bool> firstConflictFlag(kItabFirstHashSize, false);
+  std::vector<MIRFunction*> firstConflictList;
+  bool itabContainsMethod = false;
+  for (Klass *implInterface : klass.GetImplInterfaces()) {
+    CHECK_FATAL(implInterface->IsInterface(), "implInterface must be interface");
+    MIRInterfaceType *interfaceType = implInterface->GetMIRInterfaceType();
+    for (MethodPair &methodPair : interfaceType->GetMethods()) {
+      MIRFunction *interfaceMethod = builder->GetFunctionFromStidx(methodPair.first);
+      ASSERT_NOT_NULL(interfaceMethod);
+      int64 hashCode = GetHashIndex(DecodeBaseNameWithType(*interfaceMethod).c_str());
+      GStrIdx interfaceMethodStridx = interfaceMethod->GetBaseFuncNameWithTypeStrIdx();
+      if (signatureVisited.find(interfaceMethodStridx) == signatureVisited.end()) {
+        signatureVisited.insert(interfaceMethodStridx);
+      } else {
+        // some interfaces own methods with same signature, cache them in order to
+        // prevent processing these methods multiple times
+        continue;
+      }
+      // Search in vtable
+      MIRFunction *vtabMethod = nullptr;
+      for (MethodPair *curMethodPair : curType->GetVTableMethods()) {
+        MIRFunction *method = builder->GetFunctionFromStidx(curMethodPair->first);
+        if (interfaceMethodStridx == method->GetBaseFuncNameWithTypeStrIdx()) {
+          vtabMethod = method;
+          break;
+        }
+      }
+      CHECK_FATAL(vtabMethod != nullptr, "Interface method %s is not implemented in class %s",
+                  interfaceMethod->GetName().c_str(), klass.GetKlassName().c_str());
+      if (!vtabMethod->IsAbstract()) {
+        itabContainsMethod = true;
+        if (!firstItabVec[hashCode] && !firstConflictFlag[hashCode]) {
+          firstItabVec[hashCode] = vtabMethod;
+        } else {  // a conflict found
+          if (!firstConflictFlag[hashCode]) {
+            // move itab element to conflict table when first conflict occurs
+            firstConflictList.push_back(firstItabVec[hashCode]);
+            firstItabVec[hashCode] = nullptr;
+            firstConflictFlag[hashCode] = true;
+          }
+          firstConflictList.push_back(vtabMethod);
+        }
+      }
+    }
+  }
+  if (!itabContainsMethod) {
+    // No need to generate itable in this case
+    return;
+  }
+  std::vector<MIRFunction*> secondItab(kItabSecondHashSize, nullptr);
+  std::vector<bool> secondConflictFlag(kItabSecondHashSize, false);
+  std::vector<MIRFunction*> secondConflictList;
+  uint64 count = 0;
+  for (MIRFunction *func : firstConflictList) {
+    ASSERT(func != nullptr, "null ptr check!");
+    uint32 secondHashCode = GetSecondHashIndex(DecodeBaseNameWithType(*func).c_str());
+    if (!secondItab[secondHashCode] && !secondConflictFlag[secondHashCode]) {
+      secondItab[secondHashCode] = func;
+      count++;
+    } else {
+      if (secondItab[secondHashCode] != nullptr) {
+        secondConflictList.push_back(secondItab[secondHashCode]);
+        secondItab[secondHashCode] = nullptr;
+        secondConflictFlag[secondHashCode] = true;
+      }
+      secondConflictList.push_back(func);
+    }
+  }
+  if (count == 0) {
+    // If no conflict exists, reduce the unnecessary zero element at the end
+    for (int i = kItabFirstHashSize - 1; i >= 0; --i) {
+      if (!firstItabVec[i] && !firstConflictFlag[i]) {
+        firstItabVec.pop_back();
+      } else {
+        break;
+      }
+    }
+  }
+  // Create the first-level itable, which is directly accessed as an array
+  auto *firstItabEmitArray = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *voidPtrType);
+  ASSERT_NOT_NULL(firstItabEmitArray);
+  for (MIRFunction *func : firstItabVec) {
+    if (func != nullptr) {
+      firstItabEmitArray->AddItem(
+        GetMIRModule().GetMemPool()->New<MIRAddroffuncConst>(func->GetPuidx(), *voidPtrType), 0);
+    } else {
+      firstItabEmitArray->AddItem(zeroConst, 0);
+    }
+  }
+  // initialize conflict solution array
+  if (count != 0) {
+    auto *secondItabEmitArray = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *voidPtrType);
+    // remember count in secondItabVec
+    count = ((secondConflictList.size() | (1ULL << (kShiftCountBit - 1))) << kShiftCountBit) + count;
+    secondItabEmitArray->AddItem(
+        GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(count), *voidPtrType),
+        0);
+    secondItabEmitArray->AddItem(oneConst, 0);  // padding
+    for (uint32 i = 0; i < kItabSecondHashSize; ++i) {
+      if (!secondItab[i] && !secondConflictFlag[i]) {
+        continue;
+      } else {
+        secondItabEmitArray->AddItem(
+            GlobalTables::GetIntConstTable().GetOrCreateIntConst(i, *voidPtrType), 0);
+        if (secondItab[i] != nullptr) {
+          secondItabEmitArray->AddItem(
+            GetMIRModule().GetMemPool()->New<MIRAddroffuncConst>(secondItab[i]->GetPuidx(), *voidPtrType), 0);
+        } else {
+          // it measn it was conflict again in the second hash
+          secondItabEmitArray->AddItem(oneConst, 0);
+        }
+      }
+    }
+    for (MIRFunction *func : secondConflictList) {
+      ASSERT_NOT_NULL(func);
+      const std::string &signatureName = DecodeBaseNameWithType(*func);
+      uint32 nameIdx = ReflectionAnalysis::FindOrInsertRepeatString(signatureName);
+      secondItabEmitArray->AddItem(
+          GlobalTables::GetIntConstTable().GetOrCreateIntConst(nameIdx, *voidPtrType), 0);
+      secondItabEmitArray->AddItem(
+          GetMIRModule().GetMemPool()->New<MIRAddroffuncConst>(func->GetPuidx(), *voidPtrType), 0);
+    }
+    // Create the second-level itable, in which hashcode is looked up by binary searching
+    GenTableSymbol(ITAB_CONFLICT_PREFIX_STR, klass.GetKlassName(), *secondItabEmitArray);
+    // push the conflict symbol to the first-level itable
+    StIdx symIdx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(ITAB_CONFLICT_PREFIX_STR + klass.GetKlassName()));
+    firstItabEmitArray->AddItem(GetMIRModule().GetMemPool()->New<MIRAddrofConst>(symIdx, 0, *voidPtrType), 0);
+  }
+  GenTableSymbol(ITAB_PREFIX_STR, klass.GetKlassName(), *firstItabEmitArray);
+}
+
+void VtableAnalysis::GenTableSymbol(const std::string &prefix, const std::string klassName,
+                                    MIRAggConst &newConst) const {
+  size_t arraySize = newConst.GetConstVec().size();
+  MIRArrayType *arrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*voidPtrType, arraySize);
+  MIRSymbol *vtabSt = builder->CreateGlobalDecl(prefix + klassName, *arrayType);
+  if (klassName == namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr)) {
+    vtabSt->SetStorageClass(kScGlobal);
+  } else {
+    vtabSt->SetStorageClass(kScFstatic);
+  }
+  vtabSt->SetKonst(&newConst);
+}
+
+void VtableAnalysis ::DumpVtableList(const Klass &klass) const {
+  LogInfo::MapleLogger() << "=========" << klass.GetKlassName() << "========\n";
+  for (MethodPair *vtableMethod : klass.GetMIRStructType()->GetVTableMethods()) {
+    MIRFunction *method = builder->GetFunctionFromStidx(vtableMethod->first);
+    ASSERT_NOT_NULL(method);
+    LogInfo::MapleLogger() << method->GetName() << "\n";
+  }
+}
+
+// add Null-Point-Exception check
+void VtableAnalysis::AddNullPointExceptionCheck(MIRFunction &func, StmtNode &stmt) const {
+  CallNode *cNode = static_cast<CallNode*>(&stmt);
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(cNode->GetPUIdx());
+  if (!callee->IsStatic() && !callee->GetBaseClassName().empty()) {
+    BaseNode *inputOpnd = cNode->Opnd(0);
+    UnaryStmtNode *nullCheck = builder->CreateStmtUnary(OP_assertnonnull, inputOpnd);
+    func.GetBody()->InsertBefore(&stmt, nullCheck);
+  }
+}
+
+// Get puIdx of the method MethodHandles::lookup
+static PUIdx GetPUIdxOfMethodHandelsLookup() {
+  const GStrIdx &nameStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(
+      "Ljava_2Flang_2Finvoke_2FMethodHandles_3B_7Clookup_7C_28_29Ljava_2Flang_2Finvoke_2FMethodHandles_24Lookup_3B");
+  if (nameStrIdx == 0) {
+    return 0;
+  }
+  const auto *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(nameStrIdx);
+  if (funcSt == nullptr || funcSt->GetFunction() == nullptr) {
+    return 0;
+  }
+  return funcSt->GetFunction()->GetPuidx();
+}
+
+static void IdentifyCallerSensitive(const StmtNode &stmt, MIRFunction &func) {
+  Opcode op = stmt.GetOpCode();
+  if (op != OP_callassigned) {
+    return;
+  }
+
+  static const PUIdx puIdx = GetPUIdxOfMethodHandelsLookup();
+  if (puIdx == static_cast<const CallNode&>(stmt).GetPUIdx()) {
+    func.SetAttr(FUNCATTR_callersensitive);
+  }
+}
+
+// Get puIdx of the method String::intern
+static PUIdx GetPUIdxOfMethodStringIntern() {
+  const GStrIdx &nameStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(
+      "Ljava_2Flang_2FString_3B_7Cintern_7C_28_29Ljava_2Flang_2FString_3B");
+  if (nameStrIdx == 0) {
+    return 0;
+  }
+  const auto *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(nameStrIdx);
+  if (funcSt == nullptr || funcSt->GetFunction() == nullptr) {
+    return 0;
+  }
+  return funcSt->GetFunction()->GetPuidx();
+}
+
+static PUIdx GetPUIdxOfMethodStringCompareTo() {
+  const GStrIdx &nameStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(
+      "Ljava_2Flang_2FString_3B_7CcompareTo_7C_28Ljava_2Flang_2FString_3B_29I");
+  if (nameStrIdx == 0) {
+    return 0;
+  }
+  const auto *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(nameStrIdx);
+  if (funcSt == nullptr || funcSt->GetFunction() == nullptr) {
+    return 0;
+  }
+  return funcSt->GetFunction()->GetPuidx();
+}
+
+static bool ReplaceStringMethodWithNativeMethod(const StmtNode &stmt, MIRFunction &func) {
+  if (stmt.GetOpCode() != OP_virtualcallassigned) {
+    return false;
+  }
+
+  constexpr uint32 funcNumToReplace = 2;
+  const static std::array<std::string, funcNumToReplace> nativeFuncsToReplace = {
+      "Native_java_lang_String_intern__",
+      "Native_java_lang_String_compareTo__Ljava_lang_String_2"
+  };
+  const static std::array<PUIdx, funcNumToReplace> puIdxsToReplaceWith = {
+      GetPUIdxOfMethodStringIntern(), GetPUIdxOfMethodStringCompareTo()
+  };
+
+  uint32 funcId = 0;
+  for (; funcId < funcNumToReplace; ++funcId) {
+    if (static_cast<const CallNode&>(stmt).GetPUIdx() == puIdxsToReplaceWith[funcId]) {
+      break;
+    }
+  }
+  if (funcId == funcNumToReplace) {
+    return false;
+  }
+
+  auto *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdxsToReplaceWith[funcId]);
+  PUIdx puIdxOfNativeFunc = theMIRModule->GetMIRBuilder()->GetOrCreateFunction(
+      nativeFuncsToReplace[funcId], calleeFunc->GetReturnTyIdx())->GetPuidx();
+  MIRSymbol *retSym = nullptr;
+  auto &retVec = static_cast<const CallNode&>(stmt).GetReturnVec();
+  if (!retVec.empty() && !retVec.front().second.IsReg()) {
+    retSym = theMIRModule->GetMIRBuilder()->GetSymbolFromEnclosingScope(retVec.front().first);
+  }
+  auto *newCallNode = theMIRModule->GetMIRBuilder()->CreateStmtCallAssigned(
+      puIdxOfNativeFunc, static_cast<const CallNode&>(stmt).GetNopnd(), retSym, OP_callassigned);
+  func.GetBody()->ReplaceStmt1WithStmt2(&stmt, newCallNode);
+  return true;
+}
+
+void VtableAnalysis::ProcessFunc(MIRFunction *func) {
+  if (func->IsEmpty()) {
+    return;
+  }
+  SetCurrentFunction(*func);
+  StmtNode *stmt = func->GetBody()->GetFirst();
+  StmtNode *next = nullptr;
+  while (stmt != nullptr) {
+    next = stmt->GetNext();
+    switch (stmt->GetOpCode()) {
+      case OP_virtualcallassigned: {
+        if (ReplaceStringMethodWithNativeMethod(*stmt, *func)) {
+          next = next->GetPrev();
+          break;
+        }
+        ReplaceVirtualInvoke(*(static_cast<CallNode*>(stmt)));
+        break;
+      }
+      case OP_interfacecallassigned: {
+        ReplaceInterfaceInvoke(*(static_cast<CallNode*>(stmt)));
+        break;
+      }
+      case OP_superclasscallassigned: {
+        ReplaceSuperclassInvoke(*(static_cast<CallNode*>(stmt)));
+        break;
+      }
+      case OP_polymorphiccallassigned: {
+        ReplacePolymorphicInvoke(*(static_cast<CallNode*>(stmt)));
+        break;
+      }
+      case OP_call:
+      case OP_callassigned: {
+        IdentifyCallerSensitive(*stmt, *func);
+        AddNullPointExceptionCheck(*func, *stmt); // npe check
+        break;
+      }
+      default:
+        break;
+    }
+    stmt = next;
+  }
+}
+
+void VtableAnalysis::ReplaceSuperclassInvoke(CallNode &stmt) {
+  // Because the virtual method may be inherited from its parent, we need to find
+  // the actual method target.
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt.GetPUIdx());
+  Klass *klass = klassHierarchy->GetKlassFromFunc(callee);
+  if (klass == nullptr && Options::deferredVisit) {
+    return;
+  }
+
+  CHECK_FATAL(klass != nullptr, "Klass not found");
+  MapleVector<MIRFunction*> *cands = klass->GetCandidates(callee->GetBaseFuncNameWithTypeStrIdx());
+  // continue to search its implinterfaces
+  if (cands == nullptr) {
+    for (Klass *implInterface : klass->GetImplInterfaces()) {
+      cands = implInterface->GetCandidates(callee->GetBaseFuncNameWithTypeStrIdx());
+      if (cands != nullptr && !cands->empty()) {
+        break;
+      }
+    }
+  }
+  if (cands == nullptr || cands->size() == 0) {
+    if (Options::deferredVisit) {
+      return;
+    }
+    if (klass->IsClass() || klass->IsInterface()) {
+      LogInfo::MapleLogger() << "warning: func " << callee->GetName() << " is not found in SuperInvoke!" << "\n";
+      stmt.SetOpCode(OP_callassigned);
+      return;
+    }
+  }
+  CHECK_FATAL(cands != nullptr && !cands->empty(),
+              "Dependency Error: function %s cannot be found in %s or any of its superclasses/interfaces",
+              callee->GetBaseFuncNameWithType().c_str(), klass->GetKlassName().c_str());
+  MIRFunction *actualMIRFunc = cands->at(0);
+  CHECK_FATAL(actualMIRFunc != nullptr, "Can not find the implementation of %s", callee->GetName().c_str());
+  if (Options::decoupleSuper && Options::deferredVisit) {
+    // temporary solution
+    std::set<std::string> funcList = {"Landroid_2Fwidget_2FImageView_3B_7ConSizeChanged_7C_28IIII_29V"};
+    if (funcList.find(actualMIRFunc->GetName()) != funcList.end()) {
+      return;
+    }
+  }
+  stmt.SetOpCode(OP_callassigned);
+  stmt.SetPUIdx(actualMIRFunc->GetPuidx());
+  GetMIRModule().AddSuperCall(actualMIRFunc->GetName());
+}
+
+void VtableAnalysis::ReplacePolymorphicInvoke(CallNode &stmt) {
+  auto *intrinCall =
+      GetMIRModule().CurFuncCodeMemPool()->New<IntrinsiccallNode>(GetMIRModule(), OP_xintrinsiccallassigned);
+  intrinCall->SetIntrinsic(INTRN_JAVA_POLYMORPHIC_CALL);
+  intrinCall->SetNumOpnds(stmt.GetNumOpnds());
+  intrinCall->SetReturnVec(stmt.GetReturnVec());
+  intrinCall->SetNOpnd(stmt.GetNopnd());
+  currFunc->GetBody()->ReplaceStmt1WithStmt2(&stmt, intrinCall);
+}
+
+BaseNode *VtableAnalysis::GenVtabItabBaseAddr(BaseNode &obj, bool isVirtual) {
+  ASSERT_NOT_NULL(builder);
+  BaseNode *classInfoAddress = ReflectionAnalysis::GenClassInfoAddr(&obj, *builder);
+  auto *classMetadataType = static_cast<MIRStructType*>(
+      GlobalTables::GetTypeTable().GetTypeFromTyIdx(ReflectionAnalysis::GetClassMetaDataTyIdx()));
+  return builder->CreateExprIread(*voidPtrType,
+                                  *GlobalTables::GetTypeTable().GetOrCreatePointerType(*classMetadataType),
+                                  (isVirtual ? kKlassVtabFieldID : kKlassItabFieldID), classInfoAddress);
+}
+
+size_t VtableAnalysis::SearchWithoutRettype(const MIRFunction &callee, const MIRStructType &structType) const {
+  // Initilization must be < 0
+  size_t entryoffset = SIZE_MAX;
+  GStrIdx calleeSigStrIdx = callee.GetBaseFuncSigStrIdx();
+  MIRType *tmpType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(callee.GetReturnTyIdx());
+  Klass *targetKlass = nullptr;
+  bool isCalleeScalar = false;
+  if (tmpType->GetKind() == kTypePointer && tmpType->GetPrimType() == PTY_ref) {
+    auto *ptrType = (static_cast<MIRPtrType*>(tmpType))->GetPointedType();
+    targetKlass = klassHierarchy->GetKlassFromTyIdx(ptrType->GetTypeIndex());
+  } else if (tmpType->GetKind() == kTypeScalar) {
+    isCalleeScalar = true;
+  } else {
+    targetKlass = klassHierarchy->GetKlassFromTyIdx(tmpType->GetTypeIndex());
+  }
+  if (!isCalleeScalar) {
+    CHECK_FATAL(targetKlass != nullptr, "null ptr check");
+  }
+  Klass *curKlass = nullptr;
+  bool isCurrVtabScalar = false;
+  bool isFindMethod = false;
+  for (size_t id = 0; id < structType.GetVTableMethodsSize(); ++id) {
+    MIRFunction *vtableMethod = builder->GetFunctionFromStidx(structType.GetVTableMethodsElemt(id)->first);
+    ASSERT_NOT_NULL(vtableMethod);
+    if (calleeSigStrIdx == vtableMethod->GetBaseFuncSigStrIdx()) {
+      MIRType *tmpVtabType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(vtableMethod->GetReturnTyIdx());
+      Klass *tmpKlass = nullptr;
+      if (tmpVtabType->GetKind() == kTypePointer && tmpVtabType->GetPrimType() == PTY_ref) {
+        auto *tmpPtrType = (static_cast<MIRPtrType*>(tmpVtabType))->GetPointedType();
+        tmpKlass = klassHierarchy->GetKlassFromTyIdx(tmpPtrType->GetTypeIndex());
+      } else if (tmpVtabType->GetKind() == kTypeScalar) {
+        isCurrVtabScalar = true;
+      } else {
+        tmpKlass = klassHierarchy->GetKlassFromTyIdx(tmpVtabType->GetTypeIndex());
+      }
+      if (!isCurrVtabScalar) {
+        CHECK_FATAL(tmpKlass != nullptr, "null ptr check");
+      }
+      if (isCalleeScalar || isCurrVtabScalar) {
+        if (isFindMethod) {
+          CHECK_FATAL(klassHierarchy->GetKlassFromTyIdx(structType.GetTypeIndex()) != nullptr, "null ptr check");
+          LogInfo::MapleLogger() << "warning: this "
+                                 << (klassHierarchy->GetKlassFromTyIdx(structType.GetTypeIndex()))->GetKlassName()
+                                 << " has mult methods with the same function name but with different return type!\n";
+          break;
+        }
+        entryoffset = id;
+        isFindMethod = true;
+        continue;
+      }
+      CHECK_FATAL(targetKlass != nullptr, "null ptr check");
+      if (targetKlass->IsClass() && klassHierarchy->IsSuperKlass(tmpKlass, targetKlass) &&
+          (curKlass == nullptr || klassHierarchy->IsSuperKlass(curKlass, tmpKlass))) {
+        curKlass = tmpKlass;
+        entryoffset = id;
+      }
+      if (targetKlass->IsClass() && klassHierarchy->IsInterfaceImplemented(tmpKlass, targetKlass)) {
+        entryoffset = id;
+        break;
+      }
+      if (!targetKlass->IsClass()) {
+        CHECK_FATAL(tmpKlass != nullptr, "null ptr check");
+        if (tmpKlass->IsClass() && klassHierarchy->IsInterfaceImplemented(targetKlass, tmpKlass) &&
+            (curKlass == nullptr || klassHierarchy->IsSuperKlass(curKlass, tmpKlass))) {
+          curKlass = tmpKlass;
+          entryoffset = id;
+        }
+        if (!tmpKlass->IsClass() && klassHierarchy->IsSuperKlassForInterface(tmpKlass, targetKlass) &&
+            (curKlass == nullptr || klassHierarchy->IsSuperKlass(curKlass, tmpKlass))) {
+          curKlass = tmpKlass;
+          entryoffset = id;
+        }
+      }
+    }
+  }
+  return entryoffset;
+}
+
+void VtableAnalysis::ReplaceVirtualInvoke(CallNode &stmt) {
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt.GetPUIdx());
+  CHECK_FATAL(callee->GetParamSize() != 0, "container check");
+  auto *firstFormalArgType = static_cast<MIRPtrType*>(callee->GetNthParamType(0));
+  MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(firstFormalArgType->GetPointedTyIdx());
+  MIRStructType *structType = nullptr;
+  if (pointedType->GetKind() == kTypeJArray) {
+    structType = static_cast<MIRJarrayType*>(pointedType)->GetParentType();
+  } else {
+    Klass *klassFromFuncDependCallee = klassHierarchy->GetKlassFromFunc(callee);
+    const std::string &missingClassName = GlobalTables::GetStrTable().GetStringFromStrIdx(pointedType->GetNameStrIdx());
+    if (klassFromFuncDependCallee == nullptr) {
+      if (Options::deferredVisit) {
+        return;
+      }
+      currFunc->GetBody()->RemoveStmt(&stmt);
+      return;
+    }
+    CHECK_FATAL(klassFromFuncDependCallee != nullptr, "Error: missing class %s", missingClassName.c_str());
+    structType = klassFromFuncDependCallee->GetMIRStructType();
+  }
+  size_t entryOffset = SIZE_MAX;
+  if (puidxToVtabIndex.find(stmt.GetPUIdx()) != puidxToVtabIndex.end() && puidxToVtabIndex[stmt.GetPUIdx()] >= 0) {
+    entryOffset = puidxToVtabIndex[stmt.GetPUIdx()];
+  } else {
+    GStrIdx calleeStridx = callee->GetBaseFuncNameWithTypeStrIdx();
+    ASSERT(structType != nullptr, "null ptr check!");
+    for (size_t id = 0; id < structType->GetVTableMethods().size(); ++id) {
+      MIRFunction *vtableMethod = builder->GetFunctionFromStidx(structType->GetVTableMethods()[id]->first);
+      ASSERT(vtableMethod != nullptr, "null ptr check!");
+      if (calleeStridx == vtableMethod->GetBaseFuncNameWithTypeStrIdx()) {
+        entryOffset = id;
+        puidxToVtabIndex[callee->GetPuidx()] = id;
+        break;
+      }
+    }
+    // If full match function can't be found, try to ignore type of return value
+    if (entryOffset == SIZE_MAX) {
+      if (Options::deferredVisit) {
+        return;
+      }
+      entryOffset = SearchWithoutRettype(*callee, *structType);
+    }
+    // Add this check for the thirdparty APP compile
+    if (entryOffset == SIZE_MAX) {
+      Klass *parentKlass = klassHierarchy->GetKlassFromName(callee->GetBaseClassName());
+      CHECK_FATAL(parentKlass != nullptr, "nullptr check.");
+      bool flag = false;
+      Klass *currKlass = klassHierarchy->GetKlassFromTyIdx(structType->GetTypeIndex());
+      CHECK_FATAL(currKlass != nullptr, "nullptr check.");
+      if (parentKlass->GetKlassName() == currKlass->GetKlassName()) {
+        flag = true;
+      } else {
+        for (Klass * const &superClass : currKlass->GetSuperKlasses()) {
+          if (parentKlass->GetKlassName() == superClass->GetKlassName()) {
+            flag = true;
+            break;
+          }
+        }
+        if (!flag && parentKlass->IsInterface()) {
+          for (Klass * const &implClass : currKlass->GetImplKlasses()) {
+            if (parentKlass->GetKlassName() == implClass->GetKlassName()) {
+              flag = true;
+              break;
+            }
+          }
+        }
+      }
+      if (!flag) {
+        LogInfo::MapleLogger() << "warning: func " << callee->GetName() << " is not found in DeVirtual!\n";
+        LogInfo::MapleLogger() << "warning: " << callee->GetBaseClassName() << " is not the parent of "
+                               << currKlass->GetKlassName() << "\n";
+      }
+    }
+    if (entryOffset == SIZE_MAX && (structType->GetKind() == kTypeInterface || structType->GetKind() == kTypeClass)) {
+      CHECK_FATAL(klassHierarchy->GetKlassFromTyIdx(structType->GetTypeIndex()) != nullptr, "null ptr check");
+      LogInfo::MapleLogger() << "warning: func " << callee->GetName() << " is not found in "
+                             << (klassHierarchy->GetKlassFromTyIdx(structType->GetTypeIndex()))->GetKlassName()
+                             << " in VirtualCall!" << "\n";
+      if (Options::deferredVisit) {
+        return;
+      }
+      stmt.SetOpCode(OP_callassigned);
+      return;
+    }
+    CHECK_FATAL(entryOffset != SIZE_MAX,
+                "Error: method for virtual call cannot be found in all included mplt files. Call to %s in %s",
+                callee->GetName().c_str(), currFunc->GetName().c_str());
+  }
+  BaseNode *offsetNode = builder->CreateIntConst(entryOffset * kTabEntrySize, PTY_u32);
+  CHECK_FATAL(!stmt.GetNopnd().empty(), "container check");
+  BaseNode *tabBaseAddress = GenVtabItabBaseAddr(*stmt.GetNopndAt(0), true);
+  BaseNode *addrNode =
+      builder->CreateExprBinary(OP_add, *GlobalTables::GetTypeTable().GetPtr(), tabBaseAddress, offsetNode);
+  BaseNode *readFuncPtr = builder->CreateExprIread(
+      *GlobalTables::GetTypeTable().GetCompactPtr(),
+      *GlobalTables::GetTypeTable().GetOrCreatePointerType(*GlobalTables::GetTypeTable().GetCompactPtr()), 0, addrNode);
+  stmt.SetOpCode(OP_virtualicallassigned);
+  stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(), readFuncPtr);
+  stmt.SetNumOpnds(stmt.GetNumOpnds() + 1);
+}
+
+bool VtableAnalysis::CheckInterfaceImplemented(const CallNode &stmt) const {
+  GStrIdx calleeMethodStrIdx =
+    (GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt.GetPUIdx()))->GetBaseFuncNameWithTypeStrIdx();
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt.GetPUIdx());
+  Klass *klassFromFuncDependCallee = klassHierarchy->GetKlassFromFunc(callee);
+  if (klassFromFuncDependCallee == nullptr) {
+    return false;
+  }
+  std::queue<Klass*> klassList;
+  klassList.push(klassFromFuncDependCallee);
+  while (!klassList.empty()) {
+    Klass *currentKlass = klassList.front();
+    klassList.pop();
+    for (Klass *parentKlass : currentKlass->GetSuperKlasses()) {
+      if (parentKlass != nullptr) {
+        klassList.push(parentKlass);
+      }
+    }
+    if (currentKlass->IsClass() || currentKlass->IsClassIncomplete()) {
+      continue;
+    }
+    MIRInterfaceType *interfaceType = currentKlass->GetMIRInterfaceType();
+    for (MethodPair &imethodPair : interfaceType->GetMethods()) {
+      MIRFunction *interfaceMethod = builder->GetFunctionFromStidx(imethodPair.first);
+      ASSERT_NOT_NULL(interfaceMethod);
+      GStrIdx interfaceMethodStrIdx = interfaceMethod->GetBaseFuncNameWithTypeStrIdx();
+      if (interfaceMethodStrIdx == calleeMethodStrIdx) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void VtableAnalysis::ReplaceInterfaceInvoke(CallNode &stmt) {
+  CHECK_FATAL(!stmt.GetNopnd().empty(), "container check");
+  if (Options::deferredVisit && !CheckInterfaceImplemented(stmt)) {
+    return;
+  }
+  BaseNode *tabBaseAddress = GenVtabItabBaseAddr(*stmt.GetNopndAt(0), false);
+  MemPool *currentFuncMp = builder->GetCurrentFuncCodeMp();
+  ASSERT_NOT_NULL(currentFuncMp);
+  auto *resolveNode = currentFuncMp->New<ResolveFuncNode>(
+      OP_resolveinterfacefunc, GlobalTables::GetTypeTable().GetCompactPtr()->GetPrimType(), stmt.GetPUIdx(),
+      tabBaseAddress, tabBaseAddress->Opnd(0));
+  stmt.SetOpCode(OP_interfaceicallassigned);
+  stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(), resolveNode);
+  stmt.SetNumOpnds(stmt.GetNumOpnds() + 1);
+}
+
+bool M2MVtableAnalysis::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(VtableAnalysis, m)
+  return true;
+}
+
+void M2MVtableAnalysis::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/mpl2mpl/src/vtable_impl.cpp b/src/mapleall/mpl2mpl/src/vtable_impl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e05c406521e6a38087e523425cab1adbc1fd131
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/vtable_impl.cpp
@@ -0,0 +1,526 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "vtable_impl.h"
+#include "vtable_analysis.h"
+#include "itab_util.h"
+#include "reflection_analysis.h"
+#include "maple_phase_manager.h"
+
+// This phase is mainly to lower interfacecall into icall
+namespace {
+constexpr int kNumOfMCCParas = 5;
+#if USE_ARM32_MACRO
+constexpr char kInterfaceMethod[] = "MCC_getFuncPtrFromItabSecondHash32";
+#elif USE_32BIT_REF
+constexpr char kInterfaceMethod[] = "MCC_getFuncPtrFromItab";
+#else
+constexpr char kInterfaceMethod[] = "MCC_getFuncPtrFromItabSecondHash64";
+#endif
+} // namespace
+
+namespace maple {
+VtableImpl::VtableImpl(MIRModule &mod, KlassHierarchy *kh, bool dump)
+    : FuncOptimizeImpl(mod, kh, dump), mirModule(&mod), klassHierarchy(kh) {
+  mccItabFunc = builder->GetOrCreateFunction(kInterfaceMethod, TyIdx(PTY_ptr));
+  mccItabFunc->SetAttr(FUNCATTR_nosideeffect);
+}
+#if defined(TARGARM) || defined(TARGAARCH64) || defined(TARGRISCV64)
+bool VtableImpl::Intrinsify(MIRFunction &func, CallNode &cnode) {
+  MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(cnode.GetPUIdx());
+  const std::string funcName = calleeFunc->GetName();
+  MIRIntrinsicID intrnId = INTRN_UNDEFINED;
+  if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndAddInt_7C_28Ljava_2Flang_2FObject_3BJI_29I") {
+    intrnId = INTRN_GET_AND_ADDI;
+  } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndAddLong_7C_28Ljava_2Flang_2FObject_3BJJ_29J") {
+    intrnId = INTRN_GET_AND_ADDL;
+  } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndSetInt_7C_28Ljava_2Flang_2FObject_3BJI_29I") {
+    intrnId = INTRN_GET_AND_SETI;
+  } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndSetLong_7C_28Ljava_2Flang_2FObject_3BJJ_29J") {
+    intrnId = INTRN_GET_AND_SETL;
+  } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapInt_7C_28Ljava_2Flang_2FObject_3BJII_29Z") {
+    intrnId = INTRN_COMP_AND_SWAPI;
+  } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapLong_7C_28Ljava_2Flang_2FObject_3BJJJ_29Z") {
+    intrnId = INTRN_COMP_AND_SWAPL;
+  }
+  if (intrnId == INTRN_UNDEFINED) {
+    return false;
+  }
+  CallReturnVector retvs = cnode.GetReturnVec();
+  if (!retvs.empty()) {
+    StIdx stidx = retvs.begin()->first;
+    StmtNode *intrnCallStmt = nullptr;
+    if (cnode.Opnd(0)->GetOpCode() == OP_iread) {
+      for (size_t i = 0; i < cnode.GetNopndSize() - 1; ++i) {
+        cnode.SetNOpndAt(i, cnode.GetNopnd().at(i + 1));
+      }
+      cnode.SetNumOpnds(static_cast<uint8>(cnode.GetNumOpnds() - 1));
+      cnode.GetNopnd().resize(cnode.GetNumOpnds());
+    }
+    if (stidx.Idx() != 0) {
+      MIRSymbol *retSt = currFunc->GetLocalOrGlobalSymbol(stidx);
+      intrnCallStmt = builder->CreateStmtIntrinsicCallAssigned(intrnId, cnode.GetNopnd(), retSt);
+    } else {
+      ASSERT (retvs.begin()->second.IsReg(), "return value must be preg");
+      PregIdx pregIdx = retvs.begin()->second.GetPregIdx();
+      intrnCallStmt = builder->CreateStmtIntrinsicCallAssigned(intrnId, cnode.GetNopnd(), pregIdx);
+    }
+    func.GetBody()->ReplaceStmt1WithStmt2(&cnode, intrnCallStmt);
+    return true;
+  }
+  return false;
+}
+#endif
+void VtableImpl::ProcessFunc(MIRFunction *func) {
+  if (func->IsEmpty()) {
+    return;
+  }
+  SetCurrentFunction(*func);
+  StmtNode *stmt = func->GetBody()->GetFirst();
+  StmtNode *next = nullptr;
+  while (stmt != nullptr) {
+    next = stmt->GetNext();
+    Opcode opcode = stmt->GetOpCode();
+#if defined(TARGARM) || defined(TARGAARCH64) || defined(TARGRISCV64)
+    if (kOpcodeInfo.IsCallAssigned(opcode)) {
+      CallNode *cnode = static_cast<CallNode*>(stmt);
+      MIRFunction *calleefunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(cnode->GetPUIdx());
+      const std::set<std::string> intrisicsList {
+#define DEF_MIR_INTRINSIC(X, NAME, NUM_INSN, INTRN_CLASS, RETURN_TYPE, ...) NAME,
+#include "simplifyintrinsics.def"
+#undef DEF_MIR_INTRINSIC
+      };
+      const std::string funcName = calleefunc->GetName();
+      if (!Options::buildApp && Options::O2 && intrisicsList.find(funcName) != intrisicsList.end() &&
+          funcName != "Ljava_2Flang_2FString_3B_7CindexOf_7C_28Ljava_2Flang_2FString_3B_29I") {
+        if (Intrinsify(*func, *cnode)) {
+          stmt = next;
+          continue;
+        }
+      }
+    }
+#endif /* TARGARM || TARGAARCH64 */
+    switch (opcode) {
+      case OP_regassign: {
+        auto *regassign = static_cast<RegassignNode*>(stmt);
+        BaseNode *rhs = regassign->Opnd(0);
+        ASSERT_NOT_NULL(rhs);
+        if (rhs->GetOpCode() == OP_resolveinterfacefunc) {
+          ReplaceResolveInterface(*stmt, *(static_cast<ResolveFuncNode*>(rhs)));
+        }
+        break;
+      }
+      case OP_interfaceicallassigned:
+      case OP_virtualicallassigned: {
+        auto *callNode = static_cast<CallNode*>(stmt);
+        MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+        MemPool *currentFuncCodeMempool = builder->GetCurrentFuncCodeMp();
+        IcallNode *icallNode =
+            currentFuncCodeMempool->New<IcallNode>(*builder->GetCurrentFuncCodeMpAllocator(), OP_icallassigned);
+        icallNode->SetReturnVec(callNode->GetReturnVec());
+        icallNode->SetRetTyIdx(callee->GetReturnTyIdx());
+        icallNode->SetSrcPos(callNode->GetSrcPos());
+        icallNode->GetNopnd().resize(callNode->GetNopndSize());
+        icallNode->SetNumOpnds(icallNode->GetNopndSize());
+        for (size_t i = 0; i < callNode->GetNopndSize(); ++i) {
+          icallNode->SetOpnd(callNode->GetNopndAt(i)->CloneTree(mirModule->GetCurFuncCodeMPAllocator()), i);
+        }
+        currFunc->GetBody()->ReplaceStmt1WithStmt2(stmt, icallNode);
+        stmt = icallNode;
+        // Fall-through
+      }
+      [[clang::fallthrough]];
+      case OP_icallassigned: {
+        auto *icall = static_cast<IcallNode*>(stmt);
+        BaseNode *firstParm = icall->GetNopndAt(0);
+        ASSERT_NOT_NULL(firstParm);
+        if (firstParm->GetOpCode() == maple::OP_resolveinterfacefunc) {
+          ReplaceResolveInterface(*stmt, *(static_cast<ResolveFuncNode*>(firstParm)));
+        }
+        break;
+      }
+      case OP_virtualcall:
+      case OP_virtualcallassigned: {
+        if (Options::deferredVisit) {
+          DeferredVisit(*(static_cast<CallNode*>(stmt)), CallKind::kVirtualCall);
+        } else {
+          CHECK_FATAL(false, "VtableImpl::ProcessFunc does not expect to see virtucalcall");
+        }
+        break;
+      }
+      case OP_callassigned: {
+        if (Options::deferredVisit) {
+          // When open the decouple static, let the decouple resolve this case.
+          if (Options::decoupleStatic) {
+            break;
+          }
+          auto *callNode = static_cast<CallNode*>(stmt);
+          MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+          if (!calleeFunc->IsJava() && calleeFunc->GetBaseClassName().empty()) {
+            break;
+          }
+          Klass *calleeKlass = klassHierarchy->GetKlassFromFunc(calleeFunc);
+          if (calleeKlass == nullptr || (calleeKlass->GetMIRStructType()->IsLocal() && !calleeFunc->GetBody()) ||
+              calleeKlass->GetMIRStructType()->IsIncomplete()) {
+            DeferredVisit(*(static_cast<CallNode*>(stmt)), CallKind::kStaticCall);
+          }
+        }
+        break;
+      }
+      case OP_interfacecall:
+      case OP_interfacecallassigned: {
+        if (Options::deferredVisit) {
+          DeferredVisit(*(static_cast<CallNode*>(stmt)), CallKind::kVirtualCall);
+        } else {
+          ASSERT(false, "VtableImpl::ProcessFunc does not expect to see interfacecall");
+        }
+        break;
+      }
+      case OP_superclasscallassigned: {
+        if (!Options::deferredVisit) {
+          CHECK_FATAL(false, "deferredVisit is not be opened, supercallassigned can't be processed");
+        }
+        auto *callNode = static_cast<CallNode*>(stmt);
+        MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
+        if (!calleeFunc->IsJava() && calleeFunc->GetBaseClassName().empty()) {
+          std::cerr << "Error func: " << calleeFunc->GetName() << " "
+                    <<  "supercallassigned can't be processed" << std::endl;
+          CHECK_FATAL(false, "supercallassigned can't be processed");
+        }
+        Klass *calleeKlass = klassHierarchy->GetKlassFromFunc(calleeFunc);
+        CHECK_FATAL(calleeKlass != nullptr, "calleeKlass is nullptr in VtableImpl::ProcessFunc!");
+        DeferredVisit(*(static_cast<CallNode*>(stmt)), CallKind::kSuperCall);
+        break;
+      }
+      default:
+        break;
+    }
+    stmt = next;
+  }
+  if (trace) {
+    func->Dump(false);
+  }
+}
+
+void VtableImpl::DeferredVisit(CallNode &stmt, enum CallKind kind) {
+  MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt.GetPUIdx());
+  MemPool *currentFunMp = builder->GetCurrentFuncCodeMp();
+  std::string mplClassName = mirFunc->GetBaseClassName();
+  std::string mrtClassName;
+  namemangler::DecodeMapleNameToJavaDescriptor(mplClassName, mrtClassName);
+  const std::string &funcName = namemangler::DecodeName(mirFunc->GetBaseFuncName());
+  std::string sigName = namemangler::DecodeName(mirFunc->GetSignature());
+  ReflectionAnalysis::ConvertMethodSig(sigName);
+  UStrIdx classNameStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(mrtClassName);
+  CHECK_NULL_FATAL(currentFunMp);
+  ConststrNode *classNameNode = currentFunMp->New<ConststrNode>(classNameStrIdx);
+  UStrIdx funcNameStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(funcName);
+  ConststrNode *funcNameNode = currentFunMp->New<ConststrNode>(funcNameStrIdx);
+  UStrIdx sigNameStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(sigName);
+  ConststrNode *sigNameNode = currentFunMp->New<ConststrNode>(sigNameStrIdx);
+  classNameNode->SetPrimType(PTY_ptr);
+  funcNameNode->SetPrimType(PTY_ptr);
+  sigNameNode->SetPrimType(PTY_ptr);
+  if (kind == CallKind::kStaticCall && mirFunc->IsStatic()) {
+    const std::string &classinfoName = CLASSINFO_PREFIX_STR + currFunc->GetBaseClassName();
+    MIRType *classInfoType =
+        GlobalTables::GetTypeTable().GetOrCreateClassType(namemangler::kClassMetadataTypeName, *mirModule);
+    MIRSymbol *classInfoSt = mirModule->GetMIRBuilder()->GetOrCreateGlobalDecl(classinfoName, *classInfoType);
+    (void)stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(),
+                                 mirModule->GetMIRBuilder()->CreateExprAddrof(0, *classInfoSt));
+    stmt.numOpnds++;
+  }
+  (void)stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(), sigNameNode);
+  (void)stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(), funcNameNode);
+  (void)stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(), classNameNode);
+  if (kind == CallKind::kStaticCall) {
+    (void)stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(), builder->CreateIntConst(CallKind::kStaticCall, PTY_u64));
+  } else if (kind == CallKind::kVirtualCall) {
+    (void)stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(), builder->CreateIntConst(CallKind::kVirtualCall, PTY_u64));
+  } else if (kind == CallKind::kSuperCall) {
+    (void)stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(), builder->CreateIntConst(CallKind::kSuperCall, PTY_u64));
+  }
+  stmt.GetNopnd().insert(stmt.GetNopnd().cbegin(), builder->CreateIntConst(0, PTY_u64));
+  stmt.SetNumOpnds(stmt.GetNumOpnds() + kNumOfMCCParas);
+  stmt.SetOpCode(OP_callassigned);
+  MIRFunction *mccFunc = builder->GetOrCreateFunction("MCC_DeferredInvoke", mirFunc->GetReturnTyIdx());
+  stmt.SetPUIdx(mccFunc->GetPuidx());
+  DeferredVisitCheckFloat(stmt, *mirFunc);
+}
+
+void VtableImpl::DeferredVisitCheckFloat(CallNode &stmt, const MIRFunction &mirFunc) {
+  if (!stmt.GetReturnVec().empty() && mirFunc.GetReturnTyIdx() == PTY_f32) {
+    if (stmt.GetReturnVec().begin()->second.IsReg()) {
+      PregIdx returnIdx = stmt.GetReturnVec().begin()->second.GetPregIdx();
+      PregIdx newPregReturn = currFunc->GetPregTab()->CreatePreg(PTY_i32);
+      stmt.GetReturnVec().begin()->second.SetPregIdx(newPregReturn);
+      BaseNode *baseExpr = builder->CreateExprRetype(*GlobalTables::GetTypeTable().GetFloat(),
+                                                     *GlobalTables::GetTypeTable().GetInt32(),
+                                                     builder->CreateExprRegread(PTY_i32, newPregReturn));
+      RegassignNode *regAssignNode = builder->CreateStmtRegassign(PTY_f32, returnIdx, baseExpr);
+      currFunc->GetBody()->InsertAfter(&stmt, regAssignNode);
+    } else {
+      MIRSymbol *retSymbol = currFunc->GetSymTab()->GetSymbolFromStIdx(stmt.GetReturnVec()[0].first.Idx());
+      ASSERT_NOT_NULL(retSymbol);
+      MIRSymbol *newSymbol = builder->CreateSymbol(GlobalTables::GetTypeTable().GetInt32()->GetTypeIndex(),
+                                                   retSymbol->GetName() + "_def", retSymbol->GetSKind(),
+                                                   retSymbol->GetStorageClass(), currFunc, retSymbol->GetScopeIdx());
+      stmt.GetReturnVec()[0].first = newSymbol->GetStIdx();
+      AddrofNode *dreadNode =
+          builder->CreateDread(*currFunc->GetSymTab()->GetSymbolFromStIdx(stmt.GetReturnVec()[0].first.Idx()), PTY_i32);
+      MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+      args.push_back(dreadNode);
+      IntrinsicopNode *mergeNode = builder->CreateExprIntrinsicop(INTRN_JAVA_MERGE, OP_intrinsicop,
+                                                                  *GlobalTables::GetTypeTable().GetFloat(), args);
+      DassignNode *dassignNode = builder->CreateStmtDassign(*retSymbol, 0, mergeNode);
+      currFunc->GetBody()->InsertAfter(&stmt, dassignNode);
+    }
+  } else if (!stmt.GetReturnVec().empty() && mirFunc.GetReturnTyIdx() == PTY_f64) {
+    if (stmt.GetReturnVec().begin()->second.IsReg()) {
+      PregIdx returnIdx = stmt.GetReturnVec().begin()->second.GetPregIdx();
+      PregIdx newPregReturn = currFunc->GetPregTab()->CreatePreg(PTY_i64);
+      stmt.GetReturnVec().begin()->second.SetPregIdx(newPregReturn);
+      BaseNode *baseExpr = builder->CreateExprRetype(*GlobalTables::GetTypeTable().GetDouble(),
+                                                     *GlobalTables::GetTypeTable().GetInt64(),
+                                                     builder->CreateExprRegread(PTY_i64, newPregReturn));
+      RegassignNode *regAssignNode = builder->CreateStmtRegassign(PTY_f64, returnIdx, baseExpr);
+      currFunc->GetBody()->InsertAfter(&stmt, regAssignNode);
+    } else {
+      MIRSymbol *retSymbol = currFunc->GetSymTab()->GetSymbolFromStIdx(stmt.GetReturnVec()[0].first.Idx());
+      ASSERT_NOT_NULL(retSymbol);
+      MIRSymbol *newSymbol = builder->CreateSymbol(GlobalTables::GetTypeTable().GetInt64()->GetTypeIndex(),
+                                                   retSymbol->GetName() + "_def", retSymbol->GetSKind(),
+                                                   retSymbol->GetStorageClass(), currFunc, retSymbol->GetScopeIdx());
+      stmt.GetReturnVec()[0].first = newSymbol->GetStIdx();
+      AddrofNode *dreadNode =
+          builder->CreateDread(*currFunc->GetSymTab()->GetSymbolFromStIdx(stmt.GetReturnVec()[0].first.Idx()),
+                               PTY_i64);
+      MapleVector<BaseNode*> args(builder->GetCurrentFuncCodeMpAllocator()->Adapter());
+      args.push_back(dreadNode);
+      IntrinsicopNode *mergeNode = builder->CreateExprIntrinsicop(INTRN_JAVA_MERGE, OP_intrinsicop,
+                                                                  *GlobalTables::GetTypeTable().GetFloat(), args);
+      DassignNode *dassignNode = builder->CreateStmtDassign(*retSymbol, 0, mergeNode);
+      currFunc->GetBody()->InsertAfter(&stmt, dassignNode);
+    }
+  }
+}
+
+void VtableImpl::ReplaceResolveInterface(StmtNode &stmt, const ResolveFuncNode &resolveNode) {
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(resolveNode.GetPuIdx());
+  std::string signature = VtableAnalysis::DecodeBaseNameWithType(*func);
+  MIRType *compactPtrType = GlobalTables::GetTypeTable().GetCompactPtr();
+  PrimType compactPtrPrim = compactPtrType->GetPrimType();
+  PregIdx pregFuncPtr = currFunc->GetPregTab()->CreatePreg(compactPtrPrim);
+
+#ifndef USE_ARM32_MACRO
+#ifdef USE_32BIT_REF
+  if (Options::inlineCache == 1) {
+    InlineCacheProcess(stmt, resolveNode, signature, pregFuncPtr);
+  } else {
+    ItabProcess(stmt, resolveNode, signature, pregFuncPtr, *compactPtrType, compactPtrPrim);
+  }
+#else  // ~USE_32BIT_REF
+  ItabProcess(stmt, resolveNode, signature, pregFuncPtr, *compactPtrType, compactPtrPrim);
+#endif  // ~USE_32BIT_REF
+#else  // ~USE_ARM32_MACRO
+  ItabProcess(stmt, resolveNode, signature, pregFuncPtr, *compactPtrType, compactPtrPrim);
+#endif  // ~USE_ARM32_MACRO
+
+  if (stmt.GetOpCode() == OP_regassign) {
+    auto *regAssign = static_cast<RegassignNode*>(&stmt);
+    regAssign->SetOpnd(builder->CreateExprRegread(compactPtrPrim, pregFuncPtr), 0);
+  } else {
+    auto *icall = static_cast<IcallNode*>(&stmt);
+    const size_t nopndSize = icall->GetNopndSize();
+    CHECK_FATAL(nopndSize > 0, "container check");
+    icall->SetNOpndAt(0, builder->CreateExprRegread(compactPtrPrim, pregFuncPtr));
+  }
+}
+
+void VtableImpl::ItabProcess(const StmtNode &stmt, const ResolveFuncNode &resolveNode, const std::string &signature,
+                             const PregIdx &pregFuncPtr, const MIRType &compactPtrType,
+                             const PrimType &compactPtrPrim) {
+  int64 hashCode = GetHashIndex(signature.c_str());
+  uint64 secondHashCode = GetSecondHashIndex(signature.c_str());
+  PregIdx pregItabAddress = currFunc->GetPregTab()->CreatePreg(PTY_ptr);
+  RegassignNode *itabAddressAssign =
+      builder->CreateStmtRegassign(PTY_ptr, pregItabAddress, resolveNode.GetTabBaseAddr());
+  currFunc->GetBody()->InsertBefore(&stmt, itabAddressAssign);
+  // read funcvalue
+  BaseNode *offsetNode = builder->CreateIntConst(static_cast<uint64>(hashCode * kTabEntrySize), PTY_u32);
+  BaseNode *addrNode = builder->CreateExprBinary(OP_add, *GlobalTables::GetTypeTable().GetPtr(),
+                                                 builder->CreateExprRegread(PTY_ptr, pregItabAddress), offsetNode);
+  BaseNode *readFuncPtr = builder->CreateExprIread(
+      compactPtrType, *GlobalTables::GetTypeTable().GetOrCreatePointerType(compactPtrType), 0, addrNode);
+  RegassignNode *funcPtrAssign = builder->CreateStmtRegassign(compactPtrPrim, pregFuncPtr, readFuncPtr);
+  currFunc->GetBody()->InsertBefore(&stmt, funcPtrAssign);
+  // In case not found in the fast path, fall to the slow path
+  MapleAllocator *currentFuncMpAllocator = builder->GetCurrentFuncCodeMpAllocator();
+  CHECK_FATAL(currentFuncMpAllocator != nullptr, "null ptr check");
+  MapleVector<BaseNode*> opnds(currentFuncMpAllocator->Adapter());
+  opnds.push_back(builder->CreateExprRegread(PTY_ptr, pregItabAddress));
+#ifdef USE_ARM32_MACRO
+  opnds.push_back(builder->CreateIntConst(secondHashCode, PTY_u32));
+#else
+  opnds.push_back(builder->CreateIntConst(secondHashCode, PTY_u64));
+#endif
+  UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(signature);
+  MemPool *currentFunMp = builder->GetCurrentFuncCodeMp();
+  CHECK_FATAL(currentFunMp != nullptr, "null ptr check");
+  ConststrNode *signatureNode = currentFunMp->New<ConststrNode>(strIdx);
+  signatureNode->SetPrimType(PTY_ptr);
+  opnds.push_back(signatureNode);
+  StmtNode *mccCallStmt =
+      builder->CreateStmtCallRegassigned(mccItabFunc->GetPuidx(), opnds, pregFuncPtr, OP_callassigned);
+  BaseNode *checkExpr = builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(), compactPtrType,
+                                                   builder->CreateExprRegread(compactPtrPrim, pregFuncPtr),
+                                                   builder->CreateIntConst(0, compactPtrPrim));
+  IfStmtNode *ifStmt = static_cast<IfStmtNode*>(builder->CreateStmtIf(checkExpr));
+  ifStmt->GetThenPart()->AddStatement(mccCallStmt);
+  currFunc->GetBody()->InsertBefore(&stmt, ifStmt);
+}
+
+#ifndef USE_ARM32_MACRO
+#ifdef USE_32BIT_REF
+void VtableImpl::InlineCacheinit() {
+  constexpr char kInterfaceMethodInlineCache[] = "MCC_getFuncPtrFromItabInlineCache";
+  mccItabFuncInlineCache = builder->GetOrCreateFunction(kInterfaceMethodInlineCache, TyIdx(PTY_ptr));
+  mccItabFuncInlineCache->SetAttr(FUNCATTR_nosideeffect);
+  GenInlineCacheTableSymbol();
+}
+
+void VtableImpl::InlineCacheProcess(StmtNode &stmt, const ResolveFuncNode &resolveNode, const std::string &signature,
+                                    PregIdx &pregFuncPtr) {
+  if (numOfInterfaceCallSite == 0) {
+    InlineCacheinit();
+  }
+  int64 hashCode = GetHashIndex(signature.c_str());
+  uint64 secondHashCode = GetSecondHashIndex(signature.c_str());
+  AddrofNode *inlineCacheTableAddrExpr = builder->CreateExprAddrof(0, *inlineCacheTableSym);
+  ConstvalNode *offsetConstNode = builder->CreateIntConst(numOfInterfaceCallSite, PTY_i64);
+  ArrayNode *inlineCacheTableEntryNode =
+      builder->CreateExprArray(*inlineCacheTableType, inlineCacheTableAddrExpr, offsetConstNode);
+  inlineCacheTableEntryNode->SetBoundsCheck(false);
+  PregIdx pregTargetCacheEntry = currFunc->GetPregTab()->CreatePreg(
+      GlobalTables::GetTypeTable().GetOrCreatePointerType(*inlineCacheTableEntryType)->GetPrimType());
+  RegassignNode *inlineCacheCacheEntryAssign = builder->CreateStmtRegassign(
+      GlobalTables::GetTypeTable().GetOrCreatePointerType(*inlineCacheTableEntryType)->GetPrimType(),
+      pregTargetCacheEntry, inlineCacheTableEntryNode);
+  currFunc->GetBody()->InsertBefore(&stmt, inlineCacheCacheEntryAssign);
+  RegreadNode *regReadNodeTmp = builder->CreateExprRegread(
+      GlobalTables::GetTypeTable().GetOrCreatePointerType(*inlineCacheTableEntryType)->GetPrimType(),
+      pregTargetCacheEntry);
+  IreadNode *ireadNodeForClassAndMethodAddr =
+      builder->CreateExprIread(*GlobalTables::GetTypeTable().GetUInt64(),
+                               *GlobalTables::GetTypeTable().GetOrCreatePointerType(*inlineCacheTableEntryType),
+                               1, regReadNodeTmp);
+  PregIdx pregClassAndMethodAddr =
+      currFunc->GetPregTab()->CreatePreg(GlobalTables::GetTypeTable().GetUInt64()->GetPrimType());
+  RegassignNode *klassAndMethodAddrAssign =
+      builder->CreateStmtRegassign(GlobalTables::GetTypeTable().GetUInt64()->GetPrimType(),
+                                   pregClassAndMethodAddr, ireadNodeForClassAndMethodAddr);
+  currFunc->GetBody()->InsertBefore(&stmt, klassAndMethodAddrAssign);
+  RegreadNode *entryReadNode =
+      builder->CreateExprRegread(GlobalTables::GetTypeTable().GetUInt64()->GetPrimType(), pregClassAndMethodAddr);
+  BinaryNode *methodReadNode =
+      builder->CreateExprBinary(OP_lshr, *GlobalTables::GetTypeTable().GetUInt64(), entryReadNode,
+                                builder->CreateIntConst(32, GlobalTables::GetTypeTable().GetUInt64()->GetPrimType()));
+  BaseNode *methodReadNode32 = builder->CreateExprTypeCvt(OP_cvt, *GlobalTables::GetTypeTable().GetUInt32(),
+                                                          *GlobalTables::GetTypeTable().GetUInt64(), methodReadNode);
+  RegassignNode *methodAddrInCacheAssign =
+      builder->CreateStmtRegassign(GlobalTables::GetTypeTable().GetUInt32()->GetPrimType(),
+                                   pregFuncPtr, methodReadNode32);
+  BaseNode *classInfoAddress = resolveNode.GetBOpnd(1);
+  BaseNode *checkCacheHitExpr =
+      builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(),
+                                 *GlobalTables::GetTypeTable().GetUInt32(), classInfoAddress,
+                                 entryReadNode); // low 32 in entryReadNode means class metadata cached in cache
+  IfStmtNode *ifStmt = static_cast<IfStmtNode*>(builder->CreateStmtIfThenElse(checkCacheHitExpr));
+  ifStmt->GetThenPart()->AddStatement(methodAddrInCacheAssign);
+  CallMrtInlineCacheFun(stmt, resolveNode, *regReadNodeTmp, hashCode, secondHashCode, signature, pregFuncPtr, *ifStmt);
+  ++numOfInterfaceCallSite;
+}
+
+void VtableImpl::CallMrtInlineCacheFun(StmtNode &stmt, const ResolveFuncNode &resolveNode, RegreadNode &regReadNodeTmp,
+                                       int64 hashCode, uint64 secondHashCode, const std::string &signature,
+                                       PregIdx &pregFuncPtr, IfStmtNode &ifStmt) {
+  BaseNode *classInfoAddress = resolveNode.GetBOpnd(1);
+  MapleAllocator *currentFuncMpAllocator = builder->GetCurrentFuncCodeMpAllocator();
+  CHECK_FATAL(currentFuncMpAllocator != nullptr, "null ptr check");
+  MapleVector<BaseNode*> opnds(currentFuncMpAllocator->Adapter());
+  opnds.push_back(&regReadNodeTmp);
+  opnds.push_back(classInfoAddress);
+  opnds.push_back(builder->CreateIntConst(hashCode, PTY_u64));
+  opnds.push_back(builder->CreateIntConst(secondHashCode, PTY_u64));
+  UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(signature);
+  MemPool *currentFunMp = builder->GetCurrentFuncCodeMp();
+  CHECK_FATAL(currentFunMp != nullptr, "null ptr check");
+  ConststrNode *signatureNode = currentFunMp->New<ConststrNode>(strIdx);
+  signatureNode->SetPrimType(PTY_ptr);
+  opnds.push_back(signatureNode);
+  StmtNode *mccCallStmt =
+      builder->CreateStmtCallRegassigned(mccItabFuncInlineCache->GetPuidx(), opnds, pregFuncPtr, OP_callassigned);
+  ifStmt.GetElsePart()->AddStatement(mccCallStmt);
+  currFunc->GetBody()->InsertBefore(&stmt, &ifStmt);
+}
+
+void VtableImpl::GenInlineCacheTableSymbol() {
+  // Create inline_cache_table
+  FieldVector parentFields;
+  FieldVector fields;
+  GlobalTables::GetTypeTable().PushIntoFieldVector(fields, "KlassAndMethodAddr",
+                                                   *GlobalTables::GetTypeTable().GetUInt64());
+  inlineCacheTableEntryType = static_cast<MIRStructType*>(
+      GlobalTables::GetTypeTable().GetOrCreateStructType("InlineCacheTableEntry",
+                                                         fields, parentFields, GetMIRModule()));
+  inlineCacheTableType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*inlineCacheTableEntryType, 0);
+  std::string inlineCacheTableSymName = namemangler::kInlineCacheTabStr + GetMIRModule().GetFileNameAsPostfix();
+  inlineCacheTableSym = builder->GetOrCreateGlobalDecl(inlineCacheTableSymName, *inlineCacheTableType);
+}
+
+void VtableImpl::ResolveInlineCacheTable() {
+  if (numOfInterfaceCallSite == 0) {
+    ++numOfInterfaceCallSite;
+  }
+  inlineCacheTableType->SetSizeArrayItem(static_cast<uint32>(0), numOfInterfaceCallSite);
+  MIRAggConst *inlineCacheTableConst =
+      GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), *inlineCacheTableType);
+  for (uint32 i = 0; i < numOfInterfaceCallSite; ++i) {
+    MIRAggConst &entryConst = *GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(),
+                                                                             *inlineCacheTableEntryType);
+    builder->AddIntFieldConst(*inlineCacheTableEntryType, entryConst, 1, 0);
+    inlineCacheTableConst->PushBack(&entryConst);
+  }
+  inlineCacheTableSym->SetStorageClass(kScFstatic);
+  inlineCacheTableSym->SetKonst(inlineCacheTableConst);
+}
+
+void VtableImpl::Finish() {
+  if (numOfInterfaceCallSite > 0) {
+    ResolveInlineCacheTable();
+  }
+}
+#endif  // ~USE_32BIT_REF
+#endif  // ~USE_ARM32_MACRO
+
+bool M2MVtableImpl::PhaseRun(maple::MIRModule &m) {
+  OPT_TEMPLATE_NEWPM(VtableImpl, m);
+  return true;
+}
+
+void M2MVtableImpl::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  aDep.AddRequired<M2MKlassHierarchy>();
+  aDep.SetPreservedAll();
+}
+}  // namespace maple
diff --git a/src/mapleall/test/BUILD.gn b/src/mapleall/test/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..f8bcb332b01e65d273b56916e44fd634c74af7a6
--- /dev/null
+++ b/src/mapleall/test/BUILD.gn
@@ -0,0 +1,58 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+
+cflags_cc -= [
+  "-Werror",
+]
+
+include_directories = [
+  "${MAPLE_ROOT}/tools/gtest_lib/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_ir/include/",
+  "${MAPLEALL_ROOT}/mempool/include/",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
+]
+src_mapleallUT = [
+  "cl_ut_test.cpp",
+  "int_val_test.cpp",
+  "stacktrace_test.cpp",
+  "maple_string_test.cpp",
+]
+
+executable("mapleallUT") {
+  sources = src_mapleallUT
+  include_dirs = include_directories
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+
+  deps = [
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/maple_ir:libmplir",
+    "${MAPLEALL_ROOT}/mempool:libmempool",
+    "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
+    "${MAPLEALL_ROOT}/maple_util:libcommandline",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
+  ]
+
+  libs = [
+    "${MAPLE_ROOT}/tools/gtest_lib/lib/libgmock.a",
+    "${MAPLE_ROOT}/tools/gtest_lib/lib/libgmock_main.a",
+    "${MAPLE_ROOT}/tools/gtest_lib/lib/libgtest.a",
+    "${MAPLE_ROOT}/tools/gtest_lib/lib/libgtest_main.a",
+    "pthread",
+    "dl"
+  ]
+}
+
diff --git a/src/mapleall/test/CMakeLists.txt b/src/mapleall/test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..851eee05f543fc449ee8cd951bd62ff73e7ad5a8
--- /dev/null
+++ b/src/mapleall/test/CMakeLists.txt
@@ -0,0 +1,57 @@
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+
+set(include_directories
+    ${MAPLE_ROOT}/tools/gtest_lib/include
+    ${MAPLEALL_ROOT}/maple_util/include
+    ${MAPLEALL_ROOT}/maple_ir/include/
+    ${MAPLEALL_ROOT}/mempool/include/
+    ${THIRD_PARTY_ROOT}/bounds_checking_function/include
+)
+
+set(src_mapleallUT
+    cl_ut_test.cpp
+    int_val_test.cpp
+    stacktrace_test.cpp
+    maple_string_test.cpp
+)
+
+set(deps
+    libdriver_option
+    libmplphase
+    libmplutil
+    libmplir
+    libmempool
+    libmpl2mpl
+    libcommandline
+    libHWSecureC
+    ${MAPLE_ROOT}/tools/gtest_lib/lib/libgmock.a
+    ${MAPLE_ROOT}/tools/gtest_lib/lib/libgmock_main.a
+    ${MAPLE_ROOT}/tools/gtest_lib/lib/libgtest.a
+    ${MAPLE_ROOT}/tools/gtest_lib/lib/libgtest_main.a
+    pthread
+    dl
+)
+
+#mapleallUT
+add_executable(mapleallUT "${src_mapleallUT}")
+set_target_properties(mapleallUT PROPERTIES
+    COMPILE_FLAGS ""
+    INCLUDE_DIRECTORIES "${include_directories}"
+    LINK_LIBRARIES "${deps}"
+    RUNTIME_OUTPUT_DIRECTORY "${MAPLE_BUILD_OUTPUT}/bin"
+)
diff --git a/src/mapleall/test/cl_ut_test.cpp b/src/mapleall/test/cl_ut_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48b31f2007433d7c07b0e338dcddb74cfc739d28
--- /dev/null
+++ b/src/mapleall/test/cl_ut_test.cpp
@@ -0,0 +1,1086 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <climits>
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "cl_option.h"
+#include "cl_parser.h"
+#include "gtest/gtest.h"
+
+/* ##################### own OptionType for the test #####################
+ * ####################################################################### */
+
+static bool utCLTypeChecker = false;
+
+/* You can create own OptionType and Set own Option Parser for him, like this: */
+class UTCLType {
+ public:
+  UTCLType() = default;
+  UTCLType(const std::string &data) : data(data) {};
+
+  std::string data;
+};
+bool operator==(const UTCLType &opt, const std::string &str) {
+  bool ret = (opt.data == str) ? true : false;
+  return ret;
+}
+bool operator==(const std::string &str, const UTCLType &opt) {
+  bool ret = (opt.data == str) ? true : false;
+  return ret;
+}
+
+template <>
+void maplecl::Option<UTCLType>::Clear() {
+  value.data = "";
+}
+
+template <>
+std::vector<std::string> maplecl::Option<UTCLType>::GetRawValues() {
+  return std::vector<std::string>();
+}
+
+template <>
+maplecl::RetCode maplecl::Option<UTCLType>::Parse(size_t &argsIndex,
+    const std::deque<std::string_view> &args, KeyArg &keyArg) {
+  utCLTypeChecker = true;
+  RetCode err = maplecl::RetCode::noError;
+
+  if (args[argsIndex] != "--uttype") {
+    return maplecl::RetCode::parsingErr;
+  }
+
+  size_t localArgsIndex = argsIndex + 1;
+  /* Second command line argument does not exist */
+  if (localArgsIndex >= args.size() || args[localArgsIndex].empty()) {
+    return RetCode::valueEmpty;
+  }
+
+  /* In this example, the value of UTCLType must be --UTCLTypeOption */
+  if (args[localArgsIndex] == "--UTCLTypeOption") {
+    argsIndex += 2; /* 1 for Option Key, 1 for Value */
+    err = maplecl::RetCode::noError;
+    SetValue(UTCLType("--UTCLTypeOption"));
+  } else {
+    err = maplecl::RetCode::valueEmpty;
+  }
+
+  return err;
+}
+
+/* ########################## Test Options ###############################
+ * ####################################################################### */
+
+namespace testopts {
+
+  maplecl::OptionCategory defaultCategory;
+  maplecl::OptionCategory testCategory1;
+  maplecl::OptionCategory testCategory2;
+
+  maplecl::Option<bool> booloptEnabled({"--boole"}, "");
+  maplecl::Option<bool> booloptDisabled({"--boold"}, "");
+
+  maplecl::Option<std::string> testStr({"--str"}, "");
+
+  maplecl::Option<uint8_t> testUint8({"--uint8"}, "");
+  maplecl::Option<uint16_t> testUint16({"--uint16"}, "");
+
+  maplecl::Option<int32_t> testInt32({"--int32"}, "");
+  maplecl::Option<uint32_t> testUint32({"--uint32"}, "");
+
+  maplecl::Option<int64_t> testInt64({"--int64"}, "");
+  maplecl::Option<uint64_t> testUint64({"--uint64"}, "");
+
+  maplecl::Option<bool> doubleDefinedOpt({"--tst", "-t"}, "");
+
+  maplecl::Option<bool> defaultBool({"--defbool"}, "", maplecl::Init(true));
+  maplecl::Option<std::string> defaultString({"--defstring"}, "", maplecl::Init("Default String"));
+  maplecl::Option<int32_t> defaultDigit({"--defdigit"}, "", maplecl::Init(-42));
+
+  maplecl::Option<bool> enable({"--enable"}, "", maplecl::Init(true), maplecl::DisableWith("--no-enable"));
+
+  maplecl::Option<std::string> macro({"-JOIN"}, "", maplecl::joinedValue);
+  maplecl::Option<int32_t> joindig({"--joindig"}, "", maplecl::joinedValue);
+
+  maplecl::Option<std::string> equalStr({"--eqstr"}, "");
+  maplecl::Option<int32_t> equalDig({"--eqdig"}, "");
+
+  maplecl::Option<int32_t> reqVal({"--reqval"}, "", maplecl::requiredValue, maplecl::Init(-42));
+  maplecl::Option<int32_t> optVal({"--optval"}, "", maplecl::optionalValue, maplecl::Init(-42));
+  maplecl::Option<int32_t> woVal({"--woval"}, "", maplecl::disallowedValue, maplecl::Init(-42));
+
+  maplecl::Option<bool> cat1Opt1({"--c1opt1"}, "", {testCategory1});
+  maplecl::Option<bool> cat12Opt({"--c12opt"}, "", {testCategory1, testCategory2});
+
+  maplecl::Option<UTCLType> uttype({"--uttype"}, "");
+
+  maplecl::Option<bool> desc({"--desc"}, "It's test description");
+
+  maplecl::Option<bool> dup({"--dup"}, "");
+
+  maplecl::List<std::string> vecString({"--vecstr"}, "");
+  maplecl::List<uint32_t> vecDig({"--vecdig"}, "");
+  maplecl::List<bool> vecBool({"--vecbool"}, "", maplecl::DisableWith("--no-vecbool"));
+
+  maplecl::List<std::string> vecStringDef({"--vecstrdef"}, "", maplecl::Init("Default"));
+  maplecl::List<uint32_t> vecDigDef({"--vecdigdef"}, "", maplecl::Init(100));
+  maplecl::List<bool> vecBoolDef({"--vecbooldef"}, "", maplecl::DisableWith("--no-vecbooldef"), maplecl::Init(true));
+
+  maplecl::Option<std::string> common({"--common"}, "");
+} // namespace testopts
+
+/* ################# "Enable/Disable Boolean Options" Test ###############
+ * ####################################################################### */
+
+TEST(clOptions, boolOpt) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--boole",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  bool isSet = testopts::booloptEnabled;
+  ASSERT_EQ(isSet, true);
+
+  isSet = testopts::booloptDisabled;
+  ASSERT_EQ(isSet, false);
+}
+
+/* ################# "Set and Comapare Options" Test #####################
+ * ####################################################################### */
+
+TEST(clOptions, comparableOpt1) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--boole",
+    "--str", "DATA",
+    "--int32", "-42",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  std::string lStr = "data";
+  int32_t lDig = 42;
+  bool lBool = false;
+
+  bool isSet = (testopts::booloptEnabled == true);
+  ASSERT_EQ(isSet, true);
+  isSet = (testopts::booloptEnabled == lBool);
+  ASSERT_EQ(isSet, false);
+
+  isSet = (testopts::testStr == "DATA");
+  ASSERT_EQ(isSet, true);
+  isSet = ("DATA" == testopts::testStr);
+  ASSERT_EQ(isSet, true);
+  isSet = (testopts::testStr == lStr);
+  ASSERT_EQ(isSet, false);
+
+  isSet = (testopts::testInt32 == -42);
+  ASSERT_EQ(isSet, true);
+  isSet = (-42 == testopts::testInt32);
+  ASSERT_EQ(isSet, true);
+  isSet = (testopts::testInt32 == lDig);
+  ASSERT_EQ(isSet, false);
+}
+
+TEST(clOptions, IncorrectVal) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--str", "--boole",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 1);
+  ASSERT_EQ(badArgs[0].first, "--str");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::valueEmpty);
+
+  bool isSet = (testopts::booloptEnabled == true);
+  ASSERT_EQ(isSet, true);
+}
+
+/* ################# "Set Digital Options" Test ##########################
+ * ####################################################################### */
+
+TEST(clOptions, digitTestMaxVal) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--uint8", "255",
+    "--uint16", "65535",
+    "--int32", "2147483647",
+    "--uint32", "4294967295",
+    "--int64", "9223372036854775807",
+    "--uint64", "18446744073709551615",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  uint8_t uint8Dig = testopts::testUint8;
+  ASSERT_EQ(uint8Dig, (1 << 8) - 1);
+
+  uint16_t uint16Dig = testopts::testUint16;
+  ASSERT_EQ(uint16Dig, (1 << 16) - 1);
+
+  int32_t int32Dig = testopts::testInt32;
+  ASSERT_EQ(int32Dig, INT_MAX);
+
+  uint32_t uint32Dig = testopts::testUint32;
+  ASSERT_EQ(uint32Dig, UINT_MAX);
+
+  int64_t int64Dig = testopts::testInt64;
+  ASSERT_EQ(int64Dig, LLONG_MAX);
+
+  uint64_t uint64Dig = testopts::testUint64;
+  ASSERT_EQ(uint64Dig, ULLONG_MAX);
+}
+
+TEST(clOptions, digitTestNegativeVal1) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--uint32", "-10",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs[0].first, "--uint32");
+  ASSERT_EQ(badArgs[1].first, "-10");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::incorrectValue);
+  ASSERT_EQ(badArgs[1].second, maplecl::RetCode::notRegistered);
+}
+
+TEST(clOptions, digitTestNegativeVal2) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--uint64", "-10",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs[0].first, "--uint64");
+  ASSERT_EQ(badArgs[1].first, "-10");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::incorrectValue);
+  ASSERT_EQ(badArgs[1].second, maplecl::RetCode::notRegistered);
+}
+
+TEST(clOptions, digitTestNegativeVal3) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--int32", "-2147483648",
+    "--int64", "-9223372036854775808",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  int64_t int64Dig = testopts::testInt64;
+  ASSERT_EQ(int64Dig, LLONG_MIN);
+}
+
+TEST(clOptions, digitIncorrectPrefix) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--int32", "--10",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs[0].first, "--int32");
+  ASSERT_EQ(badArgs[1].first, "--10");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::incorrectValue);
+  ASSERT_EQ(badArgs[1].second, maplecl::RetCode::notRegistered);
+}
+
+TEST(clOptions, digitIncorrectVal) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--int32", "INCORRECT",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs[0].first, "--int32");
+  ASSERT_EQ(badArgs[1].first, "INCORRECT");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::incorrectValue);
+  ASSERT_EQ(badArgs[1].second, maplecl::RetCode::notRegistered);
+}
+
+/* ################# "Set out of range Value in Option" Test #############
+ * ####################################################################### */
+
+TEST(clOptions, digitTestOutOfRange1) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--int32", "-2147483649",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs[0].first, "--int32");
+  ASSERT_EQ(badArgs[1].first, "-2147483649");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::outOfRange);
+  ASSERT_EQ(badArgs[1].second, maplecl::RetCode::notRegistered);
+}
+
+TEST(clOptions, digitTestOutOfRange2) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--uint32", "4294967296",
+    "--uint16", "65536",
+    "--uint8", "256",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 6);
+  ASSERT_EQ(badArgs[0].first, "--uint32");
+  ASSERT_EQ(badArgs[1].first, "4294967296");
+  ASSERT_EQ(badArgs[2].first, "--uint16");
+  ASSERT_EQ(badArgs[3].first, "65536");
+  ASSERT_EQ(badArgs[4].first, "--uint8");
+  ASSERT_EQ(badArgs[5].first, "256");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::outOfRange);
+  ASSERT_EQ(badArgs[1].second, maplecl::RetCode::notRegistered);
+  ASSERT_EQ(badArgs[2].second, maplecl::RetCode::outOfRange);
+  ASSERT_EQ(badArgs[3].second, maplecl::RetCode::notRegistered);
+  ASSERT_EQ(badArgs[4].second, maplecl::RetCode::outOfRange);
+  ASSERT_EQ(badArgs[5].second, maplecl::RetCode::notRegistered);
+}
+
+TEST(clOptions, digitTestOutOfRange3) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--int64", "-9223372036854775809",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs[0].first, "--int64");
+  ASSERT_EQ(badArgs[1].first, "-9223372036854775809");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::outOfRange);
+  ASSERT_EQ(badArgs[1].second, maplecl::RetCode::notRegistered);
+}
+
+TEST(clOptions, digitTestOutOfRange4) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--uint64", "18446744073709551616",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs[0].first, "--uint64");
+  ASSERT_EQ(badArgs[1].first, "18446744073709551616");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::outOfRange);
+  ASSERT_EQ(badArgs[1].second, maplecl::RetCode::notRegistered);
+}
+
+/* ################# Check double option name definition #################
+ * ####################################################################### */
+
+TEST(clOptions, doubleDef1) {
+    // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--tst",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  bool isSet = testopts::doubleDefinedOpt;
+  ASSERT_EQ(isSet, true);
+}
+
+TEST(clOptions, doubleDef2) {
+    // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "-t",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  bool isSet = testopts::doubleDefinedOpt;
+  ASSERT_EQ(isSet, true);
+}
+
+/* ################# Check default option initialization #################
+ * ####################################################################### */
+
+TEST(clOptions, defaultVal) {
+    // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  /* Default Options are not set in command line but initialized with default value */
+  bool isSet = testopts::defaultBool;
+  ASSERT_EQ(isSet, true);
+
+  std::string defStr = testopts::defaultString;
+  ASSERT_EQ(defStr, "Default String");
+
+  int32_t defaultDigit = testopts::defaultDigit;
+  ASSERT_EQ(defaultDigit, -42);
+}
+
+/* ########## Check Option disabling with additional no-opt name #########
+ * ####################################################################### */
+
+/* check that testopts::enable is enabled by default.
+ * It's needed to be sure that --no-enable disables this option */
+TEST(clOptions, disableOpt1) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  bool isSet = testopts::enable;
+  ASSERT_EQ(isSet, true);
+}
+
+TEST(clOptions, disableOpt2) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--no-enable",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  bool isSet = testopts::enable;
+  ASSERT_EQ(isSet, false);
+}
+
+/* ################# Check Joined Options ################################
+ * ####################################################################### */
+
+TEST(clOptions, joinedOpt) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "-JOINMACRO",
+    "--joindig-42",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  std::string joinOpt = testopts::macro;
+  ASSERT_EQ(joinOpt, "MACRO");
+
+  int32_t joinDig = testopts::joindig;
+  ASSERT_EQ(joinDig, -42);
+}
+
+/* ################# Check Options like --opt=value ######################
+ * ####################################################################### */
+
+TEST(clOptions, equalOpt) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--eqstr=EQUALSTRING",
+    "--eqdig=-42",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  std::string equalStr = testopts::equalStr;
+  ASSERT_EQ(equalStr, "EQUALSTRING");
+
+  int32_t equalDig = testopts::equalDig;
+  ASSERT_EQ(equalDig, -42);
+}
+
+TEST(clOptions, equalOptErr) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--eqstr=",
+    "--eqdig=",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  /* --woval must not contain any key values, so 20 will be handled as second key */
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs[0].first, "--eqstr=");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::valueEmpty);
+
+  ASSERT_EQ(badArgs[1].first, "--eqdig=");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::valueEmpty);
+}
+
+TEST(clOptions, joinedEqualOpt) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "-JOINTEST=20",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  std::string joinOpt = testopts::macro;
+  ASSERT_EQ(joinOpt, "TEST=20");
+}
+
+/* ################# Check Options with required Value ###################
+ * ####################################################################### */
+
+TEST(clOptions, expectedVal1) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--reqval",
+    "--boole",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 1);
+  ASSERT_EQ(badArgs[0].first, "--reqval");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::incorrectValue);
+
+  bool isSet = testopts::booloptEnabled;
+  ASSERT_EQ(isSet, true);
+}
+
+TEST(clOptions, expectedVal2) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--reqval", "20",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  int32_t equalDig = testopts::reqVal;
+  ASSERT_EQ(equalDig, 20);
+}
+
+TEST(clOptions, expectedVal3) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--optval",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  int32_t equalDig = testopts::optVal;
+  ASSERT_EQ(equalDig, -42);
+}
+
+TEST(clOptions, expectedVal4) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--optval=20",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  int32_t equalDig = testopts::optVal;
+  ASSERT_EQ(equalDig, 20);
+}
+
+TEST(clOptions, expectedVal5) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--optval", "20",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+}
+
+TEST(clOptions, expectedVal6) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--optval", "--boole",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  testopts::booloptEnabled.Clear();
+  testopts::optVal.Clear();
+  ASSERT_EQ(testopts::booloptEnabled.GetValue(), false);
+  ASSERT_EQ(testopts::optVal.IsEnabledByUser(), false);
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  ASSERT_EQ(testopts::booloptEnabled.GetValue(), true);
+  ASSERT_EQ(testopts::optVal.IsEnabledByUser(), true);
+  ASSERT_EQ(testopts::optVal.GetValue(), -42);
+}
+
+TEST(clOptions, expectedVal7) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--woval", "20",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  /* --woval must not contain any key values, so 20 will be handled as second key */
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 1);
+  ASSERT_EQ(badArgs[0].first, "20");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::notRegistered);
+}
+
+TEST(clOptions, expectedVal8) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--woval=20",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 1);
+  ASSERT_EQ(badArgs[0].first, "--woval=20");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::unnecessaryValue);
+}
+
+TEST(clOptions, expectedVal9) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--woval",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  int32_t equalDig = testopts::woVal;
+  ASSERT_EQ(equalDig, -42);
+}
+
+/* ################# Options Category Test ###############################
+ * ####################################################################### */
+
+TEST(clOptions, optCategory1) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--c1opt1",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv, testopts::defaultCategory);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 1);
+  ASSERT_EQ(badArgs[0].first, "--c1opt1");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::notRegistered);
+}
+
+TEST(clOptions, optCategory2) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--c1opt1",
+    "--c12opt",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv, testopts::testCategory1);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  bool isSet = testopts::cat1Opt1;
+  ASSERT_EQ(isSet, true);
+
+  isSet = testopts::cat12Opt;
+  ASSERT_EQ(isSet, true);
+}
+
+TEST(clOptions, optCategory3) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--c12opt",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv, testopts::testCategory2);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  bool isSet = testopts::cat12Opt;
+  ASSERT_EQ(isSet, true);
+}
+
+/* ################# Own OptionType Test #################################
+ * ####################################################################### */
+
+TEST(clOptions, ownOptionType1) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--uttype",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  ASSERT_EQ(utCLTypeChecker, false);
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  ASSERT_EQ(utCLTypeChecker, true);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 1);
+  ASSERT_EQ(badArgs[0].first, "--uttype");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::valueEmpty);
+}
+
+TEST(clOptions, ownOptionType2) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--uttype", "TEST",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  utCLTypeChecker = false;
+  ASSERT_EQ(utCLTypeChecker, false);
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::parsingErr);
+
+  ASSERT_EQ(utCLTypeChecker, true);
+
+  auto &badArgs = maplecl::CommandLine::GetCommandLine().badCLArgs;
+  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs[0].first, "--uttype");
+  ASSERT_EQ(badArgs[0].second, maplecl::RetCode::valueEmpty);
+  ASSERT_EQ(badArgs[1].first, "TEST");
+  ASSERT_EQ(badArgs[1].second, maplecl::RetCode::notRegistered);
+}
+
+TEST(clOptions, ownOptionType3) {
+
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--uttype", "--UTCLTypeOption",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  utCLTypeChecker = false;
+  ASSERT_EQ(utCLTypeChecker, false);
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  ASSERT_EQ(utCLTypeChecker, true);
+  UTCLType opt = testopts::uttype;
+
+  std::string tst = "--UTCLTypeOption";
+  bool isSet = (tst == opt);
+
+  ASSERT_EQ(isSet, isSet);
+  ASSERT_EQ(opt, "--UTCLTypeOption");
+}
+
+/* ################# Duplicated Option ###################################
+ * ####################################################################### */
+
+TEST(clOptions, duplicatedOptions) {
+  EXPECT_DEATH(maplecl::Option<bool> dup2({"--dup"}, ""), "");
+}
+
+/* ##################### Check Description ###############################
+ * ####################################################################### */
+
+TEST(clOptions, description) {
+  ASSERT_EQ(testopts::desc.GetDescription(), "It's test description");
+}
+
+/* ##################### Check maplecl::list ##################################
+ * ####################################################################### */
+
+TEST(clOptions, optList1) {
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--vecstr", "data1",
+    "--vecstr", "data2",
+    "--vecstr", "data3",
+    "--vecdig", "10",
+    "--vecdig", "20",
+    "--vecbool", "--no-vecbool", "--vecbool",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  auto strVals = testopts::vecString.GetValues();
+  ASSERT_EQ(strVals.size(), 3);
+  ASSERT_EQ(strVals[0], "data1");
+  ASSERT_EQ(strVals[1], "data2");
+  ASSERT_EQ(strVals[2], "data3");
+
+  auto digVals = testopts::vecDig.GetValues();
+  ASSERT_EQ(digVals.size(), 2);
+  ASSERT_EQ(digVals[0], 10);
+  ASSERT_EQ(digVals[1], 20);
+
+  auto boolVals = testopts::vecBool.GetValues();
+  ASSERT_EQ(boolVals.size(), 3);
+  ASSERT_EQ(boolVals[0], true);
+  ASSERT_EQ(boolVals[1], false);
+  ASSERT_EQ(boolVals[2], true);
+
+  maplecl::CommandLine::GetCommandLine().Clear(); // to clear previous test data
+
+  ASSERT_EQ(testopts::vecBool.GetValues().size(), 0);
+  ASSERT_EQ(testopts::vecDig.GetValues().size(), 0);
+  ASSERT_EQ(testopts::vecString.GetValues().size(), 0);
+}
+
+TEST(clOptions, optList2) {
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--vecstrdef", "data1",
+    "--vecdigdef", "10",
+    "--vecbooldef", "--no-vecbooldef",
+    nullptr };
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  ASSERT_EQ(testopts::vecBoolDef.GetValues().size(), 1);
+  ASSERT_EQ(testopts::vecDigDef.GetValues().size(), 1);
+  ASSERT_EQ(testopts::vecStringDef.GetValues().size(), 1);
+
+  ASSERT_EQ(testopts::vecDigDef.GetValues()[0], 100);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues()[0], true);
+  ASSERT_EQ(testopts::vecStringDef.GetValues()[0], "Default");
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  ASSERT_EQ(testopts::vecStringDef.GetValues().size(), 2);
+  ASSERT_EQ(testopts::vecDigDef.GetValues().size(), 2);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues().size(), 3);
+
+  ASSERT_EQ(testopts::vecStringDef.GetValues()[1], "data1");
+  ASSERT_EQ(testopts::vecDigDef.GetValues()[1], 10);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues()[1], true);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues()[2], false);
+
+  maplecl::CommandLine::GetCommandLine().Clear(); // to clear previous test data
+  ASSERT_EQ(testopts::vecStringDef.GetValues().size(), 1);
+  ASSERT_EQ(testopts::vecDigDef.GetValues().size(), 1);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues().size(), 1);
+}
+
+/* ##################### "GetCommonValue from interface" check ###########
+ * ####################################################################### */
+TEST(clOptions, common) {
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--common", "datacommon",
+    nullptr };
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  maplecl::OptionInterface *commonOpt = &testopts::common;
+  std::string val = commonOpt->GetCommonValue();
+  ASSERT_EQ(val, "datacommon");
+}
+
+/* ##################### "CopyIfEnabled" check ###########
+ * ####################################################################### */
+TEST(clOptions, copyifenabled) {
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--boole",
+    "--str", "TEST",
+    "--uint8", "10",
+    nullptr };
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  maplecl::CommandLine::GetCommandLine().Clear(); // to clear previous test data
+  /* Check that options are cleared */
+  ASSERT_EQ(testopts::booloptEnabled == false, true);
+  ASSERT_EQ(testopts::booloptEnabled.IsEnabledByUser(), false);
+  ASSERT_EQ(testopts::booloptDisabled == false, true);
+  ASSERT_EQ(testopts::booloptDisabled.IsEnabledByUser(), false);
+  ASSERT_EQ(testopts::testStr == "", true);
+  ASSERT_EQ(testopts::testStr.IsEnabledByUser(), false);
+  ASSERT_EQ(testopts::testUint8 == (uint8_t)0, true);
+  ASSERT_EQ(testopts::testUint8.IsEnabledByUser(), false);
+
+  auto err = maplecl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, maplecl::RetCode::noError);
+
+  bool boole = false, boold = false;
+  std::string strTmp = "";
+  uint8_t u8Tmp = 0;
+  int tstEnabled = -1, tstDisabled = -1;
+
+  maplecl::CopyIfEnabled(boole, testopts::booloptEnabled);
+  maplecl::CopyIfEnabled(boold, testopts::booloptDisabled);
+  maplecl::CopyIfEnabled(tstEnabled, 10, testopts::booloptEnabled);
+  maplecl::CopyIfEnabled(tstDisabled, 10, testopts::booloptDisabled);
+  maplecl::CopyIfEnabled(strTmp, testopts::testStr);
+  maplecl::CopyIfEnabled(u8Tmp, testopts::testUint8);
+
+  ASSERT_EQ(boole, true);
+  ASSERT_EQ(boold, false);
+  ASSERT_EQ(tstEnabled, 10);
+  ASSERT_EQ(tstDisabled, -1);
+  ASSERT_EQ(strTmp, "TEST");
+  ASSERT_EQ(u8Tmp, 10);
+}
\ No newline at end of file
diff --git a/src/mapleall/test/int_val_test.cpp b/src/mapleall/test/int_val_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b6f169c0a6eaa9140b57c29309203a238de4c9ab
--- /dev/null
+++ b/src/mapleall/test/int_val_test.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "mpl_int_val.h"
+
+#include "gtest/gtest.h"
+
+TEST(IntVals, IncDec) {
+  maple::IntVal uValInc(254, 8, false);
+  maple::IntVal sValInc(126, 8, true);
+
+  maple::IntVal uValDec(1, 8, false);
+  maple::IntVal sValDec((maple::uint64)-127, 8, true);
+
+  ++uValInc;
+  ASSERT_EQ(uValInc.GetExtValue(), 255);
+  ASSERT_EQ((uValInc++).GetExtValue(), 255);
+  ASSERT_EQ(uValInc.GetExtValue(), 0);
+
+  ++sValInc;
+  ASSERT_EQ(sValInc.GetExtValue(), 127);
+  ASSERT_EQ((sValInc++).GetExtValue(), 127);
+  ASSERT_EQ(sValInc.GetExtValue(), -128);
+
+  --uValDec;
+  ASSERT_EQ(uValDec.GetExtValue(), 0);
+  ASSERT_EQ((uValDec--).GetExtValue(), 0);
+  ASSERT_EQ(uValDec.GetExtValue(), 255);
+
+  --sValDec;
+  ASSERT_EQ(sValDec.GetExtValue(), -128);
+  ASSERT_EQ((sValDec--).GetExtValue(), -128);
+  ASSERT_EQ(sValDec.GetExtValue(), 127);
+}
diff --git a/src/mapleall/test/maple_string_test.cpp b/src/mapleall/test/maple_string_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..292224098d5774c49472073dfd281749e81cafd5
--- /dev/null
+++ b/src/mapleall/test/maple_string_test.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "maple_string.h"
+#include "gtest/gtest.h"
+#include <string>
+
+using namespace maple;
+
+TEST(MapleString, find) {
+  MemPool* memPool = memPoolCtrler.NewMemPool("test", true);
+  MapleString ms("12345678910", memPool);
+  EXPECT_EQ(0, ms.find("123"));
+  EXPECT_EQ(5, ms.find("6789"));
+  EXPECT_EQ(std::string::npos, ms.find("2345678990"));
+  EXPECT_EQ(std::string::npos, ms.find("123", 1));
+  memPoolCtrler.DeleteMemPool(memPool);
+}
diff --git a/src/mapleall/test/stacktrace_test.cpp b/src/mapleall/test/stacktrace_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed82edcc7bc55c32de0e5918298451cc72ea270a
--- /dev/null
+++ b/src/mapleall/test/stacktrace_test.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <string>
+
+#include "gtest/gtest.h"
+#include "mpl_stacktrace.h"
+
+/* Expected stacktrace (except gtest's frames)
+ * _______________________
+ * 0# foo8() [0x*] in mapleallUT
+ * 1# foo7() [0x*] in mapleallUT
+ * 2# foo6() [0x*] in mapleallUT
+ * 3# foo5() [0x*] in mapleallUT
+ * 4# foo4() [0x*] in mapleallUT
+ * 5# foo3() [0x*] in mapleallUT
+ * 6# foo2() [0x*] in mapleallUT
+ * 7# foo1() [0x*] in mapleallUT
+ * 8# foo0() [0x*] in mapleallUT
+ * ______________________
+ */
+
+void __attribute__((noinline)) foo8() {
+  maple::Stacktrace<> st;
+
+  size_t framesCount = 8;
+  // calc end of tested frame
+  auto framesEnd = st.cbegin();
+  std::advance(framesEnd, framesCount);
+
+  for (auto it = st.cbegin(); it != framesEnd; ++it, --framesCount) {
+    auto frame = *it;
+
+    std::string path = frame.getFilename();
+    auto pos = path.rfind('/');
+    std::string filename = (pos != std::string::npos) ? path.substr(pos + 1, path.length()) : path;
+    EXPECT_EQ(filename, "mapleallUT");
+#ifdef DEBUG
+    EXPECT_EQ(frame.getName(), "foo" + std::to_string(framesCount) + "()");
+#endif
+  }
+}
+
+void __attribute__((noinline)) foo7() {
+  foo8();
+}
+
+void __attribute__((noinline)) foo6() {
+  foo7();
+}
+
+void __attribute__((noinline)) foo5() {
+  foo6();
+}
+
+void __attribute__((noinline)) foo4() {
+  foo5();
+}
+
+void __attribute__((noinline)) foo3() {
+  foo4();
+}
+
+void __attribute__((noinline)) foo2() {
+  foo3();
+}
+
+void __attribute__((noinline)) foo1() {
+  foo2();
+}
+
+void __attribute__((noinline)) foo0() {
+  foo1();
+}
+
+TEST(Stacktrace, Print) {
+  foo0();
+}
diff --git a/src/mrt/BUILD.gn b/src/mrt/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..17ca111b3471c5b5361dbdf071d5ec689919b94f
--- /dev/null
+++ b/src/mrt/BUILD.gn
@@ -0,0 +1,166 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+config("mrt_c_flags") {
+  cflags_c = []
+  if (GN_BUILD_TYPE == "RELEASE") {
+    cflags_c += [
+      "-O2",
+      "-fno-strict-aliasing",
+      "-D_FORTIFY_SOURCE=2",
+    ]
+  } else if (GN_BUILD_TYPE == "DEBUG") {
+    cflags_c += [
+      "-O0",
+      "-g3",
+      "-ftrapv",
+      "-fstack-check",
+    ]
+  } else {
+    cflags_c += [
+      "-O2",
+      "-fno-strict-aliasing",
+      "-g",
+    ]
+  }
+
+  if (GCONLY == 1) {
+    cflags += [ "-DGCONLY=1" ]
+  } else {
+    cflags += [ "-DGCONLY=0" ]
+  }
+
+  cflags_c += [
+    "-Wall",
+    "-Werror",
+    "-std=c99",
+    "-fPIC",
+    "-fstack-protector-strong",
+    "-fno-common",
+    "-pipe",
+    "-Wextra",
+    "-Wdate-time",
+    "-Wfloat-equal",
+    "-Wshadow",
+  ]
+
+  cflags_c += [
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/../../../../aarch64-linux-gnu/include/c++/7.5.0",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/../../../../aarch64-linux-gnu/include/c++/7.5.0/aarch64-linux-gnu",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/../../../../aarch64-linux-gnu/include/c++/7.5.0/backward",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/include",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/include-fixed",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/../../../../aarch64-linux-gnu/include",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../aarch64-linux-gnu/libc/usr/include",
+    "-target",
+    "aarch64-linux-gnu",
+  ]
+
+  ldflags = cflags_c
+  ldflags += [
+    "-Wl,-z,relro",
+    "-Wl,-z,now",
+    "-Wl,-z,noexecstack",
+  ]
+}
+
+config("mrt_cxx_flags") {
+  cflags_cc = []
+  if (GN_BUILD_TYPE == "RELEASE") {
+    cflags_cc += [
+      "-O2",
+      "-fno-strict-aliasing",
+      "-D_FORTIFY_SOURCE=2",
+    ]
+  } else if (GN_BUILD_TYPE == "DEBUG") {
+    cflags_cc += [
+      "-O0",
+      "-g3",
+      "-ftrapv",
+      "-fstack-check",
+    ]
+  } else {
+    cflags_cc += [
+      "-O2",
+      "-fno-strict-aliasing",
+      "-g",
+    ]
+  }
+
+  if (GCONLY == 1) {
+    cflags_cc += [ "-DGCONLY=1" ]
+  } else {
+    cflags_cc += [ "-DGCONLY=0" ]
+  }
+
+  cflags_cc += [
+    "-Wall",
+    "-Werror",
+    "-fPIC",
+    "-fstack-protector-strong",
+    "-fno-common",
+    "-pipe",
+    "-Wextra",
+    "-Weffc++",
+    "-Wdate-time",
+    "-Wfloat-equal",
+    "-Wshadow",
+    "-Wformat=2",
+  ]
+
+  cflags_cc += [
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/../../../../aarch64-linux-gnu/include/c++/7.5.0",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/../../../../aarch64-linux-gnu/include/c++/7.5.0/aarch64-linux-gnu",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/../../../../aarch64-linux-gnu/include/c++/7.5.0/backward",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/include",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/include-fixed",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../lib/gcc/aarch64-linux-gnu/7.5.0/../../../../aarch64-linux-gnu/include",
+    "-isystem",
+    "${GCC_LINARO_PATH}/bin/../aarch64-linux-gnu/libc/usr/include",
+    "-target",
+    "aarch64-linux-gnu",
+  ]
+
+  asmflags = cflags_cc
+  ldflags = cflags_cc
+  ldflags += [
+    "-Wl,-z,relro",
+    "-Wl,-z,now",
+    "-Wl,-z,noexecstack",
+  ]
+}
+
+group("maple-rt") {
+  deps = [
+    "${MAPLE_MRT_ROOT}/compiler-rt:libmplcompiler-rt",
+    "${MAPLE_MRT_ROOT}/dexinterface:libdexinterface",
+    "${MAPLE_MRT_ROOT}/interpreter:libzterp",
+    "${MAPLE_MRT_ROOT}/libcore-static-binding-jni:libcore-static-binding-jni",
+    "${MAPLE_MRT_ROOT}/maplert:libmaplert",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libhuawei_secure_c",
+  ]
+}
diff --git a/src/mrt/bin/mplsh b/src/mrt/bin/mplsh
new file mode 100755
index 0000000000000000000000000000000000000000..8f449f93a6c7c3e3f5f9985de6194703967e46f8
Binary files /dev/null and b/src/mrt/bin/mplsh differ
diff --git a/src/mrt/bin/mplsh_android b/src/mrt/bin/mplsh_android
new file mode 100755
index 0000000000000000000000000000000000000000..0b4b7c714858136ba0936fdf2d9d17189bed69d4
Binary files /dev/null and b/src/mrt/bin/mplsh_android differ
diff --git a/src/mrt/codetricks/arch/arm64/ContainerHelpers_binarySearch.s b/src/mrt/codetricks/arch/arm64/ContainerHelpers_binarySearch.s
new file mode 100755
index 0000000000000000000000000000000000000000..b22d58bd1e38d76508d400ff0650cf37be0b2fda
--- /dev/null
+++ b/src/mrt/codetricks/arch/arm64/ContainerHelpers_binarySearch.s
@@ -0,0 +1,133 @@
+#define kArrayLengthOffset 12
+#define ARRAY_START_ADDRESS_OFFSET 16
+
+        .section        .rodata
+        .align  2
+.Lmethod_desc.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized:
+        .word __methods_info__Landroid_2Futil_2FContainerHelpers_3B - .
+        .short 16
+        .short 0
+        .section  .java_text,"ax"
+        .global Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized
+        .type Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized, %function
+        .align 2
+        .word .Lmethod_desc.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized-.
+Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized:
+        .cfi_startproc
+        .cfi_personality 155, DW.ref.__mpl_personality_v0
+        stp     x29, x30, [sp,#-32]!
+        .cfi_def_cfa_offset 32
+        .cfi_offset 29, -32
+        .cfi_offset 30, -24
+        mov     x29, sp
+        .cfi_def_cfa_register 29
+        ldr     wzr, [x19]           // yieldpoint
+                                     // x0: int[] array,  w1: size,  w2: value
+        cbz     x0, .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized5
+        ldr     w7, [x0, #kArrayLengthOffset]        // w7: array length
+        cmp     w1, w7               // check array boundry
+        bgt     .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized6
+        add     x3, x0, #16          // x3: start address of array elements
+        mov     w4, #0               // w4: lo = 0
+        sub     w5, w1, #1           // w5: hi = size - 1
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized1:
+        cmp     w4, w5               // lo <= hi
+        bgt     .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized3
+        ldr     wzr, [x19]           // yieldpoint
+        add     w6, w4, w5           // w6: mid = lo + hi
+        lsr     w6, w6, #1           //     mid = mid >>> 1
+        ldr     w0, [x3,w6,SXTW #2]  // w0: midVal = array[mid]
+        cmp     w0, w2               // midVal < value
+        bge     .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized2
+        add     w4, w6, #1           // lo = mid + 1
+        b       .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized1
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized2:
+        sub     w5, w6, #1           // hi = mid - 1
+        bgt     .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized1
+        mvn     w4, w6               // return mid
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized3:
+        mvn     w0, w4               // return ~lo
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized4:
+        ldp     x29, x30, [sp], #32
+        .cfi_remember_state
+        .cfi_restore 30
+        .cfi_restore 29
+        .cfi_def_cfa 31, 0
+        ret
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized5:
+        .cfi_restore_state
+        bl       MCC_ThrowNullPointerException
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized6:
+        bl       MCC_ThrowArrayIndexOutOfBoundsException
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized7:
+        .cfi_endproc
+        .size Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized, .-Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized
+        .word 0xFFFFFFFF
+        .word .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized4-Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimized
+
+        .section        .rodata
+        .align  2
+.Lmethod_desc.Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B:
+        .word __methods_info__Landroid_2Futil_2FSparseArray_3B+672-.
+        .short 16
+        .short 0
+        .section  .java_text,"ax"
+        .global  Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B
+        .type   Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B, %function
+        .align 2
+        .word .Lmethod_desc.Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B-.
+Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B:
+.Label.Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B1:          // label order 564653
+        .cfi_startproc
+        .cfi_personality 155, DW.ref.__mpl_personality_v0
+        //      LINE SparseArray.java : 67, DEX_INSTIDX : 0 ||0000: sget-object: Landroid/util/SparseArray;.DELETED:Ljava/lang/Object; // field@37c3
+        adrp    x0, :got:Landroid_2Futil_2FSparseArray_3B_7CDELETED
+        ldr     x0, [x0,#:got_lo12:Landroid_2Futil_2FSparseArray_3B_7CDELETED]
+        ldr     x0, [x0]
+.Label.Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B4:          // label order 564654
+        ret
+.Label.Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B3:          // label order 564655
+.Label.Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B2:          // label order 564656
+        .cfi_endproc
+.Label.Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B.end:
+        .size   Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B, .-Landroid_2Futil_2FSparseArray_3B_7CgetDelete_7C_28_29Ljava_2Flang_2FObject_3B
+
+        .section        .rodata
+        .align  2
+.Lmethod_desc.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection:
+        .word __methods_info__Landroid_2Futil_2FContainerHelpers_3B-.
+        .short 16
+        .short 0
+        .section  .java_text,"ax"
+        .global Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection
+        .type Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection, %function
+        .align 2
+        .word .Lmethod_desc.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection-.
+Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection:
+        .cfi_startproc
+        .cfi_personality 155, DW.ref.__mpl_personality_v0
+        add     x3, x0, #ARRAY_START_ADDRESS_OFFSET          // x3: start address of array elements
+        mov     w4, #0               // w4: lo = 0
+        sub     w5, w1, #1           // w5: hi = size - 1
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection1:
+        cmp     w4, w5               // lo <= hi
+        bgt     .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection3
+        add     w0, w4, w5           // w0: mid = lo + hi
+        lsr     w0, w0, #1           //     mid = mid >>> 1
+        ldr     w6, [x3,w0,SXTW #2]  // w6: midVal = array[mid]
+        cmp     w6, w2               // midVal < value
+        bge     .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection2
+        add     w4, w0, #1           // lo = mid + 1
+        b       .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection1
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection2:
+        sub     w5, w0, #1           // hi = mid - 1
+        bgt     .Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection1
+        ret                          // return mid
+.Label.Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection3:
+        mvn     w0, w4               // return ~lo
+        ret
+        .cfi_endproc
+        .size Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection, .-Landroid_2Futil_2FContainerHelpers_3B_7CbinarySearch_7C_28AIII_29I__optimizedForCollection
+       .word 0xFFFFFFFF
+       .word 0
+
diff --git a/src/mrt/codetricks/arch/arm64/duplicateFunc.s b/src/mrt/codetricks/arch/arm64/duplicateFunc.s
new file mode 100644
index 0000000000000000000000000000000000000000..cb5686251e16b0309c05ee913e5ff447abbf6eda
--- /dev/null
+++ b/src/mrt/codetricks/arch/arm64/duplicateFunc.s
@@ -0,0 +1,1718 @@
+# ++++++++WARNING++++++++WARNING++++++++WARNING++++++++
+# +
+# + NEED TO BE CAREFUL WHEN THIS FILE IS MODIFIED.
+# +
+# + This file has been hand modified to preserve x11 whenever it can.
+# + It is accomplished by observing x29 == sp, and x11 is saved
+# + in the same stack location as x29 instead of x29.
+# + Further all .cfi directive for 29 is changed to 11
+# + In addition, there is no need to perform 'mv x29, sp' and the
+# + corresponding .cfe for 29.
+# +
+# + If any of the string functions is used by a MRT* function then
+# + internal to the string function the usage of x11 is prohibited.
+# + See strcmp as example.
+# +
+# ++++++++WARNING++++++++WARNING++++++++WARNING++++++++
+#ifndef ENABLE_ASSERT_RC_NZ
+#define ENABLE_ASSERT_RC_NZ 1
+#endif
+// following constant should be same with size.h
+#define RC_COLOR_CLEAR_MASK  0x3fffffff
+#define RC_CYCLE_COLOR_BROWN 0xc0000000
+#define STRONG_RC_BITS_MASK  0x0000ffff
+#define RC_BITS_MSB_INDEX    15
+#define WEAK_COLLECTED_INDEX 29
+
+#define WEAK_RC_ONE          0x00400000
+#define WEAK_RC_BITS_MASK    0x1fc00000
+#define WEAK_COLLECT         0x20000000
+#define RESURRECT_STRONG_MASK  0x003fffff
+
+
+        .text
+        .align  2
+        .p2align 4
+        .local strlen
+        .type   strlen, %function
+strlen:
+        and     x4, x0, 4096 - 1
+        mov     x8, 0x0101010101010101
+        cmp     x4, 4096 - 16
+        b.gt    .Lpage_cross
+        ldp     x2, x3, [x0]
+        sub     x4, x2, x8
+        orr     x5, x2, 0x7f7f7f7f7f7f7f7f
+        sub     x6, x3, x8
+        orr     x7, x3, 0x7f7f7f7f7f7f7f7f
+        bics    x4, x4, x5
+        bic     x5, x6, x7
+        ccmp    x5, 0, 0, eq
+        beq     .Lmain_loop_entry
+
+        csel    x4, x4, x5, cc
+        mov     x0, 8
+        rev     x4, x4
+        clz     x4, x4
+        csel    x0, xzr, x0, cc
+        add     x0, x0, x4, lsr 3
+        ret
+        .p2align 4
+.Lmain_loop_entry:
+        bic     x1, x0, 15
+        sub     x1, x1, 16
+.Lmain_loop:
+        ldp     x2, x3, [x1, 32]!
+.Lpage_cross_entry:
+        sub     x4, x2, x8
+        sub     x6, x3, x8
+        orr     x5, x4, x6
+        tst     x5, x8, lsl 7
+        bne     1f
+        ldp     x2, x3, [x1, 16]
+        sub     x4, x2, x8
+        sub     x6, x3, x8
+        orr     x5, x4, x6
+        tst     x5, x8, lsl 7
+        beq     .Lmain_loop
+        add     x1, x1, 16
+1:
+        orr     x5, x2, 0x7f7f7f7f7f7f7f7f
+        orr     x7, x3, 0x7f7f7f7f7f7f7f7f
+        bics    x4, x4, x5
+        bic     x5, x6, x7
+        ccmp    x5, 0, 0, eq
+        beq     .Lnonascii_loop
+.Ltail:
+        csel    x4, x4, x5, cc
+        sub     x0, x1, x0
+        rev     x4, x4
+        add     x5, x0, 8
+        clz     x4, x4
+        csel    x0, x0, x5, cc
+        add     x0, x0, x4, lsr 3
+        ret
+.Lnonascii_loop:
+        ldp     x2, x3, [x1, 16]!
+        sub     x4, x2, x8
+        orr     x5, x2, 0x7f7f7f7f7f7f7f7f
+        sub     x6, x3, x8
+        orr     x7, x3, 0x7f7f7f7f7f7f7f7f
+        bics    x4, x4, x5
+        bic     x5, x6, x7
+        ccmp    x5, 0, 0, eq
+        bne     .Ltail
+        ldp     x2, x3, [x1, 16]!
+        sub     x4, x2, x8
+        orr     x5, x2, 0x7f7f7f7f7f7f7f7f
+        sub     x6, x3, x8
+        orr     x7, x3, 0x7f7f7f7f7f7f7f7f
+        bics    x4, x4, x5
+        bic     x5, x6, x7
+        ccmp    x5, 0, 0, eq
+        beq     .Lnonascii_loop
+        b       .Ltail
+.Lpage_cross:
+        bic     x1, x0, 15
+        ldp     x2, x3, [x1]
+        lsl     x4, x0, 3
+        mov     x7, -1
+        lsl     x4, x7, x4
+        orr     x4, x4, 0x8080808080808080
+        orn     x2, x2, x4
+        orn     x5, x3, x4
+        tst     x0, 8
+        csel    x2, x2, x7, eq
+        csel    x3, x3, x5, eq
+        b       .Lpage_cross_entry
+        .size   strlen, .-strlen
+
+        .text
+        .align  2
+        .p2align 6
+        .local strncmp
+        .type   strncmp, %function
+strncmp:
+        cbz     x2, .Lret0_strncmp
+        eor     x8, x0, x1
+        mov     x11, #0x0101010101010101
+        tst     x8, #7
+        b.ne    .Lmisaligned8_strncmp
+        ands    x8, x0, #7
+        b.ne    .Lmutual_align_strncmp
+        sub     x13, x2, #1
+        lsr     x13, x13, #3
+.Lloop_aligned_strncmp:
+        ldr     x3, [x0], #8
+        ldr     x4, [x1], #8
+.Lstart_realigned_strncmp:
+        subs    x13, x13, #1
+        sub     x8, x3, x11
+        orr     x9, x3, #0x7f7f7f7f7f7f7f7f
+        eor     x6, x3, x4
+        csinv   x15, x6, xzr, pl
+        bics    x5, x8, x9
+        ccmp    x15, #0, #0, eq
+        b.eq    .Lloop_aligned_strncmp
+        tbz     x13, #63, .Lnot_x2_strncmp
+        ands    x2, x2, #7
+        b.eq    .Lnot_x2_strncmp
+        lsl     x2, x2, #3
+        mov     x14, #~0
+        lsl     x14, x14, x2
+        bic     x3, x3, x14
+        bic     x4, x4, x14
+        orr     x5, x5, x14
+.Lnot_x2_strncmp:
+        orr     x7, x6, x5
+//#ifndef __AARCH64EB__
+        rev     x7, x7
+        rev     x3, x3
+        clz     x12, x7
+        rev     x4, x4
+        lsl     x3, x3, x12
+        lsl     x4, x4, x12
+        lsr     x3, x3, #56
+        sub     x0, x3, x4, lsr #56
+        ret
+.Lmutual_align_strncmp:
+        bic     x0, x0, #7
+        bic     x1, x1, #7
+        ldr     x3, [x0], #8
+        neg     x10, x8, lsl #3
+        ldr     x4, [x1], #8
+        mov     x9, #~0
+        sub     x13, x2, #1
+        lsr     x9, x9, x10
+        and     x10, x13, #7
+        lsr     x13, x13, #3
+        add     x2, x2, x8
+        add     x10, x10, x8
+        orr     x3, x3, x9
+        orr     x4, x4, x9
+        add     x13, x13, x10, lsr #3
+        b       .Lstart_realigned_strncmp
+.Lret0_strncmp:
+        mov     x0, #0
+        ret
+        .p2align 6
+.Lmisaligned8_strncmp:
+        sub     x2, x2, #1
+1:
+        ldrb    w3, [x0], #1
+        ldrb    w4, [x1], #1
+        subs    x2, x2, #1
+        ccmp    w3, #1, #0, cs
+        ccmp    w3, w4, #0, cs
+        b.eq    1b
+        sub     x0, x3, x4
+        ret
+        .size   strncmp, .-strncmp
+
+        .text
+        .align  2
+        .p2align 4
+        .local memcpy
+        .type   memcpy, %function
+memcpy:
+        prfm    PLDL1KEEP, [x1]
+        add     x4, x1, x2
+        add     x5, x0, x2
+        cmp     x2, 16
+        b.ls    .Lcopy16
+        cmp     x2, 96
+        b.hi    .Lcopy_long
+        sub     x9, x2, 1
+        ldp     x6, x7, [x1]
+        tbnz    x9, 6, .Lcopy96
+        ldp     x12, x13, [x4, -16]
+        tbz     x9, 5, 1f
+        ldp     x8, x9, [x1, 16]
+        ldp     x10, x11, [x4, -32]
+        stp     x8, x9, [x0, 16]
+        stp     x10, x11, [x5, -32]
+1:
+        stp     x6, x7, [x0]
+        stp     x12, x13, [x5, -16]
+        ret
+        .p2align 4
+.Lcopy16:
+        cmp     x2, 8
+        b.lo    1f
+        ldr     x6, [x1]
+        ldr     x7, [x4, -8]
+        str     x6, [x0]
+        str     x7, [x5, -8]
+        ret
+        .p2align 4
+1:
+        tbz     x2, 2, 1f
+        ldr     w6, [x1]
+        ldr     w7, [x4, -4]
+        str     w6, [x0]
+        str     w7, [x5, -4]
+        ret
+1:
+        cbz     x2, 2f
+        lsr     x9, x2, 1
+        ldrb    w6, [x1]
+        ldrb    w7, [x4, -1]
+        ldrb    w8, [x1, x9]
+        strb    w6, [x0]
+        strb    w8, [x0, x9]
+        strb    w7, [x5, -1]
+2:      ret
+        .p2align 4
+.Lcopy96:
+        ldp     x8, x9, [x1, 16]
+        ldp     x10, x11, [x1, 32]
+        ldp     x12, x13, [x1, 48]
+        ldp     x1, x2, [x4, -32]
+        ldp     x4, x3, [x4, -16]
+        stp     x6, x7, [x0]
+        stp     x8, x9, [x0, 16]
+        stp     x10, x11, [x0, 32]
+        stp     x12, x13, [x0, 48]
+        stp     x1, x2, [x5, -32]
+        stp     x4, x3, [x5, -16]
+        ret
+        .p2align 4
+.Lcopy_long:
+        and     x9, x0, 15
+        bic     x3, x0, 15
+        ldp     x12, x13, [x1]
+        sub     x1, x1, x9
+        add     x2, x2, x9
+        ldp     x6, x7, [x1, 16]
+        stp     x12, x13, [x0]
+        ldp     x8, x9, [x1, 32]
+        ldp     x10, x11, [x1, 48]
+        ldp     x12, x13, [x1, 64]!
+        subs    x2, x2, 128 + 16
+        b.ls    2f
+1:
+        stp     x6, x7, [x3, 16]
+        ldp     x6, x7, [x1, 16]
+        stp     x8, x9, [x3, 32]
+        ldp     x8, x9, [x1, 32]
+        stp     x10, x11, [x3, 48]
+        ldp     x10, x11, [x1, 48]
+        stp     x12, x13, [x3, 64]!
+        ldp     x12, x13, [x1, 64]!
+        subs    x2, x2, 64
+        b.hi    1b
+2:
+        ldp     x1, x2, [x4, -64]
+        stp     x6, x7, [x3, 16]
+        ldp     x6, x7, [x4, -48]
+        stp     x8, x9, [x3, 32]
+        ldp     x8, x9, [x4, -32]
+        stp     x10, x11, [x3, 48]
+        ldp     x10, x11, [x4, -16]
+        stp     x12, x13, [x3, 64]
+        stp     x1, x2, [x5, -64]
+        stp     x6, x7, [x5, -48]
+        stp     x8, x9, [x5, -32]
+        stp     x10, x11, [x5, -16]
+        ret
+        .size   memcpy, .-memcpy
+
+        .text
+        .align  2
+        .p2align 6
+        .local memmove
+        .type   memmove, %function
+memmove:
+        cmp     x0, x1
+        b.lo    .Ldownwards
+        add     x3, x1, x2
+        cmp     x0, x3
+        b.hs    memcpy
+        add     x6, x0, x2
+        add     x1, x1, x2
+        cmp     x2, #64
+        b.ge    .Lmov_not_short_up
+.Ltail63up:
+        ands    x3, x2, #0x30
+        b.eq    .Ltail15up
+        sub     x6, x6, x3
+        sub     x1, x1, x3
+        cmp     w3, #0x20
+        b.eq    1f
+        b.lt    2f
+        ldp     x7, x8, [x1, #32]
+        stp     x7, x8, [x6, #32]
+1:
+        ldp     x7, x8, [x1, #16]
+        stp     x7, x8, [x6, #16]
+2:
+        ldp     x7, x8, [x1]
+        stp     x7, x8, [x6]
+.Ltail15up:
+        tbz     x2, #3, 1f
+        ldr     x3, [x1, #-8]!
+        str     x3, [x6, #-8]!
+1:
+        tbz     x2, #2, 1f
+        ldr     w3, [x1, #-4]!
+        str     w3, [x6, #-4]!
+1:
+        tbz     x2, #1, 1f
+        ldrh    w3, [x1, #-2]!
+        strh    w3, [x6, #-2]!
+1:
+        tbz     x2, #0, 1f
+        ldrb    w3, [x1, #-1]
+        strb    w3, [x6, #-1]
+1:
+        ret
+.Lmov_not_short_up:
+        ands    x4, x1, #15
+        b.eq    2f
+        sub     x2, x2, x4
+        tbz     x4, #3, 1f
+        ldr     x3, [x1, #-8]!
+        str     x3, [x6, #-8]!
+1:
+        tbz     x4, #2, 1f
+        ldr     w3, [x1, #-4]!
+        str     w3, [x6, #-4]!
+1:
+        tbz     x4, #1, 1f
+        ldrh    w3, [x1, #-2]!
+        strh    w3, [x6, #-2]!
+1:
+        tbz     x4, #0, 1f
+        ldrb    w3, [x1, #-1]!
+        strb    w3, [x6, #-1]!
+1:
+        cmp     x2, #63
+        b.le    .Ltail63up
+2:
+        subs    x2, x2, #128
+        b.ge    .Lmov_body_large_up
+        ldp     x7, x8, [x1, #-64]!
+        ldp     x9, x10, [x1, #16]
+        ldp     x11, x12, [x1, #32]
+        ldp     x13, x14, [x1, #48]
+        stp     x7, x8, [x6, #-64]!
+        stp     x9, x10, [x6, #16]
+        stp     x11, x12, [x6, #32]
+        stp     x13, x14, [x6, #48]
+        tst     x2, #0x3f
+        b.ne    .Ltail63up
+        ret
+        .p2align 6
+.Lmov_body_large_up:
+        ldp     x7, x8, [x1, #-16]
+        ldp     x9, x10, [x1, #-32]
+        ldp     x11, x12, [x1, #-48]
+        ldp     x13, x14, [x1, #-64]!
+1:
+        stp     x7, x8, [x6, #-16]
+        ldp     x7, x8, [x1, #-16]
+        stp     x9, x10, [x6, #-32]
+        ldp     x9, x10, [x1, #-32]
+        stp     x11, x12, [x6, #-48]
+        ldp     x11, x12, [x1, #-48]
+        stp     x13, x14, [x6, #-64]!
+        ldp     x13, x14, [x1, #-64]!
+        subs    x2, x2, #64
+        b.ge    1b
+        stp     x7, x8, [x6, #-16]
+        stp     x9, x10, [x6, #-32]
+        stp     x11, x12, [x6, #-48]
+        stp     x13, x14, [x6, #-64]!
+        tst     x2, #0x3f
+        b.ne    .Ltail63up
+        ret
+.Ldownwards:
+        sub     x3, x1, #16
+        cmp     x0, x3
+        b.ls    memcpy
+        mov     x6, x0
+        cmp     x2, #64
+        b.ge    .Lmov_not_short_down
+.Ltail63down:
+        ands    x3, x2, #0x30
+        b.eq    .Ltail15down
+        add     x6, x6, x3
+        add     x1, x1, x3
+        cmp     w3, #0x20
+        b.eq    1f
+        b.lt    2f
+        ldp     x7, x8, [x1, #-48]
+        stp     x7, x8, [x6, #-48]
+1:
+        ldp     x7, x8, [x1, #-32]
+        stp     x7, x8, [x6, #-32]
+2:
+        ldp     x7, x8, [x1, #-16]
+        stp     x7, x8, [x6, #-16]
+.Ltail15down:
+        tbz     x2, #3, 1f
+        ldr     x3, [x1], #8
+        str     x3, [x6], #8
+1:
+        tbz     x2, #2, 1f
+        ldr     w3, [x1], #4
+        str     w3, [x6], #4
+1:
+        tbz     x2, #1, 1f
+        ldrh    w3, [x1], #2
+        strh    w3, [x6], #2
+1:
+        tbz     x2, #0, 1f
+        ldrb    w3, [x1]
+        strb    w3, [x6]
+1:
+        ret
+.Lmov_not_short_down:
+        neg     x4, x1
+        ands    x4, x4, #15
+        b.eq    2f
+        sub     x2, x2, x4
+        tbz     x4, #3, 1f
+        ldr     x3, [x1], #8
+        str     x3, [x6], #8
+1:
+        tbz     x4, #2, 1f
+        ldr     w3, [x1], #4
+        str     w3, [x6], #4
+1:
+        tbz     x4, #1, 1f
+        ldrh    w3, [x1], #2
+        strh    w3, [x6], #2
+1:
+        tbz     x4, #0, 1f
+        ldrb    w3, [x1], #1
+        strb    w3, [x6], #1
+1:
+        cmp     x2, #63
+        b.le    .Ltail63down
+2:
+        subs    x2, x2, #128
+        b.ge    .Lmov_body_large_down
+        ldp     x7, x8, [x1]
+        ldp     x9, x10, [x1, #16]
+        ldp     x11, x12, [x1, #32]
+        ldp     x13, x14, [x1, #48]
+        stp     x7, x8, [x6]
+        stp     x9, x10, [x6, #16]
+        stp     x11, x12, [x6, #32]
+        stp     x13, x14, [x6, #48]
+        tst     x2, #0x3f
+        add     x1, x1, #64
+        add     x6, x6, #64
+        b.ne    .Ltail63down
+        ret
+        .p2align 6
+.Lmov_body_large_down:
+        ldp     x7, x8, [x1, #0]
+        sub     x6, x6, #16
+        ldp     x9, x10, [x1, #16]
+        ldp     x11, x12, [x1, #32]
+        ldp     x13, x14, [x1, #48]!
+1:
+        stp     x7, x8, [x6, #16]
+        ldp     x7, x8, [x1, #16]
+        stp     x9, x10, [x6, #32]
+        ldp     x9, x10, [x1, #32]
+        stp     x11, x12, [x6, #48]
+        ldp     x11, x12, [x1, #48]
+        stp     x13, x14, [x6, #64]!
+        ldp     x13, x14, [x1, #64]!
+        subs    x2, x2, #64
+        b.ge    1b
+        stp     x7, x8, [x6, #16]
+        stp     x9, x10, [x6, #32]
+        stp     x11, x12, [x6, #48]
+        stp     x13, x14, [x6, #64]
+        add     x1, x1, #16
+        add     x6, x6, #64 + 16
+        tst     x2, #0x3f
+        b.ne    .Ltail63down
+        ret
+        .size   memmove, .-memmove
+
+        .text
+        .align  2
+        .p2align  6
+        .local strcmp
+        .type   strcmp, %function
+strcmp:
+        eor     x7, x0, x1
+        mov     x10, #0x0101010101010101
+        tst     x7, #7
+        b.ne    .Lmisaligned8_strcmp
+        ands    x7, x0, #7
+        b.ne    .Lmutual_align_strcmp
+.Lloop_aligned_strcmp:
+        ldr     x2, [x0], #8
+        ldr     x3, [x1], #8
+.Lstart_realigned_strcmp:
+        sub     x7, x2, x10
+        orr     x8, x2, #0x7f7f7f7f7f7f7f7f
+        eor     x5, x2, x3
+        bic     x4, x7, x8
+        orr     x6, x5, x4
+        cbz     x6, .Lloop_aligned_strcmp
+//#ifndef __AARCH64EB__
+        rev     x6, x6
+        rev     x2, x2
+        # WARNING
+        # Change register usage from x11 to x9
+        # Preserve x11 for issue #547
+        clz     x9, x6
+        rev     x3, x3
+        lsl     x2, x2, x9
+        lsl     x3, x3, x9
+        lsr     x2, x2, #56
+        sub     x0, x2, x3, lsr #56
+        ret
+.Lmutual_align_strcmp:
+        bic     x0, x0, #7
+        bic     x1, x1, #7
+        lsl     x7, x7, #3
+        ldr     x2, [x0], #8
+        neg     x7, x7
+        ldr     x3, [x1], #8
+        mov     x8, #~0
+        lsr     x8, x8, x7
+        orr     x2, x2, x8
+        orr     x3, x3, x8
+        b       .Lstart_realigned_strcmp
+.Lmisaligned8_strcmp:
+        ldrb    w2, [x0], #1
+        ldrb    w3, [x1], #1
+        cmp     w2, #1
+        ccmp    w2, w3, #0, cs
+        b.eq    .Lmisaligned8_strcmp
+        sub     x0, x2, x3
+        ret
+        .size   strcmp, .-strcmp
+
+        .text
+        .align  2
+        .p2align 6
+        .local memcmp
+        .type   memcmp, %function
+memcmp:
+        cbz     x2, .Lret0
+        eor     x8, x0, x1
+        tst     x8, #7
+        b.ne    .Lmisaligned8
+        ands    x8, x0, #7
+        b.ne    .Lmutual_align
+        add     x12, x2, #7
+        lsr     x12, x12, #3
+.Lloop_aligned:
+        ldr     x3, [x0], #8
+        ldr     x4, [x1], #8
+.Lstart_realigned:
+        subs    x12, x12, #1
+        eor     x6, x3, x4
+        csinv   x7, x6, xzr, ne
+        cbz     x7, .Lloop_aligned
+        cbnz    x12, .Lnot_limit
+        ands    x2, x2, #7
+        b.eq    .Lnot_limit
+        lsl     x2, x2, #3
+        mov     x13, #~0
+        lsl     x13, x13, x2
+        bic     x3, x3, x13
+        bic     x4, x4, x13
+        orr     x6, x6, x13
+.Lnot_limit:
+        rev     x6, x6
+        rev     x3, x3
+        rev     x4, x4
+        clz     x11, x6
+        lsl     x3, x3, x11
+        lsl     x4, x4, x11
+        lsr     x3, x3, #56
+        sub     x0, x3, x4, lsr #56
+        ret
+.Lmutual_align:
+        bic     x0, x0, #7
+        bic     x1, x1, #7
+        add     x2, x2, x8      /* Adjust the limit for the extra.  */
+        lsl     x8, x8, #3          /* Bytes beyond alignment -> bits.  */
+        ldr     x3, [x0], #8
+        neg     x8, x8              /* Bits to alignment -64.  */
+        ldr     x4, [x1], #8
+        mov     x9, #~0
+        lsr     x9, x9, x8
+        add     x12, x2, #7
+        orr     x3, x3, x9
+        orr     x4, x4, x9
+        lsr     x12, x12, #3
+        b       .Lstart_realigned
+.Lret0:
+        mov     x0, #0
+        ret
+        .p2align 6
+.Lmisaligned8:
+        sub     x2, x2, #1
+1:
+        ldrb    w3, [x0], #1
+        ldrb    w4, [x1], #1
+        subs    x2, x2, #1
+        ccmp    w3, w4, #0, cs
+        b.eq    1b
+        sub     x0, x3, x4
+        ret
+        .size   memcmp, .-memcmp
+
+        .text
+        .align  2
+        .p2align 6
+        .local memcmpMpl
+        .type   memcmpMpl, %function
+        # only for jstring comparison.
+        # return 1 for equal, return 0 for not-equal
+memcmpMpl:
+        cbz     x2, .Lret1Mpl
+.Lmutual_alignMpl:
+#ifdef USE_32BIT_REF
+        add     x12, x2, #7
+        ldr     x3, [x0], #8  // string content is always 8B aligned
+        ldr     x4, [x1], #8  // string content is always 8B aligned
+#else
+        bic     x0, x0, #7
+        bic     x1, x1, #7
+        mov     x8, #4         // Note, the string content offset is hard coded here: bad
+        add     x2, x2, x8      /* Adjust the limit for the extra.  */
+        lsl     x8, x8, #3          /* Bytes beyond alignment -> bits.  */
+        ldr     x3, [x0], #8
+        neg     x8, x8              /* Bits to alignment -64.  */
+        ldr     x4, [x1], #8
+        mov     x9, #~0
+        lsr     x9, x9, x8
+        add     x12, x2, #7
+        orr     x3, x3, x9
+        orr     x4, x4, x9
+#endif //USE_32BIT_REF
+        lsr     x12, x12, #3
+        b       .Lstart_realignedMpl
+.Lloop_alignedMpl:
+        ldr     x3, [x0], #8
+        ldr     x4, [x1], #8
+.Lstart_realignedMpl:
+        subs    x12, x12, #1
+        eor     x6, x3, x4
+        csinv   x7, x6, xzr, ne
+        cbz     x7, .Lloop_alignedMpl
+        cbnz    x12, .Lret0Mpl
+        ands    x2, x2, #7
+        b.eq    .Lnot_limitMpl
+        lsl     x2, x2, #3
+        mov     x13, #~0
+        lsl     x13, x13, x2
+        bic     x3, x3, x13
+        bic     x4, x4, x13
+        orr     x6, x6, x13
+.Lnot_limitMpl:
+        rev     x6, x6
+        rev     x3, x3
+        rev     x4, x4
+        clz     x11, x6
+        lsl     x3, x3, x11
+        lsl     x4, x4, x11
+        lsr     x3, x3, #56
+        sub     x0, x3, x4, lsr #56
+        cbnz    x0, .Lret0Mpl
+.Lret1Mpl:
+        mov     x0, #1
+        ret
+        .p2align 6
+.Lret0Mpl:
+        mov     x0, #0
+        ret
+        .p2align 6
+        .size   memcmpMpl, .-memcmpMpl
+
+#Libframework_start
+        .section        .text.signalExceptionForError,"ax",@progbits
+        .globl  signalExceptionForError // -- Begin function signalExceptionForError
+        .p2align        2
+        .type   signalExceptionForError,@function
+signalExceptionForError:                // @signalExceptionForError
+        .cfi_startproc
+// %bb.0:
+        sub     sp, sp, #80             // =80
+        str     x23, [sp, #16]          // 8-byte Folded Spill
+        stp     x22, x21, [sp, #32]     // 16-byte Folded Spill
+        stp     x20, x19, [sp, #48]     // 16-byte Folded Spill
+        stp     x29, x30, [sp, #64]     // 16-byte Folded Spill
+        add     x29, sp, #64            // =64
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        .cfi_offset w19, -24
+        .cfi_offset w20, -32
+        .cfi_offset w21, -40
+        .cfi_offset w22, -48
+        .cfi_offset w23, -64
+        mrs     x23, TPIDR_EL0
+        ldr     x8, [x23, #40]
+        mov     w20, w3
+        mov     w21, w2
+        mov     x19, x0
+        cmn     w2, #23                 // =23
+        str     x8, [sp, #8]
+        b.gt    .LBB0_4
+// %bb.1:
+        orr     w8, wzr, #0x80000000
+        cmp     w21, w8
+        b.eq    .LBB0_8_signalExceptionForError
+// %bb.2:
+        cmn     w21, #38                // =38
+        b.ne    .LBB0_7_signalExceptionForError
+// %bb.3:
+        adrp    x1, .L.str.3
+        add     x1, x1, :lo12:.L.str.3
+        b       .LBB0_10
+.LBB0_4:
+        cmn     w21, #22                // =22
+        b.eq    .LBB0_9
+// %bb.5:
+        cmn     w21, #12                // =12
+        b.ne    .LBB0_7_signalExceptionForError
+// %bb.6:
+        adrp    x1, .L.str.2
+        add     x1, x1, :lo12:.L.str.2
+        b       .LBB0_10
+.LBB0_7_signalExceptionForError:
+        adrp    x22, .L.str.5
+        add     x22, x22, :lo12:.L.str.5
+        orr     w0, wzr, #0x6
+        mov     x1, xzr
+        mov     x2, x22
+        mov     w3, w21
+        bl      __android_log_print
+        mov     x0, sp
+        bl      _ZN7android7String8C1Ev
+        mov     x0, sp
+        mov     x1, x22
+        mov     w2, w21
+        bl      _ZN7android7String812appendFormatEPKcz
+        ldr     x2, [sp]
+        adrp    x8, .L.str
+        adrp    x9, .L.str.6
+        add     x8, x8, :lo12:.L.str
+        add     x9, x9, :lo12:.L.str.6
+        tst     w20, #0x1
+        csel    x1, x9, x8, ne
+        mov     x0, x19
+        bl      jniThrowException
+        mov     x0, sp
+        bl      _ZN7android7String8D1Ev
+        ldr     x8, [x23, #40]
+        ldr     x9, [sp, #8]
+        cmp     x8, x9
+        b.eq    .LBB0_12_signalExceptionForError
+        b       .LBB0_13_signalExceptionForError
+.LBB0_8_signalExceptionForError:
+        adrp    x1, .L.str
+        adrp    x2, .L.str.1
+        add     x1, x1, :lo12:.L.str
+        add     x2, x2, :lo12:.L.str.1
+        mov     x0, x19
+        b       .LBB0_11
+.LBB0_9:
+        adrp    x1, .L.str.4
+        add     x1, x1, :lo12:.L.str.4
+.LBB0_10:
+        mov     x0, x19
+        mov     x2, xzr
+.LBB0_11:
+        bl      jniThrowException
+        ldr     x8, [x23, #40]
+        ldr     x9, [sp, #8]
+        cmp     x8, x9
+        b.ne    .LBB0_13_signalExceptionForError
+.LBB0_12_signalExceptionForError:
+        ldp     x29, x30, [sp, #64]     // 16-byte Folded Reload
+        ldp     x20, x19, [sp, #48]     // 16-byte Folded Reload
+        ldp     x22, x21, [sp, #32]     // 16-byte Folded Reload
+        ldr     x23, [sp, #16]          // 8-byte Folded Reload
+        add     sp, sp, #80             // =80
+        ret
+.LBB0_13_signalExceptionForError:
+        bl      __stack_chk_fail
+.Lfunc_end0_signalExceptionForError:
+        .size   signalExceptionForError, .Lfunc_end0_signalExceptionForError-signalExceptionForError
+        .cfi_endproc
+                                        // -- End function
+        .section        .text.Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V_native,"ax",@progbits
+        .globl  Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V_native // -- Begin function Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V_native
+        .p2align        2
+        .type   Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V_native,@function
+Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V_native: // @Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V_native
+        .cfi_startproc
+// %bb.0:
+        str     x28, [sp, #-80]!        // 8-byte Folded Spill
+        stp     x24, x23, [sp, #16]     // 16-byte Folded Spill
+        stp     x22, x21, [sp, #32]     // 16-byte Folded Spill
+        stp     x20, x19, [sp, #48]     // 16-byte Folded Spill
+        stp     x29, x30, [sp, #64]     // 16-byte Folded Spill
+        add     x29, sp, #64            // =64
+        sub     sp, sp, #528            // =528
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        .cfi_offset w19, -24
+        .cfi_offset w20, -32
+        .cfi_offset w21, -40
+        .cfi_offset w22, -48
+        .cfi_offset w23, -56
+        .cfi_offset w24, -64
+        .cfi_offset w28, -80
+        mrs     x24, TPIDR_EL0
+        ldr     x8, [x24, #40]
+        stur    x8, [x29, #-72]
+        cbz     x0, .LBB1_25
+// %bb.1:
+        mov     x21, x1
+        mov     x19, x0
+        cbz     x1, .LBB1_5
+// %bb.2:
+        ldr     w9, [x21, #8]
+        tbnz    w9, #31, .LBB1_28
+// %bb.3:
+        asr     w8, w9, #1
+        add     x20, x21, #16           // =16
+        tbnz    w9, #0, .LBB1_6
+// %bb.4:
+        sxtw    x2, w8
+        mov     x0, x19
+        mov     x1, x20
+        bl      _ZN7android6Parcel13writeString16EPKDsm
+        mov     w19, w0
+        cbnz    w19, .LBB1_24
+        b       .LBB1_25
+.LBB1_5:
+        mov     x0, x19
+        mov     x1, xzr
+        mov     x2, xzr
+        bl      _ZN7android6Parcel13writeString16EPKDsm
+        mov     w19, w0
+        cbnz    w19, .LBB1_24
+        b       .LBB1_25
+.LBB1_6:
+        cmp     w9, #513                // =513
+        b.gt    .LBB1_15
+// %bb.7:
+        cmp     w9, #2                  // =2
+        sxtw    x2, w8
+        b.lt    .LBB1_14
+// %bb.8:
+        add     x9, sp, #8              // =8
+        add     x10, x9, x2, lsl #1
+        orr     x11, x9, #0x2
+        cmp     x10, x11
+        csel    x10, x10, x11, hi
+        mvn     x11, x9
+        add     x10, x10, x11
+        lsr     x10, x10, #1
+        add     x11, x10, #1            // =1
+        cmp     x11, #16                // =16
+        add     x10, sp, #8             // =8
+        b.lo    .LBB1_12
+// %bb.9:
+        and     x12, x11, #0xfffffffffffffff0
+        add     x13, sp, #8             // =8
+        add     x20, x20, x12
+        add     x10, x13, x12, lsl #1
+        add     x13, x13, #16           // =16
+        add     x14, x21, #24           // =24
+        mov     x15, x12
+.LBB1_10:                               // =>This Inner Loop Header: Depth=1
+        ldp     d0, d1, [x14, #-8]
+        subs    x15, x15, #16           // =16
+        add     x14, x14, #16           // =16
+        ushll   v0.8h, v0.8b, #0
+        ushll   v1.8h, v1.8b, #0
+        stp     q0, q1, [x13, #-16]
+        add     x13, x13, #32           // =32
+        b.ne    .LBB1_10
+// %bb.11:
+        cmp     x11, x12
+        b.eq    .LBB1_14
+.LBB1_12:
+        add     x8, x9, w8, sxtw #1
+.LBB1_13:                               // =>This Inner Loop Header: Depth=1
+        ldrb    w9, [x20], #1
+        strh    w9, [x10], #2
+        cmp     x10, x8
+        b.lo    .LBB1_13
+.LBB1_14:
+        add     x1, sp, #8              // =8
+        mov     x0, x19
+        bl      _ZN7android6Parcel13writeString16EPKDsm
+        mov     w19, w0
+        cbnz    w19, .LBB1_24
+        b       .LBB1_25
+.LBB1_15:
+        sxtw    x22, w8
+        orr     w1, wzr, #0x2
+        mov     x0, x22
+        bl      calloc
+        cbz     x0, .LBB1_23
+// %bb.16:
+        add     x8, x0, x22, lsl #1
+        mov     x23, x0
+        cmp     x8, x0
+        b.ls    .LBB1_22
+// %bb.17:
+        lsl     x9, x22, #1
+        sub     x9, x9, #1              // =1
+        lsr     x9, x9, #1
+        add     x10, x9, #1             // =1
+        cmp     x10, #16                // =16
+        mov     x9, x23
+        b.lo    .LBB1_21
+// %bb.18:
+        and     x11, x10, #0xfffffffffffffff0
+        add     x12, x23, #16           // =16
+        add     x20, x20, x11
+        add     x9, x23, x11, lsl #1
+        add     x13, x21, #24           // =24
+        mov     x14, x11
+.LBB1_19:                               // =>This Inner Loop Header: Depth=1
+        ldp     d0, d1, [x13, #-8]
+        subs    x14, x14, #16           // =16
+        add     x13, x13, #16           // =16
+        ushll   v0.8h, v0.8b, #0
+        ushll   v1.8h, v1.8b, #0
+        stp     q0, q1, [x12, #-16]
+        add     x12, x12, #32           // =32
+        b.ne    .LBB1_19
+// %bb.20:
+        cmp     x10, x11
+        b.eq    .LBB1_22
+.LBB1_21:                               // =>This Inner Loop Header: Depth=1
+        ldrb    w10, [x20], #1
+        strh    w10, [x9], #2
+        cmp     x9, x8
+        b.lo    .LBB1_21
+.LBB1_22:
+        mov     x0, x19
+        mov     x1, x23
+        mov     x2, x22
+        bl      _ZN7android6Parcel13writeString16EPKDsm
+        mov     w19, w0
+        mov     x0, x23
+        bl      free
+        cbnz    w19, .LBB1_24
+        b       .LBB1_25
+.LBB1_23:
+        mov     w19, #-12
+.LBB1_24:
+        //APP
+        mrs     x8, TPIDR_EL0
+        //NO_APP
+        ldr     x8, [x8, #56]
+        ldr     x0, [x8, #56]
+        ldr     x8, [x0]
+        ldr     x8, [x8]
+        blr     x8
+        mov     w2, w19
+        mov     w3, wzr
+        bl      signalExceptionForError
+        bl      MRT_CheckThrowPendingExceptionUnw
+.LBB1_25:
+        ldr     x8, [x24, #40]
+        ldur    x9, [x29, #-72]
+        cmp     x8, x9
+        b.ne    .LBB1_27
+// %bb.26:
+        add     sp, sp, #528            // =528
+        ldp     x29, x30, [sp, #64]     // 16-byte Folded Reload
+        ldp     x20, x19, [sp, #48]     // 16-byte Folded Reload
+        ldp     x22, x21, [sp, #32]     // 16-byte Folded Reload
+        ldp     x24, x23, [sp, #16]     // 16-byte Folded Reload
+        ldr     x28, [sp], #80          // 8-byte Folded Reload
+        ret
+.LBB1_27:
+        bl      __stack_chk_fail
+.LBB1_28:
+        bl      __ubsan_handle_implicit_conversion_minimal_abort
+.Lfunc_end1:
+        .size   Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V_native, .Lfunc_end1-Landroid_2Fos_2FParcel_3B_7CnativeWriteString_7C_28JLjava_2Flang_2FString_3B_29V_native
+        .cfi_endproc
+                                        // -- End function
+        .section        .text.Landroid_2Fos_2FParcel_3B_7CnativeWriteInt_7C_28JI_29V_native,"ax",@progbits
+        .globl  Landroid_2Fos_2FParcel_3B_7CnativeWriteInt_7C_28JI_29V_native // -- Begin function Landroid_2Fos_2FParcel_3B_7CnativeWriteInt_7C_28JI_29V_native
+        .p2align        2
+        .type   Landroid_2Fos_2FParcel_3B_7CnativeWriteInt_7C_28JI_29V_native,@function
+Landroid_2Fos_2FParcel_3B_7CnativeWriteInt_7C_28JI_29V_native: // @Landroid_2Fos_2FParcel_3B_7CnativeWriteInt_7C_28JI_29V_native
+        .cfi_startproc
+// %bb.0:
+        str     x19, [sp, #-32]!        // 8-byte Folded Spill
+        stp     x29, x30, [sp, #16]     // 16-byte Folded Spill
+        add     x29, sp, #16            // =16
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        .cfi_offset w19, -32
+        cbz     x0, .LBB2_3
+        bl      _ZN7android6Parcel10writeInt32Ei
+        cbz     w0, .LBB2_3
+        mrs     x8, TPIDR_EL0
+        ldr     x8, [x8, #56]
+        mov     w19, w0
+        ldr     x0, [x8, #56]
+        ldr     x8, [x0]
+        ldr     x8, [x8]
+        blr     x8
+        mov     w2, w19
+        mov     w3, wzr
+        bl      signalExceptionForError
+        ldp     x29, x30, [sp, #16]     // 16-byte Folded Reload
+        ldr     x19, [sp], #32          // 8-byte Folded Reload
+        b       MRT_CheckThrowPendingExceptionUnw
+.LBB2_3:
+        ldp     x29, x30, [sp, #16]     // 16-byte Folded Reload
+        ldr     x19, [sp], #32          // 8-byte Folded Reload
+        ret
+.Lfunc_end2_WriteInt:
+        .size   Landroid_2Fos_2FParcel_3B_7CnativeWriteInt_7C_28JI_29V_native, .Lfunc_end2_WriteInt-Landroid_2Fos_2FParcel_3B_7CnativeWriteInt_7C_28JI_29V_native
+        .cfi_endproc
+                                        // -- End function
+        .section        .text.Landroid_2Fos_2FParcel_3B_7CnativeWriteFloat_7C_28JF_29V_native,"ax",@progbits
+        .globl  Landroid_2Fos_2FParcel_3B_7CnativeWriteFloat_7C_28JF_29V_native // -- Begin function Landroid_2Fos_2FParcel_3B_7CnativeWriteFloat_7C_28JF_29V_native
+        .p2align        2
+        .type   Landroid_2Fos_2FParcel_3B_7CnativeWriteFloat_7C_28JF_29V_native,@function
+Landroid_2Fos_2FParcel_3B_7CnativeWriteFloat_7C_28JF_29V_native: // @Landroid_2Fos_2FParcel_3B_7CnativeWriteFloat_7C_28JF_29V_native
+        .cfi_startproc
+        str     x19, [sp, #-32]!        // 8-byte Folded Spill
+        stp     x29, x30, [sp, #16]     // 16-byte Folded Spill
+        add     x29, sp, #16            // =16
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        .cfi_offset w19, -32
+        cbz     x0, .LBB5_3
+        bl      _ZN7android6Parcel10writeFloatEf
+        cbz     w0, .LBB5_3
+        mrs     x8, TPIDR_EL0
+        ldr     x8, [x8, #56]
+        mov     w19, w0
+        ldr     x0, [x8, #56]
+        ldr     x8, [x0]
+        ldr     x8, [x8]
+        blr     x8
+        mov     w2, w19
+        mov     w3, wzr
+        bl      signalExceptionForError
+        ldp     x29, x30, [sp, #16]     // 16-byte Folded Reload
+        ldr     x19, [sp], #32          // 8-byte Folded Reload
+        b       MRT_CheckThrowPendingExceptionUnw
+.LBB5_3:
+        ldp     x29, x30, [sp, #16]     // 16-byte Folded Reload
+        ldr     x19, [sp], #32          // 8-byte Folded Reload
+        ret
+.Lfunc_end9:
+        .size   Landroid_2Fos_2FParcel_3B_7CnativeWriteFloat_7C_28JF_29V_native, .Lfunc_end9-Landroid_2Fos_2FParcel_3B_7CnativeWriteFloat_7C_28JF_29V_native
+        .cfi_endproc
+                                        // -- End function
+        .section        .text.Landroid_2Fos_2FParcel_3B_7CnativeWriteLong_7C_28JJ_29V_native,"ax",@progbits
+        .globl  Landroid_2Fos_2FParcel_3B_7CnativeWriteLong_7C_28JJ_29V_native // -- Begin function Landroid_2Fos_2FParcel_3B_7CnativeWriteLong_7C_28JJ_29V_native
+        .p2align        2
+        .type   Landroid_2Fos_2FParcel_3B_7CnativeWriteLong_7C_28JJ_29V_native,@function
+Landroid_2Fos_2FParcel_3B_7CnativeWriteLong_7C_28JJ_29V_native: // @Landroid_2Fos_2FParcel_3B_7CnativeWriteLong_7C_28JJ_29V_native
+        .cfi_startproc
+// %bb.0:
+        str     x19, [sp, #-32]!        // 8-byte Folded Spill
+        stp     x29, x30, [sp, #16]     // 16-byte Folded Spill
+        add     x29, sp, #16            // =16
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        .cfi_offset w19, -32
+        cbz     x0, .LBB6_3
+// %bb.1:
+        bl      _ZN7android6Parcel10writeInt64El
+        cbz     w0, .LBB6_3
+// %bb.2:
+        //APP
+        mrs     x8, TPIDR_EL0
+        //NO_APP
+        ldr     x8, [x8, #56]
+        mov     w19, w0
+        ldr     x0, [x8, #56]
+        ldr     x8, [x0]
+        ldr     x8, [x8]
+        blr     x8
+        mov     w2, w19
+        mov     w3, wzr
+        bl      signalExceptionForError
+        ldp     x29, x30, [sp, #16]     // 16-byte Folded Reload
+        ldr     x19, [sp], #32          // 8-byte Folded Reload
+        b       MRT_CheckThrowPendingExceptionUnw
+.LBB6_3:
+        ldp     x29, x30, [sp, #16]     // 16-byte Folded Reload
+        ldr     x19, [sp], #32          // 8-byte Folded Reload
+        ret
+.Lfunc_end8:
+        .size   Landroid_2Fos_2FParcel_3B_7CnativeWriteLong_7C_28JJ_29V_native, .Lfunc_end8-Landroid_2Fos_2FParcel_3B_7CnativeWriteLong_7C_28JJ_29V_native
+        .cfi_endproc
+                                        // -- End function
+        .section        .text.Landroid_2Fos_2FParcel_3B_7CnativeReadString_7C_28J_29Ljava_2Flang_2FString_3B_native,"ax",@progbits
+        .globl  Landroid_2Fos_2FParcel_3B_7CnativeReadString_7C_28J_29Ljava_2Flang_2FString_3B_native // -- Begin function Landroid_2Fos_2FParcel_3B_7CnativeReadString_7C_28J_29Ljava_2Flang_2FString_3B_native
+        .p2align        2
+        .type   Landroid_2Fos_2FParcel_3B_7CnativeReadString_7C_28J_29Ljava_2Flang_2FString_3B_native,@function
+Landroid_2Fos_2FParcel_3B_7CnativeReadString_7C_28J_29Ljava_2Flang_2FString_3B_native: // @Landroid_2Fos_2FParcel_3B_7CnativeReadString_7C_28J_29Ljava_2Flang_2FString_3B_native
+        .cfi_startproc
+// %bb.0:
+        sub     sp, sp, #48             // =48
+        str     x19, [sp, #16]          // 8-byte Folded Spill
+        stp     x29, x30, [sp, #32]     // 16-byte Folded Spill
+        add     x29, sp, #32            // =32
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        .cfi_offset w19, -32
+        mrs     x19, TPIDR_EL0
+        ldr     x8, [x19, #40]
+        str     x8, [sp, #8]
+        cbz     x0, .LBB3_4
+// %bb.1:
+        mov     x1, sp
+        bl      _ZNK7android6Parcel19readString16InplaceEPm
+        cbz     x0, .LBB3_4
+// %bb.2:
+        ldr     x1, [sp]
+        lsr     x8, x1, #31
+        cbnz    x8, .LBB3_7
+// %bb.3:
+                                        // kill: def $w1 killed $w1 killed $x1
+        bl      MRT_NewHeapJStr
+.LBB3_4:
+        ldr     x8, [x19, #40]
+        ldr     x9, [sp, #8]
+        cmp     x8, x9
+        b.ne    .LBB3_6
+// %bb.5:
+        ldp     x29, x30, [sp, #32]     // 16-byte Folded Reload
+        ldr     x19, [sp, #16]          // 8-byte Folded Reload
+        add     sp, sp, #48             // =48
+        ret
+.LBB3_6:
+        bl      __stack_chk_fail
+.LBB3_7:
+        bl      __ubsan_handle_implicit_conversion_minimal_abort
+.Lfunc_end3_ReadString:
+        .size   Landroid_2Fos_2FParcel_3B_7CnativeReadString_7C_28J_29Ljava_2Flang_2FString_3B_native, .Lfunc_end3_ReadString-Landroid_2Fos_2FParcel_3B_7CnativeReadString_7C_28J_29Ljava_2Flang_2FString_3B_native
+        .cfi_endproc
+                                        // -- End function
+        .section        .text.Landroid_2Fos_2FParcel_3B_7CnativeReadInt_7C_28J_29I_native,"ax",@progbits
+        .globl  Landroid_2Fos_2FParcel_3B_7CnativeReadInt_7C_28J_29I_native // -- Begin function Landroid_2Fos_2FParcel_3B_7CnativeReadInt_7C_28J_29I_native
+        .p2align        2
+        .type   Landroid_2Fos_2FParcel_3B_7CnativeReadInt_7C_28J_29I_native,@function
+Landroid_2Fos_2FParcel_3B_7CnativeReadInt_7C_28J_29I_native: // @Landroid_2Fos_2FParcel_3B_7CnativeReadInt_7C_28J_29I_native
+        .cfi_startproc
+// %bb.0:
+        cbz     x0, .LBB4_2
+// %bb.1:
+        b       _ZNK7android6Parcel9readInt32Ev
+.LBB4_2:
+        ret
+.Lfunc_end4_nativeReadInt:
+        .size   Landroid_2Fos_2FParcel_3B_7CnativeReadInt_7C_28J_29I_native, .Lfunc_end4_nativeReadInt-Landroid_2Fos_2FParcel_3B_7CnativeReadInt_7C_28J_29I_native
+        .cfi_endproc
+                                        // -- End function
+        .section        .text.Landroid_2Fos_2FParcel_3B_7CnativeWriteInterfaceToken_7C_28JLjava_2Flang_2FString_3B_29V_native,"ax",@progbits
+        .globl  Landroid_2Fos_2FParcel_3B_7CnativeWriteInterfaceToken_7C_28JLjava_2Flang_2FString_3B_29V_native // -- Begin function Landroid_2Fos_2FParcel_3B_7CnativeWriteInterfaceToken_7C_28JLjava_2Flang_2FString_3B_29V_native
+        .p2align        2
+        .type   Landroid_2Fos_2FParcel_3B_7CnativeWriteInterfaceToken_7C_28JLjava_2Flang_2FString_3B_29V_native,@function
+Landroid_2Fos_2FParcel_3B_7CnativeWriteInterfaceToken_7C_28JLjava_2Flang_2FString_3B_29V_native: // @Landroid_2Fos_2FParcel_3B_7CnativeWriteInterfaceToken_7C_28JLjava_2Flang_2FString_3B_29V_native
+        .cfi_startproc
+// %bb.0:
+        str     x28, [sp, #-80]!        // 8-byte Folded Spill
+        stp     x24, x23, [sp, #16]     // 16-byte Folded Spill
+        stp     x22, x21, [sp, #32]     // 16-byte Folded Spill
+        stp     x20, x19, [sp, #48]     // 16-byte Folded Spill
+        stp     x29, x30, [sp, #64]     // 16-byte Folded Spill
+        add     x29, sp, #64            // =64
+        sub     sp, sp, #528            // =528
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        .cfi_offset w19, -24
+        .cfi_offset w20, -32
+        .cfi_offset w21, -40
+        .cfi_offset w22, -48
+        .cfi_offset w23, -56
+        .cfi_offset w24, -64
+        .cfi_offset w28, -80
+        mrs     x24, TPIDR_EL0
+        ldr     x8, [x24, #40]
+        stur    x8, [x29, #-72]
+        cbz     x0, .LBB5_15
+// %bb.1:
+        mov     x22, x1
+        cbz     x1, .LBB5_15
+// %bb.2:
+        ldr     w9, [x22, #8]
+        tbnz    w9, #31, .LBB5_26
+// %bb.3:
+        mov     x19, x0
+        asr     w8, w9, #1
+        add     x20, x22, #16           // =16
+        tbnz    w9, #0, .LBB5_5
+// %bb.4:
+        sxtw    x2, w8
+        add     x0, sp, #8              // =8
+        mov     x1, x20
+        bl      _ZN7android8String16C1EPKDsm
+        add     x1, sp, #8              // =8
+        mov     x0, x19
+        bl      _ZN7android6Parcel19writeInterfaceTokenERKNS_8String16E
+        add     x0, sp, #8              // =8
+        b       .LBB5_14
+.LBB5_5:
+        cmp     w9, #513                // =513
+        b.gt    .LBB5_17
+// %bb.6:
+        cmp     w9, #2                  // =2
+        sxtw    x2, w8
+        b.lt    .LBB5_13
+// %bb.7:
+        add     x9, sp, #8              // =8
+        add     x10, x9, x2, lsl #1
+        orr     x11, x9, #0x2
+        cmp     x10, x11
+        csel    x10, x10, x11, hi
+        mvn     x11, x9
+        add     x10, x10, x11
+        lsr     x10, x10, #1
+        add     x11, x10, #1            // =1
+        cmp     x11, #16                // =16
+        add     x10, sp, #8             // =8
+        b.lo    .LBB5_11
+// %bb.8:
+        and     x12, x11, #0xfffffffffffffff0
+        add     x13, sp, #8             // =8
+        add     x20, x20, x12
+        add     x10, x13, x12, lsl #1
+        add     x13, x13, #16           // =16
+        add     x14, x22, #24           // =24
+        mov     x15, x12
+.LBB5_9:                                // =>This Inner Loop Header: Depth=1
+        ldp     d0, d1, [x14, #-8]
+        subs    x15, x15, #16           // =16
+        add     x14, x14, #16           // =16
+        ushll   v0.8h, v0.8b, #0
+        ushll   v1.8h, v1.8b, #0
+        stp     q0, q1, [x13, #-16]
+        add     x13, x13, #32           // =32
+        b.ne    .LBB5_9
+// %bb.10:
+        cmp     x11, x12
+        b.eq    .LBB5_13
+.LBB5_11:
+        add     x8, x9, w8, sxtw #1
+.LBB5_12:                               // =>This Inner Loop Header: Depth=1
+        ldrb    w9, [x20], #1
+        strh    w9, [x10], #2
+        cmp     x10, x8
+        b.lo    .LBB5_12
+.LBB5_13:
+        mov     x0, sp
+        add     x1, sp, #8              // =8
+        bl      _ZN7android8String16C1EPKDsm
+        mov     x1, sp
+        mov     x0, x19
+        bl      _ZN7android6Parcel19writeInterfaceTokenERKNS_8String16E
+        mov     x0, sp
+.LBB5_14:
+        bl      _ZN7android8String16D1Ev
+.LBB5_15:
+        ldr     x8, [x24, #40]
+        ldur    x9, [x29, #-72]
+        cmp     x8, x9
+        b.ne    .LBB5_25
+.LBB5_16:
+        add     sp, sp, #528            // =528
+        ldp     x29, x30, [sp, #64]     // 16-byte Folded Reload
+        ldp     x20, x19, [sp, #48]     // 16-byte Folded Reload
+        ldp     x22, x21, [sp, #32]     // 16-byte Folded Reload
+        ldp     x24, x23, [sp, #16]     // 16-byte Folded Reload
+        ldr     x28, [sp], #80          // 8-byte Folded Reload
+        ret
+.LBB5_17:
+        sxtw    x23, w8
+        orr     w1, wzr, #0x2
+        mov     x0, x23
+        bl      calloc
+        cbz     x0, .LBB5_15
+// %bb.18:
+        add     x8, x0, x23, lsl #1
+        mov     x21, x0
+        cmp     x8, x0
+        b.ls    .LBB5_24
+// %bb.19:
+        lsl     x9, x23, #1
+        sub     x9, x9, #1              // =1
+        lsr     x9, x9, #1
+        add     x10, x9, #1             // =1
+        cmp     x10, #16                // =16
+        mov     x9, x21
+        b.lo    .LBB5_23
+// %bb.20:
+        and     x11, x10, #0xfffffffffffffff0
+        add     x12, x21, #16           // =16
+        add     x20, x20, x11
+        add     x9, x21, x11, lsl #1
+        add     x13, x22, #24           // =24
+        mov     x14, x11
+.LBB5_21:                               // =>This Inner Loop Header: Depth=1
+        ldp     d0, d1, [x13, #-8]
+        subs    x14, x14, #16           // =16
+        add     x13, x13, #16           // =16
+        ushll   v0.8h, v0.8b, #0
+        ushll   v1.8h, v1.8b, #0
+        stp     q0, q1, [x12, #-16]
+        add     x12, x12, #32           // =32
+        b.ne    .LBB5_21
+// %bb.22:
+        cmp     x10, x11
+        b.eq    .LBB5_24
+.LBB5_23:                               // =>This Inner Loop Header: Depth=1
+        ldrb    w10, [x20], #1
+        strh    w10, [x9], #2
+        cmp     x9, x8
+        b.lo    .LBB5_23
+.LBB5_24:
+        add     x0, sp, #8              // =8
+        mov     x1, x21
+        mov     x2, x23
+        bl      _ZN7android8String16C1EPKDsm
+        add     x1, sp, #8              // =8
+        mov     x0, x19
+        bl      _ZN7android6Parcel19writeInterfaceTokenERKNS_8String16E
+        add     x0, sp, #8              // =8
+        bl      _ZN7android8String16D1Ev
+        mov     x0, x21
+        bl      free
+        ldr     x8, [x24, #40]
+        ldur    x9, [x29, #-72]
+        cmp     x8, x9
+        b.eq    .LBB5_16
+.LBB5_25:
+        bl      __stack_chk_fail
+.LBB5_26:
+        bl      __ubsan_handle_implicit_conversion_minimal_abort
+.Lfunc_end5:
+        .size   Landroid_2Fos_2FParcel_3B_7CnativeWriteInterfaceToken_7C_28JLjava_2Flang_2FString_3B_29V_native, .Lfunc_end5-Landroid_2Fos_2FParcel_3B_7CnativeWriteInterfaceToken_7C_28JLjava_2Flang_2FString_3B_29V_native
+        .cfi_endproc
+                                        // -- End function
+
+        .section        .text.Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native_inner,"ax",@progbits
+        .local  Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native_inner // -- Begin function Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native_inner
+        .p2align        2
+        .type   Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native_inner,@function
+Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native_inner: // @Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native_inner
+        .cfi_startproc
+// %bb.0:
+        str     x28, [sp, #-96]!        // 8-byte Folded Spill
+        stp     x26, x25, [sp, #16]     // 16-byte Folded Spill
+        stp     x24, x23, [sp, #32]     // 16-byte Folded Spill
+        stp     x22, x21, [sp, #48]     // 16-byte Folded Spill
+        stp     x20, x19, [sp, #64]     // 16-byte Folded Spill
+        stp     x29, x30, [sp, #80]     // 16-byte Folded Spill
+        add     x29, sp, #80            // =80
+        sub     sp, sp, #528            // =528
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        .cfi_offset w19, -24
+        .cfi_offset w20, -32
+        .cfi_offset w21, -40
+        .cfi_offset w22, -48
+        .cfi_offset w23, -56
+        .cfi_offset w24, -64
+        .cfi_offset w25, -72
+        .cfi_offset w26, -80
+        .cfi_offset w28, -96
+        mrs     x26, TPIDR_EL0
+        ldr     x8, [x26, #40]
+        stur    x8, [x29, #-88]
+        cbz     x0, .LBB6_24
+// %bb.1:
+        mov     x23, x1
+        cbz     x1, .LBB6_24
+// %bb.2:
+        mov     x21, x0
+        bl      _ZN7android14IPCThreadState4selfEv
+        mov     x19, x0
+        bl      _ZNK7android14IPCThreadState19getStrictModePolicyEv
+        ldr     w9, [x23, #8]
+        tbnz    w9, #31, .LBB6_28
+// %bb.3:
+        mov     w20, w0
+        asr     w8, w9, #1
+        add     x22, x23, #16           // =16
+        tbnz    w9, #0, .LBB6_5
+// %bb.4:
+        sxtw    x2, w8
+        add     x0, sp, #8              // =8
+        mov     x1, x22
+        bl      _ZN7android8String16C1EPKDsm
+        add     x1, sp, #8              // =8
+        mov     x0, x21
+        mov     x2, x19
+        bl      _ZNK7android6Parcel16enforceInterfaceERKNS_8String16EPNS_14IPCThreadStateE
+        mov     w21, w0
+        add     x0, sp, #8              // =8
+        bl      _ZN7android8String16D1Ev
+        tbnz    w21, #0, .LBB6_22
+        b       .LBB6_24
+.LBB6_5:
+        cmp     w9, #513                // =513
+        b.gt    .LBB6_14
+// %bb.6:
+        cmp     w9, #2                  // =2
+        sxtw    x2, w8
+        b.lt    .LBB6_13
+// %bb.7:
+        add     x9, sp, #8              // =8
+        add     x10, x9, x2, lsl #1
+        orr     x11, x9, #0x2
+        cmp     x10, x11
+        csel    x10, x10, x11, hi
+        mvn     x11, x9
+        add     x10, x10, x11
+        lsr     x10, x10, #1
+        add     x11, x10, #1            // =1
+        cmp     x11, #16                // =16
+        add     x10, sp, #8             // =8
+        b.lo    .LBB6_11
+// %bb.8:
+        and     x12, x11, #0xfffffffffffffff0
+        add     x13, sp, #8             // =8
+        add     x22, x22, x12
+        add     x10, x13, x12, lsl #1
+        add     x13, x13, #16           // =16
+        add     x14, x23, #24           // =24
+        mov     x15, x12
+.LBB6_9:                                // =>This Inner Loop Header: Depth=1
+        ldp     d0, d1, [x14, #-8]
+        subs    x15, x15, #16           // =16
+        add     x14, x14, #16           // =16
+        ushll   v0.8h, v0.8b, #0
+        ushll   v1.8h, v1.8b, #0
+        stp     q0, q1, [x13, #-16]
+        add     x13, x13, #32           // =32
+        b.ne    .LBB6_9
+// %bb.10:
+        cmp     x11, x12
+        b.eq    .LBB6_13
+.LBB6_11:
+        add     x8, x9, w8, sxtw #1
+.LBB6_12:                               // =>This Inner Loop Header: Depth=1
+        ldrb    w9, [x22], #1
+        strh    w9, [x10], #2
+        cmp     x10, x8
+        b.lo    .LBB6_12
+.LBB6_13:
+        mov     x0, sp
+        add     x1, sp, #8              // =8
+        bl      _ZN7android8String16C1EPKDsm
+        mov     x1, sp
+        mov     x0, x21
+        mov     x2, x19
+        bl      _ZNK7android6Parcel16enforceInterfaceERKNS_8String16EPNS_14IPCThreadStateE
+        mov     w21, w0
+        mov     x0, sp
+        bl      _ZN7android8String16D1Ev
+        tbnz    w21, #0, .LBB6_22
+        b       .LBB6_24
+.LBB6_14:
+        sxtw    x25, w8
+        orr     w1, wzr, #0x2
+        mov     x0, x25
+        bl      calloc
+        cbz     x0, .LBB6_22
+// %bb.15:
+        add     x8, x0, x25, lsl #1
+        mov     x24, x0
+        cmp     x8, x0
+        b.ls    .LBB6_21
+// %bb.16:
+        lsl     x9, x25, #1
+        sub     x9, x9, #1              // =1
+        lsr     x9, x9, #1
+        add     x10, x9, #1             // =1
+        cmp     x10, #16                // =16
+        mov     x9, x24
+        b.lo    .LBB6_20
+// %bb.17:
+        and     x11, x10, #0xfffffffffffffff0
+        add     x12, x24, #16           // =16
+        add     x22, x22, x11
+        add     x9, x24, x11, lsl #1
+        add     x13, x23, #24           // =24
+        mov     x14, x11
+.LBB6_18:                               // =>This Inner Loop Header: Depth=1
+        ldp     d0, d1, [x13, #-8]
+        subs    x14, x14, #16           // =16
+        add     x13, x13, #16           // =16
+        ushll   v0.8h, v0.8b, #0
+        ushll   v1.8h, v1.8b, #0
+        stp     q0, q1, [x12, #-16]
+        add     x12, x12, #32           // =32
+        b.ne    .LBB6_18
+// %bb.19:
+        cmp     x10, x11
+        b.eq    .LBB6_21
+.LBB6_20:                               // =>This Inner Loop Header: Depth=1
+        ldrb    w10, [x22], #1
+        strh    w10, [x9], #2
+        cmp     x9, x8
+        b.lo    .LBB6_20
+.LBB6_21:
+        add     x0, sp, #8              // =8
+        mov     x1, x24
+        mov     x2, x25
+        bl      _ZN7android8String16C1EPKDsm
+        add     x1, sp, #8              // =8
+        mov     x0, x21
+        mov     x2, x19
+        bl      _ZNK7android6Parcel16enforceInterfaceERKNS_8String16EPNS_14IPCThreadStateE
+        mov     w21, w0
+        add     x0, sp, #8              // =8
+        bl      _ZN7android8String16D1Ev
+        mov     x0, x24
+        bl      free
+        tbz     w21, #0, .LBB6_24
+.LBB6_22:
+        mov     x0, x19
+        bl      _ZNK7android14IPCThreadState19getStrictModePolicyEv
+        cmp     w20, w0
+        b.eq    .LBB6_25
+// %bb.23:
+        //APP
+        //mrs     x8, TPIDR_EL0
+        //NO_APP
+        //ldr     x8, [x8, #56]
+        //mov     w19, w0
+        //ldr     x0, [x8, #56]
+        //ldr     x8, [x0]
+        //ldr     x8, [x8]
+        //blr     x8
+        //mov     w1, w19
+        //bl      _ZN7android28set_dalvik_blockguard_policyEP7_JNIEnvi
+        bl      Landroid_2Fos_2FStrictMode_3B_7CsetBlockGuardPolicy_7C_28I_29V
+        ldr     x8, [x26, #40]
+        ldur    x9, [x29, #-88]
+        cmp     x8, x9
+        b.eq    .LBB6_26
+        b       .LBB6_27
+.LBB6_24:
+        //APP
+        mrs     x8, TPIDR_EL0
+        //NO_APP
+        ldr     x8, [x8, #56]
+        ldr     x0, [x8, #56]
+        ldr     x8, [x0]
+        ldr     x8, [x8]
+        blr     x8
+        adrp    x1, .L.str.7
+        adrp    x2, .L.str.8
+        add     x1, x1, :lo12:.L.str.7
+        add     x2, x2, :lo12:.L.str.8
+        bl      jniThrowException
+.LBB6_25:
+        ldr     x8, [x26, #40]
+        ldur    x9, [x29, #-88]
+        cmp     x8, x9
+        b.ne    .LBB6_27
+.LBB6_26:
+        add     sp, sp, #528            // =528
+        ldp     x29, x30, [sp, #80]     // 16-byte Folded Reload
+        ldp     x20, x19, [sp, #64]     // 16-byte Folded Reload
+        ldp     x22, x21, [sp, #48]     // 16-byte Folded Reload
+        ldp     x24, x23, [sp, #32]     // 16-byte Folded Reload
+        ldp     x26, x25, [sp, #16]     // 16-byte Folded Reload
+        ldr     x28, [sp], #96          // 8-byte Folded Reload
+        ret
+.LBB6_27:
+        bl      __stack_chk_fail
+.LBB6_28:
+        bl      __ubsan_handle_implicit_conversion_minimal_abort
+.Lfunc_end6:
+        .size   Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native_inner, .Lfunc_end6-Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native_inner
+        .cfi_endproc
+                                        // -- End function
+        .section        .text.Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native,"ax",@progbits
+        .globl  Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native // -- Begin function Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native
+        .p2align        2
+        .type   Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native,@function
+Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native: // @Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native
+        .cfi_startproc
+// %bb.0:
+        stp     x29, x30, [sp, #-16]!   // 16-byte Folded Spill
+        mov     x29, sp
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        bl      Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native_inner
+        bl      MRT_CheckThrowPendingExceptionUnw
+        ldp     x29, x30, [sp], #16     // 16-byte Folded Reload
+        b       MRT_SetReliableUnwindContextStatus
+.Lfunc_end7:
+        .size   Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native, .Lfunc_end7-Landroid_2Fos_2FParcel_3B_7CnativeEnforceInterface_7C_28JLjava_2Flang_2FString_3B_29V_native
+        .cfi_endproc
+                                        // -- End function
+
+        .type   .L.str,@object          // @.str
+        .section        .rodata.str1.1,"aMS",@progbits,1
+.L.str:
+        .asciz  "java/lang/RuntimeException"
+        .size   .L.str, 27
+
+        .type   .L.str.1,@object        // @.str.1
+.L.str.1:
+        .asciz  "Unknown error"
+        .size   .L.str.1, 14
+
+        .type   .L.str.2,@object        // @.str.2
+.L.str.2:
+        .asciz  "java/lang/OutOfMemoryError"
+        .size   .L.str.2, 27
+
+        .type   .L.str.3,@object        // @.str.3
+.L.str.3:
+        .asciz  "java/lang/UnsupportedOperationException"
+        .size   .L.str.3, 40
+
+        .type   .L.str.4,@object        // @.str.4
+.L.str.4:
+        .asciz  "java/lang/IllegalArgumentException"
+        .size   .L.str.4, 35
+
+        .type   .L.str.5,@object        // @.str.5
+.L.str.5:
+        .asciz  "Unknown binder error code. 0x%x"
+        .size   .L.str.5, 32
+
+        .type   .L.str.6,@object        // @.str.6
+.L.str.6:
+        .asciz  "android/os/RemoteException"
+        .size   .L.str.6, 27
+
+        .type   .L.str.7,@object        // @.str.7
+.L.str.7:
+        .asciz  "java/lang/SecurityException"
+        .size   .L.str.7, 28
+
+        .type   .L.str.8,@object        // @.str.8
+.L.str.8:
+        .asciz  "Binder invocation to an incorrect interface"
+        .size   .L.str.8, 44
+
+#Libframework_end
diff --git a/src/mrt/codetricks/arch/arm64/hashCode.s b/src/mrt/codetricks/arch/arm64/hashCode.s
new file mode 100755
index 0000000000000000000000000000000000000000..ecd38f69424cbbcde8e96f7bfc869c8babd734dd
--- /dev/null
+++ b/src/mrt/codetricks/arch/arm64/hashCode.s
@@ -0,0 +1,45 @@
+	.local	Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I
+	.type	Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I, %function
+	.word .Lmethod_desc.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I - .
+Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I:
+.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I9:
+	.cfi_startproc
+	.cfi_personality 155, DW.ref.__mpl_personality_v0
+	ldr	w2, [x0,#12]         // Ljava/lang/String;.hash
+	cbnz	w2, .Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I1
+	ldr	w1, [x0,#8]          // length + flag for compressed string
+	lsr	w4, w1, #1
+	cbz	w4, .Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I1
+	mov	w5, #0               // start offset
+	add	x3, x0, #16          // start address
+	tbz	w1, #0, .Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I4
+.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I3:
+	ldrb	w6, [x3,w5,SXTW #0]  // compressed string
+	lsl	w1, w2, #5
+	add	w5, w5, #1
+	sub	w1, w1, w2
+	cmp	w5, w4
+	add	w2, w1, w6
+	blt	.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I3
+	b	.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I6
+.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I4:
+	ldrh	w6, [x3,w5,SXTW #1]  // normal string
+	lsl	w1, w2, #5
+	add	w5, w5, #1
+	sub	w1, w1, w2
+	cmp	w5, w4
+	add	w2, w1, w6
+	blt	.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I4
+.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I6:
+	str	w2, [x0,#12]         // hash = h
+.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I1:
+	mov	w0, w2
+.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I12:
+	ret
+.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I11:
+	b	.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I12
+.Label.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I10:
+	.cfi_endproc
+.Label.end.Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I:
+	.size	Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I, .-Ljava_2Flang_2FString_3B_7ChashCode_7C_28_29I
+	.word   0x55555555
diff --git a/src/mrt/codetricks/arch/arm64/stringEquals.s b/src/mrt/codetricks/arch/arm64/stringEquals.s
new file mode 100644
index 0000000000000000000000000000000000000000..21014929c2177d8a29f6a322f6512d6b57865da8
--- /dev/null
+++ b/src/mrt/codetricks/arch/arm64/stringEquals.s
@@ -0,0 +1,68 @@
+    .local    Ljava_2Flang_2FString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z
+    .type    Ljava_2Flang_2FString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z, %function
+    .word .Lmethod_desc.Ljava_2Flang_2FString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z - .
+Ljava_2Flang_2FString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z:
+.Label.Ljava_2Flang_2FString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z26:    //label order 60736
+    .cfi_startproc
+    .cfi_personality 155, DW.ref.__mpl_personality_v0
+        cbz     x1, .Lstring_equals_false  // if the other is null
+        cmp     x0, x1
+        beq     .Lstring_equals_true       // same address, return true
+        ldp     x4, x2, [x0], #16          // read class shadow and count of this
+        ldp     x5, x3, [x1], #16
+        cmp     w4, w5
+        bne     .Lstring_equals_false      // if not the same class
+        cmp     w2, w3                     //  Length and compression flag are different
+        bne     .Lstring_equals_morecheck
+        and     w3, w2, #1
+        lsr     w2, w2, w3                 // get the number of bytes
+        cbz     w2, .Lstring_equals_true   //  zero length
+        add     w2, w2, #7
+        lsr     w5, w2, 4
+        cbz     w5, .Lstring_equals_tail2   // size is shorter than 8
+        add     x5, x0, x5, lsl 4
+.Lstring_equals_loophead:
+        ldp     x3, x6, [x0], #16
+        ldp     x4, x7, [x1], #16
+        cmp     x3, x4
+        bne     .Lstring_equals_false
+        cmp     x6, x7
+        bne     .Lstring_equals_false
+        cmp     x0, x5
+        bne     .Lstring_equals_loophead
+.Lstring_equals_tail:
+        tbz     w2, #3, .Lstring_equals_true
+.Lstring_equals_tail2:
+        ldr     x3, [x0]
+        ldr     x2, [x1]
+        cmp     x3, x2
+        bne     .Lstring_equals_false
+.Lstring_equals_true:
+        mov     w0, 1
+        ret
+.Lstring_equals_false:
+        mov     w0, 0
+        ret
+.Lstring_equals_morecheck:             // check for compressed bits are diff byte size are equal
+        eor     w2, w2, w3
+        cmp     w2, #1
+        bne     .Lstring_equals_false
+        tbnz    w3, #0, .Lstring_equals_loop2
+        mov     x2, x0
+        mov     x0, x1
+        mov     x1, x2    // swap x0 and x1 to make sure that x0 is normal and x1 is compressed
+.Lstring_equals_loop2:
+        lsr     w3, w3, #1
+        // x0: normal, x1; compressed, w3: length
+.Lstring_equals_loop2_head:
+        subs    w3, w3, #1
+        tbnz    w3, #31, .Lstring_equals_true
+        ldrh    w4, [x0,w3,SXTW #1]  // normal string
+        ldrb    w5, [x1,w3,SXTW #0]  // compressed string
+        cmp     w4, w5
+        beq     .Lstring_equals_loop2_head
+        b       .Lstring_equals_false
+    .cfi_endproc
+.Label.end.Ljava_2Flang_2FString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z:
+    .size    Ljava_2Flang_2FString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z, .-Ljava_2Flang_2FString_3B_7Cequals_7C_28Ljava_2Flang_2FObject_3B_29Z
+    .word   0x55555555
diff --git a/src/mrt/compiler-rt/BUILD.gn b/src/mrt/compiler-rt/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..9bf59ec3f69b4b372fb7610b436ae3cd4fdca112
--- /dev/null
+++ b/src/mrt/compiler-rt/BUILD.gn
@@ -0,0 +1,127 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+sources_common = [
+  "src/allocator.cpp",
+  "src/chelper.cpp",
+  "src/chosen.cpp",
+  "src/cinterface.cpp",
+  "src/collector/arena.cpp",
+  "src/collector/collector.cpp",
+  "src/collector/collector_rc.cpp",
+  "src/collector/collector_ms.cpp",
+  "src/collector/collector_naiverc.cpp",
+  "src/collector/collector_naiverc_ms.cpp",
+  "src/collector/collector_tracing.cpp",
+  "src/collector/conn_comp.cpp",
+  "src/collector/cp_generator.cpp",
+  "src/collector/cycle_collector.cpp",
+  "src/collector/gc_reason.cpp",
+  "src/collector/mpl_thread_pool.cpp",
+  "src/collector/mrt_bitmap.cpp",
+  "src/collector/native_gc.cpp",
+  "src/collector/rp_base.cpp",
+  "src/collector/rc_reference_processor.cpp",
+  "src/collector/gc_reference_processor.cpp",
+  "src/collector/stats.cpp",
+  "src/exception/eh_personality.cpp",
+  "src/exception/exception_handling.cpp",
+  "src/gc_log.cpp",
+  "src/libs.cpp",
+  "src/mm_config.cpp",
+  "src/errno_utils.cpp",
+  "src/mm_utils.cpp",
+  "src/exception/mpl_exception.cpp",
+  "src/exception/mrt_exception.cpp",
+  "src/mutator_list.cpp",
+  "src/namemangler.cpp",
+  "src/mangle_for_jni.cpp",
+  "src/file_layout.cpp",
+  "src/muid.cpp",
+  "src/panic.cpp",
+  "src/profile.cpp",
+  "src/heap_stats.cpp",
+  "src/allocator/ros_allocator.cpp",
+  "src/allocator/space.cpp",
+  "src/allocator/mem_map.cpp",
+  "src/allocator/bp_allocator.cpp",
+  "src/allocator/page_map.cpp",
+  "src/exception/stack_unwinder.cpp",
+  "src/yieldpoint.cpp",
+  "src/tracer.cpp",
+  "src/linker/linker.cpp",
+  "src/linker/linker_api.cpp",
+  "src/linker/linker_info.cpp",
+  "src/linker/linker_model.cpp",
+  "src/linker/linker_utils.cpp",
+  "src/linker/linker_cache.cpp",
+  "src/linker/linker_gctib.cpp",
+  "src/linker/linker_lazy_binding.cpp",
+  "src/linker/linker_method_builder.cpp",
+  "src/linker/linker_hotfix.cpp",
+  "src/linker/linker_debug.cpp",
+  "src/loader/file_adapter.cpp",
+  "src/loader/hash_pool.cpp",
+  "src/loader/loader_utils.cpp",
+  "src/loader/object_locator.cpp",
+  "src/loader/object_loader.cpp",
+]
+
+include_common = [
+  "include",
+  "public-headers",
+  "${AOSP_ROOT}/libnativehelper/include_jni",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include/",
+  "${MAPLE_MRT_ROOT}/maplert/include",
+  "${MAPLE_MRT_ROOT}/maplert/public-headers/",
+  "${MAPLE_MRT_ROOT}/libmrtbase/include/",
+  "${MAPLE_MRT_ROOT}/libmrtbase/include/linux",
+  "${MAPLE_MRT_ROOT}/dexinterface",
+  "${MAPLE_MRT_ROOT}/interpreter/zterp",
+  "${MAPLE_MRT_ROOT}",
+]
+
+static_library("libmplcompiler-rt") {
+  sources = sources_common
+  include_dirs = include_common
+
+  sources += [
+    "src/arch/arm64/cc_native_method_stub_arm64.S",
+    "src/arch/arm64/fastFuncs.S",
+    "src/arch/arm64/i2r_stub_arm64.S",
+    "src/arch/arm64/interp_native_method_stub_arm64.S",
+    "src/arch/arm64/memset.S",
+    "src/arch/arm64/prepare_args_for_exception_catcher_arm64.S",
+    "src/arch/arm64/proxy_stub_arm64.S",
+    "src/arch/arm64/r2c_stub_arm64.S",
+    "src/arch/arm64/signal_handler_arm64.cpp",
+    "src/arch/arm64/signal_handler_stub_arm64.S",
+    "src/arch/arm64/yieldpoint_arm64.S",
+  ]
+
+  cflags = []
+  cflags_cc = []
+  cflags_cc += [
+    "-fvisibility=hidden",
+    "-pthread",
+    "-std=gnu++14",
+    "-fasynchronous-unwind-tables",
+    "-nostdlibinc",
+  ]
+  sources += [ "src/libs_fast.cpp" ]
+  configs = [ "${MAPLE_MRT_ROOT}:mrt_cxx_flags" ]
+
+  cflags_cc += [ "-DMAPLE_EH_UTEST=0" ]
+  asmflags = cflags_cc
+}
diff --git a/src/mrt/compiler-rt/include/address.h b/src/mrt/compiler-rt/include/address.h
new file mode 100644
index 0000000000000000000000000000000000000000..b827589441d59ed78c285e5859b8ef07f31247f5
--- /dev/null
+++ b/src/mrt/compiler-rt/include/address.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ADDRESS_H
+#define MAPLE_RUNTIME_ADDRESS_H
+
+#include <atomic>
+#include <functional>
+#include "gc_callback.h"
+
+// Operations for the address type and memory operations
+namespace maplert {
+static constexpr address_t kDummyAddress = static_cast<address_t>(-1);
+
+template<class T>
+inline T &AddrToLVal(address_t addr) {
+  return *reinterpret_cast<T*>(addr);
+}
+
+template<class T>
+inline std::atomic<T> &AddrToLValAtomic(address_t addr) {
+  return *reinterpret_cast<std::atomic<T>*>(addr);
+}
+
+static inline address_t RefFieldToAddress(reffield_t refField) {
+  return static_cast<address_t>(refField);
+}
+
+static inline reffield_t AddressToRefField(address_t addr) {
+  return static_cast<reffield_t>(addr);
+}
+
+// Note: only used to load reference field of Java object
+//       raw load, no RC-bookkeeping
+static inline address_t LoadRefField(address_t *fieldAddr) {
+  return static_cast<address_t>(*reinterpret_cast<reffield_t*>(fieldAddr));
+}
+
+// dialect of the above version. Doesn't do NULL-check against obj
+static inline address_t LoadRefField(address_t obj, std::size_t offset) {
+  return LoadRefField(reinterpret_cast<address_t*>(obj + offset));
+}
+
+// Note: only used to store reference field of Java object
+//       raw store, no RC-bookkeeping
+static inline void StoreRefField(address_t *fieldAddr, address_t newVal) {
+  *reinterpret_cast<reffield_t*>(fieldAddr) = static_cast<reffield_t>(newVal);
+}
+
+// dialect of the above version. Doesn't do NULL-check against obj
+static inline void StoreRefField(address_t obj, std::size_t offset, address_t newVal) {
+  StoreRefField(reinterpret_cast<address_t*>(obj + offset), newVal);
+}
+}
+#endif
diff --git a/src/mrt/compiler-rt/include/allocator.h b/src/mrt/compiler-rt/include/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..eab6594b90c6291fdfb74cf5d17aed3882669602
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator.h
@@ -0,0 +1,588 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ALLOCATOR_H
+#define MAPLE_RUNTIME_ALLOCATOR_H
+
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <string>
+
+#include "mm_config.h"
+#include "address.h"
+#include "heap_stats.h"
+#include "mrt_object.h"
+#include "panic.h"
+#include "thread_api.h"
+#include "collector/mrt_bitmap.h"
+#include "collector/mpl_thread_pool.h"
+#include "mrt_reference_api.h"
+#if LOG_ALLOC_TIMESTAT
+#include "utils/time_utils.h"
+#endif
+
+#define ALLOC_ENABLE_LOCK_CONTENTION_STATS __MRT_DEBUG_COND_FALSE
+
+#if ALLOC_ENABLE_LOCK_CONTENTION_STATS
+#define ALLOC_MUTEX_TYPE maple::Mutex
+#define ALLOC_LOCK_TYPE maple::MutexLock
+#define ALLOC_CURRENT_THREAD maple::IThread::Current(),
+#else
+#define ALLOC_MUTEX_TYPE std::mutex
+#define ALLOC_LOCK_TYPE std::lock_guard<mutex>
+#define ALLOC_CURRENT_THREAD
+#endif
+
+namespace maplert {
+// The allocator collects five kinds of data from the heap:
+// 1. Fragmentation related: the utilisation of the heap
+// 2. Per-mutator allocation data: this is non-atomic
+// 3. Global allocation data: this is atomic
+// 4. Allocation time statistics
+// 5. Lock contention statistics
+// These are written in the contract and every allocator implementation should support them.
+// Additional stats can be supported by adding callbacks to the callback interface.
+class FragmentationRecord {
+ public:
+  // this is allocator-specific, move into allocator implementation header
+  size_t GetExternalFragmentation() const {
+    return runFreeSlots + runOverhead + freePages;
+  }
+  size_t GetInternalFragmentation() const {
+    return internal;
+  }
+  size_t GetRCHeader()const {
+    return rcOverhead;
+  }
+  size_t GetBytesInFreePages() const {
+    return freePages;
+  }
+  size_t GetBytesInPages() const {
+    return totalPages;
+  }
+  size_t GetFreeSlots() const {
+    return runFreeSlots;
+  }
+  size_t GetSlots() const {
+    return runTotalSlots;
+  }
+  size_t GetRunCacheVolume() const {
+    return runCacheVolume;
+  }
+  size_t GetRunOverhead() const {
+    return runOverhead;
+  }
+  size_t GetRun(bool isFree, bool isLocal) const {
+    if (isFree) {
+      if (isLocal) {
+        return freeLocalRun;
+      } else {
+        return freeRun;
+      }
+    } else {
+      if (isLocal) {
+        return totalLocalRun;
+      } else {
+        return totalRun;
+      }
+    }
+  }
+
+  void RecordInternalFrag(size_t totalBytes, size_t requestedBytes) {
+    internal = totalBytes - requestedBytes;
+  }
+
+  void IncFreePages(size_t bytes) {
+    freePages += bytes;
+  }
+  void IncPages(size_t bytes) {
+    totalPages += bytes;
+  }
+  void IncFreeSlots(size_t bytes) {
+    runFreeSlots += bytes;
+  }
+  void IncSlots(size_t bytes) {
+    runTotalSlots += bytes;
+  }
+  void IncRunOverhead(size_t bytes) {
+    runOverhead += bytes;
+  }
+  void IncRunCacheVolume(size_t bytes) {
+    runCacheVolume += bytes;
+  }
+  void IncRun(size_t bytes, bool isFree, bool isLocal) {
+    if (isFree) {
+      freeRun += bytes;
+      if (isLocal) {
+        freeLocalRun += bytes;
+      }
+    }
+    totalRun += bytes;
+    if (isLocal) {
+      totalLocalRun += bytes;
+    }
+  }
+
+  FragmentationRecord()
+      : internal(0),
+        freePages(0),
+        totalPages(0),
+        runFreeSlots(0),
+        runTotalSlots(0),
+        runOverhead(0),
+        rcOverhead(0),
+        runCacheVolume(0),
+        freeRun(0),
+        totalRun(0),
+        freeLocalRun(0),
+        totalLocalRun(0) {}
+  ~FragmentationRecord() = default;
+
+  void Reset() {
+    internal = 0;
+    freePages = 0;
+    totalPages = 0;
+    runFreeSlots = 0;
+    runTotalSlots = 0;
+    runOverhead = 0;
+    rcOverhead = 0;
+    runCacheVolume = 0;
+    freeRun = 0;
+    totalRun = 0;
+    freeLocalRun = 0;
+    totalLocalRun = 0;
+  }
+
+  void Print(std::basic_ostream<char> &os, std::string tag) {
+    os << "External fragment [" << tag << "]: " << GetExternalFragmentation() << "\n";
+    os << "Internal fragment [" << tag << "]: " << GetInternalFragmentation() << "\n";
+    os << "Free page bytes [" << tag << "]: " << GetBytesInFreePages() << "\n";
+    os << "Total page bytes [" << tag << "]: " << GetBytesInPages() << "\n";
+    os << "Free run bytes (incl cache) [" << tag << "]: " << GetRun(true, false) << "\n";
+    os << "Total run bytes (incl cache) [" << tag << "]: " << GetRun(false, false) << "\n";
+    os << "Free slot bytes (incl cache) [" << tag << "]: " << GetFreeSlots() << "\n";
+    os << "Run overhead [" << tag << "]: " << GetRunOverhead() << "\n";
+    // only use when not considering the gc header
+    os << "Total slot bytes (incl cache) [" << tag << "]: " << GetSlots() << "\n";
+    os << "Free local run bytes [" << tag << "]: " << GetRun(true, true) << "\n";
+    os << "Total local run bytes [" << tag << "]: " << GetRun(false, true) << "\n";
+    os << "Cached run bytes [" << tag << "]: " << GetRunCacheVolume() << "\n";
+  }
+ private:
+  // fragmentation fields:
+  size_t internal;       // internal frag. caused by rc/gc header and alignment
+  size_t freePages;      // external frag. free pages in bytes not yet allocated
+  size_t totalPages;
+  size_t runFreeSlots;   // external frag. total bytes of the free slots
+  size_t runTotalSlots;
+  size_t runOverhead;    // external frag. total bytes of the run header and the trailing space
+  // extra fields:
+  size_t rcOverhead;     // total bytes used by RC header
+  size_t runCacheVolume; // bytes consumed by the cached runs
+  size_t freeRun;
+  size_t totalRun;
+  size_t freeLocalRun;
+  size_t totalLocalRun;
+}; // class FragmentationRecord
+
+class AccUnSynchedSizeField {
+ public:
+  inline size_t LoadSize() const {
+    return val;
+  }
+  inline void Inc(size_t param) {
+    val += param;
+  }
+  inline void Dec(size_t param) {
+    val -= param;
+  }
+  inline void Init() {
+    val = 0;
+  }
+  AccUnSynchedSizeField() : val(0) {}
+  ~AccUnSynchedSizeField() = default;
+ private:
+  size_t val;
+};
+
+class AccSynchedSizeField {
+ public:
+  inline size_t LoadSize() const {
+    return val.load(std::memory_order_relaxed);
+  }
+  inline void Inc(size_t param) {
+    (void)val.fetch_add(param, std::memory_order_relaxed);
+  }
+  inline void Sub(size_t param) {
+    (void)val.fetch_sub(param, std::memory_order_relaxed);
+  }
+  inline void Dec(size_t param) {
+    (void)val.fetch_sub(param, std::memory_order_relaxed);
+  }
+  inline void Init() {
+    val.store(0, std::memory_order_seq_cst);
+  }
+  AccSynchedSizeField() : val(0) {}
+  ~AccSynchedSizeField() = default;
+ private:
+  std::atomic<size_t> val;
+};
+
+template<class SizeField>
+class AllocAccounting {
+ public:
+  inline size_t GetNetBytes() const {
+    return netBytes.LoadSize();
+  }
+  inline size_t GetNetObjs() const {
+    return netObjs.LoadSize();
+  }
+  inline size_t GetNetObjBytes() const {
+    return netObjBytes.LoadSize();
+  }
+  inline size_t GetNetLargeObjBytes() const {
+    return netLargeObjBytes.LoadSize();
+  }
+
+  AllocAccounting() {
+    netBytes.Init();
+    netObjs.Init();
+    netObjBytes.Init();
+    netLargeObjBytes.Init();
+    totalFreedBytes.Init();
+    totalFreedObjBytes.Init();
+    totalFreedObjs.Init();
+    totalAllocdBytes.Init();
+    totalAllocdObjs.Init();
+    totalAllocdObjBytes.Init();
+  }
+  ~AllocAccounting() = default;
+  inline size_t TotalAllocdBytes() {
+    return totalAllocdBytes.LoadSize();
+  }
+  inline size_t TotalFreedBytes() {
+    return totalFreedBytes.LoadSize();
+  }
+  inline size_t TotalAllocdObjs() {
+    return totalAllocdObjs.LoadSize();
+  }
+  inline size_t TotalFreedObjs() {
+    return totalFreedObjs.LoadSize();
+  }
+  inline void AtAlloc(size_t objSize, size_t internalSize, bool isLarge) {
+    netBytes.Inc(internalSize);
+    netObjBytes.Inc(objSize);
+    netObjs.Inc(1);
+    if (UNLIKELY(isLarge)) {
+      netLargeObjBytes.Inc(objSize);
+    }
+#if ENABLE_HPROF
+    if (UNLIKELY(IsHeapStatsEnabled())) {
+      // this collects total alloc stats from a time window, instead of net stats
+      totalAllocdBytes.Inc(internalSize);
+      totalAllocdObjs.Inc(1);
+    }
+#endif
+  }
+  inline void AtFree(size_t objSize, size_t internalSize, bool isLarge) {
+    netBytes.Dec(internalSize);
+    netObjBytes.Dec(objSize);
+    netObjs.Dec(1);
+    if (UNLIKELY(isLarge)) {
+      netLargeObjBytes.Dec(objSize);
+    }
+#if ENABLE_HPROF
+    if (UNLIKELY(IsHeapStatsEnabled())) {
+      // this collects total free stats from a time window, instead of net stats
+      totalFreedBytes.Inc(internalSize);
+      totalFreedObjs.Inc(1);
+    }
+#endif
+  }
+  inline void ResetWindowTotal() {
+    totalFreedBytes.Init();
+    totalFreedObjBytes.Init();
+    totalFreedObjs.Init();
+    totalAllocdBytes.Init();
+    totalAllocdObjs.Init();
+    totalAllocdObjBytes.Init();
+  }
+
+ private:
+  SizeField netBytes;
+  SizeField netObjBytes;
+  SizeField netObjs;
+  SizeField netLargeObjBytes;    // net bytes excluding overhead
+
+  // these are for total numbers in a time window, caution there is no overflow protection
+  SizeField totalAllocdBytes;    // total bytes including overhead
+  SizeField totalAllocdObjBytes; // total bytes excluding overhead
+  SizeField totalAllocdObjs;     // total number of objects allocated
+  SizeField totalFreedBytes;     // total bytes including overhead
+  SizeField totalFreedObjBytes;  // total bytes excluding overhead
+  SizeField totalFreedObjs;      // total number of objects freed
+};
+
+// the allocator uses a version that does requires atomic instructions, because multiple
+// threads could do the same operation concurrently
+using SynchedAllocAccounting = AllocAccounting<AccSynchedSizeField>;
+// the mutator uses a light weight version that does not require atomic instructions
+using UnsyncAllocAccounting = AllocAccounting<AccUnSynchedSizeField>;
+
+#if LOG_ALLOC_TIMESTAT
+// Time statistic obj for measured functions such as allocator obj alloc/release
+class TimeStat {
+ public:
+  uint64_t tmMin;  // min time for an ocurrance of the function
+  uint64_t tmMax;  // max time for an ocurrance of the function
+  uint64_t tmSum;  // sum total time of all ocurrances of the function
+  uint64_t tmCnt;  // count of ourrances of the function
+
+  TimeStat() : tmMin(std::numeric_limits<uint64_t>::max()), tmMax(0), tmSum(0), tmCnt(0) {}
+
+  void Reset() {
+    tmMin = std::numeric_limits<uint64_t>::max();
+    tmMax = 0;
+    tmSum = 0;
+    tmCnt = 0;
+  }
+
+  // Update time stats with time taken from an ocurrance of the function
+  void Update(uint64_t val) {
+    tmMin = std::min(val, tmMin);
+    tmMax = std::max(val, tmMax);
+    tmSum += val;
+    ++tmCnt;
+  }
+
+  // True if there is recorded timestat data for the function
+  bool HasStat() {
+    return (tmCnt != 0);
+  }
+
+  uint64_t GetMin() {
+    return tmMin;
+  }
+  uint64_t GetMax() {
+    return tmMax;
+  }
+  uint64_t GetSum() {
+    return tmSum;
+  }
+  uint64_t GetCnt() {
+    return tmCnt;
+  }
+  uint64_t GetAvg() {
+    return tmSum / tmCnt;
+  }
+};
+
+// TypeInd list of timed functions
+enum {
+  kTimeAllocLocal,
+  kTimeAllocGlobal,
+  kTimeAllocLarge,
+  kTimeFreeLocal,
+  kTimeFreeGlobal,
+  kTimeFreeLarge,
+  kTimeReleaseObj,
+  kTimeMax
+};
+#endif
+
+class AllocMutator {
+ public:
+  virtual void Init() = 0;
+  virtual void Fini() = 0;
+  virtual void VisitGCRoots(std::function<void(address_t)> visitor) = 0;
+  AllocMutator() = default;
+
+#if LOG_ALLOC_TIMESTAT
+  void StartTimer() {
+    timeStamp = timeutils::NanoSeconds();
+  }
+
+  void StopTimer(int typeInd) {
+    uint64_t stopTime = timeutils::NanoSeconds();
+    timeStat[typeInd].Update(stopTime - timeStamp);
+  }
+
+  // reset timestat for all tracked functions
+  void ResetTimers() {
+    for (int typeInd = 0; typeInd < kTimeMax; ++typeInd) {
+      timeStat[typeInd].Reset();
+    }
+  }
+
+  uint64_t GetTimerMin(int typeInd) {
+    return timeStat[typeInd].GetMin();
+  }
+  uint64_t GetTimerMax(int typeInd) {
+    return timeStat[typeInd].GetMax();
+  }
+  uint64_t GetTimerSum(int typeInd) {
+    return timeStat[typeInd].GetSum();
+  }
+  uint64_t GetTimerCnt(int typeInd) {
+    return timeStat[typeInd].GetCnt();
+  }
+  uint64_t GetTimerAvg(int typeInd) {
+    return timeStat[typeInd].GetAvg();
+  }
+
+  void SuspendFreeObjTimeStat() {
+    statOn = false;
+  }
+  void ResumeFreeObjTimeStat() {
+    statOn = true;
+  }
+  bool DoFreeObjTimeStat() {
+    return statOn;
+  }
+#endif
+
+  virtual ~AllocMutator() = default;
+  AllocMutator(AllocMutator const&) = delete;
+  void operator=(AllocMutator const &x) = delete;
+  inline UnsyncAllocAccounting &GetAllocAccount() {
+    return account;
+  }
+
+ public:
+  // the mutator uses a light weight version that does not require atomic instructions
+  // this is currently not properly instrumented, use the global/atomic version instead
+  UnsyncAllocAccounting account;
+#if LOG_ALLOC_TIMESTAT
+  // Note: timestat for allocator FreeObj is not collected in following cases:
+  // 1. objects freed by MS collector via RosAllocImpl::FreeAllIf
+  // 2. objects freed by non alloc-mutator threads calling the free function
+  // 3. objects freed by naive RC collector via ReleaseObj call are not individually timestat'd
+  //    again since they are already timestat'd in the ReleaseObj operation.
+  TimeStat timeStat[kTimeMax];
+  uint64_t timeStamp;
+  bool statOn = true;
+#endif
+}; // class AllocMutator
+
+// Globals used by fast allocation containing context information.
+// Putting all the information together helps avoid virtual calls (Collector::Instance()).
+// It also reduces adrp usage in the generated code, saving a few lines of code.
+struct FastAllocData {
+  static FastAllocData data;
+  std::atomic<bool> isConcurrentSweeping = { false };
+  bool isConcurrentMarking = false;
+  bool isGCOnly = false;
+  std::atomic<size_t> allocatedInternalSize = { 0 };
+  MrtBitmap *bm;
+};
+
+#if ALLOC_USE_FAST_PATH
+#define FAST_ALLOC_ACCOUNT_ADD(s) \
+    (void) FastAllocData::data.allocatedInternalSize.fetch_add((s), std::memory_order_relaxed)
+#define FAST_ALLOC_ACCOUNT_SUB(s) \
+    (void) FastAllocData::data.allocatedInternalSize.fetch_sub((s), std::memory_order_relaxed)
+#else
+#define FAST_ALLOC_ACCOUNT_ADD(s)
+#define FAST_ALLOC_ACCOUNT_SUB(s)
+#endif
+
+// Allocator abstract class
+class Allocator {
+ public:
+  // For methods that visit objects via callback functions.
+  using AddressVisitor = std::function<void(address_t)>;
+  using VisitorFactory = std::function<AddressVisitor()>;
+
+  // returns the total number of objs allocated
+  inline size_t AllocatedObjs() const {
+    return account.GetNetObjs();
+  }
+
+  // returns the total bytes that has been occupied
+  // to be specific, this is the sum of internal size of all allocated objects
+  inline size_t AllocatedMemory() const {
+#if ALLOC_USE_FAST_PATH
+    return FastAllocData::data.allocatedInternalSize.load(std::memory_order_relaxed);
+#else
+    return account.GetNetBytes();
+#endif
+  }
+
+  // returns the total size of the objects allocated
+  // the difference between requested memory and allocated memory, is that
+  // allocated memory sums internal size, whereas requested memory sums raw obj size (no header)
+  inline size_t RequestedMemory() const {
+    return account.GetNetObjBytes();
+  }
+
+  inline SynchedAllocAccounting &GetAllocAccount() {
+    return account;
+  }
+
+  // callback for mutator finalisation
+  inline void PostMutatorFini(AllocMutator &mutator);
+
+  // callback before allocation
+  __attribute__ ((always_inline))
+  void PreObjAlloc(address_t objAddress, size_t objSize) const;
+
+  // callback after allocation
+  // objSize is the requested object size
+  // internalSize is the size including overhead
+  __attribute__ ((always_inline))
+  void PostObjAlloc(address_t objAddress, size_t objSize, size_t internalSize);
+
+  // callback before free. returns the object size
+  template<bool isFast = false>
+  __attribute__ ((always_inline))
+  size_t PreObjFree(address_t objAddress) const;
+
+  // callback after free
+// internalSize is the bytes occupied by the object including overhead
+  template<bool isFast = false>
+  __attribute__ ((always_inline))
+  void PostObjFree(address_t objAddress, size_t objSize, size_t internalSize);
+
+  virtual void Init(const VMHeapParam&) = 0;
+
+  // Allocate space for a new object of the requested size
+  virtual address_t NewObj(size_t size) = 0;
+
+  static void ReleaseResource(address_t obj);
+
+  virtual ~Allocator() {
+    oome = nullptr;
+  }
+  Allocator();
+  void NewOOMException();
+
+  // Allocation tracking support, set callback
+  void SetAllocRecordingCallback(std::function<void(address_t, size_t)> allocRecordingCallbackFunc) {
+    mAllocRecordingCallbackFunc = allocRecordingCallbackFunc;
+  }
+
+ public:
+  MObject *oome; // this doesn't belong here!
+  SynchedAllocAccounting account;
+ protected:
+  std::atomic<bool> oomeCreated;
+  ALLOC_MUTEX_TYPE globalLock;
+  // Allocation tracking support, recorder callback
+  std::function<void(address_t, size_t)> mAllocRecordingCallbackFunc = nullptr;
+};
+}
+
+#endif
+
diff --git a/src/mrt/compiler-rt/include/allocator/alloc_callbacks.h b/src/mrt/compiler-rt/include/allocator/alloc_callbacks.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ced4242bbb3a4adc901983d780f591883777b28
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/alloc_callbacks.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ALLOC_CALLBACKS_H
+#define MAPLE_RUNTIME_ALLOC_CALLBACKS_H
+
+#include <fstream>
+#include <string>
+#include <dlfcn.h>
+#include <unistd.h>
+
+#include "allocator.h"
+#include "chosen.h"
+#include "exception/mrt_exception.h"
+#include "mrt_reflection.h"
+#include "mrt_object.h"
+#include "cpphelper.h"
+#include "chelper.h"
+#include "mm_config.h"
+#include "address.h"
+#include "sizes.h"
+#include "panic.h"
+#include "collector/stats.h"
+#include "jsan.h"
+
+namespace maplert {
+inline void Allocator::PreObjAlloc(address_t objAddress __attribute__((unused)),
+                                   size_t objSize __attribute__((unused))) const {}
+
+inline void Allocator::PostObjAlloc(address_t objAddress, size_t objSize, size_t internalSize) {
+  JSAN_ADD_OBJ(objAddress, objSize);
+
+  bool isLarge = internalSize > RosAllocImpl::kLargeObjSize;
+  // non-atomic: per-mutator allocation statistics (currently not instrumented)
+  // atomic: keep track of total bytes allocated in the heap
+  account.AtAlloc(objSize, internalSize, isLarge);
+
+  if (UNLIKELY(mAllocRecordingCallbackFunc != nullptr)) {
+    mAllocRecordingCallbackFunc(objAddress, objSize);
+  }
+}
+
+template<bool isFast>
+inline size_t Allocator::PreObjFree(address_t objAddress) const {
+  if (UNLIKELY(mAllocRecordingCallbackFunc != nullptr)) {
+    mAllocRecordingCallbackFunc(objAddress, 0);
+  }
+
+  if (isFast) {
+    return 0;
+  } else {
+    MObject *freeObj = MObject::Cast<MObject>(objAddress);
+    return freeObj->GetSize();
+  }
+}
+
+template<bool isFast>
+inline void Allocator::PostObjFree(address_t, size_t objSize, size_t internalSize) {
+#if ALLOC_USE_FAST_PATH
+  static_cast<void>(objSize);
+  if (!isFast) {
+    FAST_ALLOC_ACCOUNT_SUB(internalSize);
+  }
+#else
+  static_cast<void>(isFast);
+  bool isLarge = internalSize > RosAllocImpl::kLargeObjSize;
+  // non-atomic: per-mutator allocation statistics (currently not instrumented)
+  // atomic: keep track of total bytes allocated in the heap
+  account.AtFree(objSize, internalSize, isLarge);
+#endif
+}
+
+#if LOG_ALLOC_TIMESTAT
+#define PrintTimeStat(outs, op, typeInd, mut) \
+  if (mut.GetTimerCnt(typeInd) != 0) {  \
+    outs << "         " << op << "[Min] : " << mut.GetTimerMin(typeInd) << maple::endl;  \
+    outs << "         " << op << "[Max] : " << mut.GetTimerMax(typeInd) << maple::endl;  \
+    outs << "         " << op << "[Avg] : " << mut.GetTimerAvg(typeInd) <<  \
+        " out of " << mut.GetTimerCnt(typeInd) << maple::endl ;  \
+  }
+#endif
+
+void Allocator::PostMutatorFini(AllocMutator &mutator) {
+#if LOG_ALLOC_TIMESTAT
+  std::ostringstream os1;
+  os1 << "[Mutator Allocation Time] : " << &mutator << maple::endl;
+  PrintTimeStat(os1, "[local]", kTimeAllocLocal, mutator);
+  PrintTimeStat(os1, "[global]", kTimeAllocGlobal, mutator);
+  PrintTimeStat(os1, "[large]", kTimeAllocLarge, mutator);
+  PrintTimeStat(os1, "[release]", kTimeReleaseObj, mutator);
+  PrintTimeStat(os1, "[free local]", kTimeFreeLocal, mutator);
+  PrintTimeStat(os1, "[free global]", kTimeFreeGlobal, mutator);
+  PrintTimeStat(os1, "[free large]", kTimeFreeLarge, mutator);
+  LOG(ERROR) << os1.str().c_str() << maple::endl;
+#else
+  static_cast<void>(mutator);
+#endif
+}
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_ALLOC_CALLBACKS_H
diff --git a/src/mrt/compiler-rt/include/allocator/alloc_config.h b/src/mrt/compiler-rt/include/allocator/alloc_config.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f813bf34a5cb09734e7ace134704b44f530b174
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/alloc_config.h
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ALLOC_CONFIG_H
+#define MAPLE_RUNTIME_ALLOC_CONFIG_H
+
+#include "sizes.h"
+#include "mm_config.h"
+#include "alloc_utils.h"
+
+// ROS allocator specific --- start ---
+// Run configuration section ---------------------------------------------------
+const size_t kROSAllocLocalSize = 104;
+const size_t kROSAllocLargeSize = 2016;
+
+namespace maplert {
+struct RunConfigType {
+  const bool isLocal; // this kind of run can be local
+  const uint8_t numCaches; // this kind of run at most has this many caches, deprecated
+  const uint8_t numPagesPerRun; // pages per run
+  const uint32_t size; // slot size of this kind of run
+};
+class RunConfig {
+ public:
+  // this class only has static member, so its constructor and destructors are useless.
+  RunConfig() = delete;
+  RunConfig(const RunConfig&) = delete;
+  RunConfig(RunConfig&&) = delete;
+  RunConfig &operator=(const RunConfig&) = delete;
+  RunConfig &operator=(RunConfig&&) = delete;
+  ~RunConfig() = delete;
+  // REMEMBER TO CHANGE THIS WHEN YOU ADD/REMOVE CONFIGS
+  static const uint32_t kRunConfigs = 53;
+
+  // this supports a maximum of (256 * 8 == 2048 byte) run
+  // we need to extend this if we want to config multiple-page run
+  static const uint32_t kMaxRunConfigs = 256;
+  // change this when add/remove configs
+  // this stores a config for each kind of run (represented by an index)
+  static const RunConfigType kCfgs[kRunConfigs];
+  // this map maps a size ((size >> 3 - 1) to be precise) to a run config
+  // this map takes 4 * kMaxRunConfigs == 1k
+  static uint32_t size2idx[kMaxRunConfigs]; // all zero-initialised
+};
+} // namespace maplert
+
+// assume(size <= (kCfgs[N_RUN_CONFIGS - 1].size << 3))
+#define ROSIMPL_RUN_IDX(size) RunConfig::size2idx[((size) >> 3) - 1]
+// this is a short cut of ROSIMPL_RUN_IDX, only works under certain configs, see kCfgs def
+#define ROSIMPL_FAST_RUN_IDX(size) (((size) >> 3) - 2)
+#define ROSIMPL_RUN_SIZE(idx) (RunConfig::kCfgs[(idx)].size)
+// return true if for a obj of this size, we use thread-local storage
+#define ROSIMPL_IS_LOCAL_RUN_SIZE(size) \
+    ((size) <= kROSAllocLargeSize && RunConfig::kCfgs[ROSIMPL_RUN_IDX(size)].isLocal)
+// this is a short cut of ROSIMPL_IS_LOCAL_RUN_SIZE, only works under certain configs, see kCfgs def
+#define ROSIMPL_FAST_IS_LOCAL_RUN_SIZE(size) ((size) <= kROSAllocLocalSize)
+// an idx corresponds to a kind of run with a certain size,
+// return true if we allow thread-local runs of this size
+#define ROSIMPL_IS_LOCAL_RUN_IDX(idx) (RunConfig::kCfgs[(idx)].isLocal)
+#define ROSIMPL_N_CACHE_RUNS(idx) (RunConfig::kCfgs[(idx)].numCaches)
+#define ROSIMPL_N_PAGES_PER_RUN(idx) (RunConfig::kCfgs[(idx)].numPagesPerRun)
+
+const uint32_t kROSAllocLocalRuns = ROSIMPL_FAST_RUN_IDX(kROSAllocLocalSize) + 1;
+const int kRosimplDefaultPagePerRun = 1;
+const int kRosimplDefaultMaxCacheRun = 8; // unused
+
+// Heap configuration section --------------------------------------------------
+#define ROSIMPL_DEFAULT_MAX_SPACE (1ul << 29) // 512MB
+#define ROSIMPL_DEFAULT_MAX_PAGES (ROSIMPL_DEFAULT_MAX_SPACE >> ROSALLOC_LOG_PAGE_SIZE)
+const int kRosimplDefaultPageOneTime = 256;
+
+const bool kRosimplReleasePageAtFree = true;
+const bool kRosimplReleasePageAtTrim = true;
+
+#define ROSIMPL_DEFAULT_HEAP_START_SIZE (1 << 23) // 8m
+#define ROSIMPL_DEFAULT_HEAP_SIZE ROSIMPL_DEFAULT_MAX_SPACE
+#define ROSIMPL_DEFAULT_HEAP_GROWTH_LIMIT ROSIMPL_DEFAULT_HEAP_SIZE
+// we trigger grow exactly when we run out of free pages
+// changing this number won't add other triggers, so don't expect this to do what ART is doing
+#define ROSIMPL_DEFAULT_HEAP_MIN_FREE (0U)
+#define ROSIMPL_DEFAULT_HEAP_MAX_FREE (1 << 23) // 8m
+const double kRosimplDefaultHeapTargetUtilization = 0.95; // ART 0.75
+const bool kRosimplDefaultIgnoreMaxFootprint = false;
+
+// when true, we memset obj memory to 0 at Free() time;
+// when false, we memset the allocated memory to 0 at New() time instead
+// memset at New() might be useful for debugging, but lacking in performance
+#define ROSIMPL_MEMSET_AT_FREE (true)
+
+constexpr size_t kAllocAlign = 8;
+#define ROSIMPL_HEADER_ALLOC_SIZE (maplert::kHeaderSize)
+
+static_assert((ROSIMPL_HEADER_ALLOC_SIZE) % kAllocAlign == 0,
+              "obj header size must be aligned");
+static_assert((maplert::kJavaArrayContentOffset) % kAllocAlign == 0,
+              "java array content offset is required to be aligned by the allocator");
+
+static_assert(kROSAllocLargeSize >= ROSIMPL_HEADER_ALLOC_SIZE, "large size too small");
+constexpr size_t kFastAllocMaxSize =
+    maplert::AllocUtilRndDown(kROSAllocLocalSize - ROSIMPL_HEADER_ALLOC_SIZE, kAllocAlign);
+static_assert(kFastAllocMaxSize >= ROSIMPL_HEADER_ALLOC_SIZE, "large size too small");
+constexpr size_t kFastAllocArrayMaxSize = kFastAllocMaxSize - maplert::kJavaArrayContentOffset;
+
+static_assert(kFastAllocArrayMaxSize <= maplert::kMrtMaxArrayLength, "array length too big");
+
+constexpr size_t kAllocArrayMaxSize = maplert::AllocUtilRndDown(std::numeric_limits<size_t>::max() -
+    ROSIMPL_HEADER_ALLOC_SIZE - maplert::kJavaArrayContentOffset, kAllocAlign);
+
+#define ROSIMPL_GET_OBJ_FROM_ADDR(addr) ((addr) + ROSIMPL_HEADER_ALLOC_SIZE)
+#define ROSIMPL_GET_ADDR_FROM_OBJ(objAddr) ((objAddr) - ROSIMPL_HEADER_ALLOC_SIZE)
+
+// define the size of the bitmap.
+// we need to address the issue of multiple page runs
+#define ROSIMPL_SLOTS_RAW (8 * sizeof(uint32_t))
+#define ROSIMPL_BITMAP_SIZE (ALLOCUTIL_PAGE_SIZE / (ROSIMPL_SLOTS_RAW * ROSIMPL_HEADER_ALLOC_SIZE))
+
+// Debugging options -----------------------------------------------------------
+#ifndef ROSIMPL_ENABLE_VERIFY
+#define ROSIMPL_ENABLE_VERIFY __MRT_DEBUG_COND_FALSE
+#endif
+
+#if ROSIMPL_ENABLE_VERIFY
+#define ROSIMPL_ENABLE_ASSERTS true
+#define ROSIMPL_DEBUG(func) func
+#else
+#define ROSIMPL_DEBUG(func) (void(0))
+#endif
+
+#ifndef ROSIMPL_ENABLE_ASSERTS
+#define ROSIMPL_ENABLE_ASSERTS __MRT_DEBUG_COND_FALSE
+#endif
+
+#if ROSIMPL_ENABLE_ASSERTS
+#define ROSIMPL_ASSERT(p, msg) __MRT_ASSERT(p, msg)
+#define ROSIMPL_ASSERT_IF(cond, p, msg) if (cond) __MRT_ASSERT(p, msg)
+#define ROSIMPL_DUNUSED(x) x
+#else
+#define ROSIMPL_DUNUSED(x) x __attribute__((unused))
+#define ROSIMPL_ASSERT(p, msg) (void(0))
+#define ROSIMPL_ASSERT_IF(cond, p, msg) (void(0))
+#endif
+
+// ASSERTS only working under verification mode
+#if ROSIMPL_ENABLE_VERIFY && ROSIMPL_ENABLE_ASSERTS
+#define ROSIMPL_VERIFY_ASSERT(p, msg) __MRT_ASSERT(p, msg)
+#else
+#define ROSIMPL_VERIFY_ASSERT(p, msg) (void(0))
+#endif
+
+#define ROSIMPL_ENABLE_DUMP __MRT_DEBUG_COND_FALSE
+
+#if ROSIMPL_ENABLE_DUMP
+#define ROSIMPL_VERIFY_DUMP_PG_TABLE Dump()
+#else
+#define ROSIMPL_VERIFY_DUMP_PG_TABLE (void(0))
+#endif
+
+// Permanent-space allocator specific -- start ---
+const size_t kBPAllocObjAlignment = 8; // align to 8 for 64-bit system
+const size_t kBPAllocHeaderSize = maplert::DecoupleAllocHeader::kHeaderSize;
+
+const size_t kPermMaxSpaceSize = (64u << 20);        // 64MB maximum
+const size_t kMetaMaxSpaceSize = (64u << 20);        // 64MB maximum
+const size_t kDecoupleMaxSpaceSize = (64u << 20);    // 64MB maximum
+const size_t kZterpMaxSpaceSize = (32u << 20);       // 32MB maximum
+static_assert((kPermMaxSpaceSize % ALLOCUTIL_PAGE_SIZE) == 0, "invalid perm space size");
+static_assert((kMetaMaxSpaceSize % ALLOCUTIL_PAGE_SIZE) == 0, "invalid meta space size");
+static_assert((kDecoupleMaxSpaceSize % ALLOCUTIL_PAGE_SIZE) == 0, "invalid decouple space size");
+const size_t kOffHeapSpaceGap = ALLOCUTIL_PAGE_SIZE; // defensive gap
+const size_t kOffHeapSpaceSize = kPermMaxSpaceSize + kOffHeapSpaceGap +
+                                 kMetaMaxSpaceSize + kOffHeapSpaceGap +
+                                 kZterpMaxSpaceSize + kOffHeapSpaceGap +
+                                 kDecoupleMaxSpaceSize + kOffHeapSpaceGap + kZterpMaxSpaceSize;
+
+#define BPALLOC_GET_OBJ_FROM_ADDR(addr) ((addr) + maplert::DecoupleAllocHeader::kHeaderSize)
+
+#ifndef BPALLOC_DEBUG
+#define BPALLOC_DEBUG __MRT_DEBUG_COND_FALSE
+#endif
+#ifndef BPALLOC_ENABLE_ASSERTS
+#define BPALLOC_ENABLE_ASSERTS BPALLOC_DEBUG
+#endif
+
+#if BPALLOC_ENABLE_ASSERTS
+#define BPALLOC_ASSERT(p, msg) __MRT_ASSERT(p, msg)
+#define BPALLOC_ASSERT_IF(cond, p, msg) if (cond) __MRT_ASSERT(p, msg)
+#define BPALLOC_DUNUSED(x) x
+#else
+#define BPALLOC_ASSERT(p, msg) (void(0))
+#define BPALLOC_ASSERT_IF(cond, p, msg) (void(0))
+#define BPALLOC_DUNUSED(x) x __attribute__((unused))
+#endif
+
+#endif // MAPLE_RUNTIME_ALLOC_CONFIG_H
diff --git a/src/mrt/compiler-rt/include/allocator/alloc_utils.h b/src/mrt/compiler-rt/include/allocator/alloc_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..147641ec94cc56022c03a714c1362485e097b953
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/alloc_utils.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ALLOC_UTILS_H
+#define MAPLE_RUNTIME_ALLOC_UTILS_H
+
+#include <random>
+#include "sizes.h"
+#include "mm_config.h"
+#include "deps.h"
+
+namespace maplert {
+#ifndef ALLOCUTIL_PAGE_SIZE
+#define ALLOCUTIL_PAGE_SIZE (static_cast<uintptr_t>(0x1000)) // 4K page
+#endif
+
+constexpr uint32_t kAllocUtilLogPageSize = 12;
+#define ALLOCUTIL_PAGE_BYTE2CNT(x) ((x) >> kAllocUtilLogPageSize)
+#define ALLOCUTIL_PAGE_CNT2BYTE(x) (static_cast<size_t>(x) << kAllocUtilLogPageSize)
+
+
+#define ALLOCUTIL_PAGE_RND_DOWN(x) ((static_cast<uintptr_t>(x)) & (~(ALLOCUTIL_PAGE_SIZE - 1)))
+#define ALLOCUTIL_PAGE_RND_UP(x) \
+    (((static_cast<uintptr_t>(x)) + ALLOCUTIL_PAGE_SIZE - 1) & (~(ALLOCUTIL_PAGE_SIZE - 1)))
+
+#define ALLOCUTIL_PAGE_ADDR(x) (static_cast<address_t>(x) & (~(ALLOCUTIL_PAGE_SIZE - 1)))
+
+#define ALLOCUTIL_MEM_UNMAP(address, size_in_bytes) \
+  if (munmap(reinterpret_cast<void*>(address), size_in_bytes) != EOK) { \
+    perror("munmap failed. Process terminating."); \
+    MRT_Panic(); \
+  }
+
+#define ALLOCUTIL_MEM_MADVISE(address, size_in_bytes, option) \
+  if (madvise(reinterpret_cast<void*>(address), size_in_bytes, option) != EOK) { \
+    perror("madvise failed. Process terminating."); \
+    MRT_Panic(); \
+  }
+
+constexpr uint32_t kAllocUtilPrefetchWrite = 1;
+#define ALLOCUTIL_PREFETCH_WRITE(address) \
+    __builtin_prefetch(reinterpret_cast<void*>(address), kAllocUtilPrefetchWrite)
+
+template<typename T>
+constexpr T AllocUtilRndDown(T x, size_t n) {
+  return (x & static_cast<size_t>(-n));
+}
+
+template<typename T>
+constexpr T AllocUtilRndUp(T x, size_t n) {
+  return AllocUtilRndDown(x + n - 1, n);
+}
+
+template<class IntType>
+class AllocUtilRand {
+ public:
+  AllocUtilRand() = delete;
+  AllocUtilRand(IntType randStart, IntType randEnd) {
+    std::random_device rd;
+    e = std::mt19937(rd());
+    dist = std::uniform_int_distribution<IntType>(randStart, randEnd);
+  }
+  ~AllocUtilRand() = default;
+  // return random value between l and u (inclusive), please make sure l <= u
+  inline IntType next() {
+    return dist(e);
+  }
+
+ private:
+  std::mt19937 e;
+  std::uniform_int_distribution<IntType> dist;
+};
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_ALLOC_UTILS_H
diff --git a/src/mrt/compiler-rt/include/allocator/box.h b/src/mrt/compiler-rt/include/allocator/box.h
new file mode 100644
index 0000000000000000000000000000000000000000..c097ed05a239f0a875eb039278c9b13c47b0bc4c
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/box.h
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_BOX_H
+#define MAPLE_RUNTIME_BOX_H
+
+#include <cstddef>
+#include <memory>
+
+// Port of Rust Box
+namespace maplert {
+// Port of std::boxed::Box from the Rust programming language.
+//
+// Basically equivalent to C++ std::unique_ptr, but is supposed to be used with
+// a custom allocator, and is not supposed to customize the deleter.  Basically,
+//    - If you care more about where the object is allocated, use Box.
+//    - If you care more about where the object is freed, use unique_ptr.
+// Note that you can always convert a Box to and from Box::unique_ptr, a
+// std::unique_ptr specialization, using IntoUniquePtr and FromUniquePtr.
+//
+// The user should allocate object using Box<T>::New, and let the Box<T> go out
+// of scope so that it gets naturally deleted by the allocator.  We can also
+// convert a Box<T> to T* using IntoRaw, and back from T* to Box<T> using
+// FromRaw, so that the object remains alive when pointed by T*, and gets
+// recycled after converting back to Box<T> and going out of scope.
+//
+// Requirements:
+//   The allocator must be stateless.  The default allocator (std::allocator) is
+//   stateless.  maplert::StdContainerAllocator is also statelss.
+template<class T, class Allocator = std::allocator<T>>
+class Box final {
+ public:
+  // Deleter that supports std::unique_ptr
+  class Deleter {
+   public:
+    void operator()(T *ptr) {
+      DestructAndDeallocate(ptr);
+    }
+  };
+
+  // Our std::unique_ptr alias.
+  using unique_ptr = std::unique_ptr<T, Deleter>;
+
+  // Make an empty box.
+  Box() : rawPointer(nullptr) {}
+
+  // Move from another box, take the responsibility to free the object.
+  Box(Box &&other) { // not explicit
+    MoveFrom(other);
+  };
+
+  // Move from another box, take the responsibility to free the object.
+  Box &operator=(Box &&other) {
+    MoveFrom(other);
+    return *this;
+  }
+
+  // Destruct the contained object and deallocate it.
+  ~Box() {
+    Drop();
+  }
+
+  // @return true if the box is empty (initialized as empty, moved, destructed,
+  // or explicitly discarded).
+  bool IsEmpty() const {
+    return rawPointer == nullptr;
+  }
+
+  // Same as IsEmpty(), enabling the `box == nullptr` expression.
+  bool operator==(std::nullptr_t) const {
+    return IsEmpty();
+  }
+
+  // Same as !IsEmpty(), enabling the `box != nullptr` expression.
+  bool operator!=(std::nullptr_t) const {
+    return !IsEmpty();
+  }
+
+  // Get the reference to the contained object.  Similar to
+  // std::unique_ptr::operator*()
+  T &operator*() const {
+    return *rawPointer;
+  }
+
+  // Allow the box->member syntax so that the box can be used as a pointer.
+  // Similar to std::unique_ptr::operator->()
+  T *operator->() const {
+    return rawPointer;
+  }
+
+  // Convert into a raw pointer, and give up the responsibility to free the
+  // object. Similar to std::unique_ptr::release()
+  T *IntoRaw() {
+    return TakePointer();
+  }
+
+  // Get the underlying raw pointer. Similar to std::unique_ptr::get().
+  //
+  // Use with care! It breaks the "This Box is the only pointer of the object"
+  // rule.
+  T *UnsafeGetRaw() const {
+    return rawPointer;
+  }
+
+  // Convert into an std::unique_ptr.  The unique_ptr is now responsible for
+  // freeing the object.
+  unique_ptr IntoUniquePtr() {
+    T *ptr = TakePointer();
+    return unique_ptr(ptr);
+  }
+
+  // Destruct the contained object and deallocate the memory using the
+  // allocator.  Do nothing if this Box has already been moved or destroyed.
+  void Drop() noexcept {
+    if (rawPointer != nullptr) {
+      T *ptr = TakePointer();
+      DestructAndDeallocate(ptr);
+    }
+  }
+
+  // Create an empty, with a nullptr as its content. Same as the default
+  // constructor, but more explicit.
+  static Box Empty() {
+    return Box();
+  }
+
+  // Create a box using the constructor of a type. Similar to std::make_unique.
+  template<class... Args>
+  static Box New(Args &&...args) {
+    T *ptr = AllocateAndConstruct(std::forward<Args>(args)...);
+    return Box(ptr);
+  }
+
+  // Convert a raw pointer back into a Box, taking the reponsibility to free the
+  // object.  The object must be allocated by the same allocator specified for
+  // the Box<T, Allocator> type.  Similar to the constructor of std::unique_ptr
+  static Box FromRaw(T *ptr) {
+    return Box(ptr);
+  }
+
+  // Convert a unique_ptr back into a Box, taking the reponsibility to free the
+  // object.  The object must be allocated by the same allocator specified for
+  // the Box<T, Allocator> type.
+  static Box FromUniquePtr(unique_ptr uptr) {
+    return FromRaw(uptr.release());
+  }
+
+ private:
+  // Construct a box from a raw pointer.  Internal use, only.
+  Box(T *ptr) : rawPointer(ptr) {}
+
+  Box(const Box &other) = delete; // Cannot be copied.
+  Box &operator=(const Box &other) = delete; // Cannot be copy-assigned.
+
+  // Get the rawPointer, ensuring we do not forget to clear the rawPointer field.
+  T *TakePointer() {
+    T *ptr = rawPointer;
+    rawPointer = nullptr;
+    return ptr;
+  }
+
+  // Take the pointer (and the reponsibility to free the object) from another
+  // Box
+  void MoveFrom(Box &other) {
+    rawPointer = other.TakePointer();
+  }
+
+  // Use the allocator to allocate and construct the object.
+  template<class... Args>
+  static T *AllocateAndConstruct(Args &&...args) {
+    Allocator allocator;
+    T *ptr = std::allocator_traits<Allocator>::allocate(allocator, 1);
+    std::allocator_traits<Allocator>::construct(allocator, ptr, std::forward<Args>(args)...);
+    return ptr;
+  }
+
+  // Use the allocator to destruct and deallocate the object.
+  static void DestructAndDeallocate(T *ptr) {
+    Allocator allocator;
+    std::allocator_traits<Allocator>::destroy(allocator, ptr);
+    std::allocator_traits<Allocator>::deallocate(allocator, ptr, 1);
+  }
+
+  // The raw pointer
+  T *rawPointer;
+};
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_BOX_H
diff --git a/src/mrt/compiler-rt/include/allocator/bp_allocator.h b/src/mrt/compiler-rt/include/allocator/bp_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..8905170761aeec07afd126cb3803b445b1d86ddf
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/bp_allocator.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_BP_ALLOCATOR_H
+#define MAPLE_RUNTIME_BP_ALLOCATOR_H
+
+#include <cstdint>
+#include <cstdlib>
+#include <cinttypes>
+#include <mutex>
+
+#include "alloc_config.h"
+#include "allocator/mem_map.h"
+
+namespace maplert {
+// A bump-pointer allocator for permanent space.
+class BumpPointerAlloc {
+ public:
+  static const uint32_t kInitialSpaceSize;
+  static const size_t kExtendedSize;
+
+  // kClassInitializedState is defined according to kFireBreak and kSpaceAnchor,
+  // so adjust kClassInitializedState if they are modified.
+  //
+  // kFireBreak also reserves some time for C2IBridge. We need to make sure the
+  // C2I bridge does not exceed this amount.
+  //
+  // In the future, it is better to arrange the entire memory layout in a single
+  // file in order to coordinate multiple modules that need to use the low 4GB
+  // memory.
+  static constexpr size_t kFireBreak = (256u << 20); // 256MB. Leave enough space for C2I Bridge.
+  static constexpr address_t kSpaceAnchor = (3ul << 30); // 3GB
+
+  BumpPointerAlloc(const string&, size_t);
+  virtual ~BumpPointerAlloc();
+  virtual address_t Alloc(size_t size);
+  inline address_t AllocThrowExp(size_t size);
+  bool Contains(address_t obj) const;
+  void Dump(std::basic_ostream<char> &os);
+
+ protected:
+  MemMap *memMap;
+  address_t startAddr;
+  address_t currentAddr;
+  address_t endAddr;
+  mutex globalLock;
+  const string showmapName;
+
+  template <bool throwExp = false>
+  inline address_t AllocInternal(const size_t &allocSize);
+  virtual void DumpUsage(std::basic_ostream<char>&) {}
+
+ private:
+  void Init(size_t growthLimit);
+}; // class BumpPointerAlloc
+
+class MetaAllocator : public BumpPointerAlloc {
+ public:
+  MetaAllocator(const string &name, size_t maxSpaceSize) : BumpPointerAlloc(name, maxSpaceSize) {}
+  ~MetaAllocator() = default;
+  address_t Alloc(size_t size, MetaTag metaTag);
+  address_t Alloc(size_t) override {
+    BPALLOC_ASSERT(false, "must provide MetaTag in meta space");
+    return 0U;
+  }
+
+ protected:
+  void DumpUsage(std::basic_ostream<char> &os) override;
+
+ private:
+  uint32_t sizeUsed[kMetaTagNum] = { 0 };
+};
+
+class DecoupleAllocator : public BumpPointerAlloc {
+ public:
+  DecoupleAllocator(const string &name, size_t maxSpaceSize);
+  ~DecoupleAllocator() = default;
+
+  bool ForEachObj(function<void(address_t)> visitor);
+  address_t Alloc(size_t size, DecoupleTag tag);
+  address_t Alloc(size_t) override {
+    BPALLOC_ASSERT(false, "must provide DecoupleTag in decouple space");
+    return 0U;
+  }
+
+  static inline size_t GetAllocSize(size_t size) {
+    return AllocUtilRndUp<address_t>(size + DecoupleAllocHeader::kHeaderSize, kBPAllocObjAlignment);
+  }
+
+ protected:
+  void DumpUsage(std::basic_ostream<char> &os) override;
+};
+
+class ZterpStaticRootAllocator : public BumpPointerAlloc {
+ public:
+  static const size_t singleObjSize = kBPAllocObjAlignment;
+  ZterpStaticRootAllocator(const string &name, size_t maxSpaceSize) : BumpPointerAlloc(name, maxSpaceSize) {};
+  virtual ~ZterpStaticRootAllocator() = default;
+  inline address_t GetStartAddr() const {
+    return startAddr;
+  }
+  inline size_t GetObjNum() {
+    // because the space of bump pointer allocator only increase linearly, and the obj won't be erased, so the race
+    // only occurs when currentAddr is modified.
+    std::lock_guard<std::mutex> lock(globalLock);
+    __MRT_ASSERT(currentAddr >= startAddr, "currentAddr should not be lower than startAddr!");
+    size_t usedSpace = currentAddr - startAddr;
+    __MRT_ASSERT((usedSpace % singleObjSize) == 0, "used space should be devided by single size of root pointer!");
+    return usedSpace / singleObjSize;
+  }
+  void VisitStaticRoots(const RefVisitor &visitor);
+};
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_BPALLOCATOR_H
diff --git a/src/mrt/compiler-rt/include/allocator/bp_allocator_inlined.h b/src/mrt/compiler-rt/include/allocator/bp_allocator_inlined.h
new file mode 100644
index 0000000000000000000000000000000000000000..827bceaef4cf55b6f2aad5ae8243828f8a56a00e
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/bp_allocator_inlined.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_BP_ALLOCATOR_INLINED_H
+#define MAPLE_RUNTIME_BP_ALLOCATOR_INLINED_H
+
+#include <algorithm>
+#include <sstream>
+
+#include "chosen.h"
+#include "bp_allocator.h"
+
+namespace maplert {
+inline address_t BumpPointerAlloc::AllocThrowExp(size_t size) {
+  size_t internalSize = AllocUtilRndUp<address_t>(size, kBPAllocObjAlignment);
+  address_t allocAddr = AllocInternal<true>(internalSize);
+  if (UNLIKELY(allocAddr == 0)) {
+    (*theAllocator).OutOfMemory();
+    return 0;
+  }
+  return allocAddr;
+}
+
+// tries to allocate an object given the size
+template <bool throwExp>
+inline address_t BumpPointerAlloc::AllocInternal(const size_t &allocSize) {
+  lock_guard<mutex> guard(globalLock);
+  if (UNLIKELY((allocSize + currentAddr) > endAddr)) {
+    size_t requiredSize = ALLOCUTIL_PAGE_RND_UP((allocSize - (endAddr - currentAddr)));
+    size_t remainingSize = reinterpret_cast<address_t>(memMap->GetMappedEndAddr()) - endAddr;
+    size_t extendSize = std::max(requiredSize, std::min(remainingSize, kExtendedSize));
+    if (UNLIKELY(!memMap->Extend(extendSize))) {
+      if (throwExp) {
+        LOG(ERROR) << showmapName << " space out of memory, alloc size " << allocSize << ", space left " <<
+            remainingSize << maple::endl;
+        return 0;
+      }
+      // allocator failure is fatal (no OOME thrown)
+      LOG(FATAL) << showmapName << " space out of memory, alloc size " << allocSize << ", space left " <<
+          remainingSize << maple::endl;
+      __builtin_unreachable();
+      return 0;
+    }
+    endAddr = reinterpret_cast<address_t>(memMap->GetCurrEnd());
+  }
+  address_t allocAddr = currentAddr;
+  currentAddr += allocSize;
+  return allocAddr;
+}
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_BPALLOCATOR_INLINED_H
diff --git a/src/mrt/compiler-rt/include/allocator/cartesian_tree.h b/src/mrt/compiler-rt/include/allocator/cartesian_tree.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b5b419b3943de08fa5439d529ca370420b90248
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/cartesian_tree.h
@@ -0,0 +1,484 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_CARTESIAN_TREE_H
+#define MAPLE_RUNTIME_CARTESIAN_TREE_H
+
+#include <cstddef>
+#include <cstdint>
+#include <fstream>
+#include "deque.h"
+#include "panic.h"
+
+#define DEBUG_CARTESIAN_TREE __MRT_DEBUG_COND_FALSE
+#if DEBUG_CARTESIAN_TREE
+#define CTREE_ASSERT(cond, msg) __MRT_ASSERT(cond, msg)
+#define CTREE_CHECK_PARENT_AND_LCHILD(n) CheckParentAndLeftChild(n)
+#define CTREE_CHECK_PARENT_AND_RCHILD(n) CheckParentAndRightChild(n)
+#else
+#define CTREE_ASSERT(cond, msg) (void(0))
+#define CTREE_CHECK_PARENT_AND_LCHILD(n) (void(0))
+#define CTREE_CHECK_PARENT_AND_RCHILD(n) (void(0))
+#endif
+
+// This is an implementation of a Cartesian tree.
+// This can be used in arbitrary-sized, free-list allocation algorithm.
+// The use of this tree and the algorithm is inspired by
+// R. Jones, A. Hosking, E. Moss. The garbage collection handbook:
+// the art of automatic memory management. Chapman and Hall/CRC, 2016.
+// This implementation is all hand-written, in which process the
+// author might have referenced some online tutorials, notably https://www.geeksforgeeks.org/
+// This data structure doesn't guarantee the multi-thread safety, so the external invoker should take some
+// policy to avoid competition problems.
+namespace maplert {
+template<class A = std::uintptr_t, class S = std::size_t>
+class CartesianTree {
+ public:
+  CartesianTree() : root(nullptr) {}
+
+  ~CartesianTree() {
+    DeleteFrom(root);
+  }
+
+  void Init(size_t mapSize) {
+    // when used to manage free page regions, we count how many nodes we need at max
+    size_t pageCount = ALLOCUTIL_PAGE_RND_UP(mapSize) / ALLOCUTIL_PAGE_SIZE;
+    size_t regionCount = (pageCount >> 1) + 1; // at most we need this many regions
+    // calculate how much we need for native allocation
+    // we might need some extra space for some temporaries, so set aside another 7 slots
+    size_t nativeSize = (regionCount + 7) * AllocUtilRndUp(sizeof(Node), alignof(Node));
+    NativeAlloc::nal.Init(ALLOCUTIL_PAGE_RND_UP(nativeSize));
+    // calculate how much we need for the deque temporary
+    size_t dequeSize = regionCount * sizeof(void*);
+    sud.Init(ALLOCUTIL_PAGE_RND_UP(dequeSize));
+    traversalSud.Init(sud.GetMemMap());
+  }
+
+  inline bool Empty() {
+    return root == nullptr;
+  }
+  inline S Top() {
+    return root ? root->key2 : 0U;
+  }
+
+  // insert a node to the tree, if we find connecting nodes, we merge them
+  // (the non-merging insertion is not allowed)
+  // true when insertion succeeded, false otherwise
+  // if [a, a + s) clashes with existing node, it fails
+  // if s is 0U, it always fails
+  bool MergeInsert(A a, S s) {
+    if (root == nullptr) {
+      root = new Node(a, s);
+      __MRT_ASSERT(root != nullptr, "fail to allocate a new node");
+      return true;
+    }
+
+    if (s == 0) {
+      return false;
+    }
+
+    return MergeInsertInternal(a, s);
+  }
+
+  // find a node with a key2 of at least s, store its key1 into a
+  // split/remove this node if found
+  // return false if nothing is found or s is 0U
+  bool Find(A &a, S s) {
+    if (root == nullptr || s == 0) {
+      return false;
+    }
+
+    return Find(root, root, a, s);
+  }
+
+  struct CartesianTreeNode {
+    A key1;
+    S key2;
+    CartesianTreeNode *l;
+    CartesianTreeNode *r;
+
+    CartesianTreeNode(A k1, S k2) : key1(k1), key2(k2), l(nullptr), r(nullptr) {}
+    ~CartesianTreeNode() {
+      l = nullptr;
+      r = nullptr;
+    }
+
+    static void *operator new(std::size_t sz __attribute__((unused))) {
+      return NativeAlloc::Allocate();
+    }
+
+    static void operator delete(void *ptr) {
+      NativeAlloc::Deallocate(ptr);
+    }
+
+    // alias of key1: in PageManager, key1 is the first page's index of a region
+    inline A &Idx() {
+      return key1;
+    }
+
+    // alias of key2: in PageManager, key2 is the page count of a region
+    inline S &Cnt() {
+      return key2;
+    }
+  };
+
+  class Iterator {
+   public:
+    Iterator(CartesianTree &tree) : ct(tree) {
+      tq.SetSud(ct.traversalSud);
+      if (ct.root != nullptr) {
+        tq.Push(ct.root);
+      }
+    }
+    ~Iterator() = default;
+    // we provide a preorder traversal method (preorder lets the largest region visited first):
+    inline CartesianTreeNode *Next() {
+      if (tq.Empty()) {
+        return nullptr;
+      }
+      Node *front = tq.Front();
+      if (front->r != nullptr) {
+        tq.Push(front->r);
+      }
+      if (front->l != nullptr) {
+        tq.Push(front->l);
+      }
+      tq.PopFront();
+      return front;
+    }
+   private:
+    CartesianTree &ct;
+    LocalDeque<CartesianTreeNode*> tq;
+  };
+
+  using Node = CartesianTreeNode;
+  using NativeAlloc = NativeAllocLite<sizeof(Node), alignof(Node)>;
+
+ private:
+  Node *root;
+  SingleUseDeque<Node**> sud;
+  SingleUseDeque<Node*> traversalSud;
+
+  // used by destructor to resursively delete the tree
+  void DeleteFrom(Node *n) {
+    if (n == nullptr) {
+      return;
+    }
+    DeleteFrom(n->l);
+    DeleteFrom(n->r);
+    delete n;
+    n = nullptr;
+  }
+
+  // the following function tries to merge new node (a, s) with n
+  enum MergeResult {
+    kSuccess = 0, // successfully merged with the node n
+    kMiss,        // the new node (a, s) is not connected to n, cannot merge
+    kError        // error, operation aborted
+  };
+  MergeResult MergeAt(Node *n, A a, S s) {
+    A m = a + s;
+
+    // try to merge the inserted node to the right of n
+    if (a == n->key1 + n->key2) {
+      Node *last = n;
+      Node *next = n->r;
+      // also, find a connected node to the right of the inserted node
+      while (next != nullptr) {
+        if (next->key1 == m) {
+          if (next->l != nullptr) {
+            CTREE_ASSERT(false, "merging failed case 1");
+            return kError;
+          }
+          break;
+        } else if (next->key1 < m) {
+          CTREE_ASSERT(false, "merging failed case 2");
+          return kError;
+        } else {
+          last = next;
+          next = next->l;
+        }
+      }
+      n->key2 += s;
+      if (next != nullptr) {
+        n->key2 += next->key2;
+        if (last == n) {
+          last->r = RemoveNode(next);
+        } else {
+          last->l = RemoveNode(next);
+        }
+      }
+      CTREE_CHECK_PARENT_AND_RCHILD(n);
+      return kSuccess;
+    }
+
+    // try to merge the inserted node to the left of n
+    if (m == n->key1) {
+      Node *last = n;
+      Node *next = n->l;
+      // also, find a connected node to the left of the inserted node
+      while (next != nullptr) {
+        if (next->key1 + next->key2 == a) {
+          if (next->r != nullptr) {
+            CTREE_ASSERT(false, "merging failed case 3");
+            return kError;
+          }
+          break;
+        } else if (next->key1 + next->key2 > a) {
+          CTREE_ASSERT(false, "merging failed case 4");
+          return kError;
+        } else {
+          last = next;
+          next = next->r;
+        }
+      }
+      n->key1 = a;
+      n->key2 += s;
+      if (next != nullptr) {
+        n->key1 = next->key1;
+        n->key2 += next->key2;
+        if (last == n) {
+          last->l = RemoveNode(next);
+        } else {
+          last->r = RemoveNode(next);
+        }
+      }
+      CTREE_CHECK_PARENT_AND_LCHILD(n);
+      return kSuccess;
+    }
+
+    return kMiss;
+  }
+
+  // see the public MergeInsert()
+  inline bool MergeInsertInternal(A a, S s) {
+    //     +-------------+       +--------------+
+    //     | parent node |  n--> | current node |
+    //     |             |       |              |
+    // pn ---> Node* l; -------> |              |
+    //     |   Node* r;  |       |              |
+    //     +-------------+       +--------------+
+    // suppose current node is parent node's left child, then
+    // n points to the current node,
+    // pn points to the 'l' field in the parent node
+    Node *n = root; // root is current node
+    Node **pn = &root; // pointer to the 'root' field in this tree
+    // stack of pn recording how to go from root to the current node
+    LocalDeque<Node**> pnStack(sud); // this uses another deque as container
+    A m = a + s;
+
+    // this loop insert the new node (a, s) at the proper place
+    do {
+      if (n == nullptr) {
+        n = new Node(a, s);
+        __MRT_ASSERT(n != nullptr, "fail to allocate a new node");
+        *pn = n;
+        break;
+      }
+      MergeResult res = MergeAt(n, a, s);
+      if (res == kSuccess) {
+        break;
+      } else if (UNLIKELY(res == kError)) {
+        return false;
+      }
+      // kMiss: (a, s) cannot be connected to n
+      if (m < n->Idx()) {
+        // should insert into left subtree
+        pnStack.Push(pn);
+        pn = &(n->l);
+        n = n->l;
+      } else if (a > n->Idx() + n->Cnt()) {
+        // should insert into right subtree
+        pnStack.Push(pn);
+        pn = &(n->r);
+        n = n->r;
+      } else {
+        // something clashes
+        CTREE_ASSERT(false, "merge insertion failed");
+        return false;
+      }
+    } while (true);
+
+    // this loop bubbles the inserted node up the tree to satisfy heap property
+    while (!pnStack.Empty()) {
+      pn = pnStack.Top();
+      pnStack.Pop();
+      n = *pn;
+      CTREE_ASSERT(n, "merge insertion bubbling failed case 1");
+      if (m < n->Idx()) {
+        // (a, s) was inserted into n's left subtree, do rotate l, if needed
+        if (n->Cnt() < n->l->Cnt()) {
+          *pn = RotateLeft(n);
+          CTREE_CHECK_PARENT_AND_RCHILD(*pn);
+        } else {
+          break;
+        }
+      } else if (a > n->Idx() + n->Cnt()) {
+        // (a, s) was inserted into n's right subtree, do rotate r, if needed
+        if (n->Cnt() < n->r->Cnt()) {
+          *pn = RotateRight(n);
+          CTREE_CHECK_PARENT_AND_LCHILD(*pn);
+        } else {
+          break;
+        }
+      } else {
+        CTREE_ASSERT(false, "merge insertion bubbling failed case 2");
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  // rotate the node and its left child to maintain heap property
+  inline Node *RotateLeft(Node *n) {
+    Node *tmp = n->l;
+    n->l = tmp->r;
+    tmp->r = n;
+    return tmp;
+  }
+  // rotate the node and its right child to maintain heap property
+  inline Node *RotateRight(Node *n) {
+    Node *tmp = n->r;
+    n->r = tmp->l;
+    tmp->l = n;
+    return tmp;
+  }
+
+  // see the public find()
+  // balance could be a problem
+  bool Find(Node *&pn, Node *n, A &a, S s) {
+    if (n->key2 < s) {
+      return false;
+    }
+
+    if (n->l != nullptr) {
+      // leftmost node preference
+      // this makes left tree significantly shorter
+      CTREE_CHECK_PARENT_AND_LCHILD(n);
+      if (Find(n->l, n->l, a, s)) {
+        return true;
+      }
+    }
+
+    a = n->key1;
+    n->key1 += s;
+    n->key2 -= s;
+    if (n->key2) {
+      pn = LowerNode(n);
+    } else {
+      pn = RemoveNode(n);
+    }
+    CTREE_CHECK_PARENT_AND_LCHILD(pn);
+    CTREE_CHECK_PARENT_AND_RCHILD(pn);
+    return true;
+  }
+
+  // move a node down in the tree below to maintain heap property
+  Node *LowerNode(Node *n) {
+    CTREE_ASSERT(n, "lowering node failed");
+    Node *tmp = nullptr;
+
+    if (n->l != nullptr && n->l->key2 > n->key2) {
+      // this makes right tree slightly taller
+      if (n->r != nullptr && n->r->key2 > n->l->key2) {
+        tmp = RotateRight(n);
+        tmp->l = LowerNode(tmp->l);
+        CTREE_CHECK_PARENT_AND_LCHILD(tmp);
+        return tmp;
+      } else {
+        tmp = RotateLeft(n);
+        tmp->r = LowerNode(tmp->r);
+        CTREE_CHECK_PARENT_AND_RCHILD(tmp);
+        return tmp;
+      }
+    }
+
+    if (n->r && n->r->key2 > n->key2) {
+      tmp = RotateRight(n);
+      tmp->l = LowerNode(tmp->l);
+      CTREE_CHECK_PARENT_AND_LCHILD(tmp);
+      return tmp;
+    }
+
+    return n;
+  }
+
+  // remove a node and adjust the tree below
+  // inline
+  Node *RemoveNode(Node *n) {
+    CTREE_ASSERT(n, "removing node failed");
+    if (n->l == nullptr && n->r == nullptr) {
+      delete n;
+      n = nullptr;
+      return nullptr;
+    }
+    Node *tmp = nullptr;
+    if (n->l == nullptr) {
+      tmp = RotateRight(n);
+      tmp->l = RemoveNode(tmp->l);
+      CTREE_CHECK_PARENT_AND_LCHILD(tmp);
+      return tmp;
+    } else {
+      if (n->r == nullptr) {
+        tmp = RotateLeft(n);
+        tmp->r = RemoveNode(tmp->r);
+        CTREE_CHECK_PARENT_AND_RCHILD(tmp);
+        return tmp;
+      } else {
+        // this makes right tree slightly taller
+        if (n->l->key2 < n->r->key2) {
+          tmp = RotateRight(n);
+          tmp->l = RemoveNode(tmp->l);
+          CTREE_CHECK_PARENT_AND_LCHILD(tmp);
+          return tmp;
+        } else {
+          tmp = RotateLeft(n);
+          tmp->r = RemoveNode(tmp->r);
+          CTREE_CHECK_PARENT_AND_RCHILD(tmp);
+          return tmp;
+        }
+      }
+    }
+  }
+
+  inline void CheckParentAndLeftChild(const Node *n) {
+#if DEBUG_CARTESIAN_TREE
+    if (n != nullptr) {
+      const Node *l = n->l;
+      if (l != nullptr) {
+        CTREE_ASSERT((n->key1 > (l->key1 + l->key2)), "left child overlapped with parent");
+        CTREE_ASSERT((n->key2 >= l->key2), "left child bigger than parent");
+      }
+    }
+#else
+    (void)n;
+#endif
+  }
+  inline void CheckParentAndRightChild(const Node *n) {
+#if DEBUG_CARTESIAN_TREE
+    if (n != nullptr) {
+      const Node *r = n->r;
+      if (r != nullptr) {
+        CTREE_ASSERT(((n->key1 + n->key2) < r->key1), "right child overlapped with parent");
+        CTREE_ASSERT((n->key2 >= r->key2), "right child bigger than parent");
+      }
+    }
+#else
+    (void)n;
+#endif
+  }
+};
+}
+#endif
diff --git a/src/mrt/compiler-rt/include/allocator/deque.h b/src/mrt/compiler-rt/include/allocator/deque.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0e2f07ee963e0d8e6c4e625a9496bd764e2531e
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/deque.h
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ROSALLOC_DEQUE_H
+#define MAPLE_RUNTIME_ROSALLOC_DEQUE_H
+
+#include <cstddef>
+#include <cstdint>
+#include "mem_map.h"
+#include "panic.h"
+
+#define DEBUG_DEQUE __MRT_DEBUG_COND_FALSE
+#if DEBUG_DEQUE
+#define DEQUE_ASSERT(cond, msg) __MRT_ASSERT(cond, msg)
+#else
+#define DEQUE_ASSERT(cond, msg) (void(0))
+#endif
+
+namespace maplert {
+// this deque is single-use, meaning we can use it, then after a while,
+// we can discard its whole content
+// under this assumption, clearing this data structure is really fast
+// (each clear takes O(1) time)
+// also, this assumes that the underlying memory does not need to be freed
+// because we can reuse it after each clear
+//
+// it can be used like a queue or a stack
+template<class ValType>
+class SingleUseDeque {
+ public:
+  static constexpr size_t kValSize = sizeof(ValType);
+  void Init(size_t mapSize) {
+    static_assert(kValSize == sizeof(void*), "invalid val type");
+    MemMap::Option opt = MemMap::kDefaultOptions;
+    opt.tag = "maple_alloc_ros_sud";
+    opt.reqBase = nullptr;
+    opt.reqRange = false;
+    memMap = MemMap::MapMemory(mapSize, mapSize, opt);
+    beginAddr = reinterpret_cast<address_t>(memMap->GetBaseAddr());
+    endAddr = reinterpret_cast<address_t>(memMap->GetCurrEnd());
+    Clear();
+  }
+  void Init(MemMap &other) {
+    // init from another sud, that is, the two suds share the same mem map
+    static_assert(kValSize == sizeof(void*), "invalid val type");
+    memMap = &other;
+    beginAddr = reinterpret_cast<address_t>(memMap->GetBaseAddr());
+    endAddr = reinterpret_cast<address_t>(memMap->GetCurrEnd());
+    Clear();
+  }
+  MemMap &GetMemMap() {
+    return *memMap;
+  }
+  bool Empty() const {
+    return topAddr < frontAddr;
+  }
+  void Push(ValType v) {
+    topAddr += kValSize;
+    DEQUE_ASSERT(topAddr < endAddr, "not enough memory");
+    *reinterpret_cast<ValType*>(topAddr) = v;
+  }
+  ValType Top() const {
+    DEQUE_ASSERT(topAddr >= frontAddr, "read empty queue");
+    return *reinterpret_cast<ValType*>(topAddr);
+  }
+  void Pop() {
+    DEQUE_ASSERT(topAddr >= frontAddr, "pop empty queue");
+    topAddr -= kValSize;
+  }
+  ValType Front() const {
+    DEQUE_ASSERT(frontAddr <= topAddr, "front reach end");
+    return *reinterpret_cast<ValType*>(frontAddr);
+  }
+  void PopFront() {
+    DEQUE_ASSERT(frontAddr <= topAddr, "pop front empty queue");
+    frontAddr += kValSize;
+  }
+  void Clear() {
+    frontAddr = beginAddr;
+    topAddr = beginAddr - kValSize;
+  }
+ private:
+  MemMap *memMap = nullptr;
+  address_t beginAddr = 0;
+  address_t frontAddr = 0;
+  address_t topAddr = 0;
+  address_t endAddr = 0;
+};
+
+// this deque lives on the stack, hence local
+// this is better than the above deque because it avoids visiting ram
+// and it also avoids using unfreeable memory
+// however, its capacity is limited
+template<class ValType>
+class LocalDeque {
+ public:
+  static_assert(sizeof(ValType) == sizeof(void*), "invalid val type");
+  static constexpr int kLocalLength = ALLOCUTIL_PAGE_SIZE / sizeof(ValType);
+  LocalDeque() : sud(nullptr) {}
+  LocalDeque(SingleUseDeque<ValType> &singleUseDeque) : sud(&singleUseDeque) {}
+  ~LocalDeque() = default;
+  void SetSud(SingleUseDeque<ValType> &singleUseDeque) {
+    sud = &singleUseDeque;
+  }
+  bool Empty() const {
+    return (top < front) || (front == kLocalLength && sud->Empty());
+  }
+  void Push(ValType v) {
+    if (LIKELY(top < kLocalLength - 1)) {
+      array[++top] = v;
+      return;
+    } else if (top == kLocalLength - 1) {
+      ++top;
+      sud->Clear();
+    }
+    sud->Push(v);
+  }
+  ValType Top() const {
+    if (LIKELY(top < kLocalLength)) {
+      DEQUE_ASSERT(top >= front, "read empty queue");
+      return array[top];
+    }
+    return sud->Top();
+  }
+  void Pop() {
+    if (LIKELY(top < kLocalLength)) {
+      DEQUE_ASSERT(top >= front, "pop empty queue");
+      --top;
+      return;
+    }
+    DEQUE_ASSERT(top == kLocalLength, "pop error");
+    sud->Pop();
+    if (front < kLocalLength) {
+      // if front is already in sud, there is no need to dec top, since local is no longer useful
+      --top;
+      return;
+    }
+  }
+  ValType Front() const {
+    if (LIKELY(front < kLocalLength)) {
+      DEQUE_ASSERT(front <= top, "read empty queue front");
+      return array[front];
+    }
+    DEQUE_ASSERT(top == kLocalLength, "queue front error");
+    return sud->Front();
+  }
+  void PopFront() {
+    if (LIKELY(front < kLocalLength)) {
+      DEQUE_ASSERT(front <= top, "pop front empty queue");
+      ++front;
+      return;
+    }
+    DEQUE_ASSERT(front == kLocalLength, "pop front error");
+    sud->PopFront();
+  }
+ private:
+  int front = 0;
+  int top = -1;
+  SingleUseDeque<ValType> *sud;
+  ValType array[kLocalLength];
+};
+
+// this allocator allocates for a certain-sized native data structure
+// it is very lightweight but doesn't recycle pages as much as page allocator
+template<size_t allocSize, size_t align>
+class NativeAllocLite {
+  struct Slot {
+    Slot *next = nullptr;
+  };
+
+ public:
+  static NativeAllocLite nal;
+
+  void Init(size_t mapSize) {
+    static_assert(allocSize >= sizeof(Slot), "invalid alloc size");
+    static_assert(align >= alignof(Slot), "invalid align");
+    static_assert(allocSize % align == 0, "size not aligned");
+    MemMap::Option opt = MemMap::kDefaultOptions;
+    opt.tag = "maple_alloc_ros_nal";
+    opt.reqBase = nullptr;
+    opt.reqRange = false;
+    memMap = MemMap::MapMemory(mapSize, mapSize, opt);
+    currAddr = reinterpret_cast<address_t>(memMap->GetBaseAddr());
+    endAddr = reinterpret_cast<address_t>(memMap->GetCurrEnd());
+  }
+
+  static void *Allocate() {
+    void *result = nullptr;
+    if (UNLIKELY(nal.head == nullptr)) {
+      DEQUE_ASSERT(nal.currAddr + allocSize <= nal.endAddr, "not enough memory");
+      result = reinterpret_cast<void*>(nal.currAddr);
+      nal.currAddr += allocSize;
+    } else {
+      result = reinterpret_cast<void*>(nal.head);
+      nal.head = nal.head->next;
+    }
+    // no zeroing
+    return result;
+  }
+
+  static void Deallocate(void *addr) {
+    reinterpret_cast<Slot*>(addr)->next = nal.head;
+    nal.head = reinterpret_cast<Slot*>(addr);
+  }
+
+ private:
+  Slot *head = nullptr;
+  address_t currAddr = 0;
+  address_t endAddr = 0;
+  MemMap *memMap = nullptr;
+};
+
+template<size_t allocSize, size_t align>
+NativeAllocLite<allocSize, align> NativeAllocLite<allocSize, align>::nal;
+}
+
+#endif // MAPLE_RUNTIME_ROSALLOC_DEQUE_H
diff --git a/src/mrt/compiler-rt/include/allocator/mem_map.h b/src/mrt/compiler-rt/include/allocator/mem_map.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ab6d48d0aebba827705d8a2000db1d5aee6b0fe
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/mem_map.h
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ALLOC_MEM_MAP_H
+#define MAPLE_RUNTIME_ALLOC_MEM_MAP_H
+
+#include <sys/mman.h>
+#include "alloc_utils.h"
+
+namespace maplert {
+class MemMap {
+ public:
+  static const bool kEnableRange = true;
+  static const bool kEnableRandomMemStart = true;
+  static const int kDefaultMemFlags = MAP_PRIVATE | MAP_ANONYMOUS;
+  static const int kDefaultMemProt = PROT_READ | PROT_WRITE;
+
+  struct Option {          // optional args for mem map
+    const char *tag;       // name to identify the mapped memory
+    void *reqBase;         // a hint to mmap about start addr, not guaranteed
+    int flags;             // mmap flags
+    int prot;              // initial access flags
+    bool protAll;          // applying prot to all pages in range
+    bool reqRange;         // request mapping within the following range (guaranteed)
+    address_t lowestAddr;  // lowest start addr (only used when reqRange == true)
+    address_t highestAddr; // highest end addr (only used when reqRange == true)
+    bool isRandom;         // randomise start addr (only used when reqRange == true)
+  };
+  // by default, it tries to map memory in low addr space, with a random start
+  static constexpr Option kDefaultOptions = {
+      "maple_unnamed", nullptr, kDefaultMemFlags, kDefaultMemProt, false,
+      true, HEAP_START, HEAP_END, true
+  };
+
+  // the only way to get a MemMap
+  static MemMap *MapMemory(size_t reqSize, size_t initSize, const Option &opt = kDefaultOptions);
+  static MemMap *CreateMemMapAtExactAddress(void *addr, size_t size, const Option &opt = kDefaultOptions);
+
+  // destroy a MemMap
+  static void DestroyMemMap(MemMap *&memMap) noexcept {
+    if (memMap != nullptr) {
+      delete memMap;
+      memMap = nullptr;
+    }
+  }
+
+  void *GetBaseAddr() const {
+    return memBaseAddr;
+  }
+  void *GetCurrEnd() const {
+    return memCurrEndAddr;
+  }
+  void *GetMappedEndAddr() const {
+    return memMappedEndAddr;
+  }
+  size_t GetCurrSize() const {
+    return memCurrSize;
+  }
+  size_t GetMappedSize() const {
+    return memMappedSize;
+  }
+
+  inline bool IsAddrInCurrentRange(address_t addr) const {
+    return reinterpret_cast<size_t>(addr - reinterpret_cast<address_t>(memBaseAddr)) < memCurrSize;
+  }
+
+  // change the access flags of the memory in given range
+  bool ProtectMem(address_t addr, size_t size, int prot) const;
+
+  // grow the size of the usable memory
+  bool Extend(size_t reqSize);
+
+  // madvise(DONTNEED) memory in the range [releaseBeginAddr, releaseBeginAddr + size)
+  bool ReleaseMem(address_t releaseBeginAddr, size_t size) const;
+
+  // resize the memory map by releasing the pages at the end (munmap)
+  bool Shrink(size_t newSize);
+
+  ~MemMap();
+  MemMap(const MemMap &that) = delete;
+  MemMap(MemMap &&that) = delete;
+  MemMap &operator=(const MemMap &that) = delete;
+  MemMap &operator=(MemMap &&that) = delete;
+
+ private:
+  // Map in the specified range.
+  // The return addr is guaranteed to be in [lowestAddr, highestAddr - reqSize) if successful.
+  static void *MemMapInRange(address_t lowestAddr, address_t highestAddr,
+                             size_t reqSize, int prot, int flags,
+                             int fd = -1, int offset = 0);
+  static void *MemMapInRangeInternal(address_t hint,
+                                     address_t lowestAddr, address_t highestAddr,
+                                     size_t reqSize, int prot, int flags,
+                                     int fd, int offset);
+  static bool ProtectMemInternal(void *addr, size_t size, int prot);
+
+  void *memBaseAddr;      // start of the mapped memory
+  void *memCurrEndAddr;   // end of the memory **in use**
+  void *memMappedEndAddr; // end of the mapped memory, always >= currEndAddr
+  size_t memCurrSize;     // size of the memory **in use**
+  size_t memMappedSize;   // size of the mapped memory, always >= currSize
+  bool protOnce;
+  const int memProt;      // memory accessibility flags
+
+  // MemMap is created via factory method
+  MemMap(void *baseAddr, size_t initSize, size_t mappedSize, bool protAll, int prot);
+
+  void UpdateCurrEndAddr();
+}; // class MemMap
+} // namespace maplert
+#endif // MAPLE_RUNTIME_ALLOC_MEM_MAP_H
diff --git a/src/mrt/compiler-rt/include/allocator/page_allocator.h b/src/mrt/compiler-rt/include/allocator/page_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..a25ce7203d43857b204e0b04e1e099226ec01cc2
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/page_allocator.h
@@ -0,0 +1,423 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_PAGEALLOCATOR_H
+#define MAPLE_RUNTIME_PAGEALLOCATOR_H
+
+#include <pthread.h>
+#include <sys/mman.h>
+#include <atomic>
+#include <cstdint>
+#include <cstring>
+#include <mutex>
+
+#include "mm_utils.h"
+#include "globals.h"
+#include "panic.h"
+#include "deps.h"
+#include "page_pool.h"
+#include "mrt_api_common.h"
+
+#define PA_VERBOSE_LVL DEBUGY
+
+namespace maplert {
+// when there is a need to use PageAllocator to manage
+// the memory for a specific data structure, please add
+// a new type
+enum AllocationTag : uint32_t {
+  kMinAllocationTag = 0u,
+  // allocation type for customized data struction
+  kCartesianTree = kMinAllocationTag, // manage memory for CartesianTree Node
+
+  // alllocation type for std container
+  kReferenceProcessor,   // manage the std container in ReferenceProcessor
+  kROSAllocator,         // for ROS
+  kMutatorList,          // for mutator list
+  kClassNameStringPool,  // for className string pool
+  kZterpAllocator,       // for Zterp
+  kGCWorkStack,          // for gc mark and write barrier
+  kGCWriteBarrier,       // for write barrier
+  kClassLoaderAllocator, // for classloader
+  kGCTaskQueue,          // for gc task queue
+  // more to come
+  kMaxAllocationTag
+};
+
+// constants and utility function
+class AllocatorUtils {
+ public:
+  AllocatorUtils() = delete;
+  AllocatorUtils(const AllocatorUtils&) = delete;
+  AllocatorUtils(AllocatorUtils&&) = delete;
+  AllocatorUtils &operator=(const AllocatorUtils&) = delete;
+  AllocatorUtils &operator=(AllocatorUtils&&) = delete;
+  ~AllocatorUtils() = delete;
+  static constexpr uint32_t kLogAllocPageSize = 12;
+  static constexpr uint32_t kAllocPageSize = maple::kPageSize;
+  static constexpr uint32_t kLogAllocAlignment = 3;
+  static constexpr uint32_t kAllocAlignment = 1 << kLogAllocAlignment;
+  static constexpr uint32_t kMaxSlotSize = kAllocPageSize / 2;
+};
+
+// Allocator manages page allocation and deallocation
+class PageAllocator {
+  static constexpr uint32_t kMaxCached = 0;
+
+  // slots in a page are managed as a linked list
+  struct Slot {
+    Slot *next = nullptr;
+  };
+
+  // pages are linked to each other as double-linked list.
+  // the free slot list and other infomation are also in
+  // the page header
+  class Page {
+    friend class PageAllocator;
+
+   public:
+    // get a slot from the free slot list
+    inline void *Allocate() {
+      if (header != nullptr) {
+        void *result = reinterpret_cast<void*>(header);
+        header = header->next;
+        --free;
+        return result;
+      }
+      return nullptr;
+    }
+
+    // return a slot to the free slot list
+    inline void Deallocate(void *slot) {
+      Slot *cur = reinterpret_cast<Slot*>(slot);
+      cur->next = header;
+      header = cur;
+      ++free;
+    }
+
+    inline bool Available() const {
+      return free != 0;
+    }
+
+    inline bool Empty() const {
+      return free == total;
+    }
+
+   private:
+    Page *prev = nullptr;
+    Page *next = nullptr;
+    Slot *header = nullptr;
+    uint16_t free = 0;
+    uint16_t total = 0;
+  };
+
+ public:
+  PageAllocator() : nonFull(nullptr), cached(nullptr), totalPages(0), totalCached(0), slotSize(0), slotAlignment(0) {}
+
+  explicit PageAllocator(uint32_t size)
+      : nonFull(nullptr), cached(nullptr), totalPages(0), totalCached(0), slotSize(size) {
+    slotAlignment = maple::AlignUp<uint32_t>(size, AllocatorUtils::kAllocAlignment);
+  }
+
+  ~PageAllocator() = default;
+
+  void Destroy() {
+    DestroyList(nonFull);
+    DestroyList(cached);
+  }
+
+  void Init(uint32_t size) {
+    slotSize = size;
+    slotAlignment = maple::AlignUp<uint32_t>(size, AllocatorUtils::kAllocAlignment);
+  }
+
+  // allocation entrypoint
+  void *Allocate() {
+    void *result = nullptr;
+    {
+      std::lock_guard<std::mutex> guard(allocLock);
+
+      if (nonFull == nullptr) {
+        if (cached != nullptr) {
+          Page *cur = cached;
+          RemoveFromList(cached, *cur);
+          AddToList(nonFull, *cur);
+          --totalCached;
+        } else {
+          Page *cur = CreatePage();
+          InitPage(*cur);
+          nonFull = cur;
+          ++totalPages;
+        }
+        LOG(PA_VERBOSE_LVL) << "\ttotal pages mapped:  " << totalPages <<
+            ", total cached page: " << totalCached << ", slot_size: " << slotSize << maple::endl;
+      }
+
+      result = nonFull->Allocate();
+
+      if (!(nonFull->Available())) {
+        // move from nonFull to full
+        Page *cur = nonFull;
+        RemoveFromList(nonFull, *cur);
+      }
+    }
+    if (result != nullptr) {
+      if (memset_s(result, slotSize, 0, slotSize) != EOK) {
+        LOG(FATAL) << "memset_s fail" << maple::endl;
+      }
+    }
+    return result;
+  }
+
+  // deallocation entrypoint
+  void Deallocate(void *slot) {
+    Page *cur = reinterpret_cast<Page*>(maple::AlignDown<uintptr_t>(reinterpret_cast<uintptr_t>(slot),
+                                                                    AllocatorUtils::kAllocPageSize));
+
+    std::lock_guard<std::mutex> guard(allocLock);
+    if (!(cur->Available())) {
+      // move from full to nonFull
+      AddToList(nonFull, *cur);
+    }
+    cur->Deallocate(slot);
+    if (cur->Empty()) {
+      RemoveFromList(nonFull, *cur);
+      if (totalCached < kMaxCached) {
+        AddToList(cached, *cur);
+        ++totalCached;
+      } else {
+        DestroyPage(*cur);
+        --totalPages;
+      }
+      LOG(PA_VERBOSE_LVL) << "\ttotal pages mapped:  " << totalPages <<
+          ", total cached page: " << totalCached << ", slot_size: " << slotSize << maple::endl;
+    }
+  }
+
+ private:
+  // get a page from os
+  static inline Page *CreatePage() {
+    return reinterpret_cast<Page*>(PagePool::Instance().GetPage());
+  }
+
+  // return the page to os
+  static inline void DestroyPage(Page &page) {
+    if (page.free != page.total) {
+      LOG(FATAL) << "\t destroy page in use: total = " << page.total << ", free = " << page.free << maple::endl;
+    } else {
+      LOG(PA_VERBOSE_LVL) << "\t destroy page " << std::hex << &page << std::dec <<
+          " total = " << page.total << ", free = " << page.free << maple::endl;
+    }
+    PagePool::Instance().ReturnPage(reinterpret_cast<uint8_t*>(&page));
+  }
+
+  // construct the data structure of a new allocated page
+  void InitPage(Page &page) {
+    page.prev = nullptr;
+    page.next = nullptr;
+    constexpr uint32_t offset = maple::AlignUp<uint32_t>(sizeof(Page), AllocatorUtils::kAllocAlignment);
+    page.free = (AllocatorUtils::kAllocPageSize - offset) / slotAlignment;
+    page.total = page.free;
+    if (UNLIKELY(page.free < 1)) {
+      LOG(FATAL) << "use the wrong allocator! slot size = " << slotAlignment << maple::endl;
+    }
+
+    char *start = reinterpret_cast<char*>(&page);
+    char *end = start + AllocatorUtils::kAllocPageSize - 1;
+    char *slot = start + offset;
+    page.header = reinterpret_cast<Slot*>(slot);
+    Slot *prevSlot = page.header;
+    while (true) {
+      slot += slotAlignment;
+      char *slotEnd = slot + slotAlignment - 1;
+      if (slotEnd > end) {
+        break;
+      }
+
+      Slot *cur = reinterpret_cast<Slot*>(slot);
+      prevSlot->next = cur;
+      prevSlot = cur;
+    }
+
+    LOG(PA_VERBOSE_LVL) << "new page start = " << std::hex << start << ", end = " << end <<
+        ", slot header = " << page.header << std::dec <<
+        ", total slots = " << page.total << ", slot size = " << slotAlignment <<
+        ", sizeof(Page) = " << sizeof(Page) << maple::endl;
+  }
+
+  // linked-list management
+  inline void AddToList(Page *&list, Page &page) {
+    if (list != nullptr) {
+      list->prev = &page;
+    }
+    page.next = list;
+    list = &page;
+  }
+
+  inline void RemoveFromList(Page *&list, Page &page) {
+    Page *prev = page.prev;
+    Page *next = page.next;
+    if (&page == list) {
+      list = next;
+      if (next != nullptr) {
+        next->prev = nullptr;
+      }
+    } else {
+      prev->next = next;
+      if (next != nullptr) {
+        next->prev = prev;
+      }
+    }
+    page.next = nullptr;
+    page.prev = nullptr;
+  }
+
+  inline void DestroyList(Page *&list) {
+    Page *cur = nullptr;
+    while (list != nullptr) {
+      cur = list;
+      list = list->next;
+      DestroyPage(*cur);
+    }
+  }
+
+  Page *nonFull;
+  Page *cached;
+  std::mutex allocLock;
+  uint32_t totalPages;
+  uint32_t totalCached;
+  uint32_t slotSize;
+  uint32_t slotAlignment;
+};
+
+// Utility class used for StdContainerAllocator
+// It has lots of PageAllocators, each for different slot size,
+// so all allocation sizes can be handled by this bridge class.
+class AggregateAllocator {
+ public:
+  static constexpr uint32_t kMaxAllocators =
+      AllocatorUtils::kMaxSlotSize >> AllocatorUtils::kLogAllocAlignment;
+
+  MRT_EXPORT static AggregateAllocator &Instance(AllocationTag tag);
+
+  AggregateAllocator() {
+    uint32_t slotSize = AllocatorUtils::kAllocAlignment;
+    for (uint32_t i = 0; i < kMaxAllocators; ++i) {
+      allocator[i].Init(slotSize);
+      slotSize += AllocatorUtils::kAllocAlignment;
+    }
+  }
+  ~AggregateAllocator() = default;
+
+  // choose appropriate allocation to allocate
+  void *Allocate(size_t size) {
+    uint32_t alignedSize = maple::AlignUp(static_cast<uint32_t>(size), AllocatorUtils::kAllocAlignment);
+    if (alignedSize <= AllocatorUtils::kMaxSlotSize) {
+      uint32_t index = alignedSize >> AllocatorUtils::kLogAllocAlignment;
+      return allocator[index - 1].Allocate();
+    } else {
+      return PagePool::Instance().GetPage(size);
+    }
+  }
+
+  void Deallocate(void *p, size_t size) {
+    uint32_t alignedSize = maple::AlignUp(static_cast<uint32_t>(size), AllocatorUtils::kAllocAlignment);
+    if (alignedSize <= AllocatorUtils::kMaxSlotSize) {
+      uint32_t index = alignedSize >> AllocatorUtils::kLogAllocAlignment;
+      allocator[index - 1].Deallocate(p);
+    } else {
+      PagePool::Instance().ReturnPage(reinterpret_cast<uint8_t*>(p), size);
+    }
+  }
+
+ private:
+  PageAllocator allocator[kMaxAllocators];
+};
+
+// Allocator used to take control of memory allocation for std containers.
+// It uses AggregateAllocator to dispatch the memory operation to appropriate PageAllocator.
+template<class T, AllocationTag cat>
+class StdContainerAllocator {
+ public:
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using value_type = T;
+
+  using propagate_on_container_copy_assignment = std::false_type;
+  using propagate_on_container_move_assignment = std::true_type;
+  using propagate_on_container_swap = std::true_type;
+
+  template<class Up>
+  struct rebind {
+    using other = StdContainerAllocator<Up, cat>;
+  };
+
+  StdContainerAllocator() = default;
+  ~StdContainerAllocator() = default;
+
+  template<class U>
+  StdContainerAllocator(const StdContainerAllocator<U, cat>&) {}
+
+  StdContainerAllocator(const StdContainerAllocator<T, cat>&) {}
+
+  StdContainerAllocator(StdContainerAllocator<T, cat>&&) {}
+
+  StdContainerAllocator<T, cat> &operator = (const StdContainerAllocator<T, cat>&) {
+    return *this;
+  }
+
+  StdContainerAllocator<T, cat> &operator = (StdContainerAllocator<T, cat>&&) {
+    return *this;
+  }
+
+  pointer address(reference x) const {
+    return std::addressof(x);
+  }
+
+  const_pointer address(const_reference x) const {
+    return std::addressof(x);
+  }
+
+  pointer allocate(size_type n, const void *hint __attribute__((unused)) = 0) {
+    pointer result = static_cast<pointer>(AggregateAllocator::Instance(cat).Allocate(sizeof(T) * n));
+    return result;
+  }
+
+  void deallocate(pointer p, size_type n) {
+    AggregateAllocator::Instance(cat).Deallocate(p, sizeof(T) * n);
+  }
+
+  size_type max_size() const {
+    return static_cast<size_type>(~0) / sizeof(value_type);
+  }
+
+  void construct(pointer p, const_reference val) {
+    ::new (reinterpret_cast<void*>(p)) value_type(val);
+  }
+
+  template<class Up, class... Args>
+  void construct(Up *p, Args&&... args) {
+    ::new (reinterpret_cast<void*>(p)) Up(std::forward<Args>(args)...);
+  }
+
+  void destroy(pointer p) {
+    p->~value_type();
+  }
+};
+}  // end of namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/allocator/page_map.h b/src/mrt/compiler-rt/include/allocator/page_map.h
new file mode 100644
index 0000000000000000000000000000000000000000..06ce57e6694504e2c122bc46a25b57d20e72bad9
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/page_map.h
@@ -0,0 +1,421 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_PAGE_MAP_H
+#define MAPLE_RUNTIME_PAGE_MAP_H
+
+#include "alloc_utils.h"
+#include "mem_map.h"
+#include "alloc_config.h"
+
+// This file declares a page map and its operations for use in the allocator
+namespace maplert {
+// Enable this to count the total incs and decs of a page.
+#define MRT_RESURRECTION_PROFILE 0
+const uint8_t kPageLabelMygoteBit = 0x80;
+
+// rename these?
+enum PageLabel : uint8_t {
+  kPReleased = 0,
+  kPFree,
+  kPRun,
+  kPRunRem,
+  kPLargeObj,
+  kPLargeObjRem,
+  kPSweeping,
+  kPSwept,
+  // mygote pages transition from the corresponding normal pages, mygote pages are never cleared
+  kPMygoteRun = kPRun | kPageLabelMygoteBit,
+  kPMygoteRunRem = kPRunRem | kPageLabelMygoteBit,
+  kPMygoteLargeObj = kPLargeObj | kPageLabelMygoteBit,
+  kPMygoteLargeObjRem = kPLargeObjRem | kPageLabelMygoteBit,
+  kPMax,
+};
+
+// This class records the number of un-resurrected finalizable objects in each page.
+class FinalizableProf {
+  friend class PageMap;
+
+ public:
+  struct PageEntry {
+#if MRT_RESURRECTION_PROFILE == 1
+    std::atomic<size_t> incs = { 0 };   // Number of increments
+    std::atomic<size_t> decs = { 0 };   // Number of decrements
+#endif // MRT_RESURRECTION_PROFILE
+    std::atomic<uint16_t> fins = { 0 }; // Number of finalizable objects not yet resurrected
+  };
+
+  void Init(size_t maxMapSize) {
+    size_t maxSize = maxMapSize * sizeof(PageEntry);
+    maxSize = ALLOCUTIL_PAGE_RND_UP(maxSize);
+    MemMap::Option opt = MemMap::kDefaultOptions;
+    opt.tag = "maple_alloc_ros_fp";
+    opt.reqBase = nullptr;
+    opt.reqRange = false;
+    memMap = MemMap::MapMemory(maxSize, maxSize, opt);
+    entries = static_cast<PageEntry*>(memMap->GetBaseAddr());
+    if (UNLIKELY(entries == nullptr)) {
+      LOG(FATAL) << "finalizable prof initialisation failed" << maple::endl;
+    }
+  }
+
+  void IncPage(size_t index) {
+    PageEntry &entry = GetEntry(index);
+#if MRT_RESURRECTION_PROFILE == 1
+    entry.incs.fetch_add(1, std::memory_order_relaxed);
+#endif // MRT_RESURRECTION_PROFILE
+    entry.fins.fetch_add(1, std::memory_order_relaxed);
+  }
+
+  void DecPage(size_t index) {
+    PageEntry &entry = GetEntry(index);
+#if MRT_RESURRECTION_PROFILE == 1
+    entry.decs.fetch_add(1, std::memory_order_relaxed);
+#endif // MRT_RESURRECTION_PROFILE
+    entry.fins.fetch_sub(1, std::memory_order_relaxed);
+  }
+
+ private:
+  MemMap *memMap = nullptr;
+  PageEntry *entries = nullptr;
+
+  PageEntry &GetEntry(size_t index) {
+#if __MRT_DEBUG
+    size_t maxEntries = memMap->GetCurrSize() / sizeof(PageEntry);
+    if (index >= maxEntries) {
+      LOG(FATAL) << "index overflow when reading the finalizable object record index: " <<
+          index << " size: " << maxEntries << maple::endl;
+    }
+#endif
+    return entries[index];
+  }
+};
+
+// This is a map from index to type for all pages.
+// Also has a finalizable obj recorder.
+class PageMap {
+ public:
+  // the type of page index and page count
+  using IntType = size_t;
+
+  PageMap();
+  ~PageMap();
+  void Init(address_t baseAddr, size_t maxSize, size_t size);
+
+  PageMap(const PageMap &that) = delete;
+  PageMap(PageMap &&that) = delete;
+  PageMap &operator=(const PageMap &that) = delete;
+  PageMap &operator=(PageMap &&that) = delete;
+
+  inline address_t GetBeginAddr() const {
+    return spaceBeginAddr;
+  }
+  inline address_t GetEndAddr() const {
+    return spaceEndAddr;
+  }
+  inline IntType GetPageIndex(address_t addr) const {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr <= spaceEndAddr), "addr out of bound");
+    return ALLOCUTIL_PAGE_BYTE2CNT(addr - spaceBeginAddr);
+  }
+  inline address_t GetPageAddr(IntType idx) const {
+    ROSIMPL_ASSERT(idx < maxMapSize, "index out of bound");
+    return spaceBeginAddr + ALLOCUTIL_PAGE_CNT2BYTE(idx);
+  }
+  inline IntType GetMapSize() const {
+    return pageMapSize;
+  }
+  inline PageLabel GetType(IntType idx) const {
+    ROSIMPL_ASSERT(idx < maxMapSize, "index out of bound");
+    return map[idx];
+  }
+  inline PageLabel GetTypeForAddr(address_t addr) const {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    return map[GetPageIndex(addr)];
+  }
+  inline const PageLabel *GetMap() const {
+    return const_cast<PageLabel*>(map);
+  }
+
+  inline PageLabel GetTypeAcquire(IntType idx) {
+    PageLabel *p = const_cast<PageLabel*>(&map[idx]);
+    std::atomic<PageLabel> &atomicLabel = *reinterpret_cast<std::atomic<PageLabel>*>(p);
+    return atomicLabel.load(std::memory_order_acquire);
+  }
+  inline void SetTypeRelease(IntType idx, PageLabel label) {
+    PageLabel *p = const_cast<PageLabel*>(&map[idx]);
+    std::atomic<PageLabel> &atomicLabel = *reinterpret_cast<std::atomic<PageLabel>*>(p);
+    atomicLabel.store(label, std::memory_order_release);
+  }
+
+  inline bool MatchAddr(address_t addr, PageLabel pageLabel) const {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    return (map[GetPageIndex(addr)] == pageLabel);
+  }
+  inline bool ContainsAddr(address_t addr) const {
+    return (addr >= spaceBeginAddr && addr < spaceEndAddr);
+  }
+
+  inline bool IsMygotePageAddr(address_t addr) const {
+    return (static_cast<uint8_t>(map[GetPageIndex(addr)]) & kPageLabelMygoteBit) != 0;
+  }
+
+  inline bool PageHasFinalizableObject(IntType index) {
+    ROSIMPL_ASSERT(index < maxMapSize, "index out of bound");
+    return finProf.GetEntry(index).fins.load(std::memory_order_relaxed) > 0;
+  }
+  inline size_t NumOfFinalizableObjectsInPage(IntType index) {
+    ROSIMPL_ASSERT(index < pageMapSize, "index out of bound");
+    return finProf.GetEntry(index).fins.load(std::memory_order_relaxed);
+  }
+  inline size_t NumOfFinalizableObjectsInRun(IntType index) {
+    ROSIMPL_ASSERT(index < pageMapSize, "index out of bound");
+    ROSIMPL_ASSERT((map[index] == kPRun) || (map[index] == kPMygoteRun), "not a run page");
+    size_t n = NumOfFinalizableObjectsInPage(index);
+    for (IntType next = index + 1; next < pageMapSize &&
+         (map[next] == kPRunRem || map[next] == kPMygoteRunRem); ++next) {
+      n += NumOfFinalizableObjectsInPage(next);
+    }
+    return n;
+  }
+
+  // update the map size and the end address
+  inline void UpdateSize(size_t size) {
+    IntType mapSize = ALLOCUTIL_PAGE_BYTE2CNT(size);
+    if (mapSize > pageMapSize) {
+      pageMapSize = mapSize;
+      spaceEndAddr = spaceBeginAddr + size;
+    }
+  }
+
+  // set the page type of each page in range
+  inline void SetRange(IntType idx1, IntType idx2, PageLabel label) {
+    ROSIMPL_ASSERT(idx1 < idx2, "idx1 < idx2");
+    ROSIMPL_ASSERT(idx2 <= maxMapSize, "index out of bound");
+    for (IntType i = idx1; i < idx2; ++i) {
+      map[i] = label;
+    }
+  }
+
+  // set the page type of each page in range, also count
+  // how many pages are converted free -> released or released -> (free/allocated)
+  inline IntType SetRangeAndCount(IntType idx1, IntType idx2, PageLabel label) {
+    ROSIMPL_ASSERT(idx1 < idx2, "idx1 < idx2");
+    ROSIMPL_ASSERT(idx2 <= maxMapSize, "index out of bound");
+    bool isToReleased = (label == kPReleased);
+    IntType count = 0;
+    for (IntType i = idx1; i < idx2; ++i) {
+      if (isToReleased && map[i] != kPReleased) {
+        ROSIMPL_ASSERT(map[i] == kPFree, "released non-free page");
+        ++count;
+      } else if (!isToReleased && map[i] == kPReleased) {
+        ALLOCUTIL_PREFETCH_WRITE(GetPageAddr(i));
+        ++count;
+      }
+      map[i] = label;
+    }
+    return count;
+  }
+
+  // set the pageCnt pages starting from address addr to "run" type
+  inline IntType SetAsRunPage(address_t addr, IntType pageCnt) {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    IntType index = GetPageIndex(addr);
+    ROSIMPL_ASSERT(index < pageMapSize, "index out of bound");
+    ROSIMPL_ASSERT(map[index] == kPFree || map[index] == kPReleased, "set an occupied page to run");
+    IntType count = 0;
+    if (map[index] == kPReleased) {
+      ALLOCUTIL_PREFETCH_WRITE(addr);
+      ++count;
+    }
+    // for ConcurrentPrepareResurrection, see SetAsLargeObjPage comment
+#if ROSIMPL_MEMSET_AT_FREE
+    map[index] = kPRun;
+#else
+    if (map[index] == kPFree) {
+      *reinterpret_cast<uint64_t*>(GetPageAddr(index)) = 0;
+    }
+    SetTypeRelease(index, kPRun);
+#endif
+    if (pageCnt > 1) {
+      count += SetRangeAndCount(index + 1, index + pageCnt, kPRunRem);
+    }
+    return count;
+  }
+
+  // count the number of pages in a run (starting with a Run page then 0 or more RunRem pages)
+  inline IntType RunPageCount(address_t addr) const {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    IntType index = GetPageIndex(addr);
+    ROSIMPL_ASSERT(map[index] == kPRun || map[index] == kPMygoteRun, "not a run page");
+    IntType cnt = 1U;
+    for (IntType i = index + 1; i < pageMapSize; ++i, ++cnt) {
+      if (map[i] != kPRunRem && map[i] != kPMygoteRunRem) {
+        break;
+      }
+    }
+    return cnt;
+  }
+
+  // return the beginning of a run given an address (nb multi-page run)
+  inline address_t GetRunStartFromAddr(address_t addr) const {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    IntType index = GetPageIndex(addr);
+    IntType runIndex = 0;
+    for (IntType i = index; i > 0; --i) {
+      if (map[i] == kPRun || map[i] == kPMygoteRun) {
+        runIndex = i;
+        break;
+      }
+    }
+    // if we are here it means that the run could be at position 0
+    ROSIMPL_ASSERT(map[runIndex] == kPRun || map[runIndex] == kPMygoteRun, "wrong page type");
+    return GetPageAddr(runIndex);
+  }
+
+  // set the pageCnt pages starting from address addr to "large obj" type
+  inline IntType SetAsLargeObjPage(address_t addr, IntType pageCnt) {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    IntType index = GetPageIndex(addr);
+    ROSIMPL_ASSERT(index < pageMapSize, "index out of bound");
+    ROSIMPL_ASSERT(map[index] == kPFree || map[index] == kPReleased, "set an occupied page to large obj");
+    IntType count = 0;
+    if (map[index] == kPReleased) {
+      ALLOCUTIL_PREFETCH_WRITE(addr);
+      ++count;
+    }
+    // ConcurrentPrepareResurrection bug. This synchronises with GetTypeAcquire
+    // during unsafe heap scan. This ensures that when the heap scan finds a
+    // large obj page, it must look like an unallocated page at first (allocated bit is 0).
+    // If memset is done earlier, then there might not be a problem at all,
+    // assuming reorders don't pass through global locks.
+    // Caution, this atomic op is very expensive according to flame graphs.
+#if ROSIMPL_MEMSET_AT_FREE
+    map[index] = kPLargeObj;
+#else
+    if (map[index] == kPFree) {
+      // prevent ConcurrentPrepareResurrection from getting this page
+      *reinterpret_cast<uint64_t*>(GetPageAddr(index)) = 0;
+    }
+    SetTypeRelease(index, kPLargeObj);
+#endif
+    if (pageCnt > 1) {
+      count += SetRangeAndCount(index + 1, index + pageCnt, kPLargeObjRem);
+    }
+    return count;
+  }
+
+  // count the number of pages of a large obj
+  // (starting with a LargeObj page then 0 or more LargeObjRem pages)
+  inline IntType LargeObjPageCount(address_t addr) const {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    IntType index = GetPageIndex(addr);
+    ROSIMPL_ASSERT(map[index] == kPLargeObj || map[index] == kPMygoteLargeObj, "not a large obj page");
+    IntType cnt = 1U;
+    for (IntType i = index + 1; i < pageMapSize; ++i, ++cnt) {
+      if (map[i] != kPLargeObjRem && map[i] != kPMygoteLargeObjRem) {
+        break;
+      }
+    }
+    return cnt;
+  }
+
+  // clear run page (set as free or released)
+  inline void ClearRunPage(address_t addr, IntType pageCnt, bool isReleased) {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    IntType index = GetPageIndex(addr);
+    PageLabel label = isReleased ? kPReleased : kPFree;
+    for (IntType i = index; i < index + pageCnt; ++i) {
+      ROSIMPL_ASSERT((map[i] == kPRun || map[i] == kPRunRem), "page type was not correct");
+      map[i] = label;
+    }
+  }
+
+  // clear large obj page (set as free or released)
+  inline void ClearLargeObjPage(address_t addr, IntType pageCnt, bool isReleased) {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    IntType index = GetPageIndex(addr);
+    PageLabel label = isReleased ? kPReleased : kPFree;
+    for (IntType i = index; i < index + pageCnt; ++i) {
+      ROSIMPL_ASSERT((map[i] == kPLargeObj || map[i] == kPLargeObjRem), "page type was not correct");
+      map[i] = label;
+    }
+  }
+
+  // return number of pages freed after resetting labels for a large object
+  inline IntType ClearLargeObjPageAndCount(address_t addr, bool isReleased) {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    IntType index = GetPageIndex(addr);
+    ROSIMPL_ASSERT(map[index] == kPLargeObj, "page addr in the middle");
+    IntType cnt = 1U;
+    PageLabel label = isReleased ? kPReleased : kPFree;
+    map[index] = label;
+    for (IntType i = index + 1; i < pageMapSize; ++i, ++cnt) {
+      if (map[i] != kPLargeObjRem) {
+        break;
+      }
+      map[i] = label;
+    }
+    return cnt;
+  }
+
+  // set all allocated pages as mygote pages, used by mygote before forking
+  inline void SetAllAsMygotePage() {
+    for (IntType i = 0; i < pageMapSize; ++i) {
+      if (map[i] == kPRun || map[i] == kPRunRem || map[i] == kPLargeObj || map[i] == kPLargeObjRem) {
+        map[i] = static_cast<PageLabel>(static_cast<uint8_t>(map[i]) | kPageLabelMygoteBit);
+      }
+    }
+  }
+
+  inline void OnFinalizableObjCreated(address_t addr) {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    finProf.IncPage(GetPageIndex(addr));
+  }
+
+  inline void OnFinalizableObjResurrected(address_t addr) {
+    ROSIMPL_ASSERT((addr >= spaceBeginAddr) && (addr < spaceEndAddr), "addr out of bound");
+    finProf.DecPage(GetPageIndex(addr));
+  }
+
+  void Dump();
+  void DumpFinalizableInfo(std::ostream &ost);
+
+ private:
+  // defensive padding, do nothing
+  uint64_t padding __attribute__((unused)) = 0;
+
+  // the page map holds some knowledge of the address space
+  // they are updated when the page manager is updated
+  address_t spaceBeginAddr;
+  address_t spaceEndAddr;
+
+  // the total number of pages mapped
+  IntType maxMapSize;
+  // the current number of pages (the rest must be of "released" type)
+  IntType pageMapSize;
+
+  // this mmaps some memory where the page map lives
+  // this should be resizable
+  MemMap *memMap;
+  // this is a map from index to type for all pages. unlike the page manager, it only changes
+  // in lock but it can be read out of locks to quickly decide the state of a page, hence volatile.
+  PageLabel *map;
+
+  // this records the number of unresurrected finalizable objs in each page
+  // this doesn't have to be here, because it has no dependency on page map
+  FinalizableProf finProf;
+};
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_PAGE_MAP_H
diff --git a/src/mrt/compiler-rt/include/allocator/page_pool.h b/src/mrt/compiler-rt/include/allocator/page_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..68e07131d0376be7ff3a62b71286f71e3b4eb417
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/page_pool.h
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ALLOCATOR_PAGE_POOL_H
+#define MAPLE_RUNTIME_ALLOCATOR_PAGE_POOL_H
+
+#include <sys/mman.h>
+#include "globals.h"
+#include "mrt_api_common.h"
+#include "syscall.h"
+
+namespace maplert {
+// a page pool maintain a pool of free pages, serve page allocation and free
+class PagePool {
+  static constexpr int kNumTotalPages = 8192; // maximum of 8192 * 4K ~ 32M
+  static constexpr int kLargeMemAllocateStart = kNumTotalPages / 4;
+  static constexpr double kCachedRatio = 1.05; // 1.05 * used_page of pages should be cached
+
+  class Bitmap {
+    friend class PagePool;
+   public:
+    void UnmarkBits(int index, int num) {
+      int row = GetRow(index);
+      int line = GetLine(index);
+      uint32_t cur = data[line].load(std::memory_order_acquire);
+      uint32_t mask = GetMask(num) << static_cast<unsigned int>(row);
+      while (!data[line].compare_exchange_weak(cur, cur & (~mask), std::memory_order_release,
+                                               std::memory_order_acquire)) {
+      }
+    }
+
+    void Unmark(int index, int num) {
+      if (num <= kBitsInBitmapWord) {
+        UnmarkBits(index, num);
+      } else {
+        UnmarkLongBits(index, num);
+      }
+    }
+
+    // get the first free index
+    int MarkFirstNBits(int num) {
+      // the bitmap only serve maximum of 32 * 4k = 128k bytes allocation
+      if (num > kBitsInBitmapWord) {
+        return MarkLongBits(num);
+      }
+
+      // calculate the mask
+      uint32_t mask = GetMask(num);
+
+      // get the first index
+      for (int i = 0; i < kLen; ++i) {
+        uint32_t cur = data[i].load(std::memory_order_acquire);
+        if ((~cur) == 0u) {
+          continue;
+        }
+        uint32_t bit = mask;
+        for (int j = 0; j < kBitsInBitmapWord - num + 1; ++j) {
+          if ((cur & bit) == 0u) {
+            if (data[i].compare_exchange_weak(cur, cur | bit, std::memory_order_release, std::memory_order_acquire)) {
+              return i * kBitsInBitmapWord + j;
+            }
+          }
+          bit = bit << 1;
+        }
+      }
+      return -1;
+    }
+
+   protected:
+    static inline bool InSmallArena(int num) {
+      return num <= kBitsInBitmapWord;
+    }
+
+    // mark the whole word at the index
+    inline bool TryMarkWord(int index) {
+      int line = GetLine(index);
+      uint32_t cur = data[line].load(std::memory_order_acquire);
+      if (cur != 0u) {
+        return false;
+      }
+      uint32_t mask = 0u;
+      mask = ~mask;
+
+      if (data[line].compare_exchange_weak(cur, mask,
+          std::memory_order_release, std::memory_order_acquire)) {
+        return true;
+      }
+      return false;
+    }
+
+    // mark maximum sucessive bits at index in a word
+    int TryMarkBits(int index) {
+      int row = GetRow(index);
+      int line = GetLine(index);
+      uint32_t cur = data[line].load(std::memory_order_acquire);
+      uint32_t mask = 1u;
+      mask = mask << static_cast<unsigned int>(row);
+      if ((mask & cur) != 0) {
+        return 0;
+      }
+      uint32_t bit = mask;
+      int avail = 1;
+      for (int i = 1; i < (kBitsInBitmapWord - row); ++i) {
+        bit = bit << 1;
+        if ((cur & bit) != 0) {
+          break;
+        }
+        mask = mask | bit;
+        ++avail;
+      }
+
+      if (data[line].compare_exchange_weak(cur, cur | mask, std::memory_order_release, std::memory_order_acquire)) {
+        return avail;
+      }
+      return 0;
+    }
+
+   private:
+    inline int GetRow(int index) const {
+      return index % kBitsInBitmapWord;
+    }
+
+    inline int GetLine(int index) const {
+      return index / kBitsInBitmapWord;
+    }
+
+    inline int GetTotalWords(int num) const {
+      return (num + kBitsInBitmapWord - 1) / kBitsInBitmapWord;
+    }
+
+    inline uint32_t GetMask(int num) const {
+      uint32_t mask = 1u;
+      for (int i = 1; i < num; ++i) {
+        mask = mask << 1;
+        mask = mask | 1;
+      }
+      return mask;
+    }
+
+    bool MarkSuccesiveWords(int start, int len) {
+      if (start > kNumTotalPages - kBitsInBitmapWord) {
+        // exceed the last word
+        return false;
+      }
+      if (len == 0) {
+        return true;
+      }
+      if (TryMarkWord(start)) {
+        if (MarkSuccesiveWords(start + kBitsInBitmapWord, len - 1)) {
+          return true;
+        } else {
+          // undo current mark
+          UnmarkBits(start, kBitsInBitmapWord);
+        }
+      }
+      return false;
+    }
+
+    int MarkLongBits(int num) {
+      int index = -1;
+      int len = GetTotalWords(num);
+      for (int i = kLargeMemAllocateStart; i < kNumTotalPages - num; i += kBitsInBitmapWord) {
+        if (MarkSuccesiveWords(i, len)) {
+          index = i;
+          break;
+        }
+      }
+      return index;
+    }
+
+    void UnmarkLongBits(int index, int num) {
+      int len = GetTotalWords(num);
+      int start = index;
+      for (int i = 0; i < len; ++i) {
+        UnmarkBits(start, kBitsInBitmapWord);
+        start += kBitsInBitmapWord;
+      }
+    }
+
+    static constexpr int kBitsInBitmapWord = 32;
+    static constexpr int kLen = kNumTotalPages / kBitsInBitmapWord;
+    std::atomic<uint32_t> data[kLen] = {};
+  };
+
+ public:
+  PagePool() {
+    size_t size = kNumTotalPages * maple::kPageSize;
+    uint8_t *result = MapMemory(size);
+    base = reinterpret_cast<uint8_t*>(result);
+    end = base + size;
+  }
+
+  ~PagePool() {
+    (void)munmap(base, kNumTotalPages * maple::kPageSize);
+  }
+
+  uint8_t *GetPage(size_t bytes = maple::kPageSize) {
+    int num = static_cast<int>((bytes + maple::kPageSize - 1) / maple::kPageSize);
+    int index = bitmap.MarkFirstNBits(num);
+    if (index == -1) {
+      return MapMemory(num * maple::kPageSize);
+    }
+
+    if (Bitmap::InSmallArena(num)) {
+      smallPageUsed += num;
+    }
+    uint8_t *ret = base + index * maple::kPageSize;
+    return ret;
+  }
+
+  void ReturnPage(uint8_t *page, size_t bytes = maple::kPageSize) {
+    int num = static_cast<int>((bytes + maple::kPageSize - 1) / maple::kPageSize);
+    if (page >= base && page < end) {
+      int index = static_cast<int>((page - base) / maple::kPageSize);
+      bitmap.Unmark(index, num);
+      if (Bitmap::InSmallArena(num)) {
+        smallPageUsed -= num;
+      }
+    } else {
+      (void)munmap(page, num * maple::kPageSize);
+    }
+  }
+
+  // return unused pages to os
+  void Trim() {
+    int start = static_cast<int>(smallPageUsed.load() * kCachedRatio);
+    for (int i = start; i < kNumTotalPages;) {
+      int num = bitmap.TryMarkBits(i);
+      if (num == 0) {
+        ++i;
+        continue;
+      }
+      uint8_t *addr = base + i * maple::kPageSize;
+      (void)madvise(addr, num * maple::kPageSize, MADV_DONTNEED);
+      bitmap.UnmarkBits(i, num);
+      i = i + num;
+    }
+  }
+
+  MRT_EXPORT static PagePool& Instance();
+
+ private:
+  uint8_t *MapMemory(size_t size) {
+    void *result = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (result == MAP_FAILED) {
+      LOG(FATAL) << "allocate create page failed! Out of Memory!" << maple::endl;
+    }
+    MRT_PRCTL(result, size, "PagePool");
+    return reinterpret_cast<uint8_t*>(result);
+  }
+
+  uint8_t *base;   // start address of the mapped pages
+  uint8_t *end;    // end address of the mapped pages
+  std::atomic<int> smallPageUsed = { 0 };
+  Bitmap bitmap; // record the state of the mapped memory: mapped or unmapped
+};
+} // namespace maplert
+#endif  // MAPLE_RUNTIME_ALLOCATOR_PAGE_POOL_H
diff --git a/src/mrt/compiler-rt/include/allocator/ros_alloc_run.h b/src/mrt/compiler-rt/include/allocator/ros_alloc_run.h
new file mode 100644
index 0000000000000000000000000000000000000000..6aed137b55d2325f9cb74a36d6c582a521a7f8fb
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/ros_alloc_run.h
@@ -0,0 +1,467 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ROS_ALLOC_RUN_H
+#define MAPLE_RUNTIME_ROS_ALLOC_RUN_H
+
+#include "alloc_config.h"
+#include "sizes.h"
+
+namespace maplert {
+#ifdef USE_32BIT_REF
+using SlotPtrType = uint32_t;
+#else
+using SlotPtrType = address_t;
+#endif // USE_32BIT_REF
+
+class Slot {
+ public:
+  address_t GetNext() const {
+    // possible extension
+    return static_cast<address_t>(mNext);
+  }
+  void SetNext(address_t next) {
+    // possible truncation
+    mNext = static_cast<SlotPtrType>(next);
+  }
+
+ private:
+  // This pointer occupies the first few bytes in a slot of a run;
+  // it's important that this pointer is always set (as nullptr when it is the last node)
+  // because we also use this as a flag to tell if it is allocated by us.
+  // See IsAllocatedByAllocator.
+  SlotPtrType mNext;
+};
+
+class FreeList {
+ public:
+  inline address_t GetHead() const {
+    return static_cast<address_t>(mHead);
+  }
+  inline address_t GetTail() const {
+    return static_cast<address_t>(mTail);
+  }
+
+  inline void SetHead(address_t addr) {
+    mHead = static_cast<SlotPtrType>(addr);
+  }
+  inline void SetTail(address_t addr) {
+    mTail = static_cast<SlotPtrType>(addr);
+  }
+
+  // insert a slot into the list, i.e., free a slot
+  inline void Insert(address_t addr) {
+    ROSIMPL_ASSERT(addr != 0, "cannot insert null slot into the list");
+
+    // when we don't memset at free, we can enable double free check (checks 'allocated' bit)
+#if !ROSIMPL_MEMSET_AT_FREE
+    CheckDoubleFree(ROSIMPL_GET_OBJ_FROM_ADDR(addr));
+#if CONFIG_JSAN || RC_HOT_OBJECT_DATA_COLLECT
+    // in jsan the slot is extra-padded, need to manually clear 'allocated' bit
+    ClearAllocatedBit(ROSIMPL_GET_OBJ_FROM_ADDR(addr));
+#endif
+#endif
+
+    Slot *slot = reinterpret_cast<Slot*>(addr);
+    // this normally also clears 'allocated' bit, unless we do jsan
+    slot->SetNext(mHead);
+    SetHead(addr);
+
+    if (UNLIKELY(mTail == 0)) {
+      SetTail(addr);
+    }
+  }
+
+  // fetch a slot from the list, i.e., alloc a slot
+  inline address_t Fetch() {
+    if (UNLIKELY(mHead == 0)) {
+      return 0;
+    }
+
+    address_t addr = static_cast<address_t>(mHead);
+    Slot *slot = reinterpret_cast<Slot*>(addr);
+    SetHead(slot->GetNext());
+
+    if (UNLIKELY(mHead == 0)) {
+      SetTail(0);
+    }
+    return addr;
+  }
+
+  // add the other list to the beginning of this one, and clear the other list
+  // the other list is not allowed to be empty
+  inline void Prepend(FreeList &other) {
+    ROSIMPL_ASSERT(other.GetHead() != 0, "prepending an empty list");
+    Slot *tail = reinterpret_cast<Slot*>(other.GetTail());
+    tail->SetNext(GetHead());
+    SetHead(other.GetHead());
+
+    if (mTail == 0) {
+      SetTail(other.GetTail());
+    }
+
+    other.SetHead(0);
+    other.SetTail(0);
+  }
+
+  void Init(address_t baseAddr, size_t slotSize, size_t slotCount);
+
+ private:
+  SlotPtrType mHead = 0;
+  SlotPtrType mTail = 0;
+};
+
+// Used when enumerating objects.  Only call the visitor on objects that match this criterion.
+enum class OnlyVisit : uint32_t {
+  kVisitAll,              // Visit all objects
+  kVisitFinalizable,      // Only visit objects with finalizable bit
+  kVisitLast
+};
+
+class SweepContext;
+
+#ifdef USE_32BIT_REF
+using RunListPtrType = uint32_t;
+#else
+using RunListPtrType = address_t;
+#endif // USE_32BIT_REF
+
+class RunSlots {
+ public:
+  static constexpr uint8_t kIsLocalMask  = 0x1;
+  static constexpr uint8_t kIsInListMask = 0x10;
+  static constexpr uint8_t kHasInitMask = 0x80;
+
+  // run data structure size is a very vital part in heap fragmentation
+  // we currently aim for a 64-byte run header in production mode
+  // offset +0
+  uint8_t magic;
+  uint8_t mIdx;
+  uint8_t flags;
+  uint8_t padding __attribute__ ((unused));
+  // offset +4
+  uint32_t nFree; // this number can tell us whether a run is full quickly
+  // offset +8
+  RunListPtrType mNext;             // +4
+  RunListPtrType mPrev;             // +4
+  FreeList freeList;                // +8
+  // offset +24
+  // +40; run header size 64 bytes, slots begin at offset +64
+  // put a static check/warning to see if it's actually 40
+  ALLOC_MUTEX_TYPE lock;
+  static size_t maxSlots[RunConfig::kRunConfigs];
+
+  static inline constexpr size_t GetHeaderSize() {
+    return sizeof(RunSlots);
+  }
+
+  static inline constexpr size_t GetContentOffset() {
+    return AllocUtilRndUp(GetHeaderSize(), kAllocAlign);
+  }
+
+  inline size_t GetRunSize() const {
+    return ROSIMPL_RUN_SIZE(mIdx);
+  }
+  inline size_t GetMaxSlots() const {
+    return maxSlots[mIdx];
+  };
+
+  inline RunSlots *GetNext() {
+    return reinterpret_cast<RunSlots*>(static_cast<address_t>(mNext));
+  }
+  inline RunSlots *GetPrev() {
+    return reinterpret_cast<RunSlots*>(static_cast<address_t>(mPrev));
+  }
+  inline void SetNext(const RunSlots *run) {
+    mNext = static_cast<RunListPtrType>(reinterpret_cast<address_t>(run));
+  }
+  inline void SetPrev(const RunSlots *run) {
+    mPrev = static_cast<RunListPtrType>(reinterpret_cast<address_t>(run));
+  }
+  inline float Value() const {
+    // the "value" of a run depends on its current utilization
+    return 1 - static_cast<float>(nFree) / GetMaxSlots();
+  }
+
+  inline void SetLocalFlag(bool val) {
+    flags = val ? (flags | kIsLocalMask) : (flags & ~kIsLocalMask);
+  }
+
+  inline void SetInList(bool val) {
+    flags = val ? (flags | kIsInListMask) : (flags & ~kIsInListMask);
+  }
+
+  inline void SetInit() {
+    flags |= kHasInitMask;
+  }
+
+  inline void SetInitRelease() {
+    (void)reinterpret_cast<std::atomic<uint8_t>*>(&flags)->fetch_or(kHasInitMask, std::memory_order_release);
+  }
+
+  inline bool IsLocal() const {
+    return (flags & kIsLocalMask) != 0;
+  }
+
+  inline bool IsInList() const {
+    return (flags & kIsInListMask) != 0;
+  }
+
+  inline bool HasInit() const {
+    return (flags & kHasInitMask) != 0;
+  }
+
+  inline bool HasInitAcquire() {
+    return (reinterpret_cast<std::atomic<uint8_t>*>(&flags)->load(std::memory_order_acquire) & kHasInitMask) != 0;
+  }
+
+  explicit RunSlots(uint32_t idx);
+  ~RunSlots() = default;
+  void Init(bool setInitRelease);
+
+  inline bool IsEmpty() const {
+    return (nFree == GetMaxSlots());
+  }
+  inline bool IsFull() const {
+    return (nFree == 0);
+  }
+
+  inline address_t GetBaseAddress() const {
+    return reinterpret_cast<address_t>(this) + GetContentOffset();
+  }
+
+  inline address_t AllocSlot() {
+    address_t addr = reinterpret_cast<address_t>(freeList.Fetch());
+    if (LIKELY(addr != 0)) {
+      --nFree;
+    }
+    return addr;
+  }
+  inline void FreeSlot(address_t addr) {
+    freeList.Insert(addr);
+    ++nFree;
+  }
+
+  // sweep this run page if it is not swept.
+  // return true if swept run to empty (need free)
+  bool Sweep(RosAllocImpl &allocator);
+  bool DoSweep(RosAllocImpl &allocator, SweepContext &context, size_t pageIndex);
+
+  // return true if the given address represents an allocated slot
+  bool IsLiveObjAddr(address_t objAddr) const;
+  // NOTE: when `onlyVisit` is present, `hint` is the maximum number of objects
+  // in the run that matches the criterion.  This method will return immediately
+  // after `hint` slots are visited.
+  void ForEachObj(std::function<void(address_t)> visitor,
+                  OnlyVisit onlyVisit = OnlyVisit::kVisitAll,
+                  size_t hint = numeric_limits<size_t>::max());
+};
+
+// this implements a partially sorted list, according to a node's "Value", in descending order
+// this supports these operations:
+//   Insert: insert into one of the three parts of the list, according to the "Value"
+//   Erase: erase a node from the list
+//   Fetch: fetch a node from the middle part of the list, which is considered the ideal choice
+//
+// this list is sorted based on the assumption: each node's value only slowly decreases, not incs
+//
+// with this assumption, we never need to do any log(n) or whatever time-consuming operation
+template<typename NodeType>
+class ThreeTierList {
+ public:
+  static constexpr float kFirstTierBar = 0.6;
+  static constexpr float kSecondTierBar = 0.3;
+  static constexpr bool kPreferFirstTier = false;
+
+  ThreeTierList()
+      : firstTierHead(nullptr),
+        secondTierHead(nullptr),
+        secondTierTail(nullptr),
+        thirdTierHead(nullptr) {}
+
+  ~ThreeTierList() {
+    Release();
+  }
+
+  void Release() {
+    firstTierHead = nullptr;
+    secondTierHead = nullptr;
+    secondTierTail = nullptr;
+    thirdTierHead = nullptr;
+  }
+
+  // insert a node
+  void Insert(NodeType &n) {
+    ROSIMPL_ASSERT(!n.IsInList(), "inserting node already in list");
+    if (secondTierHead == nullptr) {
+      ROSIMPL_ASSERT(firstTierHead == nullptr, "list must be empty, no first tier head");
+      ROSIMPL_ASSERT(thirdTierHead == nullptr, "list must be empty, no third tier head");
+      ROSIMPL_ASSERT(secondTierTail == nullptr, "list must be empty, no second tier tail");
+      n.SetNext(nullptr);
+      n.SetPrev(nullptr);
+      secondTierHead = &n;
+      secondTierTail = &n;
+      n.SetInList(true);
+      return;
+    }
+    if (n.Value() > kFirstTierBar) {
+      ROSIMPL_ASSERT(n.Value() <= 1, "invalid node value");
+      InsertFirst(n);
+    } else if (n.Value() > kSecondTierBar) {
+      InsertSecond(n);
+    } else {
+      ROSIMPL_ASSERT(n.Value() >= 0, "negative node value");
+      InsertThird(n);
+    }
+    n.SetInList(true);
+  }
+
+  // fetch a node, ideally from the second tier
+  NodeType *Fetch() {
+    if (secondTierHead == nullptr) {
+      ROSIMPL_ASSERT(firstTierHead == nullptr, "list must be empty, no first tier head");
+      ROSIMPL_ASSERT(thirdTierHead == nullptr, "list must be empty, no third tier head");
+      ROSIMPL_ASSERT(secondTierTail == nullptr, "list must be empty, no second tier tail");
+      return nullptr;
+    }
+
+    NodeType *n = secondTierHead;
+    EraseSecond();
+    if (n->GetNext() != nullptr) {
+      n->GetNext()->SetPrev(n->GetPrev());
+    }
+    if (n->GetPrev() != nullptr) {
+      n->GetPrev()->SetNext(n->GetNext());
+    }
+    n->SetNext(nullptr);
+    n->SetPrev(nullptr);
+    n->SetInList(false);
+    return n;
+  }
+
+  // erase a particular node from the list
+  void Erase(NodeType &n) {
+    ROSIMPL_ASSERT(n.IsInList(), "erasing node not in list");
+
+    if (&n == firstTierHead) {
+      firstTierHead = firstTierHead->GetNext();
+      if (firstTierHead != nullptr && firstTierHead == secondTierHead) {
+        firstTierHead = nullptr;
+      }
+    } else if (&n == secondTierHead) {
+      EraseSecond();
+    } else if (&n == secondTierTail) {
+      ROSIMPL_ASSERT(secondTierTail != secondTierHead, "must not be second tier head");
+      secondTierTail = secondTierTail->GetPrev();
+    } else if (&n == thirdTierHead) {
+      thirdTierHead = thirdTierHead->GetNext();
+    }
+    if (n.GetNext() != nullptr) {
+      n.GetNext()->SetPrev(n.GetPrev());
+    }
+    if (n.GetPrev() != nullptr) {
+      n.GetPrev()->SetNext(n.GetNext());
+    }
+    n.SetNext(nullptr);
+    n.SetPrev(nullptr);
+    n.SetInList(false);
+  }
+
+ private:
+  NodeType *firstTierHead;
+  NodeType *secondTierHead;
+  NodeType *secondTierTail;
+  NodeType *thirdTierHead;
+
+  inline void InsertFirst(NodeType &n) {
+    // insert into first tier
+    if (firstTierHead != nullptr) {
+      n.SetNext(firstTierHead);
+      n.SetPrev(nullptr);
+      firstTierHead->SetPrev(&n);
+      firstTierHead = &n;
+    } else {
+      n.SetNext(secondTierHead);
+      n.SetPrev(nullptr);
+      secondTierHead->SetPrev(&n);
+      firstTierHead = &n;
+    }
+  }
+
+  inline void InsertSecond(NodeType &n) {
+    // insert into second tier
+    n.SetNext(secondTierHead);
+    NodeType *prev = secondTierHead->GetPrev();
+    n.SetPrev(prev);
+    if (prev != nullptr) {
+      prev->SetNext(&n);
+    }
+    secondTierHead->SetPrev(&n);
+    secondTierHead = &n;
+  }
+
+  inline void InsertThird(NodeType &n) {
+    // insert into third tier
+    if (thirdTierHead != nullptr) {
+      n.SetNext(thirdTierHead);
+      n.SetPrev(thirdTierHead->GetPrev());
+      thirdTierHead->GetPrev()->SetNext(&n);
+      thirdTierHead->SetPrev(&n);
+      thirdTierHead = &n;
+    } else {
+      n.SetNext(nullptr);
+      n.SetPrev(secondTierTail);
+      secondTierTail->SetNext(&n);
+      thirdTierHead = &n;
+    }
+  }
+
+  // remove the first node in the second tier
+  void EraseSecond() {
+    if (secondTierHead != secondTierTail) {
+      secondTierHead = secondTierHead->GetNext();
+      return;
+    }
+    // last one in the second tier
+    NodeType *newHead = nullptr;
+    if (kPreferFirstTier == true) {
+      // move a node from first tier to second tier
+      newHead = secondTierHead->GetPrev();
+      if (newHead == firstTierHead && firstTierHead != nullptr) {
+        firstTierHead = nullptr;
+      } else if (newHead == nullptr) {
+        newHead = secondTierHead->GetNext();
+        if (newHead == thirdTierHead && thirdTierHead != nullptr) {
+          thirdTierHead = thirdTierHead->GetNext();
+        }
+      }
+    } else {
+      // move a node from third tier to second tier
+      newHead = secondTierHead->GetNext();
+      if (newHead == thirdTierHead && thirdTierHead != nullptr) {
+        thirdTierHead = thirdTierHead->GetNext();
+      } else if (newHead == nullptr) {
+        newHead = secondTierHead->GetPrev();
+        if (newHead == firstTierHead && firstTierHead != nullptr) {
+          firstTierHead = nullptr;
+        }
+      }
+    }
+    secondTierHead = newHead;
+    secondTierTail = newHead;
+  }
+};
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_ROSALLOC_RUN_H
diff --git a/src/mrt/compiler-rt/include/allocator/ros_allocator.h b/src/mrt/compiler-rt/include/allocator/ros_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..88911f02935c93f83b0c5220d007e6fc9ac6d680
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/ros_allocator.h
@@ -0,0 +1,629 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ROS_ALLOCATOR_H
+#define MAPLE_RUNTIME_ROS_ALLOCATOR_H
+
+#include <cstdint>
+#include <cstdlib>
+#include <cinttypes>
+#include <condition_variable>
+#include <unordered_set>
+#include <algorithm>
+#include <iostream>
+
+#include "allocator.h"
+#include "base/systrace.h"
+#include "space.h"
+#include "exception/mrt_exception.h"
+#include "mrt_reflection.h"
+#include "mrt_object.h"
+#include "collector/mrt_bitmap.h"
+#include "ros_alloc_run.h"
+#include "page_allocator.h"
+#include "thread_offsets.h"
+
+#if __MRT_DEBUG
+#ifndef DEBUG_CONCURRENT_SWEEP
+#define DEBUG_CONCURRENT_SWEEP (1)
+#endif
+#endif
+
+extern "C" {
+// implemented in asm, only works for size >= 8, only allow zeroing
+void ROSAllocZero(void *addr, size_t size);
+}
+
+#define ROSALLOC_MEMSET_S(addr, dstsize, c, size) \
+  do { \
+    static_assert(c == 0, "we only allow zeroing"); \
+    ROSIMPL_ASSERT(addr, "null destination"); \
+    ROSIMPL_ASSERT(dstsize >= size, "destination size too small"); \
+    ROSIMPL_ASSERT(size >= 8, "we only allow size ge 8"); \
+    ROSIMPL_ASSERT(addr % 4 == 0, "addr must be aligned to at least 4"); \
+    ROSIMPL_ASSERT(size % 4 == 0, "size must be aligned to at least 4"); \
+    ROSAllocZero(reinterpret_cast<void*>(addr), size); \
+  } while (0)
+
+namespace maplert {
+static inline void TagGCFreeObject(address_t objAddr) {
+#if MRT_DEBUG_DOUBLE_FREE
+  static constexpr uint32_t kGCFreeHeaderTag = 0xd4678763;
+  RefCountLVal(objAddr) &= ~(kWeakRcBits | kResurrectWeakRcBits | kRCBits); // trigger inc/dec from 0
+  *(reinterpret_cast<uint32_t*>(objAddr + kLockWordOffset)) = kGCFreeHeaderTag; // tag special value on lock word
+#ifdef DISABLE_RC_DUPLICATE
+  static constexpr int32_t kGCFreeContentTag = 0xff;
+  size_t objByteSize = reinterpret_cast<MObject*>(objAddr)->GetSize();
+  if (memset_s(reinterpret_cast<void*>(objAddr), objByteSize, kGCFreeContentTag, objByteSize) != EOK) {
+    LOG(FATAL) << "failed to memset at address: " << objAddr << " size: " << objByteSize << maple::endl;
+  }
+#endif
+#else
+  (void)objAddr;
+#endif
+}
+
+// sweep timeout.
+constexpr auto kSweepTimeout = std::chrono::seconds(3);
+class RosAllocImpl;
+
+class SweepContext {
+  friend class RunSlots;
+  friend class RosAllocImpl;
+
+  class ScopedAliveClosure {
+   public:
+    ScopedAliveClosure(SweepContext &context) : sweepContext(context) {
+      alive = sweepContext.TryIncRC();
+    }
+
+    ~ScopedAliveClosure() {
+      if (alive) {
+        sweepContext.DecRC();
+      }
+    }
+
+    bool Alive() const {
+      return alive;
+    }
+
+   private:
+    SweepContext &sweepContext;
+    bool alive;
+  };
+
+ public:
+  // only called in STW
+  void Init(const Allocator &allocator, const size_t endPageIndex, const PageMap &snapshot) {
+    highestPageIndex = endPageIndex;
+    oldAllocatedBytes = allocator.AllocatedMemory();
+    // alloc page map to store the snapshot of page labels
+    pageMap = reinterpret_cast<PageLabel*>(PagePool::Instance().GetPage(TotalBytesOfPageMap()));
+    refCount.store(1, std::memory_order_relaxed);
+    if (memcpy_s(pageMap, TotalBytesOfPageMap(), snapshot.GetMap(), TotalBytesOfPageMap()) != EOK) {
+      LOG(FATAL) << "memcpy error for page_map snapshot";
+    }
+    emptyRuns.store(0, std::memory_order_relaxed);
+    nonFullRuns.store(0, std::memory_order_relaxed);
+    scanedRuns.store(0, std::memory_order_relaxed);
+    sweptRuns.store(0, std::memory_order_relaxed);
+    releasedObjects.store(0, std::memory_order_relaxed);
+    releasedLargeObjects.store(0, std::memory_order_relaxed);
+    releasedBytes.store(0, std::memory_order_relaxed);
+  }
+
+  // called after concurrent sweep, may run concurrently with java thread
+  void Release() {
+    DecRC();
+    std::deque<address_t>().swap(deadNeighbours);
+  }
+
+  inline void AddDeadNeighbours(std::vector<address_t> &candidates) {
+    lock_guard<mutex> guard(contextMutex);
+    for (address_t obj : candidates) {
+      deadNeighbours.push_back(obj);
+    }
+  }
+
+  // Try to set sweeping state for the given page,
+  // when another thread is sweeping the page, wait until it finished.
+  // return true if set to sweeping success, otherwise false.
+  // when success, old_state will be the original page type.
+  bool SetSweeping(size_t pageIndex, PageLabel &oldState) {
+    ScopedAliveClosure sac(*this);
+    // check page index bound.
+    if (UNLIKELY(pageIndex >= highestPageIndex || !sac.Alive())) {
+      // page_index out of bound, we treat it as swept.
+      oldState = kPSwept;
+      return false;
+    }
+
+    // get atomic state object by page index.
+    auto &atomicState = AtomicPageState(pageIndex);
+
+    // load the old state.
+    oldState = atomicState.load(std::memory_order_acquire);
+
+    do {
+      if (oldState == kPSweeping) {
+        // another thread is sweeping the page,
+        // wait until it finished.
+        if (UNLIKELY(!WaitUntilSwept(atomicState))) {
+          LOG(FATAL) << "WaitUntilSwept() timeout!!! page_index: " << pageIndex << maple::endl;
+        }
+        return false;
+      }
+      if (oldState != kPRun && oldState != kPLargeObj) {
+        // all other states except kPRun and kPLargeObj are treat as swept.
+        oldState = kPSwept;
+        return false;
+      }
+      // try to change state from kPRun/kPLargeObj to kPSweeping,
+      // loop to try again if change state failed.
+    } while (!atomicState.compare_exchange_weak(oldState, kPSweeping,
+        std::memory_order_release, std::memory_order_acquire));
+    return true;
+  }
+
+  // atomic mark page to swept state.
+  inline void SetSwept(size_t pageIndex) {
+    ScopedAliveClosure sac(*this);
+    if (LIKELY(sac.Alive() && pageIndex < highestPageIndex)) {
+      AtomicPageState(pageIndex).store(kPSwept, std::memory_order_release);
+      contextCondVar.notify_all();
+    }
+  }
+
+ protected:
+  // input
+  size_t highestPageIndex;
+  size_t oldAllocatedBytes;
+
+  // page map snapshot. contains a pointer to an array of PageLabel
+  PageLabel *pageMap;
+  std::atomic<size_t> refCount;
+
+  std::mutex contextMutex;
+  std::condition_variable contextCondVar;
+
+  // output
+  std::deque<address_t> deadNeighbours;
+  std::atomic<size_t> emptyRuns;
+  std::atomic<size_t> nonFullRuns;
+  std::atomic<size_t> scanedRuns;
+  std::atomic<size_t> sweptRuns;
+  std::atomic<size_t> releasedObjects;
+  std::atomic<size_t> releasedLargeObjects;
+  std::atomic<size_t> releasedBytes;
+
+ private:
+  inline size_t TotalBytesOfPageMap() const {
+    return highestPageIndex * sizeof(PageLabel);
+  }
+
+  inline void ReleaseMap() {
+    PagePool::Instance().ReturnPage(reinterpret_cast<uint8_t*>(pageMap), TotalBytesOfPageMap());
+    pageMap = nullptr;
+  }
+
+  inline bool TryIncRC() noexcept {
+    size_t old = refCount.load(std::memory_order_acquire);
+    do {
+      if (old == 0) {
+        return false;
+      }
+    } while (!refCount.compare_exchange_weak(old, old + 1, std::memory_order_release, std::memory_order_acquire));
+    return true;
+  }
+
+  inline void DecRC() noexcept {
+    size_t old = refCount.load(std::memory_order_acquire);
+    while (!refCount.compare_exchange_weak(old, old - 1, std::memory_order_release, std::memory_order_acquire)) {};
+    if (old == 1) {
+      ReleaseMap();
+    }
+  }
+
+  inline std::atomic<PageLabel> &AtomicPageState(size_t pageIndex) const {
+    return reinterpret_cast<std::atomic<PageLabel>&>(*(pageMap + pageIndex));
+  }
+
+  // return false if timeout.
+  inline bool WaitUntilSwept(const std::atomic<PageLabel> &state) {
+    std::unique_lock<std::mutex> lock(contextMutex);
+    return contextCondVar.wait_for(lock, kSweepTimeout, [&state] {
+      return state.load(std::memory_order_acquire) == kPSwept;
+    });
+  }
+};
+
+// allocation can .. in order to succeed
+enum AllocEagerness {
+  kEagerLevelSoft = 0, // clear soft referents (unused, should be lv2?)
+  kEagerLevelCoalesce, // coalesce free pages (default)
+  kEagerLevelExtend, // trigger gc, revoke cache, extend
+  kEagerLevelOOM, // trigger oom gc, revoke local/cache
+  kEagerLevelMax,
+};
+
+// thread-local data structure
+template<uint32_t kLocalRuns>
+class ROSAllocMutator : public AllocMutator {
+ public:
+  static inline ROSAllocMutator *Get() {
+    return reinterpret_cast<ROSAllocMutator*>(maple::tls::GetTLS(maple::tls::kSlotAllocMutator));
+  }
+
+  ROSAllocMutator() : freeListSizes{}, freeListHeads{}, localRuns{} {}
+  ~ROSAllocMutator() = default;
+  void Init() override;
+  void Fini() override;
+  void VisitGCRoots(std::function<void(address_t)>) override {};
+
+  static constexpr uint64_t kLocalAllocActivenessThreshold = 64;
+  static int gcIndex;
+  bool throwingOOME = false;
+  bool useLocal = false;
+  int mutatorGCIndex = 0;
+  uint64_t allocActiveness = 0;
+  uint16_t freeListSizes[kLocalRuns];
+  uint32_t freeListHeads[kLocalRuns]; // a backup storage for free list heads
+  FreeList freeLists[kLocalRuns];
+  RunSlots *localRuns[kLocalRuns];
+  inline bool UseLocal(int idx);
+
+  inline void DisableLocalBeforeSweep(int idx) {
+    if (freeLists[idx].GetHead() != 0) {
+      ROSIMPL_ASSERT(freeListHeads[idx] == 0, "backup already in use");
+      std::swap(*reinterpret_cast<uint32_t*>(&(freeLists[idx])), freeListHeads[idx]);
+    }
+  }
+
+  inline void EnableLocalAfterSweep(int idx) {
+    if (freeListHeads[idx] != 0) {
+      ROSIMPL_ASSERT(freeLists[idx].GetHead() == 0, "free list already in use");
+      std::swap(freeListHeads[idx], *reinterpret_cast<uint32_t*>(&(freeLists[idx])));
+    }
+  }
+
+  // thread local allocation
+  inline address_t Alloc(int idx) {
+    address_t addr = reinterpret_cast<address_t>(freeLists[idx].Fetch());
+    if (LIKELY(addr != 0)) {
+      --freeListSizes[idx];
+    }
+    return addr;
+  }
+
+  // thread local free
+  inline void Free(int idx, address_t internalAddr) {
+    FAST_ALLOC_ACCOUNT_ADD(localRuns[idx]->GetRunSize());
+    freeLists[idx].Insert(internalAddr);
+    ++freeListSizes[idx];
+  }
+
+  // localise a free list for this mutator for thread-local operations
+  inline void Localise(int idx, FreeList &freeList, uint32_t &freeListSize) {
+    this->freeLists[idx].Prepend(freeList);
+    this->freeListSizes[idx] += freeListSize;
+    freeListSize = 0;
+  }
+
+  // localise the free list *currently left* in the run
+  // also making this run *owned* by this mutator, that is, other mutator can't alloc from it
+  inline void Localise(RunSlots &run) {
+    FAST_ALLOC_ACCOUNT_ADD(run.nFree * run.GetRunSize());
+    Localise(run.mIdx, run.freeList, run.nFree);
+
+    // this will make the run owned by the mutator
+    // alternatively, we can only localise part of the run, i.e., the current list of slots
+    // the difference is very subtle: theoretically localising whole runs yields
+    // more allocation speed; localising lists yields more memory efficiency
+    run.SetLocalFlag(true);
+    localRuns[run.mIdx] = &run;
+  }
+
+  // release the ownership of the slots in the list
+  inline void Globalise(int idx, FreeList &freeList, uint32_t &freeListSize) {
+    freeList.Prepend(this->freeLists[idx]);
+    freeListSize += this->freeListSizes[idx];
+    this->freeListSizes[idx] = 0;
+  }
+
+  // release the ownership of the run
+  inline void Globalise(RunSlots &run) {
+    if (freeListSizes[run.mIdx] != 0) {
+      FAST_ALLOC_ACCOUNT_SUB(freeListSizes[run.mIdx] * run.GetRunSize());
+      Globalise(run.mIdx, run.freeList, run.nFree);
+    }
+
+    run.SetLocalFlag(false);
+    localRuns[run.mIdx] = nullptr;
+  }
+
+  // get a local address that belongs to this mutator, this is used to compute the run address
+  inline address_t GetLocalAddress(int idx) const {
+    return reinterpret_cast<address_t>(localRuns[idx]);
+  }
+
+  inline void ResetRuns() {
+    for (size_t i = 0; i < kLocalRuns; i++) {
+      freeListSizes[i] = 0;
+      freeListHeads[i] = 0;
+      freeLists[i].SetHead(0);
+      freeLists[i].SetTail(0);
+      localRuns[i] = nullptr;
+    }
+  }
+};
+
+// initial index is -1, so mutator's index (0) will be different
+template<uint32_t kLocalRuns>
+int ROSAllocMutator<kLocalRuns>::gcIndex = -1;
+
+template class ROSAllocMutator<kROSAllocLocalRuns>;
+template class ROSAllocMutator<RunConfig::kRunConfigs>;
+
+class FreeTask;
+class ForEachTask;
+
+class RosAllocImpl : public Allocator {
+ public:
+  static const size_t kLargeObjSize = kROSAllocLargeSize;
+  static const int kNumberROSRuns = RunConfig::kRunConfigs;
+  static uint8_t kRunMagic;
+
+  RosAllocImpl();
+  ~RosAllocImpl();
+  address_t NewObj(size_t size) override;
+#if ALLOC_USE_FAST_PATH
+  // this is the thread-local allocation path.
+  // assuming:
+  //   not in jsan mode
+  //   in 32-bit mode
+  //   fast run config
+  // not supported:
+  //   HPROF/large obj accounting/alloc record/timer
+  //   debug code
+  //   HOT_OBJECT_DATA
+  //   TRACE
+  __attribute__ ((always_inline))
+  address_t FastNewObj(size_t size) {
+    size_t internalSize = size + ROSIMPL_HEADER_ALLOC_SIZE;
+    uint32_t idx = ROSIMPL_FAST_RUN_IDX(internalSize);
+    RosBasedMutator &mutator = *RosBasedMutator::Get();
+    address_t internalAddr = mutator.Alloc(idx);
+    {
+      if (LIKELY(internalAddr)) {
+        address_t addr = ROSIMPL_GET_OBJ_FROM_ADDR(internalAddr);
+#if (!ROSIMPL_MEMSET_AT_FREE)
+        // memset call is not inlined
+        ROSALLOC_MEMSET_S(addr, size, 0, size);
+#endif
+        return addr;
+      }
+    }
+    internalAddr = AllocInternal(internalSize);
+    if (UNLIKELY(internalAddr == 0)) {
+      return 0;
+    }
+    return ROSIMPL_GET_OBJ_FROM_ADDR(internalAddr);
+  }
+#endif
+  void ForEachMutator(std::function<void(AllocMutator&)> visitor);
+  void FreeObj(address_t objAddr);
+  bool ParallelFreeAllIf(MplThreadPool &threadPool, const function<bool(address_t)> &shouldFree);
+  void ForEachObjUnsafe(const function<void(address_t)> &visitor, OnlyVisit onlyVisit);
+  bool ForEachObj(const function<void(address_t)> &visitor, bool debug = false);
+  bool ParallelForEachObj(MplThreadPool &threadPool, VisitorFactory visitorFactory,
+                          OnlyVisit onlyVisit = OnlyVisit::kVisitAll);
+
+  bool ForPartialRunsObj(function<void(address_t)> visitor,
+                         const function<size_t()> &stepFunc, bool debug);
+
+  // AccurateIsValidObjAddr(Concurrent) is used to identify heap objs when using
+  // conservative stack scan, where the input addr can be a random number
+  // for fast checks (precise stack scan), we use FastIsValidObjAddr
+  bool AccurateIsValidObjAddr(address_t addr);
+  bool AccurateIsValidObjAddrConcurrent(address_t addr);
+  address_t HeapLowerBound() const;
+  address_t HeapUpperBound() const;
+  // visite GC roots in allocator, for example OOM object
+  void VisitGCRoots(const RefVisitor &visitor);
+  void Init(const VMHeapParam&) override;
+
+  // releases the empty range of pages at the end of the heap.
+  // returns true if any pages were released
+  // It grabs the global lock
+  bool ReleaseFreePages(bool aggressive = false);
+  void OutOfMemory(bool isJNI = false);
+  // This function computes the capacity by (end addr - begin addr)
+  // This doesn't reflect the actual physical memory usage
+  size_t GetCurrentSpaceCapacity() const {
+    return allocSpace.GetSize();
+  }
+  // returns the estimate value of current available bytes in the space. this is an
+  // approximate because it does not account for the space occupied by run headers
+  size_t GetCurrentFreeBytes() const {
+    // get the live bytes in the heap
+    size_t allocatedSize = AllocatedMemory();
+    // the current free bytes is equal to (current heap size - allocated size)
+    size_t heapSize = GetCurrentSpaceCapacity();
+    ROSIMPL_ASSERT(heapSize >= allocatedSize, "heap stats error");
+    return (heapSize - allocatedSize);
+  }
+  // This function sums the size of the non-released pages in the heap
+  // Only non-released pages are backed by actual physical memory
+  size_t GetActualSize() const {
+    return allocSpace.GetNonReleasedPageSize();
+  }
+
+  void GetInstances(const MClass *klass, bool includeAssignable, size_t maxCount, vector<jobject> &instances);
+
+  void ClassInstanceNum(map<string, long> &objNameCntMp);
+
+  // returns the current available page count within the reserved virtual memory
+  size_t GetAvailPages() {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+    return allocSpace.GetAvailPageCount();
+  }
+
+  // returns the approximate number of pages being used within the current
+  // reserved memory range.
+  size_t GetUsedPages() {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+    return ALLOCUTIL_PAGE_BYTE2CNT(allocSpace.GetAllocatedPageSize());
+  }
+
+  void PrintPageFragment(std::basic_ostream<char> &os, std::string tag);
+
+  size_t GetMaxCapacity() const {
+    return allocSpace.GetMaxCapacity();
+  }
+
+  // HasAddress/FastIsValidObjAddr is a range-based check, used to quickly identify heap objs,
+  // assuming non-heap objs never fall into the same address range
+  // for a more accurate check, use AccurateIsValidObjAddr(Concurrent)
+  inline bool HasAddress(address_t addr) const {
+    return HeapStats::IsHeapAddr(addr);
+  }
+  inline bool FastIsValidObjAddr(address_t addr) {
+    return ((addr & (kAllocAlign - 1)) == 0) && allocSpace.HasAddress(addr);
+  }
+
+  // Parepare data for concurrent sweep and create SweepContext.
+  // call this when the world stopped.
+  void PrepareConcurrentSweep();
+
+  // Concurrent sweep heap pages.
+  // if thread_pool not null, do it parallel.
+  // DO Not trim heap when this function is running.
+  void ConcurrentSweep(MplThreadPool *threadPool);
+
+#if ALLOC_ENABLE_LOCK_CONTENTION_STATS
+  // because some runs are deleted, we need to record the
+  // contention stats of the page locks in the deleted runs
+  static uint32_t pageLockContentionRec;
+  static uint64_t pageLockWaitTimeRec;
+#endif
+  inline void DumpContention(std::basic_ostream<char> &os) const {
+    // no longer supported
+    (void)os;
+  }
+
+  void OnFinalizableObjCreated(address_t addr);
+  void OnFinalizableObjResurrected(address_t addr);
+  void Debug_DumpFinalizableInfo(ostream& ost);
+  void OnPreFork();
+
+  friend RosBasedMutator;
+  friend FreeTask;
+  friend ForEachTask;
+  friend RunSlots;
+ private:
+  PageMap pageMap;
+  // The instance space associated with the allocator
+  Space allocSpace;
+  ALLOC_MUTEX_TYPE runLocks[kNumberROSRuns];
+  ALLOC_MUTEX_TYPE globalMutatorLocks[kNumberROSRuns];
+  ThreeTierList<RunSlots> nonFullRuns[kNumberROSRuns];
+  unordered_set<RosBasedMutator*, std::hash<RosBasedMutator*>,
+                std::equal_to<RosBasedMutator*>,
+                StdContainerAllocator<RosBasedMutator*, kROSAllocator>> allocatorMutators;
+  static ROSAllocMutator<RunConfig::kRunConfigs> globalMutator;
+
+  // context data for concurrent sweep.
+  SweepContext sweepContext;
+  // this indicates if we have performed fork on mygote
+  bool hasForked = false;
+
+  inline bool IsMygotePageAlloc(address_t addr) {
+    return hasForked && addr != 0 && pageMap.IsMygotePageAddr(addr);
+  }
+
+  inline bool IsConcurrentSweepRunning() const {
+    return FastAllocData::data.isConcurrentSweeping.load(std::memory_order_relaxed);
+  }
+
+  inline void SetConcurrentSweepRunning(bool running) {
+    FastAllocData::data.isConcurrentSweeping.store(running, std::memory_order_relaxed);
+  }
+
+  inline bool IsConcurrentMarkRunning() const {
+    return FastAllocData::data.isConcurrentMarking;
+  }
+
+  // inline functions that are used within the allocator (not exposed)
+  static inline void CheckRunMagic(RunSlots &run);
+  static inline uint32_t GetRunIdx(size_t size);
+  static inline uint32_t GetPagesPerRun(int index);
+  static inline size_t GetRunSize(int index);
+  inline address_t GetSpaceEnd() const;
+  inline size_t GetEndPageIndex() const;
+  inline address_t AllocRun(int idx, int eagerness);
+  inline RunSlots *FetchRunFromNonFulls(int idx);
+  inline RunSlots *FetchOrAllocRun(int idx, int eagerness);
+  enum LocalAllocResult {
+    kLocalAllocSucceeded = 0,
+    kLocalAllocFailed,
+    kLocalAllocDismissed
+  };
+  template<uint32_t kLocalRuns>
+  __attribute__ ((always_inline))
+  std::pair<RosAllocImpl::LocalAllocResult, address_t>
+  AllocFromLocalRun(ROSAllocMutator<kLocalRuns> &mutator, int idx, int eagerness);
+  inline address_t AllocFromGlobalRun(RosBasedMutator &mutator, int idx, int eagerness);
+  inline address_t AllocFromRun(RosBasedMutator &mutator, size_t &internalSize, int eagerness);
+  inline void RevokeLocalRun(RosBasedMutator &mutator, RunSlots &run);
+  inline size_t FreeFromRun(RosBasedMutator &mutator, RunSlots &run, address_t internalAddr);
+  inline bool UpdateGlobalsAfterFree(RunSlots &run, bool wasFull);
+  inline void SweepSlot(RunSlots &run, address_t slotAddr);
+  inline void SweepLocalRun(RunSlots &run, std::function<bool(address_t)> shouldFree);
+  inline void SweepRun(RunSlots &run, std::function<bool(address_t)> shouldFree);
+  // tries to allocate an object given the size
+  __attribute__ ((always_inline))
+  address_t AllocInternal(size_t &allocSize);
+  // returns the number of bytes freed including overhead.
+  inline size_t FreeInternal(address_t objAddr);
+  inline void AddAllocMutator(RosBasedMutator &mutator);
+  inline void RemoveAllocMutator(RosBasedMutator &mutator);
+  inline void ForEachObjInRunUnsafe(RunSlots &run,
+                                    std::function<void(address_t)> visitor,
+                                    OnlyVisit onlyVisit = OnlyVisit::kVisitAll,
+                                    size_t numHint = numeric_limits<size_t>::max()) const;
+  inline bool AccurateIsValidObjAddrUnsafe(address_t addr);
+
+  address_t AllocPagesInternal(size_t reqSize, size_t &actualSize, int forceLevel);
+  address_t AllocLargeObject(size_t &allocSize, int forceLevel);
+  void SweepLargeObj(address_t objAddr);
+  void FreeLargeObj(address_t objAddr, size_t &internalSize, bool delayFree = false);
+  bool SweepPage(size_t, size_t&);
+  void SweepPages(size_t, size_t);
+  void RecordFragment();
+
+  // Handle the case when we fail to allocate. force level will pass the context of the
+  // situation, this will allow to change the aggressiveness of the memory allocation
+  void HandleAllocFailure(size_t allocSize, int &forceLevel);
+  void DumpStackBeforeOOM(size_t allocSize);
+  void GetMemoryInfoBeforeOOM(size_t allocSize, size_t newLargestChunk);
+  void FreeRun(RunSlots &run, bool delayFree = false);
+
+  void ForEachObjInRun(RunSlots &runSlots,
+                       std::function<void(address_t)> visitor,
+                       OnlyVisit onlyVisit = OnlyVisit::kVisitAll,
+                       size_t numHint = numeric_limits<size_t>::max()) const;
+  void RevokeLocalRuns(RosBasedMutator &mutator);
+}; // class RosAllocImpl
+} // namespace maplert
+#endif // MAPLE_RUNTIME_ROSALLOCATOR_H
diff --git a/src/mrt/compiler-rt/include/allocator/ros_allocator_inlined.h b/src/mrt/compiler-rt/include/allocator/ros_allocator_inlined.h
new file mode 100644
index 0000000000000000000000000000000000000000..35ee5382e0be81a0541d0146c80f9f4cbafe4739
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/ros_allocator_inlined.h
@@ -0,0 +1,490 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ROS_ALLOCATOR_INLINED_H
+#define MAPLE_RUNTIME_ROS_ALLOCATOR_INLINED_H
+
+#include "ros_allocator.h"
+
+namespace maplert {
+inline void RosAllocImpl::CheckRunMagic(RunSlots &ROSIMPL_DUNUSED(run)) {
+  ROSIMPL_ASSERT(run.magic == kRunMagic, "invalid run");
+}
+
+inline uint32_t RosAllocImpl::GetRunIdx(size_t size) {
+  ROSIMPL_ASSERT(size <= kLargeObjSize, "large size doesn't have an idx");
+  return ROSIMPL_RUN_IDX(size);
+}
+
+inline uint32_t RosAllocImpl::GetPagesPerRun(int index) {
+  ROSIMPL_ASSERT(index >= 0 && index < kNumberROSRuns, "index out of bound");
+  return ROSIMPL_N_PAGES_PER_RUN(index);
+}
+
+inline size_t RosAllocImpl::GetRunSize(int index) {
+  ROSIMPL_ASSERT(index >= 0 && index < kNumberROSRuns, "index out of bound");
+  return ROSIMPL_RUN_SIZE(index);
+}
+
+inline address_t RosAllocImpl::GetSpaceEnd() const {
+  return reinterpret_cast<address_t>(allocSpace.GetEnd());
+}
+
+inline size_t RosAllocImpl::GetEndPageIndex() const {
+  return pageMap.GetPageIndex(GetSpaceEnd());
+}
+
+inline address_t RosAllocImpl::AllocRun(int idx, int eagerness) {
+  size_t pageCount = GetPagesPerRun(idx);
+  size_t size = ALLOCUTIL_PAGE_CNT2BYTE(pageCount);
+  size_t internalSize = 0;
+  address_t pageAddr = AllocPagesInternal(size, internalSize, eagerness);
+  if (UNLIKELY(pageAddr == 0)) {
+    return 0U;
+  }
+  ROSIMPL_ASSERT(internalSize == size, "page alloc for run error");
+  size_t converted = pageMap.SetAsRunPage(pageAddr, pageCount);
+  allocSpace.RecordReleasedToNonReleased(converted);
+  return pageAddr;
+}
+
+inline RunSlots *RosAllocImpl::FetchRunFromNonFulls(int idx) {
+  return nonFullRuns[idx].Fetch();
+}
+
+inline RunSlots *RosAllocImpl::FetchOrAllocRun(int idx, int eagerness) {
+  RunSlots *run = nullptr;
+  {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD runLocks[idx]);
+    run = FetchRunFromNonFulls(idx);
+  }
+  ROSIMPL_ASSERT(!IsMygotePageAlloc(reinterpret_cast<address_t>(run)), "do not allocate in mygote page");
+  if (UNLIKELY(run == nullptr)) {
+    address_t runAddr = 0;
+    {
+      ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+      runAddr = AllocRun(idx, eagerness);
+    }
+    if (LIKELY(runAddr != 0)) {
+      ROSIMPL_ASSERT(!reinterpret_cast<RunSlots*>(runAddr)->HasInit(), "dirty page for run");
+      // we new run out of lock, in order to prevent page faults holding the lock for too long
+      // a problem is that unsafe heap scan (e.g., concurrent gc) will scan unintialised runs
+      // we use the init bit in each run to tell whether the run is ready for scan
+      run = new (reinterpret_cast<void*>(runAddr)) RunSlots(idx);
+      run->Init(IsConcurrentMarkRunning());
+    }
+  }
+  return run;
+}
+
+template<uint32_t kLocalRuns>
+__attribute__ ((always_inline))
+std::pair<RosAllocImpl::LocalAllocResult, address_t> RosAllocImpl::AllocFromLocalRun(
+    ROSAllocMutator<kLocalRuns> &mutator, int idx, int eagerness) {
+  ROSIMPL_ASSERT(static_cast<uint32_t>(idx) < kLocalRuns, "idx >= number of local runs");
+  address_t localAddress = mutator.GetLocalAddress(idx);
+  ROSIMPL_ASSERT(!IsMygotePageAlloc(localAddress), "do not allocate in mygote page");
+  // sweep run before we do anything
+  if (UNLIKELY(IsConcurrentSweepRunning())) {
+    if (LIKELY(localAddress)) {
+      RunSlots &run = *(reinterpret_cast<RunSlots*>(localAddress));
+      bool ROSIMPL_DUNUSED(needRemove) = run.Sweep(*this);
+      ROSIMPL_ASSERT(needRemove == false, "mutator run swept to empty");
+    }
+  }
+
+  // this put a toll on regular allocation, remove when not using concurrent sweep
+  mutator.EnableLocalAfterSweep(idx);
+
+  // try to allocate from the mutator's local run
+  address_t addr = 0;
+  if (LIKELY(localAddress)) {
+    // try lockless path first
+    addr = mutator.Alloc(idx);
+    if (LIKELY(addr)) {
+      return std::make_pair(kLocalAllocSucceeded, addr);
+    } else {
+      // this is the locked path, means mutator's local list is used up, need more
+      RunSlots &run = *reinterpret_cast<RunSlots*>(localAddress);
+      ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD run.lock);
+      if (UNLIKELY(run.IsFull())) {
+        mutator.Globalise(run);
+      } else {
+        mutator.Localise(run);
+        addr = mutator.Alloc(idx);
+        ROSIMPL_ASSERT(addr != 0, "unable to alloc from local list");
+        return std::make_pair(kLocalAllocSucceeded, addr);
+      }
+    }
+  }
+
+  // if we have used up the local run (we could dismiss local alloc, unimplemented)
+  RunSlots *localRun = nullptr;
+  localRun = FetchOrAllocRun(idx, eagerness);
+  if ((UNLIKELY(localRun == nullptr))) {
+    return std::make_pair(kLocalAllocFailed, 0);
+  } else {
+    if (UNLIKELY(IsConcurrentSweepRunning())) {
+      // doesn't matter if it's swept to empty
+      static_cast<void>(localRun->Sweep(*this));
+    }
+    ALLOC_LOCK_TYPE pageLock(ALLOC_CURRENT_THREAD localRun->lock);
+    // we can potentially localise multiple runs
+    mutator.Localise(*localRun);
+  }
+
+  addr = mutator.Alloc(idx);
+  ROSIMPL_ASSERT(addr, "mutator unable to alloc");
+  return std::make_pair(kLocalAllocSucceeded, addr);
+}
+
+inline address_t RosAllocImpl::AllocFromGlobalRun(RosBasedMutator &mutator, int idx, int eagerness) {
+  static_cast<void>(mutator);
+  ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalMutatorLocks[idx]);
+  auto allocRes = AllocFromLocalRun<RunConfig::kRunConfigs>(globalMutator, idx, eagerness);
+  return allocRes.second;
+}
+
+template<uint32_t kLocalRuns>
+inline bool ROSAllocMutator<kLocalRuns>::UseLocal(int idx) {
+  if (UNLIKELY(!ROSIMPL_IS_LOCAL_RUN_IDX(idx))) {
+    return false;
+  }
+  if (LIKELY(useLocal)) {
+    return true;
+  }
+  if (UNLIKELY(mutatorGCIndex != gcIndex)) {
+    mutatorGCIndex = gcIndex;
+    allocActiveness = 0;
+  }
+  if (UNLIKELY(++allocActiveness > kLocalAllocActivenessThreshold)) {
+    useLocal = true;
+    return true;
+  }
+  return false;
+}
+
+// return internal addr
+inline address_t RosAllocImpl::AllocFromRun(RosBasedMutator &mutator, size_t &internalSize, int eagerness) {
+  int idx = static_cast<int>(GetRunIdx(internalSize));
+  internalSize = GetRunSize(idx);
+  // if the mutator already has a local run, or it is eligible for one, we use local alloc
+  if (LIKELY(ROSIMPL_IS_LOCAL_RUN_IDX(idx) &&
+             (mutator.GetLocalAddress(idx) != 0 || mutator.UseLocal(idx)))) {
+    auto allocRes = AllocFromLocalRun<kROSAllocLocalRuns>(mutator, idx, eagerness);
+    if (LIKELY(allocRes.first != kLocalAllocDismissed)) {
+      return allocRes.second;
+    }
+  }
+  size_t internalAddr = AllocFromGlobalRun(mutator, idx, eagerness);
+  return internalAddr;
+}
+
+inline void RosAllocImpl::RevokeLocalRun(RosBasedMutator &mutator, RunSlots &run) {
+  int idx = run.mIdx;
+  bool needRemove = false;
+  {
+    ALLOC_LOCK_TYPE pageLock(ALLOC_CURRENT_THREAD run.lock);
+    mutator.Globalise(run);
+    if (run.IsEmpty() && !Collector::Instance().IsConcurrentMarkRunning()) {
+      // concurrent marking relies on run data structure, don't free
+      needRemove = true;
+    } else {
+      if (LIKELY(!run.IsFull())) {
+        ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD runLocks[idx]);
+        nonFullRuns[idx].Insert(run);
+      }
+    }
+  }
+  if (needRemove) {
+    FreeRun(run);
+  }
+}
+
+// return internal size
+inline size_t RosAllocImpl::FreeFromRun(RosBasedMutator &mutator, RunSlots &run, address_t internalAddr) {
+  if (UNLIKELY(IsConcurrentSweepRunning())) {
+    bool ROSIMPL_DUNUSED(needRemove) = run.Sweep(*this);
+    ROSIMPL_ASSERT(!needRemove, "need remove before free");
+  }
+
+  size_t internalSize = run.GetRunSize();
+  ROSIMPL_ASSERT(!run.IsEmpty(), "free from an empty run");
+
+  // free to local list if possible, i.e., this obj resides in this mutator's local run
+  int idx = static_cast<int>(GetRunIdx(internalSize));
+  if (LIKELY(ROSIMPL_IS_LOCAL_RUN_IDX(idx) && mutator.useLocal)) {
+    address_t localAddress = mutator.GetLocalAddress(idx);
+    if (&run == reinterpret_cast<RunSlots*>(localAddress)) {
+      mutator.EnableLocalAfterSweep(idx);
+      mutator.Free(idx, internalAddr);
+      return internalSize;
+    }
+  }
+
+  // must free to global run
+  bool needRemove = false;
+  {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD run.lock);
+    bool wasFull = run.IsFull();
+    run.FreeSlot(internalAddr);
+    needRemove = UpdateGlobalsAfterFree(run, wasFull);
+  }
+  if (UNLIKELY(needRemove)) {
+    ROSIMPL_ASSERT(run.IsEmpty(), "free a non-empty run");
+    FreeRun(run);
+  }
+  return internalSize;
+}
+
+inline bool RosAllocImpl::UpdateGlobalsAfterFree(RunSlots &run, bool wasFull) {
+  // local runs must be globalised before they are passed in here
+  if (LIKELY(run.IsLocal())) {
+    return false;
+  }
+  int idx = run.mIdx;
+  bool needRemove = false;
+  if (UNLIKELY(run.IsEmpty())) {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD runLocks[idx]);
+    bool wasInNonFullRuns = false;
+    if (run.IsInList()) {
+      wasInNonFullRuns = true;
+      nonFullRuns[idx].Erase(run);
+    }
+    if (wasInNonFullRuns || wasFull) {
+      // this cond makes sure it's not fetched by a mutator in AllocFrom(Local/Global)Run
+      needRemove = true;
+    }
+  } else if (wasFull && !run.IsFull()) {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD runLocks[idx]);
+    ROSIMPL_ASSERT(!run.IsInList(), "full run in nfrs");
+    nonFullRuns[idx].Insert(run);
+  }
+  return needRemove;
+}
+
+// must be called in critical section, either in STW or holding lock
+inline void RosAllocImpl::SweepSlot(RunSlots &run, address_t slotAddr) {
+  address_t objAddr = ROSIMPL_GET_OBJ_FROM_ADDR(slotAddr);
+  maplert::Allocator::ReleaseResource(objAddr);
+#if ALLOC_USE_FAST_PATH
+  size_t objSize = PreObjFree<true>(objAddr);
+#else
+  size_t objSize = PreObjFree(objAddr);
+#endif
+  size_t slotSize = run.GetRunSize();
+#if ROSIMPL_MEMSET_AT_FREE
+  CheckDoubleFree(objAddr);
+  // ensure header is cleared in 8 bytes, this is needed by dec from 0 check in backup tracing
+  ROSALLOC_MEMSET_S(slotAddr, slotSize, 0, slotSize);
+#else
+  TagGCFreeObject(objAddr);
+#endif
+  run.FreeSlot(slotAddr);
+#if ALLOC_USE_FAST_PATH
+  PostObjFree<true>(objAddr, objSize, slotSize);
+#else
+  PostObjFree(objAddr, objSize, slotSize);
+#endif
+}
+
+// Only invoked at STW
+// Iterate all slots in run, if it should be freed, perform free operation without lock
+//
+// If JSAN is on, don't invoke this method, this is handled in MarkSweepCollector::Sweep
+inline void RosAllocImpl::SweepLocalRun(RunSlots &run, std::function<bool(address_t)> shouldFree) {
+  if (run.IsEmpty()) {
+    return;
+  }
+  size_t slotSize = run.GetRunSize();
+  size_t slotCount = run.GetMaxSlots();
+  address_t slotAddr = run.GetBaseAddress();
+  size_t releasedBytes = 0;
+
+  for (size_t idx = 0; idx < slotCount; ++idx) {
+    address_t objAddr = ROSIMPL_GET_OBJ_FROM_ADDR(slotAddr);
+    if (IsAllocatedByAllocator(objAddr) && shouldFree(objAddr)) {
+      SweepSlot(run, slotAddr);
+      releasedBytes += slotSize;
+    }
+    slotAddr += slotSize;
+  }
+  FAST_ALLOC_ACCOUNT_SUB(releasedBytes);
+}
+
+// Only invoked at STW
+// Itreate all slots in run, if it should be freed, perform free operation without lock
+//
+// If JSAN is on, don't invoke this method, this is handled in MarkSweepCollector::Sweep
+inline void RosAllocImpl::SweepRun(RunSlots &run, std::function<bool(address_t)> shouldFree) {
+  if (run.IsEmpty()) {
+    // this is most likely cache, but sometimes free runs can be left in nfrs
+    return;
+  }
+
+  size_t slotSize = run.GetRunSize();
+  size_t slotCount = run.GetMaxSlots();
+  address_t slotAddr = run.GetBaseAddress();
+  size_t releasedBytes = 0;
+  bool wasFull = run.IsFull();
+  bool found = false;
+  for (size_t i = 0; i < slotCount; ++i) {
+    address_t objAddr = ROSIMPL_GET_OBJ_FROM_ADDR(slotAddr);
+    if (IsAllocatedByAllocator(objAddr) && shouldFree(objAddr)) {
+      SweepSlot(run, slotAddr);
+      releasedBytes += slotSize;
+      found = true;
+    }
+    slotAddr += slotSize;
+  }
+  FAST_ALLOC_ACCOUNT_SUB(releasedBytes);
+  if (found) {
+    if (UpdateGlobalsAfterFree(run, wasFull)) {
+      FreeRun(run);
+    }
+  }
+}
+
+__attribute__ ((always_inline)) address_t RosAllocImpl::AllocInternal(size_t &allocSize) {
+  RosBasedMutator &mutator = static_cast<RosBasedMutator&>(TLAllocMutator());
+  bool allocSuccess = false;
+  int eagerness = kEagerLevelCoalesce;
+  address_t internalAddr = 0U;
+  do {
+    if (UNLIKELY(allocSize > kLargeObjSize)) {
+      ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+      internalAddr = AllocLargeObject(allocSize, eagerness);
+    } else {
+      internalAddr = AllocFromRun(mutator, allocSize, eagerness);
+    }
+    allocSuccess = (internalAddr != 0U);
+    if (UNLIKELY(!allocSuccess)) {
+      if (eagerness >= kEagerLevelMax) {
+        size_t largestChunkSize = 0;
+        {
+          ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+          largestChunkSize = allocSpace.GetLargestChunkSize();
+        }
+        DumpStackBeforeOOM(allocSize);
+        GetMemoryInfoBeforeOOM(allocSize, largestChunkSize);
+        break;
+      }
+      HandleAllocFailure(allocSize, eagerness);
+#if (!ROSIMPL_MEMSET_AT_FREE)
+    } else {
+      size_t sizeMinusHeader = allocSize - ROSIMPL_HEADER_ALLOC_SIZE;
+      address_t objAddr = ROSIMPL_GET_OBJ_FROM_ADDR(internalAddr);
+      ROSALLOC_MEMSET_S(objAddr, sizeMinusHeader, 0, sizeMinusHeader);
+#endif
+    }
+  } while (!allocSuccess);
+  return internalAddr;
+}
+
+inline size_t RosAllocImpl::FreeInternal(address_t objAddr) {
+  ROSIMPL_ASSERT(pageMap.ContainsAddr(objAddr), "free objAddr out of range");
+
+  size_t internalSize = 0U;
+  address_t pageAddr = 0U;
+  PageLabel pageType = pageMap.GetTypeForAddr(objAddr);
+  RunSlots *run = nullptr;
+  if (LIKELY(pageType == kPRun)) {
+    pageAddr = ALLOCUTIL_PAGE_ADDR(objAddr);
+    run = reinterpret_cast<RunSlots*>(pageAddr);
+  } else if(LIKELY(pageType == kPLargeObj)) {
+    if (UNLIKELY(IsConcurrentSweepRunning())) {
+      // ensure large object page is swept before free.
+      SweepLargeObj(objAddr);
+    }
+    FreeLargeObj(objAddr, internalSize);
+    return internalSize;
+  } else if (pageType == kPRunRem) {
+    pageAddr = pageMap.GetRunStartFromAddr(objAddr);
+    run = reinterpret_cast<RunSlots*>(pageAddr);
+  } else if (LIKELY(pageType == kPMygoteRun || pageType == kPMygoteRunRem || pageType == kPMygoteLargeObj)) {
+    // never free anything in mygote pages
+    return 0U;
+  } else {
+    LOG(ERROR) << "invalid object address inside FreeInternal. Address: " <<
+        objAddr << " type: " << static_cast<int>(pageType) << maple::endl;
+    return 0U;
+  }
+
+  ROSIMPL_ASSERT(run != nullptr, "run cannot be null");
+  ROSIMPL_DEBUG(CheckRunMagic(*run));
+
+  address_t memAddr = ROSIMPL_GET_ADDR_FROM_OBJ(objAddr);
+  CheckDoubleFree(objAddr);
+#if ROSIMPL_MEMSET_AT_FREE
+  internalSize = run->GetRunSize();
+  ROSALLOC_MEMSET_S(memAddr, internalSize, 0, internalSize);
+#endif
+  RosBasedMutator &mutator = reinterpret_cast<RosBasedMutator&>(TLAllocMutator());
+  return FreeFromRun(mutator, *run, memAddr);
+}
+
+inline void RosAllocImpl::AddAllocMutator(RosBasedMutator &mutator) {
+  {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+    (void)allocatorMutators.insert(&mutator);
+  }
+}
+
+inline void RosAllocImpl::RemoveAllocMutator(RosBasedMutator &mutator) {
+  RevokeLocalRuns(mutator);
+  {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+    (void)allocatorMutators.erase(&mutator);
+    PostMutatorFini(mutator);
+  }
+}
+
+inline void RosAllocImpl::ForEachObjInRunUnsafe(
+    RunSlots &run, std::function<void(address_t)> visitor, OnlyVisit onlyVisit, size_t numHint) const {
+  if (!run.HasInitAcquire() || run.IsEmpty()) {
+    return;
+  }
+  run.ForEachObj(visitor, onlyVisit, numHint);
+}
+
+inline bool RosAllocImpl::AccurateIsValidObjAddrUnsafe(address_t addr) {
+  RunSlots *run = nullptr;
+  address_t pageAddr = ALLOCUTIL_PAGE_ADDR(addr);
+  PageLabel pageType = pageMap.GetTypeForAddr(addr);
+  if (LIKELY(pageType == kPRun || pageType == kPMygoteRun)) {
+    run = reinterpret_cast<RunSlots*>(pageAddr);
+  } else if (pageType == kPRunRem || pageType == kPMygoteRunRem) {
+    pageAddr = pageMap.GetRunStartFromAddr(addr);
+    run = reinterpret_cast<RunSlots*>(pageAddr);
+  } else if (pageType == kPLargeObj || pageType == kPMygoteLargeObj) {
+    if (pageAddr == ROSIMPL_GET_ADDR_FROM_OBJ(addr)) {
+      return IsAllocatedByAllocator(addr);
+    }
+    return false;
+  } else {
+    return false;
+  }
+
+  if (!run->HasInitAcquire()) {
+    return false;
+  }
+  // run obj
+  ROSIMPL_DEBUG(CheckRunMagic(*run));
+  if (LIKELY(run != nullptr)) {
+    return run->IsLiveObjAddr(addr);
+  }
+  return false;
+}
+} // namespace maplert
+#endif // MAPLE_RUNTIME_ROSALLOCATOR_INLINED_H
\ No newline at end of file
diff --git a/src/mrt/compiler-rt/include/allocator/space.h b/src/mrt/compiler-rt/include/allocator/space.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ae26bc9c88fb9d36517bb116f44e640726e7a2a
--- /dev/null
+++ b/src/mrt/compiler-rt/include/allocator/space.h
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_SPACE_H
+#define MAPLE_RUNTIME_SPACE_H
+
+#include <cstdint>
+#include <atomic>
+#include <memory>
+#include <sys/mman.h>
+#include "page_map.h"
+#include "address.h"
+#include "panic.h"
+#include "utils/time_utils.h"
+#include "alloc_config.h"
+#include "mem_map.h"
+#include "cartesian_tree.h"
+
+namespace maplert {
+class Space;
+class SpacePageManager {
+ public:
+  SpacePageManager(Space &allocSpaceVal, uintptr_t begin) : allocSpace(allocSpaceVal), baseAddress(begin) {}
+  ~SpacePageManager() = default;
+  void SetBaseAddress(uintptr_t baseAddr) {
+    baseAddress = baseAddr;
+  }
+
+  // given size in bytes we return the size normalized to pages (4k)
+  uint32_t CalcChunkSize(size_t regionSize) const;
+
+  // given index of a region, calculate the page address
+  uintptr_t GetRegAddrFromIdx(uint32_t idx) const;
+
+  // given the first page and the size of memory region in bytes, we add
+  // it to the set of free chunks
+  void AddRegion(uintptr_t regionAddr, size_t regionSize);
+  // add contiguous pages of count page_count starting with first_page
+  void AddPages(uintptr_t firstPage, uint32_t pageCount);
+
+  // release all free pages back to the system
+  void ReleaseAllFreePages(size_t freeBytes, const MemMap &memMap, bool isAggressive);
+
+  // Given a request size, we split the first chunk and return the
+  // address to the first page
+  uintptr_t GetChunk(size_t reqSize);
+
+  uint32_t CalcPageIdx(uintptr_t pageAddr) const;
+
+  size_t GetLargestChunkSize();
+ private:
+  friend Space;
+  using TreeType = CartesianTree<uint32_t, uint32_t>;
+  Space &allocSpace;
+  uintptr_t baseAddress;
+  TreeType pageCTree;
+}; // end of SpacePageManager
+
+class Space {
+ public:
+  // These parameters can be set via static methods Space::SetXXX().
+  // Currently they are called before Space::Init(). They take
+  // the values from the configuration of the virtual machine.
+  // Default configuration (please check the corresponding .prop files to confirm):
+  // kReleasePageAtFree/kReleasePageAtTrim: set in alloc_config.h
+  // heap start size: 8m
+  // heap size: 512m
+  // heap growth limit: 384m
+  // heap min free: 2m
+  // heap max free: 8m
+  // heap target utilization: 0.75
+  // ignore max footprint: see runtime.cc
+  //
+  // they are not constant..
+  // whether to release pages immediately after we free them
+  static bool kReleasePageAtFree;
+  // whether to release free pages all together at a separate phase we call "trim"
+  static bool kReleasePageAtTrim;
+  // the initial size of the heap
+  static size_t kHeapStartSize;
+  // the maximum heap size
+  static size_t kHeapSize;
+  // the default heap size
+  // In ART, kHeapGrowthLimit is used as the heap size for all processes,
+  // UNLESS the manifest file set the largeHeap property to true,
+  // in which case the heap size is kHeapSize.
+  // In our Maple, we ignore this and use the kHeapSize directly (for now),
+  // see RosAllocImpl::Init()
+  static size_t kHeapGrowthLimit;
+  // the minimum size of free pages, unused
+  static size_t kHeapMinFree;
+  // the maximum size of free pages, used to trigger trim
+  static size_t kHeapMaxFree;
+  // the following is unused
+  // target utilization rate of the heap
+  static float kHeapTargetUtilization;
+  // unused
+  static bool kIgnoreMaxFootprint;
+  // 1s interval for trim, to prevent impeding performance
+  static const uint64_t kMinTrimInterval = 1000; // ms
+  // non-aggressive trim max time
+  static const uint64_t kMaxTrimTime = 10000; // us
+
+  // this controls how many free pages we don't release (return to the os)
+  static inline size_t TargetFreePageSize() {
+    return Space::kHeapMaxFree >> 1;
+  }
+
+  static inline void SetHeapStartSize(size_t heapStartSize) {
+    Space::kHeapStartSize = heapStartSize;
+  }
+  static inline void SetHeapSize(size_t heapSize) {
+    Space::kHeapSize = heapSize;
+  }
+  static inline void SetHeapGrowthLimit(size_t heapGrowthLimit) {
+    Space::kHeapGrowthLimit = heapGrowthLimit;
+  }
+  static inline void SetHeapMinFree(size_t heapMinFree) {
+    Space::kHeapMinFree = heapMinFree;
+  }
+  static inline void SetHeapMaxFree(size_t heapMaxFree) {
+    Space::kHeapMaxFree = heapMaxFree;
+  }
+  static inline void SetHeapTargetUtilization(float heapTargetUtilization) {
+    Space::kHeapTargetUtilization = heapTargetUtilization;
+  }
+  static inline void SetIgnoreMaxFootprint(bool ignoreMaxFootprint) {
+    Space::kIgnoreMaxFootprint = ignoreMaxFootprint;
+  }
+
+ public:
+  string name; // full name of the space
+  string tag; // tag to identify the memory region in smaps
+  bool isManaged; // whether the space is under the management of RC/GC
+  // maximum memory allowed for the space
+  size_t maxCapacity;
+  // mem map is a wrapper of system calls like mmap(), madvise(), mprotect()
+  MemMap *memMap;
+  // page map labels each page with a type, e.g., run type, large obj type
+  PageMap &pageMap;
+  // The beginning of the storage for fast access.
+  uint8_t *begin;
+  // current end of the space.
+  atomic<uint8_t*> end;
+  // we do out-of-lock reads to the following fields for gc trigger heuristics
+  // as long as this fields are aligned, we don't have to worry about atomicity problems
+  // total size of pages allocated
+  size_t allocatedPageSize;
+  // total size of pages fetched from the kernel
+  // 'release' is the action of returning physical memory pages back to the kernel
+  // if a page is 'non-released', it means we still occupy the corresponding physical memory
+  size_t nonReleasedPageSize;
+
+  friend class SpacePageManager;
+  // the page manager manages all of the free pages (including released pages)
+  SpacePageManager pageManager;
+
+  // records the last time we trimed
+  uint64_t lastTrimTime;
+  inline bool IsTrimAllowedAtTheMoment() {
+    uint64_t currTime = timeutils::MilliSeconds();
+    if (currTime - lastTrimTime < kMinTrimInterval) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+ public:
+  static const int kPagesOneTime = kRosimplDefaultPageOneTime;
+  Space(const string &nameVal, const string &tagVal, bool managed, PageMap &pageMapVal);
+  virtual ~Space();
+  Space(const Space &that) = delete;
+  Space(Space &&that) = delete;
+  Space &operator=(const Space &that) = delete;
+  Space &operator=(Space &&that) = delete;
+
+  void Init(uint8_t *reqStart = nullptr);
+
+  // Name of the space. May vary, for example before/after the Zygote fork.
+  const char *GetName() const {
+    return name.c_str();
+  }
+
+  inline uint8_t *GetEnd() const {
+    return end.load(std::memory_order_acquire);
+  }
+  inline uint8_t *GetEndRelaxed() const {
+    return end.load(std::memory_order_relaxed);
+  }
+
+  size_t GetMaxCapacity() const {
+    return maxCapacity;
+  }
+
+  inline uint8_t *GetBegin() const {
+    return begin;
+  }
+
+  size_t GetSize() const {
+    return static_cast<size_t>(GetEnd() - GetBegin());
+  }
+  size_t GetSizeRelaxed() const {
+    return static_cast<size_t>(GetEndRelaxed() - GetBegin());
+  }
+
+  // Get the size of the allocated pages
+  inline size_t GetAllocatedPageSize() const {
+    return allocatedPageSize;
+  }
+  // Get the size of the non-released pages
+  inline size_t GetNonReleasedPageSize() const {
+    return nonReleasedPageSize;
+  }
+  // Get the size of the free pages
+  inline size_t GetFreePageSize() const {
+    return nonReleasedPageSize - allocatedPageSize;
+  }
+
+  inline size_t HeapMaxFreeByUtilization() const {
+    // maximum is twice the ideal
+    // cap this for the same reason
+    return std::min(TargetFreePageSizeByUtilization() << 1, kHeapMaxFree);
+  }
+
+  size_t TargetFreePageSizeByUtilization() const;
+
+  void SetEnd(uint8_t *endVal) {
+    // This should be visible by other thread
+    // 1. expand happens under global_lock, new_expand space obj
+    //    must be visible after new "end_" visible to other thread.
+    // 2. heapCurSize update before end_, and end_ store with release order
+    //
+    // when other thread see newly expand space obj, it must see new heapCurSize
+    if (isManaged) {
+      HeapStats::OnHeapExtended(static_cast<size_t>(endVal - GetBegin()));
+    }
+    end.store(endVal, memory_order_release);
+  }
+
+  void SetBegin(uint8_t *beginVal) {
+    begin = beginVal;
+    if (isManaged) {
+      HeapStats::OnHeapCreated(reinterpret_cast<address_t>(beginVal));
+    }
+    // assume begin only set once in Space, otherwise need update heapCurSize
+  }
+
+  inline void RecordReleasedToNonReleased(size_t pageCount) {
+    nonReleasedPageSize += ALLOCUTIL_PAGE_CNT2BYTE(pageCount);
+  }
+
+  // returns the number of pages free within the reserved memry space
+  size_t GetAvailPageCount() const;
+
+  uintptr_t GetChunk(size_t reqSize);
+  size_t GetLargestChunkSize();
+
+  inline bool HasAddress(address_t addr) {
+    const uint8_t *objPtr = reinterpret_cast<const uint8_t*>(addr);
+    return objPtr >= GetBegin() && objPtr < GetEnd();
+  }
+
+  void Extend(size_t deltaSize);
+  address_t Alloc(size_t reqSize, bool allowExtension);
+  size_t ReleaseFreePages(bool aggressive = false);
+  void FreeRegion(address_t addr, size_t pgCnt);
+}; // class Space
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_SPACE_H
diff --git a/src/mrt/compiler-rt/include/chelper.h b/src/mrt/compiler-rt/include/chelper.h
new file mode 100644
index 0000000000000000000000000000000000000000..abe738f3502046780d01bc04547f9d0d22df64cd
--- /dev/null
+++ b/src/mrt/compiler-rt/include/chelper.h
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_CHELPER_H
+#define MAPLE_RUNTIME_CHELPER_H
+
+/**
+ * The purpose of this file is to help C programs to correctly create managed
+ * objects and access its fields.
+ *
+ * Some functions serve the MapleJava project, only.  They are for the
+ * convenience of the C programmers.
+ *
+ * ==========
+ * HOW TO USE
+ * ==========
+ *
+ * When compiling .mpl files, add the -gen-c-macro-def option to mplcg:
+ *
+ *   mplcg -gen-c-macro-def foo.mpl
+ *
+ * That will generate foo.macros.def alongside foo.s. If you have multiple
+ * .macros.def files, merge them with `cat foo.macros.def bar.macros.def | sort
+ * | uniq > unified.macros.def` so that duplicated entries are removed.
+ *
+ * In C files (.c), add the following in the beginning:
+ *
+ *   #include "chelper.h"
+ *
+ *   #ifndef __UNIFIED_MACROS_DEF__
+ *   #define __UNIFIED_MACROS_DEF__
+ *   #include "unified.macros.def"
+ *   #endif
+ *
+ * This will create symbol definitions for class-related information, such as
+ * class instance sizes, and the offset of each class field.  This will enable
+ * all the macros in this header.
+ *
+ * The __UNIFIED_MACROS_DEF__ is useful when we have the habit of including one
+ * .c file into another, and both need to use macros in this header.
+ *
+ * Create Java scalar objects using MRT_NEWOBJ(java_class_name), for example:
+ *
+ *   address_t obj_addr = MRT_NEWOBJ(Ljava/lang/Object;);
+ *   MRT_IncRef(obj_addr);
+ *
+ * or if you defined your own `jobject` type:
+ *
+ *   jobject obj = (jobject)MRT_NEWOBJ(Ljava/lang/Object;);
+ *   MRT_IncRef((address_t)obj_addr);
+ *
+ * Don't worry about GCTIB, itable, vtable or the klass field.  MRT_NEWOBJ
+ * already filled those fields for you.  In the future, when we change our
+ * naming convention, we change this header.
+ *
+ * Creating Java arrays using MRT_NEW_*_ARRAY(len), for example:
+ *
+ *   address_t jint_array = MRT_NEW_JINT_ARRAY(100);
+ *   MRT_IncRef(jint_array);
+ *
+ *   address_t jobj_array = MRT_NEW_JOBJECT_ARRAY(100);
+ *   MRT_IncRef(jobj_array);
+ *
+ * MRT_NEW_*_ARRAY handles the length field and the elemSize (component size)
+ * field, too.
+ *
+ * String has a custom layout, and cannot be allocated in the generic way.  See
+ * `dex2mpl/projects/helloworld/HelloWorld.jni.c` for more information.
+ *
+ * Load and store object fields using the MRT_LOAD_*(object, offset) and the
+ * MRT_STORE_*(object, offset, value) macros:
+ *
+ *   jint v = MRT_LOAD_JINT(foo, MRT_FIELD_OFFSET(Lcom_2Fexample_2FSomeObject_3B, someIntField))
+ *   MRT_STORE_JINT(foo, MRT_FIELD_OFFSET(Lcom_2Fexample_2FSomeObject_3B, someIntField), newval)
+ *
+ * The MRT_FIELD_OFFSET(className, fieldName) returns the offset of that field.
+ * Note that className must be the class in which fieldName is defined.
+ * Subclasses may define fields of the same name if the field is private, so our
+ * macros make a compromise by not inheriting fields into subclasses.
+ * (Interestingly, according to the Java Language Specification, subclasses
+ * really do not "inherit" fields from its parents.)
+ *
+ * When linking, link with `mapleall/runtime/src/buildaarch64/libmplrt.a`.
+ */
+#include "collector/collector.h"
+#include "namemangler.h"
+#include "mm_config.h"
+#include "cinterface.h"
+#include "mrt_fields_api.h" // Load and store operations for fields
+#include "panic.h"
+#include "jsan.h"
+#include "mrt_compiler_api.h"
+#include "mrt_reflection_api.h"
+// Some Macro magics.
+//
+// Force expansion before pasting.
+#define __MRT_MAGIC_PASTE(x, y) __MRT_MAGIC_PASTE2(x, y)
+#define __MRT_MAGIC_PASTE2(x, y) x##y
+
+// Defer expansion
+#define __MRT_MAGIC_EMPTY()
+#define __MRT_MAGIC_DEFER(x) x __MRT_MAGIC_EMPTY()
+#define __MRT_MAGIC_DEFER_IGNORE(x) __MRT_MAGIC_EMPTY()
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+// Query instance size, field offset and field size.
+//
+// className is an identifier.  These macros automatically paste identifiers.
+#define MRT_INSTANCE_SIZE(className) __MRT_MAGIC_PASTE(__MRT_instance_size__, className)
+#define MRT_FIELD_OFFSET(className, fieldName) \
+    __MRT_MAGIC_PASTE(__MRT_MAGIC_PASTE(__MRT_MAGIC_PASTE(__MRT_field_offset__, className), __), fieldName)
+#define MRT_FIELD_SIZE(className, fieldName) \
+    __MRT_MAGIC_PASTE(__MRT_MAGIC_PASTE(__MRT_MAGIC_PASTE(__MRT_field_size__, className), __), fieldName)
+
+#define MRT_GCTIB(className)  __MRT_MAGIC_PASTE(GCTIB_PREFIX, className)
+#define MRT_ITABLE(className) __MRT_MAGIC_PASTE(ITAB_PREFIX, className)
+#define MRT_VTABLE(className) __MRT_MAGIC_PASTE(VTAB_PREFIX, className)
+#define MRT_CLASSINFO(className) __MRT_MAGIC_PASTE(CLASSINFO_PREFIX, className)
+#define MRT_PRIMITIVECLASSINFO(className) __MRT_MAGIC_PASTE(PRIMITIVECLASSINFO_PREFIX, className)
+#define MRT_FIELDS(className)  __MRT_MAGIC_PASTE(FIELDINFO_PREFIX, className)
+#define MRT_METHODS(className) __MRT_MAGIC_PASTE(METHODINFO_PREFIX, className)
+
+#define MRT_GETKLASS(className) MRT_GetClassByClassLoader(nullptr, TO_STR(className))
+
+// Expand the definitions from the .macros.def files generated by
+// `mplcg --gen-c-macro-def`
+//
+// The following two are not really a vararg macros. That's for preventing
+// expanding className and offset too early. For example, when fieldName is
+// "errno" or "stdout", it will be a problem.
+#define MRT_FIELD_OFFSET_DEF(className, fieldName) __MRT_field_offset__##className##__##fieldName
+#define MRT_FIELD_SIZE_DEF(className, fieldName) __MRT_field_size__##className##__##fieldName
+
+#define __MRT_CLASS(className, size, superclass, ...) \
+    static const size_t MRT_INSTANCE_SIZE(className##__VA_ARGS__) = size; \
+    extern void *MRT_CLASSINFO(className##__VA_ARGS__);
+
+#define __MRT_CLASS_FIELD(className, fieldName, offset, size, ...) \
+    static const size_t MRT_FIELD_OFFSET_DEF(className##__VA_ARGS__, fieldName##__VA_ARGS__) = offset; \
+    static const size_t MRT_FIELD_SIZE_DEF(className##__VA_ARGS__, fieldName##__VA_ARGS__) = size;
+
+//
+// Creating an object in Java involves four steps:
+//
+// 0. Allocating the memory for the object.
+// 1. Do proper initialization for the language-agnostic runtime
+//    - e.g. To implement GC, this will assign the GCTIB to the object header.
+// 2. Do proper initialization for the language runtime
+//    - e.g. To implement Java, this will assign the fields not visible to the
+//      Java langauge, including the pointers to I-table, V-table, the Class
+//      object, and the monitor word.
+// 3. Call the user-defined object initializer
+//    - e.g. For Java, it is the `<init>` method, of the proper signature if
+//      overloaded.
+//
+// The following macros perform one or more of the above steps.
+address_t __MRT_chelper_newobj_0(size_t size);
+
+address_t __MRT_chelper_newobj_flexible_0(size_t elemSize, size_t len);
+address_t MRT_ChelperNewobjFlexible(size_t elemSize, size_t len, address_t klass, bool isJNI = false);
+
+#define MRT_NEWOBJ_0(className) \
+    __MRT_chelper_newobj_0(MRT_INSTANCE_SIZE(className))
+// Must use MRT_GETKLASS(className) instead of MRT_CLASSINFO(className) here due to
+// dynamic class loading
+#define MRT_NEWOBJ_1(className) \
+    MRT_ReflectAllocObject(MRT_GETKLASS(className))
+
+#define MRT_NEWOBJ_FLEXIBLE_0(elemSize, len, cls) \
+    __MRT_chelper_newobj_flexible_0(elemSize, len)
+
+#define MRT_NEWOBJ_FLEXIBLE_1(elemSize, len, cls) \
+    MRT_ChelperNewobjFlexible(elemSize, len, reinterpret_cast<address_t>(cls))
+
+#define MRT_NEWOBJ_FLEXIBLE_JNI_1(elemSize, len, cls, jni) \
+    MRT_ChelperNewobjFlexible(elemSize, len, reinterpret_cast<address_t>(cls), jni)
+
+// CONFIG ME: Set the following macro to the desired level.
+//
+// Setting to 2 will automatically assign itab, vtab and klass.  Since these
+// assignments are idempotent, it does not affect the correctness if <init>()
+// also initializes those fields.
+#define __MRT_DESIRED_INIT_LEVEL 1
+
+#define __THE_MRT_NEWOBJ __MRT_MAGIC_PASTE(MRT_NEWOBJ_, __MRT_DESIRED_INIT_LEVEL)
+#define __THE_MRT_NEWOBJ_FLEXIBLE __MRT_MAGIC_PASTE(MRT_NEWOBJ_FLEXIBLE_, __MRT_DESIRED_INIT_LEVEL)
+#define THE_MRT_NEWOBJ_FLEXIBLE_JNI __MRT_MAGIC_PASTE(MRT_NEWOBJ_FLEXIBLE_JNI_, __MRT_DESIRED_INIT_LEVEL)
+
+// This is the intended way to allocate heap objects in C
+#define MRT_NEWOBJ(className) __THE_MRT_NEWOBJ(className)
+
+#define MRT_NEW_JOBJECT_ARRAY(len, klass) __THE_MRT_NEWOBJ_FLEXIBLE(sizeof(reffield_t), len, klass)
+
+#define MRT_NEW_PRIMITIVE_ARRAY(elemSize, len, klass) __THE_MRT_NEWOBJ_FLEXIBLE(elemSize, len, klass)
+
+#define MRT_NEW_PRIMITIVE_ARRAY_JNI(elemSize, len, klass, jni) THE_MRT_NEWOBJ_FLEXIBLE_JNI(elemSize, len, klass, jni)
+
+// ---  Write barriers  ---
+// Object *var = value;  ----> MRT_WRITE_REF_VAR(var, value)
+// not used now, Undefined
+#define MRT_WRITE_REF_VAR(var, value) \
+    MRT_WriteRefVar(reinterpret_cast<address_t*>(&(var)), reinterpret_cast<address_t>(value))
+
+// obj->field = value; ----> MRT_WRITE_REF_FIELD(obj, field, value)
+#define MRT_WRITE_REF_FIELD(obj, field, value) \
+    MRT_WriteRefField(reinterpret_cast<address_t>(obj), \
+    reinterpret_cast<address_t*>(&(obj->field)), reinterpret_cast<address_t>(value))
+
+// release(obj); ----> MRT_RELEASE_REF_VAR(obj)
+#define MRT_RELEASE_REF_VAR(obj) MRT_ReleaseRefVar(reinterpret_cast<address_t>(obj))
+
+// RC operations used in MRT
+#define ENABLE_RC_FASTPATH
+#ifdef ENABLE_RC_FASTPATH
+#define RC_LOCAL_INC_REF(obj) (void)(MRT_IncRefNaiveRCFast(reinterpret_cast<address_t>(obj)))
+#define RC_RUNTIME_INC_REF(obj) (void)(MRT_IncRefNaiveRCFast(reinterpret_cast<address_t>(obj)))
+#define RC_LOCAL_DEC_REF(obj) (void)MRT_DecRefNaiveRCFast(reinterpret_cast<address_t>(obj))
+#define RC_RUNTIME_DEC_REF(obj) (void)MRT_DecRefNaiveRCFast(reinterpret_cast<address_t>(obj))
+#else
+#define RC_LOCAL_INC_REF(obj) MRT_IncRef(reinterpret_cast<address_t>(obj))
+#define RC_RUNTIME_INC_REF(obj) MRT_IncRef(reinterpret_cast<address_t>(obj))
+#define RC_LOCAL_DEC_REF(obj) MRT_DecRef(reinterpret_cast<address_t>(obj))
+#define RC_RUNTIME_DEC_REF(obj) MRT_DecRef(reinterpret_cast<address_t>(obj))
+#endif
+
+constexpr std::size_t kMrtKlassOffset = 0;
+
+// Have to add these, too, in order not to depend on the C++ header sizes.h
+// GREP-ARRAYLAYOUT: Grep me to see if all these places agree.
+void MRT_SetJavaClass(address_t objAddr, address_t klass);
+void MRT_SetObjectPermanent(address_t objAddr);
+void MRT_SetJavaArrayClass(address_t objAddr, address_t klass);
+#if ALLOC_USE_FAST_PATH
+void MRT_SetFastAlloc(ClassMetadata*);
+#else
+#define MRT_SetFastAlloc(x)
+#endif
+void MRT_CheckRefCount(address_t obj, uint32_t index);
+void MRT_ReflectThrowNegtiveArraySizeException();
+void MRT_SetThreadPriority(pid_t tid, int32_t priority);
+
+inline void MRT_MemoryBarrier(void) {
+#if defined(__aarch64__) || defined(__arm__)
+  __asm__ ("dmb ish":::);
+#else
+#error "Unsupported architecture"
+#endif
+}
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+
+#endif
diff --git a/src/mrt/compiler-rt/include/chosen.h b/src/mrt/compiler-rt/include/chosen.h
new file mode 100644
index 0000000000000000000000000000000000000000..953406cef7d3996be8e1b8a9aa4a710d35a8234d
--- /dev/null
+++ b/src/mrt/compiler-rt/include/chosen.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_CHOSEN_H
+#define MAPLE_RUNTIME_CHOSEN_H
+
+#include "mm_config.h"
+#include "deps.h"
+// This module chooses the desired allocator and collector instances according
+// to the GC strategy configured using preprocessor macros.
+// The chosen strategy class inherits from the implementation, not the other way around.
+// This avoids virtual dispatch, and is what's done in MMTk.
+#if MRT_ALLOCATOR == MRT_ALLOCATOR_ROS
+namespace maplert {
+class RosAllocImpl;
+template<uint32_t kLocalRuns>
+class ROSAllocMutator;
+// this number equals kROSAllocLocalRuns; because of forward declaration, we need to explicitly
+// write it here; get rid of forward declaration in the future
+using RosBasedMutator = ROSAllocMutator<12>;
+using TheAllocator = RosAllocImpl;
+using TheAllocMutator = RosBasedMutator;
+}
+#else
+#error "Invalid MRT_ALLOCATOR"
+#endif
+
+// We don't provide an empty collect/mutator. So when MRT_COLLECTOR_NONE is defined,
+// using NaiveRC as the default ones, but disable its effect in runtime
+#if ((MRT_COLLECTOR == MRT_COLLECTOR_NONE) || (MRT_COLLECTOR == MRT_COLLECTOR_NAIVERC))
+namespace maplert {
+class NaiveRCCollector;
+class NaiveRCMutator;
+using TheCollector = NaiveRCCollector;
+using TheMutator = NaiveRCMutator;
+}
+#elif MRT_COLLECTOR == MRT_COLLECTOR_MS
+namespace maplert {
+class MarkSweepCollector;
+class MarkSweepMutator;
+using TheCollector = MarkSweepCollector;
+using TheMutator = MarkSweepMutator;
+}
+#else
+#error "Invalid MRT_COLLECTOR"
+#endif
+
+#include "tls_store.h"
+namespace maplert {
+class BumpPointerAlloc;
+class DecoupleAllocator;
+class MetaAllocator;
+class ZterpStaticRootAllocator;
+extern ImmortalWrapper<BumpPointerAlloc> permAllocator;
+extern ImmortalWrapper<BumpPointerAlloc> zterpMetaAllocator;
+extern ImmortalWrapper<MetaAllocator> metaAllocator;
+extern ImmortalWrapper<DecoupleAllocator> decoupleAllocator;
+extern ImmortalWrapper<ZterpStaticRootAllocator> zterpStaticRootAllocator;
+extern ImmortalWrapper<TheAllocator> theAllocator;
+
+class Mutator;
+
+static inline Mutator &TLMutator(void) noexcept {
+  // tl_the_mutator is added to thread context in GCInitThreadLocal()
+  return *reinterpret_cast<Mutator*>(maple::tls::GetTLS(maple::tls::kSlotMutator));
+}
+
+static inline Mutator *TLMutatorPtr(void) {
+  if (maple::tls::HasTLS()) {
+    // tl_the_mutator is added to thread context in GCInitThreadLocal()
+    return reinterpret_cast<Mutator*>(maple::tls::GetTLS(maple::tls::kSlotMutator));
+  }
+  // CreateTLS() not called on current thread.
+  return nullptr;
+}
+
+static inline TheAllocMutator &TLAllocMutator(void) {
+  // tl_alloc_mutator is added to thread context in GCInitThreadLocal()
+  return *reinterpret_cast<TheAllocMutator*>(maple::tls::GetTLS(maple::tls::kSlotAllocMutator));
+}
+
+static inline TheAllocMutator *TLAllocMutatorPtr(void) {
+  if (maple::tls::HasTLS()) {
+    // tl_alloc_mutator is added to thread context in GCInitThreadLocal()
+    return reinterpret_cast<TheAllocMutator*>(maple::tls::GetTLS(maple::tls::kSlotAllocMutator));
+  }
+  // CreateTLS() not called on current thread.
+  return nullptr;
+}
+} // namespace maplert
+
+// we forward declared the classes above, then include the headers these classes depend on,
+// so that the code (especially inline functions) in these headers can at least enjoy the benefits
+// of knowing what the chosen collector/allocator/mutator are, as well as the mutator getters.
+//
+// if any of these headers uses the above information, it needs to include chosen.h to be
+// self-contained. but we won't do that because usually chosen.h comes at the very beginning of a
+// compilation unit, and it's intended to be used in place of collector/allocator headers.
+#include "allocator/bp_allocator.h"
+#if MRT_ALLOCATOR == MRT_ALLOCATOR_ROS
+#include "allocator/ros_allocator.h"
+#endif
+#include "collector/collector_naiverc.h"
+#if ((MRT_COLLECTOR == MRT_COLLECTOR_NONE) || (MRT_COLLECTOR == MRT_COLLECTOR_NAIVERC))
+#elif MRT_COLLECTOR == MRT_COLLECTOR_MS
+#include "collector/collector_ms.h"
+#endif
+#endif // MAPLE_RUNTIME_CHOSEN_H
diff --git a/src/mrt/compiler-rt/include/cinterface.h b/src/mrt/compiler-rt/include/cinterface.h
new file mode 100644
index 0000000000000000000000000000000000000000..e58f740df774420a0c44d5e7df34e92106a13a79
--- /dev/null
+++ b/src/mrt/compiler-rt/include/cinterface.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_CINTERFACE_H
+#define MAPLE_RUNTIME_CINTERFACE_H
+
+#include <iostream>
+#include <cstdlib>
+#include <functional>
+#include <utility>
+#include <vector>
+#include <map>
+#include <string>
+#include "gc_roots.h"
+#include "address.h"
+#include "mrt_reference_api.h"
+#include "heap_stats.h"
+
+// These functions form the interface for the .s code generated from mplcg.
+// A criteria for inclusion is that if the function is callable from generated .s,
+// and is front-end independent (i.e. not specific to dex2mpl), it should be here.
+// chelper.h shall help C programmers, including the developers
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+// Most functions are simple wrappers of methods of global or thread-local
+// objects defined in chosen.h/cpp.  Read cinterface.cpp for more information.
+//
+// Gets the polling page address.
+void *MRT_GetPollingPage();
+
+// returns the approximate total number of live objects
+size_t MRT_TotalHeapObj();
+
+// executes heap trim
+void MRT_Trim(bool aggressive);
+
+// type of permanent space allocation
+enum MetaTag : uint16_t {
+  kClassMetaData = 0,
+  kFieldMetaData,
+  kMethodMetaData,
+  kITabMetaData,
+  kNativeStringData,
+  kMetaTagNum
+};
+
+enum DecoupleTag : uint16_t {
+  kITab = 0,
+  kITabAggregate,
+  kVTab,
+  kVTabArray,
+  kTagMax
+};
+static const std::string kDecoupleTagNames[kTagMax] = {
+    "itab", "itab aggregate",
+    "vtab", "vtab array",
+};
+address_t MRT_AllocFromPerm(size_t size);
+address_t MRT_AllocFromMeta(size_t size, MetaTag metaTag);
+address_t MRT_AllocFromDecouple(size_t size, DecoupleTag tag);
+
+void MRT_FreeObj(address_t obj);
+void MRT_ResetHeapStats();
+
+bool MRT_IsPermJavaObj(address_t obj);
+
+// GC related interface
+void MRT_PrintRCStats();
+void MRT_ResetRCStats();
+
+size_t MRT_GetNativeAllocBytes();
+void MRT_SetNativeAllocBytes(size_t size);
+
+void MRT_ClassInstanceNum(std::map<std::string, long> &objNameCntMp);
+
+// collector specific JNI interface
+// Unsafe
+bool MRT_UnsafeCompareAndSwapObject(address_t obj, ssize_t offset,
+                                    address_t expectedValue, address_t newValue);
+address_t MRT_UnsafeGetObjectVolatile(address_t obj, ssize_t offset);
+address_t MRT_UnsafeGetObject(address_t obj, ssize_t offset);
+void MRT_UnsafePutObject(address_t obj, ssize_t offset, address_t newValue);
+void MRT_UnsafePutObjectVolatile(address_t obj, ssize_t offset, address_t newValue);
+void MRT_UnsafePutObjectOrdered(address_t obj, ssize_t offset, address_t newValue);
+
+// barriers for runtime code.
+address_t MRT_LoadRefField(address_t obj, address_t *fieldAddr);
+address_t MRT_LoadVolatileField(address_t obj, address_t *fieldAddr);
+void MRT_WriteRefField(address_t obj, address_t *field, address_t value);
+void MRT_WriteVolatileField(address_t obj, address_t *objAddr, address_t value);
+
+address_t MRT_LoadRefFieldCommon(address_t obj, address_t *fieldAddr); // only used in naiverc
+
+// write barrier
+void MRT_WriteRefFieldNoRC(address_t obj, address_t *field, address_t value);
+void MRT_WriteRefFieldNoDec(address_t obj, address_t *field, address_t value);
+void MRT_WriteRefFieldNoInc(address_t obj, address_t *field, address_t value);
+
+void MRT_WriteVolatileFieldNoInc(address_t obj, address_t *objAddr, address_t value);
+void MRT_WriteVolatileFieldNoDec(address_t obj, address_t *objAddr, address_t value);
+void MRT_WriteVolatileFieldNoRC(address_t obj, address_t *objAddr, address_t value);
+
+// RC weak field processing
+// static not supported
+void MRT_WriteWeakField(address_t obj, address_t *field, address_t value, bool isVolatile);
+address_t MRT_LoadWeakField(address_t obj, address_t *field, bool isVolatile);
+address_t MRT_LoadWeakFieldCommon(address_t obj, address_t *field);
+
+// For referent processing
+void MRT_WriteReferentField(address_t obj, address_t *fieldAddr, address_t value, bool isResurrectWeak);
+// Load Referent can only happen in soft/weak/weak global, weak_global has special handling
+// Used in java mutator thread
+address_t MRT_LoadReferentField(address_t obj, address_t *fieldAddr);
+
+// write barrier for local reference variable update.
+void MRT_WriteRefVar(address_t *var, address_t value); // not used now, undefined
+void MRT_WriteRefVarNoInc(address_t *var, address_t value); // not used, undefined
+
+// Call this function when we are going to renew an dead object,
+// for example: reuse string from pool in NewStringUtfFromPool().
+// when concurrent mark is running, this function will mark the object to
+// prevent it from being swept by GC.
+void MRT_PreRenewObject(address_t obj);
+
+void MRT_SetTracingObject(address_t obj);
+
+// release local reference variable, only naive rc need this.
+void MRT_ReleaseRefVar(address_t obj);
+
+bool MRT_IsValidObjectAddress(address_t obj);
+
+// Trigger GC. Callable from mutator threads.  This function may or may not
+// block, depending on the specific reason.  If it blocks, it will return when
+// it has finished GC.
+//
+// reason: The specific reason for performing GC.
+void MRT_TriggerGC(maplert::GCReason reason);
+
+bool MRT_IsNaiveRCCollector();
+
+// Returns true if current thread is GC thread.
+bool MRT_IsGcThread();
+
+bool MRT_IsGcRunning();
+
+bool MRT_FastIsValidObjAddr(address_t obj);
+
+#if LOG_ALLOC_TIMESTAT
+void MRT_PrintAllocTimers();
+void MRT_ResetAllocTimers();
+#endif
+void MRT_DebugShowCurrentMutators();
+size_t MRT_AllocSize();
+size_t MRT_AllocCount();
+size_t MRT_FreeSize();
+size_t MRT_FreeCount();
+
+void MRT_DumpHeap(const std::string &tag);
+
+// dump RC and GC information into stream os
+void MRT_DumpRCAndGCPerformanceInfo(std::ostream &os);
+
+void MRT_DumpRCAndGCPerformanceInfo_Stderr();
+
+void MRT_VisitAllocatedObjects(maple::rootObjectFunc f);
+
+// Cycle pattern interface
+void MRT_DumpDynamicCyclePatterns(std::ostream &os, size_t limit);
+// Send a job that will be executed by the reference processor thread when it
+// wakes up. Intended to perform cycle pattern saving/loading/writing signature etc.
+// Implemented in reference-processor.cpp
+void MRT_SendCyclePatternJob(std::function<void()> job);
+void MRT_SetPeriodicSaveCpJob(std::function<void()> job);
+void MRT_SetPeriodicLearnCpJob(std::function<void()> job);
+void MRT_SendSaveCpJob();
+bool MRT_IsCyclePatternUpdated();
+
+// Send a background gc job to reference processor when process state change to jank imperceptible.
+void MRT_SendBackgroundGcJob(bool force);
+
+
+void MRT_UpdateProcessState(ProcessState processState, bool isSystemServer);
+
+// Set a callback function which is called after GC finished, but before
+// starting the world.  Useful for performing cleaning up after a GC.
+void MRT_DumpStaticField(std::ostream &os);
+void MRT_WaitGCStopped();
+#if RC_TRACE_OBJECT
+void TraceRefRC(address_t obj, uint32_t rc, const char *msg);
+#endif
+void MRT_SetAllocRecordingCallback(std::function<void(address_t, size_t)> callback);
+
+// traverse 'objects' allocated in the perm space
+void MRT_VisitDecoupleObjects(maple::rootObjectFunc f);
+
+#ifdef __cplusplus
+} // namespace maplert
+} // extern "C"
+#endif // __cplusplus
+
+#endif // MAPLE_RUNTIME_CINTERFACE_H
diff --git a/src/mrt/compiler-rt/include/collector/arena.h b/src/mrt/compiler-rt/include/collector/arena.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b1ac019215e834b5318df1488ee16004672259d
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/arena.h
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_ARENA_H
+#define MAPLE_RUNTIME_ARENA_H
+
+#include "address.h"
+#include "base/logging.h"
+#include "jni.h"
+#include "panic.h"
+#include "allocator/page_pool.h"
+
+namespace maplert {
+static constexpr uint32_t kLocalVarHeaderSlotCount = 1;
+static constexpr uint32_t kLocalVarBankSlotCount = maple::kPageSize / sizeof(address_t) - kLocalVarHeaderSlotCount;
+
+// Use dynamic allocated MemoryBank to save address_t content. Basic operation is save snapshot
+// pop to snapshot/iterate Object Handle Arena or iterate to snapshot.
+// HandleArena use bump-the-pointer allocation to serve object handle allocation. It should have
+// stack-style allocation and deallocation, which a set of successive allocated handles are bulk
+// freed at a specific code point.
+class HandleArena {
+  struct MemoryBank {
+    MemoryBank *prev = nullptr;
+    address_t *BeginSlotAddr() {
+      return (reinterpret_cast<address_t*>(this)) + kLocalVarHeaderSlotCount;
+    }
+    address_t *EndSlotAddr() {
+      return (reinterpret_cast<address_t*>(this)) + kLocalVarHeaderSlotCount + kLocalVarBankSlotCount;
+    }
+  };
+
+ public:
+  HandleArena() : tail(nullptr), top(nullptr) {}
+  ~HandleArena() {
+    if (tail != nullptr) {
+      PopBanks(nullptr, nullptr);
+    }
+  }
+  HandleArena &operator=(const HandleArena &other) {
+    this->tail = other.tail;
+    this->top = other.top;
+    return *this;
+  }
+  void VisitGCRoots(const RefVisitor &visitor);
+  void VisitTopSnapShot(const RefVisitor &visitor, const HandleArena &snapShot) noexcept {
+    VisitTopSnapShot(visitor, snapShot.tail, snapShot.top);
+  }
+
+  // bump-the-pointer allocation
+  address_t *AllocateSlot() {
+    if (tail == nullptr || top == tail->EndSlotAddr()) {
+      GetNewBank();
+    }
+    address_t *result = top;
+    ++top;
+    return result;
+  }
+
+  // utility function for bulk free
+  void PopBanks(const HandleArena &snapshot) noexcept {
+    PopBanks(snapshot.tail, snapshot.top);
+  }
+
+  inline void Clear() noexcept {
+    tail = nullptr;
+    top = nullptr;
+  }
+ private:
+  MemoryBank *tail;    // current allocatable bank
+  address_t *top;      // current allocatable pointer
+  inline void GetNewBank() {
+    static_assert(sizeof(MemoryBank*) == sizeof(address_t), "not equal size");
+    MemoryBank *mb = reinterpret_cast<MemoryBank*>(PagePool::Instance().GetPage());
+    if (UNLIKELY(mb == nullptr)) {
+      LOG(FATAL) << "Failed to allocate a new bank" << maple::endl;
+    }
+    mb->prev = tail;
+    tail = mb;
+    top = tail->BeginSlotAddr();
+  }
+
+  void PopBanks(MemoryBank *toTail, address_t *toTop) noexcept {
+    while (tail != toTail && tail != nullptr) {
+      MemoryBank *prev = tail->prev;
+      PagePool::Instance().ReturnPage(reinterpret_cast<uint8_t*>(tail));
+      tail = prev;
+    }
+    top = toTop;
+  }
+
+  void VisitTopSnapShot(const RefVisitor &visitor, MemoryBank *toBank, address_t *toTop) {
+    MemoryBank *curBank = tail;
+    address_t *curTop = top;
+    if (curBank == nullptr) {
+      return;
+    }
+    while (curBank != toBank) {
+      address_t *start = curBank->BeginSlotAddr();
+      address_t *end = curTop;
+      for (address_t *iter = start; iter < end; ++iter) {
+        visitor(*iter);
+      }
+      curBank = curBank->prev;
+      if (curBank != nullptr) {
+        curTop = curBank->EndSlotAddr();
+      } else {
+        __MRT_ASSERT(toBank == nullptr && toTop == nullptr, "unexpected");
+        curTop = nullptr;
+      }
+    }
+    // curBank is endBank, visit from curTop/end to endTop
+    if (curTop != toTop) {
+      for (address_t *iter = toTop; iter < curTop; ++iter) {
+        visitor(*iter);
+      }
+    }
+  }
+};
+
+class MObject;
+class MArray;
+class MString;
+// Indirect holder for Java heap object in runtime, points to a slot in HandleArena
+// It can be passed to callee, but cannot returned directly.
+// Hierarchy:
+//   HandleBase
+//     ObjHandle<MObject>
+//        ObjHandle<MString>
+//        ObjHandle<MArray>
+class HandleBase {
+ public:
+  virtual ~HandleBase() {
+    handle = nullptr;
+  }
+  inline address_t AsRaw() const {
+    return *handle;
+  }
+  inline jobject AsJObj() const {
+    return reinterpret_cast<jobject>(AsRaw());
+  }
+  inline jobjectArray AsJObjArray() const {
+    return reinterpret_cast<jobjectArray>(AsRaw());
+  }
+  inline MObject *AsObject() const {
+    return reinterpret_cast<MObject*>(AsRaw());
+  }
+  inline MArray *AsArray() const {
+    return reinterpret_cast<MArray*>(AsRaw());
+  }
+  inline bool operator==(const HandleBase &ref) const {
+    return AsRaw() == ref.AsRaw();
+  }
+  inline bool operator==(const address_t otherObj) const {
+    return AsRaw() == otherObj;
+  }
+  inline address_t Return() {
+    address_t old = AsRaw();
+    *handle = 0;
+    return old;
+  }
+  inline jobject ReturnJObj() {
+    return reinterpret_cast<jobject>(Return());
+  }
+  inline MObject *ReturnObj() {
+    return reinterpret_cast<MObject*>(Return());
+  }
+ protected:
+  inline void Release() noexcept {
+    if (handle != nullptr) {
+      *handle = 0;
+    }
+  }
+  void Push(address_t ref);
+  address_t *handle = nullptr; // indirect pointer(reference) of raw heap object pointer
+};
+
+// RC collector is supported in maple, rc count should be maintained in the Handle.
+// Some Handle do produce rc count, for example return value from another function,
+// it should use the following pattern:
+//   ObjectHandle<MObject, true> newObj(NewObject(...))
+//
+// But some handle do not produce rc count, for example the parameter arguments, it
+// should use the following pattern:
+//   ObjectHandle<MObject, false> argment(arg0)
+template<class T, bool needRC = true>
+class ObjHandle : public HandleBase {
+  using pointer = typename std::add_pointer<T>::type;
+  using lref = typename std::add_lvalue_reference<T>::type;
+ public:
+  explicit ObjHandle(address_t ref) {
+    Push(ref);
+  }
+  explicit ObjHandle(jobject ref) {
+    Push(reinterpret_cast<address_t>(ref));
+  }
+  explicit ObjHandle(MObject *object) {
+    Push(reinterpret_cast<address_t>(object));
+  }
+  explicit ObjHandle(MString *str) {
+    Push(reinterpret_cast<address_t>(str));
+  }
+  explicit ObjHandle(MArray *array) {
+    Push(reinterpret_cast<address_t>(array));
+  }
+  ~ObjHandle() {
+    if (!needRC) {
+      Release();
+    }
+  }
+  inline pointer operator->() {
+    return reinterpret_cast<pointer>(AsRaw());
+  }
+  inline pointer operator()() {
+    return reinterpret_cast<pointer>(AsRaw());
+  }
+  inline lref operator*() {
+    return reinterpret_cast<lref>(AsRaw());
+  }
+};
+
+// Used to snapshot the arena usage.
+// It should be used before Handle allocation (means ObjectHandle declaration),
+// the current top of the arena is recorded, and the memory above the recorded
+// top is returned upon the destruction of ScopedHandles.
+class ScopedHandles {
+ public:
+  ScopedHandles();
+  ~ScopedHandles();
+
+  ScopedHandles(const ScopedHandles&) = delete;
+  ScopedHandles(ScopedHandles&&) = delete;
+  ScopedHandles &operator=(const ScopedHandles&) = delete;
+  ScopedHandles &operator=(ScopedHandles&&) = delete;
+ private:
+  HandleArena snapshot;
+};
+}  // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/collector/collector.h b/src/mrt/compiler-rt/include/collector/collector.h
new file mode 100644
index 0000000000000000000000000000000000000000..696f3f662289820a93a15255cb3f2163c480a65e
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/collector.h
@@ -0,0 +1,559 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_COLLECTOR_H
+#define MAPLE_RUNTIME_COLLECTOR_H
+
+#include <cstdlib>
+#include <cstdint>
+#include <vector>
+#include <set>
+#include <iostream>
+#include <functional>
+#include <atomic>
+#include <climits>
+#include <time.h>
+
+#include "collector/stats.h"
+#include "collector/satb_buffer.h"
+#include "mm_utils.h"
+#include "mm_config.h"
+#include "address.h"
+#include "gc_reason.h"
+#include "mpl_thread_pool.h"
+#include "gc_callback.h"
+#include "arena.h"
+#include "exception/stack_unwinder.h"
+#include "syscall.h"
+
+constexpr uint32_t kMutatorDebugTrue = 0x12345678; // Used to debug STW mutator damage
+constexpr uint32_t kMutatorDebugFalse = 0x88665544;
+constexpr uint32_t kMutatorDebugMagic1 = 0x11223344;
+constexpr uint32_t kMutatorDebugMagic2 = 0x22334455;
+constexpr uint32_t kMutatorDebugMagic3 = 0x33445566;
+constexpr uint32_t kMutatorDebugMagic4 = 0x44556677;
+
+constexpr int32_t kLargArraySize = 63;
+
+namespace maplert {
+// The GC-related information after user data in the GCTIB.
+struct GCTibGCInfo {
+  // GC header prototype
+  uint32_t headerProto;
+  // Number of bitmap words.
+  uint32_t nBitmapWords;
+
+  // An array of bitmap words. Length is `nBitmapWords`.
+  uint64_t bitmapWords[];
+};
+
+extern "C" struct GCTibGCInfo MCC_GCTIB___EmptyObject;
+extern "C" struct GCTibGCInfo MCC_GCTIB___ArrayOfObject;
+extern "C" struct GCTibGCInfo MCC_GCTIB___ArrayOfPrimitive;
+
+enum CollectorType {
+  kNoneCollector,     // No Collector
+  kNaiveRC,           // Naive RC
+  kMarkSweep,         // Mark Sweep tracing GC
+  kNaiveRCMarkSweep   // Naive RC backup tracing mark sweep collector
+};
+
+// Record gcIsGCOnly symbol address in echo RC compiled maple so
+// If not found, no action is need.
+// 1. At load time, check collector type and update
+// 2. At fork time/collector create time, update all according to new collector type
+class RegisteredCollectorTypeCheckAddrs {
+ public:
+  static RegisteredCollectorTypeCheckAddrs &Instance() {
+    if (UNLIKELY(instance == nullptr)) {
+      LOG(FATAL) << "Create RegisteredCollectorTypeCheckAddrs instance failed" << maple::endl;
+    }
+    return *instance;
+  }
+  RegisteredCollectorTypeCheckAddrs() = default;
+  ~RegisteredCollectorTypeCheckAddrs() = delete;
+  void Register(uint64_t *addr);
+  void PostCollectorCreate();
+ private:
+  std::vector<uint64_t*> addrs;
+  std::mutex registerLock;
+  static RegisteredCollectorTypeCheckAddrs *instance;
+  static constexpr uint32_t kRegistedMagicNumber = 0x4d634734;
+};
+
+// Central garbage identification algorithm.
+class Collector {
+ public:
+  Collector();
+  virtual ~Collector() = default;
+
+  // Initializer and finalizer.  Default: no-op
+  //
+  // They are called from the MRT_GCInitGlobal and MRT_GCFiniGlobal,
+  // respectively.  We can assume that they can only be called after global
+  // variables are constructed (i.e. after the constructor of theCollector
+  // and theAllocator).
+  virtual void Init();
+  virtual void Fini() {}
+  static void SwitchToGCOnFork();
+  static void Create(bool gcOnly);
+  static inline Collector &Instance() noexcept {
+    return *instance;
+  }
+  static inline Collector *InstancePtr() noexcept {
+    return instance;
+  }
+  const std::string &GetName();
+
+  // Initialize after fork (in child process).
+  virtual void InitAfterFork() {
+    if (type != kNaiveRCMarkSweep && !isSystem) {
+      processState = kProcessStateJankPerceptible;
+      startupPhase.store(true, std::memory_order_release);
+    }
+    stats::gcStats->OnCollectorInit();
+  }
+
+  // GC related
+  // Start/Stop GC thread(s).
+  virtual void StartThread(bool isZygoteProcess __attribute__((unused))) {}
+  virtual void StopThread() {}
+  virtual void JoinThread() {}
+
+  // This pure virtual function implements the triggering of GC.
+  //
+  // reason: Reason for GC.
+  // unsafe: Trigger from unsafe context, e.g., holding a lock, in the middle of an alloc.
+  // In order to prevent deadlocks, unsafe trigger will not automatically
+  // enter safe region, instead the triggering mutator will enter safe region
+  // later naturally (e.g., from a yieldpoint).
+  //
+  // Return value:
+  //    0: This invocation did not trigger GC.
+  //    1: Other threads have triggered GC, and we waited for the GC to finish.
+  //    2: This invocation triggered GC, and we waited until GC finished.
+  virtual void InvokeGC(GCReason reason, bool unsafe = false) = 0;
+
+  // Wait GC finished.
+  virtual void WaitGCStopped() {}
+  virtual bool IsGcRunning() const = 0;
+  virtual bool IsGcTriggered() const = 0;
+  virtual bool IsConcurrentMarkRunning() const = 0;
+  virtual bool IsGarbage(address_t obj) = 0;
+  virtual void StackScanBarrierInMutator() = 0;
+  virtual reffield_t RefFieldLoadBarrier(const address_t obj, const reffield_t &field) = 0;
+
+  // Perform a clean-up GC after the application has finished.
+  // This is useful for detecting memory cells that should have been reclaimed but are not.
+  //
+  // This function must only be invoked after all mutator threads are
+  // terminated, but before the global collector is finalized (i.e. Call
+  // MRT_DebugCleanup() before calling MRT_GCFiniGlobal()).
+  virtual void DebugCleanup() {}
+
+  // This function is used to deal with neighbours during sweeping.
+  // For gc collector, it's a noop.
+  // For rc collector, it needs to collect dead neighbours for further operation.
+  virtual void HandleNeighboursForSweep(address_t, std::vector<address_t>&) {}
+
+  // Utils
+  virtual void SetIsSystem(bool system) {
+    isSystem.store(system, std::memory_order_release);
+  }
+  void SetIsZygote(bool zygote) {
+    isZygote.store(zygote, std::memory_order_release);
+  }
+  bool IsZygote() {
+    return isZygote.load(std::memory_order_relaxed);
+  }
+  CollectorType Type() noexcept {
+    return type;
+  }
+  virtual void DumpHeap(const std::string &tag __attribute__((unused))) {}
+  virtual void DumpFinalizeGarbage() {}
+  virtual void DumpGarbage() {}
+  virtual void DumpCleaner() {}
+  virtual void DumpWeakSoft() {}
+  virtual void PostNewObject(address_t obj __attribute__((unused))) {}
+
+  // Common object API
+  virtual void ObjectArrayCopy(address_t src, address_t dst, int32_t srcIndex, int32_t dstIndex, int32_t count,
+                               bool check) = 0;
+  virtual void PostObjectClone(address_t src, address_t dst) = 0;
+  // Unsafe
+  virtual bool UnsafeCompareAndSwapObject(address_t obj, ssize_t offset,
+                                          address_t expectedValue, address_t newValue) = 0;
+  virtual address_t UnsafeGetObjectVolatile(address_t obj, ssize_t offset) = 0;
+  virtual address_t UnsafeGetObject(address_t obj, ssize_t offset) = 0;
+  virtual void UnsafePutObject(address_t obj, ssize_t offset, address_t newValue) = 0;
+  virtual void UnsafePutObjectVolatile(address_t obj, ssize_t offset, address_t newValue) = 0;
+  virtual void UnsafePutObjectOrdered(address_t obj, ssize_t offset, address_t newValue) = 0;
+
+  // Status info
+  void UpdateProcessState(ProcessState processState, bool isSystemServer);
+
+  // Returns true if we currently not care about long mutator pause.
+  inline bool InJankImperceptibleProcessState() const {
+    return processState == kProcessStateJankImperceptible;
+  }
+  inline bool InStartupPhase() {
+    return startupPhase.load(std::memory_order_acquire);
+  }
+
+  inline void EndStartupPhase() {
+    startupPhase.store(false, std::memory_order_release);
+  }
+
+ protected:
+  CollectorType type = kNoneCollector;
+  bool IsSystem() {
+    return isSystem.load(std::memory_order_acquire);
+  }
+
+ private:
+  // Indicates whether we care about pause time.
+  ProcessState processState;
+  // set true after app fork and set false after startup background GC inovke GC
+  std::atomic<bool> startupPhase = { false };
+
+  // Set true when gc (backup tracing) is running.
+  std::atomic<bool> isSystem = { true };
+  std::atomic<bool> isZygote = { true };
+
+  // instance
+  static Collector *instance;
+};
+
+struct UnwindContext;
+
+// Per-thread Collector context for each mutator (application thread).
+//
+// Strictly speaking, memory allocation operations (NewObj, NewObjFlexible, ...)
+// also belongs to the mutator class, because collector and allocator are
+// usually tightly-coupled.  In MapleJava, currently at least, both RC and MS
+// use free-list allocator, so we consider the allocator as a shared resource.
+//
+// If we ever decide to introduce bump-pointer allocators, we will need to
+// refine the interface further.
+class Mutator {
+  friend class MutatorList;
+ public:
+  enum StackScanState : int {
+    kNeedScan,
+    kInScan,
+    kFinishScan,
+  };
+
+  // Called when a thread starts and finishes, respectively.
+  virtual void Init() {
+    concurrentMarking = Collector::Instance().IsConcurrentMarkRunning();
+  }
+  virtual void Fini() {}
+  virtual ~Mutator() {
+    tid *= -1;
+    currentCompiledMethod = nullptr;
+    if (satbNode != nullptr) {
+      SatbBuffer::Instance().RetireNode(satbNode);
+      satbNode = nullptr;
+    }
+  }
+
+  // Mutator is active if it is added to MutatorList.
+  __attribute__ ((always_inline))
+  inline bool IsActive() const {
+    if (active == kMutatorDebugTrue) {
+      return true;
+    } else if (active == kMutatorDebugFalse) {
+      return false;
+    } else {
+      DumpRaw();
+      LOG(FATAL) << "active crash " << std::hex << active << std::dec << maple::endl;
+      return false;
+    }
+  }
+
+  // Sets 'in saferegion' state of this mutator.
+  __attribute__ ((always_inline))
+  inline void SetInSaferegion(bool b) {
+    inSaferegion = b ? kMutatorDebugTrue : kMutatorDebugFalse;
+  }
+
+  // Gets 'in saferegion' state of this mutator.
+  // Returns true if this mutator is in saferegion, otherwise false.
+  __attribute__ ((always_inline))
+  inline bool InSaferegion() const {
+    if (inSaferegion == kMutatorDebugTrue) {
+      return true;
+    } else if (inSaferegion == kMutatorDebugFalse) {
+      return false;
+    } else {
+      DumpRaw();
+      LOG(FATAL) << "inSaferegion crash " << std::hex << inSaferegion << std::dec << maple::endl;
+      return false;
+    }
+  }
+
+  // Force this mutator enter saferegion, internal use only.
+  __attribute__ ((always_inline))
+  inline void DoEnterSaferegion();
+
+  // Force this mutator leave saferegion, internal use only.
+  __attribute__ ((always_inline))
+  inline void DoLeaveSaferegion();
+
+  // Let this mutator enter saferegion.
+  __attribute__ ((always_inline))
+  inline bool EnterSaferegion(bool rememberLastJavaFrame);
+
+  // Let this mutator leave saferegion.
+  __attribute__ ((always_inline))
+  inline bool LeaveSaferegion();
+
+  // Save the start stack pointer.
+  __attribute__ ((always_inline))
+  inline void SaveStackBegin(void *begin) {
+    stackBegin = reinterpret_cast<address_t>(begin);
+    InitTid();
+  }
+
+  // Save the end stack pointer.
+  __attribute__ ((always_inline))
+  inline void SaveStackEnd(void *end) {
+    stackEnd = reinterpret_cast<address_t>(end);
+  }
+
+  // Clear stack begin/end.
+  void ClearStackInfo() {
+    stackBegin = 0;
+    stackEnd = 0;
+    GetLastJavaContext().frame.Reset();
+  }
+
+  // Init after fork.
+  void InitAfterFork() {
+    // tid changed after fork,
+    // so we re-initialize it.
+    InitTid();
+  }
+
+  void VisitJavaStackRoots(const AddressVisitor &func) {
+    MapleStack::VisitJavaStackRoots(GetLastJavaContext(), func, tid);
+  }
+
+  void VisitNativeStackRoots(const RefVisitor &func) {
+    arena.VisitGCRoots(func);
+  }
+
+  ATTR_NO_SANITIZE_ADDRESS
+  inline void VisitStackSlotsContent(const AddressVisitor &func) {
+    if (UNLIKELY(stackBegin == 0)) {
+      return;
+    }
+    // we scan stack by 32bit now, this is a workaround for stack allocated objects.
+    // we should restore 64bit stack scan if scalar replacement implemented in future
+    for (address_t slot = stackEnd; slot < stackBegin; slot += sizeof(reffield_t)) {
+      func(static_cast<address_t>(*reinterpret_cast<reffield_t*>(slot)));
+    }
+  }
+
+  void DebugShow() const;
+
+  // Called on the return value of java.lang.ref.Reference.get() before
+  // returning to the caller, and also when decoding a weak global reference in
+  // JNI.
+  //
+  // Concurrent collectors need to handle this carefully to synchronize between
+  // Reference.get() and the concurrent marking threads.  Particularly, if
+  // referent is not null, it shall not be prematurely reclaimed while the
+  // mutator is still using it.
+  //
+  // This mechanism cannot handle the clearing of Reference instances.
+  // According to the Java API, if an object is no longer softly/weakly
+  // reachable, all soft/weak references to that object must be ATOMICALLY
+  // cleared.  In other words, mutators must not see some soft/weak references
+  // to that object cleared while other soft/weak references to that object not
+  // cleared.  Moreover, weak global references are cleared at a different time
+  // than java.lang.ref.WeakReference.  Specifically, it not cleared until the
+  // referent is finalized.  We should refine the API and handle the two cases
+  // differently if we want to support concurrent reference cleaning.
+  //
+  // referent: The referent of the Reference object
+  virtual void WeakRefGetBarrier(address_t referent __attribute__((unused))) {
+    // By default, this barrier does nothing
+  }
+
+  inline HandleArena &GetHandleArena() noexcept {
+    return arena;
+  }
+
+  inline StackScanState GetScanState() {
+    return scanState;
+  }
+
+  inline void SetScanState(StackScanState state) {
+    scanState.store(state);
+  }
+
+  inline bool TrySetScanState(bool wait) {
+    while (true) {
+      StackScanState state = scanState.load();
+      if (state == kFinishScan) {
+        return false;
+      }
+
+      if (state == kInScan) {
+        if (wait) {
+          int *stateAddr = reinterpret_cast<int*>(&scanState);
+          if (UNLIKELY(maple::futex(stateAddr, FUTEX_WAIT, static_cast<int>(state), nullptr, nullptr, 0) != 0)) {
+            LOG(ERROR) << "futex wait failed, " << errno << maple::endl;
+          }
+        } else {
+          return false;
+        }
+      }
+
+      if (state == kNeedScan && scanState.compare_exchange_weak(state, kInScan)) {
+        return true;
+      }
+    }
+  }
+
+  inline void FinishStackScan(bool notify) {
+    scanState.store(kFinishScan);
+    if (notify) {
+      int *stateAddr = reinterpret_cast<int*>(&scanState);
+      (void)maple::futex(stateAddr, FUTEX_WAKE, INT_MAX, nullptr, nullptr, 0);
+    }
+  }
+
+  __attribute__ ((always_inline))
+  inline void StackScanBarrier();
+
+  uint32_t GetTid() const {
+    return tid;
+  }
+
+  uintptr_t GetStackBegin() const {
+    return stackBegin;
+  }
+
+  // get stack scanning range size in bytes.
+  size_t GetStackSize() const {
+    // we assume stack is downward grow.
+    if (UNLIKELY(stackBegin == 0)) {
+      return 0;
+    }
+    return static_cast<size_t>(stackBegin - stackEnd);
+  }
+
+  void SetCurrentCompiledMethod(void *func) {
+    currentCompiledMethod = func;
+  }
+  void *GetCurrentCompiledMethod() {
+    return currentCompiledMethod;
+  }
+
+  InitialUnwindContext &GetInitialUnwindContext() {
+    return initialUnwindContext;
+  }
+
+  // should rename to GetUnwindContext
+  UnwindContext &GetLastJavaContext() {
+    return GetInitialUnwindContext().GetContext();
+  }
+
+  void DumpRaw() const {
+    LOG(ERROR) << "addr : " << this << " tid : " << tid <<
+        std::hex <<
+        " state : " << inSaferegion <<
+        " active : " << active <<
+        " magic3_ : " << magc3 <<
+        " magic2_ : " << magc2 <<
+        " magic1_ : " << magc1 <<
+        std::dec << maple::endl;
+  }
+  void CopyStateOnFork(Mutator &orig);
+
+  template<bool kPreserveSelf = true>
+  void SatbWriteBarrier(address_t obj) {
+    if (concurrentMarking) {
+      if (kPreserveSelf) {
+        PushIntoSatbBuffer(obj);
+      } else {
+        PushChildrenToSatbBuffer(obj);
+      }
+    }
+  }
+
+  void SatbWriteBarrier(address_t obj, const reffield_t &field);
+
+  void PushIntoSatbBuffer(address_t obj) {
+    if (LIKELY(IS_HEAP_ADDR(obj))) {
+      if (SatbBuffer::Instance().ShouldEnqueue(obj)) {
+        SatbBuffer::Instance().EnsureGoodNode(satbNode);
+        satbNode->Push(obj);
+      }
+    }
+  }
+
+  void PushChildrenToSatbBuffer(address_t obj);
+
+  const SatbBuffer::Node *GetSatbBufferNode() const {
+    return satbNode;
+  }
+
+  void ResetSatbBufferNode() {
+    satbNode = nullptr;
+  }
+
+  void SetConcurrentMarking(bool status) {
+    concurrentMarking = status;
+  }
+ private:
+  void InitTid();
+
+  // mutator become active if it is added to MutatorList.
+  uint32_t active = kMutatorDebugFalse;
+
+  // in saferegion, mutator will not access any managed objects.
+  uint32_t inSaferegion = kMutatorDebugFalse;
+
+  // the begin stack pointer for stack scanning.
+  address_t stackBegin = 0;
+  uint32_t magc3 = kMutatorDebugMagic3;
+  // the last stack pointer for stack scanning.
+  address_t stackEnd = 0;
+  // thread id
+  uint32_t magc2 = kMutatorDebugMagic2;
+  uint32_t tid = kMutatorDebugMagic4;
+  uint32_t magc1 = kMutatorDebugMagic1;
+
+  // arena is used to save local object pointer in native function
+  // for precise stack scan.
+  HandleArena arena;
+
+  // indicate whether the stack of current mutator is scanned
+  std::atomic<StackScanState> scanState = { kFinishScan };
+
+  // initial context for unwinding java call stack
+  InitialUnwindContext initialUnwindContext;
+  void *currentCompiledMethod = nullptr;
+
+  // satb buffer
+  bool concurrentMarking = false;
+  SatbBuffer::Node *satbNode = nullptr;
+};
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/collector/collector_ms.h b/src/mrt/compiler-rt/include/collector/collector_ms.h
new file mode 100644
index 0000000000000000000000000000000000000000..549a55ef6140188065b542d27647b2a7ac444543
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/collector_ms.h
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_COLLECTOR_MS_H
+#define MAPLE_RUNTIME_COLLECTOR_MS_H
+
+#include <vector>
+
+#include "address.h"
+#include "allocator.h"
+#include "collector_tracing.h"
+
+namespace maplert {
+class MarkTask;
+class ConcurrentMarkTask;
+
+// max size of work stack for a single mark task.
+static constexpr size_t kMaxMarkTaskSize = 128;
+
+#if BT_CLEANUP_PROFILE
+class BTCleanupStats{
+ public:
+  static size_t rootSetSize;
+  static size_t totalRemain;
+  static size_t reachableRemain;
+  static size_t unreachableRemain;
+};
+#endif
+
+class MarkSweepCollector : public TracingCollector {
+  friend MarkTask;
+  friend ConcurrentMarkTask;
+ public:
+  MarkSweepCollector() : TracingCollector() {
+    type = kMarkSweep;
+#if CONFIG_JSAN
+    enableConcurrent  = false;
+    isInitializedConcurrent = true;
+#endif
+    lastTriggerTime = timeutils::NanoSeconds();
+  }
+
+  virtual ~MarkSweepCollector() = default;
+
+  inline bool IsGcTriggered() const override {
+    return isGcTriggered.load(std::memory_order_relaxed);
+  }
+
+  // always enable concurrent GC unless it is OOM.
+  inline bool IsConcurrent(GCReason reason) {
+    if (UNLIKELY(!isInitializedConcurrent)) {
+      InitConcurrentMarkSweep();
+    }
+    return enableConcurrent && (reasonCfgs[reason].isConcurrent);
+  }
+
+  // return true if concurrent mark is running.
+  inline bool IsConcurrentMarkRunning() const override {
+    return concurrentMarkRunning; // need move to collector-ms
+  }
+
+  inline void SetConcurrentMarkRunning(bool state) {
+    // let allocator know
+#if ALLOC_USE_FAST_PATH
+    FastAllocData::data.isConcurrentMarking = state;
+#endif
+    concurrentMarkRunning = state;
+  }
+
+  // Handle newly allocated objects during concurrent marking.
+  inline void PostNewObject(address_t obj) override {  // move to concurrent marking ms
+    // When concurrent mark is running, we need to set the newly
+    // allocated object as marked to prevent it be swept by GC.
+    if (UNLIKELY(IsConcurrentMarkRunning())) {
+      (void)MarkObject(obj);
+      newObjDuringMarking.fetch_add(1, std::memory_order_relaxed);
+    }
+  }
+
+  // Handle to-be-free objects during concurrent marking.
+  // return true if concurrent mark is running.
+  virtual bool PreFreeObject(address_t) {
+    return false;
+  }
+
+  virtual bool IsGarbageBeforeResurrection(address_t addr) {
+    return !markBitmap.IsObjectMarked(addr);
+  }
+
+  // barrier for stack scan in mutator
+  void StackScanBarrierInMutator() override;
+
+  // pre/post hook
+  virtual void PreMSHook();
+  virtual void PreSweepHook();
+  virtual void PostMSHook(uint64_t gcIndex);
+
+  void DebugCleanup() override {};
+  void Fini() override;
+
+  virtual reffield_t RefFieldLoadBarrier(const address_t obj, const reffield_t &field) override {
+    const address_t fieldAddr = reinterpret_cast<address_t>(&field);
+    const MClass *cls = reinterpret_cast<const MObject*>(obj)->GetClass();
+    const char *clsName = (cls != 0) ? cls->GetName() : "<Null>";
+    const address_t offset = fieldAddr - obj;
+    LOG(ERROR) << "Bad ref field! " <<
+        " cls:" << clsName <<
+        std::hex <<
+        " obj:" << obj <<
+        " off:" << offset <<
+        " val:" << field <<
+        std::dec <<
+        maple::endl;
+    AbortWithHeader(obj);
+    return 0;
+  }
+
+ protected:
+  // statistic values.
+  std::atomic<size_t> newlyMarked = { 0 };
+  std::atomic<size_t> newObjDuringMarking = { 0 }; // new objects during concurrent marking.
+  std::atomic<size_t> freedObjDuringMarking = { 0 }; // freed objects during concurrent marking.
+  std::atomic<size_t> renewObjDuringMarking = { 0 }; // renew objects during concurrent marking.
+
+  // Copy object child refs into a vector.
+  template<typename RefContainer>
+  void CopyChildRefs(reffield_t obj, RefContainer &refs, bool collectRefs = false) {
+    address_t referentAddr = 0;
+    if (UNLIKELY(IsObjReference(obj))) {
+      // referent field address for Reference object.
+      referentAddr = obj + WellKnown::kReferenceReferentOffset;
+      // Move the decision of clearing referent to concurrent mark phase.
+      // Referent of soft references can be cleared or not depending on the implementation
+      // of gc.
+      // Whether or not to mark the referent is decided by the soft reference policy.
+      // If the referent needs to be keeped alive, reset the skipping field indicator
+      // "referent_addr". Otherwise, the skipping field indicator is keeped intact.
+      MClass *klass = reinterpret_cast<MObject*>(static_cast<uintptr_t>(obj))->GetClass();
+      uint32_t classFlag = klass->GetFlag();
+      if ((classFlag & modifier::kClassSoftReference) &&
+          !ReferenceProcessor::Instance().ShouldClearReferent(gcReason)) {
+        referentAddr = 0;
+      }
+    }
+
+    // copy child refs into refs vector.
+    auto refFunc = [this, obj, &refs, referentAddr, collectRefs](reffield_t &field, uint64_t kind) {
+      // skip referent field.
+      const address_t fieldAddr = reinterpret_cast<address_t>(&field);
+      if (UNLIKELY((kind == kUnownedRefBits))) {
+        return;
+      }
+      if (Type() == kNaiveRCMarkSweep && fieldAddr == referentAddr) {
+        // RC mode skip referent
+        return;
+      }
+
+      // ensure that we loaded a valid reference, not a lock flag
+      // set by functions like LoadRefVolatile().
+      reffield_t ref = field;
+      if (UNLIKELY((ref & LOAD_INC_RC_MASK) != 0)) {
+        ref = RefFieldLoadBarrier(obj, field);
+      }
+      if ((fieldAddr == referentAddr) && IS_HEAP_ADDR(ref)) {
+        __MRT_ASSERT(Type() != kNaiveRCMarkSweep, "GCOnly allowed");
+        address_t referent = RefFieldToAddress(ref);
+        if (referent != 0 && ReferenceGetPendingNext(obj) == 0 && IsGarbage(referent)) {
+          if (collectRefs) {
+            finalizerFindReferences.push_back(obj);
+          } else {
+            GCReferenceProcessor::Instance().DiscoverReference(obj);
+          }
+        }
+        return;
+      }
+
+      // skip non-heap ref fields.
+      if (LIKELY(IS_HEAP_ADDR(ref))) {
+        refs.push_back(ref);
+      }
+    };
+    // If need skip copy weak field udpate update with GC procesing
+    DoForEachRefField(obj, refFunc);
+  }
+
+  virtual bool CheckAndPrepareSweep(address_t addr) {
+    return (IsGarbage(addr) && !IsMygoteObj(addr));
+  }
+
+  void AddMarkTask(RootSet &rs);
+  void AddConcurrentMarkTask(RootSet &rs);
+  void ParallelMark(WorkStack &workStack, bool followReferent = false);
+  // concurrent marking.
+  void ConcurrentMark(WorkStack &workStack, bool parallel, bool scanRoot);
+  // prepare for concurrent mark, called in the end of stop-the-world-1.
+  void ConcurrentMarkPrepare();
+
+  virtual void ConcurrentMarkPreparePhase(WorkStack &workStack, WorkStack &inaccurateRoots);
+  virtual void RunFullCollection(uint64_t gcIndex) override;
+  virtual void InitReferenceWorkSet() {}
+  virtual void ResetReferenceWorkSet() {}
+  virtual void ParallelDoReference(uint32_t) {}
+  virtual void ConcurrentDoReference(uint32_t) {}
+  virtual void ReferenceRefinement(uint32_t) {}
+
+  // Unsynchronized reference counting manipulation.
+  // Only useable during stop-the-world.
+  // If don't ensure where objAddr is in heap, use the check version.
+  virtual void DecReferentUnsyncCheck(address_t, bool) {}
+  virtual void DecReferentSyncCheck(address_t, bool) {}
+ private:
+  bool enableConcurrent = true;
+  bool isInitializedConcurrent = false;
+
+  // resurrect candidate (unmarked finalizables) collected during cm
+  WorkStack resurrectCandidates;
+  WorkStack finalizerFindReferences;
+
+  // the flag to indicate whether concurrent mark is running.
+  // no need atomic here because this flag is changed when the world is stopped.
+  bool concurrentMarkRunning = false;
+
+  inline void InitConcurrentMarkSweep() {
+    enableConcurrent =
+        !(MRT_ENVCONF(MRT_IS_NON_CONCURRENT_GC, MRT_IS_NON_CONCURRENT_GC_DEFAULT) || VLOG_IS_ON(nonconcurrentgc));
+    isInitializedConcurrent = true;
+  }
+
+  void RunMarkAndSweep(uint64_t gcIndex = 0);
+
+  // common phases.
+  void ResurrectionPhase(bool isConcurrent);
+  void PrepareTracing();
+  void FinishTracing();
+  void DumpAfterGC();
+  void ScanStackAndMark(Mutator &mutator);
+  void DoWeakGRT();
+  void DoResurrection(WorkStack &workStack);
+  void ResurrectionCleanup();
+
+  /// parallel phases.
+  void ParallelMarkAndSweep();
+  void ParallelMarkPhase();
+  void ParallelScanMark(RootSet *rootSets, bool processWeak, bool rootString);
+  void ParallelResurrection(WorkStack &workStack);
+  void ParallelSweepPhase();
+
+  // concurrent phases.
+  void ConcurrentMarkAndSweep();
+  void ConcurrentMSPreSTW1();
+  void ConcurrentMSPostSTW2();
+  void ConcurrentMarkPhase(WorkStack &&workStack, WorkStack &&inaccurateRoots);
+  // concurrent re-marking.
+  void ConcurrentReMark(bool parallel);
+  // cleanup for concurrent mark, called in the beginning of stop-the-world-2.
+  void ConcurrentMarkCleanupPhase();
+  void ConcurrentMarkCleanup();
+  void ConcurrentPrepareResurrection();
+  void ConcurrentSweepPreparePhase();
+  void ConcurrentSweepPhase();
+  void ConcurrentStackScan();
+  void ConcurrentStaticRootsScan(bool parallel);
+  void ConcurrentMarkFinalizer();
+  void ConcurrentAddFinalizerToRP();
+
+  // pre-write barrier for concurrent marking.
+  // return true if success saved the object to mod-buf.
+  bool ConcurrentMarkPreWriteBarrier(address_t obj);
+
+  inline WorkStack NewWorkStack() {
+    constexpr size_t kWorkStackInitCapacity = 65536UL;
+    WorkStack workStack;
+    workStack.reserve(kWorkStackInitCapacity);
+    return workStack;
+  }
+  void ScanSingleStaticRoot(address_t *rootAddr, TracingCollector::WorkStack &workStack);
+  void EnqueueNeighbors(address_t objAddr, WorkStack &workStack);
+
+  // enqueue neighbors for a java.lang.Reference
+  void EnqueueNeighborsForRef(address_t objAddr, WorkStack &workStack);
+
+  static inline void Enqueue(address_t objAddr, WorkStack &workStack) {
+    workStack.push_back(objAddr);
+  }
+};
+
+class MarkSweepMutator : public TracingMutator {
+ public:
+  MarkSweepMutator(Collector &collector) : TracingMutator(collector) {
+    __MRT_ASSERT(collector.Type() == kMarkSweep, "collector must be MarkSweepCollector");
+  }
+  ~MarkSweepMutator() = default;
+};
+}
+
+#endif
diff --git a/src/mrt/compiler-rt/include/collector/collector_naiverc.h b/src/mrt/compiler-rt/include/collector/collector_naiverc.h
new file mode 100644
index 0000000000000000000000000000000000000000..40b51a2ef9a8971b08c4a799ad864430e0f52d21
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/collector_naiverc.h
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_COLLECTOR_NAIVERC_H
+#define MAPLE_RUNTIME_COLLECTOR_NAIVERC_H
+
+#include <cstdlib>
+#include <deque>
+#include <future>
+#include "pthread.h"
+#include "collector_rc.h"
+#include "collector_naiverc_ms.h"
+#include "cycle_collector.h"
+#include "rc_inline.h"
+
+namespace maplert {
+class NaiveRCCollector : public RCCollector {
+ public:
+  NaiveRCCollector() : RCCollector() {
+    type = kNaiveRC;
+  }
+  ~NaiveRCCollector() = default;
+  void Init() override;
+  void InitAfterFork() override;
+  void StartThread(bool isZygote) override;
+  void StopThread() override;
+  void JoinThread() override;
+  void Fini() override;
+  void DebugCleanup() override {
+    ms.DebugCleanup();
+  }
+
+  void ObjectArrayCopy(address_t src, address_t dst, int32_t srcIndex, int32_t dstIndex, int32_t count,
+                       bool check = false) override;
+  void PostObjectClone(address_t src, address_t dst) override;
+  bool UnsafeCompareAndSwapObject(address_t obj, ssize_t offset, address_t expectedValue, address_t newValue) override;
+  address_t UnsafeGetObjectVolatile(address_t obj, ssize_t offset) override;
+  address_t UnsafeGetObject(address_t obj, ssize_t offset) override;
+  void UnsafePutObject(address_t obj, ssize_t offset, address_t newValue) override;
+  void UnsafePutObjectVolatile(address_t obj, ssize_t offset, address_t newValue) override;
+  void UnsafePutObjectOrdered(address_t obj, ssize_t offset, address_t newValue) override;
+
+  void DumpHeap(const std::string &tag) override {
+    return ms.DumpHeap(tag);
+  }
+
+  void WaitGCStopped() override {
+    ms.WaitGCStopped();
+  }
+
+  bool IsGcRunning() const override {
+    return ms.IsGcRunning();
+  }
+
+  bool IsGcTriggered() const override {
+    return ms.IsGcTriggered();
+  }
+
+  bool IsConcurrentMarkRunning() const override {
+    return ms.IsConcurrentMarkRunning();
+  }
+
+  reffield_t RefFieldLoadBarrier(const address_t obj, const reffield_t &field) override {
+    return ms.RefFieldLoadBarrier(obj, field);
+  }
+
+  void SetIsSystem(bool system) override {
+    Collector::SetIsSystem(system);
+    ms.SetIsSystem(system);
+  }
+
+  void HandleNeighboursForSweep(address_t obj, std::vector<address_t> &deads) override;
+  // 1. Initialize rc to 1
+  // 2. Handle newly allocated objects during concurrent marking.
+  void PostNewObject(address_t obj) override {
+    // rc initialized with value 1.
+    RefCountLVal(obj) = 1 + kWeakRCOneBit;
+    ms.PostNewObject(obj);
+  }
+
+  // Handle to-be-free objects during concurrent marking.
+  // return true if concurrent mark is running.
+  inline bool PreFreeObject(address_t obj) { // need remove adn direclty invoke this method in RC Free Obj
+    return ms.PreFreeObject(obj);
+  }
+
+  // Return true if the object is a garbage to be swept.
+  bool IsGarbage(address_t obj) override {
+    return ms.IsGarbage(obj);
+  }
+
+  // barrier to help gc thread to do stack scan
+  void StackScanBarrierInMutator() override {
+    // need move to collector.h and doesn't need muattor& parameter because its always current mutator.
+    ms.StackScanBarrierInMutator();
+  }
+
+  void InvokeGC(GCReason reason, bool unsafe = false) override;
+
+  void SetHasWeakRelease(bool val) {
+    hasWeakRelease.store(val, std::memory_order_release);
+  }
+  bool HasWeakRelease() {
+    return hasWeakRelease.load(std::memory_order_acquire);
+  }
+ private:
+  NaiveRCMarkSweepCollector ms;  // Private back-up tracer
+  std::atomic<bool> hasWeakRelease = { false }; // only used in zygote fork
+};
+
+class NaiveRCMutator : public RCMutator {
+ public:
+  NaiveRCMutator(Collector &baseCollector)
+      : collector(static_cast<NaiveRCCollector&>(baseCollector)),
+        releaseQueue(nullptr),
+        cycleDepth(0),
+        weakReleaseDepth(0) {
+    __MRT_ASSERT(baseCollector.Type() == kNaiveRC, "collector must be NaiveRCCollector");
+  }
+
+  virtual ~NaiveRCMutator() = default;
+
+  void Init() override {
+    RCMutator::Init();
+    if (releaseQueue == nullptr) {
+      releaseQueue = new (std::nothrow) std::deque<address_t>();
+      if (UNLIKELY(releaseQueue == nullptr)) {
+        LOG(FATAL) << "new deque<address_t> failed" << maple::endl;
+      }
+    }
+  }
+
+  void Fini() override {
+    RCMutator::Fini();
+    if (releaseQueue != nullptr) {
+      delete releaseQueue;
+      releaseQueue = nullptr;
+    }
+  }
+
+  void IncRef(address_t obj);
+  void DecRef(address_t obj);
+  void DecChildrenRef(address_t obj);
+  void ReleaseObj(address_t obj) override;
+  void WeakReleaseObj(address_t obj);
+
+  address_t LoadIncRef(address_t *fieldAddr);
+
+  address_t LoadRefVolatile(address_t *fieldAddr, bool loadReferent = false);
+  void WriteRefFieldVolatile(address_t obj, address_t *fieldAddr, address_t value,
+                             bool writeReferent = false, bool isResurrectWeak = false);
+  void WriteRefFieldVolatileNoInc(address_t obj, address_t *fieldAddr, address_t value,
+                                  bool writeReferent = false, bool isResurrectWeak = false);
+  void WriteRefFieldVolatileNoDec(address_t obj, address_t *fieldAddr, address_t value,
+                                  bool writeReferent = false, bool isResurrectWeak = false);
+  void WriteRefFieldVolatileNoRC(address_t obj, address_t *fieldAddr, address_t value,
+                                 bool writeReferent = false);
+
+  address_t LoadIncRefCommon(address_t *fieldAddr);
+
+  // For Reference and JNI weak glboal
+  void IncWeak(address_t obj);
+  void IncResurrectWeak(address_t obj);
+  void DecWeak(address_t obj);
+
+  // write barrier for local reference variable update.
+  void WriteRefVar(address_t *var, address_t value);
+  void WriteRefVarNoInc(address_t *var, address_t value);
+
+  // writer barrier for object reference field update.
+  void WriteRefField(address_t obj, address_t *field, address_t value);
+  void WriteRefFieldNoDec(address_t obj, address_t *field, address_t value);
+  void WriteRefFieldNoInc(address_t obj, address_t *field, address_t value);
+  void WriteRefFieldNoRC(address_t obj, address_t *field, address_t value);
+
+  // write/load for weak field
+  void WriteWeakField(address_t obj, address_t *field, address_t value, bool isVolatile);
+  address_t LoadWeakField(address_t *fieldAddr, bool isVolatile);
+  address_t LoadWeakRefCommon(address_t *field);
+
+  // release local reference variable.
+  void ReleaseRefVar(address_t obj);
+
+  void WeakRefGetBarrier(address_t referent) override {
+    // When concurrent marking is enabled, remember the referent and
+    // prevent it from being reclaimed in this GC cycle.
+    if (LIKELY(IS_HEAP_OBJ(referent))) {
+      SatbWriteBarrier(referent);
+    }
+  }
+  inline uint32_t CycleDepth() const {
+    return cycleDepth;
+  }
+
+  inline void IncCycleDepth() {
+    ++cycleDepth;
+  }
+
+  inline void DecCycleDepth() {
+    --cycleDepth;
+  }
+
+  bool EnterWeakRelease();
+  void ExitWeakRelease();
+
+  // GC releated
+  inline bool PreFreeObject(address_t obj) {
+    if (UNLIKELY(collector.IsConcurrentMarkRunning())) {
+      SetReleasedBit(obj);
+      return true;
+    }
+    return false;
+  }
+ private:
+  NaiveRCCollector &collector;
+  std::deque<address_t> *releaseQueue; // queue for recurisive object release
+  uint32_t cycleDepth; // cycle pattern match max depth, if overflow skip cycle release
+  uint32_t weakReleaseDepth; // weak relase max depth, if overflow skip weak release
+};
+
+static inline NaiveRCMutator &NRCMutator(void) noexcept {
+  // tl_the_mutator is added to thread context in GCInitThreadLocal()
+  return *reinterpret_cast<NaiveRCMutator*>(maple::tls::GetTLS(maple::tls::kSlotMutator));
+}
+} // namespace maplert
+#endif // MAPLE_RUNTIME_COLLECTOR_NAIVERC_H
diff --git a/src/mrt/compiler-rt/include/collector/collector_naiverc_ms.h b/src/mrt/compiler-rt/include/collector/collector_naiverc_ms.h
new file mode 100644
index 0000000000000000000000000000000000000000..9cffc9231cdd82ccd8f1b1ff786c569d7a75e5a5
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/collector_naiverc_ms.h
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_COLLECTOR_NAIVERC_MS_H
+#define MAPLE_RUNTIME_COLLECTOR_NAIVERC_MS_H
+
+#include "collector_ms.h"
+#include "rc_inline.h"
+
+namespace maplert {
+struct StatRC {
+  uint32_t staticFields;
+  uint32_t weakGlobals;
+  uint32_t externals;
+  uint32_t strings;
+  uint32_t references;
+  uint32_t allocators;
+  uint32_t classloaders;
+  uint32_t stacks;
+  uint32_t heaps;
+  uint32_t weakHeaps;
+  uint32_t mygote;
+  uint32_t mygoteWeak;
+  uint32_t soft;
+  uint32_t weak;
+  uint32_t phantom; // phantom contains cleaner
+
+  uint32_t weakCount;
+  uint32_t resurrectWeakCount;
+  uint32_t weakTotal;
+  uint32_t accurate;
+};
+
+class NaiveRCMarkSweepCollector : public MarkSweepCollector {
+ public:
+  NaiveRCMarkSweepCollector();
+  virtual ~NaiveRCMarkSweepCollector() {}
+
+  // pre/post hook
+  virtual void PreMSHook() override;
+  virtual void PreSweepHook() override;
+  virtual void PostMSHook(uint64_t gcIndex) override;
+
+  // dump
+  void DumpCycleLeak(MplThreadPool &threadPool);
+  void DumpCycleProfile();
+
+  virtual void DebugCleanup() override;
+  inline void SetRCVerify(bool verify) {
+    rcVerification = verify;
+  }
+
+  // Return true if the object is a garbage to be swept.
+  inline bool IsGarbage(address_t objAddr) override {
+    bool result = TracingCollector::IsGarbage(objAddr);
+    // object is garbage if it has released bit or not marked.
+    return (result || HasReleasedBit(objAddr)); // move to collector-naivercms
+  }
+
+  bool IsGarbageBeforeResurrection(address_t addr) override {
+    return !markBitmap.IsObjectMarked(addr) || HasReleasedBit(addr);
+  }
+
+  // Handle to-be-free objects during concurrent marking.
+  // return true if concurrent mark is running.
+  inline bool PreFreeObject(address_t obj) override {
+    // when concurrent mark is running, we do not directly free the object,
+    // instead we set a released flag on it, so that it can be swept by GC.
+    if (UNLIKELY(IsConcurrentMarkRunning())) {
+      SetReleasedBit(obj);
+      freedObjDuringMarking.fetch_add(1, std::memory_order_relaxed);
+      return true;
+    }
+    // let caller directly free the object
+    // if concurrent mark not running.
+    return false;
+  }
+
+  reffield_t RefFieldLoadBarrier(const address_t obj, const reffield_t &field) override {
+    const address_t fieldAddr = reinterpret_cast<address_t>(&field);
+    constexpr size_t kMaxLoadRefSpinCount = 1000000;
+    auto &atomicRef = AddrToLValAtomic<reffield_t>(fieldAddr);
+    for (size_t spinCount = 0; ; ++spinCount) {
+      (void)sched_yield();
+      reffield_t ref = atomicRef.load(std::memory_order_acquire);
+      if ((ref & LOAD_INC_RC_MASK) == 0) {
+        return ref;
+      }
+      if (UNLIKELY(spinCount > kMaxLoadRefSpinCount)) {
+        const MClass *cls = reinterpret_cast<const MObject*>(obj)->GetClass();
+        const char *clsName = (cls != nullptr) ? cls->GetName() : "<Null>";
+        const address_t offset = fieldAddr - obj;
+        LOG(ERROR) << "Bad ref field! " << " cls:" << clsName << std::hex << " obj:" << obj <<
+            " off:" << offset << " val:" << ref << std::dec << maple::endl;
+        HandleRCError(obj);
+      }
+    }
+    return 0;
+  }
+
+ protected:
+  static constexpr uint32_t kInitialReferenceWorkSetSize = 100;
+
+  address_t LoadStaticRoot(address_t *rootAddr) override;
+
+  void InitReferenceWorkSet() override {
+    deadSoftWeaks.reserve(kInitialReferenceWorkSetSize);
+    deadPhantoms.reserve(kInitialReferenceWorkSetSize);
+    clearReferentSoftWeaks.reserve(kInitialReferenceWorkSetSize);
+    clearReferentPhantoms.reserve(kInitialReferenceWorkSetSize);
+  }
+
+  void ResetReferenceWorkSet() override {
+    deadSoftWeaks.clear();
+    deadPhantoms.clear();
+    clearReferentSoftWeaks.clear();
+    clearReferentPhantoms.clear();
+  }
+
+  bool CheckAndPrepareSweep(address_t addr) override {
+    if (IsGarbage(addr) && !IsMygoteObj(addr)) {
+      DecNeighborsAtomic(addr);
+      return true;
+    } else {
+      if (UNLIKELY(IsRCCollectable(addr))) {
+        if (!doConservativeStackScan) {
+          // under precise stack scan, rc collectable objects should be garbage
+          LOG(FATAL) << "Potential Leak " << std::hex << addr << " " << RCHeader(addr) << " " << GCHeader(addr) <<
+              " " << reinterpret_cast<MObject*>(addr)->GetClass()->GetName() <<
+              std::dec << std::endl;
+        }
+      }
+      return false;
+    }
+  }
+
+  void DecReferentUnsyncCheck(address_t objAddr, bool isResurrect) override {
+    if (!FastIsHeapObject(objAddr)) {
+      LOG2FILE(kLogTypeMix) << "(unsync) DEC object out of heap: 0x" <<
+          std::hex << objAddr << ", ignored." << std::endl;
+      return;
+    }
+
+    // this is used for weak global and only dec garbage referent, so there is no need to check dec result
+    if (isResurrect) {
+      uint32_t oldHeader __MRT_UNUSED = UpdateRC<0, 0, -1>(objAddr);
+#if __MRT_DEBUG
+      __MRT_ASSERT(IsRCOverflow(oldHeader) || (GetResurrectWeakRCFromRCHeader(oldHeader) != 0),
+          "Dec resurrect weak from 0");
+#endif
+    } else {
+      uint32_t oldHeader __MRT_UNUSED = UpdateRC<0, -1, 0>(objAddr);
+#if __MRT_DEBUG
+      __MRT_ASSERT(IsRCOverflow(oldHeader) || (GetWeakRCFromRCHeader(oldHeader) != 0), "Dec weak from 0");
+#endif
+    }
+
+#if RC_TRACE_OBJECT
+    TraceRefRC(objAddr, RefCount(objAddr), "After DecReferentUnsyncCheck");
+#endif
+  }
+
+  void DecReferentSyncCheck(address_t objAddr, bool isResurrect) override {
+    if (!FastIsHeapObject(objAddr)) {
+      LOG2FILE(kLogTypeMix) << "(unsync) DEC object out of heap: 0x" <<
+          std::hex << objAddr << ", ignored." << std::endl;
+      return;
+    }
+
+    // Need to check Dec result, because of concurrent mark:
+    // If referent is live (referenced by other live object) in concurrent mark stage, it may
+    //   be dec by mutator, makes the referent rc collected. Then this dec will be the last dec.
+    // If referent is garbage, later sweep will free object
+    if (isResurrect) {
+      uint32_t oldHeader = AtomicUpdateRC<0, 0, -1>(objAddr);
+#if __MRT_DEBUG
+      __MRT_ASSERT(IsRCOverflow(oldHeader) || (GetResurrectWeakRCFromRCHeader(oldHeader) != 0),
+          "Dec resurrect weak from 0");
+#endif
+      if (!IsGarbage(objAddr)) {
+        if (CanReleaseObj<0, 0, -1>(oldHeader) == kReleaseObject) {
+          RCReferenceProcessor::Instance().AddAsyncReleaseObj(objAddr, false);;
+        }
+      }
+    } else {
+      uint32_t oldHeader = AtomicUpdateRC<0, -1, 0>(objAddr);
+#if __MRT_DEBUG
+      __MRT_ASSERT(IsRCOverflow(oldHeader) || (GetWeakRCFromRCHeader(oldHeader) != 0), "Dec weak from 0");
+#endif
+      if (!IsGarbage(objAddr)) {
+        if (CanReleaseObj<0, -1, 0>(oldHeader) == kReleaseObject) {
+          RCReferenceProcessor::Instance().AddAsyncReleaseObj(objAddr, false);
+        }
+      }
+    }
+
+#if RC_TRACE_OBJECT
+    TraceRefRC(objAddr, RefCount(objAddr), "After DecReferentSyncCheck");
+#endif
+  }
+  void ParallelDoReference(uint32_t flags) override;
+  void ConcurrentDoReference(uint32_t flags) override;
+  void ReferenceRefinement(uint32_t flags) override;
+
+ private:
+  // DFX
+  void CheckLeakAndCycle();
+  void DebugVerifyRC();
+
+  void DetectLeak();
+  void PrintLeakRootAndRetainCount(set<address_t> &garbages);
+  void PrintMultiNodeCycleCount(vector<vector<address_t>> &components);
+  void InsertSetForEachRefField(set<address_t> &reachingSet, set<address_t> &garbages);
+  void PrintLeakRoots(set<address_t> &reachingSet, vector<address_t> &component, size_t componentIdx);
+  StatRC NewStatRC(RCHashMap referentRoots[], uint32_t rpTypeNum, address_t obj);
+  void StatReferentRootRC(RCHashMap referentRoots[], uint32_t rpTypeNum);
+  void StatHeapRC();
+  void PrintRCWrongDetails(address_t obj, const StatRC &statRC, const string &errMsg, uint32_t rc, uint32_t weakRC);
+  void PrintRCVerifyResult(std::map<uint32_t, uint32_t> &weakRCDistribution, uint32_t potentialEarlyRelease,
+      uint32_t potentialLeak, uint32_t wrongWeakRCObjs);
+  inline uint32_t GetRCFromMap(address_t obj, RCHashMap &map) {
+    uint32_t rc = 0;
+    auto it = map.find(obj);
+    if (it != map.end()) {
+      rc = it->second;
+    }
+    return rc;
+  }
+
+  void VerifyRC();
+  void ClearRootsMap();
+  virtual void PostInitTracing() override;
+  virtual void PostEndTracing() override;
+  virtual void PostParallelScanMark(bool processWeak) override;
+  virtual void PostParallelScanRoots() override;
+  virtual void ConcurrentMarkPreparePhase(WorkStack &workStack, WorkStack &inaccurateRoots) override;
+  virtual void PostParallelAddTask(bool processWeak) override;
+  void CollectReferentRoot(RootSet &rs, RCHashMap &map);
+
+  void DecNeighborsAtomic(uintptr_t objAddr);
+
+  inline void UpdateRCMap(RCHashMap &rcMap, address_t obj) {
+    auto it = rcMap.find(obj);
+    if (it != rcMap.end()) {
+      it->second = it->second + 1;
+    } else {
+      rcMap.insert({ obj, 1 });
+    }
+  }
+
+  inline void CollectRootRC(RootSet &rs, RCHashMap &rcMap) {
+    for (auto it = rs.begin(); it != rs.end(); ++it) {
+      UpdateRCMap(rcMap, *it);
+    }
+  }
+
+  // Always reate cycle pattern from backup tracing, for unit testing
+  bool alwaysCreateCyclePattern;
+
+  // The time (milli seconds) when cycle pattern learning was last performed.
+  uint64_t lastCyclePatternLearnMS;
+  // used for verifying RC
+  RCHashMap staticFieldRoots;
+  RCHashMap externalRoots;
+  RCHashMap weakGlobalRoots;
+  RCHashMap stringRoots;
+  RCHashMap referenceRoots;
+  RCHashMap allocatorRoots;
+  RCHashMap classloaderRoots;
+  RCHashMap stackRoots;
+  RCHashMap heapObjs;
+  RCHashMap heapWeakObjs;
+  RCHashMap mygoteWeakObjs;
+  RCHashMap mygoteObjs;
+  bool rcVerification = false;
+
+  std::vector<address_t*> deadSoftWeaks; // need be in collector-naivercms
+  std::vector<address_t*> deadPhantoms;
+  std::vector<address_t> clearReferentSoftWeaks;
+  std::vector<address_t> clearReferentPhantoms;
+};
+}
+#endif
diff --git a/src/mrt/compiler-rt/include/collector/collector_platform.h b/src/mrt/compiler-rt/include/collector/collector_platform.h
new file mode 100644
index 0000000000000000000000000000000000000000..b668769af5d536cd37fdb47b9c0e17188fc22a50
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/collector_platform.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_COLLECTOR_PLATFROM_H
+#define MAPLE_RUNTIME_COLLECTOR_PLATFROM_H
+namespace maplert {
+class CollectorPlatform {
+ public:
+  CollectorPlatform();
+  virtual ~CollectorPlatform() = default;
+ private:
+  virtual void InitAfterFork() {}
+};
+}
+#endif
\ No newline at end of file
diff --git a/src/mrt/compiler-rt/include/collector/collector_rc.h b/src/mrt/compiler-rt/include/collector/collector_rc.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c3428e496a772274fec55201585a9c61250baf6
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/collector_rc.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_RCCOLLECTOR_H
+#define MAPLE_RUNTIME_RCCOLLECTOR_H
+
+#include "collector.h"
+
+namespace maplert {
+class RCCollector : public Collector {
+ public:
+  static void PrintStats();
+  static void ResetStats();
+  RCCollector() : Collector() {}
+  virtual ~RCCollector() = default;
+#if RC_PROFILE
+  static std::atomic<uint64_t> numNativeInc;
+  static std::atomic<uint64_t> numNativeDec;
+  static std::atomic<uint64_t> numLoadIncRef;
+  static std::atomic<uint64_t> numWriteRefVar;
+  static std::atomic<uint64_t> numWriteRefField;
+  static std::atomic<uint64_t> numReleaseRefVar;
+  static std::atomic<uint64_t> numIncRef;
+  static std::atomic<uint64_t> numDecRef;
+  static std::atomic<uint64_t> numIncNull;
+  static std::atomic<uint64_t> numDecNull;
+#endif
+};
+
+class RCMutator : public Mutator {
+ public:
+  RCMutator() = default;
+  virtual ~RCMutator() = default;
+  void Fini() override;
+  virtual void ReleaseObj(address_t obj) = 0; // Recurisvely dec and free objects
+};
+
+#if RC_HOT_OBJECT_DATA_COLLECT
+void StatsFreeObject(address_t obj);
+void DumpHotObj();
+#else
+#define StatsFreeObject(obj)
+#define DumpHotObj()
+#endif
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/collector/collector_tracing.h b/src/mrt/compiler-rt/include/collector/collector_tracing.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd8e29bebe3a75f0aa0b5c9a6c3aa9e58020affc
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/collector_tracing.h
@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_COLLECTOR_TRACING_H
+#define MAPLE_RUNTIME_COLLECTOR_TRACING_H
+
+#include <cstdlib>
+#include <cstdint>
+#include <cinttypes>
+#include <vector>
+#include <set>
+#include <unordered_map>
+#include <fstream>
+#include <thread>
+
+#include "address.h"
+#include "collector.h"
+#include "gc_roots.h"
+#include "sizes.h"
+#include "heap_stats.h"
+#include "mm_config.h"
+#include "rc_reference_processor.h"
+#include "gc_reference_processor.h"
+#include "mpl_thread_pool.h"
+#include "mrt_bitmap.h"
+#include "task_queue.h"
+#include "deps.h"
+
+// set 1 to enable concurrent mark test.
+#define MRT_TEST_CONCURRENT_MARK __MRT_DEBUG_COND_FALSE
+
+namespace maplert {
+// prefetch distance for mark.
+#define MARK_PREFETCH_DISTANCE 16 // this macro is used for check when pre-compiling.
+static constexpr int kMarkPrefetchDistance = 16; // when it is changed, remember to change MARK_PREFETCH_DISTANCE.
+static constexpr int kSystemServerConcurrentThreadCount = 2;
+
+#if RC_TRACE_OBJECT
+extern "C" {
+  void TraceRefRC(address_t obj, uint32_t rc, const char *msg);
+}
+#endif
+
+struct RegisteredRoots {
+  size_t length; // number of roots
+  address_t **roots; // roots array
+
+  // constructor
+  RegisteredRoots(size_t len, address_t **rootList) : length(len), roots(rootList) {}
+};
+
+static inline bool IsUnmarkedResurrectable(address_t objAddr) {
+  return Collector::Instance().IsGarbage(objAddr) && IsObjResurrectable(objAddr) && !IsMygoteObj(objAddr);
+}
+
+class GCRegisteredRoots {
+ public:
+  static GCRegisteredRoots &Instance() {
+    return *instance;
+  }
+  GCRegisteredRoots() {
+    totalRootsCount = 0;
+  }
+  ~GCRegisteredRoots() = delete;
+  void Register(address_t **gcRootsList, size_t len);
+  void Visit(RefVisitor &visitor);
+  bool GetRootsLocked(size_t index, address_t **&list, size_t &len);
+ private:
+  // A list of registered GC roots, includeing:
+  // 1. static roots
+  // 2. registered single runtimes roots (runtime\interpreter...)
+  // Each registered roots is a bucket of roots address list
+  std::vector<RegisteredRoots> roots;
+  size_t totalRootsCount;
+  std::mutex staticRootsLock;
+  static ImmortalWrapper<GCRegisteredRoots> instance;
+};
+
+class TracingCollector : public Collector {
+ public:
+  class GCTask : public ScheduleTaskBase {
+   public:
+    GCTask() : ScheduleTaskBase(ScheduleTaskType::kInvalidScheduleType), gcReason(kInvalidGCReason) {}
+
+    GCTask(ScheduleTaskType type) : ScheduleTaskBase(type), gcReason(kInvalidGCReason) {
+      __MRT_ASSERT(type != ScheduleTaskType::kScheduleTaskTypeInvokeGC, "invalid gc task!");
+    }
+
+    GCTask(ScheduleTaskType type, GCReason reason)
+        : ScheduleTaskBase(type), gcReason(reason) {
+      __MRT_ASSERT(gcReason > kInvalidGCReason && gcReason < kGCReasonMax, "invalid reason");
+    }
+
+    GCTask(const GCTask &task) = default;
+    virtual ~GCTask() = default;
+    GCTask &operator=(const GCTask&) = default;
+
+    // For a task, we give it a priority based on schedule type and gc reason.
+    // Termination and timeout events get highest prio, and override lower-prio tasks.
+    // Each gc invocation task gets its prio relative to its reason.
+    // This prio is used by the async task queue.
+    static const uint32_t kPrioTerminate = 0;
+    static const uint32_t kPrioTimeout = 1;
+    static const uint32_t kPrioInvokeGC = 2;
+    static inline GCTask FromPrio(uint32_t prio) {
+      if (prio == kPrioTerminate) {
+        return GCTask(kScheduleTaskTypeTerminate);
+      } else if (prio == kPrioTimeout) {
+        return GCTask(kScheduleTaskTypeTimeout);
+      } else if (prio - kPrioInvokeGC < kGCReasonMax) {
+        return GCTask(kScheduleTaskTypeInvokeGC, static_cast<GCReason>(prio - kPrioInvokeGC));
+      }
+      __MRT_ASSERT(false, "invalid prio");
+    }
+    static inline GCTask DoNothing() {
+      return GCTask();
+    }
+    static_assert(kPrioInvokeGC + static_cast<uint32_t>(kGCReasonMax) <=
+                  std::numeric_limits<uint32_t>::digits, "task queue reached max capacity");
+    inline uint32_t GetPrio() const {
+      if (taskType == kScheduleTaskTypeTerminate) {
+        return kPrioTerminate;
+      } else if (taskType == kScheduleTaskTypeTimeout) {
+        return kPrioTimeout;
+      } else if (taskType == kScheduleTaskTypeInvokeGC) {
+        return kPrioInvokeGC + static_cast<uint32_t>(gcReason);
+      }
+      __MRT_ASSERT(false, "invalid task");
+    }
+    inline bool IsNothing() const {
+      return (taskType == kInvalidScheduleType && gcReason == kInvalidGCReason);
+    }
+    inline bool IsOverriding() const {
+      // on timeout, the force gc removes all other gcs;
+      // on termination, all gcs get removed
+      return (taskType != ScheduleTaskType::kScheduleTaskTypeInvokeGC);
+    }
+
+    inline GCReason GetGCReason() const {
+      return gcReason;
+    }
+
+    inline void SetGCReason(GCReason reason) {
+      gcReason = reason;
+    }
+
+    virtual std::string ToString() const override {
+      std::stringstream ss;
+      ss << ScheduleTaskBase::ToString() << " reason=" << gcReason;
+      return ss.str();
+    }
+
+    bool NeedFilter() const override {
+      return true;
+    }
+
+    bool Execute(void *owner) override;
+
+   private:
+    GCReason gcReason;
+  };
+
+  TracingCollector() : Collector() {}
+  virtual ~TracingCollector() = default;
+  virtual void InitTracing();
+  virtual void EndTracing();
+
+  // Types, so that we don't confuse root sets and working stack.
+  // The policy is: we simply `push_back` into root set,
+  // but we use Enqueue to add into work stack.
+  using RootSet = vector<address_t, StdContainerAllocator<address_t, kGCWorkStack>>;
+  using WorkStack = vector<address_t, StdContainerAllocator<address_t, kGCWorkStack>>;
+  using RCHashMap = unordered_map<address_t, uint32_t>;
+
+  void Init() override;
+  void InitAfterFork() override;
+  void Fini() override;
+  void StartThread(bool isZygote) override;
+  void StopThread() override;
+  void JoinThread() override;
+  void WaitGCStopped() override;
+  void OnUnsuccessfulInvoke(GCReason reason);
+  void InvokeGC(GCReason reason, bool unsafe = false) override;
+
+  // new interface added for leak detection
+  void MaybeAddRoot(address_t obj);
+
+  void ScanStackRoots(Mutator &mutator, RootSet &rootSet);
+
+  void ScanAllStacks(RootSet &rootSet);
+
+  // parallel scan all roots.
+  void ParallelScanRoots(RootSet &rootSet, bool processWeak, bool rootString);
+
+  // fast scan roots, inaccurately scan stacks (check heap boundry only).
+  void FastScanRoots(RootSet &rootSet, RootSet &inaccurateRoots, bool processWeak, bool rootString);
+
+  // filter out inaccurate roots from inaccurateRoots, move accurate ones to rootSet.
+  // this function should be called after FastScanRoots().
+  void PrepareRootSet(RootSet &rootSet, RootSet &&inaccurateRoots);
+
+  void DumpRoots(std::ofstream &ofs);
+  void DumpFinalizeGarbage() override;
+  void DumpGarbage() override;
+  void DumpCleaner() override;
+  void DumpWeakSoft() override;
+  void DumpHeap(const std::string &tag) override;
+
+  void ObjectArrayCopy(address_t src, address_t dst, int32_t srcIndex, int32_t dstIndex, int32_t count,
+                       bool check = false) override;
+  void PostObjectClone(address_t src, address_t dst) override;
+  bool UnsafeCompareAndSwapObject(address_t obj, ssize_t offset, address_t expectedValue, address_t newValue) override;
+  address_t UnsafeGetObjectVolatile(address_t obj, ssize_t offset) override;
+  address_t UnsafeGetObject(address_t obj, ssize_t offset) override;
+  void UnsafePutObject(address_t obj, ssize_t offset, address_t newValue) override;
+  void UnsafePutObjectVolatile(address_t obj, ssize_t offset, address_t newValue) override;
+  void UnsafePutObjectOrdered(address_t obj, ssize_t offset, address_t newValue) override;
+
+  inline bool IsGcRunning() const override {
+    return gcRunning.load(std::memory_order_acquire);
+  }
+
+  // Return true if the object is a garbage to be swept.
+  inline bool IsGarbage(address_t objAddr) override {
+    bool result = !markBitmap.IsObjectMarked(objAddr);
+    if (useFinalBitmap) {
+      result = result && !finalBitmap.IsObjectMarked(objAddr);
+    }
+    return result;
+  }
+
+ protected:
+  // bitmap for marking
+  MrtBitmap markBitmap;
+
+  // bitmap for concurrent mark of dead finalizers
+  // it represent the object graph of dead finalizers
+  MrtBitmap finalBitmap;
+  // indicator whether use finalizer bitmap
+  bool useFinalBitmap = false;
+
+  // reason for current GC.
+  GCReason gcReason = kGCReasonUser;
+  std::atomic<bool> gcRunning = { false };
+
+  GCFinishCallbackFunc GCFinishCallBack = DefaultGCFinishCallback;
+
+  bool doConservativeStackScan = false;
+
+  std::unordered_set<Mutator*> snapshotMutators;
+  std::mutex snapshotMutex;
+  // barrier to wait for mutator finish concurrent stack scan
+  std::condition_variable concurrentPhaseBarrier;
+  // number of mutators whose stack needs to be scanned
+  std::atomic<size_t> numMutatorToBeScan = { 0 };
+
+  // the collector thread handle.
+  pthread_t gcThread;
+  std::atomic<pid_t> gcTid;
+  std::atomic<bool> gcThreadRunning = { false };
+
+  // protect condition_variable gcFinishedCondVar's status.
+  std::mutex gcFinishedCondMutex;
+  // notified when GC finished, requires gcFinishedCondMutex
+  std::condition_variable gcFinishedCondVar;
+
+  // whether GC is triggered.
+  // NOTE: When GC finishes, it clears both isGcTriggered and gc_running_.
+  // gc_running_ can be probed asynchronously
+  // isGcTriggered must be written by gc thread only
+  std::atomic<bool> isGcTriggered = { false };
+
+  // gc request index.
+  // increment each time RequestGCAndWait() is called, no matter whether enqueued successfully or not.
+  std::atomic<uint64_t> curGcIndex = { 0 };
+  // finishedGcIndex records the currently finished gcIndex
+  // may be read by mutator but only be written by gc thread sequentially
+  std::atomic<uint64_t> finishedGcIndex = { 0 };
+  // record last gc action's triggering time
+  uint64_t lastTriggerTime = 0;
+
+  std::atomic<size_t> staticRootsTaskIndex = { 0 };
+  std::atomic<size_t> stackTaskIndex = { 0 };
+
+  inline void ResetBitmap() {
+    markBitmap.ResetBitmap();
+    finalBitmap.ResetBitmap();
+    useFinalBitmap = false;
+  }
+  // Return true if and only if the object was marked before this marking.
+  inline bool MarkObject(address_t objAddr) {
+    return markBitmap.MarkObject(objAddr);
+  }
+  inline bool MarkObjectForFinalizer(address_t objAddr) {
+    return finalBitmap.MarkObject(objAddr);
+  }
+
+  // Return true if and only if the object is marked as live.
+  inline bool IsObjectMarked(address_t objAddr) const {
+    bool result = markBitmap.IsObjectMarked(objAddr);
+    if (result) {
+      return result;
+    }
+    if (useFinalBitmap) {
+      return finalBitmap.IsObjectMarked(objAddr);
+    }
+    return false;
+  }
+
+  virtual address_t LoadStaticRoot(address_t *rootAddr) {
+    LinkerRef ref(rootAddr);
+    if (ref.IsIndex()) {
+      return 0;
+    }
+    return LoadRefField(rootAddr);
+  }
+
+  // the collector thread entry routine.
+  static void *CollectorThreadEntry(void *arg);
+
+  // Perform full garbage collection.
+  virtual void RunFullCollection(uint64_t) {
+    LOG(FATAL) << "Should call function in concrete child class!" << maple::endl;
+  }
+
+  // Notify the GC thread to start GC, and wait.
+  // Called by mutator.
+  // reason: The reason for this GC.
+  void RequestGCUnsafe(GCReason reason);
+  void RequestGCAndWait(GCReason reason);
+
+  // Notify that GC has finished.
+  // Must be called by gc thread only
+  void NotifyGCFinished(uint64_t gcIndex);
+  void WaitGCStoppedLite();
+  int32_t GetThreadCount(bool isConcurrent);
+
+  void SetGcRunning(bool running) {
+    gcRunning.store(running, std::memory_order_release);
+  }
+
+  void ScanStaticFieldRoots(RootSet &rootSet);
+  void ScanExternalRoots(RootSet &rootSet, bool processWeak);
+  void ScanLocalRefRoots(RootSet &rootSet);
+  void ScanGlobalRefRoots(RootSet &rootSet);
+  void ScanThreadExceptionRoots(RootSet &rootSet);
+  void ScanWeakGlobalRoots(RootSet &rootSet);
+  void ScanStringRoots(RootSet &rootSet);
+  void ScanAllocatorRoots(RootSet &rootSet);
+  void ScanReferenceRoots(RootSet &rootSet) const;
+  void ScanClassLoaderRoots(RootSet &rootSet);
+  void ScanZterpStaticRoots(RootSet &rootSet);
+
+  void VisitStaticFieldRoots(const maple::rootObjectFunc &func);
+  void VisitAllocatorRoots(const RefVisitor &func) const;
+  void VisitStringRoots(const RefVisitor &func) const;
+  void VisitReferenceRoots(const maple::rootObjectFunc &func) const;
+  void MaybeAddRoot(address_t data, RootSet &rootSet, bool useFastCheck = false);
+
+  // null-implemented here, override in NaiveRCMarkSweepCollector
+  virtual void PostInitTracing() {}
+  virtual void PostEndTracing() {}
+  virtual void PostParallelAddTask(bool) {}
+  virtual void PostParallelScanMark(bool) {}
+  virtual void PostParallelScanRoots() {}
+
+  inline void SetGCReason(GCReason reason) {
+    gcReason = reason;
+  }
+
+  inline void AddRoot(address_t obj, RootSet &rootSet) {
+    if (!IS_HEAP_OBJ(obj)) {
+      MRT_BuiltinAbortSaferegister(obj, nullptr);
+    }
+    rootSet.push_back(obj);
+  }
+
+  inline bool InHeapBoundry(address_t objAddr) const {
+    return IS_HEAP_ADDR(objAddr);
+  }
+
+  inline bool FastIsHeapObject(address_t objAddr) const {
+    return IS_HEAP_OBJ(objAddr);
+  }
+
+  MplThreadPool *GetThreadPool() const {
+    return workerThreadPool;
+  }
+
+  void RunTaskLoop();
+
+ private:
+  // the thread pool for parallel tracing.
+  MplThreadPool *workerThreadPool = nullptr;
+  int32_t concurrentThreadCount = 1; // first process is zygote
+  int32_t parallelThreadCount = 2;
+  TaskQueue<GCTask> taskQueue;
+  static void DefaultGCFinishCallback();
+};
+
+class TracingMutator : public Mutator {
+ public:
+  TracingMutator(Collector &collector __attribute__((unused))) {}
+  virtual ~TracingMutator() = default;
+};
+}
+
+#endif
diff --git a/src/mrt/compiler-rt/include/collector/conn_comp.h b/src/mrt/compiler-rt/include/collector/conn_comp.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5e4d793da3aa46c7d616356628f1b8924b5a5b6
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/conn_comp.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_CONN_COMP_H
+#define MAPLE_RUNTIME_CONN_COMP_H
+
+#include <cstdint>
+#include <vector>
+#include <unordered_set>
+#include <unordered_map>
+#include <memory>
+#include <utility>
+#include <functional>
+#include "address.h"
+
+// Tarjan's strongly connected component algorithm.
+// This is a modified algorithm that is not recursive.  Different from the recursive version
+// https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm,
+// this algorithm uses the ENTER and EXIT action to decide whether to go
+// deeper into a node's descendents, or backing up finding connected components.
+// This is used to find strongly connected components in the object graph for finding cyclic garbages.
+namespace maplert {
+class TracingCollector;
+class CyclePatternGenerator;
+
+struct NodeInfo {
+  uint32_t seqNum;
+  uint32_t lowLink;
+};
+
+NodeInfo inline NewNode() {
+  NodeInfo node;
+  node.seqNum = 0;
+  node.lowLink = 0;
+  return node;
+}
+
+void inline InitNode(NodeInfo &node, uint32_t &curSeqNum) {
+  node.seqNum = curSeqNum;
+  node.lowLink = curSeqNum;
+  ++curSeqNum;
+}
+
+class ConnectedComponentFinder {
+  enum Action {
+    kEnter,
+    kExit,
+  };
+
+  using Node = address_t;
+  using WorkItem = std::pair<Action, Node>;
+  using SeqNum = size_t;
+  using NodeNeighborFinder = std::function<std::vector<Node>(Node)>;
+
+  std::vector<Node> roots;
+  NodeNeighborFinder nnf;
+  bool rootsOnly;
+
+  std::unordered_set<Node> rootsSet;
+
+  std::vector<WorkItem> workList;
+  std::vector<Node> candidateStack;
+  std::unordered_set<Node> candidateSet;
+
+  struct NodeInfoInClass {
+    SeqNum seqNum;
+    SeqNum lowLink;
+  };
+
+  std::unordered_map<Node, NodeInfoInClass> nodeToInfo; // Nodeinfo for each visited node
+
+  std::vector<std::vector<Node>> results;
+
+  SeqNum nextSeqNum;
+
+  bool IsRoot(Node node) {
+    return rootsSet.find(node) != rootsSet.end();
+  }
+
+  bool IsVisited(Node node) {
+    return nodeToInfo.find(node) != nodeToInfo.end();
+  }
+
+  void InitializeNodeInfo(Node node);
+
+  bool IsCandidate(Node node) {
+    return candidateSet.find(node) != candidateSet.end();
+  }
+
+  void PushCandidate(Node node);
+  Node PopCandidate();
+
+  void ProcessActionEnter(std::vector<reffield_t> &workingList, std::unordered_map<reffield_t, NodeInfo> &nodeInfoMap,
+      uint32_t &curSeqNum, address_t node);
+  void ProcessActionExit(std::unordered_map<reffield_t, NodeInfo> &nodeInfoMap, address_t node,
+      CyclePatternGenerator &cpg);
+
+  void ProcessEnterAction(Node node);
+  void ProcessExitAction(Node node);
+
+ public:
+  // paraRoots is the list of roots, i.e. known nodes.  paraNnf is a function that
+  // returns the neighbors of an object.
+  ConnectedComponentFinder(const std::vector<Node> &paraRoots, const NodeNeighborFinder &paraNnf)
+      : roots(paraRoots), nnf(paraNnf), rootsOnly(true), nextSeqNum(0ULL) {}
+  ~ConnectedComponentFinder() = default;
+
+  // True if limit the search to the root set; false if we search among all
+  // nodes reachable from roots as determined by nnf.
+  void SetRootsOnly(bool paraRootsOnly) {
+    rootsOnly = paraRootsOnly;
+  }
+
+  // Run the connected component algorithm
+  void Run();
+
+  // Return the results.
+  const std::vector<std::vector<Node>> &GetResults() const {
+    return results;
+  }
+
+  // improve speed and invoked only in backup tracing
+  // after marking and before sweep
+  void RunInBackupTrace(TracingCollector &collector, CyclePatternGenerator &cpg);
+  ConnectedComponentFinder(const NodeNeighborFinder &paraNnf)
+      : nnf(paraNnf), rootsOnly(true), nextSeqNum(0ULL) {}
+};
+} // namespace
+
+#endif // MAPLE_RUNTIME_CONN_COMP_H
diff --git a/src/mrt/compiler-rt/include/collector/cp_generator.h b/src/mrt/compiler-rt/include/collector/cp_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..eae12b13c195064bc5754a6c2e0251f47f165d29
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/cp_generator.h
@@ -0,0 +1,589 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_CP_GENERATOR_H
+#define MAPLE_RUNTIME_CP_GENERATOR_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <algorithm>
+#include <fstream>
+#include <sys/stat.h>
+#include "mm_config.h"
+#include "sizes.h"
+#include "mrt_object.h"
+#include "cycle_collector.h"
+
+namespace maplert {
+#define CHECK_INFO_FALSE(p, logType, node, msg)        \
+  do {                                               \
+    if (UNLIKELY(p)) {                               \
+      LOG2FILE(logType) << msg << node << std::endl; \
+      return false;                                  \
+    }                                                \
+  } while (0)
+using address_t = uintptr_t;
+
+// garbage subset choose description
+// 1. choose 1 run from every kCyclePatternGarbageRunRatio
+// 2. choose 1 run from every kCyclePatternGarbageCountRatio garbage object
+// 3. max count is kCyclePatternMaxGarbageCount
+const int kCyclePatternGarbageCountRatio = 4;
+const int kCyclePatternGarbageRunRatio = 4;
+const int kCyclePatternMaxGarbageCount = 10000;
+// just test for reduce the pattern install time
+const int kCyclePatternDupInitialThreshold = 3;
+const int kLeastOutputThreshold = 3;
+const double kMaxOutputPercent = 0.8;
+
+// record a cycle pattern, content mapping to pattern in following format
+// class: Landroid_2Fcontent_2Fres_2FHwResourcesImpl_3B
+// Header: ROOT, 1
+// Cycle: 1, 1, 1
+// Node: 0, 88, Landroid_2Fcontent_2Fres_2FResourcesImpl_3B, 1
+// Edge: 1, 0, 104
+//
+class CyclePattern {
+ public:
+  uint32_t count;
+  // getter/setter
+  inline void IncCount() {
+    ++count;
+  }
+  inline int32_t NumNodes() const {
+    return headerInfo.nNodes;
+  }
+  inline int32_t NumEdges() const {
+    return headerInfo.nEdges;
+  }
+
+  bool constructFromBinary(CyclePatternInfo &cyclePatternInfo, MClass *cls) {
+    headerInfo = cyclePatternInfo;
+    CHECK_INFO_FALSE(headerInfo.nNodes > kCyclepPatternMaxNodeNum || headerInfo.nNodes < 0, kLogtypeCycle,
+                     headerInfo.nNodes, "cycle_check: not a valid header, invalide nodes ");
+    CHECK_INFO_FALSE(headerInfo.nEdges > kCyclepPatternMaxEdgeNum || headerInfo.nEdges < 1, kLogtypeCycle,
+                     headerInfo.nEdges, "cycle_check: not a valid header, invalide edge number ");
+    CHECK_INFO_FALSE(headerInfo.expectRc < 1, kLogtypeCycle, headerInfo.expectRc,
+                     "cycle_check: not a valid header, invalide expect rc ");
+    ++(headerInfo.nNodes);
+    // construct node 0
+    CyclePatternNodeInfo node0;
+    node0.expectRc = cyclePatternInfo.expectRc;
+    node0.expectType = cls;
+    nodes[0] = node0;
+    CyclePatternNodeInfo *curNodeInfo = GetCyclePatternNodeInfo(cyclePatternInfo);
+    for (int32_t i = 1; i < headerInfo.nNodes; ++i) {
+      CHECK_INFO_FALSE(curNodeInfo->loadOffset < static_cast<int32_t>(kCyclepObjHeaderLength), kLogtypeCycle,
+                       curNodeInfo->loadOffset, "cycle_check: not a valid node info, invalide loadOffset ");
+      CHECK_INFO_FALSE(curNodeInfo->loadIndex < 0, kLogtypeCycle,
+                       curNodeInfo->loadIndex, "cycle_check: not a valid node info, invalide loadIndex ");
+      CHECK_INFO_FALSE(curNodeInfo->expectRc < 1, kLogtypeCycle,
+                       curNodeInfo->expectRc, "cycle_check: not a valid node info, invalide expect_tc ");
+      nodes[i] = *curNodeInfo;
+      curNodeInfo = reinterpret_cast<CyclePatternNodeInfo*>(
+          (reinterpret_cast<char*>(curNodeInfo)) + sizeof(CyclePatternNodeInfo));
+    }
+
+    CyclePatternEdgeInfo *curEdgeInfo = GetCyclePatternEdgeInfo(cyclePatternInfo);
+    for (int32_t i = 0; i < headerInfo.nEdges; ++i) {
+      CHECK_INFO_FALSE(curEdgeInfo->loadOffset < static_cast<int32_t>(kCyclepObjHeaderLength), kLogtypeCycle,
+                       curEdgeInfo->loadOffset, "cycle_check: not a valid edge info, invalide loadOffset ");
+      CHECK_INFO_FALSE(curEdgeInfo->srcNodeIndex < 0, kLogtypeCycle, curEdgeInfo->srcNodeIndex,
+                       "cycle_check: not a valid edge info, invalide srcNodeIndex ");
+      CHECK_INFO_FALSE(curEdgeInfo->destNodeIndex < 0, kLogtypeCycle, curEdgeInfo->destNodeIndex,
+                       "cycle_check: not a valid edge info, invalide destNodeIndex ");
+      edges[i] = *curEdgeInfo;
+      curEdgeInfo = reinterpret_cast<CyclePatternEdgeInfo*>(
+          (reinterpret_cast<char*>(curEdgeInfo)) + sizeof(CyclePatternEdgeInfo));
+    }
+    return true;
+  }
+
+  // inline utilities
+  inline const CyclePatternNodeInfo *GetNodeInfo(int32_t index) {
+    if (index >= NumNodes()) {
+      LOG(ERROR) << "cycle_check: index out of range";
+      return nullptr;
+    }
+    return &(nodes[index]);
+  }
+
+  inline const CyclePatternEdgeInfo *GetEdgeInfo(int32_t index) {
+    if (index >= NumEdges()) {
+      LOG(ERROR) << "cycle_check: edge index out of range";
+      return nullptr;
+    }
+    return &(edges[index]);
+  }
+
+  inline bool NeedMerge() const {
+    // simplify now
+    if (LIKELY(!kMergeAllPatterns)) {
+      return count >= kLeastOutputThreshold;
+    } else {
+      return true;
+    }
+  }
+  inline void SetNeedMerge() {
+    mergeCandiate = true;
+  }
+
+  // inline utilities
+  inline address_t node(int32_t index) const {
+    if (index >= NumNodes()) {
+      return 0;
+    }
+    return objAddrs[index];
+  }
+
+  bool AddNode(address_t addr, MClass *cls, int8_t loadIndex, int16_t loadOffset, int32_t rc) {
+    if (headerInfo.nNodes == kCyclepPatternMaxNodeNum) {
+      return false;
+    }
+
+    if (rc > static_cast<int32_t>(kMaxRcInCyclePattern)) {
+      return false;
+    }
+
+    if (headerInfo.nNodes == 0) {
+      headerInfo.expectRc = static_cast<int8_t>(rc);
+    }
+    nodes[headerInfo.nNodes].expectType = cls;
+    nodes[headerInfo.nNodes].loadOffset = loadOffset;
+    nodes[headerInfo.nNodes].loadIndex = loadIndex;
+    nodes[headerInfo.nNodes].expectRc = static_cast<int8_t>(rc);
+    objAddrs[headerInfo.nNodes] = addr;
+    ++(headerInfo.nNodes);
+    return true;
+  }
+
+  inline bool AddEdge(int8_t srcIndex, int8_t destIndex, int16_t loadOffset) {
+    if (headerInfo.nEdges == kCyclepPatternMaxEdgeNum) {
+      return false;
+    }
+    edges[headerInfo.nEdges].srcNodeIndex = srcIndex;
+    edges[headerInfo.nEdges].destNodeIndex = destIndex;
+    edges[headerInfo.nEdges].loadOffset = loadOffset;
+    ++(headerInfo.nEdges);
+    return true;
+  }
+
+  inline size_t EmitByteSize() const {
+    size_t size = sizeof(CyclePatternInfo);
+    size += sizeof(CyclePatternNodeInfo) * (NumNodes() - 1);
+    size += sizeof(CyclePatternEdgeInfo) * NumEdges();
+    // align pattern with 8 bytes DWORD size
+    size_t rem = size % kDWordBytes;
+    if (rem != 0) {
+      size += (kDWordBytes - rem);
+    }
+    return size;
+  }
+
+  inline int32_t IndexofObj(address_t obj) const {
+    for (int32_t i = 0; i < NumNodes(); ++i) {
+      if (objAddrs[i] == obj) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  inline int32_t IndexofClass(void *cls) const {
+    for (int32_t i = 0; i < NumNodes(); ++i) {
+      if (nodes[i].expectType == cls) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  bool operator==(const CyclePattern &other) const {
+    if (NumNodes() != other.NumNodes() || NumEdges() != other.NumEdges()) {
+      return false;
+    }
+    for (int32_t i = 0; i < NumNodes(); ++i) {
+      if (nodes[i].expectType != other.nodes[i].expectType ||
+          nodes[i].loadOffset != other.nodes[i].loadOffset ||
+          nodes[i].loadIndex != other.nodes[i].loadIndex ||
+          nodes[i].expectRc != other.nodes[i].expectRc) {
+        return false;
+      }
+    }
+    for (int32_t i = 0; i < NumEdges(); ++i) {
+      if (edges[i].srcNodeIndex != other.edges[i].srcNodeIndex ||
+          edges[i].destNodeIndex != other.edges[i].destNodeIndex ||
+          edges[i].loadOffset != other.edges[i].loadOffset) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  void ReindexNodesAndEdges(const CyclePattern &master, int8_t indexMap[], int32_t numTotalEdges,
+                            const CyclePatternEdgeInfo edgesAll[], bool edgeUsed[]);
+
+  // constructor
+  CyclePattern() : objAddrs {} {
+    count = 1;
+    headerInfo.nNodes = 0;
+    headerInfo.nEdges = 0;
+    headerInfo.expectRc = 0;
+    headerInfo.hasNextFlag = 0;
+    mergeCandiate = false;
+  }
+  CyclePattern(CyclePattern &master, int32_t startIndex);
+  CyclePattern &operator=(const CyclePattern&) = delete;
+  ~CyclePattern() = default;
+
+  // verify and filter
+  // Cycle pattern is valid if internal each obj's rc >= internal edge count
+  bool IsValid(bool allowExternalReference) const {
+    int8_t internalRc[kCyclepPatternMaxNodeNum];
+    int8_t internalref[kCyclepPatternMaxNodeNum]; // how many times ref other objects in cycle
+    for (int32_t i = 0; i < kCyclepPatternMaxNodeNum; ++i) {
+      internalref[i] = 0;
+    }
+    internalRc[0] = 0;
+    for (int32_t i = 1; i < NumNodes(); ++i) {
+      internalRc[i] = 1;
+      int8_t srcIndex = nodes[i].loadIndex;
+      ++internalref[srcIndex];
+    }
+
+    // accumulate rc in edges
+    for (int32_t i = 0; i < NumEdges(); ++i) {
+      int8_t destIndex = edges[i].destNodeIndex;
+      int8_t srcIndex = edges[i].srcNodeIndex;
+      ++internalRc[destIndex];
+      ++internalref[srcIndex];
+    }
+
+    for (int32_t i = 0; i < NumNodes(); ++i) {
+      if (internalref[i] == 0) {
+        // not refed in cycle
+        return false;
+      } else if (internalRc[i] > (int8_t)(kMaxRcInCyclePattern)) {
+        return false;
+      } else if (internalRc[i] == nodes[i].expectRc) {
+        continue;
+      } else if (internalRc[i] > nodes[i].expectRc) {
+        return false;
+      } else if (allowExternalReference) {
+        continue;
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // adjust cycle pattern to remove external RC
+  void AdjustForOuptut() {
+    int8_t internalRc[kCyclepPatternMaxNodeNum];
+    internalRc[0] = 0;
+    for (int32_t i = 1; i < NumNodes(); ++i) {
+      internalRc[i] = 1;
+    }
+
+    // accumulate rc in edges
+    for (int32_t i = 0; i < NumEdges(); ++i) {
+      int8_t destIndex = edges[i].destNodeIndex;
+      ++internalRc[destIndex];
+    }
+
+    headerInfo.expectRc = internalRc[0];
+    for (int32_t i = 0; i < NumNodes(); ++i) {
+      nodes[i].expectRc = internalRc[i];
+    }
+  }
+
+  // workflow
+  // Merge cycle to runtime
+  void Merge();
+  // Emit cycle to binary to buffer
+  void Emit(char *buffer, size_t limit);
+  bool IsSamePattern(int8_t index, CyclePatternInfo &cyclePatternInfo, size_t &origGctibByteSize) const;
+  bool AppendPattern(MClass *cls, int8_t index, size_t origGctibByteSize, GCTibGCInfo *origGctibInfo,
+                     const CyclePatternInfo *lastCyclePattern);
+  // Append current from index
+  bool FindAndAppendPattern(int8_t index);
+  // Find edges in current cycle
+  bool FindEdge(int8_t srcIndex, int8_t destIndex, int16_t loadOffset) const;
+  // log cycle into stream
+  void Print(ostream &os);
+
+ private:
+  CyclePatternInfo headerInfo;
+  // might add with large count for analysis
+  address_t objAddrs[kCyclepPatternMaxNodeNum];
+  CyclePatternNodeInfo nodes[kCyclepPatternMaxNodeNum];
+  CyclePatternEdgeInfo edges[kCyclepPatternMaxEdgeNum];
+  bool mergeCandiate;
+};
+
+// CycleGarbage and CyclePattern
+// CycleGarbage is collected from garbage can hold any cycles founded at runtime.
+// CyclePattern is CycleGarbage suitable added as dynamic cycle pattern at runtime.
+//
+// CyclePattern has more limitation than CycleGarbage
+// 1. limited nodes
+// 2. limited edges
+// 3. limited rcs
+// 4. limited offset
+//
+// Entire flow in self learning
+// 1. check if big data cache string is empty: last collected big data is cleared or not.
+//    1.1 if not empty, construct cycle pattern, goto 6
+//    1.2 if empty, construct cycle garbage, goto 2
+// 2. Collect CycleGarbage in garbage objects
+// 2. Filter invalid CycleGarbage (adjust rc, find out incorrect cycle)
+// 3. Add CycleGarbage into candidate set (compare and insert, write)
+// 4. Select suitable CycleGarbage and covert them into CyclePattern, goto 7
+// 5. Write information to big data
+//    5.1 suitable for merge at run time and newly merged
+//    5.2 not suitable for merge
+// 6. Create Cycle pattern from garbage objects
+// 7. Cycle pattern emit
+class GarbageNode {
+  reffield_t addr;
+  int32_t index;
+  uint32_t internalRc;
+  MClass *type;
+  bool visited;
+ public:
+  vector<pair<GarbageNode*, int32_t>> references;
+
+  GarbageNode(reffield_t paraAddr, int32_t paraIndex, MClass *paraType)
+      : addr(paraAddr), index(paraIndex), type(paraType) {
+    internalRc = 0;
+    visited = false;
+  }
+  ~GarbageNode() {
+    type = nullptr;
+  }
+  void addChild(GarbageNode &child, int32_t offset) {
+    references.push_back(make_pair(&child, offset));
+    ++child.internalRc;
+  }
+  uint32_t GetInternalRc() const {
+    return internalRc;
+  }
+  int32_t GetIndex() const {
+    return index;
+  }
+  reffield_t GetAddr() const {
+    return addr;
+  }
+  MClass *GetType() const {
+    return type;
+  }
+  bool IsVisited() const {
+    return visited;
+  }
+  void SetVisited() {
+    visited = true;
+  }
+  const vector<pair<GarbageNode*, int32_t>> &GetReferences() {
+    return references;
+  }
+
+  bool operator==(const GarbageNode &other) const;
+};
+
+class CycleGarbage {
+ public:
+  CycleGarbage() {
+    adjusted = false;
+    valid = true;
+    count = 1;
+    hashValue = 0;
+    totalEdges = 0;
+    hasDuplicateType = false;
+  }
+  ~CycleGarbage() {
+    for (auto it : nodesVec) {
+      delete it;
+    }
+  }
+  GarbageNode *AddNode(reffield_t addr, MClass *type) {
+    GarbageNode *node = new (std::nothrow) GarbageNode(addr, static_cast<int32_t>(nodesVec.size()), type);
+    if (node == nullptr) {
+      LOG(FATAL) << "new GarbageNode failed" << maple::endl;
+    }
+    nodesVec.push_back(node);
+    nodesMap[addr] = node;
+    return node;
+  }
+  bool Construct(std::vector<address_t> &sccNodeAddrs);
+  bool operator==(const CycleGarbage &other) const;
+  uint64_t Hash() const {
+    return hashValue;
+  }
+  void IncCount() {
+    ++count;
+  }
+  uint32_t Count() const {
+    return count;
+  }
+
+  // Cycle pattern Merge
+  bool ToCyclePattern(CyclePattern &cyclePattern);
+
+  // utilites
+  void AppendToString(ostringstream &oss); // content to string, for big data
+  void Print(std::ostream &os); // print into cyclelog or other file
+
+ private:
+  unordered_map<reffield_t, GarbageNode*> nodesMap;
+  vector<GarbageNode*> nodesVec;
+  bool adjusted;
+  bool valid;
+  bool hasDuplicateType;
+  uint32_t count;
+  uint32_t totalEdges;
+  uint64_t hashValue;
+
+  bool CheckAndUpdate();
+  void ComputeHash();
+  void ConstructCycle(std::vector<address_t> &sccNodeAddrs, address_t rootAddr);
+};
+
+class CyclePatternGenerator {
+ public:
+  std::vector<CycleGarbage*> resultCycles;
+  CyclePatternGenerator() = default;
+
+  ~CyclePatternGenerator() {
+    for (CycleGarbage *cycle : resultCycles) {
+      delete cycle;
+    }
+  }
+
+  void CollectCycleGarbage(vector<address_t> &sccNodes);
+  vector<CycleGarbage*> &Cycles() {
+    return resultCycles;
+  }
+};
+
+const int kPatternStaleThredhold = 50;
+const int kMaxBigdataUploadSize = 4096;
+const int kMaxBigDataCacheSize = kMaxBigdataUploadSize * 20; // means the max cache is 20 * 4k
+const int kMaxBigDataUploadStringEndSize = 3; // reserved for ; and endl
+class PatternAgeFlags {
+ public:
+  uint8_t dupThreshold;
+  bool preDefined;
+};
+class ClassCycleManager {
+ public:
+  static inline bool HasDynamicLoadPattern(MClass *cls) {
+    if (dynamicLoadedCycleClasses.find(cls) != dynamicLoadedCycleClasses.end()) {
+      return true;
+    }
+    return false;
+  }
+  static inline void AddDynamicLoadPattern(MClass *cls, bool preDfined) {
+    // call this Add, the dynamicLoadedCycleClasses[second] must be zero, so as to Has method
+    PatternAgeFlags flag;
+    flag.dupThreshold = kCyclePatternDupInitialThreshold;
+    flag.preDefined = preDfined;
+    dynamicLoadedCycleClasses[cls] = flag;
+  }
+
+  static inline void DeleteDynamicLoadPattern(MClass *cls) {
+    auto ret = dynamicLoadedCycleClasses.erase(cls);
+    if (ret == 0) {
+      LOG(FATAL) << "ClassCycleManager::DeleteDynamicLoadPattern delete zero element" << maple::endl;
+    }
+  }
+
+  static inline bool DynamicPatternTryMerge(MClass *cls) {
+    if (dynamicLoadedCycleClasses.find(cls) == dynamicLoadedCycleClasses.end()) {
+      return true;
+    }
+    PatternAgeFlags &flag = dynamicLoadedCycleClasses[cls];
+    if (flag.dupThreshold == 0) {
+      flag.dupThreshold = kCyclePatternDupInitialThreshold;
+      return true;
+    }
+    --flag.dupThreshold;
+    return false;
+  }
+
+  static inline void findDuplicate(MClass *cls) {
+    PatternAgeFlags &flag = dynamicLoadedCycleClasses[cls];
+    flag.dupThreshold = (kCyclePatternDupInitialThreshold << 1);
+  }
+
+  static inline unordered_map<MClass*, PatternAgeFlags> &GetDynamicLoadClass() {
+    return dynamicLoadedCycleClasses;
+  }
+
+  // Trim all dead patterns in dynamic laoded class
+  static void RemoveDeadPatterns();
+
+  // Dump all cycles in loaded_cycle_classes_
+  static void DumpDynamicCyclePatterns(ostream &os, size_t limit, bool dupThreshold);
+  // merge cycle patterns into runtime
+  static void MergeCycles(vector<CycleGarbage*> &cycles);
+  static bool CheckValidPattern(MClass *cls, char *buffer);
+
+  static inline string &GetPatternsCache() {
+    return patternsCache;
+  }
+
+  static bool GetRCThreshold(uint32_t &rcMax, uint32_t &rcMin, char *cyclepatternBinary);
+
+  static inline void WritePatternToCache(CyclePattern &pattern) {
+    uint32_t cacheSize = static_cast<int32_t>(patternsCache.size());
+    if (cacheSize > kMaxBigdataUploadSize) {
+      return;
+    }
+
+    ostringstream oss;
+    pattern.Print(oss);
+    const string content = oss.str();
+    if (content.size() + cacheSize > kMaxBigdataUploadSize) {
+      return;
+    }
+    patternsCache.append(content);
+  }
+
+  static inline void SetCpUpdatedFlag() {
+    cpUpdated = true;
+  }
+
+  static inline bool IsCyclePatternUpdated() {
+    return cpUpdated;
+  }
+
+ private:
+  // mapping and record object has dynmamic loaded cycle pattern
+  // <MClass*, PatternAgeFlags flags>
+  static unordered_map<MClass*, PatternAgeFlags> dynamicLoadedCycleClasses;
+  // for bigdata, volume is 4096
+  static string patternsCache;
+  // mutex between updating and dump
+  static mutex cycleMutex;
+  // recode the patterns of system has been changed or not
+  // to reduce the IO for saving patterns
+  static bool cpUpdated;
+
+  void MergeCyclePattern(CyclePattern &cyclePattern);
+};
+} // namespace maplert
+#endif // MAPLE_RUNTIME_CP_GENERATOR_H
diff --git a/src/mrt/compiler-rt/include/collector/cycle_collector.h b/src/mrt/compiler-rt/include/collector/cycle_collector.h
new file mode 100644
index 0000000000000000000000000000000000000000..feba9c5594411d1a0e61702c77b620f6b561baed
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/cycle_collector.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_CYCLECOLLECTOR_H
+#define MAPLE_RUNTIME_CYCLECOLLECTOR_H
+
+#include <cstdlib>
+#include <cstdint>
+#include <set>
+#include <unordered_map>
+#include "collector.h"
+#include "sizes.h"
+
+namespace maplert {
+// Explicitly trigger cycle collection
+const int kCyclepPatternMaxNodeNum = 12;
+const int kCyclepPatternMaxEdgeNum = 12;
+const int kCyclepMaxNum = 8;
+// from kCycleRCMaxMask to kCycleRCMaxShift
+const int kMaxRcInCyclePattern = 7;
+
+const int kCyclepPatternProfileCheckThreshold = 2000;
+const int kCyclepPatternProfileCleanThreshold = 2;
+const int kCyclepPatternProfileCancelThreshold = 6;
+const int kCyclepPatternProfileMatchCountShift = 32;
+const int kCyclepMaxOffset = 32767;
+
+// the first (possible) non-shadow reference field offset
+#ifdef USE_32BIT_REF
+const size_t kCyclepObjHeaderLength = (sizeof(reffield_t) + sizeof(uint32_t)); // shadow+monitor
+#else
+const size_t kCyclepObjHeaderLength = (sizeof(reffield_t) + sizeof(address_t)); // shadow+monitor+padding
+#endif // USE_32BIT_REF
+
+// enabled when ifndef ANDORID
+// if merge_all_cps is true, then
+// 1. fetch all garbages when DumpCycleLeak
+// 2. merge all patterns when Appending Patterns
+// 3. record the cost time of TryFreeCycleAtMutator
+extern const bool kMergeAllPatterns;
+
+struct CyclePatternNodeInfo {
+  void *expectType = nullptr; // meta, 8 bytes
+  int16_t loadOffset = 0; // load field offset
+  int8_t loadIndex = 0; // load object form index on stack
+  int8_t expectRc = 0; // rc for this field
+  int32_t flags = 0; // 4 bytes padding and flags
+};
+
+struct CyclePatternEdgeInfo {
+  int8_t srcNodeIndex = 0;
+  int8_t destNodeIndex = 0;
+  int16_t loadOffset = 0;
+  int32_t flags = 0; // 4 bytes padding and flags
+};
+
+struct CyclePatternInfo {
+  int8_t nNodes = 0;
+  int8_t nEdges = 0;
+  int8_t expectRc = 0;
+  int8_t hasNextFlag = 0;
+  int8_t invalidated = kCycleValid; // is this pattern valid, invalidate at match time
+  int8_t duplicateCount = 0; // how many time duplicated in self study
+  int16_t matchCount = 0; // positive means ok, negative mean abandond time
+  uint64_t matchProfiling = 0;
+};
+
+static inline CyclePatternInfo *GetCyclePatternInfo(GCTibGCInfo &gctibInfo) {
+  CyclePatternInfo *res = reinterpret_cast<CyclePatternInfo*>(
+      (reinterpret_cast<char*>(&gctibInfo)) + ((gctibInfo.nBitmapWords + 1) * kDWordBytes));
+  return res;
+}
+
+static inline size_t GetCyclePatternSize(const CyclePatternInfo &info) {
+  size_t size = sizeof(CyclePatternInfo);
+  size += sizeof(CyclePatternNodeInfo) * info.nNodes;
+  size += sizeof(CyclePatternEdgeInfo) * info.nEdges;
+  // align pattern with 8 bytes
+  size_t rem = reinterpret_cast<size_t>(size) % kDWordBytes;
+  if (rem != 0) {
+    size += (kDWordBytes - rem);
+  }
+  return size;
+}
+
+static inline CyclePatternInfo *GetNextCyclePattern(CyclePatternInfo &info) {
+  if (info.hasNextFlag == 0) {
+    return nullptr;
+  }
+  char *res = reinterpret_cast<char*>(&info);
+  res += sizeof(CyclePatternInfo);
+  res += sizeof(CyclePatternNodeInfo) * info.nNodes;
+  res += sizeof(CyclePatternEdgeInfo) * info.nEdges;
+  // align pattern with 8 bytes
+  size_t rem = reinterpret_cast<uintptr_t>(res) % kDWordBytes;
+  if (rem != 0) {
+    res += (kDWordBytes - rem);
+  }
+  return reinterpret_cast<CyclePatternInfo*>(res);
+}
+
+static inline CyclePatternNodeInfo *GetCyclePatternNodeInfo(CyclePatternInfo &info) {
+  return reinterpret_cast<CyclePatternNodeInfo*>((reinterpret_cast<char*>(&info)) + sizeof(CyclePatternInfo));
+}
+
+static inline CyclePatternEdgeInfo *GetCyclePatternEdgeInfo(CyclePatternInfo &info) {
+  return reinterpret_cast<CyclePatternEdgeInfo*>(
+      (reinterpret_cast<char*>(&info)) + sizeof(CyclePatternInfo) + sizeof(CyclePatternNodeInfo) * info.nNodes);
+}
+
+string MRT_CyclePatternValidityStr(int validStatus);
+
+class CycleCollector {
+ public:
+  CycleCollector() = default;
+  ~CycleCollector() = default;
+
+  static bool TryFreeCycleAtMutator(address_t obj, uint32_t rootDelta, bool isRefProcess);
+
+ private:
+  static bool MatchNodes(address_t stack[], CyclePatternNodeInfo &infos, int32_t nNodes, bool &hasFinal,
+                         bool isRefProcess, uint32_t expectRC[]);
+  static bool MatchEdges(const address_t stack[], CyclePatternEdgeInfo &infos, int32_t nNodes, int32_t nEdges);
+  static bool CheckStackColorGray(const address_t stack[], int32_t nNodes, bool weakCollectedSet[],
+                                  const uint32_t expectRC[]);
+  static void ReleaseCycleObjects(const address_t stack[],
+                                  CyclePatternNodeInfo &nInfos, int32_t nNodes,
+                                  CyclePatternEdgeInfo &eInfos, int32_t nEdges,
+                                  const bool weakCollectedSet[]);
+  static void FinalizeCycleObjects(const address_t stack[], int32_t nNodes, const bool weakCollectedSet[]);
+  static bool CheckAndReleaseCycle(address_t obj, uint32_t rootDelta, bool isRefProcess,
+                                   CyclePatternInfo &cyclePatternInfo, CyclePatternInfo *prevPattern);
+};
+
+string GetSoNameFromCls(const MClass *elementClass);
+}
+
+#endif
diff --git a/src/mrt/compiler-rt/include/collector/gc_reference_processor.h b/src/mrt/compiler-rt/include/collector/gc_reference_processor.h
new file mode 100644
index 0000000000000000000000000000000000000000..d27f0c4a6e3b0a6b7f2b7ddc3cf81c5f9b222827
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/gc_reference_processor.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_COMPILER_RT_GC_REFERENCE_PROCESSOR_H
+#define MAPLE_COMPILER_RT_GC_REFERENCE_PROCESSOR_H
+
+#include <mutex>
+#include "address.h"
+#include "sizes.h"
+#include "rp_base.h"
+
+namespace maplert {
+struct GCRefContext {
+  std::mutex discoverLock;
+  address_t discoverRefs; // Discover list
+  address_t enqueueRefs; // enqueue list
+  uint32_t discoverCount;
+  uint32_t enqueueCount;
+};
+
+class GCReferenceProcessor : public ReferenceProcessor {
+ public:
+  static inline GCReferenceProcessor &Instance() {
+    return static_cast<GCReferenceProcessor&>(ReferenceProcessor::Instance());
+  }
+  GCReferenceProcessor();
+  ~GCReferenceProcessor() = default;
+  void DiscoverReference(address_t reference);
+  void ProcessDiscoveredReference(uint32_t flags);
+  void VisitGCRoots(RefVisitor &visitor) override;
+  void ConcurrentProcessDisovered();
+  void InitEnqueueAtFork(uint32_t type, address_t refs);
+ protected:
+  bool ShouldStartIteration() override;
+  void LogRefProcessorBegin() override;
+  void LogRefProcessorEnd() override;
+ private:
+  void PreAddFinalizables(address_t obj[], uint32_t count, bool needLock) override;
+  void PostAddFinalizables(address_t obj[], uint32_t count, bool needLock) override;
+  void EnqeueReferences() override;
+  GCRefContext refContext[kRPPhantomRef + 1]; // weak/soft/phantom has index 0,1,2
+};
+}
+#endif // MAPLE_COMPILER_RT_REFERENCE_PROCESSOR_H
diff --git a/src/mrt/compiler-rt/include/collector/mpl_thread_pool.h b/src/mrt/compiler-rt/include/collector/mpl_thread_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8c8dc73e25f02999c33689bc6186fe7cb903f40
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/mpl_thread_pool.h
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_COMPILER_RT_THREAD_POOL_H
+#define MRT_COMPILER_RT_THREAD_POOL_H
+
+#include <pthread.h>
+#include <atomic>
+#include <queue>
+#include <functional>
+#include <mutex>
+#include <condition_variable>
+#include <vector>
+
+// thread pool implementation
+namespace maplert {
+class MplTask {
+ public:
+  MplTask() = default;
+  virtual ~MplTask() = default;
+  virtual void Execute(size_t threadId) = 0;
+};
+
+
+class MplLambdaTask : public MplTask {
+ public:
+  explicit MplLambdaTask(const std::function<void(size_t)> &function) : func(function) {}
+  ~MplLambdaTask() = default;
+  void Execute(size_t threadId) override {
+    func(threadId);
+  }
+ private:
+  std::function<void(size_t)> func;
+};
+
+class MplThreadPool;
+
+class MplPoolThread {
+ public:
+  // use for profiling
+  std::vector<int32_t> *schedCores;
+
+  MplPoolThread(MplThreadPool *threadPool, const char *threadName, size_t threadId, size_t stackSize);
+  ~MplPoolThread();
+
+  void SetPriority(int32_t prior);
+
+  // get pthread of thread
+  pthread_t GetThread() const {
+    return pthread;
+  }
+
+  // get thread id of thread
+  pid_t GetTid() const {
+    return tid;
+  }
+
+  static void *WorkerFunc(void *param);
+
+ private:
+  size_t id;
+  pthread_t pthread;
+  pid_t tid;
+  std::string name;
+  MplThreadPool *pool;
+};
+
+
+// manual
+// new  (SetMaxActiveThreadNum(optional) addTask  startPool waitFinish)^. Exit delete
+// if need to change MaxActiveThreadNum, should waitFinish or stop pool at first
+class MplThreadPool {
+ public:
+  // Constructor for thread pool, 1) Create threads, 2) wait all thread created & sleep
+  // name is the thread pool name. thread name = Pool_$(poolname)_ThreadId_$(threadId)
+  // maxThreadNum is the max thread number in pool.
+  // prior is the priority of threads in pool.
+  MplThreadPool(const char *name, int32_t maxThreadNum, int32_t prior);
+
+  // Destructor for thread pool, 1) close pool 2) wait thread in pool to exit, 3) release resources of class
+  ~MplThreadPool();
+
+  // Set priority of each thread in pool.
+  void SetPriority(int32_t prior);
+
+  // Set max active thread number of pool, redundant thread hangup in sleep condition var.
+  // notify more waitting thread get to work when pool is running.
+  // Range [1 - maxThreadNum].
+  void SetMaxActiveThreadNum(int32_t num);
+
+  // Get max active thread number of pool.
+  int32_t GetMaxActiveThreadNum() const {
+    return maxActiveThreadNum;
+  }
+
+  // Get max thread number of pool, defalut = maxThreadNum.
+  int32_t GetMaxThreadNum() const {
+    return maxThreadNum;
+  }
+
+  // Add new task to task queue , task should inherit from MplTask.
+  void AddTask(MplTask *task);
+
+  // Add task to thread , func indicate Lambda statement.
+  void AddTask(std::function<void(size_t)> func);
+
+  // Start thread pool, notify all sleep threads to get to work
+  void Start();
+
+  // Wait all task in task queue finished, if pool stopped, only wait until current excuting task finish
+  // after all task finished, stop pool
+  // addToExecute indicate whether the caller thread excute task
+  void WaitFinish(bool addToExecute, std::vector<int32_t> *schedCores = nullptr);
+
+  // used in none-parallel concurrent mark
+  void DrainTaskQueue();
+
+  // Notify & Wait all thread waitting for task to sleep
+  void Stop();
+
+  // Notify all thread in pool to exit , notify all waitFinish thread to return,nonblock ^.
+  void Exit();
+
+  // Remove all task in task queue
+  void ClearAllTask();
+
+  // Get task count in queue
+  size_t GetTaskNumber() {
+    std::unique_lock<std::mutex> taskLock(taskMutex);
+    return taskQueue.size();
+  }
+
+  // Get all MplPoolThread in pool
+  const std::vector<MplPoolThread*> &GetThreads() const {
+    return threads;
+  }
+
+ private:
+  // thread default stack size 512 KB.
+  static const size_t kDefaultStackSize = (512 * 1024);
+  int32_t priority;
+
+  std::string name;
+  // pool stop or running state
+  std::atomic<bool> running;
+  // is pool exit
+  std::atomic<bool> exit;
+  // all task put in task queue
+  std::queue<MplTask*> taskQueue;
+
+  // active thread 0 ..... maxActiveThreadNum .....maxThreadNum
+  // max thread number in pool
+  int32_t maxThreadNum;
+
+  // max active thread number, redundant thread hang up in threadSleepingCondVar
+  int32_t maxActiveThreadNum;
+
+  // current active thread, when equals to zero, no thread running, all thread slept
+  int32_t currActiveThreadNum;
+
+  // current waitting thread, when equals to currActiveThreadNum
+  // no thread excuting, all task finished
+  int32_t currWaittingThreadNum;
+
+  // single lock
+  std::mutex taskMutex;
+
+  // hangup when no task available
+  std::condition_variable taskEmptyCondVar;
+
+  // hangup when to much active thread or pool stopped
+  std::condition_variable threadSleepingCondVar;
+
+  // hangup when there is thread excuting
+  std::condition_variable allWorkDoneCondVar;
+
+  // hangup when there is thread active
+  std::condition_variable allThreadStopped;
+
+  // use for profiling
+  std::vector<MplPoolThread*> threads;
+
+  // is pool running or stopped
+  bool IsRunning() const {
+    return running.load(std::memory_order_relaxed);
+  }
+
+  bool IsExited() const {
+    return exit.load(std::memory_order_relaxed);
+  }
+
+  friend class MplPoolThread;
+};
+} // namespace maplert
+
+#endif // MRT_COMPILER_RT_THREAD_POOL_H
diff --git a/src/mrt/compiler-rt/include/collector/mrt_bitmap.h b/src/mrt/compiler-rt/include/collector/mrt_bitmap.h
new file mode 100644
index 0000000000000000000000000000000000000000..48a0fabb1506752b9bd0e22c32deeba4a8bca794
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/mrt_bitmap.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MRT_BITMAP_H
+#define MAPLE_RUNTIME_MRT_BITMAP_H
+
+#include <atomic>
+#include <sys/mman.h>
+#include "mm_utils.h" // address_t
+
+// set 1 to enable bitmap debug functions
+#define MRT_DEBUG_BITMAP 0
+namespace maplert {
+// kLogObjAlignment == 4 indicates 2^4(16) bytes per bit in bitmap
+static constexpr size_t kLogObjAlignment = 4;
+static constexpr size_t kLogBitsPerByte = 3; // 8 bit per byte
+static constexpr size_t kLogBytesPerWord = 2; // 4 byte per word
+static constexpr size_t kLogBitsPerWord = kLogBitsPerByte + kLogBytesPerWord;
+
+static constexpr size_t kBitsPerWord = sizeof(uint32_t) * 8; // 8 bits per byte.
+
+
+class MrtBitmap {
+ public:
+  MrtBitmap() : spaceStart(0), spaceEnd(0), curEnd(0), isInitialized(false), bitmapBegin(nullptr), bitmapSize(0) {}
+  ~MrtBitmap();
+  // for initialization
+  bool Initialized() const {
+    return isInitialized;
+  }
+
+  void Initialize();
+  void ResetCurEnd();
+  ALWAYS_INLINE void ResetBitmap() {
+    if (bitmapBegin != nullptr) {
+#ifdef __ANDROID__
+      int result = madvise(bitmapBegin, bitmapSize, MADV_DONTNEED);
+      if (result != 0) {
+        LOG(WARNING) << "ResetBitmap madvise failed";
+        size_t curBitmapSize = GetBitmapSizeByHeap(curEnd - spaceStart);
+        (void)memset_s(reinterpret_cast<void*>(bitmapBegin), curBitmapSize, 0, curBitmapSize);
+      }
+#else
+      // use memset on qemu
+      size_t curBitmapSize = GetBitmapSizeByHeap(curEnd - spaceStart);
+      (void)memset_s(reinterpret_cast<void*>(bitmapBegin), curBitmapSize, 0, curBitmapSize);
+#endif
+    }
+  }
+
+  // return true if object already marked, false if unmarked
+  ALWAYS_INLINE bool MarkObject(address_t addr) {
+    uint32_t lineIndex;
+    uint32_t bitMask;
+    GetLocation(addr, lineIndex, bitMask);
+    std::atomic<uint32_t> *line = bitmapBegin + lineIndex;
+
+    uint32_t old = line->fetch_or(bitMask, std::memory_order_relaxed);
+    return ((old & bitMask) != 0);
+  }
+
+  ALWAYS_INLINE bool IsObjectMarked(address_t addr) const {
+    uint32_t lineIndex;
+    uint32_t bitMask;
+    GetLocation(addr, lineIndex, bitMask);
+    std::atomic<uint32_t> *line = bitmapBegin + lineIndex;
+    uint32_t word = line->load(std::memory_order_relaxed);
+    return (word & bitMask) != 0;
+  }
+
+#if MRT_DEBUG_BITMAP
+  // copy from another bitmap, for debug purpose.
+  void CopyBitmap(const BitMap &bitmap);
+
+  // size in bytes, just for debug purpose.
+  inline size_t Size() const {
+    return bitmapSize;
+  }
+
+  // data as an uint32_t array, for debug purpose.
+  inline const uint32_t *Data() const {
+    return reinterpret_cast<uint32_t*>(bitmapBegin);
+  }
+#endif
+
+ private:
+  ALWAYS_INLINE bool AddrInRange(address_t addr) const {
+    return (addr >= spaceStart) && (addr <= spaceEnd);
+  }
+
+  ALWAYS_INLINE void CheckAddr(address_t addr) const {
+    if (UNLIKELY(!AddrInRange(addr))) {
+      LOG(FATAL) << "invalid object address." << " addr:" << std::hex << addr << " spaceStart:" << spaceStart <<
+          " curEnd:" << curEnd << " spaceEnd:" << spaceEnd << std::dec << maple::endl;
+    }
+  }
+
+  // round value up to alignValue
+  uint32_t AlignRight(uint32_t value, uint32_t alignValue) const noexcept;
+  size_t GetBitmapSizeByHeap(size_t heapBytes);
+
+  // get index in the bitmap array and bit mask in the word.
+  ALWAYS_INLINE void GetLocation(address_t addr, uint32_t &lineIndex, uint32_t &bitMask) const {
+#if MRT_DEBUG_BITMAP
+    CheckAddr(addr);
+#endif
+    uint32_t offset = static_cast<uint32_t>(addr - spaceStart);
+
+    // lower bitmap word in the bitmapWords array encodes lower address
+    lineIndex = (offset >> kLogBitsPerWord) >> kLogObjAlignment;
+
+    // higher bits in each word encodes lower address
+    unsigned int bitIndex = kBitsPerWord - 1 - ((offset >> kLogObjAlignment) & (kBitsPerWord - 1));
+    bitMask = static_cast<uint32_t>(1) << bitIndex;
+  }
+
+  // the start and end of memory space covered by the bitmap.
+  address_t spaceStart;
+  address_t spaceEnd;
+  address_t curEnd;
+  bool isInitialized;
+  std::atomic<uint32_t> *bitmapBegin;
+  size_t bitmapSize;
+};
+}  // namespace maplert
+
+#endif // MAPLE_RUNTIME_MRT_BITMAP_H
diff --git a/src/mrt/compiler-rt/include/collector/native_gc.h b/src/mrt/compiler-rt/include/collector/native_gc.h
new file mode 100644
index 0000000000000000000000000000000000000000..e3c028470d6ae994ac4b713d28dc594de55f20ff
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/native_gc.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVEGC_H
+#define MAPLE_RUNTIME_NATIVEGC_H
+
+#include <cstdlib>
+#include <atomic>
+#include <ratio>
+
+#include "globals.h"
+#include "mm_config.h"
+#include "gc_log.h"
+
+// Define Native Trigger GC model and data structure.
+namespace maplert {
+const uint32_t kDefaultNativeEpochSeconds = 15;
+const uint32_t kEpochSecondRatio = 1000; // set ratio to 1000
+// Record Native GC Epoch to determin if trigger GC or RP
+class NativeEpochStats {
+ public:
+  NativeEpochStats() {
+    Init();
+  }
+  ~NativeEpochStats() = default;
+  // Used in PostForChild
+  void SetEpochInterval(uint32_t seconds) {
+    Init(seconds);
+  }
+
+  void CheckNativeGC();
+
+  static inline NativeEpochStats &Instance() {
+    return instance;
+  }
+
+  bool isEnabled() const {
+    return epochInterval > 0;
+  }
+
+  void Init(uint32_t epochSeconds = kDefaultNativeEpochSeconds);
+ private:
+  static constexpr float kEpochGCEagerDeltaRatio = 1.4;
+  static constexpr float kEpochGCDeltaRatio = 1.2;
+  static constexpr float kEpochRPDeltaRatio = 1.1;
+  __attribute__((visibility("default"))) static NativeEpochStats instance;
+  // only RP thread will check and update these values, no need atomic
+  size_t epochMin;
+  size_t epochMax;
+  size_t epochTotal;
+
+  size_t curGCWatermark;
+  size_t curRPWatermark;
+
+  uint32_t epochInterval;
+  uint32_t curEpochIndex;
+
+  bool RPTriggered;
+  bool logNativeInfo;
+};
+
+class NativeGCStats {
+ public:
+  typedef std::ratio<11, 20> NativeDiscountRatio; // native bytes discount ratio when compared with java bytes
+  static constexpr float kSkipNativeGcFactor = 0.0;
+  static constexpr float kTriggerNativeGcFactor = 1.0;
+  static constexpr float kWaitNativeGcFactor = 4.0;
+  static constexpr size_t kHugeNativeBytes = 1 * maple::GB;
+  static constexpr size_t kOldDiscountFactor = 65536;
+  static constexpr size_t kNativeWatermarkExtra = 2 * maple::MB;
+  static constexpr size_t kNativeWatermarkFactor = 8;
+  static constexpr size_t kCheckInterval = 32;
+  static constexpr size_t kCheckBytesThreshold = 300000;
+  static constexpr double kFrontgroundGrowthRate = 3.0;
+  static constexpr double kBackgroundGrowthRate = 1.0;
+
+  size_t GetNativeBytes();
+
+  static inline NativeGCStats &Instance() {
+    return instance;
+  }
+
+  void SetIsEpochBasedTrigger(bool isEpochBased) {
+    isEpochBasedTrigger.store(isEpochBased, std::memory_order_relaxed);
+    NativeEpochStats::Instance().Init(isEpochBased ? kDefaultNativeEpochSeconds : 0);
+  }
+
+  void NotifyNativeAllocation() {
+    if (isEpochBasedTrigger.load(std::memory_order_relaxed)) {
+      return;
+    }
+    nativeObjectNotified.fetch_add(kCheckInterval, std::memory_order_relaxed);
+    CheckForGC();
+  }
+
+  void RegisterNativeAllocation(size_t bytes) {
+    if (isEpochBasedTrigger.load(std::memory_order_relaxed)) {
+      return;
+    }
+    nativeBytesRegistered.fetch_add(bytes, std::memory_order_relaxed);
+    size_t objectsNotified = nativeObjectNotified.fetch_add(1, std::memory_order_relaxed);
+    if (UNLIKELY((objectsNotified % kCheckInterval) + 1 == kCheckInterval || bytes > kCheckBytesThreshold)) {
+      CheckForGC();
+    }
+  }
+
+  void RegisterNativeFree(size_t bytes) {
+    if (isEpochBasedTrigger.load(std::memory_order_relaxed)) {
+      return;
+    }
+    size_t allocated = nativeBytesRegistered.load(std::memory_order_relaxed);
+    size_t newFreedBytes;
+    do {
+      newFreedBytes = std::min(allocated, bytes);
+    } while (!nativeBytesRegistered.compare_exchange_weak(allocated, allocated - newFreedBytes));
+  }
+
+  // should be called after GC finished.
+  void OnGcFinished() {
+    // update native bytes allocated.
+    const size_t nativeBytes = GetNativeBytes();
+    oldNativeBytesAllocated.store(nativeBytes, std::memory_order_relaxed);
+    LOG2FILE(kLogtypeGc) << "Native bytes updated to " << nativeBytes << '\n';
+  }
+
+ private:
+  __attribute__((visibility("default"))) static NativeGCStats instance;
+  std::atomic<bool> isEpochBasedTrigger = { false };
+  std::atomic<size_t> nativeBytesRegistered = { 0 };
+  std::atomic<size_t> nativeObjectNotified = { 0 };
+  std::atomic<size_t> oldNativeBytesAllocated = { 0 };
+
+  void CheckForGC();
+  float NativeGcFactor(size_t currentNativeBytes);
+};
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_NATIVEGC_H
diff --git a/src/mrt/compiler-rt/include/collector/rc_inline.h b/src/mrt/compiler-rt/include/collector/rc_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..f838f380e6fc9ec5a9d7eabcd6bd90ffeb443a7a
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/rc_inline.h
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_RC_INLINE_H
+#define MAPLE_RUNTIME_RC_INLINE_H
+
+#include "sizes.h"
+
+namespace maplert {
+static void inline HandleRCError(address_t obj) {
+  AbortWithHeader(obj);
+}
+
+template<int32_t strongRCDelta, bool updateColor>
+static inline uint32_t GetNewRCHeaderStrong(uint32_t header) {
+  static_assert(strongRCDelta == 1 || strongRCDelta == -1 || strongRCDelta == 0, "Invalid strong rc delta");
+  if (strongRCDelta == 0) {
+    return header;
+  }
+  uint32_t newHeader = static_cast<uint32_t>((static_cast<int32_t>(header)) + strongRCDelta);
+  if (updateColor) {
+    uint32_t color = (strongRCDelta > 0) ? kRCCycleColorBlack : kRCCycleColorBrown;
+    newHeader = (newHeader & ~kRCCycleColorMask) | color;
+  }
+  return newHeader;
+}
+
+template<int32_t weakRCDelta>
+static inline uint32_t GetNewRCHeaderWeak(uint32_t header) {
+  static_assert(weakRCDelta == 1 || weakRCDelta == -1 || weakRCDelta == 0, "Invalid weak rc delta");
+  if (weakRCDelta == 0) {
+    return header;
+  }
+  uint32_t weakRC = GetWeakRCFromRCHeader(header);
+  if (weakRC == kMaxWeakRC) {
+    return header;
+  }
+
+  weakRC = static_cast<uint32_t>((static_cast<int32_t>(weakRC)) + weakRCDelta);
+  uint32_t newHeader = header & ~kWeakRcBits;
+  newHeader |= ((weakRC << kWeakRcBitsShift) & kWeakRcBits);
+  return newHeader;
+}
+
+template<int32_t resurrectWeakRCDelta>
+static inline uint32_t GetNewRCHeaderResurrectWeak(uint32_t header) {
+  static_assert(resurrectWeakRCDelta == 1 || resurrectWeakRCDelta == -1 || resurrectWeakRCDelta == 0,
+                "Invalid weak rc delta");
+  if (resurrectWeakRCDelta == 0) {
+    return header;
+  }
+  uint32_t resurrectWeakRC = GetResurrectWeakRCFromRCHeader(header);
+  if (resurrectWeakRC == kMaxResurrectWeakRC) {
+    return header;
+  }
+
+  resurrectWeakRC =
+      static_cast<uint32_t>((static_cast<int32_t>(resurrectWeakRC)) + resurrectWeakRCDelta);
+  uint32_t newHeader = header & ~kResurrectWeakRcBits;
+  newHeader |= ((resurrectWeakRC << KResurrectWeakRcBitsShift) & kResurrectWeakRcBits);
+  return newHeader;
+}
+
+// Update reference count non-atomically:
+// 1. During backup tracing STW time
+// 2. Or for non-escaped objects
+// No color update needed, because no racing with cycle pattern in above scenario
+template<int32_t strongRCDelta, int32_t weakRCDelta, int32_t resurrectWeakRCDelta>
+static inline uint32_t UpdateRC(address_t objAddr) {
+  uint32_t oldHeader = RCHeader(objAddr);
+  StatsRCOperationCount(objAddr);
+  if (UNLIKELY(SkipRC(oldHeader))) {
+    return oldHeader;
+  }
+  uint32_t newHeader = GetNewRCHeaderStrong<strongRCDelta, false>(oldHeader);
+  newHeader = GetNewRCHeaderWeak<weakRCDelta>(newHeader);
+  newHeader = GetNewRCHeaderResurrectWeak<resurrectWeakRCDelta>(newHeader);
+  RefCountLVal(objAddr) = newHeader;
+  return oldHeader;
+}
+
+// Update reference count atomically:
+// 1. Mutator update RC
+// 2. Backup tracing: parallel/concurrent sweep
+template<int32_t strongRCDelta, int32_t weakRCDelta, int32_t resurrectWeakRCDelta>
+static inline uint32_t AtomicUpdateRC(address_t objAddr) {
+  std::atomic<uint32_t> &headerAtomic = RefCountAtomicLVal(objAddr);
+  uint32_t oldHeader = headerAtomic.load();
+  uint32_t newHeader = 0;
+
+  do {
+    StatsRCOperationCount(objAddr);
+    if (UNLIKELY(SkipRC(oldHeader))) {
+      return oldHeader;
+    }
+    newHeader = GetNewRCHeaderStrong<strongRCDelta, true>(oldHeader);
+    newHeader = GetNewRCHeaderWeak<weakRCDelta>(newHeader);
+    newHeader = GetNewRCHeaderResurrectWeak<resurrectWeakRCDelta>(newHeader);
+  } while (!headerAtomic.compare_exchange_weak(oldHeader, newHeader));
+  return oldHeader;
+}
+
+// Check what to do next after Dec
+// 1. Release object if:
+//    1.1 weak collected bit is set, and all rc is zero
+//    1.2 weak collected bit is not set and only weak rc is 1, strong rc and resurrect weak rc is 0
+// 2. Collected object weak rc if:
+//    2.1 weak collected bit is not set and strong rc and resurrect rc is 0
+static constexpr uint32_t kReleaseObject = 0x0;
+static constexpr uint32_t kCollectedWeak = 0x1;
+static constexpr uint32_t kNotRelease = 0x2;
+template<int32_t strongRCDelta, int32_t weakRCDelta, int32_t resurrectWeakRCDelta>
+static inline uint32_t CanReleaseObj(uint32_t oldHeader) {
+  static_assert(strongRCDelta + weakRCDelta + resurrectWeakRCDelta == -1, "only one with -1");
+  static_assert(strongRCDelta * weakRCDelta * resurrectWeakRCDelta == 0, "only one with -1");
+  uint32_t oldRC = oldHeader & (kWeakCollectedBit | kWeakRcBits | kResurrectWeakRcBits | kRCBits);
+  if (strongRCDelta != 0) {
+    // old header is strong rc = 1, resurrect weak rc = 0, weak rc = 0 and collected bit set
+    if ((oldRC == (1 + kWeakRCOneBit)) || (oldRC == (1 + kWeakCollectedBit))) {
+      return kReleaseObject;
+    } else if ((oldHeader & (kWeakCollectedBit | kResurrectWeakRcBits | kRCBits)) == 1) {
+      return kCollectedWeak;
+    }
+  } else if (weakRCDelta != 0) {
+    if ((oldRC == (kWeakRCOneBit + kWeakRCOneBit)) || (oldRC == (kWeakRCOneBit + kWeakCollectedBit))) {
+      return kReleaseObject;
+    }
+  } else {
+    // Dec resurrect weak rc
+    if (oldRC == (kResurrectWeakOneBit + kWeakRCOneBit) || oldRC == (kResurrectWeakOneBit + kWeakCollectedBit)) {
+      return kReleaseObject;
+    } else if ((oldHeader & (kWeakCollectedBit | kResurrectWeakRcBits | kRCBits)) == kResurrectWeakOneBit) {
+      return kCollectedWeak;
+    }
+  }
+  return kNotRelease;
+}
+
+template<int32_t strongRCDelta, int32_t weakRCDelta, int32_t resurrectWeakRCDelta, bool checkWeakCollected = true>
+static inline uint32_t AtomicDecRCAndCheckRelease(address_t objAddr, uint32_t &releaseState) {
+  static_assert(strongRCDelta == -1 || strongRCDelta == 0, "Invalid dec rc delta");
+  static_assert(weakRCDelta == -1 || weakRCDelta == 0, "Invalid dec rc delta");
+  static_assert(resurrectWeakRCDelta == -1 || resurrectWeakRCDelta == 0, "Invalid dec rc delta");
+  static_assert(strongRCDelta == -1 || weakRCDelta == -1 || resurrectWeakRCDelta == -1, "must have one -1");
+  std::atomic<uint32_t> &headerAtomic = RefCountAtomicLVal(objAddr);
+  uint32_t oldHeader = headerAtomic.load();
+  uint32_t newHeader = 0;
+
+  do {
+    StatsRCOperationCount(objAddr);
+    releaseState = kNotRelease;
+    if (UNLIKELY(SkipRC(oldHeader))) {
+      return oldHeader;
+    }
+    newHeader = GetNewRCHeaderStrong<strongRCDelta, true>(oldHeader);
+    newHeader = GetNewRCHeaderWeak<weakRCDelta>(newHeader);
+    newHeader = GetNewRCHeaderResurrectWeak<resurrectWeakRCDelta>(newHeader);
+    // update release state
+    // release: weak rc is 1, resurrect and strong rc and weak collected bit not set
+    //          weak rc is 0, resurrect and strong rc and weak collected bit set
+    if (IsWeakCollectedFromRCHeader(newHeader)) {
+      if (GetTotalRCFromRCHeader(newHeader) == 0) {
+        releaseState = kReleaseObject;
+      }
+    } else {
+      if (GetTotalRCFromRCHeader(newHeader) == kWeakRCOneBit) {
+        releaseState = kReleaseObject;
+      } else if (checkWeakCollected && (newHeader & (kRCBits | kResurrectWeakRcBits)) == 0) {
+        releaseState = kCollectedWeak;
+        newHeader = newHeader | kWeakCollectedBit;
+      }
+    }
+  } while (!headerAtomic.compare_exchange_weak(oldHeader, newHeader));
+  return oldHeader;
+}
+
+template<int32_t strongRCDelta, int32_t weakRCDelta, int32_t resurrectWeakRCDelta>
+static inline bool IsInvalidDec(uint32_t oldHeader) {
+  static_assert(strongRCDelta + weakRCDelta + resurrectWeakRCDelta == -1, "only one with -1");
+  static_assert(strongRCDelta * weakRCDelta * resurrectWeakRCDelta == 0, "only one with -1");
+  if (IsRCOverflow(oldHeader)) {
+    return false;
+  }
+  if (strongRCDelta != 0) {
+    return (oldHeader & kRCBits) == 0;
+  } else if (weakRCDelta != 0) {
+    return (oldHeader & kWeakRcBits) == 0;
+  }
+  return (oldHeader & kResurrectWeakRcBits) == 0;
+}
+
+// Update color atomically:
+// 1. Cycle pattern match
+static inline uint32_t AtomicUpdateColor(address_t objAddr, uint32_t color) {
+  std::atomic<uint32_t> &headerAtomic = RefCountAtomicLVal(objAddr);
+  uint32_t oldHeader = headerAtomic.load();
+  uint32_t newHeader = 0;
+
+  do {
+    StatsRCOperationCount(objAddr);
+    if (UNLIKELY(SkipRC(oldHeader))) {
+      return oldHeader;
+    }
+    newHeader = (oldHeader & ~kRCCycleColorMask) | color;
+  } while (!headerAtomic.compare_exchange_weak(oldHeader, newHeader));
+  return oldHeader;
+}
+
+static inline bool TryAtomicIncStrongRC(address_t objAddr) {
+  std::atomic<uint32_t> &headerAtomic = RefCountAtomicLVal(objAddr);
+  uint32_t oldHeader = headerAtomic.load();
+  uint32_t newHeader = 0;
+
+  do {
+    StatsRCOperationCount(objAddr);
+    if (UNLIKELY(SkipRC(oldHeader))) {
+      return true;
+    }
+    if (UNLIKELY(GetRCFromRCHeader(oldHeader) == 0)) {
+      return false;
+    }
+    newHeader = GetNewRCHeaderStrong<1, true>(oldHeader);
+  } while (!headerAtomic.compare_exchange_weak(oldHeader, newHeader));
+  return true;
+}
+
+// RC Java Reference and Weak Global processing
+// Operatoins
+// 1. Collect:
+//    1.1. weak rc == strong rc is equal, set weak collected bit
+//    1.2. weak rc == (strong rc - matched cycle rc), set weak collected bit
+//    1.3. If weak collected bit is set, perform clearAndEnqueue/clear WGRT
+// 2. Process finalizable
+//    2.1 add finalizable queue
+//    2.2 clear weak collected bit: object is resurrected
+// 3. Get
+//    If weak collected bit is on, Reference.get and Weak Global.get return null
+//
+// delta is used in cycle collect for referent
+// 1. when process reference: check cycle with rc (rc-weakrc)
+// 2. if match, invoke AtomicCheckWeakCollectable(obj, rc-weakrc)
+// no overflow/skipRC check! should be handled by caller!
+template<bool checkResurrectWeak>
+static inline bool AtomicCheckWeakCollectable(address_t objAddr, uint32_t delta) {
+  std::atomic<uint32_t> &headerAtomic = RefCountAtomicLVal(objAddr);
+  uint32_t oldHeader = headerAtomic.load();
+  uint32_t newHeader = 0;
+
+  do {
+    if (IsWeakCollectedFromRCHeader(oldHeader)) {
+      return false;
+    }
+    uint32_t strongRC = GetRCFromRCHeader(oldHeader);
+    if (strongRC != delta) {
+      return false;
+    }
+    if (checkResurrectWeak) {
+      if (oldHeader & kResurrectWeakRcBits) {
+        return false;
+      }
+    }
+    newHeader = oldHeader | kWeakCollectedBit;
+  } while (!headerAtomic.compare_exchange_weak(oldHeader, newHeader));
+  return true;
+}
+
+// invoked in reference processor thread or muator thread
+// 1. reference process clear kWeakCollectedBit for finalizable
+// 2. mutator set obj as referent again and need clear corrsponding bit
+// no overflow/skipRC check! should be handled by caller!
+static inline void AtomicClearWeakCollectable(address_t objAddr) {
+  std::atomic<uint32_t> &headerAtomic = RefCountAtomicLVal(objAddr);
+  uint32_t oldHeader = headerAtomic.load();
+  uint32_t newHeader = 0;
+  do {
+    if (!(oldHeader & kWeakCollectedBit)) {
+      return;
+    }
+    newHeader = oldHeader & (~kWeakCollectedBit);
+  } while (!headerAtomic.compare_exchange_weak(oldHeader, newHeader));
+  return;
+}
+
+// Load and inc Referent, load can from
+// 1. Weak Global.get
+// 2. SoftReference.get
+// 3. WeakReference.get
+//
+// If object 1) has no weak rc 2) weak collected bit set return 0
+// Otherwise, try inc weak rc
+template<bool incWeak>
+static inline address_t AtomicIncLoadWeak(address_t objAddr) {
+  std::atomic<uint32_t> &headerAtomic = RefCountAtomicLVal(objAddr);
+  uint32_t oldHeader = headerAtomic.load();
+  uint32_t newHeader = 0;
+  do {
+    if (oldHeader & kWeakCollectedBit) {
+      return 0;
+    }
+    StatsRCOperationCount(objAddr);
+    if (UNLIKELY(SkipRC(oldHeader))) {
+      return objAddr;
+    }
+    if (incWeak) {
+      // weak collected bit not set, weak rc is 1 means no other weak reference
+      if (GetWeakRCFromRCHeader(oldHeader) == 1) {
+        return 0;
+      }
+      newHeader = GetNewRCHeaderWeak<1>(oldHeader);
+    } else {
+      newHeader = GetNewRCHeaderStrong<1, true>(oldHeader);
+    }
+  } while (!headerAtomic.compare_exchange_weak(oldHeader, newHeader));
+  return objAddr;
+}
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_RC_INLINE_H
diff --git a/src/mrt/compiler-rt/include/collector/rc_reference_processor.h b/src/mrt/compiler-rt/include/collector/rc_reference_processor.h
new file mode 100644
index 0000000000000000000000000000000000000000..82e34661d4fdabb23c9cb386cd0b0dffed66bf64
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/rc_reference_processor.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_COMPILER_RT_RC_REFERENCE_PROCESSOR_H
+#define MAPLE_COMPILER_RT_RC_REFERENCE_PROCESSOR_H
+
+#include <vector>
+#include <mutex>
+#include "mm_config.h"
+#include "address.h"
+#include "sizes.h"
+#include "mrt_reference_api.h"
+#include "mrt_well_known.h"
+#include "rp_base.h"
+
+namespace maplert {
+class RCReferenceProcessor : public ReferenceProcessor {
+ public:
+  static inline RCReferenceProcessor &Instance() {
+    return static_cast<RCReferenceProcessor&>(ReferenceProcessor::Instance());
+  }
+  RCReferenceProcessor();
+  ~RCReferenceProcessor() = default;
+  void Init() override;
+  void Fini() override;
+  void VisitFinalizers(RefVisitor &visitor) override;
+
+  // async release queue
+  void AddAsyncReleaseObj(address_t obj, bool isMutator);
+  void ClearAsyncReleaseObjs();
+  void ProcessAsyncReleaseObjs();
+  void VisitAsyncReleaseObjs(const RefVisitor &vistor);
+  // stats
+  inline void CountRecent(uint32_t type) {
+    ++(recentCount[type]);
+  }
+  inline uint32_t RecentCount(uint32_t type) {
+    return recentCount[type];
+  }
+  inline void AddAgedProcessedCount() {
+    ++(numProcessedAgedRefs[curProcessingRef]);
+  }
+  bool CheckAndSetReferenceFlags();
+  bool CheckAndUpdateAgedReference(uint32_t type); // check if perfrom aged reference process after young
+  bool CheckAndAddFinalizable(address_t obj);
+  void TransferFinalizblesOnFork(ManagedList<address_t> &toFinalizables);
+  address_t TransferEnquenenableReferenceOnFork(uint32_t type);
+ protected:
+  bool ShouldStartIteration() override;
+  void LogRefProcessorBegin() override;
+  void LogRefProcessorEnd() override;
+ private:
+  void PreIteration() override;
+  void PostIteration() override;
+  void PreExitDoFinalize() override;
+  void PostProcessFinalizables() override;
+  void PostFinalizable(address_t obj) override;
+  void PreAddFinalizables(address_t obj[], uint32_t count, bool needLock) override;
+  void PostAddFinalizables(address_t obj[], uint32_t count, bool needLock) override;
+  bool SpecializedAddFinalizable(address_t obj) override;
+  void EnqeueReferences() override;
+  // RP check and start
+  inline bool HasReferenceFlag(uint32_t type) {
+    return referenceFlags & RPMask(type);
+  }
+
+  // finalization
+  ManagedList<address_t> pendingFinalizables; // pending list for RC, workaround for too fast finalize
+  ManagedList<address_t> pendingFinalizablesPrev; // Prev to record next list for processing
+  // release queue
+  std::mutex releaseQueueLock;
+  ManagedDeque<address_t> asyncReleaseQueue; // release queue for async release
+  ManagedDeque<address_t> workingAsyncReleaseQueue; // working async release queue
+  // reference processing flags
+  uint32_t referenceFlags; // which references to process
+  uint32_t agedReferenceFlags; // which aged references to process
+  uint32_t numProcessedAgedRefs[kRPTypeNum]; // aged reference processed from begining
+  uint32_t numLastProcessedAgedRefs[kRPTypeNum];
+  volatile uint32_t recentCount[kRPTypeNum]; // recent reference count added to list
+  uint32_t agedReferenceCount[kRPTypeNum]; // how many iterations aged is skipped
+  uint32_t hungryCount; // how many iteration not process RP
+  uint32_t agedHungryCount; // how many iteration not process aged RP
+};
+
+
+// add a (newly created) reference object for later processing
+void AddNewReference(address_t obj, uint32_t classFlag);
+void MrtVisitReferenceRoots(AddressVisitor visitor, uint32_t flags);
+
+// used by gc thread for visit and process references in non-parallel or parallel mode.
+void MRT_GCVisitReferenceRoots(RefVisitor &visitor, uint32_t flags);
+void MRT_ParallelVisitReferenceRoots(MplThreadPool &threadPool, RefVisitor &visitor, uint32_t flags);
+
+uint32_t MrtRpEpochIntervalMs();
+}
+#endif // MAPLE_COMPILER_RT_REFERENCE_PROCESSOR_H
diff --git a/src/mrt/compiler-rt/include/collector/rp_base.h b/src/mrt/compiler-rt/include/collector/rp_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..3728ff890fce81b6983c2e936ec3adde80c0945e
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/rp_base.h
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_COMPILER_RT_RP_BASE_H
+#define MAPLE_COMPILER_RT_RP_BASE_H
+
+#include <forward_list>
+#include <list>
+#include <deque>
+
+#include "mm_config.h"
+#include "address.h"
+#include "sizes.h"
+#include "allocator/page_allocator.h"
+
+namespace maplert {
+constexpr float kPercentageDivend = 100.0f;
+
+// flags for RP visitor and type
+enum RPType : uint32_t {
+  kRPWeakRef = 0, // weak reference
+  kRPSoftRef, // soft reference
+  kRPPhantomRef, // phantom and cleaner
+  kRPFinalizer, // finalizers
+  kRPWeakGRT, // weak global reference
+  kRPReleaseQueue, // release queue for RC
+  kRPTypeNum
+};
+constexpr uint32_t kRPTypeNumCommon = 4; // previous 4 type is shared by GC and RC
+constexpr uint32_t kRPAllFlags = ((1U << kRPTypeNum) - 1);
+
+static inline uint32_t RPMask(uint32_t type) {
+  __MRT_ASSERT(type >= kRPWeakRef && type <= kRPReleaseQueue, "invalid type");
+  return 1U << type;
+}
+
+using LockType = std::mutex;
+using LockGuard = std::lock_guard<std::mutex>;
+
+template<typename T>
+using ManagedForwardList = std::forward_list<T, StdContainerAllocator<T, kReferenceProcessor>>;
+
+template<typename T>
+using ManagedDeque = std::deque<T, StdContainerAllocator<T, kReferenceProcessor>>;
+
+template<typename T>
+using ManagedList = std::list<T, StdContainerAllocator<T, kReferenceProcessor>>;
+
+// raw load access, no RC book-keeping
+static inline address_t ReferenceGetReferent(address_t reference) {
+  return LoadRefField(reference, WellKnown::kReferenceReferentOffset);
+}
+
+static inline address_t ReferenceGetQueue(address_t reference) {
+  return LoadRefField(reference, WellKnown::kReferenceQueueOffset);
+}
+
+static inline address_t ReferenceGetPendingNext(address_t reference) {
+  return LoadRefField(reference, WellKnown::kReferencePendingnextOffset);
+}
+
+static inline void ReferenceSetPendingNext(address_t reference, address_t next) {
+  StoreRefField(reference, WellKnown::kReferencePendingnextOffset, next);
+}
+
+// raw store 0 access, no RC book-keeping
+static inline void ReferenceClearReferent(address_t reference) {
+  StoreRefField(reference, WellKnown::kReferenceReferentOffset, 0);
+}
+
+// there are some policy to recycle SoftReference
+// 1. NeverClearPolicy is used for GCtype: Force.
+// 2. ClearAllPolicy is used for GCtype: OOM.
+// 3. other GCtype and RC will use the CurrentHeapPolicy.
+//    CurrentHeapPolicy is the avaliable memory of current processor
+class SoftReferencePolicy {
+ public:
+  virtual bool ShouldClearSoftRef() = 0;
+  virtual ~SoftReferencePolicy() = default;
+  virtual void Init() {}
+};
+
+class NeverClearPolicy : public SoftReferencePolicy {
+ public:
+  bool ShouldClearSoftRef() override {
+    return false;
+  }
+};
+
+class ClearAllPolicy : public SoftReferencePolicy {
+ public:
+  bool ShouldClearSoftRef() override {
+    return true;
+  }
+};
+
+class CurrentHeapPolicy : public SoftReferencePolicy {
+ public:
+  CurrentHeapPolicy() : counter(1), maxInterval(0) {}
+  ~CurrentHeapPolicy() = default;
+  void Init() override;
+  uint32_t MaxInterval() const {
+    return maxInterval;
+  }
+  bool ShouldClearSoftRef() override {
+    if (maxInterval == 0) {
+      return true;
+    }
+    uint32_t cnt = counter.fetch_add(1, std::memory_order_relaxed);
+    return (cnt % maxInterval) == 0;
+  }
+ private:
+  std::atomic<uint32_t> counter;
+  uint32_t maxInterval;
+};
+
+class ReferenceProcessor {
+ public:
+  ReferenceProcessor();
+  virtual ~ReferenceProcessor() = default;
+
+  // GC Roots or util iterators
+  virtual void VisitFinalizers(RefVisitor &visitor); // finalizable objs visotr, not template for rvalue
+  virtual void VisitGCRoots(RefVisitor &visitor);
+  bool ShouldClearReferent(GCReason reason);
+  void InitSoftRefPolicy();
+
+  // utils
+  static inline ReferenceProcessor &Instance() {
+    return *instance;
+  }
+  bool IsCurrentRPThread() const;
+  void SetIterationWaitTimeMs(uint32_t waitTime) {
+    iterationWaitTime = waitTime;
+  }
+  static MethodMeta *EnqueueMethod() {
+    return enqueueMethod;
+  }
+
+  // notify & wait for RP processing, invoked after GC/Naive GC heurstic, start RP iteration
+  void Notify(bool processAll);
+  void NotifyBackgroundGC(bool force);
+
+  // notify & wait for RP start
+  void WaitStarted();
+
+  static void Create(CollectorType type);
+  static void SwitchToGCOnFork();
+  virtual void Run(); // now virtual, tobe devirtualized
+  virtual void Init();
+  virtual void Fini() {};
+  virtual void Stop(bool finalize);
+  virtual void WaitStop();
+  virtual void PreSwitchCollector();
+
+  void RunFinalization();
+  void AddFinalizable(address_t obj, bool needLock);
+  void AddFinalizables(address_t objs[], uint32_t count, bool needLock);
+  void LogFinalizeInfo();
+
+  static void Enqueue(address_t reference);
+
+  void CountProcessed() { // tobe in private
+    ++numProcessedRefs[curProcessingRef];
+  }
+  void SetProcessingType(uint32_t type) { // tobe private
+    curProcessingRef = type;
+  }
+
+  static uint32_t GetRPTypeByClassFlag(uint32_t classFlag) {
+    uint32_t type = kRPWeakRef;
+    if (classFlag & (modifier::kClassCleaner | modifier::kClassPhantomReference)) {
+      type = kRPPhantomRef;
+    } else if (classFlag & modifier::kClassWeakReference) {
+      type = kRPWeakRef;
+    } else if (classFlag & modifier::kClassSoftReference) {
+      type = kRPSoftRef;
+    } else {
+      __MRT_ASSERT(false, "not expected reference");
+    }
+    return type;
+  }
+ protected:
+  virtual bool ShouldStartIteration() = 0;
+  void NotifyStrated();
+  void Wait(uint32_t timeoutMilliSeconds);
+  void ProcessFinalizables();
+  void ProcessFinalizablesList(ManagedList<address_t> &list);
+  // run process
+  virtual void PreIteration(); // pre reference processing iteration
+  virtual void PostIteration() {}
+  virtual void PreExitDoFinalize();
+  virtual void DoChores();
+
+  std::mutex wakeLock;
+  std::condition_variable wakeCondition; // notify RP processing continue
+
+  std::mutex startedLock; // notify RP thread is started
+  std::condition_variable startedCondition;
+  volatile bool RPStarted;
+
+  volatile pthread_t threadHandle; // thread handle to RP thread
+  volatile bool RPRunning; // Initially false and set true after RP thread start, set false when stop
+  volatile bool doFinalizeOnStop; // Should perfrom run finalization when stop RP thread
+
+  uint32_t iterationWaitTime;
+  std::atomic<bool> processAllRefs;
+
+  // finalization
+  std::mutex finalizersLock; // lock list swap/add
+  std::mutex finalizerProcessingLock; // finalizer processing lock, for runFinalization sync
+  std::mutex runFinalizationLock; // runFinalization lock, for multiple run Finalization sync
+  ManagedList<address_t> finalizables; // candiate objects to perform finalize method
+  ManagedList<address_t> workingFinalizables; // finlaize working queue
+  ManagedList<address_t> runFinalizations; // finalizerables processed by runFinalization
+  // stats
+  virtual void LogRefProcessorBegin();
+  virtual void LogRefProcessorEnd();
+  uint32_t curProcessingRef;
+  uint32_t numProcessedRefs[kRPTypeNum]; // reference processed from begining used in RPLog
+  uint32_t numLastProcessedRefs[kRPTypeNum];
+  // background gc
+  std::atomic_bool hasBackgroundGC; // back ground gc, tobe moved to task based GC thread
+  uint64_t timeRefProcessorBegin;
+  uint64_t timeRefProcessUsed;
+  uint64_t timeCurrentRefProcessBegin;
+ private:
+  void RunBackgroundGC();
+  bool forceBackgroundGC; // force background GC can not be canceled, used in start up
+  uint64_t catchBGGcJobTime;
+  // finalize
+  virtual void PostProcessFinalizables() {} // inovke after finish process finalizables in RP thread
+  virtual void PostFinalizable(address_t) {} // inovke after process signle finalizables
+  virtual void PreAddFinalizables(address_t obj[], uint32_t count, bool needLock) = 0;
+  virtual void PostAddFinalizables(address_t obj[], uint32_t count, bool needLock) = 0;
+  virtual bool SpecializedAddFinalizable(address_t) {
+    return false;
+  }
+  // reference
+  virtual void EnqeueReferences() = 0;
+  // fields
+  static ReferenceProcessor *instance;
+  static MethodMeta *enqueueMethod;
+  // Policy used in gc
+  NeverClearPolicy forceGcSoftPolicy;
+  ClearAllPolicy oomGcSoftPolicy;
+  CurrentHeapPolicy heapGcSoftPolicy;
+};
+}
+#endif // MAPLE_COMPILER_RT_REFERENCE_PROCESSOR_H
diff --git a/src/mrt/compiler-rt/include/collector/satb_buffer.h b/src/mrt/compiler-rt/include/collector/satb_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ecd15649674d7c024cb62c4cc1a65279a825ab7
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/satb_buffer.h
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_SATB_BUFFER_H
+#define MAPLE_RUNTIME_SATB_BUFFER_H
+
+#include "allocator/page_pool.h"
+#include "collector/mrt_bitmap.h"
+
+namespace maplert {
+// snapshot at the beginning buffer
+// mainly used to buffer modified field of mutator write
+class SatbBuffer {
+  static constexpr size_t kInitialPages = 64; // 64 pages of initial satb buffer
+  static constexpr size_t kNodeSize = 512 - 8; // size of SatbBuffer node, which can store 63 entries
+ public:
+  static SatbBuffer &Instance();
+
+  class Node {
+    friend class SatbBuffer;
+   public:
+    Node() {
+      top = reinterpret_cast<address_t*>(this + 1);
+      next = nullptr;
+    }
+    ~Node() = default;
+    bool IsEmpty() const {
+      return reinterpret_cast<size_t>(top) == (reinterpret_cast<size_t>(this) + sizeof(Node));
+    }
+    bool IsFull() const {
+      static_assert((sizeof(Node) % sizeof(address_t*)) == 0, "Satb node must be aligned");
+      return reinterpret_cast<size_t>(top) == (reinterpret_cast<size_t>(this) + kNodeSize);
+    }
+    void Push(address_t obj) {
+      *top = obj;
+      top++;
+    }
+    template<typename T>
+    void GetObjects(T &stack) const {
+      address_t *start = reinterpret_cast<address_t*>(const_cast<Node*>(this + 1));
+      __MRT_ASSERT(top <= reinterpret_cast<address_t*>(reinterpret_cast<uintptr_t>(this) + kNodeSize), "invalid node");
+      (void)std::copy(start, top, std::back_inserter(stack));
+    }
+   private:
+    address_t *top;
+    Node *next;
+  };
+
+  struct Page {
+    Page *next;
+  };
+
+  // there is no need to use LL/SC to avoid ABA problem, becasue Nodes are all unique.
+  template<typename T>
+  class LockFreeList {
+    friend class SatbBuffer;
+   public:
+    LockFreeList() : head(nullptr) {}
+    ~LockFreeList() = default;
+
+    void Reset() {
+      head = nullptr;
+    }
+
+    void Push(T *n) {
+      T *old = head.load(std::memory_order_relaxed);
+      do {
+        n->next = old;
+      } while (!head.compare_exchange_weak(old, n, std::memory_order_release, std::memory_order_relaxed));
+    }
+
+    T *Pop() {
+      T *old = head.load(std::memory_order_relaxed);
+      do {
+        if (old == nullptr) {
+          return nullptr;
+        }
+      } while (!head.compare_exchange_weak(old, old->next, std::memory_order_release, std::memory_order_relaxed));
+      old->next = nullptr;
+      return old;
+    }
+
+    T *PopAll() {
+      T *old = head.load(std::memory_order_relaxed);
+      while (!head.compare_exchange_weak(old, nullptr, std::memory_order_release, std::memory_order_relaxed)) {};
+      return old;
+    }
+   private:
+    std::atomic<T*> head;
+  };
+
+  void EnsureGoodNode(Node *&node) {
+    if (node == nullptr) {
+      node = freeNodes.Pop();
+    } else if (node->IsFull()) {
+      // means current node is full
+      retiredNodes.Push(node);
+      node = freeNodes.Pop();
+    } else {
+      // not null & have slots
+      return;
+    }
+    if (node == nullptr) {
+      // there is no free nodes in the freeNodes list
+      Page *page = GetPages(maple::kPageSize);
+      Node *list = ConstructFreeNodeList(page, maple::kPageSize);
+      node = list;
+      Node *cur = list->next;
+      node->next = nullptr;
+      while (cur != nullptr) {
+        Node *next = cur->next;
+        freeNodes.Push(cur);
+        cur = next;
+      }
+    }
+  }
+  bool ShouldEnqueue(address_t obj) {
+    if (markMap->IsObjectMarked(obj)) {
+      return false;
+    }
+    return !enqueueMap.MarkObject(obj);
+  }
+  // must not have thread racing
+  void Init(MrtBitmap *map) {
+    size_t initalBytes = kInitialPages * maple::kPageSize;
+    Page *page = GetPages(initalBytes);
+    Node *list = ConstructFreeNodeList(page, initalBytes);
+    freeNodes.head = list;
+    retiredNodes.head = nullptr;
+    enqueueMap.Initialize();
+    enqueueMap.ResetCurEnd();
+    markMap = map;
+  }
+  void RetireNode(Node *node) {
+    retiredNodes.Push(node);
+  }
+  // must not have thread racing
+  void Reset() {
+    Page *list = arena.head;
+    while (list->next != nullptr) {
+      Page *next = list->next;
+      PagePool::Instance().ReturnPage(reinterpret_cast<uint8_t*>(list), maple::kPageSize);
+      list = next;
+    }
+    PagePool::Instance().ReturnPage(reinterpret_cast<uint8_t*>(list), kInitialPages * maple::kPageSize);
+    arena.head = nullptr;
+    freeNodes.head = nullptr;
+    retiredNodes.head = nullptr;
+    enqueueMap.ResetBitmap();
+    markMap = nullptr;
+  }
+  template<typename T>
+  void GetRetiredObjects(T &stack) {
+    Node *head = retiredNodes.PopAll();
+    while (head != nullptr) {
+      head->GetObjects(stack);
+      head = head->next;
+    }
+  }
+ private:
+  Page *GetPages(size_t bytes) {
+    Page *page = reinterpret_cast<Page*>(PagePool::Instance().GetPage(bytes));
+    page->next = nullptr;
+    arena.Push(page);
+    return page;
+  }
+  Node *ConstructFreeNodeList(const Page *page, size_t bytes) const {
+    address_t start = reinterpret_cast<address_t>(page) + sizeof(Page);
+    address_t end = reinterpret_cast<address_t>(page) + bytes;
+    Node *cur = nullptr;
+    Node *head = nullptr;
+    while (start <= (end - kNodeSize)) {
+      Node *node = new (reinterpret_cast<void*>(start)) Node();
+      if (cur == nullptr) {
+        cur = node;
+        head = node;
+      } else {
+        cur->next = node;
+        cur = node;
+      }
+      start += kNodeSize;
+    }
+    return head;
+  }
+
+  LockFreeList<Page> arena; // arena of allocatable area, first area is 64 * 4k = 256k, the rest is 4k
+  LockFreeList<Node> freeNodes; // free nodes, mutator will acquire nodes from this list to record old value writes
+  LockFreeList<Node> retiredNodes; // has been filled by mutator, ready for scan
+  MrtBitmap enqueueMap; // enqueue bitmap to indicate whether the obj has been enqueued to SatbBuffer
+  MrtBitmap *markMap; // mark bitmap to filter marked objects from being enqueued to SatbBuffer
+};
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_SATB_BUFFER_H
diff --git a/src/mrt/compiler-rt/include/collector/stats.h b/src/mrt/compiler-rt/include/collector/stats.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e4b03df2ae424afe12efb17ad39eb7546b21b61
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/stats.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_STATS_H
+#define MAPLE_RUNTIME_STATS_H
+
+#include <mutex>
+#include <memory>
+#include <list>
+#include <atomic>
+#include <algorithm>
+
+#include "mm_config.h"
+#include "gc_reason.h"
+#include "panic.h"
+#include "deps.h"
+
+namespace maplert {
+namespace stats {
+// Time unit is nanoseconds.
+struct SingleGCRecord {
+  GCReason reason;
+  bool isConcurrentMark;
+  bool async;
+  uint64_t stw1Time; // First stop-the-world time, or the whole STW if marking is not concurrent.
+  uint64_t stw2Time; // Second stop-the-world time, or 0 if marking is not concurrent.
+  uint64_t totalGcTime; // Including both marking and sweeping
+  size_t objectsCollected;
+  size_t bytesCollected;
+  size_t bytesSurvived;
+  size_t newHeapSize;
+
+  inline uint64_t MaxSTWTime() const {
+    if (isConcurrentMark) {
+      return std::max(stw1Time, stw2Time);
+    } else {
+      return stw1Time;
+    }
+  }
+
+  inline uint64_t TotalSTWTime() const {
+    if (isConcurrentMark) {
+      return stw1Time + stw2Time;
+    } else {
+      return stw1Time;
+    }
+  }
+};
+
+// Public-visible statistics generated by triggered GCs.
+// Time unit is nanoseconds.
+class GCStats {
+ public:
+  // GC record handling.
+  // Call this at the beginning of GC to initialize the curRec field.
+  void BeginGCRecord();
+  void CommitGCRecord();
+  SingleGCRecord &CurrentGCRecord() {
+    __MRT_ASSERT(curRec != nullptr, "curRec is nullptr.  Call BeginGCRecord() first!");
+    return *curRec;
+  }
+
+  // Writers.  Collect statistics from different place of the runtime.
+  void OnCollectorInit();
+  void OnAllocAnomaly();
+  void OnFreeObject(size_t size) const;
+  void OnRCAnomaly();
+
+  // Readers.
+  uint64_t MaxSTWNanos() const;
+  size_t NumGCTriggered() const;
+  size_t AverageMemoryLeak() const;
+  // returns the bytes claimed by the tracing GC
+  size_t TotalMemoryLeak() const;
+  double MemoryUtilization() const;
+  size_t NumAllocAnomalies() const;
+  size_t NumRCAnomalies() const;
+  void ResetMaxSTWNanos();
+  void ResetNumGCTriggered();
+  void ResetMemoryLeak();
+  void ResetMemoryUtility();
+  void ResetNumAllocAnomalies();
+  void ResetNumRCAnomalies();
+
+  size_t CurAllocBytes() const;
+  size_t CurAllocatorCapacity() const;
+  size_t CurSpaceCapacity() const;
+  size_t CurGCThreshold() const;
+  void InitialGCThreshold(const bool isSystem);
+  void InitialGCProcessName();
+
+  GCStats();
+  ~GCStats() = default;
+
+ private:
+  std::atomic<size_t> numGcTriggered;
+  // Total bytes collected since last reset
+  // this field is incremented inside OnGCFinished; so we do not need to increment
+  // on every object release.
+  size_t totalBytesCollected;
+  // The number of gc times since last reset
+  size_t recentGcCount;
+  // The max bytes collected by gc since last reset
+  size_t maxBytesCollected;
+  std::atomic<uint64_t> maxStopTheWorldTime;
+  // The number of allocation requests that failed due to OOM. Reset on every getMemAlloc
+  std::atomic<size_t> numAllocAnomalies;
+  std::atomic<size_t> numRcAnomalies;
+  std::atomic<size_t> currentGcThreshold;
+
+  // Current GC record. Need to be written by many different classes, so we put it here.
+  std::unique_ptr<SingleGCRecord> curRec;
+  float waterLevelLow;
+  float waterLevel;
+  std::string processName;
+  void UpdateStatistics(const std::unique_ptr<SingleGCRecord> &rec);
+  void Dump(const std::unique_ptr<SingleGCRecord> &rec);
+  // Add the GC record.
+  // GC thread should use Begin/Current/CommitGCRecord instead.
+  void OnGCFinished(const std::unique_ptr<SingleGCRecord> &rec);
+};
+
+extern ImmortalWrapper<GCStats> gcStats;
+} // namespace stats
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/collector/task_queue.h b/src/mrt/compiler-rt/include/collector/task_queue.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce5648aa8523c80f4fccf2069024677ec288b1f8
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collector/task_queue.h
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_RUNTIME_TASK_QUEUE_H
+#define MAPLE_RUNTIME_TASK_QUEUE_H
+
+#include "allocator/page_allocator.h"
+
+// task queue implementation
+namespace maplert {
+class ScheduleTaskBase {
+ public:
+  enum ScheduleTaskType : int {
+    kInvalidScheduleType = -1,
+    kScheduleTaskTypeInvokeGC = 0, // invoke gc task
+    kScheduleTaskTypeTimeout = 1, // timeout task
+    kScheduleTaskTypeTerminate = 2, // terminate task
+  };
+  static constexpr uint64_t kIndexExit = 0;
+  static constexpr uint64_t kSyncIndexStartValue = 1;
+  static constexpr uint64_t kAsyncIndex = ULONG_MAX;
+
+  ScheduleTaskBase(const ScheduleTaskBase &task) = default;
+  ScheduleTaskBase(ScheduleTaskType type) : taskType(type), syncIndex(kAsyncIndex) {}
+  virtual ~ScheduleTaskBase() = default;
+  ScheduleTaskBase &operator=(const ScheduleTaskBase&) = default;
+
+  ScheduleTaskType GetType() const {
+    return taskType;
+  }
+
+  void SetType(ScheduleTaskType type) {
+    taskType = type;
+  }
+
+  uint64_t GetSyncIndex() const {
+    return syncIndex;
+  }
+
+  void SetSyncIndex(uint64_t index) {
+    syncIndex = index;
+  }
+
+  virtual bool NeedFilter() const {
+    return false;
+  }
+
+  virtual bool Execute(void *owner) = 0;
+
+  virtual std::string ToString() const {
+    std::stringstream ss;
+    ss << ScheduleTaskTypeToString(taskType) << " index=" << syncIndex;
+    return ss.str();
+  }
+
+ protected:
+  ScheduleTaskType taskType;
+  uint64_t syncIndex;
+
+ private:
+  const char *ScheduleTaskTypeToString(ScheduleTaskType type) const {
+    switch (type) {
+      case ScheduleTaskType::kScheduleTaskTypeInvokeGC:
+        return "InvokeGC";
+      case ScheduleTaskType::kScheduleTaskTypeTimeout:
+        return "Timeout";
+      case ScheduleTaskType::kScheduleTaskTypeTerminate:
+        return "Terminate";
+      default:
+        return "Wrong Type";
+    }
+  }
+};
+
+template<typename T>
+class LocklessTaskQueue {
+ public:
+  // this queue manages a list of deduplicated tasks of *a fixed number of* kinds
+  // each task has a priority directly associated with the kind
+  // smaller kind (that is, smaller integer) has a higher priority
+  // high priority task's enqueue might erase all lower-priority tasks
+  // the intuition is that, (when managing concurrent gc tasks, which are merely
+  // to lower memory level from the background), maybe we only need the strongest
+  // one in the queue
+  // this queue is lockless
+  void Push(const T &task) {
+    bool overriding = task.IsOverriding();
+    uint32_t taskMask = (1U << task.GetPrio());
+    uint32_t oldWord = tqWord.load(std::memory_order_relaxed);
+    uint32_t newWord = 0;
+    do {
+      if (overriding) {
+        newWord = taskMask | ((taskMask - 1) & oldWord);
+      } else {
+        newWord = taskMask | oldWord;
+      }
+    } while (!tqWord.compare_exchange_weak(oldWord, newWord, std::memory_order_relaxed));
+  }
+  T Pop() {
+    uint32_t oldWord = tqWord.load(std::memory_order_relaxed);
+    uint32_t newWord = 0;
+    uint32_t dequeued = oldWord;
+    do {
+      newWord = oldWord & (oldWord - 1);
+      dequeued = oldWord;
+    } while (!tqWord.compare_exchange_weak(oldWord, newWord, std::memory_order_relaxed));
+    if (oldWord == 0) {
+      return T::DoNothing();
+    }
+    // count the number of trailing zeros
+    return T::FromPrio(__builtin_ctz(dequeued));
+  }
+  void Clear() {
+    tqWord.store(0, std::memory_order_relaxed);
+  }
+ private:
+  std::atomic<uint32_t> tqWord = {};
+};
+
+template<typename T, uint64_t minIntervalNs = 1000UL * 1000 * 1000>
+class TaskQueue {
+  static_assert(std::is_base_of<ScheduleTaskBase, T>::value, "T is not a subclass of maplert::ScheduleTaskBase");
+
+ public:
+  using TaskFilter = std::function<bool(T &oldTask, T &newTask)>;
+  using TaskQueueType = std::list<T, StdContainerAllocator<T, kGCTaskQueue>>;
+
+  void Init() {
+    queueSyncIndex = ScheduleTaskBase::kSyncIndexStartValue;
+  }
+
+  void DeInit() {
+    std::lock_guard<std::mutex> lock(taskQueueLock);
+    taskQueue.Clear();
+    syncTaskQueue.clear();
+    LOG(INFO) << "[GC] DeInit task Q done" << maple::endl;
+  }
+
+  template<bool sync = false>
+  uint64_t Enqueue(T &task, TaskFilter &filter) {
+    if (!sync) {
+      EnqueueAsync(task);
+      return ScheduleTaskBase::kAsyncIndex;
+    }
+    std::unique_lock<std::mutex> lock(taskQueueLock);
+    TaskQueueType &queue = syncTaskQueue;
+
+    if (!queue.empty() && task.NeedFilter()) {
+      for (auto iter = queue.rbegin(); iter != queue.rend(); ++iter) {
+        if (filter(*iter, task)) {
+          return (*iter).GetSyncIndex();
+        }
+      }
+    }
+    task.SetSyncIndex(++queueSyncIndex);
+    queue.push_back(task);
+    taskQueueCondVar.notify_all();
+    return task.GetSyncIndex();
+  }
+
+  void EnqueueAsync(const T &task) {
+    taskQueue.Push(task);
+    taskQueueCondVar.notify_all();
+  }
+
+  T Dequeue() {
+    std::cv_status cvResult = std::cv_status::no_timeout;
+    std::chrono::nanoseconds waitTime(kDefaultTheadTimeoutNs);
+    while (true) {
+      std::unique_lock<std::mutex> qLock(taskQueueLock);
+      // check sync queue firstly
+      if (!syncTaskQueue.empty()) {
+        T curTask(syncTaskQueue.front());
+        syncTaskQueue.pop_front();
+        return curTask;
+      }
+
+      if (cvResult == std::cv_status::timeout) {
+        taskQueue.Push(T(ScheduleTaskBase::ScheduleTaskType::kScheduleTaskTypeTimeout));
+      }
+
+      T task = taskQueue.Pop();
+      if (!task.IsNothing()) {
+        return task;
+      }
+      cvResult = taskQueueCondVar.wait_for(qLock, waitTime);
+    }
+  }
+
+  void LoopDrainTaskQueue(void *owner) {
+    while (true) {
+      T task = Dequeue();
+      if (!task.Execute(owner)) {
+        DeInit();
+        break;
+      }
+    }
+  }
+
+ private:
+#if LOG_ALLOC_TIMESTAT
+  static constexpr uint64_t kDefaultTheadTimeoutNs = 300000L * 1000 * 1000; // default 300s
+#else
+  static constexpr uint64_t kDefaultTheadTimeoutNs = 1000L * 1000 * 1000; // default 1s
+#endif
+  std::mutex taskQueueLock;
+  uint64_t queueSyncIndex;
+  TaskQueueType syncTaskQueue;
+  LocklessTaskQueue<T> taskQueue;
+  std::condition_variable taskQueueCondVar;
+};
+}
+#endif
diff --git a/src/mrt/compiler-rt/include/collie.h b/src/mrt/compiler-rt/include/collie.h
new file mode 100644
index 0000000000000000000000000000000000000000..00e8c03799873e1ae15906f572caf96236c71755
--- /dev/null
+++ b/src/mrt/compiler-rt/include/collie.h
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef COLLIE_H
+#define COLLIE_H
+
+#ifdef __ANDROID__
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cinttypes>
+#include <vector>
+#include <deque>
+#include <atomic>
+#include <mutex>
+#include <chrono>
+#include <sys/types.h>
+#include <sys/syscall.h>
+#include <time.h>
+#include "mrt_api_common.h"
+#include "panic.h"
+#include "mutator_list.h"
+
+namespace maplert {
+constexpr int kMplWaitCheckInterval = 5;
+const int kMaxDelayCount = 3;
+constexpr unsigned int kTimerRingCheckInterval = 1;
+const int kMplCollieCallbackHistoryMax = 5;
+const int kMplCollieCallbackTimewinMax = 60;
+const int kInvalidId = -1;
+
+constexpr int kMplWaitHeavyGcTimeout = 90; // other threads wait for gc finish
+constexpr int kMplWaitGcTimeout = 60; // normal gc timeout
+constexpr int kMplFinalizerTimeout = 30;
+constexpr int kThreadDumpTimeout = 40;
+constexpr int kMplCollieMaxRecordVal = 10;
+
+#define MPLCOLLIE_FLAG_ABORT (1 << 0)
+#define MPLCOLLIE_FLAG_PROMOTE_PRIORITY (1 << 7)
+#define MPLCOLLIE_FLAG_IN_STW (1 << 8)
+#define MPLCOLLIE_FLAG_FOR_STW (1 << 9)
+#define MPLCOLLIE_FLAG_IS_STW(flag) (((flag) & MPLCOLLIE_FLAG_IN_STW) || ((flag) & MPLCOLLIE_FLAG_FOR_STW))
+
+enum CollieType {
+  kGCCollie = 0, // wait for GC finish
+  kProcessFinalizeCollie, // reference processor trigger
+  kSTWCollie, // wait for stop the world finish
+  kThreadDumpCollie,
+  kCollieTypeMax
+};
+
+struct CollieNode {
+  CollieType type;
+  bool isUsed;
+  std::string name;
+  time_t startTime;
+  int timeout;
+  int promoteTimes;
+  pid_t tid;
+  void *arg;
+  uint32_t flag;
+  void (*callback)(void *args);
+  CollieNode *next = nullptr;
+  void Reset() {
+    next = nullptr;
+  }
+};
+
+class CollieList {
+ public:
+  CollieList() : head(nullptr) {}
+
+  void Init() {
+    head = nullptr;
+  }
+
+  void Insert(CollieNode &target) {
+    if (head == nullptr) {
+      head = &target;
+      target.Reset();
+      return;
+    }
+    CollieNode *prev = nullptr;
+    CollieNode *cur = head;
+    while (cur != nullptr) {
+      if (target.timeout >= cur->timeout) {
+        prev = cur;
+        cur = cur->next;
+        continue;
+      }
+      if (prev == nullptr) {
+        head = &target;
+        head->next = cur;
+      } else {
+        prev->next = &target;
+        target.next = cur;
+      }
+      return;
+    }
+    prev->next = &target;
+    target.Reset();
+  }
+
+  void Remove(CollieNode &target) {
+    __MRT_ASSERT(head != nullptr, "remove a node from a empty list");
+    CollieNode *prev = nullptr;
+    CollieNode *cur = head;
+    while (cur != nullptr) {
+      if (cur != &target) {
+        prev = cur;
+        cur = cur->next;
+        continue;
+      }
+      if (prev == nullptr) {
+        head = cur->next;
+        target.Reset();
+      } else {
+        prev->next = cur->next;
+        target.Reset();
+      }
+      return;
+    }
+    __MRT_ASSERT(cur != nullptr, "collie list can not find a target node");
+  }
+
+  CollieNode *GetHead() const {
+    return head;
+  }
+
+  bool IsEmpty() {
+    return head == nullptr;
+  }
+ private:
+  CollieNode *head;
+};
+
+struct CollieTimerRing {
+  CollieList cl;
+  int timer;
+};
+
+class MplCollie {
+ public:
+  void Init();
+  void Fini();
+
+  MRT_EXPORT int Start(CollieType type, int flag, pid_t tid = maple::GetTid(),
+                       void (*func)(void*) = nullptr, void *arg = nullptr);
+  MRT_EXPORT void End(int type);
+
+  void StartSTW() {
+    Start(kSTWCollie, MPLCOLLIE_FLAG_ABORT | MPLCOLLIE_FLAG_FOR_STW);
+  }
+
+  void EndSTW() {
+    End(kSTWCollie);
+  }
+
+  void JoinThread();
+  MRT_EXPORT void SetSTWPanic(bool enable);
+  MRT_EXPORT bool GetSTWPanic(void);
+
+  MRT_EXPORT void FatalPanic(std::string &s, int tid);
+  void FatalPanicStopTheWorld(std::string &msg);
+
+ private:
+  int CallbackShouldLimit(int flag);
+  void CheckTimerRing(CollieNode callbackList[], CollieTimerRing &r, int &count);
+  static void *CollieThreadEntry(void *arg);
+  void *CollieThreadHandle();
+  void CollieTrySleep(void);
+  void CollieTryWake(void);
+  void FatalPanicLocked(std::string &msg);
+  void InitImp();
+  void ResetNode(CollieNode &node, int seq);
+  void RunCallback(CollieNode &cb);
+  void TimerRingTimeout();
+  void ForceEnd();
+  pthread_t collieThread;
+
+  int targetTid = kInvalidId;
+
+  int stwID = kInvalidId;
+  bool runnable = false; // false means the collie thread should stop.
+  std::mutex initMutex;
+  std::mutex listMutex;
+  std::mutex panicMutex;
+  // used for timing.
+  std::mutex timerMutex;
+  std::condition_variable timerCond;
+  // call back count
+  unsigned int nrCallback = 0;
+
+  // call back time stamp
+  time_t timeCallback = 0;
+
+  // to store the time
+  CollieTimerRing collieTimerRingSTW;
+  CollieTimerRing collieTimerRingNonSTW;
+
+  // save all the monitor info
+  CollieNode collieNodesArray[kCollieTypeMax];
+
+  struct TimerRingSleepControl {
+    bool threadInSleep;
+    std::atomic<unsigned int> delayCount;
+    std::unique_ptr<std::mutex> sleepMutexPtr;
+    std::unique_ptr<std::condition_variable> sleepCond;
+  } trCtl;
+};
+#ifdef __ANDROID__
+extern MRT_EXPORT MplCollie mplCollie;
+#endif
+
+class MplCollieScope {
+ public:
+  MplCollieScope(CollieType type, int flag, pid_t tid = maple::GetTid(), void (*func)(void*) = nullptr,
+                 void *arg = nullptr) {
+    mplCollieType = mplCollie.Start(type, flag, tid, func, arg);
+  }
+  ~MplCollieScope() {
+    mplCollie.End(mplCollieType);
+  }
+ private:
+  int mplCollieType = kInvalidId;
+};
+}
+#endif // __ANDROID__
+#endif // COLLIE_H
diff --git a/src/mrt/compiler-rt/include/cpphelper.h b/src/mrt/compiler-rt/include/cpphelper.h
new file mode 100644
index 0000000000000000000000000000000000000000..136bb943bbf9a3dcd9896b3d20058b6c19984f94
--- /dev/null
+++ b/src/mrt/compiler-rt/include/cpphelper.h
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_CPP_HELPER_H
+#define MAPLE_RUNTIME_CPP_HELPER_H
+
+#include <jni.h>
+#include "thread_api.h"
+#include "mm_utils.h"
+#include "cinterface.h"
+#include "saferegion.h"
+
+// helper utilities for runtime C++ code.
+namespace maplert {
+// Scoped guard for saferegion.
+class ScopedEnterSaferegion {
+ public:
+  __attribute__ ((always_inline))
+  ScopedEnterSaferegion() {
+    Mutator *mutator = CurrentMutatorPtr();
+    stateChanged = (mutator != nullptr) ? mutator->EnterSaferegion(true) : false;
+  }
+
+  __attribute__ ((always_inline))
+  ~ScopedEnterSaferegion() {
+    if (LIKELY(stateChanged)) {
+      Mutator *mutator = CurrentMutatorPtr(); // state changed, mutator must be not null
+      (void)mutator->LeaveSaferegion();
+    }
+  }
+ private:
+  bool stateChanged;
+};
+
+// Scoped guard for access java objects from native code.
+class ScopedObjectAccess {
+ public:
+  __attribute__ ((always_inline))
+  ScopedObjectAccess()
+      : mutator(CurrentMutator()),
+        stateChanged(mutator.LeaveSaferegion()) {}
+
+  __attribute__ ((always_inline))
+  explicit ScopedObjectAccess(JNIEnv *env __attribute__((unused))) : ScopedObjectAccess() {}
+
+  __attribute__ ((always_inline))
+  explicit ScopedObjectAccess(maple::IThread &self __attribute__((unused))) : ScopedObjectAccess() {}
+
+  __attribute__ ((always_inline))
+  ~ScopedObjectAccess() {
+    if (LIKELY(stateChanged)) {
+      (void)mutator.EnterSaferegion(false);
+    }
+  }
+ private:
+  Mutator &mutator;
+  bool stateChanged;
+};
+
+// Scoped enable GC for current thread.
+class ScopedEnableGC {
+ public:
+  ScopedEnableGC() {
+    MRT_GCInitThreadLocal(false);
+  }
+
+  __attribute__ ((always_inline))
+  ~ScopedEnableGC() {
+    MRT_GCFiniThreadLocal();
+  }
+};
+
+extern "C" void MRT_SetCurrentCompiledMethod(void *func);
+extern "C" void *MRT_GetCurrentCompiledMethod();
+
+// return value is in d0 if return type is float/double.
+// Since R2CForwardStubXX is assembly code, we have to wrap them with partially
+// specialized class template. Note C++ does not support partially specializing
+// template method/function. Thus we place these template functions as static methods
+// in some template class.
+#if defined(__arm__)
+extern "C" jlong   R2CForwardStubLong(...);
+extern "C" void    R2CForwardStubVoid(...);
+
+// note arm compiler always passes return value via r0/r1 for functions with variadic argument list.
+// refer to r2c_stub_arm.S to see how this is handled.
+extern "C" jfloat  R2CForwardStubFloat(...);
+extern "C" jdouble R2CForwardStubDouble(...);
+#else
+extern "C" jlong   R2CForwardStubLong(void *func, ...);
+extern "C" void    R2CForwardStubVoid(void *func, ...);
+extern "C" jfloat  R2CForwardStubFloat(void *func, ...);
+extern "C" jdouble R2CForwardStubDouble(void *func, ...);
+#endif
+
+extern "C" jlong   R2CBoxedStubLong(void *func, jvalue *argJvalue, size_t stackSize, size_t dregSize);
+extern "C" void    R2CBoxedStubVoid(void *func, jvalue *argJvalue, size_t stackSize, size_t dregSize);
+extern "C" jfloat  R2CBoxedStubFloat(void *func, jvalue *argJvalue, size_t stackSize, size_t dregSize);
+extern "C" jdouble R2CBoxedStubDouble(void *func, jvalue *argJvalue, size_t stackSize, size_t dregSize);
+
+// generic stubs for calling java code from maple runtime.
+// setup a stub frame to call java method represented by func
+template<typename Ret>
+class RuntimeStub {
+ public:
+  template<typename Func, typename... Args>
+  static Ret FastCallCompiledMethod(Func &&func, Args&&... args) {
+#if defined(__arm__)
+    MRT_SetCurrentCompiledMethod(reinterpret_cast<void*>(func));
+    Ret result = reinterpret_cast<Ret>(R2CForwardStubLong(std::forward<Args>(args)...));
+#else
+    Ret result = (Ret) R2CForwardStubLong(reinterpret_cast<void*>(func), std::forward<Args>(args)...);
+#endif
+    return result;
+  }
+
+  template<typename Func, typename... Args>
+  static jvalue FastCallCompiledMethodJ(Func &&func, Args&&... args) {
+    jvalue result;
+#if defined(__arm__)
+    MRT_SetCurrentCompiledMethod(reinterpret_cast<void*>(func));
+    result.j = R2CForwardStubLong(std::forward<Args>(args)...);
+#else
+    result.j = R2CForwardStubLong(reinterpret_cast<void*>(func), std::forward<Args>(args)...);
+#endif
+    return result;
+  }
+
+  template<typename Func>
+  static Ret SlowCallCompiledMethod(Func func, jvalue *argJvalue, size_t stackSize, size_t dregSize) {
+    Ret result = (Ret)R2CBoxedStubLong(reinterpret_cast<void*>(func), argJvalue, stackSize, dregSize);
+    return result;
+  }
+
+  template<typename Func>
+  static jvalue SlowCallCompiledMethodJ(Func func, jvalue *argJvalue, size_t stackSize, size_t dregSize) {
+    jvalue result;
+    result.j = R2CBoxedStubLong(reinterpret_cast<void*>(func), argJvalue, stackSize, dregSize);
+    return result;
+  }
+};
+
+// specialized RuntimeStub for returning void
+template<>
+class RuntimeStub<void> {
+ public:
+  template<typename Func, typename... Args>
+  static void FastCallCompiledMethod(Func &&func, Args&&... args) {
+#if defined(__arm__)
+    MRT_SetCurrentCompiledMethod(reinterpret_cast<void*>(func));
+    R2CForwardStubVoid(std::forward<Args>(args)...);
+#else
+    R2CForwardStubVoid(reinterpret_cast<void*>(func), std::forward<Args>(args)...);
+#endif
+    return;
+  }
+
+  template<typename Func>
+  static void SlowCallCompiledMethod(Func func, jvalue *argJvalue, size_t stackSize, size_t dregSize) {
+    R2CBoxedStubVoid(reinterpret_cast<void*>(func), argJvalue, stackSize, dregSize);
+    return;
+  }
+};
+
+template<>
+class RuntimeStub<jfloat> {
+ public:
+  template<typename Func, typename... Args>
+  static jfloat FastCallCompiledMethod(Func &&func, Args&&... args) {
+#if defined(__arm__)
+    MRT_SetCurrentCompiledMethod(reinterpret_cast<void*>(func));
+    jfloat result = R2CForwardStubFloat(std::forward<Args>(args)...);
+#else
+    jfloat result = R2CForwardStubFloat(reinterpret_cast<void*>(func), std::forward<Args>(args)...);
+#endif
+    return result;
+  }
+
+  template<typename Func>
+  static jfloat SlowCallCompiledMethod(Func func, jvalue *argJvalue, size_t stackSize, size_t dregSize) {
+    jfloat result = R2CBoxedStubFloat(reinterpret_cast<void*>(func), argJvalue, stackSize, dregSize);
+    return result;
+  }
+};
+
+template<>
+class RuntimeStub<jdouble> {
+ public:
+  template<typename Func, typename... Args>
+  static jdouble FastCallCompiledMethod(Func &&func, Args&&... args) {
+#if defined(__arm__)
+    MRT_SetCurrentCompiledMethod(reinterpret_cast<void*>(func));
+    jdouble result = R2CForwardStubDouble(std::forward<Args>(args)...);
+#else
+    jdouble result = R2CForwardStubDouble(reinterpret_cast<void*>(func), std::forward<Args>(args)...);
+#endif
+    return result;
+  }
+
+  template<typename Func>
+  static jdouble SlowCallCompiledMethod(Func func, jvalue *argJvalue, size_t stackSize, size_t dregSize) {
+    jdouble result = R2CBoxedStubDouble(reinterpret_cast<void*>(func), argJvalue, stackSize, dregSize);
+    return result;
+  }
+};
+
+inline jobject MRT_JNI_AddLocalReference(JNIEnv *env, jobject objAddr) {
+  if (env == nullptr) {
+    // it must be from static-binding native method,
+    // which it's in libcore-static-binding-jni/etc/static-binding-list.txt list.
+    // we needn't do encode, as native stub needn't do decode.
+    return objAddr;
+  }
+
+  maple::IThread *self = maple::IThread::Current();
+  return reinterpret_cast<jobject>(
+      (self == nullptr) ? nullptr : self->JniAddObj2LocalRefTbl(env, (reinterpret_cast<address_t>(objAddr))));
+}
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_CPP_HELPER_H
diff --git a/src/mrt/compiler-rt/include/deps.h b/src/mrt/compiler-rt/include/deps.h
new file mode 100644
index 0000000000000000000000000000000000000000..535cff7fe773e1542a21d7de900792caabce6652
--- /dev/null
+++ b/src/mrt/compiler-rt/include/deps.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_DEFS_H
+#define MAPLE_RUNTIME_DEFS_H
+
+#include <type_traits>
+
+namespace maplert {
+// utility class to avoid un-ordered static global destruction
+template<class T>
+class ImmortalWrapper {
+ public:
+  using pointer = typename std::add_pointer<T>::type;
+  using lref = typename std::add_lvalue_reference<T>::type;
+
+  template<class... Args>
+  ImmortalWrapper(Args && ...args) {
+    new(buffer) T(std::forward<Args>(args)...);
+  }
+  ImmortalWrapper(const ImmortalWrapper&) = delete;
+  ImmortalWrapper &operator=(const ImmortalWrapper&) = delete;
+  ~ImmortalWrapper() = default;
+  inline pointer operator->() {
+    return reinterpret_cast<pointer>(buffer);
+  }
+
+  inline lref operator*() {
+    return reinterpret_cast<lref>(buffer);
+  }
+
+ private:
+  alignas(T) unsigned char buffer[sizeof(T)];
+};
+} // namespace maplert
+#endif // MAPLE_RUNTIME_DEFS_H
diff --git a/src/mrt/compiler-rt/include/errno_utils.h b/src/mrt/compiler-rt/include/errno_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d2842fb82525b69ac41668f91e5e0698d6de8cc
--- /dev/null
+++ b/src/mrt/compiler-rt/include/errno_utils.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_RUNTIME_ERRNO_UTILS_H
+#define MPL_RUNTIME_ERRNO_UTILS_H
+
+#include <string>
+
+namespace maplert {
+std::string ErrnoToString(int errNum);
+} // namespace maplert
+#endif // MPL_RUNTIME_ERRNO_UTILS_H
diff --git a/src/mrt/compiler-rt/include/exception/eh_personality.h b/src/mrt/compiler-rt/include/exception/eh_personality.h
new file mode 100644
index 0000000000000000000000000000000000000000..d12324325b99c8b029047ccc32f5d77371e587f1
--- /dev/null
+++ b/src/mrt/compiler-rt/include/exception/eh_personality.h
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef _MPL_EH_PERSONALITY_H
+#define _MPL_EH_PERSONALITY_H
+
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <cstdint>
+#include <cstdio>
+#include <stdarg.h>
+#include <cstdlib>
+#include <exception>
+#include <typeinfo>
+
+#define EHLOG(level) LOG(level) << "<EH> "
+
+using MrtClass = void*;
+
+namespace maplert {
+const unsigned int kAbnormalFrameTag = 0x55555555;
+const unsigned int kNoExceptionTag = 0xFFFFFFFF;
+
+typedef enum {
+  kNoException = 0,
+  kNoFrame     = 1,
+  kNormal      = 2,
+} EHTableType;
+extern "C" {
+
+/* This section defines global identifiers and their values that are associated
+ * with interfaces contained in libgcc_s. These definitions are organized into
+ * groups that correspond to system headers. This convention is used as a
+ * convenience for the reader, and does not imply the existence of these headers,
+ * or their content.
+ * These definitions are intended to supplement those provided in the referenced
+ * underlying specifications.
+ * This specification uses ISO/IEC 9899 C Language as the reference programming
+ * language, and data definitions are specified in ISO C format. The C language
+ * is used here as a convenient notation. Using a C language description of these
+ * data objects does not preclude their use by other programming languages.
+ * http://refspecs.linuxbase.org/LSB_3.0.0/LSB-PDA/LSB-PDA/libgcc-s-ddefs.html
+ */
+typedef enum {
+  _URC_NO_REASON = 0,
+  _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
+  _URC_FATAL_PHASE2_ERROR = 2,
+  _URC_FATAL_PHASE1_ERROR = 3,
+  _URC_NORMAL_STOP = 4,
+  _URC_END_OF_STACK = 5,
+  _URC_HANDLER_FOUND = 6,
+  _URC_INSTALL_CONTEXT = 7,
+  _URC_CONTINUE_UNWIND = 8,
+} UnwindReasonCode;
+
+typedef enum {
+  kSearchPhase = 1,
+  kCleanupPhase = 2,
+} UnwindAction;
+
+using _Unwind_Word = uintptr_t;
+using _Unwind_Ptr = uintptr_t;
+using _Unwind_Exception_Class = uintptr_t;
+struct _Unwind_Context;
+struct _Unwind_Exception;
+
+typedef void (*_Unwind_Exception_Cleanup_Fn)(UnwindReasonCode, struct _Unwind_Exception*);
+
+#if defined(__aarch64__)
+struct _Unwind_Exception {
+  _Unwind_Exception_Class exception_class;
+  _Unwind_Exception_Cleanup_Fn exception_cleanup;
+  _Unwind_Word private_1;
+  _Unwind_Word private_2;
+} __attribute__((__aligned__));
+#elif defined(__arm__)
+struct _Unwind_Control_Block;
+#define _Unwind_Exception _Unwind_Control_Block
+#endif
+
+typedef UnwindReasonCode (*UnwindTraceFn)(const _Unwind_Context*, void*);
+
+void _Unwind_SetGR(struct _Unwind_Context*, int, _Unwind_Word);
+
+_Unwind_Word _Unwind_GetIP(struct _Unwind_Context*);
+void _Unwind_SetIP(struct _Unwind_Context*, _Unwind_Word);
+void _Unwind_Resume(struct _Unwind_Exception*);
+UnwindReasonCode _Unwind_Backtrace(UnwindTraceFn, void*);
+
+#if defined(__arm__)
+typedef enum {
+  _UVRSC_CORE  = 0, // INTEGER REGISTER
+  _UVRSC_VFP   = 1, // vfp
+  _UVRSC_WMMXD = 3, // Intel WMMX data register
+  _UVRSC_WMMXC = 4, // Intel WMMX control register
+} _Unwind_VRS_RegClass;
+
+typedef enum {
+  _UVRSD_UINT32  = 0,
+  _UVRSD_VFPX    = 1,
+  _UVRSD_UINT64  = 3,
+  _UVRSD_FLOAT   = 4,
+  _UVRSD_DOUBLE  = 5
+} _Unwind_VRS_DataRepresentation;
+
+typedef enum {
+  _UVRSR_OK      = 0,
+  _UVRSR_NOT_IMPLEMENTED = 1,
+  _UVRSR_FAILED  = 2
+} _Unwind_VRS_Result;
+
+typedef enum {
+  _US_VIRTUAL_UNWIND_FRAME = 0,
+  _US_UNWIND_FRAME_STARTING = 1,
+  _US_UNWIND_FRAME_RESUME = 2,
+  _US_ACTION_MASK = 3,
+  _US_FORCE_UNWIND = 8,
+  _US_END_OF_STACK = 16
+} _Unwind_State;
+
+_Unwind_VRS_Result _Unwind_VRS_Get(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
+    uint32_t regno, _Unwind_VRS_DataRepresentation representation, void *valuep);
+
+_Unwind_VRS_Result _Unwind_VRS_Set(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
+    uint32_t regno, _Unwind_VRS_DataRepresentation representation, void *valuep);
+
+typedef uintptr_t  _Unwind_EHT_Header;
+typedef uintptr_t  _uw;
+
+const unsigned int kExceptionClassNameLength = 8;
+const unsigned int kBarrierCachePatternSize = 5;
+const unsigned int kCleanupCachePatternSize = 4;
+
+// UCB:
+struct _Unwind_Control_Block {
+  char exception_class[kExceptionClassNameLength];
+  void (*exception_cleanup)(UnwindReasonCode, _Unwind_Control_Block*);
+  // Unwinder cache, private fields for the unwinder's use
+  struct {
+    _uw reserved1; // Forced unwind stop fn, 0 if not forced
+    _uw reserved2; // Personality routine address
+    _uw reserved3; // Saved callsite address
+    _uw reserved4; // Forced unwind stop arg
+    _uw reserved5;
+  }
+  unwinder_cache;
+  // Propagation barrier cache (valid after phase 1):
+  struct {
+    _uw sp;
+    _uw bitpattern[kBarrierCachePatternSize];
+  }
+  barrier_cache;
+  // Cleanup cache (preserved over cleanup):
+  struct {
+    _uw bitpattern[kCleanupCachePatternSize];
+  }
+  cleanup_cache;
+  // Pr cache (for pr's benefit):
+  struct {
+    _uw fnstart;              // function start address
+    _Unwind_EHT_Header *ehtp; // pointer to EHT entry header word
+    _uw additional;           // additional data
+    _uw reserved1;
+  }
+  pr_cache;
+  long long int :0; // Force alignment to 8-byte boundary
+};
+#endif
+}
+
+struct ScanResults {
+  uintptr_t      tTypeIndex;            // > 0 catch handler, < 0 exception spec handler, == 0 a cleanup
+  uintptr_t      landingPad;            // null -> nothing found, else something found
+  bool           caughtByJava;          // set if exception is caught by some java frame
+  UnwindReasonCode unwindReason;        // One of _URC_FATAL_PHASE1_ERROR,
+                                        //        _URC_FATAL_PHASE2_ERROR,
+                                        //        _URC_CONTINUE_UNWIND,
+                                        //        _URC_HANDLER_FOUND
+  ScanResults() {
+    tTypeIndex = 0;
+    landingPad = 0;
+    caughtByJava = false;
+    unwindReason = _URC_FATAL_PHASE1_ERROR;
+  }
+};
+
+class EHTable {
+ public:
+  ScanResults results;
+  bool CanCatch(const MrtClass catchType, const void *exObj);
+  uintptr_t ReadSData4(const uint8_t **p) const;
+  uintptr_t ReadULEB128(const uint8_t **data) const;
+  uintptr_t ReadTypeData(const uint8_t **data, bool use32Ref = false);
+  MrtClass GetMplTypeInfo(uintptr_t tTypeIndex, const uint8_t *classInfo);
+  void ScanExceptionTable(UnwindAction actions, bool nativeException, const _Unwind_Exception &unwindException);
+
+  void SetScanResultsValue(const uintptr_t tTypeIndex, const uintptr_t landingPad,
+                           const UnwindReasonCode unwindReason, const bool caughtByJava);
+
+  void ParseEHTableHeadInfo(const uint8_t *start);
+
+  EHTable(const uint32_t *funcStart, const uint32_t *funcEnd, const uint32_t *pc) {
+    funcEndPoint = funcEnd;
+    funcStartPoint = funcStart;
+    currentPC = pc;
+    if ((*funcEndPoint) == kNoExceptionTag) {
+      type = kNoException;
+      uintptr_t cleanupOffset = *(funcEndPoint + 1);
+      uintptr_t cleanupLabel = 0;
+      if (cleanupOffset != 0) {
+        cleanupLabel = reinterpret_cast<uintptr_t>(funcStartPoint) + cleanupOffset;
+      }
+      // Found a cleanup
+      SetScanResultsValue(0, cleanupLabel, _URC_HANDLER_FOUND, false);
+    } else if ((*funcEndPoint) == kAbnormalFrameTag) {
+      type = kNoFrame;
+      SetScanResultsValue(0, 0, _URC_HANDLER_FOUND, false);
+    } else {
+      type = kNormal;
+      uintptr_t lsdaOffset = *funcEndPoint;
+      ehTableStart = reinterpret_cast<const uint8_t*>(reinterpret_cast<uintptr_t>(funcStartPoint) + lsdaOffset);
+      curPtr = ehTableStart;
+      ParseEHTableHeadInfo(curPtr);
+    }
+  }
+
+ private:
+  EHTableType type;
+  const uint8_t *curPtr = nullptr;
+  const uint8_t *ehTableStart = nullptr;
+  const uint32_t *funcStartPoint = nullptr;
+  const uint32_t *funcEndPoint = nullptr;
+  const uint32_t *currentPC = nullptr;
+  const uint8_t *classInfoPoint = nullptr;
+  const uint8_t *callSiteTableStart = nullptr;
+  const uint8_t *callSiteTableEnd = nullptr;
+  const uint8_t *actionTableStart = nullptr;
+};
+
+#pragma GCC visibility push(hidden)
+
+#if defined(__aarch64__)
+// "MPLJAVA\0" for maple java runtime
+static const uint64_t kOurExceptionClass = 0x4d504c4a41564100;
+static const uint64_t kGetVendorAndLanguage = 0xFFFFFFFFFFFFFF00;
+#elif defined(__arm__)
+static const char kOurExceptionClass[kExceptionClassNameLength] = "MPLEC";
+static const uint32_t kGetVendorAndLanguage = 0xFFFFFF00;
+#endif
+
+#pragma GCC visibility pop
+
+extern "C" {
+#if defined(__aarch64__)
+__attribute__((__visibility__("default"))) UnwindReasonCode __mpl_personality_v0 (int version,
+    UnwindAction actions, uintptr_t exceptionClass, const _Unwind_Exception *unwindException,
+    const _Unwind_Context *context);
+#elif defined(__arm__)
+__attribute__((__visibility__("default"))) UnwindReasonCode __mpl_personality_v0(_Unwind_State state,
+    _Unwind_Exception *unwindException, _Unwind_Context *context);
+#endif
+} // extern "C"
+} // namespace maplert
+#endif  // _MPL_EH_PERSONALITY_H
diff --git a/src/mrt/compiler-rt/include/exception/exception_handling.h b/src/mrt/compiler-rt/include/exception/exception_handling.h
new file mode 100644
index 0000000000000000000000000000000000000000..d067d9de831f79d09549b9dd7136a5e69e1e5fe5
--- /dev/null
+++ b/src/mrt/compiler-rt/include/exception/exception_handling.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef _MPL_STACK_UNWIND_H_
+#define _MPL_STACK_UNWIND_H_
+
+#include <functional>
+#include <string>
+#include <map>
+#include <jni.h>
+#include "stack_unwinder.h"
+
+namespace maplert {
+const int kMethodDescOffset = 1;
+
+const int kPrevInsnOffset = 1;
+
+// offset used to tag a java frame, we adjust return address of a java frame
+// with this adderss, so that we can quickly tell whether a frame is java or not.
+const int kJavaFrameRaTag = 1;
+
+class EHFrameInfo : public JavaFrameInfo {
+ public:
+  void LookupExceptionHandler(const _Unwind_Exception &unwindException);
+
+  EHFrameInfo(const JavaFrame &frame, _Unwind_Exception &unwindException) : JavaFrameInfo(frame) {
+    mUnwindException = &unwindException;
+    // resolved is false in java function written with assembly
+    if (resolved) {
+      LookupExceptionHandler(unwindException);
+    }
+  }
+  EHFrameInfo(const EHFrameInfo&) = default;
+  ~EHFrameInfo() {
+    mCatchCode = nullptr;
+    mCleanupCode = nullptr;
+    mGeneralHandler = nullptr;
+    mUnwindException = nullptr;
+  }
+  const void *GetGeneralExceptionHandler() const {
+    return mGeneralHandler;
+  }
+
+  const void *GetCatchCode() const {
+    return mCatchCode;
+  }
+
+  const void *GetReturnAddress() const {
+    return javaFrame.GetReturnAddress();
+  }
+
+  const void *GetFrameAddress() const {
+    return javaFrame.GetFrameAddress();
+  }
+
+  // this will modify the return address of this frame to the exception handler, thus
+  // after the epilogue is executed, control flow turns to the exception handler.
+  inline void ChainToGeneralHandler(const void *handler) {
+    if (mGeneralHandler != nullptr) {
+      CallChain *fa = javaFrame.GetFrameAddress();
+      fa->returnAddress = reinterpret_cast<const uint32_t*>(handler);
+    }
+  }
+
+  // frameinfo is usually from the caller frame
+  inline void ChainToCallerEHFrame(const EHFrameInfo &frameinfo) {
+    uintptr_t handler = reinterpret_cast<uintptr_t>(frameinfo.GetGeneralExceptionHandler());
+    ChainToGeneralHandler(reinterpret_cast<void*>(handler));
+  }
+
+  void Dump(const std::string msg, std::stringstream &ss) override {
+    JavaFrameInfo::Dump(msg, ss);
+    if (mCleanupCode != nullptr) {
+      ss << "\t" << "cleanup code : " << std::hex << reinterpret_cast<uintptr_t>(mCleanupCode) << std::dec;
+    }
+    if (mCatchCode != nullptr) {
+      ss << "\t" << "catch code   : " << std::hex << reinterpret_cast<uintptr_t>(mCatchCode) << std::dec;
+    }
+  }
+ private:
+  const void *mCatchCode   = nullptr;            // exception handler
+  const void *mCleanupCode = nullptr;            // extended epilogue (including clean up code)
+  const void *mGeneralHandler = nullptr;         // exception handler or extended epilogue (including clean up code).
+  _Unwind_Exception *mUnwindException = nullptr; // this value is propagated from EHStackInfo.
+};
+
+class EHStackInfo {
+ public:
+  void Build(_Unwind_Exception &unwindException, bool isRet = false);
+  void ChainAllEHFrames(const _Unwind_Exception &unwindException, bool isRet = false, bool isImplicitNPE = false);
+  EHStackInfo() : priUnwindException(nullptr) {}
+  explicit EHStackInfo(_Unwind_Exception &unwindException) {
+    priUnwindException = &unwindException;
+    Build(unwindException);
+  }
+  ~EHStackInfo() {
+    priUnwindException = nullptr;
+  }
+ private:
+  std::vector<EHFrameInfo> priEhStackInfo;
+  BasicFrame C2RStub;
+  _Unwind_Exception *priUnwindException;
+};
+
+void RaiseException(struct _Unwind_Exception &unwindException, bool isRet = false, bool isImplicitNPE = false);
+} // end namespace maplert
+
+#endif // _MPL_STACK_UNWIND_H_
diff --git a/src/mrt/compiler-rt/include/exception/mpl_exception.h b/src/mrt/compiler-rt/include/exception/mpl_exception.h
new file mode 100644
index 0000000000000000000000000000000000000000..c30465c047b90759b9c15a5f3b4db113c044a268
--- /dev/null
+++ b/src/mrt/compiler-rt/include/exception/mpl_exception.h
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef _MPL_EXCEPTION_H
+#define _MPL_EXCEPTION_H
+
+#include <cstdint>
+#include "cinterface.h"
+#include "eh_personality.h"
+#include "exception_handling.h"
+#include "stack_unwinder.h"
+#include "base/logging.h"
+
+namespace maplert {
+extern "C" {
+#if defined(__arm__)
+enum Register {
+  kR0  = 0,
+  kR1  = 1,
+  KR12 = 12,
+  kFP  = 11,
+  kLR  = 14,
+  kPC  = 15,
+};
+inline _Unwind_Ptr _Unwind_GetIP(_Unwind_Context*) {
+  return 0;
+}
+
+inline void _Unwind_SetGR(struct _Unwind_Context*, int, _Unwind_Word) {}
+inline void _Unwind_SetIP(struct _Unwind_Context*, _Unwind_Word) {}
+#elif defined(__aarch64__)
+enum Register {
+  kX0  = 0,
+  kX17 = 17,
+  kFP  = 29,
+  kLR  = 30,
+};
+#endif
+
+// exception header for maple
+struct MExceptionHeader {
+  std::type_info *exceptionType;
+  void (*exceptionDestructor)(void*);
+  // top java frame landing pad or clean up entry.
+  const void *topJavaHandler;
+  int handlerCount;
+  int handlerSwitchValue;
+  const unsigned char *actionRecord;
+  const unsigned char *languageSpecificData;
+  // exception handler of the Java frame if caught,
+  // otherwise the continuation in native-to-java frame
+  void *realHandler;
+  uintptr_t tTypeIndex;
+  // caught by Java context
+  bool caughtByJava;
+  // instruction pointer of signaling point for signal handlers
+  // null if not signal handler context
+  void *sigIP;
+#if defined(__aarch64__)
+  _Unwind_Exception unwindHeader;
+#elif defined(__arm__)
+  _Unwind_Control_Block unwindHeader;
+#endif
+};
+
+// struct are 16-byte algned, so we need a header and let compiler calculate the offset.
+struct MplException {
+  MExceptionHeader exceptionHeader;
+  // the reference to the thrown object must be placed here.
+  // adjust GetThrownException and GetThrownExceptionHeader if you modify
+  // this layout.
+  jthrowable thrownObject;
+};
+
+static inline MplException *MplExceptionFromThrownObject(MrtClass *thrownPtr) {
+  if (thrownPtr != nullptr) {
+    return reinterpret_cast<MplException*>(reinterpret_cast<MExceptionHeader*>(thrownPtr) - 1);
+  } else {
+    EHLOG(FATAL) << "thrownPtr should not be null!" << maple::endl;
+    return nullptr;
+  }
+}
+
+static inline jthrowable GetThrownObject(const _Unwind_Exception &unwindException) {
+  if (const_cast<_Unwind_Exception*>(&unwindException) != nullptr) {
+    jthrowable thrown = *reinterpret_cast<jthrowable*>(const_cast<_Unwind_Exception*>(&unwindException) + 1);
+    return thrown;
+  } else {
+    EHLOG(FATAL) << "unwindException should not be null!" << maple::endl;
+    return nullptr;
+  }
+}
+
+// Get the exception object from the unwind pointer.
+// Relies on the structure layout, where the unwind pointer is right in
+// front of the user's exception object
+static inline MExceptionHeader *GetThrownExceptionHeader(const _Unwind_Exception &unwindException) {
+  if (const_cast<_Unwind_Exception*>(&unwindException) != nullptr) {
+    return reinterpret_cast<MExceptionHeader*>(MplExceptionFromThrownObject(reinterpret_cast<MrtClass*>(
+        const_cast<_Unwind_Exception*>(&unwindException) + 1)));
+  } else {
+    EHLOG(FATAL) << "unwindException should not be null!" << maple::endl;
+    return nullptr;
+  }
+}
+
+static inline MplException *GetThrownException(const _Unwind_Exception &unwindException) {
+  if (const_cast<_Unwind_Exception*>(&unwindException) != nullptr) {
+    return MplExceptionFromThrownObject(reinterpret_cast<MrtClass*>(
+        const_cast<_Unwind_Exception*>(&unwindException) + 1));
+  } else {
+    EHLOG(FATAL) << "unwindException should not be null!" << maple::endl;
+    return nullptr;
+  }
+}
+
+void MplThrow(const MrtClass &thrownObject, bool isRet = false, bool isImplicitNPE = false);
+
+void MplDumpStack(const std::string &msg = "");
+
+void MplCheck(bool ok, const std::string &msg = "");
+} // extern "C"
+} // namespace maplert
+
+#endif  // _MPL_EXCEPTION_H
diff --git a/src/mrt/compiler-rt/include/exception/mrt_exception.h b/src/mrt/compiler-rt/include/exception/mrt_exception.h
new file mode 100644
index 0000000000000000000000000000000000000000..24b51cfb339f3075a94b9cc20aa2862c99b8b017
--- /dev/null
+++ b/src/mrt/compiler-rt/include/exception/mrt_exception.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_EXCEPTION_H_
+#define MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_EXCEPTION_H_
+
+#include "jni.h"
+#include "mrt_object.h"
+#include "mrt_string.h"
+#include "mrt_array.h"
+#include "mrt_reflection.h"
+#include "mrt_exception_api.h" // exported API declaration
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+class ScopedException {
+ public:
+  ScopedException() = default;
+
+  ~ScopedException() {
+    MRT_CheckThrowPendingExceptionRet();
+  }
+};
+
+// record an exception if delayed handling is expetced.
+void MRT_ThrowExceptionSafe(jobject ex);   // check whether ex is throwable
+void MRT_ThrowExceptionUnsafe(jobject ex); // do not check, throw anything
+
+void MRT_ClearPendingException();
+void MRT_ClearThrowingException();
+
+// null if no pending exception. if return value is not null, an exception is
+// raised earlier, and should be handled or rethrown some time later.
+jobject MRT_PendingException();
+bool MRT_HasPendingException();
+void __MRT_SetPendingException(jobject e);
+void MRT_InvokeResetHandler();
+
+// Note: these functions do not raise exception immediately.
+// It saves exception to so-called pending exception which will be raised when
+// control flow leaves a JNI stub frame to return to Java frame.
+// ThrowNewExceptionInternalTypeUnw() will be called automatically in JNI stub frame
+// which is inserted by maple compiler.
+// If you want to bypass JNI stub frame, please do call ThrowNewExceptionInternalTypeUnw()
+// when you are ready to return to a Java frame from a native frame.
+// For other normal situations, only MRT_ThrowNewException() is allowed to be invoked
+// in normal native code.
+void MRT_ThrowNewExceptionInternalType(MrtClass classType, const char *msg = "unknown reason");
+void MRT_ThrowNewException(const char *className, const char *msg = "unknown reason");
+// Note: these functions raise exception immediately.
+void ThrowExceptionUnw(MrtClass e);
+void ThrowNewExceptionInternalTypeUnw(MrtClass classType, const char *kMsg = "unknown reason");
+
+void MRT_DecRefThrowExceptionUnw(MrtClass obj, const void *sigIP = nullptr);
+void MRT_DecRefThrowExceptionRet(MrtClass obj, bool isImplicitNPE  = false, const void *sigIP = nullptr);
+
+// note JNI native code is different from runtime native code for raising exception
+// if we raise exceptions in runtime, it is thrown immediately. On the other hand,
+// exceptions raised in native code is delayed until it is prepared to return to its caller.
+void MRT_ThrowImplicitNullPointerExceptionUnw(const void *sigIP);
+void MRT_ThrowArithmeticExceptionUnw();
+void MRT_ThrowClassCastExceptionUnw(const std::string msg = "unknown reason");
+void MRT_ThrowStringIndexOutOfBoundsExceptionUnw();
+void MRT_ThrowUnsatisfiedLinkErrorUnw();
+void MRT_ThrowArrayStoreExceptionUnw(const std::string msg = "unknown reason");
+void MRT_ThrowInterruptedExceptionUnw();
+void MRT_ThrowExceptionInInitializerErrorUnw(MrtClass cause);
+void MRT_ThrowNoClassDefFoundErrorUnw(const char *msg);
+void MRT_ThrowNoClassDefFoundErrorClassUnw(const void *classInfo);
+void MRT_ThrowNoSuchMethodErrorUnw(const std::string &msg);
+void MRT_ThrowNoSuchFieldErrorUnw(const std::string &msg);
+void MRT_ThrowVerifyErrorUnw(const std::string &msg);
+
+// Note: these functions raise exception by pending
+void MRT_ThrowNullPointerException();
+void MRT_ThrowImplicitNullPointerException();
+void MRT_ThrowArithmeticException();
+void MRT_ThrowClassCastException(const std::string msg = "unknown reason");
+void MRT_ThrowStringIndexOutOfBoundsException();
+void MRT_ThrowUnsatisfiedLinkError();
+void MRT_ThrowArrayStoreException(const std::string msg = "unknown reason");
+void MRT_ThrowInterruptedException();
+void MRT_ThrowExceptionInInitializerError(MrtClass cause);
+void MRT_ThrowNoClassDefFoundError(const std::string &msg);
+void MRT_ThrowNoSuchMethodError(const std::string &msg);
+void MRT_ThrowNoSuchFieldError(const std::string &msg);
+void MRT_ThrowVerifyError(const std::string &msg);
+
+extern list<std::string> ehObjectList;
+extern std::map<std::string, uint64_t> ehObjectStackMap;
+extern std::mutex ehObjectListLock;
+extern std::mutex ehObjectStackMapLock;
+
+#ifdef __cplusplus
+} // namespace maplert
+} // extern "C"
+#endif
+
+#endif // MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_EXCEPTION_H_
diff --git a/src/mrt/compiler-rt/include/exception/stack_unwinder.h b/src/mrt/compiler-rt/include/exception/stack_unwinder.h
new file mode 100644
index 0000000000000000000000000000000000000000..d511650c62816ece5875a39b6448831a5994e9dd
--- /dev/null
+++ b/src/mrt/compiler-rt/include/exception/stack_unwinder.h
@@ -0,0 +1,627 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// Stack unwinder
+//
+// The stack unwinder iterates through the frames of a stack from the top to
+// the bottom.  The main purpose is:
+//
+// 1. During garbage collection, it reveals the register and stack states at the
+// call site of each frame (without modifying the frames) in order to helps the
+// stack scanner identify object references held on the stack.
+//
+// It may also server the following purposes:
+//
+// 2. During exception handling, it removes stack frames from the top of the
+// stack.  Alternatively, exception handling can be done using the system ABI.
+//
+// The design is mainly inspired by:
+//
+// a) libunwind
+//    Original implementation: http://www.nongnu.org/libunwind/
+//    LLVM implementation: http://releases.llvm.org/download.html
+// b) The stack introspection API for the Mu micro virtual machine
+//    https://gitlab.anu.edu.au/mu/mu-spec/blob/master/api.rst#stack-introspection
+//
+#ifndef __MAPLERT_STACKUNWINDER_H__
+#define __MAPLERT_STACKUNWINDER_H__
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <map>
+#include <mutex>
+#include <jni.h>
+#include <utils/time_utils.h>
+
+#include "cinterface.h"
+#include "linker_api.h"
+#include "eh_personality.h"
+#include "metadata_layout.h"
+
+#define MAPLE_STACK_UNWIND_STEP_MAX 8000UL
+
+namespace maplert {
+enum UnwindState {
+  kUnwindFail   = 0,
+  kUnwindSucc   = 1,
+  kUnwindFinish = 2,
+};
+
+// this data struct matches the machine frame layout for both aarch64 and arm.
+//                 |  ...           |
+//                 |  ...           |
+//                 |  lr to caller  | return address for this frame
+//        fp  -->  |  caller fp     |
+//                 |  ...           |
+//        sp  -->  |  ...           |
+// pointer to CallChain is actually frame address (fp)
+struct CallChain {
+  CallChain *callerFrameAddress;
+  const uint32_t *returnAddress;
+};
+
+// do not ever define any virtual method for BasicFrame
+// we should rename BasicFrame to MachineFrame
+class BasicFrame {
+ public:
+  // fa: frame address of this frame, for now this is frame pointer
+  CallChain *fa;
+
+  // ip: instruction pointer, the value in PC register when unwinding this frame,
+  // which points to the instruction when control flow returns from callee to this frame.
+  const uint32_t *ip;
+
+  // ra: return address of this frame. For a normal frame, this can
+  // be retrieved from frame address,
+  const uint32_t *ra;
+
+  // lr: Specific to frames which do not have a normal frame structure.
+  // This field is 0 for a normal frame, because we can always retrieve return address from CallChain.
+  // If not null, this field indicates the return address.
+  // This is necessary for segv occured in a frame without data on stack .
+  const uint32_t *lr;
+
+  void Reset() {
+    ip = nullptr;
+    fa = nullptr;
+    lr = nullptr;
+    ra = nullptr;
+  }
+
+  BasicFrame() {
+    Reset();
+  }
+
+  BasicFrame(const uint32_t *ip, CallChain *fa, const uint32_t *ra) : fa(fa), ip(ip), ra(ra), lr(nullptr) {}
+
+  explicit BasicFrame(const BasicFrame &frame) {
+    CopyFrom(frame);
+  }
+
+  BasicFrame& operator=(const BasicFrame &frame) {
+    CopyFrom(frame);
+    return *this;
+  }
+
+  virtual ~BasicFrame() = default;
+
+  void Dump(const std::string msg, std::stringstream &ss) const {
+    static constexpr size_t defaultBufSize = 128;
+    char buf[defaultBufSize];
+    if (snprintf_s(buf, sizeof buf, sizeof buf,
+                   ": frame pc %p, frame address %p, retrun to %p, link register %p", ip, fa, ra, lr) < 0) {
+      LOG(ERROR) << "Dump snprintf_s fail" << maple::endl;
+    }
+    ss << msg << buf;
+  }
+
+  void Dump(const std::string msg) const {
+    std::stringstream ss;
+    Dump(msg, ss);
+    EHLOG(INFO) << ss.str() << maple::endl;
+  }
+
+  void Check(bool val, const char *msg) const;
+
+  const uint32_t *GetFramePC() const {
+    return ip;
+  }
+
+  void SetFramePC(const void *pc) {
+    ip = static_cast<const uint32_t*>(pc);
+  }
+
+  CallChain *GetFrameAddress() const {
+    return fa;
+  }
+
+  const uint32_t *GetReturnAddress() const {
+    return ra;
+  }
+
+  const uint32_t *GetLR() const {
+    return lr;
+  }
+
+  inline bool IsCompiledFrame() const {
+    return LinkerAPI::Instance().IsJavaText(ip);
+  }
+
+  inline bool IsR2CFrame() const {
+    return (reinterpret_cast<uintptr_t>(ra) & 1) == 1;
+  }
+
+  // note: this method takes advantage of JavaMethodHasNoFrame
+  inline bool HasFrameStructure() const {
+    return lr == nullptr;
+  }
+
+  // The anchor frame is conceptually a sentinel frame, whose
+  // fp/ip is all zeros. This frame does not exists but is natually a good
+  // choice to detect the completion of unwinding if we initialize fp/ip to null.
+  inline bool IsAnchorFrame() const {
+    return (fa == nullptr);
+  }
+
+  inline void CopyFrom(const BasicFrame &frame) {
+    ip = frame.ip;
+    fa = frame.fa;
+    ra = frame.ra;
+    lr = frame.lr;
+  }
+
+  // return kUnwindSucc or kUnwindFinish only, do not return kUnwindFail.
+  // caller assures this frame is a normal frame.
+  // we name the direct caller frame in machine stack with "machine caller".
+  UnwindState UnwindToMachineCaller(BasicFrame &caller) const;
+};
+
+// JavaFrame should be renamed to CommonFrame or just Frame
+class JavaFrame : public BasicFrame {
+ public:
+  JavaFrame() : BasicFrame() {
+    md = nullptr;
+  }
+
+  // caller assures this frame is a normal frame.
+  UnwindState UnwindToNominalCaller(JavaFrame &caller) const;
+  UnwindState UnwindToJavaCallerFromRuntime(JavaFrame &frame, bool isEH = false);
+
+  // format: class|method|signature
+  MRT_EXPORT static bool GetJavaMethodFullName(std::string &name, const uint64_t *md);
+
+  // method|signature
+  MRT_EXPORT static void GetJavaMethodSignatureName(std::string &name, const void *md);
+  // method
+  MRT_EXPORT static void GetJavaMethodName(std::string &name, const void *md);
+  // class: A.B.C
+  MRT_EXPORT static void GetJavaClassName(std::string &name, const uint64_t *md);
+
+  MRT_EXPORT static jclass GetDeclaringClass(const uint64_t *md);
+
+  MRT_EXPORT static uint64_t *GetMethodMetadata(const uint32_t *startPC);
+  MRT_EXPORT static const MethodDesc *GetMethodDesc(const uint32_t *startPC);
+
+  MRT_EXPORT static uint64_t GetRelativePc(
+      const std::string &soName, uint64_t pc, LinkerMFileInfo *mplInfo = nullptr);
+
+  static bool GetMapleMethodFullName(std::string &name, const uint64_t *md, const void *ip);
+  // format: <class-name>|<method-name>|<signature>
+  MRT_EXPORT static bool GetMapleMethodFullName(std::string &name, const uint64_t *md);
+
+  // Maple-mangled format
+  static void GetMapleClassName(std::string &name, const uint64_t *md);
+
+  // for resolving symbols of call stack
+  static bool DumpProcInfo(uintptr_t pc, std::string *name = nullptr);
+  static void DumpProcInfoLog(jlong elem);
+
+  static bool JavaMethodHasNoFrame(const uint32_t *ip);
+
+  inline void ResolveMethodMetadata() {
+    if (md == nullptr) {
+      LinkerLocInfo info;
+      if (LinkerAPI::Instance().LocateAddress(const_cast<uint32_t*>(ip), info, false)) {
+        md = static_cast<uint64_t*>(
+            GetMethodMetadata(reinterpret_cast<uint32_t*>(reinterpret_cast<uintptr_t>(info.addr))));
+      }
+    }
+  }
+
+  inline jclass GetDeclaringClass() {
+    ResolveMethodMetadata();
+    return GetDeclaringClass(md);
+  }
+
+  // format: class|method|signature
+  inline void GetJavaMethodFullName(std::string &name) {
+    ResolveMethodMetadata();
+    (void)GetJavaMethodFullName(name, md);
+  }
+  // method|signature
+  inline void GetJavaMethodSignatureName(std::string &name) {
+    ResolveMethodMetadata();
+    GetJavaMethodSignatureName(name, md);
+  }
+
+  // method
+  inline void GetJavaMethodName(std::string &name) {
+    ResolveMethodMetadata();
+    GetJavaMethodName(name, md);
+  }
+
+  // class: A.B.C
+  inline void GetJavaClassName(std::string &name) {
+    ResolveMethodMetadata();
+    GetJavaClassName(name, md);
+  }
+
+  // Maple-mangled format
+  inline void GetMapleClassName(std::string &name) {
+    ResolveMethodMetadata();
+    GetMapleClassName(name, md);
+  }
+
+  inline const uint64_t *GetMetadata() const {
+    return md;
+  }
+
+  inline void SetMetadata(const uint64_t *metadata) {
+    md = metadata;
+  }
+ private:
+  const uint64_t *md; // mMD: Metadata for this Java method, nullptr indicates unresolved
+};
+
+// UnwindData is a helper for retrieving previous java context.
+// this data struct should match the layout defined in r2c_stub
+struct UnwindData {
+  const uint32_t *pc;
+  CallChain *fa;
+  const uint32_t *lr;
+  uintptr_t ucstatus;
+  uintptr_t interpFrame;
+  uintptr_t directCallJava;
+};
+
+// R2CFrame is a stub frame constructed by runtime code to invoke compiled java methods. R2CFrame saves
+// its java caller context as it is for unwinding. R2CStub is implemented in r2c_stub_xx.S.
+// Runtime code must be always compiled with -fno-omit-frame-pointer to maintain standard frame layout according to ABI.
+class R2CFrame : public BasicFrame {
+ public:
+  R2CFrame() : BasicFrame() {}
+  R2CFrame(const uint32_t *ip, CallChain *fa, const uint32_t *ra) : BasicFrame(ip, fa, ra) {}
+
+  // return kUnwindSucc or kUnwindFinish only, do not return kUnwindFail
+  UnwindState UnwindToJavaCaller(JavaFrame &caller) const;
+
+  static UnwindData *GetUnwindData(CallChain *fa) {
+    return reinterpret_cast<UnwindData*>(fa + kOffsetForUnwindData);
+  }
+
+  UnwindData *GetUnwindData() {
+    return GetUnwindData(this->fa);
+  }
+ private:
+  static constexpr size_t kOffsetForUnwindData = 1;
+};
+
+enum UnwindContextStatus {
+  UnwindContextStatusIsIgnored = 0x12345678, // ignore this status when unwinding to caller context
+  UnwindContextIsReliable = 1, // we should unwind these frames one by one
+  UnwindContextIsRisky    = 2, // we should cross these frames to get to previous java frame
+};
+
+extern "C" void MRT_UpdateLastUnwindFrameLR(const uint32_t *lr);
+extern "C" void MRT_UpdateLastUnwindContext(const uint32_t *pc, CallChain *fp, UnwindContextStatus status);
+
+// UnwindContext contains all information needed for stack unwinding.
+// *frame* is current frame which is start point for stack unwinding.
+// If *status* is UnwindContextIsReliable, caller frame is constructed by inspecting frame structure according to ABI.
+// Otherwise, if *status* is UnwindContextIsRisky, caller frame is constructed either from TLS when we get
+// last-java-frame, or by inspecting R2J frame structure if *frame* is a R2J frame.
+struct UnwindContext {
+  UnwindContextStatus status = UnwindContextIsRisky;
+  JavaFrame frame; // BasicFrame
+  void *interpFrame = nullptr; // if not null, some interpreted frame is the last java frame
+
+  bool hasDirectJavaCallee = false; // tag when interpreted method calls a compiled method, used only by R2C stub
+ public:
+  inline void *GetInterpFrame() {
+    return interpFrame;
+  }
+  inline void SetInterpFrame(void *newInterpFrame) {
+    interpFrame = newInterpFrame;
+  }
+  inline bool HasDirectJavaCallee() const {
+    return hasDirectJavaCallee;
+  }
+  inline void TagDirectJavaCallee(bool val) {
+    hasDirectJavaCallee = val;
+  }
+  inline void Reset() {
+    status = UnwindContextIsRisky;
+    frame.Reset();
+    interpFrame = nullptr;
+    hasDirectJavaCallee = false;
+  }
+  inline void CopyFrom(const UnwindContext &context) {
+    this->status = context.status;
+    this->interpFrame = context.interpFrame;
+    this->hasDirectJavaCallee = context.hasDirectJavaCallee;
+    this->frame.CopyFrom(context.frame);
+  }
+
+  bool IsCompiledContext() const {
+    return frame.IsCompiledFrame();
+  }
+  bool IsInterpretedContext() const {
+    return (interpFrame != nullptr);
+  }
+  bool IsJavaContext() const {
+    return IsCompiledContext() || IsInterpretedContext();
+  }
+  bool IsStackBottomContext() const;
+
+  UnwindState UnwindToCallerContext(UnwindContext &caller, bool isEH = false) const;
+  UnwindState UnwindToCallerContextFromR2CStub(UnwindContext &caller) const;
+  void UpdateFrame(const uint32_t *pc, CallChain *fp);
+
+  void RestoreUnwindContextFromR2CStub(CallChain *fa); // fa is the address of R2CStub frame
+  static UnwindState GetStackTopUnwindContext(UnwindContext &context);
+};
+
+struct InitialUnwindContext {
+ public:
+  UnwindContext &GetContext() {
+    return uwContext;
+  }
+
+  bool IsEffective() const {
+    return effective.load(std::memory_order_acquire);
+  }
+
+  void SetEffective(bool value) {
+    effective.store(value, std::memory_order_release);
+  }
+
+  void CopyFrom(InitialUnwindContext &context) {
+    uwContext.CopyFrom(context.GetContext());
+    effective.store(context.effective.load(std::memory_order_acquire), std::memory_order_release);
+  }
+
+ private:
+  UnwindContext uwContext;
+  std::atomic<bool> effective = { true };
+};
+
+class JavaFrameInfo {
+ public:
+  void VisitGCRoots(const AddressVisitor &func) {
+    const JavaFrame &thisFrame = GetJavaFrame();
+    const MethodDesc *desc = JavaFrame::GetMethodDesc(GetStartPC());
+    uintptr_t localRefStart = reinterpret_cast<uintptr_t>(thisFrame.GetFrameAddress()) + desc->localRefOffset;
+    for (size_t i = 0; i < desc->localRefNumber; ++i) {
+      uintptr_t localRefSlot = localRefStart + i * sizeof(address_t);
+      address_t &localRef = *reinterpret_cast<address_t*>(localRefSlot);
+      func(localRef);
+    }
+  }
+
+  const uint32_t *GetEndPC() const {
+    return endIp;
+  }
+
+  void SetEndPC(uint32_t *pc) {
+    endIp = pc;
+  }
+
+  const uint32_t *GetStartPC() const {
+    return startIp;
+  }
+
+  void SetStartPC(uint32_t *pc) {
+    startIp = pc;
+  }
+
+  // These asm frame are in the jave section, but not in any java type.
+  bool IsAsmFrame() const {
+    return (startIp == nullptr);
+  }
+
+  const JavaFrame &GetJavaFrame() const {
+    return javaFrame;
+  }
+
+  inline void Build(const JavaFrame &frame) {
+    this->javaFrame = frame;
+    ResolveFrameInfo();
+  }
+
+  inline void CopyFrom(const JavaFrameInfo &frameInfo) {
+    this->javaFrame = frameInfo.javaFrame;
+    this->startIp = frameInfo.startIp;
+    this->endIp = frameInfo.endIp;
+    this->resolved = frameInfo.resolved;
+  }
+
+  JavaFrameInfo(uint32_t *startIP, uint32_t *endIP, const void *pc) {
+    startIp = startIP;
+    endIp = endIP;
+    javaFrame.SetFramePC(pc);
+  }
+
+  explicit JavaFrameInfo(const JavaFrame &frame) {
+    Build(frame);
+  }
+
+  explicit JavaFrameInfo(const JavaFrameInfo &frameInfo) {
+    CopyFrom(frameInfo);
+  };
+
+  virtual ~JavaFrameInfo() = default;
+ protected:
+  JavaFrame javaFrame;
+  uint32_t *startIp;
+  uint32_t *endIp;       // endIp == lsda, when the lsda is next to the .cfi_endproc
+  bool resolved = false; // true if proc_info_ is valid
+
+  inline void ResolveMethodMetadata() {
+    if (javaFrame.GetMetadata() == nullptr && startIp != nullptr) {
+      uint64_t *md = JavaFrame::GetMethodMetadata(reinterpret_cast<uint32_t*>(reinterpret_cast<uintptr_t>(startIp)));
+      javaFrame.SetMetadata(md);
+    }
+  }
+
+  void ResolveFrameInfo();
+
+  virtual void Dump(const std::string msg, std::stringstream &ss) {
+    std::string name;
+    javaFrame.GetJavaMethodFullName(name);
+    ss << msg << " --- java frame info " << "\n" <<
+        "\t" << "name         : " << name << "\n" << std::hex <<
+        "\t" << "current pc   : " << javaFrame.ip << "\n" <<
+        "\t" << "start pc     : " << startIp << "\n" <<
+        "\t" << "end pc       : " << endIp << "\n" <<
+        std::dec;
+  }
+};
+
+using RemoteUnwindStatus = enum {
+  kRemoteUnwindIdle,
+  kRemoteLastJavaFrameUpdataFinish,
+  kRemoteUnwindFinish,
+  kRemoteTargetThreadSignalHandlingExited,
+};
+
+class RemoteUnwinder {
+ public:
+  RemoteUnwinder() {
+    remoteUnwindStatus = kRemoteUnwindIdle;
+    remoteIdle = true;
+    unwinderIdle = true;
+  }
+
+  ~RemoteUnwinder() = default;
+
+  std::mutex &GetRemoteUnwindLock() {
+    return remoteUnwindLock;
+  }
+
+  void SetRemoteUnwindStatus(RemoteUnwindStatus status) {
+    remoteUnwindStatus = status;
+  }
+
+  void SetRemoteIdle(bool status) {
+    remoteIdle = status;
+  }
+
+  void SetUnwinderIdle(bool status) {
+    unwinderIdle = status;
+  }
+
+  bool IsUnwinderIdle() const {
+    return unwinderIdle;
+  }
+
+  bool WaitForRemoteIdle() const {
+    uint64_t times = 0;
+    constexpr uint64_t maxTimes = 500000;
+    while (remoteIdle != true) {
+      ++times;
+      if (times > maxTimes) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool WaitRemoteUnwindStatus(RemoteUnwindStatus status) const {
+    uint64_t times = 0;
+    constexpr uint64_t maxTimes = 500000;
+    if (remoteIdle == true) {
+      return false;
+    }
+    while (remoteUnwindStatus != status) {
+      ++times;
+      if (times > maxTimes) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+ private:
+  std::atomic<bool> remoteIdle;
+  std::atomic<bool> unwinderIdle;
+  std::mutex remoteUnwindLock;
+  std::atomic<RemoteUnwindStatus> remoteUnwindStatus;
+};
+
+class MapleStack {
+ public:
+  MapleStack() = default;
+  ~MapleStack() = default;
+
+  // the last java frame is on the top of java call stack.
+  static UnwindState GetLastJavaContext(UnwindContext &context, const UnwindContext &initialContext, uint32_t tid);
+  static UnwindState GetLastJavaFrame(JavaFrame &frame, const UnwindContext *initialContext = nullptr,
+                                      bool isEH = false);
+
+
+  const inline std::vector<JavaFrame> &GetStackFrames() {
+    return stackFrames;
+  }
+  inline std::vector<UnwindContext> &GetContextStack() {
+    return uwContextStack;
+  }
+
+  inline void AddFrame(const JavaFrame &frame) {
+    stackFrames.push_back(frame);
+  }
+
+  // visit GC roots of current java thread for tracing GC
+  static void VisitJavaStackRoots(const UnwindContext &initialContext, const AddressVisitor &func, uint32_t tid);
+
+  MRT_EXPORT static void FastRecordCurrentJavaStack(std::vector<UnwindContext> &uwContextStack,
+                                                    size_t steps = MAPLE_STACK_UNWIND_STEP_MAX,
+                                                    bool resolveMD = false);
+
+  MRT_EXPORT static void FastRecordCurrentJavaStack(MapleStack &callStack,
+                                                    size_t steps = MAPLE_STACK_UNWIND_STEP_MAX,
+                                                    bool resolveMD = false) {
+    FastRecordCurrentJavaStack(callStack.GetContextStack(), steps, resolveMD);
+  }
+
+  MRT_EXPORT static void *VisitCurrentJavaStack(UnwindContext &uwContext,
+                                                std::function<void* (UnwindContext&)> filter);
+
+  MRT_EXPORT static void FastRecordCurrentStackPCsByUnwind(std::vector<uint64_t> &framePCs,
+                                                           size_t steps = MAPLE_STACK_UNWIND_STEP_MAX);
+
+  MRT_EXPORT static void FastRecordCurrentStackPCs(std::vector<uint64_t> &framePCs,
+                                                   size_t steps = MAPLE_STACK_UNWIND_STEP_MAX);
+
+  MRT_EXPORT static void RecordStackPCs(std::vector<uint64_t> &framePCs, uint32_t tid,
+                                        size_t steps = MAPLE_STACK_UNWIND_STEP_MAX);
+
+ private:
+  std::vector<JavaFrame> stackFrames;
+  std::vector<UnwindContext> uwContextStack;
+};
+} // namespace maplert
+
+#endif // __MAPLERT_STACKUNWINDER_H__
diff --git a/src/mrt/compiler-rt/include/fast_alloc_inline.h b/src/mrt/compiler-rt/include/fast_alloc_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..efe732e100a3923e1799f7474359f70c05b7c5df
--- /dev/null
+++ b/src/mrt/compiler-rt/include/fast_alloc_inline.h
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_FAST_ALLOC_INLINE_H
+#define MAPLE_RUNTIME_FAST_ALLOC_INLINE_H
+
+#include "chosen.h"
+#include "sizes.h"
+
+namespace maplert {
+#if ALLOC_USE_FAST_PATH
+// common fast allocation routine, it assumes the size is aligned, and
+// it shouldn't be too big (bigger than large obj size)
+__attribute__ ((always_inline))
+static address_t MRT_TryNew(size_t alignedObjSize, address_t klass) {
+  address_t objAddr = (*theAllocator).FastNewObj(alignedObjSize);
+  if (LIKELY(objAddr != 0)) {
+    StoreRefField(objAddr, kMrtKlassOffset, klass);
+    // in rc mode, we need to set cycle bits and rc bits
+    // this produces very long code, need to optimise
+    GCTibGCInfo *gcInfo = reinterpret_cast<GCTibGCInfo*>(reinterpret_cast<MClass*>(klass)->GetGctib());
+    CHECK(gcInfo != nullptr) << "MRT_TryNew : gcInfo is nullptr";
+    GCHeaderLVal(objAddr) = (kAllocatedBit | gcInfo->headerProto);
+    RefCountLVal(objAddr) = 1 + kWeakRCOneBit;
+    if (UNLIKELY(FastAllocData::data.isConcurrentMarking)) {
+      FastAllocData::data.bm->MarkObject(objAddr);
+    }
+  }
+  return objAddr;
+}
+
+// try new object: it takes fast path if possible, otherwise returns 0
+// see slow path code for more info
+__attribute__ ((always_inline, used))
+static address_t MRT_TryNewObject(address_t klass) {
+  if (UNLIKELY(!modifier::IsFastAllocClass(reinterpret_cast<ClassMetadata*>(klass)->flag))) {
+    return 0;
+  }
+  MClass *cls = MObject::Cast<MClass>(klass);
+  size_t objSize = cls->GetObjectSize(); // must have been aligned
+  address_t objAddr = MRT_TryNew(objSize, klass);
+  if (UNLIKELY(objAddr == 0)) {
+    return 0;
+  }
+
+  return objAddr;
+}
+
+// try new object: it takes fast path if possible, otherwise returns 0
+// it also accepts an explicit size instead of taking the size from the klass
+// useful for allocation of strings (where the klass's size is not accurate)
+// see slow path code for more info
+__attribute__ ((always_inline, used))
+static address_t MRT_TryNewObject(address_t klass, size_t explicitSize) {
+  if (UNLIKELY(explicitSize > kFastAllocMaxSize)) {
+    return 0;
+  }
+  // we need to make sure the string class passes the following condition
+  // somehow it does, coincidently
+  if (UNLIKELY(!modifier::IsFastAllocClass(reinterpret_cast<ClassMetadata*>(klass)->flag))) {
+    return 0;
+  }
+  // we additionally need to align the size, because the explicit size can be any number
+  // this costs additional time
+  address_t alignedSize = AllocUtilRndUp(explicitSize, kAllocAlign);
+  address_t objAddr = MRT_TryNew(alignedSize, klass);
+  if (UNLIKELY(objAddr == 0)) {
+    return 0;
+  }
+
+  return objAddr;
+}
+
+// try new array: it takes fast path if possible, otherwise returns 0
+// see slow path code for more info
+// assumption: class initialised
+template<ArrayElemSize elemSizeExp>
+__attribute__ ((always_inline, used))
+static address_t MRT_TryNewArray(size_t nElems, address_t klass) {
+  if (UNLIKELY(nElems > (kFastAllocArrayMaxSize >> static_cast<size_t>(elemSizeExp)))) {
+    return 0;
+  }
+  size_t contentSize = nElems << static_cast<size_t>(elemSizeExp);
+  // this size must be aligned because the allocator fast path takes it as an assumption
+  size_t objSize = kJavaArrayContentOffset + AllocUtilRndUp(contentSize, kAllocAlign);
+  // potentially optimise this given the constraint that we are an array class?
+  address_t objAddr = MRT_TryNew(objSize, klass);
+  if (LIKELY(objAddr != 0)) {
+    ArrayLength(objAddr) = static_cast<uint32_t>(nElems);
+    // not sure if we want this fence
+    std::atomic_thread_fence(std::memory_order_release);
+  }
+  return objAddr;
+}
+
+// try new array: it takes fast path if possible, otherwise returns 0
+// this function also accepts an elem size variable, in case the elem size is not
+// immediately available
+// the previous function is preferred over this one
+// see slow path code for more info
+// assumption: class initialised
+__attribute__ ((always_inline, used))
+static address_t MRT_TryNewArray(size_t elemSize, size_t nElems, address_t klass) {
+  // multiplication cost more cpu clocks, we don't like it, prefer shifting
+  if (UNLIKELY(nElems > (kFastAllocArrayMaxSize / elemSize))) {
+    return 0;
+  }
+  size_t contentSize = elemSize * nElems;
+  // this size must be aligned because the allocator fast path takes it as an assumption
+  size_t objSize = kJavaArrayContentOffset + AllocUtilRndUp(contentSize, kAllocAlign);
+  // potentially optimise this given the constraint that we are an array class?
+  address_t objAddr = MRT_TryNew(objSize, klass);
+  if (LIKELY(objAddr != 0)) {
+    ArrayLength(objAddr) = static_cast<uint32_t>(nElems);
+    // not sure if we want this fence
+    std::atomic_thread_fence(std::memory_order_release);
+  }
+  return objAddr;
+}
+#else
+inline address_t MRT_TryNewObject(address_t) {
+  return 0;
+}
+inline address_t MRT_TryNewObject(address_t, size_t) {
+  return 0;
+}
+template<ArrayElemSize elemSizeExp>
+__attribute__ ((always_inline, used))
+static address_t MRT_TryNewArray(size_t, address_t) {
+  return 0;
+}
+__attribute__ ((always_inline, used))
+static address_t MRT_TryNewArray(size_t, size_t, address_t) {
+  return 0;
+}
+#endif
+}
+
+#endif
diff --git a/src/mrt/compiler-rt/include/file_layout.h b/src/mrt/compiler-rt/include/file_layout.h
new file mode 100644
index 0000000000000000000000000000000000000000..ffc42b797f4962ee5405f936abafc3a9f026e579
--- /dev/null
+++ b/src/mrt/compiler-rt/include/file_layout.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MIRLAYOUT_H
+#define MIRLAYOUT_H
+#include <iostream>
+
+namespace maple {
+// file-layout is shared between maple compiler and runtime, thus not in namespace maplert
+enum LayoutType : uint8_t {
+  kLayoutBootHot,
+  kLayoutBothHot,
+  kLayoutRunHot,
+  kLayoutStartupOnly,
+  kLayoutUsedOnce,
+  kLayoutExecuted, // method excuted in some condition
+  kLayoutUnused,
+  kLayoutTypeCount
+};
+
+// this used for c string layout
+static uint8_t kCStringShift = 1;
+std::string GetLayoutTypeString(uint32_t type);
+} // namespace maple
+#endif
diff --git a/src/mrt/compiler-rt/include/gc_log.h b/src/mrt/compiler-rt/include/gc_log.h
new file mode 100644
index 0000000000000000000000000000000000000000..22af7911ea39bf9b31605f12d49374d74162811a
--- /dev/null
+++ b/src/mrt/compiler-rt/include/gc_log.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_GC_LOG_H
+#define MAPLE_RUNTIME_GC_LOG_H
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <unistd.h>
+#include "utils/time_utils.h"
+#include "mm_config.h"
+
+namespace maplert {
+enum Logtype : int {
+  kLogtypeGc = 0,
+  kLogtypeRcTrace,
+  kLogtypeRp,
+  kLogtypeCycle,
+  kLogTypeAllocFrag,
+  kLogTypeAllocator,
+  kLogTypeMix,
+  kLogtypeGcOrStderr,
+  kLogtypeNum
+};
+
+// gclog file stream buffer size.
+const int kGcLogBufSize = 4096;
+
+class GCLogImpl {
+ public:
+  GCLogImpl() = default;
+  ~GCLogImpl() = default;
+  std::ostream &Stream(uint32_t logType = kLogtypeGc) noexcept {
+    return *os[logType];
+  }
+
+  void Init(bool openGClog);
+  void OnPreFork();
+  void OnPostFork();
+
+  void OnGCStart();
+  void OnGCEnd();
+
+  bool IsWriteToFile(uint32_t logType = kLogtypeGc) const noexcept {
+    return writeToFile[logType];
+  }
+
+ private:
+  void OpenFile();
+  void CloseFile();
+
+  void SetFlags();
+
+  std::ostream *os[kLogtypeNum]; // Current stream
+  bool doWriteToFile;
+  bool doOpenFileOnStartup;
+
+  bool writeToFile[kLogtypeNum] = { false };
+  bool openFileOnStartup[kLogtypeNum] = { false };
+
+  std::ofstream file[kLogtypeNum]; // Open file
+
+  char *buffer[kLogtypeNum] = { nullptr }; // buffer for file stream
+  bool openGCLog = false;
+};
+
+GCLogImpl &GCLog();
+std::string Pretty(uint64_t number);
+std::string Pretty(uint32_t number);
+std::string Pretty(int64_t number);
+std::string PrettyOrderInfo(uint64_t number, std::string unit);
+std::string PrettyOrderMathNano(uint64_t number, std::string unit);
+
+#if __MRT_DEBUG
+#define MRT_PASTE_ARGS_EXPANDED(x, y) x ## y
+#define MRT_PASTE(x, y) MRT_PASTE_ARGS_EXPANDED(x, y)
+#define MRT_PHASE_TIMER(...) PhaseTimerImpl MRT_PASTE(MRT_pt_, __LINE__)(__VA_ARGS__)
+#else
+#define MRT_PHASE_TIMER(...)
+#endif
+class PhaseTimerImpl {
+ public:
+  explicit PhaseTimerImpl(std::string name, uint32_t type = kLogtypeGc) : name(name), logType(type) {
+    if (GCLog().IsWriteToFile(type)) {
+      startTime = timeutils::MicroSeconds();
+    }
+  }
+
+  ~PhaseTimerImpl() {
+    if (GCLog().IsWriteToFile(logType)) {
+      uint64_t stopTime = timeutils::MicroSeconds();
+      uint64_t diffTime = stopTime - startTime;
+      GCLog().Stream(logType) << name << " time: " << Pretty(diffTime) << "us\n";
+    }
+  }
+
+ private:
+  std::string name;
+  uint64_t startTime = 0;
+  uint32_t logType;
+};
+
+// The LOG2FILE(type) macro can only be used in this fashion:
+//
+//   LOG2FILE(xxxx) << blah << blah << blah;
+//
+// The if statement in the macro will nullify the effect of the << expression
+// following the LOG2FILE macro.
+#if __MRT_DEBUG
+#define LOG2FILE(type) if (GCLog().IsWriteToFile(type)) GCLog().Stream(type)
+#define FLUSH2FILE(type) if (GCLog().IsWriteToFile(type)) GCLog().Stream(type).flush()
+#else
+#define LOG2FILE(type) if (false) GCLog().Stream(type)
+#define FLUSH2FILE(type) if (false) GCLog().Stream(type).flush()
+#endif
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/heap_stats.h b/src/mrt/compiler-rt/include/heap_stats.h
new file mode 100644
index 0000000000000000000000000000000000000000..04187ec7be09b6003788d0bcfc63df6037635784
--- /dev/null
+++ b/src/mrt/compiler-rt/include/heap_stats.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_HEAP_STATS_H
+#define MAPLE_RUNTIME_HEAP_STATS_H
+
+#include "address.h"
+
+namespace maplert {
+#if PERMISSIVE_HEAP_COND
+#define IS_HEAP_ADDR(addr) ((static_cast<address_t>(addr) - HEAP_START) < (HEAP_END - HEAP_START))
+#define IS_HEAP_OBJ(addr) ((static_cast<address_t>(addr) % maplert::kMrtHeapAlign == 0) && IS_HEAP_ADDR(addr))
+#else
+#define IS_HEAP_ADDR(addr) maplert::HeapStats::IsHeapAddr(addr)
+#define IS_HEAP_OBJ(addr) maplert::MRT_FastIsValidObjAddr(addr)
+#endif
+
+// Used by runtime interfaces SetStatsEnabled/ResetStats/GetStats
+// for collecting heap allocation stats between StatsEnable/Disable windows.
+// On StatsEnable, start heapstats allocation counting.
+// On StatsDisable, stop heapstats allocation counting and sum results.
+class HeapStats {
+ public:
+  static void OnHeapCreated(address_t startAddr) {
+    heapStartAddr = startAddr;
+    heapCurrentSize = 0;
+  }
+  static void OnHeapExtended(size_t newSize) {
+    heapCurrentSize = newSize;
+  }
+  static bool IsHeapAddr(address_t addr) {
+    return (addr - heapStartAddr) < heapCurrentSize;
+  }
+  static address_t StartAddr() {
+    return heapStartAddr;
+  }
+  static size_t CurrentSize() {
+    return heapCurrentSize;
+  }
+
+  size_t GetAllocSize() const {
+    return bytesAlloc;
+  }
+
+  size_t GetAllocCount() const {
+    return numAlloc;
+  }
+
+  size_t GetFreeSize() const {
+    return bytesFreed;
+  }
+
+  size_t GetFreeCount() const {
+    return numFreed;
+  }
+
+  size_t GetNativeAllocBytes() const {
+    return nativeAllocatedBytes.load(std::memory_order_relaxed);
+  }
+  void SetNativeAllocBytes(size_t size) {
+    nativeAllocatedBytes.store(size, std::memory_order_relaxed);
+  }
+
+  HeapStats();
+  ~HeapStats() = default;
+
+  void PrintHeapStats();
+  void ResetHeapStats();
+  void EnableHeapStats();
+  void DisableHeapStats();
+  void SumHeapStats();
+
+ private:
+  static address_t heapStartAddr;
+  static size_t heapCurrentSize;
+  // allocation stats collected in a time window
+  size_t bytesAlloc; // total internal bytes allocated
+  size_t bytesFreed; // total internal bytes freed
+  size_t numAlloc; // total allocated objects
+  size_t numFreed; // total freed objects
+  std::atomic<size_t> nativeAllocatedBytes;
+};
+
+extern HeapStats heapStats;
+extern std::atomic<int> heapProfile;
+
+inline int IsHeapStatsEnabled() {
+  return heapProfile.load(std::memory_order_relaxed);
+}
+}
+
+#endif
diff --git a/src/mrt/compiler-rt/include/imported.h b/src/mrt/compiler-rt/include/imported.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0bd1cb24cfc79b9ef0e4ca02a6758b2b40eec22
--- /dev/null
+++ b/src/mrt/compiler-rt/include/imported.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_IMPORTED_H
+#define MAPLE_RUNTIME_IMPORTED_H
+
+#include "address.h"
+
+namespace maplert {
+//  This file include imported symbols from a specific build of the application.
+//
+//  Currently, the imported symbols include:
+//
+//  -   __MRT_GCRootList: List of GC roots.
+//  -   __MRT_PrimordialObjectList: List of primordial objects
+//
+// DO NOT MAKE THE SYMBOLS BELOW WEAK!  They are necessary for the proper
+// execution of the program.  If there is a linking error, it means the
+// application buildilng script does not properly provide the GC root list.  The
+// building script needs to be fixed.  If we make the list empty "by default",
+// we may silently ignore a class of building mistakes.
+//
+// The two global variables are global roots provided by the application.
+// Tracing collectors, including the back-up tracer which is currently used in
+// the RC collector for cleaning up, work by starting tracing the heap from
+// global GC roots and computing its transitive closure.
+//
+// They are defined in unified.groots.s, which is generated by the script
+// mapleall/maplebe/collect/mpl-collect-groot-lists.  That script contains
+// detailed instruction about how to generate the unified.groots.s file.
+//
+// After generating, assemble and link the unified.groots.s into the executable
+// or the shared object.
+//
+// If you are writing test cases, you can manually define the two lists to
+// manually specify GC roots.  If you don't have GC roots in your test case,
+// make an empty list.
+//
+// A list of global GC roots.  For Java, it is the complete list of static
+// variables of reference types.
+extern "C" address_t *gcRootNewList[];
+
+// The length of the __MRT_GCRootList array.
+extern "C" size_t gcRootNewListSize;
+}
+
+#endif
diff --git a/src/mrt/compiler-rt/include/java_primitive_ops.h b/src/mrt/compiler-rt/include/java_primitive_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..a94b2a6dacf0764a361885e3b4676495ac50dc5c
--- /dev/null
+++ b/src/mrt/compiler-rt/include/java_primitive_ops.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_JAVA_PRIMITIVE_OPS_H
+#define MAPLE_RUNTIME_JAVA_PRIMITIVE_OPS_H
+
+#include <cstdint>
+#include <cmath>
+#include <limits>
+
+namespace maplert {
+/**
+ * Convert a floating point value to a signed integral type, using the Java semantics.  This function exists mainly
+ * because on ARMv7, such convertion must be done by software, and there is no equivalent in the ARMv7 instruction set.
+ * This is a template function that serves all types.  If it is desired to call this from assembly/machine code, please
+ * wrap this function in non-inline functions, such as MCC_JDouble2JLong for AoT-compiled code and DoubleToLong for
+ * fterp.
+ *
+ * @tparam FPType The floating point type, can be float or double.
+ * @tparam IntType The integral type, can be int32_t or int64_t.
+ * @param fpValue The input floating-point value.
+ * @return The value converted to IntType according to the Java semantics.
+ */
+template<class FPType, class IntType>
+static inline IntType JavaFPToSInt(FPType fpValue) {
+  static_assert(std::numeric_limits<IntType>::is_integer, "IntType must be an integral type.");
+  static_assert(!std::numeric_limits<FPType>::is_integer, "FPType must be a floating point type.");
+  static_assert(std::numeric_limits<FPType>::is_iec559, "Java requires IEC559/IEEE754 floating point format.");
+  static_assert(std::numeric_limits<FPType>::round_style == std::round_to_nearest,
+      "Java requires the round-to-nearest rounding mode.");
+
+  if (std::isnan(fpValue)) {
+    return IntType(0);
+  } else if (fpValue >= static_cast<FPType>(std::numeric_limits<IntType>::max())) {
+    return std::numeric_limits<IntType>::max();
+  } else if (fpValue <= static_cast<FPType>(std::numeric_limits<IntType>::min())) {
+    return std::numeric_limits<IntType>::min();
+  } else {
+    return static_cast<IntType>(fpValue);
+  }
+}
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_CINTERFACE_H
diff --git a/src/mrt/compiler-rt/include/libs.h b/src/mrt/compiler-rt/include/libs.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea25c10f1c57bf5afac2adf6c29aba9a941c7fae
--- /dev/null
+++ b/src/mrt/compiler-rt/include/libs.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __CG_LIB_H_
+#define __CG_LIB_H_
+
+#include <cstdint>
+#include <jni.h>
+#include <iostream>
+#include "mrt_api_common.h"
+#include "mrt_compiler_api.h"
+
+namespace maplert {
+// sync enter, sync exit compiler not used
+extern "C" MRT_EXPORT void  MRT_BuiltinSyncEnter(address_t obj);
+extern "C" MRT_EXPORT void  MRT_BuiltinSyncExit(address_t obj);
+
+
+// This macro identifies all Java functions implemented in c++. It can be defined as
+// __attribute__((section(".java_text"))),and then you can use the MplLinker:
+// IsJavaText interface to identify it.Because these frameworks do not have metedata
+// data, they cannot be typed out like normal Java stacks in the process of stacking.
+#define MAPLE_JAVA_SECTION_DIRECTIVE
+
+// size in bytes for encoding one aarch64 instruction
+const int kAarch64InsnSize = 4;
+
+// msg buffer size
+constexpr int kBufferSize = 128;
+
+#define MRT_UNW_GETCALLERFRAME(frame)             \
+  do {                                               \
+    uint32_t *ip = reinterpret_cast<uint32_t*>(__builtin_return_address(0));  \
+    CallChain *fa = reinterpret_cast<CallChain*>(__builtin_frame_address(0))->callerFrameAddress;   \
+    __MRT_ASSERT(fa != nullptr, "frame address is nullptr!"); \
+    (frame).ip = ip;                 \
+    (frame).fa = fa;         \
+    (frame).ra = fa->returnAddress; \
+  } while (0)
+
+extern "C" void PrepareArgsForExceptionCatcher();
+
+#if defined(__arm__)
+extern "C" UnwindReasonCode AdaptationFunc(_Unwind_State, _Unwind_Exception*, _Unwind_Context*);
+#endif
+extern "C" uintptr_t IsThrowingExceptionByRet();
+}
+
+extern "C" MRT_EXPORT void MRT_DumpRegisters();
+
+// this is helper for logging one line with no more than 256 characters
+inline static std::string FormatString(const char *format, ...) {
+  constexpr size_t defaultBufferSize = 256;
+  char buf[defaultBufferSize];
+
+  va_list argList;
+  va_start(argList, format);
+  if (vsprintf_s(buf, sizeof(buf), format, argList) == -1) {
+    return "";
+  }
+  va_end(argList);
+
+  std::string str(buf);
+  return str;
+}
+
+#endif // __CG_LIB_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker.h b/src/mrt/compiler-rt/include/linker/linker.h
new file mode 100644
index 0000000000000000000000000000000000000000..756c185c2dd72b021f3eead3f2830cbb6b5d2991
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_LINKER_H_
+#define MAPLE_RUNTIME_MPL_LINKER_H_
+
+#include "linker_model.h"
+
+#ifdef __cplusplus
+
+namespace maplert {
+// Maple linker tools.
+class Linker : public FeatureModel {
+ public:
+  static FeatureName featureName;
+  explicit Linker(LinkerInvoker &invoker) : pInvoker(&invoker) {};
+  ~Linker() {
+    pInvoker = nullptr;
+  }
+  bool HandleSymbol();
+  bool HandleMethodSymbol();
+  bool HandleDataSymbol();
+  bool HandleSymbol(LinkerMFileInfo &mplInfo);
+  bool HandleMethodSymbol(LinkerMFileInfo &mplInfo);
+  bool HandleDataSymbol(LinkerMFileInfo &mplInfo);
+  bool ResolveMethodSymbol(LinkerMFileInfo &mplInfo);
+  bool RelocateMethodSymbol(LinkerMFileInfo &mplInfo);
+  void InitMethodSymbol(LinkerMFileInfo &mplInfo);
+  bool ResolveVTableSymbol(LinkerMFileInfo &mplInfo);
+  bool ResolveITableSymbol(LinkerMFileInfo &mplInfo);
+  bool ResolveDataSymbol(LinkerMFileInfo &mplInfo);
+
+  bool ResolveSuperClassSymbol(LinkerMFileInfo &mplInfo);
+  bool ResolveGCRootSymbol(LinkerMFileInfo &mplInfo);
+  bool RelocateDataSymbol(LinkerMFileInfo &mplInfo);
+  void InitDataSymbol(LinkerMFileInfo &mplInfo);
+
+  void *LookUpSymbolAddress(const void *handle, const MUID &muid);
+  void *LookUpSymbolAddress(const MUID &muid);
+  void *LookUpSymbolAddress(LinkerMFileInfo &mplInfo, const MUID &muid);
+
+  bool InitLinkerMFileInfo(LinkerMFileInfo &mplInfo, int32_t pos = -1);
+  void FreeAllCacheTables(const MObject *classLoader) const;
+
+  void AdjustDefTableAddress(const LinkerMFileInfo &mplInfo, LinkerAddrTableItem &pTable, size_t index);
+  template<typename T1, typename T2>
+  int64_t BinarySearch(T1 &pTable, int64_t start, int64_t end, const T2 &value);
+  template<typename T1, typename T2, typename T3>
+  int64_t BinarySearch(T1 &pTable, const T2 &pMuidIndexTable, int64_t start, int64_t end, const T3 &value);
+
+ private:
+  void InitLinkerMFileInfoIgnoreSysCL(LinkerMFileInfo &mplInfo);
+  void InitLinkerMFileInfoTableAddr(LinkerMFileInfo &mplInfo) const;
+  bool HandleMethodSymbolNoLazy(LinkerMFileInfo &mplInfo);
+  bool HandleDataSymbolNoLazy(LinkerMFileInfo &mplInfo);
+  bool DoResolveSuperClassSymbol(LinkerMFileInfo &mplInfo, IndexSlice &superTableSlice,
+      const AddrSlice &dataUndefSlice, const AddrSlice &dataDefSlice, size_t i);
+  bool ResolveUndefVTableSymbol(
+      LinkerMFileInfo &mplInfo, bool fromUndef, size_t index, VTableSlice &vTableSlice, size_t i);
+  bool ResolveUndefITableSymbol(
+      LinkerMFileInfo &mplInfo, bool fromUndef, size_t index, ITableSlice &iTableSlice, size_t i);
+
+#if defined(LINKER_LAZY_BINDING) && defined(LINKER_32BIT_REF_FOR_DEF_UNDEF)
+  void InitMethodSymbolLazy32(LinkerMFileInfo &mplInfo, size_t defSize);
+  void InitDataSymbolLazy32(LinkerMFileInfo &mplInfo, size_t defSize);
+#endif // LINKER_32BIT_REF_FOR_DEF_UNDEF LINKER_LAZY_BINDING
+
+  bool methodHasNotResolved = false;
+  bool dataHasNotResolved = false;
+  bool methodHasNotRelocated = false;
+  bool dataHasNotRelocated = false;
+  bool vtableHasNotResolved = false;
+  bool itableHasNotResolved = false;
+  bool superClassHasNotResolved = false;
+  bool gcRootListHasNotResolved = false;
+  LinkerInvoker *pInvoker = nullptr;
+};
+} // namespace maplert
+#endif // __cplusplus
+#endif  // MAPLE_RUNTIME_MPL_LINKER_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker_cache.h b/src/mrt/compiler-rt/include/linker/linker_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..4aa7b79b802765e19a4735e115517ec4418a693b
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_cache.h
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_LINKER_CACHE_H_
+#define MAPLE_RUNTIME_MPL_LINKER_CACHE_H_
+
+#include <string>
+
+#include "linker_model.h"
+
+namespace maplert {
+#ifdef LINKER_RT_CACHE
+class MFileCacheInf {
+ public:
+  uint16_t Append(const std::string &name, const MUID &muid) {
+    auto iter = filter.insert(std::make_pair(name, 0));
+    if (iter.second) {
+      size_t size = data.size();
+      data.push_back(std::make_pair(name, muid));
+      iter.first->second = size;
+      return size;
+    }
+    return iter.first->second;
+  }
+
+  // Required: id < data.size()
+  const std::string &GetName(uint16_t id) const {
+    return data[id].first;
+  }
+  const MUID &GetHash(uint16_t id) const {
+    return data[id].second;
+  }
+
+  const std::vector<std::pair<std::string, MUID>> &NameList() const {
+    return data;
+  }
+
+ private:
+  std::unordered_map<std::string, uint16_t> filter;
+  std::vector<std::pair<std::string, MUID>> data;
+};
+
+class LinkerCache : public FeatureModel {
+ public:
+  using MplInfoStore = std::vector<LinkerMFileInfo*>;
+  using LookUpSymbolAddr = LinkerVoidType(maplert::LinkerInvoker::*)(LinkerMFileInfo&, const MUID&, size_t&);
+  enum CacheIndex {
+    kMethodUndefIndex = 0,
+    kMethodDefIndex,
+    kDataUndefIndex,
+    kDataDefIndex
+  };
+  struct CacheInfo {
+    CacheIndex cacheIndex;
+    LookUpSymbolAddr lookUpSymbolAddress;
+    MFileInfoFlags notResolved;
+    MFileInfoFlags cacheValid;
+    bool isMethod;
+    bool isUndef;
+  };
+
+  static FeatureName featureName;
+  explicit LinkerCache(LinkerInvoker &invoker)
+      : pInvoker(invoker), pClSoCnt{ 0 } {}
+  ~LinkerCache() = default;
+  void SetPath(const std::string &path);
+  bool GetPath(LinkerMFileInfo &mplInfo, std::string &path,
+               LinkerCacheType cacheType, LoadStateType loadState);
+  void Reset();
+  void FreeAllTables(LinkerMFileInfo &mplInfo) {
+    FreeTable(mplInfo, kMethodUndefIndex);
+    FreeTable(mplInfo, kMethodDefIndex);
+    FreeTable(mplInfo, kDataUndefIndex);
+    FreeTable(mplInfo, kDataDefIndex);
+  }
+  bool RemoveAllTables(LinkerMFileInfo &mplInfo) {
+    RemoveTable(mplInfo, kMethodUndefIndex);
+    RemoveTable(mplInfo, kMethodDefIndex);
+    RemoveTable(mplInfo, kDataUndefIndex);
+    RemoveTable(mplInfo, kDataDefIndex);
+    return true;
+  }
+
+  void ResolveMethodSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice);
+  void FreeMethodUndefTable(LinkerMFileInfo &mplInfo);
+
+  void RelocateMethodSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice);
+  void FreeMethodDefTable(LinkerMFileInfo &mplInfo);
+
+  void ResolveDataSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice);
+  void FreeDataUndefTable(LinkerMFileInfo &mplInfo);
+
+  void RelocateDataSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice);
+  void FreeDataDefTable(LinkerMFileInfo &mplInfo);
+
+  bool DumpTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex);
+
+ private:
+  bool GetFastPath(LinkerMFileInfo &mplInfo, LinkerCacheType cacheType, std::string &path);
+  void FinishPath(LinkerMFileInfo &mplInfo, LinkerCacheType cacheType, std::string &path);
+
+  bool InitDump(LinkerMFileInfo &mplInfo, std::ifstream &in, std::ofstream &out, CacheIndex cacheIndex);
+  bool DumpMetaValidity(std::stringstream &ss, BufferSlice &buf);
+  bool DumpMetaVersion(LinkerMFileInfo &mplInfo, std::stringstream &ss, BufferSlice &buf);
+  bool DumpMetaCl(std::stringstream &ss, BufferSlice &buf, CacheIndex cacheIndex);
+  int DumpMap(std::stringstream &ss, BufferSlice &buf);
+  bool DumpData(std::stringstream &ss, BufferSlice &buf, size_t mapSize);
+  bool DumpFile(std::ofstream &out, std::stringstream &ss);
+
+  void UpdateProperty(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex);
+  LinkerCacheType GetLinkerCacheType(CacheIndex cacheIndex);
+  MplCacheMapT *GetCacheMap(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex);
+
+  bool RemoveTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex);
+  void FreeTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex);
+
+  bool LoadInstallCache(LinkerMFileInfo &mplInfo, LinkerCacheType cacheType);
+
+  bool SaveTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex);
+  int GetCacheFd(LinkerMFileInfo &mplInfo, std::string &path, CacheIndex cacheIndex);
+  void SaveMeta(LinkerMFileInfo &mplInfo, std::string &buffer, CacheIndex cacheIndex);
+  bool SaveData(LinkerMFileInfo &mplInfo, std::string &buffer, CacheIndex cacheIndex);
+  bool SaveNameList(std::string &buffer, CacheIndex cacheIndex);
+  bool WriteTable(int fd, std::string &buffer, CacheIndex cacheIndex);
+  bool CleanSavingTable(LinkerMFileInfo &mplInfo, int fd, bool res);
+
+  bool LoadTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex);
+  bool LoadTable(LinkerMFileInfo &mplInfo, const std::string &path, CacheIndex cacheIndex);
+  void *LoadCache(const std::string &path, size_t &cacheSize);
+  bool LoadFooter(BufferSlice &buf, CacheIndex cacheIndex);
+  bool LoadMeta(LinkerMFileInfo &mplInfo, BufferSlice &buf, CacheIndex cacheIndex);
+  bool LoadData(LinkerMFileInfo &mplInfo, BufferSlice &buf, CacheIndex cacheIndex);
+  bool LoadNameList(BufferSlice &buf, CacheIndex cacheIndex);
+
+  bool ProcessTable(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice, CacheInfo cacheInfo);
+  bool LookUpUndefSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice, CacheInfo cacheInfo);
+  bool UndefSymbolFailHandler(LinkerMFileInfo &mplInfo, uint32_t idx, CacheInfo cacheInfo);
+  bool LookUpDefSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice, CacheInfo cacheInfo);
+  bool LookUpUndefAddr(LinkerMFileInfo &mplInfo, const MUID &muid,
+                       LinkerOffsetType &addr, LinkerCacheTableItem &pItem, CacheInfo cacheInfo);
+  bool LookUpDefAddr(LinkerMFileInfo &mplInfo, const MUID &muid,
+                     LinkerOffsetType &addr, LinkerCacheTableItem &pItem, CacheInfo cacheInfo);
+  LinkerMFileInfo *FindLinkerMFileInfo(uint16_t soid, const MFileCacheInf &inf, MplInfoStore &store);
+  LinkerOffsetType GetAddr(LinkerMFileInfo &res, LinkerCacheTableItem &pItem, bool isMethod);
+
+  template<typename F>
+  void ParallelLookUp(F const &lookFunc, int numThreads, size_t defSize);
+
+  static constexpr int kLinkerInvalidNameLen = 1;
+  static constexpr int kMaxCacheIndex = kDataDefIndex + 1;
+  static const MUID kInvalidHash;
+  LinkerInvoker &pInvoker;
+  std::string pCachePath;
+  MUID pClHash[kMaxCacheIndex];      // Hash code of class loader .so list
+  uint16_t pClSoCnt[kMaxCacheIndex]; // .so count in class loader
+  MFileCacheInf pMplCacheInf[kMaxCacheIndex];
+  MplInfoStore pMplStore[kMaxCacheIndex];
+};
+#endif // LINKER_RT_CACHE
+} // namespace maplert
+#endif
diff --git a/src/mrt/compiler-rt/include/linker/linker_common.h b/src/mrt/compiler-rt/include/linker/linker_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..45da7a9709ee89ffdad10f236b5f63447878828e
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_common.h
@@ -0,0 +1,571 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_LINKER_COMMON_H_
+#define MAPLE_RUNTIME_MPL_LINKER_COMMON_H_
+
+#include <link.h>
+#include <assert.h>
+
+#include "mrt_api_common.h"
+#include "jni.h"
+#include "linker_compiler.h"
+#include "object_type.h"
+#include "metadata_layout.h"
+#ifdef LINKER_DECOUPLE
+#include "decouple/linker_decouple_common.h"
+#endif
+
+#ifdef __cplusplus
+#include <unordered_map>
+#include <tuple>
+#include <set>
+#include <map>
+#include <vector>
+#include <unordered_set>
+namespace maplert {
+// For un|define tables' address.
+using PtrFuncType = void *(*)();
+
+#define LINKER_INSTALL_STATE (maple::MplCacheFirstFile::GetInstallStat())
+
+#ifdef LINKER_RT_CACHE
+enum class LinkerCacheType : uint8_t {
+  kLinkerCacheDataUndef = 0,   // data undef symbol
+  kLinkerCacheDataDef = 1,     // data def symbol
+  kLinkerCacheMethodUndef = 2, // method symbol
+  kLinkerCacheMethodDef = 3,   // method symbol
+  kLinkerCacheVTable = 4,      // vtable
+  kLinkerCacheCTable = 5,      // vtable offset table
+  kLinkerCacheFieldOffset = 6, // field offset
+  kLinkerCacheFieldTable = 7,  // field offset table
+  kLinkerCacheITable = 8,      // itable
+  kLinkerCacheStaticTable = 9, // static table
+  kLinkerCacheLazy = 10        // lazy cache
+};
+
+static constexpr char kLinkerSystemCachePath[] = "/data/system";
+static constexpr char kLinkerRootCachePath[] = "/data/dalvik-cache";
+static constexpr char kLinkerCacheFold[] = "mpl-lnk";
+static constexpr unsigned int kLinkerIndexMax = 0xFFFFFFFF;
+static constexpr int kLinkerClHashFlagValue = 0;
+static constexpr unsigned int kLinkerClHashFlagIndex = 0xFFFF;
+// Crash type(count) kLinkerServiceCrashRecoveryMygote(2) for mygote recovery.
+static constexpr int kLinkerServiceCrashRecoveryMygote = 2;
+// Crash type(count) kLinkerServiceCrashRecoverySystemServer(3) for sysvr recovery.
+static constexpr int kLinkerServiceCrashRecoverySystemServer = 3;
+
+// Method undefine cache table item.
+class LinkerCacheTableItem {
+ public:
+  LinkerCacheTableItem() : addrIndex(0), soIndex(0), filled(0), state(kValid) {}
+
+  LinkerCacheTableItem(const LinkerCacheTableItem &item) {
+    addrIndex = item.addrIndex;
+    soIndex = item.soIndex;
+    filled = item.filled;
+    state = item.state;
+  }
+
+  LinkerCacheTableItem &operator=(const LinkerCacheTableItem &item) {
+    this->addrIndex = item.addrIndex;
+    this->soIndex = item.soIndex;
+    this->filled = item.filled;
+    this->state = item.state;
+    return *this;
+  }
+  LinkerCacheTableItem(uint32_t aidx, uint16_t soidx) : addrIndex(aidx), soIndex(soidx) {
+    filled = 0;
+    state = kValid;
+  }
+  ~LinkerCacheTableItem() = default;
+  uint32_t AddrId() const {
+    return addrIndex;
+  }
+  uint16_t SoId() const {
+    return soIndex;
+  }
+
+  void SetFilled() {
+    filled = 1;
+  }
+  bool Filled() const {
+    return filled == 1;
+  }
+  bool LazyInvalidName() const {
+    return state == kLazyInvalid;
+  }
+  bool InvalidName() const {
+    return state == kInvalid;
+  }
+  bool Valid() const {
+    return state == kValid;
+  }
+
+  LinkerCacheTableItem &SetIds(size_t addrId, uint16_t soid) {
+    addrIndex = static_cast<uint32_t>(addrId);
+    soIndex = soid;
+    state = kValid;
+    return *this;
+  }
+  LinkerCacheTableItem &SetLazyInvalidSoId(uint16_t soidx) {
+    soIndex = soidx;
+    state = kLazyInvalid;
+    return *this;
+  }
+  LinkerCacheTableItem &SetInvalidSoId(uint16_t soidx) {
+    soIndex = soidx;
+    state = kInvalid;
+    return *this;
+  }
+ private:
+  uint32_t addrIndex; // Index, the same order as item in undef|def table
+  uint16_t soIndex; // index for maple so
+  uint8_t filled; // If this item was handled before.
+  uint8_t state; // if maple so name valid
+
+  enum SoIdState : uint8_t {
+    kValid = 0,
+    kInvalid = 1,
+    kLazyInvalid = 2,
+  };
+};
+
+using MplCacheMapT = std::unordered_map<uint32_t, LinkerCacheTableItem>;
+
+struct LinkerCacheRep {
+  MplCacheMapT methodUndefCacheMap;
+  int64_t methodUndefCacheSize = -1;
+  MplCacheMapT methodDefCacheMap;
+  int64_t methodDefCacheSize = -1;
+  std::string methodUndefCachePath;
+  std::string methodDefCachePath;
+  MplCacheMapT dataUndefCacheMap;
+  int64_t dataUndefCacheSize = -1;
+  MplCacheMapT dataDefCacheMap;
+  int64_t dataDefCacheSize = -1;
+  std::string dataUndefCachePath;
+  std::string dataDefCachePath;
+  std::string lazyCachePath;
+};
+#endif // LINKER_RT_CACHE
+
+// Refer to MUIDReplacement::GenRangeTable() for sequence.
+enum SectTabIndex {
+  kRange = 0,
+  kDecouple,
+  kVTable,
+  kITable,
+  kVTabOffset,
+  kFieldOffset,
+  kValueOffset,
+  kLocalCinfo,
+  kDataConstStr,
+  kDataSuperClass,
+  kDataGcRoot,
+  kTabClassMetadata,
+  kClassMetadataBucket,
+  kJavaText,
+  kJavaJni,
+  kJavaJniFunc,
+  kMethodDef,
+  kMethodDefOrig,
+  kMethodInfo,
+  kMethodUndef,
+  kDataDef,
+  kDataDefOrig,
+  kDataUndef,
+  kMethodDefMuid,
+  kMethodUndefMuid,
+  kDataDefMuid,
+  kDataUndefMuid,
+  kMethodMuidIndex,
+  kMethodProfile,
+  kDataSection,
+  kStaticDecoupleKey,
+  kStaticDecoupleValue,
+  kBssSection,
+  kLinkerHashSo,
+  kArrayClassCacheIndex,
+  kArrayClassCacheNameIndex,
+  kFuncIRProfDesc,
+  kFuncIRProfCounter,
+  kMaxTableIndexCount
+};
+
+// Start/end address of table
+enum SectTabPairIndex {
+  kTable1stIndex,
+  kTable2ndIndex,
+  kTable2ndDimMaxCount
+};
+
+// State of address, for lazy binding.
+enum BindingState {
+  kBindingStateUnresolved   = 0, // Represents all kinds of unresolved state.
+  kBindingStateCinfUndef    = 1,
+  kBindingStateCinfDef      = 2,
+  kBindingStateDataUndef    = 3,
+  kBindingStateDataDef      = 4,
+  kBindingStateMethodUndef  = 5,
+  kBindingStateMethodDef    = 6,
+  kBindingStateMax          = 4 * 1024, // a page
+  kBindingStateResolved // Already resolved if great than Max.
+};
+
+// Type for searching address.
+enum AddressRangeType {
+  kTypeWhole  = 0, // The range is the whole MFile.
+  kTypeText   = 1, // The range is Java Text sections
+  kTypeClass  = 2, // The range is Class Metadata sections.
+  kTypeData   = 3  // The range is Data section
+};
+
+// State of loading process.
+enum LoadStateType {
+  kLoadStateNone = 0, // The state of no loading or loading finished.
+  kLoadStateBoot = 1, // The state of loading in boot(mygote).
+  kLoadStateSS   = 2, // The state of loading system_server.
+  kLoadStateApk  = 3  // The state of loading APK.
+};
+
+// State of app loading.
+enum AppLoadState {
+  kAppLoadNone          = 0, // Not loading APK for App.
+  kAppLoadBaseOnlyReady = 1, // Ready to load the base APK
+  kAppLoadBaseOnly      = 2, // Loading the base APK and successive
+  kAppLoadBaseAndOthers = 3  // Start to load other APKs
+};
+
+enum MFileInfoSource {
+  kFromPC = 0,
+  kFromAddr,
+  kFromMeta,
+  kFromHandle,
+  kFromName,
+  kFromClass,
+  kFromClassLoader
+};
+
+using PtrMatrixType = void *(*)[kTable2ndDimMaxCount];
+
+struct FuncProfInfo {
+  uint32_t callTimes;
+  uint8_t layoutType;
+  std::string funcName;
+  FuncProfInfo(uint32_t callTimes, uint8_t layoutType) : callTimes(callTimes), layoutType(layoutType) {}
+  FuncProfInfo(uint32_t callTimes, uint8_t layoutType, std::string funcName)
+      : callTimes(callTimes), layoutType(layoutType), funcName(std::move(funcName)) {}
+};
+
+struct FuncIRProfInfo {
+  std::string funcName;
+  uint64_t hash;
+  uint32_t start; // indicate the start index in counter Table
+  uint32_t end;
+  FuncIRProfInfo(std::string funcName, uint64_t hash, uint32_t start, uint32_t end)
+      : funcName(std::move(funcName)), hash(hash), start(start), end(end) {}
+};
+
+struct MFileIRProfInfo {
+  std::vector<FuncIRProfInfo> descTab;
+  std::vector<uint32_t> counterTab;
+};
+
+struct LinkerLocInfo {
+  std::string path; // Path name of maple library
+  void *addr = nullptr; // Method address
+  uint32_t size = 0; // Method size
+  std::string sym; // Method symbol pointer
+};
+
+using ClassLoaderListT = std::vector<jobject>;
+using ClassLoaderListItT = std::vector<jobject>::iterator;
+using ClassLoaderListRevItT = std::vector<jobject>::reverse_iterator;
+
+enum MFileInfoFlags {
+  // LinkerMFileInfo flags
+  kIsBoot = 0,
+  kIsLazy,
+  kIsRelMethodOnce,
+  kIsRelDataOnce,
+  kIsMethodDefResolved,
+  kIsDataDefResolved,
+  kIsVTabResolved,
+  kIsITabResolved,
+  kIsVTabOffsetResolved,
+  kIsFieldOffsetResolved,
+  kIsSuperClassResolved,
+  kIsGCRootListResolved,
+  kIsMethodUndefHasNotResolved,
+  kIsMethodDefHasNotResolved,
+  kIsDataUndefHasNotResolved,
+  kIsDataDefHasNotResolved,
+  kIsMethodRelocated,
+  kIsDataRelocated,
+  kIsMethodUndefCacheValid,
+  kIsMethodCacheValid,
+  kIsDataUndefCacheValid,
+  kIsDataCacheValid,
+  // DecoupleMFileInfo flags
+  kIsRelDecoupledClassOnce,
+  kIsDecoupledVTabResolved,
+  kIsDecoupledFieldOffsetResolved,
+  kIsFieldOffsetTabResolved,
+  kIsDecoupledStaticAddrTabResolved,
+  kIsFieldOffsetTrashCacheFileRemoved,
+  kIsFieldTableTrashCacheFileRemoved,
+  kIsStaticTrashCacheFileRemoved,
+  kIsVTabTrashCacheFileRemoved,
+  kIsCTabTrashCacheFileRemoved,
+  kIsITabTrashCacheFileRemoved,
+  kMFileInfoFlagMaxIndex
+};
+
+// each interval part for SectTabIndex Item
+static constexpr size_t kTableSizeInterval[] = {
+    1, 1, sizeof(LinkerVTableItem), sizeof(LinkerITableItem), sizeof(LinkerVTableOffsetItem),
+    sizeof(LinkerFieldOffsetItem), sizeof(int32_t), sizeof(size_t), sizeof(void*), sizeof(LinkerSuperClassTableItem),
+    sizeof(LinkerGCRootTableItem), 1, 1, 1, 1, 1, sizeof(LinkerAddrTableItem), sizeof(LinkerAddrTableItem),
+    sizeof(LinkerInfTableItem), sizeof(LinkerAddrTableItem), sizeof(LinkerAddrTableItem), sizeof(LinkerAddrTableItem),
+    sizeof(LinkerAddrTableItem), sizeof(LinkerMuidTableItem), sizeof(LinkerMuidTableItem), sizeof(LinkerMuidTableItem),
+    sizeof(LinkerMuidTableItem), sizeof(uint32_t), sizeof(LinkerFuncProfileTableItem), 1,
+    sizeof(LinkerStaticDecoupleClass), 1, 1, 1, 1, 1, sizeof(LinkerFuncProfDescItem),
+    sizeof(LinkerFuncProfileTableItem), 1
+};
+// each offset part for SectTabIndex Item
+static constexpr size_t kTableSizeOffset[] = {
+    0, 0, 0, 0, 0, 0, sizeof(LinkerOffsetKeyTableInfo) / sizeof(int32_t), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, sizeof(MplStaticAddrTabHead) / sizeof(LinkerStaticAddrItem), 0, 0, 0, 0, 0, 0, 0
+};
+using MplFuncProfile = std::unordered_map<uint32_t, FuncProfInfo>;
+class LinkerMFileInfo {
+ public:
+  LinkerMFileInfo() {
+    classLoader = nullptr;
+    startHotStrTab = nullptr;
+    bothHotStrTab = nullptr;
+    runHotStrTab = nullptr;
+    coldStrTab = nullptr;
+    coldStrTabEnd = nullptr;
+    rometadataFieldStart = nullptr;
+    rometadataFieldEnd = nullptr;
+    rometadataMethodStart = nullptr;
+    rometadataMethodEnd = nullptr;
+    romuidtabStart = nullptr;
+    romuidtabEnd = nullptr;
+  }
+  virtual ~LinkerMFileInfo() {}
+  void *elfBase = nullptr; // ELF base address.
+  void *elfStart = nullptr; // ELF tables start address.
+  void *elfEnd = nullptr; // ELF tables ending address.
+  std::string name; // Maple file path name.
+  void *handle = nullptr; // Maple file open handle.
+  MUID hash; // Hash code of .so.
+  MUID hashOfDecouple; // Hash code for decouple of .so.
+  uint32_t rangeTabSize = 0;
+  uint64_t decoupleStaticLevel = 0;
+
+  PtrMatrixType tableAddr = 0;
+
+  MplFuncProfile funProfileMap;
+#ifdef LINKER_RT_CACHE
+  LinkerCacheRep rep;
+#endif
+
+  jobject classLoader;
+  ClassLoaderListT clList;
+
+  char *startHotStrTab;
+  char *bothHotStrTab;
+  char *runHotStrTab;
+  char *coldStrTab;
+  char *coldStrTabEnd;
+
+  void *rometadataFieldStart;
+  void *rometadataFieldEnd;
+  void *rometadataMethodStart;
+  void *rometadataMethodEnd;
+
+  void *romuidtabStart;
+  void *romuidtabEnd;
+
+  MUID vtbCLHash;
+  MUID ctbCLHash;
+  MUID fosCLHash;
+  MUID ftbCLHash;
+  MUID staticCLHash;
+
+#if defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+  int methodCachingNum = 0;
+  std::string methodCachingStr;
+  std::mutex methodCachingLock;
+#endif // defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+
+  bool BelongsToApp();
+  void ReleaseReadOnlyMemory();
+#ifdef LINKER_DECOUPLE
+  virtual uint64_t GetDecoupleLevel() const = 0;
+  virtual void SetDecoupleLevel(uint64_t level) = 0;
+#endif
+  template<typename Type = void*, typename Convert = Type>
+  inline Type GetTblBegin(SectTabIndex index) {
+    assert(tableAddr != nullptr);
+    index = ((index == kMethodDefOrig || index == kDataDefOrig) && !flag[kIsLazy]) ?
+        static_cast<SectTabIndex>(static_cast<int>(index) - 1) : index;
+    return static_cast<Convert>(reinterpret_cast<Type>(tableAddr[index][kTable1stIndex]));
+  }
+  template<typename Type = void*, typename Convert = Type>
+  inline Type GetTblEnd(SectTabIndex index) {
+    assert(tableAddr != nullptr);
+    index = ((index == kMethodDefOrig || index == kDataDefOrig) && !flag[kIsLazy]) ?
+        static_cast<SectTabIndex>(static_cast<int>(index) - 1) : index;
+    return static_cast<Convert>(reinterpret_cast<Type>(tableAddr[index][kTable2ndIndex]));
+  }
+  template<typename Type = size_t>
+  inline Type GetTblSize(SectTabIndex index) {
+    assert(tableAddr != nullptr);
+    size_t begin = reinterpret_cast<size_t>(tableAddr[index][kTable1stIndex]);
+    size_t end = reinterpret_cast<size_t>(tableAddr[index][kTable2ndIndex]);
+    size_t result = (end - begin) / kTableSizeInterval[index];
+    size_t offset = kTableSizeOffset[index];
+    size_t size = (begin == 0 || end == 0 || result <= offset) ? 0 : (result - offset);
+    return static_cast<Type>(size);
+  }
+  inline bool IsFlag(MFileInfoFlags flagIndex) const {
+    return flag[flagIndex];
+  }
+  inline void SetFlag(MFileInfoFlags flagIndex, bool isTrue) {
+    flag[flagIndex] = isTrue;
+  }
+ private:
+  bool flag[kMFileInfoFlagMaxIndex] = { false };
+};
+
+class LinkerRef : public DataRef {
+ public:
+  LinkerRef() = default;
+  template<typename T>
+  explicit LinkerRef(T ref) {
+    SetDataRef<T>(ref);
+  }
+  LinkerRef(const LinkerRef&) = default;
+  ~LinkerRef() = default;
+  inline bool IsEmpty() const {
+    return refVal == 0;
+  }
+  inline bool IsVTabIndex() const { // 1 marks a conflict.
+    return ((refVal & kNegativeNum) == 0) && refVal != 1 && refVal != 0;
+  }
+  inline bool IsITabIndex() const { // 1 marks a conflict.
+    return (refVal & kNegativeNum) == 0 && refVal != 1;
+  }
+  inline bool IsIndex() const {
+    return (refVal & kFromIndexMask) != 0;
+  }
+  inline bool IsTabUndef() const {
+    constexpr uintptr_t kTableUndefBitMask = 0x2;
+    return (refVal & kTableUndefBitMask) == 0;
+  }
+  inline bool IsFromUndef() const {
+    return (refVal & kLinkerRefUnDef) != 0;
+  }
+  inline size_t GetTabIndex() const {
+    return static_cast<size_t>((refVal >> 2) - 1); // 2 bits as flag, real index is start with 3 bits;
+  }
+  inline size_t GetIndex() const {
+#if defined(__aarch64__)
+    constexpr uintptr_t kAddressMask = 0x0fffffffffffffff;
+    return static_cast<size_t>(refVal & kAddressMask);
+#elif defined(__arm__)
+    return static_cast<size_t>(refVal >> 2); // low 2 bit as flag
+#else
+    return 0;
+#endif
+  }
+ protected:
+#if defined(__aarch64__)
+  enum LinkerRefFormat {
+    kLinkerRefAddress   = 0ul, // must be 0
+    kLinkerRefDef       = 1ul << 61, // 61 bit as Def
+    kLinkerRefUnDef     = 1ul << 62, // 62 bit as Undef
+    kFromIndexMask      = kLinkerRefDef | kLinkerRefUnDef
+  };
+#elif defined(__arm__)
+  enum LinkerRefFormat {
+    kLinkerRefAddress   = 0ul, // must be 0
+    kLinkerRefDef       = 1ul, // def
+    kLinkerRefUnDef     = 2ul, // undef
+    kFromIndexMask      = kLinkerRefDef | kLinkerRefUnDef
+  };
+#endif
+};
+
+template<typename T>
+class Slice {
+ public:
+  Slice() : base(nullptr), num(0) {}
+  Slice(T *b, size_t n) : base(b), num(n) {}
+  ~Slice() {
+    base = nullptr;
+    num = 0;
+  }
+  Slice(const Slice&) = default;
+  Slice &operator=(const Slice&) = default;
+  T *Data() {
+    return base;
+  }
+  const T *Data() const {
+    return base;
+  }
+  size_t Size() const {
+    return num;
+  }
+  // Required: n < num.
+  T &operator[](size_t n) {
+    return base[n];
+  }
+  const T &operator[](size_t n) const {
+    return base[n];
+  }
+  // Required: num >= n.
+  Slice &operator+=(size_t n) {
+    base += n;
+    num -= n;
+    return *this;
+  }
+  bool Empty() const {
+    return (base == nullptr || num == 0);
+  }
+  void Clear() {
+    base = nullptr;
+    num = 0;
+  }
+
+ private:
+  T *base;
+  size_t num;
+};
+
+using AddrSlice = Slice<LinkerAddrTableItem>;
+using MuidSlice = Slice<LinkerMuidTableItem>;
+using MuidIndexSlice = Slice<LinkerMuidIndexTableItem>;
+using BufferSlice = Slice<char>;
+using IndexSlice = Slice<LinkerTableItem>;
+using VTableSlice = Slice<LinkerVTableItem>;
+using ITableSlice = VTableSlice;
+using InfTableSlice = Slice<LinkerInfTableItem>;
+}
+#endif // __cplusplus
+#endif // MAPLE_RUNTIME_MPL_LINKER_COMMON_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker_compiler.h b/src/mrt/compiler-rt/include/linker/linker_compiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..95336851919077246d21153ed9058fa16e2ba776
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_compiler.h
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_LINKER_COMPILER_H_
+#define MAPLE_RUNTIME_MPL_LINKER_COMPILER_H_
+
+#include "muid.h"
+#include "address.h"
+
+namespace maplert {
+#ifndef LINKER_LAZY_BINDING
+#define LINKER_LAZY_BINDING
+#endif
+
+#if defined(__ANDROID__)
+#define LINKER_RT_CACHE
+#define LINKER_DECOUPLE_CACHE
+#endif
+
+#ifdef USE_32BIT_REF
+constexpr uint32_t kDsoLoadedAddressStart = 0xC0000000;
+constexpr uint32_t kDsoLoadedAddressEnd   = 0xF0000000;
+#endif
+
+#ifdef USE_32BIT_REF
+constexpr uint32_t kNegativeNum = 0x80000000;
+constexpr uint32_t kGoldSymbolTableEndFlag = 0X40000000;
+#else
+constexpr uint64_t kNegativeNum = 0x8000000000000000;
+constexpr uint64_t kGoldSymbolTableEndFlag = 0X4000000000000000;
+#endif
+
+// We must open LINKER_ADDR_FROM_OFFSET and LINKER_32BIT_REF_FOR_DEF_UNDEF
+// at the same time for '.long' and '[sym]-.', such as '.long __cinf_Xxx - .',
+// or close them for '.quad __cinf_Xxx'
+#ifdef USE_32BIT_REF
+#define LINKER_32BIT_REF_FOR_DEF_UNDEF
+#define LINKER_ADDR_FROM_OFFSET
+#endif
+
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF // We use exclusive LINKER_32BIT_REF_FOR_DEF_UNDEF for def/undef USE_32BIT_REF
+using LinkerOffsetType = int32_t;
+using LinkerVoidType = uint32_t;
+#else
+using LinkerOffsetType = int64_t;
+using LinkerVoidType = uint64_t;
+#endif // USE_32BIT_REF
+
+#ifdef USE_32BIT_REF
+using VOID_PTR = uint32_t;
+using INT_VAL = int32_t;
+#else
+using VOID_PTR = uint64_t;
+using INT_VAL = int64_t;
+#endif
+
+static constexpr const char kPreinitModuleClasses[] = "MRT_PreinitModuleClasses";
+static constexpr const char kRangeTableFunc[] = "MRT_GetRangeTableBegin";
+static constexpr const char kRangeTableEndFunc[] = "MRT_GetRangeTableEnd";
+static constexpr const char kMapleStartFunc[] = "MRT_GetMapleStart";
+static constexpr const char kMapleEndFunc[] = "MRT_GetMapleEnd";
+static constexpr const char kMapleVersionBegin[] = "MRT_GetVersionTabBegin";
+static constexpr const char kMapleVersionEnd[] = "MRT_GetVersionTabEnd";
+static constexpr const char kMapleCompileStatusBegin[] = "MRT_GetMFileStatusBegin";
+static constexpr const char kMapleCompileStatusEnd[] = "MRT_GetMFileStatusEnd";
+static constexpr const char kStartHotStrTabBegin[] = "MRT_GetStartHotStrTabBegin";
+static constexpr const char kBothHotStrTabBegin[] = "MRT_GetBothHotStrTabBegin";
+static constexpr const char kRunHotStrTabBegin[] = "MRT_GetRunHotStrTabBegin";
+static constexpr const char kColdStrTabBegin[] = "MRT_GetColdStrTabBegin";
+static constexpr const char kColdStrTabEnd[] = "MRT_GetColdStrTabEnd";
+static constexpr const char kMetadataFieldStart[] = "MRT_GetMFileROMetadataFieldStart";
+static constexpr const char kMetadataFieldEnd[] = "MRT_GetMFileROMetadataFieldEnd";
+static constexpr const char kMetadataMethodStart[] = "MRT_GetMFileROMetadataMethodStart";
+static constexpr const char kMetadataMethodEnd[] = "MRT_GetMFileROMetadataMethodEnd";
+static constexpr const char kMuidTabStart[] = "MRT_GetMFileROMuidtabStart";
+static constexpr const char kMuidTabEnd[] = "MRT_GetMFileROMuidtabEnd";
+static constexpr const char kBBProfileTabBegin[] = "MRT_GetBBProfileTabBegin";
+static constexpr const char kBBProfileTabEnd[] = "MRT_GetBBProfileTabEnd";
+static constexpr const char kBBProfileStrTabBegin[] = "MRT_GetBBProfileStrTabBegin";
+static constexpr const char kBBProfileStrTabEnd[] = "MRT_GetBBProfileStrTabEnd";
+
+#pragma pack(4)
+struct LinkerOffsetKeyTableInfo {
+#ifdef USE_32BIT_REF
+  int32_t vtableOffsetTable;
+  int32_t fieldOffsetTable;
+#else
+  int64_t vtableOffsetTable;
+  int64_t fieldOffsetTable;
+#endif
+  uint32_t vtableOffsetTableSize;
+  uint32_t fieldOffsetTableSize;
+};
+
+// vtable offset key table for decoupling
+struct LinkerVTableOffsetItem {
+  size_t index; // pointer to class metadata
+  int32_t methodName;
+  int32_t signatureName;
+  int32_t fieldIndex;
+};
+
+struct LinkerFieldOffsetItem {
+  size_t index; // pointer to class metadata
+  int32_t fieldName;
+  int32_t fieldType;
+  int32_t vtableIndex;
+};
+
+struct LinkerStaticDecoupleClass {
+  size_t callee; // class index
+  uint32_t fieldsNum;
+  uint32_t methodsNum;
+  uint32_t pad;
+};
+
+struct LinkerStaticAddrItem {
+  VOID_PTR address;
+  VOID_PTR index;
+  VOID_PTR dcpAddr;
+  VOID_PTR classInfo;
+};
+
+struct MplStaticFieldItem {
+  size_t caller;
+  uint32_t fieldName;
+  uint32_t fieldType;
+  uint32_t fieldIdx;
+};
+
+struct MplStaticMethodItem {
+  size_t caller;
+  uint32_t methodName;
+  uint32_t methodSignature;
+  uint32_t methodIdx;
+};
+
+struct MplStaticAddrTabHead {
+  union {
+    uintptr_t mplInfo;
+    uint64_t pad; // keep 64 bits alignment
+  };
+  VOID_PTR classSize;
+  VOID_PTR tableSize;
+  uint64_t magic;
+};
+
+struct MplStaticFieldInfo {
+  bool isAccess;
+  uint64_t fieldAddr;
+  uint64_t classInfo;
+};
+
+struct MplFieldInfo {
+  char *fieldName;
+  char *fieldType;
+};
+#pragma pack()
+
+struct LinkerAddrTableItem {
+  LinkerOffsetType addr; // Original method address offset, 64bits
+
+  // We've used AddressFromOffset() as hard code everywhere,
+  // so we control using offset(implying 32bit in the case of def/undef)
+  // or not in the function, by LINKER_ADDR_FROM_OFFSET.
+  void *AddressFromOffset() const {
+#ifdef LINKER_ADDR_FROM_OFFSET
+    LinkerOffsetType offset = addr;
+    char *base = reinterpret_cast<char*>(const_cast<LinkerOffsetType*>(&addr));
+    return reinterpret_cast<void*>(base + offset);
+#else
+    return reinterpret_cast<void*>(static_cast<LinkerVoidType>(addr));
+#endif
+  }
+
+  void *AddressFromBase(void *baseAddr) const {
+    LinkerOffsetType offset = addr;
+    char *base = reinterpret_cast<char*>(baseAddr);
+    return reinterpret_cast<void*>(base + offset);
+  }
+
+  void *Address() const {
+    return reinterpret_cast<void*>(static_cast<LinkerVoidType>(addr));
+  }
+};
+
+// Method undefine table item.
+struct LinkerMuidTableItem {
+  MUID muid; // MUID, 128bits
+
+  // MUID comparison
+  bool operator < (const MUID &tmp) const {
+    return muid < tmp;
+  }
+  bool operator > (const MUID &tmp) const {
+    return muid > tmp;
+  }
+  bool operator == (const MUID &tmp) const {
+    return muid == tmp;
+  }
+};
+
+// Muid sorted index table item for 'LinkerAddrTableItem'.
+// Use for SYMBOL/MUID --> ADDRESS.
+// See struct 'LinkerAddrTableItem'
+struct LinkerMuidIndexTableItem {
+  uint32_t index; // Address sorted index, 32bits
+};
+
+struct LinkerFuncProfileTableItem {
+  uint32_t callTimes; // function call times or bb call times
+};
+
+struct LinkerFuncProfDescItem {
+  uint64_t hash; // function hash
+  // [start,end] indicate the range in profile counter tab
+  // which belongs to this function
+  uint32_t start;
+  uint32_t end;
+};
+
+struct LinkerVTableItem {
+#ifdef USE_32BIT_REF
+  uint32_t index; // Index in undef table, 32bits
+#else
+  size_t index; // Index in undef table, 64bits
+#endif
+};
+
+using LinkerITableItem = LinkerVTableItem;
+
+struct LinkerTableItem {
+  size_t index;
+};
+
+using LinkerSuperClassTableItem = LinkerTableItem;
+using LinkerGCRootTableItem = LinkerTableItem;
+
+// offset value table for decoupling
+struct LinkerOffsetValItem {
+  int32_t offset; // field offset in object layout, or method offset in vtable
+};
+
+struct LinkerOffsetValItemLazyLoad {
+  reffield_t offsetAddr;
+  uint32_t offset; // field offset in object layout, or method offset in vtable
+#ifndef USE_32BIT_REF
+  int32_t pad;
+#endif
+};
+
+struct MapleVersionT {
+  uint32_t mplMajorVersion;
+  uint32_t compilerMinorVersion;
+};
+
+// Method info. table item.
+struct LinkerInfTableItem {
+  uint32_t size; // Method size, 32bits
+  int32_t funcNameOffset; // Offset of func name, 32bits
+};
+} // namespace maplert
+#endif // MAPLE_RUNTIME_MPL_LINKER_COMPILER_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker_debug.h b/src/mrt/compiler-rt/include/linker/linker_debug.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ba9703a224285487fcf5fd95665843a4213aa5c
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_debug.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_DEBUG_H_
+#define MAPLE_RUNTIME_MPL_DEBUG_H_
+
+#include "linker_model.h"
+
+namespace maplert {
+class Debug : public FeatureModel {
+ public:
+  static FeatureName featureName;
+  explicit Debug(LinkerInvoker &invoker) : pInvoker(&invoker) {};
+  ~Debug() {
+    pInvoker = nullptr;
+  }
+  void DumpAllMplSectionInfo(std::ostream &os);
+  void DumpAllMplFuncProfile(std::unordered_map<std::string, std::vector<FuncProfInfo>> &funcProfileRaw);
+  void DumpAllMplFuncIRProfile(std::unordered_map<std::string, MFileIRProfInfo> &funcProfileRaw);
+  uint64_t DumpMetadataSectionSize(std::ostream &os, void *handle, const std::string sectionName);
+  bool DumpMethodUndefSymbol(LinkerMFileInfo &mplInfo);
+  bool DumpMethodSymbol(LinkerMFileInfo &mplInfo);
+  bool DumpDataUndefSymbol(LinkerMFileInfo &mplInfo);
+  bool DumpDataSymbol(LinkerMFileInfo &mplInfo);
+  void DumpStackInfoInLog();
+  void DumpBBProfileInfo(std::ostream &os);
+ private:
+  LinkerInvoker *pInvoker = nullptr;
+};
+} // namespace maplert
+#endif // MAPLE_RUNTIME_MPL_DEBUG_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker_gctib.h b/src/mrt/compiler-rt/include/linker/linker_gctib.h
new file mode 100644
index 0000000000000000000000000000000000000000..9abb2be93c1a2f39d85404c1c0bda7f592cee625
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_gctib.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MPL_RUNTIME_LINKER_GCTIB_H
+#define MPL_RUNTIME_LINKER_GCTIB_H
+
+#include "sizes.h"
+
+namespace maplert {
+void RefCal(const MClass &cls, std::vector<uint64_t> &refOffsets, std::vector<uint64_t> &weakOffsets,
+    std::vector<uint64_t> &unownedOffsets, uint64_t &maxRefOffset);
+void DumpGctib(const struct GCTibGCInfo &gctib);
+bool ReGenGctib(ClassMetadata *classInfo, bool forceUpdate = true);
+} // namespace maplert
+#endif // MPL_RUNTIME_LINKER_GCTIB_H
diff --git a/src/mrt/compiler-rt/include/linker/linker_hotfix.h b/src/mrt/compiler-rt/include/linker/linker_hotfix.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b785b0c615514f685a0b9138e0b7a50b0ac237f
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_hotfix.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_HOTFIX_H_
+#define MAPLE_RUNTIME_MPL_HOTFIX_H_
+
+#include "linker_model.h"
+
+namespace maplert {
+class Hotfix : public FeatureModel {
+ public:
+  static FeatureName featureName;
+  explicit Hotfix(LinkerInvoker &invoker) : pInvoker(&invoker) {}
+  ~Hotfix() {
+    pInvoker = nullptr;
+  }
+  void SetClassLoaderParent(const MObject *classLoader, const MObject *newParent);
+  void InsertClassesFront(const MObject *classLoader, const LinkerMFileInfo &mplInfo, const std::string &path);
+  void SetPatchPath(const std::string &path, int32_t mode);
+  std::string GetPatchPath();
+  bool IsFrontPatchMode(const std::string &path);
+  bool ResetResolvedFlags(LinkerMFileInfo &mplInfo);
+  bool ReleaseCaches(LinkerMFileInfo &mplInfo);
+ private:
+  int32_t patchMode = 1; // 0 - classloader parent, 1 - dexpath list
+  std::string patchPath;
+  LinkerInvoker *pInvoker = nullptr;
+};
+} // namespace maplert
+#endif // MAPLE_RUNTIME_MPL_HOTFIX_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker_info.h b/src/mrt/compiler-rt/include/linker/linker_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..514278b8a2703c2c16154ccc9f08d77e83ec191c
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_info.h
@@ -0,0 +1,404 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_LINKER_INFO_H_
+#define MAPLE_RUNTIME_MPL_LINKER_INFO_H_
+
+#include <mutex>
+#include <algorithm>
+
+#include "linker_utils.h"
+#include "methodmeta.h"
+
+namespace maplert {
+MUID GetHash(const std::vector<LinkerMFileInfo*> &mplInfos, bool getSolidHash);
+
+class LinkerMFileInfoListT {
+ public:
+  using InfoList = std::vector<LinkerMFileInfo*>;
+
+  LinkerMFileInfoListT() {}
+  ~LinkerMFileInfoListT() {}
+
+  LinkerMFileInfoListT(const LinkerMFileInfoListT &other) = delete;
+  LinkerMFileInfoListT &operator=(const LinkerMFileInfoListT&) = delete;
+
+  void Merge(const InfoList &other) {
+    std::lock_guard<std::mutex> lock(mutex);
+    (void)infos.insert(infos.end(), other.begin(), other.end());
+  }
+
+  void Clear() {
+    std::lock_guard<std::mutex> lock(mutex);
+    infos.clear();
+  }
+
+  std::vector<LinkerMFileInfo*> Clone() {
+    std::lock_guard<std::mutex> lock(mutex);
+    return infos;
+  }
+
+  LinkerMFileInfo *Get(size_t index) {
+    std::lock_guard<std::mutex> lock(mutex);
+    return infos[index];
+  }
+
+  size_t Size() {
+    std::lock_guard<std::mutex> lock(mutex);
+    return infos.size();
+  }
+
+  bool Empty() {
+    std::lock_guard<std::mutex> lock(mutex);
+    return infos.empty();
+  }
+
+  void Append(LinkerMFileInfo &mplInfo, int32_t pos) {
+    std::lock_guard<std::mutex> lock(mutex);
+    if (pos <= -1) {
+      infos.push_back(&mplInfo);
+    } else {
+      (void)infos.insert(infos.begin() + pos, &mplInfo);
+    }
+  }
+  template<typename UnaryFunction>
+  void ForEach(const UnaryFunction f) {
+    std::lock_guard<std::mutex> lock(mutex);
+    for (auto mplInfo : infos) {
+      f(*mplInfo);
+    }
+  }
+  template<class UnaryPredicate>
+  bool FindIf(const UnaryPredicate p) {
+    std::lock_guard<std::mutex> lock(mutex);
+    for (auto mplInfo : infos) {
+      if (p(*mplInfo)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  template<class UnaryPredicate>
+  bool FindIfNot(UnaryPredicate p) {
+    std::lock_guard<std::mutex> lock(mutex);
+    for (auto mplInfo : infos) {
+      if (!p(*mplInfo)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  MUID Hash(bool getSolidHash) {
+    std::lock_guard<std::mutex> lock(mutex);
+    return GetHash(infos, getSolidHash);
+  }
+
+ private:
+  std::mutex mutex;
+  InfoList infos;
+};
+
+class LinkerMFileInfoListCLMapT {
+ public:
+  using ClInfoMapT = std::unordered_map<const MObject*, std::vector<LinkerMFileInfo*>>;
+
+  LinkerMFileInfoListCLMapT() {
+    (void)pthread_rwlock_init(&lock, nullptr);
+  }
+  ~LinkerMFileInfoListCLMapT() {}
+
+  LinkerMFileInfoListCLMapT(const LinkerMFileInfoListCLMapT &other) = delete;
+  LinkerMFileInfoListCLMapT &operator=(const LinkerMFileInfoListCLMapT&) = delete;
+
+  void Clear() {
+    (void)(pthread_rwlock_wrlock(&lock));
+    infos.clear();
+    (void)(pthread_rwlock_unlock(&lock));
+  }
+  void Append(LinkerMFileInfo &mplInfo, int32_t pos) {
+    (void)(pthread_rwlock_wrlock(&lock));
+    const MObject *classLoader = reinterpret_cast<const MObject*>(mplInfo.classLoader);
+    auto &list = infos[classLoader];
+    if (pos <= -1) {
+      list.push_back(&mplInfo);
+    } else {
+      (void)list.insert(list.begin() + pos, &mplInfo);
+    }
+    (void)(pthread_rwlock_unlock(&lock));
+  }
+  template<typename UnaryFunction>
+  bool FindIf(const MObject *classLoader, const UnaryFunction f) {
+    (void)(pthread_rwlock_rdlock(&lock));
+    auto iter = infos.find(classLoader);
+    if (iter != infos.end()) {
+      auto &list = iter->second;
+      for (auto mplInfo : list) {
+        if (f(*mplInfo)) {
+          (void)(pthread_rwlock_unlock(&lock));
+          return true;
+        }
+      }
+    }
+    (void)(pthread_rwlock_unlock(&lock));
+    return false;
+  }
+  template<typename UnaryFunction>
+  bool ForEach(const UnaryFunction f) {
+    (void)(pthread_rwlock_rdlock(&lock));
+    for (auto &item : infos) {
+      auto &list = item.second;
+      for (auto mplinfo : list) {
+        f(*mplinfo);
+      }
+    }
+    (void)(pthread_rwlock_unlock(&lock));
+    return true;
+  }
+  template<typename UnaryFunction>
+  bool ForEach(const MObject *classLoader, const UnaryFunction f) {
+    (void)(pthread_rwlock_rdlock(&lock));
+    auto iter = infos.find(classLoader);
+    if (iter != infos.end()) {
+      auto &list = iter->second;
+      for (auto mplinfo : list) {
+        f(*mplinfo);
+      }
+    }
+    (void)(pthread_rwlock_unlock(&lock));
+    return true;
+  }
+  void FindToExport(const MObject *classLoader, LinkerMFileInfoListT &fileList) {
+    (void)(pthread_rwlock_rdlock(&lock));
+    auto iter = infos.find(classLoader);
+    if (iter != infos.end()) {
+      fileList.Merge(iter->second);
+    }
+    (void)(pthread_rwlock_unlock(&lock));
+  }
+  bool FindListInfo(const MObject *classLoader, size_t &size, MUID &hash) {
+    (void)(pthread_rwlock_rdlock(&lock));
+    auto iter = infos.find(classLoader);
+    if (iter != infos.end()) {
+      auto &list = iter->second;
+      size = list.size();
+      hash = GetHash(list, false);
+      (void)(pthread_rwlock_unlock(&lock));
+      return true;
+    }
+    (void)(pthread_rwlock_unlock(&lock));
+    return false;
+  }
+
+ private:
+  pthread_rwlock_t lock;
+  ClInfoMapT infos;
+};
+
+class LinkerMFileInfoNameMapT {
+ public:
+  using NameInfoMapT = std::unordered_map<std::string, LinkerMFileInfo*>;
+
+  void Clear() {
+    std::lock_guard<std::mutex> lock(mutex);
+    nameInfos.clear();
+  }
+  void Append(LinkerMFileInfo &mplInfo) {
+    std::lock_guard<std::mutex> lock(mutex);
+    (void)nameInfos.insert(std::make_pair(mplInfo.name, &mplInfo));
+  }
+  bool Find(const std::string &name) {
+    std::lock_guard<std::mutex> lock(mutex);
+    return nameInfos.find(name) != nameInfos.end();
+  }
+  bool Find(const std::string &name, LinkerMFileInfo *&res) {
+    std::lock_guard<std::mutex> lock(mutex);
+    auto it = nameInfos.find(name);
+    if (it != nameInfos.end()) {
+      res = it->second;
+      return true;
+    }
+    res = nullptr;
+    return false;
+  }
+  LinkerMFileInfo *FindByDecoupleHash(const MUID &hash) {
+    std::lock_guard<std::mutex> lock(mutex);
+    auto it = nameInfos.begin();
+    for (; it != nameInfos.end(); ++it) {
+      if (it->second->hashOfDecouple == hash) {
+        return it->second;
+      }
+    }
+    return nullptr;
+  }
+ private:
+  std::mutex mutex;
+  NameInfoMapT nameInfos;
+};
+
+class LinkerMFileInfoHandleMapT {
+ public:
+  using HandleInfoMapT = std::unordered_map<const void*, LinkerMFileInfo*>;
+
+  bool Find(const void *handle) {
+    std::lock_guard<std::mutex> lock(mutex);
+    return handleInfos.find(handle) != handleInfos.end();
+  }
+  bool Find(const void *handle, LinkerMFileInfo *&res) {
+    std::lock_guard<std::mutex> lock(mutex);
+    auto it = handleInfos.find(handle);
+    if (it != handleInfos.end()) {
+      res = it->second;
+      return true;
+    }
+    res = nullptr;
+    return false;
+  }
+  void Clear() {
+    std::lock_guard<std::mutex> lock(mutex);
+    handleInfos.clear();
+  }
+  void Append(LinkerMFileInfo &mplInfo) {
+    std::lock_guard<std::mutex> lock(mutex);
+    (void)handleInfos.insert(std::make_pair(mplInfo.handle, &mplInfo));
+  }
+
+ private:
+  std::mutex mutex;
+  HandleInfoMapT handleInfos;
+};
+
+struct ElfAddrCmp {
+  using is_transparent = void; // stl::set search will use this defing, cannot remove
+  const void *addr = nullptr;
+  AddressRangeType searchType = kTypeText;
+  bool operator()(const ElfAddrCmp *leftObj, const LinkerMFileInfo *rightObj) const {
+    switch (leftObj->searchType) {
+      case kTypeText:
+        return leftObj->addr > rightObj->tableAddr[kJavaText][kTable1stIndex];
+      case kTypeClass:
+        return leftObj->addr > rightObj->tableAddr[kTabClassMetadata][kTable1stIndex];
+      case kTypeData:
+        return leftObj->addr > rightObj->tableAddr[kBssSection][kTable1stIndex];
+      default:
+        return leftObj->addr > rightObj->elfStart;
+    }
+  }
+  bool operator()(const LinkerMFileInfo *leftObj, const ElfAddrCmp *rightObj) const {
+    switch (rightObj->searchType) {
+      case kTypeText:
+        return leftObj->tableAddr[kJavaText][kTable1stIndex] > rightObj->addr;
+      case kTypeClass:
+        return leftObj->tableAddr[kTabClassMetadata][kTable1stIndex] > rightObj->addr;
+      case kTypeData:
+        return leftObj->tableAddr[kBssSection][kTable1stIndex] > rightObj->addr;
+      default:
+        return leftObj->elfStart > rightObj->addr;
+    }
+  }
+  bool operator()(const LinkerMFileInfo *leftObj, const LinkerMFileInfo *rightObj) const {
+    // NOTICE: 'tableAddr' must be initialized before here! Check InitLinkerMFileInfo()->GetValidityCode().
+    // We expect the ELF files don't overlap with each other, so we just us JAVA TEXT to compare.
+    return leftObj->tableAddr[kJavaText][kTable1stIndex] > rightObj->tableAddr[kJavaText][kTable1stIndex];
+  }
+  bool operator()(const LinkerMFileInfo *leftObj, const void *address) const {
+    return leftObj->tableAddr[kJavaText][kTable1stIndex] > address;
+  }
+  bool operator()(const void *address, const LinkerMFileInfo *rightObj) const {
+    return address > rightObj->tableAddr[kJavaText][kTable1stIndex];
+  }
+};
+class LinkerMFileInfoElfAddrSetT {
+ public:
+  using InfoSetT = std::set<LinkerMFileInfo*, ElfAddrCmp>;
+
+  void Clear() {
+    std::lock_guard<std::mutex> lock(mutex);
+    infos.clear();
+  }
+
+  bool Append(LinkerMFileInfo &mplInfo) {
+    std::lock_guard<std::mutex> lock(mutex);
+    return infos.insert(&mplInfo).second;
+  }
+
+  LinkerMFileInfo *Search(const void *pc, AddressRangeType type) {
+    std::lock_guard<std::mutex> lock(mutex);
+    ElfAddrCmp tmpObj;
+    tmpObj.addr = pc;
+    tmpObj.searchType = type;
+    const void *endAddr = nullptr;
+    auto iter = infos.lower_bound(&tmpObj);
+    if (iter == infos.end()) {
+      return nullptr;
+    }
+    switch (type) {
+      case kTypeText:
+        endAddr = (*iter)->tableAddr[kJavaText][kTable2ndIndex];
+        break;
+      case kTypeClass:
+        endAddr = (*iter)->tableAddr[kTabClassMetadata][kTable2ndIndex];
+        break;
+      case kTypeData:
+        endAddr = (*iter)->tableAddr[kBssSection][kTable2ndIndex];
+        break;
+      default:
+        endAddr = (*iter)->elfEnd;
+        break;
+    }
+    if (pc <= endAddr) {
+      return *iter;
+    }
+    return nullptr;
+  }
+
+  LinkerMFileInfo *SearchJavaText(const void *pc) {
+    if (UNLIKELY(pc == nullptr)) {
+      return nullptr;
+    }
+    auto iter = infos.lower_bound(pc);
+    if (iter != infos.end() && pc <= (*iter)->tableAddr[kJavaText][kTable2ndIndex]) {
+      return *iter;
+    }
+    return nullptr;
+  }
+
+ private:
+  std::mutex mutex;
+  InfoSetT infos;
+};
+
+// Map from classloader object to loadClass method.
+class MplClassLoaderLoadClassMethodMapT {
+ public:
+  // Map from classloader object to loadClass method.
+  using ClMethodMapT = std::unordered_map<MClass*, MethodMeta*>;
+
+  MethodMeta *Find(MClass *classLoaderClass) {
+    std::lock_guard<std::mutex> lock(mutex);
+    auto it = clMethodInfo.find(classLoaderClass);
+    if (it != clMethodInfo.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+  void Append(MClass *classLoaderClass, MethodMeta *method) {
+    std::lock_guard<std::mutex> lock(mutex);
+    (void)clMethodInfo.insert(std::make_pair(classLoaderClass, method));
+  }
+
+ private:
+  std::mutex mutex;
+  ClMethodMapT clMethodInfo;
+};
+} // namespace maplert
+#endif
diff --git a/src/mrt/compiler-rt/include/linker/linker_inline.h b/src/mrt/compiler-rt/include/linker/linker_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b833381d14547cfbce7de83fff098bed6d9f677
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_inline.h
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_LINKER_INLINE_H_
+#define MAPLE_RUNTIME_MPL_LINKER_INLINE_H_
+
+#include "linker_api.h"
+#include "linker_hotfix.h"
+#include "linker_lazy_binding.h"
+#include "linker.h"
+
+namespace maplert {
+// Do action for each maple file
+template<typename Type, typename F, typename Data>
+bool LinkerInvoker::ForEachDoAction(Type obj, F action, const Data &data) {
+  bool ret = true;
+  auto handle = [&](LinkerMFileInfo &mplInfo) {
+    if (!(obj->*action)(mplInfo, *data)) {
+      ret = false;
+    }
+  };
+  (void)mplInfoListCLMap.ForEach(handle);
+  return ret;
+}
+template<typename Type, typename F>
+bool LinkerInvoker::ForEachDoAction(Type obj, F action) {
+  bool ret = true;
+  auto handle = [&](LinkerMFileInfo &mplInfo) {
+    if (!(obj->*action)(mplInfo)) {
+      ret = false;
+    }
+  };
+  (void)mplInfoListCLMap.ForEach(handle);
+  return ret;
+}
+template<typename Type, typename F>
+bool LinkerInvoker::DoAction(Type obj, F action, LinkerMFileInfo &mplInfo) {
+  bool ret = true;
+  ret = (obj->*action)(mplInfo);
+  return ret;
+}
+
+// Return the position in un|define table, -1 if not found.
+// pTable: Main table, maintaining all data.
+// pMuidIndexTable: Index table, use it to find the index in muid table.
+// start: Start index of sorted table, if index table exists, use index table start index.
+// End: End index of sorted table, if index table exists, use index table end index.
+// value: Value, to search.
+template<typename T1, typename T2, typename T3>
+int64_t Linker::BinarySearch(T1 &pTable, const T2 &pMuidIndexTable, int64_t start, int64_t end, const T3 &value) {
+  int64_t mid = 0;
+  while (start <= end) {
+    mid = (start + end) / 2;
+    // reserve index low 31 bits
+    uint64_t index = (&pMuidIndexTable)[mid].index & ~(1UL << 31);
+    T1 *tmp = &pTable + index;
+    if (*tmp < value) { // Less than value
+      start = mid + 1;
+    } else if (*tmp > value) { // Greater than value
+      end = mid - 1;
+    } else { // Resolved
+      return static_cast<int64_t>(index);
+    }
+  }
+  return -1; // Not resolved
+}
+
+// Return the position in un|define table, -1 if not found.
+// pTable: Main table, maintaining all data.
+// start: Start index of sorted table, if index table exists, use index table statrt index.
+// End: End index of sorted table, if index table exists, use index table end index.
+// value: Value, to search.
+template<typename T1, typename T2>
+int64_t Linker::BinarySearch(T1 &pTable, int64_t start, int64_t end, const T2 &value) {
+  int64_t mid = 0;
+  while (start <= end) {
+    mid = (start + end) / 2;
+    T1 *tmp = &pTable + mid;
+    if (*tmp < value) { // Less than value
+      start = mid + 1;
+    } else if (*tmp > value) { // Greater than value
+      end = mid - 1;
+    } else { // Resolved
+      return mid;
+    }
+  }
+  return -1; // Not resolved
+}
+
+inline bool AddrInScope(size_t addr, size_t start, size_t end, uint32_t index, const int skipInvalidBitsNum) {
+  return ((!((addr >= start) && (addr < end))) || ((index >> static_cast<uint32_t>(skipInvalidBitsNum)) & 1));
+}
+// Return the position in un|define table, -1 if not found.
+//
+// table: Main table, maintaining all data.
+// start: Start index of sorted table, if index table exists, use index table statrt index.
+// end: End index of sorted table, if index table exists, use index table end index.
+// value: Value, to search.
+// indexTable: Index table, containing sorted indice.
+// infoTable: Info. table, containing sorted indice.
+// scopeStartAddr: Java text section start address.
+// scopeEndAddr: Java text section end address.
+template<typename T1, typename T2, typename T3>
+int64_t LinkerInvoker::BinarySearchIndex(const LinkerMFileInfo &mplInfo, const T1 &table, size_t start,
+    size_t end, const size_t value, const T2 &indexTable, T3 &infTable, size_t scopeStartAddr,
+    size_t scopeEndAddr) {
+  constexpr int skipInvalidBitsNum = 31;
+  while (AddrInScope(reinterpret_cast<size_t>(linkerutils::GetDefTableAddress(mplInfo, table, start, true)),
+      scopeStartAddr, scopeEndAddr, indexTable[start].index, skipInvalidBitsNum) && (start <= end)) {
+    ++start; // Skip invalid address towards END. Check 32 bit
+  }
+  while (AddrInScope(reinterpret_cast<size_t>(linkerutils::GetDefTableAddress(mplInfo, table, end, true)),
+      scopeStartAddr, scopeEndAddr, indexTable[end].index, skipInvalidBitsNum) && (end >= start)) {
+    --end; // Skip invalid address towards START. Check 32 bit
+  }
+  while (start <= end) {
+    size_t mid = (start + end) / 2;
+    while (AddrInScope(reinterpret_cast<size_t>(linkerutils::GetDefTableAddress(mplInfo, table, mid, true)),
+        scopeStartAddr, scopeEndAddr, indexTable[mid].index, skipInvalidBitsNum) && (mid < end)) {
+      ++mid; // Skip invalid address towards END. Check 32 bit
+    }
+    if (mid == end) { // Check if all addresses are invalid between MID and END
+      mid = (start + end) / 2;
+      while (AddrInScope(reinterpret_cast<size_t>(linkerutils::GetDefTableAddress(mplInfo, table, mid, true)),
+          scopeStartAddr, scopeEndAddr, indexTable[mid].index, skipInvalidBitsNum) && (mid > start)) {
+        --mid; // Skip invalid address towards START. Check 32 bit
+      }
+      // Here, mid is equal to start or a position between start and end.
+    }
+    size_t index = mid;
+    void *addr = linkerutils::GetDefTableAddress(mplInfo, table, index, true);
+    size_t startAddr = reinterpret_cast<size_t>(addr);
+    size_t endAddr = reinterpret_cast<size_t>(addr) + static_cast<size_t>(infTable[index].size) - 1;
+    if (endAddr < value) { // Less than value
+      start = mid + 1;
+      while (AddrInScope(reinterpret_cast<size_t>(linkerutils::GetDefTableAddress(mplInfo, table, start, true)),
+          scopeStartAddr, scopeEndAddr, indexTable[mid].index, skipInvalidBitsNum) && (start < end)) {
+        ++start; // Skip invalid address towards END. Check 32 bit
+      }
+    } else if (startAddr > value) { // Greater than value
+      end = mid - 1;
+      while (AddrInScope(reinterpret_cast<size_t>(linkerutils::GetDefTableAddress(mplInfo, table, end, true)),
+          scopeStartAddr, scopeEndAddr, indexTable[mid].index, skipInvalidBitsNum) && (end > start)) {
+        --end; // Skip invalid address towards START. Check 32 bit
+      }
+    } else {
+      return static_cast<int64_t>(index); // Resolved
+    }
+  }
+  return -1; // Not resolved
+}
+
+// Look up for each maple file.
+template<typename Type, typename F>
+bool LinkerInvoker::ForEachLookUp(const MUID &muid, Type obj, F lookup, LinkerMFileInfo &mplInfo,
+#ifdef LINKER_RT_CACHE
+    LinkerMFileInfo **resInfo, size_t &index,
+#endif // LINKER_RT_CACHE
+    LinkerOffsetType &pAddr) {
+  // Find LinkerMFileInfo list by class loader.
+  auto handle = [&](LinkerMFileInfo &item)->bool {
+    LinkerVoidType addr = 0;
+    size_t tmp = 0;
+    addr = (obj->*lookup)(item, muid, tmp);
+    if (addr != 0) {
+      *reinterpret_cast<LinkerVoidType*>(&pAddr) = addr;
+#ifdef LINKER_RT_CACHE
+      *resInfo = &item;
+      index = tmp;
+#endif // LINKER_RT_CACHE
+      return true;
+    }
+    return false;
+  };
+  ClassLoaderListT &classLoaderList = mplInfo.clList;
+  // Look up the address.
+  for (auto iter = classLoaderList.rbegin(); iter != classLoaderList.rend(); ++iter) {
+    MObject *classLoader = reinterpret_cast<MObject*>(*iter);
+#ifdef LINKER_RT_CACHE
+    // Ignore the LinkerMFileInfos not from system(Boot class loader) for lazy binding with half option.
+    if (mplInfo.IsFlag(kIsLazy) && !IsBootClassLoader(classLoader) && classLoader != nullptr &&
+        !IsSystemClassLoader(classLoader)) { // Not system
+      continue;
+    }
+#endif // LINKER_RT_CACHE
+    if (mplInfoListCLMap.FindIf(classLoader, handle)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+template<typename TableItem>
+bool LinkerInvoker::ResolveSymbolLazily(LinkerMFileInfo &mplInfo, bool isSuper, const AddrSlice &dstSlice,
+    size_t index, bool fromUpper, bool fromUndef, TableItem &tableItem, size_t tableIndex, const void *addr) {
+  size_t muidSize = fromUndef ?
+      (isSuper ? (mplInfo.GetTblSize(kDataUndefMuid)) : (mplInfo.GetTblSize(kMethodUndefMuid))) :
+      (isSuper ? (mplInfo.GetTblSize(kDataDefMuid)) : (mplInfo.GetTblSize(kMethodDefMuid)));
+  MuidSlice muidSlice = fromUndef ?
+      (isSuper ? (MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataUndefMuid), muidSize)) :
+      (MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodUndefMuid), muidSize))) :
+      (isSuper ? (MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataDefMuid), muidSize)) :
+      (MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodDefMuid), muidSize)));
+  if (isSuper) {
+    addr = Get<LazyBinding>()->ResolveClassSymbol(mplInfo, dstSlice, muidSlice, index, nullptr, fromUpper, !fromUndef);
+  } else {
+    addr = Get<LazyBinding>()->ResolveMethodSymbol(mplInfo, dstSlice, muidSlice, index, !fromUndef);
+  }
+  if (addr != nullptr) {
+    __atomic_store_n(&tableItem.index, reinterpret_cast<size_t>(addr), __ATOMIC_RELEASE);
+    return false;
+  } else {
+    LINKER_LOG(ERROR) << "not resolved lazily, " << fromUndef << ", " << index << ", " << " in " <<
+        mplInfo.name << maple::endl;
+    return isSuper ? true : ((tableIndex != 0) ?  true : false);
+  }
+}
+
+template<SectTabIndex UndefName, SectTabIndex DefName, typename TableItem, bool isSuper>
+bool LinkerInvoker::ResolveSymbolByClass(LinkerMFileInfo &mplInfo,
+    TableItem &tableItem, size_t index, size_t tableIndex, bool fromUndef) {
+  bool fromUpper = false;
+  void *addr = nullptr;
+  AddrSlice dstSlice;
+  bool ret = false;
+  size_t undefSize = mplInfo.GetTblSize(UndefName);
+  AddrSlice undefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(UndefName), undefSize);
+  size_t defSize = mplInfo.GetTblSize(DefName);
+  AddrSlice defSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(DefName), defSize);
+  if (fromUndef && index < undefSize && !undefSlice.Empty()) {
+    if (mplInfo.IsFlag(kIsLazy) && GetAddrBindingState(undefSlice, index) != kBindingStateResolved) {
+      dstSlice = undefSlice;
+      ret = ResolveSymbolLazily<TableItem>(
+          mplInfo, isSuper, dstSlice, index, fromUpper, fromUndef, tableItem, tableIndex, addr);
+    } else {
+      __atomic_store_n(&tableItem.index, reinterpret_cast<size_t>(undefSlice[index].Address()), __ATOMIC_RELEASE);
+    }
+  } else if (!fromUndef && index < defSize && !defSlice.Empty()) {
+    if (mplInfo.IsFlag(kIsLazy)) {
+      dstSlice = defSlice;
+      ret = ResolveSymbolLazily<TableItem>(
+          mplInfo, isSuper, dstSlice, index, fromUpper, fromUndef, tableItem, tableIndex, addr);
+    } else {
+      __atomic_store_n(&tableItem.index, reinterpret_cast<size_t>(isSuper ? linkerutils::GetDefTableAddress(
+          mplInfo, defSlice, index, false) : defSlice[index].Address()), __ATOMIC_RELEASE);
+    }
+  } else {
+    return isSuper ? true : ((tableIndex != 0) ?  true : false);
+  }
+  return ret;
+}
+} // namespace maplert
+#endif // MAPLE_RUNTIME_MPL_LINKER_INLINE_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker_lazy_binding.h b/src/mrt/compiler-rt/include/linker/linker_lazy_binding.h
new file mode 100644
index 0000000000000000000000000000000000000000..93ba6c86c6721d87b9f244b06dced0c78ea383dd
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_lazy_binding.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_LINKER_LAZY_H_
+#define MAPLE_RUNTIME_MPL_LINKER_LAZY_H_
+
+#include "linker_method_builder.h"
+
+#ifdef __cplusplus
+namespace maplert {
+class LazyBinding : public FeatureModel {
+ public:
+  static FeatureName featureName;
+  LazyBinding(LinkerInvoker &invoker, MethodBuilder &build) : pInvoker(&invoker), pMethodBuilder(&build) {};
+  ~LazyBinding() {
+    pInvoker = nullptr;
+    pMethodBuilder = nullptr;
+  }
+  void *SetClassInDefAddrTable(size_t index, const MClass *klass);
+  inline void *SetAddrInAddrTable(AddrSlice &addrSlice, size_t index, const MClass *addr);
+  BindingState GetAddrBindingState(LinkerVoidType addr);
+  BindingState GetAddrBindingState(const AddrSlice &addrSlice, size_t index, bool isAtomic = true);
+  BindingState GetAddrBindingState(const LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const void *offset);
+  void LinkClass(MClass *klass);
+  MClass *LinkDataUndefSuperClassAndInterfaces(LinkerMFileInfo &mplInfo, MObject *candidateClassLoader, size_t index,
+      AddrSlice dataUndefSlice, MClass *superClassesItem, IndexSlice superTableSlice, uint32_t i, bool fromUndef);
+  MClass *LinkDataDefSuperClassAndInterfaces(LinkerMFileInfo &mplInfo, size_t index, AddrSlice dataDefSlice,
+      MClass *superClassesItem, IndexSlice superTableSlice, uint32_t i, bool fromUndef);
+  void LinkSuperClassAndInterfaces(
+      const MClass *klass, MObject *candidateClassLoader, bool recursive = true, bool forCold = false);
+
+  void GetAddrAndMuidSlice(LinkerMFileInfo &mplInfo,
+      BindingState state, AddrSlice &addrSlice, MuidSlice &muidSlice, const void *offset);
+  void *ResolveClassSymbolClassification(
+      LinkerMFileInfo &mplInfo, BindingState state, const AddrSlice &addrSlice, const MuidSlice &muidSlice,
+      const size_t &index, MObject *candidateClassLoader, bool &fromUpper, const void *pc, const void *offset);
+  bool HandleSymbol(const void *offset, const void *pc, BindingState state, bool fromSignal);
+  bool HandleSymbolForDecoupling(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, size_t index);
+  bool HandleSymbol(
+      LinkerMFileInfo &mplInfo, const void *offset, const void *pc, BindingState state, bool fromSignal);
+
+  size_t GetAddrIndex(const LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const void *offset);
+  void *SearchInUndef(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const MuidSlice &muidSlice,
+      size_t index, MObject *candidateClassLoader, bool &fromUpper, bool isDef, std::string className);
+  void *ResolveClassSymbolForAPK(LinkerMFileInfo &mplInfo, size_t index, bool &fromUpper, bool isDef);
+  void *ResolveClassSymbol(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const MuidSlice &muidSlice,
+      size_t index, MObject *candidateClassLoader, bool &fromUpper, bool isDef, bool clinit = false);
+  void *ResolveClassSymbolInternal(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const MuidSlice &muidSlice,
+      size_t index, MObject *classLoader, bool &fromUpper, bool isDef, const std::string &className);
+  void *ResolveDataSymbol(const AddrSlice &addrSlice, const MuidSlice &muidSlice, size_t index, bool isDef);
+  void *ResolveDataSymbol(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice,
+      const MuidSlice &muidSlice, size_t index, bool isDef);
+  void *ResolveMethodSymbol(const AddrSlice &addrSlice, const MuidSlice &muidSlice, size_t index, bool isDef);
+  void *ResolveMethodSymbol(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const MuidSlice &muidSlice,
+      size_t index, bool isDef, bool forClass = false);
+  MClass *GetUnresolvedClass(MClass *klass, bool &fromUpper, bool isDef);
+  void ResolveMethodsClassSymbol(const LinkerMFileInfo &mplInfo, bool isDef, const void *addr);
+  void LinkStaticSymbol(LinkerMFileInfo &mplInfo, const MClass *target);
+  void LinkStaticMethod(LinkerMFileInfo &mplInfo, const MClass *target);
+  void LinkStaticField(LinkerMFileInfo &mplInfo, const MClass *target);
+  void LinkStaticMethodSlow(MethodMeta &meta, std::string name, LinkerMFileInfo &mplInfo,
+      LinkerMFileInfo &oldLinkerMFileInfo, AddrSlice &srcTable, AddrSlice &dstTable);
+  void LinkStaticMethodFast(MethodMeta &meta, const std::string name, size_t index, LinkerMFileInfo &mplInfo,
+      const LinkerMFileInfo &oldLinkerMFileInfo, AddrSlice &srcTable, AddrSlice &dstTable);
+  void LinkStaticFieldSlow(FieldMeta &meta, std::string name, LinkerMFileInfo &mplInfo,
+      LinkerMFileInfo &oldLinkerMFileInfo, AddrSlice &srcTable, AddrSlice &dstTable);
+  void LinkStaticFieldFast(FieldMeta &meta, const std::string name, size_t index, LinkerMFileInfo &mplInfo,
+      const LinkerMFileInfo &oldLinkerMFileInfo, AddrSlice &srcTable, AddrSlice &dstTable);
+  void LinkClassInternal(MClass *klass, MObject *candidateClassLoader);
+  void LinkClassInternal(LinkerMFileInfo &mplInfo, MClass *klass, MObject *candidateClassLoader, bool first = true);
+  void LinkSuperClassAndInterfaces(LinkerMFileInfo &mplInfo, const MClass *klass, MObject *candidateClassLoader,
+      bool recursive = true, bool forCold = false);
+  void LinkMethods(LinkerMFileInfo &mplInfo, MClass *klass, bool first, MetaRef index);
+  inline void LinkFields(const LinkerMFileInfo &mplInfo, MClass *klass);
+  void *GetClassMetadata(LinkerMFileInfo &mplInfo, size_t classIndex);
+  void *LookUpDataSymbolAddressLazily(const MObject *classLoader, const MUID &muid,
+      LinkerMFileInfo **outLinkerMFileInfo = nullptr, bool ignoreClassLoader = false);
+  void *LookUpMethodSymbolAddressLazily(const MObject *classLoader, const MUID &muid, bool ignoreClassLoader = false);
+  inline std::string ResolveClassMethod(MClass *klass);
+
+  void PreLinkLazyMethod(LinkerMFileInfo &mplInfo);
+#if defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+  bool LoadLazyCache(LinkerMFileInfo &mplInfo, std::string &cachingIndex);
+  bool LoadLazyCacheInternal(
+      LinkerMFileInfo &mplInfo, std::string &path, std::string &cachingIndex,
+      char *buf, std::streamsize &index, std::streamsize &byteCount);
+  bool SaveLazyCache(LinkerMFileInfo &mplInfo, const std::string &cachingIndex);
+  bool SaveLazyCacheInternal(std::string &path, int &fd, std::vector<char> &bufVector);
+#endif // defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+ private:
+  LinkerInvoker *pInvoker = nullptr;
+  MethodBuilder *pMethodBuilder = nullptr;
+};
+extern "C" {
+#endif // __cplusplus
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif // __cplusplus
+#endif // MAPLE_RUNTIME_MPL_LINKER_LAZY_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker_method_builder.h b/src/mrt/compiler-rt/include/linker/linker_method_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..e78e14c06ef71b2f9396d3abfaebb47a6052a672
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_method_builder.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_LINKER_METHOD_H_
+#define MAPLE_RUNTIME_MPL_LINKER_METHOD_H_
+
+#include "linker_model.h"
+#include "methodmeta.h"
+
+namespace maplert {
+constexpr uint16_t kAdjacencyInvalidValue = static_cast<uint16_t>(-1);
+
+struct MethodItem {
+  LinkerVoidType methodMeta; // MethodMetaBase*
+  uint32_t hash;
+#ifdef LINKER_RT_LAZY_CACHE
+  std::vector<uint16_t> depth;
+  uint16_t index;
+#endif // LINKER_RT_LAZY_CACHE
+  bool isInterface;
+
+ public:
+  void SetMethod(const MethodMetaBase &method) {
+    methodMeta = static_cast<LinkerVoidType>(reinterpret_cast<uintptr_t>(&method));
+  }
+
+  MethodMetaBase *GetMethod() const {
+    return reinterpret_cast<MethodMetaBase*>(static_cast<uintptr_t>(methodMeta));
+  }
+};
+
+struct AdjItem {
+  uint16_t first;
+  uint16_t next;
+  LinkerVoidType methodMeta; // MethodMetaBase*
+
+ public:
+  AdjItem(uint16_t firstVal, uint16_t nextVal, uint16_t methodVal)
+      : first(firstVal), next(nextVal), methodMeta(methodVal) {};
+  AdjItem() : first(kAdjacencyInvalidValue), next(kAdjacencyInvalidValue), methodMeta(0) {};
+
+  void SetMethod(const MethodMetaBase &method) {
+    methodMeta = static_cast<LinkerVoidType>(reinterpret_cast<uintptr_t>(&method));
+  }
+
+  MethodMetaBase *GetMethod() const {
+    return reinterpret_cast<MethodMetaBase*>(static_cast<uintptr_t>(methodMeta));
+  }
+};
+
+// Map from class object to its vtab index mapping.
+using MplLazyBindingVTableMapT = std::vector<AdjItem>;
+class MethodBuilder : public FeatureModel {
+ public:
+  static FeatureName featureName;
+  explicit MethodBuilder(LinkerInvoker &invoker) : pInvoker(&invoker) {};
+  ~MethodBuilder() {
+    pInvoker = nullptr;
+  }
+  int32_t UpdateOffsetTableByVTable(
+      const MClass *klass, MplLazyBindingVTableMapT &adjMethods,
+      LinkerVTableOffsetItem &vtableOffsetItem, LinkerOffsetValItem &offsetTableItem);
+  int32_t UpdateOffsetTableByVTable(
+      const MClass *klass, MplLazyBindingVTableMapT &adjMethods,
+      LinkerVTableOffsetItem &vtableOffsetItem, LinkerOffsetValItemLazyLoad &offsetTableItem);
+#ifdef LINKER_RT_LAZY_CACHE
+  void BuildMethodByCachingIndex(MClass *klass, const std::string &cachingIndex);
+#endif // LINKER_RT_LAZY_CACHE
+  std::string BuildMethod(MClass *klass);
+  MplLazyBindingVTableMapT GetMethodVTableMap(MClass *klass);
+
+ private:
+  unsigned int GetHashIndex(const char *name);
+  inline uint16_t GetMethodMetaHash(const MethodMetaBase &method);
+  std::string GetMethodFullName(const MethodMetaBase &method);
+  inline std::string GetMethodSignature(const MethodMetaBase &method) const;
+  bool EqualMethod(const MethodMetaBase &method1, const MethodMetaBase &method2);
+  bool EqualMethod(const MethodMetaBase *method, const char *methodName, const char *methodSignature);
+  bool CanAccess(const MethodMetaBase &baseMethod, const MethodMetaBase &currentMethod);
+  bool CheckMethodMeta(const MClass *klass, std::vector<std::pair<MethodMetaBase*, uint16_t>> &methods);
+  bool CheckMethodMetaNoSort(const MClass *klass, std::vector<std::pair<MethodMetaBase*, uint16_t>> &methods);
+  void OverrideVTabMethod(std::vector<MethodItem> &virtualMethods, uint16_t vtabIndex,
+      const MethodMetaBase &method, const std::vector<uint16_t> &depth, uint16_t index, bool isInterface);
+  void AppendVTabMethod(std::vector<MethodItem> &virtualMethods, int16_t vtabIndex, const MethodMetaBase &method,
+      const std::vector<uint16_t> &depth, uint16_t index, bool isInterface, uint16_t hash);
+  void CollectClassMethodsFast(const MClass *klass, const std::vector<uint16_t> &depth,
+      std::vector<MethodItem> &virtualMethods, const std::vector<std::pair<MethodMetaBase*, uint16_t>> &methods);
+  void CollectClassMethodsSlow(const MClass *klass, const std::vector<uint16_t> &depth,
+      std::vector<MethodItem> &virtualMethods, const MplLazyBindingVTableMapT &adjMethods,
+      const std::vector<std::pair<MethodMetaBase*, uint16_t>> &methods);
+  void CollectClassMethodsRecursive(MClass *klass, bool &isDecouple, std::set<MClass*> &checkedClasses,
+      std::vector<uint16_t> &depth, uint16_t superNum,
+      std::vector<MethodItem> &virtualMethods, MplLazyBindingVTableMapT &adjMethods);
+  void CollectClassMethods(const MClass *klass, const bool &isDecouple, const std::vector<uint16_t> &depth,
+      std::vector<MethodItem> &virtualMethods, MplLazyBindingVTableMapT &adjMethods);
+  void BuildAdjMethodList(std::vector<MethodItem> &virtualMethods, MplLazyBindingVTableMapT &adjMethods);
+  void GenerateAndAttachClassVTable(MClass *klass, std::vector<MethodItem> &virtualMethods);
+  uint32_t ProcessITableFirstTable(std::vector<MethodItem> &virtualMethods,
+      std::vector<MethodMetaBase*> &firstITabVector, std::vector<MethodMetaBase*> &firstITabConflictVector,
+      uint32_t &maxFirstITabIndex);
+  size_t ProcessITableSecondTable(std::vector<MethodMetaBase*> &firstITabConflictVector,
+      std::map<uint32_t, MethodMetaBase*> &secondITableMap, std::vector<MethodMetaBase*> &secondITabConflictVector);
+  inline void GenerateITableFirstTable(LinkerVoidType &itab, const std::vector<MethodMetaBase*> &firstITabVector,
+      const std::vector<MethodMetaBase*> &firstITabConflictVector, uint32_t maxFirstITabIndex) const;
+  void GenerateITableSecondTable(LinkerVoidType &itab, std::map<uint32_t, MethodMetaBase*> &secondITableMap,
+      std::vector<MethodMetaBase*> &secondITabConflictVector, size_t sizeOfITabNoNames);
+  void GenerateAndAttachClassITable(MClass *klass, std::vector<MethodItem> &virtualMethods);
+  inline void BuildMethodVTableITable(MClass *klass, std::vector<MethodItem> &virtualMethods);
+  inline bool IsValidMethod(const MethodMetaBase &method) const;
+  int32_t GetVTableItemIndex(
+      const MClass *klass, MplLazyBindingVTableMapT &adjMethods, const char *methodName, const char *methodSignature);
+#ifdef LINKER_RT_LAZY_CACHE
+  MethodMetaBase *GetMethodByIndex(MClass *klass, uint16_t index);
+  std::string GetMethodCachingIndexString(MClass *klass, std::vector<MethodItem> &virtualMethods);
+#endif // LINKER_RT_LAZY_CACHE
+  LinkerInvoker *pInvoker = nullptr;
+};
+} // namespace maplert
+#endif // MAPLE_RUNTIME_MPL_LINKER_METHOD_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker_model.h b/src/mrt/compiler-rt/include/linker/linker_model.h
new file mode 100644
index 0000000000000000000000000000000000000000..26258d994b8a761d5858abf19df6b424712ada54
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_model.h
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MPL_LINKER_MODEL_H_
+#define MAPLE_RUNTIME_MPL_LINKER_MODEL_H_
+
+#include "linker_info.h"
+#include "linker_api.h"
+#include "loader_api.h"
+#include "mclass_inline.h"
+
+#include <typeinfo>
+#include <atomic>
+#include <array>
+namespace maplert {
+enum FeatureName {
+  kFLinker,
+#ifdef LINKER_DECOUPLE
+  kFDecouple,
+#endif
+  kFLinkerCache,
+  kFDebug,
+  kFHotfix,
+  kFLazyBinding,
+  kFMethodBuilder
+};
+class FeatureModel {
+ public:
+  FeatureModel() {}
+  virtual ~FeatureModel() {}
+  virtual std::string GetName() {
+    return "";
+  }
+};
+class LinkerInvoker : public LinkerAPI {
+ public:
+  friend class FeatureModel;
+  struct CodeRange {
+    uintptr_t start;
+    uintptr_t end;
+    LinkerMFileInfo *mplInfo;
+  };
+  struct UpdateNode {
+    MUID symbolId;
+    MClass *klass;
+    uintptr_t oldAddr;
+    uintptr_t newAddr;
+    UpdateNode(MClass *cls, const MUID id, uintptr_t oldA, uintptr_t newA) {
+      klass = cls;
+      symbolId = id;
+      oldAddr = oldA;
+      newAddr = newA;
+    }
+  };
+  struct LinkerMFileCache {
+    MClass *clsArray[4] = { nullptr }; // CacheSize is 4
+    LinkerMFileInfo *mpArray[4] = { nullptr }; // CacheSize is 4
+    uint8_t idx = 0;
+  };
+  // API Interfaces Begin
+  std::string GetAppInfo() {
+    return maplert::linkerutils::GetAppInfo();
+  }
+  void SetAppInfo(const char *dataPath, int64_t versionCode) {
+    maplert::linkerutils::SetAppInfo(dataPath, versionCode);
+  }
+  AppLoadState GetAppLoadState() {
+    return maplert::linkerutils::GetAppLoadState();
+  }
+  std::string GetAppPackageName() {
+    return maplert::linkerutils::GetAppPackageName();
+  }
+  void *GetSymbolAddr(void *handle, const char *symbol, bool isFunction) {
+    return maplert::linkerutils::GetSymbolAddr(handle, symbol, isFunction);
+  }
+  void GetMplVersion(const LinkerMFileInfo &mplInfo, MapleVersionT &item) {
+    return maplert::linkerutils::GetMplVersion(mplInfo, item);
+  }
+  void GetMplCompilerStatus(const LinkerMFileInfo &mplInfo, uint32_t &status) {
+    return maplert::linkerutils::GetMplCompilerStatus(mplInfo, status);
+  }
+  std::string GetMethodSymbolByOffset(const LinkerInfTableItem &pTable) {
+    return maplert::linkerutils::GetMethodSymbolByOffset(pTable);
+  }
+  bool IsJavaText(const void *addr) {
+    return GetLinkerMFileInfo(kFromPC, addr) != nullptr;
+  }
+  LinkerMFileInfo *GetLinkerMFileInfoByName(const std::string &name) {
+    return GetLinkerMFileInfo(kFromName, name.c_str());
+  }
+  LinkerMFileInfo *GetLinkerMFileInfoByAddress(const void *addr, bool isLazyBinding) {
+    return GetLinkerMFileInfo(kFromAddr, addr, isLazyBinding);
+  }
+  std::string GetMFileNameByPC(const void *pc, bool isLazyBinding) {
+    return GetMFileName(kFromPC, pc, isLazyBinding);
+  }
+  std::string GetMFileNameByClassMetadata(const void *addr, bool isLazyBinding) {
+    return GetMFileName(kFromMeta, addr, isLazyBinding);
+  }
+  LinkerMFileInfo *GetLinkerMFileInfoByClassMetadata(const void *addr, bool isClass) {
+    bool isLazyBinding = false;
+    if (isClass) {
+      isLazyBinding = (reinterpret_cast<const MClass*>(addr))->IsLazyBinding();
+    }
+    return GetLinkerMFileInfo(kFromMeta, addr, isLazyBinding);
+  }
+  LinkerInvoker();
+  virtual ~LinkerInvoker();
+  virtual void PreInit();
+  virtual void PostInit();
+  virtual void UnInit();
+#ifdef LINKER_RT_CACHE
+  void SetCachePath(const char *path);
+  bool GetCachePath(LinkerMFileInfo &mplInfo, std::string &path, LinkerCacheType cacheType);
+#endif
+  bool IsFrontPatchMode(const std::string &path);
+  bool LinkClassLazily(jclass klass);
+  bool ReGenGctib4Class(jclass classInfo);
+  uint64_t DumpMetadataSectionSize(std::ostream &os, void *handle, const std::string sectionName);
+  void DumpAllMplSectionInfo(std::ostream &os);
+  void DumpAllMplFuncProfile(std::unordered_map<std::string, std::vector<FuncProfInfo>> &funcProfileRaw);
+  void DumpAllMplFuncIRProfile(std::unordered_map<std::string, MFileIRProfInfo> &funcProfileRaw);
+  void DumpBBProfileInfo(std::ostream &os);
+  void ClearAllMplFuncProfile();
+  void ReleaseBootPhaseMemory(bool isZygote, bool isSystemServer);
+  bool CheckLinkerMFileInfoElfBase(LinkerMFileInfo &mplInfo);
+  void ClearLinkerMFileInfo();
+  bool ContainLinkerMFileInfo(const std::string &name);
+  bool ContainLinkerMFileInfo(const void *handle);
+  bool GetJavaTextInfo(const void *addr, LinkerMFileInfo **mplInfo, LinkerLocInfo &info, bool getName);
+  bool UpdateMethodSymbolAddress(jmethodID method, uintptr_t addr);
+  jclass GetSuperClass(ClassMetadata **addr);
+  void GetStrTab(jclass dCl, StrTab &strTab);
+  char *GetCString(jclass dCl, uint32_t index);
+  void DestroyMFileCache();
+  bool LocateAddress(const void *addr, LinkerLocInfo &info, bool getName);
+  void ResolveColdClassSymbol(jclass classInfo);
+  jclass InvokeClassLoaderLoadClass(jobject classLoader, const std::string &className);
+  void *LookUpSymbolAddress(const MUID &muid);
+  MUID GetMUID(const std::string symbol, bool forSystem);
+  void CreateMplInfo(ObjFile &objFile, jobject classLoader);
+  bool Add(ObjFile &objFile, jobject classLoader);
+  bool Resolve();
+  bool Resolve(LinkerMFileInfo &mplInfo, bool decouple); // Resolve the single maple file.
+#ifdef LINKER_DECOUPLE
+  bool HandleDecouple(std::vector<LinkerMFileInfo*> &mplList);
+#endif
+  void FinishLink(jobject classLoader);
+  bool Link();
+  // Resolve the single maple file. MUST invoked Add() before.
+  bool Link(LinkerMFileInfo &mplInfo, bool decouple);
+  void SetLoadState(LoadStateType state);
+  void SetLinkerMFileInfoClassLoader(const ObjFile &objFile, jobject classLoader);
+  void SetClassLoaderParent(jobject classLoader, jobject newParent);
+  bool InsertClassesFront(ObjFile &objFile, jobject classLoader);
+  void SetPatchPath(std::string &path, int32_t mode);
+  // API Interfaces END
+#ifdef LINKER_DECOUPLE
+  bool IsClassComplete(const MClass &classInfo);
+#endif
+  BindingState GetAddrBindingState(LinkerVoidType addr);
+  BindingState GetAddrBindingState(const AddrSlice &addrSlice, size_t index, bool isAtomic = true);
+  void DumpStackInfoInLog();
+  void *GetMplOffsetValue(LinkerMFileInfo &mplInfo);
+  MUID GetValidityCode(LinkerMFileInfo &mplInfo) const;
+  MUID GetValidityCodeForDecouple(LinkerMFileInfo &mplInfo) const;
+  void *GetMethodSymbolAddress(LinkerMFileInfo &mplInfo, size_t index);
+  void *GetDataSymbolAddress(LinkerMFileInfo &mplInfo, size_t index);
+  void GetClassLoaderList(const LinkerMFileInfo &mplInfo, ClassLoaderListT &out, bool isNewList = true);
+  void ResetClassLoaderList(const MObject *classLoader);
+  MObject *GetClassLoaderByAddress(LinkerMFileInfo &mplInfo, const void *addr);
+  void GetLinkerMFileInfos(LinkerMFileInfo &mplInfo, LinkerMFileInfoListT &fileList, bool isNewList = true);
+  void *GetClassMetadataLazily(LinkerMFileInfo &mplInfo, size_t classIndex);
+  void *GetClassMetadataLazily(const void *offsetTable, size_t classIndex);
+  LinkerMFileInfo *SearchAddress(const void *pc, AddressRangeType type = kTypeWhole, bool isLazyBinding = false);
+
+  bool LocateAddress(const void *handle, const void *addr, LinkerLocInfo &info, bool getName);
+  bool LocateAddress(LinkerMFileInfo &mplInfo, const void *addr, LinkerLocInfo &info, bool getName);
+  bool DoLocateAddress(const LinkerMFileInfo &mplInfo, LinkerLocInfo &info, const void *addr,
+      const AddrSlice &pTable, const InfTableSlice &infTableSlice, int64_t pos, bool getName);
+  LinkerVoidType LookUpDataSymbolAddress(LinkerMFileInfo &mplInfo, const MUID &muid, size_t &index);
+  LinkerVoidType LookUpMethodSymbolAddress(LinkerMFileInfo &mplInfo, const MUID &muid, size_t &index);
+  void ResolveVTableSymbolByClass(LinkerMFileInfo &mplInfo, const MClass *classInfo, bool flag);
+  void ResolveITableSymbolByClass(LinkerMFileInfo &mplInfo, const MClass *classInfo);
+  void ResolveSuperClassSymbolByClass(LinkerMFileInfo &mplInfo, const MClass *classInfo);
+  bool UpdateMethodSymbolAddressDef(const MClass *klass, const MUID &symbolId, const uintptr_t newAddr);
+  bool UpdateMethodSymbolAddressUndef(LinkerMFileInfo &mplInfo, const UpdateNode &node);
+  bool UpdateMethodSymbolAddressDecouple(LinkerMFileInfo &mplInfo, const UpdateNode &node);
+  LinkerMFileInfo *GetLinkerMFileInfo(MFileInfoSource source, const void *key, bool isLazyBinding = false);
+  std::string GetMFileName(MFileInfoSource source, const void *key, bool isLazyBinding = false);
+  void InitArrayCache(uintptr_t pc, uintptr_t addr);
+  template<typename Type, typename F>
+  bool ForEachDoAction(Type obj, F action);
+  template<typename Type, typename F, typename Data>
+  bool ForEachDoAction(Type obj, F action, const Data &data);
+  template<typename Type, typename F>
+  bool DoAction(Type obj, F action, LinkerMFileInfo &mplInfo);
+  template<typename Type, typename F>
+  bool ForEachLookUp(const MUID &muid, Type obj, F lookup, LinkerMFileInfo &mplInfo,
+#ifdef LINKER_RT_CACHE
+                     LinkerMFileInfo **resInfo, size_t &index,
+#endif // LINKER_RT_CACHE
+                     LinkerOffsetType &pAddr);
+  template<typename T1, typename T2, typename T3>
+  int64_t BinarySearchIndex(const LinkerMFileInfo &mplInfo, const T1 &pTable, size_t start,
+      size_t end, const size_t value, const T2 &pIndexTable, T3 &pInfTable, size_t scopeStartAddr,
+      size_t scopeEndAddr);
+  template<typename TableItem>
+  bool ResolveSymbolLazily(LinkerMFileInfo &mplInfo, bool isSuper, const AddrSlice &dstSlice, size_t index,
+      bool fromUpper, bool fromUndef, TableItem &tableItem, size_t tableIndex, const void *addr);
+  template<SectTabIndex UndefName, SectTabIndex DefName, typename TableItem, bool isSuper>
+  bool ResolveSymbolByClass(LinkerMFileInfo &mplInfo, TableItem &tableItem, size_t index, size_t tableIndex,
+      bool fromUndef);
+  template<class T>
+  T *Get() {
+    return reinterpret_cast<T*>(features[T::featureName]);
+  }
+  inline const LoaderAPI *GetLoader() const {
+    return pLoader;
+  }
+  inline bool IsSystemClassLoader(const MObject *classLoader) {
+    return pLoader->GetSystemClassLoader() == reinterpret_cast<jclass>(const_cast<MObject*>(classLoader));
+  }
+  inline bool IsBootClassLoader(const MObject *classLoader) {
+    return pLoader->IsBootClassLoader(reinterpret_cast<jclass>(const_cast<MObject*>(classLoader)));
+  }
+  // Reset class loader hierarchy list
+  inline void ResetMplInfoClList(LinkerMFileInfo &mplInfo) {
+    mplInfo.clList.clear();
+  }
+  inline int32_t GetMultiSoPendingCount() const {
+    return multiSoPendingCount;
+  }
+  inline void AddMultiSoPendingCount() {
+    ++multiSoPendingCount;
+  }
+  inline void SubMultiSoPendingCount() {
+    --multiSoPendingCount;
+  }
+  inline uint32_t AddrToUint32(const void *addr) {
+    if (addr == nullptr) {
+      LINKER_LOG(FATAL) << "AddrToUint32: addr is nullptr!" << maple::endl;
+    }
+    return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(addr));
+  }
+  LinkerMFileInfoListT mplInfoList;
+  LinkerMFileInfoListCLMapT mplInfoListCLMap;
+  LinkerMFileInfoNameMapT mplInfoNameMap;
+  LinkerMFileInfoHandleMapT mplInfoHandleMap;
+  LinkerMFileInfoElfAddrSetT mplInfoElfAddrSet;
+  // Compare the lazy binding ELF file only.
+  LinkerMFileInfoElfAddrSetT mplInfoElfAddrLazyBindingSet;
+  MplClassLoaderLoadClassMethodMapT mplClassLoaderLoadClassMethodMap;
+ protected:
+  std::mutex mLinkLock;
+  const uint32_t kItabHashSize = 23;
+  LoaderAPI *pLoader = nullptr;
+  std::map<FeatureName, FeatureModel*> features;
+  int32_t multiSoPendingCount = 0;
+  static constexpr size_t kLeastReleaseMemoryByteSize = 100 * 1024; // 100KiB (1KiB is 1024B)
+};
+} // namespace maplert
+#endif // MAPLE_RUNTIME_MPL_LINKER_MODEL_H_
diff --git a/src/mrt/compiler-rt/include/linker/linker_utils.h b/src/mrt/compiler-rt/include/linker/linker_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..0bc353a689d0a966422a4ef7617b72be98a8d91d
--- /dev/null
+++ b/src/mrt/compiler-rt/include/linker/linker_utils.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_LINKER_UTILS_H_
+#define MAPLE_LINKER_UTILS_H_
+
+#include <link.h>
+#include <stddef.h>
+#include <linux/limits.h>
+
+#include <string.h>
+#include <iostream>
+#include <string>
+
+#include "linker_common.h"
+
+namespace maplert {
+namespace linkerutils {
+void ReleaseMemory(void *start, void *end);
+
+void *GetSymbolAddr(void *handle, const char *symbol, bool isFunction);
+
+int32_t GetMaxVersion();
+int32_t GetMinVersion();
+void GetMplVersion(const LinkerMFileInfo &mplInfo, MapleVersionT &item);
+void GetMplCompilerStatus(const LinkerMFileInfo &mplInfo, uint32_t &status);
+std::string GetAppPackageName();
+const std::string &GetAppInfo();
+void ClearAppInfo();
+void SetAppInfo(const char *dataPath, int64_t versionCode);
+const LoadStateType &GetLoadState();
+void SetLoadState(const LoadStateType state);
+const AppLoadState &GetAppLoadState();
+void SetAppLoadState(const AppLoadState state);
+const std::string &GetAppBaseStr();
+void SetAppBaseStr(const std::string &str);
+
+bool NeedRelocateSymbol(const std::string &name);
+void *GetDefTableAddress(const LinkerMFileInfo &mplInfo, const AddrSlice &pTable, size_t index, bool forMethod);
+std::string GetMethodSymbolByOffset(const LinkerInfTableItem &pTable);
+const char *GetMuidDefFuncTableFuncname(const LinkerInfTableItem &pTable);
+std::string GetMuidDefFuncTableSigname(const LinkerInfTableItem &pTable);
+const char *GetMuidDefFuncTableClassname(const LinkerInfTableItem &pTable);
+// Return N microseconds.
+// isEnd: false starts counting, true ends counting.
+inline long CountTimeConsuming(bool isEnd) {
+  static struct timespec timeSpec[2]; // 2 means startTimeSpec and endTimeSpec
+
+  if (!isEnd) {
+    clock_gettime(CLOCK_MONOTONIC, &timeSpec[0]);
+    return 0;
+  } else {
+    clock_gettime(CLOCK_MONOTONIC, &timeSpec[1]);
+    // 1000000 means MILLION, sec to microsec, 1000 means THOUAND, nsec to micromsec
+    return (timeSpec[1].tv_sec - timeSpec[0].tv_sec) * 1000000LL + (timeSpec[1].tv_nsec - timeSpec[0].tv_nsec) / 1000LL;
+  }
+}
+
+inline void DumpMUID(const MUID &muid) {
+  for (unsigned int i = 0; i < kMuidLength; ++i) {
+    fprintf(stderr, "\t%02x", muid.data.bytes[i]);
+  }
+}
+
+inline void GenerateMUID(const void *data, unsigned long size, MUID &muid) {
+  auto *srcStr = reinterpret_cast<const unsigned char*>(data);
+  GetMUIDHash(*srcStr, size, muid);
+}
+inline void GenerateMUID(const char *const str, MUID &muid) {
+  GenerateMUID(str, strlen(str), muid);
+}
+
+#ifdef LINKER_RT_CACHE
+const std::string &GetLinkerCacheTypeStr(LinkerCacheType index);
+bool FileExists(const char *name);
+bool FolderExists(const char *name);
+bool PrepareFolder(const std::string &dir);
+bool GetInstallCachePath(LinkerMFileInfo &mplInfo, std::string &path, LinkerCacheType cacheType);
+#endif
+}
+}
+#endif // MAPLE_LINKER_UTILS_H_
diff --git a/src/mrt/compiler-rt/include/loader/hash_pool.h b/src/mrt/compiler-rt/include/loader/hash_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e204c51018fb09f29978b755a51f092f024175a
--- /dev/null
+++ b/src/mrt/compiler-rt/include/loader/hash_pool.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_LOADER_HASH_POOL__
+#define __MAPLE_LOADER_HASH_POOL__
+
+#include <vector>
+
+#include "gc_roots.h"
+#include "mrt_object.h"
+#include "mrt_reflection_class.h"
+#include "allocator/page_allocator.h"
+#include "mclass_inline.h"
+#include <bitset>
+namespace maplert {
+#ifndef __ANDROID__
+using ClassPtr = uintptr_t;
+#else
+using ClassPtr = uint32_t;
+#endif
+
+#if defined(__arm__)
+using BucketType = uint32_t;
+#else
+using BucketType = uint64_t;
+#endif
+struct ConflictClass {
+  std::vector<ClassPtr> conflictData;
+};
+template<class Key>
+using HashPoolVector = std::vector<Key, StdContainerAllocator<Key, kClassLoaderAllocator>>;
+using NameCompare = std::function<bool(const ClassPtr data, const std::string &name)>;
+enum MClassFlag {
+  kIsConflict = 1ul, // low 1 bit as conflict flag
+  kIsDexClassOffset = 2ul, // low 2 bit as dexClassDef flag
+};
+
+class MClassHashPool {
+ public:
+  MClassHashPool();
+  ~MClassHashPool();
+
+  void Create(uint32_t bucketCount);
+  void Destroy();
+  size_t CalcMemoryCost() const;
+  double GetHashConflictRate() const;
+  double GetClassConflictRate() const;
+  void InitClass(uint32_t hashIndex);
+  void Collect();
+  void Set(uint32_t hashIndex, ClassPtr classInfo);
+  void VisitClasses(const maple::rootObjectFunc &func);
+  MClass *Get(const std::string &name) const;
+  ClassPtr Get(const std::string &name, NameCompare cmp) const;
+  inline void Set(const std::string &name, ClassPtr classInfo) {
+    uint32_t hashIndex = GetHashIndex32(name);
+    Set(hashIndex, classInfo);
+  }
+  inline void Set(uint32_t hashIndex, const MClass &klass) {
+    Set(hashIndex, static_cast<ClassPtr>(reinterpret_cast<uintptr_t>(&klass)));
+  }
+  inline uint16_t GetHashIndex16(const std::string &name) const {
+    // 211 is a proper prime, which can reduce the conflict rate.
+    return static_cast<uint16_t>(0xFFFF & BKDRHash(name, 211));
+  }
+  inline uint32_t GetHashIndex32(const std::string &name) const {
+    // 211 is a proper prime, which can reduce the conflict rate.
+    return BKDRHash(name, 211);
+  }
+ protected:
+  inline uint32_t BitCount(uint32_t n) const;
+  inline uint32_t BitCount(uint64_t n) const;
+  size_t FindNextPrime(size_t nr) const;
+  inline uint32_t NextPrime(size_t n) const;
+  inline uint32_t BKDRHash(const std::string &key, uint32_t seed) const {
+    size_t len = key.length();
+    size_t idx = 0;
+    uint32_t hash = 0;
+    while (idx < len) {
+      hash = hash * seed + static_cast<uint32_t>(key[idx++]);
+    }
+    return hash;
+  }
+
+ private:
+  static constexpr uint32_t kBucketBitNum = sizeof(BucketType) << 3; // calculate the number of bits
+  static constexpr uint32_t kMaxExtended = 20;
+  static constexpr ClassPtr kMClassAddressMask = 0x3;
+  uint32_t mBucketCount = 0;
+  uint32_t mClassCount = 0;
+  uint32_t mConflictBucketCount = 0;
+  uint32_t mFillBucketCount = 0;
+  HashPoolVector<uint32_t> bitCounts;
+  HashPoolVector<BucketType> bitBuckets;
+  HashPoolVector<ClassPtr> bucketData; // 2-x : Ptr to Data, 1: DexClassOffset flag, 0: conflict Flag
+};
+} // namespace maplert
+#endif // __MAPLE_LOADER_HASH_POOL__
diff --git a/src/mrt/compiler-rt/include/loader/loader_utils.h b/src/mrt/compiler-rt/include/loader/loader_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..86a460655e09cbfd6ba273a8805d891542d0a495
--- /dev/null
+++ b/src/mrt/compiler-rt/include/loader/loader_utils.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_LOADER_UTILS__
+#define __MAPLE_LOADER_UTILS__
+
+#include <string>
+
+#include "loader_api.h"
+#include "version.h"
+#include "base/macros.h"
+
+namespace maplert {
+namespace loaderutils {
+  std::string GetNicePath(const std::string &fullPath);
+  std::string Dex2MplPath(const std::string &filePath);
+  bool CheckVersion(const ObjFile &mplFile, const maplert::LinkerMFileInfo &mplInfo);
+  bool CheckCompilerStatus(const ObjFile &mplFile, const maplert::LinkerMFileInfo &mplInfo);
+}
+} // end namespace maple
+#endif // endif __MAPLE_LOADER_UTILS__
diff --git a/src/mrt/compiler-rt/include/loader/object_loader.h b/src/mrt/compiler-rt/include/loader/object_loader.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0fda3590f9f2d6dbe9dce93d87d4368a36b143f
--- /dev/null
+++ b/src/mrt/compiler-rt/include/loader/object_loader.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_LOADER_OBJECT_LOADER__
+#define __MAPLE_LOADER_OBJECT_LOADER__
+
+#include "object_locator.h"
+#include "gc_roots.h"
+#include "loader/loader_utils.h"
+
+namespace maplert {
+enum FieldName {
+  kFieldParent = 0,
+  kFieldClassTable
+};
+
+class ObjectLoader : public LoaderAPI {
+ public:
+  ObjectLoader();
+  virtual ~ObjectLoader();
+  // API Interfaces Begin
+  virtual void PreInit(IAdapterEx interpEx) override;
+  virtual void PostInit(jobject systemClassLoader) override;
+  virtual void UnInit() override;
+  jobject GetCLParent(jobject classLoader) override;
+  void SetCLParent(jobject classLoader, jobject parentClassLoader) override;
+  bool IsBootClassLoader(jobject classLoader) override;
+  bool LoadClasses(jobject classLoader, ObjFile &objFile) override;
+  // get registered mpl file by exact path-name: the path should be canonicalized
+  size_t GetLoadedClassCount() override;
+  size_t GetAllHashMapSize() override;
+  bool IsLinked(jobject classLoader) override;
+  void SetLinked(jobject classLoader, bool isLinked) override;
+  bool GetClassNameList(jobject classLoader, ObjFile &objFile, std::vector<std::string> &classVec) override;
+  void ReTryLoadClassesFromMplFile(jobject jobject, ObjFile &mplFile) override;
+  // MRT_EXPORT Split
+  // visit class loader gc roots
+  void VisitGCRoots(const RefVisitor &visitor) override;
+  jobject GetSystemClassLoader() override;
+  jobject GetBootClassLoaderInstance() override;
+  void SetClassCL(jclass klass, jobject classLoader) override;
+  IObjectLocator GetCLClassTable(jobject classLoader) override;
+  void SetCLClassTable(jobject classLoader, IObjectLocator classLocator) override;
+  // API Interfaces End
+  MObject *GetClassCL(MClass *klass);
+  void SetCLParent(const MObject *classLoader, const MObject *parentClassLoader);
+  void RegisterDynamicClass(const MObject *classLoader, const MClass *klass);
+  void UnregisterDynamicClass(const MObject *classLoader, const MClass *klass);
+  virtual MClass *GetPrimitiveClass(const std::string &mplClassName) = 0;
+  virtual void VisitPrimitiveClass(const maple::rootObjectFunc &func) = 0;
+  virtual MClass *CreateArrayClass(const std::string &mplClassName, MClass &componentClass) = 0;
+  IAdapterEx GetAdapterEx() override {
+    return pAdapterEx;
+  }
+ protected:
+  void UnloadClasses(const MObject *classLoader);
+  uint16_t PresetClassCL(const MObject *classLoader);
+  bool LocateIndex(const MObject *classLoader, int16_t &pos) const;
+  bool RecycleIndex(const MObject *classLoader);
+  void VisitClassesByLoader(const MObject *loader, const maple::rootObjectFunc &func);
+  bool LoadClassesFromMplFile(const MObject *classLoader, ObjFile &mplFile,
+      std::vector<LinkerMFileInfo*> &infoList, bool hasSiblings = false);
+  bool LoadClasses(const MObject *classLoader, ObjFile &objFile);
+  bool LoadClasses(const MObject *classLoader, std::vector<ObjFile*> &objList);
+
+  LinkerAPI *pLinker = nullptr;
+  AdapterExAPI *pAdapterEx = nullptr;
+  static const int kMaxClassloaderNum = 256;
+  const unsigned int kClIndexValueMask = 0x00FF;
+  const unsigned int kClIndexFlagMask = 0xFF00;
+  const unsigned int kClIndexFlag = 0xAB00;
+  const unsigned int kClIndexInintValue = 0xABCD;
+  // mCLTable[] stores all class loader, except index 0.
+  // In each class loader, classTable filed will store its classlocator instance.
+  // 'Cause NULL is for Bootstrap class loader, mCLTable[0]'d point to locator directly.
+  // Index ---> Value
+  // ---
+  // [0]   -------------------------> MClassLocator_0_for_boot_class_loader
+  // [1]   --->  CLASS_LOADER_1  ===> MClassLocator_1
+  // [2]   --->  CLASS_LOADER_2  ===> MClassLocator_2
+  // ...   --->  ..............  ===> ...
+  // [255] ---> CLASS_LOADER_255 ===> MClassLocator_255
+  const MObject *mCLTable[kMaxClassloaderNum] = { 0 };
+  MObject *mBootClassLoader = nullptr;
+  MObject *mSystemClassLoader = nullptr;
+  std::vector<MClass*> primitiveClasses;
+ private:
+  jfieldID GetCLField(const FieldName &name);
+};
+} // end namespace maple
+#endif // endif __MAPLE_LOADER_OBJECT_LOADER__
diff --git a/src/mrt/compiler-rt/include/loader/object_locator.h b/src/mrt/compiler-rt/include/loader/object_locator.h
new file mode 100644
index 0000000000000000000000000000000000000000..34f2501d37b2c5df62bd1e302e91e58353940e54
--- /dev/null
+++ b/src/mrt/compiler-rt/include/loader/object_locator.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_LOADER_OBJECT_LOCATOR__
+#define __MAPLE_LOADER_OBJECT_LOCATOR__
+
+#include <set>
+#include <list>
+#include <map>
+#include <cstring>
+#include <mutex>
+
+#include "object_base.h"
+#include "hash_pool.h"
+#include "loader_api.h"
+#include "linker_api.h"
+
+namespace maplert {
+// this is for using class-name as the hash key.
+struct ObjCmpStr {
+  bool operator()(const std::string &a, const std::string &b) const {
+    return a.compare(b) < 0;
+  }
+};
+
+struct ObjFileCmp {
+  bool operator()(const ObjFile *a, const ObjFile *b) const {
+    if (a == nullptr) {
+      return false;
+    } else if (b == nullptr) {
+      return true;
+    }
+    return a->GetUniqueID() < b->GetUniqueID();
+  }
+};
+
+using ClassMapT = std::map<const std::string, MClass*, ObjCmpStr>;
+using ClassMapIterT = std::map<const std::string, MClass*, ObjCmpStr>::iterator;
+using ClassMapConstIterT = std::map<const std::string, MClass*, ObjCmpStr>::const_iterator;
+using ObjFileHashPool = std::map<ObjFile*, MClassHashPool*, ObjFileCmp>;
+// A MFileClasslocator loads class info from MFile.
+class ClassLocator {
+  friend class MClassLocatorInterpEx;
+ public:
+  ClassLocator() = default;
+  ~ClassLocator() = default;
+  // Load classes from MFiles
+  bool LoadClasses(std::vector<ObjFile*> &objList, uint16_t clindex);
+  // Load classes from one MFile
+  bool LoadClasses(ObjFile &objFile, uint16_t clindex);
+  MClass *InquireClass(const std::string &internalName, SearchFilter &filter);
+  uint32_t GetClassCount(const ObjFile &objFile);
+  void UnloadClasses();
+  void VisitClasses(const maple::rootObjectFunc &f, bool isBoot = false);
+
+  bool GetClassNameList(const ObjFile &objFile, std::vector<std::string> &classVec);
+  void UnregisterDynamicClassImpl(const ClassMapIterT &it) const;
+  // from classes loaded by this class-loader
+  bool RegisterDynamicClass(const std::string &className, MClass &classObj);
+  // MFileClassloader manage dynamic class info
+  bool UnregisterDynamicClass(const std::string &className);
+  // Unregister all dynamic classes
+  void UnregisterDynamicClasses();
+  size_t GetLoadedClassCount() {
+    maple::SpinAutoLock lock(spLock);
+    return mLoadedClassCount;
+  }
+  size_t GetClassHashMapSize();
+
+  bool IsLinked() const {
+    return mLinked;
+  }
+
+  void SetLinked(bool isLinked) {
+    mLinked = isLinked;
+  }
+ protected:
+  bool InitClasses(std::vector<ObjFile*> &objList, MClassHashPool &pool);
+  void InitClasses(const ObjFile &objFile, MClassHashPool &pool);
+  void SetClasses(std::vector<ObjFile*> &objList, MClassHashPool &pool, uint16_t clIndex);
+  void SetClasses(const ObjFile &objFile, MClassHashPool &pool, uint16_t clIndex);
+ private:
+  // Find a loaded class from mpl(all) or dex(on-demand) in the order of mhashpools.
+  MClass *FindClassInternal(const std::string &className, SearchFilter &filter);
+  // Find a loaded class from mpl(all) and dex(on-demand), or created array class in runtime.
+  MClass *FindLoadedClass(const MClassHashPool &pool, const std::string &className, SearchFilter &filter);
+  MClass *FindRuntimeClass(const std::string &mplClassName);
+  MClass *CreateArrayClassRecursively(const std::string &mplClassName, SearchFilter &filter);
+
+  maple::SpinLock spLock;
+  ObjFileHashPool mHashPools;
+  pthread_rwlock_t dClassMapLock = PTHREAD_RWLOCK_INITIALIZER;
+  ClassMapT dClassMap; // map for dynamic classInfo
+  size_t mLoadedClassCount = 0;
+  bool mLinked = false;
+};
+} // namespace maplert
+#endif // __MAPLE_LOADER_OBJECT_LOCATOR__
diff --git a/src/mrt/compiler-rt/include/metadata_inline.h b/src/mrt/compiler-rt/include/metadata_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..0bdf67a32a4ba298d499743b58fdee85baba8f65
--- /dev/null
+++ b/src/mrt/compiler-rt/include/metadata_inline.h
@@ -0,0 +1,414 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef METADATA_INLINE_H
+#define METADATA_INLINE_H
+
+#include "metadata_layout.h"
+
+template<typename T>
+inline T DataRef32::GetDataRef() const {
+  uint32_t format = refVal & kDataRefBitMask;
+  switch (format) {
+    case kDataRefIsDirect: {
+      // Note if *refVal* is a memory address, it should not be sign-extended
+      return reinterpret_cast<T>(static_cast<uintptr_t>(refVal));
+    }
+    case kDataRefIsOffset: {
+      // Note if *refVal* is an offset, it is a signed integer and should be sign-extended
+      int32_t offset = static_cast<int32_t>(refVal & ~static_cast<uint32_t>(kDataRefBitMask));
+      intptr_t addr = reinterpret_cast<intptr_t>(this) + static_cast<intptr_t>(offset);
+      return reinterpret_cast<T>(addr);
+    }
+    case kDataRefIsIndirect: {
+      // Note if *refVal* is an offset, it is a signed integer and should be sign-extended
+      int32_t offset = static_cast<int32_t>(refVal & ~static_cast<uint32_t>(kDataRefBitMask));
+      intptr_t addr = reinterpret_cast<intptr_t>(this) + static_cast<intptr_t>(offset);
+      uintptr_t *pRef = reinterpret_cast<uintptr_t*>(addr);
+      return reinterpret_cast<T>(*pRef);
+    }
+    default: {
+      std::abort();
+    }
+  }
+}
+
+template<typename T>
+inline void DataRef32::SetDataRef(T ref, DataRefFormat format) {
+  static_assert(sizeof(T) == sizeof(uintptr_t), "wrong type.");
+  switch (format) {
+    case kDataRefIsDirect: {
+      // Note if *refVal* is a memory address, it should be an unsigned integer.
+      uintptr_t val = reinterpret_cast<uintptr_t>(ref);
+      if ((val & kDataRefBitMask) == 0 && val <= UINT32_MAX) {
+        refVal = static_cast<uint32_t>(val);
+        return;
+      } else {
+        std::abort();
+      }
+    }
+    case kDataRefIsOffset: {
+      intptr_t offset = static_cast<intptr_t>(reinterpret_cast<uintptr_t>(ref)) - reinterpret_cast<intptr_t>(this);
+      if ((offset & kDataRefBitMask) == 0 && INT32_MIN <= offset && offset <= INT32_MAX) {
+        refVal = static_cast<uint32_t>(offset | kDataRefIsOffset);
+        return;
+      } else {
+        std::abort();
+      }
+    }
+    default: {
+      std::abort();
+    }
+  }
+}
+
+template<typename T>
+inline T DataRef32::GetRawValue() const {
+  return reinterpret_cast<T>(refVal);
+}
+
+template<typename T>
+inline T DataRef::GetDataRef() const {
+  intptr_t ref = static_cast<intptr_t>(refVal);
+  intptr_t format = ref & kDataRefBitMask;
+  switch (format) {
+    case kDataRefIsDirect: return reinterpret_cast<T>(refVal);
+    case kDataRefIsOffset: {
+      ref &= ~static_cast<intptr_t>(kDataRefBitMask);
+      ref += reinterpret_cast<intptr_t>(this);
+      return reinterpret_cast<T>(ref);
+    }
+    case kDataRefIsIndirect: {
+      ref &= ~static_cast<intptr_t>(kDataRefBitMask);
+      ref += reinterpret_cast<intptr_t>(this);
+      uintptr_t *pRef = reinterpret_cast<uintptr_t*>(ref);
+      return reinterpret_cast<T>(*pRef);
+    }
+    default: {
+      std::abort();
+    }
+  }
+}
+
+template<typename T>
+inline void DataRef::SetDataRef(const T ref, const DataRefFormat format) {
+  static_assert(sizeof(T) == sizeof(uintptr_t), "wrong type.");
+  uintptr_t uRef = reinterpret_cast<uintptr_t>(ref);
+  switch (format) {
+    case kDataRefIsDirect: {
+      refVal = reinterpret_cast<uintptr_t>(uRef);
+      return;
+    }
+    case kDataRefIsOffset: {
+      intptr_t offset = static_cast<intptr_t>(uRef) - reinterpret_cast<intptr_t>(this);
+      if ((offset & kDataRefBitMask) == 0) {
+        refVal = static_cast<uintptr_t>(offset | kDataRefIsOffset);
+        return;
+      } else {
+        std::abort();
+      }
+    }
+    default: {
+      std::abort();
+    }
+  }
+}
+
+template<typename T>
+inline T DataRef::GetRawValue() const {
+  return reinterpret_cast<T>(refVal);
+}
+
+template<typename T>
+inline T GctibRef32::GetGctibRef() const {
+  uint32_t format = refVal & kGctibRefBitMask;
+  switch (format) {
+    case kGctibRefIsOffset: {
+      // Note if *refVal* is an offset, it is a signed integer and should be sign-extended
+      int32_t offset = static_cast<int32_t>(refVal);
+      intptr_t addr = reinterpret_cast<intptr_t>(this) + static_cast<intptr_t>(offset);
+      return reinterpret_cast<T>(addr);
+    }
+    case kGctibRefIsIndirect: {
+      // Note if *refVal* is an offset, it is a signed integer and should be sign-extended
+      int32_t offset = static_cast<int32_t>(refVal & ~static_cast<uint32_t>(kGctibRefBitMask));
+      intptr_t addr = reinterpret_cast<intptr_t>(this) + static_cast<intptr_t>(offset);
+      uintptr_t *pRef = reinterpret_cast<uintptr_t*>(addr);
+      return reinterpret_cast<T>(*pRef);
+    }
+    default: {
+      std::abort();
+    }
+  }
+}
+
+template<typename T>
+inline void GctibRef32::SetGctibRef(T ref, GctibRefFormat format) {
+  static_assert(sizeof(T) == sizeof(uintptr_t), "wrong type.");
+  switch (format) {
+    case kGctibRefIsOffset:  {
+      intptr_t offset = reinterpret_cast<intptr_t>(ref) - reinterpret_cast<intptr_t>(this);
+      if ((offset & kGctibRefBitMask) == 0 && INT32_MIN <= offset && offset <= INT32_MAX) {
+        refVal = static_cast<uint32_t>(offset);
+        return;
+      } else {
+        std::abort();
+      }
+    }
+    default: {
+      std::abort();
+    }
+  }
+}
+
+template<typename T>
+inline T GctibRef::GetGctibRef() const {
+  intptr_t ref = static_cast<intptr_t>(refVal);
+  intptr_t format = ref & kGctibRefBitMask;
+  switch (format) {
+    case kGctibRefIsOffset: {
+      ref += reinterpret_cast<intptr_t>(this);
+      return reinterpret_cast<T>(ref);
+    }
+    case kGctibRefIsIndirect: {
+      ref &= ~static_cast<intptr_t>(kGctibRefBitMask);
+      ref += reinterpret_cast<intptr_t>(this);
+      uintptr_t *pRef = reinterpret_cast<uintptr_t*>(ref);
+      return reinterpret_cast<T>(*pRef);
+    }
+    default: {
+      std::abort();
+    }
+  }
+}
+
+template<typename T>
+inline void GctibRef::SetGctibRef(const T ref, const GctibRefFormat format) {
+  static_assert(sizeof(T) == sizeof(uintptr_t), "wrong type.");
+  switch (format) {
+    case kGctibRefIsOffset: {
+      intptr_t offset = static_cast<intptr_t>(reinterpret_cast<uintptr_t>(ref)) - reinterpret_cast<intptr_t>(this);
+      if ((offset & kDataRefBitMask) == 0) {
+        refVal = static_cast<uintptr_t>(offset);
+        return;
+      } else {
+        std::abort();
+      }
+    }
+    default: {
+      std::abort();
+    }
+  }
+}
+
+#if defined(__aarch64__)
+inline bool MByteRef::IsOffset() const {
+  uintptr_t offset = reinterpret_cast<uintptr_t>(refVal);
+  return (kEncodedPosOffsetMin < offset) && (offset < kEncodedPosOffsetMax);
+}
+
+template<typename T>
+inline T MByteRef::GetRef() const {
+  if (IsOffset()) {
+    uint32_t offset = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(refVal) & ~kPositiveOffsetBias);
+    intptr_t ref = reinterpret_cast<intptr_t>(this) + static_cast<intptr_t>(offset);
+    return reinterpret_cast<T>(ref);
+  }
+  uintptr_t ref = reinterpret_cast<uintptr_t>(refVal);
+  return reinterpret_cast<T>(ref);
+}
+
+template<typename T>
+inline void MByteRef::SetRef(const T ref) {
+  static_assert(sizeof(T) == sizeof(uintptr_t), "wrong type.");
+  refVal = reinterpret_cast<uintptr_t>(ref);
+  if (IsOffset()) {
+    std::abort();
+  }
+}
+#elif defined(__arm__)
+inline bool MByteRef::IsOffset() const {
+  intptr_t offset = static_cast<intptr_t>(refVal);
+  return (kEncodedOffsetMin < offset) && (offset < kEncodedOffsetMax);
+}
+
+template<typename T>
+inline T MByteRef::GetRef() const {
+  if (IsOffset()) {
+    int32_t offset = static_cast<int32_t>(static_cast<intptr_t>(refVal) - kPositiveOffsetBias);
+    intptr_t ref = reinterpret_cast<intptr_t>(this) + static_cast<intptr_t>(offset);
+    return reinterpret_cast<T>(ref);
+  }
+  uintptr_t ref = reinterpret_cast<uintptr_t>(refVal);
+  return reinterpret_cast<T>(ref);
+}
+
+template<typename T>
+inline void MByteRef::SetRef(const T ref) {
+  static_assert(sizeof(T) == sizeof(uintptr_t), "wrong type.");
+  refVal = reinterpret_cast<uintptr_t>(ref);
+  if (IsOffset()) {
+    std::abort();
+  }
+}
+#endif
+
+inline bool MByteRef32::IsPositiveOffset() const {
+  return (kEncodedPosOffsetMin < refVal) && (refVal < kEncodedPosOffsetMax);
+}
+
+inline bool MByteRef32::IsNegativeOffset() const {
+  int32_t offset = static_cast<int32_t>(refVal);
+  return (kNegativeOffsetMin <= offset) && (offset < kNegativeOffsetMax);
+}
+
+inline bool MByteRef32::IsOffset() const {
+  return IsNegativeOffset() || IsPositiveOffset();
+}
+
+template<typename T>
+inline T MByteRef32::GetRef() const {
+  if (IsPositiveOffset()) {
+    uint32_t offset = refVal & ~kPositiveOffsetBias;
+    intptr_t ref = reinterpret_cast<intptr_t>(this) + static_cast<intptr_t>(offset);
+    return reinterpret_cast<T>(ref);
+  } else if (IsNegativeOffset()) {
+    int32_t offset = static_cast<int32_t>(refVal);
+    intptr_t ref = reinterpret_cast<intptr_t>(this) + static_cast<intptr_t>(offset);
+    return reinterpret_cast<T>(ref);
+  }
+
+  uintptr_t ref = static_cast<uintptr_t>(refVal);
+  return reinterpret_cast<T>(ref);
+}
+
+template<typename T>
+inline void MByteRef32::SetRef(T ref) {
+  static_assert(sizeof(T) == sizeof(uintptr_t), "wrong type.");
+  uintptr_t addr = reinterpret_cast<uintptr_t>(ref);
+  refVal = static_cast<uint32_t>(addr);
+#if defined(__aarch64__)
+  if (IsOffset()) {
+    std::abort();
+  }
+#endif
+}
+
+template<typename T>
+inline T DataRefOffset32::GetDataRef() const {
+  if (refOffset == 0) {
+    return 0;
+  }
+  intptr_t ref = static_cast<intptr_t>(refOffset);
+  ref += reinterpret_cast<intptr_t>(this);
+  return reinterpret_cast<T>(static_cast<uintptr_t>(ref));
+}
+
+inline int32_t DataRefOffset32::GetRawValue() const {
+  return refOffset;
+}
+
+inline void DataRefOffset32::SetRawValue(int32_t value) {
+  refOffset = value;
+}
+
+// specialized for int32_t, check for out-of-boundary
+template<typename T>
+inline void DataRefOffset32::SetDataRef(T ref) {
+  static_assert(sizeof(T) == sizeof(uintptr_t), "wrong type.");
+  if (ref == 0) {
+    refOffset = 0;
+    return;
+  }
+  uintptr_t uRef = reinterpret_cast<uintptr_t>(ref);
+  intptr_t offset = static_cast<intptr_t>(uRef) - reinterpret_cast<intptr_t>(this);
+  if (INT32_MIN <= offset && offset <= INT32_MAX) {
+    refOffset = static_cast<int32_t>(offset);
+  } else {
+    std::abort();
+  }
+}
+
+template<typename T>
+inline T DataRefOffsetPtr::GetDataRef() const {
+  if (refOffset == 0) {
+    return 0;
+  }
+  intptr_t ref = static_cast<intptr_t>(refOffset);
+  ref += reinterpret_cast<intptr_t>(this);
+  return reinterpret_cast<T>(static_cast<uintptr_t>(ref));
+}
+
+template<typename T>
+inline void DataRefOffsetPtr::SetDataRef(T ref) {
+  static_assert(sizeof(T) == sizeof(uintptr_t), "wrong type.");
+  uintptr_t uRef = reinterpret_cast<uintptr_t>(ref);
+  refOffset = static_cast<intptr_t>(uRef) - reinterpret_cast<intptr_t>(this);
+}
+
+inline intptr_t DataRefOffsetPtr::GetRawValue() const {
+  return refOffset;
+}
+
+inline void DataRefOffsetPtr::SetRawValue(intptr_t value) {
+  refOffset = value;
+}
+
+template<typename T>
+inline T DataRefOffset::GetDataRef() const {
+  return refOffset.GetDataRef<T>();
+}
+
+template<typename T>
+inline void DataRefOffset::SetDataRef(T ref) {
+  refOffset.SetDataRef(ref);
+}
+
+inline intptr_t DataRefOffset::GetRawValue() const {
+  return refOffset.GetRawValue();
+}
+
+inline void DataRefOffset::SetRawValue(intptr_t value) {
+  refOffset.SetRawValue(value);
+}
+
+template<typename T>
+inline T MethodFieldRef::GetDataRef() const {
+  return refOffset.GetDataRef<T>();
+}
+
+template<typename T>
+inline void MethodFieldRef::SetDataRef(T ref) {
+  refOffset.SetDataRef(ref);
+}
+
+inline intptr_t MethodFieldRef::GetRawValue() const {
+  return refOffset.GetRawValue();
+}
+
+inline void MethodFieldRef::SetRawValue(intptr_t value) {
+  refOffset.SetRawValue(value);
+}
+
+inline bool MethodFieldRef::IsCompact() const {
+  return (static_cast<uint32_t>(refOffset.GetRawValue()) & kMethodFieldRefIsCompact) == kMethodFieldRefIsCompact;
+}
+
+template<typename T>
+inline T MethodFieldRef::GetCompactData() const {
+  uint8_t *ref = GetDataRef<uint8_t*>();
+  uintptr_t isCompact = kMethodFieldRefIsCompact;
+  return reinterpret_cast<T>(reinterpret_cast<uintptr_t>(ref) & (~isCompact));
+}
+#endif // METADATA_INLINE_H
diff --git a/src/mrt/compiler-rt/include/metadata_layout.h b/src/mrt/compiler-rt/include/metadata_layout.h
new file mode 100644
index 0000000000000000000000000000000000000000..86b975177a1a4d1174f28ac721e4783d70d274a7
--- /dev/null
+++ b/src/mrt/compiler-rt/include/metadata_layout.h
@@ -0,0 +1,352 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef METADATA_LAYOUT_H
+#define METADATA_LAYOUT_H
+#include <cstdlib>
+
+// metadata layout is shared between maple compiler and runtime, thus not in namespace maplert
+// some of the reference field of metadata is stored as relative offset
+// for example, declaring class of Fields/Methods
+// which can be negative
+#ifdef USE_32BIT_REF
+using MetaRef = uint32_t;      // consistent with reffield_t in address.h
+#else
+using MetaRef = uintptr_t;     // consistent iwth reffield_t in address.h
+#endif // USE_32BIT_REF
+
+// DataRefOffset aims to represent a reference to data in maple file, which is already an offset.
+// DataRefOffset is meant to have pointer size.
+// All Xx32 data types defined in this file aim to use 32 bits to save 64-bit address, and thus are
+// specific for 64-bit platforms.
+struct DataRefOffset32 {
+  int32_t refOffset;
+  template<typename T>
+  inline void SetDataRef(T ref);
+  template<typename T>
+  inline T GetDataRef() const;
+  inline int32_t GetRawValue() const;
+  inline void SetRawValue(int32_t value);
+};
+
+struct DataRefOffsetPtr {
+  intptr_t refOffset;
+  template<typename T>
+  inline void SetDataRef(T ref);
+  template<typename T>
+  inline T GetDataRef() const;
+  inline intptr_t GetRawValue() const;
+  inline void SetRawValue(intptr_t value);
+};
+
+struct DataRefOffset {
+#ifdef USE_32BIT_REF
+  DataRefOffset32 refOffset;
+#else
+  DataRefOffsetPtr refOffset;
+#endif
+  template<typename T>
+  inline void SetDataRef(T ref);
+  template<typename T>
+  inline T GetDataRef() const;
+  inline intptr_t GetRawValue() const;
+  inline void SetRawValue(intptr_t value);
+};
+
+struct MethodFieldRef {
+  // MethodFieldRef aims to represent a reference to fields/methods in maple file, which is already an offset.
+  // also, offset LSB may set 1, to indicate that it is compact fields/methods.
+  enum MethodFieldRefFormat {
+    kMethodFieldRefIsCompact = 1,
+  };
+  DataRefOffsetPtr refOffset;
+  template<typename T>
+  inline void SetDataRef(T ref);
+  template<typename T>
+  inline T GetDataRef() const;
+  inline bool IsCompact() const;
+  template<typename T>
+  inline T GetCompactData() const;
+  inline intptr_t GetRawValue() const;
+  inline void SetRawValue(intptr_t value);
+};
+
+// DataRef aims for reference to data in maple file (generated by maple compiler) and is aligned to at least 4 bytes.
+// Perhaps MDataRef is more fit, still DataRef is chosen to make it common.
+// DataRef allows 4 formats of value:
+// 0. "label_name" for direct reference
+// 1. "label_name - . + 1" for padding unused
+// 2. "label_name - . + 2" for reference in offset format
+// 3. "indirect.label_name - . + 3" for indirect reference
+//    this format aims to support lld which does not support expression "global_symbol - ."
+// DataRef is self-decoded by also encoding the format and is defined for binary compatibility.
+// If no compatibility problem is involved, DataRefOffsetPtr is preferred.
+enum DataRefFormat {
+  kDataRefIsDirect   = 0, // must be 0
+  kDataRefPadding    = 1, // unused
+  kDataRefIsOffset   = 2,
+  kDataRefIsIndirect = 3, // read-only
+  kDataRefBitMask    = 3,
+};
+
+struct DataRef32 {
+  // be careful when *refVal* is treated as an offset which is a signed integer actually.
+  uint32_t refVal;
+  template<typename T>
+  inline T GetDataRef() const;
+  template<typename T>
+  inline void SetDataRef(T ref, DataRefFormat format = kDataRefIsDirect);
+  template<typename T>
+  inline T GetRawValue() const;
+};
+
+struct DataRef {
+  uintptr_t refVal;
+  template<typename T>
+  inline T GetDataRef() const;
+  template<typename T>
+  inline void SetDataRef(const T ref, const DataRefFormat format = kDataRefIsDirect);
+  template<typename T>
+  inline T GetRawValue() const;
+};
+// GctibRef aims to represent a reference to gctib in maple file, which is an offset by default.
+// GctibRef is meant to have pointer size and aligned to at least 4 bytes.
+// GctibRef allows 2 formats of value:
+// 0. "label_name - . + 0" for reference in offset format
+// 1. "indirect.label_name - . + 1" for indirect reference
+//    this format aims to support lld which does not support expression "global_symbol - ."
+// GctibRef is self-decoded by also encoding the format and is defined for binary compatibility.
+// If no compatibility problem is involved, DataRef is preferred.
+enum GctibRefFormat {
+  kGctibRefIsOffset = 0, // default
+  kGctibRefIsIndirect = 1,
+  kGctibRefBitMask = 3
+};
+
+struct GctibRef32 {
+  // be careful when *refVal* is treated as an offset which is a signed integer actually.
+  uint32_t refVal;
+  template<typename T>
+  inline T GetGctibRef() const;
+  template<typename T>
+  inline void SetGctibRef(T ref, GctibRefFormat format = kGctibRefIsOffset);
+};
+
+struct GctibRef {
+  uintptr_t refVal;
+  template<typename T>
+  inline T GetGctibRef() const;
+  template<typename T>
+  inline void SetGctibRef(const T ref, const GctibRefFormat format = kGctibRefIsOffset);
+};
+
+// MByteRef is meant to represent a reference to data defined in maple file. It is a direct reference or an offset.
+// MByteRef is self-encoded/decoded and aligned to 1 byte.
+// Unlike DataRef, the format of MByteRef is determined by its value.
+struct MByteRef {
+  uintptr_t refVal; // initializer prefers this field to be a pointer
+
+#if defined(__arm__) || defined(USE_ARM32_MACRO)
+  // assume address range 0 ~ 256MB is unused in arm runtime
+  // kEncodedOffsetMin ~ kEncodedOffsetMax is the value range of encoded offset
+  static constexpr intptr_t kOffsetBound = 128 * 1024 * 1024;
+  static constexpr intptr_t kOffsetMin = -kOffsetBound;
+  static constexpr intptr_t kOffsetMax = kOffsetBound;
+
+  static constexpr intptr_t kPositiveOffsetBias = 128 * 1024 * 1024;
+  static constexpr intptr_t kEncodedOffsetMin = kPositiveOffsetBias + kOffsetMin;
+  static constexpr intptr_t kEncodedOffsetMax = kPositiveOffsetBias + kOffsetMax;
+#else
+  enum {
+    kBiasBitPosition = sizeof(refVal) * 8 - 4, // the most significant 4 bits
+  };
+
+  static constexpr uintptr_t kOffsetBound = 256 * 1024 * 1024; // according to kDsoLoadedAddessEnd = 0xF0000000
+  static constexpr uintptr_t kPositiveOffsetMin = 0;
+  static constexpr uintptr_t kPositiveOffsetMax = kOffsetBound;
+
+  static constexpr uintptr_t kPositiveOffsetBias = static_cast<uintptr_t>(6) << kBiasBitPosition;
+  static constexpr uintptr_t kEncodedPosOffsetMin = kPositiveOffsetMin + kPositiveOffsetBias;
+  static constexpr uintptr_t kEncodedPosOffsetMax = kPositiveOffsetMax + kPositiveOffsetBias;
+#endif
+
+  template<typename T>
+  inline T GetRef() const;
+  template<typename T>
+  inline void SetRef(const T ref);
+  inline bool IsOffset() const;
+};
+
+struct MByteRef32 {
+  uint32_t refVal;
+  static constexpr uint32_t kOffsetBound = 256 * 1024 * 1024; // according to kDsoLoadedAddessEnd = 0xF0000000
+  static constexpr uint32_t kPositiveOffsetMin = 0;
+  static constexpr uint32_t kPositiveOffsetMax = kOffsetBound;
+
+  static constexpr uint32_t kPositiveOffsetBias = 0x60000000; // the most significant 4 bits 0110
+  static constexpr uint32_t kEncodedPosOffsetMin = kPositiveOffsetMin + kPositiveOffsetBias;
+  static constexpr uint32_t kEncodedPosOffsetMax = kPositiveOffsetMax + kPositiveOffsetBias;
+
+  static constexpr uint32_t kDirectRefMin = 0xC0000000; // according to kDsoLoadedAddessStart = 0xC0000000
+  static constexpr uint32_t kDirectRefMax = 0xF0000000; // according to kDsoLoadedAddessEnd = 0xF0000000
+
+  static constexpr int32_t kNegativeOffsetMin = -(256 * 1024 * 1024); // -kOffsetBound
+  static constexpr int32_t kNegativeOffsetMax = 0;
+
+  template<typename T>
+  inline T GetRef() const;
+  template<typename T>
+  inline void SetRef(T ref);
+  inline bool IsOffset() const;
+  inline bool IsPositiveOffset() const;
+  inline bool IsNegativeOffset() const;
+};
+
+// MethodMeta defined in methodmeta.h
+// FieldMeta  defined in fieldmeta.h
+// MethodDesc contains MethodMetadata and stack map
+struct MethodDesc {
+  // relative offset for method metadata relative to current PC.
+  // method metadata is in compact format if this offset is odd.
+  uint32_t metadataOffset;
+
+  int16_t localRefOffset;
+  uint16_t localRefNumber;
+
+  // stack map for a methed might be placed here
+};
+
+// Note: class init in maplebe and cg is highly dependent on this type.
+// update aarch64rtsupport.h if you modify this definition.
+struct ClassMetadataRO {
+  MByteRef className;
+  MethodFieldRef fields;  // point to info of fields
+  MethodFieldRef methods; // point to info of methods
+  union {  // Element classinfo of array, others parent classinfo
+    DataRef superclass;
+    DataRef componentClass;
+  };
+
+  uint16_t numOfFields;
+  uint16_t numOfMethods;
+
+#ifndef USE_32BIT_REF
+  uint16_t flag;
+  uint16_t numOfSuperclasses;
+  uint32_t padding;
+#endif // !USE_32BIT_REF
+
+  uint32_t mod;
+  DataRefOffset32 annotation;
+  DataRefOffset32 clinitAddr;
+};
+
+static constexpr size_t kPageSize = 4096;
+static constexpr size_t kCacheLine = 64;
+
+// according to kSpaceAnchor and kFireBreak defined in bp_allocator.cpp
+// the address of this readable page is set as kProtectedMemoryStart for java class
+static constexpr uintptr_t kClInitStateAddrBase = 0xc0000000 - (1u << 20) * 2;
+
+// In Kirin 980, 2 mmap memory address with odd number of page distances may have unreasonable L1&L2 cache conflict.
+// kClassInitializedState is used as the init state for class that has no <clinit> method, it's will be loaded in many
+// place for Decouple build App. if we set the value to kClInitStateAddrBase(0xbfe00000), it may conflict with the
+// yieldpoind test address globalPollingPage which is defined in yieldpoint.cpp.
+// Hence we add 1 cache line (64 byte) offset here to avoid such conflict
+static constexpr uintptr_t kClassInitializedState = kClInitStateAddrBase + kCacheLine;
+
+extern "C" uint8_t classInitProtectRegion[];
+
+// Note there is no state to indicate a class is already initialized.
+// Any state beyond listed below is treated as initialized.
+enum ClassInitState {
+  kClassInitStateMin = 0,
+  kClassUninitialized = 1,
+  kClassInitializing = 2,
+  kClassInitFailed = 3,
+  kClassInitialized = 4,
+  kClassInitStateMax = 4,
+};
+
+enum SEGVAddr {
+  kSEGVAddrRangeStart = kPageSize + 0,
+
+  // Note any readable address is treated as Initialized.
+  kSEGVAddrForClassInitStateMin = kSEGVAddrRangeStart + kClassInitStateMin,
+  kSEGVAddrForClassUninitialized = kSEGVAddrForClassInitStateMin + kClassUninitialized,
+  kSEGVAddrForClassInitializing = kSEGVAddrForClassInitStateMin + kClassInitializing,
+  kSEGVAddrForClassInitFailed = kSEGVAddrForClassInitStateMin + kClassInitFailed,
+  kSEGVAddrFoClassInitStateMax  = kSEGVAddrForClassInitStateMin + kClassInitStateMax,
+
+  kSEGVAddrRangeEnd,
+};
+
+struct ClassMetadata {
+  // object common fields
+  MetaRef shadow;  // point to classinfo of java/lang/Class
+  int32_t monitor;
+
+  // other fields
+  uint16_t clIndex; // 8bit ClassLoader index, used for querying the address of related ClassLoader instance.
+  union {
+    uint16_t objSize;
+    uint16_t componentSize;
+  } sizeInfo;
+
+#ifdef USE_32BIT_REF // for alignment purpose
+  uint16_t flag;
+  uint16_t numOfSuperclasses;
+#endif // USE_32BIT_REF
+
+  DataRef iTable;  // iTable of current class, used for interface call, will insert the content into classinfo
+  DataRef vTable;  // vTable of current class, used for virtual call, will insert the content into classinfo
+  GctibRef gctib;  // for rc
+
+#ifdef USE_32BIT_REF
+  DataRef32 classInfoRo;
+  DataRef32 cacheFalseClass;
+#else
+  DataRef classInfoRo;
+#endif
+
+  union {
+    uintptr_t initState; // a readable address for initState means initialized
+    DataRef cacheTrueClass;
+  };
+
+ public:
+  static inline intptr_t OffsetOfInitState() {
+    ClassMetadata *base = nullptr;
+    return reinterpret_cast<intptr_t>(&(base->initState));
+  }
+
+  uintptr_t GetInitStateRawValue() const {
+    return __atomic_load_n(&initState, __ATOMIC_ACQUIRE);
+  }
+
+  template<typename T>
+  void SetInitStateRawValue(T val) {
+    __atomic_store_n(&initState, reinterpret_cast<uintptr_t>(val), __ATOMIC_RELEASE);
+  }
+};
+
+// function to set Class/Field/Method metadata's shadow field to avoid type conversion
+// Note 1: here we don't do NULL-check and type-compatibility check
+// NOte 2: C should be of jclass/ClassMetata* type
+template<typename M, typename C>
+static inline void MRTSetMetadataShadow(M *meta, C cls) {
+  meta->shadow = static_cast<MetaRef>(reinterpret_cast<uintptr_t>(cls));
+}
+
+#endif // METADATA_LAYOUT_H
diff --git a/src/mrt/compiler-rt/include/mm_config.h b/src/mrt/compiler-rt/include/mm_config.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b6858fc021213bfecda90e7af12c0aea23f9ed2
--- /dev/null
+++ b/src/mrt/compiler-rt/include/mm_config.h
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MM_CONFIG_H
+#define MAPLE_RUNTIME_MM_CONFIG_H
+
+#include <cstdint>
+#include <cassert>
+#include <cstdio>
+#include <cstring>
+#include "securec.h"
+#include "mrt_mm_config_common.h"
+#include "base/logging.h"
+
+// Enable debug features.  Codes that implement debug features are guarded by
+// this macro.  When this macro is set to 0, related codes will become no-ops
+// and will have no impact on performance or code size.  Affected features
+// include (but are not limited to):
+//
+// -   Assertion using __MRT_ASSERT (panic.h)
+// -   ROS allocator debug features:
+//     -   Assertion, verification, dumping
+//     -   Bitmap debug in rosallocator
+//     -   Part of the statistics
+// -   Naive RC collector debug features:
+//     -   Inc/Dec from zero detection (?)
+//     -   Weak RC checking
+//     -   LoadIncRef starvation detection
+// -   Saferegion checks
+// -   GC phase timer
+//
+#ifndef __MRT_DEBUG
+#define __MRT_DEBUG 1
+#endif // __MRT_DEBUG
+
+// Environment variable-affected configuration
+//
+// Enable EnvConf. This may create a "undisclosed interface" (i.e. security
+// exploit) in production, so we provide a way to easily disable it when
+// compiling for production.
+#ifndef MRT_ALLOW_ENVCONF
+#define MRT_ALLOW_ENVCONF 1
+#endif
+
+#if MRT_ALLOW_ENVCONF
+namespace maplert {
+long MrtEnvConf(const char *name, long defaultValue); // do not use directly
+}
+
+// Use this macro to get config from environment variable, defaulting to the
+// value of a macro.
+//
+// For example: MRT_ENVCONF(MRT_GCLOG_USE_FILE, MRT_GCLOG_USE_FILE_DEFAULT)
+// Will first check if an environment variable "MRT_GCLOG_USE_FILE" is present,
+// and is a valid integer, and use its value.  If not present or is not a valid
+// integer, it will fall back to the current value of the MRT_GCLOG_USE_FILE
+// macro.  This lets the user override configuration at run time, most useful
+// for debugging.
+#define MRT_ENVCONF(conf, defaultValue) maplert::MrtEnvConf(#conf, defaultValue)
+#else
+#define MRT_ENVCONF(conf) (conf)
+#endif
+
+// configuration control for Maple runtime memory manager
+// HEAP_OBJ_CHECK, used for debugging.
+#ifndef HEAP_OBJ_CHECK // When set, INC, DEC and other RC operations will print
+#define HEAP_OBJ_CHECK 0 // detailed error messages when encountering a non-heap obj.
+#endif
+
+#ifndef HEAP_PROFILE
+#define HEAP_PROFILE 0
+#endif // HEAP_PROFILE
+
+#ifndef SAFEREGION_CHECK // When set, RC will print backtrace and abort the program
+#define SAFEREGION_CHECK __MRT_DEBUG_COND_FALSE // if mutator execute inc, dec or other RC operations in saferegion.
+#endif
+
+#ifndef RC_PROFILE
+#define RC_PROFILE 0
+#endif // RC_PROFILE
+
+#ifndef ENABLE_HPROF
+#define ENABLE_HPROF 1
+#endif
+
+#ifndef LOG_ALLOC_TIMESTAT // Set to 1 to log time stats for obj allocation
+#define LOG_ALLOC_TIMESTAT 0 // and release in allocator
+#endif
+
+// Set to 1 to enable collecting hot object data for RC.
+#ifndef RC_HOT_OBJECT_DATA_COLLECT
+#define RC_HOT_OBJECT_DATA_COLLECT 0
+#endif // RC_HOT_OBJECT_DATA_COLLECT
+
+#ifndef BT_CLEANUP_PROFILE // Back-up tracing cleanup profiling
+#define BT_CLEANUP_PROFILE 1
+#endif // BT_CLEANUP_PROFILE
+
+#ifndef RC_TRACE_OBJECT
+#define RC_TRACE_OBJECT __MRT_DEBUG_COND_FALSE
+#endif // RC_TRACE_OBJECT
+
+#ifndef PATTERN_FROM_BACKUP_TRACING_DEFAULT
+#define PATTERN_FROM_BACKUP_TRACING_DEFAULT 0
+#endif
+
+// Enforcing MRT_GCFini{Global,ThreadLocal}
+#ifndef MRT_ENFORCE_FINI // When 1, not calling MRT_GCFini{Global,ThreadLocal} will abort and print error
+#define MRT_ENFORCE_FINI 0 // When 0, We will call MRT_GCFini{Global,ThreadLocal} for the higher level
+#endif // MRT_ENFORCE_FINI
+
+// Selection of different allocator
+// define MRT_ALLOCATOR_MALLOC 1
+#define MRT_ALLOCATOR_ROS 3
+
+#ifndef MRT_ALLOCATOR
+#define MRT_ALLOCATOR MRT_ALLOCATOR_ROS
+#endif
+
+// Enable/disable systrace in the allocator slow path
+#ifndef MRT_SYSTRACE_ALLOCATOR
+#define MRT_SYSTRACE_ALLOCATOR 0
+#endif
+
+// configuration for use-after-free debugging
+//
+// When enabled, newobj, freeobj, inc and dec will check if the object address
+// to work with actually points to a live object.
+#ifndef MRT_REF_VALIDITY_CHECK
+#define MRT_REF_VALIDITY_CHECK 1 // Do checking by default. Can be disabled.
+#endif // MRT_REF_VALIDITY_CHECK
+
+// This enables assertions at obj free
+#ifndef MRT_DEBUG_DOUBLE_FREE
+#define MRT_DEBUG_DOUBLE_FREE 1
+#endif
+
+// GCLog: logs specific to GC
+//
+// If this is on, write GC log to a disk file.  This is useful when debugging,
+// because logcat may be flooded by messages from other processes.
+//
+// If off, GCLog will not do anything.
+//
+// Can be overridden by the environment variable of the same name.
+#ifndef MRT_GCLOG_USE_FILE_DEFAULT
+#define MRT_GCLOG_USE_FILE_DEFAULT 0
+#endif // MRT_GCLOG_USE_FILE_DEFAULT
+
+// If true, the process will open the GC log file and write to it on startup.
+// Otherwise, it will only open GC log file on fork(), i.e. when Zygote creates
+// a sub-process.
+//
+// Can be overridden by the environment variable of the same name.
+#ifndef MRT_GCLOG_OPEN_ON_STARTUP_DEFAULT
+#define MRT_GCLOG_OPEN_ON_STARTUP_DEFAULT 0
+#endif // MRT_GCLOG_OPEN_ON_STARTUP_DEFAULT
+
+#ifndef MRT_RCTRACELOG_USE_FILE_DEFAULT
+#define MRT_RCTRACELOG_USE_FILE_DEFAULT RC_TRACE_OBJECT
+#endif // MRT_RCTRACELOG_USE_FILE_DEFAULT
+
+#ifndef MRT_RCTRACELOG_OPEN_ON_STARTUP_DEFAULT
+#define MRT_RCTRACELOG_OPEN_ON_STARTUP_DEFAULT RC_TRACE_OBJECT
+#endif // MRT_RCTRACELOG_OPEN_ON_STARTUP_DEFAULT
+
+#ifndef MRT_RPLOG_USE_FILE_DEFAULT
+#define MRT_RPLOG_USE_FILE_DEFAULT 0
+#endif // MRT_RPLOG_USE_FILE_DEFAULT
+
+#ifndef MRT_RPLOG_OPEN_ON_STARTUP_DEFAULT
+#define MRT_RPLOG_OPEN_ON_STARTUP_DEFAULT 0
+#endif // MRT_RPLOG_OPEN_ON_STARTUP_DEFAULT
+
+#ifndef MRT_CYCLELOG_USE_FILE_DEFAULT
+#define MRT_CYCLELOG_USE_FILE_DEFAULT 0
+#endif // MRT_CYCLELOG_USE_FILE_DEFAULT
+
+#ifndef MRT_CYCLELOG_OPEN_ON_STARTUP_DEFAULT
+#define MRT_CYCLELOG_OPEN_ON_STARTUP_DEFAULT 0
+#endif // MRT_CYCLELOG_OPEN_ON_STARTUP_DEFAULT
+
+#ifndef MRT_ALLOCFRAGLOG_USE_FILE_DEFAULT
+#define MRT_ALLOCFRAGLOG_USE_FILE_DEFAULT 0
+#endif // MRT_ALLOCFRAGLOG_USE_FILE_DEFAULT
+
+#ifndef MRT_ALLOCFRAGLOG_OPEN_ON_STARTUP_DEFAULT
+#define MRT_ALLOCFRAGLOG_OPEN_ON_STARTUP_DEFAULT 0
+#endif // MRT_ALLOCFRAGLOG_OPEN_ON_STARTUP_DEFAULT
+
+#ifndef MRT_ALLOCATORLOG_USE_FILE_DEFAULT
+#define MRT_ALLOCATORLOG_USE_FILE_DEFAULT 0
+#endif // MRT_ALLOCFRAGLOG_USE_FILE_DEFAULT
+
+#ifndef MRT_ALLOCATOR_OPEN_ON_STARTUP_DEFAULT
+#define MRT_ALLOCATOR_OPEN_ON_STARTUP_DEFAULT 0
+#endif // MRT_ALLOCFRAGLOG_OPEN_ON_STARTUP_DEFAULT
+
+#ifndef MRT_MIXLOG_USE_FILE_DEFAULT
+#define MRT_MIXLOG_USE_FILE_DEFAULT 0
+#endif // MRT_ALLOCFRAGLOG_USE_FILE_DEFAULT
+
+#ifndef MRT_MIXLOG_OPEN_ON_STARTUP_DEFAULT
+#define MRT_MIXLOG_OPEN_ON_STARTUP_DEFAULT 0
+#endif // MRT_ALLOCFRAGLOG_OPEN_ON_STARTUP_DEFAULT
+
+#ifndef MRT_STDERRLOG_USE_FILE
+#define MRT_STDERRLOG_USE_FILE 0
+#endif // MRT_ALLOCFRAGLOG_USE_FILE
+
+#ifndef MRT_STDERR_OPEN_ON_STARTUP
+#define MRT_STDERR_OPEN_ON_STARTUP 0
+#endif // MRT_ALLOCFRAGLOG_OPEN_ON_STARTUP
+
+// if set to 1 by the environment variable, MarkSweepCollector::concurrentMark and concurrentSweep will be false
+#ifndef MRT_IS_NON_CONCURRENT_GC_DEFAULT
+#define MRT_IS_NON_CONCURRENT_GC_DEFAULT 0
+#endif // MRT_IS_NON_CONCURRENT_GC_DEFAULT
+
+#define LOAD_INC_RC_MASK 1 // can only use lower 3bits on 64bit-platform
+
+#ifdef USE_32BIT_REF
+#define GRT_DEADVALUE (0xdeaddeadul)
+#else
+#define GRT_DEADVALUE (0xdeaddeaddeaddeadul)
+#endif // USE_32BIT_REF
+
+// ---------------------------------------------------
+// NOTE: Don't forget update 'duplicateFunc.s'
+// if you changed HEAP_START or HEAP_END.
+// ---------------------------------------------------
+
+#ifdef __aarch64__
+// The first 64KB is protected by SELinux.
+#define HEAP_START (1u << 16)
+#define HEAP_END (1ul << 31) // max of 2GB space
+#define PERM_BEGIN (9ul << 28) // perm start from 2.25G
+#define PERM_END (3ul << 30) // perm end at 3G
+#elif defined(__arm__)
+// The first 64KB is protected by SELinux.
+// 0~256MB is reserved to encode offset in mfile.
+#define PERM_BEGIN (256ul << 20)
+#define PERM_END (1ul << 30)
+#define HEAP_START PERM_END
+#define HEAP_END (2ul << 30)
+#endif // __aarch64__
+
+#ifndef PERMISSIVE_HEAP_COND
+#define PERMISSIVE_HEAP_COND 0 // disabled for portability reason
+#endif
+namespace maplert {
+constexpr uint64_t kMrtHeapAlign = 8;
+// Maple uses i32 for array length and can be negative
+constexpr uint32_t kMrtMaxArrayLength = ((1UL << 31) - 1); // the max of int32 is 2 ^ 31 - 1
+constexpr uint32_t kMfileHighAddress = 0xfe000000;
+}
+
+#ifdef USE_32BIT_REF
+#define ALLOC_USE_FAST_PATH (!CONFIG_JSAN && \
+                             !RC_HOT_OBJECT_DATA_COLLECT && \
+                             !RC_TRACE_OBJECT && \
+                             !LOG_ALLOC_TIMESTAT)
+#else
+#define ALLOC_USE_FAST_PATH false
+#endif
+
+#ifndef LIKELY
+#define LIKELY(x) __builtin_expect(!!(x), 1)
+#endif
+
+#ifndef UNLIKELY
+#define UNLIKELY(x) __builtin_expect(!!(x), 0)
+#endif
+
+#endif // MAPLE_RUNTIME_MMCONFIG_H
diff --git a/src/mrt/compiler-rt/include/mm_utils.h b/src/mrt/compiler-rt/include/mm_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..0fb877b94e965a6631daae72e4c4d82980ef0bf7
--- /dev/null
+++ b/src/mrt/compiler-rt/include/mm_utils.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MM_UTILS_H
+#define MAPLE_RUNTIME_MM_UTILS_H
+
+#include <cinttypes>
+#include <unistd.h>
+#include <linux/futex.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <fstream>
+
+#include "gc_log.h"
+
+using address_t = uintptr_t;
+
+namespace maplert {
+namespace util {
+void PrintPCSymbol(const void *pc);
+
+void PrintPCSymbolToLog(const void *pc, uint32_t logtype = kLogtypeRcTrace, bool printBt = true);
+
+void PrintPCSymbolToLog(const void *pc, std::ostream &ofs, bool printBt);
+
+void PrintBacktrace();
+
+void PrintBacktrace(int32_t logFile);
+
+void PrintBacktrace(size_t limit, int32_t logFile);
+
+extern "C" void DumpObject(address_t obj, std::ostream &ofs);
+
+void WaitUntilAllThreadsStopped();
+
+std::string GetLogDir();
+} // namespace util
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/mrt_common.h b/src/mrt/compiler-rt/include/mrt_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..eeace7987ba99c9931e5b96190a83005954a2f53
--- /dev/null
+++ b/src/mrt/compiler-rt/include/mrt_common.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_COMMON_H
+#define MRT_COMMON_H
+
+// This file is used to declare some common use variables between mrt and mapleall
+// For decoupling load
+constexpr uint32_t kMplStaticDecoupleMagicNumber = 0x1a0;               // For non-lazy static decouple trigger SIGSEGV
+constexpr uint32_t kMplLazyStaticDecoupleMagicNumber = 0x1a1;           // For lazy static decouple trigger SIGSEGV
+constexpr uint32_t kMplLazyLoadMagicNumber = 0x1a2;                     // For lazy decouple trigger SIGSEGV
+constexpr uint64_t kMplLazyLoadSentryNumber = 0x1a27b10d10810ade;       // Sentry for offset table
+constexpr uint64_t kMplStaticLazyLoadSentryNumber = 0x1a27b10d10810ad1; // Sentry for static offset table
+constexpr uint32_t kMplArrayClassCacheMagicNumber = 0x1a3;              // For init array class cache trigger SIGSEGV
+#endif // MRT_COMMON_H
diff --git a/src/mrt/compiler-rt/include/muid.h b/src/mrt/compiler-rt/include/muid.h
new file mode 100644
index 0000000000000000000000000000000000000000..8fa6889594e1ddb83c6ce2041648980d0bbf8ad9
--- /dev/null
+++ b/src/mrt/compiler-rt/include/muid.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MUID_H
+#define MUID_H
+
+// This is shared between maple compiler and runtime.
+#include <cstdint>
+#include <string>
+#include <sstream>
+#include <iomanip>
+
+#ifdef USE_32BIT_REF
+#define USE_64BIT_MUID
+#endif // USE_32BIT_REF
+
+constexpr unsigned int kSystemNamespace = 0xc0;
+constexpr unsigned int kApkNamespace = 0x80;
+constexpr unsigned int kBitMask = 0x3f;
+constexpr unsigned int kGroupSize = 64;
+constexpr unsigned int kShiftAmount = 32;
+constexpr unsigned int kBlockLength = 16;
+constexpr unsigned int kByteLength = 8;
+constexpr unsigned int kNumLowAndHigh = 2;
+
+#ifdef USE_64BIT_MUID
+constexpr unsigned int kMuidLength = 8;
+#else
+constexpr unsigned int kMuidLength = 16;
+#endif // USE_64BIT_MUID
+
+constexpr unsigned int kDigestShortHashLength = 8;
+constexpr unsigned int kDigestHashLength = 16;
+union DigestHash {
+  uint8_t bytes[kDigestHashLength];
+  struct {
+    uint64_t first;
+    uint64_t second;
+  } data;
+};
+
+// muid-related files are shared between maple compiler and runtime, thus not in
+// namespace maplert
+struct MuidContext {
+  unsigned int a;
+  unsigned int b;
+  unsigned int c;
+  unsigned int d;
+  unsigned int count[kNumLowAndHigh];
+  unsigned int block[kBlockLength];
+  unsigned char buffer[kGroupSize];
+};
+
+class MUID {
+ public:
+  union {
+#ifdef USE_64BIT_MUID
+    uint32_t words[kNumLowAndHigh] = { 0 };
+    uint8_t bytes[kMuidLength];
+    uint64_t raw;
+#else
+    uint64_t words[kNumLowAndHigh] = { 0 };
+    uint8_t bytes[kMuidLength];
+#endif // USE_64BIT_MUID
+  } data;
+
+  inline bool IsSystemNameSpace() const {
+    return (data.bytes[kMuidLength - 1] & ~kBitMask) == kSystemNamespace;
+  }
+  inline bool IsApkNameSpace() const {
+    return (data.bytes[kMuidLength - 1] & ~kBitMask) == kApkNamespace;
+  }
+  inline void SetSystemNameSpace() {
+    data.bytes[kMuidLength - 1] &= kBitMask;
+    data.bytes[kMuidLength - 1] |= kSystemNamespace;
+  }
+  inline void SetApkNameSpace() {
+    data.bytes[kMuidLength - 1] &= kBitMask;
+    data.bytes[kMuidLength - 1] |= kApkNamespace;
+  }
+  bool operator<(const MUID &muid) const {
+    return (data.words[1] < muid.data.words[1] ||
+            (data.words[1] == muid.data.words[1] && data.words[0] < muid.data.words[0]));
+  }
+  bool operator>(const MUID &muid) const {
+    return (data.words[1] > muid.data.words[1] ||
+            (data.words[1] == muid.data.words[1] && data.words[0] > muid.data.words[0]));
+  }
+  bool operator==(const MUID &muid) const {
+    return data.words[1] == muid.data.words[1] && data.words[0] == muid.data.words[0];
+  }
+  bool operator!=(const MUID &muid) const {
+    return data.words[1] != muid.data.words[1] || data.words[0] != muid.data.words[0];
+  }
+  std::string ToStr() const {
+    std::stringstream sbuf;
+#ifdef USE_64BIT_MUID
+    // 8 spaces to 64 bit
+    sbuf << std::setfill('0') << std::setw(8) << std::hex << data.words[1] << std::setfill('0') << std::setw(8) <<
+        std::hex << data.words[0];
+#else
+    // 16 spaces to 32 bit
+    sbuf << std::setfill('0') << std::setw(16) << std::hex << data.words[1] << std::setfill('0') << std::setw(16) <<
+        std::hex << data.words[0];
+#endif // USE_64BIT_MUID
+    return sbuf.str();
+  }
+};
+
+void MuidInit(MuidContext &status);
+void MuidDecode(MuidContext &status, const unsigned char &data, uint64_t size);
+
+template<typename T>
+void FullEncode(T &result, MuidContext &status);
+void MuidEncode(unsigned char (&result)[kDigestShortHashLength], MuidContext &status);
+void MuidEncode(unsigned char (&result)[kDigestHashLength], MuidContext &status, bool use64Bit = false);
+
+void GetMUIDHash(const unsigned char &data, size_t size, MUID &muid);
+DigestHash GetDigestHash(const unsigned char &bytes, uint32_t len);
+MUID GetMUID(const std::string &symbolName, bool forSystem = true);
+#endif
diff --git a/src/mrt/compiler-rt/include/mutator_list.h b/src/mrt/compiler-rt/include/mutator_list.h
new file mode 100644
index 0000000000000000000000000000000000000000..d4655f225a13fc3e85d91c0049fe11da46d583ec
--- /dev/null
+++ b/src/mrt/compiler-rt/include/mutator_list.h
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MUTATOR_LIST_H
+#define MAPLE_RUNTIME_MUTATOR_LIST_H
+
+#include <mutex>
+#include <list>
+#include <cinttypes>
+#include <memory>
+#include <unordered_map>
+#include "mm_config.h"
+#include "collector/collector.h"
+#include "panic.h"
+#include "syscall.h"
+#include "allocator/page_allocator.h"
+
+#ifndef MRT_DEBUG_MUTATOR_LIST
+#define MRT_DEBUG_MUTATOR_LIST __MRT_DEBUG_COND_FALSE
+#endif
+
+namespace maplert {
+class MutatorList {
+ public:
+  MutatorList() : lockOwnerTid(0) {}
+  ~MutatorList() = default;
+  // Gets the singleton instance.
+  static inline MutatorList &Instance() {
+    return *instance;
+  }
+
+  // Replace the singleton instance with a new one.
+  // This should be called after forked from parent process.
+  static void reset();
+
+  // Add a mutator to the list.
+  void AddMutator(Mutator &mutator) {
+    std::lock_guard<std::mutex> lock(mutatorListMutex);
+    lockOwnerTid = static_cast<uint32_t>(maple::GetTid());
+    mutator.active = kMutatorDebugTrue;
+    mutator.Init();
+    mutatorList.push_back(&mutator);
+    lockOwnerTid = 0;
+#if MRT_DEBUG_MUTATOR_LIST
+    auto result = debugMap.insert({ &mutator, mutator.tid });
+    if (UNLIKELY(!result.second)) {
+      // insert failed, means there is a record leaved by an abnormlly exited mutator.
+      LOG(FATAL) << "Found abnormally exited mutator!" <<
+          " mutator: " << result.first->first <<
+          " tid: " << result.first->second << maple::endl;
+    }
+#endif
+  }
+
+  // Remove a mutator from the list.
+  template<typename Func>
+  void RemoveMutator(Mutator &mutator, Func &&func) {
+    std::lock_guard<std::mutex> lock(mutatorListMutex);
+    lockOwnerTid = static_cast<uint32_t>(maple::GetTid());
+    size_t sizeBeforeRemove __MRT_UNUSED = mutatorList.size();
+    mutatorList.remove(&mutator);
+#if __MRT_DEBUG
+    size_t removedCount = sizeBeforeRemove - mutatorList.size();
+    if (UNLIKELY(removedCount != 1)) {
+      LOG(FATAL) << "RemoveMutator: invalid removed count: " << removedCount << maple::endl;
+    }
+#endif
+    func(&mutator);
+    mutator.active = kMutatorDebugFalse;
+    lockOwnerTid = 0;
+#if MRT_DEBUG_MUTATOR_LIST
+    size_t removed = debugMap.erase(&mutator);
+    if (UNLIKELY(removed != 1)) {
+      LOG(FATAL) << "Remove an invalid mutator" << maple::endl;
+    }
+#endif
+  }
+
+  // Do things when lock is hold.
+  template<typename Func>
+  void LockGuard(Func &&func) {
+    std::lock_guard<std::mutex> lock(mutatorListMutex);
+    lockOwnerTid = static_cast<uint32_t>(maple::GetTid());
+    func();
+    lockOwnerTid = 0;
+  }
+
+  // Lock the mutex.
+  void Lock() {
+    mutatorListMutex.lock();
+    lockOwnerTid = static_cast<uint32_t>(maple::GetTid());
+  }
+
+  // Unlock the mutex.
+  bool TryLock() {
+    if (mutatorListMutex.try_lock()) {
+      lockOwnerTid = static_cast<uint32_t>(maple::GetTid());
+      return true;
+    }
+    return false;
+  }
+
+  // Unlock the mutex.
+  void Unlock() {
+    lockOwnerTid = 0;
+    mutatorListMutex.unlock();
+  }
+
+  // Number of mutators in the list.
+  size_t Size() const {
+    return mutatorList.size();
+  }
+
+  // Gets the mutator list.
+  const std::list<Mutator*, StdContainerAllocator<Mutator*, kMutatorList>> &List() const {
+    return mutatorList;
+  }
+
+  // Before using this interface, you need to call instance.Lock,
+  // and after using mutator, you should call instance.Unlock.
+  Mutator *GetMutator(uint32_t tid) {
+    __MRT_ASSERT(MutatorList::Instance().IsLockedBySelf() == true, "mutator list is not locked");
+    for (auto &mutator : mutatorList) {
+      if (mutator->GetTid() == tid) {
+        return mutator;
+      }
+    }
+    return nullptr;
+  }
+
+  // Visit all mutators, should be called
+  // in collector thread after the world stopped.
+  // Func: void func(Mutator* mutator);
+  template<typename Func>
+  void VisitMutators(Func &&func) {
+    for (auto &mutator : mutatorList) {
+      func(mutator);
+    }
+  }
+
+  // Get stack begin with given tid
+  uintptr_t GetStackBeginByTid(uint32_t tid) {
+    for (auto &mutator : mutatorList) {
+      if (mutator->GetTid() == tid) {
+        return mutator->GetStackBegin();
+      }
+    }
+    return 0;
+  }
+
+  void DebugShowCurrentMutators();
+
+  bool IsLockedBySelf() const {
+    if (lockOwnerTid == 0) {
+      return false;
+    }
+    return lockOwnerTid == static_cast<uint32_t>(maple::GetTid());
+  }
+
+  uint32_t LockOwner() const {
+    return lockOwnerTid;
+  }
+
+ private:
+  // mutex use to protect mutatorList.
+  // we also use it to block all mutators when the world is stopped.
+  std::mutex mutatorListMutex;
+
+  // list of all mutators, protected by mutatorListMutex.
+  std::list<Mutator*, StdContainerAllocator<Mutator*, kMutatorList>> mutatorList;
+
+  // holder for this lock
+  volatile uint32_t lockOwnerTid;
+
+  // The Singleton instance.
+  __attribute__((visibility("default"))) static ImmortalWrapper<MutatorList> instance;
+
+#if MRT_DEBUG_MUTATOR_LIST
+  // mutator --> tid map, for debug purpose.
+  std::unordered_map<Mutator*, uint32_t> debugMap;
+#endif
+};
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/namemangler.h b/src/mrt/compiler-rt/include/namemangler.h
new file mode 100644
index 0000000000000000000000000000000000000000..d561f3ce90d937221bba305620e04b7658d0fb8c
--- /dev/null
+++ b/src/mrt/compiler-rt/include/namemangler.h
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef NAMEMANGLER_H
+#define NAMEMANGLER_H
+#include <string>
+#include <vector>
+
+// This is a general name mangler which is shared between maple compiler and runtime.
+// maple-compiler-specific data structure may NOT be used here.
+namespace namemangler {
+#define TO_STR(s)  TO_STR2(s)
+#define TO_STR2(s) #s
+
+
+#define VTAB_PREFIX               __vtb_
+#define ITAB_PREFIX               __itb_
+#define VTAB_AND_ITAB_PREFIX      __vtb_and_itb_
+#define ITAB_CONFLICT_PREFIX      __itbC_
+#define CLASSINFO_PREFIX          __cinf_
+#define CLASSINFO_RO_PREFIX       __classinforo__
+#define SUPERCLASSINFO_PREFIX     __superclasses__
+#define PRIMITIVECLASSINFO_PREFIX __pinf_
+#define CLASS_INIT_BRIDGE_PREFIX  __ClassInitBridge__
+#define GCTIB_PREFIX              MCC_GCTIB__
+#define REF_PREFIX                REF_
+#define JARRAY_PREFIX             A
+
+#define VTAB_PREFIX_STR               TO_STR(VTAB_PREFIX)
+#define ITAB_PREFIX_STR               TO_STR(ITAB_PREFIX)
+#define VTAB_AND_ITAB_PREFIX_STR      TO_STR(VTAB_AND_ITAB_PREFIX)
+#define ITAB_CONFLICT_PREFIX_STR      TO_STR(ITAB_CONFLICT_PREFIX)
+#define CLASSINFO_PREFIX_STR          TO_STR(CLASSINFO_PREFIX)
+#define CLASSINFO_RO_PREFIX_STR       TO_STR(CLASSINFO_RO_PREFIX)
+#define SUPERCLASSINFO_PREFIX_STR     TO_STR(SUPERCLASSINFO_PREFIX)
+#define PRIMITIVECLASSINFO_PREFIX_STR TO_STR(PRIMITIVECLASSINFO_PREFIX)
+#define CLASS_INIT_BRIDGE_PREFIX_STR  TO_STR(CLASS_INIT_BRIDGE_PREFIX)
+#define GCTIB_PREFIX_STR              TO_STR(GCTIB_PREFIX)
+#define REF_PREFIX_STR                TO_STR(REF_PREFIX)
+#define JARRAY_PREFIX_STR             TO_STR(JARRAY_PREFIX)
+
+// Names of all compiler-generated tables and accessed by runtime
+static constexpr const char kMuidPrefixStr[] = "__muid_";
+static constexpr const char kMuidRoPrefixStr[] = "__muid_ro";
+static constexpr const char kMuidFuncDefTabPrefixStr[] = "__muid_func_def_tab";
+static constexpr const char kMuidFuncDefOrigTabPrefixStr[] = "__muid_ro_func_def_orig_tab";
+static constexpr const char kMuidFuncInfTabPrefixStr[] = "__muid_ro_func_inf_tab";
+static constexpr const char kMuidFuncMuidIdxTabPrefixStr[] = "__muid_ro_func_muid_idx_tab";
+static constexpr const char kMuidDataDefTabPrefixStr[] = "__muid_data_def_tab";
+static constexpr const char kMuidDataDefOrigTabPrefixStr[] = "__muid_ro_data_def_orig_tab";
+static constexpr const char kMuidFuncUndefTabPrefixStr[] = "__muid_func_undef_tab";
+static constexpr const char kMuidDataUndefTabPrefixStr[] = "__muid_data_undef_tab";
+static constexpr const char kMuidFuncDefMuidTabPrefixStr[] = "__muid_ro_func_def_muid_tab";
+static constexpr const char kMuidDataDefMuidTabPrefixStr[] = "__muid_ro_data_def_muid_tab";
+static constexpr const char kMuidFuncUndefMuidTabPrefixStr[] = "__muid_ro_func_undef_muid_tab";
+static constexpr const char kMuidDataUndefMuidTabPrefixStr[] = "__muid_ro_data_undef_muid_tab";
+static constexpr const char kMuidVtabAndItabPrefixStr[] = "__muid_vtab_and_itab";
+static constexpr const char kMuidItabConflictPrefixStr[] = "__muid_itab_conflict";
+static constexpr const char kMuidColdVtabAndItabPrefixStr[] = "__muid_cold_vtab_and_itab";
+static constexpr const char kMuidColdItabConflictPrefixStr[] = "__muid_cold_itab_conflict";
+static constexpr const char kMuidVtabOffsetPrefixStr[] = "__muid_vtab_offset_tab";
+static constexpr const char kMuidFieldOffsetPrefixStr[] = "__muid_field_offset_tab";
+static constexpr const char kMuidVtabOffsetKeyPrefixStr[] = "__muid_vtable_offset_key_tab";
+static constexpr const char kMuidFieldOffsetKeyPrefixStr[] = "__muid_field_offset_key_tab";
+static constexpr const char kMuidValueOffsetPrefixStr[] = "__muid_offset_value_table";
+static constexpr const char kMuidLocalClassInfoStr[] = "__muid_local_classinfo_tab";
+static constexpr const char kMuidSuperclassPrefixStr[] = "__muid_superclass";
+static constexpr const char kMuidGlobalRootlistPrefixStr[] = "__muid_globalrootlist";
+static constexpr const char kMuidClassMetadataPrefixStr[] = "__muid_classmetadata";
+static constexpr const char kMuidClassMetadataBucketPrefixStr[] = "__muid_classmetadata_bucket";
+static constexpr const char kMuidJavatextPrefixStr[] = "java_text";
+static constexpr const char kMuidDataSectionStr[] = "__data_section";
+static constexpr const char kMuidRangeTabPrefixStr[] = "__muid_range_tab";
+static constexpr const char kMuidConststrPrefixStr[] = "__muid_conststr";
+static constexpr const char kVtabOffsetTabStr[] = "__vtable_offset_table";
+static constexpr const char kFieldOffsetTabKeyStr[] = "__field_offset_key_table";
+static constexpr const char kFieldOffsetTabStr[] = "__field_offset_table";
+static constexpr const char kVtableKeyOffsetTabStr[] = "__vtable_offset_key_table";
+static constexpr const char kVtableOffsetTabKeyStr[] = "__vtable_offset_key_table";
+static constexpr const char kFieldKeyOffsetTabStr[] = "__field_offset_table";
+static constexpr const char kOffsetTabStr[] = "__offset_value_table";
+static constexpr const char kInlineCacheTabStr[] = "__inline_cache_table";
+static constexpr const char kLocalClassInfoStr[] = "__local_classinfo_table";
+static constexpr const char kMethodsInfoPrefixStr[] = "__methods_info__";
+static constexpr const char kMethodsInfoCompactPrefixStr[] = "__methods_infocompact__";
+static constexpr const char kFieldsInfoPrefixStr[] = "__fields_info__";
+static constexpr const char kFieldsInfoCompactPrefixStr[] = "__fields_infocompact__";
+static constexpr const char kFieldOffsetDataPrefixStr[] = "__fieldOffsetData__";
+static constexpr const char kMethodAddrDataPrefixStr[] = "__methodAddrData__";
+static constexpr const char kMethodSignaturePrefixStr[] = "__methodSignature__";
+static constexpr const char kParameterTypesPrefixStr[] = "__parameterTypes__";
+static constexpr const char kRegJNITabPrefixStr[] = "__reg_jni_tab";
+static constexpr const char kRegJNIFuncTabPrefixStr[] = "__reg_jni_func_tab";
+static constexpr const char kReflectionStrtabPrefixStr[] = "__reflection_strtab";
+static constexpr const char kReflectionStartHotStrtabPrefixStr[] = "__reflection_start_hot_strtab";
+static constexpr const char kReflectionBothHotStrTabPrefixStr[] = "__reflection_both_hot_strtab";
+static constexpr const char kReflectionRunHotStrtabPrefixStr[] = "__reflection_run_hot_strtab";
+static constexpr const char kReflectionNoEmitStrtabPrefixStr[] = "__reflection_no_emit_strtab";
+static constexpr const char kMarkMuidFuncDefStr[] = "muid_func_def:";
+static constexpr const char kMarkMuidFuncUndefStr[] = "muid_func_undef:";
+static constexpr const char kGcRootList[] = "gcRootNewList";
+static constexpr const char kDecoupleOption[] = "__decouple_option";
+static constexpr const char kDecoupleStr[] = "__decouple";
+static constexpr const char kCompilerVersionNum[] = "__compilerVersionNum";
+static constexpr const char kCompilerVersionNumStr[] = "__compilerVersionNumTab";
+static constexpr const char kCompilerMfileStatus[]  = "__compiler_mfile_status";
+static constexpr const char kMapleGlobalVariable[]  = "maple_global_variable";
+static constexpr const char kMapleLiteralString[]  = "maple_literal_string";
+
+static constexpr const char kSourceMuid[] = "__sourceMuid";
+static constexpr const char kSourceMuidSectionStr[] = "__sourceMuidTab";
+static constexpr const char kDecoupleStaticKeyStr[] = "__staticDecoupleKeyOffset";
+static constexpr const char kDecoupleStaticValueStr[] = "__staticDecoupleValueOffset";
+static constexpr const char kMarkDecoupleStaticStr[] = "decouple_static:";
+static constexpr const char kClassInfoPrefix[] = "__cinf";
+static constexpr const char kBssSectionStr[] = "__bss_section";
+static constexpr const char kLinkerHashSoStr[] = "__linkerHashSo";
+
+static constexpr const char kStaticFieldNamePrefixStr[] = "__static_field_name";
+static constexpr const char kMplSuffix[] = ".mpl";
+static constexpr const char kClinvocation[] = ".clinvocation";
+static constexpr const char kPackageNameSplitterStr[] = "_2F";
+static constexpr const char kFileNameSplitterStr[] = "$$";
+static constexpr const char kNameSplitterStr[] = "_7C";  // 7C is the ascii code for |
+static constexpr const char kRightBracketStr[] = "_29";  // 29 is the ascii code for )
+static constexpr const char kClassNameSplitterStr[] = "_3B_7C";
+static constexpr const char kJavaLangClassStr[] = "Ljava_2Flang_2FClass_3B";
+static constexpr const char kJavaLangObjectStr[] = "Ljava_2Flang_2FObject_3B";
+static constexpr const char kJavaLangClassloader[] = "Ljava_2Flang_2FClassLoader_3B";
+static constexpr const char kJavaLangObjectStrJVersion[] = "Ljava/lang/Object;";
+static constexpr const char kJavaLangStringStr[] = "Ljava_2Flang_2FString_3B";
+static constexpr const char kJavaLangExceptionStr[] = "Ljava_2Flang_2FException_3B";
+static constexpr const char kThrowClassStr[] = "Ljava_2Flang_2FThrowable_3B";
+static constexpr const char kReflectionClassesPrefixStr[] = "Ljava_2Flang_2Freflect_2F";
+static constexpr const char kReflectionClassMethodStr[] = "Ljava_2Flang_2Freflect_2FMethod_241_3B";
+static constexpr const char kClassMetadataTypeName[] = "__class_meta__";
+static constexpr const char kPtrPrefixStr[] = "_PTR";
+static constexpr const char kClassINfoPtrPrefixStr[] = "_PTR__cinf_";
+static constexpr const char kArrayClassInfoPrefixStr[] = "__cinf_A";
+static constexpr const char kShadowClassName[] = "shadow_24__klass__";
+static constexpr const char kClinitSuffix[] = "_7C_3Cclinit_3E_7C_28_29V";
+static constexpr const char kCinitStr[] = "_7C_3Cinit_3E_7C_28";
+static constexpr const char kClinitSubStr[] = "7C_3Cinit_3E_7C";
+
+static constexpr const char kPreNativeFunc[] = "MCC_PreNativeCall";
+static constexpr const char kPostNativeFunc[] = "MCC_PostNativeCall";
+static constexpr const char kDecodeRefFunc[] = "MCC_DecodeReference";
+static constexpr const char kFindNativeFunc[] = "MCC_FindNativeMethodPtr";
+static constexpr const char kFindNativeFuncNoeh[] = "MCC_FindNativeMethodPtrWithoutException";
+static constexpr const char kDummyNativeFunc[] = "MCC_DummyNativeMethodPtr";
+static constexpr const char kCheckThrowPendingExceptionFunc[] = "MCC_CheckThrowPendingException";
+static constexpr const char kCallFastNative[] = "MCC_CallFastNative";
+static constexpr const char kCallFastNativeExt[] = "MCC_CallFastNativeExt";
+static constexpr const char kCallSlowNativeExt[] = "MCC_CallSlowNativeExt";
+static constexpr const char kSetReliableUnwindContextFunc[] = "MCC_SetReliableUnwindContext";
+
+static constexpr const char kArrayClassCacheTable[] = "__arrayClassCacheTable";
+static constexpr const char kArrayClassCacheNameTable[] = "__muid_ro_arrayClassCacheNameTable";
+static constexpr const char kFunctionLayoutStr[] = "__func_layout__";
+
+static constexpr const char kFunctionProfileTabPrefixStr[] = "__muid_profile_func_tab";
+
+static constexpr const char kBBProfileTabPrefixStr[] = "__muid_prof_counter_tab";
+static constexpr const char kFuncIRProfInfTabPrefixStr[] = "__muid_prof_ir_desc_tab";
+
+static constexpr const char kBindingProtectedRegionStr[] = "__BindingProtectRegion__";
+
+static constexpr const char kClassNamePrefixStr[] = "L";
+static constexpr const char kClassMethodSplitterStr[] = "_3B";
+static constexpr const char kFuncGetCurrentCl[] = "MCC_GetCurrentClassLoader";
+// Serve as a global flag to indicate whether frequent strings have been compressed
+extern bool doCompression;
+
+// Return the input string if the compression is not on; otherwise, return its compressed version
+std::string GetInternalNameLiteral(std::string name);
+std::string GetOriginalNameLiteral(std::string name);
+
+std::string EncodeName(const std::string &name);
+std::string DecodeName(const std::string &name);
+void DecodeMapleNameToJavaDescriptor(const std::string &nameIn, std::string &nameOut);
+
+std::string NativeJavaName(const std::string &name, bool overLoaded = true);
+
+__attribute__((visibility("default"))) unsigned UTF16ToUTF8(std::string &str, const std::u16string &str16,
+                                                            unsigned short num = 0, bool isBigEndian = false);
+__attribute__((visibility("default"))) unsigned UTF8ToUTF16(std::u16string &str16, const std::string &str,
+                                                            unsigned short num = 0, bool isBigEndian = false);
+void GetUnsignedLeb128Encode(std::vector<uint8_t> &dest, uint32_t value);
+uint32_t GetUnsignedLeb128Decode(const uint8_t **data);
+uint64_t GetUleb128Encode(uint64_t val);
+uint64_t GetSleb128Encode(int64_t val);
+uint64_t GetUleb128Decode(uint64_t val);
+int64_t  GetSleb128Decode(uint64_t val);
+size_t GetUleb128Size(uint64_t val);
+size_t GetSleb128Size(int32_t val);
+bool NeedConvertUTF16(const std::string &str8);
+} // namespace namemangler
+
+#endif
diff --git a/src/mrt/compiler-rt/include/panic.h b/src/mrt/compiler-rt/include/panic.h
new file mode 100644
index 0000000000000000000000000000000000000000..6deb6c0840f3ef3df28b86e1a8630920f1d15552
--- /dev/null
+++ b/src/mrt/compiler-rt/include/panic.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_PANIC_H
+#define MAPLE_RUNTIME_PANIC_H
+
+#include <cstdlib>
+#include "mm_config.h"
+#include "mm_utils.h"
+
+
+extern "C" void abort_saferegister(void *addr);
+
+namespace maplert {
+void MRT_Panic() __attribute__((noreturn));
+
+// This macro controls all mrt debugging code
+// submodules might define their own debug macro; they should use the format:
+//   define SUBMODULE_DEBUG __MRT_DEBUG_COND_TRUE
+//   if you want to enable the submodule debugging code, or
+//   define SUBMODULE_DEBUG __MRT_DEBUG_COND_FALSE
+//   if you want to turn off the submodule debugging code
+//
+// explanation: __MRT_DEBUG_COND_FALSE is always false
+//              __MRT_DEBUG_COND_TRUE is only true when __MRT_DEBUG is true
+// have a look at ROSIMPL_ASSERT for example
+#if __MRT_DEBUG
+void __MRT_AssertBreakPoint() __attribute__((noinline));
+#define __MRT_DEBUG_COND_TRUE (true)
+#define __MRT_DEBUG_COND_FALSE (false)
+#ifdef __ANDROID__
+#define __MRT_ASSERT(p, msg)                                                 \
+  do {                                                                         \
+    if (!(p)) {                                                                \
+      LOG(ERROR) << __FILE__ << ":" << __LINE__ << ":" << msg << maple::endl;  \
+      maplert::__MRT_AssertBreakPoint();                                       \
+      maplert::MRT_Panic();                                                  \
+    }                                                                          \
+  } while (0)
+#define __MRT_ASSERT_ADDR(p, msg, addr)                                      \
+  do {                                                                         \
+    if (!(p)) {                                                                \
+      LOG(ERROR) << __FILE__ << ":" << __LINE__ << ":" << msg << maple::endl;  \
+      mapelrt::__MRT_AssertBreakPoint();                                       \
+      abort_saferegister(addr);                                                \
+    }                                                                          \
+  } while (0)
+#else
+#define __MRT_ASSERT(p, msg)                                                 \
+  do {                                                                         \
+    if (!(p)) {                                                                \
+      (void)printf("%s:%d:%s", __FILE__, __LINE__, msg);                       \
+      util::PrintBacktrace();                                       \
+      maplert::MRT_Panic();                                                  \
+    }                                                                          \
+  } while (0)
+#define __MRT_ASSERT_ADDR(p, msg, addr)                                      \
+  do {                                                                         \
+    if (!(p)) {                                                                \
+      (void)printf("%s:%d:%s", __FILE__, __LINE__, msg);                       \
+      util::PrintBacktrace();                                                  \
+      abort_saferegister(addr);                                                \
+    }                                                                          \
+  } while (0)
+#endif
+#define __MRT_UNUSED
+#define __MRT_CallAndAssertTrue(fcall, msg) __MRT_ASSERT(fcall, msg)
+#define __MRT_CallAndAssertFalse(fcall, msg) __MRT_ASSERT(!fcall, msg)
+#else
+#define __MRT_AssertBreakPoint()
+#define __MRT_DEBUG_COND_TRUE (false)
+#define __MRT_DEBUG_COND_FALSE (false)
+#define __MRT_ASSERT(p, msg)
+#define __MRT_UNUSED __attribute__((unused))
+#define __MRT_CallAndAssertTrue(fcall, msg) (void) fcall
+#define __MRT_CallAndAssertFalse(fcall, msg) (void) fcall
+#endif
+} // namespace maplert
+
+#endif // MAPLE_RUNTIME_PANIC_H
+
diff --git a/src/mrt/compiler-rt/include/profile.h b/src/mrt/compiler-rt/include/profile.h
new file mode 100644
index 0000000000000000000000000000000000000000..45370a44206c2f9ee753e0ac2c52e8affef15dce
--- /dev/null
+++ b/src/mrt/compiler-rt/include/profile.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_PROFILE_H
+#define MAPLE_RUNTIME_PROFILE_H
+
+#include <iostream>
+#include <string>
+
+#include "address.h"
+
+#define RECORD_FUNC_NAME 0
+
+namespace maplert {
+void DumpRCAndGCPerformanceInfo(std::ostream &os);
+void RecordMethod(uint64_t faddr, std::string &func, std::string &soname);
+bool CheckMethodResolved(uint64_t faddr);
+void DumpMethodUse(std::ostream &os);
+
+void RecordStaticField(address_t *addr, const std::string name);
+void DumpStaticField(std::ostream &os);
+void ClearFuncProfile();
+}
+
+#endif
diff --git a/src/mrt/compiler-rt/include/profile_type.h b/src/mrt/compiler-rt/include/profile_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..26e59216c34c8b5ac63a272c15d2b44ea76acb62
--- /dev/null
+++ b/src/mrt/compiler-rt/include/profile_type.h
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef PROFILE_TYPE_H
+#define PROFILE_TYPE_H
+
+static constexpr uint8_t kProfileMagic[] = { 'm', 'a', 'p', 'l', 'e', '.', 'p', 'r', 'o', 'f', 'i', 'l', 'e', '\0' };
+static constexpr uint8_t kVer[] = { 0, 0, 1 };
+
+enum ProfileFileType : uint8_t {
+  kSystemServer = 0x00,
+  kApp = 0x01
+};
+
+enum ProfileType : uint8_t {
+  kFunction = 0x00,
+  kClassMeta = 0x01,
+  kFieldMeta = 0x02,
+  kMethodMeta = 0x03,
+  kReflectionStr = 0x04,
+  kLiteral = 0x05,
+  kBBInfo = 0x06,
+  kIRCounter = 0x07,
+  kAll = 0x08,
+  kMethodSig = 0x09,
+  kFileDesc = 0xFF
+};
+
+enum FuncIRItemIndex : uint8_t {
+  kFuncIRItemNameIndex,
+  kCounterStartIndex,
+  kCounterEndIndex,
+  kHashIndex
+};
+
+enum FuncItemIndex : uint8_t {
+  kFuncItemNameIndex,
+  kFuncTypeIndex,
+  kFuncCallTimesIndex
+};
+
+enum FuncNameIndex : uint8_t {
+  kClassNameIndex,
+  kFuncNameIndex,
+  kSignatureNameIndex,
+};
+
+struct ProfileDataInfo {
+  uint32_t profileDataOff;
+  uint8_t profileType;
+  uint8_t mapleFileNum;
+  uint16_t pad = 0;
+  ProfileDataInfo() = default;
+  ProfileDataInfo(uint32_t profileDataOff, uint8_t profileType, uint8_t mapleFileNum)
+      : profileDataOff(profileDataOff), profileType(profileType), mapleFileNum(mapleFileNum) {}
+};
+
+struct FunctionItem {
+  uint32_t classIdx;
+  uint32_t methodIdx;
+  uint32_t sigIdx;
+  uint32_t callTimes;
+  uint8_t type;
+  FunctionItem(uint32_t classIdx, uint32_t methodIdx, uint32_t sigIdx, uint32_t callTimes, uint8_t type)
+      : classIdx(classIdx), methodIdx(methodIdx), sigIdx(sigIdx), callTimes(callTimes), type(type) {}
+};
+
+struct FunctionIRProfItem {
+  uint64_t hash;
+  uint32_t classIdx;
+  uint32_t methodIdx;
+  uint32_t sigIdx;
+  uint32_t counterStart;
+  uint32_t counterEnd;
+  FunctionIRProfItem(uint64_t hash, uint32_t classIdx, uint32_t methodIdx, uint32_t sigIdx, uint32_t start,
+      uint32_t end)
+      : hash(hash), classIdx(classIdx), methodIdx(methodIdx), sigIdx(sigIdx), counterStart(start), counterEnd(end) {}
+};
+
+struct FuncCounterItem {
+  uint32_t callTimes;
+  FuncCounterItem(uint32_t callTimes) : callTimes(callTimes) {}
+};
+
+struct MetaItem {
+  uint32_t idx;
+  MetaItem(uint32_t idx) : idx(idx) {}
+};
+
+struct MethodSignatureItem {
+  uint32_t methodIdx;
+  uint32_t sigIdx;
+  MethodSignatureItem(uint32_t methodIdx, uint32_t sigIdx) : methodIdx(methodIdx), sigIdx(sigIdx) {}
+};
+
+struct ReflectionStrItem {
+  uint8_t type;
+  uint32_t idx;
+  ReflectionStrItem(uint32_t idx, uint8_t type) : type(type), idx(idx) {}
+};
+
+struct MapleFileProf {
+  uint32_t idx;
+  uint32_t num;
+  uint32_t size;
+  MapleFileProf(uint32_t idx, uint32_t num, uint32_t size) : idx(idx), num(num), size(size) {}
+};
+
+constexpr int kMagicNum = 14;
+constexpr int kVerNum = 3;
+constexpr int kCheckSumNum = 4;
+struct Header {
+  uint8_t magic[kMagicNum] = {};
+  uint8_t ver[kVerNum] = {};
+  uint8_t checkSum[kCheckSumNum] = {};
+  uint8_t profileNum = 0;
+  uint8_t profileFileType = 0;
+  uint8_t pad = 0;
+  uint32_t headerSize = 0;
+  uint32_t stringCount = 0;
+  uint32_t stringTabOff = 0;
+  ProfileDataInfo data[1] = {}; // profile data info detemined by runtime
+};
+
+#endif
diff --git a/src/mrt/compiler-rt/include/saferegion.h b/src/mrt/compiler-rt/include/saferegion.h
new file mode 100644
index 0000000000000000000000000000000000000000..d4144f2b90f924480ff14b77c79292f8b040afe3
--- /dev/null
+++ b/src/mrt/compiler-rt/include/saferegion.h
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_SAFEREGION_H
+#define MAPLE_RUNTIME_SAFEREGION_H
+
+#include "tls_store.h"
+#include "collector/collector.h"
+#include "mrt_exception_api.h"
+
+const uint64_t kSafeRegionStateMagic1 = 0x1122334455667788;
+const uint64_t kSafeRegionStateMagic2 = 0x8877665544332211;
+
+// Saferegion inline functions
+namespace maplert {
+// CurrentMutator() is similar to TLMutator() but
+// returns TLS mutator with the base class.
+// we can use this function to avoid unnecessary dependence.
+static inline Mutator &CurrentMutator() {
+  return *(reinterpret_cast<Mutator*>(maple::tls::GetTLS(maple::tls::kSlotMutator)));
+}
+
+static inline Mutator *CurrentMutatorPtr() {
+  if (LIKELY(maple::tls::HasTLS())) {
+    return reinterpret_cast<Mutator*>(maple::tls::GetTLS(maple::tls::kSlotMutator));
+  }
+  return nullptr;
+}
+
+// The global saferegion state.
+class SaferegionState {
+ public:
+  uint64_t magic1 = kSafeRegionStateMagic1;
+  union {
+    struct {
+      // we assume little endian.
+      uint32_t saferegionCount; // number of mutators in saferegion.
+      uint32_t pendingCount; // number of mutators pending for stop.
+    } asStruct;
+    std::atomic<uint64_t> asAtomic;
+    uint64_t asUint64;
+  };
+  uint64_t magic2 = kSafeRegionStateMagic2;
+
+  // default ctor (value is undefined).
+  __attribute__((always_inline))
+  SaferegionState() = default;
+
+  __attribute__((always_inline))
+  ~SaferegionState() = default;
+
+  // init with value.
+  __attribute__((always_inline))
+  explicit SaferegionState(uint64_t value) : asUint64(value) {}
+
+  // copy ctor.
+  __attribute__((always_inline))
+  SaferegionState(const SaferegionState &state) : asUint64(state.asUint64) {}
+
+  // copy assign.
+  __attribute__((always_inline))
+  SaferegionState &operator=(const SaferegionState &state) {
+    asUint64 = state.asUint64;
+    return *this;
+  }
+
+  // we treat all mutator stopped when pendingCount == saferegionCount.
+  __attribute__((always_inline))
+  inline bool AllMutatorStopped() const {
+    return asStruct.pendingCount == asStruct.saferegionCount;
+  }
+
+  // static functions
+  __attribute__((always_inline))
+  static inline int *SaferegionCountAddr() {
+    return reinterpret_cast<int*>(&instance.asStruct.saferegionCount);
+  }
+
+  __attribute__((always_inline))
+  static inline int *PendingCountAddr() {
+    return reinterpret_cast<int*>(&instance.asStruct.pendingCount);
+  }
+
+  // Atomic load saferegion state.
+  __attribute__((always_inline))
+  static inline SaferegionState Load() {
+    instance.CheckMagic();
+    return SaferegionState(instance.asAtomic.load(std::memory_order_acquire));
+  }
+
+  // Set pending count by CAS, return the old saferegion state.
+  __attribute__((always_inline))
+  static inline SaferegionState SetPendingCount(uint32_t pendingCount) {
+    SaferegionState newState;
+    uint64_t oldState = instance.asAtomic.load(std::memory_order_relaxed);
+    do {
+      newState.asUint64 = oldState;
+      newState.asStruct.pendingCount = pendingCount;
+    } while (!SaferegionState::instance.asAtomic.compare_exchange_weak(oldState, newState.asUint64,
+        std::memory_order_release, std::memory_order_relaxed));
+    return SaferegionState(oldState);
+  }
+
+  // Atomic Inc saferegion count, return the old saferegion state.
+  __attribute__((always_inline))
+  static inline SaferegionState IncSaferegionCount() {
+    instance.CheckMagic();
+    uint64_t oldState = instance.asAtomic.fetch_add(1, std::memory_order_release);
+    return SaferegionState(oldState);
+  }
+
+  // Atomic Dec saferegion count, return the old saferegion state.
+  __attribute__((always_inline))
+  static inline SaferegionState DecSaferegionCount() {
+    instance.CheckMagic();
+    uint64_t oldState = instance.asAtomic.fetch_sub(1, std::memory_order_release);
+    return SaferegionState(oldState);
+  }
+
+ private:
+  // global instance of saferegion state.
+  MRT_EXPORT static SaferegionState instance;
+
+  __attribute__((always_inline))
+  inline void CheckMagic() {
+    if (UNLIKELY(magic1 != kSafeRegionStateMagic1 || magic2 != kSafeRegionStateMagic2)) {
+      CheckMagicFailed();
+    }
+  }
+
+  MRT_EXPORT void CheckMagicFailed();
+};
+
+// slow path of enter saferegion.
+MRT_EXPORT void EnterSaferegionSlowPath();
+
+// slow path of leave saferegion.
+MRT_EXPORT void LeaveSaferegionSlowPath();
+
+MRT_EXPORT void StackScanBarrierSlowPath();
+
+// Force this mutator enter saferegion, internal use only.
+inline void Mutator::DoEnterSaferegion() {
+#if __MRT_DEBUG
+  if (UNLIKELY(!IsActive())) {
+    LOG(FATAL) << "DoEnterSaferegion on inactive mutator" << maple::endl;
+  }
+#endif
+
+  // increase saferegionCount and load pendingCount.
+  SaferegionState state = SaferegionState::IncSaferegionCount();
+
+  // let inc saferegionCount visible when we see saferegion state set to true.
+  std::atomic_thread_fence(std::memory_order_release);
+
+  // set current mutator in saferegion.
+  SetInSaferegion(true);
+
+  // compare old saferegionCount and pendingCount.
+  if (UNLIKELY(state.asStruct.saferegionCount + 1 == state.asStruct.pendingCount)) {
+    // slow path:
+    // if this is the last mutator entering saferegion, wakeup StopTheWorld().
+    EnterSaferegionSlowPath();
+  }
+}
+
+// Force this mutator leave saferegion, internal use only.
+inline void Mutator::DoLeaveSaferegion() {
+#if __MRT_DEBUG
+  if (UNLIKELY(!IsActive())) {
+    LOG(FATAL) << "DoLeaveSaferegion on inactive mutator" << maple::endl;
+  }
+#endif
+
+  // decrease saferegion count and load pendingCount.
+  SaferegionState state = SaferegionState::DecSaferegionCount();
+  // go slow path if pendingCount is set.
+  if (UNLIKELY(state.asStruct.pendingCount != 0)) {
+    // slow path:
+    // pendingCount is set, this means the world is stopping
+    // or stoppped, we should block until the world start.
+    LeaveSaferegionSlowPath();
+  }
+
+  // set in_saferegion flag to false.
+  SetInSaferegion(false);
+
+  // check if need to help gc thread to do stack scan
+  StackScanBarrier();
+}
+
+// Let this mutator enter saferegion.
+inline bool Mutator::EnterSaferegion(bool rememberLastJavaFrame) {
+  // if mutator not in saferegion.
+  if (LIKELY(!InSaferegion())) {
+    // save current stack pointer as the stack scan end pointer.
+    void *stackPointer = nullptr;
+    __asm__ volatile ("mov %0, sp" : "=r" (stackPointer));
+    SaveStackEnd(stackPointer);
+
+    if (rememberLastJavaFrame) {
+      const uint32_t *ip = reinterpret_cast<const uint32_t*>(__builtin_return_address(0)); // caller pc
+      CallChain *fa = reinterpret_cast<CallChain*>(__builtin_frame_address(0))->callerFrameAddress; // caller frame
+      MRT_UpdateLastUnwindContextIfReliable(ip, fa);
+    }
+
+    // let mutator enter saferegion.
+    DoEnterSaferegion();
+    // mutator in_saferegion state changed.
+    return true;
+  }
+  // mutator in_saferegion state not changed.
+  return false;
+}
+
+// Let this mutator leave saferegion.
+inline bool Mutator::LeaveSaferegion() {
+  // if mutator in saferegion.
+  if (LIKELY(InSaferegion())) {
+    // let mutator leave saferegion.
+    DoLeaveSaferegion();
+    // mutator in_saferegion state changed.
+    return true;
+  }
+  // mutator in_saferegion state not changed.
+  return false;
+}
+
+inline void Mutator::StackScanBarrier() {
+  if (scanState.load() != kFinishScan) {
+    StackScanBarrierSlowPath();
+  }
+}
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/sizes.h b/src/mrt/compiler-rt/include/sizes.h
new file mode 100644
index 0000000000000000000000000000000000000000..5cc6b14ff95f90140016494c8866cfcf58a18d75
--- /dev/null
+++ b/src/mrt/compiler-rt/include/sizes.h
@@ -0,0 +1,738 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_SIZES_H
+#define MAPLE_RUNTIME_SIZES_H
+
+#include <cstdlib>
+#include <cstdint>
+#include <cstddef>
+#include <atomic>
+
+#ifdef OBJSCAN_DEBUG
+#include <cstdio>
+#include <cinttypes>
+#endif
+
+#include "thread_offsets.h"
+#include "mm_utils.h"
+#include "address.h"
+#include "chelper.h"
+#include "exception/mrt_exception.h"
+
+namespace maplert {
+// Paranoid assertions. Please find clues in language specifications or ABIs
+// that these predicates must hold.
+#if defined(__aarch64__)
+static_assert(sizeof(uint64_t) == sizeof(size_t),
+    "size_t does not have the same size as uint64_t. We are probably not "
+    "working on a 64-bit platform.");
+
+static_assert(sizeof(int64_t) == sizeof(ssize_t),
+    "ssize_t does not have the same size as int64_t. We are probably not "
+    "working on a 64-bit platform.");
+#elif defined(__arm__)
+static_assert(sizeof(uint32_t) == sizeof(size_t),
+    "size_t does not have the same size as uint32_t. We are probably not "
+    "working on a 32-bit platform.");
+
+static_assert(sizeof(int32_t) == sizeof(ssize_t),
+    "ssize_t does not have the same size as int32_t. We are probably not "
+    "working on a 64-bit platform.");
+#endif
+
+static_assert(sizeof(uintptr_t) == sizeof(size_t),
+    "size_t does not have the same size as uintptr_t.");
+
+static_assert(sizeof(intptr_t) == sizeof(ssize_t),
+    "ssize_t does not have the same size as intptr_t.");
+
+// AArch64-specific sizes.
+const size_t kHWordBytes = 2;
+const size_t kWordBytes = 4;
+const size_t kDWordBytes = 8;
+const size_t kQWordBytes = 16;
+
+#if CONFIG_JSAN
+const int kJsanHeaderSize = kDWordBytes;
+
+const offset_t kOffsetJsanHeader = -(kDWordBytes + kDWordBytes);
+const offset_t kOffsetObjStatus = -(kDWordBytes + kWordBytes);
+
+static constexpr uint32_t kObjMagic = 0xabcabcab;
+static constexpr uint32_t kObjStatusUnknown = 0x0;
+static constexpr uint32_t kObjStatusAllocated = 0x1;
+static constexpr uint32_t kObjStatusQuarantined = 0x2;
+
+static inline void JSANSetAllocated(address_t objAddr) {
+  *reinterpret_cast<uint32_t*>(objAddr + kOffsetJsanHeader) = kObjMagic;
+  *reinterpret_cast<uint32_t*>(objAddr + kOffsetObjStatus) = kObjStatusAllocated;
+}
+
+static inline void JSANSetQuarantined(address_t objAddr) {
+  *reinterpret_cast<uint32_t*>(objAddr + kOffsetObjStatus) = kObjStatusQuarantined;
+}
+
+static inline void JSANSetFreed(address_t objAddr) {
+  *reinterpret_cast<uint32_t*>(objAddr + kOffsetJsanHeader) = 0;
+  *reinterpret_cast<uint32_t*>(objAddr + kOffsetObjStatus) = kObjStatusUnknown;
+}
+
+static inline bool JSANIsValidObjAddress(address_t objAddr) {
+  return *reinterpret_cast<uint32_t*>(objAddr + kOffsetJsanHeader) == kObjMagic;
+}
+
+static inline uint32_t JSANGetObjStatus(address_t objAddr) {
+  if (!JSANIsValidObjAddress(objAddr)) {
+    return kObjStatusUnknown;
+  }
+  return *reinterpret_cast<uint32_t*>(objAddr + kOffsetObjStatus);
+}
+#else
+const int kJsanHeaderSize = 0;
+#endif
+
+#if RC_HOT_OBJECT_DATA_COLLECT
+const size_t kTrackFrameNum = 4;
+const size_t kRcHotHeaderSize = kDWordBytes + kDWordBytes * kTrackFrameNum;
+
+// The offset of the RC Operation count field.
+const offset_t kOffsetRcOperationCount = -(kWordBytes + kDWordBytes);
+
+// The offset of the GC count field.
+const offset_t kOffsetGcCountCount = -(kDWordBytes + kDWordBytes);
+
+const offset_t kOffsetTrackPC = -(kDWordBytes + kDWordBytes + kDWordBytes * kTrackFrameNum);
+
+static inline uint32_t RCOperationCount(address_t objAddr) {
+  return (*reinterpret_cast<uint32_t*>(objAddr + kOffsetRcOperationCount));
+}
+
+static inline uint32_t GCCount(address_t objAddr) {
+  return (*reinterpret_cast<uint32_t*>(objAddr + kOffsetGcCountCount));
+}
+
+static inline std::atomic<uint32_t> &RCOperationCountAtomicLVal(address_t objAddr) {
+  return AddrToLValAtomic<uint32_t>(objAddr + kOffsetRcOperationCount);
+}
+
+static inline std::atomic<uint32_t> &GCCountAtomicLVal(address_t objAddr) {
+  return AddrToLValAtomic<uint32_t>(objAddr + kOffsetGcCountCount);
+}
+
+extern std::atomic<uint64_t> totalSkipedRCOpCount;
+extern std::atomic<uint64_t> totalRCOperationCount;
+
+static inline bool IsRCSkiped(address_t obj);
+
+static inline void StatsRCOperationCount(address_t obj) {
+  totalRCOperationCount.fetch_add(1, memory_order_relaxed);
+  if (IsRCSkiped(obj)) {
+    totalSkipedRCOpCount.fetch_add(1, memory_order_relaxed);
+  } else {
+    if (RCOperationCount(obj) < std::numeric_limits<uint32_t>::max()) {
+      RCOperationCountAtomicLVal(obj).fetch_add(1, memory_order_relaxed);
+    }
+  }
+}
+
+inline void StatsGCCount(address_t obj) {
+  if (GCCount(obj) < std::numeric_limits<uint32_t>::max()) {
+    GCCountAtomicLVal(obj).fetch_add(1, memory_order_relaxed);
+  }
+}
+#else
+const int kRcHotHeaderSize = 0;
+#define StatsRCOperationCount(obj)
+#endif
+
+// Heap object header size.
+const size_t kHeaderSize = kDWordBytes + kJsanHeaderSize + kRcHotHeaderSize;
+
+// The offset of the reference count field.
+const offset_t kOffsetRefCount = -kWordBytes;
+// The offset of the GC header.
+const offset_t kOffsetGCHeader = -kDWordBytes;
+
+// Object Header bits
+// Total 64 bit, split int two 32 bits word (RC Header/GC Header)
+// RC Header: record reference counting
+// GC Header: record misc informations: attributes, GCITB prototypes
+//
+// RC Header
+// [15 -  0]  Strong RC
+// [21 - 16]  Resurrectable Weak RC: soft/weak/global weak reference
+// [28 - 22]  Weak RC: phantom reference/weak annotation
+// [29 - 29]  Weak Collected
+// [31 - 30]  RC Cycle Collect Color
+//
+// Strong RC: normal references like: stack reference\normal field
+// reference\runtime reference(string table, classloader table, ..).
+// In normals case object can be release when its Strong RC reach zero.
+// If Weak RC is not zero, object release processing is differently
+// according to Weak RC's type.
+//
+// Weak RC: If Object has Weak RC, it comes from phantom reference or
+// @weak annotation. Object can be relased immedidately when Strong RC is zero
+// while Weak RC not zero.
+//
+// Resurrectable Weak RC: special weak reference from soft/weak/weak global
+// reference. Object can not be relased immedidately when Strong RC is zero
+// while Resurrectable Weak RC not zero. Because these reference has cache
+// semantic and need be resurrect with Reference.get(). Object with Resurrectable
+// Weak RC is collected periodically in reference processor thread.
+//
+// Weak Collected: If set, weak reference to this object in invalidated.
+// Reference.get returns null.
+//
+// RC Cycle Collect Color: Color used in Cycle pattern. Color is atmoiclly set
+// and checked to avoiding racing condition in cycle pattern match and mutator
+// operations.
+//
+static constexpr uint32_t kRCBits = 0x0000ffff;
+static constexpr uint32_t kRCBitsMsb = 0x00008000;
+
+static constexpr uint32_t kResurrectWeakRcBits = 0x003f0000;
+static constexpr uint32_t kResurrectWeakOneBit = 0x00010000;
+static constexpr uint32_t KResurrectWeakRcBitsShift = 16;
+static constexpr uint32_t kMaxResurrectWeakRC = kResurrectWeakRcBits >> KResurrectWeakRcBitsShift;
+
+
+static constexpr uint32_t kWeakRcBits = 0x1fc00000;
+static constexpr uint32_t kWeakRCOneBit = 0x00400000;
+static constexpr uint32_t kWeakRcBitsShift = 22;
+static constexpr uint32_t kMaxWeakRC = kWeakRcBits >> kWeakRcBitsShift;
+
+static constexpr uint32_t kWeakCollectedBit = 0x20000000;
+
+static constexpr uint32_t kRCCycleColorMask = 0xc0000000;
+static constexpr uint32_t kRCCycleColorBlack = 0x00000000;
+static constexpr uint32_t kRCCycleColorGray = 0x40000000;
+static constexpr uint32_t kRCCycleColorWhite = 0x80000000;
+static constexpr uint32_t kRCCycleColorBrown = 0xc0000000; // color for decref, just for debug
+
+// GC Header
+// [0] Allocated:   Flag to tell if the object is allocated *by the allocator*
+// [1] Dirty:       Tracing queued bit used in cocurrent marking
+// [2] Release:     RC released object during backup tracing concurrent marking
+// [3] RCTracing:   Object with this bit, all inc/dec will be traced, debug only
+// [4] WrapWeakRef: Object need be put into a weak reference for periodlly dead check.
+// [5] HasChildRef: Object has reference to other object.
+// ...
+// [20]      ReferenceActive: Reference is recently get, used in reference processor
+// [21]      EnqueuedFinalizable: debug only, finalizalbe object is eqneued
+// [22]      Array:       Object is array
+// [23]      Reference:   Object is reference type
+// [24]      Finalizable: Object is finalizable
+// [27-25]   Cycle pattern RC min value
+// [30-28]   Cycle pattern RC max value
+// [31] Cycle pattern: Object with this bit is candiate for cycle collection
+//
+// The bottom three bits of GCHeader(obj) are used for color.
+// NOTE: Only used by cycle detection, not mark-sweep.
+//
+// Bit for flags word (-8 offset)
+static constexpr uint32_t kAllocatedBit = 0x1;
+static constexpr uint32_t kDirtyBit = 0x2; // set if child refs modified during concurrent marking.
+static constexpr uint32_t kReleasedBit = 0x4; // set if freed during concurrent marking.
+static constexpr uint32_t kRCTracingBit = 0x8;
+static constexpr uint32_t kHasChildRef = 0x40; // object has no child reference, need update compiler
+static constexpr uint32_t kMygoteObjBit = 0x80; // object is mygote object, no free, likely immutable
+
+static constexpr uint32_t kReferenceActiveBit = 0x00100000; // mark if reference is got recently and clear in rp
+static constexpr uint32_t kEnqueuedFinalizableBit = 0x00200000;
+static constexpr uint32_t kArrayBit = 0x00400000;
+static constexpr uint32_t kReferenceBit = 0x00800000;
+static constexpr uint32_t kFinalizableBit = 0x01000000;
+static constexpr uint32_t kCycleRCMinMask = 0x0e000000;
+static constexpr uint32_t kCycleRCMaxMask = 0x70000000;
+static constexpr uint32_t kCyclePatternBit = 0x80000000;
+
+static constexpr uint32_t kCycleRCMinShift = 25;
+static constexpr uint32_t kCycleRCMaxShift = 28;
+#define CYCLE_MIN_RC(header) (((static_cast<uint32_t>(header)) & kCycleRCMinMask) >> kCycleRCMinShift)
+#define CYCLE_MAX_RC(header) (((static_cast<uint32_t>(header)) & kCycleRCMaxMask) >> kCycleRCMaxShift)
+
+// ------------------------------------------------------------------
+// About kHasChildRef and kArrayBit:
+//                             kHasChildRef    kArrayBit
+// object without child ref        0              0
+// object with child ref           1              0
+// primitive array                 0              1
+// object array                    1              1
+// ------------------------------------------------------------------
+const size_t kJavaObjAlignment = kDWordBytes;
+
+// Array content is 8 bytes align for long/double array type
+const offset_t kJavaArrayLengthOffset = 12; // shadow + monitor + [padding], fixed.
+const offset_t kJavaArrayContentOffset = 16; // fixed for 8B alignment
+
+struct DecoupleAllocHeader {
+  using FieldType = uint32_t;
+  FieldType size;
+  FieldType tag;
+  // Object  header align to 8 , header align to 8 too
+  static constexpr size_t kHeaderSize = 8;
+  static constexpr size_t kSizeOffset = kHeaderSize;
+  static constexpr size_t kTagOffset = kHeaderSize - sizeof(FieldType);
+
+#if defined(__aarch64__)
+  static constexpr size_t kMaxSize = (1UL << 32); // 4GB
+#elif defined(__arm__)
+  static constexpr size_t kMaxSize = (1UL << 31); // lower 2GB address space
+#endif
+
+  static inline size_t GetSize(address_t objAddr) {
+    return static_cast<size_t>(*reinterpret_cast<FieldType*>(objAddr - kSizeOffset));
+  }
+
+  static inline void SetSize(address_t objAddr, size_t size) {
+    *reinterpret_cast<FieldType*>(objAddr - kSizeOffset) = static_cast<FieldType>(size);
+  }
+
+  static inline int GetTag(address_t objAddr) {
+    return static_cast<int>(*reinterpret_cast<FieldType*>(objAddr - kTagOffset));
+  }
+
+  static inline void SetTag(address_t objAddr, int tag) {
+    *reinterpret_cast<FieldType*>(objAddr - kTagOffset) = static_cast<FieldType>(tag);
+  }
+
+  static inline void SetHeader(address_t objAddr, int tag, size_t size) {
+    SetTag(objAddr, tag);
+    SetSize(objAddr, size);
+  }
+};
+
+#define HEADER_CHECK_VALID_HEAP_OBJECT __MRT_DEBUG_COND_FALSE
+#if HEADER_CHECK_VALID_HEAP_OBJECT
+static inline void CheckValidHeapObject(address_t obj) {
+  if (!IS_HEAP_OBJ(obj)) {
+    LOG(FATAL) << "invalid heap obj addr: " << std::hex << obj << maple::endl;
+  }
+}
+#define CHECK_HEADER_VALID_OBJ(obj) CheckValidHeapObject(obj)
+#else
+#define CHECK_HEADER_VALID_OBJ(obj)
+#endif
+
+// Accessors to Java array-specific fields
+static inline uint32_t &ArrayLength(address_t objAddr) {
+  return AddrToLVal<uint32_t>(objAddr + kJavaArrayLengthOffset);
+}
+
+// Accessors for gctib pointer from class metadata
+static inline address_t GCTibPtr(address_t objAddr) {
+  CHECK_HEADER_VALID_OBJ(objAddr);
+  return reinterpret_cast<address_t>(MObject::Cast<MObject>(objAddr)->GetClass()->GetGctib());
+}
+
+static inline GCTibGCInfo &GCInfo(address_t objAddr) {
+  CHECK_HEADER_VALID_OBJ(objAddr);
+  return AddrToLVal<struct GCTibGCInfo>(GCTibPtr(objAddr));
+}
+
+static inline uint32_t GCHeader(address_t objAddr) {
+  CHECK_HEADER_VALID_OBJ(objAddr);
+  return *reinterpret_cast<uint32_t*>(objAddr + kOffsetGCHeader);
+}
+
+static inline uint32_t &GCHeaderLVal(address_t objAddr) {
+  CHECK_HEADER_VALID_OBJ(objAddr);
+  return AddrToLVal<uint32_t>(objAddr + kOffsetGCHeader);
+}
+
+static inline std::atomic<uint32_t> &GCHeaderAtomic(address_t objAddr) {
+  CHECK_HEADER_VALID_OBJ(objAddr);
+  return AddrToLValAtomic<uint32_t>(objAddr + kOffsetGCHeader);
+}
+
+static inline void SetGCHeader(address_t objAddr, uint32_t val) {
+  CHECK_HEADER_VALID_OBJ(objAddr);
+  uint32_t *gcHeaderAddr = reinterpret_cast<uint32_t*>(objAddr + kOffsetGCHeader);
+  *gcHeaderAddr = val;
+}
+
+static inline uint32_t RCHeader(address_t objAddr) {
+  CHECK_HEADER_VALID_OBJ(objAddr);
+  return *reinterpret_cast<uint32_t*>(objAddr + kOffsetRefCount);
+}
+
+static inline uint32_t GetRCFromRCHeader(uint32_t rcHeader) {
+  return rcHeader & kRCBits;
+}
+
+static inline uint32_t GetResurrectWeakRCFromRCHeader(uint32_t rcHeader) {
+  return (rcHeader & kResurrectWeakRcBits) >> KResurrectWeakRcBitsShift;
+}
+
+static inline uint32_t GetWeakRCFromRCHeader(uint32_t rcHeader) {
+  return (rcHeader & kWeakRcBits) >> kWeakRcBitsShift;
+}
+
+static inline uint32_t GetTotalWeakRCFromRCHeader(uint32_t rcHeader) {
+  return (rcHeader & (kWeakRcBits | kResurrectWeakRcBits));
+}
+
+static inline uint32_t GetTotalRCFromRCHeader(uint32_t rcHeader) {
+  return (rcHeader & (kWeakRcBits | kResurrectWeakRcBits | kRCBits));
+}
+
+static inline bool IsWeakCollectedFromRCHeader(uint32_t rcHeader) {
+  return (rcHeader & kWeakCollectedBit) != 0;
+}
+
+static inline bool IsRCCollectableFromRCHeader(uint32_t rcHeader) {
+  uint32_t totalRC = GetTotalRCFromRCHeader(rcHeader);
+  return (totalRC == 0) || ((totalRC == kWeakRCOneBit) && !IsWeakCollectedFromRCHeader(rcHeader));
+}
+
+static inline uint32_t RefCount(address_t obj) {
+  CHECK_HEADER_VALID_OBJ(obj);
+  return GetRCFromRCHeader(RCHeader(obj));
+}
+
+static inline uint32_t ResurrectWeakRefCount(address_t obj) {
+  CHECK_HEADER_VALID_OBJ(obj);
+  return GetResurrectWeakRCFromRCHeader(RCHeader(obj));
+}
+
+static inline uint32_t WeakRefCount(address_t obj) {
+  CHECK_HEADER_VALID_OBJ(obj);
+  return GetWeakRCFromRCHeader(RCHeader(obj));
+}
+
+static inline uint32_t TotalRefCount(address_t obj) {
+  CHECK_HEADER_VALID_OBJ(obj);
+  return GetTotalRCFromRCHeader(RCHeader(obj));
+}
+
+static inline uint32_t TotalWeakRefCount(address_t obj) {
+  CHECK_HEADER_VALID_OBJ(obj);
+  return GetTotalWeakRCFromRCHeader(RCHeader(obj));
+}
+
+static inline bool IsRCCollectable(address_t obj) {
+  CHECK_HEADER_VALID_OBJ(obj);
+  return IsRCCollectableFromRCHeader(RCHeader(obj));
+}
+
+static inline bool IsWeakCollected(address_t obj) {
+  CHECK_HEADER_VALID_OBJ(obj);
+  return IsWeakCollectedFromRCHeader(RCHeader(obj));
+}
+
+static inline uint32_t& RefCountLVal(address_t objAddr) {
+  CHECK_HEADER_VALID_OBJ(objAddr);
+  return AddrToLVal<uint32_t>(objAddr + kOffsetRefCount);
+}
+
+static inline std::atomic<uint32_t>& RefCountAtomicLVal(address_t objAddr) {
+  CHECK_HEADER_VALID_OBJ(objAddr);
+  return AddrToLValAtomic<uint32_t>(objAddr + kOffsetRefCount);
+}
+
+// quickly check if need check cycle pattern for this object
+// 1. has cycle pattern
+// 2. rc in range
+static inline bool IsValidForCyclePatterMatch(uint32_t rcFlags, uint32_t curRC) {
+  return (rcFlags & kCyclePatternBit) && (curRC <= CYCLE_MAX_RC(rcFlags)) && (curRC >= CYCLE_MIN_RC(rcFlags));
+}
+
+static inline void ClearCyclePatternBit(address_t objAddr) {
+  (void)GCHeaderAtomic(objAddr).fetch_and((~kCyclePatternBit), std::memory_order_release);
+}
+
+static inline uint32_t SetCycleMaxRC(uint32_t oldRcFlags, uint32_t max) {
+  return (oldRcFlags & ~kCycleRCMaxMask) | (max << kCycleRCMaxShift);
+}
+
+static inline uint32_t SetCycleMinRC(uint32_t oldRcFlags, uint32_t min) {
+  return (oldRcFlags & ~kCycleRCMinMask) | (min << kCycleRCMinShift);
+}
+
+static inline void InitWithAllocatedBit(address_t objAddr) {
+  GCHeaderLVal(objAddr) = kAllocatedBit;
+}
+
+static inline void ClearAllocatedBit(address_t objAddr) {
+  GCHeaderLVal(objAddr) &= ~kAllocatedBit;
+}
+
+static inline bool IsAllocatedByAllocator(address_t objAddr) {
+  return (GCHeader(objAddr) & kAllocatedBit) != 0;
+}
+
+static inline bool IsDirty(address_t objAddr) {
+  uint32_t header = GCHeaderAtomic(objAddr).load(std::memory_order_acquire);
+  return (header & kDirtyBit) != 0;
+}
+
+static inline void SetDirty(address_t objAddr) {
+  (void)GCHeaderAtomic(objAddr).fetch_or(kDirtyBit, std::memory_order_release);
+}
+
+static inline void ClearDirtyBit(address_t objAddr) {
+  // this is called when the world is stopped, so no need atomic.
+  GCHeaderLVal(objAddr) &= (~kDirtyBit);
+}
+
+static inline void SetReleasedBit(address_t objAddr) {
+  (void)GCHeaderAtomic(objAddr).fetch_or(kReleasedBit, std::memory_order_release);
+}
+
+static inline bool HasReleasedBit(address_t objAddr) {
+  return (GCHeader(objAddr) & kReleasedBit) != 0;
+}
+
+static inline void SetMygoteBit(address_t objAddr) {
+  GCHeaderLVal(objAddr) |= kMygoteObjBit; // not clearable
+}
+
+static inline bool IsMygoteObj(address_t objAddr) {
+  return (GCHeader(objAddr) & kMygoteObjBit) != 0;
+}
+
+static inline void SetReferenceActive(address_t objAddr) {
+  if (!IsMygoteObj(objAddr)) {
+    GCHeaderLVal(objAddr) |= kReferenceActiveBit;
+  }
+}
+
+static inline void ClearReferenceActive(address_t objAddr) {
+  if (!IsMygoteObj(objAddr)) {
+    GCHeaderLVal(objAddr) &= ~(kReferenceActiveBit);
+  }
+}
+
+static inline bool IsReferenceActive(address_t objAddr) {
+  return (GCHeader(objAddr) & kReferenceActiveBit) != 0;
+}
+
+static inline void SetObjFinalizable(address_t objAddr) {
+  // should be set once at creation time.
+  GCHeaderLVal(objAddr) |= kFinalizableBit;
+}
+
+static inline void SetEnqueuedObjFinalizable(address_t objAddr) {
+  (void)GCHeaderAtomic(objAddr).fetch_or(kEnqueuedFinalizableBit, std::memory_order_relaxed);
+}
+
+static inline void ClearObjFinalizable(address_t objAddr) {
+  // should be cleared only by FinalizerThread
+  (void)GCHeaderAtomic(objAddr).fetch_and(~(kFinalizableBit | kEnqueuedFinalizableBit), std::memory_order_relaxed);
+}
+
+static inline bool IsEnqueuedObjFinalizable(address_t objAddr) {
+  return (GCHeader(objAddr) & kEnqueuedFinalizableBit) != 0;
+}
+
+static inline bool IsObjFinalizable(address_t objAddr) {
+  return (GCHeader(objAddr) & kFinalizableBit) != 0;
+}
+
+static inline bool IsObjResurrectable(address_t objAddr) {
+  return IsObjFinalizable(objAddr) && !IsEnqueuedObjFinalizable(objAddr);
+}
+
+// Trace Bit is settting for debugging and trace object life cycle
+static inline void SetTraceBit(address_t objAddr) {
+  (void)GCHeaderAtomic(objAddr).fetch_or(kRCTracingBit, std::memory_order_relaxed);
+}
+
+static inline void ClearTraceBit(address_t objAddr) {
+  (void)GCHeaderAtomic(objAddr).fetch_and((~kRCTracingBit), std::memory_order_relaxed);
+}
+
+static inline bool IsTraceObj(address_t objAddr) {
+  if (!IS_HEAP_OBJ(objAddr)) {
+    return false;
+  }
+  if (TotalRefCount(objAddr) == 0) {
+    return false;
+  }
+  return (GCHeader(objAddr) & kRCTracingBit) != 0;
+}
+
+static inline bool HasChildRef(address_t objAddr) {
+  return (GCHeader(objAddr) & kHasChildRef) != 0;
+}
+
+static inline void SetObjReference(address_t objAddr) {
+  GCHeaderLVal(objAddr) |= kReferenceBit;;
+}
+
+static inline bool IsObjReference(address_t objAddr) {
+  return (GCHeader(objAddr) & kReferenceBit) != 0;
+}
+
+static inline bool IsArray(address_t objAddr) {
+  return (GCHeader(objAddr) & kArrayBit) != 0;
+}
+
+static inline bool IsObjectArray(address_t objAddr) {
+  return (GCHeader(objAddr) & (kArrayBit | kHasChildRef)) == (kArrayBit | kHasChildRef);
+}
+
+static inline bool SkipRC(uint32_t rcHeader) {
+  return (rcHeader & kRCBitsMsb) != 0;
+}
+
+static inline bool IsRCOverflow(uint32_t rc) {
+  return SkipRC(rc);
+}
+
+static inline bool IsRCSkiped(address_t obj) {
+  CHECK_HEADER_VALID_OBJ(obj);
+  return SkipRC(RCHeader(obj));
+}
+
+static inline void SetRCOverflow(address_t objAddr) {
+  if (!IsRCSkiped(objAddr)) {
+    RefCountLVal(objAddr) |= kRCBitsMsb;
+  }
+}
+
+extern "C" {
+extern void MRT_BuiltinAbortSaferegister(maple::address_t addr, const char *clsName);
+}
+
+#ifdef __ANDROID__
+static void inline AbortWithHeader(address_t obj) {
+  char *clsName = nullptr;
+  static constexpr address_t lowerMetaBound  = 0x80000000;
+  static constexpr address_t higherMetaBound = 0xdfffffff;
+  if (IS_HEAP_OBJ(obj)) {
+    __MRT_ASSERT(MObject::Cast<MObject>(obj) != nullptr, "AbortWithHeader: obj is a nullptr.");
+    MClass *cls = MObject::Cast<MObject>(obj)->GetClass();
+    address_t clsAddr = reinterpret_cast<address_t>(cls);
+    if ((clsAddr >= lowerMetaBound) && (clsAddr < higherMetaBound) &&
+        ((clsAddr % kJavaObjAlignment) == 0) && MRT_IsValidClass(*cls)) {
+      clsName = cls->GetName();
+    }
+  }
+  MRT_BuiltinAbortSaferegister(obj, clsName);
+}
+#else
+static void inline AbortWithHeader(address_t obj) {
+  __MRT_ASSERT(MObject::Cast<MObject>(obj) != nullptr, "AbortWithHeader: obj is a nullptr.");
+  MClass *cls = MObject::Cast<MObject>(obj)->GetClass();
+  std::cout << "Inc/Dec from 0 " << std::hex << obj << " " << GCHeader(obj) <<
+      " " << RCHeader(obj) << " lock " << *(reinterpret_cast<uint32_t*>(obj + kLockWordOffset)) <<
+      std::dec << cls->GetName() << std::endl;
+
+  MRT_BuiltinAbortSaferegister(obj, nullptr);
+}
+#endif
+
+#if MRT_DEBUG_DOUBLE_FREE && !ALLOC_USE_FAST_PATH
+static inline void CheckDoubleFree(address_t objAddr) {
+  if (UNLIKELY(!IsAllocatedByAllocator(objAddr))) {
+    LOG(ERROR) << "double freeing " << objAddr;
+    AbortWithHeader(objAddr);
+  }
+}
+#else
+#define CheckDoubleFree(x)
+#endif
+
+// Object reference field iteration utilities, used in
+// Recursive RC update when release
+// Backup tracing mark/sweep
+static const uint64_t kNotRefBits = 0;
+static const uint64_t kNormalRefBits = 1;
+static const uint64_t kWeakRefBits = 2;
+static const uint64_t kUnownedRefBits = 3;
+static const uint64_t kRefBitsMask = 3;
+static const uint32_t kBitsPerRefWord = 2;
+
+constexpr uint32_t kBitsPerByte = 8;
+static const uint32_t kRefWordPerMapWord = ((sizeof(uint64_t) * kBitsPerByte) / kBitsPerRefWord);
+
+template<class RefFunc>
+void ForEachRefFieldNonArrayObj(address_t objAddr, RefFunc &&refFunc) {
+  struct GCTibGCInfo &gcInf = GCInfo(objAddr);
+
+  // number of bitmap words from GCTIB.
+  uint32_t bitmapWordsCount = gcInf.nBitmapWords;
+  uint64_t *bitmapWords = gcInf.bitmapWords;
+  bool allNormal = Collector::Instance().Type() == kMarkSweep;
+
+  // start address of fields.
+  address_t baseAddr = objAddr;
+  // for each bitmap word.
+  for (size_t i = 0; i < bitmapWordsCount; ++i) {
+    uint64_t bitmapWord = bitmapWords[i];
+    address_t fieldAddr = baseAddr;
+
+    // for each bit in bitmap.
+    while (LIKELY(bitmapWord != 0)) {
+      uint64_t wordBits = bitmapWord & kRefBitsMask;
+      if (wordBits != kNotRefBits) {
+        if (allNormal) {
+          wordBits = kNormalRefBits;
+        }
+        refFunc(AddrToLVal<reffield_t>(fieldAddr), wordBits);
+      }
+      // go next ref word.
+      bitmapWord >>= kBitsPerRefWord;
+      fieldAddr += sizeof(reffield_t);
+    }
+
+    // go next bitmap word.
+    baseAddr += (sizeof(reffield_t) * kRefWordPerMapWord);
+  }
+}
+
+// Call func on each element in an object array.
+template<class UnaryFunction>
+void ForEachObjectArrayElement(address_t objAddr, UnaryFunction &&func) {
+  // we assume that both kHasChildRef & kArrayBit are set.
+  // take array length and content.
+  uint32_t arrayLengthVal = AddrToLVal<uint32_t>(objAddr + kJavaArrayLengthOffset);
+  reffield_t *arrayContent = reinterpret_cast<reffield_t*>(objAddr + kJavaArrayContentOffset);
+
+  // for each object in array.
+  for (uint32_t i = 0; i < arrayLengthVal; ++i) {
+    func(arrayContent[i], kNormalRefBits);
+  }
+}
+
+// Use this macro to ensure that kHasChildRef & kArrayBit
+// is checked before __ForEachXXXX() get called
+// function should accept 'reffield_t&' as argument
+// pattern for the call-back function:
+// ForEachRefField(objAddr, [](reffield_t &field) { address_t ref = LoadRefField(field); }
+// similar constraint applies to the other 2 macros.
+#define ForEachRefField(obj, refFunc) do { \
+  if (maplert::HasChildRef(obj)) { \
+    if (UNLIKELY(IsObjectArray(obj))) { \
+      ForEachObjectArrayElement(obj, refFunc); \
+    } else { \
+      ForEachRefFieldNonArrayObj(obj, refFunc); \
+    } \
+  } \
+} while (0)
+
+// Use this macro if kHasChildRef already checked.
+#define DoForEachRefField(obj, refFunc) do { \
+  if (UNLIKELY(IsObjectArray(obj))) { \
+    ForEachObjectArrayElement(obj, refFunc); \
+  } else { \
+    ForEachRefFieldNonArrayObj(obj, refFunc); \
+  } \
+} while (0)
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/include/version.h b/src/mrt/compiler-rt/include/version.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf59484897805626de3cb5894e15eabae9b70a96
--- /dev/null
+++ b/src/mrt/compiler-rt/include/version.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef VERSION_H
+#define VERSION_H
+
+namespace Version {
+static constexpr const int kMajorMplVersion = 4;
+static constexpr const int kMinorCompilerVersion = 0;
+static constexpr const int kMinorRuntimeVersion = 0;
+}
+
+#endif
diff --git a/src/mrt/compiler-rt/include/yieldpoint.h b/src/mrt/compiler-rt/include/yieldpoint.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ca73ae29ee234f3ff218994e4e435875a4276c6
--- /dev/null
+++ b/src/mrt/compiler-rt/include/yieldpoint.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_YIELDPOINT_H
+#define MAPLE_RUNTIME_YIELDPOINT_H
+
+#include <csignal>
+#include "mrt_api_common.h"
+#include "collector/collector.h"
+
+// Yieldpoint runtime APIs
+namespace maplert {
+// Signal handler for yieldpoint.
+// return true if signal is triggered by yieldpoint.
+bool YieldpointSignalHandler(int sig, siginfo_t *info, ucontext_t *ctx);
+
+// reset yieldpoint module for forked process.
+void YieldpointInitAfterFork();
+
+// Initialize yieldpoint for mutator.
+void InitYieldpoint(Mutator &mutator);
+
+// Finalize yieldpoint for mutator.
+void FiniYieldpoint(Mutator &mutator);
+
+// Stop all muators.
+MRT_EXPORT void StopTheWorld();
+
+// Start all mutators suspended by StopTheWorld().
+MRT_EXPORT void StartTheWorld();
+
+bool WorldStopped();
+
+void LockStopTheWorld();
+
+void UnlockStopTheWorld();
+
+void DumpMutatorsListInfo(bool isFatal);
+// Scoped stop the world,
+class ScopedStopTheWorld {
+ public:
+  __attribute__ ((always_inline))
+  explicit ScopedStopTheWorld() {
+    StopTheWorld();
+  }
+
+  __attribute__ ((always_inline))
+  ~ScopedStopTheWorld() {
+    StartTheWorld();
+  }
+};
+
+// Scoped start the world.
+class ScopedStartTheWorld {
+ public:
+  __attribute__ ((always_inline))
+  explicit ScopedStartTheWorld() {
+    StartTheWorld();
+  }
+
+  __attribute__ ((always_inline))
+  ~ScopedStartTheWorld() {
+    StopTheWorld();
+  }
+};
+
+// Scoped lock stop-the-world, this prevent other
+// thread stop-the-world during the current scope.
+class ScopedLockStopTheWorld {
+ public:
+  __attribute__ ((always_inline))
+  explicit ScopedLockStopTheWorld() {
+    LockStopTheWorld();
+  }
+
+  __attribute__ ((always_inline))
+  ~ScopedLockStopTheWorld() {
+    UnlockStopTheWorld();
+  }
+};
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/public-headers/file_adapter.h b/src/mrt/compiler-rt/public-headers/file_adapter.h
new file mode 100644
index 0000000000000000000000000000000000000000..ed5294957b1b2f2b88e3282cd9131cc793bba356
--- /dev/null
+++ b/src/mrt/compiler-rt/public-headers/file_adapter.h
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_LOADER_FILE_ADAPTER__
+#define __MAPLE_LOADER_FILE_ADAPTER__
+
+#include <string>
+
+#include "linker/linker_common.h"
+#include "utils/string_utils.h"
+#include "allocator/page_allocator.h"
+#include "utils/time_utils.h"
+namespace maplert {
+enum FileType {
+  kMFile,
+  kDFile,
+  kUnknown
+};
+// file manager for (all) maple supported class-file types
+// one instance per class-file
+class ObjFile {
+ public:
+  ObjFile(jobject classLoader, const std::string &path, FileType fileType)
+      : fileAddr(nullptr),
+        classLoader(classLoader),
+        name(path),
+        fileType(fileType),
+        fileSize(0),
+        lazyBinding(false),
+        classTableLoaded(false),
+        mplInfo(nullptr) {
+    static int32_t globalUniqueKey = 0x100000;
+    uniqueID = __atomic_add_fetch(&globalUniqueKey, 1, __ATOMIC_ACQ_REL);
+  }
+
+  virtual bool Open() = 0;
+  virtual bool Close() = 0;
+  virtual void Load() = 0;
+
+  // check if the jni class in the maple file by jni class name
+  virtual bool CanRegisterNativeMethods(const std::string &jniClassName) = 0;
+  // if the register success, it will return true, othewise false;
+  virtual bool RegisterNativeMethods(IEnv env, jclass javaClass, const std::string &jniClassName,
+      INativeMethod methods, int32_t methodCount, bool fake) = 0;
+  virtual void DumpUnregisterNativeFunc(std::ostream &os) = 0;
+
+  virtual void *GetHandle() const { // different File manager might use different handle
+    return fileAddr;
+  }
+
+  virtual ~ObjFile() {
+    fileAddr = nullptr;
+    classLoader = nullptr;
+    mplInfo = nullptr;
+  };
+
+  inline int32_t GetUniqueID() const {
+    return uniqueID;
+  }
+
+  inline LinkerMFileInfo *GetMplInfo() const {
+    return mplInfo;
+  }
+
+  inline void SetMplInfo(LinkerMFileInfo &outMplInfo) {
+    mplInfo = &outMplInfo;
+  }
+  inline const std::string &GetName() const {
+    return name;
+  }
+
+  inline const jobject &GetClassLoader() const {
+    return classLoader;
+  }
+
+  inline void SetClassLoader(jobject loader) {
+    classLoader = loader;
+  }
+
+  inline void SetUniqueID(int32_t id) {
+    this->uniqueID = id;
+  }
+
+  inline FileType GetFileType() const {
+    return fileType;
+  }
+
+  inline size_t GetFileSize() const {
+    return fileSize;
+  };
+
+  inline bool IsLazyBinding() const {
+    return lazyBinding;
+  }
+
+  inline void SetLazyBinding() {
+    lazyBinding = true;
+  }
+
+  inline bool IsClassTableLoaded() const {
+    return classTableLoaded;
+  }
+
+  inline void SetClassTableLoaded() {
+    classTableLoaded = true;
+  }
+
+  void *fileAddr;         // dlopen/mmaped address
+
+ protected: // need to be accessed by derived class
+  jobject classLoader;    // class loader to load classes in the file
+  int32_t uniqueID;        // use createTime to sort
+  std::string name;       // name of class file to open
+  FileType fileType;      // type of file
+  size_t fileSize;        // file size
+  bool lazyBinding;       // it's lazy binding file.
+  bool classTableLoaded;  // whether the class table has been loaded
+  LinkerMFileInfo *mplInfo; // memory map for objfile
+};
+class FileAdapter {
+ public:
+  template<class Key, class Value>
+  using ObjFileMap = std::unordered_map<Key, Value, std::hash<Key>, std::equal_to<Key>,
+      StdContainerAllocator<std::pair<const Key, Value>, kClassLoaderAllocator>>;
+  FileAdapter() {};
+  MRT_EXPORT FileAdapter(std::string srcPath);
+  MRT_EXPORT FileAdapter(std::string srcPath, IAdapterEx adapter);
+
+  ~FileAdapter() {
+    mMplLibs.clear();
+    mMplSeqList.clear();
+  }
+  size_t GetRegisterSize() const {
+    std::lock_guard<std::mutex> lock(mMplLibLock);
+    return mMplLibs.size();
+  }
+  size_t GetSize() const {
+    return mMplSeqList.size();
+  }
+  const std::vector<const ObjFile*> &GetMplFiles() const {
+    return mMplSeqList;
+  }
+  const std::string &GetOriginPath() const {
+    return originalPath;
+  }
+  const std::string &GetConvertPath() const {
+    return convertPath;
+  }
+  bool IsThirdApp() const {
+    return isThirdApp;
+  }
+  bool IsPartialAot() const {
+    return isPartialAot;
+  }
+  bool HasStartUp() const {
+    return hasStartUp;
+  }
+  bool HasSiblings() const {
+    return hasSiblings;
+  }
+  void SetInterpExAPI(const IAdapterEx api) {
+    pAdapterEx = api;
+  }
+  ObjFile *OpenObjectFile(jobject classLoader, bool isFallBack = false, const std::string specialPath = "");
+  bool CloseObjectFile(ObjFile &objFile);
+  void GetObjFiles(std::vector<const ObjFile*> &bootClassPath);
+  void GetObjLoaders(std::set<jobject> &classLoaders);
+  const ObjFile *Get(const std::string &path);
+  void Put(const std::string &path, const ObjFile &objFile);
+  bool Register(IEnv env, jclass javaClass, const std::string &jniClassName,
+      INativeMethod methods, int32_t methodCount, bool fake);
+  void DumpUnregisterNativeFunc(std::ostream &os);
+  void DumpMethodName();
+  // Get MFile list from filePath, and store split file path into pathList
+  // returns: true if "startup MFile" found in the filePath false if not found in the filePath
+  void GetObjFileList(std::vector<std::string> &pathList, bool isFallBack);
+ protected:
+  const ObjFile *GetLocked(const std::string &path);
+  bool GetObjFileListInternal(std::vector<std::string> &pathList);
+
+  std::string originalPath;
+  std::string convertPath;
+  // If it is third App
+  bool isThirdApp = false;
+  // If it is partial AOT
+  bool isPartialAot = false;
+  // If it is has startup so
+  bool hasStartUp = false;
+  // If it is has mulito so
+  bool hasSiblings = false;
+  // Input dex path
+  IAdapterEx pAdapterEx;
+  mutable std::mutex mMplLibLock;
+  // the string represents mplefile libpath
+  ObjFileMap<std::string, const ObjFile*> mMplLibs;
+  std::vector<const ObjFile*> mMplSeqList;
+};
+} // namespace maplert
+#endif // __MAPLE_LOADER_FILE_ADAPTER__
diff --git a/src/mrt/compiler-rt/public-headers/file_loader.h b/src/mrt/compiler-rt/public-headers/file_loader.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2637e626d66c11a3b3a2cdbf47fa6585e578ea5
--- /dev/null
+++ b/src/mrt/compiler-rt/public-headers/file_loader.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_LOADER_FILE_LOADER__
+#define __MAPLE_LOADER_FILE_LOADER__
+
+#include <string>
+
+#include "base/macros.h"
+namespace maple {
+class IMplLoader {
+ public:
+  virtual void *Open(const std::string &name) = 0;
+  virtual void Close(void *handle) = 0;
+  virtual ~IMplLoader() = default;
+};
+} // end namespace maple
+#endif // endif __MAPLE_LOADER_FILE_LOADER__
diff --git a/src/mrt/compiler-rt/public-headers/gc_callback.h b/src/mrt/compiler-rt/public-headers/gc_callback.h
new file mode 100644
index 0000000000000000000000000000000000000000..adcc95f34f87a24036c8b4fcab15597126ef175c
--- /dev/null
+++ b/src/mrt/compiler-rt/public-headers/gc_callback.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_GCCALLBACK_H
+#define MAPLE_RUNTIME_GCCALLBACK_H
+
+#include <functional>
+
+namespace maplert {
+// This call back function type is called when GC finished.
+using GCFinishCallbackFunc = std::function<void()>;
+
+using address_t = uintptr_t;
+using offset_t = intptr_t;
+
+#ifdef USE_32BIT_REF
+using reffield_t = uint32_t;
+#else
+using reffield_t = address_t ;
+#endif // USE_32BIT_REF
+
+#ifdef USE_32BIT_REF
+#define DEADVALUE (0xdeaddeadul)  // only stores 32bit value
+#else   // !USE_32BIT_REF
+#define DEADVALUE (0xdeaddeaddeaddeadul)
+#endif  // USE_32BIT_REF
+
+using AddressVisitor = std::function<void(address_t)>;
+using RefVisitor = std::function<void(address_t&)>;
+using HeapRefVisitor = std::function<void(reffield_t&)>;
+}
+
+#endif // MAPLE_RUNTIME_GCCALLBACK_H
diff --git a/src/mrt/compiler-rt/public-headers/gc_reason.h b/src/mrt/compiler-rt/public-headers/gc_reason.h
new file mode 100644
index 0000000000000000000000000000000000000000..52556c5782fc19bb603997d4766290786234b0f5
--- /dev/null
+++ b/src/mrt/compiler-rt/public-headers/gc_reason.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_GCREASON_H
+#define MAPLE_RUNTIME_GCREASON_H
+
+#include <cstdint>
+#include "globals.h"
+
+namespace maplert {
+constexpr float kGCWaterLevelLow = 1.1; // aggressive gc water level for sys app
+constexpr float kGCWaterLevelGCOnly = 1.15;
+constexpr float kGCWaterLevel = 1.2; // normal gc water level for sys app
+constexpr float kHeapWaterLevel = 0.5; // more aggressive when space capacity exceeds 50% of max
+constexpr float kAppGCWaterLevelLow = 1.4; // aggressive gc water level for normal app
+constexpr float kAppGCWaterLevel = 1.6; // normal gc water level for normal app
+constexpr float kAppStartupHeapHeurstic = 1.5; // startup require's less gc
+constexpr uint64_t kMaxGCThresholdDelta = 15 * maple::MB;
+constexpr uint64_t kInitSystemGCThreshold = 80 * maple::MB;
+constexpr uint64_t kInitGCThreshold = 20 * maple::MB;
+
+// Used by Collector::TriggerGC and its wrapper MRT_TriggerGC.
+// It tells the backup tracer why GC is triggered.
+//
+// [B] blocking: Calling Collector::TriggerGC or MRT_TriggerGC will block until
+// the current GC finishes.
+//
+// [LB] lite-blocking: just wait one gc request. Mainly for heuristic & native gc.
+// It's helpfull to reduce fragmentation both in java heap and native heap.
+//
+// [NB] non-blocking: Caller of Collector::TriggerGC or MRT_TriggerGC will
+// continue, and the GC will try to stop the world using yieldpoints.
+// Non-blocking GC will be triggered asynchronously, IsBlockingGCReason() deprecated.
+enum GCReason : int {
+  kInvalidGCReason = -1,
+  kGCReasonUser = 0, // [B] Triggered by user (System.gc(), etc.)
+  kGCReasonUserNi = 1, // [B] Triggered by user and not interactive (System.gc(), etc.)
+  kGCReasonOOM = 2, // [B] Out of memory. Failed to allocate object.
+  kGCReasonForceGC = 3, // [B] A special reason that forces GC.
+  kGCReasonTransistBG = 4, // [B] App's processState changed to JankImperceptible(background).
+  kGCReasonHeu = 5, // [NB] Statistics show it is worth doing GC. Does not have to be immediate.
+  kGCReasonNative = 6, // [NB] Native-Allocation-Registry shows it's worth doing GC.
+  kGCReasonHeuBlocking = 7, // [LB] Just wait one gc request to reduce java heap fragmentation.
+  kGCReasonNativeBlocking = 8, // [LB] Just wait one gc request to reduce native heap consumption.
+  kGCReasonMax = 9,
+};
+
+enum GCReleaseSoType : unsigned int {
+  kReleaseNone = 0, // do not release any maple so's read only section
+  kReleaseAppSo, // do not release sys maple so's read only section
+  kReleaseAll, // release all maple so's read only section
+};
+
+struct GCReasonConfig {
+  static int64_t lastGCTimestamp; // last timestamp of all gc
+  const GCReason reason;
+  const char *name; // Human-readable names of GC reasons.
+  const bool isBlocking;
+  const bool isLiteBlocking;
+  const bool isNonBlocking;
+  const bool isConcurrent;
+  const int64_t minIntervelNs;
+  int64_t lastTriggerTimestamp;
+
+  inline bool IsFrequentGC() const;
+  inline bool IsFrequentAsyncGC() const;
+  inline bool IsFrequentHeuristicGC() const;
+  bool ShouldIgnore() const;
+  void IgnoreCallback() const;
+  GCReleaseSoType ShouldReleaseSo() const;
+  bool ShouldTrimHeap() const;
+  bool ShouldCollectCycle() const;
+  void SetLastTriggerTime(int64_t timestamp);
+  bool IsLiteBlockingGC() const {
+    return isLiteBlocking;
+  }
+  bool IsBlockingGC() const {
+    return isBlocking;
+  }
+  bool IsNonBlockingGC() const {
+    return isNonBlocking;
+  }
+};
+
+// Defined in compiler-rt/src/gcreason.cpp
+extern GCReasonConfig reasonCfgs[];
+
+// The process state passed in from the activity manager, used to determine
+// when to do cycle.pattern saving or other cases.
+enum ProcessState {
+  kProcessStateJankPerceptible = 0,
+  kProcessStateJankImperceptible = 1,
+};
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/compiler-rt/public-headers/linker_api.h b/src/mrt/compiler-rt/public-headers/linker_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..427d5fcbcdec00088421cbab77e68f5d4b8b29d5
--- /dev/null
+++ b/src/mrt/compiler-rt/public-headers/linker_api.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_LINKER_API__
+#define __MAPLE_LINKER_API__
+
+#include "linker/linker_utils.h"
+#include "file_adapter.h"
+
+#ifdef __cplusplus
+namespace maplert {
+#define LINKER_LOG(level) LOG(level) << __FUNCTION__ << "(MplLinker), "
+#define LINKER_VLOG(module) VLOG(module) << __FUNCTION__ << "(MplLinker), "
+#define LINKER_DLOG(module) DLOG(module) << __FUNCTION__ << "(MplLinker), "
+struct SignalInfo {
+  SignalInfo(void *pc, void *offset) : pc(pc), offset(offset) {};
+  void *pc;
+  void *offset;
+};
+struct StrTab {
+  char *startHotStrTab = nullptr;
+  char *bothHotStrTab = nullptr;
+  char *runHotStrTab = nullptr;
+  char *coldStrTab = nullptr;
+};
+class LinkerAPI {
+ public:
+  MRT_EXPORT static LinkerAPI &Instance();
+  template<typename T>
+  static T As() {
+    return reinterpret_cast<T>(Instance());
+  }
+  LinkerAPI() {};
+  virtual ~LinkerAPI() = default;
+  virtual void PreInit() = 0;
+  virtual void PostInit() = 0;
+  virtual void UnInit() = 0;
+  // reference by stack_unwinder.h | jsan.cpp | jsan_lite.cpp | mm_utils.cpp | fault_handler_arm64.cc |
+  //   fault_handler_linux.cc
+  virtual bool IsJavaText(const void *addr) = 0;
+  // reference by stack_unwinder.h | eh_personality.cpp | jsan.cpp | jsan_lite.cpp | libs.cpp |
+  //   mm_utils.cpp | stack_unwinder.cpp | mpl_linkerTest.cpp
+  virtual bool LocateAddress(const void *addr, LinkerLocInfo &info, bool getName) = 0;
+  // reference by chelper.cpp | mclass.cpp | mrt_class_init.cpp | mrt_mclasslocatormanager.cpp |
+  // mrt_reflection_class.cpp
+  virtual bool LinkClassLazily(jclass klass) = 0;
+  // reference by chelper.cpp | mrt_reflection_class | mpl_field_gctib.cpp | mclass.cpp
+  virtual void ResolveColdClassSymbol(jclass classinfo) = 0;
+  // reference by cinterface.cpp | collector_ms.cpp
+  virtual void ReleaseBootPhaseMemory(bool isZygote, bool isSystemServer) = 0;
+  // reference by collector_ms.cpp
+  virtual void ClearAllMplFuncProfile() = 0;
+  // reference by libs.cpp | dalvik_system_VMStack.cc | jvm.cpp
+  virtual std::string GetMFileNameByPC(const void *pc, bool isLazyBinding) = 0;
+  // reference by mm_utils.cpp | runtime.cc | mpl_linkerTest.cpp
+  virtual std::string GetAppInfo() = 0;
+  // reference by stack_unwinder.cpp
+  virtual LinkerMFileInfo *GetLinkerMFileInfoByName(const std::string &name) = 0;
+  virtual bool CheckLinkerMFileInfoElfBase(LinkerMFileInfo &mplInfo) = 0;
+  // reference by fieldmeta.cpp | methodmeta.cpp | mrt_annotation.cpp
+  virtual void GetStrTab(jclass dCl, StrTab &strTab) = 0;
+  virtual char *GetCString(jclass dCl, uint32_t index) = 0;
+  virtual void DestroyMFileCache() = 0;
+  // reference by mrt_class_init.cpp | mrt_profile.cpp
+  virtual LinkerMFileInfo *GetLinkerMFileInfoByAddress(const void *addr, bool isLazyBinding) = 0;
+  // reference by mrt_mclasslocatormanager.cpp
+  virtual jclass InvokeClassLoaderLoadClass(jobject classLoader, const std::string &className) = 0;
+  // reference by mrt_profile.cpp
+  virtual void DumpAllMplFuncProfile(
+      std::unordered_map<std::string, std::vector<FuncProfInfo>> &funcProfileRaw) = 0;
+  virtual void DumpBBProfileInfo(std::ostream &os) = 0;
+  virtual void DumpAllMplFuncIRProfile(std::unordered_map<std::string, MFileIRProfInfo> &funcProfileRaw) = 0;
+  // reference by mrt_reflection_method.cpp
+  virtual bool UpdateMethodSymbolAddress(jmethodID method, uintptr_t addr) = 0;
+  // reference by dalvik_system_VMStack.cc | class_linker.cc | jvm.cpp
+  virtual LinkerMFileInfo *GetLinkerMFileInfoByClassMetadata(const void *addr, bool isClass) = 0;
+  // reference by class_linker.cc | mpl_linkerTest.cpp
+  virtual void *GetSymbolAddr(void *handle, const char *symbol, bool isFunction) = 0;
+  // reference by mpl_file_checker.cc
+  virtual void GetMplVersion(const LinkerMFileInfo &mplInfo, MapleVersionT &item) = 0;
+  virtual void GetMplCompilerStatus(const LinkerMFileInfo &mplInfo, uint32_t &status) = 0;
+  // reference by mpl_native_stack.cpp
+  virtual bool GetJavaTextInfo(
+      const void *addr, LinkerMFileInfo **mplInfo, LinkerLocInfo &info, bool getName) = 0;
+  // reference by signal_catcher.cc | mpl_linkerTest.cpp
+  virtual void DumpAllMplSectionInfo(std::ostream &os) = 0;
+  // reference by mpl_linkerTest.cpp | NativeEntry.cpp
+  virtual bool ContainLinkerMFileInfo(const std::string &name) = 0;
+  virtual bool ContainLinkerMFileInfo(const void *handle) = 0;
+  virtual void SetAppInfo(const char *dataPath, int64_t versionCode) = 0;
+  virtual AppLoadState GetAppLoadState() = 0;
+  virtual uint64_t DumpMetadataSectionSize(std::ostream &os, void *handle, const std::string sectionName) = 0;
+  virtual std::string GetMethodSymbolByOffset(const LinkerInfTableItem &pTable) = 0;
+  // reference by mclass_inline.h
+  virtual jclass GetSuperClass(ClassMetadata **addr) = 0;
+  // reference by jvm.cpp
+  virtual std::string GetMFileNameByClassMetadata(const void *addr, bool isLazyBinding) = 0;
+  // reference by mrt_prifole.cpp
+  virtual std::string GetAppPackageName() = 0;
+  // reference by mrt_mclasslocator_interpreter.cpp
+  virtual bool ReGenGctib4Class(jclass classInfo) = 0;
+  // reference by NativeEntry.cpp of cbg
+  virtual void *LookUpSymbolAddress(const MUID &muid) = 0;
+  virtual MUID GetMUID(const std::string symbol, bool forSystem) = 0;
+  virtual bool IsFrontPatchMode(const std::string &path) = 0;
+
+  virtual bool Add(ObjFile &objFile, jobject classLoader) = 0;
+  virtual bool Resolve() = 0;
+  // Resolve the single maple file.
+  virtual bool Resolve(LinkerMFileInfo &mplInfo, bool decouple) = 0;
+#ifdef LINKER_DECOUPLE
+  virtual bool HandleDecouple(std::vector<LinkerMFileInfo*> &mplList) = 0;
+#endif
+  virtual void FinishLink(jobject classLoader) = 0;
+  virtual bool Link() = 0;
+  // Resolve the single maple file. MUST invoked Add() before.
+  virtual bool Link(LinkerMFileInfo &mplInfo, bool decouple) = 0;
+  virtual void SetLoadState(LoadStateType state) = 0;
+  virtual void SetLinkerMFileInfoClassLoader(const ObjFile &objFile, jobject classLoader) = 0;
+  virtual void SetClassLoaderParent(jobject classLoader, jobject newParent) = 0;
+  virtual bool InsertClassesFront(ObjFile &objFile, jobject classLoader) = 0;
+  virtual void SetPatchPath(std::string &path, int32_t mode) = 0;
+  virtual void InitArrayCache(uintptr_t pc, uintptr_t addr) = 0;
+#ifdef LINKER_RT_CACHE
+  // reference by runtime.cc
+  virtual void SetCachePath(const char *path) = 0;
+#endif // LINKER_RT_CACHE
+ protected:
+  static LinkerAPI *pInstance;
+};
+extern "C" {
+#endif
+extern uint8_t __BindingProtectRegion__[];
+
+bool MRT_RequestLazyBindingForSignal(const SignalInfo &data);
+bool MRT_RequestLazyBindingForInitiative(const void *data);
+bool MRT_RequestLazyBinding(const void *offset, const void *pc, bool fromSignal);
+void MRT_FixOffsetTableLazily(LinkerOffsetValItemLazyLoad &offsetEntry);
+void MRT_FixStaticAddrTableLazily(LinkerStaticAddrItem &addrTableItem);
+void MRT_FixStaticAddrTable(LinkerStaticAddrItem &addrTableItem);
+void InitProtectedRegion();
+bool MRT_IsLazyBindingState(const uint8_t *address);
+bool MRT_RequestInitArrayCache(SignalInfo *info);
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+#endif // __MAPLE_LINKER_API__
diff --git a/src/mrt/compiler-rt/public-headers/loader_api.h b/src/mrt/compiler-rt/public-headers/loader_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..49690f369e9d59b73fc663d2b2e801d7ee3d2984
--- /dev/null
+++ b/src/mrt/compiler-rt/public-headers/loader_api.h
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_LOADER_API__
+#define __MAPLE_LOADER_API__
+
+#include "file_adapter.h"
+#include "gc_roots.h"
+
+namespace maplert {
+#define CL_LOG(level) LOG(level) << __FUNCTION__ << "(ClassLoader), "
+#define CL_VLOG(module) VLOG(module) << __FUNCTION__ << "(ClassLoader), "
+#define CL_DLOG(module) DLOG(module) << __FUNCTION__ << "(ClassLoader), "
+enum AdapterFileList {
+  kMplFileBootList,
+  kMplFileOtherList
+};
+class SearchFilter {
+ public:
+  jobject specificCL = nullptr; // assign by 'User', immutable
+  jobject contextCL = nullptr; // assign by 'Module',  low mutable
+  jobject currentCL = nullptr; // assign by 'Condition', high mutable
+  ObjFile *outFile = nullptr;
+  ObjFile *specificFile = nullptr; // assign by 'User', immutable
+  ObjFile *currentFile = nullptr; // assign by 'Condition', high mutable
+  bool isInternalName = false;
+  bool isLowerDelegate = false;
+  bool isDelegateLast = false;
+  bool ignoreBootSystem = false;
+  SearchFilter() {};
+  SearchFilter(jobject loader) : specificCL(loader) {};
+  SearchFilter(jobject specific, jobject context) : specificCL(specific), contextCL(context) {};
+  SearchFilter(jobject loader, bool lowerDelegate, ObjFile *file)
+      : specificCL(loader),
+        specificFile(file),
+        isLowerDelegate(lowerDelegate) {};
+  SearchFilter(jobject loader, bool internalName, bool lowerDelegate, ObjFile *file)
+      : specificCL(loader),
+        specificFile(file),
+        isInternalName(internalName),
+        isLowerDelegate(lowerDelegate) {};
+  SearchFilter(jobject loader, bool internalName, bool lowerDelegate, bool delegateLast)
+      : specificCL(loader),
+        isInternalName(internalName),
+        isLowerDelegate(lowerDelegate),
+        isDelegateLast(delegateLast) {};
+  SearchFilter(const SearchFilter &filter)
+      : specificCL(filter.specificCL),
+        specificFile(filter.specificFile),
+        isInternalName(filter.isInternalName),
+        isLowerDelegate(filter.isLowerDelegate),
+        isDelegateLast(filter.isDelegateLast),
+        ignoreBootSystem(filter.ignoreBootSystem) {};
+  ~SearchFilter() {
+    outFile = nullptr;
+    specificFile = nullptr;
+    currentFile = nullptr;
+    specificCL = nullptr;
+    currentCL = nullptr;
+    contextCL = nullptr;
+  }
+  inline SearchFilter &Clear() {
+    currentFile = nullptr;
+    currentCL = nullptr;
+    return *this;
+  }
+  inline SearchFilter &Reset() {
+    currentFile = specificFile;
+    currentCL = contextCL;
+    return *this;
+  }
+  inline SearchFilter &ClearFile() {
+    currentFile = nullptr;
+    return *this;
+  }
+  inline SearchFilter &ResetFile() {
+    currentFile = specificFile;
+    return *this;
+  }
+  inline SearchFilter &ResetClear() {
+    currentFile = nullptr;
+    currentCL = contextCL;
+    return *this;
+  }
+  inline bool IsBootOrSystem(const jobject systemLoader) const {
+    return (contextCL == nullptr) || (contextCL == systemLoader);
+  }
+  inline bool IsNullOrSystem(const jobject systemLoader) const {
+    return (systemLoader == nullptr) || (contextCL == systemLoader);
+  }
+  inline void Dump(const std::string &msg, const jclass klass) {
+    CL_LOG(INFO) << msg << ", isInternalName=" << isInternalName << ", isLowerDelegate=" << isLowerDelegate <<
+        ", isDelegateLast=" << isDelegateLast << ", ignoreBootSystem=" << ignoreBootSystem << ", specificCL=" <<
+        specificCL << ", contextCL=" << contextCL << ", currentCL=" << currentCL << ", outFile=" << outFile <<
+        ", specificFile=" << specificFile << ", currentFile=" << currentFile << ", klass=" << klass << maple::endl;
+  }
+};
+class LoaderAPI {
+ public:
+  MRT_EXPORT static LoaderAPI &Instance();
+  template<typename T>
+  static T As() {
+    return reinterpret_cast<T>(Instance());
+  }
+  LoaderAPI() {};
+  virtual ~LoaderAPI() {};
+  virtual void PreInit(IAdapterEx interpEx) = 0;
+  virtual void PostInit(jobject systemClassLoader) = 0;
+  virtual void UnInit() = 0;
+  virtual jobject GetCLParent(jobject classLoader) = 0;
+  virtual void SetCLParent(jobject classLoader, jobject parentClassLoader) = 0;
+  virtual bool IsBootClassLoader(jobject classLoader) = 0;
+  virtual bool LoadMplFileInBootClassPath(const std::string &pathString) = 0;
+#ifndef __ANDROID__
+  virtual bool LoadMplFileInUserClassPath(const std::string &pathString) = 0;
+#endif
+  virtual bool LoadMplFileInAppClassPath(jobject classLoader, FileAdapter &adapter) = 0;
+  virtual bool LoadClasses(jobject classLoader, ObjFile &objFile) = 0;
+  virtual void RegisterMplFile(const ObjFile &mplFile) = 0;
+  virtual bool UnRegisterMplFile(const ObjFile &mplFile) = 0;
+  virtual bool RegisterJniClass(IEnv env, jclass javaClass, const std::string &filterName,
+      const std::string &jniClassName, INativeMethod methods, int32_t methodCount, bool fake) = 0;
+  virtual jclass FindClass(const std::string &className, const SearchFilter &filter) = 0;
+  // get registered mpl file by exact path-name: the path should be canonicalized
+  virtual const ObjFile *GetMplFileRegistered(const std::string &name) = 0;
+  virtual const ObjFile *GetAppMplFileRegistered(const std::string &package) = 0;
+  virtual size_t GetListSize(AdapterFileList type) = 0;
+  virtual size_t GetLoadedClassCount() = 0;
+  virtual size_t GetAllHashMapSize() = 0;
+  virtual void DumpUnregisterNativeFunc(std::ostream &os) = 0;
+  virtual void VisitClasses(maple::rootObjectFunc &func) = 0;
+  virtual bool IsLinked(jobject classLoader) = 0;
+  virtual void SetLinked(jobject classLoader, bool isLinked) = 0;
+  virtual bool GetClassNameList(jobject classLoader, ObjFile &objFile, std::vector<std::string> &classVec) = 0;
+  virtual bool GetMappedClassLoaders(const jobject classLoader,
+      std::vector<std::pair<jobject, const ObjFile*>> &mappedPairs) = 0;
+  virtual bool GetMappedClassLoader(const std::string &fileName, jobject classLoader, jobject &realClassLoader) = 0;
+  virtual void ReTryLoadClassesFromMplFile(jobject classLoader, ObjFile &mplFile) = 0;
+  virtual bool RegisterNativeMethods(ObjFile &objFile, jclass klass, INativeMethod methods, int32_t methodCount) = 0;
+  // MRT_EXPORT Split
+  virtual void VisitGCRoots(const RefVisitor &visitor) = 0;
+  virtual jobject GetSystemClassLoader() = 0;
+  virtual jobject GetBootClassLoaderInstance() = 0;
+  virtual void SetClassCL(jclass klass, jobject classLoader) = 0;
+  virtual IObjectLocator GetCLClassTable(jobject classLoader) = 0;
+  virtual void SetCLClassTable(jobject classLoader, IObjectLocator classLocator) = 0;
+  virtual jclass LocateClass(const std::string &className, const SearchFilter &filter) = 0;
+  virtual IAdapterEx GetAdapterEx() = 0;
+  virtual void ResetCLCache() = 0;
+  virtual jclass GetCache(const jclass contextClass, const std::string &className, uint32_t &index, bool&) = 0;
+  virtual void WriteCache(const jclass klass, const jclass contextClass, uint32_t index) = 0;
+ protected:
+  static LoaderAPI *pInstance;
+};
+class IAdapterExObj {
+ public:
+  IAdapterExObj() = default;
+  virtual ~IAdapterExObj() = default;
+  virtual bool IsSystemServer() = 0;
+  virtual bool IsGcOnly() = 0;
+  virtual bool IsStarted() = 0;
+};
+template<typename Type>
+class AdapterExObj : public IAdapterExObj {
+ public:
+  using TypeFlagCall = bool (Type::*)() const;
+  AdapterExObj(Type &obj, TypeFlagCall api) {
+    this->obj = &obj;
+    this->isSystemServer = api;
+  }
+  ~AdapterExObj() {
+    obj = nullptr;
+    isSystemServer = nullptr;
+  }
+  bool IsSystemServer() {
+    return (obj->*isSystemServer)();
+  }
+  bool IsGcOnly() {
+    return (obj->*isGcOnly)();
+  }
+  bool IsStarted() {
+    return (obj->*isStarted)();
+  }
+ protected:
+  Type *obj;
+  union {
+    TypeFlagCall isSystemServer;
+    TypeFlagCall isGcOnly;
+    TypeFlagCall isStarted;
+  };
+};
+class AdapterExAPI {
+ public:
+  AdapterExAPI()
+      : openDexFile(nullptr),
+        openMplFile(nullptr),
+        enableMygote(nullptr),
+        getDexFileList(nullptr),
+        createThread(nullptr),
+        isSystemServer(nullptr),
+        isGcOnly(nullptr),
+        isStarted(nullptr) {};
+  ~AdapterExAPI() {
+    openDexFile = nullptr;
+    openMplFile = nullptr;
+    enableMygote = nullptr;
+    getDexFileList = nullptr;
+    createThread = nullptr;
+    delete isSystemServer;
+    delete isGcOnly;
+    delete isStarted;
+    isSystemServer = nullptr;
+    isGcOnly = nullptr;
+    isStarted = nullptr;
+  }
+  using MplFileOpenCall = ObjFile *(*)(jobject classLoader, const std::string &path);
+  using LoadMplFileCall = bool (*)(LoaderAPI &loader, ObjFile &mplFile, jobject classLoader);
+  using EnableMygoteCall = int (*)(bool enable, const std::string &message);
+  using GetDexFileListCall = void (*)(const std::string &fileName, std::vector<std::string> &fileList);
+  using CreateThreadCall = void (*)(void* (*loadingCallback)(void*), void* args);
+  using DexFileOpenCall = MplFileOpenCall;
+  void RegisterOpenDexFileAPI(DexFileOpenCall api) {
+    openDexFile = api;
+  }
+  void RegisterOpenMplFileAPI(MplFileOpenCall api) {
+    openMplFile = api;
+  }
+  void RegisterEnableMygoteAPI(EnableMygoteCall api) {
+    enableMygote = api;
+  }
+  void RegisterGetDexFileListAPI(GetDexFileListCall api) {
+    getDexFileList = api;
+  }
+  void RegisterCreateThreadAPI(CreateThreadCall api) {
+    createThread = api;
+  }
+  template<typename Type>
+  void RegisterIsSystemServerAPI(AdapterExObj<Type> &obj) {
+    isSystemServer = &obj;
+  }
+  template<typename Type>
+  void RegisterIsGconlyAPI(AdapterExObj<Type> &obj) {
+    isGcOnly = &obj;
+  }
+  template<typename Type>
+  void RegisterIsStartedAPI(AdapterExObj<Type> &obj) {
+    isStarted = &obj;
+  }
+  ObjFile *OpenDexFile(jobject classLoader, const std::string &path) const {
+    return (*openDexFile)(classLoader, path);
+  }
+  ObjFile *OpenMplFile(jobject classLoader, const std::string &path) const {
+    return (*openMplFile)(classLoader, path);
+  }
+  int EnableMygote(bool enable, const std::string &message) const {
+    return (*enableMygote)(enable, message);
+  }
+  void GetListOfDexFileToLoad(const std::string &fileName, std::vector<std::string> &fileList) const {
+    (*getDexFileList)(fileName, fileList);
+  }
+  void CreateThreadAndLoadFollowingClasses(void* (*loadingCallback)(void*), void* args) const {
+    (*createThread)(loadingCallback, args);
+  }
+  bool IsSystemServer() const {
+    return isSystemServer->IsSystemServer();
+  }
+  bool IsGcOnly() const {
+    return isGcOnly->IsGcOnly();
+  }
+  bool IsStarted() const {
+    return isStarted->IsStarted();
+  }
+ protected:
+  MplFileOpenCall openDexFile;
+  MplFileOpenCall openMplFile;
+  EnableMygoteCall enableMygote;
+  GetDexFileListCall getDexFileList;
+  CreateThreadCall createThread;
+  IAdapterExObj *isSystemServer;
+  IAdapterExObj *isGcOnly;
+  IAdapterExObj *isStarted;
+};
+} // namespace maplert
+#endif // __MAPLE_LOADER_API__
diff --git a/src/mrt/compiler-rt/public-headers/object_type.h b/src/mrt/compiler-rt/public-headers/object_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6ea3d4b518110428ea82cc355c1faccb8a3b1ea
--- /dev/null
+++ b/src/mrt/compiler-rt/public-headers/object_type.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_LOADER_OBJECT_TYPE__
+#define __MAPLE_LOADER_OBJECT_TYPE__
+
+namespace maplert {
+// compiler-rt API use IObject for JNI type (jclass/IObject) or Java type (MClass/MObject) and so
+#define TYPE_CAST(T, D) reinterpret_cast<T>(D)
+#define CONST_TYPE_CAST(T, D) const_cast<T>(reinterpret_cast<const T>(D))
+class IObject {
+ public:
+  IObject() = default;
+  ~IObject() {
+    data = nullptr;
+  }
+  IObject(const IObject &c) {
+    this->data = c.data;
+  }
+  IObject &operator=(const IObject &obj) {
+    this->data = obj.data;
+    return *this;
+  }
+  bool operator==(const IObject obj) const {
+    return data == obj.data;
+  }
+  bool operator!=(const IObject obj) const {
+    return data != obj.data;
+  }
+  bool operator<(const IObject obj) const {
+    return data < obj.data;
+  }
+  template<typename Type>
+  IObject(const Type &c) {
+    this->data = CONST_TYPE_CAST(void*, c);
+  }
+  template<typename Type>
+  Type As() {
+    return TYPE_CAST(Type, data);
+  }
+  template<typename Type>
+  Type As() const {
+    return TYPE_CAST(Type, data);
+  }
+  template<typename Type>
+  IObject &operator=(const Type &obj) {
+    data = CONST_TYPE_CAST(void*, obj);
+    return *this;
+  }
+  template<typename Type>
+  bool operator==(const Type obj) const {
+    return data == CONST_TYPE_CAST(void*, obj);
+  }
+  template<typename Type>
+  bool operator!=(const Type obj) const {
+    return data != CONST_TYPE_CAST(void*, obj);
+  }
+  template<typename Type>
+  bool operator<(const Type obj) const {
+    return data < CONST_TYPE_CAST(void*, obj);
+  }
+  bool Empty() const {
+    return data == nullptr;
+  }
+  const void *Get() const {
+    return data;
+  }
+ protected:
+  void *data = nullptr;
+};
+using IEnv = IObject;
+using INativeMethod = IObject;
+using IAdapterEx = IObject;
+using IObjectLocator = IObject;
+} // namespace maplert
+#endif // __MAPLE_LOADER_OBJECT_TYPE__
+
diff --git a/src/mrt/compiler-rt/public-headers/tracer.h b/src/mrt/compiler-rt/public-headers/tracer.h
new file mode 100644
index 0000000000000000000000000000000000000000..eacb348baaa73172e92ea79bf5634d69b89e3fe1
--- /dev/null
+++ b/src/mrt/compiler-rt/public-headers/tracer.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef __MAPLE_RUNTIME_TRACER_H
+#define __MAPLE_RUNTIME_TRACER_H
+
+#include <string>
+#include "mrt_api_common.h"
+
+namespace maplert {
+class Tracer {
+ public:
+  // event, 0 means function enter, 1 means function exit
+  virtual void LogMethodTraceEvent(const std::string funcName, int event) = 0;
+  virtual ~Tracer() = default;
+};
+
+MRT_EXPORT void SetTracer(Tracer *tracer);
+
+MRT_EXPORT Tracer *GetTracer();
+
+static inline bool IsTracingEnabled() {
+  return (GetTracer() == nullptr);
+}
+}; // namespace maplert
+
+#endif // __MAPLE_RUNTIME_TRACER_H
diff --git a/src/mrt/compiler-rt/src/allocator.cpp b/src/mrt/compiler-rt/src/allocator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..94ae6fb49c40cf5465ba7370072987b151e38c2c
--- /dev/null
+++ b/src/mrt/compiler-rt/src/allocator.cpp
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "allocator.h"
+
+#include <cstdint>
+#include <cinttypes>
+#include <dlfcn.h>
+
+#include "mm_config.h"
+#include "address.h"
+#include "sizes.h"
+#include "imported.h"
+#include "lock_word.h"
+#include "deps.h"
+#include "object_base.h"
+#include "allocator/page_allocator.h"
+
+namespace maplert {
+using namespace std;
+
+void Allocator::ReleaseResource(address_t obj) {
+  if (maple::ObjectBase::ReleaseResource(obj)) {
+    return;
+  }
+  MClass *classInfo = MObject::Cast<MObject>(obj)->GetClass();
+  // failed to release resource means fatal error.
+  if (classInfo == nullptr) {
+    LOG(FATAL) << "classInfo is nullptr in ReleaseResource, obj = " << obj << maple::endl;
+  }
+  LOG(FATAL) << "obj = " << obj << ", class name = " << classInfo->GetName() << maple::endl;
+}
+
+Allocator::Allocator()
+#if ALLOC_ENABLE_LOCK_CONTENTION_STATS
+    : oome(nullptr), oomeCreated(false), globalLock("allocator lock", maple::kAllocatorLock) {}
+#else
+    : oome(nullptr), oomeCreated(false) {}
+#endif
+
+void Allocator::NewOOMException() {
+  bool oldOOMECreated = false;
+  if (oome == nullptr && oomeCreated.compare_exchange_strong(oldOOMECreated, true)) {
+    ScopedObjectAccess soa;
+    MClass *exClass = MClass::JniCast(MRT_ReflectClassForCharName("java/lang/OutOfMemoryError", true, nullptr));
+    if (exClass == nullptr) {
+      LOG(FATAL) << "New OOM exception object failed, because exClass is nullptr" << maple::endl;
+      return;
+    }
+    size_t size = exClass->GetObjectSize();
+    // leave cause and stack null is fine, it will get default empty stack and null cause
+    oome = MObject::Cast<MObject>(NewObj(size));
+    if (oome == nullptr) {
+      LOG(FATAL) << "New OOM exception object failed, because oome is nullptr" << maple::endl;
+      return;
+    }
+    MRT_SetJavaClass(oome->AsUintptr(), exClass->AsUintptr());
+  }
+}
+
+// PageAlllocator
+// the input parameter cat should be guaranteed in the range of value of enum type AllocationTag by
+// external invoker, in order to avoid exceed the border of matrix
+AggregateAllocator &AggregateAllocator::Instance(AllocationTag tag) {
+  static ImmortalWrapper<AggregateAllocator> instance[kMaxAllocationTag];
+  return *(instance[tag]);
+}
+
+// PagePool
+PagePool &PagePool::Instance() {
+  static ImmortalWrapper<PagePool> instance;
+  return *instance;
+}
+}
diff --git a/src/mrt/compiler-rt/src/allocator/bp_allocator.cpp b/src/mrt/compiler-rt/src/allocator/bp_allocator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..99323d22549143be4e96e24e6b5c6460d3d09c31
--- /dev/null
+++ b/src/mrt/compiler-rt/src/allocator/bp_allocator.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "allocator/bp_allocator.h"
+#include "allocator/bp_allocator_inlined.h"
+#include "collector/collector_tracing.h"
+
+namespace maplert {
+// vaddr starts from (kSpaceAnchor - kMaxSpaceSize)
+const uint32_t BumpPointerAlloc::kInitialSpaceSize = (1u << 18); // 256KB initially
+const size_t BumpPointerAlloc::kExtendedSize = (1u << 16); // extend 64KB each time
+
+// The reason with this mem map is that we use multiple bp allocators, each
+// having a mem map. If we let them map random addresses one by one, there
+// is a good chance the attempted mmap() clobbers one another, and fails
+// constantly, thus impeding performance.
+// The solution is to reserve enough space for all of them, then each of
+// them uses another mmap (with flag MAP_FIXED) to place their mappings
+// in the reserved space in order.
+// See the usage of flag MAP_FIXED:
+//   http://man7.org/linux/man-pages/man2/mmap.2.html
+// Alternatively, we can make changes to MemMap so it coordinates
+// multiple random mappings better, but by intuition that's more expensive.
+static MemMap *reservedAddrSpace = nullptr;
+static address_t reservedAddr = 0;
+static address_t reservedEnd = 0;
+
+static inline void ReserveAddrSpace() {
+  if (reservedAddr != 0) {
+    return;
+  }
+  MemMap::Option opt = MemMap::kDefaultOptions;
+  opt.reqRange = true;
+  opt.lowestAddr = PERM_BEGIN;
+  opt.highestAddr = PERM_END - BumpPointerAlloc::kFireBreak;
+  opt.tag = "maple_alloc_reserved";
+  // this must succeed otherwise it won't return
+  reservedAddrSpace = MemMap::MapMemory(kOffHeapSpaceSize, 0, opt);
+  reservedAddr = reinterpret_cast<address_t>(reservedAddrSpace->GetBaseAddr());
+  reservedEnd = reinterpret_cast<address_t>(reservedAddrSpace->GetMappedEndAddr());
+}
+
+BumpPointerAlloc::BumpPointerAlloc(const string &name, size_t maxSize)
+    : memMap(nullptr), startAddr(0), currentAddr(0), endAddr(0), showmapName(name) {
+  // this should be called at a separate time!
+  Init(maxSize);
+}
+
+BumpPointerAlloc::~BumpPointerAlloc() {
+  LOG2FILE(kLogTypeAllocator) << "Destructing BumpPointerAlloc" << std::endl;
+  MemMap::DestroyMemMap(memMap);
+}
+
+void BumpPointerAlloc::Init(size_t growthLimit) {
+  ReserveAddrSpace();
+  if (reservedAddr == 0 || reservedAddr > reservedEnd - growthLimit) {
+    LOG(FATAL) << "space size inconsistency: reserved from " << std::hex << reservedAddr <<
+                  " to " << reservedEnd << ", size requested " << growthLimit;
+  }
+  MemMap::Option opt = MemMap::kDefaultOptions;
+  opt.reqRange = false;
+  opt.tag = showmapName.c_str();
+  opt.reqBase = reinterpret_cast<void*>(reservedAddr);
+  opt.flags |= MAP_FIXED;
+  reservedAddr += growthLimit + kOffHeapSpaceGap;
+  if (reservedAddr == reservedEnd + kOffHeapSpaceGap) {
+    MemMap::DestroyMemMap(reservedAddrSpace);
+  }
+  memMap = MemMap::MapMemory(growthLimit, kInitialSpaceSize, opt);
+  startAddr = reinterpret_cast<address_t>(memMap->GetBaseAddr());
+  currentAddr = startAddr;
+  endAddr = reinterpret_cast<address_t>(memMap->GetCurrEnd());
+}
+
+void BumpPointerAlloc::Dump(std::basic_ostream<char> &os) {
+  if (memMap == nullptr) {
+    os << "Fail to dump permanent space because memMap is null!" << "\n";
+    return;
+  }
+  // invoked in stw
+  size_t usedSize = currentAddr - startAddr;
+  os << showmapName << " space used: " << usedSize << ", left: " << ((memMap->GetMappedSize()) - usedSize) << "\n";
+
+#if BPALLOC_DEBUG
+  DumpUsage(os);
+#endif
+}
+
+address_t BumpPointerAlloc::Alloc(size_t size) {
+  size_t allocSize = AllocUtilRndUp<address_t>(size, kBPAllocObjAlignment);
+  address_t resultAddr = AllocInternal(allocSize);
+  return resultAddr;
+}
+
+bool BumpPointerAlloc::Contains(address_t obj) const {
+  if ((obj < currentAddr) && (obj >= startAddr)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+DecoupleAllocator::DecoupleAllocator(const string &name, size_t maxSize) : BumpPointerAlloc(name, maxSize) {}
+
+address_t DecoupleAllocator::Alloc(size_t size, DecoupleTag tag) {
+  address_t resultAddr = 0U;
+  if (UNLIKELY(size >= DecoupleAllocHeader::kMaxSize)) {
+    return resultAddr;
+  }
+  size_t allocSize = GetAllocSize(size);
+  resultAddr = AllocInternal(allocSize);
+  address_t allocAddr = BPALLOC_GET_OBJ_FROM_ADDR(resultAddr);
+  DecoupleAllocHeader::SetHeader(allocAddr, static_cast<int>(tag), size);
+  return allocAddr;
+}
+
+bool DecoupleAllocator::ForEachObj(function<void(address_t)> visitor) {
+  address_t objAddr = startAddr + DecoupleAllocHeader::kHeaderSize;
+  while (objAddr < currentAddr) {
+    size_t size = DecoupleAllocHeader::GetSize(objAddr);
+    if (size >= DecoupleAllocHeader::kMaxSize) {
+      // size broken! heap corruption detected.
+      return false;
+    }
+    visitor(objAddr);
+    size_t allocSize = GetAllocSize(size);
+    if (currentAddr - objAddr <= allocSize) {
+      break;
+    }
+    objAddr += allocSize;
+  }
+  return true;
+}
+
+constexpr int kDecoupleTagNamesAlign = 20;
+
+void DecoupleAllocator::DumpUsage(std::basic_ostream<char> &os) {
+  std::vector<std::pair<uint64_t, size_t>> profile;
+  for (int i = 0; i < static_cast<int>(DecoupleTag::kTagMax); ++i) {
+    profile.push_back(std::make_pair(0, 0));
+  }
+  address_t objAddr = startAddr + DecoupleAllocHeader::kHeaderSize;
+  while (objAddr < currentAddr) {
+    int tag = DecoupleAllocHeader::GetTag(objAddr);
+    if (tag < static_cast<int>(DecoupleTag::kTagMax)) {
+      profile[tag].first++;
+    } else {
+      os << "tag broken at " << objAddr << ", tag " << tag << "\n";
+      break;
+    }
+    size_t size = DecoupleAllocHeader::GetSize(objAddr);
+    if (size < DecoupleAllocHeader::kMaxSize) {
+      profile[tag].second += size;
+    } else {
+      os << "size broken at " << objAddr << ", tag " << tag << ", size " << size << "\n";
+      break;
+    }
+    size_t allocSize = GetAllocSize(size);
+    if (currentAddr - objAddr <= allocSize) {
+      break;
+    }
+    objAddr += allocSize;
+  }
+  os << showmapName << " space usage:\n";
+  for (uint16_t i = 0; i < DecoupleTag::kTagMax; ++i) {
+    os << " " << std::setw(kDecoupleTagNamesAlign) << kDecoupleTagNames[i] << ": count " << profile[i].first <<
+        ", total size " << profile[i].second << "\n";
+  }
+}
+
+address_t MetaAllocator::Alloc(size_t size, MetaTag metaTag) {
+  size_t allocSize = AllocUtilRndUp<address_t>(size, kBPAllocObjAlignment);
+  address_t resultAddr = AllocInternal(allocSize);
+  sizeUsed[metaTag] += allocSize;
+  return resultAddr;
+}
+
+void MetaAllocator::DumpUsage(std::basic_ostream<char> &os) {
+  os << "Class meta: " << sizeUsed[kClassMetaData] << "\n";
+  os << "Field meta: " << sizeUsed[kFieldMetaData] << "\n";
+  os << "Method meta: " << sizeUsed[kMethodMetaData] << "\n";
+  os << "VTable meta: " << sizeUsed[kITabMetaData] << "\n";
+  os << "Native string: " << sizeUsed[kNativeStringData] << "\n";
+}
+
+void ZterpStaticRootAllocator::VisitStaticRoots(const RefVisitor &visitor) {
+  std::lock_guard<std::mutex> lock(globalLock);
+  size_t spaceAddr = startAddr;
+  while (spaceAddr < currentAddr) {
+    address_t *rootAddr = *(reinterpret_cast<address_t**>(spaceAddr));
+    LinkerRef ref(rootAddr);
+    if (!ref.IsIndex()) {
+      visitor(*rootAddr);
+    }
+    spaceAddr += singleObjSize;
+  }
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/allocator/mem_map.cpp b/src/mrt/compiler-rt/src/allocator/mem_map.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f364a260ff02ac62cf10861eefd73c56f89991ff
--- /dev/null
+++ b/src/mrt/compiler-rt/src/allocator/mem_map.cpp
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "allocator/mem_map.h"
+
+#include <sys/mman.h>
+#include <algorithm>
+#include "sizes.h"
+#include "syscall.h"
+#include "libs.h"
+
+namespace maplert {
+using namespace std;
+
+// not thread safe, do not call from multiple threads
+MemMap *MemMap::MapMemory(size_t reqSize, size_t initSize, const Option &opt) {
+  void *mappedAddr = MAP_FAILED;
+  reqSize = AllocUtilRndUp<size_t>(reqSize, ALLOCUTIL_PAGE_SIZE);
+
+  LOG2FILE(kLogTypeAllocator) << "MemMap::MapMemory size " << reqSize << std::endl;
+  if (kEnableRange && opt.reqRange) {
+    // repeatedly map and guarantee the result is in the specified range
+    mappedAddr = MemMapInRange(opt.lowestAddr, opt.highestAddr, reqSize, PROT_NONE, opt.flags);
+  } else {
+    mappedAddr = mmap(opt.reqBase, reqSize, PROT_NONE, opt.flags, -1, 0);
+  }
+
+  bool failure = false;
+  if (mappedAddr != MAP_FAILED) {
+    MRT_PRCTL(mappedAddr, reqSize, opt.tag);
+    // if protAll, all memory is protected at creation, and we never change it (save time)
+    size_t protSize = opt.protAll ? reqSize : initSize;
+    if (!ProtectMemInternal(mappedAddr, protSize, opt.prot)) {
+      failure = true;
+      LOG(ERROR) << "MemMap::MapMemory mprotect failed" << maple::endl;
+      ALLOCUTIL_MEM_UNMAP(mappedAddr, reqSize);
+    }
+  } else {
+    failure = true;
+  }
+  if (failure) {
+    LOG(FATAL) << "MemMap::MapMemory failed reqSize: " << reqSize << " initSize: " << initSize <<
+        " reqRange: " << opt.reqRange;
+  }
+
+  LOG2FILE(kLogTypeAllocator) << "MemMap::MapMemory size " << reqSize <<
+      " successful at " << mappedAddr << std::endl;
+  return new MemMap(mappedAddr, initSize, reqSize, opt.protAll, opt.prot);
+}
+
+MemMap *MemMap::CreateMemMapAtExactAddress(void *addr, size_t size, const Option &opt) {
+  const size_t pageSize = static_cast<size_t>(sysconf(_SC_PAGESIZE));
+  uintptr_t uaddr = reinterpret_cast<uintptr_t>(addr);
+  if (uaddr % pageSize != 0) {
+    LOG(FATAL) << "try to mmap at address " << std::hex << uaddr << std::dec << " which is not page-aligned" <<
+        maple::endl;
+  }
+
+  void *mappedAddr = mmap(addr, size, opt.prot, opt.flags | MAP_FIXED, -1, 0);
+  if (mappedAddr != MAP_FAILED && uaddr == reinterpret_cast<uintptr_t>(mappedAddr)) {
+    MRT_PRCTL(mappedAddr, size, opt.tag);
+    return new MemMap(mappedAddr, size, size, opt.protAll, opt.prot);
+  } else {
+    LOG(FATAL) << "MemMap::CreateMemMapAtExactAddress failed to map memory at 0x: " << std::hex << uaddr <<
+        std::dec << " size: " << size << maple::endl;
+  }
+
+  return nullptr;
+}
+
+MemMap::MemMap(void *baseAddr, size_t initSize, size_t mappedSize, bool protAll, int prot)
+    : memBaseAddr(baseAddr),
+      memCurrSize(initSize),
+      memMappedSize(mappedSize),
+      protOnce(protAll),
+      memProt(prot) {
+  memCurrEndAddr = reinterpret_cast<void*>(reinterpret_cast<address_t>(memBaseAddr) + memCurrSize);
+  memMappedEndAddr = reinterpret_cast<void*>(reinterpret_cast<address_t>(memBaseAddr) + memMappedSize);
+}
+
+bool MemMap::ProtectMemInternal(void *addr, size_t size, int prot) {
+  LOG2FILE(kLogTypeAllocator) << "MemMap::ProtectMem " << addr << ", size " <<
+      size << ", prot " << prot << std::endl;
+  int ret = mprotect(addr, size, prot);
+  return (ret == 0);
+}
+
+bool MemMap::ProtectMem(address_t addr, size_t size, int prot) const {
+  if (addr >= reinterpret_cast<address_t>(memBaseAddr) &&
+      addr + size <= reinterpret_cast<address_t>(memCurrEndAddr)) {
+    return ProtectMemInternal(reinterpret_cast<void*>(addr), size, prot);
+  }
+  return false;
+}
+
+void MemMap::UpdateCurrEndAddr() {
+  address_t startAddr = (reinterpret_cast<address_t>(memBaseAddr));
+  memCurrEndAddr = reinterpret_cast<void*>(startAddr + memCurrSize);
+}
+
+bool MemMap::Extend(size_t reqSize) {
+  if (memCurrSize >= memMappedSize) {
+    LOG(ERROR) << "MemMap::Extend failed, curr size " << memCurrSize <<
+        ", mapped size " << memMappedSize << maple::endl;
+    return false;
+  }
+  size_t newCurrSize = memCurrSize + reqSize;
+  if (newCurrSize > memMappedSize) {
+    LOG(ERROR) << "MemMap::Extend invalid new size " << newCurrSize <<
+        ", mapped size " << memMappedSize << maple::endl;
+    return false;
+  }
+  if (!protOnce && !ProtectMemInternal(memCurrEndAddr, reqSize, memProt)) {
+    LOG(ERROR) << "MemMap::Extend mprotect failed" << maple::endl;
+    return false;
+  }
+  memCurrSize = newCurrSize;
+  UpdateCurrEndAddr();
+  LOG2FILE(kLogTypeAllocator) << "MemMap::Extend successful, curr size " <<
+      memCurrSize << ", mapped size " << memMappedSize << std::endl;
+  return true;
+}
+
+bool MemMap::ReleaseMem(address_t releaseBeginAddr, size_t size) const {
+  address_t baseAddr = reinterpret_cast<address_t>(memBaseAddr);
+  address_t currEndAddr = reinterpret_cast<address_t>(memCurrEndAddr);
+  address_t releaseEndAddr = releaseBeginAddr + size;
+  if (releaseBeginAddr < baseAddr || releaseEndAddr > currEndAddr) {
+    return false;
+  }
+  ALLOCUTIL_MEM_MADVISE(releaseBeginAddr, size, MADV_DONTNEED);
+  return true;
+}
+
+// resize the memory map by releasing the pages at the end (munmap)
+bool MemMap::Shrink(size_t newSize) {
+  if (newSize >= memMappedSize) {
+    return false;
+  }
+  address_t newEndAddr = reinterpret_cast<address_t>(memBaseAddr) + newSize;
+  memMappedEndAddr = reinterpret_cast<void*>(newEndAddr);
+  ALLOCUTIL_MEM_UNMAP(memMappedEndAddr, memMappedSize - newSize);
+  memMappedSize = newSize;
+  memCurrSize = std::min(newSize, memCurrSize);
+  return true;
+}
+
+void *MemMap::MemMapInRange(address_t lowestAddr, address_t highestAddr,
+                            size_t reqSize, int prot, int flags, int fd, int offset) {
+  lowestAddr = AllocUtilRndUp<address_t>(lowestAddr, ALLOCUTIL_PAGE_SIZE);
+  highestAddr = AllocUtilRndDown<address_t>(highestAddr, ALLOCUTIL_PAGE_SIZE);
+  if (lowestAddr >= highestAddr || highestAddr - lowestAddr < reqSize) {
+    LOG(ERROR) << "MemMap::MemMapInRange illegal range [" << lowestAddr <<
+        ", " << highestAddr << "]" << maple::endl;
+    return MAP_FAILED;
+  }
+  void *mappedAddr = MAP_FAILED;
+  highestAddr -= reqSize;
+  AllocUtilRand<address_t> randAddr(lowestAddr, highestAddr);
+  if (kEnableRandomMemStart) {
+    // The hint doesn't guarantee the actually mapped address is in the specified range.
+    // If the hint address is already occupied, mmap will try other arbitrary addresses.
+    // We need to check the result, and repeat if fails.
+    int repeat = 10;
+    while (mappedAddr == MAP_FAILED && (--repeat) != 0) {
+      address_t hint = AllocUtilRndUp(randAddr.next(), ALLOCUTIL_PAGE_SIZE);
+      mappedAddr = MemMapInRangeInternal(hint, lowestAddr, highestAddr,
+                                         reqSize, prot, flags | MAP_FIXED, fd, offset);
+    }
+  }
+  if (mappedAddr == MAP_FAILED) {
+    for (address_t addr = lowestAddr; addr <= highestAddr; addr += ALLOCUTIL_PAGE_SIZE) {
+      mappedAddr = MemMapInRangeInternal(addr, lowestAddr, highestAddr,
+                                         reqSize, prot, flags | MAP_FIXED, fd, offset);
+      if (mappedAddr != MAP_FAILED) {
+        break;
+      }
+    }
+  }
+  if (mappedAddr == MAP_FAILED) {
+    LOG(ERROR) << "MemMap::MemMapInRange failed" << maple::endl;
+  } else {
+    LOG2FILE(kLogTypeAllocator) << "MemMap::MemMapInRange returns " << mappedAddr << std::endl;
+  }
+  return mappedAddr;
+}
+
+void *MemMap::MemMapInRangeInternal(address_t hint,
+                                    address_t lowestAddr, address_t highestAddr,
+                                    size_t reqSize, int prot, int flags,
+                                    int fd, int offset) {
+  void *mappedAddr = mmap(reinterpret_cast<void*>(hint), reqSize, prot, flags, fd, offset);
+  if (mappedAddr == MAP_FAILED) {
+    LOG2FILE(kLogTypeAllocator) <<
+        FormatString("map memory at %p: hint %p, low %p, high %p, size %zu, prot %x, flags %x, fd %d, offset %d",
+                     mappedAddr, hint, lowestAddr, highestAddr, reqSize, prot, flags, fd, offset);
+  } else if (reinterpret_cast<address_t>(mappedAddr) < lowestAddr ||
+             reinterpret_cast<address_t>(mappedAddr) > highestAddr) {
+    LOG2FILE(kLogTypeAllocator) <<
+        FormatString("map memory at %p: hint %p, low %p, high %p, size %zu, prot %x, flags %x, fd %d, offset %d",
+                     mappedAddr, hint, lowestAddr, highestAddr, reqSize, prot, flags, fd, offset);
+    ALLOCUTIL_MEM_UNMAP(mappedAddr, reqSize); // roll back
+    mappedAddr = MAP_FAILED;
+  }
+  return mappedAddr;
+}
+
+MemMap::~MemMap() {
+  memBaseAddr = nullptr;
+  memCurrEndAddr = nullptr;
+  memMappedEndAddr = nullptr;
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/allocator/page_map.cpp b/src/mrt/compiler-rt/src/allocator/page_map.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..acbcccbef93039f38f5475f2526f3004ee879fee
--- /dev/null
+++ b/src/mrt/compiler-rt/src/allocator/page_map.cpp
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "allocator/page_map.h"
+#include "allocator/alloc_config.h"
+
+// Definitions of page map
+namespace maplert {
+PageMap::PageMap()
+    : spaceBeginAddr(0),
+      spaceEndAddr(0),
+      maxMapSize(0),
+      pageMapSize(0),
+      memMap(nullptr),
+      map(nullptr) {
+}
+
+PageMap::~PageMap() {
+  ROSIMPL_VERIFY_DUMP_PG_TABLE;
+  spaceBeginAddr = 0;
+  spaceEndAddr = 0;
+  MemMap::DestroyMemMap(memMap);
+  // memory will be released by memMap
+  map = nullptr;
+}
+
+void PageMap::Init(address_t baseAddr, size_t maxSize, size_t size) {
+  spaceBeginAddr = baseAddr;
+  spaceEndAddr = baseAddr + size;
+  maxMapSize = ALLOCUTIL_PAGE_BYTE2CNT(maxSize);
+  pageMapSize = ALLOCUTIL_PAGE_BYTE2CNT(size);
+
+  size_t reqSize = ALLOCUTIL_PAGE_RND_UP(maxMapSize);
+  MemMap::Option opt = MemMap::kDefaultOptions;
+  opt.tag = "maple_alloc_ros_pm";
+  opt.reqBase = nullptr;
+  opt.reqRange = false;
+  memMap = MemMap::MapMemory(reqSize, reqSize, opt);
+  map = static_cast<PageLabel*>(memMap->GetBaseAddr());
+  if (UNLIKELY(map == nullptr)) {
+    LOG(FATAL) << "page map initialisation failed";
+  }
+  SetRange(0, maxMapSize, kPReleased);
+
+  // As for now, the assignment to maxMapSize in this function is the only
+  // assignment.  This means the heap memory mapped to the address space never
+  // exceeds this size.  We initialize finProf to create a table of this size,
+  // so that the table is big enough even when the heap size is changed.
+  finProf.Init(maxMapSize);
+
+  LOG2FILE(kLogTypeAllocator) << "[PageMap] number of entries " << pageMapSize << ". address " << map << std::endl;
+}
+
+constexpr uint32_t kMaxNumPerLine = 10;
+
+void PageMap::Dump() {
+  LOG2FILE(kLogTypeAllocator) << "[PageMap] number of entries: " << pageMapSize << "\n";
+  LOG2FILE(kLogTypeAllocator) << "          max number of entries: " << maxMapSize << "\n";
+  LOG2FILE(kLogTypeAllocator) << "          spaceBeginAddr = 0x" << std::hex << spaceBeginAddr << "\n";
+  LOG2FILE(kLogTypeAllocator) << "          spaceEndAddr = 0x" << std::hex << spaceEndAddr << "\n";
+  std::stringstream ss;
+  bool skipFreePages = true;
+  if (map != nullptr) {
+    for (IntType i = 0 ; i < GetMapSize(); ++i) {
+      if (skipFreePages && static_cast<int>(map[i]) <= static_cast<int>(kPFree)) {
+        continue;
+      }
+      if (i % kMaxNumPerLine == 0) {
+        ss << "\n          [" << i << "]:" << static_cast<int>(map[i]);
+        continue;
+      }
+      ss << "  [" << i << "]:" << static_cast<int>(map[i]);
+    }
+  }
+  LOG2FILE(kLogTypeAllocator) << ss.str().c_str() << std::endl;
+}
+
+void PageMap::DumpFinalizableInfo(std::ostream &ost) {
+  ost << "Dumping finalizable information for each page" << std::endl;
+
+  IntType touched = 0;
+  IntType hasFins = 0;
+
+  for (IntType index = 0; index < maxMapSize; ++index) {
+    FinalizableProf::PageEntry &entry = finProf.GetEntry(index);
+#if MRT_RESURRECTION_PROFILE == 1
+    size_t incs = entry.incs.load(std::memory_order_relaxed);
+    size_t decs = entry.decs.load(std::memory_order_relaxed);
+#endif // MRT_RESURRECTION_PROFILE
+    uint16_t fins = entry.fins.load(std::memory_order_relaxed);
+    if (
+#if MRT_RESURRECTION_PROFILE == 1
+      incs == 0 && decs == 0 &&
+#endif // MRT_RESURRECTION_PROFILE
+      fins == 0
+    ) {
+      continue;
+    }
+
+    ++touched;
+
+    if (fins != 0) {
+      ++hasFins;
+    }
+
+    ost << "  index: " << index <<
+#if MRT_RESURRECTION_PROFILE == 1
+        "  incs:" << incs <<
+        "  decs:" << decs <<
+#endif // MRT_RESURRECTION_PROFILE
+        "  fins:" << fins <<
+        std::endl;
+  }
+
+  ost << "maxMapSize: " << maxMapSize << std::endl;
+  ost << "touched: " << touched << std::endl;
+  ost << "hasFins: " << hasFins << std::endl;
+  ost << "pageMapSize: " << pageMapSize << std::endl;
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/allocator/ros_allocator.cpp b/src/mrt/compiler-rt/src/allocator/ros_allocator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..334bcbe1ffe5602fdf8a7b1f121669b21b2a213a
--- /dev/null
+++ b/src/mrt/compiler-rt/src/allocator/ros_allocator.cpp
@@ -0,0 +1,1556 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <cstdint>
+#include <cstdlib>
+#include <cinttypes>
+#include <mutex>
+#include <iostream>
+#include <iomanip>
+#include "chosen.h"
+#include "allocator/alloc_callbacks.h"
+#include "allocator/ros_allocator_inlined.h"
+#include "yieldpoint.h"
+#include "exception/mpl_exception.h"
+#include "mstring_inline.h"
+
+namespace maplert {
+using namespace maple;
+
+uint8_t RosAllocImpl::kRunMagic;
+
+// REMEMBER TO CHANGE kRunConfigs WHEN YOU ADD/REMOVE CONFIGS
+// this stores a config for each kind of run (represented by an index)
+const RunConfigType RunConfig::kCfgs[kRunConfigs] = {
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 16 },
+
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 24 },
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 32 },
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 40 },
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 48 },
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 56 },
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 64 },
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 72 },
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 80 },
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 88 },
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 96 },
+    // [1] this size must be the same with kROSAllocLocalSize
+    // [2] all sizes smaller than this must also use local
+    // [3] all sizes smaller must increment by 8
+    //     ([2, 3] are optimisations, rather than restrictions)
+    { true, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 104 },
+
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 112 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 120 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 128 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 136 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 144 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 152 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 160 },
+
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 168 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 176 },
+
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 184 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 192 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 200 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 208 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 216 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 224 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 232 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 240 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 248 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 256 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 264 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 272 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 280 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 288 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 296 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 304 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 312 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 320 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 328 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 336 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 344 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 352 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 360 },
+
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 400 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 448 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 504 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 576 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 672 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 800 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 1008 },
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 1344 },
+    // this size must be the same with kROSAllocLargeSize
+    { false, kRosimplDefaultMaxCacheRun, kRosimplDefaultPagePerRun, 2016 }
+};
+// this map maps a size ((size >> 3 - 1) to be precise) to a run config
+// this map takes 4 * kMaxRunConfigs == 1k
+uint32_t RunConfig::size2idx[kMaxRunConfigs] = { 0 }; // all zero-initialised
+
+// this function inits the config map using the configs above
+// so that for any size there is a config for it
+// if the size doesn't match any of the configs exactly, we choose
+// the closest config with a greater size, e.g.,
+// size2idx[456 >> 3 - 1] == size2idx[464 >> 3 - 1] == .. == size2idx[504 >> 3 - 1]
+static void InitRunConfigMap() {
+  constexpr uint32_t runSizeShift = 3;
+  ROSIMPL_ASSERT(RunConfig::kRunConfigs <= RunConfig::kMaxRunConfigs, "too many configs");
+  uint32_t idx = RunConfig::kRunConfigs;
+  uint32_t nextSize = RunConfig::kCfgs[RunConfig::kRunConfigs - 1].size;
+  ROSIMPL_ASSERT(nextSize <= (RunConfig::kMaxRunConfigs << runSizeShift), "size too big in config");
+  uint32_t i = (RunConfig::kMaxRunConfigs - 1);
+  while (true) {
+    if (((i + 1) << runSizeShift) > nextSize) {
+      if (idx < RunConfig::kRunConfigs) {
+        RunConfig::size2idx[i] = idx;
+      }
+    } else {
+      ROSIMPL_ASSERT(((i + 1) << runSizeShift) == nextSize, "init run config error");
+      ROSIMPL_ASSERT(idx > 0, "init run config error");
+      RunConfig::size2idx[i] = --idx;
+      if (idx > 0 && idx < RunConfig::kRunConfigs) {
+        ROSIMPL_ASSERT(static_cast<size_t>(RunConfig::kCfgs[idx - 1].size) < nextSize, "not in ascending order");
+        nextSize = RunConfig::kCfgs[idx - 1].size;
+      } else {
+        nextSize = 0;
+      }
+    }
+
+    if (i == 0) {
+      break;
+    } else {
+      --i;
+    }
+  }
+
+#if ROSIMPL_ENABLE_ASSERTS
+  for (i = 0; i <= ROSIMPL_RUN_IDX(kROSAllocLocalSize); ++i) {
+    ROSIMPL_ASSERT(ROSIMPL_IS_LOCAL_RUN_IDX(i), "run config inconsistent: small idx not local");
+  }
+#endif
+  ROSIMPL_ASSERT(ROSIMPL_RUN_IDX(kROSAllocLargeSize) + 1 == RunConfig::kRunConfigs,
+                 "run config inconsistent: large size");
+}
+
+size_t RunSlots::maxSlots[RunConfig::kRunConfigs] = {};
+
+// max number of pages for a single parallel task.
+constexpr size_t kMaxPagesPerTask = 256; // 4K * 256 = 1M
+
+// FreeList
+void FreeList::Init(address_t baseAddr, size_t slotSize, size_t slotCount) {
+  ROSIMPL_ASSERT(slotCount > 0, "cannot init free list with 0 slot");
+  SetHead(baseAddr);
+  Slot *lastSlot = reinterpret_cast<Slot*>(baseAddr);
+  address_t currAddr = baseAddr;
+  for (size_t ind = 1; ind < slotCount; ++ind) {
+#if (!ROSIMPL_MEMSET_AT_FREE)
+#if CONFIG_JSAN || RC_HOT_OBJECT_DATA_COLLECT
+    // SetNext() will fail to clear the 'allocated' bit in jsan, so we manually clear it
+    ClearAllocatedBit(ROSIMPL_GET_OBJ_FROM_ADDR(currAddr));
+#endif
+#endif
+    currAddr += slotSize;
+    lastSlot->SetNext(currAddr);
+    lastSlot = reinterpret_cast<Slot*>(currAddr);
+  }
+
+  SetTail(currAddr);
+  lastSlot->SetNext(0);
+#if (!ROSIMPL_MEMSET_AT_FREE)
+#if CONFIG_JSAN || RC_HOT_OBJECT_DATA_COLLECT
+  // SetNext() will fail to clear the 'allocated' bit in jsan, so we manually clear it
+  ClearAllocatedBit(ROSIMPL_GET_OBJ_FROM_ADDR(currAddr));
+#endif
+#endif
+}
+
+// RunSlots
+RunSlots::RunSlots(uint32_t idx) : padding(0) {
+#if ROSIMPL_MEMSET_AT_FREE
+  ROSIMPL_ASSERT(magic == 0U, "initializing run with dirty memory");
+#endif
+  magic = RosAllocImpl::kRunMagic;
+  mIdx = static_cast<uint8_t>(idx);
+  flags = 0;
+  SetNext(nullptr);
+  SetPrev(nullptr);
+}
+
+void RunSlots::Init(bool setInitRelease) {
+  size_t slotsCount = GetMaxSlots();
+  address_t slotAddr = GetBaseAddress();
+
+  freeList.Init(slotAddr, GetRunSize(), slotsCount);
+  nFree = static_cast<uint32_t>(slotsCount);
+  if (setInitRelease) {
+    SetInitRelease();
+  } else {
+    SetInit();
+  }
+}
+
+void RunSlots::ForEachObj(function<void(address_t)> visitor, OnlyVisit onlyVisit, size_t hint) {
+  size_t runUnitSize = GetRunSize();
+  size_t slotsCount = GetMaxSlots();
+  address_t slotAddr = GetBaseAddress();
+
+  if (UNLIKELY(slotsCount == 0)) {
+    return;
+  }
+
+  // Hoist the test for onlyVisit outside the loop.  This may result in some
+  // code duplication.
+  if (onlyVisit == OnlyVisit::kVisitFinalizable) {
+    size_t toVisit = hint;
+    for (size_t idx = 0; idx < slotsCount; ++idx) {
+      address_t objAddr = ROSIMPL_GET_OBJ_FROM_ADDR(slotAddr);
+      if (IsAllocatedByAllocator(objAddr) && IsObjResurrectable(objAddr)) {
+        visitor(objAddr);
+        --toVisit;
+        if (toVisit == 0) {
+          break;
+        }
+      }
+      slotAddr += runUnitSize;
+    }
+  } else {
+    for (size_t idx = 0; idx < slotsCount; ++idx) {
+      address_t objAddr = ROSIMPL_GET_OBJ_FROM_ADDR(slotAddr);
+      if (IsAllocatedByAllocator(objAddr)) {
+        visitor(objAddr);
+      }
+      slotAddr += runUnitSize;
+    }
+  }
+}
+
+// return true if the given address represents a live object
+bool RunSlots::IsLiveObjAddr(address_t objAddr) const {
+  // since there is no lock, a mutator might be allocating/freeing from this run
+  // at the same time, so there is a slight inaccuracy that the caller should be aware of
+  address_t slotAddr = ROSIMPL_GET_ADDR_FROM_OBJ(objAddr);
+  address_t firstSlotAddr = GetBaseAddress();
+  size_t slotsCount = GetMaxSlots();
+  address_t lastSlot = firstSlotAddr + (slotsCount - 1) * GetRunSize();
+  if (!(slotAddr <= lastSlot && slotAddr >= firstSlotAddr)) {
+    return false;
+  }
+  if (((slotAddr - firstSlotAddr) % GetRunSize()) != 0)
+    return false;
+
+  return IsAllocatedByAllocator(objAddr);
+}
+
+bool RunSlots::Sweep(RosAllocImpl& allocator) {
+  // get & check sweep context.
+  SweepContext &context = allocator.sweepContext;
+
+  // get page index of this run page.
+  size_t pageIndex = allocator.pageMap.GetPageIndex(reinterpret_cast<address_t>(this));
+
+  // try to set page to sweeping state.
+  PageLabel pageType = kPMax;
+  if (!context.SetSweeping(pageIndex, pageType)) {
+    // page already swept.
+    return false;
+  }
+
+  ROSIMPL_ASSERT(pageType == kPRun, "Sweep: incorrect page type");
+
+  // if set sweeping state success, run sweep for this run page.
+  return DoSweep(allocator, context, pageIndex);
+}
+
+bool RunSlots::DoSweep(RosAllocImpl &allocator, SweepContext &context, size_t pageIndex) {
+  ROSIMPL_ASSERT(HasInit(), "run not initialised");
+  const bool fullBeforeSweep = IsFull();
+  const size_t slotSize = GetRunSize();
+  std::vector<address_t> deadNeighbours;
+  size_t releasedCount = 0;
+  size_t releasedBytes = 0;
+  bool updateState = false;
+
+  // count scaned runs.
+  (void)context.scanedRuns.fetch_add(1, std::memory_order_relaxed);
+
+  if (IsEmpty()) {
+    // if run is empty, do nothing but set page swept.
+    context.SetSwept(pageIndex);
+    return false;
+  }
+
+  // for all dead objects in this RunSlots.
+  ForEachObj([this, &allocator, &deadNeighbours, &releasedCount, &releasedBytes, slotSize](address_t obj) {
+    // skip live objects.
+    if (!Collector::Instance().IsGarbage(obj)) {
+      return;
+    }
+
+#if CONFIG_JSAN
+    // when JSAN is enabled, skip objects held by JSAN.
+    if (JSANGetObjStatus(obj) == kObjStatusQuarantined) {
+      return;
+    }
+#endif
+
+    Collector::Instance().HandleNeighboursForSweep(obj, deadNeighbours);
+
+    allocator.SweepSlot(*this, ROSIMPL_GET_ADDR_FROM_OBJ(obj));
+    ++releasedCount;
+    releasedBytes += slotSize;
+  });
+
+  // To prevent dead lock, we do not release dead neighbours here,
+  // but save them to sweep context, so that we can release them later.
+  if (UNLIKELY(!deadNeighbours.empty())) {
+    context.AddDeadNeighbours(deadNeighbours);
+  }
+
+  // if there are released objects.
+  if (releasedCount > 0) {
+    // statistics in sweep context.
+    (void)context.sweptRuns.fetch_add(1, std::memory_order_relaxed);
+    (void)context.releasedObjects.fetch_add(releasedCount, std::memory_order_relaxed);
+    (void)context.releasedBytes.fetch_add(releasedBytes, std::memory_order_relaxed);
+    FAST_ALLOC_ACCOUNT_SUB(releasedBytes);
+
+    updateState = (*theAllocator).UpdateGlobalsAfterFree(*this, fullBeforeSweep);
+  }
+
+  // set page swept.
+  context.SetSwept(pageIndex);
+
+  return updateState;
+}
+
+// RosAllocImpl
+// the global mutator is a proxy for non-local allocation
+// this mutator doesn't need to be initialised or finalised, we only need its lists/runs
+ROSAllocMutator<RunConfig::kRunConfigs> RosAllocImpl::globalMutator;
+
+#if ALLOC_ENABLE_LOCK_CONTENTION_STATS
+uint32_t RosAllocImpl::pageLockContentionRec = 0;
+uint64_t RosAllocImpl::pageLockWaitTimeRec = 0U;
+#endif
+
+FastAllocData FastAllocData::data;
+
+FragmentationRecord fragRec;
+
+RosAllocImpl::RosAllocImpl()
+    : Allocator(),
+      pageMap(),
+      allocSpace("ROS memory space", "maple_alloc_ros", true, pageMap) { // managed space
+  LOG2FILE(kLogTypeAllocator) << "Initializing RosAllocImpl" << std::endl;
+  InitRunConfigMap();
+
+  // initialize run array to be full
+  for (int i = 0; i < kNumberROSRuns; ++i) {
+    size_t maxBytes = ALLOCUTIL_PAGE_CNT2BYTE(ROSIMPL_N_PAGES_PER_RUN(i)) -
+        RunSlots::GetContentOffset();
+    RunSlots::maxSlots[i] = maxBytes / ROSIMPL_RUN_SIZE(i);
+  }
+  LOG2FILE(kLogTypeAllocator) << "Finished Initializing RosAllocImpl" << std::endl;
+}
+
+void RosAllocImpl::Init(const VMHeapParam &vmHeapParam) {
+  AllocUtilRand<size_t> rand(0, std::numeric_limits<uint8_t>::max());
+  kRunMagic = static_cast<uint8_t>(rand.next());
+  Space::SetHeapStartSize(vmHeapParam.heapStartSize);
+  Space::SetHeapSize(vmHeapParam.heapSize);
+  // We should use this one in future
+  Space::SetHeapGrowthLimit(vmHeapParam.heapGrowthLimit);
+  // this overwrites the previous Set(), because currently we don't
+  // distinguish large-heap processes from small-heap processes
+  Space::SetHeapGrowthLimit(vmHeapParam.heapSize);
+  Space::SetHeapMinFree(vmHeapParam.heapMinFree);
+  Space::SetHeapMaxFree(vmHeapParam.heapMaxFree);
+  Space::SetHeapTargetUtilization(vmHeapParam.heapTargetUtilization);
+  Space::SetIgnoreMaxFootprint(vmHeapParam.ignoreMaxFootprint);
+  allocSpace.Init();
+  pageMap.Init(reinterpret_cast<address_t>(allocSpace.GetBegin()),
+               allocSpace.GetMaxCapacity(), allocSpace.GetSize());
+  if (VLOG_IS_ON(jsanlite)) {
+    JsanliteInit();
+  }
+}
+
+RosAllocImpl::~RosAllocImpl() {
+  LOG2FILE(kLogTypeAllocator) << "Destructing RosAllocImpl" << std::endl;
+}
+
+address_t RosAllocImpl::AllocPagesInternal(size_t reqSize, size_t &actualSize, int forceLevel) {
+  actualSize = ALLOCUTIL_PAGE_RND_UP(reqSize);
+  // we allow extension, assuming that concurrent gc has done
+  // everything it can to reduce footprint
+  size_t oldSize = allocSpace.GetSizeRelaxed();
+  address_t retAddress = allocSpace.Alloc(actualSize, true);
+  // update page map if the heap was extended
+  size_t newSize = allocSpace.GetSizeRelaxed();
+  if (UNLIKELY(newSize > oldSize)) {
+    pageMap.UpdateSize(newSize);
+    // on successful extension, check the heap growth against the threshold
+    // and trigger non-blocking concurrent gc if condition met
+    // don't trigger if forceLevel too high (indicating other gc must have been done)
+    if (forceLevel < static_cast<int>(kEagerLevelExtend)) {
+      size_t threshold = stats::gcStats->CurGCThreshold();
+      size_t allocated = AllocatedMemory();
+      if (allocated >= threshold) {
+        // we are holding the global lock, and the object hasn't been properly
+        // initialised, this is considered unsafe
+        Collector::Instance().InvokeGC(kGCReasonHeu, true);
+      }
+    }
+  }
+
+  return retAddress;
+}
+
+address_t RosAllocImpl::NewObj(size_t size) {
+  size_t allocSize = AllocUtilRndUp((size + ROSIMPL_HEADER_ALLOC_SIZE + JsanliteGetPayloadSize(size)),
+                                    kAllocAlign);
+  address_t allocAddr = AllocInternal(allocSize);
+  if (UNLIKELY(allocAddr == 0)) {
+    return allocAddr;
+  }
+  address_t resultAddr = ROSIMPL_GET_OBJ_FROM_ADDR(allocAddr);
+
+  // Free slots in RoS begin with a pointer, which lowest 3 bits are always 0.
+  // By setting one of them 1 (currently the lowest bit), we can tell if a slot
+  // has been allocated.
+  // This bit is automatically cleared when a slot is created/freed.
+  // For large objects, we also set this bit, but we use
+  // other ways to tell if it is allocated by us (page type).
+  InitWithAllocatedBit(resultAddr);
+
+  // When concurrent mark is running, we need to set the newly
+  // allocated object as marked to prevent it be swept by GC.
+  Collector::Instance().PostNewObject(resultAddr);
+
+#if ALLOC_USE_FAST_PATH
+  if (allocSize > kLargeObjSize) {
+    // this is a bit ugly but in fast-alloc mode, small alloc's stats is managed
+    // differently, we only need to account for the non-local allocs here
+    FAST_ALLOC_ACCOUNT_ADD(allocSize);
+  }
+#else
+  PostObjAlloc(resultAddr, size, allocSize);
+#endif
+  ROSIMPL_ASSERT(!IsMygotePageAlloc(reinterpret_cast<address_t>(resultAddr)), "do not allocat in mygote page");
+  return resultAddr;
+}
+
+void RosAllocImpl::FreeObj(address_t objAddr) {
+  __MRT_ASSERT(!IsMygotePageAlloc(reinterpret_cast<address_t>(objAddr)), "do not free object in mygote page");
+#if !CONFIG_JSAN
+  __MRT_ASSERT(Collector::Instance().Type() == kNaiveRC, "unexpected type");
+#endif
+#if LOG_ALLOC_TIMESTAT
+  TheAllocMutator *mut = TLAllocMutatorPtr();
+  if (mut != nullptr && mut->DoFreeObjTimeStat()) {
+    mut->StartTimer();
+  }
+#endif
+  // release monitor
+  maplert::Allocator::ReleaseResource(objAddr);
+
+  size_t objSize = PreObjFree(objAddr);
+  size_t freedBytes = 0U;
+  JsanliteFree(objAddr);
+  JSAN_FREE(objAddr, FreeInternal, freedBytes);
+  if (freedBytes) {
+    PostObjFree(objAddr, objSize, freedBytes);
+  }
+#if LOG_ALLOC_TIMESTAT
+  int typeInd = kTimeFreeGlobal;
+  if (mut != nullptr && mut->DoFreeObjTimeStat()) {
+    if (ROSIMPL_IS_LOCAL_RUN_SIZE(freedBytes)) {
+      typeInd = kTimeFreeLocal;
+    } else if (freedBytes > kLargeObjSize) {
+      typeInd = kTimeFreeLarge;
+    }
+    mut->StopTimer(typeInd);
+  }
+#endif
+}
+
+class FreeTask : public MplTask {
+ public:
+  FreeTask(RosAllocImpl &allocatorVal, PageMap &pageMapVal, size_t beginVal,
+           size_t endVal, const function<bool(address_t)> &shouldFreeVal)
+      : allocator(allocatorVal), pageMap(pageMapVal), begin(beginVal), end(endVal), shouldFree(shouldFreeVal) {}
+  virtual ~FreeTask() {}
+  void Execute(size_t workerID __attribute__((unused))) override {
+    PageLabel pageType = kPReleased;
+    for (size_t pageIndex = begin; pageIndex < end; ++pageIndex) {
+      pageType = pageMap.GetType(pageIndex);
+      if (LIKELY(pageType == kPRun)) {
+        address_t runAddr = pageMap.GetPageAddr(pageIndex);
+        RunSlots *runSlots = reinterpret_cast<RunSlots*>(runAddr);
+        ROSIMPL_ASSERT(runSlots->HasInit(), "run not initialised");
+        ROSIMPL_DEBUG(allocator.CheckRunMagic(*runSlots));
+        ROSIMPL_ASSERT(runSlots->mIdx < RosAllocImpl::kNumberROSRuns,
+                       "runSlots returned has wrong index");
+        if (runSlots->IsLocal()) {
+          allocator.SweepLocalRun(*runSlots, shouldFree);
+        } else {
+          allocator.SweepRun(*runSlots, shouldFree);
+        }
+      } else if (UNLIKELY(pageType == kPLargeObj)) {
+        address_t memAddr = pageMap.GetPageAddr(pageIndex);
+        address_t lrgAddr = ROSIMPL_GET_OBJ_FROM_ADDR(memAddr);
+        if (shouldFree(lrgAddr)) {
+          maplert::Allocator::ReleaseResource(lrgAddr);
+          size_t objSize = allocator.PreObjFree(lrgAddr);
+          size_t freedBytes = 0U;
+#if !ROSIMPL_MEMSET_AT_FREE
+          TagGCFreeObject(lrgAddr);
+#endif
+          {
+            // FreeLargeObj will change page map, so we guard it with lock.
+            allocator.FreeLargeObj(lrgAddr, freedBytes);
+          }
+          allocator.PostObjFree(lrgAddr, objSize, freedBytes);
+        }
+      }
+    }
+  }
+
+ private:
+  RosAllocImpl &allocator;
+  PageMap &pageMap;
+  size_t begin;
+  size_t end;
+  function<bool(address_t)> shouldFree;
+};
+
+bool RosAllocImpl::ParallelFreeAllIf(MplThreadPool &threadPool, const function<bool(address_t)> &shouldFree) {
+  ROSIMPL_ASSERT(WorldStopped(), "Invalid invoke");
+
+  const int32_t threadCount = threadPool.GetMaxThreadNum() + 1;
+  const size_t lastPageIndex = pageMap.GetPageIndex(GetSpaceEnd());
+  const size_t chunkSize = std::min(lastPageIndex / static_cast<size_t>(threadCount) + 1, kMaxPagesPerTask);
+  for (size_t pageIndex = 0; pageIndex < lastPageIndex;) {
+    const size_t delta = std::min(lastPageIndex - pageIndex, chunkSize);
+    threadPool.AddTask(new FreeTask(*this, pageMap, pageIndex, pageIndex + delta, shouldFree));
+    pageIndex += delta;
+  }
+  threadPool.SetMaxActiveThreadNum(threadCount - 1);
+  threadPool.Start();
+  threadPool.WaitFinish(true);
+  return true;
+}
+
+class ForEachTask : public MplTask {
+ public:
+  struct Stats {
+    size_t pagesVisited = 0;
+    size_t pagesSkipped = 0;
+    size_t totalFinalizable = 0;
+  };
+  ForEachTask(RosAllocImpl &allocatorVal, PageMap &pageMapVal, size_t beginVal, size_t endVal,
+              const function<void(address_t)> &visitorVal, OnlyVisit onlyVisitVal,
+              const function<void(Stats&)> &onFinishVal)
+      : allocator(allocatorVal),
+        pageMap(pageMapVal),
+        begin(beginVal),
+        end(endVal),
+        visitor(visitorVal),
+        onlyVisit(onlyVisitVal),
+        onFinish(onFinishVal) {}
+
+  ~ForEachTask() {
+    onFinish(stats);
+  }
+
+  void Execute(size_t workerID __attribute__((unused))) override {
+    PageLabel pageType = kPReleased;
+    for (size_t pageIndex = begin; pageIndex < end; ++pageIndex) {
+      pageType = pageMap.GetType(pageIndex);
+      if (LIKELY(pageType == kPRun || pageType == kPMygoteRun)) {
+        address_t runAddr = pageMap.GetPageAddr(pageIndex);
+        size_t cnt = pageMap.RunPageCount(runAddr);
+        RunSlots *runSlots = reinterpret_cast<RunSlots*>(runAddr);
+        ROSIMPL_ASSERT(runSlots->HasInit(), "run not initialised");
+        ROSIMPL_ASSERT(cnt > 0, "incorrect run page count");
+        if (ShouldSkipThisRun(pageIndex)) {
+          stats.pagesSkipped += cnt;
+          pageIndex += cnt - 1; // skip all the kPRunRem
+          continue;
+        }
+        ROSIMPL_DEBUG(allocator.CheckRunMagic(*runSlots));
+        ROSIMPL_ASSERT(runSlots->mIdx < RosAllocImpl::kNumberROSRuns,
+                       "runSlots returned has wrong index");
+        // Limit the number of object to be visited.
+        size_t hint = numeric_limits<size_t>::max();
+        if (onlyVisit == OnlyVisit::kVisitFinalizable) {
+          hint = pageMap.NumOfFinalizableObjectsInRun(pageIndex);
+        }
+        allocator.ForEachObjInRun(*runSlots, visitor, onlyVisit, hint);
+        stats.pagesVisited += cnt;
+        pageIndex += cnt - 1; // skip all the kPRunRem
+      } else if (UNLIKELY(pageType == kPLargeObj || pageType == kPMygoteLargeObj)) {
+        if (ShouldSkipThisPage(pageIndex)) {
+          continue;
+        }
+        address_t memAddr = pageMap.GetPageAddr(pageIndex);
+        address_t lrgAddr = ROSIMPL_GET_OBJ_FROM_ADDR(memAddr);
+        visitor(lrgAddr);
+      }
+    }
+  }
+
+ private:
+  inline bool ShouldSkipThisPage(size_t pageIndex) {
+    if (onlyVisit == OnlyVisit::kVisitFinalizable) {
+      if (pageMap.PageHasFinalizableObject(pageIndex)) {
+        stats.totalFinalizable += pageMap.NumOfFinalizableObjectsInPage(pageIndex);
+        ++stats.pagesVisited;
+        return false;
+      } else {
+        ++stats.pagesSkipped;
+        return true;
+      }
+    } else {
+      ++stats.pagesVisited;
+      return false;
+    }
+  }
+  inline bool ShouldSkipThisRun(size_t pageIndex) {
+    if (onlyVisit == OnlyVisit::kVisitFinalizable) {
+      size_t n = pageMap.NumOfFinalizableObjectsInRun(pageIndex);
+      if (n > 0) {
+        stats.totalFinalizable += n;
+        return false;
+      } else {
+        return true;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  RosAllocImpl &allocator;
+  PageMap &pageMap;
+  size_t begin;
+  size_t end;
+  function<void(address_t)> visitor;
+  OnlyVisit onlyVisit;
+  Stats stats;
+  function<void(Stats&)> onFinish;
+};
+
+bool RosAllocImpl::ParallelForEachObj(MplThreadPool &threadPool, VisitorFactory visitorFactory,
+                                      OnlyVisit onlyVisit) {
+  ROSIMPL_ASSERT(WorldStopped(), "ParallelForEachObj can only be invoked while world stopped");
+
+#if CONFIG_JSAN
+  auto originalVisitorFactory = visitorFactory;
+  visitorFactory = [&originalVisitorFactory]() {
+    auto originalVisitor = originalVisitorFactory();
+    auto visitor = [originalVisitor](address_t obj) {   // NOTE: intentionally capture by value
+      if (JSANGetObjStatus(obj) != kObjStatusQuarantined) {
+        originalVisitor(obj);
+      }
+    };
+    // NOTE: The variable originalVisitor goes out of scope here.
+    return visitor;
+  };
+#endif
+
+  mutex statsMutex;
+  ForEachTask::Stats overallStats;
+
+  function<void(ForEachTask::Stats&)> onFinish = [&statsMutex, &overallStats](
+      const ForEachTask::Stats &taskStats) {
+    lock_guard<mutex> lg(statsMutex);
+    overallStats.pagesVisited += taskStats.pagesVisited;
+    overallStats.pagesSkipped += taskStats.pagesSkipped;
+    overallStats.totalFinalizable += taskStats.totalFinalizable;
+  };
+
+  const int32_t threadCount = threadPool.GetMaxThreadNum() + 1;
+  const size_t lastPageIndex = pageMap.GetPageIndex(GetSpaceEnd());
+  const size_t chunkSize = std::min(lastPageIndex / static_cast<size_t>(threadCount) + 1, kMaxPagesPerTask);
+  for (size_t pageIndex = 0; pageIndex < lastPageIndex;) {
+    const size_t delta = std::min(lastPageIndex - pageIndex, chunkSize);
+    threadPool.AddTask(new ForEachTask(*this, pageMap, pageIndex, pageIndex + delta,
+                       visitorFactory(), onlyVisit, onFinish));
+    pageIndex += delta;
+  }
+  threadPool.SetMaxActiveThreadNum(threadCount - 1);
+  threadPool.Start();
+  threadPool.WaitFinish(true);
+
+  ostringstream ost;
+  ost << "ParallelForEachObj:\n";
+  ost << "  Visited pages: " << overallStats.pagesVisited << '\n';
+  ost << "  Skipped pages: " << overallStats.pagesSkipped << '\n';
+  if (onlyVisit == OnlyVisit::kVisitFinalizable) {
+    ost << "  Total finalizable objs (from counter): " << overallStats.totalFinalizable << '\n';
+  }
+  LOG2FILE(kLogtypeGc) << ost.str() << std::endl;
+
+  return true;
+}
+
+void RosAllocImpl::ForEachObjUnsafe(const function<void(address_t)> &visitor, OnlyVisit onlyVisit) {
+  PageLabel pageType = kPReleased;
+  size_t endIndex = pageMap.GetPageIndex(GetSpaceEnd());
+  for (size_t index = 0; index < endIndex; ++index) {
+    // ConcurrentPrepareResurrection bug. This synchronises with SetTypeRelease
+    // when allocating large objs. This ensures that when the heap scan finds a
+    // large obj page, it must look like an unallocated page at first (allocated bit is 0).
+    // If memset is done earlier, then there might not be a problem at all,
+    // assuming reorders don't pass through global locks.
+    // Caution, this atomic op is very expensive according to flame graphs.
+#if ROSIMPL_MEMSET_AT_FREE
+    pageType = pageMap.GetType(index);
+#else
+    pageType = pageMap.GetTypeAcquire(index);
+#endif
+    if (LIKELY(pageType == kPRun || pageType == kPMygoteRun)) {
+      address_t runAddr = pageMap.GetPageAddr(index);
+      RunSlots &run = *reinterpret_cast<RunSlots*>(runAddr);
+
+      if (onlyVisit == OnlyVisit::kVisitFinalizable &&
+          pageMap.NumOfFinalizableObjectsInRun(index) == 0) {
+        continue;
+      }
+
+      // unsafe mode, the finalizable count is inaccurate
+      ForEachObjInRunUnsafe(run, visitor, onlyVisit, std::numeric_limits<size_t>::max());
+    } else if (pageType == kPLargeObj || pageType == kPMygoteLargeObj) {
+      address_t pageAddr = pageMap.GetPageAddr(index);
+      address_t largeObjAddr = ROSIMPL_GET_OBJ_FROM_ADDR(pageAddr);
+      visitor(largeObjAddr);
+    }
+  }
+}
+
+bool RosAllocImpl::ForEachObj(const function<void(address_t)> &visitor, bool debug) {
+  return ForPartialRunsObj(visitor, []() { return 1; }, debug);
+}
+// Sample heaps, used in cycle pattern learning
+// Enumerate a subset of pages
+bool RosAllocImpl::ForPartialRunsObj(function<void(address_t)> visitor,
+                                     const function<size_t()> &stepFunc, bool debug) {
+  ROSIMPL_ASSERT(WorldStopped(), "_ForEachObj can only be invoked while world stopped");
+
+#if CONFIG_JSAN
+  auto orginalVisitor = visitor;
+  visitor = [&orginalVisitor](address_t obj) {
+    if (JSANGetObjStatus(obj) != kObjStatusQuarantined) {
+      orginalVisitor(obj);
+    }
+  };
+#endif
+
+  PageLabel pageType = kPReleased;
+  size_t pageIndex = 0;
+  if (UNLIKELY(debug &&
+               (pageMap.GetBeginAddr() != HeapStats::StartAddr() ||
+                pageMap.GetEndAddr() != HeapStats::StartAddr() + HeapStats::CurrentSize()))) {
+    return false;
+  }
+  size_t endIndex = pageMap.GetPageIndex(GetSpaceEnd());
+  while (pageIndex < endIndex) {
+    pageType = pageMap.GetType(pageIndex);
+    if (UNLIKELY(debug &&
+                 (pageMap.GetBeginAddr() != HeapStats::StartAddr() ||
+                  pageMap.GetEndAddr() != HeapStats::StartAddr() + HeapStats::CurrentSize()))) {
+      return false;
+    }
+    address_t pageAddr = pageMap.GetPageAddr(pageIndex);
+    if (LIKELY(pageType == kPRun || pageType == kPMygoteRun)) {
+      RunSlots *runSlots = reinterpret_cast<RunSlots*>(pageAddr);
+      ROSIMPL_ASSERT(runSlots->HasInit(), "run not initialised");
+      ROSIMPL_DEBUG(CheckRunMagic(*runSlots));
+      ROSIMPL_ASSERT(runSlots->mIdx < kNumberROSRuns,
+                     "runSlots returned has wrong index");
+      ForEachObjInRun(*runSlots, visitor);
+    } else if (UNLIKELY(pageType == kPLargeObj || pageType == kPMygoteLargeObj)) {
+      address_t lrgAddr = ROSIMPL_GET_OBJ_FROM_ADDR(pageAddr);
+      visitor(lrgAddr);
+    }
+    pageIndex += stepFunc();
+  }
+  return true;
+}
+
+// AccurateIsValidObjAddr and AccurateIsValidObjAddrConcurrent are used in
+// conservative stack scan to identify valid obj addresses from random numbers
+//
+// in other times, we can theoretically assume non-heap objs do not share the
+// same address range with heap objs, so we can just use a range-based check
+// to distinguish them (FastIsValidObjAddr)
+//
+// check if an address is of an valid obj, only used in stw (parallel gc)
+bool RosAllocImpl::AccurateIsValidObjAddr(address_t addr) {
+  ROSIMPL_ASSERT(WorldStopped(), "AccurateIsValidObjAddr invoked at non-STW");
+  if (!FastIsValidObjAddr(addr)) {
+    return false;
+  }
+  return AccurateIsValidObjAddrUnsafe(addr);
+}
+
+// check if an address is of an valid obj, used during concurrent marking (concurrent gc)
+bool RosAllocImpl::AccurateIsValidObjAddrConcurrent(address_t addr) {
+  ROSIMPL_ASSERT(!WorldStopped(), "AccurateIsValidObjAddrConcurrent invoked at STW,"
+                                  "please use the STW version instead");
+  if (!FastIsValidObjAddr(addr)) {
+    return false;
+  }
+  ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+  return AccurateIsValidObjAddrUnsafe(addr);
+}
+
+address_t RosAllocImpl::HeapLowerBound() const {
+  return reinterpret_cast<address_t>(allocSpace.GetBegin());
+}
+
+address_t RosAllocImpl::HeapUpperBound() const {
+  return reinterpret_cast<address_t>(allocSpace.GetEnd());
+}
+
+// this is called by mutator before free a large object
+// when concurrent sweep is running.
+void RosAllocImpl::SweepLargeObj(address_t objAddr) {
+  address_t pageAddr = ROSIMPL_GET_ADDR_FROM_OBJ(objAddr);
+  const size_t pageIndex = pageMap.GetPageIndex(pageAddr);
+  PageLabel pageType = kPMax;
+
+  // try to set page to sweeping state.
+  if (!sweepContext.SetSweeping(pageIndex, pageType)) {
+    // page already swept.
+    return;
+  }
+
+  __MRT_ASSERT(pageType == kPLargeObj, "incorrect large object page type");
+  __MRT_ASSERT(!Collector::Instance().IsGarbage(objAddr), "mutator free a dead large object");
+
+  // set page to swept state.
+  sweepContext.SetSwept(pageIndex);
+}
+
+void RosAllocImpl::FreeLargeObj(address_t objAddr, size_t &internalSize, bool delayFree) {
+  address_t memAddr = ROSIMPL_GET_ADDR_FROM_OBJ(objAddr);
+  ROSIMPL_ASSERT((memAddr & 0xfff) == 0, "big obj addr is not page aligned");
+  size_t pageCnt = pageMap.ClearLargeObjPageAndCount(memAddr, false);
+  size_t totalObjSize = ALLOCUTIL_PAGE_CNT2BYTE(pageCnt);
+  CheckDoubleFree(objAddr);
+
+  // ensure header is cleared in 8 bytes
+  *reinterpret_cast<uint64_t*>(memAddr) = 0;
+
+#if ROSIMPL_MEMSET_AT_FREE
+  ROSALLOC_MEMSET_S(memAddr, totalObjSize, 0, totalObjSize);
+#endif
+  if (!delayFree) {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+    allocSpace.FreeRegion(memAddr, pageCnt);
+  }
+  internalSize += totalObjSize;
+}
+
+address_t RosAllocImpl::AllocLargeObject(size_t &allocSize, int forceLevel) {
+  size_t actualSize = 0U;
+  address_t objAddr = AllocPagesInternal(allocSize, actualSize, forceLevel);
+  if (LIKELY(objAddr != 0U)) {
+    allocSize = actualSize;
+    size_t pgCnt = ALLOCUTIL_PAGE_BYTE2CNT(actualSize);
+    size_t converted = pageMap.SetAsLargeObjPage(objAddr, pgCnt);
+    // record the number of pages fetched from the kernel (previously released)
+    allocSpace.RecordReleasedToNonReleased(converted);
+  }
+  return objAddr;
+}
+
+void RosAllocImpl::FreeRun(RunSlots &runSlots, bool delayFree) {
+  size_t pgCnt = static_cast<size_t>(GetPagesPerRun(runSlots.mIdx));
+  size_t totalRunSize = ALLOCUTIL_PAGE_CNT2BYTE(pgCnt);
+  address_t memAddr = reinterpret_cast<address_t>(&runSlots);
+
+#if ALLOC_ENABLE_LOCK_CONTENTION_STATS
+  // this run is going to be deleted; we retrieve its lock stats first
+  RosAllocImpl::pageLockContentionRec += runSlots.lock.GetContentionCount();
+  RosAllocImpl::pageLockWaitTimeRec += runSlots.lock.GetWaitTime();
+#endif
+#if ROSIMPL_MEMSET_AT_FREE
+  // runSlots is created by placement new, we should explicity call
+  // destructor to ensure resources (such as mutex) are properly released.
+  runSlots.~RunSlots();
+  ROSALLOC_MEMSET_S(memAddr, totalRunSize, 0, totalRunSize);
+#else
+  constexpr size_t runHeaderSize = RunSlots::GetHeaderSize();
+  // runSlots is created by placement new, we should explicity call
+  // destructor to ensure resources (such as mutex) are properly released.
+  runSlots.~RunSlots();
+  ROSALLOC_MEMSET_S(memAddr, runHeaderSize, 0, runHeaderSize);
+#endif
+  (void)totalRunSize;
+  // page map need not be cleared in lock:
+  // this assumes that all unsafe heap visit is during concurrent marking,
+  // where there can be no freeing of anything
+  pageMap.ClearRunPage(memAddr, pgCnt, false);
+  if (!delayFree) {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+    allocSpace.FreeRegion(memAddr, pgCnt);
+  }
+}
+
+void RosAllocImpl::HandleAllocFailure(size_t, int& forceLevel) {
+  forceLevel += 1;
+  if (forceLevel == static_cast<int>(kEagerLevelExtend)) {
+    Collector::Instance().InvokeGC(kGCReasonHeuBlocking);
+    return;
+  }
+  stats::gcStats->OnAllocAnomaly();  // already tried extending addr space so update stats
+  if (static_cast<int>(kEagerLevelOOM) == forceLevel) {
+    Collector::Instance().InvokeGC(kGCReasonOOM);
+    // should revoke local run here
+    return;
+  }
+}
+
+void RosAllocImpl::DumpStackBeforeOOM(size_t allocSize) {
+  // DFX utitlies, if OOM happen and allocate size is large than 10M
+  // print stack
+  constexpr size_t largeObjectSize = 10 * 1024 * 1024;
+  if (allocSize > largeObjectSize) {
+    LOG(ERROR) << "large object allocation fail before OOM" << maple::endl;
+    MplDumpStack("ALLOCATOR_OMM");
+  }
+}
+
+#if __MRT_DEBUG
+void RosAllocImpl::GetMemoryInfoBeforeOOM(size_t allocSize, size_t newLargestChunk){
+  // current fail alloc size
+  LOG(ERROR) << "alloc size          : " << allocSize << maple::endl;
+  // heap size
+  uint64_t heapSize = GetCurrentSpaceCapacity();
+  LOG(ERROR) << "heap size           : " << heapSize << maple::endl;
+  // actual size of heap pages backed by physical memory
+  size_t actualHeapSize = GetActualSize();
+  LOG(ERROR) << "actualHeapSize      : " << actualHeapSize << maple::endl;
+  // total survived
+  LOG(ERROR) << "total bytes survived: " << AllocatedMemory() << maple::endl;
+  // largest chunk
+  LOG(ERROR) << "largest chunk       : " << newLargestChunk << maple::endl;
+  // reference-collector queues
+  MRT_logRefqueuesSize();
+}
+#else
+void RosAllocImpl::GetMemoryInfoBeforeOOM(size_t, size_t) {}
+#endif
+
+void RosAllocImpl::ForEachObjInRun(RunSlots &runSlots,
+                                   function<void(address_t)> visitor,
+                                   OnlyVisit onlyVisit,
+                                   size_t numHint) const {
+  ROSIMPL_ASSERT(WorldStopped(), "ForEachObjInRun must be invoked in STW");
+  ForEachObjInRunUnsafe(runSlots, visitor, onlyVisit, numHint);
+}
+
+void RosAllocImpl::VisitGCRoots(const RefVisitor &visitor) {
+  visitor(reinterpret_cast<address_t&>(oome));
+}
+
+// release the physical memory of free pages, using madvise()
+bool RosAllocImpl::ReleaseFreePages(bool aggressive) {
+  {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+    size_t releasedBytes = allocSpace.ReleaseFreePages(aggressive);
+    if (releasedBytes == 0U) {
+      return aggressive ? true : false;
+    }
+  }
+  return true;
+}
+
+void RosAllocImpl::OutOfMemory(bool isJNI) {
+  RosBasedMutator &mutator = reinterpret_cast<RosBasedMutator&>(TLAllocMutator());
+  if (mutator.throwingOOME) {
+    // this thread is already in the state of throwing OOME
+    // this means this is a nested OOM call from another OOM call (which news stuff)
+    // when this happens, throw the OOME object prepared earlier to end the recursion
+    // this object will contain less information about this incident though
+#if UNIT_TEST
+    LOG(FATAL) << "out of memory";
+    __MRT_Panic();
+#endif
+    __MRT_ASSERT(oome != nullptr, "OOME object null");
+    RC_LOCAL_INC_REF(oome);
+    if (isJNI) {
+      MRT_ThrowExceptionSafe(oome->AsJobject());
+      return;
+    } else {
+      ThrowExceptionUnw(oome);
+      __builtin_unreachable();
+    }
+  }
+  mutator.throwingOOME = true;
+  LOG(ERROR) << "The heap is out of space. Allocator failed to allocate memory for objects." << maple::endl;
+  if (isJNI) {
+    MRT_ThrowNewException("java/lang/OutOfMemoryError", nullptr);
+  } else {
+    MRT_ThrowNewExceptionUnw("java/lang/OutOfMemoryError", nullptr);
+  }
+  mutator.throwingOOME = false;
+}
+
+void RosAllocImpl::ForEachMutator(std::function<void(AllocMutator&)> visitor) {
+  ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+  for (auto mutator : allocatorMutators) {
+    visitor(*mutator);
+  }
+}
+
+void RosAllocImpl::GetInstances(const MClass *klass, bool includeAssignable,
+                                size_t maxCount, vector<jobject> &instances) {
+  (void)ForEachObj([&klass, &includeAssignable, &maxCount, &instances](address_t obj) {
+    if (maxCount == 0 || (maxCount > instances.size())) {
+      MObject *currObj = MObject::Cast<MObject>(obj);
+      if (currObj->IsInstanceOf(*klass)) {
+        instances.push_back(currObj->AsJobject());
+      } else if (includeAssignable) {
+        if (klass->IsAssignableFrom(*currObj->GetClass())) {
+          instances.push_back(currObj->AsJobject());
+        }
+      }
+    }
+  });
+}
+
+void RosAllocImpl::ClassInstanceNum(map<string, long> &objNameCntMp) {
+  bool tmpResult = ForEachObj([&objNameCntMp](address_t obj) {
+    MClass *cl = reinterpret_cast<MObject*>(obj)->GetClass();
+    string name = cl->GetName();
+    ++objNameCntMp[name];
+  });
+  if (UNLIKELY(!tmpResult)) {
+    LOG(ERROR) << "ForEachObj(true) in RosAllocImpl::ClassInstanceNum() return false." << maple::endl;
+  }
+}
+
+// This function requires stw or global lock.
+// When using global lock, this can be inaccurate, but it's fine because it's debug only.
+void RosAllocImpl::RecordFragment() {
+  RunSlots *run = nullptr;
+  address_t pageAddr;
+  size_t freeSlots = 0;
+  fragRec.Reset();
+  fragRec.RecordInternalFrag(AllocatedMemory(), RequestedMemory());
+
+  address_t allocSpaceEndAddr = reinterpret_cast<address_t>(allocSpace.GetEnd());
+  size_t endIndex = pageMap.GetPageIndex(allocSpaceEndAddr);
+  // walk the heap to account for external fragmentation
+  for (size_t i = 0; i < endIndex; ++i) {
+    pageAddr = pageMap.GetPageAddr(i);
+    PageLabel ptype = pageMap.GetType(i);
+    if (ptype == kPFree) {
+      fragRec.IncFreePages(ALLOCUTIL_PAGE_SIZE);
+    } else if (ptype == kPRun) {
+      run = reinterpret_cast<RunSlots*>(pageAddr);
+      bool isFree = false;
+      size_t runMaxNSlots = run->GetMaxSlots();
+      size_t slotSize = run->GetRunSize();
+      if (!run->IsFull()) {
+        // add the free slots to the fragmentations
+        freeSlots = run->nFree;
+        fragRec.IncFreeSlots(slotSize * freeSlots);
+        if (freeSlots == runMaxNSlots) {
+          isFree = true;
+        }
+      }
+      size_t bytesPerRun = ALLOCUTIL_PAGE_CNT2BYTE(GetPagesPerRun(run->mIdx));
+      // add the header of the run and the trailing fragmen
+      fragRec.IncRunOverhead(bytesPerRun - (slotSize * runMaxNSlots));
+      fragRec.IncSlots(slotSize * runMaxNSlots);
+      fragRec.IncRun(bytesPerRun, isFree, run->IsLocal());
+    }
+    if (ptype != kPReleased) {
+      fragRec.IncPages(static_cast<uint64_t>(ALLOCUTIL_PAGE_SIZE));
+    }
+  }
+}
+
+// This function should only be invoked in stw or global lock.
+// It can be inaccurate in global, but it's fine because it's debug only.
+void RosAllocImpl::PrintPageFragment(std::basic_ostream<char> &os, std::string tag) {
+  uint32_t nRuns = 0; // number of runs, caches excluded
+  uint16_t nRunsFull[kNumberROSRuns]; // number of full runs
+  uint16_t nRunsNonfull[kNumberROSRuns]; // number of partial full runs
+  uint16_t nRunsCached [kNumberROSRuns]; // number of cached runs (all free)
+  uint32_t sumNonfullRunsUsedslots[kNumberROSRuns];
+  uint32_t sumNonfullRunsFreeslots[kNumberROSRuns];
+  uint32_t largeobjs = 0;
+  uint32_t largeobjsPages = 0;
+  uint32_t pagesFreed = 0;
+  uint32_t pagesReleased = 0;
+  uint32_t pagesFull = 0;
+  uint32_t pagesNonfull = 0;
+  uint32_t pagesCached = 0;
+
+  uint32_t sumRunsObjInternalBytesUsed = 0;
+  uint32_t sumRunsObjInternalBytesFree = 0;
+  uint32_t sumRunsOverheadBytes = 0; // run header + end of page remainder gap
+
+  (void)memset_s(&nRunsFull[0], sizeof(nRunsFull), 0, sizeof(nRunsFull));
+  (void)memset_s(&nRunsNonfull[0], sizeof(nRunsNonfull), 0, sizeof(nRunsNonfull));
+  (void)memset_s(&nRunsCached[0], sizeof(nRunsCached), 0, sizeof(nRunsCached));
+  (void)memset_s(&sumNonfullRunsUsedslots[0], sizeof(sumNonfullRunsUsedslots), 0,
+                 sizeof(sumNonfullRunsUsedslots));
+  (void)memset_s(&sumNonfullRunsFreeslots[0], sizeof(sumNonfullRunsFreeslots), 0,
+                 sizeof(sumNonfullRunsFreeslots));
+
+  std::string date = timeutils::GetDigitDate();
+  os << "Allocator Fragmentation Log Start - " << date << std::endl;
+  RecordFragment();
+  fragRec.Print(os, tag);
+
+  os << "Non-released page size [" << tag << "]: " << allocSpace.GetNonReleasedPageSize() << "\n";
+  os << "Current heap size [" << tag << "]: " << allocSpace.GetSize() << "\n";
+
+  os << "Page fragment [" << tag << "]: ";
+  for (address_t i = reinterpret_cast<address_t>(allocSpace.GetBegin());
+       i < reinterpret_cast<address_t>(allocSpace.GetEnd());) {
+    size_t pageIdx = pageMap.GetPageIndex(i);
+    PageLabel ptype = pageMap.GetType(pageIdx);
+    switch (ptype) {
+      case kPReleased:
+        ++pagesReleased;
+        os << " " << int(ptype);
+        break;
+      case kPFree:
+        ++pagesFreed;
+        os << " " << int(ptype);
+        break;
+      case kPLargeObj:
+        ++largeobjs;
+        FALLTHROUGH_INTENDED;
+      case kPLargeObjRem:
+        ++largeobjsPages;
+        os << " " << int(kPLargeObj);
+        break;
+      case kPRun: {
+        RunSlots *run = reinterpret_cast<RunSlots*>(i);
+        os << " " << int(ptype) << " [" << run->GetRunSize() << "](";
+        size_t freeSlots = run->nFree;
+        os << (run->GetRunSize() * freeSlots) << "/" << (run->GetRunSize() * run->GetMaxSlots()) << ")";
+
+        int idx = run->mIdx;
+        if (freeSlots != 0) {
+          if (freeSlots == run->GetMaxSlots()) {
+            // completely free runs are either kept as cached runs or freed
+            ++nRunsCached[idx];
+          } else {
+            ++nRunsNonfull[idx];
+            sumNonfullRunsFreeslots[idx] += freeSlots;
+            sumNonfullRunsUsedslots[idx] += run->GetMaxSlots()-freeSlots;
+          }
+        } else {
+          nRunsFull[idx] += 1;
+        }
+        break;
+      }
+      case kPRunRem:
+        os << " " << int(kPRun);
+        break;
+      default:
+        LOG(ERROR) << "Unknown page type for print" << maple::endl;
+        break;
+    }
+    i += ALLOCUTIL_PAGE_SIZE;
+  }
+  os << "\n";
+
+  // Additional logging
+  os << "Extended Logging Start\n";
+  os << "Bracket|Full |NonFull|Full Runs     |NonFull Runs  |NonFullRuns    |Partial+Full Runs |Cached\n";
+  os << "Size   |Runs |Runs   |Used SlotBytes|Used SlotBytes|Avail SlotBytes|TotalOverheadBytes|Free Runs\n";
+
+  for (unsigned int i = 0; i < kNumberROSRuns; ++i) {
+    size_t bracketSize = GetRunSize(i);
+    size_t slotCapacity = RunSlots::maxSlots[i];
+    uint32_t pagesPerRun = GetPagesPerRun(i);
+    size_t runOverheadBytes = ALLOCUTIL_PAGE_CNT2BYTE(pagesPerRun) - bracketSize * slotCapacity;
+
+    os << "[" << setw(4) << bracketSize << "]" <<
+        setw(5)  << nRunsFull[i] << " " <<
+        setw(5)  << nRunsNonfull[i] << " " <<
+        setw(15) << (bracketSize * nRunsFull[i] * slotCapacity) << " " <<
+        setw(15) << (bracketSize * sumNonfullRunsUsedslots[i]) << " " <<
+        setw(15) << (bracketSize * sumNonfullRunsFreeslots[i]) << " " <<
+        setw(15) << (runOverheadBytes * (nRunsFull[i] + nRunsNonfull[i]) * pagesPerRun) << " " <<
+        setw(10) << nRunsCached[i] << "\n";
+
+    nRuns += nRunsFull[i] + nRunsNonfull[i];
+    pagesFull += nRunsFull[i] * pagesPerRun;
+    pagesNonfull += nRunsNonfull[i] * pagesPerRun;
+    pagesCached += nRunsCached[i] * pagesPerRun;
+    sumRunsObjInternalBytesUsed += bracketSize *
+        ((slotCapacity * nRunsFull[i]) + sumNonfullRunsUsedslots[i]);
+    sumRunsObjInternalBytesFree += bracketSize * sumNonfullRunsFreeslots[i];
+    sumRunsOverheadBytes += runOverheadBytes * (nRunsFull[i] + nRunsNonfull[i]);
+  }
+  uint64_t runPagePadding = sumRunsOverheadBytes - RunSlots::GetHeaderSize() * nRuns;
+  uint32_t runPages = pagesFull + pagesNonfull + pagesCached;
+  uint32_t heapPages = runPages + largeobjsPages + pagesFreed;
+
+  uint64_t totalObjs = account.GetNetObjs(); // runObjs+lgeObjs
+  uint64_t totalObjBytes = account.GetNetObjBytes(); // newobj req java obj bytes
+  uint64_t totalBytes = account.GetNetBytes();
+  uint64_t largeObjBytes = account.GetNetLargeObjBytes();
+  uint64_t largeObjWastage = ALLOCUTIL_PAGE_CNT2BYTE(largeobjsPages) - largeObjBytes;
+  uint64_t internalFragment = totalBytes - totalObjBytes - (totalObjs * ROSIMPL_HEADER_ALLOC_SIZE);
+  uint64_t externalFragment = sumRunsObjInternalBytesFree + sumRunsOverheadBytes +
+      ALLOCUTIL_PAGE_CNT2BYTE(pagesFreed + pagesCached);
+#define FRAG_PRINT_PAGE(title, pageCount) title << \
+  std::setw(10) << ALLOCUTIL_PAGE_CNT2BYTE((pageCount)) << " Bytes / " << \
+  std::setw(8) << (pageCount) << " pages"
+#define FRAG_PRINT_SIZE(title, size) title << std::setw(10) << (size) << " Bytes"
+#define FRAG_PRINT(title, num) title << std::setw(10) << (num)
+  os <<                 "SUMMARY:\n";
+  os <<                 "    Allocator Heap Size\n";
+  os <<                 "1     mapped (addr space):\n";
+  os << FRAG_PRINT_PAGE("2     populated(run+lge+freed):", heapPages) << "\n";
+  os << FRAG_PRINT_PAGE("3     pages freed:             ", pagesFreed) << "\n";
+  os <<                 "    Runs and run objects:\n";
+  os << FRAG_PRINT_PAGE("4     pages full:              ", pagesFull) << "\n";
+  os << FRAG_PRINT_PAGE("5     pages partially full:    ", pagesNonfull) << "\n";
+  os << FRAG_PRINT_PAGE("6     pages cached:            ", pagesCached) << "\n";
+  os << FRAG_PRINT_SIZE("7     obj internal bytes used: ", sumRunsObjInternalBytesUsed) << "\n";
+  os << FRAG_PRINT_SIZE("8     obj internal bytes free: ", sumRunsObjInternalBytesFree) << "\n";
+  os << FRAG_PRINT_SIZE("9     Run page overheads:      ", sumRunsOverheadBytes) << "  (full+paritial full runs)\n";
+  os << FRAG_PRINT_SIZE("      Run page end wastages:   ", runPagePadding) << "  (9)-run headers\n";
+  os <<                 "    Large Objects:\n";
+  os <<      FRAG_PRINT("10    objs:                    ", largeobjs) << "\n";
+  os << FRAG_PRINT_SIZE("11    obj req bytes:           ", largeObjBytes) << "\n";
+  os << FRAG_PRINT_PAGE("12    obj internal bytes:      ", largeobjsPages) << "  (11)+(13)\n";
+  os << FRAG_PRINT_SIZE("13    obj page end wastages:   ", largeObjWastage) << "\n";
+  os << "\n";
+  os <<      FRAG_PRINT("14  Total Objs (incl largeobj):", totalObjs) << "\n";
+  os << FRAG_PRINT_SIZE("15  Sum Objs Req Bytes:        ", totalObjBytes) << "\n";
+  os << FRAG_PRINT_SIZE("16  Sum Objs Internal Bytes:   ", totalBytes) << "  (7)+(12)\n";
+  os <<      FRAG_PRINT("17  Sum Objs RC Header Bytes:  ", account.GetNetObjs() * ROSIMPL_HEADER_ALLOC_SIZE) << "\n";
+  os <<      FRAG_PRINT("    Internal Fragmentation:    ", internalFragment) << "  (16)-(15)-(17)\n";
+  os <<      FRAG_PRINT("    External Fragmentation:    ", externalFragment) << "  (8)+(9)+(6)+(3)\n";
+  os << "\n";
+  os << FRAG_PRINT_SIZE("  CurrentSpaceCapacity:        ", GetCurrentSpaceCapacity()) << "\n";
+  os << FRAG_PRINT_SIZE("  AllocatedMemory:             ", AllocatedMemory()) << "  (16)\n";
+  os <<                 "Extended Logging End\n";
+  os <<                 "Allocator Fragmentation Log End\n";
+  os << "\n";
+  os.flush();
+}
+
+void RosAllocImpl::RevokeLocalRuns(RosBasedMutator &mutator) {
+  for (int i = 0; i < static_cast<int>(kROSAllocLocalRuns); ++i) {
+    address_t localAddress = mutator.GetLocalAddress(i);
+    if (UNLIKELY(localAddress == 0)) {
+      continue;
+    }
+    RunSlots &run = *(reinterpret_cast<RunSlots*>(localAddress));
+    if (UNLIKELY(IsConcurrentSweepRunning())) {
+      bool ROSIMPL_DUNUSED(needRemove) = run.Sweep(*this);
+      ROSIMPL_ASSERT(needRemove == false, "mutator run swept to empty");
+    }
+    mutator.EnableLocalAfterSweep(i);
+    RevokeLocalRun(mutator, run);
+  }
+}
+
+void RosAllocImpl::OnFinalizableObjCreated(address_t addr) {
+  pageMap.OnFinalizableObjCreated(addr);
+}
+
+void RosAllocImpl::OnFinalizableObjResurrected(address_t addr) {
+  pageMap.OnFinalizableObjResurrected(addr);
+}
+
+void RosAllocImpl::Debug_DumpFinalizableInfo(ostream& ost) {
+  size_t endIndex = pageMap.GetPageIndex(GetSpaceEnd());
+  ost << "Last page:" << endIndex << "\n";
+  pageMap.DumpFinalizableInfo(ost);
+}
+
+// prepare concurrent sweep, run when world stopped.
+void RosAllocImpl::PrepareConcurrentSweep() {
+  // Init sweep context
+  sweepContext.Init(*this, GetEndPageIndex(), pageMap);
+
+  for (auto mutator : allocatorMutators) {
+    RosBasedMutator &m = *reinterpret_cast<RosBasedMutator*>(mutator);
+    if (!m.useLocal) {
+      continue;
+    }
+    for (int i = 0; i < static_cast<int>(kROSAllocLocalRuns); ++i) {
+      // temporarily disable fast alloc so that mutator can help sweep
+      // recover when sweeping done
+      m.DisableLocalBeforeSweep(i);
+    }
+  }
+
+  // set sweep running flag.
+  SetConcurrentSweepRunning(true);
+}
+
+// sweep from the page at pageIndex:
+// if it's a run, sweep the run page(s); if it's a large obj, sweep its page(s).
+// return whether the page becomes free, update the swept page count
+bool RosAllocImpl::SweepPage(size_t pageIndex, size_t &pageCount) {
+  SweepContext &context = sweepContext;
+
+  // try to set page to sweeping state.
+  PageLabel pageType = kPMax;
+  if (!context.SetSweeping(pageIndex, pageType)) {
+    // page already swept.
+    pageCount = 1;
+    return false;
+  }
+
+  __MRT_ASSERT(pageType == pageMap.GetType(pageIndex), "page type changed before sweep");
+  if (pageType == kPRun) {
+    // sweep run page.
+    address_t pageAddr = pageMap.GetPageAddr(pageIndex);
+    RunSlots *runSlots = reinterpret_cast<RunSlots*>(pageAddr);
+    uint8_t idx = runSlots->mIdx;
+
+    // sweep the run.
+    if (runSlots->DoSweep(*this, context, pageIndex)) {
+      FreeRun(*runSlots, true);
+      pageCount = ROSIMPL_N_PAGES_PER_RUN(idx);
+      return true;
+    }
+  } else if (pageType == kPLargeObj) {
+    // sweep large object.
+    address_t pageAddr = pageMap.GetPageAddr(pageIndex);
+    address_t largeObjAddr = ROSIMPL_GET_OBJ_FROM_ADDR(pageAddr);
+
+    // check if the large object dead.
+    // this should be done before SetSwept(), because the large
+    // object may be released by other thread after SetSwept().
+    bool isDead = Collector::Instance().IsGarbage(largeObjAddr);
+
+    // set large object page to swept state.
+    // this should be called before release the page, because
+    // mutator may reuse the released page that swept state not set.
+    context.SetSwept(pageIndex);
+
+    // release the object if it is dead.
+    if (isDead) {
+      // for dead large object,
+      // dec neighbours before release it.
+      std::vector<address_t> deadNeighbours;
+      Collector::Instance().HandleNeighboursForSweep(largeObjAddr, deadNeighbours);
+
+      // To prevent dead lock, we do not release dead neighbours here,
+      // but save them to sweep context, so that we can release them later.
+      if (UNLIKELY(!deadNeighbours.empty())) {
+        context.AddDeadNeighbours(deadNeighbours);
+      }
+
+      // release the large object.
+      maplert::Allocator::ReleaseResource(largeObjAddr);
+      size_t objSize = PreObjFree(largeObjAddr);
+      size_t internalSize = 0U;
+#if !ROSIMPL_MEMSET_AT_FREE
+      TagGCFreeObject(largeObjAddr);
+#endif
+      FreeLargeObj(largeObjAddr, internalSize, true);
+      PostObjFree(largeObjAddr, objSize, internalSize);
+
+      // count released large objects and bytes.
+      (void)context.releasedLargeObjects.fetch_add(1, std::memory_order_relaxed);
+      (void)context.releasedBytes.fetch_add(internalSize, std::memory_order_relaxed);
+      pageCount = ALLOCUTIL_PAGE_BYTE2CNT(internalSize);
+      return true;
+    }
+  } else {
+    __MRT_ASSERT(pageType == kPMygoteRun || pageType == kPMygoteLargeObj,
+                 "ConcurrentSweep: incorrect page type");
+  }
+  pageCount = 1;
+  return false;
+}
+
+void RosAllocImpl::SweepPages(size_t pageBegin, size_t pageEnd) {
+  // the cost of freeing a single region is around the us magnitude
+  // so freeing 64 regions together will likely not cause frame loss
+  // also the buffer size is exactly 1 page for 64-bit system
+  const uint32_t bufferSize = 64;
+  size_t freeBuffer[bufferSize][2] = {}; // all zero
+  auto clearBufferFunc = [this, &freeBuffer]() {
+    ALLOC_LOCK_TYPE guard(ALLOC_CURRENT_THREAD globalLock);
+    for (uint32_t idx = 0; idx < bufferSize; ++idx) {
+      if (freeBuffer[idx][1] == 0) {
+        return;
+      }
+      allocSpace.FreeRegion(pageMap.GetPageAddr(freeBuffer[idx][0]), freeBuffer[idx][1]);
+      freeBuffer[idx][1] = 0;
+    }
+  };
+
+  uint32_t regionCount = 0;
+  size_t adjacentIdx = pageBegin;
+  size_t adjacentSize = 0;
+  for (size_t idx = pageBegin; idx < pageEnd;) {
+    size_t pageCount = 1;
+    bool isFreed = SweepPage(idx, pageCount);
+    if (isFreed) {
+      if (adjacentSize == 0) {
+        adjacentIdx = idx;
+      }
+      adjacentSize += pageCount;
+    } else {
+      if (adjacentSize != 0) {
+        freeBuffer[regionCount][0] = adjacentIdx;
+        freeBuffer[regionCount++][1] = adjacentSize;
+        if (regionCount == bufferSize) {
+          clearBufferFunc();
+          regionCount = 0;
+        }
+        adjacentSize = 0;
+      }
+    }
+    idx += pageCount;
+  }
+  if (adjacentSize != 0) {
+    freeBuffer[regionCount][0] = adjacentIdx;
+    freeBuffer[regionCount][1] = adjacentSize;
+  }
+  if (freeBuffer[0][1] != 0) {
+    clearBufferFunc();
+  }
+}
+
+// Note: we assume that heap will not trim when concurrent sweep is running.
+void RosAllocImpl::ConcurrentSweep(MplThreadPool *threadPool) {
+  // sweepContext should be created by PrepareConcurrentSweep().
+  ROSIMPL_ASSERT(IsConcurrentSweepRunning(), "sweep flag not set for concurrent sweep");
+
+  SweepContext& context = sweepContext;
+  const size_t endPageIndex = context.highestPageIndex;
+
+  // sweep pages.
+  if (threadPool != nullptr) {
+    // parallel sweep pages.
+    MRT_PHASE_TIMER("Parallel Sweep Pages");
+    const size_t threadCount = static_cast<size_t>(threadPool->GetMaxActiveThreadNum()) + 1;
+    const size_t chunkSize = std::min(endPageIndex / threadCount + 1, kMaxPagesPerTask);
+    for (size_t pageIndex = 0; pageIndex < endPageIndex;) {
+      const size_t delta = std::min(endPageIndex - pageIndex, chunkSize);
+      threadPool->AddTask(new MplLambdaTask([this, pageIndex, delta](size_t) {
+        SweepPages(pageIndex, pageIndex + delta);
+      }));
+      pageIndex += delta;
+    }
+
+    threadPool->Start();
+    threadPool->WaitFinish(true);
+  } else {
+    // serial sweep pages.
+    MRT_PHASE_TIMER("Sweep Pages");
+    SweepPages(0, endPageIndex);
+  }
+
+  // release dead neighbours.
+  // only rc collector has work to do
+  {
+    MRT_PHASE_TIMER("Release dead neighbours");
+    for (auto obj : context.deadNeighbours) {
+      __MRT_ASSERT(IsRCCollectable(obj), "not zero RC in dead_neighbours");
+      RCReferenceProcessor::Instance().AddAsyncReleaseObj(obj, false);
+    }
+  }
+
+  // unset sweep running flag.
+  SetConcurrentSweepRunning(false);
+
+  // update gc statistic.
+  stats::gcStats->CurrentGCRecord().objectsCollected = context.releasedObjects + context.releasedLargeObjects;
+  stats::gcStats->CurrentGCRecord().bytesCollected = context.releasedBytes;
+  stats::gcStats->CurrentGCRecord().bytesSurvived = context.oldAllocatedBytes - context.releasedBytes;
+
+  // GC logging.
+  LOG2FILE(kLogtypeGc) << "End of concurrent sweeping.\n" <<
+      "  pages before swept: "    << Pretty(context.highestPageIndex) << '\n' <<
+      "  bytes before swept: "    << Pretty(context.oldAllocatedBytes) << '\n' <<
+      "  swept small objects: "   << Pretty(context.releasedObjects) << '\n' <<
+      "  swept large objects: "   << Pretty(context.releasedLargeObjects) << '\n' <<
+      "  swept bytes: "           << Pretty(context.releasedBytes) << '\n' <<
+      "  swept dead neighbours: " << Pretty(context.deadNeighbours.size()) << '\n' <<
+      "  swept run pages: "       << Pretty(context.sweptRuns) << "/" << Pretty(context.scanedRuns) << '\n' <<
+      "  swept to empty runs: "   << Pretty(context.emptyRuns) << '\n' <<
+      "  swept full runs: "       << Pretty(context.nonFullRuns) << '\n';
+  sweepContext.Release();
+}
+
+void RosAllocImpl::OnPreFork() {
+  if (!hasForked) {
+    // ignore all rc operations for mygote objs
+    auto visitor = [](address_t objAddr) {
+      SetRCOverflow(objAddr);
+      SetMygoteBit(objAddr);
+    };
+    (*theAllocator).ForEachObjUnsafe(visitor, OnlyVisit::kVisitAll);
+
+    // mark all mygote pages with a special page type
+    pageMap.SetAllAsMygotePage();
+    // release all local run
+    globalMutator.ResetRuns();
+    RosBasedMutator &mutator = static_cast<RosBasedMutator&>(TLAllocMutator());
+    mutator.ResetRuns();
+    // release all nonfull run
+    for (size_t i = 0; i < kNumberROSRuns; ++i) {
+      nonFullRuns[i].Release();
+    }
+    hasForked = true;
+  }
+}
+
+template<>
+void RosBasedMutator::Init() {
+  LOG2FILE(kLogTypeAllocator) << "Alloc Mutator " << this << " initializing." << std::endl;
+  int pid = getpid();
+  int tid = maple::GetTid();
+  static const int prioThreadAllowed = 3;
+  if (tid != 0 && tid < pid + prioThreadAllowed) {
+    // allow local allocation for main threads directly (no better ways to identify them than tid)
+    useLocal = true;
+  }
+  // we leave saferegion here to prevent Init() be interrupted by GC.
+  ScopedObjectAccess soa;
+  (*theAllocator).AddAllocMutator(*this);
+  LOG2FILE(kLogTypeAllocator) << "Alloc Mutator " << this << " initialized." << std::endl;
+}
+
+template<>
+void RosBasedMutator::Fini() {
+  LOG2FILE(kLogTypeAllocator) << "ROSAllocMutator::Fini() " << this << " started Fini." << std::endl;
+  // we leave saferegion here to prevent Fini() be interrupted by GC.
+  ScopedObjectAccess soa;
+  (*theAllocator).RemoveAllocMutator(*this);
+
+  LOG2FILE(kLogTypeAllocator) << "ROSAllocMutator::Fini() " << this << " finished Fini." << std::endl;
+}
+
+template<> void ROSAllocMutator<RunConfig::kRunConfigs>::Init() {}
+template<> void ROSAllocMutator<RunConfig::kRunConfigs>::Fini() {}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/allocator/space.cpp b/src/mrt/compiler-rt/src/allocator/space.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3292d554e74a6d5c1d5325f7db684db0caaf2724
--- /dev/null
+++ b/src/mrt/compiler-rt/src/allocator/space.cpp
@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "allocator/space.h"
+
+#include <atomic>
+#include <cinttypes>
+#include <sys/types.h>
+#include <sys/syscall.h>
+#include "chosen.h"
+#include "collector/stats.h"
+#include "yieldpoint.h"
+
+namespace maplert {
+using namespace std;
+
+bool Space::kReleasePageAtFree = kRosimplReleasePageAtFree;
+bool Space::kReleasePageAtTrim = kRosimplReleasePageAtTrim;
+// this duplicates with heap initial size
+size_t Space::kHeapStartSize = ROSIMPL_DEFAULT_HEAP_START_SIZE;
+size_t Space::kHeapSize = ROSIMPL_DEFAULT_HEAP_SIZE;
+size_t Space::kHeapGrowthLimit = ROSIMPL_DEFAULT_HEAP_GROWTH_LIMIT;
+size_t Space::kHeapMinFree = ROSIMPL_DEFAULT_HEAP_MIN_FREE;
+size_t Space::kHeapMaxFree = ROSIMPL_DEFAULT_HEAP_MAX_FREE;
+// the following is unused
+float Space::kHeapTargetUtilization = kRosimplDefaultHeapTargetUtilization;
+bool Space::kIgnoreMaxFootprint = kRosimplDefaultIgnoreMaxFootprint;
+
+//  SpacePageManager
+uint32_t SpacePageManager::CalcPageIdx(uintptr_t pageAddr) const {
+  return static_cast<uint32_t>(ALLOCUTIL_PAGE_BYTE2CNT(pageAddr - baseAddress));
+}
+
+// given the first page and the size of region in bytes, we add it
+// to the set
+void SpacePageManager::AddRegion(uintptr_t regionAddr, size_t regionSize) {
+  uint32_t pageCount = CalcChunkSize(regionSize);
+  AddPages(regionAddr, pageCount);
+}
+
+// add contiguous pages of count page_count starting with first_page
+void SpacePageManager::AddPages(uintptr_t firstPage, uint32_t pageCount) {
+  // we should check that the page is within the limit in future
+  uint32_t pageIdx = CalcPageIdx(firstPage);
+  // add the new entry to the set
+  if (UNLIKELY(!pageCTree.MergeInsert(pageIdx, pageCount))) {
+    LOG(ERROR) << "free page insertion failed, inconsistency, " << pageIdx << ", " << pageCount << maple::endl;
+  }
+}
+
+void SpacePageManager::ReleaseAllFreePages(size_t freeBytes, const MemMap &memMap, bool isAggressive) {
+  if (pageCTree.Empty()) {
+    return;
+  }
+  uint64_t beginTime = timeutils::MicroSeconds();
+  TreeType::Iterator it(pageCTree);
+  auto next = it.Next();
+  size_t totalReleasedBytes = 0U;
+  size_t targetFreeBytes = allocSpace.TargetFreePageSizeByUtilization();
+  size_t targetReleaseBytes = freeBytes > targetFreeBytes ? freeBytes - targetFreeBytes : 0U;
+  while (next != nullptr) {
+    // control the size of unreleased pages
+    uintptr_t releaseBeginAddr = GetRegAddrFromIdx(next->Idx());
+    size_t releaseBytes = ALLOCUTIL_PAGE_CNT2BYTE(next->Cnt());
+    if (UNLIKELY(!isAggressive && // aggressive trim ignores these conditions
+                 (timeutils::MicroSeconds() - beginTime > Space::kMaxTrimTime ||
+                  totalReleasedBytes >= targetReleaseBytes))) {
+      // after we release enough many pages, we stop (reserve a certain number of free pages)
+      // also, 10ms timeout
+      break;
+    }
+
+    // release
+    uint32_t relEndIdx = next->Idx() + next->Cnt();
+    size_t c = allocSpace.pageMap.SetRangeAndCount(next->Idx(), relEndIdx, kPReleased);
+    if (c) {
+      (void)memMap.ReleaseMem(releaseBeginAddr, releaseBytes);
+      totalReleasedBytes += ALLOCUTIL_PAGE_CNT2BYTE(c);
+    }
+    next = it.Next();
+  }
+  allocSpace.nonReleasedPageSize -= totalReleasedBytes;
+  size_t allocated = stats::gcStats->CurAllocBytes();
+  float utilization = static_cast<float>(allocated) / allocSpace.nonReleasedPageSize;
+  LOG2FILE(kLogTypeAllocFrag) <<
+      (isAggressive ? "    A" : "Non-a") << "ggressive trim time " <<
+      (timeutils::MicroSeconds() - beginTime) << "us, released " << totalReleasedBytes <<
+      ", post-trim utilization (" << allocated <<
+      "/" << allocSpace.allocatedPageSize <<
+      "/" << allocSpace.nonReleasedPageSize << ") " <<
+      std::setprecision(2) << std::fixed << utilization <<
+      " (target " << Space::kHeapTargetUtilization << ")\n";
+}
+
+// Given a request size in bytes, we split the first chunk and return the
+// address to the first page
+uintptr_t SpacePageManager::GetChunk(size_t reqSize) {
+  uint32_t idx = 0U;
+  return pageCTree.Find(idx, CalcChunkSize(reqSize)) ? GetRegAddrFromIdx(idx) : 0U;
+}
+
+// given size in bytes we return the size normalized to pages (4k)
+uint32_t SpacePageManager::CalcChunkSize(size_t regionSize) const {
+  return static_cast<uint32_t>(ALLOCUTIL_PAGE_BYTE2CNT(ALLOCUTIL_PAGE_RND_UP(regionSize)));
+}
+
+// given index of a region, calculate the page address
+uintptr_t SpacePageManager::GetRegAddrFromIdx(uint32_t idx) const {
+  size_t offset = ALLOCUTIL_PAGE_CNT2BYTE(idx);
+  return offset + baseAddress;
+}
+
+// Returns the size of largest chunk currently in the page set.
+size_t SpacePageManager::GetLargestChunkSize() {
+  return ALLOCUTIL_PAGE_CNT2BYTE(pageCTree.Top());
+}
+
+// Space
+Space::Space(const std::string &fullname, const std::string &tagVal, bool managed, PageMap &pageMapVal)
+    : name(fullname),
+      tag(tagVal),
+      isManaged(managed),
+      maxCapacity(0),
+      memMap(nullptr),
+      pageMap(pageMapVal),
+      begin(nullptr),
+      end(0),
+      allocatedPageSize(0),
+      nonReleasedPageSize(0),
+      pageManager(*this, 0U),
+      lastTrimTime(0) {
+}
+
+void Space::Init(uint8_t *reqBegin) {
+  LOG2FILE(kLogTypeAllocator) << "Initializing the heap.." << std::endl;
+  LOG2FILE(kLogTypeAllocator) << "  heap start size: " << Space::kHeapStartSize << std::endl;
+  LOG2FILE(kLogTypeAllocator) << "  heap maximum size: " << Space::kHeapSize << std::endl;
+  LOG2FILE(kLogTypeAllocator) << "  heap growth limit: " << Space::kHeapGrowthLimit << std::endl;
+  LOG2FILE(kLogTypeAllocator) << "  heap minimum free size: " << Space::kHeapMinFree << std::endl;
+  LOG2FILE(kLogTypeAllocator) << "  heap maximum free size: " << Space::kHeapMaxFree << std::endl;
+  LOG2FILE(kLogTypeAllocator) << "  heap target utilization rate: " << Space::kHeapTargetUtilization << std::endl;
+  LOG2FILE(kLogTypeAllocator) << "  is ignoring max footprint: " << Space::kIgnoreMaxFootprint << std::endl;
+  maxCapacity = Space::kHeapGrowthLimit;
+  MemMap::Option opt = MemMap::kDefaultOptions;
+  opt.tag = tag.c_str();
+  opt.reqBase = reinterpret_cast<void*>(reqBegin);
+#if !ROSIMPL_ENABLE_ASSERTS
+  opt.protAll = true;
+#endif
+  memMap = MemMap::MapMemory(maxCapacity, Space::kHeapStartSize, opt);
+  begin = reqBegin;
+
+  uint8_t *baseAddress = reinterpret_cast<uint8_t*>(memMap->GetBaseAddr());
+  SetBegin(baseAddress);
+  SetEnd(reinterpret_cast<uint8_t*>(memMap->GetCurrEnd()));
+  uintptr_t startAddress = reinterpret_cast<uintptr_t>(baseAddress);
+  allocatedPageSize = 0U;
+  nonReleasedPageSize = 0U;
+  pageManager.pageCTree.Init(maxCapacity);
+  pageManager.SetBaseAddress(startAddress);
+  pageManager.AddRegion(startAddress, GetSize());
+}
+
+
+// returns the number of pages free within the reserved memory space
+size_t Space::GetAvailPageCount() const {
+  return ALLOCUTIL_PAGE_BYTE2CNT(GetSize() - allocatedPageSize);
+}
+
+uintptr_t Space::GetChunk(size_t reqSize) {
+  uintptr_t addr = pageManager.GetChunk(reqSize);
+  if (addr != 0) {
+#if DEBUG_RUNLOCK_OWNER
+    if (UNLIKELY(!memMap->ProtectMem(addr, reqSize, PROT_READ | PROT_WRITE))) {
+      LOG(FATAL) << "failed to mprotect " << std::hex << addr << " of size " << std::dec << reqSize;
+    }
+#endif
+    allocatedPageSize += reqSize;
+  }
+  return addr;
+}
+
+size_t Space::GetLargestChunkSize() {
+  return pageManager.GetLargestChunkSize();
+}
+
+size_t Space::TargetFreePageSizeByUtilization() const {
+  size_t allocated = stats::gcStats->CurAllocBytes();
+  // this should be guaranteed by the option parser
+  __MRT_ASSERT(kHeapTargetUtilization > 0, "invalid utilization");
+  __MRT_ASSERT(kHeapTargetUtilization < 1, "invalid utilization");
+  size_t targetTotal = static_cast<size_t>(allocated / kHeapTargetUtilization);
+  size_t targetFree = std::max(targetTotal, allocatedPageSize) - allocatedPageSize;
+  // we want to cap this: for larger heap, assuming usage do not grow that much faster
+  return std::min(targetFree, TargetFreePageSize());
+}
+
+void Space::Extend(size_t deltaSize) {
+  LOG2FILE(kLogTypeAllocator) << "extending space size delta " << deltaSize << std::endl;
+  size_t reqSize = ALLOCUTIL_PAGE_RND_UP(deltaSize);
+  size_t currentSize = GetSize();
+  if (currentSize >= maxCapacity || reqSize > maxCapacity) {
+    LOG(ERROR) << "space exceeded maximum capacity." << maple::endl;
+    return;
+  }
+  size_t oneTimeReq = ALLOCUTIL_PAGE_CNT2BYTE(kPagesOneTime);
+  size_t remainingSize = maxCapacity - currentSize;
+
+  size_t expandValue = std::min(remainingSize, std::max(reqSize, oneTimeReq));
+  LOG2FILE(kLogTypeAllocator) << "    requesting " << expandValue << std::endl;
+  bool extendResult = memMap->Extend(expandValue);
+  if (!extendResult) {
+    LOG(ERROR) << "allocator: extending space failed." << maple::endl;
+    return;
+  }
+  address_t oldEndAddr = reinterpret_cast<address_t>(GetEndRelaxed());
+  SetEnd(reinterpret_cast<uint8_t*>(memMap->GetCurrEnd()));
+  LOG2FILE(kLogTypeAllocator) << "    setting new end address 0x" <<
+      std::hex << reinterpret_cast<address_t>(GetEndRelaxed()) << std::endl;
+  // we add the new chunk to the page manager so that it can coalesce with
+  // any existing chunk at the end of the space
+  pageManager.AddRegion(oldEndAddr, expandValue);
+}
+
+address_t Space::Alloc(size_t reqSize, bool allowExtension) {
+  address_t retAddress = 0U;
+  if (GetSize() - allocatedPageSize >= reqSize) {
+    retAddress = GetChunk(reqSize);
+    if (retAddress != 0) {
+      return retAddress;
+    }
+  }
+
+  if (allowExtension) {
+    Extend(reqSize);
+    retAddress = GetChunk(reqSize);
+  }
+  return retAddress;
+}
+
+// release the physical memory of free pages, using madvise()
+size_t Space::ReleaseFreePages(bool aggressive) {
+  // don't release when gc running, too slow
+  if (Collector::Instance().InStartupPhase() ||
+      Collector::Instance().IsGcRunning() || WorldStopped()) {
+    return 0;
+  }
+  size_t free_bytes = GetFreePageSize();
+  // if aggressive, it ignores the threshold and the timer
+  if (aggressive || (IsTrimAllowedAtTheMoment() && free_bytes > HeapMaxFreeByUtilization())) {
+    pageManager.ReleaseAllFreePages(free_bytes, *memMap, aggressive);
+    lastTrimTime = timeutils::MilliSeconds();
+  }
+  // if any page was released, the size must have decreased
+  return free_bytes - GetFreePageSize();
+}
+
+void Space::FreeRegion(address_t addr, size_t pgCnt) {
+  pageManager.AddPages(addr, static_cast<uint32_t>(pgCnt));
+  size_t memSize = ALLOCUTIL_PAGE_CNT2BYTE(pgCnt);
+#if DEBUG_RUNLOCK_OWNER
+  if (UNLIKELY(!memMap->ProtectMem(addr, memSize, PROT_NONE))) {
+    LOG(FATAL) << "failed to mprotect " << std::hex << addr << " of size " << std::dec << memSize;
+  }
+#endif
+  allocatedPageSize -= memSize;
+  if (Space::kReleasePageAtFree) {
+    static_cast<void>(ReleaseFreePages(false));
+  }
+}
+
+Space::~Space() {
+  LOG2FILE(kLogTypeAllocator) << "Destructing RoSSpace" << std::endl;
+  if (memMap != nullptr) {
+    delete(memMap);
+    memMap = nullptr;
+  }
+  begin = nullptr;
+  LOG2FILE(kLogTypeAllocator) << "Done Destructing RoSSpace" << std::endl;
+}
+} // namesapce maplert
diff --git a/src/mrt/compiler-rt/src/arch/arm64/cc_native_method_stub_arm64.S b/src/mrt/compiler-rt/src/arch/arm64/cc_native_method_stub_arm64.S
new file mode 100644
index 0000000000000000000000000000000000000000..c0ae29dc86d8feef0fe144a8a8803812c69f97b8
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/cc_native_method_stub_arm64.S
@@ -0,0 +1,437 @@
+// This file defines stub to support calling java native methods.
+// "cc_" means "compiled code" by maple.
+
+//------------------------------------------------------------------------
+//  native wrapper      num of args   enter saferegion  copy stack args
+//------------------------------------------------------------------------
+//  MCC_CallFastNative       any           no             no
+//  MCC_CallFastNativeExt    any           no             no
+//  MCC_CallSlowNative       <=8           yes            no
+//  MCC_CallSlowNativeExt    any           yes            yes
+//------------------------------------------------------------------------
+
+//---------------------------------------------------------------
+// MCC_CallFastNative() calls a fast native function from
+// managed code. We use x9 register to pass the native function pointer.
+//
+// MCC_CallFastNative(...) {
+//   br x9; // call the_native_function;
+// }
+//---------------------------------------------------------------
+
+  .text
+  .align 2
+  .global MCC_CallFastNative
+  .global MCC_CallFastNativeExt
+  .type MCC_CallFastNative, %function
+  .type MCC_CallFastNativeExt, %function
+MCC_CallFastNative:
+MCC_CallFastNativeExt:
+  .cfi_startproc
+  // call the native function.
+  br  x9
+  .cfi_endproc
+  .size MCC_CallFastNative, .-MCC_CallFastNative
+
+//---------------------------------------------------------------
+// MCC_CallSlowNative() calls a slow or blocking native
+// function from managed code. The number of arguments
+// of the native function should less than or equal to 8.
+//
+// We use x9 register to pass the native function pointer.
+//
+// This stub will save callee-saved registers to stack and
+// enter saferegion before calling the native function:
+//
+// MCC_CallSlowNative(the_native_function, ...) {
+//   save_callee_saved_registers(); // r19..r28
+//   stateChanged = MRT_EnterSaferegion();
+//   blr x9; // call the_native_function;
+//   if (stateChanged) MRT_LeaveSaferegion();
+//   restore_callee_saved_registers();
+//   return ret;
+// }
+//
+// caller fp,sp -> --------  0
+//                 |  x28 |
+//                 |  x27 | [sp, 0x50]
+//                 |  ... |
+//                 |  x19 | [sp, 0x10]
+//                 --------
+//                 |  x30 | lr
+//                 |  x29 | fp
+//       fp, sp -> --------  -0x60
+//
+//---------------------------------------------------------------
+  .macro MCC_CallSlowNative, funcName, argSize
+  .align 2
+  .global \funcName
+  .type \funcName, %function
+\funcName:
+  .cfi_startproc
+  stp   x29, x30, [sp, -0x60]!
+  .cfi_def_cfa_offset 0x60
+  .cfi_offset 29, -0x60
+  .cfi_offset 30, -0x58
+  add   x29, sp, 0
+  .cfi_def_cfa_register 29
+
+  // save callee-saved registers.
+  stp  x19, x20, [x29, 0x10]
+  .cfi_rel_offset x19, 0x10
+  .cfi_rel_offset x20, 0x18
+
+  stp  x21, x22, [x29, 0x20]
+  .cfi_rel_offset x21, 0x20
+  .cfi_rel_offset x22, 0x28
+
+  stp  x23, x24, [x29, 0x30]
+  .cfi_rel_offset x23, 0x30
+  .cfi_rel_offset x24, 0x38
+
+  stp  x25, x26, [x29, 0x40]
+  .cfi_rel_offset x25, 0x40
+  .cfi_rel_offset x26, 0x48
+
+  stp  x27, x28, [x29, 0x50]
+  .cfi_rel_offset x27, 0x50
+  .cfi_rel_offset x28, 0x58
+
+  // save args to callee-saved reigsters.
+  mov  x19, x9  // func ptr
+  .if \argSize == 1
+  mov  x20, x0  // arg0
+  .endif
+  .if \argSize == 2
+  mov  x20, x0  // arg0
+  mov  x21, x1  // arg1
+  .endif
+  .if \argSize == 3
+  mov  x20, x0  // arg0
+  mov  x21, x1  // arg1
+  mov  x22, x2  // arg2
+  .endif
+  .if \argSize == 4
+  mov  x20, x0  // arg0
+  mov  x21, x1  // arg1
+  mov  x22, x2  // arg2
+  mov  x23, x3  // arg3
+  .endif
+  .if \argSize == 5
+  mov  x20, x0  // arg0
+  mov  x21, x1  // arg1
+  mov  x22, x2  // arg2
+  mov  x23, x3  // arg3
+  mov  x24, x4  // arg4
+  .endif
+  .if \argSize == 6
+  mov  x20, x0  // arg0
+  mov  x21, x1  // arg1
+  mov  x22, x2  // arg2
+  mov  x23, x3  // arg3
+  mov  x24, x4  // arg4
+  mov  x25, x5  // arg5
+  .endif
+  .if \argSize == 7
+  mov  x20, x0  // arg0
+  mov  x21, x1  // arg1
+  mov  x22, x2  // arg2
+  mov  x23, x3  // arg3
+  mov  x24, x4  // arg4
+  mov  x25, x5  // arg5
+  mov  x26, x6  // arg6
+  .endif
+  .if \argSize == 8
+  mov  x20, x0  // arg0
+  mov  x21, x1  // arg1
+  mov  x22, x2  // arg2
+  mov  x23, x3  // arg3
+  mov  x24, x4  // arg4
+  mov  x25, x5  // arg5
+  mov  x26, x6  // arg6
+  mov  x27, x7  // arg7
+  .endif
+
+#if CONFIG_ASAN
+  stp d0,  d1,  [sp,-16]!
+  stp d2,  d3,  [sp,-16]!
+  stp d4,  d5,  [sp,-16]!
+  stp d6,  d7,  [sp,-16]!
+#endif
+
+  // save last java frame
+  ldr  x1, [x29]
+  mov  x0, x30
+  bl   MRT_SetRiskyUnwindContext
+
+  // enter saferegion.
+  mov  x0, #0
+  bl   MRT_EnterSaferegion
+
+  // save result.
+  mov  x28, x0
+#if CONFIG_ASAN
+  ldp d6,  d7,  [sp], 16
+  ldp d4,  d5,  [sp], 16
+  ldp d2,  d3,  [sp], 16
+  ldp d0,  d1,  [sp], 16
+#endif
+
+  // restore args.
+  .if \argSize == 1
+  mov  x0,  x20
+  .endif
+  .if \argSize == 2
+  mov  x0,  x20
+  mov  x1,  x21
+  .endif
+  .if \argSize == 3
+  mov  x0,  x20
+  mov  x1,  x21
+  mov  x2,  x22
+  .endif
+  .if \argSize == 4
+  mov  x0,  x20
+  mov  x1,  x21
+  mov  x2,  x22
+  mov  x3,  x23
+  .endif
+  .if \argSize == 5
+  mov  x0,  x20
+  mov  x1,  x21
+  mov  x2,  x22
+  mov  x3,  x23
+  mov  x4,  x24
+  .endif
+  .if \argSize == 6
+  mov  x0,  x20
+  mov  x1,  x21
+  mov  x2,  x22
+  mov  x3,  x23
+  mov  x4,  x24
+  mov  x5,  x25
+  .endif
+  .if \argSize == 7
+  mov  x0,  x20
+  mov  x1,  x21
+  mov  x2,  x22
+  mov  x3,  x23
+  mov  x4,  x24
+  mov  x5,  x25
+  mov  x6,  x26
+  .endif
+  .if \argSize == 8
+  mov  x0,  x20
+  mov  x1,  x21
+  mov  x2,  x22
+  mov  x3,  x23
+  mov  x4,  x24
+  mov  x5,  x25
+  mov  x6,  x26
+  mov  x7,  x27
+  .endif
+
+  // call native function.
+  blr  x19
+
+  // do not call MRT_LeaveSaferegion
+  // if MRT_EnterSaferegion returns 0
+  cbz  w28, .AFTER_CALL_SLOW_NATIVE_\argSize
+
+  // save return value.
+  mov  x28, x0
+  fmov x27, d0
+
+  // leave saferegion
+  bl   MRT_LeaveSaferegion
+
+  // restore return value
+  mov  x0,  x28
+  fmov d0,  x27
+
+.AFTER_CALL_SLOW_NATIVE_\argSize:
+  // restore callee-saved registers.
+  ldp  x19, x20, [x29, 0x10]
+  .cfi_restore 19
+  .cfi_restore 20
+  ldp  x21, x22, [x29, 0x20]
+  .cfi_restore 21
+  .cfi_restore 22
+  ldp  x23, x24, [x29, 0x30]
+  .cfi_restore 23
+  .cfi_restore 24
+  ldp  x25, x26, [x29, 0x40]
+  .cfi_restore 25
+  .cfi_restore 26
+  ldp  x27, x28, [x29, 0x50]
+  .cfi_restore 27
+  .cfi_restore 28
+
+  // restore fp, lr, sp
+  ldp   x29, x30, [sp], 0x60
+  .cfi_restore 29
+  .cfi_restore 30
+  .cfi_def_cfa 31, 0
+  ret
+  .cfi_endproc
+  .size \funcName, .-\funcName
+  .endm
+
+MCC_CallSlowNative MCC_CallSlowNative0, 0
+MCC_CallSlowNative MCC_CallSlowNative1, 1
+MCC_CallSlowNative MCC_CallSlowNative2, 2
+MCC_CallSlowNative MCC_CallSlowNative3, 3
+MCC_CallSlowNative MCC_CallSlowNative4, 4
+MCC_CallSlowNative MCC_CallSlowNative5, 5
+MCC_CallSlowNative MCC_CallSlowNative6, 6
+MCC_CallSlowNative MCC_CallSlowNative7, 7
+MCC_CallSlowNative MCC_CallSlowNative8, 8
+//---------------------------------------------------------------
+// MCC_CallSlowNativeExt() calls a slow or blocking native
+// function from managed code. this function accept arbitrary number
+// of arguments of the native function.
+//
+// We use x9 register to pass the native function pointer.
+//
+// MCC_CallSlowNativeExt(...) {
+//   save_callee_saved_registers(); // x19..x28
+//   copy_stack_args();             // copy stack args if found
+//   stateChanged = MRT_EnterSaferegion();
+//   blr x9; // call the_native_function;
+//   if (stateChanged) MRT_LeaveSaferegion();
+//   restore_callee_saved_registers();
+//   return ret;
+// }
+//
+//  caller fp ---> --------
+//                 | stack|
+//                 | args |
+//  caller sp ---> --------  0
+//                 |  x28 |
+//                 |  x27 |
+//                 |  ... |
+//                 |  x19 |
+//                 --------
+//                 |  x30 | lr
+//                 |  x29 | fp
+//         fp -->  --------  -0x60
+//                 | stack|
+//                 | args | copy from caller
+//         sp ---> --------
+//
+//---------------------------------------------------------------
+  .align 2
+  .global MCC_CallSlowNativeExt
+  .type MCC_CallSlowNativeExt, %function
+MCC_CallSlowNativeExt:
+  .cfi_startproc
+  stp   x29, x30, [sp, -0x60]!
+  .cfi_def_cfa_offset 0x60
+  .cfi_offset 29, -0x60
+  .cfi_offset 30, -0x58
+  add   x29, sp, 0
+  .cfi_def_cfa_register 29
+
+  // save callee-saved registers.
+  stp  x19, x20, [x29, 0x10]
+  stp  x21, x22, [x29, 0x20]
+  stp  x23, x24, [x29, 0x30]
+  stp  x25, x26, [x29, 0x40]
+  stp  x27, x28, [x29, 0x50]
+
+  // copy stack args.
+  ldr  x19, [x29]               // x19 = caller FP
+  add  x20, sp, 0x60            // x20 = caller SP
+.LOOP_COPY_ARG2:                // for(;;) {
+  cmp  x19, x20                 //   if (x19 == x20)
+  beq  .COPY_ARG_END2           //     break;
+  ldp  x27, x28, [x19, -0x10]!  //   x19-=0x10; load [x19] into x27, x28;
+  stp  x27, x28, [sp,  -0x10]!  //   sp-=0x10;  store x27,x28 to [sp];
+  b    .LOOP_COPY_ARG2          // }
+.COPY_ARG_END2:
+
+  // save args to callee-saved reigsters.
+  mov  x19, x9  // func ptr
+  mov  x20, x0  // arg0
+  mov  x21, x1  // arg1
+  mov  x22, x2  // arg2
+  mov  x23, x3  // arg3
+  mov  x24, x4  // arg4
+  mov  x25, x5  // arg5
+  mov  x26, x6  // arg6
+  mov  x27, x7  // arg7
+
+#if CONFIG_ASAN
+  stp d0,  d1,  [sp,-16]!
+  stp d2,  d3,  [sp,-16]!
+  stp d4,  d5,  [sp,-16]!
+  stp d6,  d7,  [sp,-16]!
+#endif
+
+   // save last java frame
+  ldr  x1, [x29]
+  mov  x0, x30
+  bl   MRT_SetRiskyUnwindContext
+
+  // enter saferegioni.
+  mov  x0, #0
+  bl   MRT_EnterSaferegion
+
+  // save result.
+  mov  x28, x0
+
+  // restore args.
+  mov  x0,  x20
+  mov  x1,  x21
+  mov  x2,  x22
+  mov  x3,  x23
+  mov  x4,  x24
+  mov  x5,  x25
+  mov  x6,  x26
+  mov  x7,  x27
+
+
+#if CONFIG_ASAN
+  ldp d6,  d7,  [sp], 16
+  ldp d4,  d5,  [sp], 16
+  ldp d2,  d3,  [sp], 16
+  ldp d0,  d1,  [sp], 16
+#endif
+
+  // call native function.
+  blr  x19
+
+  // do not call MRT_LeaveSaferegion
+  // if MRT_EnterSaferegion returns 0
+  cbz  w28, .AFTER_CALL_NATIVE2
+
+  // save return value.
+  mov  x28, x0
+  fmov x27, d0
+
+  // leave saferegion
+  bl   MRT_LeaveSaferegion
+
+  // restore return value
+  mov  x0,  x28
+  fmov d0,  x27
+
+.AFTER_CALL_NATIVE2:
+  // restore callee-saved registers.
+  ldp  x19, x20, [x29, 0x10]
+  ldp  x21, x22, [x29, 0x20]
+  ldp  x23, x24, [x29, 0x30]
+  ldp  x25, x26, [x29, 0x40]
+  ldp  x27, x28, [x29, 0x50]
+
+  // set sp to fp.
+  mov sp, x29
+
+  // restore fp, lr, sp
+  ldp   x29, x30, [sp], 0x60
+  .cfi_restore 30
+  .cfi_restore 29
+  .cfi_def_cfa 31, 0
+  ret
+  .cfi_endproc
+  .size MCC_CallSlowNativeExt, .-MCC_CallSlowNativeExt
diff --git a/src/mrt/compiler-rt/src/arch/arm64/dump_register_stub_arm64.S b/src/mrt/compiler-rt/src/arch/arm64/dump_register_stub_arm64.S
new file mode 100644
index 0000000000000000000000000000000000000000..b79bf661b51b9a34433c93cae33d32476e6e9aaa
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/dump_register_stub_arm64.S
@@ -0,0 +1,61 @@
+#define RegSaveAreaSize           (8 * 32)
+#define DumpFrameSize             (RegSaveAreaSize + 8 * 2)
+
+        .text
+        .align 2
+        .global MRT_DumpRegisters
+        .type MRT_DumpRegisters, %function
+MRT_DumpRegisters:
+        .cfi_startproc
+        stp x0, x1, [sp, #-RegSaveAreaSize + 16*0]
+        stp x2, x3, [sp, #-RegSaveAreaSize + 16*1]
+        stp x4, x5, [sp, #-RegSaveAreaSize + 16*2]
+        stp x6, x7, [sp, #-RegSaveAreaSize + 16*3]
+        stp x8, x9, [sp, #-RegSaveAreaSize + 16*4]
+        stp x10, x11, [sp, #-RegSaveAreaSize + 16*5]
+        stp x12, x13, [sp, #-RegSaveAreaSize + 16*6]
+        stp x14, x15, [sp, #-RegSaveAreaSize + 16*7]
+        stp x16, x17, [sp, #-RegSaveAreaSize + 16*8]
+        stp x18, x19, [sp, #-RegSaveAreaSize + 16*9]
+        stp x20, x21, [sp, #-RegSaveAreaSize + 16*10]
+        stp x22, x23, [sp, #-RegSaveAreaSize + 16*11]
+        stp x24, x25, [sp, #-RegSaveAreaSize + 16*12]
+        stp x26, x27, [sp, #-RegSaveAreaSize + 16*13]
+        str x28, [sp, #-RegSaveAreaSize + 16*14]
+
+        str x29, [sp, #-RegSaveAreaSize + 16*14+8]
+        str x30, [sp, #-RegSaveAreaSize + 16*15]
+        mov x0, sp
+        str x0, [sp,  #-RegSaveAreaSize + 16*15 + 8]
+
+        // parameter for PrintAArch64RegSet
+        sub x0, sp, #RegSaveAreaSize
+
+        // prologue
+        stp x29, x30, [sp, #-DumpFrameSize]!
+        mov x29, sp
+
+        bl PrintAArch64RegSet
+
+        // epilogue
+        ldp x29, x30, [sp], #DumpFrameSize
+
+        ldp x0, x1, [sp, #-RegSaveAreaSize + 16*0]
+        ldp x2, x3, [sp, #-RegSaveAreaSize + 16*1]
+        ldp x4, x5, [sp, #-RegSaveAreaSize + 16*2]
+        ldp x6, x7, [sp, #-RegSaveAreaSize + 16*3]
+        ldp x8, x9, [sp, #-RegSaveAreaSize + 16*4]
+        ldp x10, x11, [sp, #-RegSaveAreaSize + 16*5]
+        ldp x12, x13, [sp, #-RegSaveAreaSize + 16*6]
+        ldp x14, x15, [sp, #-RegSaveAreaSize + 16*7]
+        ldp x16, x17, [sp, #-RegSaveAreaSize + 16*8]
+        ldp x18, x19, [sp, #-RegSaveAreaSize + 16*9]
+        ldp x20, x21, [sp, #-RegSaveAreaSize + 16*10]
+        ldp x22, x23, [sp, #-RegSaveAreaSize + 16*11]
+        ldp x24, x25, [sp, #-RegSaveAreaSize + 16*12]
+        ldp x26, x27, [sp, #-RegSaveAreaSize + 16*13]
+        ldr x28, [sp, #-RegSaveAreaSize + 16*14]
+
+        ret
+        .cfi_endproc
+        .size MRT_DumpRegisters, .-MRT_DumpRegisters
diff --git a/src/mrt/compiler-rt/src/arch/arm64/fastFuncs.S b/src/mrt/compiler-rt/src/arch/arm64/fastFuncs.S
new file mode 100644
index 0000000000000000000000000000000000000000..1d721a7887d3d83e1052812d8f33bb17431f919f
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/fastFuncs.S
@@ -0,0 +1,1372 @@
+# ++++++++WARNING++++++++WARNING++++++++WARNING++++++++
+# +
+# + NEED TO BE CAREFUL WHEN THIS FILE IS MODIFIED.
+# +
+# + This file has been hand modified to preserve x11 whenever it can.
+# + It is accomplished by observing x29 == sp, and x11 is saved
+# + in the same stack location as x29 instead of x29.
+# + Further all .cfi directive for 29 is changed to 11
+# + In addition, there is no need to perform 'mv x29, sp' and the
+# + corresponding .cfe for 29.
+# +
+# + If any of the string functions is used by a MRT* function then
+# + internal to the string function the usage of x11 is prohibited.
+# + See strcmp as example.
+# +
+# ++++++++WARNING++++++++WARNING++++++++WARNING++++++++
+
+#ifndef ENABLE_ASSERT_RC_NZ
+#define ENABLE_ASSERT_RC_NZ 1
+#endif
+// following constant should be same with size.h
+#define RC_COLOR_CLEAR_MASK  0x3fffffff
+#define RC_CYCLE_COLOR_BROWN 0xc0000000
+#define STRONG_RC_BITS_MASK  0x0000ffff
+#define RC_BITS_MSB_INDEX    15
+#define WEAK_COLLECTED_INDEX 29
+
+#define WEAK_RC_ONE          0x00400000
+#define WEAK_RC_BITS_MASK    0x1fc00000
+#define WEAK_COLLECT         0x20000000
+#define RESURRECT_STRONG_MASK  0x003fffff
+
+        .text
+        .align  2
+        .p2align 3,,7
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .section .text.MCC_Array_Boundary_Check,"ax",@progbits
+        .global MCC_Array_Boundary_Check
+#else
+        .local  MCC_Array_Boundary_Check
+#endif
+        .type   MCC_Array_Boundary_Check, %function
+MCC_Array_Boundary_Check:
+.LFB9064:
+        .cfi_startproc
+        stp     x11, x30, [sp, -32]!
+        .cfi_def_cfa_offset 32
+        .cfi_offset 11, -32
+        .cfi_offset 30, -24
+#       add     x29, sp, 0
+#       .cfi_def_cfa_register 29
+        cbz     x0, .L840
+        ldr     w2, [x0, 12]
+        tbnz    w1, #31, .L838
+        cmp     w1, w2
+        bge     .L838
+        ldp     x11, x30, [sp], 32
+        .cfi_remember_state
+        .cfi_restore 30
+        .cfi_restore 11
+        .cfi_def_cfa 31, 0
+        ret
+        .p2align 3
+.L838:
+        .cfi_restore_state
+#   WARNING The value stored at [sp+0] should be x29
+#           which has not been changed by this func
+#       ldr     x1, [sp]
+#   store index and length
+        stp x1, x2, [sp, 16]
+        mov x1, x29
+        mov     x0, x30
+        bl      MRT_SetRiskyUnwindContext
+#   restore index and length
+        ldp      x11, x30, [sp], 16
+        ldp      x1, x0, [sp], 16
+        .cfi_remember_state
+        .cfi_restore 30
+        .cfi_restore 11
+        .cfi_def_cfa 31, 0
+        b       MRT_ThrowArrayIndexOutOfBoundsException
+        .p2align 3
+.L840:
+        .cfi_restore_state
+#   WARNING The value stored at [sp+0] should be x29
+#           which has not been changed by this func
+#       ldr     x1, [sp]
+        mov x1, x29
+        mov     x0, x30
+        bl      MRT_SetRiskyUnwindContext
+        ldp     x11, x30, [sp], 32
+        .cfi_restore 30
+        .cfi_restore 11
+        .cfi_def_cfa 31, 0
+        b       MRT_ThrowNullPointerExceptionUnw
+        .cfi_endproc
+.LFE9064:
+        .size   MCC_Array_Boundary_Check, .-MCC_Array_Boundary_Check
+
+        .section .rodata, "a",%progbits
+        .local .L.str.interface.itab
+        .p2align 3
+        .type   .L.str.interface.itab,@object
+.L.str.interface.itab:
+        .asciz  "java/lang/AbstractMethodError"
+        .size   .L.str.interface.itab, 30
+
+        .text
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .section .text.MCC_getFuncPtrFromItab // -- Begin function MCC_getFuncPtrFromItab,"ax",@progbits
+        .global MCC_getFuncPtrFromItab // -- Begin function MCC_getFuncPtrFromItab
+#else
+        .local MCC_getFuncPtrFromItab // -- Begin function MCC_getFuncPtrFromItab
+#endif
+        .p2align 3
+        .type   MCC_getFuncPtrFromItab,@function
+MCC_getFuncPtrFromItab:     // @MCC_getFuncPtrFromItab
+        .cfi_startproc
+// %bb.0:
+        sub     sp, sp, #64             // =64
+        stp     x22, x21, [sp, #16]     // 16-byte Folded Spill
+        stp     x20, x19, [sp, #32]     // 16-byte Folded Spill
+        stp     x29, x30, [sp, #48]     // 16-byte Folded Spill
+        add     x29, sp, #48            // =48
+        .cfi_def_cfa w29, 16
+        .cfi_offset w30, -8
+        .cfi_offset w29, -16
+        .cfi_offset w19, -24
+        .cfi_offset w20, -32
+        .cfi_offset w21, -40
+        .cfi_offset w22, -48
+        ldr     w8, [x0, #92]
+        cbz     w8, .LBB131_4
+// %bb.1:
+        cmp     w1, #203                // =203
+        add     x10, x8, #8             // =8
+        b.hi    .LBB131_7
+.LBB131_2:                              // =>This Inner Loop Header: Depth=1
+        ldr     w8, [x10], #8
+        cmp     w8, w1
+        b.ne    .LBB131_2
+// %bb.3:
+        ldur    w0, [x10, #-4]
+        b       .LBB131_6
+.LBB131_4:
+        adrp    x0, .L.str.interface.itab
+        add     x0, x0, :lo12:.L.str.interface.itab
+        mov     x1, x2
+.LBB131_5:
+        bl      MRT_ThrowNewExceptionUnw
+        mov     x0, xzr
+.LBB131_6:
+        ldp     x29, x30, [sp, #48]     // 16-byte Folded Reload
+        ldp     x20, x19, [sp, #32]     // 16-byte Folded Reload
+        ldp     x22, x21, [sp, #16]     // 16-byte Folded Reload
+        add     sp, sp, #64             // =64
+        ret
+.LBB131_7:
+        ldr     w9, [x8]
+        mov     w11, wzr
+        and     w12, w9, #0xffff
+.LBB131_8:                              // =>This Inner Loop Header: Depth=1
+        add     w13, w11, w12
+        and     w14, w13, #0xfffffffe
+        ldr     w14, [x10, w14, uxtw #2]
+        cmp     w14, w1
+        b.eq    .LBB131_10
+// %bb.9:                               //   in Loop: Header=BB131_8 Depth=1
+        lsr     w15, w13, #1
+        cmp     w14, w1
+        sub     w14, w15, #1            // =1
+        csel    w12, w12, w14, lo
+        csinc   w11, w11, w15, hs
+        cmp     w11, w12
+        b.ls    .LBB131_8
+.LBB131_10:
+        orr     w11, w13, #0x1
+        ldr     w0, [x10, w11, uxtw #2]
+        cmp     w0, #1                  // =1
+        b.ne    .LBB131_6
+// %bb.11:
+        stp     x8, x2, [sp]            // 16-byte Folded Spill
+        ubfx    x8, x9, #15, #17
+        cmp     w9, #0                  // =0
+        and     w8, w8, #0xfffe
+        orr     w10, wzr, #0xfffffffe
+        csel    w8, w8, w10, lt
+        cbz     w8, .LBB131_15
+// %bb.12:
+        ubfiz   x9, x9, #1, #16
+        add     x20, x9, #2             // =2
+        ldr     x9, [sp]                // 8-byte Folded Reload
+        mov     x19, xzr
+        mov     w21, w8
+        add     x9, x9, x20, lsl #2
+        sub     x22, x9, #8             // =8
+.LBB131_13:                             // =>This Inner Loop Header: Depth=1
+        add     x8, x22, x19, lsl #2
+        ldr     w1, [x8, #8]
+        ldr     x0, [sp, #8]            // 8-byte Folded Reload
+        bl      strcmp
+        cbz     w0, .LBB131_16
+// %bb.14:                              //   in Loop: Header=BB131_13 Depth=1
+        add     x19, x19, #2            // =2
+        cmp     x19, x21
+        b.lo    .LBB131_13
+.LBB131_15:
+        ldr     x1, [sp, #8]            // 8-byte Folded Reload
+        adrp    x0, .L.str.interface.itab
+        add     x0, x0, :lo12:.L.str.interface.itab
+        b       .LBB131_5
+.LBB131_16:
+        ldr     x8, [sp]                // 8-byte Folded Reload
+        add     x8, x8, x20, lsl #2
+        add     x8, x8, x19, lsl #2
+        ldr     w0, [x8, #4]
+        b       .LBB131_6
+.Lfunc_end131:
+        .size   MCC_getFuncPtrFromItab, .Lfunc_end131-MCC_getFuncPtrFromItab
+        .cfi_endproc
+
+
+#define STRING_LENGTH_OFFSET 8
+#define STRING_HASH_OFFSET 12
+
+        .section        .rodata
+        .align  2
+.Lmethod_desc.string_equals:
+        .word __methods_compact__string_equals - .
+        .short 16
+        .short 0
+        .section  .java_text,"ax"
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .global  __string_equals
+#else
+        .local  __string_equals
+#endif
+        .type   __string_equals, %function
+        .align 2
+        .word .Lmethod_desc.string_equals - .
+__string_equals:
+        .cfi_startproc
+        .cfi_personality 155, DW.ref.__mpl_personality_v0
+        ldp     x4, x2, [x0], #16               // read class shadow and count of this, replace assertnonnull
+        cbz     x1, .Label.string_equals_false  // if the other is null
+        cmp     x0, x1
+        beq     .Label.string_equals_true       // same address, return true
+        ldp     x5, x3, [x1], #16               // read class shadow and count of the other
+        cmp     w4, w5
+        bne     .Label.string_equals_false      // if not the same class
+        cmp     w2, w3                          //  Length and compression flag are different
+        bne     .Label.string_equals_morecheck
+        and     w3, w2, #1
+        lsr     w2, w2, w3                      // get the number of bytes
+        cbz     w2, .Label.string_equals_true   //  zero length
+        add     w2, w2, #7
+        lsr     w5, w2, 4
+        cbz     w5, .Label.string_equals_tail2  // size is shorter than 8
+        add     x5, x0, x5, lsl 4
+.Label.string_equals_loophead:
+        ldp     x3, x6, [x0], #16
+        ldp     x4, x7, [x1], #16
+        cmp     x3, x4
+        bne     .Label.string_equals_false
+        cmp     x6, x7
+        bne     .Label.string_equals_false
+        cmp     x0, x5
+        bne     .Label.string_equals_loophead
+.Label.string_equals_tail:
+        tbz     w2, #3, .Label.string_equals_true
+.Label.string_equals_tail2:
+        ldr     x3, [x0]
+        ldr     x2, [x1]
+        cmp     x3, x2
+        bne     .Label.string_equals_false
+.Label.string_equals_true:
+        mov     w0, 1
+        ret
+.Label.string_equals_false:
+        mov     w0, 0
+        ret
+.Label.string_equals_morecheck:         // check for compressed bits are diff byte size are equal
+        eor     w2, w2, w3
+        cmp     w2, #1
+        bne     .Label.string_equals_false
+        tbnz    w3, #0, .Label.string_equals_loop2
+        mov     x2, x0
+        mov     x0, x1
+        mov     x1, x2    // swap x0 and x1 to make sure that x0 is normal and x1 is compressed
+.Label.string_equals_loop2:
+        lsr     w3, w3, #1
+        // x0: normal, x1; compressed, w3: length
+.Label.string_equals_loop2_head:
+        subs    w3, w3, #1
+        tbnz    w3, #31, .Label.string_equals_true
+        ldrh    w4, [x0,w3,SXTW #1]  // normal string
+        ldrb    w5, [x1,w3,SXTW #0]  // compressed string
+        cmp     w4, w5
+        beq     .Label.string_equals_loop2_head
+        b       .Label.string_equals_false
+       .cfi_endproc
+.Label.end.__string_equals:
+        .size   __string_equals, .-__string_equals
+        .word 0x55555555
+
+        .data
+        .align  3
+        .type  __ref__string_equals, %object
+        .local __ref__string_equals
+__ref_string_equals:
+        .quad  __string_equals
+        .size  __ref_string_equals, . - __ref_string_equals
+
+        .data
+        .align  3
+        .type  __methods_compact__string_equals, %object
+        .local __methods_compact__string_equals
+__methods_compact__string_equals:
+        .long   0                            // methodInVtabIndex
+        .long   0                            // declaringClass
+        .long   0                            // addr
+        .long   0                            // mod
+        .long   __namestr__string_equals - . // name
+        .long   0                            // signature
+        .long   0                            // annotation
+        .short  0                            // flag
+        .short  2                            // argsize
+        .data
+        .type __namestr__string_equals, %object
+        .local __namestr__string_equals
+__namestr__string_equals:
+        .string "__string_equals"
+
+        .section        .rodata
+        .align  2
+.Lmethod_desc.string_hashCode:
+        .word __methods_compact_string_hashCode - .
+        .short 16
+        .short 0
+        .section  .java_text,"ax"
+        .align 2
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .global __string_hashCode
+#else
+        .local  __string_hashCode
+#endif
+        .type   __string_hashCode, %function
+        .word .Lmethod_desc.string_hashCode - .
+__string_hashCode:
+.Label.__string_hashCode9:
+        .cfi_startproc
+        .cfi_personality 155, DW.ref.__mpl_personality_v0
+        ldr     w2, [x0,#STRING_HASH_OFFSET]         // Ljava/lang/String;.hash
+        cbnz    w2, .Label.__string_hashCode1
+        ldr     w1, [x0,#STRING_LENGTH_OFFSET]          // length + flag for compressed string
+        lsr     w4, w1, #1
+        cbz     w4, .Label.__string_hashCode1
+        mov     w5, #0               // start offset
+        add     x3, x0, #16          // start address
+        tbz     w1, #0, .Label.__string_hashCode4
+.Label.__string_hashCode3:
+        ldrb    w6, [x3,w5,SXTW #0]  // compressed string
+        lsl     w1, w2, #5
+        add     w5, w5, #1
+        sub     w1, w1, w2
+        cmp     w5, w4
+        add     w2, w1, w6
+        blt     .Label.__string_hashCode3
+        b       .Label.__string_hashCode6
+.Label.__string_hashCode4:
+        ldrh    w6, [x3,w5,SXTW #1]  // normal string
+        lsl     w1, w2, #5
+        add     w5, w5, #1
+        sub     w1, w1, w2
+        cmp     w5, w4
+        add     w2, w1, w6
+        blt     .Label.__string_hashCode4
+.Label.__string_hashCode6:
+        str     w2, [x0,#12]         // hash = h
+.Label.__string_hashCode1:
+        mov     w0, w2
+.Label.__string_hashCode12:
+        ret
+.Label.__string_hashCode11:
+        b       .Label.__string_hashCode12
+.Label.__string_hashCode10:
+        .cfi_endproc
+.Label.end.__string_hashCode:
+        .size   __string_hashCode, .-__string_hashCode
+        .word 0x55555555
+
+        .data
+        .align  3
+        .type  __ref_string_hashCode, %object
+        .local __ref_string_hashCode
+__ref_string_hashCode:
+        .quad  __string_hashCode
+        .size  __ref_string_hashCode, . - __ref_string_hashCode
+
+        .data
+        .align  3
+        .type  __methods_compact_string_hashCode, %object
+        .local __methods_compact_string_hashCode
+__methods_compact_string_hashCode:
+        .long   0                              // methodInVtabIndex
+        .long   0                              // declaringClass
+        .long   0                              // addr
+        .long   0                              // mod
+        .long   __namestr__string_hashCode - . // name
+        .long   0                              // signature
+        .long   0                              // annotation
+        .short  0                              // flag
+        .short  1                              // argsize
+
+        .data
+        .type __namestr__string_hashCode, %object
+        .local __namestr__string_hashCode
+__namestr__string_hashCode:
+        .string "__string_hashCode"
+
+        // The following implementation is android specific.
+        // ARM64-linux will call into libs-fast directly
+        // (with the cost of an extra plt)
+#ifdef __ANDROID__
+        .text
+        .align   2
+        .p2align 3,,7
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .section .text.MCC_PreNativeCall,"ax",@progbits
+        .global  MCC_PreNativeCall
+#else
+        .local  MCC_PreNativeCall
+#endif
+        .type   MCC_PreNativeCall, %function
+MCC_PreNativeCall:
+.Lfunc_begin2:
+        .cfi_startproc
+        mrs     x8, TPIDR_EL0
+        ldr     x8, [x8, #56]
+        ldr     x8, [x8, #56]
+        ldr     x9, [x8]
+        mov     x0, x8
+        ldr     x1, [x9, #8]
+        br      x1
+.Lfunc_end2:
+        .size   MCC_PreNativeCall, .Lfunc_end2-MCC_PreNativeCall
+        .cfi_endproc
+
+        .text
+        .align   2
+        .p2align 3,,7
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .section .text.MCC_PostNativeCall,"ax",@progbits
+        .global  MCC_PostNativeCall
+#else
+        .local  MCC_PostNativeCall
+#endif
+        .type   MCC_PostNativeCall, %function
+MCC_PostNativeCall:                     // @MCC_PostNativeCall
+.Lfunc_begin3:
+        .cfi_startproc
+        mrs     x8, TPIDR_EL0
+        ldr     x8, [x8, #56]
+        mov     x1, x0
+        ldr     x8, [x8, #56]
+        ldr     x9, [x8]
+        mov     x0, x8
+        ldr     x2, [x9, #16]
+        br      x2
+.Lfunc_end3:
+        .size   MCC_PostNativeCall, .Lfunc_end3-MCC_PostNativeCall
+        .cfi_endproc
+
+#endif // __ANDROID__
+
+#ifdef __ANDROID__
+        .text
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .section .text.MCC_SetRiskyUnwindContext // -- Begin function MCC_SetRiskyUnwindContext,"ax",@progbits
+        .global  MCC_SetRiskyUnwindContext // -- Begin function MCC_SetRiskyUnwindContext
+#else
+        .local MCC_SetRiskyUnwindContext // -- Begin function MCC_SetRiskyUnwindContext
+#endif
+        .p2align 2
+        .type   MCC_SetRiskyUnwindContext,@function
+MCC_SetRiskyUnwindContext:
+.Lfunc_begin18:
+        .cfi_startproc
+        mrs     x8, TPIDR_EL0
+        ldr     x8, [x8, #56]
+        cbz     x8, .LBB18_2
+        ldr     x8, [x8]
+.LBB18_2:
+        orr     w9, wzr, #0x2
+        stp     x1, x0, [x8, #96]
+        str     xzr, [x8, #136]
+        stp     xzr, xzr, [x8, #112]
+        str     w9, [x8, #80]
+        ret
+.Lfunc_end18:
+        .size   MCC_SetRiskyUnwindContext, .Lfunc_end18-MCC_SetRiskyUnwindContext
+        .cfi_endproc
+
+        .text
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .section .text.MCC_SetReliableUnwindContext // -- Begin function MCC_SetReliableUnwindContext,"ax",@progbits
+        .global  MCC_SetReliableUnwindContext // -- Begin function MCC_SetReliableUnwindContext
+#else
+        .local MCC_SetReliableUnwindContext // -- Begin function MCC_SetReliableUnwindContext
+#endif
+        .p2align 2
+        .type   MCC_SetReliableUnwindContext,@function
+MCC_SetReliableUnwindContext:     // @MCC_SetReliableUnwindContext
+.Lfunc_begin19:
+        .cfi_startproc
+        mrs     x8, TPIDR_EL0
+        ldr     x8, [x8, #56]
+        orr     w9, wzr, #0x1
+        ldr     x8, [x8]
+        str     w9, [x8, #80]
+        ret
+.Lfunc_end19:
+        .size   MCC_SetReliableUnwindContext, .Lfunc_end19-MCC_SetReliableUnwindContext
+        .cfi_endproc
+
+//libmrtbase/include/thread-offsets.h
+
+        .text
+        .align  2
+        .p2align 3,,7
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .section .text.MCC_SyncExitFast,"ax",@progbits
+        .global MCC_SyncExitFast
+#else
+        .local MCC_SyncExitFast
+#endif
+        .type  MCC_SyncExitFast, %function
+MCC_SyncExitFast:
+.Lfunc_begin4:
+        .cfi_startproc
+        adrp    x8, :got:_ZN5maple7IThread11is_started_E
+        ldr     x8, [x8, :got_lo12:_ZN5maple7IThread11is_started_E]
+        ldr     x8, [x8]
+        ldrb    w8, [x8]
+        cmp     w8, #1
+        b.ne    .LBB4_7
+        mrs     x8, TPIDR_EL0
+        ldr     x8, [x8, #56]
+        cbz     x8, .LBB4_7
+        cbz     x0, .LBB4_7
+        ldr     x8, [x8, #56]
+        cbz     x8, .LBB4_7
+        add     x9, x0, #4
+        ldar    w10, [x9]
+        ldr     w11, [x8, #8]
+        and     w12, w10, #0xc000ffff
+        cmp     w11, w12
+        b.ne    .LBB4_7
+        ldaxr   w12, [x9]
+        and     w11, w10, #0x10000000
+        sub     w13, w10, #16, lsl #12  // =65536
+        tst     w10, #0xfff0000
+        csel    w11, w11, w13, eq
+        cmp     w12, w10
+        b.ne    .LBB4_8
+        stlxr   w10, w11, [x9]
+        cbz     w10, .LBB4_9
+.LBB4_7:
+        b       MRT_BuiltinSyncExit
+.LBB4_8:
+        clrex
+        b       MRT_BuiltinSyncExit
+.LBB4_9:
+        ldr     x9, [x8]
+        mov     x0, x8
+        ldr     x1, [x9, #304]
+        br      x1
+.Lfunc_end4:
+        .size   MCC_SyncExitFast, .Lfunc_end4-MCC_SyncExitFast
+        .cfi_endproc
+
+        .text
+        .align  2
+        .p2align 3,,7
+#ifndef ENABLE_LOCAL_FAST_FUNCS
+        .section .text.MCC_SyncEnterFast2,"ax",@progbits
+        .global MCC_SyncEnterFast2
+#else
+        .local MCC_SyncEnterFast2
+#endif
+        .type  MCC_SyncEnterFast2, %function
+MCC_SyncEnterFast2:
+.Lfunc_begin0:
+        .cfi_startproc
+        adrp    x8, :got:_ZN5maple7IThread11is_started_E
+        ldr     x8, [x8, :got_lo12:_ZN5maple7IThread11is_started_E]
+        mov     x1, x0
+        ldr     x8, [x8]
+        ldrb    w8, [x8]
+        cmp     w8, #1
+        b.ne    .LBB0_13
+        mrs     x8, TPIDR_EL0
+        ldr     x8, [x8, #56]
+        cbz     x8, .LBB0_13
+        cbz     x1, .LBB0_13
+        ldr     x0, [x8, #56]
+        cbz     x0, .LBB0_13
+        add     x8, x1, #4
+        ldar    w9, [x8]
+        ldr     w10, [x0, #8]
+        tst     w9, #0xefffffff
+        b.ne    .LBB0_8
+        ldaxr   w11, [x8]
+        cmp     w11, w9
+        b.ne    .LBB0_12
+        orr     x9, x10, x9
+        stlxr   w10, w9, [x8]
+        cbnz    w10, .LBB0_13
+.LBB0_7:
+        ldr     x8, [x0]
+        orr     w3, wzr, #0x1
+        mov     x2, x30
+        ldr     x4, [x8, #288]
+        br      x4
+.LBB0_8:
+
+        and     w11, w9, #0xc000ffff
+        cmp     w10, w11
+        b.ne    .LBB0_13
+        and     w10, w9, #0xfff0000
+        orr     w11, wzr, #0xfff0000
+        cmp     w10, w11
+        b.eq    .LBB0_13
+
+        ldaxr   w10, [x8]
+        cmp     w10, w9
+        b.ne    .LBB0_12
+        add     w9, w9, #16, lsl #12    // =65536
+        stlxr   w10, w9, [x8]
+        cbnz    w10, .LBB0_13
+        b       .LBB0_7
+.LBB0_12:
+        clrex
+.LBB0_13:
+        mov     x0, x1
+        b       MRT_BuiltinSyncEnter
+.Lfunc_end0:
+        .size   MCC_SyncEnterFast2, .Lfunc_end0-MCC_SyncEnterFast2
+        .cfi_endproc
+#endif // __ANDROID__
+
+#ifdef ENABLE_LOCAL_FAST_FUNCS
+#if !DISABLE_RC_DUPLICATE
+        .text
+        .align  2
+        .p2align 3,,7
+        .local  MCC_DecRefResetPair
+        .type  MCC_DecRefResetPair, %function
+MCC_DecRefResetPair:
+        .cfi_startproc
+        adrp    x2, gcIsGCOnly
+        ldr     x2, [x2, :lo12:gcIsGCOnly]
+        cbz     x2, .L_RC_DECREF_RESET_PAIR
+        str     xzr, [x0]
+        str     xzr, [x1]
+        ret
+.L_RC_DECREF_RESET_PAIR:
+.LResetPairSTART:
+        stp     x20, x30, [sp, -16]!
+        .cfi_def_cfa_offset 16
+        .cfi_offset 20, -16
+        .cfi_offset 30, -8
+        ldr     x2, [x0]
+        mov     x20, x1
+        str     xzr, [x0]
+        mov     x0, x2
+        bl      MCC_DecRef_NaiveRCFast
+        ldr     x0, [x20]
+        str     xzr, [x20]
+        bl      MCC_DecRef_NaiveRCFast
+        ldp     x20, x30, [sp], 16
+        .cfi_remember_state
+        .cfi_restore 30
+        .cfi_restore 20
+        .cfi_def_cfa 31, 0
+        ret
+        .cfi_endproc
+        .size   MCC_DecRefResetPair, .-MCC_DecRefResetPair
+
+        .text
+        .align  2
+        .p2align 3,,7
+        .local  MCC_IncDecRefReset
+        .type   MCC_IncDecRefReset, %function
+MCC_IncDecRefReset:
+        .cfi_startproc
+        adrp    x2, gcIsGCOnly
+        ldr     x2, [x2, :lo12:gcIsGCOnly]
+        cbz     x2, .L_RC_IncDec_Reset
+        str     xzr, [x1]
+        ret
+.L_RC_IncDec_Reset:
+        ldr     x2, [x1]
+        str     xzr, [x1]
+        mov     x1, x2
+        b       MCC_IncDecRef_NaiveRCFast
+        .cfi_endproc
+        .size   MCC_IncDecRefReset, .-MCC_IncDecRefReset
+
+        .text
+        .align  2
+        .p2align 3,,7
+        .local  MCC_IncRef_NaiveRCFast
+        .type   MCC_IncRef_NaiveRCFast, %function
+MCC_IncRef_NaiveRCFast:
+.LFB7178:
+        .cfi_startproc
+    # WARNING - presersing x11
+    #         - replacing x29 with sp
+    #         - there should be no usage of x29
+        adrp    x1, gcIsGCOnly
+        ldr     x1, [x1, :lo12:gcIsGCOnly]
+        cbz     x1, .L_RC_INC
+        ret
+.L_RC_INC:
+        sub     x1, x0, #16, lsl #12    // x1 = x0 - 65536
+        mov     w2, #2147418111         // x2 = 2^31 - 65537
+        cmp     x1, x2                  // if (x1 >= x2)
+        bhi     .L81                    //   goto .L81
+        stp     x11, x30, [sp, -32]!
+        .cfi_def_cfa_offset 32
+        .cfi_offset 11, -32
+        .cfi_offset 30, -24
+        sub     x2, x0, #4
+#       add     x29, sp, 0
+#       .cfi_def_cfa_register 29
+        .p2align 2
+.L73:
+        ldar    w4, [x2]
+        tbnz    w4, #RC_BITS_MSB_INDEX, .L80
+        and     w1, w4, RC_COLOR_CLEAR_MASK
+        add     w1, w1, 1
+        ldaxr   w3, [x2]
+        cmp     w3, w4
+        bne     .L73
+        stlxr   w5, w1, [x2]
+        cbnz w5, .L73
+#if ENABLE_ASSERT_RC_NZ
+        tst     x4, STRONG_RC_BITS_MASK  // check inc from 0
+        beq     .L83
+#endif
+.L80:
+        ldp     x11, x30, [sp], 32
+        .p2align 2
+.L81:
+        .cfi_remember_state
+        .cfi_restore 30
+        .cfi_restore 11
+        .cfi_def_cfa 31, 0
+        ret
+        .p2align 3
+.L83:
+        .cfi_restore_state
+        bl      MRT_BuiltinAbortSaferegister
+        .cfi_endproc
+.LFE7178:
+        .size   MCC_IncRef_NaiveRCFast, .-MCC_IncRef_NaiveRCFast
+
+        .text
+        .align  2
+        .p2align 3,,7
+        .local  MCC_ClearLocalStackRef
+        .type   MCC_ClearLocalStackRef, %function
+MCC_ClearLocalStackRef:
+        .cfi_startproc
+        adrp    x1, gcIsGCOnly
+        ldr     x1, [x1, :lo12:gcIsGCOnly]
+        cbz     x1, .L_RC_CLEAR_LOCAL
+        str     xzr, [x0]
+        ret
+.L_RC_CLEAR_LOCAL:
+        ldr     x1, [x0]
+        str     xzr, [x0]
+        mov     x0, x1
+        b       MCC_DecRef_NaiveRCFast
+        .cfi_endproc
+        .size   MCC_ClearLocalStackRef, .-MCC_ClearLocalStackRef
+
+        .text
+        .align  2
+        .p2align 3,,7
+        .local  MCC_LoadRefField_NaiveRCFast
+        .type   MCC_LoadRefField_NaiveRCFast, %function
+MCC_LoadRefField_NaiveRCFast:
+.LFB7197:
+        .cfi_startproc
+    # WARNING - presersing x11
+    #         - replacing x29 with sp
+    #         - there should be no usage of x29
+        cbz     x0, .L_RC_LOAD_REF
+        adrp    x3, gcIsGCOnly
+        ldr     x3, [x3, :lo12:gcIsGCOnly]
+        cbz     x3, .L_RC_LOAD_REF
+#ifdef USE_32BIT_REF
+        ldr     w0, [x1] // load 32bit-ref-field
+#else
+        ldr     x0, [x1] // load 64bit-ref-field
+#endif //USE_32BIT_REF
+        ret
+.L_RC_LOAD_REF:
+        stp     x11, x30, [sp, -64]!
+        .cfi_def_cfa_offset 64
+        .cfi_offset 11, -64
+        .cfi_offset 30, -56
+#       add     x29, sp, 0
+#       .cfi_def_cfa_register 29
+.LEHB15:
+        stp     x19, x20, [sp, 16]
+        .cfi_offset 19, -48
+        .cfi_offset 20, -40
+        mov     x19, x0
+        str     x21, [sp, 32]
+        .cfi_offset 21, -32
+        mov     x20, x1
+        mov     x21, x30
+        cbz     x0, .L185
+.L174:
+#ifdef USE_32BIT_REF
+        ldr     w1, [x20] // load 32bit-ref-field
+#else
+        ldr     x1, [x20] // load 64bit-ref-field
+#endif //USE_32BIT_REF
+        tbnz    x1, #0, .L178
+        mov     x0, x1
+        sub     x2, x1, #16, lsl #12    // x2 = x1 - 65536
+        mov     w3, #2147418111         // x3 = 2^31 - 65537
+        cmp     x2, x3                  // if (x2 < x3)
+        bls     .L186                   //   goto .L186
+        .p2align 2
+.L175:
+        ldp     x19, x20, [sp, 16]
+        ldr     x21, [sp, 32]
+.LEHE15:
+        ldp     x11, x30, [sp], 64
+        .cfi_remember_state
+        .cfi_restore 30
+        .cfi_restore 11
+        .cfi_restore 21
+        .cfi_restore 19
+        .cfi_restore 20
+        .cfi_def_cfa 31, 0
+        ret
+        .p2align 3
+.L186:
+        .cfi_restore_state
+        sub     x1, x1, #4
+        ldar    w2, [x1]
+        tbnz    w2, #RC_BITS_MSB_INDEX, .L175
+        ands    w3, w2, STRONG_RC_BITS_MASK
+        str     w2, [sp, 60]
+        beq     .L178
+        ands    w3, w2, RC_COLOR_CLEAR_MASK
+        add     w3, w3, 1
+        ldaxr   w4, [x1]
+        cmp     w4, w2
+        bne     .L183
+        stlxr   w5, w3, [x1]
+        cmp     w5, 0
+.L183:
+        beq     .L175
+        str     w4, [sp, 60]
+.L178:
+#   WARNING The value stored at [sp+0] should be x29
+#           which has not been changed by this func
+#       ldr     x1, [sp]
+        mov     x1, x29
+        mov     x0, x21
+.LEHB16:
+        bl      MRT_SetRiskyUnwindContext
+        mov     x1, x20
+        mov     x0, x19
+        bl      MRT_LoadRefField
+
+        mov     x19, x0
+        bl      MRT_SetReliableUnwindContextStatus
+        mov     x0, x19
+
+        ldp     x19, x20, [sp, 16]
+        ldr     x21, [sp, 32]
+        ldp     x11, x30, [sp], 64
+        .cfi_remember_state
+        .cfi_restore 20
+        .cfi_restore 19
+        .cfi_restore 21
+        .cfi_restore 11
+        .cfi_restore 30
+        .cfi_def_cfa 31, 0
+        ret
+        .p2align 3
+.L185:
+        .cfi_restore_state
+#   WARNING The value stored at [sp+0] should be x29
+#           which has not been changed by this func
+#       ldr     x1, [sp]
+        mov     x1, x29
+        mov     x0, x30
+        bl      MRT_SetRiskyUnwindContext
+        bl      MRT_ThrowNullPointerExceptionUnw
+.LEHE16:
+        b      .L174
+        .cfi_endproc
+.LFE7197:
+        .size   MCC_LoadRefField_NaiveRCFast, .-MCC_LoadRefField_NaiveRCFast
+
+        .text
+        .align  2
+        .p2align 3,,7
+        .local MCC_CleanupLocalStackRef_NaiveRCFast
+        .type   MCC_CleanupLocalStackRef_NaiveRCFast, %function
+MCC_CleanupLocalStackRef_NaiveRCFast:
+        .cfi_startproc
+        adrp    x2, gcIsGCOnly
+        ldr     x2, [x2, :lo12:gcIsGCOnly]
+        cbz     x2, .L_RC_CLEANUP
+        ret
+.L_RC_CLEANUP:
+#if CONFIG_JSAN
+        stp     x29, x30, [sp, -32]!
+        .cfi_def_cfa_offset 32
+        .cfi_offset 29, -32
+        .cfi_offset 30, -24
+        mov     x29, sp
+        str     x11, [x29, 16]
+        .cfi_offset 11, -16
+        bl      MCC_CleanupLocalStackRef
+        ldr     x11, [x29, 16]
+        ldp     x29, x30, [sp], 32
+        .cfi_restore 11
+        .cfi_restore 29
+        .cfi_restore 30
+        .cfi_def_cfa 31, 0
+        ret
+        .cfi_endproc
+#else
+.LFB7168:
+    # WARNING - presersing x11
+    #         - replacing x29 with sp
+    #         - there should be no usage of x29
+        cbz     x1, .L150
+        stp     x11, x30, [sp, -48]!
+        .cfi_def_cfa_offset 48
+        .cfi_offset 11, -48
+        .cfi_offset 30, -40
+#       add     x29, sp, 0
+#       .cfi_def_cfa_register 29
+        stp     x19, x20, [sp, 16]
+        .cfi_offset 19, -32
+        .cfi_offset 20, -24
+        mov     x20, x1
+        str     x21, [sp, 32]
+        .cfi_offset 21, -16
+        mov     x19, 0
+        mov     x21, x0
+        b       .L120
+        .p2align 3
+.L101:
+        cmp     x20, x19
+        beq     .L110
+.L120:
+        ldr     x0, [x21, x19, lsl 3]
+        add     x19, x19, 1
+        cbz     x0, .L101
+        bl      MCC_DecRef_NaiveRCFast
+        cmp     x20, x19
+        bne     .L120
+.L110:
+        ldp     x19, x20, [sp, 16]
+        ldr     x21, [sp, 32]
+        ldp     x11, x30, [sp], 48
+        .cfi_restore 30
+        .cfi_restore 11
+        .cfi_restore 21
+        .cfi_restore 19
+        .cfi_restore 20
+        .cfi_def_cfa 31, 0
+        ret
+.L150:
+        ret
+        .cfi_endproc
+.LFE7168:
+#endif
+        .size   MCC_CleanupLocalStackRef_NaiveRCFast, .-MCC_CleanupLocalStackRef_NaiveRCFast
+
+        .text
+        .align  2
+        .p2align 3,,7
+        .local MCC_CleanupLocalStackRefSkip_NaiveRCFast
+        .type   MCC_CleanupLocalStackRefSkip_NaiveRCFast, %function
+MCC_CleanupLocalStackRefSkip_NaiveRCFast:
+        .cfi_startproc
+        adrp    x3, gcIsGCOnly
+        ldr     x3, [x3, :lo12:gcIsGCOnly]
+        cbz     x3, .L_RC_CLEANUP_SKIP
+        ret
+.L_RC_CLEANUP_SKIP:
+#if CONFIG_JSAN
+        stp     x29, x30, [sp, -32]!
+        .cfi_def_cfa_offset 32
+        .cfi_offset 29, -32
+        .cfi_offset 30, -24
+        mov     x29, sp
+        str     x11, [x29, 16]
+        bl      MCC_CleanupLocalStackRefSkip
+        .cfi_offset 11, -16
+        ldr     x11, [x29, 16]
+        ldp     x29, x30, [sp], 32
+        .cfi_restore 11
+        .cfi_restore 29
+        .cfi_restore 30
+        .cfi_def_cfa 31, 0
+        ret
+        .cfi_endproc
+#else
+.LFB7169:
+    # WARNING - presersing x11
+    #         - replacing x29 with sp
+    #         - there should be no usage of x29
+        cbz     x1, .L121
+        stp     x11, x30, [sp, -48]!
+        .cfi_def_cfa_offset 48
+        .cfi_offset 11, -48
+        .cfi_offset 30, -40
+#       add     x29, sp, 0
+#       .cfi_def_cfa_register 29
+        stp     x19, x20, [sp, 16]
+        .cfi_offset 19, -32
+        .cfi_offset 20, -24
+        mov     x20, x1
+        stp     x21, x22, [sp, 32]
+        .cfi_offset 21, -16
+        .cfi_offset 22, -8
+        mov     x19, 0
+        mov     x22, x0
+        mov     x21, x2
+        b       .L118
+        .p2align 3
+.L113:
+        add     x19, x19, 1
+        cmp     x20, x19
+        beq     .L122
+.L118:
+        cmp     x21, x19
+        beq     .L113
+        ldr     x0, [x22, x19, lsl 3]
+        cbz     x0, .L113
+        bl      MCC_DecRef_NaiveRCFast
+        add     x19, x19, 1
+        cmp     x20, x19
+        bne     .L118
+.L122:
+        ldp     x19, x20, [sp, 16]
+        ldp     x21, x22, [sp, 32]
+        ldp     x11, x30, [sp], 48
+        .cfi_restore 30
+        .cfi_restore 11
+        .cfi_restore 21
+        .cfi_restore 22
+        .cfi_restore 19
+        .cfi_restore 20
+        .cfi_def_cfa 31, 0
+        ret
+.L121:
+        ret
+        .cfi_endproc
+.LFE7169:
+#endif
+        .size   MCC_CleanupLocalStackRefSkip_NaiveRCFast, .-MCC_CleanupLocalStackRefSkip_NaiveRCFast
+
+        .text
+        .align  2
+        .p2align 3,,7
+        .local MCC_DecRef_NaiveRCFast
+        .type   MCC_DecRef_NaiveRCFast, %function
+MCC_DecRef_NaiveRCFast:
+        .cfi_startproc
+        adrp    x1, gcIsGCOnly
+        ldr     x1, [x1, :lo12:gcIsGCOnly]
+        cbz     x1, .L_RC_DEC_REF
+        ret
+.L_RC_DEC_REF:
+#if CONFIG_JSAN
+        stp     x29, x30, [sp, -32]!
+        .cfi_def_cfa_offset 32
+        .cfi_offset 29, -32
+        .cfi_offset 30, -24
+        mov     x29, sp
+        str     x11, [x29, 16]
+        .cfi_offset 11, -16
+        bl      MRT_DecRef
+        ldr     x11, [x29, 16]
+        ldp     x29, x30, [sp], 32
+        .cfi_restore 11
+        .cfi_restore 29
+        .cfi_restore 30
+        .cfi_def_cfa 31, 0
+        ret
+        .cfi_endproc
+#else
+.LFB7179:
+        sub     x1, x0, #16, lsl #12    // x1 = x0 - 65536
+        mov     w2, #2147418111         // x2 = 2^31 - 65537
+        cmp     x1, x2                  // if (x1 >= x2)
+        bhi     .L76                    //   goto .L76
+        ldr     w2, [x0, -8]
+        tbnz    w2, #31, .L79
+        sub     x1, x0, #4
+.L91:
+        ldxr    w2, [x1]
+        tbnz    w2, #RC_BITS_MSB_INDEX, .L76
+        sub     w3, w2, #1
+        orr     w3, w3, #RC_CYCLE_COLOR_BROWN
+        // start check if weak collected bit can set
+        // 1. weak collected bit not set
+        tbnz     w3, #WEAK_COLLECTED_INDEX, .L95
+        // 2. newHeader's weak rc > 1
+        and     w4, w3, WEAK_RC_BITS_MASK
+        cmp     w4, WEAK_RC_ONE
+        ble .L95
+        // 3. newHeader's strong and resurrect rc is zero
+        and     w4, w3, RESURRECT_STRONG_MASK
+        cbnz    w4, .L95
+        // 4. set weak collected bit
+        orr w3, w3, #WEAK_COLLECT
+        // end weak collected bit check
+.L95:
+        stxr    w4, w3, [x1]
+        cbnz    w4, .L91
+        // old rcheader in w2 and new rcheader in w3
+        // as imm is too long, split release operation
+        // check strong rc first if old strong rc is 1, if not return
+        and     w1, w2, STRONG_RC_BITS_MASK
+        cmp     w1, 1
+        bne .L94
+        // check if release object
+        and w1, w3, RC_COLOR_CLEAR_MASK
+        cmp w1, WEAK_RC_ONE
+        beq     .L92
+        eor w1, w1, #WEAK_COLLECT
+        cbz w1, .L92
+        // check if weak collected
+        tbz     w3, #WEAK_COLLECTED_INDEX, .L94
+        tbz     w2, #WEAK_COLLECTED_INDEX, .L93
+.L94:
+#if ENABLE_ASSERT_RC_NZ
+  and   w1, w2, STRONG_RC_BITS_MASK
+        cbz     w1, .L309
+#endif
+.L76:
+        ret
+        .p2align 3
+.L79:
+        b       MRT_DecRef
+.L309:
+        stp     x29, x30, [sp, -16]!
+        .cfi_def_cfa_offset 16
+        .cfi_offset 29, -16
+        .cfi_offset 30, -8
+        add     x29, sp, 0
+        .cfi_def_cfa_register 29
+        bl      MRT_BuiltinAbortSaferegister
+        .p2align 3
+.L93:
+        .cfi_def_cfa 31, 0
+        .cfi_restore 29
+        .cfi_restore 30
+        b       MRT_CollectWeakObj
+.L92:
+        .cfi_def_cfa 31, 0
+        .cfi_restore 29
+        .cfi_restore 30
+        b       MRT_ReleaseObj
+        .cfi_endproc
+.LFE7179:
+#endif
+        .size   MCC_DecRef_NaiveRCFast, .-MCC_DecRef_NaiveRCFast
+        .text
+        .align  2
+        .p2align 3,,7
+        .local MCC_IncDecRef_NaiveRCFast
+        .type   MCC_IncDecRef_NaiveRCFast, %function
+MCC_IncDecRef_NaiveRCFast:
+        .cfi_startproc
+        adrp    x2, gcIsGCOnly
+        ldr     x2, [x2, :lo12:gcIsGCOnly]
+        cbz     x2, .L_RC_INC_DEC
+        ret
+.L_RC_INC_DEC:
+#if CONFIG_JSAN
+        stp     x29, x30, [sp, -32]!
+        .cfi_def_cfa_offset 32
+        .cfi_offset 29, -32
+        .cfi_offset 30, -24
+        mov     x29, sp
+        str     x11, [x29, 16]
+        .cfi_offset 11, -16
+        bl      MRT_IncDecRef
+        ldr     x11, [x29, 16]
+        ldp     x29, x30, [sp], 32
+        .cfi_restore 11
+        .cfi_restore 29
+        .cfi_restore 30
+        .cfi_def_cfa 31, 0
+        ret
+        .cfi_endproc
+#else
+.LFB7170:
+    # WARNING - presersing x11
+    #         - replacing x29 with sp
+    #         - there should be no usage of x29
+        cmp     x0, x1
+        beq     .L142
+        stp     x11, x30, [sp, -32]!
+        .cfi_def_cfa_offset 32
+        .cfi_offset 11, -32
+        .cfi_offset 30, -24
+        mov     x2, x0
+        mov     x0, x1
+        mov     w7, #2147418111         // x7 = 2^31 - 65537
+        sub     x6, x2, #16, lsl #12    // x6 = x2 - 65536
+        cmp     x6, x7                  // if (x6 < x7)
+        bls     .L123                   //   goto .L123
+        .p2align 2
+.L130:
+        sub     x6, x0, #16, lsl #12    // x6 = x0 - 65536
+        cmp     x6, x7                  // if (x6 >= x7)
+        bhi     .L107                   //   goto .L107
+        ldr     w1, [x0, -8]
+        tbnz    w1, #31, .L114
+        sub     x2, x0, #4
+.L119:
+        ldxr    w1, [x2]
+        tbnz    w1, #RC_BITS_MSB_INDEX, .L107
+        sub     w3, w1, #1
+        orr     w3, w3, #RC_CYCLE_COLOR_BROWN
+        // start check if weak collected bit can set
+        // 1. weak collected bit not set
+        tbnz    w3, #WEAK_COLLECTED_INDEX, .L128
+        // 2. newHeader's weak rc > 1
+        and     w4, w3, WEAK_RC_BITS_MASK
+        cmp     w4, WEAK_RC_ONE
+        ble .L128
+        // 3. newHeader's strong and resurrect rc is zero
+        and     w4, w3, RESURRECT_STRONG_MASK
+        cbnz    w4, .L128
+        // 4. set weak collected bit
+        orr w3, w3, #WEAK_COLLECT
+        // end weak collected bit check
+.L128:
+        stxr    w4, w3, [x2]
+        cbnz    w4, .L119
+        // old rcheader in w1 and new rcheader in w3
+  // as imm is too long, split release operation
+  // check strong rc first if old strong rc is 1, if not return
+        and     w4, w1, STRONG_RC_BITS_MASK
+        cmp     w4, 1
+        bne .L127
+  // check if release object
+        and w4, w3, RC_COLOR_CLEAR_MASK
+        cmp w4, WEAK_RC_ONE
+        beq     .L124
+        eor w4, w4, #WEAK_COLLECT
+        cbz w4, .L124
+        // check if weak collected
+        tbz     w3, #WEAK_COLLECTED_INDEX, .L127
+        tbz     w1, #WEAK_COLLECTED_INDEX, .L126
+.L127:
+#if ENABLE_ASSERT_RC_NZ
+  and   w1, w1, STRONG_RC_BITS_MASK  // check old strong is not zero
+        cbz     w1, .L343
+#endif
+.L107:
+        ldp     x11, x30, [sp], 32
+        .cfi_remember_state
+        .cfi_restore 30
+        .cfi_restore 11
+        .cfi_def_cfa 31, 0
+        ret
+.L114:
+        .cfi_restore_state
+        bl      MRT_DecRef
+        ldp     x11, x30, [sp], 32
+        .cfi_remember_state
+        .cfi_restore 11
+        .cfi_restore 30
+        .cfi_def_cfa 31, 0
+        ret
+.L123:
+        .cfi_restore_state
+        add     x5, sp, 32
+        sub     x3, x2, #4
+        str     wzr, [x5, -4]!
+        .p2align 2
+.L112:
+        ldar    w1, [x3]
+        tbnz    w1, #RC_BITS_MSB_INDEX, .L130
+        and     w2, w1, RC_COLOR_CLEAR_MASK
+        add     w2, w2, 1
+        str     w1, [sp, 28]
+        ldaxr   w4, [x3]
+        cmp     w4, w1
+        bne     .L140
+        stlxr   w8, w2, [x3]
+        cmp     w8, 0
+.L140:
+        bne     .L125
+        ldr     w1, [sp, 28]
+        tst     x1, STRONG_RC_BITS_MASK
+        bne     .L130
+.L343:
+        bl     MRT_BuiltinAbortSaferegister
+        .p2align 3
+.L125:
+        str     w4, [x5]
+        b       .L112
+.L142:
+        .cfi_def_cfa 31, 0
+        .cfi_restore 11
+        .cfi_restore 30
+        ret
+.L124:
+        .cfi_def_cfa 29, 32
+        .cfi_offset 11, -32
+        .cfi_offset 30, -24
+        bl      MRT_ReleaseObj
+        ldp     x11, x30, [sp], 32
+        .cfi_restore 11
+        .cfi_restore 30
+        .cfi_def_cfa 31, 0
+        ret
+.L126:
+        .cfi_def_cfa 29, 32
+        .cfi_offset 11, -32
+        .cfi_offset 30, -24
+        bl      MRT_CollectWeakObj
+        ldp     x11, x30, [sp], 32
+        .cfi_restore 11
+        .cfi_restore 30
+        .cfi_def_cfa 31, 0
+        ret
+        .cfi_endproc
+.LFE7170:
+#endif // CONFIG_JSAN
+        .size   MCC_IncDecRef_NaiveRCFast, .-MCC_IncDecRef_NaiveRCFast
+
+.section .data.maple.gcInfo,"aw",%progbits
+    .type   gcIsGCOnly, @object
+    .p2align 3
+    .local gcIsGCOnly
+gcIsGCOnly:
+    .quad   0
+    .quad   0x4d634734  // maigc
+    .size   gcIsGCOnly,.-gcIsGCOnly
+// Add global symbol REF_gcIsGCOnly for indirect reference to gcIsGCOnly.
+// Add this indirect because of lld relocation limitation
+    .type   REF_gcIsGCOnly, @object
+    .p2align 3
+    .global REF_gcIsGCOnly
+REF_gcIsGCOnly:
+    .quad   gcIsGCOnly - .
+    .size   REF_gcIsGCOnly,.-REF_gcIsGCOnly
+#endif // !DISABLE_RC_DUPLICATE
+#endif
diff --git a/src/mrt/compiler-rt/src/arch/arm64/i2r_stub_arm64.S b/src/mrt/compiler-rt/src/arch/arm64/i2r_stub_arm64.S
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/mrt/compiler-rt/src/arch/arm64/interp_native_method_stub_arm64.S b/src/mrt/compiler-rt/src/arch/arm64/interp_native_method_stub_arm64.S
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/mrt/compiler-rt/src/arch/arm64/memset.S b/src/mrt/compiler-rt/src/arch/arm64/memset.S
new file mode 100644
index 0000000000000000000000000000000000000000..a5748d9fa8f2346903de42bae3b6abfeb7efd88e
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/memset.S
@@ -0,0 +1,114 @@
+// this file implements memset or similar functionalities
+
+        .text
+        .align 2
+        .global ROSAllocZero
+        .hidden ROSAllocZero         // remove plt within so
+        .type ROSAllocZero, %function
+ROSAllocZero:
+        .cfi_startproc
+
+// this works on sizes >= 8, since rosalloc doesn't need any size
+// smaller than that
+
+// based on profiling, the most frequent size should be [16, 32],
+// followed by (32, 96], followed by the others, i.e., [8, 16) and (96, +inf);
+// notice that size [8, 16) is not frequent at all
+
+// x0: dst, x1: size, x2: dstend, x3: dstmid
+
+        dup     v0.16B, wzr
+        add     x2, x0, x1
+        cmp     x1, 32
+        b.hi    .Lhi32
+        cmp     x1, 16
+        b.lo    .Llo16
+
+        str     q0, [x0]
+        str     q0, [x2, -16]
+        ret
+
+.Lhi32: // size > 32
+        stp     q0, q0, [x0]         // head 32
+        stp     q0, q0, [x2, -32]    // tail 32
+        cmp     x1, 256
+        b.hs    .Lhs256 // optimisation for pages?
+        add     x3, x0, x1, lsr #1
+        stp     q0, q0, [x3, -16]    // mid 32
+        cmp     x1, 96
+        b.hi    .Lhi96
+        ret
+
+.Lhi96: // size > 96
+        // stp     q0, q0, [x0]      // head 32, done in .Lhi32
+        stp     q0, q0, [x0, 32]
+        stp     q0, q0, [x0, 64]
+        stp     q0, q0, [x3, -48]
+        // stp     q0, q0, [x3, -16] // mid 32, done in .Lhi32
+        stp     q0, q0, [x3, 16]
+        stp     q0, q0, [x2, -96]
+        stp     q0, q0, [x2, -64]
+        // stp     q0, q0, [x2, -32] // tail 32, done in .Lhi32
+        ret
+
+.Llo16: // size < 16
+        str     xzr, [x0]
+        str     xzr, [x2, -8]
+        ret
+
+.Lhs256: // size >= 256
+        mrs     x4, dczid_el0
+        tbnz    w4, 4, .Lnozva
+        and     w4, w4, 15
+        cmp     w4, 4
+        b.ne    .Lzva128
+
+.Lzva64:
+        // stp     q0, q0, [x0]      // head 32, done in .Lhi32
+        stp     q0, q0, [x0, 32]
+        bic     x0, x0, 63
+        sub     x5, x2, 128
+1:
+        add     x0, x0, 64
+        dc      zva, x0
+        cmp     x5, x0
+        b.hi    1b
+        stp     q0, q0, [x2, -64]
+        // stp     q0, q0, [x2, -32] // tail 32, done in .Lhi32
+        ret
+
+.Lzva128:
+        cmp     w4, 5
+        b.ne    .Lnozva
+
+        // stp     q0, q0, [x0]      // head 32, done in .Lhi32
+        stp     q0, q0, [x0, 32]
+        stp     q0, q0, [x0, 64]
+        stp     q0, q0, [x0, 96]
+        bic     x0, x0, 127
+        sub     x5, x2, 128
+        sub     x5, x5, 128
+1:
+        add     x0, x0, 128
+        dc      zva, x0
+        cmp     x5, x0
+        b.hi    1b
+        stp     q0, q0, [x2, -128]
+        stp     q0, q0, [x2, -96]
+        stp     q0, q0, [x2, -64]
+        // stp     q0, q0, [x2, -32] // tail 32, done in .Lhi32
+        ret
+
+.Lnozva:
+        // stp     q0, q0, [x0]      // head 32, done in .Lhi32
+        sub     x5, x2, 64
+1:
+        add     x0, x0, 32
+        stp     q0, q0, [x0]
+        cmp     x5, x0
+        b.hi    1b
+        // stp     q0, q0, [x2, -32] // tail 32, done in .Lhi32
+        ret
+
+        .cfi_endproc
+        .size ROSAllocZero, .-ROSAllocZero
diff --git a/src/mrt/compiler-rt/src/arch/arm64/prepare_args_for_exception_catcher_arm64.S b/src/mrt/compiler-rt/src/arch/arm64/prepare_args_for_exception_catcher_arm64.S
new file mode 100644
index 0000000000000000000000000000000000000000..20dd113ad7ea022fb37f34113401d794009d1d79
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/prepare_args_for_exception_catcher_arm64.S
@@ -0,0 +1,38 @@
+#define SavedRegisterSize (8 * 2)
+#define PrepareArgsStructSize (8 * 4)
+
+        .text
+        .align 2
+        .global PrepareArgsForExceptionCatcher
+        .hidden PrepareArgsForExceptionCatcher
+        .type PrepareArgsForExceptionCatcher, %function
+PrepareArgsForExceptionCatcher:
+        .cfi_startproc
+        stp x29, x30, [sp, #-SavedRegisterSize]!
+        .cfi_adjust_cfa_offset SavedRegisterSize
+        .cfi_rel_offset x29, 0
+        .cfi_rel_offset x30, 8
+
+        // fp points to caller fp
+        mov x29, sp
+        .cfi_def_cfa_register x29
+
+        sub sp, sp, #PrepareArgsStructSize
+
+        mov x0, sp
+        bl MRT_GetHandlerCatcherArgs
+
+        ldr x0, [sp]
+        ldr x1, [sp, #16]
+        str x1, [x29, #8]
+        ldr x1, [sp, #8]
+
+        mov sp, x29
+        .cfi_def_cfa_register sp
+        ldp x29, x30, [sp], #SavedRegisterSize
+        .cfi_adjust_cfa_offset -SavedRegisterSize
+        .cfi_restore x29
+        .cfi_restore x30
+        ret
+        .cfi_endproc
+        .size PrepareArgsForExceptionCatcher, .-PrepareArgsForExceptionCatcher
diff --git a/src/mrt/compiler-rt/src/arch/arm64/proxy_stub_arm64.S b/src/mrt/compiler-rt/src/arch/arm64/proxy_stub_arm64.S
new file mode 100644
index 0000000000000000000000000000000000000000..c4149e8c0c964dc602802053b29ff679d8193246
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/proxy_stub_arm64.S
@@ -0,0 +1,853 @@
+// ProxyStubXX used by proxy method entrypoint, the func address fill in vtab/itab for proxy class.
+// this stub builds a stub frame, copy caller arguments to stack frame
+// and we can restructure arguments according to MethodMeta
+// On execution of "bl StubFuncwithReturnTypeArm32", the top frame layout of stack(growing downwards) looks like:
+// r0~r3: hold the first 4 possible arguments arg0~arg3 if existed
+// lr: return address of "bl ProxyStubXX"
+// all on-stack arguments are addressable by SP as the frame layout shows.
+//                 |  ...        |
+//                 |  lr(r14)    | lr for the caller of ProxyStubXX
+// caller fp  -->  |  fp(r11)    |
+//                 |  ...        |
+//                 | arg7        |
+//                 | arg6        |
+//                 | arg5        |
+// caller sp  -->  | arg4        |
+
+// the frame layout of stack(growing downwards) after ProxyStubXX frame is built looks like:
+//                 |  ...        |
+//                 |  lr(r14)    | lr for the caller of ProxyStubXX
+// caller fp  -->  |  fp(r11)    |
+//                 |  ...        |
+//                 | arg7        |
+//                 | arg6        |
+//                 | arg5        |
+// caller sp  -->  | arg4        |
+//                 | caller lr   | <== ProxyStubXX frame starts from here
+//   stub fp  -->  | caller fp   | fp for the caller of ProxyStubXX
+// callee saved    | r28         |
+//                 | r27         |
+//                 | r26         |
+//                 | r25         |
+//                 | r24         |
+//                 | r23         |
+//                 | r22         |
+//                 | r21         |
+//                 | r20         |
+// callee saved    | r19         |
+//                 | ...         |
+//                 | arg7        |
+//                 | arg6        |
+//                 | arg5        |
+//                 | arg4        |
+//                 | d7          |
+//                 | ...         |
+//                 | d0          |
+//                 | x7          |
+//                 | ...         |
+//   stub sp  -->  | x0          | <== ProxyStubXX frame ends at here
+#define cfi_adjust_cfa_offset(off)      .cfi_adjust_cfa_offset off
+#define cfi_rel_offset(reg, off)        .cfi_rel_offset reg, off
+#define cfi_restore(reg)                .cfi_restore reg
+#define cfi_def_cfa_register(reg)       .cfi_def_cfa_register reg
+
+#define StubFrameSize      (8 * 18)
+#define StubCalleeSaveArea (8 * 8)
+        .text
+        .align 2
+        .global MCC_DeferredInvoke
+        .type MCC_DeferredInvoke , %function
+MCC_DeferredInvoke:
+        .cfi_startproc
+        stp  x29, x30, [sp,  #-StubFrameSize]!
+        cfi_adjust_cfa_offset (StubFrameSize)
+        cfi_rel_offset (x29, 0)
+        cfi_rel_offset (x30, 8)
+
+        // save all used callee-saved registers.
+        stp  x19, x20, [sp, #StubCalleeSaveArea]
+        cfi_rel_offset (x19, StubCalleeSaveArea)
+        cfi_rel_offset (x20, StubCalleeSaveArea+8)
+
+        stp  x21, x22, [sp, #StubCalleeSaveArea+0x10]
+        cfi_rel_offset (x21, StubCalleeSaveArea+0x10)
+        cfi_rel_offset (x22, StubCalleeSaveArea+0x18)
+
+        stp  x23, x24, [sp, #StubCalleeSaveArea+0x20]
+        cfi_rel_offset (x23, StubCalleeSaveArea+0x20)
+        cfi_rel_offset (x24, StubCalleeSaveArea+0x28)
+
+        stp  x25, x26, [sp, #StubCalleeSaveArea+0x30]
+        cfi_rel_offset (x25, StubCalleeSaveArea+0x30)
+        cfi_rel_offset (x26, StubCalleeSaveArea+0x38)
+
+        stp  x27, x28, [sp, #StubCalleeSaveArea+0x40]
+        cfi_rel_offset (x27, StubCalleeSaveArea+0x40)
+        cfi_rel_offset (x28, StubCalleeSaveArea+0x48)
+
+        // back up caller sp and fp for copying caller's outgoing arguments
+        mov  x19, x29
+        add  x20, sp, #StubFrameSize
+
+        mov  x29, sp
+        cfi_def_cfa_register (x29)
+
+        // buffer for caller's arguments.
+        sub x21, x19, x20
+        add x21, x21, #(8 + 8) * 8 // size for arguments register
+        sub sp, sp, x21
+        mov x21, sp
+
+        stp x0, x1, [x21], #16
+        stp x2, x3, [x21], #16
+        stp x4, x5, [x21], #16
+        stp x6, x7, [x21], #16
+
+        stp d0, d1, [x21], #16
+        stp d2, d3, [x21], #16
+        stp d4, d5, [x21], #16
+        stp d6, d7, [x21], #16
+
+        // copy on-stack arguments if existed
+.LCopy:
+        cmp x20, x19
+        bge .LCopyEnd
+        ldp x4, x5, [x20], #16
+        stp x4, x5, [x21], #16
+        b .LCopy
+.LCopyEnd:
+
+        mov x0, sp
+        bl EnterDeferredInvoke
+        /* set potential return value, float/double save in x0 */
+        fmov d0, x0
+
+        mov  sp, x29
+        cfi_def_cfa_register (sp)
+
+        // restore all used callee-saved registers.
+        ldp  x19, x20, [sp, #StubCalleeSaveArea]
+        cfi_restore (x19)
+        cfi_restore (x20)
+        ldp  x21, x22, [sp, #StubCalleeSaveArea+0x10]
+        cfi_restore (x21)
+        cfi_restore (x22)
+        ldp  x23, x24, [sp, #StubCalleeSaveArea+0x20]
+        cfi_restore (x23)
+        cfi_restore (x24)
+        ldp  x25, x26, [sp, #StubCalleeSaveArea+0x30]
+        cfi_restore (x25)
+        cfi_restore (x26)
+        ldp  x27, x28, [sp, #StubCalleeSaveArea+0x40]
+        cfi_restore (x27)
+        cfi_restore (x28)
+
+        ldp     x29, x30, [sp], #StubFrameSize
+        cfi_adjust_cfa_offset (-StubFrameSize)
+        cfi_restore (x29)
+        cfi_restore (x30)
+        ret
+        .cfi_endproc
+        .size MCC_DeferredInvoke, .-MCC_DeferredInvoke
+
+.macro PROXYFUNCENTER, funcName, number
+        .text
+        .align 2
+        .global \funcName\number
+        .hidden \funcName\number
+        .type \funcName\number , %function
+\funcName\number:
+        .cfi_startproc
+        stp  x29, x30, [sp,  #-StubFrameSize]!
+        cfi_adjust_cfa_offset (StubFrameSize)
+        cfi_rel_offset (x29, 0)
+        cfi_rel_offset (x30, 8)
+
+        // save all used callee-saved registers.
+        stp  x19, x20, [sp, #StubCalleeSaveArea]
+        cfi_rel_offset (x19, StubCalleeSaveArea)
+        cfi_rel_offset (x20, StubCalleeSaveArea+8)
+
+        stp  x21, x22, [sp, #StubCalleeSaveArea+0x10]
+        cfi_rel_offset (x21, StubCalleeSaveArea+0x10)
+        cfi_rel_offset (x22, StubCalleeSaveArea+0x18)
+
+        stp  x23, x24, [sp, #StubCalleeSaveArea+0x20]
+        cfi_rel_offset (x23, StubCalleeSaveArea+0x20)
+        cfi_rel_offset (x24, StubCalleeSaveArea+0x28)
+
+        stp  x25, x26, [sp, #StubCalleeSaveArea+0x30]
+        cfi_rel_offset (x25, StubCalleeSaveArea+0x30)
+        cfi_rel_offset (x26, StubCalleeSaveArea+0x38)
+
+        stp  x27, x28, [sp, #StubCalleeSaveArea+0x40]
+        cfi_rel_offset (x27, StubCalleeSaveArea+0x40)
+        cfi_rel_offset (x28, StubCalleeSaveArea+0x48)
+
+        // back up caller sp and fp for copying caller's outgoing arguments
+        mov  x19, x29
+        add  x20, sp, #StubFrameSize
+
+        mov  x29, sp
+        cfi_def_cfa_register (x29)
+
+        // buffer for caller's arguments.
+        sub x21, x19, x20
+        add x21, x21, #(8 + 8) * 8 // size for arguments register
+        sub sp, sp, x21
+        mov x21, sp
+
+        stp x0, x1, [x21], #16
+        stp x2, x3, [x21], #16
+        stp x4, x5, [x21], #16
+        stp x6, x7, [x21], #16
+
+        stp d0, d1, [x21], #16
+        stp d2, d3, [x21], #16
+        stp d4, d5, [x21], #16
+        stp d6, d7, [x21], #16
+
+        // copy on-stack arguments if existed
+.L_copy\number:
+        cmp x20, x19
+        bge .L_copy_end\number
+        ldp x4, x5, [x20], #16
+        stp x4, x5, [x21], #16
+        b .L_copy\number
+.L_copy_end\number:
+
+        mov x0, sp
+        mov x1, #\number
+        bl EnterProxyMethodInvoke
+        /* set potential return value, float/double save in x0 */
+        fmov d0, x0
+
+        mov  sp, x29
+        cfi_def_cfa_register (sp)
+
+        // restore all used callee-saved registers.
+        ldp  x19, x20, [sp, #StubCalleeSaveArea]
+        cfi_restore (x19)
+        cfi_restore (x20)
+        ldp  x21, x22, [sp, #StubCalleeSaveArea+0x10]
+        cfi_restore (x21)
+        cfi_restore (x22)
+        ldp  x23, x24, [sp, #StubCalleeSaveArea+0x20]
+        cfi_restore (x23)
+        cfi_restore (x24)
+        ldp  x25, x26, [sp, #StubCalleeSaveArea+0x30]
+        cfi_restore (x25)
+        cfi_restore (x26)
+        ldp  x27, x28, [sp, #StubCalleeSaveArea+0x40]
+        cfi_restore (x27)
+        cfi_restore (x28)
+
+        ldp     x29, x30, [sp], #StubFrameSize
+        cfi_adjust_cfa_offset (-StubFrameSize)
+        cfi_restore (x29)
+        cfi_restore (x30)
+        ret
+        .cfi_endproc
+        .size \funcName\number, .-\funcName\number
+        .endm
+
+PROXYFUNCENTER sfp_jlong_, 0
+PROXYFUNCENTER sfp_jlong_, 1
+PROXYFUNCENTER sfp_jlong_, 2
+PROXYFUNCENTER sfp_jlong_, 3
+PROXYFUNCENTER sfp_jlong_, 4
+PROXYFUNCENTER sfp_jlong_, 5
+PROXYFUNCENTER sfp_jlong_, 6
+PROXYFUNCENTER sfp_jlong_, 7
+PROXYFUNCENTER sfp_jlong_, 8
+PROXYFUNCENTER sfp_jlong_, 9
+PROXYFUNCENTER sfp_jlong_, 10
+PROXYFUNCENTER sfp_jlong_, 11
+PROXYFUNCENTER sfp_jlong_, 12
+PROXYFUNCENTER sfp_jlong_, 13
+PROXYFUNCENTER sfp_jlong_, 14
+PROXYFUNCENTER sfp_jlong_, 15
+PROXYFUNCENTER sfp_jlong_, 16
+PROXYFUNCENTER sfp_jlong_, 17
+PROXYFUNCENTER sfp_jlong_, 18
+PROXYFUNCENTER sfp_jlong_, 19
+PROXYFUNCENTER sfp_jlong_, 20
+PROXYFUNCENTER sfp_jlong_, 21
+PROXYFUNCENTER sfp_jlong_, 22
+PROXYFUNCENTER sfp_jlong_, 23
+PROXYFUNCENTER sfp_jlong_, 24
+PROXYFUNCENTER sfp_jlong_, 25
+PROXYFUNCENTER sfp_jlong_, 26
+PROXYFUNCENTER sfp_jlong_, 27
+PROXYFUNCENTER sfp_jlong_, 28
+PROXYFUNCENTER sfp_jlong_, 29
+PROXYFUNCENTER sfp_jlong_, 30
+PROXYFUNCENTER sfp_jlong_, 31
+PROXYFUNCENTER sfp_jlong_, 32
+PROXYFUNCENTER sfp_jlong_, 33
+PROXYFUNCENTER sfp_jlong_, 34
+PROXYFUNCENTER sfp_jlong_, 35
+PROXYFUNCENTER sfp_jlong_, 36
+PROXYFUNCENTER sfp_jlong_, 37
+PROXYFUNCENTER sfp_jlong_, 38
+PROXYFUNCENTER sfp_jlong_, 39
+PROXYFUNCENTER sfp_jlong_, 40
+PROXYFUNCENTER sfp_jlong_, 41
+PROXYFUNCENTER sfp_jlong_, 42
+PROXYFUNCENTER sfp_jlong_, 43
+PROXYFUNCENTER sfp_jlong_, 44
+PROXYFUNCENTER sfp_jlong_, 45
+PROXYFUNCENTER sfp_jlong_, 46
+PROXYFUNCENTER sfp_jlong_, 47
+PROXYFUNCENTER sfp_jlong_, 48
+PROXYFUNCENTER sfp_jlong_, 49
+PROXYFUNCENTER sfp_jlong_, 50
+PROXYFUNCENTER sfp_jlong_, 51
+PROXYFUNCENTER sfp_jlong_, 52
+PROXYFUNCENTER sfp_jlong_, 53
+PROXYFUNCENTER sfp_jlong_, 54
+PROXYFUNCENTER sfp_jlong_, 55
+PROXYFUNCENTER sfp_jlong_, 56
+PROXYFUNCENTER sfp_jlong_, 57
+PROXYFUNCENTER sfp_jlong_, 58
+PROXYFUNCENTER sfp_jlong_, 59
+PROXYFUNCENTER sfp_jlong_, 60
+PROXYFUNCENTER sfp_jlong_, 61
+PROXYFUNCENTER sfp_jlong_, 62
+PROXYFUNCENTER sfp_jlong_, 63
+PROXYFUNCENTER sfp_jlong_, 64
+PROXYFUNCENTER sfp_jlong_, 65
+PROXYFUNCENTER sfp_jlong_, 66
+PROXYFUNCENTER sfp_jlong_, 67
+PROXYFUNCENTER sfp_jlong_, 68
+PROXYFUNCENTER sfp_jlong_, 69
+PROXYFUNCENTER sfp_jlong_, 70
+PROXYFUNCENTER sfp_jlong_, 71
+PROXYFUNCENTER sfp_jlong_, 72
+PROXYFUNCENTER sfp_jlong_, 73
+PROXYFUNCENTER sfp_jlong_, 74
+PROXYFUNCENTER sfp_jlong_, 75
+PROXYFUNCENTER sfp_jlong_, 76
+PROXYFUNCENTER sfp_jlong_, 77
+PROXYFUNCENTER sfp_jlong_, 78
+PROXYFUNCENTER sfp_jlong_, 79
+PROXYFUNCENTER sfp_jlong_, 80
+PROXYFUNCENTER sfp_jlong_, 81
+PROXYFUNCENTER sfp_jlong_, 82
+PROXYFUNCENTER sfp_jlong_, 83
+PROXYFUNCENTER sfp_jlong_, 84
+PROXYFUNCENTER sfp_jlong_, 85
+PROXYFUNCENTER sfp_jlong_, 86
+PROXYFUNCENTER sfp_jlong_, 87
+PROXYFUNCENTER sfp_jlong_, 88
+PROXYFUNCENTER sfp_jlong_, 89
+PROXYFUNCENTER sfp_jlong_, 90
+PROXYFUNCENTER sfp_jlong_, 91
+PROXYFUNCENTER sfp_jlong_, 92
+PROXYFUNCENTER sfp_jlong_, 93
+PROXYFUNCENTER sfp_jlong_, 94
+PROXYFUNCENTER sfp_jlong_, 95
+PROXYFUNCENTER sfp_jlong_, 96
+PROXYFUNCENTER sfp_jlong_, 97
+PROXYFUNCENTER sfp_jlong_, 98
+PROXYFUNCENTER sfp_jlong_, 99
+PROXYFUNCENTER sfp_jlong_, 100
+PROXYFUNCENTER sfp_jlong_, 101
+PROXYFUNCENTER sfp_jlong_, 102
+PROXYFUNCENTER sfp_jlong_, 103
+PROXYFUNCENTER sfp_jlong_, 104
+PROXYFUNCENTER sfp_jlong_, 105
+PROXYFUNCENTER sfp_jlong_, 106
+PROXYFUNCENTER sfp_jlong_, 107
+PROXYFUNCENTER sfp_jlong_, 108
+PROXYFUNCENTER sfp_jlong_, 109
+PROXYFUNCENTER sfp_jlong_, 110
+PROXYFUNCENTER sfp_jlong_, 111
+PROXYFUNCENTER sfp_jlong_, 112
+PROXYFUNCENTER sfp_jlong_, 113
+PROXYFUNCENTER sfp_jlong_, 114
+PROXYFUNCENTER sfp_jlong_, 115
+PROXYFUNCENTER sfp_jlong_, 116
+PROXYFUNCENTER sfp_jlong_, 117
+PROXYFUNCENTER sfp_jlong_, 118
+PROXYFUNCENTER sfp_jlong_, 119
+PROXYFUNCENTER sfp_jlong_, 120
+PROXYFUNCENTER sfp_jlong_, 121
+PROXYFUNCENTER sfp_jlong_, 122
+PROXYFUNCENTER sfp_jlong_, 123
+PROXYFUNCENTER sfp_jlong_, 124
+PROXYFUNCENTER sfp_jlong_, 125
+PROXYFUNCENTER sfp_jlong_, 126
+PROXYFUNCENTER sfp_jlong_, 127
+PROXYFUNCENTER sfp_jlong_, 128
+PROXYFUNCENTER sfp_jlong_, 129
+PROXYFUNCENTER sfp_jlong_, 130
+PROXYFUNCENTER sfp_jlong_, 131
+PROXYFUNCENTER sfp_jlong_, 132
+PROXYFUNCENTER sfp_jlong_, 133
+PROXYFUNCENTER sfp_jlong_, 134
+PROXYFUNCENTER sfp_jlong_, 135
+PROXYFUNCENTER sfp_jlong_, 136
+PROXYFUNCENTER sfp_jlong_, 137
+PROXYFUNCENTER sfp_jlong_, 138
+PROXYFUNCENTER sfp_jlong_, 139
+PROXYFUNCENTER sfp_jlong_, 140
+PROXYFUNCENTER sfp_jlong_, 141
+PROXYFUNCENTER sfp_jlong_, 142
+PROXYFUNCENTER sfp_jlong_, 143
+PROXYFUNCENTER sfp_jlong_, 144
+PROXYFUNCENTER sfp_jlong_, 145
+PROXYFUNCENTER sfp_jlong_, 146
+PROXYFUNCENTER sfp_jlong_, 147
+PROXYFUNCENTER sfp_jlong_, 148
+PROXYFUNCENTER sfp_jlong_, 149
+PROXYFUNCENTER sfp_jlong_, 150
+PROXYFUNCENTER sfp_jlong_, 151
+PROXYFUNCENTER sfp_jlong_, 152
+PROXYFUNCENTER sfp_jlong_, 153
+PROXYFUNCENTER sfp_jlong_, 154
+PROXYFUNCENTER sfp_jlong_, 155
+PROXYFUNCENTER sfp_jlong_, 156
+PROXYFUNCENTER sfp_jlong_, 157
+PROXYFUNCENTER sfp_jlong_, 158
+PROXYFUNCENTER sfp_jlong_, 159
+PROXYFUNCENTER sfp_jlong_, 160
+PROXYFUNCENTER sfp_jlong_, 161
+PROXYFUNCENTER sfp_jlong_, 162
+PROXYFUNCENTER sfp_jlong_, 163
+PROXYFUNCENTER sfp_jlong_, 164
+PROXYFUNCENTER sfp_jlong_, 165
+PROXYFUNCENTER sfp_jlong_, 166
+PROXYFUNCENTER sfp_jlong_, 167
+PROXYFUNCENTER sfp_jlong_, 168
+PROXYFUNCENTER sfp_jlong_, 169
+PROXYFUNCENTER sfp_jlong_, 170
+PROXYFUNCENTER sfp_jlong_, 171
+PROXYFUNCENTER sfp_jlong_, 172
+PROXYFUNCENTER sfp_jlong_, 173
+PROXYFUNCENTER sfp_jlong_, 174
+PROXYFUNCENTER sfp_jlong_, 175
+PROXYFUNCENTER sfp_jlong_, 176
+PROXYFUNCENTER sfp_jlong_, 177
+PROXYFUNCENTER sfp_jlong_, 178
+PROXYFUNCENTER sfp_jlong_, 179
+PROXYFUNCENTER sfp_jlong_, 180
+PROXYFUNCENTER sfp_jlong_, 181
+PROXYFUNCENTER sfp_jlong_, 182
+PROXYFUNCENTER sfp_jlong_, 183
+PROXYFUNCENTER sfp_jlong_, 184
+PROXYFUNCENTER sfp_jlong_, 185
+PROXYFUNCENTER sfp_jlong_, 186
+PROXYFUNCENTER sfp_jlong_, 187
+PROXYFUNCENTER sfp_jlong_, 188
+PROXYFUNCENTER sfp_jlong_, 189
+PROXYFUNCENTER sfp_jlong_, 190
+PROXYFUNCENTER sfp_jlong_, 191
+PROXYFUNCENTER sfp_jlong_, 192
+PROXYFUNCENTER sfp_jlong_, 193
+PROXYFUNCENTER sfp_jlong_, 194
+PROXYFUNCENTER sfp_jlong_, 195
+PROXYFUNCENTER sfp_jlong_, 196
+PROXYFUNCENTER sfp_jlong_, 197
+PROXYFUNCENTER sfp_jlong_, 198
+PROXYFUNCENTER sfp_jlong_, 199
+PROXYFUNCENTER sfp_jlong_, 200
+PROXYFUNCENTER sfp_jlong_, 201
+PROXYFUNCENTER sfp_jlong_, 202
+PROXYFUNCENTER sfp_jlong_, 203
+PROXYFUNCENTER sfp_jlong_, 204
+PROXYFUNCENTER sfp_jlong_, 205
+PROXYFUNCENTER sfp_jlong_, 206
+PROXYFUNCENTER sfp_jlong_, 207
+PROXYFUNCENTER sfp_jlong_, 208
+PROXYFUNCENTER sfp_jlong_, 209
+PROXYFUNCENTER sfp_jlong_, 210
+PROXYFUNCENTER sfp_jlong_, 211
+PROXYFUNCENTER sfp_jlong_, 212
+PROXYFUNCENTER sfp_jlong_, 213
+PROXYFUNCENTER sfp_jlong_, 214
+PROXYFUNCENTER sfp_jlong_, 215
+PROXYFUNCENTER sfp_jlong_, 216
+PROXYFUNCENTER sfp_jlong_, 217
+PROXYFUNCENTER sfp_jlong_, 218
+PROXYFUNCENTER sfp_jlong_, 219
+PROXYFUNCENTER sfp_jlong_, 220
+PROXYFUNCENTER sfp_jlong_, 221
+PROXYFUNCENTER sfp_jlong_, 222
+PROXYFUNCENTER sfp_jlong_, 223
+PROXYFUNCENTER sfp_jlong_, 224
+PROXYFUNCENTER sfp_jlong_, 225
+PROXYFUNCENTER sfp_jlong_, 226
+PROXYFUNCENTER sfp_jlong_, 227
+PROXYFUNCENTER sfp_jlong_, 228
+PROXYFUNCENTER sfp_jlong_, 229
+PROXYFUNCENTER sfp_jlong_, 230
+PROXYFUNCENTER sfp_jlong_, 231
+PROXYFUNCENTER sfp_jlong_, 232
+PROXYFUNCENTER sfp_jlong_, 233
+PROXYFUNCENTER sfp_jlong_, 234
+PROXYFUNCENTER sfp_jlong_, 235
+PROXYFUNCENTER sfp_jlong_, 236
+PROXYFUNCENTER sfp_jlong_, 237
+PROXYFUNCENTER sfp_jlong_, 238
+PROXYFUNCENTER sfp_jlong_, 239
+PROXYFUNCENTER sfp_jlong_, 240
+PROXYFUNCENTER sfp_jlong_, 241
+PROXYFUNCENTER sfp_jlong_, 242
+PROXYFUNCENTER sfp_jlong_, 243
+PROXYFUNCENTER sfp_jlong_, 244
+PROXYFUNCENTER sfp_jlong_, 245
+PROXYFUNCENTER sfp_jlong_, 246
+PROXYFUNCENTER sfp_jlong_, 247
+PROXYFUNCENTER sfp_jlong_, 248
+PROXYFUNCENTER sfp_jlong_, 249
+PROXYFUNCENTER sfp_jlong_, 250
+PROXYFUNCENTER sfp_jlong_, 251
+PROXYFUNCENTER sfp_jlong_, 252
+PROXYFUNCENTER sfp_jlong_, 253
+PROXYFUNCENTER sfp_jlong_, 254
+PROXYFUNCENTER sfp_jlong_, 255
+PROXYFUNCENTER sfp_jlong_, 256
+PROXYFUNCENTER sfp_jlong_, 257
+PROXYFUNCENTER sfp_jlong_, 258
+PROXYFUNCENTER sfp_jlong_, 259
+PROXYFUNCENTER sfp_jlong_, 260
+PROXYFUNCENTER sfp_jlong_, 261
+PROXYFUNCENTER sfp_jlong_, 262
+PROXYFUNCENTER sfp_jlong_, 263
+PROXYFUNCENTER sfp_jlong_, 264
+PROXYFUNCENTER sfp_jlong_, 265
+PROXYFUNCENTER sfp_jlong_, 266
+PROXYFUNCENTER sfp_jlong_, 267
+PROXYFUNCENTER sfp_jlong_, 268
+PROXYFUNCENTER sfp_jlong_, 269
+PROXYFUNCENTER sfp_jlong_, 270
+PROXYFUNCENTER sfp_jlong_, 271
+PROXYFUNCENTER sfp_jlong_, 272
+PROXYFUNCENTER sfp_jlong_, 273
+PROXYFUNCENTER sfp_jlong_, 274
+PROXYFUNCENTER sfp_jlong_, 275
+PROXYFUNCENTER sfp_jlong_, 276
+PROXYFUNCENTER sfp_jlong_, 277
+PROXYFUNCENTER sfp_jlong_, 278
+PROXYFUNCENTER sfp_jlong_, 279
+PROXYFUNCENTER sfp_jlong_, 280
+PROXYFUNCENTER sfp_jlong_, 281
+PROXYFUNCENTER sfp_jlong_, 282
+PROXYFUNCENTER sfp_jlong_, 283
+PROXYFUNCENTER sfp_jlong_, 284
+PROXYFUNCENTER sfp_jlong_, 285
+PROXYFUNCENTER sfp_jlong_, 286
+PROXYFUNCENTER sfp_jlong_, 287
+PROXYFUNCENTER sfp_jlong_, 288
+PROXYFUNCENTER sfp_jlong_, 289
+PROXYFUNCENTER sfp_jlong_, 290
+PROXYFUNCENTER sfp_jlong_, 291
+PROXYFUNCENTER sfp_jlong_, 292
+PROXYFUNCENTER sfp_jlong_, 293
+PROXYFUNCENTER sfp_jlong_, 294
+PROXYFUNCENTER sfp_jlong_, 295
+PROXYFUNCENTER sfp_jlong_, 296
+PROXYFUNCENTER sfp_jlong_, 297
+PROXYFUNCENTER sfp_jlong_, 298
+PROXYFUNCENTER sfp_jlong_, 299
+PROXYFUNCENTER sfp_jlong_, 300
+PROXYFUNCENTER sfp_jlong_, 301
+PROXYFUNCENTER sfp_jlong_, 302
+PROXYFUNCENTER sfp_jlong_, 303
+PROXYFUNCENTER sfp_jlong_, 304
+PROXYFUNCENTER sfp_jlong_, 305
+PROXYFUNCENTER sfp_jlong_, 306
+PROXYFUNCENTER sfp_jlong_, 307
+PROXYFUNCENTER sfp_jlong_, 308
+PROXYFUNCENTER sfp_jlong_, 309
+PROXYFUNCENTER sfp_jlong_, 310
+PROXYFUNCENTER sfp_jlong_, 311
+PROXYFUNCENTER sfp_jlong_, 312
+PROXYFUNCENTER sfp_jlong_, 313
+PROXYFUNCENTER sfp_jlong_, 314
+PROXYFUNCENTER sfp_jlong_, 315
+PROXYFUNCENTER sfp_jlong_, 316
+PROXYFUNCENTER sfp_jlong_, 317
+PROXYFUNCENTER sfp_jlong_, 318
+PROXYFUNCENTER sfp_jlong_, 319
+PROXYFUNCENTER sfp_jlong_, 320
+PROXYFUNCENTER sfp_jlong_, 321
+PROXYFUNCENTER sfp_jlong_, 322
+PROXYFUNCENTER sfp_jlong_, 323
+PROXYFUNCENTER sfp_jlong_, 324
+PROXYFUNCENTER sfp_jlong_, 325
+PROXYFUNCENTER sfp_jlong_, 326
+PROXYFUNCENTER sfp_jlong_, 327
+PROXYFUNCENTER sfp_jlong_, 328
+PROXYFUNCENTER sfp_jlong_, 329
+PROXYFUNCENTER sfp_jlong_, 330
+PROXYFUNCENTER sfp_jlong_, 331
+PROXYFUNCENTER sfp_jlong_, 332
+PROXYFUNCENTER sfp_jlong_, 333
+PROXYFUNCENTER sfp_jlong_, 334
+PROXYFUNCENTER sfp_jlong_, 335
+PROXYFUNCENTER sfp_jlong_, 336
+PROXYFUNCENTER sfp_jlong_, 337
+PROXYFUNCENTER sfp_jlong_, 338
+PROXYFUNCENTER sfp_jlong_, 339
+PROXYFUNCENTER sfp_jlong_, 340
+PROXYFUNCENTER sfp_jlong_, 341
+PROXYFUNCENTER sfp_jlong_, 342
+PROXYFUNCENTER sfp_jlong_, 343
+PROXYFUNCENTER sfp_jlong_, 344
+PROXYFUNCENTER sfp_jlong_, 345
+PROXYFUNCENTER sfp_jlong_, 346
+PROXYFUNCENTER sfp_jlong_, 347
+PROXYFUNCENTER sfp_jlong_, 348
+PROXYFUNCENTER sfp_jlong_, 349
+PROXYFUNCENTER sfp_jlong_, 350
+PROXYFUNCENTER sfp_jlong_, 351
+PROXYFUNCENTER sfp_jlong_, 352
+PROXYFUNCENTER sfp_jlong_, 353
+PROXYFUNCENTER sfp_jlong_, 354
+PROXYFUNCENTER sfp_jlong_, 355
+PROXYFUNCENTER sfp_jlong_, 356
+PROXYFUNCENTER sfp_jlong_, 357
+PROXYFUNCENTER sfp_jlong_, 358
+PROXYFUNCENTER sfp_jlong_, 359
+PROXYFUNCENTER sfp_jlong_, 360
+PROXYFUNCENTER sfp_jlong_, 361
+PROXYFUNCENTER sfp_jlong_, 362
+PROXYFUNCENTER sfp_jlong_, 363
+PROXYFUNCENTER sfp_jlong_, 364
+PROXYFUNCENTER sfp_jlong_, 365
+PROXYFUNCENTER sfp_jlong_, 366
+PROXYFUNCENTER sfp_jlong_, 367
+PROXYFUNCENTER sfp_jlong_, 368
+PROXYFUNCENTER sfp_jlong_, 369
+PROXYFUNCENTER sfp_jlong_, 370
+PROXYFUNCENTER sfp_jlong_, 371
+PROXYFUNCENTER sfp_jlong_, 372
+PROXYFUNCENTER sfp_jlong_, 373
+PROXYFUNCENTER sfp_jlong_, 374
+PROXYFUNCENTER sfp_jlong_, 375
+PROXYFUNCENTER sfp_jlong_, 376
+PROXYFUNCENTER sfp_jlong_, 377
+PROXYFUNCENTER sfp_jlong_, 378
+PROXYFUNCENTER sfp_jlong_, 379
+PROXYFUNCENTER sfp_jlong_, 380
+PROXYFUNCENTER sfp_jlong_, 381
+PROXYFUNCENTER sfp_jlong_, 382
+PROXYFUNCENTER sfp_jlong_, 383
+PROXYFUNCENTER sfp_jlong_, 384
+PROXYFUNCENTER sfp_jlong_, 385
+PROXYFUNCENTER sfp_jlong_, 386
+PROXYFUNCENTER sfp_jlong_, 387
+PROXYFUNCENTER sfp_jlong_, 388
+PROXYFUNCENTER sfp_jlong_, 389
+PROXYFUNCENTER sfp_jlong_, 390
+PROXYFUNCENTER sfp_jlong_, 391
+PROXYFUNCENTER sfp_jlong_, 392
+PROXYFUNCENTER sfp_jlong_, 393
+PROXYFUNCENTER sfp_jlong_, 394
+PROXYFUNCENTER sfp_jlong_, 395
+PROXYFUNCENTER sfp_jlong_, 396
+PROXYFUNCENTER sfp_jlong_, 397
+PROXYFUNCENTER sfp_jlong_, 398
+PROXYFUNCENTER sfp_jlong_, 399
+PROXYFUNCENTER sfp_jlong_, 400
+PROXYFUNCENTER sfp_jlong_, 401
+PROXYFUNCENTER sfp_jlong_, 402
+PROXYFUNCENTER sfp_jlong_, 403
+PROXYFUNCENTER sfp_jlong_, 404
+PROXYFUNCENTER sfp_jlong_, 405
+PROXYFUNCENTER sfp_jlong_, 406
+PROXYFUNCENTER sfp_jlong_, 407
+PROXYFUNCENTER sfp_jlong_, 408
+PROXYFUNCENTER sfp_jlong_, 409
+PROXYFUNCENTER sfp_jlong_, 410
+PROXYFUNCENTER sfp_jlong_, 411
+PROXYFUNCENTER sfp_jlong_, 412
+PROXYFUNCENTER sfp_jlong_, 413
+PROXYFUNCENTER sfp_jlong_, 414
+PROXYFUNCENTER sfp_jlong_, 415
+PROXYFUNCENTER sfp_jlong_, 416
+PROXYFUNCENTER sfp_jlong_, 417
+PROXYFUNCENTER sfp_jlong_, 418
+PROXYFUNCENTER sfp_jlong_, 419
+PROXYFUNCENTER sfp_jlong_, 420
+PROXYFUNCENTER sfp_jlong_, 421
+PROXYFUNCENTER sfp_jlong_, 422
+PROXYFUNCENTER sfp_jlong_, 423
+PROXYFUNCENTER sfp_jlong_, 424
+PROXYFUNCENTER sfp_jlong_, 425
+PROXYFUNCENTER sfp_jlong_, 426
+PROXYFUNCENTER sfp_jlong_, 427
+PROXYFUNCENTER sfp_jlong_, 428
+PROXYFUNCENTER sfp_jlong_, 429
+PROXYFUNCENTER sfp_jlong_, 430
+PROXYFUNCENTER sfp_jlong_, 431
+PROXYFUNCENTER sfp_jlong_, 432
+PROXYFUNCENTER sfp_jlong_, 433
+PROXYFUNCENTER sfp_jlong_, 434
+PROXYFUNCENTER sfp_jlong_, 435
+PROXYFUNCENTER sfp_jlong_, 436
+PROXYFUNCENTER sfp_jlong_, 437
+PROXYFUNCENTER sfp_jlong_, 438
+PROXYFUNCENTER sfp_jlong_, 439
+PROXYFUNCENTER sfp_jlong_, 440
+PROXYFUNCENTER sfp_jlong_, 441
+PROXYFUNCENTER sfp_jlong_, 442
+PROXYFUNCENTER sfp_jlong_, 443
+PROXYFUNCENTER sfp_jlong_, 444
+PROXYFUNCENTER sfp_jlong_, 445
+PROXYFUNCENTER sfp_jlong_, 446
+PROXYFUNCENTER sfp_jlong_, 447
+PROXYFUNCENTER sfp_jlong_, 448
+PROXYFUNCENTER sfp_jlong_, 449
+PROXYFUNCENTER sfp_jlong_, 450
+PROXYFUNCENTER sfp_jlong_, 451
+PROXYFUNCENTER sfp_jlong_, 452
+PROXYFUNCENTER sfp_jlong_, 453
+PROXYFUNCENTER sfp_jlong_, 454
+PROXYFUNCENTER sfp_jlong_, 455
+PROXYFUNCENTER sfp_jlong_, 456
+PROXYFUNCENTER sfp_jlong_, 457
+PROXYFUNCENTER sfp_jlong_, 458
+PROXYFUNCENTER sfp_jlong_, 459
+PROXYFUNCENTER sfp_jlong_, 460
+PROXYFUNCENTER sfp_jlong_, 461
+PROXYFUNCENTER sfp_jlong_, 462
+PROXYFUNCENTER sfp_jlong_, 463
+PROXYFUNCENTER sfp_jlong_, 464
+PROXYFUNCENTER sfp_jlong_, 465
+PROXYFUNCENTER sfp_jlong_, 466
+PROXYFUNCENTER sfp_jlong_, 467
+PROXYFUNCENTER sfp_jlong_, 468
+PROXYFUNCENTER sfp_jlong_, 469
+PROXYFUNCENTER sfp_jlong_, 470
+PROXYFUNCENTER sfp_jlong_, 471
+PROXYFUNCENTER sfp_jlong_, 472
+PROXYFUNCENTER sfp_jlong_, 473
+PROXYFUNCENTER sfp_jlong_, 474
+PROXYFUNCENTER sfp_jlong_, 475
+PROXYFUNCENTER sfp_jlong_, 476
+PROXYFUNCENTER sfp_jlong_, 477
+PROXYFUNCENTER sfp_jlong_, 478
+PROXYFUNCENTER sfp_jlong_, 479
+PROXYFUNCENTER sfp_jlong_, 480
+PROXYFUNCENTER sfp_jlong_, 481
+PROXYFUNCENTER sfp_jlong_, 482
+PROXYFUNCENTER sfp_jlong_, 483
+PROXYFUNCENTER sfp_jlong_, 484
+PROXYFUNCENTER sfp_jlong_, 485
+PROXYFUNCENTER sfp_jlong_, 486
+PROXYFUNCENTER sfp_jlong_, 487
+PROXYFUNCENTER sfp_jlong_, 488
+PROXYFUNCENTER sfp_jlong_, 489
+PROXYFUNCENTER sfp_jlong_, 490
+PROXYFUNCENTER sfp_jlong_, 491
+PROXYFUNCENTER sfp_jlong_, 492
+PROXYFUNCENTER sfp_jlong_, 493
+PROXYFUNCENTER sfp_jlong_, 494
+PROXYFUNCENTER sfp_jlong_, 495
+PROXYFUNCENTER sfp_jlong_, 496
+PROXYFUNCENTER sfp_jlong_, 497
+PROXYFUNCENTER sfp_jlong_, 498
+PROXYFUNCENTER sfp_jlong_, 499
+PROXYFUNCENTER sfp_jlong_, 500
+PROXYFUNCENTER sfp_jlong_, 501
+PROXYFUNCENTER sfp_jlong_, 502
+PROXYFUNCENTER sfp_jlong_, 503
+PROXYFUNCENTER sfp_jlong_, 504
+PROXYFUNCENTER sfp_jlong_, 505
+PROXYFUNCENTER sfp_jlong_, 506
+PROXYFUNCENTER sfp_jlong_, 507
+PROXYFUNCENTER sfp_jlong_, 508
+PROXYFUNCENTER sfp_jlong_, 509
+PROXYFUNCENTER sfp_jlong_, 510
+PROXYFUNCENTER sfp_jlong_, 511
+PROXYFUNCENTER sfp_jlong_, 512
+PROXYFUNCENTER sfp_jlong_, 513
+PROXYFUNCENTER sfp_jlong_, 514
+PROXYFUNCENTER sfp_jlong_, 515
+PROXYFUNCENTER sfp_jlong_, 516
+PROXYFUNCENTER sfp_jlong_, 517
+PROXYFUNCENTER sfp_jlong_, 518
+PROXYFUNCENTER sfp_jlong_, 519
+PROXYFUNCENTER sfp_jlong_, 520
+PROXYFUNCENTER sfp_jlong_, 521
+PROXYFUNCENTER sfp_jlong_, 522
+PROXYFUNCENTER sfp_jlong_, 523
+PROXYFUNCENTER sfp_jlong_, 524
+PROXYFUNCENTER sfp_jlong_, 525
+PROXYFUNCENTER sfp_jlong_, 526
+PROXYFUNCENTER sfp_jlong_, 527
+PROXYFUNCENTER sfp_jlong_, 528
+PROXYFUNCENTER sfp_jlong_, 529
+PROXYFUNCENTER sfp_jlong_, 530
+PROXYFUNCENTER sfp_jlong_, 531
+PROXYFUNCENTER sfp_jlong_, 532
+PROXYFUNCENTER sfp_jlong_, 533
+PROXYFUNCENTER sfp_jlong_, 534
+PROXYFUNCENTER sfp_jlong_, 535
+PROXYFUNCENTER sfp_jlong_, 536
+PROXYFUNCENTER sfp_jlong_, 537
+PROXYFUNCENTER sfp_jlong_, 538
+PROXYFUNCENTER sfp_jlong_, 539
+PROXYFUNCENTER sfp_jlong_, 540
+PROXYFUNCENTER sfp_jlong_, 541
+PROXYFUNCENTER sfp_jlong_, 542
+PROXYFUNCENTER sfp_jlong_, 543
+PROXYFUNCENTER sfp_jlong_, 544
+PROXYFUNCENTER sfp_jlong_, 545
+PROXYFUNCENTER sfp_jlong_, 546
+PROXYFUNCENTER sfp_jlong_, 547
+PROXYFUNCENTER sfp_jlong_, 548
+PROXYFUNCENTER sfp_jlong_, 549
+PROXYFUNCENTER sfp_jlong_, 550
+PROXYFUNCENTER sfp_jlong_, 551
+PROXYFUNCENTER sfp_jlong_, 552
+PROXYFUNCENTER sfp_jlong_, 553
+PROXYFUNCENTER sfp_jlong_, 554
+PROXYFUNCENTER sfp_jlong_, 555
+PROXYFUNCENTER sfp_jlong_, 556
+PROXYFUNCENTER sfp_jlong_, 557
+PROXYFUNCENTER sfp_jlong_, 558
+PROXYFUNCENTER sfp_jlong_, 559
+PROXYFUNCENTER sfp_jlong_, 560
+PROXYFUNCENTER sfp_jlong_, 561
+PROXYFUNCENTER sfp_jlong_, 562
+PROXYFUNCENTER sfp_jlong_, 563
+PROXYFUNCENTER sfp_jlong_, 564
+PROXYFUNCENTER sfp_jlong_, 565
+PROXYFUNCENTER sfp_jlong_, 566
+PROXYFUNCENTER sfp_jlong_, 567
+PROXYFUNCENTER sfp_jlong_, 568
+PROXYFUNCENTER sfp_jlong_, 569
+PROXYFUNCENTER sfp_jlong_, 570
+PROXYFUNCENTER sfp_jlong_, 571
+PROXYFUNCENTER sfp_jlong_, 572
+PROXYFUNCENTER sfp_jlong_, 573
+PROXYFUNCENTER sfp_jlong_, 574
+PROXYFUNCENTER sfp_jlong_, 575
+PROXYFUNCENTER sfp_jlong_, 576
+PROXYFUNCENTER sfp_jlong_, 577
+PROXYFUNCENTER sfp_jlong_, 578
+PROXYFUNCENTER sfp_jlong_, 579
+PROXYFUNCENTER sfp_jlong_, 580
+PROXYFUNCENTER sfp_jlong_, 581
+PROXYFUNCENTER sfp_jlong_, 582
+PROXYFUNCENTER sfp_jlong_, 583
+PROXYFUNCENTER sfp_jlong_, 584
+PROXYFUNCENTER sfp_jlong_, 585
+PROXYFUNCENTER sfp_jlong_, 586
+PROXYFUNCENTER sfp_jlong_, 587
+PROXYFUNCENTER sfp_jlong_, 588
+PROXYFUNCENTER sfp_jlong_, 589
+PROXYFUNCENTER sfp_jlong_, 590
+PROXYFUNCENTER sfp_jlong_, 591
+PROXYFUNCENTER sfp_jlong_, 592
+PROXYFUNCENTER sfp_jlong_, 593
+PROXYFUNCENTER sfp_jlong_, 594
+PROXYFUNCENTER sfp_jlong_, 595
+PROXYFUNCENTER sfp_jlong_, 596
+PROXYFUNCENTER sfp_jlong_, 597
+PROXYFUNCENTER sfp_jlong_, 598
+PROXYFUNCENTER sfp_jlong_, 599
\ No newline at end of file
diff --git a/src/mrt/compiler-rt/src/arch/arm64/r2c_stub_arm64.S b/src/mrt/compiler-rt/src/arch/arm64/r2c_stub_arm64.S
new file mode 100644
index 0000000000000000000000000000000000000000..812195ebd1699f69667161ffc14173f7a309dca2
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/r2c_stub_arm64.S
@@ -0,0 +1,412 @@
+#define cfi_adjust_cfa_offset(off)      .cfi_adjust_cfa_offset off
+#define cfi_rel_offset(reg, off)        .cfi_rel_offset reg, off
+#define cfi_restore(reg)                .cfi_restore reg
+#define cfi_def_cfa_register(reg)       .cfi_def_cfa_register reg
+
+////////////////////////////////////////////////////////////////////////////////
+// there are 2 kinds of stubs to invoke a compiled java method: ForwardStub and BoxedStub.
+//
+// ForwardStub simply forwards arguments passed by runtime, i.e., arguments for compiled java method are passed
+// according to C/C++ calling convention, which usually means efficiency.
+//
+// BoxedStub takes a general way: maple runtime first boxes all java arguments into an array composed of first integer
+// arguments which are passed via general registers, then floating-point arguments which are passed via fp registers,
+// and arguments which can not be passed by register (they will be passed on stack).
+// BoxedStub unboxes all the arguments according to C/C++ calling convention.
+////////////////////////////////////////////////////////////////////////////////
+
+#define ForwardStubFrameSize      (8 * 18)
+#define ForwardStubCalleeSaveArea (8 * 8)
+
+// R2CForwardStubXX builds a stub frame to invoke the target java_method according to the previous frame which invokes
+// R2CForwardStubXX(java_method, std::forward<Args>(args)...).
+// R means runtime, while C means compiled java method. XX indicates the return type of this java method.
+
+// On execution of "bl R2CForwardStubXX", the frame layout of stack(growing downwards) looks like:
+// x0: the entry point of Java method to be invoked
+// x1~x7: hold the first 7 arguments arg0~arg6 if existed
+// x30: return address of "bl R2CForwardStubXX"
+// all on-stack arguments are addressable by SP as the frame layout shows.
+// arg7 will be passed to x7 from caller's stack after R2CForwardStub is built.
+//                 |  ...         |
+//                 |  x30         | lr for the caller of R2CForwardStubXX
+// caller fp  -->  |  x29         |
+//                 |  ...         |
+//                 | arg11        |
+//                 | arg10        |
+//                 | arg9         |
+//                 | arg8         |
+// caller sp  -->  | arg7         |
+
+// the frame layout of stack(growing downwards) after R2CForwardStub frame is built looks like:
+//                 |  ...         |
+//                 |  x30         | lr for the caller of R2CForwardStubXX
+// caller fp  -->  |  x29         |
+//                 |  ...         |
+//                 | arg11        |
+//                 | arg10        |
+//                 | arg9         |
+//                 | arg8         |
+// caller sp  -->  | arg7         |
+// callee saved    | r28          | <== R2CForwardStub frame starts from here
+//                 | r27          |
+//                 | r26          |
+//                 | r25          |
+//                 | r24          |
+//                 | r23          |
+//                 | r22          |
+//                 | r21          |
+//                 | r20          |
+// callee saved    | r19          |
+// unwind context  | direct call  | directly invoke callee java method
+//                 | shadowframe  | the information of caller frame which is interpreted
+//                 | UC Status    | unwind context status of caller frame
+//                 | Context LR   | LR of unwind context frame
+//                 | Context FP   | FP of unwind context frame
+// unwind context  | Context PC   | PC of unwind context frame
+//                 | x30          |
+//   stub fp  -->  | caller fp    |
+//                 |  ...         |
+//                 | arg11        |
+//                 | arg10        |
+//                 | arg9         |
+//   stub sp  -->  | arg8         | <== R2CForwardStub frame ends at here
+
+        .text
+        .align 2
+        .global R2CForwardStubLong
+        .hidden R2CForwardStubLong
+        .global R2CForwardStubVoid
+        .hidden R2CForwardStubVoid
+        .global R2CForwardStubFloat
+        .hidden R2CForwardStubFloat
+        .global R2CForwardStubDouble
+        .hidden R2CForwardStubDouble
+        .type R2CForwardStubVoid  , %function
+        .type R2CForwardStubLong  , %function
+        .type R2CForwardStubFloat , %function
+        .type R2CForwardStubDouble, %function
+R2CForwardStubLong:
+R2CForwardStubVoid:
+R2CForwardStubFloat:
+R2CForwardStubDouble:
+        .cfi_startproc
+        .cfi_personality 155, DW.ref.__n2j_stub_personality
+        add  x30, x30, #1
+        stp  x29, x30, [sp,  #-ForwardStubFrameSize]!
+        cfi_adjust_cfa_offset (ForwardStubFrameSize)
+        cfi_rel_offset (x29, 0)
+        cfi_rel_offset (x30, 8)
+
+        // save all used callee-saved registers.
+        stp  x19, x20, [sp, #ForwardStubCalleeSaveArea]
+        cfi_rel_offset (x19, ForwardStubCalleeSaveArea)
+        cfi_rel_offset (x20, ForwardStubCalleeSaveArea+8)
+
+        stp  x21, x22, [sp, #ForwardStubCalleeSaveArea+0x10]
+        cfi_rel_offset (x21, ForwardStubCalleeSaveArea+0x10)
+        cfi_rel_offset (x22, ForwardStubCalleeSaveArea+0x18)
+
+        stp  x23, x24, [sp, #ForwardStubCalleeSaveArea+0x20]
+        cfi_rel_offset (x23, ForwardStubCalleeSaveArea+0x20)
+        cfi_rel_offset (x24, ForwardStubCalleeSaveArea+0x28)
+
+        stp  x25, x26, [sp, #ForwardStubCalleeSaveArea+0x30]
+        cfi_rel_offset (x25, ForwardStubCalleeSaveArea+0x30)
+        cfi_rel_offset (x26, ForwardStubCalleeSaveArea+0x38)
+
+        stp  x27, x28, [sp, #ForwardStubCalleeSaveArea+0x40]
+        cfi_rel_offset (x27, ForwardStubCalleeSaveArea+0x40)
+        cfi_rel_offset (x28, ForwardStubCalleeSaveArea+0x48)
+
+        // x19 <- previous fp
+        mov  x19, x29
+
+        mov  x20, x0 // the entry point of Java method
+
+        mov  x21, x1
+        mov  x22, x2
+        mov  x23, x3
+        mov  x24, x4
+        mov  x25, x5
+        mov  x26, x6
+        mov  x27, x7
+
+        // x28 <- previous sp
+        add  x28, sp, #ForwardStubFrameSize
+
+        mov  x29, sp
+        cfi_def_cfa_register (x29)
+
+        // frame info: tls -> stub
+        mov  x0, x29
+        bl MRT_SaveLastUnwindContext
+
+        // java code is always reliable for stack unwinding
+        bl MRT_SetReliableUnwindContextStatus
+
+        // prepare arguments for invoking target Java method
+        mov  x0, x21
+        mov  x1, x22
+        mov  x2, x23
+        mov  x3, x24
+        mov  x4, x25
+        mov  x5, x26
+        mov  x6, x27
+
+        // passing on-stack arguments. start from arg8.
+        // put the 8th argument into register x7 from on-stack
+        ldr x7, [x28], #8
+        add x19, x19, #8
+
+        // copy arg9, arg10, ... (if existed)
+.L_copy:
+        cmp x19, x28
+        ble .L_copy_end
+        ldp x25, x26, [x19, #-16]!
+        // SP is always 16 byte-aligned.
+        stp x25, x26, [sp,  #-16]!
+        b .L_copy
+.L_copy_end:
+
+        // set x19 to the polling page address
+        adrp x19, REF_globalPollingPage
+        add  x19, x19, :lo12:REF_globalPollingPage
+        ldr  x19, [x19]
+        ldr  x19, [x19]
+
+        blr  x20
+
+        /* keep potential return value */
+        mov  x28, x0
+        fmov x27, d0
+
+        /* restore last_java_frame */
+        mov  x0, x29
+        bl MRT_RestoreLastUnwindContext
+
+        /* set potential return value */
+        mov  x0, x28
+        fmov d0, x27
+
+        mov  sp, x29
+        cfi_def_cfa_register (sp)
+
+        // restore all used callee-saved registers.
+        ldp  x19, x20, [sp, #ForwardStubCalleeSaveArea]
+        cfi_restore (x19)
+        cfi_restore (x20)
+        ldp  x21, x22, [sp, #ForwardStubCalleeSaveArea+0x10]
+        cfi_restore (x21)
+        cfi_restore (x22)
+        ldp  x23, x24, [sp, #ForwardStubCalleeSaveArea+0x20]
+        cfi_restore (x23)
+        cfi_restore (x24)
+        ldp  x25, x26, [sp, #ForwardStubCalleeSaveArea+0x30]
+        cfi_restore (x25)
+        cfi_restore (x26)
+        ldp  x27, x28, [sp, #ForwardStubCalleeSaveArea+0x40]
+        cfi_restore (x27)
+        cfi_restore (x28)
+
+        ldp     x29, x30, [sp], #ForwardStubFrameSize
+        cfi_adjust_cfa_offset (-ForwardStubFrameSize)
+        cfi_restore (x29)
+        cfi_restore (x30)
+        sub  x30, x30, #1
+        ret
+        .cfi_endproc
+        .size R2CForwardStubLong, .-R2CForwardStubLong
+
+////////////////////////////////////////////////////////////////////////////////
+
+#define BoxedStubFrameSize      (8 * 16)
+#define BoxedStubCalleeSaveArea (8 * 8)
+
+#define JVALUE_SIZE 8
+
+// extern"C" void R2CBoxedStubXXX(void *func_ptr,       x0
+//                                     jvalue    *argJvalue, x1
+//                                     uint_32   stackSize,      x2
+//                                     uint_32   dregSize        x3)
+
+// On execution of "bl R2CBoxedStub", the top frame of stack(growing downwards) looks like:
+// x0: the entry point of Java method to be invoked
+// x1: argJvalue
+// x2: stackSize
+// x3: dregSize
+//                 |  ...        |
+//                 |  x30        |
+//    sp, fp  -->  |  x29        | fp for the caller of R2CBoxedStub
+
+// this routine builds a stub frame to invoke java method
+// x20: the entry point of Java method to be invoked
+// x0~x7: hold the first 8 integer arguments if existed
+// d0~d7: hold the first 8 float arguments if existed
+//                 |  ...        |
+//                 |  x30        |
+// caller fp  -->  |  x29        |
+// callee saved    |  ---        |
+//                 |  ---        |
+//                 |  r24        |
+//                 |  r23        |
+//                 |  r22        |
+//                 |  r21        |
+//                 |  r20        |
+// callee saved    |  r19        |
+// unwind context  | direct call | directly invoke callee java method
+//                 | shadowframe | the information of caller frame which is interpreted
+//                 | UCStatus    | unwind context status of caller frame
+//                 | Caller LR   | LR of caller frame
+//                 | Caller FP   | FP of caller frame
+// unwind context  | Caller PC   | PC of caller frame
+//                 | x30         |
+// stub sp,fp -->  | caller fp   |
+
+        .text
+        .align 2
+        .global R2CBoxedStubLong
+        .hidden R2CBoxedStubLong
+        .global R2CBoxedStubVoid
+        .hidden R2CBoxedStubVoid
+        .global R2CBoxedStubFloat
+        .hidden R2CBoxedStubFloat
+        .global R2CBoxedStubDouble
+        .hidden R2CBoxedStubDouble
+        .type R2CBoxedStubLong, %function
+        .type R2CBoxedStubVoid, %function
+        .type R2CBoxedStubFloat, %function
+        .type R2CBoxedStubDouble, %function
+R2CBoxedStubLong:
+R2CBoxedStubVoid:
+R2CBoxedStubFloat:
+R2CBoxedStubDouble:
+        .cfi_startproc
+        .cfi_personality 155, DW.ref.__n2j_stub_personality
+        add  x30, x30, #1
+        stp  x29, x30, [sp,  #-BoxedStubFrameSize]!
+        cfi_adjust_cfa_offset (BoxedStubFrameSize)
+        cfi_rel_offset (x29, 0)
+        cfi_rel_offset (x30, 8)
+
+        // save all used callee-saved registers.
+        stp  x19, x20, [sp, #BoxedStubCalleeSaveArea]
+        cfi_rel_offset (x19, BoxedStubCalleeSaveArea)
+        cfi_rel_offset (x20, BoxedStubCalleeSaveArea+8)
+
+        stp  x21, x22, [sp, #BoxedStubCalleeSaveArea+0x10]
+        cfi_rel_offset (x21, BoxedStubCalleeSaveArea+0x10)
+        cfi_rel_offset (x22, BoxedStubCalleeSaveArea+0x18)
+
+        stp  x23, x24, [sp, #BoxedStubCalleeSaveArea+0x20]
+        cfi_rel_offset (x23, BoxedStubCalleeSaveArea+0x20)
+        cfi_rel_offset (x24, BoxedStubCalleeSaveArea+0x28)
+
+        mov  x20, x0 // the entry point of Java method
+
+        mov  x21, x1 // jvalue start
+        mov  x22, x2 // stack size
+        mov  x23, x3 // dreg size
+
+        mov  x29, sp
+        cfi_def_cfa_register (x29)
+
+        // frame info: tls -> stub
+        mov  x0, x29
+        bl MRT_SaveLastUnwindContext
+
+        // java code is always reliable for stack unwinding
+        bl MRT_SetReliableUnwindContextStatus
+
+        cbz  x22, .LskipStack
+        // copy parameter to stack
+        // size align to 16 byte.
+        add  x22, x22, #(16 - 1)
+        and  x22, x22, #0xFFFFFFFFFFFFFFF0;
+        sub  sp, sp, x22
+        mov  x0, sp
+        add  x24, x21, #128 // 16 * 8, jvalus offset 16
+        add  x22, x24, x22
+.LCopy:
+        cmp  x24, x22
+        bge  .LCopyEnd
+        ldp  x1, x2, [x24], #16
+        stp  x1, x2, [x0], #16
+        b .LCopy
+.LCopyEnd:
+.LskipStack:
+        ldp  x0, x1, [x21, #0]
+        ldp  x2, x3, [x21, #16]
+        ldp  x4, x5, [x21, #32]
+        ldp  x6, x7, [x21, #48]
+
+        cbz  x23, .LcallFunction
+        ldp  d0, d1, [x21, #64 +  0]
+        ldp  d2, d3, [x21, #64 + 16]
+        ldp  d4, d5, [x21, #64 + 32]
+        ldp  d6, d7, [x21, #64 + 48]
+
+.LcallFunction:
+        // set x19 to the polling page address
+        adrp x19, REF_globalPollingPage
+        add  x19, x19, :lo12:REF_globalPollingPage
+        ldr  x19, [x19]
+        ldr  x19, [x19]
+
+        blr  x20
+
+        /* keep potential return value */
+        mov  x20, x0
+        fmov  x19, d0
+
+        /* restore last_java_frame */
+        mov  x0, x29
+        bl MRT_RestoreLastUnwindContext
+
+        /* set potential return value */
+        mov  x0, x20
+        fmov  d0, x19
+
+        mov  sp, x29
+        cfi_def_cfa_register (sp)
+
+        // restore all used callee-saved registers.
+        ldp  x19, x20, [sp, #BoxedStubCalleeSaveArea]
+        cfi_restore (x19)
+        cfi_restore (x20)
+        ldp  x21, x22, [sp, #BoxedStubCalleeSaveArea+0x10]
+        cfi_restore (x21)
+        cfi_restore (x22)
+        ldp  x23, x24, [sp, #BoxedStubCalleeSaveArea+0x20]
+        cfi_restore (x23)
+        cfi_restore (x24)
+
+        ldp     x29, x30, [sp], #BoxedStubFrameSize
+        cfi_adjust_cfa_offset (-BoxedStubFrameSize)
+        cfi_restore (x29)
+        cfi_restore (x30)
+        sub  x30, x30, #1
+        ret
+        .cfi_endproc
+        .size R2CBoxedStubLong, .-R2CBoxedStubLong
+
+////////////////////////////////////////////////////////////////////////////////
+
+        .hidden DW.ref.__n2j_stub_personality
+        .weak DW.ref.__n2j_stub_personality
+        .section .data.DW.ref.__n2j_stub_personality,"awG",%progbits,DW.ref.__n2j_stub_personality,comdat
+        .align 3
+        .type DW.ref.__n2j_stub_personality, %object
+        .size DW.ref.__n2j_stub_personality,8
+DW.ref.__n2j_stub_personality:
+        .xword __n2j_stub_personality
+
+///////////////////////////////////////////////////////////////////////////////
+        // Add this section for lld relocation limitation
+.section .data.ref.lld_relocation_limitation,"aw",%progbits
+   .type REF_globalPollingPage,@object
+   .align 3
+   .local REF_globalPollingPage
+REF_globalPollingPage:
+   .xword globalPollingPage
+   .size REF_globalPollingPage,.-REF_globalPollingPage
diff --git a/src/mrt/compiler-rt/src/arch/arm64/signal_handler_arm64.cpp b/src/mrt/compiler-rt/src/arch/arm64/signal_handler_arm64.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f752e8c7b3ef845348420de6f2cb4299b9a27670
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/signal_handler_arm64.cpp
@@ -0,0 +1,597 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <sys/mman.h>
+#include <csignal>
+#include <unistd.h>
+#include <cstdlib>
+#include <cassert>
+#include <cerrno>
+#include <cstring>
+#include <cstdio>
+#include <map>
+#include <dlfcn.h>
+#include "libs.h"
+#include "chelper.h"
+#include "sizes.h" // runtime/include
+#include "exception/mpl_exception.h"
+#include "yieldpoint.h"
+#include "exception_store.h"
+#include "linker_api.h"
+#include "thread_helper.h"
+#include "mrt_common.h"
+#include "exception/stack_unwinder.h"
+#include "utils/time_utils.h"
+
+namespace maplert {
+//  Access a label defined in assembly from within C
+//  1.  Export the label using .globl in the assembly
+//  1.1 For _ZTI37Ljava_2Flang_2FArithmeticException_3B and
+//      _ZTI38Ljava_2Flang_2FNullPointerException_3B,
+//      the labels are defined in the same compilation unit
+//      (see the below comment about a couple of dummy functions)
+//      we don't need the step.
+//  2. Declare that the labels are external ones.
+//  3. Don't for get to take the ADDRESS of the symbol.
+using namespace maple;
+
+extern "C" ClassInitState MRT_TryInitClassOnDemand(const MClass &classinfo);
+extern "C" bool MRT_ClassInitialized(jclass classinfo);
+
+// Exception handling through signals
+//
+// Throwing an exception from a signal handler will not automatically notify the
+// kernel that we have finished signal handling.  Therefore, the kernel still
+// thinks we are handlign exceptions.  The kernel keeps the same signal blocked
+// when we are handling it, and it will prevent a second SIGSEGV to be thrown
+// when a hardware trap is triggered by a subsequent NULL pointer access.
+//
+// This function is a workaround.  It unblocks the SIGSEGV before throwing a
+// Java exception.  This allows repeated NULL pointer accesses to throw NPE, but
+// the correct implementation needs to actually look at the PC to find out if
+// the SIGSEGV is actually caused by a Java instruction.  We also need to
+// thoroughly investigate the side effects of rt_sigreturn (the function which
+// is called after a signal handler returns) in addition to unblocking the
+// signal and restoring the mcontext.
+//
+// PrepareToHandleJavaSignal implicitly does the job by RealHandler1 when signal
+// stub frame is retreated.
+using RealHandler2 = void (*)(void*, void*);
+struct SignalHandler {
+  // pc is utilized to restore control flow after signal is handled
+  void *mPC;                  // the program point where this signal is raised
+  void *mReturnPC;            // the return pc after this signal is handled
+  RealHandler1 mHandler;      // the real signal handler
+  void *mArg1;                // the first argument of mHandler
+  RealHandler1 mResetHandler; // the page reset handler called after mHandler done
+  void *mArgr1;               // the first argument of mResetHandler
+};
+
+// this is unreliable because sh is deleted after real signal handler is excecuted.
+// we can not use this in HandleJavaSignalStub after calling InvokeJavaSignalHandler
+// since sh is already deleted.
+extern "C" void *GetRaisedSignalPC() {
+  SignalHandler *sh = reinterpret_cast<SignalHandler*>(maple::ExceptionVisitor::GetSignalHandler());
+  if (sh == nullptr) {
+    LOG(FATAL) << "signale handler should not be nullptr" << maple::endl;
+    return nullptr;
+  }
+  return sh->mPC;
+}
+
+extern "C" void MRT_InvokeResetHandler() {
+  SignalHandler *sh = reinterpret_cast<SignalHandler*>(maple::ExceptionVisitor::GetSignalHandler());
+  if (sh == nullptr) {
+    return;
+  }
+  maple::ExceptionVisitor::SetSignalHandler(nullptr);
+  RealHandler1 handler = sh->mResetHandler;
+  if (handler != nullptr) {
+    handler(sh->mArgr1);
+  }
+  delete sh;
+  sh = nullptr;
+}
+
+extern "C" void *InvokeJavaSignalHandler() {
+  auto sh = reinterpret_cast<SignalHandler*>(maple::ExceptionVisitor::GetSignalHandler());
+  if (sh == nullptr) {
+    LOG(FATAL) << "signale handler should not be nullptr" << maple::endl;
+    return nullptr;
+  }
+  if (sh->mResetHandler == nullptr) {
+    maple::ExceptionVisitor::SetSignalHandler(nullptr);
+  }
+  RealHandler1 handler = sh->mHandler;
+  void *arg1 = sh->mArg1;
+  void *returnPC = sh->mReturnPC;
+  if (sh->mResetHandler == nullptr) {
+    delete sh;
+    sh = nullptr;
+  }
+  handler(arg1);
+  return returnPC;
+}
+
+extern "C" void HandleJavaSignalStub();
+
+// this is a stub only for handling signals raised in java methods
+extern "C" bool MRT_PrepareToHandleJavaSignal(ucontext_t *ucontext,
+                                              RealHandler1 handler, void *arg1,
+                                              RealHandler1 rhandler, void *r1,
+                                              int32_t returnPCOffset) {
+  // For parameter returnPCOffset, its default valus is 1, that is pc + 4 , mean to issue the next instructions after
+  // signale handling. but signals like lazybinding or decouple would like to redo the instruction bundle
+  // after handling the signal. We can not set register x17 to the alctually return pc but pc + 4 because
+  // the value in x17 will set to the eh frame which is used to determin if the EH is inside a try block.  So
+  // here we set the x17 as (pc + 4) and sh->mReturnPC as pc + 4 * returnPCOffset.
+  mcontext_t *mcontext = &(ucontext->uc_mcontext);
+
+  auto sh = new (std::nothrow) SignalHandler;
+  if (sh == nullptr) {
+    LOG(FATAL) << "new SignalHandler failed" << maple::endl;
+  }
+  sh->mHandler = handler;
+  sh->mArg1 = arg1;
+  sh->mPC = reinterpret_cast<void*>(mcontext->pc);
+  sh->mReturnPC = reinterpret_cast<void*>(mcontext->pc + kAarch64InsnSize * returnPCOffset);
+  sh->mResetHandler = rhandler;
+  sh->mArgr1 = r1;
+  ExceptionVisitor::SetSignalHandler(sh);
+
+  {
+    // signal handler frame is specifically structured, and can not be uniwinded according to ABI, which is more or less
+    // like the frames constructed by third-party native code, thus we have to update this java context as *risky*.
+    MRT_UpdateLastUnwindContext(reinterpret_cast<uint32_t*>(mcontext->pc + kAarch64InsnSize),
+                                reinterpret_cast<CallChain*>(mcontext->regs[kFP]), UnwindContextIsRisky);
+    // make lr valid for java method without an frame.
+    if (JavaFrame::JavaMethodHasNoFrame(reinterpret_cast<const uint32_t*>(mcontext->pc))) {
+      MRT_UpdateLastUnwindFrameLR(reinterpret_cast<const uint32_t*>(mcontext->regs[kLR]));
+    }
+  }
+
+  // backup the pc in the abnormal frame to x17.
+  // set x17 to "pc + 4", and mimic as if this is a bl instruction.
+  // Note _Unwind_GetIP relies on this value to get
+  // the context where an exception is raised. __mpl_personality_v0 should cooperate
+  // with this backup. otherwise, search exception table will fail.
+  //
+  // Furthermore, _Unwind APIs assume the value of pc points to the next instruction
+  // of the instruction which raises a signal. Otherwise stack unwinding fails when
+  // the first instruction of a method in an abnormal frame raises a signal.
+  // refer to uw_update_context in libgcc.
+  mcontext->regs[kX17] = mcontext->pc + kAarch64InsnSize;
+
+  // mimic the return address for HandleJavaSignalStub, this is necessary for gdb
+  // as well as _Unwind_xx APIs, since control flow *jumps* to HandleJavaSignalStub,
+  // and does not save exceptioning instruction pointer automatically.
+  // We need a precise site where raises an exception for _Unwind_xx APIs to work.
+  // backup x30 is an alternative option.
+  mcontext->pc = reinterpret_cast<uint64_t>(&HandleJavaSignalStub); // ready to perform signal handling
+  return true;
+}
+
+static int UnblockSignal(int sig) {
+  sigset_t sigSet;
+  if (UNLIKELY(sigemptyset(&sigSet) == -1)) {
+    LOG(ERROR) << "sigemptyset() in UnblockSignal() return -1 for failed." << maple::endl;
+  }
+  if (UNLIKELY(sigaddset(&sigSet, sig) == -1)) {
+    LOG(ERROR) << "sigaddset() in UnblockSignal() return -1 for failed." << maple::endl;
+  }
+  sigset_t oldSet;
+  int err = sigprocmask(SIG_UNBLOCK, &sigSet, &oldSet);
+  if (err != 0) {
+    PLOG(ERROR) << "UnblockSignal failed" << maple::endl;
+  }
+  return err;
+}
+
+static void *AnalyzeLazyloadInstructionSequence(uint32_t *pc4, ucontext_t *ucontext) {
+  uint32_t *pc0 =  pc4 - 1;
+  // 0:         ldr   wm [xn] // xm for 64bit
+  // 4:         ldr   wm [wm]
+#ifdef USE_32BIT_REF
+  constexpr static uint32_t prefixCode0 = 0xb9400;
+#else
+  constexpr static uint32_t prefixCode0 = 0xf9400;
+#endif
+  constexpr static uint32_t prefixCode4 = 0xb9400;
+  constexpr static uint32_t regMask = 0b11111;
+  constexpr static uint32_t kMplOffsetFixFlag = 0x80000000;
+  constexpr static uint16_t regCodeOffset = 12;
+  constexpr static uint16_t regNumOffset = 5;
+
+  uint32_t code0 = (*pc0 >> regCodeOffset);
+  uint32_t code4 = (*pc4 >> regCodeOffset);
+  uint32_t distRegNum0 = *pc0 & regMask;
+  uint32_t srcRegNum0 =  (*pc0 >> regNumOffset) & regMask;
+  uint32_t srcRegNum4 =  (*pc4 >> regNumOffset) & regMask;
+
+  if (code0 == prefixCode0 && code4 == prefixCode4 && distRegNum0 != srcRegNum0 &&
+      distRegNum0 == srcRegNum4 && ucontext != nullptr) {
+    // Further check the LazyLoad Sentry Number
+    LinkerOffsetValItemLazyLoad *offValTabAddr =
+        reinterpret_cast<LinkerOffsetValItemLazyLoad*>(ucontext->uc_mcontext.regs[srcRegNum0]);
+    uint32_t offsetValue = offValTabAddr->offset;
+    if (offsetValue & kMplOffsetFixFlag) {
+      uint32_t offsetIndex = (offsetValue & (~kMplOffsetFixFlag));
+      if (*(reinterpret_cast<uint64_t*>(offValTabAddr - offsetIndex) - 1) != kMplLazyLoadSentryNumber) {
+        return nullptr;
+      }
+    }
+    return offValTabAddr;
+  }
+  return nullptr;
+}
+
+const uint64_t kAdrpBinaryCode = 0b10010000;
+const uint64_t kLdrBinaryCode  = 0b1011100101;
+const uint64_t kAdrBinaryCode  = 0b00010000;
+const uint64_t kAddBinaryCode  = 0b00010001;
+const uint64_t kShortCmdMask   = 0b10011111;
+const uint64_t kLongCmdMask    = 0b1011111111;
+const uint64_t kLdrXtMask      = 0b11111;
+const uint64_t kXzrReg         = 31;
+const uint32_t kLongCmdMaskOffset = 22;
+const uint32_t kShortCmdMaskOffset = 24;
+
+uint64_t *PICAdrpCodeCheck(const uint32_t *pc) {
+  // case 1.1: PIC code
+  //    0: 0x90012c20  adrp  x0, 0x555a844000          # (code >> 24) &   0b10011111 ==   0b10010000
+  //    4: 0xf9400000  ldr   x0, [x0,#1024]            # (code >> 22) & 0b1011111111 == 0b1011100101
+  //    8: 0xf9400000  ldr   x0, [x0,#112]             # (code >> 22) & 0b1011111111 == 0b1011100101
+  //   12: 0xf9400000  ldr   x0, [x0]                  # (code >> 22) & 0b1011111111 == 0b1011100101
+  if ((((*(pc + 0) >> kShortCmdMaskOffset) & kShortCmdMask) == kAdrpBinaryCode) &&
+      (((*(pc + 1) >> kLongCmdMaskOffset) & kLongCmdMask) == kLdrBinaryCode)) {
+    {
+      // decode adrp (refer to ARM Architecture Reference Manual ARMv8 C6.2.10)
+      uintptr_t adrpCode = *pc;
+      // 19 + 2 + 12 bits
+      uintptr_t adrpOffset = ((((adrpCode >> 5) & 0x7FFFF) << 2) | ((adrpCode >> 29) & 0b11)) << 12;
+      // 19 + 2 + 12 bits sign-extend to 64 bits
+      adrpOffset = (adrpOffset << (64 - 33)) >> (64 - 33);
+      // relative to pc page address.
+      uintptr_t targetPage = ((reinterpret_cast<uintptr_t>(pc) >> 12) << 12) + adrpOffset;
+
+      // decode add (refer to ARM Architecture Reference Manual ARMv8 C6.2.4)
+      uint32_t ldrCode = *(pc + 1);
+      uintptr_t ldrOffset = (ldrCode >> 10) & 0xFFF; // 12 bits
+      uint32_t ldrScale = (ldrCode >> 30) & 0b11; // 2 bits
+      return reinterpret_cast<uint64_t*>(targetPage + (ldrOffset << ldrScale));
+    }
+  }
+  return nullptr;
+}
+
+uint64_t *PICAdrCodeCheck(const uint32_t *pc, uint32_t secondLdrOffset) {
+  // case 1.2: PIC code. CG does not generate these code, but assembler will replace adrp for adr
+  // 0: 0x90012c20  adr  x0, 0xffff7030d000          # (code >> 24) &   0b10011111 ==   0b10010000
+  // 4: 0xf9400000  ldr   x0, [x0,#1024]            # (code >> 22) & 0b1011111111 == 0b1011100101
+  // 8: 0xf9400000  ldr   x0, [x0,#112]             # (code >> 22) & 0b1011111111 == 0b1011100101
+  // 12: 0xf9400000  ldr   x0, [x0]                  # (code >> 22) & 0b1011111111 == 0b1011100101
+  if ((((*(pc + 0) >> kShortCmdMaskOffset) & kShortCmdMask) == kAdrBinaryCode) &&
+      (((*(pc + 1) >> kLongCmdMaskOffset) & kLongCmdMask) == kLdrBinaryCode) &&
+      (((*(pc + secondLdrOffset) >> kLongCmdMaskOffset) & kLongCmdMask) == kLdrBinaryCode)) {
+    {
+      // decode adrp (refer to ARM Architecture Reference Manual ARMv8 C6.2.10)
+      uintptr_t adrCode = *pc;
+      // 19 + 2 bits
+      uintptr_t adrOffset = ((((adrCode >> 5) & 0x7FFFF) << 2) | ((adrCode >> 29) & 0b11));
+      // 19 + 2 bits sign-extend to 64 bits
+      adrOffset = (adrOffset << (64 - 21)) >> (64 - 21);
+      // relative to pc address.
+      uintptr_t targetPage = reinterpret_cast<uintptr_t>(pc) + adrOffset;
+
+      // decode add (refer to ARM Architecture Reference Manual ARMv8 C6.2.4)
+      uint32_t ldrCode = *(pc + 1);
+      uintptr_t ldrOffset = (ldrCode >> 10) & 0xFFF; // 12 bits
+      uint32_t ldrScale = (ldrCode >> 30) & 0b11; // 2 bits
+      return reinterpret_cast<uint64_t*>(targetPage + (ldrOffset << ldrScale));
+    }
+  }
+  return nullptr;
+}
+
+uint64_t *NonPICCodeCheck(const uint32_t *pc) {
+  // case 2: non-PIC code
+  //    0: 0x90012c20  adrp  x0, 0x555a844000          # (code >> 24) &   0b10011111 ==   0b10010000
+  //    4: 0x911e2000  add   x0, x0, #0x788            # (code >> 24) &   0b01111111 ==   0b00010001
+  //    8: 0xf9400000  ldr   x0, [x0,#112]             # (code >> 22) & 0b1011111111 == 0b1011100101
+  //   12: 0xf9400000  ldr   x0, [x0]                  # (code >> 22) & 0b1011111111 == 0b1011100101
+  if ((((*(pc + 0) >> kShortCmdMaskOffset) & kShortCmdMask) == kAdrpBinaryCode) &&
+      (((*(pc + 1) >> kShortCmdMaskOffset) & kShortCmdMask) == kAddBinaryCode)) {
+    {
+      // decode adrp (refer to ARM Architecture Reference Manual ARMv8 C6.2.10)
+      uintptr_t adrpCode = *pc;
+
+      // 19 + 2 + 12 bits
+      uintptr_t adrpOffset = ((((adrpCode >> 5) & 0x7FFFF) << 2) | ((adrpCode >> 29) & 0b11)) << 12;
+      // 19 + 2 + 12 bits sign-extend to 64 bits
+      adrpOffset = (adrpOffset << (64 - 33)) >> (64 - 33);
+      // relative to pc page address.
+      uintptr_t targetPage = ((reinterpret_cast<uintptr_t>(pc) >> 12) << 12) + adrpOffset;
+
+      // decode add (refer to ARM Architecture Reference Manual ARMv8 C6.2.4)
+      uint32_t addCode = *(pc + 1);
+      uintptr_t addOffset = (addCode >> 10) & 0xFFF; // 12 bits
+      uint32_t addShift = (addCode >> 22) & 0b11; // 2 bits
+      __MRT_ASSERT(addShift < 0b10, "AnalyzeClinitInstructionSequence addShift error");
+      if (addShift == 0b01) {
+        addOffset <<= 12;
+      }
+      return reinterpret_cast<uint64_t*>(targetPage + addOffset);
+    }
+  }
+  return nullptr;
+}
+
+// analyze following instructions:
+static uint64_t *AnalyzeClinitInstructionSequence(const uint32_t *pc) {
+  uint32_t secondLdrOffset = 2;
+  // check the case with a lazybind instruction
+  // -4: 0xd0000080  adrp x0,  14000 <_GLOBAL_OFFSET_TABLE_+0xf0>
+  // 0: 0xf9425000  ldr  x0,  [x0,#1184]
+  // 4: 0xf940001f  ldr  xzr, [x0]    // for lazy binnding
+  // 8: 0xf9401811  ldr  x17, [x0,#48]
+  // c: 0xf940023f  ldr  xzr, [x17]
+  if ((((*(pc + 0) >> kLongCmdMaskOffset) & kLongCmdMask) == kLdrBinaryCode) &&
+      (((*(pc + 1) >> kLongCmdMaskOffset) & kLongCmdMask) == kLdrBinaryCode) &&
+      ((*(pc + 1) & kLdrXtMask) == kXzrReg)) {
+    --pc;
+    ++secondLdrOffset;
+  }
+
+  uint64_t *result = nullptr;
+
+  result = PICAdrpCodeCheck(pc);
+  if (result != nullptr) {
+    return result;
+  }
+
+  result = PICAdrCodeCheck(pc, secondLdrOffset);
+  if (result != nullptr) {
+    return result;
+  }
+
+  result = NonPICCodeCheck(pc);
+  if (result != nullptr) {
+    return result;
+  }
+
+  return nullptr;
+}
+
+static int64_t sigvCausedClinit = 0;
+
+static inline int64_t IncSigvCausedClinitCount(int64_t count) {
+  return __atomic_add_fetch(&sigvCausedClinit, count, __ATOMIC_ACQ_REL);
+}
+
+namespace {
+constexpr uint16_t kAdrpPcOffsetForLazy = 2;
+}
+
+static inline uint32_t GetLdrSrcRegNum(uint32_t pc) {
+  constexpr static uint16_t srcRegNumOffset = 5;
+  constexpr static uint32_t regMask = 0b11111;
+  return (pc >> srcRegNumOffset) & regMask;
+}
+
+static bool AnalyzeLoadArrayCacheInstructionSequence(uint32_t *pc, ucontext_t &ucontext) {
+  // adrp    x1, 1798000
+  // ldr     w1, [x1,#2400]
+  // ldr     wzr, [x1]
+  constexpr uint16_t adrpPCOffsetForArrayCache = 2;
+  uint32_t *adrpPC = pc - adrpPCOffsetForArrayCache;
+  uint64_t *addr = AnalyzeClinitInstructionSequence(adrpPC);
+  if (addr == nullptr) {
+    return MRT_PrepareToHandleJavaSignal(&ucontext, &MRT_ThrowImplicitNullPointerExceptionUnw, pc);
+  }
+
+  SignalInfo *pSignalInfo = new (std::nothrow) SignalInfo(pc, addr);
+  MplCheck(pSignalInfo != nullptr, "pSignalInfo is nullptr");
+  constexpr int32_t arrayCacheReturnPCOffset = -2;
+  return MRT_PrepareToHandleJavaSignal(&ucontext, reinterpret_cast<RealHandler1>(MRT_RequestInitArrayCache),
+                                       pSignalInfo, nullptr, nullptr, arrayCacheReturnPCOffset);
+}
+
+static bool HandleStaticDecoupleSignal(ucontext_t &ucontext) {
+  uint32_t *pc = reinterpret_cast<uint32_t*>(ucontext.uc_mcontext.pc);
+  constexpr int32_t kDecoupleStaticReturnPCOffset = -2;
+
+  auto *item = reinterpret_cast<LinkerStaticAddrItem*>(
+      AnalyzeClinitInstructionSequence(pc - kAdrpPcOffsetForLazy));
+  if (item == nullptr) {
+    return MRT_PrepareToHandleJavaSignal(&ucontext, &MRT_ThrowImplicitNullPointerExceptionUnw, pc);
+  }
+  MplStaticAddrTabHead *head = reinterpret_cast<MplStaticAddrTabHead*>(item - item->index) - 1;
+  if (head->magic == kMplStaticLazyLoadSentryNumber) {
+    int32_t returnPCOffset = kDecoupleStaticReturnPCOffset;
+    if (item->dcpAddr != 0) { // kMplStaticItemUnResolved
+      ucontext.uc_mcontext.regs[GetLdrSrcRegNum(*pc)] = item->dcpAddr; // this solves the static call in <clinit>
+      returnPCOffset = 1;
+    }
+
+    if (item->address == kMplLazyStaticDecoupleMagicNumber) {
+      return MRT_PrepareToHandleJavaSignal(&ucontext,
+                                           reinterpret_cast<RealHandler1>(MRT_FixStaticAddrTableLazily),
+                                           item, nullptr, nullptr, returnPCOffset);
+    } else {
+      return MRT_PrepareToHandleJavaSignal(&ucontext,
+                                           reinterpret_cast<RealHandler1>(MRT_FixStaticAddrTable),
+                                           item, nullptr, nullptr, returnPCOffset);
+    }
+  } else {
+    return MRT_PrepareToHandleJavaSignal(&ucontext, &MRT_ThrowImplicitNullPointerExceptionUnw, pc);
+  }
+}
+
+static bool HandleSigsegvFromJava(siginfo_t *info, ucontext_t *ucontext) {
+  constexpr uint16_t adrpPcOffsetForClinit = 3;
+  constexpr int32_t kLazyBindingReturnPcOffset = -2;
+  constexpr int32_t kDecoupleReturnPcOffset = -1;
+
+  // must unblock SIGSEGV before calling <clinit>
+  int tmpResult = UnblockSignal(SIGSEGV);
+  if (UNLIKELY(tmpResult != 0)) {
+    LOG(ERROR) << "UnblockSignal in HandleSigsegvFromJava() return " << tmpResult << " rather than 0." <<
+        maple::endl;
+  }
+  if (ucontext == nullptr) {
+    LOG(FATAL) << "ucontext is nullptr, lead to crash." << maple::endl;
+  }
+
+  mcontext_t *mcontext = &(ucontext->uc_mcontext);
+  uint32_t *pc = reinterpret_cast<uint32_t*>(mcontext->pc);
+
+  if (reinterpret_cast<uintptr_t>(info->si_addr) == static_cast<uintptr_t>(kSEGVAddrForClassUninitialized) ||
+      reinterpret_cast<uintptr_t>(info->si_addr) == static_cast<uintptr_t>(kSEGVAddrForClassInitializing)  ||
+      info->si_addr == &classInitProtectRegion[static_cast<int>(kClassUninitialized) - 1]) {
+    // case 1: segv triggered by class init
+    uint32_t *adrpPc = pc - adrpPcOffsetForClinit;
+    int64_t sigvCausedClinitCount = IncSigvCausedClinitCount(1);
+    VLOG(classinit) << "clinit segv " << sigvCausedClinit << std::endl;
+    VLOG(classinit) << "sigvCausedClinitCount" << sigvCausedClinitCount << std::endl;
+#ifdef USE_32BIT_REF
+    void *classinfo = MRT_GetAddress32ByAddress(AnalyzeClinitInstructionSequence(adrpPc));
+#else
+    void *classinfo = MRT_GetAddressByAddress(AnalyzeClinitInstructionSequence(adrpPc));
+#endif // USE_32BIT_REF
+    if (classinfo == nullptr) {
+      maplert::MRT_Panic();
+    }
+    return MRT_PrepareToHandleJavaSignal(ucontext, (RealHandler1)&MRT_TryInitClassOnDemand, classinfo);
+  } else if (reinterpret_cast<uintptr_t>(info->si_addr) == static_cast<uintptr_t>(kSEGVAddrForClassInitFailed)) {
+    // case 2: segv triggered by class init failure
+    uint32_t *adrpPc = pc - adrpPcOffsetForClinit;
+    int64_t sigvCausedClinitCount = IncSigvCausedClinitCount(1);
+    VLOG(classinit) << "clinit segv " << sigvCausedClinit << std::endl;
+    VLOG(classinit) << "sigvCausedClinitCount" << sigvCausedClinitCount << std::endl;
+#ifdef USE_32BIT_REF
+    void *classinfo = MRT_GetAddress32ByAddress(AnalyzeClinitInstructionSequence(adrpPc));
+#else
+    void *classinfo = MRT_GetAddressByAddress(AnalyzeClinitInstructionSequence(adrpPc));
+#endif // USE_32BIT_REF
+    char msg[kBufferSize] = { 0 };
+    if (sprintf_s(msg, sizeof(msg), "unexpected class initialization failure for classinfo encoded at %p",
+                  adrpPc) < 0) {
+      LOG(ERROR) << "HandleSigsegvFromJava sprintf_s fail" << maple::endl;
+    }
+    MplCheck(classinfo != nullptr, msg);
+    // this will actually invoke MRT_ThrowNoClassDefFoundErrorClassUnw(classinfo)
+    return MRT_PrepareToHandleJavaSignal(ucontext,
+                                         &MRT_ThrowNoClassDefFoundErrorClassUnw,
+                                         reinterpret_cast<ClassMetadata*>(classinfo));
+#ifdef LINKER_LAZY_BINDING
+  } else if (info->si_addr >= __BindingProtectRegion__ &&
+             info->si_addr < &__BindingProtectRegion__[kBindingStateMax]) {
+    // SEGV triggered by Linker binding.
+    VLOG(lazybinding) << "HandleSigsegvFromJava(), info->si_addr=" << info->si_addr <<
+        ", between {" << reinterpret_cast<void*>(__BindingProtectRegion__) <<
+        ", " << reinterpret_cast<void*>(&__BindingProtectRegion__[kBindingStateMax]) << "}" << maple::endl;
+    uint32_t *adrpPc = pc - kAdrpPcOffsetForLazy;
+    void *addr = reinterpret_cast<void*>(AnalyzeClinitInstructionSequence(adrpPc));
+    SignalInfo *pSignalInfo = new (std::nothrow) SignalInfo(pc, addr);
+    if (pSignalInfo == nullptr) {
+      LOG(FATAL) << "new SignalInfo failed" << maple::endl;
+    }
+    return MRT_PrepareToHandleJavaSignal(ucontext, reinterpret_cast<RealHandler1>(MRT_RequestLazyBindingForSignal),
+                                         pSignalInfo, nullptr, nullptr, kLazyBindingReturnPcOffset);
+#endif // LINKER_LAZY_BINDING
+  } else if (reinterpret_cast<uintptr_t>(info->si_addr) == kMplLazyLoadMagicNumber) {
+    // segv triggerd by lazy load
+    // 0:         ldr   wm [xn] // xm for 64bit
+    // 4:         ldr   wm [wm]
+    void *offsetEntry = AnalyzeLazyloadInstructionSequence(pc, ucontext);
+    if (offsetEntry != nullptr) {
+      return MRT_PrepareToHandleJavaSignal(ucontext, reinterpret_cast<RealHandler1>(MRT_FixOffsetTableLazily),
+                                           offsetEntry, nullptr, nullptr, kDecoupleReturnPcOffset);
+    } else {
+      return MRT_PrepareToHandleJavaSignal(ucontext, &MRT_ThrowImplicitNullPointerExceptionUnw, pc);
+    }
+  } else if (reinterpret_cast<uintptr_t>(info->si_addr) == kMplLazyStaticDecoupleMagicNumber ||
+             reinterpret_cast<uintptr_t>(info->si_addr) == kMplStaticDecoupleMagicNumber) {
+    return HandleStaticDecoupleSignal(*ucontext);
+  } else if (reinterpret_cast<uintptr_t>(info->si_addr) == kMplArrayClassCacheMagicNumber) {
+    return AnalyzeLoadArrayCacheInstructionSequence(pc, *ucontext);
+  } else if (reinterpret_cast<uintptr_t>(info->si_addr) < static_cast<uintptr_t>(maple::kPageSize)) {
+    // case 3: segv triggered by NPE
+    // this will actually invoke MRT_ThrowImplicitNullPointerExceptionUnw(pc)
+    // if not null may have compiler
+    if (info->si_addr != nullptr) {
+      LOG(ERROR) << " info->si_addr not null: " << std::hex << info->si_addr << " PC: " <<
+          std::hex << mcontext->pc << maple::endl;
+    }
+    return MRT_PrepareToHandleJavaSignal(ucontext, &MRT_ThrowImplicitNullPointerExceptionUnw, pc);
+  }
+  return false;
+}
+
+// Signal handler For Android, return value matters.
+extern "C" bool MRT_FaultHandler(int sig, siginfo_t *info, ucontext_t *ucontext, bool isFromJava) {
+  auto origErrno = errno;
+
+  if (ucontext == nullptr) {
+    LOG(FATAL) << "ucontext is nullptr, lead to crash." << maple::endl;
+  }
+  if (isFromJava) {
+    // signal handler is some kind of java-to-runtime stub frame, so we need to update the unwind context
+    mcontext_t *mcontext = &(ucontext->uc_mcontext);
+    MRT_UpdateLastUnwindContextIfReliable(reinterpret_cast<uint32_t*>(mcontext->pc + kAarch64InsnSize),
+                                          reinterpret_cast<void*>(mcontext->regs[kFP] /* FP */));
+  }
+
+  if (YieldpointSignalHandler(sig, info, ucontext)) {
+    errno = origErrno;
+    return true;
+  } else if (UNLIKELY(ThreadHelper::SuspendHandler())) {
+    timeutils::SleepForever();
+  } else if (isFromJava) {
+    bool ret = false;
+    switch (sig) {
+      case SIGSEGV:
+        ret = HandleSigsegvFromJava(info, ucontext);
+        break;
+      default: {
+        LOG(ERROR) << "maple runtime internal error: unexpected signal from java frame." << maple::endl;
+      }
+    }
+    return ret;
+  }
+
+  errno = origErrno;
+  return false;
+}
+
+// siginfo_t* info for future extention
+extern "C" bool MRT_FaultDebugHandler(int sig, siginfo_t *info __attribute__((unused)), void *context) {
+  if (context == nullptr) {
+    LOG(FATAL) << "context is nullptr, lead to crash." << maple::endl;
+  }
+  ucontext_t *ucontext = reinterpret_cast<ucontext_t*>(context);
+  mcontext_t *mcontext = &(ucontext->uc_mcontext);
+  switch (sig) {
+    case SIGTRAP: {
+      // x0 is addr of obj
+      JsanliteError(mcontext->regs[0]);
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  return false;
+}
+}
diff --git a/src/mrt/compiler-rt/src/arch/arm64/signal_handler_stub_arm64.S b/src/mrt/compiler-rt/src/arch/arm64/signal_handler_stub_arm64.S
new file mode 100644
index 0000000000000000000000000000000000000000..15e21ab5240e1c7a2f1df58ed1a507d917d63699
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/signal_handler_stub_arm64.S
@@ -0,0 +1,167 @@
+#define cfi_adjust_cfa_offset(off)	.cfi_adjust_cfa_offset off
+#define cfi_rel_offset(reg, off)	.cfi_rel_offset reg, off
+#define cfi_restore(reg)		.cfi_restore reg
+#define cfi_def_cfa_register(reg)	.cfi_def_cfa_register reg
+
+#define SignalStubFrameSize           (0x2c0)
+
+// This signal handler stub relies on MRT_PrepareToHandleJavaSignal to put continuation pc in x17.
+// Continuation pc describes the control flow after signal handling completes.
+
+        .text
+        .align 2
+        .global HandleJavaSignalStub
+        .hidden HandleJavaSignalStub
+        .type HandleJavaSignalStub, %function
+HandleJavaSignalStub:
+        .cfi_startproc
+        .cfi_return_column x17
+        sub  sp, sp, # SignalStubFrameSize
+        cfi_adjust_cfa_offset (SignalStubFrameSize)
+        stp  x29, x17, [sp]
+        cfi_rel_offset (x29, 0)
+        cfi_rel_offset (x17, 8)
+
+        mov  x29, sp
+        cfi_def_cfa_register (x29)
+
+        // save all non callee-saved registers which may be contaminated by calling
+        // the real signal handler.
+        stp  x0, x1, [sp, #0x10]
+        cfi_rel_offset (x0, 0x10)
+        cfi_rel_offset (x1, 0x18)
+
+        stp  x2, x3, [sp, #0x20]
+        cfi_rel_offset (x2, 0x20)
+        cfi_rel_offset (x3, 0x28)
+
+        stp  x4, x5, [sp, #0x30]
+        cfi_rel_offset (x4, 0x30)
+        cfi_rel_offset (x5, 0x38)
+
+        stp  x6, x7, [sp, #0x40]
+        cfi_rel_offset (x6, 0x40)
+        cfi_rel_offset (x7, 0x48)
+
+        stp  x8, x9, [sp, #0x50]
+        cfi_rel_offset (x8, 0x50)
+        cfi_rel_offset (x9, 0x58)
+
+        stp  x10, x11, [sp, #0x60]
+        cfi_rel_offset (x10, 0x60)
+        cfi_rel_offset (x11, 0x68)
+
+        stp  x12, x13, [sp, #0x70]
+        cfi_rel_offset (x12, 0x70)
+        cfi_rel_offset (x13, 0x78)
+
+        stp  x14, x15, [sp, #0x80]
+        cfi_rel_offset (x14, 0x80)
+        cfi_rel_offset (x15, 0x88)
+
+        stp  x16, x30, [sp, #0x90]
+        cfi_rel_offset (x16, 0x90)
+        cfi_rel_offset (x30, 0x98)
+
+        mrs x17, nzcv
+        stp  x18, x17, [sp, #0xa0]
+        cfi_rel_offset (x18, 0xa0)
+        cfi_rel_offset (nzcv, 0xa8)
+
+        stp   q0,  q1, [sp, #0xc0]
+        stp   q2,  q3, [sp, #0xe0]
+        stp   q4,  q5, [sp, #0x100]
+        stp   q6,  q7, [sp, #0x120]
+        stp   q8,  q9, [sp, #0x140]
+        stp  q10, q11, [sp, #0x160]
+        stp  q12, q13, [sp, #0x180]
+        stp  q14, q15, [sp, #0x1a0]
+        stp  q16, q17, [sp, #0x1c0]
+        stp  q18, q19, [sp, #0x1e0]
+        stp  q20, q21, [sp, #0x200]
+        stp  q22, q23, [sp, #0x220]
+        stp  q24, q25, [sp, #0x240]
+        stp  q26, q27, [sp, #0x260]
+        stp  q28, q29, [sp, #0x280]
+        stp  q30, q31, [sp, #0x2a0]
+
+        bl InvokeJavaSignalHandler
+        cbz   x0, .L_nochangex17
+        str   x0, [sp, #0x8]
+.L_nochangex17:
+
+        bl MRT_SetReliableUnwindContextStatus
+
+        bl IsThrowingExceptionByRet
+        cbz   x0,  .L_noexception
+        str   x0, [sp, #0x8]
+.L_noexception:
+        ldp   q0,  q1, [sp, #0xc0]
+        ldp   q2,  q3, [sp, #0xe0]
+        ldp   q4,  q5, [sp, #0x100]
+        ldp   q6,  q7, [sp, #0x120]
+        ldp   q8,  q9, [sp, #0x140]
+        ldp  q10, q11, [sp, #0x160]
+        ldp  q12, q13, [sp, #0x180]
+        ldp  q14, q15, [sp, #0x1a0]
+        ldp  q16, q17, [sp, #0x1c0]
+        ldp  q18, q19, [sp, #0x1e0]
+        ldp  q20, q21, [sp, #0x200]
+        ldp  q22, q23, [sp, #0x220]
+        ldp  q24, q25, [sp, #0x240]
+        ldp  q26, q27, [sp, #0x260]
+        ldp  q28, q29, [sp, #0x280]
+        ldp  q30, q31, [sp, #0x2a0]
+
+        ldp  x0, x1, [sp, #0x10]
+        cfi_restore (x0)
+        cfi_restore (x1)
+
+        ldp  x2, x3, [sp, #0x20]
+        cfi_restore (x2)
+        cfi_restore (x3)
+
+        ldp  x4, x5, [sp, #0x30]
+        cfi_restore (x4)
+        cfi_restore (x5)
+
+        ldp  x6, x7, [sp, #0x40]
+        cfi_restore (x6)
+        cfi_restore (x7)
+
+        ldp  x8, x9, [sp, #0x50]
+        cfi_restore (x8)
+        cfi_restore (x9)
+
+        ldp  x10, x11, [sp, #0x60]
+        cfi_restore (x10)
+        cfi_restore (x11)
+
+        ldp  x12, x13, [sp, #0x70]
+        cfi_restore (x12)
+        cfi_restore (x13)
+
+        ldp  x14, x15, [sp, #0x80]
+        cfi_restore (x14)
+        cfi_restore (x15)
+
+        ldp  x16, x30, [sp, #0x90]
+        cfi_restore (x16)
+        cfi_restore (x30)
+
+        ldp  x18, x17, [sp, #0xa0]
+        cfi_restore (x18)
+        msr  nzcv, x17
+        cfi_restore(nzcv)
+
+        ldp     x29, x17, [sp]
+        cfi_restore (x29)
+        cfi_restore (x17)
+
+        add  sp, sp, # SignalStubFrameSize
+        cfi_adjust_cfa_offset (-SignalStubFrameSize)
+
+        // we backup PC with x17 in PrepareToHandleJavaSignal already
+        ret x17
+        .cfi_endproc
+        .size HandleJavaSignalStub, .-HandleJavaSignalStub
diff --git a/src/mrt/compiler-rt/src/arch/arm64/yieldpoint_arm64.S b/src/mrt/compiler-rt/src/arch/arm64/yieldpoint_arm64.S
new file mode 100644
index 0000000000000000000000000000000000000000..a6e06eabfe1812c8fbf6037bd719d14b0c220214
--- /dev/null
+++ b/src/mrt/compiler-rt/src/arch/arm64/yieldpoint_arm64.S
@@ -0,0 +1,146 @@
+//---------------------------------------------------------------
+// This file defines assembly functions to support yieldpoints.
+//---------------------------------------------------------------
+  .text
+
+//---------------------------------------------------------------
+// MRT_YieldpointStub() will called when yieldpoint is taken.
+//
+// void MRT_YieldpointStub() {
+//    save_live_registers();
+//    lr = MRT_GetThreadYieldpointPC();
+//    MRT_YieldpointHandler(last_fp);
+//    restore_live_registers();
+//    return to lr;
+// }
+//
+//         fp ---> --------  0
+//                 |  q31 |
+//                 |  ... |
+//                 |  q0  |
+//                 --------
+//                 |  x29 |
+//                 |  x28 |
+//                 |  ... |
+//                 |  x0  |
+//                 --------
+//                 |  x30 | lr
+//                 |  x29 | fp
+//         sp ---> --------  -0x300
+//
+//---------------------------------------------------------------
+  .align 2
+  .global MRT_YieldpointStub
+  .type MRT_YieldpointStub, %function
+MRT_YieldpointStub:
+  .cfi_startproc
+  sub  sp, sp, 0x300
+  .cfi_def_cfa_offset 0x300
+
+  // save fp,lr on stack, follow the calling convention.
+  stp  x29, x30, [sp]
+  .cfi_offset 29, -0x300
+  .cfi_offset 30, -0x2f8
+
+  // save integer registers except LR(x30)
+  stp  x0,  x1,  [sp, 0x10]
+  stp  x2,  x3,  [sp, 0x20]
+  stp  x4,  x5,  [sp, 0x30]
+  stp  x6,  x7,  [sp, 0x40]
+  stp  x8,  x9,  [sp, 0x50]
+  stp  x10, x11, [sp, 0x60]
+  stp  x12, x13, [sp, 0x70]
+  stp  x14, x15, [sp, 0x80]
+  stp  x16, x17, [sp, 0x90]
+  stp  x18, x19, [sp, 0xa0]
+  stp  x20, x21, [sp, 0xb0]
+  stp  x22, x23, [sp, 0xc0]
+  stp  x24, x25, [sp, 0xd0]
+  stp  x26, x27, [sp, 0xe0]
+  stp  x28, x29, [sp, 0xf0]
+
+  // save scalar registers
+  stp  q0,  q1,  [sp, 0x100]
+  stp  q2,  q3,  [sp, 0x120]
+  stp  q4,  q5,  [sp, 0x140]
+  stp  q6,  q7,  [sp, 0x160]
+  stp  q8,  q9,  [sp, 0x180]
+  stp  q10, q11, [sp, 0x1a0]
+  stp  q12, q13, [sp, 0x1c0]
+  stp  q14, q15, [sp, 0x1e0]
+  stp  q16, q17, [sp, 0x200]
+  stp  q18, q19, [sp, 0x220]
+  stp  q20, q21, [sp, 0x240]
+  stp  q22, q23, [sp, 0x260]
+  stp  q24, q25, [sp, 0x280]
+  stp  q26, q27, [sp, 0x2a0]
+  stp  q28, q29, [sp, 0x2c0]
+  stp  q30, q31, [sp, 0x2e0]
+
+  // set current fp
+  add  x29, sp, 0
+  .cfi_def_cfa_register 29
+
+  // save condition flags
+  mrs  x28, NZCV
+
+  // set LR as the PC of yieldpoint,
+  // and save it to the proper slot of stack.
+  bl   MRT_GetThreadYieldpointPC
+  mov  x30, x0
+  str  x30, [sp, 0x08]
+
+  // call yieldpoint handler with current fp
+  mov  x0,  x29
+  bl   MRT_YieldpointHandler
+
+  // restore condition flags
+  msr  NZCV, x28
+
+  // restore integer registers except lr
+  ldp  x0,  x1,  [sp, 0x10]
+  ldp  x2,  x3,  [sp, 0x20]
+  ldp  x4,  x5,  [sp, 0x30]
+  ldp  x6,  x7,  [sp, 0x40]
+  ldp  x8,  x9,  [sp, 0x50]
+  ldp  x10, x11, [sp, 0x60]
+  ldp  x12, x13, [sp, 0x70]
+  ldp  x14, x15, [sp, 0x80]
+  ldp  x16, x17, [sp, 0x90]
+  ldp  x18, x19, [sp, 0xa0]
+  ldp  x20, x21, [sp, 0xb0]
+  ldp  x22, x23, [sp, 0xc0]
+  ldp  x24, x25, [sp, 0xd0]
+  ldp  x26, x27, [sp, 0xe0]
+  ldp  x28, x29, [sp, 0xf0]
+
+  // restore scalar registers
+  ldp  q0,  q1,  [sp, 0x100]
+  ldp  q2,  q3,  [sp, 0x120]
+  ldp  q4,  q5,  [sp, 0x140]
+  ldp  q6,  q7,  [sp, 0x160]
+  ldp  q8,  q9,  [sp, 0x180]
+  ldp  q10, q11, [sp, 0x1a0]
+  ldp  q12, q13, [sp, 0x1c0]
+  ldp  q14, q15, [sp, 0x1e0]
+  ldp  q16, q17, [sp, 0x200]
+  ldp  q18, q19, [sp, 0x220]
+  ldp  q20, q21, [sp, 0x240]
+  ldp  q22, q23, [sp, 0x260]
+  ldp  q24, q25, [sp, 0x280]
+  ldp  q26, q27, [sp, 0x2a0]
+  ldp  q28, q29, [sp, 0x2c0]
+  ldp  q30, q31, [sp, 0x2e0]
+
+  // restore fp, lr
+  ldp  x29, x30, [sp]
+
+  // restore stack pointer.
+  add  sp, sp, 0x300
+
+  .cfi_restore 29
+  .cfi_restore 30
+  .cfi_def_cfa 31, 0
+  ret
+  .cfi_endproc
+  .size MRT_YieldpointStub, .-MRT_YieldpointStub
diff --git a/src/mrt/compiler-rt/src/chelper.cpp b/src/mrt/compiler-rt/src/chelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6ff4d9adb6cfaaf62d9bb8442ab17ee287f528ca
--- /dev/null
+++ b/src/mrt/compiler-rt/src/chelper.cpp
@@ -0,0 +1,550 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "chelper.h"
+#include <sys/time.h>
+#include <sys/resource.h>
+#include "sizes.h"
+#include "chosen.h"
+#include "fast_alloc_inline.h"
+#include "libs.h"
+namespace maplert {
+extern "C" void *MRT_CLASSINFO(Ljava_2Flang_2Fref_2FWeakReference_3B);
+
+extern "C" inline void MRT_SetJavaClass(address_t objAddr, address_t klass) {
+  // set class.
+  StoreRefField(objAddr, kMrtKlassOffset, klass);
+  // initialize gc header from prototype.
+  MClass *cls = MObject::Cast<MClass>(klass);
+  if (auto gcInfo = reinterpret_cast<struct GCTibGCInfo*>(cls->GetGctib())) {
+    GCHeaderLVal(objAddr) |= gcInfo->headerProto;
+  }
+
+#if RC_TRACE_OBJECT
+  if (IsTraceObj(objAddr)) {
+    void *callerPc = __builtin_return_address(0);
+    LOG2FILE(kLogtypeRcTrace) << "Obj " << std::hex << reinterpret_cast<void*>(objAddr) << std::dec <<
+        " RC= " << RefCount(objAddr) << " New at " << std::endl;
+    util::PrintPCSymbolToLog(callerPc);
+  }
+#endif
+  // mark finalizable object.
+  // check class flag.
+  uint32_t classFlag = cls->GetFlag();
+  if (modifier::hasFinalizer(classFlag)) {
+    SetObjFinalizable(objAddr);
+    (*theAllocator).OnFinalizableObjCreated(objAddr);
+  }
+  if (cls->IsLazyBinding()) {
+    (void)LinkerAPI::Instance().LinkClassLazily(cls->AsJclass());
+  } else if (modifier::IsColdClass(classFlag)) {
+    LinkerAPI::Instance().ResolveColdClassSymbol(cls->AsJclass());
+  }
+}
+
+extern "C" void MCC_SetJavaClass(address_t objAddr, address_t klass) __attribute__((alias("MRT_SetJavaClass")));
+extern "C" inline void MRT_SetJavaArrayClass(address_t objAddr, address_t klass) {
+  // set class.
+  StoreRefField(objAddr, kMrtKlassOffset, klass);
+
+  // initialize gc header from prototype.
+  if (auto gcInfo = reinterpret_cast<struct GCTibGCInfo*>(MObject::Cast<MClass>(klass)->GetGctib())) {
+    GCHeaderLVal(objAddr) |= gcInfo->headerProto;
+  }
+
+  // array has no finalizer and it is not a reference,
+  // so we skip class flag check for array.
+  // make the store above visible to other thread
+  std::atomic_thread_fence(std::memory_order_release);
+}
+
+address_t MCC_Reflect_ThrowInstantiationError() {
+  MRT_ThrowNewException("java/lang/InstantiationError", nullptr);
+  return 0;
+}
+
+extern "C" void MRT_ReflectThrowNegtiveArraySizeException() {
+#if UNITTEST
+  __MRT_ASSERT(0 && "Array element number is negtive.");
+#else
+  MRT_ThrowNewExceptionUnw("java/lang/NegativeArraySizeException", nullptr);
+  __builtin_unreachable();
+#endif
+}
+
+extern "C" void MRT_SetThreadPriority(pid_t tid, int32_t priority) {
+  errno = 0;
+  int ret = ::setpriority(static_cast<int>(PRIO_PROCESS), static_cast<uint32_t>(tid), priority);
+  if (UNLIKELY(ret != 0 && errno != 0)) {
+    char errMsg[maple::kMaxStrErrorBufLen];
+    (void)strerror_r(errno, errMsg, sizeof(errMsg));
+    LOG(ERROR) << "::setpriority() in MRT_SetThreadPriority() failed with errno " <<
+        errno << ": " << errMsg << maple::endl;
+  }
+}
+
+#if RC_HOT_OBJECT_DATA_COLLECT
+const int kMaxClassNameLen = 256;
+const int kMaxProfileClassCount = 5;
+std::vector<std::string> LoadTraceClassName() {
+#ifdef __ANDROID__
+  std::string fileName = "/etc/maple_rc_profile_classes_name.txt";
+#else
+  std::string fileName = "./maple_rc_profile_classes_name.txt";
+#endif
+  std::ifstream ifs(fileName, std::ifstream::in);
+  std::vector<std::string> classNames;
+  if (!ifs.is_open()) {
+    LOG(INFO) << "LoadTraceClassName open file failed, no permission or not exist\n";
+    return classNames;
+  }
+  char className[kMaxClassNameLen];
+  int profileClassCount = 0;
+  // only read kMaxProfileClassCount line of file
+  while (ifs.getline(className, kMaxClassNameLen) && (profileClassCount++ < kMaxProfileClassCount)) {
+    std::string name(className);
+    if (name.size() <= 0) {
+      continue;
+    }
+    // class name should start with 'L' or '['
+    if ((name[0] == 'L') || (name[0] == '[')) {
+      classNames.push_back(name);
+    }
+  }
+  LOG(INFO) << "LoadTraceClassName success, trace class size = " << classNames.size() << maple::endl;
+  ifs.close();
+  return classNames;
+}
+
+static std::vector<std::string> traceClassesName = LoadTraceClassName();
+
+static bool IsTraceClass(address_t klass) {
+  if (klass == 0) {
+    return false;
+  }
+  char *className = MObject::Cast<MClass>(klass)->GetName();
+  if (className == nullptr) {
+    return false;
+  }
+  for (auto name : traceClassesName) {
+    if (name.compare(0, kMaxClassNameLen, className) == 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static inline void setObjPc(address_t objAddr, unsigned long *pc) {
+  for (size_t i = 0; i < kTrackFrameNum; ++i) {
+    *reinterpret_cast<unsigned long*>(objAddr + kOffsetTrackPC + kDWordBytes * i) = pc[i];
+  }
+}
+
+static void DumpObjectBackTrace(address_t obj, address_t klass) {
+  if (!IsTraceClass(klass)) {
+    return;
+  }
+  size_t limit = 7; // the stack depth limit of recording new object in debug
+  std::vector<uint64_t> stackArray;
+  MapleStack::FastRecordCurrentStackPCsByUnwind(stackArray, limit);
+  size_t size = stackArray.size();
+  unsigned long pc[kTrackFrameNum] = { 0 };
+  // only track last kTrackFrameNum frame
+  size_t skip = limit - kTrackFrameNum;
+  for (size_t i = skip; i < limit && i < size; ++i) {
+    pc[i - skip] = static_cast<unsigned long>(stackArray[i]);
+  }
+  // set track PCs to object header
+  setObjPc(obj, pc);
+}
+#endif // RC_HOT_OBJECT_DATA_COLLECT
+
+#if ALLOC_USE_FAST_PATH
+#define MCC_SLOW_NEW_OBJECT MRT_NewObject
+#else
+#define MCC_SLOW_NEW_OBJECT MCC_NewObj_fixed_class
+#endif
+
+extern "C" address_t MCC_SLOW_NEW_OBJECT(address_t klass) {
+  MClass *cls = MObject::Cast<MClass>(klass);
+  uint32_t mod = cls->GetModifier();
+  if (UNLIKELY(modifier::IsAbstract(mod) || modifier::IsInterface(mod))) {
+    std::string clsName;
+    cls->GetBinaryName(clsName);
+    MRT_ThrowNewExceptionUnw("java/lang/InstantiationError", clsName.c_str());
+    return 0;
+  }
+  address_t result = (*theAllocator).NewObj(cls->GetObjectSize());
+  if (UNLIKELY(result == 0)) {
+    (*theAllocator).OutOfMemory();
+  }
+  MRT_SetJavaClass(result, klass);
+#if RC_HOT_OBJECT_DATA_COLLECT
+  DumpObjectBackTrace(result, klass);
+#endif
+  return result;
+}
+
+static inline address_t AllocatorNewArray(size_t elemSize, size_t nElems) {
+  if (UNLIKELY(nElems > kAllocArrayMaxSize / elemSize)) {
+    return 0;
+  }
+  size_t size = kJavaArrayContentOffset + elemSize * nElems;
+  return (*theAllocator).NewObj(size);
+}
+
+extern "C" address_t MRT_ChelperNewobjFlexible(size_t elemSize, size_t len, address_t klass, bool isJNI) {
+  address_t result = AllocatorNewArray(elemSize, len);
+  if (UNLIKELY(result == 0)) {
+    (*theAllocator).OutOfMemory(isJNI);
+    return result;
+  }
+  ArrayLength(result) = static_cast<uint32_t>(len);
+  MRT_SetJavaArrayClass(result, klass);
+  return result;
+}
+
+const unsigned int kClassObjectFlag = 0xF0;
+
+static inline MClass *GetArrayClass(const char *classNameOrClassObj, address_t callerObj, unsigned long classFlag) {
+  if (classFlag & kClassObjectFlag) {
+    return reinterpret_cast<MClass*>(const_cast<char*>(classNameOrClassObj));
+  } else if (classFlag & (~kClassObjectFlag)) {
+    return WellKnown::GetWellKnowClassWithFlag(static_cast<uint8_t>(classFlag & (~kClassObjectFlag)),
+                                               *MObject::Cast<MClass>(callerObj),
+                                               classNameOrClassObj);
+  } else {
+    return MClass::JniCast(MCC_GetClass(MObject::Cast<MClass>(callerObj)->AsJclass(), classNameOrClassObj));
+  }
+}
+
+#define MCC_SLOW_NEW_ARRAY MCC_NewObj_flexible_cname
+address_t MCC_NewObj_flexible_cname(size_t elemSize,
+                                    size_t nElems,
+                                    const char *classNameOrClassObj,
+                                    address_t callerObj,
+                                    unsigned long classFlag) {
+  // array length is set in NewArray
+  if (nElems > kMrtMaxArrayLength) {
+    MRT_ReflectThrowNegtiveArraySizeException();
+  }
+  MClass *klass = GetArrayClass(classNameOrClassObj, callerObj, classFlag);
+  __MRT_ASSERT(klass != nullptr, "MCC_NewObj_flexible_cname klass nullptr");
+  address_t result = AllocatorNewArray(elemSize, nElems);
+  if (UNLIKELY(result == 0)) {
+    (*theAllocator).OutOfMemory();
+  }
+  ArrayLength(result) = static_cast<uint32_t>(nElems);
+  MRT_SetJavaArrayClass(result, klass->AsUintptr());
+
+#if RC_HOT_OBJECT_DATA_COLLECT
+  DumpObjectBackTrace(result, klass->AsUintptr());
+#endif
+  return result;
+}
+
+#if ALLOC_USE_FAST_PATH
+void MRT_SetFastAlloc(ClassMetadata *classMetadata) {
+  __MRT_ASSERT(classMetadata != nullptr, "classMetadata is nullptr in MRT_SetFastAlloc");
+  uint16_t flag = classMetadata->flag;
+  MClass *cls = reinterpret_cast<MClass*>(classMetadata);
+  if (UNLIKELY(modifier::IsFastAllocClass(flag))) {
+    LOG(ERROR) << "fast path: init repeated or bad flag " << cls->GetName() << maple::endl;
+    classMetadata->flag &= ~modifier::kClassFastAlloc;
+    return;
+  }
+  if (UNLIKELY(modifier::hasFinalizer(flag) ||
+               modifier::IsArrayClass(flag) ||
+               // potentially, we can enable fast path for lazy/cold classes,
+               // but, watch out for race condition
+               modifier::IsLazyBindingClass(flag) ||
+               modifier::IsColdClass(flag))) {
+    return;
+  }
+  uint32_t mod = cls->GetModifier();
+  if (UNLIKELY(modifier::IsAbstract(mod) || modifier::IsInterface(mod))) {
+    return;
+  }
+  size_t objSize = cls->GetObjectSize();
+  size_t alignedSize = AllocUtilRndUp(objSize, kAllocAlign);
+  if (LIKELY(ROSIMPL_IS_LOCAL_RUN_SIZE((alignedSize + ROSIMPL_HEADER_ALLOC_SIZE)))) {
+    classMetadata->sizeInfo.objSize = alignedSize;
+    classMetadata->flag |= modifier::kClassFastAlloc;
+  }
+}
+#endif
+
+// try to inline in this .cpp
+__attribute__((always_inline))
+extern "C" address_t MCC_NewObject(address_t klass) {
+  address_t objAddr = MRT_TryNewObject(klass);
+  if (LIKELY(objAddr != 0)) {
+    return objAddr;
+  }
+  return MCC_SLOW_NEW_OBJECT(klass);
+}
+
+#if ALLOC_USE_FAST_PATH
+// change compiler invocation so that this redirection can be removed!
+// inline helps when this function is used in this .cpp (e.g., new permanent)
+inline address_t MCC_NewObj_fixed_class(address_t klass) {
+  return MCC_NewObject(klass);
+}
+#endif
+
+extern "C" address_t MCC_NewArray8(size_t nElems, address_t klass) {
+  address_t objAddr = MRT_TryNewArray<kElemByte>(nElems, klass);
+  if (LIKELY(objAddr != 0)) {
+    return objAddr;
+  }
+  const char *param = reinterpret_cast<const char*>(klass);
+  return MCC_SLOW_NEW_ARRAY(1, nElems, param, 0, kClassObjectFlag); // 1 is 8bit
+}
+
+extern "C" address_t MCC_NewArray16(size_t nElems, address_t klass) {
+  address_t objAddr = MRT_TryNewArray<kElemHWord>(nElems, klass);
+  if (LIKELY(objAddr != 0)) {
+    return objAddr;
+  }
+  const char *param = reinterpret_cast<const char*>(klass);
+  return MCC_SLOW_NEW_ARRAY(2, nElems, param, 0, kClassObjectFlag); // 2 is 16bit
+}
+
+extern "C" address_t MCC_NewArray32(size_t nElems, address_t klass) {
+  address_t objAddr = MRT_TryNewArray<kElemWord>(nElems, klass);
+  if (LIKELY(objAddr != 0)) {
+    return objAddr;
+  }
+  const char *param = reinterpret_cast<const char*>(klass);
+  return MCC_SLOW_NEW_ARRAY(4, nElems, param, 0, kClassObjectFlag); // 4 is 32bit
+}
+
+extern "C" address_t MCC_NewArray64(size_t nElems, address_t klass) {
+  address_t objAddr = MRT_TryNewArray<kElemDWord>(nElems, klass);
+  if (LIKELY(objAddr != 0)) {
+    return objAddr;
+  }
+  const char *param = reinterpret_cast<const char*>(klass);
+  return MCC_SLOW_NEW_ARRAY(8, nElems, param, 0, kClassObjectFlag); // 8 is 64bit
+}
+
+extern "C" address_t MCC_NewArray(size_t nElems, const char *descriptor, address_t callerObj) {
+  address_t objAddr = MRT_TryNewArray<kElemWord>(nElems, reinterpret_cast<address_t>(
+      MCC_GetClass(MObject::Cast<MClass>(callerObj)->AsJclass(), descriptor)));
+  if (LIKELY(objAddr != 0)) {
+    return objAddr;
+  }
+  // this will go the get class path
+  return MCC_SLOW_NEW_ARRAY(4, nElems, descriptor, callerObj, 0); // 4 is 32bit
+}
+
+#ifdef USE_32BIT_REF
+#if !defined(__ANDROID__) && defined(__arm__)
+constexpr address_t kKlassHighestBoundary = 0xffffffff;
+#else
+constexpr address_t kKlassHighestBoundary = 0xdfffffff;
+#endif // __ANDROID__
+#if __MRT_DEBUG
+constexpr address_t kKlassLowestBoundary = 0x80000000;
+#endif
+#endif //USE_32BIT_REF
+
+static inline void SetPermanentObjectClass(address_t objAddr, address_t klass) {
+#ifdef USE_32BIT_REF
+#if __MRT_DEBUG
+  if ((klass > kKlassHighestBoundary) || (klass < kKlassLowestBoundary)) {
+    LOG(FATAL) << "klass is not correct: " << std::hex << klass << std::dec <<
+        MObject::Cast<MClass>(klass)->GetName() << maple::endl;
+  }
+#endif
+#endif //USE_32BIT_REF
+  // set class.
+  StoreRefField(objAddr, kMrtKlassOffset, klass);
+
+  // handle cold class.
+  if (MObject::Cast<MClass>(klass)->IsLazyBinding()) {
+    (void)LinkerAPI::Instance().LinkClassLazily(reinterpret_cast<jclass>(klass));
+  } else if (MObject::Cast<MClass>(klass)->IsColdClass()) {
+    LinkerAPI::Instance().ResolveColdClassSymbol(reinterpret_cast<jclass>(klass));
+  }
+}
+
+static inline void SetPermanentArrayClass(address_t objAddr, address_t klass) {
+#ifdef USE_32BIT_REF
+  if (UNLIKELY(klass > kKlassHighestBoundary)) {
+    LOG(FATAL) << "klass is not correct: " << std::hex << klass << std::dec <<
+        MObject::Cast<MClass>(klass)->GetName() << maple::endl;
+  }
+#endif //USE_32BIT_REF
+  // set class.
+  StoreRefField(objAddr, kMrtKlassOffset, klass);
+}
+
+static inline bool HasChildReference(const MClass *klass) {
+  __MRT_ASSERT(klass != nullptr, "kclass is nullptr in HasChildReference");
+  const GCTibGCInfo *gcInfo = reinterpret_cast<GCTibGCInfo*>(klass->GetGctib());
+  return (gcInfo == nullptr || (gcInfo->headerProto & kHasChildRef) != 0);
+}
+
+address_t MCC_NewPermanentObject(address_t klass) {
+  // allocate permanent Reference or finalizable objects is not allowed,
+  // we fallback to allocate them in heap space. this means the @Permanent
+  // annotation for Reference or finalizable objects is ignored.
+  const MClass *javaClass = MObject::Cast<MClass>(klass);
+  const uint32_t classFlag = javaClass->GetFlag();
+  if (UNLIKELY(modifier::IsReferenceClass(classFlag) || modifier::hasFinalizer(classFlag))) {
+    return MCC_NewObj_fixed_class(klass);
+  }
+
+  // if object has child reference, we allocate it in heap
+  // and set it as rc overflowed so that rc operations are ignored.
+  if (HasChildReference(javaClass)) {
+    address_t result = MCC_NewObj_fixed_class(klass);
+    SetRCOverflow(result);
+    return result;
+  }
+
+  // allocate object in permanent space, without object header.
+  address_t result = MRT_AllocFromPerm(javaClass->GetObjectSize());
+  if (UNLIKELY(result == 0)) {
+    return 0;
+  }
+  // set class.
+  SetPermanentObjectClass(result, klass);
+
+  return result;
+}
+
+extern "C" address_t MCC_NewPermObject(address_t klass) __attribute__((alias("MCC_NewPermanentObject")));
+
+address_t MCC_NewPermanentArray(size_t elemSize,
+                                size_t nElems,
+                                const char *classNameOrClassObj,
+                                address_t callerObj,
+                                unsigned long classFlag) {
+  // determine array class.
+  MClass *klass = GetArrayClass(classNameOrClassObj, callerObj, classFlag);
+  __MRT_ASSERT(klass != nullptr, "MCC_NewPermanentArray klass nullptr");
+
+  // for object array and length > 0, we allocate it in heap
+  // and set it as rc overflowed so that rc operations are ignored.
+  if (HasChildReference(klass) && nElems != 0) {
+    // this still calls slow path, should switch to fast path
+    address_t result = MCC_NewObj_flexible_cname(elemSize, nElems, classNameOrClassObj, callerObj, classFlag);
+    SetRCOverflow(result);
+    return result;
+  }
+
+  // check length.
+  if (UNLIKELY(nElems > kMrtMaxArrayLength)) {
+    MRT_ReflectThrowNegtiveArraySizeException();
+  }
+
+  // allocate array in permanent space, without object header.
+  const size_t totalSize = kJavaArrayContentOffset + elemSize * nElems;
+  address_t result = MRT_AllocFromPerm(totalSize);
+  if (UNLIKELY(result == 0)) {
+    return 0;
+  }
+  // set class.
+  SetPermanentArrayClass(result, reinterpret_cast<address_t>(klass));
+
+  // set array length.
+  ArrayLength(result) = static_cast<uint32_t>(nElems);
+
+  return result;
+}
+
+template<ArrayElemSize elemSizeExp>
+static address_t MRT_NewPermArray(size_t nElems, address_t klass) {
+  // objects in permanent space cannot have child references, use normal heap
+  if (HasChildReference(MObject::Cast<MClass>(klass)) && nElems != 0) {
+    address_t objAddr = MRT_TryNewArray<elemSizeExp>(nElems, klass);
+    if (UNLIKELY(objAddr == 0)) {
+      const char *param = reinterpret_cast<const char*>(klass);
+      objAddr = MCC_SLOW_NEW_ARRAY(1 << elemSizeExp, nElems, param, 0, kClassObjectFlag);
+    }
+    SetRCOverflow(objAddr);
+    return objAddr;
+  }
+
+  if (UNLIKELY(nElems > kMrtMaxArrayLength)) {
+    MRT_ReflectThrowNegtiveArraySizeException();
+  }
+  size_t objSize = kJavaArrayContentOffset + (nElems << elemSizeExp);
+  address_t objAddr = MRT_AllocFromPerm(objSize);
+  if (UNLIKELY(objAddr == 0)) {
+    return 0;
+  }
+  // permanent allocator does not properly throw OOM, it will just abort
+  SetPermanentArrayClass(objAddr, klass);
+  ArrayLength(objAddr) = static_cast<uint32_t>(nElems);
+  return objAddr;
+}
+
+extern "C" address_t MCC_NewPermArray8(size_t nElems, address_t klass) {
+  return MRT_NewPermArray<kElemByte>(nElems, klass);
+}
+
+extern "C" address_t MCC_NewPermArray16(size_t nElems, address_t klass) {
+  return MRT_NewPermArray<kElemHWord>(nElems, klass);
+}
+
+extern "C" address_t MCC_NewPermArray32(size_t nElems, address_t klass) {
+  return MRT_NewPermArray<kElemWord>(nElems, klass);
+}
+
+extern "C" address_t MCC_NewPermArray64(size_t nElems, address_t klass) {
+  return MRT_NewPermArray<kElemDWord>(nElems, klass);
+}
+
+address_t MCC_NewPermArray(size_t nElems, const char *descriptor, address_t callerObj) {
+  return MRT_NewPermArray<kElemWord>(nElems, reinterpret_cast<address_t>(
+      MCC_GetClass(MObject::Cast<MClass>(callerObj)->AsJclass(), descriptor)));
+}
+
+  // set object rc overflow to ignore rc operation
+extern "C" void MRT_SetObjectPermanent(address_t objAddr) {
+  if (!IS_HEAP_OBJ(objAddr)) {
+    return;
+  }
+  SetRCOverflow(objAddr);
+}
+
+extern "C" void MCC_SetObjectPermanent(address_t objAddr) __attribute__((alias("MRT_SetObjectPermanent")));
+
+extern "C" void MRT_CheckRefCount(address_t objAddr, uint32_t index) {
+  if (!IS_HEAP_OBJ(objAddr)) {
+    return;
+  }
+
+  uint32_t rc = RefCount(objAddr);
+  if (rc == 0) {
+#ifdef __ANDROID__
+    LOG(ERROR) << "Obj = 0x" << std::hex << objAddr << " RCHeader = 0x" << RCHeader(objAddr) <<
+        " GCHeader = 0x" << GCHeader(objAddr) <<
+        " LockWord = 0x" << *(reinterpret_cast<uint32_t*>(objAddr + kLockWordOffset)) <<
+        " Index = " << std::dec << index << ", RC Fatal Error is detected." << std::endl;
+#else
+    std::cout << "Obj = 0x" << std::hex << objAddr << " RCHeader = 0x" << RCHeader(objAddr) <<
+        " GCHeader = 0x" << GCHeader(objAddr) <<
+        " LockWord = 0x" << *(reinterpret_cast<uint32_t*>(objAddr + kLockWordOffset)) <<
+        " Index = " << std::dec << index << ", RC Fatal Error is detected." << std::endl;
+#endif
+    HandleRCError(objAddr);
+  }
+}
+
+extern "C" void MCC_CheckRefCount(address_t objAddr, uint32_t index) __attribute__((alias("MRT_CheckRefCount")));
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/chosen.cpp b/src/mrt/compiler-rt/src/chosen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e9b99e5975d479f8450cceb9a3b5ba5bdc60a82e
--- /dev/null
+++ b/src/mrt/compiler-rt/src/chosen.cpp
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "chosen.h"
+
+namespace maplert {
+// Actual instances
+ImmortalWrapper<BumpPointerAlloc> permAllocator("maple_alloc_perm", kPermMaxSpaceSize);
+ImmortalWrapper<BumpPointerAlloc> zterpMetaAllocator("maple_alloc_zterp_meta", kZterpMaxSpaceSize);
+ImmortalWrapper<MetaAllocator> metaAllocator("maple_alloc_meta", kMetaMaxSpaceSize);
+ImmortalWrapper<DecoupleAllocator> decoupleAllocator("maple_alloc_decouple", kDecoupleMaxSpaceSize);
+ImmortalWrapper<ZterpStaticRootAllocator> zterpStaticRootAllocator("maple_alloc_zterp_static_root",
+                                                                   kZterpMaxSpaceSize);
+ImmortalWrapper<TheAllocator> theAllocator;
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/cinterface.cpp b/src/mrt/compiler-rt/src/cinterface.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e49e651eb168b53cf4e766e3368c17571d583cef
--- /dev/null
+++ b/src/mrt/compiler-rt/src/cinterface.cpp
@@ -0,0 +1,1665 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <sys/syscall.h>
+#include "mm_config.h"
+#include "mm_utils.h"
+#include "sizes.h"
+#include "collector/stats.h"
+#include "chosen.h"
+#include "yieldpoint.h"
+#include "mutator_list.h"
+#include "profile.h"
+#include "collector/cp_generator.h"
+#include "allocator/bp_allocator_inlined.h"
+#include "mrt_poisonstack.h"
+#include "collector/native_gc.h"
+#include "java_primitive_ops.h"
+#include "libs.h"
+
+#if SAFEREGION_CHECK && __MRT_DEBUG
+static void LogSlow(const char *fmt, ...) {
+  const int bufSize = 128;
+  char buf[bufSize] = { '\0' };
+  const char *toPrint = buf;
+  va_list ap;
+  va_start(ap, fmt);
+  int rv = vsnprintf_s(buf, bufSize, bufSize - 1, fmt, ap);
+  if (rv == -1) {
+    toPrint = "Error when calling vsnprintf_s.";
+  }
+  va_end(ap);
+
+#ifdef __ANDROID__
+  LOG(ERROR) << toPrint << maple::endl;
+#else
+  fprintf(stderr, "%s\n", toPrint);
+  fflush(stderr);
+#endif
+}
+#endif
+
+#if SAFEREGION_CHECK && __MRT_DEBUG
+#define CHECK_SAFEREGION(MSG, ...) do { \
+  if (UNLIKELY(TLMutator().InSaferegion())) { \
+    LogSlow("In saferegion: " MSG, ##__VA_ARGS__); \
+    util::print_backtrace(); \
+    abort(); \
+  } \
+} while (0)
+#else
+#define CHECK_SAFEREGION(MSG, ...)  ((void)0)
+#endif
+
+#if __MRT_DEBUG
+#define MRT_ASSERT_RC_NZ(rc, msg, obj, rcHeader) do {                             \
+  if (rc == 0) {                                                                  \
+    LOG(ERROR) << msg << "; obj: " << std::hex << reinterpret_cast<void*>(obj) << \
+        ", rc header: 0x" << std::hex << rcHeader;                                \
+    HandleRCError(obj);                                                           \
+  }                                                                               \
+} while (0)
+// this is used to check rc updates
+// the update function must return an rc header
+#define MRT_CallAndCheckRC(fcall, obj) do {                                  \
+  uint32_t rcHeader = fcall;                                                 \
+  MRT_ASSERT_RC_NZ(GetRCFromRCHeader(rcHeader), "rc == 0", obj, rcHeader);   \
+} while (0)
+#else
+#define MRT_ASSERT_RC_NZ(rc, msg, obj, rcHeader)
+// we still call the update function, but do not check the returned rc header
+#define MRT_CallAndCheckRC(fcall, obj) (void)fcall
+#endif
+namespace maplert {
+static inline void CheckObjAllocated(address_t obj) {
+#ifdef DISABLE_RC_DUPLICATE
+  if (IS_HEAP_ADDR(obj) && !IsAllocatedByAllocator(obj)) {
+    HandleRCError(obj);
+  }
+#else
+  (void)obj;
+#endif
+}
+
+void MCC_CheckObjAllocated(address_t obj) {
+  CheckObjAllocated(obj);
+}
+
+template<bool isVolatile>
+static inline void GCWriteField(address_t obj, address_t *fieldAddr, address_t value) {
+  CheckObjAllocated(value);
+  CheckObjAllocated(obj);
+  TLMutator().SatbWriteBarrier(obj, *reinterpret_cast<reffield_t*>(fieldAddr));
+  if (isVolatile) {
+    std::atomic<reffield_t> &volatileFieldAddr = AddrToLValAtomic<reffield_t>(reinterpret_cast<address_t>(fieldAddr));
+    volatileFieldAddr.store(AddressToRefField(value), std::memory_order_release);
+  } else {
+    StoreRefField(fieldAddr, value);
+  }
+}
+
+template<bool isVolatile>
+static inline address_t GCLoadField(address_t *fieldAddr) {
+  address_t value;
+  if (isVolatile) {
+    std::atomic<reffield_t> &volatileFieldAddr = AddrToLValAtomic<reffield_t>(reinterpret_cast<address_t>(fieldAddr));
+    value = volatileFieldAddr.load(std::memory_order_acquire);
+  } else {
+    value = LoadRefField(fieldAddr);
+  }
+  CheckObjAllocated(value);
+  return value;
+}
+
+extern "C" {
+
+// Initialize the global heap allocator.
+bool MRT_GCInitGlobal(const VMHeapParam &vmHeapParam) {
+  Collector::Create(vmHeapParam.gcOnly);
+  GCLog().Init(vmHeapParam.enableGCLog);
+  (*theAllocator).Init(vmHeapParam);
+  Collector::Instance().Init();
+  NativeGCStats::Instance().SetIsEpochBasedTrigger(vmHeapParam.isZygote);
+  return true;
+}
+
+// finalize the global heap allocator
+bool MRT_GCFiniGlobal() {
+  Collector::Instance().Fini();
+  return true;
+}
+
+void MRT_GCPreFork() {
+  // Close the GC log
+  GCLog().OnPreFork();
+
+  // stop threads before fork.
+  Collector::Instance().StopThread();
+  MRT_StopProcessReferences();
+
+  // wait threads stopped.
+  Collector::Instance().JoinThread();
+  MRT_WaitProcessReferencesStopped();
+
+  // confirm all threads stopped.
+  util::WaitUntilAllThreadsStopped();
+  CreateAppStringPool();
+  Collector &collector = Collector::Instance();
+  __MRT_ASSERT(collector.IsZygote(), "not zygote in perfork");
+  if (collector.Type() == kNaiveRC && static_cast<NaiveRCCollector&>(collector).HasWeakRelease()) {
+    uint64_t startTime = timeutils::NanoSeconds();
+    auto clearWeakField = [](reffield_t &field, uint64_t kind) {
+      address_t ref = RefFieldToAddress(field);
+      if (kind == kWeakRefBits && IS_HEAP_ADDR(ref) && IsWeakCollected(ref)) {
+        field = 0;
+        // maintian rc but not release, to avoid new weak collector object
+        // rc verify can pass but might leave some object and wait gc clear
+        // only thread here, no racing
+        (void)UpdateRC<0, -1, 0>(ref);
+      }
+    };
+    (*theAllocator).ForEachObjUnsafe([&clearWeakField](address_t obj) {
+      if (!IsArray(obj)) {
+        ForEachRefField(obj, clearWeakField);
+      }
+    }, OnlyVisit::kVisitAll);
+    LOG(INFO) << "prefork clear weak takes " << (timeutils::NanoSeconds() - startTime) << "ns";
+    static_cast<NaiveRCCollector&>(collector).SetHasWeakRelease(false);
+  }
+  (*theAllocator).OnPreFork();
+}
+
+void MRT_GCPostForkChild(bool isSystem) {
+  // Re-open the GC log
+  GCLog().OnPostFork();
+  NativeGCStats::Instance().SetIsEpochBasedTrigger(isSystem);
+  maplert::stats::gcStats->InitialGCThreshold(isSystem);
+  maplert::stats::gcStats->InitialGCProcessName();
+  // init collector after fork in child.
+  Collector::Instance().SetIsSystem(isSystem);
+  Collector::Instance().InitAfterFork();
+
+  if (!isSystem) {
+    MRT_SendBackgroundGcJob(true);
+  }
+
+  // init yieldpoint after fork.
+  YieldpointInitAfterFork();
+}
+
+void MRT_ForkInGC(bool runInGC) {
+  if (runInGC && Collector::Instance().Type() == kNaiveRC) {
+    uint64_t startTime = timeutils::NanoSeconds();
+    Collector::SwitchToGCOnFork();
+    LOG(INFO) << "switch collector success " << (static_cast<int32_t>(Collector::Instance().Type())) <<
+        " spent " << (timeutils::NanoSeconds() - startTime) << "ns" << maple::endl;
+  }
+}
+
+void MRT_GCPostForkCommon(bool isZygote) {
+  if (isZygote) {
+    LinkerAPI::Instance().ReleaseBootPhaseMemory(true, false);
+  }
+  Collector::Instance().SetIsZygote(isZygote);
+  // start gc thread(s) after fork.
+  Collector::Instance().StartThread(isZygote);
+}
+
+void MRT_RegisterNativeAllocation(size_t byte) {
+  NativeGCStats::Instance().RegisterNativeAllocation(byte);
+}
+
+void MRT_RegisterNativeFree(size_t byte) {
+  NativeGCStats::Instance().RegisterNativeFree(byte);
+}
+
+void MRT_NotifyNativeAllocation() {
+  NativeGCStats::Instance().NotifyNativeAllocation();
+}
+
+#if RC_TRACE_OBJECT
+address_t tracingObject = 0;
+void __attribute__((noinline)) TraceRefRC(address_t obj, uint32_t rc, const char *msg) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    if ((tracingObject != 0 && obj == tracingObject) || IsTraceObj(obj)) {
+      void *callerPc = __builtin_return_address(1);
+      LOG2FILE(kLogtypeRcTrace) <<  "Obj " << std::hex << reinterpret_cast<void*>(obj) << std::dec <<
+          " RC=" << rc << (SkipRC(rc) ? " (inaccurate: rc operation skipped) " : " ") << msg << " ";
+      util::PrintPCSymbolToLog(callerPc);
+    }
+  }
+}
+#endif
+
+// Start GC-module for the process. It should always called from the "main"
+// thread.
+void MRT_GCStart() {
+  // main-thread doesn't have this created yet.
+  (*theAllocator).NewOOMException();
+}
+
+// Initialize the thread-local heap allocator. It should be called when a
+// mutator thread is created.
+// isMain: whether it's the "main" thread.
+bool MRT_GCInitThreadLocal(bool isMain) {
+  // we should not call this function if current mutator already initialized.
+#if __MRT_DEBUG
+  if (UNLIKELY(TLMutatorPtr() != nullptr || TLAllocMutatorPtr() != nullptr)) {
+    LOG(FATAL) << "MRT_GCInitThreadLocal() called on active mutator: " <<
+        TLMutatorPtr() << " " << TLAllocMutatorPtr() << maple::endl;
+  }
+#endif
+
+  // create thread local mutator.
+  Mutator *mutator = nullptr;
+  if (Collector::Instance().Type() == kNaiveRC) {
+    mutator = new (std::nothrow) NaiveRCMutator(Collector::Instance());
+  } else {
+    mutator = new (std::nothrow) MarkSweepMutator(Collector::Instance());
+  }
+  TheAllocMutator *allocMutator = new (std::nothrow) TheAllocMutator();
+
+  // ensure mutator successfully created.
+  __MRT_ASSERT(mutator != nullptr && allocMutator != nullptr, "Out of memory");
+
+  // add key thread local variable's handle to thread's local-storage-area to allow
+  // fast access.
+  maple::tls::StoreTLS(mutator, maple::tls::kSlotMutator);
+  maple::tls::StoreTLS(allocMutator, maple::tls::kSlotAllocMutator);
+
+  // Set up the stack begin pointer.  We assume the caller calls this function
+  // before calling any Java function.  It is primarily used by conservative
+  // stack scanners, because an exact stack scanner can always identify the
+  // stack-bottom function.
+  pthread_attr_t attr;
+  void *stackAddr = nullptr;
+  size_t stackSize;
+  int tmpResult = pthread_getattr_np(pthread_self(), &attr);
+  if (tmpResult != 0) {
+    LOG(FATAL) << "pthread_getattr_np() in MRT_GCInitThreadLocal() return " <<
+        tmpResult << " rather than 0" << maple::endl;
+  };
+  tmpResult = pthread_attr_getstack(&attr, &stackAddr, &stackSize);
+  if (tmpResult != 0) {
+    LOG(FATAL) << "pthread_attr_getstack() in MRT_GCInitThreadLocal() return " <<
+        tmpResult << " rather than 0" << maple::endl;
+  };
+  void *stackBegin = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(stackAddr) + stackSize);
+  mutator->SaveStackBegin(stackBegin);
+
+  // mutator->Init() will be called in InitYieldpoint().
+  InitYieldpoint(*mutator);
+
+  // allocMutator->Init() need to create an OOMError instance,
+  // it should be called after thread local GC mutator initialized.
+  allocMutator->Init();
+
+  if (!isMain) {
+    (*theAllocator).NewOOMException();
+  }
+  tmpResult = pthread_attr_destroy(&attr);
+  if (tmpResult != 0) {
+    LOG(ERROR) << "pthread_attr_destroy() in MRT_GCInitThreadLocal() return " <<
+        tmpResult << " rather than 0" << maple::endl;
+    return false;
+  }
+  return true;
+}
+
+// Finalize the thread-local heap allocator. It should be called when a
+// mutator thread exits.
+bool MRT_GCFiniThreadLocal() {
+  // Get thread local mutator.
+  Mutator *mutator = TLMutatorPtr();
+  TheAllocMutator *allocMutator = TLAllocMutatorPtr();
+
+  // we should not call this function if current mutator not initialized
+  // or has been removed from mutator list.
+#if __MRT_DEBUG
+  if (UNLIKELY(mutator == nullptr || mutator->IsActive() == false || allocMutator == nullptr)) {
+    LOG(FATAL) << "MRT_GCFiniThreadLocal() called on inactive mutator: " <<
+        mutator << " " << allocMutator << maple::endl;
+  }
+#endif
+
+  // check tid.
+#if __MRT_DEBUG
+  uint32_t tid = static_cast<uint32_t>(maple::GetTid());
+  if (UNLIKELY(mutator->GetTid() != tid)) {
+    mutator->DumpRaw();
+    LOG(FATAL) << "MRT_GCFiniThreadLocal() invalid mutator tid: " <<
+        mutator->GetTid() << " != " << tid << maple::endl;
+  }
+#endif
+
+  // clean up tl_alloc_mutator.
+  allocMutator->Fini();
+
+  // mutator->Fini() will be called in FiniYieldpoint().
+  FiniYieldpoint(*mutator);
+
+  // release mutator objects.
+  delete allocMutator;
+  delete mutator;
+
+  // clear TLS slots.
+  maple::tls::StoreTLS(nullptr, maple::tls::kSlotMutator);
+  maple::tls::StoreTLS(nullptr, maple::tls::kSlotAllocMutator);
+
+  return true;
+}
+
+address_t MRT_AllocFromPerm(size_t size) {
+  return (*permAllocator).AllocThrowExp(size);
+}
+
+address_t MRT_AllocFromMeta(size_t size, MetaTag metaTag) {
+  return (*metaAllocator).Alloc(size, metaTag);
+}
+
+address_t MRT_AllocFromDecouple(size_t size, DecoupleTag tag) {
+  return (*decoupleAllocator).Alloc(size, tag);
+}
+
+bool MRT_IsPermJavaObj(address_t obj){
+  return (*permAllocator).Contains(obj);
+}
+
+void MRT_VisitDecoupleObjects(maple::rootObjectFunc f) {
+  if (!(*decoupleAllocator).ForEachObj(f)) {
+    LOG(ERROR) << "(*decoupleAllocator).ForEachObj() in MRT_VisitDecoupleObjects() return false." << maple::endl;
+  }
+}
+
+// deprecated
+address_t MCC_NewObj(size_t size, size_t) {
+  address_t addr = (*theAllocator).NewObj(size);
+  if (UNLIKELY(addr == 0)) {
+    (*theAllocator).OutOfMemory(false);
+  }
+  return addr;
+}
+
+void MRT_ClassInstanceNum(std::map<std::string, long> &objNameCntMp){
+  ScopedStopTheWorld sstw;
+  (*theAllocator).ClassInstanceNum(objNameCntMp);
+}
+
+void MRT_FreeObj(address_t obj) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    (*theAllocator).FreeObj(obj);
+  }
+}
+
+void MRT_PrintHeapStats() {
+  heapStats.PrintHeapStats();
+}
+
+void MRT_ResetHeapStats() {
+  heapStats.ResetHeapStats();
+}
+
+size_t MRT_TotalHeapObj() {
+  return (*theAllocator).AllocatedObjs();
+}
+
+size_t MRT_TotalMemory() {
+  return (*theAllocator).GetCurrentSpaceCapacity();
+}
+
+size_t MRT_MaxMemory() {
+  return (*theAllocator).GetMaxCapacity();
+}
+
+size_t MRT_FreeMemory() {
+  return (*theAllocator).GetCurrentFreeBytes();
+}
+
+void MRT_GetInstances(jclass klass, bool includeAssignable, size_t maxCount, std::vector<jobject> &instances) {
+  if (klass != nullptr) {
+    (*theAllocator).GetInstances(MClass::JniCast(klass), includeAssignable, maxCount, instances);
+  }
+}
+
+
+void MRT_Trim(bool aggressive) {
+  if (!(*theAllocator).ReleaseFreePages(aggressive)) {
+    LOG(ERROR) << "(*theAllocator).ReleaseFreePages() in MRT_Trim() return false.";
+  }
+}
+
+extern "C" void MRT_RequestTrim() {
+  if (!(*theAllocator).ReleaseFreePages(false)) {
+    LOG(ERROR) << "release requested but not effective";
+  }
+}
+
+size_t MRT_AllocSize() {
+  return heapStats.GetAllocSize();
+}
+
+size_t MRT_AllocCount() {
+  return heapStats.GetAllocCount();
+}
+
+size_t MRT_FreeSize() {
+  return heapStats.GetFreeSize();
+}
+
+size_t MRT_FreeCount() {
+  return heapStats.GetFreeCount();
+}
+
+size_t MRT_GetNativeAllocBytes() {
+  return heapStats.GetNativeAllocBytes();
+}
+
+void MRT_SetNativeAllocBytes(size_t size) {
+  heapStats.SetNativeAllocBytes(size);
+}
+
+void MRT_PrintRCStats() {
+  RCCollector::PrintStats();
+}
+
+void MRT_ResetRCStats() {
+  RCCollector::ResetStats();
+}
+
+void MRT_GetGcCounts(size_t &gcCount, uint64_t &maxGcMs) {
+  gcCount = maplert::stats::gcStats->NumGCTriggered();
+  maxGcMs = maplert::stats::gcStats->MaxSTWNanos();
+  maplert::stats::gcStats->ResetNumGCTriggered();
+  maplert::stats::gcStats->ResetMaxSTWNanos();
+}
+
+void MRT_GetMemLeak(size_t &avgLeak, size_t &peakLeak) {
+  avgLeak = maplert::stats::gcStats->AverageMemoryLeak();
+  peakLeak = maplert::stats::gcStats->TotalMemoryLeak();
+  maplert::stats::gcStats->ResetMemoryLeak();
+}
+
+void MRT_GetMemAlloc(float &util, size_t &abnormalCount) {
+  util = maplert::stats::gcStats->MemoryUtilization();
+  abnormalCount = maplert::stats::gcStats->NumAllocAnomalies();
+  maplert::stats::gcStats->ResetNumAllocAnomalies();
+}
+
+void MRT_GetRCParam(size_t &abnormalCount) {
+  abnormalCount = maplert::stats::gcStats->NumRCAnomalies();
+  maplert::stats::gcStats->ResetNumRCAnomalies();
+}
+
+address_t MRT_LoadVolatileField(address_t obj, address_t *fieldAddr) {
+  CHECK_SAFEREGION("MRT_LoadVolatileField: fieldAddr %p", static_cast<void*>(fieldAddr));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadRefVolatile(fieldAddr);
+  } else {
+    auto atomicField = reinterpret_cast<std::atomic<reffield_t>*>(fieldAddr);
+    return atomicField->load(std::memory_order_acquire);
+  }
+}
+
+void MRT_WriteVolatileField(address_t obj, address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MRT_WriteVolatileField: fieldAddr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldVolatile(obj, fieldAddr, value);
+  } else {
+    GCWriteField<true>(obj, fieldAddr, value);
+  }
+}
+
+address_t MCC_LoadVolatileStaticField(address_t *fieldAddr) {
+  CHECK_SAFEREGION("MCC_LoadVolatileStaticField: fieldAddr %p", static_cast<void*>(fieldAddr));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadRefVolatile(fieldAddr);
+  } else {
+    return GCLoadField<true>(fieldAddr);
+  }
+}
+
+void MRT_WriteVolatileStaticField(address_t *fieldAddr, address_t value)
+    __attribute__((alias("MCC_WriteVolatileStaticField")));
+
+void MCC_WriteVolatileStaticField(address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteVolatileStaticField: fieldAddr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldVolatile(kDummyAddress, fieldAddr, value);
+  } else {
+    GCWriteField<true>(kDummyAddress, fieldAddr, value);
+  }
+}
+
+uint32_t MRT_RefCount(address_t obj) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    if (obj == 0) {
+      return 0;
+    }
+    return RefCount(obj);
+  } else {
+    constexpr uint32_t gcOnlyRefCount = 1;
+    MRT_DummyUse(obj);
+    return gcOnlyRefCount;
+  }
+}
+
+address_t MCC_LoadVolatileField(address_t obj, address_t *fieldAddr) {
+  CHECK_SAFEREGION("MCC_LoadVolatileField: fieldAddr %p", static_cast<void*>(fieldAddr));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadRefVolatile(fieldAddr);
+  } else {
+    return GCLoadField<true>(fieldAddr);
+  }
+}
+
+// write barrier
+void MCC_WriteRefField(address_t obj, address_t *field, address_t value) {
+  CHECK_SAFEREGION("write ref field: obj %p, field %p, value %p",
+                   reinterpret_cast<void*>(obj), reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (UNLIKELY(obj == 0)) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefField(obj, field, value);
+  } else {
+    GCWriteField<false>(obj, field, value);
+  }
+}
+
+void MCC_WriteVolatileField(address_t obj, address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteVolatileField: obj %p, fieldAddr %p, value %p",
+                   static_cast<void*>(obj), reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldVolatile(obj, fieldAddr, value);
+  } else {
+    GCWriteField<true>(obj, fieldAddr, value);
+  }
+}
+
+// write barrier
+void MRT_WriteRefField(address_t obj, address_t *field, address_t value) {
+  CHECK_SAFEREGION("write ref field: obj %p, field %p, value %p",
+                   reinterpret_cast<void*>(obj), reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefField(obj, field, value);
+  } else {
+    GCWriteField<false>(obj, field, value);
+  }
+}
+
+void MRT_WriteRefFieldStatic(address_t *field, address_t value) __attribute__((alias("MCC_WriteRefFieldStatic")));
+void MCC_WriteRefFieldStatic(address_t *field, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteRefFieldStatic: field %p, value %p",
+                   reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefField(kDummyAddress, field, value);
+  } else {
+    GCWriteField<false>(kDummyAddress, field, value);
+  }
+}
+
+void MRT_WeakRefGetBarrier(address_t referent) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WeakRefGetBarrier(referent);
+  } else {
+    // When concurrent marking is enabled, remember the referent and
+    // prevent it from being reclaimed in this GC cycle.
+    if (LIKELY(IS_HEAP_OBJ(referent))) {
+      TLMutator().SatbWriteBarrier(referent);
+    }
+  }
+}
+
+address_t MRT_LoadRefField(address_t obj, address_t *fieldAddr) {
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CHECK_SAFEREGION("MRT_LoadRefField: fieldAddr %p", reinterpret_cast<void*>(fieldAddr));
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadIncRef(fieldAddr);
+  } else {
+    return GCLoadField<false>(fieldAddr);
+  }
+}
+
+// extract first 4k and write to os.
+// find single cycle boundary delmeter ";"
+void MRT_GetCyclePattern(ostream &os) {
+  string &patterns = ClassCycleManager::GetPatternsCache();
+  if (patterns.size() <= kMaxBigdataUploadSize) {
+    LOG2FILE(kLogtypeCycle) << "flush all patterns " << patterns << "end" << std::endl;
+    os << patterns;
+    patterns.clear();
+    return;
+  }
+  LOG2FILE(kLogtypeCycle) << "loading_patterns current " << patterns << "end" << std::endl;
+  size_t pos = patterns.rfind(";", kMaxBigdataUploadSize);
+  // If first cycle pattern is too large, find its end and truncate to kMaxBigdataUploadSize
+  if (pos == string::npos) {
+    size_t cycleEndPos = patterns.find(";", kMaxBigdataUploadSize);
+    os << (patterns.substr(0, kMaxBigdataUploadSize));
+    LOG2FILE(kLogtypeCycle) << "truncate loading_patterns " << (patterns.substr(0, kMaxBigdataUploadSize)) <<
+        "end" << std::endl;
+    patterns = patterns.substr(cycleEndPos + 1);
+    LOG2FILE(kLogtypeCycle) << "partial loading_patterns remain " << patterns << "end" << std::endl;
+  } else {
+    os << (patterns.substr(0, pos + 1));
+    LOG2FILE(kLogtypeCycle) << "partial loading_patterns " << (patterns.substr(0, pos + 1)) << "end" << std::endl;
+    patterns = patterns.substr(pos + 1);
+    LOG2FILE(kLogtypeCycle) << "partial loading_patterns remain " << patterns << "end" << std::endl;
+  }
+}
+
+ostream *MRT_GetCycleLogFile() {
+  return &GCLog().Stream(kLogtypeCycle);
+}
+
+void MRT_IncDecRef(address_t incAddr, address_t decAddr) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    if (incAddr == decAddr) {
+      return;
+    }
+    MRT_IncRef(incAddr);
+    MRT_DecRef(decAddr);
+  }
+}
+
+void MCC_ClearLocalStackRef(address_t *var) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    address_t slot = *var;
+    *var = 0;
+    MRT_DecRef(slot);
+  } else {
+    *var = 0;
+  }
+}
+
+void MCC_DecRefResetPair(address_t *incAddr, address_t *decAddr) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    address_t slot0 = *incAddr;
+    *incAddr = 0;
+    MRT_DecRef(slot0);
+    address_t slot1 = *decAddr;
+    *decAddr = 0;
+    MRT_DecRef(slot1);
+  } else {
+    *incAddr = 0;
+    *decAddr = 0;
+  }
+}
+
+void MCC_IncDecRefReset(address_t incAddr, address_t *decAddr) {
+  CheckObjAllocated(incAddr);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    address_t slot = *decAddr;
+    *decAddr = 0;
+    if (incAddr == slot) {
+      return;
+    }
+    MRT_IncRef(incAddr);
+    MRT_DecRef(slot);
+  } else {
+    *decAddr = 0;
+  }
+}
+
+void MRT_IncRef(address_t obj) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    JSAN_CHECK_OBJ(obj);
+    CHECK_SAFEREGION("inc %p", reinterpret_cast<void*>(obj));
+    NRCMutator().IncRef(obj);
+  }
+}
+
+address_t MCC_IncRef_NaiveRCFast(address_t obj) __attribute__((alias("MRT_IncRefNaiveRCFast")));
+
+address_t MRT_IncRefNaiveRCFast(address_t obj) {
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() != kNaiveRC) {
+    return obj;
+  }
+  // skip non-heap objects.
+  if (UNLIKELY(!IS_HEAP_ADDR(obj))) {
+    return obj;
+  }
+
+  MRT_CallAndCheckRC((AtomicUpdateRC<1, 0, 0>(obj)), obj);
+
+#if RC_TRACE_OBJECT
+  TraceRefRC(obj, RefCount(obj), "After MCC_IncRef_NaiveRCFast");
+#endif
+  return obj;
+}
+
+address_t MCC_LoadRefField_NaiveRCFast(address_t obj, address_t *fieldAddr) {
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CheckObjAllocated(obj);
+  address_t fld = LoadRefField(fieldAddr);
+  if (Collector::Instance().Type() != kNaiveRC) {
+    return fld;
+  }
+
+  // return if field is non-heap object.
+  if (UNLIKELY((fld & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK)) {
+    return NRCMutator().LoadRefVolatile(fieldAddr);
+  } else if (UNLIKELY(!IS_HEAP_ADDR(fld))) {
+    return fld;
+  }
+
+  if (TryAtomicIncStrongRC(fld)) {
+#if RC_TRACE_OBJECT
+    TraceRefRC(fld, RefCount(fld), "After MCC_LoadRefField_NaiveRCFast");
+#endif
+    return fld;
+  }
+  return MRT_LoadRefField(obj, fieldAddr);
+}
+
+static inline void WriteVolatileFieldNoInc(address_t obj, address_t *fieldAddr, address_t value) {
+  NRCMutator().WriteRefFieldVolatileNoInc(obj, fieldAddr, value);
+  if (UNLIKELY(obj == value)) {
+    MRT_DecRef(obj);
+  }
+}
+
+void MRT_WriteVolatileFieldNoInc(address_t obj, address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MRT_WriteVolatileFieldNoInc: fieldAddr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    // compensate early inc
+    MRT_DecRef(value);
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteVolatileFieldNoInc(obj, fieldAddr, value);
+  } else {
+    GCWriteField<true>(obj, fieldAddr, value);
+  }
+}
+
+void MCC_WriteVolatileStaticFieldNoInc(address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteVolatileStaticFieldNoInc: fieldAddr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldVolatileNoInc(kDummyAddress, fieldAddr, value);
+  } else {
+    GCWriteField<true>(kDummyAddress, fieldAddr, value);
+  }
+}
+
+void MCC_WriteVolatileStaticFieldNoDec(address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteVolatileStaticFieldNoDec: fieldAddr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldVolatileNoDec(kDummyAddress, fieldAddr, value);
+  } else {
+    GCWriteField<true>(kDummyAddress, fieldAddr, value);
+  }
+}
+
+void MCC_WriteVolatileStaticFieldNoRC(address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteVolatileStaticFieldNoRC: fieldAddr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldVolatileNoRC(kDummyAddress, fieldAddr, value);
+  } else {
+    GCWriteField<true>(kDummyAddress, fieldAddr, value);
+  }
+}
+
+static inline void WriteWeakField(address_t obj, address_t *field, address_t value, bool isVolatile) {
+  NRCMutator().WriteWeakField(obj, field, value, isVolatile);
+}
+
+void MRT_WriteWeakField(address_t obj, address_t *field, address_t value, bool isVolatile) {
+  CHECK_SAFEREGION("MRT_WriteWeakField: obj_addr %p, value %p",
+                   reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteWeakField(obj, field, value, isVolatile);
+  } else {
+    if (isVolatile) {
+      GCWriteField<true>(obj, field, value);
+    } else {
+      GCWriteField<false>(obj, field, value);
+    }
+  }
+}
+
+address_t MRT_LoadWeakField(address_t obj, address_t *field, bool isVolatile) {
+  CHECK_SAFEREGION("MRT_LoadWeakField: fieldAddr %p", reinterpret_cast<void*>(field));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadWeakField(field, isVolatile);
+  } else {
+    if (isVolatile) {
+      return GCLoadField<true>(field);
+    } else {
+      return GCLoadField<false>(field);
+    }
+  }
+}
+
+address_t MRT_LoadWeakFieldCommon(address_t obj, address_t *field) {
+  CHECK_SAFEREGION("MRT_LoadWeakFieldCommon: fieldAddr %p", reinterpret_cast<void*>(field));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadWeakRefCommon(field);
+  } else {
+    return GCLoadField<true>(field);
+  }
+}
+
+void MCC_WriteWeakField(address_t obj, address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteWeakField: obj_addr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteWeakField(obj, fieldAddr, value, false);
+  } else {
+    GCWriteField<false>(obj, fieldAddr, value);
+  }
+}
+
+address_t MCC_LoadWeakField(address_t obj, address_t *fieldAddr) {
+  CHECK_SAFEREGION("MCC_LoadWeakField: fieldAddr %p", reinterpret_cast<void*>(fieldAddr));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadWeakField(fieldAddr, false);
+  } else {
+    return GCLoadField<false>(fieldAddr);
+  }
+}
+
+void MCC_WriteVolatileWeakField(address_t obj, address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteWeakField: obj_addr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteWeakField(obj, fieldAddr, value, true);
+  } else {
+    GCWriteField<true>(obj, fieldAddr, value);
+  }
+}
+
+address_t MCC_LoadVolatileWeakField(address_t obj, address_t *fieldAddr) {
+  CHECK_SAFEREGION("MCC_LoadWeakField: fieldAddr %p", reinterpret_cast<void*>(fieldAddr));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadWeakField(fieldAddr, true);
+  } else {
+    return GCLoadField<true>(fieldAddr);
+  }
+}
+
+void MRT_CollectWeakObj(address_t obj) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    __MRT_ASSERT(IsWeakCollected(obj), "weak rc not collected");
+    if (!RCReferenceProcessor::Instance().CheckAndAddFinalizable(obj)) {
+      NRCMutator().WeakReleaseObj(obj);
+      NRCMutator().DecWeak(obj);
+    }
+  }
+}
+
+void MRT_ReleaseObj(address_t obj) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().ReleaseObj(obj);
+  }
+}
+
+address_t MCC_DecRef_NaiveRCFast(address_t obj) __attribute__((alias("MRT_DecRefNaiveRCFast")));
+address_t MRT_DecRefNaiveRCFast(address_t obj) {
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() != kNaiveRC) {
+    return obj;
+  }
+  // skip non-heap objects.
+  if (UNLIKELY(!IS_HEAP_ADDR(obj))) {
+    return obj;
+  }
+
+  // Check Cycle before DecRef, avoid data racing release object in other thread while match
+  uint32_t rcFlags = GCHeader(obj);
+  if ((rcFlags & kCyclePatternBit) == 0) {
+    uint32_t releaseState = kNotRelease;
+    uint32_t oldHeader __MRT_UNUSED = AtomicDecRCAndCheckRelease<-1, 0, 0>(obj, releaseState);
+#if RC_TRACE_OBJECT
+    TraceRefRC(obj, RefCount(obj), "After MCC_DecRef_NaiveRCFast");
+#endif
+    if (releaseState == kReleaseObject) {
+      MRT_ReleaseObj(obj);
+    } else if (releaseState == kCollectedWeak) {
+      if (!RCReferenceProcessor::Instance().CheckAndAddFinalizable(obj)) {
+        NRCMutator().WeakReleaseObj(obj);
+        NRCMutator().DecWeak(obj);
+      }
+    }
+    MRT_ASSERT_RC_NZ(GetRCFromRCHeader(oldHeader), "Dec from 0", obj, oldHeader);
+  } else {
+    MRT_DecRef(obj);
+  }
+  return obj;
+}
+
+void MCC_IncDecRef_NaiveRCFast(address_t incAddr, address_t decAddr)
+    __attribute__((alias("MRT_IncDecRefNaiveRCFast")));
+void MRT_IncDecRefNaiveRCFast(address_t incAddr, address_t decAddr) {
+  if (Collector::Instance().Type() != kNaiveRC) {
+    return;
+  }
+  if (incAddr == decAddr) {
+    return;
+  }
+
+  (void)MCC_IncRef_NaiveRCFast(incAddr);
+  (void)MCC_DecRef_NaiveRCFast(decAddr);
+}
+
+void MCC_CleanupLocalStackRef_NaiveRCFast(address_t *localStart, size_t count) {
+  if (Collector::Instance().Type() != kNaiveRC) {
+    return;
+  }
+  for (size_t i = 0; i < count; ++i) {
+    address_t slot = localStart[i];
+    if (slot != 0) {
+      (void)MRT_DecRefNaiveRCFast(slot);
+    }
+  }
+}
+
+void MCC_CleanupLocalStackRefSkip_NaiveRCFast(address_t *localStart, size_t count, size_t skip) {
+  if (Collector::Instance().Type() != kNaiveRC) {
+    return;
+  }
+  for (size_t i = 0; i < count; ++i) {
+    if (i == skip) {
+      continue;
+    }
+    address_t slot = localStart[i];
+    if (slot != 0) {
+      (void)MRT_DecRefNaiveRCFast(slot);
+    }
+  }
+}
+
+void MRT_DecRef(address_t obj) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    JSAN_CHECK_OBJ(obj);
+    CHECK_SAFEREGION("dec %p", reinterpret_cast<void*>(obj));
+    NRCMutator().DecRef(obj);
+  }
+}
+
+void MRT_DecRefUnsync(address_t obj) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    (void)UpdateRC<-1, 0, 0>(obj);
+#if RC_TRACE_OBJECT
+    TraceRefRC(obj, RefCount(obj), "After MRT_DecRefUnsync");
+#endif
+  }
+}
+
+static inline void WriteRefFieldNoDec(address_t obj, address_t *field, address_t value) {
+  NRCMutator().WriteRefFieldNoDec(obj, field, value);
+}
+
+void MCC_WriteRefFieldNoDec(address_t obj, address_t *field, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteRefFieldNoDec: obj %p, field %p, value %p",
+                   reinterpret_cast<void*>(obj), reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteRefFieldNoDec(obj, field, value);
+  } else {
+    GCWriteField<false>(obj, field, value);
+  }
+}
+
+static inline void WriteRefFieldNoInc(address_t obj, address_t *field, address_t value) {
+  NRCMutator().WriteRefFieldNoInc(obj, field, value);
+  if (UNLIKELY(obj == value)) {
+    MRT_DecRef(obj);
+  }
+}
+
+void MCC_WriteRefFieldNoInc(address_t obj, address_t *field, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteRefFieldNoInc: obj %p, field %p, value %p",
+                   reinterpret_cast<void*>(obj), reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    // compensate early inc
+    MRT_DecRef(value);
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteRefFieldNoInc(obj, field, value);
+  } else {
+    GCWriteField<false>(obj, field, value);
+  }
+}
+
+
+static inline void WriteRefFieldNoRC(address_t obj, address_t *field, address_t value) {
+  NRCMutator().WriteRefFieldNoRC(obj, field, value);
+  if (UNLIKELY(obj == value)) {
+    MRT_DecRef(obj);
+  }
+}
+
+void MCC_WriteRefFieldNoRC(address_t obj, address_t *field, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteRefFieldNoRC: obj %p, field %p, value %p",
+                   reinterpret_cast<void*>(obj), reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    // compensate early inc
+    MRT_DecRef(value);
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteRefFieldNoRC(obj, field, value);
+  } else {
+    GCWriteField<false>(obj, field, value);
+  }
+}
+
+void MCC_WriteVolatileFieldNoDec(address_t obj, address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteVolatileFieldNoDec: fieldAddr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldVolatileNoDec(obj, fieldAddr, value);
+  } else {
+    GCWriteField<true>(obj, fieldAddr, value);
+  }
+}
+
+void MCC_WriteVolatileFieldNoRC(address_t obj, address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteVolatileFieldNoRC: fieldAddr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    // compensate early inc
+    MRT_DecRef(value);
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldVolatileNoRC(obj, fieldAddr, value);
+    if (UNLIKELY(obj == value)) {
+      // compensate dec
+      MRT_DecRef(obj);
+    }
+  } else {
+    GCWriteField<true>(obj, fieldAddr, value);
+  }
+}
+
+void MCC_WriteVolatileFieldNoInc(address_t obj, address_t *fieldAddr, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteVolatileFieldNoInc: fieldAddr %p, value %p",
+                   reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    // compensate early inc
+    MRT_DecRef(value);
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteVolatileFieldNoInc(obj, fieldAddr, value);
+  } else {
+    GCWriteField<true>(obj, fieldAddr, value);
+  }
+}
+
+address_t MRT_LoadRefFieldCommon(address_t obj, address_t *fieldAddr) {
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CHECK_SAFEREGION("MRT_LoadRefFieldCommon: fieldAddr %p", reinterpret_cast<void*>(fieldAddr));
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadIncRefCommon(fieldAddr);
+  } else {
+    return GCLoadField<true>(fieldAddr);
+  }
+}
+
+address_t MCC_LoadRefStatic(address_t *fieldAddr) {
+  CHECK_SAFEREGION("MCC_LoadRefStatic: fieldAddr %p", reinterpret_cast<void*>(fieldAddr));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadIncRef(fieldAddr);
+  } else {
+    return GCLoadField<false>(fieldAddr);
+  }
+}
+
+void MRT_WriteRefFieldNoDec(address_t obj, address_t *field, address_t value) {
+  CHECK_SAFEREGION("MRT_WriteRefFieldNoDec: obj %p, field %p, value %p",
+                   reinterpret_cast<void*>(obj), reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteRefFieldNoDec(obj, field, value);
+  } else {
+    GCWriteField<false>(obj, field, value);
+  }
+}
+
+void MRT_WriteRefFieldNoInc(address_t obj, address_t *field, address_t value) {
+  CHECK_SAFEREGION("MRT_WriteRefFieldNoInc: obj %p, field %p, value %p",
+                   reinterpret_cast<void*>(obj), reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    // compensate early inc
+    MRT_DecRef(value);
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteRefFieldNoInc(obj, field, value);
+  } else {
+    GCWriteField<false>(obj, field, value);
+  }
+}
+
+void MRT_WriteRefFieldNoRC(address_t obj, address_t *field, address_t value) {
+  CHECK_SAFEREGION("MRT_WriteRefFieldNoRC: obj %p, field %p, value %p",
+                   reinterpret_cast<void*>(obj), reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    // compensate early inc
+    MRT_DecRef(value);
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    WriteRefFieldNoRC(obj, field, value);
+  } else {
+    GCWriteField<false>(obj, field, value);
+  }
+}
+
+void MCC_WriteRefFieldStaticNoInc(address_t *field, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteRefFieldStaticNoInc: field %p, value %p",
+                   reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldNoInc(kDummyAddress, field, value);
+  } else {
+    GCWriteField<false>(kDummyAddress, field, value);
+  }
+}
+
+void MCC_WriteRefFieldStaticNoDec(address_t *field, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteRefFieldStaticNoDec: field %p, value %p",
+                   reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldNoDec(kDummyAddress, field, value);
+  } else {
+    GCWriteField<false>(kDummyAddress, field, value);
+  }
+}
+
+void MCC_WriteRefFieldStaticNoRC(address_t *field, address_t value) {
+  CHECK_SAFEREGION("MCC_WriteRefFieldStaticNoRC: field %p, value %p",
+                   reinterpret_cast<void*>(field), reinterpret_cast<void*>(value));
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldNoRC(kDummyAddress, field, value);
+  } else {
+    GCWriteField<false>(kDummyAddress, field, value);
+  }
+}
+
+void MRT_WriteReferentField(address_t obj, address_t *fieldAddr, address_t value, bool isResurrectWeak) {
+  CHECK_SAFEREGION("MRT_WriteReferentField: obj_addr %p, value %p",
+      reinterpret_cast<void*>(fieldAddr), reinterpret_cast<void*>(value));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  if (Collector::Instance().Type() == kNaiveRC) {
+    NRCMutator().WriteRefFieldVolatile(obj, fieldAddr, value, true, isResurrectWeak);
+  } else {
+    GCWriteField<true>(obj, fieldAddr, value);
+  }
+}
+
+address_t MCC_LoadReferentField(address_t obj, address_t *fieldAddr) __attribute__((alias("MRT_LoadReferentField")));
+address_t MRT_LoadReferentField(address_t obj, address_t *fieldAddr) {
+  CHECK_SAFEREGION("MRT_LoadReferentField: obj_addr %p, value %p", reinterpret_cast<void*>(fieldAddr));
+  if (obj == 0) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CheckObjAllocated(obj);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return NRCMutator().LoadRefVolatile(fieldAddr, true);
+  } else {
+    return GCLoadField<true>(fieldAddr);
+  }
+}
+
+void MRT_IncResurrectWeak(address_t obj) {
+  JSAN_CHECK_OBJ(obj);
+  CHECK_SAFEREGION("inc resurrect weak %p", reinterpret_cast<void*>(obj));
+  NRCMutator().IncResurrectWeak(obj);
+}
+
+void MCC_WriteReferent(address_t obj, address_t value) {
+  if (Collector::Instance().Type() != kNaiveRC) {
+    SetObjReference(obj);
+    return;
+  }
+  // When referent is null, the collector always treats the referent as marked in art & hotspot.
+  // Not adding null referent reference to rp list will achieve the same effect, because rp
+  // thread will not collect the reference.
+  if (IS_HEAP_OBJ(value)) {
+    MClass *klass = reinterpret_cast<MObject*>(obj)->GetClass();
+    uint32_t classFlag = klass->GetFlag();
+    if (classFlag & (modifier::kClassCleaner | modifier::kClassPhantomReference)) {
+      (void)AtomicUpdateRC<-1, 1, 0>(value);
+    } else {
+      (void)AtomicUpdateRC<-1, 0, 1>(value);
+    }
+    AddNewReference(obj, classFlag);
+  }
+}
+
+// pre-write barrier for concurrent marking.
+void MRT_PreWriteRefField(address_t obj) {
+  CHECK_SAFEREGION("mrt pre-write barrier: obj %p", reinterpret_cast<void*>(obj));
+  TLMutator().SatbWriteBarrier<false>(obj);
+}
+
+// pre-write barrier for compiled code.
+void MCC_PreWriteRefField(address_t obj) {
+  CHECK_SAFEREGION("pre-write barrier: obj %p", reinterpret_cast<void*>(obj));
+  if (UNLIKELY(obj == 0)) {
+    // skip pre-write barrier for null object.
+    return;
+  }
+  // pre-write barrier for concurrent marking.
+  TLMutator().SatbWriteBarrier<false>(obj);
+}
+
+void MRT_SetTracingObject(address_t obj) {
+  if (!IS_HEAP_ADDR(obj)) {
+    return;
+  }
+
+  SetTraceBit(obj);
+#if RC_TRACE_OBJECT
+  void *callerPc = __builtin_return_address(0);
+  LOG2FILE(kLogtypeRcTrace) << "Obj " << std::hex << reinterpret_cast<void*>(obj) << std::dec << " RC= " <<
+      RefCount(obj) << " SetTrace ";
+  util::PrintPCSymbolToLog(callerPc);
+#endif
+}
+
+bool MRT_IsValidObjectAddress(address_t obj) {
+  if ((obj & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK) {
+    return false;
+  }
+  return true;
+}
+
+// not used now
+void MCC_ReleaseRefVar(address_t obj) __attribute__((alias("MRT_ReleaseRefVar")));
+void MRT_ReleaseRefVar(address_t obj) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    CHECK_SAFEREGION("release var: %p", reinterpret_cast<void*>(obj));
+    NRCMutator().ReleaseRefVar(obj);
+  }
+}
+
+void MRT_TriggerGC(maplert::GCReason reason) {
+  if (reason == kGCReasonUser && VLOG_IS_ON(opengclog)) {
+    util::PrintBacktrace(kLogtypeGc);
+  }
+
+  Collector::Instance().InvokeGC(reason);
+}
+
+bool MRT_IsNaiveRCCollector() {
+  return Collector::Instance().Type() == kNaiveRC;
+}
+
+bool MRT_IsGcRunning() {
+  return Collector::Instance().IsGcRunning();
+}
+
+bool MRT_IsGcThread() {
+  return static_cast<bool>(reinterpret_cast<uintptr_t>(maple::tls::GetTLS(maple::tls::kSlotIsGcThread)));
+}
+
+void MRT_DebugCleanup() {
+#if !defined(NDEBUG)
+  // In debug builds, main thread will skip vm->DetachCurrentThread() (see: mplsh.cc),
+  // so we should ensure MRT_GCFiniThreadLocal() is called before debug cleanup.
+  Mutator *mutator = TLMutatorPtr();
+  if (mutator != nullptr && mutator->IsActive()) {
+    (void)MRT_GCFiniThreadLocal();
+  }
+#endif
+  Collector::Instance().DebugCleanup();
+}
+
+void MRT_RegisterGCRoots(address_t *gcroots[], size_t len) {
+  GCRegisteredRoots::Instance().Register(gcroots, len);
+}
+
+void MRT_RegisterRCCheckAddr(uint64_t *addr) {
+  RegisteredCollectorTypeCheckAddrs::Instance().Register(addr);
+}
+
+// only used in STW
+bool MRT_IsValidObjAddr(address_t obj) {
+  __MRT_ASSERT(WorldStopped(), "invoke MRT_IsValidObjAddr in none STW");
+  return (*theAllocator).AccurateIsValidObjAddr(obj);
+}
+
+bool MRT_FastIsValidObjAddr(address_t obj) {
+  return (*theAllocator).FastIsValidObjAddr(obj);
+}
+
+// deprecated, use the two above
+bool MRT_CheckHeapObj(address_t obj) {
+  return IS_HEAP_ADDR(obj);
+}
+
+bool MRT_IsGarbage(address_t obj) {
+  return Collector::Instance().IsGarbage(obj);
+}
+
+ATTR_NO_SANITIZE_ADDRESS
+void MCC_InitializeLocalStackRef(address_t *localStart, size_t count) {
+  for (size_t i = 0; i < count; ++i) {
+    localStart[i] = 0;
+  }
+}
+
+static inline void CleanupLocalStackRef(const address_t &localStart) {
+  address_t slot = localStart;
+  if (slot != 0) {
+    MRT_DecRef(slot);
+  }
+}
+
+void MCC_CleanupLocalStackRef(const address_t *localStart, size_t count) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    for (size_t i = 0; i < count; ++i) {
+      CleanupLocalStackRef(localStart[i]);
+    }
+    MRT_InitPoisonStack(reinterpret_cast<uintptr_t>(localStart));
+  }
+}
+
+void MCC_CleanupLocalStackRefSkip(const address_t *localStart, size_t count, size_t skip) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    for (size_t i = 0; i < count; ++i) {
+      if (i == skip) {
+        continue;
+      }
+      CleanupLocalStackRef(localStart[i]);
+    }
+#if CONFIG_JSAN
+    MRT_InitPoisonStack(reinterpret_cast<uintptr_t>(localStart));
+#endif
+  }
+}
+
+#if LOG_ALLOC_TIMESTAT
+void MRT_ResetAllocTimers() {
+  (*theAllocator).ForEachMutator([](AllocMutator &mutator) {
+    mutator.ResetTimers();
+  });
+}
+
+void MRT_PrintAllocTimers() {
+  TimeStat timers[kTimeMax];
+  (*theAllocator).ForEachMutator([&timers](AllocMutator &mutator) {
+    for (int i = 0; i < kTimeMax; ++i) {
+      timers[i].tmMin = std::min(mutator.GetTimerMin(i), timers[i].GetMin());
+      timers[i].tmMax = std::max(mutator.GetTimerMax(i), timers[i].GetMax());
+      timers[i].tmSum += mutator.GetTimerSum(i);
+      timers[i].tmCnt += mutator.GetTimerCnt(i);
+    }
+  });
+  int i;
+  i = kTimeAllocLocal;
+  if (timers[i].HasStat()) {
+    LOG(INFO) << "[ATIME] local min: " << timers[i].GetMin() << ", max: " << timers[i].GetMax() << ", avg: " <<
+        timers[i].GetAvg() << "(" << timers[i].GetCnt() << ")" << maple::endl;
+  }
+  i = kTimeAllocGlobal;
+  if (timers[i].HasStat()) {
+    LOG(INFO) << "[ATIME] global min: " << timers[i].GetMin() << ", max: " << timers[i].GetMax() << ", avg: " <<
+        timers[i].GetAvg() << "(" << timers[i].GetCnt() << ")" << maple::endl;
+  }
+  i = kTimeAllocLarge;
+  if (timers[i].HasStat()) {
+    LOG(INFO) << "[ATIME] large min: " << timers[i].GetMin() << ", max: " << timers[i].GetMax() << ", avg: " <<
+        timers[i].GetAvg() << "(" << timers[i].GetCnt() << ")" << maple::endl;
+  }
+  i = kTimeReleaseObj;
+  if (timers[i].HasStat()) {
+    LOG(INFO) << "[ATIME] release min: " << timers[i].GetMin() << ", max: " << timers[i].GetMax() << ", avg: " <<
+        timers[i].GetAvg() << "(" << timers[i].GetCnt() << ")" << maple::endl;
+  }
+  i = kTimeFreeLocal;
+  if (timers[i].HasStat()) {
+    LOG(INFO) << "[ATIME] free local min: " << timers[i].GetMin() << ", max: " << timers[i].GetMax() << ", avg: " <<
+        timers[i].GetAvg() << "(" << timers[i].GetCnt() << ")" << maple::endl;
+  }
+  i = kTimeFreeGlobal;
+  if (timers[i].HasStat()) {
+    LOG(INFO) << "[ATIME] free global min: " << timers[i].GetMin() << ", max: " << timers[i].GetMax() << ", avg: " <<
+        timers[i].GetAvg() << "(" << timers[i].GetCnt() << ")" << maple::endl;
+  }
+  i = kTimeFreeLarge;
+  if (timers[i].HasStat()) {
+    LOG(INFO) << "[ATIME] free large min: " << timers[i].GetMin() << ", max: " << timers[i].GetMax() << ", avg: " <<
+        timers[i].GetAvg() << "(" << timers[i].GetCnt() << ")" << maple::endl;
+  }
+}
+#endif
+
+void MCC_CleanupNonescapedVar(address_t obj) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    // obj is a stack address which can not be null, but the
+    // classinfo field may be null due to diverged control flow
+    if (LIKELY(reinterpret_cast<MObject*>(obj)->GetClass() != 0)) {
+      NRCMutator().DecChildrenRef(obj);
+    }
+  }
+}
+
+void MRT_DebugShowCurrentMutators() {
+  MutatorList::Instance().DebugShowCurrentMutators();
+}
+
+void MRT_CheckSaferegion(bool expect, const char *msg) {
+  bool safeRegionState = TLMutator().InSaferegion();
+  if (UNLIKELY(safeRegionState != expect)) {
+    util::PrintBacktrace();
+    LOG(FATAL) << msg << " check saferegion failed! in saferegion: " << safeRegionState << maple::endl;
+  }
+}
+
+// Dump Heap content at yield point
+// index and msg give a unique log file name for dumped result
+void MRT_DumpHeap(const std::string &tag) {
+  Collector::Instance().DumpHeap(tag);
+}
+
+void MRT_DumpRCAndGCPerformanceInfo(std::ostream &os) {
+  DumpRCAndGCPerformanceInfo(os);
+}
+
+void MRT_DumpRCAndGCPerformanceInfo_Stderr() {
+  DumpRCAndGCPerformanceInfo(cerr);
+}
+
+void MRT_VisitAllocatedObjects(maple::rootObjectFunc func) {
+  if (!(*theAllocator).ForEachObj(func)) {
+    LOG(ERROR) << "(*theAllocator).ForEachObj() in MRT_VisitAllocatedObjects() return false." << maple::endl;
+  }
+}
+
+address_t MRT_GetHeapLowerBound() {
+  return (*theAllocator).HeapLowerBound();
+}
+
+address_t MRT_GetHeapUpperBound() {
+  return (*theAllocator).HeapUpperBound();
+}
+
+void MRT_DumpDynamicCyclePatterns(std::ostream &os, size_t limit) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    ClassCycleManager::DumpDynamicCyclePatterns(os, limit, false);
+  }
+}
+
+bool MRT_IsCyclePatternUpdated() {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    return ClassCycleManager::IsCyclePatternUpdated();
+  }
+  return true;
+}
+
+
+void MRT_UpdateProcessState(ProcessState processState, bool isSystemServer) {
+  Collector::Instance().UpdateProcessState(processState, isSystemServer);
+}
+
+void MRT_WaitGCStopped() {
+  Collector::Instance().WaitGCStopped();
+}
+
+void MCC_RecordStaticField(address_t *field, const char *name) {
+  RecordStaticField(field, name);
+}
+
+void MRT_DumpStaticField(std::ostream &os) {
+  DumpStaticField(os);
+}
+
+void MRT_PreRenewObject(address_t obj) {
+  TLMutator().SatbWriteBarrier(obj);
+}
+
+void MRT_GCLogPostFork() {
+  GCLog().OnPostFork();
+}
+
+void MRT_SetAllocRecordingCallback(std::function<void(address_t, size_t)> callback) {
+  (*theAllocator).SetAllocRecordingCallback(callback);
+}
+
+// --- MCC read barriers for GCONLY --- //
+//
+// For GCONLY, compiler will optimize read barrier calls to inline codes.
+// we keep read barriers here to support O0 build and debug.
+address_t MCC_LoadRefField(address_t obj, address_t *fieldAddr) {
+  if (UNLIKELY(obj == 0)) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  CHECK_SAFEREGION("MCC_LoadRefField: fieldAddr %p", static_cast<void*>(fieldAddr));
+  return LoadRefField(fieldAddr);
+}
+
+// replace MCC_IncRef when gconly is enabled and peephole optimize disabled.
+address_t MCC_Dummy(address_t obj) {
+  return obj;
+}
+
+bool MRT_UnsafeCompareAndSwapObject(address_t obj, ssize_t offset, address_t expectedValue, address_t newValue) {
+  CHECK_SAFEREGION("MRT_UnsafeCompareAndSwapObject: obj %p, offset %lld expectedValue %p, newValue %p",
+                   reinterpret_cast<void*>(obj), offset,
+                   reinterpret_cast<void*>(expectedValue), reinterpret_cast<void*>(newValue));
+  return Collector::Instance().UnsafeCompareAndSwapObject(obj, offset, expectedValue, newValue);
+}
+
+address_t MRT_UnsafeGetObjectVolatile(address_t obj, ssize_t offset) {
+  CHECK_SAFEREGION("MRT_UnsafeGetObjectVolatile: obj %p, offset %lld",
+                   reinterpret_cast<void*>(obj), offset);
+  return Collector::Instance().UnsafeGetObjectVolatile(obj, offset);
+}
+
+address_t MRT_UnsafeGetObject(address_t obj, ssize_t offset) {
+  CHECK_SAFEREGION("MRT_UnsafeGetObject: obj %p, offset %lld",
+                   reinterpret_cast<void*>(obj), offset);
+  return Collector::Instance().UnsafeGetObject(obj, offset);
+}
+
+void MRT_UnsafePutObject(address_t obj, ssize_t offset, address_t newValue) {
+  CHECK_SAFEREGION("MRT_UnsafePutObject: obj %p, offset %lld, newValue %p",
+                   reinterpret_cast<void*>(obj), offset, reinterpret_cast<void*>(newValue));
+  Collector::Instance().UnsafePutObject(obj, offset, newValue);
+}
+
+void MRT_UnsafePutObjectVolatile(address_t obj, ssize_t offset, address_t newValue) {
+  CHECK_SAFEREGION("MRT_UnsafePutObjectVolatile: obj %p, offset %lld, newValue %p",
+                   reinterpret_cast<void*>(obj), offset, reinterpret_cast<void*>(newValue));
+  Collector::Instance().UnsafePutObjectVolatile(obj, offset, newValue);
+}
+
+void MRT_UnsafePutObjectOrdered(address_t obj, ssize_t offset, address_t newValue) {
+  CHECK_SAFEREGION("MRT_UnsafePutObjectOrdered: obj %p, offset %lld, newValue %p",
+                   reinterpret_cast<void*>(obj), offset, reinterpret_cast<void*>(newValue));
+  Collector::Instance().UnsafePutObjectOrdered(obj, offset, newValue);
+}
+
+int64_t MCC_JDouble2JLong(double num) {
+  return JavaFPToSInt<double, int64_t>(num);
+}
+
+int64_t MCC_JFloat2JLong(float num) {
+  return JavaFPToSInt<float, int64_t>(num);
+}
+
+} // extern "C"
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collector/arena.cpp b/src/mrt/compiler-rt/src/collector/arena.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3e4eb75fac0c1143ff95f96fe058ec501d55175e
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/arena.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/arena.h"
+#include "chosen.h"
+namespace maplert {
+void HandleArena::VisitGCRoots(const RefVisitor &visitor) {
+  VisitTopSnapShot(visitor, nullptr, nullptr);
+}
+
+ScopedHandles::ScopedHandles() {
+  snapshot = TLMutator().GetHandleArena();
+}
+
+ScopedHandles::~ScopedHandles() {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    RefVisitor decVisitor = [](address_t &obj) {
+      MRT_DecRef(obj);
+    };
+    TLMutator().GetHandleArena().VisitTopSnapShot(decVisitor, snapshot);
+  }
+  TLMutator().GetHandleArena().PopBanks(snapshot);
+  snapshot.Clear(); // clear to avoid destructor handling again
+}
+
+void HandleBase::Push(address_t ref) {
+  handle = TLMutator().GetHandleArena().AllocateSlot();
+  if (handle == nullptr) {
+    LOG(FATAL) << "Get Arena handle failed" << maple::endl;
+    return;
+  }
+  *handle = ref;
+}
+}  // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collector/collector.cpp b/src/mrt/compiler-rt/src/collector/collector.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c84f61965b505d5670f82d56ab60189b3b16beee
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/collector.cpp
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/collector.h"
+#include "collector/rp_base.h"
+#include "chosen.h"
+#include "mutator_list.h"
+
+namespace maplert {
+namespace {
+const std::string kCollectorName[] = {
+    "NoCollector", "NaiveRC", "MarkSweep", "NaiveRCMarkSweep"
+};
+}
+
+Collector *Collector::instance = nullptr;
+RegisteredCollectorTypeCheckAddrs *RegisteredCollectorTypeCheckAddrs::instance =
+    new (std::nothrow) RegisteredCollectorTypeCheckAddrs();
+
+void RegisteredCollectorTypeCheckAddrs::Register(uint64_t *addr) {
+  if (addr == nullptr) {
+    LOG(FATAL) << "Register get a null pointer as parameter" << maple::endl;
+  }
+  std::lock_guard<std::mutex> lock(registerLock);
+  addrs.push_back(addr);
+  if (Collector::InstancePtr() != nullptr) {
+    bool isGCOnly = Collector::Instance().Type() != kNaiveRC;
+    if (isGCOnly) {
+      __MRT_ASSERT(*(addr + 1) == kRegistedMagicNumber, "Invalid number");
+      *addr = 1;
+    }
+  }
+}
+
+void RegisteredCollectorTypeCheckAddrs::PostCollectorCreate() {
+  std::lock_guard<std::mutex> lock(registerLock);
+  bool isGCOnly = Collector::Instance().Type() != kNaiveRC;
+  if (isGCOnly) {
+    LOG(INFO) << "RegisterRCCheckAddr switch to GC " << addrs.size();
+    for (uint64_t *addr : addrs) {
+      __MRT_ASSERT(*(addr + 1) == kRegistedMagicNumber, "Invalid number");
+      *addr = 1;
+    }
+  }
+}
+
+Collector::Collector()
+    : processState(kProcessStateJankPerceptible) {}
+
+void Collector::Create(bool gcOnly) {
+  bool createNaivRCCollector = true;
+#if ((MRT_COLLECTOR == MRT_COLLECTOR_NONE) || (MRT_COLLECTOR == MRT_COLLECTOR_NAIVERC))
+  createNaivRCCollector = !VLOG_IS_ON(gconly) && !gcOnly;
+#elif (MRT_COLLECTOR == MRT_COLLECTOR_MS)
+  UNUSED(gcOnly);
+  createNaivRCCollector = false;
+#else
+#error "Invalid MRT_COLLECTOR"
+#endif
+  if (createNaivRCCollector) {
+    instance = new (std::nothrow) NaiveRCCollector();
+    FastAllocData::data.isGCOnly = false;
+  } else {
+    instance = new (std::nothrow) MarkSweepCollector();
+    FastAllocData::data.isGCOnly = true;
+  }
+  if (UNLIKELY(instance == nullptr)) {
+    LOG(FATAL) << "Create Collector instance failed!" << maple::endl;
+  }
+  RegisteredCollectorTypeCheckAddrs::Instance().PostCollectorCreate();
+}
+
+void Collector::SwitchToGCOnFork() {
+  __MRT_ASSERT(instance != nullptr, "null collector");
+  __MRT_ASSERT(instance->Type() == kNaiveRC, "not RC collector");
+  // update all object's RC to overflow, avoid RC check
+  __MRT_ASSERT((static_cast<NaiveRCCollector*>(instance)->HasWeakRelease()) == false, "has weak field");
+  // switch reference processor
+  ReferenceProcessor::SwitchToGCOnFork();
+  // switch collector
+  __MRT_ASSERT(instance->IsSystem() == false, "switch to gc for SS");
+  instance->Fini();
+  delete instance;
+  instance = new (std::nothrow) MarkSweepCollector();
+  FastAllocData::data.isGCOnly = true;
+  if (instance == nullptr) {
+    LOG(FATAL) << "create new collector fail" << maple::endl;
+  }
+  RegisteredCollectorTypeCheckAddrs::Instance().PostCollectorCreate();
+  instance->SetIsSystem(false);
+  instance->InitAfterFork();
+  MRT_SendBackgroundGcJob(true);
+  // switch mutator
+  __MRT_ASSERT(MutatorList::Instance().Size() == 1, "only main thread allowed");
+  NaiveRCMutator &rcMutator = NRCMutator();
+  Mutator *gcMutator = new (std::nothrow) MarkSweepMutator(*instance);
+  if (gcMutator == nullptr) {
+    LOG(FATAL) << "create new mutator fail" << maple::endl;
+  }
+  gcMutator->CopyStateOnFork(rcMutator);
+  gcMutator->InitAfterFork();
+  // close rc mutator
+  MutatorList::Instance().RemoveMutator(rcMutator, [](Mutator *mut) {
+    if (mut == nullptr) {
+      LOG(FATAL) << "Wrong mutator pointer" << maple::endl;
+    }
+    mut->Fini();
+  });
+  delete &rcMutator;
+  // add new gc mutator
+  MutatorList::Instance().AddMutator(*gcMutator);
+  maple::tls::StoreTLS(gcMutator, maple::tls::kSlotMutator);
+  std::atomic_thread_fence(std::memory_order_release);
+}
+
+void Collector::UpdateProcessState(ProcessState processStateVal, bool isSystemServer) {
+  // ensure the new state is different from the old state
+  if (processStateVal == processState) {
+    return;
+  }
+  if ((processStateVal == kProcessStateJankImperceptible) && !isSystemServer) {
+    LOG(INFO) << "UpdateProcessState to JankImperceptible triggers GC" << maple::endl;
+    MRT_SendBackgroundGcJob(false);
+  }
+  processState = processStateVal;
+}
+
+const std::string &Collector::GetName() {
+  return kCollectorName[type];
+}
+
+void Collector::Init() {
+  ReferenceProcessor::Create(type);
+  stats::gcStats->OnCollectorInit();
+}
+
+void Mutator::InitTid() {
+  tid = static_cast<uint32_t>(maple::GetTid());
+  if (UNLIKELY(tid == 0)) {
+    LOG(FATAL) << "Mutator::InitTid(): invalid tid = 0" << maple::endl;
+  }
+}
+
+void Mutator::DebugShow() const {
+  fprintf(stderr, "Mutator: %p", this);
+  fprintf(stderr, "  tid = %" PRIu32, GetTid());
+  fprintf(stderr, "  active = %s", IsActive() ? "true" : "false");
+  fprintf(stderr, "  in_saferegion = %s", InSaferegion() ? "true" : "false");
+  fprintf(stderr, "  stack: %p to %p", reinterpret_cast<void*>(stackBegin), reinterpret_cast<void*>(stackEnd));
+}
+
+// Copy state: active, in safe region and stack begin
+// Copy last java context
+// Copy LocalValueArena and force current LocalValueArena skip desctructor
+void Mutator::CopyStateOnFork(Mutator &orig) {
+  __MRT_ASSERT(orig.active == kMutatorDebugTrue, "Base not active");
+  active = orig.active;
+  __MRT_ASSERT(orig.inSaferegion == kMutatorDebugTrue, "Base in saferegion");
+  inSaferegion = orig.inSaferegion;
+  stackBegin = orig.stackBegin;
+  initialUnwindContext.CopyFrom(orig.initialUnwindContext);
+  arena = orig.arena;
+  orig.arena.Clear();
+}
+
+void Mutator::SatbWriteBarrier(address_t obj, const reffield_t &field) {
+  if (!concurrentMarking) {
+    return;
+  }
+  reffield_t ref = field;
+  if (UNLIKELY((ref & LOAD_INC_RC_MASK) != 0)) {
+    ref = Collector::Instance().RefFieldLoadBarrier(obj, field);
+  }
+  PushIntoSatbBuffer(ref);
+}
+
+void Mutator::PushChildrenToSatbBuffer(address_t obj) {
+  if (!IS_HEAP_ADDR(obj)) {
+    return;
+  }
+  auto func = [&](const reffield_t &field, uint64_t) {
+    reffield_t ref = field;
+    if (UNLIKELY((ref & LOAD_INC_RC_MASK) != 0)) {
+      ref = Collector::Instance().RefFieldLoadBarrier(obj, field);
+    }
+    PushIntoSatbBuffer(ref);
+  };
+  DoForEachRefField(obj, func);
+}
+
+// satb buffer
+SatbBuffer &SatbBuffer::Instance() {
+  static ImmortalWrapper<SatbBuffer> instance;
+  return *instance;
+}
+
+struct GCTibGCInfo MCC_GCTIB___EmptyObject = { .headerProto = 0, .nBitmapWords = 0 };
+struct GCTibGCInfo MCC_GCTIB___ArrayOfObject = { .headerProto = kHasChildRef | kArrayBit, .nBitmapWords = 0 };
+struct GCTibGCInfo MCC_GCTIB___ArrayOfPrimitive = { .headerProto = kArrayBit, .nBitmapWords = 0 };
+} // namespace maplert.
diff --git a/src/mrt/compiler-rt/src/collector/collector_ms.cpp b/src/mrt/compiler-rt/src/collector/collector_ms.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4bf993ff03245b1a158a361d5273d4832769b8e6
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/collector_ms.cpp
@@ -0,0 +1,1762 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/collector_ms.h"
+
+#include <cassert>
+#include <cstddef>
+#include <cinttypes>
+#include <atomic>
+#include <fstream>
+#include "mm_config.h"
+#include "address.h"
+#include "chosen.h"
+#include "collector/mrt_bitmap.h"
+#include "collector/stats.h"
+#include "yieldpoint.h"
+#include "profile.h"
+#include "collector/native_gc.h"
+#include "mutator_list.h"
+#include "collie.h"
+#include "mrt_class_api.h"
+
+namespace maplert {
+// number of nanoseconds in a microsecond.
+constexpr uint64_t kNsPerUs = 1000;
+
+#if BT_CLEANUP_PROFILE
+size_t BTCleanupStats::rootSetSize;
+size_t BTCleanupStats::totalRemain;
+size_t BTCleanupStats::reachableRemain;
+size_t BTCleanupStats::unreachableRemain;
+#endif
+
+// Small queue implementation, for prefetching.
+#define MRT_MAX_PREFETCH_QUEUE_SIZE_LOG 5UL
+#define MRT_MAX_PREFETCH_QUEUE_SIZE (1UL << MRT_MAX_PREFETCH_QUEUE_SIZE_LOG)
+#if MRT_MAX_PREFETCH_QUEUE_SIZE <= MARK_PREFETCH_DISTANCE
+#error Prefetch queue size must be strictly greater than prefetch distance.
+#endif
+class PrefetchQueue {
+ public:
+  explicit PrefetchQueue(size_t d) : elems {}, distance(d), tail(0), head(0) {}
+  ~PrefetchQueue() {}
+  inline void Add(address_t objaddr) {
+    size_t t = tail;
+    elems[t] = objaddr;
+    tail = (t + 1) & (MRT_MAX_PREFETCH_QUEUE_SIZE - 1UL);
+
+    __builtin_prefetch(reinterpret_cast<void*>(objaddr - kJavaObjAlignment), 1, kPrefetchLocality);
+    __builtin_prefetch(reinterpret_cast<void*>(objaddr), 0, kPrefetchLocality);
+  }
+
+  inline address_t Remove() {
+    size_t h = head;
+    address_t objaddr = elems[h];
+    head = (h + 1) & (MRT_MAX_PREFETCH_QUEUE_SIZE - 1UL);
+
+    return objaddr;
+  }
+
+  inline size_t Length() const {
+    return (tail - head) & (MRT_MAX_PREFETCH_QUEUE_SIZE - 1UL);
+  }
+
+  inline bool Empty() const {
+    return head == tail;
+  }
+
+  inline bool Full() const {
+    return Length() == distance;
+  }
+
+ private:
+  static constexpr int kPrefetchLocality = 3;
+  address_t elems[MRT_MAX_PREFETCH_QUEUE_SIZE];
+  size_t distance;
+  size_t tail;
+  size_t head;
+}; // End of small queue implementation
+
+class MarkTask : public MplTask {
+ public:
+  MarkTask(MarkSweepCollector &tc,
+           MplThreadPool *pool,
+           size_t workStackSize,
+           TracingCollector::WorkStack::iterator workStackData,
+           bool isFollowReferent)
+      : collector(tc), threadPool(pool), followReferent(isFollowReferent) {
+    workStack.reserve(workStackSize + kMaxMarkTaskSize);
+    workStack.insert(workStack.begin(), workStackData, workStackData + workStackSize);
+  }
+
+  // single work task without thread pool
+  MarkTask(MarkSweepCollector &tc, TracingCollector::WorkStack &stack, bool isFollowReferent)
+      : collector(tc), threadPool(nullptr), followReferent(isFollowReferent) {
+    workStack.reserve(stack.size());
+    workStack.insert(workStack.begin(), stack.begin(), stack.end());
+  }
+  virtual ~MarkTask() {
+    threadPool = nullptr;
+  }
+  void Execute(size_t workerID __attribute__((unused))) override {
+    size_t nNewlyMarked = 0;
+    const size_t prefetchDistance = kMarkPrefetchDistance;
+    PrefetchQueue pq(prefetchDistance);
+    for (;;) {
+      // Prefetch as much as possible.
+      while (!pq.Full() && !workStack.empty()) {
+        address_t objaddr = workStack.back();
+        pq.Add(objaddr);
+        workStack.pop_back();
+      }
+
+      // End if pq is empty.  This implies that workStack is also empty.
+      if (pq.Empty()) {
+        break;
+      }
+
+      address_t objaddr = pq.Remove();
+      bool wasMarked = collector.MarkObject(objaddr);
+      if (!wasMarked) {
+        LOG2FILE(kLogTypeMix) << "Newly marked: 0x%" << objaddr << std::endl;
+        ++nNewlyMarked;
+        // If we mark before enqueing, we should have checked if it has children.
+        if (!HasChildRef(objaddr)) {
+          continue;
+        }
+
+        if (LIKELY(!IsObjReference(objaddr)) || UNLIKELY(followReferent)) {
+          collector.EnqueueNeighbors(objaddr, workStack);
+        } else {
+          collector.EnqueueNeighborsForRef(objaddr, workStack);
+        }
+
+        if (threadPool != nullptr && UNLIKELY(workStack.size() > kMaxMarkTaskSize)) {
+          // Mark stack overflow, give 1/2 the stack to the thread pool as a new work task.
+          size_t newSize = workStack.size() >> 1;
+          threadPool->AddTask(new (std::nothrow) MarkTask(collector,
+                                                          threadPool,
+                                                          workStack.size() - newSize,
+                                                          workStack.begin() + newSize,
+                                                          followReferent));
+          workStack.resize(newSize);
+        }
+      } else {
+        LOG2FILE(kLogTypeMix) << "Already marked: 0x" << objaddr << std::endl;
+      }
+    } // for loop
+
+    // newly marked statistics.
+    (void)collector.newlyMarked.fetch_add(nNewlyMarked, std::memory_order_relaxed);
+  }
+
+ private:
+  TracingCollector::WorkStack workStack;
+  MarkSweepCollector &collector;
+  MplThreadPool *threadPool;
+  bool followReferent;
+};
+
+class ConcurrentMarkTask : public MplTask {
+ public:
+  ConcurrentMarkTask(MarkSweepCollector &tc,
+                     MplThreadPool *pool,
+                     TracingCollector::WorkStack::iterator workStackStart,
+                     size_t workStackSize)
+      : collector(tc), threadPool(pool) {
+    workStack.reserve(workStackSize + kMaxMarkTaskSize);
+    workStack.insert(workStack.begin(), workStackStart, workStackStart + workStackSize);
+  }
+
+  // create concurrent mark task without thread pool.
+  ConcurrentMarkTask(MarkSweepCollector &tc, TracingCollector::WorkStack &&stack)
+      : collector(tc), threadPool(nullptr), workStack(std::move(stack)) {}
+
+  virtual ~ConcurrentMarkTask() {
+    threadPool = nullptr;
+  }
+
+  // when parallel is enabled, fork new task if work stack overflow.
+  inline void TryForkTask() {
+    if (threadPool != nullptr && UNLIKELY(workStack.size() > kMaxMarkTaskSize)) {
+      // Mark stack overflow, give 1/2 the stack to the thread pool as a new work task.
+      size_t newSize = workStack.size() >> 1;
+      threadPool->AddTask(new (std::nothrow) ConcurrentMarkTask(collector, threadPool, workStack.begin() + newSize,
+                                                                workStack.size() - newSize));
+      workStack.resize(newSize);
+    }
+  }
+
+  // Mark object.
+  // return true if success set object from unmarked to marked.
+  inline bool Mark(address_t obj) {
+    // try to mark object and load old mark state.
+    bool wasMarked = collector.MarkObject(obj);
+    // return false if object already marked.
+    if (UNLIKELY(wasMarked)) {
+      return false;
+    }
+    // make success.
+    ++newlyMarked;
+    return true;
+  }
+
+  // run concurrent marking task.
+  void Execute(size_t) override {
+    // loop until work stack empty.
+    for (;;) {
+      if (workStack.empty()) {
+        break;
+      }
+      // get next object from work stack.
+      address_t objaddr = workStack.back();
+      workStack.pop_back();
+
+      // skip dangling reference (such as: object already released).
+      if (UNLIKELY(!IsAllocatedByAllocator(objaddr))) {
+        // kAllocatedBit not set, means the object address is a dangling reference.
+        LOG(ERROR) << "Mark encounter dangling reference: " << objaddr << maple::endl;
+        continue;
+      }
+
+      bool wasMarked = collector.MarkObject(objaddr);
+      if (!wasMarked) {
+        if (!HasChildRef(objaddr)) {
+          continue;
+        }
+
+        collector.CopyChildRefs(objaddr, workStack);
+      }
+      // try to fork new task if need.
+      TryForkTask();
+    } // end of mark loop.
+    // newly marked statistics.
+    (void)collector.newlyMarked.fetch_add(newlyMarked, std::memory_order_relaxed);
+  }
+
+ private:
+  MarkSweepCollector &collector;
+  MplThreadPool *threadPool;
+  TracingCollector::WorkStack workStack;
+  size_t newlyMarked = 0;
+};
+
+#if MRT_TEST_CONCURRENT_MARK
+struct RootInfo {
+  std::unordered_set<address_t> staticRoots;
+  std::unordered_set<address_t> extRoots;
+  std::unordered_set<address_t> stringRoots;
+  std::unordered_set<address_t> refRoots;
+  std::unordered_set<address_t> allocatorRoots;
+  std::unordered_set<address_t> classloaderRoots;
+  std::unordered_set<address_t> stackRoots;
+
+  std::string WhatRoot(address_t obj) const {
+    std::ostringstream oss;
+    if (staticRoots.count(obj) != 0) {
+      oss << ":static";
+    }
+    if (extRoots.count(obj) != 0) {
+      oss << ":ext";
+    }
+    if (stringRoots.count(obj) != 0) {
+      oss << ":string";
+    }
+    if (refRoots.count(obj) != 0) {
+      oss << ":ref";
+    }
+    if (allocatorRoots.count(obj) != 0) {
+      oss << ":alloc";
+    }
+    if (classloaderRoots.count(obj) != 0) {
+      oss << ":cloader";
+    }
+    if (stackRoots.count(obj) != 0) {
+      oss << ":stack";
+    }
+    return oss.str();
+  };
+};
+
+static void GCLogPrintObjects(const char *title, const std::vector<address_t> &objects, MrtBitmap &bitmap,
+                              bool findOwner = false, const RootInfo *rootInfo = nullptr) {
+  constexpr size_t kMaxPrintCount = 10;
+  LOG2FILE(kLogtypeGc) << title << '\n';
+  for (size_t i = 0; i < objects.size() && i < kMaxPrintCount; ++i) {
+    address_t obj = objects.at(i);
+    MClass *cls = reinterpret_cast<MObject*>(obj)->GetClass();
+    const char *cname = (cls == nullptr) ? "<null>" : cls->GetName();
+    LOG2FILE(kLogtypeGc) << reinterpret_cast<void*>(obj) <<
+        std::hex <<
+        " rc:" << RefCountLVar(obj) <<
+        " hd:" << GCHeader(obj) <<
+        std::dec <<
+        " mark:" << bitmap.IsObjectMarked(obj) <<
+        " " << ((rootInfo != nullptr) ? rootInfo->WhatRoot(obj) : "") <<
+        " " << cname <<
+        '\n';
+    if (findOwner) {
+      (*theAllocator).ForEachObj([obj, rootInfo, &bitmap](address_t owner) {
+        auto refFunc = [rootInfo, &bitmap, owner, obj](reffield_t &field, uint64_t kind) {
+          if ((static_cast<address_t>(field) == obj) && (kind != kUnownedRefBits)) {
+            address_t fieldOffset = (address_t)(&field) - owner;
+            MClass *ownerCls = reinterpret_cast<MObject*>(owner)->GetClass();
+            const char *ownerCname = (ownerCls == nullptr) ? "<null>" : ownerCls->GetClass();
+            LOG2FILE(kLogtypeGc) << (kind == kNormalRefBits ? "  owner: " : " weak owner: ") <<
+                reinterpret_cast<void*>(owner) <<
+                std::hex <<
+                " +0x" << fieldOffset <<
+                " rc:" << RefCount(owner) <<
+                " hd:" << GCHeader(owner) <<
+                std::dec <<
+                " mark:" << bitmap.IsObjectMarked(owner) <<
+                " " << ((rootInfo != nullptr) ? rootInfo->WhatRoot(owner) : "") <<
+                " " << ownerCname <<
+                '\n';
+          }
+        };
+        ForEachRefField(owner, refFunc);
+      });
+    }
+  }
+}
+
+// we need some Bitmap debug functions when testing concurrent mark.
+#if !(MRT_DEBUG_BITMAP)
+#error "Please enable MRT_DEBUG_BITMAP in bitmap.h when MRT_TEST_CONCURRENT_MARK enabled."
+#endif
+
+static void CompareBitmap(const MrtBitmap &bitmap1,
+                          const MrtBitmap &bitmap2,
+                          std::vector<address_t> &unmarked1,
+                          std::vector<address_t> &unmarked2) {
+  const address_t heapStart = (*theAllocator).HeapLowerBound();
+
+  auto words1 = bitmap1.Data();
+  auto words2 = bitmap2.Data();
+  size_t nWords = bitmap1.Size() >> kLogBytesPerWord;
+  using WordType = decltype(*words1);
+
+  // compare word by word.
+  for (size_t i = 0; i < nWords; ++i) {
+    WordType w1 = words1[i];
+    WordType w2 = words2[i];
+
+    // continue if two words are equal.
+    if (w1 == w2) {
+      continue;
+    }
+    // compare bit by bit in the word.
+    for (size_t nBit = 0; nBit < kBitsPerWord; ++nBit) {
+      WordType mask = ((WordType)1 << nBit);
+      bool bit1 = ((w1 & mask) != 0);
+      bool bit2 = ((w2 & mask) != 0);
+
+      // continue if two bits are equal.
+      if (bit1 == bit2) {
+        continue;
+      }
+      // calculate object address by bit position.
+      address_t obj = heapStart + ((i * kBitsPerWord + (kBitsPerWord - 1 - nBit)) << kLogObjAlignment);
+
+      if (bit1) {
+        // bitmap1 marked, but bitmap2 unmarked.
+        unmarked2.push_back(obj);
+      } else {
+        // bitmap2 marked, but bitmap1 unmakred.
+        unmarked1.push_back(obj);
+      }
+    }
+  }
+}
+#endif // MRT_TEST_CONCURRENT_MARK
+
+void MarkSweepCollector::ParallelMark(WorkStack &workStack, bool followReferent) {
+  LOG2FILE(kLogTypeMix) << "Parallel mark work stack size: " << workStack.size() << std::endl;
+
+  newlyMarked.store(0, std::memory_order_relaxed);
+  if (workStack.size() > kMaxMarkTaskSize) {
+    MplThreadPool *threadPool = GetThreadPool();
+    __MRT_ASSERT(threadPool != nullptr, "null thread pool");
+    const int32_t threadCount = GetThreadCount(false);
+    __MRT_ASSERT(threadCount > 1, "incorrect thread count");
+    const size_t kChunkSize = std::min(workStack.size() / threadCount + 1, kMaxMarkTaskSize);
+    // Split the current work stack into work tasks.
+    auto end = workStack.end();
+    for (auto it = workStack.begin(); it < end;) {
+      const size_t delta = std::min(static_cast<size_t>(end - it), kChunkSize);
+      threadPool->AddTask(new (std::nothrow) MarkTask(*this, threadPool, delta, it, followReferent));
+      it += delta;
+    }
+    workStack.clear();
+    threadPool->SetMaxActiveThreadNum(threadCount - 1);
+    threadPool->Start();
+    threadPool->WaitFinish(true);
+
+    LOG2FILE(kLogtypeGc) << "Parallel Newly Marked " << newlyMarked.load(std::memory_order_relaxed) <<
+        " objects in this phase.\n";
+  } else {
+    // serial marking with a single mark task.
+    MarkTask markTask(*this, workStack, followReferent);
+    markTask.Execute(0);
+  }
+}
+
+void MarkSweepCollector::AddMarkTask(RootSet &rs) {
+  if (rs.size() == 0) {
+    return;
+  }
+
+  MplThreadPool *threadPool = GetThreadPool();
+  const size_t kChunkSize = kMaxMarkTaskSize;
+  bool followReferent = false;
+  auto end = rs.end();
+  for (auto it = rs.begin(); it < end;) {
+    const size_t delta = std::min(static_cast<size_t>(end - it), kChunkSize);
+    threadPool->AddTask(new (std::nothrow) MarkTask(*this, threadPool, delta, it, followReferent));
+    it += delta;
+  }
+  rs.clear();
+}
+
+void MarkSweepCollector::ParallelScanMark(RootSet *rootSets, bool processWeak, bool rootString) {
+  MplThreadPool *threadPool = GetThreadPool();
+  const size_t kThreadCount = threadPool->GetMaxThreadNum() + 1;
+
+  // task to scan external roots.
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, processWeak, rootSets](size_t workerID) {
+    ScanExternalRoots(rootSets[workerID], processWeak);
+    AddMarkTask(rootSets[workerID]);
+  }));
+
+  // task to scan reference, allocator and classloader roots.
+  // those scan are very fast, so we combine them into one single task.
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, rootSets](size_t workerID) {
+    ScanReferenceRoots(rootSets[workerID]);
+    ScanAllocatorRoots(rootSets[workerID]);
+    ScanClassLoaderRoots(rootSets[workerID]);
+    AddMarkTask(rootSets[workerID]);
+  }));
+  // task to scan zterp static field roots.
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, rootSets](size_t workerID) {
+    ScanZterpStaticRoots(rootSets[workerID]);
+    AddMarkTask(rootSets[workerID]);
+  }));
+  // task to scan static field roots.
+  staticRootsTaskIndex.store(0);
+  for (size_t t = 0; t < kThreadCount; ++t) {
+    threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, rootSets](size_t workerID) {
+      while (true) {
+        size_t old = staticRootsTaskIndex.fetch_add(1, std::memory_order_release);
+        address_t **list = nullptr;
+        size_t len = 0;
+        {
+          // Even in STW, *.so loading is in safeRegion, we also need to add a lock to avoid racing.
+          bool success = GCRegisteredRoots::Instance().GetRootsLocked(old, list, len);
+          if (!success) {
+            break;
+          }
+          for (size_t i = 0; i < len; ++i) {
+            MaybeAddRoot(LoadStaticRoot(list[i]), rootSets[workerID], true);
+          }
+        }
+      }
+
+      AddMarkTask(rootSets[workerID]);
+    }));
+  }
+
+  // task to scan stack roots.
+  stackTaskIndex.store(0);
+  for (size_t t = 0; t < kThreadCount; ++t) {
+    threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, rootSets](size_t workerID) {
+      RootSet &rs = rootSets[workerID];
+      auto &mutatorList = MutatorList::Instance().List();
+      const size_t mutatorLen = mutatorList.size();
+
+      while (true) {
+        size_t old = stackTaskIndex.fetch_add(1, std::memory_order_release);
+        if (old >= mutatorLen) {
+          break;
+        }
+        auto it = mutatorList.begin();
+        size_t nop = 0;
+        while (nop < old) {
+          ++it;
+          ++nop;
+        }
+        if (doConservativeStackScan) {
+          ScanStackRoots(**it, rs);
+        } else {
+          // for nearly-precise stack scanning
+          (*it)->VisitJavaStackRoots([&rs](address_t ref) {
+            // currently only scan & collect the local var
+            if (LIKELY((*theAllocator).AccurateIsValidObjAddr(ref))) {
+              rs.push_back(ref);
+            }
+          });
+        }
+        // both conservtive and accurate scan, need scan scoped local refs
+        (*it)->VisitNativeStackRoots([&rs](address_t &ref) {
+          if (LIKELY((*theAllocator).AccurateIsValidObjAddr(ref))) {
+            rs.push_back(ref);
+          }
+        });
+      }
+
+      AddMarkTask(rootSets[workerID]);
+    }));
+  }
+
+  // task to scan string roots.
+  if (rootString) {
+    threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, rootSets](size_t workerID) {
+      ScanStringRoots(rootSets[workerID]);
+      AddMarkTask(rootSets[workerID]);
+    }));
+  }
+
+  PostParallelScanMark(processWeak);
+}
+
+void MarkSweepCollector::DoWeakGRT() {
+  size_t numIterated = 0;
+  size_t numCleared = 0;
+
+  RefVisitor rootVisitor = [this, &numIterated, &numCleared](address_t &obj) {
+    ++numIterated;
+    if (InHeapBoundry(obj) && IsGarbage(obj)) {
+      __MRT_ASSERT(obj != DEADVALUE, "must be a valid obj");
+      ++numCleared;
+      DecReferentUnsyncCheck(obj, true);
+      obj = DEADVALUE;
+    }
+  };
+
+  maple::GCRootsVisitor::VisitWeakGRT(rootVisitor);
+
+  LOG2FILE(kLogtypeGc) << "  iterated WeakGRT = " << numIterated << '\n';
+  LOG2FILE(kLogtypeGc) << "  cleared WeakGRT = " << numCleared << '\n';
+}
+
+void MarkSweepCollector::ConcurrentPrepareResurrection() {
+  const size_t vectorCapacity = 100;
+  resurrectCandidates.reserve(vectorCapacity);
+  function<void(address_t)> visitor = [this](address_t objAddr) {
+    if (UNLIKELY(IsUnmarkedResurrectable(objAddr))) {
+      resurrectCandidates.push_back(objAddr);
+    }
+  };
+
+  // an unsafe scan of the heap, only works because we are in concurrent mark
+  // this assumes no objs are actually released by the allocator
+  //      assumes it won't crash when we scan any uninitialised memory (e.g., uninitialised obj)
+  //      assumes all new objs are marked
+  //      assumes the finalizable count always >= actual finalizable objs in page
+  //      assumes all resurrected obj during cm must not unset enqueue flag
+  (*theAllocator).ForEachObjUnsafe(visitor, OnlyVisit::kVisitFinalizable);
+}
+
+void MarkSweepCollector::ConcurrentMarkFinalizer() {
+  WorkStack workStack = resurrectCandidates;
+
+  size_t markedObjs = 0;
+  // loop until work stack and prefetch queue empty.
+  for (;;) {
+    if (workStack.empty()) {
+      break;
+    }
+
+    // get next object from prefetch queue.
+    address_t objAddr = workStack.back();
+    workStack.pop_back();
+
+    // skip dangling reference (such as: object already released).
+    if (UNLIKELY(!IsAllocatedByAllocator(objAddr))) {
+      // kAllocatedBit not set, means the object address is a dangling reference.
+      LOG(ERROR) << "Mark encounter dangling reference: " << objAddr << maple::endl;
+      continue;
+    }
+
+    // skip if the object already marked.
+    if (markBitmap.IsObjectMarked(objAddr) || finalBitmap.IsObjectMarked(objAddr)) {
+      continue;
+    }
+
+    // if object has no child refs.
+    if (!HasChildRef(objAddr)) {
+      ++markedObjs;
+      // mark object and skip child refs.
+      (void)MarkObjectForFinalizer(objAddr);
+      continue;
+    }
+
+    // handle child refs.
+    // remember work stack size before child refs added,
+    // so that we can discard newly added refs if needed.
+    const size_t kOldWorkStackSize = workStack.size();
+
+    // check dirty bit.
+    bool dirty = IsDirty(objAddr);
+    if (LIKELY(!dirty)) {
+      // if object was not modified,
+      // try to copy object child refs into work stack.
+      CopyChildRefs(objAddr, workStack, true);
+      std::atomic_thread_fence(std::memory_order_acq_rel);
+      dirty = IsDirty(objAddr);
+    }
+
+    if (UNLIKELY(dirty)) {
+      // discard copied child refs in work stack.
+      workStack.resize(kOldWorkStackSize);
+    } else {
+      ++markedObjs;
+      (void)MarkObjectForFinalizer(objAddr);
+    }
+  } // end of mark loop.
+  LOG2FILE(kLogtypeGc) << "\tmarked objects for finalizer: " << markedObjs << "\n";
+}
+
+void MarkSweepCollector::ConcurrentAddFinalizerToRP() {
+  size_t nResurrected = 0;
+  WorkStack deadFinalizers;
+  deadFinalizers.reserve(resurrectCandidates.size());
+  for (auto addr : resurrectCandidates) {
+    if (IsGarbageBeforeResurrection(addr) && IsObjResurrectable(addr)) {
+      ++nResurrected;
+      deadFinalizers.push_back(addr);
+    }
+  }
+  ReferenceProcessor::Instance().AddFinalizables(
+      deadFinalizers.data(), static_cast<uint32_t>(deadFinalizers.size()), true);
+  LOG2FILE(kLogtypeGc) << nResurrected << " objects resurrected in " << resurrectCandidates.size() << " candidates.\n";
+}
+
+void MarkSweepCollector::DoResurrection(WorkStack&) {
+  if (Type() == kNaiveRCMarkSweep) {
+    size_t nResurrected = 0;
+    for (auto addr : resurrectCandidates) {
+      if (IsUnmarkedResurrectable(addr)) {
+        ++nResurrected;
+        ReferenceProcessor::Instance().AddFinalizable(addr, false);
+      }
+    }
+    LOG2FILE(kLogtypeGc) << nResurrected << " objects resurrected in " << resurrectCandidates.size() << " candidates\n";
+  } else {
+    // gc need discover Reference
+    for (auto ref : finalizerFindReferences) {
+      GCReferenceProcessor::Instance().DiscoverReference(ref);
+    }
+  }
+  useFinalBitmap = true;
+}
+
+void MarkSweepCollector::ResurrectionCleanup() {
+  WorkStack().swap(resurrectCandidates);
+  WorkStack().swap(finalizerFindReferences);
+}
+
+void MarkSweepCollector::ParallelResurrection(WorkStack &workStack) {
+  if (VLOG_IS_ON(dumpgarbage)) {
+    DumpFinalizeGarbage();
+  }
+  // WARNING: Cannot use vector on the outer level.  We don't know how many
+  // threads the thread pool has.  Lists never invalidate references to its
+  // elements when adding new elements, while vectors may need to be
+  // re-allocated when resizing, causing all references to existing elements to
+  // be invalidated.
+  list<vector<address_t>> finalizablesFromEachTask;
+  // The factory is called when creating each task.
+  Allocator::VisitorFactory visitorFactory = [&finalizablesFromEachTask]() {
+    // NOTE: No locking here, because (1) tasks are created sequentially, and
+    // (2) even if new tasks can be created when old tasks are running,
+    // emplace_back on std::list adds new nodes, but does not modify or
+    // reallocate existing **elements**.
+    finalizablesFromEachTask.emplace_back();
+    vector<address_t> &myFinalizables = finalizablesFromEachTask.back();
+    // NOTE: my_finalizables is an L-value of an element of the
+    // finalizablesFromEachTask vector.  Each returned lambda function
+    // captures a different element of the finalizablesFromEachTask by
+    // reference (capturing the address), therefore different tasks (and
+    // threads) do not share any vectors.
+    return [&myFinalizables](address_t objaddr) {
+      if (IsUnmarkedResurrectable(objaddr)) {
+        myFinalizables.push_back(objaddr); // No need for locking because each task uses its own vector
+      }
+    };
+  };
+  if (UNLIKELY(!(*theAllocator).ParallelForEachObj(*GetThreadPool(), visitorFactory,
+                                                   OnlyVisit::kVisitFinalizable))) {
+    LOG(ERROR) << "(*theAllocator).ParallelForEachObj() in TracingCollector::ParallelResurrection() return false.";
+  }
+  GCLog().Stream() << "Number of parallel tasks: " << finalizablesFromEachTask.size() << std::endl;
+
+  size_t numResurrected = 0;
+  for (auto &finalizables : finalizablesFromEachTask) {
+    for (auto objaddr : finalizables) {
+#if __MRT_DEBUG
+      if (!IsUnmarkedResurrectable(objaddr)) {
+        LOG(FATAL) << "Attempted to resurrect non-resurrectable object. " <<
+            reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(objaddr))->GetClass()->GetName() << maple::endl;
+      }
+#endif
+      // Add to the finalization queue instead of freeing the object
+      // NOTE: __MRT_addFinalizableObj internally holds a mutex before adding
+      // the object to the queue, so it may be faster to create a batch version,
+      // such as __MRT_addManyFinalizableObj.  But tests show that the current
+      // single-threaded performance is good enough for now because the mutex is
+      // never contended.
+      ReferenceProcessor::Instance().AddFinalizable(objaddr, true);
+      {
+        ++numResurrected;
+
+        // Put it into the tracing work stack so that we continue marking from it.
+        Enqueue(objaddr, workStack);
+      }
+    }
+  }
+
+  LOG2FILE(kLogtypeGc) << numResurrected << " objects resurrected.\n";
+}
+
+void MarkSweepCollector::EnqueueNeighbors(address_t objAddr, WorkStack &workStack) {
+  auto refFunc = [this, &workStack, objAddr](reffield_t &field, uint64_t kind) {
+    address_t ref = RefFieldToAddress(field);
+    if ((kind != kUnownedRefBits) && InHeapBoundry(ref)) {
+      LOG2FILE(kLogTypeMix) << "enqueueing neighbor: 0x" << std::hex << ref << std::endl;
+      // This might hurt cache
+      if (UNLIKELY(!IsAllocatedByAllocator(ref))) {
+        LOG(ERROR) << "EnqueueNeighbors Adding released object into work queue " << std::hex <<
+            ref << " " << RCHeader(ref) << " " << GCHeader(ref) <<
+            " " << reinterpret_cast<MObject*>(ref)->GetClass()->GetName() <<
+            objAddr << " " << RCHeader(objAddr) << " " << GCHeader(objAddr) <<
+            " " << reinterpret_cast<MObject*>(objAddr)->GetClass()->GetName() <<
+            std::dec << maple::endl;
+        HandleRCError(ref);
+      }
+      Enqueue(ref, workStack);
+    }
+  };
+  ForEachRefField(objAddr, refFunc);
+}
+
+void MarkSweepCollector::EnqueueNeighborsForRef(address_t objAddr, WorkStack &workStack) {
+  address_t referentOffset = WellKnown::kReferenceReferentOffset;
+  MClass *klass = reinterpret_cast<MObject*>(objAddr)->GetClass();
+  uint32_t classFlag = klass->GetFlag();
+  if ((classFlag & modifier::kClassSoftReference) && !ReferenceProcessor::Instance().ShouldClearReferent(gcReason)) {
+    referentOffset = 0;
+  }
+  auto refFunc = [this, &workStack, objAddr, referentOffset](reffield_t &field, uint64_t kind) {
+    address_t ref = RefFieldToAddress(field);
+    if ((kind != kUnownedRefBits) && InHeapBoundry(ref)) {
+      LOG2FILE(kLogTypeMix) << " enqueueing neighbor for ref: 0x" << std::hex << ref << std::endl;
+      if (static_cast<int32_t>(reinterpret_cast<address_t>(&field) - objAddr) !=
+          static_cast<int32_t>(referentOffset)) {
+        if (UNLIKELY(!IsAllocatedByAllocator(ref))) {
+          LOG(ERROR) << "EnqueueNeighbors Adding released object into work queue " << std::hex <<
+              ref << " " << RCHeader(ref) << " " << GCHeader(ref) <<
+              " " << reinterpret_cast<MObject*>(ref)->GetClass()->GetName() <<
+              objAddr << " " << RCHeader(objAddr) << " " << GCHeader(objAddr) <<
+              " " << reinterpret_cast<MObject*>(objAddr)->GetClass()->GetName() <<
+              std::dec << maple::endl;
+          HandleRCError(ref);
+        }
+        Enqueue(ref, workStack);
+      } else if (Type() != kNaiveRCMarkSweep) {
+        // visit referent and running with GC
+        if (ref != 0 && ReferenceGetPendingNext(objAddr) == 0 && IsGarbage(ref)) {
+          GCReferenceProcessor::Instance().DiscoverReference(objAddr);
+        }
+      }
+    }
+  };
+  ForEachRefField(objAddr, refFunc);
+}
+
+#if MRT_TEST_CONCURRENT_MARK
+static MrtBitmap snapshotBitmap;
+#endif
+
+void MarkSweepCollector::ConcurrentMSPreSTW1() {
+  SatbBuffer::Instance().Init(&markBitmap);
+}
+
+void MarkSweepCollector::ConcurrentMarkPrepare() {
+#if MRT_TEST_CONCURRENT_MARK
+  // To test the correctness of concurrent mark, we run a marking
+  // in stop-the-world-1 stage before concurrent mark started, after
+  // concurrent mark finished we compare their mark bitmaps to find
+  // out objects which are not correctlly marked.
+  {
+    LOG2FILE(kLogtypeGc) << "TestConcurrentMark: snapshot mark...\n";
+    MRT_PHASE_TIMER("TestConcurrentMark: snapshot mark");
+    WorkStack workStack;
+    ParallelScanRoots(workStack, true, false);
+    ParallelMark(workStack);
+
+    // save bitmap to snapshotBitmap.
+    snapshotBitmap.CopyBitmap(markBitmap);
+    markBitmap.ResetBitmap();
+  }
+#endif
+
+  // reset statistic.
+  newlyMarked.store(0, std::memory_order_relaxed);
+  newObjDuringMarking.store(0, std::memory_order_relaxed);
+  freedObjDuringMarking.store(0, std::memory_order_relaxed);
+  renewObjDuringMarking.store(0, std::memory_order_relaxed);
+
+  // set flag to indicate that concurrent marking is started.
+  SetConcurrentMarkRunning(true);
+  for (Mutator *mutator : MutatorList::Instance().List()) {
+    mutator->SetConcurrentMarking(true);
+  }
+}
+
+void MarkSweepCollector::ScanStackAndMark(Mutator &mutator) {
+  TracingCollector::WorkStack workStack;
+  if (doConservativeStackScan) {
+    mutator.VisitStackSlotsContent(
+      [&workStack](address_t ref) {
+        // most of stack slots are not java heap address.
+        if (UNLIKELY((*theAllocator).AccurateIsValidObjAddrConcurrent(ref))) {
+          workStack.push_back(ref);
+        }
+      }
+    );
+    mutator.VisitJavaStackRoots([&workStack](address_t ref) {
+      // currently only scan & collect the local var
+      if (LIKELY((*theAllocator).AccurateIsValidObjAddrConcurrent(ref))) {
+        workStack.push_back(ref);
+      }
+    });
+  } else {
+    mutator.VisitJavaStackRoots([&workStack](address_t ref) {
+      // currently only scan & collect the local var
+      if (LIKELY((*theAllocator).AccurateIsValidObjAddrConcurrent(ref))) {
+        workStack.push_back(ref);
+      }
+    });
+  }
+
+  // add a mark task
+  if (workStack.size() > 0) {
+    MplThreadPool *threadPool = GetThreadPool();
+    threadPool->AddTask(new (std::nothrow) ConcurrentMarkTask(*this, threadPool, workStack.begin(), workStack.size()));
+  }
+
+  // the stack is scanned, dec needScanMutators
+  if (numMutatorToBeScan.fetch_sub(1, std::memory_order_relaxed) == 1) {
+    // notify gc thread
+    concurrentPhaseBarrier.notify_all();
+  }
+}
+
+void MarkSweepCollector::StackScanBarrierInMutator() {
+  // check if need to scan
+  Mutator &mutator = TLMutator();
+  if (mutator.TrySetScanState(true)) {
+    // help gc thread to finish
+    // scan the stack of the mutator
+    ScanStackAndMark(mutator);
+    mutator.FinishStackScan(false);
+
+    std::lock_guard<std::mutex> guard(snapshotMutex);
+    snapshotMutators.erase(&mutator);
+  }
+}
+
+void MarkSweepCollector::ConcurrentStackScan() {
+  while (true) {
+    Mutator *mutator = nullptr;
+    bool needScan = false;
+    {
+      std::lock_guard<std::mutex> guard(snapshotMutex);
+      if (snapshotMutators.size() != 0) {
+        mutator = *(snapshotMutators.begin());
+        snapshotMutators.erase(mutator);
+      } else {
+        return;
+      }
+      needScan = mutator->TrySetScanState(false);
+    }
+    if (needScan) {
+      // scan the stack of the mutator
+      ScanStackAndMark(*mutator);
+      mutator->FinishStackScan(true);
+    }
+  }
+}
+
+void MarkSweepCollector::ScanSingleStaticRoot(address_t *rootAddr, TracingCollector::WorkStack &workStack) {
+  const reffield_t ref = LoadStaticRoot(rootAddr);
+  // most of static fields are null or non-heap objects (e.g. literal strings).
+  if (UNLIKELY(InHeapBoundry(ref))) {
+    address_t value = RefFieldToAddress(ref);
+    if (LIKELY(!IsObjectMarked(value))) {
+      workStack.push_back(ref);
+    }
+  }
+}
+
+void MarkSweepCollector::ConcurrentStaticRootsScan(bool parallel) {
+  TracingCollector::WorkStack workStack;
+
+  // scan static field roots.
+  address_t **staticList;
+  size_t staticListLen;
+  size_t index = 0;
+
+  while (GCRegisteredRoots::Instance().GetRootsLocked(index++, staticList, staticListLen)) {
+    for (size_t i = 0; i < staticListLen; ++i) {
+      ScanSingleStaticRoot(staticList[i], workStack);
+    }
+  }
+  // zterp static field roots
+  address_t spaceAddr = (*zterpStaticRootAllocator).GetStartAddr();
+  for (size_t i = 0; i < (*zterpStaticRootAllocator).GetObjNum(); ++i) {
+    ScanSingleStaticRoot(*(reinterpret_cast<address_t**>(spaceAddr)), workStack);
+    spaceAddr += ZterpStaticRootAllocator::singleObjSize;
+  }
+  // add a concurrent mark task.
+  MplThreadPool *threadPool = GetThreadPool();
+  if (parallel && threadPool != nullptr) {
+    AddConcurrentMarkTask(workStack);
+  } else {
+    // serial marking with a single mark task.
+    ConcurrentMarkTask markTask(*this, std::move(workStack));
+    markTask.Execute(0);
+  }
+}
+
+void MarkSweepCollector::ConcurrentMark(WorkStack &workStack, bool parallel, bool scanRoot) {
+  __MRT_ASSERT(IsConcurrentMarkRunning(), "running flag not set");
+
+  // enable parallel marking if we have thread pool.
+  MplThreadPool *threadPool = GetThreadPool();
+  __MRT_ASSERT(threadPool != nullptr, "thread pool is null");
+  if (parallel) {
+    // parallel marking.
+    AddConcurrentMarkTask(workStack);
+    workStack.clear();
+    threadPool->Start();
+
+    if (scanRoot) {
+      // precise stack scan
+      ConcurrentStackScan();
+
+      // concurrent mark static roots.
+      ConcurrentStaticRootsScan(parallel);
+    }
+
+    threadPool->WaitFinish(true);
+  } else {
+    if (scanRoot) {
+      // scan stack roots and add into task queue
+      ConcurrentStackScan();
+      // mark static roots.
+      ConcurrentStaticRootsScan(false);
+    }
+    // serial marking with a single mark task.
+    ConcurrentMarkTask markTask(*this, std::move(workStack));
+    markTask.Execute(0);
+    threadPool->DrainTaskQueue(); // drain stack roots task
+  }
+
+  // wait if the mutator is scanning the stack
+  if (numMutatorToBeScan.load(std::memory_order_relaxed) != 0) {
+    std::unique_lock<std::mutex> lk(snapshotMutex);
+    concurrentPhaseBarrier.wait(lk, [this]{
+      return numMutatorToBeScan.load(std::memory_order_relaxed) == 0;
+    });
+  }
+}
+
+void MarkSweepCollector::ConcurrentReMark(bool parallel) {
+  constexpr int kReMarkRounds = 2;
+  for (int i = 0; i < kReMarkRounds; ++i) {
+    // find out unmarked dirty objects.
+    WorkStack remarkStack;
+    {
+      MRT_PHASE_TIMER("Get re-mark stack");
+      SatbBuffer::Instance().GetRetiredObjects(remarkStack);
+    }
+
+    MplThreadPool *threadPool = GetThreadPool();
+    if (remarkStack.empty() && (threadPool->GetTaskNumber() == 0)) {
+      // stop re-mark if work stack is empty.
+      return;
+    }
+
+    LOG2FILE(kLogtypeGc) << "  re-mark stack: " << Pretty(remarkStack.size()) << '\n';
+
+    // run re-mark if remarkStack not empty.
+    {
+      MRT_PHASE_TIMER("Run re-mark");
+      ConcurrentMark(remarkStack, parallel && (remarkStack.size() > kMaxMarkTaskSize), false);
+    }
+  }
+}
+
+// should be called in the beginning of stop-the-world-2.
+void MarkSweepCollector::ConcurrentMarkCleanup() {
+  __MRT_ASSERT(IsConcurrentMarkRunning(), "running flag not set");
+
+  // statistics.
+  const size_t markObjects = newlyMarked.load(std::memory_order_relaxed);
+  const size_t newObjects = newObjDuringMarking.load(std::memory_order_relaxed);
+  const size_t freeObjects = freedObjDuringMarking.load(std::memory_order_relaxed);
+  const size_t renewObjects = renewObjDuringMarking.load(std::memory_order_relaxed);
+
+  LOG2FILE(kLogtypeGc) << "  mark   " << Pretty(markObjects) << '\n' <<
+      "  new    " << Pretty(newObjects)    << '\n' <<
+      "  free   " << Pretty(freeObjects)   << '\n' <<
+      "  renew  " << Pretty(renewObjects)  << '\n';
+
+#if MRT_TEST_CONCURRENT_MARK
+  // compare concurrent mark bitmap with snapshot bitmap.
+  std::vector<address_t> stwUnmarked;
+  std::vector<address_t> cmUnmarked;
+  CompareBitmap(snapshotBitmap, markBitmap, stwUnmarked, cmUnmarked);
+
+  LOG2FILE(kLogtypeGc) << "TestConcurrentMark:\n" <<
+      "  snapshot unmarked:   " << Pretty(stwUnmarked.size()) << '\n' <<
+      "  concurrent unmarked: " << Pretty(cmUnmarked.size())  << '\n';
+
+  if (cmUnmarked.size() > 0) {
+    GCLogPrintObjects("=== concurrent unmarked ===", cmUnmarked, markBitmap, true);
+    LOG2FILE(kLogtypeGc) << "TestConcurrentMark failed!" << std::endl; // flush gclog.
+    LOG(FATAL) << "TestConcurrentMark failed! found unmarked alives: " << cmUnmarked.size() << maple::endl;
+  }
+
+  stwUnmarked.clear();
+  cmUnmarked.clear();
+#endif
+
+  // find out unmarked dirty objects.
+  WorkStack remarkStack;
+  {
+    MRT_PHASE_TIMER("Find re-mark objects");
+    SatbBuffer::Instance().GetRetiredObjects(remarkStack);
+    auto func = [&](Mutator *mutator) {
+      const SatbBuffer::Node *node = mutator->GetSatbBufferNode();
+      mutator->SetConcurrentMarking(false);
+      if (node != nullptr) {
+        node->GetObjects(remarkStack);
+        mutator->ResetSatbBufferNode();
+      }
+    };
+    MutatorList::Instance().VisitMutators(func);
+  }
+
+  LOG2FILE(kLogtypeGc) << "  stw re-mark stack: " << Pretty(remarkStack.size()) << '\n';
+
+#if MRT_TEST_CONCURRENT_MARK
+  // print remark stack if test is enabled.
+  if (remarkStack.size() > 0) {
+    GCLogPrintObjects("=== Need Re-mark ===", remarkStack, markBitmap);
+  }
+#endif
+
+  // start re-mark if needed, re-mark is marking on heap snapshot.
+  // we are more likely have an empty remark stack because of concurrent re-marking.
+  MplThreadPool *threadPool = GetThreadPool();
+  if (UNLIKELY((remarkStack.size() > 0) || (threadPool->GetTaskNumber() > 0))) {
+    MRT_PHASE_TIMER("Re-mark");
+    ConcurrentMark(remarkStack, (remarkStack.size() > kMaxMarkTaskSize) || (threadPool->GetTaskNumber() > 0), false);
+  }
+
+  // set flag to indicate that concurrent marking is done.
+  SetConcurrentMarkRunning(false);
+
+  // update heap bound again in the beginning of STW-2 stage.
+  InitTracing();
+
+#if MRT_TEST_CONCURRENT_MARK
+  // To test the correctness of concurrent mark, we run a marking again
+  // after concurrent mark finished in stop-the-world-2 stage, and then
+  // compare their mark bitmaps to find out objects which are not
+  // correctlly marked.
+  LOG2FILE(kLogtypeGc) << "TestConcurrentMark...\n";
+  MRT_PHASE_TIMER("TestConcurrentMark");
+
+  // before we start another marking, make a copy of current mark bitmap,
+  // and then reset current mark bitmap.
+  MrtBitmap bitmap;
+  bitmap.CopyBitmap(markBitmap);
+  markBitmap.ResetBitmap();
+
+  // scan roots and marking.
+  {
+    MRT_PHASE_TIMER("TestConcurrentMark: scan roots & mark");
+    WorkStack workStack;
+    ParallelScanRoots(workStack, true, false);
+    ParallelMark(workStack);
+  }
+
+  // compare two bitmaps to find out error.
+  CompareBitmap(markBitmap, bitmap, stwUnmarked, cmUnmarked);
+
+  // We treat objects which are marked by concurrent marking, but
+  // not marked by STW marking, and not released as floating garbages.
+  size_t nFloatingGarbages = 0;
+  for (address_t obj : stwUnmarked) {
+    if (!HasReleasedBit(obj)) {
+      ++nFloatingGarbages;
+    }
+  }
+
+  LOG2FILE(kLogtypeGc) << "TestConcurrentMark:\n" <<
+      "  stw unmarked: " << stwUnmarked.size() << '\n' <<
+      "  floating garbages: " << nFloatingGarbages << '\n' <<
+      "  unmarked live objects: " << cmUnmarked.size() << '\n';
+
+  if (cmUnmarked.size() > 0) {
+    // scan root info.
+    RootInfo rootInfo;
+    std::vector<address_t> rs;
+
+    ScanStaticFieldRoots(rs);
+    rootInfo.staticRoots.insert(rs.begin(), rs.end());
+    rs.clear();
+
+    ScanExternalRoots(rs, true);
+    rootInfo.extRoots.insert(rs.begin(), rs.end());
+    rs.clear();
+
+    ScanStringRoots(rs);
+    rootInfo.stringRoots.insert(rs.begin(), rs.end());
+    rs.clear();
+
+    ScanReferenceRoots(rs);
+    rootInfo.refRoots.insert(rs.begin(), rs.end());
+    rs.clear();
+
+    ScanAllocatorRoots(rs);
+    rootInfo.allocatorRoots.insert(rs.begin(), rs.end());
+    rs.clear();
+
+    ScanClassLoaderRoots(rs);
+    rootInfo.classloaderRoots.insert(rs.begin(), rs.end());
+    rs.clear();
+
+    ScanAllStacks(rs);
+    rootInfo.stackRoots.insert(rs.begin(), rs.end());
+    rs.clear();
+
+    GCLogPrintObjects("=== unmarked live objects ===", cmUnmarked, markBitmap, true, &rootInfo);
+    LOG2FILE(kLogtypeGc) << "WARNING: check unmarked objects!" << std::endl; // flush gclog.
+
+    // we set rc to 0 for unmarked objects, so that 'inc/dec from 0' occurs if mutator access them.
+    for (address_t obj : cmUnmarked) {
+      RefCountLVal(obj) = 0;
+    }
+  }
+
+  LOG2FILE(kLogtypeGc) << "TestConcurrentMark done." << std::endl; // flush gclog.
+
+  // restore bitmap after test.
+  markBitmap.CopyBitmap(bitmap);
+#endif // MRT_TEST_CONCURRENT_MARK
+}
+
+void MarkSweepCollector::ConcurrentMSPostSTW2() {
+  SatbBuffer::Instance().Reset();
+}
+
+void MarkSweepCollector::RunFullCollection(uint64_t gcIndex) {
+  // prevent other threads stop-the-world during GC.
+  ScopedLockStopTheWorld lockStopTheWorld;
+
+  PreMSHook();
+
+  // Run mark-and-sweep gc.
+  RunMarkAndSweep(gcIndex);
+
+  PostMSHook(gcIndex);
+}
+
+void MarkSweepCollector::RunMarkAndSweep(uint64_t gcIndex) {
+  // prepare thread pool.
+  MplThreadPool *threadPool = GetThreadPool();
+  const int32_t threadCount = GetThreadCount(false);
+  __MRT_ASSERT(threadCount > 1, "unexpected thread count");
+  threadPool->SetPriority(maple::kGCThreadStwPriority);
+  threadPool->SetMaxActiveThreadNum(threadCount);
+
+  const uint64_t gcStartNs = timeutils::NanoSeconds();
+  const GCReason reason = gcReason;
+  const bool concurrent = IsConcurrent(reason);
+  LOG(INFO) << "[GC] Start " << reasonCfgs[reason].name << " gcIndex= " << gcIndex << maple::endl;
+
+  stats::gcStats->BeginGCRecord();
+  stats::gcStats->CurrentGCRecord().reason = reason;
+  stats::gcStats->CurrentGCRecord().async = reasonCfgs[reason].IsNonBlockingGC();
+  stats::gcStats->CurrentGCRecord().isConcurrentMark = concurrent;
+
+  // run mark & sweep.
+  if (LIKELY(concurrent)) {
+    ConcurrentMarkAndSweep();
+  } else {
+    ParallelMarkAndSweep();
+  }
+
+  // releaes mark bitmap memory after GC.
+  ResetBitmap();
+
+  // it's the end of boot phase or it's a user_ni GC
+  GCReleaseSoType releaseSoType = reasonCfgs[reason].ShouldReleaseSo();
+  if (releaseSoType != kReleaseNone) {
+    MRT_PHASE_TIMER("ReleaseBootMemory");
+    MRT_ClearMetaProfile();
+    LinkerAPI::Instance().ClearAllMplFuncProfile();
+    LOG(INFO) << "Force GC finished" << maple::endl;
+    // release boot-phase maple*.so memory
+    LinkerAPI::Instance().ReleaseBootPhaseMemory(false, (releaseSoType == kReleaseAppSo) ? IsSystem() : true);
+  }
+
+  // release pages in PagePool
+  PagePool::Instance().Trim();
+
+  // update NativeGCStats after gc finished.
+  NativeGCStats::Instance().OnGcFinished();
+
+  // total GC time.
+  uint64_t gcTimeNs = timeutils::NanoSeconds() - gcStartNs;
+  stats::gcStats->CurrentGCRecord().totalGcTime = gcTimeNs;
+  LOG2FILE(kLogtypeGc) << "Total GC time: " << Pretty(gcTimeNs / kNsPerUs) << "us" << "\n";
+
+  // trigger reference processor after GC finished.
+  ReferenceProcessor::Instance().Notify(true);
+}
+
+void MarkSweepCollector::PreMSHook() {
+  // Notify that GC has started.  We need to set the gc_running_ flag here
+  // because it is a guarantee that when TriggerGCAsync returns, the caller sees GC running.
+  SetGcRunning(true);
+}
+
+void MarkSweepCollector::PreSweepHook() {
+}
+
+void MarkSweepCollector::PostMSHook(uint64_t gcIndex) {
+  if (UNLIKELY(VLOG_IS_ON(allocatorfragmentlog))) {
+    if (IsConcurrent(gcReason)) {
+      ScopedStopTheWorld stopTheWorld;
+      std::stringstream ss;
+      (*theAllocator).PrintPageFragment(ss, "AfterGC");
+      LOG2FILE(kLogTypeAllocFrag) << ss.str() << std::flush;
+    }
+  }
+
+  GCReason reason = gcReason;
+  SetGcRunning(false);
+  NotifyGCFinished(gcIndex);
+
+  // some jobs can be done after NotifyGCFinished(), if they don't block the waiting threads
+  {
+    MRT_PHASE_TIMER("Post-MS hook: release free pages");
+    bool aggressive = reasonCfgs[reason].ShouldTrimHeap();
+    // release the physical memory of free pages
+    if (!(*theAllocator).ReleaseFreePages(aggressive)) {
+      LOG(INFO) << "no page released";
+    }
+  }
+
+  // commit gc statistics.
+  stats::gcStats->CommitGCRecord();
+
+  // flush gclog.
+  GCLog().OnGCEnd();
+}
+
+// stop the world parallel mark & sweep.
+void MarkSweepCollector::ParallelMarkAndSweep() {
+  ScopedStopTheWorld stw;
+  const uint64_t stwStartNs = timeutils::NanoSeconds();
+  PrepareTracing();
+  ParallelMarkPhase();
+  ResurrectionPhase(false);
+  ParallelSweepPhase();
+  FinishTracing();
+  DumpAfterGC();
+  const uint64_t stwTimeNs = timeutils::NanoSeconds() - stwStartNs;
+  stats::gcStats->CurrentGCRecord().stw1Time = stwTimeNs;
+  stats::gcStats->CurrentGCRecord().stw2Time = 0;
+  TheAllocMutator::gcIndex++;
+  LOG2FILE(kLogtypeGc) << "Stop-the-world time: " << Pretty(stwTimeNs / kNsPerUs) << "us\n";
+}
+
+// concurrent mark & sweep.
+void MarkSweepCollector::ConcurrentMarkAndSweep() {
+  ConcurrentMSPreSTW1();
+  WorkStack workStack = NewWorkStack();
+  WorkStack inaccurateRoots = NewWorkStack();
+  {
+    ScopedStopTheWorld stw1;
+    const uint64_t stw1StartNs = timeutils::NanoSeconds();
+    PrepareTracing();
+    ConcurrentMarkPreparePhase(workStack, inaccurateRoots);
+    const uint64_t stw1TimeNs = timeutils::NanoSeconds() - stw1StartNs;
+    stats::gcStats->CurrentGCRecord().stw1Time = stw1TimeNs;
+    LOG2FILE(kLogtypeGc) << "Stop-the-world-1 time: " << Pretty(stw1TimeNs / kNsPerUs) << "us\n";
+  }
+  ConcurrentMarkPhase(std::move(workStack), std::move(inaccurateRoots));
+  {
+    ScopedStopTheWorld stw2;
+    const uint64_t stw2StartNs = timeutils::NanoSeconds();
+    ConcurrentMarkCleanupPhase();
+    ResurrectionPhase(true);
+    ConcurrentSweepPreparePhase();
+    FinishTracing();
+    const uint64_t stw2TimeNs = timeutils::NanoSeconds() - stw2StartNs;
+    stats::gcStats->CurrentGCRecord().stw2Time = stw2TimeNs;
+    TheAllocMutator::gcIndex++;
+    LOG2FILE(kLogtypeGc) << "Stop-the-world-2 time: " << Pretty(stw2TimeNs / kNsPerUs) << "us\n";
+  }
+  ConcurrentMSPostSTW2();
+  ConcurrentSweepPhase();
+}
+
+void MarkSweepCollector::PrepareTracing() {
+  GCLog().OnGCStart();
+  LOG2FILE(kLogtypeGc) << "GCReason: " << reasonCfgs[gcReason].name << '\n';
+
+  if (VLOG_IS_ON(opengclog)) {
+    (*theAllocator).DumpContention(GCLog().Stream());
+  }
+
+  if (VLOG_IS_ON(allocatorfragmentlog)) {
+    std::stringstream ss;
+    (*theAllocator).PrintPageFragment(ss, "BeforeGC");
+    LOG2FILE(kLogTypeAllocFrag) << ss.str() << std::flush;
+  }
+
+  if (VLOG_IS_ON(dumpheapbeforegc)) {
+    DumpHeap("before_gc");
+  }
+
+#if RC_HOT_OBJECT_DATA_COLLECT
+  DumpHotObj();
+#endif
+
+  InitTracing();
+}
+
+void MarkSweepCollector::FinishTracing() {
+  EndTracing();
+
+  // Call the registerd callback before starting the world.
+  {
+    MRT_PHASE_TIMER("Calling GC-finish callback");
+    GCFinishCallBack();
+  }
+}
+
+void MarkSweepCollector::DumpAfterGC() {
+  if (VLOG_IS_ON(dumpheapaftergc)) {
+    DumpHeap("after_gc");
+  }
+
+  if (VLOG_IS_ON(allocatorfragmentlog)) {
+    std::stringstream ss;
+    (*theAllocator).PrintPageFragment(ss, "AfterGC");
+    LOG2FILE(kLogTypeAllocFrag) << ss.str() << std::flush;
+  }
+}
+
+void MarkSweepCollector::ParallelMarkPhase() {
+  MplThreadPool *threadPool = GetThreadPool();
+  const size_t threadCount = threadPool->GetMaxThreadNum() + 1;
+  clockid_t cid[threadCount];
+  struct timespec workerStart[threadCount];
+  struct timespec workerEnd[threadCount];
+  uint64_t workerCpuTime[threadCount];
+#ifdef __ANDROID__
+  // qemu does not support sys_call: sched_getcpu()
+  // do not support profile executing cpu of workers
+  const bool profileSchedCore = true;
+#else
+  const bool profileSchedCore = false;
+#endif
+  // record executing cpu of workers in each sampling point
+  std::vector<int> schedCores[threadCount];
+
+  if (GCLog().IsWriteToFile(kLogTypeMix)) {
+    // debug functionality: set sched_core and cputime
+    size_t index = 1;
+    for (auto worker: threadPool->GetThreads()) {
+      pthread_t thread = worker->GetThread();
+      worker->schedCores = profileSchedCore ? &schedCores[index] : nullptr;
+      pthread_getcpuclockid(thread, &cid[index]);
+      clock_gettime(cid[index], &workerStart[index]);
+      ++index;
+    }
+    pthread_getcpuclockid(pthread_self(), &cid[0]);
+    clock_gettime(cid[0], &workerStart[0]);
+  }
+
+  {
+    MRT_PHASE_TIMER("Parallel Scan Roots & Mark");
+    // prepare
+    threadPool->Start();
+    RootSet rootSets[threadCount];
+
+    ParallelScanMark(rootSets, true, false);
+
+    threadPool->WaitFinish(true, profileSchedCore ? &schedCores[0] : nullptr);
+  }
+
+  if (GCLog().IsWriteToFile(kLogTypeMix)) {
+    // debug functionality: print cputime & sched core
+    for (size_t i = 0; i < threadCount; ++i) {
+      clock_gettime(cid[i], &workerEnd[i]);
+      workerCpuTime[i] = static_cast<uint64_t>(workerEnd[i].tv_sec - workerStart[i].tv_sec) *
+          maple::kSecondToNanosecond + static_cast<uint64_t>((workerEnd[i].tv_nsec - workerStart[i].tv_nsec));
+    }
+    int cpus[threadCount][threadCount];
+    errno_t ret = memset_s(cpus, sizeof(cpus), 0, sizeof(cpus));
+    if (UNLIKELY(ret != EOK)) {
+      LOG(ERROR) << "memset_s(cpus, sizeof(cpus), 0, sizeof(cpus)) in ParallelMarkPhase return " <<
+          ret << " rather than 0." << maple::endl;
+    }
+    for (size_t i = 0; i < threadCount; ++i) {
+      for (auto num: schedCores[i]) {
+        cpus[i][num % static_cast<int>(threadCount)] += 1;
+      }
+    }
+
+    for (size_t i = 0; i < threadCount; ++i) {
+      LOG2FILE(kLogtypeGc) << "worker " << i << " cputime:" << workerCpuTime[i] << ",\t";
+      for (size_t j = 0; j < threadCount; ++j) {
+        LOG2FILE(kLogtypeGc) << cpus[i][j] << "\t";
+      }
+      LOG2FILE(kLogtypeGc) << '\n';
+    }
+  }
+}
+
+void MarkSweepCollector::ResurrectionPhase(bool isConcurrent) {
+  if (Type() == kNaiveRCMarkSweep) {
+    MRT_PHASE_TIMER("Reference: Release Queue");
+#if __MRT_DEBUG
+    MrtVisitReferenceRoots([this](address_t obj) {
+      // As stack scan is conservative, it is poissble that released object on stack and marked
+      if (!(InHeapBoundry(obj) && (IsGarbage(obj) || IsRCCollectable(obj)))) {
+        LOG(FATAL) << "Live object in release queue. " <<
+            std::hex << obj << std::dec <<
+            " IsObjectMarked=" << IsObjectMarked(obj) <<
+            " refCount=" << RefCount(obj) <<
+            " weakRefCount=" << WeakRefCount(obj) <<
+            " resurrect weakRefCount=" << ResurrectWeakRefCount(obj) <<
+            (IsWeakCollected(obj) ? " weak collected " : " not weak collected ") <<
+            reinterpret_cast<MObject*>(obj)->GetClass()->GetName() << maple::endl;
+        return;
+      }
+    }, RPMask(kRPReleaseQueue));
+#endif
+    RCReferenceProcessor::Instance().ClearAsyncReleaseObjs();
+  }
+
+  // Handle Soft/Weak Reference.
+  if (UNLIKELY(VLOG_IS_ON(dumpgarbage))) {
+    DumpWeakSoft();
+  }
+
+  if (Type() == kNaiveRCMarkSweep) {
+    if (LIKELY(isConcurrent)) {
+      MRT_PHASE_TIMER("Soft/Weak Refinement");
+      ReferenceRefinement(RPMask(kRPSoftRef) | RPMask(kRPWeakRef));
+    } else {
+      MRT_PHASE_TIMER("Parallel Reference: Soft/Weak");
+      if (Type() == kNaiveRCMarkSweep) {
+        ParallelDoReference(RPMask(kRPSoftRef) | RPMask(kRPWeakRef));
+      }
+    }
+  } else {
+    MRT_PHASE_TIMER("Soft/Weak Discover Processing");
+    GCReferenceProcessor::Instance().ProcessDiscoveredReference(RPMask(kRPSoftRef) | RPMask(kRPWeakRef));
+  }
+
+  // Finalizable resurrection phase.
+  WorkStack workStack = NewWorkStack();
+  {
+    MRT_PHASE_TIMER("Parallel Resurrection");
+    if (isConcurrent) {
+      DoResurrection(workStack);
+    } else {
+      ParallelResurrection(workStack);
+    }
+  }
+
+  LOG2FILE(kLogtypeGc) << "Mark 2:\n" << "  workStack size = " << workStack.size() << '\n';
+  if (!isConcurrent) {
+    MRT_PHASE_TIMER("Parallel Mark 2");
+    ParallelMark(workStack);
+  }
+
+  if (UNLIKELY(VLOG_IS_ON(dumpgarbage))) {
+    DumpCleaner();
+  }
+
+  // Handle Cleaner.
+  if (Type() == kNaiveRCMarkSweep) {
+    if (LIKELY(isConcurrent)) {
+      MRT_PHASE_TIMER("Cleaner Refinement");
+      ReferenceRefinement(RPMask(kRPPhantomRef));
+    } else {
+      MRT_PHASE_TIMER("Parallel Reference: Cleaner");
+      ParallelDoReference(RPMask(kRPPhantomRef));
+    }
+  } else {
+    MRT_PHASE_TIMER("Cleaner: Discover Processing");
+    uint32_t rpFlag = RPMask(kRPSoftRef) | RPMask(kRPWeakRef) | RPMask(kRPPhantomRef);
+    GCReferenceProcessor::Instance().ProcessDiscoveredReference(rpFlag);
+  }
+
+  {
+    MRT_PHASE_TIMER("Reference: WeakGRT");
+    DoWeakGRT();
+  }
+}
+
+void MarkSweepCollector::ConcurrentMarkPreparePhase(WorkStack& workStack, WorkStack& inaccurateRoots) {
+  {
+    // use fast root scan for concurrent marking.
+    MRT_PHASE_TIMER("Fast Root scan");
+    FastScanRoots(workStack, inaccurateRoots, true, false);
+  }
+  // prepare for concurrent marking.
+  ConcurrentMarkPrepare();
+}
+
+void MarkSweepCollector::ConcurrentMarkPhase(WorkStack&& workStack, WorkStack&& inaccurateRoots) {
+  // prepare root set before mark, filter out inaccurate roots.
+  {
+    MRT_PHASE_TIMER("Prepare root set");
+    const size_t accurateSize = workStack.size();
+    const size_t inaccurateSize = inaccurateRoots.size();
+    PrepareRootSet(workStack, std::move(inaccurateRoots));
+    LOG2FILE(kLogtypeGc) << "accurate: " << accurateSize <<
+        " inaccurate: " << inaccurateSize <<
+        " final roots: " << workStack.size() <<
+        '\n';
+  }
+
+  // BT statistic for root size.
+  BTCleanupStats::rootSetSize = workStack.size();
+  MplThreadPool *threadPool = GetThreadPool();
+  __MRT_ASSERT(threadPool != nullptr, "null thread pool");
+
+  // use fewer threads and lower priority for concurrent mark.
+  const int32_t stwWorkers = threadPool->GetMaxActiveThreadNum();
+  const int32_t maxWorkers = GetThreadCount(true) - 1;
+  if (maxWorkers > 0) {
+    threadPool->SetMaxActiveThreadNum(maxWorkers);
+    threadPool->SetPriority(maple::kGCThreadConcurrentPriority);
+  }
+  MRT_SetThreadPriority(maple::GetTid(), maple::kGCThreadConcurrentPriority);
+  LOG2FILE(kLogtypeGc) << "Concurrent mark with " << (maxWorkers + 1) << " threads" <<
+      ", workStack: " << workStack.size() << '\n';
+
+  // run concurrent marking.
+  {
+    MRT_PHASE_TIMER("Concurrent marking");
+    ConcurrentMark(workStack, maxWorkers > 0, true);
+  }
+
+  // concurrent do references
+  if (Type() == kNaiveRCMarkSweep) {
+    InitReferenceWorkSet();
+    {
+      MRT_PHASE_TIMER("Concurrent Do Reference: Soft/Weak");
+      ConcurrentDoReference(RPMask(kRPSoftRef) | RPMask(kRPWeakRef));
+    }
+    {
+      MRT_PHASE_TIMER("Concurrent Do Reference: Cleaner");
+      ConcurrentDoReference(RPMask(kRPPhantomRef));
+    }
+  } else {
+    MRT_PHASE_TIMER("Concurrent Do Reference");
+    GCReferenceProcessor::Instance().ConcurrentProcessDisovered();
+  }
+
+  {
+    MRT_PHASE_TIMER("Concurrent prepare resurrection");
+    ConcurrentPrepareResurrection();
+  }
+
+  {
+    MRT_PHASE_TIMER("Concurrent mark finalizer");
+    ConcurrentMarkFinalizer();
+  }
+
+  // run concurrent re-marking.
+  {
+    MRT_PHASE_TIMER("Concurrent re-marking");
+    ConcurrentReMark(maxWorkers > 0);
+  }
+
+  // restore thread pool max workers and priority after concurrent marking.
+  if (maxWorkers > 0) {
+    threadPool->SetMaxActiveThreadNum(stwWorkers);
+    threadPool->SetPriority(maple::kGCThreadStwPriority);
+  }
+  MRT_SetThreadPriority(maple::GetTid(), maple::kGCThreadStwPriority);
+}
+
+// concurrent marking clean-up, run in STW2.
+void MarkSweepCollector::ConcurrentMarkCleanupPhase() {
+  MRT_PHASE_TIMER("Concurrent marking clean-up");
+  ConcurrentMarkCleanup();
+}
+
+void MarkSweepCollector::ConcurrentSweepPreparePhase() {
+  if (VLOG_IS_ON(dumpgarbage)) {
+    DumpGarbage();
+  }
+  PreSweepHook();
+  {
+    MRT_PHASE_TIMER("Sweep: prepare concurrent for StringTable");
+    StringPrepareConcurrentSweeping();
+  }
+
+  {
+    MRT_PHASE_TIMER("Sweep: prepare concurrent sweep");
+    (*theAllocator).PrepareConcurrentSweep();
+  }
+}
+
+void MarkSweepCollector::ConcurrentSweepPhase() {
+  // reduce the number of thread in concurrent stage.
+  MplThreadPool *threadPool = GetThreadPool();
+  const int32_t maxWorkers = GetThreadCount(true) - 1;
+  if (maxWorkers > 0) {
+    threadPool->SetMaxActiveThreadNum(maxWorkers);
+    threadPool->SetPriority(maple::kGCThreadConcurrentPriority);
+  }
+  MRT_SetThreadPriority(maple::GetTid(), maple::kGCThreadConcurrentPriority);
+
+  if (Type() != kNaiveRCMarkSweep) {
+    // concurrent sweep only sweep unmarked objects in both bitmap.
+    // it's safe to concurrent add finalizer to reference processor.
+    MRT_PHASE_TIMER("Concurrent Add Finalizer");
+    ConcurrentAddFinalizerToRP();
+  }
+
+  {
+    MRT_PHASE_TIMER("Resurrection cleanup");
+    ResurrectionCleanup();
+  }
+
+  {
+    MRT_PHASE_TIMER("Concurrent sweep");
+    (*theAllocator).ConcurrentSweep((maxWorkers > 0) ? threadPool : nullptr);
+  }
+
+  {
+    MRT_PHASE_TIMER("Concurrent sweep StringTable");
+    size_t deadStrings = ConcurrentSweepDeadStrings((maxWorkers > 0) ? threadPool : nullptr);
+    LOG2FILE(kLogtypeGc) << "    Dead strings in StringTable: " << deadStrings << '\n';
+  }
+  if (Type() == kNaiveRCMarkSweep) {
+    ResetReferenceWorkSet();
+  }
+  MRT_SetThreadPriority(maple::GetTid(), maple::kGCThreadPriority);
+}
+
+void MarkSweepCollector::ParallelSweepPhase() {
+  MRT_PHASE_TIMER("Parallel Sweep");
+
+  size_t oldLiveBytes = (*theAllocator).AllocatedMemory();
+  size_t oldLiveObjBytes = (*theAllocator).RequestedMemory();
+  size_t oldTotalObjects = (*theAllocator).AllocatedObjs();
+
+  if (VLOG_IS_ON(dumpgarbage)) {
+    DumpGarbage();
+  }
+
+  PreSweepHook();
+
+  size_t deadStrings;
+  {
+    MRT_PHASE_TIMER("Sweep: Removing String from StringTable");
+    deadStrings = RemoveDeadStringFromPool();
+  }
+
+  MRT_PHASE_TIMER("Parallel Sweep: enumerating and sweeping");
+  auto sweeper = [this](address_t addr) {
+    return CheckAndPrepareSweep(addr);
+  };
+
+#if CONFIG_JSAN
+  auto checkAndSweep = [&sweeper](address_t addr) {
+    if (sweeper(addr)) {
+      (*theAllocator).FreeObj(addr);
+    }
+  };
+  (*theAllocator).ParallelForEachObj(*GetThreadPool(), [&checkAndSweep] {
+      return checkAndSweep;
+    }, OnlyVisit::kVisitAll);
+#else
+  if (UNLIKELY(!(*theAllocator).ParallelFreeAllIf(*GetThreadPool(), sweeper))) {
+    LOG(ERROR) << "(*theAllocator).ParallelFreeAllIf() in ParallelSweepPhase() return false." << maple::endl;
+  }
+#endif
+
+  size_t newLiveBytes = (*theAllocator).AllocatedMemory();
+  size_t newLiveObjBytes = (*theAllocator).RequestedMemory();
+  size_t newTotalObjects = (*theAllocator).AllocatedObjs();
+
+  size_t totalObjBytesCollected = oldLiveObjBytes - newLiveObjBytes;
+  size_t totalBytesCollected = oldLiveBytes - newLiveBytes;
+  size_t totalBytesSurvived  = newLiveBytes;
+  size_t totalGarbages = oldTotalObjects - newTotalObjects;
+  stats::gcStats->CurrentGCRecord().objectsCollected = totalGarbages;
+  stats::gcStats->CurrentGCRecord().bytesCollected = totalBytesCollected;
+  stats::gcStats->CurrentGCRecord().bytesSurvived = totalBytesSurvived;
+
+  LOG2FILE(kLogtypeGc) << "End of parallel sweeping.\n" <<
+      "    Total objects: " << oldTotalObjects << '\n' <<
+      "    Live objects: " << newTotalObjects << '\n' <<
+      "    Total garbages: " << totalGarbages << '\n' <<
+      "    Object Survived(bytes) " << Pretty(newLiveObjBytes) <<
+      " Object Collected(bytes) " << Pretty(totalObjBytesCollected) << '\n' <<
+      "    Total Survived(bytes) " << Pretty(totalBytesSurvived) <<
+      " Total Collected(bytes) " << Pretty(totalBytesCollected) << '\n' <<
+      "    Dead strings in StringTable: " << deadStrings << '\n';
+}
+
+void MarkSweepCollector::Fini() {
+  TracingCollector::Fini();
+}
+
+void MarkSweepCollector::AddConcurrentMarkTask(RootSet &rs) {
+  if (rs.size() == 0) {
+    return;
+  }
+  MplThreadPool *threadPool = GetThreadPool();
+  size_t threadCount = threadPool->GetMaxActiveThreadNum() + 1;
+  const size_t kChunkSize = std::min(rs.size() / threadCount + 1, kMaxMarkTaskSize);
+  // Split the current work stack into work tasks.
+  auto end = rs.end();
+  for (auto it = rs.begin(); it < end;) {
+    const size_t delta = std::min(static_cast<size_t>(end - it), kChunkSize);
+    threadPool->AddTask(new (std::nothrow) ConcurrentMarkTask(*this, threadPool, it, delta));
+    it += delta;
+  }
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collector/collector_naiverc.cpp b/src/mrt/compiler-rt/src/collector/collector_naiverc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..66e3402a7816c239171b0f8d55b1f3a8de37a41a
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/collector_naiverc.cpp
@@ -0,0 +1,1168 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/collector_naiverc.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cinttypes>
+#include <deque>
+#include <atomic>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include "mm_config.h"
+#include "mm_utils.h"
+#include "chosen.h"
+#include "yieldpoint.h"
+#include "mutator_list.h"
+#include "collector/stats.h"
+#include "mrt_array.h"
+#if CONFIG_JSAN
+#include "jsan.h"
+#endif
+
+#ifdef __ANDROID__
+#include "collie.h"
+#endif
+
+namespace maplert {
+using namespace std;
+namespace {
+const int kMaxReleaseCount = 2000;
+constexpr uint32_t kMaxWeakRelaseDepth = 20;
+}
+// Perfrom DecRef on strong/weak/resurrect weak rc.
+// Before update RC, try match cycle pattern.
+//
+// Check Cycle before atomic update, avoid data racing.
+// If other thread dec and release obj while current thread still matching cycle.
+// It might have unexpected errors and obj already released.
+// Current implemenation might cause some leak in rare case, for example
+// Two thread perform dec at same time and see same oldRC and oldRC bigger
+// than cycle pattern threshold.
+template<int32_t strongRCDelta, int32_t weakRCDelta, int32_t resurrectWeakRCDelta>
+static inline uint32_t AtomicDecRef(address_t obj, uint32_t &releaseState) {
+  static_assert(strongRCDelta + weakRCDelta + resurrectWeakRCDelta == -1, "only one with -1");
+  static_assert(strongRCDelta * weakRCDelta * resurrectWeakRCDelta == 0, "only one with -1");
+
+  uint32_t oldHeader = RCHeader(obj);
+  bool released = false;
+  if (weakRCDelta == 0) {
+    // cycle pattern check condition: after dec, strong RC > 0 and all weak are zero
+    uint32_t oldRC = GetRCFromRCHeader(oldHeader);
+    if (oldRC > (-strongRCDelta)) {
+      if (GetResurrectWeakRCFromRCHeader(oldHeader) == (-resurrectWeakRCDelta)) {
+        uint32_t rcFlags = GCHeader(obj);
+        if (IsValidForCyclePatterMatch(rcFlags, oldRC + strongRCDelta)) {
+          released = CycleCollector::TryFreeCycleAtMutator(obj, -strongRCDelta, false);
+        }
+      }
+    }
+  }
+  if (!released) {
+    oldHeader = AtomicDecRCAndCheckRelease<strongRCDelta, weakRCDelta, resurrectWeakRCDelta>(obj, releaseState);
+  } else {
+    releaseState = kNotRelease;
+  }
+  return oldHeader;
+}
+
+template<int32_t strongRCDelta, int32_t weakRCDelta, int32_t resurrectWeakRCDelta>
+static inline void IncRefInline(address_t obj) {
+  static_assert(strongRCDelta + weakRCDelta + resurrectWeakRCDelta == 1, "only one with 1");
+  static_assert(strongRCDelta * weakRCDelta * resurrectWeakRCDelta == 0, "only one with 1");
+  if (UNLIKELY(!IS_HEAP_ADDR(obj))) {
+    return;
+  }
+
+  uint32_t oldHeader = AtomicUpdateRC<strongRCDelta, weakRCDelta, resurrectWeakRCDelta>(obj);
+  uint32_t oldRC = GetRCFromRCHeader(oldHeader);
+  // check if inc from 0.
+  if (oldRC == 0) {
+    HandleRCError(obj);
+  }
+
+#if RC_TRACE_OBJECT
+  TraceRefRC(obj, RefCount(obj), "IncRefInline at");
+#endif
+}
+
+#if RC_HOT_OBJECT_DATA_COLLECT
+const uint32_t kRCOperationCountThreshold = 1000000;
+static uint64_t hotReleseObjCount = 0;
+static uint64_t noRCReleseObjCount = 0;
+static uint64_t totalReleseObjCount = 0;
+static uint64_t hotReleseRCOpCount = 0;
+static uint64_t totalReleaseRCOpCount = 0;
+std::atomic<uint64_t> totalSkipedRCOpCount(0);
+std::atomic<uint64_t> totalRCOperationCount(0);
+
+void StatsFreeObject(address_t obj) {
+  uint32_t count = RCOperationCount(obj);
+  ++totalReleseObjCount;
+  totalReleaseRCOpCount += count;
+  if (count > kRCOperationCountThreshold) {
+    ++hotReleseObjCount;
+    hotReleseRCOpCount += count;
+  } else if (count == 0) {
+    ++noRCReleseObjCount;
+  }
+}
+
+static void DumpObjectBT(address_t obj, std::ostream &ofs) {
+  // print object info
+  MObject *mObject = reinterpret_cast<MObject*>(obj);
+  MClass *classInfo = mObject->GetClass();
+  ofs << "[obj]" << std::dec << " " << GCCount(obj) << " " << RCOperationCount(obj) << " " << RefCount(obj) <<
+      " " << GetObjectDWordSize(*mObject) << std::hex << " "  << obj <<
+      " " << classInfo->GetName() << std::endl;
+
+  // print traced class new obj callstack
+  void *pc[kTrackFrameNum] = { 0 };
+  int trackCount = kTrackFrameNum;
+  for (size_t i = 0; i < kTrackFrameNum; ++i) {
+    // get track PCs from object header
+    pc[i] = reinterpret_cast<void*>(*reinterpret_cast<unsigned long*>(obj + kOffsetTrackPC + kDWordBytes * i));
+    if (pc[i] == 0) {
+      --trackCount;
+    }
+  }
+  if (trackCount == 0) {
+    // all PC is zero, not track class
+    return;
+  }
+
+  for (size_t i = 0; i < kTrackFrameNum; ++i) {
+    if (pc[i] == 0) {
+      continue;
+    }
+    util::PrintPCSymbolToLog(pc[i], ofs, false);
+  }
+}
+
+void DumpHotObj() {
+  pid_t pid = getpid();
+#ifdef __ANDROID__
+  std::string dirName = util::GetLogDir();
+  std::string filename = dirName + "/hot_obj_dump_" + std::to_string(pid) + "_" +
+      timeutils::GetDigitDate() + ".txt";
+#else
+  std::string filename = "./hot_obj_dump_" + std::to_string(pid) + "_" +
+      timeutils::GetDigitDate() + ".txt";
+#endif
+  std::ofstream ofs (filename, std::ofstream::out);
+  uint64_t noRCObjCount = 0;
+  uint64_t hotObjCount = 0;
+  uint64_t totalObjCount = 0;
+
+  uint64_t hotRCOpCount = 0;
+  uint64_t totalRCOpCount = 0;
+  auto func = [&ofs, &noRCObjCount, &hotObjCount, &totalObjCount, &hotRCOpCount, &totalRCOpCount](address_t obj) {
+    // track object gc count
+    StatsGCCount(obj);
+    // print hot object backtrace
+    uint32_t count = RCOperationCount(obj);
+    if (count > kRCOperationCountThreshold) {
+      DumpObjectBT(obj, ofs);
+      ++hotObjCount;
+      hotRCOpCount += count;
+    } else if (count == 0) {
+      ++noRCObjCount;
+    }
+    ++totalObjCount;
+    totalRCOpCount += count;
+  }
+  bool tmpResult = (*theAllocator).ForEachObj(func);
+  // all retain objet total info
+  ofs << "[rc total retain]" << std::dec <<
+      " totalObjCount " << totalObjCount <<
+      " hotObjCount " << hotObjCount <<
+      " noRCObjCount " << noRCObjCount <<
+      " totalRCOpCount " << totalRCOpCount <<
+      " hotRCOpCount " << hotRCOpCount  << std::endl;
+
+  // all release objet total info
+  ofs << "[rc total release]" << std::dec <<
+      " totalReleseObjCount " << totalReleseObjCount <<
+      " hotReleseObjCount  " << hotReleseObjCount <<
+      " noRCReleseObjCount " << noRCReleseObjCount <<
+      " totalReleaseRCOpCount  "  << totalReleaseRCOpCount <<
+      " hotReleseRCOpCount " << hotReleseRCOpCount << std::endl;
+
+  // all objet total rc info
+  ofs << "[rc total ]" << std::dec <<
+      " totalRCOperationCount " << totalRCOperationCount <<
+      " totalSkipedRCOpCount " << totalSkipedRCOpCount << std::endl;
+
+  if (UNLIKELY(!tmpResult)) {
+      LOG(ERROR) << "ForEachObj() in NaiveRCCollector::DumpHotObj() return false." << maple::endl;
+  }
+}
+#endif // RC_HOT_OBJECT_DATA_COLLECT
+
+// Free Object.
+static inline void FreeObject(address_t obj) {
+  StatsFreeObject(obj);
+  // when concurrent mark is running, we are not directly free the object,
+  // instead we set flags on it, this is done by PreFreeObject(),
+  // which will return true if concurrent mark is running.
+  NaiveRCMutator &mutator = NRCMutator();
+  if (LIKELY(!mutator.PreFreeObject(obj))) {
+    // directly free the object if concurrent mark not running.
+    (*theAllocator).FreeObj(obj);
+  }
+}
+
+// Dec ref count for children before release the object.
+static inline void ReleaseObjectWithChildren(address_t obj, std::deque<address_t> &releaseQueue,
+                                             address_t firstobj __MRT_UNUSED, const MClass *firstObjCls __MRT_UNUSED,
+                                             uint32_t &releaseCount) {
+  auto refFunc = [&](reffield_t &field, uint64_t kind) {
+    address_t child = RefFieldToAddress(field);
+    if (UNLIKELY((!IS_HEAP_ADDR(child)) || child == obj || kind == kUnownedRefBits)) {
+      return;
+    }
+
+    // dec ref.
+    uint32_t oldHeader;
+    uint32_t releaseState = kNotRelease;
+    if (kind == kNormalRefBits) {
+      oldHeader = AtomicDecRef<-1, 0, 0>(child, releaseState);
+    } else {
+      oldHeader = AtomicDecRef<0, -1, 0>(child, releaseState);
+    }
+
+#if RC_TRACE_OBJECT
+    TraceRefRC(child, RefCount(child), "Dec at Release Object, referer from");
+#endif
+    if (releaseState == kReleaseObject) {
+      // check and handle finalizable object before release it.
+      if (RCReferenceProcessor::Instance().CheckAndAddFinalizable(child)) {
+        return;
+      }
+
+      // check HashChildRef bit.
+      if (HasChildRef(child)) {
+        // push object to release_queue if it has children to handle.
+        releaseQueue.push_back(child);
+      } else {
+        // directly release object if it has no children.
+        ++releaseCount;
+        FreeObject(child);
+      }
+    } else if (releaseState == kCollectedWeak) {
+      if (!RCReferenceProcessor::Instance().CheckAndAddFinalizable(child)) {
+        NRCMutator().WeakReleaseObj(child);
+        NRCMutator().DecWeak(child);
+      }
+    } else if (((kind == kNormalRefBits) && IsInvalidDec<-1, 0, 0>(oldHeader)) ||
+               ((kind == kWeakRefBits) && IsInvalidDec<0, -1, 0>(oldHeader))) {
+#if __MRT_DEBUG
+#if CONFIG_JSAN
+      JsanUseAfterFreeDeath(child);
+#endif
+      LOG(ERROR) << "Dec from 0, Invalid " << std::hex << child <<
+          " " << RCHeader(child) << " " << oldHeader << " " << GCHeader(child) <<
+          " parent: " << obj << " " << MObject::Cast<MObject>(obj)->GetClass()->GetName() <<
+          " firstobj: " << firstobj << " " << firstObjCls->GetName() <<
+          " kind " << kind <<
+          std::dec << maple::endl;
+      HandleRCError(child);
+#endif
+    }
+  };
+  DoForEachRefField(obj, refFunc);
+  // release object.
+  ++releaseCount;
+  FreeObject(obj);
+}
+
+// Release Object that ref count became zero.
+static inline void ReleaseObject(address_t obj, std::deque<address_t> &releaseQueue) {
+#if LOG_ALLOC_TIMESTAT
+  TheAllocMutator &mut = TLAllocMutator();
+  mut.StartTimer();
+#endif
+  // check and handle finalizable object before release it.
+  if (RCReferenceProcessor::Instance().CheckAndAddFinalizable(obj)) {
+    return;
+  }
+  // simply release the object if it has no children.
+  if (!HasChildRef(obj)) {
+    // release object.
+    FreeObject(obj);
+    return;
+  }
+  address_t firstobj = obj;
+  MClass *firstObjCls = MObject::Cast<MObject>(firstobj)->GetClass();
+  address_t curObj = obj;
+  uint32_t releaseCount = 0;
+
+#if LOG_ALLOC_TIMESTAT
+  // Do not timestat individual FreeObjs when doing
+  // timestat on release obj with children to keep the
+  // overhead from skewing the result.
+  mut.SuspendFreeObjTimeStat();
+#endif
+
+  // loop until all children handled.
+  for (;;) {
+    // dec ref children and then release the object.
+    ReleaseObjectWithChildren(curObj, releaseQueue, firstobj, firstObjCls, releaseCount);
+
+    // exit loop when release_queue is empty.
+    if (releaseQueue.empty()) {
+      break;
+    }
+
+#if CONFIG_JSAN
+    if ((releaseCount > kMaxReleaseCount) && (!ReferenceProcessor::Instance().IsCurrentRPThread())) {
+      LOG(INFO) << "Skip Aysnc release for JSAN" << maple::endl;
+    }
+#else
+    // async release lefted objects
+    if ((releaseCount > kMaxReleaseCount) && (!ReferenceProcessor::Instance().IsCurrentRPThread())) {
+      for (auto it = releaseQueue.begin(); it != releaseQueue.end(); ++it) {
+        RCReferenceProcessor::Instance().AddAsyncReleaseObj(*it, false);
+      }
+      releaseQueue.clear();
+      break;
+    }
+#endif
+
+    // take an object from release queue.
+    // the object must be: valid heap object && rc == 0 && kHasChildRef == 1.
+    curObj = releaseQueue.front();
+    releaseQueue.pop_front();
+  }
+  std::deque<address_t>().swap(releaseQueue);
+#if LOG_ALLOC_TIMESTAT
+  mut.StopTimer(kTimeReleaseObj);
+  mut.ResumeFreeObjTimeStat();
+#endif
+}
+
+template<int32_t strongRCDelta, int32_t weakRCDelta, int32_t resurrectWeakRCDelta>
+static inline void DecRefInline(address_t obj, std::deque<address_t> &releaseQueue) {
+  static_assert(strongRCDelta + weakRCDelta + resurrectWeakRCDelta == -1, "only one with -1");
+  static_assert(strongRCDelta * weakRCDelta * resurrectWeakRCDelta == 0, "only one with -1");
+  if (UNLIKELY(!IS_HEAP_OBJ(obj))) {
+    return;
+  }
+  uint32_t releaseState = kNotRelease;
+  uint32_t oldHeader __MRT_UNUSED = AtomicDecRef<strongRCDelta, weakRCDelta, resurrectWeakRCDelta>(obj, releaseState);
+
+  if (releaseState == kReleaseObject) {
+    ReleaseObject(obj, releaseQueue);
+  } else if (releaseState == kCollectedWeak) {
+    if (!RCReferenceProcessor::Instance().CheckAndAddFinalizable(obj)) {
+      NRCMutator().WeakReleaseObj(obj);
+      NRCMutator().DecWeak(obj);
+    }
+  }
+#if __MRT_DEBUG
+  else if (IsInvalidDec<strongRCDelta, weakRCDelta, resurrectWeakRCDelta>(oldHeader)) {
+    LOG(ERROR) << "DecRefInline fail " << std::hex << obj <<
+        " " << RCHeader(obj) << " " << oldHeader << " " << GCHeader(obj) <<
+        (strongRCDelta != 0 ? " dec strong" : (weakRCDelta != 0 ? " dec weak" : " dec resurect weak")) <<
+        std::dec << maple::endl;
+    HandleRCError(obj);
+  }
+#endif
+#if RC_TRACE_OBJECT
+  TraceRefRC(obj, RefCount(obj), "After DecRefInline at");
+#endif
+}
+
+// Mutator implementation
+void NaiveRCMutator::IncWeak(address_t obj) {
+  IncRefInline<0, 1, 0>(obj);
+}
+
+void NaiveRCMutator::IncResurrectWeak(address_t obj) {
+  IncRefInline<0, 0, 1>(obj);
+}
+
+void NaiveRCMutator::DecWeak(address_t obj) {
+  DecRefInline<0, -1, 0>(obj, *releaseQueue);
+}
+
+void NaiveRCMutator::IncRef(address_t obj) {
+  IncRefInline<1, 0, 0>(obj);
+}
+
+void NaiveRCMutator::DecRef(address_t obj) {
+  DecRefInline<-1, 0, 0>(obj, *releaseQueue);
+}
+
+bool NaiveRCMutator::EnterWeakRelease() {
+  __MRT_ASSERT(weakReleaseDepth <= kMaxWeakRelaseDepth, "Invalid status");
+  if (weakReleaseDepth == kMaxWeakRelaseDepth) {
+    LOG2FILE(kLogtypeGc) << "EnterWeakRelease return false" << std::endl;
+    return false;
+  }
+  ++weakReleaseDepth;
+  return true;
+}
+
+void NaiveRCMutator::ExitWeakRelease() {
+  --weakReleaseDepth;
+  __MRT_ASSERT(weakReleaseDepth <= kMaxWeakRelaseDepth, "Invalid status");
+}
+
+// Weak release: release object external reference (dec and clear slot)
+// Invoked when weak collected bit is set and object is not finalizable
+void NaiveRCMutator::WeakReleaseObj(address_t obj) {
+#if LOG_ALLOC_TIMESTAT
+  TheAllocMutator &mut = TLAllocMutator();
+  mut.StartTimer();
+#endif
+  __MRT_ASSERT(IsWeakCollected(obj), "obj is not weak collected");
+  __MRT_ASSERT(!IsEnqueuedObjFinalizable(obj) && !IsObjFinalizable(obj), "obj is finalizable");
+  if (UNLIKELY(collector.IsZygote())) {
+    if (collector.HasWeakRelease() == false) {
+      collector.SetHasWeakRelease(true);
+    }
+  }
+
+  if (!HasChildRef(obj)) {
+    return;
+  }
+
+  NaiveRCMutator &mutator = NRCMutator();
+  if (UNLIKELY(!mutator.EnterWeakRelease())) {
+    return;
+  }
+
+#if LOG_ALLOC_TIMESTAT
+  // Do not timestat individual FreeObjs when doing
+  // timestat on release obj with children to keep the
+  // overhead from skewing the result.
+  mut.SuspendFreeObjTimeStat();
+#endif
+  auto refFunc = [&, this](reffield_t& field, uint64_t kind) {
+    address_t child = RefFieldToAddress(field);
+    SatbWriteBarrier(child);
+    field = 0;
+    if (child == obj || kind == kUnownedRefBits) {
+      return;
+    }
+    if (kind == kNormalRefBits) {
+      DecRefInline<-1, 0, 0>(child, *releaseQueue);
+    } else {
+      DecRefInline<0, -1, 0>(child, *releaseQueue);
+    }
+  };
+  DoForEachRefField(obj, refFunc);
+  mutator.ExitWeakRelease();
+
+#if LOG_ALLOC_TIMESTAT
+  mut.StopTimer(kTimeReleaseObj);
+  mut.ResumeFreeObjTimeStat();
+#endif
+}
+
+void NaiveRCMutator::ReleaseObj(address_t obj) {
+  ReleaseObject(obj, *releaseQueue);
+}
+
+#if !STRICT_NAIVE_RC
+static inline bool SpinIncRef(address_t obj, uint32_t &yieldCount) {
+  if (TryAtomicIncStrongRC(obj) == false) {
+    int tmpResult = sched_yield();
+    if (UNLIKELY(tmpResult != 0)) {
+      LOG(INFO) << "sched_yield() fail " << tmpResult << maple::endl;
+    }
+    ++yieldCount;
+#if CONFIG_JSAN
+    if (yieldCount ==  1) {
+      LOG(ERROR) << "[JSAN] spin found condition" << maple::endl;
+      JsanUseAfterFreeDeath(obj);
+    }
+#endif
+    if ((yieldCount & 0x7f) == 0) {
+#if CONFIG_JSAN
+      JsanUseAfterFreeDeath(obj);
+#endif
+      LOG(ERROR) << "LoadIncRef hang exceed limit " << std::hex << obj << " gcheader " << GCHeader(obj) << maple::endl;
+      HandleRCError(obj);
+    }
+    return false;
+  }
+#if RC_TRACE_OBJECT
+  TraceRefRC(obj, RefCount(obj), "Inc at LoadIncRef");
+#endif
+  return true;
+}
+#endif
+
+address_t NaiveRCMutator::LoadIncRefCommon(address_t *fieldAddr) {
+#if RC_PROFILE
+  ++RCCollector::numLoadIncRef;
+#endif
+#if !STRICT_NAIVE_RC
+  uint32_t yieldCount = 0;
+#endif
+  do {
+    address_t obj = LoadRefField(fieldAddr);
+    if (obj == 0) {
+      return obj;
+    } else if ((obj & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK) {
+      return LoadRefVolatile(fieldAddr, false);
+    } else if (!IS_HEAP_ADDR(obj)) {
+      return obj;
+    }
+#if STRICT_NAIVE_RC
+    IncRefInline<1, 0, 0>(obj);
+    return obj;
+#else
+    if (SpinIncRef(obj, yieldCount)) {
+      return obj;
+    }
+#endif
+  } while (true);
+}
+
+address_t NaiveRCMutator::LoadIncRef(address_t *fieldAddr) {
+#if RC_PROFILE
+  ++RCCollector::numLoadIncRef;
+#endif
+
+#if STRICT_NAIVE_RC
+  address_t obj = LoadRefField(fieldAddr);
+  IncRefInline<1, 0, 0>(obj);
+  return obj;
+#else
+  // if yield exceed limit, force enter yield point to sync memory
+  // If still fail, then its a real early release
+  uint32_t yieldCount = 0;
+  do {
+    address_t obj = LoadRefField(fieldAddr);
+    if (UNLIKELY((obj & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK)) {
+      return LoadRefVolatile(fieldAddr, false);
+    } else if (!IS_HEAP_ADDR(obj)) {
+      return obj;
+    }
+    if (SpinIncRef(obj, yieldCount)) {
+      return obj;
+    }
+  } while (true);
+#endif
+}
+
+// load thread need lock this slot, by compare and swap it to  muator_ptr|1
+// store thread, compare and swap old value to new_value
+// loadReferent is true when load volatile is load referent in:
+// 1. Referent.get()
+// 2. WeakGlobal.get()
+// Similar with LoadRefVolatile but if kWeakCollectedBit is set for referent, return null
+const uint32_t kVolatileFieldTidShift = 3;
+address_t NaiveRCMutator::LoadRefVolatile(address_t *objAddr, bool loadReferent) {
+  size_t count = 0xf;
+  while (true) {
+    atomic<reffield_t> &volatileFieldAddr = AddrToLValAtomic<reffield_t>(reinterpret_cast<address_t>(objAddr));
+    address_t obj = RefFieldToAddress(volatileFieldAddr.load(memory_order_acquire));
+    if (obj == 0 || obj == GRT_DEADVALUE) {
+      return obj;
+    } else if ((obj & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK) {
+      // lock by other thread load and inc
+      --count;
+      if (count == 0) {
+        count = 0xf;
+        LOG(ERROR) << "LoadRefVolatile " << (obj >> kVolatileFieldTidShift) << " " << objAddr << maple::endl;
+      }
+      int tmpResult = sched_yield();
+      if (UNLIKELY(tmpResult != 0)) {
+        LOG(ERROR) << "sched_yield() in NaiveRCMutator::LoadRefVolatile() return " << tmpResult << "rather than 0." <<
+            maple::endl;
+      }
+      continue;
+    } else if (!IS_HEAP_OBJ(obj)) {
+      return obj;
+    } else {
+      // obj is in heap, try swap it
+      // must be unique, better with thread address
+      reffield_t holder = ((static_cast<reffield_t>(GetTid())) << kVolatileFieldTidShift) | LOAD_INC_RC_MASK;
+      reffield_t objRef = AddressToRefField(obj);
+      if (!volatileFieldAddr.compare_exchange_weak(objRef, holder, memory_order_release, memory_order_relaxed)) {
+        continue;
+      }
+      if (loadReferent) {
+        obj = AtomicIncLoadWeak<false>(obj);
+        volatileFieldAddr.store(objRef, memory_order_release);
+        return obj;
+      }
+      // locked
+      IncRefInline<1, 0, 0>(obj);
+      // free and return
+      volatileFieldAddr.store(objRef, memory_order_release);
+      return obj;
+    }
+  }
+}
+
+void NaiveRCMutator::WriteRefFieldVolatileNoInc(address_t obj, address_t *fieldAddr, address_t value,
+                                                bool writeReferent, bool isResurrectWeak) {
+  // we skip pre-write barrier for referent write, because we do not follow referent
+  // during marking, and sometime we need call this function on a non-heap address,
+  // for example: EntryElement::clearobjAndDecRef() in indirect_reference_table.h.
+  if (LIKELY(!writeReferent)) {
+    // pre-write barrier for concurrent marking.
+    SatbWriteBarrier(obj, *reinterpret_cast<reffield_t*>(fieldAddr));
+  }
+  size_t count = 0xf;
+  while (true) {
+    atomic<reffield_t> &volatileFieldAddr = AddrToLValAtomic<reffield_t>(reinterpret_cast<address_t>(fieldAddr));
+    reffield_t oldValueRef = volatileFieldAddr.load(memory_order_acquire);
+    if ((oldValueRef & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK) {
+      // lock by other thread load and inc
+      --count;
+      if (count == 0) {
+        count = 0xf;
+        LOG(ERROR) << "LoadRefVolatile " << (oldValueRef >> kVolatileFieldTidShift) << " " << fieldAddr <<
+            maple::endl;
+      }
+      int tmpResult = sched_yield();
+      if (UNLIKELY(tmpResult != 0)) {
+        LOG(ERROR) << "sched_yield() in NaiveRCMutator::WriteRefFieldVolatileNoInc() return " << tmpResult <<
+            "rather than 0." << maple::endl;
+      }
+      continue;
+    } else {
+      // valid object here
+      reffield_t valueRef = AddressToRefField(value);
+      if (!volatileFieldAddr.compare_exchange_weak(oldValueRef, valueRef,
+          memory_order_release, memory_order_relaxed)) {
+        continue;
+      }
+      // successful
+      address_t oldValue = RefFieldToAddress(oldValueRef);
+      if (oldValue != obj) {
+        if (writeReferent) {
+          if (isResurrectWeak) {
+            DecRefInline<0, 0, -1>(oldValue, *releaseQueue);
+          } else {
+            DecRefInline<0, -1, 0>(oldValue, *releaseQueue);
+          }
+        } else {
+          DecRefInline<-1, 0, 0>(oldValue, *releaseQueue);
+        }
+      }
+      return;
+    }
+  }
+}
+
+void NaiveRCMutator::WriteRefFieldVolatileNoRC(address_t obj, address_t *fieldAddr, address_t value,
+                                               bool writeReferent) {
+  // we skip pre-write barrier for referent write, because we do not follow referent
+  // during marking, and sometime we need call this function on a non-heap address,
+  // for example: EntryElement::clearobjAndDecRef() in indirect_reference_table.h.
+  if (LIKELY(!writeReferent)) {
+    // pre-write barrier for concurrent marking.
+    SatbWriteBarrier(obj, *reinterpret_cast<reffield_t*>(fieldAddr));
+  }
+  size_t count = 0xf;
+  while (true) {
+    atomic<reffield_t> &volatileFieldAddr = AddrToLValAtomic<reffield_t>(reinterpret_cast<address_t>(fieldAddr));
+    reffield_t oldValueRef = volatileFieldAddr.load(memory_order_acquire);
+    if ((oldValueRef & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK) {
+      // lock by other thread load and inc
+      --count;
+      if (count == 0) {
+        count = 0xf;
+        LOG(ERROR) << "LoadRefVolatile " << (oldValueRef >> kVolatileFieldTidShift) << " " << fieldAddr << maple::endl;
+      }
+      int tmpResult = sched_yield();
+      if (UNLIKELY(tmpResult != 0)) {
+        LOG(ERROR) << "sched_yield() in NaiveRCMutator::WriteRefFieldVolatileNoInc() return " << tmpResult <<
+            "rather than 0." << maple::endl;
+      }
+      continue;
+    } else {
+      // valid object here
+      reffield_t valueRef = AddressToRefField(value);
+      if (!volatileFieldAddr.compare_exchange_weak(oldValueRef, valueRef, memory_order_release, memory_order_relaxed)) {
+        continue;
+      }
+      // successful
+      return;
+    }
+  }
+}
+
+void NaiveRCMutator::WriteRefFieldVolatileNoDec(address_t obj, address_t *fieldAddr, address_t value,
+                                                bool writeReferent, bool isResurrectWeak) {
+  if (writeReferent) {
+    if (isResurrectWeak) {
+      IncRefInline<0, 0, 1>(value);
+    } else {
+      IncRefInline<0, 1, 0>(value);
+    }
+  } else {
+    if (value != obj) {
+      IncRefInline<1, 0, 0>(value);
+    }
+  }
+  WriteRefFieldVolatileNoRC(obj, fieldAddr, value, writeReferent);
+}
+
+void NaiveRCMutator::WriteRefFieldVolatile(address_t obj, address_t *fieldAddr, address_t value,
+                                           bool writeReferent, bool isResurrectWeak) {
+  if (value != obj) {
+    if (writeReferent) {
+      if (isResurrectWeak) {
+        IncRefInline<0, 0, 1>(value);
+      } else {
+        IncRefInline<0, 1, 0>(value);
+      }
+    } else {
+      IncRefInline<1, 0, 0>(value);
+    }
+  }
+  WriteRefFieldVolatileNoInc(obj, fieldAddr, value, writeReferent, isResurrectWeak);
+}
+
+// write barrier for local reference variable update.
+void NaiveRCMutator::WriteRefVar(address_t *var, address_t value) {
+  // inc ref for the new value.
+  IncRefInline<1, 0, 0>(value);
+  WriteRefVarNoInc(var, value);
+}
+
+void NaiveRCMutator::WriteRefVarNoInc(address_t *var, address_t value) {
+#if RC_PROFILE
+  ++RCCollector::numWriteRefVar;
+#endif
+  // dec ref count for the old one.
+  DecRefInline<-1, 0, 0>(*var, *releaseQueue);
+
+  // no need atomic, since var is on the stack,
+  // only current thread can access it.
+  *var = value;
+}
+
+// writer barrier for object reference field update.
+void NaiveRCMutator::WriteRefField(address_t obj, address_t *field, address_t value) {
+  if (obj != value) {
+    IncRefInline<1, 0, 0>(value);
+  }
+  WriteRefFieldNoInc(obj, field, value);
+}
+
+void NaiveRCMutator::WriteRefFieldNoDec(address_t obj, address_t *field, address_t value) {
+  if (obj != value) {
+    IncRefInline<1, 0, 0>(value);
+  }
+
+  WriteRefFieldNoRC(obj, field, value);
+}
+
+void NaiveRCMutator::WriteRefFieldNoRC(address_t obj, address_t *field, address_t value) {
+#if RC_PROFILE
+  ++RCCollector::numWriteRefField;
+#endif
+
+  SatbWriteBarrier(obj, *reinterpret_cast<reffield_t*>(field));
+
+#ifdef USE_32BIT_REF
+  *reinterpret_cast<reffield_t*>(field) = static_cast<reffield_t>(value);
+#else
+  *field = value;
+#endif // USE_32BIT_REF
+}
+
+void NaiveRCMutator::WriteRefFieldNoInc(address_t obj, address_t *field, address_t value) {
+#if RC_PROFILE
+  ++RCCollector::numWriteRefField;
+#endif
+
+  SatbWriteBarrier(obj, *reinterpret_cast<reffield_t*>(field));
+
+  // use atomic exchange to prevent race condition.
+  // In case of field is loaded as volatile and compare exchange might get unexpected object
+  atomic<reffield_t> &fieldAddr = AddrToLValAtomic<reffield_t>(reinterpret_cast<address_t>(field));
+  while (true) {
+    reffield_t oldValue = fieldAddr.load(memory_order_acquire);
+    if (UNLIKELY((oldValue & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK)) {
+      WriteRefFieldVolatileNoInc(obj, field, value);
+      return;
+    } else {
+      reffield_t valueRef = AddressToRefField(value);
+      if (!fieldAddr.compare_exchange_weak(oldValue, valueRef, memory_order_release, memory_order_relaxed)) {
+        continue;
+      }
+      // dec ref count for old one.
+      if (oldValue != obj) {
+        DecRefInline<-1, 0, 0>(oldValue, *releaseQueue);
+      }
+      return;
+    }
+  }
+}
+
+void NaiveRCMutator::WriteWeakField(address_t obj, address_t *field, address_t value,
+                                    bool isVolatile __attribute__((unused))) {
+  return WriteRefFieldVolatile(obj, field, value, true, false);
+}
+
+address_t NaiveRCMutator::LoadWeakField(address_t *fieldAddr, bool isVolatile __attribute__((unused))) {
+  return LoadRefVolatile(fieldAddr, true);
+}
+
+// Load a ref field object and increase its weak rc count.
+// There could be racing here if other thread is writting field
+// 1. If field is volatile, load volatile field: dec strong and inc weak rc
+// 2. If object a)has no weak reference 2) weak collected bit set return 0
+// 3. Otherwise, try inc weak rc and return obj
+address_t NaiveRCMutator::LoadWeakRefCommon(address_t *field) {
+  address_t obj = LoadRefField(field);
+  if (obj == 0) {
+    return obj;
+  } else if ((obj & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK) {
+    address_t result = LoadRefVolatile(field, true);
+    if (IS_HEAP_ADDR(result)) {
+      IncRefInline<0, 1, 0>(result);
+      DecRefInline<-1, 0, 0>(result, *releaseQueue);
+    }
+    return result;
+  } else if (!IS_HEAP_ADDR(obj)) {
+    return obj;
+  }
+  return AtomicIncLoadWeak<true>(obj);
+}
+
+// release local reference variable.
+void NaiveRCMutator::ReleaseRefVar(address_t obj) {
+#if RC_PROFILE
+  ++RCCollector::numReleaseRefVar;
+#endif
+
+  // dec ref for released object.
+  DecRefInline<-1, 0, 0>(obj, *releaseQueue);
+}
+
+void NaiveRCCollector::HandleNeighboursForSweep(address_t obj, std::vector<address_t> &deads) {
+  // if the object was set as released during concurrent marking,
+  // we should skip dec neighbours because mutator already did this in MRT_ReleaseObj().
+  if (HasReleasedBit(obj)) {
+    return;
+  }
+  auto refFunc = [obj, &deads](reffield_t field, uint64_t kind) {
+    address_t neighbour = RefFieldToAddress(field);
+    if ((kind != kUnownedRefBits) &&
+        IS_HEAP_OBJ(neighbour) &&
+        !Collector::Instance().IsGarbage(neighbour) &&
+        (neighbour != obj)) {
+      uint32_t releaseState = kNotRelease;
+      if (kind == kNormalRefBits) {
+        uint32_t oldHeader __MRT_UNUSED = AtomicDecRCAndCheckRelease<-1, 0, 0, false>(neighbour, releaseState);
+        __MRT_ASSERT(IsRCOverflow(oldHeader) || (GetRCFromRCHeader(oldHeader) != 0), "unexpected dec from 0");
+      } else {
+        uint32_t oldHeader __MRT_UNUSED = AtomicDecRCAndCheckRelease<0, -1, 0, false>(neighbour, releaseState);
+        __MRT_ASSERT(IsRCOverflow(oldHeader) || (GetWeakRCFromRCHeader(oldHeader) != 0), "unexpected dec weak from 0");
+      }
+      if (releaseState == kReleaseObject) {
+        // if rc became zero, we found a dead neighbour.
+#if LOGGING_DEAD_NEIGHBOURS
+        MClass *nebCls = reinterpret_cast<MObject*>(neighbour)->GetClass();
+        MClass *objCls = reinterpret_cast<MObject*>(obj)->GetClass();
+        LOG2FILE(LOGTYPE_GC) << "Dead neighbour: " <<
+            std::hex <<
+            neighbour <<
+            " rc: " << RefCount(neighbour) <<
+            " hd: " << GCHeader(neighbour) <<
+            std::dec <<
+            " cls: " <<
+            nebCls == nullptr ? "<null>" : nebCls->GetName() <<
+            " <-- " << reinterpret_cast<void*>(obj) << " " <<
+            objCls->GetName() <<
+            '\n';
+#else
+        MRT_DummyUse(obj); // avoid unused warning.
+#endif
+        // save dead neighbour for later release.
+        deads.push_back(neighbour);
+      } else if (releaseState == kCollectedWeak) {
+        __MRT_ASSERT(false, "can not collect weak in concurrent sweep");
+      }
+    }
+  };
+  ForEachRefField(obj, refFunc);
+}
+
+// Set to 1 to try to reduce inc/dec operations during arraycopy at the cost of
+// load+inc atomicity.
+#define FAST_UNSAFE_ARRAYCOPY 1
+
+static void ModifyElemRef(address_t javaSrc, int32_t srcPos, int32_t dstPos, int32_t length) {
+  int32_t minPos = min(srcPos, dstPos);
+  int32_t maxPos = max(srcPos, dstPos);
+  int32_t offset = maxPos - minPos;
+
+  int32_t startPos = minPos;
+  NaiveRCMutator &mutator = NRCMutator();
+  MArray *mArray = reinterpret_cast<MArray*>(javaSrc);
+  if (srcPos < dstPos) {
+    for (int32_t i = 0; i < offset; ++i) {
+      address_t frontElem = reinterpret_cast<address_t>(mArray->GetObjectElementNoRc(startPos + i));
+      address_t backElem = reinterpret_cast<address_t>(mArray->GetObjectElementNoRc(startPos + length + i));
+      if ((frontElem != javaSrc) && (backElem != javaSrc)) {
+        mutator.IncRef(frontElem);
+        mutator.DecRef(backElem);
+      } else if ((frontElem == javaSrc) && (backElem != javaSrc)) {
+        mutator.DecRef(backElem);
+      } else if ((frontElem != javaSrc) && (backElem == javaSrc)) {
+        mutator.IncRef(frontElem);
+      }
+    }
+  } else {
+    for (int32_t i = 0; i < offset; ++i) {
+      address_t backElem = reinterpret_cast<address_t>(mArray->GetObjectElementNoRc(startPos + i));
+      address_t frontElem = reinterpret_cast<address_t>(mArray->GetObjectElementNoRc(startPos + length + i));
+      if ((frontElem != javaSrc) && (backElem != javaSrc)) {
+        mutator.IncRef(frontElem);
+        mutator.DecRef(backElem);
+      } else if ((frontElem == javaSrc) && (backElem != javaSrc)) {
+        mutator.DecRef(backElem);
+      } else if ((frontElem != javaSrc) && (backElem == javaSrc)) {
+        mutator.IncRef(frontElem);
+      }
+    }
+  }
+}
+
+void NaiveRCCollector::ObjectArrayCopy(address_t javaSrc, address_t javaDst, int32_t srcPos,
+                                       int32_t dstPos, int32_t length, bool check) {
+  size_t elemSize = sizeof(reffield_t);
+  MArray *srcMarray = reinterpret_cast<MArray*>(javaSrc);
+  MArray *dstMarray = reinterpret_cast<MArray*>(javaDst);
+  char *srcCarray = reinterpret_cast<char*>(srcMarray->ConvertToCArray());
+  char *dstCarray = reinterpret_cast<char*>(dstMarray->ConvertToCArray());
+  reffield_t *src = reinterpret_cast<reffield_t*>(srcCarray + elemSize * srcPos);
+  reffield_t *dst = reinterpret_cast<reffield_t*>(dstCarray + elemSize * dstPos);
+
+  TLMutator().SatbWriteBarrier<false>(javaDst);
+
+  if ((javaSrc == javaDst) && (abs(srcPos - dstPos) < length)) {
+    ModifyElemRef(javaSrc, srcPos, dstPos, length);
+    // most of the copy here are for small length. inline it here
+    // assumption: length > 0; aligned to 8bytes
+    if (length < kLargArraySize) {
+      if (srcPos > dstPos) { // copy to front
+        for (int i = 0; i < length; ++i) {
+          dst[i] = src[i];
+        }
+      } else { // copy to back
+        for (int i = length - 1; i >= 0; --i) {
+          dst[i] = src[i];
+        }
+      }
+    } else {
+      if (memmove_s(dst, elemSize * length, src, elemSize * length) != EOK) {
+        LOG(FATAL) << "Function memmove_s() failed." << maple::endl;
+      }
+    }
+  } else {
+    NaiveRCMutator &mutator = NRCMutator();
+#if FAST_UNSAFE_ARRAYCOPY
+    MClass *dstClass = dstMarray->GetClass();
+    MClass *dstComponentType = dstClass->GetComponentClass();
+    MClass *lastAssignableComponentType = dstComponentType;
+
+    for (int32_t i = 0; i < length; ++i) {
+      reffield_t srcelem;
+      reffield_t dstelem;
+      srcelem = src[i];
+      dstelem = dst[i];
+      address_t se = RefFieldToAddress(srcelem);
+      address_t de = RefFieldToAddress(dstelem);
+      MObject *srcComponent = reinterpret_cast<MObject*>(se);
+      if (!check || AssignableCheckingObjectCopy(*dstComponentType, lastAssignableComponentType, srcComponent)) {
+        dst[i] = srcelem;
+      } else {
+        ThrowArrayStoreException(*srcComponent, i, *dstComponentType);
+        return;
+      }
+      if ((se != javaDst) && (de != javaDst)) {
+        mutator.IncRef(RefFieldToAddress(srcelem));
+        mutator.DecRef(RefFieldToAddress(dstelem));
+      } else if ((se == javaDst) && (de != javaDst)) {
+        mutator.DecRef(de);
+      } else if ((se != javaDst) && (de == javaDst)) {
+        mutator.IncRef(se);
+      }
+    }
+#else
+    for (int32_t i = 0; i < length; ++i) {
+      MObject *srcComponent = srcMarray->GetObjectElement(srcPosition + i);
+      dstMarray->SetObjectArrayElement(dstPos + i, srcComponent);
+      mutator.DecRef(reinterpret_cast<address_t>(srcComponent));
+    }
+#endif
+  }
+}
+
+void NaiveRCCollector::PostObjectClone(address_t src, address_t dst) {
+    // no need to traverse field of offheap object
+    if (!IS_HEAP_ADDR(src)) {
+      return;
+    }
+    // to avoid unsafe clone, object is clone and being modified be other thread
+    // thread1 clone
+    // 1. memcpy jobj, newobj
+    // 2. incref jObj.f old value
+    //
+    // thread 2 modify
+    // 1. jObj.f = new field decref and release
+    //
+    // if release happens before thread1 step2, then incref from 0
+    // issues: what happen if clone Reference? need update weakrc
+    auto refFunc = [src, dst](reffield_t &field, uint64_t kind) {
+      if (kind == kUnownedRefBits) {
+        return;
+      }
+      address_t offset = (reinterpret_cast<address_t>(&field)) - src;
+      // field can be volatile, can not simply use MRT_LoadRefField
+      address_t ref;
+      if (kind == kNormalRefBits) {
+        ref = MRT_LoadRefFieldCommon(src, reinterpret_cast<address_t*>(&field));
+      } else {
+        // kind is kWeakRefBits
+        ref = MRT_LoadWeakFieldCommon(src, reinterpret_cast<address_t*>(&field));
+      }
+      StoreRefField(dst, offset, ref);
+    };
+    ForEachRefField(src, refFunc);
+}
+
+bool NaiveRCCollector::UnsafeCompareAndSwapObject(address_t obj, ssize_t offset,
+                                                  address_t expectedValue, address_t newValue) {
+  JSAN_CHECK_OBJ(obj);
+  TLMutator().SatbWriteBarrier(obj, *reinterpret_cast<reffield_t*>(obj + offset));
+
+  NaiveRCMutator &mutator = NRCMutator();
+  mutator.IncRef(newValue);
+  bool result = false;
+  for (;;) {
+    reffield_t expected = AddressToRefField(expectedValue);
+    result = __atomic_compare_exchange_n(reinterpret_cast<reffield_t*>(obj + offset),
+                                         &expected,
+                                         AddressToRefField(newValue),
+                                         false,
+                                         __ATOMIC_SEQ_CST,
+                                         __ATOMIC_SEQ_CST);
+    if (LIKELY(result || (expected & LOAD_INC_RC_MASK) == 0)) {
+      break;
+    }
+    // try again if CAS on a locked volatile object.
+    (void)(::sched_yield());
+  }
+  if (result) {
+    // avoid self cycle inc dec
+    if (obj == newValue) {
+      mutator.DecRef(newValue);
+    }
+    if (obj != expectedValue) {
+      mutator.DecRef(expectedValue);
+    }
+  } else {
+    mutator.DecRef(newValue);
+  }
+  return result;
+}
+
+address_t NaiveRCCollector::UnsafeGetObjectVolatile(address_t obj, ssize_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return NRCMutator().LoadRefVolatile(reinterpret_cast<address_t*>(obj + offset));
+}
+
+address_t NaiveRCCollector::UnsafeGetObject(address_t obj, ssize_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return NRCMutator().LoadIncRef(reinterpret_cast<address_t*>(obj + offset));
+}
+
+void NaiveRCCollector::UnsafePutObject(address_t obj, ssize_t offset, address_t newValue) {
+  JSAN_CHECK_OBJ(obj);
+  NRCMutator().WriteRefField(obj, reinterpret_cast<address_t*>(obj + offset), newValue);
+}
+
+void NaiveRCCollector::UnsafePutObjectVolatile(address_t obj, ssize_t offset, address_t newValue) {
+  JSAN_CHECK_OBJ(obj);
+  NRCMutator().WriteRefFieldVolatile(obj, reinterpret_cast<address_t*>(obj + offset), newValue);
+}
+
+void NaiveRCCollector::UnsafePutObjectOrdered(address_t obj, ssize_t offset, address_t newValue) {
+  JSAN_CHECK_OBJ(obj);
+  UnsafePutObjectVolatile(obj, offset, newValue);
+}
+
+// (global) Collector implementation
+void NaiveRCCollector::Init() {
+  RCCollector::Init();
+
+  LOG2FILE(kLogtypeGc) <<  "NaiveRCCollector::Init()" << std::endl;
+  if (VLOG_IS_ON(rcverify)) {
+    ms.SetRCVerify(true);
+  }
+  ms.Init();
+}
+
+void NaiveRCCollector::InitAfterFork() {
+  // post fork child
+  RCCollector::InitAfterFork();
+  ms.InitAfterFork();
+}
+
+void NaiveRCCollector::StartThread(bool isZygote) {
+  ms.StartThread(isZygote);
+}
+
+void NaiveRCCollector::StopThread() {
+  ms.StopThread();
+}
+
+void NaiveRCCollector::JoinThread() {
+  ms.JoinThread();
+}
+
+void NaiveRCCollector::Fini() {
+  LOG2FILE(kLogtypeGc) <<  "NaiveRCCollector::Fini()" << std::endl;
+  RCCollector::Fini();
+  ms.Fini();
+}
+
+void NaiveRCCollector::InvokeGC(GCReason reason, bool unsafe) {
+  ms.InvokeGC(reason, unsafe);
+}
+
+// This is invoked from release on stack allocated object only
+void NaiveRCMutator::DecChildrenRef(address_t obj) {
+  // Dec ref for object's children.
+  auto refFunc = [&, this](reffield_t &field, uint64_t kind) {
+    address_t child = RefFieldToAddress(field);
+    if (child == obj || kind == kUnownedRefBits) {
+      return;
+    }
+    if (kind == kNormalRefBits) {
+      DecRefInline<-1, 0, 0>(child, *releaseQueue);
+    } else {
+      DecRefInline<0, -1, 0>(child, *releaseQueue);
+    }
+  };
+  DoForEachRefField(obj, refFunc);
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collector/collector_naiverc_ms.cpp b/src/mrt/compiler-rt/src/collector/collector_naiverc_ms.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ecf0a3cb17497ae9218574042a36fe18f82af144
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/collector_naiverc_ms.cpp
@@ -0,0 +1,892 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/collector_naiverc_ms.h"
+
+#include "chosen.h"
+#include "collie.h"
+#include "collector/conn_comp.h"
+#include "collector/cp_generator.h"
+#include "yieldpoint.h"
+#include "mutator_list.h"
+#include "mstring_inline.h"
+
+namespace maplert {
+namespace {
+  // Minimum time between cycle pattern learning
+  constexpr uint64_t kMinTimeBetweenCPLearningMS = 10LL * 60 * 1000; // 10 min
+}
+
+NaiveRCMarkSweepCollector::NaiveRCMarkSweepCollector() : MarkSweepCollector() {
+  type = kNaiveRCMarkSweep;
+  alwaysCreateCyclePattern = MRT_ENVCONF(PATTERN_FROM_BACKUP_TRACING, PATTERN_FROM_BACKUP_TRACING_DEFAULT);
+  lastCyclePatternLearnMS = timeutils::MilliSeconds() - kMinTimeBetweenCPLearningMS;
+}
+
+void NaiveRCMarkSweepCollector::PreMSHook() {
+  MarkSweepCollector::PreMSHook();
+}
+
+void NaiveRCMarkSweepCollector::PostMSHook(uint64_t gcIndex) {
+  MarkSweepCollector::PostMSHook(gcIndex);
+}
+
+void NaiveRCMarkSweepCollector::PreSweepHook() {
+  MarkSweepCollector::PreSweepHook();
+  if (VLOG_IS_ON(opencyclelog)) {
+    DumpCycleProfile();
+  }
+
+  uint64_t now = timeutils::MilliSeconds();
+  if (alwaysCreateCyclePattern ||
+      (reasonCfgs[gcReason].ShouldCollectCycle() &&
+      (now - lastCyclePatternLearnMS) >= kMinTimeBetweenCPLearningMS)) {
+    MRT_PHASE_TIMER("Sweep: learn hot cycles");
+    lastCyclePatternLearnMS = now;
+    DumpCycleLeak(*GetThreadPool());
+  }
+}
+
+address_t NaiveRCMarkSweepCollector::LoadStaticRoot(address_t *rootAddr) {
+  LinkerRef ref(rootAddr);
+  if (ref.IsIndex()) {
+    return 0;
+  }
+
+  address_t obj = LoadRefField(rootAddr);
+  // The static field may be volatile, and other thread is loading.
+  // If read the spinlock, it needs wait for the volatile loading.
+  if ((obj & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK) {
+    size_t count = 0xf;
+    while (true) {
+      int ret = sched_yield();
+      if (UNLIKELY(ret != 0)) {
+        LOG(ERROR) << "sched_yield() in LoadStaticRoot return " << ret << "rather than 0." << maple::endl;
+      }
+
+      std::atomic<reffield_t> &volatileAddr = AddrToLValAtomic<reffield_t>(reinterpret_cast<address_t>(rootAddr));
+      obj = RefFieldToAddress(volatileAddr.load(std::memory_order_relaxed));
+      if ((obj & LOAD_INC_RC_MASK) != LOAD_INC_RC_MASK) {
+        return obj;
+      } else {
+        --count;
+        if (count == 0) {
+          count = 0xf;
+          LOG(ERROR) << "LoadStaticRoot current value: " << obj << " addr: " << rootAddr << maple::endl;
+        }
+      }
+    }
+  }
+  return obj;
+}
+
+// Atomic decrement all live neighbors of a deadobject.
+// Only called during parallel backup tracing.
+void NaiveRCMarkSweepCollector::DecNeighborsAtomic(uintptr_t obj) {
+  __MRT_ASSERT(!HasReleasedBit(obj), "object is marked released in parallel sweep");
+  auto refFunc = [obj, this](reffield_t &field, uint64_t kind) {
+    address_t ref = RefFieldToAddress(field);
+    if ((kind != kUnownedRefBits) && InHeapBoundry(ref) && (ref != obj) && !IsGarbage(ref) && !IsMygoteObj(ref)) {
+      uint32_t oldHeader, oldRC;
+      if (kind == kNormalRefBits) {
+        oldHeader = AtomicUpdateRC<-1, 0, 0>(ref);
+        oldRC = GetRCFromRCHeader(oldHeader);
+      } else {
+        oldHeader = AtomicUpdateRC<0, -1, 0>(ref);
+        oldRC = GetWeakRCFromRCHeader(oldHeader);
+      }
+      // in parallel gc, ref is not garbage, it must have reference and can not be released or weak released
+      if (UNLIKELY(oldRC == 0)) {
+        MClass *childClass = reinterpret_cast<MObject*>(ref)->GetClass();
+        MClass *objClass = reinterpret_cast<MObject*>(obj)->GetClass();
+        LOG2FILE(kLogtypeGc) << "DecNeighborsAtomic from zero " << std::hex << ref << " " << oldHeader <<
+            " " << RCHeader(ref) << " "  << GCHeader(ref) << " " << std::dec <<
+            ((childClass == nullptr) ? "already freed" : childClass->GetName()) <<
+            " parent is " <<  objClass->GetName() << '\n';
+        HandleRCError(ref);
+      }
+#if __MRT_DEBUG
+      uint32_t releaseState;
+      if (kind == kNormalRefBits) {
+        releaseState = CanReleaseObj<-1, 0, 0>(oldHeader);
+      } else {
+        releaseState = CanReleaseObj<0, -1, 0>(oldHeader);
+      }
+      if (releaseState == kReleaseObject) {
+        if (!doConservativeStackScan) {
+          LOG(FATAL) << "live object can be released after parall sweep " << std::hex << ref << " " << oldHeader <<
+              " " << RCHeader(ref) << " " << GCHeader(ref) << std::dec << maple::endl;
+        } else {
+          // ref might live due to conservertive stack scan
+          // put object into release queue
+          RCReferenceProcessor::Instance().AddAsyncReleaseObj(ref, false);
+        }
+      }
+#endif
+#if RC_TRACE_OBJECT
+      TraceRefRC(ref, RefCount(ref),
+          (kind == kNormalRefBits ? "After DecNeighborsAtomic strong" : "After DecNeighborsAtomic weak"));
+#endif
+      LOG2FILE(kLogTypeMix) << "Atomic DEC neighbor: 0x" << ref << " from " << oldHeader << std::endl;
+    }
+  };
+  ForEachRefField(obj, refFunc);
+}
+
+void NaiveRCMarkSweepCollector::ConcurrentDoReference(uint32_t flags) {
+  function<void(address_t&)> visitRoot = [this, flags](address_t &reference) -> void {
+    // reference processor may modify the reference, using C++ Reference may cause racing problem.
+    // use a stack variable to avoid the racing.
+    address_t ref = reference;
+    if (ref == 0) {
+      return;
+    }
+
+    bool referenceAlive = !IsGarbage(ref);
+
+    // there will be refinement, it's ok to use the following unsafe get
+    address_t referent = ReferenceGetReferent(ref);
+
+    if (!referenceAlive) {
+      if (!(flags & RPMask(kRPPhantomRef))) {
+        // soft & weak
+        deadSoftWeaks.push_back(&reference);
+      } else {
+        // cleaner & phantom
+        deadPhantoms.push_back(&reference);
+      }
+    } else {
+      // if mutator is accessing the referent, delay the decision to STW phase
+      bool racing = ((referent & LOAD_INC_RC_MASK) == LOAD_INC_RC_MASK);
+
+      // reference is alive, none-heap referent should keep alive
+      if (racing || (referent && InHeapBoundry(referent) && IsGarbage(referent))) {
+        if (!(flags & RPMask(kRPPhantomRef))) {
+          // soft & weak
+          clearReferentSoftWeaks.push_back(ref);
+        } else {
+          // cleaner & phantom
+          clearReferentPhantoms.push_back(ref);
+        }
+      }
+    }
+  };
+
+  MRT_GCVisitReferenceRoots(visitRoot, flags);
+}
+
+void NaiveRCMarkSweepCollector::ReferenceRefinement(uint32_t flags) {
+  std::vector<address_t*> *deadsPointer = nullptr;
+  std::vector<address_t> *clearReferentsPointer = nullptr;
+  if (flags & RPMask(kRPPhantomRef)) {
+    deadsPointer = &deadPhantoms;
+    clearReferentsPointer = &clearReferentPhantoms;
+  } else {
+    deadsPointer = &deadSoftWeaks;
+    clearReferentsPointer = &clearReferentSoftWeaks;
+  }
+
+  std::vector<address_t*> &deads = *deadsPointer;
+  std::vector<address_t> &clearReferents = *clearReferentsPointer;
+  uint32_t trueDead = 0;
+  uint32_t trueNeedClear = 0;
+
+  for (address_t *reference : deads) {
+    __MRT_ASSERT(reference != nullptr, "should be valid reference address");
+    if (*reference == 0) {
+      continue;
+    }
+    if (IsGarbage(*reference)) {
+      address_t referent = ReferenceGetReferent(*reference);
+      if (referent) {
+        DecReferentSyncCheck(referent, !(flags & RPMask(kRPPhantomRef)));
+        ReferenceClearReferent(*reference);
+      }
+      (void)AtomicUpdateRC<-1, 0, 0>(*reference);
+      *reference = 0;
+      ++trueDead;
+    } else {
+      address_t referent = ReferenceGetReferent(*reference);
+      if (referent && InHeapBoundry(referent) && IsGarbage(referent)) {
+        DecReferentSyncCheck(referent, !(flags & RPMask(kRPPhantomRef)));
+        ReferenceClearReferent(*reference);
+        ++trueNeedClear;
+      }
+    }
+  }
+
+  for (address_t reference : clearReferents) {
+    if (!IsGarbage(reference)) {
+      address_t referent = ReferenceGetReferent(reference);
+      if (referent && InHeapBoundry(referent) && IsGarbage(referent)) {
+        DecReferentSyncCheck(referent, !(flags & RPMask(kRPPhantomRef)));
+        ReferenceClearReferent(reference);
+        ++trueNeedClear;
+      }
+    }
+  }
+
+  LOG2FILE(kLogtypeGc) << "  truely dead references = " << trueDead << "\n";
+  LOG2FILE(kLogtypeGc) << "  truely need clear refernt references = " << trueNeedClear << "\n";
+}
+
+void NaiveRCMarkSweepCollector::ParallelDoReference(uint32_t flags) {
+  __MRT_ASSERT((flags & ~kRPAllFlags) == 0, "DoReference flag kMrtScanAll");
+
+  std::atomic<size_t> numProcessed = { 0 };
+  std::atomic<size_t> numIterated = { 0 };
+  std::atomic<size_t> numDead = { 0 };
+  std::atomic<size_t> numRcOne = { 0 };
+
+  function<void(address_t&)> visitRoot =
+      [this, &numIterated, &numProcessed, &numDead, &numRcOne, flags](address_t &reference) -> void {
+        numIterated.fetch_add(1, std::memory_order_relaxed);
+        if (reference == 0) {
+          return;
+        }
+
+        uint32_t referenceRc = RefCount(reference);
+        bool referenceAlive = !IsGarbage(reference);
+
+        if (referenceRc == 0) {
+          __MRT_ASSERT(!referenceAlive, "reference_alive");
+          // RefCount(reference) == 0, IsGarbage(reference): processed, do nothing here.
+        }
+        else {
+          // RefCount(reference) > 0;
+          address_t referent = ReferenceGetReferent(reference);
+
+          if (!referenceAlive) {
+            // reference in dead cycle.
+            // in case finalize resurrect this reference, cleare referent early
+            numDead.fetch_add(1, std::memory_order_relaxed);
+            if (referenceRc == 1) {
+              numRcOne.fetch_add(1, std::memory_order_relaxed);
+            }
+            if (referent) {
+              DecReferentSyncCheck(referent, !(flags & RPMask(kRPPhantomRef)));
+              ReferenceClearReferent(reference);
+            }
+            MRT_DecRefUnsync(reference);
+            reference = 0;
+          } else {
+            // reference is alive.
+            // Clear referent and enqueue when referent is not alive.
+            // reference is alive, none-heap referent should keep alive
+            if (referent && InHeapBoundry(referent) && IsGarbage(referent)) {
+              DecReferentSyncCheck(referent, !(flags & RPMask(kRPPhantomRef)));
+              ReferenceClearReferent(reference);
+              numProcessed.fetch_add(1, std::memory_order_relaxed);
+              LOG2FILE(kLogTypeMix) << "Clear referent in reference[" << flags << "] " << reference << std::endl;
+            }
+          }
+        }
+      };
+
+  MRT_ParallelVisitReferenceRoots(*GetThreadPool(), visitRoot, flags);
+  LOG2FILE(kLogtypeGc) << numProcessed.load(std::memory_order_relaxed) << " references[" <<
+      flags << "] processed" << std::endl;
+  LOG2FILE(kLogtypeGc) << "  iterated references = " << numIterated.load(std::memory_order_relaxed) << "\n";
+  LOG2FILE(kLogtypeGc) << "  processed references = " << numProcessed.load(std::memory_order_relaxed) << "\n";
+  LOG2FILE(kLogtypeGc) << "  dead references = " << numDead.load(std::memory_order_relaxed) << "\n";
+  LOG2FILE(kLogtypeGc) << "  rc one references = " << numRcOne.load(std::memory_order_relaxed) << "\n";
+  LOG2FILE(kLogtypeGc) << "  uncollected references = " << (numIterated.load(std::memory_order_relaxed) -
+      numDead.load(std::memory_order_relaxed) - numProcessed.load(std::memory_order_relaxed)) << "\n";
+}
+
+static vector<address_t> FindNeighbors(address_t objaddr) {
+  vector<address_t> neighbors;
+  auto refFunc = [&neighbors, objaddr](reffield_t &field, uint64_t kind) {
+    address_t ref = RefFieldToAddress(field);
+    if (kind == kNormalRefBits && IS_HEAP_ADDR(ref) && (objaddr != ref)) {
+      neighbors.push_back(ref);
+    }
+  };
+  ForEachRefField(objaddr, refFunc);
+  return neighbors;
+}
+
+// Invoke only at STW before sweep, Collect garbage cycles in GC garbage, steps:
+// 1. collect garbage objects
+//    exclude: object without child, garbage rc is 0
+//    Can be collected in parallel with threadPool
+// 2. Compute SCC in garbage set, initial garbage with WorkItem(ENTER, obj)
+//    exclude: self cycle, too big cycles(if big data is off)
+//    Output: CycleGarbage or CyclePattern
+// 3. Merge and log for big data
+//
+// 1. in qemu test, collect all and study all
+// 2. in andorid, limit STW time to 300ms total
+//    2.1 if bigdata string is cached, only study, skip large/duplicate scc
+//    2.2 if bigdata string is empty, study all
+void NaiveRCMarkSweepCollector::DumpCycleLeak(MplThreadPool &threadPool __attribute__((unused))) {
+  LOG2FILE(kLogtypeCycle) << "Cycle Leak start" << std::endl;
+
+  CyclePatternGenerator cpg;
+  {
+    ConnectedComponentFinder finder(FindNeighbors);
+    finder.RunInBackupTrace(*this, cpg);
+  }
+
+  // print cycle pattern generated by backup tracing
+  {
+    MRT_PHASE_TIMER("DumpCycleLeak: Cycle pattern merge");
+    ClassCycleManager::MergeCycles(cpg.Cycles());
+    ClassCycleManager::RemoveDeadPatterns();
+  }
+  // bigdata
+  LOG2FILE(kLogtypeCycle) << "Cycle Leak end" << std::endl;
+  MRT_SendSaveCpJob();
+}
+
+void NaiveRCMarkSweepCollector::DumpCycleProfile() {
+  constexpr size_t kDumpLimit = 100LL * maple::MB;
+  ClassCycleManager::DumpDynamicCyclePatterns(GCLog().Stream(kLogtypeCycle), kDumpLimit, true);
+}
+
+void NaiveRCMarkSweepCollector::DebugCleanup() {
+  // GC is stoped in GC.Finalize()
+  const char *mapleReportRCLeak = getenv("MAPLE_REPORT_RC_LEAK");
+  if (mapleReportRCLeak != nullptr) {
+    CheckLeakAndCycle();
+  }
+
+  const char *mapleVerifyRC = getenv("MAPLE_VERIFY_RC");
+  if (mapleVerifyRC != nullptr) {
+    DebugVerifyRC();
+  }
+}
+
+void NaiveRCMarkSweepCollector::CheckLeakAndCycle() {
+  LOG(INFO) << "Start CheckLeakAndCycle" << maple::endl;
+  ScopedStopTheWorld pauseTheWorld;
+  LOG(INFO) << "World stopped" << maple::endl;
+
+  InitTracing();
+  RootSet rootSet;
+  ParallelScanRoots(rootSet, false, true);
+  MrtVisitReferenceRoots([&rootSet](address_t obj) {
+    if (obj != 0) {
+      rootSet.push_back(obj);
+    }
+  }, kRPAllFlags);
+  // skip RC overflowed object
+  (void)(*theAllocator).ForEachObj([&rootSet](address_t obj) {
+    if (IsRCSkiped(obj)) {
+      rootSet.push_back(obj);
+    }
+  });
+  // trigger tracing mark which follows referent. if not follow referent here, qemu test will fail
+  ParallelMark(rootSet, true);
+
+  // leak/cycle dection
+  DetectLeak();
+  EndTracing();
+  ResetBitmap();
+  LOG(INFO) << "World restarted" << maple::endl;
+}
+
+void NaiveRCMarkSweepCollector::StatReferentRootRC(RCHashMap referentRoots[], uint32_t rpTypeNum) {
+  RootSet rs;
+  function<void(address_t)> visitRefRoots = [&rs](address_t obj) {
+    if (obj != 0) {
+      rs.push_back(obj);
+    }
+  };
+
+  rs.clear();
+  MrtVisitReferenceRoots(visitRefRoots, RPMask(kRPSoftRef));
+  __MRT_ASSERT(kRPSoftRef < rpTypeNum, "Invalid index");
+  CollectReferentRoot(rs, referentRoots[kRPSoftRef]);
+
+  rs.clear();
+  MrtVisitReferenceRoots(visitRefRoots, RPMask(kRPWeakRef));
+  __MRT_ASSERT(kRPWeakRef < rpTypeNum, "Invalid index");
+  CollectReferentRoot(rs, referentRoots[kRPWeakRef]);
+
+  rs.clear();
+  MrtVisitReferenceRoots(visitRefRoots, RPMask(kRPPhantomRef));
+  __MRT_ASSERT(kRPPhantomRef < rpTypeNum, "Invalid index");
+  CollectReferentRoot(rs, referentRoots[kRPPhantomRef]);
+}
+
+void NaiveRCMarkSweepCollector::StatHeapRC() {
+  // stat heap reference
+  (void)(*theAllocator).ForEachObj([this](address_t obj) {
+    auto refFunc = [&](reffield_t &field, uint64_t kind) {
+      address_t ref = RefFieldToAddress(field);
+      if (InHeapBoundry(ref) && ref != obj && kind != kUnownedRefBits) {
+        if (IsMygoteObj(obj)) {
+          if (kind == kNormalRefBits) {
+            UpdateRCMap(mygoteObjs, ref);
+          } else {
+            UpdateRCMap(mygoteWeakObjs, ref);
+          }
+        } else {
+          if (kind == kNormalRefBits) {
+            UpdateRCMap(heapObjs, ref);
+          } else {
+            UpdateRCMap(heapWeakObjs, ref);
+          }
+        }
+      }
+    };
+    ForEachRefField(obj, refFunc);
+  });
+}
+
+void NaiveRCMarkSweepCollector::VerifyRC() {
+  RCHashMap referentRoots[kRPTypeNum];
+  StatReferentRootRC(referentRoots, kRPTypeNum);
+  StatHeapRC();
+
+  uint32_t potentialEarlyRelease = 0U;
+  uint32_t potentialLeak = 0U;
+  uint32_t wrongWeakRCObjs = 0U;
+  std::map<uint32_t, uint32_t> weakRCDistribution;
+
+  (void)(*theAllocator).ForEachObj([&, this](address_t obj) {
+    StatRC statRC = NewStatRC(referentRoots, kRPTypeNum, obj);
+    if (statRC.weakTotal > 0) {
+      if (weakRCDistribution.find(statRC.weakTotal) == weakRCDistribution.end()) {
+        weakRCDistribution[statRC.weakTotal] = 1;
+      } else {
+        weakRCDistribution[statRC.weakTotal] += 1;
+      }
+    }
+    uint32_t rc = RefCount(obj);
+    bool danger = IsRCOverflow(rc) ? false : (rc < (statRC.accurate + statRC.heaps) && (statRC.mygote == 0));
+    bool leak = IsRCOverflow(rc) ? false : (rc > (statRC.accurate + statRC.heaps + statRC.stacks));
+    uint32_t resurrectWeakRC = ResurrectWeakRefCount(obj);
+    uint32_t weakRC = (IsWeakCollected(obj) && (!IsEnqueuedObjFinalizable(obj))) ? WeakRefCount(obj) :
+                                                                                   (WeakRefCount(obj) - 1);
+    bool weakWrong = IsRCOverflow(rc) ? false :
+                     ((weakRC < statRC.weakCount) && (weakRC != kMaxWeakRC) &&
+                     ((weakRC > statRC.weakCount) && (statRC.mygoteWeak == 0))) ||
+                     ((resurrectWeakRC != statRC.resurrectWeakCount) && (resurrectWeakRC != kMaxResurrectWeakRC));
+    if (danger || leak || weakWrong) {
+      if (danger) {
+        potentialEarlyRelease += 1U;
+      } else if (leak) {
+        potentialLeak += 1U;
+      } else {
+        wrongWeakRCObjs += 1U;
+      }
+      string errMsg = danger ? "DANGER" : weakWrong ? "WEAK_WRONG" : "LEAK";
+#if __MRT_DEBUG
+      PrintRCWrongDetails(obj, statRC, errMsg, rc, weakRC);
+#endif
+    }
+  });
+
+#if __MRT_DEBUG
+  PrintRCVerifyResult(weakRCDistribution, potentialEarlyRelease, potentialLeak, wrongWeakRCObjs);
+#endif
+
+  if ((potentialEarlyRelease + potentialLeak + wrongWeakRCObjs) != 0U) {
+    LOG(ERROR) << "===============>RC Verfiy Failed!" << std::endl;
+  }
+}
+
+void NaiveRCMarkSweepCollector::PrintRCVerifyResult(std::map<uint32_t, uint32_t> &weakRCDistribution,
+    uint32_t potentialEarlyRelease, uint32_t potentialLeak, uint32_t wrongWeakRCObjs) {
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] [RC Verify] total " << potentialEarlyRelease <<
+      " objects potential early release" << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] [RC Verify] total " << potentialLeak << " objects potential leak" << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] [RC Verify] total " << wrongWeakRCObjs <<
+      " objects weak rc are wrong" << std::endl;
+
+  for (auto item : weakRCDistribution) {
+    LOG2FILE(kLogtypeGcOrStderr) << "[MS] weakRC = " << item.first << ", ref_num = " << item.second << std::endl;
+  }
+}
+
+void NaiveRCMarkSweepCollector::PrintRCWrongDetails(address_t obj, const StatRC &statRC, const string &errMsg,
+    uint32_t rc, uint32_t weakRC) {
+  // something bad has happened
+  MClass *classInfo = reinterpret_cast<MObject*>(obj)->GetClass();
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] [RC Verify] " << errMsg <<
+      " obj " << obj << " rc wrong: rc = " << rc << std::endl;
+
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tsummary: accurate = " << statRC.accurate <<
+      ", conservative = " << statRC.stacks << ", heap = " << statRC.heaps << ", weak_accuate = " << statRC.weakTotal <<
+      ", weakRC = " << weakRC << ", resurrect weakRC = " << statRC.resurrectWeakCount << " " <<
+      (IsWeakCollected(obj) ? "collected" : "not collectecd") << std::endl;
+
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tclass: " << classInfo->GetName() << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tstatic & const string roots = " << statRC.staticFields << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\texternal roots              = " << statRC.externals << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tstring roots                = " << statRC.strings << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\treference roots             = " << statRC.references << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tallocator roots             = " << statRC.allocators << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tclassloader roots           = " << statRC.classloaders << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tstack roots                 = " << statRC.stacks << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tweak global roots           = " << statRC.weakGlobals << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tsoft                        = " << statRC.soft << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tweak                        = " << statRC.weak << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\tphantom and cleaner         = " << statRC.phantom << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "[MS] \t\theap weak field             = " << statRC.weakHeaps << std::endl;
+}
+
+StatRC NaiveRCMarkSweepCollector::NewStatRC(RCHashMap referentRoots[], uint32_t rpTypeNum, address_t obj) {
+  StatRC statRC;
+  statRC.staticFields = GetRCFromMap(obj, staticFieldRoots);
+  statRC.weakGlobals = GetRCFromMap(obj, weakGlobalRoots);
+  statRC.externals = GetRCFromMap(obj, externalRoots);
+  statRC.strings = GetRCFromMap(obj, stringRoots);
+  statRC.references = GetRCFromMap(obj, referenceRoots);
+  statRC.allocators = GetRCFromMap(obj, allocatorRoots);
+  statRC.classloaders = GetRCFromMap(obj, classloaderRoots);
+  statRC.stacks = GetRCFromMap(obj, stackRoots);
+  statRC.heaps = GetRCFromMap(obj, heapObjs);
+  statRC.weakHeaps = GetRCFromMap(obj, heapWeakObjs);
+  statRC.mygote = GetRCFromMap(obj, mygoteObjs);
+  statRC.mygoteWeak = GetRCFromMap(obj, mygoteWeakObjs);
+
+  __MRT_ASSERT(kRPSoftRef < rpTypeNum, "Invalid index");
+  statRC.soft = GetRCFromMap(obj, referentRoots[kRPSoftRef]);
+  __MRT_ASSERT(kRPWeakRef < rpTypeNum, "Invalid index");
+  statRC.weak = GetRCFromMap(obj, referentRoots[kRPWeakRef]);
+  __MRT_ASSERT(kRPPhantomRef < rpTypeNum, "Invalid index");
+  statRC.phantom = GetRCFromMap(obj, referentRoots[kRPPhantomRef]);
+
+  statRC.heaps = statRC.heaps - (statRC.soft + statRC.weak + statRC.phantom) + statRC.mygote;
+  statRC.weakCount = statRC.phantom + statRC.weakHeaps + statRC.mygoteWeak;
+  statRC.resurrectWeakCount = statRC.weakGlobals + statRC.soft + statRC.weak;
+  statRC.weakTotal = statRC.resurrectWeakCount + statRC.weakCount;
+  statRC.accurate = statRC.staticFields + statRC.externals + statRC.strings + statRC.references + statRC.allocators +
+                    statRC.classloaders;
+  return statRC;
+}
+
+void NaiveRCMarkSweepCollector::DebugVerifyRC() {
+  LOG(INFO) << "Start RC Verification " << maple::endl;
+  ScopedStopTheWorld pauseTheWorld;
+  LOG(INFO) << "World stopped" << maple::endl;
+#ifdef __ANDROID__
+  mplCollie.SetSTWPanic(false);
+#endif
+
+  InitTracing();
+  RootSet rootSet;
+  SetRCVerify(true);
+  ParallelScanRoots(rootSet, true, false);
+  EndTracing();
+  ResetBitmap();
+  LOG(INFO) << "World restarted" << maple::endl;
+}
+
+void NaiveRCMarkSweepCollector::DetectLeak() {
+  size_t totalObjCount = 0;
+  size_t totalSize = 0;
+  size_t totalLeakSize = 0;
+  set<address_t> leakObjectSet;
+  bool tmpResult = (*theAllocator).ForEachObj([&, this](address_t obj) {
+    size_t objSize = reinterpret_cast<MObject*>(obj)->GetSize();
+    totalSize += objSize;
+    if (IsGarbage(obj)) {
+      totalLeakSize += objSize;
+      if (UNLIKELY(!leakObjectSet.insert(obj).second)) {
+        LOG(ERROR) << "leakObjectSet.insert() in TracingCollector::DetectLeak() failed." << maple::endl;
+      }
+    }
+    ++totalObjCount;
+  });
+  if (UNLIKELY(!tmpResult)) {
+    LOG(ERROR) << "(*theAllocator).ForEachObj() in TracingCollector::DetectLeak() return false." << maple::endl;
+  }
+
+  LOG2FILE(kLogtypeGcOrStderr) << "Total Objects " << totalObjCount << ", Total Leak Count " <<
+      leakObjectSet.size() << std::endl;
+  LOG2FILE(kLogtypeGcOrStderr) << "Total Objects size " << totalSize << ", Total Leak size " <<
+      totalLeakSize << std::endl;
+  PrintLeakRootAndRetainCount(leakObjectSet);
+}
+
+void NaiveRCMarkSweepCollector::PrintLeakRootAndRetainCount(set<address_t> &garbages) {
+  // check if leak object is root, when
+  // 1. not referenced by other leak object
+  // 2. can be referenced by it self
+  set<address_t> rootSet;
+  rootSet.insert(garbages.begin(), garbages.end());
+  const char *mapleReportRCLeakDetail = getenv("MAPLE_REPORT_RC_LEAK_DETAIL");
+  for (auto it = garbages.begin(); it != garbages.end(); ++it) {
+    address_t leakObj = *it;
+    auto refFunc = [&garbages, &rootSet](reffield_t &field, uint64_t kind) {
+      address_t ref = RefFieldToAddress(field);
+      if ((kind != kUnownedRefBits) && (garbages.find(ref) != garbages.end())) {
+        rootSet.erase(ref);
+      }
+    };
+    ForEachRefField(leakObj, refFunc);
+    if (mapleReportRCLeakDetail != nullptr) {
+      MClass *classInfo = reinterpret_cast<MObject*>(leakObj)->GetClass();
+      const char *className = classInfo->GetName();
+      LOG2FILE(kLogtypeGcOrStderr) << "Leak Object "" 0x" << std::hex << leakObj << " RC=" <<
+          RefCount(leakObj) << " " << className << std::endl;
+    }
+  }
+  LOG2FILE(kLogtypeGcOrStderr) << " Total none-cycle root objects " << rootSet.size() << std::endl;
+
+  // find cycles
+  vector<address_t> garbagesVec;
+  std::copy(garbages.begin(), garbages.end(), std::back_inserter(garbagesVec));
+
+  ConnectedComponentFinder finder(garbagesVec, FindNeighbors);
+  finder.Run();
+  vector<vector<address_t>> components = finder.GetResults();
+  PrintMultiNodeCycleCount(components);
+
+  size_t componentIdx = 0;
+  for (auto &component : components) {
+    ++componentIdx;
+    // if component has root, calcuate its retain sizes
+    bool isRoot = (component.size() > 1) ? true : rootSet.find(component.at(0)) != rootSet.end();
+    if (isRoot) {
+      set<address_t> reachingSet;
+      for (auto objaddr : component) {
+        if (UNLIKELY(!reachingSet.insert(objaddr).second)) {
+          LOG(ERROR) << "reachingSet.insert() in PrintLeakRootAndRetainCount() failed." << maple::endl;
+        }
+      }
+      InsertSetForEachRefField(reachingSet, garbages);
+#if __MRT_DEBUG
+      PrintLeakRoots(reachingSet, component, componentIdx);
+#endif
+    }
+  }
+}
+
+void NaiveRCMarkSweepCollector::PrintMultiNodeCycleCount(vector<vector<address_t>> &components) {
+  size_t multNodeCycleCount = 0;
+  for (auto &component : components) {
+    if (component.size() > 1) {
+      ++multNodeCycleCount;
+    }
+  }
+  LOG2FILE(kLogtypeGcOrStderr) << " Total multi-node cycle count " << multNodeCycleCount << std::endl;
+}
+
+void NaiveRCMarkSweepCollector::InsertSetForEachRefField(set<address_t> &reachingSet, set<address_t> &garbages) {
+  set<address_t> visitingSet;
+  visitingSet.insert(reachingSet.begin(), reachingSet.end());
+  while (true) {
+    set<address_t> newAddedSet;
+    for (auto it = visitingSet.begin(); it != visitingSet.end(); ++it) {
+      address_t leakObj = *it;
+      auto refFunc = [&garbages, &reachingSet, &newAddedSet](reffield_t &field, uint64_t kind) {
+        address_t ref = RefFieldToAddress(field);
+        // garbage and not added into reaching set
+        if ((kind == kNormalRefBits) &&
+            (garbages.find(ref) != garbages.end()) &&
+            (reachingSet.find(ref) == reachingSet.end())) {
+          if (UNLIKELY(!reachingSet.insert(ref).second)) {
+            LOG(ERROR) << "reachingSet.insert() in InsertSetForEachRefField() failed." << maple::endl;
+          }
+          if (UNLIKELY(!newAddedSet.insert(ref).second)) {
+            LOG(ERROR) << "newAddedSet.insert() in InsertSetForEachRefField() failed." << maple::endl;
+          }
+        }
+      };
+      ForEachRefField(leakObj, refFunc);
+    }
+    if (newAddedSet.size() == 0) {
+      break;
+    }
+    visitingSet.clear();
+    visitingSet.insert(newAddedSet.begin(), newAddedSet.end());
+    newAddedSet.clear();
+  }
+}
+
+void NaiveRCMarkSweepCollector::PrintLeakRoots(set<address_t> &reachingSet, vector<address_t> &component,
+    size_t componentIdx) {
+  // print root, calculate reaching set object size
+  size_t reachingObjectsSize = 0;
+  for (auto objaddr : reachingSet) {
+    reachingObjectsSize += reinterpret_cast<MObject*>(objaddr)->GetSize();
+  }
+
+  if (component.size() > 1) {
+    LOG2FILE(kLogtypeGcOrStderr) << "[" << componentIdx << "] Cycle Leak: retain num " << reachingSet.size() <<
+        ", retain sz " << reachingObjectsSize << ", cycle count " << component.size() << std::endl;
+    for (auto objaddr : component) {
+      uint32_t rc = RefCount(objaddr);
+      MClass *classInfo = reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(objaddr))->GetClass();
+      const char *className = classInfo->GetName();
+      LOG2FILE(kLogtypeGcOrStderr) << "[" << componentIdx << "]    0x" << std::hex << objaddr <<
+          " RC=" << rc << " " << className << std::endl;
+    }
+  } else {
+    __MRT_ASSERT(component.size() == 1, "Invalid component");
+    auto objaddr = component.at(0);
+    MClass *classInfo = reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(objaddr))->GetClass();
+    const char *className = classInfo->GetName();
+    LOG2FILE(kLogtypeGcOrStderr) << "[" << componentIdx << "] Leak: retain num " << reachingSet.size() <<
+        ", retain sz " << reachingObjectsSize << ", "" 0x" << std::hex << objaddr << " RC=" << RefCount(objaddr) <<
+        " " << WeakRefCount(objaddr) << " " << ResurrectWeakRefCount(objaddr) << " " <<
+        (IsWeakCollected(objaddr) ? "weak collected" : "not weak collected") << " " << className << std::endl;
+  }
+}
+
+void NaiveRCMarkSweepCollector::CollectReferentRoot(RootSet &rs, RCHashMap &map) {
+  for (auto it = rs.begin(); it != rs.end(); ++it) {
+    address_t reference = *it;
+    if (FastIsHeapObject(reference)) {
+      address_t referent = ReferenceGetReferent(reference);
+      if (FastIsHeapObject(referent)) {
+        UpdateRCMap(map, referent);
+      }
+    }
+  }
+}
+
+void NaiveRCMarkSweepCollector::ClearRootsMap() {
+  if (UNLIKELY(rcVerification)) {
+    staticFieldRoots.clear();
+    externalRoots.clear();
+    weakGlobalRoots.clear();
+    stringRoots.clear();
+    referenceRoots.clear();
+    allocatorRoots.clear();
+    classloaderRoots.clear();
+    stackRoots.clear();
+    heapObjs.clear();
+    heapWeakObjs.clear();
+  }
+}
+
+void NaiveRCMarkSweepCollector::PostParallelAddTask(bool processWeak) {
+  if (LIKELY(!rcVerification)) {
+    return;
+  }
+
+  MplThreadPool *threadPool = GetThreadPool();
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this](size_t workerID __attribute__((unused))) {
+    RootSet rs;
+    ScanStringRoots(rs);
+    CollectRootRC(rs, stringRoots);
+  }));
+
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, processWeak](size_t workerID __attribute__((unused))) {
+    RootSet rs;
+    ScanExternalRoots(rs, processWeak);
+    CollectRootRC(rs, externalRoots);
+  }));
+
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this](size_t workerID __attribute__((unused))) {
+    // static-fields root and const-string field root may overlap. deduplicate it to make RC-count correct.
+    std::unordered_set<address_t*> uniqStaticFields;
+    RefVisitor visitor = [&uniqStaticFields](address_t &field) {
+      if (UNLIKELY(!uniqStaticFields.insert(&field).second)) {
+        VLOG(gc) << "uniqStaticFields.insert() in TracingCollector::ParallelScanRoots() failed." << maple::endl;
+      }
+    };
+    GCRegisteredRoots::Instance().Visit(visitor);
+    RootSet rs;
+    for (auto field: uniqStaticFields) {
+      MaybeAddRoot(LoadRefField(field), rs, true);
+    }
+    CollectRootRC(rs, staticFieldRoots);
+  }));
+
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this](size_t workerID __attribute__((unused))) {
+    RootSet rs;
+    ScanWeakGlobalRoots(rs);
+    CollectRootRC(rs, weakGlobalRoots);
+  }));
+
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this](size_t workerID __attribute__((unused))) {
+    RootSet rs1;
+    RootSet rs2;
+    ScanAllocatorRoots(rs1);
+    ScanClassLoaderRoots(rs2);
+    CollectRootRC(rs1, allocatorRoots);
+    CollectRootRC(rs2, classloaderRoots);
+  }));
+
+  // add remaining reference roots
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this](size_t workerID __attribute__((unused))) {
+    RootSet rs;
+    function<void(address_t)> visitRefRoots = [&rs](address_t obj) {
+      if (obj != 0) {
+        rs.push_back(obj);
+      }
+    };
+    MrtVisitReferenceRoots(visitRefRoots, RPMask(kRPSoftRef) | RPMask(kRPWeakRef) | RPMask(kRPPhantomRef));
+    // Some SoftRefs will be the Roots(e.g. Force will push all SoftRefs to roots),
+    // VisitReferenceRoots and ScanReferencesRoots will scan the soft twice,
+    // so create a dummy reason--OOM, to skip softrefs, when ScanReferencesRoots
+    GCReason oldReason = gcReason;
+    SetGCReason(kGCReasonOOM);
+    ScanReferenceRoots(rs);
+    SetGCReason(oldReason);
+    CollectRootRC(rs, referenceRoots);
+  }));
+
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this](size_t workerID __attribute__((unused))) {
+    RootSet rs;
+    auto &list = MutatorList::Instance().List();
+    for (auto it = list.begin(); it != list.end(); ++it) {
+      ScanStackRoots(**it, rs);
+    }
+    RefVisitor visitor = [&rs](address_t &obj) {
+      if (IS_HEAP_OBJ(obj)) {
+        rs.push_back(obj);
+      }
+    };
+    for (auto it = list.begin(); it != list.end(); ++it) {
+      (*it)->VisitNativeStackRoots(visitor);
+    }
+    CollectRootRC(rs, stackRoots);
+  }));
+}
+
+void NaiveRCMarkSweepCollector::PostParallelScanMark(bool processWeak) {
+  if (UNLIKELY(rcVerification)) {
+    MplThreadPool *threadPool = GetThreadPool();
+    PostParallelAddTask(processWeak);
+    threadPool->WaitFinish(true);
+    VerifyRC();
+  }
+}
+
+void NaiveRCMarkSweepCollector::PostParallelScanRoots() {
+  if (UNLIKELY(rcVerification)) {
+    VerifyRC();
+  }
+}
+
+void NaiveRCMarkSweepCollector::ConcurrentMarkPreparePhase(WorkStack &workStack, WorkStack &inaccurateRoots) {
+  if (UNLIKELY(rcVerification)) {
+    // when rc verification is enabled, use parallel scan roots.
+    MRT_PHASE_TIMER("Parallel Root scan and verify rc");
+    ParallelScanRoots(workStack, true, false);
+  } else {
+    // use fast root scan for concurrent marking.
+    MRT_PHASE_TIMER("Fast Root scan");
+    FastScanRoots(workStack, inaccurateRoots, true, false);
+  }
+  // prepare for concurrent marking.
+  ConcurrentMarkPrepare();
+}
+
+void NaiveRCMarkSweepCollector::PostInitTracing() {
+  ClearRootsMap();
+}
+
+void NaiveRCMarkSweepCollector::PostEndTracing() {
+  ClearRootsMap();
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collector/collector_rc.cpp b/src/mrt/compiler-rt/src/collector/collector_rc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f2cf9686120f019796be5c16595790fc13c79f6c
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/collector_rc.cpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/collector_rc.h"
+
+#include "chosen.h"
+#include "mutator_list.h"
+
+namespace maplert {
+#if RC_PROFILE
+std::atomic<uint64_t> RCCollector::numLoadIncRef(0);
+std::atomic<uint64_t> RCCollector::numWriteRefVar(0);
+std::atomic<uint64_t> RCCollector::numWriteRefField(0);
+std::atomic<uint64_t> RCCollector::numReleaseRefVar(0);
+std::atomic<uint64_t> RCCollector::numNativeInc(0);
+std::atomic<uint64_t> RCCollector::numNativeDec(0);
+std::atomic<uint64_t> RCCollector::numIncRef(0);
+std::atomic<uint64_t> RCCollector::numDecRef(0);
+std::atomic<uint64_t> RCCollector::numIncNull(0);
+std::atomic<uint64_t> RCCollector::numDecNull(0);
+
+void RCCollector::PrintStats() {
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] RC statistics:" << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # LoadIncRefVar   : " << RCCollector::numLoadIncRef.load() << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # WriteRefVar   : " << RCCollector::numWriteRefVar.load() << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # WriteRefField : " << RCCollector::numWriteRefField.load() << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # ReleaseRefVar : " << RCCollector::numReleaseRefVar.load() << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # IncRef  : " << RCCollector::numIncRef.load() << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # IncNull : " << RCCollector::numIncNull.load() << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # DecRef  : " << RCCollector::numDecRef.load() << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # DecNull : " << RCCollector::numDecNull.load() << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # NativeInc : " << RCCollector::numNativeInc.load() << std::endl;
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] # NativeDec : " << RCCollector::numNativeDec.load() << std::endl;
+}
+
+void RCCollector::ResetStats() {
+  RCCollector::numLoadIncRef = 0;
+  RCCollector::numWriteRefVar = 0;
+  RCCollector::numWriteRefField = 0;
+  RCCollector::numReleaseRefVar = 0;
+  RCCollector::numIncRef = 0;
+  RCCollector::numDecRef = 0;
+  RCCollector::numIncNull = 0;
+  RCCollector::numDecNull = 0;
+  RCCollector::numNativeInc = 0;
+  RCCollector::numNativeDec = 0;
+}
+
+#else
+
+void RCCollector::PrintStats() {
+  LOG2FILE(kLogtypeGc) << "[RCSTATS] RC statistics is disabled." << std::endl;
+}
+
+void RCCollector::ResetStats() {}
+
+#endif // RC_PROFILE
+
+void RCMutator::Fini() {
+  Mutator::Fini();
+}
+}
diff --git a/src/mrt/compiler-rt/src/collector/collector_tracing.cpp b/src/mrt/compiler-rt/src/collector/collector_tracing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2c89c8abcc699f9e319a6429220ac3e6a6bf382f
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/collector_tracing.cpp
@@ -0,0 +1,1100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/collector_tracing.h"
+
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sched.h>
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cinttypes>
+#include <iterator>
+#include <list>
+#include <fstream>
+
+#include "syscall.h"
+#include "mm_config.h"
+#include "mm_utils.h"
+#include "address.h"
+#include "chosen.h"
+#include "imported.h"
+#include "mutator_list.h"
+// cycle pattern generator depend on the conn-comp
+#include "collector/conn_comp.h"
+#include "collector/cp_generator.h"
+#include "collector/stats.h"
+#include "collector/native_gc.h"
+#include "collie.h"
+#include "mstring_inline.h"
+#include "mrt_array.h"
+
+namespace maplert {
+namespace {
+constexpr int kDefaultWaitGCLiteTimeoutMs = 500; // lite wait gc, timeout by 500ms
+constexpr uint64_t kDefaultSystemAutoGcIntervalNs = 4ULL * 60 * 1000 * 1000 * 1000; // 4mins
+constexpr uint32_t kStaticFieldRootsBatchSize = 256; // static roots batch size is 256
+}
+
+ImmortalWrapper<GCRegisteredRoots> GCRegisteredRoots::instance;
+
+void GCRegisteredRoots::Register(address_t **gcRootsList, size_t len) {
+  std::lock_guard<std::mutex> lock(staticRootsLock);
+  address_t **list = gcRootsList;
+  size_t remain = len;
+  while (true) {
+    if (remain <= kStaticFieldRootsBatchSize) {
+      roots.push_back({remain, list});
+      break;
+    } else {
+      roots.push_back({kStaticFieldRootsBatchSize, list});
+      list += kStaticFieldRootsBatchSize;
+      remain -= kStaticFieldRootsBatchSize;
+    }
+  }
+  totalRootsCount += len;
+}
+
+void GCRegisteredRoots::Visit(RefVisitor &visitor) {
+  {
+    std::lock_guard<std::mutex> lock(staticRootsLock);
+    for (RegisteredRoots &item : roots) {
+      for (size_t i = 0; i < item.length; ++i) {
+        LinkerRef ref(item.roots[i]);
+        if (!ref.IsIndex()) {
+          visitor(*(item.roots[i]));
+        }
+      }
+    }
+  }
+  (*zterpStaticRootAllocator).VisitStaticRoots(visitor);
+}
+
+bool GCRegisteredRoots::GetRootsLocked(size_t index, address_t **&list, size_t &len) {
+  std::lock_guard<std::mutex> lock(staticRootsLock);
+  if (index >= roots.size()) {
+    return false;
+  }
+  list = roots[index].roots;
+  len = roots[index].length;
+  return true;
+}
+
+void TracingCollector::Init() {
+  Collector::Init();
+  StartThread(true);
+}
+
+void TracingCollector::InitAfterFork() {
+  // post fork child
+  Collector::InitAfterFork();
+}
+
+void TracingCollector::Fini() {
+  Collector::Fini();
+  StopThread();
+  JoinThread();
+}
+
+// Start the GC thread(s).
+void TracingCollector::StartThread(bool isZygote) {
+  bool expected = false;
+  if (gcThreadRunning.compare_exchange_strong(expected, true, std::memory_order_acquire) == false) {
+    return;
+  }
+  // starts the thread pool.
+  lastTriggerTime = timeutils::NanoSeconds();
+  if (workerThreadPool == nullptr) {
+    // if it's the zygote thread, 1 thread is enough for GC
+    // in 8 cores, use 4 thread parallel with 3 GC worker thread and 1 GC thread
+    int32_t numThreads = isZygote ? 1 : ((std::thread::hardware_concurrency() / maple::kGCThreadNumAdjustFactor) - 1);
+    numThreads = (numThreads < 1) ? 1 : numThreads;
+    parallelThreadCount = numThreads + 1;
+    if (IsSystem()) {
+      concurrentThreadCount = (parallelThreadCount > kSystemServerConcurrentThreadCount) ?
+          kSystemServerConcurrentThreadCount : parallelThreadCount;
+    } else {
+      concurrentThreadCount = 1;
+    }
+    LOG2FILE(kLogtypeGc) << "concurrent thread count " << concurrentThreadCount <<
+        " parallel thread count " << parallelThreadCount <<
+        " thread pool size " << numThreads << std::endl;
+    workerThreadPool = new (std::nothrow) MplThreadPool("gc", numThreads, maple::kGCThreadPriority);
+    if (workerThreadPool == nullptr) {
+      LOG(FATAL) << "new MplThreadPool failed" << maple::endl;
+    }
+  }
+
+  // create the collector thread.
+  if (::pthread_create(&gcThread, nullptr, TracingCollector::CollectorThreadEntry, this) != 0) {
+    __MRT_ASSERT(0, "pthread_create failed!");
+  }
+  // set thread name.
+  int ret = pthread_setname_np(gcThread, "GC");
+  if (UNLIKELY(ret != 0)) {
+    LOG(ERROR) << "pthread_setname_np() in MarkSweepCollector::StartThread() return " <<
+        ret << " rather than 0" << maple::endl;
+  }
+#ifdef __ANDROID__
+  mplCollie.Init();
+#endif
+}
+
+void TracingCollector::StopThread() {
+  // tell the collector thread to exit.
+  if (gcThreadRunning.load(std::memory_order_acquire) == false) {
+    return;
+  }
+
+  TaskQueue<GCTask>::TaskFilter filter = [](GCTask&, GCTask&) {
+    return false;
+  };
+  GCTask task(ScheduleTaskBase::ScheduleTaskType::kScheduleTaskTypeTerminate);
+  (void)taskQueue.Enqueue<true>(task, filter); // enqueue to sync queue
+  if (workerThreadPool != nullptr) {
+    workerThreadPool->Exit();
+  }
+#ifdef __ANDROID__
+  mplCollie.Fini();
+#endif
+}
+
+void TracingCollector::JoinThread() {
+  // wait for collector thread to exit.
+  // Collector::Fini() usually called from main thread,
+  // if Collector::Fini() called before Mutator::Fini(),
+  // we should enter saferegion when blocking on pthread_join().
+  if (gcThreadRunning.load(std::memory_order_acquire) == false) {
+    return;
+  }
+  ScopedEnterSaferegion enterSaferegion;
+  int ret = ::pthread_join(gcThread, nullptr);
+  if (UNLIKELY(ret != 0)) {
+    LOG(ERROR) << "::pthread_join() in MarkSweepCollector::JoinThread() return " <<
+        ret << "rather than 0." << maple::endl;
+  }
+  // wait the thread pool stopped.
+  if (workerThreadPool != nullptr) {
+    delete workerThreadPool;
+    workerThreadPool = nullptr;
+  }
+  gcThreadRunning.store(false, std::memory_order_release);
+#ifdef __ANDROID__
+  mplCollie.JoinThread();
+#endif
+}
+
+void *TracingCollector::CollectorThreadEntry(void *arg) {
+  // set current thread as a gc thread.
+  (void)maple::tls::CreateTLS();
+  StoreTLS(reinterpret_cast<void*>(true), maple::tls::kSlotIsGcThread);
+
+  LOG(INFO) << "[GC] Thread begin." << maple::endl;
+  __MRT_ASSERT(arg != nullptr, "CollectorThreadEntry arg=nullptr");
+
+  // set thread priority.
+  MRT_SetThreadPriority(maple::GetTid(), maple::kGCThreadPriority);
+
+  // run event loop in this thread.
+  TracingCollector *self = reinterpret_cast<TracingCollector*>(arg);
+  self->RunTaskLoop();
+
+  LOG(INFO) << "[GC] Thread end." << maple::endl;
+  maple::tls::DestoryTLS();
+  return nullptr;
+}
+
+bool TracingCollector::GCTask::Execute(void *owner) {
+  __MRT_ASSERT(owner != nullptr, "task queue owner ptr should not be null!");
+  TracingCollector *traceCollector = reinterpret_cast<TracingCollector*>(owner);
+  switch (taskType) {
+    case ScheduleTaskBase::ScheduleTaskType::kScheduleTaskTypeTerminate: {
+      return false;
+    }
+    case ScheduleTaskBase::ScheduleTaskType::kScheduleTaskTypeTimeout: {
+      if (NativeEpochStats::Instance().isEnabled()) {
+        uint64_t curTime = timeutils::NanoSeconds();
+        if ((curTime - traceCollector->lastTriggerTime) > kDefaultSystemAutoGcIntervalNs) {
+          traceCollector->gcReason = kGCReasonForceGC;
+          traceCollector->lastTriggerTime = timeutils::NanoSeconds();
+          GCReasonConfig &cfg = reasonCfgs[gcReason];
+          cfg.SetLastTriggerTime(static_cast<int64_t>(traceCollector->lastTriggerTime));
+          traceCollector->isGcTriggered.store(true, std::memory_order_relaxed);
+          traceCollector->RunFullCollection(ScheduleTaskBase::kAsyncIndex);
+        }
+      }
+      break;
+    }
+    case ScheduleTaskBase::ScheduleTaskType::kScheduleTaskTypeInvokeGC: {
+      traceCollector->gcReason = gcReason;
+      traceCollector->lastTriggerTime = timeutils::NanoSeconds();
+      GCReasonConfig &cfg = reasonCfgs[gcReason];
+      cfg.SetLastTriggerTime(static_cast<int64_t>(traceCollector->lastTriggerTime));
+      traceCollector->isGcTriggered.store(true, std::memory_order_relaxed);
+      traceCollector->RunFullCollection(syncIndex);
+      break;
+    }
+    default:
+      LOG(ERROR) << "[GC] Error task type: " << static_cast<uint32_t>(taskType) << " ignored!" << maple::endl;
+      break;
+  }
+  return true;
+}
+
+void TracingCollector::RunTaskLoop() {
+  LOG(ERROR) << "[GC] RunTaskLoop start" << maple::endl;
+  finishedGcIndex = ScheduleTaskBase::kSyncIndexStartValue;
+  gcTid.store(maple::GetTid(), std::memory_order_release);
+  taskQueue.Init();
+  taskQueue.LoopDrainTaskQueue(this);
+  LOG(INFO) << "[GC] GC thread exit!!!" << maple::endl;
+  NotifyGCFinished(ScheduleTaskBase::kIndexExit);
+}
+
+void TracingCollector::OnUnsuccessfulInvoke(GCReason reason) {
+  if (reason == kGCReasonHeu) {
+    return;
+  }
+  GCReasonConfig &cfg = reasonCfgs[reason];
+  if (!cfg.IsNonBlockingGC() && isGcTriggered.load(std::memory_order_seq_cst)) {
+    ScopedEnterSaferegion safeRegion;
+    WaitGCStopped();
+  }
+}
+
+void TracingCollector::InvokeGC(GCReason reason, bool unsafe) {
+  // check if trigger GC thread holds thread list lock and mutator list lock
+  if (maple::GCRootsVisitor::IsThreadListLockLockBySelf()) {
+    LOG(ERROR) << "[GC] thread list is locked by self, skip GC" << maple::endl;
+    return;
+  }
+  if (MutatorList::Instance().IsLockedBySelf()) {
+    LOG(ERROR) << "[GC] mutator list is locked by self, skip GC" << maple::endl;
+    return;
+  }
+
+  GCReasonConfig &cfg = reasonCfgs[reason];
+  if (cfg.ShouldIgnore()) {
+    OnUnsuccessfulInvoke(reason);
+  } else if (unsafe) {
+    RequestGCUnsafe(reason);
+  } else {
+    RequestGCAndWait(reason);
+  }
+
+  return;
+}
+
+void TracingCollector::RequestGCUnsafe(GCReason reason) {
+  // this function is to trigger gc from an unsafe context, e.g., while holding
+  // a lock, or while in the middle of an allocation
+  //
+  // the difference with the following function is that the reason must be
+  // non-blocking, and that we don't enter safe region:
+  // non-blocking because mutator must finish what it's doing (releasing lock
+  // or finishing the allocation);
+  // not entering safe region because it will cause deadlocks
+  __MRT_ASSERT(reasonCfgs[reason].IsNonBlockingGC(),
+               "trigger from unsafe context must not be blocked");
+  GCTask gcTask(ScheduleTaskBase::ScheduleTaskType::kScheduleTaskTypeInvokeGC, reason);
+  // we use async enqueue because this doesn't have locks, lowering the risk
+  // of timeouts when entering safe region due to thread scheduling
+  taskQueue.EnqueueAsync(gcTask);
+}
+
+void TracingCollector::RequestGCAndWait(GCReason reason) {
+  // Enter saferegion since current thread may blocked by locks.
+  ScopedEnterSaferegion enterSaferegion;
+  GCTask gcTask(ScheduleTaskBase::ScheduleTaskType::kScheduleTaskTypeInvokeGC, reason);
+  uint64_t curThreadSyncIndex = 0;
+  TaskQueue<GCTask>::TaskFilter filter = [](GCTask &oldTask, GCTask &newTask) {
+    return oldTask.GetGCReason() == newTask.GetGCReason();
+  };
+
+  // adjust task order/priority by sync mode
+  GCReasonConfig &cfg = reasonCfgs[reason];
+  if (cfg.IsNonBlockingGC()) {
+    (void)taskQueue.Enqueue<false>(gcTask, filter);
+    return;
+  } else {
+    curThreadSyncIndex = taskQueue.Enqueue<true>(gcTask, filter);
+  }
+
+  // wait gc or not by sync mode
+  if (cfg.IsLiteBlockingGC()) {
+    WaitGCStoppedLite();
+    return;
+  }
+  std::unique_lock<std::mutex> lock(gcFinishedCondMutex);
+  // wait until GC finished
+  std::function<bool()> pred = [this, curThreadSyncIndex] {
+    return ((finishedGcIndex >= curThreadSyncIndex) || (finishedGcIndex == ScheduleTaskBase::kIndexExit));
+  };
+  {
+#ifdef __ANDROID__
+    MplCollieScope mcs(kGCCollie, (MPLCOLLIE_FLAG_ABORT | MPLCOLLIE_FLAG_PROMOTE_PRIORITY), gcTid.load());
+#endif
+    gcFinishedCondVar.wait(lock, pred);
+  }
+}
+
+void TracingCollector::NotifyGCFinished(uint64_t gcIndex) {
+  std::unique_lock<std::mutex> lock(gcFinishedCondMutex);
+  isGcTriggered.store(false, std::memory_order_relaxed);
+  if (gcIndex != ScheduleTaskBase::kAsyncIndex) { // sync gc, need set syncIndex
+    finishedGcIndex.store(gcIndex);
+  }
+  gcFinishedCondVar.notify_all();
+}
+
+void TracingCollector::WaitGCStoppedLite() {
+  std::unique_lock<std::mutex> lock(gcFinishedCondMutex);
+  std::chrono::milliseconds timeout(kDefaultWaitGCLiteTimeoutMs);
+  (void)gcFinishedCondVar.wait_for(lock, timeout);
+}
+
+void TracingCollector::WaitGCStopped() {
+  std::unique_lock<std::mutex> lock(gcFinishedCondMutex);
+  uint64_t curWaitGcIndex = finishedGcIndex.load();
+  std::function<bool()> pred = [this, curWaitGcIndex] {
+    return (!IsGcTriggered() || (curWaitGcIndex != finishedGcIndex) ||
+        (finishedGcIndex == ScheduleTaskBase::kIndexExit));
+  };
+  {
+#ifdef __ANDROID__
+    MplCollieScope mcs(kGCCollie, (MPLCOLLIE_FLAG_ABORT | MPLCOLLIE_FLAG_PROMOTE_PRIORITY), gcTid.load());
+#endif
+    gcFinishedCondVar.wait(lock, pred);
+  }
+}
+
+void TracingCollector::DumpHeap(const std::string &tag) {
+  pid_t pid = getpid();
+#ifdef __ANDROID__
+  std::string dirName = util::GetLogDir();
+  std::string filename = dirName + "/rc_heap_dump_" + tag + "_" +
+      std::to_string(pid) + "_" + timeutils::GetDigitDate() + ".txt";
+#else
+  std::string filename = "./rc_heap_dump_" + tag + "_" + std::to_string(pid) +
+      timeutils::GetDigitDate() + ".txt";
+#endif
+  std::ofstream ofs(filename, std::ofstream::out);
+  if (!ofs.is_open()) {
+    LOG(ERROR) << "racingCollector::DumpHeap open file failed" << maple::endl;
+    return;
+  }
+  InitTracing();
+
+  // dump roots
+  DumpRoots(ofs);
+  // dump object contents
+  bool ret = (*theAllocator).ForEachObj([&ofs](address_t obj) {
+    util::DumpObject(obj, ofs);
+  });
+  if (UNLIKELY(!ret)) {
+    LOG(ERROR) << "(*theAllocator).ForEachObj() in DumpHeap() return false." << maple::endl;
+  }
+
+  // dump object types
+  ofs << "Print Type information" << std::endl;
+  set<MClass*> classinfoSet;
+  ret = (*theAllocator).ForEachObj([&classinfoSet](address_t obj) {
+    MClass *classInfo = reinterpret_cast<MObject*>(obj)->GetClass();
+    // No need to check the result of insertion, because there're multiple-insertions.
+    (void)classinfoSet.insert(classInfo);
+  });
+  if (UNLIKELY(!ret)) {
+    LOG(ERROR) << "(*theAllocator).ForEachObj()#2 in DumpHeap() return false." << maple::endl;
+  }
+
+  for (auto it = classinfoSet.begin(); it != classinfoSet.end(); it++) {
+    MClass *classInfo = *it;
+    ofs << std::hex << classInfo << " " << classInfo->GetName() << std::endl;
+  }
+
+  ofs << "Dump Allocator" << std::endl;
+  (*theAllocator).PrintPageFragment(ofs, "DumpHeap");
+  ofs.close();
+
+  EndTracing();
+  ResetBitmap();
+}
+
+void TracingCollector::InitTracing() {
+  ReferenceProcessor::Instance().InitSoftRefPolicy();
+  const char *oldStackScan = getenv("USE_OLD_STACK_SCAN");
+  doConservativeStackScan = VLOG_IS_ON(conservativestackscan) || (oldStackScan != nullptr);
+
+  // create bitmap for mark sweep
+  if (UNLIKELY(!markBitmap.Initialized())) {
+#if ALLOC_USE_FAST_PATH
+    FastAllocData::data.bm = &markBitmap;
+#endif
+    markBitmap.Initialize();
+    finalBitmap.Initialize();
+  } else {
+    markBitmap.ResetCurEnd();
+    finalBitmap.ResetCurEnd();
+  }
+
+  PostInitTracing();
+}
+
+void TracingCollector::EndTracing() {
+  PostEndTracing();
+}
+
+// Add to root set if it actually points to an object.  This does not mark the object.
+void TracingCollector::MaybeAddRoot(address_t data, RootSet &rootSet, bool useFastCheck) {
+  bool isValid = useFastCheck ? FastIsHeapObject(data) :
+                                ((*theAllocator).AccurateIsValidObjAddr(data)
+#if CONFIG_JSAN
+                                 && (JSANGetObjStatus(data) != kObjStatusQuarantined)
+#endif
+                                );
+  if (isValid) {
+    rootSet.push_back(data);
+  }
+}
+
+void TracingCollector::ParallelScanRoots(RootSet &rootSet, bool processWeak, bool rootString) {
+  MplThreadPool *threadPool = GetThreadPool();
+  const size_t threadCount = threadPool->GetMaxThreadNum() + 1;
+  RootSet rootSetsInstance[threadCount];
+  RootSet *rootSets = rootSetsInstance; // work_around the crash of clang parser
+
+  // task to scan external roots.
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, processWeak, rootSets](size_t workerID) {
+    ScanExternalRoots(rootSets[workerID], processWeak);
+  }));
+
+  // task to scan reference, allocator and classloader roots.
+  // those scan are very fast, so we combine them into one single task.
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, rootSets](size_t workerID) {
+    ScanReferenceRoots(rootSets[workerID]);
+    ScanAllocatorRoots(rootSets[workerID]);
+    ScanClassLoaderRoots(rootSets[workerID]);
+  }));
+
+  // task to scan static field roots.
+  threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, rootSets](size_t workerID) {
+    ScanStaticFieldRoots(rootSets[workerID]);
+  }));
+
+  // task to scan stack roots.
+  stackTaskIndex.store(0);
+  auto &mutatorList = MutatorList::Instance().List();
+  const size_t mutatorLen = mutatorList.size();
+  for (size_t t = 0; t < threadCount; ++t) {
+    threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, &mutatorList, &mutatorLen, rootSets](size_t workerID) {
+      RootSet &rs = rootSets[workerID];
+      while (true) {
+        size_t old = stackTaskIndex.fetch_add(1, std::memory_order_release);
+        if (old >= mutatorLen) {
+          break;
+        }
+        auto it = mutatorList.begin();
+        size_t nop = 0;
+        while (nop < old) {
+          ++it;
+          ++nop;
+        }
+        if (doConservativeStackScan) {
+          ScanStackRoots(**it, rs);
+        } else {
+          // for nearly-precise stack scanning
+          (*it)->VisitJavaStackRoots([&rs](address_t ref) {
+            // currently only scan & collect the local var
+            if (LIKELY((*theAllocator).AccurateIsValidObjAddr(ref))) {
+              rs.push_back(ref);
+            }
+          });
+        }
+        // both conservtive and accurate scan, need scan scoped local refs
+        (*it)->VisitNativeStackRoots([&rs](address_t &ref) {
+          if (LIKELY((*theAllocator).AccurateIsValidObjAddr(ref))) {
+            rs.push_back(ref);
+          }
+        });
+      }
+    }));
+  }
+
+  // task to scan string roots.
+  if (rootString) {
+    threadPool->AddTask(new (std::nothrow) MplLambdaTask([this, rootSets](size_t workerID) {
+      ScanStringRoots(rootSets[workerID]);
+    }));
+  }
+
+  PostParallelAddTask(processWeak);
+  threadPool->Start();
+  threadPool->WaitFinish(true);
+
+  for (size_t i = 0; i < threadCount; ++i) {
+    rootSet.insert(rootSet.end(), rootSets[i].begin(), rootSets[i].end());
+  }
+
+  LOG2FILE(kLogtypeGc) << "Total roots: " << rootSet.size() << '\n';
+  PostParallelScanRoots();
+}
+
+void TracingCollector::FastScanRoots(RootSet &rootSet, RootSet &inaccurateRoots,
+                                     bool processWeak, bool rootString) {
+  // fast scan stack roots.
+  const size_t totalStackSize = 0;
+  size_t oldSize = inaccurateRoots.size();
+  snapshotMutators.reserve(MutatorList::Instance().Size());
+  numMutatorToBeScan = static_cast<uint32_t>(MutatorList::Instance().Size());
+  for (Mutator *mutator : MutatorList::Instance().List()) {
+    mutator->SetScanState(Mutator::kNeedScan);
+    snapshotMutators.insert(mutator);
+    // both conservtive and accurate scan, need scan scoped local refs
+    mutator->VisitNativeStackRoots([this, &inaccurateRoots](address_t &ref) {
+      if (LIKELY(InHeapBoundry(ref))) {
+        inaccurateRoots.push_back(ref);
+      }
+    });
+  }
+
+  const size_t nStackRoots = inaccurateRoots.size() - oldSize;
+
+  // scan external roots.
+  oldSize = rootSet.size();
+  ScanExternalRoots(rootSet, processWeak);
+  const size_t nExtRoots = rootSet.size() - oldSize;
+
+  // scan reference roots.
+  oldSize = rootSet.size();
+  ScanReferenceRoots(rootSet);
+  const size_t nRefRoots = rootSet.size() - oldSize;
+
+  // scan allocator roots.
+  oldSize = rootSet.size();
+  ScanAllocatorRoots(rootSet);
+  const size_t nAllocRoots = rootSet.size() - oldSize;
+
+  // scan class loader roots.
+  oldSize = rootSet.size();
+  ScanClassLoaderRoots(rootSet);
+  const size_t nClassloaderRoots = rootSet.size() - oldSize;
+
+  LOG2FILE(kLogtypeGc) <<
+      "  mutator: " << MutatorList::Instance().Size() << '\n' <<
+      "  stack slots: " << nStackRoots << '/' << (totalStackSize / sizeof(reffield_t)) << '\n' <<
+      "  ext roots: " << nExtRoots << '\n' <<
+      "  ref roots: " << nRefRoots << '\n' <<
+      "  alloc roots: " << nAllocRoots << '\n' <<
+      "  cl roots: " << nClassloaderRoots << '\n';
+
+  // scan string roots, disabled by default.
+  if (UNLIKELY(rootString)) {
+    oldSize = rootSet.size();
+    ScanStringRoots(rootSet);
+    const size_t nStringRoots = rootSet.size() - oldSize;
+    LOG2FILE(kLogtypeGc) << "  string roots: " << nStringRoots << '\n';
+  }
+}
+
+void TracingCollector::PrepareRootSet(RootSet &rootSet, RootSet &&inaccurateRoots) {
+  for (address_t addr : inaccurateRoots) {
+    if ((*theAllocator).AccurateIsValidObjAddrConcurrent(addr)) {
+      rootSet.push_back(addr);
+    }
+  }
+}
+
+ATTR_NO_SANITIZE_ADDRESS
+void TracingCollector::ScanStackRoots(Mutator &mutator, RootSet &rootSet) {
+  mutator.VisitStackSlotsContent(
+      [this, &rootSet](address_t ref) {
+        MaybeAddRoot(ref, rootSet);
+      }
+  );
+  mutator.VisitJavaStackRoots([&rootSet](address_t ref) {
+    // currently only scan & collect the local var
+    if (LIKELY((*theAllocator).AccurateIsValidObjAddr(ref))) {
+      rootSet.push_back(ref);
+    }
+  });
+}
+
+void TracingCollector::ScanAllStacks(RootSet &rootSet) {
+  // visit all mutators when the world is stopped.
+  MutatorList::Instance().VisitMutators([this, &rootSet](Mutator *mutator) {
+    ScanStackRoots(*mutator, rootSet);
+  });
+}
+
+void TracingCollector::ScanStaticFieldRoots(RootSet &rootSet) {
+  RefVisitor visitor = [this, &rootSet](address_t &obj) {
+    MaybeAddRoot(obj, rootSet, true);
+  };
+  GCRegisteredRoots::Instance().Visit(visitor);
+}
+
+void TracingCollector::ScanClassLoaderRoots(RootSet &rootSet) {
+  // Using MaybeAddRoot, because reference table may have meta object
+  RefVisitor addRootF = [&rootSet, this](const address_t &addr) {
+    MaybeAddRoot(addr, rootSet, true);
+  };
+  LoaderAPI::Instance().VisitGCRoots(addRootF);
+}
+
+void TracingCollector::ScanZterpStaticRoots(RootSet &rootSet) {
+  RefVisitor visitor = [this, &rootSet](address_t obj) {
+    MaybeAddRoot(obj, rootSet, true);
+  };
+  (*zterpStaticRootAllocator).VisitStaticRoots(visitor);
+}
+void TracingCollector::ScanReferenceRoots(RootSet &rs) const {
+  RefVisitor visitor = [&rs](address_t &obj) {
+    if (!IS_HEAP_OBJ(obj)) {
+      MRT_BuiltinAbortSaferegister(obj, nullptr);
+    }
+    rs.push_back(obj);
+  };
+  ReferenceProcessor::Instance().VisitGCRoots(visitor);
+}
+
+void TracingCollector::ScanExternalRoots(RootSet &rootSet, bool processWeak) {
+  // Using MaybeAddRoot, because reference table may have meta object
+  RefVisitor addRootF = [&rootSet, this](address_t &addr) {
+    MaybeAddRoot(addr, rootSet, true);
+  };
+  maple::GCRootsVisitor::Visit(addRootF);
+  if (!processWeak) {
+    maple::GCRootsVisitor::VisitWeakGRT(addRootF);
+  }
+}
+
+void TracingCollector::ScanWeakGlobalRoots(RootSet &rootSet) {
+  RefVisitor addRootF = [&rootSet, this](address_t &addr) {
+    MaybeAddRoot(addr, rootSet, true);
+  };
+  maple::GCRootsVisitor::VisitWeakGRT(addRootF);
+}
+
+void TracingCollector::ScanLocalRefRoots(RootSet &rootSet) {
+  // Using MaybeAddRoot, because reference table may have meta object
+  RefVisitor addRootF = [&rootSet, this](address_t &addr) {
+    MaybeAddRoot(addr, rootSet, true);
+  };
+  maple::GCRootsVisitor::VisitLocalRef(addRootF);
+}
+
+void TracingCollector::ScanGlobalRefRoots(RootSet &rootSet) {
+  // Using MaybeAddRoot, because reference table may have meta object
+  RefVisitor addRootF = [&rootSet, this](address_t &addr) {
+    MaybeAddRoot(addr, rootSet, true);
+  };
+  maple::GCRootsVisitor::VisitGlobalRef(addRootF);
+}
+
+void TracingCollector::ScanThreadExceptionRoots(RootSet &rootSet) {
+  // Using MaybeAddRoot, because reference table may have meta object
+  maple::rootObjectFunc addRootF = [&rootSet, this](address_t addr) {
+    MaybeAddRoot(addr, rootSet, true);
+  };
+  maple::GCRootsVisitor::VisitThreadException(addRootF);
+}
+
+void TracingCollector::ScanAllocatorRoots(RootSet &rootSet) {
+  // Using MaybeAddRoot, because reference table may have meta object
+  RefVisitor addRootF = [&rootSet, this](const address_t &addr) {
+    MaybeAddRoot(addr, rootSet, true);
+  };
+  (*theAllocator).VisitGCRoots(addRootF);
+}
+
+void TracingCollector::ScanStringRoots(RootSet &rootSet) {
+  RefVisitor visitor = [this, &rootSet](const address_t &addr) {
+    if (IS_HEAP_OBJ(addr)) {
+      AddRoot(addr, rootSet);
+    }
+  };
+  VisitStringPool(visitor);
+}
+
+void TracingCollector::DumpFinalizeGarbage() {
+  pid_t pid = getpid();
+#ifdef __ANDROID__
+  std::string dirName = util::GetLogDir();
+  std::string filename = dirName + "/final_garbage_" + std::to_string(pid) + "_" + timeutils::GetDigitDate() + ".txt";
+#else
+  std::string filename = "./rc_heap_dump_final_garbage_" + std::to_string(pid) +
+      "_" + timeutils::GetDigitDate() + ".txt";
+#endif
+  std::ofstream ofs(filename, std::ofstream::out);
+  if (!ofs.is_open()) {
+    LOG(ERROR) << "TracingCollector::DumpFinalizeGarbage open file failed" << maple::endl;
+    return;
+  }
+  bool tmpResult = (*theAllocator).ForEachObj([&ofs](address_t objAddr) {
+    if (IsUnmarkedResurrectable(objAddr)) {
+      MClass *classInfo = reinterpret_cast<MObject*>(objAddr)->GetClass();
+      ofs << "[final] " << std::hex << objAddr << std::dec << " " << RefCount(objAddr) << " " <<
+          namemangler::EncodeName(std::string(classInfo->GetName())) << std::endl;
+      util::DumpObject(objAddr, ofs);
+    }
+  });
+  if (UNLIKELY(!tmpResult)) {
+    LOG(ERROR) << "(*theAllocator).ForEachObj() in TracingCollector::DumpFinalizeGarbage() return false." <<
+        maple::endl;
+  }
+  ofs.close();
+}
+
+void TracingCollector::DumpWeakSoft() {
+  pid_t pid = getpid();
+#ifdef __ANDROID__
+  std::string dirName = util::GetLogDir();
+  std::string filename = dirName + "/softweak_" + std::to_string(pid) + "_" + timeutils::GetDigitDate() + ".txt";
+#else
+  std::string filename = "./rc_heap_dump_softweak_" + std::to_string(pid) + "_" + timeutils::GetDigitDate() + ".txt";
+#endif
+  std::ofstream ofs(filename, std::ofstream::out);
+  if (!ofs.is_open()) {
+    LOG(ERROR) << "TracingCollector::DumpWeakSoft open file failed" << maple::endl;
+    return;
+  }
+  MrtVisitReferenceRoots([this, &ofs](address_t reference) {
+    if (reference == 0) {
+      return;
+    }
+    address_t referent = ReferenceGetReferent(reference);
+    if (referent && InHeapBoundry(referent) && IsGarbage(referent)) {
+      MClass *classInfo = reinterpret_cast<MObject*>(referent)->GetClass();
+      ofs << "weak " << std::hex << referent <<  std::dec << " " <<
+          namemangler::EncodeName(std::string(classInfo->GetName())) << " " << RefCount(referent) << " " <<
+          WeakRefCount(referent) << " " << ResurrectWeakRefCount(referent) << std::endl;
+    }
+  }, RPMask(kRPWeakRef));
+  MrtVisitReferenceRoots([this, &ofs](address_t reference) {
+    if (reference == 0) {
+      return;
+    }
+    address_t referent = ReferenceGetReferent(reference);
+    if (referent && InHeapBoundry(referent) && IsGarbage(referent)) {
+      MClass *classInfo = reinterpret_cast<MObject*>(referent)->GetClass();
+      ofs << "soft " << std::hex << referent <<  std::dec << " " <<
+          namemangler::EncodeName(std::string(classInfo->GetName())) << " " << RefCount(referent) << " " <<
+          WeakRefCount(referent) << " " << ResurrectWeakRefCount(referent) << std::endl;
+    }
+  }, RPMask(kRPSoftRef));
+  maple::irtVisitFunc visitor = [this, &ofs](uint32_t index, address_t obj) {
+    if (InHeapBoundry(obj) && IsGarbage(obj)) {
+      MClass *classInfo = reinterpret_cast<MObject*>(obj)->GetClass();
+      ofs << "globalweak " << index << " " << std::hex << obj <<  std::dec << " " <<
+          namemangler::EncodeName(std::string(classInfo->GetName())) << " " << RefCount(obj) <<
+          " " << WeakRefCount(obj) << " " << ResurrectWeakRefCount(obj) << std::endl;
+    }
+  };
+  maple::GCRootsVisitor::VisitWeakGRT(visitor);
+  ofs.close();
+}
+
+void TracingCollector::DumpCleaner() {
+  pid_t pid = getpid();
+#ifdef __ANDROID__
+  std::string dirName = util::GetLogDir();
+  std::string filename = dirName + "/cleaner_" + std::to_string(pid) + "_" + timeutils::GetDigitDate() + ".txt";
+#else
+  std::string filename = "./rc_heap_dump_cleaner_" + std::to_string(pid) + "_" + timeutils::GetDigitDate() + ".txt";
+#endif
+  std::ofstream ofs(filename, std::ofstream::out);
+  if (!ofs.is_open()) {
+    LOG(ERROR) << "TracingCollector::DumpWeakSoft open file failed" << maple::endl;
+    return;
+  }
+  MrtVisitReferenceRoots([this, &ofs](address_t reference) {
+    if (reference == 0) {
+      return;
+    }
+    address_t referent = ReferenceGetReferent(reference);
+    if (referent && InHeapBoundry(referent) && IsGarbage(referent)) {
+      MClass *classInfo = reinterpret_cast<MObject*>(referent)->GetClass();
+      ofs << "cleaner and phantom refs " << std::hex << referent << std::dec <<
+          " " << namemangler::EncodeName(std::string(classInfo->GetName())) <<
+          " " << RefCount(referent) <<
+          " " << WeakRefCount(referent) <<
+          " " << ResurrectWeakRefCount(referent) <<
+          std::endl;
+    }
+  }, RPMask(kRPPhantomRef));
+  ofs.close();
+}
+
+void TracingCollector::DumpGarbage() {
+  pid_t pid = getpid();
+#ifdef __ANDROID__
+  std::string dirName = util::GetLogDir();
+  std::string filename = dirName + "/garbage_" + std::to_string(pid) + "_" + timeutils::GetDigitDate() + ".txt";
+#else
+  std::string filename = "./rc_heap_dump_garbage_" + std::to_string(pid) + "_" + timeutils::GetDigitDate() + ".txt";
+#endif
+  std::ofstream ofs(filename, std::ofstream::out);
+  if (!ofs.is_open()) {
+    LOG(ERROR) << "TracingCollector::DumpGarbage open file failed" << maple::endl;
+    return;
+  }
+  std::map<MClass*, std::string> metaToSoNameMap;
+  bool tmpResult = (*theAllocator).ForEachObj([&ofs, &metaToSoNameMap, this](address_t objAddr) {
+    if (IsGarbage(objAddr)) {
+      MObject *obj = reinterpret_cast<MObject*>(objAddr);
+      MClass *cls = obj->GetClass();
+      if (metaToSoNameMap.find(cls) == metaToSoNameMap.end()) {
+        metaToSoNameMap[cls] = GetSoNameFromCls(cls);
+      }
+      ofs << "[garbage] " << std::hex << objAddr << " " << reinterpret_cast<address_t>(cls) << std::dec << " " <<
+          RefCount(objAddr) << " " <<
+          namemangler::EncodeName(std::string(cls->GetName())) << " " <<
+          obj->GetSize() << std::endl;
+      // dump ref child
+      auto refFunc = [objAddr, &ofs, this](const reffield_t &field, uint64_t kind) {
+        address_t ref = RefFieldToAddress(field);
+        if (IS_HEAP_ADDR(ref) && IsGarbage(ref)) {
+          ofs << (reinterpret_cast<address_t>(&field) - objAddr) << " " << std::hex << ref <<
+              (kind == kWeakRefBits ? " w" : (kind == kUnownedRefBits ? " u" : "")) <<
+              std::dec << std::endl;
+        }
+      };
+      ForEachRefField(objAddr, refFunc);
+      ofs << std::endl;
+    }
+  });
+
+  for (auto &entry : metaToSoNameMap) {
+    ofs << "[class] " << std::hex << reinterpret_cast<address_t>(entry.first) << " " << entry.second << std::endl;
+  }
+  if (UNLIKELY(!tmpResult)) {
+    LOG(ERROR) << "(*theAllocator).ForEachObj() in TracingCollector::DumpGarbage() return false." << maple::endl;
+  }
+  ofs.close();
+}
+
+ATTR_NO_SANITIZE_ADDRESS
+void TracingCollector::DumpRoots(std::ofstream &ofs) {
+  maple::rootObjectFunc maybePrintRootsF = [this, &ofs] (address_t rootObj) {
+    if (rootObj == 0) {
+      return;
+    }
+    if (VLOG_IS_ON(dumpheapsimple)) {
+      if (FastIsHeapObject(rootObj)) {
+        ofs << std::hex << rootObj <<
+            " F " << FastIsHeapObject(rootObj) <<
+            " A " << (*theAllocator).AccurateIsValidObjAddr(rootObj) <<
+            std::hex << std::endl;
+      }
+    } else {
+      ofs << std::hex << rootObj <<
+          " Fast Check " << FastIsHeapObject(rootObj) <<
+          " Accurate Check " << (*theAllocator).AccurateIsValidObjAddr(rootObj) <<
+          std::hex << std::endl;
+    }
+  };
+  RefVisitor mayPrintVisitor = [&](const address_t &obj) {
+    maybePrintRootsF(obj);
+  };
+
+  ofs << "Thread stack roots" << std::endl;
+  MutatorList::Instance().VisitMutators([&maybePrintRootsF](Mutator *mutator) {
+    // do conservative stack scanning for the mutator.
+    mutator->VisitStackSlotsContent(maybePrintRootsF);
+  });
+
+  ofs << "static field roots" << std::endl;
+  VisitStaticFieldRoots(maybePrintRootsF);
+
+  ofs << "allocator roots" << std::endl;
+  VisitAllocatorRoots(mayPrintVisitor);
+
+  ofs << "string table roots" << std::endl;
+  VisitStringRoots(mayPrintVisitor);
+
+  ofs << "reference processor roots" << std::endl;
+  VisitReferenceRoots(maybePrintRootsF);
+
+  ofs << "GCRoots in threads/pending exception" << std::endl;
+  maple::GCRootsVisitor::VisitThreadException(maybePrintRootsF);
+
+  ofs << "GCRoots in local reference table" << std::endl;
+  maple::GCRootsVisitor::VisitLocalRef(mayPrintVisitor);
+
+  ofs << "GCRoots in global reference table" << std::endl;
+  maple::GCRootsVisitor::VisitGlobalRef(mayPrintVisitor);
+
+  // visit weak roots
+  ofs << "GCRoots in weak global" << std::endl;
+  maple::irtVisitFunc weakFunc = [&maybePrintRootsF](uint32_t, address_t obj) { maybePrintRootsF(obj); };
+  maple::GCRootsVisitor::VisitWeakGRT(weakFunc);
+
+  ofs << "GCRoots in classloader" << std::endl;
+  LoaderAPI::Instance().VisitGCRoots(mayPrintVisitor);
+  ofs << "GCRoots end" << std::endl;
+}
+
+void TracingCollector::VisitStaticFieldRoots(const maple::rootObjectFunc &func) {
+  RefVisitor visitor = [&func] (address_t obj) {
+    // final static fields of java.lang.String type may actually contain
+    // pointers to utf16-encoded raw strings.  As we now allocate our heap at
+    // low addresses, some string patterns may be interpreted as addresses into
+    // the heap.
+    //
+    // We now add an "AccurateIsValidObjAddr" call to workaround this problem.
+    // This basically make static roots conservative.  Please fix the issue and
+    // remove AccurateIsValidObjAddr check.
+    if (obj != 0 && IS_HEAP_OBJ(obj)) {
+      func(obj);
+    }
+  };
+  GCRegisteredRoots::Instance().Visit(visitor);
+}
+
+void TracingCollector::VisitAllocatorRoots(const RefVisitor &func) const {
+  (*theAllocator).VisitGCRoots(func);
+}
+
+void TracingCollector::VisitStringRoots(const RefVisitor &func) const {
+  VisitStringPool(func);
+}
+
+void TracingCollector::VisitReferenceRoots(const maple::rootObjectFunc &func) const {
+  MrtVisitReferenceRoots(func, kRPAllFlags);
+}
+
+int32_t TracingCollector::GetThreadCount(bool isConcurrent) {
+  if (GetThreadPool() == nullptr) {
+    return 1;
+  }
+  if (isConcurrent) {
+    return concurrentThreadCount;
+  }
+  if ((!IsSystem()) && Collector::Instance().InJankImperceptibleProcessState()) {
+    // allow STW, later
+    __MRT_ASSERT(parallelThreadCount >= 2, "invalid parallelThreadCount");
+    LOG(INFO) << "GetThreadCount in InJankImperceptibleProcessState ";
+    return 2;
+  } else {
+    return parallelThreadCount;
+  }
+}
+
+void TracingCollector::DefaultGCFinishCallback() {
+#if __MRT_DEBUG
+  std::stringstream ss;
+  (*permAllocator).Dump(ss);
+  (*metaAllocator).Dump(ss);
+  (*decoupleAllocator).Dump(ss);
+  LOG2FILE(kLogtypeGc) << ss.str();
+#endif
+}
+
+void TracingCollector::ObjectArrayCopy(address_t javaSrc, address_t javaDst, int32_t srcPos,
+                                       int32_t dstPos, int32_t length, bool check) {
+  size_t elemSize = sizeof(reffield_t);
+  char *srcCarray = reinterpret_cast<char*>(reinterpret_cast<MArray*>(javaSrc)->ConvertToCArray());
+  char *dstCarray = reinterpret_cast<char*>(reinterpret_cast<MArray*>(javaDst)->ConvertToCArray());
+  reffield_t *src = reinterpret_cast<reffield_t*>(srcCarray + elemSize * srcPos);
+  reffield_t *dst = reinterpret_cast<reffield_t*>(dstCarray + elemSize * dstPos);
+
+  TLMutator().SatbWriteBarrier<false>(javaDst);
+
+  if ((javaSrc == javaDst) && (abs(srcPos - dstPos) < length)) {
+    // most of the copy here are for small length. inline it here
+    // assumption: length > 0; aligned to 8bytes
+    if (length < kLargArraySize) {
+      if (srcPos > dstPos) { // copy to front
+        for (int32_t i = 0; i < length; ++i) {
+          dst[i] = src[i];
+        }
+      } else { // copy to back
+        for (int32_t i = length - 1; i >= 0; --i) {
+          dst[i] = src[i];
+        }
+      }
+    } else {
+      if (memmove_s(dst, elemSize * length, src, elemSize * length) != EOK) {
+        LOG(FATAL) << "Function memmove_s() failed." <<maple::endl;
+      }
+    }
+  } else {
+    if (!check) {
+      if (memcpy_s(dst, elemSize * length, src, elemSize * length) != EOK) {
+        LOG(ERROR) << "Function memcpy_s() failed." << maple::endl;
+      }
+    } else {
+      MClass *dstClass = reinterpret_cast<MArray*>(javaDst)->GetClass();
+      MClass *dstComponentType = dstClass->GetComponentClass();
+      MClass *lastAssignableComponentType = dstComponentType;
+      for (int32_t i = 0; i < length; ++i) {
+        reffield_t srcelem = src[i];
+        MObject *srcComponent = reinterpret_cast<MObject*>(RefFieldToAddress(srcelem));
+        if (AssignableCheckingObjectCopy(*dstComponentType, lastAssignableComponentType, srcComponent)) {
+          dst[i] = srcelem;
+        } else {
+          ThrowArrayStoreException(*srcComponent, i, *dstComponentType);
+          return;
+        }
+      }
+    }
+  }
+}
+
+void TracingCollector::PostObjectClone(address_t src, address_t dst) {
+  // nothing to do for tracing collector
+  (void)src;
+  (void)dst;
+}
+
+bool TracingCollector::UnsafeCompareAndSwapObject(address_t obj, ssize_t offset,
+                                                  address_t expectedValue, address_t newValue) {
+  JSAN_CHECK_OBJ(obj);
+  TLMutator().SatbWriteBarrier(obj, *reinterpret_cast<reffield_t*>(obj + offset));
+  reffield_t expectedRef = AddressToRefField(expectedValue);
+  reffield_t newRef = AddressToRefField(newValue);
+  auto atomicField = reinterpret_cast<std::atomic<reffield_t>*>(obj + offset);
+  return atomicField->compare_exchange_strong(expectedRef, newRef, std::memory_order_seq_cst);
+}
+
+address_t TracingCollector::UnsafeGetObjectVolatile(address_t obj, ssize_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  auto atomicField = reinterpret_cast<std::atomic<reffield_t>*>(obj + offset);
+  return atomicField->load(std::memory_order_acquire);
+}
+
+address_t TracingCollector::UnsafeGetObject(address_t obj, ssize_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return LoadRefField(obj, offset);
+}
+
+void TracingCollector::UnsafePutObject(address_t obj, ssize_t offset, address_t newValue) {
+  JSAN_CHECK_OBJ(obj);
+  TLMutator().SatbWriteBarrier(obj, *reinterpret_cast<reffield_t*>(obj + offset));
+  StoreRefField(obj, offset, newValue);
+}
+
+void TracingCollector::UnsafePutObjectVolatile(address_t obj, ssize_t offset, address_t newValue) {
+  JSAN_CHECK_OBJ(obj);
+  TLMutator().SatbWriteBarrier(obj, *reinterpret_cast<reffield_t*>(obj + offset));
+  auto atomicField = reinterpret_cast<std::atomic<reffield_t>*>(obj + offset);
+  atomicField->store(static_cast<reffield_t>(newValue), std::memory_order_release);
+}
+
+void TracingCollector::UnsafePutObjectOrdered(address_t obj, ssize_t offset, address_t newValue) {
+  JSAN_CHECK_OBJ(obj);
+  UnsafePutObjectVolatile(obj, offset, newValue);
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collector/conn_comp.cpp b/src/mrt/compiler-rt/src/collector/conn_comp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6f22bfb75d84df03d1ec756f4591f79c18fee24a
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/conn_comp.cpp
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/conn_comp.h"
+
+#include <cstdio>
+#include <cstdint>
+#include <cinttypes>
+
+#include "mm_config.h"
+#include "mm_utils.h"
+#include "chosen.h"
+#include "collector/cp_generator.h"
+
+namespace maplert {
+// default find scc run in milliseconds
+const int kDefaultFindSccTime = 200000;
+const int kInitalGarbageCount = 100000;
+const uint32_t kActionEnter = 0;
+const uint32_t kActionExit = 1;
+bool inline IsInHeapObject(address_t obj) {
+  return IS_HEAP_ADDR(static_cast<uintptr_t>(obj));
+}
+uint32_t inline GetAction(reffield_t ref) {
+  return ref & kActionExit;
+}
+reffield_t inline GetNodeAddr(reffield_t ref) {
+  return ref & ~kActionExit;
+}
+
+void ConnectedComponentFinder::ProcessActionEnter(vector<reffield_t> &workingList,
+    unordered_map<reffield_t, NodeInfo> &nodeInfoMap, uint32_t &curSeqNum, address_t node) {
+  NodeInfo &curNodeInfo = nodeInfoMap[static_cast<reffield_t>(node)];
+  if (curNodeInfo.seqNum == 0) { // Newly visited.
+    InitNode(curNodeInfo, curSeqNum);
+    PushCandidate(node);
+    workingList.push_back(static_cast<reffield_t>(node | kActionExit));
+
+    auto refFunc = [node, &workingList, &nodeInfoMap](reffield_t &field, uint64_t kind) {
+      address_t ref = RefFieldToAddress(field);
+      if ((kind != kNormalRefBits) || (ref == node) || !IS_HEAP_ADDR(ref)) {
+        return;
+      }
+      if ((nodeInfoMap.find(field) != nodeInfoMap.end()) &&
+          (nodeInfoMap[field].seqNum == 0)) {
+        workingList.push_back(ref);
+      }
+    };
+    ForEachRefField(node, refFunc);
+  } // Otherwise ignore, because already visited.
+}
+
+void ConnectedComponentFinder::ProcessActionExit(unordered_map<reffield_t, NodeInfo> &nodeInfoMap, address_t node,
+    CyclePatternGenerator &cpg) {
+  NodeInfo &curNodeInfo = nodeInfoMap[static_cast<reffield_t>(node)];
+  uint32_t lowestLink = curNodeInfo.lowLink;
+  auto refFunc = [this, &lowestLink, node, &nodeInfoMap](reffield_t &field, uint64_t kind) {
+    address_t ref = RefFieldToAddress(field);
+    if ((kind == kNormalRefBits) && (ref != node) && IsCandidate(ref)) {
+      uint32_t neighborLowLink = nodeInfoMap[static_cast<reffield_t>(ref)].lowLink;
+      lowestLink = min(lowestLink, neighborLowLink);
+    }
+  };
+  ForEachRefField(node, refFunc);
+  curNodeInfo.lowLink = lowestLink;
+
+  uint32_t mySeqNum = curNodeInfo.seqNum;
+  if (lowestLink == mySeqNum) {
+    if (candidateStack.back() == node) {
+      (void)PopCandidate();
+    } else {
+      // last poped and no duplicate type can be root in CycleGarbage
+      static vector<address_t> foundComponent;
+      address_t componentNode;
+      bool skip = false;
+      do {
+        componentNode = PopCandidate();
+        if (!skip) {
+          foundComponent.push_back(componentNode);
+          bool collectAll = kMergeAllPatterns || (ClassCycleManager::GetPatternsCache().length() == 0);
+          if ((LIKELY(!collectAll)) && (foundComponent.size() > kCyclepPatternMaxNodeNum)) {
+            skip = true;
+          }
+        }
+      } while (componentNode != node);
+      if ((!skip) && foundComponent.size() > 1) {
+        cpg.CollectCycleGarbage(foundComponent);
+      }
+      foundComponent.clear();
+    }
+  }
+}
+
+// Different with cycle leak check on qemu
+// 1. faster speed, save intermedidate copy and setup
+// Maybe combined later
+//
+// In worklist, LSB 1 means Exit
+// Skip enter already visisted object
+void ConnectedComponentFinder::RunInBackupTrace(TracingCollector &collector, CyclePatternGenerator &cpg) {
+  vector<reffield_t> workingList;
+  unordered_map<reffield_t, NodeInfo> nodeInfoMap;
+  workingList.reserve(kInitalGarbageCount);
+  bool collectAll = kMergeAllPatterns || (ClassCycleManager::GetPatternsCache().length() == 0);
+  // skip complex pattern
+  // when collect garbages:
+  // 1. skip object rc > cycle_pattern_node_max
+  // when finding SCC
+  // 2. skip scc node number > cycle_pattern_node_max
+  // bool skip_complex_pattern = (ClassCycleManager::GetPatternsCache().length() != 0)
+  //
+  // if kMergeAllPatterns is true, no limit on processing time 200ms
+  {
+    MRT_PHASE_TIMER("DumpCycleLeak: collect garbage nodes");
+    (void)(*theAllocator).ForEachObj(
+        [&collector, &workingList, &nodeInfoMap, collectAll](address_t objaddr) {
+          if ((HasChildRef(objaddr)) && (RefCount(objaddr) > 0) && (collector.IsGarbage(objaddr))) {
+            if (UNLIKELY(collectAll) || RefCount(objaddr) <= kMaxRcInCyclePattern) {
+              workingList.push_back(static_cast<reffield_t>(objaddr));
+              nodeInfoMap[static_cast<reffield_t>(objaddr)] = NewNode();
+            }
+          }
+        }
+    );
+    LOG2FILE(kLogtypeCycle) << "garbage objects count " << workingList.size() << std::endl;
+  }
+
+  {
+    MRT_PHASE_TIMER("DumpCycleLeak: Find CycleGarbage");
+    uint64_t startTime = timeutils::NanoSeconds();
+    uint32_t curSeqNum = 1;
+    while (!workingList.empty()) {
+      reffield_t curRef = workingList.back();
+      workingList.pop_back();
+      uint32_t action = GetAction(curRef);
+      address_t node = static_cast<address_t>(GetNodeAddr(curRef));
+      if (action == kActionEnter) {
+        ProcessActionEnter(workingList, nodeInfoMap, curSeqNum, node);
+      } else { // action is kExit
+        ProcessActionExit(nodeInfoMap, node, cpg);
+      }
+    }
+    if (LIKELY(!collectAll)) {
+      uint64_t endTime = timeutils::NanoSeconds();
+      uint64_t costTime = (endTime - startTime) / 1000UL; // 1nanoSeconds = 1000milliseconds
+      if (costTime > kDefaultFindSccTime) {
+        return;
+      }
+    }
+  }
+}
+
+void ConnectedComponentFinder::ProcessEnterAction(Node node) {
+  LOG2FILE(kLogTypeMix) << "Visiting node " << node << ", action: kEnter" << std::endl;
+  if (!IsVisited(node)) { // Newly visited.
+    InitializeNodeInfo(node); // Mark as visited
+    PushCandidate(node);
+
+    workList.push_back(WorkItem(kExit, node));
+
+    vector<Node> neighbors = nnf(node);
+    for (auto it = neighbors.rbegin(); it != neighbors.rend(); ++it) {
+      if (rootsOnly && !IsRoot(*it)) {
+        continue;
+      }
+      workList.push_back(WorkItem(kEnter, *it));
+    }
+  } // Otherwise ignore, because already visited.
+}
+
+void ConnectedComponentFinder::ProcessExitAction(Node node) {
+  LOG2FILE(kLogTypeMix) << "Visiting node " << node << ", action: kExit" << std::endl;
+  NodeInfoInClass &myInfo = nodeToInfo[node];
+  SeqNum lowestLink = myInfo.lowLink;
+
+  vector<Node> neighbors = nnf(node);
+  for (auto neighbor : neighbors) {
+    if (rootsOnly && !IsRoot(neighbor)) {
+      continue;
+    }
+    if (IsCandidate(neighbor)) {
+      SeqNum neighborLowLink = nodeToInfo[neighbor].lowLink;
+      lowestLink = min(lowestLink, neighborLowLink);
+    }
+  }
+
+  myInfo.lowLink = lowestLink;
+
+  SeqNum mySeqNum = myInfo.seqNum;
+  if (lowestLink == mySeqNum) {
+    LOG2FILE(kLogTypeMix) << "  Creating new component from " << node << " " << mySeqNum << std::endl;
+    vector<Node> myComponent;
+
+    Node componentNode;
+    do {
+      componentNode = PopCandidate();
+      myComponent.push_back(componentNode);
+    } while (componentNode != node);
+
+    results.push_back(move(myComponent));
+  }
+}
+
+void ConnectedComponentFinder::Run() {
+  // Initialize work list.
+  for (auto it = roots.rbegin(); it != roots.rend(); ++it) {
+    if (UNLIKELY(!rootsSet.insert(*it).second)) {
+      LOG(ERROR) << "rootsSet.insert() in ConnectedComponentFinder::Run() failed." << maple::endl;
+    }
+    workList.push_back(WorkItem(kEnter, *it));
+  }
+
+  while (!workList.empty()) {
+    WorkItem item = workList.back();
+    workList.pop_back();
+
+    Action action = item.first;
+    Node node = item.second;
+
+    if (action == kEnter) {
+      ProcessEnterAction(node);
+    } else { // action is kExit
+      ProcessExitAction(node);
+    }
+  }
+}
+
+void ConnectedComponentFinder::InitializeNodeInfo(Node node) {
+  SeqNum mySeqNum = nextSeqNum;
+  ++nextSeqNum;
+
+  LOG2FILE(kLogTypeMix) << "seqNum[" << node << "] = " << mySeqNum << std::endl;
+
+  nodeToInfo[node] = NodeInfoInClass {
+    .seqNum = mySeqNum,
+    .lowLink = mySeqNum,
+  };
+}
+
+void ConnectedComponentFinder::PushCandidate(Node node) {
+  candidateStack.push_back(node);
+  if (UNLIKELY(!candidateSet.insert(node).second)) {
+    LOG(ERROR) << "candidateSet.insert() in ConnectedComponentFinder::PushCandidate() failed." << maple::endl;
+  }
+}
+
+ConnectedComponentFinder::Node ConnectedComponentFinder::PopCandidate() {
+  if (!candidateStack.empty()) {
+    Node node = candidateStack.back();
+    candidateStack.pop_back();
+    candidateSet.erase(node);
+    return node;
+  }
+  return static_cast<Node>(0);
+}
+} // namespace
diff --git a/src/mrt/compiler-rt/src/collector/cp_generator.cpp b/src/mrt/compiler-rt/src/collector/cp_generator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d706bef6228a75254d29c18246dfd9944037b15c
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/cp_generator.cpp
@@ -0,0 +1,1228 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/cp_generator.h"
+
+#include "chosen.h"
+
+namespace maplert {
+namespace {
+const char *kSkipRootType[] = {
+    "array", "set;", "list;", "map;",
+    "map$", "hashtable", "collections"
+};
+}
+unordered_map<MClass*, PatternAgeFlags> ClassCycleManager::dynamicLoadedCycleClasses;
+string ClassCycleManager::patternsCache;
+mutex ClassCycleManager::cycleMutex;
+bool ClassCycleManager::cpUpdated = false;
+
+bool SortByObjMetaRC(address_t obj1, address_t obj2) {
+  uintptr_t classInfo1 = MObject::Cast<MObject>(obj1)->GetClass()->AsUintptr();
+  uintptr_t classInfo2 = MObject::Cast<MObject>(obj2)->GetClass()->AsUintptr();
+  if (classInfo1 != classInfo2) {
+    return classInfo1 < classInfo2;
+  }
+  uint32_t rc1 = RefCount(obj1);
+  uint32_t rc2 = RefCount(obj2);
+  return rc1 < rc2;
+}
+
+// Output format:
+// Class Name:soname
+// Cycle information
+// node1
+// node2
+// edge0
+// edge1
+// ..
+// edgen
+//
+// class: Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_241_3B:libmaplecore-all.so
+// Cycle: 2, 2, 1
+// Node: 0, 16, Lsun_2Fnio_2Fch_2FFileChannelImpl_3B:libmaplecore-all.so, 2
+// Node: 1, 80, Ljava_2Fio_2FRandomAccessFile_3B:libmaplecore-all.so, 1
+// Edge: 1, 0, 32
+// Edge: 2, 1, 16
+void CyclePattern::Print(ostream &os) {
+  os << "#SCC count " << count << std::endl;
+  os << "class: " << namemangler::EncodeName(std::string(MObject::Cast<MClass>(nodes[0].expectType)->GetName())) <<
+      ":" << GetSoNameFromCls(MObject::Cast<MClass>(nodes[0].expectType)) << std::endl;
+  os << "Cycle: " << (NumNodes() - 1) << ", " << NumEdges() << ", " << nodes[0].expectRc << std::endl;
+  for (int32_t i = 1; i < NumNodes(); ++i) {
+    os << "Node: " << nodes[i].loadIndex <<
+        ", " << nodes[i].loadOffset <<
+        ", " << namemangler::EncodeName(std::string(MObject::Cast<MClass>(nodes[i].expectType)->GetName())) <<
+        ":" << GetSoNameFromCls(MObject::Cast<MClass>(nodes[i].expectType)) <<
+        ", " << nodes[i].expectRc << std::endl;
+  }
+  for (int32_t i = 0; i < NumEdges(); ++i) {
+    os << "Edge: " << edges[i].srcNodeIndex << ", " <<
+        edges[i].destNodeIndex << ", " << edges[i].loadOffset << std::endl;
+  }
+  os << std::endl;
+}
+
+// Cycle Header:
+// NodeInfo
+// EdgeInfo
+void CyclePattern::Emit(char *buffer, size_t limit) {
+  if (UNLIKELY(!IsValid(false))) {
+    LOG(ERROR) << "Emit pattern failed, node has invalid rc" << maple::endl;
+    Print(LOG_STREAM(ERROR));
+    return;
+  }
+  if (UNLIKELY(headerInfo.expectRc != nodes[0].expectRc)) {
+    LOG(ERROR) << "Emit pattern failed, root's expectRc not equals header" << maple::endl;
+    return;
+  }
+  if (UNLIKELY(headerInfo.hasNextFlag != 0)) {
+    LOG(ERROR) << "Emit pattern failed, invalid next flag" << maple::endl;
+    return;
+  }
+  if (UNLIKELY(((reinterpret_cast<size_t>(reinterpret_cast<uintptr_t>(buffer))) & 0x7) != 0)) {
+    LOG(ERROR) << "Emit pattern failed, invalid buffer's address" << maple::endl;
+    return;
+  }
+  if (UNLIKELY(limit < kDWordBytes)) {
+    LOG(ERROR) << "Emit pattern failed, invalid buffer's size" << maple::endl;
+    return;
+  }
+  CyclePatternInfo *cyclePatternInfo = reinterpret_cast<CyclePatternInfo*>((buffer));
+  *cyclePatternInfo = headerInfo;
+  // subtract to match with current pattern
+  cyclePatternInfo->nNodes -= 1;
+  // cause of during constructing CyclePattern and clean stale cyclepattern
+  // use the match_counts, now need to reset
+  //
+  // Emit nodes, skip first one
+  char *curBuf = buffer + sizeof(CyclePatternInfo);
+  for (int32_t i = 1; i < NumNodes(); ++i) {
+    __MRT_ASSERT(static_cast<size_t>(curBuf - reinterpret_cast<char*>(buffer)) < limit, "invalid");
+    nodes[i].flags = 0;
+    *(reinterpret_cast<CyclePatternNodeInfo*>(curBuf)) = nodes[i];
+    curBuf += sizeof(CyclePatternNodeInfo);
+  }
+
+  // Emit edges
+  for (int32_t i = 0; i < NumEdges(); ++i) {
+    __MRT_ASSERT(static_cast<size_t>(curBuf - reinterpret_cast<char*>(buffer)) < limit, "invalid");
+    *(reinterpret_cast<CyclePatternEdgeInfo*>(curBuf)) = edges[i];
+    curBuf += sizeof(CyclePatternEdgeInfo);
+  }
+  __MRT_ASSERT(static_cast<size_t>(curBuf - reinterpret_cast<char*>(buffer)) <= limit, "invalid");
+  // the statistic of class's pattern has been updated
+  ClassCycleManager::SetCpUpdatedFlag();
+}
+
+void CyclePattern::ReindexNodesAndEdges(const CyclePattern &master, int8_t indexMap[], int32_t numTotalEdges,
+                                        const CyclePatternEdgeInfo edgesAll[], bool edgeUsed[]) {
+  int8_t currentNodeIndex = 1;
+  // search all nodes from startIndex with edgesAll
+  for (int32_t i = 0; i < NumNodes(); ++i) {
+    int8_t origSrcIndex = static_cast<int8_t>(nodes[i].flags);
+    if (origSrcIndex == -1) {
+      count = 0;
+      mergeCandiate = false;
+      return;
+    }
+    bool foundAll = false;
+    // search all edges from origSrcIndex
+    for (int32_t j = 0; j < numTotalEdges; ++j) {
+      if ((!edgeUsed[j]) && edgesAll[j].srcNodeIndex == origSrcIndex) {
+        int8_t origDestIndex = edgesAll[j].destNodeIndex;
+        if (indexMap[origDestIndex] == -1) {
+          // dest not added
+          indexMap[origDestIndex] = currentNodeIndex;
+          nodes[currentNodeIndex].expectType = master.nodes[origDestIndex].expectType;
+          nodes[currentNodeIndex].expectRc = master.nodes[origDestIndex].expectRc;
+          nodes[currentNodeIndex].loadIndex = i;
+          nodes[currentNodeIndex].loadOffset = edgesAll[j].loadOffset;
+          nodes[currentNodeIndex].flags = origDestIndex; // save index in master
+          edgeUsed[j] = true;
+          ++currentNodeIndex;
+          foundAll = (currentNodeIndex == NumNodes());
+        }
+      }
+    }
+    if (foundAll) {
+      break;
+    }
+  }
+
+  __MRT_ASSERT(currentNodeIndex == NumNodes(), "Invalid case");
+
+  // Setup other edges from new index and all edges
+  int32_t currentEdgeIndex = 0;
+  for (int32_t i = 0; i < numTotalEdges; ++i) {
+    if (edgeUsed[i]) {
+      continue;
+    }
+    edges[currentEdgeIndex].srcNodeIndex = indexMap[edgesAll[i].srcNodeIndex];
+    edges[currentEdgeIndex].destNodeIndex = indexMap[edgesAll[i].destNodeIndex];;
+    edges[currentEdgeIndex].loadOffset = edgesAll[i].loadOffset;
+    currentEdgeIndex++;
+  }
+  __MRT_ASSERT(currentEdgeIndex == NumEdges(), "Invalid case");
+}
+
+// Used when iterate all cycles from different root node.
+//
+// 1. Find all edges start from root_index
+// 2. Reindex nodes
+// 3. List all implicit/explicit edges
+// 4. Setup new cycle from new index and all edges
+CyclePattern::CyclePattern(CyclePattern &master, int32_t startIndex) : objAddrs {} {
+  __MRT_ASSERT(startIndex != 0, "invalid");
+  count = master.count;
+  headerInfo = master.headerInfo;
+  headerInfo.expectRc = master.nodes[startIndex].expectRc;
+  mergeCandiate = false;
+
+  // find all edges
+  int32_t numTotalEdges = NumNodes() + NumEdges() - 1;
+  CyclePatternEdgeInfo edgesAll[numTotalEdges];
+  bool edgeUsed[numTotalEdges];
+  for (int32_t i = 0; i < numTotalEdges; ++i) {
+    edgeUsed[i] = false;
+  }
+  for (int32_t i = 1; i < NumNodes(); ++i) {
+    edgesAll[i - 1].srcNodeIndex = master.nodes[i].loadIndex;
+    edgesAll[i - 1].destNodeIndex = i;
+    edgesAll[i - 1].loadOffset = master.nodes[i].loadOffset;
+  }
+  for (int32_t i = 0; i < NumEdges(); ++i) {
+    edgesAll[NumNodes() + i - 1] = master.edges[i];
+  }
+
+  // reindex from startIndex, mapping from index in master to new index
+  // creating nodes at same time
+  int8_t indexMap[NumNodes()];
+  for (int32_t i = 0; i < NumNodes(); ++i) {
+    indexMap[i] = -1;
+    nodes[0].flags = -1;
+  }
+  indexMap[startIndex] = 0;
+  nodes[0] = master.nodes[startIndex];
+  nodes[0].loadIndex = -1;
+  nodes[0].loadOffset = -1;
+  nodes[0].flags = startIndex; // save index in master
+  ReindexNodesAndEdges(master, indexMap, numTotalEdges, edgesAll, edgeUsed);
+}
+
+bool CyclePattern::FindEdge(int8_t srcIndex, int8_t destIndex, int16_t loadOffset) const {
+  __MRT_ASSERT(srcIndex >= 0 && srcIndex < NumNodes() && destIndex >= 0 && destIndex < NumNodes(), "unexpected");
+  if (destIndex != 0 &&
+      nodes[destIndex].loadIndex == srcIndex &&
+      nodes[destIndex].loadOffset == loadOffset) {
+    return true;
+  }
+  for (int32_t i = 0; i < NumEdges(); ++i) {
+    if (edges[i].srcNodeIndex == srcIndex &&
+        edges[i].destNodeIndex == destIndex &&
+        edges[i].loadOffset == loadOffset) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// exclude add pattern on collection and collection node
+// name contains Map, Set, List and their Node and Entry
+//
+// Use sub class check is not suitable, for example
+// Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_3B, 20, Ljava_2Flang_2FObject_3B
+// Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_3B, 16, Ljava_2Flang_2FObject_3B
+// Landroid_2Futil_2FArrayMap_3B, 28, Ljava_2Flang_2FObject_3B
+const size_t kSkipRootCount = sizeof(kSkipRootType) / sizeof(const char*);
+
+static inline bool IsCollectionType(const char *kClsName) {
+  for (size_t i = 0; i < kSkipRootCount; ++i) {
+    if (strcasestr(kClsName, kSkipRootType[i]) != nullptr) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool CyclePattern::IsSamePattern(int8_t index, CyclePatternInfo &cyclePatternInfo, size_t &origGctibByteSize) const {
+  // accumulate size
+  origGctibByteSize += GetCyclePatternSize(cyclePatternInfo);
+  // check node edge num
+  if (cyclePatternInfo.nNodes + 1 != NumNodes() || cyclePatternInfo.nEdges != NumEdges()) {
+    return false;
+  }
+  // check type and rc, setup indexMap
+  // mapping node index in GCTIB cycle pattern to its index in current CyclePattern
+  int8_t indexMap[NumNodes()];
+  for (int32_t i = 0; i < NumNodes(); ++i) {
+    indexMap[i] = -1;
+  }
+  indexMap[0] = index;
+  if (nodes[index].expectRc != cyclePatternInfo.expectRc) {
+    return false;
+  }
+  CyclePatternNodeInfo *curNodeInfo = GetCyclePatternNodeInfo(cyclePatternInfo);
+  // might need check same cls issue
+  for (int32_t i = 1; i < NumNodes(); ++i) {
+    void *curCls = curNodeInfo->expectType;
+    int32_t clsIdx = IndexofClass(curCls);
+    if (clsIdx == -1 || nodes[clsIdx].expectRc != curNodeInfo->expectRc) {
+      return false;
+    }
+    indexMap[i] = clsIdx;
+    curNodeInfo = reinterpret_cast<CyclePatternNodeInfo*>(
+        ((reinterpret_cast<char*>(curNodeInfo)) + sizeof(CyclePatternNodeInfo)));
+  }
+
+  // check edges, implicit edges in nodes, revisit GetNodeInfo agian
+  curNodeInfo = GetCyclePatternNodeInfo(cyclePatternInfo);
+  for (int32_t i = 1; i < NumNodes(); ++i) {
+    int8_t gctibLoadIndex = curNodeInfo->loadIndex;
+    int8_t loadIndex = indexMap[gctibLoadIndex];
+    int16_t loadOffset = curNodeInfo->loadOffset;
+    if (!FindEdge(loadIndex, indexMap[i], loadOffset)) {
+      return false;
+    }
+    curNodeInfo = reinterpret_cast<CyclePatternNodeInfo*>(
+      ((reinterpret_cast<char*>(curNodeInfo)) + sizeof(CyclePatternNodeInfo)));
+  }
+
+  // check explicit edges
+  CyclePatternEdgeInfo *curEdgeInfo = GetCyclePatternEdgeInfo(cyclePatternInfo);
+  for (int32_t i = 0; i < NumEdges(); ++i) {
+    int8_t gctibSrcIndex = curEdgeInfo->srcNodeIndex;
+    int8_t gctibDestIndex = curEdgeInfo->destNodeIndex;
+    int16_t loadOffset = curEdgeInfo->loadOffset;
+    int8_t srcIndex = indexMap[gctibSrcIndex];
+    int8_t destIndex = indexMap[gctibDestIndex];
+    if (!FindEdge(srcIndex, destIndex, loadOffset)) {
+      return false;
+    }
+    curEdgeInfo = reinterpret_cast<CyclePatternEdgeInfo*>(
+      ((reinterpret_cast<char*>(curEdgeInfo)) + sizeof(CyclePatternEdgeInfo)));
+  }
+  return true;
+}
+
+bool CyclePattern::AppendPattern(MClass *cls, int8_t index, size_t origGctibByteSize,
+                                 GCTibGCInfo *origGctibInfo, const CyclePatternInfo *lastCyclePattern) {
+  size_t newGctibByteSize = origGctibByteSize + EmitByteSize();
+  GCTibGCInfo *newGctibInfo = reinterpret_cast<GCTibGCInfo*>(malloc(newGctibByteSize));
+  if (newGctibInfo == nullptr) {
+    return false;
+  }
+  errno_t tmpResult = memcpy_s(reinterpret_cast<char*>(newGctibInfo), origGctibByteSize,
+                               reinterpret_cast<char*>(origGctibInfo), origGctibByteSize);
+  if (UNLIKELY(tmpResult != EOK)) {
+    LOG(ERROR) << "memcpy_s() in CyclePattern::FindAndAppendPattern() return " <<
+        tmpResult << " rather than 0." << maple::endl;
+    free(newGctibInfo);
+    return false;
+  }
+
+  // update header and next flag
+  uint32_t origHeaderProto = origGctibInfo->headerProto;
+  if ((origHeaderProto & kCyclePatternBit) != 0) {
+    int32_t origMaxRc = static_cast<int32_t>(CYCLE_MAX_RC(origHeaderProto));
+    int32_t origMinRc = static_cast<int32_t>(CYCLE_MIN_RC(origHeaderProto));
+    if (nodes[index].expectRc > origMaxRc) {
+      newGctibInfo->headerProto = SetCycleMaxRC(origHeaderProto, static_cast<uint32_t>(nodes[index].expectRc));
+    } else if (nodes[index].expectRc < origMinRc) {
+      newGctibInfo->headerProto = SetCycleMinRC(origHeaderProto, static_cast<uint32_t>(nodes[index].expectRc));
+    }
+
+    __MRT_ASSERT(lastCyclePattern != nullptr && lastCyclePattern->hasNextFlag == 0, "unexpected");
+    // set has next flag
+    uintptr_t lastCycleNextFlagOffset =
+        (const_cast<char*>(reinterpret_cast<const char*>(&(lastCyclePattern->hasNextFlag)))) -
+        reinterpret_cast<char*>(origGctibInfo);
+    *reinterpret_cast<int8_t*>((reinterpret_cast<char*>(newGctibInfo)) + lastCycleNextFlagOffset) = 1;
+  } else {
+    newGctibInfo->headerProto = SetCycleMaxRC(origHeaderProto, static_cast<uint32_t>(nodes[index].expectRc)) |
+                                SetCycleMinRC(origHeaderProto, static_cast<uint32_t>(nodes[index].expectRc)) |
+                                kCyclePatternBit;
+  }
+
+  // emit new cycle into buffer
+  if (index == 0) {
+    Emit((reinterpret_cast<char*>(newGctibInfo)) + origGctibByteSize, newGctibByteSize - origGctibByteSize);
+    Print(GCLog().Stream(kLogtypeCycle));
+  } else {
+    CyclePattern switchedPattern(*this, index);
+    switchedPattern.Emit((reinterpret_cast<char*>(newGctibInfo)) + origGctibByteSize,
+                         newGctibByteSize - origGctibByteSize);
+    switchedPattern.Print(GCLog().Stream(kLogtypeCycle));
+  }
+
+  // replace
+  cls->SetGctib(reinterpret_cast<uintptr_t>(newGctibInfo));
+  if (ClassCycleManager::HasDynamicLoadPattern(cls)) {
+    free(origGctibInfo);
+  } else {
+    ClassCycleManager::AddDynamicLoadPattern(cls, false);
+  }
+  return true;
+}
+
+// Iterate current cycles and check if need append new cycle
+// Append new cycle
+//
+// Check flow
+// 1. jclass has cycle patterns
+// 2. iterate each cycle in gctib
+//    2.1 check num_node and num_edge
+//    2.2 check node type and expect rc are same
+//    2.3 check if each edge is same
+//    if found same, log warning
+//
+// Append flow
+// 1. calcuate new gctib size, original size + current cycle size
+// 2. copy original content into new space
+// 3. update header: rc threshold, cyclePattern bit
+// 4. change last cycle's has next bit
+// 5. emit new cycle into remain buffers
+// 6. replace GCTIB with new GCTIB (if original GCTIB is dynamic linked, free)
+bool CyclePattern::FindAndAppendPattern(int8_t index) {
+  MClass *cls = MObject::Cast<MClass>(nodes[index].expectType);
+  GCTibGCInfo *origGctibInfo = reinterpret_cast<GCTibGCInfo*>(cls->GetGctib());
+  if (origGctibInfo == nullptr) {
+    return false;
+  }
+
+  // reduce the pattern install time
+  // 1. if the class' pattern duplicated value > 0, just skip
+  // 2. if the class' pattern duplicated value == 0, continue
+  if (LIKELY(!kMergeAllPatterns) && !ClassCycleManager::DynamicPatternTryMerge(cls)) {
+    return false;
+  }
+  if (cls->IsArrayClass()) {
+    LOG2FILE(kLogtypeCycle) << "Skip Object array " << cls->GetName() << std::endl;
+    return false;
+  }
+  const char *kClsName = cls->GetName();
+  if (IsCollectionType(kClsName)) {
+    LOG2FILE(kLogtypeCycle) << "Skip collection type " << kClsName << std::endl;
+    return false;
+  }
+
+  size_t origGctibByteSize = sizeof(GCTibGCInfo) + (origGctibInfo->nBitmapWords * kDWordBytes);
+  CyclePatternInfo *lastCyclePattern = nullptr;
+  int32_t numCycles = 0;
+  // find if pattern exist
+  if ((origGctibInfo->headerProto & kCyclePatternBit) != 0) {
+    CyclePatternInfo *cyclePatternInfo = GetCyclePatternInfo(*origGctibInfo);
+    for (; cyclePatternInfo != nullptr; cyclePatternInfo = GetNextCyclePattern(*cyclePatternInfo), numCycles++) {
+      lastCyclePattern = cyclePatternInfo;
+      if (!IsSamePattern(index, *cyclePatternInfo, origGctibByteSize)) {
+        continue;
+      }
+      // find same cycle pattern
+      ClassCycleManager::findDuplicate(cls);
+      LOG2FILE(kLogtypeCycle) << "Find duplicated pattern " <<
+          (cyclePatternInfo->invalidated == kCycleNotValid ? "invalid" : "valid") << std::endl;
+      Print(GCLog().Stream(kLogtypeCycle));
+      return false;
+    }
+  }
+
+  if (numCycles >= kCyclepMaxNum) {
+    GCLog().Stream() << "numCycles exceed limit for " << cls->GetName() << " " << numCycles << std::endl;
+    Print(GCLog().Stream());
+    return false;
+  }
+
+  if (!AppendPattern(cls, index, origGctibByteSize, origGctibInfo, lastCyclePattern)) {
+    return false;
+  }
+  LOG2FILE(kLogtypeCycle) << "Add pattern for class " <<
+      cls->GetName() << " cycle num " << (numCycles + 1) << std::endl;
+  return true;
+}
+
+void CyclePattern::Merge() {
+  for (int32_t i = 0; i < NumNodes(); ++i) {
+    (void)FindAndAppendPattern(i);
+  }
+  return;
+}
+
+// Perform two tasks here
+// 1. merge suitable cycle into runtine.(hot and fit size)
+// 2. log cycle pattern into big data cache if necessary
+void ClassCycleManager::MergeCycles(vector<CycleGarbage*> &cycles) {
+  CyclePattern pattern;
+  (void)memset_s(reinterpret_cast<char*>(&pattern), sizeof(CyclePattern), 0, sizeof(CyclePattern));
+  ostringstream oss;
+  streampos startPos = oss.tellp();
+
+  lock_guard<mutex> guard(cycleMutex);
+  bool needLogBigdata = (patternsCache.length() == 0);
+  for (CycleGarbage *cycle : cycles) {
+    if (cycle->ToCyclePattern(pattern) && pattern.NeedMerge()) {
+      pattern.Merge();
+    }
+    if (needLogBigdata) {
+      streampos curPos = oss.tellp();
+      if ((curPos - startPos) < kMaxBigDataCacheSize) {
+        cycle->AppendToString(oss);
+      }
+    }
+    (void)memset_s(reinterpret_cast<char*>(&pattern), sizeof(CyclePattern), 0, sizeof(CyclePattern));
+  }
+  if (needLogBigdata) {
+    patternsCache.append(oss.str());
+    LOG2FILE(kLogtypeCycle) << "pattern cache " << patternsCache << std::endl;
+  }
+}
+
+bool UpdateClassGCTibInfo(GCTibGCInfo *curGCTibInfo, uint32_t minRC, uint32_t maxRC,
+                          GCTibGCInfo *newGCTibInfo, size_t newGCTibSize) {
+  size_t origGCTibMapSize = sizeof(GCTibGCInfo) + (curGCTibInfo->nBitmapWords * kDWordBytes);
+  errno_t tmpResult = memcpy_s(reinterpret_cast<char*>(newGCTibInfo), origGCTibMapSize,
+                               reinterpret_cast<char*>(curGCTibInfo), origGCTibMapSize);
+  if (UNLIKELY(tmpResult != EOK)) {
+    LOG(ERROR) << "memcpy_s() in RemoveDeadPatterns return " << tmpResult << " rather than 0." << maple::endl;
+    free(newGCTibInfo);
+    return false;
+  }
+
+  // update new min/max match rc
+  uint32_t curHeaderProto = curGCTibInfo->headerProto;
+  __MRT_ASSERT(minRC >= 1 && maxRC <= kMaxRcInCyclePattern && minRC <= maxRC, "unepxected rc");
+  newGCTibInfo->headerProto = SetCycleMaxRC(curHeaderProto, maxRC) | SetCycleMinRC(curHeaderProto, minRC) |
+                              kCyclePatternBit;
+  // copy valid pattern into new space
+  CyclePatternInfo *cyclePatternInfo = GetCyclePatternInfo(*curGCTibInfo);
+  CyclePatternInfo *lastPatternInfo = nullptr;
+  char *curPos = (reinterpret_cast<char*>(newGCTibInfo)) + origGCTibMapSize;
+  bool copySuccess = true;
+  for (; cyclePatternInfo != nullptr; cyclePatternInfo = GetNextCyclePattern(*cyclePatternInfo)) {
+    if (cyclePatternInfo->invalidated == kCycleNotValid) {
+      continue;
+    }
+    size_t patternSize = GetCyclePatternSize(*cyclePatternInfo);
+    errno_t tmpResult1 = memcpy_s(curPos, patternSize, reinterpret_cast<char*>(cyclePatternInfo), patternSize);
+    if (UNLIKELY(tmpResult1 != EOK)) {
+      LOG(ERROR) << "memcpy_s() in RemoveDeadPatterns return " << tmpResult << " rather than 0." << maple::endl;
+      copySuccess = false;
+      break;
+    }
+    lastPatternInfo = reinterpret_cast<CyclePatternInfo*>(curPos);
+    curPos += patternSize;
+  }
+  if (!copySuccess) {
+    free(newGCTibInfo);
+    return false;
+  }
+  __MRT_ASSERT((lastPatternInfo != nullptr) &&
+      (static_cast<size_t>(curPos - reinterpret_cast<char*>(newGCTibInfo))) == newGCTibSize, "not equal");
+  lastPatternInfo->hasNextFlag = 0;
+  return true;
+}
+
+bool CheckAndUpdateClassPatterns(MClass *cls, GCTibGCInfo *curGCTibInfo,
+                                 uint32_t &validPatternCount, uint32_t &deadPatternCount) {
+  uint32_t minRC = kMaxRcInCyclePattern;
+  uint32_t maxRC = 0;
+  size_t newGCTibSize = sizeof(GCTibGCInfo) + (curGCTibInfo->nBitmapWords * kDWordBytes);
+  size_t origGCTibMapSize = newGCTibSize;
+
+  if ((curGCTibInfo->headerProto & kCyclePatternBit) != 0) {
+    CyclePatternInfo *cyclePatternInfo = GetCyclePatternInfo(*curGCTibInfo);
+    for (; cyclePatternInfo != nullptr; cyclePatternInfo = GetNextCyclePattern(*cyclePatternInfo)) {
+      if (cyclePatternInfo->invalidated == kCycleNotValid) {
+        ++deadPatternCount;
+        continue;
+      }
+      // calculate remaining size
+      ++validPatternCount;
+      newGCTibSize += GetCyclePatternSize(*cyclePatternInfo);
+
+      // calculate min/max rc
+      uint32_t expectRc = static_cast<uint32_t>(cyclePatternInfo->expectRc);
+      minRC = expectRc < minRC ? expectRc : minRC;
+      maxRC = expectRc > maxRC ? expectRc : maxRC;
+    }
+  }
+
+  // remove dead pattern and construct new gctib
+  if (validPatternCount == 0) {
+    LOG2FILE(kLogtypeCycle) << cls->GetName() << " Remove Dead Class " << std::endl;
+    GCTibGCInfo *newGCTibInfo = reinterpret_cast<GCTibGCInfo*>(malloc(newGCTibSize));
+    if (newGCTibInfo == nullptr) {
+      // leave unchanged
+      return false;
+    }
+    errno_t tmpResult = memcpy_s(reinterpret_cast<char*>(newGCTibInfo),
+                                 origGCTibMapSize, reinterpret_cast<char*>(curGCTibInfo), origGCTibMapSize);
+    if (UNLIKELY(tmpResult != EOK)) {
+      LOG(ERROR) << "memcpy_s() in RemoveDeadPatterns return " << tmpResult << " rather than 0." << maple::endl;
+      free(newGCTibInfo);
+      return false;
+    }
+    newGCTibInfo->headerProto = newGCTibInfo->headerProto & (~kCyclePatternBit);
+    // delete original gctib space
+    (reinterpret_cast<ClassMetadata*>(cls))->gctib.SetGctibRef(newGCTibInfo);
+    free(curGCTibInfo);
+  } else if (deadPatternCount > 0)  {
+    // remove dead patterns in valid class
+    LOG2FILE(kLogtypeCycle) << cls->GetName() << " Remove Dead Pattern " <<
+        deadPatternCount << " Remain Valid pattern " << validPatternCount << std::endl;
+    // copy bitmap and valid pattern to new space
+    GCTibGCInfo *newGCTibInfo = reinterpret_cast<GCTibGCInfo*>(malloc(newGCTibSize));
+    if (newGCTibInfo == nullptr) {
+      // leave unchanged
+      return false;
+    }
+    if (!UpdateClassGCTibInfo(curGCTibInfo, minRC, maxRC, newGCTibInfo, newGCTibSize)) {
+      return false;
+    }
+    __MRT_ASSERT(ClassCycleManager::CheckValidPattern(cls, reinterpret_cast<char*>(newGCTibInfo)), "verify fail");
+    // delete original gctib space
+    (reinterpret_cast<ClassMetadata*>(cls))->gctib.SetGctibRef(newGCTibInfo);
+    free(curGCTibInfo);
+  }
+  return true;
+}
+
+// Try remove dead patterns in dynamic loaded patterns
+// 1. iterate all cycle patterns, remove dead patterns
+// 2. remove class from dynamicLoadedCycleClasses, if no pattern exist
+//
+// Remove dead pattern before study
+void ClassCycleManager::RemoveDeadPatterns() {
+  lock_guard<mutex> guard(cycleMutex);
+  for (auto it = dynamicLoadedCycleClasses.begin(); it != dynamicLoadedCycleClasses.end();) {
+    MClass *cls = it->first;
+    GCTibGCInfo *curGCTibInfo = reinterpret_cast<GCTibGCInfo*>(cls->GetGctib());
+    if (curGCTibInfo == nullptr) {
+      LOG(FATAL) << "The class has no gctibInfo:" << cls->GetName() << maple::endl;
+      continue;
+    }
+    uint32_t validPatternCount = 0;
+    uint32_t deadPatternCount = 0;
+
+    if (!CheckAndUpdateClassPatterns(cls, curGCTibInfo, validPatternCount, deadPatternCount)) {
+      continue;
+    }
+
+    if (validPatternCount == 0) {
+      LOG2FILE(kLogtypeCycle) << cls->GetName() << " Remove No Pattern Class " << std::endl;
+      it = dynamicLoadedCycleClasses.erase(it);
+    } else {
+      ++it;
+    }
+
+    if (deadPatternCount > 0) {
+      ClassCycleManager::SetCpUpdatedFlag();
+    }
+  }
+}
+
+static string GetIndexOfSoName(vector<string> &soSet, const MClass *cls) {
+  string rawName = GetSoNameFromCls(cls);
+  size_t pos = 0;
+  auto iElement = find(soSet.begin(), soSet.end(), rawName);
+  if (iElement != soSet.end()) {
+    pos = static_cast<size_t>(distance(soSet.begin(), iElement));
+  } else {
+    soSet.push_back(rawName);
+    pos = soSet.size() - 1;
+  }
+  return to_string(pos);
+}
+
+static inline void DumpSOSet(std::ostream &os, bool dupThreshold, const vector<string> &soSet) {
+  if (dupThreshold) {
+    return;
+  }
+  os << "....." << std::endl;
+  uint32_t index = 0;
+  for (auto soName : soSet) {
+    os << index++ << ":" <<  soName << std::endl;
+  }
+}
+
+// class: Lsun_2Fnio_2Fcs_2FStreamDecoder_3B:libmaplecore-all.so
+// Header: ROOT, 1
+// Cycle: 1, 1, 1
+// Node: 0, 16, Ljava_2Fio_2FInputStreamReader_3B:libmaplecore-all.so, 1
+// Edge: 1, 0, 32
+static void DumpClassNameSo(std::ostream &os, const MClass *cls, vector<string> &soSet, bool dupThreshold) {
+  string soName = dupThreshold ? GetSoNameFromCls(cls) : GetIndexOfSoName(soSet, cls);
+  os << "class: " << namemangler::EncodeName(std::string(cls->GetName())) <<
+      ":" << soName << std::endl;
+}
+
+static void DumpCycleHeader(std::ostream &os, const CyclePatternInfo &cyclePatternInfo, bool dumpProfile) {
+  os << ((cyclePatternInfo.invalidated == kCyclePermernant) ? "C_P: " : "C: ") <<
+      static_cast<int32_t>(cyclePatternInfo.nNodes) << ", " <<
+      static_cast<int32_t>(cyclePatternInfo.nEdges) << ", " <<
+      static_cast<int32_t>(cyclePatternInfo.expectRc) << std::endl;
+  if (dumpProfile) {
+    os << "check_count " << static_cast<uint32_t>(cyclePatternInfo.matchProfiling) << " hit count " <<
+        static_cast<uint32_t>(cyclePatternInfo.matchProfiling >> kCyclepPatternProfileMatchCountShift) <<
+        " prof " << static_cast<int32_t>(cyclePatternInfo.matchCount) <<
+        " invalid " << static_cast<int32_t>(cyclePatternInfo.invalidated) << std::endl;
+  }
+}
+
+static void DumpCycleNodeInfo(std::ostream &os, const CyclePatternNodeInfo &nodeInfo, vector<string> &soSet,
+                              bool dupThreshold) {
+  MClass *cls = MObject::Cast<MClass>(nodeInfo.expectType);
+  string soName = dupThreshold ? GetSoNameFromCls(cls) : GetIndexOfSoName(soSet, cls);
+  os << ((static_cast<unsigned int>(nodeInfo.flags) & kCycleNodeSubClass) ?  "N_C_D: " : "N_D: ") <<
+      static_cast<int32_t>(nodeInfo.loadIndex) << ", " <<
+      static_cast<int32_t>(nodeInfo.loadOffset) << ", " <<
+      namemangler::EncodeName(std::string(cls->GetName())) <<
+      ":" << soName << ", " <<
+      static_cast<int32_t>(nodeInfo.expectRc) << std::endl;
+}
+
+static void DumpCycleEdgeInfo(std::ostream &os, const CyclePatternEdgeInfo &edgeInfo) {
+  os << ((static_cast<unsigned int>(edgeInfo.flags) & kCycleEdgeSkipMatch) ? "E_S_D: " : "E_D: ") <<
+      static_cast<int32_t>(edgeInfo.srcNodeIndex) << ", " <<
+      static_cast<int32_t>(edgeInfo.destNodeIndex) << ", " <<
+      static_cast<int32_t>(edgeInfo.loadOffset) << std::endl;
+}
+
+static void DumpClassCyclePatterns(std::ostream &os, bool dumpProfile, const MClass *cls, vector<string> &soSet) {
+  GCTibGCInfo *gctibInfo = reinterpret_cast<GCTibGCInfo*>(cls->GetGctib());
+  if (gctibInfo == nullptr) {
+    LOG(FATAL) << "The class has no gctibInfo:" << cls->GetName() << maple::endl;
+    return;
+  }
+  if (((gctibInfo->headerProto & kCyclePatternBit) == 0) && !dumpProfile) {
+    LOG2FILE(kLogtypeCycle) << "skip dump class: " << cls->GetName() << std::endl;
+    return;
+  }
+  CyclePatternInfo *cyclePatternInfo = GetCyclePatternInfo(*gctibInfo);
+  // dump class
+  DumpClassNameSo(os, cls, soSet, dumpProfile);
+  uint32_t pattern_index = 0;
+  for (; cyclePatternInfo != nullptr;
+      cyclePatternInfo = GetNextCyclePattern(*cyclePatternInfo), pattern_index++) {
+    if (cyclePatternInfo->invalidated == kCycleNotValid && !dumpProfile) {
+      LOG2FILE(kLogtypeCycle) << "skip dump pattern: " << cls->GetName() <<
+          "index " << pattern_index << std::endl;
+      continue;
+    }
+    // dump header
+    DumpCycleHeader(os, *cyclePatternInfo, dumpProfile);
+    // dump cycles: cycle header, Nodes, Edges
+    CyclePatternNodeInfo *curNodeInfo = GetCyclePatternNodeInfo(*cyclePatternInfo);
+    for (int32_t i = 0; i < cyclePatternInfo->nNodes; ++i) {
+      DumpCycleNodeInfo(os, *curNodeInfo, soSet, dumpProfile);
+      curNodeInfo = reinterpret_cast<CyclePatternNodeInfo*>(
+          ((reinterpret_cast<char*>(curNodeInfo)) + sizeof(CyclePatternNodeInfo)));
+    }
+    CyclePatternEdgeInfo *curEdgeInfo = GetCyclePatternEdgeInfo(*cyclePatternInfo);
+    for (int32_t i = 0; i < cyclePatternInfo->nEdges; ++i) {
+      DumpCycleEdgeInfo(os, *curEdgeInfo);
+      curEdgeInfo = reinterpret_cast<CyclePatternEdgeInfo*>(
+          ((reinterpret_cast<char*>(curEdgeInfo)) + sizeof(CyclePatternEdgeInfo)));
+    }
+  }
+  os << std::endl;
+}
+
+void ClassCycleManager::DumpDynamicCyclePatterns(std::ostream &os, size_t limit, bool dupThreshold) {
+  // prefer to skip pattern not matched at runtime
+  streampos startSize = os.tellp();
+  lock_guard<mutex> guard(cycleMutex);
+  vector<string> soSet;
+  for (auto it : dynamicLoadedCycleClasses) {
+    PatternAgeFlags &flag = it.second;
+    if (flag.preDefined) {
+      MClass *cls = it.first;
+      streampos curSize = os.tellp();
+      if (curSize - startSize >= static_cast<long>(limit)) {
+        break;
+      }
+      LOG2FILE(kLogtypeCycle) << "Dump Predefine " << cls->GetName() << std::endl;
+      DumpClassCyclePatterns(os, dupThreshold, cls, soSet);
+    }
+  }
+  for (auto it : dynamicLoadedCycleClasses) {
+    PatternAgeFlags &flag = it.second;
+    if (!flag.preDefined) {
+      streampos curSize = os.tellp();
+      if (curSize - startSize >= static_cast<long>(limit)) {
+        break;
+      }
+      MClass *cls = it.first;
+      LOG2FILE(kLogtypeCycle) << "Dump learned " << cls->GetName() << std::endl;
+      DumpClassCyclePatterns(os, dupThreshold, cls, soSet);
+    }
+  }
+  DumpSOSet(os, dupThreshold, soSet);
+  cpUpdated = false;
+}
+
+static bool CheckGctibBitAtOffset(const MClass &cls, uint32_t offset) {
+  if ((offset % sizeof(reffield_t)) != 0) {
+    return false;
+  }
+
+  if (cls.IsObjectArrayClass()) {
+    return true;
+  }
+
+  struct GCTibGCInfo *gcinfo = reinterpret_cast<struct GCTibGCInfo*>(cls.GetGctib());
+  __MRT_ASSERT(gcinfo != nullptr, "emtpy gctib");
+
+  uint32_t refWordIndex = offset / sizeof(reffield_t);
+  uint32_t bitmapWordIndex = refWordIndex / kRefWordPerMapWord;
+  if (bitmapWordIndex >= gcinfo->nBitmapWords) {
+    return false;
+  }
+
+  // return true if bit mask is normal ref
+  uint32_t inBitmapWordOffset = (refWordIndex % kRefWordPerMapWord) * kBitsPerRefWord;
+  return (((gcinfo->bitmapWords[bitmapWordIndex]) >> inBitmapWordOffset) & kRefBitsMask) == kNormalRefBits;
+}
+
+bool CheckPatternNodesAndEdges(CyclePattern &newPattern) {
+  // skip root node
+  for (int32_t i = 1; i < newPattern.NumNodes(); ++i) {
+    // check load offset
+    const CyclePatternNodeInfo *curNode = newPattern.GetNodeInfo(i);
+    if (curNode == nullptr) {
+      return false;
+    }
+    if (curNode->loadIndex >= newPattern.NumNodes()) {
+      LOG2FILE(kLogtypeCycle) << "cycle_check: load index excceed num nodes, node " << i << std::endl;
+      return false;
+    }
+
+    if (curNode->loadIndex >= i) {
+      LOG2FILE(kLogtypeCycle) << "cycle_check: load index excceed current stack index, node " << i << std::endl;
+      return false;
+    }
+
+    MClass *jcls = MObject::Cast<MClass>(newPattern.GetNodeInfo(curNode->loadIndex)->expectType);
+    // check if reference
+    if (!CheckGctibBitAtOffset(*jcls, static_cast<uint32_t>(curNode->loadOffset))) {
+      LOG2FILE(kLogtypeCycle) << "cycle_check: not valid reference offset, node " << i << std::endl;
+      return false;
+    }
+  }
+
+  // check edge reference
+  for (int32_t i = 0; i < newPattern.NumEdges(); ++i) {
+    // check reference
+    const CyclePatternEdgeInfo *curEdge = newPattern.GetEdgeInfo(i);
+    if (curEdge == nullptr) {
+      return false;
+    }
+    // check src index and dest index
+    if (curEdge->srcNodeIndex >= newPattern.NumNodes() || curEdge->destNodeIndex >= newPattern.NumNodes()) {
+      LOG2FILE(kLogtypeCycle) << "cycle_check: not valid node index, edge " << i << std::endl;
+      return false;
+    }
+
+    MClass *jcls = MObject::Cast<MClass>(newPattern.GetNodeInfo(curEdge->srcNodeIndex)->expectType);
+    // check if reference
+    if (!CheckGctibBitAtOffset(*jcls, static_cast<uint32_t>(curEdge->loadOffset))) {
+      LOG2FILE(kLogtypeCycle) << "cycle_check: not valid reference offset, edge " << i << std::endl;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool ClassCycleManager::CheckValidPattern(MClass *cls, char *buffer) {
+  // check if the jclass and it's buffer is valid
+  CyclePattern newPattern;
+  struct GCTibGCInfo *gctibInfo = reinterpret_cast<struct GCTibGCInfo*>(buffer);
+  CyclePatternInfo *cyclePatternInfo = GetCyclePatternInfo(*gctibInfo);
+  uint32_t patternCount = 0;
+  for (; cyclePatternInfo != nullptr; cyclePatternInfo = GetNextCyclePattern(*cyclePatternInfo)) {
+    patternCount++;
+    if (patternCount > kCyclepMaxNum) {
+      LOG2FILE(kLogtypeCycle) << "cycle_check: too many patterns" << std::endl;
+      return false;
+    }
+    if (!newPattern.constructFromBinary(*cyclePatternInfo, cls)) {
+      LOG2FILE(kLogtypeCycle) << "cycle_check: construct fail" << std::endl;
+      return false;
+    }
+
+    if (!newPattern.IsValid(false)) {
+      LOG2FILE(kLogtypeCycle) << "cycle_check: not valid inner cycle rc" << std::endl;
+      return false;
+    }
+
+    if (!CheckPatternNodesAndEdges(newPattern)) {
+      return false;
+    }
+  }
+  LOG2FILE(kLogtypeCycle) << "cycle_check: pass for " << cls->GetName() << std::endl;
+  return true;
+}
+
+bool ClassCycleManager::GetRCThreshold(uint32_t &rcMax, uint32_t &rcMin, char *cyclepatternBinary) {
+  CyclePatternInfo *cyclePatternInfo = reinterpret_cast<CyclePatternInfo*>(cyclepatternBinary);
+  rcMax = 0;
+  rcMin = kMaxRcInCyclePattern;
+  uint32_t patternCount = 0;
+  for (; cyclePatternInfo != nullptr; cyclePatternInfo = GetNextCyclePattern(*cyclePatternInfo)) {
+    ++patternCount;
+    if (patternCount > kCyclepMaxNum) {
+      LOG2FILE(kLogtypeCycle) << "cycle_check: too many patterns" << std::endl;
+      return false;
+    }
+
+    uint32_t expectRc = static_cast<uint32_t>(cyclePatternInfo->expectRc);
+    if (expectRc > rcMax) {
+      rcMax = expectRc;
+    }
+    if (expectRc < rcMin) {
+      rcMin = expectRc;
+    }
+  }
+  return (rcMax != 0) && (rcMin != 0) && (rcMax <= kMaxRcInCyclePattern) && (rcMax >= rcMin);
+}
+
+void CyclePatternGenerator::CollectCycleGarbage(vector<address_t> &sccNodes) {
+  std::unique_ptr<CycleGarbage> cycle(new CycleGarbage());
+  if (!cycle->Construct(sccNodes)) {
+    return;
+  }
+  for (CycleGarbage *savedCycle : resultCycles) {
+    if (*savedCycle == *cycle) {
+      savedCycle->IncCount();
+      // cout << "Find duplicated" << std::endl;
+      savedCycle->Print(cout);
+      return;
+    }
+  }
+  resultCycles.push_back(cycle.release());
+}
+
+// GarbageNode equal
+// 1. type and rc equal
+// 2. child index and offset equal
+//    Because all nodes are sorted with type and rc, same node likeley has same index
+bool GarbageNode::operator==(const GarbageNode &other) const {
+  if (type != other.type || internalRc != other.internalRc) {
+    return false;
+  }
+  if (references.size() != other.references.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < references.size(); ++i) {
+    GarbageNode *child = references.at(i).first;
+    GarbageNode *otherChild = other.references.at(i).first;
+    if (child->GetIndex() != otherChild->GetIndex()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// CycleGarbage equal
+// 1. hash equal
+// 2. num node is equal
+// 3. total edges equal
+// 4. GarbageNode equal
+//
+// Same Cycle might have different represenation, this is fixed in construct
+// class A-> class B1 16
+// class A-> class B2 20
+// class B1-> class A 8
+// class B2-> class A 8
+//
+// Cycle1:
+// A   -> 16 B1 20 B2
+// B1
+// B2
+//
+// A   -> 16 B1 20 B2
+// B2
+// B1
+bool CycleGarbage::operator==(const CycleGarbage &other) const {
+  if (Hash() != other.Hash() ||
+      nodesVec.size() != other.nodesVec.size() ||
+      totalEdges != other.totalEdges) {
+    return false;
+  }
+  for (size_t i = 0; i < nodesVec.size(); ++i) {
+    GarbageNode *node = nodesVec.at(i);
+    GarbageNode *otherNode = other.nodesVec.at(i);
+    if (!(*node == *otherNode)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void CycleGarbage::ConstructCycle(std::vector<address_t> &sccNodeAddrs, address_t rootAddr) {
+  GarbageNode *firstNode = AddNode(rootAddr, MObject::Cast<MObject>(rootAddr)->GetClass());
+  deque<GarbageNode*> workingDeque;
+  workingDeque.push_back(firstNode);
+  while (!workingDeque.empty()) {
+    GarbageNode *curNode = workingDeque.front();
+    workingDeque.pop_front();
+    reffield_t curAddr = curNode->GetAddr();
+    auto refFunc = [this, curNode, curAddr, &sccNodeAddrs, &workingDeque](reffield_t &field, uint64_t kind) {
+      address_t ref = RefFieldToAddress(field);
+      // skip self cycle and off heap object
+      if ((kind != kNormalRefBits) || (field == curAddr) || !IS_HEAP_ADDR(ref)) {
+        return;
+      }
+      if (std::find(sccNodeAddrs.begin(), sccNodeAddrs.end(), ref) == sccNodeAddrs.end()) {
+        return;
+      }
+      auto it = nodesMap.find(field);
+      GarbageNode *child = nullptr;
+      if (it == nodesMap.end()) {
+        child = AddNode(ref, MObject::Cast<MObject>(ref)->GetClass());
+        workingDeque.push_back(child);
+      } else {
+        child = it->second;
+        if (child == curNode) {
+          return;
+        }
+      }
+      int32_t offset = static_cast<int32_t>(reinterpret_cast<address_t>(&field) - curAddr);
+      curNode->addChild(*child, offset);
+      ++totalEdges;
+    };
+    ForEachRefField(curAddr, refFunc);
+  }
+}
+
+// Construct Cycle from Node, to Construct a unique cycle
+// 1. sort objects with type
+// 2. search a unique type node as root
+// 3. if all duplicated, Cycle is not valid and only compare with type
+// 4. construct cycle
+// 5. check validity
+// 6. compuate hash
+bool CycleGarbage::Construct(std::vector<address_t> &sccNodeAddrs) {
+  // 1. sort objects with type
+  size_t totalObjs = sccNodeAddrs.size();
+  if (totalObjs > 1) {
+    std::sort(sccNodeAddrs.begin(), sccNodeAddrs.end(), SortByObjMetaRC);
+  }
+
+  // 2. find a unique root in sccNodeAddrs
+  address_t rootAddr = 0;
+  for (size_t i = 0; i < totalObjs; ++i) {
+    MClass *cls = reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(sccNodeAddrs.at(i)))->GetClass();
+    bool found = false;
+    for (size_t j = i + 1; j < totalObjs; ++j) {
+      MClass *clsOther = reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(sccNodeAddrs.at(j)))->GetClass();
+      if (cls == clsOther) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      rootAddr = sccNodeAddrs.at(i);
+      break;
+    }
+  }
+  for (size_t i = 0; i < totalObjs - 1; ++i) {
+    MClass *cls = reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(sccNodeAddrs.at(i)))->GetClass();
+    MClass *clsNext = reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(sccNodeAddrs.at(i + 1)))->GetClass();
+    if (cls == clsNext) {
+      hasDuplicateType = true;
+      break;
+    }
+  }
+
+  if (rootAddr == 0) {
+    // 3. if all duplicated, Cycle is not valid and only compare with type
+    valid = false;
+    for (address_t addr : sccNodeAddrs) {
+      (void)AddNode(addr, MObject::Cast<MObject>(addr)->GetClass());
+    }
+  } else {
+    ConstructCycle(sccNodeAddrs, rootAddr);
+  }
+
+  if ((nodesVec.size() != totalObjs) || (CheckAndUpdate() == false)) {
+    return false;
+  }
+  ComputeHash();
+  return true;
+}
+
+// Check if Cycle garbage is valid to covert to cycle pattern
+// return true if can convert to pattern
+// return false if can not convert to pattern
+// 1. nodes count
+// 2. edges count
+// 3. each node's max rc no exceed limit
+// 4. each edge's offset is valid
+// 5. all nodes has same type and node count exceed 1, this likely data structurs
+//    like doubly-linked list, tree structure etc
+bool CycleGarbage::ToCyclePattern(CyclePattern &cyclePattern) {
+  size_t totalObjs = nodesVec.size();
+  if (totalObjs > kCyclepPatternMaxNodeNum) {
+    return false;
+  }
+  if (totalEdges - (nodesVec.size() - 1) > kCyclepPatternMaxEdgeNum) {
+    return false;
+  }
+  if (hasDuplicateType) {
+    return false;
+  }
+  GarbageNode *node = nodesVec.at(0);
+  cyclePattern.count = count;
+  // add root node
+  if (!cyclePattern.AddNode(node->GetAddr(), node->GetType(), -1, -1, node->GetInternalRc())) {
+    return false;
+  }
+  node->SetVisited();
+  for (size_t i = 0; i < totalObjs; ++i) {
+    GarbageNode *curNode = nodesVec.at(i);
+    // iterate edges and add node or edge
+    for (auto it: curNode->GetReferences()) {
+      GarbageNode *child = it.first;
+      int32_t offset = it.second;
+      if (offset >= kCyclepMaxOffset) {
+        return false;
+      }
+      if (child->IsVisited()) {
+        if (!cyclePattern.AddEdge(curNode->GetIndex(), child->GetIndex(), offset)) {
+          return false;
+        }
+      } else {
+        if (!cyclePattern.AddNode(
+            child->GetAddr(), child->GetType(), curNode->GetIndex(), offset, child->GetInternalRc())) {
+          return false;
+        }
+        child->SetVisited();
+      }
+    }
+  }
+
+  return cyclePattern.IsValid(false);
+}
+
+// Update limit, single update can load exceed kMaxBigdataUploadSize
+// Write content into cache with kMaxBigDataCacheSize
+// When upload split string and upload as big as possible.
+//
+// Delimer is ;
+// Example:
+// class_a class_b 0 1 24 1 0 32;
+// If has duplicated type:
+// class_a class_a class_a 0 1 16 1 2 16 2 0 16
+// 0 class_a c0 c0 c0 0 1 16 1 2 16 2 0 16
+//
+// If single pattern exceed kMaxBigdataUploadSize,
+// then split it into multiple string, or use compact result
+void CycleGarbage::AppendToString(ostringstream &oss) {
+  // single pattern string must smaller than kMaxBigdataUploadSize
+  int64_t startPos = oss.tellp();
+  if (hasDuplicateType) {
+    static unordered_map<MClass*, uint32_t> classToIndexMap;
+    uint32_t i = 0;
+    for (auto node : nodesVec) {
+      MClass *cls = node->GetType();
+      if (classToIndexMap.find(cls) != classToIndexMap.end()) {
+        oss << "n" << classToIndexMap[cls] << " ";
+      } else {
+        oss << namemangler::EncodeName(std::string(cls->GetName())) <<
+            ":" << GetSoNameFromCls(cls) << " ";
+        classToIndexMap[cls] = i;
+      }
+      ++i;
+    }
+    classToIndexMap.clear();
+  } else {
+    for (auto node : nodesVec) {
+      oss << namemangler::EncodeName(std::string(node->GetType()->GetName())) <<
+          ":" << GetSoNameFromCls(node->GetType()) << " ";
+    }
+  }
+  int i = 0;
+  for (auto node : nodesVec) {
+    for (auto it : node->GetReferences()) {
+      GarbageNode *child = it.first;
+      oss << i << " " << child->GetIndex() << " " << it.second << " ";
+    }
+    ++i;
+  }
+  if (adjusted) {
+    oss << "adjust"; // indicate this cycle has external reference
+  }
+  int64_t curPos = oss.tellp();
+  // output as more as possible for big cycles
+  if ((curPos - startPos) >= (kMaxBigdataUploadSize - kMaxBigDataUploadStringEndSize)) {
+    int64_t newPos = startPos + kMaxBigdataUploadSize - kMaxBigDataUploadStringEndSize;
+    (void)oss.seekp(newPos);
+  }
+  oss << ";" << std::endl;
+}
+
+void CycleGarbage::Print(std::ostream &os) {
+  os << "count " << count << std::endl;
+  for (auto node : nodesVec) {
+    os << node->GetType()->GetName() << std::endl;
+  }
+  int i = 0;
+  for (auto node : nodesVec) {
+    for (auto it : node->GetReferences()) {
+      GarbageNode *child = it.first;
+      os << i << " " << child->GetIndex() << " " << it.second << std::endl;
+    }
+    ++i;
+  }
+}
+
+// Return false whe
+// 1. node doesn't reference any other node in cycle
+// 2. node doesn't referenced by any other node in cycle
+// 3. node's rc is less than internal rc
+// If has external rc (internal rc < actual rc), set adjusted true
+bool CycleGarbage::CheckAndUpdate() {
+  if (valid == false) {
+    return true;
+  }
+  if (totalEdges < nodesVec.size()) {
+    return false;
+  }
+  for (auto node : nodesVec) {
+    if (node->GetInternalRc() == 0) {
+      return false;
+    }
+    if (node->GetReferences().empty()) {
+      return false;
+    }
+    if (node->GetInternalRc() > RefCount(node->GetAddr())) {
+      return false;
+    } else if (node->GetInternalRc() < RefCount(node->GetAddr())) {
+      adjusted = true;
+    }
+  }
+  return true;
+}
+
+// Compute hash for this Cycle, for fast compare in Cycle pattern aggragate
+// foreach jclass, internal rc
+const uint64_t kHashMagicMultiplier = 31;
+void CycleGarbage::ComputeHash() {
+  uint64_t hash = 0;
+  for (auto node : nodesVec) {
+    hash = (hash * kHashMagicMultiplier) + node->GetType()->AsUintptr();
+  }
+  hashValue = hash;
+}
+} // namespace
diff --git a/src/mrt/compiler-rt/src/collector/cycle_collector.cpp b/src/mrt/compiler-rt/src/collector/cycle_collector.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f67fb5ce560ebb32df67bea2e7117bcd35cf9563
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/cycle_collector.cpp
@@ -0,0 +1,632 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/cycle_collector.h"
+
+#include <cstdint>
+#include <cinttypes>
+#include <dlfcn.h>
+
+#include "file_system.h"
+#include "mm_config.h"
+#include "sizes.h"
+#include "chosen.h"
+#include "collector/rc_reference_processor.h"
+#include "collector/collector_naiverc.h"
+#include "interp_support.h"
+
+namespace maplert {
+namespace {
+const string kCyclePatternValidityStrs[] = { "Valid", "InValid", "Permanent" };
+}
+const bool kMergeAllPatterns = MRT_ENVCONF(PATTERN_FROM_BACKUP_TRACING, PATTERN_FROM_BACKUP_TRACING_DEFAULT);
+
+string MRT_CyclePatternValidityStr(int validStatus) {
+  if (validStatus < kCycleValid || validStatus > kCyclePermernant) {
+    return "error";
+  }
+  return kCyclePatternValidityStrs[validStatus];
+}
+
+static inline bool CycleDestArrayCheck(uint32_t offset, address_t refObj) {
+  if (IsArray(refObj)) {
+    uint32_t arrayLen = ArrayLength(refObj);
+    if ((offset < kJavaArrayContentOffset) ||
+        (offset >= (arrayLen * sizeof(reffield_t) + kJavaArrayContentOffset))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static inline address_t CycleNodeLoadObject(const address_t stack[], const CyclePatternNodeInfo &nodeInfo) {
+  address_t srcObj = stack[nodeInfo.loadIndex];
+  // check for array offset
+  if (UNLIKELY(!CycleDestArrayCheck(nodeInfo.loadOffset, srcObj))) {
+    return static_cast<address_t>(0);
+  }
+
+  // so far, it looks good
+  return LoadRefField(srcObj, nodeInfo.loadOffset);
+}
+
+static inline address_t CycleEdgeLoadObject(const address_t stack[], const CyclePatternEdgeInfo &edgeInfo) {
+  address_t srcObj = stack[edgeInfo.srcNodeIndex];
+  // check for array offset
+  if (UNLIKELY(!CycleDestArrayCheck(edgeInfo.loadOffset, srcObj))) {
+    return static_cast<address_t>(0);
+  }
+
+  return LoadRefField(srcObj, edgeInfo.loadOffset);
+}
+
+// Cycle pattern profiling and abandant rules
+// 1. match count profiling
+//    CyclePatternInfo.matchProfiling record if cycle match count and success count
+//    in TryFreeCycleAtMutator. low 32 bit for check count, high 32 bit for match sucess count.
+//
+// 2. CyclePatternInfo.matchCount
+//    If check count reach kCyclepPatternProfileCheckThreshold, check if pattern is matched during
+//    this period. If match success count exceed kCyclepPatternProfileCleanThreshold, matchCount++.
+//    Otherwise matchCount--;
+//
+// 3. If matchCount exceed kCyclepPatternProfileCancelThreshold, no change.
+//
+// 4. If matchCount is less than -kCyclepPatternProfileCancelThreshold, disable this cycle pattern.
+//
+//
+// update match count.
+// success is true iff match success count is less than threshold
+//
+// return true, if keep cycle pattern
+// return false, if not keep cycle pattern
+static inline bool UpdateCycleMatchCount(CyclePatternInfo &pattern, bool success) {
+  if (success) {
+    if (pattern.matchCount < kCyclepPatternProfileCancelThreshold) {
+      pattern.matchCount = kCyclepPatternProfileCancelThreshold;
+    }
+    return true;
+  } else {
+    // delta is -1
+    if (pattern.matchCount <= -kCyclepPatternProfileCancelThreshold) {
+      return false;
+    }
+    --(pattern.matchCount);
+    return true;
+  }
+}
+
+static void UpdateClassPatternAtCancel(const MClass *cls) {
+  GCTibGCInfo *gctibInfo = reinterpret_cast<GCTibGCInfo*>(cls->GetGctib());
+  if (gctibInfo == nullptr) {
+    LOG(FATAL) << "The class has no gctibInfo:" << cls->GetName() << maple::endl;
+    return;
+  }
+  if (UNLIKELY(gctibInfo->headerProto & kCyclePatternBit) == 0) {
+    LOG2FILE(kLogtypeCycle) << "already canceled by other " << cls->GetName() << std::endl;
+    return;
+  }
+  CyclePatternInfo *cyclePatternInfo = GetCyclePatternInfo(*gctibInfo);
+  for (; cyclePatternInfo != nullptr; cyclePatternInfo = GetNextCyclePattern(*cyclePatternInfo)) {
+    if (cyclePatternInfo->invalidated != kCycleNotValid) {
+      return;
+    }
+  }
+  // gctib is updated only in
+  // STW: cycle pattern study
+  // Startup: dynamic load
+  // runtime: clear cycle pattern bit here
+  // need update min/max rc, this could be updated by multiple thread
+  gctibInfo->headerProto &= ~kCyclePatternBit;
+  LOG2FILE(kLogtypeCycle) << "prof_cancel_class: " << cls->GetName() <<
+      std::hex << gctibInfo->headerProto << std::dec << std::endl;
+}
+
+static void AddProfilingMatch(CyclePatternInfo &pattern, const MClass *cls, uint32_t patternIndex, bool matchSuccess) {
+  uint64_t matchProfile = pattern.matchProfiling;
+  uint64_t count = 0;
+  if (matchSuccess) {
+    count = matchProfile + 1 + (1ULL << kCyclepPatternProfileMatchCountShift);
+  } else {
+    count = matchProfile + 1;
+  }
+  if (static_cast<uint32_t>(count) >= kCyclepPatternProfileCheckThreshold) {
+    pattern.matchProfiling = 0;
+    if ((count >> kCyclepPatternProfileMatchCountShift) < kCyclepPatternProfileCleanThreshold) {
+      if (!UpdateCycleMatchCount(pattern, false)) {
+        if (pattern.invalidated != kCyclePermernant) {
+          LOG2FILE(kLogtypeCycle) << "prof_cancel: " <<
+              namemangler::EncodeName(std::string(cls->GetName())) <<
+              ":" << GetSoNameFromCls(cls) <<
+              " index " << (patternIndex) <<
+              " " << MRT_CyclePatternValidityStr(static_cast<uint32_t>(pattern.invalidated)) <<
+              std::endl;
+          pattern.invalidated = kCycleNotValid;
+          UpdateClassPatternAtCancel(cls);
+        }
+      }
+      LOG2FILE(kLogtypeCycle) << "prof_abandon: " <<
+          namemangler::EncodeName(std::string(cls->GetName())) <<
+          ":" << GetSoNameFromCls(cls) <<
+          " " << count << " " <<
+          static_cast<uint32_t>(count >> kCyclepPatternProfileMatchCountShift) <<
+          " index " << (patternIndex) <<
+          " prof " << static_cast<int32_t>(pattern.matchCount) <<
+          " " << MRT_CyclePatternValidityStr(static_cast<uint32_t>(pattern.invalidated)) <<
+          std::endl;
+    } else {
+      (void)UpdateCycleMatchCount(pattern, true);
+      LOG2FILE(kLogtypeCycle) << "prof_ok: " <<
+          namemangler::EncodeName(std::string(cls->GetName())) <<
+          ":" << GetSoNameFromCls(cls) <<
+          " " << static_cast<uint32_t>(count) << " " <<
+          static_cast<uint32_t>(count >> kCyclepPatternProfileMatchCountShift) <<
+          " index " << (patternIndex) <<
+          " prof " << static_cast<int32_t>(pattern.matchCount) <<
+          " " << MRT_CyclePatternValidityStr(static_cast<uint32_t>(pattern.invalidated)) <<
+          std::endl;
+    }
+  } else {
+    pattern.matchProfiling = count;
+  }
+}
+
+bool CycleCollector::CheckAndReleaseCycle(address_t obj, uint32_t rootDelta, bool isRefProcess,
+                                          CyclePatternInfo &cyclePatternInfo, CyclePatternInfo *prevPattern) {
+  address_t stack[kCyclepPatternMaxNodeNum] = {};
+  bool weakCollectedSet[kCyclepPatternMaxNodeNum] = {};
+  uint32_t expectRC[kCyclepPatternMaxNodeNum] = {};
+  // match first node, only need match rc
+  // low cost to skip not suitable pattern, avoid atomic
+  uint32_t node0ExpectRc = static_cast<uint32_t>(static_cast<int32_t>(cyclePatternInfo.expectRc));
+  if (((RefCount(obj) - rootDelta) != node0ExpectRc) || IsRCSkiped(obj)) {
+    prevPattern = nullptr;
+    return false;
+  }
+  uint32_t oldHeader = AtomicUpdateColor(obj, kRCCycleColorGray);
+  uint32_t rc = GetRCFromRCHeader(oldHeader);
+  if (((rc - rootDelta) != node0ExpectRc) || SkipRC(oldHeader)) {
+    // first node rc not match, skip prfoling, as this cycle is not checked intensively
+    prevPattern = nullptr;
+    return false;
+  } else if (isRefProcess) {
+    __MRT_ASSERT(IsRCOverflow(oldHeader) || (GetTotalWeakRCFromRCHeader(oldHeader) != 0), "root doesn't have weak rc");
+  }
+
+  // other thread might incref throgh weak proxy
+  bool hasFinal = IsObjFinalizable(obj);
+  stack[0] = obj;
+  expectRC[0] = rc;
+
+  // match other nodes and edges
+  // check concurrent modification
+  CyclePatternNodeInfo *nodeInfos = GetCyclePatternNodeInfo(cyclePatternInfo);
+  CyclePatternEdgeInfo *edgeInfos = GetCyclePatternEdgeInfo(cyclePatternInfo);
+  if ((!MatchNodes(stack, *nodeInfos, cyclePatternInfo.nNodes + 1, hasFinal, isRefProcess, expectRC)) ||
+      (!MatchEdges(stack, *edgeInfos, cyclePatternInfo.nNodes + 1, cyclePatternInfo.nEdges)) ||
+      (!CheckStackColorGray(stack, cyclePatternInfo.nNodes + 1, weakCollectedSet, expectRC))) {
+    return false;
+  }
+
+  // release objects in stack
+  if (hasFinal) {
+    if (!isRefProcess) {
+      RefCountLVal(stack[0]) -= rootDelta;
+      uint32_t resurrectWeakRC = ResurrectWeakRefCount(stack[0]);
+      if (resurrectWeakRC > 0) {
+        __MRT_ASSERT(resurrectWeakRC == 1, "unexpected weak count");
+        RefCountLVal(stack[0]) &= ~(kResurrectWeakRcBits);
+      }
+    }
+    FinalizeCycleObjects(stack, cyclePatternInfo.nNodes + 1, weakCollectedSet);
+  } else if (!isRefProcess) {
+    ReleaseCycleObjects(stack, *nodeInfos, cyclePatternInfo.nNodes + 1, *edgeInfos,
+                        cyclePatternInfo.nEdges, weakCollectedSet);
+  } else {
+    for (int32_t i = 0; i < (cyclePatternInfo.nNodes + 1); ++i) {
+      if (weakCollectedSet[i]) {
+        NRCMutator().WeakReleaseObj(stack[i]);
+        NRCMutator().DecWeak(stack[i]);
+      }
+    }
+  }
+  return true;
+}
+
+// Match Cycle pattern and perf actions (add finalize, release, checkonly).
+//
+// This method is invoked when:
+// 1. Dec Strong RC
+// 2. Dec Weak RC
+// 3. Reference processor check
+//
+// rootDelta: strong rc delta for root object
+// is_weak: tobe removed
+// cycle_finals: record finalizable objects in cycle
+// cycle_weaks: record object and its strong rc iff object has weak rc in cycle
+//
+// return true if match success
+//
+// Implementation flows
+// Loop1: Itreate root object's all cycle patterns and match
+//   1. prepare work
+//      1.1 update profile
+//      1.2 clear state: stack/cycle_finals/cycle_weaks/all flags
+//   2. check root object if strong rc is same with expected rc
+//      2.1 quick check before atomic operation and check again after atomic
+//      2.2 if cycleWeaks is needed, record root object, root must have weak rc
+//   3. match other nodes, iterate pattern nodes, for each node
+//      3.1 read object from src node with valid offset, if fail return false
+//      3.2 check strong rc match expected rc, if fail return false
+//      3.3 check object match expected type, if fail return false
+//   4. match edges, itrate pattern edges
+//      4.1 load object from source object with offset and check with expected object
+//   5. check concurrent modification: if color still gray and success covert to white
+//   6. matched pattern processing
+//      6.1 not check and no finalizable object: direct release
+//      6.2 not check and has finalizable object: add to finalizable
+//      6.3 check only: add finalizable object into list
+//   7. update profile
+bool CycleCollector::TryFreeCycleAtMutator(address_t obj, uint32_t rootDelta, bool isRefProcess) {
+  MClass *cls = reinterpret_cast<MObject*>(obj)->GetClass();
+  GCTibGCInfo *gctibInfo = reinterpret_cast<GCTibGCInfo*>(cls->GetGctib());
+  if (gctibInfo == nullptr) {
+    LOG(FATAL) << "The class has no gctibInfo:" << cls->GetName() << maple::endl;
+    return false;
+  }
+  if (UNLIKELY(gctibInfo->headerProto & kCyclePatternBit) == 0) {
+    // This can heappen if object is created before pattern is invalidated.
+    ClearCyclePatternBit(obj);
+    return false;
+  }
+  CyclePatternInfo *cyclePatternInfo = GetCyclePatternInfo(*gctibInfo);
+  uint32_t patternIndex = 0; // current processing pattern index
+  uint32_t prevPatternIndex = 0; // prev valid pattern index
+  CyclePatternInfo *prevPattern = nullptr; // prev points to last valid pattern, skip canceled pattern.
+  for (; cyclePatternInfo != nullptr; cyclePatternInfo = GetNextCyclePattern(*cyclePatternInfo), ++patternIndex) {
+    if (prevPattern != nullptr && prevPattern->invalidated != kCyclePermernant) {
+      // add check count and judge if invalidate
+      AddProfilingMatch(*prevPattern, cls, prevPatternIndex, false);
+    }
+    if (cyclePatternInfo->invalidated == kCycleNotValid) {
+      continue;
+    }
+    prevPattern = cyclePatternInfo;
+    prevPatternIndex = patternIndex;
+
+    if (!CheckAndReleaseCycle(obj, rootDelta, isRefProcess, *cyclePatternInfo, prevPattern)) {
+      continue;
+    }
+
+    if (cyclePatternInfo->invalidated != kCyclePermernant) {
+      // add hit count and check count
+      AddProfilingMatch(*cyclePatternInfo, cls, patternIndex, true);
+    }
+    return true; // a match found
+  }
+  if (prevPattern != nullptr && prevPattern->invalidated != kCyclePermernant) {
+    // add check count and judge if invalidate
+    AddProfilingMatch(*prevPattern, cls, prevPatternIndex, false);
+  }
+  return false; // doesn't match any pattern
+}
+
+static inline bool CheckSubClass(const MClass *objCls, const MClass *expectCls) {
+  MClass *parent = objCls->GetSuperClass();
+  return parent == expectCls;
+}
+
+// search pattern from obj, match all nodes in node patterns
+bool CycleCollector::MatchNodes(address_t stack[], CyclePatternNodeInfo &infos,
+                                int32_t nNodes, bool &hasFinal, bool isRefProcess, uint32_t expectRC[]) {
+  CyclePatternNodeInfo *curInfo = &infos;
+  // match start from second nodes in cycle
+  for (int32_t i = 1; i < nNodes; ++i) {
+    __MRT_ASSERT(curInfo->loadIndex < i, "invlaid load index");
+    address_t curObj = CycleNodeLoadObject(stack, *curInfo);
+    if (!IS_HEAP_OBJ(curObj)) {
+      return false;
+    }
+
+    uint32_t nodeExpectRc = static_cast<uint32_t>(static_cast<int32_t>(curInfo->expectRc));
+    if ((RefCount(curObj) != nodeExpectRc) || IsRCSkiped(curObj)) {
+      return false;
+    }
+    // mark gray atomic
+    uint32_t oldHeader = AtomicUpdateColor(curObj, kRCCycleColorGray);
+    uint32_t rc = GetRCFromRCHeader(oldHeader);
+    // check pattern type, rc
+    if (rc != nodeExpectRc || SkipRC(oldHeader)) {
+      return false;
+    }
+
+    if (!isRefProcess) {
+      if (GetResurrectWeakRCFromRCHeader(oldHeader) != 0 && !IsWeakCollectedFromRCHeader(oldHeader)) {
+        return false;
+      }
+    }
+    MClass *classInfo = MObject::Cast<MObject>(curObj)->GetClass();
+    MClass *expectCls = MObject::Cast<MClass>(curInfo->expectType);
+    if (classInfo != expectCls) {
+      // 1. not check sub class
+      // 2. check sub class and fail
+      if (((static_cast<unsigned int>(curInfo->flags) & kCycleNodeSubClass) == 0) ||
+          (!CheckSubClass(classInfo, expectCls))) {
+        return false;
+      }
+    }
+
+    // next info
+    curInfo = reinterpret_cast<CyclePatternNodeInfo*>(
+        ((reinterpret_cast<char*>(curInfo)) + sizeof(CyclePatternNodeInfo)));
+    stack[i] = curObj;
+    expectRC[i] = rc;
+    hasFinal = hasFinal || IsObjFinalizable(curObj);
+  }
+  return true;
+}
+
+// int8_t  srcNodeIndex;
+// int8_t  destNodeIndex;
+// int16_t loadOffset;
+bool CycleCollector::MatchEdges(const address_t stack[], CyclePatternEdgeInfo &infos, int32_t nNodes, int32_t nEdges) {
+  CyclePatternEdgeInfo *curInfo = &infos;
+  for (int32_t i = 0; i < nEdges; ++i) {
+    if ((static_cast<unsigned int>(curInfo->flags) & kCycleEdgeSkipMatch) == 0) {
+      address_t loadedObj = CycleEdgeLoadObject(stack, *curInfo);
+      __MRT_ASSERT(curInfo->destNodeIndex < nNodes, "destNodeIndex overflow");
+      address_t expectedObj = stack[curInfo->destNodeIndex];
+      if (loadedObj != expectedObj) {
+        return false;
+      }
+    }
+
+    // next info
+    curInfo = reinterpret_cast<CyclePatternEdgeInfo*>(
+        ((reinterpret_cast<char*>(curInfo)) + sizeof(CyclePatternEdgeInfo)));
+  }
+  return true;
+}
+
+// check if color is still gray and can successfully set white
+// return true, if check success
+// weakCollectedSet is set true, if weak collected bit is set in atomic operation
+static bool AtomicCheckCycleCollectable(address_t objAddr, bool &weakCollectedSet, uint32_t rc) {
+  atomic<uint32_t> &headerAtomic = RefCountAtomicLVal(objAddr);
+  uint32_t oldHeader = headerAtomic.load();
+  uint32_t newHeader = 0;
+
+  do {
+    if (UNLIKELY(SkipRC(oldHeader))) {
+      return false;
+    }
+
+    if ((oldHeader & kRCCycleColorMask) != kRCCycleColorGray) {
+      return false;
+    }
+
+    if (GetRCFromRCHeader(oldHeader) != rc) {
+      return false;
+    }
+
+    newHeader = (oldHeader & ~kRCCycleColorMask) | kRCCycleColorWhite;
+    if ((!IsWeakCollectedFromRCHeader(oldHeader))) {
+      newHeader = (newHeader | kWeakCollectedBit);
+      weakCollectedSet = true;
+    } else {
+      weakCollectedSet = false;
+    }
+  } while (!headerAtomic.compare_exchange_weak(oldHeader, newHeader));
+  return true;
+}
+
+// check if pattern match is valid and set weak collected bit if needed.
+// 1. check if old color is still gray and new color is set to white
+// 2. weak collected bit need set iff: weak collected bit not set &&
+//    (weak rc > 1 || resurrect weak rc > 0)
+// 3. if old color is not gray, update color and weak collected bit is fail
+// 4. if node's check is fail, need revert early weak collected bit.
+bool CycleCollector::CheckStackColorGray(const address_t stack[], int32_t nNodes,
+                                         bool weakCollectedSet[], const uint32_t expectRC[]) {
+  bool checkPass = true;
+  int i;
+  for (i = 0; i < nNodes; ++i) {
+    address_t obj = stack[i];
+    uint32_t rc = expectRC[i];
+    bool weakCollectedBitSet = false;
+    if (AtomicCheckCycleCollectable(obj, weakCollectedBitSet, rc)) {
+      weakCollectedSet[i] = weakCollectedBitSet;
+    } else {
+      checkPass = false;
+      break;
+    }
+  }
+  if (!checkPass) {
+    LOG2FILE(kLogtypeGc) << "CheckStackColorGray fail with rollback " << std::endl;
+    for (int j = 0; j < i; ++j) {
+      if (weakCollectedSet[j]) {
+        AtomicClearWeakCollectable(stack[j]);
+      }
+    }
+    return false;
+  }
+  return true;
+}
+
+// If any object is fianlizable in cycle, need put object in finalize list
+void CycleCollector::FinalizeCycleObjects(const address_t stack[], int32_t nNodes, const bool weakCollectedSet[]) {
+  __MRT_ASSERT(nNodes <= kCyclepPatternMaxNodeNum, "overflow");
+  address_t finalizableObjs[kCyclepPatternMaxNodeNum] = {};
+  int32_t finalizableCount = 0;
+  // record if object is finalizable before add into finalizable queue, otherwise
+  // for cycle A<->B, A is finalizable
+  // 1. mutator thread find cycle and add A into finalizable queue
+  // 2. RP thread get invoked and execute A's finalize and trigger cycle pattern match again release A and B
+  // 3. mutator thread try processing B and find it is already release.
+  //
+  // If multiple object in cycle is finalizable, there might racing in add finalizable
+  // for cycle A<->B, A and B is finalizable
+  // 1. mutator thread find cycle and add A into finalizable queue
+  // 2. RP thread execute A's finalize and trigger cycle pattern match again, put B into finalize queue
+  // 3. mutator thread also put B into finalize queue
+  // solution is put A and B into finalize queue together
+  for (int32_t i = 0; i < nNodes; ++i) {
+    if (IsObjFinalizable(stack[i])) {
+      __MRT_ASSERT(weakCollectedSet[i] == true, "weak collected bit already set for finalizable object");
+      finalizableObjs[finalizableCount] = stack[i];
+      ++finalizableCount;
+    } else {
+      if (weakCollectedSet[i]) {
+        NRCMutator().DecWeak(stack[i]);
+      }
+    }
+  }
+  __MRT_ASSERT(finalizableCount > 0, "no finalizable found");
+  ReferenceProcessor::Instance().AddFinalizables(finalizableObjs, finalizableCount, true);
+}
+
+static uint32_t AtomicUpdateStrongRC(address_t objAddr, int32_t delta) {
+  atomic<uint32_t> &headerAtomic = RefCountAtomicLVal(objAddr);
+  uint32_t oldHeader = headerAtomic.load();
+  uint32_t newHeader = 0;
+
+  do {
+    StatsRCOperationCount(objAddr);
+    if (UNLIKELY(SkipRC(oldHeader))) {
+      return oldHeader;
+    }
+    newHeader = static_cast<uint32_t>((static_cast<int32_t>(oldHeader)) + delta);
+    uint32_t color = (delta > 0) ? kRCCycleColorBlack : kRCCycleColorBrown;
+    newHeader = (newHeader & ~kRCCycleColorMask) | color;
+  } while (!headerAtomic.compare_exchange_weak(oldHeader, newHeader));
+  return oldHeader;
+}
+
+// strong rc is not cleared and weak collected bit is set
+// check if node can be release iff weak and resurrect weak is 0
+// 1. weak collected bit is set before cycle pattern match and all rc is zero
+// 2. weak collected bit is set in cycle pattern match and only weak rc one left
+void ReleaseObjInCycle(const address_t stack[], NaiveRCMutator &mutator, bool deferRelease,
+                       const bool weakCollectedSet[], int32_t i){
+  address_t obj = stack[i];
+  if (weakCollectedSet[i]) {
+    if (TotalWeakRefCount(obj) == kWeakRCOneBit) {
+      // no other strong and weak reference, no racing
+      if (LIKELY(!deferRelease)) {
+        mutator.ReleaseObj(obj);
+      } else {
+        // no racing its safe to update rc without atomic
+        RefCountLVal(obj) &= ~(kRCBits | kWeakRcBits);
+        RCReferenceProcessor::Instance().AddAsyncReleaseObj(obj, true);
+      }
+    } else {
+      // has other weak reference, might racing, storng reference can not change
+      uint32_t strongRC = RefCount(obj);
+      uint32_t oldHeader __MRT_UNUSED = AtomicUpdateStrongRC(obj, -static_cast<int32_t>(strongRC));
+      __MRT_ASSERT(GetWeakRCFromRCHeader(oldHeader) > 0, "weak rc must be none zero");
+      if (LIKELY(!deferRelease)) {
+        mutator.WeakReleaseObj(obj);
+      } else {
+        // skip weak release might cause delayed release
+        LOG2FILE(kLogtypeGc) << "Skip Weak Release " << i << " " << std::hex << RCHeader(obj) << " " <<
+            GCHeader(obj) << " " << std::dec << reinterpret_cast<MObject*>(obj)->GetClass()->GetName() << std::endl;
+      }
+      mutator.DecWeak(obj);
+    }
+  } else {
+    uint32_t strongRC = RefCount(obj);
+    if (strongRC > 1) {
+      (void)AtomicUpdateStrongRC(obj, 1 - static_cast<int32_t>(strongRC));
+    }
+    mutator.DecRef(obj);
+  }
+}
+
+// If none object is finalizable, invoke release
+// release object need skip recurisve white object
+const uint32_t kCycleDepthToAsyncReleaseThreshold = 5;
+void CycleCollector::ReleaseCycleObjects(const address_t stack[], CyclePatternNodeInfo &nInfos, int32_t nNodes,
+                                         CyclePatternEdgeInfo &eInfos, int32_t nEdges, const bool weakCollectedSet[]) {
+  CyclePatternNodeInfo *curNInfo = &nInfos;
+  for (int32_t i = 1; i < nNodes; ++i) {
+    // decref(load_result)
+    // remove internal edges
+    address_t objAddr = stack[curNInfo->loadIndex];
+    reffield_t *addr = reinterpret_cast<reffield_t*>(objAddr + curNInfo->loadOffset);
+    TLMutator().SatbWriteBarrier(objAddr, *addr);
+    *addr = 0;
+    curNInfo = reinterpret_cast<CyclePatternNodeInfo*>(
+        ((reinterpret_cast<char*>(curNInfo)) + sizeof(CyclePatternNodeInfo)));
+  }
+
+  CyclePatternEdgeInfo *curEInfo = &eInfos;
+  for (int32_t i = 0; i < nEdges; ++i) {
+    address_t objAddr = stack[curEInfo->srcNodeIndex];
+    reffield_t *addr = reinterpret_cast<reffield_t*>(objAddr + curEInfo->loadOffset);
+    TLMutator().SatbWriteBarrier(objAddr, *addr);
+    *addr = 0;
+    curEInfo = reinterpret_cast<CyclePatternEdgeInfo*>(
+        ((reinterpret_cast<char*>(curEInfo)) + sizeof(CyclePatternEdgeInfo)));
+  }
+
+  for (int32_t i = 0; i < nNodes; ++i) {
+    // clear strong rc/resurrect rc and dec weak rc
+    // if weak rc is not zero, there could be other threads dec weak rc concurrently
+    address_t obj = stack[i];
+    uint32_t oldHeader = RCHeader(obj);
+    uint32_t reusrrectWeakRC = GetResurrectWeakRCFromRCHeader(oldHeader);
+    if (i == 0 && reusrrectWeakRC > 0) {
+      __MRT_ASSERT(reusrrectWeakRC == 1, "unexpected resurrect weak count, not 1");
+      // none reference processing cycle pattern match, node's reusrrect rc must be one.
+      (void)AtomicUpdateRC<0, 0, -1>(obj);
+    } else {
+      __MRT_ASSERT((reusrrectWeakRC == 0) || IsWeakCollected(obj), "unexpected weak count, not 0");
+    }
+#if RC_TRACE_OBJECT
+    TraceRefRC(stack[i], 0, " Release In Cycle Pattern");
+#endif
+  }
+
+  NaiveRCMutator &mutator = NRCMutator();
+#if CONFIG_JSAN
+  bool deferRelease = false;
+  (void)kCycleDepthToAsyncReleaseThreshold;
+#else
+  bool deferRelease = (mutator.CycleDepth() >= kCycleDepthToAsyncReleaseThreshold);
+#endif
+  mutator.IncCycleDepth();
+  for (int32_t i = 0; i < nNodes; ++i) {
+    ReleaseObjInCycle(stack, mutator, deferRelease, weakCollectedSet, i);
+  }
+  mutator.DecCycleDepth();
+}
+
+string GetSoNameFromCls(const MClass *elementClass) {
+  Dl_info dlinfo;
+  while (elementClass->IsArrayClass()) {
+    elementClass = elementClass->GetComponentClass();
+    __MRT_ASSERT(elementClass != nullptr, "object array class's element cannot be null");
+  }
+  if ((dladdr(elementClass, &dlinfo) != 0) && dlinfo.dli_fname != nullptr) {
+    string fullname = string(dlinfo.dli_fname);
+    // trim to libmaplecore-all.so
+    if (fullname == maple::fs::kLibcorePath) {
+    return "libmaplecore-all.so";
+    }
+    return fullname;
+  } else {
+    return InterpSupport::GetSoName();
+  }
+}
+} // end of namespace
diff --git a/src/mrt/compiler-rt/src/collector/gc_reason.cpp b/src/mrt/compiler-rt/src/collector/gc_reason.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba2118057637ef38a167c5179c64f36327e202d6
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/gc_reason.cpp
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "gc_reason.h"
+#include "gc_log.h"
+#include "chosen.h"
+#include "collector/stats.h"
+
+namespace maplert {
+namespace {
+// Minimum time between async GC (heuristic, native).
+constexpr int64_t kMinAsyncGcIntervalNs = static_cast<int64_t>(maple::kSecondToNanosecond);
+// 10ms for heuristic gc: gc usually takes longer than 10ms; if interval is
+// smaller than 10ms, it tells us something is faulty or we should use blocking gc
+constexpr int64_t kMinHeuGcIntervalNs = 10 * static_cast<int64_t>(maple::kMillisecondToNanosecond);
+
+// Set a safe initial value so that the first GC is able to trigger.
+int64_t initHeuTriggerTimestamp = static_cast<int64_t>(timeutils::NanoSeconds()) - kMinHeuGcIntervalNs;
+int64_t initNativeTriggerTimestamp = static_cast<int64_t>(timeutils::NanoSeconds()) - kMinAsyncGcIntervalNs;
+} // namespace
+
+int64_t GCReasonConfig::lastGCTimestamp = initNativeTriggerTimestamp;
+
+void GCReasonConfig::IgnoreCallback() const {
+  LOG2FILE(kLogtypeGc) << name << " is triggered too frequently. Ignoring this request." << std::endl;
+  LOG(ERROR) << "[GC] " << name << " is triggered too frequently.  Ignoring this request." << maple::endl;
+}
+
+inline bool GCReasonConfig::IsFrequentGC() const {
+  if (minIntervelNs == 0) {
+    return false;
+  }
+  int64_t now = static_cast<int64_t>(timeutils::NanoSeconds());
+  return (now - lastTriggerTimestamp < minIntervelNs);
+}
+
+inline bool GCReasonConfig::IsFrequentAsyncGC() const {
+  int64_t now = static_cast<int64_t>(timeutils::NanoSeconds());
+  return (now - lastGCTimestamp < minIntervelNs);
+}
+
+// heuristic gc is triggered by object allocation,
+// the heap stats should take into consideration.
+inline bool GCReasonConfig::IsFrequentHeuristicGC() const {
+  return IsFrequentAsyncGC();
+}
+
+bool GCReasonConfig::ShouldIgnore() const {
+  switch (reason) {
+    case kGCReasonHeu:
+      return IsFrequentHeuristicGC();
+    case kGCReasonNative:
+      return IsFrequentAsyncGC();
+    case kGCReasonOOM:
+      return IsFrequentGC();
+    default:
+      return false;
+  }
+}
+
+GCReleaseSoType GCReasonConfig::ShouldReleaseSo() const {
+  switch (reason) {
+    case kGCReasonUserNi: // fall through
+    case kGCReasonForceGC:
+      return kReleaseAll;
+    case kGCReasonTransistBG:
+      return Collector::Instance().InJankImperceptibleProcessState() ? kReleaseAppSo : kReleaseNone;
+    default:
+      return kReleaseNone;
+  }
+}
+
+bool GCReasonConfig::ShouldTrimHeap() const {
+  switch (reason) {
+    case kGCReasonUserNi: // fall through
+    case kGCReasonForceGC:
+      return true;
+    case kGCReasonTransistBG:
+      return Collector::Instance().InJankImperceptibleProcessState();
+    default:
+      return false;
+  }
+}
+
+bool GCReasonConfig::ShouldCollectCycle() const {
+  switch (reason) {
+    case kGCReasonUserNi:
+      return true;
+    default:
+      return false;
+  }
+}
+
+void GCReasonConfig::SetLastTriggerTime(int64_t timestamp) {
+  lastTriggerTimestamp = timestamp;
+  lastGCTimestamp = timestamp;
+}
+
+GCReasonConfig reasonCfgs[] = {
+    { kGCReasonUser, "user", true, false, false, true, 0, 0 },
+    { kGCReasonUserNi, "user_ni", true, false, false, true, 0, 0 },
+    { kGCReasonOOM, "oom", true, false, false, false, 0, 0 },
+    { kGCReasonForceGC, "force", true, false, false, true, 0, 0 },
+    { kGCReasonTransistBG, "transist_background", true, false, false, true, 0, 0 },
+    { kGCReasonHeu, "heuristic", false, false, true, true, kMinHeuGcIntervalNs, initHeuTriggerTimestamp },
+    { kGCReasonNative, "native_alloc", false, false, true, true, kMinAsyncGcIntervalNs, initNativeTriggerTimestamp },
+    { kGCReasonHeuBlocking, "heuristic_blocking", false, true, false, true, 0, 0 },
+    { kGCReasonNativeBlocking, "native_alloc_blocking", false, true, false, true, 0, 0 },
+};
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collector/gc_reference_processor.cpp b/src/mrt/compiler-rt/src/collector/gc_reference_processor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53b708f20863656203d1b259cd8972066b4306e3
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/gc_reference_processor.cpp
@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/gc_reference_processor.h"
+#include "yieldpoint.h"
+#include "chosen.h"
+
+namespace maplert {
+GCReferenceProcessor::GCReferenceProcessor() : ReferenceProcessor() {
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; ++type) {
+    refContext[type].discoverRefs = 0;
+    refContext[type].enqueueRefs = 0;
+    refContext[type].discoverCount = 0;
+    refContext[type].enqueueCount = 0;
+  }
+}
+
+bool GCReferenceProcessor::ShouldStartIteration() {
+  if (processAllRefs.load()) {
+    processAllRefs.store(false);
+    return true;
+  }
+  if (hasBackgroundGC.load()) {
+    return true;
+  }
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; ++type) {
+    if (refContext[type].enqueueRefs != 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void GCReferenceProcessor::VisitGCRoots(RefVisitor &visitor) {
+  ReferenceProcessor::VisitGCRoots(visitor);
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; ++type) {
+    GCRefContext &ctx = refContext[type];
+    if (ctx.enqueueRefs != 0) {
+      visitor(ctx.enqueueRefs);
+    }
+  }
+}
+
+inline void SetNextReference(address_t next, address_t reference) {
+  if (next == 0) {
+    ReferenceSetPendingNext(reference, reference);
+  } else {
+    ReferenceSetPendingNext(reference, next);
+  }
+}
+
+void GCReferenceProcessor::DiscoverReference(address_t reference) {
+  MClass *klass = reinterpret_cast<MObject*>(reference)->GetClass();
+  uint32_t classFlag = klass->GetFlag();
+  uint32_t type = ReferenceProcessor::GetRPTypeByClassFlag(classFlag);
+  GCRefContext &ctx = refContext[type];
+  {
+    LockGuard guard(ctx.discoverLock);
+    if (ReferenceGetPendingNext(reference) != 0) { // avoid multiple threads racing discover
+      return;
+    }
+    address_t head = ctx.discoverRefs;
+    SetNextReference(head, reference);
+    ctx.discoverRefs = reference;
+    ++(ctx.discoverCount);
+  }
+}
+
+// Concurrently remove reference with null or marked referent, save STW processing time
+// 1. Lock discover ref and retrive whole list
+// 2. start with prev and cur reference, always record the head and tail
+// 3. Iterate and remove reference whose referent is null or marked
+// 4. Merge discovered list back to context
+void GCReferenceProcessor::ConcurrentProcessDisovered() {
+  Collector &collector = Collector::Instance();
+  __MRT_ASSERT(collector.IsConcurrentMarkRunning(), "Not In Concurrent marking");
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; ++type) {
+    GCRefContext &ctx = refContext[type];
+    address_t prev = 0;
+    address_t cur;
+    address_t head;
+    uint32_t removedCount = 0;
+    {
+      LockGuard guard(ctx.discoverLock);
+      head = ctx.discoverRefs;
+      cur = ctx.discoverRefs;
+      ctx.discoverRefs = 0;
+    }
+    while (cur != 0) {
+      address_t referent = ReferenceGetReferent(cur);
+      address_t next = ReferenceGetPendingNext(cur);
+      if (next == cur) {
+        next = 0;
+      }
+      if (referent == 0 || !collector.IsGarbage(referent)) {
+        ++removedCount;
+        if (prev == 0) {
+          head = next;
+        } else {
+          SetNextReference(next, prev);
+        }
+        ReferenceSetPendingNext(cur, 0);
+      } else {
+        prev = cur;
+      }
+      if (next == 0) {
+        break;
+      }
+      cur = next;
+    }
+    if (head != 0) {
+      LockGuard guard(ctx.discoverLock);
+      address_t curHead = ctx.discoverRefs;
+      ctx.discoverRefs = head;
+      if (curHead != 0) {
+        ReferenceSetPendingNext(cur, curHead);
+      }
+    }
+    if (removedCount > 0) {
+      LOG2FILE(kLogtypeGc) << "ConcurrentProcessDisovered clear " << type << " " << removedCount << std::endl;
+    }
+  }
+}
+
+void GCReferenceProcessor::InitEnqueueAtFork(uint32_t type, address_t refs) {
+  __MRT_ASSERT(type <= kRPPhantomRef, "Invalid type");
+  GCRefContext &ctx = refContext[type];
+  __MRT_ASSERT(ctx.enqueueRefs == 0, "not zero at fork");
+  ctx.enqueueRefs = refs;
+}
+
+// Iterate discoverd Reference:
+// 1. check if it can be enqueued, referent is not null and dead
+// 2. If enqueuable, add into enqueueRefs
+// 3. Otherwise, clear pending next
+// 4. clear discoveredref
+void GCReferenceProcessor::ProcessDiscoveredReference(uint32_t flags) {
+  __MRT_ASSERT(WorldStopped(), "Not In STW");
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; type++) {
+    if (!(flags & RPMask(type))) {
+      continue;
+    }
+    GCRefContext &ctx = refContext[type];
+    address_t reference = ctx.discoverRefs;
+    while (reference != 0) {
+      address_t referent = ReferenceGetReferent(reference);
+      address_t next = ReferenceGetPendingNext(reference);
+      if (next == reference) {
+        next = 0;
+      }
+      // must be in heap or cleared during concurrent mark
+      if (referent != 0 && Collector::Instance().IsGarbage(referent)) {
+        ReferenceClearReferent(reference);
+        SetNextReference(ctx.enqueueRefs, reference);
+        ctx.enqueueRefs = reference;
+        ++(ctx.enqueueCount);
+      } else {
+        ReferenceSetPendingNext(reference, 0);
+      }
+      reference = next;
+    }
+    ctx.discoverRefs = 0;
+    ctx.discoverCount = 0;
+  }
+}
+
+// Iterate enqueued Reference:
+// 1. Leave Safe Region, avoid GC STW modify enqueueRefs
+// 2. Check if available enqueueRefs, break if empty
+// 3. Get Reference to proceess and update enqueueRefs
+// 4. Invoke Enqueu method
+void GCReferenceProcessor::EnqeueReferences() {
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; ++type) {
+    GCRefContext &ctx = refContext[type];
+    // iterate all reference and invoke enqueue method, might racing with GC STW phase
+    while (true) {
+      ScopedObjectAccess soa; // leave safe region to sync with GC
+      if (ctx.enqueueRefs == 0) {
+        break;
+      }
+      ScopedHandles sHandles;
+      ObjHandle<MObject, false> reference(ctx.enqueueRefs);
+      address_t next = ReferenceGetPendingNext(reference.AsRaw());
+      __MRT_ASSERT(next != 0 && ReferenceGetReferent(reference.AsRaw()) == 0, "Invalid pending enqueue reference");
+      if (next == reference.AsRaw()) {
+        next = 0;
+      } else {
+        TLMutator().SatbWriteBarrier(next);
+      }
+      ReferenceSetPendingNext(reference.AsRaw(), reference.AsRaw());
+      --(ctx.enqueueCount);
+      ctx.enqueueRefs = next;
+      Enqueue(reference.AsRaw());
+    }
+  }
+}
+
+void GCReferenceProcessor::LogRefProcessorBegin() {
+  if (!GCLog().IsWriteToFile(kLogtypeRp)) {
+    return;
+  }
+  timeCurrentRefProcessBegin = timeutils::MicroSeconds();
+  LOG2FILE(kLogtypeRp) << "[RefProcessor] Begin (" << timeutils::GetDigitDate() << ") Soft: " <<
+      refContext[kRPSoftRef].enqueueCount <<
+      " Weak " << refContext[kRPWeakRef].enqueueCount <<
+      " Phantom " << refContext[kRPPhantomRef].enqueueCount << std::endl;
+}
+
+void GCReferenceProcessor::LogRefProcessorEnd() {
+  if (!GCLog().IsWriteToFile(kLogtypeRp)) {
+    return;
+  }
+  uint64_t timeNow = timeutils::MicroSeconds();
+  uint64_t timeConsumed = timeNow - timeCurrentRefProcessBegin;
+  uint64_t totalTimePassed = timeNow - timeRefProcessorBegin;
+  timeRefProcessUsed += timeConsumed;
+  float percentage = ((maple::kTimeFactor * timeRefProcessUsed) / totalTimePassed) / kPercentageDivend;
+  LOG2FILE(kLogtypeRp) << "[RefProcessor] End " << " (" << timeConsumed << "us" <<
+      " [" << timeRefProcessUsed << "us]" <<
+      " [ " << percentage << "%]" << std::endl;
+}
+
+void GCReferenceProcessor::PreAddFinalizables(address_t[], uint32_t, bool needLock) {
+  if (needLock) {
+    finalizersLock.lock();
+  }
+}
+
+void GCReferenceProcessor::PostAddFinalizables(address_t[], uint32_t, bool needLock) {
+  if (needLock) {
+    finalizersLock.unlock();
+  }
+}
+}
diff --git a/src/mrt/compiler-rt/src/collector/mpl_thread_pool.cpp b/src/mrt/compiler-rt/src/collector/mpl_thread_pool.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..de9f665e8cc7e96ff30466a7f1e4d89c2ea400f1
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/mpl_thread_pool.cpp
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/mpl_thread_pool.h"
+
+#include <sys/time.h>
+#include <syscall.h>
+#include <sys/resource.h>
+#include <sched.h>
+
+#include "securec.h"
+#include "base/logging.h"
+#include "chosen.h"
+
+// thread pool implementation
+namespace maplert {
+MplPoolThread::MplPoolThread(MplThreadPool *threadPool, const char *threadName, size_t threadId, size_t stackSize)
+    : schedCores(nullptr),
+      id(threadId),
+      tid(-1),
+      name(threadName),
+      pool(threadPool) {
+  pthread_attr_t attr;
+  CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "");
+  CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stackSize), stackSize);
+  CHECK_PTHREAD_CALL(pthread_create, (&pthread, nullptr, &WorkerFunc, this), "MplPoolThread init");
+  CHECK_PTHREAD_CALL(pthread_setname_np, (pthread, threadName), "MplPoolThread SetName");
+  CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "MplPoolThread init");
+}
+
+MplPoolThread::~MplPoolThread() {
+  CHECK_PTHREAD_CALL(pthread_join, (pthread, nullptr), "thread deinit");
+  schedCores = nullptr;
+  pool = nullptr;
+}
+
+void MplPoolThread::SetPriority(int32_t priority) {
+  int32_t result = setpriority(static_cast<int>(PRIO_PROCESS), tid, priority);
+  if (result != 0) {
+    LOG(ERROR) << "Failed to setpriority to :" << priority;
+  }
+}
+
+void *MplPoolThread::WorkerFunc(void *param) {
+  // set current thread as a gc thread.
+  (void)maple::tls::CreateTLS();
+  StoreTLS(reinterpret_cast<void*>(true), maple::tls::kSlotIsGcThread);
+
+  MplPoolThread *thread = reinterpret_cast<MplPoolThread*>(param);
+  MplThreadPool *pool = thread->pool;
+
+  thread->tid = maple::GetTid();
+  MRT_SetThreadPriority(thread->tid, pool->priority);
+
+  while (!pool->IsExited()) {
+    MplTask *task = nullptr;
+    {
+      std::unique_lock<std::mutex> taskLock(pool->taskMutex);
+      // hang up in threadSleepingCondVar when pool stopped or to many active thread
+      while (((pool->currActiveThreadNum > pool->maxActiveThreadNum) || !pool->IsRunning()) && !pool->IsExited()) {
+        // currActiveThreadNum start at maxThreadNum, dec before thread hangup in sleeping state
+        --(pool->currActiveThreadNum);
+        if (pool->currActiveThreadNum == 0) {
+          // all thread sleeping, pool in stop state, notify wait stop thread
+          pool->allThreadStopped.notify_all();
+        }
+        pool->threadSleepingCondVar.wait(taskLock);
+        ++(pool->currActiveThreadNum);
+      }
+      // if no task available thread hung up in taskEmptyCondVar
+      while (pool->taskQueue.empty() && pool->IsRunning() && !pool->IsExited()) {
+        // currExecuteThreadNum start at 0, inc before thread wait for task
+        ++(pool->currWaittingThreadNum);
+        if (pool->currWaittingThreadNum == pool->maxActiveThreadNum) {
+          // all task is done, notify wait finish thread
+          pool->allWorkDoneCondVar.notify_all();
+        }
+        pool->taskEmptyCondVar.wait(taskLock);
+        --(pool->currWaittingThreadNum);
+      }
+      if (!pool->taskQueue.empty() && pool->IsRunning() && !pool->IsExited()) {
+        task = pool->taskQueue.front();
+        pool->taskQueue.pop();
+      }
+    }
+    if (task != nullptr) {
+      if (thread->schedCores != nullptr) {
+        thread->schedCores->push_back(sched_getcpu());
+      }
+      task->Execute(thread->id);
+      delete task;
+    }
+  }
+  {
+    std::unique_lock<std::mutex> taskLock(pool->taskMutex);
+    --(pool->currActiveThreadNum);
+    if (pool->currActiveThreadNum == 0) {
+      // all thread sleeping, pool in stop state, notify wait stop thread
+      pool->allThreadStopped.notify_all();
+    }
+  }
+  maple::tls::DestoryTLS();
+  return nullptr;
+}
+
+const int kMaxNameLen = 256;
+
+MplThreadPool::MplThreadPool(const char *poolName, int32_t threadNum, int32_t prior)
+    : priority(prior),
+      name(poolName),
+      running(false),
+      exit(false),
+      maxThreadNum(threadNum),
+      maxActiveThreadNum(threadNum),
+      currActiveThreadNum(maxThreadNum),
+      currWaittingThreadNum(0) {
+  // init and start thread
+  char threadName[kMaxNameLen];
+  for (int32_t i = 0; i < maxThreadNum; ++i) {
+    // threadID 0 is main thread, sub threadID start at 1
+    errno_t ret = snprintf_s(threadName, kMaxNameLen, (kMaxNameLen - 1), "Pool%s_%d", poolName, (i + 1));
+    if (ret < 0) {
+      LOG(ERROR) << "snprintf_s " << "name = " << name << "threadId" << (i + 1) <<
+          " in MplThreadPool::MplThreadPool return " << ret << " rather than 0." << maple::endl;
+    }
+    // default Sleeping
+    MplPoolThread *threadItem = new (std::nothrow) MplPoolThread(this, threadName, (i + 1), kDefaultStackSize);
+    if (threadItem == nullptr) {
+      LOG(FATAL) << "new MplPoolThread failed" << maple::endl;
+    }
+    threads.push_back(threadItem);
+  }
+  // pool init in stop state
+  Stop();
+  LOG(DEBUGY) << "MplThreadPool init" << maple::endl;
+}
+
+void MplThreadPool::Exit() {
+  std::unique_lock<std::mutex> taskLock(taskMutex);
+  // set pool exit flag
+  exit.store(true, std::memory_order_relaxed);
+
+  // notify all waitting thread exit
+  taskEmptyCondVar.notify_all();
+  // notify all stopped thread exit
+  threadSleepingCondVar.notify_all();
+
+  // notify all WaitFinish thread return
+  allWorkDoneCondVar.notify_all();
+  // notify all WaitStop thread return
+  allThreadStopped.notify_all();
+  LOG(DEBUGY) << "MplThreadPool Exit" << maple::endl;
+}
+
+MplThreadPool::~MplThreadPool() {
+  Exit();
+  // wait until threads exit
+  for (auto thread : threads) {
+    delete thread;
+  }
+  threads.clear();
+  ClearAllTask();
+}
+
+void MplThreadPool::SetPriority(int32_t prior) {
+  for (auto thread : threads) {
+    thread->SetPriority(prior);
+  }
+}
+
+void MplThreadPool::SetMaxActiveThreadNum(int32_t num) {
+  std::unique_lock<std::mutex> taskLock(taskMutex);
+  int32_t oldNum = maxActiveThreadNum;
+  if (num >= maxThreadNum) {
+    maxActiveThreadNum = maxThreadNum;
+  } else if (num > 0) {
+    maxActiveThreadNum = num;
+  } else {
+    LOG(ERROR) << "SetMaxActiveThreadNum invalid input val" << maple::endl;;
+    return;
+  }
+  // active more thread get to work when pool is running
+  if ((maxActiveThreadNum > oldNum) && (currWaittingThreadNum > 0) && IsRunning()) {
+    threadSleepingCondVar.notify_all();
+  }
+}
+
+void MplThreadPool::AddTask(MplTask *task) {
+  if (UNLIKELY(task == nullptr)) {
+    LOG(FATAL) << "failed to add a null task" << maple::endl;
+  }
+  std::unique_lock<std::mutex> taskLock(taskMutex);
+  taskQueue.push(task);
+  // do not notify when pool isn't running, notify_all in start
+  // notify if there is active thread waiting for task
+  if (IsRunning() && (currWaittingThreadNum > 0)) {
+    taskEmptyCondVar.notify_one();
+  }
+}
+
+void MplThreadPool::AddTask(std::function<void(size_t)> func) {
+  AddTask(new (std::nothrow) MplLambdaTask(func));
+}
+
+void MplThreadPool::Start() {
+  // notify all sleeping threads get to work
+  std::unique_lock<std::mutex> taskLock(taskMutex);
+  running.store(true, std::memory_order_relaxed);
+  threadSleepingCondVar.notify_all();
+}
+
+void MplThreadPool::DrainTaskQueue() {
+  __MRT_ASSERT(!IsRunning(), "thread pool is running");
+  MplTask *task = nullptr;
+  do {
+    task = nullptr;
+    taskMutex.lock();
+    if (!taskQueue.empty()) {
+      task = taskQueue.front();
+      taskQueue.pop();
+    }
+    taskMutex.unlock();
+    if (task != nullptr) {
+      task->Execute(0);
+      delete task;
+    }
+  } while (task != nullptr);
+}
+
+void MplThreadPool::WaitFinish(bool addToExecute, std::vector<int32_t> *schedCores) {
+  if (addToExecute) {
+    MplTask *task = nullptr;
+    do {
+      task = nullptr;
+      taskMutex.lock();
+      if (!taskQueue.empty() && IsRunning() && !IsExited()) {
+        task = taskQueue.front();
+        taskQueue.pop();
+      }
+      taskMutex.unlock();
+      if (task != nullptr) {
+        if (schedCores != nullptr) {
+          schedCores->push_back(sched_getcpu());
+        }
+        task->Execute(0);
+        delete task;
+      }
+    } while (task != nullptr);
+  }
+
+  // wait all task excute finish
+  // currWaittingThreadNum == maxActiveThreadNum indicate all work done
+  // no need to wait when pool stopped or exited
+  {
+    std::unique_lock<std::mutex> taskLock(taskMutex);
+    while ((currWaittingThreadNum != maxActiveThreadNum) && IsRunning() && !IsExited()) {
+      allWorkDoneCondVar.wait(taskLock);
+    }
+  }
+  // let all thread sleeing for next start
+  // if threads not in sleeping mode, next start signal may be missed
+  Stop();
+  // clean up task in GC thread, thread pool might receive "exit" in stop thread
+  DrainTaskQueue();
+}
+
+void MplThreadPool::Stop() {
+  // notify & wait all thread enter stopped state
+  std::unique_lock<std::mutex> taskLock(taskMutex);
+  running.store(false, std::memory_order_relaxed);
+  taskEmptyCondVar.notify_all();
+  while (currActiveThreadNum != 0) {
+    allThreadStopped.wait(taskLock);
+  }
+}
+
+void MplThreadPool::ClearAllTask() {
+  std::unique_lock<std::mutex> taskLock(taskMutex);
+  while (!taskQueue.empty()) {
+    MplTask *task = taskQueue.front();
+    taskQueue.pop();
+    delete task;
+  }
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collector/mrt_bitmap.cpp b/src/mrt/compiler-rt/src/collector/mrt_bitmap.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4ce4694c1fd4503750fe2307c1a2055e98f7f13a
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/mrt_bitmap.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/mrt_bitmap.h"
+
+#include "chosen.h"
+#include "syscall.h"
+
+namespace maplert {
+// round value up to alignValue which must be a power of 2.
+ALWAYS_INLINE uint32_t MrtBitmap::AlignRight(uint32_t value, uint32_t alignValue) const noexcept {
+  return (value + alignValue - 1) & ~(alignValue - 1);
+}
+
+void MrtBitmap::ResetCurEnd() {
+  curEnd = spaceStart + (*theAllocator).GetCurrentSpaceCapacity();
+  LOG2FILE(kLogtypeGc) << "resetCurEnd Bitmap " << std::hex << spaceStart << " " << curEnd << std::dec << '\n';
+}
+
+ALWAYS_INLINE size_t MrtBitmap::GetBitmapSizeByHeap(size_t heapBytes) {
+  size_t nBytes;
+  size_t nBits;
+
+  if ((heapBytes & ((static_cast<uint32_t>(1) << kLogObjAlignment) - 1)) == 0) {
+    nBits = heapBytes >> kLogObjAlignment;
+  } else {
+    nBits = (heapBytes >> kLogObjAlignment) + 1;
+  }
+
+  nBytes = AlignRight(static_cast<uint32_t>(nBits), kBitsPerWord) >> kLogBitsPerByte;
+  return nBytes;
+}
+
+void MrtBitmap::Initialize() {
+  if (isInitialized) {
+    return;
+  }
+
+  size_t maxHeapBytes = (*theAllocator).GetMaxCapacity();
+  spaceStart = (*theAllocator).HeapLowerBound();
+  spaceEnd = spaceStart + maxHeapBytes;
+  curEnd = spaceStart + (*theAllocator).GetCurrentSpaceCapacity();
+
+  bitmapSize = GetBitmapSizeByHeap(maxHeapBytes);
+  size_t roundUpPage = AlignRight(static_cast<uint32_t>(bitmapSize), maple::kPageSize);
+  void *ret = mmap(nullptr, roundUpPage, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (ret == MAP_FAILED) {
+    LOG(FATAL) << "maple failed to initialize MrtBitmap";
+  } else {
+    MRT_PRCTL(ret, roundUpPage, "MrtBitmap_Initialize");
+  }
+
+  bitmapBegin = reinterpret_cast<atomic<uint32_t>*>(ret);
+  isInitialized = true;
+  LOG2FILE(kLogtypeGc) << "Initialize Bitmap " << std::hex << spaceStart << " " << curEnd << std::dec << '\n';
+  size_t curBitmapSize = GetBitmapSizeByHeap(curEnd - spaceStart);
+  if (memset_s(reinterpret_cast<void*>(bitmapBegin), curBitmapSize, 0, curBitmapSize) != EOK) {
+    LOG(FATAL) << "MrtBitmap init memset_s failed." << maple::endl;
+  }
+}
+
+MrtBitmap::~MrtBitmap() {
+  if (munmap(bitmapBegin, AlignRight(static_cast<uint32_t>(bitmapSize), maple::kPageSize)) != EOK) {
+    LOG(ERROR) << "munmap error in MrtBitmap destruction!" << maple::endl;
+  }
+  bitmapBegin = nullptr;
+}
+
+#if MRT_DEBUG_BITMAP
+void MrtBitmap::CopyBitmap(const MrtBitmap &bitmap) {
+  if (bitmapBegin != nullptr) {
+    if (munmap(bitmapBegin, AlignRight(bitmapSize, maple::kPageSize)) != 0) {
+      LOG(FATAL) << "munmap error in copy bitmap";
+    }
+    bitmapBegin = nullptr;
+  }
+  isInitialized = bitmap.Initialized();
+  bitmapSize = bitmap.Size();
+  if (isInitialized) {
+    void *result = mmap(nullptr, AlignRight(bitmapSize, maple::kPageSize),
+                        PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (result == MAP_FAILED) {
+      LOG(FATAL) << "mmap(" << bitmapSize << ") failed in copy bitmap";
+    }
+    bitmapBegin = reinterpret_cast<atomic<uint32_t>*> (result);
+    if (memcpy_s(bitmapBegin, bitmapSize, bitmap.bitmapBegin, bitmapSize) != EOK) {
+      LOG(ERROR) << "memcpy_s error in copy bitmap";
+    }
+  }
+}
+#endif
+}
diff --git a/src/mrt/compiler-rt/src/collector/native_gc.cpp b/src/mrt/compiler-rt/src/collector/native_gc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fc702911f01d99a9fb7c73123dfcaed1ca61ea15
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/native_gc.cpp
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/native_gc.h"
+
+#include <malloc.h>
+#include <sys/stat.h>
+
+#include "panic.h"
+#include "chosen.h"
+#include "collector/stats.h"
+
+namespace maplert {
+NativeGCStats NativeGCStats::instance;
+
+size_t NativeGCStats::GetNativeBytes() {
+  struct mallinfo mi = mallinfo();
+  constexpr bool kMallocBytesNeedCast = (sizeof(size_t) > sizeof(mi.uordblks));
+  constexpr bool kMappedBytesNeedCast = (sizeof(size_t) > sizeof(mi.hblkhd));
+  size_t mallocBytes = kMallocBytesNeedCast ? static_cast<uint32_t>(mi.uordblks) : mi.uordblks;
+  size_t mappedBytes = kMappedBytesNeedCast ? static_cast<uint32_t>(mi.hblkhd) : mi.hblkhd;
+  if (UNLIKELY(mappedBytes > mallocBytes)) {
+    mallocBytes = mappedBytes;
+  }
+  return mallocBytes + nativeBytesRegistered.load(std::memory_order_relaxed);
+}
+
+void NativeGCStats::CheckForGC() {
+  if (Collector::Instance().IsGcTriggered()) {
+    // skip native gc check if gc already triggered.
+    return;
+  }
+  const size_t currentNativeBytes = GetNativeBytes();
+  const float factor = NativeGcFactor(currentNativeBytes);
+  if (LIKELY(factor < kTriggerNativeGcFactor)) {
+    return;
+  }
+  bool wait = (factor > kWaitNativeGcFactor && currentNativeBytes > kHugeNativeBytes) &&
+      (!Collector::Instance().InStartupPhase()) &&
+      Collector::Instance().InJankImperceptibleProcessState();
+  LOG2FILE(kLogtypeGc) << "Trigger native GC" << (wait ? " and wait," : ",") << " factor: " << factor << '\n' <<
+      "  old native: " << oldNativeBytesAllocated.load(std::memory_order_relaxed) << '\n' <<
+      "  cur native: " << currentNativeBytes << '\n' <<
+      "  cur heap  : " << stats::gcStats->CurAllocBytes() << '\n' <<
+      "  threshold : " << stats::gcStats->CurGCThreshold() << '\n' <<
+      "  reg bytes : " << nativeBytesRegistered.load(std::memory_order_relaxed) << '\n' <<
+      "  notif objs: " << nativeObjectNotified.load(std::memory_order_relaxed) << '\n' <<
+      std::endl;
+  if (wait) {
+    Collector::Instance().InvokeGC(kGCReasonNativeBlocking);
+  } else {
+    Collector::Instance().InvokeGC(kGCReasonNative);
+  }
+}
+
+static inline size_t NativeGcWatermark() {
+  const size_t heapGcThreshold = stats::gcStats->CurGCThreshold();
+  return heapGcThreshold / NativeGCStats::kNativeWatermarkFactor +
+         NativeGCStats::kNativeWatermarkExtra;
+}
+
+static inline double MemoryGrowthRate() {
+  return Collector::Instance().InJankImperceptibleProcessState() ? NativeGCStats::kBackgroundGrowthRate :
+      NativeGCStats::kFrontgroundGrowthRate;
+}
+
+float NativeGCStats::NativeGcFactor(size_t currentNativeBytes) {
+  const size_t oldNativeBytes = oldNativeBytesAllocated.load(std::memory_order_relaxed);
+  if (oldNativeBytes > currentNativeBytes) {
+    oldNativeBytesAllocated.store(currentNativeBytes, std::memory_order_relaxed);
+    return kSkipNativeGcFactor;
+  }
+  const size_t newNativeBytes = currentNativeBytes - oldNativeBytes;
+  const size_t weightedNativeBytes = (newNativeBytes * NativeDiscountRatio::num / NativeDiscountRatio::den) +
+                                     (oldNativeBytes / kOldDiscountFactor);
+  const size_t watermarkNativeBytes =
+      static_cast<size_t>(NativeGcWatermark() * MemoryGrowthRate()) *
+      NativeDiscountRatio::num / NativeDiscountRatio::den;
+  const size_t currentHeapBytes = stats::gcStats->CurAllocBytes();
+  const size_t heapGcThreshold = stats::gcStats->CurGCThreshold();
+  return static_cast<float>(currentHeapBytes + weightedNativeBytes) /
+         static_cast<float>(heapGcThreshold + watermarkNativeBytes);
+}
+
+NativeEpochStats NativeEpochStats::instance;
+
+void NativeEpochStats::Init(uint32_t epochSeconds) {
+  epochInterval = static_cast<uint32_t>((epochSeconds * kEpochSecondRatio) / MrtRpEpochIntervalMs());
+  logNativeInfo = VLOG_IS_ON(opennativelog);
+  curGCWatermark = NativeGCStats::Instance().GetNativeBytes();
+  curRPWatermark = curGCWatermark;
+  epochMin = epochMax = epochTotal = curGCWatermark;
+  curEpochIndex = 1;
+  RPTriggered = false;
+
+  if (logNativeInfo) {
+    LOG(INFO) << "FigoNativeMEpoch Init " << " Interval " << curEpochIndex <<
+        " GC WaterMark " << curGCWatermark <<
+        " GC WaterMark " << curRPWatermark <<
+        maple::endl;
+  }
+}
+
+static inline float BytesToMB(size_t bytes) {
+  return (bytes * 1.0f) / maple::MB;
+}
+
+// Check and record current native meomory
+void NativeEpochStats::CheckNativeGC() {
+  size_t curNativeBytes = NativeGCStats::Instance().GetNativeBytes();
+  if (++curEpochIndex == epochInterval) {
+    if (logNativeInfo) {
+      LOG(INFO) << "FigoNativeMEpoch " << curEpochIndex << "[" << BytesToMB(epochMin) << ", " <<
+          BytesToMB(epochMax) << ", " << (BytesToMB(epochTotal) / epochInterval) << "] " <<
+          "[" << BytesToMB(curGCWatermark) << ", " << BytesToMB(curRPWatermark) << "] " << maple::endl;
+    }
+    if (epochMin > (curGCWatermark * kEpochGCDeltaRatio)) {
+      if (RPTriggered || (epochMin > (curGCWatermark * kEpochGCEagerDeltaRatio))) {
+        LOG2FILE(kLogtypeGc) << "EpochMin " << BytesToMB(epochMin) << " cur " << BytesToMB(curGCWatermark) << std::endl;
+        MRT_TriggerGC(kGCReasonNative);
+        curGCWatermark = epochMin;
+      } else {
+        ReferenceProcessor::Instance().Notify(true);
+        curRPWatermark = epochMin;
+        RPTriggered = true;
+      }
+    } else if (epochMin > (curRPWatermark * kEpochRPDeltaRatio)) {
+      ReferenceProcessor::Instance().Notify(true);
+      curRPWatermark = epochMin;
+    } else {
+      RPTriggered = false;
+    }
+    if (epochMin < curGCWatermark) {
+      if (logNativeInfo) {
+        LOG(INFO) << "New watermark " << BytesToMB(curGCWatermark) << " To " << BytesToMB(epochMin) << maple::endl;
+      }
+      curGCWatermark = epochMin;
+    }
+    if (epochMin < curRPWatermark) {
+      if (logNativeInfo) {
+        LOG(INFO) << "New RP watermark " << BytesToMB(curRPWatermark) << " To " << BytesToMB(epochMin) << maple::endl;
+      }
+      curRPWatermark = epochMin;
+    }
+    epochTotal = curNativeBytes;
+    epochMax = curNativeBytes;
+    epochMin = curNativeBytes;
+    curEpochIndex = 0;
+  } else {
+    if (logNativeInfo) {
+      epochTotal += curNativeBytes;
+      if (curNativeBytes > epochMax) {
+        epochMax = curNativeBytes;
+      }
+    }
+    if (curNativeBytes < epochMin) {
+      epochMin = curNativeBytes;
+    }
+  }
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collector/rc_reference_processor.cpp b/src/mrt/compiler-rt/src/collector/rc_reference_processor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df511924fe22881bf34919fd96075976e39ec0d9
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/rc_reference_processor.cpp
@@ -0,0 +1,1224 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/rc_reference_processor.h"
+
+#include <unordered_map>
+
+#include "chosen.h"
+#include "yieldpoint.h"
+#include "collector/native_gc.h"
+
+namespace maplert {
+constexpr uint64_t kRPLogBufSize = 256;
+#if CONFIG_JSAN
+constexpr uint32_t kRCEpochIntervalMs = 50;
+#else
+constexpr uint32_t kRCEpochIntervalMs = 773;
+#endif
+
+namespace {
+// (default) Parameters to control (how fast) the references are processed
+// {WeakRef, SoftRef, PhantomRefAndCleaner, Finalier, WeakGRT, ReleaseQueue}
+// WeakGRT is processed every time, useless now.
+uint32_t referenceLimit[kRPTypeNum] = { 50, 100, 100, 20, 0, 40 };
+// slow-down factor for low-speed tasks, ~6min
+uint32_t agedReferenceLimit[kRPTypeNum] = { 50, 50, 50, 0, 0, 0 };
+// process all references after hungryLimit runs.
+uint32_t hungryLimit = 100;
+uint32_t agedHungryLimit = 400;
+
+uint64_t referenceProcessorCycles = 0;
+uint64_t curRpIndex = 0;
+
+const char *kRefTypeMnemonics[kRPTypeNum] = {
+    "WeakRef", "SoftRef", "PhantomRef", "Finalizer", "WeakGRT", "ReleaseQueue",
+};
+}
+
+
+constexpr uint32_t kPendingFinalizeEpochMS = 8000; // ms between pending finalize processing
+constexpr uint32_t kPendingFinalizerRpCount = (kPendingFinalizeEpochMS / kRCEpochIntervalMs) + 1;
+
+static void LogReferenceFrequencies() {
+  if (!GCLog().IsWriteToFile(kLogtypeRp)) {
+    return;
+  }
+  LOG2FILE(kLogtypeRp) << "[RefProcessor] Read Frequencies from File: " << std::endl;
+  LOG2FILE(kLogtypeRp) << "               refLimit: ";
+  for (uint32_t i = 0; i < kRPTypeNum; i++) {
+    LOG2FILE(kLogtypeRp) << kRefTypeMnemonics[i] << "[" << referenceLimit[i] << "] ";
+  }
+  LOG2FILE(kLogtypeRp) << std::endl;
+  LOG2FILE(kLogtypeRp) << "               agedRefLimit: ";
+  for (uint32_t i = 0; i < kRPTypeNum; i++) {
+    LOG2FILE(kLogtypeRp) << kRefTypeMnemonics[i] << "[" << agedReferenceLimit[i] << "] ";
+  }
+  LOG2FILE(kLogtypeRp) << std::endl;
+  LOG2FILE(kLogtypeRp) << "               agedRefLimit: " << hungryLimit << std::endl;
+}
+
+static void InitReferenceFlags() {
+  LogReferenceFrequencies();
+}
+
+uint32_t MrtRpEpochIntervalMs() {
+  return kRCEpochIntervalMs;
+}
+
+// Aged Reference list structure
+constexpr uint32_t kRefRetireThreshold = 1600;
+// Node for references, with age information
+struct TimedRef {
+  explicit TimedRef(address_t obj) : ref(obj), age(0) {}
+  address_t ref;
+  uint32_t age;
+};
+
+constexpr uint32_t kYoungRefParallelListNum = 4;
+constexpr uint32_t kAgedRefParallelListNum = 8;
+
+// Policy used in reference processing
+std::unique_ptr<SoftReferencePolicy> rpSoftPolicy = std::make_unique<CurrentHeapPolicy>();
+
+// queues and queue-header access lock
+static LockType weakRefLock;
+static ManagedForwardList<TimedRef> weakReferences[kYoungRefParallelListNum]; // for young weakRefs
+static ManagedForwardList<TimedRef> workingWeakRefs;
+static ManagedForwardList<address_t> agedWeakRefs[kAgedRefParallelListNum]; // for aged weakRefs
+
+// SoftReference, PhantomReference
+static LockType softRefLock;
+static ManagedForwardList<TimedRef> softRefs[kYoungRefParallelListNum]; // for young SoftRefs
+static ManagedForwardList<TimedRef> workingSoftRefs;
+static ManagedForwardList<address_t> agedSoftRefs[kAgedRefParallelListNum]; // for aged SoftRefs
+
+// cleaners shared the same queue with phantom refs
+static LockType phantomRefLock;
+static ManagedForwardList<TimedRef> phantomRefs[kYoungRefParallelListNum]; // for young PhantomRefs and Cleaners
+static ManagedForwardList<TimedRef> workingPhantomRefs;
+static ManagedForwardList<address_t> agedPhantomRefs[kAgedRefParallelListNum]; // for aged PhantomRefs and Cleaners
+
+// stats, element in forward_list
+static uint32_t agedWeakCount = 0; // only used in RP thread
+static std::atomic<uint32_t> weakCount = { 0 }; // used in mutator and RP thread, need atomic
+
+static uint32_t agedSoftCount = 0;
+static std::atomic<uint32_t> softCount = { 0 };
+// the count of aged_phantom/phantom, contatined cleaners
+static uint32_t agedPhantomCount = 0;
+static std::atomic<uint32_t> phantomCount = { 0 };
+
+// Context for different reference handling: visit, enqueue, context includes
+// List/count/lock/type
+struct ReferenceContext {
+  ManagedForwardList<TimedRef> (&youngs)[kYoungRefParallelListNum];
+  ManagedForwardList<TimedRef> &working;
+  ManagedForwardList<address_t> (&ages)[kAgedRefParallelListNum];
+  LockType &lock;
+  uint32_t &agedCount;
+  std::atomic<uint32_t> &youngCount;
+};
+
+static ReferenceContext referenceContext[kRPPhantomRef + 1] = {
+    { weakReferences, workingWeakRefs, agedWeakRefs, weakRefLock, agedWeakCount, weakCount },
+    { softRefs, workingSoftRefs, agedSoftRefs, softRefLock, agedSoftCount, softCount },
+    { phantomRefs, workingPhantomRefs, agedPhantomRefs, phantomRefLock, agedPhantomCount, phantomCount }
+};
+
+static void RCVisitReferences(ReferenceContext &context, AddressVisitor &visitor) {
+  for (TimedRef ref : context.working) {
+    visitor(ref.ref);
+  }
+  for (uint32_t i = 0; i < kYoungRefParallelListNum; ++i) {
+    ManagedForwardList<TimedRef> &young = context.youngs[i];
+    for (TimedRef ref : young) {
+      visitor(ref.ref);
+    }
+  }
+  for (uint32_t i = 0; i < kAgedRefParallelListNum; ++i) {
+    ManagedForwardList<address_t> &aged = context.ages[i];
+    for (address_t ref : aged) {
+      visitor(ref);
+    }
+  }
+}
+
+void MrtVisitReferenceRoots(AddressVisitor visitor, uint32_t flags) {
+  if (flags & RPMask(kRPSoftRef)) {
+    RCVisitReferences(referenceContext[kRPSoftRef], visitor);
+  }
+  if (flags & RPMask(kRPPhantomRef)) {
+    RCVisitReferences(referenceContext[kRPPhantomRef], visitor);
+  }
+  if (flags & RPMask(kRPWeakRef)) {
+    RCVisitReferences(referenceContext[kRPWeakRef], visitor);
+  }
+
+  if (flags & RPMask(kRPFinalizer)) {
+    RefVisitor finalizableVisitor = [&visitor](address_t &obj) {
+      visitor(obj);
+    };
+    ReferenceProcessor::Instance().VisitFinalizers(finalizableVisitor);
+  }
+  if (flags & RPMask(kRPReleaseQueue)) {
+    RefVisitor releaseQueueVistor = [&visitor](address_t &obj) {
+      visitor(obj);
+    };
+    RCReferenceProcessor::Instance().VisitAsyncReleaseObjs(releaseQueueVistor);
+  }
+}
+
+// used in gc for process aged generation references
+// remove reference from queue when reference is dead.
+static inline void GCProcessRefs(ManagedForwardList<address_t> &refList, RefVisitor &visitor) {
+  auto itor = refList.begin();
+  while (itor != refList.end()) {
+    address_t &ref = *itor;
+    visitor(ref);
+    ++itor;
+  }
+}
+
+static inline void GCProcessGenRefs(ManagedForwardList<TimedRef>::iterator &begin,
+                                    ManagedForwardList<TimedRef>::iterator &end,
+                                    RefVisitor &visitor) {
+  ManagedForwardList<TimedRef>::iterator &itor = begin;
+  while (itor != end) {
+    TimedRef &ref = *itor;
+    visitor(ref.ref);
+    ++itor;
+  }
+}
+
+// used in gc for process young generation references
+static inline void GCProcessGenRefs(ManagedForwardList<TimedRef> &refList, RefVisitor &visitor) {
+  auto begin = refList.begin();
+  auto end = refList.end();
+  GCProcessGenRefs(begin, end, visitor);
+}
+
+// only used in concurrent mark sweep to process references in non-parallel mode.
+void MRT_GCVisitReferenceRoots(function<void(address_t&)> &visitor, uint32_t flags) {
+  ManagedForwardList<TimedRef>::iterator begins[kYoungRefParallelListNum + 1];
+  ManagedForwardList<TimedRef>::iterator ends[kYoungRefParallelListNum + 1];
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; ++type) {
+    if (!(flags & RPMask(type))) {
+      continue;
+    }
+    ReferenceContext &ctx = referenceContext[type];
+    {
+      LockGuard guard(ctx.lock);
+      for (uint32_t i = 0; i < kYoungRefParallelListNum; ++i) {
+        begins[i] = ctx.youngs[i].begin();
+        ends[i] = ctx.youngs[i].end();
+      }
+      begins[kYoungRefParallelListNum] = ctx.working.begin();
+      ends[kYoungRefParallelListNum] = ctx.working.end();
+    }
+    for (uint32_t i = 0; i <= kYoungRefParallelListNum; ++i) {
+      GCProcessGenRefs(begins[i], ends[i], visitor);
+    }
+    for (uint32_t i = 0; i < kAgedRefParallelListNum; ++i) {
+      GCProcessRefs(ctx.ages[i], visitor);
+    }
+  }
+}
+
+// only used in GC thread to process references in parallel mode.
+// we process softReference & phantomReference & weakReference & cleaner in GC.
+void MRT_ParallelVisitReferenceRoots(MplThreadPool &threadPool, RefVisitor &visitor, uint32_t flags) {
+  std::atomic<uint32_t> taskIndex[kRPPhantomRef + 1];
+  const uint32_t threadCount = static_cast<uint32_t>(threadPool.GetMaxThreadNum() + 1);
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; type++) {
+    if (!(flags & RPMask(type))) {
+      continue;
+    }
+    std::atomic<uint32_t> &index = taskIndex[type];
+    index.store(0);
+    ReferenceContext &ctx = referenceContext[type];
+    for (uint32_t i = 0; i < threadCount; ++i) {
+      threadPool.AddTask(new (std::nothrow) MplLambdaTask([&index, &ctx, &visitor](size_t) {
+        while (true) {
+          uint32_t old = index.fetch_add(1, std::memory_order_relaxed);
+          if (old < kYoungRefParallelListNum) {
+            GCProcessGenRefs(ctx.youngs[old], visitor);
+          } else if (old < (kYoungRefParallelListNum + kAgedRefParallelListNum)) {
+            GCProcessRefs(ctx.ages[old - kYoungRefParallelListNum], visitor);
+          } else if (old == (kYoungRefParallelListNum + kAgedRefParallelListNum)) {
+            GCProcessGenRefs(ctx.working, visitor);
+          } else {
+            return;
+          }
+        }
+      }));
+    }
+  }
+  threadPool.Start();
+  threadPool.WaitFinish(true);
+}
+
+// RC cycle pattern related, cycle pattern load and save
+// 1. MRT_SendCyclePatternJob is invoked when load app cycle pattern, invoked in platform-rt
+// 2. MRT_SetPeriodicSaveCpJob, invoked in platform-rt, set save method, after cycle pattern is
+//    learned, job is set and wait RP thread to process
+// 3. MRT_SetPeriodicLearnCpJob, similar with period save job, but empty now
+static std::atomic_bool hasCPJobs(false);
+static LockType cpJobsLock;
+static std::deque<function<void()>> cpJobs; // cycle pattern jobs
+static bool periodSaveCpJobOn = false;
+static std::function<void()> periodSaveCpJob = []() {};
+
+// Submitting job
+extern "C" void MRT_SendBackgroundGcJob(bool force) {
+  ReferenceProcessor::Instance().NotifyBackgroundGC(force);
+}
+
+extern "C" void MRT_SendCyclePatternJob(function<void()> job) {
+  {
+    std::lock_guard<LockType> lock(cpJobsLock);
+    cpJobs.push_back(std::move(job));
+    hasCPJobs = true;
+  }
+  ReferenceProcessor::Instance().Notify(false);
+}
+
+extern "C" void MRT_SetPeriodicSaveCpJob(std::function<void()> job) {
+  periodSaveCpJob = std::move(job);
+  periodSaveCpJobOn = true;
+}
+
+extern "C" void MRT_SendSaveCpJob() {
+  if (periodSaveCpJobOn) {
+    MRT_SendCyclePatternJob(periodSaveCpJob);
+  }
+}
+
+extern "C" void MRT_SetPeriodicLearnCpJob(std::function<void()> job ATTR_UNUSED) {}
+
+static void runAllCyclePatternJobs() {
+  while (true) {
+    function<void()> job;
+    {
+      std::lock_guard<LockType> lock(cpJobsLock);
+      if (cpJobs.empty()) {
+        hasCPJobs = false;
+        break;
+      }
+      job = cpJobs.front();
+      cpJobs.pop_front();
+    }
+    job();
+  }
+}
+
+static void LogStatsReference(std::unordered_map<MClass*, uint32_t> &countMap, string &&prefix, const uint32_t total) {
+  constexpr uint32_t topClassNumInRefqueue = 10;
+  std::vector<std::pair<MClass*, uint32_t>> vtMap;
+  for (auto iter = countMap.begin(); iter != countMap.end(); ++iter) {
+    vtMap.push_back(std::make_pair(iter->first, iter->second));
+  }
+  std::sort(vtMap.begin(), vtMap.end(),
+      [](const std::pair<MClass*, uint32_t> &x, const std::pair<MClass*, uint32_t> &y) -> bool {
+        return x.second > y.second;
+      });
+  LOG(INFO) << prefix << "'s top reference:" << maple::endl;
+  uint32_t count = 0;
+  uint32_t nullCount = 0;
+  for (auto iter = vtMap.begin(); iter != vtMap.end() && (count < topClassNumInRefqueue); ++iter, ++count) {
+    if (iter->first == nullptr) {
+      nullCount = iter->second;
+      continue;
+    }
+    const char *className = iter->first->GetName();
+    LOG(INFO) << prefix << " " << className << "  count: " << iter->second << "/" << total << maple::endl;
+  }
+  if (nullCount != 0) {
+    LOG(INFO) << prefix << " NULL ref count in " << nullCount << "/" << total << maple::endl;
+  }
+}
+
+// Dump Reference Queue and finalizer hot type information. Only stats kMaxCountInRefqueue reference
+// 1. stats individually for young/aged reference
+// 2. stats referent/fianlizer type
+// 3. find hot types and log
+// Skip processing working as it might modifing during check and it has small impact on entire stats
+// For aged list, it might modifiying while stats here, lock deosn't help.
+static __MRT_UNUSED void StatsReference(const uint32_t type) {
+  constexpr uint32_t maxCountInRefqueue = 4096;
+  ReferenceContext &ctx = referenceContext[type];
+  std::unordered_map<MClass*, uint32_t> refClassCount;
+  uint32_t count = 0;
+  LOG(INFO) << kRefTypeMnemonics[type] << " young size : " << ctx.youngCount <<
+      " aged " << ctx.agedCount << maple::endl;
+  AddressVisitor countReference = [&refClassCount, &count](address_t reference) {
+    if (reference == 0) {
+      return;
+    }
+    ++count;
+    address_t referent = MRT_LoadReferentField(reference,
+        reinterpret_cast<address_t*>(reference + WellKnown::kReferenceReferentOffset));
+    if (referent) {
+      refClassCount[reinterpret_cast<MObject*>(referent)->GetClass()] += 1;
+      MRT_DecRef(referent);
+    } else {
+      refClassCount[NULL] += 1;
+    }
+  };
+  for (uint32_t i = 0; i < kYoungRefParallelListNum && (count < maxCountInRefqueue); ++i) {
+    LockGuard guard(ctx.lock);
+    ManagedForwardList<TimedRef> &young = ctx.youngs[i];
+    for (TimedRef &timedRef : young) {
+      countReference(timedRef.ref);
+      if (count >= maxCountInRefqueue) {
+        break;
+      }
+    }
+  }
+  LogStatsReference(refClassCount, string(kRefTypeMnemonics[type]) + "young", count);
+
+  count = 0;
+  refClassCount.clear();
+  for (uint32_t i = 0; i < kAgedRefParallelListNum && (count < maxCountInRefqueue); ++i) {
+    ManagedForwardList<address_t> &aged = ctx.ages[i];
+    for (address_t ref : aged) {
+      countReference(ref);
+      if (count >= maxCountInRefqueue) {
+        break;
+      }
+    }
+  }
+  LogStatsReference(refClassCount, string(kRefTypeMnemonics[type]) + "aged", count);
+}
+
+#if __MRT_DEBUG
+static atomic<bool> outOfMemoryPrintLock(false);
+void MRT_logRefqueuesSize() {
+  if (outOfMemoryPrintLock.exchange(true) == true) {
+    return;
+  }
+  LOG(INFO) <<  "========log top ref in queues now========" << maple::endl;
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; ++type) {
+    StatsReference(type);
+  }
+  ReferenceProcessor::Instance().LogFinalizeInfo();
+  outOfMemoryPrintLock = false;
+}
+#else
+void MRT_logRefqueuesSize() {}
+#endif // #if __MRT_DEBUG
+
+static uint32_t refAddIndex[kRPPhantomRef + 1] = { 0, 0, 0 };
+void AddNewReference(address_t obj, uint32_t classFlag) {
+  static_assert((kRPWeakRef == 0) && (kRPSoftRef == (kRPWeakRef + 1)) &&
+                (kRPPhantomRef == (kRPSoftRef + 1)), "RP type change");
+  SetObjReference(obj);
+  ScopedObjectAccess soa;
+  // hold a reference here , use a fast version of MRT_IncRef(objaddr);
+  (void)AtomicUpdateRC<1, 0, 0>(obj);
+  uint32_t type = ReferenceProcessor::GetRPTypeByClassFlag(classFlag);
+  ReferenceContext &ctx = referenceContext[type];
+  {
+    LockGuard guard(ctx.lock);
+    uint32_t youngIndex = refAddIndex[type] % kYoungRefParallelListNum;
+    refAddIndex[type] += 1;
+    ctx.youngs[youngIndex].push_front(TimedRef(obj));
+    RCReferenceProcessor::Instance().CountRecent(type);
+  }
+  (void)ctx.youngCount.fetch_add(1, std::memory_order_relaxed);
+}
+
+// Clear Reference and invoke enqueu method
+// 1. leave safe region because it will modify reference and invoke java method
+// 2. clear referent
+// 3. check reference queu and invoke method
+static __attribute__((noinline)) void ClearReferentAndEnqueue(address_t reference) {
+  ScopedObjectAccess soa;
+  if (ReferenceGetReferent(reference)) {
+    MRT_ReferenceClearReferent(reference);
+  }
+  ReferenceProcessor::Enqueue(reference);
+}
+
+enum RefStatus { // the status/result of processing a reference
+  kNothingTodo = 0,
+  kReferentCleared,
+  kPromoteToOld,
+};
+
+static __attribute__((noinline)) RefStatus TryClearReferent(address_t reference, address_t referent,
+                                                            const uint32_t reftype) {
+  if (reftype == kRPWeakGRT) {
+    __MRT_ASSERT(reference == 0, "reference null");
+    return kReferentCleared;
+  }
+  if ((reftype == kRPSoftRef) || (reftype == kRPWeakRef)) {
+    __MRT_ASSERT(reference != 0, "reference not null");
+    // suppose has multiple reference, like WGRT
+    ClearReferentAndEnqueue(reference);
+    return kReferentCleared;
+  }
+  if (reftype == kRPPhantomRef) {
+    __MRT_ASSERT(reference != 0, "reference not null");
+    if (!IsObjFinalizable(referent)) {
+      ClearReferentAndEnqueue(reference);
+      return kReferentCleared;
+    }
+  }
+  return kNothingTodo;
+}
+
+// do weak collection of references according to weak rc
+// referent has local rc in current thread
+static __attribute__((noinline)) RefStatus WeakRCCollection(address_t reference,
+                                                            address_t referent,
+                                                            const uint32_t reftype) {
+  if (IsWeakCollected(referent)) {
+    // weak bit is set
+    return TryClearReferent(reference, referent, reftype);
+  }
+  // If weak RC collect is performed for normal reference, weak grt,
+  // it has racing with muator, so refernt is loaded and Inced to keep operations safe
+  // we need sub delta in cycle pattern match and weak collect bit set.
+  if (AtomicCheckWeakCollectable<false>(referent, 1)) {
+    // success
+    if (IsObjFinalizable(referent)) {
+      ReferenceProcessor::Instance().AddFinalizable(referent, true);
+    } else {
+      NRCMutator().WeakReleaseObj(referent);
+      NRCMutator().DecWeak(referent);
+    }
+    return TryClearReferent(reference, referent, reftype);
+  } else {
+    // fail
+    uint32_t referentRc = GetRCFromRCHeader(RCHeader(referent));
+    if (IsValidForCyclePatterMatch(GCHeader(referent), referentRc - 1)) {
+      if (CycleCollector::TryFreeCycleAtMutator(referent, 1, true)) {
+        return TryClearReferent(reference, referent, reftype);
+      }
+    }
+  }
+  return kNothingTodo;
+}
+
+// try-free weak global references
+void TryFreeWeakGRs() {
+  ScopedObjectAccess soa;
+  ReferenceProcessor::Instance().SetProcessingType(kRPWeakGRT);
+  maple::irtVisitFunc visitor = [&](uint32_t index, address_t obj) {
+    if (!IS_HEAP_OBJ(obj)) {
+      return;
+    }
+    if (WeakRCCollection(0, obj, kRPWeakGRT) == kReferentCleared) {
+      maple::GCRootsVisitor::ClearWeakGRTReference(index, MObject::Cast<MObject>(obj)->AsJobject());
+      RCReferenceProcessor::Instance().CountProcessed();
+    }
+  };
+  maple::GCRootsVisitor::VisitWeakGRTConcurrent(visitor);
+}
+
+static RefStatus ProcessEmptyRef(address_t reference, const uint32_t reftype, bool young){
+  if (reftype == kRPPhantomRef) {
+    // cleaner doesn't have get method, so no load volatile mask
+    address_t collectedReferent = ReferenceGetReferent(reference);
+    if (IS_HEAP_OBJ(collectedReferent)) {
+      // weak collected bit is set, but finalize is not invoked yet
+      if (IsObjFinalizable(collectedReferent)) {
+        return kNothingTodo;
+      }
+      (void)young;
+    }
+  }
+  ClearReferentAndEnqueue(reference);
+  return kReferentCleared;
+}
+
+static RefStatus ProcessMygoteRef(address_t reference){
+  std::atomic<reffield_t> &referentAddr = AddrToLValAtomic<reffield_t>(
+      reinterpret_cast<address_t>(reference + WellKnown::kReferenceReferentOffset));
+  address_t mygoteReferent = referentAddr.load(std::memory_order_acquire);
+  if (mygoteReferent) {
+    return kNothingTodo;
+  } else {
+    ClearReferentAndEnqueue(reference);
+    return kReferentCleared;
+  }
+}
+
+// process a single reference (softRef, phantomeRef)
+// return value:
+//       REFERENT_CLEARED the referent is cleared (reference can be removed now)
+//       kNothingTodo: the reference cannot be removed
+// Note: ref should not be nullptr
+template<bool young>
+static RefStatus ProcessRef(address_t reference, const uint32_t reftype) {
+  if (IsMygoteObj(reference)) {
+    return ProcessMygoteRef(reference);
+  }
+
+  // the reference is dead when rc becomes 1
+  if (CanReleaseObj<-1, 0, 0>(RCHeader(reference)) == kReleaseObject) {
+    MRT_ReferenceClearReferent(reference);
+    return kReferentCleared;
+  }
+
+  address_t referent = MRT_LoadReferentField(reference,
+      reinterpret_cast<address_t*>(reference + WellKnown::kReferenceReferentOffset));
+  if (referent) {
+    // need refactored in moving gc
+    ScopedHandles sHandles;
+    ObjHandle<MObject> referentRef(referent);
+    __MRT_ASSERT(IS_HEAP_ADDR(referent), "off heap referent");
+    // policy may not work, cause of soft hard to become old
+    if (UNLIKELY(reftype == kRPSoftRef && !rpSoftPolicy->ShouldClearSoftRef())) {
+      if (young) {
+        SetReferenceActive(reference);
+      }
+      return kNothingTodo;
+    }
+    if (young && IsReferenceActive(reference)) {
+      // If reference is recently get, skip its processing
+      // avoid reclaim valid weak/soft cache too fast
+      // check after load, make this flag visible after mutator's change
+      // If this load happens later than muator referent load
+      ClearReferenceActive(reference);
+      return kNothingTodo;
+    }
+    // concurrent marking skip reference's referent, make it live in concurrent marking
+    MRT_PreRenewObject(referentRef.AsRaw());
+    if (WeakRCCollection(reference, referent, reftype) == kReferentCleared) {
+      return kReferentCleared;
+    }
+    return kNothingTodo;
+  } else {
+    return ProcessEmptyRef(reference, reftype, young);
+  }
+}
+
+// process aged reference queues: currently only for old-gen queues
+//    i.e., reference with empty referent. This can only be done for old-gen queues
+//    since reference in young-gen queues may not done initialization and set referent yet.
+//    GC may put reference in other readyToRemoveQueue and clean it's referent.
+static void ProcessRefs(ManagedForwardList<address_t> &refList, const uint32_t reftype, uint32_t &agedCount) {
+  auto prev = refList.before_begin();
+  auto itor = refList.begin();
+  while (itor != refList.end()) {
+    ScopedObjectAccess soa; // avoid from being cleared/rc-changed by GC thread
+    address_t reference = *itor;
+    if (reference == 0) {
+      if (Collector::Instance().IsConcurrentMarkRunning()) {
+        // soa is a gc point, before modify the list, check if concurrent mark is running
+        continue;
+      }
+      ++itor;
+      refList.erase_after(prev);
+      --agedCount;
+      continue;
+    }
+    // RC will not moving, only keep it on stack roots
+    ScopedHandles sHandles;
+    ObjHandle<MObject, false> referenceRef(reference);
+    if (ProcessRef<false>(reference, reftype) == kReferentCleared) {
+      // referent is cleared, can now be removed from queue
+      RC_RUNTIME_DEC_REF(reference); // release ownership
+      RCReferenceProcessor::Instance().AddAgedProcessedCount();
+      if (Collector::Instance().IsConcurrentMarkRunning()) {
+        *itor = 0;
+        continue;
+      }
+
+      // now gc will not modify the list, we can safely remove the node
+      ++itor; // increase itor first, since current node will be deleted
+      refList.erase_after(prev);
+      --agedCount;
+    } else {
+      prev = itor;
+      ++itor;
+    }
+  }
+}
+
+// process cleaner, weak-references (in young-generation working queue)
+// return value:
+//       kReferentCleared: zombie field is cleared (reference can be removed now)
+//       kPromoteToOld: reference is old enough to move to old gen queue
+//       kNothingTodo: the reference cannot be removed from queue
+// Note: ref.ref should not be nullptr
+static __attribute__((noinline)) RefStatus ProcessGenRef(TimedRef &ref, const uint32_t reftype) {
+  ++(ref.age);
+  address_t reference = ref.ref;
+  RefStatus status = ProcessRef<true>(reference, reftype);
+  if (status != kNothingTodo) {
+    return status;
+  }
+
+  if (ref.age > kRefRetireThreshold) {
+    return kPromoteToOld;
+  }
+  return kNothingTodo;
+}
+
+// process reference queues in a generational style
+static uint32_t ProcessGenRefs(ManagedForwardList<TimedRef> &refList, ManagedForwardList<address_t> &agedRefList,
+                               const uint32_t reftype, uint32_t &agedCount) {
+  uint32_t removedCount = 0;
+  auto prev = refList.before_begin();
+  auto itor = refList.begin();
+  while (itor != refList.end()) {
+    ScopedObjectAccess soa; // avoid from being cleared/rc-changed by GC thread
+    TimedRef &ref = *itor;
+    address_t reference = ref.ref;
+    if (reference == 0) {
+      if (Collector::Instance().IsConcurrentMarkRunning()) {
+        // soa is a gc point, before modify the list, check if concurrent mark is running
+        continue;
+      }
+      ++itor;
+      refList.erase_after(prev);
+      ++removedCount;
+      continue;
+    }
+    ScopedHandles sHandles;
+    ObjHandle<MObject, false> refRef(reference);
+    RefStatus result = ProcessGenRef(ref, reftype);
+    if (result == kPromoteToOld) {
+      if (Collector::Instance().IsConcurrentMarkRunning()) {
+        continue;
+      }
+      // reference is old enough, move it to aged reference list
+      agedRefList.push_front(reference);
+      ++itor; // increase itor first, since current node will be deleted
+      refList.erase_after(prev);
+      ++agedCount;
+      ++removedCount;
+      // prev doesn't need to update
+    } else if (result == kReferentCleared) {
+      // reference is ready to be removed from the queue
+      RC_RUNTIME_DEC_REF(reference); // release ownership
+      RCReferenceProcessor::Instance().CountProcessed();
+      ++removedCount;
+      if (Collector::Instance().IsConcurrentMarkRunning()) {
+        ref.ref = 0;
+        continue;
+      }
+      ++itor; // increase itor first, since current node will be deleted
+      refList.erase_after(prev);
+    } else { // nothing to do
+      prev = itor;
+      ++itor;
+    }
+  }
+  return removedCount;
+}
+
+extern "C" void *MRT_CLASSINFO(Ljava_2Flang_2Fref_2FReference_3B);
+extern "C" void *MRT_CLASSINFO(Ljava_2Flang_2Fref_2FFinalizerReference_3B);
+
+// used to sync reference-processor and its creator.
+void MRT_WaitProcessReferencesStarted() {
+  ReferenceProcessor::Instance().WaitStarted();
+}
+
+// This method is used in qemu unitest (not invoked from zygote)
+// keep hungryLimit to 1 might keep rp busy and make mutator not running
+extern "C" void MRT_SetReferenceProcessMode(bool immediate) {
+  if (Collector::Instance().Type() != kNaiveRC) {
+    return;
+  }
+  constexpr uint32_t kUnitTestRPWaitTimeMS = 2;
+  constexpr uint32_t kUnitTestRPHungryLimit = 5;
+  constexpr uint32_t kUnitTestRPAgedHungryLimit = 10;
+  bool immediateRPMode = VLOG_IS_ON(immediaterp);
+  if (immediate || immediateRPMode) {
+    for (uint32_t i = 0; i < kRPTypeNum; ++i) {
+      referenceLimit[i] = 0;
+      agedReferenceLimit[i] = 0;
+    }
+    hungryLimit = kUnitTestRPHungryLimit;
+    agedHungryLimit = kUnitTestRPAgedHungryLimit;
+    ReferenceProcessor::Instance().SetIterationWaitTimeMs(kUnitTestRPWaitTimeMS);
+  }
+}
+
+extern "C" void MRT_StopProcessReferences(bool finalize) {
+  ReferenceProcessor::Instance().Stop(finalize);
+  ReferenceProcessor::Instance().Notify(false);
+}
+
+extern "C" void MRT_WaitProcessReferencesStopped() {
+  ReferenceProcessor::Instance().WaitStop();
+}
+
+RCReferenceProcessor::RCReferenceProcessor() : ReferenceProcessor() {
+  iterationWaitTime = kRCEpochIntervalMs;
+  referenceFlags = 0;
+  agedReferenceFlags = 0;
+  hungryCount = 1;
+  agedHungryCount = 1;
+  for (uint32_t i = 0; i < kRPTypeNum; ++i) {
+    numProcessedAgedRefs[i] = 0;
+    numLastProcessedAgedRefs[i] = 0;
+    recentCount[i] = 0;
+    agedReferenceCount[i] = 0;
+  }
+}
+
+void RCReferenceProcessor::Init() {
+  ReferenceProcessor::Init();
+  InitReferenceFlags();
+  referenceFlags = kRPAllFlags;
+}
+
+// Clear RC reference data structure: release queue, discovered reference list
+// Move Pending finalizable to fianlizables.
+void RCReferenceProcessor::Fini() {
+  ReferenceProcessor::Fini();
+  __MRT_ASSERT(RPRunning == false, "still running");
+  __MRT_ASSERT(workingAsyncReleaseQueue.size() == 0, "working not empty");
+  asyncReleaseQueue.clear();
+  cpJobs.clear();
+}
+
+static void inline DiscoverReference(address_t &head, address_t enqueued) {
+  if (head == 0) {
+    ReferenceSetPendingNext(enqueued, enqueued);
+  } else {
+    ReferenceSetPendingNext(enqueued, head);
+  }
+  head = enqueued;
+}
+
+static void inline DiscoverGenRefs(address_t &head, ManagedForwardList<TimedRef> &refList, uint32_t &count) {
+  auto itor = refList.begin();
+  auto end = refList.end();
+  while (itor != end) {
+    TimedRef &ref = *itor;
+    address_t reference = ref.ref;
+    if (reference != 0 && ReferenceGetReferent(reference) == 0) {
+      DiscoverReference(head, reference);
+      ++count;
+    }
+    ++itor;
+  }
+}
+
+static void inline DiscoverRefs(address_t &head, ManagedForwardList<address_t> &refList, uint32_t &count) {
+  auto itor = refList.begin();
+  auto end = refList.end();
+  while (itor != end) {
+    address_t reference = *itor;
+    if (reference != 0 && ReferenceGetReferent(reference) == 0) {
+      DiscoverReference(head, reference);
+      ++count;
+    }
+    ++itor;
+  }
+}
+
+address_t RCReferenceProcessor::TransferEnquenenableReferenceOnFork(uint32_t type) {
+  ReferenceContext &ctx = referenceContext[type];
+  address_t enqueueables = 0;
+  uint32_t count = 0;
+  DiscoverGenRefs(enqueueables, ctx.working, count);
+  ctx.working.clear();
+  for (uint32_t i = 0; i < kYoungRefParallelListNum; ++i) {
+    DiscoverGenRefs(enqueueables, ctx.youngs[i], count);
+    ctx.youngs[i].clear();
+  }
+  for (uint32_t i = 0; i < kAgedRefParallelListNum; ++i) {
+    DiscoverRefs(enqueueables, ctx.ages[i], count);
+    ctx.ages[i].clear();
+  }
+  return enqueueables;
+}
+
+void RCReferenceProcessor::TransferFinalizblesOnFork(ManagedList<address_t> &toFinalizables) {
+  __MRT_ASSERT(workingFinalizables.empty() == true, "working finalizable not empty");
+  __MRT_ASSERT(runFinalizations.empty() == true, "working runFinalizations not empty");
+  uint32_t transferedFinal = 0;
+  for (address_t obj : finalizables) {
+    toFinalizables.push_back(obj);
+    ++transferedFinal;
+  }
+  for (address_t obj : pendingFinalizablesPrev) {
+    toFinalizables.push_back(obj);
+    ++transferedFinal;
+  }
+  for (address_t obj : pendingFinalizables) {
+    toFinalizables.push_back(obj);
+    ++transferedFinal;
+  }
+  finalizables.clear();
+  pendingFinalizablesPrev.clear();
+  pendingFinalizables.clear();
+  LOG(INFO) << "TransferFinalizblesOnFork " << transferedFinal << maple::endl;
+}
+
+// Periodically check which reference need be processed
+// 1. agedHungryCount reach threshold, process all references
+// 2. hungryCount reach threshold, process all young references
+// 3. otherwise check if specific type recent count reach threshold
+// signle aged reference process will be determined after young is processed
+bool RCReferenceProcessor::CheckAndSetReferenceFlags() {
+  ++agedHungryCount;
+  ++hungryCount;
+  if (agedHungryCount > agedHungryLimit) {
+    referenceFlags = kRPAllFlags;
+    agedReferenceFlags = kRPAllFlags;
+    agedHungryCount = 0;
+    hungryCount = 0;
+    LOG2FILE(kLogtypeRp) << "[RefProcessor] AgedHungryLimit(" << agedHungryLimit <<
+        ") reached, ready to process all aged references." << std::endl;
+  } else if (hungryCount > hungryLimit) {
+    referenceFlags = kRPAllFlags;
+    agedReferenceFlags = 0;
+    hungryCount = 0;
+    LOG2FILE(kLogtypeRp) << "[RefProcessor] HungryLimit(" << hungryLimit <<
+        ") reached, ready to process all references." << std::endl;
+  } else {
+    uint32_t flags = 0;
+    for (uint32_t i = 0; i < kRPTypeNum; ++i) {
+      if (recentCount[i] > referenceLimit[i]) {
+        flags |= (1U << i);
+        recentCount[i] = 0;
+      }
+    }
+    referenceFlags = flags;
+    agedReferenceFlags = 0;
+  }
+  return (referenceFlags != 0 || agedReferenceFlags != 0);
+}
+
+bool RCReferenceProcessor::CheckAndUpdateAgedReference(uint32_t type) {
+  uint32_t mask = RPMask(type);
+  if ((agedReferenceFlags & mask) != 0 || agedReferenceCount[type] > agedReferenceLimit[type]) {
+    agedReferenceCount[type] = 0;
+    return true;
+  }
+  ++(agedReferenceCount[type]);
+  return false;
+}
+
+void RCReferenceProcessor::LogRefProcessorBegin() {
+  if (!GCLog().IsWriteToFile(kLogtypeRp)) {
+    return;
+  }
+  timeCurrentRefProcessBegin = timeutils::MicroSeconds();
+  char buf[kRPLogBufSize]; // doesn't need initialize
+  buf[0] = 0;
+  for (uint32_t i = 0; i < kRPTypeNum; ++i) {
+    if (referenceFlags & (1U << i)) {
+      errno_t tmpResult1 = strcat_s(buf, sizeof(buf), kRefTypeMnemonics[i]);
+      errno_t tmpResult2 = strcat_s(buf, sizeof(buf), " ");
+      if (UNLIKELY(tmpResult1 != EOK || tmpResult2 != EOK)) {
+        LOG(ERROR) << "strcat_s() in maplert::logRefProcessorBegin() return " << tmpResult1 << " and " <<
+            tmpResult2 << " rather than 0. " << maple::endl;
+      }
+    }
+  }
+  LOG2FILE(kLogtypeRp) << "[RefProcessor] Begin " << curRpIndex << " (" << timeutils::GetDigitDate() <<
+      ") : (" << buf << ")" << std::endl;
+  for (uint32_t i = 0; i < kRPTypeNum; ++i) {
+    numLastProcessedRefs[i] = numProcessedRefs[i];
+    numLastProcessedAgedRefs[i] = numProcessedAgedRefs[i];
+  }
+}
+
+void RCReferenceProcessor::LogRefProcessorEnd() {
+  if (!GCLog().IsWriteToFile(kLogtypeRp)) {
+    return;
+  }
+  LOG2FILE(kLogtypeRp) << "[RefProcessor] Number Processed: ";
+  for (uint32_t i = 0; i < kRPTypeNum; ++i) {
+    if (referenceFlags & (1U << i)) {
+      LOG2FILE(kLogtypeRp) << kRefTypeMnemonics[i] << " " << (numProcessedRefs[i] - numLastProcessedRefs[i]) <<
+          " [" << numProcessedRefs[i] << "] ";
+      if (numProcessedAgedRefs[i] != numLastProcessedAgedRefs[i]) {
+        LOG2FILE(kLogtypeRp) << " (aged: " << (numProcessedAgedRefs[i] - numLastProcessedAgedRefs[i]) <<
+            " [" << numProcessedAgedRefs[i] << "]) ";
+      }
+    }
+  }
+  LOG2FILE(kLogtypeRp) << std::endl;
+
+  uint64_t timeNow = timeutils::MicroSeconds();
+  uint64_t timeConsumed = timeNow - timeCurrentRefProcessBegin;
+  uint64_t totalTimePassed = timeNow - timeRefProcessorBegin;
+  timeRefProcessUsed += timeConsumed;
+  float percentage = ((maple::kTimeFactor * timeRefProcessUsed) / totalTimePassed) / kPercentageDivend;
+  LOG2FILE(kLogtypeRp) << "[RefProcessor] End " << curRpIndex << " (" << timeConsumed << "us" <<
+      " [" << timeRefProcessUsed << "us]" <<
+      " [ " << percentage << "%]" <<
+      std::endl;
+  ++curRpIndex;
+}
+
+void RCReferenceProcessor::AddAsyncReleaseObj(address_t obj, bool isMutator) {
+  __MRT_ASSERT(IS_HEAP_OBJ(obj), "Not valid object");
+  __MRT_ASSERT(IsRCCollectable(obj), "Not collectable object");
+
+  if (isMutator) {
+    __MRT_ASSERT(IsObjResurrectable(obj) == false, "Add finalizable object to release queue in mutator");
+    if (UNLIKELY(TLMutator().InSaferegion())) {
+      LOG(ERROR) << "__MRTMutatorDeferReleaseObj in safe region.";
+      DumpMutatorsListInfo(true);
+    }
+    if (UNLIKELY(Collector::Instance().IsConcurrentMarkRunning())) {
+      // if concurrent mark is running, can not add object into pending release
+      // as all object need been recrusively processed.
+      return;
+    }
+  } else {
+    // GC concurrent sweep
+    if (UNLIKELY(IsObjResurrectable(obj))) {
+      AddFinalizable(obj, true);
+      return;
+    }
+  }
+  {
+    LockGuard guard(releaseQueueLock);
+    asyncReleaseQueue.push_back(obj);
+  }
+  CountRecent(kRPReleaseQueue);
+}
+
+void RCReferenceProcessor::ClearAsyncReleaseObjs() {
+  __MRT_ASSERT(WorldStopped(), "Invoke when world not stop");
+  asyncReleaseQueue.clear();
+  workingAsyncReleaseQueue.clear();
+}
+
+void RCReferenceProcessor::ProcessAsyncReleaseObjs() {
+  SetProcessingType(kRPReleaseQueue);
+  {
+    // Swap release queue. Leave saferegion to avoid GC visit those changing queues.
+    ScopedObjectAccess soa;
+    LockGuard guard(releaseQueueLock);
+    workingAsyncReleaseQueue.swap(asyncReleaseQueue);
+  }
+  LOG2FILE(kLogtypeRp) << "Async Release Queue size " << workingAsyncReleaseQueue.size() << std::endl;
+  while (true) {
+    ScopedObjectAccess soa;
+    // because GC might clear this queue, check and fetch reference from deque in none-safe region
+    if (workingAsyncReleaseQueue.empty()) {
+      return;
+    }
+    address_t obj = workingAsyncReleaseQueue.front(); // no need in slv because no gc in release
+    workingAsyncReleaseQueue.pop_front();
+    MRT_ReleaseObj(obj);
+    CountProcessed();
+  }
+}
+
+void RCReferenceProcessor::VisitAsyncReleaseObjs(const RefVisitor &vistor) {
+  for (address_t &obj : workingAsyncReleaseQueue) {
+    vistor(obj);
+  }
+  for (address_t &obj : asyncReleaseQueue) {
+    vistor(obj);
+  }
+}
+
+// Visit pending finalizable list for RC
+void RCReferenceProcessor::VisitFinalizers(RefVisitor &visitor) {
+  ReferenceProcessor::VisitFinalizers(visitor);
+  for (address_t &obj : pendingFinalizables) {
+    visitor(obj);
+  }
+  for (address_t &obj : pendingFinalizablesPrev) {
+    visitor(obj);
+  }
+}
+
+// 1. IncRef for objects added into RC finalizable list, otherwise it will be live with RC 0
+// 2. Acquire finalizersLock because mutliple mutator might add finalizable objects spontaneously
+// 3. Only STW can skip lock
+void RCReferenceProcessor::PreAddFinalizables(address_t objs[], uint32_t count, bool needLock) {
+  for (uint32_t i = 0; i < count; ++i) {
+    address_t obj = objs[i];
+    if (needLock) {
+      (void)AtomicUpdateRC<1, 0, 0>(obj);
+    } else {
+      (void)UpdateRC<1, 0, 0>(obj);
+    }
+    CountRecent(kRPFinalizer);
+  }
+  if (needLock) {
+    finalizersLock.lock();
+  } else {
+    __MRT_ASSERT(WorldStopped(), "No lock when not STW");
+  }
+}
+
+void RCReferenceProcessor::PostAddFinalizables(address_t objs[], uint32_t count, bool needLock) {
+  (void)objs;
+  (void)count;
+  if (needLock) {
+    finalizersLock.unlock();
+  }
+}
+
+bool RCReferenceProcessor::CheckAndAddFinalizable(address_t obj) {
+  if (UNLIKELY(IsObjResurrectable(obj))) {
+    AddFinalizable(obj, true);
+    return true;
+  }
+  return false;
+}
+
+bool RCReferenceProcessor::SpecializedAddFinalizable(address_t) {
+  return false;
+}
+
+// Processes pending finalize periodically
+void RCReferenceProcessor::PostProcessFinalizables() {
+  if ((referenceProcessorCycles % kPendingFinalizerRpCount) == 0) {
+    {
+      ScopedObjectAccess soa;
+      finalizersLock.lock();
+      workingFinalizables.swap(pendingFinalizablesPrev);
+      pendingFinalizablesPrev.swap(pendingFinalizables);
+      finalizersLock.unlock();
+    }
+    LOG2FILE(kLogtypeRp) << "referenceProcessorCycles " << referenceProcessorCycles <<
+        " pending finalizer: working size " <<  workingFinalizables.size() <<
+        " pending finalizer: waiting size " <<  pendingFinalizablesPrev.size() <<
+        std::endl;
+    MRT_PHASE_TIMER("PendingFinalizer", kLogtypeRp);
+    ProcessFinalizablesList(workingFinalizables);
+  }
+}
+
+// DecRef and weak reference processing for finalizable objects
+void RCReferenceProcessor::PostFinalizable(address_t obj) {
+  if (IsWeakCollected(obj)) {
+    NaiveRCMutator &mutator = NRCMutator();
+    // check if finalize object is ready to be released
+    // if its strong rc is 1 and weak rc is 1
+    if (TotalRefCount(obj) == kWeakRCOneBit + 1) {
+      mutator.ReleaseObj(obj);
+      CountProcessed();
+      return;
+    } else if (RefCount(obj) == 1) {
+      mutator.WeakReleaseObj(obj);
+    }
+    // else finalizer might have cycle with other finalizer object or resurrect after fianlize
+    mutator.DecWeak(obj);
+  }
+  // resume the pending DecRef
+  RC_RUNTIME_DEC_REF(obj);
+  CountProcessed();
+}
+
+void RCReferenceProcessor::PreIteration() {
+  ++referenceProcessorCycles;
+  ReferenceProcessor::PreIteration();
+  if (UNLIKELY(hasCPJobs)) {
+    MRT_PHASE_TIMER("cycle pattern job", kLogtypeRp);
+    runAllCyclePatternJobs();
+  }
+
+  {
+    MRT_PHASE_TIMER("release", kLogtypeRp);
+    ProcessAsyncReleaseObjs();
+  }
+}
+
+// RC specific processing after RP iteration
+// 1. Process Weak GRT in RC, GC clear weak GRT in STW
+// 2. If reach hungry limit, try drain RC release queue
+// 3. RC specifie GC trigger
+//    3.1 Epoch native mode: trigger native GC if binder proxy count exceed: tobe in android
+//    3.2 Epoch native mode: check native gc epoch stats and trigger gc
+//    3.3 None epoch mode, trigger GC if reference count delta exceed threshold
+void RCReferenceProcessor::PostIteration() {
+  {
+    MRT_PHASE_TIMER("FreeWeakGRT", kLogtypeRp);
+    TryFreeWeakGRs();
+  }
+
+  // release again in full processing
+  if (agedHungryCount == 0) {
+    MRT_PHASE_TIMER("release 2", kLogtypeRp);
+    ProcessAsyncReleaseObjs();
+  }
+
+  if (NativeEpochStats::Instance().isEnabled()) {
+    MRT_PHASE_TIMER("Epoch Check Native", kLogtypeRp);
+    NativeEpochStats::Instance().CheckNativeGC();
+  }
+}
+
+void RCReferenceProcessor::PreExitDoFinalize() {
+  LOG(INFO) << "Release all releasing-obj before stopped" << maple::endl;
+  ProcessAsyncReleaseObjs();
+}
+
+// Enqueue reference in RC will check before enque reference, steps include
+// 1. iterate all reference type: weak, soft, phantom, check if need process current type
+// 2. log, setting current processing type and prepare work
+// 3. process young refs
+// 4. check and process aged refs
+static uint32_t youngToAgedIndex = 0;
+void RCReferenceProcessor::EnqeueReferences() {
+  for (uint32_t type = 0; type <= kRPPhantomRef; ++type) {
+    if (HasReferenceFlag(type) == false) {
+      continue;
+    }
+    ReferenceContext &ctx = referenceContext[type];
+    MRT_PHASE_TIMER(kRefTypeMnemonics[type], kLogtypeRp);
+    LOG2FILE(kLogtypeRp) << kRefTypeMnemonics[type] << ": young " << ctx.youngCount <<
+        " age " << ctx.agedCount << std::endl;
+    if (type == kRPSoftRef) {
+      rpSoftPolicy->Init();
+    }
+    SetProcessingType(type);
+    // processing youngs
+    {
+      uint32_t index = (youngToAgedIndex++) % kAgedRefParallelListNum;
+      uint32_t removeCount = ProcessGenRefs(ctx.working, ctx.ages[index], type, ctx.agedCount);
+      (void)ctx.youngCount.fetch_sub(removeCount, std::memory_order_relaxed);
+    }
+    for (uint32_t i = 0; i < kYoungRefParallelListNum; ++i) {
+      {
+        // Exchange current queue and working. Leave saferegion to avoid GC visit those changing queues.
+        ScopedObjectAccess soa;
+        ctx.lock.lock();
+        ctx.working.swap(ctx.youngs[i]);
+        ctx.lock.unlock();
+      }
+      uint32_t index = (youngToAgedIndex++) % kAgedRefParallelListNum;
+      uint32_t removeCount = ProcessGenRefs(ctx.working, ctx.ages[index], type, ctx.agedCount);
+      (void)ctx.youngCount.fetch_sub(removeCount, std::memory_order_relaxed);
+    }
+    if (CheckAndUpdateAgedReference(type)) {
+      for (uint32_t i = 0; i < kAgedRefParallelListNum; ++i) {
+        ProcessRefs(ctx.ages[i], type, ctx.agedCount);
+      }
+    }
+  }
+}
+
+bool RCReferenceProcessor::ShouldStartIteration() {
+  if (processAllRefs.load()) {
+    referenceFlags = kRPAllFlags;
+    agedReferenceFlags = kRPAllFlags;
+    agedHungryCount = 0;
+    processAllRefs.store(false);
+    return true;
+  }
+  bool hasReferenctToProcess = CheckAndSetReferenceFlags();
+  return (hasReferenctToProcess || hasCPJobs.load() || hasBackgroundGC.load());
+}
+}
diff --git a/src/mrt/compiler-rt/src/collector/rp_base.cpp b/src/mrt/compiler-rt/src/collector/rp_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9aa6bfbd6bd461d3d9886efdd8335b708d7ace79
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/rp_base.cpp
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/rp_base.h"
+
+#include "chosen.h"
+#include "collector/stats.h"
+#ifdef __ANDROID__
+#include "collie.h"
+#endif
+
+namespace maplert {
+constexpr uint32_t kDefaultGCRPTimeoutMs = 2000;
+constexpr uint64_t kNanoPerSecond = 1000L * 1000 * 1000; // 1sec equals 10^9ns
+ReferenceProcessor *ReferenceProcessor::instance = nullptr;
+MethodMeta *ReferenceProcessor::enqueueMethod = nullptr;
+
+// Note: can only be called by reference-processing thread
+extern "C" void *MRT_ProcessReferences(void *not_used __attribute__((unused))) {
+  ReferenceProcessor::Instance().Run();
+  return nullptr;
+}
+
+void CurrentHeapPolicy::Init() {
+  size_t freeMem = MRT_MaxMemory() - HeapStats::CurrentSize();
+  maxInterval = static_cast<uint32_t>(freeMem / (maple::MB));
+}
+
+void ReferenceProcessor::Create(CollectorType type) {
+  if (type == kNaiveRCMarkSweep) {
+    return;
+  }
+  __MRT_ASSERT(instance == nullptr, "RP already created");
+  if (type == kNaiveRC) {
+    instance = new (std::nothrow) RCReferenceProcessor();
+    if (instance == nullptr) {
+      LOG(FATAL) << "new RCReferenceProcessor failed" << maple::endl;
+    }
+  } else if (type == kMarkSweep) {
+    instance = new (std::nothrow) GCReferenceProcessor();
+    if (instance == nullptr) {
+      LOG(FATAL) << "new GCReferenceProcessor failed" << maple::endl;
+    }
+  } else {
+    __MRT_ASSERT(false, "Unepxected type");
+  }
+  __MRT_ASSERT(instance != nullptr, "RP created failed");
+}
+
+// create new GC reference processor to accept information
+// Copy ready to qneuque reference from rc list to gc enqueue list
+// Copy finalizables to gc reference processor
+// Clean RC reference processor
+// delete old reference processor
+void ReferenceProcessor::SwitchToGCOnFork() {
+  RCReferenceProcessor *rcRefProcessor = static_cast<RCReferenceProcessor*>(instance);
+  instance = nullptr;
+  Create(kMarkSweep);
+  GCReferenceProcessor *gcRefProcessor = static_cast<GCReferenceProcessor*>(instance);
+  // copy ready to enque reference to gc reference processor
+  for (uint32_t type = kRPWeakRef; type <= kRPPhantomRef; ++type) {
+    address_t refs = rcRefProcessor->TransferEnquenenableReferenceOnFork(type);
+    gcRefProcessor->InitEnqueueAtFork(type, refs);
+  }
+  // copy finalizables to gc reference processor
+  ManagedList<address_t> &toFinalizables = gcRefProcessor->finalizables;
+  rcRefProcessor->TransferFinalizblesOnFork(toFinalizables);
+  // clear old rc reference processor
+  rcRefProcessor->Fini();
+  delete rcRefProcessor;
+}
+
+ReferenceProcessor::ReferenceProcessor () {
+  threadHandle = 0;
+  RPStarted = false;
+  RPRunning = false;
+  doFinalizeOnStop = false;
+  curProcessingRef = kRPWeakRef;
+  for (uint32_t i = 0; i < kRPTypeNum; ++i) {
+    numProcessedRefs[i] = 0;
+    numLastProcessedRefs[i] = 0;
+  }
+  iterationWaitTime = kDefaultGCRPTimeoutMs;
+  processAllRefs = false;
+  hasBackgroundGC = false;
+  forceBackgroundGC = false;
+  catchBGGcJobTime = 0;
+  hasBackgroundGC.store(false, std::memory_order_release);
+  timeRefProcessorBegin = 0;
+  timeRefProcessUsed = 0;
+  timeCurrentRefProcessBegin = 0;
+}
+
+bool ReferenceProcessor::IsCurrentRPThread() const {
+  pthread_t cur = ::pthread_self();
+  return threadHandle == cur;
+}
+
+void ReferenceProcessor::Run() {
+  Init();
+  NotifyStrated();
+  while (RPRunning) {
+    {
+      LogRefProcessorBegin();
+      PreIteration();
+      ProcessFinalizables();
+      EnqeueReferences();
+      PostIteration();
+      LogRefProcessorEnd();
+    }
+    {
+      MRT_PHASE_TIMER("RP waitting time", kLogtypeRp);
+      while (RPRunning) {
+        Wait(iterationWaitTime);
+        DoChores();
+        if (ShouldStartIteration()) {
+          break;
+        }
+      }
+    }
+  }
+
+  if (doFinalizeOnStop) {
+    PreExitDoFinalize();
+    LOG(INFO) << "Do finalization before ReferenceProcessor stopped" << maple::endl;
+    ProcessFinalizables();
+  }
+  LOG(INFO) << "ReferenceProcessor thread stopped" << maple::endl;
+}
+
+void ReferenceProcessor::Init() {
+  threadHandle = ::pthread_self();
+  RPRunning = true;
+  doFinalizeOnStop = false;
+  if (enqueueMethod == nullptr) {
+    enqueueMethod = WellKnown::GetMClassReference()->GetMethod("enqueue", "()Z");
+  }
+  timeRefProcessorBegin = timeutils::MicroSeconds();
+  timeRefProcessUsed = 0;
+  LOG(INFO) << "ReferenceProcessor thread started" << maple::endl;
+}
+
+// Stop Reference Processor is only invoked at Fork or Runtime finliazaiton
+// Should only invoke once.
+void ReferenceProcessor::Stop(bool finalize) {
+  __MRT_ASSERT(RPRunning == true, "invalid RP status");
+  doFinalizeOnStop = finalize;
+  RPRunning = false;
+  forceBackgroundGC = false;
+  hasBackgroundGC.store(false, std::memory_order_release);
+}
+
+void ReferenceProcessor::WaitStop() {
+  ScopedEnterSaferegion saferegion;
+  pthread_t thread = threadHandle;
+  int tmpResult = ::pthread_join(thread, nullptr);
+  if (UNLIKELY(tmpResult != 0)) {
+    LOG(FATAL) << "::pthread_join() in maplert::MRT_WaitProcessReferencesStopped() return " << tmpResult <<
+        " rather than 0. " << maple::endl;
+  }
+  RPStarted = false;
+  threadHandle = 0;
+}
+
+// Invoked before switch collector, need clear all internal data structure
+void ReferenceProcessor::PreSwitchCollector() {}
+
+void ReferenceProcessor::VisitFinalizers(RefVisitor &visitor) {
+  for (address_t &obj : finalizables) {
+    visitor(obj);
+  }
+  for (address_t &obj : workingFinalizables) {
+    visitor(obj);
+  }
+  for (address_t &obj : runFinalizations) {
+    visitor(obj);
+  }
+}
+
+void ReferenceProcessor::VisitGCRoots(RefVisitor &visitor) {
+  VisitFinalizers(visitor);
+}
+
+void ReferenceProcessor::Notify(bool processAll) {
+  if (processAll) {
+    processAllRefs.store(true);
+  }
+  wakeCondition.notify_one();
+}
+
+void ReferenceProcessor::NotifyBackgroundGC(bool force) {
+  if (forceBackgroundGC == false) {
+    catchBGGcJobTime = timeutils::NanoSeconds();
+    if (force) {
+      forceBackgroundGC = true;
+      catchBGGcJobTime += kNanoPerSecond;
+    }
+    hasBackgroundGC.store(true, std::memory_order_release);
+  } else {
+    __MRT_ASSERT(hasBackgroundGC.load(std::memory_order_acquire) == true,
+        "force is true but hasBackgroundGC is false");
+  }
+}
+
+void ReferenceProcessor::RunBackgroundGC() {
+  uint64_t curTime = timeutils::NanoSeconds();
+  if (hasBackgroundGC.load(std::memory_order_acquire) &&
+      (curTime > catchBGGcJobTime) && (curTime - catchBGGcJobTime) > kNanoPerSecond) {
+    if (forceBackgroundGC || Collector::Instance().InJankImperceptibleProcessState()) {
+      Collector::Instance().InvokeGC(kGCReasonTransistBG);
+      forceBackgroundGC = false;
+      Collector::Instance().EndStartupPhase();
+      LOG(INFO) << "End startup phase" << maple::endl;
+    }
+    hasBackgroundGC.store(false, std::memory_order_release);
+  }
+}
+
+void ReferenceProcessor::Wait(uint32_t timeoutMilliSeconds) {
+  std::unique_lock<std::mutex> lock(wakeLock);
+  std::chrono::milliseconds epoch(timeoutMilliSeconds);
+  wakeCondition.wait_for(lock, epoch);
+}
+
+void ReferenceProcessor::NotifyStrated() {
+  {
+    std::unique_lock<std::mutex> lock(startedLock);
+    __MRT_ASSERT(RPStarted == false, "unpexcted true, reference processor might not wait stopped");
+    RPStarted = true;
+  }
+  startedCondition.notify_all();
+}
+
+void ReferenceProcessor::WaitStarted() {
+  std::unique_lock<std::mutex> lock(startedLock);
+  if (RPStarted) {
+    return;
+  }
+  startedCondition.wait(lock, [this]{ return RPStarted; });
+}
+
+void ReferenceProcessor::PreIteration() {
+  if (UNLIKELY(hasBackgroundGC)) {
+    MRT_PHASE_TIMER("may trigger background gc", kLogtypeRp);
+    RunBackgroundGC();
+  }
+}
+
+void ReferenceProcessor::PreExitDoFinalize() {}
+
+// do non-rp-related stuff
+void ReferenceProcessor::DoChores() {
+  // trigger heuristic gc
+  size_t threshold = stats::gcStats->CurGCThreshold();
+  size_t allocated = (*theAllocator).AllocatedMemory();
+  if (allocated >= threshold) {
+    Collector::Instance().InvokeGC(kGCReasonHeu);
+  }
+}
+
+// Add finalizable objects into finalizable list. This could be invoked
+// in GC thread or Java mutator (RC cycle pattern), at STW time or running time.
+// needLock is true when RC mutator add or multiple GC threads add spontaneously.
+// 1. pre hook, collector specific handling: RC/Lock/Assert
+// 2. For each obj, set enqued bit, GC barrier, allocator hook
+// 3. Add into finalizable list
+// 2. PostHook, lock, stats
+void ReferenceProcessor::AddFinalizables(address_t objs[], uint32_t count, bool needLock) {
+  PreAddFinalizables(objs, count, needLock);
+
+  for (uint32_t i = 0; i < count; ++i) {
+    address_t obj = objs[i];
+    __MRT_ASSERT(!IsEnqueuedObjFinalizable(obj), "alredy enqueued");
+
+    // change status befor pushback. After pushback, this addr is not safe:
+    // we may change another obj while reference-collector may free it at sametime
+    SetEnqueuedObjFinalizable(obj);
+
+    // tell collector that the object prepare to renew, this is required for concurrent marking.
+    // it's safe to invoke at STW, as concurrent marking is false and no action happen
+    Mutator *mutator = TLMutatorPtr();
+    if (mutator != nullptr) {
+      mutator->SatbWriteBarrier(obj);
+    }
+
+    // This is the place where object resurrects.
+    (*theAllocator).OnFinalizableObjResurrected(obj);
+
+    if (SpecializedAddFinalizable(obj) == false) {
+      finalizables.push_back(obj);
+    }
+  }
+  PostAddFinalizables(objs, count, needLock);
+}
+
+void ReferenceProcessor::AddFinalizable(address_t obj, bool needLock) {
+  __MRT_ASSERT(!IsMygoteObj(obj), "too late to enqueue mygote finalizable obj");
+  AddFinalizables(&obj, 1, needLock);
+}
+
+// Process finalizable list
+// 1. always process list head and remove processed fnalizables
+// 2. Leave safe region (calling in RP thread)
+// 3. timeout processing, finalizer watchdog: tobe in collector-platform
+// 4. Invoke finalize method
+// 5. post processing: collector specific action and stats
+void ReferenceProcessor::ProcessFinalizablesList(ManagedList<address_t> &list) {
+  auto itor = list.begin();
+  while (itor != list.end()) {
+    // keep GC thread from scanning roots when finalizer list is updating
+    ScopedObjectAccess soa;
+    __MRT_ASSERT(!MRT_HasPendingException(), "should not exist pending exception");
+    address_t finalizeObj = *itor;
+    if (IsMygoteObj(finalizeObj)) {
+      // don't want to touch mygote obj (makes its page private)
+      // it's okay because mygote finalizables will never be enqueued again (rc overflow)
+      list.pop_front();
+      itor = list.begin();
+      continue;
+    }
+    {
+#ifdef __ANDROID__
+      // set up finalizer watch-dog for this finalizer
+      MplCollieScope mcs(kProcessFinalizeCollie, MPLCOLLIE_FLAG_ABORT, maple::GetTid(),
+                         [](void *finalizer) {
+                           MClass *classInfo = reinterpret_cast<MObject*>(finalizer)->GetClass();
+                           LOG(ERROR) << "--- calling finalize() on " << finalizer << "(" <<
+                               classInfo->GetName() << ") took too long" << maple::endl;
+                         }, reinterpret_cast<void*>(finalizeObj));
+#endif // __ANDROID__
+
+      MClass *classInfo = reinterpret_cast<MObject*>(finalizeObj)->GetClass();
+      MethodMeta *finalizerMethod = classInfo->GetFinalizeMethod();
+      if (finalizerMethod != nullptr) {
+        // finalize method return void
+        (void)finalizerMethod->InvokeJavaMethodFast<int>(reinterpret_cast<MObject*>(finalizeObj));
+      } else {
+        LOG(FATAL) << std::hex << finalizeObj << std::dec << " has no finalize method " << maple::endl;
+      }
+    }
+    MRT_ClearPendingException();
+    ClearObjFinalizable(finalizeObj);
+    PostFinalizable(finalizeObj);
+    list.pop_front();
+    itor = list.begin();
+  }
+}
+
+// Invoked from RP thread and should be in safe region
+// 1. acquire finalizerProcessingLock, indicate RP is processsing finalizables, sync with runFinalization
+// 2. swap finalizables with workingFinalizables
+// 3. process working list
+// 4. Invoke Post Process for collector specific operations
+// 5. release finalizerProcessingLock lock
+void ReferenceProcessor::ProcessFinalizables() {
+  MRT_PHASE_TIMER("Finalizer", kLogtypeRp);
+  SetProcessingType(kRPFinalizer);
+  finalizerProcessingLock.lock();
+  {
+    // Exchange current queue and working queue.
+    // we leave saferegion to avoid GC visit those changing queues.
+    ScopedObjectAccess soa;
+    finalizersLock.lock();
+    workingFinalizables.swap(finalizables);
+    finalizersLock.unlock();
+  }
+
+  LOG2FILE(kLogtypeRp) << "finalizer: working size " << workingFinalizables.size() << std::endl;
+  ProcessFinalizablesList(workingFinalizables);
+  PostProcessFinalizables();
+  finalizerProcessingLock.unlock();
+}
+
+// Invoked from compiled code and should be in none safe region
+// 1. wait finalizerProcessingLock, avoid multiple run finalization concurrently and use same runFinalizations list
+// 2. swap finalizables with runFinalizations
+// 3. process finalizables in runFinalizations
+// 4. Sync with RP thread with running finalization processing, try get and release finalizerProcessingLock
+void ReferenceProcessor::RunFinalization() {
+#ifndef __OPENJDK__
+  __MRT_CallAndAssertTrue(MRT_EnterSaferegion(), "calling runFinalization from safe region");
+#endif
+  runFinalizationLock.lock();
+  (void)MRT_LeaveSaferegion();
+  {
+    __MRT_ASSERT(runFinalizations.empty(), "not empty run finalization list");
+    finalizersLock.lock();
+    runFinalizations.swap(finalizables);
+    finalizersLock.unlock();
+  }
+  ProcessFinalizablesList(runFinalizations);
+  runFinalizationLock.unlock();
+
+#ifdef __OPENJDK__
+  finalizerProcessingLock.lock();
+#else
+  __MRT_CallAndAssertTrue(MRT_EnterSaferegion(), "calling runFinalization from safe region");
+  finalizerProcessingLock.lock();
+  (void)MRT_LeaveSaferegion();
+#endif
+  finalizerProcessingLock.unlock();
+}
+
+void ReferenceProcessor::LogFinalizeInfo() {
+  LOG(INFO) << " finalizers size : " << finalizables.size() << " working " << workingFinalizables.size() <<
+      " runFinalization " << runFinalizations.size() << maple::endl;
+}
+
+void ReferenceProcessor::Enqueue(address_t reference) {
+  // clear possible pending exception.
+  MRT_ClearPendingException();
+  // enqueue tells application this reference is now free-able
+  (void)enqueueMethod->InvokeJavaMethodFast<uint8_t>(reinterpret_cast<MObject*>(reference));
+  MRT_ClearPendingException();
+}
+
+void ReferenceProcessor::LogRefProcessorBegin() {}
+
+void ReferenceProcessor::LogRefProcessorEnd() {}
+
+bool ReferenceProcessor::ShouldClearReferent(GCReason reason) {
+  switch (reason) {
+    case kGCReasonForceGC:
+      return forceGcSoftPolicy.ShouldClearSoftRef();
+    case kGCReasonOOM:
+      return oomGcSoftPolicy.ShouldClearSoftRef();
+    default:
+      return heapGcSoftPolicy.ShouldClearSoftRef();
+  }
+}
+
+void ReferenceProcessor::InitSoftRefPolicy() {
+  heapGcSoftPolicy.Init();
+}
+}
diff --git a/src/mrt/compiler-rt/src/collector/stats.cpp b/src/mrt/compiler-rt/src/collector/stats.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f4956b83a3a40f12ca257dabc7d6c46b43d13196
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collector/stats.cpp
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/stats.h"
+#include "chosen.h"
+
+namespace maplert {
+namespace stats {
+ImmortalWrapper<GCStats> gcStats;
+
+GCStats::GCStats()
+    : numGcTriggered(0),
+      totalBytesCollected(0),
+      recentGcCount(0),
+      maxBytesCollected(0),
+      maxStopTheWorldTime(0),
+      numAllocAnomalies(0),
+      numRcAnomalies(0),
+      currentGcThreshold(kInitGCThreshold),
+      waterLevelLow(kAppGCWaterLevelLow),
+      waterLevel(kAppGCWaterLevel) {}
+
+void GCStats::BeginGCRecord() {
+  __MRT_ASSERT(curRec == nullptr, "curRec is already initialized.  Please commit the last record.");
+  curRec = make_unique<SingleGCRecord>();
+  curRec->isConcurrentMark = false;
+  curRec->async = false;
+  curRec->stw1Time = 0;
+  curRec->stw2Time = 0;
+  curRec->totalGcTime = 0;
+  curRec->objectsCollected = 0;
+  curRec->bytesCollected = 0;
+  curRec->bytesSurvived = 0;
+}
+
+void GCStats::CommitGCRecord() {
+  __MRT_ASSERT(curRec != nullptr, "curRec is nullptr.  Call BeginGCRecord() first!");
+  OnGCFinished(std::move(curRec));
+  curRec = nullptr;
+}
+
+void GCStats::OnCollectorInit() {
+  if (Collector::Instance().Type() == kMarkSweep) {
+    waterLevel = kGCWaterLevelGCOnly;
+  }
+}
+
+void GCStats::UpdateStatistics(const unique_ptr<SingleGCRecord> &rec) {
+  ++numGcTriggered;
+  totalBytesCollected += rec->bytesCollected;
+  ++recentGcCount;
+  maxBytesCollected = std::max(rec->bytesCollected, maxBytesCollected);
+
+  // Strictly speaking, we need a compare-and-swap to atomically update this.
+  // But (1) this field is only updated by the GC thread, and (2) statistics is
+  // not exact.  So we only need to ensure that individual reads and writes are
+  // atomic so that readers do not see garbage when reading those fields without
+  // locking.
+  if (rec->reason != kGCReasonUserNi) {
+    maxStopTheWorldTime = max(maxStopTheWorldTime.load(), rec->MaxSTWTime());
+  }
+
+  size_t maxHeapThreshold = (*theAllocator).GetMaxCapacity() - (maple::MB + maple::MB);
+
+  // a simple heuristic to adjust the threshold according to
+  //   1. previous garbage ratio.
+  //   2. current heap capacity vs. max heap capacity.
+  // if the ratio is high, means we need to lower the water level to do more GC
+  size_t calculatedThr = static_cast<size_t>(rec->bytesSurvived * waterLevelLow);
+  if (rec->reason != kGCReasonTransistBG && !Collector::Instance().InJankImperceptibleProcessState()) {
+    float totalBytes = static_cast<float>(rec->bytesSurvived + rec->bytesCollected);
+    float garbageRatio = (static_cast<float>(rec->bytesCollected)) / totalBytes;
+    // footprint is the heap range we have ever touched
+    // it's preferable to reduce the footprint from the allocator point of view (less fragmentation)
+    size_t footprint = (*theAllocator).GetCurrentSpaceCapacity();
+    size_t gcAdvance = std::max((*theAllocator).AllocatedMemory(), rec->bytesSurvived) - rec->bytesSurvived;
+    size_t attemptedThr = static_cast<size_t>(rec->bytesSurvived * waterLevel);
+
+    if (attemptedThr <= footprint - gcAdvance && garbageRatio <= (1 - 1 / waterLevel) &&
+        footprint <= static_cast<size_t>(maxHeapThreshold * kHeapWaterLevel)) {
+      calculatedThr = attemptedThr;
+    }
+  }
+
+  // caps and exceptions
+  size_t maxDeltaThreashold = currentGcThreshold + kMaxGCThresholdDelta;
+  calculatedThr = std::min(calculatedThr, maxDeltaThreashold);
+  if (Collector::Instance().InStartupPhase()) {
+    calculatedThr = static_cast<size_t>(calculatedThr * kAppStartupHeapHeurstic);
+  }
+  LOG2FILE(kLogtypeGc) << "old threshold " << currentGcThreshold << " new threshold " << calculatedThr << std::endl;
+  currentGcThreshold = std::min(maxHeapThreshold, calculatedThr);
+}
+
+void GCStats::Dump(const unique_ptr<SingleGCRecord> &rec) {
+  // Print a summary of the last GC.
+  size_t used = CurAllocBytes();
+  size_t capacity = CurAllocatorCapacity();
+  double utilization = MemoryUtilization();
+  constexpr int kOneHundred = 100;
+
+  std::ostringstream ost;
+  ost << processName.c_str() << " " << Collector::Instance().GetName() <<
+      " GC for " << reasonCfgs[rec->reason].name << ": " <<
+      (rec->async ? "async:" : "sync: ") <<
+      "collected objects: " << rec->objectsCollected <<
+      "(" << PrettyOrderInfo(rec->bytesCollected, "B") << "), " <<
+      (utilization * kOneHundred) << "% utilization " <<
+      "(" << PrettyOrderInfo(used, "B") << "/" << PrettyOrderInfo(capacity, "B") << "), " <<
+      "max pause: " << PrettyOrderMathNano(rec->MaxSTWTime(), "s") << ", " <<
+      "total pause: " << PrettyOrderMathNano(rec->TotalSTWTime(), "s") << ", " <<
+      "total GC time: " << PrettyOrderMathNano(rec->totalGcTime, "s") <<
+      maple::endl;
+
+  // This will appear in LogCat.
+  LOG(INFO) << ost.str();
+
+  // Utilization is not printed to GCLog.  Ensure we also get a copy there so
+  // that we don't need to collect the numbers from both sides.
+  LOG2FILE(kLogtypeGc) << "End of GC. GC statistics committed.\n" <<
+      "  current total allocated bytes: " << Pretty(used) << "\n" <<
+      "  current heap capacity: " << Pretty(capacity) << "\n" <<
+      "  heap utilization: " << (utilization * kOneHundred) << "%\n";
+}
+
+// This function is only called by the GC thread.
+void GCStats::OnGCFinished(const unique_ptr<SingleGCRecord> &rec) {
+  UpdateStatistics(rec);
+  Dump(rec);
+}
+
+void GCStats::OnAllocAnomaly() {
+  ++numAllocAnomalies;
+}
+
+void GCStats::OnFreeObject(size_t size __attribute__((unused))) const {
+}
+
+void GCStats::OnRCAnomaly() {
+  ++numRcAnomalies;
+}
+
+size_t GCStats::CurAllocBytes() const {
+  return (*theAllocator).AllocatedMemory();
+}
+
+size_t GCStats::CurAllocatorCapacity() const {
+  return (*theAllocator).GetActualSize();
+}
+
+size_t GCStats::CurSpaceCapacity() const {
+  return (*theAllocator).GetCurrentSpaceCapacity();
+}
+
+size_t GCStats::CurGCThreshold() const {
+  return currentGcThreshold;
+}
+
+void GCStats::InitialGCThreshold(const bool isSystem) {
+  if (isSystem) {
+    currentGcThreshold = kInitSystemGCThreshold;
+    waterLevelLow = kGCWaterLevelLow;
+    waterLevel = kGCWaterLevel;
+  } else {
+    currentGcThreshold = kInitGCThreshold;
+    waterLevelLow = kAppGCWaterLevelLow;
+    waterLevel = kAppGCWaterLevel;
+  }
+}
+
+void GCStats::InitialGCProcessName() {
+  const std::string fileName = "/proc/self/status";
+  std::ifstream file(fileName);
+  if (!file.is_open()) {
+    LOG(ERROR) << "InitialGCProcessName open file failed" << maple::endl;
+    return;
+  }
+  constexpr size_t bufSize = 64;
+  char buf[bufSize + 1] = { 0 };
+  if (file.getline(buf, bufSize + 1, '\n')) {
+    processName = processName.assign(buf);
+    processName.erase(0, processName.find_last_of("\t") + 1);
+  }
+  file.close();
+}
+
+uint64_t GCStats::MaxSTWNanos() const {
+  return maxStopTheWorldTime;
+}
+
+size_t GCStats::NumGCTriggered() const {
+  return numGcTriggered;
+}
+
+size_t GCStats::AverageMemoryLeak() const {
+  return recentGcCount ? (static_cast<uint32_t>(totalBytesCollected / recentGcCount)) : 0;
+}
+
+size_t GCStats::TotalMemoryLeak() const {
+  return maxBytesCollected;
+}
+
+double GCStats::MemoryUtilization() const {
+  size_t used = CurAllocBytes();
+  size_t capacity = CurAllocatorCapacity();
+  if (capacity != 0) {
+    return static_cast<double>(used) / capacity;
+  }
+  return 0;
+}
+
+size_t GCStats::NumAllocAnomalies() const {
+  // get the number of allocated objects since last time we rest the count
+  return numAllocAnomalies;
+}
+
+size_t GCStats::NumRCAnomalies() const {
+  return numRcAnomalies;
+}
+
+void GCStats::ResetMaxSTWNanos() {
+  maxStopTheWorldTime = 0;
+}
+void GCStats::ResetNumGCTriggered() {
+  numGcTriggered = 0;
+}
+void GCStats::ResetMemoryLeak() {
+  totalBytesCollected = 0;
+  recentGcCount = 0;
+  maxBytesCollected = 0;
+}
+void GCStats::ResetNumAllocAnomalies() {
+  numAllocAnomalies = 0;
+}
+void GCStats::ResetNumRCAnomalies() {
+  numRcAnomalies = 0;
+}
+} // namespace stats
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/collie.cpp b/src/mrt/compiler-rt/src/collie.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..16ea0afee86b983a2d163f87438e87afdee69d1a
--- /dev/null
+++ b/src/mrt/compiler-rt/src/collie.cpp
@@ -0,0 +1,450 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#ifdef __ANDROID__
+#include "collie.h"
+
+#include <cstdio>
+#include <pthread.h>
+#include <unistd.h>
+#include <cstdlib>
+#include <ctime>
+#include <semaphore.h>
+#include <cerrno>
+#include <cstring>
+#include <string>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <android/set_abort_message.h>
+
+#undef LOG_TAG
+#define LOG_TAG "MAPLECOLLIE"
+#include <log/log.h>
+
+#define USE_LIBC_SEC
+#ifdef USE_LIBC_SEC
+#include "securec.h"
+#endif
+#include "chelper.h"
+
+#define ID_IS_INVALID(x) (UNLIKELY(((x) >= kCollieTypeMax) || ((x) < 0)))
+
+namespace maplert {
+MplCollie mplCollie;
+
+// let monitor thread try to sleep
+// it will sleep if count to kMaxDelayCount and no request from the watched threads
+void MplCollie::CollieTrySleep(void) {
+  if (trCtl.delayCount.load() >= kMaxDelayCount) {
+    std::unique_lock<std::mutex> lock(*trCtl.sleepMutexPtr.get());
+    trCtl.threadInSleep = true;
+    trCtl.sleepCond->wait(lock, [this] { return !(trCtl.threadInSleep && runnable); });
+    trCtl.delayCount = 0;
+    collieTimerRingSTW.timer = 0;
+    collieTimerRingNonSTW.timer = 0;
+  }
+}
+
+// initialize a monitor node
+void MplCollie::ResetNode(CollieNode &node, int type) {
+  int savedType = node.type;
+  if (memset_s(&node, sizeof(CollieNode), 0, sizeof(CollieNode)) != EOK) {
+    LOG(FATAL) << "ResetNode memset_s not return 0" << maple::endl;
+  }
+  node.type = CollieType(type);
+  node.isUsed = false;
+  switch (type) {
+    case kGCCollie: {
+      node.name = "WaitForGCFinish Collie";
+      node.timeout = kMplWaitCheckInterval;
+      break;
+    }
+    case kProcessFinalizeCollie: {
+      node.name = "Finalizer Collie";
+      node.timeout = kMplFinalizerTimeout;
+      break;
+    }
+    case kSTWCollie: {
+      node.name = "StopTheWorld Collie";
+      node.timeout = kMplCollieMaxRecordVal;
+      break;
+    }
+    case kThreadDumpCollie: {
+      node.name = "ThreadDump Collie";
+      node.timeout = kThreadDumpTimeout;
+      break;
+    }
+    default: {
+      node.type = CollieType(savedType);
+    }
+  }
+  int maxPromoteTimeout = ((VLOG_IS_ON(dumpgarbage) || VLOG_IS_ON(dumpheapbeforegc) || VLOG_IS_ON(dumpheapaftergc) ||
+                            VLOG_IS_ON(rcverify))) ? kMplWaitHeavyGcTimeout : kMplWaitGcTimeout;
+  node.promoteTimes = maxPromoteTimeout / kMplWaitCheckInterval;
+  node.Reset();
+}
+
+int MplCollie::CallbackShouldLimit(int flag ATTR_UNUSED) {
+  int ret = 0;
+  time_t now;
+
+  now = time(nullptr);
+  if (timeCallback + kMplCollieCallbackTimewinMax < now) {
+    timeCallback = now;
+  } else {
+    if (++nrCallback > kMplCollieCallbackHistoryMax) {
+      ret = 1;
+    }
+  }
+
+  return ret;
+}
+
+void MplCollie::FatalPanicLocked(std::string &msg) {
+  if (VLOG_IS_ON(dumpgarbage) || VLOG_IS_ON(dumpheapbeforegc) || VLOG_IS_ON(dumpheapaftergc) || VLOG_IS_ON(rcverify)) {
+    LOG(ERROR) << "dump heap switch or verfiy rc is on, skip maple collie panic";
+    return;
+  }
+#if CONFIG_JSAN
+  LOG(ERROR) << msg << maple::endl;
+  LOG(ERROR) << "== Skip abort in JSAN version ==";
+#else
+  android_set_abort_message(msg.c_str());
+  sleep(2);
+  abort();
+#endif
+}
+
+void MplCollie::FatalPanicStopTheWorld(std::string &msg) {
+  std::unique_lock<std::mutex> lock(panicMutex);
+
+  std::string dumpMsg;
+  if (!ID_IS_INVALID(stwID)) {
+    targetTid = collieNodesArray[stwID].tid;
+  } else {
+    targetTid = static_cast<int>(maple::GetTid());
+    dumpMsg = "cannot find stw id\n";
+  }
+  maplert::MutatorList::Instance().VisitMutators([this, &dumpMsg](Mutator *mutator) {
+    if (!mutator->InSaferegion()) {
+      targetTid = static_cast<int>(mutator->GetTid());
+      dumpMsg = dumpMsg + " not in saferegion : " + std::to_string(targetTid);
+    }
+  });
+  dumpMsg = "tid: " + std::to_string(targetTid) + "\n" + msg + dumpMsg;
+  FatalPanicLocked(dumpMsg);
+}
+
+static void PromoteThreadPriority(pid_t tid) {
+  errno = 0;
+  int32_t priority = getpriority(static_cast<int>(PRIO_PROCESS), tid);
+  if (UNLIKELY(errno != 0)) {
+    char errMsg[maple::kMaxStrErrorBufLen];
+    (void)strerror_r(errno, errMsg, sizeof(errMsg));
+    LOG(ERROR) << "getpriority() in failed with errno " << errno << ": " << errMsg;
+    return;
+  }
+  if (priority + maple::kPriorityPromoteStep > maple::kGCThreadStwPriority) {
+    priority += maple::kPriorityPromoteStep;
+  } else if (priority > maple::kGCThreadStwPriority) {
+    priority = maple::kGCThreadStwPriority;
+  } else {
+    return;
+  }
+  MRT_SetThreadPriority(tid, priority);
+}
+
+void MplCollie::FatalPanic(std::string &msg, int tid) {
+  std::unique_lock<std::mutex> lock(panicMutex);
+  msg = "tid: " + std::to_string(tid) + "\n" + msg;
+  FatalPanicLocked(msg);
+}
+
+// trigger callback and caller-defined callback
+void MplCollie::RunCallback(CollieNode &cb) {
+  if (CallbackShouldLimit(cb.flag)) {
+    LOG(ERROR) << "Too many callback triggerd in a short time!" << maple::endl;
+    return;
+  }
+
+  if (cb.callback) {
+    cb.callback(cb.arg);
+  }
+
+  if (static_cast<uint32_t>(cb.flag) & MPLCOLLIE_FLAG_ABORT) {
+    std::string msg = cb.name;
+    msg += " took too long: from ";
+    msg += std::to_string(cb.startTime);
+    msg += " to ";
+    msg += std::to_string(time(nullptr));
+    if (MPLCOLLIE_FLAG_IS_STW(static_cast<uint32_t>(cb.flag))) {
+      FatalPanicStopTheWorld(msg);
+    } else {
+      FatalPanic(msg, cb.tid);
+    }
+  }
+}
+
+void MplCollie::CheckTimerRing(CollieNode callbackList[], CollieTimerRing &r, int &count) {
+  r.timer += kTimerRingCheckInterval;
+  CollieNode *cur = r.cl.GetHead();
+  while (cur != nullptr && r.timer > cur->timeout) {
+    CollieNode *node = cur;
+    cur = cur->next;
+    r.cl.Remove(*node);
+    if ((static_cast<uint32_t>(node->flag) & MPLCOLLIE_FLAG_PROMOTE_PRIORITY) && node->promoteTimes > 0) {
+      PromoteThreadPriority(node->tid);
+      node->timeout = r.timer + kMplWaitCheckInterval;
+      --(node->promoteTimes);
+      r.cl.Insert(*node);
+    } else {
+      if (stwID == node->type) {
+        stwID = kInvalidId;
+      } else {
+        callbackList[count] = *node;
+        ++count;
+      }
+      int type = node->type;
+      ResetNode(*node, type);
+    }
+  }
+}
+
+// check the current timer ring position and run all the callbacks
+void MplCollie::TimerRingTimeout() {
+  CollieNode callbackList[kCollieTypeMax];
+
+  int count = 0;
+  {
+    std::unique_lock<std::mutex> lock(listMutex);
+    bool isEmpty = true;
+    // point to the current list timeout in timer ring
+    if (!collieTimerRingSTW.cl.IsEmpty()) {
+      CheckTimerRing(callbackList, collieTimerRingSTW, count);
+      isEmpty = false;
+    }
+    // if in stop the world, then stop the nonstw timer walking
+    if (ID_IS_INVALID(stwID)) {
+      if (!collieTimerRingNonSTW.cl.IsEmpty()) {
+        CheckTimerRing(callbackList, collieTimerRingNonSTW, count);
+        isEmpty = false;
+      }
+    }
+    if (isEmpty) {
+      ++(trCtl.delayCount);
+    } else {
+      trCtl.delayCount = 0;
+    }
+  }
+  // run timeout callback
+  for (int i = 0; i < count; ++i) {
+    LOG(ERROR) << "Trigger " << callbackList[i].name << " Callback Function (start time: " <<
+        std::to_string(callbackList[i].startTime) << ")" << maple::endl;
+    RunCallback(callbackList[i]);
+  }
+}
+
+// monitor thread main loop
+void *MplCollie::CollieThreadHandle() {
+  pthread_setname_np(pthread_self(), "MapleCollie");
+
+  while (runnable) {
+    {
+      std::unique_lock<std::mutex> lock(timerMutex);
+      timerCond.wait_for(lock, std::chrono::seconds(kTimerRingCheckInterval), [this] { return !runnable; });
+    }
+    // timeout process
+    // step 1: get timeout info and run callback
+    TimerRingTimeout();
+
+    // step 2: goto sleep if needed
+    // if wake up from sleep state, time should be re-calc
+    CollieTrySleep();
+  }
+  return nullptr;
+}
+
+// force collie thread to end.
+void MplCollie::ForceEnd() {
+  std::unique_lock<std::mutex> lock(timerMutex);
+  runnable = false;
+  timerCond.notify_one();
+}
+
+void MplCollie::JoinThread() {
+  int ret = ::pthread_join(collieThread, nullptr);
+  if (UNLIKELY(ret != 0)) {
+    LOG(FATAL) << "failed to join maple collie thread!" << maple::endl;
+  }
+}
+
+void* MplCollie::CollieThreadEntry(void *arg) {
+  if (arg != nullptr) {
+    MplCollie *self = reinterpret_cast<MplCollie*>(arg);
+    self->CollieThreadHandle();
+  }
+
+  return nullptr;
+}
+
+// initializing the data struct
+void MplCollie::InitImp(void) {
+  trCtl.threadInSleep = false;
+  trCtl.delayCount = 0;
+  trCtl.sleepMutexPtr = std::make_unique<std::mutex>();
+  trCtl.sleepCond = std::make_unique<std::condition_variable>();
+
+  for (int i = 0; i < kCollieTypeMax; ++i) {
+    ResetNode(collieNodesArray[i], i);
+  }
+
+  collieTimerRingSTW.timer = 0;
+  collieTimerRingSTW.cl.Init();
+
+  collieTimerRingNonSTW.timer = 0;
+  collieTimerRingNonSTW.cl.Init();
+
+  stwID = kInvalidId;
+  // wait until last collie thread exits successfully.
+  runnable = true;
+  int ret = pthread_create(&collieThread, nullptr, MplCollie::CollieThreadEntry, this);
+  if (ret != EOK) {
+    LOG(ERROR) << "pthread_create return fail, MplCollie::InitImp" << maple::endl;
+  }
+}
+
+// try wake up the monitor thread if it is sleeping
+void MplCollie::CollieTryWake(void) {
+  std::unique_lock<std::mutex> lock(*trCtl.sleepMutexPtr.get());
+  if (trCtl.threadInSleep) {
+    trCtl.threadInSleep = false;
+    trCtl.sleepCond->notify_one();
+  }
+}
+
+void MplCollie::Init(void) {
+  std::unique_lock<std::mutex> lock(initMutex);
+  if (UNLIKELY(!runnable)) {
+    InitImp();
+  }
+}
+
+void MplCollie::Fini() {
+  ForceEnd();
+  {
+    std::unique_lock<std::mutex> lock(listMutex);
+    collieTimerRingSTW.cl.Init();
+    collieTimerRingNonSTW.cl.Init();
+  }
+  CollieTryWake();
+}
+
+bool MplCollie::GetSTWPanic(void) {
+  if (ID_IS_INVALID(stwID)) {
+    return true;
+  }
+  CollieNode *node = &collieNodesArray[stwID];
+  return ((static_cast<uint32_t>(node->flag) & MPLCOLLIE_FLAG_ABORT) != 0);
+}
+
+void MplCollie::SetSTWPanic(bool enable) {
+  if (ID_IS_INVALID(stwID)) {
+    return;
+  }
+  LOG(ERROR) << "Set STW Panic: " << (enable ? "true" : "false") << maple::endl;
+  CollieNode *node = &collieNodesArray[stwID];
+  if (enable) {
+    node->flag = static_cast<int>(static_cast<uint32_t>(node->flag) | MPLCOLLIE_FLAG_ABORT); // set abort flag
+  } else {
+    node->flag = static_cast<int>(static_cast<uint32_t>(node->flag) & (~MPLCOLLIE_FLAG_ABORT)); // clear abort flag
+  }
+}
+
+// fill the collie node, and put it into the timer ring
+// @param flag used to control whether to call the FatalPanicLocked or PromoteThreadPriority function after timeout
+// @param tid thread id being monitored
+// @param func callback called after timeout
+// @param arg  args for callback
+int MplCollie::Start(CollieType type, int flag, pid_t tid, void (*func)(void*), void *arg) {
+  if (UNLIKELY(!runnable)) {
+    return kInvalidId;
+  }
+  std::unique_lock<std::mutex> lock(listMutex);
+
+  CollieNode *node = &(collieNodesArray[type]);
+  if (node->isUsed) {
+    LOG(ERROR) << node->name << "node is in used" << maple::endl;
+    return kInvalidId;
+  }
+  node->Reset();
+
+  // fill node info
+  node->startTime = time(nullptr);
+  node->tid = tid;
+  node->arg = arg;
+  node->flag = flag;
+  node->callback = func;
+
+  // add to timer ring
+  CollieTimerRing *r = MPLCOLLIE_FLAG_IS_STW(static_cast<uint32_t>(node->flag)) ? &collieTimerRingSTW
+                                                                                : &collieTimerRingNonSTW;
+  node->timeout += r->timer;
+  r->cl.Insert(*node);
+  node->isUsed = true;
+
+  if (static_cast<uint32_t>(flag) & MPLCOLLIE_FLAG_FOR_STW) {
+    stwID = node->type;
+  }
+
+  CollieTryWake(); // Wake up the collie monitor thread when inserting at the front.
+  trCtl.delayCount = 0;
+  return node->type;
+}
+
+void MplCollie::End(int type) {
+  if (UNLIKELY(!runnable)) {
+    return;
+  }
+
+  if (ID_IS_INVALID(type)) {
+    LOG(ERROR) << "MplCollie::End : not valid type: " << type << maple::endl;
+    return;
+  }
+
+  // get node from timer ring, add to free list
+  std::unique_lock<std::mutex> lock(listMutex);
+
+  if (!collieNodesArray[type].isUsed) {
+    LOG(ERROR) << "MplCollie::End : already release type: " << type << maple::endl;
+    return;
+  }
+  CollieNode *node = &(collieNodesArray[type]);
+
+  if (static_cast<uint32_t>(node->flag) & MPLCOLLIE_FLAG_FOR_STW) {
+    stwID = kInvalidId;
+  }
+
+  // remove from timer ring
+  CollieTimerRing *r = MPLCOLLIE_FLAG_IS_STW(static_cast<uint32_t>(node->flag)) ? &collieTimerRingSTW
+                                                                                : &collieTimerRingNonSTW;
+  r->cl.Remove(*node);
+
+  ResetNode(*node, type);
+}
+}
+#endif
diff --git a/src/mrt/compiler-rt/src/errno_utils.cpp b/src/mrt/compiler-rt/src/errno_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8df489ea75ca50166f50a07f08aa203e89c98bbd
--- /dev/null
+++ b/src/mrt/compiler-rt/src/errno_utils.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "errno_utils.h"
+
+#include <cerrno>
+#include <string.h> // Not <cstring>. strerror_r is a POSIX function not in the C++ standard.
+
+namespace maplert {
+// NOTE: We use strerror_r, because strerror is not thread-safe.  The man page
+// of strerror_l says it is thread-safe, but the man page contradicts with
+// itself.
+//
+// Since we don't know whether we are using the XSI-compliant version or the GNU
+// version of strerror_r, we use C++ function overloading to detect which
+// strerror_r is provided.
+//
+// See: man strerror
+using XSIStrErrorRType = int(*)(int, char*, size_t);
+using GNUStrErrorRType = char*(*)(int, char*, size_t);
+
+// The XSI-compliant version
+std::string DoErrnoToString(XSIStrErrorRType theStrErrorRFunction, int errNum, char *buf, size_t bufSize) {
+  std::string message;
+
+  int result = theStrErrorRFunction(errNum, buf, bufSize);
+  if (result == 0) {
+    message = buf;
+  } else {
+    int anotherErrnum = errno;
+
+    message = "Error while calling XSI-compliant strerror_r: ";
+
+    switch (anotherErrnum) {
+      case EINVAL:
+        message += "The value of errNum is not a valid error number.";
+        break;
+      case ERANGE:
+        message += "Insufficient storage was supplied to contain the error description string.";
+        break;
+      default:
+        message += "Unexpected errno from strerror_r: " + std::to_string(anotherErrnum);
+        break;
+    }
+  }
+
+  return message;
+}
+
+// The GNU version
+std::string DoErrnoToString(GNUStrErrorRType theStrErrorRFunction, int errNum, char *buf, size_t bufSize) {
+  std::string message;
+
+  char *result = theStrErrorRFunction(errNum, buf, bufSize);
+  // On error, result will point to something like "Unkonwn error nnn".
+  message = result;
+
+  return message;
+}
+
+// Get the error message for an errno as a std::string.
+//
+// @param errNum The error code, from the errno macro.
+//
+// @return The error description string represented as an std::string. Handles
+// strerror_r errors internally.
+std::string ErrnoToString(int errNum) {
+  static constexpr size_t kErrorBufferSize = 256;
+  char buf[kErrorBufferSize]; // Cannot use std::string until C++17. Need to write to the buffer.
+
+  // Because of function overloading, the C++ compiler will choose the
+  // appropriate DoErrnoToString variant depending on the actual type of
+  // ::strerror_r.
+  std::string message = DoErrnoToString(::strerror_r, errNum, buf, kErrorBufferSize);
+
+  return message;
+}
+}  // namespace maplert
diff --git a/src/mrt/compiler-rt/src/exception/eh_personality.cpp b/src/mrt/compiler-rt/src/exception/eh_personality.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4149967e746ca03e1def5511d018b051adfbb15
--- /dev/null
+++ b/src/mrt/compiler-rt/src/exception/eh_personality.cpp
@@ -0,0 +1,516 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "exception/eh_personality.h"
+
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <cstdint>
+#include <cstdio>
+#include <exception>
+#include <iostream>
+#include <dlfcn.h>
+#include "exception/mrt_exception.h"
+#include "exception/mpl_exception.h"
+#include "linker_api.h"
+
+namespace maplert {
+const uint8_t TTYPE_ENCODING = 0x9B;
+const uint8_t LP_START_ENCODING = 0xFF;
+const uint8_t CALL_SITE_ENCODING = 0x01;
+
+bool EHTable::CanCatch(const MrtClass catchType, const void *exObj) {
+  if (exObj == nullptr) {
+    EHLOG(FATAL) << "exception object is null" << maple::endl;
+  }
+  return reinterpret_cast<const MObject*>(exObj)->IsInstanceOf(*reinterpret_cast<MClass*>(catchType));
+}
+
+uintptr_t EHTable::ReadSData4(const uint8_t **p) const {
+  uint32_t value;
+  size_t size = sizeof(uint32_t);
+  errno_t result = memcpy_s(&value, size, *p, size);
+  if (result != EOK) {
+    EHLOG(ERROR) << "memcpy_s() in ReadSData4() return " << result << "rather than 0." << maple::endl;
+    return reinterpret_cast<uintptr_t>(nullptr);
+  }
+  *p += size;
+  return static_cast<uintptr_t>(value);
+}
+
+uintptr_t EHTable::ReadULEB128(const uint8_t **data) const {
+  uintptr_t result = 0;
+  uintptr_t shift = 0;
+  const uintptr_t shiftLength = 7;
+  unsigned char byte;
+  const uint8_t *p = *data;
+  do {
+    byte = *p++;
+    result |= static_cast<uintptr_t>(byte & 0x7F) << shift;
+    shift += shiftLength;
+  } while (byte & 0x80);
+  *data = p;
+  return result;
+}
+
+uintptr_t EHTable::ReadTypeData(const uint8_t **data, bool use32Ref) {
+  const uint8_t *typePoint = *data;
+  // first get value
+  uintptr_t  result = ReadSData4(&typePoint);
+  // then add relative offset
+  if (result != 0) {
+    result += reinterpret_cast<uintptr_t>(*data);
+  }
+  if (result != 0) {
+    if (use32Ref) {
+#ifdef LINKER_LAZY_BINDING
+      (void)MRT_RequestLazyBindingForInitiative(reinterpret_cast<void*>(result));
+#endif // LINKER_LAZY_BINDING
+      result = static_cast<uintptr_t>(*(reinterpret_cast<uint32_t*>(result)));
+    } else {
+#ifdef LINKER_LAZY_BINDING
+      (void)MRT_RequestLazyBindingForInitiative(reinterpret_cast<void*>(result));
+#endif // LINKER_LAZY_BINDING
+      result = *(reinterpret_cast<uintptr_t*>(result));
+    }
+  }
+  *data = typePoint;
+  return result;
+}
+
+MrtClass EHTable::GetMplTypeInfo(uintptr_t tTypeIndex, const uint8_t *classInfo) {
+  if (classInfo == nullptr) {
+    EHLOG(FATAL) << "classInfo is 0 in GetMplTypeInfo" << maple::endl;;
+  }
+#if defined(__aarch64__)
+  if (UINT64_MAX / sizeof(int) < tTypeIndex) {
+#elif defined(__arm__)
+  if (UINT32_MAX / sizeof(int) < tTypeIndex) {
+#endif
+    EHLOG(FATAL) << "tTypeIndex * sizeof(int) > UINT64_MAX" << maple::endl;
+  } else {
+    tTypeIndex *= sizeof(int);
+  }
+  classInfo -= tTypeIndex;
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+  return reinterpret_cast<MrtClass>(ReadTypeData(&classInfo, true));
+#else
+  return reinterpret_cast<MrtClass>(ReadTypeData(&classInfo));
+#endif // LINKER_32BIT_REF_FOR_DEF_UNDEF
+}
+
+extern "C" {
+ATTR_NO_SANITIZE_ADDRESS
+static void SetRegisters(const _Unwind_Exception &unwindException, const _Unwind_Context &context,
+                         const ScanResults &results) {
+  MExceptionHeader *exceptionHeader = GetThrownExceptionHeader(unwindException);
+
+#if defined(__arm__)
+  const _Unwind_Exception *unwindExceptionAddress = &unwindException;
+  _Unwind_VRS_Set(const_cast<_Unwind_Context*>(&context), _UVRSC_CORE, kR0, _UVRSD_UINT32,
+                  reinterpret_cast<uintptr_t*>(&unwindExceptionAddress));
+  _Unwind_VRS_Set(const_cast<_Unwind_Context*>(&context), _UVRSC_CORE, kR1, _UVRSD_UINT32,
+                  &exceptionHeader->tTypeIndex);
+  _Unwind_VRS_Set(const_cast<_Unwind_Context*>(&context), _UVRSC_CORE, kPC, _UVRSD_UINT32,
+                  const_cast<uintptr_t*>(&results.landingPad));
+#else
+  _Unwind_SetGR(const_cast<_Unwind_Context*>(&context), __builtin_eh_return_data_regno(0),
+                reinterpret_cast<uintptr_t>(&unwindException));
+  _Unwind_SetGR(const_cast<_Unwind_Context*>(&context), __builtin_eh_return_data_regno(1),
+                static_cast<uintptr_t>(exceptionHeader->tTypeIndex));
+  _Unwind_SetIP(const_cast<_Unwind_Context*>(&context), results.landingPad);
+#endif
+}
+} // extern "C"
+
+// maple exception table:
+//
+// No exception function >>
+//      .word    0xFFFFFFFF
+//      .word    .Label.Cleanup
+//
+// No frame function(leaf function) >>
+//      .word    0x55555555
+//
+// exception function >>
+//      .word    mplETableOffset
+//      .byte    lpStartEncoding
+//      .byte    ttypeEncoding
+//      .uleb128 classInfoOffset
+//      .byte    callSiteEncoding
+//      .uleb128 callSiteTableLength
+//     Call Site Table
+//      .uleb    start
+//      .uleb    length
+//      .uleb    ladingPad
+//      .uleb    actionEntry
+//      ....
+//     Action Table
+//      .byte    tTypeIndex
+//      .byte    ttypeOffset
+//      ....
+//     Exception Class Info
+//      .4byte   class info
+//
+
+void EHTable::ParseEHTableHeadInfo(const uint8_t *mLSDA) {
+  if (mLSDA == nullptr) {
+    LOG(FATAL) << "mLSDA is nullptr in function ScanExceptionTable for method" << maple::endl;
+  }
+  uint8_t lpStartEncoding = *mLSDA++;
+  MplCheck(lpStartEncoding == LP_START_ENCODING);
+
+  uint8_t ttypeEncoding = *mLSDA++;
+  MplCheck(ttypeEncoding == TTYPE_ENCODING);
+  uintptr_t classInfoOffset = ReadULEB128(&mLSDA);
+  classInfoPoint = mLSDA + classInfoOffset;
+
+  // Walk call-site table looking for range that includes current PC.
+  uint8_t callSiteEncoding = *mLSDA++;
+  MplCheck(callSiteEncoding == CALL_SITE_ENCODING);
+  uint32_t callSiteTableLength = static_cast<uint32_t>(ReadULEB128(&mLSDA));
+  callSiteTableStart = mLSDA;
+  callSiteTableEnd = callSiteTableStart + callSiteTableLength;
+
+  actionTableStart = callSiteTableEnd;
+  curPtr = mLSDA;
+}
+
+void EHTable::ScanExceptionTable(UnwindAction actions, bool nativeException,
+                                 const _Unwind_Exception &unwindException) {
+  MplCheck(nativeException);
+  // actions must be either _UA_SEARCH_PHASE or _UA_SEARCH_PHASE.
+  // either action shares the same scanning strategy.
+  MplCheck((static_cast<unsigned int>(actions) & static_cast<int>(kSearchPhase)) ||
+           (static_cast<unsigned int>(actions) & static_cast<int>(kCleanupPhase)));
+
+  if (type == kNoException || type == kNoFrame) {
+    return;
+  }
+
+  uintptr_t ip = reinterpret_cast<uintptr_t>(currentPC);
+  // we should always adjust ip by -1 to make it point to the instruction which
+  // raises the signal or performs a function call, because this is the precise
+  // site triggering an exception.
+  // Note in PrepareToHandleJavaSignal we have already bias the pc to the next
+  // instruction of the instruction which raises a signal, like what bl instruction
+  // does. so it is safe to do so.
+  ip -= kPrevInsnOffset;
+
+  // Get beginning current frame's code (as defined by the emitted dwarf code)
+  uintptr_t funcStart = reinterpret_cast<uintptr_t>(funcStartPoint);
+  uintptr_t ipOffset = ip - funcStart;
+
+  jthrowable thrownObject = GetThrownObject(unwindException);
+  MplCheck(thrownObject != nullptr);
+
+  while (curPtr < callSiteTableEnd) {
+    // There is one entry per call site.
+    // The call sites are non-overlapping in [start, start+length)
+    // The call sites are ordered in increasing value of start
+    uintptr_t start = ReadULEB128(&curPtr);
+    uintptr_t length = ReadULEB128(&curPtr);
+    uintptr_t landingPad = ReadULEB128(&curPtr);
+    uintptr_t actionEntry = ReadULEB128(&curPtr);
+    if ((start <= ipOffset) && (ipOffset < (start + length))) {
+      // Found the call site containing ip.
+      if (landingPad == 0) {
+        // No handler here
+        results.unwindReason = _URC_CONTINUE_UNWIND;
+        return;
+      }
+      landingPad = reinterpret_cast<uintptr_t>(funcStartPoint) + landingPad;
+      if (actionEntry == 0) {
+        // Found a cleanup
+        SetScanResultsValue(0, landingPad, _URC_HANDLER_FOUND, false);
+        return;
+      }
+      // Convert 1-based byte offset into
+      const uint8_t *action = actionTableStart + (actionEntry - 1);
+      // Scan action entries until you find a matching handler, or the end of action list.
+      // action list is a sequence of pairs (type index, offset of next action).
+      // if offset of next action is 0, the end of current action list is reached.
+      // right now type index would not be 0 for maple exception handling.
+      for (;;) {
+        uintptr_t tTypeIndex = *action++;
+        MplCheck(tTypeIndex != 0);
+        if (tTypeIndex > 0) {
+          // this is a catch (T) clause
+          const MrtClass catchType = GetMplTypeInfo(static_cast<uintptr_t>(tTypeIndex),
+                                                    classInfoPoint);
+          MplCheck(catchType != nullptr);
+          if (CanCatch(catchType, thrownObject)) {
+            // Found a matching handler
+            // Save state and return _URC_HANDLER_FOUND
+            SetScanResultsValue(tTypeIndex, landingPad, _URC_HANDLER_FOUND, true);
+            return;
+          }
+        }
+
+        const uint8_t actionOffset = *action;
+        // reach the end of action list
+        if (actionOffset == 0) {
+          // End of action list, no matching handler or cleanup found,
+          // which means the thrown exception can not be caught by this catch clause.
+          // For C++, we will return _URC_CONTINUE_UNWIND.
+          // For maple, we will continue to search call site table until we reach
+          // the last call site entry which is the cleanup entry.
+          break;
+        } else if (actionOffset == 125) {
+          // According to the sleb encoding format, when actionOffset is equal to 125,
+          // it is equivalent to action -3, and the parsing process of sleb reading is omitted here.
+          action -= 3;
+        }
+      } // there is no break out of this loop, only return end of while
+    }
+  } // there might be some tricky cases which break out of this loop
+
+  // It is possible that no eh table entry specify how to handle
+  // this exception. By spec, terminate it immediately.
+  EHLOG(FATAL) << "ScanExceptionTable failed" << maple::endl;
+}
+
+// set ScanResults Value
+void EHTable::SetScanResultsValue(const uintptr_t tTypeIndex, const uintptr_t landingPad,
+                                  const UnwindReasonCode unwindReason, const bool caughtByJava) {
+  results.tTypeIndex = tTypeIndex;
+  results.landingPad = landingPad;
+  results.unwindReason = unwindReason;
+  results.caughtByJava = caughtByJava;
+}
+
+extern "C" {
+static void DumpInfoPersonality(int version, const _Unwind_Exception &unwindException, int line) {
+  EHLOG(ERROR) << "personality error line [" << line << "]" << maple::endl;
+  EHLOG(ERROR) << "version: " << version << maple::endl;
+  MRT_DumpException(GetThrownObject(unwindException), nullptr);
+  MplDumpStack("\n DumpInfoPersonality");
+}
+
+#if defined(__aarch64__)
+static void DumpFrameInfo(UnwindAction actions, const _Unwind_Context &context) {
+  Dl_info addrInfo;
+  addrInfo.dli_sname = nullptr;
+  std::string unwindAction;
+  if (static_cast<unsigned int>(actions) & static_cast<int>(kSearchPhase)) {
+    unwindAction = "unwind actions: kSearchPhase  ";
+  }
+  if (static_cast<unsigned int>(actions) & static_cast<int>(kCleanupPhase)) {
+    unwindAction = "unwind actions: kCleanupPhase  ";
+  }
+  uintptr_t pc;
+  pc = _Unwind_GetIP(const_cast<_Unwind_Context*>(&context));
+  int dladdrOk = dladdr(reinterpret_cast<void*>(pc), &addrInfo);
+  if (dladdrOk && addrInfo.dli_sname) {
+    EHLOG(INFO) << unwindAction << "function name of current frame: " << addrInfo.dli_sname << maple::endl;
+  } else {
+    EHLOG(INFO) << unwindAction << "pc of current frame: 0x" << std::hex << pc << std::dec << maple::endl;
+  }
+}
+
+UnwindReasonCode __n2j_stub_personality(int version, UnwindAction actions, uintptr_t exceptionClass,
+                                        const _Unwind_Exception *unwindException, const _Unwind_Context *context) {
+  if (unwindException == nullptr) {
+    EHLOG(FATAL) << "unwindException is nullptr!" << maple::endl;
+  }
+  if (version != 1 || context == nullptr) {
+    DumpInfoPersonality(version, *unwindException, __LINE__);
+    return _URC_FATAL_PHASE1_ERROR;
+  }
+  bool nativeException = (exceptionClass & kGetVendorAndLanguage) == (kOurExceptionClass & kGetVendorAndLanguage);
+
+  if (nativeException && (static_cast<unsigned int>(actions) & static_cast<unsigned int>(kCleanupPhase))) {
+    // that n2j stub is the last chance to handle java exception.
+    // so we pretend that n2j frame catches this exception.
+    MExceptionHeader *exceptionHeader = GetThrownExceptionHeader(*unwindException);
+    exceptionHeader->tTypeIndex = 0;
+    ScanResults results;
+    uintptr_t ip;
+    ip = _Unwind_GetIP(const_cast<_Unwind_Context*>(context));
+    if ((ip & 1) == 1) {
+      ip--;
+    }
+    results.landingPad = reinterpret_cast<uintptr_t>(ip);
+
+    // when the stack backtracks to native frame, print the java stack and all the stack
+    // the five line can be deleted for performance
+    if (VLOG_IS_ON(eh)) {
+      MRT_DumpException(GetThrownObject(*unwindException));
+      MplDumpStack("call stack for non-caught exception:");
+    }
+
+    MRT_ThrowExceptionUnsafe(GetThrownObject(*unwindException));
+    MRT_ClearThrowingException();
+
+    // set the continuation with the handler
+    SetRegisters(*unwindException, *context, results);
+    free(GetThrownException(*unwindException));
+    return _URC_INSTALL_CONTEXT;
+  }
+
+  // should not reach here
+  DumpInfoPersonality(version, *unwindException, __LINE__);
+  return _URC_FATAL_PHASE1_ERROR;
+}
+#elif defined(__arm__)
+UnwindReasonCode __n2j_stub_personality(_Unwind_State state, _Unwind_Exception *unwindException,
+                                        _Unwind_Context *context) {
+  if (unwindException == nullptr) {
+    EHLOG(FATAL) << "unwindException is nullptr!" << maple::endl;
+  }
+  if (context == nullptr) {
+    DumpInfoPersonality(state, *unwindException, __LINE__);
+    return _URC_FATAL_PHASE1_ERROR;
+  }
+
+  if (state == (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND)) {
+    constexpr int contextFPOffset = 12;
+    constexpr int contextPCOffset = 16;
+    uintptr_t *callerFP = *(reinterpret_cast<uintptr_t**>(context) + contextFPOffset);
+    uintptr_t *currentPC = reinterpret_cast<uintptr_t*>(context) + contextPCOffset;
+    *currentPC = *(callerFP + 1);
+    uintptr_t *currentFP = reinterpret_cast<uintptr_t*>(context) + contextFPOffset;
+    *currentFP = *callerFP;
+    return _URC_CONTINUE_UNWIND;
+  }
+  // that n2j stub is the last chance to handle java exception.
+  // so we pretend that n2j frame catches this exception.
+  MExceptionHeader *exceptionHeader = GetThrownExceptionHeader(*unwindException);
+  exceptionHeader->tTypeIndex = 0;
+  ScanResults results;
+  uintptr_t ip;
+  _Unwind_VRS_Get(const_cast<_Unwind_Context*>(context), _UVRSC_CORE, kPC, _UVRSD_UINT32, &ip);
+  if ((ip & 1) == 1) {
+    ip--;
+  }
+  results.landingPad = reinterpret_cast<uintptr_t>(ip);
+
+  // when the stack backtracks to native frame, print the java stack and all the stack
+  // the five line can be deleted for performance
+  if (VLOG_IS_ON(eh)) {
+    MRT_DumpException(GetThrownObject(*unwindException));
+    MplDumpStack("call stack for non-caught exception:");
+  }
+
+  MRT_ThrowExceptionUnsafe(GetThrownObject(*unwindException));
+  MRT_ClearThrowingException();
+
+  // set the continuation with the handler
+  SetRegisters(*unwindException, *context, results);
+  free(GetThrownException(*unwindException));
+  return _URC_INSTALL_CONTEXT;
+}
+#endif
+
+#if defined(__aarch64__)
+// this personality is invoked to enter the general handler of the java frame on stack top.
+UnwindReasonCode __mpl_personality_v0(int version, UnwindAction actions, uintptr_t exceptionClass,
+                                      const _Unwind_Exception *unwindException, const _Unwind_Context *context) {
+  if (unwindException == nullptr) {
+    EHLOG(FATAL) << "unwindException is nullptr!" << maple::endl;
+  }
+  if (version != 1 || context == nullptr) {
+    DumpInfoPersonality(version, *unwindException, __LINE__);
+    return _URC_FATAL_PHASE1_ERROR;
+  }
+
+  bool nativeException = (exceptionClass & kGetVendorAndLanguage) == (kOurExceptionClass & kGetVendorAndLanguage);
+
+  MplCheck(nativeException);
+  MplCheck((static_cast<unsigned int>(actions) & static_cast<int>(kCleanupPhase)) != 0);
+
+  const uint32_t *pc = reinterpret_cast<const uint32_t*>(_Unwind_GetIP(const_cast<_Unwind_Context*>(context)));
+  const uint32_t *mLSDA = nullptr;
+  const uint32_t *startPC = nullptr;
+  LinkerLocInfo info;
+  if (LinkerAPI::Instance().LocateAddress(pc, info, false)) {
+    startPC = reinterpret_cast<const uint32_t*>(info.addr);
+    mLSDA = reinterpret_cast<const uint32_t*>((uintptr_t)info.addr + info.size);
+  } else {
+    EHLOG(INFO) << "pc must be java method written with assembly" << maple::endl;
+    return _URC_CONTINUE_UNWIND;
+  }
+  EHTable ehTable(startPC, mLSDA, pc);
+  ehTable.ScanExceptionTable(actions, nativeException, *unwindException);
+  // If the stack-top java frame is abnormal, eh still calls __mpl_personality_v0 now because .cfi_personality.
+  if (ehTable.results.unwindReason == _URC_HANDLER_FOUND && ehTable.results.landingPad) {
+    MExceptionHeader *exceptionHeader = GetThrownExceptionHeader(*unwindException);
+    if (VLOG_IS_ON(eh)) {
+      DumpFrameInfo(actions, *context);
+      EHLOG(INFO) << "Catch Exception Succeeded : " <<
+          reinterpret_cast<MObject*>(GetThrownObject(*unwindException))->GetClass()->GetName() << maple::endl;
+    }
+    SetRegisters(*unwindException, *context, ehTable.results);
+    if (!exceptionHeader->caughtByJava) {
+      free(GetThrownException(*unwindException));
+    } // otherwise exception wrapper is freed in begin_catch
+    return _URC_INSTALL_CONTEXT;
+  } else {
+    // control flow reaches here if top-stack java frame is abnormal
+    return _URC_CONTINUE_UNWIND;
+  }
+}
+
+#elif defined(__arm__)
+UnwindReasonCode __mpl_personality_v0(_Unwind_State state, _Unwind_Exception *unwindException,
+                                      _Unwind_Context *context) {
+  if (unwindException == nullptr || context == nullptr) {
+    return _URC_FATAL_PHASE1_ERROR;
+  }
+
+  if (state == (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND)) {
+    constexpr int contextFPOffset = 12;
+    constexpr int contextPCOffset = 16;
+    uintptr_t *callerFP = *(reinterpret_cast<uintptr_t**>(context) + contextFPOffset);
+    uintptr_t *currentPC = reinterpret_cast<uintptr_t*>(context) + contextPCOffset;
+    *currentPC = *(callerFP + 1);
+    uintptr_t *currentFP = reinterpret_cast<uintptr_t*>(context) + contextFPOffset;
+    *currentFP = *callerFP;
+    return _URC_CONTINUE_UNWIND;
+  }
+  const uint32_t *pc;
+  _Unwind_VRS_Get(const_cast<_Unwind_Context*>(context), _UVRSC_CORE, kPC, _UVRSD_UINT32, &pc);
+  const uint32_t *mLSDA = nullptr;
+  const uint32_t *startPC = nullptr;
+  LinkerLocInfo info;
+  if (LinkerAPI::Instance().LocateAddress(pc, info, false)) {
+    startPC = reinterpret_cast<const uint32_t*>(info.addr);
+    mLSDA = reinterpret_cast<const uint32_t*>((uintptr_t)info.addr + info.size);
+  } else {
+    EHLOG(INFO) << "pc must be java method written with assembly" << maple::endl;
+    return _URC_CONTINUE_UNWIND;
+  }
+  EHTable ehTable(startPC, mLSDA, pc);
+  ehTable.ScanExceptionTable(kSearchPhase, true, *unwindException);
+  // If the stack-top java frame is abnormal, eh still calls __mpl_personality_v0 now because .cfi_personality.
+  if (ehTable.results.unwindReason == _URC_HANDLER_FOUND && ehTable.results.landingPad) {
+    MExceptionHeader *exceptionHeader = GetThrownExceptionHeader(*unwindException);
+    if (VLOG_IS_ON(eh)) {
+      EHLOG(INFO) << "Catch Exception Succeeded : " <<
+          reinterpret_cast<MObject*>(GetThrownObject(*unwindException))->GetClass()->GetName() << maple::endl;
+    }
+    SetRegisters(*unwindException, *context, ehTable.results);
+    if (!exceptionHeader->caughtByJava) {
+      free(GetThrownException(*unwindException));
+    } // otherwise exception wrapper is freed in begin_catch
+    return _URC_INSTALL_CONTEXT;
+  } else {
+    // control flow reaches here if top-stack java frame is abnormal
+    return _URC_CONTINUE_UNWIND;
+  }
+}
+#endif
+} // extern "C"
+} // maplert
diff --git a/src/mrt/compiler-rt/src/exception/exception_handling.cpp b/src/mrt/compiler-rt/src/exception/exception_handling.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d54e9a7c8ac106c1d6d9c5b1d2246cb39e896b28
--- /dev/null
+++ b/src/mrt/compiler-rt/src/exception/exception_handling.cpp
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "exception/exception_handling.h"
+
+#include <vector>
+#include <cassert>
+#include <cstdint>
+#include <cstddef>
+#include <link.h>
+#include "libs.h"
+#include "exception/mpl_exception.h"
+#include "exception/mrt_exception.h"
+#include "exception_store.h"
+#include "chosen.h"
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+namespace maplert {
+void EHFrameInfo::LookupExceptionHandler(const _Unwind_Exception &unwindException) {
+  EHTable ehTable(GetStartPC(), GetEndPC(), GetJavaFrame().ip);
+  ehTable.ScanExceptionTable(kSearchPhase, true, unwindException);
+  mGeneralHandler = reinterpret_cast<void*>(ehTable.results.landingPad);
+
+  if (ehTable.results.caughtByJava) {
+    MExceptionHeader *exceptionHeader = GetThrownExceptionHeader(unwindException);
+    exceptionHeader->tTypeIndex = ehTable.results.tTypeIndex;
+    exceptionHeader->caughtByJava = true; // for a matching handler
+    mCleanupCode = nullptr;
+    mCatchCode = reinterpret_cast<void*>(ehTable.results.landingPad);
+  } else {
+    mCatchCode = nullptr;
+    mCleanupCode = reinterpret_cast<void*>(ehTable.results.landingPad);
+  }
+
+  // no general handler for this frame means it is an abnormal frame.
+  __MRT_ASSERT(mGeneralHandler != nullptr || (!javaFrame.HasFrameStructure()), "");
+  return;
+}
+
+void EHStackInfo::Build(_Unwind_Exception &unwindException, bool isRet) {
+  JavaFrame frame;
+  // If UnwindFinish is returned here, it means that no Java frame has been found
+  // on the stack in the current n2j block, so no build operation is required in
+  // the exception handling phase.
+  if (MapleStack::GetLastJavaFrame(frame, nullptr, true) == kUnwindFinish) {
+    return;
+  }
+
+  (void)isRet;
+
+  if (VLOG_IS_ON(eh)) {
+    MplCheck(frame.IsCompiledFrame(), "Build should start at java frame");
+  }
+
+  size_t n = 0;
+  while (n < MAPLE_STACK_UNWIND_STEP_MAX && frame.IsCompiledFrame()) {
+    EHFrameInfo frameInfo(frame, unwindException);
+
+    // the latest java frame might be a fake frame, we ignore this fake frame
+    const JavaFrame& calleeframe = frameInfo.GetJavaFrame();
+    if (calleeframe.HasFrameStructure()) {
+      priEhStackInfo.push_back(frameInfo);
+    };
+
+    if (frameInfo.GetCatchCode()) {
+      if (VLOG_IS_ON(eh)) {
+        std::stringstream ss;
+        frameInfo.Dump(">>>> Building eh stack: handler at", ss);
+        EHLOG(INFO) << ss.str() << maple::endl;
+      }
+      break;
+    }
+
+    if (VLOG_IS_ON(eh)) {
+      std::stringstream ss;
+      frameInfo.Dump(">>>> Building eh stack: unwind at", ss);
+      EHLOG(INFO) << ss.str() << maple::endl;
+    }
+
+    (void)calleeframe.UnwindToNominalCaller(frame);
+    ++n;
+  }
+}
+
+// chain all java frames in this exception-handling stack
+// this is done by rewriting the return address of callee frame with the general
+// handler of caller frame.
+void EHStackInfo::ChainAllEHFrames(const _Unwind_Exception &unwindException, bool isRet, bool isImplicitNPE) {
+  MExceptionHeader *exceptionHeader = GetThrownExceptionHeader(unwindException);
+  // If the array is equal to 0, it represents a special scenario of a Java method
+  // implemented natively.
+  if (priEhStackInfo.size() == 0) {
+  (void)isRet;
+  (void)isImplicitNPE;
+    return;
+  }
+
+
+  EHFrameInfo *currentFrameInfo = &priEhStackInfo[0];
+  for (unsigned i = 1; i < priEhStackInfo.size(); ++i) {
+    EHFrameInfo *callerFrameInfo = &priEhStackInfo[i];
+    currentFrameInfo->ChainToCallerEHFrame(*callerFrameInfo);
+    currentFrameInfo = callerFrameInfo;
+  }
+
+  // if exception is caught by java frame, the last frame in priEhStackInfo holds the handler.
+  // otherwise, we treat the return address of last frame in priEhStackInfo as the handler.
+  if (exceptionHeader->caughtByJava) {
+    MRT_SetReliableUnwindContextStatus();
+  } else {
+    if (currentFrameInfo->GetJavaFrame().HasFrameStructure()) {
+      currentFrameInfo->ChainToGeneralHandler(currentFrameInfo->GetReturnAddress());
+    }
+    MRT_ThrowExceptionUnsafe(GetThrownObject(unwindException));
+    MRT_ClearThrowingException();
+  }
+
+}
+
+// This function is called by HandleJavaSignalStub and aims to check whether the
+// segv signal results into a java exception. If so it returns PrepareArgsForExceptionCatcher as
+// the continuation point for HandleJavaSignalStub.
+extern "C" uintptr_t IsThrowingExceptionByRet() {
+  // Check whether there is an exception thrown by TLS.
+  MrtClass *thrownObject = reinterpret_cast<MrtClass*>(maple::ExceptionVisitor::GetExceptionAddress());
+  if (thrownObject != nullptr) {
+    return reinterpret_cast<uintptr_t>(&PrepareArgsForExceptionCatcher);
+  } else {
+    return 0;
+  }
+}
+
+struct HandlerCatcherArgs {
+  uintptr_t uwException;
+  intptr_t  typeIndex;
+  uintptr_t topJavaHandler;
+};
+
+extern "C" void MRT_GetHandlerCatcherArgs(struct HandlerCatcherArgs *cArgs) {
+  (void)cArgs;
+}
+
+#if defined(__arm__)
+extern "C" MRT_EXPORT UnwindReasonCode AdaptationFunc(_Unwind_State, _Unwind_Exception*, _Unwind_Context*) {
+  return _URC_CONTINUE_UNWIND;
+}
+#endif
+
+
+ATTR_NO_SANITIZE_ADDRESS
+void RaiseException(struct _Unwind_Exception &unwindException, bool isRet, bool isImplicitNPE) {
+  {
+    EHStackInfo ehStack;
+    ehStack.Build(unwindException, isRet);
+
+    // 1. chain all java frames in this exception-handling stack
+    ehStack.ChainAllEHFrames(unwindException, isRet, isImplicitNPE);
+  }
+
+    // 2. the entry point of exception handler is the extended epilogue of top java frame
+    // here we invoke _Unwind_Resume in libgcc which invokes _Unwind_RaiseException_Phase2.
+    // we adjust the personality to trick _Unwind_RaiseException_Phase2 to continue to
+    // the entry point of exception handler.
+#if defined(__aarch64__)
+    unwindException.private_1 = 0;
+#elif defined(__arm__)
+    // Add an adaptation function, the first time you enter __gnu_Unwind_Resume will be executed.
+    unwindException.unwinder_cache.reserved2 = reinterpret_cast<uintptr_t>(&AdaptationFunc);
+    unwindException.unwinder_cache.reserved3 = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
+#endif
+    _Unwind_Resume(&unwindException);
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/exception/mpl_exception.cpp b/src/mrt/compiler-rt/src/exception/mpl_exception.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a9f0f55da1347718f5e6e80fef3d85c56aa7223e
--- /dev/null
+++ b/src/mrt/compiler-rt/src/exception/mpl_exception.cpp
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "exception/mpl_exception.h"
+
+#include <iostream>
+#include <vector>
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <dlfcn.h>
+#include <list>
+#include "libs.h"
+#include "exception/mrt_exception.h"
+#include "exception_store.h"
+
+namespace maplert {
+static uint64_t exceptionTotalCount = 0;
+list<std::string> ehObjectList;
+std::map<std::string, uint64_t> ehObjectStackMap;
+std::mutex ehObjectListLock;
+std::mutex ehObjectStackMapLock;
+
+
+static inline uint64_t IncExceptionTotalCount(uint64_t count) {
+  return __atomic_add_fetch(&exceptionTotalCount, count, __ATOMIC_ACQ_REL);
+}
+
+static inline void RecordExceptionType(const std::string ehNumType) {
+  std::lock_guard<std::mutex> lock(ehObjectListLock);
+  ehObjectList.push_back(ehNumType);
+}
+
+static void RecordExceptionStack(std::string ehStack) {
+  std::lock_guard<std::mutex> lock(ehObjectStackMapLock);
+  auto it = ehObjectStackMap.find(ehStack);
+  if (it == ehObjectStackMap.end()) {
+    if (UNLIKELY(!ehObjectStackMap.insert(std::make_pair(ehStack, 1)).second)) {
+      EHLOG(ERROR) << "ehObjectStackMap.insert() in RecordExceptionStack() failed." << maple::endl;
+    }
+  } else {
+    it->second = it->second + 1;
+  }
+}
+
+static void SetExceptionClass(_Unwind_Exception &unwindException) {
+#if defined(__aarch64__)
+  unwindException.exception_class = kOurExceptionClass;
+#elif defined(__arm__)
+  if (strcpy_s(unwindException.exception_class, sizeof(kOurExceptionClass), kOurExceptionClass) != EOK) {
+    LOG(FATAL) << "SetExceptionClass strcpy_s() not return 0" << maple::endl;
+  };
+#endif
+}
+
+extern "C" {
+
+ATTR_NO_SANITIZE_ADDRESS
+void MplThrow(const MrtClass &thrownObject, bool isRet, bool isImplicitNPE) {
+  MExceptionHeader *exceptionHeader =
+      &(MplExceptionFromThrownObject(const_cast<MrtClass*>(&thrownObject))->exceptionHeader);
+
+  exceptionHeader->exceptionType = nullptr;
+  exceptionHeader->exceptionDestructor = nullptr;
+
+  SetExceptionClass(exceptionHeader->unwindHeader);
+
+  if (VLOG_IS_ON(eh)) {
+    uint64_t totalCount = IncExceptionTotalCount(1);
+    std::string exceptionType(reinterpret_cast<MObject*>(thrownObject)->GetClass()->GetName());
+    std::string exceptionCount = std::to_string(totalCount);
+    EHLOG(INFO) << "Exception Type : " << exceptionType << maple::endl;
+    EHLOG(INFO) << "Total Exception Count : " << totalCount << maple::endl;
+    RecordExceptionType(exceptionType + ":" + exceptionCount);
+
+    MplDumpStack("------------------ Dump Stack In Start To Throw Exception ------------------");
+
+    std::string exceptionStack;
+    MRT_DumpException(reinterpret_cast<jthrowable>(thrownObject), &exceptionStack);
+    RecordExceptionStack(exceptionStack);
+  }
+
+  RaiseException(exceptionHeader->unwindHeader, isRet, isImplicitNPE);
+
+
+  // This only happens when there is no handler, or some unexpected unwinding error happens.
+  MplDumpStack("------------------ Dump Stack As Throw Exception Fail ------------------");
+  EHLOG(FATAL) << "Throw Exception failed" << maple::endl;
+}
+
+static UnwindReasonCode UnwindBacktraceDumpStackCallback(const _Unwind_Context *context, void *ip) {
+  uintptr_t pc;
+#if defined(__arm__)
+  _Unwind_VRS_Get(const_cast<_Unwind_Context*>(context), _UVRSC_CORE, kPC, _UVRSD_UINT32, &pc);
+#else
+  pc = _Unwind_GetIP(const_cast<_Unwind_Context*>(context));
+#endif
+  if (*reinterpret_cast<uintptr_t*>(ip) == pc) {
+    EHLOG(ERROR) << "It could be a recursive function, pc : " << pc << maple::endl;
+    return _URC_NORMAL_STOP;
+  }
+  *reinterpret_cast<uintptr_t*>(ip) = pc;
+  if (pc) {
+    (void)JavaFrame::DumpProcInfo(pc);
+  } else {
+    EHLOG(ERROR) << "Unwind_Backtrace failed to get pc address :" << ip <<  maple::endl;
+  }
+  return _URC_NO_REASON;
+}
+
+void MplDumpStack(const std::string &msg) {
+  EHLOG(INFO) << "----------------------------- dump call stack -------------------------------------" << maple::endl;
+  if (msg != "") {
+    EHLOG(INFO) << "reason: " << msg << maple::endl;
+  }
+  uintptr_t ip = 0;
+  (void)_Unwind_Backtrace(UnwindBacktraceDumpStackCallback, &ip);
+}
+
+void MplCheck(bool ok, const std::string &msg) {
+  if (!ok) {
+    MplDumpStack(msg);
+    EHLOG(FATAL) << "Check failed" << maple::endl;
+  }
+}
+
+static MrtClass *MplWrapException(MrtClass obj, const void *sigIp = nullptr) {
+  if (obj == nullptr) {
+    MRT_ThrowNullPointerExceptionUnw();
+    // never returns here
+  }
+  const size_t kMplExceptionSize = sizeof(struct MplException);
+  // memory allocated here is freed when:
+  // 1. after exception is caught, during __java_begin_catch is called,
+  // 2. if exception is not caught, when we jump to the continuation of caller native frame.
+  MplException *mplException = reinterpret_cast<MplException*>(calloc(1, kMplExceptionSize));
+  // must to be successful from malloc above
+  if (mplException == nullptr) {
+    EHLOG(ERROR) << "--eh-- exception object malloc failed." << maple::endl;
+    std::terminate();
+  }
+
+  // since this record exception at the wrapper
+  RC_RUNTIME_INC_REF(obj);
+  // both are set, first is for root visitor
+  // second is for personality
+  maple::ExceptionVisitor::SetThrowningException(reinterpret_cast<jobject>(obj));
+  mplException->exceptionHeader.sigIP = const_cast<void*>(sigIp);
+  mplException->thrownObject = reinterpret_cast<jthrowable>(obj);
+  return reinterpret_cast<MrtClass*>(&(mplException->thrownObject));
+}
+
+void *MCC_JavaBeginCatch(const _Unwind_Exception *unwindException) {
+  maple::ExceptionVisitor::SetThrowningException(nullptr);
+  jthrowable thrown = GetThrownObject(*unwindException);
+  MRT_InvokeResetHandler();
+  free(GetThrownException(*unwindException));
+  return thrown;
+}
+
+void MCC_ThrowException(MrtClass obj) {
+  MrtClass *exPtr = MplWrapException(obj);
+  MplThrow(*exPtr, true);
+}
+
+// note: this function can not be called directly by java code.
+void MRT_DecRefThrowExceptionUnw(MrtClass obj, const void *sigIp) {
+  MrtClass *exPtr  = MplWrapException(obj, sigIp);
+
+  // we do not hava chance to dec ref-count for exception when we throw exception
+  // directly in runtime native code since this function changes control flow.
+  RC_RUNTIME_DEC_REF(obj);
+
+  MplThrow(*exPtr);
+}
+
+void MRT_DecRefThrowExceptionRet(MrtClass obj, bool isImplicitNPE, const void *sigIp) {
+  MrtClass *exPtr  = MplWrapException(obj, sigIp);
+  // we do not hava chance to dec ref-count for exception when we throw exception
+  // directly in runtime native code since this function changes control flow.
+  RC_RUNTIME_DEC_REF(obj);
+
+  MplThrow(*exPtr, true, isImplicitNPE);
+}
+
+void MCC_ThrowPendingException() {
+  jobject ex = maple::ExceptionVisitor::GetPendingException();
+  if (ex == nullptr) {
+    EHLOG(FATAL) << "pending exception is null" << maple::endl;
+  }
+
+  maple::ExceptionVisitor::SetPendingException(nullptr);
+  MrtClass *exPtr  = MplWrapException(ex, nullptr);
+
+  // we do not hava chance to dec ref-count for exception when we throw exception
+  // directly in runtime native code since this function changes control flow.
+  RC_RUNTIME_DEC_REF(ex);
+
+  MplThrow(*exPtr, true);
+}
+
+// alias for exported symbol
+void MRT_CheckException(bool ok, std::string msg) __attribute__((alias("MplCheck")));
+
+void MCC_RethrowException(MrtClass obj) __attribute__((alias("MCC_ThrowException")));
+
+} // extern "C"
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/exception/mrt_exception.cpp b/src/mrt/compiler-rt/src/exception/mrt_exception.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cba80d2495a078a2293e1e689f5a0bf154564d01
--- /dev/null
+++ b/src/mrt/compiler-rt/src/exception/mrt_exception.cpp
@@ -0,0 +1,630 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "exception/mrt_exception.h"
+
+#include <csignal>
+#include <sys/resource.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <climits>
+#include <cstdio>
+#include <cstring>
+#include <cassert>
+#include <list>
+#include <string>
+#include <map>
+#include "libs.h"
+#include "base/logging.h"
+#include "exception_store.h"
+
+#ifndef UNIFIED_MACROS_DEF
+#define UNIFIED_MACROS_DEF
+#include "unified.macros.def"
+#endif
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+
+namespace maplert {
+static uint64_t nativeExceptionTotalCount = 0;
+
+list<std::string> nativeEhObjectList;
+std::map<std::string, uint64_t> nativeEhObjectStackMap;
+std::mutex nativeEhObjectListLock;
+std::mutex nativeEhObjectStackMapLock;
+
+static inline uint64_t IncNativeExceptionTotalCount(uint64_t count) {
+  return __atomic_add_fetch(&nativeExceptionTotalCount, count, __ATOMIC_ACQ_REL);
+}
+
+static inline void RecordNativeExceptionType(const std::string ehNumType) {
+  std::lock_guard<std::mutex> lock(nativeEhObjectListLock);
+  nativeEhObjectList.push_back(ehNumType);
+}
+
+static void RecordNativeExceptionStack(std::string &ehStack) {
+  std::lock_guard<std::mutex> lock(nativeEhObjectStackMapLock);
+  auto it = nativeEhObjectStackMap.find(ehStack);
+  if (it == nativeEhObjectStackMap.end()) {
+    if (nativeEhObjectStackMap.insert(std::make_pair(ehStack, 1)).second != true) {
+      EHLOG(ERROR) << "record_nateve_exception_stack insert() not return true" << maple::endl;
+    }
+  } else {
+    it->second = it->second + 1;
+  }
+}
+
+static void ValidateThrowableException(const MrtClass ex) {
+  CHECK(ex != nullptr) << "the thrown exception must not be null" << maple::endl;
+  bool throwable = reinterpret_cast<MObject*>(ex)->IsInstanceOf(*WellKnown::GetMClassThrowable());
+  CHECK(throwable) << "should not throw a nonthrowable object" << maple::endl;
+}
+
+enum ExceptionType : uint8_t {
+  kErrno = 0,
+  kMesgAndCause,
+  kMesg,
+  kCause,
+  kNull
+};
+
+static MrtClass NewExceptionImpl(const MClass *exCls, const char *kMsg, const MrtClass cause,
+                                 const char *sig, const ExceptionType type) {
+  MObject *newex = nullptr;
+  MethodMeta *exceptionConstruct = exCls->GetDeclaredConstructor(sig);
+  CHECK(exceptionConstruct != nullptr) << "failed to find constructor " << sig << maple::endl;
+  switch (type) {
+    case ExceptionType::kErrno : {
+      ObjHandle<MString> jmsg(NewStringUTF(kMsg, strlen(kMsg)));
+      CHECK(jmsg() != 0) << "failed to create jstring object for exception message" << maple::endl;
+      if (exceptionConstruct == nullptr || jmsg() == 0) { EHLOG(FATAL) << "ex msg : " << kMsg << maple::endl; }
+      newex = MObject::NewObject(*exCls, exceptionConstruct, jmsg.AsRaw(), 0);
+      break;
+    }
+    case ExceptionType::kMesgAndCause : {
+      ObjHandle<MString> jmsg(NewStringUTF(kMsg, strlen(kMsg)));
+      CHECK(jmsg() != 0) << "failed to create jstring object for exception message" << maple::endl;
+      if (exceptionConstruct == nullptr || jmsg() == 0) { EHLOG(FATAL) << "ex msg : " << kMsg << maple::endl; }
+      newex = MObject::NewObject(*exCls, exceptionConstruct, jmsg.AsRaw(), cause);
+      break;
+    }
+    case ExceptionType::kMesg : {
+      ObjHandle<MString> jmsg(NewStringUTF(kMsg, strlen(kMsg)));
+      CHECK(jmsg() != 0) << "failed to create jstring object for exception message" << maple::endl;
+      if (exceptionConstruct == nullptr || jmsg() == 0) { EHLOG(FATAL) << "ex msg : " << kMsg << maple::endl; }
+      newex = MObject::NewObject(*exCls, exceptionConstruct, jmsg.AsRaw());
+      break;
+    }
+    case ExceptionType::kCause :
+      newex = MObject::NewObject(*exCls, exceptionConstruct, cause);
+      break;
+    default :
+      newex = MObject::NewObject(*exCls, exceptionConstruct);
+      break;
+  }
+  if (newex == nullptr) {
+    EHLOG(ERROR) << "new exception object is nullptr" << maple::endl;
+  }
+  return reinterpret_cast<MrtClass>(newex);
+}
+
+static MrtClass NewException(MrtClass classType, const char *kMsg = "unknown reason", MrtClass cause = nullptr) {
+  CHECK(classType != nullptr) << "invalid exception class type: null" << maple::endl;
+  if (classType == nullptr) {
+    return nullptr;
+  }
+  MClass *exceptioncls = reinterpret_cast<MClass*>(classType);
+  ScopedHandles sHandles;
+  if (!strcmp(exceptioncls->GetName(), "Landroid/system/ErrnoException;")) {
+    return NewExceptionImpl(exceptioncls, kMsg, cause, "(Ljava/lang/String;I)V", ExceptionType::kErrno);
+  }
+  if (kMsg != nullptr && cause != nullptr) {
+    return NewExceptionImpl(exceptioncls, kMsg, cause,
+                            "(Ljava/lang/String;Ljava/lang/Throwable;)V", ExceptionType::kMesgAndCause);
+  } else if (kMsg != nullptr && cause == nullptr) {
+    return NewExceptionImpl(exceptioncls, kMsg, cause, "(Ljava/lang/String;)V", ExceptionType::kMesg);
+  } else if (kMsg == nullptr && cause != nullptr) {
+    return NewExceptionImpl(exceptioncls, nullptr, cause, "(Ljava/lang/Throwable;)V", ExceptionType::kCause);
+  } else {
+    return NewExceptionImpl(exceptioncls, nullptr, cause, "()V", ExceptionType::kNull);
+  }
+}
+
+extern "C" void MRT_DumpException(jthrowable exObj, std::string *exceptionStack) {
+  MObject *ex = reinterpret_cast<MObject*>(exObj);
+  if (ex == nullptr) {
+    return;
+  }
+
+  bool throwable = ex->IsInstanceOf(*WellKnown::GetMClassThrowable());
+  if (throwable) {
+    MClass *clsThrowable = ex->GetClass();
+    if (clsThrowable == nullptr) {
+      EHLOG(ERROR) << "Cannot Find the corresponding Exception Class" << maple::endl;
+      return;
+    }
+
+    if (exceptionStack != nullptr) {
+      exceptionStack->append(clsThrowable->GetName()).append("\n");
+    } else {
+      EHLOG(INFO) << "-- exception class -- " << clsThrowable->GetName() << maple::endl;
+    }
+
+    FieldMeta *fid = clsThrowable->GetField("backtrace");
+    if (fid == nullptr) {
+      EHLOG(ERROR) << "Cannot Find the backtrace field in Class " << clsThrowable->GetName() << maple::endl;
+      return;
+    }
+
+    jlongArray backtrace = reinterpret_cast<jlongArray>(fid->GetObjectValue(ex));
+    if (!backtrace) {
+      EHLOG(ERROR) << "Cannot Find the backtrace Array in Class " << clsThrowable->GetName() << maple::endl;
+      return;
+    }
+    MArray *backtraceArray = reinterpret_cast<MArray*>(backtrace);
+    uint32_t size = backtraceArray->GetLength();
+    jlong *array = reinterpret_cast<jlong*>(backtraceArray->ConvertToCArray());
+
+    for (uint32_t i = 0; i < size; ++i) {
+      (void)JavaFrame::DumpProcInfo(static_cast<uintptr_t>(array[i]), exceptionStack);
+    }
+    RC_LOCAL_DEC_REF(backtrace);
+  } else {
+    EHLOG(ERROR) << "object is not an exception!" << maple::endl;
+  }
+}
+
+extern "C" void MRT_DumpExceptionForLog(jthrowable exObj) {
+  MObject *ex = reinterpret_cast<MObject*>(exObj);
+  if (ex == nullptr) {
+    return;
+  }
+
+  bool throwable = ex->IsInstanceOf(*WellKnown::GetMClassThrowable());
+  if (throwable) {
+    MClass *clsThrowable = ex->GetClass();
+    if (clsThrowable == nullptr) {
+      EHLOG(ERROR) << "Cannot Find the corresponding Exception Class" << maple::endl;
+      return;
+    }
+
+    EHLOG(ERROR) << "-- exception class -- " << clsThrowable->GetName() <<
+        maple::endl;
+
+    FieldMeta *fid = clsThrowable->GetField("backtrace");
+    if (fid == nullptr) {
+      EHLOG(ERROR) << "Cannot Find the backtrace field in Class " << clsThrowable->GetName() << maple::endl;
+      return;
+    }
+
+    jlongArray backtrace = reinterpret_cast<jlongArray>(fid->GetObjectValue(ex));
+    if (!backtrace) {
+      EHLOG(ERROR) << "Cannot Find the backtrace Array in Class " << clsThrowable->GetName() << maple::endl;
+      return;
+    }
+
+    MArray *backtraceArray = reinterpret_cast<MArray*>(backtrace);
+    uint32_t size = backtraceArray->GetLength();
+    jlong *array = reinterpret_cast<jlong*>(backtraceArray->ConvertToCArray());
+
+    for (uint32_t i = 0; i < size; ++i) {
+      JavaFrame::DumpProcInfoLog(array[i]);
+    }
+    RC_LOCAL_DEC_REF(backtrace);
+  } else {
+    EHLOG(ERROR) << "object is not an exception!" << maple::endl;
+  }
+}
+
+extern "C" void MRT_DumpExceptionTypeCount(std::ostream &os) {
+  std::lock_guard<std::mutex> lock(ehObjectListLock);
+  os << "-- eh object list --" << std::endl;
+  for (auto eh_object : ehObjectList) {
+    os << eh_object << std::endl;
+  }
+}
+
+extern "C" void MRT_DumpExceptionStack(std::ostream &os) {
+  std::lock_guard<std::mutex> lock(ehObjectStackMapLock);
+  os << "-- eh object-stack map --" << std::endl;
+  for (auto it = ehObjectStackMap.begin(); it != ehObjectStackMap.end(); ++it) {
+    os << "----eh stack----" << std::endl;
+    os << it->first << std::endl;
+    os << "----total count----: " << it->second << std::endl;
+  }
+}
+
+extern "C" void MRT_DumpNativeExceptionTypeCount(std::ostream &os) {
+  std::lock_guard<std::mutex> lock(nativeEhObjectListLock);
+  os << "-- native eh object list --" << std::endl;
+  for (auto &native_eh_object : nativeEhObjectList) {
+    os << native_eh_object << std::endl;
+  }
+}
+
+extern "C" void MRT_DumpNativeExceptionStack(std::ostream &os) {
+  std::lock_guard<std::mutex> lock(nativeEhObjectStackMapLock);
+  os << "-- native eh object-stack map --" << std::endl;
+  for (auto it = nativeEhObjectStackMap.begin(); it != nativeEhObjectStackMap.end(); ++it) {
+    os << "----native eh stack----" << std::endl;
+    os << it->first << std::endl;
+    os << "----total count----: " << it->second << std::endl;
+  }
+}
+
+// "raise" an async exception from JNI code
+extern "C" void MRT_ThrowExceptionSafe(jobject ex) {
+  ValidateThrowableException(ex);
+  MRT_ThrowExceptionUnsafe(ex);
+}
+
+extern "C" void MRT_ThrowNewExceptionInternalType(MrtClass classType, const char *msg) {
+  MrtClass newex = NewException(classType, msg);
+  if (newex == nullptr) {
+    return;
+  }
+  MRT_ThrowExceptionSafe(reinterpret_cast<jobject>(newex));
+  RC_LOCAL_DEC_REF(newex);
+}
+
+extern "C" void MRT_ThrowNewException(const char *className, const char *msg) {
+  jclass exceptionCls = MRT_ReflectClassForCharName(className, false, nullptr);
+  if (!exceptionCls) {
+    EHLOG(FATAL) << "exceptioncls is null." << maple::endl;
+  }
+  MRT_ThrowNewExceptionInternalType(reinterpret_cast<MrtClass>(exceptionCls), msg);
+}
+
+extern "C" jobject MRT_PendingException() {
+  jobject e = maple::ExceptionVisitor::GetPendingException();
+  if (e != nullptr) {
+    RC_LOCAL_INC_REF(e);
+  }
+  return e;
+}
+
+extern "C"  bool MRT_HasPendingException() {
+  jobject e = maple::ExceptionVisitor::GetPendingException();
+  return (e != nullptr);
+}
+
+extern "C" void MRT_ThrowExceptionUnsafe(jobject ex) {
+  if (VLOG_IS_ON(eh)) {
+    uint64_t nativeTotalCount = IncNativeExceptionTotalCount(1);
+    std::string nativeExceptionType(reinterpret_cast<MObject*>(ex)->GetClass()->GetName());
+    std::string nativeExceptionCount = std::to_string(nativeTotalCount);
+    EHLOG(INFO) << "Native Exception Type: " << nativeExceptionType << maple::endl;
+    EHLOG(INFO) << "Total Native Exception Count: " << nativeTotalCount << maple::endl;
+    RecordNativeExceptionType(nativeExceptionType + ":" + nativeExceptionCount);
+    std::string nativeExceptionStack;
+    MRT_DumpException(reinterpret_cast<jthrowable>(ex), &nativeExceptionStack);
+    RecordNativeExceptionStack(nativeExceptionStack);
+  }
+
+  RC_RUNTIME_INC_REF(ex);
+  maple::ExceptionVisitor::SetPendingException(ex);
+}
+
+extern "C" void MRT_CheckThrowPendingExceptionRet() {
+  jobject ex = MRT_PendingException();
+  if (ex) {
+    MRT_ClearPendingException();
+    MRT_DecRefThrowExceptionRet(ex);
+  }
+}
+
+extern "C" void MRT_ClearPendingException() {
+  jobject e = maple::ExceptionVisitor::GetPendingException();
+  if (e != nullptr) {
+    RC_RUNTIME_DEC_REF(e);
+    maple::ExceptionVisitor::SetPendingException(nullptr);
+  }
+}
+
+extern "C" void MRT_ClearThrowingException() {
+  jobject e = maple::ExceptionVisitor::GetThrowningException();
+  if (e != nullptr) {
+    RC_RUNTIME_DEC_REF(e);
+    maple::ExceptionVisitor::SetThrowningException(nullptr);
+  }
+}
+
+// raise a sync exception from runtime native code
+// These function will be removed later.
+extern "C" void MRT_CheckThrowPendingExceptionUnw() {
+  jobject ex = MRT_PendingException();
+  if (ex) {
+    MRT_ClearPendingException();
+    MRT_DecRefThrowExceptionUnw(ex);
+  }
+}
+
+ATTR_NO_SANITIZE_ADDRESS
+extern "C" void ThrowExceptionUnw(MrtClass ex) {
+  jobject e = maple::ExceptionVisitor::GetPendingException();
+  CHECK(e == nullptr) << "pending exception needs to be handled" << maple::endl;
+
+  ValidateThrowableException(ex);
+  MRT_DecRefThrowExceptionUnw(ex);
+}
+
+ATTR_NO_SANITIZE_ADDRESS
+extern "C" void ThrowExceptionRet(MrtClass ex) {
+  jobject e = maple::ExceptionVisitor::GetPendingException();
+  CHECK(e == nullptr) << "pending exception needs to be handled" << maple::endl;
+
+  ValidateThrowableException(ex);
+  MRT_DecRefThrowExceptionRet(ex);
+}
+
+extern "C" void ThrowNewExceptionInternalTypeUnw(MrtClass classType, const char *kMsg) {
+  MrtClass throwable = NewException(classType, kMsg);
+  ThrowExceptionUnw(throwable);
+}
+
+extern "C" void ThrowNewExceptionInternalTypeRet(MrtClass classType, const char *kMsg) {
+  MrtClass throwable = NewException(classType, kMsg);
+  ThrowExceptionRet(throwable);
+}
+
+extern "C" void MRT_ThrowNewExceptionRet(const char *className, const char *msg) {
+  jclass exceptionCls = MRT_ReflectClassForCharName(className, false, nullptr);
+  ThrowNewExceptionInternalTypeRet(reinterpret_cast<MrtClass>(exceptionCls), msg);
+}
+
+extern "C" void MRT_ThrowNewExceptionUnw(const char *className, const char *msg) {
+  jclass exceptionCls = MRT_ReflectClassForCharName(className, false, nullptr);
+  ThrowNewExceptionInternalTypeUnw(reinterpret_cast<MrtClass>(exceptionCls), msg);
+}
+
+extern "C" void MRT_ThrowImplicitNullPointerExceptionUnw(const void *sigIP) {
+  jobject e = maple::ExceptionVisitor::GetPendingException();
+  CHECK(e == nullptr) << "pending exception needs to be handled" << maple::endl;
+
+  MrtClass throwable = NewException(*WellKnown::GetMClassNullPointerException());
+  ValidateThrowableException(throwable);
+  MRT_DecRefThrowExceptionRet(throwable, true, sigIP);
+}
+
+extern "C" void MRT_ThrowNullPointerExceptionUnw() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassNullPointerException());
+}
+
+extern "C" void MRT_ThrowArithmeticExceptionUnw() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassArithmeticException());
+}
+
+extern "C" void MRT_ThrowInterruptedExceptionUnw() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassInterruptedException());
+}
+
+extern "C" void MRT_ThrowClassCastExceptionUnw(const std::string msg) {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassClassCastException(), msg.c_str());
+}
+
+extern "C" void MRT_ThrowArrayStoreExceptionUnw(const std::string msg) {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassArrayStoreException(), msg.c_str());
+}
+
+extern "C" void MRT_ThrowArrayIndexOutOfBoundsExceptionUnw(int32_t length, int32_t index) {
+  // formatting information about exception
+  char msg[kBufferSize / 2] = { 0 }; // kBufferSize / 2 = 64
+  // MRT_ThrowException_Unw does not return, so cannot apply for heap memory here.
+  if (sprintf_s(msg, sizeof(msg), "length=%d; index=%d", length, index) < 0) {
+    EHLOG(ERROR) << "MRT_ThrowArrayIndexOutOfBoundsExceptionUnw sprintf_s return -1" << maple::endl;
+  }
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassArrayIndexOutOfBoundsException(), msg);
+}
+
+extern "C" void MRT_ThrowUnsatisfiedLinkErrorUnw() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassUnsatisfiedLinkError());
+}
+
+extern "C" void MRT_ThrowExceptionInInitializerErrorUnw(MrtClass cause) {
+  MrtClass throwable = NewException(*WellKnown::GetMClassExceptionInInitializerError(), nullptr, cause);
+  if (cause != nullptr) {
+    RC_RUNTIME_DEC_REF(cause);
+  }
+  ThrowExceptionUnw(throwable);
+}
+
+extern "C" void MRT_ThrowNoSuchMethodErrorUnw(const std::string &msg) {
+  MrtClass throwable = NewException(*WellKnown::GetMClassNoSuchMethodError(), msg.c_str());
+  ThrowExceptionUnw(throwable);
+}
+
+extern "C" void MRT_ThrowNoSuchFieldErrorUnw(const std::string &msg) {
+  MrtClass throwable = NewException(*WellKnown::GetMClassNoSuchFieldError(), msg.c_str());
+  ThrowExceptionUnw(throwable);
+}
+
+extern "C" void MRT_ThrowNoClassDefFoundErrorUnw(const char *msg) {
+  MrtClass throwable = NewException(*WellKnown::GetMClassNoClassDefFoundError(), msg);
+  ThrowExceptionUnw(throwable);
+}
+
+extern "C" void MRT_ThrowNoClassDefFoundErrorClassUnw(const void *classInfo) {
+  char msg[kBufferSize * 2] = { 0 }; // kBufferSize * 2 = 256
+  {
+    // ThrowExceptionUnw does not return, so name must be in closed scope or
+    // use smart pointer.
+    std::string name;
+    (reinterpret_cast<MClass*>(const_cast<void*>(classInfo)))->GetTypeName(name);
+    if (sprintf_s(msg, sizeof(msg), "Could not initialize class %s", name.c_str()) < 0) {
+      LOG(ERROR) << "MRT_ThrowNoClassDefFoundErrorClassUnw sprintf_s return -1" << maple::endl;
+    }
+  }
+  MrtClass throwable = NewException(*WellKnown::GetMClassNoClassDefFoundError(), msg);
+  ThrowExceptionUnw(throwable);
+}
+
+extern "C" void MRT_ThrowStringIndexOutOfBoundsExceptionUnw() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassStringIndexOutOfBoundsException());
+}
+
+extern "C" void MRT_ThrowVerifyErrorUnw(const std::string &msg) {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassVerifyError(), msg.c_str());
+}
+
+// all no Unw suffixed functions are used to throw exception by recording pending
+extern "C" void MRT_ThrowImplicitNullPointerException() {
+  jobject e = maple::ExceptionVisitor::GetPendingException();
+  CHECK(e == nullptr) << "pending exception needs to be handled" << maple::endl;
+
+  MrtClass throwable = NewException(WellKnown::GetMClassNullPointerException());
+  MRT_ThrowExceptionSafe(reinterpret_cast<jobject>(throwable));
+  RC_LOCAL_DEC_REF(throwable);
+}
+
+extern "C" void MRT_ThrowNullPointerException() {
+  MRT_ThrowNewExceptionInternalType(WellKnown::GetMClassNullPointerException());
+}
+
+extern "C" void MRT_ThrowArithmeticException() {
+  MRT_ThrowNewExceptionInternalType(WellKnown::GetMClassArithmeticException());
+}
+
+extern "C" void MRT_ThrowInterruptedException() {
+  MRT_ThrowNewExceptionInternalType(WellKnown::GetMClassInterruptedException());
+}
+
+extern "C" void MRT_ThrowClassCastException(const std::string msg) {
+  MRT_ThrowNewExceptionInternalType(WellKnown::GetMClassClassCastException(), msg.c_str());
+}
+
+extern "C" void MRT_ThrowArrayStoreException(const std::string msg) {
+  MRT_ThrowNewExceptionInternalType(WellKnown::GetMClassArrayStoreException(), msg.c_str());
+}
+
+extern "C" void MRT_ThrowArrayIndexOutOfBoundsException(int32_t length, int32_t index) {
+  // formatting information about exception
+  char msg[kBufferSize / 2] = { 0 }; // kBufferSize / 2 = 64
+  // MRT_ThrowException_Unw does not return, so cannot apply for heap memory here.
+  if (sprintf_s(msg, sizeof(msg), "length=%d; index=%d", length, index) < 0) {
+    EHLOG(ERROR) << "MRT_ThrowArrayIndexOutOfBoundsExceptionUnw sprintf_s return -1" << maple::endl;
+  }
+  ThrowNewExceptionInternalTypeRet(WellKnown::GetMClassArrayIndexOutOfBoundsException(), msg);
+}
+
+extern "C" void MRT_ThrowUnsatisfiedLinkError() {
+  MRT_ThrowNewExceptionInternalType(WellKnown::GetMClassUnsatisfiedLinkError());
+}
+
+extern "C" void MRT_ThrowNoSuchMethodError(const std::string &msg) {
+  MRT_ThrowNewExceptionInternalType(WellKnown::GetMClassNoSuchMethodError(), msg.c_str());
+}
+
+extern "C" void MRT_ThrowNoSuchFieldError(const std::string &msg) {
+  MRT_ThrowNewExceptionInternalType(WellKnown::GetMClassNoSuchFieldError(), msg.c_str());
+}
+
+extern "C" void MRT_ThrowVerifyError(const std::string &msg) {
+  MRT_ThrowNewExceptionInternalType(*WellKnown::GetMClassVerifyError(), msg.c_str());
+}
+
+extern "C" void MRT_ThrowStringIndexOutOfBoundsException() {
+  MRT_ThrowNewExceptionInternalType(WellKnown::GetMClassStringIndexOutOfBoundsException());
+}
+
+extern "C" void MRT_ThrowExceptionInInitializerError(MrtClass cause) {
+  MrtClass throwable = NewException(*WellKnown::GetMClassExceptionInInitializerError(), nullptr, cause);
+  if (throwable == nullptr) {
+    EHLOG(FATAL) << "Create New Exception is fail" << maple::endl;
+  }
+  if (cause != nullptr) {
+    RC_RUNTIME_DEC_REF(cause);
+  }
+  MRT_ThrowExceptionSafe(reinterpret_cast<jobject>(throwable));
+  RC_LOCAL_DEC_REF(throwable);
+}
+
+extern "C" void MRT_ThrowNoClassDefFoundError(const std::string &msg) {
+  MrtClass throwable = NewException(WellKnown::GetMClassNoClassDefFoundError(), msg.c_str());
+  if (throwable == nullptr) {
+    EHLOG(FATAL) << "Create New Exception is fail" << maple::endl;
+  }
+  MRT_ThrowExceptionSafe(reinterpret_cast<jobject>(throwable));
+  RC_LOCAL_DEC_REF(throwable);
+}
+
+// all MCC prefixed functions are used only for maple compiler to generate code
+extern "C" void MCC_CheckThrowPendingException() {
+  MRT_SetReliableUnwindContextStatus();
+  jobject ex = MRT_PendingException();
+  if (ex) {
+    MRT_ClearPendingException();
+    MRT_DecRefThrowExceptionRet(ex);
+  }
+}
+
+extern "C" void MCC_ThrowNullArrayNullPointerException() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassNullPointerException(), "Attempt to get length of null array");
+}
+
+extern "C" void MCC_ThrowNullPointerException() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassNullPointerException());
+}
+
+extern "C" void MCC_ThrowArithmeticException() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassArithmeticException());
+}
+
+extern "C" void MCC_ThrowInterruptedException() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassInterruptedException());
+}
+
+extern "C" void MCC_ThrowClassCastException(const char *msg) {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassClassCastException(), msg);
+}
+
+extern "C" void MCC_ThrowArrayIndexOutOfBoundsException(const char *msg) {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassArrayIndexOutOfBoundsException(), msg);
+}
+
+extern "C" void MCC_ThrowUnsatisfiedLinkError() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassUnsatisfiedLinkError());
+}
+
+extern "C" void MCC_ThrowSecurityException() {
+#ifndef __OPENJDK__
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassSecurityException());
+#endif // __OPENJDK__
+}
+
+extern "C" void MCC_ThrowExceptionInInitializerError(MrtClass cause) {
+  MrtClass throwable = NewException(*WellKnown::GetMClassExceptionInInitializerError(), nullptr, cause);
+  ThrowExceptionUnw(throwable);
+}
+
+extern "C" void MCC_ThrowNoClassDefFoundError(const MrtClass classInfo) {
+  char msg[kBufferSize * 2] = { 0 }; // kBufferSize * 2 = 256
+  {
+    std::string name;
+    reinterpret_cast<MClass*>(classInfo)->GetTypeName(name);
+    if (sprintf_s(msg, sizeof(msg), "Could not initialize class %s", name.c_str()) < 0) {
+      EHLOG(ERROR) << "MRT_ThrowNoClassDefFoundErrorUnw sprintf_s return -1" << maple::endl;
+    }
+  }
+
+  MRT_ThrowNoClassDefFoundErrorUnw(msg);
+}
+
+extern "C" void MCC_ThrowStringIndexOutOfBoundsException() {
+  ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassStringIndexOutOfBoundsException());
+}
+} // namespace maplert
+
diff --git a/src/mrt/compiler-rt/src/exception/stack_unwinder.cpp b/src/mrt/compiler-rt/src/exception/stack_unwinder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b6d727c8069b6ce2e3ca47a6dd916588b9be3ee
--- /dev/null
+++ b/src/mrt/compiler-rt/src/exception/stack_unwinder.cpp
@@ -0,0 +1,1106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "exception/stack_unwinder.h"
+
+#include <cstring>
+#include <cstdint>
+#include <cinttypes>
+#include <ucontext.h>
+#include <pthread.h>
+#include <dlfcn.h>
+
+#include "libs.h"
+#include "mm_config.h"
+#include "panic.h"
+#include "syscall.h"
+#include "exception_store.h"
+#include "exception/mpl_exception.h"
+#include "chosen.h"
+#include "collie.h"
+#include "mutator_list.h"
+#include "interp_support.h"
+
+namespace maplert {
+const int kBuffSize = 24;
+static RemoteUnwinder remoteUnwinder;
+
+#define MAPLE_RECORD_METHOD_INFO_AT_START_PROC
+
+// analyze the instruction:
+//  .word __methods__Lexcp01802_3B+56-.
+// pc belongs to section .text.java
+//   desc - pc
+// desc belongs to section .rodata
+//   method info - desc
+// method info belongs to .data
+// using uintptr_t as offset means we should put section .rodata after section .text.java, thus use its signed
+// counter-part.
+const MethodDesc *JavaFrame::GetMethodDesc(const uint32_t *startPC) {
+  const uint32_t *offsetAddr = startPC - kMethodDescOffset;
+  const MethodDesc *methodDesc = reinterpret_cast<const MethodDesc*>(
+      reinterpret_cast<uintptr_t>(offsetAddr) + static_cast<uintptr_t>(*offsetAddr));
+  return methodDesc;
+}
+
+uint64_t *JavaFrame::GetMethodMetadata(const uint32_t *startPC) {
+  const MethodDesc *methodDesc = GetMethodDesc(startPC);
+  const uint32_t *offsetAddr = &(methodDesc->metadataOffset);
+  uint64_t *metadata = reinterpret_cast<uint64_t*>(
+      reinterpret_cast<uintptr_t>(offsetAddr) + static_cast<uintptr_t>(*offsetAddr));
+  return metadata;
+}
+
+jclass JavaFrame::GetDeclaringClass(const uint64_t *md) {
+  if (md != nullptr) {
+    const MethodMetaBase *methodMeta = reinterpret_cast<const MethodMetaBase*>(md);
+    void *cls = methodMeta->GetDeclaringClass();
+    if (cls == nullptr) {
+      LOG(FATAL) << "class should not be null" << maple::endl;
+    }
+    // some faked compact methods don't have a valid declaringClass
+    // for e.g., the methods in duplicateFunc.s and hashcode.s
+    if (MRT_ReflectIsClass(reinterpret_cast<jobject>(cls))) {
+      return reinterpret_cast<jclass>(cls);
+    }
+  }
+  return nullptr;
+}
+
+// class name mangled by maple
+void JavaFrame::GetMapleClassName(std::string &name, const uint64_t *md) {
+  if (md != nullptr) {
+    jclass cls = GetDeclaringClass(md);
+    if (cls != nullptr) {
+      name.append(reinterpret_cast<MClass*>(cls)->GetName());
+    } else {
+      name.append("figo.internal.class");
+    }
+  }
+}
+
+void JavaFrame::GetJavaClassName(std::string &name, const uint64_t *md) {
+  if (md != nullptr) {
+    jclass cls = GetDeclaringClass(md);
+    if (cls) {
+      reinterpret_cast<MClass*>(cls)->GetBinaryName(name);
+    } else {
+      name.append("figo.internal.class");
+    }
+  }
+}
+
+// fill in the string of method and type name
+void JavaFrame::GetJavaMethodSignatureName(std::string &name, const void *md) {
+  if (md != nullptr) {
+    const MethodMetaBase *methodMeta = reinterpret_cast<const MethodMetaBase*>(md);
+    const std::string mathodName = methodMeta->GetName();
+    name.append(mathodName);
+  }
+}
+
+// fill in the string of method
+void JavaFrame::GetJavaMethodName(std::string &name, const void *md) {
+  if (md != nullptr) {
+    const MethodMetaBase *methodMeta = reinterpret_cast<const MethodMetaBase*>(md);
+    name = methodMeta->GetName();
+  }
+}
+
+bool JavaFrame::GetMapleMethodFullName(std::string &name, const uint64_t *md) {
+  if (md != nullptr) {
+    GetJavaClassName(name, md);
+    const MethodMetaBase *methodMeta = reinterpret_cast<const MethodMetaBase*>(md);
+    const std::string methodName = methodMeta->GetName();
+    std::string sigName;
+    methodMeta->GetSignature(sigName);
+    name.append("|").append(methodName).append("|").append(sigName);
+    return true;
+  }
+  return false;
+}
+
+// <class-name>|<method-name>|([Ljava/lang/String;)V
+bool JavaFrame::GetMapleMethodFullName(std::string &name, const uint64_t *md, const void *ip) {
+  if (GetMapleMethodFullName(name, md)) {
+    return true;
+  } else {
+    Dl_info addrInfo;
+    int dladdrOk = dladdr(ip, &addrInfo);
+    if (dladdrOk && addrInfo.dli_sname) {
+      name.append(addrInfo.dli_sname);
+      EHLOG(ERROR) << "Method meta data is invalid " << reinterpret_cast<uint64_t>(md) <<
+          " for " << addrInfo.dli_sname << " at PC " << reinterpret_cast<const void*>(ip) << maple::endl;
+      return true;
+    }
+  }
+  return false;
+}
+
+// <class-name>.<method-name>([Ljava/lang/String;)V
+bool JavaFrame::GetJavaMethodFullName(std::string &name, const uint64_t *md) {
+  if (md != nullptr) {
+    GetJavaClassName(name, md);
+    const MethodMetaBase *methodMeta = reinterpret_cast<const MethodMetaBase*>(md);
+    const std::string mathodName = methodMeta->GetName();
+    std::string sigName;
+    methodMeta->GetSignature(sigName);
+    name.append(".").append(mathodName).append(sigName);
+    return true;
+  }
+  return false;
+}
+
+static bool DumpProcInfoForJava(
+    uintptr_t pc, const LinkerLocInfo &procInfo, const LinkerMFileInfo &mplInfo, std::string *symbolInfo) {
+  string methodName;
+  const uint64_t *md = JavaFrame::GetMethodMetadata(reinterpret_cast<uint32_t*>(procInfo.addr));
+  if (UNLIKELY(!JavaFrame::GetJavaMethodFullName(methodName, md))) {
+    EHLOG(ERROR) << "JavaFrame::GetJavaMethodFullName() in DumpProcInfoForJava() return false." << maple::endl;
+    return false;
+  }
+  uintptr_t lineNumber = pc - 1 - reinterpret_cast<uintptr_t>(procInfo.addr);
+
+  if (symbolInfo != nullptr) {
+    char ipBuf[kBuffSize] = {0};
+    if (UNLIKELY(sprintf_s(ipBuf, sizeof(ipBuf), "0x%llx", static_cast<long long unsigned>(pc)) == -1)) {
+      EHLOG(ERROR) << "sprintf_s() in DumpProcInfoForJava() return -1 for failed." << maple::endl;
+      return false;
+    }
+    symbolInfo->append("\t").append(ipBuf).append(" in ").append(methodName).append(" at ").append(
+        mplInfo.name).append(":").append(std::to_string(lineNumber)).append("\n");
+  } else {
+    EHLOG(INFO) << "\t" << std::hex << "0x" << pc << " in " << methodName <<
+        " at " << mplInfo.name << ":" << std::dec << lineNumber << maple::endl;
+  }
+  return true;
+}
+
+uint64_t JavaFrame::GetRelativePc(const std::string &soName, uint64_t pc, LinkerMFileInfo *mplInfo) {
+  if (mplInfo == nullptr) {
+    mplInfo = LinkerAPI::Instance().GetLinkerMFileInfoByName(soName);
+  }
+  if (mplInfo == nullptr) {
+    LOG(ERROR) << "mplInfo is nullptr" << maple::endl;
+    return 0;
+  }
+
+  if (mplInfo->elfBase == nullptr) {
+    (void)LinkerAPI::Instance().CheckLinkerMFileInfoElfBase(*mplInfo);
+  }
+  return pc - reinterpret_cast<uintptr_t>(mplInfo->elfBase);
+}
+
+void JavaFrame::DumpProcInfoLog(jlong elem) {
+  uint64_t ip = static_cast<uint64_t>(elem);
+  LinkerLocInfo info;
+  LinkerMFileInfo *mplInfo = nullptr;
+  bool isJava = LinkerAPI::Instance().GetJavaTextInfo(reinterpret_cast<uint32_t*>(ip), &mplInfo, info, false);
+  if (isJava) {
+    uint64_t *md = JavaFrame::GetMethodMetadata(reinterpret_cast<uint32_t*>(info.addr));
+    std::string declaringClass;
+    std::string methodName;
+    std::string fileName;
+    JavaFrame::GetJavaClassName(declaringClass, md);
+    JavaFrame::GetJavaMethodSignatureName(methodName, md);
+    fileName = mplInfo->name;
+    uint64_t lineNumber = JavaFrame::GetRelativePc(fileName, static_cast<uintptr_t>(ip), mplInfo);
+    EHLOG(INFO) << declaringClass << ":" << methodName << ":" << fileName << ":" << lineNumber << maple::endl;
+  } else if (mplInfo != nullptr) {
+    std::string fileName = mplInfo->name;
+    uint64_t lineNumber = JavaFrame::GetRelativePc(fileName, static_cast<uintptr_t>(ip), mplInfo);
+    EHLOG(ERROR) << fileName << ":" << lineNumber << maple::endl;
+  } else {
+    EHLOG(ERROR) << "Could not get mplinfo." << maple::endl;
+  }
+}
+
+// use procInfo first if it is java code, then pc
+bool JavaFrame::DumpProcInfo(uintptr_t pc, std::string *symbolInfo) {
+  LinkerLocInfo info;
+  LinkerMFileInfo *mplInfo = nullptr;
+  bool isJava = LinkerAPI::Instance().GetJavaTextInfo(reinterpret_cast<uint32_t*>(pc), &mplInfo, info, false);
+  if (isJava) {
+    return DumpProcInfoForJava(pc, info, *mplInfo, symbolInfo);
+  } else {
+    Dl_info addrInfo;
+    int dladdrOk = dladdr(reinterpret_cast<void*>(pc), &addrInfo);
+    if (dladdrOk && addrInfo.dli_sname) {
+      std::string fileName(addrInfo.dli_fname);
+      uintptr_t lineNumber = pc - reinterpret_cast<uintptr_t>(addrInfo.dli_saddr);
+      EHLOG(INFO) << "\t" << std::hex << "0x" << pc << " in " << addrInfo.dli_sname <<
+          " at " << fileName << ":" << std::dec << lineNumber << maple::endl;
+    } else {
+      EHLOG(ERROR) << "\t" << std::hex << "0x" << pc << " in (unresolved symbol): dladdr() failed" <<
+          std::dec << maple::endl;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool JavaFrame::JavaMethodHasNoFrame(const uint32_t *ip) {
+  if (ip == nullptr) {
+    return false;
+  }
+
+  LinkerLocInfo info;
+  const uint32_t *end_proc = nullptr;
+  if (LinkerAPI::Instance().LocateAddress(const_cast<uint32_t*>(ip), info, false)) {
+    end_proc = const_cast<const uint32_t*>(
+        reinterpret_cast<uint32_t*>((reinterpret_cast<uintptr_t>(info.addr) + info.size)));
+  } else {
+    EHLOG(INFO) << "ip must be java method written with assembly. pc : " << ip << maple::endl;
+    return true;
+  }
+
+  // LSDA is placed just at end_proc, so end_proc is the start address of LSDA.
+  if (*end_proc == kAbnormalFrameTag) {
+    return true;
+  }
+  return false;
+}
+
+extern "C" void MRT_UpdateLastUnwindFrameLR(const uint32_t *lr) {
+  InitialUnwindContext &initialUnwindContext = maplert::TLMutator().GetInitialUnwindContext();
+  UnwindContext &initialContext = initialUnwindContext.GetContext();
+  initialUnwindContext.SetEffective(false);
+  initialContext.frame.lr = lr;
+  initialUnwindContext.SetEffective(true);
+}
+
+void UnwindContext::UpdateFrame(const uint32_t *pc, CallChain *fp) {
+  frame.ip = pc;
+  frame.fa = fp;
+  frame.ra = nullptr;
+  frame.lr = nullptr;
+  interpFrame = nullptr;
+}
+
+extern "C" void MRT_UpdateLastJavaFrame(const uint32_t *pc, void *fa) {
+  CallChain *fp = reinterpret_cast<CallChain*>(fa);
+  InitialUnwindContext &initialUnwindContext = maplert::TLMutator().GetInitialUnwindContext();
+  UnwindContext &initialContext = initialUnwindContext.GetContext();
+  initialUnwindContext.SetEffective(false);
+  initialContext.UpdateFrame(pc, fp);
+  initialUnwindContext.SetEffective(true);
+}
+
+extern "C" void MRT_UpdateLastUnwindContext(const uint32_t *pc, CallChain *fp, UnwindContextStatus status) {
+  InitialUnwindContext &initialUnwindContext = maplert::TLMutator().GetInitialUnwindContext();
+  UnwindContext &initialContext = initialUnwindContext.GetContext();
+  initialUnwindContext.SetEffective(false);
+  initialContext.UpdateFrame(pc, fp);
+  initialContext.status = status;
+  if (status != UnwindContextStatusIsIgnored) {
+    initialContext.SetInterpFrame(nullptr);
+    initialContext.TagDirectJavaCallee(false);
+  }
+  initialUnwindContext.SetEffective(true);
+}
+
+extern "C" void MRT_UpdateLastUnwindContextIfReliable(const uint32_t *pc, void *fa) {
+  CallChain *fp = reinterpret_cast<CallChain*>(fa);
+  InitialUnwindContext &initialUnwindContext = maplert::TLMutator().GetInitialUnwindContext();
+  UnwindContext &initialContext = initialUnwindContext.GetContext();
+  initialUnwindContext.SetEffective(false);
+  if (initialContext.status == UnwindContextIsReliable) {
+    initialContext.UpdateFrame(pc, fp);
+  }
+  initialUnwindContext.SetEffective(true);
+}
+
+extern "C" void MRT_SetRiskyUnwindContext(const uint32_t *pc, void *fa) {
+  CallChain *fp = reinterpret_cast<CallChain*>(fa);
+  MRT_UpdateLastUnwindContext(pc, fp, UnwindContextIsRisky);
+}
+
+extern "C" void MRT_SetReliableUnwindContextStatus() {
+  InitialUnwindContext &initialUnwindContext = maplert::TLMutator().GetInitialUnwindContext();
+  UnwindContext &initialContext = initialUnwindContext.GetContext();
+  initialUnwindContext.SetEffective(false);
+  initialContext.status = UnwindContextIsReliable;
+  initialContext.SetInterpFrame(nullptr);
+  initialContext.TagDirectJavaCallee(false);
+  initialUnwindContext.SetEffective(true);
+}
+
+#if !defined(__ANDROID__) || defined(__arm__)
+extern "C" void MCC_SetRiskyUnwindContext(uint32_t *pc, void *fp)
+__attribute__ ((alias ("MRT_SetRiskyUnwindContext")));
+
+extern "C" void MCC_SetReliableUnwindContext()
+__attribute__ ((alias ("MRT_SetReliableUnwindContextStatus")));
+#endif // __ANDROID__
+
+extern "C" void MRT_SetIgnoredUnwindContextStatus() {
+  InitialUnwindContext &initialUnwindContext = maplert::TLMutator().GetInitialUnwindContext();
+  UnwindContext &initialContext = initialUnwindContext.GetContext();
+  initialUnwindContext.SetEffective(false);
+  initialContext.status = UnwindContextStatusIsIgnored;
+  initialUnwindContext.SetEffective(true);
+}
+
+extern "C" void MCC_SetIgnoredUnwindContext()
+__attribute__ ((alias ("MRT_SetIgnoredUnwindContextStatus")));
+
+extern "C" void MRT_SaveLastUnwindContext(CallChain *frameAddr) {
+  DCHECK(frameAddr != nullptr) << "frameAddr is nullptr in MRT_SaveLastUnwindContext" << maple::endl;
+  InitialUnwindContext &initialUnwindContext = maplert::TLMutator().GetInitialUnwindContext();
+  UnwindContext &initialContext = initialUnwindContext.GetContext();
+
+  initialUnwindContext.SetEffective(false);
+  UnwindData *unwindData = R2CFrame::GetUnwindData(frameAddr);
+  unwindData->pc = initialContext.frame.ip;
+  unwindData->fa = initialContext.frame.fa;
+  unwindData->lr = initialContext.frame.lr;
+  unwindData->ucstatus = static_cast<uintptr_t>(initialContext.status);
+  unwindData->interpFrame = reinterpret_cast<uintptr_t>(initialContext.GetInterpFrame());
+  unwindData->directCallJava = static_cast<uintptr_t>(initialContext.HasDirectJavaCallee());
+  initialUnwindContext.SetEffective(true);
+}
+
+extern "C" void MRT_RestoreLastUnwindContext(CallChain *frameAddr) {
+  InitialUnwindContext &initialUnwindContext = maplert::TLMutator().GetInitialUnwindContext();
+  UnwindContext &initialContext = initialUnwindContext.GetContext();
+  initialUnwindContext.SetEffective(false);
+  initialContext.RestoreUnwindContextFromR2CStub(frameAddr);
+  initialUnwindContext.SetEffective(true);
+}
+
+extern "C" void MRT_SetCurrentCompiledMethod(void *func) {
+  maplert::TLMutator().SetCurrentCompiledMethod(func);
+}
+extern "C" void *MRT_GetCurrentCompiledMethod() {
+  return maplert::TLMutator().GetCurrentCompiledMethod();
+}
+
+ATTR_NO_SANITIZE_ADDRESS
+UnwindState BasicFrame::UnwindToMachineCaller(BasicFrame &caller) const {
+  if (VLOG_IS_ON(eh)) {
+    Check(this->HasFrameStructure(), ">> try to unwind an abnormal frame");
+  }
+
+  CallChain *curFp = this->fa; // backup current frame address
+  CallChain *callerFp = curFp->callerFrameAddress;
+  caller.fa = callerFp;
+  caller.ip = this->ra;
+  Check(caller.ip == curFp->returnAddress, "fatal: error callee frame for stack unwinding");
+
+  if (caller.IsAnchorFrame()) {
+    caller.ra = nullptr;
+    return kUnwindFinish;
+  } else {
+    caller.ra = callerFp->returnAddress;
+    return kUnwindSucc;
+  }
+}
+
+void BasicFrame::Check(bool val, const char *msg) const {
+  if (!val) {
+    Dump(msg);
+    MplDumpStack(msg);
+    std::abort();
+  }
+}
+
+// this method is able to obtain the nominal caller for java methods whose prologue and epilogue
+// are eliminated during compilation.
+ATTR_NO_SANITIZE_ADDRESS
+UnwindState JavaFrame::UnwindToNominalCaller(JavaFrame &caller) const {
+  if (VLOG_IS_ON(eh)) {
+    Check(!this->IsAnchorFrame(), ">> try to unwind up from stack bottom frame");
+  }
+
+  if (this->HasFrameStructure()) {
+    // in this case the parent frame is also the nominal caller.
+    UnwindState state = BasicFrame::UnwindToMachineCaller(caller);
+    caller.md = nullptr;
+    caller.lr = nullptr;
+    return state;
+  } else {
+    // in this case we construct a nominal caller.
+    caller.fa = fa;
+    caller.ip = ra;
+    caller.lr = nullptr;
+    caller.md = nullptr;
+
+    if (caller.IsAnchorFrame()) {
+      return kUnwindFinish;
+    }
+
+    CallChain *callerFp = caller.fa;
+    DCHECK(callerFp != nullptr) << "caller frame address is null in JavaFrame::UnwindToNominalCaller" << maple::endl;
+    caller.ra = callerFp->returnAddress;
+    return kUnwindSucc;
+  }
+}
+
+UnwindState JavaFrame::UnwindToJavaCallerFromRuntime(JavaFrame &frame, bool isEH) {
+  size_t n = 0;
+  while (n < MAPLE_STACK_UNWIND_STEP_MAX) {
+    if (frame.IsAnchorFrame() || (isEH && frame.IsR2CFrame())) {
+      return kUnwindFinish;
+    }
+
+    (void)frame.UnwindToNominalCaller(frame);
+
+    if (frame.IsCompiledFrame()) {
+      return kUnwindSucc;
+    }
+    ++n;
+  }
+
+  return kUnwindFail;
+}
+
+bool UnwindContext::IsStackBottomContext() const {
+  if (interpFrame == nullptr) {
+    return frame.IsAnchorFrame();
+  } else {
+    return false;
+  }
+}
+
+ATTR_NO_SANITIZE_ADDRESS
+void UnwindContext::RestoreUnwindContextFromR2CStub(CallChain *fa) {
+  __MRT_ASSERT(fa != nullptr, "fatal error: frame pointer should be null");
+  UnwindData *unwindData = R2CFrame::GetUnwindData(fa);
+  status = static_cast<UnwindContextStatus>(unwindData->ucstatus);
+  frame.ip = unwindData->pc;
+  frame.fa = unwindData->fa;
+  frame.lr = unwindData->lr;
+  frame.ra = nullptr;
+  interpFrame = reinterpret_cast<void*>(unwindData->interpFrame);
+
+  CallChain *fp = frame.fa;
+  if (fp != nullptr) {
+    if (frame.lr != nullptr) {
+      frame.ra = frame.lr;
+    } else {
+      frame.ra = fp->returnAddress;
+    }
+  }
+}
+
+UnwindState UnwindContext::UnwindToCallerContextFromR2CStub(UnwindContext& caller) const {
+  __MRT_ASSERT(frame.IsR2CFrame(), "fatal error: current frame is not R2C stub");
+  __MRT_ASSERT(status == UnwindContextIsReliable || status == UnwindContextIsRisky,
+               "fatal error: R2C stub is not reliable for unwinding stack");
+
+  UnwindData *unwindData = R2CFrame::GetUnwindData(frame.fa);
+  UnwindContextStatus stubStatus = static_cast<UnwindContextStatus>(unwindData->ucstatus);
+
+  switch (stubStatus) {
+    case UnwindContextStatusIsIgnored: {
+      caller.status = UnwindContextStatusIsIgnored;
+      caller.interpFrame = reinterpret_cast<void*>(unwindData->interpFrame);
+      __MRT_ASSERT(caller.interpFrame != nullptr, "fatal error: interp frame is null");
+      caller.frame.Reset();
+      break;
+    }
+    case UnwindContextIsReliable: {
+      (void)frame.UnwindToNominalCaller(caller.frame);
+      caller.status = UnwindContextIsReliable;
+      caller.interpFrame = nullptr;
+      break;
+    }
+    case UnwindContextIsRisky: {
+      caller.RestoreUnwindContextFromR2CStub(frame.fa);
+      caller.status = UnwindContextIsReliable;
+      if (VLOG_IS_ON(eh)) {
+        __MRT_ASSERT(caller.interpFrame == nullptr, "fatal error: interp frame is null");
+      }
+      break;
+    }
+    // Normally, there is only one case can go into here. A thread is executing MRT_SaveLastUnwindContext,
+    // Suddenly receive a signal sent by another thread to unwind stack. This case is not guaranteed the status slot
+    // of stub has been updated. So it may be an invalid status.
+    default: {
+      EHLOG(ERROR) << "Top function must be MRT_SaveLastUnwindContext, \
+          Otherwise it is memory overwrite" << maple::endl;
+      return kUnwindFinish;
+    }
+  }
+
+  if (caller.IsStackBottomContext()) {
+    return kUnwindFinish;
+  }
+  return kUnwindSucc;
+}
+
+UnwindState UnwindContext::UnwindToCallerContext(UnwindContext& caller, bool) const {
+  // R2C stub is treated specially for unwinding stack because it saves unwind context transition.
+  if (frame.IsR2CFrame()) {
+    return UnwindToCallerContextFromR2CStub(caller);
+  }
+
+  switch (status) {
+    case UnwindContextStatusIsIgnored: {
+      // caller frame is obtained from *interpFrame* and must be an interpreted frame
+      frame.Check(interpFrame != nullptr, "caller frame is expected to be an interpreted frame");
+      return UnwindContextInterpEx::UnwindToCaller(interpFrame, caller);
+    }
+    case UnwindContextIsReliable: {
+      caller.interpFrame = nullptr;
+      caller.status = UnwindContextIsReliable;
+      // caller frame is obtained by checking the structure of current context frame
+      return frame.UnwindToNominalCaller(caller.frame);
+    }
+    case UnwindContextIsRisky: {
+      if (VLOG_IS_ON(eh)) {
+        // caller frame is obtained the value saved in UnwindContext.frame, and it is must be a compiled java frame
+        frame.Check(frame.IsCompiledFrame(), "a compiled java frame is expected");
+      }
+
+      caller.frame = frame;
+      caller.status = UnwindContextIsReliable;
+      caller.interpFrame = nullptr;
+      return kUnwindSucc;
+    }
+
+    default: {
+      LOG(FATAL) << "UnwindToCallerContext status invalid" << maple::endl;
+    }
+  }
+}
+
+// obtain an unwind context as the start point of current thread.
+UnwindState UnwindContext::GetStackTopUnwindContext(UnwindContext &context) {
+  UnwindContext &lastContext = maplert::TLMutator().GetLastJavaContext();
+  switch (lastContext.status) {
+    case UnwindContextIsReliable: {
+      lastContext.frame.Check(lastContext.interpFrame == nullptr, "");
+      MRT_UNW_GETCALLERFRAME(context.frame);
+      context.status = UnwindContextIsReliable;
+      context.interpFrame = nullptr;
+      break;
+    }
+    case UnwindContextIsRisky: {
+      lastContext.frame.Check(lastContext.interpFrame == nullptr, "");
+      context.status = UnwindContextIsReliable;
+      context.frame = lastContext.frame;
+
+      if (context.IsStackBottomContext()) {
+        return kUnwindFinish;
+      }
+      // restore return address by frame structure since it is not maintained in this case
+      if (context.frame.lr != nullptr) {
+        context.frame.ra = context.frame.lr;
+      } else {
+        CallChain *curFp = lastContext.frame.fa;
+        context.frame.ra = curFp->returnAddress;
+      }
+      break;
+    }
+    case UnwindContextStatusIsIgnored: {
+      lastContext.frame.Check(lastContext.interpFrame != nullptr, "");
+      context.status = UnwindContextStatusIsIgnored;
+      context.interpFrame = lastContext.interpFrame;
+      break;
+    }
+
+    default: std::abort();
+  }
+  return kUnwindFinish;
+}
+
+void JavaFrameInfo::ResolveFrameInfo() {
+  if (resolved) {
+    return;
+  }
+
+  const uint32_t *ip = javaFrame.GetFramePC();
+  if (ip == nullptr) {
+    return;
+  }
+  LinkerLocInfo info;
+  if (LinkerAPI::Instance().LocateAddress(const_cast<uint32_t*>(ip), info, false)) {
+    startIp = static_cast<uint32_t*>(info.addr);
+    endIp = reinterpret_cast<uint32_t*>(reinterpret_cast<uintptr_t>(info.addr) + info.size);
+    resolved = true;
+  } else {
+    EHLOG(INFO) << "Frame is java method written with assembly. pc : " << ip << maple::endl;
+    startIp = nullptr;
+    endIp = nullptr;
+    return;
+  }
+  ResolveMethodMetadata();
+}
+
+void MapleStack::FastRecordCurrentJavaStack(std::vector<UnwindContext>& uwContextStack, size_t steps, bool resolveMD) {
+  if (VLOG_IS_ON(eh)) {
+    MplDumpStack("------------------ Fast Record Current Java Stack ------------------");
+  }
+  UnwindContext uwContext;
+  (void) UnwindContext::GetStackTopUnwindContext(uwContext);
+
+  size_t n = 0;
+  while (n < steps && !uwContext.IsStackBottomContext()) {
+    // Here you need to exclude the stack of the native implementation of the java method,
+    // Otherwise the LocalAddress used in the later GetCallClass will trigger abort
+    if (uwContext.IsCompiledContext()) {
+      if (resolveMD) {
+        uwContext.frame.ResolveMethodMetadata();
+      }
+      uwContextStack.push_back(uwContext);
+      ++n;
+    } else if (uwContext.IsInterpretedContext()) {
+      uwContextStack.push_back(uwContext);
+      ++n;
+    }
+
+    UnwindContext caller;
+    if (UNLIKELY(uwContext.UnwindToCallerContext(caller) == kUnwindFinish)) {
+      break;
+    }
+    uwContext = caller;
+  }
+}
+
+void *MapleStack::VisitCurrentJavaStack(UnwindContext& uwContext,
+                                        std::function<void *(UnwindContext&)> const filter) {
+  if (VLOG_IS_ON(eh)) {
+    MplDumpStack("------------------ Visit Current Java Stack ------------------");
+  }
+
+  (void) UnwindContext::GetStackTopUnwindContext(uwContext);
+
+  size_t n = 0;
+  void *retval = nullptr;
+  while (n < MAPLE_STACK_UNWIND_STEP_MAX && !uwContext.IsStackBottomContext()) {
+    if (uwContext.IsCompiledContext() ||
+        uwContext.IsInterpretedContext()) {
+      retval = filter(uwContext);
+      if (retval != nullptr) {
+        return retval;
+      }
+      ++n;
+    }
+
+    UnwindContext caller;
+    if (UNLIKELY(uwContext.UnwindToCallerContext(caller) == kUnwindFinish)) {
+      break;
+    }
+    uwContext = caller;
+  }
+  return retval;
+}
+
+void MapleStack::VisitJavaStackRoots(const UnwindContext &initialContext, const AddressVisitor &func, uint32_t tid) {
+  UnwindContext context;
+  UnwindState state = MapleStack::GetLastJavaContext(context, initialContext, tid);
+  if (state != kUnwindSucc) {
+    return;
+  }
+
+  while (!context.IsStackBottomContext()) {
+    if (context.IsCompiledContext()) {
+      // precise stack scan stack local var
+      JavaFrameInfo frameInfo(context.frame);
+      if (!frameInfo.IsAsmFrame()) {
+        frameInfo.VisitGCRoots(func);
+      }
+    } else if (context.IsInterpretedContext()) {
+      // visit gc roots in interp frame
+      UnwindContextInterpEx::VisitGCRoot(context, func);
+    }
+
+    UnwindContext caller;
+    if (UNLIKELY(context.UnwindToCallerContext(caller) == kUnwindFinish)) {
+      break;
+    }
+    context = caller;
+  }
+  return;
+}
+
+static UnwindReasonCode UnwindBacktraceCallback(const _Unwind_Context *context, void *arg) {
+  uintptr_t pc;
+#if defined(__arm__)
+  _Unwind_VRS_Get(const_cast<_Unwind_Context*>(context), _UVRSC_CORE, kPC, _UVRSD_UINT32, &pc);
+#else
+  pc = _Unwind_GetIP(const_cast<_Unwind_Context*>(context));
+#endif
+  std::vector<uint64_t> *stack = reinterpret_cast<std::vector<uint64_t>*>(arg);
+  if (pc) {
+    (*stack).push_back(pc);
+  } else {
+    LOG(INFO) << "UnwindBacktrace is failed to get pc" << maple::endl;
+  }
+  return _URC_NO_REASON;
+}
+
+void MapleStack::FastRecordCurrentStackPCsByUnwind(std::vector<uint64_t> &callStack, size_t step) {
+  (void)_Unwind_Backtrace(UnwindBacktraceCallback, &callStack);
+  if (callStack.size() > step) {
+    callStack.erase(callStack.begin() + step, callStack.end());
+  }
+}
+
+struct sigaction act;
+struct sigaction oldact;
+
+// The LOG interface cannot be used in this function to prevent deadlocks.
+static void RemoteUnwindHandler(int, siginfo_t*, void *ucontext) {
+  sigaction(SIGRTMIN, &oldact, nullptr);
+  Mutator *mutator = CurrentMutatorPtr();
+  if (mutator == nullptr) {
+    LOG(FATAL) << "current mutator should not be nullptr " << ucontext << maple::endl;
+  }
+
+#if defined(__aarch64__)
+  mcontext_t *mcontext = &(reinterpret_cast<ucontext_t*>(ucontext)->uc_mcontext);
+  if (!mutator->InSaferegion()) {
+    if (LinkerAPI::Instance().IsJavaText(reinterpret_cast<void*>(mcontext->pc))) {
+      InitialUnwindContext &initialUnwindContext = mutator->GetInitialUnwindContext();
+      UnwindContext &initialContext = initialUnwindContext.GetContext();
+      initialContext.frame.fa = reinterpret_cast<CallChain*>(mcontext->regs[Register::kFP]);
+      initialContext.frame.ip = reinterpret_cast<uint32_t*>(mcontext->pc + kAarch64InsnSize);
+    } else {
+      while (!remoteUnwinder.IsUnwinderIdle()) {}
+      remoteUnwinder.SetRemoteIdle(true);
+      return;
+    }
+  }
+#elif defined(__arm__)
+  if (!mutator->InSaferegion()) {
+    while (!remoteUnwinder.IsUnwinderIdle()) {}
+    remoteUnwinder.SetRemoteIdle(true);
+    return;
+  }
+#endif
+
+  // Last java frame update is finished,wake up the request thread to unwind.
+  remoteUnwinder.SetRemoteUnwindStatus(kRemoteLastJavaFrameUpdataFinish);
+
+  // Waiting for request thread to finish unwind
+  if (!remoteUnwinder.WaitRemoteUnwindStatus(kRemoteUnwindFinish)) {
+    while (!remoteUnwinder.IsUnwinderIdle()) {}
+    remoteUnwinder.SetRemoteIdle(true);
+    return;
+  }
+
+  remoteUnwinder.SetRemoteUnwindStatus(kRemoteTargetThreadSignalHandlingExited);
+  while (!remoteUnwinder.IsUnwinderIdle()) {}
+  remoteUnwinder.SetRemoteIdle(true);
+}
+
+void CheckMutatorListLock(uint32_t tid) {
+  uint64_t times = 0;
+  constexpr uint64_t sleepTime = 5000;   // 5us
+  constexpr uint64_t maxTimes = 1000000; // 1sec
+  while (!MutatorList::Instance().TryLock()) {
+    ++times;
+    if (times > maxTimes) {
+      LOG(FATAL) << "Get Mutator Timeout : tid = " << tid << maple::endl;
+    }
+    timeutils::SleepForNano(sleepTime);
+  }
+}
+
+void RecordStackFromUnwindContext(std::vector<uint64_t> &callStack, size_t steps, UnwindContext &context) {
+  size_t n = 0;
+  while (n < steps && !context.IsStackBottomContext()) {
+    // A program counter (PC) is a CPU register in the computer processor which has the address of the next
+    // instruction to be executed from memory. so the address of current instruction should minus 4.
+    // Here you need to exclude the stack of the native implementation of the java method,
+    // Otherwise the LocalAddress used in the later GetCallClass will trigger abort
+    if (!UnwindContextInterpEx::TryRecordStackFromUnwindContext(callStack, context)) {
+      // The lowest ip bit in r2c frame is marked with 1 and needs to be filtered out and dec 1.
+      if (reinterpret_cast<uint64_t>(context.frame.ip) & kDexMethodTag) {
+        callStack.push_back(reinterpret_cast<uint64_t>(context.frame.ip) - kDexMethodTag - kAarch64InsnSize);
+      } else {
+        callStack.push_back(reinterpret_cast<uint64_t>(context.frame.ip) - kAarch64InsnSize);
+      }
+    }
+
+    ++n;
+    UnwindContext caller;
+    if (UNLIKELY(context.UnwindToCallerContext(caller) == kUnwindFinish)) {
+      break;
+    }
+    context = caller;
+  }
+}
+
+// At present, when printing call stack in maple, Java method implemented by native is not
+// included, because this kind of method is compiled by g++ compiler without metedata,
+// so it can not be printed when printing call stack.
+void MapleStack::FastRecordCurrentStackPCs(std::vector<uint64_t> &callStack, size_t steps) {
+  if (VLOG_IS_ON(eh)) {
+    MplDumpStack("------------------ Fast Record Current Java Stack PCs ------------------");
+  }
+
+  UnwindContext context;
+  (void)UnwindContext::GetStackTopUnwindContext(context);
+
+  RecordStackFromUnwindContext(callStack, steps, context);
+}
+
+void MapleStack::RecordStackPCs(std::vector<uint64_t> &callStack, uint32_t tid, size_t steps) {
+  std::lock_guard<std::mutex> lock(remoteUnwinder.GetRemoteUnwindLock());
+  // Reserve memory space for the vector. When you push back, the memory will not be
+  // applied. Avoid deadlock with target thread
+  callStack.reserve(steps);
+
+  if (tid == static_cast<uint32_t>(maple::GetTid())) {
+    LOG(ERROR) << "The target thread is the same as the current thread" << maple::endl;
+    remoteUnwinder.SetUnwinderIdle(true);
+    return;
+  }
+
+  CheckMutatorListLock(tid);
+
+  Mutator *mutator = MutatorList::Instance().GetMutator(tid);
+  if (mutator == nullptr) {
+    MutatorList::Instance().Unlock();
+    return;
+  }
+
+  if (!remoteUnwinder.WaitForRemoteIdle()) {
+    MutatorList::Instance().Unlock();
+    return;
+  }
+
+  remoteUnwinder.SetUnwinderIdle(false);
+  remoteUnwinder.SetRemoteIdle(false);
+  remoteUnwinder.SetRemoteUnwindStatus(kRemoteUnwindIdle);
+
+  // register signal hander function
+  (void)memset_s(&act, sizeof(act), 0, sizeof(act));
+  (void)memset_s(&oldact, sizeof(oldact), 0, sizeof(oldact));
+  act.sa_sigaction = RemoteUnwindHandler;
+  act.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
+  sigemptyset(&act.sa_mask);
+  if (sigaction(SIGRTMIN, &act, &oldact) != 0) {
+    LOG(ERROR) << "sigaction failed" << maple::endl;
+    return;
+  }
+
+  LOG(INFO) << "send signal to tid " << tid << maple::endl;
+
+  // ***************************************************************************
+  // From now on until the SignalHandler exits, you can't use the LOG interface,
+  // because if the target thread is in the LOG state, a deadlock will occur.
+  // ***************************************************************************
+  if (maple::TgKill(static_cast<uint32_t>(maple::GetPid()), tid, SIGRTMIN) != 0) {
+    MutatorList::Instance().Unlock();
+    remoteUnwinder.SetRemoteIdle(true);
+    remoteUnwinder.SetUnwinderIdle(true);
+    sigaction(SIGRTMIN, &oldact, nullptr);
+    return;
+  }
+
+  // waiting for the target thread to complete the last java frame update
+  if (!remoteUnwinder.WaitRemoteUnwindStatus(kRemoteLastJavaFrameUpdataFinish)) {
+    MutatorList::Instance().Unlock();
+    remoteUnwinder.SetUnwinderIdle(true);
+    return;
+  }
+
+  UnwindContext uwContext;
+  InitialUnwindContext &initialUnwindContext = mutator->GetInitialUnwindContext();
+
+  // At this time, the target thread has entered the signal handling. The validity of the
+  // corresponding mutator can be guaranteed and so the lock can be released.
+  MutatorList::Instance().Unlock();
+  UnwindState state = kUnwindFail;
+  if (initialUnwindContext.IsEffective()) {
+    const UnwindContext &initialContext = initialUnwindContext.GetContext();
+    state = GetLastJavaContext(uwContext, initialContext, tid);
+  }
+
+  if (state == kUnwindFail) {
+    // After the kill signal is sent, it must be exited by the handshake
+    // mechanism, otherwise the corresponding thread will always wait.
+    remoteUnwinder.SetRemoteUnwindStatus(kRemoteUnwindFinish);
+    if (!remoteUnwinder.WaitRemoteUnwindStatus(kRemoteTargetThreadSignalHandlingExited)) {
+      remoteUnwinder.SetUnwinderIdle(true);
+      return;
+    }
+    remoteUnwinder.SetUnwinderIdle(true);
+    return;
+  }
+
+  RecordStackFromUnwindContext(callStack, steps, uwContext);
+
+  // After the kill signal is sent, it must be exited by the handshake
+  // mechanism, otherwise the corresponding thread will always wait.
+  remoteUnwinder.SetRemoteUnwindStatus(kRemoteUnwindFinish);
+
+  if (!remoteUnwinder.WaitRemoteUnwindStatus(kRemoteTargetThreadSignalHandlingExited)) {
+    remoteUnwinder.SetUnwinderIdle(true);
+    return;
+  }
+  remoteUnwinder.SetUnwinderIdle(true);
+}
+
+UnwindState GetNextJavaFrame(UnwindContext &context) {
+  UnwindState state = kUnwindFail;
+  while (!context.IsStackBottomContext()) {
+    if (context.IsCompiledContext()) {
+      context.interpFrame = nullptr;
+      context.status = UnwindContextIsReliable;
+      state = kUnwindSucc;
+      break;
+    }
+
+    if (context.IsInterpretedContext()) {
+      context.status = UnwindContextStatusIsIgnored;
+      state = kUnwindSucc;
+      break;
+    }
+
+    UnwindContext caller;
+    if (UNLIKELY(context.UnwindToCallerContext(caller) == kUnwindFinish)) {
+      state = kUnwindFinish;
+      break;
+    }
+    context = caller;
+  }
+  return state;
+}
+
+// NEED: support enable USE_ZTERP in phone. Similar with other functions, need refactor.
+UnwindState MapleStack::GetLastJavaContext(UnwindContext &context, const UnwindContext &initialContext, uint32_t tid) {
+  if (VLOG_IS_ON(eh)) {
+    EHLOG(INFO) << "GetLastJavaContext tid : " << tid << maple::endl;
+  }
+  if (initialContext.IsStackBottomContext()) {
+    return kUnwindFinish;
+  }
+
+  UnwindState state = kUnwindFail;
+
+  switch (initialContext.status) {
+    case UnwindContextStatusIsIgnored: {
+      initialContext.frame.Check(initialContext.interpFrame != nullptr, "");
+      context.status = UnwindContextStatusIsIgnored;
+      context.interpFrame = initialContext.interpFrame;
+      context.frame.Reset();
+      state = kUnwindSucc;
+      break;
+    }
+    case UnwindContextIsReliable:
+    case UnwindContextIsRisky: {
+      JavaFrame frame = initialContext.frame;
+      CallChain *curFp = frame.fa;
+      if (VLOG_IS_ON(eh)) {
+        MplCheck(curFp != 0, "latest java frame address should not be null");
+      }
+      if (frame.lr) {
+        // this frame does not have frame structure.
+        frame.ra = frame.lr;
+      } else {
+        // this frame does have frame structure so we obtain return address as ABI described.
+        frame.ra = curFp->returnAddress;
+      }
+
+      frame.SetMetadata(nullptr);
+      context.frame = frame;
+      context.status = initialContext.status;
+      state = GetNextJavaFrame(context);
+      break;
+    }
+    default: std::abort();
+  }
+  return state;
+}
+
+
+// If the parameter isEH is true, it means that the function may recognize n2j frame,
+// which needs to be set to true when calling the function in exception handling, and
+// false when stacking.
+UnwindState MapleStack::GetLastJavaFrame(JavaFrame &frame, const UnwindContext *initialContext, bool isEH) {
+  bool unwindAnotherThread = true;
+  if (initialContext == nullptr) {
+    initialContext = &(TLMutator().GetLastJavaContext());
+    unwindAnotherThread = false;
+  }
+
+  UnwindContextStatus status = initialContext->status;
+
+  UnwindState state = kUnwindFail;
+  if (status == UnwindContextIsReliable && !unwindAnotherThread) {
+    MRT_UNW_GETCALLERFRAME(frame);
+    state = frame.UnwindToJavaCallerFromRuntime(frame, isEH);
+  } else {
+    frame = initialContext->frame;
+
+    // For rare cases (like in reference collector thread), *initialContext* may holds an anchor frame.
+    if (frame.IsAnchorFrame()) {
+      state = kUnwindFinish;
+      return state;
+    } else {
+      CallChain *curFp = frame.fa;
+      MplCheck(curFp != 0, "latest java frame address should not be null");
+
+      if (frame.lr) {
+        // this frame does not have frame structure.
+        frame.ra = frame.lr;
+      } else {
+        // this frame does have frame structure so we obtain return address as ABI described.
+        frame.ra = curFp->returnAddress;
+      }
+
+      frame.SetMetadata(nullptr);
+    }
+
+    if (frame.IsCompiledFrame()) {
+      state = kUnwindSucc;
+    } else {
+      state = frame.UnwindToJavaCallerFromRuntime(frame);
+    }
+  }
+
+  if (VLOG_IS_ON(eh)) {
+    std::stringstream ss;
+    frame.Dump(">>>> Get stack-top java frame ", ss);
+    EHLOG(INFO) << ss.str() << maple::endl <<
+        "\t" << "frame context is " <<
+        (status == UnwindContextIsReliable ? "Reliable" : "Risky") <<
+        " -- Unwind " << (state == kUnwindSucc ? "Succeeded" : "Finished") << maple::endl;
+  }
+
+  return state;
+}
+
+#ifdef MAPLE_RECORD_METHOD_INFO_AT_START_PROC
+extern "C" MRT_EXPORT bool MapleGetJavaMethodNameByIP(const uint32_t *ip, std::string &funcName, uint64_t *funcOffset) {
+  LinkerLocInfo info;
+  bool isJava = LinkerAPI::Instance().LocateAddress(ip, info, false);
+  if (isJava) {
+    if (VLOG_IS_ON(eh)) {
+      EHLOG(INFO) << std::hex << "obtain java method name for pc " << reinterpret_cast<uintptr_t>(ip) << " (" <<
+          info.addr << " ~ " << reinterpret_cast<uintptr_t>(info.addr) + info.size << ")" <<
+          std::dec << maple::endl;
+    }
+
+    uint64_t *md = static_cast<uint64_t*>(
+        JavaFrame::GetMethodMetadata(reinterpret_cast<uint32_t*>(info.addr)));
+    if (UNLIKELY(!JavaFrame::GetMapleMethodFullName(funcName, md, ip))) {
+      EHLOG(ERROR) << "JavaFrame::GetMapleMethodFullName() in MapleGetJavaMethodNameByIP() return false." <<
+          maple::endl;
+    }
+    if (funcOffset == nullptr) {
+      EHLOG(FATAL) << "funcOffset is nullptr" << maple::endl;
+    }
+    *funcOffset = reinterpret_cast<uint64_t>(ip) - reinterpret_cast<uint64_t>(info.addr);
+    return funcName.size() > 0;
+  }
+  return false;
+}
+#endif // MAPLE_RECORD_METHOD_INFO_AT_START_PROC
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/file_layout.cpp b/src/mrt/compiler-rt/src/file_layout.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..584dc595ff0101371072b13ca16f7f148b4540da
--- /dev/null
+++ b/src/mrt/compiler-rt/src/file_layout.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "file_layout.h"
+
+namespace maple {
+std::string GetLayoutTypeString(uint32_t type) {
+  switch (type) {
+    case kLayoutBootHot:
+      return "BootHot";
+    case kLayoutBothHot:
+      return "BothHot";
+    case kLayoutRunHot:
+      return "RunHot";
+    case kLayoutStartupOnly:
+      return "StartupOnly";
+    case kLayoutUsedOnce:
+      return "UsedOnce";
+    case kLayoutExecuted:
+      return "UsedMaybe";
+    case kLayoutUnused:
+      return "Unused";
+    default:
+      std::cerr << "no such type" << std::endl;
+      return "";
+  }
+}
+} // namespace maple
diff --git a/src/mrt/compiler-rt/src/gc_log.cpp b/src/mrt/compiler-rt/src/gc_log.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1b656d3207420d75cf79a84f35298173c15ded79
--- /dev/null
+++ b/src/mrt/compiler-rt/src/gc_log.cpp
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "gc_log.h"
+
+#include <sys/stat.h>
+#include "panic.h"
+#include "collector/stats.h"
+#include "cinterface.h"
+#include "linker_api.h"
+
+#define SET_LOG_FLAGS(type, usefile, verbose, open) do { \
+  writeToFile[type] = MRT_ENVCONF(usefile, usefile##_DEFAULT) || VLOG_IS_ON(verbose); \
+  openFileOnStartup[type] = MRT_ENVCONF(open, open##_DEFAULT) || VLOG_IS_ON(verbose); \
+} while (0)
+
+namespace maplert {
+class NullBuffer : public std::streambuf {
+ public:
+  int overflow(int c) override {
+    return c;
+  }
+};
+
+class NullStream : public std::ostream {
+ public:
+  NullStream() : std::ostream(&sb) {}
+  ~NullStream() = default;
+ private:
+  NullBuffer sb;
+};
+
+static NullStream nullStream;
+
+namespace {
+const char *kPrefixName[kLogtypeNum] = {
+    "gclog_", "rctracelog_", "rplog_", "cyclelog_", "allocatorfragmentlog_", "allocatorlog_", "mixlog_", "stderr_"
+};
+
+// Orders of magnitudes.  Note: The upperbound of uint64_t is 16E (16 * (1024 ^ 6))
+const char *kOrdersOfManitude[] = { "", "K", "M", "G", "T", "P", "E" };
+
+// Orders of magnitudes.  Note: The upperbound of uint64_t is 16E (16 * (1024 ^ 6))
+const char *kOrdersOfMagnitudeFromNano[] = { "n", "u", "m", nullptr };
+
+// number of digits in a pretty format segment (100,000,000 each has three digits)
+constexpr int kNumDigitsPerSegment = 3;
+}
+
+void GCLogImpl::Init(bool gcLog) {
+  openGCLog = gcLog;
+  SetFlags();
+  if (doWriteToFile && doOpenFileOnStartup) {
+    OpenFile();
+  }
+}
+
+void GCLogImpl::SetFlags() {
+  SET_LOG_FLAGS(kLogtypeGc, MRT_GCLOG_USE_FILE, opengclog, MRT_GCLOG_OPEN_ON_STARTUP);
+  SET_LOG_FLAGS(kLogtypeRcTrace, MRT_RCTRACELOG_USE_FILE, openrctracelog, MRT_RCTRACELOG_OPEN_ON_STARTUP);
+  SET_LOG_FLAGS(kLogtypeRp, MRT_RPLOG_USE_FILE, openrplog, MRT_RPLOG_OPEN_ON_STARTUP);
+  SET_LOG_FLAGS(kLogtypeCycle, MRT_CYCLELOG_USE_FILE, opencyclelog, MRT_CYCLELOG_OPEN_ON_STARTUP);
+  SET_LOG_FLAGS(kLogTypeAllocFrag, MRT_ALLOCFRAGLOG_USE_FILE, allocatorfragmentlog, MRT_ALLOCFRAGLOG_OPEN_ON_STARTUP);
+  SET_LOG_FLAGS(kLogTypeAllocator, MRT_ALLOCATORLOG_USE_FILE, allocatorlog, MRT_ALLOCATOR_OPEN_ON_STARTUP);
+  SET_LOG_FLAGS(kLogTypeMix, MRT_MIXLOG_USE_FILE, openmixlog, MRT_MIXLOG_OPEN_ON_STARTUP);
+
+  if (openGCLog) {
+    writeToFile[kLogtypeGc] = true;
+    openFileOnStartup[kLogtypeGc] = true;
+  }
+  doWriteToFile = false;
+  doOpenFileOnStartup = false;
+  for (int i = 0; i < kLogtypeNum; ++i) {
+    if (i == kLogtypeGcOrStderr) {
+#ifdef __ANDROID__
+      writeToFile[i] = false;
+      (void)file[i].rdbuf()->pubsetbuf(nullptr, 0); // set 0 as unbuffered stream to save memory when gclog disabled
+      os[i] = &nullStream;
+      doWriteToFile = doWriteToFile || writeToFile[i];
+      doOpenFileOnStartup = doOpenFileOnStartup || openFileOnStartup[i];
+#else
+      writeToFile[i] = true;
+      os[i] = &std::cerr;
+#endif
+    } else {
+      (void)file[i].rdbuf()->pubsetbuf(nullptr, 0); // set 0 as unbuffered stream to save memory when gclog disabled
+      os[i] = &nullStream;
+      doWriteToFile = doWriteToFile || writeToFile[i];
+      doOpenFileOnStartup = doOpenFileOnStartup || openFileOnStartup[i];
+    }
+  }
+}
+
+void GCLogImpl::OpenFile() {
+  if (!doWriteToFile) {
+    return;
+  }
+
+  pid_t pid = getpid();
+  std::string dateDigit = timeutils::GetDigitDate();
+#ifdef __ANDROID__
+  std::string dirName = util::GetLogDir();
+#else
+  std::string dirName = ".";
+#endif
+
+  for (int i = 0; i < kLogtypeNum; ++i) {
+    if (!writeToFile[i] || (i == kLogtypeGcOrStderr)) {
+      continue;
+    }
+
+    std::string baseName = kPrefixName[i] + std::to_string(pid) + "_" + dateDigit + ".txt";
+    std::string fileName = dirName + "/" + baseName;
+    file[i] = std::ofstream(fileName, std::ofstream::app); // Assignment closes the old file.
+    if (!file[i]) {
+      LOG(ERROR) << "GCLogImpl::OpenFile(): fail to open the file" << maple::endl;
+      continue;
+    }
+    buffer[i] = new (std::nothrow) char[kGcLogBufSize];
+    if (buffer[i] == nullptr) {
+      LOG(ERROR) << "GCLogImpl::OpenFile(): new char[kGcLogBufSize] failed" << maple::endl;
+      continue;
+    }
+    (void)file[i].rdbuf()->pubsetbuf(buffer[i], kGcLogBufSize);
+    os[i] = &file[i];
+  }
+#ifdef __ANDROID__
+    writeToFile[kLogtypeGcOrStderr] = writeToFile[kLogtypeGc];
+    os[kLogtypeGcOrStderr] = &file[kLogtypeGc];
+#endif
+}
+
+void GCLogImpl::CloseFile() {
+  if (!doWriteToFile) {
+    return;
+  }
+
+  for (int i = 0; i < kLogtypeNum; ++i) {
+    if (writeToFile[i] && (i != kLogtypeGcOrStderr)) {
+      if (os[i] == &file[i]) {
+        os[i] = &nullStream;
+        file[i].close();
+        delete[] buffer[i];
+        buffer[i] = nullptr;
+      }
+    }
+  }
+}
+
+void GCLogImpl::OnPreFork() {
+  CloseFile();
+}
+
+void GCLogImpl::OnPostFork() {
+  SetFlags();
+  OpenFile();
+}
+
+void GCLogImpl::OnGCStart() {
+  std::string dateDigit = timeutils::GetDigitDate();
+  Stream(kLogtypeGc) << "Begin GC log. Time: " << dateDigit << '\n';
+  Stream(kLogtypeGc) << "Current allocated: " << Pretty(stats::gcStats->CurAllocBytes()) <<
+      " Current threshold: " << Pretty(stats::gcStats->CurGCThreshold()) << '\n';
+  Stream(kLogtypeGc) << "Current allocated native bytes (before GC): " << Pretty(MRT_GetNativeAllocBytes()) << '\n';
+}
+
+void GCLogImpl::OnGCEnd() {
+  Stream(kLogtypeGc) << "Current allocated native bytes (after  GC): " << Pretty(MRT_GetNativeAllocBytes()) << '\n';
+  Stream(kLogtypeGc) << "End of GC log.\n\n";
+  Stream(kLogtypeGc).flush();
+}
+
+GCLogImpl gcLogInstance;
+
+GCLogImpl &GCLog() {
+  return gcLogInstance;
+}
+
+std::string Pretty(uint64_t number) {
+  std::string orig = std::to_string(number);
+  int pos = static_cast<int>(orig.length()) - kNumDigitsPerSegment;
+  while (pos > 0) {
+    orig.insert(pos, ",");
+    pos -= kNumDigitsPerSegment;
+  }
+  return orig;
+}
+
+std::string Pretty(int64_t number) {
+  std::string orig = std::to_string(number);
+  int pos = static_cast<int>(orig.length()) - kNumDigitsPerSegment;
+  while (pos > 0) {
+    orig.insert(pos, ",");
+    pos -= kNumDigitsPerSegment;
+  }
+  return orig;
+}
+
+std::string Pretty(uint32_t number) {
+  return Pretty(static_cast<uint64_t>(number));
+}
+
+// Useful for informatic units, such as KiB, MiB, GiB, ...
+std::string PrettyOrderInfo(uint64_t number, std::string unit) {
+  size_t order = 0;
+  const uint64_t factor = 1024;
+
+  while (number > factor) {
+    number /= factor;
+    order += 1;
+  }
+
+  const char *prefix = kOrdersOfManitude[order];
+  const char *infix = order > 0 ? "i" : ""; // 1KiB = 1024B, but there is no "1iB"
+
+  return std::to_string(number) + std::string(prefix) + std::string(infix) + unit;
+}
+
+// Useful for scientific units where number is in nanos: ns, us, ms, s
+std::string PrettyOrderMathNano(uint64_t number, std::string unit) {
+  size_t order = 0;
+  const uint64_t factor = 1000; // show in us if under 10ms
+
+  while (number > factor && kOrdersOfMagnitudeFromNano[order] != nullptr) {
+    number /= factor;
+    order += 1;
+  }
+
+  const char *prefix = kOrdersOfMagnitudeFromNano[order];
+  if (prefix == nullptr) {
+    prefix = "";
+  }
+
+  return std::to_string(number) + std::string(prefix) + unit;
+}
+}
\ No newline at end of file
diff --git a/src/mrt/compiler-rt/src/heap_stats.cpp b/src/mrt/compiler-rt/src/heap_stats.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..32706e7ddd325f1c2780ef707089c007af4c4324
--- /dev/null
+++ b/src/mrt/compiler-rt/src/heap_stats.cpp
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "heap_stats.h"
+#include "chosen.h"
+
+namespace maplert {
+HeapStats heapStats;
+address_t HeapStats::heapStartAddr = 0;
+size_t HeapStats::heapCurrentSize = 0;
+atomic<int> heapProfile;
+
+struct HeapProfileInit {
+ public:
+  HeapProfileInit() {
+    heapProfile.store(HEAP_PROFILE, std::memory_order_relaxed);
+  }
+};
+HeapProfileInit heapProfileInit;
+
+// Enable/Disable heapstats collection
+extern "C" void MRT_SetHeapProfile(int hp) {
+  static constexpr int heapProfileDisable = 0;
+  static constexpr int heapProfileEnable = 1;
+  switch (hp) {
+    case heapProfileDisable:
+      // stop heap usage counting (android.os.debug.stopAllocAccounting)
+      heapStats.DisableHeapStats();
+      break;
+    case heapProfileEnable:
+      // start heap usage counting (android.os.debug.startAllocAccounting)
+      heapStats.EnableHeapStats();
+      break;
+    default:
+      break;
+  }
+}
+
+HeapStats::HeapStats()
+    : bytesAlloc(0),
+      bytesFreed(0),
+      numAlloc(0),
+      numFreed(0) {}
+
+// Reset total and per mutator heapstats
+void HeapStats::ResetHeapStats() {
+  bytesAlloc = 0;
+  bytesFreed = 0;
+  numAlloc = 0;
+  numFreed = 0;
+  (*theAllocator).GetAllocAccount().ResetWindowTotal();
+}
+
+// Sum heapstats from all mutators, unused because the per-mutator data is not maintained
+void HeapStats::SumHeapStats() {
+  // this has lock, be careful
+  (*theAllocator).ForEachMutator([this](AllocMutator &mutator) {
+    auto &account = mutator.GetAllocAccount();
+    bytesAlloc += account.TotalAllocdBytes();
+    bytesFreed += account.TotalFreedBytes();
+    numAlloc += account.TotalAllocdObjs();
+    numFreed += account.TotalFreedObjs();
+    account.ResetWindowTotal();
+  });
+}
+
+// Begin heap usage stats collection
+void HeapStats::EnableHeapStats() {
+  heapProfile.store(1, std::memory_order_relaxed);
+}
+
+// End heap usage stats collection
+void HeapStats::DisableHeapStats() {
+  heapProfile.store(0, std::memory_order_relaxed);
+  auto &account = (*theAllocator).GetAllocAccount();
+  bytesAlloc = account.TotalAllocdBytes();
+  bytesFreed = account.TotalFreedBytes();
+  numAlloc = account.TotalAllocdObjs();
+  numFreed = account.TotalFreedObjs();
+  account.ResetWindowTotal();
+}
+
+void HeapStats::PrintHeapStats() {
+  LOG2FILE(kLogtypeGc) << "[HEAPSTATS] Heap statistics:" << maple::endl;
+  LOG2FILE(kLogtypeGc) << "[HEAPSTATS]   allocated " << bytesAlloc << maple::endl;
+  LOG2FILE(kLogtypeGc) << "[HEAPSTATS]   freed " << bytesFreed << maple::endl;
+  LOG2FILE(kLogtypeGc) << "[HEAPSTATS]   number of allocation " << numAlloc << maple::endl;
+  LOG2FILE(kLogtypeGc) << "[HEAPSTATS]   number of free " << numFreed << maple::endl;
+}
+}
diff --git a/src/mrt/compiler-rt/src/libs.cpp b/src/mrt/compiler-rt/src/libs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b503ae12cc8a9deeb98614d3f4a7b212290d594d
--- /dev/null
+++ b/src/mrt/compiler-rt/src/libs.cpp
@@ -0,0 +1,537 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "libs.h"
+#include <algorithm>
+#include <dlfcn.h>
+#include "exception/exception_handling.h"
+#include "tracer.h"
+#include "mm_config.h"
+#include "mrt_libs_api.h"
+#include "mrt_monitor_api.h"
+#include "exception/mrt_exception.h"
+#include "mrt_handleutil.h"
+#include "mrt_methodhandle_mpl.h"
+#include "profile.h"
+#include "object_base.h"
+#include "sizes.h"
+
+namespace maplert {
+// we may inline this?
+// array-length: Returns the number of elements of the array
+// referenced by 'p'
+int32_t MCC_DexArrayLength(const void *p) {
+  if (p == nullptr) {
+    MRT_ThrowNullPointerExceptionUnw();
+    return -1;
+  }
+  return *reinterpret_cast<const int32_t*>((reinterpret_cast<const char*>(p) + kJavaArrayLengthOffset));
+}
+
+int32_t MCC_JavaArrayLength(const void *p) __attribute__((alias("MCC_DexArrayLength")));
+
+// we may inline this?
+// fill-array-data: Fills the array referenced by d with the static data 's'.
+void MCC_DexArrayFill(void *d, void *s, int32_t len) {
+  __MRT_ASSERT(d && s, "MCC_DexArrayFill arg nullptr");
+  char *dest = reinterpret_cast<char*>(d) + kJavaArrayContentOffset;
+  size_t lenSizet = len;
+  // We trust the frontend to supply the correct length
+  errno_t rv = memcpy_s(dest, lenSizet, s, lenSizet);
+  if (rv != EOK) {
+    LOG(ERROR) << "memcpy_s failed.  Reason: " << rv << ", dest: " << dest << ", destMax: " <<
+        lenSizet << ", src: " << s << ", count: " << lenSizet << ", SECUREC_MEM_MAX_LEN: " <<
+        SECUREC_MEM_MAX_LEN << maple::endl;
+    LOG(FATAL) << "check logcat and get more info " << maple::endl;
+  }
+}
+
+void MCC_JavaArrayFill(void *d, void *s, int32_t len) __attribute__((alias("MCC_DexArrayFill")));
+
+// we may move this to mpl2mpl where Java EH is lowered.
+void *MCC_DexCheckCast(void *i __attribute__((unused)), void *c __attribute__((unused))) {
+  // eventually, remove this builtin function.
+  // and from the be lowerer
+  __MRT_ASSERT(0, "MCC_DexCheckCast");
+  return nullptr;
+}
+
+void *MCC_JavaCheckCast(void *i __attribute__((unused)), void *c __attribute__((unused)))
+    __attribute__((alias("MCC_DexCheckCast")));
+
+// Moves the class object of a class identified by type_id
+// (e.g. Object.class) into vx.
+void *MCC_GetReferenceToClass(void *p2tyid) {
+  return p2tyid;
+}
+
+bool  MCC_DexInstanceOf(void *obj, void *javaClass) {
+  if (UNLIKELY(obj == nullptr)) {
+    return false;
+  }
+  MObject *o = reinterpret_cast<MObject*>(obj);
+  MClass *c = reinterpret_cast<MClass*>(javaClass);
+  DCHECK(c != nullptr) << "javaClass is nullptr." << maple::endl;
+  return o->IsInstanceOf(*c);
+}
+
+bool MCC_JavaInstanceOf(void *obj, void *javaClass) __attribute__((alias("MCC_DexInstanceOf")));
+
+bool MCC_IsAssignableFrom(jclass subClass, jclass superClass) {
+  MClass *mSub = reinterpret_cast<MClass*>(subClass);
+  MClass *mSuper = reinterpret_cast<MClass*>(superClass);
+  DCHECK(mSub != nullptr) << "mSub is nullptr." << maple::endl;
+  DCHECK(mSuper != nullptr) << "mSuper is nullptr." << maple::endl;
+  return mSuper->IsAssignableFrom(*mSub);
+}
+
+void MCC_DexInterfaceCall(void *dummy __attribute__((unused))) {
+  // placeholder for doing the right interface call at runtime
+  __MRT_ASSERT(0, "MCC_DexInterfaceCall not implemented yet");
+}
+
+void MCC_JavaInterfaceCall(void *dummy __attribute__((unused))) __attribute__((alias("MCC_DexInterfaceCall")));
+
+#if defined(__aarch64__)
+jvalue MCC_DexPolymorphicCall(jstring calleeName, jstring protoString, int paramNum, jobject methodHandle, ...) {
+  va_list args;
+  va_start(args, methodHandle);
+  VArg vargs(args);
+  MClass *callerClass = GetContextCls(vargs, reinterpret_cast<MString*&>(calleeName));
+  POLYRETURNTYPE result = PolymorphicCallEnter(reinterpret_cast<MString*>(calleeName),
+                                               reinterpret_cast<MString*>(protoString), static_cast<uint32_t>(paramNum),
+                                               reinterpret_cast<MObject*>(methodHandle), vargs, callerClass);
+  va_end(args);
+  return result;
+}
+
+jvalue MCC_JavaPolymorphicCall(jstring calleeName, jstring protoString, int paramNum, jobject methodHandle, ...)
+    __attribute__((alias("MCC_DexPolymorphicCall")));
+#endif
+
+void MRT_BuiltinSyncEnter(address_t obj) {
+  VLOG(monitor) << "MRT_BuiltinSyncEnter obj = " << obj << maple::endl;
+  if (UNLIKELY(obj == 0)) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+
+  if (maple::IThread *tSelf = maple::IThread::Current()) {
+    void *ra = __builtin_return_address(0);
+    tSelf->PushLockedMonitor(reinterpret_cast<void*>(obj), ra, (uint32_t)maple::kMplWaitingOn);
+    jint ret = maple::ObjectBase::MonitorEnter(obj);
+    tSelf->UpdateLockMonitorState();
+    if (UNLIKELY(ret == JNI_ERR)) {
+      MRT_CheckThrowPendingExceptionUnw();
+    }
+  }
+}
+
+void MRT_BuiltinSyncExit(address_t obj) {
+  VLOG(monitor) << "MRT_BuiltinSyncExit obj = " << obj << maple::endl;
+  if (UNLIKELY(obj == 0)) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+
+  if (maple::IThread *tSelf = maple::IThread::Current()) {
+    jint ret = maple::ObjectBase::MonitorExit(obj);
+    tSelf->PopLockedMonitor();
+    if (UNLIKELY(ret == JNI_ERR)) {
+      MRT_CheckThrowPendingExceptionUnw();
+    }
+  }
+}
+
+void MRT_DumpMethodUse(std::ostream &os) {
+  DumpMethodUse(os);
+}
+
+// Instrumentation/tracing facilities
+static bool ResolveAddr2Name(std::string &funcname, uint64_t addr) {
+  LinkerLocInfo info;
+#ifdef RECORD_METHOD
+  MRT_DisableMetaProfile();
+#endif
+  bool result = LinkerAPI::Instance().LocateAddress(reinterpret_cast<void*>(addr), info, true);
+#ifdef RECORD_METHOD
+  MRT_EnableMetaProfile();
+#endif
+  if (result) {
+    funcname = info.sym;
+    return true;
+  }
+  Dl_info dlInfo;
+  if (dladdr(reinterpret_cast<void*>(addr), &dlInfo) && dlInfo.dli_sname) {
+    funcname = dlInfo.dli_sname;
+    return dlInfo.dli_sname;
+  }
+  return false;
+}
+
+#if defined(__aarch64__)
+#define ENTRY_POINT_IMPL(name)                         \
+    asm("    .text\n"                                    \
+        "    .align 2\n"                                 \
+        "    .globl __" #name                            \
+        "__\n"                                           \
+        "    .type  __" #name                            \
+        "__, %function\n"                                \
+        "__" #name                                       \
+        "__:\n"                                          \
+        " /* save arguments. must match frame below. */" \
+        "    stp X29, X30, [sp,-16]!\n"                  \
+        "    stp X0,  X1,  [SP,-16]!\n"                  \
+        "    stp X2,  X3,  [SP,-16]!\n"                  \
+        "    stp X4,  X5,  [SP,-16]!\n"                  \
+        "    stp X6,  X7,  [SP,-16]!\n"                  \
+        "    stp D0,  D1,  [SP,-16]!\n"                  \
+        "    stp D2,  D3,  [SP,-16]!\n"                  \
+        "    stp D4,  D5,  [SP,-16]!\n"                  \
+        "    stp D6,  D7,  [SP,-16]!\n"                  \
+        "    mov X0,  SP\n"                              \
+        "    bl  " #name                                 \
+        "Impl\n"                                        \
+        "    ldp D6,  D7,  [SP], 16\n"                   \
+        "    ldp D4,  D5,  [SP], 16\n"                   \
+        "    ldp D2,  D3,  [SP], 16\n"                   \
+        "    ldp D0,  D1,  [SP], 16\n"                   \
+        "    ldp X6,  X7,  [SP], 16\n"                   \
+        "    ldp X4,  X5,  [SP], 16\n"                   \
+        "    ldp X2,  X3,  [SP], 16\n"                   \
+        "    ldp X0,  X1,  [SP], 16\n"                   \
+        "    ldp X29, X30, [SP], 16\n"                   \
+        "    ret\n"); // this return send the control back to the original caller,
+                      // not the next instruction of the jump instruction
+#elif defined(__arm__)
+#define ENTRY_POINT_IMPL(name)                         \
+    asm("    .text\n"                                    \
+        "    .align 2\n"                                 \
+        "    .globl __" #name                            \
+        "__\n"                                           \
+        "    .type  __" #name                            \
+        "__, %function\n"                                \
+        "__" #name                                       \
+        "__:\n"                                          \
+        "\n");
+#endif
+
+#define ENTRY_POINT_BL(name) ENTRY_POINT_IMPL(name)
+#define ENTRY_POINT_JMP(name) ENTRY_POINT_IMPL(name)
+
+#ifdef __ANDROID__
+// for save context and terminate system
+asm("    .text\n"
+    "    .align 2\n"
+    "    .globl MRT_BuiltinAbortSaferegister\n"
+    "    .type  MRT_BuiltinAbortSaferegister, %function\n"
+    "MRT_BuiltinAbortSaferegister:\n"
+#if defined(__aarch64__)
+    "    brk #1\n"
+    "    ret\n"
+#endif
+    "    .size    MRT_BuiltinAbortSaferegister, .-MRT_BuiltinAbortSaferegister");
+
+#else
+extern "C" void MRT_BuiltinAbortSaferegister(maple::address_t addr ATTR_UNUSED, const char *clsName ATTR_UNUSED) {
+  util::PrintBacktrace();
+  abort();
+}
+#endif
+
+struct AArch64RegSet {
+  uint64_t x0;
+  uint64_t x1;
+  uint64_t x2;
+  uint64_t x3;
+  uint64_t x4;
+  uint64_t x5;
+  uint64_t x6;
+  uint64_t x7;
+  uint64_t x8;
+  uint64_t x9;
+  uint64_t x10;
+  uint64_t x11;
+  uint64_t x12;
+  uint64_t x13;
+  uint64_t x14;
+  uint64_t x15;
+  uint64_t x16;
+  uint64_t x17;
+  uint64_t x18;
+  uint64_t x19;
+  uint64_t x20;
+  uint64_t x21;
+  uint64_t x22;
+  uint64_t x23;
+  uint64_t x24;
+  uint64_t x25;
+  uint64_t x26;
+  uint64_t x27;
+  uint64_t x28;
+  uint64_t x29;
+  uint64_t x30;
+  uint64_t sp;
+};
+
+const int kMaxRegConst = 128;
+static void PrintRegister(const std::string reg, uint64_t val) {
+  char content[kMaxRegConst];
+  int ret = sprintf_s(content, sizeof(content), "\t - phy reg %s\t%zx\t%zu", reg.c_str(), val, val);
+  if (ret < EOK) {
+    LOG(ERROR) << "sprintf_s failed. buffer: " << content << maple::endl;
+    return;
+  }
+#ifdef __ANDROID__
+  LOG(INFO) << content << maple::endl;
+#else
+  printf("%s\n", content);
+#endif
+}
+
+extern "C" void PrintAArch64RegSet(AArch64RegSet *pregs) {
+  const char *msg = "dump phy reg for aarch64, note x16 and x17 are unreliable due to plt or signal handler stub";
+#ifdef __ANDROID__
+  LOG(INFO) << msg << maple::endl;
+#else
+  printf("%s\n", msg);
+#endif
+  DCHECK(pregs != nullptr) << "pregs is nullptr in PrintAArch64RegSet" << maple::endl;
+  PrintRegister("x0", pregs->x0);
+  PrintRegister("x1", pregs->x1);
+  PrintRegister("x2", pregs->x2);
+  PrintRegister("x3", pregs->x3);
+  PrintRegister("x4", pregs->x4);
+  PrintRegister("x5", pregs->x5);
+  PrintRegister("x6", pregs->x6);
+  PrintRegister("x7", pregs->x7);
+  PrintRegister("x8", pregs->x8);
+  PrintRegister("x9", pregs->x9);
+  PrintRegister("x10", pregs->x10);
+  PrintRegister("x11", pregs->x11);
+  PrintRegister("x12", pregs->x12);
+  PrintRegister("x13", pregs->x13);
+  PrintRegister("x14", pregs->x14);
+  PrintRegister("x15", pregs->x15);
+  PrintRegister("x16", pregs->x16);
+  PrintRegister("x17", pregs->x17);
+  PrintRegister("x18", pregs->x18);
+  PrintRegister("x19", pregs->x19);
+  PrintRegister("x20", pregs->x20);
+  PrintRegister("x21", pregs->x21);
+  PrintRegister("x22", pregs->x22);
+  PrintRegister("x23", pregs->x23);
+  PrintRegister("x24", pregs->x24);
+  PrintRegister("x25", pregs->x25);
+  PrintRegister("x26", pregs->x26);
+  PrintRegister("x27", pregs->x27);
+  PrintRegister("x28", pregs->x28);
+  PrintRegister("x29", pregs->x29);
+  PrintRegister("x30", pregs->x30);
+  PrintRegister("sp", pregs->sp);
+
+  // dump anything of interest here
+}
+
+// undocumented entry points
+ENTRY_POINT_BL(MplDtEnter)
+ENTRY_POINT_JMP(MplDtExit)
+ENTRY_POINT_JMP(MplFuncProfile)
+ENTRY_POINT_BL(MplTraceWithBreak)
+
+struct frame {
+  double d6;
+  double d7;
+  double d4;
+  double d5;
+  double d2;
+  double d3;
+  double d0;
+  double d1;
+  uint64_t x6;
+  uint64_t x7;
+  uint64_t x4;
+  uint64_t x5;
+  uint64_t x2;
+  uint64_t x3;
+  uint64_t x0;
+  uint64_t x1;
+  uint64_t x29;  // FP
+  uint64_t x30;  // LR
+};
+
+extern "C" {
+const unsigned int kNumLimit = 10;
+const unsigned int kCodeOffset = 4;
+void DecodeName(const char *name, char *dname) {
+  size_t i = 0;
+  size_t j = 0;
+
+  if (name == nullptr || dname == nullptr) {
+    return;
+  }
+  size_t len = strlen(name);
+  const size_t maxLen = 512;
+  if (len >= maxLen) {
+    return;
+  }
+
+  while (i < len) {
+    unsigned char c = name[i++];
+    if (c == '_') {
+      if (name[i] == '_') {
+        dname[j++] = name[i++];
+      } else {
+        // _XX: '_' followed by ascii code in hex
+        c = name[i++];
+        auto v = static_cast<unsigned>((c <= '9') ? c - '0' : c - 'A' + kNumLimit);
+        unsigned asc = v << kCodeOffset;
+        c = name[i++];
+        v = static_cast<unsigned>((c <= '9') ? c - '0' : c - 'A' + kNumLimit);
+        asc += v;
+        dname[j++] = static_cast<char>(asc);
+
+        if (asc == '(' || asc == ')' || asc == ';') {
+          while (name[i] == 'A') {
+            dname[j++] = '[';
+            i++;
+          }
+        }
+      }
+    } else {
+      dname[j++] = c;
+    }
+  }
+  dname[j] = '\0';
+  return;
+}
+
+static __attribute__((used)) __thread int nEntered = 0;
+const int kStackCapacity = 1024;
+static __attribute__((used)) __thread uint64_t funcStack[kStackCapacity];
+
+void MplFuncProfileImpl(struct frame *fr) {
+  if (!VLOG_IS_ON(methodtrace)) {
+    return;
+  }
+  std::string func("unknown");
+  std::string soname("unknown");
+  std::ostringstream funcaddrstr;
+  DCHECK(fr != nullptr) << "fr is nullptr in MplFuncProfileImpl" << maple::endl;
+  uint64_t faddr = fr->x30 - 4; /* 4 for bl to this call */
+  if (CheckMethodResolved(faddr)) {
+    return;
+  }
+#if RECORD_FUNC_NAME
+  bool result = resolve_addr2name(func, faddr);
+  if (!result) {
+    LOG(WARNING) << "resolve " << std::hex << "0x" << faddr << " failed " << std::dec;
+    funcaddrstr << std::hex << "0x" << faddr;
+    func = funcaddrstr.str();
+  } else {
+    soname = maple::LinkerAPI::Instance().GetMFileNameByPC(reinterpret_cast<void*>(faddr), false);
+  }
+#endif
+  RecordMethod(faddr, func, soname);
+}
+
+// No floating point can be used in this function.
+__attribute__((used)) void MplDtEnterImpl(struct frame *fr) {
+  if (!VLOG_IS_ON(methodtrace)) {
+    return;
+  }
+  std::string func("unknown");
+  std::ostringstream funcaddrstr;
+  DCHECK(fr != nullptr) << "fr is nullptr in MplDtEnterImpl" << maple::endl;
+  uint64_t faddr = fr->x30 - 4; // 4 for bl to this call
+  bool result = ResolveAddr2Name(func, faddr);
+  if (!result) {
+    LOG(WARNING) << "resolve " << std::hex << "0x" << faddr << " failed " << std::dec;
+  }
+  pthread_t self;
+  self = pthread_self();
+  char dfunc[512]; // max length of dfunc
+  int top = nEntered++;
+  if (top < kStackCapacity && top >= 0) {
+    funcStack[top] = faddr;
+  }
+  DecodeName(func.c_str(), dfunc);
+  (void)fprintf(stderr, "enter: [%d:%p] %s : %16p\n", top, reinterpret_cast<void*>(self), dfunc,
+                reinterpret_cast<void*>(fr->x0));
+#if CONFIG_TRACE
+  const int minDFuncLength = 12;
+  if (IsTracingEnabled()) {
+    if (strlen(dfunc) <= minDFuncLength) {
+      return;
+    }
+
+    GetTracer()->LogMethodTraceEvent(dfunc, 0x0);
+  }
+#endif
+}
+
+__attribute__((used)) void MplDtExitImpl(struct frame *fr) {
+  if (!VLOG_IS_ON(methodtrace)) {
+    return;
+  }
+
+  pthread_t self;
+  self = pthread_self();
+  std::string func;
+  char dfunc[512] = { 0 }; // max length of dfunc
+  uint64_t faddr = 0;
+  int top = --nEntered;
+  if (top < kStackCapacity && top >= 0) {
+    faddr = funcStack[top];
+  }
+  if (faddr != 0) {
+    if (ResolveAddr2Name(func, faddr)) {
+      DecodeName(func.c_str(), dfunc);
+    }
+  }
+  DCHECK(fr != nullptr) << "fr is nullptr in MplDtExitImpl" << maple::endl;
+  fprintf(stderr, " exit: [%d:%p] %s : rv %16p\n", top, reinterpret_cast<void*>(self),
+          (faddr != 0) ? dfunc : "unknown", reinterpret_cast<void*>(fr->x0));
+#if CONFIG_TRACE
+  const int minDfuncLength = 12;
+  if (IsTracingEnabled()) {
+    if (strlen(dfunc) <= minDfuncLength) {
+      return;
+    }
+
+    GetTracer()->LogMethodTraceEvent(dfunc, 0x1);
+  }
+#endif
+}
+const int kAddrRegOffset = 8;
+// No floating point can be used in this function.
+__attribute__((used)) void MplTraceImpl(struct frame *fr) {
+  std::string func;
+  char dfunc[512]; // max length of dfunc
+  DCHECK(fr != nullptr) << "fr is nullptr in MplTraceImpl" << maple::endl;
+  if (ResolveAddr2Name(func, fr->x30 - kAddrRegOffset)) {
+    DecodeName(func.c_str(), dfunc);
+    (void)fprintf(stderr, "%s : %16p\n", dfunc, reinterpret_cast<void*>(fr->x0));
+  }
+}
+
+__attribute__((noinline)) void SetBreakPoint() {
+}
+
+// No floating point can be used in this function.
+__attribute__((used)) void MplTraceWithBreakImpl(struct frame *fr) {
+  MplTraceImpl(fr);
+  SetBreakPoint();
+}
+}
+
+}  // namespace maplert
diff --git a/src/mrt/compiler-rt/src/libs_fast.cpp b/src/mrt/compiler-rt/src/libs_fast.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec3f53ec765252da9fb7ce8d088aff367b453a4f
--- /dev/null
+++ b/src/mrt/compiler-rt/src/libs_fast.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <dlfcn.h>
+#include "securec.h"
+#include "libs.h"
+#include "mm_config.h"
+#include "panic.h"
+#include "thread_offsets.h"
+#include "exception/mrt_exception.h"
+
+namespace maplert {
+extern "C" {
+// lockword in java object is 32bit. from lockword.h:
+//
+// ThinLock:
+// |10|98|765432109876|5432109876543210|
+// |00|xx|lock count  |thread id       |
+#define THREADID(lockword)       (lockword & 0xFFFF)
+#define STATE_THREADID(lockword) (lockword & 0xC000FFFF)
+#define LOCKSTATE(lockword)      (lockword & 0xC0000000)
+#define LOCKCOUNT(lockword)      (lockword & 0x0FFF0000)
+const int kLockCountMax = 0x0FFF0000;
+const int kLockCount1 = 0x00010000;
+
+// This version will be converted to assembly code
+void MCC_SyncEnterFast2(address_t obj) {
+  maple::IThread *tSelf = maple::IThread::Current();
+
+  if (LIKELY((tSelf != nullptr) && (obj != 0))) {
+    // fast path
+    std::atomic<uint32_t> &lockword = AddrToLValAtomic<uint32_t>(obj + kLockWordOffset);
+    uint32_t oldLockword = lockword.load();
+    uint32_t oldLockword2 = oldLockword;
+    oldLockword2 &= 0xEFFFFFFF;
+    uint32_t threadID = *reinterpret_cast<uint32_t*>((reinterpret_cast<uint64_t>(tSelf) + kThreadIdOffset));
+    // Note: threadID bit 16-31 should be zero, shold we check it here?
+    if (LIKELY(oldLockword2 == 0)) { // nobody owns the lock
+      uint32_t newLockword = oldLockword | threadID; // just set threadID
+      if (lockword.compare_exchange_weak(oldLockword, newLockword)) {
+        goto SYNC_ENTER_FAST_PATH_EXIT;
+      }
+    } else if (threadID == STATE_THREADID(oldLockword)) { // thin lock owned by this thread
+      if (LOCKCOUNT(oldLockword) < kLockCountMax) { // not exceed thin-lock capability
+        if (lockword.compare_exchange_weak(oldLockword, oldLockword + kLockCount1)) {
+          goto SYNC_ENTER_FAST_PATH_EXIT;
+        }
+      }
+    }
+  }
+
+  // slow path
+  MRT_BuiltinSyncEnter(obj);
+  return;
+
+SYNC_ENTER_FAST_PATH_EXIT:
+  tSelf->PushLockedMonitor(reinterpret_cast<void*>(obj), __builtin_return_address(0),
+                           static_cast<uint32_t>(maple::kMplLocked));
+}
+
+void MCC_SyncEnterFast0(address_t obj) __attribute__((alias("MCC_SyncEnterFast2")));
+void MCC_SyncEnterFast1(address_t obj) __attribute__((alias("MCC_SyncEnterFast2")));
+void MCC_SyncEnterFast3(address_t obj) __attribute__((alias("MCC_SyncEnterFast2")));
+
+void MCC_SyncExitFast(address_t obj) {
+  maple::IThread *tSelf = maple::IThread::Current();
+
+  if (LIKELY((tSelf != nullptr) && (obj != 0))) {
+    // fast path
+    std::atomic<uint32_t> &lockword = AddrToLValAtomic<uint32_t>(obj + kLockWordOffset);
+    uint32_t oldLockword = lockword.load();
+    uint32_t threadID = *reinterpret_cast<uint32_t*>((reinterpret_cast<uint64_t>(tSelf) + kThreadIdOffset));
+    if (threadID == STATE_THREADID(oldLockword)) { // thin lock owned by this thread
+      uint32_t newLockword = oldLockword & 0x10000000; // default to count == 1 case, need to clear threadID
+      if (UNLIKELY(LOCKCOUNT(oldLockword) > 0)) { // count > 1, just --count
+        newLockword = oldLockword - kLockCount1;
+      }
+      if (lockword.compare_exchange_weak(oldLockword, newLockword)) {
+        goto SYNC_EXIT_FAST_PATH_EXIT;
+      }
+    }
+  }
+
+  // slow path
+  MRT_BuiltinSyncExit(obj);
+  return;
+
+SYNC_EXIT_FAST_PATH_EXIT:
+  tSelf->PopLockedMonitor();
+}
+
+JNIEnv *MCC_PreNativeCall(jobject) {
+  // at this point, currentThread cannot be null
+  maple::IThread *currentThread = maple::IThread::Current();
+  return currentThread->PreNativeCall();
+}
+
+void MCC_PostNativeCall(JNIEnv *env) {
+  // at this point, currentThread cannot be null
+  maple::IThread *currentThread = maple::IThread::Current();
+  currentThread->PostNativeCall(env);
+}
+
+} // extern "C"
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/linker/linker.cpp b/src/mrt/compiler-rt/src/linker/linker.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6bddeac91770865c1159c8d88699aecf78fa1340
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker.cpp
@@ -0,0 +1,979 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker.h"
+
+#include <thread>
+#include <dirent.h>
+#include <fstream>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <sys/file.h>
+
+#include "file_system.h"
+#include "linker/linker_inline.h"
+#include "linker/linker_debug.h"
+#include "linker/linker_cache.h"
+#include "linker/linker_lazy_binding.h"
+#ifdef LINKER_DECOUPLE
+#include "linker/decouple/linker_decouple.h"
+#endif
+#include "collector/cp_generator.h"
+
+using namespace maple;
+
+namespace maplert {
+using namespace linkerutils;
+FeatureName Linker::featureName = kFLinker;
+bool Linker::HandleSymbol() {
+  bool ret = true;
+  if (!HandleMethodSymbol()) {
+    ret = false;
+  }
+  if (!HandleDataSymbol()) {
+    ret = false;
+  }
+  return ret;
+}
+
+// Handle all methods relevant symbols for the .so file of 'handle', by traverse 'handles' list.
+bool Linker::HandleMethodSymbol() {
+  if (!LOG_NDEBUG) {
+    (void)(pInvoker->ForEachDoAction(pInvoker->Get<Debug>(), &Debug::DumpMethodSymbol));
+  }
+  bool ret = true;
+  if (!(pInvoker->ForEachDoAction(this, &Linker::ResolveMethodSymbol))) {
+    ret = false;
+  }
+  if (!(pInvoker->ForEachDoAction(this, &Linker::RelocateMethodSymbol))) {
+    ret = false;
+  }
+  if (!(pInvoker->ForEachDoAction(this, &Linker::ResolveVTableSymbol))) {
+    ret = false;
+  }
+  if (!(pInvoker->ForEachDoAction(this, &Linker::ResolveITableSymbol))) {
+    ret = false;
+  }
+  if (!LOG_NDEBUG) {
+    (void)(pInvoker->ForEachDoAction(pInvoker->Get<Debug>(), &Debug::DumpMethodUndefSymbol));
+  }
+  return ret;
+}
+
+// Handle all data relevant symbols for the .so file of 'handle', by traverse 'handles' list.
+bool Linker::HandleDataSymbol() {
+  if (!LOG_NDEBUG) {
+    (void)(pInvoker->ForEachDoAction(pInvoker->Get<Debug>(), &Debug::DumpDataSymbol));
+  }
+  bool ret = true;
+  if (!(pInvoker->ForEachDoAction(this, &Linker::ResolveDataSymbol))) {
+    ret = false;
+  }
+  if (!(pInvoker->ForEachDoAction(this, &Linker::RelocateDataSymbol))) {
+    ret = false;
+  }
+  if (!(pInvoker->ForEachDoAction(this, &Linker::ResolveSuperClassSymbol))) {
+    ret = false;
+  }
+  if (!(pInvoker->ForEachDoAction(this, &Linker::ResolveGCRootSymbol))) {
+    ret = false;
+  }
+
+  if (!LOG_NDEBUG) {
+    (void)(pInvoker->ForEachDoAction(pInvoker->Get<Debug>(), &Debug::DumpDataUndefSymbol));
+  }
+  return ret;
+}
+
+bool Linker::HandleSymbol(LinkerMFileInfo &mplInfo) {
+  // Ignore the system class loader.
+  if (!pInvoker->IsSystemClassLoader(reinterpret_cast<MObject*>(mplInfo.classLoader)) &&
+      GetLoadState() == kLoadStateApk) {
+    pInvoker->SubMultiSoPendingCount();
+  }
+  bool ret = true;
+  if (!HandleMethodSymbol(mplInfo)) {
+    ret = false;
+  }
+  if (!HandleDataSymbol(mplInfo)) {
+    ret = false;
+  }
+  return ret;
+}
+
+// Handle all methods relevant symbols for the .so file of 'handle', by traverse 'handles' list.
+bool Linker::HandleMethodSymbol(LinkerMFileInfo &mplInfo) {
+  if (!LOG_NDEBUG) {
+    (void)(pInvoker->DoAction(pInvoker->Get<Debug>(), &Debug::DumpMethodSymbol, mplInfo));
+  }
+  if (!mplInfo.IsFlag(kIsLazy)) {
+    // If not resolved symbols exist after previous trial, we need a full traversal.
+    if (methodHasNotResolved) {
+      methodHasNotResolved = !pInvoker->ForEachDoAction(this, &Linker::ResolveMethodSymbol);
+    } else {
+      methodHasNotResolved = !pInvoker->DoAction(this, &Linker::ResolveMethodSymbol, mplInfo);
+    }
+
+    if (NeedRelocateSymbol(mplInfo.name)) { // Ignore the procedure for profiling top apps
+      // If not relocated symbols exist after previous trial, we need a full traversal.
+      if (methodHasNotRelocated) {
+        methodHasNotRelocated = !pInvoker->ForEachDoAction(this, &Linker::RelocateMethodSymbol);
+      } else {
+        methodHasNotRelocated = !pInvoker->DoAction(this, &Linker::RelocateMethodSymbol, mplInfo);
+      }
+    }
+
+    // If not resolved symbols exist after previous trial, we need a full traversal.
+    if (vtableHasNotResolved) {
+      vtableHasNotResolved = !pInvoker->ForEachDoAction(this, &Linker::ResolveVTableSymbol);
+    } else {
+      vtableHasNotResolved = !pInvoker->DoAction(this, &Linker::ResolveVTableSymbol, mplInfo);
+    }
+
+    // If not resolved symbols exist after previous trial, we need a full traversal.
+    if (itableHasNotResolved) {
+      itableHasNotResolved = !pInvoker->ForEachDoAction(this, &Linker::ResolveITableSymbol);
+    } else {
+      itableHasNotResolved = !pInvoker->DoAction(this, &Linker::ResolveITableSymbol, mplInfo);
+    }
+  }
+
+  if (!LOG_NDEBUG) {
+    (void)(pInvoker->DoAction(pInvoker->Get<Debug>(), &Debug::DumpMethodUndefSymbol, mplInfo));
+  }
+  return !methodHasNotResolved && !methodHasNotRelocated && !vtableHasNotResolved && !itableHasNotResolved;
+}
+
+// Handle all data relevant symbols for the .so file of 'handle', by traverse 'handles' list.
+bool Linker::HandleDataSymbol(LinkerMFileInfo &mplInfo) {
+  if (!LOG_NDEBUG) {
+    (void)(pInvoker->DoAction(pInvoker->Get<Debug>(), &Debug::DumpDataSymbol, mplInfo));
+  }
+  if (!mplInfo.IsFlag(kIsLazy)) {
+    // If not resolved symbols exist after previous trial, we need a full traversal.
+    if (dataHasNotResolved) {
+      dataHasNotResolved = !pInvoker->ForEachDoAction(this, &Linker::ResolveDataSymbol);
+    } else {
+      dataHasNotResolved = !pInvoker->DoAction(this, &Linker::ResolveDataSymbol, mplInfo);
+    }
+
+    if (NeedRelocateSymbol(mplInfo.name)) { // Ignore the procedure for profiling top apps
+      // If not relocated symbols exist after previous trial, we need a full traversal.
+      if (dataHasNotRelocated) {
+        dataHasNotRelocated = !pInvoker->ForEachDoAction(this, &Linker::RelocateDataSymbol);
+      } else {
+        dataHasNotRelocated = !pInvoker->DoAction(this, &Linker::RelocateDataSymbol, mplInfo);
+      }
+    }
+
+    // If not resolved symbols exist after previous trial, we need a full traversal.
+    if (superClassHasNotResolved) {
+      superClassHasNotResolved = !pInvoker->ForEachDoAction(this, &Linker::ResolveSuperClassSymbol);
+    } else {
+      superClassHasNotResolved = !pInvoker->DoAction(this, &Linker::ResolveSuperClassSymbol, mplInfo);
+    }
+  }
+
+  // If not resolved symbols exist after previous trial, we need a full traversal.
+  if (gcRootListHasNotResolved) {
+    gcRootListHasNotResolved = !pInvoker->ForEachDoAction(this, &Linker::ResolveGCRootSymbol);
+  } else {
+    gcRootListHasNotResolved = !pInvoker->DoAction(this, &Linker::ResolveGCRootSymbol, mplInfo);
+  }
+
+  if (!LOG_NDEBUG) {
+    (void)(pInvoker->DoAction(pInvoker->Get<Debug>(), &Debug::DumpDataUndefSymbol, mplInfo));
+  }
+  return !dataHasNotResolved && !dataHasNotRelocated && !superClassHasNotResolved && !gcRootListHasNotResolved;
+}
+
+// Resolve all undefined methods symbols for the .so file of 'handle', by traverse 'handles' list.
+bool Linker::ResolveMethodSymbol(LinkerMFileInfo &mplInfo) {
+  mplInfo.SetFlag(kIsMethodUndefHasNotResolved, false);
+  if (mplInfo.IsFlag(kIsMethodDefResolved) || mplInfo.IsFlag(kIsLazy)) {
+    return true;
+  }
+  size_t undefSize = mplInfo.GetTblSize(kMethodUndef);
+  if (undefSize == 0) {
+    LINKER_LOG(ERROR) << "undefSize=" << undefSize << ", " << mplInfo.name << maple::endl;
+    mplInfo.SetFlag(kIsMethodDefResolved, true);
+    return true;
+  }
+  AddrSlice addrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodUndef), undefSize);
+  MuidSlice muidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodUndefMuid), undefSize);
+  pInvoker->GetClassLoaderList(mplInfo, mplInfo.clList);
+#ifdef LINKER_RT_CACHE
+  pInvoker->Get<LinkerCache>()->ResolveMethodSymbol(mplInfo, addrSlice, muidSlice);
+  if (!mplInfo.IsFlag(kIsLazy)) {
+    pInvoker->Get<LinkerCache>()->FreeMethodUndefTable(mplInfo);
+  }
+#else
+  for (size_t i = 0; i < undefSize; ++i) {
+    LinkerOffsetType tmpAddr = 0;
+    if (!pInvoker->ForEachLookUp(muidSlice[i].muid, pInvoker,
+        &LinkerInvoker::LookUpMethodSymbolAddress, mplInfo, tmpAddr)) { // Not found
+      if (!mplInfo.IsFlag(kIsLazy)) {
+        mplInfo.SetFlag(kIsMethodUndefHasNotResolved, true);
+      }
+    } else { // Found
+      addrSlice[i].addr = tmpAddr;
+    }
+  }
+#endif
+  if (!mplInfo.IsFlag(kIsMethodUndefHasNotResolved)) {
+    mplInfo.SetFlag(kIsMethodDefResolved, true);
+    return true;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed to resolve all MUIDs for " << mplInfo.name << maple::endl;
+    return false;
+  }
+}
+
+#ifdef LINKER_LAZY_BINDING
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+void Linker::InitMethodSymbolLazy32(LinkerMFileInfo &mplInfo, size_t defSize) {
+  if (mplInfo.IsFlag(kIsLazy)) {
+    size_t undefSize = mplInfo.GetTblSize(kMethodUndef);
+    LinkerAddrTableItem *pUndefTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodUndef);
+    if (undefSize != 0 && pUndefTable != nullptr) {
+      for (size_t i = 0; i < undefSize; ++i) {
+        // + kBindingStateMethodUndef:0x5
+        pUndefTable[i].addr = pInvoker->AddrToUint32(
+            reinterpret_cast<void*>(__BindingProtectRegion__ + static_cast<int>(pUndefTable[i].addr)));
+      }
+    } else {
+      LINKER_LOG(ERROR) << "failed, --lazy-binding, pUndefTable is invalid in " << mplInfo.name << maple::endl;
+    }
+    LinkerAddrTableItem *pDefTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDef);
+    if (pDefTable != nullptr) {
+      for (size_t i = 0; i < defSize; ++i) {
+        // + kBindingStateMethodDef:0x6
+        pDefTable[i].addr = pInvoker->AddrToUint32(
+            reinterpret_cast<void*>(__BindingProtectRegion__ + static_cast<int>(pDefTable[i].addr)));
+      }
+    } else {
+      LINKER_LOG(ERROR) << "failed, --lazy-binding, pDefTable is null in " << mplInfo.name << maple::endl;
+    }
+  }
+}
+
+void Linker::InitDataSymbolLazy32(LinkerMFileInfo &mplInfo, size_t defSize) {
+  if (mplInfo.IsFlag(kIsLazy)) {
+    size_t undefSize = mplInfo.GetTblSize(kDataUndef);
+    LinkerAddrTableItem *pUndefTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataUndef);
+    if (undefSize != 0 && pUndefTable != nullptr) {
+      for (size_t i = 0; i < undefSize; ++i) {
+        // + kBindingStateCinfUndef:1, or + kBindingStateDataUndef:3
+        pUndefTable[i].addr = pInvoker->AddrToUint32(
+            reinterpret_cast<void*>(__BindingProtectRegion__ + reinterpret_cast<int>(pUndefTable[i].addr)));
+      }
+    } else {
+      LINKER_LOG(ERROR) << "failed, --lazy-binding, pUndefTable is invalid in " << mplInfo.name << maple::endl;
+    }
+    LinkerAddrTableItem *pDefTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDef);
+    if (pDefTable != nullptr) {
+      for (size_t i = 0; i < defSize; ++i) {
+        // + kBindingStateCinfDef:2, or + kBindingStateDataDef:4
+        pDefTable[i].addr = pInvoker->AddrToUint32(
+            reinterpret_cast<void*>(__BindingProtectRegion__ + reinterpret_cast<int>(pDefTable[i].addr)));
+      }
+    } else {
+      LINKER_LOG(ERROR) << "failed, --lazy-binding, pDefTable is null in " << mplInfo.name << maple::endl;
+    }
+  }
+}
+#endif // LINKER_32BIT_REF_FOR_DEF_UNDEF
+#endif // LINKER_LAZY_BINDING
+
+// Init all defined method symbols.
+void Linker::InitMethodSymbol(LinkerMFileInfo &mplInfo) {
+  // Fill the address by its offset.
+  if (!mplInfo.IsFlag(kIsRelMethodOnce)) {
+    mplInfo.SetFlag(kIsRelMethodOnce, true);
+    size_t defSize = mplInfo.GetTblSize(kMethodDef);
+    if (defSize == 0) {
+      return;
+    }
+
+    // Check if it's lazy-binding flag for methods.
+    if (mplInfo.GetTblSize(kMethodDefOrig) != 0) {
+      LINKER_VLOG(mpllinker) << "applied compiler --lazy-binding option in " << mplInfo.name << maple::endl;
+      mplInfo.SetFlag(kIsLazy, true);
+    }
+
+    LinkerAddrTableItem *pTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig);
+    if (pTable == nullptr) {
+      LINKER_LOG(ERROR) << "failed, pTable is null in " << mplInfo.name << maple::endl;
+      __MRT_ASSERT(0, "InitMethodSymbol(), pTable is null!\n");
+    }
+
+    if (!mplInfo.IsFlag(kIsLazy)) {
+      for (size_t i = 0; i < defSize; ++i) {
+        AdjustDefTableAddress(mplInfo, *pTable, i);
+      }
+    }
+
+#ifdef LINKER_LAZY_BINDING
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+    InitMethodSymbolLazy32(mplInfo, defSize);
+#endif // LINKER_32BIT_REF_FOR_DEF_UNDEF
+#endif // LINKER_LAZY_BINDING
+  }
+}
+
+// Relocate all defined method symbols.
+bool Linker::RelocateMethodSymbol(LinkerMFileInfo &mplInfo) {
+  mplInfo.SetFlag(kIsMethodDefHasNotResolved, false);
+  if (mplInfo.IsFlag(kIsMethodRelocated) || mplInfo.IsFlag(kIsLazy) || mplInfo.name == maple::fs::kLibcorePath) {
+    return true;
+  }
+  size_t defSize = mplInfo.GetTblSize(kMethodDef);
+  if (defSize == 0) {
+    mplInfo.SetFlag(kIsMethodRelocated, true);
+    LINKER_LOG(ERROR) << "methodDef table is null in" << mplInfo.name << maple::endl;
+    return true;
+  }
+  AddrSlice addrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDef), defSize);
+  MuidSlice muidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodDefMuid), defSize);
+  pInvoker->GetClassLoaderList(mplInfo, mplInfo.clList);
+#ifdef LINKER_RT_CACHE
+  pInvoker->Get<LinkerCache>()->RelocateMethodSymbol(mplInfo, addrSlice, muidSlice);
+  pInvoker->Get<LinkerCache>()->FreeMethodDefTable(mplInfo);
+#else
+  // Start binary search def from here.
+  for (size_t i = 0; i < defSize; ++i) {
+    LinkerOffsetType tmpAddr = 0;
+    if (!pInvoker->ForEachLookUp(muidSlice[i].muid, pInvoker,
+        &LinkerInvoker::LookUpMethodSymbolAddress, mplInfo, tmpAddr)) { // Not found
+      // Never reach here.
+      LINKER_LOG(ERROR) << "failed to relocate MUID=" << muidSlice[i].muid.ToStr() << " in " << mplInfo.name <<
+          ", tmpAddr=" << tmpAddr;
+      mplInfo.SetFlag(kIsMethodDefHasNotResolved, true);
+    } else { // Found
+      addrSlice[i].addr = tmpAddr;
+    }
+  }
+#endif
+  if (!mplInfo.IsFlag(kIsMethodDefHasNotResolved)) {
+    mplInfo.SetFlag(kIsMethodRelocated, true);
+    return true;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed to relocate all MUIDs for " << mplInfo.name << maple::endl;
+    return false;
+  }
+}
+
+bool Linker::ResolveUndefVTableSymbol(LinkerMFileInfo &mplInfo, bool fromUndef, size_t index,
+    VTableSlice &vTableSlice, size_t i) {
+  size_t methodUndefSize = mplInfo.GetTblSize(kMethodUndef);
+  AddrSlice methodUndefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodUndef), methodUndefSize);
+  size_t methodDefSize = mplInfo.GetTblSize(kMethodDef);
+  AddrSlice methodDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig), methodDefSize);
+  bool hasNotResolved = false;
+  if (fromUndef && index < methodUndefSize) {
+    if (mplInfo.IsFlag(kIsLazy) && pInvoker->GetAddrBindingState(methodUndefSlice, index) != kBindingStateResolved) {
+      size_t muidSize = mplInfo.GetTblSize(kMethodUndefMuid);
+      MuidSlice muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodUndefMuid), muidSize);
+      void *addr = pInvoker->Get<LazyBinding>()->ResolveMethodSymbol(
+          mplInfo, methodUndefSlice, muidSlice, index, false);
+      if (addr != nullptr) {
+        vTableSlice[i].index = reinterpret_cast<size_t>(addr);
+        LINKER_VLOG(lazybinding) << "resolved lazily, " << fromUndef << ", addr=" <<
+            methodUndefSlice[index].Address() << " in " << mplInfo.name << maple::endl;
+      } else {
+        LINKER_LOG(ERROR) << "not resolved lazily, " << fromUndef << ", " << index << ", " << methodUndefSize << ", " <<
+            methodDefSize << " in " << mplInfo.name << maple::endl;
+        hasNotResolved = true;
+      }
+    } else {
+      LINKER_DLOG(mpllinker) << "undef, " << std::hex << "addr=" << methodUndefSlice[index].Address() <<
+          " in " << mplInfo.name << maple::endl;
+      vTableSlice[i].index = reinterpret_cast<size_t>(methodUndefSlice[index].Address());
+    }
+  } else if (!fromUndef && index < methodDefSize) {
+    LINKER_DLOG(mpllinker) << "def, " << std::hex << "addr=" << methodDefSlice[index].Address() << " in " <<
+        mplInfo.name << maple::endl;
+    vTableSlice[i].index = reinterpret_cast<size_t>(GetDefTableAddress(mplInfo, methodDefSlice,
+        static_cast<size_t>(index), true));
+  } else {
+    LINKER_VLOG(mpllinker) << "not resolved, " << fromUndef << ", " << index << ", " << methodUndefSize << ", " <<
+        methodDefSize << " in " << mplInfo.name << maple::endl;
+    hasNotResolved = true;
+  }
+  return hasNotResolved;
+}
+
+// Resolve all VTable symbols for the .so file of 'handle'.
+bool Linker::ResolveVTableSymbol(LinkerMFileInfo &mplInfo) {
+  if (mplInfo.IsFlag(kIsVTabResolved) || mplInfo.IsFlag(kIsLazy)) {
+    return true;
+  }
+
+  bool hasNotResolved = false;
+  size_t vSize = mplInfo.GetTblSize(kVTable);
+  if (vSize == 0) {
+    mplInfo.SetFlag(kIsVTabResolved, true);
+    LINKER_LOG(ERROR) << "vTable is null in " << mplInfo.name << maple::endl;
+    return true;
+  }
+  VTableSlice vTableSlice = VTableSlice(mplInfo.GetTblBegin<LinkerVTableItem*>(kVTable), vSize);
+
+  for (size_t i = 0; i < vSize; ++i) {
+    LinkerRef ref(static_cast<uintptr_t>(vTableSlice[i].index));
+    if (ref.IsVTabIndex()) { // Index of undefine table.
+      hasNotResolved = ResolveUndefVTableSymbol(mplInfo, ref.IsTabUndef(), ref.GetTabIndex(), vTableSlice, i);
+    } else if (vTableSlice[i].index & kNegativeNum) { // Offset of address.
+      DataRefOffset *data = reinterpret_cast<DataRefOffset*>(&(vTableSlice[i].index));
+#ifdef USE_32BIT_REF
+      // To allow re-parse Vtable by the proper way.
+      if (!(static_cast<uint32_t>(vTableSlice[i].index) < kDsoLoadedAddressEnd &&
+          static_cast<uint32_t>(vTableSlice[i].index) >= kDsoLoadedAddressStart)) {
+        vTableSlice[i].index = data->GetDataRef<size_t>();
+      } else {
+        LINKER_DLOG(mpllinker) << "not re-parse for patch, " << std::hex << "addr=" << vTableSlice[i].index <<
+            ">X>" << data->GetDataRef<size_t>() << " in " << mplInfo.name << maple::endl;
+      }
+#else
+      vTableSlice[i].index = data->GetDataRef<size_t>();
+#endif
+    }
+  }
+  if (!hasNotResolved) {
+    mplInfo.SetFlag(kIsVTabResolved, true);
+    LINKER_VLOG(mpllinker) << "successfully resolved VTable for " << mplInfo.name << maple::endl;
+    return true;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed to resolve all VTable for " << mplInfo.name << maple::endl;
+    return false;
+  }
+}
+
+bool Linker::ResolveUndefITableSymbol(
+    LinkerMFileInfo &mplInfo, bool fromUndef, size_t index, ITableSlice &iTableSlice, size_t i) {
+  size_t methodUndefSize = mplInfo.GetTblSize(kMethodUndef);
+  AddrSlice methodUndefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodUndef), methodUndefSize);
+  size_t methodDefSize = mplInfo.GetTblSize(kMethodDef);
+  AddrSlice methodDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig), methodDefSize);
+  bool hasNotResolved = false;
+  if (fromUndef && index < methodUndefSize && !methodUndefSlice.Empty()) {
+    if (mplInfo.IsFlag(kIsLazy) && pInvoker->GetAddrBindingState(methodUndefSlice, index) != kBindingStateResolved) {
+      size_t muidSize = mplInfo.GetTblSize(kMethodUndefMuid);
+      MuidSlice muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodUndefMuid), muidSize);
+      void *addr = pInvoker->Get<LazyBinding>()->ResolveMethodSymbol(
+          mplInfo, methodUndefSlice, muidSlice, index, false);
+      if (addr != nullptr) {
+        iTableSlice[i].index = reinterpret_cast<size_t>(addr);
+        LINKER_VLOG(lazybinding) << "resolved lazily, " << fromUndef << ", addr=" <<
+            methodUndefSlice[index].Address() << " in " << mplInfo.name << maple::endl;
+      } else {
+        LINKER_LOG(ERROR) << "not resolved lazily, " << fromUndef << ", " << index << ", " << methodUndefSize << ", " <<
+            methodDefSize << " in " << mplInfo.name << maple::endl;
+        hasNotResolved = true;
+      }
+    } else {
+      iTableSlice[i].index = reinterpret_cast<size_t>(methodUndefSlice[index].Address());
+    }
+  } else if (!fromUndef && index < methodDefSize && !methodDefSlice.Empty()) {
+    iTableSlice[i].index = reinterpret_cast<size_t>(GetDefTableAddress(mplInfo, methodDefSlice,
+        static_cast<size_t>(index), true));
+  } else {
+    hasNotResolved = true;
+  }
+  return hasNotResolved;
+}
+
+// Resolve all ITable symbols for the .so file of 'handle'.
+bool Linker::ResolveITableSymbol(LinkerMFileInfo &mplInfo) {
+  if (mplInfo.IsFlag(kIsITabResolved) || mplInfo.IsFlag(kIsLazy)) {
+    return true;
+  }
+
+  bool hasNotResolved = false;
+  size_t iSize = mplInfo.GetTblSize(kITable);
+  if (iSize == 0) {
+    mplInfo.SetFlag(kIsITabResolved, true);
+    LINKER_LOG(ERROR) << "iTable is null in " << mplInfo.name << maple::endl;
+    return true;
+  }
+  ITableSlice iTableSlice = ITableSlice(mplInfo.GetTblBegin<LinkerITableItem*>(kITable), iSize);
+
+  for (size_t i = 0; i < iSize; ++i) {
+    if (i % 2 == 1) { // i % 2 is 1 means the number is odd.
+      LinkerRef ref(static_cast<uintptr_t>(iTableSlice[i].index));
+      if (ref.IsITabIndex()) { // Index of undefine table.
+        hasNotResolved = ResolveUndefITableSymbol(mplInfo, ref.IsTabUndef(), ref.GetTabIndex(), iTableSlice, i);
+      }
+    } else { // Offset of address
+#ifdef USE_32BIT_REF
+      MByteRef32 *ref = reinterpret_cast<MByteRef32*>(&(iTableSlice[i].index));
+      void *addr = ref->GetRef<void*>();
+      ref->SetRef(addr);
+#else
+      MByteRef *ref = reinterpret_cast<MByteRef*>(&(iTableSlice[i].index));
+      void *addr = ref->GetRef<void*>();
+      ref->SetRef(addr);
+#endif
+    }
+  }
+
+  if (!hasNotResolved) {
+    mplInfo.SetFlag(kIsITabResolved, true);
+    LINKER_VLOG(mpllinker) << "successfully resolved ITable for " << mplInfo.name << maple::endl;
+    return true;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed to resolve all ITable for " << mplInfo.name << maple::endl;
+    return false;
+  }
+}
+
+// Resolve all undefined data symbols for the .so file of 'handle', by traverse 'handles' list.
+bool Linker::ResolveDataSymbol(LinkerMFileInfo &mplInfo) {
+  mplInfo.SetFlag(kIsDataUndefHasNotResolved, false);
+  if (mplInfo.IsFlag(kIsDataDefResolved) || mplInfo.IsFlag(kIsLazy)) {
+    return true;
+  }
+  size_t undefSize = mplInfo.GetTblSize(kDataUndef);
+  if (undefSize == 0) {
+    mplInfo.SetFlag(kIsDataDefResolved, true);
+    LINKER_LOG(ERROR) << "DataUndef table is null in " << mplInfo.name << maple::endl;
+    return true;
+  }
+  AddrSlice addrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataUndef), undefSize);
+  MuidSlice muidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataUndefMuid), undefSize);
+  pInvoker->GetClassLoaderList(mplInfo, mplInfo.clList);
+#ifdef LINKER_RT_CACHE
+  pInvoker->Get<LinkerCache>()->ResolveDataSymbol(mplInfo, addrSlice, muidSlice);
+  if (!mplInfo.IsFlag(kIsLazy)) {
+    pInvoker->Get<LinkerCache>()->FreeDataUndefTable(mplInfo);
+  }
+#else
+  for (size_t i = 0; i < undefSize; ++i) {
+    LinkerOffsetType tmpAddr = 0;
+    if (!pInvoker->ForEachLookUp(muidSlice[i].muid, pInvoker,
+        &LinkerInvoker::LookUpDataSymbolAddress, mplInfo, tmpAddr)) { // Not found
+      if (!mplInfo.IsFlag(kIsLazy)) {
+        mplInfo.SetFlag(kIsDataUndefHasNotResolved, true);
+      }
+    } else { // Found
+      addrSlice[i].addr = tmpAddr;
+    }
+  }
+#endif // LINKER_RT_CACHE
+  if (!mplInfo.IsFlag(kIsDataUndefHasNotResolved)) {
+    mplInfo.SetFlag(kIsDataDefResolved, true);
+    return true;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed to resolve all MUIDs for " << mplInfo.name << maple::endl;
+    return false;
+  }
+}
+
+inline void Linker::AdjustDefTableAddress(
+    const LinkerMFileInfo &mplInfo, LinkerAddrTableItem &pTable, size_t index) {
+#ifndef LINKER_ADDRESS_VIA_BASE
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+  (&pTable)[index].addr = pInvoker->AddrToUint32((&pTable)[index].AddressFromOffset());
+#else
+  (&pTable)[index].addr = reinterpret_cast<LinkerOffsetType>((&pTable)[index].AddressFromOffset());
+#endif // USE_32BIT_REF
+#else // LINKER_ADDRESS_VIA_BASE
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+  (&pTable)[index].addr = pInvoker->AddrToUint32((&pTable)[index].AddressFromBase(mplInfo.elfBase));
+#else
+  (&pTable)[index].addr = reinterpret_cast<LinkerOffsetType>((&pTable)[index].Address());
+#endif // USE_32BIT_REF
+#endif // LINKER_ADDRESS_VIA_BASE
+  (void)(&mplInfo);
+}
+
+// Init all defined data symbols.
+void Linker::InitDataSymbol(LinkerMFileInfo &mplInfo) {
+  // Resolve the literal initialization entries based on the Literal pool
+  void **cTable = mplInfo.GetTblBegin<void**>(kDataConstStr);
+  if (cTable != nullptr) {
+    for (size_t i = 0; i < mplInfo.GetTblSize(kDataConstStr); ++i) {
+      DataRef *constStringRef = reinterpret_cast<DataRef*>(&cTable[i]);
+      MString *oldStrObj = constStringRef->GetDataRef<MString*>();
+      DCHECK(oldStrObj != nullptr);
+      cTable[i] = GetOrInsertLiteral(*oldStrObj);
+    }
+  }
+
+  // Fill the address by its offset.
+  if (!mplInfo.IsFlag(kIsRelDataOnce)) {
+    mplInfo.SetFlag(kIsRelDataOnce, true);
+    size_t defSize = mplInfo.GetTblSize(kDataDef);
+    if (defSize == 0) {
+      return;
+    }
+
+#ifdef LINKER_LAZY_BINDING
+    // Check if it's lazy-binding flag for cinf or data.
+    if (mplInfo.GetTblSize(kDataDefOrig) != 0) {
+      LINKER_VLOG(mpllinker) << "applied compiler --lazy-binding option in " << mplInfo.name << maple::endl;
+      mplInfo.SetFlag(kIsLazy, true);
+    }
+#endif // LINKER_LAZY_BINDING
+
+    LinkerAddrTableItem *pTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig);
+    if (pTable == nullptr) {
+      LINKER_LOG(ERROR) << "failed, pTable is null in " << mplInfo.name << maple::endl;
+      __MRT_ASSERT(0, "InitDataSymbol(), pTable is null!\n");
+    }
+
+#ifdef LINKER_LAZY_BINDING
+    if (!mplInfo.IsFlag(kIsLazy)) {
+#endif // LINKER_LAZY_BINDING
+      for (size_t i = 0; i < defSize; ++i) {
+        AdjustDefTableAddress(mplInfo, *pTable, i);
+      }
+#ifdef LINKER_LAZY_BINDING
+    }
+#endif // LINKER_LAZY_BINDING
+
+#ifdef LINKER_LAZY_BINDING
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+    InitDataSymbolLazy32(mplInfo, defSize);
+#endif // LINKER_32BIT_REF_FOR_DEF_UNDEF
+#endif // LINKER_LAZY_BINDING
+  }
+}
+
+// Relocate all defined data symbols.
+bool Linker::RelocateDataSymbol(LinkerMFileInfo &mplInfo) {
+  mplInfo.SetFlag(kIsDataDefHasNotResolved, false);
+  if (mplInfo.IsFlag(kIsDataRelocated) || mplInfo.IsFlag(kIsLazy) || mplInfo.name == maple::fs::kLibcorePath) {
+    return true;
+  }
+  size_t defSize = mplInfo.GetTblSize(kDataDef);
+  if (defSize == 0) {
+    mplInfo.SetFlag(kIsDataRelocated, true);
+    LINKER_LOG(ERROR) << "dataDef table is null in " << mplInfo.name << maple::endl;
+    return true;
+  }
+  AddrSlice addrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDef), defSize);
+  MuidSlice muidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataDefMuid), defSize);
+#ifdef LINKER_RT_CACHE
+  pInvoker->Get<LinkerCache>()->RelocateDataSymbol(mplInfo, addrSlice, muidSlice);
+  pInvoker->Get<LinkerCache>()->FreeDataDefTable(mplInfo);
+#else
+  pInvoker->GetClassLoaderList(mplInfo, mplInfo.clList);
+  for (size_t i = 0; i < defSize; ++i) {
+    LinkerOffsetType tmpAddr = 0;
+    if (!pInvoker->ForEachLookUp(muidSlice[i].muid, pInvoker,
+        &LinkerInvoker::LookUpDataSymbolAddress, mplInfo, tmpAddr)) { // Not found
+      // Never reach here.
+      LINKER_LOG(ERROR) << "failed to relocate MUID=" << muidSlice[i].muid.ToStr() << " in " << mplInfo.name <<
+          ", tmpAddr=" << tmpAddr;
+      mplInfo.SetFlag(kIsDataDefHasNotResolved, true);
+    } else { // Found
+      addrSlice[i].addr = tmpAddr;
+    }
+  }
+#endif // LINKER_RT_CACHE
+  if (!mplInfo.IsFlag(kIsDataDefHasNotResolved)) {
+    mplInfo.SetFlag(kIsDataRelocated, true);
+    return true;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed to relocate all MUIDs for " << mplInfo.name << maple::endl;
+    return false;
+  }
+}
+
+bool Linker::DoResolveSuperClassSymbol(LinkerMFileInfo &mplInfo, IndexSlice &superTableSlice,
+    const AddrSlice &dataUndefSlice, const AddrSlice &dataDefSlice, size_t i) {
+  bool fromUpper = false;
+  LinkerRef ref(superTableSlice[i].index);
+  if (ref.IsIndex()) {
+    size_t index = ref.GetIndex();
+    bool fromUndef = ref.IsFromUndef();
+    if (fromUndef && index < dataUndefSlice.Size() && !dataUndefSlice.Empty()) {
+      if (mplInfo.IsFlag(kIsLazy) && pInvoker->GetAddrBindingState(dataUndefSlice, index) != kBindingStateResolved) {
+        size_t muidSize = mplInfo.GetTblSize(kDataUndefMuid);
+        MuidSlice muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataUndefMuid), muidSize);
+        void *addr = pInvoker->Get<LazyBinding>()->ResolveClassSymbol(
+            mplInfo, dataUndefSlice, muidSlice, index, nullptr, fromUpper, false);
+        if (addr != nullptr) {
+          superTableSlice[i].index = reinterpret_cast<size_t>(addr);
+          LINKER_VLOG(lazybinding) << "resolved lazily, " << "addr=" << dataUndefSlice[index].Address() << maple::endl;
+        } else {
+          LINKER_LOG(ERROR) << "not resolved lazily, " << fromUndef << ", " << index << ", " << dataUndefSlice.Size() <<
+              ", " << dataDefSlice.Size() << " in " << mplInfo.name << maple::endl;
+          return true;
+        }
+      } else {
+        superTableSlice[i].index = reinterpret_cast<size_t>(dataUndefSlice[index].Address());
+        LINKER_DLOG(mpllinker) << "undef, addr=" << std::hex << superTableSlice[i].index << maple::endl;
+      }
+    } else if (!fromUndef && index < dataDefSlice.Size() && !dataDefSlice.Empty()) {
+      if (mplInfo.IsFlag(kIsLazy) && pInvoker->GetAddrBindingState(dataDefSlice, index) != kBindingStateResolved) {
+        size_t muidSize = mplInfo.GetTblSize(kDataDefMuid);
+        MuidSlice muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataDefMuid), muidSize);
+        void *addr = pInvoker->Get<LazyBinding>()->ResolveClassSymbol(
+            mplInfo, dataDefSlice, muidSlice, index, nullptr, fromUpper, true);
+        if (addr != nullptr) {
+          superTableSlice[i].index = reinterpret_cast<size_t>(addr);
+          LINKER_VLOG(lazybinding) << "resolved lazily, " << "addr=" << dataDefSlice[index].Address() << maple::endl;
+        } else {
+          LINKER_LOG(ERROR) << "not resolved lazily, " << fromUndef << ", " << index << ", " << dataUndefSlice.Size() <<
+              ", " << dataDefSlice.Size() << " in " << mplInfo.name << maple::endl;
+          return true;
+        }
+      } else {
+        superTableSlice[i].index = reinterpret_cast<size_t>(dataDefSlice[index].Address());
+        LINKER_DLOG(mpllinker) << "def, addr=" << std::hex << superTableSlice[i].index << maple::endl;
+      }
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Resolve all super-class symbols for the .so file of 'handle'.
+bool Linker::ResolveSuperClassSymbol(LinkerMFileInfo &mplInfo) {
+  if (mplInfo.IsFlag(kIsSuperClassResolved) || mplInfo.IsFlag(kIsLazy)) {
+    return true;
+  }
+
+  bool hasNotResolved = false;
+  size_t superSize = mplInfo.GetTblSize(kDataSuperClass);
+  if (superSize == 0) {
+    mplInfo.SetFlag(kIsSuperClassResolved, true);
+    LINKER_LOG(ERROR) << "dataSuperClass table is null in " << mplInfo.name << maple::endl;
+    return true;
+  }
+  IndexSlice superTableSlice = IndexSlice(mplInfo.GetTblBegin<LinkerSuperClassTableItem*>(kDataSuperClass), superSize);
+  size_t dataUndefSize = mplInfo.GetTblSize(kDataUndef);
+  AddrSlice dataUndefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataUndef), dataUndefSize);
+  size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+  AddrSlice dataDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), dataDefSize);
+  for (size_t i = 0; i < superSize; ++i) {
+    hasNotResolved = DoResolveSuperClassSymbol(mplInfo, superTableSlice, dataUndefSlice, dataDefSlice, i);
+  }
+  if (!hasNotResolved) {
+    mplInfo.SetFlag(kIsSuperClassResolved, true);
+    LINKER_VLOG(mpllinker) << "successfully resolved super-class for " << mplInfo.name << maple::endl;
+    return true;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed to resolve all super-class for " << mplInfo.name << maple::endl;
+    return false;
+  }
+}
+
+// Resolve all super-class symbols for the .so file of 'handle'.
+bool Linker::ResolveGCRootSymbol(LinkerMFileInfo &mplInfo) {
+  if (mplInfo.IsFlag(kIsGCRootListResolved)) {
+    LINKER_DLOG(mpllinker) << "already resolved for " << mplInfo.name << maple::endl;
+    return true;
+  }
+
+  bool hasNotResolved = false;
+  size_t gcRootSize = mplInfo.GetTblSize(kDataGcRoot);
+  if (gcRootSize == 0) {
+    mplInfo.SetFlag(kIsGCRootListResolved, true);
+    LINKER_LOG(ERROR) << "gcRootTable is null in " << mplInfo.name << maple::endl;
+    return true;
+  }
+  LinkerGCRootTableItem *gcRootTable = mplInfo.GetTblBegin<LinkerGCRootTableItem*>(kDataGcRoot);
+  size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+  AddrSlice dataDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), dataDefSize);
+
+  for (size_t i = 0; i < gcRootSize; ++i) {
+    LinkerRef ref(gcRootTable[i].index);
+    if (ref.IsIndex()) { // Index
+      size_t index = ref.GetIndex();
+      if (!ref.IsFromUndef() && index < dataDefSize) {
+        gcRootTable[i].index = reinterpret_cast<size_t>(GetDefTableAddress(mplInfo,
+            dataDefSlice, static_cast<size_t>(index), false));
+      } else {
+        hasNotResolved = true;
+      }
+    }
+  }
+  if (!hasNotResolved) {
+    mplInfo.SetFlag(kIsGCRootListResolved, true);
+    LINKER_VLOG(mpllinker) << "successfully resolved GCRoots for " << mplInfo.name << maple::endl;
+    return true;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed to resolve all GCRoots for " << mplInfo.name << maple::endl;
+    return false;
+  }
+}
+
+// Look up the MUID in both method table and data table.
+// Also see void *dlsym(void *handle, const char *symbol)
+void *Linker::LookUpSymbolAddress(const void *handle, const MUID &muid) {
+  LinkerMFileInfo *mplInfo = pInvoker->GetLinkerMFileInfo(kFromHandle, handle);
+  if (mplInfo != nullptr) {
+    return LookUpSymbolAddress(mplInfo, muid);
+  }
+  return nullptr;
+}
+
+// Look up the MUID in both method table and data table.
+// Also see void *dlsym(void *handle, const char *symbol)
+void *Linker::LookUpSymbolAddress(LinkerMFileInfo &mplInfo, const MUID &muid) {
+  void *symbol = nullptr;
+  size_t index = 0;
+  symbol = reinterpret_cast<void*>(pInvoker->LookUpMethodSymbolAddress(mplInfo, muid, index));
+  if (symbol == nullptr) {
+    symbol = reinterpret_cast<void*>(pInvoker->LookUpDataSymbolAddress(mplInfo, muid, index));
+  }
+  return symbol;
+}
+
+// Look up the MUID in both method table and data table.
+// Also see void *dlsym(void *handle, const char *symbol)
+void *Linker::LookUpSymbolAddress(const MUID &muid) {
+  void *addr = nullptr;
+  auto handle = [this, &muid, &addr](LinkerMFileInfo &mplInfo)->bool {
+    addr = this->LookUpSymbolAddress(mplInfo, muid);
+    if (addr != nullptr) {
+      LINKER_VLOG(mpllinker) << "found address of " << muid.ToStr() << ", in " << mplInfo.name << maple::endl;
+      return true;
+    }
+    return false;
+  };
+  (void)pInvoker->mplInfoList.FindIf(handle);
+  return addr;
+}
+
+void Linker::InitLinkerMFileInfoIgnoreSysCL(LinkerMFileInfo &mplInfo) {
+  mplInfo.hash = pInvoker->GetValidityCode(mplInfo);
+  mplInfo.hashOfDecouple = pInvoker->GetValidityCodeForDecouple(mplInfo);
+  bool isBoot = (mplInfo.classLoader == nullptr ||
+      pInvoker->IsBootClassLoader(reinterpret_cast<const MObject*>(mplInfo.classLoader)));
+  mplInfo.SetFlag(kIsBoot, isBoot);
+  if (!pInvoker->IsSystemClassLoader(reinterpret_cast<const MObject*>(mplInfo.classLoader)) &&
+      GetLoadState() == kLoadStateApk) {
+    pInvoker->AddMultiSoPendingCount();
+    if (GetAppLoadState() == kAppLoadBaseOnlyReady) {
+      SetAppLoadState(kAppLoadBaseOnly);
+
+      // For multi-so, set kGlobalAppBaseStr as
+      // "/data/app/com.sina.weibolite-ylociBbJwvlbG4TkHkRGkQ==/maple/arm64/"
+      // without "mapleclasses.so"
+      size_t posSeparator = mplInfo.name.rfind("/");
+      SetAppBaseStr(mplInfo.name.substr(0, posSeparator + 1));
+      LINKER_VLOG(mpllinker) << "GlobalAppBaseStr=" << GetAppBaseStr().c_str() << " in " << mplInfo.name << maple::endl;
+    } else if (GetAppLoadState() == kAppLoadBaseOnly) {
+      size_t posSeparator = mplInfo.name.rfind("/");
+      if (mplInfo.name.substr(0, posSeparator + 1) != GetAppBaseStr()) {
+        LINKER_VLOG(lazybinding) << "kAppLoadBaseOnly-->kAppLoadBaseAndOthers, " << mplInfo.name << maple::endl;
+        SetAppLoadState(kAppLoadBaseAndOthers);
+      }
+    }
+  }
+}
+
+void Linker::InitLinkerMFileInfoTableAddr(LinkerMFileInfo &mplInfo) const {
+  static const void *mapleCoreElfStart = nullptr;
+  uint64_t *rangeStart = static_cast<uint64_t*>(GetSymbolAddr(mplInfo.handle, kRangeTableFunc, true));
+  uint64_t *rangeEnd = static_cast<uint64_t*>(GetSymbolAddr(mplInfo.handle, kRangeTableEndFunc, true));
+  mplInfo.tableAddr = reinterpret_cast<PtrMatrixType>(rangeStart);
+  uint64_t maxLength = static_cast<uint64_t>(rangeEnd - rangeStart) / kTable2ndDimMaxCount;
+  mplInfo.rangeTabSize = static_cast<uint32_t>(maxLength);
+
+  mplInfo.elfStart = GetSymbolAddr(mplInfo.handle, kMapleStartFunc, true);
+  mplInfo.elfEnd = GetSymbolAddr(mplInfo.handle, kMapleEndFunc, true);
+
+  // Update the start and end address of the maple file(ELF). according by libmaplecore-all.so
+  if (mapleCoreElfStart == mplInfo.elfStart) {
+    mplInfo.elfStart = nullptr;
+  }
+
+  if (mplInfo.elfStart == nullptr || mplInfo.elfEnd == nullptr) {
+    // Update with the start of range table.
+    void *start = mplInfo.tableAddr;
+    mplInfo.elfStart = (mplInfo.elfStart == nullptr || mplInfo.elfStart > start) ? start : mplInfo.elfStart;
+    // Update with outline of range table end.
+    void *end = mplInfo.tableAddr + maxLength;
+    mplInfo.elfEnd = mplInfo.elfEnd > end ? mplInfo.elfEnd : end;
+    // Start from kVTable, ignore kRange.
+    for (size_t i = static_cast<size_t>(kVTable); i < static_cast<size_t>(maxLength); ++i) {
+      // Update the start address.
+      start = mplInfo.tableAddr[i][kTable1stIndex];
+      mplInfo.elfStart = (start != nullptr && mplInfo.elfStart > start) ? start : mplInfo.elfStart;
+      // Update the end address.
+      end = mplInfo.tableAddr[i][kTable2ndIndex];
+      mplInfo.elfEnd = mplInfo.elfEnd > end ? mplInfo.elfEnd : end;
+    }
+  }
+  if (mplInfo.name == maple::fs::kLibcorePath) {
+    mapleCoreElfStart = mplInfo.elfStart;
+  }
+}
+
+// Set the maple file's handle and path name.
+// We save them in a map, then we can query the path by handle in the map.
+// Also see GetDlopenMapleFiles().
+bool Linker::InitLinkerMFileInfo(LinkerMFileInfo &mplInfo, int32_t pos) {
+  InitLinkerMFileInfoTableAddr(mplInfo);
+  // Ignore the system class loader.
+  InitLinkerMFileInfoIgnoreSysCL(mplInfo);
+  InitMethodSymbol(mplInfo);
+  InitDataSymbol(mplInfo);
+
+#ifdef LINKER_DECOUPLE
+  DecoupleMFileInfo *dpInfo = reinterpret_cast<DecoupleMFileInfo*>(&mplInfo);
+  size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+  size_t dataUndefSize = mplInfo.GetTblSize(kDataUndef);
+  dpInfo->dataDefSlice = AddrSlice(dpInfo->GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), dataDefSize);
+  dpInfo->dataUndefSlice = AddrSlice(dpInfo->GetTblBegin<LinkerAddrTableItem*>(kDataUndef), dataUndefSize);
+  pInvoker->Get<Decouple>()->InitDecoupledClasses(dpInfo);
+#endif // LINKER_DECOUPLE
+
+  mplInfo.startHotStrTab = reinterpret_cast<char*>(GetSymbolAddr(mplInfo.handle, kStartHotStrTabBegin, true));
+  mplInfo.bothHotStrTab = reinterpret_cast<char*>(GetSymbolAddr(mplInfo.handle, kBothHotStrTabBegin, true));
+  mplInfo.runHotStrTab = reinterpret_cast<char*>(GetSymbolAddr(mplInfo.handle, kRunHotStrTabBegin, true));
+  mplInfo.coldStrTab = reinterpret_cast<char*>(GetSymbolAddr(mplInfo.handle, kColdStrTabBegin, true));
+  mplInfo.coldStrTabEnd = reinterpret_cast<char*>(GetSymbolAddr(mplInfo.handle, kColdStrTabEnd, true));
+
+  mplInfo.rometadataFieldStart = GetSymbolAddr(mplInfo.handle, kMetadataFieldStart, true);
+  mplInfo.rometadataFieldEnd = GetSymbolAddr(mplInfo.handle, kMetadataFieldEnd, true);
+
+  mplInfo.rometadataMethodStart = GetSymbolAddr(mplInfo.handle, kMetadataMethodStart, true);
+  mplInfo.rometadataMethodEnd = GetSymbolAddr(mplInfo.handle, kMetadataMethodEnd, true);
+
+  mplInfo.romuidtabStart = GetSymbolAddr(mplInfo.handle, kMuidTabStart, true);
+  mplInfo.romuidtabEnd = GetSymbolAddr(mplInfo.handle, kMuidTabEnd, true);
+
+  pInvoker->mplInfoNameMap.Append(mplInfo);
+  pInvoker->mplInfoHandleMap.Append(mplInfo);
+  pInvoker->mplInfoList.Append(mplInfo, pos);
+  pInvoker->mplInfoListCLMap.Append(mplInfo, pos);
+  bool isSuccess = pInvoker->mplInfoElfAddrSet.Append(mplInfo);
+  __MRT_ASSERT(isSuccess, "mplInfoElfAddrSet.insert failed\n");
+  if (mplInfo.IsFlag(kIsLazy)) {
+    isSuccess = pInvoker->mplInfoElfAddrLazyBindingSet.Append(mplInfo);
+    __MRT_ASSERT(isSuccess, "mplInfoElfAddrLazyBindingSet.insert failed\n");
+#if defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+    pInvoker->PreLinkLazyMethod(&mplInfo);
+#endif // defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+  }
+  return mplInfo.IsFlag(kIsLazy);
+}
+
+void Linker::FreeAllCacheTables(const MObject *classLoader) const {
+#ifdef LINKER_RT_CACHE
+  auto handle = [this](LinkerMFileInfo &mplInfo) {
+    this->pInvoker->Get<LinkerCache>()->FreeAllTables(mplInfo);
+  };
+  pInvoker->mplInfoListCLMap.ForEach(classLoader, handle);
+#endif
+  (void)classLoader;
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/linker/linker_api.cpp b/src/mrt/compiler-rt/src/linker/linker_api.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fec0f089d8a0e5067ff957db13d88902514e752f
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_api.cpp
@@ -0,0 +1,974 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker_api.h"
+
+#include <thread>
+#include <dirent.h>
+#include <fstream>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <sys/file.h>
+
+#include "file_system.h"
+#include "object_type.h"
+#include "linker/linker.h"
+#include "linker/linker_inline.h"
+#include "linker/linker_model.h"
+#include "linker/linker_cache.h"
+#include "linker/linker_debug.h"
+#include "linker/linker_hotfix.h"
+#include "linker/linker_lazy_binding.h"
+#include "linker/linker_gctib.h"
+#ifdef LINKER_DECOUPLE
+#include "linker/decouple/linker_decouple.h"
+#endif
+#include "utils/name_utils.h"
+#include "file_layout.h"
+#include "collector/cp_generator.h"
+
+using namespace maple;
+namespace maplert {
+using namespace linkerutils;
+void LinkerInvoker::PreInit() {
+  pLoader = &LoaderAPI::Instance();
+#ifdef LINKER_RT_CACHE
+  SetCachePath(kLinkerRootCachePath);
+#endif
+}
+void LinkerInvoker::PostInit() {
+  multiSoPendingCount = 0;
+}
+void LinkerInvoker::UnInit() {
+  multiSoPendingCount = 0;
+}
+#ifdef LINKER_RT_CACHE
+void LinkerInvoker::SetCachePath(const char *path) {
+  Get<LinkerCache>()->SetPath(path);
+}
+bool LinkerInvoker::GetCachePath(LinkerMFileInfo &mplInfo, std::string &path, LinkerCacheType cacheType) {
+  return Get<LinkerCache>()->GetPath(mplInfo, path, cacheType, maplert::linkerutils::GetLoadState());
+}
+#endif
+bool LinkerInvoker::LinkClassLazily(jclass klass) {
+  Get<LazyBinding>()->LinkClass(reinterpret_cast<MClass*>(klass));
+  return reinterpret_cast<MClass*>(klass)->IsLazyBinding();
+}
+bool LinkerInvoker::ReGenGctib4Class(jclass classInfo) {
+#ifdef LINKER_DECOUPLE
+  MplGctibAnalysis &gctib = Get<Decouple>()->GetGctibResolver();
+  return gctib.ReGenGctib4Class(reinterpret_cast<ClassMetadata*>(classInfo));
+#else
+  return ReGenGctib(reinterpret_cast<ClassMetadata*>(classInfo));
+#endif
+}
+uint64_t LinkerInvoker::DumpMetadataSectionSize(std::ostream &os, void *handle, const std::string sectionName) {
+  return Get<Debug>()->DumpMetadataSectionSize(os, handle, sectionName);
+}
+
+void LinkerInvoker::DumpAllMplSectionInfo(std::ostream &os) {
+  Get<Debug>()->DumpAllMplSectionInfo(os);
+}
+void LinkerInvoker::DumpAllMplFuncProfile(std::unordered_map<std::string, std::vector<FuncProfInfo>> &funcProfileRaw) {
+  Get<Debug>()->DumpAllMplFuncProfile(funcProfileRaw);
+}
+void LinkerInvoker::DumpAllMplFuncIRProfile(std::unordered_map<std::string, MFileIRProfInfo> &funcProfileRaw) {
+  Get<Debug>()->DumpAllMplFuncIRProfile(funcProfileRaw);
+}
+void LinkerInvoker::DumpBBProfileInfo(std::ostream &os) {
+  Get<Debug>()->DumpBBProfileInfo(os);
+}
+void LinkerInvoker::ClearAllMplFuncProfile() {
+  auto handle = [](LinkerMFileInfo &mplInfo)->void {
+    size_t size = mplInfo.GetTblSize(kMethodProfile);
+    LinkerFuncProfileTableItem *pTable = mplInfo.GetTblBegin<LinkerFuncProfileTableItem*>(kMethodProfile);
+    if (size == 0) {
+      return;
+    }
+    for (size_t i = 0; i < size; ++i) {
+      LinkerFuncProfileTableItem item = pTable[i];
+      if (item.callTimes) {
+        (void)mplInfo.funProfileMap.insert(std::make_pair(static_cast<uint32_t>(i),
+            FuncProfInfo(item.callTimes, static_cast<uint8_t>(kLayoutBootHot))));
+      }
+    }
+  };
+  mplInfoList.ForEach(handle);
+}
+
+// 1.ignore zygote process
+// 2.ignore system library in app process
+// 3.ignore library whose javaTextTableSize < 100KB
+// 4.release cold string table, JAVA_TEXT_TABLE and read-only memory of muid-tables:
+//   METHOD_INF_TABLE, METHOD_DEF_MUID_TABLE, DATA_DEF_MUID_TABLE, METHOD_MUID_INDEX_TABLE
+void LinkerInvoker::ReleaseBootPhaseMemory(bool isZygote, bool isSystemServer) {
+  if (isZygote) {
+    // release other mygote only boot-memory
+    return;
+  }
+  auto workingLinkerMFileInfoList = mplInfoList.Clone();
+  for (auto mplInfo : workingLinkerMFileInfoList) {
+    // ignore system library memory release in app process, which reduce release about 7M/8M
+    if (!isSystemServer && !mplInfo->BelongsToApp()) {
+      continue;
+    }
+
+    // according to statistics, the library memory is small if its javaTextTableSize < 100kB
+    // ignore all the sections release with the small library
+    size_t javaTextTableSize = mplInfo->GetTblSize(kJavaText);
+    if (javaTextTableSize < kLeastReleaseMemoryByteSize) {
+      continue;
+    }
+
+    // release .java_text
+    void *startAddr = mplInfo->GetTblBegin(kJavaText);
+    void *endAddr = mplInfo->GetTblEnd(kJavaText);
+    ReleaseMemory(startAddr, endAddr);
+
+    mplInfo->ReleaseReadOnlyMemory();
+  }
+}
+
+bool LinkerInvoker::CheckLinkerMFileInfoElfBase(LinkerMFileInfo &mplInfo) {
+  if (mplInfo.elfEnd == nullptr) {
+    mplInfo.elfEnd = GetSymbolAddr(mplInfo.handle, "MRT_GetMapleEnd", true);
+  }
+  int result = dl_iterate_phdr(
+    [](struct dl_phdr_info *phdrInfo, size_t, void *data)->int {
+      if (!LOG_NDEBUG) {
+        std::string name(phdrInfo->dlpi_name);
+        if (name.find("libmaple") != std::string::npos) {
+          LINKER_DLOG(mpllinker) << "name=" << phdrInfo->dlpi_name << " (" << phdrInfo->dlpi_phnum << " segments)" <<
+              "base=" << std::hex << phdrInfo->dlpi_addr << maple::endl;
+          for (int i = 0; i < phdrInfo->dlpi_phnum; ++i) {
+            LINKER_DLOG(mpllinker) << "header[" << i << "][type:" << phdrInfo->dlpi_phdr[i].p_type << "]: address=" <<
+                std::hex << reinterpret_cast<void*>(phdrInfo->dlpi_addr + phdrInfo->dlpi_phdr[i].p_vaddr) <<
+                maple::endl;
+          }
+        }
+      }
+      LinkerMFileInfo *mplInfo = static_cast<LinkerMFileInfo*>(data);
+      if (mplInfo->name != phdrInfo->dlpi_name) {
+        // If not equel, to check next dl_phdr_info
+        return 0;
+      }
+      mplInfo->elfBase = reinterpret_cast<void*>(phdrInfo->dlpi_addr);
+      return 1;
+    }, &mplInfo);
+  // To match abnormal path, such as /data/maple/lib64/libmaplecore-all.so -> /system/lib64/libmaplecore-all.so
+  bool flagResult = static_cast<bool>(result);
+  if (!flagResult) {
+    result = dl_iterate_phdr(
+      [](struct dl_phdr_info *phdrInfo, size_t, void *data)->int {
+        LinkerMFileInfo *mplInfo = static_cast<LinkerMFileInfo*>(data);
+        size_t pos = mplInfo->name.rfind('/');
+        if (pos == std::string::npos) {
+          return 0;
+        }
+        std::string fileName = mplInfo->name.substr(pos + 1);
+        std::string name(phdrInfo->dlpi_name);
+        if (name.find(fileName) == std::string::npos) {
+          // If not equel, to check next dl_phdr_info
+          return 0;
+        }
+        mplInfo->elfBase = reinterpret_cast<void*>(phdrInfo->dlpi_addr);
+        LINKER_VLOG(mpllinker) << "for abnormal path, elfBase=" << std::hex << mplInfo->elfBase << ", for " <<
+            mplInfo->name << maple::endl;
+        return 1;
+      }, &mplInfo);
+  }
+
+  LINKER_VLOG(mpllinker) << "base=" << mplInfo.elfBase << ", " <<
+      GetSymbolAddr(mplInfo.handle, "MRT_GetMapleEnd", true) <<
+      ", range={" << mplInfo.elfStart << ", " <<  mplInfo.elfEnd << "}, for " << mplInfo.name << maple::endl;
+  return static_cast<bool>(result);
+}
+
+// Check if the maple file of name is open for the maple file.
+// Return true, if it's valid maple file handle, or return false.
+bool LinkerInvoker::ContainLinkerMFileInfo(const std::string &name) {
+  return mplInfoNameMap.Find(name);
+}
+
+// Check if the handle is open for the maple file.
+// Return true, if it's valid maple file handle, or return false.
+bool LinkerInvoker::ContainLinkerMFileInfo(const void *handle) {
+  return mplInfoHandleMap.Find(handle);
+}
+
+bool LinkerInvoker::GetJavaTextInfo(const void *addr, LinkerMFileInfo **mplInfo, LinkerLocInfo &info, bool getName) {
+  *mplInfo = GetLinkerMFileInfo(kFromPC, addr);
+  if (*mplInfo != nullptr && LocateAddress(**mplInfo, addr, info, getName)) {
+    return true;
+  }
+  LINKER_VLOG(mpllinker) << "failed, not found " << addr << maple::endl;
+  return false;
+}
+
+void LinkerInvoker::GetStrTab(jclass klass, StrTab &strTab) {
+  const MClass *dCl = reinterpret_cast<const MClass*>(klass);
+  if (dCl->IsProxy() && dCl->GetNumOfSuperClasses() >= 1) {
+    dCl = dCl->GetSuperClassArray()[1];
+  }
+  constexpr int32_t cacheSize = 4;
+  LinkerMFileCache *lc = static_cast<LinkerMFileCache*>(maple::tls::GetTLS(maple::tls::kSlotMFileCache));
+  if (lc == nullptr) {
+    lc = new (std::nothrow) LinkerMFileCache;
+    if (lc == nullptr) {
+      LOG(FATAL) << "new LinkerMFileCache fail" << maple::endl;
+    }
+  }
+  LinkerMFileInfo *mplInfo = nullptr;
+  for (uint8_t i = 0; i < cacheSize; ++i) {
+    if (lc->clsArray[i] == dCl) {
+      mplInfo = lc->mpArray[i];
+    }
+  }
+  if (mplInfo == nullptr) {
+    mplInfo = GetLinkerMFileInfo(kFromMeta, dCl, dCl->IsLazyBinding());
+    lc->clsArray[lc->idx] = const_cast<MClass*>(dCl);
+    lc->mpArray[lc->idx] = mplInfo;
+    lc->idx = (lc->idx + 1) % cacheSize;
+    maple::tls::StoreTLS(static_cast<void*>(lc), maple::tls::kSlotMFileCache);
+  }
+  if (mplInfo == nullptr) {
+    LINKER_VLOG(mpllinker) << dCl->GetName() << ", mplInfo is nullptr" << maple::endl;
+    return;
+  }
+  strTab.startHotStrTab = mplInfo->startHotStrTab;
+  strTab.bothHotStrTab = mplInfo->bothHotStrTab;
+  strTab.runHotStrTab = mplInfo->runHotStrTab;
+  strTab.coldStrTab = mplInfo->coldStrTab;
+}
+
+char *LinkerInvoker::GetCString(jclass klass, uint32_t srcIndex) {
+  const MClass *dCl = reinterpret_cast<const MClass*>(klass);
+  constexpr int32_t realIndexStart = 2;
+  LinkerMFileInfo *mplInfo = GetLinkerMFileInfo(kFromMeta, dCl, dCl->IsLazyBinding());
+  if (mplInfo == nullptr) {
+    LINKER_VLOG(mpllinker) << dCl->GetName() << ", mplInfo is nullptr" << maple::endl;
+    return nullptr;
+  }
+  char *cStrStart = nullptr;
+  uint32_t index = srcIndex & 0xFFFFFFFF;
+  // 0x03 is 0011, index & 0x03 is to check isHotReflectStr.
+  bool isHotReflectStr = (index & 0x03) != 0;
+  uint32_t cStrIndex = index >> realIndexStart;
+  if (isHotReflectStr) {
+    uint32_t tag = (index & 0x03) - kCStringShift;
+    if (tag == static_cast<uint32_t>(kLayoutBootHot)) {
+      cStrStart = mplInfo->startHotStrTab;
+    } else if (tag == static_cast<uint32_t>(kLayoutBothHot)) {
+      cStrStart = mplInfo->bothHotStrTab;
+    } else {
+      cStrStart = mplInfo->runHotStrTab;
+    }
+  } else {
+    cStrStart = mplInfo->coldStrTab;
+  }
+  return cStrStart + cStrIndex;
+}
+
+void LinkerInvoker::DestroyMFileCache() {
+  LinkerMFileCache *lc = static_cast<LinkerMFileCache*>(maple::tls::GetTLS(maple::tls::kSlotMFileCache));
+  if (lc != nullptr) {
+    delete lc;
+    lc = nullptr;
+    maple::tls::StoreTLS(nullptr, maple::tls::kSlotMFileCache);
+  }
+}
+
+// Thread-Unsafe
+bool LinkerInvoker::UpdateMethodSymbolAddress(jmethodID method, uintptr_t newAddr) {
+  MethodMeta *methodInfo = reinterpret_cast<MethodMeta*>(method);
+  MClass *klass = methodInfo->GetDeclaringClass();
+  if (klass == nullptr) {
+    LINKER_LOG(FATAL) << "klass is nullptr" << maple::endl;
+  }
+  // build symbol name
+  std::string symbolName(klass->GetName());
+  symbolName += "|";
+  symbolName += methodInfo->GetName();
+  symbolName += "|";
+  symbolName += methodInfo->GetSignature();
+  // generate unique id
+  MUID symbolId = GetMUID(namemangler::EncodeName(symbolName), true);
+  if (!UpdateMethodSymbolAddressDef(klass, symbolId, newAddr)) {
+    return false;
+  }
+  UpdateNode node(klass, symbolId, 0, newAddr);
+  // traverse all libraries and update external reference table
+  (void)ForEachDoAction(this, &LinkerInvoker::UpdateMethodSymbolAddressUndef, &node);
+  // constructor, private or static method
+  if (methodInfo->IsDirectMethod()) {
+    return true; // all done
+  }
+  uintptr_t oldAddr = reinterpret_cast<uintptr_t>(methodInfo->GetFuncAddress());
+  node.oldAddr = oldAddr;
+#ifdef LINKER_DECOUPLE
+  if (!MRT_CLASS_IS_DECOUPLE(klass)) {
+    // traverse all libraries and update vtable and itable (non-decoupled class)
+    (void)ForEachDoAction(this, &LinkerInvoker::UpdateMethodSymbolAddressDecouple, &node);
+  } else {
+    // update vtable and itable in the perm space (decoupled class)
+    MRT_VisitDecoupleObjects([oldAddr, newAddr](address_t objAddr) {
+      int tag = DecoupleAllocHeader::GetTag(objAddr);
+      if (static_cast<DecoupleTag>(tag) != kITabAggregate && static_cast<DecoupleTag>(tag) != kVTabArray) {
+        return; // next block
+      }
+      size_t blockSize = DecoupleAllocHeader::GetSize(objAddr);
+      size_t size = static_cast<size_t>(blockSize / sizeof(LinkerVTableItem));
+      LinkerVTableItem *pTable = reinterpret_cast<LinkerVTableItem*>(objAddr);
+      if (size != 0 && pTable != nullptr) {
+        for (size_t i = 0; i < size; ++i) {
+          if (static_cast<uint32_t>(pTable[i].index) == oldAddr) { // compare by address
+            LINKER_VLOG(mpllinker) << "Update [perm]" << (pTable + i) << ":" << tag << ":" << oldAddr << maple::endl;
+            pTable[i].index = newAddr;
+          }
+        }
+      }
+    });
+  }
+#else
+  // traverse all libraries and update vtable and itable (non-decoupled class)
+  (void)ForEachDoAction(this, &LinkerInvoker::UpdateMethodSymbolAddressDecouple, &node);
+#endif
+  return true;
+}
+
+jclass LinkerInvoker::GetSuperClass(ClassMetadata **addr) {
+  MClass *klass = reinterpret_cast<MClass*>(__atomic_load_n(addr, __ATOMIC_ACQUIRE));
+  // To check if the super class is not resolved.
+  // If so, we'd try to resolve it once again.
+  LinkerRef ref(klass);
+  if (ref.IsIndex()) {
+    size_t index = ref.GetIndex();
+    bool fromUndef = ref.IsFromUndef();
+    LINKER_LOG(ERROR) << "unresolved super class=" << klass << ", " << index <<
+        ", fromUndef=" << fromUndef << maple::endl;
+    LinkerMFileInfo *mplInfo = SearchAddress(addr);
+    if (mplInfo == nullptr) {
+      LINKER_LOG(FATAL) << "LinkerMFileInfo is null, addr=" << addr << ", " << klass << ", " << index << maple::endl;
+      return 0;
+    }
+    size_t dataUndefSize = mplInfo->GetTblSize(kDataUndef);
+    AddrSlice dataUndefSlice(mplInfo->GetTblBegin<LinkerAddrTableItem*>(kDataUndef), dataUndefSize);
+    size_t dataDefSize = mplInfo->GetTblSize(kDataDef);
+    AddrSlice dataDefSlice(mplInfo->GetTblBegin<LinkerAddrTableItem*>(kDataDef), dataDefSize);
+    if (fromUndef && index < dataUndefSize && !dataUndefSlice.Empty()) {
+      if (mplInfo->IsFlag(kIsLazy)) {
+        LINKER_LOG(FATAL) << "should not resolve lazily, " << fromUndef << ", " << index << ", " << dataUndefSize <<
+            ", " << dataDefSize << " in " << mplInfo->name << maple::endl;
+      } else {
+        klass = reinterpret_cast<MClass*>(dataUndefSlice[index].Address());
+        LINKER_LOG(ERROR) << "(UNDEF), klass=" << klass->GetName() << "addr=" <<
+            dataUndefSlice[index].Address() << " in " << mplInfo->name << maple::endl;
+      }
+    } else if (!fromUndef && index < dataDefSize && !dataDefSlice.Empty()) {
+      if (mplInfo->IsFlag(kIsLazy)) {
+        LINKER_LOG(FATAL) << "(DEF), should not resolve lazily, " << fromUndef << ", " << index << ", " <<
+            dataUndefSize << ", " << dataDefSize << " in " << mplInfo->name << maple::endl;
+      } else {
+        klass = reinterpret_cast<MClass*>(GetDefTableAddress(*mplInfo, dataDefSlice,
+            static_cast<size_t>(index), false));
+        LINKER_LOG(ERROR) << "(DEF), klass=" << klass->GetName() << "addr=" <<
+            dataDefSlice[index].Address() << " in " << mplInfo->name << maple::endl;
+      }
+    } else {
+      LINKER_LOG(FATAL) << "(DEF), not resolved, " << fromUndef << ", " << index << ", " << dataUndefSize << ", " <<
+          dataDefSize << " in " << mplInfo->name << maple::endl;
+    }
+  }
+
+  return reinterpret_cast<jclass>(klass);
+}
+
+// Locate the address for method, which defined in the .so of 'handle'.
+// Also see int dladdr(void *addr, Dl_info *info)
+bool LinkerInvoker::LocateAddress(const void *handle, const void *addr, LinkerLocInfo &info, bool getName) {
+  LinkerMFileInfo *mplInfo = GetLinkerMFileInfo(kFromHandle, handle);
+  if (UNLIKELY(mplInfo != nullptr)) {
+    return LocateAddress(&mplInfo, addr, info, getName);
+  }
+  return false;
+}
+
+void LinkerInvoker::ResolveColdClassSymbol(jclass cls) {
+  MClass *klass = reinterpret_cast<MClass*>(cls);
+  static std::mutex resolveClassSymbolMutex;
+  LinkerMFileInfo *mplInfo = SearchAddress(*klass, kTypeClass);
+  if (mplInfo == nullptr) {
+    LINKER_DLOG(mpllinker) << "not find so for class=" << klass->GetName() << maple::endl;
+    return;
+  }
+  {
+    std::lock_guard<std::mutex> lock(resolveClassSymbolMutex);
+    if (!klass->IsColdClass()) {
+      return;
+    }
+
+#ifdef LINKER_DECOUPLE
+    if (mplInfo->IsFlag(kIsLazy) && mplInfo->GetDecoupleLevel() != 0) {
+      LINKER_LOG(FATAL) << "failed to resolve class = " << klass->GetName() << " for " << mplInfo->name <<
+          ", lazy=" << klass->IsLazyBinding() << ", cold=" << klass->IsColdClass() << ", decouple=" <<
+          klass->IsDecouple() << maple::endl;
+    }
+#endif
+
+    __MRT_Profile_ClassMeta(*klass);
+#ifdef LINKER_DECOUPLE
+    if (!MRT_CLASS_IS_DECOUPLE(klass)) {
+      ResolveVTableSymbolByClass(*mplInfo, klass, true);
+      ResolveVTableSymbolByClass(*mplInfo, klass, false);
+    }
+#else
+  ResolveVTableSymbolByClass(*mplInfo, klass, true);
+  ResolveVTableSymbolByClass(*mplInfo, klass, false);
+#endif
+
+    ResolveSuperClassSymbolByClass(*mplInfo, klass);
+    klass->ReSetFlag(0xF7FF); // 0xF7FF is Cold Flag, Clear Cold Flag
+  }
+}
+
+jclass LinkerInvoker::InvokeClassLoaderLoadClass(jobject clsLoader, const std::string &className) {
+  MObject *classLoader = reinterpret_cast<MObject*>(clsLoader);
+  MethodMeta *method = nullptr;
+  MClass *classLoaderClass = reinterpret_cast<MClass*>(MRT_ReflectGetObjectClass(
+      reinterpret_cast<jobject>(classLoader)));
+
+  // To find the loadClass() method (for the classLoader class) in cached map.
+  method = mplClassLoaderLoadClassMethodMap.Find(classLoaderClass);
+  // If no cached method found
+  if (method == nullptr) {
+    // Find the loadClass() method in classLoader class or its super class.
+    method = classLoaderClass->GetMethod("loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+    if (method == nullptr) {
+      LINKER_LOG(ERROR) << "failed, MethodMeta is null, " << classLoaderClass->GetName() << maple::endl;
+      return nullptr;
+    }
+    // Insert it into cached map
+    mplClassLoaderLoadClassMethodMap.Append(classLoaderClass, method);
+  }
+
+  std::string dotName = nameutils::SlashNameToDot(className);
+  MClass *ret = nullptr;
+  ScopedHandles sHandles;
+  ObjHandle<MObject, false> classLoaderRef(classLoader);
+  ObjHandle<MString> javaClassName(NewStringUTF(dotName.c_str(), static_cast<int>(dotName.length())));
+  // Method shouldn't be nullptr
+  if (!method->NeedsInterp()) { // Method is in compiled code
+    uintptr_t funcAddr = method->GetFuncAddress();
+    ret = RuntimeStub<MClass*>::FastCallCompiledMethod(funcAddr, classLoaderRef(), javaClassName());
+  } else { // Method needs to be interpreted
+    address_t param = javaClassName.AsRaw();
+    ret = reinterpret_cast<MClass*>(MRT_ReflectInvokeMethodAjobject(
+        classLoaderRef.AsJObj(), reinterpret_cast<jmethodID>(method), reinterpret_cast<jvalue*>(&param)));
+  }
+  LINKER_VLOG(lazybinding) << "(" << dotName << "), classLoader=" << classLoaderRef() << ", ret=" << ret <<
+      ", has exception=" << MRT_HasPendingException() << maple::endl;
+  ObjHandle<MObject> ex(MRT_PendingException());
+  if (ex() != 0) {
+    if (VLOG_IS_ON(lazybinding)) {
+      std::string exceptionString;
+      MRT_DumpException(reinterpret_cast<jthrowable>(ex()), &exceptionString);
+      LINKER_VLOG(mpllinker) << "(" << dotName << "), exception=" << exceptionString.c_str() << maple::endl;
+      LINKER_LOG(ERROR) << "(), Pending Exception: " << reinterpret_cast<MObject*>(ex())->GetClass()->GetName() <<
+          ", with classLoader=" << classLoaderRef() << maple::endl;
+    }
+    MRT_ClearPendingException(); // Not throw by MRT_ThrowException_Unw((MObject*)ex);
+    // not dec ret because its class type and off heap
+    return nullptr; // Not found
+  }
+  return reinterpret_cast<jclass>(ret);
+}
+
+void *LinkerInvoker::LookUpSymbolAddress(const MUID &muid) {
+  return Get<Linker>()->LookUpSymbolAddress(muid);
+}
+
+MUID LinkerInvoker::GetMUID(const std::string symbol, bool forSystem) {
+  MUID muid;
+  if (symbol.empty()) {
+    LINKER_LOG(ERROR) << "failed, symbol is null." << maple::endl;
+    return muid; // All fields are 0
+  }
+  GenerateMUID(symbol.c_str(), muid);
+
+  if (forSystem) {
+    muid.SetSystemNameSpace();
+  } else {
+    muid.SetApkNameSpace();
+  }
+  return muid;
+}
+
+bool LinkerInvoker::Add(ObjFile &objFile, jobject classLoader) {
+  std::lock_guard<std::mutex> lock(mLinkLock);
+  // Filter non-maple .so out.
+  //
+  // Maple so includes two type:
+  // Type 1: maple so
+  //         e.g. /system/lib64/libmaplecore-all.so
+  //              /system/lib64/libmapleframework.so
+  // Type 2: apk wrapped maple so
+  //         e.g. /system/priv-app/HwSystemServer/HwSystemServer.apk!/maple/arm64/mapleclasses.so
+  //              /system/app/KeyChain/KeyChain.apk!/maple/arm64/mapleclasses.so
+  const void *handle = objFile.GetHandle();
+  std::string libName = objFile.GetName();
+  LINKER_VLOG(mpllinker) << "old name=" << libName << ", handle=" << handle << ", cl=" << classLoader << maple::endl;
+  std::string::size_type index = libName.rfind('/');
+  if (index == std::string::npos) {
+    libName = maple::fs::kSystemLibPath + libName;
+  }
+  // Eliminate . and ..
+  if (libName.find("/./") != std::string::npos || libName.find("/../") != std::string::npos) {
+    if (libName.length() > PATH_MAX) {
+      LINKER_LOG(ERROR) << "failed: path exceeds limit! " << libName.length() << ", " << libName << maple::endl;
+      return false;
+    }
+    char canonical[PATH_MAX + 1] = { 0 };
+    if (realpath(libName.c_str(), canonical)) {
+      libName = canonical;
+    } else {
+      return false;
+    }
+  }
+
+  MFileInfoSource searchKey[] = { kFromHandle, kFromName };
+  const void *data[] = { handle, libName.c_str() };
+  for (uint32_t i = 0; i < sizeof(searchKey) / sizeof(MFileInfoSource); ++i) {
+    auto resInfo = GetLinkerMFileInfo(searchKey[i], data[i]);
+    if (resInfo != nullptr) {
+      objFile.SetMplInfo(*resInfo);
+      LINKER_VLOG(mpllinker) << "failed:" << libName << ", handle=" << handle << ", cl=" << classLoader << maple::endl;
+      return false;
+    }
+  }
+
+  LINKER_VLOG(mpllinker) << "new name=" << libName << ", handle=" << handle << ", cl=" << classLoader << maple::endl;
+  CreateMplInfo(objFile, classLoader);
+  return true;
+}
+
+void LinkerInvoker::CreateMplInfo(ObjFile &objFile, jobject classLoader) {
+  LinkerMFileInfo *mplInfo;
+#ifdef LINKER_DECOUPLE
+  mplInfo = new (std::nothrow) DecoupleMFileInfo();
+#else
+  mplInfo = new (std::nothrow) LinkerMFileInfo();
+#endif
+  if (mplInfo == nullptr) {
+    LINKER_LOG(FATAL) << "new mplInfo failed" << maple::endl;
+  }
+  mplInfo->name = objFile.GetName();
+  mplInfo->handle = const_cast<void*>(objFile.GetHandle());
+  mplInfo->classLoader = classLoader;
+  mplInfo->SetFlag(kIsMethodDefResolved, false);
+  mplInfo->SetFlag(kIsDataDefResolved, false);
+  mplInfo->SetFlag(kIsVTabResolved, false);
+  mplInfo->SetFlag(kIsITabResolved, false);
+  int32_t pos = -1; // pos -1 means isn't hotfix
+  if (objFile.GetUniqueID() == 0) { // hotfix
+    pos = 0;
+  }
+  if (Get<Linker>()->InitLinkerMFileInfo(*mplInfo, pos)) {
+    objFile.SetLazyBinding();
+  }
+  objFile.SetMplInfo(*mplInfo);
+}
+
+// Resolve all undefined symbols for all the maple .so.
+bool LinkerInvoker::Resolve() {
+  std::lock_guard<std::mutex> lock(mLinkLock);
+  bool ret = true;
+  if (!Get<Linker>()->HandleSymbol()) {
+    ret = false;
+  }
+#ifdef LINKER_DECOUPLE
+  if (!Get<Decouple>()->HandleDecouple()) {
+    ret = false;
+  }
+#endif
+  return ret;
+}
+
+// Resolve all undefined symbols for the single maple .so of 'handle'.
+bool LinkerInvoker::Resolve(LinkerMFileInfo &mplInfo, bool decouple) {
+  std::lock_guard<std::mutex> lock(mLinkLock);
+  bool ret = true;
+  if (!Get<Linker>()->HandleSymbol(mplInfo)) {
+    ret = false;
+  }
+#ifdef LINKER_DECOUPLE
+  if (decouple && !Get<Decouple>()->HandleDecouple(&mplInfo)) {
+    ret = false;
+  }
+#else
+  (void)decouple;
+#endif
+
+  LINKER_VLOG(mpllinker) << "pre clinit " << mplInfo.name << maple::endl;
+  // invoke __MRT_PreinitModuleClasses() to preinit specified classes for current .so file
+  (void)GetSymbolAddr(mplInfo.handle, "MRT_PreinitModuleClasses", true);
+  return ret;
+}
+
+#ifdef LINKER_DECOUPLE
+bool LinkerInvoker::HandleDecouple(std::vector<LinkerMFileInfo*> &mplList) {
+  if (mplList.size() > 0) {
+    std::lock_guard<std::mutex> lock(mLinkLock);
+    return Get<Decouple>()->HandleDecouple();
+  }
+  return true;
+}
+#endif
+
+// Notify all resolving jobs finished.
+void LinkerInvoker::FinishLink(jobject classLoader) {
+  std::lock_guard<std::mutex> lock(mLinkLock);
+  Get<Linker>()->FreeAllCacheTables(reinterpret_cast<MObject*>(classLoader));
+}
+
+// Link all the maple .so library added by Add() before.
+bool LinkerInvoker::Link() {
+  return Resolve();
+}
+
+// Just resolve the single maple file. MUST invoked Add() before.
+bool LinkerInvoker::Link(LinkerMFileInfo &mplInfo, bool decouple) {
+  return Resolve(mplInfo, decouple);
+}
+
+void LinkerInvoker::SetLoadState(LoadStateType state) {
+  maplert::linkerutils::SetLoadState(state);
+#ifdef LINKER_RT_CACHE
+  Get<LinkerCache>()->Reset();
+#endif // LINKER_RT_CACHE
+}
+
+void LinkerInvoker::SetLinkerMFileInfoClassLoader(const ObjFile &objFile, jobject classLoader) {
+  LinkerMFileInfo *mplInfo = nullptr;
+  mplInfo = GetLinkerMFileInfo(kFromHandle, objFile.GetHandle());
+  if (mplInfo == nullptr) {
+    LINKER_LOG(ERROR) << "handle exists, failed to change classLoader, name=" << objFile.GetName() << ", handle=" <<
+        objFile.GetHandle() << ", classLoader=" << classLoader << maple::endl;
+    return;
+  }
+  LinkerMFileInfo *mplInfo2 = GetLinkerMFileInfoByName(objFile.GetName());
+  if (mplInfo2 == nullptr || mplInfo2 != mplInfo) {
+    LINKER_LOG(ERROR) << "name not exists or not equal with handle, " << "failed to change classLoader, name=" <<
+        objFile.GetName() << ", handle=" << objFile.GetHandle() << ", classLoader=" << classLoader << maple::endl;
+    return;
+  }
+  mplInfo->classLoader = classLoader;
+}
+
+void LinkerInvoker::SetClassLoaderParent(jobject classLoader, jobject newParent) {
+  std::lock_guard<std::mutex> lock(mLinkLock);
+  Get<Hotfix>()->SetClassLoaderParent(reinterpret_cast<MObject*>(classLoader), reinterpret_cast<MObject*>(newParent));
+}
+
+bool LinkerInvoker::InsertClassesFront(ObjFile &objFile, jobject classLoader) {
+  if (!Add(objFile, classLoader)) {
+    LINKER_LOG(ERROR) << "InsertClassesFront failed" << maple::endl;
+    return false;
+  }
+  std::lock_guard<std::mutex> lock(mLinkLock);
+  Get<Hotfix>()->InsertClassesFront(reinterpret_cast<MObject*>(classLoader), *(objFile.GetMplInfo()),
+      objFile.GetName());
+  return true;
+}
+bool LinkerInvoker::IsFrontPatchMode(const std::string &path) {
+  std::lock_guard<std::mutex> lock(mLinkLock);
+  return Get<Hotfix>()->IsFrontPatchMode(path);
+}
+void LinkerInvoker::SetPatchPath(std::string &path, int32_t mode) {
+  std::lock_guard<std::mutex> lock(mLinkLock);
+  Get<Hotfix>()->SetPatchPath(path, mode);
+}
+
+void LinkerInvoker::InitArrayCache(uintptr_t pc, uintptr_t addr) {
+  LinkerLocInfo locInfo;
+  LinkerMFileInfo *mplInfo = nullptr;
+  DataRefOffset *srcAddr = reinterpret_cast<DataRefOffset*>(addr);
+  bool isJava = GetJavaTextInfo(reinterpret_cast<uint8_t*>(pc), &mplInfo, locInfo, false);
+  if (!isJava) {
+    MRT_ThrowNullPointerExceptionUnw();
+    return;
+  }
+  DataRefOffset *tabStart = mplInfo->GetTblBegin<DataRefOffset*>(kArrayClassCacheIndex);
+  size_t tableSize = mplInfo->GetTblSize(kArrayClassCacheIndex);
+  if (tabStart > srcAddr ||
+      ((reinterpret_cast<uintptr_t>(tabStart) + tableSize) <= reinterpret_cast<uintptr_t>(srcAddr))) {
+    MRT_ThrowNullPointerExceptionUnw();
+    return;
+  }
+
+  size_t index = srcAddr - tabStart;
+  DataRefOffset *classNameTabStart = mplInfo->GetTblBegin<DataRefOffset*>(kArrayClassCacheNameIndex);
+  DataRefOffset *classNameItem = classNameTabStart + index;
+  char *className = classNameItem->GetDataRef<char*>();
+  uint64_t *md = JavaFrame::GetMethodMetadata(reinterpret_cast<uint32_t*>(locInfo.addr));
+  MClass *callerCls = reinterpret_cast<MClass*>(JavaFrame::GetDeclaringClass(md));
+  MClass *classArrayCache = MClass::GetClassFromDescriptor(callerCls, className);
+  if (classArrayCache == nullptr) {
+    MRT_CheckThrowPendingExceptionUnw();
+    return;
+  }
+  srcAddr->SetRawValue(classArrayCache->AsUintptr());
+}
+#ifdef __cplusplus
+extern "C" {
+#endif
+__attribute__((aligned(4096), visibility("default")))
+uint8_t __BindingProtectRegion__[kBindingStateMax] = { 0 };
+
+static int64_t sigvLazyBindingCountCinfUndef = 0;
+static int64_t sigvLazyBindingCountCinfDef = 0;
+static int64_t sigvLazyBindingCountDataUndef = 0;
+static int64_t sigvLazyBindingCountDataDef = 0;
+static int64_t sigvLazyBindingCountMethodUndef = 0;
+static int64_t sigvLazyBindingCountMethodDef = 0;
+
+static inline int64_t IncSigvLazyBindingCount(int64_t &count) {
+  return __atomic_add_fetch(&count, 1, __ATOMIC_ACQ_REL);
+}
+
+void InitProtectedRegion() {
+  if (mprotect(__BindingProtectRegion__, 4096, PROT_NONE)) { // 4096 is 2^12, region page size is 4k.
+    LINKER_LOG(ERROR) << "protect __BindingProtectRegion__ failed" << maple::endl;
+  }
+  LINKER_VLOG(lazybinding) << "__BindingProtectRegion__=" << static_cast<void*>(__BindingProtectRegion__) <<
+      maple::endl;
+}
+
+bool MRT_RequestLazyBindingForSignal(const SignalInfo &data) {
+  void *pc = data.pc;
+  void *offset = data.offset;
+  delete &data;
+  return MRT_RequestLazyBinding(offset, pc, true);
+}
+
+bool MRT_RequestLazyBindingForInitiative(const void *data) {
+  LinkerMFileInfo *mplInfo = LinkerAPI::As<LinkerInvoker&>().GetLinkerMFileInfoByAddress(data, true);
+  if (mplInfo == nullptr) {
+    LINKER_VLOG(lazybinding) << "data=" << data << ", not found LinkerMFileInfo." << maple::endl;
+    return false;
+  }
+  return MRT_RequestLazyBinding(data, 0, false);
+}
+
+bool MRT_RequestLazyBinding(const void *offset, const void *pc, bool fromSignal) {
+  BindingState state =
+      LinkerAPI::As<LinkerInvoker&>().GetAddrBindingState(*(reinterpret_cast<const LinkerVoidType*>(offset)));
+  LINKER_VLOG(lazybinding) << "*offset=" <<
+      reinterpret_cast<void*>(*(reinterpret_cast<const LinkerVoidType*>(offset))) <<
+      ", __BindingProtectRegion__=" << reinterpret_cast<void*>(__BindingProtectRegion__) << maple::endl;
+  bool res = false;
+  LazyBinding *lazyBinding = LinkerAPI::As<LinkerInvoker&>().Get<LazyBinding>();
+  switch (state) {
+    case kBindingStateCinfUndef:
+      LINKER_VLOG(lazybinding) << "cinf undef SEGV count=" <<
+          IncSigvLazyBindingCount(sigvLazyBindingCountCinfUndef) << maple::endl;
+      res = lazyBinding->HandleSymbol(offset, pc, state, fromSignal);
+      break;
+    case kBindingStateDataUndef:
+      LINKER_VLOG(lazybinding) << "data undef SEGV count=" <<
+          IncSigvLazyBindingCount(sigvLazyBindingCountDataUndef) << maple::endl;
+      res = lazyBinding->HandleSymbol(offset, pc, state, fromSignal);
+      break;
+    case kBindingStateCinfDef:
+      LINKER_VLOG(lazybinding) << "cinf def SEGV count=" <<
+          IncSigvLazyBindingCount(sigvLazyBindingCountCinfDef) << maple::endl;
+      res = lazyBinding->HandleSymbol(offset, pc, state, fromSignal);
+      break;
+    case kBindingStateDataDef:
+      LINKER_VLOG(lazybinding) << "data def SEGV count=" <<
+          IncSigvLazyBindingCount(sigvLazyBindingCountDataDef) << maple::endl;
+      res = lazyBinding->HandleSymbol(offset, pc, state, fromSignal);
+      break;
+    case kBindingStateMethodUndef:
+      LINKER_VLOG(lazybinding) << "method undef SEGV count=" <<
+          IncSigvLazyBindingCount(sigvLazyBindingCountMethodUndef) << maple::endl;
+      res = lazyBinding->HandleSymbol(offset, pc, state, fromSignal);
+      break;
+    case kBindingStateMethodDef:
+      LINKER_VLOG(lazybinding) << "method def SEGV count=" <<
+          IncSigvLazyBindingCount(sigvLazyBindingCountMethodDef) << maple::endl;
+      res = lazyBinding->HandleSymbol(offset, pc, state, fromSignal);
+      break;
+    default:
+      // Handle exception here...
+      if (VLOG_IS_ON(lazybinding)) {
+        LINKER_LOG(ERROR) << "wrong state " << static_cast<int>(state) << "! offset=" << offset << ", pc=" << pc <<
+            ", __BindingProtectRegion__=" << reinterpret_cast<void*>(__BindingProtectRegion__) << maple::endl;
+        LinkerAPI::As<LinkerInvoker&>().DumpStackInfoInLog();
+      }
+      break;
+  }
+  return res;
+}
+
+int32_t MCC_FixOffsetTableVtable(uint32_t offsetVal, char *offsetEntry) {
+#ifdef LINKER_DECOUPLE
+  Decouple *decouple = LinkerAPI::As<LinkerInvoker&>().Get<Decouple>();
+  // highest bit is fix flag
+  const uint32_t kMplOffsetFixFlag = 0x80000000;
+  (void)offsetVal; // placeholder para
+  int32_t offsetValue = *(reinterpret_cast<int32_t*>(offsetEntry));
+  if (static_cast<uint32_t>(offsetValue) & kMplOffsetFixFlag) {
+    uint32_t offsetIndex = (static_cast<uint32_t>(offsetValue) & (~kMplOffsetFixFlag));
+    LinkerOffsetValItem tmpItem;
+    offsetEntry -= reinterpret_cast<char*>(&tmpItem.offset) - reinterpret_cast<char*>(&tmpItem);
+    LinkerOffsetValItem *offsetTable = reinterpret_cast<LinkerOffsetValItem*>(offsetEntry) - offsetIndex;
+    LinkerOffsetKeyTableInfo *keyTableInfo = reinterpret_cast<LinkerOffsetKeyTableInfo*>(offsetTable) - 1;
+    if (offsetIndex >= keyTableInfo->vtableOffsetTableSize) {
+      LINKER_LOG(FATAL) << "offsetIndex = " << offsetIndex << maple::endl;
+    }
+    return decouple->FixOffsetTableLazily(reinterpret_cast<char*>(offsetTable), offsetIndex);
+  } else {
+    return offsetValue;
+  }
+#else
+  (void)offsetVal;
+  (void)offsetEntry;
+  return -1;
+#endif
+}
+
+int32_t MCC_FixOffsetTableField(uint32_t offsetVal, char *offsetEntry) {
+#ifdef LINKER_DECOUPLE
+  Decouple *decouple = LinkerAPI::As<LinkerInvoker&>().Get<Decouple>();
+  // highest bit is fix flag
+  const uint32_t kMplOffsetFixFlag = 0x80000000;
+  (void)offsetVal; // placeholder para
+  uint32_t offsetValue = *(reinterpret_cast<uint32_t*>(offsetEntry));
+  if (offsetValue & kMplOffsetFixFlag) {
+    uint32_t offsetIndex = (offsetValue & (~kMplOffsetFixFlag));
+    LinkerOffsetValItem tmpItem;
+    offsetEntry -= reinterpret_cast<char*>(&tmpItem.offset) - reinterpret_cast<char*>(&tmpItem);
+    LinkerOffsetValItem *offsetTable = reinterpret_cast<LinkerOffsetValItem*>(offsetEntry) - offsetIndex;
+    LinkerOffsetKeyTableInfo *keyTableInfo = reinterpret_cast<LinkerOffsetKeyTableInfo*>(offsetTable) - 1;
+    if (offsetIndex < keyTableInfo->vtableOffsetTableSize) {
+      LINKER_LOG(FATAL) << "offsetIndex = " << offsetIndex << maple::endl;
+    }
+    return decouple->FixOffsetTableLazily(reinterpret_cast<char*>(offsetTable), offsetIndex);
+  } else {
+    return static_cast<int32_t>(offsetValue);
+  }
+#else
+  (void)offsetVal;
+  (void)offsetEntry;
+  return -1;
+#endif
+}
+
+void MRT_FixOffsetTableLazily(LinkerOffsetValItemLazyLoad &offsetEntry) {
+#ifdef LINKER_DECOUPLE
+  Decouple *decouple = LinkerAPI::As<LinkerInvoker&>().Get<Decouple>();
+  // highest bit is fix flag
+  const uint32_t kMplOffsetFixFlag = 0x80000000;
+  uint32_t offsetValue = static_cast<uint32_t>(offsetEntry.offset);
+  if (offsetValue & kMplOffsetFixFlag) {
+    uint32_t offsetIndex = (offsetValue & (~kMplOffsetFixFlag));
+    (void)decouple->FixOffsetTableLazily(reinterpret_cast<char*>(&offsetEntry - offsetIndex), offsetIndex);
+  }
+#else
+  (void)offsetEntry;
+#endif
+}
+
+void MRT_FixStaticAddrTable(LinkerStaticAddrItem &addrTableItem) {
+#ifdef LINKER_DECOUPLE
+  Decouple *decouple = LinkerAPI::As<LinkerInvoker&>().Get<Decouple>();
+  MplStaticDecouple &staticResolver = decouple->GetStaticResolver();
+  uint32_t signalIndex = static_cast<uint32_t>(addrTableItem.index);
+  MplStaticAddrTabHead *staticAddrTabHead = reinterpret_cast<MplStaticAddrTabHead*>(&addrTableItem - signalIndex) - 1;
+  LinkerMFileInfo *mplInfo = staticResolver.GetLinkerMFileInfoFromHead(*staticAddrTabHead);
+  LinkerStaticAddrItem *addrTableItems = reinterpret_cast<LinkerStaticAddrItem*>(&addrTableItem - signalIndex);
+  LinkerStaticDecoupleClass *keyTableItems = mplInfo->GetTblBegin<LinkerStaticDecoupleClass*>(kStaticDecoupleKey);
+  size_t keyTableSize = mplInfo->GetTblSize(kStaticDecoupleKey);
+  if (UNLIKELY(addrTableItems == nullptr || keyTableItems == nullptr || keyTableSize == 0)) {
+    LINKER_LOG(FATAL) << "Fail to get static address table from " << mplInfo->name << maple::endl;
+    return;
+  }
+  bool resolved = staticResolver.FixClassClinit(*keyTableItems, *addrTableItems, signalIndex, false);
+  LINKER_VLOG(staticdcp) << "exit. class initialized=" << resolved << maple::endl;
+#else
+  (void)addrTableItem;
+#endif
+}
+
+bool MRT_IsLazyBindingState(const uint8_t *address) {
+  if (address >= __BindingProtectRegion__ && address < &__BindingProtectRegion__[kBindingStateMax]) {
+    return true;
+  }
+  return false;
+}
+
+void MRT_FixStaticAddrTableLazily(LinkerStaticAddrItem &addrTableItem) {
+#ifdef LINKER_DECOUPLE
+  Decouple *decouple = LinkerAPI::As<LinkerInvoker&>().Get<Decouple>();
+  MplStaticDecouple &staticResolver = decouple->GetStaticResolver();
+  LINKER_VLOG(staticdcp) << "entered, addrTableItem=" << std::hex << &addrTableItem << maple::endl;
+  uint32_t signalIndex = static_cast<uint32_t>(addrTableItem.index);
+  MplStaticAddrTabHead *staticAddrTabHead = reinterpret_cast<MplStaticAddrTabHead*>(&addrTableItem - signalIndex) - 1;
+  LinkerMFileInfo *mplInfo = staticResolver.GetLinkerMFileInfoFromHead(*staticAddrTabHead);
+  LinkerStaticAddrItem *addrTableItems = reinterpret_cast<LinkerStaticAddrItem*>(&addrTableItem - signalIndex);
+  LinkerStaticDecoupleClass *keyTableItems = mplInfo->GetTblBegin<LinkerStaticDecoupleClass*>(kStaticDecoupleKey);
+  size_t keyTableSize = mplInfo->GetTblSize(kStaticDecoupleKey);
+  if (UNLIKELY(addrTableItems == nullptr || keyTableItems == nullptr || keyTableSize == 0)) {
+    LINKER_LOG(FATAL) << "Fail to get static address table from " << mplInfo->name << " keyTableSize=" <<
+        keyTableSize << " addrTableItems=" << std::hex << addrTableItems << " keyTableItems=" << keyTableItems <<
+        maple::endl;
+    return;
+  }
+
+  int32_t index = staticResolver.GetClassInfoIndex(*addrTableItems, signalIndex);
+  ClassMetadata *clsCallee = staticResolver.GetClassMetadata(mplInfo, keyTableItems[index].callee);
+  if (UNLIKELY(clsCallee == nullptr)) {
+    LINKER_LOG(FATAL) << "exit: null pointer to current class" << maple::endl;
+    return;
+  }
+  bool isResolved = true;
+  if (static_cast<int>(signalIndex) <= (index + static_cast<int>(keyTableItems[index].fieldsNum))) {
+    isResolved = staticResolver.SetStaticFieldAddr(mplInfo, *clsCallee,
+        keyTableItems[signalIndex], addrTableItems[signalIndex]);
+  } else {
+    isResolved = staticResolver.SetStaticMethodAddr(mplInfo, *clsCallee,
+        keyTableItems[signalIndex], addrTableItems[signalIndex]);
+  }
+  bool initialized = staticResolver.FixClassClinit(*keyTableItems, *addrTableItems, signalIndex, true);
+  LINKER_VLOG(staticdcp) << "exit. isResolved = " << isResolved << " clinit = " << initialized << maple::endl;
+#else
+  (void)addrTableItem;
+#endif
+}
+
+// init array class cache reference by compiler code
+bool MRT_RequestInitArrayCache(SignalInfo *info) {
+  uintptr_t pc = reinterpret_cast<uintptr_t>(info->pc);
+  // array cache addr
+  uintptr_t addr = reinterpret_cast<uintptr_t>(info->offset);
+  delete info;
+  LinkerAPI::As<LinkerInvoker&>().InitArrayCache(pc, addr);
+  return true;
+}
+#ifdef __cplusplus
+}
+#endif
+} // namespace maple
+
diff --git a/src/mrt/compiler-rt/src/linker/linker_cache.cpp b/src/mrt/compiler-rt/src/linker/linker_cache.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8056ea256fffbadff2338e802fc5d011a2cf30f6
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_cache.cpp
@@ -0,0 +1,1289 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker_cache.h"
+
+#include <fstream>
+#include <thread>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+#include <fcntl.h>
+
+#include "mrt_object.h"
+#include "linker/linker_model.h"
+#include "linker/linker_inline.h"
+#include "mpl_cache_first_file.h"
+namespace maplert {
+#ifdef LINKER_RT_CACHE
+using namespace linkerutils;
+const uint64_t kCacheMagicNumber = 0xcac7e5272799710bull;
+namespace {
+  constexpr char kLinkerLazyInvalidSoName[] = "LAZY";
+  constexpr char kLinkerInvalidName[] = "X";
+}
+static constexpr struct LinkerCache::CacheInfo methodUndef = {
+    LinkerCache::kMethodUndefIndex,
+    &LinkerInvoker::LookUpMethodSymbolAddress,
+    kIsMethodUndefHasNotResolved,
+    kIsMethodUndefCacheValid,
+    true,
+    true
+};
+static constexpr struct LinkerCache::CacheInfo dataUndef = {
+    LinkerCache::kDataUndefIndex,
+    &LinkerInvoker::LookUpDataSymbolAddress,
+    kIsDataUndefHasNotResolved,
+    kIsDataUndefCacheValid,
+    false,
+    true
+};
+static constexpr struct LinkerCache::CacheInfo methodDef = {
+    LinkerCache::kMethodDefIndex,
+    &LinkerInvoker::LookUpMethodSymbolAddress,
+    kIsMethodDefHasNotResolved,
+    kIsMethodCacheValid,
+    true,
+    false
+};
+static constexpr struct LinkerCache::CacheInfo dataDef = {
+    LinkerCache::kDataDefIndex,
+    &LinkerInvoker::LookUpDataSymbolAddress,
+    kIsDataDefHasNotResolved,
+    kIsDataCacheValid,
+    false,
+    false
+};
+
+const MUID LinkerCache::kInvalidHash = {{{ 0 }}};
+FeatureName LinkerCache::featureName = kFLinkerCache;
+void LinkerCache::SetPath(const std::string &path) {
+  LINKER_VLOG(mpllinker) << pCachePath << " --> " << path << maple::endl;
+  pCachePath = path;
+}
+
+LinkerMFileInfo *LinkerCache::FindLinkerMFileInfo(uint16_t soid, const MFileCacheInf &inf, MplInfoStore &store) {
+  if (soid >= store.size()) {
+    store.resize(soid + 1);
+  }
+  auto res = store[soid];
+  if (res == nullptr) {
+    res = pInvoker.GetLinkerMFileInfoByName(inf.GetName(soid));
+    store[soid] = res;
+  }
+  return res;
+}
+
+bool LinkerCache::GetPath(LinkerMFileInfo &mplInfo, std::string &path,
+    LinkerCacheType cacheType, LoadStateType loadState) {
+  if (GetFastPath(mplInfo, cacheType, path)) {
+    return true;
+  }
+  if (loadState == kLoadStateBoot || loadState == kLoadStateSS) {
+    path = pCachePath; // Use preset value from SetCachePath().
+    if (path.empty()) {
+      if (loadState == kLoadStateBoot) {
+        path = kLinkerRootCachePath;
+      } else { // If loadState is equal to kLoadStateSS
+        path = kLinkerSystemCachePath;
+      }
+    }
+  } else if (loadState == kLoadStateApk) {
+    path = GetAppInfo();
+  } else {
+    LINKER_LOG(ERROR) << "(" << static_cast<uint32_t>(cacheType) << "), failed to prepare folder, loadState=" <<
+        loadState << maple::endl;
+    return false;
+  }
+  path.append("/").append(kLinkerCacheFold).append("/");
+  if (!PrepareFolder(path)) {
+    LINKER_LOG(ERROR) << "(" << static_cast<uint32_t>(cacheType) << "), failed to prepare folder:" << path <<
+        maple::endl;
+    return false;
+  }
+  // Use the full path in case of the same so name.
+  // e.g.
+  //      /system/lib64/libmaplecore-all.so
+  //  ==> _system_lib64_libmaplecore-all.so
+  //
+  //      /system/app/KeyChain/KeyChain.apk!/maple/arm64/mapleclasses.so
+  //  ==> _system_app_KeyChain_KeyChain.apk!_maple_arm64_mapleclasses.so
+  std::string name = mplInfo.name;
+  std::replace(name.begin(), name.end(), '/', '_');
+  path.append(name);
+  FinishPath(mplInfo, cacheType, path);
+  LINKER_VLOG(mpllinker) << "(" << static_cast<uint32_t>(cacheType) << "), loadState=" << loadState << ", " << path <<
+      maple::endl;
+  return true;
+}
+
+bool LinkerCache::GetFastPath(LinkerMFileInfo &mplInfo, LinkerCacheType cacheType, std::string &path) {
+  if (cacheType == LinkerCacheType::kLinkerCacheLazy && mplInfo.rep.lazyCachePath.length() != 0) {
+    path = mplInfo.rep.lazyCachePath;
+    return true;
+  } else if (cacheType == LinkerCacheType::kLinkerCacheMethodUndef && mplInfo.rep.methodUndefCachePath.length() != 0) {
+    path = mplInfo.rep.methodUndefCachePath;
+    return true;
+  } else if (cacheType == LinkerCacheType::kLinkerCacheMethodDef && mplInfo.rep.methodDefCachePath.length() != 0) {
+    path = mplInfo.rep.methodDefCachePath;
+    return true;
+  } else if (cacheType == LinkerCacheType::kLinkerCacheDataUndef && mplInfo.rep.dataUndefCachePath.length() != 0) {
+    path = mplInfo.rep.dataUndefCachePath;
+    return true;
+  } else if (cacheType == LinkerCacheType::kLinkerCacheDataDef && mplInfo.rep.dataDefCachePath.length() != 0) {
+    path = mplInfo.rep.dataDefCachePath;
+    return true;
+  }
+  return false;
+}
+
+void LinkerCache::FinishPath(LinkerMFileInfo &mplInfo, LinkerCacheType cacheType, std::string &path) {
+  if (cacheType == LinkerCacheType::kLinkerCacheLazy) {
+    path += GetLinkerCacheTypeStr(cacheType);
+    mplInfo.rep.lazyCachePath = path;
+  } else if (cacheType == LinkerCacheType::kLinkerCacheMethodUndef) {
+    path += GetLinkerCacheTypeStr(cacheType);
+    mplInfo.rep.methodUndefCachePath = path;
+  } else if (cacheType == LinkerCacheType::kLinkerCacheMethodDef) {
+    path += GetLinkerCacheTypeStr(cacheType);
+    mplInfo.rep.methodDefCachePath = path;
+  } else if (cacheType == LinkerCacheType::kLinkerCacheDataUndef) {
+    path += GetLinkerCacheTypeStr(cacheType);
+    mplInfo.rep.dataUndefCachePath = path;
+  } else if (cacheType == LinkerCacheType::kLinkerCacheDataDef) {
+    path += GetLinkerCacheTypeStr(cacheType);
+    mplInfo.rep.dataDefCachePath = path;
+  } else {
+    path += GetLinkerCacheTypeStr(cacheType);
+  }
+}
+
+void LinkerCache::Reset() {
+  pCachePath.clear();
+}
+
+inline LinkerCacheType LinkerCache::GetLinkerCacheType(CacheIndex cacheIndex) {
+  switch (cacheIndex) {
+    case kMethodUndefIndex:
+      return LinkerCacheType::kLinkerCacheMethodUndef;
+    case kMethodDefIndex:
+      return LinkerCacheType::kLinkerCacheMethodDef;
+    case kDataUndefIndex:
+      return LinkerCacheType::kLinkerCacheDataUndef;
+    case kDataDefIndex:
+      return LinkerCacheType::kLinkerCacheDataDef;
+  };
+}
+
+// Load the table from FS cache if exist.
+// Return true if the cache exists and is valid, or return false.
+bool LinkerCache::LoadTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex) {
+  if (LINKER_INSTALL_STATE) {
+    return false;
+  }
+  LinkerCacheType cacheType = GetLinkerCacheType(cacheIndex);
+  std::string path;
+  if (!GetPath(mplInfo, path, cacheType, GetLoadState())) {
+    LINKER_DLOG(mpllinker) << "(" << cacheIndex << "), failed to prepare folder for " <<
+        path << ", " << errno << maple::endl;
+    return false;
+  }
+  if (LoadTable(mplInfo, path, cacheIndex)) {
+    LINKER_VLOG(mpllinker) << "(" << cacheIndex << "), runtime load cache:" << path << " OK" << maple::endl;
+    return true;
+  }
+  LINKER_DLOG(mpllinker) << "load runtime path:" << path << " fail" << maple::endl;
+  // try to load cache generated in HOTA/Install process
+  if (LoadInstallCache(mplInfo, cacheType)) {
+    LINKER_VLOG(mpllinker) << "(" << cacheIndex << "), install load cache:" << path << " OK" << maple::endl;
+    return true;
+  }
+  return false;
+}
+
+bool LinkerCache::LoadTable(LinkerMFileInfo &mplInfo, const std::string &path, CacheIndex cacheIndex) {
+  bool res = true;
+  BufferSlice buf;
+  size_t cacheSize = 0;
+  void *content = LoadCache(path, cacheSize);
+  if (content == nullptr) {
+    res = false;
+    goto END;
+  }
+  buf = BufferSlice(reinterpret_cast<char*>(content), cacheSize);
+  // update before clhash and clsocnt.
+  UpdateProperty(mplInfo, cacheIndex);
+  if (!LoadFooter(buf, cacheIndex)) {
+    res = false;
+    goto END;
+  }
+  if (!LoadMeta(mplInfo, buf, cacheIndex)) {
+    res = false;
+    goto END;
+  }
+  LoadData(mplInfo, buf, cacheIndex);
+  if (buf.Size() != 0) {
+    res = false;
+    LINKER_LOG(ERROR) << "invalid format, still have cache dat to resolve:" << mplInfo.name  << maple::endl;
+  }
+END:
+  if (content != MAP_FAILED) {
+    munmap(content, cacheSize);
+  }
+  if (!res) {
+    LINKER_VLOG(mpllinker) << "(" << cacheIndex << "), to remove " << path << maple::endl;
+    RemoveTable(mplInfo, cacheIndex); // In case of more exceptions, from here to re-save the cache.
+  }
+  return res;
+}
+
+void *LinkerCache::LoadCache(const std::string &path, size_t &cacheSize) {
+  struct stat sb;
+  int fd = open(path.c_str(), O_RDONLY);
+  if (fd < 0) {
+    if (errno != ENOENT && errno != EACCES) {
+      LINKER_LOG(ERROR) << "failed to open " << path << ", " << errno << maple::endl;
+    } else {
+      if (errno == EACCES) {
+        LINKER_LOG(ERROR) << "EACCES, failed to open " << path << ", " << errno << maple::endl;
+      }
+    }
+    return nullptr;
+  }
+  // shared lock for read
+  if (flock(fd, LOCK_SH) < 0) {
+    LINKER_LOG(ERROR) << "failed to flock(" << errno << ") " << path << maple::endl;
+    close(fd);
+    return nullptr;
+  }
+  if (fstat(fd, &sb) < 0) {
+    LINKER_LOG(ERROR) << "to obtain file size fail(" << errno << ") "<< path << maple::endl;
+    close(fd);
+    return nullptr;
+  }
+  cacheSize = sb.st_size;
+  // {head:|MinVersion(int32)|MaxVersion(int32)|ValidityCode(MUID)|clhash(MUID)|clSoCount(uint16)|},
+  // {data:|mapSize(uint32)|}, {footer:|contentLen(uint32)|cacheType(uint8)|CacheValidity(MUID)|magicNumber(uint64)|}
+  const int minSize = sizeof(int32_t) * 2 + sizeof(MUID) * 2 + sizeof(uint16_t) + sizeof(uint32_t) +
+      sizeof(uint32_t) + sizeof(uint8_t) + sizeof(MUID) + sizeof(uint64_t);
+  if (cacheSize < minSize) {
+    LINKER_LOG(INFO) << "failed, read no data for " << path << ", " << errno << maple::endl;
+    close(fd);
+    return nullptr;
+  }
+  void *content = mmap(nullptr, cacheSize, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0);
+  if (content == MAP_FAILED) {
+    LINKER_LOG(ERROR) << "failed to mmap " << cacheSize << " (" << errno << ")for " << path << maple::endl;
+    close(fd);
+    return nullptr;
+  }
+  if (madvise(content, cacheSize, MADV_WILLNEED | MADV_SEQUENTIAL) < 0) {
+    LINKER_LOG(ERROR) << "madvise failed(" << errno << ") " << path << maple::endl;
+  }
+  close(fd);
+  return content;
+}
+
+bool LinkerCache::LoadFooter(BufferSlice &buf, CacheIndex cacheIndex) {
+  size_t size = buf.Size();
+  // 1. checking magic number.
+  size -= sizeof(kCacheMagicNumber); // 8 bytes
+  uint64_t magicNum = *(reinterpret_cast<uint64_t*>(&buf[size]));
+  if (magicNum != kCacheMagicNumber) {
+    LINKER_LOG(ERROR) << "magic number checking failed," << " wrong number:" << std::hex << magicNum << maple::endl;
+    return false;
+  }
+  // 2. checking the validity.
+  size -= sizeof(MUID);
+  MUID lastCacheValidity = *(reinterpret_cast<MUID*>(&buf[size]));
+  // Generate the digest for validity, excluding the length of content.
+  MUID rtCacheValidity;
+  GenerateMUID(buf.Data(), size, rtCacheValidity);
+  if (lastCacheValidity != rtCacheValidity) {
+    LINKER_LOG(ERROR) << "cache validity checking failed," << rtCacheValidity.ToStr() <<
+        " vs. " << lastCacheValidity.ToStr() << maple::endl;
+    return -1;
+  }
+  // 3. Read the cache type
+  size -= sizeof(uint8_t); // 1 bytes
+  uint8_t type = *(reinterpret_cast<uint8_t*>(&buf[size]));
+  uint8_t wantedType = static_cast<uint8_t>(cacheIndex);
+  if (type != wantedType) {
+    LINKER_LOG(ERROR) << "cache index type failed," << wantedType << " vs. " << type << maple::endl;
+    return false;
+  }
+  // 4. Read the length of content.
+  size -= sizeof(uint32_t); // 4 bytes
+  uint32_t contentSize = *(reinterpret_cast<uint32_t*>(&buf[size]));
+  if (contentSize != size) {
+    LINKER_LOG(ERROR) << "cache length checking failed," << contentSize <<
+        " vs. " << size << maple::endl;
+    return false;
+  }
+  buf = Slice<char>(buf.Data(), size);
+  return true;
+}
+
+bool LinkerCache::LoadMeta(LinkerMFileInfo &mplInfo, BufferSlice &buf, CacheIndex cacheIndex) {
+  // 1. Read maximum version.
+  int32_t maxVersion = *(reinterpret_cast<int32_t*>(buf.Data()));
+  if (maxVersion != 0 && maxVersion != GetMaxVersion()) {
+    LINKER_LOG(ERROR) << "failed to check max version," << maxVersion <<
+        " vs. " << GetMaxVersion() << maple::endl;
+    return false;
+  }
+  buf += sizeof(maxVersion); // 4 bytes
+  // 2. Read minimum version.
+  int32_t minVersion = *(reinterpret_cast<int32_t*>(buf.Data()));
+  if (minVersion != 0 && minVersion != GetMinVersion()) {
+    LINKER_LOG(ERROR) << "failed to check min version," << minVersion << " vs. " <<
+        GetMinVersion() << maple::endl;
+    return false;
+  }
+  buf += sizeof(minVersion); // 4 bytes
+  // 3. Read the hash from cache file, comparing with .so.
+  MUID lastSoValidity = *(reinterpret_cast<MUID*>(buf.Data()));
+  MUID rtSoValidity = pInvoker.GetValidityCode(mplInfo);
+  if (lastSoValidity != rtSoValidity) {
+    LINKER_LOG(ERROR) << "so validity checking failed," << rtSoValidity.ToStr() << " vs. " <<
+        lastSoValidity.ToStr() << " in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  buf += sizeof(lastSoValidity); // 8 bytes
+  // 4. Read the clhash from cache file
+  MUID lastClValidity = *(reinterpret_cast<MUID*>(buf.Data()));
+  MUID rtClValidity = pClHash[cacheIndex];
+  if (lastClValidity != rtClValidity) {
+    LINKER_LOG(ERROR) << "classloader validity checking failed, " << rtClValidity.ToStr() <<
+        " vs. " << lastClValidity.ToStr() << " in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  buf += sizeof(lastClValidity); // 8 bytes
+  // 5. Read the classloader .so count.
+  uint16_t lastClSoCnt = *(reinterpret_cast<uint16_t*>(buf.Data()));
+  uint16_t rtClSoCnt = pClSoCnt[cacheIndex];
+  if (lastClSoCnt != rtClSoCnt) {
+    LINKER_LOG(ERROR) << "classloader so count checking failed, " << rtClSoCnt << " vs. "
+        << lastClSoCnt << " in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  buf += sizeof(lastClSoCnt); // 2 bytes
+  return true;
+}
+
+bool LinkerCache::LoadData(LinkerMFileInfo &mplInfo, BufferSlice &buf, CacheIndex cacheIndex) {
+  // 1. Read the map size
+  uint32_t mapSize = *(reinterpret_cast<uint32_t*>(buf.Data()));
+  buf += sizeof(mapSize); // 4 bytes
+  if (mapSize == 0) {
+    return true;
+  }
+  // 2. Read So Name List Info.
+  LoadNameList(buf, cacheIndex);
+  // 3. Read Bucket for resolving table.
+  uint32_t mapBucketCnt = *(reinterpret_cast<uint32_t*>(buf.Data()));
+  buf += sizeof(mapBucketCnt); // 4 bytes
+  auto &cacheMap = *GetCacheMap(mplInfo, cacheIndex);
+  cacheMap.rehash(mapBucketCnt);
+  for (uint32_t i = 0; i < mapSize; ++i) {
+    // 4. Read the undef index.
+    uint32_t undefIndex = *(reinterpret_cast<uint32_t*>(buf.Data()));
+    buf += sizeof(undefIndex);
+    // 5. Read the addr index.
+    uint32_t addrIndex = *(reinterpret_cast<uint32_t*>(buf.Data()));
+    buf += sizeof(addrIndex);
+    // 6. Read the soid
+    uint16_t soid = *(reinterpret_cast<uint16_t*>(buf.Data()));
+    buf += sizeof(soid);
+    LinkerCacheTableItem pItem(addrIndex, soid);
+    cacheMap.insert(std::make_pair(undefIndex, pItem));
+  }
+  return true;
+}
+
+bool LinkerCache::LoadNameList(BufferSlice &buf, CacheIndex cacheIndex) {
+  auto &inf = pMplCacheInf[cacheIndex];
+  // 6. listsize
+  uint32_t listSize = *reinterpret_cast<uint32_t*>(buf.Data());
+  buf += sizeof(listSize);
+  for (uint32_t i = 0; i < listSize; ++i) {
+    // 7. name size
+    uint32_t nameSize = *reinterpret_cast<uint32_t*>(buf.Data());
+    buf += sizeof(nameSize);
+    // 8. name content
+    const char *name = buf.Data();
+    buf += nameSize;
+    // 9. so hash.
+    const MUID *muid = reinterpret_cast<const MUID*>(buf.Data());
+    buf += sizeof(*muid);
+    inf.Append(std::string(name, nameSize), *muid);
+  }
+  return true;
+}
+
+MplCacheMapT *LinkerCache::GetCacheMap(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex) {
+  switch (cacheIndex) {
+    case kMethodUndefIndex:
+      return &(mplInfo.rep.methodUndefCacheMap);
+    case kMethodDefIndex:
+      return &(mplInfo.rep.methodDefCacheMap);
+    case kDataUndefIndex:
+      return &(mplInfo.rep.dataUndefCacheMap);
+    case kDataDefIndex:
+      return &(mplInfo.rep.dataDefCacheMap);
+  };
+}
+
+// Save the table into FS cache.
+bool LinkerCache::SaveTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex) {
+  bool res = true;
+  std::string path;
+  std::string buffer;
+  int fd = GetCacheFd(mplInfo, path, cacheIndex);
+  if (fd < 0) {
+    res = false;
+    goto END;
+  }
+  // exclusive lock for write
+  if (flock(fd, LOCK_EX) < 0) {
+    LINKER_LOG(ERROR) << "failed to flock(" << errno << ") " << path << maple::endl;
+    res = false;
+    goto END;
+  }
+  if (ftruncate(fd, 0) < 0) {
+    LINKER_LOG(ERROR) << "failed to ftruncate zero(" << errno << ") path:" << path << maple::endl;
+    res = false;
+    goto END;
+  }
+  UpdateProperty(mplInfo, cacheIndex);
+  SaveMeta(mplInfo, buffer, cacheIndex);
+  SaveData(mplInfo, buffer, cacheIndex);
+  if (!WriteTable(fd, buffer, cacheIndex)) {
+    res = false;
+  }
+END:
+  if (!res) {
+    RemoveTable(mplInfo, cacheIndex); // In case of more exceptions, from here to re-save the cache.
+  }
+  return CleanSavingTable(mplInfo, fd, res);
+}
+
+int LinkerCache::GetCacheFd(LinkerMFileInfo &mplInfo, std::string &path, CacheIndex cacheIndex) {
+  int fd = -1;
+  LinkerCacheType cacheType = GetLinkerCacheType(cacheIndex);
+  if (LINKER_INSTALL_STATE) {
+    if (mplInfo.IsFlag(kIsLazy)) {
+      LINKER_LOG(WARNING) << "(" << cacheIndex << "), not save install cache for lazy binding." << maple::endl;
+      return -1;
+    }
+    fd = maple::MplCacheFirstFile::GetFd(mplInfo.name, static_cast<int32_t>(cacheType));
+    if (fd < 0) {
+      LINKER_VLOG(mpllinker) << "(" << cacheIndex << ") get invalid fd when install" << maple::endl;
+      return -1;
+    }
+  } else {
+    if (!GetPath(mplInfo, path, cacheType, GetLoadState())) {
+      LINKER_LOG(ERROR) << "(" << cacheIndex << "), failed to prepare folder for " <<
+          path << ", " << errno << maple::endl;
+      return -1;
+    }
+    fd = open(path.c_str(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
+    if (fd == -1) {
+      if (errno != EACCES) {
+        LINKER_LOG(ERROR) << "(" << cacheIndex << "), failed to open " <<
+            path << ", " << errno << maple::endl;
+      } else {
+        LINKER_LOG(ERROR) << "(" << cacheIndex << "), EACCES, failed to open " <<
+            path << ", " << errno << maple::endl;
+      }
+      return -1;
+    }
+  }
+  return fd;
+}
+
+void LinkerCache::SaveMeta(LinkerMFileInfo &mplInfo, std::string &buffer, CacheIndex cacheIndex) {
+  // Prepare all the data in buffer firstly.
+  // 1. Write maximum version.
+  int32_t maxVersion = GetMaxVersion();
+  buffer.append(reinterpret_cast<char*>(&maxVersion), sizeof(maxVersion));
+  // 2. Write minimum version.
+  int32_t minVersion = GetMinVersion();
+  buffer.append(reinterpret_cast<char*>(&minVersion), sizeof(minVersion));
+  // 3. Write the hash from .so.
+  MUID soValidity = pInvoker.GetValidityCode(mplInfo);
+  buffer.append(reinterpret_cast<char*>(&soValidity), sizeof(soValidity));
+  // 4. Write the clhash from classloader *.so
+  buffer.append(reinterpret_cast<char*>(&pClHash[cacheIndex]), sizeof(pClHash[cacheIndex]));
+  // 5. Write the classloader .so count.
+  buffer.append(reinterpret_cast<char*>(&pClSoCnt[cacheIndex]), sizeof(pClSoCnt[cacheIndex]));
+}
+
+bool LinkerCache::SaveNameList(std::string &buffer, CacheIndex cacheIndex) {
+  auto &inf = pMplCacheInf[cacheIndex];
+  const auto &nameList = inf.NameList();
+  // 1. Write the listsize
+  uint32_t listSize = static_cast<uint32_t>(nameList.size());
+  buffer.append(reinterpret_cast<char*>(&listSize), sizeof(listSize));
+  for (const auto &item : nameList) {
+    // 2. Write the name size
+    const std::string &name = item.first;
+    uint32_t size = static_cast<uint32_t>(name.size());
+    buffer.append(reinterpret_cast<const char*>(&size), sizeof(size));
+    // 3. Write the name data
+    buffer.append(name.data(), name.size());
+    // 4. Write the so hash.
+    const MUID &hash = item.second;
+    buffer.append(reinterpret_cast<const char*>(&hash), sizeof(hash));
+  }
+  return true;
+}
+
+bool LinkerCache::SaveData(LinkerMFileInfo &mplInfo, std::string &buffer, CacheIndex cacheIndex) {
+  const auto &cacheMap = *GetCacheMap(mplInfo, cacheIndex);
+  // 1. Write the size and nBucket of map.
+  uint32_t mapSize = static_cast<uint32_t>(cacheMap.size());
+  buffer.append(reinterpret_cast<char*>(&mapSize), sizeof(mapSize));
+  if (mapSize == 0) {
+    return true;
+  }
+  // 2. Write the so name list info.
+  SaveNameList(buffer, cacheIndex);
+  // 3. Write the bucket number.
+  uint32_t mapBucketCnt = static_cast<uint32_t>(cacheMap.bucket_count());
+  buffer.append(reinterpret_cast<char*>(&mapBucketCnt), sizeof(mapBucketCnt));
+  for (auto it = cacheMap.begin(); it != cacheMap.end(); ++it) {
+    const LinkerCacheTableItem &tableItem = it->second;
+    // 4. Write the undef index.
+    uint32_t undefIndex = it->first;
+    buffer.append(reinterpret_cast<char*>(&undefIndex), sizeof(undefIndex));
+    // 5. Write the addr index.
+    uint32_t addrIndex = tableItem.AddrId();
+    buffer.append(reinterpret_cast<char*>(&addrIndex), sizeof(addrIndex));
+    // 6. Write the so index.
+    uint16_t soid = tableItem.SoId();
+    buffer.append(reinterpret_cast<char*>(&soid), sizeof(soid));
+  }
+  return true;
+}
+
+bool LinkerCache::WriteTable(int fd, std::string &buffer, CacheIndex cacheIndex) {
+  // 1. Append content data
+  uint32_t bufferSize = static_cast<uint32_t>(buffer.size());
+  buffer.append(reinterpret_cast<char*>(&bufferSize), sizeof(bufferSize));
+  // 2. Append cache index type.
+  uint8_t type = static_cast<uint8_t>(cacheIndex);
+  buffer.append(reinterpret_cast<char*>(&type), sizeof(type));
+  // 2. Append validity crc.
+  MUID cacheValidity;
+  GenerateMUID(buffer.data(), buffer.size(), cacheValidity);
+  buffer.append(reinterpret_cast<char*>(&cacheValidity), sizeof(cacheValidity));
+  // 3. Append magic number.
+  buffer.append(reinterpret_cast<const char*>(&kCacheMagicNumber), sizeof(kCacheMagicNumber));
+  // Write for all cache data.
+  if (write(fd, buffer.data(), buffer.size()) < 0) {
+    LINKER_LOG(ERROR) << "failed to write cache content," << errno << maple::endl;
+    return false;
+  }
+  return true;
+}
+
+bool LinkerCache::CleanSavingTable(LinkerMFileInfo &mplInfo, int fd, bool res) {
+#ifdef LINKER_DECOUPLE_CACHE
+  // chmod from 600 to 644. When installing/updating app and generating decouple cache, need to
+  // read these cache as OTHER
+  if (res) {
+    if (fchmod(fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0) {
+      LINKER_LOG(ERROR) << "failed to chmod cache," << errno << " name:" << mplInfo.name << maple::endl;
+      res = false;
+    }
+  }
+#endif
+  if (!LINKER_INSTALL_STATE) {
+    close(fd);
+  }
+  return res;
+}
+
+// For debug only.
+bool LinkerCache::DumpTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex) {
+  bool res = false;
+  std::ifstream in;
+  std::ofstream out;
+  BufferSlice buf;
+  std::stringstream ss;
+  if (!InitDump(mplInfo, in, out, cacheIndex)) {
+    goto END;
+  }
+  // Read all the data in buffer firstly.
+  in.seekg(0, std::ios::end);
+  buf = Slice<char>(new char[in.tellg()], in.tellg());
+  in.seekg(0, std::ios::beg);
+  if (!in.read(buf.Data(), buf.Size())) {
+    LINKER_LOG(ERROR) << "(" << cacheIndex << "), failed to read all data," << errno << maple::endl;
+    return false;
+  }
+  if (!DumpMetaValidity(ss, buf) || !DumpMetaVersion(mplInfo, ss, buf) || !DumpMetaCl(ss, buf, cacheIndex)) {
+    goto END;
+  }
+  for (uint32_t type = 0; type < 2; ++type) { // 2 types is undef:0 or def:1
+    if (type == 0) {
+      ss << "\n===== UNDEF =====\n";
+    } else {
+      ss << "\n===== DEF =====\n";
+    }
+    auto mapSize = DumpMap(ss, buf);
+    if (mapSize < 0) {
+      goto END;
+    } else if (mapSize == 0) {
+      continue;
+    }
+    if (!DumpData(ss, buf, mapSize)) {
+      goto END;
+    }
+  }
+  if (!DumpFile(out, ss)) {
+      goto END;
+  }
+  res = true;
+END:
+  in.close();
+  out.close();
+  if (!buf.Empty()) {
+    delete []buf.Data();
+  }
+  return res;
+}
+
+bool LinkerCache::InitDump(LinkerMFileInfo &mplInfo, std::ifstream &in, std::ofstream &out, CacheIndex cacheIndex) {
+  LinkerCacheType cacheType = GetLinkerCacheType(cacheIndex);
+  std::string path;
+  if (!GetPath(mplInfo, path, cacheType, GetLoadState())) {
+    LINKER_LOG(ERROR) << "(" << cacheIndex << "), failed to prepare folder for " <<
+        path << ", " << errno << maple::endl;
+    return false;
+  }
+  in.open(path, std::ios::binary);
+  bool ifStream = (!in);
+  if (ifStream) {
+    if (errno != ENOENT && errno != EACCES) {
+      LINKER_LOG(ERROR) << "(" << cacheIndex << "), failed to open " << path << ", " << errno << maple::endl;
+    }
+    return false;
+  }
+  std::string dump = path + ".dump";
+  out.open(dump, std::ios::trunc);
+  bool ofstream = (!out);
+  if (ofstream) {
+    if (errno != EACCES) {
+      LINKER_LOG(ERROR) << "(" << cacheIndex << "), failed to open " << dump << ", " << errno << maple::endl;
+    }
+    return false;
+  }
+  return true;
+}
+
+bool LinkerCache::DumpMetaValidity(std::stringstream &ss, BufferSlice &buf) {
+  if (buf.Size() < 50) { // 50 is count all sizeof.
+    LINKER_LOG(ERROR) << "failed, read no data," << errno << maple::endl;
+    return false;
+  }
+  // 0. Read EOF.
+  uint32_t eof = *(reinterpret_cast<const uint32_t*>(&buf[buf.Size() - sizeof(eof)]));
+  if (eof != static_cast<uint32_t>(EOF)) {
+    LINKER_LOG(ERROR) << "cache EOF checking failed, eof=" << std::hex << eof << maple::endl;
+    return false;
+  }
+  // 1. Read the validity.
+  MUID lastCacheValidity = *(reinterpret_cast<const MUID*>(buf.Data()));
+  buf += sizeof(lastCacheValidity);
+  // 2. Read the length of content.
+  uint32_t contentSize = *(reinterpret_cast<const uint32_t*>(buf.Data()));
+  buf += sizeof(contentSize);
+  size_t size = buf.Size() - sizeof(eof);
+  ss << "LEN:\t" << contentSize << "\n";
+  ss << "\t" << contentSize << " vs. " << static_cast<uint32_t>(size) << "\n";
+  if (contentSize != static_cast<uint32_t>(size)) {
+    LINKER_LOG(ERROR) << "cache length checking failed," << contentSize << " vs. " <<
+        static_cast<uint32_t>(size) << maple::endl;
+    ss << "\t[FAILED]" << "\n";
+    return false;
+  }
+  ss << "VALIDITY:\t" << lastCacheValidity.ToStr() << "\n";
+  // Generate the digest for validity, excluding the length of content.
+  MUID cacheValidity;
+  GenerateMUID(buf.Data(), size, cacheValidity);
+  ss << "\t" << lastCacheValidity.ToStr() << " vs. " << cacheValidity.ToStr() << "\n";
+  if (lastCacheValidity != cacheValidity) {
+    LINKER_LOG(ERROR) << "cache validity checking failed" << maple::endl;
+    ss << "\t[FAILED]" << "\n";
+    return false;
+  }
+  return true;
+}
+
+bool LinkerCache::DumpMetaVersion(LinkerMFileInfo &mplInfo, std::stringstream &ss, BufferSlice &buf) {
+  // 3. Read maximum version.
+  int32_t maxVersion = *(reinterpret_cast<const int32_t*>(buf.Data()));
+  ss << "MAX:\t" << maxVersion << "\n";
+  ss << "\t" << maxVersion << " vs. " << GetMaxVersion() << "\n";
+  if (maxVersion != GetMaxVersion()) {
+    LINKER_LOG(ERROR) << "failed to check max version for " << maxVersion << " vs. " << GetMaxVersion() << maple::endl;
+    ss << "\t[FAILED]" << "\n";
+    return false;
+  }
+  buf += sizeof(maxVersion);
+  // 4. Read minimum version.
+  int32_t minVersion = *(reinterpret_cast<const int32_t*>(buf.Data()));
+  ss << "MIN:\t" << maxVersion << "\n";
+  ss << "\t" << minVersion << " vs. " << GetMinVersion() << "\n";
+  if (minVersion != GetMinVersion()) {
+    LINKER_LOG(ERROR) << "failed to check min version for " << minVersion << " vs. " << GetMinVersion() << maple::endl;
+    ss << "\t[FAILED]" << "\n";
+    return false;
+  }
+  buf += sizeof(minVersion);
+  // 5. Read the hash from cache file, comparing with .so.
+  MUID lastSoValidity = *(reinterpret_cast<const MUID*>(buf.Data()));
+  MUID soValidity = pInvoker.GetValidityCode(mplInfo);
+  ss << "SO_HASH:\t" << lastSoValidity.ToStr() << "\n";
+  ss << "\t" << lastSoValidity.ToStr() << " vs. " << soValidity.ToStr() << "\n";
+  if (lastSoValidity != soValidity) {
+    LINKER_LOG(ERROR) << "so validity checking failed, " << soValidity.ToStr() <<
+        " vs. " << lastSoValidity.ToStr() << " in " << mplInfo.name << maple::endl;
+    ss << "\t[FAILED]" << "\n";
+    return false;
+  }
+  buf += sizeof(lastSoValidity);
+  return true;
+}
+
+bool LinkerCache::DumpMetaCl(std::stringstream &ss, BufferSlice &buf, CacheIndex cacheIndex) {
+  // 6. Read the hash from classloader.
+  MUID lastClValidity = *(reinterpret_cast<const MUID*>(buf.Data()));
+  MUID rtClValidity = pClHash[cacheIndex];
+  ss << "CL_HASH:\t" << lastClValidity.ToStr() << "\n";
+  ss << "\t" << lastClValidity.ToStr() << " vs. " << rtClValidity.ToStr() << "\n";
+  if (lastClValidity != rtClValidity) {
+    LINKER_LOG(ERROR) << "(" << cacheIndex << "), classloader validity checking failed, " <<
+        rtClValidity.ToStr() << " vs. " << lastClValidity.ToStr();
+    ss << "\t[FAILED]" << "\n";
+    return false;
+  }
+  buf += sizeof(lastClValidity);
+  // 7. Read the .so count.
+  uint16_t lastClSoCnt = *(reinterpret_cast<const uint16_t*>(buf.Data()));
+  uint16_t rtClSoCnt = pClSoCnt[cacheIndex];
+  ss << "\tCL_nSO:\t" << lastClSoCnt << "\n";
+  ss << "\t" << lastClSoCnt << " vs. " << rtClSoCnt << "\n";
+  if (lastClSoCnt != rtClSoCnt) {
+    LINKER_LOG(ERROR) << "(" << cacheIndex << "), classloader so cnt checking failed, " <<
+        rtClSoCnt << " vs. " << lastClSoCnt;
+    ss << "\t[FAILED]" << "\n";
+    return false;
+  }
+  buf += sizeof(uint16_t);
+  return true;
+}
+
+bool LinkerCache::DumpData(std::stringstream &ss, BufferSlice &buf, size_t mapSize) {
+  std::vector<std::pair<std::string, MUID>> soList;
+  for (size_t i = 0; i < mapSize; ++i) {
+    MUID hash;
+    uint16_t arrayIndex = 0;
+    // 9. Read the undef index.
+    uint32_t undefIndex = *(reinterpret_cast<const uint32_t*>(buf.Data()));
+    ss << "\t*UNDEF_INX:\t" << undefIndex << "\n";
+    buf += sizeof(undefIndex);
+    // 10. Read the name length firstly.
+    uint16_t len = *(reinterpret_cast<const uint16_t*>(buf.Data()));
+    ss << "\tLEN_FLAG:\t" << len << "\n";
+    if (len > PATH_MAX) {
+      LINKER_LOG(ERROR) << "failed, length is too long:" << len << maple::endl;
+      return false;
+    }
+    buf += sizeof(len);
+    // 11. Read the name by its length.
+    if (len == 0) { // Name index.
+      arrayIndex = *(reinterpret_cast<const uint16_t*>(buf.Data()));
+      buf += sizeof(arrayIndex);
+      std::pair<std::string, MUID> pair = soList[arrayIndex];
+      ss << "\tNAME:\t" << pair.first << "\n" << "\tHASH:\t" << pair.second.ToStr() << "\n";
+    } else { // Name string, including INVALID_NAME.
+      std::string text(buf.Data(), len);
+      buf += len;
+      if (len == kLinkerInvalidNameLen) {
+        LINKER_LOG(ERROR) << "has not resolved symbol" << maple::endl;
+        ss << "\tNAME:\tX" << "\n" << "\tHASH:\t(nul)" << "\n";
+      } else {
+        // 12. Read the hash code of .so
+        hash = *(reinterpret_cast<const MUID*>(buf.Data()));
+        buf += sizeof(hash);
+        ss << "\tNAME:\t" << text << "\n" << "\tHASH:\t" << hash.ToStr() << "\n";
+        auto soListIt = std::find_if (soList.begin(), soList.end(),
+            [&text](const std::pair<std::string, MUID> &item){ return item.first == text; });
+        if (soListIt == soList.end()) {
+          soList.push_back(std::make_pair(text, hash));
+        } else {
+          LINKER_LOG(ERROR) << "bad format, has multiple name string" << maple::endl;
+          ss << "\t[FAILED]" << "\n";
+          return false;
+        }
+      }
+    }
+    // 13. Read the index.
+    uint32_t idx = *(reinterpret_cast<const uint32_t*>(buf.Data()));
+    ss << "\t*INDEX:\t" << idx << "\n";
+    buf += sizeof(uint32_t);
+  }
+  return true;
+}
+
+int LinkerCache::DumpMap(std::stringstream &ss, BufferSlice &buf) {
+  // 8. Read the map size and nBucket for resolving table.
+  uint32_t mapSize = *(reinterpret_cast<const uint32_t*>(buf.Data()));
+  ss << "MAP_SIZE:\t" << mapSize << "\n";
+  ss << "\t" << mapSize << " vs. 0" << "\n";
+  if (mapSize == 0) {
+    ss << "\t[SUCC]" << "\n";
+    return 0;
+  }
+  buf += sizeof(mapSize);
+  uint32_t mapBucketCnt = *(reinterpret_cast<const uint32_t*>(buf.Data()));
+  ss << "nBUCKET:\t" << mapBucketCnt << "\n";
+  ss << "\t" << mapBucketCnt << " vs. 0" << "\n";
+  if (mapBucketCnt == 0) {
+    LINKER_LOG(ERROR) << "map nBucket is 0" << maple::endl;
+    ss << "\t[FAILED]" << "\n";
+    return -1;
+  }
+  buf += sizeof(mapBucketCnt);
+  return mapSize;
+}
+
+bool LinkerCache::DumpFile(std::ofstream &out, std::stringstream &ss) {
+  // 14. Dump the content.
+  std::string content = ss.str();
+  if (!out.write(content.data(), content.length())) {
+    LINKER_LOG(ERROR) << "failed to write cache content:" << errno << maple::endl;
+    return false;
+  }
+  return true;
+}
+
+// Remove FS cache.
+bool LinkerCache::RemoveTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex) {
+  LinkerCacheType cacheType = GetLinkerCacheType(cacheIndex);
+  std::string path;
+  if (!GetPath(mplInfo, path, cacheType, GetLoadState())) {
+    LINKER_LOG(ERROR) << "(" << cacheIndex << "), failed to prepare folder for " <<
+        path << ", " << errno << maple::endl;
+    return false;
+  }
+  if (std::remove(path.c_str())) {
+    if (errno != ENOENT) {
+      LINKER_LOG(ERROR) << "(" << cacheIndex << "), failed to remove " << path << ", " << errno << maple::endl;
+    }
+    return false;
+  }
+  LINKER_LOG(INFO) << "(" << cacheIndex << "), remove " << path << " successfully" << maple::endl;
+  return true;
+}
+
+// Release the memory allocated.
+// Notice: MUST only invoke ONCE after BOTH def&undef finished!
+void LinkerCache::FreeTable(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex) {
+  switch (cacheIndex) {
+    case kMethodUndefIndex:
+      mplInfo.rep.methodUndefCacheMap.clear();
+      MplCacheMapT().swap(mplInfo.rep.methodUndefCacheMap);
+      mplInfo.SetFlag(kIsMethodUndefCacheValid, false);
+      break;
+    case kMethodDefIndex:
+      mplInfo.rep.methodDefCacheMap.clear();
+      MplCacheMapT().swap(mplInfo.rep.methodDefCacheMap);
+      mplInfo.SetFlag(kIsMethodCacheValid, false);
+      break;
+    case kDataUndefIndex:
+      mplInfo.rep.dataUndefCacheMap.clear();
+      MplCacheMapT().swap(mplInfo.rep.dataUndefCacheMap);
+      mplInfo.SetFlag(kIsDataUndefCacheValid, false);
+      break;
+    case kDataDefIndex:
+      mplInfo.rep.dataDefCacheMap.clear();
+      MplCacheMapT().swap(mplInfo.rep.dataDefCacheMap);
+      mplInfo.SetFlag(kIsDataCacheValid, false);
+      break;
+  };
+}
+
+static constexpr uint32_t kLinkerMaxCacheNumPerType = 10;
+bool LinkerCache::LoadInstallCache(LinkerMFileInfo &mplInfo, LinkerCacheType cacheType) {
+  std::string path;
+  if (!GetInstallCachePath(mplInfo, path, cacheType)) {
+    return false;
+  }
+  path += '.';
+  for (uint32_t i = 0; i < kLinkerMaxCacheNumPerType; ++i) {
+    std::string file = path + static_cast<char>('0' + i);
+    LINKER_DLOG(mpllinker) << "name:" << mplInfo.name << " get file:" << file << maple::endl;
+    if (access(file.c_str(), R_OK) != 0) {
+      LINKER_VLOG(mpllinker) << "name:" << mplInfo.name << " access file:" << file << " fail" << maple::endl;
+      break;
+    }
+
+    bool ret = false;
+    switch (cacheType) {
+      case LinkerCacheType::kLinkerCacheMethodUndef:
+        ret = LoadTable(mplInfo, file, kMethodUndefIndex);
+        break;
+      case LinkerCacheType::kLinkerCacheMethodDef:
+        ret = LoadTable(mplInfo, file, kMethodDefIndex);
+        break;
+      case LinkerCacheType::kLinkerCacheDataUndef:
+        ret = LoadTable(mplInfo, file, kDataUndefIndex);
+        break;
+      case LinkerCacheType::kLinkerCacheDataDef:
+        ret = LoadTable(mplInfo, file, kDataDefIndex);
+        break;
+      default:
+        break;
+    }
+    if (ret) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void LinkerCache::UpdateProperty(LinkerMFileInfo &mplInfo, CacheIndex cacheIndex) {
+  LinkerMFileInfoListT mplFileList;
+  pInvoker.GetLinkerMFileInfos(mplInfo, mplFileList);
+  pClHash[cacheIndex] = mplFileList.Hash(false);
+  pClSoCnt[cacheIndex] = mplFileList.Size();
+}
+
+void LinkerCache::ResolveMethodSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice) {
+  bool saveRtCache = false;
+  if (mplInfo.rep.methodUndefCacheSize == -1) {
+    mplInfo.SetFlag(kIsMethodUndefCacheValid, LoadTable(mplInfo, kMethodUndefIndex));
+    mplInfo.rep.methodUndefCacheSize = mplInfo.rep.methodUndefCacheMap.size();
+    if (mplInfo.rep.methodUndefCacheMap.size() < addrSlice.Size()) {
+      mplInfo.SetFlag(kIsMethodUndefCacheValid, false);
+    }
+  }
+  if (mplInfo.IsFlag(kIsMethodUndefCacheValid)) {
+    saveRtCache = ProcessTable(mplInfo, addrSlice, muidSlice, methodUndef);
+  } else {
+    saveRtCache = LookUpUndefSymbol(mplInfo, addrSlice, muidSlice, methodUndef);
+  }
+  if (saveRtCache) {
+    SaveTable(mplInfo, kMethodUndefIndex);
+  }
+}
+
+void LinkerCache::FreeMethodUndefTable(LinkerMFileInfo &mplInfo) {
+  FreeTable(mplInfo, kMethodUndefIndex);
+}
+
+bool LinkerCache::LookUpDefAddr(LinkerMFileInfo &mplInfo, const MUID &muid, LinkerOffsetType &addr,
+    LinkerCacheTableItem &pItem, CacheInfo cacheInfo) {
+  LinkerMFileInfo *resInfo = nullptr;
+  LinkerOffsetType resAddr = 0;
+  size_t index = 0;
+  if (!pInvoker.ForEachLookUp(muid, &pInvoker, cacheInfo.lookUpSymbolAddress, mplInfo,
+      &resInfo, index, resAddr)) {
+    LINKER_LOG(ERROR) << "[RT/binary searching] failed to relocate MUID=" <<
+        muid.ToStr() << " in " << mplInfo.name << maple::endl;
+    mplInfo.SetFlag(cacheInfo.notResolved, true);
+  } else {
+    addr = resAddr;
+    auto &inf = pMplCacheInf[cacheInfo.cacheIndex];
+    uint16_t soid = inf.Append(resInfo->name, resInfo->hash);
+    pItem.SetIds(index, soid).SetFilled();
+    return true;
+  }
+  return false;
+}
+
+bool LinkerCache::LookUpDefSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice,
+    CacheInfo cacheInfo) {
+  auto &inf = pMplCacheInf[cacheInfo.cacheIndex];
+  bool saveRtCache = false;
+  std::mutex mtx;
+  auto lookFunc = [&](size_t begSize, size_t endSize) {
+    LinkerOffsetType resAddr = 0;
+    LinkerMFileInfo *resInfo = nullptr;
+    size_t index = 0;
+    // Start binary search def from here.
+    for (size_t i = begSize; i < endSize; ++i) {
+      if (!pInvoker.ForEachLookUp(muidSlice[i].muid, &pInvoker, cacheInfo.lookUpSymbolAddress, mplInfo,
+                                  &resInfo, index, resAddr)) { // Not found
+        // Never reach here.
+        LINKER_LOG(ERROR) << "failed to relocate MUID=" << muidSlice[i].muid.ToStr() <<
+            " in " << mplInfo.name << ", resAddr=" << resAddr << maple::endl;
+        mplInfo.SetFlag(cacheInfo.notResolved, true);
+      } else { // Found
+        if (mplInfo.name != resInfo->name) { // It's not in self SO.
+          std::lock_guard<std::mutex> lck(mtx);
+          addrSlice[i].addr = resAddr;
+          uint16_t soid = inf.Append(resInfo->name, resInfo->hash);
+          LinkerCacheTableItem pItem(static_cast<uint32_t>(index), soid);
+          pItem.SetFilled();
+          auto &cacheMap = *GetCacheMap(mplInfo, cacheInfo.cacheIndex);
+          cacheMap[static_cast<uint32_t>(i)] = pItem;
+        }
+        saveRtCache = true;
+      }
+    }
+  };
+  const int threadNumber = 4; // half of the cpu number of phone.
+  ParallelLookUp(lookFunc, threadNumber, addrSlice.Size());
+  mplInfo.SetFlag(cacheInfo.cacheValid, true);
+  return saveRtCache;
+}
+
+template<typename F>
+void LinkerCache::ParallelLookUp(F const &lookFunc, int numThreads, size_t defSize) {
+  size_t blockStart;
+  size_t blockEnd;
+  size_t blockSize = defSize / numThreads;
+  std::vector<std::thread> threads;
+  for (int i = 0; i < numThreads - 1; ++i) {
+    blockStart = i * blockSize;
+    blockEnd = (i + 1) * blockSize;
+    threads.push_back(std::thread(lookFunc, blockStart, blockEnd));
+  }
+  lookFunc((numThreads - 1) * blockSize, defSize);
+  for (auto &thr : threads) {
+    thr.join();
+  }
+}
+
+void LinkerCache::RelocateMethodSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice) {
+  bool saveRtCache = false;
+  if (mplInfo.rep.methodDefCacheSize == -1) {
+    mplInfo.SetFlag(kIsMethodCacheValid, LoadTable(mplInfo, kMethodDefIndex));
+    mplInfo.rep.methodDefCacheSize = mplInfo.rep.methodDefCacheMap.size();
+  }
+  if (mplInfo.IsFlag(kIsMethodCacheValid)) {
+    saveRtCache = ProcessTable(mplInfo, addrSlice, muidSlice, methodDef);
+  } else {
+    saveRtCache = LookUpDefSymbol(mplInfo, addrSlice, muidSlice, methodDef);
+  }
+  if (saveRtCache) {
+    SaveTable(mplInfo, kMethodDefIndex);
+  }
+}
+
+void LinkerCache::FreeMethodDefTable(LinkerMFileInfo &mplInfo) {
+  FreeTable(mplInfo, kMethodDefIndex);
+}
+
+bool LinkerCache::ProcessTable(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice,
+    CacheInfo cacheInfo) {
+  auto &inf = pMplCacheInf[cacheInfo.cacheIndex];
+  auto &store = pMplStore[cacheInfo.cacheIndex];
+  bool saveRtCache = false;
+  auto &cacheMap = *GetCacheMap(mplInfo, cacheInfo.cacheIndex);
+  for (auto it = cacheMap.begin(); it != cacheMap.end(); ++it) {
+    bool noRtCache = false;
+    uint32_t i = it->first;
+    LinkerCacheTableItem &pItem = it->second;
+    if (pItem.Filled()) { // Already done
+      continue;
+    } else if (pItem.LazyInvalidName() && cacheInfo.isUndef) {
+      continue; // Ignore the symbols not found from system(Boot class loader).
+    } else if (pItem.Valid()) {
+      LinkerMFileInfo *res = FindLinkerMFileInfo(pItem.SoId(), inf, store);
+      if (res != nullptr) {
+        // We suppose that dex(.so) list is always changed with increment in runtime.
+        // If so, we use dex(.so) list hash and its count to check the cache validity.
+        const MUID &hash = inf.GetHash(pItem.SoId());
+        if (hash == res->hash) {
+          addrSlice[i].addr = GetAddr(*res, pItem, cacheInfo.isMethod);
+          pItem.SetFilled();
+        } else {
+          noRtCache = true;
+          if (VLOG_IS_ON(mpllinker)) {
+            LINKER_VLOG(mpllinker) << "runtime cache is invalid(expired) {" << hash.ToStr() << " vs. " <<
+                res->hash.ToStr() << "} for " << mplInfo.name << "->" << res->name << maple::endl;
+          }
+        }
+      } else {
+        mplInfo.SetFlag(cacheInfo.notResolved, true); // noRtCache is true; // Wait for next loading so.
+      }
+    } else if (cacheInfo.isUndef) {
+      noRtCache = true;
+    } else {
+      // Never reach here!!
+      LINKER_LOG(ERROR) << "no runtime cache so found? for " << mplInfo.name << maple::endl;
+    }
+    // If no runtime cached one found, start binary searching.
+    if (cacheInfo.isUndef) {
+      if (noRtCache && LookUpUndefAddr(mplInfo, muidSlice[i].muid, addrSlice[i].addr, pItem, dataUndef)) {
+        saveRtCache = true;
+      }
+    } else {
+      if (noRtCache && LookUpDefAddr(mplInfo, muidSlice[i].muid, addrSlice[i].addr, pItem, dataUndef)) {
+        saveRtCache = true;
+      }
+    }
+  }
+  return saveRtCache;
+}
+
+bool LinkerCache::LookUpUndefAddr(LinkerMFileInfo &mplInfo, const MUID &muid,
+                                  LinkerOffsetType &addr, LinkerCacheTableItem &pItem, CacheInfo cacheInfo) {
+  auto &inf = pMplCacheInf[cacheInfo.cacheIndex];
+  LinkerMFileInfo *resInfo = nullptr;
+  size_t index = 0;
+  LinkerOffsetType resAddr = 0;
+  if (!pInvoker.ForEachLookUp(muid, &pInvoker,
+      cacheInfo.lookUpSymbolAddress, mplInfo, &resInfo, index, resAddr)) { // Not found
+    // Ignore the symbols not found from system(Boot class loader) for lazy binding.
+    if (!mplInfo.IsFlag(kIsLazy)) {
+      mplInfo.SetFlag(cacheInfo.notResolved, true);
+    }
+  } else { // Found
+    // Ignore the symbols found not from system(Boot class loader).
+    if (mplInfo.IsFlag(kIsLazy) && !resInfo->IsFlag(kIsBoot) &&
+        !pInvoker.IsSystemClassLoader(reinterpret_cast<const MObject*>(resInfo->classLoader))) {
+      uint16_t soid = inf.Append(kLinkerLazyInvalidSoName, kInvalidHash);
+      pItem.SetLazyInvalidSoId(soid).SetFilled();
+    } else {
+      addr = resAddr;
+      uint16_t soid = inf.Append(resInfo->name, resInfo->hash);
+      pItem.SetIds(index, soid).SetFilled();
+    }
+    return true;
+  }
+  return false;
+}
+
+bool LinkerCache::UndefSymbolFailHandler(LinkerMFileInfo &mplInfo, uint32_t idx, CacheInfo cacheInfo) {
+  auto &inf = pMplCacheInf[cacheInfo.cacheIndex];
+  LinkerCacheTableItem pItem;
+  // Ignore the symbols not found from system(Boot class loader).
+  if (mplInfo.IsFlag(kIsLazy)) {
+    uint16_t soid = inf.Append(kLinkerLazyInvalidSoName, kInvalidHash);
+    pItem.SetLazyInvalidSoId(soid).SetFilled();
+  } else {
+    uint16_t soid = inf.Append(kLinkerInvalidName, kInvalidHash);
+    pItem.SetInvalidSoId(soid);
+  }
+  auto &cacheMap = *GetCacheMap(mplInfo, cacheInfo.cacheIndex);
+  cacheMap.insert(std::make_pair(idx, pItem));
+  if (!mplInfo.IsFlag(kIsLazy)) {
+    mplInfo.SetFlag(cacheInfo.notResolved, true);
+  }
+  return true;
+}
+
+bool LinkerCache::LookUpUndefSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice,
+    CacheInfo cacheInfo) {
+  auto &inf = pMplCacheInf[cacheInfo.cacheIndex];
+  bool saveRtCache = false;
+  // Start binary search from here.
+  for (size_t i = 0; i < addrSlice.Size(); ++i) {
+    // To check pTable[i].addr == 0 later?
+    LinkerMFileInfo *resInfo = nullptr;
+    size_t index = 0;
+    LinkerOffsetType resAddr = 0;
+    if (!pInvoker.ForEachLookUp(muidSlice[i].muid, &pInvoker,
+        cacheInfo.lookUpSymbolAddress, mplInfo, &resInfo, index, resAddr)) { // Not found
+      saveRtCache = UndefSymbolFailHandler(mplInfo, static_cast<uint32_t>(i), cacheInfo);
+    } else { // Found
+      LinkerCacheTableItem pItem;
+      // Ignore the symbols found not from system(Boot class loader).
+        if (mplInfo.IsFlag(kIsLazy) && !resInfo->IsFlag(kIsBoot) &&
+            !pInvoker.IsSystemClassLoader(reinterpret_cast<const MObject*>(resInfo->classLoader))) {
+        uint16_t soid = inf.Append(kLinkerLazyInvalidSoName, kInvalidHash);
+        pItem.SetLazyInvalidSoId(soid).SetFilled();
+      } else {
+        addrSlice[i].addr = resAddr;
+        uint16_t soid = inf.Append(resInfo->name, resInfo->hash);
+        pItem.SetIds(index, soid).SetFilled();
+      }
+      auto &cacheMap = *GetCacheMap(mplInfo, cacheInfo.cacheIndex);
+      cacheMap.insert(std::make_pair(i, pItem));
+      saveRtCache = true;
+    }
+  }
+  mplInfo.SetFlag(cacheInfo.cacheValid, true);
+  return saveRtCache;
+}
+
+void LinkerCache::ResolveDataSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice) {
+  bool saveRtCache = false;
+  if (mplInfo.rep.dataUndefCacheSize == -1) {
+    mplInfo.SetFlag(kIsDataUndefCacheValid, LoadTable(mplInfo, kDataUndefIndex));
+    mplInfo.rep.dataUndefCacheSize = mplInfo.rep.dataUndefCacheMap.size();
+    if (mplInfo.rep.dataUndefCacheMap.size() < addrSlice.Size()) {
+      mplInfo.SetFlag(kIsDataUndefCacheValid, false);
+    }
+  }
+  if (mplInfo.IsFlag(kIsDataUndefCacheValid)) {
+    saveRtCache = ProcessTable(mplInfo, addrSlice, muidSlice, dataUndef);
+  } else {
+    saveRtCache = LookUpUndefSymbol(mplInfo, addrSlice, muidSlice, dataUndef);
+  }
+  if (saveRtCache) {
+    SaveTable(mplInfo, kDataUndefIndex);
+  }
+}
+
+void LinkerCache::FreeDataUndefTable(LinkerMFileInfo &mplInfo) {
+  FreeTable(mplInfo, kDataUndefIndex);
+}
+
+void LinkerCache::RelocateDataSymbol(LinkerMFileInfo &mplInfo, AddrSlice &addrSlice, MuidSlice &muidSlice) {
+  bool saveRtCache = false;
+  if (mplInfo.rep.dataDefCacheSize == -1) {
+    mplInfo.SetFlag(kIsDataCacheValid, LoadTable(mplInfo, kDataDefIndex));
+    mplInfo.rep.dataDefCacheSize = mplInfo.rep.dataDefCacheMap.size();
+  }
+  if (mplInfo.IsFlag(kIsDataCacheValid)) {
+    saveRtCache = ProcessTable(mplInfo, addrSlice, muidSlice, dataDef);
+  } else {
+    saveRtCache = LookUpDefSymbol(mplInfo, addrSlice, muidSlice, dataDef);
+  }
+  if (saveRtCache) {
+    SaveTable(mplInfo, kDataDefIndex);
+  }
+}
+
+void LinkerCache::FreeDataDefTable(LinkerMFileInfo &mplInfo) {
+  FreeTable(mplInfo, kDataDefIndex);
+}
+
+LinkerOffsetType LinkerCache::GetAddr(LinkerMFileInfo &res, LinkerCacheTableItem &pItem, bool isMethod) {
+  if (isMethod) {
+#ifdef USE_32BIT_REF
+    return pInvoker.AddrToUint32(pInvoker.GetMethodSymbolAddress(res, pItem.AddrId()));
+#else
+    return reinterpret_cast<LinkerOffsetType>(pInvoker.GetMethodSymbolAddress(res, pItem.AddrId()));
+#endif // USE_32BIT_REF
+  } else {
+#ifdef USE_32BIT_REF
+    return pInvoker.AddrToUint32(pInvoker.GetDataSymbolAddress(res, pItem.AddrId()));
+#else
+    return reinterpret_cast<LinkerOffsetType>(pInvoker.GetDataSymbolAddress(res, pItem.AddrId()));
+#endif // USE_32BIT_REF
+  }
+}
+
+#endif
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/linker/linker_debug.cpp b/src/mrt/compiler-rt/src/linker/linker_debug.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..84e4784d9f3dfa41f483a56e8e103d2e41ec3218
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_debug.cpp
@@ -0,0 +1,428 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker_debug.h"
+
+#include "linker/linker_model.h"
+#include "linker/linker_inline.h"
+#include "file_layout.h"
+#include "collector/cp_generator.h"
+#include "interp_support.h"
+using namespace maple;
+
+namespace maplert {
+using namespace linkerutils;
+FeatureName Debug::featureName = kFDebug;
+// Dump all the section info of all loaded maple-so
+void Debug::DumpAllMplSectionInfo(std::ostream &os) {
+  uint64_t sumMethodsHotSize = 0;
+  uint64_t sumMethodsColdSize = 0;
+  uint64_t sumMethodsCompactSize = 0;
+  uint64_t sumFieldsHotSize = 0;
+  uint64_t sumFieldsColdSize = 0;
+  uint64_t sumFieldsCompactSize = 0;
+  uint64_t sumVtbHotSize = 0;
+  uint64_t sumVtbColdSize = 0;
+  uint64_t sumItbHotSize = 0;
+  uint64_t sumItbColdSize = 0;
+  uint64_t sumSuperClassHotSize = 0;
+  uint64_t sumSuperClassColdSize = 0;
+  uint64_t sumClassMeta = 0;
+  uint64_t sumHotLiteralSize = 0;
+  uint64_t sumColdLiteralSize = 0;
+  uint64_t sumEhframeSize = 0;
+  uint64_t sumReflectionStrSize = 0;
+  uint64_t sumMuidTabSize = 0;
+  void *symAddr = nullptr;
+  auto handle = [&, this](LinkerMFileInfo &mplInfo) {
+    os << mplInfo.name << ":\n";
+    void *javaStartAddr = mplInfo.GetTblBegin(kJavaText);
+    void *javaEndAddr = reinterpret_cast<void*>(
+        reinterpret_cast<uintptr_t>(javaStartAddr) + mplInfo.GetTblSize(kJavaText));
+    os << "\tjava-text-start:" << std::hex << javaStartAddr << "\n";
+    os << "\tjava-text-end:" << std::hex << javaEndAddr << "\n";
+    os << "\tstrtab-start:" << std::hex << GetSymbolAddr(mplInfo.handle, "MRT_GetStrTabBegin", true) << "\n";
+    os << "\tstrtab-end:" << std::hex << GetSymbolAddr(mplInfo.handle, "MRT_GetStrTabEnd", true) << "\n";
+    os << "\tjnitab-start:" << std::hex << GetSymbolAddr(mplInfo.handle, "__MRT_GetJNITable_Begin", true) << "\n";
+    os << "\tjnitab-end:" << std::hex << GetSymbolAddr(mplInfo.handle, "__MRT_GetJNITable_End", true) << "\n";
+    os << "\tjnifunctab-start:" << std::hex << GetSymbolAddr(mplInfo.handle, "__MRT_GetJNIFuncTable_Begin", true) <<
+        "\n";
+    os << "\tjnifunctab-end:" << std::hex << GetSymbolAddr(mplInfo.handle, "__MRT_GetJNIFuncTable_End", true) << "\n";
+    os << "\trangetab-start:" << std::hex << GetSymbolAddr(mplInfo.handle, "MRT_GetRangeTableBegin", true) << "\n";
+    os << "\trangetab-end:" << std::hex << GetSymbolAddr(mplInfo.handle, "MRT_GetRangeTableEnd", true) << "\n";
+
+    os << "\treflectColdStr_begin:" << std::hex << GetSymbolAddr(mplInfo.handle, "MRT_GetColdStrTabBegin", true) <<
+        "\n";
+    uint64_t reflectionColdStrSize =
+        static_cast<uint64_t>(static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetColdStrTabEnd", true)) -
+        static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetColdStrTabBegin", true)));
+    os << "\treflectStartHotStr_begin:" << std::hex <<
+        GetSymbolAddr(mplInfo.handle, "MRT_GetStartHotStrTabBegin", true) << "\n";
+    uint64_t reflectionStartHotStrSize =
+        static_cast<uint64_t>(static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetStartHotStrTabEnd", true)) -
+        static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetStartHotStrTabBegin", true)));
+    os << "\treflectBothHotStr_begin:" << std::hex <<
+        GetSymbolAddr(mplInfo.handle, "MRT_GetBothHotStrTabBegin", true) << "\n";
+    uint64_t reflectionBothHotStrSize =
+        static_cast<uint64_t>(static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetBothHotStrTabEnd", true)) -
+        static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetBothHotStrTabBegin", true)));
+    os << "\treflectRunHotStr_begin:" << std::hex <<
+        GetSymbolAddr(mplInfo.handle, "MRT_GetRunHotStrTabBegin", true) << "\n";
+    uint64_t reflectionRunHotStrSize =
+        static_cast<uint64_t>(static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetRunHotStrTabEnd", true)) -
+        static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetRunHotStrTabBegin", true)));
+    sumReflectionStrSize += (reflectionColdStrSize + reflectionStartHotStrSize +
+                             reflectionBothHotStrSize + reflectionRunHotStrSize);
+    os << "\treflectColdStr size:" << std::hex << reflectionColdStrSize << "\n";
+    os << "\treflectStartHotStr size:" << std::hex << reflectionStartHotStrSize << "\n";
+    os << "\treflectBothHotStr size:" << std::hex << reflectionBothHotStrSize << "\n";
+    os << "\treflectRunHotStr size:" << std::hex << reflectionRunHotStrSize << "\n";
+
+    os << "\tmuidTab_begin:" << std::hex << GetSymbolAddr(mplInfo.handle, "MRT_GetMuidTabBegin", true) << "\n";
+    uint64_t muidTabSize =
+        static_cast<uint64_t>(static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetMuidTabEnd", true)) -
+        static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetMuidTabBegin", true)));
+    sumMuidTabSize += muidTabSize;
+    os << "\tmuidTab size:" << std::hex << muidTabSize << "\n";
+
+    os << "\tEhframe_begin:" << std::hex << GetSymbolAddr(mplInfo.handle, "MRT_GetEhframeStart", true) << "\n";
+    uint64_t ehframeSize =
+        static_cast<uint64_t>(static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetEhframeEnd", true)) -
+        static_cast<char*>(GetSymbolAddr(mplInfo.handle, "MRT_GetEhframeStart", true)));
+    sumEhframeSize += ehframeSize;
+    os << "\tEhframe size:" << std::hex << ehframeSize << "\n";
+    for (uint32_t i = 0; i < static_cast<uint32_t>(kLayoutTypeCount); ++i) {
+      std::string markerName = "__MBlock_" + GetLayoutTypeString(i) + "_func_start";
+      symAddr = GetSymbolAddr(mplInfo.handle, markerName.c_str(), false);
+      if (symAddr != nullptr) {
+        os << "\t" << markerName << ":" << std::hex << *(reinterpret_cast<int64_t*>(symAddr)) << "\n";
+      }
+    }
+    if ((symAddr = GetSymbolAddr(mplInfo.handle, "__MBlock_globalVars_hot_begin", false))) {
+      os << "\t__MBlock_globalVars_hot_begin:" << std::hex << *(reinterpret_cast<int64_t*>(symAddr)) << "\n";
+    }
+    if ((symAddr = GetSymbolAddr(mplInfo.handle, "__MBlock_globalVars_cold_begin", false))) {
+      os << "\t__MBlock_globalVars_cold_begin:" << std::hex << *(reinterpret_cast<int64_t*>(symAddr)) << "\n";
+    }
+    if ((symAddr = GetSymbolAddr(mplInfo.handle, "__MBlock_globalVars_cold_end", false))) {
+      os << "\t__MBlock_globalVars_cold_end:" << std::hex << *(reinterpret_cast<int64_t*>(symAddr)) << "\n";
+    }
+
+    sumHotLiteralSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock_literal_hot");
+    sumColdLiteralSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock_literal_cold");
+    sumClassMeta += mplInfo.GetTblSize(kTabClassMetadata);
+
+    sumMethodsHotSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock__methods_info__hot");
+    sumMethodsColdSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock__methods_info__cold");
+    sumMethodsCompactSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock__methods_infocompact__cold");
+
+    sumFieldsHotSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock__fields_info__hot");
+    sumFieldsColdSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock__fields_info__cold");
+    sumFieldsCompactSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock__fields_infocompact__cold");
+
+    sumVtbHotSize += mplInfo.GetTblSize(kVTable);
+    sumVtbColdSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock__vtb_cold");
+    sumItbHotSize += mplInfo.GetTblSize(kITable);
+    sumItbColdSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock__itb_cold");
+    sumSuperClassHotSize += mplInfo.GetTblSize(kDataSuperClass);
+    sumSuperClassColdSize += DumpMetadataSectionSize(os, mplInfo.handle, "__MBlock__superclasses__cold");
+  };
+  pInvoker->mplInfoList.ForEach(handle);
+  os << std::dec;
+  os << "All maple*.so literal information: " << "\n";
+  os << "\tsumLiteralHotSize: " << sumHotLiteralSize << "\n";
+  os << "\tsumLiteralColdSize: " << sumColdLiteralSize << "\n";
+
+  os << "All maple*.so MetaData information: " << "\n";
+  os << "\tsumClassMetaSize: " << sumClassMeta << "\n";
+  os << "\tsumMethodsHotSize: " << sumMethodsHotSize << "\n";
+  os << "\tsumMethodsColdSize: " << sumMethodsColdSize << "\n";
+  os << "\tsumMethodsCompactSize: " << sumMethodsCompactSize << "\n";
+  os << "\tsumFieldsHotSize: " << sumFieldsHotSize << "\n";
+  os << "\tsumFieldsColdSize: " << sumFieldsColdSize << "\n";
+  os << "\tsumFieldsCompactSize: " << sumFieldsCompactSize << "\n";
+  os << "\tsumVtbHotSize: " << sumVtbHotSize << "\n";
+  os << "\tsumVtbColdSize: " << sumVtbColdSize << "\n";
+  os << "\tsumItbHotSize: " << sumItbHotSize << "\n";
+  os << "\tsumItbColdSize: " << sumItbColdSize << "\n";
+  os << "\tsumSuperClassHotSize: " << sumSuperClassHotSize << "\n";
+  os << "\tsumSuperClassColdSize: " << sumSuperClassColdSize << "\n";
+  os << "\tsumEhframeSize: " << sumEhframeSize << "\n";
+  os << "\tsumMuidTabSize: " << sumMuidTabSize << "\n";
+  os << "\tsumReflectionStrSize: " << sumReflectionStrSize << "\n";
+}
+
+// Dump all the function profile of all loaded maple-so
+void Debug::DumpAllMplFuncProfile(std::unordered_map<std::string, std::vector<FuncProfInfo>> &funcProfileRaw) {
+  size_t size;
+  LinkerFuncProfileTableItem *tableItem = nullptr;
+  auto handle = [&](LinkerMFileInfo &mplInfo) {
+    size = mplInfo.GetTblSize(kMethodProfile);
+    tableItem = mplInfo.GetTblBegin<LinkerFuncProfileTableItem*>(kMethodProfile);
+    VLOG(profiler) << mplInfo.name << " size " << size << "\n";
+    bool emptySize = (!size);
+    if (emptySize) {
+      return;
+    }
+    auto &profileList = funcProfileRaw[mplInfo.name];
+    LinkerInfTableItem *pInfTable = mplInfo.GetTblBegin<LinkerInfTableItem*>(kMethodInfo);
+    for (size_t i = 0; i < size; ++i) {
+      LinkerFuncProfileTableItem item = tableItem[i];
+      if (item.callTimes) {
+        LinkerInfTableItem *infItem = reinterpret_cast<LinkerInfTableItem*>(pInfTable + i);
+        std::string funcName = GetMethodSymbolByOffset(*infItem);
+        auto startupProfile = mplInfo.funProfileMap.find(static_cast<uint32_t>(i));
+        uint8_t layoutType = static_cast<uint8_t>(kLayoutBootHot);
+        if (mplInfo.funProfileMap.empty()) {
+          layoutType = static_cast<uint8_t>(kLayoutBootHot);
+        } else if (startupProfile == mplInfo.funProfileMap.end()) {
+          layoutType = static_cast<uint8_t>(kLayoutRunHot);
+        } else if ((startupProfile->second).callTimes == item.callTimes) {
+          layoutType = static_cast<uint8_t>(kLayoutBootHot);
+        } else {
+          layoutType = static_cast<uint8_t>(kLayoutBothHot);
+        }
+        profileList.emplace_back(item.callTimes, layoutType, funcName);
+      }
+    }
+  };
+  pInvoker->mplInfoList.ForEach(handle);
+}
+
+// Dump the method undefine table of 'handle'.
+bool Debug::DumpMethodUndefSymbol(LinkerMFileInfo &mplInfo) {
+  size_t size = mplInfo.GetTblSize(kMethodUndef);
+  if (size == 0) {
+    LINKER_DLOG(mpllinker) << "failed, size is zero in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  LinkerAddrTableItem *pTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodUndef);
+  if (pTable == nullptr) {
+    LINKER_DLOG(mpllinker) << "failed, pTable is null in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  LinkerMuidTableItem *pMuidTable = mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodUndefMuid);
+  if (pMuidTable == nullptr) {
+    LINKER_DLOG(mpllinker) << "failed, pMuidTable is null in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  for (size_t i = 0; i < size; ++i) {
+    LinkerAddrTableItem item = pTable[i];
+    LinkerMuidTableItem muidItem = pMuidTable[i];
+    if (item.addr == 0) {
+      LINKER_LOG(INFO) << "(" << i << "), \tMUID = " << muidItem.muid.ToStr() << " in " << mplInfo.name << maple::endl;
+    }
+    LINKER_DLOG(mpllinker) << "(" << i << "), \taddr = " << item.addr << ", MUID = " << muidItem.muid.ToStr() <<
+        " in " << mplInfo.name << maple::endl;
+  }
+  return true;
+}
+
+// Dump the method define table of 'handle'.
+bool Debug::DumpMethodSymbol(LinkerMFileInfo &mplInfo) {
+  size_t size = mplInfo.GetTblSize(kMethodDef);
+  if (size == 0) {
+    LINKER_DLOG(mpllinker) << "failed, size is zero in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  LinkerAddrTableItem *pTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig);
+  if (pTable == nullptr) {
+    LINKER_DLOG(mpllinker) << "failed, pTable is null in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  LinkerMuidTableItem *pMuidTable = mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodDefMuid);
+  if (pMuidTable == nullptr) {
+    LINKER_DLOG(mpllinker) << "failed, pMuidTable is null in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  LinkerInfTableItem *pInfTable = mplInfo.GetTblBegin<LinkerInfTableItem*>(kMethodInfo);
+  if (pInfTable == nullptr) {
+    LINKER_DLOG(mpllinker) << "failed, pInfTable is null in " << mplInfo.name << maple::endl;
+    return false;
+  }
+
+  for (size_t i = 0; i < size; ++i) {
+    LinkerAddrTableItem *item = reinterpret_cast<LinkerAddrTableItem*>(pTable + i);
+    LinkerMuidTableItem *muidItem = reinterpret_cast<LinkerMuidTableItem*>(pMuidTable + i);
+    LinkerInfTableItem *infItem = reinterpret_cast<LinkerInfTableItem*>(pInfTable + i);
+    LINKER_LOG(INFO) << "(" << i << "), \tMUID=" << muidItem->muid.ToStr() << " in " << mplInfo.name << maple::endl;
+    LINKER_LOG(INFO) << "(" << i << "), \taddr=" << item->addr << " in " << mplInfo.name << maple::endl;
+    LINKER_LOG(INFO) << "(" << i << "), \tsize=" << infItem->size << " in " << mplInfo.name << maple::endl;
+    LINKER_LOG(INFO) << "(" << i << "), \tsym=" << GetMethodSymbolByOffset(*infItem) << " in " <<
+        mplInfo.name << maple::endl;
+  }
+  return true;
+}
+
+// Dump the data undefine table of 'handle'.
+bool Debug::DumpDataUndefSymbol(LinkerMFileInfo &mplInfo) {
+  size_t size = mplInfo.GetTblSize(kDataUndef);
+  if (size == 0) {
+    LINKER_LOG(ERROR) << "failed, size is zero, in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  LinkerAddrTableItem *pTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataUndef);
+  if (pTable == nullptr) {
+    LINKER_LOG(ERROR) << "failed, pTable is null, in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  LinkerMuidTableItem *pMuidTable = mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataUndefMuid);
+  if (pMuidTable == nullptr) {
+    LINKER_LOG(ERROR) << "failed, pMuidTable is null in " << mplInfo.name << maple::endl;
+    return false;
+  }
+
+  for (size_t i = 0; i < size; ++i) {
+    LinkerAddrTableItem item = pTable[i];
+    LinkerMuidTableItem muidItem = pMuidTable[i];
+    if (item.addr == 0) {
+      LINKER_LOG(INFO) << "(" << i << "), \tMUID=" << muidItem.muid.ToStr() << " in " << mplInfo.name << maple::endl;
+    }
+    LINKER_DLOG(mpllinker) << "(" << i << "), \taddr=" << item.addr << ", MUID=" << muidItem.muid.ToStr() << " in " <<
+        mplInfo.name << maple::endl;
+  }
+  return true;
+}
+
+// Dump the data define table of 'handle'.
+bool Debug::DumpDataSymbol(LinkerMFileInfo &mplInfo) {
+  size_t size = mplInfo.GetTblSize(kDataDef);
+  if (size == 0) {
+    LINKER_DLOG(mpllinker) << "failed, size is zero, in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  LinkerAddrTableItem *pTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig);
+  if (pTable == nullptr) {
+    LINKER_DLOG(mpllinker) << "failed, pTable is null, in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  LinkerMuidTableItem *pMuidTable = mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataDefMuid);
+  if (pMuidTable == nullptr) {
+    LINKER_LOG(ERROR) << "failed, pMuidTable is null in " << mplInfo.name << maple::endl;
+    return false;
+  }
+
+  for (size_t i = 0; i < size; ++i) {
+    LinkerAddrTableItem item = pTable[i];
+    LinkerMuidTableItem muidItem = pMuidTable[i];
+    LINKER_LOG(INFO) << "(" << i << "), \tMUID=" << muidItem.muid.ToStr() << " in " << mplInfo.name << maple::endl;
+    LINKER_LOG(INFO) << "(" << i << "), \taddr=" << item.addr << " in " << mplInfo.name << maple::endl;
+  }
+  return true;
+}
+
+// Lazy-Binding routines start
+void Debug::DumpStackInfoInLog() {
+  // We needn't care the performance of unwinding here.
+  std::vector<UnwindContext> uwContextStack;
+  // Unwind as many as possible till reaching the end.
+  MapleStack::FastRecordCurrentJavaStack(uwContextStack, MAPLE_STACK_UNWIND_STEP_MAX);
+
+  for (auto &uwContext : uwContextStack) {
+    if (!UnwindContextInterpEx::TryDumpStackInfoInLog(*pInvoker, uwContext)) {
+      if (uwContext.IsCompiledContext()) {
+        std::string methodName;
+        uwContext.frame.GetJavaMethodFullName(methodName);
+        LinkerMFileInfo *mplInfo =
+            pInvoker->GetLinkerMFileInfo(kFromAddr, reinterpret_cast<const void*>(uwContext.frame.ip));
+        if (mplInfo != nullptr) {
+          LINKER_LOG(INFO) << methodName << ":" << uwContext.frame.ip << ":" << mplInfo->name << maple::endl;
+        } else {
+          LINKER_LOG(INFO) << methodName << ":" << uwContext.frame.ip << ":NO_SO_NAME" << maple::endl;
+        }
+      }
+    }
+  }
+}
+
+uint64_t Debug::DumpMetadataSectionSize(std::ostream &os, void *handle, const std::string sectionName) {
+  std::ios::fmtflags f(os.flags());
+  std::string hotOrCold = (sectionName.find("hot") != std::string::npos) ? "hot" : "cold";
+  std::string startString = sectionName + "_begin";
+  std::string endString = sectionName + "_end";
+  void *end = GetSymbolAddr(handle, endString.c_str(), false);
+  void *start = GetSymbolAddr(handle, startString.c_str(), false);
+  uint64_t size = static_cast<uint64_t>(reinterpret_cast<char*>(end) - reinterpret_cast<char*>(start));
+  os << "\t" << startString << ": " << std::hex << start << "\n";
+  os << "\t" << hotOrCold << " " << sectionName << " size: " << size << "\n";
+  os.flags(f);
+  return size;
+}
+
+void Debug::DumpBBProfileInfo(std::ostream &os) {
+  auto handle = [&os](const LinkerMFileInfo &mplInfo) {
+    void *bbProfileTabStart = GetSymbolAddr(mplInfo.handle, kBBProfileTabBegin, true);
+    void *bbProfileTabEnd = GetSymbolAddr(mplInfo.handle, kBBProfileTabEnd, true);
+    size_t itemSize = (reinterpret_cast<size_t>(bbProfileTabEnd) -
+        reinterpret_cast<size_t>(bbProfileTabStart)) / sizeof(uint32_t);
+
+    char *bbProfileStrTabStart = static_cast<char*>(GetSymbolAddr(mplInfo.handle, kBBProfileStrTabBegin, true));
+    char *bbProfileStrTabEnd = reinterpret_cast<char*>(GetSymbolAddr(mplInfo.handle, kBBProfileStrTabEnd, true));
+    std::vector<std::string> profileStr;
+    std::string str(bbProfileStrTabStart, bbProfileStrTabEnd - bbProfileStrTabStart);
+    std::stringstream ss;
+    ss.str(str);
+    std::string item;
+    while (std::getline(ss, item, '\0')) {
+      profileStr.emplace_back(item);
+    }
+    if (profileStr.size() != itemSize) {
+      LOG(INFO) << "profileStr size " << profileStr.size() << " doestn't match item size " <<
+          itemSize << " in " << mplInfo.name << maple::endl;
+      LOG(INFO) << "profile Tab Start " << std::hex <<  bbProfileTabStart << " end " <<
+          bbProfileTabEnd << std::dec << maple::endl;
+      return;
+    }
+    uint32_t *bbProfileTab = reinterpret_cast<uint32_t*>(bbProfileTabStart);
+    for (size_t i = 0; i < itemSize; ++i) {
+      os << profileStr[i] << ":" << bbProfileTab[i] << "\n";
+    }
+  };
+  pInvoker->mplInfoList.ForEach(handle);
+}
+// Dump all the func IR  profile of all loaded maple-so
+void Debug::DumpAllMplFuncIRProfile(std::unordered_map<std::string, MFileIRProfInfo> &funcProfileRaw) {
+  auto handle = [&](LinkerMFileInfo &mplInfo) {
+    auto counterSize = mplInfo.GetTblSize(kFuncIRProfCounter);
+    auto counterTable = mplInfo.GetTblBegin<LinkerFuncProfileTableItem*>(kFuncIRProfCounter);
+    auto descSize = mplInfo.GetTblSize(kFuncIRProfDesc);
+    auto descTable = mplInfo.GetTblBegin<LinkerFuncProfDescItem*>(kFuncIRProfDesc);
+    VLOG(profiler) << mplInfo.name << " counter size " << counterSize << " desc size " << descSize << "\n";
+    if (!counterSize || !descSize) {
+      return;
+    }
+    auto &profileList = funcProfileRaw[mplInfo.name];
+    auto &descTab = profileList.descTab;
+    auto &counterTab = profileList.counterTab;
+    counterTab.reserve(counterSize);
+    LinkerInfTableItem *pInfTable = mplInfo.GetTblBegin<LinkerInfTableItem*>(kMethodInfo);
+    for (size_t i = 0; i < descSize; ++i) {
+      LinkerFuncProfDescItem descItem = descTable[i];
+      if ((descItem.start >= counterSize) || (descItem.end >= counterSize)) {
+        return;
+      }
+      LinkerInfTableItem *infItem = reinterpret_cast<LinkerInfTableItem*>(pInfTable + i);
+      std::string funcName = GetMethodSymbolByOffset(*infItem);
+      VLOG(profiler) << funcName << " counter range [" << descItem.start << "," << descItem.end << "]" << "\n";
+      descTab.emplace_back(funcName, descItem.hash, descItem.start, descItem.end);
+    }
+
+    for (size_t i = 0; i < counterSize; ++i) {
+      LinkerFuncProfileTableItem counterItem = counterTable[i];
+      counterTab.push_back(counterItem.callTimes);
+    }
+  };
+  pInvoker->mplInfoList.ForEach(handle);
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/linker/linker_gctib.cpp b/src/mrt/compiler-rt/src/linker/linker_gctib.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..89eee09311792e7995818ce7e469dba40c873dd6
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_gctib.cpp
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker_gctib.h"
+
+#include <dirent.h>
+#include <sys/mman.h>
+#include "base/logging.h"
+#include "collector/cp_generator.h"
+
+namespace maplert {
+// Get all offset of reference field.
+void RefCal(const MClass &klass, vector<uint64_t> &refOffsets, vector<uint64_t> &weakOffsets,
+    vector<uint64_t> &unownedOffsets, uint64_t &maxRefOffset) {
+  if (&klass == WellKnown::GetMClassObject()) {
+    return;
+  }
+  FieldMeta *fields = klass.GetFieldMetas();
+  uint32_t numOfField = klass.GetNumOfFields();
+  for (uint32_t i = 0; i < numOfField; ++i) {
+    FieldMeta *field = &fields[i];
+    if (field->IsPrimitive() || field->IsStatic()) {
+      continue;
+    }
+    uint64_t fieldOffset = field->GetOffset();
+    if (fieldOffset == 0) {
+      // skip first meta
+      continue;
+    }
+    if (fieldOffset > maxRefOffset) {
+      maxRefOffset = fieldOffset;
+    }
+    size_t fieldModifier = field->GetMod();
+    if (modifier::IsUnowned(fieldModifier)) {
+      unownedOffsets.push_back(fieldOffset);
+    } else if (modifier::IsWeakRef(fieldModifier)) {
+      weakOffsets.push_back(fieldOffset);
+    } else {
+      refOffsets.push_back(fieldOffset);
+    }
+  }
+
+  if (klass.GetNumOfSuperClasses() == 0) {
+    return;
+  }
+
+  if (klass.IsColdClass() && !klass.IsLazyBinding()) {
+    LinkerAPI::Instance().ResolveColdClassSymbol(klass.AsJclass());
+  }
+
+  MClass **superclassArray = klass.GetSuperClassArrayPtr();
+  MClass *superClass = superclassArray[0];
+  if (superClass != WellKnown::GetMClassObject() && !superClass->IsInterface()) {
+    RefCal(*superClass, refOffsets, weakOffsets, unownedOffsets, maxRefOffset);
+  }
+  return;
+}
+
+void DumpGctib(const struct GCTibGCInfo &gcTib) {
+  ostringstream oss;
+  for (size_t i = 0; i != gcTib.nBitmapWords; ++i) {
+    oss << std::hex << gcTib.bitmapWords[i] << '\t';
+  }
+  LOG(WARNING) << "[Gctib]headerProto:" << gcTib.headerProto <<
+      ", nBitmapWords:" << gcTib.nBitmapWords <<
+      ", bitmapWords:" << oss.str() << endl;
+}
+
+static inline uint64_t OffsetToMapWordIndex(uint64_t offset) {
+  return (offset / sizeof(reffield_t)) / kRefWordPerMapWord;
+}
+
+static inline uint64_t OffsetToInMapWordOffset(uint64_t offset) {
+  return ((offset / sizeof(reffield_t)) % kRefWordPerMapWord) * kBitsPerRefWord;
+}
+
+static void FillBitmapWords(vector<uint64_t> refOffsets, struct GCTibGCInfo *newGctibPtr, uint64_t refType) {
+  for (auto refOffset : refOffsets) {
+    uint64_t index = OffsetToMapWordIndex(refOffset);
+    uint64_t shift = OffsetToInMapWordOffset(refOffset);
+    newGctibPtr->bitmapWords[index] |= (refType << shift);
+  }
+}
+
+bool ReGenGctib(ClassMetadata *classInfo, bool forceUpdate) {
+  vector<uint64_t> refOffsets;
+  vector<uint64_t> weakOffsets;
+  vector<uint64_t> unownedOffsets;
+  uint64_t maxRefOffset = 0;
+  MClass *cls = reinterpret_cast<MClass*>(classInfo);
+  if (cls->IsInterface()) {
+    return false;
+  }
+  RefCal(*cls, refOffsets, weakOffsets, unownedOffsets, maxRefOffset);
+
+  struct GCTibGCInfo *gcInfo = reinterpret_cast<struct GCTibGCInfo*>(cls->GetGctib());
+  // construct new GCTIB
+  uint64_t nBitmapWords = 0;
+  if (maxRefOffset > 0) {
+    nBitmapWords = OffsetToMapWordIndex(maxRefOffset) + 1;
+  }
+  uint32_t gctibByteSize = static_cast<uint32_t>((nBitmapWords + 1) * sizeof(uint64_t));
+  struct GCTibGCInfo *newGctibPtr = reinterpret_cast<struct GCTibGCInfo*>(calloc(gctibByteSize, sizeof(char)));
+  if (newGctibPtr == nullptr) {
+    LOG(FATAL) << "malloc gctib failed" << endl;
+    return false;
+  }
+
+  // fill bitmap
+  FillBitmapWords(refOffsets, newGctibPtr, kNormalRefBits);
+  FillBitmapWords(weakOffsets, newGctibPtr, kWeakRefBits);
+  FillBitmapWords(unownedOffsets, newGctibPtr, kUnownedRefBits);
+  newGctibPtr->nBitmapWords = static_cast<uint32_t>(nBitmapWords);
+  if (gcInfo != nullptr) {
+    if (maxRefOffset > 0) {
+      newGctibPtr->headerProto = gcInfo->headerProto | kHasChildRef;
+    } else {
+      newGctibPtr->headerProto = gcInfo->headerProto & ~(kHasChildRef);
+    }
+    newGctibPtr->headerProto = newGctibPtr->headerProto & ~(kCyclePatternBit);
+    if ((!forceUpdate || VLOG_IS_ON(mpllinker)) && (gcInfo->nBitmapWords == nBitmapWords) &&
+        (memcmp(gcInfo, newGctibPtr, gctibByteSize) == 0)) {
+      free(newGctibPtr);
+      return false;
+    } else if (VLOG_IS_ON(mpllinker)) {
+      LOG(WARNING) << "[Gctib] ResolveClassGctib:" << cls->GetName() << " mismatch" << endl;
+      DumpGctib(*gcInfo);
+      DumpGctib(*newGctibPtr);
+    }
+  }
+  classInfo->gctib.SetGctibRef(newGctibPtr);
+  if (gcInfo != nullptr && Collector::Instance().Type() == kNaiveRC && ClassCycleManager::HasDynamicLoadPattern(cls)) {
+    free(gcInfo);
+    // delete the cls from dynamic_loaded_cycle_classes_
+    ClassCycleManager::DeleteDynamicLoadPattern(cls);
+  }
+  return true;
+}
+}
diff --git a/src/mrt/compiler-rt/src/linker/linker_hotfix.cpp b/src/mrt/compiler-rt/src/linker/linker_hotfix.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b5cb4beb4e9ebacf993bcd2d8bacd9ffc11a4d3a
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_hotfix.cpp
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker_hotfix.h"
+
+#include "linker/linker_model.h"
+#include "linker/linker_inline.h"
+#include "linker/linker_cache.h"
+#include "linker/linker.h"
+
+namespace maplert {
+using namespace linkerutils;
+FeatureName Hotfix::featureName = kFHotfix;
+bool Hotfix::ResetResolvedFlags(LinkerMFileInfo &mplInfo) {
+  LINKER_VLOG(mpllinker) << mplInfo.name << maple::endl;
+  mplInfo.SetFlag(kIsMethodDefResolved, false);
+  mplInfo.SetFlag(kIsVTabResolved, false);
+  mplInfo.SetFlag(kIsITabResolved, false);
+  mplInfo.SetFlag(kIsSuperClassResolved, false);
+  mplInfo.SetFlag(kIsGCRootListResolved, false);
+  mplInfo.SetFlag(kIsMethodRelocated, false);
+  mplInfo.SetFlag(kIsDataRelocated, false);
+  return true;
+}
+
+bool Hotfix::ReleaseCaches(LinkerMFileInfo &mplInfo) {
+  LINKER_VLOG(mpllinker) << mplInfo.name << maple::endl;
+#ifdef LINKER_RT_CACHE
+  pInvoker->Get<LinkerCache>()->RemoveAllTables(mplInfo);
+  pInvoker->Get<LinkerCache>()->FreeAllTables(mplInfo);
+#endif // LINKER_RT_CACHE
+  return true;
+}
+
+void Hotfix::SetClassLoaderParent(const MObject *classLoader, const MObject *newParent) {
+  LINKER_VLOG(hotfix) << classLoader << ", " << newParent << maple::endl;
+  pInvoker->ResetClassLoaderList(classLoader);
+  pInvoker->ResetClassLoaderList(newParent);
+  (void)(pInvoker->ForEachDoAction(this, &Hotfix::ResetResolvedFlags));
+  (void)(pInvoker->ForEachDoAction(this, &Hotfix::ReleaseCaches));
+  (void)(pInvoker->Get<Linker>()->HandleMethodSymbol());
+  (void)(pInvoker->Get<Linker>()->HandleDataSymbol());
+}
+
+void Hotfix::InsertClassesFront(const MObject *classLoader, const LinkerMFileInfo &mplInfo, const std::string &path) {
+  LINKER_VLOG(hotfix) << "insert path[" << path << "] in ClassLoader[" << classLoader << "], isLazyBinding=" <<
+      mplInfo.IsFlag(kIsLazy) << maple::endl;
+  if (!mplInfo.IsFlag(kIsLazy)) {
+    (void)(pInvoker->ForEachDoAction(this, &Hotfix::ResetResolvedFlags));
+    (void)(pInvoker->ForEachDoAction(this, &Hotfix::ReleaseCaches));
+    (void)(pInvoker->Get<Linker>()->HandleMethodSymbol());
+    (void)(pInvoker->Get<Linker>()->HandleDataSymbol());
+  }
+}
+
+void Hotfix::SetPatchPath(const std::string &path, int32_t mode) {
+  LINKER_VLOG(hotfix) << "set patch path[" << path << "], mode =" << mode << maple::endl;
+  patchPath = path;
+  patchMode = mode;
+}
+
+bool Hotfix::IsFrontPatchMode(const std::string &path) {
+  return (patchMode == 1 && path == patchPath) ? true : false; // 0 - classloader parent, 1 - dexpath list
+}
+
+std::string Hotfix::GetPatchPath() {
+  return patchPath;
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/linker/linker_info.cpp b/src/mrt/compiler-rt/src/linker/linker_info.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5c216fb368f004f88585f6895dc319f02024326a
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_info.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker_info.h"
+
+namespace maplert {
+MUID GetHash(const std::vector<LinkerMFileInfo*> &mplInfos, bool getSolidHash) {
+  std::stringstream sstream;
+  for (auto mplInfo : mplInfos) {
+    MUID &hash = getSolidHash ? mplInfo->hashOfDecouple : mplInfo->hash;
+#ifdef USE_64BIT_MUID
+    // 8 spaces to 64 bit
+    sstream << std::setfill('0') << std::setw(8) << std::hex << hash.data.words[1] <<
+        std::setfill('0') << std::setw(8) << std::hex << hash.data.words[0];
+#else
+    // 16 spaces to 32 bit
+    sstream << std::setfill('0') << std::setw(16) << std::hex << hash.data.words[1] <<
+        std::setfill('0') << std::setw(16) << std::hex << hash.data.words[0];
+#endif // USE_64BIT_MUID
+  }
+  auto str = sstream.str();
+  MUID muid;
+  linkerutils::GenerateMUID(str.data(), str.size(), muid);
+  return muid;
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/linker/linker_lazy_binding.cpp b/src/mrt/compiler-rt/src/linker/linker_lazy_binding.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e7ae688a2f1501a7b8db8c6c2580d7105a8949fc
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_lazy_binding.cpp
@@ -0,0 +1,1536 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker_lazy_binding.h"
+
+#include "linker/linker_model.h"
+#include "linker/linker_inline.h"
+#include "linker/linker_method_builder.h"
+#ifdef LINKER_DECOUPLE
+#include "linker/decouple/linker_decouple.h"
+#include "linker/decouple/linker_field.h"
+#include "linker/decouple/linker_gctib.h"
+#endif
+#include "loader_api.h"
+#include "loader/object_loader.h"
+#include "chelper.h"
+#include "object_base.h"
+#include "mrt_class_api.h"
+#include "mrt_reflection_method.h"
+#include "fieldmeta_inline.h"
+#include "exception/mrt_exception.h"
+#include "exception/stack_unwinder.h"
+#include "mrt_well_known.h"
+
+using namespace maple;
+
+namespace maplert {
+using namespace linkerutils;
+FeatureName LazyBinding::featureName = kFLazyBinding;
+// In most cases, decoupling routine don't call this function here.
+// We just add this procedure in case.
+bool LazyBinding::HandleSymbolForDecoupling(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, size_t index) {
+  BindingState state = GetAddrBindingState(addrSlice, index);
+  LINKER_VLOG(lazybinding) << "state=" << static_cast<int>(state) << ", addr=" << addrSlice.Data() << ", index=" <<
+      index << maple::endl;
+  return HandleSymbol(mplInfo, addrSlice.Data() + index, nullptr, state, true);
+}
+
+bool LazyBinding::HandleSymbol(const void *offset, const void *pc, BindingState state, bool fromSignal) {
+  LinkerMFileInfo *mplInfo = pInvoker->GetLinkerMFileInfo(kFromAddr, offset, true);
+  if (mplInfo == nullptr) {
+    pInvoker->DumpStackInfoInLog();
+    LINKER_DLOG(lazybinding) << "--end--/" << offset << ", " << static_cast<int>(state) << maple::endl;
+    LINKER_LOG(FATAL) << "failed, offset=" << offset << ", pc=" << pc << ", state=" << static_cast<int>(state) <<
+        ", mplInfo is null." << maple::endl;
+  }
+  return HandleSymbol(*mplInfo, offset, pc, state, fromSignal);
+}
+
+void LazyBinding::GetAddrAndMuidSlice(LinkerMFileInfo &mplInfo,
+    BindingState state, AddrSlice &addrSlice, MuidSlice &muidSlice, const void *offset) {
+  size_t tableSize = 0;
+  size_t muidSize = 0;
+  switch (state) {
+    case kBindingStateCinfUndef:
+    case kBindingStateDataUndef:
+      tableSize = mplInfo.GetTblSize(kDataUndef);
+      addrSlice = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataUndef), tableSize);
+      muidSize = mplInfo.GetTblSize(kDataUndefMuid);
+      muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataUndefMuid), muidSize);
+      break;
+    case kBindingStateCinfDef:
+    case kBindingStateDataDef:
+      tableSize = mplInfo.GetTblSize(kDataDef);
+      addrSlice = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDef), tableSize);
+      muidSize = mplInfo.GetTblSize(kDataDefMuid);
+      muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataDefMuid), muidSize);
+      break;
+    case kBindingStateMethodUndef:
+      tableSize = mplInfo.GetTblSize(kMethodUndef);
+      addrSlice = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodUndef), tableSize);
+      muidSize = mplInfo.GetTblSize(kMethodUndefMuid);
+      muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodUndefMuid), muidSize);
+      break;
+    case kBindingStateMethodDef:
+      tableSize = mplInfo.GetTblSize(kMethodDef);
+      addrSlice = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDef), tableSize);
+      muidSize = mplInfo.GetTblSize(kMethodDefMuid);
+      muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodDefMuid), muidSize);
+      break;
+    default:
+      LINKER_LOG(ERROR) << "failed, offset=" << offset << ", state=" << static_cast<int>(state) << maple::endl;
+      return;
+  }
+}
+
+void *LazyBinding::ResolveClassSymbolClassification(
+    LinkerMFileInfo &mplInfo, BindingState state, const AddrSlice &addrSlice, const MuidSlice &muidSlice,
+    const size_t &index, MObject *candidateClassLoader, bool &fromUpper, const void *pc, const void *offset) {
+  void *data = nullptr;
+  switch (state) {
+    case kBindingStateCinfUndef:
+      if (mplInfo.IsFlag(kIsLazy) && mplInfo.classLoader == nullptr) {
+        candidateClassLoader = pInvoker->GetClassLoaderByAddress(mplInfo, pc);
+        LINKER_VLOG(lazybinding) << "candidateClassLoader=" << candidateClassLoader << maple::endl;
+      }
+      data = ResolveClassSymbol(mplInfo, addrSlice, muidSlice, index, candidateClassLoader, fromUpper, false, true);
+      break;
+    case kBindingStateCinfDef:
+      data = ResolveClassSymbol(mplInfo, addrSlice, muidSlice, index, candidateClassLoader, fromUpper, true, true);
+      break;
+    case kBindingStateDataUndef:
+      data = ResolveDataSymbol(mplInfo, addrSlice, muidSlice, index, false);
+      break;
+    case kBindingStateDataDef:
+      data = ResolveDataSymbol(mplInfo, addrSlice, muidSlice, index, true);
+      break;
+    case kBindingStateMethodUndef:
+      data = ResolveMethodSymbol(mplInfo, addrSlice, muidSlice, index, false, true);
+      break;
+    case kBindingStateMethodDef:
+      data = ResolveMethodSymbol(mplInfo, addrSlice, muidSlice, index, true, true);
+      break;
+    default:
+      // Never reach here.
+      break;
+  }
+
+  if (data == nullptr) {
+    LINKER_LOG(ERROR) << "failed, data returns null, offset=" << offset << ", " << mplInfo.name << maple::endl;
+    pInvoker->DumpStackInfoInLog();
+  }
+  return data;
+}
+
+bool LazyBinding::HandleSymbol(
+    LinkerMFileInfo &mplInfo, const void *offset, const void *pc, BindingState state, bool fromSignal) {
+  LINKER_DLOG(lazybinding) << "--start--/" << offset << ", " << state << ", " << fromSignal << maple::endl;
+  AddrSlice addrSlice;
+  MuidSlice muidSlice;
+  GetAddrAndMuidSlice(mplInfo, state, addrSlice, muidSlice, offset);
+
+  if (pInvoker->GetMultiSoPendingCount() > 0) {
+    if (state == kBindingStateCinfUndef || state == kBindingStateDataUndef || state == kBindingStateMethodUndef) {
+      LINKER_LOG(ERROR) << "waiting for startup asynchronism procedure, " << "name=" << mplInfo.name <<
+          ", multiSoPendingCount=" << pInvoker->GetMultiSoPendingCount() << maple::endl;
+      (void)MRT_EnterSaferegion(!fromSignal);
+      while (pInvoker->GetMultiSoPendingCount() > 0) {
+        constexpr int oneMillisecond = 1000;
+        (void)usleep(oneMillisecond); // Sleep 1ms
+      }
+      (void)MRT_LeaveSaferegion();
+    }
+  }
+
+  size_t index = GetAddrIndex(mplInfo, addrSlice, offset);
+  if (GetAddrBindingState(addrSlice, index, true) == kBindingStateResolved) {
+    LINKER_VLOG(lazybinding) << "resolved, state=" << state << ", index=" << index << mplInfo.name << maple::endl;
+    return true;
+  }
+  if (index == static_cast<size_t>(-1)) {
+    pInvoker->DumpStackInfoInLog();
+    LINKER_LOG(FATAL) << "out of range, offset=" << offset << "|" << state << "|" << mplInfo.name << maple::endl;
+  }
+  bool fromUpper = false;
+  MObject *candidateClassLoader = nullptr;
+  void *data = ResolveClassSymbolClassification(
+      mplInfo, state, addrSlice, muidSlice, index, candidateClassLoader, fromUpper, pc, offset);
+
+  if (state == kBindingStateCinfUndef || state == kBindingStateCinfDef) {
+    if (!fromUpper) {
+      LinkerMFileInfo *tmpLinkerMFileInfo = pInvoker->GetLinkerMFileInfo(kFromMeta, data); // Not only lazy .so.
+      if (tmpLinkerMFileInfo != nullptr) {
+        LinkClassInternal(*tmpLinkerMFileInfo, static_cast<MClass*>(data), candidateClassLoader, true);
+      } else {
+        // If the class is from the Interpreter, it can not be found in the LinkerMFileInfos list.
+        // It's allowed to return success in this case and not to link it any more.
+        LINKER_VLOG(lazybinding) << "class is lazy but no defined MFileInfo, from Interpreter, " << " klass=" <<
+            data << ", name=" << reinterpret_cast<MClass*>(data)->GetName() << maple::endl;
+      }
+    }
+  }
+  if (SetAddrInAddrTable(addrSlice, index, reinterpret_cast<MClass*>(data)) == nullptr) {
+    LINKER_LOG(ERROR) << "set addr failed, addr = " << data << maple::endl;
+  }
+  LINKER_VLOG(lazybinding) << "resolved " << data << ", state=" << state << ", index=" << index <<
+      ", successfully in " << mplInfo.name << maple::endl;
+  return true;
+}
+
+size_t LazyBinding::GetAddrIndex(
+    const LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const void *offset) {
+  if (addrSlice.Data() > offset) {
+    LINKER_LOG(ERROR) << "failed, pTable=" << addrSlice.Data() << ", offset=" << offset << " in " << mplInfo.name <<
+        maple::endl;
+    return static_cast<size_t>(-1); // Maximum value of size_t means failure.
+  }
+
+  const LinkerAddrTableItem *pAddr = static_cast<LinkerAddrTableItem*>(const_cast<void*>(offset));
+  size_t index = static_cast<size_t>(pAddr - addrSlice.Data());
+  LINKER_VLOG(lazybinding) << "index=" << index << maple::endl;
+  return index;
+}
+
+BindingState LazyBinding::GetAddrBindingState(LinkerVoidType addr) {
+  int difference = static_cast<int>(reinterpret_cast<uint8_t*>(addr) - __BindingProtectRegion__);
+  if (difference >= static_cast<int>(kBindingStateCinfUndef) &&
+      difference < static_cast<int>(kBindingStateResolved)) {
+    return static_cast<BindingState>(difference);
+  } else {
+    return kBindingStateResolved;
+  }
+}
+
+BindingState LazyBinding::GetAddrBindingState(const AddrSlice &addrSlice, size_t index, bool isAtomic) {
+  if (isAtomic) {
+    LinkerOffsetType *tmp = const_cast<LinkerOffsetType*>(&addrSlice[index].addr);
+    LinkerVoidType addr = __atomic_load_n(tmp, __ATOMIC_ACQUIRE);
+    return GetAddrBindingState(addr);
+  } else {
+    return GetAddrBindingState(static_cast<LinkerVoidType>(addrSlice[index].addr));
+  }
+}
+
+BindingState LazyBinding::GetAddrBindingState(
+    const LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const void *offset) {
+  size_t index = GetAddrIndex(mplInfo, addrSlice, offset);
+  BindingState state = GetAddrBindingState(addrSlice, index);
+  return state;
+}
+
+// Set the 'addrSlice[index].data()' as 'klass'
+// addrSlice is data def|undef table, but not def original table.
+// Returns the value of 'klass' in void *type.
+inline void *LazyBinding::SetAddrInAddrTable(AddrSlice &addrSlice, size_t index, const MClass *addr) {
+  if (addr != nullptr) {
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+    __atomic_store_n(&addrSlice[index].addr, pInvoker->AddrToUint32(addr), __ATOMIC_RELEASE);
+#else
+    __atomic_store_n(&addrSlice[index].addr, reinterpret_cast<LinkerOffsetType>(addr), __ATOMIC_RELEASE);
+#endif // USE_32BIT_REF
+    return addrSlice[index].Address();
+  }
+  return nullptr;
+}
+
+void *LazyBinding::SetClassInDefAddrTable(size_t index, const MClass *klass) {
+  LinkerMFileInfo *mplInfo = pInvoker->GetLinkerMFileInfo(kFromMeta, klass, true);
+  size_t dataDefSize = mplInfo->GetTblSize(kDataDef);
+  AddrSlice dataDefSlice(mplInfo->GetTblBegin<LinkerAddrTableItem*>(kDataDef), dataDefSize);
+  return SetAddrInAddrTable(dataDefSlice, index, klass);
+}
+
+void *LazyBinding::SearchInUndef(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const MuidSlice &muidSlice,
+    size_t index, MObject *candidateClassLoader, bool &fromUpper, bool isDef, std::string className) {
+  void *res = nullptr;
+  LinkerMFileInfo *tmpLinkerMFileInfo = nullptr;
+  void *addr = LookUpDataSymbolAddressLazily(nullptr, muidSlice[index].muid, &tmpLinkerMFileInfo, true);
+  LINKER_LOG(WARNING) << "(" << (isDef ? "DEF" : "UNDEF") << "), double resolve MUID=" <<
+      muidSlice[index].muid.ToStr() << ", addr=" << addr << ", candidateClassLoader=" << candidateClassLoader <<
+      ", in " << mplInfo.name << maple::endl;
+  if (addr != nullptr) { // To check candidateClassLoader != nullptr?
+    if (className.empty()) {
+      className = reinterpret_cast<MClass*>(addr)->GetName();
+    }
+    res = ResolveClassSymbolInternal(
+        mplInfo, addrSlice, muidSlice, index, candidateClassLoader, fromUpper, isDef, className);
+    if (res == nullptr) {
+      LINKER_LOG(WARNING) << "(" << (isDef ? "DEF" : "UNDEF") << "), failed to double resolve MUID=" <<
+          muidSlice[index].muid.ToStr() << ", use addr=" << addr << ", candidateClassLoader=" <<
+          candidateClassLoader << ", in " << mplInfo.name << maple::endl;
+      MClass *pseudo = reinterpret_cast<MClass*>(addr);
+      res = reinterpret_cast<void*>(pseudo);
+      if (pseudo != nullptr && !MRT_IsClassInitialized(*pseudo)) {
+        LoaderAPI::Instance().SetClassCL(*pseudo, tmpLinkerMFileInfo->classLoader);
+      }
+      fromUpper = false;
+    }
+  }
+  return res;
+}
+
+void *LazyBinding::ResolveClassSymbolForAPK(LinkerMFileInfo &mplInfo, size_t index, bool &fromUpper, bool isDef) {
+  void *res = nullptr;
+  size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+  AddrSlice dataDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), dataDefSize);
+  MClass *klass = reinterpret_cast<MClass*>(GetDefTableAddress(mplInfo, dataDefSlice,
+      static_cast<size_t>(index), false));
+  res = reinterpret_cast<void*>(klass);
+  if (klass != nullptr && !MRT_IsClassInitialized(*klass)) {
+    LoaderAPI::Instance().SetClassCL(*klass, mplInfo.classLoader);
+    LINKER_VLOG(lazybinding) << isDef << "for apk loading, klass=" << klass->GetName() << "in" <<
+        mplInfo.name.c_str() << maple::endl;
+  }
+  fromUpper = false;
+  return res;
+}
+
+// Just resolve without checking.
+void *LazyBinding::ResolveClassSymbol(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const MuidSlice &muidSlice,
+    size_t index, MObject *candidateClassLoader, bool &fromUpper, bool isDef, bool clinit) {
+  void *res = nullptr;
+  // Optimize for app loading.
+  // WARNING: On the premise of that we've filtered out the class in APK,
+  //          which is already defined in boot class loader jar path.
+  if (isDef && GetAppLoadState() == kAppLoadBaseOnly) {
+    res = ResolveClassSymbolForAPK(mplInfo, index, fromUpper, isDef);
+    return res;
+  }
+
+  // Building class loader hierarchy.
+  ClassLoaderListT classLoaderList;
+  pInvoker->GetClassLoaderList(mplInfo, classLoaderList);
+  // Look up the address with class loader.
+  string className;
+  for (jobject &loader : classLoaderList) {
+    MClass *pseudo = nullptr;
+    MObject *classLoader = reinterpret_cast<MObject*>(loader);
+    if (isDef) {
+      // Check the real def table directly.
+      size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+      AddrSlice dataDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), dataDefSize);
+      pseudo = reinterpret_cast<MClass*>(GetDefTableAddress(mplInfo, dataDefSlice,
+          static_cast<size_t>(index), false));
+    } else {
+      // We must find the real cinfo firstly with its muid.
+      pseudo = reinterpret_cast<MClass*>(LookUpDataSymbolAddressLazily(classLoader, muidSlice[index].muid));
+    }
+    if (pseudo == nullptr) {
+      LINKER_VLOG(lazybinding) << isDef << ", pseudo=nil, not resolved MUID=" << muidSlice[index].muid.ToStr() <<
+          ", with classloader=" << classLoader << " in " << mplInfo.name << maple::endl;
+      continue;
+    }
+    className = pseudo->GetName();
+    void *tempRes = ResolveClassSymbolInternal(
+        mplInfo, addrSlice, muidSlice, index, classLoader, fromUpper, isDef, className);
+    if (tempRes != nullptr) {
+      res = tempRes;
+    }
+  }
+
+  // Add more searching without classloader for UNDEF.
+  if (!isDef && res == nullptr) {
+    res = SearchInUndef(mplInfo, addrSlice, muidSlice, index, candidateClassLoader, fromUpper, isDef, className);
+  }
+
+  if (res == nullptr) {
+    LINKER_LOG(ERROR) << "failed, className = " << className.c_str() << maple::endl;
+    char msg[256] = { 0 }; // 256 is maxBuffSize
+    (void)sprintf_s(msg, sizeof(msg), "No class definition found");
+    MRT_ThrowNoClassDefFoundErrorUnw(msg);
+    return nullptr;
+  }
+  // We will check if we can open (void)MRT_TryInitClass(res, false);
+  if (clinit && (static_cast<MClass*>(res)->IsLazyBinding())) {
+    LINKER_DLOG(lazybinding) << isDef << ", CLINIT for " << res << ", in " << mplInfo.name << maple::endl;
+  }
+  LINKER_VLOG(lazybinding) << isDef << ", success, res=" << res << " in " << mplInfo.name << maple::endl;
+  return res;
+}
+
+void *LazyBinding::ResolveClassSymbolInternal(
+    LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice, const MuidSlice &muidSlice,
+    size_t index, MObject *classLoader, bool &fromUpper, bool isDef, const std::string &className) {
+  void *res = nullptr;
+  MClass *klass = nullptr;
+  LoaderAPI *loader = const_cast<LoaderAPI*>(pInvoker->GetLoader());
+  klass = reinterpret_cast<MClass*>(loader->FindClass(className, SearchFilter(reinterpret_cast<jobject>(classLoader))));
+  if (klass != nullptr) {
+    LINKER_VLOG(lazybinding) << "(" << (isDef ? "DEF" : "UNDEF") << "), delegation, resolved MUID=" <<
+        muidSlice[index].muid.ToStr() << ", name=" << klass->GetName() << ", addr={" <<
+        addrSlice[index].Address() << "->" << klass << "},  with classloader=" << classLoader << " in " <<
+        mplInfo.name << ", cold=" << klass->IsColdClass() << ", lazy=" << klass->IsLazyBinding() << ", init=" <<
+        MRT_IsClassInitialized(*klass) << maple::endl;
+    res = reinterpret_cast<void*>(klass);
+    fromUpper = false;
+    return res;
+  } else {
+    MObject *bootClassLoader = reinterpret_cast<MObject*>(loader->GetBootClassLoaderInstance());
+    // Ignore lower classloaders
+    if (classLoader != nullptr && classLoader != bootClassLoader && !pInvoker->IsSystemClassLoader(classLoader)) {
+      klass = reinterpret_cast<MClass*>(pInvoker->InvokeClassLoaderLoadClass(*classLoader, className));
+      if (klass != nullptr) {
+        LINKER_VLOG(lazybinding) << "(" << (isDef ? "DEF" : "UNDEF") << "), route, resolved MUID=" <<
+            muidSlice[index].muid.ToStr() << ", name=" << klass->GetName() << ", addr={" <<
+            addrSlice[index].Address() << "->" << klass << "}, with classloader=" << classLoader << "/" <<
+            bootClassLoader << "/" << loader->GetSystemClassLoader() << " in " << mplInfo.name << ", cold=" <<
+            klass->IsColdClass() << ", lazy=" << klass->IsLazyBinding() << ", init=" <<
+            MRT_IsClassInitialized(*klass) << maple::endl;
+        LinkStaticSymbol(mplInfo, klass);
+        res = reinterpret_cast<void*>(klass);
+        fromUpper = true;
+        return res;
+      } else {
+        LINKER_VLOG(lazybinding) << "(" << (isDef ? "DEF" : "UNDEF") << "), route, not resolved MUID=" <<
+            muidSlice[index].muid.ToStr() << ", name=" << className << ", with classloader=" << classLoader <<
+            "/" << bootClassLoader <<  "/" << loader->GetSystemClassLoader() << " in " << mplInfo.name << maple::endl;
+      }
+    }
+  }
+  return nullptr;
+}
+
+void *LazyBinding::ResolveDataSymbol(const AddrSlice &addrSlice, const MuidSlice &muidSlice, size_t index, bool isDef) {
+  LinkerMFileInfo *mplInfo = pInvoker->GetLinkerMFileInfo(kFromAddr, &addrSlice, true);
+  if (mplInfo == nullptr) {
+    LINKER_LOG(ERROR) << "failed, " << addrSlice.Data() << ", mplInfo is null." << maple::endl;
+    return nullptr;
+  }
+  return ResolveDataSymbol(*mplInfo, addrSlice, muidSlice, index, isDef);
+}
+
+void *LazyBinding::ResolveDataSymbol(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice,
+    const MuidSlice &muidSlice, size_t index, bool isDef) {
+  void *res = nullptr;
+  // Optimize for app loading.
+  // WARNING: On the premise of that we've filtered out the class in APK,
+  //          which is already defined in boot class loader jar path.
+  if (isDef) {
+    if (GetAppLoadState() == kAppLoadBaseOnly) {
+      size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+      AddrSlice dataDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), dataDefSize);
+      res = GetDefTableAddress(mplInfo, dataDefSlice, static_cast<size_t>(index), false);
+      LINKER_DLOG(lazybinding) << isDef << ", optimized for App, resolved MUID=" << muidSlice[index].muid.ToStr() <<
+          ", addr={" << addrSlice[index].Address() << "->" << res << "} in " << mplInfo.name << maple::endl;
+      return res;
+    }
+  }
+
+  // Building class loader hierarchy.
+  ClassLoaderListT classLoaderList;
+  pInvoker->GetClassLoaderList(mplInfo, classLoaderList);
+  for (jobject &classLoader : classLoaderList) { // Look up the address.
+    void *addr = LookUpDataSymbolAddressLazily(reinterpret_cast<MObject*>(classLoader), muidSlice[index].muid);
+    if (addr != nullptr) {
+      LINKER_VLOG(lazybinding) << isDef << ", resolved MUID=" << muidSlice[index].muid.ToStr() << ", addr={" <<
+          addrSlice[index].Address() << "->" << addr << "}, in " << mplInfo.name << maple::endl;
+      res = addr;
+    }
+  }
+  if (!isDef && res == nullptr) { // Add more searching without classloader for UNDEF.
+    LinkerMFileInfo *tmpLinkerMFileInfo = nullptr;
+    void *addr = LookUpDataSymbolAddressLazily(nullptr, muidSlice[index].muid, &tmpLinkerMFileInfo, true);
+    if (addr != nullptr) {
+      LINKER_LOG(WARNING) << isDef << ", double resolve MUID=" << muidSlice[index].muid.ToStr() << ", addr=" << addr <<
+          ", in " << mplInfo.name << ", from " << tmpLinkerMFileInfo->name << maple::endl;
+      res = addr;
+    }
+  }
+
+  if (res == nullptr) {
+    LINKER_LOG(ERROR) << isDef << ", failed to resolve MUID=" << muidSlice[index].muid.ToStr() << " in " <<
+        mplInfo.name << maple::endl;
+    char msg[256] = { 0 }; // 256 is maxBuffSize
+    (void)sprintf_s(msg, sizeof(msg), "No static field MUID:%s found in the class",
+        muidSlice[index].muid.ToStr().c_str());
+    MRT_ThrowNoSuchFieldErrorUnw(msg);
+  }
+  return res;
+}
+
+void *LazyBinding::ResolveMethodSymbol(
+    const AddrSlice &addrSlice, const MuidSlice &muidSlice, size_t index, bool isDef) {
+  LinkerMFileInfo *mplInfo = pInvoker->GetLinkerMFileInfo(kFromAddr, &addrSlice, true);
+  if (mplInfo == nullptr) {
+    LINKER_LOG(ERROR) << "failed, " << addrSlice.Data() << ", mplInfo is null." << maple::endl;
+    return nullptr;
+  }
+  return ResolveMethodSymbol(*mplInfo, addrSlice, muidSlice, index, isDef, true);
+}
+
+void *LazyBinding::ResolveMethodSymbol(LinkerMFileInfo &mplInfo, const AddrSlice &addrSlice,
+    const MuidSlice &muidSlice, size_t index, bool isDef, bool forClass) {
+  void *res = nullptr;
+  // Optimize for app loading.
+  // WARNING: On the premise of that we've filtered out the class in APK,
+  //          which is already defined in boot class loader jar path.
+  if (isDef) {
+    if (GetAppLoadState() == kAppLoadBaseOnly) {
+      size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+      AddrSlice dataDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig), dataDefSize);
+      res = GetDefTableAddress(mplInfo, dataDefSlice, static_cast<size_t>(index), true);
+      LINKER_DLOG(lazybinding) << isDef << forClass << ", MUID=" << muidSlice[index].muid.ToStr() <<
+          ", addr={" << addrSlice[index].Address() << "->" << res << "} in " << mplInfo.name << maple::endl;
+#ifdef LINKER_LAZY_BINDING_METHOD_TO_CLASS
+      if (forClass) {
+        ResolveMethodsClassSymbol(mplInfo, isDef, res);
+      }
+#endif // LINKER_LAZY_BINDING_METHOD_TO_CLASS
+      return res;
+    }
+  }
+
+  ClassLoaderListT classLoaderList; // Building class loader hierarchy.
+  pInvoker->GetClassLoaderList(mplInfo, classLoaderList);
+  for (jobject &classLoader : classLoaderList) { // Look up the address with class loader.
+    void *tempRes = LookUpMethodSymbolAddressLazily(reinterpret_cast<MObject*>(classLoader), muidSlice[index].muid);
+    if (tempRes != nullptr) {
+      LINKER_VLOG(lazybinding) << isDef << ", MUID=" << muidSlice[index].muid.ToStr() << ", addr={" <<
+          addrSlice[index].Address() << "->" << tempRes << "}, in " << mplInfo.name << maple::endl;
+#ifdef LINKER_LAZY_BINDING_METHOD_TO_CLASS
+      if (forClass) {
+        ResolveMethodsClassSymbol(mplInfo, isDef, tempRes);
+      }
+#endif // LINKER_LAZY_BINDING_METHOD_TO_CLASS
+      res = tempRes;
+    }
+  }
+
+  if (!isDef && res == nullptr) { // Add more searching without classloader for UNDEF.
+    res = LookUpMethodSymbolAddressLazily(nullptr, muidSlice[index].muid, true);
+    LINKER_LOG(WARNING) << isDef << ", double resolve MUID=" << muidSlice[index].muid.ToStr() << ", addr=" << res <<
+        " in " << mplInfo.name << maple::endl;
+#ifdef LINKER_LAZY_BINDING_METHOD_TO_CLASS
+    if (res != nullptr && forClass) {
+      ResolveMethodsClassSymbol(mplInfo, isDef, res);
+    }
+#endif // LINKER_LAZY_BINDING_METHOD_TO_CLASS
+  }
+
+  if (res == nullptr) {
+    char msg[256] = { 0 }; // 256 is maxBuffSize
+    (void)sprintf_s(msg, sizeof(msg), "No method MUID:%s found in the class", muidSlice[index].muid.ToStr().c_str());
+    MRT_ThrowNoSuchMethodErrorUnw(msg);
+  }
+  return res;
+}
+
+MClass *LazyBinding::GetUnresolvedClass(MClass *klass, bool &fromUpper, bool isDef) {
+  // The klass must be DEF, of course.
+  LinkerMFileInfo *mplInfo = pInvoker->GetLinkerMFileInfo(kFromMeta, static_cast<void*>(klass), true);
+  if (mplInfo == nullptr) {
+    LINKER_LOG(FATAL) << "LinkerMFileInfo not found in lazy list, klass=" << klass << "name = " <<
+        klass->GetName()<< maple::endl;
+    return nullptr;
+  }
+  size_t dataDefSize = mplInfo->GetTblSize(kDataDef);
+  AddrSlice dataDefSlice(mplInfo->GetTblBegin<LinkerAddrTableItem*>(kDataDef), dataDefSize);
+  size_t muidSize = mplInfo->GetTblSize(kDataDefMuid);
+  MuidSlice muidSlice = MuidSlice(mplInfo->GetTblBegin<LinkerMuidTableItem*>(kDataDefMuid), muidSize);
+
+  // To get the index in the pTable
+  MClass *indexClass = klass->GetClass();
+  uint32_t defIndex = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(indexClass));
+  if (defIndex == 0) { // It's not lazy, we use 0 as flag of not lazy.
+    LINKER_LOG(FATAL) << "class is lazy, but no def index?klass=" << klass << "name=" << klass->GetName()<< maple::endl;
+    return nullptr;
+  } else {
+    if (indexClass == WellKnown::GetMClassClass()) {
+      return nullptr;
+    }
+    --defIndex;
+  }
+
+  if (GetAddrBindingState(dataDefSlice, defIndex, true) == kBindingStateResolved) {
+    return nullptr;
+  }
+  return reinterpret_cast<MClass*>(ResolveClassSymbol(
+      *mplInfo, dataDefSlice, muidSlice, defIndex, nullptr, fromUpper, isDef, true));
+}
+
+void LazyBinding::ResolveMethodsClassSymbol(const LinkerMFileInfo &mplInfo, bool isDef, const void *addr) {
+  // To get the declaring class of the method.
+  void *md = JavaFrame::GetMethodMetadata(static_cast<const uint32_t*>(addr));
+  if (md != nullptr) {
+    const MethodMetaBase *methodMeta = reinterpret_cast<const MethodMetaBase*>(md);
+    void *classAddr = methodMeta->GetDeclaringClass();
+    MClass *klass = static_cast<MClass*>(classAddr);
+    if (klass == nullptr) {
+      LINKER_LOG(FATAL) << "klass is nullptr" << maple::endl;
+    }
+    LINKER_VLOG(lazybinding) << "(" << (isDef ? "DEF" : "UNDEF") << "), to resolve klass=" << klass << ", name=" <<
+        klass->GetName() << ", prim=" << klass->IsPrimitiveClass() << ", array=" << klass->IsArray() << ", cold=" <<
+        modifier::IsColdClass(klass->GetFlag()) << ", lazy=" << klass->IsLazyBinding() <<
+        ", in " << mplInfo.name << maple::endl;
+    if (!klass->IsPrimitiveClass() && !klass->IsArrayClass() && klass->IsLazyBinding()) {
+      bool fromUpper = false;
+      MClass *unresolvedClass = GetUnresolvedClass(klass, fromUpper, isDef);
+      if (unresolvedClass == nullptr) {
+        LINKER_LOG(ERROR) << "(" << (isDef ? "DEF" : "UNDEF") << "), class is lazy, but no def index? klass=" <<
+            klass << ", name=" << klass->GetName() << maple::endl;
+        // Should not reach here?
+        return;
+      } else {
+        if (!fromUpper) {
+          LINKER_VLOG(lazybinding) << "(" << (isDef ? "DEF" : "UNDEF") << "), found class, unresolved class=" <<
+              unresolvedClass << ", class name=" << unresolvedClass->GetName() << maple::endl;
+          // Not only lazy .so.
+          LinkerMFileInfo *tmpLinkerMFileInfo = pInvoker->GetLinkerMFileInfo(kFromMeta, unresolvedClass);
+          if (tmpLinkerMFileInfo != nullptr) {
+            LinkClassInternal(*tmpLinkerMFileInfo, unresolvedClass, nullptr, true);
+          } else {
+            LINKER_LOG(FATAL) << "class is lazy, but no lazy LinkerMFileInfo?" << " klass=" << unresolvedClass <<
+                ", name=" << unresolvedClass->GetName() << maple::endl;
+          }
+          return;
+        } else {
+          // We don't set the method address any more.
+          LINKER_VLOG(lazybinding) << "(" << (isDef ? "DEF" : "UNDEF") << "), not set the method address for klass=" <<
+              klass << ", name=" << klass->GetName() << maple::endl;
+        }
+      }
+    } else {
+      // Already resolved the class before, just set address for the method.
+      return;
+    }
+  } else {
+    LINKER_LOG(FATAL) << "(" << (isDef ? "DEF" : "UNDEF") << "), md is null, addr=" << addr << maple::endl;
+  }
+  return;
+}
+
+void LazyBinding::LinkStaticSymbol(LinkerMFileInfo &mplInfo, const MClass *target) {
+  LazyBinding::LinkStaticMethod(mplInfo, target);
+  LazyBinding::LinkStaticField(mplInfo, target);
+}
+
+void LazyBinding::LinkStaticMethodSlow(MethodMeta &meta, std::string name,
+    LinkerMFileInfo &mplInfo, LinkerMFileInfo &oldMplInfo, AddrSlice &srcTable, AddrSlice &dstTable) {
+  MethodMeta *method = &meta;
+  LinkerVoidType dstAddr = 0;
+  size_t iSrcIndex = 0;
+  size_t iDstIndex = 0;
+  std::string methodName = name;
+  methodName += "|";
+  methodName += method->GetName();
+  methodName += "|";
+  methodName += method->GetSignature();
+  std::string encodedMethodName = namemangler::EncodeName(methodName);
+  MUID methodMuid = GetMUID(encodedMethodName, true);
+  LinkerVoidType srcAddr = pInvoker->LookUpMethodSymbolAddress(oldMplInfo, methodMuid, iSrcIndex);
+  if (UNLIKELY(&oldMplInfo != &mplInfo)) {
+    dstAddr = pInvoker->LookUpMethodSymbolAddress(mplInfo, methodMuid, iDstIndex);
+  } else {
+    dstAddr = srcAddr;
+    iDstIndex = iSrcIndex;
+  }
+  if (srcAddr != 0) {
+    void *addr = reinterpret_cast<void*>(srcAddr);
+    LINKER_VLOG(lazybinding) << "resolved MUID=" << methodMuid.ToStr() << ", Address=" << dstAddr <<
+        ", copy form srcAddr=" << srcTable[iSrcIndex].Address() << ", srcIndex=" << iSrcIndex << " to dstAddr=" <<
+        dstTable[iDstIndex].Address() << ", dstIndex=" << iDstIndex << ", methodName=" << methodName <<
+        ", form mplInfo=" << oldMplInfo.name << " to mplInfo=" << mplInfo.name << maple::endl;
+    if (SetAddrInAddrTable(dstTable, iDstIndex, reinterpret_cast<MClass*>(addr)) == nullptr) {
+      LINKER_LOG(ERROR) << "set addr failed, addr = " << addr << maple::endl;
+    }
+  } else {
+    LINKER_LOG(ERROR) << "failed to resolve MUID=" << methodMuid.ToStr() << ", Address=" << dstAddr <<
+        ", encodedMethodName=" << encodedMethodName << ", srcAddr=" << srcTable[iSrcIndex].Address() <<
+        ", srcIndex" << iSrcIndex << ", methodName=" << methodName.c_str() << ", from mplInfo=" <<
+        oldMplInfo.name << " to mplInfo=" << mplInfo.name << maple::endl;
+  }
+}
+
+void LazyBinding::LinkStaticMethodFast(MethodMeta &meta, const std::string name, size_t index,
+    LinkerMFileInfo &mplInfo, const LinkerMFileInfo &oldMplInfo, AddrSlice &srcTable, AddrSlice &dstTable) {
+  MethodMeta *method = &meta;
+  LinkerVoidType dstAddr = 0;
+  size_t iSrcIndex = index;
+  size_t iDstIndex = 0;
+  std::string methodName = name;
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+  LinkerVoidType methodSrcAddr = pInvoker->AddrToUint32(GetDefTableAddress(mplInfo, srcTable, iSrcIndex, true));
+#else
+  LinkerVoidType methodSrcAddr =
+      reinterpret_cast<LinkerVoidType>(GetDefTableAddress(mplInfo, srcTable, iSrcIndex, true));
+#endif // USE_32BIT_REF
+  if (methodSrcAddr != 0) {
+    method->SetAddress(methodSrcAddr);
+    dstAddr = methodSrcAddr;
+    if (UNLIKELY(&oldMplInfo != &mplInfo)) {
+      methodName += "|";
+      methodName += method->GetName();
+      methodName += "|";
+      methodName += method->GetSignature();
+      std::string encodedMethodName = namemangler::EncodeName(methodName);
+      MUID methodMuid = GetMUID(encodedMethodName, true);
+      dstAddr = pInvoker->LookUpMethodSymbolAddress(mplInfo, methodMuid, iDstIndex);
+      if (SetAddrInAddrTable(dstTable, iDstIndex, reinterpret_cast<MClass*>(methodSrcAddr)) == nullptr) {
+        LINKER_LOG(ERROR) << "set addr failed, addr = " << methodSrcAddr << maple::endl;
+      }
+    } else {
+      iDstIndex = iSrcIndex;
+      if (SetAddrInAddrTable(dstTable, iDstIndex, reinterpret_cast<MClass*>(methodSrcAddr)) == nullptr) {
+        LINKER_LOG(ERROR) << "set addr failed, addr = " << methodSrcAddr << maple::endl;
+      }
+    }
+    LINKER_VLOG(lazybinding) << "resolved " << ", Address=" << dstAddr << ", copy form methodSrcAddr=" <<
+        srcTable[iSrcIndex].Address() << ", srcIndex=" << iSrcIndex << " to dstAddr=" <<
+        dstTable[iDstIndex].Address() << ", dstIndex=" << iDstIndex << ", methodName=" <<
+        methodName << ", form mplInfo=" << oldMplInfo.name << " to mplInfo=" << mplInfo.name << maple::endl;
+  } else {
+    LINKER_LOG(ERROR) << "failed to resolve " << ", Address=" << methodSrcAddr << ", methodSrcAddr=" <<
+        srcTable[iSrcIndex].Address() << ", srcIndex" << iSrcIndex << ", methodName=" << methodName <<
+        ", from mplInfo=" << oldMplInfo.name << " to mplInfo=" << mplInfo.name << maple::endl;
+  }
+}
+
+// In maple, actually all methods are linked to static symbols.
+void LazyBinding::LinkStaticMethod(LinkerMFileInfo &mplInfo, const MClass *target) {
+  if (UNLIKELY(target == nullptr)) {
+    LINKER_DLOG(lazybinding) << "failed, target is null!" << maple::endl;
+    return;
+  }
+  LinkerMFileInfo *oldMplInfo = pInvoker->GetLinkerMFileInfo(kFromMeta, target);
+  size_t iTableSize = 0;
+  AddrSlice srcTable;
+  AddrSlice dstTable;
+  if (oldMplInfo == nullptr) {
+    oldMplInfo = &mplInfo;
+  }
+  if (UNLIKELY(oldMplInfo != &mplInfo)) {
+    iTableSize = oldMplInfo->GetTblSize(kMethodDefOrig);
+    size_t dstTableSize = mplInfo.GetTblSize(kMethodDef);
+    srcTable = AddrSlice(oldMplInfo->GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig), iTableSize);
+    dstTable = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDef), dstTableSize);
+  } else {
+    iTableSize = mplInfo.GetTblSize(kMethodDefOrig);
+    srcTable = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig), iTableSize);
+    dstTable = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDef), iTableSize);
+  }
+  if (dstTable.Empty() || srcTable.Empty()) {
+    LINKER_DLOG(lazybinding) << "failed, table is null" << maple::endl;
+    return;
+  }
+  MethodMeta *methods = target->GetMethodMetas();
+  uint32_t numOfMethods = target->GetNumOfMethods();
+  for (uint32_t i = 0; i < numOfMethods; ++i) {
+    MethodMeta *method = methods + i;
+    // Consider as the case of default methods, we don't check if (__MRT_Class_isInterface(target)).
+    if (method == nullptr || UNLIKELY(method->IsAbstract())) {
+      continue;
+    }
+    std::string methodName = target->GetName();
+    int32_t index = method->GetDefTabIndex();
+    if (index != -1) {
+      size_t offset = static_cast<size_t>(index);
+      if (offset >= iTableSize) {
+        continue;
+      }
+      LinkStaticMethodFast(*method, methodName, offset, mplInfo, *oldMplInfo, srcTable, dstTable);
+    } else {
+      LinkStaticMethodSlow(*method, methodName, mplInfo, *oldMplInfo, srcTable, dstTable);
+    }
+  }
+}
+
+void LazyBinding::LinkStaticFieldSlow(FieldMeta &meta, std::string name,
+    LinkerMFileInfo &mplInfo, LinkerMFileInfo &oldMplInfo, AddrSlice &srcTable, AddrSlice &dstTable) {
+  FieldMeta *field = &meta;
+  LinkerVoidType dstAddr = 0;
+  size_t iSrcIndex = 0;
+  size_t iDstIndex = 0;
+  std::string fieldName = name;
+  fieldName += "|";
+  fieldName += field->GetName();
+  std::string encodedFieldName = namemangler::EncodeName(fieldName);
+  MUID fieldMuid = GetMUID(encodedFieldName, true);
+  LinkerVoidType srcAddr = pInvoker->LookUpDataSymbolAddress(oldMplInfo, fieldMuid, iSrcIndex);
+  if (UNLIKELY(&oldMplInfo != &mplInfo)) {
+    dstAddr = pInvoker->LookUpDataSymbolAddress(mplInfo, fieldMuid, iDstIndex);
+  } else {
+    dstAddr = srcAddr;
+    iDstIndex = iSrcIndex;
+  }
+  if (srcAddr != 0) {
+    void *addr = reinterpret_cast<void*>(srcAddr);
+    LINKER_VLOG(lazybinding) << "resolved MUID=" << fieldMuid.ToStr() << ", Address=" << dstAddr <<
+        ", copy form srcAddr=" << srcTable[iSrcIndex].Address() << ", srcIndex=" << iSrcIndex << " to dstAddr=" <<
+        dstTable[iDstIndex].Address() << ", dstIndex=" << iDstIndex << ", fieldName=" << fieldName <<
+        ", form mplInfo=" << oldMplInfo.name << " to mplInfo=" << mplInfo.name << maple::endl;
+    if (SetAddrInAddrTable(dstTable, iDstIndex, reinterpret_cast<MClass*>(addr)) == nullptr) {
+      LINKER_LOG(ERROR) << "set addr failed, addr = " << addr << maple::endl;
+    }
+  } else {
+    LINKER_LOG(ERROR) << "failed to resolve MUID=" << fieldMuid.ToStr() << ", Address=" << dstAddr <<
+        ", encodedFieldName=" << encodedFieldName << ", srcAddr=" << srcTable[iSrcIndex].Address() << ", srcIndex" <<
+        iSrcIndex << ", fieldName=" << fieldName.c_str() << ", from mplInfo=" << oldMplInfo.name <<
+        " to mplInfo=" << mplInfo.name << maple::endl;
+  }
+}
+
+void LazyBinding::LinkStaticFieldFast(FieldMeta &meta, const std::string name, size_t index,
+    LinkerMFileInfo &mplInfo, const LinkerMFileInfo &oldMplInfo, AddrSlice &srcTable, AddrSlice &dstTable) {
+  FieldMeta *field = &meta;
+  LinkerVoidType dstAddr = 0;
+  size_t iSrcIndex = index;
+  size_t iDstIndex = 0;
+  std::string fieldName = name;
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+  LinkerVoidType fieldSrcAddr = pInvoker->AddrToUint32(GetDefTableAddress(mplInfo, srcTable, iSrcIndex, false));
+#else
+  LinkerVoidType fieldSrcAddr =
+      reinterpret_cast<LinkerVoidType>(GetDefTableAddress(mplInfo, srcTable, iSrcIndex, false));
+#endif // USE_32BIT_REF
+  if (fieldSrcAddr != 0) {
+    field->SetStaticAddr(fieldSrcAddr);
+    dstAddr = fieldSrcAddr;
+    if (UNLIKELY(&oldMplInfo != &mplInfo)) {
+      fieldName += "|";
+      fieldName += field->GetName();
+      std::string encodedFieldName = namemangler::EncodeName(fieldName);
+      MUID fieldMuid = GetMUID(encodedFieldName, true);
+      dstAddr = pInvoker->LookUpDataSymbolAddress(mplInfo, fieldMuid, iDstIndex);
+      if (SetAddrInAddrTable(dstTable, iDstIndex, reinterpret_cast<MClass*>(fieldSrcAddr)) == nullptr) {
+        LINKER_LOG(ERROR) << "set addr failed, addr = " << fieldSrcAddr << maple::endl;
+      }
+    } else {
+      iDstIndex = iSrcIndex;
+      if (SetAddrInAddrTable(dstTable, iDstIndex, reinterpret_cast<MClass*>(fieldSrcAddr)) == nullptr) {
+        LINKER_LOG(ERROR) << "set addr failed, addr = " << fieldSrcAddr << maple::endl;
+      }
+    }
+    LINKER_VLOG(lazybinding) << "resolved " << ", Address=" << dstAddr << ", copy form fieldSrcAddr=" <<
+        srcTable[iSrcIndex].Address() << ", srcIndex=" << iSrcIndex << " to dstAddr=" <<
+        dstTable[iDstIndex].Address() << ", dstIndex=" << iDstIndex << ", fieldName=" <<
+        fieldName << ", form mplInfo=" << oldMplInfo.name << " to mplInfo=" << mplInfo.name << maple::endl;
+  } else {
+    LINKER_LOG(ERROR) << "failed to resolve " << ", Address=" << fieldSrcAddr << ", fieldSrcAddr=" <<
+        srcTable[iSrcIndex].Address() << ", srcIndex" << iSrcIndex << ", fieldName=" << fieldName <<
+        ", from mplInfo=" << oldMplInfo.name << " to mplInfo=" << mplInfo.name << maple::endl;
+  }
+}
+
+void LazyBinding::LinkStaticField(LinkerMFileInfo &mplInfo, const MClass *target) {
+  if (UNLIKELY(target == nullptr)) {
+    LINKER_DLOG(lazybinding) << "failed, target is null!" << maple::endl;
+    return;
+  }
+  size_t iTableSize = 0;
+  AddrSlice srcTable;
+  AddrSlice dstTable;
+  LinkerMFileInfo *oldMplInfo = pInvoker->GetLinkerMFileInfo(kFromMeta, target);
+  if (oldMplInfo == nullptr) {
+    oldMplInfo = &mplInfo;
+  }
+  if (UNLIKELY(oldMplInfo != &mplInfo)) {
+    iTableSize = oldMplInfo->GetTblSize(kDataDefOrig);
+    size_t dstTableSize = mplInfo.GetTblSize(kDataDef);
+    srcTable = AddrSlice(oldMplInfo->GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), iTableSize);
+    dstTable = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDef), dstTableSize);
+  } else {
+    iTableSize = mplInfo.GetTblSize(kDataDefOrig);
+    srcTable = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), iTableSize);
+    dstTable = AddrSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDef), iTableSize);
+  }
+  if (dstTable.Empty() || srcTable.Empty()) {
+    LINKER_DLOG(lazybinding) << "failed, table is null" << maple::endl;
+    return;
+  }
+  FieldMeta *fields = target->GetFieldMetas();
+  uint32_t numOfFields = target->GetNumOfFields();
+  for (uint32_t i = 0; i < numOfFields; ++i) {
+    FieldMeta *field = fields + i;
+    // Not check !field->IsPublic() any more.
+    if (field == nullptr || !field->IsStatic()) {
+      continue;
+    }
+    std::string fieldName = target->GetName();
+    int32_t index = field->GetDefTabIndex();
+    if (index != -1) {
+      size_t offset = static_cast<size_t>(index);
+      if (offset >= iTableSize) {
+        continue;
+      }
+      LinkStaticFieldFast(*field, fieldName, offset, mplInfo, *oldMplInfo, srcTable, dstTable);
+    } else {
+      LinkStaticFieldSlow(*field, fieldName, mplInfo, *oldMplInfo, srcTable, dstTable);
+    }
+  }
+}
+
+void LazyBinding::LinkSuperClassAndInterfaces(
+    const MClass *klass, MObject *candidateClassLoader, bool recursive, bool forCold) {
+  LinkerMFileInfo *mplInfo = pInvoker->GetLinkerMFileInfo(kFromMeta, klass, !forCold);
+  if (mplInfo != nullptr && (forCold || mplInfo->IsFlag(kIsLazy))) {
+    LinkSuperClassAndInterfaces(*mplInfo, klass, candidateClassLoader, recursive, forCold);
+  }
+}
+
+MClass *LazyBinding::LinkDataUndefSuperClassAndInterfaces(
+    LinkerMFileInfo &mplInfo, MObject *candidateClassLoader, size_t index, AddrSlice dataUndefSlice,
+    MClass *superClassesItem, IndexSlice superTableSlice, uint32_t i, bool fromUndef) {
+  size_t muidSize = mplInfo.GetTblSize(kDataUndefMuid);
+  MuidSlice muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataUndefMuid), muidSize);
+  if (GetAddrBindingState(dataUndefSlice, index, true) != kBindingStateResolved) {
+    bool fromUpper = false;
+    superClassesItem = reinterpret_cast<MClass*>(ResolveClassSymbol(
+        mplInfo, dataUndefSlice, muidSlice, index, candidateClassLoader, fromUpper, false, true));
+    if (superClassesItem != nullptr) {
+      superTableSlice[i].index = reinterpret_cast<size_t>(superClassesItem);
+      LINKER_VLOG(lazybinding) << "fromUpper:"<< fromUpper << "resolved UNDEF lazily, " << fromUndef <<
+          ", addr=" << dataUndefSlice[index].Address() << ", class=" <<  superClassesItem->GetName() <<
+          " in " << mplInfo.name << maple::endl;
+    } else {
+      __MRT_ASSERT(0, "LazyBinding::LinkSuperClassAndInterfaces(), not resolved UNDEF lazily\n");
+    }
+  } else {
+    LINKER_VLOG(lazybinding) << "already resolved UNDEF, just use, " << fromUndef << ", addr=" <<
+        dataUndefSlice[index].Address() << ", class=" <<
+        reinterpret_cast<MClass*>(dataUndefSlice[index].Address())->GetName() << " in " << mplInfo.name <<
+        maple::endl;
+    superTableSlice[i].index = reinterpret_cast<size_t>(dataUndefSlice[index].Address());
+
+    // To link lazy class even if it's resolved before.
+    MClass *resolvedClass = reinterpret_cast<MClass*>(dataUndefSlice[index].Address());
+    if (resolvedClass->IsLazyBinding()) {
+      superClassesItem = resolvedClass;
+    }
+  }
+  return superClassesItem;
+}
+
+MClass *LazyBinding::LinkDataDefSuperClassAndInterfaces(
+    LinkerMFileInfo &mplInfo, size_t index, AddrSlice dataDefSlice,
+    MClass *superClassesItem, IndexSlice superTableSlice, uint32_t i, bool fromUndef) {
+  size_t muidSize = mplInfo.GetTblSize(kDataDefMuid);
+  MuidSlice muidSlice = MuidSlice(mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataDefMuid), muidSize);
+  // We must don't check resolved state for DEF table.
+  // Not check if (GetAddrBindingState(dataDefSlice, index, true) == kBindingStateResolved)
+  if (GetAddrBindingState(dataDefSlice, index, true) == kBindingStateResolved) {
+    LINKER_VLOG(lazybinding) << "already resolved DEF before, " << fromUndef << ", addr=" <<
+        dataDefSlice[index].Address() << ", class=" <<
+        reinterpret_cast<MClass*>(dataDefSlice[index].Address())->GetName() << ", in " << mplInfo.name <<
+        maple::endl;
+  }
+  bool fromUpper = false;
+  superClassesItem = reinterpret_cast<MClass*>(ResolveClassSymbol(
+      mplInfo, dataDefSlice, muidSlice, index, nullptr, fromUpper, true, true));
+  if (superClassesItem != nullptr) {
+    superTableSlice[i].index = reinterpret_cast<size_t>(superClassesItem);
+    LINKER_VLOG(lazybinding) << "fromUpper:" << fromUpper <<"resolved DEF lazily, " << fromUndef << ", addr=" <<
+        dataDefSlice[index].Address() << ", class=" << superClassesItem->GetName() << " in " << mplInfo.name <<
+        maple::endl;
+  } else {
+    __MRT_ASSERT(0, "LazyBinding::LinkSuperClassAndInterfaces(), not resolved DEF lazily\n");
+  }
+  return superClassesItem;
+}
+
+void LazyBinding::LinkSuperClassAndInterfaces(
+    LinkerMFileInfo &mplInfo, const MClass *klass, MObject *candidateClassLoader, bool recursive, bool forCold) {
+  uint32_t superClassSize = klass->GetNumOfSuperClasses();
+  IndexSlice superTableSlice = IndexSlice(
+      reinterpret_cast<LinkerSuperClassTableItem*>(klass->GetSuperClassArrayPtr()), superClassSize);
+  if (superTableSlice.Empty()) {
+    return;
+  }
+
+  size_t dataUndefSize = mplInfo.GetTblSize(kDataUndef);
+  AddrSlice dataUndefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataUndef), dataUndefSize);
+  size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+  AddrSlice dataDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDef), dataDefSize);
+  for (uint32_t i = 0; i < superClassSize; ++i) {
+    LinkerRef ref(superTableSlice[i].index);
+    MClass *superClassesItem = nullptr;
+    LINKER_VLOG(lazybinding) << "super[" << i << "]=" << superTableSlice[i].index << ", defSize=" << dataDefSize <<
+        ", undefSize=" << dataUndefSize << ", for " << klass->GetName() << ", in " << mplInfo.name << maple::endl;
+    if (ref.IsIndex()) { // Def or Undef Index
+      bool fromUndef = ref.IsFromUndef();
+      size_t index = ref.GetIndex();
+      if (fromUndef && index < dataUndefSize && !dataUndefSlice.Empty()) {
+        superClassesItem = LinkDataUndefSuperClassAndInterfaces(mplInfo, candidateClassLoader, index, dataUndefSlice,
+            superClassesItem, superTableSlice, i, fromUndef);
+      } else if (!fromUndef && index < dataDefSize && !dataDefSlice.Empty()) {
+        superClassesItem = LinkDataDefSuperClassAndInterfaces(mplInfo, index, dataDefSlice, superClassesItem,
+            superTableSlice, i, fromUndef);
+      } else {
+        __MRT_ASSERT(0, "LazyBinding::LinkSuperClassAndInterfaces(), must be DEF or UNDEF\n");
+      }
+    } else { // Address.
+      // Already resolved.
+      if (!ref.IsEmpty() && forCold) {
+        superClassesItem = ref.GetDataRef<MClass*>();
+        LINKER_VLOG(lazybinding) << "already resolved, super[" << i << "]=" << superClassesItem << ", defSize=" <<
+            dataDefSize << ", undefSize=" << dataUndefSize << ", for " << superClassesItem->GetName() <<
+            ", in " << mplInfo.name << maple::endl;
+      }
+      // Allow re-link.
+    }
+
+    if (recursive) {
+      if (superClassesItem == nullptr) {
+        LINKER_VLOG(lazybinding) << "ignore one item of super in " << klass->GetName() << maple::endl;
+        // We allow super class or interfaces as null.
+        continue;
+      }
+      if (forCold) {
+        LinkSuperClassAndInterfaces(superClassesItem, candidateClassLoader, true, true);
+      } else {
+        LinkClassInternal(superClassesItem, candidateClassLoader);
+      }
+    }
+  }
+}
+
+void LazyBinding::LinkClass(MClass *klass) {
+  LINKER_DLOG(lazybinding) << "klass=" << klass << ", name=" << klass->GetName() << ", lazy=" <<
+      klass->IsLazyBinding() << ", cold=" << klass->IsColdClass() << maple::endl;
+  // If the array's component is not ready, to link the component class for array class.
+  if (klass->IsArrayClass()) {
+    MClass *componentClass = klass->GetComponentClass();
+    if (componentClass == nullptr) {
+      LINKER_LOG(FATAL) << "component class is null, klass=" << klass << ", name=" << klass->GetName() << maple::endl;
+      return;
+    }
+    if (componentClass->IsLazyBinding()) {
+      LinkClass(componentClass);
+    }
+    return;
+  }
+
+  // We use the field of shadow to store def table index.
+  if (klass->IsPrimitiveClass() || !klass->IsLazyBinding()) {
+    return;
+  }
+  LinkerMFileInfo *mplInfo = pInvoker->GetLinkerMFileInfo(kFromMeta, klass, true);
+  if (mplInfo != nullptr) {
+    // To get the index in the pTable
+    MClass *indexClass = klass->GetClass();
+    uint32_t defIndex = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(indexClass));
+    if (defIndex == 0) { // It's not lazy, we use 0 as flag of not lazy.
+      LINKER_LOG(FATAL) << "class has no def index? klass=" << klass << ", name=" << klass->GetName() << maple::endl;
+      return;
+    } else {
+      if (indexClass == WellKnown::GetMClassClass()) {
+        return;
+      }
+      --defIndex;
+    }
+    size_t dataDefSize = mplInfo->GetTblSize(kDataDef);
+    AddrSlice dataTable(mplInfo->GetTblBegin<LinkerAddrTableItem*>(kDataDef), dataDefSize);
+    if (GetAddrBindingState(dataTable, defIndex, true) == kBindingStateResolved) {
+      return;
+    }
+    if (!MRT_IsClassInitialized(*klass)) {
+      LoaderAPI::Instance().SetClassCL(*klass, mplInfo->classLoader);
+      LinkClassInternal(*mplInfo, klass, reinterpret_cast<MObject*>(mplInfo->classLoader), true);
+    } else {
+      LinkClassInternal(*mplInfo, klass, reinterpret_cast<MObject*>(MRT_GetClassLoader(*klass)), true);
+    }
+  } else {
+    LINKER_LOG(FATAL) << "lazy class has no MFileInfo? klass=" << klass << ", name=" << klass->GetName() << maple::endl;
+  }
+}
+
+// Only used in LinkSuperClassAndInterfaces().
+void LazyBinding::LinkClassInternal(MClass *klass, MObject *candidateClassLoader) {
+  LinkerMFileInfo *mplInfo = pInvoker->GetLinkerMFileInfo(kFromMeta, klass, true);
+  if (mplInfo != nullptr) {
+    LinkClassInternal(*mplInfo, klass, candidateClassLoader, true);
+  }
+}
+
+void LazyBinding::LinkClassInternal(
+    LinkerMFileInfo &mplInfo, MClass *klass, MObject *candidateClassLoader, bool first) {
+  LINKER_VLOG(lazybinding) << "klass=" << klass << ", name=" << klass->GetName() << ", lazy=" <<
+      klass->IsLazyBinding() << ", cold=" << klass->IsColdClass() << ", decouple=" <<
+      klass->IsDecouple() << ", in " << mplInfo.name << maple::endl;
+  if (!klass->IsLazyBinding() || *klass == MRT_GetClassObject()) {
+    return;
+  }
+  if (maple::ObjectBase::MonitorEnter(reinterpret_cast<address_t>(klass)) == JNI_ERR) {
+    LINKER_LOG(ERROR) << ", maple::ObjectBase::MonitorEnter() failed" << maple::endl;
+  }
+
+  // Check if we link it before, or no need linking.
+  // (Notice:Lazy binding class must also be cold class,
+  // but lazy-binding is optional, lazy binding class maybe not cold.)
+  // To prevent deadlock, we will checking klass status after got MonitorEnter lock.
+  if (!klass->IsLazyBinding() || *klass == MRT_GetClassObject()) {
+    if (maple::ObjectBase::MonitorExit(reinterpret_cast<address_t>(klass)) == JNI_ERR) {
+      LINKER_LOG(ERROR) << "maple::ObjectBase::MonitorExit() failed" << maple::endl;
+    }
+    return;
+  }
+
+  LinkSuperClassAndInterfaces(mplInfo, klass, candidateClassLoader, true);
+
+  // Set the def index all the time.
+  MClass *indexClass = klass->GetClass();
+  MetaRef index = static_cast<MetaRef>(reinterpret_cast<uintptr_t>(indexClass));
+  if (index == 0) { // It's not lazy, we use 0 as flag of not lazy.
+    LINKER_LOG(FATAL) << "class is lazy, but no def index? klass=" << klass << ", name=" <<
+        klass->GetName() << maple::endl;
+  } else {
+    if (indexClass == WellKnown::GetMClassClass()) {
+      if (maple::ObjectBase::MonitorExit(reinterpret_cast<address_t>(klass)) == JNI_ERR) {
+        LINKER_LOG(ERROR) << "maple::ObjectBase::MonitorExit() failed" << maple::endl;
+      }
+      return;
+    }
+    --index;
+  }
+
+  LinkStaticSymbol(mplInfo, klass);
+  // To handle decoupling routine.
+  LinkMethods(mplInfo, klass, first, index);
+  LinkFields(mplInfo, klass);
+
+  // The same as MRTSetMetadataShadow(reinterpret_cast<ClassMetadata*>(klass), WellKnown::GetMClassClass())
+  // If first loaded, we clear the def index in 'shadow' field which multiplex used for lazy binding.
+  // Set shadow to CLASS. We multiplex use the 'shadow' before class's being intialized,
+  MRTSetMetadataShadow(reinterpret_cast<ClassMetadata*>(klass), WellKnown::GetMClassClass());
+  if (SetClassInDefAddrTable(index, klass) == nullptr) {
+    LINKER_LOG(ERROR) << "SetClassInDefAddrTable failed" << maple::endl;
+  }
+
+  // Set cold class as hot.
+  klass->SetHotClass();
+  // Clear lazy binding flag.
+  klass->ReSetFlag(0xDFFF); // 0xDFFF is LazyBinding flag
+  klass->SetFlag(modifier::kClassLazyBoundClass);
+
+  if (maple::ObjectBase::MonitorExit(reinterpret_cast<address_t>(klass)) == JNI_ERR) {
+    LINKER_LOG(ERROR) << "maple::ObjectBase::MonitorExit() failed" << maple::endl;
+  }
+}
+
+
+inline std::string LazyBinding::ResolveClassMethod(MClass *klass) {
+  return pMethodBuilder->BuildMethod(klass);
+}
+
+#if defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+void LazyBinding::PreLinkLazyMethod(LinkerMFileInfo &mplInfo) {
+  if (mplInfo.IsFlag(kIsLazy)) {
+    std::string cachingStr;
+    if (!LoadLazyCache(&mplInfo, cachingStr)) {
+      return;
+    }
+    mplInfo.methodCachingStr = cachingStr;
+
+    std::vector<std::string> cachingIndexes;
+    std::istringstream issCaching(cachingStr);
+    std::string tmp;
+    while (getline(issCaching, tmp, ';')) {
+      cachingIndexes.push_back(tmp);
+    }
+    LINKER_VLOG(lazybinding) << "klass num=" << cachingIndexes.size() << ", in " << mplInfo.name << maple::endl;
+
+    LinkerAddrTableItem *pDefRealTable = mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig);
+    for (size_t i = 0; i < cachingIndexes.size(); ++i) {
+      std::string indexStr = cachingIndexes[i];
+      std::string::size_type pos = indexStr.find(':');
+      if (pos == std::string::npos) { // Error
+        continue;
+      }
+      constexpr int decimalBase = 10;
+      auto index = std::strtol(indexStr.c_str(), nullptr, decimalBase);
+      MClass *klass = reinterpret_cast<MClass*>(GetDefTableAddress(mplInfo, *pDefRealTable, index, false));
+      LinkStaticSymbol(mplInfo, klass);
+      LinkSuperClassAndInterfaces(mplInfo, klass, nullptr, true, true);
+      std::string cachingIndex = indexStr.substr(pos + 1);
+      pMethodBuilder->BuildMethodByCachingIndex(klass, cachingIndex);
+
+      // To handle decoupling routine.
+      LinkFields(mplInfo, klass);
+
+      // The same as MRTSetMetadataShadow(reinterpret_cast<ClassMetadata*>(klass), WellKnown::GetMClassClass())
+      // If first loaded, we clear the def index in 'shadow' field which multiplex used for lazy binding.
+      // Set shadow to CLASS.
+      MRTSetMetadataShadow(reinterpret_cast<ClassMetadata*>(klass), WellKnown::GetMClassClass());
+      (void)SetClassInDefAddrTable(index, klass);
+
+      // Set Classloader for the class.
+      LoaderAPI::Instance().SetClassCL(*klass, mplInfo.classLoader);
+      // Set cold class as hot.
+      klass->SetHotClass();
+      // Clear lazy binding flag.
+      klass->ReSetFlag(0xDFFF); // 0xDFFF is LazyBinding flag
+      klass->SetFlag(modifier::kClassLazyBoundClass);
+
+      ++(mplInfo.methodCachingNum);
+    }
+  }
+}
+#endif // defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+
+void LazyBinding::LinkMethods(LinkerMFileInfo &mplInfo, MClass *klass, bool first, MetaRef index) {
+  LINKER_VLOG(lazybinding) << "(" << &mplInfo << ", " << klass->GetName() << "), first=" << first << ", index=" <<
+      index << maple::endl;
+#ifdef LINKER_DECOUPLE
+  if (mplInfo.IsFlag(kIsLazy) && mplInfo.GetDecoupleLevel() != 0) {
+    // Inteface has no vtable or itable.
+    if (klass->IsInterface() || !first) {
+      return;
+    }
+    if (klass->IsDecouple()) {
+      if (reinterpret_cast<ClassMetadata*>(klass)->vTable.refVal != 0) {
+        LINKER_LOG(ERROR) << "(" << klass->GetName() << "), already set, index=" << index << maple::endl;
+        return;
+      }
+#if defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+      if (mplInfo.methodCachingNum < 2000) { // We don't need save all classes, here we use 2000 as upper threshold.
+        std::lock_guard<std::mutex> autoLock(mplInfo->methodCachingLock);
+        std::string cachingStr = ResolveClassMethod(klass);
+        if (!cachingStr.empty()) {
+          mplInfo.methodCachingStr += std::to_string(index) + ':';
+          mplInfo.methodCachingStr += cachingStr;
+          mplInfo.methodCachingStr += ';';
+          ++(mplInfo.methodCachingNum);
+        }
+
+        if (mplInfo.methodCachingNum % 500 == 0) { // We use 500 as upper threshold, to reduce the times of saving.
+          SaveLazyCache(mplInfo, mplInfo.methodCachingStr);
+        }
+      } else {
+        (void)ResolveClassMethod(klass);
+      }
+#else // defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+      (void)ResolveClassMethod(klass);
+#endif // defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+    }
+  } else if (klass->IsColdClass()) {
+#else
+  if (klass->IsColdClass()) {
+#endif
+    LINKER_VLOG(lazybinding) << "for non-decouple class, name=" << klass->GetName() << ", index=" << index <<
+        ", lazy=" << klass->IsLazyBinding() << ", cold=" << klass->IsColdClass() << ", decouple=" <<
+        klass->IsDecouple() << ", in " << mplInfo.name << maple::endl;
+    pInvoker->ResolveVTableSymbolByClass(mplInfo, klass, true);
+    pInvoker->ResolveVTableSymbolByClass(mplInfo, klass, false);
+  }
+}
+
+inline void LazyBinding::LinkFields(const LinkerMFileInfo &mplInfo, MClass *klass) {
+  LINKER_VLOG(lazybinding) << "(" << &mplInfo << ", " << klass->GetName() << ")" << maple::endl;
+#ifdef LINKER_DECOUPLE
+  if (mplInfo.IsFlag(kIsLazy) && mplInfo.GetDecoupleLevel() != 0) {
+    Decouple *decouple = pInvoker->Get<Decouple>();
+    MplFieldDecouple *fieldDecouple = &decouple->GetFieldResolver();
+    MplGctibAnalysis *gctibResolver = &decouple->GetGctibResolver();
+    fieldDecouple->ResolveFieldOffsetAndObjSizeLazily(*(reinterpret_cast<ClassMetadata*>(klass)));
+    (void)gctibResolver->ReGenGctib4Class(reinterpret_cast<ClassMetadata*>(klass));
+  }
+#endif
+}
+
+#if defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+inline bool LazyBinding::SaveLazyCacheInternal(std::string &path, int &fd, std::vector<char> &bufVector) {
+  char *buf = nullptr;
+  MUID cacheValidity;
+  uint32_t eof = static_cast<uint32_t>(EOF);
+
+  // Ready to write all the data in buffer.
+  buf = reinterpret_cast<char*>(bufVector.data());
+  std::streamsize byteCount = bufVector.size();
+  // 1. Write for validity.
+  GenerateMUID(buf, byteCount, cacheValidity);
+  if (write(fd, reinterpret_cast<char*>(&cacheValidity.data), sizeof(cacheValidity.data)) < 0) {
+    LINKER_LOG(ERROR) << "..validity, " << path << ", " << errno << maple::endl;
+    return false;
+  }
+  // 2. Write for the content length.
+  uint32_t contentSize = static_cast<uint32_t>(byteCount);
+  if (write(fd, reinterpret_cast<char*>(&contentSize), sizeof(contentSize)) < 0) {
+    LINKER_LOG(ERROR) << "..content length, " << path << ", " << errno << maple::endl;
+    return false;
+  }
+  // 3. Write for the content.
+  if (write(fd, buf, byteCount) < 0) {
+    LINKER_LOG(ERROR) << "..content, " << path << ", " << errno << maple::endl;
+    return false;
+  }
+  // 4. Write EOF.
+  if (write(fd, reinterpret_cast<char*>(&eof), sizeof(eof)) < 0) {
+    LINKER_LOG(ERROR) << "write EOF error, " << path << ", " << errno << maple::endl;
+    return false;
+  }
+  return true;
+}
+
+bool LazyBinding::SaveLazyCache(LinkerMFileInfo &mplInfo, const std::string &cachingIndex) {
+  bool res = true;
+  std::vector<char> bufVector;
+  char *str = nullptr;
+  std::string path;
+  LinkerCacheType cacheType = LinkerCacheType::kLinkerCacheLazy;
+
+  if (!pInvoker->GetCachePath(mplInfo, path, cacheType)) {
+    LINKER_LOG(ERROR) << "fail to prepare " << path << ", " << errno << maple::endl;
+    return false;
+  }
+  int fd = open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644); // 0644 means file's permissions
+  if (fd == -1) {
+    LINKER_LOG(ERROR) << "fail to open " << path << ", " << errno << maple::endl;
+    res = false;
+    goto END;
+  }
+
+  // Prepare all the data in buffer firstly.
+  // 1. Insert maximum version into content.
+  int32_t maxVersion = GetMaxVersion();
+  str = reinterpret_cast<char*>(&maxVersion);
+  bufVector.insert(bufVector.end(), str, str + sizeof(maxVersion));
+  // 2. Insert minimum version into content.
+  int32_t minVersion = GetMinVersion();
+  str = reinterpret_cast<char*>(&minVersion);
+  bufVector.insert(bufVector.end(), str, str + sizeof(minVersion));
+  // 3. Insert the hash from .so into content.
+  MUID soValidity = pInvoker->GetValidityCode(mplInfo);
+  str = reinterpret_cast<char*>(&soValidity);
+  bufVector.insert(bufVector.end(), str, str + sizeof(soValidity));
+
+  // 4. Insert the string length firstly into content.
+  uint32_t len = cachingIndex.size();
+  str = reinterpret_cast<char*>(&len);
+  bufVector.insert(bufVector.end(), str, str + sizeof(len));
+
+  // 5. Insert the caching index info. into content.
+  bufVector.insert(bufVector.end(), cachingIndex.begin(), cachingIndex.end());
+
+  if (!SaveLazyCacheInternal(path, fd, bufVector)) {
+    res = false;
+  }
+
+END:
+  close(fd);
+  return res;
+}
+
+inline bool LazyBinding::LoadLazyCacheInternal(
+    LinkerMFileInfo &mplInfo, std::string &path, std::string &cachingIndex,
+    char *buf, std::streamsize &index, std::streamsize &byteCount) {
+  MUID cacheValidity;
+
+  // 1. Read the validity.
+  MUID lastCacheValidity = *(reinterpret_cast<MUID*>(&buf[index]));
+  index += sizeof(lastCacheValidity);
+  // 2. Read the length of content.
+  uint32_t contentSize = *(reinterpret_cast<uint32_t*>(&buf[index]));
+  index += sizeof(contentSize);
+  if (contentSize != static_cast<uint32_t>(byteCount - index)) {
+    LINKER_LOG(ERROR) << "wrong cache length, " << path << ", " << contentSize << " vs. " <<
+        static_cast<uint32_t>(byteCount - index) << maple::endl;
+    return false;
+  }
+
+  // Generate the digest for validity, excluding the length of content.
+  GenerateMUID(&buf[index], byteCount - index, cacheValidity);
+  if (lastCacheValidity != cacheValidity) {
+    LINKER_LOG(ERROR) << "cache validity checking failed, " << path << maple::endl;
+    return false;
+  }
+
+  // 3. Read maximum version.
+  int32_t maxVersion = *(reinterpret_cast<int32_t*>(&buf[index]));
+  if (maxVersion != GetMaxVersion()) {
+    LINKER_LOG(ERROR) << "wrong max version, " << path << ", " << maxVersion << maple::endl;
+    return false;
+  }
+  index += sizeof(maxVersion);
+
+  // 4. Read minimum version.
+  int32_t minVersion = *(reinterpret_cast<int32_t*>(&buf[index]));
+  if (minVersion != GetMinVersion()) {
+    LINKER_LOG(ERROR) << "wrong min version, " << path << ", " << minVersion << maple::endl;
+    return false;
+  }
+  index += sizeof(minVersion);
+
+  // 5. Read the hash from cache file, comparing with .so.
+  MUID lastSoValidity = *(reinterpret_cast<MUID*>(&buf[index]));
+  MUID soValidity = pInvoker->GetValidityCode(mplInfo);
+  if (lastSoValidity != soValidity) {
+    LINKER_LOG(ERROR) << "wrong validity, " << soValidity.ToStr() << " vs. " << lastSoValidity.ToStr() << " in " <<
+        mplInfo.name << maple::endl;
+    return false;
+  }
+  index += sizeof(lastSoValidity);
+
+  // 6. Read the content length firstly.
+  uint32_t len = *(reinterpret_cast<uint32_t*>(&buf[index]));
+  index += sizeof(len);
+
+  // 7. Read the content.
+  cachingIndex.resize(len + 1);
+  cachingIndex.assign(&buf[index], len);
+  index += len;
+  return true;
+}
+
+bool LazyBinding::LoadLazyCache(LinkerMFileInfo &mplInfo, std::string &cachingIndex) {
+  bool res = false;
+  std::ifstream in;
+  std::streamsize index = 0;
+  std::vector<char> bufVector;
+  char *buf = nullptr;
+  std::string path;
+
+  if (!pInvoker->GetCachePath(&mplInfo, path, LinkerCacheType::kLinkerCacheLazy)) {
+    LINKER_LOG(ERROR) << "fail to prepare " << path << ", " << errno << maple::endl;
+    return res;
+  }
+  in.open(path, std::ios::binary);
+  bool failIn = (!in);
+  if (failIn) {
+    LINKER_LOG(ERROR) << "fail to open " << path << ", " << errno << maple::endl;
+    goto END;
+  }
+
+  // Read all the data in buffer firstly.
+  in.seekg(0, std::ios::end);
+  std::streamsize byteCount = in.tellg();
+  in.seekg(0, std::ios::beg);
+  bufVector.resize(byteCount);
+  buf = reinterpret_cast<char*>(bufVector.data());
+  if (!in.read(buf, byteCount)) {
+    LINKER_LOG(ERROR) << "read data error, " << path << ", " << errno << maple::endl;
+    goto END;
+  }
+  // 0. Read EOF.
+  uint32_t eof = *(reinterpret_cast<uint32_t*>(&buf[byteCount - sizeof(eof)]));
+  if (eof != static_cast<uint32_t>(EOF)) {
+    LINKER_LOG(ERROR) << "wrong EOF, " << path << ", eof=" << std::hex << eof << maple::endl;
+    goto END;
+  }
+  byteCount -= sizeof(eof);
+  if (!LoadLazyCacheInternal(&mplInfo, path, cachingIndex, buf, index, byteCount)) {
+    goto END;
+  }
+  if (index == byteCount) {
+    res = true;
+  }
+
+END:
+  if (in.is_open()) {
+    in.close();
+  }
+  return res;
+}
+#endif // defined(LINKER_RT_CACHE) && defined(LINKER_RT_LAZY_CACHE)
+
+void *LazyBinding::GetClassMetadata(LinkerMFileInfo &mplInfo, size_t classIndex) {
+  LinkerRef ref(classIndex);
+  void *addr = nullptr;
+  if (ref.IsIndex()) { // Index
+    size_t index = ref.GetIndex();
+    bool fromUndef = ref.IsFromUndef();
+    if (fromUndef && index < mplInfo.GetTblSize(kDataUndef)) {
+      LinkerMuidTableItem *pMuidTable = mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataUndefMuid);
+      size_t dataUndefSize = mplInfo.GetTblSize(kDataUndef);
+      AddrSlice dataUndefTable(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataUndef), dataUndefSize);
+      if (mplInfo.IsFlag(kIsLazy) && GetAddrBindingState(dataUndefTable, index) != kBindingStateResolved) {
+        if (HandleSymbolForDecoupling(mplInfo, dataUndefTable, index)) {
+          addr = dataUndefTable[index].Address();
+          LINKER_VLOG(lazybinding) << "(UNDEF), resolved lazily, index=" << index << ", name=" <<
+              reinterpret_cast<MClass*>(addr)->GetName() << " for " << mplInfo.name << maple::endl;
+        } else {
+          addr = dataUndefTable[index].Address();
+          LINKER_LOG(ERROR) << "(UNDEF), resolve class error, index=" << index << ", muid=" <<
+              pMuidTable[index].muid.ToStr() << ", addr=" << addr << ", resolved=" <<
+              (GetAddrBindingState(dataUndefTable, index) == kBindingStateResolved) <<
+              " for " << mplInfo.name << maple::endl;
+        }
+      } else {
+        addr = dataUndefTable[index].Address();
+      }
+    } else if (!fromUndef && index < mplInfo.GetTblSize(kDataDef)) {
+      size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+      AddrSlice dataDefTable(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDef), dataDefSize);
+      if (mplInfo.IsFlag(kIsLazy) && GetAddrBindingState(dataDefTable, index) != kBindingStateResolved) {
+        if (HandleSymbolForDecoupling(mplInfo, dataDefTable, index)) {
+          addr = dataDefTable[index].Address();
+          LINKER_VLOG(lazybinding) << "(DEF), resolved lazily, index=" << index << ", name=" <<
+              reinterpret_cast<MClass*>(addr)->GetName() << " for " << mplInfo.name << maple::endl;
+        } else {
+          addr = GetDefTableAddress(mplInfo, dataDefTable, static_cast<size_t>(index), false);
+          LinkerMuidTableItem *dataDefMuidTable = mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataDefMuid);
+          LINKER_LOG(ERROR) << "(DEF), resolve class error, index=" << index << ", muid=" <<
+              dataDefMuidTable[index].muid.ToStr() << ", addr=" << addr << ", resolved=" <<
+              (GetAddrBindingState(dataDefTable, index) == kBindingStateResolved) <<
+              " for " << mplInfo.name << maple::endl;
+        }
+      } else {
+        addr = dataDefTable[index].Address();
+      }
+    }
+  }
+  return addr;
+}
+
+void *LazyBinding::LookUpDataSymbolAddressLazily(
+    const MObject *classLoader, const MUID &muid, LinkerMFileInfo **outLinkerMFileInfo, bool ignoreClassLoader) {
+  void *res = nullptr;
+  if (!ignoreClassLoader) {
+    auto handle = [this, &muid, &res](LinkerMFileInfo &mplInfo)->bool {
+      size_t tmp = 0;
+      LinkerVoidType addr = this->pInvoker->LookUpDataSymbolAddress(mplInfo, muid, tmp);
+      if (addr != 0) {
+        res = reinterpret_cast<void*>(addr);
+        return true;
+      }
+      return false;
+    };
+    (void)pInvoker->mplInfoListCLMap.FindIf(classLoader, handle);
+  } else {
+    auto handle = [this, &muid, outLinkerMFileInfo, &res](LinkerMFileInfo &mplInfo)->bool {
+      size_t tmp = 0;
+      LinkerVoidType addr = this->pInvoker->LookUpDataSymbolAddress(mplInfo, muid, tmp);
+      if (addr != 0) {
+        if (outLinkerMFileInfo != nullptr) {
+          *outLinkerMFileInfo = &mplInfo;
+        }
+        res = reinterpret_cast<void*>(addr);
+        return true;
+      }
+      return false;
+    };
+    (void)pInvoker->mplInfoList.FindIf(handle);
+  }
+  return res;
+}
+
+void *LazyBinding::LookUpMethodSymbolAddressLazily(
+    const MObject *classLoader, const MUID &muid, bool ignoreClassLoader) {
+  void *res = nullptr;
+  auto handle = [this, &muid, &res](LinkerMFileInfo &mplInfo)->bool {
+    size_t tmp = 0;
+    LinkerVoidType addr = this->pInvoker->LookUpMethodSymbolAddress(mplInfo, muid, tmp);
+    if (addr != 0) {
+      res = reinterpret_cast<void*>(addr);
+      return true;
+    }
+    return false;
+  };
+  if (!ignoreClassLoader) {
+    (void)pInvoker->mplInfoListCLMap.FindIf(classLoader, handle);
+  } else {
+    (void)pInvoker->mplInfoList.FindIf(handle);
+  }
+  return res;
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/linker/linker_method_builder.cpp b/src/mrt/compiler-rt/src/linker/linker_method_builder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a5e510ec054bd484e135d9a3abbdacb3aa9f798
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_method_builder.cpp
@@ -0,0 +1,791 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker_method_builder.h"
+
+#include <algorithm>
+
+#include "linker/linker_model.h"
+#include "itab_util.h"
+#include "cinterface.h"
+#include "mrt_object.h"
+#include "mclass_inline.h"
+#include "mrt_reflection_class.h"
+#include "modifier.h"
+#include "mrt_reflection_method.h"
+#include "mrt_class_api.h"
+
+namespace maplert {
+using namespace linkerutils;
+FeatureName MethodBuilder::featureName = kFMethodBuilder;
+inline unsigned int MethodBuilder::GetHashIndex(const char *name) {
+  unsigned int hashcode = maple::DJBHash(name);
+  return (hashcode % maple::kHashSize);
+}
+
+inline bool MethodBuilder::IsValidMethod(const MethodMetaBase &method) const {
+  uint32_t methodFlag = method.GetFlag();
+  uint32_t methodModifier = method.GetMod();
+  return !modifier::IsNotvirtualMethod(methodFlag) &&
+      !modifier::IsStatic(methodModifier) && !modifier::IsPrivate(methodModifier);
+}
+
+// Check the method and sort them with vtab index,
+// then check if it's compact.
+inline bool MethodBuilder::CheckMethodMetaNoSort(
+    const MClass *klass, std::vector<std::pair<MethodMetaBase*, uint16_t>> &methods) {
+  uint32_t methodNum = klass->GetNumOfMethods();
+  MethodMeta *methodMetas = klass->GetRawMethodMetas();
+  if (UNLIKELY(methodNum == 0 || methodMetas == nullptr)) {
+    return false;
+  }
+  bool isCompactMeta = reinterpret_cast<const MClass*>(klass)->IsCompactMetaMethods();
+
+  // We should create the method metadata list sorted by its index in default,
+  // then we can avoid sorting them once here.
+  bool isInterface = klass->IsInterface();
+  for (uint32_t i = 0; i < methodNum; ++i) {
+    MethodMetaBase *method = nullptr;
+    if (!isCompactMeta) {
+      method = reinterpret_cast<MethodMetaBase*>(&methodMetas[i]);
+    } else {
+      MethodMetaCompact *compact = MethodMetaCompact::GetMethodMetaCompact(*klass, i);
+      method = reinterpret_cast<MethodMetaBase*>(compact);
+    }
+    if (!isInterface && !IsValidMethod(*method)) {
+      continue;
+    }
+    methods.push_back(std::make_pair(method, i)); // Push back the method and its position.
+  }
+  return true;
+}
+
+inline bool MethodBuilder::CheckMethodMeta(
+    const MClass *klass, std::vector<std::pair<MethodMetaBase*, uint16_t>> &methods) {
+  bool res = CheckMethodMetaNoSort(klass, methods);
+  std::sort(methods.begin(), methods.end(), [](auto &lhs, auto &rhs) {
+    return lhs.first->GetVtabIndex() < rhs.first->GetVtabIndex();
+  });
+  return res;
+}
+
+inline void MethodBuilder::BuildAdjMethodList(
+    std::vector<MethodItem> &virtualMethods, MplLazyBindingVTableMapT &adjMethods) {
+  uint16_t size = virtualMethods.size();
+  if (UNLIKELY(size == 0)) {
+    return;
+  }
+  adjMethods.resize(size);
+  adjMethods.assign(size, AdjItem());
+  for (uint16_t i = 0; i < size; ++i) { // Travel across the methods one by one.
+    uint16_t hash = virtualMethods[i].hash;
+    uint16_t pos = hash % size;
+    adjMethods[i].next = adjMethods[pos].first;
+    adjMethods[pos].first = i;
+    adjMethods[i].methodMeta = virtualMethods[i].methodMeta;
+  }
+}
+
+void MethodBuilder::CollectClassMethods(const MClass *klass, const bool &isDecouple, const std::vector<uint16_t> &depth,
+    std::vector<MethodItem> &virtualMethods, MplLazyBindingVTableMapT &adjMethods) {
+  bool isInterface = klass->IsInterface();
+  if (isDecouple || isInterface) {
+    std::vector<std::pair<MethodMetaBase*, uint16_t>> methods;
+    if (!CheckMethodMeta(klass, methods)) {
+      return;
+    }
+    CollectClassMethodsSlow(klass, depth, virtualMethods, adjMethods, methods);
+  } else {
+    std::vector<std::pair<MethodMetaBase*, uint16_t>> methods;
+    if (!CheckMethodMetaNoSort(klass, methods)) {
+      return;
+    }
+    CollectClassMethodsFast(klass, depth, virtualMethods, methods);
+  }
+
+  // If we want to save the mapping info. in memory, so we shouldn't check klass != targetClass.
+  BuildAdjMethodList(virtualMethods, adjMethods);
+}
+
+void MethodBuilder::OverrideVTabMethod(std::vector<MethodItem> &virtualMethods, uint16_t vtabIndex,
+    const MethodMetaBase &method, const std::vector<uint16_t> &depth, uint16_t index, bool isInterface) {
+  virtualMethods[vtabIndex].SetMethod(method);
+#ifdef LINKER_RT_LAZY_CACHE
+  virtualMethods[vtabIndex].depth = (depth.size() > 0) ? depth : virtualMethods[vtabIndex].depth;
+  virtualMethods[vtabIndex].index = index;
+#endif // LINKER_RT_LAZY_CACHE
+  virtualMethods[vtabIndex].isInterface = isInterface || virtualMethods[vtabIndex].isInterface;
+  LINKER_DLOG(lazybinding) << "method=" << GetMethodFullName(method) << ", vtabIndex=" << vtabIndex <<
+      ", depth size=" << depth.size() << ", index" << index <<
+      ", isInterface=" << virtualMethods[vtabIndex].isInterface << maple::endl;
+}
+
+void MethodBuilder::AppendVTabMethod(std::vector<MethodItem> &virtualMethods, int16_t vtabIndex,
+    const MethodMetaBase &method, const std::vector<uint16_t> &depth, uint16_t index, bool isInterface,
+    uint16_t hash) {
+  MethodItem methodItem;
+  methodItem.SetMethod(method);
+#ifdef LINKER_RT_LAZY_CACHE
+  methodItem.depth = (depth.size() > 0) ? depth : methodItem.depth;
+  methodItem.index = index;
+#endif // LINKER_RT_LAZY_CACHE
+  methodItem.isInterface = isInterface;
+  methodItem.hash = hash;
+  if (vtabIndex < 0) {
+    virtualMethods.push_back(std::move(methodItem));
+  } else {
+    virtualMethods[vtabIndex] = std::move(methodItem);
+  }
+  LINKER_DLOG(lazybinding) << "method=" << GetMethodFullName(method) << ", depth size=" << depth.size() <<
+      ", index=" << index << ", isInterface=" << isInterface << ", hash=" << hash << maple::endl;
+}
+
+void MethodBuilder::CollectClassMethodsSlow(const MClass *klass, const std::vector<uint16_t> &depth,
+    std::vector<MethodItem> &virtualMethods, const MplLazyBindingVTableMapT &adjMethods,
+    const std::vector<std::pair<MethodMetaBase*, uint16_t>> &methods) {
+  bool isInterface = reinterpret_cast<const MClass*>(klass)->IsInterface();
+  for (size_t i = 0; i < methods.size(); ++i) { // Travel across the methods one by one.
+    auto methodPair = methods[i];
+    MethodMetaBase *method = methodPair.first;
+    uint16_t index = methodPair.second;
+    uint16_t hash = GetMethodMetaHash(*method);
+    uint16_t k = kAdjacencyInvalidValue;
+    size_t size = adjMethods.size();
+    if (LIKELY(size > 0)) {
+      for (k = adjMethods[hash % size].first; k != kAdjacencyInvalidValue; k = adjMethods[k].next) {
+        if (EqualMethod(*(virtualMethods[k].GetMethod()), *method)) { // Found.
+          break;
+        }
+      }
+    }
+    LINKER_VLOG(lazybinding) << "method=" << GetMethodFullName(*method) << ", vtabIndex=" << method->GetVtabIndex() <<
+        "->" << k << ", depth/index=" << depth.size() << "/" << index << ", interface=" << isInterface <<
+        ", isAbstract=" << modifier::IsAbstract(method->GetMod()) << ", ofClass=" << klass->GetName() << ", hash=" <<
+        hash << ", flag=" << method->GetFlag() << ", modifier=" << method->GetMod() << maple::endl;
+    if (k != kAdjacencyInvalidValue) { // Found, 'k' is the position.
+      // Class, and not abstract. Should we check CanAccess for class type.
+      // or Interface, and old method is also interface.
+      bool isAbstract = modifier::IsAbstract(method->GetMod());
+      bool canAccess = CanAccess(*(virtualMethods[k].GetMethod()), *method);
+      MClass *virtualClass = virtualMethods[k].GetMethod()->GetDeclaringClass();
+      if (virtualClass == nullptr) {
+        LINKER_LOG(FATAL) << "virtualClass is nullptr" << maple::endl;
+      }
+      if (!isAbstract && ((!isInterface && canAccess) || (isInterface && virtualClass->IsInterface()))) {
+        OverrideVTabMethod(virtualMethods, k, *method, depth, index, isInterface);
+      } else if (!isAbstract && !isInterface && !canAccess) {
+        // -1 means invalid vtab index, push_back directly.
+        AppendVTabMethod(virtualMethods, -1, *method, depth, index, isInterface, hash);
+      } else {
+        virtualMethods[k].isInterface = isInterface || virtualMethods[k].isInterface;
+      }
+    } else { // Not found.
+      // -1 means invalid vtab index, push_back directly.
+      AppendVTabMethod(virtualMethods, -1, *method, depth, index, isInterface, hash);
+    }
+  }
+}
+
+// Only for no decoupled classes.
+void MethodBuilder::CollectClassMethodsFast(const MClass *klass, const std::vector<uint16_t> &depth,
+    std::vector<MethodItem> &virtualMethods, const std::vector<std::pair<MethodMetaBase*, uint16_t>> &methods) {
+  bool isInterface = klass->IsInterface();
+  size_t methodNum = methods.size();
+  size_t size = virtualMethods.size();
+  virtualMethods.resize(size + methodNum);
+  int16_t ignoredNum = 0;
+  for (size_t i = 0; i < methodNum; ++i) { // Travel across the methods one by one.
+    auto methodPair = methods[i];
+    MethodMetaBase *method = methodPair.first;
+    uint16_t index = methodPair.second;
+    int16_t vtabIndex = method->GetVtabIndex();
+    uint16_t hash = GetMethodMetaHash(*method);
+    if (vtabIndex >= 0 && !isInterface) { // Class.
+      if (UNLIKELY(static_cast<size_t>(vtabIndex) < size && virtualMethods[vtabIndex].GetMethod() == nullptr)) {
+        LINKER_LOG(ERROR) << "null item" << ", method=" << GetMethodFullName(*method) << ", depth/index=" <<
+            depth.size() << "/" << index << ", hash=" << hash << "/" << virtualMethods[vtabIndex].hash <<
+            ", vtabIndex=" << vtabIndex << "/" << size << ", isAbstract=" << modifier::IsAbstract(method->GetMod()) <<
+            ", isInterface=" << isInterface << ", ofClass=" << klass->GetName() << maple::endl;
+      }
+      if (static_cast<size_t>(vtabIndex) < size &&
+          (virtualMethods[vtabIndex].GetMethod() == nullptr ||
+          CanAccess(*(virtualMethods[vtabIndex].GetMethod()), *method))) {
+        OverrideVTabMethod(virtualMethods, vtabIndex, *method, depth, index, isInterface);
+        ignoredNum++;
+        continue;
+      } else {
+        AppendVTabMethod(virtualMethods, vtabIndex, *method, depth, index, isInterface, hash);
+        continue;
+      }
+    }
+
+    LINKER_LOG(FATAL) << "negative vtab index, or interface, " << ", method=" << GetMethodFullName(*method) <<
+        ", hash=" << hash << ", vtabIndex=" << method->GetVtabIndex() << "->(" << size << "-" << ignoredNum <<
+        "), ofClass=" << klass->GetName() << maple::endl;
+  }
+  virtualMethods.resize(virtualMethods.size() - ignoredNum);
+}
+
+void MethodBuilder::CollectClassMethodsRecursive(MClass *klass, bool &isDecouple, std::set<MClass*> &checkedClasses,
+    std::vector<uint16_t> &depth, uint16_t superNum,
+    std::vector<MethodItem> &virtualMethods, MplLazyBindingVTableMapT &adjMethods) {
+  if (klass->IsColdClass() && !klass->IsLazyBinding()) {
+    LINKER_VLOG(lazybinding) << "cold class name=" << klass->GetName() << maple::endl;
+    pInvoker->ResolveColdClassSymbol(reinterpret_cast<jclass>(klass));
+  }
+
+#ifdef LINKER_RT_LAZY_CACHE
+  // superNum == 0xFFFF, means not to record depth.
+  if (superNum != static_cast<uint16_t>(-1)) {
+    depth.push_back(superNum);
+  }
+#endif // LINKER_RT_LAZY_CACHE
+
+  uint32_t superClassNum = klass->GetNumOfSuperClasses();
+  MClass **superClassArray = klass->GetSuperClassArrayPtr();
+  if (superClassNum != 0) {
+    // Check the supers of 'klass'.
+    for (uint32_t i = 0; i < superClassNum; ++i) {
+      MClass *superClass = superClassArray[i];
+      uint16_t num = 0;
+#ifdef LINKER_RT_LAZY_CACHE
+      if (superNum != static_cast<uint16_t>(-1)) {
+        num = i;
+      } else {
+        num = static_cast<uint16_t>(-1);
+      }
+#endif // LINKER_RT_LAZY_CACHE
+      CollectClassMethodsRecursive(superClass, isDecouple, checkedClasses, depth, num, virtualMethods, adjMethods);
+    }
+  }
+
+  // Check the 'klass'.
+  LINKER_VLOG(lazybinding) << "class=" << klass->GetName() << ", " << superNum << maple::endl;
+  if (!isDecouple) {
+    // Mark the class as not decoupled when its only superclass is object
+    isDecouple = (klass->IsDecouple() && (superClassNum != 1 || *superClassArray[0] != MRT_GetClassObject()));
+  }
+  bool isInterface = klass->IsInterface();
+  if (LIKELY(!isInterface || checkedClasses.count(klass) == 0)) {
+    CollectClassMethods(klass, isDecouple, depth, virtualMethods, adjMethods);
+  }
+  if (isInterface) {
+    checkedClasses.insert(klass);
+  }
+
+#ifdef LINKER_RT_LAZY_CACHE
+  if (superNum != static_cast<uint16_t>(-1)) {
+    depth.erase(depth.end() - 1);
+  }
+#endif // LINKER_RT_LAZY_CACHE
+}
+
+void MethodBuilder::GenerateAndAttachClassVTable(MClass *klass, std::vector<MethodItem> &virtualMethods) {
+  if (UNLIKELY(virtualMethods.size() == 0)) {
+    return;
+  }
+
+  LinkerVoidType *vtab = reinterpret_cast<LinkerVoidType*>(
+      MRT_AllocFromDecouple(sizeof(LinkerVTableItem) * virtualMethods.size(), kVTabArray));
+  if (UNLIKELY(vtab == nullptr)) {
+    LINKER_LOG(FATAL) << "returns null" << maple::endl;
+    return;
+  }
+
+  LinkerVTableItem *item = reinterpret_cast<LinkerVTableItem*>(vtab);
+  for (uint32_t i = 0; i < virtualMethods.size(); ++i) {
+    item->index = reinterpret_cast<size_t>(virtualMethods[i].GetMethod()->GetFuncAddress());
+    item++;
+  }
+  reinterpret_cast<ClassMetadata*>(klass)->vTable.SetDataRef(vtab);
+}
+
+inline uint16_t MethodBuilder::GetMethodMetaHash(const MethodMetaBase &method) {
+  uint16_t hash = kMethodHashMask;
+  if (!method.IsMethodMetaCompact()) {
+    hash = reinterpret_cast<MethodMeta*>(const_cast<MethodMetaBase*>(&method))->GetHashCode();
+  }
+  if (hash == kMethodHashMask) {
+    hash = MClass::GetMethodFieldHash(method.GetName(), GetMethodSignature(method).c_str(), true);
+  }
+  return hash;
+}
+
+std::string MethodBuilder::GetMethodFullName(const MethodMetaBase &method) {
+  const char *methodName = method.GetName();
+  std::string name = methodName;
+  name += '|';
+  if (!method.IsMethodMetaCompact()) {
+    name += reinterpret_cast<const MethodMeta*>(&method)->GetSignature();
+  } else {
+    std::string signature;
+    method.GetSignature(signature);
+    name += signature;
+  }
+  return name;
+}
+
+inline std::string MethodBuilder::GetMethodSignature(const MethodMetaBase &method) const {
+  if (!method.IsMethodMetaCompact()) {
+    return std::string(reinterpret_cast<const MethodMeta*>(&method)->GetSignature());
+  } else {
+    std::string signature;
+    method.GetSignature(signature);
+    return signature;
+  }
+}
+
+// If the method name and signature are equal.
+bool MethodBuilder::EqualMethod(const MethodMetaBase &method1, const MethodMetaBase &method2) {
+  if (strcmp(method1.GetName(), method2.GetName()) != 0) {
+    return false;
+  }
+
+  std::string signature1;
+  const char *method1Signature;
+  if (!method1.IsMethodMetaCompact()) {
+    method1Signature = reinterpret_cast<const MethodMeta*>(&method1)->GetSignature();
+  } else {
+    method1.GetSignature(signature1);
+    method1Signature = signature1.c_str();
+  }
+  std::string signature2;
+  const char *method2Signature;
+  if (!method2.IsMethodMetaCompact()) {
+    method2Signature = reinterpret_cast<const MethodMeta*>(&method2)->GetSignature();
+  } else {
+    method2.GetSignature(signature2);
+    method2Signature = signature2.c_str();
+  }
+  return strcmp(method1Signature, method2Signature) == 0;
+}
+
+inline bool MethodBuilder::EqualMethod(
+    const MethodMetaBase *method, const char *methodName, const char *methodSignature) {
+  if (strcmp(method->GetName(), methodName) != 0) {
+    return false;
+  }
+
+  std::string tmp;
+  const char *signature;
+  if (!method->IsMethodMetaCompact()) {
+    signature = reinterpret_cast<const MethodMeta*>(method)->GetSignature();
+  } else {
+    method->GetSignature(tmp);
+    signature = tmp.c_str();
+  }
+  return strcmp(signature, methodSignature) == 0;
+}
+
+// Also see VtableAnalysis::CheckOverrideForCrossPackage at compiler side.
+// Return true if virtual functions can be set override relationship.
+// We just check if the base method is visibile for current method.
+inline bool MethodBuilder::CanAccess(
+    const MethodMetaBase &baseMethod, const MethodMetaBase &currentMethod) {
+  // For the corss package inheritance, only if the base func is declared
+  // as either 'public' or 'protected', we shall set override relationship.
+  if (modifier::IsPublic(baseMethod.GetMod()) || modifier::IsProtected(baseMethod.GetMod())) {
+    return true;
+  }
+  MClass *basePackageClass = baseMethod.GetDeclaringClass();
+  MClass *currentPackageClass = currentMethod.GetDeclaringClass();
+  if (basePackageClass == nullptr || currentPackageClass == nullptr) {
+    LINKER_LOG(FATAL) << "class is null" << maple::endl;
+  }
+  char *basePackageName = basePackageClass->GetName();
+  char *currentPackageName = currentPackageClass->GetName();
+  char *basePos = strrchr(basePackageName, '/'); // Reverse find the end of package
+  char *currentPos = strrchr(currentPackageName, '/'); // Reverse find the end of package
+  uint32_t basePackageLen = (basePos == nullptr) ? 0 : static_cast<uint32_t>(basePos - basePackageName);
+  uint32_t currentPackageLen = (currentPos == nullptr) ? 0 : static_cast<uint32_t>(currentPos - currentPackageName);
+  if (basePackageLen == currentPackageLen && strncmp(basePackageName, currentPackageName, basePackageLen) == 0) {
+    return true;
+  }
+
+  LINKER_VLOG(lazybinding) << "return false, method=" << GetMethodFullName(currentMethod) << ", baseClass=" <<
+      basePackageName << ", currentClass=" << currentPackageName << maple::endl;
+  return false;
+}
+
+// virtualMethods: In
+// firstITabVector: Out
+// firstITabConflictVector: Out
+// maxFirstITabIndex: Out
+inline uint32_t MethodBuilder::ProcessITableFirstTable(std::vector<MethodItem> &virtualMethods,
+    std::vector<MethodMetaBase*> &firstITabVector, std::vector<MethodMetaBase*> &firstITabConflictVector,
+    uint32_t &maxFirstITabIndex) {
+  uint32_t num = 0;
+  std::vector<bool> firstITabConflictFlagVector(maple::kItabFirstHashSize, false);
+  for (size_t i = 0; i < virtualMethods.size(); ++i) {
+    MethodItem methodItem = virtualMethods[i];
+    if (!methodItem.isInterface) {
+      continue;
+    }
+    ++num;
+
+    // Should check if we can directly use GetMethodMetaHash, and mod maple::kHashSize.
+    auto name = GetMethodFullName(*(methodItem.GetMethod()));
+    uint32_t hash = GetHashIndex(name.c_str());
+    if (hash > maxFirstITabIndex) {
+      maxFirstITabIndex = hash;
+    }
+    if (firstITabVector[hash] == nullptr && !firstITabConflictFlagVector[hash]) { // First insertion.
+      firstITabVector[hash] = methodItem.GetMethod();
+    } else { // Conflict
+      if (!firstITabConflictFlagVector[hash]) { // First conflict.
+        firstITabConflictVector.push_back(firstITabVector[hash]);
+        firstITabConflictVector.push_back(methodItem.GetMethod());
+        firstITabVector[hash] = nullptr;
+        firstITabConflictFlagVector[hash] = true;
+      } else { // Successive conflicts.
+        firstITabConflictVector.push_back(methodItem.GetMethod());
+      }
+    }
+  }
+  return num;
+}
+
+// firstITabConflictVector: In
+// secondITableMap: Out
+// secondITabConflictVector: Out
+inline size_t MethodBuilder::ProcessITableSecondTable(std::vector<MethodMetaBase*> &firstITabConflictVector,
+    std::map<uint32_t, MethodMetaBase*> &secondITableMap, std::vector<MethodMetaBase*> &secondITabConflictVector) {
+  size_t sizeOfMethodsNames = 0;
+  for (size_t i = 0; i < firstITabConflictVector.size(); ++i) { // Travel across the methods one by one.
+    MethodMetaBase *method = firstITabConflictVector[i];
+    auto name = GetMethodFullName(*method);
+    sizeOfMethodsNames += name.size() + 1;
+    uint32_t hash = maple::GetSecondHashIndex(name.c_str());
+    if (secondITableMap.find(hash) == secondITableMap.end()) { // First insertion.
+      secondITableMap[hash] = method;
+    } else { // Conflict.
+      if (secondITableMap[hash] != nullptr) { // First conflict.
+        secondITabConflictVector.push_back(secondITableMap[hash]);
+        secondITabConflictVector.push_back(method);
+        secondITableMap[hash] = nullptr; // Set null as conflict flag temporarily.
+      } else { // Successive conflicts.
+        secondITabConflictVector.push_back(method);
+      }
+    }
+  }
+  return sizeOfMethodsNames;
+}
+
+inline void MethodBuilder::GenerateITableFirstTable(LinkerVoidType &itab,
+    const std::vector<MethodMetaBase*> &firstITabVector,
+    const std::vector<MethodMetaBase*> &firstITabConflictVector, uint32_t maxFirstITabIndex) const {
+  // ITable's first table
+  size_t firstITabVectorSize = firstITabConflictVector.empty() ? maxFirstITabIndex + 1 : firstITabVector.size();
+  for (size_t i = 0; i < firstITabVectorSize; ++i) {
+    auto method = firstITabVector[i];
+    if (LIKELY(method != nullptr)) {
+      (&itab)[i] = reinterpret_cast<uintptr_t>(method->GetFuncAddress());
+    }
+  }
+}
+
+inline void MethodBuilder::GenerateITableSecondTable(
+    LinkerVoidType &itab, std::map<uint32_t, MethodMetaBase*> &secondITableMap,
+    std::vector<MethodMetaBase*> &secondITabConflictVector, size_t sizeOfITabNoNames) {
+  // kHeadSizeOfSecondHash:3
+  // The last one points to the second level table
+  (&itab)[maple::kHashSize] = reinterpret_cast<uintptr_t>(&itab + maple::kHashSize + 1);
+  int pos = maple::kHashSize + 1;
+  /// Hash table: size + align
+#ifdef USE_32BIT_REF
+  uint64_t shiftCountBit = 16; // 16 is 4 x 4
+#else
+  uint64_t shiftCountBit = 32; // 32 is 8 x 4
+#endif
+  (&itab)[pos++] = ((secondITabConflictVector.size() | (1UL << (shiftCountBit - 1))) << shiftCountBit) +
+      secondITableMap.size();
+  (&itab)[pos++] = maple::kFlagAgInHeadOfSecondHash;
+
+  /// Hash table: hash + method address
+  for (auto &item : secondITableMap) {
+    auto method = item.second;
+    (&itab)[pos++] = item.first;
+    (&itab)[pos++] = method != nullptr ?
+        reinterpret_cast<uintptr_t>(method->GetFuncAddress()) : maple::kFlagSecondHashConflict;
+  }
+
+  // Conflict table: method string + address
+  char *methodsNames = reinterpret_cast<char*>(&itab + sizeOfITabNoNames);
+  int namePos = 0;
+  for (size_t i = 0; i < secondITabConflictVector.size(); i++) { // Travel across the methods one by one.
+    auto method = secondITabConflictVector[i];
+    // Copy the method's name firstly.
+    std::string name = GetMethodFullName(*method);
+    size_t len = name.size();
+    if (UNLIKELY(strcpy_s(methodsNames + namePos, len + 1, name.c_str()) != EOK)) {
+      free(&itab);
+      LINKER_LOG(FATAL) << "strcpy_s() failed" << maple::endl;
+    }
+    (methodsNames + namePos)[len] = '\0';
+
+    LINKER_DLOG(lazybinding) << "conflict name[" << pos << "][" << namePos << "]: " <<
+        reinterpret_cast<uintptr_t>(method->GetFuncAddress()) << "/" << (methodsNames + namePos) << maple::endl;
+    // Set the name and address.
+    (&itab)[pos++] = reinterpret_cast<uintptr_t>(methodsNames + namePos);
+    (&itab)[pos++] = reinterpret_cast<uintptr_t>(method->GetFuncAddress());
+
+    // Next method's name offset.
+    namePos += len + 1;
+  }
+}
+
+void MethodBuilder::GenerateAndAttachClassITable(MClass *klass, std::vector<MethodItem> &virtualMethods) {
+  if (UNLIKELY(klass->IsAbstract())) {
+    return;
+  }
+  // Filter the methods for the first level table of itable.
+  uint32_t maxFirstITabIndex = 0;
+  std::vector<MethodMetaBase*> firstITabVector(maple::kItabFirstHashSize, nullptr);
+  std::vector<MethodMetaBase*> firstITabConflictVector;
+  if (ProcessITableFirstTable(
+      virtualMethods, firstITabVector, firstITabConflictVector, maxFirstITabIndex) == 0) {
+    reinterpret_cast<ClassMetadata*>(klass)->iTable.SetDataRef(nullptr);
+    return;
+  }
+  // Collect the second level table of itable.
+  std::map<uint32_t, MethodMetaBase*> secondITableMap;
+  std::vector<MethodMetaBase*> secondITabConflictVector;
+  size_t sizeOfMethodsNames = ProcessITableSecondTable(
+      firstITabConflictVector, secondITableMap, secondITabConflictVector);
+  size_t sizeOfITab = 0;
+  size_t sizeOfITabNoNames = 0;
+  if (firstITabConflictVector.empty()) { // No conflict in first level table.
+    sizeOfITab += maxFirstITabIndex + 1;
+    sizeOfITab = sizeOfITab * sizeof(LinkerVoidType);
+  } else {
+    sizeOfITabNoNames = maple::kHashSize + maple::kHeadSizeOfSecondHash +
+        secondITableMap.size() * 2 + secondITabConflictVector.size() * 2; // 2 is to skit length of table
+    sizeOfITab += sizeOfITabNoNames + sizeOfMethodsNames;
+    sizeOfITab = sizeOfITab * sizeof(LinkerVoidType);
+  }
+  LINKER_DLOG(lazybinding) << "size of itab :" << sizeOfITab << maple::endl;
+  LinkerVoidType *itab = reinterpret_cast<LinkerVoidType*>(MRT_AllocFromDecouple(sizeOfITab, kITabAggregate));
+  if (UNLIKELY(itab == nullptr)) {
+    LINKER_LOG(FATAL) << "MRT_NewPermObj returns null" << maple::endl;
+    return;
+  }
+  if (UNLIKELY(memset_s(itab, sizeOfITab, 0, sizeOfITab) != EOK)) {
+    LINKER_LOG(ERROR) << "memset_s() failed" << maple::endl;
+    return;
+  }
+  GenerateITableFirstTable(*itab, firstITabVector, firstITabConflictVector, maxFirstITabIndex);
+  if (firstITabConflictVector.empty()) { // No conflict in first level table.
+    reinterpret_cast<ClassMetadata*>(klass)->iTable.SetDataRef(itab);
+    return;
+  }
+  GenerateITableSecondTable(*itab, secondITableMap, secondITabConflictVector, sizeOfITabNoNames);
+  reinterpret_cast<ClassMetadata*>(klass)->iTable.SetDataRef(itab);
+}
+
+inline int32_t MethodBuilder::GetVTableItemIndex(
+    const MClass *klass, MplLazyBindingVTableMapT &adjMethods, const char *methodName, const char *methodSignature) {
+  size_t size = adjMethods.size();
+  if (LIKELY(size > 0)) {
+    uint16_t hash = MClass::GetMethodFieldHash(methodName, methodSignature, true);
+    uint16_t pos = hash % size;
+    uint16_t k = kAdjacencyInvalidValue;
+    for (k = adjMethods[pos].first; k != kAdjacencyInvalidValue; k = adjMethods[k].next) {
+      MethodMetaBase *method = adjMethods[k].GetMethod();
+      if (EqualMethod(method, methodName, methodSignature)) { // Found.
+        return k;
+      }
+    }
+  }
+  LINKER_LOG(ERROR) << "failed to find method=" << methodName << "|" << methodSignature << ", " << size <<
+      ", in class=" << klass->GetName() << maple::endl;
+  return -1;
+}
+
+int32_t MethodBuilder::UpdateOffsetTableByVTable(const MClass *klass, MplLazyBindingVTableMapT &adjMethods,
+    LinkerVTableOffsetItem &vtableOffsetItem, LinkerOffsetValItem &offsetTableItem) {
+  DataRefOffset32 *dataMethodName = reinterpret_cast<DataRefOffset32*>(&vtableOffsetItem.methodName);
+  const char *method = dataMethodName->GetDataRef<char*>();
+  DataRefOffset32 *dataSignatureName = reinterpret_cast<DataRefOffset32*>(&vtableOffsetItem.signatureName);
+  const char *signature = dataSignatureName->GetDataRef<char*>();
+  int32_t index = GetVTableItemIndex(klass, adjMethods, method, signature);
+  if (LIKELY(index >= 0)) {
+    offsetTableItem.offset = index * sizeof(LinkerVTableItem);
+  }
+  return index;
+}
+
+int32_t MethodBuilder::UpdateOffsetTableByVTable(const MClass *klass, MplLazyBindingVTableMapT &adjMethods,
+    LinkerVTableOffsetItem &vtableOffsetItem, LinkerOffsetValItemLazyLoad &offsetTableItem) {
+  DataRefOffset32 *klassMethod = reinterpret_cast<DataRefOffset32*>(&vtableOffsetItem.methodName);
+  const char *method = klassMethod->GetDataRef<char*>();
+  DataRefOffset32 *klassSignature = reinterpret_cast<DataRefOffset32*>(&vtableOffsetItem.signatureName);
+  const char *signature = klassSignature->GetDataRef<char*>();
+  int32_t index = GetVTableItemIndex(klass, adjMethods, method, signature);
+  if (LIKELY(index >= 0)) {
+    offsetTableItem.offset = index * sizeof(LinkerVTableItem);
+    offsetTableItem.offsetAddr = AddressToRefField(reinterpret_cast<uintptr_t>(&offsetTableItem.offset));
+  }
+  return index;
+}
+
+inline void MethodBuilder::BuildMethodVTableITable(MClass *klass, std::vector<MethodItem> &virtualMethods) {
+  if (reinterpret_cast<ClassMetadata*>(klass)->vTable.refVal == 0) {
+    GenerateAndAttachClassVTable(klass, virtualMethods);
+  }
+  if (reinterpret_cast<ClassMetadata*>(klass)->iTable.refVal == 0) {
+    GenerateAndAttachClassITable(klass, virtualMethods);
+  }
+}
+
+#ifdef LINKER_RT_LAZY_CACHE
+MethodMetaBase* MethodBuilder::GetMethodByIndex(MClass *klass, uint16_t index) {
+  uint32_t methodNum = klass->GetNumOfMethods();
+  MethodMeta *methodMetas = klass->GetRawMethodMetas();
+  if (UNLIKELY(methodNum == 0 || methodMetas == nullptr)) {
+    LINKER_LOG(WARNING) << "invalid method, " << klass << "/" << klass->GetName() <<
+        ", " << methodNum << ", " << methodMetas << maple::endl;
+    return nullptr;
+  }
+  bool isCompactMeta = __MRT_IsCompactMeta(reinterpret_cast<uintptr_t>(methodMetas));
+  if (!isCompactMeta) {
+    method = reinterpret_cast<MethodMetaBase*>(&methodMetas[index]);
+  } else {
+    MethodMetaCompact *compact = MethodMetaCompact::GetMethodMetaCompact(*klass, index);
+    method = reinterpret_cast<MethodMetaBase*>(compact);
+  }
+  return method;
+}
+
+void MethodBuilder::BuildMethodByCachingIndex(MClass *klass, const std::string &cachingIndex) {
+  std::vector<MethodItem> virtualMethods;
+  std::string::size_type startPos = 0;
+  while (true) {
+    std::string::size_type endPos = cachingIndex.find(',', startPos);
+    if (endPos == std::string::npos) {
+      break;
+    }
+
+    bool isInterface = false;
+    std::string::size_type indexPos = cachingIndex.find('#', startPos);
+    if (indexPos == std::string::npos || indexPos > endPos) {
+      indexPos = cachingIndex.find('!', startPos);
+      isInterface = true;
+    }
+    constexpr int decimalBase = 10;
+    auto index = std::strtol(cachingIndex.c_str() + indexPos + 1, nullptr, decimalBase);
+
+    // There're 3 type for depth info.:
+    // 1. If the depth is not like 0/0/0/, for example 0/1/, we should record the whole depth info.
+    // 2. If the depth is like 0/0/0/, we could only record the depth number(2).
+    // 3. Further if the depth is 0, we could ignore it as default.
+    std::vector<uint16_t> depth;
+    char *depthStr == nullptr;
+    auto tmp = std::strtol(cachingIndex.c_str() + startPos, &depthStr, decimalBase);
+    if (tmp == 0 && depthStr == cachingIndex.c_str() + startPos) { // Type 3, needn't push anything.
+    } else if (*depthStr != '/') { // Type 2.
+      depth.resize(tmp, 0);
+    } else { // Type 1.
+      // Ignore the first depth.
+      depthStr++;
+      while (depthStr != cachingIndex.c_str() + indexPos) {
+        tmp = std::strtol(depthStr, &depthStr, decimalBase);
+        depth.push_back(tmp);
+        depthStr++;
+      }
+    }
+
+    MClass *superClass = klass;
+    for (uint32_t i = 0; i < depth.size(); ++i) {
+      uint16_t superNum = depth[i];
+      MClass **superClassArray = klass->GetSuperClassArrayPtr();
+      // We trust the caching info. and don't check __MRT_Class_getNumofSuperClasses() here.
+      superClass = superClassArray[superNum];
+    }
+
+    auto method = GetMethodByIndex(superClass, index);
+    uint16_t hash = GetMethodMetaHash(*method);
+    MethodItem methodItem;
+    methodItem.SetMethod(*method);
+    methodItem.isInterface = isInterface;
+    methodItem.hash = hash;
+    virtualMethods.push_back(std::move(methodItem));
+    startPos = endPos + 1;
+  }
+
+  BuildMethodVTableITable(klass, virtualMethods);
+}
+
+std::string MethodBuilder::GetMethodCachingIndexString(MClass *klass, std::vector<MethodItem> &virtualMethods) {
+  std::string vtabIndexStr;
+  for (uint32_t i = 0; i < virtualMethods.size(); ++i) {
+    bool mainLine = true;
+    std::string depthStr;
+    for (uint32_t j = 0; j < virtualMethods[i].depth.size(); ++j) {
+      if (virtualMethods[i].depth[j] != 0) {
+        mainLine = false;
+      }
+      depthStr += std::to_string(virtualMethods[i].depth[j]);
+      depthStr += '/';
+    }
+
+    // There're 3 type for depth info.:
+    // 1. If the depth is not like 0/0/0/, for example 0/1/, we should record the whole depth info.
+    // 2. If the depth is like 0/0/0/, we could only record the depth number(2).
+    // 3. Further if the depth is 0, we could ignore it as default.
+    if (!mainLine) {
+      vtabIndexStr += depthStr;
+    } else {
+      if (virtualMethods[i].depth.size() > 1) {
+        vtabIndexStr += std::to_string(virtualMethods[i].depth.size() - 1);
+      }
+    }
+    if (virtualMethods[i].isInterface) {
+      vtabIndexStr += '!';
+    } else {
+      vtabIndexStr += '#';
+    }
+    vtabIndexStr += std::to_string(virtualMethods[i].index);
+    vtabIndexStr += ',';
+  }
+  LINKER_DLOG(lazybinding) << "vtabIndexStr=" << vtabIndexStr << ", for " << klass->GetName() << maple::endl;
+  return vtabIndexStr;
+}
+#endif // LINKER_RT_LAZY_CACHE
+
+MplLazyBindingVTableMapT MethodBuilder::GetMethodVTableMap(MClass *klass) {
+  std::set<MClass*> checkedClasses;
+  std::vector<MethodItem> virtualMethods;
+  MplLazyBindingVTableMapT adjMethods;
+  bool isDecouple = false;
+  std::vector<uint16_t> depth;
+  CollectClassMethodsRecursive(
+      klass, isDecouple, checkedClasses, depth, static_cast<uint16_t>(-1), virtualMethods, adjMethods);
+  return adjMethods;
+}
+
+std::string MethodBuilder::BuildMethod(MClass *klass) {
+  std::set<MClass*> checkedClasses;
+  std::vector<MethodItem> virtualMethods;
+  MplLazyBindingVTableMapT adjMethods;
+  bool isDecouple = false;
+  std::vector<uint16_t> depth;
+  CollectClassMethodsRecursive(klass, isDecouple, checkedClasses, depth, 0, virtualMethods, adjMethods);
+  BuildMethodVTableITable(klass, virtualMethods);
+  std::string res;
+#ifdef LINKER_RT_LAZY_CACHE
+  res = GetMethodCachingIndexString(klass, virtualMethods);
+#endif // LINKER_RT_LAZY_CACHE
+  return res;
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/linker/linker_model.cpp b/src/mrt/compiler-rt/src/linker/linker_model.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a342b2c00a8aec1d7ea97f1156bad0296910a7f5
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_model.cpp
@@ -0,0 +1,659 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker_model.h"
+
+#include <thread>
+#include <dirent.h>
+#include <fstream>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <sys/file.h>
+#include <atomic>
+
+#include "file_system.h"
+#include "linker/linker_inline.h"
+#ifdef LINKER_DECOUPLE
+#include "linker/decouple/linker_decouple.h"
+#endif
+#include "linker/linker_cache.h"
+#include "linker/linker_debug.h"
+#include "linker/linker_hotfix.h"
+#include "linker/linker_lazy_binding.h"
+#include "utils/name_utils.h"
+#include "file_layout.h"
+#include "collector/cp_generator.h"
+
+using namespace maple;
+namespace maplert {
+using namespace linkerutils;
+bool LinkerMFileInfo::BelongsToApp() {
+  LinkerInvoker &invoker = LinkerAPI::As<LinkerInvoker&>();
+  return (!IsFlag(kIsBoot) && !invoker.IsSystemClassLoader(reinterpret_cast<MObject*>(this->classLoader)));
+}
+
+void LinkerMFileInfo::ReleaseReadOnlyMemory() {
+  LINKER_VLOG(mpllinker) << "release file-mapped readonly memory for " << name << maple::endl;
+
+   // release .refl_strtab
+  ReleaseMemory(this->coldStrTab, this->coldStrTabEnd);
+
+  // release .rometadata for java methods
+  ReleaseMemory(this->rometadataMethodStart, this->rometadataMethodEnd);
+
+  // release .rometadata for java fields
+  ReleaseMemory(this->rometadataFieldStart, this->rometadataFieldEnd);
+
+  // release .romuidtab
+  ReleaseMemory(this->romuidtabStart, this->romuidtabEnd);
+}
+
+LinkerInvoker::LinkerInvoker() {
+  InitProtectedRegion();
+}
+LinkerInvoker::~LinkerInvoker() {
+  features.clear();
+  ClearLinkerMFileInfo();
+  pLoader = nullptr;
+}
+
+// Fetch the method address by index directly, in the define table of 'handle'.
+void *LinkerInvoker::GetMethodSymbolAddress(LinkerMFileInfo &mplInfo, size_t index) {
+  size_t methodDefSize = mplInfo.GetTblSize(kMethodDef);
+  if (methodDefSize == 0) {
+    LINKER_LOG(ERROR) << "failed, the size of methodDef is zero in " << mplInfo.name << maple::endl;
+    return nullptr;
+  }
+  AddrSlice methodDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig), methodDefSize);
+  if (index < methodDefSize) {
+    return GetDefTableAddress(mplInfo, methodDefSlice, index, true);
+  }
+  return nullptr;
+}
+
+// Fetch the data address by index directly, in the define table of 'handle'.
+void *LinkerInvoker::GetDataSymbolAddress(LinkerMFileInfo &mplInfo, size_t index) {
+  size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+  if (dataDefSize == 0) {
+    LINKER_LOG(ERROR) << "failed, the size of dataDef is zero in " << mplInfo.name << maple::endl;
+    return nullptr;
+  }
+  AddrSlice dataDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), dataDefSize);
+  if (index < dataDefSize) {
+    return GetDefTableAddress(mplInfo, dataDefSlice, index, false);
+  }
+  return nullptr;
+}
+
+bool LinkerInvoker::DoLocateAddress(const LinkerMFileInfo &mplInfo, LinkerLocInfo &info, const void *addr,
+    const AddrSlice &addrSlice, const InfTableSlice &infTableSlice, int64_t pos, bool getName) {
+  if (pos != -1) {
+    info.size = infTableSlice[static_cast<size_t>(pos)].size;
+    info.addr = GetDefTableAddress(mplInfo, addrSlice, static_cast<size_t>(pos), true);
+    if (getName) {
+      info.sym = GetMethodSymbolByOffset(infTableSlice[static_cast<size_t>(pos)]);
+      // Get library name.
+      info.path = mplInfo.name;
+    } else {
+      info.sym = "";
+      info.path = "";
+    }
+    return true;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed, not found addr=" << addr << " in " << mplInfo.name << maple::endl;
+  }
+  return false;
+}
+
+// Locate the address for method, which defined in the .so of 'handle'.
+// Also see int dladdr(void *addr, Dl_info *info)
+bool LinkerInvoker::LocateAddress(LinkerMFileInfo &mplInfo, const void *addr, LinkerLocInfo &info, bool getName) {
+  size_t methodDefSize = mplInfo.GetTblSize(kMethodDef);
+  if (methodDefSize == 0) {
+    LINKER_DLOG(mpllinker) << "failed, size is zero, in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  AddrSlice methodDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig), methodDefSize);
+  size_t indexSize = mplInfo.GetTblSize(kMethodMuidIndex);
+  if (indexSize == 0) {
+    LINKER_LOG(ERROR) << "failed, muidIndexTable size is zero" << " in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  MuidIndexSlice muidIndexSlice = MuidIndexSlice(
+      mplInfo.GetTblBegin<LinkerMuidIndexTableItem*>(kMethodMuidIndex), indexSize);
+  size_t infSize = mplInfo.GetTblSize(kMethodInfo);
+  if (infSize == 0 || infSize != methodDefSize) {
+    LINKER_LOG(ERROR) << "failed, infTable size is 0, or tables size are not equal, " << infSize << " vs. " <<
+        methodDefSize << " in " << mplInfo.name << maple::endl;
+    return false;
+  }
+  InfTableSlice infTableSlice = InfTableSlice(mplInfo.GetTblBegin<LinkerInfTableItem*>(kMethodInfo), infSize);
+
+  const size_t start = 0;
+  size_t end = indexSize - 1;
+  size_t scopeStartAddr = mplInfo.GetTblBegin<size_t>(kJavaText);
+  size_t scopeEndAddr = scopeStartAddr + mplInfo.GetTblSize(kJavaText);
+  int64_t pos = BinarySearchIndex<AddrSlice, MuidIndexSlice, InfTableSlice>(mplInfo, methodDefSlice, start, end,
+      reinterpret_cast<size_t>(addr), muidIndexSlice, infTableSlice, scopeStartAddr, scopeEndAddr);
+  return DoLocateAddress(mplInfo, info, addr, methodDefSlice, infTableSlice, pos, getName);
+}
+
+// Locate the address for method, by traversal all open maple .so files.
+// Also see int dladdr(void *addr, Dl_info *info)
+bool LinkerInvoker::LocateAddress(const void *addr, LinkerLocInfo &info, bool getName) {
+  if (UNLIKELY(addr == nullptr)) {
+    return false;
+  }
+  LinkerMFileInfo *mplInfo = GetLinkerMFileInfo(kFromPC, addr);
+  if (mplInfo != nullptr) {
+    if (LocateAddress(*mplInfo, addr, info, getName)) {
+      return true;
+    }
+    LINKER_VLOG(mpllinker) << "failed, not found " << addr << maple::endl;
+  } else {
+    LINKER_VLOG(mpllinker) << "failed, not found in JAVA section for " << addr << maple::endl;
+  }
+  return false;
+}
+
+// Return the LinkerMFileInfo pointer, null if not found.
+LinkerMFileInfo *LinkerInvoker::SearchAddress(const void *pc, AddressRangeType type, bool isLazyBinding) {
+  if (type == kTypeText) {
+    return mplInfoElfAddrSet.SearchJavaText(pc);
+  }
+  if (isLazyBinding) {
+    return mplInfoElfAddrLazyBindingSet.Search(pc, type);
+  } else {
+    return mplInfoElfAddrSet.Search(pc, type);
+  }
+}
+
+// Get offset vtable origin address.
+void *LinkerInvoker::GetMplOffsetValue(LinkerMFileInfo &mplInfo) {
+  void *tableAddr = mplInfo.GetTblBegin(kValueOffset);
+  return reinterpret_cast<char*>(tableAddr) + sizeof(LinkerOffsetKeyTableInfo);
+}
+
+// Get mpl linker validity code from range table.
+MUID LinkerInvoker::GetValidityCode(LinkerMFileInfo &mplInfo) const {
+  if (mplInfo.hash.data.words[0] == 0 && mplInfo.hash.data.words[1] == 0) {
+    mplInfo.hash.data.words[0] = mplInfo.GetTblBegin<uintptr_t>(kRange);
+    mplInfo.hash.data.words[1] = mplInfo.GetTblEnd<uintptr_t>(kRange);
+  }
+  return mplInfo.hash;
+}
+
+// Get decouple validity code from range table.
+MUID LinkerInvoker::GetValidityCodeForDecouple(LinkerMFileInfo &mplInfo) const {
+  if (mplInfo.hashOfDecouple.data.words[0] == 0 && mplInfo.hashOfDecouple.data.words[1] == 0) {
+    mplInfo.hashOfDecouple.data.words[0] = mplInfo.GetTblBegin<uintptr_t>(kDecouple);
+    mplInfo.hashOfDecouple.data.words[1] = mplInfo.GetTblEnd<uintptr_t>(kDecouple);
+  }
+  return mplInfo.hashOfDecouple;
+}
+
+// see if class's super symbol has been resolved
+#ifdef LINKER_DECOUPLE
+bool LinkerInvoker::IsClassComplete(const MClass &classInfo) {
+  MClass **superTable = classInfo.GetSuperClassArrayPtr();
+  uint32_t superSize = classInfo.GetNumOfSuperClasses();
+  if (superTable != nullptr && superSize > 0) {
+    if (!classInfo.IsColdClass()) {
+      for (uint32_t i = 0; i < superSize; ++i) {
+        LinkerRef ref(superTable[i]);
+        if (ref.IsEmpty() || ref.IsIndex() || !IsClassComplete(*superTable[i])) {
+          return false;
+        }
+      }
+    } else {
+      DecoupleMFileInfo *mplInfo = reinterpret_cast<DecoupleMFileInfo*>(SearchAddress(&classInfo, kTypeClass));
+      if (mplInfo == nullptr) {
+        LOG(ERROR) << "Decouple::IsClassComplete: not find so for " << classInfo.GetName() << maple::endl;
+        return false;
+      }
+      for (uint32_t i = 0; i < superSize; ++i) {
+        MClass *superClass = superTable[i];
+        LinkerRef ref(superClass);
+        if (ref.IsIndex()) {
+          size_t index = ref.GetIndex();
+          bool fromUndef = ref.IsFromUndef();
+          if (fromUndef && index < mplInfo->dataUndefSlice.Size() && !mplInfo->dataUndefSlice.Empty()) {
+            superClass = static_cast<MClass*>(mplInfo->dataUndefSlice[index].Address());
+          } else if (!fromUndef && index < mplInfo->dataDefSlice.Size() && !mplInfo->dataDefSlice.Empty()) {
+            superClass = static_cast<MClass*>(GetDefTableAddress(*mplInfo, mplInfo->dataDefSlice, index, false));
+          }
+        }
+        if (superClass == nullptr || !IsClassComplete(*superClass)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+#endif
+
+void *LinkerInvoker::GetClassMetadataLazily(const void *offsetTable, size_t classIndex) {
+  LinkerMFileInfo *mplInfo = GetLinkerMFileInfo(kFromAddr, offsetTable, true);
+  if (mplInfo == nullptr) {
+    LINKER_LOG(FATAL) << "failed to find mplInfo for " << offsetTable << maple::endl;
+  }
+  return GetClassMetadataLazily(*mplInfo, classIndex);
+}
+
+BindingState LinkerInvoker::GetAddrBindingState(LinkerVoidType addr) {
+  return Get<LazyBinding>()->GetAddrBindingState(addr);
+}
+BindingState LinkerInvoker::GetAddrBindingState(const AddrSlice &addrSlice, size_t index, bool isAtomic) {
+  return Get<LazyBinding>()->GetAddrBindingState(addrSlice, index, isAtomic);
+}
+void LinkerInvoker::DumpStackInfoInLog() {
+  Get<Debug>()->DumpStackInfoInLog();
+}
+void *LinkerInvoker::GetClassMetadataLazily(LinkerMFileInfo &mplInfo, size_t classIndex) {
+  return Get<LazyBinding>()->GetClassMetadata(mplInfo, classIndex);
+}
+
+MObject *LinkerInvoker::GetClassLoaderByAddress(LinkerMFileInfo &mplInfo, const void *addr) {
+  if (addr != nullptr) {
+    LINKER_VLOG(lazybinding) << "addr=" << addr << ", in " << mplInfo.name << maple::endl;
+    LinkerLocInfo info;
+    if (LocateAddress(mplInfo, addr, info, false) == false) {
+      LINKER_LOG(ERROR) << "failed to locate, addr=" << addr << maple::endl;
+      return nullptr;
+    }
+    uint32_t *method = static_cast<uint32_t*>(const_cast<void*>(info.addr));
+    // To get the declaring class of the method.
+    void *md = JavaFrame::GetMethodMetadata(method);
+    if (md != nullptr) {
+      const MethodMetaBase *methodMeta = reinterpret_cast<const MethodMetaBase*>(md);
+      return reinterpret_cast<MObject*>(MRT_GetClassLoader(*methodMeta->GetDeclaringClass()));
+    }
+  }
+  return nullptr;
+}
+
+// Look up the method address with MUID, in the define table of 'handle'.
+// Also see LookUpSymbol()
+LinkerVoidType LinkerInvoker::LookUpMethodSymbolAddress(LinkerMFileInfo &mplInfo, const MUID &muid, size_t &index) {
+  index = 0;
+  size_t methodDefSize = mplInfo.GetTblSize(kMethodDef);
+  if (methodDefSize == 0) {
+    LINKER_DLOG(mpllinker) << "failed, the size of methodDef table is zero, " << maple::endl;
+    return 0;
+  }
+  AddrSlice methodDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodDefOrig), methodDefSize);
+  if (methodDefSlice.Empty()) {
+    LINKER_DLOG(mpllinker) << "failed, methodDef table is null" << maple::endl;
+    return 0;
+  }
+  LinkerMuidTableItem *pMuidTable = mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodDefMuid);
+  if (pMuidTable == nullptr) {
+    LINKER_DLOG(mpllinker) << "failed, pMuidTable is null in " << mplInfo.name << maple::endl;
+    return 0;
+  }
+
+  // Because method define table is sorted by address ascending order,
+  // we must add an index side-table for binary searching address with muid.
+  LinkerMuidIndexTableItem *pMuidIndexTable = mplInfo.GetTblBegin<LinkerMuidIndexTableItem*>(kMethodMuidIndex);
+  size_t indexSize = mplInfo.GetTblSize(kMethodMuidIndex);
+  if (pMuidIndexTable == nullptr || indexSize == 0) {
+    LINKER_DLOG(mpllinker) << "failed, pMuidIndexTable is null, or size is zero" << maple::endl;
+    return 0;
+  }
+
+  const int64_t start = 0;
+  int64_t end = static_cast<int64_t>(methodDefSize) - 1;
+  int64_t pos = Get<Linker>()->BinarySearch<LinkerMuidTableItem, LinkerMuidIndexTableItem, MUID>(
+      *pMuidTable, *pMuidIndexTable, start, end, muid);
+  if (pos != -1) {
+    index = static_cast<size_t>(pos);
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+    return AddrToUint32(GetDefTableAddress(mplInfo, methodDefSlice, index, true));
+#else
+    return reinterpret_cast<LinkerVoidType>(GetDefTableAddress(mplInfo, methodDefSlice, index, true));
+#endif // USE_32BIT_REF
+  } else {
+    LINKER_DLOG(mpllinker) << "failed, not found MUID=" << muid.ToStr() << maple::endl;
+  }
+  return 0;
+}
+
+// Look up the data with MUID, in the data define table of 'handle'.
+// Also see LookUpSymbol()
+LinkerVoidType LinkerInvoker::LookUpDataSymbolAddress(LinkerMFileInfo &mplInfo, const MUID &muid, size_t &index) {
+  size_t dataDefSize = mplInfo.GetTblSize(kDataDef);
+  if (dataDefSize == 0) {
+    LINKER_DLOG(mpllinker) << "failed, the size of dataDef table is zero" << maple::endl;
+    return 0;
+  }
+  AddrSlice dataDefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kDataDefOrig), dataDefSize);
+  if (dataDefSlice.Empty()) {
+    LINKER_DLOG(mpllinker) << "failed, dataDef table is null" << maple::endl;
+    return 0;
+  }
+  LinkerMuidTableItem *pMuidTable = mplInfo.GetTblBegin<LinkerMuidTableItem*>(kDataDefMuid);
+  if (pMuidTable == nullptr) {
+    LINKER_DLOG(mpllinker) << "failed, pMuidTable is null in " << mplInfo.name << maple::endl;
+    return 0;
+  }
+
+  const int64_t start = 0;
+  int64_t end = static_cast<int64_t>(dataDefSize) - 1;
+  int64_t pos = Get<Linker>()->BinarySearch<LinkerMuidTableItem, MUID>(*pMuidTable, start, end, muid);
+  if (pos != -1) {
+    index = static_cast<size_t>(pos);
+#ifdef LINKER_32BIT_REF_FOR_DEF_UNDEF
+    return AddrToUint32(GetDefTableAddress(mplInfo, dataDefSlice, index, false));
+#else
+    return reinterpret_cast<LinkerVoidType>(GetDefTableAddress(mplInfo, dataDefSlice, index, false));
+#endif // USE_32BIT_REF
+  } else {
+    LINKER_DLOG(mpllinker) << "failed, not found MUID=" << muid.ToStr() << maple::endl;
+    return 0;
+  }
+}
+
+void LinkerInvoker::ResolveVTableSymbolByClass(LinkerMFileInfo &mplInfo, const MClass *klass, bool forVtab) {
+  LinkerVTableItem *pVTable = forVtab ? reinterpret_cast<LinkerVTableItem*>(
+      klass->GetVtab()) : reinterpret_cast<LinkerVTableItem*>(klass->GetItab());
+  if (pVTable == nullptr) {
+    return;
+  }
+  bool hasNotResolved = false;
+  uint32_t i = 0;
+  bool endFlag = false;
+  while (!endFlag) {
+    size_t vtabIndexOrg = pVTable[i].index;
+    LinkerRef vRef(vtabIndexOrg & (~kGoldSymbolTableEndFlag));
+    endFlag = static_cast<bool>(vtabIndexOrg & kGoldSymbolTableEndFlag);
+    if (vRef.IsVTabIndex()) { // Index of undefine table.
+      hasNotResolved = ResolveSymbolByClass<kMethodUndef, kMethodDef, LinkerVTableItem, false>(mplInfo, pVTable[i],
+          vRef.GetTabIndex(), vRef.GetRawValue<size_t>(), vRef.IsTabUndef());
+    } else if (pVTable[i].index & kNegativeNum) { // Offset of address.
+      DataRefOffset *klassIndex = reinterpret_cast<DataRefOffset*>(&pVTable[i].index);
+#ifdef USE_32BIT_REF
+      // To allow re-parse Vtable by the proper way.
+      if (!(static_cast<uint32_t>(pVTable[i].index) < kDsoLoadedAddressEnd &&
+          static_cast<uint32_t>(pVTable[i].index) >= kDsoLoadedAddressStart)) {
+        pVTable[i].index = klassIndex->GetDataRef<size_t>();
+      } else {
+        LINKER_VLOG(mpllinker) << "(" << forVtab << "), not re-parse for patch, " << std::hex << "addr=" <<
+            pVTable[i].index << ">X>" << klassIndex->GetDataRef<size_t>() << " in " << mplInfo.name << maple::endl;
+      }
+#else
+      pVTable[i].index = klassIndex->GetDataRef<size_t>();
+#endif
+    } else if (!forVtab) {
+      MByteRef32 *ref = reinterpret_cast<MByteRef32*>(&(pVTable[i].index));
+      if (ref->IsOffset()) {
+        std::abort();
+      }
+    }
+    ++i;
+  }
+  if (!forVtab && i == kItabHashSize + 1) {
+    ResolveITableSymbolByClass(mplInfo, klass);
+  }
+  if (hasNotResolved) {
+    char *className = klass->GetName();
+    LINKER_LOG(ERROR) << "failed, " << "mplInfo=" << mplInfo.name << ", class=" << className << maple::endl;
+    return;
+  }
+}
+
+void LinkerInvoker::ResolveITableSymbolByClass(LinkerMFileInfo &mplInfo, const MClass *klass) {
+#ifdef USE_32BIT_REF
+  int32_t *address = reinterpret_cast<int32_t*>(klass->GetItab()) + kItabHashSize;
+  LinkerITableItem *pITable = reinterpret_cast<LinkerITableItem*>(static_cast<unsigned long>(*address) & 0xffffffff);
+  size_t noConflictItabSize = (pITable != nullptr) ? pITable[0].index & 0xffff : 0;
+#else
+  LinkerITableItem *pITable = reinterpret_cast<LinkerITableItem*>(*reinterpret_cast<int64_t*>(
+      reinterpret_cast<int64_t*>(klass->GetItab()) + kItabHashSize));
+  size_t noConflictItabSize = (pITable != nullptr) ? pITable[0].index & 0xffffffff : 0;
+#endif
+  if (pITable == nullptr) {
+    return;
+  }
+  size_t conflictItabStart = noConflictItabSize * 2 + 2; // 2 is to count conflictItabStart.
+  size_t i = 2;
+  bool endFlag = false;
+  while (!endFlag) {
+    if (i % 2 == 1) { // i % 2 == 1 means the number is odd.
+      size_t itabIndexOrg = pITable[i].index;
+      LinkerRef ref(itabIndexOrg & (~kGoldSymbolTableEndFlag));
+      endFlag = ((itabIndexOrg & kGoldSymbolTableEndFlag) != 0);
+      if (ref.IsITabIndex()) { // Index of undefine table.
+        (void)ResolveSymbolByClass<kMethodUndef, kMethodDef, LinkerITableItem, false>(mplInfo, pITable[i],
+            ref.GetTabIndex(), ref.GetRawValue<size_t>(), ref.IsTabUndef());
+      } else if (ref.GetRawValue<size_t>() != 1) {
+        LOG(FATAL) << "ResolveITableSymbolByClass failed, pITableIndex isn't 1" << maple::endl;
+      }
+    } else if (conflictItabStart <= i) {
+#ifdef USE_32BIT_REF
+      MByteRef32 *ref = reinterpret_cast<MByteRef32*>(&(pITable[i].index));
+#else
+      MByteRef *ref = reinterpret_cast<MByteRef*>(&(pITable[i].index));
+#endif
+      void *addr = ref->GetRef<void*>();
+      ref->SetRef(addr);
+    }
+    ++i;
+  }
+}
+
+void LinkerInvoker::ResolveSuperClassSymbolByClass(LinkerMFileInfo &mplInfo, const MClass *klass) {
+  bool hasNotResolved = false;
+  uint32_t superSize = klass->GetNumOfSuperClasses();
+  if (superSize == 0) {
+    return;
+  }
+  LinkerSuperClassTableItem *pSuperTable = reinterpret_cast<LinkerSuperClassTableItem*>(klass->GetSuperClassArrayPtr());
+  if (pSuperTable == nullptr) {
+    return;
+  }
+
+  for (uint32_t i = 0; i < superSize; ++i) {
+    LinkerRef ref(pSuperTable[i].index);
+    if (ref.IsIndex()) {
+      size_t index = ref.GetIndex();
+      bool fromUndef = ref.IsFromUndef();
+      hasNotResolved = ResolveSymbolByClass<kDataUndef, kDataDef, LinkerSuperClassTableItem, true>(
+          mplInfo, pSuperTable[i], index, 0, fromUndef);
+    }
+  }
+  if (hasNotResolved) {
+    char *className = klass->GetName();
+    LINKER_LOG(ERROR) << "failed, " << "mplInfo=" << mplInfo.name << ", class=" << className << maple::endl;
+    return;
+  }
+}
+
+LinkerMFileInfo *LinkerInvoker::GetLinkerMFileInfo(MFileInfoSource source, const void *key, bool isLazyBinding) {
+  if (source == kFromPC) {
+    return SearchAddress(key, kTypeText, isLazyBinding);
+  } else if (source == kFromAddr) {
+    return SearchAddress(key, kTypeWhole, isLazyBinding);
+  } else if (source == kFromMeta) {
+    return SearchAddress(key, kTypeClass, isLazyBinding);
+  } else if (source == kFromHandle) {
+    LinkerMFileInfo *mplInfo = nullptr;
+    (void)mplInfoHandleMap.Find(key, mplInfo);
+    return mplInfo;
+  } else if (source == kFromName) {
+    const std::string name = reinterpret_cast<const char*>(key);
+    LinkerMFileInfo *mplInfo = nullptr;
+    (void)mplInfoNameMap.Find(name, mplInfo);
+    return mplInfo;
+  } else if (source == kFromClass) {
+    return SearchAddress(key, kTypeClass);
+  }
+  return nullptr;
+}
+
+std::string LinkerInvoker::GetMFileName(MFileInfoSource source, const void *key, bool isLazyBinding) {
+  LinkerMFileInfo *mplInfo = GetLinkerMFileInfo(source, key, isLazyBinding);
+  return (mplInfo != nullptr) ? mplInfo->name : "";
+}
+
+bool LinkerInvoker::UpdateMethodSymbolAddressDef(const MClass *klass, const MUID &symbolId, const uintptr_t newAddr) {
+  // update symbol table (defining library only)
+  // get the defining library
+  LinkerMFileInfo *mplInfo = GetLinkerMFileInfo(kFromMeta, klass);
+  if (mplInfo == nullptr) { // it should be a dynamic-created class
+    LINKER_LOG(ERROR) << "No defining library of " << klass->GetName() << maple::endl;
+    return false;
+  }
+  LinkerMuidIndexTableItem *pIndexTable = mplInfo->GetTblBegin<LinkerMuidIndexTableItem*>(kMethodMuidIndex);
+  size_t size = mplInfo->GetTblSize(kMethodDef);
+  LinkerAddrTableItem *pTable = mplInfo->GetTblBegin<LinkerAddrTableItem*>(kMethodDef);
+  LinkerMuidTableItem *pMuidTable = mplInfo->GetTblBegin<LinkerMuidTableItem*>(kMethodDefMuid);
+  // search by unique id
+  const int64_t start = 0;
+  int64_t end = static_cast<int64_t>(size) - 1;
+  int64_t pos = Get<Linker>()->BinarySearch<LinkerMuidTableItem, LinkerMuidIndexTableItem, MUID>(
+      *pMuidTable, *pIndexTable, start, end, symbolId);
+  if (pos == -1) { // no idea about it
+    LINKER_LOG(ERROR) << "No symbol " << klass->GetName() << " in " << mplInfo->name << maple::endl;
+    return false;
+  }
+  LINKER_VLOG(mpllinker) << "Update " << mplInfo->name << ":DefTab#" << pos << ":" << pTable[pos].addr << maple::endl;
+  pTable[pos].addr = static_cast<LinkerOffsetType>(newAddr);
+  return true;
+}
+
+bool LinkerInvoker::UpdateMethodSymbolAddressUndef(LinkerMFileInfo &mplInfo, const UpdateNode &node) {
+  size_t methodUndefSize = mplInfo.GetTblSize(kMethodUndef);
+  AddrSlice methodUndefSlice(mplInfo.GetTblBegin<LinkerAddrTableItem*>(kMethodUndef), methodUndefSize);
+  LinkerMuidTableItem *pMuidTable = mplInfo.GetTblBegin<LinkerMuidTableItem*>(kMethodUndefMuid);
+  if (methodUndefSize != 0 && !methodUndefSlice.Empty() && pMuidTable != nullptr) {
+    const int64_t start = 0;
+    int64_t end = static_cast<int64_t>(methodUndefSize) - 1;
+    int64_t pos = Get<Linker>()->BinarySearch<LinkerMuidTableItem, MUID>(*pMuidTable, start, end, node.symbolId);
+    if (pos != -1 && (!mplInfo.IsFlag(kIsLazy) ||
+        GetAddrBindingState(methodUndefSlice, static_cast<size_t>(pos)) == kBindingStateResolved)) {
+      LINKER_VLOG(mpllinker) << "Update " << mplInfo.name << ":UndefTab#" << pos << ":" <<
+          methodUndefSlice[static_cast<size_t>(pos)].addr << maple::endl;
+      methodUndefSlice[static_cast<size_t>(pos)].addr = static_cast<LinkerOffsetType>(node.newAddr);
+    }
+  }
+  return true;
+}
+
+bool LinkerInvoker::UpdateMethodSymbolAddressDecouple(LinkerMFileInfo &mplInfo, const UpdateNode &node) {
+  { // update vtable
+    size_t size = mplInfo.GetTblSize(kVTable);
+    LinkerVTableItem *pTable = mplInfo.GetTblBegin<LinkerVTableItem*>(kVTable);
+    if (size != 0 && pTable != nullptr) {
+      for (size_t i = 0; i < size; ++i) {
+        if (static_cast<uint32_t>(pTable[i].index) == node.oldAddr) { // compare by address
+          LINKER_VLOG(mpllinker) << "Update " << mplInfo.name <<
+              ":Vtable#" << i << ":" << node.oldAddr << maple::endl;
+          pTable[i].index = reinterpret_cast<uintptr_t>(node.newAddr);
+        }
+      }
+    }
+  }
+
+  if (node.klass->IsInterface()) {
+    // interface has no itable
+    return true;
+  }
+
+  { // update itable
+    size_t size = mplInfo.GetTblSize(kITable);
+    LinkerITableItem *pTable = mplInfo.GetTblBegin<LinkerITableItem*>(kITable);
+    if (size != 0 && pTable != nullptr) {
+      for (size_t i = 0; i < size; ++i) {
+        if (static_cast<uint32_t>(pTable[i].index) == node.oldAddr) { // compare by address
+          LINKER_VLOG(mpllinker) << "Update " << mplInfo.name <<
+              ":Itable#" << i << ":" << node.oldAddr << maple::endl;
+          pTable[i].index = reinterpret_cast<uintptr_t>(node.newAddr);
+        }
+      }
+    }
+  }
+  return true; // next library
+}
+
+// Get class loader hierarchy list
+void LinkerInvoker::GetClassLoaderList(const LinkerMFileInfo &mplInfo, ClassLoaderListT &clList, bool isNewList) {
+  if (!isNewList || !clList.empty()) {
+    return;
+  }
+  MObject *parent = reinterpret_cast<MObject*>(mplInfo.classLoader);
+  MObject *system = reinterpret_cast<MObject*>(pLoader->GetSystemClassLoader());
+  // first insert system class loader will cause last search
+  if (parent != system && system != nullptr && mplInfo.name != Get<Hotfix>()->GetPatchPath()) {
+    LINKER_VLOG(mpllinker) << "push SystemClassLoader(" << system << ")" << maple::endl;
+    clList.push_back(reinterpret_cast<jobject>(system));
+  }
+  LINKER_VLOG(mpllinker) << ">>> building hierarchy for " << mplInfo.name << maple::endl;
+  for (;;) {
+    // Skip if it's boot class loader instance.
+    if (parent == nullptr || !IsBootClassLoader(parent)) {
+      LINKER_VLOG(mpllinker) << "push " << parent << maple::endl;
+      clList.push_back(reinterpret_cast<jobject>(parent));
+    } else {
+      LINKER_VLOG(mpllinker) << "skip BootClassLoader(" << parent << ")" << maple::endl;
+    }
+    if (parent == nullptr) { // 'parent is null' means it reaches the boot class loader.
+      LINKER_VLOG(mpllinker) << "<<< building hierarchy for " << mplInfo.name << maple::endl;
+      break;
+    }
+    parent = reinterpret_cast<MObject*>(pLoader->GetCLParent(reinterpret_cast<jobject>(parent)));
+  }
+}
+
+void LinkerInvoker::ResetClassLoaderList(const MObject *classLoader) {
+  auto handle = [this](LinkerMFileInfo &mplInfo) {
+    this->ResetMplInfoClList(mplInfo);
+  };
+  (void)mplInfoListCLMap.ForEach(classLoader, handle);
+}
+
+void LinkerInvoker::GetLinkerMFileInfos(LinkerMFileInfo &mplInfo, LinkerMFileInfoListT &fileList, bool isNewList) {
+  // Lazy building class loader hierarchy.
+  GetClassLoaderList(mplInfo, mplInfo.clList, isNewList);
+  ClassLoaderListT &classLoaderList = mplInfo.clList;
+  if (classLoaderList.empty()) {
+    LINKER_LOG(ERROR) << "clList null for " << mplInfo.name << maple::endl;
+    return;
+  }
+
+  // Iteration from parent to child.
+  for (ClassLoaderListRevItT it = classLoaderList.rbegin(); it != classLoaderList.rend(); ++it) {
+    mplInfoListCLMap.FindToExport(reinterpret_cast<MObject*>(*it), fileList);
+  }
+}
+
+void LinkerInvoker::ClearLinkerMFileInfo() {
+  auto handle = [this](LinkerMFileInfo &item) {
+    (void)this;
+#ifdef LINKER_RT_CACHE
+    this->Get<LinkerCache>()->FreeAllTables(item);
+#endif // LINKER_RT_CACHE
+    delete (&item);
+  };
+  mplInfoList.ForEach(handle);
+  mplInfoList.Clear();
+  mplInfoNameMap.Clear();
+  mplInfoHandleMap.Clear();
+  mplInfoElfAddrSet.Clear();
+  mplInfoElfAddrLazyBindingSet.Clear();
+  mplInfoListCLMap.Clear();
+  ClearAppInfo();
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/linker/linker_utils.cpp b/src/mrt/compiler-rt/src/linker/linker_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..709affa7aea268db58e8ebf49040484332cf886e
--- /dev/null
+++ b/src/mrt/compiler-rt/src/linker/linker_utils.cpp
@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "linker/linker_utils.h"
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dlfcn.h>
+
+#include "mrt_object.h"
+#include "mclass_inline.h"
+#include "modifier.h"
+#include "mrt_object.h"
+
+namespace maplert {
+namespace linkerutils {
+static int64_t kGlobalVersionCode = -1;
+static LoadStateType kGlobalLoadState = kLoadStateNone;
+static AppLoadState kGlobalAppLoadState = kAppLoadNone;
+static std::string kGlobalAppDataDir;
+static std::string kGlobalAppBaseStr;
+// Release the (physical) memory to kernel. Note: only for RO sections
+void ReleaseMemory(void *start, void *end) {
+  constexpr int maxPageSize = 15;
+  uintptr_t startAddr = reinterpret_cast<uintptr_t>(start);
+  uintptr_t endAddr = reinterpret_cast<uintptr_t>(end);
+  if (startAddr == 0 || endAddr == 0 || startAddr >= endAddr) {
+    return;
+  }
+
+  // round up start to page size: assuming 4K page size, 4K=2^12
+  startAddr = (startAddr + (1 << 12) - 1) & (~(static_cast<uintptr_t>((1 << 12) - 1)));
+  if (endAddr < (startAddr + (1 << maxPageSize))) {
+    return; // the region is not big enough, just skip
+  }
+  // calculate section size, and round it to 4K page size, 4K=2^12
+  size_t length = (endAddr - startAddr) & (~(static_cast<uintptr_t>((1 << 12) - 1)));
+
+  // doing madvise, ignore its return status, it should be safe for text/ro sections.
+  (void)(madvise(reinterpret_cast<void*>(startAddr), length, MADV_DONTNEED));
+}
+
+// For un|define tables' address.
+void *GetSymbolAddr(void *handle, const char *symbol, bool isFunction) {
+  if (handle == nullptr) {
+    LINKER_VLOG(mpllinker) << "failed, handle is null" << maple::endl;
+    return nullptr;
+  }
+
+  PtrFuncType func = reinterpret_cast<PtrFuncType>(dlsym(handle, symbol));
+  if (func == nullptr) {
+    LINKER_VLOG(mpllinker) << "failed, function " << symbol << " is null" << maple::endl;
+    return nullptr;
+  }
+  return isFunction ? func() : reinterpret_cast<void*>(func);
+}
+
+// Get maxmium version from range table.
+int32_t GetMaxVersion() {
+  constexpr int maxSize = 32;
+  if (kGlobalLoadState == kLoadStateApk) {
+    return static_cast<int32_t>(static_cast<uint64_t>(kGlobalVersionCode) >> maxSize);
+  }
+  return 0;
+}
+
+// Get minmium version from range table.
+int32_t GetMinVersion() {
+  if (kGlobalLoadState == kLoadStateApk) {
+    return static_cast<int32_t>(kGlobalVersionCode);
+  }
+  return 0;
+}
+
+void GetMplVersion(const LinkerMFileInfo &mplInfo, MapleVersionT &version) {
+  void *begin = static_cast<void*>(GetSymbolAddr(mplInfo.handle, kMapleVersionBegin, true));
+  void *end = static_cast<void*>(GetSymbolAddr(mplInfo.handle, kMapleVersionEnd, true));
+  if (begin == end) {
+    LINKER_VLOG(mpllinker) << mplInfo.name << " has no version number!\n" << maple::endl;
+    return;
+  }
+  MapleVersionT *item = static_cast<MapleVersionT*>(begin);
+  version.mplMajorVersion = item->mplMajorVersion;
+  version.compilerMinorVersion = item->compilerMinorVersion;
+}
+
+void GetMplCompilerStatus(const LinkerMFileInfo &mplInfo, uint32_t &status) {
+  void *begin = static_cast<void*>(GetSymbolAddr(mplInfo.handle, kMapleCompileStatusBegin, true));
+  void *end = static_cast<void*>(GetSymbolAddr(mplInfo.handle, kMapleCompileStatusEnd, true));
+  if (begin == end) {
+    status = 0;
+    return;
+  }
+  status = *(static_cast<uint32_t*>(begin));
+}
+
+std::string GetAppPackageName() {
+  size_t pos = kGlobalAppDataDir.find_last_of('/');
+  std::string packageName = kGlobalAppDataDir.substr(pos + 1);
+  return packageName;
+}
+
+const std::string &GetAppInfo() {
+  return kGlobalAppDataDir;
+}
+void ClearAppInfo() {
+  kGlobalAppDataDir.clear();
+}
+const LoadStateType &GetLoadState() {
+  return kGlobalLoadState;
+}
+void SetLoadState(const LoadStateType state) {
+  kGlobalLoadState = state;
+}
+const AppLoadState &GetAppLoadState() {
+  return kGlobalAppLoadState;
+}
+void SetAppLoadState(const AppLoadState state) {
+  kGlobalAppLoadState = state;
+}
+const std::string &GetAppBaseStr() {
+  return kGlobalAppBaseStr;
+}
+void SetAppBaseStr(const std::string &str) {
+  kGlobalAppBaseStr = str;
+}
+// Set running app's state, if data path and version code are valid.
+void SetAppInfo(const char *dataPath, int64_t appVersionCode) {
+  if (kGlobalLoadState == kLoadStateApk) {
+    LINKER_LOG(ERROR) << "(" << dataPath << ", " << appVersionCode << "), failed, already set before? appDataDir=" <<
+        kGlobalAppDataDir << ", versionCode=" << kGlobalVersionCode << maple::endl;
+    return;
+  }
+
+  kGlobalAppDataDir = std::string(dataPath);
+  kGlobalVersionCode = appVersionCode;
+  if (!kGlobalAppDataDir.empty() && kGlobalVersionCode > 0) {
+    kGlobalLoadState = kLoadStateApk;
+    kGlobalAppLoadState = kAppLoadBaseOnlyReady;
+  } else {
+    LINKER_LOG(ERROR) << "(" << dataPath << ", " << appVersionCode << "), failed, appDataDir=" << kGlobalAppDataDir <<
+        ", versionCode=" << kGlobalVersionCode << maple::endl;
+    kGlobalLoadState = kLoadStateNone;
+  }
+}
+
+bool NeedRelocateSymbol(const std::string &name) {
+  // 900,4088... is VersionCode.
+  static std::map<std::string, int64_t> apps = {
+      { "com.ss.android.article.news", 900 },
+      { "com.sina.weibolite", 4088 },
+      { "com.xunmeng.pinduoduo", 46600 },
+      { "com.tencent.kg.android.lite", 282 },
+      { "com.Qunar", 198 },
+      { "com.wuba", 82400 }
+  };
+  for (auto &app : apps) {
+    if (kGlobalVersionCode == app.second) {
+      if (name.find(app.first) != std::string::npos) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+void *GetDefTableAddress(const LinkerMFileInfo &mplInfo, const AddrSlice &defSlice, size_t index, bool forMethod) {
+  if (mplInfo.IsFlag(kIsLazy) || (!mplInfo.IsFlag(kIsRelDataOnce) && !forMethod) ||
+      (!mplInfo.IsFlag(kIsRelMethodOnce) && forMethod)) {
+    return defSlice[index].AddressFromOffset();
+  } else {
+    return defSlice[index].Address();
+  }
+}
+
+const char *GetMuidDefFuncTableFuncname(const LinkerInfTableItem &pInfTable) {
+  const DataRefOffset32 *data = reinterpret_cast<const DataRefOffset32*>(&pInfTable.funcNameOffset);
+  MethodMetaBase *methodInfo = data->GetDataRef<MethodMetaBase*>();
+  return methodInfo->GetName();
+}
+
+std::string GetMuidDefFuncTableSigname(const LinkerInfTableItem &pInfTable) {
+  const DataRefOffset32 *data = reinterpret_cast<const DataRefOffset32*>(&pInfTable.funcNameOffset);
+  MethodMetaBase *methodInfo = data->GetDataRef<MethodMetaBase*>();
+  std::string signature;
+  methodInfo->GetSignature(signature);
+  return signature;
+}
+
+const char *GetMuidDefFuncTableClassname(const LinkerInfTableItem &pInfTable) {
+  const DataRefOffset32 *data = reinterpret_cast<const DataRefOffset32*>(&pInfTable.funcNameOffset);
+  MethodMetaBase *methodInfo = data->GetDataRef<MethodMetaBase*>();
+  MClass *klass = methodInfo->GetDeclaringClass();
+  if (klass == nullptr) {
+    LINKER_LOG(FATAL) << "klass is null" << maple::endl;
+  }
+  return klass->GetName();
+}
+
+// Get method symbol by the offsets of class name, method name and signature.
+std::string GetMethodSymbolByOffset(const LinkerInfTableItem &infTable) {
+  std::string sym;
+  const char *name = GetMuidDefFuncTableClassname(infTable);
+  if (name != nullptr) {
+    sym += name;
+    sym += '|';
+  } else {
+    LINKER_LOG(WARNING) << "class name is null!?" <<  maple::endl;
+  }
+
+  name = GetMuidDefFuncTableFuncname(infTable);
+  if (name != nullptr) {
+    sym += name;
+    sym += '|';
+  } else {
+    LINKER_LOG(WARNING) << "function name is null!?" <<  maple::endl;
+  }
+
+  std::string signature = GetMuidDefFuncTableSigname(infTable);
+  if (!signature.empty()) {
+    sym += signature;
+  } else {
+    LINKER_LOG(WARNING) << "signature is null!?" <<  maple::endl;
+  }
+  return sym;
+}
+
+#ifdef LINKER_RT_CACHE
+constexpr uint8_t kLinkerCacheTypeStrSize = 11; // 11 is LinkerCacheType::kLinkerCacheLazy + 1
+constexpr char kLinkerLazyCacheSuffix[] = ".lzy";
+constexpr char kLinkerUndefCacheSuffixFcn[] = ".fcn";
+constexpr char kLinkerDefCacheSuffixFcn[] = ".def.fcn";
+constexpr char kLinkerUndefCacheSuffixVar[] = ".var";
+constexpr char kLinkerDefCacheSuffixVar[] = ".def.var";
+constexpr char kLinkerCacheSuffixVTable[] = ".vtb";
+constexpr char kLinkerCacheSuffixCTable[] = ".ctb";
+constexpr char kLinkerCacheSuffixITable[] = ".itb";
+constexpr char kLinkerCacheSuffixFieldOffset[] = ".fos";
+constexpr char kLinkerCacheSuffixFieldTable[] = ".ftb";
+constexpr char kLinkerCacheSuffixStaAddrTable[] = ".sta";
+const std::string LinkerCacheTypeStr[kLinkerCacheTypeStrSize] = {
+    kLinkerUndefCacheSuffixVar,
+    kLinkerDefCacheSuffixVar,
+    kLinkerUndefCacheSuffixFcn,
+    kLinkerDefCacheSuffixFcn,
+    kLinkerCacheSuffixVTable,
+    kLinkerCacheSuffixCTable,
+    kLinkerCacheSuffixFieldOffset,
+    kLinkerCacheSuffixFieldTable,
+    kLinkerCacheSuffixITable,
+    kLinkerCacheSuffixStaAddrTable,
+    kLinkerLazyCacheSuffix
+};
+
+// get LinkerCacheTypeStr
+const std::string &GetLinkerCacheTypeStr(LinkerCacheType index) {
+  return LinkerCacheTypeStr[static_cast<int>(index)];
+}
+
+bool FileExists(const char *name) {
+  struct stat st;
+  if (stat(name, &st) == 0) {
+    return S_ISREG(st.st_mode);
+  } else {
+    return false;
+  }
+}
+
+bool FolderExists(const char *name) {
+  struct stat st;
+  if (stat(name, &st) == 0) {
+    return S_ISDIR(st.st_mode);
+  } else {
+    return false;
+  }
+}
+
+bool PrepareFolder(const std::string &dir) {
+  size_t first = 0;
+  size_t second = 0;
+  struct stat dirStat;
+  if (stat(dir.c_str(), &dirStat) == 0) {
+    if (!S_ISDIR(dirStat.st_mode)) {
+      LINKER_LOG(ERROR) << "exist, but not directory! " << dir << maple::endl;
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  // It's not "No such file or directory"?
+  if (errno != ENOENT) {
+    LINKER_LOG(ERROR) << strerror(errno) << maple::endl;
+    return false;
+  }
+
+  for(;;) {
+    // Get the parent directory.
+    first = second;
+    if (first == dir.length() - 1) { // Exit if reach the end, or root /.
+      return true;
+    }
+    second = dir.find('/', first + 1);
+    if (second == std::string::npos) { // If it's not ended by /.
+      second = dir.length() - 1;
+    }
+
+    // Check if exist.
+    std::string substr = dir.substr(0, second + 1);
+    if (stat(substr.c_str(), &dirStat) == 0) {
+      if (!S_ISDIR(dirStat.st_mode)) {
+        LINKER_LOG(ERROR) << "parent exist, but not directory! " << substr << maple::endl;
+        return false;
+      } else {
+        LINKER_DLOG(mpllinker) << "parent exist! " << substr << maple::endl;
+        continue;
+      }
+    }
+
+    // Create the folder.
+    mode_t mode = S_IRWXU | S_IRWXG | S_IXOTH;
+    if (mkdir(substr.c_str(), mode) != 0) {
+      LINKER_LOG(ERROR) << "failed to create dir " << substr << ":" << strerror(errno) << maple::endl;
+      return false;
+    }
+    if (chmod(substr.c_str(), mode) != 0) {
+      LINKER_LOG(ERROR) << "failed to chmod dir " << substr << ":" << strerror(errno) << maple::endl;
+      return false;
+    }
+    LINKER_DLOG(mpllinker) << "created dir " << substr << " successfully!" << maple::endl;
+  }
+}
+
+// note: the install cache is specified by installd(see mpl_cache_gen.cpp)
+static constexpr char kLinkerDataAppPath[] = "/data/app/";
+static constexpr char kLinkerDalvikDcpCachePath[] = "/data/dalvik-cache/instdcp/";
+bool GetInstallCachePath(LinkerMFileInfo &mplInfo, std::string &path, LinkerCacheType cacheType) {
+  if (mplInfo.name.find(kLinkerDataAppPath) == 0) {
+    // for data/app
+    size_t pos = mplInfo.name.find('/', strlen(kLinkerDataAppPath));
+    if (pos != std::string::npos) {
+      path = mplInfo.name.substr(0, pos + 1);
+      path += "instdcp/";
+      std::string name = mplInfo.name.substr(pos + 1);
+      std::replace(name.begin(), name.end(), '/', '_');
+      path += name;
+    } else {
+      LINKER_VLOG(mpllinker) << "failed to get app path for " << mplInfo.name << maple::endl;
+      return false;
+    }
+  } else {
+    // for system/app
+    path = kLinkerDalvikDcpCachePath;
+    std::string name = mplInfo.name;
+    std::replace(name.begin(), name.end(), '/', '_');
+    path += name;
+  }
+  path += GetLinkerCacheTypeStr(cacheType);
+  return true;
+}
+#endif
+}
+}
diff --git a/src/mrt/compiler-rt/src/loader/file_adapter.cpp b/src/mrt/compiler-rt/src/loader/file_adapter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c2d06e87cc81645c4071652f3cc3432a1ee1c4dc
--- /dev/null
+++ b/src/mrt/compiler-rt/src/loader/file_adapter.cpp
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "file_adapter.h"
+#include "loader_api.h"
+#include "loader/loader_utils.h"
+#include "utils/string_utils.h"
+#include "base/file_utils.h"
+#include "exception/stack_unwinder.h"
+#include "interp_support.h"
+
+namespace maplert {
+FileAdapter::FileAdapter(const std::string srcPath)
+    : originalPath(loaderutils::GetNicePath(srcPath)),
+      convertPath(loaderutils::Dex2MplPath(originalPath)),
+      isThirdApp(stringutils::WithPrefix(originalPath.c_str(), "/data/app/")),
+      isPartialAot(stringutils::WithSuffix(convertPath.c_str(), "/maple/arm64/maplepclasses.so")) {}
+
+FileAdapter::FileAdapter(const std::string srcPath, const IAdapterEx adapter) : FileAdapter(srcPath) {
+  pAdapterEx = adapter;
+}
+
+ObjFile *FileAdapter::OpenObjectFile(jobject classLoader, bool isFallBack, const std::string designPath) {
+  // try to open MFile first
+  if (!isFallBack) {
+    return pAdapterEx.As<AdapterExAPI*>()->OpenMplFile(classLoader, designPath.empty() ? convertPath : designPath);
+  } else {
+    if (pAdapterEx.As<AdapterExAPI*>()->IsSystemServer()) {
+      return nullptr;  // don't turn-on interpreter for system-server
+    }
+    // then try to open the DFile
+    return pAdapterEx.As<AdapterExAPI*>()->OpenDexFile(classLoader, designPath.empty() ? originalPath : designPath);
+  }
+}
+
+bool FileAdapter::CloseObjectFile(ObjFile &objFile) {
+  return objFile.Close();
+}
+const ObjFile *FileAdapter::Get(const std::string &path) {
+  std::lock_guard<std::mutex> lock(mMplLibLock);
+  return GetLocked(path);
+}
+
+const ObjFile *FileAdapter::GetLocked(const std::string &path) {
+  auto it = mMplLibs.find(path);
+  return (it == mMplLibs.end()) ? nullptr : it->second;
+}
+
+void FileAdapter::Put(const std::string &path, const ObjFile &objFile) {
+  std::lock_guard<std::mutex> lock(mMplLibLock);
+  mMplLibs[path] = &objFile;
+  if ((objFile.GetFileType() == FileType::kDFile) && (!IsPartialAot())) {
+    (void)mMplSeqList.insert(mMplSeqList.begin(), &objFile);
+  } else {
+    mMplSeqList.push_back(&objFile);
+  }
+}
+
+bool FileAdapter::Register(const IEnv env, jclass javaClass, const std::string &jniClassName,
+    const INativeMethod methods, int32_t methodCount, bool fake) {
+  std::lock_guard<std::mutex> lock(mMplLibLock);
+
+  for (const ObjFile *mf : mMplSeqList) {
+    ObjFile *objFile = const_cast<ObjFile*>(mf);
+    if (mf != nullptr && objFile->CanRegisterNativeMethods(jniClassName) && (objFile->RegisterNativeMethods(env,
+        javaClass, jniClassName, methods, methodCount, fake) == true)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void FileAdapter::GetObjFiles(std::vector<const ObjFile*> &bootClassPath) {
+  std::lock_guard<std::mutex> lock(mMplLibLock);
+  (void)std::copy(mMplSeqList.begin(), mMplSeqList.end(), std::back_inserter(bootClassPath));
+}
+
+void FileAdapter::GetObjLoaders(std::set<jobject> &classLoaders) {
+  std::lock_guard<std::mutex> lock(mMplLibLock);
+  std::vector<const ObjFile*>::iterator it = mMplSeqList.begin();
+  for (; it != mMplSeqList.end(); ++it) {
+    jobject classLoader = (*it)->GetClassLoader();
+    (void)classLoaders.insert(classLoader);
+  }
+}
+
+void FileAdapter::GetObjFileList(std::vector <std::string> &pathList, bool isFallBack) {
+  if (!isFallBack) {
+    if (isThirdApp) {
+      hasStartUp = GetObjFileListInternal(pathList);
+    } else {
+      if (stringutils::WithSuffix(convertPath.c_str(), ".so")) {
+        pathList.push_back(convertPath);
+      }
+      hasStartUp = false;
+    }
+  } else {
+    hasStartUp = false;
+    pAdapterEx.As<AdapterExAPI*>()->GetListOfDexFileToLoad(originalPath, pathList);
+  }
+  hasSiblings = pathList.size() > 1;
+}
+
+bool FileAdapter::GetObjFileListInternal(std::vector <std::string> &pathList) {
+  if (!stringutils::WithSuffix(convertPath.c_str(), ".so")) {
+    CL_LOG(ERROR) << "base ObjFile name not end with .so: " << convertPath << maple::endl;
+    return false;
+  }
+
+  // Base ObjFile located in zip, add to path directly, and return
+  // Tips: Not support multi-so in zip for performance concern
+  if (convertPath.rfind("!/") != std::string::npos) {
+    pathList.push_back(convertPath);
+    return false;
+  }
+
+  size_t posPostfix = convertPath.rfind(".so");
+
+  // Base MplFiles, whose name is mapleclasses.so or maplepclasses.so
+  if (maple::FileUtils::FileExists(convertPath)) {
+    pathList.push_back(convertPath);
+  } else {
+    CL_LOG(ERROR) << "cannot find base ObjFile: " << convertPath << maple::endl;
+    return false;
+  }
+
+  // Sibling MplFiles, whose name starts from 2, like mapleclasses2.so, mapleclass3.so, ... and mapleclass999.so
+  for (int i = 2;; ++i) {
+    std::string incFileName(convertPath);
+    (void)incFileName.insert(posPostfix, std::to_string(i));
+    if (maple::FileUtils::FileExists(incFileName)) {
+      pathList.push_back(incFileName);
+    } else {
+      CL_VLOG(classloader) << "cannot find siblings ObjFile: " << incFileName << maple::endl;
+      break;
+    }
+  }
+
+  // Stub ObjFile, whose name index is 999
+  std::string stubFileName(convertPath);
+  std::string stubIndex("999");
+  (void)stubFileName.insert(posPostfix, stubIndex);
+  if (maple::FileUtils::FileExists(stubFileName)) {
+    pathList.push_back(stubFileName);
+  } else {
+    CL_VLOG(classloader) << "cannot find stub-siblings ObjFile: " << stubFileName << maple::endl;
+  }
+
+  // Starup.so ObjFile.
+  std::string fileName = "mapleclasses.so";
+  size_t posFileName = convertPath.rfind(fileName);
+  if (posFileName == std::string::npos) {
+    // Must be "maplepclasses.so"
+    return false;
+  }
+  std::string startupFileName("maplestartup.so");
+  std::string startupPathName(convertPath);
+  (void)startupPathName.replace(posFileName, fileName.length(), startupFileName);
+  if (maple::FileUtils::FileExists(startupPathName)) {
+    (void)pathList.insert(pathList.begin(), startupPathName);
+    return true;
+  } else {
+    CL_VLOG(classloader) << "cannot find startup ObjFile: " << startupPathName << maple::endl;
+    return false;
+  }
+}
+void FileAdapter::DumpUnregisterNativeFunc(std::ostream &os) {
+  std::lock_guard<std::mutex> lock(mMplLibLock);
+
+  for (auto mf : mMplSeqList) {
+    ObjFile *objFile = const_cast<ObjFile*>(mf);
+    objFile->DumpUnregisterNativeFunc(os);
+  }
+}
+void FileAdapter::DumpMethodName() {
+  // We needn't care about the performance of unwinding here.
+  std::vector<UnwindContext> uwContextStack;
+  // Unwind as many as possible till reaching the end.
+  MapleStack::FastRecordCurrentJavaStack(uwContextStack, MAPLE_STACK_UNWIND_STEP_MAX);
+
+  for (auto &uwContext : uwContextStack) {
+    std::string methodName;
+    if (!uwContext.IsInterpretedContext()) {
+      uwContext.frame.GetJavaMethodFullName(methodName);
+    } else {
+      UnwindContextInterpEx::GetJavaMethodFullNameFromUnwindContext(uwContext, methodName);
+    }
+    CL_LOG(WARNING) << "LoadClassFromMplFile(), " << methodName << maple::endl;
+  }
+}
+}
diff --git a/src/mrt/compiler-rt/src/loader/hash_pool.cpp b/src/mrt/compiler-rt/src/loader/hash_pool.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..039b0411f7ea1d4e895a030bfd7b0e97a5219698
--- /dev/null
+++ b/src/mrt/compiler-rt/src/loader/hash_pool.cpp
@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "loader/hash_pool.h"
+#include "cinterface.h"
+#include "utils/time_utils.h"
+
+using namespace std;
+namespace maplert {
+// special case 0, handle next_prime(i) for i in [1, 210)
+const unsigned kSmallPrimes[] = {
+    0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
+    109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211
+};
+
+// potential primes = 210*k + kIndices[i], k >= 1 these numbers are not divisible
+//     by 2, 3, 5 or 7 (or any integer 2 <= j <= 10 for that matter).
+const unsigned kIndices[] = {
+    1, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
+    121, 127, 131, 137, 139, 143, 149, 151, 157, 163, 167, 169, 173, 179, 181, 187, 191, 193, 197, 199, 209
+};
+
+const unsigned kFactor[] = {
+    10, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4,
+    2, 4, 8, 6, 4, 6, 2, 4, 6, 2, 6, 6, 4, 2, 4, 6, 2, 6, 4, 2, 4, 2, 10
+};
+const size_t kMaxIndices = 210;
+const size_t kSmallPrimesNum = sizeof(kSmallPrimes) / sizeof(kSmallPrimes[0]);
+const size_t kFactNum = sizeof(kFactor) / sizeof(kFactor[0]);
+const size_t kIndicesNum = sizeof(kIndices) / sizeof(kIndices[0]);
+size_t MClassHashPool::FindNextPrime(size_t nr) const {
+  // Else nr > largest kSmallPrimes
+  bool flag = false;
+  // Start searching list of potential primes: L * k0 + kIndices[in]
+  // Select first potential prime >= nr
+  //   Known a-priori nr >= L
+  size_t k0 = nr / kMaxIndices;
+  size_t in = static_cast<size_t>(std::lower_bound(kIndices, kIndices + kIndicesNum, nr - k0 * kMaxIndices) - kIndices);
+  nr = kMaxIndices * k0 + kIndices[in];
+  for (;;) {
+    // It is known a-priori that nr is not divisible by 2, 3, 5 or 7, so don't test those (j == 5 -> divide by 11 first)
+    //   And the potential primes start with 211, so don't test against the last small prime.
+    // Divide nr by all primes or potential primes(i) until:
+    //   1.The division is even, so try next potential prime.  2.The i > sqrt(nr), in which case nr is prime.
+    size_t ix = 211;
+    for (size_t j = 5; j < kSmallPrimesNum - 1; ++j) {
+      const std::size_t qr = nr / kSmallPrimes[j];
+      if (qr < kSmallPrimes[j]) {
+        return nr;
+      }
+      if (nr == qr * kSmallPrimes[j]) {
+        goto NEXT;
+      }
+    }
+    // nr cann't divisible by small primes, try potential primes
+    for (;;) {
+      std::size_t qr = nr / ix;
+      if (qr < ix) {
+        return nr;
+      }
+      if (nr == qr * ix) {
+        break;
+      }
+      for (size_t factorIndex = 0; factorIndex < kFactNum; ++factorIndex) {
+        ix += kFactor[factorIndex];
+        qr = nr / ix;
+        if (qr < ix) {
+          return nr;
+        }
+        if (nr == qr * ix) {
+          flag = true;
+          break;
+        }
+      }
+      if (flag) {
+        flag = false;
+        break;
+      }
+      ix += 2; // This will loop i to the next "plane" of potential primes, 2:Even numbers can not be primes.
+    }
+NEXT:
+    // nr is not prime.  Increment nr to next potential prime.
+    if (++in == kIndicesNum) {
+      ++k0;
+      in = 0;
+    }
+    nr = kMaxIndices * k0 + kIndices[in];
+  }
+}
+
+inline uint32_t MClassHashPool::NextPrime(size_t n) const {
+  size_t nr = n * kMaxExtended; // to increase the number of nbuckets in advance, which can reduce the conflict rate.
+  // If nr is small enough, search in kSmallPrimes
+  if (nr <= kSmallPrimes[kSmallPrimesNum - 1]) {
+    return *std::lower_bound(kSmallPrimes, kSmallPrimes + kSmallPrimesNum, nr);
+  }
+  return static_cast<uint32_t>(FindNextPrime(nr));
+}
+
+MClassHashPool::MClassHashPool() : mBucketCount(0), mClassCount(0), mConflictBucketCount(0), mFillBucketCount(0) {}
+
+MClassHashPool::~MClassHashPool() {
+  bucketData.clear();
+  bitBuckets.clear();
+  bitCounts.clear();
+}
+
+void MClassHashPool::Create(uint32_t classCount) {
+  mClassCount = classCount;
+  if (classCount != 0) {
+    mBucketCount = NextPrime(classCount);
+  }
+
+  CL_VLOG(classloader) << "Create(), extended bucket count: " << classCount << "-->" << mBucketCount << maple::endl;
+  bitBuckets.resize(mBucketCount / kBucketBitNum + 1, 0);
+  bitCounts.resize(mBucketCount / kBucketBitNum + 1, 0);
+}
+
+void MClassHashPool::Destroy() {
+  bucketData.clear();
+  bitBuckets.clear();
+  bitCounts.clear();
+}
+
+inline uint32_t MClassHashPool::BitCount(uint32_t n) const {
+  return __builtin_popcountl(n);
+}
+
+inline uint32_t MClassHashPool::BitCount(uint64_t n) const {
+  return __builtin_popcountll(n);
+}
+
+void MClassHashPool::InitClass(uint32_t hashIndex) {
+  uint32_t bucketPos = hashIndex % mBucketCount;
+  uint32_t index = bucketPos / kBucketBitNum;
+  uint32_t offset = bucketPos % kBucketBitNum;
+  BucketType bucketVal = bitBuckets[index];
+  BucketType targetBit = 1ul << (kBucketBitNum - offset - 1);
+  if ((bucketVal & targetBit) == 0) { // no conflict
+    bitBuckets[index] = bucketVal | targetBit;
+    ++mFillBucketCount;
+  } else {
+    ++mConflictBucketCount;
+  }
+}
+void MClassHashPool::Collect() {
+  bucketData.resize(mFillBucketCount, 0);
+  uint32_t total = 0;
+  for (uint32_t i = 0; i < bitCounts.size(); ++i) {
+    bitCounts[i] = total;
+    total += BitCount(bitBuckets[i]);
+  }
+}
+
+void MClassHashPool::Set(uint32_t hashIndex, ClassPtr targetKlass) {
+  uint32_t bucketPos = hashIndex % mBucketCount;
+  uint32_t index = bucketPos / kBucketBitNum;
+  uint32_t offset = bucketPos % kBucketBitNum;
+  BucketType targetBit = 1ul << (kBucketBitNum - offset - 1);
+  if ((bitBuckets[index] & targetBit) == 0) { // Not in pool
+    CL_LOG(FATAL) << "Fatal Error, Set HashPool Empty Bucket, this=" << this << ", hashIndex=" << hashIndex <<
+        ", mBucketCount=" << mBucketCount << ", bitBuckets[index]" << bitBuckets[index] << maple::endl;
+    return;
+  }
+  BucketType shift = (offset == 0) ? 0 : bitBuckets[index] >> (kBucketBitNum - offset);
+  uint32_t dataPos = bitCounts[index] + BitCount(shift);
+  if (dataPos >= mFillBucketCount) {
+    CL_LOG(FATAL) << "Fatal Error, Set HashPool Index overflow, this=" << this << ", index=" << index << ", offset=" <<
+        offset << ", dataPos=" << dataPos << ", mFillBucketCount=" << mFillBucketCount << ", bitCounts[index]=" <<
+        bitCounts[index] << ", BitCount(shift)=" << BitCount(shift) << ", bitBuckets[index]=" << bitBuckets[index] <<
+        ", mBucketCount=" << mBucketCount << ", bitBuckets.size()=" << bitBuckets.size() << ", hashIndex=" <<
+        hashIndex << maple::endl;
+    return;
+  }
+  ClassPtr data = bucketData[dataPos];
+  if (data == 0) { // no conflict
+    bucketData[dataPos] = targetKlass;
+  } else { // conflict
+    if ((data & kIsConflict) == 0) { // first conflict
+      ConflictClass *obj = reinterpret_cast<ConflictClass*>(maplert::MRT_AllocFromMeta(sizeof(ConflictClass),
+                                                                                       kClassMetaData));
+      obj->conflictData.push_back(data);
+      obj->conflictData.push_back(targetKlass);
+      data = static_cast<ClassPtr>(reinterpret_cast<uintptr_t>(obj));
+      data |= kIsConflict;
+      bucketData[dataPos] = data;
+    } else { // no first conflict
+      ConflictClass *obj = reinterpret_cast<ConflictClass*>(data & ~kMClassAddressMask);
+      obj->conflictData.push_back(targetKlass);
+    }
+  }
+}
+
+MClass *MClassHashPool::Get(const std::string &name) const {
+  auto compare = [&](const ClassPtr data, const std::string &name)->bool {
+    if ((data & kIsDexClassOffset) != 0) {
+      return false;
+    }
+    MClass *klass = reinterpret_cast<MClass*>(data & ~kMClassAddressMask);
+    if (name == klass->GetName()) {
+      return true;
+    }
+    return false;
+  };
+  return reinterpret_cast<MClass*>(Get(name, compare));
+}
+
+ClassPtr MClassHashPool::Get(const std::string &name, const NameCompare compare) const {
+  if (mClassCount == 0) {
+    return 0;
+  }
+  uint32_t hashIndex = GetHashIndex32(name);
+  uint32_t bucketPos = hashIndex % mBucketCount;
+  uint32_t index = bucketPos / kBucketBitNum;
+  uint32_t offset = bucketPos % kBucketBitNum;
+  BucketType targetBit = 1ul << (kBucketBitNum - offset - 1);
+  if ((bitBuckets[index] & targetBit) == 0) { // Not in pool
+    return 0;
+  }
+  BucketType shift = (offset == 0) ? 0 : bitBuckets[index] >> (kBucketBitNum - offset);
+  uint32_t dataPos = bitCounts[index] + BitCount(shift);
+  if (dataPos >= mFillBucketCount) {
+    CL_LOG(FATAL) << "Fatal Error, Get HashPool Index overflow, this=" << this << ", index=" << index << ", offset=" <<
+        offset << ", dataPos=" << dataPos << ", mFillBucketCount=" << mFillBucketCount << ", bitCounts[index]=" <<
+        bitCounts[index] << ", BitCount(shift)=" << BitCount(shift) << ", bitBuckets[index]=" << bitBuckets[index] <<
+        ", mBucketCount=" << mBucketCount << ", bitBuckets.size()=" << bitBuckets.size() << ", hashIndex=" <<
+        hashIndex << maple::endl;
+    return 0;
+  }
+  ClassPtr data = bucketData[dataPos];
+  if (data == 0) {
+    return 0;
+  }
+  if ((data & kIsConflict) == 0) { // no conflict
+    if (compare(data, name)) {
+      return data;
+    }
+  } else { // conflict
+    ConflictClass *obj = reinterpret_cast<ConflictClass*>(data & ~kMClassAddressMask);
+    for (ClassPtr conflict : obj->conflictData) {
+      if (compare(conflict, name)) {
+        return conflict;
+      }
+    }
+  }
+  return 0;
+}
+
+double MClassHashPool::GetHashConflictRate() const {
+  return static_cast<double>(mConflictBucketCount) / static_cast<double>(mBucketCount);
+}
+
+double MClassHashPool::GetClassConflictRate() const {
+  return static_cast<double>(mClassCount - mFillBucketCount) / static_cast<double>(mClassCount);
+}
+
+size_t MClassHashPool::CalcMemoryCost() const {
+  size_t memory = 0;
+  memory += sizeof(mBucketCount) + sizeof(mClassCount) + sizeof(mFillBucketCount) + sizeof(mConflictBucketCount) + 1;
+  memory += bitBuckets.size() * sizeof(BucketType);
+  memory += bitCounts.size() * sizeof(uint16_t);
+  memory += bucketData.size() * sizeof(ClassPtr);
+  for (ClassPtr ptr : bucketData) {
+    if ((ptr & kIsConflict) != 0) { // conflict calc
+      ConflictClass *obj = reinterpret_cast<ConflictClass*>(ptr & ~kIsConflict);
+      memory += sizeof(ConflictClass) + obj->conflictData.size() * sizeof(ClassPtr);
+    }
+  }
+  return memory;
+}
+
+void MClassHashPool::VisitClasses(const maple::rootObjectFunc &func) {
+  for (ClassPtr ptr : bucketData) {
+    if ((ptr & kIsConflict) != 0) { // conflict calc
+      ConflictClass *obj = reinterpret_cast<ConflictClass*>(ptr & ~kIsConflict);
+      for (ClassPtr conflict : obj->conflictData) {
+        MClass *classInfo = reinterpret_cast<MClass*>(conflict);
+        func(reinterpret_cast<maple::address_t>(classInfo));
+      }
+    } else { // not conflict
+      MClass *classInfo = reinterpret_cast<MClass*>(ptr);
+      func(reinterpret_cast<maple::address_t>(classInfo));
+    }
+  }
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/loader/loader_utils.cpp b/src/mrt/compiler-rt/src/loader/loader_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bae4768e1c389fbe3a17e91bf33ab6ee32c25b40
--- /dev/null
+++ b/src/mrt/compiler-rt/src/loader/loader_utils.cpp
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "loader/loader_utils.h"
+
+#include <climits>
+
+#include "utils/string_utils.h"
+#include "base/file_utils.h"
+#include "loader_api.h"
+#include "file_system.h"
+#include "linker_api.h"
+#include "file_adapter.h"
+
+using namespace maple;
+namespace maplert {
+namespace loaderutils {
+bool IsZipMagic(uint32_t magic) {
+  const uint8_t lowZipBit = 8;
+  const uint8_t lowZipMask = 0xff;
+  return (((magic & lowZipMask) == 'P') && (((magic >> lowZipBit) & lowZipMask) == 'K'));
+}
+std::string GetNicePath(const std::string &path) {
+  // Make canonical path.
+  std::string file(path);
+  if (file.find("/./") != std::string::npos || file.find("/../") != std::string::npos) {
+    if (file.length() > PATH_MAX) {
+      CL_LOG(ERROR) << "the path name exceeds the length limit! " << file.length() << ", " << file << maple::endl;
+      return "";
+    }
+    char canonical[PATH_MAX + 1] = { 0 };
+    if (realpath(file.c_str(), canonical)) {
+      file = canonical;
+    } else {
+      CL_LOG(ERROR) << "returned null! " << file << maple::endl;
+      return "";
+    }
+  }
+  return file;
+}
+std::string GetJarPath(const std::string &curDir,
+    const std::string &fileWithPostfix, bool isAppDataPath, bool isSystemPath) {
+  if (stringutils::WithSuffix(fileWithPostfix.c_str(), ".jar")) {
+    size_t jarPos = fileWithPostfix.rfind(".jar");
+    std::string newFileWithPostFix(fileWithPostfix);
+    newFileWithPostFix = "libmaple" + newFileWithPostFix.replace(jarPos, sizeof(".jar"), ".so");
+    // PATH 2: system jar in /system/ or /apex/, and end with .jar
+    // return /system/lib64/libmaple<jar-name-without-postfix>.so
+    if (isSystemPath) {
+      std::string newFilePath = maple::fs::kSystemLibPath + newFileWithPostFix;
+      CL_VLOG(classloader) << "return " << newFilePath << maple::endl;
+      return newFilePath;
+    }
+
+    // PATH 3: not starts with /data/data/ and /data/user/, and end with .jar
+    // return <current-dir>/maple/arm64/libmaple<jar-name-without-postfix>.so
+    if (!isAppDataPath) {
+      CL_VLOG(classloader) << "return " << curDir << "maple/arm64/" << newFileWithPostFix << maple::endl;
+      return curDir + "maple/arm64/" + newFileWithPostFix;
+    }
+  }
+  return "";
+}
+std::string GetApkPath(const std::string &curDir, const std::string &fileWithPostfix, bool isAppDataPath) {
+  const std::string appSoPostfix = "maple/arm64/mapleclasses.so";
+  const std::string appPartialSoPostfix = "maple/arm64/maplepclasses.so";
+  if (stringutils::WithSuffix(fileWithPostfix.c_str(), ".apk")) {
+    // PATH 4: not starts with /data/data/ and /data/user/, and end with .apk
+    // return <current-dir>/maple/arm64/mapleclasses.so for full AOT
+    // return <current-dir>/maple/arm64/maplepclasses.so for partial AOT
+    if (!isAppDataPath) {
+      std::string result = curDir + appSoPostfix;
+      // check PATH 4 existence
+      if (FileUtils::FileExists(result)) {
+        CL_VLOG(classloader) << "return " << result << maple::endl;
+        return result;
+      }
+      // check partial classes
+      result = curDir + appPartialSoPostfix;
+      if (FileUtils::FileExists(result)) {
+        CL_VLOG(classloader) << "return " << result << maple::endl;
+        return result;
+      }
+    }
+  }
+  return "";
+}
+std::string Dex2MplPath(const std::string &filePath) {
+  std::string file(filePath);
+  CL_VLOG(classloader) << "input " << file << maple::endl;
+
+#ifndef __OPENJDK__
+  size_t curDirPos = file.rfind('/');
+  // PATH 1: if there is no path, just file name
+  // return input directly, like libmaplecore-all.so
+  if (curDirPos == std::string::npos) {
+    CL_VLOG(classloader) << "return " << file << maple::endl;
+    return file;
+  }
+
+  std::string curDir = file.substr(0, curDirPos + 1);
+  std::string fileWithPostfix = file.substr(curDirPos + 1);
+
+  // PATH 2: system path starts with /system/ or /apex/
+  bool isAppDataPath = stringutils::WithPrefix(file.c_str(), "/data/data/") ||
+      stringutils::WithPrefix(file.c_str(), "/data/user/");
+  bool isSystemPath = stringutils::WithPrefix(file.c_str(), "/system/") ||
+      stringutils::WithPrefix(file.c_str(), "/apex/");
+
+  std::string resultPath = GetJarPath(curDir, fileWithPostfix, isAppDataPath, isSystemPath);
+  if (!resultPath.empty()) {
+    return resultPath;
+  }
+
+  resultPath = GetApkPath(curDir, fileWithPostfix, isAppDataPath);
+  if (!resultPath.empty()) {
+    return resultPath;
+  }
+
+  // return <current-dir>/maple/arm64/libmaple<name-with-postfix>.so
+  if (isAppDataPath) {
+    std::string result = curDir + "maple/arm64/libmaple" + fileWithPostfix + ".so";
+    // check PATH 5 existence
+    if (FileUtils::FileExists(result)) {
+      CL_VLOG(classloader) << "return " << result << maple::endl;
+      return result;
+    }
+  }
+
+  // read and check file magic number
+  std::unique_ptr<File> fileInput;
+  fileInput.reset(FileUtils::OpenFileReadOnly(file));
+  if (fileInput.get() != nullptr) {
+    uint32_t magic = 0;
+    int ret = static_cast<int>(fileInput->Read(
+        reinterpret_cast<char*>(&magic), static_cast<int64_t>(sizeof(magic)), 0));
+    if ((ret == static_cast<int>(sizeof(magic))) && IsZipMagic(magic)) {
+      // PATH 6: if the others all failed
+      // return <file-path>!/maple/arm64/mapleclasses.so
+      CL_VLOG(classloader) << "return " << file << "!/maple/arm64/mapleclasses.so" << maple::endl;
+      return file + "!/maple/arm64/mapleclasses.so";
+    }
+  }
+
+  // default path
+  CL_VLOG(classloader) << "return " << file << maple::endl;
+  return file;
+#else
+  CL_VLOG(classloader) << "return " << file << maple::endl;
+  return file;
+#endif
+}
+
+bool CheckVersion(const ObjFile &mplFile, const LinkerMFileInfo &mplInfo) {
+  maplert::MapleVersionT mplFileVersion;
+  maplert::LinkerAPI::Instance().GetMplVersion(mplInfo, mplFileVersion);
+  if (mplFileVersion.mplMajorVersion > Version::kMajorMplVersion) {
+    CL_LOG(ERROR) << "Compiler and Runtime major version are inconsistent in " << mplFile.GetName() <<
+        " Compiler version : " << mplFileVersion.mplMajorVersion << "." << mplFileVersion.compilerMinorVersion <<
+        ", Runtime version : " << Version::kMajorMplVersion << "." << Version::kMinorRuntimeVersion << maple::endl;
+    return false;
+  }
+  return true;
+}
+
+bool CheckCompilerStatus(const ObjFile &mplFile, const LinkerMFileInfo &mplInfo) {
+  // check mpl file compiler status
+  constexpr uint32_t gcOnlyMask = 1;
+  uint32_t compilerStatus = 0;
+  maplert::LinkerAPI::Instance().GetMplCompilerStatus(mplInfo, compilerStatus);
+  AdapterExAPI *adapter = maplert::LoaderAPI::Instance().GetAdapterEx().As<AdapterExAPI*>();
+  bool gcOnlyInProcess = adapter->IsGcOnly();
+  bool gcOnlyInMfile = static_cast<bool>(compilerStatus & gcOnlyMask);
+
+  // if mfile is gc only, the process must be gconly mode;
+  if (gcOnlyInMfile && !gcOnlyInProcess) {
+    CL_LOG(FATAL) << "Compiler status: " << compilerStatus << " in " << mplFile.GetName() <<
+        " dont match the process gc only mode" << maple::endl;
+  }
+
+  // in zygote startup mode, all mfile should be rc and process in rc mode
+  // in application startup mode, if in process rc mode, all after-loaded mfle
+  // should be rc mfile, otherwise in process gc-only mode, all after-loaded mfile
+  // can be rc mfile or gc mfile. butr rc mfile don't friendly performance
+  if (gcOnlyInMfile != gcOnlyInProcess) {
+    CL_LOG(INFO) << "Compiler status: " << compilerStatus << " in " << mplFile.GetName() << " in not-friendly mode" <<
+        " process is in" << (gcOnlyInProcess ? " gconly mode" : " rc mode") << maple::endl;
+  }
+  return true;
+}
+}
+} // end namespace maplert
diff --git a/src/mrt/compiler-rt/src/loader/object_loader.cpp b/src/mrt/compiler-rt/src/loader/object_loader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6767fc8ac2960087be7ea9a4a798f09792a8b9fc
--- /dev/null
+++ b/src/mrt/compiler-rt/src/loader/object_loader.cpp
@@ -0,0 +1,503 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "loader/object_loader.h"
+
+#include "chelper.h"
+#include "cpphelper.h"
+#include "base/systrace.h"
+#include "yieldpoint.h"
+#include "interp_support.h"
+
+using namespace std;
+namespace maplert {
+ObjectLoader::ObjectLoader() : mBootClassLoader(nullptr), mSystemClassLoader(nullptr) {}
+ObjectLoader::~ObjectLoader() {
+  mBootClassLoader = nullptr;
+  mSystemClassLoader = nullptr;
+  pLinker = nullptr;
+  pAdapterEx = nullptr;
+}
+
+// API Interfaces Begin
+void ObjectLoader::PreInit(IAdapterEx adapterEx) {
+  pLinker = &LinkerAPI::Instance();
+  pAdapterEx = adapterEx.As<AdapterExAPI*>();
+}
+void ObjectLoader::PostInit(jobject systemClassLoader) {
+  mSystemClassLoader = reinterpret_cast<MObject*>(systemClassLoader);
+  RC_RUNTIME_INC_REF(systemClassLoader);
+}
+void ObjectLoader::UnInit() {
+  if (mSystemClassLoader != nullptr) {
+    RC_RUNTIME_DEC_REF(reinterpret_cast<jobject>(mSystemClassLoader));
+  }
+}
+// If boot class loader, directly use nullptr as class loader.
+// If so, we can reduce once iteration.
+bool ObjectLoader::IsBootClassLoader(jobject classLoader) {
+  if (classLoader == nullptr) {
+    return true;
+  }
+  // save Inc/DecRef
+  // If mBootClassLoader is not initialized, it must false, compare return false
+  // If mBootClassLoader is initialized, return compare result
+  return mBootClassLoader == reinterpret_cast<MObject*>(classLoader);
+}
+
+// WARNING: speical handle return value's RC for this method
+// parent class loader return result can only be used in maple linker runtime code
+// CANNOT return to java code
+// save inc/dec cost
+jobject ObjectLoader::GetCLParent(jobject classLoader) {
+  if (IsBootClassLoader(classLoader)) {
+    return nullptr;
+  }
+  if (WorldStopped()) {
+    jobject res = MRT_ReflectGetFieldjobject(GetCLField(kFieldParent), classLoader);
+    // warning, this is exceptional case, no incref for return value
+    RC_LOCAL_DEC_REF(res);
+    return res;
+  }
+  maplert::ScopedObjectAccess soa;
+  jobject res = MRT_ReflectGetFieldjobject(GetCLField(kFieldParent), classLoader);
+  // warning, this is exceptional case, no incref for return value
+  RC_LOCAL_DEC_REF(res);
+  return res;
+}
+
+void ObjectLoader::SetCLParent(jobject classLoader, jobject parentClassLoader) {
+  if (IsBootClassLoader(classLoader)) {
+    return;
+  }
+  maplert::ScopedObjectAccess soa;
+  MRT_ReflectSetFieldjobject(GetCLField(kFieldParent), classLoader, parentClassLoader);
+}
+
+bool ObjectLoader::LoadClasses(jobject classLoader, ObjFile &objFile) {
+  if (objFile.GetFileType() == FileType::kMFile) {
+    return LoadClasses(reinterpret_cast<MObject*>(classLoader), objFile);
+  } else if (objFile.GetFileType() == FileType::kDFile) {
+    return MClassLocatorManagerInterpEx::LoadClasses(*this, classLoader, objFile);
+  }
+  CL_LOG(ERROR) << "unknow class file type" << maple::endl;
+  return false;
+}
+
+size_t ObjectLoader::GetLoadedClassCount() {
+  size_t totalCount = 0;
+  ClassLocator *classLocator = nullptr;
+
+  // Boot Class loader
+  classLocator = reinterpret_cast<ClassLocator*>(const_cast<MObject*>(mCLTable[0]));
+  totalCount += classLocator->GetLoadedClassCount();
+
+  for (int i = 1; i < kMaxClassloaderNum; ++i) {
+    const MObject *classLoader = mCLTable[i];
+    jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(classLoader));
+    if (classLoader == nullptr) {
+      break;
+    }
+    classLocator = GetCLClassTable(jClassLoader).As<ClassLocator*>();
+    if (classLocator == nullptr) {
+      CL_LOG(ERROR) << "failed, cl=" << classLoader << ", classLocator is null!" << maple::endl;
+      continue;
+    }
+    totalCount += classLocator->GetLoadedClassCount();
+  }
+
+  return totalCount;
+}
+
+size_t ObjectLoader::GetAllHashMapSize() {
+  size_t totalSize = 0;
+  // Boot Class loader
+  ClassLocator *classLocator = reinterpret_cast<ClassLocator*>(const_cast<MObject*>(mCLTable[0]));
+  totalSize += classLocator->GetClassHashMapSize();
+
+  for (int i = 1; i < kMaxClassloaderNum; ++i) {
+    const MObject *classLoader = mCLTable[i];
+    jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(classLoader));
+    if (classLoader == nullptr) {
+      break;
+    }
+    classLocator = GetCLClassTable(jClassLoader).As<ClassLocator*>();
+    if (classLocator == nullptr) {
+      CL_LOG(ERROR) << "failed, classloader=" << classLoader << ", to CHECK why classLocator is null!" << maple::endl;
+      continue;
+    }
+    totalSize += classLocator->GetClassHashMapSize();
+  }
+
+  return totalSize;
+}
+
+bool ObjectLoader::IsLinked(jobject classLoader) {
+  ClassLocator *classLocator = GetCLClassTable(classLoader).As<ClassLocator*>();
+  if (classLocator == nullptr) {
+    return true; // Not to link if no classes loaded.
+  }
+  return classLocator->IsLinked();
+}
+
+void ObjectLoader::SetLinked(jobject classLoader, bool isLinked) {
+  ClassLocator *classLocator = GetCLClassTable(classLoader).As<ClassLocator*>();
+  if (classLocator == nullptr) {
+    return;
+  }
+  classLocator->SetLinked(isLinked);
+}
+
+void ObjectLoader::ReTryLoadClassesFromMplFile(jobject classLoader, ObjFile &mplFile) {
+  std::vector<LinkerMFileInfo*> fakeInfoList; // just for not multi-so, it is a empty list and never used
+  (void)LoadClassesFromMplFile(reinterpret_cast<const MObject*>(classLoader), mplFile, fakeInfoList);
+}
+
+bool ObjectLoader::GetClassNameList(jobject classLoader, ObjFile &objFile, vector<std::string> &classVec) {
+  ClassLocator *classLocator = GetCLClassTable(classLoader).As<ClassLocator*>();
+  if (classLocator == nullptr) {
+    return false;
+  }
+  return classLocator->GetClassNameList(objFile, classVec);
+}
+// MRT_EXPORT Split
+// visit class laoder gc roots
+void ObjectLoader::VisitGCRoots(const RefVisitor &function) {
+  // system class loader is also recorded is Runtime, not visit there
+  function(reinterpret_cast<address_t&>(mSystemClassLoader));
+  for (int i = 1; i < kMaxClassloaderNum; ++i) {
+    if (mCLTable[i] == nullptr) {
+      break;
+    }
+    function(reinterpret_cast<address_t&>(mCLTable[i]));
+  }
+}
+
+jobject ObjectLoader::GetSystemClassLoader() {
+  // exceptional case, no need incref, as this only used in runtime and not return to java code
+  // warning: use it with special care of RC
+  return reinterpret_cast<jobject>(mSystemClassLoader);
+}
+
+jobject ObjectLoader::GetBootClassLoaderInstance() {
+#ifndef __OPENJDK__
+  if (mBootClassLoader == nullptr) {
+    MClass *cls = reinterpret_cast<MClass*>(LocateClass("Ljava/lang/BootClassLoader;", SearchFilter()));
+    MethodMeta *getInstanceMth = cls->GetMethod("getInstance", "()Ljava/lang/BootClassLoader;");
+    mBootClassLoader = reinterpret_cast<MObject*>(getInstanceMth->InvokeJavaMethodFast<jobject>(nullptr));
+    // warning, this is exceptional case, no incref for return value
+    RC_LOCAL_DEC_REF(reinterpret_cast<jobject>(mBootClassLoader));
+    return reinterpret_cast<jobject>(mBootClassLoader);
+  }
+#endif // !__OPENJDK__
+  return reinterpret_cast<jobject>(mBootClassLoader);
+}
+
+void ObjectLoader::SetClassCL(jclass kls, jobject cl) {
+  MClass *klass = reinterpret_cast<MClass*>(kls);
+  MObject *classLoader = reinterpret_cast<MObject*>(cl);
+  if (klass == nullptr) {
+    CL_LOG(ERROR) << "failed, classloader=" << cl << ", error parameter: klass is null!" << maple::endl;
+    return;
+  }
+  if (IsBootClassLoader(cl)) { // for bootstrap class loader
+    klass->SetClIndex(static_cast<uint16_t>(kClIndexFlag | 0));
+    return;
+  }
+  int16_t pos = -1;
+  bool found = LocateIndex(classLoader, pos);
+  if (found) {
+    klass->SetClIndex(static_cast<uint16_t>(kClIndexFlag | static_cast<uint16_t>(pos)));
+  } else if (!found && pos != -1) {
+    mCLTable[pos] = classLoader;
+    RC_RUNTIME_INC_REF(classLoader);
+    klass->SetClIndex(static_cast<uint16_t>(kClIndexFlag | static_cast<uint16_t>(pos)));
+  } else {
+    CL_LOG(ERROR) << "failed, classloader=" << classLoader << ", table is null!" << maple::endl;
+  }
+}
+
+// Get class locator from Class Loader's 'classTable' field.
+// Notice that we get special locator at the beginning of mCLTable for boot class loader.
+IObjectLocator ObjectLoader::GetCLClassTable(jobject classLoader) {
+  if (IsBootClassLoader(classLoader)) {
+    return reinterpret_cast<ClassLocator*>(const_cast<MObject*>(mCLTable[0]));
+  }
+  return reinterpret_cast<ClassLocator*>(MRT_ReflectGetFieldjlong(GetCLField(kFieldClassTable), classLoader));
+}
+
+void ObjectLoader::SetCLClassTable(jobject classLoader, IObjectLocator classLocator) {
+  if (IsBootClassLoader(classLoader)) { // Boot classlocator is fixed at mCLTable[0], use it directly.
+    mCLTable[0] = classLocator.As<const MObject*>();
+    return;
+  }
+  // We set class locator for all classloaders, except bootclassloader.
+  MRT_ReflectSetFieldjlong(GetCLField(kFieldClassTable), classLoader, classLocator.As<jlong>());
+}
+// API Interfaces End
+bool ObjectLoader::LoadClassesFromMplFile(const MObject *classLoader, ObjFile &objFile,
+    std::vector<LinkerMFileInfo*> &mplInfoList, bool hasSiblings) {
+  bool isDecouple = true;
+  jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(classLoader));
+  if (objFile.GetFileType() == FileType::kMFile) {
+    if (!pLinker->Add(objFile, jClassLoader)) {
+      CL_LOG(ERROR) << "invalid maple file, or multiple loading " << objFile.GetName() << maple::endl;
+    }
+    LinkerMFileInfo *mplInfo = objFile.GetMplInfo();
+    objFile.Load();
+    if (hasSiblings) {
+      mplInfoList.push_back(mplInfo);
+    } else {
+      static_cast<void>(pLinker->Link(*mplInfo, isDecouple));
+    }
+
+    // check mpl file version
+    if (!loaderutils::CheckVersion(objFile, *mplInfo)) {
+      return false;
+    }
+
+    // check mpl file compiler status, such as is gconly
+    if (!loaderutils::CheckCompilerStatus(objFile, *mplInfo)) {
+      return false;
+    }
+
+    SetLinked(jClassLoader, false);
+
+    if (!LoadClasses(jClassLoader, objFile)) {
+      CL_LOG(ERROR) << "failed to load classes from " << objFile.GetName() << ", classloader: " << classLoader <<
+          maple::endl;
+      return false;
+    }
+    objFile.SetClassTableLoaded();
+  } else if (objFile.GetFileType() == FileType::kDFile) {
+    if (!pAdapterEx->IsStarted()) {
+      // Now, ClassLocatorManager.LoadClasses is needed only for one case:
+      // loading Dex files in classpath into SystemClassLoader.
+      if (!LoadClasses(jClassLoader, objFile)) {
+        CL_LOG(ERROR) << "load class for dex file failed: " << objFile.GetName() << maple::endl;
+        return false;
+      }
+    }
+  } else {
+    return false;
+  }
+  return true;
+}
+
+void ObjectLoader::UnloadClasses(const MObject *classLoader) {
+  jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(classLoader));
+  ClassLocator *classLocator = GetCLClassTable(jClassLoader).As<ClassLocator*>();
+  if (classLocator == nullptr) {
+    CL_LOG(ERROR) << "failed, classLocator is null." << maple::endl;
+    return;
+  }
+  classLocator->UnloadClasses();
+
+  // Destruct class loader's references properly.
+  if (IsBootClassLoader(jClassLoader)) { // for boot class loader
+    mCLTable[0] = nullptr; // Dereference the class locator of boot class loader.
+  } else if (!RecycleIndex(classLoader)) { // Dereference the class loader, and recycle mCLTable index.
+    CL_LOG(ERROR) << "RecycleIndex fail" << maple::endl;
+  }
+  delete classLocator; // Delete the class locator of class loader.
+}
+
+void ObjectLoader::VisitClassesByLoader(const MObject *loader, const maple::rootObjectFunc &func) {
+  jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(loader));
+  ClassLocator *locator = GetCLClassTable(jClassLoader).As<ClassLocator*>();
+  if (locator == nullptr) {
+    CL_LOG(ERROR) << "VisitClasses locator null for loader:" << loader << maple::endl;
+    return;
+  }
+  locator->VisitClasses(func, IsBootClassLoader(jClassLoader));
+}
+
+jfieldID ObjectLoader::GetCLField(const FieldName &field) {
+  static jfieldID cachedFields[] = { nullptr, nullptr };
+  static const char *cachedNames[] = { "parent", "classTable" };
+  if (cachedFields[field] == nullptr) {
+    if (mCLTable[0] != nullptr) {
+      jclass klass = FindClass("Ljava/lang/ClassLoader;", SearchFilter());
+      if (klass == nullptr) {
+        CL_LOG(ERROR) << "failed, can't find \"java/lang/ClassLoader\"!" << maple::endl;
+        return nullptr;
+      }
+      cachedFields[field] = MRT_ReflectGetCharField(klass, cachedNames[field]);
+      if (cachedFields[field] == nullptr) {
+        CL_LOG(ERROR) << "failed, mParentField should not null!" << maple::endl;
+      }
+    } else {
+      CL_LOG(ERROR) << "failed for mCLTable[0] is null!" << maple::endl;
+    }
+  }
+  return cachedFields[field];
+}
+
+MObject *ObjectLoader::GetClassCL(MClass *klass) {
+  uint16_t index = klass->GetClIndex();
+  // Remove after clIndex can be initialized by compiler.
+  if ((kClIndexFlagMask & index) == kClIndexFlag && index != kClIndexInintValue) { // Once initialized
+    index = kClIndexValueMask & index;
+  } else { // Not initialized
+    index = 0;
+    klass->SetClIndex(static_cast<uint16_t>(kClIndexFlag | 0));
+    CL_DLOG(classloader) << "not initialized for " << klass->GetName() << maple::endl;
+  }
+
+  if (index == 0) { // for boot class loader
+    return nullptr;
+  } else if (index > 0 && index < kMaxClassloaderNum) {
+    return const_cast<MObject*>(mCLTable[index]);
+  } else {
+    CL_LOG(ERROR) << "failed for index=" << index << maple::endl;
+    return nullptr;
+  }
+}
+
+// Assign index for classloader in advance, and return index with mask.
+uint16_t ObjectLoader::PresetClassCL(const MObject *classLoader) {
+  jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(classLoader));
+  if (IsBootClassLoader(jClassLoader)) { // for boot class loader
+    return static_cast<uint16_t>(kClIndexFlag | 0);
+  }
+  int16_t pos = -1;
+  bool found = LocateIndex(classLoader, pos);
+  if (found) {
+    return static_cast<uint16_t>(kClIndexFlag | static_cast<uint16_t>(pos));
+  } else if (!found && pos != -1) {
+    maplert::ScopedObjectAccess soa;
+    mCLTable[pos] = classLoader;
+    RC_RUNTIME_INC_REF(classLoader);
+    return static_cast<uint16_t>(kClIndexFlag | static_cast<uint16_t>(pos));
+  } else {
+    CL_LOG(ERROR) << "failed, classloader=" << classLoader << ", table is null!" << maple::endl;
+    return 0;
+  }
+}
+
+// Return the index if matched, or found a new valid index.
+bool ObjectLoader::LocateIndex(const MObject *classLoader, int16_t &pos) const {
+  pos = -1;
+  for (int16_t i = 1; i < kMaxClassloaderNum; ++i) {
+    if (mCLTable[i] == classLoader) { // Matched class loader set before.
+      pos = i;
+      return true;
+    } else if (mCLTable[i] == nullptr) {
+      pos = i;
+      return false;
+    }
+  }
+  return false;
+}
+
+// Recycle the index, we can rearrange the index to other class loader.
+bool ObjectLoader::RecycleIndex(const MObject *classLoader) {
+  for (int32_t i = 1; i < kMaxClassloaderNum; ++i) {
+    if (mCLTable[i] == classLoader) { // Matched class loader set before.
+      mCLTable[i] = nullptr;
+      RC_RUNTIME_DEC_REF(classLoader);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void ObjectLoader::RegisterDynamicClass(const MObject *classLoader, const MClass *klass) {
+  jclass jKlass = reinterpret_cast<jclass>(const_cast<MClass*>(klass));
+  jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(classLoader));
+  ClassLocator *classLocator = GetCLClassTable(jClassLoader).As<ClassLocator*>();
+  if (classLocator == nullptr) {
+    CL_LOG(ERROR) << "failed, classloader=" << classLoader << ", to CHECK why classLocator is null!" << maple::endl;
+    return;
+  }
+  char *className = klass->GetName();
+  if (!classLocator->RegisterDynamicClass(className, *const_cast<MClass*>(klass))) {
+    CL_LOG(ERROR) << "failed to registerDynamicClass,name:className" << maple::endl;
+  }
+  SetClassCL(jKlass, jClassLoader);
+}
+
+void ObjectLoader::UnregisterDynamicClass(const MObject *classLoader, const MClass *klass) {
+  jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(classLoader));
+  ClassLocator *classLocator = GetCLClassTable(jClassLoader).As<ClassLocator*>();
+  if (classLocator == nullptr) {
+    CL_LOG(ERROR) << "failed, classloader=" << classLoader << ", to CHECK why classLocator is null!" << maple::endl;
+    return;
+  }
+  char *className = klass->GetName();
+  if (!classLocator->UnregisterDynamicClass(className)) {
+    CL_LOG(ERROR) << "failed to unregisterDynamicClass, name:className" << maple::endl;
+  }
+}
+
+// load classes from one ObjFile.
+bool ObjectLoader::LoadClasses(const MObject *classLoader, ObjFile &objFile) {
+  jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(classLoader));
+  ClassLocator *classLocator = GetCLClassTable(jClassLoader).As<ClassLocator*>();
+  if (classLocator == nullptr) {
+    classLocator = new (std::nothrow) ClassLocator();
+    if (classLocator == nullptr) {
+      LINKER_LOG(FATAL) << "new ClassLocator failed" << maple::endl;
+    }
+    SetCLClassTable(jClassLoader, classLocator);
+  }
+  if (classLocator == nullptr) {
+    CL_LOG(ERROR) << "failed, classloader=" << classLoader << ", classLocator is null" << maple::endl;
+    return false;
+  }
+
+  // We will check the 'mplInfo' lazy binding flag in the ClassLocator.
+  // If it's lazy, we will not set ClassLoader Index during initialization,
+  // even though set 'initCLIndex' parameter here.
+  if (!classLocator->LoadClasses(objFile, PresetClassCL(classLoader))) {
+    CL_LOG(ERROR) << "failed: classloader=" << classLoader << maple::endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool ObjectLoader::LoadClasses(const MObject *classLoader, vector<ObjFile*> &objList) {
+  jobject jClassLoader = reinterpret_cast<jobject>(const_cast<MObject*>(classLoader));
+  ClassLocator *classLocator = GetCLClassTable(jClassLoader).As<ClassLocator*>();
+  if (classLocator == nullptr) {
+    classLocator = new (std::nothrow) ClassLocator();
+    if (classLocator == nullptr) {
+      LINKER_LOG(FATAL) << "new ClassLocator failed!" << maple::endl;
+    }
+    SetCLClassTable(jClassLoader, classLocator);
+  }
+  if (classLocator == nullptr) {
+    CL_LOG(ERROR) << "failed, classloader = " << classLoader << ", classLocator is null" << maple::endl;
+    return false;
+  }
+
+  // We will check the 'mplInfo' lazy binding flag in each ClassLocator.
+  // If it's lazy, we will not set ClassLoader Index during initialization,
+  // even though set 'initCLIndex' parameter here.
+  if (!classLocator->LoadClasses(objList, PresetClassCL(classLoader))) {
+    return false;
+  }
+  if (IsBootClassLoader(jClassLoader)) {
+    // BootClassLoader will only call this function to load classes.
+    // now register predefined array (object) classes. This is required for fast cycle detection
+    for (MClass* primitiveItem: primitiveClasses) {
+      RegisterDynamicClass(classLoader, primitiveItem);
+    }
+  }
+  return true;
+}
+} // end namespace maple
diff --git a/src/mrt/compiler-rt/src/loader/object_locator.cpp b/src/mrt/compiler-rt/src/loader/object_locator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5802ee45c1d1a910b7d4a45621abb8520ac2b9a6
--- /dev/null
+++ b/src/mrt/compiler-rt/src/loader/object_locator.cpp
@@ -0,0 +1,420 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "loader/object_locator.h"
+
+#include <cinttypes>
+#include <algorithm>
+
+#include "sizes.h"
+#include "allocator.h"
+#include "itab_util.h"
+#include "loader/hash_pool.h"
+#include "loader/object_loader.h"
+using namespace std;
+
+namespace maplert {
+// Load classes for all .so files in list.
+bool ClassLocator::LoadClasses(vector<ObjFile*> &objList, uint16_t clIndex) {
+  maple::SpinAutoLock lock(spLock);
+  // Firstly get total classes count in all .so
+  uint32_t total = 0;
+  for (auto objFile : objList) {
+    uint32_t count = GetClassCount(*objFile);
+    if (count == 0) {
+      return false;
+    }
+    total += count;
+
+    CL_VLOG(classloader) << "Class Count of " << objFile->GetName() << ":" << count << maple::endl;
+  }
+
+  mLoadedClassCount += total;
+  CL_VLOG(classloader) << "Class Total Count:" << total << maple::endl;
+
+  // Initialize all class's class loader info. when .so is loaded.
+  MClassHashPool *pool;
+  pool = new (std::nothrow) MClassHashPool();
+  if (pool == nullptr) {
+    CL_LOG(FATAL) << "new MClassHashPool failed" << maple::endl;
+  }
+  pool->Create(total);
+  // For performance we construct only one MClassHashPool for boot/system classloader.
+  // App can't reflect class from boot classloader's maple file.
+  // So we set handle to nullptr.
+  if (mHashPools.find(nullptr) != mHashPools.end()) {
+    CL_LOG(FATAL) << "Attempt to Add Multi Pool to Same Boot Handle!" << maple::endl;
+  }
+  mHashPools[nullptr] = pool;
+  if (InitClasses(objList, *pool)) {
+    pool->Collect();
+    SetClasses(objList, *pool, clIndex);
+  }
+  CL_VLOG(classloader) << "LoadClasses(), Class Hash Conflict Rate:" << pool->GetHashConflictRate() << "/" <<
+      pool->GetClassConflictRate() << ", Total Memory Cost=" << pool->CalcMemoryCost() << maple::endl;
+  return true;
+}
+
+// Load classes for single .so file.
+bool ClassLocator::LoadClasses(ObjFile &objFile, uint16_t clIndex) {
+  maple::SpinAutoLock lock(spLock);
+  // Firstly get class count in .so
+  uint32_t count = GetClassCount(objFile);
+  if (count == 0) {
+    return false;
+  }
+  mLoadedClassCount += count;
+  CL_VLOG(classloader) << "Class Counts of " << objFile.GetName() << ":" << count << maple::endl;
+
+  // Initialize all class's class loader info. when .so is loaded.
+  MClassHashPool *pool;
+  pool = new (std::nothrow) MClassHashPool();
+  if (pool == nullptr) {
+    LINKER_LOG(FATAL) << "new MClassHashPool failed" << maple::endl;
+  }
+  pool->Create(count);
+  if (objFile.GetUniqueID() == 0) {
+    auto min = min_element(mHashPools.begin(), mHashPools.end(), [](const auto &left, const auto &right) {
+      if (left.first == nullptr) {
+        return false;
+      } else if (right.first == nullptr) {
+        return true;
+      }
+      return left.first->GetUniqueID() < right.first->GetUniqueID();
+    });
+    if (min != mHashPools.end() && min->first != nullptr) {
+      objFile.SetUniqueID(min->first->GetUniqueID() - 1);
+    }
+  }
+  if (mHashPools.find(&objFile) != mHashPools.end()) {
+    CL_LOG(FATAL) << "Attempt to Add Multi Pool to Same Handle, objFile=" << &objFile << maple::endl;
+  }
+  mHashPools[&objFile] = pool;
+  InitClasses(objFile, *pool);
+  pool->Collect();
+  SetClasses(objFile, *pool, clIndex);
+  CL_VLOG(classloader) << " conflict:" << pool->GetHashConflictRate() << "/" << pool->GetClassConflictRate() <<
+      ", for " << objFile.GetName() << ", Total Memory Cost=" << pool->CalcMemoryCost() << maple::endl;
+
+  return true;
+}
+
+void ClassLocator::SetClasses(vector<ObjFile*> &objList, MClassHashPool &pool, uint16_t clIndex) {
+  for (auto objFile : objList) {
+    SetClasses(*objFile, pool, clIndex);
+  }
+}
+
+void ClassLocator::SetClasses(const ObjFile &objFile, MClassHashPool &pool, uint16_t clIndex) {
+  DataRefOffset *data = objFile.GetMplInfo()->GetTblBegin<DataRefOffset*>(kClassMetadataBucket);
+  uint32_t size = static_cast<uint32_t>(objFile.GetMplInfo()->GetTblEnd<DataRefOffset*>(kClassMetadataBucket) - data);
+  bool isLazy = objFile.GetMplInfo()->IsFlag(kIsLazy);
+  for (uint32_t i = 0; i < size; ++i) {
+    DataRefOffset *klass = data + i;
+    MClass *classInfo = klass->GetDataRef<MClass*>();
+    pool.Set(static_cast<uint32_t>(classInfo->GetMonitor()), *classInfo);
+    classInfo->SetMonitor(0);
+    classInfo->ResolveVtabItab();
+    if (!isLazy) {
+      classInfo->SetClIndex(clIndex);
+      // Set classInfo->shadow for not lazy binding.
+      MRTSetMetadataShadow(reinterpret_cast<ClassMetadata*>(classInfo), WellKnown::GetMClassClass());
+    }
+    MRT_SetFastAlloc(reinterpret_cast<ClassMetadata*>(classInfo));
+    JSAN_ADD_CLASS_METADATA(classInfo);
+  }
+}
+
+// Initialize all classinfos for all .so in list.
+bool ClassLocator::InitClasses(vector<ObjFile*> &objList, MClassHashPool &pool) {
+  uint32_t count = 0;
+  for (auto objFile : objList) {
+    InitClasses(*objFile, pool);
+    ++count;
+  }
+  return count > 0;
+}
+
+// Initialize all classinfos in single .so.
+void ClassLocator::InitClasses(const ObjFile &objFile, MClassHashPool &pool) {
+  DataRefOffset *data = objFile.GetMplInfo()->GetTblBegin<DataRefOffset*>(kClassMetadataBucket);
+  uint32_t size = static_cast<uint32_t>(objFile.GetMplInfo()->GetTblEnd<DataRefOffset*>(kClassMetadataBucket) - data);
+  for (uint32_t i = 0; i < size; ++i) {
+    const DataRefOffset *klass = data + i;
+    MClass *classInfo = klass->GetDataRef<MClass*>();
+    pool.InitClass(static_cast<uint32_t>(classInfo->GetMonitor()));
+  }
+}
+
+uint32_t ClassLocator::GetClassCount(const ObjFile &objFile) {
+  DataRefOffset *hashTabStart = objFile.GetMplInfo()->GetTblBegin<DataRefOffset*>(kClassMetadataBucket);
+  DataRefOffset *hashTabEnd = objFile.GetMplInfo()->GetTblEnd<DataRefOffset*>(kClassMetadataBucket);
+  if ((hashTabStart == nullptr) || (hashTabEnd == nullptr)) {
+    return 0;
+  }
+  return static_cast<uint32_t>(hashTabEnd - hashTabStart);
+}
+
+void ClassLocator::UnloadClasses() {
+  maple::SpinAutoLock lock(spLock);
+
+  for (auto item : mHashPools) {
+    MClassHashPool *pool = item.second;
+    if (pool == nullptr) {
+      continue;
+    }
+    pool->Destroy();
+    delete pool;
+    pool = nullptr;
+  }
+  UnregisterDynamicClasses();
+}
+
+void ClassLocator::VisitClasses(const maple::rootObjectFunc &func, bool isBoot) {
+  // Remove lock to avoid dead lock with FindClass call.
+  for (auto item : mHashPools) {
+    MClassHashPool *pool = item.second;
+    pool->VisitClasses(func);
+  }
+
+  (void)(pthread_rwlock_rdlock(&dClassMapLock));
+  for (ClassMapConstIterT it2 = dClassMap.begin(); it2 != dClassMap.end(); ++it2) {
+    func(reinterpret_cast<maple::address_t>(it2->second));
+  }
+  (void)(pthread_rwlock_unlock(&dClassMapLock));
+
+  if (isBoot) { // boot class loader?
+    LoaderAPI::As<ObjectLoader&>().VisitPrimitiveClass(func);
+  }
+}
+
+bool ClassLocator::GetClassNameList(const ObjFile &objFile, vector<std::string> &classVec) {
+  maple::SpinAutoLock lock(spLock);
+
+  LinkerMFileInfo *mplInfo = objFile.GetMplInfo();
+  DataRefOffset *hashTabStart = mplInfo->GetTblBegin<DataRefOffset*>(kClassMetadataBucket);
+  DataRefOffset *hashTabEnd = mplInfo->GetTblEnd<DataRefOffset*>(kClassMetadataBucket);
+  if ((hashTabStart == nullptr) || (hashTabEnd == nullptr)) {
+    return false;
+  }
+  DataRefOffset *data = hashTabStart;
+  uint32_t size = static_cast<uint32_t>(hashTabEnd - hashTabStart);
+
+  for (uint32_t i = 0; i < size; ++i) {
+    DataRefOffset *klass = data + i;
+    if (klass != nullptr) {
+      MClass *classInfo = klass->GetDataRef<MClass*>();
+      classVec.emplace_back(classInfo->GetName());
+    }
+  }
+  return true;
+}
+
+// Find a class by class name.
+// For array class, if no loaded class found, create a array class and return.
+MClass *ClassLocator::InquireClass(const std::string &internalName, SearchFilter &filter) {
+  // Return null if it's void array such as "[V".
+  if (internalName[0] == '[') {
+    uint32_t dim = 0;
+    while (internalName[dim] == '[') {
+      ++dim;
+    }
+    if (internalName[dim] == 'V') {
+      return nullptr;
+    }
+  }
+  MClass *classInfo = FindClassInternal(internalName, filter);
+  if (classInfo != nullptr) {
+    JSAN_ADD_CLASS_METADATA(classInfo);
+    return classInfo;
+  }
+
+  // Try to create a array classe
+  if (internalName[0] == '[') {
+    classInfo = CreateArrayClassRecursively(internalName, filter);
+  }
+  JSAN_ADD_CLASS_METADATA(classInfo);
+  return classInfo;
+}
+
+MClass *ClassLocator::FindLoadedClass(const MClassHashPool &pool, const std::string &className, SearchFilter &filter) {
+  MClass *classInfo = nullptr;
+  ClassMetadata *metaData = nullptr;
+  // Find it in hashpool first.
+  classInfo = pool.Get(className);
+  // If no class found, we find whether it is dex in the dexFiles.
+  if (classInfo == nullptr && filter.currentFile != nullptr && filter.currentFile->GetFileType() == FileType::kDFile) {
+    metaData = MClassLocatorInterpEx::BuildClassFromDex(this, className, filter);
+    classInfo = reinterpret_cast<MClass*>(metaData);
+  }
+
+  if (classInfo != nullptr) {
+    filter.outFile = filter.currentFile;
+  }
+  return classInfo;
+}
+
+// Find class without creating array class.
+// Here we can find the class in mpl, dex, or created array class.
+MClass *ClassLocator::FindClassInternal(const std::string &className, SearchFilter &filter) {
+  maple::SpinAutoLock lock(spLock);
+  MClass *classInfo = nullptr;
+  if (className[0] != '[') {
+    // Traversal in all class hash map.
+    if (filter.currentFile != nullptr) {
+      auto item = mHashPools.find(filter.currentFile);
+      if (item == mHashPools.end()) {
+        return classInfo;
+      }
+      MClassHashPool *currentPool = item->second;
+      classInfo = FindLoadedClass(*currentPool, className, filter);
+    } else {
+      for (auto item : mHashPools) {
+        filter.currentFile = item.first;
+        classInfo = FindLoadedClass(*item.second, className, filter);
+        if (classInfo != nullptr) {
+          return classInfo;
+        }
+      }
+    }
+  }
+  // It may be created by an array class or by another runtime class, such as proxy/annotation classes.
+  if (classInfo == nullptr) {
+    classInfo = FindRuntimeClass(className);
+  }
+  return classInfo;
+}
+
+MClass *ClassLocator::CreateArrayClassRecursively(const std::string &mplClassName, SearchFilter &filter) {
+  uint32_t dim = 0;
+  while (mplClassName[dim] == '[') {
+    ++dim;
+  }
+
+  // find the first component class defined. don't recursive
+  MClass *componentClass = nullptr;
+  uint32_t currentDim;
+  for (currentDim = 1; currentDim < dim; ++currentDim) {
+    componentClass = FindClassInternal(&mplClassName[currentDim], filter);
+    if (componentClass != nullptr) {
+      break;
+    }
+  }
+
+  // The non-array element class type
+  if (componentClass == nullptr) {
+    componentClass = FindClassInternal(&mplClassName[dim], filter);
+  }
+
+  // Cannot find the element class
+  if (componentClass == nullptr) {
+    return static_cast<MClass*>(nullptr);
+  }
+
+  if (componentClass->IsLazyBinding()) {
+    (void)LinkerAPI::Instance().LinkClassLazily(*componentClass);
+  }
+
+  MClass *currentClass = nullptr;
+  for (int i = currentDim - 1; i >= 0; --i) {
+    maple::SpinAutoLock lock(spLock);
+    currentClass = FindRuntimeClass(&mplClassName[static_cast<uint32_t>(i)]);
+    if (currentClass != nullptr) { // Current class already registered
+      componentClass = currentClass;
+      continue;
+    } else { // Not registered
+      currentClass = LoaderAPI::As<ObjectLoader&>().CreateArrayClass(
+          &mplClassName[static_cast<uint32_t>(i)], *componentClass);
+      if (currentClass != nullptr) {
+        (void)!RegisterDynamicClass(&mplClassName[static_cast<uint32_t>(i)], *currentClass);
+        // No memory leak happens, 'cause it's reserved by RegisterDynamicClass().
+        componentClass = currentClass;
+      } else {
+        break;
+      }
+    }
+  }
+  return currentClass;
+}
+
+bool ClassLocator::RegisterDynamicClass(const std::string &className, MClass &classObj) {
+  if (FindRuntimeClass(className) != nullptr) {
+    return true;
+  }
+  (void)(pthread_rwlock_wrlock(&dClassMapLock));
+  if ((dClassMap.emplace(std::pair<const std::string, MClass*>(className, &classObj))).second != true) {
+    CL_LOG(ERROR) << "dClassMap insert not return true" << maple::endl;
+    (void)(pthread_rwlock_unlock(&dClassMapLock));
+    return false;
+  }
+  MRT_SetFastAlloc(reinterpret_cast<ClassMetadata*>(&classObj));
+  (void)(pthread_rwlock_unlock(&dClassMapLock));
+  JSAN_ADD_CLASS_METADATA(&classObj);
+  return true;
+}
+
+void ClassLocator::UnregisterDynamicClassImpl(const ClassMapIterT &it) const {
+  MClass *klass = it->second;
+  if (klass != nullptr) {
+    char *className = klass->GetName();
+    if (className != nullptr) {
+      klass->SetName(nullptr);
+    }
+    it->second = nullptr;
+  }
+}
+
+bool ClassLocator::UnregisterDynamicClass(const std::string &className) {
+  (void)(pthread_rwlock_wrlock(&dClassMapLock));
+  ClassMapIterT it = dClassMap.find(className);
+  if (it != dClassMap.end()) {
+    UnregisterDynamicClassImpl(it);
+    (void)dClassMap.erase(it);
+    (void)(pthread_rwlock_unlock(&dClassMapLock));
+    return true;
+  }
+  (void)(pthread_rwlock_unlock(&dClassMapLock));
+  return false;
+}
+
+void ClassLocator::UnregisterDynamicClasses() {
+  (void)(pthread_rwlock_wrlock(&dClassMapLock));
+  for (ClassMapIterT it = dClassMap.begin(); it != dClassMap.end(); ++it) {
+    UnregisterDynamicClassImpl(it);
+  }
+  dClassMap.clear();
+  (void)(pthread_rwlock_unlock(&dClassMapLock));
+}
+
+// just try to get the array class
+MClass *ClassLocator::FindRuntimeClass(const std::string &mplClassName) {
+  MClass *classInfo = LoaderAPI::As<ObjectLoader&>().GetPrimitiveClass(mplClassName);
+  if (classInfo != nullptr) {
+    return classInfo;
+  }
+  (void)(pthread_rwlock_rdlock(&dClassMapLock));
+  ClassMapConstIterT it = dClassMap.find(mplClassName);
+  if (it != dClassMap.end()) {
+    (void)(pthread_rwlock_unlock(&dClassMapLock));
+    return it->second;
+  }
+  (void)(pthread_rwlock_unlock(&dClassMapLock));
+  return nullptr;
+}
+
+size_t ClassLocator::GetClassHashMapSize() {
+  maple::SpinAutoLock lock(spLock);
+  return sizeof(MClassHashPool) * mHashPools.size();
+}
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/mangle_for_jni.cpp b/src/mrt/compiler-rt/src/mangle_for_jni.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0a43fc7233ebc936a4d1cdd624fbf01713881c36
--- /dev/null
+++ b/src/mrt/compiler-rt/src/mangle_for_jni.cpp
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_naming_api.h"
+#include "utils/string_utils.h"
+
+namespace namemanglerapi {
+static bool ConvertSpeicalChar(uint32_t code, std::string &str) {
+  switch (code) {
+    case '.':
+    case '/':
+      str = "_";
+      return true;
+    case '_':
+      str = "_1";
+      return true;
+    case ';':
+      str = "_2";
+      return true;
+    case '[':
+      str = "_3";
+      return true;
+    default:
+      return false;
+  }
+}
+
+static inline void AppendUint(std::string &s, uint32_t code) {
+  const uint16_t low = static_cast<uint16_t>(code & 0xFFFF);
+  const uint16_t high = static_cast<uint16_t>(code >> 16); // get the high 16 bits
+
+  stringutils::AppendFormat(s, "_0%04x", low);
+  if (high != 0) {
+    stringutils::AppendFormat(s, "_0%04x", high);
+  }
+}
+
+static uint32_t DecodeUtf8(const char *&data) {
+  // one~three utf8 bytes translate to utf16 in 'Basic Multilingual Plane'
+  const uint8_t byte0 = *data++;
+  // utf8 one byte: 0xxxxxxx
+  if (byte0 < 0x80) {
+    return byte0;
+  }
+
+  // utf8 two bytes: 110xxxxx 10xxxxxx
+  uint32_t rc = 0;
+  const uint8_t byte1 = *data++;
+  if (byte0 < 0xe0) {
+    rc = (static_cast<uint32_t>(byte0 & 0x1f) << 6) | (static_cast<uint32_t>(byte1 & 0x3f));
+    return rc;
+  }
+
+  // utf8 three bytes: 1110xxxx 10xxxxxx 10xxxxxx
+  const uint8_t byte2 = *data++;
+  if (byte0 < 0xf0) {
+    rc = (static_cast<uint32_t>(byte0 & 0x0f) << 12) |
+         (static_cast<uint32_t>(byte1 & 0x3f) << 06) |
+         (static_cast<uint32_t>(byte2 & 0x3f));
+    return rc;
+  }
+
+  // Four utf8 bytes translate to utf16 in 'Supplementary Planes'.
+  // In Supplementary Planes Utf16 is encoded as a 'Surrogate Pair'.
+  // About utf16 you can refer to: https://zh.wikipedia.org/wiki/UTF-16
+  //
+  // utf8 four bytes: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+  const uint8_t byte3 = *data++;
+  uint32_t code;
+  code = (static_cast<uint32_t>(byte0 & 0x07) << 18) |
+         (static_cast<uint32_t>(byte1 & 0x3f) << 12) |
+         (static_cast<uint32_t>(byte2 & 0x3f) << 06) |
+         (static_cast<uint32_t>(byte3 & 0x3f));
+
+  // Convert to Surrogate Pair, use three steps:
+  code -= 0x10000;
+  uint32_t lead = (code >> 10) | 0xD800;
+  uint32_t tail = (code & 0x3FF) | 0xDC00;
+  rc = lead + (tail << 16);
+  return rc;
+}
+
+static inline bool IsAlnum(uint32_t code) {
+  if ((code >= 'a' && code <= 'z') || (code >= 'A' && code <= 'Z') || (code >= '0' && code <= '9')) {
+    return true;
+  }
+  return false;
+}
+
+static std::string MangleInternal(const std::string &s, const bool isDex) {
+  std::string output = "";
+  const char *cp = &s[0];
+  const char *end = cp + s.length();
+  while (cp < end) {
+    uint32_t code = DecodeUtf8(cp);
+    if (isDex) {
+      if (code == '(') {
+        output.append("__");
+        continue;
+      }
+      if (code == ')') {
+        break;
+      }
+    }
+
+    std::string str;
+    if (IsAlnum(code)) {
+      output.append(1, static_cast<char>(code));
+    } else if (ConvertSpeicalChar(code, str)) {
+      output.append(str);
+    } else {
+      AppendUint(output, code);
+    }
+  }
+
+  return output;
+}
+
+std::string MangleForJniDex(const std::string &s) {
+  return MangleInternal(s, true);
+}
+
+std::string MangleForJni(const std::string &s) {
+  return MangleInternal(s, false);
+}
+}
diff --git a/src/mrt/compiler-rt/src/mm_config.cpp b/src/mrt/compiler-rt/src/mm_config.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..23343e10ea39a04f5566435c7acac995302a38be
--- /dev/null
+++ b/src/mrt/compiler-rt/src/mm_config.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mm_config.h"
+
+namespace maplert {
+long MrtEnvConf(const char *envName, long defaultValue) {
+  const char *ev = getenv(envName);
+  if (ev != nullptr) {
+    char *endptr = nullptr;
+    long rv = std::strtol(ev, &endptr, 0); // support dec, oct and hex
+    if (*endptr == '\0') {
+      return rv;
+    } else {
+      return defaultValue;
+    }
+  } else {
+    return defaultValue;
+  }
+}
+}
diff --git a/src/mrt/compiler-rt/src/mm_utils.cpp b/src/mrt/compiler-rt/src/mm_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7eff08aa6d670268f7ff973544dfeea3a62350c2
--- /dev/null
+++ b/src/mrt/compiler-rt/src/mm_utils.cpp
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mm_utils.h"
+
+#include <cinttypes>
+#include <limits>
+#include <dlfcn.h>
+#include <dirent.h>
+#include <mutex>
+#include <sys/stat.h>
+
+#include "mm_config.h"
+#include "chosen.h"
+
+namespace maplert {
+namespace util {
+const uint32_t kInstructionSize = 4;
+const uint32_t kDefaultPrintStackDepth = 30;
+const uint32_t kDefaultPrintStackSkip = 2; // skip first two frames in mmutils
+
+void GetSymbolName(const void *exactPc, std::string &funcPath, std::string &funcName, Dl_info &dlinfo) {
+  LinkerLocInfo mInfo;
+  dlinfo.dli_fname = nullptr;
+  dlinfo.dli_fbase = nullptr;
+  dlinfo.dli_sname = nullptr;
+  dlinfo.dli_saddr = nullptr;
+
+  bool dladdrOk = dladdr(exactPc, &dlinfo) != 0;
+  if (dladdrOk && dlinfo.dli_sname != nullptr) {
+    funcName = dlinfo.dli_sname;
+    funcPath = dlinfo.dli_fname;
+  } else {
+    if (LinkerAPI::Instance().IsJavaText(exactPc)) {
+      (void)LinkerAPI::Instance().LocateAddress(exactPc, mInfo, true);
+    }
+
+    funcName = "unknown function";
+    funcPath = "unknown image";
+    if (!mInfo.sym.empty()) {
+      funcName = mInfo.sym;
+    }
+    if (!mInfo.path.empty()) {
+      funcPath = mInfo.path;
+    }
+  }
+}
+
+void PrintPCSymbol(const void *pc) {
+  static constexpr int byteShift = 4;
+  void *exactPc = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(pc) - byteShift);
+  // convert pc to symbol/offset in elf file
+  std::string funcName, funcPath;
+  Dl_info dlinfo;
+
+  GetSymbolName(exactPc, funcPath, funcName, dlinfo);
+
+#ifdef __ANDROID__
+  LOG(ERROR) << "PC: " << std::hex << exactPc << " " << funcPath << " (+" <<
+      reinterpret_cast<void*>(dlinfo.dli_fbase == nullptr ? 0 :
+          (reinterpret_cast<intptr_t>(exactPc) - (reinterpret_cast<intptr_t>(dlinfo.dli_fbase)))) <<
+      ") " << funcName << " (+" <<
+      reinterpret_cast<void*>(dlinfo.dli_saddr == nullptr ? 0 :
+          (reinterpret_cast<intptr_t>(exactPc) - (reinterpret_cast<intptr_t>(dlinfo.dli_saddr)))) <<
+      ")" << std::dec << maple::endl;
+#else
+  printf("PC: %p %s (+%p) %s (+%p)\n",
+         exactPc,
+         funcPath.c_str(),
+         reinterpret_cast<void*>(dlinfo.dli_fbase == nullptr ? 0 :
+             (reinterpret_cast<intptr_t>(exactPc) - (reinterpret_cast<intptr_t>(dlinfo.dli_fbase)))),
+         funcName.c_str(),
+         reinterpret_cast<void*>(dlinfo.dli_saddr == nullptr ? 0 :
+             (reinterpret_cast<intptr_t>(exactPc) - (reinterpret_cast<intptr_t>(dlinfo.dli_saddr)))));
+#endif
+}
+
+void PrintPCSymbolToLog(const void *pc, uint32_t logtype, bool printBt) {
+  void *exactPc = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(pc) - kInstructionSize);
+  // convert pc to symbol/offset in elf file
+  std::string funcName = "";
+  std::string funcPath = "";
+  Dl_info dlinfo;
+
+  GetSymbolName(exactPc, funcPath, funcName, dlinfo);
+
+  LOG2FILE(logtype) << "PC: " << std::hex << exactPc << " " << funcPath << " (+" <<
+      reinterpret_cast<void*>(dlinfo.dli_fbase == nullptr ? 0 :
+          (reinterpret_cast<intptr_t>(exactPc) - (reinterpret_cast<intptr_t>(dlinfo.dli_fbase)))) <<
+      ") " << funcName << " (+" <<
+      reinterpret_cast<void*>(dlinfo.dli_saddr == nullptr ? 0 :
+          (reinterpret_cast<intptr_t>(exactPc) - (reinterpret_cast<intptr_t>(dlinfo.dli_fbase)))) <<
+      ") " << printBt << std::dec << std::endl;
+}
+
+void PrintPCSymbolToLog(const void *pc, std::ostream &ofs, bool printBt) {
+  void *exactPc = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(pc) - kInstructionSize);
+  // convert pc to symbol/offset in elf file
+  std::string funcName, funcPath;
+  Dl_info dlinfo;
+
+  GetSymbolName(exactPc, funcPath, funcName, dlinfo);
+
+  ofs << "PC: " << std::hex << exactPc << " " << funcPath << " (+" <<
+      reinterpret_cast<void*>(dlinfo.dli_fbase == nullptr ? 0 :
+          (reinterpret_cast<intptr_t>(exactPc) - reinterpret_cast<intptr_t>(dlinfo.dli_fbase))) <<
+      ") " << funcName << " (+" <<
+      reinterpret_cast<void*>(dlinfo.dli_saddr == nullptr ? 0 :
+          (reinterpret_cast<intptr_t>(exactPc) - reinterpret_cast<intptr_t>(dlinfo.dli_saddr))) <<
+      ") " << printBt << std::dec << std::endl;
+}
+
+void PrintBacktrace() {
+  PrintBacktrace(kDefaultPrintStackDepth, -1);
+}
+
+void PrintBacktrace(int32_t logFile) {
+  PrintBacktrace(kDefaultPrintStackDepth, logFile);
+}
+
+std::mutex btmutex;
+
+void PrintBacktrace(size_t limit, int32_t logFile) {
+  std::lock_guard<std::mutex> l(btmutex);
+  const size_t hardLimit = 30;
+  std::vector<uint64_t> stackArray;
+
+  if (limit > hardLimit) {
+    limit = hardLimit;
+  }
+
+  if (logFile < 0) {
+    printf("%lu: PrintBacktrace()\n", pthread_self());
+  } else {
+    LOG2FILE(logFile) << pthread_self() << ": PrintBacktrace()" << std::endl;
+  }
+
+  MapleStack::FastRecordCurrentStackPCsByUnwind(stackArray, limit);
+  size_t size = stackArray.size();
+  // skip first two frame, record stack and print stack
+  for (size_t i = kDefaultPrintStackSkip; i < size; ++i) {
+    if (logFile < 0) {
+      PrintPCSymbol(reinterpret_cast<void*>(stackArray[i]));
+    } else {
+      PrintPCSymbolToLog(reinterpret_cast<void*>(stackArray[i]), logFile, false);
+    }
+  }
+  if (logFile < 0) {
+    fflush(stdout);
+  }
+}
+
+// [obj] addr header rc meta
+// content from meta
+const size_t kDumpWordsPerLine = 4;
+void DumpObject(address_t obj, std::ostream &ofs) {
+  MObject *mObject = reinterpret_cast<MObject*>(obj);
+  MClass *classInfo = mObject->GetClass();
+  ofs << "[obj] " << std::hex << obj << " " << GCHeader(obj) <<
+      " " << RefCount(obj) << " " << WeakRefCount(obj) << " " << classInfo <<
+      std::dec << " " << GetObjectDWordSize(*mObject) << std::endl;
+  if (VLOG_IS_ON(dumpheapsimple)) {
+    auto refFunc = [&ofs](reffield_t &field, uint64_t kind) {
+      address_t ref = RefFieldToAddress(field);
+      if (IS_HEAP_ADDR(ref)) {
+        ofs << std::hex << ref << (kind == kWeakRefBits ? " w" : (kind == kUnownedRefBits ? " u" : "")) <<
+            std::dec << std::endl;
+      }
+    };
+    ForEachRefField(obj, refFunc);
+  } else {
+    size_t word = GetObjectDWordSize(*mObject);
+    for (size_t i = 0; i < word; i += kDumpWordsPerLine) {
+      ofs << std::hex << (obj + (i * sizeof(address_t))) << ": ";
+      size_t bound = (i + kDumpWordsPerLine) < word ? (i + kDumpWordsPerLine) : word;
+      for (size_t j = i; j < bound; j++) {
+        ofs << std::hex << *reinterpret_cast<reffield_t*>(obj + (j * sizeof(address_t))) << " ";
+#ifdef USE_32BIT_REF
+        ofs << std::hex << *reinterpret_cast<reffield_t*>(obj + (j * sizeof(address_t) + sizeof(reffield_t))) << " ";
+#endif // USE_32BIT_REF
+      }
+      ofs << std::dec << std::endl;
+    }
+  }
+}
+
+// We must not fork until we're single-threaded again.
+// Wait until /proc shows we're down to just one thread.
+void WaitUntilAllThreadsStopped() {
+  // If there are only 3 itmes in /proc/selftask,
+  // we can confirm that all threads stopped except
+  // main thread. for example:
+  // $ls -a /proc/self/task
+  // . .. <main tid>
+  static constexpr int maxNumEntryOfSingleThreadProc = 3;
+  struct dirent *entryPtr = nullptr;
+  int numOfEntries;
+
+  // All background threads are stopped already. We're just waiting
+  // for their OS counterparts to finish as well. This shouldn't take
+  // much time so spinning is ok here.
+  for (;;) {
+    // Find threads by listing files in "/proc/self/task".
+    DIR *dirp = ::opendir("/proc/self/task");
+    __MRT_ASSERT(dirp != nullptr, "WaitUntilAllThreadsStopped dirp=nullptr");
+    for (numOfEntries = 0; numOfEntries <= maxNumEntryOfSingleThreadProc; ++numOfEntries) {
+      entryPtr = ::readdir(dirp);
+      if (entryPtr == nullptr) {
+        break;
+      }
+    }
+    ::closedir(dirp);
+
+    if (numOfEntries == maxNumEntryOfSingleThreadProc) {
+      return;
+    }
+
+    // Yield before try again.
+    std::this_thread::yield();
+  }
+}
+
+std::string GetLogDir() {
+  string appDir = LinkerAPI::Instance().GetAppInfo();
+  if (appDir.empty()) {
+    // must be system server
+    appDir = "/data/log/maple";
+  } else {
+    appDir = appDir + "/maple";
+  }
+  // Best effort.
+  mode_t mode = S_IRWXU;
+  if (mkdir(appDir.c_str(), mode) != 0) {
+    int myErrno = errno;
+    errno = 0;
+    if (myErrno != EEXIST) {
+      LOG(ERROR) << "Failed to create directory for GCLog." << maple::endl;
+      LOG(ERROR) << "  Directory: " << appDir << maple::endl;
+      LOG(ERROR) << "  Error code: " << strerror(myErrno) << maple::endl;
+    }
+  }
+
+  return appDir;
+}
+} // namespace util
+} // namespace maplert
diff --git a/src/mrt/compiler-rt/src/muid.cpp b/src/mrt/compiler-rt/src/muid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..93afdab671a5231801cd3b95bc98d0547da78a8a
--- /dev/null
+++ b/src/mrt/compiler-rt/src/muid.cpp
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/*
+ * We generate muid-hashcode according to the MD5 Message-Digest Algorithm here.
+ */
+#include "muid.h"
+#include <cstring>
+#include "securec.h"
+
+/*
+ * Basic MUID functions.
+ */
+#define F(x, y, z) (((x) & (y)) | ((~(x)) & (z)))
+#define G(x, y, z) (((x) & (z)) | ((y) & (~(z))))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define I(x, y, z) ((y) ^ ((x) | (~(z))))
+
+/*
+ * Muid Transformation function.
+ */
+#define TRANS(f, a, b, c, d, x, t, s) \
+    (a) += f((b), (c), (d)) + (x) + (t); \
+    (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
+    (a) += (b);
+
+/*
+ * Divide the whole input data into sevral groups with kGroupSizebit each and decode them.
+ */
+#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
+#define DECODE(n, input, output) \
+    ((output)[(n)] = \
+    (*reinterpret_cast<unsigned int*>(const_cast<unsigned char*>(&input[(n) * 4]))))
+#else
+#define DECODE(n, input, output) \
+    ((output)[(n)] = \
+    (unsigned int)input[(n) * 4] | \
+    ((unsigned int)input[(n) * 4 + 1] << 8) | \
+    ((unsigned int)input[(n) * 4 + 2] << 16) | \
+    ((unsigned int)input[(n) * 4 + 3] << 24))
+#endif
+
+/*
+ * Encode function.
+ */
+#define ENCODE(dst, src) \
+    (dst)[0] = (unsigned char)(src); \
+    (dst)[1] = (unsigned char)((src) >> 8); \
+    (dst)[2] = (unsigned char)((src) >> 16); \
+    (dst)[3] = (unsigned char)((src) >> 24);
+
+/*
+ * Body of transformation.
+ */
+static const unsigned char *MuidTransform(MuidContext &status, const unsigned char &data, uint64_t count) {
+  unsigned int a, b, c, d;
+  auto *result = &data;
+
+  while (count--) {
+    for (unsigned int i = 0; i < kBlockLength; i++) {
+      DECODE(i, result, status.block);
+    }
+
+    a = status.a;
+    b = status.b;
+    c = status.c;
+    d = status.d;
+
+    /* Round 1 */
+    TRANS(F, a, b, c, d, status.block[0], 0xd76aa478, 7)
+    TRANS(F, d, a, b, c, status.block[1], 0xe8c7b756, 12)
+    TRANS(F, c, d, a, b, status.block[2], 0x242070db, 17)
+    TRANS(F, b, c, d, a, status.block[3], 0xc1bdceee, 22)
+    TRANS(F, a, b, c, d, status.block[4], 0xf57c0faf, 7)
+    TRANS(F, d, a, b, c, status.block[5], 0x4787c62a, 12)
+    TRANS(F, c, d, a, b, status.block[6], 0xa8304613, 17)
+    TRANS(F, b, c, d, a, status.block[7], 0xfd469501, 22)
+    TRANS(F, a, b, c, d, status.block[8], 0x698098d8, 7)
+    TRANS(F, d, a, b, c, status.block[9], 0x8b44f7af, 12)
+    TRANS(F, c, d, a, b, status.block[10], 0xffff5bb1, 17)
+    TRANS(F, b, c, d, a, status.block[11], 0x895cd7be, 22)
+    TRANS(F, a, b, c, d, status.block[12], 0x6b901122, 7)
+    TRANS(F, d, a, b, c, status.block[13], 0xfd987193, 12)
+    TRANS(F, c, d, a, b, status.block[14], 0xa679438e, 17)
+    TRANS(F, b, c, d, a, status.block[15], 0x49b40821, 22)
+
+    /* Round 2 */
+    TRANS(G, a, b, c, d, status.block[1], 0xf61e2562, 5)
+    TRANS(G, d, a, b, c, status.block[6], 0xc040b340, 9)
+    TRANS(G, c, d, a, b, status.block[11], 0x265e5a51, 14)
+    TRANS(G, b, c, d, a, status.block[0], 0xe9b6c7aa, 20)
+    TRANS(G, a, b, c, d, status.block[5], 0xd62f105d, 5)
+    TRANS(G, d, a, b, c, status.block[10], 0x02441453, 9)
+    TRANS(G, c, d, a, b, status.block[15], 0xd8a1e681, 14)
+    TRANS(G, b, c, d, a, status.block[4], 0xe7d3fbc8, 20)
+    TRANS(G, a, b, c, d, status.block[9], 0x21e1cde6, 5)
+    TRANS(G, d, a, b, c, status.block[14], 0xc33707d6, 9)
+    TRANS(G, c, d, a, b, status.block[3], 0xf4d50d87, 14)
+    TRANS(G, b, c, d, a, status.block[8], 0x455a14ed, 20)
+    TRANS(G, a, b, c, d, status.block[13], 0xa9e3e905, 5)
+    TRANS(G, d, a, b, c, status.block[2], 0xfcefa3f8, 9)
+    TRANS(G, c, d, a, b, status.block[7], 0x676f02d9, 14)
+    TRANS(G, b, c, d, a, status.block[12], 0x8d2a4c8a, 20)
+
+    /* Round 3 */
+    TRANS(H, a, b, c, d, status.block[5], 0xfffa3942, 4)
+    TRANS(H, d, a, b, c, status.block[8], 0x8771f681, 11)
+    TRANS(H, c, d, a, b, status.block[11], 0x6d9d6122, 16)
+    TRANS(H, b, c, d, a, status.block[14], 0xfde5380c, 23)
+    TRANS(H, a, b, c, d, status.block[1], 0xa4beea44, 4)
+    TRANS(H, d, a, b, c, status.block[4], 0x4bdecfa9, 11)
+    TRANS(H, c, d, a, b, status.block[7], 0xf6bb4b60, 16)
+    TRANS(H, b, c, d, a, status.block[10], 0xbebfbc70, 23)
+    TRANS(H, a, b, c, d, status.block[13], 0x289b7ec6, 4)
+    TRANS(H, d, a, b, c, status.block[0], 0xeaa127fa, 11)
+    TRANS(H, c, d, a, b, status.block[3], 0xd4ef3085, 16)
+    TRANS(H, b, c, d, a, status.block[6], 0x04881d05, 23)
+    TRANS(H, a, b, c, d, status.block[9], 0xd9d4d039, 4)
+    TRANS(H, d, a, b, c, status.block[12], 0xe6db99e5, 11)
+    TRANS(H, c, d, a, b, status.block[15], 0x1fa27cf8, 16)
+    TRANS(H, b, c, d, a, status.block[2], 0xc4ac5665, 23)
+
+    /* Round 4 */
+    TRANS(I, a, b, c, d, status.block[0], 0xf4292244, 6)
+    TRANS(I, d, a, b, c, status.block[7], 0x432aff97, 10)
+    TRANS(I, c, d, a, b, status.block[14], 0xab9423a7, 15)
+    TRANS(I, b, c, d, a, status.block[5], 0xfc93a039, 21)
+    TRANS(I, a, b, c, d, status.block[12], 0x655b59c3, 6)
+    TRANS(I, d, a, b, c, status.block[3], 0x8f0ccc92, 10)
+    TRANS(I, c, d, a, b, status.block[10], 0xffeff47d, 15)
+    TRANS(I, b, c, d, a, status.block[1], 0x85845dd1, 21)
+    TRANS(I, a, b, c, d, status.block[8], 0x6fa87e4f, 6)
+    TRANS(I, d, a, b, c, status.block[15], 0xfe2ce6e0, 10)
+    TRANS(I, c, d, a, b, status.block[6], 0xa3014314, 15)
+    TRANS(I, b, c, d, a, status.block[13], 0x4e0811a1, 21)
+    TRANS(I, a, b, c, d, status.block[4], 0xf7537e82, 6)
+    TRANS(I, d, a, b, c, status.block[11], 0xbd3af235, 10)
+    TRANS(I, c, d, a, b, status.block[2], 0x2ad7d2bb, 15)
+    TRANS(I, b, c, d, a, status.block[9], 0xeb86d391, 21)
+
+    status.a += a;
+    status.b += b;
+    status.c += c;
+    status.d += d;
+
+    result += kGroupSize;
+  }
+
+  return result;
+}
+
+/*
+ * Initialize constants here.
+ */
+void MuidInit(MuidContext &status) {
+  status.a = 0x67452301;
+  status.b = 0xefcdab89;
+  status.c = 0x98badcfe;
+  status.d = 0x10325476;
+
+  status.count[0] = 0;
+  status.count[1] = 0;
+}
+
+/*
+ * Decoding part(byte to unsigned int).
+ */
+void MuidDecode(MuidContext &status, const unsigned char &data, size_t size) {
+  unsigned int tmp = status.count[0];
+  status.count[0] = (tmp + size) & 0x1fffffff;
+  if (status.count[0] < tmp) {
+    status.count[1]++;
+  }
+  uint32_t higherBits = static_cast<uint64_t>(size) >> kShiftAmount;
+  status.count[1] += higherBits * kByteLength;
+
+  size_t idx = tmp & kBitMask;
+  size_t remain = kGroupSize - idx;
+  auto *position = &data;
+
+  if (idx != 0) {
+    if (size < remain) {
+      if (memcpy_s(&status.buffer[idx], kGroupSize, &data, size) != EOK) {
+        return;
+      }
+      return;
+    }
+
+    if (memcpy_s(&status.buffer[idx], kGroupSize, &data, remain) != EOK) {
+      return;
+    }
+    (void)MuidTransform(status, *status.buffer, 1);
+
+    size -= remain;
+    position += remain;
+  }
+
+  if (size >= kGroupSize) {
+    position = MuidTransform(status, *position, size / kGroupSize);
+    size &= kBitMask;
+  }
+
+  if (memcpy_s(status.buffer, kGroupSize, position, size) != EOK) {
+    return;
+  }
+}
+
+/*
+ * Encoding part(unsigned int to byte).
+ */
+template<typename T>
+void FullEncode(T &result, MuidContext &status) {
+  size_t idx = status.count[0] & kBitMask;
+  status.buffer[idx++] = 0x80;
+
+  size_t remain = kGroupSize - idx;
+
+  if (remain < kByteLength) {
+    if (memset_s(&status.buffer[idx], kGroupSize, 0, remain) != EOK) {
+      return;
+    }
+    (void)MuidTransform(status, *status.buffer, 1);
+    idx = 0;
+    remain = kGroupSize;
+  }
+
+  if (memset_s(&status.buffer[idx], kGroupSize, 0, remain - kByteLength) != EOK) {
+    return;
+  }
+  status.count[0] *= kByteLength;
+  const unsigned int indexOfLastEight = 56;
+  const unsigned int indexOfLastFour = 60;
+  ENCODE(&status.buffer[indexOfLastEight], status.count[0])
+  ENCODE(&status.buffer[indexOfLastFour], status.count[1])
+
+  (void)MuidTransform(status, *status.buffer, 1);
+  ENCODE(&result[0], status.a)
+  ENCODE(&result[4], status.b)
+}
+
+void MuidEncode(unsigned char (&result)[kDigestShortHashLength], MuidContext &status) {
+  FullEncode(result, status);
+  if (memset_s(&status, sizeof(status), 0, sizeof(status)) != EOK) {
+    return;
+  }
+}
+
+void MuidEncode(unsigned char (&result)[kDigestHashLength], MuidContext &status, bool use64Bit) {
+  FullEncode(result, status);
+  if (!use64Bit) {
+    ENCODE(&result[8], status.c)
+    ENCODE(&result[12], status.d)
+  }
+  if (memset_s(&status, sizeof(status), 0, sizeof(status)) != EOK) {
+    return;
+  }
+}
+
+/*
+ * The entrance functions.
+ */
+void GetMUIDHash(const unsigned char &data, size_t size, MUID &muid) {
+  MuidContext status;
+  MuidInit(status);
+  MuidDecode(status, data, size);
+  MuidEncode(muid.data.bytes, status);
+}
+
+DigestHash GetDigestHash(const unsigned char &bytes, uint32_t len) {
+  DigestHash digestHash;
+  MuidContext digestContext;
+
+  digestHash.data.first = 0;
+  digestHash.data.second = 0;
+
+  MuidInit(digestContext);
+  MuidDecode(digestContext, bytes, len);
+  MuidEncode(digestHash.bytes, digestContext);
+
+  return digestHash;
+}
+
+MUID GetMUID(const std::string &symbolName, bool forSystem) {
+  MUID muid;
+  auto *data = reinterpret_cast<const unsigned char*>(symbolName.c_str());
+  GetMUIDHash(*data, symbolName.length(), muid);
+  if (forSystem) {
+    muid.SetSystemNameSpace();
+  } else {
+    muid.SetApkNameSpace();
+  }
+  return muid;
+}
\ No newline at end of file
diff --git a/src/mrt/compiler-rt/src/mutator_list.cpp b/src/mrt/compiler-rt/src/mutator_list.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..42d5d6a1b0a9c523140bb020827b3daf76c48d12
--- /dev/null
+++ b/src/mrt/compiler-rt/src/mutator_list.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mutator_list.h"
+
+namespace maplert {
+// The singleton instance of MutatorList.
+ImmortalWrapper<MutatorList> MutatorList::instance;
+
+void MutatorList::DebugShowCurrentMutators() {
+  (void)fprintf(stderr, "Showing current mutators. size=%zu", mutatorList.size());
+  for (auto &mutator : mutatorList) {
+    mutator->DebugShow();
+  }
+}
+}
diff --git a/src/mrt/compiler-rt/src/namemangler.cpp b/src/mrt/compiler-rt/src/namemangler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..425db542040aa0abeb004312331b18773bbf9814
--- /dev/null
+++ b/src/mrt/compiler-rt/src/namemangler.cpp
@@ -0,0 +1,626 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "namemangler.h"
+#include <regex>
+#include <cassert>
+#include <map>
+
+namespace namemangler {
+#ifdef __MRT_DEBUG
+#define ASSERT(f) assert(f)
+#else
+#define ASSERT(f) ((void)0)
+#endif
+
+const int kLocalCodebufSize = 1024;
+const int kMaxCodecbufSize = (1 << 16); // Java spec support a max name length of 64K.
+
+#define GETHEXCHAR(n) static_cast<char>((n) < 10 ? (n) + '0' : (n) - 10 + 'a')
+#define GETHEXCHARU(n) static_cast<char>((n) < 10 ? (n) + '0' : (n) - 10 + 'A')
+
+bool doCompression = false;
+
+// Store a mapping between full string and its compressed version
+// More frequent and specific strings go before  general ones,
+// e.g. Ljava_2Flang_2FObject_3B goes before Ljava_2Flang_2F
+//
+using StringMap = std::map<const std::string, const std::string>;
+
+const StringMap kInternalMangleTable = {
+    { "Ljava_2Flang_2FObject_3B", "L0_3B" },
+    { "Ljava_2Flang_2FClass_3B",  "L1_3B" },
+    { "Ljava_2Flang_2FString_3B", "L2_3B" }
+};
+
+// This mapping is mainly used for compressing annotation strings
+const StringMap kOriginalMangleTable = {
+    { "Ljava/lang/Object", "L0" },
+    { "Ljava/lang/Class",  "L1" },
+    { "Ljava/lang/String", "L2" }
+};
+
+// The returned buffer needs to be explicitly freed
+static inline char *AllocCodecBuf(size_t maxLen) {
+  if (maxLen == 0) {
+    return nullptr;
+  }
+  // each char may have 2 more char, so give out the max space buffer
+  return reinterpret_cast<char*>(malloc((maxLen <= kLocalCodebufSize) ? 3 * maxLen : 3 * kMaxCodecbufSize));
+}
+
+static inline void FreeCodecBuf(char *buf) {
+  free(buf);
+}
+
+static std::string CompressName(std::string &name, const StringMap &mapping = kInternalMangleTable) {
+  for (auto &entry : mapping) {
+    if (name.find(entry.first) != name.npos) {
+      name = std::regex_replace(name, std::regex(entry.first), entry.second);
+    }
+  }
+  return name;
+}
+
+static std::string DecompressName(std::string &name, const StringMap &mapping = kInternalMangleTable) {
+  for (auto &entry : mapping) {
+    if (name.find(entry.second) != name.npos) {
+      name = std::regex_replace(name, std::regex(entry.second), entry.first);
+    }
+  }
+  return name;
+}
+
+std::string GetInternalNameLiteral(std::string name) {
+  return (doCompression ? CompressName(name) : name);
+}
+
+std::string GetOriginalNameLiteral(std::string name) {
+  return (doCompression ? CompressName(name, kOriginalMangleTable) : name);
+}
+
+std::string EncodeName(const std::string &name) {
+  // name is guaranteed to be null-terminated
+  size_t nameLen = name.length();
+  nameLen = nameLen > kMaxCodecbufSize ? kMaxCodecbufSize : nameLen;
+  char *buf = AllocCodecBuf(nameLen);
+  if (buf == nullptr) {
+    return std::string(name);
+  }
+
+  size_t pos = 0;
+  size_t i = 0;
+  std::string str(name);
+  std::u16string str16;
+  while (i < nameLen) {
+    unsigned char c = name[i];
+    if (c == '_') {
+      buf[pos++] = '_';
+      buf[pos++] = '_';
+    } else if (c == '[') {
+      buf[pos++] = 'A';
+    } else if (isalnum(c)) {
+      buf[pos++] = c;
+    } else if (c <= 0x7F) {
+      // _XX: '_' followed by ascii code in hex
+      if (c == '.') {
+        c = '/'; // use / in package name
+      }
+      buf[pos++] = '_';
+      unsigned char n = c >> 4; // get the high 4 bit and calculate
+      buf[pos++] = GETHEXCHARU(n);
+      n = c - static_cast<unsigned char>(n << 4); // revert
+      buf[pos++] = GETHEXCHARU(n);
+    } else {
+      str16.clear();
+      // process one 16-bit char at a time
+      unsigned int n = UTF8ToUTF16(str16, str.substr(i), 1, false);
+      buf[pos++] = '_';
+      if ((n >> 16) == 1) {
+        unsigned short m = str16[0];
+        buf[pos++] = 'u';
+        buf[pos++] = GETHEXCHAR((m & 0xF000) >> 12);
+        buf[pos++] = GETHEXCHAR((m & 0x0F00) >> 8);
+        buf[pos++] = GETHEXCHAR((m & 0x00F0) >> 4);
+        buf[pos++] = GETHEXCHAR(m & 0x000F);
+      } else {
+        unsigned short m = str16[0];
+        buf[pos++] = 'U';
+        buf[pos++] = GETHEXCHAR((m & 0xF000) >> 12);
+        buf[pos++] = GETHEXCHAR((m & 0x0F00) >> 8);
+        buf[pos++] = GETHEXCHAR((m & 0x00F0) >> 4);
+        buf[pos++] = GETHEXCHAR(m & 0x000F);
+        m = str16[1];
+        buf[pos++] = GETHEXCHAR((m & 0xF000) >> 12);
+        buf[pos++] = GETHEXCHAR((m & 0x0F00) >> 8);
+        buf[pos++] = GETHEXCHAR((m & 0x00F0) >> 4);
+        buf[pos++] = GETHEXCHAR(m & 0x000F);
+      }
+      i += int32_t(n & 0xFFFF) - 1;
+    }
+    i++;
+  }
+
+  buf[pos] = '\0';
+  std::string newName = std::string(buf, pos);
+  FreeCodecBuf(buf);
+  if (doCompression) {
+    newName = CompressName(newName);
+  }
+  return newName;
+}
+
+static inline bool UpdatePrimType(bool primType, int splitNo, uint32_t ch) {
+  if (ch == 'L') {
+    return false;
+  }
+
+  if (((ch == ';') || (ch == '(') || (ch == ')')) && (splitNo > 1)) {
+    return true;
+  }
+
+  return primType;
+}
+
+const int kNumLimit = 10;
+const int kCodeOffset3 = 12;
+const int kCodeOffset2 = 8;
+const int kCodeOffset = 4;
+const int kJavaStrLength = 5;
+
+std::string DecodeName(const std::string &name) {
+  if (name.find(';') != std::string::npos) { // no need Decoding a non-encoded string
+    return name;
+  }
+  std::string decompressedName;
+  const char *namePtr = nullptr;
+  size_t nameLen;
+
+  if (doCompression) {
+    decompressedName = name;
+    decompressedName = DecompressName(decompressedName);
+    namePtr = decompressedName.c_str();
+    nameLen = decompressedName.length();
+  }
+  else {
+    namePtr = name.c_str();
+    nameLen = name.length();
+  }
+
+  // Demangled name is supposed to be shorter. No buffer overflow issue here.
+  std::string newName(nameLen, '\0');
+
+  bool primType = true;
+  int splitNo = 0; // split: class 0 | method 1 | signature 2
+  size_t pos = 0;
+  std::string str;
+  std::u16string str16;
+  for (size_t i = 0; i < nameLen;) {
+    unsigned char c = namePtr[i++];
+    if (c == '_') { // _XX: '_' followed by ascii code in hex
+      if (i >= nameLen) {
+        break;
+      }
+      if (namePtr[i] == '_') {
+        newName[pos++] = namePtr[i++];
+      } else if (namePtr[i] == 'u') {
+        str.clear();
+        str16.clear();
+        i++;
+        c = namePtr[i++];
+        uint8_t b1 = (c <= '9') ? c - '0' : c - 'a' + kNumLimit;
+        c = namePtr[i++];
+        uint8_t b2 = (c <= '9') ? c - '0' : c - 'a' + kNumLimit;
+        c = namePtr[i++];
+        uint8_t b3 = (c <= '9') ? c - '0' : c - 'a' + kNumLimit;
+        c = namePtr[i++];
+        uint8_t b4 = (c <= '9') ? c - '0' : c - 'a' + kNumLimit;
+        uint32_t codepoint = (b1 << kCodeOffset3) | (b2 << kCodeOffset2) | (b3 << kCodeOffset) | b4;
+        str16 += (char16_t)codepoint;
+        unsigned int n = UTF16ToUTF8(str, str16, 1, false);
+        if ((n >> 16) == 2) { // the count of str equal 2 to 4, use array to save the utf8 results
+          newName[pos++] = str[0];
+          newName[pos++] = str[1];
+        } else if ((n >> 16) == 3) {
+          newName[pos++] = str[0];
+          newName[pos++] = str[1];
+          newName[pos++] = str[2];
+        } else if ((n >> 16) == 4) {
+          newName[pos++] = str[0];
+          newName[pos++] = str[1];
+          newName[pos++] = str[2];
+          newName[pos++] = str[3];
+        }
+      } else {
+        c = namePtr[i++];
+        unsigned int v = (c <= '9') ? c - '0' : c - 'A' + kNumLimit;
+        unsigned int asc = v << kCodeOffset;
+        if (i >= nameLen) {
+          break;
+        }
+        c = namePtr[i++];
+        v = (c <= '9') ? c - '0' : c - 'A' + kNumLimit;
+        asc += v;
+
+        newName[pos++] = static_cast<char>(asc);
+
+        if (asc == '|') {
+          splitNo++;
+        }
+
+        primType = UpdatePrimType(primType, splitNo, asc);
+      }
+    } else {
+      if (splitNo < 2) { // split: class 0 | method 1 | signature 2
+        newName[pos++] = c;
+        continue;
+      }
+
+      primType = UpdatePrimType(primType, splitNo, c);
+      if (primType) {
+        newName[pos++] = (c == 'A') ? '[' : c;
+      } else {
+        newName[pos++] = c;
+      }
+    }
+  }
+
+  newName.resize(pos);
+  return newName;
+}
+
+// input: maple name
+// output: Ljava/lang/Object;  [Ljava/lang/Object;
+void DecodeMapleNameToJavaDescriptor(const std::string &nameIn, std::string &nameOut) {
+  nameOut = DecodeName(nameIn);
+  if (nameOut[0] == 'A') {
+    int i = 0;
+    while (nameOut[i] == 'A') {
+      nameOut[i++] = '[';
+    }
+  }
+}
+
+// convert maple name to java name
+// http://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/design.html#resolving_native_method_names
+std::string NativeJavaName(const std::string &name, bool overLoaded) {
+  // Decompress name first because the generated native function name needs
+  // to follow certain spec, not something maple can control.
+  std::string decompressedName(name);
+  if (doCompression) {
+    decompressedName = DecompressName(decompressedName);
+  }
+
+  unsigned int nameLen = static_cast<unsigned int>(decompressedName.length()) + kJavaStrLength;
+  std::string newName = "Java_";
+  unsigned int i = 0;
+
+  // leading A's are array
+  while (i < nameLen && name[i] == 'A') {
+    newName += "_3";
+    i++;
+  }
+
+  bool isProto = false; // class names in prototype have 'L' and ';'
+  bool isFuncname = false;
+  bool isTypename = false;
+  while (i < nameLen) {
+    char c = decompressedName[i];
+    if (c == '_') {
+      i++;
+      // UTF16 unicode
+      if (decompressedName[i] == 'u') {
+        newName += "_0";
+        i++;
+      } else if (decompressedName[i] == '_') {
+        newName += "_1";
+        i++;
+      } else {
+        // _XX: '_' followed by ascii code in hex
+        c = decompressedName[i++];
+        unsigned char v = (c <= '9') ? c - '0' : c - 'A' + kNumLimit;
+        unsigned char asc = v << kCodeOffset;
+        c = decompressedName[i++];
+        v = (c <= '9') ? c - '0' : c - 'A' + kNumLimit;
+        asc += v;
+        if (asc == '/') {
+          newName += "_";
+        } else if (asc == '|' && !isFuncname) {
+          newName += "_";
+          isFuncname = true;
+        } else if (asc == '|' && isFuncname) {
+          if (!overLoaded) {
+            break;
+          }
+          newName += "_";
+          isFuncname = false;
+        } else if (asc == '(') {
+          newName += "_";
+          isProto = true;
+        } else if (asc == ')') {
+          break;
+        } else if (asc == ';' && !isFuncname) {
+          if (isProto) {
+            newName += "_2";
+          }
+          isTypename = false;
+        } else if (asc == '$') {
+          newName += "_00024";
+        } else if (asc == '-') {
+          newName += "_0002d";
+        } else {
+          printf("name = %s\n", decompressedName.c_str());
+          printf("c = %c\n", asc);
+          ASSERT(false && "more cases in NativeJavaName");
+        }
+      }
+    } else {
+      if (c == 'L' && !isFuncname && !isTypename) {
+        if (isProto) {
+          newName += c;
+        }
+        isTypename = true;
+        i++;
+      } else if (c == 'A' && !isTypename && !isFuncname) {
+        while (name[i] == 'A') {
+          newName += "_3";
+          i++;
+        }
+      } else {
+        newName += c;
+        i++;
+      }
+    }
+  }
+  return newName;
+}
+
+static uint16_t ChangeEndian16(uint16_t u16) {
+  return ((u16 & 0xFF00) >> kCodeOffset2) | ((u16 & 0xFF) << kCodeOffset2);
+}
+
+/* UTF8
+ * U+0000 - U+007F   0xxxxxxx
+ * U+0080 - U+07FF   110xxxxx 10xxxxxx
+ * U+0800 - U+FFFF   1110xxxx 10xxxxxx 10xxxxxx
+ * U+10000- U+10FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ *
+ * UTF16
+ * U+0000 - U+D7FF   codePoint
+ * U+E000 - U+FFFF   codePoint
+ * U+10000- U+10FFFF XXXX YYYY
+ *   code = codePoint - 0x010000, ie, 20-bit number in the range 0x000000..0x0FFFFF
+ *   XXXX: top 10 bits of code + 0xD800: 0xD800..0xDBFF
+ *   YYYY: low 10 bits of code + 0xDC00: 0xDC00..0xDFFF
+ *
+ * convert upto num UTF8 elements
+ * return two 16-bit values: return_number_of_elements | consumed_input_number_of_elements
+ */
+const int kCodepointOffset1 = 6; // U+0080 - U+07FF   110xxxxx 10xxxxxx
+const int kCodepointOffset2 = 12; // U+0800 - U+FFFF   1110xxxx 10xxxxxx 10xxxxxx
+const int kCodepointOffset3 = 18; // U+10000- U+10FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+const int kCountOffset = 16;
+const int kCodeAfterMinusOffset = 10; // codePoint equals itself minus 0x10000
+
+unsigned UTF16ToUTF8(std::string &str, const std::u16string &str16, unsigned short num, bool isBigEndian) {
+  uint32_t codePoint = 0;
+  uint32_t i = 0;
+  unsigned short count = 0;
+  unsigned short retNum = 0;
+  while (i < str16.length()) {
+    if (isBigEndian || num == 1) {
+      codePoint = str16[i++];
+    } else {
+      codePoint = ChangeEndian16(str16[i++]);
+    }
+    if (codePoint > 0xFFFF) {
+      codePoint &= 0x3FF;
+      codePoint <<= kNumLimit;
+      if (isBigEndian) {
+        codePoint += str16[i++] & 0x3FF;
+      } else {
+        codePoint += ChangeEndian16(str16[i++]) & 0x3FF;
+      }
+    }
+    if (codePoint <= 0x7F) {
+      str += static_cast<char>(codePoint);
+      retNum += 1; // one UTF8 char
+    } else if (codePoint <= 0x7FF) {
+      str += static_cast<char>(0xC0 + (codePoint >> kCodepointOffset1));
+      str += static_cast<char>(0x80 + (codePoint & 0x3F));
+      retNum += 2; // two UTF8 chars
+    } else if (codePoint <= 0xFFFF) {
+      str += static_cast<char>(0xE0 + ((codePoint >> kCodepointOffset2) & 0xF));
+      str += static_cast<char>(0x80 + ((codePoint >> kCodepointOffset1) & 0x3F));
+      str += static_cast<char>(0x80 + (codePoint & 0x3F));
+      retNum += 3; // three UTF8 chars
+    } else {
+      str += static_cast<char>(0xF0 + ((codePoint >> kCodepointOffset3) & 0x7));
+      str += static_cast<char>(0x80 + ((codePoint >> kCodepointOffset2) & 0x3F));
+      str += static_cast<char>(0x80 + ((codePoint >> kCodepointOffset1) & 0x3F));
+      str += static_cast<char>(0x80 + (codePoint & 0x3F));
+      retNum += 4; // four UTF8 chars
+    }
+    count++;
+    if (num == count) {
+      return ((static_cast<unsigned>(retNum)) << kCountOffset) | static_cast<unsigned>(i);
+    }
+  }
+  return i;
+}
+
+bool NeedConvertUTF16(const std::string &str8) {
+  uint32_t a = 0;
+  size_t i = 0;
+  size_t size = str8.length();
+  while (i < size) {
+    a = static_cast<uint8_t>(str8[i++]);
+    constexpr uint8_t maxValidAscii = 0x7F;
+    if (a > maxValidAscii) {
+      return true;
+    }
+  }
+  return false;
+}
+
+uint32_t GetCodePoint(const std::string &str8, uint32_t &i) {
+  uint32_t b;
+  uint32_t c;
+  uint32_t d;
+  uint32_t codePoint = 0;
+  uint32_t a = static_cast<uint8_t>(str8[i++]);
+  if (a <= 0x7F) { // 0...
+    codePoint = a;
+  } else if (a >= 0xF0) { // 11110...
+    b = str8[i++];
+    c = str8[i++];
+    d = str8[i++];
+    codePoint = ((a & 0x7) << kCodepointOffset3) | ((b & 0x3F) << kCodepointOffset2) |
+                ((c & 0x3F) << kCodepointOffset1) | (d & 0x3F);
+  } else if (a >= 0xE0) { // 1110...
+    b = str8[i++];
+    c = str8[i++];
+    codePoint = ((a & 0xF) << kCodepointOffset2) | ((b & 0x3F) << kCodepointOffset1) | (c & 0x3F);
+  } else if (a >= 0xC0) { // 110...
+    b = str8[i++];
+    codePoint = ((a & 0x1F) << kCodepointOffset1) | (b & 0x3F);
+  } else {
+    ASSERT(false && "invalid UTF-8");
+  }
+  return codePoint;
+}
+
+// convert upto num UTF16 elements
+// two 16-bit values: return_number_of_elements | consumed_input_number_of_elements
+unsigned UTF8ToUTF16(std::u16string &str16, const std::string &str8, unsigned short num, bool isBigEndian) {
+  uint32_t i = 0;
+  unsigned short count = 0;
+  unsigned short retNum = 0;
+  while (i < str8.length()) {
+    uint32_t codePoint = GetCodePoint(str8, i);
+    if (codePoint <= 0xFFFF) {
+      if (isBigEndian || num == 1) {
+        str16 += static_cast<char16_t>(codePoint);
+      } else {
+        str16 += static_cast<char16_t>(ChangeEndian16(static_cast<uint16_t>(codePoint)));
+      }
+      retNum += 1; // one utf16
+    } else {
+      codePoint -= 0x10000;
+      if (isBigEndian || num == 1) {
+        str16 += static_cast<char16_t>((codePoint >> kCodeAfterMinusOffset) | 0xD800);
+        str16 += static_cast<char16_t>((codePoint & 0x3FF) | 0xDC00);
+      } else {
+        str16 += static_cast<char16_t>(
+            ChangeEndian16(static_cast<uint16_t>((codePoint >> kCodeAfterMinusOffset) | 0xD800)));
+        str16 += static_cast<char16_t>(ChangeEndian16((codePoint & 0x3FF) | 0xDC00));
+      }
+      retNum += 2; // two utf16
+    }
+    count++;
+    // only convert num elmements
+    if (num == count) {
+      return (static_cast<char16_t>(retNum) << kCountOffset) | static_cast<char16_t>(i);
+    }
+  }
+  return i;
+}
+
+const int kGreybackOffset = 7;
+void GetUnsignedLeb128Encode(std::vector<uint8_t> &dest, uint32_t value) {
+  bool done = false;
+  do {
+    uint8_t byte = value & 0x7f;
+    value >>= kGreybackOffset;
+    done = (value == 0);
+    if (!done) {
+      byte |= 0x80;
+    }
+    dest.push_back(byte);
+  } while (!done);
+}
+
+uint32_t GetUnsignedLeb128Decode(const uint8_t **data) {
+  ASSERT(data != nullptr && "data in GetUnsignedLeb128Decode() is nullptr");
+  const uint8_t *ptr = *data;
+  uint32_t result = 0;
+  int shift = 0;
+  uint8_t byte = 0;
+  while (true) {
+    byte = *(ptr++);
+    result |= (byte & 0x7f) << shift;
+    if ((byte & 0x80) == 0) {
+      break;
+    }
+    shift += kGreybackOffset;
+  }
+  *data = ptr;
+  return result;
+}
+
+uint64_t GetLEB128Encode(int64_t val, bool isUnsigned) {
+  uint64_t res = 0;
+  uint8_t byte = 0;
+  uint8_t count = 0;
+  bool done = false;
+  do {
+    byte = static_cast<uint64_t>(val) & 0x7f;
+    val >>= kGreybackOffset; // intended signed shift: block codedex here
+    done = (isUnsigned ? val == 0 : (val == 0 || val == -1));
+    if (!done) {
+      byte |= 0x80;
+    }
+    res |= (static_cast<uint64_t>(byte) << (count++ << 3)); // each byte need 8 bit
+  } while (!done);
+  return res;
+}
+
+uint64_t GetUleb128Encode(uint64_t val) {
+  return GetLEB128Encode(int64_t(val), true);
+}
+
+uint64_t GetSleb128Encode(int64_t val) {
+  return GetLEB128Encode(val, false);
+}
+
+uint64_t GetUleb128Decode(uint64_t val) {
+  return val;
+}
+
+int64_t GetSleb128Decode(uint64_t val) {
+  return val;
+}
+
+size_t GetUleb128Size(uint64_t v) {
+  ASSERT(v && "if v == 0, __builtin_clzll(v) is not defined");
+  size_t clz = static_cast<size_t>(__builtin_clzll(v));
+  // num of 7-bit groups
+  return size_t((64 - clz + 6) / 7);
+}
+
+size_t GetSleb128Size(int32_t v) {
+  size_t size = 0;
+  int rem = v >> kGreybackOffset;
+  bool hasMore = true;
+  int end = ((v >= 0) ? 0 : -1);
+
+  while (hasMore) {
+    hasMore = (rem != end) || ((rem & 1) != ((v >> 6) & 1)); // judege whether has More valid rem
+    size++;
+    v = rem;
+    rem >>= kGreybackOffset; // intended signed shift: block codedex here
+  }
+  return size;
+}
+} // namespace namemangler
diff --git a/src/mrt/compiler-rt/src/panic.cpp b/src/mrt/compiler-rt/src/panic.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac0d834820ac220a3fb68420cdbd80a378f364d9
--- /dev/null
+++ b/src/mrt/compiler-rt/src/panic.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "panic.h"
+
+asm("    .text\n"
+    "    .align 2\n"
+    "    .globl abort_saferegister\n"
+    "    .type  abort_saferegister, %function\n"
+    "abort_saferegister:\n"
+#if defined(__aarch64__)
+    "    brk #1\n"
+    "    ret\n"
+#endif
+    "    .size    abort_saferegister, .-abort_saferegister");
+
+namespace maplert {
+void MRT_Panic() {
+  abort();
+}
+
+#if __MRT_DEBUG
+void __MRT_AssertBreakPoint() {
+  // hook for debug
+}
+#endif
+}
diff --git a/src/mrt/compiler-rt/src/profile.cpp b/src/mrt/compiler-rt/src/profile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..915f92d7d2055b15392dc3e54bd1d3d22a4deb2d
--- /dev/null
+++ b/src/mrt/compiler-rt/src/profile.cpp
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "profile.h"
+
+#include <cstddef>
+#include <vector>
+#include <map>
+#include <iterator>
+#include <iostream>
+#include <iomanip>
+
+#include "mm_config.h"
+#include "cpphelper.h"
+#include "yieldpoint.h"
+#include "chosen.h"
+#include "collector/stats.h"
+#include "collector/native_gc.h"
+#include "mstring_inline.h"
+
+namespace maplert {
+struct InstanceInfo {
+  size_t bytes;
+  size_t count;
+  size_t size;
+  std::string name;
+
+  InstanceInfo() {
+    bytes = 0;
+    count = 0;
+    size = 0;
+  }
+};
+
+struct FuncInfo {
+  uint32_t enterCount;
+  std::string soname;
+  std::string funcName;
+  uint64_t funcaddr;
+  explicit FuncInfo(std::string sonamein, std::string funcname, uint64_t faddr) {
+    soname = std::move(sonamein);
+    funcName = std::move(funcname);
+    funcaddr = std::move(faddr);
+    enterCount = 1;
+  }
+};
+
+static std::unordered_map<uint64_t, FuncInfo*> recordFunc;
+static std::mutex recordMtx;
+
+static std::unordered_map<address_t*, const std::string> recordStaticField;
+static std::mutex recordStaticFieldMtx;
+
+void DumpRCAndGCPerformanceInfo(std::ostream &os) {
+  stats::GCStats &curStats = *(stats::gcStats);
+
+  os << "Registered native bytes allocated: " << NativeGCStats::Instance().GetNativeBytes() << std::endl;
+
+  os << "Maximum stop-the-world time:\t" << curStats.MaxSTWNanos() << std::endl;
+  os << "GC triggered:\t" << curStats.NumGCTriggered() << std::endl;
+  os << "Average memory leak:\t" << curStats.AverageMemoryLeak() << std::endl;
+  os << "Total memory leak:\t" << curStats.TotalMemoryLeak() << std::endl;
+  os << "Number of heap allocation anomalies:\t" << curStats.NumAllocAnomalies() << std::endl;
+  os << "Number of RC anomalies:\t" << curStats.NumRCAnomalies() << std::endl;
+  os << "Total string num in intern pool:\t" << ConstStringPoolNum(false) << std::endl;
+  os << "Total string size in intern pool:\t" << ConstStringPoolSize(false) << std::endl;
+  os << "Total string num in literal pool:\t" << ConstStringPoolNum(true) << std::endl;
+  os << "Total string size in literal pool:\t" << ConstStringPoolSize(true) << std::endl;
+
+  size_t totalObjBytes = 0;
+
+  // klass -> statistics map.
+  std::map<MClass*, InstanceInfo> instanceInfos;
+
+  {
+    LOG(INFO) << "Stopping the world for usage-by-class statistics" << maple::endl;
+
+    // Stop the world for statistics.
+    ScopedStopTheWorld stw;
+
+    // Now all threads are in safe region.
+    // We enumerate all objects
+    (void)(*theAllocator).ForEachObj([&instanceInfos, &totalObjBytes](address_t obj) {
+      MObject *mObj = reinterpret_cast<MObject*>(obj);
+      MClass *klass = mObj->GetClass();
+      size_t bytes = mObj->GetSize();
+
+      InstanceInfo &info = instanceInfos[klass];   // Creates element if not found.
+      info.bytes += bytes;
+      info.count += 1;
+
+      // We leave the InstanceInfo::name field uninitialized here, for performance reason.
+      totalObjBytes += bytes;
+    }, true);
+  } // The world starts here.
+
+  os << "Total object size:\t" << totalObjBytes << std::endl;
+
+  // Copy into a vector for sorting.
+  std::vector<InstanceInfo> vec;
+  for (auto &kv : instanceInfos) {
+    auto &klass = kv.first;
+    InstanceInfo &info = kv.second;
+    info.size = klass->GetObjectSize();
+    vec.push_back(info);
+    klass->GetBinaryName(vec.back().name);
+  }
+
+  // Sort by bytes, count and name.
+  std::sort(vec.begin(), vec.end(), [](InstanceInfo &a, InstanceInfo &b) {
+    if (a.bytes != b.bytes) {
+      return a.bytes > b.bytes;
+    } else if (a.count != b.count) {
+      return a.count > b.count;
+    } else {
+      return a.name < b.name;
+    }
+  });
+
+  // Print, use std::setw() to ensure alignment
+  os << "Heap usage by class:" << std::endl;
+  os << std::setw(10) << "num" << std::setw(16) <<  "#instance" << std::setw(16) << "#bytes" <<
+      std::setw(16) << "size" << "  class name" << std::endl;
+  os << "-------------------------------------------------------------------" << std::endl;
+  size_t rank = 1;
+
+  for (auto &info : vec) {
+    os << std::setw(10) << rank << std::setw(16) << info.count << std::setw(16) << info.bytes <<
+        std::setw(16) << info.size << "  " << info.name << std::endl;
+    rank++;
+  }
+
+  os << std::endl;
+}
+
+__attribute__((used)) void RecordMethod(uint64_t faddr, std::string &func, std::string &soname) {
+  if (func.empty()) {
+    LOG(INFO) << "func is empty  " << faddr << std::endl;
+  }
+  std::lock_guard<std::mutex> lock(recordMtx);
+  recordFunc.insert(std::make_pair(faddr, new FuncInfo(soname, func, faddr)));
+}
+
+bool CheckMethodResolved(uint64_t faddr) {
+  std::lock_guard<std::mutex> lock(recordMtx);
+  auto item = recordFunc.find(faddr);
+  if (item != recordFunc.end()) {
+    (item->second)->enterCount++;
+    return true;
+  }
+  return false;
+}
+
+void ClearFuncProfile() {
+  std::lock_guard<std::mutex> lock(recordMtx);
+  recordFunc.clear();
+}
+
+void DumpMethodUse(std::ostream &os) {
+  os << "start record func " << std::endl;
+  std::vector<FuncInfo*> funsInfo;
+  // sort by calltimes
+  for (auto &p : recordFunc) {
+    if (p.second != nullptr) {
+      funsInfo.push_back(p.second);
+    }
+  }
+  std::sort(funsInfo.begin(), funsInfo.end(), [](const FuncInfo *a, const FuncInfo *b) {
+    return a->enterCount < b->enterCount;
+  });
+
+  for (auto &p : funsInfo) {
+#if RECORD_FUNC_NAME
+    os << p->soname << "\t" << p->funcName << "\t" << p->enterCount << "\t" << std::hex <<
+        p->funcaddr << std::dec << std::endl;
+#else
+    os << std::hex << "0x" << p->funcaddr << "\t" << p->enterCount << std::dec << std::endl;
+#endif
+  }
+  os << "end record func " << std::endl;
+}
+
+void RecordStaticField(address_t *addr, const std::string name) {
+  std::lock_guard<std::mutex> lock(recordStaticFieldMtx);
+  if (recordStaticField.find(addr) == recordStaticField.end()) {
+    recordStaticField.insert(std::make_pair(addr, name));
+  }
+}
+
+void DumpStaticField(std::ostream &os) {
+  os << "start record static fields " << std::endl;
+  for (auto &p : recordStaticField) {
+    os << p.first << " " << p.second << std::endl;
+  }
+  os << "end record static fields " << std::endl;
+}
+}
diff --git a/src/mrt/compiler-rt/src/tracer.cpp b/src/mrt/compiler-rt/src/tracer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..20e75c455cdf527400bce18e794a670e43857925
--- /dev/null
+++ b/src/mrt/compiler-rt/src/tracer.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "tracer.h"
+
+namespace maplert {
+static Tracer *tracer = nullptr;
+
+void SetTracer(Tracer *t) {
+  tracer = t;
+}
+
+Tracer *GetTracer() {
+  return tracer;
+}
+}; // namespace maplert
diff --git a/src/mrt/compiler-rt/src/yieldpoint.cpp b/src/mrt/compiler-rt/src/yieldpoint.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e7e58079d25d7f6b4ea628265cb58e1f62c89bc
--- /dev/null
+++ b/src/mrt/compiler-rt/src/yieldpoint.cpp
@@ -0,0 +1,537 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "yieldpoint.h"
+
+#include <cinttypes>
+#include <climits>
+#include <cassert>
+#include <thread>
+#include <list>
+#include <atomic>
+#include <mutex>
+#include <ucontext.h>
+#include <sys/mman.h>
+
+#include "mm_config.h"
+#include "mm_utils.h"
+#include "mutator_list.h"
+#include "chosen.h"
+#ifdef __ANDROID__
+#include "collie.h"
+#include "android/set_abort_message.h"
+#endif
+
+#ifndef MRT_DEBUG_YIELDPOINT
+#define MRT_DEBUG_YIELDPOINT __MRT_DEBUG_COND_TRUE
+#endif
+
+namespace maplert {
+// use system memory page size for polling page.
+const int kPollingPageSize = 4096;
+
+// stop the world wait timeout, in milliseconds.
+#if MRT_UNIT_TEST
+// qemu is slow when doing unit test, so we use much longer timeout.
+const int kStopTheWorldTimeoutMs = 20000;
+#else
+const int kStopTheWorldTimeoutMs = 2000;
+#endif
+
+extern "C" {
+// Implemented in assembly, see 'yieldpoint-asm.s'.
+// DO NOT call this function directly.
+void MRT_YieldpointStub();
+
+// Yieldpoint handler will be called when yieldpoint is taken,
+// the lastSp is the stack frame pointer of the caller, can
+// be used as the begin stack pointer for stack scanning.
+// DO NOT call this function directly,
+// it will be called by MRT_YieldpointStub().
+void MRT_YieldpointHandler(void *lastSp);
+
+// Return the saved yieldpoint PC,
+// only used by MRT_YieldpointStub().
+void *MRT_GetThreadYieldpointPC() {
+  return maple::tls::GetTLS(maple::tls::kSlotYieldPointPc);
+}
+
+// Polling page for yeildpoint check. when polling page is set unreadable,
+// and we try to load data from polling page, a SIGSEGV signal will raised,
+// and function YieldpointSignalHandler() get called.
+void *globalPollingPage = MAP_FAILED;
+
+// Most functions are simple wrappers of methods of global or thread-local
+// objects defined in chosen.h/cpp.  Read cinterface.cpp for more information.
+//
+// Gets the polling page address.
+void *MRT_GetPollingPage() {
+  return globalPollingPage;
+}
+
+// Call this if you want insert a yieldpoint in managed code.
+void MRT_Yieldpoint() {
+#if  __aarch64__
+  // when yieldpoint is taken, x30 will changed to the PC at the yieldpoint,
+  // so we tell compiler to save x30 for yieldpoints.
+  __asm__ volatile ("ldr wzr, [x19]" ::: "x30", "memory");
+#else
+  // this is the portable version of yieldpoint, but tiny slower.
+  __attribute__ ((unused))
+  volatile register uintptr_t x = *reinterpret_cast<uintptr_t*>(MRT_GetPollingPage());
+#endif
+}
+}
+
+// saferegion state instance, include pending mutator count and saferegion count.
+SaferegionState SaferegionState::instance { 0 };
+
+namespace {
+// size of SaferegionState should be size_of(uint64_t) * 3 = 24 bytes.
+constexpr size_t kSaferegionStateSize = 24;
+static_assert(sizeof(SaferegionState) == kSaferegionStateSize, "SaferegionState incorrect size");
+
+std::atomic<bool> worldStopped = { false };
+
+// mutex to ensure only one thread can doing stop-the-world.
+std::recursive_mutex stwMutex;
+
+// Initializer, create polling page before main() function.
+struct YieldpointInitializer {
+  YieldpointInitializer() {
+    globalPollingPage = ::mmap(nullptr, kPollingPageSize, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    __MRT_ASSERT(globalPollingPage != MAP_FAILED, "globalPollingPage != MAP_FAILED");
+    LOG2FILE(kLogTypeMix) << "polling_page: " << globalPollingPage << std::endl;
+  }
+} yieldpointInitializer;
+}
+
+// Mark the polling page as unreadable
+static inline void SetPollingPageUnreadable() {
+  if (::mprotect(globalPollingPage, kPollingPageSize, PROT_NONE) != 0) {
+    LOG(FATAL) << "Could not disable polling page. errno=" << errno;
+  }
+}
+
+// Mark the polling page as readable
+static inline void SetPollingPageReadable() {
+  if (::mprotect(globalPollingPage, kPollingPageSize, PROT_READ) != 0) {
+    LOG(FATAL) << "Could not enable polling page. errno=" << errno;
+  }
+}
+
+void DumpMutatorsListInfo(bool isFatal) {
+  std::atomic_thread_fence(std::memory_order_acquire);
+  std::stringstream notInSaferegionTids;
+  size_t visitedCount = 0;
+  size_t visitedSaferegion = 0;
+  int firstNotStoppedTid = -1;
+  LOG(ERROR) << "MutatorList size : " << MutatorList::Instance().Size() << maple::endl;
+  MutatorList::Instance().VisitMutators(
+      [&notInSaferegionTids, &visitedCount, &visitedSaferegion, &firstNotStoppedTid](const Mutator *mut) {
+    mut->DumpRaw();
+    if (!mut->InSaferegion()) {
+      if (firstNotStoppedTid == -1) {
+        firstNotStoppedTid = static_cast<int>(mut->GetTid());
+      }
+      notInSaferegionTids << mut->GetTid() << " ";
+    } else {
+      ++visitedSaferegion;
+    }
+    ++visitedCount;
+  });
+
+  SaferegionState state = SaferegionState::Load();
+  std::stringstream dumpSaferegionInfo;
+  dumpSaferegionInfo << " total: " << state.asStruct.pendingCount <<
+      ", current: " << state.asStruct.saferegionCount <<
+      ", visited: " << visitedSaferegion << "/" << visitedCount <<
+      ", not stopped: " << notInSaferegionTids.str();
+#if MRT_UNIT_TEST
+  // for unit-test only.
+  LOG(ERROR) << "STW Timeout!" << dumpSaferegionInfo.str() << maple::endl;
+#endif
+  if (isFatal) {
+#ifdef __ANDROID__
+    if (firstNotStoppedTid != -1) {
+      std::stringstream errorMessage;
+      errorMessage << "SaferegionState info:" << dumpSaferegionInfo.str() << maple::endl;
+      android_set_abort_message(errorMessage.str().c_str());
+      int ret = tgkill(getpid(), firstNotStoppedTid, SIGABRT);
+      if (ret == 0) {
+        // wait abort signal kill
+        // abort success, so no need fatal again
+        constexpr int waitAbortSeconds = 3;
+        sleep(waitAbortSeconds);
+        return;
+      }
+    }
+#endif
+    LOG(FATAL) << "SaferegionState info:" << dumpSaferegionInfo.str() << maple::endl;
+  } else {
+    LOG(ERROR) << "SaferegionState info:" << dumpSaferegionInfo.str() << maple::endl;
+  }
+}
+
+// init after fork in child.
+void YieldpointInitAfterFork() {
+  // check state after fork in child process.
+  SaferegionState state = SaferegionState::Load();
+  Mutator &mutator = TLMutator();
+  bool expected = (MutatorList::Instance().Size() == 1 && state.asStruct.pendingCount == 0 &&
+                   state.asStruct.saferegionCount == 1 && mutator.IsActive() && mutator.InSaferegion());
+  if (UNLIKELY(!expected)) {
+    LOG(FATAL) << "Illegal state after fork!" <<
+        " MutatorList:" << MutatorList::Instance().Size() <<
+        " SaferegionState:" << state.asStruct.pendingCount << '/' << state.asStruct.saferegionCount <<
+        " Mutator:" << &mutator << '/' << mutator.IsActive() << '/' << mutator.InSaferegion() <<
+        maple::endl;
+  }
+
+  // init current mutator after fork in child.
+  mutator.InitAfterFork();
+}
+
+// called from registered signal handler, see libjavaeh.cpp.
+// uc context of the yieldpoint.
+bool YieldpointSignalHandler(int sig, siginfo_t *info, ucontext_t *uc) {
+  // check if the signal is triggered by yieldpoint.
+  if (sig != SIGSEGV || info == nullptr || uc == nullptr || info->si_addr != globalPollingPage) {
+    // not a yieldpoint signal.
+    return false;
+  }
+
+  // do not enter yieldpoint if already in saferegion.
+  if (UNLIKELY(TLMutator().InSaferegion())) {
+    return true;
+  }
+
+#if defined(__aarch64__)
+  // x29 as FP register.
+  constexpr int fpRegisterNum = 29;
+
+  // logging for debug
+  LOG2FILE(kLogTypeMix) << "signal handler, pc: " << uc->uc_mcontext.pc <<
+      ", fp: " << uc->uc_mcontext.regs[fpRegisterNum] << std::endl;
+
+  // Save yieldpoint PC to thread local storage.
+  // MRT_YieldpointStub() use it as the return address.
+  StoreTLS(reinterpret_cast<void*>(static_cast<uintptr_t>(uc->uc_mcontext.pc)), maple::tls::kSlotYieldPointPc);
+
+  // Redirect yieldpoint to the slow path: call MRT_YieldpointStub().
+  uc->uc_mcontext.pc = reinterpret_cast<__u64>(MRT_YieldpointStub);
+#elif defined(__arm__)
+  StoreTLS(reinterpret_cast<void*>(static_cast<uintptr_t>(uc->uc_mcontext.arm_pc)), maple::tls::kSlotYieldPointPc);
+  uc->uc_mcontext.arm_pc = reinterpret_cast<uintptr_t>(MRT_YieldpointStub);
+#endif
+
+  // tell caller that the yieldpoint signal is handled.
+  return true;
+}
+
+// Initialize yieldpoint for mutator.
+void InitYieldpoint(Mutator &mutator) {
+  __MRT_ASSERT(!mutator.IsActive(), "InitYieldpoint on active mutator.");
+
+  // add mutator to mutator list. if the world is stopped,
+  // the AddMutator() will block until the world is started again.
+  MutatorList::Instance().AddMutator(mutator);
+
+  // let the mutator enter saferegion after mutator started.
+  // mutator will leave saferegion when managed code is called.
+  if (UNLIKELY(!mutator.EnterSaferegion(false))) {
+    // ensure we are not in saferegion before InitYieldpoint().
+    LOG(FATAL) << "InitYieldpoint() invalid saferegion state. mutator: " << &mutator << maple::endl;
+  }
+}
+
+// Finalize yieldpoint for mutator.
+void FiniYieldpoint(Mutator &mutator) {
+  __MRT_ASSERT(mutator.IsActive(), "FiniYieldpoint on inactive mutator.");
+
+  // mutator is about to exit, all reference holding on stack will released.
+  // We clear managed stack pointers so that stack scanner skip this mutator.
+  mutator.ClearStackInfo();
+
+  // enter saferegion before remove mutator from list,
+  // because RemoveMutator() may block current thread.
+  if (mutator.EnterSaferegion(false)) {
+    LOG(FATAL) << "FiniYieldpoint() from nosafe-region. mutator: " << &mutator << maple::endl;
+  }
+
+  // remove mutator from list. if the world is stopped,
+  // the RemoveMutator() will block util the world is started again.
+  MutatorList::Instance().RemoveMutator(mutator, [](Mutator *mut) {
+    // Leave saferegion after mutator removed from list.
+    // this will not interrupted by GC because we hold mutator list lock.
+    if (UNLIKELY(!mut->LeaveSaferegion())) {
+      // ensure we are in saferegion before RemoveMutator().
+      LOG(FATAL) << "FiniYieldpoint() invalid saferegion state. mutator: " << mut << maple::endl;
+    }
+
+    // clean up mutator.
+    mut->Fini();
+  });
+}
+
+void MRT_YieldpointHandler(void *lastSp) {
+  // logging for debug
+  LOG2FILE(kLogTypeMix) << "MRT_YieldpointHandler, last sp: " << lastSp <<
+      ", prev fp: " << *(reinterpret_cast<void**>(lastSp)) <<
+      ", prev lr: " << *(reinterpret_cast<void**>((reinterpret_cast<uintptr_t>(lastSp)) + sizeof(void*))) << std::endl;
+
+  // current mutator.
+  Mutator &mutator = TLMutator();
+
+#if __MRT_DEBUG
+  // do nothing if mutator already in saferegion.
+  if (UNLIKELY(mutator.InSaferegion())) {
+    LOG(FATAL) << "Incorrect saferegion state at yieldpoint!" << maple::endl;
+  }
+#endif
+
+  // save the last stack pointer.
+  mutator.SaveStackEnd(lastSp);
+
+  // let mutator enter saferegion.
+  mutator.DoEnterSaferegion();
+
+  // block current thread before leave saferegion.
+  mutator.DoLeaveSaferegion();
+  LOG2FILE(kLogTypeMix) << "MRT_YieldpointHandler, thread restarted." << std::endl;
+}
+
+extern "C" bool MRT_EnterSaferegion(bool rememberLastJavaFrame) {
+  return TLMutator().EnterSaferegion(rememberLastJavaFrame);
+}
+
+extern "C" bool MRT_LeaveSaferegion() {
+  return TLMutator().LeaveSaferegion();
+}
+
+// if this is the last mutator entering saferegion, wakeup StopTheWorld().
+void EnterSaferegionSlowPath() {
+  int *saferegionCountAddr = SaferegionState::SaferegionCountAddr();
+  (void)maple::futex(saferegionCountAddr, FUTEX_WAKE, INT_MAX, nullptr, nullptr, 0);
+}
+
+void StackScanBarrierSlowPath() {
+  Collector::Instance().StackScanBarrierInMutator();
+}
+
+// LeaveSaferegionSlowPath is called if pendingCount is set when we leaving saferegion.
+// this means when the world is stopping or stoppped, we should block until the world start.
+void LeaveSaferegionSlowPath() {
+  for (;;) {
+    // we are not leave saferegion now, so the saferegion count should
+    // be increased to indicate that current mutator still stay in saferegion.
+    SaferegionState state = SaferegionState::IncSaferegionCount();
+    if (UNLIKELY(state.asStruct.saferegionCount + 1 == state.asStruct.pendingCount)) {
+      // if this is the last mutator entering saferegion, wakeup StopTheWorld().
+      int *saferegionCountAddr = SaferegionState::SaferegionCountAddr();
+      (void)maple::futex(saferegionCountAddr, FUTEX_WAKE, INT_MAX, nullptr, nullptr, 0);
+    }
+    // wait until pendingCount changed to 0.
+    int curNum = static_cast<int>(state.asStruct.pendingCount);
+    if (curNum > 0) { // here curNum might already been set to 0, does so to avoid lost wake-ups
+      int *pendingCountAddr = SaferegionState::PendingCountAddr();
+      if (UNLIKELY(maple::futex(pendingCountAddr, FUTEX_WAIT, curNum, nullptr, nullptr, 0) != 0)) {
+        LOG(ERROR) << "futex wait failed, " << errno << maple::endl;
+      }
+    }
+    // dec saferegion count, and load pendingCount.
+    state = SaferegionState::DecSaferegionCount();
+    // usually the loaded pendingCount here should be 0,
+    // but we need to check it.
+    if (LIKELY(state.asStruct.pendingCount == 0)) {
+      // leave saferegion if pending count is 0, otherwise try again.
+      return;
+    }
+  }
+}
+
+static void InitTimeSpec(long milliSecond, timespec &timeSpec) {
+  timeSpec.tv_sec = milliSecond / static_cast<long>(maple::kTimeFactor);
+  timeSpec.tv_nsec = 0;
+}
+
+static void WaitForAllMutatorsStopped() {
+  // wait timeout
+  struct timespec timeout;
+  InitTimeSpec(kStopTheWorldTimeoutMs, timeout);
+  int timeoutTimes = 0;
+  // wait until all mutators enter saferegion.
+  for (;;) {
+    // current saferegion state.
+    SaferegionState state = SaferegionState::Load();
+    if (UNLIKELY(state.asStruct.pendingCount < state.asStruct.saferegionCount)) {
+      MutatorList::Instance().VisitMutators([](const Mutator *mut) {
+        mut->DumpRaw();
+      });
+      LOG(FATAL) << "Incorrect SaferegionState! pendingCount: " << state.asStruct.pendingCount <<
+          ", saferegionCount: " << state.asStruct.saferegionCount <<
+          ", nMutators: " << MutatorList::Instance().Size() << maple::endl;
+    }
+
+#if MRT_UNIT_TEST
+    // Use sched_yield() to let mutator have a chance to modify
+    // the SaferegionState before we check it.
+    (void)sched_yield();
+#endif
+
+    // stop wait if all mutators stopped (aka. in saferegion).
+    if (UNLIKELY(state.AllMutatorStopped())) {
+      return;
+    }
+
+    // wait for saferegionCount changed.
+    int curNum = static_cast<int>(state.asStruct.saferegionCount);
+    int *saferegionCountAddr = SaferegionState::SaferegionCountAddr();
+    if (UNLIKELY(maple::futex(saferegionCountAddr, FUTEX_WAIT, curNum, &timeout, nullptr, 0) != 0)) {
+      if (errno == ETIMEDOUT) {
+        timeoutTimes++;
+#if MRT_DEBUG_YIELDPOINT
+        DumpMutatorsListInfo(timeoutTimes > 1);
+#else
+        constexpr int maxTimeoutTimes = 30;
+        DumpMutatorsListInfo(timeoutTimes == maxTimeoutTimes);
+#endif
+      } else if ((errno != EAGAIN) && (errno != EINTR)) {
+        LOG(ERROR) << "futex wait failed, " << errno << maple::endl;
+      }
+    }
+  }
+}
+
+static bool saferegionStateChanged = false;
+
+void StopTheWorld() {
+  constexpr uint64_t waitLockInterval = 5000; // 5us
+  constexpr uint64_t nanoPerSecond = 1000000000; // 1sec equals 10^9ns
+  constexpr uint64_t waitLockTimeout = 30; // seconds
+  bool saferegionEntered = false;
+
+  // ensure an active mutator entered saferegion before
+  // stop-the-world (aka. stop all other mutators).
+  Mutator *mutator = TLMutatorPtr();
+  if (mutator != nullptr && mutator->IsActive()) {
+    saferegionEntered = mutator->EnterSaferegion(true);
+  }
+
+  // block if another thread is holding the stwMutex.
+  // this prevent multi-thread doing stop-the-world concurrently.
+  stwMutex.lock();
+
+  maple::Locks::threadListLock->Dump(LOG_STREAM(DEBUGY));
+  uint64_t start = timeutils::NanoSeconds();
+  bool threadListLockAcquired = maple::GCRootsVisitor::TryAcquireThreadListLock();;
+  while (!threadListLockAcquired) {
+    timeutils::SleepForNano(waitLockInterval);
+    threadListLockAcquired = maple::GCRootsVisitor::TryAcquireThreadListLock();
+    uint64_t now = timeutils::NanoSeconds();
+    if (threadListLockAcquired == false && ((now - start) / nanoPerSecond) > waitLockTimeout) {
+      maple::Locks::threadListLock->Dump(LOG_STREAM(ERROR));
+      LOG(FATAL) << " wait thread list lock out of time " << maple::endl;
+    }
+  }
+
+  start = timeutils::NanoSeconds();
+  bool mutatorListLockAcquired = MutatorList::Instance().TryLock();
+  while (!mutatorListLockAcquired) {
+    timeutils::SleepForNano(waitLockInterval);
+    mutatorListLockAcquired = MutatorList::Instance().TryLock();
+    uint64_t now = timeutils::NanoSeconds();
+    if (mutatorListLockAcquired == false && ((now - start) / nanoPerSecond) > waitLockTimeout) {
+      LOG(FATAL) << " wait mutator list lock out of time " << MutatorList::Instance().LockOwner() << maple::endl;
+    }
+  }
+  // if a mutator saferegion state changed (entered saferegion from outside),
+  // we should restore it after the mutator called StartTheWorld().
+  saferegionStateChanged = saferegionEntered;
+  // number of mutators. it will not be changed since
+  // we hold the lock of mutator list when the world is stopped.
+  size_t nMutators = MutatorList::Instance().Size();
+  // do not wait if no mutator in the list.
+  if (UNLIKELY(nMutators == 0)) {
+    worldStopped.store(true, std::memory_order_release);
+    return;
+  }
+  // set n_muators as pendingCount.
+  (void)SaferegionState::SetPendingCount(static_cast<uint32_t>(nMutators));
+  // trigger yieldpoints.
+  SetPollingPageUnreadable();
+  WaitForAllMutatorsStopped();
+
+#ifdef __ANDROID__
+  mplCollie.StartSTW();
+#endif
+  // the world is stopped.
+  worldStopped.store(true, std::memory_order_release);
+}
+
+void StartTheWorld() {
+#ifdef __ANDROID__
+  mplCollie.EndSTW();
+#endif
+  bool shouldLeaveSaferegion = saferegionStateChanged;
+  worldStopped.store(false, std::memory_order_release);
+  // restore polling page.
+  SetPollingPageReadable();
+
+  // clear pending count.
+  (void)SaferegionState::SetPendingCount(0);
+
+  // wakeup all mutators which blocking on pendingCount futex.
+  int *uaddr = SaferegionState::PendingCountAddr();
+  (void)maple::futex(uaddr, FUTEX_WAKE, INT_MAX, nullptr, nullptr, 0);
+
+  // release mutator list lock.
+  MutatorList::Instance().Unlock();
+
+  LOG2FILE(kLogTypeMix) << "Releasing threadListLock..." << std::endl;
+  maple::GCRootsVisitor::ReleaseThreadListLock();
+  LOG2FILE(kLogTypeMix) << "Released threadListLock." << std::endl;
+
+  // unlock stwMutex to allow other thread stop-the-world.
+  stwMutex.unlock();
+
+  // restore saferegion state (leave saferegion) if
+  // the state is changed when mutator calls StopTheWorld().
+  Mutator *mutator = TLMutatorPtr();
+  if (mutator != nullptr && mutator->IsActive() && shouldLeaveSaferegion) {
+    (void)mutator->LeaveSaferegion();
+  }
+}
+
+bool WorldStopped() {
+  return worldStopped.load(std::memory_order_acquire);
+}
+
+void LockStopTheWorld() {
+  stwMutex.lock();
+}
+
+void UnlockStopTheWorld() {
+  stwMutex.unlock();
+}
+
+void SaferegionState::CheckMagicFailed() {
+  LOG(FATAL) << "SaferegionState Magic modified!" << std::hex <<
+      " magic1:" << magic1 <<
+      " magic2:" << magic2 << std::dec <<
+      " &magic1:" << &magic1 <<
+      " &state:"  << &asUint64 <<
+      " &magic2:" << &magic2 << maple::endl;
+}
+} // namespace maplert
diff --git a/src/mrt/deplibs/gc/libcore-static-binding-jni-qemu.a b/src/mrt/deplibs/gc/libcore-static-binding-jni-qemu.a
new file mode 100644
index 0000000000000000000000000000000000000000..0c2b2f8e1345c10315448cfd9a91a60ab24676db
Binary files /dev/null and b/src/mrt/deplibs/gc/libcore-static-binding-jni-qemu.a differ
diff --git a/src/mrt/deplibs/libandroidmpl-rt.so b/src/mrt/deplibs/libandroidmpl-rt.so
new file mode 100755
index 0000000000000000000000000000000000000000..ec74a51bedab489f3a8048be2a53c3e32ba5ed15
Binary files /dev/null and b/src/mrt/deplibs/libandroidmpl-rt.so differ
diff --git a/src/mrt/deplibs/libc_secshared.so b/src/mrt/deplibs/libc_secshared.so
new file mode 100755
index 0000000000000000000000000000000000000000..b2f377c64a1cd4850e3b0c926a9ce77c800fe1b5
Binary files /dev/null and b/src/mrt/deplibs/libc_secshared.so differ
diff --git a/src/mrt/deplibs/libcommon-bridge.so b/src/mrt/deplibs/libcommon-bridge.so
new file mode 100755
index 0000000000000000000000000000000000000000..5a8afdff651dcfd2d50537dc546cb9a2c9ddfc1d
Binary files /dev/null and b/src/mrt/deplibs/libcommon-bridge.so differ
diff --git a/src/mrt/deplibs/libcommon_bridge.so b/src/mrt/deplibs/libcommon_bridge.so
new file mode 100755
index 0000000000000000000000000000000000000000..1871b4a9ccd18f1c85c9835101fca29b0eadcabd
Binary files /dev/null and b/src/mrt/deplibs/libcommon_bridge.so differ
diff --git a/src/mrt/deplibs/libcore-static-binding-jni-qemu.a b/src/mrt/deplibs/libcore-static-binding-jni-qemu.a
new file mode 100644
index 0000000000000000000000000000000000000000..75e945adc286cd714ed4616eee1c7a4e41779009
Binary files /dev/null and b/src/mrt/deplibs/libcore-static-binding-jni-qemu.a differ
diff --git a/src/mrt/deplibs/libjava_addr2line.so b/src/mrt/deplibs/libjava_addr2line.so
new file mode 100755
index 0000000000000000000000000000000000000000..d9e7ae502f7cdb52ca8e180ae445caace10d3c82
Binary files /dev/null and b/src/mrt/deplibs/libjava_addr2line.so differ
diff --git a/src/mrt/deplibs/libmplandroid.so b/src/mrt/deplibs/libmplandroid.so
new file mode 100755
index 0000000000000000000000000000000000000000..48552d4c7d630b5a718984b1cd2a20c40f042154
Binary files /dev/null and b/src/mrt/deplibs/libmplandroid.so differ
diff --git a/src/mrt/deplibs/libmplopenjdk.so b/src/mrt/deplibs/libmplopenjdk.so
new file mode 100755
index 0000000000000000000000000000000000000000..714f68916377edb049e00122ebe7798c6dcaf02d
Binary files /dev/null and b/src/mrt/deplibs/libmplopenjdk.so differ
diff --git a/src/mrt/dexinterface/BUILD.gn b/src/mrt/dexinterface/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..691a0eb129a887bd395da2c4b1ac9181c0c6fcc2
--- /dev/null
+++ b/src/mrt/dexinterface/BUILD.gn
@@ -0,0 +1,27 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+static_library("libdexinterface") {
+  cflags_cc = []
+  configs = [ "${MAPLE_MRT_ROOT}:mrt_cxx_flags" ]
+
+  asmflags = cflags_cc
+  sources = []
+
+  cflags_cc += [
+    "-pthread",
+    "-fasynchronous-unwind-tables",
+    "-std=gnu++17",
+  ]
+}
diff --git a/src/mrt/interpreter/BUILD.gn b/src/mrt/interpreter/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..af7068400dd352235dfbfa7ae985b2c66118b271
--- /dev/null
+++ b/src/mrt/interpreter/BUILD.gn
@@ -0,0 +1,22 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+static_library("libzterp") {
+  cflags = []
+  cflags_cc = []
+  configs = [ "${MAPLE_MRT_ROOT}:mrt_cxx_flags" ]
+
+  asmflags = cflags_cc
+  sources = []
+}
diff --git a/src/mrt/interpreter/zterp/interp_support.h b/src/mrt/interpreter/zterp/interp_support.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f6536a80ccd6fa002bfb11f708d0199cd85dddd
--- /dev/null
+++ b/src/mrt/interpreter/zterp/interp_support.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MPL_RUNTIME_INTERPRETER_SUPPORT_H
+#define MPL_RUNTIME_INTERPRETER_SUPPORT_H
+
+#include "exception/stack_unwinder.h"
+#include "methodmeta.h"
+#include "loader_api.h"
+#include "chelper.h"
+// forward declaring
+namespace maple {
+struct maple_native_stack_item;
+}
+
+namespace maplert {
+inline bool MethodMeta::NeedsInterp() const {
+  return false;
+}
+
+extern "C" inline bool TryGetNativeContexClassLoaderForInterp(const UnwindContext &, jclass &) {
+  return false;
+}
+
+class MClassLocatorManagerInterpEx {
+ public:
+  static inline bool LoadClasses(LoaderAPI &, jobject, ObjFile &) {
+    return false;
+  }
+
+  static inline bool RegisterNativeMethods(LoaderAPI &, ObjFile &, jclass, const JNINativeMethod *, jint) {
+    return false;
+  }
+};
+
+class MClassLocatorInterpEx {
+ public:
+  static inline ClassMetadata *BuildClassFromDex(IObjectLocator, const std::string &, SearchFilter &) {
+    return nullptr;
+  }
+};
+
+class UnwindContextInterpEx {
+ public:
+  static inline UnwindState UnwindToCaller(void *, UnwindContext &) {
+    return kUnwindSucc;
+  }
+
+  static inline void VisitGCRoot(UnwindContext &, const AddressVisitor &) {
+    return;
+  }
+
+  static inline bool TryRecordStackFromUnwindContext(std::vector<uint64_t> &, UnwindContext &) {
+    return false;
+  }
+
+  static inline bool TryDumpStackInfoInLog(LinkerAPI &, UnwindContext &) {
+    return false;
+  }
+
+  MRT_EXPORT static inline MClass *GetDeclaringClassFromUnwindContext(UnwindContext &) {
+    return nullptr;
+  }
+
+  MRT_EXPORT static inline void GetJavaMethodFullNameFromUnwindContext(UnwindContext &, std::string &) {
+    return;
+  }
+
+  MRT_EXPORT static inline void LogCallerClassInfoFromUnwindContext(UnwindContext &, UnwindContext &, int &) {
+    return;
+  }
+
+  MRT_EXPORT static inline void LogCallerFilenameFromUnwindContext(UnwindContext &, int &) {
+    return;
+  }
+
+  MRT_EXPORT static inline void GetStackFrameFromUnwindContext(UnwindContext &, maple::maple_native_stack_item &) {
+    return;
+  }
+};
+
+class InterpSupport {
+ public:
+  static inline std::string GetSoName() {
+    return std::string("unknown");
+  }
+};
+
+namespace interpreter {
+static inline std::string GetStringFromInterpreterStrTable(int32_t) {
+  return std::string();
+}
+
+template<calljavastubconst::ArgsType argsType>
+static inline jvalue InterpJavaMethod(MethodMeta *, MObject *, uintptr_t) {
+  jvalue ret;
+  ret.j = 0LL;
+  return ret;
+}
+
+template<typename T, calljavastubconst::ArgsType argsType>
+static inline T InterpJavaMethod(MethodMeta *, MObject *, const uintptr_t) {
+  return (T)0;
+}
+} // namespace interpreter
+} // namespace maplert
+
+#endif // MPL_RUNTIME_INTERPRETER_SUPPORT_H
diff --git a/src/mrt/libcore-static-binding-jni/BUILD.gn b/src/mrt/libcore-static-binding-jni/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..966d01690a1df61c325410d6d20eb9a760b95b00
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/BUILD.gn
@@ -0,0 +1,67 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+sources_common = [
+  "src/java_lang_Class.cpp",
+  "src/java_lang_reflect_Array.cpp",
+  "src/java_lang_reflect_Field.cpp",
+  "src/java_lang_reflect_Method.cpp",
+  "src/java_lang_String.cpp",
+  "src/java_lang_StringFactory.cpp",
+  "src/java_lang_System.cpp",
+  "src/libcore_util_CharsetUtils.cpp",
+  "src/native_binding_utils.cpp",
+  "src/java_lang_ref_Reference.cpp",
+  "src/java_io_File.cpp",
+  "src/com_android_internal_util_ArrayUtils.cpp",
+  "src/java_lang_Object.cpp",
+  "src/java_lang_Thread.cpp",
+]
+
+include_common = [
+  "${AOSP_ROOT}/libnativehelper/include_jni",
+  "${MAPLE_MRT_ROOT}/libcore-static-binding-jni/include",
+  "${MAPLE_MRT_ROOT}/maplert/include",
+  "${MAPLE_MRT_ROOT}/compiler-rt/include",
+  "${MAPLE_MRT_ROOT}/compiler-rt/public-headers",
+  "${MAPLE_MRT_ROOT}/libmrtbase/include",
+  "${MAPLE_MRT_ROOT}/libmrtbase/include/linux",
+  "${MAPLE_MRT_ROOT}/maplert/public-headers",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include/",
+  "${MAPLE_MRT_ROOT}/dexinterface",
+  "${MAPLE_MRT_ROOT}/interpreter/zterp",
+  "${MAPLE_MRT_ROOT}",
+]
+
+static_library("libcore-static-binding-jni") {
+  cflags = []
+  cflags_cc = []
+
+  cflags = [
+    "-DPLATFORM_SDK_VERSION=27",
+    "-DJNIDEBUG=0",
+    "-DTRACE_LEVEL=3",
+  ]
+
+  sources = sources_common
+  include_dirs = include_common
+
+  cflags_cc += [
+    "-fvisibility=hidden",
+    "-std=c++11",
+    "-nostdlibinc",
+    "-march=armv8-a",
+  ]
+  configs = [ "${MAPLE_MRT_ROOT}:mrt_cxx_flags" ]
+}
diff --git a/src/mrt/libcore-static-binding-jni/include/com_android_internal_util_ArrayUtils.h b/src/mrt/libcore-static-binding-jni/include/com_android_internal_util_ArrayUtils.h
new file mode 100644
index 0000000000000000000000000000000000000000..c570bb2741792cd6cd30dbf6407b63c166944c65
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/com_android_internal_util_ArrayUtils.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_COM_ANDROID_INTERNAL_UTIL_ARRAYUTILS_H
+#define MAPLE_RUNTIME_NATIVE_COM_ANDROID_INTERNAL_UTIL_ARRAYUTILS_H
+#include <jni.h>
+
+#endif // MAPLE_RUNTIME_NATIVE_COM_ANDROID_INTERNAL_UTIL_ARRAYUTILS_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_io_File.h b/src/mrt/libcore-static-binding-jni/include/java_io_File.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8a8a517c93d95e994c03dadf200956a34abd929
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_io_File.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_IO_FILE_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_IO_FILE_H
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jstring Native_Ljava_2Fio_2FUnixFileSystem_3B_7Cnormalize_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B(
+    jobject jthis, jstring pathName);
+
+jboolean Java_libcore_io_Linux_access__Ljava_lang_String_2I(const JNIEnv *env, jobject,
+                                                            const jstring javaPath, jint mode);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_IO_FILE_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_Class.h b/src/mrt/libcore-static-binding-jni/include/java_lang_Class.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b78c70315054bce952bbc1555c2e646e1619d57
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_Class.h
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_CLASS_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_CLASS_H
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jobject Java_java_lang_Class_newInstance__(JNIEnv *env, jobject klass);
+
+// Ljava/lang/Class;|isAssignableFrom|(Ljava/lang/Class;)Z
+jboolean Ljava_2Flang_2FClass_3B_7CisAssignableFrom_7C_28Ljava_2Flang_2FClass_3B_29Z(jclass javaThis, jclass cls);
+
+// Ljava/lang/Class;|isInterface|()Z
+jboolean Ljava_2Flang_2FClass_3B_7CisInterface_7C_28_29Z(const jobject javaThis);
+
+// Ljava/lang/Class;|isPrimitive|()Z
+jboolean Ljava_2Flang_2FClass_3B_7CisPrimitive_7C_28_29Z(const jobject javaThis);
+
+#ifndef __OPENJDK__
+// Ljava/lang/Class;|getName|()Ljava/lang/String;
+jobject Ljava_2Flang_2FClass_3B_7CgetName_7C_28_29Ljava_2Flang_2FString_3B(jclass javaThis);
+
+jboolean Ljava_2Flang_2FClass_3B_7CisMemberClass_7C_28_29Z(jobject javaThis);
+jboolean Ljava_2Flang_2FClass_3B_7CisLocalClass_7C_28_29Z(jobject javaThis);
+#endif // __OPENJDK__
+
+jobject Java_java_lang_Class_getNameNative__(JNIEnv *env, jclass javaThis);
+// Ljava/lang/Class;|getClassLoader|()Ljava/lang/ClassLoader;
+jobject Ljava_2Flang_2FClass_3B_7CgetClassLoader_7C_28_29Ljava_2Flang_2FClassLoader_3B(jobject javaThis);
+
+#ifdef __OPENJDK__
+// Ljava/lang/Class;|getClassLoader0|()Ljava/lang/ClassLoader;
+jobject Ljava_2Flang_2FClass_3B_7CgetClassLoader0_7C_28_29Ljava_2Flang_2FClassLoader_3B(jobject javaThis);
+#endif // __OPENJDK__
+
+#if PLATFORM_SDK_VERSION >= 27
+jobject Java_java_lang_Class_getPrimitiveClass__Ljava_lang_String_2(JNIEnv *env, jobject klass, jobject name);
+#endif
+
+// Ljava/lang/Class;|getSuperclass|()Ljava/lang/Class;
+jobject Ljava_2Flang_2FClass_3B_7CgetSuperclass_7C_28_29Ljava_2Flang_2FClass_3B(jclass javaThis);
+
+// Ljava/lang/Class;|getInterfaces|()ALjava/lang/Class;
+jobject Ljava_2Flang_2FClass_3B_7CgetInterfaces_7C_28_29ALjava_2Flang_2FClass_3B(jclass javaThis);
+jobject Java_java_lang_Class_getInterfacesInternal__(JNIEnv *env, jobject klass);
+
+// Ljava/lang/Class;|getComponentType|()Ljava/lang/Class;
+jobject Ljava_2Flang_2FClass_3B_7CgetComponentType_7C_28_29Ljava_2Flang_2FClass_3B(const jobject javaThis);
+
+// Ljava/lang/Class;|getModifiers|()I
+jint Ljava_2Flang_2FClass_3B_7CgetModifiers_7C_28_29I(jobject javaThis);
+jint Java_java_lang_Class_getInnerClassFlags__I(JNIEnv *env, jobject klass, jint defaultValue);
+jobject Java_java_lang_Class_getEnclosingMethodNative__(JNIEnv *env, jobject klass);
+
+jobject Java_java_lang_Class_getEnclosingConstructorNative__(JNIEnv *env, jobject klass);
+
+jobject Java_java_lang_Class_getDeclaringClass__(JNIEnv *env, jclass klass);
+
+jobject Java_java_lang_Class_getEnclosingClass__(JNIEnv *env, jobject klass);
+
+jboolean Java_java_lang_Class_isAnonymousClass__(JNIEnv *env, jobject klass);
+
+// Ljava/lang/Class;|getClasses|()ALjava/lang/Class;
+jobject Ljava_2Flang_2FClass_3B_7CgetClasses_7C_28_29ALjava_2Flang_2FClass_3B(jobject javaThis);
+
+// Ljava/lang/Class;|getFields|()ALjava/lang/reflect/Field;
+jobject Ljava_2Flang_2FClass_3B_7CgetFields_7C_28_29ALjava_2Flang_2Freflect_2FField_3B(jobject javaThis);
+void Ljava_2Flang_2FClass_3B_7CgetPublicFieldsRecursive_7C_28Ljava_2Futil_2FList_3B_29V(
+    jobject javaThis, jobject listObj);
+jobject Java_java_lang_Class_getPublicFieldRecursive__Ljava_lang_String_2(
+    JNIEnv *env, jobject javaThis, jobject fieldName);
+jobject Java_java_lang_Class_getPublicDeclaredFields__(JNIEnv *env, jobject klass);
+
+// Ljava/lang/Class;|getMethods|()ALjava/lang/reflect/Method;
+jobject Ljava_2Flang_2FClass_3B_7CgetMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B(jobject javaThis);
+void Ljava_2Flang_2FClass_3B_7CgetPublicMethodsInternal_7C_28Ljava_2Futil_2FList_3B_29V(
+    jobject classObj, jobject listObject);
+
+// Ljava/lang/Class;|getConstructors|()ALjava/lang/reflect/Constructor;
+jobject Ljava_2Flang_2FClass_3B_7CgetConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B(jobject javaThis);
+jobject Java_java_lang_Class_getDeclaredConstructorsInternal__Z(JNIEnv *env, jobject classObj, jboolean publicOnly);
+jobject Java_java_lang_Class_getDeclaredMethodInternal__Ljava_lang_String_2_3Ljava_lang_Class_2(
+    JNIEnv *env, jobject klass, jobject name, jobject parameterTypes);
+// Ljava/lang/Class;|getField|(Ljava/lang/String;)Ljava/lang/reflect/Field;
+jobject Ljava_2Flang_2FClass_3B_7CgetField_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2Freflect_2FField_3B(
+    jobject javaThis, jobject name);
+
+// Ljava/lang/Class;|getMethod|(Ljava/lang/String;ALjava/lang/Class;)Ljava/lang/reflect/Method;
+jobject Ljava_2Flang_2FClass_3B_7CgetMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B(
+    jobject klass, jobject s, jobject array);
+
+// Ljava/lang/Class;|getConstructor|(ALjava/lang/Class;)Ljava/lang/reflect/Constructor;
+jobject Ljava_2Flang_2FClass_3B_7CgetConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B(
+    jobject klass, jobject array);
+
+jobject Java_java_lang_Class_getDeclaredClasses__(JNIEnv *env, jclass klass);
+
+jobject Java_java_lang_Class_getDeclaredFields__(JNIEnv *env, jobject klass);
+
+jobject Java_java_lang_Class_getDeclaredFieldsUnchecked__Z(JNIEnv *env, jobject klass, jboolean arg1);
+
+jobject Ljava_2Flang_2FClass_3B_7CgetDeclaredMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B(jobject klass);
+
+jobject Java_java_lang_Class_getDeclaredMethodsUnchecked__Z(JNIEnv *env, jobject klass, jboolean arg1);
+
+// Ljava/lang/Class;|getDeclaredConstructors|()ALjava/lang/reflect/Constructor;
+jobject Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B(
+    jobject javaThis);
+
+jobject Java_java_lang_Class_getDeclaredField__Ljava_lang_String_2(JNIEnv *env, jobject klass, jobject s);
+
+// Ljava/lang/Class;|getDeclaredMethod|(Ljava/lang/String;ALjava/lang/Class;)Ljava/lang/reflect/Method;
+jobject Ljava_2Flang_2FClass_3B_7CgetDeclaredMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B(
+    jobject javaThis, jobject name, jobject parameterTypes);
+
+// Ljava/lang/Class;|getInstanceMethod|(Ljava/lang/String;ALjava/lang/Class;)Ljava/lang/reflect/Method;
+jobject Ljava_2Flang_2FClass_3B_7CgetInstanceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B(
+    jobject javaThis, jobject name, jobject parameterTypes);
+
+jobject Ljava_2Flang_2FClass_3B_7CfindInterfaceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B(
+    jobject javaThis, jobject name, jobject parameterTypes);
+jobject Java_java_lang_Class_getDeclaredConstructorInternal___3Ljava_lang_Class_2(
+    JNIEnv *env, jobject klass, jobject parameterTypes);
+
+// Ljava/lang/Class;|getDeclaredConstructor|(ALjava/lang/Class;)Ljava/lang/reflect/Constructor;
+jobject Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B(
+    jobject javaThis, jobject parameterTypes);
+
+jobject Java_java_lang_Class_getInnerClassName__(JNIEnv *env, jobject klass);
+
+jobject Java_java_lang_Class_getDeclaredAnnotation__Ljava_lang_Class_2(JNIEnv *env, jobject klass, jobject cls);
+
+jobject Java_java_lang_Class_getDeclaredAnnotations__(JNIEnv *env, jclass klass);
+
+jboolean Java_java_lang_Class_isDeclaredAnnotationPresent__Ljava_lang_Class_2(JNIEnv *env, jobject klass, jobject cls);
+
+jobject Java_java_lang_Class_getSignatureAnnotation__(JNIEnv *env, jobject klass);
+
+// Ljava/lang/Class;|isProxy|()Z
+jboolean Ljava_2Flang_2FClass_3B_7CisProxy_7C_28_29Z(jobject javaThis);
+
+// Ljava/lang/Class;|getAccessFlags|()I
+jint Ljava_2Flang_2FClass_3B_7CgetAccessFlags_7C_28_29I(jclass javaThis);
+
+#ifdef __OPENJDK__
+jobject Java_java_lang_Class_getAnnotation0__Ljava_lang_Class_2(JNIEnv *env, jobject klass, jobject annotationKlass);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_CLASS_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_Object.h b/src/mrt/libcore-static-binding-jni/include/java_lang_Object.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c892b6ccdccbaf3780997dc9717a462ee13a022
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_Object.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_OBJECT_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_OBJECT_H
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+using address_t = uintptr_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_OBJECT_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_String.h b/src/mrt/libcore-static-binding-jni/include/java_lang_String.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a065ff7f9fa27ade7e9e882b5705afc9c4d36fa
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_String.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_STRING_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_STRING_H
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __OPENJDK__
+void Java_java_lang_String_nativeGetChars__II_3CI(
+    JNIEnv *env,
+    jstring jthis,
+    jint start, // idx of 1st jchar in string to copy
+    jint end, // idx after last jchar in string to copy
+    jcharArray buffer, // dst jchar array
+    jint index);
+
+jstring Java_java_lang_String_nativeSubString__Ljava_lang_String_2II(
+    JNIEnv *env,
+    jstring jthis,
+    jstring srcStr,
+    jint start,
+    jint length);
+
+jstring Java_java_lang_String_nativeReplace__CC(JNIEnv *env, jstring jthis, jchar oldChar, jchar newChar);
+
+jint Java_java_lang_String_nativeIndexOf__Ljava_lang_String_2Ljava_lang_String_2I(
+    JNIEnv *env, jstring jthis, jstring subStr, jstring srcStr, jint fromIndex);
+
+jint Java_java_lang_String_nativeIndexOf__Ljava_lang_String_2_3CIII(
+    JNIEnv *env, jstring jthis, jstring subStr, jarray arraySrc, jint srcOffset, jint srcCount, jint fromIndex);
+
+jint Java_java_lang_String_nativeLastIndexOf__Ljava_lang_String_2Ljava_lang_String_2I(
+    JNIEnv *env, jstring jthis, jstring subStr, jstring srcStr, jint fromIndex);
+
+jint Java_java_lang_String_nativeLastIndexOf__Ljava_lang_String_2_3CIII(
+    JNIEnv *env, jstring jthis, jstring subStr, jarray arraySrc, jint srcOffset, jint srcCount, jint fromIndex);
+
+jint Java_java_lang_String_nativeCodePointAt__I(JNIEnv *env, jstring jthis, jint index);
+
+jint Java_java_lang_String_nativeCodePointBefore__I(JNIEnv *env, jstring jthis, jint index);
+
+jint Java_java_lang_String_nativeCodePointCount__II(JNIEnv *env, jstring jthis, jint beginIndex, jint endIndex);
+
+jint Java_java_lang_String_nativeOffsetByCodePoint__II(JNIEnv *env, jstring jthis, jint index, jint codePointOffset);
+#endif
+
+jchar Native_java_lang_String_charAt__I(jstring jthis, jint index);
+
+jchar JNICALL Java_java_lang_String_charAt__I(JNIEnv *env, jstring jthis, jint index);
+
+void Native_java_lang_String_setCharAt__IC(jstring java_this, jint index, jchar jch);
+
+void JNICALL Java_java_lang_String_setCharAt__IC(JNIEnv *env, jstring java_this, jint index, jchar jch);
+
+void Native_java_lang_String_getCharsNoCheck__II_3CI(
+    jstring jthis, jint start, jint end, jcharArray buffer, jint index);
+
+void JNICALL Java_java_lang_String_getCharsNoCheck__II_3CI(
+    JNIEnv *env, jstring jthis, jint start, jint end, jcharArray buffer, jint index);
+
+jcharArray Native_java_lang_String_toCharArray__(jstring jthis);
+
+jcharArray JNICALL Java_java_lang_String_toCharArray__(JNIEnv *env, jstring jthis);
+
+jstring Native_java_lang_String_fastSubstring__II(jstring jthis, jint start, jint length);
+
+jstring JNICALL Java_java_lang_String_fastSubstring__II(JNIEnv *env, jstring jthis, jint start, jint length);
+
+jstring Native_java_lang_String_intern__(jstring jthis);
+
+jstring Java_java_lang_String_intern__(JNIEnv *env, jstring jthis);
+
+jstring Native_java_lang_String_doReplace__CC(jstring jthis, jchar oldChar, jchar newChar);
+
+jstring Java_java_lang_String_doReplace__CC(JNIEnv *env, jstring jthis, jchar oldChar, jchar newChar);
+
+jint Native_java_lang_String_compareTo__Ljava_lang_String_2(jstring String_arg0, jstring String_arg1);
+
+jint Java_java_lang_String_compareTo__Ljava_lang_String_2(JNIEnv *env, jstring String_arg0, jstring String_arg1);
+
+jstring Native_java_lang_String_concat__Ljava_lang_String_2(jstring jthis, jstring jarg);
+
+jstring Java_java_lang_String_concat__Ljava_lang_String_2(JNIEnv *env, jstring jthis, jstring jarg);
+#if PLATFORM_SDK_VERSION >= 27
+
+#else
+jint Native_java_lang_String_fastIndexOf__II(jstring jthis, jint ch, jint start);
+
+jint Java_java_lang_String_fastIndexOf__II(JNIEnv *env, jstring jthis, jint ch, jint start);
+#endif
+jobject Native_java_lang_Object_clone_Ljava_lang_Object__(jobject java_this);
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_STRING_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_StringFactory.h b/src/mrt/libcore-static-binding-jni/include/java_lang_StringFactory.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5bd1fb3670148f5bd14dfba3f39d0d29548d78c
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_StringFactory.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_STRINGFACTORY_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_STRINGFACTORY_H
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jstring Native_java_lang_StringFactory_newStringFromString__Ljava_lang_String_2(jstring toCopy);
+
+jstring Java_java_lang_StringFactory_newStringFromString__Ljava_lang_String_2(
+    JNIEnv *env, jclass unused, jstring toCopy);
+
+#ifdef __OPENJDK__
+jstring Native_java_lang_StringFactory_nativeStringFromChars___3CII(jarray ja, jint i, jint i2);
+
+jstring Java_java_lang_StringFactory_nativeStringFromChars___3CII(
+    JNIEnv *env, jclass jc __attribute__((unused)), jarray ja, jint i, jint i2);
+#else
+
+// Ljava_2Flang_2FStringFactory_3B_7CnewStringFromChars_7C_28IIAC_29Ljava_2Flang_2FString_3B
+jstring Native_java_lang_StringFactory_newStringFromChars__II_3C(jint i, jint i2, jarray ja);
+
+jstring Java_java_lang_StringFactory_newStringFromChars__II_3C(JNIEnv *env, jclass jc, jint i, jint i2, jarray ja);
+#endif
+
+#ifdef __OPENJDK__
+jstring Native_java_lang_StringFactory_nativeStringFromBytes___3BIII(
+    jbyteArray javaData, jint high, jint offset, jint byteCount);
+
+jstring Java_java_lang_StringFactory_nativeStringFromBytes___3BIII(
+    JNIEnv* env, jclass unused __attribute__((unused)), jbyteArray javaData,
+    jint high, jint offset, jint byteCount);
+#endif
+
+jstring Native_java_lang_StringFactory_newStringFromBytes___3BIII(
+    jbyteArray javaData, jint high, jint offset, jint byteCount);
+
+jstring Java_java_lang_StringFactory_newStringFromBytes___3BIII(
+    JNIEnv* env, jclass unused, jbyteArray javaData, jint high, jint offset, jint byteCount);
+
+#ifdef __OPENJDK__
+jstring Java_java_lang_StringFactory_newStringFromCodePoints___3III(
+    JNIEnv *env, jclass jc __attribute__((unused)), jarray javaData, jint offset, jint count);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_STRINGFACTORY_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_System.h b/src/mrt/libcore-static-binding-jni/include/java_lang_System.h
new file mode 100644
index 0000000000000000000000000000000000000000..5cee9774f490d85d8d89fa9fb48a3286b5a1af28
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_System.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_SYSTEM_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_SYSTEM_H
+#include <jni.h>
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_SYSTEM_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_Thread.h b/src/mrt/libcore-static-binding-jni/include/java_lang_Thread.h
new file mode 100644
index 0000000000000000000000000000000000000000..3be74114b680a213974d0b42b47b09effa5abc4e
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_Thread.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_THREAD_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_THREAD_H
+#include <jni.h>
+#include "mrt_api_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+MRT_EXPORT jobject Native_Thread_currentThread();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_THREAD_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_ref_Reference.h b/src/mrt/libcore-static-binding-jni/include/java_lang_ref_Reference.h
new file mode 100644
index 0000000000000000000000000000000000000000..15495ef1b189792f9fa81ff484cba9da6df341aa
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_ref_Reference.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_REF_REFERENCE_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_REF_REFERENCE_H
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+using address_t = uintptr_t;
+
+address_t Ljava_2Flang_2Fref_2FReference_3B_7Cget_7C_28_29Ljava_2Flang_2FObject_3B(address_t javaThis);
+void Ljava_2Flang_2Fref_2FReference_3B_7Cclear_7C_28_29V(address_t javaThis);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_REF_REFERENCE_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_reflect_Array.h b/src/mrt/libcore-static-binding-jni/include/java_lang_reflect_Array.h
new file mode 100644
index 0000000000000000000000000000000000000000..efb2088c9685fb12312a89381acf3fadec829c85
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_reflect_Array.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_REFLECT_ARRAY_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_REFLECT_ARRAY_H
+#include <jni.h>
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_REFLECT_ARRAY_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_reflect_Field.h b/src/mrt/libcore-static-binding-jni/include/java_lang_reflect_Field.h
new file mode 100644
index 0000000000000000000000000000000000000000..344b2e57597f733e487b955db414ea37ab2d47b9
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_reflect_Field.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_REFLECT_FIELD_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_REFLECT_FIELD_H
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jobject Java_java_lang_reflect_Field_getNameInternal__(JNIEnv *env, jobject field);
+jobject Java_java_lang_reflect_Field_getSignatureAnnotation__(JNIEnv *env, jobject field);
+jobject Java_java_lang_reflect_Field_get__Ljava_lang_Object_2(JNIEnv *env, jobject field, jobject obj);
+jboolean Java_java_lang_reflect_Field_getBoolean__Ljava_lang_Object_2(JNIEnv *env, jobject field, jobject obj);
+jbyte Java_java_lang_reflect_Field_getByte__Ljava_lang_Object_2(JNIEnv *env, jobject field, jobject obj);
+jchar Java_java_lang_reflect_Field_getChar__Ljava_lang_Object_2(JNIEnv *env, jobject field, jobject obj);
+jshort Java_java_lang_reflect_Field_getShort__Ljava_lang_Object_2(JNIEnv *env, jobject field, jobject obj);
+jint Java_java_lang_reflect_Field_getInt__Ljava_lang_Object_2(JNIEnv *env, jobject field, jobject obj);
+jlong Java_java_lang_reflect_Field_getLong__Ljava_lang_Object_2(JNIEnv *env, jobject field, jobject obj);
+jfloat Java_java_lang_reflect_Field_getFloat__Ljava_lang_Object_2(JNIEnv *env, jobject field, jobject obj);
+jdouble Java_java_lang_reflect_Field_getDouble__Ljava_lang_Object_2(JNIEnv *env, jobject field, jobject obj);
+void Java_java_lang_reflect_Field_set__Ljava_lang_Object_2Ljava_lang_Object_2(JNIEnv *env, jobject field,
+                                                                              jobject obj, jobject obj1);
+void Java_java_lang_reflect_Field_setBoolean__Ljava_lang_Object_2Z(JNIEnv *env, jobject field,
+                                                                   jobject obj, jboolean arg2);
+void Java_java_lang_reflect_Field_setByte__Ljava_lang_Object_2B(JNIEnv *env, jobject field, jobject obj, jbyte arg2);
+void Java_java_lang_reflect_Field_setChar__Ljava_lang_Object_2C(JNIEnv *env, jobject field, jobject obj, jchar arg2);
+void Java_java_lang_reflect_Field_setShort__Ljava_lang_Object_2S(JNIEnv *env, jobject field, jobject obj, jshort arg2);
+void Java_java_lang_reflect_Field_setInt__Ljava_lang_Object_2I(JNIEnv *env, jobject field, jobject obj, jint arg2);
+void Java_java_lang_reflect_Field_setLong__Ljava_lang_Object_2J(JNIEnv *env, jobject field, jobject obj, jlong arg2);
+void Java_java_lang_reflect_Field_setFloat__Ljava_lang_Object_2F(JNIEnv *env, jobject field, jobject obj, jfloat arg2);
+void Java_java_lang_reflect_Field_setDouble__Ljava_lang_Object_2D(JNIEnv *env, jobject field,
+                                                                  jobject obj, jdouble arg2);
+jobject Java_java_lang_reflect_Field_getAnnotationNative__Ljava_lang_Class_2(JNIEnv *env, jobject field, jobject obj);
+jboolean Java_java_lang_reflect_Field_isAnnotationPresentNative__Ljava_lang_Class_2(JNIEnv *env, jobject field,
+                                                                                    jobject obj);
+jobject Java_java_lang_reflect_Field_getDeclaredAnnotations__(JNIEnv *env, jobject field);
+
+// Ljava/lang/reflect/Field;|getArtField|()J
+jlong Java_java_lang_reflect_Field_getArtField__(JNIEnv *env, jobject field);
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_REFLECT_FIELD_H
diff --git a/src/mrt/libcore-static-binding-jni/include/java_lang_reflect_Method.h b/src/mrt/libcore-static-binding-jni/include/java_lang_reflect_Method.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b242dc6b4e8c63652d2a61ab44c0359461ea113
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/java_lang_reflect_Method.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_JAVA_LANG_REFLECT_METHOD_H
+#define MAPLE_RUNTIME_NATIVE_JAVA_LANG_REFLECT_METHOD_H
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+// public native Object invoke(Object obj, Object... args)
+jobject Java_java_lang_reflect_Method_invoke__Ljava_lang_Object_2_3Ljava_lang_Object_2(JNIEnv *env, jobject javaThis,
+                                                                                       jobject obj, jarray arrayObj);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_JAVA_LANG_REFLECT_METHOD_H
diff --git a/src/mrt/libcore-static-binding-jni/include/libcore_util_CharsetUtils.h b/src/mrt/libcore-static-binding-jni/include/libcore_util_CharsetUtils.h
new file mode 100644
index 0000000000000000000000000000000000000000..5776ddb8b9307bf3191162e7f121d9ec0a6e96f9
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/libcore_util_CharsetUtils.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_LIBCORE_UTIL_CHARSETUTILS_H
+#define MAPLE_RUNTIME_NATIVE_LIBCORE_UTIL_CHARSETUTILS_H
+#include <jni.h>
+#include "mrt_api_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+MRT_EXPORT void Java_libcore_util_CharsetUtils_asciiBytesToChars___3BII_3C(JNIEnv *env,
+    jclass unused, jbyteArray javaBytes, jint offset, jint length, jcharArray javaChars);
+
+MRT_EXPORT void Java_libcore_util_CharsetUtils_isoLatin1BytesToChars___3BII_3C(JNIEnv *env,
+    jclass unused, jbyteArray javaBytes, jint offset, jint length, jcharArray javaChars);
+
+MRT_EXPORT jbyteArray Java_libcore_util_CharsetUtils_toAsciiBytes__Ljava_lang_String_2II(JNIEnv *env,
+    jclass unused, jstring java_string, jint offset, jint length);
+
+MRT_EXPORT jbyteArray Java_libcore_util_CharsetUtils_toIsoLatin1Bytes__Ljava_lang_String_2II(JNIEnv *env,
+    jclass unused, jstring java_string, jint offset, jint length);
+
+MRT_EXPORT jbyteArray Java_libcore_util_CharsetUtils_toUtf8Bytes__Ljava_lang_String_2II(JNIEnv *env,
+    jclass unused, jstring java_string, jint offset, jint length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MAPLE_RUNTIME_NATIVE_LIBCORE_UTIL_CHARSETUTILS_H
diff --git a/src/mrt/libcore-static-binding-jni/include/native_binding_utils.h b/src/mrt/libcore-static-binding-jni/include/native_binding_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d275c3f343dedd20e01d8cf326ef32b97dec461
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/include/native_binding_utils.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NATIVE_NATIVE_BINDING_UTILS_H
+#define MAPLE_RUNTIME_NATIVE_NATIVE_BINDING_UTILS_H
+#include <jni.h>
+
+#endif // MAPLE_RUNTIME_NATIVE_NATIVE_BINDING_UTILS_H
diff --git a/src/mrt/libcore-static-binding-jni/src/com_android_internal_util_ArrayUtils.cpp b/src/mrt/libcore-static-binding-jni/src/com_android_internal_util_ArrayUtils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..75e3f9e2b89869d9c9e85f18dfd0f8c01c5c4dd5
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/com_android_internal_util_ArrayUtils.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "com_android_internal_util_ArrayUtils.h"
+#include "exception/mrt_exception.h"
+#include "mrt_array.h"
+#include "libs.h"
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define Native_newUnpaddedArray(type1, type2, type3, type4, type5) jobject \
+    Native_Lcom_2Fandroid_2Finternal_2Futil_2FArrayUtils_3B_7CnewUnpadded##type5##Array_7C_28I_29A##type1( \
+    jint length) { \
+  if (UNLIKELY(length < 0)) { \
+    MRT_ThrowNewExceptionUnw("java/lang/NegativeArraySizeException", std::to_string(length).c_str()); \
+    return nullptr; \
+  } \
+  type2 array = reinterpret_cast<type2>(MRT_NewPrimitiveArray(length, type3, sizeof(type4))); \
+  return array; \
+}
+
+MRT_EXPORT Native_newUnpaddedArray(B, jbyteArray, maple::Primitive::kByte, jbyte, Byte)
+MRT_EXPORT Native_newUnpaddedArray(C, jcharArray, maple::Primitive::kChar, jchar, Char)
+MRT_EXPORT Native_newUnpaddedArray(I, jintArray, maple::Primitive::kInt, jint, Int)
+MRT_EXPORT Native_newUnpaddedArray(Z, jbooleanArray, maple::Primitive::kBoolean, jboolean, Boolean)
+MRT_EXPORT Native_newUnpaddedArray(J, jlongArray, maple::Primitive::kLong, jlong, Long)
+MRT_EXPORT Native_newUnpaddedArray(F, jfloatArray, maple::Primitive::kFloat, jfloat, Float)
+
+MRT_EXPORT jobject Native_Lcom_2Fandroid_2Finternal_2Futil_2FArrayUtils_3B_7CnewUnpaddedObjectArray_7C_28I_29ALjava_2Flang_2FObject_3B(
+    jclass javaElementClass, jint length) {
+  if (UNLIKELY(length < 0)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NegativeArraySizeException", std::to_string(length).c_str());
+    return nullptr;
+  }
+  if (UNLIKELY(javaElementClass == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "element class == null");
+    return nullptr;
+  }
+  jobject array = MRT_NewObjArray(length, javaElementClass, nullptr);
+  return array;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/java_io_File.cpp b/src/mrt/libcore-static-binding-jni/src/java_io_File.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ab1d747f5fcefb77b78d4e56a009620375e7e6bc
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_io_File.cpp
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java2c_rule.h"
+#include "java_io_File.h"
+#include "mstring_inline.h"
+#include "chelper.h"
+using namespace maplert;
+
+template<typename Type>
+uint32_t NormalizeConvert(uint32_t count, MString *&newObj, const MString &pathName){
+  Type prevChar = 0;
+  uint32_t index = 0;
+
+  Type *newSrc = nullptr;
+  bool startCopy = false;
+  Type *src = reinterpret_cast<Type*>(pathName.GetContentsPtr());
+  for (uint32_t i = 0; i < count; ++i) {
+    const Type current = src[i];
+    // Remove duplicate slashes.
+    if ((current == '/' && prevChar == '/')) {
+      if (newObj == nullptr) {
+        newObj = MString::NewStringObject<Type>(count, [](MString&) { });
+        newSrc = reinterpret_cast<Type*>(newObj->GetContentsPtr());
+        size_t typeWidth = sizeof(Type);
+        if (memcpy_s(newSrc, count * typeWidth, src, (i + 1) * typeWidth) != EOK) {
+          LOG(ERROR) << "NormalizeConvert not return EOK";
+          return 0;
+        }
+        startCopy = true;
+        index = i;
+      }
+    } else if(startCopy) {
+      newSrc[index++] = src[i];
+    }
+    prevChar = current;
+  }
+  // Omit the trailing slash, except when pathname == "/".
+  if (prevChar == '/' && count > 1) {
+    if (newObj == nullptr) {
+      newObj = MString::NewStringObject<Type>(count, [](MString&) { });
+      newSrc = reinterpret_cast<Type*>(newObj->GetContentsPtr());
+      size_t typeWidth = sizeof(Type);
+      if (memcpy_s(newSrc, count * typeWidth, src, (count - 1) * typeWidth) != EOK) {
+        LOG(ERROR) << "NormalizeConvert not return EOK";
+        return 0;
+      }
+      index = count - 1;
+    } else {
+      --index;
+    }
+  }
+  uint32_t res = (index != 0) ? index : count;
+  return res;
+}
+
+extern "C" jboolean Java_libcore_io_Linux_access__Ljava_lang_String_2I(const JNIEnv *env, jobject,
+                                                                       const jstring javaPath, jint mode) {
+  if (UNLIKELY(javaPath == nullptr) || UNLIKELY(env == nullptr)) {
+    return JNI_FALSE;
+  }
+  std::string path = (reinterpret_cast<MString*>(javaPath))->GetChars();
+  int rc = access(path.c_str(), mode);
+  return static_cast<jboolean>(rc == 0);
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+MRT_EXPORT jstring Native_Ljava_2Fio_2FUnixFileSystem_3B_7Cnormalize_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B(
+    __attribute__((unused))jobject jthis, jstring pathName) {
+  maplert::Java2CRule j2cRule(INIT_ARGS);
+  MString *pathNameObj = MString::JniCastNonNull(pathName);
+  uint32_t count = pathNameObj->GetLength();
+  uint32_t index = 0;
+  MString *newObj = nullptr;
+  if (pathNameObj->IsCompress()) {
+    index = NormalizeConvert<uint8_t>(count, newObj, *pathNameObj);
+    if (index != count) {
+      newObj->SetCountValue((index << 1) | 1);
+      j2cRule.Epilogue();
+      return reinterpret_cast<jstring>(newObj);
+    }
+  } else {
+    index = NormalizeConvert<uint16_t>(count, newObj, *pathNameObj);
+    if (index != count) {
+      newObj->SetCountValue(index << 1);
+      j2cRule.Epilogue();
+      return reinterpret_cast<jstring>(newObj);
+    }
+  }
+  // if exception happen, it will unwinder directly.
+  j2cRule.Epilogue();
+  RC_LOCAL_INC_REF(pathName);
+  return pathName;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_Class.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_Class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4684f99e96b0595a80ba97274b596db9b6b9e581
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_Class.cpp
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_Class.h"
+#include "mrt_reflection_class.h"
+#include "mrt_reflection_api.h"
+#include "mrt_class_api.h"
+#include "mclass_inline.h"
+#include "mstring_inline.h"
+#include "java2c_rule.h"
+#include "cpphelper.h"
+#include "mclass_inline.h"
+using namespace maplert;
+// static-binding native:
+// 1. use c function rewrite java function, especially some class.java methods which reference class object fields,
+//   as maple class object's layout is deferent from class object's layout defined in class.java.
+//   c function:
+//   void Ljava_2Ffoo() {
+//     Java2CRule j2cRule(INIT_ARGS)
+//     doImplement()
+//     j2cRule.Epilogue()
+//   }
+//   NOTE: (1) if implement new native method, need add to maplert/include/reflection_list.def list
+//
+// 2. java native methods which are defined by java native. especially reflect, string native methods.
+//   jobject Java_foo(JNIEnv *env, jobject thisObj) {
+//     ScopedObjectAccess soa
+//     jobject o = doImplement()
+//     return MRT_JNI_AddLocalReference(env, o)
+//   }
+//   NOTE: (1) if implement new native method, need add to libcore-static-binding-jni/etc/static-binding-list.txt list,
+//             to improve static-binding native stub performance .
+//         (2) env maybe nullptr, as maple optimise static-binding native stub. static-binding native stub only keep
+//             ecxeption check. and pre/post nativecall, decode object operation are deleted, also in native do not
+//             encode object if return value is object.
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jobject Java_java_lang_Class_newInstance__(JNIEnv *env, jobject thisClass) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MObject *newObject = ReflectClassNewInstance(*klass);
+  return MRT_JNI_AddLocalReference(env, reinterpret_cast<jobject>(newObject));
+}
+
+// Ljava/lang/Class;|isAssignableFrom|(Ljava/lang/Class;)Z
+jboolean Ljava_2Flang_2FClass_3B_7CisAssignableFrom_7C_28Ljava_2Flang_2FClass_3B_29Z(jclass javaThis, jclass cls) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *thisClass = MClass::JniCastNonNull(javaThis);
+  MClass *targetClass = MClass::JniCast(cls);
+  if (targetClass == nullptr) {
+    MRT_ThrowNullPointerException();
+    j2cRule.Epilogue();
+    return JNI_FALSE;
+  }
+  // no exception happen.
+  bool ret = thisClass->IsAssignableFrom(*targetClass);
+  return ret ? JNI_TRUE : JNI_FALSE;
+}
+
+// Ljava/lang/Class;|isInterface|()Z
+jboolean Ljava_2Flang_2FClass_3B_7CisInterface_7C_28_29Z(const jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  const MClass *klass = MClass::JniCastNonNull(javaThis);
+  bool ret = klass->IsInterface();
+  j2cRule.Epilogue();
+  return ret;
+}
+
+// Ljava/lang/Class;|isPrimitive|()Z
+jboolean Ljava_2Flang_2FClass_3B_7CisPrimitive_7C_28_29Z(const jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  const MClass *klass = MClass::JniCastNonNull(javaThis);
+  bool ret = klass->IsPrimitiveClass();
+  j2cRule.Epilogue();
+  return ret;
+}
+
+#ifndef __OPENJDK__
+// Ljava/lang/Class;|getName|()Ljava/lang/String;
+jobject Ljava_2Flang_2FClass_3B_7CgetName_7C_28_29Ljava_2Flang_2FString_3B(jclass javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  jobject ret = MRT_ReflectClassGetName(javaThis);
+  j2cRule.Epilogue();
+  return ret;
+}
+
+jboolean Ljava_2Flang_2FClass_3B_7CisLocalClass_7C_28_29Z(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  bool ret = ReflectClassIsLocalClass(*klass);
+  j2cRule.Epilogue();
+  return ret;
+}
+
+jboolean Ljava_2Flang_2FClass_3B_7CisMemberClass_7C_28_29Z(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  bool ret = ReflectClassIsMemberClass(*klass);
+  j2cRule.Epilogue();
+  return ret;
+}
+#endif // __OPENJDK__
+
+jobject Java_java_lang_Class_getNameNative__(JNIEnv *env, jclass javaThis) {
+  ScopedObjectAccess soa;
+  return MRT_JNI_AddLocalReference(env, MRT_ReflectClassGetName(javaThis));
+}
+
+// Ljava/lang/Class;|getClassLoader|()Ljava/lang/ClassLoader;
+jobject Ljava_2Flang_2FClass_3B_7CgetClassLoader_7C_28_29Ljava_2Flang_2FClassLoader_3B(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  if (klass->IsPrimitiveClass()) {
+    return 0;
+  }
+  MObject *ret = ReflectClassGetClassLoader(*klass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+#ifdef __OPENJDK__
+// Ljava/lang/Class;|getClassLoader|()Ljava/lang/ClassLoader;
+jobject Ljava_2Flang_2FClass_3B_7CgetClassLoader0_7C_28_29Ljava_2Flang_2FClassLoader_3B(jobject javaThis) {
+  return Ljava_2Flang_2FClass_3B_7CgetClassLoader_7C_28_29Ljava_2Flang_2FClassLoader_3B(javaThis);
+}
+#endif // __OPENJDK__
+
+#if PLATFORM_SDK_VERSION >= 27
+jobject Java_java_lang_Class_getPrimitiveClass__Ljava_lang_String_2(JNIEnv*, jobject javaThis, jobject name) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MString *className = MString::JniCast(name);
+  MObject *ret = ReflectClassGetPrimitiveClass(*klass, className);
+  return ret->AsJobject();
+}
+#endif
+
+// Ljava/lang/Class;|getSuperclass|()Ljava/lang/Class;
+jobject Ljava_2Flang_2FClass_3B_7CgetSuperclass_7C_28_29Ljava_2Flang_2FClass_3B(jclass javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  jclass ret = MRT_ReflectClassGetSuperClass(javaThis);
+  j2cRule.Epilogue();
+  return ret;
+}
+
+// Ljava/lang/Class;|getInterfaces|()ALjava/lang/Class;
+jobject Ljava_2Flang_2FClass_3B_7CgetInterfaces_7C_28_29ALjava_2Flang_2FClass_3B(jclass javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  jobjectArray ret = MRT_ReflectClassGetInterfaces(javaThis);
+  j2cRule.Epilogue();
+  return ret;
+}
+
+jobject Java_java_lang_Class_getInterfacesInternal__(JNIEnv *env, jobject thisClass) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MObject *ret = ReflectClassGetInterfacesInternal(*klass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/Class;|getComponentType|()Ljava/lang/Class;
+jobject Ljava_2Flang_2FClass_3B_7CgetComponentType_7C_28_29Ljava_2Flang_2FClass_3B(const jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *ret = MClass::JniCastNonNull(javaThis)->GetComponentClass();
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+// Ljava/lang/Class;|getModifiers|()I
+jint Ljava_2Flang_2FClass_3B_7CgetModifiers_7C_28_29I(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  int32_t ret = MRT_ReflectClassGetModifiers(reinterpret_cast<jclass>(javaThis));
+  j2cRule.Epilogue();
+  return ret;
+}
+
+jint Java_java_lang_Class_getInnerClassFlags__I(JNIEnv*, jobject javaThis, jint) {
+  ScopedObjectAccess soa;
+  return MRT_ReflectClassGetModifiers(reinterpret_cast<jclass>(javaThis));
+}
+
+
+// java_lang_Class_getEnclosingMethodNative
+jobject Java_java_lang_Class_getEnclosingMethodNative__(JNIEnv *env, jobject javaThis) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetEnclosingMethodNative(*klass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jobject Java_java_lang_Class_getEnclosingConstructorNative__(JNIEnv *env, jobject javaThis) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetEnclosingConstructorNative(*klass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jobject Java_java_lang_Class_getDeclaringClass__(JNIEnv *env, jclass cls) {
+  ScopedObjectAccess soa;
+  jclass ret = MRT_ReflectClassGetDeclaringClass(cls);
+  return MRT_JNI_AddLocalReference(env, ret);
+}
+
+jobject Java_java_lang_Class_getEnclosingClass__(JNIEnv *env, jobject javaThis) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetEnclosingClass(*klass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jboolean Java_java_lang_Class_isAnonymousClass__(JNIEnv*, jobject javaThis) {
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  return klass->IsAnonymousClass();
+}
+
+// Ljava/lang/Class;|getClasses|()ALjava/lang/Class;
+jobject Ljava_2Flang_2FClass_3B_7CgetClasses_7C_28_29ALjava_2Flang_2FClass_3B(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetClasses(*klass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+// Ljava/lang/Class;|getFields|()ALjava/lang/reflect/Field;
+jobject Ljava_2Flang_2FClass_3B_7CgetFields_7C_28_29ALjava_2Flang_2Freflect_2FField_3B(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetFields(*klass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+// Ljava/lang/Class;|getMethods|()ALjava/lang/reflect/Method;
+jobject Ljava_2Flang_2FClass_3B_7CgetMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetMethods(*klass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+// Ljava/lang/Class;|getConstructors|()ALjava/lang/reflect/Constructor;
+jobject Ljava_2Flang_2FClass_3B_7CgetConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetConstructors(*klass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+// Ljava/lang/Class;|getField|(Ljava/lang/String;)Ljava/lang/reflect/Field;
+jobject Ljava_2Flang_2FClass_3B_7CgetField_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2Freflect_2FField_3B(
+    jobject javaThis, jobject name) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MString *fieldName = MString::JniCast(name);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetField(*klass, fieldName);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+// Ljava/lang/Class;|getMethod|(Ljava/lang/String;ALjava/lang/Class;)Ljava/lang/reflect/Method;
+jobject Ljava_2Flang_2FClass_3B_7CgetMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B(
+    jobject javaThis, jobject name, jobject parameterTypes) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MString *methodName = MString::JniCast(name);
+  MArray *arrayClass = MArray::JniCast(parameterTypes);
+  MObject *ret = ReflectClassGetMethod(*klass, methodName, arrayClass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+// Ljava/lang/Class;|getConstructor|(ALjava/lang/Class;)Ljava/lang/reflect/Constructor;
+jobject Ljava_2Flang_2FClass_3B_7CgetConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B(
+    jobject javaThis, jobject parameterTypes) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MArray *arrayClass = MArray::JniCast(parameterTypes);
+  MObject *ret = ReflectClassGetConstructor(*klass, arrayClass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+jobject Java_java_lang_Class_getDeclaredClasses__(JNIEnv *env, jclass cls) {
+  ScopedObjectAccess soa;
+  jobjectArray ret = MRT_ReflectClassGetDeclaredClasses(cls);
+  return MRT_JNI_AddLocalReference(env, ret);
+}
+
+jobject Java_java_lang_Class_getDeclaredFields__(JNIEnv *env, jobject thisClass) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MObject *ret = ReflectClassGetDeclaredFields(*klass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jobject Java_java_lang_Class_getDeclaredFieldsUnchecked__Z(JNIEnv *env, jobject thisClass, jboolean publicOnly) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MObject *ret = ReflectClassGetDeclaredFieldsUnchecked(*klass, publicOnly == JNI_TRUE);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+void Ljava_2Flang_2FClass_3B_7CgetPublicFieldsRecursive_7C_28Ljava_2Futil_2FList_3B_29V(
+    jobject thisClass, jobject listObject) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MObject *listObj = MObject::JniCast(listObject);
+  ReflectClassGetPublicFieldsRecursive(*klass, listObj);
+  j2cRule.Epilogue();
+}
+
+jobject Java_java_lang_Class_getPublicFieldRecursive__Ljava_lang_String_2(
+    JNIEnv *env, jobject thisClass, jobject fieldName) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MString *name = MString::JniCast(fieldName);
+  MObject *ret =  ReflectClassGetPublicFieldRecursive(*klass, name);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/Class;|getDeclaredMethods|()ALjava/lang/reflect/Method;
+jobject Ljava_2Flang_2FClass_3B_7CgetDeclaredMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetDeclaredMethods(*klass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+jobject Java_java_lang_Class_getDeclaredMethodsUnchecked__Z(JNIEnv *env, jobject thisClass, jboolean publicOnly) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MObject *ret = ReflectClassGetDeclaredMethodsUnchecked(*klass, publicOnly == JNI_TRUE);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/Class;|getDeclaredConstructors|()ALjava/lang/reflect/Constructor;
+jobject Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B(
+    jobject thisClass) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MObject *ret = ReflectClassGetDeclaredConstructors(*klass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+jobject Java_java_lang_Class_getDeclaredConstructorsInternal__Z(JNIEnv *env, jobject thisClass, jboolean publicOnly) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MObject *ret = ReflectClassGetDeclaredConstructorsInternal(*klass, publicOnly == JNI_TRUE);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jobject Java_java_lang_Class_getDeclaredField__Ljava_lang_String_2(JNIEnv *env, jobject thisClass, jobject s) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MString *fieldName = MString::JniCast(s);
+  MObject *ret = ReflectClassGetDeclaredField(*klass, fieldName);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jobject Java_java_lang_Class_getPublicDeclaredFields__(JNIEnv *env, jobject thisClass) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(thisClass);
+  MObject *ret = ReflectClassGetPublicDeclaredFields(*klass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/Class;|getDeclaredMethod|(Ljava/lang/String;ALjava/lang/Class;)
+// Ljava/lang/reflect/Method;
+jobject Ljava_2Flang_2FClass_3B_7CgetDeclaredMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B(
+    jobject javaThis, jobject name, jobject parameterTypes) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MString *methodName = MString::JniCast(name);
+  MArray *arrayClass = MArray::JniCast(parameterTypes);
+  MObject *ret = ReflectClassGetDeclaredMethod(*klass, methodName, arrayClass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+void Ljava_2Flang_2FClass_3B_7CgetPublicMethodsInternal_7C_28Ljava_2Futil_2FList_3B_29V(
+    jobject javaThis, jobject listObject) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *listObj = MObject::JniCast(listObject);
+  ReflectClassGetPublicMethodsInternal(*klass, listObj);
+  j2cRule.Epilogue();
+}
+
+// Ljava/lang/Class;|getInstanceMethod|(Ljava/lang/String;ALjava/lang/Class;)
+// Ljava/lang/reflect/Method;
+jobject Ljava_2Flang_2FClass_3B_7CgetInstanceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B(
+    jobject javaThis, jobject name, jobject parameterTypes) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MString *methodName = MString::JniCast(name);
+  MArray *arrayClass = MArray::JniCast(parameterTypes);
+  MObject *ret = ReflectClassGetInstanceMethod(*klass, methodName, arrayClass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+jobject Ljava_2Flang_2FClass_3B_7CfindInterfaceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B(
+    jobject javaThis, jobject name, jobject parameterTypes) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MString *methodName = MString::JniCast(name);
+  MArray *arrayClass = MArray::JniCast(parameterTypes);
+  MObject *ret = ReflectClassFindInterfaceMethod(*klass, methodName, arrayClass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+jobject Java_java_lang_Class_getDeclaredMethodInternal__Ljava_lang_String_2_3Ljava_lang_Class_2(
+    JNIEnv *env, jobject javaThis, jobject name, jobject parameterTypes) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MString *methodName = MString::JniCast(name);
+  MArray *arrayClass = MArray::JniCast(parameterTypes);
+  MObject *ret = ReflectClassGetDeclaredMethodInternal(*klass, methodName, arrayClass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jobject Java_java_lang_Class_getDeclaredConstructorInternal___3Ljava_lang_Class_2(
+    JNIEnv *env, jobject javaThis, jobject parameterTypes) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MArray *arrayClass = MArray::JniCast(parameterTypes);
+  MObject *ret = ReflectClassGetDeclaredConstructorInternal(*klass, arrayClass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/Class;|getDeclaredConstructor|(ALjava/lang/Class;)Ljava/lang/reflect/Constructor;
+jobject Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B(
+    jobject javaThis, jobject parameterTypes) {
+  Java2CRule j2cRule(INIT_ARGS);
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MArray *arrayClass = MArray::JniCast(parameterTypes);
+  MObject *ret = ReflectClassGetDeclaredConstructor(*klass, arrayClass);
+  j2cRule.Epilogue();
+  return ret->AsJobject();
+}
+
+jobject Java_java_lang_Class_getInnerClassName__(JNIEnv *env, jobject javaThis) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetInnerClassName(*klass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jobject Java_java_lang_Class_getDeclaredAnnotation__Ljava_lang_Class_2(
+    JNIEnv *env, jobject javaThis, jobject annoCls) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MClass *annoClass = MClass::JniCast(annoCls);
+  MObject *ret = ReflectClassGetDeclaredAnnotation(*klass, annoClass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jobject Java_java_lang_Class_getDeclaredAnnotations__(JNIEnv *env, jclass cls) {
+  ScopedObjectAccess soa;
+  jobject ret = MRT_ReflectClassGetDeclaredAnnotations(cls);
+  return MRT_JNI_AddLocalReference(env, ret);
+}
+
+jboolean Java_java_lang_Class_isDeclaredAnnotationPresent__Ljava_lang_Class_2(
+    JNIEnv*, jobject javaThis, jobject annoCls) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *annoClass = MObject::JniCast(annoCls);
+  bool ret = ReflectClassIsDeclaredAnnotationPresent(*klass, annoClass);
+  return ret;
+}
+
+jobject Java_java_lang_Class_getSignatureAnnotation__(JNIEnv *env, jobject javaThis) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MObject *ret = ReflectClassGetSignatureAnnotation(*klass);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/Class;|isProxy|()Z
+jboolean Ljava_2Flang_2FClass_3B_7CisProxy_7C_28_29Z(jobject javaThis) {
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  bool isProxy = klass->IsProxy();
+  return isProxy;
+}
+
+// Ljava/lang/Class;|getAccessFlags|()I
+jint Ljava_2Flang_2FClass_3B_7CgetAccessFlags_7C_28_29I(jclass javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  jint ret = MRT_ReflectClassGetAccessFlags(javaThis);
+  j2cRule.Epilogue();
+  return ret;
+}
+
+#ifdef __OPENJDK__
+// native interface specific to openJDK. libcore should also be able to use this.
+// return an Annotation
+jobject Java_java_lang_Class_getAnnotation0__Ljava_lang_Class_2(JNIEnv *env, jobject javaThis, jobject annKlass) {
+  ScopedObjectAccess soa;
+  MClass *klass = MClass::JniCastNonNull(javaThis);
+  MClass *cls = MClass::JniCast(annKlass);
+  MObject *ret = ReflectClassGetAnnotation(*klass, cls);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+#endif // __OPENJDK__
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_Object.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_Object.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5d00cff0412b6de4186d054fccd6f689b8940d1a
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_Object.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_Object.h"
+#include "java2c_rule.h"
+#include "object_base.h"
+#include "mrt_monitor_api.h"
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jobject Java_java_lang_Object_internalClone__(JNIEnv *env, jobject obj) {
+  return MRT_JNI_AddLocalReference(env, MRT_CloneJavaObject(obj));
+}
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_String.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_String.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7525571adcefe523e6af304f90e7a42ae274a37e
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_String.cpp
@@ -0,0 +1,600 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_String.h"
+#include <cstdio>
+#include <unistd.h>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <unordered_map>
+#include "securec.h"
+#include "mstring_inline.h"
+#include "libs.h"
+#include "exception/mrt_exception.h"
+#include "mrt_monitor_api.h"
+#include "java2c_rule.h"
+using namespace std;
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+MRT_EXPORT jchar Native_java_lang_String_charAt__I(jstring jthis, jint index) {
+  MString *stringObj = MString::JniCast(jthis);
+  if (UNLIKELY(stringObj == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return 0;
+  }
+  int32_t len = static_cast<int32_t>(stringObj->GetLength());
+  if (index < 0 || index >= len) {
+    char msg[50] = { 0 };  // message size is 50, buffer size 45
+    if (snprintf_s(msg, sizeof(msg), 45, "length=%d; index=%d", len, index) < 0) {
+      return 0;
+    }
+    MRT_ThrowNewExceptionUnw("java/lang/StringIndexOutOfBoundsException", msg);
+    return 0;
+  }
+  return stringObj->CharAt(static_cast<uint32_t>(index));
+}
+
+jchar Java_java_lang_String_charAt__I(JNIEnv*, jstring jthis, jint index) {
+  MString *stringObj = MString::JniCast(jthis);
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return 0;
+  }
+
+  int32_t len = static_cast<int32_t>(stringObj->GetLength());
+  if (index < 0 || index >= len) {
+    char msg[50] = { 0 };  // message size is 50, buffer size 45
+    if (snprintf_s(msg, sizeof(msg), 45, "length=%d; index=%d", len, index) < 0) {
+      MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException");
+      return 0;
+    }
+    MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException", msg);
+    return 0;
+  }
+  return stringObj->CharAt(static_cast<uint32_t>(index));
+}
+
+// getChars without bounds checks, for use by other classes
+// within the java.lang package only.  The caller is responsible for
+// ensuring that start >= 0 && start <= end && end <= count.
+//
+// native void getCharsNoCheck(int start, int end, char[] buffer, int index)
+// Ljava_2Flang_2FString_3B_7CgetCharsNoCheck_7C_28IIACI_29V
+static void local_String_getCharsNoCheck(jstring jstr, jint start, jint end, jcharArray buffer, jint index) {
+  MArray *mArray = reinterpret_cast<MArray*>(buffer);
+  jchar *dst = reinterpret_cast<jchar*>(mArray->ConvertToCArray()) + index;
+  MString *stringObj = MString::JniCastNonNull(jstr);
+  if (stringObj->IsCompress()) {
+    const uint8_t *src = stringObj->GetContentsPtr() + start;
+    for (jint i = start; i < end; ++i) {
+      *dst++ = *src++;
+    }
+  } else {
+    uint16_t *src = reinterpret_cast<uint16_t*>(stringObj->GetContentsPtr()) + start;
+    size_t memcpyLen = static_cast<size_t>(end - start) * sizeof(uint16_t);
+    if (memcpyLen == 0) {
+      return;
+    }
+
+    if (memcpy_s(dst, memcpyLen, src, memcpyLen) != EOK) {
+      LOG(ERROR) << "In local_String_getCharsNoCheck Function memcpy_s() return wrong" << maple::endl;
+    }
+  }
+}
+
+MRT_EXPORT void Native_java_lang_String_getCharsNoCheck__II_3CI(
+    jstring jthis,
+    jint start,         // idx of 1st jchar in string to copy
+    jint end,           // idx after last jchar in string to copy
+    jcharArray buffer,  // dst jchar array
+    jint index) {       // start offset in dst to copy to
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return;
+  }
+  local_String_getCharsNoCheck(jthis, start, end, buffer, index);
+}
+
+void Java_java_lang_String_getCharsNoCheck__II_3CI(
+    JNIEnv*,
+    jstring jthis,
+    jint start,         // idx of 1st jchar in string to copy
+    jint end,           // idx after last jchar in string to copy
+    jcharArray buffer,  // dst jchar array
+    jint index) {       // start offset in dst to copy to
+  local_String_getCharsNoCheck(jthis, start, end, buffer, index);
+}
+
+/*
+ * Converts this string to a new character array.
+ *
+ * @return  a newly allocated character array whose length is the length
+ *          of this string and whose contents are initialized to contain
+ *          the character sequence represented by this string.
+ */
+// public native char[] toCharArray()
+// Ljava_2Flang_2FString_3B_7CtoCharArray_7C_28_29AC
+static jcharArray local_String_toCharArray(jstring jstr) {
+  MString *stringObj = MString::JniCastNonNull(jstr);
+  int32_t len = static_cast<int32_t>(stringObj->GetLength());
+  jcharArray charArray = reinterpret_cast<jcharArray>(MArray::NewPrimitiveArray<kElemHWord>(static_cast<uint32_t>(len),
+      *WellKnown::GetPrimitiveArrayClass(maple::Primitive::kChar)));
+  if (charArray != nullptr) {
+    const char *src = reinterpret_cast<char*>(stringObj->GetContentsPtr());
+    jchar *dst = reinterpret_cast<jchar*>(reinterpret_cast<MArray*>(charArray)->ConvertToCArray());
+    if (stringObj->IsCompress()) {
+      for (jint i = 0; i < len; i++) {
+        dst[i] = src[i];
+      }
+    } else {
+      uint32_t cpyLen = static_cast<unsigned int>(len) << 1;
+      if (cpyLen == 0) {
+        return charArray;
+      }
+
+      if (memcpy_s(dst, cpyLen, src, cpyLen) != EOK) {
+        LOG(ERROR) << "In local_String_toCharArray Function memcpy_s() return wrong" << maple::endl;
+      }
+    }
+  }
+  return charArray;
+}
+
+MRT_EXPORT jcharArray Native_java_lang_String_toCharArray__(jstring jthis) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  jcharArray charArray;
+
+  charArray = local_String_toCharArray(jthis);
+  if (charArray == nullptr) {
+    MRT_CheckThrowPendingExceptionUnw();
+  }
+  return charArray;
+}
+
+jcharArray Java_java_lang_String_toCharArray__(JNIEnv *env, jstring jthis) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  ScopedObjectAccess soa;
+  jcharArray chararray;
+
+  chararray = local_String_toCharArray(jthis);
+  return reinterpret_cast<jcharArray>(MRT_JNI_AddLocalReference(env, chararray));
+}
+
+MRT_EXPORT jstring Native_java_lang_String_fastSubstring__II(jstring jthis, jint start, jint length) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  jstring subStr = reinterpret_cast<jstring>(StringNewStringFromSubstring(
+      *reinterpret_cast<MString*>(jthis), start, static_cast<uint32_t>(length)));
+  return subStr;
+}
+
+jstring Java_java_lang_String_fastSubstring__II(
+    JNIEnv *env,
+    jstring jthis,
+    jint start,
+    jint length) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  ScopedObjectAccess soa;
+  jstring subStr = reinterpret_cast<jstring>(StringNewStringFromSubstring(
+      *reinterpret_cast<MString*>(jthis), start, static_cast<uint32_t>(length)));
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, subStr));
+}
+
+static jint local_String_compareTo(jstring jthis, jstring jarg) {
+  if (jthis == jarg) {
+    return 0;
+  }
+  MString *thisStringObj = MString::JniCastNonNull(jthis);
+  MString *annotherStringObj = MString::JniCastNonNull(jarg);
+  int32_t lenThis = static_cast<int32_t>(thisStringObj->GetLength());
+  int32_t lenArg = static_cast<int32_t>(annotherStringObj->GetLength());
+
+  int len = (lenThis > lenArg) ? lenArg : lenThis;
+
+  uint8_t *srcThis = thisStringObj->GetContentsPtr();
+  uint8_t *srcArg = annotherStringObj->GetContentsPtr();
+
+  bool thisCompress = thisStringObj->IsCompress();
+  bool argCompress = annotherStringObj->IsCompress();
+  if (thisCompress && argCompress) {
+    int i = 0;
+    for (int j = 0; j < len; ++j) {
+      if (srcThis[i] == srcArg[i]) {
+        ++i;
+        continue;
+      }
+      return srcThis[i] - srcArg[i];
+    }
+  } else if (thisCompress || argCompress) {
+    uint8_t *compressChars = nullptr;
+    uint16_t *uncompressChars = nullptr;
+    if (thisCompress) {
+      compressChars = srcThis;
+      uncompressChars = reinterpret_cast<uint16_t*>(srcArg);
+    } else {
+      compressChars = srcArg;
+      uncompressChars = reinterpret_cast<uint16_t*>(srcThis);
+    }
+    for (int i = 0; i < len; ++i) {
+      if (uncompressChars[i] != static_cast<jchar>(static_cast<int16_t>(compressChars[i]))) {
+        return (thisCompress) ? (static_cast<jchar>(static_cast<int16_t>(compressChars[i])) - uncompressChars[i]) :
+            (uncompressChars[i] - static_cast<jchar>(static_cast<int16_t>(compressChars[i])));
+      }
+    }
+  } else {
+    uint16_t *utf16This = reinterpret_cast<uint16_t*>(srcThis);
+    uint16_t *utf16Arg = reinterpret_cast<uint16_t*>(srcArg);
+    for (int i = 0; i < len; ++i) {
+      if (utf16This[i] == utf16Arg[i]) {
+        continue;
+      }
+      return utf16This[i] - utf16Arg[i];
+    }
+  }
+  return lenThis - lenArg;
+}
+
+MRT_EXPORT jint Native_java_lang_String_compareTo__Ljava_lang_String_2(jstring jthis, jstring jarg) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+
+  if (UNLIKELY(jarg == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "rhs == null");
+    return -1;
+  }
+
+  jint res = local_String_compareTo(jthis, jarg);
+
+  return res;
+}
+
+jint Java_java_lang_String_compareTo__Ljava_lang_String_2(JNIEnv*, jstring jthis, jstring jarg) {
+  ScopedObjectAccess soa;
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  if (UNLIKELY(jarg == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "rhs == null");
+    return -1;
+  }
+  return local_String_compareTo(jthis, jarg);
+}
+
+// func &Ljava_2Flang_2FString_3B_7Cintern_7C_28_29Ljava_2Flang_2FString_3B local native public virtual
+// (var %_this <* <$Ljava_2Flang_2FString_3B>>) <* <$Ljava_2Flang_2FString_3B>>
+MRT_EXPORT jstring Native_java_lang_String_intern__(jstring jthis) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  } else {
+    ScopedObjectAccess soa;
+    MString *stringObj = reinterpret_cast<MString*>(jthis);
+    return reinterpret_cast<jstring>(stringObj->Intern());
+  }
+}
+
+
+jstring Java_java_lang_String_intern__(JNIEnv *env, jstring jthis) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  } else {
+    ScopedObjectAccess soa;
+    jstring internStr = Native_java_lang_String_intern__(jthis);
+    return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, internStr));
+  }
+}
+
+MRT_EXPORT jstring Native_java_lang_String_doReplace__CC(jstring jthis, jchar oldChar, jchar newChar) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  jstring repStr = reinterpret_cast<jstring>(JStringDoReplace(*reinterpret_cast<MString*>(jthis), oldChar, newChar));
+  return repStr;
+}
+
+jstring Java_java_lang_String_doReplace__CC(JNIEnv *env, jstring jthis, jchar oldChar, jchar newChar) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  ScopedObjectAccess soa;
+  jstring repStr = reinterpret_cast<jstring>(JStringDoReplace(*reinterpret_cast<MString*>(jthis), oldChar, newChar));
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, repStr));
+}
+
+MRT_EXPORT jstring Native_java_lang_String_concat__Ljava_lang_String_2(jstring jthis, jstring jarg) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  if (UNLIKELY(jarg == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "string arg == null");
+    return nullptr;
+  }
+  jstring conStr = reinterpret_cast<jstring>(StringConcat(
+      *reinterpret_cast<MString*>(jthis), *reinterpret_cast<MString*>(jarg)));
+  return conStr;
+}
+
+jstring Java_java_lang_String_concat__Ljava_lang_String_2(JNIEnv *env, jstring jthis, jstring jarg) {
+  ScopedObjectAccess soa;
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+
+  if (UNLIKELY(jarg == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "string arg == null");
+    return nullptr;
+  }
+  jstring conStr = reinterpret_cast<jstring>(StringConcat(
+      *reinterpret_cast<MString*>(jthis), *reinterpret_cast<MString*>(jarg)));
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, conStr));
+}
+
+#if PLATFORM_SDK_VERSION < 27
+MRT_EXPORT jint Native_java_lang_String_fastIndexOf__II(jstring jthis, jint ch, jint start) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  return StringFastIndexOf(*reinterpret_cast<MString*>(jthis), ch, start);
+}
+
+jint Java_java_lang_String_fastIndexOf__II(JNIEnv*, jstring jthis, jint ch, jint start) {
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  return StringFastIndexOf(*reinterpret_cast<MString*>(jthis), ch, start);
+}
+#endif
+
+MRT_EXPORT jobject Native_java_lang_Object_clone_Ljava_lang_Object__(jobject javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  if (UNLIKELY(javaThis == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  MObject *thisObj = reinterpret_cast<MObject*>(javaThis);
+  MClass *jcClone = WellKnown::GetMClassCloneable();
+  if (!thisObj->IsInstanceOf(*jcClone)) {
+    std::string classNameStr = thisObj->GetClass()->GetName();
+    std::string outputstr = std::string("Class ") + classNameStr + std::string(" doesn't implement Cloneable");
+    MRT_ThrowNewExceptionUnw("java/lang/CloneNotSupportedException", outputstr.c_str());
+  }
+
+  jobject newObj = MRT_CloneJavaObject(javaThis);
+  j2cRule.Epilogue();
+  return newObj;
+}
+
+#ifdef __OPENJDK__
+void Java_java_lang_String_nativeGetChars__II_3CI(
+    JNIEnv*,
+    jstring jthis,
+    jint start,         // idx of 1st jchar in string to copy
+    jint end,           // idx after last jchar in string to copy
+    jcharArray buffer,  // dst jchar array
+    jint index) {       // start offset in dst to copy to
+  ScopedObjectAccess soa;
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return;
+  }
+
+  local_String_getCharsNoCheck(jthis, start, end, buffer, index);
+}
+
+jstring Java_java_lang_String_nativeSubString__Ljava_lang_String_2II(
+    JNIEnv *env,
+    jstring jthis,
+    jstring srcStr,
+    jint start,
+    jint length) {
+  ScopedObjectAccess soa;
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  jstring subStr = reinterpret_cast<jstring>(StringNewStringFromSubstring(
+      *reinterpret_cast<MString*>(srcStr), start, static_cast<uint32_t>(length)));
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, subStr));
+}
+
+jstring Java_java_lang_String_nativeReplace__CC(JNIEnv *env, jstring jthis, jchar oldChar, jchar newChar) {
+  ScopedObjectAccess soa;
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  jstring repStr = reinterpret_cast<jstring>(JStringDoReplace(*reinterpret_cast<MString*>(jthis), oldChar, newChar));
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, repStr));
+}
+
+jint Java_java_lang_String_nativeIndexOf__Ljava_lang_String_2Ljava_lang_String_2I(
+    JNIEnv*, jstring jthis, jstring subStr, jstring srcStr, jint fromIndex) {
+  if (LIKELY(subStr == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "Parameter subStr must not be null");
+    return -1;
+  }
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  ScopedObjectAccess soa;
+  MString *srcStrObj = reinterpret_cast<MString*>(srcStr);
+  DCHECK(srcStrObj != nullptr);
+  MString *subStrObj = reinterpret_cast<MString*>(subStr);
+  jint res = StringNativeIndexOfP3(*subStrObj, *srcStrObj, fromIndex);
+  return res;
+}
+
+jint Java_java_lang_String_nativeIndexOf__Ljava_lang_String_2_3CIII(
+    JNIEnv*, jstring jthis, jstring subStr, jarray arraySrc, jint srcOffset, jint srcCount, jint fromIndex) {
+  if (LIKELY(subStr == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "Parameter subStr must not be null");
+    return -1;
+  }
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+
+  ScopedObjectAccess soa;
+  MArray *srcArrayObj = reinterpret_cast<MArray*>(arraySrc);
+  DCHECK(srcArrayObj != nullptr);
+  MString *subStrObj = reinterpret_cast<MString*>(subStr);
+  jint res = StringNativeIndexOfP5(*subStrObj, *srcArrayObj, srcOffset, srcCount, fromIndex);
+  return res;
+}
+
+jint Java_java_lang_String_nativeLastIndexOf__Ljava_lang_String_2Ljava_lang_String_2I(
+    JNIEnv*, jstring jthis, jstring subStr, jstring srcStr, jint fromIndex) {
+  if (LIKELY(subStr == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "Parameter subStr must not be null");
+    return -1;
+  }
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  ScopedObjectAccess soa;
+  MString *srcStrObj = reinterpret_cast<MString*>(srcStr);
+  DCHECK(srcStrObj != nullptr);
+  MString *subStrObj = reinterpret_cast<MString*>(subStr);
+  jint res = StringNativeLastIndexOfP3(*subStrObj, *srcStrObj, fromIndex);
+  return res;
+}
+
+jint Java_java_lang_String_nativeLastIndexOf__Ljava_lang_String_2_3CIII(
+    JNIEnv*, jstring jthis, jstring subStr, jarray arraySrc,
+    jint srcOffset, jint srcCount, jint fromIndex) {
+  if (LIKELY(subStr == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "Parameter subStr must not be null");
+    return -1;
+  }
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  ScopedObjectAccess soa;
+  MArray *srcArrayObj = reinterpret_cast<MArray*>(arraySrc);
+  DCHECK(srcArrayObj != nullptr);
+  MString *subStrObj = reinterpret_cast<MString*>(subStr);
+  jint res = StringNativeLastIndexOfP5(*subStrObj, *srcArrayObj, srcOffset, srcCount, fromIndex);
+  return res;
+}
+#endif
+
+#ifdef __OPENJDK__
+jint Java_java_lang_String_nativeCodePointAt__I(JNIEnv*, jstring jthis, jint index) {
+  ScopedObjectAccess soa;
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  MString *strObj = reinterpret_cast<MString*>(jthis);
+  jint res = StringNativeCodePointAt(*strObj, index);
+  return res;
+}
+
+jint Java_java_lang_String_nativeCodePointBefore__I(JNIEnv*, jstring jthis, jint index) {
+  ScopedObjectAccess soa;
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  MString *strObj = reinterpret_cast<MString*>(jthis);
+  jint res = StringNativeCodePointBefore(*strObj, index);
+  return res;
+}
+
+jint Java_java_lang_String_nativeCodePointCount__II(JNIEnv*, jstring jthis, jint beginIndex, jint endIndex) {
+  ScopedObjectAccess soa;
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  MString *strObj = reinterpret_cast<MString*>(jthis);
+  jint res = StringNativeCodePointCount(*strObj, beginIndex, endIndex);
+  return res;
+}
+
+jint Java_java_lang_String_nativeOffsetByCodePoint__II(
+    JNIEnv*, jstring jthis, jint index, jint codePointOffset) {
+  ScopedObjectAccess soa;
+  if (UNLIKELY(jthis == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return -1;
+  }
+  MString *strObj = reinterpret_cast<MString*>(jthis);
+  jint res = StringNativeOffsetByCodePoint(*strObj, index, codePointOffset);
+  return res;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_StringFactory.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_StringFactory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b8e903afe8499b720cce3d49c493afecd171cb9c
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_StringFactory.cpp
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_StringFactory.h"
+#include <cstring>
+#include <cstdlib>
+#include <cstdio>
+#include <cassert>
+#include <cctype>
+#include <cstdint>
+#include <iostream>
+#include "mrt_string.h"
+#include "mstring_inline.h"
+#include "exception/mrt_exception.h"
+#include "libs.h"
+using namespace std;
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+MRT_EXPORT jstring Native_java_lang_StringFactory_newStringFromString__Ljava_lang_String_2(jstring toCopy) {
+  if (UNLIKELY(toCopy == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  MString *stringObj = reinterpret_cast<MString*>(toCopy);
+  jstring newStr = reinterpret_cast<jstring>(StringNewStringFromString(*stringObj));
+  MRT_MemoryBarrier();
+  return newStr;
+}
+
+jstring Java_java_lang_StringFactory_newStringFromString__Ljava_lang_String_2(JNIEnv *env, jclass, jstring toCopy) {
+  ScopedObjectAccess soa;
+  if (toCopy == nullptr) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+  MString *stringObj = reinterpret_cast<MString*>(toCopy);
+  jstring newStr = reinterpret_cast<jstring>(StringNewStringFromString(*stringObj));
+  MRT_MemoryBarrier();
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, newStr));
+}
+
+#ifdef __OPENJDK__
+MRT_EXPORT jstring Native_java_lang_StringFactory_nativeStringFromChars___3CII(
+    jarray ja,
+    jint i,
+    jint i2) {
+  if (ja == nullptr) {
+    jstring emptyString = reinterpret_cast<jstring>(MString::NewEmptyStringObject());
+    MRT_MemoryBarrier();
+    return emptyString;
+  }
+  jstring res = reinterpret_cast<jstring>(
+      StringNewStringFromCharArray(i, static_cast<uint32_t>(i2), *reinterpret_cast<MArray*>(ja)));
+  MRT_MemoryBarrier();
+  return res;
+}
+
+jstring Java_java_lang_StringFactory_nativeStringFromChars___3CII(
+    JNIEnv *env,
+    jclass,
+    jarray ja,
+    jint i,
+    jint i2) {
+  ScopedObjectAccess soa;
+  jstring res = Native_java_lang_StringFactory_nativeStringFromChars___3CII(ja, i, i2);
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, res));
+}
+#else // libcore
+// Ljava_2Flang_2FStringFactory_3B_7CnewStringFromChars_7C_28IIAC_29Ljava_2Flang_2FString_3B
+MRT_EXPORT jstring Native_java_lang_StringFactory_newStringFromChars__II_3C(
+    jint i,
+    jint i2,
+    jarray ja) {
+  if (UNLIKELY(ja == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+
+  jstring res = reinterpret_cast<jstring>(
+      StringNewStringFromCharArray(i, static_cast<uint32_t>(i2), *reinterpret_cast<MArray*>(ja)));
+  MRT_MemoryBarrier();
+  return res;
+}
+
+jstring Java_java_lang_StringFactory_newStringFromChars__II_3C(
+    JNIEnv *env,
+    jclass,
+    jint i,
+    jint i2,
+    jarray ja) {
+  ScopedObjectAccess soa;
+  jstring res = Native_java_lang_StringFactory_newStringFromChars__II_3C(i, i2, ja);
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, res));
+}
+#endif // __OPENJDK__
+
+#ifdef __OPENJDK__
+MRT_EXPORT jstring Native_java_lang_StringFactory_nativeStringFromBytes___3BIII(
+    jbyteArray javaData, jint high, jint offset, jint byteCount) {
+  if (javaData == nullptr && high == 0 && offset == 0 && byteCount == 0) {
+    jstring emptyString = reinterpret_cast<jstring>(MString::NewEmptyStringObject());
+    return emptyString;
+  }
+
+  MArray *arrayObj = reinterpret_cast<MArray*>(javaData);
+  DCHECK(arrayObj != nullptr) ;
+  int32_t dataSize = arrayObj->GetLength();
+  if ((offset < 0) || (byteCount < 0) || (offset > (INT_MAX - byteCount)) || (byteCount > (dataSize - offset))) {
+    MRT_ThrowNewExceptionUnw("java/lang/StringIndexOutOfBoundsException");
+    return nullptr;
+  }
+  jstring res = reinterpret_cast<jstring>(
+      StringNewStringFromByteArray(*arrayObj, high, offset, static_cast<uint32_t>(byteCount)));
+  MRT_MemoryBarrier();
+  return res;
+}
+
+jstring Java_java_lang_StringFactory_nativeStringFromBytes___3BIII(
+    JNIEnv *env, jclass, jbyteArray javaData, jint high, jint offset, jint byteCount) {
+  ScopedObjectAccess soa;
+  if (javaData == nullptr && high == 0 && offset == 0 && byteCount == 0) {
+    jstring emptyString = reinterpret_cast<jstring>(MString::NewEmptyStringObject());
+    return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, emptyString));
+  }
+
+  MArray *arrayObj = reinterpret_cast<MArray*>(javaData);
+  DCHECK(arrayObj != nullptr);
+  int32_t dataSize = arrayObj->GetLength();
+  if ((offset < 0) || (byteCount < 0) || (offset > (INT_MAX - byteCount)) || (byteCount > (dataSize - offset))) {
+    MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException", nullptr);
+    return nullptr;
+  }
+  jstring res = reinterpret_cast<jstring>(
+      StringNewStringFromByteArray(*arrayObj, high, offset, static_cast<uint32_t>(byteCount)));
+  MRT_MemoryBarrier();
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, res));
+}
+#endif // __OPENJDK__
+
+MRT_EXPORT jstring Native_java_lang_StringFactory_newStringFromBytes___3BIII(
+    jbyteArray javaData, jint high, jint offset, jint byteCount) {
+  if (UNLIKELY(javaData == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException",
+                             "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+
+  MArray *arrayObj = reinterpret_cast<MArray*>(javaData);
+  DCHECK(arrayObj != nullptr);
+  int32_t dataSize = static_cast<int32_t>(arrayObj->GetLength());
+  if ((offset < 0) || (byteCount < 0) || (offset > (INT_MAX - byteCount)) || (byteCount > (dataSize - offset))) {
+    MRT_ThrowNewExceptionUnw("java/lang/StringIndexOutOfBoundsException");
+    return nullptr;
+  }
+  jstring res = reinterpret_cast<jstring>(
+      StringNewStringFromByteArray(*arrayObj, high, offset, static_cast<uint32_t>(byteCount)));
+  MRT_MemoryBarrier();
+  return res;
+}
+
+jstring Java_java_lang_StringFactory_newStringFromBytes___3BIII(
+    JNIEnv *env, jclass, jbyteArray javaData, jint high, jint offset, jint byteCount) {
+  ScopedObjectAccess soa;
+  if (javaData == nullptr) {
+    MRT_ThrowNewException("java/lang/NullPointerException",
+                          "Attempt to invoke a virtual method on a null object reference");
+    return nullptr;
+  }
+
+  MArray *arrayObj = reinterpret_cast<MArray*>(javaData);
+  DCHECK(arrayObj != nullptr);
+  int32_t dataSize = static_cast<int32_t>(arrayObj->GetLength());
+  if ((offset < 0) || (byteCount < 0) || (offset > (INT_MAX - byteCount)) || (byteCount > (dataSize - offset))) {
+    MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException", nullptr);
+    return nullptr;
+  }
+  jstring res = reinterpret_cast<jstring>(
+      StringNewStringFromByteArray(*arrayObj, high, offset, static_cast<uint32_t>(byteCount)));
+  MRT_MemoryBarrier();
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, res));
+}
+
+#ifdef __OPENJDK__
+jstring Java_java_lang_StringFactory_newStringFromCodePoints___3III(
+    JNIEnv *env,
+    jclass,
+    jarray javaData,
+    jint offset,
+    jint count) {
+  ScopedObjectAccess soa;
+  MArray *arrayObj = reinterpret_cast<MArray*>(javaData);
+  DCHECK(arrayObj != nullptr);
+  int32_t dataSize = arrayObj->GetLength();
+  if ((offset < 0) || (count < 0) || ((offset + count) < 0) || (count > (dataSize - offset))) {
+    MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException");
+    return nullptr;
+  }
+  if (count == 0 && offset <= dataSize) {
+    jstring emptyString = reinterpret_cast<jstring>(MString::NewEmptyStringObject());
+    MRT_MemoryBarrier();
+    return emptyString;
+  }
+  jstring res = reinterpret_cast<jstring>(StringNewStringFromCodePoints(*arrayObj, offset, count));
+  MRT_MemoryBarrier();
+  return reinterpret_cast<jstring>(MRT_JNI_AddLocalReference(env, res));
+}
+#endif // __OPENJDK__
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_System.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_System.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..14012a5a75388e934672d7c738ad7b8c8550b593
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_System.cpp
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_System.h"
+#include "mrt_array.h"
+#include "exception/mrt_exception.h"
+#include "libs.h"
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static void ThrowArrayStoreExceptionSrcNotArray(const MObject &javaObjSrc) {
+  std::ostringstream msg;
+  std::string srcBinaryName;
+  javaObjSrc.GetClass()->GetBinaryName(srcBinaryName);
+  msg << "source of type " << srcBinaryName << " is not an array";
+  MRT_ThrowNewExceptionUnw("java/lang/ArrayStoreException", msg.str().c_str());
+}
+
+static void ThrowArrayStoreExceptionDstNotArray(const MObject &javaObjDst) {
+  std::ostringstream msg;
+  std::string dstName;
+  javaObjDst.GetClass()->GetBinaryName(dstName);
+  msg << "destination of type " << dstName << " is not an array";
+  MRT_ThrowNewExceptionUnw("java/lang/ArrayStoreException", msg.str().c_str());
+}
+
+static void ThrowArrayIndexOutOfBoundsException(const int32_t szLength, const jint srcPos,
+                                                const int32_t dstLength, const jint dstPos, const jint length) {
+    string s = "src.length=" + std::to_string(szLength) + " srcPos=" + std::to_string(srcPos) + " dst.length=" +
+        std::to_string(dstLength) + " dstPos=" + std::to_string(dstPos) + " length=" + std::to_string(length);
+    MRT_ThrowNewExceptionUnw("java/lang/ArrayIndexOutOfBoundsException", s.c_str());
+}
+
+static void ThrowArrayStoreExceptionIncompatibleTypes(const MClass &srcComponentType, const MClass &dstComponentType) {
+  std::ostringstream msg;
+  std::string srcBinaryName;
+  std::string dstBinaryName;
+  srcComponentType.GetBinaryName(srcBinaryName);
+  dstComponentType.GetBinaryName(dstBinaryName);
+  msg << "Incompatible types: src=" << srcBinaryName << "[], dst=" << dstBinaryName << "[]";
+  MRT_ThrowNewExceptionUnw("java/lang/ArrayStoreException", msg.str().c_str());
+}
+
+static void AssignableObjectCopy(const MArray &javaSrc, jint srcPos, MArray &javaDst, jint dstPos, jint length,
+                                 bool check = false) {
+  MRT_ObjectArrayCopy(reinterpret_cast<address_t>(&javaSrc), reinterpret_cast<address_t>(&javaDst),
+                      srcPos, dstPos, length, check);
+}
+
+static void PrimitiveCopy(const MArray &javaSrc, jint srcPos, MArray &javaDst, jint dstPos, jint length) {
+  uint8_t *src = javaSrc.ConvertToCArray();
+  uint8_t *dst = javaDst.ConvertToCArray();
+  size_t szElem = javaSrc.GetElementSize();
+
+  uint8_t *srcStart = src + szElem * static_cast<size_t>(srcPos);
+  uint8_t *dstStart = dst + szElem * static_cast<size_t>(dstPos);
+
+  size_t arrayLen = szElem * static_cast<size_t>(length);
+  // primitive array copy tend to copy to different arrays, with relative large length
+  if (src != dst) {
+    if (memcpy_s(dstStart, arrayLen, srcStart, arrayLen) != EOK) {
+      LOG(ERROR) << "In PrimitiveCopy Function memcpy_s() return wrong" << maple::endl;
+    }
+  } else {
+    if (memmove_s(dstStart, arrayLen, srcStart, arrayLen) != EOK) {
+      LOG(ERROR) << "Function memmove_s() failed." << maple::endl;
+    }
+  }
+}
+
+static void NativeSystemArraycopy(const MArray &srcArray, jint srcPos, MArray &dstArray, jint dstPos, jint length) {
+  const MObject *javaObjSrc = static_cast<const MObject*>(&srcArray);
+  MObject *javaObjDst = static_cast<MObject*>(&dstArray);
+  // Make sure source and destination are both arrays.
+  if (UNLIKELY(!javaObjSrc->IsArray())) {
+    ThrowArrayStoreExceptionSrcNotArray(*javaObjSrc);
+    return;
+  }
+  if (UNLIKELY(!javaObjDst->IsArray())) {
+    ThrowArrayStoreExceptionDstNotArray(*javaObjDst);
+    return;
+  }
+
+  // Bounds checking.
+  int32_t szLength = static_cast<int32_t>(srcArray.GetLength());
+  int32_t dstLength = static_cast<int32_t>(dstArray.GetLength());
+  if (UNLIKELY(srcPos < 0) || UNLIKELY(dstPos < 0) || UNLIKELY(length < 0) ||
+      UNLIKELY(srcPos > szLength - length) || UNLIKELY(dstPos > dstLength - length)) {
+    ThrowArrayIndexOutOfBoundsException(szLength, srcPos, dstLength, dstPos, length);
+    return;
+  }
+  // saw a lot of arraycopy with 0 length so we add a fast path here.
+  if (length == 0) {
+    return;
+  }
+  // same array and offset, skip copy
+  if (&srcArray == &dstArray && srcPos == dstPos) {
+    return;
+  }
+
+  // check two array have same element class. Otherwise ArrayStoreException
+  MClass *dstComponentType = dstArray.GetClass()->GetComponentClass();
+  MClass *srcComponentType = srcArray.GetClass()->GetComponentClass();
+
+  if (LIKELY((dstComponentType == srcComponentType))) {
+    srcArray.IsObjectArray() ? AssignableObjectCopy(srcArray, srcPos, dstArray, dstPos, length, false) :
+                               PrimitiveCopy(srcArray, srcPos, dstArray, dstPos, length);
+    return;
+  }
+
+  if (UNLIKELY(dstComponentType->IsPrimitiveClass() || srcComponentType->IsPrimitiveClass())) {
+    ThrowArrayStoreExceptionIncompatibleTypes(*srcComponentType, *dstComponentType);
+    return;
+  }
+
+  if (LIKELY(dstComponentType == WellKnown::GetMClassObject()) ||
+      dstComponentType->IsAssignableFrom(*srcComponentType)) {
+    AssignableObjectCopy(srcArray, srcPos, dstArray, dstPos, length, false);
+    return;
+  }
+
+  AssignableObjectCopy(srcArray, srcPos, dstArray, dstPos, length, true);
+}
+
+MRT_EXPORT void Native_java_lang_System_arraycopy__Ljava_lang_Object_2ILjava_lang_Object_2II(
+    jobject javaSrc,  // source array
+    jint srcPos,    // start idx
+    jobject javaDst,  // dst array
+    jint dstPos,    // start idx
+    jint length) {   // nr. array elements to copy
+  if (UNLIKELY(javaSrc == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "src == null");
+    return;
+  }
+  if (UNLIKELY(javaDst == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "dst == null");
+    return;
+  }
+  NativeSystemArraycopy(*reinterpret_cast<MArray*>(javaSrc), srcPos,
+                        *reinterpret_cast<MArray*>(javaDst), dstPos, length);
+}
+
+void Java_java_lang_System_arraycopy__Ljava_lang_Object_2ILjava_lang_Object_2II(
+    JNIEnv*,
+    jclass,
+    jobject javaSrc,  // source array
+    jint srcPos,    // start idx
+    jobject javaDst,  // dst array
+    jint dstPos,    // start idx
+    jint length) {  // nr. array elements to copy
+  maplert::ScopedObjectAccess soa;
+  if (UNLIKELY(javaSrc == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "src == null");
+    return;
+  }
+  if (UNLIKELY(javaDst == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "dst == null");
+    return;
+  }
+  NativeSystemArraycopy(*reinterpret_cast<MArray*>(javaSrc), srcPos,
+                        *reinterpret_cast<MArray*>(javaDst), dstPos, length);
+}
+
+void SystemArraycopyTUnchecked(const jobject javaSrc, jint srcPos, jobject javaDst, jint dstPos, jint count) {
+  if (count == 0) {
+    return;
+  }
+  if (UNLIKELY(count < 0)) {
+    string s = "length=" + std::to_string(count);
+    MRT_ThrowNewExceptionRet("java/lang/ArrayIndexOutOfBoundsException", s.c_str());
+    return;
+  }
+  if (javaSrc == javaDst && srcPos == dstPos) {
+    return;
+  }
+  PrimitiveCopy(*reinterpret_cast<MArray*>(javaSrc), srcPos, *reinterpret_cast<MArray*>(javaDst), dstPos, count);
+}
+
+
+MRT_EXPORT void Native_java_lang_System_arraycopyCharUnchecked___3CI_3CII(jobject javaSrc, jint srcPos,
+                                                                          jobject javaDst, jint dstPos, jint count) {
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+MRT_EXPORT void Native_java_lang_System_arraycopyByteUnchecked___3BI_3BII(jobject javaSrc, jint srcPos,
+                                                                          jobject javaDst, jint dstPos, jint count) {
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+MRT_EXPORT void Native_java_lang_System_arraycopyShortUnchecked___3SI_3SII(jobject javaSrc, jint srcPos,
+                                                                           jobject javaDst, jint dstPos, jint count) {
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+MRT_EXPORT void Native_java_lang_System_arraycopyIntUnchecked___3II_3III(jobject javaSrc, jint srcPos,
+                                                                         jobject javaDst, jint dstPos, jint count) {
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+MRT_EXPORT void Native_java_lang_System_arraycopyLongUnchecked___3JI_3JII(jobject javaSrc, jint srcPos,
+                                                                          jobject javaDst, jint dstPos, jint count) {
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+MRT_EXPORT void Native_java_lang_System_arraycopyFloatUnchecked___3FI_3FII(jobject javaSrc, jint srcPos,
+                                                                           jobject javaDst, jint dstPos, jint count) {
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+MRT_EXPORT void Native_java_lang_System_arraycopyDoubleUnchecked___3DI_3DII(jobject javaSrc, jint srcPos,
+                                                                            jobject javaDst, jint dstPos, jint count) {
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+MRT_EXPORT void Native_java_lang_System_arraycopyBooleanUnchecked___3ZI_3ZII(jobject javaSrc, jint srcPos,
+                                                                             jobject javaDst, jint dstPos, jint count) {
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+// 33 Ljava/lang/System;|arraycopyCharUnchecked|([CI[CII)V
+void Java_java_lang_System_arraycopyCharUnchecked___3CI_3CII(JNIEnv*, jclass, jobject javaSrc, jint srcPos,
+                                                             jobject javaDst, jint dstPos, jint count) {
+  maplert::ScopedObjectAccess soa;
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+void Java_java_lang_System_arraycopyByteUnchecked___3BI_3BII(JNIEnv*, jclass, jobject javaSrc, jint srcPos,
+                                                             jobject javaDst, jint dstPos, jint count) {
+  maplert::ScopedObjectAccess soa;
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+void Java_java_lang_System_arraycopyShortUnchecked___3SI_3SII(JNIEnv*, jclass, jobject javaSrc, jint srcPos,
+                                                              jobject javaDst, jint dstPos, jint count) {
+  maplert::ScopedObjectAccess soa;
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+void Java_java_lang_System_arraycopyIntUnchecked___3II_3III(JNIEnv*, jclass, jobject javaSrc, jint srcPos,
+                                                            jobject javaDst, jint dstPos, jint count) {
+  maplert::ScopedObjectAccess soa;
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+void Java_java_lang_System_arraycopyLongUnchecked___3JI_3JII(JNIEnv*, jclass, jobject javaSrc, jint srcPos,
+                                                             jobject javaDst, jint dstPos, jint count) {
+  maplert::ScopedObjectAccess soa;
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+void Java_java_lang_System_arraycopyFloatUnchecked___3FI_3FII(JNIEnv*, jclass, jobject javaSrc, jint srcPos,
+                                                              jobject javaDst, jint dstPos, jint count) {
+  maplert::ScopedObjectAccess soa;
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+void Java_java_lang_System_arraycopyDoubleUnchecked___3DI_3DII(JNIEnv*, jclass, jobject javaSrc, jint srcPos,
+                                                               jobject javaDst, jint dstPos, jint count) {
+  maplert::ScopedObjectAccess soa;
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+void Java_java_lang_System_arraycopyBooleanUnchecked___3ZI_3ZII(JNIEnv*, jclass, jobject javaSrc, jint srcPos,
+                                                                jobject javaDst, jint dstPos, jint count) {
+  maplert::ScopedObjectAccess soa;
+  SystemArraycopyTUnchecked(javaSrc, srcPos, javaDst, dstPos, count);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_Thread.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_Thread.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ddc66ddd6db591db3306f8ca12ffacdd6308b3b1
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_Thread.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_Thread.h"
+#include "chelper.h"
+#include "thread_api.h"
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jobject Native_Thread_currentThread() {
+  jobject thread = maple::IThread::Current()->GetRawPeer();
+  RC_LOCAL_INC_REF(thread);
+  return thread;
+}
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_ref_Reference.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_ref_Reference.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9a34a3a93d9beb8f4908b13e2d3ddd0830211e4a
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_ref_Reference.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_ref_Reference.h"
+#include "java2c_rule.h"
+#include "mrt_reference_api.h"
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+address_t Ljava_2Flang_2Fref_2FReference_3B_7Cget_7C_28_29Ljava_2Flang_2FObject_3B(address_t javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  address_t ret = MRT_ReferenceGetReferent(javaThis);
+  j2cRule.Epilogue();
+  return ret;
+}
+
+void Ljava_2Flang_2Fref_2FReference_3B_7Cclear_7C_28_29V(address_t javaThis) {
+  Java2CRule j2cRule(INIT_ARGS);
+  if (javaThis != 0) {
+    MRT_ReferenceClearReferent(javaThis);
+  }
+  j2cRule.Epilogue();
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_reflect_Array.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_reflect_Array.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4097d1c176a077cac5ac064c09658e1a38dccb8a
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_reflect_Array.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_reflect_Array.h"
+#include "mrt_array.h"
+#include "exception/mrt_exception.h"
+#include "utils/string_utils.h"
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jobject Java_java_lang_reflect_Array_createObjectArray__Ljava_lang_Class_2I(
+    JNIEnv *env, jclass, jobject componentClass, jint length) {
+  maplert::ScopedObjectAccess soa;
+  if (UNLIKELY(length < 0)) {
+    std::string msg = std::to_string(length);
+    MRT_ThrowNewException("java/lang/NegativeArraySizeException", msg.c_str());
+    return nullptr;
+  }
+  return MRT_JNI_AddLocalReference(env, MRT_NewObjArray(length, static_cast<jclass>(componentClass), nullptr));
+}
+
+jobject Java_java_lang_reflect_Array_createMultiArray__Ljava_lang_Class_2_3I(
+    JNIEnv *env, jclass, jclass javaElementClass, jobject javaDimArray) {
+  maplert::ScopedObjectAccess soa;
+  DCHECK(javaDimArray != nullptr) << "reflect_Array_createMultiArry:: javaDimArray is nullptr" << maple::endl;
+  MArray *mDimArray = reinterpret_cast<MArray*>(javaDimArray);
+  uint32_t dimCount =  mDimArray->GetLength();
+  jint *dimArray = reinterpret_cast<jint*>(mDimArray->ConvertToCArray());
+  jclass arrayClass = javaElementClass;
+  for (uint32_t i = 0; i < dimCount; i++) {
+    jint dimension = dimArray[i];
+    arrayClass = MRT_ReflectGetOrCreateArrayClassObj(arrayClass);
+    if (UNLIKELY(arrayClass == nullptr)) {
+      LOG(FATAL) << "the result of MRT_ReflectGetOrCreateArrayClassObj() from arrayClass is nullptr" << maple::endl;
+    }
+    if (UNLIKELY(dimension < 0)) {
+      MRT_ThrowNewException("java/lang/NegativeArraySizeException",
+                            stringutils::Format("Dimension %u: %d", i, dimension).c_str());
+      return nullptr;
+    }
+  }
+  return MRT_JNI_AddLocalReference(env, MRT_RecursiveCreateMultiArray(arrayClass, 0, dimCount, dimArray));
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_reflect_Field.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_reflect_Field.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4152e32169060ef96af551499d989207f02c3d7e
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_reflect_Field.cpp
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_reflect_Field.h"
+#include "mrt_reflection_field.h"
+#include "fieldmeta_inline.h"
+#include "mfield_inline.h"
+#include "mclass_inline.h"
+#include "java2c_rule.h"
+#include "cpphelper.h"
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jobject Java_java_lang_reflect_Field_getNameInternal__(JNIEnv *env, jobject fieldArg) {
+  ScopedObjectAccess soa;
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *ret = ReflectFieldGetNameInternal(*field);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/reflect/Field;|getSignatureAnnotation|()ALjava/lang/String;
+jobject Java_java_lang_reflect_Field_getSignatureAnnotation__(JNIEnv *env, jobject fieldArg) {
+  ScopedObjectAccess soa;
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *ret = ReflectFieldGetSignatureAnnotation(*field);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/reflect/Field;|get|(Ljava/lang/Object;)Ljava/lang/Object;
+jobject Java_java_lang_reflect_Field_get__Ljava_lang_Object_2(JNIEnv *env, jobject fieldArg, jobject obj) {
+  ScopedObjectAccess soa;
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  MObject *ret = ReflectGetFieldNativeObject(*field, o);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/reflect/Field;|getBoolean|(Ljava/lang/Object;)Z
+jboolean Java_java_lang_reflect_Field_getBoolean__Ljava_lang_Object_2(JNIEnv*, jobject fieldArg, jobject obj) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  return ReflectGetFieldNativeUint8(*field, o);
+}
+
+// Ljava/lang/reflect/Field;|getByte|(Ljava/lang/Object;)B
+jbyte Java_java_lang_reflect_Field_getByte__Ljava_lang_Object_2(JNIEnv*, jobject fieldArg, jobject obj) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  return ReflectGetFieldNativeInt8(*field, o);
+}
+
+// Ljava/lang/reflect/Field;|getChar|(Ljava/lang/Object;)C
+jchar Java_java_lang_reflect_Field_getChar__Ljava_lang_Object_2(JNIEnv*, jobject fieldArg, jobject obj) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  return ReflectGetFieldNativeUint16(*field, o);
+}
+
+// Ljava/lang/reflect/Field;|getShort|(Ljava/lang/Object;)S
+jshort Java_java_lang_reflect_Field_getShort__Ljava_lang_Object_2(JNIEnv*, jobject fieldArg, jobject obj) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  return ReflectGetFieldNativeInt16(*field, o);
+}
+
+// Ljava/lang/reflect/Field;|getInt|(Ljava/lang/Object;)I
+jint Java_java_lang_reflect_Field_getInt__Ljava_lang_Object_2(JNIEnv*, jobject fieldArg, jobject obj) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  return ReflectGetFieldNativeInt32(*field, o);
+}
+
+// Ljava/lang/reflect/Field;|getLong|(Ljava/lang/Object;)J
+jlong Java_java_lang_reflect_Field_getLong__Ljava_lang_Object_2(JNIEnv*, jobject fieldArg, jobject obj) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  return ReflectGetFieldNativeInt64(*field, o);
+}
+
+// Ljava/lang/reflect/Field;|getFloat|(Ljava/lang/Object;)F
+jfloat Java_java_lang_reflect_Field_getFloat__Ljava_lang_Object_2(JNIEnv*, jobject fieldArg, jobject obj) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  return ReflectGetFieldNativeFloat(*field, o);
+}
+
+// Ljava/lang/reflect/Field;|getDouble|(Ljava/lang/Object;)D
+jdouble Java_java_lang_reflect_Field_getDouble__Ljava_lang_Object_2(JNIEnv*, jobject fieldArg, jobject obj) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  return ReflectGetFieldNativeDouble(*field, o);
+}
+
+// Ljava/lang/reflect/Field;|set|(Ljava/lang/Object;Ljava/lang/Object;)V
+void Java_java_lang_reflect_Field_set__Ljava_lang_Object_2Ljava_lang_Object_2(JNIEnv*, jobject fieldArg,
+                                                                              jobject obj1, jobject obj2) {
+  ScopedObjectAccess soa;
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o1 = MObject::JniCast(obj1);
+  MObject *o2 = MObject::JniCast(obj2);
+  ReflectSetFieldNativeObject(*field, o1, o2);
+}
+
+// Ljava/lang/reflect/Field;|setBoolean|(Ljava/lang/Object;Z)V
+void Java_java_lang_reflect_Field_setBoolean__Ljava_lang_Object_2Z(JNIEnv*, jobject fieldArg,
+                                                                   jobject obj, jboolean arg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  ReflectSetFieldNativeUint8(*field, o, arg);
+}
+
+// Ljava/lang/reflect/Field;|setByte|(Ljava/lang/Object;B)V
+void Java_java_lang_reflect_Field_setByte__Ljava_lang_Object_2B(JNIEnv*, jobject fieldArg, jobject obj, jbyte arg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  ReflectSetFieldNativeInt8(*field, o, arg);
+}
+
+// Ljava/lang/reflect/Field;|setChar|(Ljava/lang/Object;C)V
+void Java_java_lang_reflect_Field_setChar__Ljava_lang_Object_2C(JNIEnv*, jobject fieldArg, jobject obj, jchar arg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  ReflectSetFieldNativeUint16(*field, o, arg);
+}
+
+// Ljava/lang/reflect/Field;|setShort|(Ljava/lang/Object;S)V
+void Java_java_lang_reflect_Field_setShort__Ljava_lang_Object_2S(JNIEnv*, jobject fieldArg, jobject obj, jshort arg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  ReflectSetFieldNativeInt16(*field, o, arg);
+}
+
+// Ljava/lang/reflect/Field;|setInt|(Ljava/lang/Object;I)V
+void Java_java_lang_reflect_Field_setInt__Ljava_lang_Object_2I(JNIEnv*, jobject fieldArg, jobject obj, jint arg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  ReflectSetFieldNativeInt32(*field, o, arg);
+}
+
+// Ljava/lang/reflect/Field;|setLong|(Ljava/lang/Object;J)V
+void Java_java_lang_reflect_Field_setLong__Ljava_lang_Object_2J(JNIEnv*, jobject fieldArg, jobject obj, jlong arg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  ReflectSetFieldNativeInt64(*field, o, arg);
+}
+
+// Ljava/lang/reflect/Field;|setFloat|(Ljava/lang/Object;F)V
+void Java_java_lang_reflect_Field_setFloat__Ljava_lang_Object_2F(JNIEnv*, jobject fieldArg, jobject obj, jfloat arg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  ReflectSetFieldNativeFloat(*field, o, arg);
+}
+
+// Ljava/lang/reflect/Field;|setDouble|(Ljava/lang/Object;D)V
+void Java_java_lang_reflect_Field_setDouble__Ljava_lang_Object_2D(JNIEnv*, jobject fieldArg, jobject obj, jdouble arg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *o = MObject::JniCast(obj);
+  ReflectSetFieldNativeDouble(*field, o, arg);
+}
+
+// Ljava/lang/reflect/Field;|getAnnotationNative|(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;
+jobject Java_java_lang_reflect_Field_getAnnotationNative__Ljava_lang_Class_2(JNIEnv *env, jobject fieldArg,
+                                                                             jobject classArg) {
+  ScopedObjectAccess soa;
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MClass *cls = MClass::JniCast(classArg);
+  MObject *ret = ReflectFieldGetAnnotation(*field, cls);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+// Ljava/lang/reflect/Field;|isAnnotationPresentNative|(Ljava/lang/Class;)Z
+jboolean Java_java_lang_reflect_Field_isAnnotationPresentNative__Ljava_lang_Class_2(JNIEnv*,
+                                                                                    jobject fieldArg,
+                                                                                    jobject classArg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MClass *cls = MClass::JniCast(classArg);
+  return ReflectFieldIsAnnotationPresentNative(*field, cls);
+}
+
+jobject Java_java_lang_reflect_Field_getDeclaredAnnotations__(JNIEnv *env, jobject fieldArg) {
+  ScopedObjectAccess soa;
+  MField *field = MField::JniCastNonNull(fieldArg);
+  MObject *ret = ReflectFieldGetDeclaredAnnotations(*field);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+jlong Java_java_lang_reflect_Field_getArtField__(JNIEnv*, jobject fieldArg) {
+  MField *field = MField::JniCastNonNull(fieldArg);
+  FieldMeta *fieldMeta = ReflectFieldGetArtField(*field);
+  return reinterpret_cast<jlong>(fieldMeta);
+}
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/src/mrt/libcore-static-binding-jni/src/java_lang_reflect_Method.cpp b/src/mrt/libcore-static-binding-jni/src/java_lang_reflect_Method.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..25ab5eaf086da82843933b3245a4c215ee77edf1
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/java_lang_reflect_Method.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java_lang_reflect_Method.h"
+#include "mrt_reflection_method.h"
+#include "methodmeta_inline.h"
+#include "mmethod_inline.h"
+#include "java2c_rule.h"
+#include "cpphelper.h"
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// public native Object invoke(Object obj, Object... args)
+MRT_EXPORT jobject Java_java_lang_reflect_Method_invoke__Ljava_lang_Object_2_3Ljava_lang_Object_2(JNIEnv *env,
+                                                                                                  jobject javaThis,
+                                                                                                  jobject obj,
+                                                                                                  jarray arrayObj) {
+  maplert::ScopedObjectAccess soa;
+  MMethod *method = MMethod::JniCastNonNull(javaThis);
+  MObject *o = MObject::JniCast(obj);
+  MArray *array = MArray::JniCast(arrayObj);
+  MObject *ret = ReflectMethodInvoke(*method, o, array, 1);
+  return MRT_JNI_AddLocalReference(env, ret->AsJobject());
+}
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/libcore_util_CharsetUtils.cpp b/src/mrt/libcore-static-binding-jni/src/libcore_util_CharsetUtils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9c5da5efc46df6a8425da855fe3bfdb5e78a7765
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/libcore_util_CharsetUtils.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "libcore_util_CharsetUtils.h"
+#include <cstdio>
+#include <unistd.h>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <unordered_map>
+#include "securec.h"
+#include "mrt_string.h"
+#include "mrt_array.h"
+#include "chelper.h"
+#include "cpphelper.h"
+#include "mstring_inline.h"
+#include "marray_inline.h"
+
+#ifndef UNIFIED_MACROS_DEF
+#define UNIFIED_MACROS_DEF
+#include "unified.macros.def"
+#endif
+using namespace std;
+using namespace maplert;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void Java_libcore_util_CharsetUtils_asciiBytesToChars___3BII_3C(JNIEnv*,
+    jclass, jbyteArray javaBytes, jint offset, jint length, jcharArray javaChars) {
+  if (javaBytes == nullptr || javaChars == nullptr) {
+    return;
+  }
+  MArray *srcArray = reinterpret_cast<MArray*>(javaBytes);
+  MArray *dstArray = reinterpret_cast<MArray*>(javaChars);
+  int32_t srcElementCount = static_cast<int32_t>(srcArray->GetLength());
+  if (UNLIKELY(offset < 0 || length < 0 || offset + length > srcElementCount || offset > INT_MAX - length)) {
+    LOG(FATAL) << "the index to access javaBytes is illegal" << maple::endl;
+  }
+  jbyte *src = reinterpret_cast<jbyte*>(srcArray->ConvertToCArray()) + offset;
+  jchar *dst = reinterpret_cast<jchar*>(dstArray->ConvertToCArray());
+  jchar *end = dst + length;
+
+  while (dst < end) {
+    jchar tmp = static_cast<jchar>(static_cast<unsigned char>(*src++) & 0xff);
+    *dst++ = (tmp < 0x80) ? tmp : 0xfffd;
+  }
+}
+
+void Java_libcore_util_CharsetUtils_isoLatin1BytesToChars___3BII_3C(JNIEnv*,
+    jclass, jbyteArray javaBytes, jint offset, jint length, jcharArray javaChars) {
+  if (javaBytes == nullptr || javaChars == nullptr) {
+    return;
+  }
+  MArray *srcArray = reinterpret_cast<MArray*>(javaBytes);
+  MArray *dstArray = reinterpret_cast<MArray*>(javaChars);
+  int32_t srcElementCount = static_cast<int32_t>(srcArray->GetLength());
+  if (UNLIKELY(offset < 0 || length < 0 || offset + length > srcElementCount || offset > INT_MAX - length)) {
+    LOG(FATAL) << "the index to access javaBytes is illegal" << maple::endl;
+  }
+  jbyte *src = reinterpret_cast<jbyte*>(srcArray->ConvertToCArray()) + offset;
+  jchar *dst = reinterpret_cast<jchar*>(dstArray->ConvertToCArray());
+  jchar *end = dst + length;
+
+  while (dst < end) {
+    *dst++ = static_cast<jchar>(static_cast<unsigned char>(*src++) & 0xff);
+  }
+}
+
+jbyteArray Java_libcore_util_CharsetUtils_toAsciiBytes__Ljava_lang_String_2II(JNIEnv *env,
+    jclass, jstring javaString, jint offset, jint length) {
+  ScopedObjectAccess soa;
+  const jchar replacementByte = 0x7f;
+  MString *stringObj = reinterpret_cast<MString*>(javaString);
+  DCHECK(stringObj != nullptr);
+  MArray *res = stringObj->IsCompress() ? MStringToBytes(*stringObj, offset, length, replacementByte, 1) :
+                                          MStringToBytes(*stringObj, offset, length, replacementByte, 0);
+  return reinterpret_cast<jbyteArray>(MRT_JNI_AddLocalReference(env, reinterpret_cast<jobject>(res)));
+}
+
+jbyteArray Java_libcore_util_CharsetUtils_toIsoLatin1Bytes__Ljava_lang_String_2II(JNIEnv *env,
+    jclass, jstring javaString, jint offset, jint length) {
+  ScopedObjectAccess soa;
+  const jchar replacementByte = 0xff;
+  MString *stringObj = reinterpret_cast<MString*>(javaString);
+  DCHECK(stringObj != nullptr);
+  MArray *res = stringObj->IsCompress() ? MStringToBytes(*stringObj, offset, length, replacementByte, 1) :
+                                          MStringToBytes(*stringObj, offset, length, replacementByte, 0);
+  return reinterpret_cast<jbyteArray>(MRT_JNI_AddLocalReference(env, reinterpret_cast<jobject>(res)));
+}
+
+jbyteArray Java_libcore_util_CharsetUtils_toUtf8Bytes__Ljava_lang_String_2II(JNIEnv *env,
+    jclass, jstring javaString, jint offset, jint length) {
+  ScopedObjectAccess soa;
+  MString *stringObj = reinterpret_cast<MString*>(javaString);
+  DCHECK(stringObj != nullptr);
+  MArray *res = stringObj->IsCompress() ? MStringToMutf8(*stringObj, offset, length, 1) :
+                                          MStringToMutf8(*stringObj, offset, length, 0);
+  return reinterpret_cast<jbyteArray>(MRT_JNI_AddLocalReference(env, reinterpret_cast<jobject>(res)));
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/mrt/libcore-static-binding-jni/src/native_binding_utils.cpp b/src/mrt/libcore-static-binding-jni/src/native_binding_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..737e531e5de3b423224092256f497a67bd29ec3a
--- /dev/null
+++ b/src/mrt/libcore-static-binding-jni/src/native_binding_utils.cpp
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "native_binding_utils.h"
+#include "base/logging.h"
+#include "thread_api.h"
+#include "mrt_class_api.h"
+#include "mrt_string_api.h"
+#include "mrt_array_api.h"
+#include "chelper.h"
+#include "libs.h"
+#include "mrt_well_known.h"
+
+namespace maplert {
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// The set of "C" functions exported to compiler for native function calls
+//
+// used in compiler-generated "weak" static-bound native function.
+// on qemu/arm64-server platform (without all the native-libraries available), it will report an warning.
+// but on android, it will throw an UnsatisfiedLinkError.
+//
+// return a "dummy" object in case the calling native functions needs to return a jobject
+jobject MCC_CannotFindNativeMethod(const char *signature) {
+  VLOG(jni) << signature << "is weak symbol and throw java/lang/UnsatisfiedLinkError!" << maple::endl;
+#ifdef __ANDROID__
+  JNIEnv *env = maple::IThread::Current()->GetJniEnv();
+  env->ThrowNew(reinterpret_cast<jclass>(WellKnown::GetMClassUnsatisfiedLinkError()), signature);
+  return (jobject) nullptr;
+#else
+  return reinterpret_cast<jobject>(MRT_GetClassClass());
+#endif //__ANDROID__
+}
+
+#ifndef __ANDROID__
+static uint64_t dummyJstr[3] = { 0 };  // field size 3
+#endif // __ANDROID__
+
+// a version returns a literal string.
+jstring MCC_CannotFindNativeMethod_S(const char *signature) {
+  VLOG(jni) << signature << "is weak symbol and throw java/lang/UnsatisfiedLinkError!" << maple::endl;
+#ifdef __ANDROID__
+  JNIEnv *env = maple::IThread::Current()->GetJniEnv();
+  env->ThrowNew(reinterpret_cast<jclass>(WellKnown::GetMClassUnsatisfiedLinkError()), signature);
+  return (jstring) nullptr;
+#else
+  if (dummyJstr[0] == 0) {
+    dummyJstr[0] = reinterpret_cast<uint64_t>(MRT_GetClassString());
+  }
+  return reinterpret_cast<jstring>(dummyJstr);
+#endif //__ANDROID__
+}
+
+#ifndef __ANDROID__
+static uint64_t dummyJarray[3] = { 0 }; // field size 3
+#endif //__ANDROID__
+
+// a version returns an empty array.
+jobject MCC_CannotFindNativeMethod_A(const char *signature) {
+  VLOG(jni) << signature << "is weak symbol and throw java/lang/UnsatisfiedLinkError!" << maple::endl;
+#ifdef __ANDROID__
+  JNIEnv *env = maple::IThread::Current()->GetJniEnv();
+  env->ThrowNew(reinterpret_cast<jclass>(WellKnown::GetMClassUnsatisfiedLinkError()), signature);
+  return (jobject) nullptr;
+#else
+  if (dummyJarray[0] == 0) {
+    dummyJarray[0] = reinterpret_cast<uint64_t>(MRT_GetPrimitiveArrayClassJint());
+  }
+  return reinterpret_cast<jobject>(dummyJarray);
+#endif //__ANDROID__
+}
+
+void *MCC_DummyNativeMethodPtr() {
+#if defined(__ANDROID__)
+  VLOG(jni) << "[NOTE] : MCC_DummyNativeMethodPtr is called for encountering null native method!" << maple::endl;
+#endif //__ANDROID__
+  return reinterpret_cast<void*>(&MCC_DummyNativeMethodPtr);
+}
+
+void *MCC_FindNativeMethodPtr(uintptr_t **regFuncTabAddr) {
+  VLOG(jni) << "[NOTE] : MCC_FindNativeMethodPtr is invoked by function address at " <<
+      reinterpret_cast<uintptr_t>(regFuncTabAddr)  << maple::endl;
+  void *nativeMethodPtr = reinterpret_cast<void*>(&MCC_DummyNativeMethodPtr);
+#if defined(__ANDROID__)
+  maple::IThread *tSelf = maple::IThread::Current();
+  JNIEnv *env = tSelf->GetJniEnv();
+  nativeMethodPtr = tSelf->FindNativeMethodPtr(env, regFuncTabAddr, true);
+  if (nativeMethodPtr == nullptr) {
+    nativeMethodPtr = reinterpret_cast<void*>(&MCC_DummyNativeMethodPtr);
+  }
+#else
+  // Currently we're reusing native registration functions, which will
+  // trigger exceptions for openjdk core library. disable exception during registration.
+  maple::IThread *tSelf = maple::IThread::Current();
+  JNIEnv *env = tSelf->GetJniEnv();
+  nativeMethodPtr = tSelf->FindNativeMethodPtr(env, regFuncTabAddr, false);
+  if (nativeMethodPtr == nullptr) {
+    nativeMethodPtr = reinterpret_cast<void*>(&MCC_DummyNativeMethodPtr);
+  }
+#endif //__ANDROID__
+  return (jobject) nativeMethodPtr;
+}
+
+void *MCC_FindNativeMethodPtrWithoutException(uintptr_t **regFuncTabAddr) {
+  VLOG(jni) << "[NOTE] : MCC_FindNativeMethodPtrWithoutException is invoked by function address at " <<
+      reinterpret_cast<uintptr_t>(regFuncTabAddr)  << maple::endl;
+  void *nativeMethodPtr = reinterpret_cast<void*>(&MCC_DummyNativeMethodPtr);
+  maple::IThread *tSelf = maple::IThread::Current();
+  JNIEnv *env = tSelf->GetJniEnv();
+  nativeMethodPtr = tSelf->FindNativeMethodPtr(env, regFuncTabAddr, false);
+  if (nativeMethodPtr == nullptr) {
+    nativeMethodPtr = reinterpret_cast<void*>(&MCC_DummyNativeMethodPtr);
+  }
+  return static_cast<jobject>(nativeMethodPtr);
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+} // maplert
diff --git a/src/mrt/libmrtbase/include/atomic_spinlock.h b/src/mrt/libmrtbase/include/atomic_spinlock.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbffb2cba910aea5897ae572be1ab3367a345e06
--- /dev/null
+++ b/src/mrt/libmrtbase/include/atomic_spinlock.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_ATOMIC_SPINLOCK_H
+#define MAPLE_ATOMIC_SPINLOCK_H
+#include <atomic>
+#include <base/macros.h>
+#include "scoped_spinlock.h"
+
+namespace maple {
+
+class AtomicSpinLock {
+ public:
+  AtomicSpinLock();
+  ~AtomicSpinLock() = default;
+
+  void Lock();
+  void Unlock()
+
+ private:
+  std::atomic_flag state = ATOMIC_FLAG_INIT;
+
+  DISABLE_CLASS_COPY_AND_ASSIGN(AtomicSpinLock);
+};
+
+using ScopedAtomicSpinLock = ScopedSpinLock<AtomicSpinLock>;
+} // maple namespace
+
+#endif // MAPLE_ATOMIC_SPINLOCK_H
diff --git a/src/mrt/libmrtbase/include/base/file_utils.h b/src/mrt/libmrtbase/include/base/file_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..6526cc2ebdd8ca19b39585b2340212e037b5bbfd
--- /dev/null
+++ b/src/mrt/libmrtbase/include/base/file_utils.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef _MAPLE_FILE_IO_H
+#define _MAPLE_FILE_IO_H
+
+#include <fcntl.h>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace maple {
+
+class File final {
+ public:
+  File();
+  File(int fd_);
+  File(int fd_, const std::string &path);
+  File(const std::string &path, int flags);
+  File(const std::string &path, int flags, mode_t mode);
+
+  int GetFd() const;
+
+  virtual ~File();
+
+  int64_t Read(char *buffer, int64_t count, int64_t offset) const;
+  int64_t Write(const char *buffer, int64_t count, int64_t offset);
+  int Close();
+  int Flush();
+  bool Unlink();
+  bool Opened() const;
+
+  bool ReadFully(std::string &buffer);
+  bool WriteFully(const void *buffer, size_t count);
+  void ReadLines(std::vector<std::string> &lines);
+
+  int64_t GetLength() const;
+
+ private:
+  int fd;
+  std::string filePath;
+  static constexpr unsigned int maxPathLength = 4096;
+  bool Open(const std::string &path, int flags, mode_t mode);
+  void Destroy();
+};
+
+class FileUtils {
+ public:
+  // Open a file with O_RDONLY flag
+  static File *OpenFileReadOnly(const std::string &name);
+
+  // Open a file with O_RDWR flag
+  static File *OpenFileReadWrite(const std::string &name);
+
+  // Open a file whith user specified flags (man 2 open)
+  static File *OpenFile(const std::string &name, int flags);
+
+  // Create a new file
+  static File *CreateFile(const std::string &name, unsigned int flags);
+
+  // Create a file with O_RDWR flag
+  static File *CreateFileReadWrite(const std::string &name);
+
+  // Create a file with O_WRONLY flag
+  static File *CreateFileWriteOnly(const std::string &name);
+
+  // Judge if one file exists or not
+  static bool FileExists(const std::string &name);
+
+  // Judge if one directory exists or not
+  static bool DirExists(const std::string &name);
+
+  // Delete one directory and its subdirs recursely by default
+  static void RmDir(const std::string &dir);
+};
+
+}  // namespace maple
+
+#endif // _MAPLE_FILE_IO_H
diff --git a/src/mrt/libmrtbase/include/base/logging.h b/src/mrt/libmrtbase/include/base/logging.h
new file mode 100644
index 0000000000000000000000000000000000000000..20385b9618762da9211e6626861e38fabea907d2
--- /dev/null
+++ b/src/mrt/libmrtbase/include/base/logging.h
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_RUNTIME_BASE_LOGGING_H_
+#define MAPLE_RUNTIME_BASE_LOGGING_H_
+
+#include <ostream>
+#include <sstream>
+#include <functional>
+#include <memory>
+#include <string>
+#include <sys/uio.h>
+#include <cstring>
+#include <cerrno>
+#include "base/macros.h"
+
+#ifndef LOG_TAG
+#define LOG_TAG "maple"
+#endif
+
+namespace maple {
+
+enum LogId {
+  DEFAULT,
+  MAIN,
+  SYSTEM,
+};
+
+enum LogLevel {
+  VERBOSE,
+  DEBUGY,
+  INFO,
+  WARNING,
+  ERROR,
+  FATAL_WITHOUT_ABORT,
+  FATAL,
+};
+
+void InitLogging();
+
+#define LEVEL_LAMBDA(level) ([&]() {  \
+  using ::maple::VERBOSE;             \
+  using ::maple::DEBUGY;              \
+  using ::maple::INFO;                \
+  using ::maple::WARNING;             \
+  using ::maple::ERROR;               \
+  using ::maple::FATAL_WITHOUT_ABORT; \
+  using ::maple::FATAL;               \
+  return (level); }())
+
+#define WOULD_LOG(level) \
+  (UNLIKELY((LEVEL_LAMBDA(level)) >= ::maple::GetMinimumLogLevel()))
+
+#define LOG_STREAM(level)                                           \
+  ::maple::LogData(__FILE__, __LINE__,                              \
+                              LEVEL_LAMBDA(level), LOG_TAG)         \
+      .stream()
+
+#define LOG(level) if (WOULD_LOG(level))  LOG_STREAM(level)
+
+#define PLOG(level) LOG(level)
+
+#define VLOG_IS_ON(module) (::maple::gLogVerbosity.module)
+
+#define VLOG(module) if (VLOG_IS_ON(module)) LOG(INFO)
+
+#ifndef LOG_NDEBUG
+#define LOG_NDEBUG 1
+#endif
+
+#define DLOG(module) if (((LOG_NDEBUG == 1) ? false : VLOG_IS_ON(module))) LOG(DEBUGY)
+
+#ifndef NEVERCALLTHIS
+#define NEVERCALLTHIS(level) LOG(level)
+#endif // NEVERCALLTHIS
+
+#define UNIMPLEMENTED(level) \
+  LOG(level) << __PRETTY_FUNCTION__ << " unimplemented "
+
+#define CHECK(x)                                           \
+  if (!(LIKELY((x))))                                      \
+      ::maple::LogData(__FILE__, __LINE__,                 \
+                                  ::maple::FATAL, LOG_TAG) \
+              .stream()                                    \
+          << "Check failed: " #x << " "
+
+#define CHECK_E(x, str)                  \
+  do {                                   \
+    if (x) {                             \
+      LOG(ERROR) << str << maple::endl;  \
+    }                                    \
+  } while (false);
+
+#define CHECK_E_B(x, str)                \
+  do {                                   \
+    if (x) {                             \
+      LOG(ERROR) << str << maple::endl;  \
+      return false;                      \
+    }                                    \
+  } while (false);
+
+#define CHECK_E_V(x, str)                \
+  do {                                   \
+    if (x) {                             \
+      LOG(ERROR) << str << maple::endl;  \
+      return;                            \
+    }                                    \
+  } while (false);
+
+#define CHECK_E_P(x, str)                \
+  do {                                   \
+    if (x) {                             \
+      LOG(ERROR) << str << maple::endl;  \
+      return nullptr;                    \
+    }                                    \
+  } while (false);
+
+
+#define CHECK_OP(LHS, RHS, OP)                                                                       \
+  for (auto _values = ::maple::CreateValueHolder(LHS, RHS);                                          \
+       UNLIKELY(!(_values.GetLHS() OP _values.GetRHS()));                                            \
+       /* empty */)                                                                                  \
+  ::maple::LogData(__FILE__, __LINE__,                                                               \
+                              ::maple::FATAL, LOG_TAG)                                               \
+          .stream()                                                                                  \
+      << "Check failed: " << #LHS << " " << #OP << " " << #RHS << " (" #LHS "=" << _values.GetLHS()  \
+      << ", " #RHS "=" << _values.GetRHS()<< ") "
+
+#define CHECK_EQ(x, y) CHECK_OP(x, y, ==)
+#define CHECK_NE(x, y) CHECK_OP(x, y, !=)
+#define CHECK_GE(x, y) CHECK_OP(x, y, >=)
+#define CHECK_GT(x, y) CHECK_OP(x, y, >)
+#define CHECK_LE(x, y) CHECK_OP(x, y, <=)
+#define CHECK_LT(x, y) CHECK_OP(x, y, <)
+
+#define CHECK_PTHREAD_CALL(call, args, what)                           \
+  do {                                                                 \
+    int rc = call args;                                                \
+    if (rc != 0) {                                                     \
+      errno = rc;                                                      \
+      PLOG(FATAL) << #call << " failed for " << (what) << " reason "   \
+                  << strerror(errno) << " return " << errno;           \
+    }                                                                  \
+  } while (false)
+
+#if defined(NDEBUG)
+static constexpr bool kEnableDebugChecks = false;
+#else
+static constexpr bool kEnableDebugChecks = true;
+#endif
+
+#define DCHECK(x) \
+  if (::maple::kEnableDebugChecks) CHECK(x)
+#define DCHECK_EQ(x, y) \
+  if (::maple::kEnableDebugChecks) CHECK_EQ(x, y)
+#define DCHECK_NE(x, y) \
+  if (::maple::kEnableDebugChecks) CHECK_NE(x, y)
+#define DCHECK_LE(x, y) \
+  if (::maple::kEnableDebugChecks) CHECK_LE(x, y)
+#define DCHECK_LT(x, y) \
+  if (::maple::kEnableDebugChecks) CHECK_LT(x, y)
+#define DCHECK_GE(x, y) \
+  if (::maple::kEnableDebugChecks) CHECK_GE(x, y)
+#define DCHECK_GT(x, y) \
+  if (::maple::kEnableDebugChecks) CHECK_GT(x, y)
+
+template <typename LHS, typename RHS>
+class ValueHolder {
+ public:
+  constexpr ValueHolder(LHS l, RHS r);
+
+  LHS GetLHS();
+  RHS GetRHS();
+
+ private:
+  LHS lhs;
+  RHS rhs;
+};
+
+template <typename LHS, typename RHS>
+ValueHolder<LHS, RHS> CreateValueHolder(LHS lhs, RHS rhs);
+
+class LogData {
+ public:
+  LogData(const char* file, unsigned int line, LogLevel level, const char* tag);
+
+  ~LogData();
+
+  std::ostream& stream();
+
+ private:
+#if defined(__ANDROID__) || defined(__ZIDANE__)
+  std::ostringstream oStringBuffer;
+#endif
+  const char* const fileName;
+  const unsigned int lineNumber;
+  const LogLevel logLevel;
+  const char* const logTag;
+};
+
+LogLevel GetMinimumLogLevel();
+
+// The members of this struct are the valid arguments to VLOG and VLOG_IS_ON in code,
+// and the "-verbose:" command line argument.
+struct LogVerbosity {
+  bool jni;
+  bool binding;
+  bool startup;
+  bool jvm;
+  bool thread;
+  bool classloader;
+  bool mpllinker;
+  bool lazybinding;
+  bool hotfix;
+  bool signals;
+  bool gc;
+  bool rc;
+  bool eh;
+  bool stackunwind;
+  bool reflect;
+  bool methodtrace;
+  bool classinit;
+  bool bytecodeverify;
+  bool printf;
+  bool monitor;
+  bool profiler;
+  bool rcreleasetrace;
+  bool jsan;
+  bool nativeleak;
+  bool addr2line;
+  bool systrace_lock_logging;  // Enabled with "-verbose:sys-locks".
+  // for rc backup tracing debug
+  bool gcbindcpu;
+  bool rcverify;
+  bool immediaterp;
+  bool opengclog;
+  bool openrctracelog;
+  bool openrplog;
+  bool opencyclelog;
+  bool opennativelog;
+  bool allocatorfragmentlog;
+  bool allocatorlog;
+  bool openmixlog;
+  bool dumpgarbage;
+  bool dumpheap;
+  bool dumpheapbeforegc;
+  bool dumpheapaftergc;
+  bool dumpheapsimple;
+  bool dumpgcinfoonsigquit;
+  bool jdwp;
+  bool decouple;
+  bool decoupleStats;
+  bool decoupleCheck;
+  bool staticdcp;
+  bool decoupleNoCache;
+  bool nonconcurrentgc;
+  bool conservativestackscan;
+  bool gconly;
+  bool zterp;
+  bool jsanlite;
+};
+
+extern LogVerbosity gLogVerbosity;
+extern const char *const endl;
+extern unsigned int abortingCnt;
+
+extern void InitLogging(char* argv[]);
+
+}  // namespace maple
+
+#endif  // MAPLE_RUNTIME_BASE_LOGGING_H_
diff --git a/src/mrt/libmrtbase/include/base/low_mem_set.h b/src/mrt/libmrtbase/include/base/low_mem_set.h
new file mode 100644
index 0000000000000000000000000000000000000000..e08893d8a6b99841e1cd063d67df798bb04a51d5
--- /dev/null
+++ b/src/mrt/libmrtbase/include/base/low_mem_set.h
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef LOW_MEM_SET_H
+#define LOW_MEM_SET_H
+
+#include <memory>
+#include "base/logging.h"
+#include "base/macros.h"
+
+namespace maple {
+template <class T, class HashEqualFn>
+class LowMemSet {
+ public:
+  static constexpr double kGuardPercent = 0.9;
+  static constexpr size_t kSpaceExpandRate = 2;
+  static constexpr size_t kMinCapacity = 1000;
+
+  LowMemSet() : size(0u), capacity(0u), guardSize(0u), buf(nullptr) {}
+
+  LowMemSet(const LowMemSet &other) = delete;
+
+  LowMemSet(LowMemSet &&other) = delete;
+
+  LowMemSet& operator=(LowMemSet &&other) = delete;
+
+  LowMemSet& operator=(const LowMemSet &other) = delete;
+
+  ~LowMemSet() {
+    DeleteBuf(buf);
+  }
+
+  void Insert(T &&data) {
+    EnsureSize();
+    buf[FindEmptyIndex(data)] = std::move(data);
+    size++;
+  }
+
+  void Insert(const T &data) {
+    EnsureSize();
+    buf[FindEmptyIndex(data)] = data;
+    size++;
+  }
+
+  // ======== condition ======== 0 ================================= (capacity - 1)
+  //               |             |                                         |
+  // nextHashIndex <= nextIndex: |*****|nextHashIndex|--D--|nextIndex|*****|
+  // nextHashIndex >  nextIndex: |--D--|nextIndex|*****|nextHashIndex|--D--|
+  // 1.nextIndex should be large it's hashIndex. In other words: nextIndex is behind nextHashIndex.
+  //   so, if nextIndex < nextHashIndex, nextIndex must be folded, then unfold it.
+  // 2.if some index between in [nextHashIndex,nextIndex) was delte, nextIndex should be moved.
+  void Erase(const size_t index) {
+    CHECK(index < capacity) << "LowMemSet Erase index is invalid!!";
+    if (UNLIKELY(fn.IsEmpty(buf[index]))) {
+      return;
+    }
+
+    size_t eraseIndex = index;
+    size_t nextIndex = GetNextIndex(eraseIndex);
+    do {
+      T &data = buf[nextIndex];
+      if (fn.IsEmpty(data)) {
+        fn.Clear(buf[eraseIndex]);
+        break;
+      }
+      size_t nextHashIndex = fn(data) % capacity;
+      size_t nextNoCircleIndex =
+          nextIndex < nextHashIndex ? nextIndex + capacity : nextIndex;
+      size_t eraseNoCircleIndex =
+          eraseIndex < nextHashIndex ? eraseIndex + capacity : eraseIndex;
+      if (nextHashIndex <= eraseNoCircleIndex && eraseNoCircleIndex < nextNoCircleIndex) {
+        buf[eraseIndex] = std::move(buf[nextIndex]);
+        eraseIndex = nextIndex;
+      }
+      nextIndex = GetNextIndex(nextIndex);
+    } while (nextIndex != index);
+
+    size--;
+
+    return;
+  }
+
+  // Warning: call this funtion before insert
+  void Reserve(size_t num) {
+    if (capacity != 0) {
+      return;
+    }
+    capacity = static_cast<size_t>(num / kGuardPercent + 1);
+    guardSize = num;
+    buf = NewBuf(capacity);
+  }
+
+  // For set: K is same to T.
+  // For map: K is Key, T is std::pair<K, V>
+  // return index of element.
+  template <class K>
+  size_t Find(const K data) {
+    size_t index = (capacity != 0) ? (fn(data) % capacity) : 0;
+    while (true) {
+      T &entry = buf[index];
+      if (fn.IsEmpty(entry)) {
+        return capacity;
+      }
+      if (fn(data, buf[index])) {
+        return index;
+      }
+      index = GetNextIndex(index);
+    }
+  }
+
+  size_t End() const {
+    return capacity;
+  }
+
+  size_t Size() const {
+    return size;
+  }
+
+  // caller must ensure index is valid
+  T &Element(size_t index) {
+    CHECK(index < capacity) << "LowMemSet index is invalid!!";
+    return buf[index];
+  }
+
+  template<typename Func>
+  void ForEach(Func &&func) {
+    size_t count = 0;
+    for (size_t i = 0; i < capacity; i++) {
+      if (fn.IsEmpty(buf[i])) {
+        continue;
+      }
+      func(buf[i]);
+      count++;
+    }
+    CHECK(size == count) << "LowMemSet count & size mismatch!!";
+  }
+
+ private:
+  void EnsureSize() {
+    if (guardSize > size) {
+      return;
+    }
+
+    T *oldBuf = buf;
+    size_t oldCapacity = capacity;
+
+    if (capacity == 0) {
+      capacity = kMinCapacity;
+    } else {
+      capacity = capacity * kSpaceExpandRate;
+    }
+    guardSize = static_cast<size_t>(capacity * kGuardPercent);
+
+    buf = NewBuf(capacity);
+    RestoreBuf(oldBuf, oldCapacity);
+    DeleteBuf(oldBuf);
+  }
+
+  T *NewBuf(size_t newSize) {
+    T *newBuf = new T[newSize];
+    for (size_t i = 0; i < newSize; i++) {
+      fn.Clear(newBuf[i]);
+    }
+    return newBuf;
+  }
+
+  void DeleteBuf(T *data) {
+    if (UNLIKELY(data == nullptr)) {
+      return;
+    }
+    delete []data;
+  }
+
+  void RestoreBuf(T *oldBuf, size_t oldCapacity) {
+    for (size_t i = 0; i < oldCapacity; i++) {
+      T &data = oldBuf[i];
+      if (fn.IsEmpty(data)) {
+        continue;
+      }
+      size_t index = FindEmptyIndex(data);
+      buf[index] = std::move(data);
+    }
+  }
+
+  size_t FindEmptyIndex(const T data) {
+    size_t hash = fn(data);
+    const size_t index = (capacity != 0) ? (hash % capacity) : 0;
+    size_t nextIndex = index;
+    bool isFind = false;
+    do {
+      T &tmp = buf[nextIndex];
+      if (fn.IsEmpty(tmp)) {
+        isFind = true;
+        break;
+      }
+      nextIndex = GetNextIndex(nextIndex);
+    } while (nextIndex != index);
+    CHECK(isFind) << "LowMemSet can not find empty index!";
+    return nextIndex;
+  }
+
+  inline size_t GetNextIndex(size_t index) {
+    return (++index == capacity) ? 0 : index;
+  }
+
+  size_t size;
+  size_t capacity;
+  size_t guardSize;
+  T *buf;
+  HashEqualFn fn;
+};
+} // namespace maple
+
+#endif // LOW_MEM_SET_H
\ No newline at end of file
diff --git a/src/mrt/libmrtbase/include/base/macros.h b/src/mrt/libmrtbase/include/base/macros.h
new file mode 100644
index 0000000000000000000000000000000000000000..c44ef848717f9bf70bf7c5f4cfe9aa1dbc25d979
--- /dev/null
+++ b/src/mrt/libmrtbase/include/base/macros.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_RUNTIME_BASE_MACROS_H_
+#define MAPLE_RUNTIME_BASE_MACROS_H_
+
+#include <stddef.h>
+#include <unistd.h>
+
+// Macro definitions for attribute
+#define ATTR_NO_INLINE __attribute__ ((noinline))
+
+#define ATTR_PACKED(x) __attribute__ ((__aligned__(x), __packed__))
+
+#define ATTR_UNUSED __attribute__((__unused__))
+
+#define ATTR_WARN_UNUSED __attribute__((warn_unused_result))
+
+#if defined (__APPLE__)
+#define ATTR_HOT
+#define ATTR_COLD
+#else
+#define ATTR_HOT __attribute__ ((hot))
+#define ATTR_COLD __attribute__ ((cold))
+#endif
+
+#ifndef NDEBUG
+#define ALWAYS_INLINE
+#else
+#define ALWAYS_INLINE  __attribute__ ((always_inline))
+#endif
+
+#if defined(__clang__)
+#define ATTR_NO_SANITIZE_ADDRESS __attribute__((no_sanitize("address")))
+#else
+#define ATTR_NO_SANITIZE_ADDRESS
+#endif
+
+// Macro definitions for builtin
+#define BUILTIN_UNREACHABLE  __builtin_unreachable
+
+#define LIKELY(exp)       (__builtin_expect((long)!!(exp), 1))
+
+#define UNLIKELY(exp)     (__builtin_expect((long)!!(exp), 0))
+
+// Macro definitions for class operator
+#define DISABLE_CLASS_DEFAULT_CONSTRUCTOR(ClassName) \
+  ClassName() = delete;
+
+#define DISABLE_CLASS_COPY_CONSTRUCTOR(ClassName) \
+  ClassName(const ClassName&) = delete;
+
+#define DISABLE_CLASS_ASSIGN_OPERATOR(ClassName) \
+  ClassName& operator=(const ClassName&) = delete
+
+#define DISABLE_CLASS_COPY_AND_ASSIGN(ClassName) \
+  DISABLE_CLASS_COPY_CONSTRUCTOR(ClassName)      \
+  DISABLE_CLASS_ASSIGN_OPERATOR(ClassName)
+
+#define DISABLE_CLASS_IMPLICIT_CONSTRUCTORS(ClassName) \
+  DISABLE_CLASS_DEFAULT_CONSTRUCTOR(ClassName)         \
+  DISABLE_CLASS_COPY_CONSTRUCTOR(ClassName)            \
+  DISABLE_CLASS_ASSIGN_OPERATOR(ClassName)
+
+// Macro definitions for others
+#define UNUSED(expr) \
+  do {               \
+    (void)(expr);    \
+  } while (0)
+
+#define NO_RETURN [[ noreturn ]]
+
+#ifndef FALLTHROUGH_INTENDED
+#define FALLTHROUGH_INTENDED [[clang::fallthrough]]
+#endif
+
+#if defined(__clang__)
+#define GUARD_OFFSETOF_MEMBER(t, f, expect)  static_assert(offsetof(t, f) == expect, "member offset is changed!");
+#else
+#define GUARD_OFFSETOF_MEMBER(t, f, expect)
+#endif
+
+#endif  // MAPLE_RUNTIME_BASE_MACROS_H_
diff --git a/src/mrt/libmrtbase/include/base/mutex.h b/src/mrt/libmrtbase/include/base/mutex.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e253eb5e183cc079722d521d5f289d1acf1a42d
--- /dev/null
+++ b/src/mrt/libmrtbase/include/base/mutex.h
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MPL_RUNTIME_BASE_MUTEX_H_
+#define MPL_RUNTIME_BASE_MUTEX_H_
+
+#include <pthread.h>
+#include <cstdint>
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <set>
+#include <atomic>
+#include "base/logging.h"
+#include "base/macros.h"
+#include "globals.h"
+
+#if defined(__APPLE__)
+#define MAPLE_USE_FUTEXES 0
+#else
+#define MAPLE_USE_FUTEXES 1
+#endif
+
+#if !defined(__APPLE__)
+#define HAVE_TIMED_RWLOCK 1
+#else
+#define HAVE_TIMED_RWLOCK 0
+#endif
+
+#define CHECK_MUTEX_CALL(call, args) CHECK_PTHREAD_CALL(call, args, name)
+
+namespace maple {
+
+class ReaderWriterMutex;
+class IThread;
+
+class AtomicInteger : public std::atomic<int32_t> {
+ public:
+  AtomicInteger();
+
+  explicit AtomicInteger(int32_t value);
+
+  ~AtomicInteger() = default;
+
+  // avoid to fix the expected value
+  bool CompareExchange(int32_t expected, int32_t desired, std::memory_order order);
+
+  volatile int32_t *Pointer();
+};
+
+enum LockLevel {
+  kLoggingLock = 0,
+  kUnexpectedSignalLock,
+  KANRObjectsLock,
+  kSuspendLock,
+  kThreadSuspendCountLock,
+  kAbortLock,
+  kJniFunctionTableLock,
+  kJniWeakGlobalsLock,
+  kJniGlobalsLock,
+  kDefaultMutexLevel,
+  kAllocatedThreadIdsLock,
+  kMonitorPoolLock,
+  kClassLinkerClassesLock,
+  kMonitorLock,
+  kMonitorListLock,
+  kJniLoadLibraryLock,
+  kThreadListLock,
+  kStartWorldLock,
+  kStopWorldLock,
+  kTracingUniqueMethodsLock,
+  kTracingStreamingLock,
+  kProfilerLock,
+  kRuntimeShutdownLock,
+  kTraceLock,
+  kMutatorLock,
+  kAllocatorLock,
+
+  kLockLevelCount  // Must come last.
+};
+
+enum LockState : int32_t {
+  kLockState = 0x7ABBCCDD,
+  kUnLockState = 0x75443322,
+};
+
+std::ostream &operator<<(std::ostream &os, const LockLevel &rhs);
+class BaseMutex {
+ public:
+  const char *GetName() const;
+
+  virtual bool IsMutex() const;
+
+  virtual bool IsReaderWriterMutex() const;
+
+  virtual bool IsMutatorMutex() const;
+
+  virtual void Dump(std::ostream &os) const = 0;
+
+ protected:
+  friend class ConditionVariable;
+
+  BaseMutex(const char *name, LockLevel level);
+
+  virtual ~BaseMutex();
+
+  void RegisterAsLocked(IThread *self);
+
+  void RegisterAsUnlocked(IThread *self);
+
+  const LockLevel level;  // Support for lock hierarchy.
+  const char *const name;
+};
+
+class Mutex : public BaseMutex {
+ public:
+  explicit Mutex(const char *name = "default name", LockLevel level = kDefaultMutexLevel, bool recursive = false);
+  ~Mutex();
+
+  virtual bool IsMutex() const;
+
+  void ExclusiveLock(IThread *self);
+
+  void Lock(IThread *self);
+
+  bool ExclusiveTryLock(IThread *self);
+
+  bool TryLock(IThread *self);
+
+  void ExclusiveUnlock(IThread *self);
+
+  void Unlock(IThread *self);
+
+  bool IsExclusiveHeld(const IThread *self) const;
+
+  uint64_t GetExclusiveOwnerTid() const;
+
+  unsigned int GetDepth() const;
+
+  void ReleaseMutex(IThread *self);
+
+  virtual void Dump(std::ostream &os) const;
+
+  const Mutex &operator!() const;
+
+ private:
+#if MAPLE_USE_FUTEXES
+  // 0 is unheld, 1 is held.
+  AtomicInteger heldState;
+  // Exclusive owner.
+  volatile uint64_t exclusiveOwner;
+  // Number of waiting contenders.
+  AtomicInteger numContenders;
+#else
+  pthread_mutex_t mutex;
+  volatile uint64_t exclusiveOwner;
+#endif
+  const bool recursive;
+  unsigned int recursionCount;
+  friend class ConditionVariable;
+  DISABLE_CLASS_COPY_AND_ASSIGN(Mutex);
+};
+
+class ReaderWriterMutex : public BaseMutex {
+ public:
+  explicit ReaderWriterMutex(const char *name, LockLevel level = kDefaultMutexLevel);
+  ~ReaderWriterMutex();
+
+  virtual bool IsReaderWriterMutex() const;
+
+  void ExclusiveLock(IThread *self);
+
+  void WriterLock(IThread *self);
+
+  void ExclusiveUnlock(IThread *self);
+
+  void WriterUnlock(IThread *self);
+
+#if HAVE_TIMED_RWLOCK
+  bool ExclusiveLockWithTimeout(IThread *self, int64_t ms, int32_t ns);
+#endif
+
+  void SharedLock(IThread *self) ALWAYS_INLINE;
+
+  void ReaderLock(IThread *self);
+
+  bool SharedTryLock(IThread *self);
+
+  void SharedUnlock(IThread *self) ALWAYS_INLINE;
+
+  void ReaderUnlock(IThread *self);
+
+  bool IsExclusiveHeld(const IThread *self) const;
+
+  bool IsSharedHeld(const IThread *self) const;
+
+  uint64_t GetExclusiveOwnerTid() const;
+
+  virtual void Dump(std::ostream &os) const;
+
+  virtual const ReaderWriterMutex &operator!() const;
+
+ private:
+  void HandleSharedLockContention(IThread *self, int32_t curState);
+
+#if MAPLE_USE_FUTEXES
+  AtomicInteger heldState;
+  volatile uint64_t exclusiveOwner;
+  AtomicInteger numPendingReaders;
+  AtomicInteger numPendingWriters;
+#else
+  pthread_rwlock_t rwlock;
+  volatile uint64_t exclusiveOwner;  // Guarded by rwlock_.
+#endif
+  DISABLE_CLASS_COPY_AND_ASSIGN(ReaderWriterMutex);
+};
+class ConditionVariable {
+ public:
+  ConditionVariable(const char *name, Mutex &mutex);
+  ~ConditionVariable();
+
+  void Broadcast(IThread *self);
+  void Signal(IThread *self);
+  void Wait(IThread *self);
+  bool TimedWait(IThread *self, int64_t ms, int32_t ns);
+  void WaitHoldingLocks(IThread *self);
+
+ private:
+  const char *const name;
+  Mutex &guard;
+#if MAPLE_USE_FUTEXES
+  AtomicInteger sequence;
+  volatile int32_t numWaiters;
+#else
+  pthread_cond_t cond;
+#endif
+  DISABLE_CLASS_COPY_AND_ASSIGN(ConditionVariable);
+};
+class MutexLock {
+ public:
+  MutexLock(IThread *self, Mutex &mu);
+
+  ~MutexLock();
+
+ private:
+  IThread *const owner;
+  Mutex &mu;
+  DISABLE_CLASS_COPY_AND_ASSIGN(MutexLock);
+};
+class ReaderMutexLock {
+ public:
+  ReaderMutexLock(IThread *self, ReaderWriterMutex &mu) ALWAYS_INLINE;
+
+  ~ReaderMutexLock() ALWAYS_INLINE;
+
+ private:
+  IThread *const owner;
+  ReaderWriterMutex &mu;
+  DISABLE_CLASS_COPY_AND_ASSIGN(ReaderMutexLock);
+};
+class WriterMutexLock {
+ public:
+  WriterMutexLock(IThread *self, ReaderWriterMutex &mu);
+
+  ~WriterMutexLock();
+
+ private:
+  IThread *const owner;
+  ReaderWriterMutex &mu;
+  DISABLE_CLASS_COPY_AND_ASSIGN(WriterMutexLock);
+};
+
+std::ostream &operator<<(std::ostream &os, const Mutex &mu);
+std::ostream &operator<<(std::ostream &os, const ReaderWriterMutex &mu);
+class Locks {
+ public:
+  static void Init();
+  static void InitConditions();
+
+  static Mutex *mutatorLock;
+
+  static Mutex *runtimeShutdownLock;
+
+  static Mutex *profilerLock;
+
+  static Mutex *traceLock;
+
+  static Mutex *stopWorldLock;
+  static ConditionVariable *stopWorldCond;
+
+  static Mutex *startWorldLock;
+  static ConditionVariable *startWorldCond;
+
+  // The threadListLock guards ThreadList::list_. It is also commonly held to stop threads
+  // attaching and detaching.
+  static Mutex *threadListLock;
+
+  static ConditionVariable *threadExitCond;
+
+  static Mutex *jniLibrariesLock;
+
+  static ReaderWriterMutex *classlinkerClassesLock;
+
+  static Mutex *allocatedMonitorIdsLock;
+
+  static Mutex *allocatedThreadIdsLock;
+
+  static ReaderWriterMutex *jniGlobalsLock;
+
+  static Mutex *jniWeakGlobalsLock;
+
+  static Mutex *jniFunctionTableLock;
+
+  static Mutex *abortLock;
+
+  static Mutex *threadSuspendCountLock;
+
+  static Mutex *suspendMutex;
+
+  static ConditionVariable *suspendCond;
+
+  static ReaderWriterMutex *anrObjectsLock;
+
+  static Mutex *unexpectedSignalLock;
+
+  static Mutex *loggingLock;
+};
+
+uint64_t SafeGetTid(const IThread *self);
+
+}  // namespace maple
+
+#endif  // MPL_RUNTIME_BASE_MUTEX_H_
diff --git a/src/mrt/libmrtbase/include/base/systrace.h b/src/mrt/libmrtbase/include/base/systrace.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b55eb26a075f963a1c3adcbb0049d513dc913c0
--- /dev/null
+++ b/src/mrt/libmrtbase/include/base/systrace.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_BASE_SYSTRACE_H
+#define MAPLE_RUNTIME_BASE_SYSTRACE_H
+
+#include <string>
+#include <stdarg.h>
+#include <cstdio>
+
+#ifdef __ANDROID__
+#define ATRACE_TAG ATRACE_TAG_DALVIK
+
+#include <cutils/trace.h>
+#include "securec.h"
+
+#ifndef ATRACE_TAG_RUNTIME
+#define ATRACE_TAG_RUNTIME (1 << 23)
+#endif
+
+#else
+#define ATRACE_BEGIN(label)
+#define ATRACE_END()
+static inline bool ATRACE_ENABLED() {
+  return false;
+}
+#endif  // __ANDROID__
+
+namespace maple {
+
+class ScopedTrace {
+ public:
+  explicit ScopedTrace(const char *name, ...);
+
+  explicit ScopedTrace(const std::string &name, ...);
+
+  ~ScopedTrace();
+};
+
+extern "C" {
+
+void RuntimeTraceBegin(uint64_t tag, const char *name, ...);
+
+void RuntimeTraceEnd();
+}
+
+}  // namespace maple
+#endif  // MAPLE_RUNTIME_BASE_SYSTRACE_H
diff --git a/src/mrt/libmrtbase/include/base/types.h b/src/mrt/libmrtbase/include/base/types.h
new file mode 100644
index 0000000000000000000000000000000000000000..649701a1ee3dceca8f432b0f31b4efc29be29145
--- /dev/null
+++ b/src/mrt/libmrtbase/include/base/types.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_RUNTIME_BASE_TYPES_H_
+#define MAPLE_RUNTIME_BASE_TYPES_H_
+
+#include <atomic>
+
+namespace maple {
+
+using address_t = uintptr_t;
+
+using MonitorId = size_t;
+
+using AtomicUInteger = std::atomic<uint32_t>;
+
+} // namespace maple
+
+#endif  // MAPLE_RUNTIME_BASE_TYPES_H_
diff --git a/src/mrt/libmrtbase/include/exception_store.h b/src/mrt/libmrtbase/include/exception_store.h
new file mode 100644
index 0000000000000000000000000000000000000000..85fbc024ed583f1d64acc7b81a2922f8c2ac038c
--- /dev/null
+++ b/src/mrt/libmrtbase/include/exception_store.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef EXCEPTION_STORE_H
+#define EXCEPTION_STORE_H
+
+#include "jni.h"
+#include "tls_store.h"
+
+namespace maple {
+
+class ExceptionVisitor {
+ public:
+  static inline jobject GetPendingException() {
+    return (jobject)maple::tls::GetTLS(tls::kSlotException);
+  }
+
+  static inline void SetPendingException(const jobject ex) {
+    maple::tls::StoreTLS(reinterpret_cast<void*>(ex), tls::kSlotException);
+  }
+
+  static inline jobject GetThrowningException() {
+    return (jobject)maple::tls::GetTLS(tls::kSlotThrowException);
+  }
+
+  static inline void SetThrowningException(const jobject ex) {
+    maple::tls::StoreTLS(reinterpret_cast<void*>(ex), tls::kSlotThrowException);
+  }
+
+  static inline void *GetSignalHandler() {
+    return reinterpret_cast<void*>(maple::tls::GetTLS(tls::kSlotSignalHandler));
+  }
+
+  static inline void  SetSignalHandler(const void *args) {
+    maple::tls::StoreTLS(args, tls::kSlotSignalHandler);
+  }
+
+  static inline void *GetExceptionAddress() {
+    return reinterpret_cast<void*>(maple::tls::GetTLS(tls::kSlotExceptionAddress));
+  }
+
+  static inline void SetExceptionAddress(const void *addr) {
+    maple::tls::StoreTLS(addr, tls::kSlotExceptionAddress);
+  }
+
+};
+
+} // namespace maple
+
+#endif //EXCEPTION_STORE_H
diff --git a/src/mrt/libmrtbase/include/file_system.h b/src/mrt/libmrtbase/include/file_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..4bf75653d938508ac7d34d34e7c5a82ca1a41a1c
--- /dev/null
+++ b/src/mrt/libmrtbase/include/file_system.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_FS_H_
+#define MAPLE_FS_H_
+
+namespace maple {
+namespace fs {
+#if defined(__aarch64__)
+  static constexpr char kSystemLibPath[] = "/system/lib64/";
+  static constexpr char kLibcorePath[] = "/system/lib64/libmaplecore-all.so";
+
+  static constexpr char kLibframeworkPath[] = "/system/lib64/libmapleframework.so";
+#elif defined(__arm__)
+  static constexpr char kSystemLibPath[] = "/system/lib/";
+  static constexpr char kLibcorePath[] = "/system/lib/libmaplecore-all.so";
+  static constexpr char kLibframeworkPath[] = "/system/lib/libmapleframework.so";
+#endif
+}; // namespace fs
+} // end namespace maple
+#endif // end MAPLE_FS_H_
diff --git a/src/mrt/libmrtbase/include/gc_config.h b/src/mrt/libmrtbase/include/gc_config.h
new file mode 100644
index 0000000000000000000000000000000000000000..151a34fb32739da14043aeb29204ce6ef102f527
--- /dev/null
+++ b/src/mrt/libmrtbase/include/gc_config.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_GC_CONGIF_H_
+#define MAPLE_GC_CONGIF_H_
+
+#define MRT_COLLECTOR_NONE (0)     // no collector
+#define MRT_COLLECTOR_MS (1)       // mark & sweep
+#define MRT_COLLECTOR_NAIVERC (2)  // naive rc
+#define MOVING_GC false
+
+#ifndef MRT_COLLECTOR
+#if GCONLY
+#define MRT_COLLECTOR MRT_COLLECTOR_MS       // gc-only collector
+#else
+#define MRT_COLLECTOR MRT_COLLECTOR_NAIVERC  // default collector
+#endif
+#endif
+
+#endif  // MAPLE_GC_CONFIG_H_
diff --git a/src/mrt/libmrtbase/include/gc_roots.h b/src/mrt/libmrtbase/include/gc_roots.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf58a6f123c70af1a7926ec65d7eec3e5e786795
--- /dev/null
+++ b/src/mrt/libmrtbase/include/gc_roots.h
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_GC_ROOTS_H_
+#define MAPLE_GC_ROOTS_H_
+#include <functional>
+#include <iostream>
+#include <sstream>
+#include "jni.h"
+#include "base/macros.h"
+#include "base/types.h"
+#include "gc_callback.h"
+
+namespace maple {
+
+typedef std::function<void(address_t)> rootObjectFunc;
+typedef std::function<void(uint32_t, address_t)> irtVisitFunc;
+typedef std::function<void(address_t*)> rootObjectAddrFunc;
+
+class GCRootsVisitor {
+ public:
+  // Acquire the threadListLock.  This must be called before triggering
+  // yieldpoint to prevent a race condition.  Alternative solutions exist, which
+  // should be considered in a long run.
+  static void AcquireThreadListLock();
+
+  static bool TryAcquireThreadListLock();
+
+  // Release the threadListLock. This should be called after
+  // GCRootsVisotor::Visit(rootObjectFunc) is called.
+  static void ReleaseThreadListLock();
+
+  static bool IsThreadListLockLockBySelf();
+
+  // visit all roots in android mrt, visite its value
+  static void Visit(maplert::RefVisitor &f);
+
+  static void VisitLocalRef(maplert::RefVisitor &f);
+  static void VisitGlobalRef(maplert::RefVisitor &f);
+  static void VisitThreadException(rootObjectFunc &f);
+
+  static void FixLockedObjects(maplert::RefVisitor &f);
+  // visit all roots in android mrt, visite its address
+  static void Visit(rootObjectAddrFunc &f ATTR_UNUSED) {
+  }
+
+  static void ClearWeakGRTReference(uint32_t index, jobject obj);
+
+  // visit weak GRT
+  // VisitWeakGRT is used in STW
+  // VisitWeakGRTConcurrent is used in none-STW
+  static void VisitWeakGRT(irtVisitFunc &f);
+  static void VisitWeakGRT(maplert::RefVisitor &f);
+  static void VisitWeakGRTConcurrent(irtVisitFunc &f);
+};
+
+enum RootType {
+  kRootUnknown = 0,
+  kRootJNIGlobal,
+  kRootJNILocal,
+  kRootJavaFrame,
+  kRootNativeStack,
+  kRootStickyClass,
+  kRootThreadBlock,
+  kRootMonitorUsed,
+  kRootThreadObject,
+  kRootInternedString,
+  kRootFinalizing,
+  kRootDebugger,
+  kRootReferenceCleanup,
+  kRootVMInternal,
+  kRootJNIMonitor,
+};
+inline std::ostream &operator<<(std::ostream &os, const RootType &root_type) {
+  os << (uint32_t)root_type;
+  return os;
+}
+class RootInfo {
+ public:
+  explicit RootInfo(RootType type, uint32_t thread_id = 0);
+  RootInfo(const RootInfo&) = default;
+  virtual ~RootInfo();
+  RootType GetType() const;
+  uint32_t GetThreadId() const;
+  virtual void Describe(std::ostream &os) const;
+  inline std::string ToString() const;
+
+ private:
+  const RootType type_;
+  const uint32_t thread_id_;
+};
+
+std::ostream &operator<<(std::ostream &os, const RootInfo &root_info);
+
+enum VisitRootFlags : uint8_t {
+  kVisitRootFlagAllRoots = 0x1,
+  kVisitRootFlagNewRoots = 0x2,
+  kVisitRootFlagStartLoggingNewRoots = 0x4,
+  kVisitRootFlagStopLoggingNewRoots = 0x8,
+  kVisitRootFlagClearRootLog = 0x10,
+  kVisitRootFlagClassLoader = 0x20,
+  kVisitRootFlagPrecise = 0x80,
+};
+
+class RootVisitor {
+ public:
+  virtual ~RootVisitor();
+
+  virtual ALWAYS_INLINE void VisitRoot(jobject root, const RootInfo &info);
+
+  ALWAYS_INLINE void VisitRootIfNonNull(jobject root, const RootInfo &info);
+
+  virtual void VisitRoots(jobject *roots, size_t count, const RootInfo &info) = 0;
+};
+class SingleRootVisitor : public RootVisitor {
+ private:
+  void VisitRoots(jobject *roots, size_t count, const RootInfo &info) override;
+
+  virtual void VisitRoot(jobject root, const RootInfo &info) override = 0;
+};
+}  // namespace maple
+#endif  // MAPLE_GC_ROOTS_H_
diff --git a/src/mrt/libmrtbase/include/globals.h b/src/mrt/libmrtbase/include/globals.h
new file mode 100644
index 0000000000000000000000000000000000000000..c49213f4f52d133369d60c449c420e5ca1b75e70
--- /dev/null
+++ b/src/mrt/libmrtbase/include/globals.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_RUNTIME_GLOBALS_H_
+#define MAPLE_RUNTIME_GLOBALS_H_
+
+#include <stddef.h>
+#include <cstdint>
+#include "base/logging.h"
+
+namespace maple {
+
+// Time Factors
+static constexpr uint64_t kTimeFactor = 1000LL;
+static constexpr uint64_t kSecondToMillisecond = kTimeFactor;
+static constexpr uint64_t kMillisecondToNanosecond = kTimeFactor * kTimeFactor;
+static constexpr uint64_t kSecondToNanosecond = kSecondToMillisecond * kMillisecondToNanosecond;
+
+static constexpr size_t KB = 1024;
+static constexpr size_t MB = KB * KB;
+static constexpr size_t GB = KB * KB * KB;
+
+// GC priority
+constexpr int32_t kGCThreadPriority            = -18; // default priority
+constexpr int32_t kGCThreadStwPriority         = -18; // priority used in stw stage
+constexpr int32_t kGCThreadConcurrentPriority  = 0;   // priority used in concurrent stage
+constexpr int32_t kPriorityPromoteStep         = -5;  // priority promote step
+constexpr int32_t kGCThreadNumAdjustFactor     = 2;   // move to platform information
+constexpr int32_t kGCThreadNumAdjustFactorAPP  = 4;   // move to platform information
+
+// System default page size in linux
+static constexpr uint32_t kPageSize = 4096;
+
+// Error msg
+static constexpr uint32_t kMaxStrErrorBufLen = 128;
+
+// Whether or not this is a debug build. Useful in conditionals where NDEBUG isn't.
+#if defined(NDEBUG)
+static constexpr bool kDebugBuild = false;
+#else
+static constexpr bool kDebugBuild = true;
+#endif
+
+template <typename T>
+struct Identity {
+  using type = T;
+};
+// For rounding integers.
+// Note: Omit the `n` from T type deduction, deduce only from the `x` argument.
+template<typename T>
+constexpr bool IsPowerOfTwo(T x) {
+  static_assert(std::is_integral<T>::value, "T must be integral");
+  return (x & (x - 1)) == 0;
+}
+
+template<typename T>
+T RoundDown(T x, typename Identity<T>::type n);
+
+template<typename T>
+T RoundDown(T x, typename Identity<T>::type n) {
+  DCHECK(IsPowerOfTwo(n));
+  return (x & -n);
+}
+
+template<typename T>
+constexpr T RoundUp(T x, typename std::remove_reference<T>::type n);
+
+template<typename T>
+constexpr T RoundUp(T x, typename std::remove_reference<T>::type n) {
+  return RoundDown(x + n - 1, n);
+}
+
+template<typename T>
+inline T* AlignUp(T* x, uintptr_t n);
+
+template<typename T>
+inline T* AlignUp(T* x, uintptr_t n) {
+  return reinterpret_cast<T*>(RoundUp(reinterpret_cast<uintptr_t>(x), n));
+}
+
+template <class T>
+static constexpr T AlignUp(T size, T alignment) {
+  return ((size + alignment - 1) & ~(alignment - 1));
+}
+
+template <class T>
+static constexpr T AlignDown(T size, T alignment) {
+  return (size & ~(alignment - 1));
+}
+
+}  // namespace maple
+
+#endif  // MAPLE_RUNTIME_GLOBALS_H_
diff --git a/src/mrt/libmrtbase/include/lock_word.h b/src/mrt/libmrtbase/include/lock_word.h
new file mode 100644
index 0000000000000000000000000000000000000000..ef8c82b559c14934a1c60471ca5b52cde058bed0
--- /dev/null
+++ b/src/mrt/libmrtbase/include/lock_word.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_OBJECT_LOCK_WORD_H_
+#define MAPLE_OBJECT_LOCK_WORD_H_
+
+#include "monitor.h"
+#include "monitor_pool.h"
+
+namespace maple {
+
+/*
+  format:
+  ThinLock:
+  |10|98|765432109876|5432109876543210|
+  |00|xx|lock count  |thread id       |
+
+  FatLock:
+  |10|98|7654321098765432109876543210|
+  |01|xx| MonitorId                  |
+
+  HashCode:
+  |10|98|7654321098765432109876543210|
+  |10|xx| HashCode                   |
+*/
+class LockWord {
+ public:
+  enum SizeShiftsAndMasks {
+    kStateSize = 2,
+    kReadBarrierStateSize = 2,
+
+    // ThinLock
+    kThinLockOwnerSize = 16,
+    kThinLockCountSize = 32 - kThinLockOwnerSize - kStateSize - kReadBarrierStateSize,
+    // ThinLock owner
+    kThinLockOwnerShift = 0,
+    kThinLockOwnerMask = (1 << kThinLockOwnerSize) - 1,
+    kThinLockMaxOwner = kThinLockOwnerMask,
+    // ThinLock Count
+    kThinLockCountShift = kThinLockOwnerSize + kThinLockOwnerShift,
+    kThinLockCountMask = (1 << kThinLockCountSize) - 1,
+    kThinLockMaxCount = kThinLockCountMask,
+
+    // FatLock
+    kMonitorIdShift = 0,
+    kMonitorIdSize = 32 - kStateSize - kReadBarrierStateSize,
+    kMonitorIdMask = (1 << kMonitorIdSize) - 1,
+    kMaxMonitorId = kMonitorIdMask,
+
+    // HashCode
+    kHashShift = 0,
+    kHashSize = 32 - kStateSize - kReadBarrierStateSize,
+    kHashMask = (1 << kHashSize) - 1,
+    kMaxHash = kHashMask,
+
+    // Hash Cached flag
+    kHashFlagShift = kThinLockCountSize + kThinLockCountShift,
+    kHashFlagMaskShifted  = 1 << kHashFlagShift,
+
+    // Lock Status
+    kStateThinOrUnlocked = 0,
+    kStateFat = 1,
+    kStateHash = 2,
+
+    // State in the highest bits.
+    kStateShift = kReadBarrierStateSize + kThinLockCountSize + kThinLockCountShift,
+    kStateMask = (1 << kStateSize) - 1,
+    kStateMaskShifted = kStateMask << kStateShift,
+  };
+
+  enum LockState {
+    kUnlocked = 0,
+    kThinLocked,
+    kFatLocked,
+    kHashCode,
+    kUndefined,
+  };
+
+  LockWord();
+  LockWord(uint32_t val);
+  LockWord(Monitor* mon);
+
+  static LockWord FromThinLockId(uint32_t threadId, uint32_t count, uint32_t ATTR_UNUSED) {
+    // CHECK(threadId <= 0xffff) << "thread id out of maxsize" << maple::endl;
+    return LockWord((threadId << kThinLockOwnerShift) | (count << kThinLockCountShift) |
+                    (kStateThinOrUnlocked << kStateShift));
+  }
+
+  static LockWord FromHashCode(uint32_t hashCode, uint32_t unused ATTR_UNUSED) {
+    CHECK_LE(hashCode, static_cast<uint32_t>(kMaxHash));
+    return LockWord((hashCode << kHashShift) |
+                    (kStateHash << kStateShift));
+  }
+
+  LockState GetState() const;
+
+  uint32_t ThinLockOwner() const;
+
+  uint32_t ThinLockCount() const;
+
+  Monitor* FatLockMonitor() const;
+
+  int32_t GetHashCode();
+
+  uint32_t GetHashFlag() const;
+
+  uint32_t GetValue() const;
+
+ private:
+  uint32_t value;
+};
+
+} // namespace maple
+#endif // MAPLE_OBJECT_LOCK_WORD_H_
diff --git a/src/mrt/libmrtbase/include/monitor.h b/src/mrt/libmrtbase/include/monitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1fad910aa098b88c76122947ae84fd9b42afe32
--- /dev/null
+++ b/src/mrt/libmrtbase/include/monitor.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_OBJECT_MONITOR_H_
+#define MAPLE_OBJECT_MONITOR_H_
+
+#include <cstdint>
+#include <jni.h>
+#include <atomic>
+#include "base/mutex.h"
+#include "base/types.h"
+#include "spinlock.h"
+#include "threadstate.h"
+
+namespace maple {
+
+class IThread;
+class LockWord;
+
+#define CAS_LOCK(lock) lock.Lock();
+#define CAS_UNLOCK(lock) lock.Unlock();
+extern SpinLock gDeflatedMonitorContenderLock;
+
+class Monitor {
+ public:
+  Monitor(IThread* tSelf ATTR_UNUSED, MonitorId id);
+
+  ~Monitor();
+
+  // Object.wait().
+  static void Wait(IThread* tSelf, address_t obj, const long long ms, const int ns,
+             const bool interruptShouldThrow, ThreadState why);
+
+  static void DoNotify(IThread* tSelf, address_t obj, bool notifyAll);
+
+  // Object.notify()
+  static void Notify(IThread* tSelf, address_t obj) {
+    DoNotify(tSelf, obj, false);
+  }
+
+  // Object.notifyAll()
+  static void NotifyAll(IThread* tSelf, address_t obj) {
+    DoNotify(tSelf, obj, true);
+  }
+
+  // for synchronized
+  static jint MonitorEnter(IThread* tSelf, address_t obj);
+
+  static jint MonitorExit(IThread* tSelf, address_t obj);
+
+  static bool Inflate(IThread* tSelf, address_t obj, LockWord lockWord, uint32_t hashCode ATTR_UNUSED);
+
+  static void DumpDeflatedMonitor(std::ostream& os);
+
+  static void CollectDeflatedMonitor(Monitor *mon, int tid, void *obj);
+
+  static void ReleaseHashObject(address_t obj);
+
+  static void FixGlobalHash(address_t obj, address_t to);
+
+  static int32_t IdentityHashCode(address_t obj);
+
+  bool Lock(IThread* tSelf);
+
+  bool GetLockStatusWhenRelease() const;
+
+  jint Unlock(IThread* tSelf, address_t obj);
+
+  void Wait(IThread* tSelf, const long long ms, const int ns,
+            const bool interruptShouldThrow, ThreadState why);
+
+  void Notify(IThread* tSelf);
+
+  void NotifyAll(IThread* tSelf);
+
+  static uint32_t GetLockOwnerThreadId(address_t obj);
+  static uint32_t GetLockOwnerOsThreadId(address_t obj);
+
+  uint32_t GetOwnerThreadId();
+  uint32_t GetOwnerSystemTid();
+
+  ALWAYS_INLINE static void AtraceMonitorLock(IThread* self, address_t obj, bool is_wait);
+  static void AtraceMonitorLockImpl(IThread* self, address_t obj, bool is_wait);
+  ALWAYS_INLINE static void AtraceMonitorUnlock();
+
+  MonitorId GetMonitorId() const;
+
+  void SetLockCount(int count);
+
+  int GetLockCount() const;
+
+  bool HasHashCode() const;
+
+  void FixReloc(address_t to);
+
+  int32_t GetHashCode(address_t obj);
+
+  MonitorId monitorId;
+
+  Monitor* nextFree;
+
+
+ private:
+  void AppendToWaitSet(IThread* thread);
+
+  void RemoveFromWaitSet(IThread* thread);
+
+  bool TryLockLocked(IThread* tSelf);
+
+  void WakeUpMonitorContenders(bool isNotifyAll);
+
+  Mutex monitorLock;
+
+  ConditionVariable monitorContender;
+
+  IThread *waitSet;
+
+  uint32_t volatile ownerId;
+
+  int lockCount;
+
+  // wait thread number
+  int numWaiters;
+
+  std::atomic <int> fatLockCount;
+
+  // jobject related monitor
+  address_t object;
+
+  // hashcode
+  AtomicUInteger hashCode;
+};
+
+} // namespace maple
+#endif // MAPLE_OBJECT_MONITOR_H_
diff --git a/src/mrt/libmrtbase/include/monitor_pool.h b/src/mrt/libmrtbase/include/monitor_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..62323d33741a7ebe3b70eece8c0c66ba99f45275
--- /dev/null
+++ b/src/mrt/libmrtbase/include/monitor_pool.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_OBJECT_MONITOR_POOL_H_
+#define MAPLE_OBJECT_MONITOR_POOL_H_
+
+#include "monitor.h"
+#include "globals.h"
+#include "base/types.h"
+
+namespace maple {
+
+class IThread;
+
+class MonitorPool {
+ public:
+  MonitorPool();
+
+  ~MonitorPool();
+
+  static Monitor *CreateMonitor(IThread *self) {
+    return monitorPool->CreateMonitorInPool(self);
+  }
+
+  static void ReleaseMonitor(IThread *self, Monitor *monitor) {
+    monitorPool->ReleaseMonitorToPool(self, monitor);
+  }
+
+  static Monitor *MonitorFromMonitorId(MonitorId mId) {
+    return monitorPool->LookupMonitor(mId);
+  }
+
+  static MonitorId MonitorIdFromMonitor(const Monitor *m) {
+    return m->GetMonitorId();
+  }
+
+ private:
+  void AllocateChunk();
+
+  void FreeInternal();
+  /*
+    Get Monitor from free list.
+    If free list is null then create new chunk.
+  */
+  Monitor *CreateMonitorInPool(IThread*);
+
+  // Release Monitor to free list.
+  void ReleaseMonitorToPool(IThread*, Monitor*);
+
+  Monitor* LookupMonitor(MonitorId mId) const;
+
+  static const size_t kInitialChunkStorage = 256U;
+
+  static inline size_t ChunkListCapacity(size_t index) {
+    return kInitialChunkStorage << index;
+  }
+
+  static size_t MonitorIdToOffset(MonitorId id) {
+    return id << 3;
+  }
+
+  static MonitorId OffsetToMonitorId(size_t offset) {
+    return static_cast<MonitorId>(offset >> 3);
+  }
+
+  static const size_t kChunkSize = kPageSize;
+
+  static const size_t kMonitorAlignment = 8;
+
+  static const size_t kAlignedMonitorSize = (sizeof(Monitor) + kMonitorAlignment - 1) & -kMonitorAlignment;
+
+  static const size_t kChunkCapacity = kPageSize / kAlignedMonitorSize;
+
+  static const size_t kMaxChunkLists = 8;
+
+  static const size_t kMaxListSize = kInitialChunkStorage << (kMaxChunkLists - 1);
+
+  uintptr_t* monitorChunks[kMaxChunkLists];
+
+  size_t currentChunkListIndex;
+
+  size_t numChunks;
+
+  size_t currentChunkListCapacity;
+
+  static MonitorPool *monitorPool;
+
+  Monitor *firstFree;
+};
+
+} // namespace maple
+#endif // MAPLE_OBJECT_MONITOR_POOL_H_
diff --git a/src/mrt/libmrtbase/include/mpl_cache_first_file.h b/src/mrt/libmrtbase/include/mpl_cache_first_file.h
new file mode 100644
index 0000000000000000000000000000000000000000..0bd530456661f723aa72b588891cd059d0c536e4
--- /dev/null
+++ b/src/mrt/libmrtbase/include/mpl_cache_first_file.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MPL_CACHE_FIRST_FILE_H
+#define MPL_CACHE_FIRST_FILE_H
+
+#include <ostream>
+#include <sstream>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+#include <sys/uio.h>
+#include "base/macros.h"
+
+namespace maple {
+// equal MplLinkCacheType::kCacheButt
+const int32_t kDecoupleCacheTypeNum = 10;          // 10 means cache file num(equal CACHE_FILE_NUM in mpl_cache_gen.cpp)
+static const int32_t kDecoupleCacheTypeStart = 2;  // cache type start from 2, which means vtb cache.
+static const int32_t kMaxNonStubSoNum = 999;       // non stub so's idx must be less than 999
+static const int32_t kMultiSoStart = 2;            // multi so start from 2
+
+struct LinkerCacheFileFdPerSo {
+  int32_t mplDecoupleCacheFd[kDecoupleCacheTypeNum];
+  bool mplStubSoExist;
+  uint32_t validCacheTypeNum;
+};
+
+class MplCacheFirstFile {
+ public:
+  static bool GetInstallStat();
+  static void SetInstallStat();
+  static void ResetInstallStat();
+  static int32_t GetFd(const std::string &mplSoPath, uint32_t cacheType);
+  static void ResetFdAll();
+  static bool GetNeedStatFlag();
+  static void SetNeedStatFlag(bool value);
+  static bool GetGenerateFileExit();
+  static void SetGenerateFileExit(bool value);
+  static void SetNonStubFdStr(std::string &str);
+  static void SetStubFdStr(std::string &str);
+  static bool ParseFdStr();
+ private:
+  static bool GetStrWithDivision(std::string& mplSoFdStrRemain, std::string& mplSoFdStrOut,
+                                 const std::string& divisionStr);
+  static bool ParseFdStrOneSo(const std::string &mplSoFdStrPerSo, bool mplStubSoExist);
+  static bool GetSoIdxFromPath(const std::string &mplSoPath, uint32_t &soIdx, bool &stubSoFlag);
+  static bool mplDecoupleInstallStat;
+  static bool needStatFlag;
+  static bool generateFileExit;
+  static std::string mplSoFdStrArg;
+  static std::string mplStubSoFdStrArg;
+  static std::vector<LinkerCacheFileFdPerSo> mplCacheFileFd;
+};
+}  // namespace maple
+
+#endif  // MPL_CACHE_FIRST_FILE_H
diff --git a/src/mrt/libmrtbase/include/object_base.h b/src/mrt/libmrtbase/include/object_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..1deac158dc340b9fbcf536af7d9488c830d50445
--- /dev/null
+++ b/src/mrt/libmrtbase/include/object_base.h
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_OBJECT_BASE_H_
+#define MAPLE_OBJECT_BASE_H_
+
+
+#include "spinlock.h"
+#include "monitor.h"
+#include "monitor_pool.h"
+#include <jni.h>
+#include <atomic>
+#include "base/logging.h"
+#include "base/types.h"
+
+namespace maple {
+
+class Monitor;
+
+class ObjectBase {
+ public:
+  ObjectBase();
+  ~ObjectBase();
+
+  /* This method causes the current thread to wait until another thread invokes the notify() method
+  or the notifyAll() method for this object. */
+  static void Wait(address_t obj);
+
+  /* This method causes the current thread to wait until another thread invokes the notify() method
+  or the notifyAll() method for this object, or some other thread interrupts the current thread,
+  or a certain amount of real time has elapsed. */
+  static void Wait(address_t obj, const long long  ms, const int ns);
+
+  /* This method wakes up a single thread that is waiting on this object's monitor. */
+  static void Notify(address_t obj);
+
+  /* This method wakes up all threads that are waiting on this object's monitor. */
+  static void NotifyAll(address_t obj);
+
+  /* This method holds up a lock by current thread via synchronized. */
+  static jint MonitorEnter(address_t obj);
+
+  /* This method release a lock by current thread. */
+  static jint MonitorExit(address_t obj);
+
+  static uint32_t GetLockOwnerThreadId(address_t obj);
+
+  static inline bool SetMonitorWord(address_t obj, uint32_t old_val, uint32_t new_val) {
+#ifdef USE_32BIT_REF
+    AtomicUInteger *paddr = reinterpret_cast<AtomicUInteger*>(obj + sizeof(uint32_t));
+#else //!USE_32BIT_REF
+    AtomicUInteger *paddr = reinterpret_cast<AtomicUInteger*>(obj + sizeof(uintptr_t*));
+#endif //USE_32BIT_REF
+#ifdef __arm__
+    // due to "Spurious Failure" of compare_exchange_weak, compare_exchange_strong is chosen here
+    bool success = paddr->compare_exchange_strong(old_val, new_val, std::memory_order_acq_rel);
+#else
+    bool success = paddr->compare_exchange_weak(old_val, new_val, std::memory_order_seq_cst);
+#endif
+    return success;
+  }
+
+  static inline void SetMonitorWord(address_t obj, uint32_t new_val) {
+#ifdef USE_32BIT_REF
+    AtomicUInteger *paddr = reinterpret_cast<AtomicUInteger*>(obj + sizeof(uint32_t));
+#else // !USE_32BIT_REF
+    AtomicUInteger *paddr = reinterpret_cast<AtomicUInteger*>(obj + sizeof(uintptr_t*));
+#endif // USE_32BIT_REF
+    paddr->store(new_val, std::memory_order_seq_cst);
+  }
+
+  static inline uint32_t &GetMonitorWordVal(address_t obj) {
+#ifdef USE_32BIT_REF
+    uint32_t *paddr = reinterpret_cast<uint32_t*>(obj + sizeof(uint32_t));
+#else // !USE_32BIT_REF
+    uint32_t *paddr = reinterpret_cast<uint32_t*>(obj + sizeof(uintptr_t*));
+#endif // USE_32BIT_REF
+    return *paddr;
+  }
+
+  static inline uint32_t GetMonitorWord(address_t obj) {
+#ifdef USE_32BIT_REF
+    AtomicUInteger *paddr = reinterpret_cast<AtomicUInteger*>(obj + sizeof(uint32_t));
+#else // !USE_32BIT_REF
+    AtomicUInteger *paddr = reinterpret_cast<AtomicUInteger*>(obj + sizeof(uintptr_t*));
+#endif // USE_32BIT_REF
+    return *paddr;
+  }
+
+  static uint32_t GenerateIdentityHashCode();
+
+  static int32_t IdentityHashCode(address_t obj);
+
+  static AtomicUInteger hashCodeSeed;
+
+  static bool ReleaseResource(address_t obj);
+  static void FixRelocObjResource(address_t obj, uint32_t lock, address_t to);
+};
+
+}  // namespace maple
+#endif // MAPLE_OBJECT_BASE_H_
diff --git a/src/mrt/libmrtbase/include/primitive.h b/src/mrt/libmrtbase/include/primitive.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f74c0ab0613c8f0df161562fbff0cfdef97c92b
--- /dev/null
+++ b/src/mrt/libmrtbase/include/primitive.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_RUNTIME_PRIMITIVE_H
+#define MAPLE_RUNTIME_PRIMITIVE_H
+
+#include "base/logging.h"
+#include "base/macros.h"
+
+namespace maple {
+
+class Primitive {
+ public:
+  enum Type : uint32_t {
+    kNot = 0,
+    kBoolean,
+    kByte,
+    kChar,
+    kShort,
+    kInt,
+    kLong,
+    kFloat,
+    kDouble,
+    kVoid,
+    kLast
+  };
+
+  struct TypeInfo {
+    Type type;
+    char charName;
+    char* charArrayName;
+    char* charArrayDescriptorName;
+    bool IsNumericType;
+    bool IsSignedNumericType;
+    size_t BitsRequiredForLargestValue;
+    bool IsReferenceType;
+    size_t ComponentSize;
+  };
+
+  static TypeInfo typeinfoCache[kLast];
+
+  static TypeInfo GetTypeInfo(Type type) {
+    return typeinfoCache[type];
+  }
+
+  static const TypeInfo *GetTypeInfoByCharName(char name);
+
+  static const char* Descriptor(Type type) {
+    return GetTypeInfo(type).charArrayName;
+  }
+
+  static void PrettyDescriptor_forField(Primitive::Type t, std::string &descriptor) {
+    descriptor = GetTypeInfo(t).charArrayDescriptorName;
+  }
+
+  static bool IsNumericType(Type type) {
+    return GetTypeInfo(type).IsNumericType;
+  }
+
+  static bool IsSignedNumericType(Type type) {
+    return GetTypeInfo(type).IsSignedNumericType;
+  }
+
+  static size_t BitsRequiredForLargestValue(Type type) {
+    return GetTypeInfo(type).BitsRequiredForLargestValue;
+  }
+
+  static inline bool IsReferenceType(Type type) {
+    return GetTypeInfo(type).IsReferenceType;
+  }
+
+  static inline bool IsPrimitiveType(Primitive::Type type) {
+    return !IsReferenceType(type);
+  }
+
+  static void GetPrimitiveClassName(const char *descriptor, std::string &name) {
+    const auto *info = GetTypeInfoByCharName(descriptor[0]);
+    if (info != nullptr) {
+      name += info->charArrayDescriptorName;
+    }
+    return;
+  }
+
+  static Type GetType(char type) {
+    Type rc = kNot;
+    const auto *info = GetTypeInfoByCharName(type);
+    if (info != nullptr) {
+      rc = info->type;
+    }
+    return rc;
+  }
+
+ private:
+  DISABLE_CLASS_IMPLICIT_CONSTRUCTORS(Primitive);
+};
+
+}  // namespace maple
+#endif  // MAPLE_RUNTIME_PRIMITIVE_H
diff --git a/src/mrt/libmrtbase/include/scoped_spinlock.h b/src/mrt/libmrtbase/include/scoped_spinlock.h
new file mode 100644
index 0000000000000000000000000000000000000000..933bd099ddaf08a996a5348d81fbe41e46f32b9c
--- /dev/null
+++ b/src/mrt/libmrtbase/include/scoped_spinlock.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_SCOPED_SPINLOCK_H
+#define MAPLE_SCOPED_SPINLOCK_H
+
+#include "base/macros.h"
+
+namespace maple {
+
+template <typename LockType>
+class ScopedSpinLock {
+ public:
+  explicit ScopedSpinLock(LockType &lock) : sl(lock) {
+    sl.Lock();
+  }
+
+  ~ScopedSpinLock() {
+    sl.Unlock();
+  }
+
+ private:
+  LockType &sl;
+  DISABLE_CLASS_COPY_AND_ASSIGN(ScopedSpinLock);
+};
+
+} // namespace maple
+
+#endif // MAPLE_SCOPED_SPINLOCK_H
diff --git a/src/mrt/libmrtbase/include/spinlock.h b/src/mrt/libmrtbase/include/spinlock.h
new file mode 100644
index 0000000000000000000000000000000000000000..524778ca41294ce0b4379c77d8e2006802021ad0
--- /dev/null
+++ b/src/mrt/libmrtbase/include/spinlock.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_SPINLOCK_H
+#define MAPLE_SPINLOCK_H
+#include <pthread.h>
+#include "scoped_spinlock.h"
+
+namespace maple {
+
+class SpinLock {
+ public:
+  // Create a Mutex that is not held by anybody.
+  inline SpinLock();
+
+  // Destructor
+  inline ~SpinLock();
+
+  inline void Lock();
+  inline void Unlock();
+  inline bool TryLock();
+
+ private:
+  pthread_spinlock_t spinlock;
+  DISABLE_CLASS_COPY_AND_ASSIGN(SpinLock);
+};
+
+inline SpinLock::SpinLock() {
+  pthread_spin_init(&spinlock, 0);
+}
+
+inline SpinLock::~SpinLock() {
+  pthread_spin_destroy(&spinlock);
+}
+
+inline void SpinLock::Lock() {
+  pthread_spin_lock(&spinlock);
+}
+
+inline void SpinLock::Unlock() {
+  pthread_spin_unlock(&spinlock);
+}
+
+inline bool SpinLock::TryLock() {
+  return pthread_spin_trylock(&spinlock) == 0;
+}
+
+using SpinAutoLock = ScopedSpinLock<SpinLock>;
+
+}  // namespace maple
+#endif  // MAPLE_SPINLOCK_H
diff --git a/src/mrt/libmrtbase/include/syscall.h b/src/mrt/libmrtbase/include/syscall.h
new file mode 100644
index 0000000000000000000000000000000000000000..4bed5604dccc3d304339191c6cce1a5ff27fe933
--- /dev/null
+++ b/src/mrt/libmrtbase/include/syscall.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_SYSCALL_H_
+#define MAPLE_SYSCALL_H_
+#include "sys/syscall.h"
+#include <sys/prctl.h>
+#include "linux/futex.h"
+#include  <ctime>
+
+namespace maple {
+
+int futex(volatile int *uaddr, int op, int val, const struct timespec *timeout,
+          volatile int *uaddr2, int val3);
+
+pid_t GetTid();
+
+pid_t GetPid();
+
+int TgKill(int tgid, int tid, int sig);
+
+#ifndef PR_SET_VMA
+#define PR_SET_VMA           0x53564d41
+#define PR_SET_VMA_ANON_NAME 0
+#endif
+
+#define MRT_PRCTL(base_address, allocated_size, mmtag) \
+    (void)prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, base_address, allocated_size, mmtag)
+
+} // namespace maple
+#endif // MAPLE_SYSCALL_H_
diff --git a/src/mrt/libmrtbase/include/thread_api.h b/src/mrt/libmrtbase/include/thread_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b7c605fdc78ca7e6e6852af02e25983ec88cf78
--- /dev/null
+++ b/src/mrt/libmrtbase/include/thread_api.h
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_RUNTIME_THREAD_API_H_
+#define MAPLE_RUNTIME_THREAD_API_H_
+
+#include <string>
+#include <vector>
+
+#include "threadstate.h"
+#include "jni.h"
+#include "base/mutex.h"
+#include "spinlock.h"
+#include "monitor.h"
+#include "gc_roots.h"
+#include "tls_store.h"
+#include "gc_callback.h"
+
+namespace maple {
+
+struct ObjectInfo;
+
+enum LOCK_STATE {
+  kMplWaitingTo,
+  kMplLocked,
+  kMplWaitingOn,
+  kMplSleepingOn,
+};
+
+class IThread {
+ public:
+  static bool &is_started_;
+  inline static IThread* Current() {
+    if (UNLIKELY(is_started_ == false)) {
+      return nullptr;
+    }
+    void* thread = GetTLS(tls::kSlotThreadSelf);
+    return reinterpret_cast<IThread*>(thread);
+  }
+
+  // get a thread related  env
+  virtual JNIEnv* GetJniEnv() const = 0;
+
+  virtual JNIEnv* PreNativeCall() = 0;
+
+  virtual void PostNativeCall(JNIEnv* env) = 0;
+
+  virtual jobject MakeReference(JNIEnv* env, address_t addr) const = 0;
+
+  virtual jobject DecodeReference(jobject obj) const = 0;
+
+  virtual jobject JniAddObj2LocalRefTbl(JNIEnv* env, address_t addr) const = 0;
+
+  virtual address_t JniDecode(JNIEnv* env, jobject obj) const = 0;
+
+  virtual ~IThread();
+
+  virtual bool IsInterruptedLocked() = 0;
+
+  virtual bool Interrupted() = 0;
+
+  // Interrupt the thread
+  virtual void Interrupt(const IThread* thread) = 0;
+
+  // Waiter link-list support.
+  virtual IThread* GetWaitNext() const = 0;
+
+  virtual void SetWaitNext(IThread* next) = 0;
+
+  virtual Mutex* GetWaitMutex() = 0;
+
+  virtual BaseMutex* GetHeldMutex(LockLevel level) const = 0;
+
+  virtual void SetHeldMutex(LockLevel level, BaseMutex* mutex) = 0;
+
+  // get thread state
+  virtual ThreadState GetState() const = 0;
+
+  virtual void SetState(const ThreadState new_state) = 0;
+
+  virtual Monitor* GetWaitMonitor() = 0;
+
+  virtual void SetWaitMonitor(Monitor* mon) = 0;
+
+  virtual ConditionVariable *GetWaitConditionVariable() = 0;
+
+  virtual void SetInterrupted(bool i) = 0;
+
+  virtual void ThrowInterruptException() = 0;
+
+  virtual void ThrowIllegalMonitorStateException(const char* msg) = 0;
+
+  virtual void ThrowIllegalArgumentException(const char* msg) = 0;
+
+  // get thread tid
+  virtual pid_t GetTid() const = 0;
+
+  virtual uint32_t GetThreadId() const = 0;
+
+  virtual void GetThreadName(std::string& name) const = 0;
+
+  virtual bool IsDaemon() = 0;
+  virtual bool IsSuspend() = 0;
+  virtual void Suspend() = 0;
+
+  // sleep for milliSeconds + nanoSeconds on an optional jLock (can be nullptr)
+  virtual void Sleep(jobject jLock, long long milliSeconds, int nanoSeconds) = 0;
+
+  // some interface of JNIEXT
+  virtual bool IsRuntimeDeleted() = 0;
+  virtual void SetFunctionsToRuntimeShutdownFunctions() = 0;
+
+  // GC roots
+  static void VisitGCRoots(maplert::RefVisitor &f);
+
+  static void VisitWeakGRT(irtVisitFunc& f); // visit the weak-global-reference table
+
+  static void WeakGRTVisitor(maplert::RefVisitor& f); // visit the weak-global-reference table
+
+  static void VisitWeakGRTConcurrent(irtVisitFunc& f); // visit the weak-global-reference table
+
+  // clear a specific reference in weak-global-reference table
+  static void ClearWeakGRTReference(uint32_t index, jobject obj);
+
+  static void VisitGCLocalRefRoots(maplert::RefVisitor &f);
+
+  // fix lockedObjects when Moving GC
+  static void FixLockedObjects(maplert::RefVisitor &f);
+
+  static void VisitGCThreadExceptionRoots(rootObjectFunc& f);
+
+  static void VisitGCGlobalRefRoots(maplert::RefVisitor &f);
+
+  // for signal dump
+  virtual std::vector<ObjectInfo>* GetLockedObjects() = 0;
+
+  virtual void PushLockedMonitor(void* monitorAddr, void* ra, uint32_t type) = 0;
+
+  virtual void UpdateLockMonitorState() = 0;
+
+  virtual void PopLockedMonitor(void) = 0;
+
+  // Native_Thread_currentThread
+  virtual jobject GetRawPeer() const = 0;
+
+  // Native method dynamic linking support.
+  virtual void *FindNativeMethodPtr(JNIEnv* env, uintptr_t** regFuncTabAddr, bool throwable) = 0;
+
+  virtual void *FindNativeMethod(JNIEnv* env, std::string& name, bool throwable) = 0;
+
+  virtual void *GetMonitorAddress(void *obj) = 0;
+
+  virtual void GetCurrentLocation(void *pc, std::string &method, std::string &fileName, int32_t &lineNumber) = 0;
+
+  virtual void SetSuspend(const bool) = 0;
+
+  virtual void TriggerSuspend() = 0;
+
+  virtual void* CheckSuspend() = 0;
+};
+
+// Annotalysis helper for going to a suspended state from runnable.
+class ScopedThreadSuspension {
+ public:
+  __attribute__ ((always_inline))
+  explicit ScopedThreadSuspension(IThread* curThread, ThreadState state);
+
+  __attribute__ ((always_inline))
+  ~ScopedThreadSuspension();
+ private:
+  IThread* const self;
+  const ThreadState suspendedState;
+};
+
+
+}  // namespace maple
+
+#endif  // MAPLE_RUNTIME_THREAD_API_H_
diff --git a/src/mrt/libmrtbase/include/thread_helper.h b/src/mrt/libmrtbase/include/thread_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd121f45ac725d4f1bc2864a80322eb248fb34e5
--- /dev/null
+++ b/src/mrt/libmrtbase/include/thread_helper.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __MAPLE_THREAD_HELPER_H
+#define __MAPLE_THREAD_HELPER_H
+
+#include <cstdint>
+#include <map>
+#include <functional>
+#include "base/mutex.h"
+#include "thread_api.h"
+#include "gc_callback.h"
+
+namespace maple {
+
+class ThreadHelper {
+ public:
+  static const uint32_t kInvalidThreadId = 0;
+  static bool is_started_;
+
+  // Hold ThreadList::list_
+  static std::map<uint32_t, IThread*> threadMap;
+
+  static IThread *FindThreadByThreadId(uint32_t threadId);
+
+  static bool SuspendHandler() {
+    IThread *iSelf = IThread::Current();
+    // native thread only, avoid SIGSEGV Nesting
+    if (UNLIKELY(iSelf == nullptr)) {
+      return false;
+    }
+
+    if (LIKELY(iSelf->CheckSuspend() != nullptr)) {
+      return false;
+    }
+
+    iSelf->SetSuspend(true);
+    return true;
+  }
+};
+
+extern std::function<void(maplert::RefVisitor&)> visitGCRootsFunc;
+extern std::function<void(irtVisitFunc&)> VisitWeakGRTFunc;
+extern std::function<void(maplert::RefVisitor&)> visitWeakGRTFunc;
+extern std::function<void(irtVisitFunc&)> VisitWeakGRTConcurrentFunc;
+extern std::function<void(uint32_t, jobject)> ClearWeakGRTReferenceFunc;
+extern std::function<void(maplert::RefVisitor&)> FixLockedObjectsFunc;
+
+extern std::function<void(maplert::RefVisitor&)> visitGCLocalRefRootsFunc;
+extern std::function<void(maplert::RefVisitor&)> visitGCGlobalRefRootsFunc;
+extern std::function<void(rootObjectFunc&)> VisitGCThreadExceptionRootsFunc;
+
+// this provides a unified way to pre-initialize classes for each module (dex/so)
+typedef void *PreinitModuleClassesCallback(void*);
+extern std::function<void(PreinitModuleClassesCallback)> PreinitModuleClassesFunc;
+}  // namespace maple
+#endif  // __MAPLE_THREAD_HELPER_H
diff --git a/src/mrt/libmrtbase/include/thread_offsets.h b/src/mrt/libmrtbase/include/thread_offsets.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1f1ba69ec651c2a43cef532149c038781bab766
--- /dev/null
+++ b/src/mrt/libmrtbase/include/thread_offsets.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_RUNTIME_THREAD_OFFSETS_H_
+#define MAPLE_RUNTIME_THREAD_OFFSETS_H_
+
+#if defined(__aarch64__)
+constexpr size_t kThreadIdOffset = 8; // 8 bytes
+#elif defined(__arm__)
+constexpr size_t kThreadIdOffset = 4; // 4 bytes
+#endif
+
+// obj+ofst = lock_word address;
+#ifdef USE_32BIT_REF
+constexpr size_t kLockWordOffset = 4;  // 4 bytes
+#else
+constexpr size_t kLockWordOffset = 8;  // 8 bytes
+#endif
+
+#endif  // MAPLE_RUNTIME_THREAD_OFFSETS_H_
diff --git a/src/mrt/libmrtbase/include/threadstate.h b/src/mrt/libmrtbase/include/threadstate.h
new file mode 100644
index 0000000000000000000000000000000000000000..774153d731ba54dad00a04710d61a9f478f7180f
--- /dev/null
+++ b/src/mrt/libmrtbase/include/threadstate.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_RUNTIME_THREAD_STATE_H
+#define MAPLE_RUNTIME_THREAD_STATE_H
+
+enum ThreadState {
+  //                               Thread.State   JDWP state
+  kStarting,                    // NEW            TS_WAIT      native thread started, not yet ready to run managed code
+  kRunnable,                    // RUNNABLE       TS_RUNNING   runnable
+  kBlocked,                     // BLOCKED        TS_MONITOR   blocked on a monitor
+  kWaiting,                     // WAITING        TS_WAIT      in Object.wait()
+  kTimedWaiting,                // TIMED_WAITING  TS_WAIT      in Object.wait() with a timeout
+  kTerminated,                  // TERMINATED     TS_ZOMBIE    Thread.run has returned, but Thread* still around
+};
+
+#endif // MAPLE_RUNTIME_THREAD_STATE_H
diff --git a/src/mrt/libmrtbase/include/tls_store.h b/src/mrt/libmrtbase/include/tls_store.h
new file mode 100644
index 0000000000000000000000000000000000000000..91aebdb4405ca0052a90ce5668af97a14fbf629f
--- /dev/null
+++ b/src/mrt/libmrtbase/include/tls_store.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef MAPLE_TLS_STORE_H
+#define MAPLE_TLS_STORE_H
+
+#ifdef __ANDROID_USE_TLS__
+#include <bionic_tls.h>
+#else
+#include <cstdint>
+#endif
+
+namespace maple {
+
+namespace tls {
+
+// Modify this enum is highly risky since codetricks/arch/arm64/duplicateFunc.s
+// contains some hard-coded assembly with offsets derived from this enum.
+// Most of these assembly code looks like:
+//        mrs     x20, TPIDR_EL0
+//        ldr     x8, [x20, #40]
+// We can extend the enum but should never change or delete current entries.
+// If we have to modify this data structure, we can only insert new value between
+// SLOT_SIGNAL_HANDLER and TLS_PTR_TABLE_SIZE.
+enum ThreadTlsSlot {
+  kSlotMutator = 0,
+  kSlotException = 1,
+  kSlotAllocMutator = 2,
+  kSlotThrowException = 3,
+  kSlotLastJavaFrame = 4, // deprecated and moved to mutator
+  kSlotSignalHandler = 5,
+  kSlotJniEnv = 6,
+  kSlotThreadSelf = 7,
+  kSlotExceptionAddress = 8,
+  kSlotAnnotationMap = 9,
+  kSlotZterpLifoAlloc = 10, // used by the stackless interpreter
+  kSlotJniMonitorList = 11,
+  kSlotIsGcThread = 12,
+  kSlotYieldPointPc = 13, // Saved yieldpoint PC for current thread.
+  kSlotInterpCache = 14,
+  kSlotMFileCache = 15,
+  kSlotTableSize,
+};
+
+void* CreateTLS();
+void DestoryTLS();
+
+#ifdef __ANDROID_USE_TLS__
+#else
+extern thread_local uintptr_t tlsItems[kSlotTableSize];
+#endif
+
+static inline void StoreTLS(const void* ptr, ThreadTlsSlot slot) {
+#ifdef __ANDROID_USE_TLS__
+  (reinterpret_cast<uintptr_t*>(__get_tls()[TLS_SLOT_ART_THREAD_SELF]))[slot] = reinterpret_cast<uintptr_t>(ptr);
+#else
+  tlsItems[slot] = (uintptr_t)ptr;
+#endif
+}
+
+static inline bool HasTLS() {
+#ifdef __ANDROID_USE_TLS__
+  return __get_tls()[TLS_SLOT_ART_THREAD_SELF] != nullptr;
+#else
+  return true;
+#endif
+}
+
+static inline void* GetTLS(tls::ThreadTlsSlot slot) {
+#ifdef __ANDROID_USE_TLS__
+  if (HasTLS() == false) {
+    return nullptr;
+  } else {
+    return reinterpret_cast<void*>((reinterpret_cast<uintptr_t*>(__get_tls()[TLS_SLOT_ART_THREAD_SELF]))[slot]);
+  }
+#else
+  return reinterpret_cast<void*>(tlsItems[slot]);
+#endif
+}
+
+} // tls
+} // namespace maple
+
+#endif // MAPLE_TLS_STORE_H
diff --git a/src/mrt/libmrtbase/include/utils/name_utils.h b/src/mrt/libmrtbase/include/utils/name_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..e86d5d1fc8d7cf1b4729be00badbc82377269179
--- /dev/null
+++ b/src/mrt/libmrtbase/include/utils/name_utils.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * c++ utils library is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_NAME_UTILS_H
+#define MAPLE_RUNTIME_NAME_UTILS_H
+
+#include <string>
+
+namespace nameutils {
+
+// the object type like "Ljava/lang/Class;" to "java.lang.Class"
+std::string SlashNameToDot(const std::string &slashName);
+
+// "java.lang.Class" to "Ljava/lang/Class"
+std::string DotNameToSlash(const std::string &dotName);
+
+} // namespace nameutils
+#endif // MAPLE_RUNTIME_NAME_UTILS_H~
diff --git a/src/mrt/libmrtbase/include/utils/string_utils.h b/src/mrt/libmrtbase/include/utils/string_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0f9bdc72c74a5273c1efc015f338c96fbf63544
--- /dev/null
+++ b/src/mrt/libmrtbase/include/utils/string_utils.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * c++ utils library is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_STRING_UTILS_H
+#define MAPLE_RUNTIME_STRING_UTILS_H
+
+#include <string>
+#include <vector>
+
+namespace stringutils {
+
+// Split a string into string tokens according to the separator, such as blank space
+std::vector<std::string> Split(const std::string &source, char separator = ' ');
+
+// Join a string vector to a single string with separator
+std::string Join(const std::vector<std::string>&, char separator);
+
+// Format c-style args according to the format string, and return the result as a string.
+std::string Format(const char *format, ...);
+
+// Append a format string into target string.
+void AppendFormat(std::string &target, const char *format, ...);
+
+void AppendFormatV(std::string &target, const char *format, va_list args);
+
+// Check if a string prefix is a specified string
+bool WithPrefix(const std::string &source, const std::string &prefix);
+
+// Check if a string suffix is a specified string
+bool WithSuffix(const std::string &source, const std::string &suffix);
+
+// Trim a leading white space in a specified string
+void TrimLeadingWhiteSpace(std::string &source, const std::string &whiteSpaces = "\t\n\r ");
+
+// Trim a tail white space in a specified string
+void TrimTailingWhiteSpace(std::string &source, const std::string &whiteSpaces = "\t\n\r ");
+
+} // namespace stringutils
+#endif // MAPLE_RUNTIME_STRING_UTILS_H
diff --git a/src/mrt/libmrtbase/include/utils/time_utils.h b/src/mrt/libmrtbase/include/utils/time_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..42c8cdbbb7b447e97da85cbd9da5be224e3e46a2
--- /dev/null
+++ b/src/mrt/libmrtbase/include/utils/time_utils.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * c++ utils library is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_TIME_UTILS_H
+#define MAPLE_RUNTIME_TIME_UTILS_H
+
+#include <string>
+#include <cinttypes>
+
+namespace timeutils {
+
+// returns the monotonic time since epoch starting point in milliseconds
+uint64_t MilliSeconds();
+
+// returns the monotonic time since epoch starting point in nanoseconds
+uint64_t NanoSeconds();
+
+// returns the monotonic time since epoch starting point in microseconds
+uint64_t MicroSeconds() noexcept;
+
+// returns the thread-specific cpu clock time in nanoseconds or -1 if the clock is not exist
+uint64_t ThreadCpuTimeNs();
+
+// returns the process cpu clock time in nanoseconds or -1 if the clock is not exist
+uint64_t ProcessCpuTimeNs();
+
+// sleep for the given count of nanoseconds
+void SleepForNano(uint64_t ns);
+
+// Sleep forever
+void SleepForever();
+
+// returns the current date in ios yyymmddhhmmss format
+std::string GetDigitDate();
+
+// returns the current date in ios yyyy-mm-dd hh:mm::ss format
+std::string GetIsoDate();
+
+void ConstructTimeSpec(int clock, int64_t millSeconds, int32_t nanoSeconds, timespec &ts, bool absolute);
+
+// if time is at future, now remain time is update to 'updateTime'
+// if time has past, it will return false;
+bool UpdateRemainTimeToNow(int clock, const timespec &time, timespec &updateTime);
+
+} // namespace timeutils
+#endif // MAPLE_TIME_UTILS_H
diff --git a/src/mrt/maplert/BUILD.gn b/src/mrt/maplert/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..f74186cc948c753ef08a000975fef67cbcc8c16f
--- /dev/null
+++ b/src/mrt/maplert/BUILD.gn
@@ -0,0 +1,103 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+sources_common = [
+  "src/mrt_array.cpp",
+  "src/mrt_class_init.cpp",
+  "src/mrt_object.cpp",
+  "src/mrt_reflection_class.cpp",
+  "src/mrt_reflection_method.cpp",
+  "src/mrt_reflection_field.cpp",
+  "src/mrt_reflection_constructor.cpp",
+  "src/modifier.cpp",
+  "src/mrt_reflection_proxy.cpp",
+  "src/mrt_reflection_executable.cpp",
+  "src/mrt_annotation.cpp",
+  "src/mrt_annotation_parser.cpp",
+  "src/mrt_string.cpp",
+  "src/mrt_util.cpp",
+  "src/mrt_preload_class.cpp",
+  "src/mrt_linker.cpp",
+  "src/mrt_classloader.cpp",
+  "src/mrt_reflection_reference.cpp",
+  "src/literalstrname.cpp",
+  "src/java2c_rule.cpp",
+  "src/mrt_poisonstack.cpp",
+  "src/mrt_methodhandle.cpp",
+  "src/mrt_methodhandle_mpl.cpp",
+  "src/mrt_handlecommon.cpp",
+  "src/mrt_handleutil.cpp",
+  "src/mrt_profile.cpp",
+  "src/mrt_well_known.cpp",
+  "src/mrt_primitive_util.cpp",
+  "src/itab_util.cpp",
+  "src/mobject.cpp",
+  "src/marray.cpp",
+  "src/mstring.cpp",
+  "src/mclass.cpp",
+  "src/mmethod.cpp",
+  "src/mfield.cpp",
+  "src/fieldmeta.cpp",
+  "src/methodmeta.cpp",
+  "src/deferredaccess.cpp",
+]
+
+include_common = [
+  "${MAPLE_MRT_ROOT}/maplert/include",
+  "${AOSP_ROOT}/libnativehelper/include_jni",
+  "${THIRD_PARTY_ROOT}/bounds_checking_function/include/",
+  "${MAPLE_MRT_ROOT}/compiler-rt/include",
+  "${MAPLE_MRT_ROOT}/compiler-rt/public-headers",
+  "${MAPLE_MRT_ROOT}/maplert/public-headers",
+  "${MAPLE_MRT_ROOT}/libmrtbase/include",
+  "${MAPLE_MRT_ROOT}/libmrtbase/include/linux",
+  "${MAPLE_MRT_ROOT}/interpreter/zterp",
+  "${MAPLE_MRT_ROOT}/dexinterface",
+  "${MAPLE_MRT_ROOT}/verifier/include",
+  "${MAPLE_MRT_ROOT}",
+]
+
+cflags = []
+cflags_cc = []
+
+cflags += [
+  "-DPLATFORM_SDK_VERSION=27",
+  "-DJNIDEBUG=0",
+  "-DTRACE_LEVEL=3",
+]
+
+cflags_cc += [
+  "-fvisibility=hidden",
+  "-std=c++14",
+  "-nostdlibinc",
+  "-march=armv8-a",
+]
+
+configs = [ "${MAPLE_MRT_ROOT}:mrt_cxx_flags" ]
+
+static_library("libmaplert") {
+  sources = sources_common
+  include_dirs = include_common
+}
+
+copy("maplert_module_init_cpp") {
+  sources = [ "src/mrt_module_init.c__" ]
+  outputs = [ "${root_out_dir}/mrt_module_init.cpp" ]
+}
+
+static_library("libmrt_module_init") {
+  sources = get_target_outputs(":maplert_module_init_cpp")
+  include_dirs = include_common
+  deps = [ ":maplert_module_init_cpp" ]
+}
diff --git a/src/mrt/maplert/include/argvalue.h b/src/mrt/maplert/include/argvalue.h
new file mode 100644
index 0000000000000000000000000000000000000000..2473ff5e464344526de69557f8f14fb63586ee49
--- /dev/null
+++ b/src/mrt/maplert/include/argvalue.h
@@ -0,0 +1,519 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_ARGVALUE_H_
+#define MRT_MAPLERT_INCLUDE_ARGVALUE_H_
+
+#include "panic.h"
+
+namespace maplert {
+namespace calljavastubconst{
+enum ArgsType {
+  kVaArg,
+  kJvalue,
+  kJArray,
+  kNone // no parameter
+};
+
+#if defined(__aarch64__)
+static constexpr uint32_t kAArch64XregSize = 8;
+static constexpr uint32_t kAArch64DregSize = 8;
+static constexpr uint32_t kAArch64XregAndDregSize = kAArch64XregSize + kAArch64DregSize;
+static constexpr uint32_t kRegArgsSize = kAArch64XregAndDregSize;
+#elif defined(__arm__)
+static constexpr uint32_t kArmRregSize = 4;
+#if defined(__ARM_PCS_VFP)
+static constexpr uint32_t kArmDregSize = 8;
+#else
+static constexpr uint32_t kArmDregSize = 0;
+#endif
+static constexpr uint32_t kRegArgsSize = kArmRregSize + kArmDregSize;
+#else
+#error "Unimplemented Architecture"
+#endif
+} // namespace calljavastubconst
+
+class BaseArgValue {
+ public:
+  explicit BaseArgValue(const uintptr_t methodArgs)
+      : methodArgs(methodArgs), values(regArgValues), valuesSize(calljavastubconst::kRegArgsSize),
+        gregIdx(0), fregIdx(0), stackIdx(0) {
+    for (uint32_t i = 0; i < calljavastubconst::kRegArgsSize; i++) {
+      regArgValues[i].j = 0L; // clean up regArgValues
+    }
+  }
+
+  virtual ~BaseArgValue() {
+    if (values != regArgValues) {
+      delete []values;
+    }
+  }
+
+  virtual void AddReference(MObject *ref) = 0;
+  virtual void AddInt32(int32_t value) = 0;
+  virtual void AddInt64(int64_t value) = 0;
+  virtual void AddFloat(float value) = 0;
+  virtual void AddDouble(double value) = 0;
+  virtual uint32_t GetFRegSize() const = 0;
+  virtual uint32_t GetStackSize() const = 0;
+  virtual MObject *GetReceiver() const = 0;
+
+  jvalue *GetData() {
+    return &values[0];
+  }
+
+  uintptr_t GetMethodArgs() const {
+    return methodArgs;
+  }
+
+  uint32_t GetGIdx() const noexcept {
+    return gregIdx;
+  }
+
+ protected:
+  void Resize(uint32_t newSize) {
+    if (newSize < valuesSize) {
+      return;
+    }
+
+    jvalue *oldValues = values;
+    uint32_t oldValuesSize = valuesSize;
+    valuesSize = newSize + kIncSize;
+    values = new jvalue[valuesSize];
+    std::copy(oldValues, oldValues + oldValuesSize, values);
+    if (oldValues != regArgValues) {
+      delete []oldValues; // free dynamic array.
+    }
+  }
+
+  constexpr static uint32_t kIncSize = 8;
+  const uintptr_t methodArgs;
+  jvalue regArgValues[calljavastubconst::kRegArgsSize];
+  jvalue *values;
+  uint32_t valuesSize;
+  uint32_t gregIdx;
+  uint32_t fregIdx;
+  uint32_t stackIdx;
+};
+
+class ArgValueInterp : public BaseArgValue {
+ public:
+  explicit ArgValueInterp(const uintptr_t methodArgs) : BaseArgValue(methodArgs) {}
+  virtual ~ArgValueInterp() = default;
+
+  virtual void AddReference(MObject *ref) override {
+    AddInt64(reinterpret_cast<int64_t>(ref));
+  }
+
+  virtual void AddInt32(int32_t value) override {
+    AddInt64(value);
+  }
+
+  virtual void AddInt64(int64_t value) override {
+    Resize(gregIdx + 1);
+    values[gregIdx++].j = value;
+  }
+
+  virtual void AddFloat(float value) override {
+    Resize(gregIdx + 1);
+    values[gregIdx++].f = value;
+  }
+
+  virtual void AddDouble(double value) override {
+    Resize(gregIdx + 1);
+    values[gregIdx++].d = value;
+  }
+
+  virtual uint32_t GetFRegSize() const override {
+    LOG(FATAL) << "ArgValueInterp.GetFREgSize: Should not reach here!" << maple::endl;
+    return 0;
+  }
+
+  virtual uint32_t GetStackSize() const override {
+    LOG(FATAL) << "ArgValueInterp.GetStackSize: Should not reach here!" << maple::endl;
+    return 0;
+  }
+
+  virtual MObject *GetReceiver() const override {
+    return reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(values[0].l));
+  }
+};
+
+#if defined(__aarch64__)
+class ArgValue : public BaseArgValue {
+ public:
+  explicit ArgValue(const uintptr_t methodArgs) : BaseArgValue(methodArgs) {
+    fregIdx = calljavastubconst::kAArch64XregSize;
+    stackIdx = calljavastubconst::kAArch64XregAndDregSize;
+  }
+  virtual ~ArgValue() = default;
+
+  virtual void AddReference(MObject *ref) override {
+    AddInt64(reinterpret_cast<int64_t>(ref));
+  }
+
+  virtual void AddInt32(int32_t value) override {
+    AddInt64(value);
+  }
+
+  virtual void AddInt64(int64_t value) override {
+    if (gregIdx < calljavastubconst::kAArch64XregSize) {
+      Resize(gregIdx + 1);
+      values[gregIdx++].j = value;
+    } else {
+      Resize(stackIdx + 1);
+      values[stackIdx++].j = value;
+    }
+  }
+
+  virtual void AddFloat(float value) override {
+    double arg = 0;
+    *reinterpret_cast<float*>(&arg) = value;
+    AddDouble(arg);
+  }
+
+  virtual void AddDouble(double value) override {
+    if (fregIdx < calljavastubconst::kAArch64XregAndDregSize) {
+      Resize(fregIdx + 1);
+      values[fregIdx++].d = value;
+    } else {
+      Resize(stackIdx + 1);
+      values[stackIdx++].d = value;
+    }
+  }
+
+  virtual uint32_t GetFRegSize() const override {
+    return fregIdx - calljavastubconst::kAArch64XregSize;
+  }
+
+  virtual uint32_t GetStackSize() const override {
+    return static_cast<uint32_t>((stackIdx - calljavastubconst::kAArch64XregAndDregSize) * sizeof(jvalue));
+  }
+
+  virtual MObject *GetReceiver() const override {
+    return reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(values[0].l));
+  }
+
+  // used in annotation, confirmed size and not stored in stack
+  inline MObject *GetReferenceFromGidx(uint32_t idx) const noexcept {
+    return reinterpret_cast<MObject*>(values[idx].l);
+  }
+};
+
+
+// we restructure parameter in stub, copy caller's caller parameter to caller stack
+class DecodeStackArgs {
+ public:
+  explicit DecodeStackArgs(intptr_t *stack) : stackMemery(stack), values(kIncSize), gregIdx(0), valueIdx(0) {
+    fregIdx = calljavastubconst::kAArch64XregSize;
+    stackIdx = calljavastubconst::kAArch64XregAndDregSize;
+  }
+  ~DecodeStackArgs() {
+    stackMemery = nullptr;
+  }
+
+  void DecodeReference() {
+    DecodeInt64();
+  }
+
+  void DecodeInt32() {
+    Resize(valueIdx);
+    if (gregIdx < calljavastubconst::kAArch64XregSize) {
+      values[valueIdx].i = static_cast<int32_t>(stackMemery[gregIdx]);
+      gregIdx++;
+    } else {
+      values[valueIdx].i = static_cast<int32_t>(stackMemery[stackIdx]);
+      stackIdx++;
+    }
+    valueIdx++;
+  }
+
+  void DecodeInt64() {
+    Resize(valueIdx);
+    if (gregIdx < calljavastubconst::kAArch64XregSize) {
+      values[valueIdx].j = stackMemery[gregIdx];
+      gregIdx++;
+    } else {
+      values[valueIdx].j = stackMemery[stackIdx];
+      stackIdx++;
+    }
+    valueIdx++;
+  }
+
+  void DecodeFloat() {
+    DecodeDouble();
+  }
+
+  void DecodeDouble() {
+    Resize(valueIdx);
+    if (fregIdx < calljavastubconst::kAArch64XregAndDregSize) {
+      values[valueIdx].d = *(reinterpret_cast<double*>(&stackMemery[fregIdx]));
+      fregIdx++;
+    } else {
+      values[valueIdx].d = *(reinterpret_cast<double*>(&stackMemery[stackIdx]));
+      stackIdx++;
+    }
+    valueIdx++;
+  }
+
+  jvalue *GetData() {
+    return &values[0];
+  }
+
+ protected:
+  void Resize(uint32_t newSize) {
+    if (newSize < values.size()) {
+      return;
+    }
+    values.resize(newSize + kIncSize);
+  }
+
+  constexpr static uint32_t kIncSize = 8;
+  intptr_t *stackMemery;
+  std::vector<jvalue> values;
+  uint32_t gregIdx;
+  uint32_t fregIdx;
+  uint32_t stackIdx;
+  uint32_t valueIdx;
+};
+#elif defined(__arm__)
+class ArgValue : public BaseArgValue {
+ public:
+  explicit ArgValue(const uintptr_t methodArgs) : BaseArgValue(methodArgs) {
+    fregIdx = calljavastubconst::kArmRregSize;
+    stackIdx = calljavastubconst::kArmRregSize + calljavastubconst::kArmDregSize * kWideSize;
+  }
+  virtual ~ArgValue() = default;
+
+  virtual void AddReference(MObject *ref) override {
+    AddInt32(static_cast<int32_t>(reinterpret_cast<int64_t>(ref)));
+  }
+
+  // used in annotation, confirmed size and not stored in stack
+  inline MObject *GetReferenceFromGidx(uint32_t idx) noexcept {
+    return reinterpret_cast<MObject*>(values[idx >> 1].i);
+  }
+
+  void AddInt32(int32_t *value) {
+    uint32_t &valueIdx = (gregIdx >= kMaxGregSize) ? stackIdx : gregIdx;
+    Resize(valueIdx >> 1);
+    if ((valueIdx & 0x1) == 0) {
+      values[valueIdx >> 1].i = *value;
+    } else {
+      *(reinterpret_cast<uint32_t*>(&values[valueIdx >> 1]) + 1) = *value;
+    }
+    valueIdx++;
+  }
+
+  virtual void AddInt32(int32_t value) override {
+    AddInt32(&value);
+  }
+
+  void AddInt64(int64_t *value) {
+    uint32_t &tempIdx = (gregIdx >= kMaxGregSize) ? stackIdx : gregIdx;
+    if ((tempIdx & 0x1) == 1) {
+      tempIdx++;
+    }
+
+    uint32_t &valueIdx = (gregIdx >= kMaxGregSize) ? stackIdx : gregIdx;
+    Resize(valueIdx >> 1);
+    values[valueIdx >> 1].j = *value;
+    valueIdx += kWideSize;
+  }
+
+  virtual void AddInt64(int64_t value) override {
+    AddInt64(&value);
+  }
+
+  virtual void AddFloat(float value) override {
+#if defined(__ARM_PCS_VFP)
+    if (fregOddSpace != 0) {
+      __MRT_ASSERT((fregOddSpace & 1) == 1, "Invalid fregOddSpace");
+      *(reinterpret_cast<float*>(&values[fregOddSpace >> 1]) + 1) = value;
+      fregOddSpace = 0;
+      return;
+    }
+    uint32_t &valueIdx = (fregIdx >= kMaxFregSize) ? stackIdx : fregIdx;
+    Resize(valueIdx >> 1);
+    if ((valueIdx & 0x1) == 0) {
+      values[valueIdx >> 1].f = value;
+    } else {
+      *(reinterpret_cast<float*>(&values[valueIdx >> 1]) + 1) = value;
+    }
+    valueIdx++;
+#else
+    AddInt32(reinterpret_cast<int32_t*>(&value));
+#endif
+  }
+
+  virtual void AddDouble(double value) override {
+#if defined(__ARM_PCS_VFP)
+    uint32_t &tempIdx = (fregIdx >= kMaxFregSize) ? stackIdx : fregIdx;
+    if ((tempIdx & 0x1) == 1) {
+      __MRT_ASSERT(fregOddSpace == 0, "Invalid float odd space!");
+      if (fregIdx < kMaxFregSize) {
+        fregOddSpace = fregIdx;
+      }
+      tempIdx++;
+    }
+    uint32_t &valueIdx = (fregIdx >= kMaxFregSize) ? stackIdx : fregIdx;
+    Resize(valueIdx >> 1);
+    values[valueIdx >> 1].d = value;
+    valueIdx += kWideSize;
+#else
+    AddInt64(reinterpret_cast<int64_t*>(&value));
+#endif
+  }
+
+  virtual uint32_t GetFRegSize() const override {
+    return ((fregIdx + 1) - kMaxGregSize) >> 1;
+  }
+
+  virtual uint32_t GetStackSize() const override {
+    return (((stackIdx + 1) - kMaxFregSize) >> 1) * sizeof(jvalue);
+  }
+
+  virtual MObject *GetReceiver() const override {
+    return reinterpret_cast<MObject*>(values[0].i);
+  }
+
+ private:
+#if defined(__ARM_PCS_VFP)
+  uint32_t fregOddSpace = 0;
+#endif
+  constexpr static uint32_t kWideSize = 2;
+  constexpr static uint32_t kMaxGregSize = calljavastubconst::kArmRregSize;
+  constexpr static uint32_t kMaxFregSize = calljavastubconst::kArmRregSize +
+                                           calljavastubconst::kArmDregSize * kWideSize;
+};
+
+// we restructure parameter in stub, copy caller's caller parameter to caller stack
+class DecodeStackArgs {
+ public:
+  explicit DecodeStackArgs(intptr_t *stack)
+      : stackMemery(stack), values(kIncSize), gregIdx(0), oddFregIdx(0), valueIdx(0) {
+    fregIdx = calljavastubconst::kArmRregSize;
+    stackIdx = calljavastubconst::kArmRregSize + calljavastubconst::kArmDregSize * kWideSize;
+  }
+  ~DecodeStackArgs() {
+    stackMemery = nullptr;
+  }
+
+  void DecodeReference() {
+    DecodeInt32();
+  }
+
+  void DecodeInt32() {
+    Resize(valueIdx);
+    if (gregIdx < kMaxGregSize) {
+      values[valueIdx].i = stackMemery[gregIdx];
+      gregIdx++;
+    } else {
+      values[valueIdx].i = stackMemery[stackIdx];
+      stackIdx++;
+    }
+    valueIdx++;
+  }
+
+  void DecodeInt64() {
+    Resize(valueIdx);
+    if ((gregIdx & 0x1) == 0x1) {
+      gregIdx++;
+    }
+    if (gregIdx < kMaxGregSize) {
+      values[valueIdx].j = *(reinterpret_cast<int64_t*>(&stackMemery[gregIdx]));
+      gregIdx += kWideSize;
+    } else {
+      if ((stackIdx & 0x1) == 0x1) {
+        stackIdx++;
+      }
+      values[valueIdx].j = *(reinterpret_cast<int64_t*>(&stackMemery[stackIdx]));
+      stackIdx += kWideSize;
+    }
+    valueIdx++;
+  }
+
+  void DecodeFloat() {
+#if defined(__ARM_PCS_VFP)
+    Resize(valueIdx);
+    if ((oddFregIdx & 0x1) == 0x01) {
+      values[valueIdx].f = *(reinterpret_cast<float*>(&stackMemery[oddFregIdx]));
+      oddFregIdx = 0;
+      valueIdx++;
+      return;
+    }
+    if (fregIdx < kMaxFregSize) {
+      values[valueIdx].f = *(reinterpret_cast<float*>(&stackMemery[fregIdx]));
+      fregIdx++;
+    } else {
+      values[valueIdx].f = *(reinterpret_cast<float*>(&stackMemery[stackIdx]));
+      stackIdx++;
+    }
+    valueIdx++;
+#else
+    DecodeInt32();
+#endif
+  }
+
+  void DecodeDouble() {
+#if defined(__ARM_PCS_VFP)
+    Resize(valueIdx);
+    if ((fregIdx & 0x1) == 0x1) {
+      oddFregIdx = fregIdx;
+      fregIdx++;
+    }
+    if (fregIdx < kMaxFregSize) {
+      values[valueIdx].d = *(reinterpret_cast<double*>(&stackMemery[fregIdx]));
+      fregIdx += kWideSize;
+    } else {
+      if ((stackIdx & 0x1) == 0x1) {
+        stackIdx++;
+      }
+      values[valueIdx].d = *(reinterpret_cast<double*>(&stackMemery[stackIdx]));
+      stackIdx += kWideSize;
+    }
+    valueIdx++;
+#else
+    DecodeInt64();
+#endif
+  }
+
+  jvalue *GetData() {
+    return &values[0];
+  }
+
+ protected:
+  void Resize(uint32_t newSize) {
+    if (newSize < values.size()) {
+      return;
+    }
+    values.resize(newSize + kIncSize);
+  }
+
+  constexpr static uint32_t kIncSize = 8;
+  intptr_t *stackMemery;
+  std::vector<jvalue> values;
+  uint32_t gregIdx;
+  uint32_t fregIdx;
+  uint32_t stackIdx;
+  uint32_t oddFregIdx;
+  uint32_t valueIdx;
+  constexpr static uint32_t kWideSize = 2;
+  constexpr static uint32_t kMaxGregSize = calljavastubconst::kArmRregSize;
+  constexpr static uint32_t kMaxFregSize = calljavastubconst::kArmRregSize +
+                                           calljavastubconst::kArmDregSize * kWideSize;
+};
+#endif
+}
+#endif
diff --git a/src/mrt/maplert/include/deferredaccess.h b/src/mrt/maplert/include/deferredaccess.h
new file mode 100644
index 0000000000000000000000000000000000000000..f43fcbe04efb3fdb965b16cddfff1b84c3fb56a3
--- /dev/null
+++ b/src/mrt/maplert/include/deferredaccess.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_DEFERREDACCESS_H_
+#define MRT_MAPLERT_INCLUDE_DEFERREDACCESS_H_
+#include "marray.h"
+#include "fieldmeta.h"
+#include "methodmeta.h"
+
+namespace maplert {
+namespace deferredaccess {
+enum DeferredInvokeType {
+  kStaticCall,                 // invoke-static
+  kVirtualCall,                // invoke-virtual
+  kSuperCall,                  // invoke-super
+  kDirectCall,                 // invoke-direct
+  kInterfaceCall               // invoke-interface
+}; // enum DeferredInvokeType
+
+// this offset keep order with MCC_DeferredInvoke stack frame
+enum DeferredInvokeParameterOffset {
+  kDaiMethod = 0,                   // cache dai Method
+  kInvokeType = 1,                  // invoke type
+  kClassName = 2,                   // class name
+  kMethodName = 3,                  // method name
+#if defined(__aarch64__)
+  kSignature = 4,                   // signature
+  kThisObj = 5,                     // this obj
+#elif defined(__arm__)
+  kStackOffset = 20,                // StackOffset see argvalue.h, DecodeStackArgs
+  kSignature = kStackOffset,        // signature
+  kThisObj = kStackOffset + 1,      // this obj
+#endif
+}; // enum DeferredInvokeParameterOrder
+
+// DAI struct
+using DaiClass = struct DAIClass {
+  MClass *daiClass;
+};
+using DaiField = struct DAIField {
+  FieldMeta *fieldMeta;
+};
+using DaiMethod = struct DAIMethod {
+  MethodMeta *methodMeta;
+};
+
+MClass *GetConstClass(const MObject &caller, const char *descriptor);
+void ClinitCheck(const MClass &classObject);
+bool IsInstanceOf(const MClass &classObject, const MObject &obj);
+MObject *NewInstance(const MClass &classObject);
+MArray *NewArray(const MClass &classObject, uint32_t length);
+MArray *NewArray(const MClass &classObject, uint32_t length, va_list initialElement);
+jvalue LoadField(const FieldMeta &fieldMeta, const MObject *obj);
+void StoreField(const FieldMeta &fieldMeta, MObject *obj, jvalue value);
+FieldMeta *InitDaiField(DaiField *daiField, const MClass &classObject,
+                        const MString &fieldName, const MString &fieldTypeName);
+jvalue Invoke(DeferredInvokeType invokeType, const MethodMeta *methodMeta, MObject *obj, jvalue args[]);
+MethodMeta *InitDaiMethod(DeferredInvokeType invokeType, DaiMethod *daiMethod, const MClass &classObject,
+                          const char *methodName, const char *signatureName);
+bool CheckFieldAccess(MObject &caller, const FieldMeta &fieldMeta, const MObject *obj);
+}; // namespace deferredaccess
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_DEFERREDACCESS_H_
diff --git a/src/mrt/maplert/include/fieldmeta.h b/src/mrt/maplert/include/fieldmeta.h
new file mode 100644
index 0000000000000000000000000000000000000000..1496da6fdb6b8dc3c2ad4958514d86980274a8ae
--- /dev/null
+++ b/src/mrt/maplert/include/fieldmeta.h
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_FIELDMETA_H_
+#define MRT_MAPLERT_INCLUDE_FIELDMETA_H_
+#include "primitive.h"
+#include "mobject.h"
+#include "mstring.h"
+
+namespace maplert {
+static constexpr uint32_t kFieldHashMask = 0x3FF;
+static constexpr uint32_t kFieldFlagBits = 6;
+static constexpr uint32_t kFieldOffsetShift = 3;
+class FieldOffset {
+ public:
+  void SetBitOffset(uint32_t bitOffset);
+  uint32_t GetBitOffset() const;
+  void SetAddress(uintptr_t addr);
+  uintptr_t GetAddress() const;
+  int32_t GetDefTabIndex() const;
+
+ private:
+  union {
+    DataRefOffset offset;       // offset for instance field in bits
+    DataRefOffset relOffset;    // address offset for static field
+    DataRefOffset defTabIndex;  // def tab index, before lazy binding resolve for static field.
+  };
+};
+
+class FieldMeta {
+ public:
+  char *GetName() const;
+  uint16_t GetHashCode() const;
+  uint32_t GetMod() const;
+  char *GetTypeName() const;
+  MClass *GetType() const;
+  uint16_t GetFlag() const;
+  uint16_t GetIndex() const;
+  uint32_t GetOffset() const;
+  int32_t GetDefTabIndex() const;
+  // instance field
+  void SetBitOffset(uint32_t setOffset);
+  // instance field or static field
+  void SetOffsetOrAddress(size_t setOffset);
+  uint32_t GetBitOffset() const;
+  MObject *GetRealMObject(const MObject *o, bool clinitCheck = true) const;
+  MClass *GetDeclaringclass() const;
+  uintptr_t GetStaticAddr() const;
+  bool IsPublic() const;
+  bool IsVolatile() const;
+  bool IsStatic() const;
+  bool IsFinal() const;
+  bool IsPrivate() const;
+  bool IsProtected() const;
+  bool IsPrimitive() const;
+  bool IsReference() const;
+  bool IspOffset() const;
+  FieldOffset *GetFieldpOffset() const;
+  bool Cmp(const char *fieldName, const char *fieldType) const;
+  bool Cmp(const MString *fieldName, const MClass *type) const;
+  template<typename valueType>
+  void SetPrimitiveValue(MObject *o, char dstType, valueType value, bool clinitCheck = true) const;
+  template<typename dstType>
+  dstType GetPrimitiveValue(const MObject *o, char srcType) const;
+  std::string GetAnnotation() const;
+  std::string GetFullName(const MClass *declaringClass, bool needType) const;
+  MObject *GetObjectValue(const MObject *o) const;
+  MObject *GetSignatureAnnotation() const;
+  void SetObjectValue(MObject *o, const MObject *value, bool clinitCheck = true) const;
+  void SetStaticAddr(uintptr_t addr);
+  void SetHashCode(uint16_t hash);
+  void SetMod(const uint32_t modifier);
+  void SetTypeName(const char *typeName);
+  void SetFlag(const uint16_t fieldFlag);
+  void SetIndex(const uint16_t fieldIndex);
+  void SetFieldName(const char *fieldName);
+  void SetAnnotation(const char *strAnnotation);
+  void SetDeclaringClass(const MClass &dlClass);
+  void FillFieldMeta(uint32_t modifier, size_t offset, const char *typeName, uint16_t hash,
+                     uint16_t index, const char *name, const char *strAnnotation, const MClass &cls);
+  size_t GetMemSize() const; // return the memory size this field consumes
+
+  template<typename T>
+  static inline FieldMeta *JniCast(T fieldMeta);
+  template<typename T>
+  static inline FieldMeta *JniCastNonNull(T fieldMeta);
+  template<typename T>
+  static inline FieldMeta *Cast(T fieldMeta);
+  template<typename T>
+  static inline FieldMeta *CastNonNull(T fieldMeta);
+  inline jfieldID AsJfieldID();
+
+ private:
+  union {
+    DataRefOffset pOffset;      // point to FieldOffset struct, and meta is RO, if the flag LSB mask 1.
+    DataRefOffset offset;       // offset for instance field in bits, compatibility before or runtime generic meta.
+    DataRefOffset relOffset;    // address offset for static field, compatibility before or runtime generic meta.
+  };
+  uint32_t mod;
+  uint16_t flag;
+  uint16_t index;
+  DataRefOffset typeName;      // point to the string address in reflection strtab
+  DataRefOffset32 fieldName;
+  DataRefOffset32 annotation;
+  DataRefOffset declaringClass;
+  DataRefOffset pClassType;    // point to the mclass address in muid tab
+};
+
+class FieldMetaCompact {
+ public:
+  uint32_t GetBitOffset() const;
+  uintptr_t GetOffsetOrAddress(bool isStatic) const;
+  void SetBitOffset(uint32_t fieldOffset);
+  static FieldMeta *DecodeCompactFieldMetas(MClass &cls);
+  static FieldMetaCompact *DecodeCompactFieldMetasToVector(
+      const MClass &cls, uint32_t vecSize, char **typeNameVec = nullptr, char **fieldNameVec = nullptr,
+      size_t *offsetVec = nullptr, uint32_t *modifierVec = nullptr, FieldMetaCompact **fieldMetaCompacts = nullptr,
+      char **annotationVec = nullptr);
+  static void SetCompactFieldMetaOffset(const MClass &cls, uint32_t index, int32_t fieldOffset);
+  FieldOffset *GetFieldpOffset() const;
+
+ private:
+  union {
+    DataRefOffset32 pOffset;      // point to FieldOffset struct, and meta is always RO.
+  };
+  uint8_t leb128Start;
+  static std::mutex resolveMutex;
+  uint8_t *GetpCompact();
+};
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_FIELDMETA_H_
diff --git a/src/mrt/maplert/include/fieldmeta_inline.h b/src/mrt/maplert/include/fieldmeta_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..9478f0020dbd982b1d6336ed451e84aef385b89c
--- /dev/null
+++ b/src/mrt/maplert/include/fieldmeta_inline.h
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_FIELDMETA_INLINE_H_
+#define MRT_MAPLERT_INCLUDE_FIELDMETA_INLINE_H_
+#include "fieldmeta.h"
+#include "cpphelper.h"
+#include "modifier.h"
+#include "mobject_inline.h"
+#include "mrt_class_init.h"
+#include "mrt_annotation.h"
+#include "mstring_inline.h"
+namespace maplert {
+inline uint32_t FieldOffset::GetBitOffset() const {
+  return static_cast<uint32_t>(offset.GetRawValue());
+}
+
+inline uintptr_t FieldOffset::GetAddress() const {
+  return relOffset.GetDataRef<uintptr_t>();
+}
+
+inline void FieldOffset::SetBitOffset(uint32_t value) {
+  offset.SetRawValue(value);
+}
+
+inline void FieldOffset::SetAddress(uintptr_t addr) {
+  relOffset.SetDataRef(addr);
+}
+
+inline int32_t FieldOffset::GetDefTabIndex() const {
+  return static_cast<int32_t>(defTabIndex.GetRawValue());
+}
+
+inline char *FieldMeta::GetName() const {
+  char *name = fieldName.GetDataRef<char*>();
+  __MRT_Profile_CString(name);
+  return name;
+}
+
+inline int32_t FieldMeta::GetDefTabIndex() const {
+  if (!IspOffset()) {
+    // no def tab index
+    return -1;
+  }
+  FieldOffset *fieldOffset = GetFieldpOffset();
+  DCHECK(fieldOffset != nullptr) << "FieldMeta::GetDefTabIndex(): fieldOffset is nullptr!" << maple::endl;
+  return fieldOffset->GetDefTabIndex();
+}
+
+inline uint16_t FieldMeta::GetHashCode() const {
+  return (flag >> kFieldFlagBits) & kFieldHashMask;
+}
+
+inline void FieldMeta::SetHashCode(uint16_t hash) {
+  flag &= ~(kFieldHashMask << kFieldFlagBits);
+  flag |= (hash & kFieldHashMask) << kFieldFlagBits;
+}
+
+inline void FieldMeta::SetFlag(uint16_t fieldFlag) {
+  flag = fieldFlag;
+}
+
+inline uint16_t FieldMeta::GetFlag() const {
+  return flag;
+}
+
+inline void FieldMeta::SetMod(uint32_t modifier) {
+  mod = modifier;
+}
+
+inline uint32_t FieldMeta::GetMod() const {
+  return mod;
+}
+
+inline char *FieldMeta::GetTypeName() const {
+  char *fieldTypeName = typeName.GetDataRef<char*>();
+  __MRT_Profile_CString(fieldTypeName);
+  return fieldTypeName;
+}
+
+inline MClass *FieldMeta::GetType() const {
+  MetaRef* pFieldType = pClassType.GetDataRef<MetaRef*>();
+  if (pFieldType != nullptr && *pFieldType != 0 && !MRT_IsLazyBindingState(reinterpret_cast<uint8_t*>(*pFieldType))) {
+    return reinterpret_cast<MClass*>(*pFieldType);
+  } else {
+    char *fieldTypeName = GetTypeName();
+    return MClass::GetClassFromDescriptor(GetDeclaringclass(), fieldTypeName);
+  }
+}
+
+// all static field are algned to 8 bytes
+inline size_t FieldMeta::GetMemSize() const {
+  char *fieldTypeName = GetTypeName();
+  DCHECK(fieldTypeName != nullptr) << "FieldMeta::GetMemSize: fieldTypeName is nullptr!" << maple::endl;
+  const size_t algne = 8; // algned to 8 bytes
+  switch (*fieldTypeName) {
+    case 'Z':
+    case 'B':
+    case 'C':
+    case 'S':
+    case 'I':
+    case 'F':
+    case 'J':
+    case 'D':
+    case '[':
+    case 'L':
+      return algne;
+    default:
+      __MRT_ASSERT(false, "Unknown Field Type!");
+      return 0;
+  }
+  return 0;
+}
+
+inline void FieldMeta::SetIndex(uint16_t fieldIndex) {
+  index = fieldIndex;
+}
+
+inline uint16_t FieldMeta::GetIndex() const {
+  return index;
+}
+
+inline uint32_t FieldMeta::GetOffset() const {
+  return IsStatic() ? 0 : GetBitOffset() >> kFieldOffsetShift;
+}
+
+inline uint32_t FieldMeta::GetBitOffset() const {
+  // instance field offset
+  DCHECK(!IsStatic()) << "should be a instance field";
+  FieldOffset *fieldOffset = GetFieldpOffset();
+  DCHECK(fieldOffset != nullptr) << "FieldMeta::GetBitOffset(): fieldOffset is nullptr!" << maple::endl;
+  return fieldOffset->GetBitOffset();
+}
+
+inline MClass *FieldMeta::GetDeclaringclass() const {
+  MClass *dcl = declaringClass.GetDataRef<MClass*>();
+  return dcl;
+}
+
+inline uintptr_t FieldMeta::GetStaticAddr() const {
+  DCHECK(IsStatic()) << "should be a static field";
+  FieldOffset *fieldOffset = GetFieldpOffset();
+  DCHECK(fieldOffset != nullptr) << "FieldMeta::GetStaticAddr: fieldOffset is nullptr!" << maple::endl;
+  return fieldOffset->GetAddress();
+}
+
+inline void FieldMeta::SetTypeName(const char *name) {
+  typeName.SetDataRef(name);
+  __MRT_ASSERT(GetTypeName() == name, "Offset larger than 32bits!");
+}
+
+inline bool FieldMeta::IsPublic() const {
+  return static_cast<bool>(mod & modifier::kModifierPublic);
+}
+
+inline bool FieldMeta::IsVolatile() const {
+  return static_cast<bool>(mod & modifier::kModifierVolatile);
+}
+
+inline bool FieldMeta::IsStatic() const {
+  return static_cast<bool>(mod & modifier::kModifierStatic);
+}
+
+inline bool FieldMeta::IsFinal() const {
+  return static_cast<bool>(mod & modifier::kModifierFinal);
+}
+
+inline bool FieldMeta::IsPrivate() const {
+  return static_cast<bool>(mod & modifier::kModifierPrivate);
+}
+
+inline bool FieldMeta::IsProtected() const {
+  return static_cast<bool>(mod & modifier::kModifierProtected);
+}
+
+inline bool FieldMeta::IsReference() const {
+  const char *fieldTypeName = GetTypeName();
+  DCHECK(fieldTypeName != nullptr) << "FieldMeta::IsReference: fieldTypeName is nullptr!" << maple::endl;
+  bool isRefType = (fieldTypeName[0] == 'L') || (fieldTypeName[0] == '[');
+  return isRefType;
+}
+
+inline bool FieldMeta::IsPrimitive() const {
+  return !IsReference();
+}
+
+inline bool FieldMeta::IspOffset() const {
+  return static_cast<bool>(flag & modifier::kFieldOffsetIspOffset);
+}
+
+inline FieldOffset *FieldMeta::GetFieldpOffset() const {
+  FieldOffset *fieldOffset = nullptr;
+  if (IspOffset()) {
+    fieldOffset = pOffset.GetDataRef<FieldOffset*>();
+  } else {
+    fieldOffset = const_cast<FieldOffset*>(reinterpret_cast<const FieldOffset*>(&pOffset));
+  }
+  return fieldOffset;
+}
+
+inline std::string FieldMeta::GetAnnotation() const {
+  char *annotationStr = annotation.GetDataRef<char*>();
+  __MRT_Profile_CString(annotationStr);
+  return AnnotationUtil::GetAnnotationUtil(annotationStr);
+}
+
+inline MObject *FieldMeta::GetRealMObject(const MObject *o, bool clinitCheck) const {
+  if (!IsStatic()) {
+    return const_cast<MObject*>(o);
+  }
+  // access to tatic fields
+  if (clinitCheck && !GetDeclaringclass()->InitClassIfNeeded()) {
+    return nullptr;
+  }
+  return MObject::Cast<MObject>(GetStaticAddr());
+}
+
+inline void FieldMeta::SetBitOffset(uint32_t setOffset) {
+  // instance field offset
+  DCHECK(!IsStatic()) << "should be instance field" << maple::endl;
+  FieldOffset *fieldOffset = GetFieldpOffset();
+  DCHECK(fieldOffset != nullptr) << "FieldMeta::SetBitOffset: fieldOffset is nullptr!" << maple::endl;
+  fieldOffset->SetBitOffset(setOffset);
+}
+
+template<typename valueType>
+inline void FieldMeta::SetPrimitiveValue(MObject *o, char dstType, valueType value, bool clinitCheck) const {
+  o = GetRealMObject(o, clinitCheck);
+  if (UNLIKELY(o == nullptr)) {
+    return;
+  }
+  uint32_t offset = GetOffset();
+  const bool isVol = IsVolatile();
+  switch (dstType) {
+    case 'Z':
+      o->Store<uint8_t>(offset, static_cast<uint8_t>(value), isVol);
+      break;
+    case 'B':
+      o->Store<int8_t>(offset, static_cast<int8_t>(value), isVol);
+      break;
+    case 'C':
+      o->Store<uint16_t>(offset, static_cast<uint16_t>(value), isVol);
+      break;
+    case 'S':
+      o->Store<int16_t>(offset, static_cast<int16_t>(value), isVol);
+      break;
+    case 'I':
+      o->Store<int32_t>(offset, static_cast<int32_t>(value), isVol);
+      break;
+    case 'J':
+      o->Store<int64_t>(offset, static_cast<int64_t>(value), isVol);
+      break;
+    case 'F':
+      o->Store<float>(offset, static_cast<float>(value), isVol);
+      break;
+    case 'D':
+      o->Store<double>(offset, static_cast<double>(value), isVol);
+      break;
+    default:
+      LOG(FATAL) << "can not run here!!! dstType: " << dstType << maple::endl;
+  }
+}
+
+template<typename dstType>
+inline dstType FieldMeta::GetPrimitiveValue(const MObject *o, char srcType) const {
+  o = GetRealMObject(o);
+  if (UNLIKELY(o == nullptr)) {
+    return 0;
+  }
+  uint32_t offset = GetOffset();
+  const bool isVol = IsVolatile();
+  switch (srcType) {
+    case 'Z':
+      return static_cast<dstType>(o->Load<uint8_t>(offset, isVol));
+    case 'B':
+      return static_cast<dstType>(o->Load<int8_t>(offset, isVol));
+    case 'C':
+      return static_cast<dstType>(o->Load<uint16_t>(offset, isVol));
+    case 'S':
+      return static_cast<dstType>(o->Load<int16_t>(offset, isVol));
+    case 'I':
+      return static_cast<dstType>(o->Load<int32_t>(offset, isVol));
+    case 'J':
+      return static_cast<dstType>(o->Load<int64_t>(offset, isVol));
+    case 'F':
+      return static_cast<dstType>(o->Load<float>(offset, isVol));
+    case 'D':
+      return static_cast<dstType>(o->Load<double>(offset, isVol));
+    default:
+      LOG(FATAL) << "can not run here!!! srcType: " << srcType << maple::endl;
+  }
+  return 0;
+}
+
+inline bool FieldMeta::Cmp(const char *name, const char *type) const {
+  DCHECK(name != nullptr) << "fieldName is null." << maple::endl;
+  if (strcmp(name, GetName()) == 0) {
+    return (type != nullptr) ? (strcmp(type, GetTypeName()) == 0) : true;
+  }
+  return false;
+}
+
+inline bool FieldMeta::Cmp(const MString *name, const MClass *type __attribute__((unused))) const {
+  DCHECK(name != nullptr) << "FieldMeta::Cmp: name is nullptr!" << maple::endl;
+  return name->Cmp(std::string(GetName()));
+}
+
+template<typename T>
+inline FieldMeta *FieldMeta::JniCast(T fieldMeta) {
+  static_assert(std::is_same<T, jfieldID>::value || std::is_same<T, jobject>::value, "wrong type");
+  return reinterpret_cast<FieldMeta*>(fieldMeta);
+}
+
+template<typename T>
+inline FieldMeta *FieldMeta::JniCastNonNull(T fieldMeta) {
+  DCHECK(fieldMeta != nullptr);
+  return JniCast(fieldMeta);
+}
+
+template<typename T>
+inline FieldMeta *FieldMeta::Cast(T fieldMeta) {
+  static_assert(std::is_same<T, address_t>::value, "wrong type");
+  return reinterpret_cast<FieldMeta*>(fieldMeta);
+}
+
+template<typename T>
+inline FieldMeta *FieldMeta::CastNonNull(T fieldMeta) {
+  DCHECK(fieldMeta != nullptr);
+  return Cast(fieldMeta);
+}
+
+inline jfieldID FieldMeta::AsJfieldID() {
+  return reinterpret_cast<jfieldID>(this);
+}
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_FIELDMETA_INLINE_H_
diff --git a/src/mrt/maplert/include/itab_util.h b/src/mrt/maplert/include/itab_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..d4c44eaa36f5cdc02bfa48c9afbae82c9b659db8
--- /dev/null
+++ b/src/mrt/maplert/include/itab_util.h
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_ITAB_HOT_METHOD_H
+#define MRT_ITAB_HOT_METHOD_H
+
+namespace maple {
+constexpr int kHashSize = 23;
+constexpr int kHeadSizeOfSecondHash = 3;
+constexpr int kFlagAgInHeadOfSecondHash = 1;
+constexpr unsigned int kItabSecondHashSize = 0x1fff;
+constexpr int kFlagFirstHashConflict = 0;
+constexpr int kFlagSecondHashConflict = 1;
+#define ITAB_HOTMETHOD_SIZE (sizeof(itabHotMethod) / sizeof(itabHotMethod[0]))
+
+constexpr int kItabFirstHashSize = kHashSize;
+
+unsigned int DJBHash(const char *str);
+unsigned int GetHashIndex(const char *name);
+unsigned int GetSecondHashIndex(const char *name);
+
+static const char *itabHotMethod[] = {
+    "hasNext_7C_28_29Z",
+    "next_7C_28_29Ljava_2Flang_2FObject_3B",
+    "asBinder_7C_28_29Landroid_2Fos_2FIBinder_3B",
+    "gettid_7C_28_29I",
+    "get_7C_28I_29Ljava_2Flang_2FObject_3B",
+    "size_7C_28_29I",
+    "next_7C_28_29I",
+    "get_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "length_7C_28_29I",
+    "isUidPrivileged_7C_28I_29Z",
+    "sendBehavior_7C_28Lhuawei_2Fandroid_2Fsecurity_2FIHwBehaviorCollectManager_24BehaviorId_3BALjava_2Flang_2FObject_3B_29V",
+    "sendBehavior_7C_28Lhuawei_2Fandroid_2Fsecurity_2FIHwBehaviorCollectManager_24BehaviorId_3B_29V",
+    "iterator_7C_28_29Ljava_2Futil_2FIterator_3B",
+    "attribute_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "getAttributeValue_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B",
+    "index_7C_28_29I",
+    "toString_7C_28_29Ljava_2Flang_2FString_3B",
+    "print_7C_28Ljava_2Flang_2FObject_3BLjava_2Futil_2FLocale_3B_29V",
+    "append_7C_28Ljava_2Flang_2FCharSequence_3B_29Ljava_2Flang_2FAppendable_3B",
+    "add_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "containsKey_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "onReadFromDisk_7C_28_29V",
+    "apply_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "getDepth_7C_28_29I",
+    "accept_7C_28Ljava_2Flang_2FObject_3B_29V",
+    "getName_7C_28_29Ljava_2Flang_2FString_3B",
+    "writeToParcel_7C_28Landroid_2Fos_2FParcel_3BI_29V",
+    "getuid_7C_28_29I",
+    "charAt_7C_28I_29C",
+    "read_7C_28Ljava_2Fio_2FFileDescriptor_3BABII_29I",
+    "test_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "contains_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "isEmpty_7C_28_29Z",
+    "createFromParcel_7C_28Landroid_2Fos_2FParcel_3B_29Ljava_2Flang_2FObject_3B",
+    "toJavaFormatString_7C_28_29Ljava_2Flang_2FString_3B",
+    "endTag_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "getHwHandler_7C_28_29Landroid_2Fos_2FIHwHandler_3B",
+    "startTag_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "resetMessageDelayMillis_7C_28Landroid_2Fos_2FMessage_3BJ_29J",
+    "close_7C_28Ljava_2Fio_2FFileDescriptor_3B_29V",
+    "iterator_7C_28_29Ljava_2Futil_2FIterator_3B",
+    "transact_7C_28ILandroid_2Fos_2FParcel_3BLandroid_2Fos_2FParcel_3BI_29Z",
+    "getValue_7C_28_29Ljava_2Flang_2FObject_3B",
+    "checkPermission_7C_28Ljava_2Flang_2FString_3BII_29I",
+    "getKey_7C_28_29Ljava_2Flang_2FObject_3B",
+    "compare_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29I",
+    "getAttrs_7C_28_29Landroid_2Fview_2FWindowManager_24LayoutParams_3B",
+    "run_7C_28_29V",
+    "getpid_7C_28_29I",
+    "isEmpty_7C_28_29Z",
+    "checkUidPermission_7C_28Ljava_2Flang_2FString_3BI_29I",
+    "close_7C_28Ljava_2Flang_2FThrowable_3B_29V",
+    "queryLocalInterface_7C_28Ljava_2Flang_2FString_3B_29Landroid_2Fos_2FIInterface_3B",
+    "getService_7C_28Landroid_2Fapp_2FContextImpl_3B_29Ljava_2Flang_2FObject_3B",
+    "getInt_7C_28I_29I",
+    "stat_7C_28Ljava_2Flang_2FString_3B_29Landroid_2Fsystem_2FStructStat_3B",
+    "getHwConfiguration_7C_28_29Landroid_2Fcontent_2Fres_2FIHwConfiguration_3B",
+    "process_7C_28Lcom_2Fandroid_2Fserver_2Fjob_2Fcontrollers_2FJobStatus_3B_29V",
+    "put_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "getWinFreezeScreenMonitor_7C_28_29Lcom_2Fandroid_2Fserver_2Fos_2FIFreezeScreenWindowMonitor_3B",
+    "setTo_7C_28Landroid_2Fcontent_2Fres_2FIHwConfiguration_3B_29V",
+    "getWindowLayerFromTypeLw_7C_28IZ_29I",
+    "getString_7C_28I_29Ljava_2Flang_2FString_3B",
+    "isVisibleLw_7C_28_29Z",
+    "toArray_7C_28_29ALjava_2Flang_2FObject_3B",
+    "getPolicyMask_7C_28_29I",
+    "close_7C_28_29V",
+    "compareTo_7C_28Landroid_2Fcontent_2Fres_2FIHwConfiguration_3B_29I",
+    "setToDefaults_7C_28_29V",
+    "getEventType_7C_28_29I",
+    "contains_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "remove_7C_28I_29Ljava_2Flang_2FObject_3B",
+    "checkIntent_7C_28ILjava_2Flang_2FString_3BIILjava_2Flang_2FString_3BI_29Z",
+    "getStackId_7C_28_29I",
+    "hashCode_7C_28_29I",
+    "applyPostLayoutPolicyLw_7C_28Landroid_2Fview_2FWindowManagerPolicy_24WindowState_3BLandroid_2Fview_2FWindowManager_24LayoutParams_3BLandroid_2Fview_2FWindowManagerPolicy_24WindowState_3BLandroid_2Fview_2FWindowManagerPolicy_24WindowState_3B_29V",
+    "getHwFlogManager_7C_28_29Landroid_2Fcommon_2FHwFlogManager_3B",
+    "canAffectSystemUiFlags_7C_28_29Z",
+    "isKeyguardLocked_7C_28_29Z",
+    "slog_7C_28IILjava_2Flang_2FString_3B_29I",
+    "values_7C_28_29Ljava_2Futil_2FCollection_3B",
+    "checkFreezeScreen_7C_28Landroid_2Futil_2FArrayMap_3B_29V",
+    "moveToNext_7C_28_29Z",
+    "getResolution_7C_28Ljava_2Flang_2FString_3B_29F",
+    "resolveContentProvider_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FProviderInfo_3B",
+    "uptimeMillis_7C_28_29J",
+    "getApplicationInfo_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FApplicationInfo_3B",
+    "canAddInternalSystemWindow_7C_28_29Z",
+    "append_7C_28Ljava_2Flang_2FCharSequence_3B_29Ljava_2Flang_2FAppendable_3B",
+    "getBaseType_7C_28_29I",
+    "onWriteToDisk_7C_28_29V",
+    "isCustedCouldStopped_7C_28Ljava_2Flang_2FString_3BZZ_29Z",
+    "size_7C_28_29I",
+    "write_7C_28Ljava_2Fio_2FFileDescriptor_3BABII_29I",
+    "getIntentForIntentSender_7C_28Landroid_2Fcontent_2FIIntentSender_3B_29Landroid_2Fcontent_2FIntent_3B",
+    "getApsManager_7C_28_29Landroid_2Faps_2FIApsManager_3B",
+    "getConfigItem_7C_28I_29I",
+    "getAppToken_7C_28_29Landroid_2Fview_2FIApplicationToken_3B",
+    "linkToDeath_7C_28Landroid_2Fos_2FIBinder_24DeathRecipient_3BI_29V",
+    "packageHasActiveAdmins_7C_28Ljava_2Flang_2FString_3BI_29Z",
+    "getPackagesForUid_7C_28I_29ALjava_2Flang_2FString_3B",
+    "elapsedRealtime_7C_28_29J",
+    "isBoundWidgetPackage_7C_28Ljava_2Flang_2FString_3BI_29Z",
+    "getIntentForIntentSender_7C_28Landroid_2Fcontent_2FIIntentSender_3B_29Landroid_2Fcontent_2FIntent_3B",
+    "getPackageUid_7C_28Ljava_2Flang_2FString_3BII_29I",
+    "getWinFreezeScreenMonitor_7C_28_29Lcom_2Fandroid_2Fserver_2Fos_2FIFreezeScreenWindowMonitor_3B",
+    "stat_7C_28Ljava_2Flang_2FString_3B_29Landroid_2Fsystem_2FStructStat_3B",
+    "isKeyguardLocked_7C_28_29Z",
+    "applyPostLayoutPolicyLw_7C_28Landroid_2Fview_2FWindowManagerPolicy_24WindowState_3BLandroid_2Fview_2FWindowManager_24LayoutParams_3BLandroid_2Fview_2FWindowManagerPolicy_24WindowState_3BLandroid_2Fview_2FWindowManagerPolicy_24WindowState_3B_29V",
+    "getPackagesForUid_7C_28I_29ALjava_2Flang_2FString_3B",
+    "compare_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29I",
+    "next_7C_28_29Ljava_2Flang_2FObject_3B",
+    "getApplicationInfo_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FApplicationInfo_3B",
+    "registerReceiver_7C_28Landroid_2Fapp_2FIApplicationThread_3BLjava_2Flang_2FString_3BLandroid_2Fcontent_2FIIntentReceiver_3BLandroid_2Fcontent_2FIntentFilter_3BLjava_2Flang_2FString_3BII_29Landroid_2Fcontent_2FIntent_3B",
+    "iterator_7C_28_29Ljava_2Futil_2FIterator_3B",
+    "getHwFlogManager_7C_28_29Landroid_2Fcommon_2FHwFlogManager_3B",
+    "getString_7C_28I_29Ljava_2Flang_2FString_3B",
+    "getppid_7C_28_29I",
+    "getNameForUid_7C_28I_29Ljava_2Flang_2FString_3B",
+    "isProtectedBroadcast_7C_28Ljava_2Flang_2FString_3B_29Z",
+    "getEventType_7C_28_29I",
+    "packageHasActiveAdmins_7C_28Ljava_2Flang_2FString_3BI_29Z",
+    "getApplicationEnabledSetting_7C_28Ljava_2Flang_2FString_3BI_29I",
+    "handleIncomingUser_7C_28IIIZZLjava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29I",
+    "write_7C_28Ljava_2Fio_2FFileDescriptor_3BABII_29I",
+    "getApsManager_7C_28_29Landroid_2Faps_2FIApsManager_3B",
+    "getBaseType_7C_28_29I",
+    "size_7C_28_29I",
+    "getPackageInfo_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FPackageInfo_3B",
+    "remove_7C_28I_29Ljava_2Flang_2FObject_3B",
+    "resolveContentProvider_7C_28Ljava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FProviderInfo_3B",
+    "fstat_7C_28Ljava_2Fio_2FFileDescriptor_3B_29Landroid_2Fsystem_2FStructStat_3B",
+    "getName_7C_28_29Ljava_2Flang_2FString_3B",
+    "isEmpty_7C_28_29Z",
+    "queryIntentReceivers_7C_28Landroid_2Fcontent_2FIntent_3BLjava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FParceledListSlice_3B",
+    "print_7C_28Ljava_2Flang_2FObject_3BLjava_2Futil_2FLocale_3B_29V",
+    "getStackId_7C_28_29I",
+    "iterator_7C_28_29Ljava_2Futil_2FIterator_3B",
+    "get_7C_28Ljava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "checkUidSignatures_7C_28II_29I",
+    "add_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "containsKey_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "endTag_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "getResolution_7C_28Ljava_2Flang_2FString_3B_29F",
+    "getDepth_7C_28_29I",
+    "canAddInternalSystemWindow_7C_28_29Z",
+    "getResolution_7C_28Ljava_2Flang_2FString_3B_29F",
+    "values_7C_28_29Ljava_2Futil_2FCollection_3B",
+    "moveToNext_7C_28_29Z",
+    "getCurrentUser_7C_28_29Landroid_2Fcontent_2Fpm_2FUserInfo_3B",
+    "close_7C_28_29V",
+    "getInt_7C_28I_29I",
+    "charAt_7C_28I_29C",
+    "read_7C_28Ljava_2Fio_2FFileDescriptor_3BABII_29I",
+    "getRunningAppProcesses_7C_28_29Ljava_2Futil_2FList_3B",
+    "setPackageStoppedState_7C_28Ljava_2Flang_2FString_3BZI_29V",
+    "getNonDecorDisplayWidth_7C_28IIIII_29I",
+    "startTag_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Lorg_2Fxmlpull_2Fv1_2FXmlSerializer_3B",
+    "finishLayoutLw_7C_28_29V",
+    "contains_7C_28Ljava_2Flang_2FObject_3B_29Z",
+    "setFirewallUidRule_7C_28III_29V",
+    "getForceRotationManager_7C_28_29Lcom_2Fhuawei_2Fforcerotation_2FIForceRotationManager_3B",
+    "ioctlInt_7C_28Ljava_2Fio_2FFileDescriptor_3BILandroid_2Futil_2FMutableInt_3B_29I",
+    "close_7C_28Ljava_2Fio_2FFileDescriptor_3B_29V",
+    "isResourceNeeded_7C_28I_29Z",
+    "isAppStartModeDisabled_7C_28ILjava_2Flang_2FString_3B_29Z",
+    "getpid_7C_28_29I",
+    "beginPostLayoutPolicyLw_7C_28II_29V",
+    "getAttributeValue_7C_28Ljava_2Flang_2FString_3BLjava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B",
+    "getUserInfo_7C_28I_29Landroid_2Fcontent_2Fpm_2FUserInfo_3B",
+    "getActiveScorerPackage_7C_28_29Ljava_2Flang_2FString_3B",
+    "isPowerSaveWhitelistExceptIdleApp_7C_28Ljava_2Flang_2FString_3B_29Z",
+    "open_7C_28Ljava_2Flang_2FString_3BII_29Ljava_2Fio_2FFileDescriptor_3B",
+    "index_7C_28_29I",
+    "toString_7C_28_29Ljava_2Flang_2FString_3B",
+    "isPackageAvailable_7C_28Ljava_2Flang_2FString_3BI_29Z",
+    "append_7C_28Ljava_2Flang_2FCharSequence_3B_29Ljava_2Flang_2FAppendable_3B",
+    "scheduleRegisteredReceiver_7C_28Landroid_2Fcontent_2FIIntentReceiver_3BLandroid_2Fcontent_2FIntent_3BILjava_2Flang_2FString_3BLandroid_2Fos_2FBundle_3BZZII_29V",
+    "getPackageForIntentSender_7C_28Landroid_2Fcontent_2FIIntentSender_3B_29Ljava_2Flang_2FString_3B",
+    "toArray_7C_28_29ALjava_2Flang_2FObject_3B",
+    "setToDefaults_7C_28_29V",
+    "isEmpty_7C_28_29Z",
+    "put_7C_28Ljava_2Flang_2FObject_3BLjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "getStackBounds_7C_28ILandroid_2Fgraphics_2FRect_3B_29V",
+    "checkPackageStartable_7C_28Ljava_2Flang_2FString_3BI_29V",
+    "checkPackage_7C_28ILjava_2Flang_2FString_3B_29I",
+    "notifyPackageUse_7C_28Ljava_2Flang_2FString_3BI_29V",
+    "getAppToken_7C_28_29Landroid_2Fview_2FIApplicationToken_3B",
+    "isScreenOn_7C_28_29Z",
+    "computeFrameLw_7C_28Landroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3BLandroid_2Fgraphics_2FRect_3B_29V",
+    "getPolicy_7C_28Landroid_2Fcontent_2FComponentName_3BLjava_2Flang_2FString_3BI_29Landroid_2Fos_2FBundle_3B",
+    "getAttributeNameResource_7C_28I_29I",
+    "getuid_7C_28_29I",
+    "getConfigDisplayHeight_7C_28IIIII_29I",
+    "set_7C_28ILjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B",
+    "finishPostLayoutPolicyLw_7C_28_29I",
+    "isNetworkMetered_7C_28Landroid_2Fnet_2FNetworkState_3B_29Z",
+    "getResources_7C_28Ljava_2Flang_2FClassLoader_3B_29Landroid_2Fcontent_2Fres_2FResources_3B",
+    "refContentProvider_7C_28Landroid_2Fos_2FIBinder_3BII_29Z",
+    "queryIntentServices_7C_28Landroid_2Fcontent_2FIntent_3BLjava_2Flang_2FString_3BII_29Landroid_2Fcontent_2Fpm_2FParceledListSlice_3B",
+    "bindService_7C_28Landroid_2Fapp_2FIApplicationThread_3BLandroid_2Fos_2FIBinder_3BLandroid_2Fcontent_2FIntent_3BLjava_2Flang_2FString_3BLandroid_2Fapp_2FIServiceConnection_3BILjava_2Flang_2FString_3BI_29I",
+    "appendChild_7C_28Lorg_2Fw3c_2Fdom_2FNode_3B_29Lorg_2Fw3c_2Fdom_2FNode_3B",
+    "getHwNsdImpl_7C_28_29Landroid_2Fview_2FIHwNsdImpl_3B",
+    "getenv_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2FString_3B"
+};
+}  // namespace maple
+#endif
diff --git a/src/mrt/maplert/include/literalstrname.h b/src/mrt/maplert/include/literalstrname.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbb5e7a3b6706bb013229e097fb1bb252a9e01c2
--- /dev/null
+++ b/src/mrt/maplert/include/literalstrname.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_INCLUDE_LITERALSTRNAME_H
+#define MRT_INCLUDE_LITERALSTRNAME_H
+#include <map>
+#include "muid.h"
+
+// literal string naming is shared between maple compiler and runtime, thus not in namespace maplert
+const std::string kConstString = "_C_STR_";
+const std::string kConstStringPtr = "_PTR_C_STR_";
+const std::string kLocalStringPrefix = "L_STR_";
+constexpr int kConstStringLen = 7;
+
+class LiteralStrName {
+ public:
+  static int32_t CalculateHashSwapByte(const char16_t *data, uint32_t len);
+  static uint32_t CalculateHash(const char16_t *data, uint32_t len, bool dataIsCompress) {
+    uint32_t hash = 0;
+    if (dataIsCompress) {
+      const char *dataStart = reinterpret_cast<const char*>(data);
+      const char *end = dataStart + len;
+      while (dataStart < end) {
+        hash = (hash << 5) - hash + static_cast<uint32_t>(*dataStart++); // calculate the hash code of data
+      }
+    } else {
+      const char16_t *end = data + len;
+      while (data < end) {
+        hash = (static_cast<unsigned int>(hash) << 5) - hash + *data++; // calculate the hash code of data
+      }
+    }
+    return hash;
+  }
+
+  static std::string GetHexStr(const uint8_t *bytes, uint32_t len);
+  static std::string GetLiteralStrName(const uint8_t *bytes, uint32_t len);
+  static std::string ComputeMuid(const uint8_t *bytes, uint32_t len);
+};
+
+#endif
diff --git a/src/mrt/maplert/include/marray.h b/src/mrt/maplert/include/marray.h
new file mode 100644
index 0000000000000000000000000000000000000000..85e339d00c8a70c33d96df76143497396a38234e
--- /dev/null
+++ b/src/mrt/maplert/include/marray.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MARRAY_H_
+#define MRT_MAPLERT_INCLUDE_MARRAY_H_
+#include "mobject.h"
+#include "mrt_fields_api.h"
+namespace maplert {
+  const uint32_t kMrtArrayLengthOffset = 12;  // shadow:[4|8] + monitor:4, but we fix it here,
+                                              // since content offset is fixed
+  const uint32_t kMrtArrayContentOffset = 16; // fixed. aligned to 8B to along hosting of size-8B elements.
+
+enum ArrayElemSize {
+  kElemByte = 0,
+  kElemHWord = 1,
+  kElemWord = 2,
+  kElemDWord = 3
+};
+
+class MArray : public MObject {
+ public:
+  uint32_t GetLength() const;
+  uint32_t GetArraySize() const;
+  uint32_t GetElementSize() const;
+  char *GetElementTypeName() const;
+  void InitialObjectArray(const MObject *initialElement) const;
+  uint8_t *ConvertToCArray() const;
+  template<typename T>
+  T GetPrimitiveElement(uint32_t index);
+  template<typename T>
+  void SetPrimitiveElement(uint32_t index, T value);
+  MObject *GetObjectElement(uint32_t index) const;
+  void SetObjectElement(uint32_t index, const MObject *mObj) const;
+  MObject *GetObjectElementNoRc(uint32_t index) const;
+  void SetObjectElementNoRc(uint32_t index, const MObject *mObj) const;
+  MObject *GetObjectElementOffHeap(uint32_t index) const;
+  void SetObjectElementOffHeap(uint32_t index, const MObject *mObj) const;
+  bool HasNullElement() const;
+  static uint32_t GetArrayContentOffset();
+  template<ArrayElemSize elemSizeExp>
+  static MArray *NewPrimitiveArray(uint32_t length, const MClass &arrayClass, bool isJNI = false);
+  static MArray *NewPrimitiveArray(uint32_t length, const MClass &arrayClass, bool isJNI = false);
+  template<ArrayElemSize elemSizeExp>
+  static MArray *NewPrimitiveArrayComponentClass(uint32_t length, const MClass &componentClass);
+  static MArray *NewPrimitiveArrayComponentClass(uint32_t length, const MClass &componentClass);
+  static MArray *NewObjectArray(uint32_t length, const MClass &arrayClass);
+  static MArray *NewObjectArrayComponentClass(uint32_t length, const MClass &componentClass);
+
+  template<typename T>
+  static inline MArray *JniCast(T array);
+  template<typename T>
+  static inline MArray *JniCastNonNull(T array);
+  inline jarray AsJarray() const;
+  inline jobjectArray AsJobjectArray() const;
+
+ private:
+  static constexpr uint32_t lengthOffset = kMrtArrayLengthOffset;
+  static constexpr uint32_t contentOffset = kMrtArrayContentOffset;
+  static constexpr uint32_t objectElemSize = sizeof(reffield_t);
+};
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MARRAY_H_
diff --git a/src/mrt/maplert/include/marray_inline.h b/src/mrt/maplert/include/marray_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..f41b15923ddc39fbfa84e669c8205538200839c6
--- /dev/null
+++ b/src/mrt/maplert/include/marray_inline.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MARRAY_INLINE_H_
+#define MRT_MAPLERT_INCLUDE_MARRAY_INLINE_H_
+#include <atomic>
+#include "marray.h"
+#include "mobject_inline.h"
+namespace maplert {
+inline uint32_t MArray::GetLength() const {
+  return Load<uint32_t>(lengthOffset, false);
+}
+
+inline uint8_t *MArray::ConvertToCArray() const {
+  return reinterpret_cast<uint8_t*>(AsUintptr() + contentOffset);
+}
+
+inline uint32_t MArray::GetArrayContentOffset() {
+  return contentOffset;
+}
+
+inline uint32_t MArray::GetArraySize() const {
+  uint32_t length = GetLength();
+  uint32_t elementSize = GetElementSize();
+  return (contentOffset + elementSize * length);
+}
+
+inline uint32_t MArray::GetElementSize() const {
+  MClass *cls = GetClass();
+  return cls->GetComponentSize();
+}
+
+inline char *MArray::GetElementTypeName() const {
+  MClass *cls = GetClass();
+  MClass *componentClass = cls->GetComponentClass();
+  return componentClass->GetName();
+}
+
+inline MObject *MArray::GetObjectElement(uint32_t index) const {
+  return LoadObject(contentOffset + objectElemSize * index, false);
+}
+
+inline void MArray::SetObjectElement(uint32_t index, const MObject *mObj) const {
+  StoreObject(contentOffset + objectElemSize * index, mObj, false);
+}
+
+inline MObject *MArray::GetObjectElementNoRc(uint32_t index) const {
+  return LoadObjectNoRc(contentOffset + objectElemSize * index);
+}
+
+inline void MArray::SetObjectElementNoRc(uint32_t index, const MObject *mObj) const {
+  StoreObjectNoRc(contentOffset + objectElemSize * index, mObj);
+}
+
+inline MObject *MArray::GetObjectElementOffHeap(uint32_t index) const {
+  return LoadObjectOffHeap(contentOffset + objectElemSize * index);
+}
+
+inline void MArray::SetObjectElementOffHeap(uint32_t index, const MObject *mObj) const {
+  StoreObjectOffHeap(contentOffset + objectElemSize * index, mObj);
+}
+
+template<typename T>
+inline T MArray::GetPrimitiveElement(uint32_t index) {
+  uint32_t offset = contentOffset + GetElementSize() * index;
+  T value = Load<T>(offset, false);
+  return value;
+}
+
+template<typename T>
+inline void MArray::SetPrimitiveElement(uint32_t index, T value) {
+  uint32_t offset = contentOffset + GetElementSize() * index;
+  Store<T>(offset, value, false);
+}
+
+inline bool MArray::HasNullElement() const {
+  uint32_t len = GetLength();
+  for (uint32_t i = 0; i < len; ++i) {
+    MObject *element = GetObjectElementNoRc(i);
+    if (element == nullptr) {
+      return true;
+    }
+  }
+  return false;
+}
+
+template<typename T>
+inline MArray *MArray::JniCast(T array) {
+  static_assert(std::is_same<T, jarray>::value || std::is_same<T, jobject>::value ||
+      std::is_same<T, jobjectArray>::value, "wrong type");
+  return reinterpret_cast<MArray*>(array);
+}
+
+template<typename T>
+inline MArray *MArray::JniCastNonNull(T array) {
+  DCHECK(array != nullptr);
+  return JniCast(array);
+}
+
+inline jarray MArray::AsJarray() const {
+  return reinterpret_cast<jarray>(const_cast<MArray*>(this));
+}
+
+inline jobjectArray MArray::AsJobjectArray() const {
+  return reinterpret_cast<jobjectArray>(const_cast<MArray*>(this));
+}
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MARRAY_INLINE_H_
diff --git a/src/mrt/maplert/include/mclass.h b/src/mrt/maplert/include/mclass.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6bb0ea648cb80163f418f841e74d2ce03e9cea9
--- /dev/null
+++ b/src/mrt/maplert/include/mclass.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MCLASS_H_
+#define MRT_MAPLERT_INCLUDE_MCLASS_H_
+#include "mobject.h"
+#include "metadata_inline.h"
+#include "fieldmeta.h"
+#include "methodmeta.h"
+
+namespace maplert {
+// NOTE: class object layout is different from java.lang.Class
+//       its layout defind in struct ClassMetadata
+class FieldMeta;
+class MethodMeta;
+class FieldMetaCompact;
+class MethodMetaCompact;
+class MClass : public MObject {
+ public:
+  char *GetName() const;
+  uint16_t GetClIndex() const;
+  uint32_t GetFlag() const;
+  int32_t GetMonitor() const;
+  uint32_t GetNumOfSuperClasses() const;
+  uint32_t GetNumOfInterface() const;
+  MClass *GetComponentClass() const;
+  uint32_t GetComponentSize() const;
+  uint8_t *GetItab() const;
+  uint8_t *GetVtab() const;
+  uint8_t *GetGctib() const;
+  uint32_t GetNumOfFields() const;
+  uint32_t GetNumOfMethods() const;
+  uint32_t GetModifier() const;
+  uint32_t GetObjectSize() const;
+  uintptr_t GetClinitFuncAddr() const;
+  std::string GetAnnotation() const;
+  char *GetRawAnnotation() const;
+  // super class in java
+  MClass *GetSuperClass() const;
+  // include interface
+  MClass *GetSuperClass(uint32_t index) const;
+  // resolve data
+  MClass **GetSuperClassArray() const;
+  // unresolve data
+  MClass **GetSuperClassArrayPtr() const;
+  MClass *GetCacheTrueClass() const;
+  MClass *GetCacheFalseClass() const;
+  bool HasFinalizer() const;
+  bool IsObjectArrayClass() const;
+  bool IsPrimitiveClass() const;
+  bool IsArrayClass() const;
+  bool IsInterface() const;
+  bool IsPublic() const;
+  bool IsProtected() const;
+  bool IsAbstract() const;
+  bool IsProxy() const;
+  bool IsStringClass() const;
+  bool IsAnonymousClass() const;
+  bool IsEnum() const;
+  bool IsDecouple() const;
+  bool IsFinalizable() const;
+  bool IsColdClass() const;
+  bool IsLazyBinding() const;
+  bool IsAssignableFrom(MClass &cls) const;
+  bool IsLazy() const;
+  bool IsFinal() const;
+  bool IsInnerClass() const;
+  bool IsVerified() const;
+  void SetVerified();
+
+  // java.lang.Class<java.lang.Object>
+  void GetPrettyClass(std::string &dstName) const;
+  // java.lang.Object, [Ljava.lang.Object;, int, [I
+  void GetBinaryName(std::string &dstName) const;
+  // java.lang.Object, java.lang.Object[], int, int[]
+  void GetTypeName(std::string &dstName) const;
+  // Ljava/lang/Object; [Ljava/lang/Object; I, [I
+  void GetDescriptor(std::string &dstName) const;
+  static void ConvertDescriptorToTypeName(const std::string &descriptor, std::string &defineName);
+  static void ConvertDescriptorToBinaryName(const std::string &descriptor, std::string &binaryName);
+  uint32_t GetDimension() const;
+  static uint32_t GetDimensionFromDescriptor(const std::string &descriptor);
+
+  FieldMetaCompact *GetCompactFields() const;
+  FieldMeta *GetFieldMetas() const;
+  FieldMeta *GetFieldMeta(uint32_t index) const;
+  MethodMetaCompact *GetCompactMethods() const;
+  MethodMeta *GetMethodMeta(uint32_t index) const;
+  MethodMeta *GetMethodMetas() const;
+  MethodMeta *GetRawMethodMetas() const;
+  MethodMeta *GetDeclaredMethod(const char *methodName, const char *signatureName) const;
+  MethodMeta *GetDeclaredMethod(const MString *methodName, const MArray *signatureName) const;
+  MethodMeta *GetClinitMethodMeta() const;
+  MethodMeta *GetVirtualMethod(const MethodMeta &srcMethod) const;
+  // recursive search method
+  MethodMeta *GetMethod(const char *methodName, const char *signatureName) const;
+  MethodMeta *GetInterfaceMethod(const char *methodName, const char *signatureName) const;
+  MethodMeta *GetMethodForVirtual(const MethodMeta &srcMethod) const;
+  MethodMeta *GetDeclaredConstructor(const char *signature) const;
+  MethodMeta *GetDeclaredConstructor(const MArray *signature) const;
+  MethodMeta *GetDefaultConstructor() const;
+  MethodMeta *GetDeclaredFinalizeMethod() const;
+  MethodMeta *GetFinalizeMethod() const;
+  FieldMeta *GetDeclaredField(const char *name, const char *type = nullptr) const;
+  FieldMeta *GetDeclaredField(const MString *name) const;
+  // recursive search field
+  FieldMeta *GetField(const char *fieldName, const char *fieldType = nullptr, bool isPublic = false) const;
+  FieldMeta *GetField(const MString *fieldName, bool isPublic) const;
+  FieldMeta *GetRawFieldMetas() const;
+  bool IsCompactMetaMethods() const;
+  bool IsCompactMetaFields() const;
+  uint32_t GetMethodMetaIndex(const MethodMeta &srcMethodMeta) const;
+  void GetDeclaredMethods(std::vector<MethodMeta*> &methodsVector, bool publicOnly) const;
+  void GetSuperClassInterfaces(uint32_t numOfSuperClass, MClass **superArray,
+                               std::vector<MClass*> &interfaceVector, uint32_t firstSuperClass) const;
+  void GetInterfaces(std::vector<MClass*> &interfaceVector) const;
+  void GetDirectInterfaces(MClass *interfaceVector[], uint32_t size) const;
+  bool InitClassIfNeeded() const;
+  ClassInitState GetInitState() const;
+  bool IsInitialized() const;
+  void SetInitState(ClassInitState state);
+  MObject *GetSignatureAnnotation() const;
+
+  uint32_t GetArrayModifiers() const;
+  void SetName(const char *name);
+  void SetModifier(uint32_t newMod);
+  void SetGctib(uintptr_t newGctib);
+  void SetSuperClassArray(uintptr_t newValue);
+  void SetObjectSize(uint32_t newSize);
+  void SetItable(uintptr_t newItb);
+  void SetVtable(uintptr_t newVtab);
+  void SetNumOfFields(uint32_t newValue);
+  void SetNumOfMethods(uint32_t newValue);
+  void SetMethods(const MethodMeta &newMethods);
+  void SetFields(const FieldMeta &newFields);
+  void SetInitStateRawValue(uintptr_t newValue);
+  void SetClassMetaRoData(uintptr_t ro);
+  void SetNumOfSuperClasses(uint32_t numOfSuperclasses);
+  void SetHotClass();
+  void SetFlag(uint16_t newFlag);
+  void SetClIndex(uint16_t clIndex);
+  void SetMonitor(int32_t monitor);
+  void ReSetFlag(uint16_t newFlag);
+  void SetNumSuperClasses(uint32_t numOfSuperclasses);
+  void SetComponentClass(const MClass &klass);
+  // for instanceOf cache
+  void SetCacheTrueClass(const MClass &cacheClass);
+  void SetCacheFalseClass(const MClass &cacheClass);
+
+  void ResolveVtabItab();
+  // super class may not visible, resolve by other thread
+  static MClass *ResolveSuperClass(MClass **super);
+  static MClass *GetArrayClass(const MClass &componentClass);
+
+  // context can caller Class, or its instance
+  static MClass *GetClassFromDescriptor(const MObject *context, const char *descriptor, bool throwException = true);
+  static MClass *GetClassFromDescriptorUtil(const MObject *context, const char *descriptor, bool throwException);
+  static MClass *GetPrimitiveClass(const char *descriptor);
+
+  // alloc class memory from perm space if newClsMem is 0,
+  // newClsMem size: sizeof(ClassMetadata) + sizeof(ClassMetadataRO)
+  static MClass *NewMClass(uintptr_t newClsMem = 0);
+  static uint16_t GetMethodFieldHash(const char *name, const char *signature, bool isMethod);
+
+  operator jclass () {
+    return reinterpret_cast<jclass>(this);
+  }
+
+  operator jclass () const {
+    return reinterpret_cast<jclass>(const_cast<MClass*>(this));
+  }
+
+  template<typename T>
+  static inline MClass *JniCast(T c);
+  template<typename T>
+  static inline MClass *JniCastNonNull(T c);
+  jclass inline AsJclass() const;
+
+ private:
+  ClassMetadataRO *GetClassMetaRo() const;
+  ClassMetadata *GetClassMeta() const;
+  bool IsAssignableFromImpl(const MClass &cls) const;
+  // this class is interface
+  bool IsAssignableFromInterface(const MClass &cls) const;
+  static uint16_t GetMethodFieldHash(const MString *name, const MArray *signature, bool isMethod);
+
+  template<typename T1, typename T2, typename T3>
+  T1 *CmpHashEqual(int32_t mid, uint32_t num, T1 *metas, T2 name, T3 signature, uint16_t srcHash) const;
+  template<typename T1, typename T2, typename T3>
+  T1 *GetDeclareMethodFieldUtil(T1 *metas, uint32_t num, T2 name, T3 signature, bool isMethod) const;
+  template<typename T1, typename T2>
+  MethodMeta *GetDeclaredMethodUtil(T1 methodName, T2 methodSignature) const;
+  template<typename T1, typename T2>
+  FieldMeta *GetDeclaredFieldUtil(T1 fieldName, T2 fieldType) const;
+  template<typename T1, typename T2>
+  FieldMeta *GetFieldUtil(T1 fieldName, T2 fieldType, bool isPublic) const;
+  template<typename T1, typename T2>
+  FieldMeta *CmpHashEqualField(int32_t mid, T1 fieldName, T2 fieldType, uint16_t srchash) const;
+  template<typename T>
+  MethodMeta *GetDeclaredConstructorUtil(T signature) const;
+};
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MCLASS_H_
+
diff --git a/src/mrt/maplert/include/mclass_inline.h b/src/mrt/maplert/include/mclass_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..9426db14b8bfb7a496bb99aa97b17ccee9d87095
--- /dev/null
+++ b/src/mrt/maplert/include/mclass_inline.h
@@ -0,0 +1,821 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MCLASS_INLINE_H_
+#define MRT_MAPLERT_INCLUDE_MCLASS_INLINE_H_
+#include "mclass.h"
+#include "mobject_inline.h"
+#include "methodmeta_inline.h"
+#include "fieldmeta_inline.h"
+#include "mrt_class_init.h"
+#include "mrt_profile.h"
+#include "modifier.h"
+#include "mrt_well_known.h"
+#include "linker_api.h"
+#include "mstring_inline.h"
+
+namespace maplert {
+inline ClassMetadata *MClass::GetClassMeta() const {
+  return reinterpret_cast<ClassMetadata*>(const_cast<MClass*>(this));
+}
+
+inline ClassMetadataRO *MClass::GetClassMetaRo() const {
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->classInfoRo.GetDataRef<ClassMetadataRO*>();
+}
+
+inline char *MClass::GetName() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  char *name = classInfoRo->className.GetRef<char*>();
+  __MRT_Profile_CString(name);
+  return name;
+}
+
+inline uint32_t MClass::GetFlag() const {
+#ifdef USE_32BIT_REF
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->flag;
+#else
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->flag;
+#endif // USE_32BIT_REF
+}
+
+inline uint32_t MClass::GetModifier() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->mod;
+}
+
+inline uint16_t MClass::GetClIndex() const {
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->clIndex;
+}
+
+inline int32_t MClass::GetMonitor() const {
+  return this->monitor;
+}
+
+inline uint32_t MClass::GetNumOfSuperClasses() const {
+#if USE_32BIT_REF
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->numOfSuperclasses;
+#else
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->numOfSuperclasses;
+#endif // USE_32BIT_REF
+}
+
+inline uint32_t MClass::GetNumOfInterface() const {
+  uint32_t numOfInterface = 0;
+  if (IsArrayClass()) {
+    // array class has 2 interfaces.
+    numOfInterface = 2;
+  } else {
+    uint32_t numOfSuper = GetNumOfSuperClasses();
+    numOfInterface = (numOfSuper == 0) ? 0 : (IsInterface() ? numOfSuper : numOfSuper - 1);
+  }
+  return numOfInterface;
+}
+
+inline MClass *MClass::GetComponentClass() const {
+  if (UNLIKELY(!IsArrayClass())) {
+    return nullptr;
+  }
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  MClass *componentClass = classInfoRo->componentClass.GetDataRef<MClass*>();
+  return componentClass;
+}
+
+inline uint32_t MClass::GetComponentSize() const {
+  DCHECK(IsArrayClass()) << "must array class." << maple::endl;
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->sizeInfo.componentSize;
+}
+
+inline uint8_t *MClass::GetItab() const {
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->iTable.GetDataRef<uint8_t*>();
+}
+
+inline uint8_t *MClass::GetVtab() const {
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->vTable.GetDataRef<uint8_t*>();
+}
+
+inline uint8_t *MClass::GetGctib() const {
+  ClassMetadata *cls = GetClassMeta();
+  return cls->gctib.GetGctibRef<uint8_t*>();
+}
+
+inline uint32_t MClass::GetNumOfFields() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->numOfFields;
+}
+
+inline uint32_t MClass::GetNumOfMethods() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->numOfMethods;
+}
+
+inline uint32_t MClass::GetObjectSize() const {
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->sizeInfo.objSize;
+}
+
+inline uintptr_t MClass::GetClinitFuncAddr() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->clinitAddr.GetDataRef<uintptr_t>();
+}
+
+inline char *MClass::GetRawAnnotation() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->annotation.GetDataRef<char*>();
+}
+
+inline MClass *MClass::GetSuperClass(uint32_t index) const {
+  MClass **superClassArray = GetSuperClassArray();
+  DCHECK(index < GetNumOfSuperClasses()) << "index too big." << maple::endl;
+  return ResolveSuperClass(superClassArray + index);
+}
+
+inline MClass *MClass::GetSuperClass() const {
+  MClass *super = nullptr;
+  if (!IsInterface() && (GetNumOfSuperClasses() > 0)) {
+    super = GetSuperClass(0);
+  } else if (IsArrayClass()) {
+    super = WellKnown::GetMClassObject();
+  }
+  return super;
+}
+
+ALWAYS_INLINE inline MClass **MClass::GetSuperClassArray() const {
+  MClass *cls = const_cast<MClass*>(this);
+  if (UNLIKELY(IsColdClass())) {
+    LinkerAPI::Instance().ResolveColdClassSymbol(*cls);
+  }
+  return GetSuperClassArrayPtr();
+}
+
+inline MClass *MClass::ResolveSuperClass(MClass **pSuperClass) {
+  MClass *super = *pSuperClass;
+  LinkerRef ref(super->AsUintptr());
+  // Need more fast check interface.
+  if (UNLIKELY(ref.IsIndex())) {
+    return reinterpret_cast<MClass*>(LinkerAPI::Instance().GetSuperClass(
+        reinterpret_cast<ClassMetadata**>(pSuperClass)));
+  } else {
+    return super;
+  }
+}
+
+inline MClass **MClass::GetSuperClassArrayPtr() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->superclass.GetDataRef<MClass**>();
+}
+
+inline MClass *MClass::GetCacheTrueClass() const {
+#ifdef USE_32BIT_REF
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->cacheTrueClass.GetRawValue<MClass*>();
+#else
+  return nullptr;
+#endif
+}
+
+inline  MClass *MClass::GetCacheFalseClass() const {
+#ifdef USE_32BIT_REF
+  const ClassMetadata *cls = GetClassMeta();
+  return cls->cacheFalseClass.GetDataRef<MClass*>();
+#else
+  return nullptr;
+#endif
+}
+
+inline void MClass::SetCacheTrueClass(const MClass &cacheClass) {
+#ifdef USE_32BIT_REF
+  ClassMetadata *cls = GetClassMeta();
+  if (LIKELY(IsInitialized())) {
+    cls->cacheTrueClass.SetDataRef(&cacheClass);
+  }
+#else
+  (void)cacheClass;
+#endif
+}
+
+inline void MClass::SetCacheFalseClass(const MClass &cacheClass) {
+#ifdef USE_32BIT_REF
+  ClassMetadata *cls = GetClassMeta();
+  if (LIKELY(IsInitialized())) {
+    cls->cacheFalseClass.SetDataRef(&cacheClass);
+  }
+#else
+  (void)cacheClass;
+#endif
+}
+
+inline FieldMeta *MClass::GetFieldMetas() const {
+  __MRT_Profile_FieldMeta(*this);
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  FieldMeta *fields = nullptr;
+  if (classInfoRo->fields.IsCompact()) {
+    fields = FieldMetaCompact::DecodeCompactFieldMetas(*const_cast<MClass*>(this));
+  } else {
+    fields = classInfoRo->fields.GetDataRef<FieldMeta*>();
+  }
+  return fields;
+}
+
+inline MethodMeta *MClass::GetMethodMetas() const {
+  __MRT_Profile_MethodMeta(*this);
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  MethodMeta *methods = nullptr;
+  if (classInfoRo->methods.IsCompact()) {
+    methods = MethodMetaCompact::DecodeCompactMethodMetas(*const_cast<MClass*>(this));
+  } else {
+    methods = classInfoRo->methods.GetDataRef<MethodMeta*>();
+  }
+  return methods;
+}
+
+inline MethodMeta *MClass::GetMethodMeta(uint32_t index) const {
+  CHECK(index < GetNumOfMethods()) << "index too large." << maple::endl;
+  MethodMeta *methods = GetMethodMetas();
+  return &methods[index];
+}
+
+inline uint32_t MClass::GetMethodMetaIndex(const MethodMeta &srcMethodMeta) const {
+  MethodMeta *methods = GetMethodMetas();
+  DCHECK(methods != nullptr) << "MClass::GetMethodMetaIndex: methods is null." << maple::endl;
+  uint32_t numOfMethods = GetNumOfMethods();
+  for (uint32_t index = 0; index < numOfMethods; ++index) {
+    if (&methods[index] == &srcMethodMeta) {
+      return index;
+    }
+  }
+  BUILTIN_UNREACHABLE();
+}
+
+inline bool MClass::HasFinalizer() const {
+  uint32_t flags = GetFlag();
+  return modifier::hasFinalizer(flags);
+}
+
+inline bool MClass::IsObjectArrayClass() const {
+  MClass *componentClass = GetComponentClass();
+  if (UNLIKELY(componentClass == nullptr)) {
+    return false;
+  }
+  return !componentClass->IsPrimitiveClass();
+}
+
+inline bool MClass::IsPrimitiveClass() const {
+  uint32_t flag = GetFlag();
+  return modifier::IsPrimitiveClass(flag);
+}
+
+inline bool MClass::IsArrayClass() const {
+  uint32_t flag = GetFlag();
+  return modifier::IsArrayClass(flag);
+}
+
+inline bool MClass::IsStringClass() const {
+  return this == WellKnown::GetMClassString();
+}
+
+inline bool MClass::IsAnonymousClass() const {
+  uint32_t flag = GetFlag();
+  return modifier::IsAnonymousClass(flag);
+}
+
+inline bool MClass::IsEnum() const {
+  return modifier::IsEnum(GetModifier());
+}
+
+inline bool MClass::IsFinalizable() const {
+  return modifier::IsFinalizable(GetModifier());
+}
+
+inline bool MClass::IsDecouple() const {
+  return modifier::IsDecoupleClass(GetFlag());
+}
+
+inline bool MClass::IsInterface() const {
+  uint32_t modifier = GetModifier();
+  return modifier::IsInterface(modifier);
+}
+
+inline bool MClass::IsPublic() const {
+  uint32_t modifier = GetModifier();
+  return modifier::IsPublic(modifier);
+}
+
+inline bool MClass::IsProtected() const {
+  uint32_t modifier = GetModifier();
+  return modifier::IsProtected(modifier);
+}
+
+inline bool MClass::IsAbstract() const {
+  uint32_t modifier = GetModifier();
+  return modifier::IsAbstract(modifier);
+}
+
+inline bool MClass::IsProxy() const {
+  uint32_t modifier = GetModifier();
+  return modifier::IsProxy(modifier);
+}
+
+inline bool MClass::IsFinal() const {
+  uint32_t modifier = GetModifier();
+  return modifier::IsFinal(modifier);
+}
+
+inline bool MClass::IsColdClass() const {
+#ifdef USE_32BIT_REF
+  ClassMetadata *cls = GetClassMeta();
+  uint16_t flag = __atomic_load_n(&cls->flag, __ATOMIC_ACQUIRE);
+  return modifier::IsColdClass(flag);
+#else
+  ClassMetadataRO *clsRo = GetClassMetaRo();
+  uint16_t flag = __atomic_load_n(&clsRo->flag, __ATOMIC_ACQUIRE);
+  return modifier::IsColdClass(flag);
+#endif // USE_32BIT_REF
+}
+
+inline bool MClass::IsLazyBinding() const {
+#ifdef USE_32BIT_REF
+  uint16_t flag = __atomic_load_n(&GetClassMeta()->flag, __ATOMIC_ACQUIRE);
+  return modifier::IsLazyBindingClass(flag);
+#else
+  uint16_t flag = __atomic_load_n(&GetClassMetaRo()->flag, __ATOMIC_ACQUIRE);
+  return modifier::IsLazyBindingClass(flag);
+#endif // USE_32BIT_REF
+}
+
+inline bool MClass::IsLazy() const {
+#ifdef USE_32BIT_REF
+  uint16_t flag = __atomic_load_n(&GetClassMeta()->flag, __ATOMIC_ACQUIRE);
+  return  modifier::IsLazyBindingClass(flag) || modifier::IsLazyBoundClass(flag);
+#else
+  uint16_t flag = __atomic_load_n(&GetClassMetaRo()->flag, __ATOMIC_ACQUIRE);
+  return  modifier::IsLazyBindingClass(flag) || modifier::IsLazyBoundClass(flag);
+#endif // USE_32BIT_REF
+}
+
+inline bool MClass::IsVerified() const {
+#ifdef USE_32BIT_REF
+  uint16_t flag = __atomic_load_n(&GetClassMeta()->flag, __ATOMIC_ACQUIRE);
+  return !modifier::IsNotVerifiedClass(flag);
+#else
+  uint16_t flag = __atomic_load_n(&GetClassMetaRo()->flag, __ATOMIC_ACQUIRE);
+  return !modifier::IsNotVerifiedClass(flag);
+#endif // USE_32BIT_REF
+}
+
+inline void MClass::SetVerified() {
+  uint16_t verifiedFlag = static_cast<uint16_t>(~modifier::kClassRuntimeVerify);
+  ReSetFlag(verifiedFlag);
+}
+
+inline void MClass::SetClassMetaRoData(uintptr_t ro) {
+  ClassMetadata *cls = GetClassMeta();
+  cls->classInfoRo.SetDataRef(ro);
+}
+
+inline void MClass::SetFlag(uint16_t newFlag) {
+#ifdef USE_32BIT_REF
+  ClassMetadata *cls = GetClassMeta();
+  uint16_t flag = __atomic_load_n(&cls->flag, __ATOMIC_ACQUIRE) | newFlag;
+  __atomic_store_n(&cls->flag, flag, __ATOMIC_RELEASE);
+#else
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  uint16_t flag = __atomic_load_n(&classInfoRo->flag, __ATOMIC_ACQUIRE) | newFlag;
+  __atomic_store_n(&classInfoRo->flag, flag, __ATOMIC_RELEASE);
+#endif // USE_32BIT_REF
+}
+
+inline void MClass::SetClIndex(uint16_t clIndex) {
+  ClassMetadata *cls = GetClassMeta();
+  cls->clIndex = clIndex;
+}
+
+inline void MClass::SetMonitor(int32_t monitor) {
+  this->monitor = monitor;
+}
+
+inline void MClass::ReSetFlag(uint16_t newFlag) {
+#ifdef USE_32BIT_REF
+  ClassMetadata *cls = GetClassMeta();
+  uint16_t flag = __atomic_load_n(&cls->flag, __ATOMIC_ACQUIRE) & newFlag;
+  __atomic_store_n(&cls->flag, flag, __ATOMIC_RELEASE);
+#else
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  uint16_t flag = __atomic_load_n(&classInfoRo->flag, __ATOMIC_ACQUIRE) & newFlag;
+  __atomic_store_n(&classInfoRo->flag, flag, __ATOMIC_RELEASE);
+#endif
+}
+
+inline void MClass::SetNumOfSuperClasses(uint32_t numOfSuperclasses) {
+#if USE_32BIT_REF
+  ClassMetadata *cls = GetClassMeta();
+  cls->numOfSuperclasses = static_cast<uint16_t>(numOfSuperclasses);
+#else
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  classInfoRo->numOfSuperclasses = numOfSuperclasses;
+#endif // USE_32BIT_REF
+}
+
+inline void MClass::SetHotClass() {
+  ReSetFlag(~modifier::kClassIsColdClass);
+}
+
+inline MethodMeta *MClass::GetRawMethodMetas() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  MethodMeta *methods = classInfoRo->methods.GetDataRef<MethodMeta*>();
+  return methods;
+}
+
+inline FieldMeta *MClass::GetRawFieldMetas() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  FieldMeta *fields = classInfoRo->fields.GetDataRef<FieldMeta*>();
+  return fields;
+}
+
+inline FieldMeta *MClass::GetFieldMeta(uint32_t index) const {
+  DCHECK(index < GetNumOfFields()) << "index too large." << maple::endl;
+  FieldMeta *fields = GetRawFieldMetas();
+  DCHECK(fields != nullptr) << "fields is nullptr." << maple::endl;
+  return fields + index;
+}
+
+inline bool MClass::IsAssignableFrom(MClass &cls) const {
+#ifdef USE_32BIT_REF
+  if ((&cls == this) || (cls.GetCacheTrueClass() == this)) {
+    return true;
+  } else if (cls.GetCacheFalseClass() == this) {
+    return false;
+  }
+#endif
+  bool result = IsAssignableFromImpl(cls);
+#ifdef USE_32BIT_REF
+  if (result) {
+    cls.SetCacheTrueClass(*this);
+  } else {
+    cls.SetCacheFalseClass(*this);
+  }
+#endif
+  return result;
+}
+
+ALWAYS_INLINE inline uint16_t MClass::GetMethodFieldHash(const MString *name, const MArray *signature, bool isMethod) {
+  DCHECK(name != nullptr) << "name must non null." << maple::endl;
+  uint32_t hash = 5381; // initial value for DJB hash algorithm
+  constexpr uint32_t kShift = 5;
+  // cal method name
+  if (name->IsCompress()) {
+    uint32_t nameLen = name->GetLength();
+    uint8_t *contents = name->GetContentsPtr();
+    for (uint32_t i = 0; i < nameLen; ++i) {
+      hash += (hash << kShift) + (*contents++);
+    }
+  } else {
+    std::string charMethodName = name->GetChars();
+    // Note: charMethodName is the name encoded in UTF-8 as a sequence of bytes.
+    for (char byte : charMethodName) {
+      // Iterate through the byte sequence.  Treat each byte as a uint8_t, and zero-extend it to 32 bits.  This is
+      // consistent with the algorithm used by the AoT compiler.
+      uint32_t byteU32 = static_cast<uint32_t>(static_cast<uint8_t>(byte));
+      hash += (hash << kShift) + byteU32;
+    }
+  }
+  if (isMethod) {
+    // cal signature
+    hash += (hash << kShift) + '(';
+    if (signature != nullptr) {
+      uint32_t arrayLen = signature->GetLength();
+      for (uint32_t i = 0; i < arrayLen; ++i) {
+        MClass *clsObj = static_cast<MClass*>(signature->GetObjectElementNoRc(i));
+        // we have check the args non null
+        char *className = clsObj->GetName();
+        while (*className) {
+          hash += (hash << kShift) + (*className++);
+        }
+      }
+    }
+    hash += (hash << kShift) + ')';
+  }
+  return (hash & 0x7FFFFFFF) % modifier::kMethodFieldHashSize;
+}
+
+ALWAYS_INLINE inline uint16_t MClass::GetMethodFieldHash(const char *name, const char *signature, bool isMethod) {
+  DCHECK(name != nullptr) << "name must non null." << maple::endl;
+  DCHECK(!isMethod || (signature != nullptr)) << "signature must non null." << maple::endl;
+  unsigned int hash = 5381; // initial value for DJB hash algorithm
+  constexpr uint32_t kShift = 5;
+  while (*name) {
+    hash += (hash << kShift) + (*name++);
+  }
+  if (isMethod) {
+    while (*signature) {
+      hash += (hash << kShift) + (*signature++);
+      if (*(signature - 1) == ')') {
+        break;
+      }
+    }
+  }
+  return (hash & 0x7FFFFFFF) % modifier::kMethodFieldHashSize;
+}
+
+template<typename T1, typename T2, typename T3>
+ALWAYS_INLINE inline T1 *MClass::CmpHashEqual(int32_t mid, uint32_t num, T1 *metas, T2 name,
+                                              T3 signature, uint16_t srcHash) const {
+  int32_t numOfMetas = static_cast<int32_t>(num);
+  while (++mid < numOfMetas) {
+    T1 *meta = metas + mid;
+    if (srcHash != meta->GetHashCode()) {
+      break;
+    }
+  }
+  // find left
+  while (--mid >= 0) {
+    T1 *meta = metas + mid;
+    if (srcHash == meta->GetHashCode()) {
+      if (meta->Cmp(name, signature)) {
+        return meta;
+      }
+    } else {
+      break;
+    }
+  }
+  return nullptr;
+}
+
+template<typename T1, typename T2, typename T3>
+ALWAYS_INLINE inline T1 *MClass::GetDeclareMethodFieldUtil(T1 *metas, uint32_t num, T2 name,
+                                                           T3 signature, bool isMethod) const {
+  uint16_t srcHash = GetMethodFieldHash(name, signature, isMethod);
+  int32_t low = 0;
+  int32_t high = static_cast<int32_t>(num) - 1;
+  int32_t mid = 0;
+  while (low <= high) {
+    mid = static_cast<int32_t>(static_cast<uint32_t>(low + high) >> 1);
+    T1 *meta = metas + mid;
+    uint16_t dstHash = meta->GetHashCode();
+    if (dstHash == srcHash) {
+      if (meta->Cmp(name, signature) && !isMethod) {
+        return meta;
+      }
+      T1 *result = CmpHashEqual(mid, num, metas, name, signature, srcHash);
+      if (result != nullptr) {
+        return result;
+      }
+      break;
+    }
+    if (dstHash < srcHash) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+
+  // the following code just for compatibility, this may impact performance when field not found
+  // now, kMajorMplVersion is same in maple 2.1 && 2.2. we will optimise these code when version changed
+  for (int i = static_cast<int32_t>(num) - 1; i >= 0 ; --i) {
+    T1 *meta = metas + i;
+    if (modifier::kHashConflict == meta->GetHashCode()) {
+      if (meta->Cmp(name, signature)) {
+        return meta;
+      }
+    } else {
+      break;
+    }
+  }
+  return nullptr;
+}
+
+template<typename T1, typename T2>
+ALWAYS_INLINE inline MethodMeta *MClass::GetDeclaredMethodUtil(T1 methodName, T2 methodSignature) const {
+  MethodMeta *methods = GetMethodMetas();
+  uint32_t num = GetNumOfMethods();
+  return GetDeclareMethodFieldUtil(methods, num, methodName, methodSignature, true);
+}
+
+ALWAYS_INLINE inline MethodMeta *MClass::GetDeclaredMethod(const char *methodName, const char *signatureName) const {
+  if ((methodName == nullptr) || (signatureName == nullptr)) {
+    return nullptr;
+  }
+  return GetDeclaredMethodUtil(methodName, signatureName);
+}
+
+ALWAYS_INLINE inline MethodMeta *MClass::GetDeclaredMethod(const MString *methodName,
+                                                           const MArray *signatureClass) const {
+  if ((methodName == nullptr) || ((signatureClass != nullptr) && signatureClass->HasNullElement())) {
+    return nullptr;
+  }
+  MethodMeta *methodMeta = GetDeclaredMethodUtil(methodName, signatureClass);
+  return (methodMeta != nullptr) ? (methodMeta->IsConstructor() ? nullptr : methodMeta) : nullptr;
+}
+
+ALWAYS_INLINE inline MethodMeta *MClass::GetDefaultConstructor() const {
+  MethodMeta *methods = GetMethodMetas();
+  uint32_t num = GetNumOfMethods();
+  for (uint32_t i = 0; i < num; ++i) {
+    MethodMeta *methodMeta = &methods[i];
+    // defaultConstructor has 1 arg
+    if (methodMeta->IsConstructor() && methodMeta->GetArgSize() == 1) {
+      return methodMeta;
+    }
+  }
+  return nullptr;
+}
+
+ALWAYS_INLINE inline MethodMeta *MClass::GetVirtualMethod(const MethodMeta &srcMethod) const {
+  MClass *declarClass = srcMethod.GetDeclaringClass();
+  if ((declarClass == this) || srcMethod.IsDirectMethod()) {
+    return const_cast<MethodMeta*>(&srcMethod);
+  }
+  return GetMethodForVirtual(srcMethod);
+}
+
+template<typename T1, typename T2>
+ALWAYS_INLINE inline FieldMeta *MClass::GetDeclaredFieldUtil(T1 fieldName, T2 fieldType) const {
+  uint32_t num = GetNumOfFields();
+  FieldMeta *fields = GetFieldMetas();
+  return GetDeclareMethodFieldUtil(fields, num, fieldName, fieldType, false);
+}
+
+ALWAYS_INLINE inline FieldMeta *MClass::GetDeclaredField(const char *name, const char *type) const {
+  return GetDeclaredFieldUtil(name, type);
+}
+
+ALWAYS_INLINE inline FieldMeta *MClass::GetDeclaredField(const MString *name) const {
+  return GetDeclaredFieldUtil(name, nullptr);
+}
+
+template<typename T1, typename T2>
+ALWAYS_INLINE inline FieldMeta *MClass::GetFieldUtil(T1 fieldName, T2 fieldType, bool isPublic) const {
+  FieldMeta *result = nullptr;
+  const MClass *superClass = this;
+  while (superClass != nullptr) {
+    result = superClass->GetDeclaredFieldUtil(fieldName, fieldType);
+    if ((result != nullptr) && (!isPublic || result->IsPublic())) {
+      return result;
+    }
+    uint32_t numOfInterface = superClass->GetNumOfInterface();
+    MClass *interfaceVector[numOfInterface];
+    superClass->GetDirectInterfaces(interfaceVector, numOfInterface);
+    for (uint32_t i = 0; i < numOfInterface; ++i) {
+      auto interface = interfaceVector[i];
+      result = interface->GetFieldUtil(fieldName, fieldType, isPublic);
+      if ((result != nullptr) && (!isPublic || result->IsPublic())) {
+        return result;
+      }
+    }
+    if (superClass->IsInterface()) {
+      break;
+    }
+    superClass = superClass->GetSuperClass();
+  }
+  return nullptr;
+}
+
+ALWAYS_INLINE inline FieldMeta *MClass::GetField(const char *fieldName, const char *fieldType, bool isPublic) const {
+  return GetFieldUtil(fieldName, fieldType, isPublic);
+}
+
+ALWAYS_INLINE inline FieldMeta *MClass::GetField(const MString *fieldName, bool isPublic) const {
+  return GetFieldUtil(fieldName, nullptr, isPublic);
+}
+
+template<typename T>
+ALWAYS_INLINE inline MethodMeta *MClass::GetDeclaredConstructorUtil(T signature) const {
+  MethodMeta *methods = GetMethodMetas();
+  uint32_t num = GetNumOfMethods();
+  for (uint32_t i = 0; i < num; ++i) {
+    MethodMeta *methodMeta = &methods[i];
+    if (methodMeta->IsConstructor() && !methodMeta->IsStatic() && methodMeta->SignatureCmp(signature)) {
+      return methodMeta;
+    }
+  }
+  return nullptr;
+}
+
+inline MethodMeta *MClass::GetDeclaredConstructor(const char *signature) const {
+  return GetDeclaredConstructorUtil(signature);
+}
+
+inline MethodMeta *MClass::GetDeclaredConstructor(const MArray *signature) const {
+  return GetDeclaredConstructorUtil(signature);
+}
+
+inline ClassInitState MClass::GetInitState() const {
+  ClassMetadata *cls = GetClassMeta();
+  uintptr_t val = cls->GetInitStateRawValue();
+  uintptr_t state = 0;
+  // previously ClassInitState::kClassInitStateUninitialized is defined as 0.
+  if (val == reinterpret_cast<uintptr_t>(&classInitProtectRegion[kClassUninitialized - 1])) {
+    return kClassUninitialized;
+  } else if (kSEGVAddrForClassInitStateMin < val && val < kSEGVAddrFoClassInitStateMax) {
+    state = val - static_cast<intptr_t>(kSEGVAddrForClassInitStateMin);
+  } else {
+    return kClassInitialized;
+  }
+
+  if (kClassInitStateMin < state && state < kClassInitStateMax) {
+    return static_cast<ClassInitState>(state);
+  } else if (kClassInitStateMax <= state) {
+    return kClassInitialized;
+  }
+  BUILTIN_UNREACHABLE();
+}
+
+inline void MClass::SetInitState(ClassInitState state) {
+  if (kClassInitStateMin < state && state < kClassInitStateMax) {
+    uintptr_t stateVal = kSEGVAddrForClassInitStateMin + state;
+    ClassMetadata *cls = GetClassMeta();
+    cls->SetInitStateRawValue(stateVal);
+    return;
+  }
+  BUILTIN_UNREACHABLE();
+}
+
+inline bool MClass::IsInitialized() const {
+  return GetInitState() == kClassInitialized;
+}
+
+inline bool MClass::InitClassIfNeeded() const {
+  return IsInitialized() ? true : MRT_InitClassIfNeeded(*this);
+}
+
+inline uint32_t MClass::GetDimension() const {
+  return GetDimensionFromDescriptor(GetName());
+}
+
+inline uint32_t MClass::GetDimensionFromDescriptor(const std::string &descriptor) {
+  uint32_t dim = 0;
+  while (descriptor[dim] == '[') {
+    dim++;
+  }
+  return dim;
+}
+
+inline MClass *MClass::GetPrimitiveClass(const char *descriptor) {
+  DCHECK(descriptor != nullptr);
+  switch (*descriptor) {
+    case 'Z':
+      return WellKnown::GetMClassZ();
+    case 'B':
+      return WellKnown::GetMClassB();
+    case 'C':
+      return WellKnown::GetMClassC();
+    case 'S':
+      return WellKnown::GetMClassS();
+    case 'I':
+      return WellKnown::GetMClassI();
+    case 'J':
+      return WellKnown::GetMClassJ();
+    case 'F':
+      return WellKnown::GetMClassF();
+    case 'D':
+      return WellKnown::GetMClassD();
+    case 'V':
+      return WellKnown::GetMClassV();
+    default:
+      return nullptr;
+    }
+}
+
+inline MClass *MClass::GetClassFromDescriptor(const MObject *context, const char *descriptor, bool throwException) {
+  // first check primitive class
+  MClass *cls = GetPrimitiveClass(descriptor);
+  return (cls != nullptr) ? cls : GetClassFromDescriptorUtil(context, descriptor, throwException);
+}
+
+template<typename T>
+inline MClass *MClass::JniCast(T c) {
+  static_assert(std::is_same<T, jobject>::value || std::is_same<T, jclass>::value, "wrong type");
+  return reinterpret_cast<MClass*>(c);
+}
+
+template<typename T>
+inline MClass *MClass::JniCastNonNull(T c) {
+  DCHECK(c != nullptr);
+  return JniCast(c);
+}
+
+inline jclass MClass::AsJclass() const {
+  return reinterpret_cast<jclass>(const_cast<MClass*>(this));
+}
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MCLASS_INLINE_H_
+
diff --git a/src/mrt/maplert/include/methodmeta.h b/src/mrt/maplert/include/methodmeta.h
new file mode 100644
index 0000000000000000000000000000000000000000..0928f346cf4a30b05da9e3fcc1b854aaf7b78771
--- /dev/null
+++ b/src/mrt/maplert/include/methodmeta.h
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_METHODMETA_H_
+#define MRT_MAPLERT_INCLUDE_METHODMETA_H_
+#include "mobject.h"
+#include "base/macros.h"
+#include "marray.h"
+#include "mstring.h"
+#include "argvalue.h"
+
+namespace maplert {
+static constexpr uint32_t kMethodHashMask = 0x3FF;
+static constexpr uint32_t kMethodFlagBits = 6;
+static constexpr uint32_t kMethodFlagVtabIndexBits = 16;
+
+static constexpr uint32_t kDexMethodTag = 0x1;
+static constexpr uint32_t kMethodMetaHashMask = 0x3FF;
+static constexpr uint32_t kMethodMetaHashBitIdx = 6;
+static constexpr uint32_t kMethodMetaAddrIspAddress = 0x02;
+
+// MethodMetaBase： It contain compactMetaFlag to indicate
+//                  the struct is compacted or not
+// MethodMeta： normal method Meta struct
+// MethodMetaCompact: method Meta is compacted by leb128
+class MethodAddress {
+ public:
+  uintptr_t GetAddr() const;
+  void SetAddr(uintptr_t address);
+  int32_t GetDefTabIndex() const;
+
+ private:
+  union {
+    DataRefOffset addr;        // func address.
+    DataRefOffset defTabIndex; // def tab index, before lazy binding resolve for method.
+  };
+};
+
+class MethodSignature {
+ public:
+  char *GetSignature() const;
+  void SetSignature(const char *signature);
+  MetaRef *GetTypes() const;
+
+ private:
+  DataRefOffset32 signatureName;
+  // ponit to a types array, only enable Cache ParametarType(methodMeta flag kMethodParametarType is set).
+  // otherwise can't use this field.
+  DataRefOffset32 pTypes;
+};
+
+class MethodMetaBase {
+ public:
+  char *GetName() const;
+  void GetSignature(std::string &signature) const;
+  bool IsMethodMetaCompact() const;
+  MClass *GetDeclaringClass() const;
+  uint16_t GetFlag() const;
+  uint32_t GetMod() const;
+  int16_t GetVtabIndex() const;
+  uintptr_t GetFuncAddress() const;
+
+ private:
+  struct {
+    int16_t vtabIndex;
+    uint16_t compactMetaFlag;
+  };
+};
+
+class MethodMeta {
+ public:
+  uint32_t GetMod() const;
+  char *GetName() const;
+  char *GetSignature() const;
+  void GetShortySignature(char shorty[], const uint32_t size) const;
+  static void GetShortySignature(const char srcSignature[], char shorty[], const uint32_t size);
+  static void GetShortySignatureUtil(const char srcSignature[], char shorty[], const uint32_t size);
+  uintptr_t GetFuncAddress() const;
+  std::string GetAnnotation() const;
+  char *GetAnnotationRaw() const;
+  MClass *GetDeclaringClass() const;
+  MRT_EXPORT void GetJavaMethodFullName(std::string &name) const;
+  MRT_EXPORT void GetJavaClassName(std::string &name) const;
+  MRT_EXPORT void GetJavaMethodName(std::string &name) const;
+  uint16_t GetArgSize() const;
+  int16_t GetVtabIndex() const;
+  uint16_t GetHashCode() const;
+  void SetHashCode(uint16_t hash);
+  uint16_t GetFlag() const;
+  bool IsStatic() const;
+  bool IsAbstract() const;
+  bool IsPublic() const;
+  bool IsPrivate() const;
+  bool IsDirectMethod() const;
+  bool IsFinalizeMethod() const;
+  bool IsFinalMethod() const;
+  bool IsConstructor() const;
+  bool IsDefault() const;
+  bool IsProtected() const;
+  bool IsNative() const;
+  bool IsSynchronized() const;
+  bool IsCriticalNative() const;
+  bool IsMethodAccessible(const MClass &curClass) const;
+  bool IsOverrideMethod(const MethodMeta &srcMethod) const;
+  bool IspAddress() const;
+  bool IsEnableParametarType() const;
+  int32_t GetDefTabIndex() const;
+  MethodAddress *GetpMethodAddress() const;
+  MClass *GetReturnType() const;
+  char *GetReturnTypeName() const;
+  char GetReturnPrimitiveType() const;
+  void GetParameterTypes(std::vector<MClass*> &parameterTypes) const;
+  bool GetParameterTypes(MClass *parameterTypes[], uint32_t size) const;
+  bool GetParameterTypesUtil(MClass *parameterTypes[], uint32_t size) const;
+  MArray *GetParameterTypes() const;
+  MethodSignature *GetMethodSignature() const;
+  void GetParameterTypesDescriptor(std::vector<std::string> &descriptors) const;
+  void GetExceptionTypes(std::vector<MClass*> &types) const;
+  MArray *GetExceptionTypes() const;
+  void GetPrettyName(bool needSignature, std::string &dstName) const;
+  uint32_t GetParameterCount() const;
+  MObject *GetSignatureAnnotation() const;
+  bool Cmp(const char *mthName, const char *srcSigName) const;
+  bool Cmp(const MString *mthName, const MArray *srcSigName) const;
+  bool NameCmp(const MString *mthName) const;
+  bool NameCmp(const char *name) const;
+  bool SignatureCmp(const MArray *sigArray) const;
+  bool SignatureCmp(const char *srcSigName) const;
+  void FillMethodMeta(bool copySignature, const char *name, const MethodSignature *mthSignature, const char *annotation,
+                      int32_t inVtabIndex, const MClass &methodDclClass, const uintptr_t funcAddr, uint32_t modifier,
+                      uint16_t methodFlag, uint16_t argSize);
+  template<calljavastubconst::ArgsType argsType>
+  static inline void BuildArgstoJvalues(char type, BaseArgValue &values, uintptr_t args);
+  template<calljavastubconst::ArgsType argsType>
+  inline void BuildJavaMethodArgJvalues(MObject *obj, BaseArgValue &values) const;
+
+  void BuildJValuesArgsFromVaList(jvalue argsJvalue[], va_list valistArgs) const;
+  void BuildMArrayArgsFromJValues(MArray &targetValue, jvalue argsJvalue[]) const;
+  static void BuildJValuesArgsFromStackMemery(DecodeStackArgs &args, std::string &shorty);
+  void BuildJValuesArgsFromStackMemeryPrefixSigNature(DecodeStackArgs &args, std::string prefix);
+  // invoke compiled code interface
+  template<typename T, calljavastubconst::ArgsType argsType>
+  T InvokeJavaMethod(MObject *obj, const uintptr_t methodAargs, uintptr_t calleeFuncAddr = 0) const;
+  template<typename T> T InvokeJavaMethodFast(MObject *obj) const; // method without parameter
+
+  template<typename RetType, calljavastubconst::ArgsType argsType, typename T>
+  RetType Invoke(MObject *obj, T methodAargs = 0, uintptr_t calleeFuncAddr = 0) const;
+
+  bool NeedsInterp() const;
+
+  // set interfaces
+  void SetMod(const uint32_t mod);
+  void SetName(const char *name);
+  void SetSignature(const char *signature);
+  void SetMethodSignature(const MethodSignature *methodSignature);
+  void SetAddress(const uintptr_t addr);
+  void SetAnnotation(const char *annotation);
+  void SetDeclaringClass(const MClass &declaringClass);
+  void SetFlag(const uint16_t flag);
+  void AddFlag(const uint16_t flag);
+  void SetArgsSize(const uint16_t argSize);
+  void SetVtabIndex(const int32_t methodVtabIndex);
+
+  MethodSignature *CreateMethodSignatureByName(const char *signature);
+#ifndef USE_32BIT_REF
+  uint32_t GetPadding() {
+    return padding;
+  }
+#endif
+  static constexpr size_t GetModOffset() {
+    return offsetof(MethodMeta, mod);
+  }
+  static constexpr size_t GetDeclaringClassOffset() {
+    return offsetof(MethodMeta, declaringClass);
+  }
+  static constexpr size_t GetAddrOffset() {
+    return offsetof(MethodMeta, addr);
+  }
+  static constexpr size_t GetArgSizeOffset() {
+    return offsetof(MethodMeta, argumentSize);
+  }
+
+  template<typename T>
+  static inline MethodMeta *JniCast(T methodMeta);
+  template<typename T>
+  static inline MethodMeta *JniCastNonNull(T methodMeta);
+  template<typename T>
+  static inline MethodMeta *Cast(T methodMeta);
+  template<typename T>
+  static inline MethodMeta *CastNonNull(T methodMeta);
+  inline jmethodID AsJmethodID();
+
+ private:
+  struct {
+    int16_t vtabIndex;
+    uint16_t compactMetaFlag;
+  };
+  DataRefOffset declaringClass;
+  union {
+    DataRefOffset pAddr;
+    DataRefOffset addr;
+  };
+  uint32_t mod;
+  DataRefOffset32 methodName;
+  // only method flag kMethodParametarType is set, we will use pMethodSignature,
+  // and compiler will generate MethodSignature struct with pTypes which save types cache,
+  // otherwise just use signatureOffset.
+  union {
+    DataRefOffset32 signatureOffset;
+    DataRefOffset32 pMethodSignature;
+  };
+  DataRefOffset32 annotationValue;
+  uint16_t flag;
+  uint16_t argumentSize;
+#ifndef USE_32BIT_REF
+  uint32_t padding;
+#endif
+};
+
+class MethodMetaCompact {
+ public:
+  int16_t GetVtabIndex() const;
+  uint16_t GetFlag() const;
+  uint32_t GetMod() const;
+  uintptr_t GetFuncAddress() const;
+  const uint8_t *GetpCompact() const;
+  bool IsAbstract() const;
+  char *GetName() const;
+  void GetSignature(std::string &signature) const;
+  MClass *GetDeclaringClass() const;
+  int32_t GetDefTabIndex() const;
+  MethodAddress *GetpMethodAddress() const;
+  void SetFuncAddress(uintptr_t address);
+  uint8_t *DecodeCompactMethodMeta(const MClass &cls, uintptr_t &funcAddress, uint32_t &modifier,
+                                   std::string &methodName, std::string &signatureName,
+                                   std::string &annotationValue, int32_t &methodInVtabIndex,
+                                   uint16_t &flags, uint16_t &argsSize) const;
+  static MethodMeta *DecodeCompactMethodMetas(MClass &cls);
+  static uintptr_t GetCompactFuncAddr(const MClass &cls, uint32_t index);
+  static MethodMetaCompact *GetMethodMetaCompact(const MClass &cls, uint32_t index);
+
+ private:
+  static std::mutex resolveMutex;
+  struct {
+    int16_t vtabIndex;
+    uint16_t compactMetaFlag;
+  };
+  uint8_t leb128Start;
+  // data layout in compact methodmeta
+  // ===========================================
+  // |  union {int32_t pAddr; int32_t addr;}   |
+  // |  int32_t declaringClass                 |
+  // |  int32_t modifier                       |
+  // |  int32_t methodname                     |
+  // |  int32_t arg size                       |
+  // |  int32_t methodsignature                |
+  // |  int32_t annotation                     |
+  // ===========================================
+};
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_METHODMETA_H_
diff --git a/src/mrt/maplert/include/methodmeta_inline.h b/src/mrt/maplert/include/methodmeta_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..b62e58dcee4affdd23c51405246ae44b319791fd
--- /dev/null
+++ b/src/mrt/maplert/include/methodmeta_inline.h
@@ -0,0 +1,447 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_METHODMETA_INLINE_H_
+#define MRT_MAPLERT_INCLUDE_METHODMETA_INLINE_H_
+#include "methodmeta.h"
+#include "marray_inline.h"
+#include "mrt_primitive_util.h"
+#include "mrt_annotation.h"
+#include "mrt_util.h"
+#include "interp_support.h"
+#include "modifier.h"
+#include "mstring_inline.h"
+namespace maplert {
+inline int32_t MethodAddress::GetDefTabIndex() const {
+  return static_cast<int32_t>(defTabIndex.GetRawValue());
+}
+
+inline uintptr_t MethodAddress::GetAddr() const {
+  return addr.GetDataRef<uintptr_t>();
+}
+
+inline void MethodAddress::SetAddr(uintptr_t address) {
+  addr.SetDataRef(address);
+}
+
+inline char *MethodSignature::GetSignature() const {
+  char *signature = signatureName.GetDataRef<char*>();
+  __MRT_Profile_CString(signature);
+  return signature;
+}
+
+inline void MethodSignature::SetSignature(const char *signature) {
+  signatureName.SetDataRef(signature);
+}
+
+inline MetaRef *MethodSignature::GetTypes() const {
+  return pTypes.GetDataRef<MetaRef*>();
+}
+
+inline char *MethodMeta::GetName() const {
+  char *name = methodName.GetDataRef<char*>();
+  __MRT_Profile_CString(name);
+  return name;
+}
+
+inline char *MethodMeta::GetSignature() const {
+  return GetMethodSignature()->GetSignature();
+}
+
+inline uint32_t MethodMeta::GetMod() const {
+  return mod;
+}
+
+inline std::string MethodMeta::GetAnnotation() const {
+  return AnnotationUtil::GetAnnotationUtil(GetAnnotationRaw());
+}
+
+inline char *MethodMeta::GetAnnotationRaw() const {
+  char *annotationRaw = annotationValue.GetDataRef<char*>();
+  __MRT_Profile_CString(annotationRaw);
+  return annotationRaw;
+}
+
+// This function is inlined in Fterp. If modified, change Fterp accordingly.
+inline uintptr_t MethodMeta::GetFuncAddress() const {
+  MethodAddress *pMethodAddress = GetpMethodAddress();
+  return pMethodAddress->GetAddr();
+}
+
+inline uint16_t MethodMeta::GetFlag() const {
+  return flag;
+}
+
+inline uint16_t MethodMeta::GetArgSize() const {
+  return argumentSize;
+}
+
+inline int16_t MethodMeta::GetVtabIndex() const {
+  return vtabIndex;
+}
+
+inline bool MethodMeta::IsStatic() const {
+  return modifier::IsStatic(GetMod());
+}
+
+inline bool MethodMeta::IsAbstract() const {
+  return modifier::IsAbstract(GetMod());
+}
+
+inline bool MethodMeta::IsPublic() const {
+  return modifier::IsPublic(GetMod());
+}
+
+inline bool MethodMeta::IsPrivate() const {
+  return modifier::IsPrivate(GetMod());
+}
+inline bool MethodMeta::IsDirectMethod() const {
+  return modifier::IsDirectMethod(GetMod());
+}
+
+inline bool MethodMeta::IsConstructor() const {
+  return modifier::IsConstructor(GetMod());
+}
+
+inline bool MethodMeta::IsDefault() const {
+  return modifier::IsDefault(GetMod());
+}
+
+inline bool MethodMeta::IsProtected() const {
+  return modifier::IsProtected(GetMod());
+}
+
+inline bool MethodMeta::IsFinalizeMethod() const {
+  return modifier::IsFinalizeMethod(GetFlag());
+}
+
+inline bool MethodMeta::IsFinalMethod() const {
+  return modifier::IsFinal(GetMod());
+}
+
+inline bool MethodMeta::IsNative() const {
+  return modifier::IsNative(GetMod());
+}
+
+inline bool MethodMeta::IsCriticalNative() const {
+  return false;
+}
+
+inline bool MethodMeta::IspAddress() const {
+  return static_cast<bool>(pAddr.GetRawValue() & kMethodMetaAddrIspAddress);
+}
+
+inline bool MethodMeta::IsEnableParametarType() const {
+  return (GetFlag() & modifier::kMethodParametarType) == modifier::kMethodParametarType;
+}
+
+inline bool MethodMeta::IsSynchronized() const {
+  return modifier::IsSynchronized(GetMod());
+}
+
+inline int32_t MethodMeta::GetDefTabIndex() const {
+  if (!IspAddress()) {
+    return -1;
+  }
+  MethodAddress *pMethodAddress = GetpMethodAddress();
+  return pMethodAddress->GetDefTabIndex();
+}
+
+inline MClass *MethodMeta::GetDeclaringClass() const {
+  return declaringClass.GetDataRef<MClass*>();
+}
+
+inline uint32_t MethodMeta::GetParameterCount() const {
+  uint32_t argSize = GetArgSize();
+  return IsStatic() ? argSize : argSize - 1;
+}
+
+inline char *MethodMeta::GetReturnTypeName() const {
+  char *methodSig = GetSignature();
+  char *rtTypeName = methodSig;
+  while (*(rtTypeName++) != ')') { }
+  return rtTypeName;
+}
+
+inline char MethodMeta::GetReturnPrimitiveType() const {
+  char *typeName = GetReturnTypeName();
+  DCHECK(typeName != nullptr) << "MethodMeta::GetReturnPrimitiveType: typeName is nullptr!" << maple::endl;
+  return typeName[0];
+}
+
+inline void MethodMeta::AddFlag(const uint16_t methodFlag) {
+  flag |= methodFlag;
+}
+
+// This function is inlined in Fterp. If modified, change Fterp accordingly.
+inline MethodAddress *MethodMeta::GetpMethodAddress() const {
+  if (IspAddress()) {
+    uintptr_t value = pAddr.GetDataRef<uintptr_t>();
+    // compile will +2 as flag, here need -2 to remove it
+    return reinterpret_cast<MethodAddress*>(value - 2);
+  } else {
+    uintptr_t value = reinterpret_cast<uintptr_t>(&pAddr);
+    return reinterpret_cast<MethodAddress*>(value);
+  }
+}
+
+inline MethodSignature *MethodMeta::GetMethodSignature() const {
+  if (IsEnableParametarType()) {
+    return pMethodSignature.GetDataRef<MethodSignature*>();
+  } else {
+    uintptr_t value = reinterpret_cast<uintptr_t>(&signatureOffset);
+    return reinterpret_cast<MethodSignature*>(value);
+  }
+}
+
+inline uint16_t MethodMeta::GetHashCode() const {
+  return (flag >> kMethodFlagBits) & kMethodHashMask;
+}
+
+inline void MethodMeta::SetHashCode(uint16_t hash) {
+  flag &= ~(kMethodHashMask << kMethodFlagBits);
+  flag |= (hash & kMethodHashMask) << kMethodFlagBits;
+}
+
+ALWAYS_INLINE inline bool MethodMeta::NameCmp(const MString *name) const {
+  if (UNLIKELY(name == nullptr)) {
+    return false;
+  }
+  return name->Cmp(std::string(GetName()));
+}
+
+ALWAYS_INLINE inline bool MethodMeta::NameCmp(const char *name) const {
+  if (UNLIKELY(name == nullptr)) {
+    return false;
+  }
+  return !strcmp(name, GetName());
+}
+
+ALWAYS_INLINE inline bool MethodMeta::SignatureCmp(const MArray *signature) const {
+  // signature always like (Ljava/lang/String;I), we can skip first char '('.
+  char *desSigName = GetSignature() + 1;
+  uint32_t arrayLen = signature == nullptr ? 0 : signature->GetLength();
+  uint32_t index = 0;
+  for (uint32_t i = 0; i < arrayLen; ++i) {
+    MClass *clsObj = static_cast<MClass*>(signature->GetObjectElementNoRc(i));
+    if (UNLIKELY(clsObj == nullptr)) {
+      return false;
+    }
+    char *className = clsObj->GetName();
+    for (uint32_t clsNameIndex = 0; className[clsNameIndex] != '\0' && desSigName[clsNameIndex] != '\0';
+        ++clsNameIndex, ++index) {
+      if (className[clsNameIndex] != desSigName[index]) {
+        return false;
+      }
+    }
+  }
+  return desSigName[index] == ')' ? true : false;
+}
+
+ALWAYS_INLINE inline bool MethodMeta::SignatureCmp(const char *signature) const {
+  if (UNLIKELY(signature == nullptr)) {
+    return false;
+  }
+  return !strcmp(signature, GetSignature());
+}
+
+ALWAYS_INLINE inline bool MethodMeta::Cmp(const MString *mthName, const MArray *sigArray) const {
+  return NameCmp(mthName) && SignatureCmp(sigArray);
+}
+
+ALWAYS_INLINE inline bool MethodMeta::Cmp(const char *name, const char *signature) const {
+  return NameCmp(name) && SignatureCmp(signature);
+}
+
+template<calljavastubconst::ArgsType argsType>
+ALWAYS_INLINE inline void MethodMeta::BuildArgstoJvalues(char type, BaseArgValue &values, uintptr_t args) {
+  bool isVaArg = (argsType == calljavastubconst::kVaArg);
+  switch (type) {
+    case 'B':
+      values.AddInt32(isVaArg ? va_arg(*reinterpret_cast<va_list*>(args), int32_t)
+                              : (*reinterpret_cast<jvalue*>(args)).b);
+      break;
+    case 'C':
+      values.AddInt32(isVaArg ? va_arg(*reinterpret_cast<va_list*>(args), int32_t)
+                              : static_cast<int32_t>(static_cast<uint32_t>((*reinterpret_cast<jvalue*>(args)).c)));
+      break;
+    case 'I':
+      values.AddInt32(isVaArg ? va_arg(*reinterpret_cast<va_list*>(args), int32_t)
+                              : (*reinterpret_cast<jvalue*>(args)).i);
+      break;
+    case 'J':
+      values.AddInt64(isVaArg ? va_arg(*reinterpret_cast<va_list*>(args), int64_t)
+                              : (*reinterpret_cast<jvalue*>(args)).j);
+      break;
+    case 'S':
+      values.AddInt32(isVaArg ? va_arg(*reinterpret_cast<va_list*>(args), int32_t)
+                              : (*reinterpret_cast<jvalue*>(args)).s);
+      break;
+    case 'Z':
+      values.AddInt32(isVaArg ? va_arg(*reinterpret_cast<va_list*>(args), int32_t)
+                              : static_cast<int32_t>(static_cast<uint32_t>((*reinterpret_cast<jvalue*>(args)).z)));
+      break;
+    case 'D':
+      values.AddDouble(isVaArg ? va_arg(*reinterpret_cast<va_list*>(args), double)
+                               : (*reinterpret_cast<jvalue*>(args)).d);
+      break;
+    case 'F':
+      values.AddFloat(isVaArg ? va_arg(*reinterpret_cast<va_list*>(args), double)
+                              : (*reinterpret_cast<jvalue*>(args)).f);
+      break;
+    case 'L':
+    case '[':
+      values.AddReference(reinterpret_cast<MObject*>(isVaArg ? va_arg(*reinterpret_cast<va_list*>(args), jobject)
+                                                             : (*reinterpret_cast<jvalue*>(args)).l));
+      break;
+    default:;
+  }
+}
+
+template<calljavastubconst::ArgsType argsType>
+ALWAYS_INLINE inline void MethodMeta::BuildJavaMethodArgJvalues(MObject *obj, BaseArgValue &values) const {
+  uint32_t parameterCount = GetParameterCount();
+  char retTypeNames[parameterCount];
+  GetShortySignature(retTypeNames, parameterCount);
+  if (!IsStatic()) {
+    values.AddReference(obj);
+  }
+  if (values.GetMethodArgs() == 0) {
+    return;
+  }
+  uintptr_t arg = values.GetMethodArgs();
+  for (uint32_t i = 0; i < parameterCount; ++i) {
+    char c = retTypeNames[i];
+    if (argsType == calljavastubconst::kJvalue) {
+      arg = reinterpret_cast<uintptr_t>((reinterpret_cast<jvalue*>(values.GetMethodArgs())) + i);
+    }
+
+    BuildArgstoJvalues<argsType>(c, values, arg);
+  }
+}
+
+template<typename T, calljavastubconst::ArgsType argsType>
+ALWAYS_INLINE inline T MethodMeta::InvokeJavaMethod(MObject *obj, const uintptr_t methodAargs,
+                                                    uintptr_t calleeFuncAddr) const {
+  ArgValue argValues(methodAargs);
+  BuildJavaMethodArgJvalues<argsType>(obj, argValues);
+
+  uintptr_t funcPtr = (calleeFuncAddr == 0) ? GetFuncAddress() : calleeFuncAddr;
+  T result = RuntimeStub<T>::SlowCallCompiledMethod(funcPtr, argValues.GetData(),
+                                                    argValues.GetStackSize(), argValues.GetFRegSize());
+  return result;
+}
+
+template<typename T>
+inline T MethodMeta::InvokeJavaMethodFast(MObject *obj) const {
+  if (NeedsInterp()) {
+    return interpreter::InterpJavaMethod<T, calljavastubconst::kJvalue>(const_cast<MethodMeta*>(this), obj, 0);
+  } else {
+    jvalue argJvalues[1];
+    argJvalues[0].l = reinterpret_cast<jobject>(obj);
+    uintptr_t funcPtr = GetFuncAddress();
+    return RuntimeStub<T>::SlowCallCompiledMethod(funcPtr, argJvalues, 0, 0);
+  }
+}
+
+template<typename RetType, calljavastubconst::ArgsType argsType, typename T>
+inline RetType MethodMeta::Invoke(MObject *obj, const T methodAargs, uintptr_t calleeFuncAddr) const {
+  static_assert(std::is_same<T, jvalue*>::value || std::is_same<T, const jvalue*>::value ||
+      std::is_same<T, va_list*>::value, "wrong type");
+  RetType result = NeedsInterp() ? interpreter::InterpJavaMethod<RetType, argsType>(const_cast<MethodMeta*>(this),
+      obj, reinterpret_cast<const uintptr_t>(methodAargs)) :
+      InvokeJavaMethod<RetType, argsType>(obj, reinterpret_cast<const uintptr_t>(methodAargs), calleeFuncAddr);
+  return result;
+}
+
+inline void MethodMeta::GetShortySignature(char shorty[], const uint32_t size) const {
+  GetShortySignature(GetSignature(), shorty, size);
+}
+
+inline void MethodMeta::GetShortySignature(const char srcSignature[], char shorty[], const uint32_t size) {
+  if (size == 0) { // ()V
+  } else if (size == 1) {
+    // if size == 1, just need first signature char.
+    shorty[0] = srcSignature[size]; // (I)V -> I
+  } else {
+    GetShortySignatureUtil(srcSignature, shorty, size);
+  }
+}
+
+inline bool MethodMeta::GetParameterTypes(MClass *parameterTypes[], uint32_t size) const {
+  if (size == 0) {
+    return true;
+  } else if (size == 1) {
+    // first check Primitive Class
+    MClass *c = MClass::GetPrimitiveClass(GetSignature() + 1); // (I)V
+    if (c != nullptr) {
+      parameterTypes[0] = c;
+      return true;
+    }
+  }
+  bool isEnableParametarType = IsEnableParametarType();
+  if (isEnableParametarType) {
+    MetaRef *pTypes = GetMethodSignature()->GetTypes();
+    uint32_t index = 0;
+    for (; index < size; ++index) {
+      if (pTypes[index] != 0) {
+        parameterTypes[index] = reinterpret_cast<MClass*>(pTypes[index]);
+      } else {
+        break;
+      }
+    }
+    if (index == size) {
+      return true;
+    }
+  }
+  bool isSuccess = GetParameterTypesUtil(parameterTypes, size);
+  if (isSuccess && isEnableParametarType) {
+    MetaRef *pTypes = GetMethodSignature()->GetTypes();
+    for (uint32_t i = 0; i < size; ++i) {
+      pTypes[i] = static_cast<MetaRef>(parameterTypes[i]->AsUintptr());
+    }
+  }
+  return isSuccess;
+}
+
+template<typename T>
+inline MethodMeta *MethodMeta::JniCast(T methodMeta) {
+  static_assert(std::is_same<T, jmethodID>::value || std::is_same<T, jobject>::value, "wrong type");
+  return reinterpret_cast<MethodMeta*>(methodMeta);
+}
+
+template<typename T>
+inline MethodMeta *MethodMeta::JniCastNonNull(T methodMeta) {
+  DCHECK(methodMeta != 0);
+  return JniCast(methodMeta);
+}
+
+template<typename T>
+inline MethodMeta *MethodMeta::Cast(T methodMeta) {
+  static_assert(std::is_same<T, void*>::value || std::is_same<T, address_t>::value ||
+      std::is_same<T, uint64_t>::value, "wrong type");
+  return reinterpret_cast<MethodMeta*>(methodMeta);
+}
+
+template<typename T>
+inline MethodMeta *MethodMeta::CastNonNull(T methodMeta) {
+  DCHECK(methodMeta != 0);
+  return Cast(methodMeta);
+}
+
+inline jmethodID MethodMeta::AsJmethodID() {
+  return reinterpret_cast<jmethodID>(this);
+}
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_METHODMETA_INLINE_H_
diff --git a/src/mrt/maplert/include/mfield.h b/src/mrt/maplert/include/mfield.h
new file mode 100644
index 0000000000000000000000000000000000000000..feeab8be7d9a61397072ae497785b1b2e8723f6e
--- /dev/null
+++ b/src/mrt/maplert/include/mfield.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MFIELD_H_
+#define MRT_MAPLERT_INCLUDE_MFIELD_H_
+#include "mobject.h"
+#include "fieldmeta.h"
+namespace maplert {
+// Field Object Layout:
+// TYPE:       field                   offset:USE_32BIT_REF(!USE_32BIT_REF)
+// metaref_t   shadow                  + 0(0)
+// int         monitor                 + 4(8)
+// int8        override                + 8(12)
+// int         accessFlags             +12(16)
+// metaref_t   declaringClass          +16(24)
+// int         dexFieldIndex           +20(20)
+// int         offset                  +24(32)
+// metaref_t   type                    +28(40)
+class MField : public MObject {
+ public:
+  FieldMeta *GetFieldMeta() const;
+  MClass *GetDeclaringClass() const;
+  MClass *GetType() const;
+  bool IsAccessible() const;
+  void SetAccessible(uint8_t flag);
+#ifndef __OPENJDK__
+  int GetOffset() const;
+#endif
+  int GetAccessFlags() const;
+  int GetFieldMetaIndex() const;
+  static MField *NewMFieldObject(const FieldMeta &fieldMeta);
+
+  template<typename T>
+  static inline MField *JniCast(T f);
+  template<typename T>
+  static inline MField *JniCastNonNull(T f);
+
+ private:
+#ifndef __OPENJDK__
+  static uint32_t accessFlagsOffset;
+  static uint32_t declaringClassOffset;
+  static uint32_t fieldMetaIndexOffset;
+  static uint32_t offsetOffset;
+#else
+  static uint32_t declaringClassOffset;
+  static uint32_t accessFlagsOffset;
+  static uint32_t fieldMetaIndexOffset;
+  static uint32_t nameOffset;
+#endif
+  static uint32_t typeOffset;
+  static uint32_t overrideOffset;
+};
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MFIELD_H_
diff --git a/src/mrt/maplert/include/mfield_inline.h b/src/mrt/maplert/include/mfield_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..c22f354412f48f659b4659a12b876278b554f190
--- /dev/null
+++ b/src/mrt/maplert/include/mfield_inline.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MFIELD_INLINE_H_
+#define MRT_MAPLERT_INCLUDE_MFIELD_INLINE_H_
+#include "mfield.h"
+#include "mobject_inline.h"
+#include "fieldmeta_inline.h"
+namespace maplert {
+inline FieldMeta *MField::GetFieldMeta() const {
+  int index = GetFieldMetaIndex();
+  MClass *declClass = GetDeclaringClass();
+  FieldMeta *fieldMeta = declClass->GetFieldMeta(static_cast<uint32_t>(index));
+  return fieldMeta;
+}
+
+inline int MField::GetFieldMetaIndex() const {
+  return Load<int>(fieldMetaIndexOffset, false);
+}
+
+inline MClass *MField::GetDeclaringClass() const {
+  MetaRef dcl = Load<MetaRef>(declaringClassOffset, false);
+  return MObject::Cast<MClass>(dcl);
+}
+
+inline MClass *MField::GetType() const {
+  MetaRef type = Load<MetaRef>(typeOffset, false);
+  return MObject::Cast<MClass>(type);
+}
+
+inline bool MField::IsAccessible() const {
+  uint8_t override = Load<uint8_t>(overrideOffset, false);
+  return static_cast<bool>(override & 1u);
+}
+
+inline void MField::SetAccessible(uint8_t flag) {
+  Store<uint8_t>(overrideOffset, flag, false);
+}
+
+#ifndef __OPENJDK__
+inline int MField::GetOffset() const {
+  return Load<int>(offsetOffset, false);
+}
+#endif
+
+inline int MField::GetAccessFlags() const {
+  return Load<int>(accessFlagsOffset, false);
+}
+
+template<typename T>
+inline MField *MField::JniCast(T f) {
+  static_assert(std::is_same<T, jobject>::value, "wrong type");
+  return reinterpret_cast<MField*>(f);
+}
+
+template<typename T>
+inline MField *MField::JniCastNonNull(T f) {
+  DCHECK(f != nullptr);
+  return JniCast(f);
+}
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MFIELD_INLINE_H_
diff --git a/src/mrt/maplert/include/mmethod.h b/src/mrt/maplert/include/mmethod.h
new file mode 100644
index 0000000000000000000000000000000000000000..113164cfedaeaf6833959b061277328ad15ebd01
--- /dev/null
+++ b/src/mrt/maplert/include/mmethod.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MMETHOD_H_
+#define MRT_MAPLERT_INCLUDE_MMETHOD_H_
+#include "mobject.h"
+#include "methodmeta.h"
+
+namespace maplert {
+// Field Object Layout:
+// TYPE:       field                   offset:USE_32BIT_REF(!USE_32BIT_REF)
+// metaref_t   shadow                  + 0(0)
+// int         monitor                 + 4(8)
+// int8        override                + 8(12)
+// int         accessFlags             +12(16)
+// long        artMethod               +(24)
+// metaref_t   declaringClass          +16(32)
+// metaref_t   declaringClassOfOverriddenMethod +(40)
+// int         dexMethodIndex          +20(20)
+// int8        hasRealParameterData    +(13)
+// int         parameters              +24(48)
+class MMethod : public MObject {
+ public:
+  MethodMeta *GetMethodMeta() const;
+  MClass *GetDeclaringClass() const;
+  bool IsAccessible() const;
+  void SetAccessible(bool override);
+  static MMethod *NewMMethodObject(const MethodMeta &methodMeta);
+
+  template<typename T>
+  static inline MMethod *JniCast(T m);
+  template<typename T>
+  static inline MMethod *JniCastNonNull(T m);
+
+ private:
+#ifndef __OPENJDK__
+  static uint32_t methodMetaOffset;
+  static uint32_t declaringClassOffset;
+#else
+  static uint32_t methodDeclaringClassOffset;
+  static uint32_t methodSlotOffset;
+  static uint32_t methodNameOffset;
+  static uint32_t methodReturnTypeOffset;
+  static uint32_t methodParameterTypesOffset;
+  static uint32_t methodExceptionTypesOffset;
+  static uint32_t methodModifiersOffset;
+
+  // constructor
+  static uint32_t constructorDeclaringClassOffset;
+  static uint32_t constructorSlotOffset;
+  static uint32_t constructorParameterTypesOffset;
+  static uint32_t constructorExceptionTypesOffset;
+  static uint32_t constructorModifiersOffset;
+#endif
+  static uint32_t accessFlagsOffset;
+  static uint32_t overrideOffset;
+};
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MMETHOD_H_
diff --git a/src/mrt/maplert/include/mmethod_inline.h b/src/mrt/maplert/include/mmethod_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..70c469a09ce00a9f8efa4bd2b99696302fc2337d
--- /dev/null
+++ b/src/mrt/maplert/include/mmethod_inline.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MMETHOD_INLINE_H_
+#define MRT_MAPLERT_INCLUDE_MMETHOD_INLINE_H_
+#include "mmethod.h"
+#include "mobject_inline.h"
+#include "methodmeta_inline.h"
+namespace maplert {
+inline MethodMeta *MMethod::GetMethodMeta() const {
+#ifndef __OPENJDK__
+  return MethodMeta::Cast(Load<uint64_t>(methodMetaOffset, false));
+#else
+  MClass *clazz = GetClass();
+  uint32_t slotOffset = (clazz == WellKnown::GetMClassConstructor()) ? constructorSlotOffset : methodSlotOffset;
+  uint32_t slot = Load<uint32_t>(slotOffset, false);
+  MethodMeta *methodMeta = GetDeclaringClass()->GetMethodMeta(slot);
+  return methodMeta;
+#endif
+}
+
+inline MClass *MMethod::GetDeclaringClass() const {
+#ifndef __OPENJDK__
+  return MClass::Cast<MClass>(Load<MetaRef>(declaringClassOffset, false));
+#else
+  MClass *clazz = GetClass();
+  uint32_t dclClzzOffset = (clazz == WellKnown::GetMClassConstructor()) ?
+      constructorDeclaringClassOffset : methodDeclaringClassOffset;
+  return MClass::Cast<MClass>(Load<MetaRef>(dclClzzOffset, false));
+#endif
+}
+
+inline bool MMethod::IsAccessible() const {
+  uint8_t override = Load<uint8_t>(overrideOffset, false);
+  return (override & 0x01u) == 0x01u;
+}
+
+inline void MMethod::SetAccessible(bool override) {
+  Store<uint8_t>(overrideOffset, static_cast<uint8_t>(override), false);
+}
+
+template<typename T>
+inline MMethod *MMethod::JniCast(T m) {
+  static_assert(std::is_same<T, jobject>::value, "wrong type");
+  return reinterpret_cast<MMethod*>(m);
+}
+
+template<typename T>
+inline MMethod *MMethod::JniCastNonNull(T m) {
+  DCHECK(m != nullptr);
+  return JniCast(m);
+}
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MMETHOD_INLINE_H_
diff --git a/src/mrt/maplert/include/mobject.h b/src/mrt/maplert/include/mobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e980a6cd84e989fcac97b4975b189ad5b1e18fe
--- /dev/null
+++ b/src/mrt/maplert/include/mobject.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MOBJECT_H_
+#define MRT_MAPLERT_INCLUDE_MOBJECT_H_
+#include <vector>
+#include <string>
+#include <mutex>
+#include <atomic>
+
+#include "jni.h"
+#include "metadata_layout.h"
+#include "base/logging.h"
+namespace maplert {
+class MClass;
+class MArray;
+class MString;
+class MMethod;
+class MField;
+class MethodMeta;
+#define PACKED(n) __attribute__ ((__aligned__(n), __packed__))
+
+class PACKED(4) MObject {
+ public:
+  inline MClass *GetClass() const;
+  inline uint32_t GetSize() const;
+  inline bool IsInstanceOf(const MClass &mClass) const;
+  inline bool IsArray() const;
+  inline bool IsString() const;
+  inline bool IsClass() const;
+  inline bool IsObjectArray() const;
+  inline bool IsPrimitiveArray() const;
+  inline bool IsOffHeap() const;
+  inline void ResetMonitor();
+  template<typename T>
+  inline T Load(size_t offset, bool isVolatile = false) const;
+  template<typename T>
+  inline void Store(size_t offset, T value, bool isVolatile = false);
+  inline MObject *LoadObject(size_t offset, bool isVolatile = false) const;
+  inline void StoreObject(size_t offset, const MObject *value, bool isVolatile = false) const;
+  inline MObject *LoadObjectNoRc(size_t offset) const;
+  inline void StoreObjectNoRc(size_t offset, const MObject *value) const;
+  inline MObject *LoadObjectOffHeap(size_t offset) const;
+  inline void StoreObjectOffHeap(size_t offset, const MObject *value) const;
+  static MObject *NewObject(const MClass &klass, size_t objectSize, bool isJNI = false);
+  static MObject *NewObject(const MClass &klass, bool isJNI = false);
+  static MObject *NewObject(const MClass &klass, const MethodMeta *constructor, ...);
+  static MObject *NewObject(const MClass &klass, const MethodMeta &constructor, const jvalue &args, bool isJNI = false);
+  static uint32_t GetReffieldSize();
+  operator jobject () {
+    return reinterpret_cast<jobject>(this);
+  }
+
+  operator jobject () const {
+    return reinterpret_cast<jobject>(const_cast<MObject*>(this));
+  }
+
+  inline uintptr_t AsUintptr() const;
+  static inline MObject *JniCast(jobject o);
+  static inline MObject *JniCastNonNull(jobject o);
+  template<typename T0, typename T1>
+  static inline T0 *Cast(T1 o);
+  template<typename T0, typename T1>
+  static inline T0 *CastNonNull(T1 o);
+  inline MClass *AsMClass() const;
+  inline MArray *AsMArray() const;
+  inline MString *AsMString() const;
+  inline MMethod *AsMMethod() const;
+  inline MField *AsMField() const;
+  inline jobject AsJobject() const;
+
+ protected:
+  MetaRef shadow;
+  int32_t monitor;
+  MObject() = delete;
+  ~MObject() = delete;
+  MObject(MObject&&) = delete;
+  MObject &operator=(MObject&&) = delete;
+  MObject *SetClass(const MClass &mClass);
+
+  static inline MObject *NewObjectInternal(const MClass &klass, size_t objectSize, bool isJNI);
+};
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MOBJECT_H_
diff --git a/src/mrt/maplert/include/mobject_inline.h b/src/mrt/maplert/include/mobject_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..752b077e40a34fa1c1439833039dbd325f5448d6
--- /dev/null
+++ b/src/mrt/maplert/include/mobject_inline.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MOBJECT_INLINE_H_
+#define MRT_MAPLERT_INCLUDE_MOBJECT_INLINE_H_
+#include "mobject.h"
+#include "cinterface.h"
+#include "mrt_fields_api.h"
+#include "mrt_well_known.h"
+#include "mfield.h"
+#include "mmethod.h"
+namespace maplert {
+inline MClass *MObject::GetClass() const{
+  return MObject::Cast<MClass>(shadow);
+}
+
+inline bool MObject::IsArray() const {
+  return GetClass()->IsArrayClass();
+}
+
+inline bool MObject::IsString() const {
+  return GetClass() == WellKnown::GetMClassString();
+}
+
+inline bool MObject::IsClass() const {
+  return GetClass() == WellKnown::GetMClassClass();
+}
+
+inline bool MObject::IsObjectArray() const {
+  MClass *componentClass = GetClass()->GetComponentClass();
+  return componentClass == nullptr ? false : !componentClass->IsPrimitiveClass();
+}
+
+inline bool MObject::IsPrimitiveArray() const {
+  MClass *componentClass = GetClass()->GetComponentClass();
+  return componentClass == nullptr ? false : componentClass->IsPrimitiveClass();
+}
+
+inline uint32_t MObject::GetSize() const {
+  if (IsArray()) {
+    return AsMArray()->GetArraySize();
+  } else if (IsString()) {
+    return AsMString()->GetStringSize();
+  } else {
+    return GetClass()->GetObjectSize();
+  }
+}
+
+inline bool MObject::IsOffHeap() const {
+  return !IS_HEAP_ADDR(AsUintptr());
+}
+
+template<typename T>
+inline T MObject::Load(size_t offset, bool isVolatile) const {
+  return isVolatile ? reinterpret_cast<std::atomic<T>*>(AsUintptr() + offset)->load(std::memory_order_seq_cst)
+                    : *(reinterpret_cast<T*>(AsUintptr() + offset));
+}
+
+template<typename T>
+inline void MObject::Store(size_t offset, T value, bool isVolatile) {
+  if (isVolatile) {
+    reinterpret_cast<std::atomic<T>*>(AsUintptr() + offset)->store(value, std::memory_order_seq_cst);
+  } else {
+    *(reinterpret_cast<T*>(AsUintptr() + offset)) = value;
+  }
+}
+
+inline MObject *MObject::LoadObject(size_t offset, bool isVolatile) const {
+  return isVolatile ? Cast<MObject>(MRT_LOAD_JOBJECT_INC_VOLATILE(this, offset)) :
+                      Cast<MObject>(MRT_LOAD_JOBJECT_INC(this, offset));
+}
+
+inline void MObject::StoreObject(size_t offset, const MObject *value, bool isVolatile) const {
+  if (isVolatile) {
+    MRT_STORE_JOBJECT_VOLATILE(this, offset, value);
+  } else {
+    MRT_STORE_JOBJECT(this, offset, value);
+  }
+}
+
+inline MObject *MObject::LoadObjectNoRc(size_t offset) const {
+  return Cast<MObject>(__UNSAFE_MRT_LOAD_JOBJECT_NOINC(this, offset));
+}
+
+inline void MObject::StoreObjectNoRc(size_t offset, const MObject *value) const {
+  __UNSAFE_MRT_STORE_JOBJECT_NORC(this, offset, value);
+}
+
+inline MObject *MObject::LoadObjectOffHeap(size_t offset) const {
+  MObject *obj = LoadObjectNoRc(offset);
+  DCHECK(obj->IsOffHeap()) << "obj is in heap, but use LoadObjectOffHeap." << maple::endl;
+  return obj;
+}
+
+inline void MObject::StoreObjectOffHeap(size_t offset, const MObject *value) const {
+  DCHECK(LoadObjectNoRc(offset)->IsOffHeap()) << "org obj is in heap, but use StoreObjectOffHeap." << maple::endl;
+  DCHECK(value != nullptr && value->IsOffHeap()) << "obj is in heap, but use StoreObjectOffHeap." << maple::endl;
+  StoreObjectNoRc(offset, value);
+}
+
+inline bool MObject::IsInstanceOf(const MClass &mClass) const {
+  return mClass.IsAssignableFrom(*GetClass());
+}
+
+inline uint32_t MObject::GetReffieldSize() {
+  return sizeof(reffield_t);
+}
+
+inline void MObject::ResetMonitor() {
+  monitor = 0;
+}
+
+inline uintptr_t MObject::AsUintptr() const {
+  return reinterpret_cast<uintptr_t>(const_cast<MObject*>(this));
+}
+
+inline MObject *MObject::JniCast(const jobject o) {
+  return reinterpret_cast<MObject*>(const_cast<jobject>(o));
+}
+
+inline MObject *MObject::JniCastNonNull(const jobject o) {
+  DCHECK(o != nullptr);
+  return JniCast(o);
+}
+
+template<typename T0, typename T1>
+inline T0 *MObject::Cast(T1 o) {
+  static_assert(std::is_same<T1, void*>::value || std::is_same<T1, uintptr_t>::value ||
+      (std::is_same<T0, MClass>::value && std::is_same<T1, MetaRef>::value), "wrong type");
+  return reinterpret_cast<T0*>(o);
+}
+
+template<typename T0, typename T1>
+inline T0 *MObject::CastNonNull(T1 o) {
+  DCHECK(o != 0);
+  return Cast<T0>(o);
+}
+
+inline MClass *MObject::AsMClass() const {
+  return static_cast<MClass*>(const_cast<MObject*>(this));
+}
+
+inline MArray *MObject::AsMArray() const {
+  return static_cast<MArray*>(const_cast<MObject*>(this));
+}
+
+inline MString *MObject::AsMString() const {
+  return static_cast<MString*>(const_cast<MObject*>(this));
+}
+
+inline MMethod *MObject::AsMMethod() const {
+  return static_cast<MMethod*>(const_cast<MObject*>(this));
+}
+
+inline MField *MObject::AsMField() const {
+  return static_cast<MField*>(const_cast<MObject*>(this));
+}
+
+inline jobject MObject::AsJobject() const {
+  return reinterpret_cast<jobject>(const_cast<MObject*>(this));
+}
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MOBJECT_INLINE_H_
diff --git a/src/mrt/maplert/include/modifier.h b/src/mrt/maplert/include/modifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..4de8f5a9a30dd26bcc658d4a20ee1614062081b6
--- /dev/null
+++ b/src/mrt/maplert/include/modifier.h
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_MODIFIER_H_
+#define MRT_MAPLERT_MODIFIER_H_
+#include <cstdint>
+#include <string>
+
+namespace maplert {
+namespace modifier {
+static constexpr uint32_t kModifierPublic = 0x00000001;
+static constexpr uint32_t kModifierPrivate = 0x00000002;
+static constexpr uint32_t kModifierProtected = 0x00000004;
+static constexpr uint32_t kModifierStatic = 0x00000008;
+static constexpr uint32_t kModifierFinal = 0x00000010;
+static constexpr uint32_t kModifierSynchronized = 0x00000020;
+static constexpr uint32_t kModifierVolatile = 0x00000040;
+static constexpr uint32_t kModifierTransient = 0x00000080;
+static constexpr uint32_t kModifierNative = 0x00000100;
+static constexpr uint32_t kModifierInterface = 0x00000200;
+static constexpr uint32_t kModifierAbstract = 0x00000400;
+static constexpr uint32_t kModifierStrict = 0x00000800;
+static constexpr uint32_t kModifierSynthetic = 0x00001000;
+static constexpr uint32_t kModifierAnnotation = 0x00002000;
+static constexpr uint32_t kModifierEnum = 0x00004000;
+static constexpr uint32_t kModifierMandated = 0x00008000;
+static constexpr uint32_t kModifierConstructor = 0x00010000;
+static constexpr uint32_t kModifierCriticalNative = 0x00200000;
+static constexpr uint32_t kModifierDefault = 0x00400000;
+static constexpr uint32_t kAFOriginPublic = 0x08000000;
+static constexpr uint32_t kLocalClass = 0x10000000;
+static constexpr uint32_t kLocalClassVaild = 0x20000000;
+
+// use for annotation
+static constexpr size_t kModifierRCUnowned = 0x00800000;
+static constexpr size_t kModifierRCWeak = 0x01000000;
+
+static constexpr uint32_t kModifierBridge = 0x00000040;
+static constexpr uint32_t kModifierVarargs = 0x00000080;
+static constexpr uint32_t kModifierFinalizable = 0x80000000;
+static constexpr uint32_t kModifierProxy = 0x00040000;
+
+// class flag
+static constexpr uint16_t kClassPrim = 0x0001;
+static constexpr uint16_t kClassArray = 0x0002;
+static constexpr uint16_t kClassHasFinalizer = 0x0004;
+static constexpr uint16_t kClassSoftReference = 0x0008;
+static constexpr uint16_t kClassWeakReference = 0x0010;
+static constexpr uint16_t kClassPhantomReference = 0x0020;
+static constexpr uint16_t kClassFinalizerReference = 0x0040;
+static constexpr uint16_t kClassCleaner = 0x0080;
+static constexpr uint16_t kClassFinalizerReferenceSentinel = 0x0100;
+static constexpr uint32_t kClassFastAlloc = 0x0200;
+static constexpr uint16_t kClassIsAnonymousClass = 0x0400;
+static constexpr uint16_t kClassIsColdClass = 0x0800;
+static constexpr uint16_t kClassIsDecoupleClass = 0x1000;
+static constexpr uint16_t kClassLazyBindingClass = 0x2000;
+static constexpr uint16_t kClassLazyBoundClass = 0x4000;
+static constexpr uint16_t kClassRuntimeVerify = 0x8000; // True if need verifier in runtime (error or deferred check).
+
+static constexpr uint16_t kClassReference = (kClassSoftReference | kClassWeakReference |
+    kClassCleaner | kClassFinalizerReference | kClassPhantomReference);
+
+// method & field Hash Size & Conflict
+static constexpr uint32_t kHashConflict = 1023;
+static constexpr uint32_t kMethodFieldHashSize = 1022;
+
+// field flag, type: uint16_t
+// reserved high 10bits for field's hashcode: 0xFFC0
+static constexpr uint32_t kFieldOffsetIspOffset = 0x0001;
+
+// method flag, type: uint16_t
+// reserved high 10bits for method's hashcode: 0xFFC0
+static constexpr uint32_t kMethodNotVirtual = 0x00000001;
+static constexpr uint32_t kMethodFinalize = 0x00000002;
+static constexpr uint32_t kMethodMetaCompact = 0x00000004;
+static constexpr uint32_t kMethodParametarType = 0x00000008;
+static constexpr uint32_t kMethodAbstract = 0x00000010;
+static constexpr uint32_t kMethodNativeSignature = 0x00000020;
+
+static inline bool IsAFOriginPublic(uint32_t modifier) {
+  return (modifier & kAFOriginPublic) != 0;
+}
+
+static inline bool IsLocalClass(uint32_t modifier) {
+  return (modifier & kLocalClass) != 0;
+}
+
+static inline bool IsLocalClassVaild(uint32_t modifier) {
+  return (modifier & kLocalClassVaild) != 0;
+}
+
+static inline bool IsPublic(uint32_t modifier) {
+  return (modifier & kModifierPublic) != 0;
+}
+
+static inline bool IsPrivate(uint32_t modifier) {
+  return (modifier & kModifierPrivate) != 0;
+}
+
+static inline bool IsProtected(uint32_t modifier) {
+  return (modifier & kModifierProtected) != 0;
+}
+
+static inline bool IsStatic(uint32_t modifier) {
+  return (modifier & kModifierStatic) != 0;
+}
+
+static inline bool IsFinal(uint32_t modifier) {
+  return (modifier & kModifierFinal) != 0;
+}
+
+static inline bool IsSynchronized(uint32_t modifier) {
+  return (modifier & kModifierSynchronized) != 0;
+}
+
+static inline bool IsVolatile(uint32_t modifier) {
+  return (modifier & kModifierVolatile) != 0;
+}
+
+static inline bool IsTransient(uint32_t modifier) {
+  return (modifier & kModifierTransient) != 0;
+}
+
+static inline bool IsNative(uint32_t modifier) {
+  return (modifier & kModifierNative) != 0;
+}
+
+static inline bool IsCriticalNative(uint32_t modifier) {
+  return (modifier & kModifierCriticalNative) != 0;
+}
+
+static inline bool IsInterface(uint32_t modifier) {
+  return (modifier & kModifierInterface) != 0;
+}
+
+static inline bool IsAbstract(uint32_t modifier) {
+  return (modifier & kModifierAbstract) != 0;
+}
+
+static inline bool IsStrict(uint32_t modifier) {
+  return (modifier & kModifierStrict) != 0;
+}
+
+static inline bool IsSynthetic(uint32_t modifier) {
+  return (modifier & kModifierSynthetic) != 0;
+}
+
+static inline bool IsConstructor(uint32_t modifier) {
+  return (modifier & kModifierConstructor) != 0;
+}
+
+static inline bool IsDefault(uint32_t modifier) {
+  return (modifier & kModifierDefault) != 0;
+}
+
+static inline bool IsAnnotation(uint32_t modifier) {
+  return (modifier & kModifierAnnotation) != 0;
+}
+
+static inline bool IsEnum(uint32_t modifier) {
+  return (modifier & kModifierEnum) != 0;
+}
+
+static inline bool IsMandated(uint32_t modifier) {
+  return (modifier & kModifierMandated) != 0;
+}
+
+static inline bool IsBridge(uint32_t modifier) {
+  return (modifier & kModifierBridge) != 0;
+}
+
+static inline bool IsVarargs(uint32_t modifier) {
+  return (modifier & kModifierVarargs) != 0;
+}
+
+static inline bool IsFinalizable(uint32_t modifier) {
+  return (modifier & kModifierFinalizable) != 0;
+}
+
+static inline bool IsProxy(uint32_t modifier) {
+  return (modifier & kModifierProxy) != 0;
+}
+
+static inline bool IsUnowned(size_t modifier) {
+  return (modifier & kModifierRCUnowned) != 0;
+}
+
+static inline bool IsWeakRef(size_t modifier) {
+  return (modifier & kModifierRCWeak) != 0;
+}
+
+static inline bool IsDirectMethod(uint32_t modifier) {
+  constexpr uint32_t direct = kModifierStatic | kModifierPrivate | kModifierConstructor;
+  return (modifier & direct) != 0;
+}
+
+static inline uint32_t GetInterfaceModifier() {
+  return kModifierInterface;
+}
+
+static inline uint32_t GetStaticModifier() {
+  return kModifierStatic;
+}
+
+static inline uint32_t GetAbstractModifier() {
+  return kModifierAbstract;
+}
+
+static inline uint32_t GetFinalModifier() {
+  return kModifierFinal;
+}
+
+static inline uint32_t GetNativeModifier() {
+  return kModifierNative;
+}
+
+static inline uint32_t GetSynchronizedModifier() {
+  return kModifierSynchronized;
+}
+
+static inline bool IsPrimitiveClass(uint32_t flag) {
+  return (flag & kClassPrim) != 0;
+}
+
+static inline bool IsArrayClass(uint32_t flag) {
+  return (flag & kClassArray) != 0;
+}
+
+static inline bool hasFinalizer(uint32_t flag) {
+  return (flag & kClassHasFinalizer) != 0;
+}
+
+static inline bool IsReferenceClass(uint32_t flag) {
+  return (flag & kClassReference) != 0;
+}
+
+static inline bool IsFastAllocClass(uint32_t flag) {
+  return (flag & kClassFastAlloc) != 0;
+}
+
+static inline bool IsAnonymousClass(uint32_t flag) {
+  return (flag & kClassIsAnonymousClass) != 0;
+}
+
+static inline bool IsColdClass(uint32_t flag) {
+  return (flag & kClassIsColdClass) != 0;
+}
+
+static inline bool IsDecoupleClass(uint32_t flag) {
+  return (flag & kClassIsDecoupleClass) != 0;
+}
+
+static inline bool IsLazyBindingClass(uint32_t flag) {
+  return (flag & kClassLazyBindingClass) != 0;
+}
+
+static inline bool IsLazyBoundClass(uint32_t flag) {
+  return (flag & kClassLazyBoundClass) != 0;
+}
+
+static inline bool IsNotVerifiedClass(uint32_t flag) {
+  return (flag & kClassRuntimeVerify) != 0;
+}
+
+static inline bool IsNotvirtualMethod(uint32_t flag) {
+  return (flag & kMethodNotVirtual) != 0;
+}
+
+static inline bool IsFinalizeMethod(uint32_t flag) {
+  return (flag & kMethodFinalize) != 0;
+}
+void JavaAccessFlagsToString(uint32_t accessFlags, std::string &result);
+} // namespace modifier
+} // namespace maplert
+#endif
diff --git a/src/mrt/maplert/include/mrt_annotation.h b/src/mrt/maplert/include/mrt_annotation.h
new file mode 100644
index 0000000000000000000000000000000000000000..0abf4dd7c48c0cf33a05edc5e8d3ab232caa8a8f
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_annotation.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_INCLUDE_MRT_REFLECTION_ANNOTATION_H_
+#define MRT_INCLUDE_MRT_REFLECTION_ANNOTATION_H_
+
+#include "spinlock.h"
+#include "mrt_annotation_parser_inline.h"
+namespace maplert {
+using CacheValueType = void*;
+
+class DcAnnoPresentKeyType {
+ public:
+  DcAnnoPresentKeyType(CacheValueType mt, CacheValueType anno) : meta(mt), annoObj(anno) {}
+  DcAnnoPresentKeyType(const DcAnnoPresentKeyType&) = default;
+  DcAnnoPresentKeyType &operator=(const DcAnnoPresentKeyType&) = default;
+  ~DcAnnoPresentKeyType() = default;
+  CacheValueType meta;
+  CacheValueType annoObj;
+  bool operator<(const DcAnnoPresentKeyType &lhs) const {
+    return lhs.meta < meta || (lhs.meta == meta && lhs.annoObj < annoObj);
+  }
+};
+
+class CacheItem {
+ public:
+  CacheItem() : key(nullptr), value(nullptr) {}
+  ~CacheItem() = default;
+  CacheValueType key;
+  CacheValueType value;
+  maple::SpinLock lock;
+};
+
+class AnnotationUtil {
+ public:
+  static CacheValueType Get(annoconstant::CacheLabel label, MClass *classObj) noexcept;
+  static bool GetCache(annoconstant::CacheLabel label, CacheValueType classObj, CacheValueType &result) noexcept;
+  static jboolean GetIsAnnoPresent(const std::string&, const std::string&, CacheValueType,
+                                   MClass*, annoconstant::CacheLabel) noexcept;
+  static void GetDeclaredClasses(MClass *classObj, std::set<MClass*> &metalist) noexcept;
+  static MObject *GetDeclaredAnnotations(const std::string annoStr, MClass *classObj);
+  static uint32_t GetRealParaCntForConstructor(const MethodMeta &mthd, const char *kMthdAnnoStr);
+  static bool HasDeclaredAnnotation(MClass *klass, annoconstant::AnnotationClass annoType);
+  static jboolean IsDeclaredAnnotationPresent(const std::string &annoStr, const std::string&, MClass *currentCls);
+  static std::string GetAnnotationUtil(const char *annotation);
+
+ private:
+#ifndef __OPENJDK__
+  static void DeCompressHighFrequencyStr(std::string &str);
+#endif
+  static CacheItem cache[annoconstant::kRTCacheSize];
+  static MethodMeta *GetEnclosingMethodValue(MClass *classObj, const std::string &annSet);
+  static MethodMeta *GetEnclosingMethod(MClass *argObj) noexcept;
+  static void UpdateCache(annoconstant::CacheLabel label, CacheValueType classObj, CacheValueType result) noexcept;
+  static MObject *GetEnclosingClass(MClass *classObj) noexcept;
+  static MObject *GetDeclaringClassFromAnnotation(MClass *classObj) noexcept;
+};
+
+class MethodDefaultUtil {
+ public:
+  MethodDefaultUtil(MethodMeta &mthMeta, MClass *declCls)
+      : methodMeta(mthMeta), declClass(declCls) {}
+  static bool HasDefaultValue(const char *methodName, AnnoParser &parser);
+  ~MethodDefaultUtil() = default;
+  MObject *GetDefaultValue(const std::unique_ptr<AnnoParser> &uniqueParser);
+ private:
+  MObject *GetDefaultAnnotationValue(const std::unique_ptr<AnnoParser> &uniqueParser);
+  MObject *GetDefaultEnumValue(const std::unique_ptr<AnnoParser> &uniqueParser);
+  MObject *GetDefaultPrimValue(const std::unique_ptr<AnnoParser> &uniqueParser, uint32_t type);
+
+  MethodMeta &methodMeta;
+  MClass *declClass;
+};
+} // namespace maplert
+#endif
diff --git a/src/mrt/maplert/include/mrt_annotation_parser.h b/src/mrt/maplert/include/mrt_annotation_parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..308fedf87db3df83a27d4e4f648df027ae153b3d
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_annotation_parser.h
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_INCLUDE_MRT_ANNOTATION_PARSER_H_
+#define MRT_INCLUDE_MRT_ANNOTATION_PARSER_H_
+
+#include <string.h>
+#include <set>
+#include "jni.h"
+#include "fieldmeta.h"
+#include "mmethod.h"
+#include "linker_api.h"
+
+namespace maplert{
+namespace annoconstant {
+constexpr bool kDefParseStrType = false;
+constexpr int kDefSkipItemNum = 1;
+constexpr char kOldMetaLabel = '0';
+constexpr char kNewMetaLabel = '1';
+constexpr int8_t kMemberPosValidOffset = 2;
+constexpr int8_t kIsMemberClassOffset = 1;
+constexpr uint8_t kLabelSize = 2;
+constexpr char kAnnoDelimiterPrefix = '`';
+constexpr char kAnnoDelimiter = '!';
+constexpr char kAnnoArrayStartDelimiter = '[';
+constexpr char kAnnoArrayEndDelimiter = ']';
+constexpr int8_t kNPos = -1;
+constexpr char kInheritClass[] = "Ljava/lang/annotation/Inherited;";
+constexpr char kRepeatableClasss[] = "Ljava/lang/annotation/Repeatable;";
+constexpr char kAnnoAccessFlags[] = "accessFlags";
+constexpr char kThrowVerifyError[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoThrowVerifyError;";
+constexpr char kDeferredOverrideFinalCheck[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoDeferredOverrideFinalCheck;";
+constexpr char kDeferredExtendFinalCheck[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoDeferredExtendFinalCheck;";
+constexpr char kAssignableChecksContainer[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoDeferredAssignableChecks;";
+constexpr char kDeferredAssignableCheck[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoDeferredAssignableCheck;";
+
+
+const std::string kEncosilngClass("Lark/annotation/EnclosingClass;");
+const std::string kInnerClass("Lark/annotation/InnerClass;");
+const std::string kMemberClasses("Lark/annotation/MemberClasses;");
+const std::string kSignatureClass("Lark/annotation/Signature;");
+const std::string kEncsloingMethodClass("Lark/annotation/EnclosingMethod;");
+const std::string kAnnoDefault("Lark/annotation/AnnotationDefault;");
+const std::string kMethodParameters("Lark/annotation/MethodParameters;");
+const std::string kThrowsClass("Lark/annotation/Throws;");
+const std::string kMrtTypeClass("Ljava/lang/reflect/Type;");
+
+const std::string kRepeatableClasssIndex("Ljava/lang/annotation/Repeatable;");
+const std::string kEncosilngClassIndex("Lark/annotation/EnclosingClass;");
+const std::string kInnerClassIndex("Lark/annotation/InnerClass;");
+const std::string kMemberClassesIndex("Lark/annotation/MemberClasses;");
+const std::string kSignatureClassIndex("Lark/annotation/Signature;");
+const std::string kEncsloingMethodClassIndex("Lark/annotation/EnclosingMethod;");
+const std::string kThrowsClassIndex("Lark/annotation/Throws;");
+const std::string kAnnoDefaultIndex("Lark/annotation/AnnotationDefault;");
+const std::string kMethodParametersIndex("Lark/annotation/MethodParameters;");
+const std::string kInheritClassIndex("Ljava/lang/annotation/Inherited;");
+constexpr char kAnnoArrayStartDelimiterIndex = '{';
+constexpr char kAnnoArrayEndDelimiterIndex = '}';
+constexpr char kThrowVerifyErrorIndex[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoThrowVerifyError;";
+constexpr char kDeferredOverrideFinalCheckIndex[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoDeferredOverrideFinalCheck;";
+constexpr char kDeferredExtendFinalCheckIndex[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoDeferredExtendFinalCheck;";
+constexpr char kAssignableChecksContainerIndex[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoDeferredAssignableChecks;";
+constexpr char kDeferredAssignableCheckIndex[] =
+    "Lcom/huawei/ark/annotation/verify/VerfAnnoDeferredAssignableCheck;";
+
+enum ParseTypeValue : uint8_t {
+  kValueByte = 0x00,
+  kValueShort = 0x02,
+  kValueChar,
+  kValueInt,
+  kValueLong = 0x06,
+  kValueFloat = 0x10,
+  kValueDouble,
+  kValueMethodType = 0x15,
+  kValueMethodHandle,
+  kValueString,
+  kValueType,
+  kValueField,
+  kValueMethod,
+  kValueEnum,
+  kValueArray,
+  kValueAnnotation,
+  kValueNull,
+  kValueBoolean
+};
+using AnnotationClass = enum {
+  kAnnotationInherited = 0,
+  kAnnotationRepeatable = 1
+};
+enum CacheLabel : uint8_t {
+  kEnclosingClass,
+  kDeclaredClasses,
+  kDeclaringClass,
+  kEnclosingMethod,
+  kHasNoDeclaredAnno,
+  kClassAnnoPresent,
+  kMethodAnnoPresent,
+  kFieldAnnoPresent,
+  kRTCacheSize
+};
+} // namespace annoconstant
+
+class AnnoParser {
+ public:
+  AnnoParser(const char *str, MClass *dClass = nullptr, size_t idx = 0)
+      : annoStr(str), annoStrIndex(idx), declaringClass(dClass), annoSize(strlen(str)) {
+    if (declaringClass != nullptr) {
+      strTab = new StrTab;
+      LinkerAPI::Instance().GetStrTab(reinterpret_cast<jclass>(declaringClass), *strTab);
+    }
+  }
+  AnnoParser(const AnnoParser&) = default;
+  AnnoParser &operator=(const AnnoParser&) = default;
+  static inline AnnoParser &ConstructParser(const char *str, MClass *dClass = nullptr, size_t idx = 0);
+  MObject *AllocAnnoObject(MClass *classObj, MClass *annoClass);
+  MObject *GetAnnotationNative(int32_t index, const MClass *annoClass);
+  MObject *GetParameterAnnotationsNative(const MethodMeta *methodMeta);
+  MObject *GetParameters0(MMethod *method);
+  static MObject *GetSignatureValue(const std::string &annSet, MClass *cls);
+  virtual bool ExceptAnnotationJudge(const std::string &annoName) const = 0;
+  virtual std::string ParseStr(bool isSN) = 0;
+  virtual std::string ParseStrImpl() = 0;
+  virtual void NextItem(int iter);
+  virtual void IncIdx(size_t step) = 0;
+  virtual int32_t Find(const std::string &target) = 0;
+  int32_t Find(char target);
+  static bool IsIndexParser(const char *str);
+  static bool IsMemberClass(const char *str, bool &isValid);
+  static std::string GetParameterAnnotationInfo(const std::string &entireStr);
+  MObject *GenerateAnnotationTypeValue(MClass *classInfo, const MClass*, uint32_t);
+  MObject *GenerateAnnotationProxyInstance(MClass *classInfo, MClass*, uint32_t memberNum);
+  static std::string RemoveParameterAnnoInfo(std::string &annoStr);
+  static bool HasAnnoMember(const std::string &annoStr);
+  std::string ParseStrNotMove();
+  std::string ParseStrForLastStringArray();
+  double ParseDoubleNum(int type);
+  int64_t ParseNum(int type);
+  void SkipNameAndType(int iter = 1);
+  void SkipAnnoMember(uint32_t iter);
+#ifdef __OPENJDK__
+  MObject *GenerateMemberValueHashMap(MClass *classInfo, MClass *annotationInfo, uint32_t memberNum);
+  MObject *CaseArray(MClass *classInfo, MClass *annotationInfo, MethodMeta &mthdObj);
+  static MObject *InvokeAnnotationParser(MObject *hashMapInst, MObject *annotationInfo);
+#else
+  MObject *GenerateAnnotationMemberArray(MClass *classInfo, MClass *annotationInfo, uint32_t memberNum);
+  MObject *CaseArray(MClass *classInfo, MClass *annotationInfo, ArgValue &argArr, MethodMeta &mthdObj);
+#endif // __OPENJDK__
+  void InitAnnoMemberCntArray(uint32_t *annoMemberCntArray, uint32_t annoNum);
+  bool IsVerificationAnno(const std::string &annotName) const;
+  void SetIdx(uint32_t idx) noexcept {
+    annoStrIndex = idx;
+  }
+  size_t GetIdx() const noexcept {
+    return annoStrIndex;
+  }
+  const char *GetStr() const noexcept {
+    return annoStr;
+  }
+  char GetCurrentChar() const noexcept {
+    return annoStr[annoStrIndex];
+  }
+  virtual ~AnnoParser();
+  virtual const std::string &GetEnclosingClassStr() const noexcept {
+    return annoconstant::kEncosilngClass;
+  }
+  virtual const std::string &GetInnerClassStr() const noexcept {
+    return annoconstant::kInnerClass;
+  }
+  virtual const std::string &GetMemberClassesStr() const noexcept {
+    return annoconstant::kMemberClasses;
+  }
+  virtual const std::string &GetSignatureClassStr() const noexcept {
+    return annoconstant::kSignatureClass;
+  }
+  virtual const std::string &GetEncsloingMethodClassStr() const noexcept {
+    return annoconstant::kEncsloingMethodClass;
+  }
+  virtual const std::string &GetThrowsClassStr() const noexcept {
+    return annoconstant::kThrowsClass;
+  }
+  virtual const std::string &GetAnnoDefaultStr() const noexcept {
+    return annoconstant::kAnnoDefault;
+  }
+  virtual const std::string &GetMethodParametersStr() const noexcept {
+    return annoconstant::kMethodParameters;
+  }
+  virtual char GetAnnoArrayStartDelimiter() const noexcept {
+    return annoconstant::kAnnoArrayStartDelimiter;
+  }
+  virtual char GetAnnoArrayEndDelimiter() const noexcept {
+    return annoconstant::kAnnoArrayEndDelimiter;
+  }
+ protected:
+  template<typename T>
+  T ParseNumImpl(int type);
+  char *GetCStringFromStrTab(uint32_t srcIndex) const;
+  const char *annoStr;
+  size_t annoStrIndex;
+  MClass *declaringClass;
+  size_t annoSize;
+  StrTab *strTab = nullptr;
+};
+
+class AnnoIndexParser : public AnnoParser {
+ public:
+  AnnoIndexParser(const char *str, MClass *dClass = nullptr, size_t idx = 0) : AnnoParser(str, dClass, idx) {}
+  std::string ParseStr(bool isSN);
+  static std::string GetParameterAnnotationInfoIndex(const std::string &entireStr);
+  bool ExceptAnnotationJudge(const std::string &annoName) const;
+  std::string ParseStrImpl();
+  uint32_t ParseIndex();
+  int32_t Find(const std::string &target);
+  void IncIdx(size_t step __attribute__((unused))) {
+    return;
+  }
+  virtual ~AnnoIndexParser() = default;
+  virtual void NextItem(int iter);
+  virtual const std::string &GetEnclosingClassStr() const noexcept {
+    return annoconstant::kEncosilngClassIndex;
+  }
+  virtual const std::string &GetInnerClassStr() const noexcept {
+    return annoconstant::kInnerClassIndex;
+  }
+  virtual const std::string &GetMemberClassesStr() const noexcept {
+    return annoconstant::kMemberClassesIndex;
+  }
+  virtual const std::string &GetSignatureClassStr() const noexcept {
+    return annoconstant::kSignatureClassIndex;
+  }
+  virtual const std::string &GetEncsloingMethodClassStr() const noexcept {
+    return annoconstant::kEncsloingMethodClassIndex;
+  }
+  virtual const std::string &GetThrowsClassStr() const noexcept {
+    return annoconstant::kThrowsClassIndex;
+  }
+  virtual const std::string &GetAnnoDefaultStr() const noexcept {
+    return annoconstant::kAnnoDefaultIndex;
+  }
+  virtual const std::string &GetMethodParametersStr() const noexcept {
+    return annoconstant::kMethodParametersIndex;
+  }
+  virtual char GetAnnoArrayStartDelimiter() const noexcept {
+    return annoconstant::kAnnoArrayStartDelimiterIndex;
+  }
+  virtual char GetAnnoArrayEndDelimiter() const noexcept {
+    return annoconstant::kAnnoArrayEndDelimiterIndex;
+  }
+  static std::set<std::string> exceptIndexSet;
+};
+
+class AnnoAsciiParser : public AnnoParser {
+ public:
+  AnnoAsciiParser(const char *str, MClass *dClass = nullptr, size_t idx = 0) : AnnoParser(str, dClass, idx) {}
+  std::string ParseStr(bool isSN);
+  static std::string GetParameterAnnotationInfoAscii(const std::string &entireStr);
+  bool ExceptAnnotationJudge(const std::string &kAnnoName) const;
+  std::string ParseStrImpl();
+  virtual ~AnnoAsciiParser() = default;
+  int32_t Find(const std::string &target);
+  static std::set<std::string> exceptAsciiSet;
+  void IncIdx(size_t step) noexcept {
+    annoStrIndex += step;
+  }
+};
+} // namespace maplert
+#endif
diff --git a/src/mrt/maplert/include/mrt_annotation_parser_inline.h b/src/mrt/maplert/include/mrt_annotation_parser_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d7c08d947805bacf4e3b579689bd19a82adab03
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_annotation_parser_inline.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_INCLUDE_MRT_REFLECTION_ANNOTATION_INLINE_H_
+#define MRT_INCLUDE_MRT_REFLECTION_ANNOTATION_INLINE_H_
+#include "mrt_annotation_parser.h"
+#include "mrt_profile.h"
+namespace maplert {
+inline AnnoParser &AnnoParser::ConstructParser(const char *str, MClass *dClass, size_t idx) {
+  AnnoParser *parser = nullptr;
+  if (IsIndexParser(str)) {
+    parser = new AnnoIndexParser(str + annoconstant::kLabelSize, dClass, idx);
+  } else {
+    parser = new AnnoAsciiParser(str + annoconstant::kLabelSize, dClass, idx);
+  }
+  return *parser;
+}
+
+inline bool AnnoParser::IsIndexParser(const char *str) {
+  int32_t flag = str[0] - annoconstant::kOldMetaLabel;
+  return static_cast<bool>(flag & 1);
+}
+
+inline bool AnnoParser::HasAnnoMember(const std::string &annoStr) {
+  if (annoStr.size() >= annoconstant::kLabelSize && annoStr[annoconstant::kLabelSize] > '0') {
+    return true;
+  }
+  return false;
+}
+
+inline bool AnnoParser::IsMemberClass(const char *str, bool &isValid) {
+  int32_t flag = str[0] - annoconstant::kOldMetaLabel;
+  isValid = static_cast<bool>((flag >> annoconstant::kMemberPosValidOffset) & 1);
+  if (!isValid) {
+    return false;
+  }
+  return static_cast<bool>(flag & (1 << annoconstant::kIsMemberClassOffset));
+}
+
+inline std::string AnnoParser::ParseStrNotMove() {
+  size_t oldIndex = annoStrIndex;
+  std::string retArr = ParseStrImpl();
+  annoStrIndex = oldIndex;
+  return retArr;
+}
+
+inline std::string AnnoParser::ParseStrForLastStringArray() {
+  if (annoStr[annoStrIndex] == annoconstant::kAnnoArrayEndDelimiter) {
+    ++annoStrIndex;
+  }
+  return ParseStrImpl();
+}
+
+inline double AnnoParser::ParseDoubleNum(int type) {
+  return ParseNumImpl<double>(type);
+}
+
+inline int64_t AnnoParser::ParseNum(int type) {
+  if (annoSize == 0) {
+    return 0;
+  }
+  return ParseNumImpl<int64_t>(type);
+}
+} // namespace maplert
+#endif
diff --git a/src/mrt/maplert/include/mrt_array.h b/src/mrt/maplert/include/mrt_array.h
new file mode 100644
index 0000000000000000000000000000000000000000..c323497812aa3ca5c673ad1b546ae1d814c7c0cd
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_array.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef JAVA_MRT_ARRAY_H_
+#define JAVA_MRT_ARRAY_H_
+
+#include "jni.h"
+#include "mrt_array_api.h"
+#include "mclass.h"
+
+namespace maplert {
+void *MRT_JavaArrayToCArray(jarray javaArray);
+void MRT_ObjectArrayCopy(address_t javaSrc, address_t javaDst, jint srcPos, jint dstPos, jint length,
+                         bool check = false);
+void ThrowArrayStoreException(const MObject &srcComponent, int index, const MClass &dstComponentType);
+bool AssignableCheckingObjectCopy(const MClass &dstComponentType, MClass *&lastAssignableComponentType,
+                                  const MObject *srcComponent);
+} // namespace maplert
+
+#endif // JAVA_MRT_ARRAY_H_
diff --git a/src/mrt/maplert/include/mrt_class_init.h b/src/mrt/maplert/include/mrt_class_init.h
new file mode 100644
index 0000000000000000000000000000000000000000..56d877c2c1a9a378a0e7078c19b2c43ccec163ba
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_class_init.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef JAVA_MRT_CLASS_INIT_H_
+#define JAVA_MRT_CLASS_INIT_H_
+
+#include <iostream>
+#include "mrt_class_api.h"  // exported-api declaration.
+#include "mrt_object.h"
+#include "cinterface.h"
+
+namespace maplert {
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ClassInitState MRT_TryInitClass(const MClass &classInfo, bool recursive = true);
+ClassInitState MRT_TryInitClassOnDemand(const MClass &classInfo);
+bool MRT_InitClassIfNeeded(const MClass &classInfo);
+#ifdef __cplusplus
+}
+#endif
+}
+#endif // JAVA_MRT_CLASS_INIT_H_
+
diff --git a/src/mrt/maplert/include/mrt_classloader.h b/src/mrt/maplert/include/mrt_classloader.h
new file mode 100644
index 0000000000000000000000000000000000000000..784559b13f9b5f718c11d18a7fe72a50dea05f78
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_classloader.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_CLASS_CLASSLOADER_IMP_H_
+#define MRT_CLASS_CLASSLOADER_IMP_H_
+
+#include <vector>
+
+#include "gc_roots.h"
+#include "object_base.h"
+#include "jni.h"
+#include "mrt_classloader_api.h"
+#include "loader/object_locator.h"
+#include "loader/object_loader.h"
+#include "mrt_api_common.h"
+#include "linker_api.h"
+namespace maplert {
+class CLCache {
+ private:
+#ifdef USE_32BIT_REF
+  static constexpr int ptrSize = 4;
+  using CacheType = uint32_t;
+#else
+  static constexpr int ptrSize = 8;
+  using CacheType = uint64_t;
+#endif
+  static constexpr int kCacheSize = 2 * 1024; // 2k
+  static constexpr int kMutexNum = 64;
+  static constexpr int kPerMutexRange = kCacheSize / kMutexNum;
+  static constexpr int arraySize = kCacheSize * ptrSize / sizeof(CacheType);
+  CacheType classAddrArray[arraySize] = { 0 };
+  CacheType resultArray[arraySize] = { 0 };
+  std::mutex cacheMtx[kMutexNum];
+  std::atomic<bool> valid;
+ public:
+  static CLCache instance;
+  CLCache() {
+    valid = true;
+  }
+  ~CLCache() {}
+
+  jclass GetCache(const jclass contextClass, const std::string &className, uint32_t &index, bool &lockFail) noexcept {
+    size_t clNameSize = className.size();
+    if (valid.load(std::memory_order_acquire)) {
+      constexpr int kSeed = 31;
+      constexpr int kDistance = 2;
+      uint64_t hash = 0;
+      for (size_t i = 0; i < clNameSize; i += kDistance) {
+        hash = kSeed * hash + className[i];
+      }
+      hash += reinterpret_cast<address_t>(contextClass);
+      index = hash % kCacheSize;
+      size_t mutexIdx = index / kPerMutexRange;
+      if (!cacheMtx[mutexIdx].try_lock()) {
+        lockFail = true;
+        return nullptr;
+      }
+      jclass retVal = reinterpret_cast<jclass>(static_cast<uint64_t>(resultArray[index]));
+      if (classAddrArray[index] == static_cast<CacheType>(reinterpret_cast<uint64_t>(contextClass)) &&
+          retVal != nullptr && className == (reinterpret_cast<MClass*>(retVal))->GetName()) {
+        cacheMtx[mutexIdx].unlock();
+        return retVal;
+      }
+      cacheMtx[mutexIdx].unlock();
+    }
+    return nullptr;
+  }
+
+  void WriteCache(const jclass klass, const jclass contextClass, uint32_t index) noexcept {
+    if (valid.load(std::memory_order_acquire)) {
+      size_t mutexIdx = index / kPerMutexRange;
+      if (!cacheMtx[mutexIdx].try_lock()) {
+        return;
+      }
+      classAddrArray[index] = static_cast<CacheType>(reinterpret_cast<uint64_t>(contextClass));
+      resultArray[index] = static_cast<CacheType>(reinterpret_cast<uint64_t>(klass));
+      cacheMtx[mutexIdx].unlock();
+    }
+  }
+  void ResetCache() {
+    bool expect = true;
+    if (!valid.compare_exchange_strong(expect, false, std::memory_order_acq_rel) && !expect) {
+      return; // other thread is Reseting, just return when cas fail
+    }
+    if (memset_s(classAddrArray, kCacheSize * ptrSize, 0, kCacheSize * ptrSize) != EOK) {
+      LOG(FATAL) << "memset_s fail." << maple::endl;
+    }
+    expect = false;
+    if (!valid.compare_exchange_strong(expect, true, std::memory_order_acq_rel) && expect) {
+      LOG(FATAL) << "CLCache is working when reseting cache" << maple::endl;
+    }
+  }
+};
+class ClassLoaderImpl : public ObjectLoader {
+ public:
+  ClassLoaderImpl();
+  ~ClassLoaderImpl();
+  void UnInit() override;
+  // API Interfaces Begin
+  bool LoadMplFileInBootClassPath(const std::string &pathString) override;
+#ifndef __ANDROID__
+  bool LoadMplFileInUserClassPath(const std::string &pathString) override;
+#endif
+  bool LoadMplFileInAppClassPath(jobject classLoader, FileAdapter &adapter) override;
+  void ResetCLCache() override;
+  jclass GetCache(const jclass contextClass, const std::string &className, uint32_t &index, bool &lockFail) override;
+  void WriteCache(const jclass klass, const jclass contextClass, uint32_t index) override;
+  void RegisterMplFile(const ObjFile &mplFile) override;
+  bool UnRegisterMplFile(const ObjFile &mplFile) override;
+  bool RegisterJniClass(IEnv env, jclass javaClass, const std::string &filterName, const std::string &jniClassName,
+      INativeMethod methods, int32_t methodCount, bool fake) override;
+  jclass FindClass(const std::string &className, const SearchFilter &filter) override;
+  // get registered mpl file by exact path-name: the path should be canonicalized
+  const ObjFile *GetMplFileRegistered(const std::string &name) override;
+  const ObjFile *GetAppMplFileRegistered(const std::string &package) override;
+  size_t GetListSize(AdapterFileList type) override;
+  void DumpUnregisterNativeFunc(std::ostream &os) override;
+  bool GetMappedClassLoaders(
+      jobject classLoader, std::vector<std::pair<jobject, const ObjFile*>> &mappedPairs) override;
+  bool GetMappedClassLoader(const std::string &fileName, jobject classLoader, jobject &realClassLoader) override;
+  void VisitClasses(maple::rootObjectFunc &func) override;
+  bool RegisterNativeMethods(ObjFile &objFile, jclass klass, INativeMethod methods, int32_t methodCount) override;
+  // MRT_EXPORT Split
+  jclass LocateClass(const std::string &className, const SearchFilter &filter) override;
+  // API Interfaces End
+  MClass *GetPrimitiveClass(const std::string &mplClassName) override;
+  void VisitPrimitiveClass(const maple::rootObjectFunc &func) override;
+  MClass *CreateArrayClass(const std::string &mplClassName, MClass &componentClass) override;
+
+ protected:
+  bool SetMappedClassLoader(const std::string &fileName, MObject *classLoader, MObject *realClassLoader);
+  void RemoveMappedClassLoader(const std::string &fileName);
+  MClass *FindClassInSingleClassLoader(const std::string &className, SearchFilter &filter);
+  MClass *LocateInCurrentClassLoader(const std::string &className, SearchFilter &filter);
+  MClass *LocateInParentClassLoader(const std::string &className, SearchFilter &filter);
+ private:
+  MClass *DoCreateArrayClass(MClass &klass, MClass &componentClass, const std::string &name);
+  void LinkStartUpAndMultiSo(std::vector<LinkerMFileInfo*> &mplInfoList, bool hasStartup);
+  const std::string kAppSoPostfix = "/maple/arm64/mapleclasses.so";
+  const std::string kAppPartialSoPostfix = "/maple/arm64/maplepclasses.so";
+  const std::string kSystemLibPath = "/system/lib64";
+  const std::string kIgnoreJarList = "core-oj.jar:core-libart.jar";
+  const static uint16_t kClIndexUnInit = static_cast<uint16_t>(-1);
+  // boot mplfile list
+  FileAdapter mMplFilesBoot;
+  // DEX classloader list
+  FileAdapter mMplFilesOther;
+  // Mapping classloader for multiple loading .so
+  std::unordered_multimap<std::string, std::pair<MObject*, MObject*>> mMappedClassLoader;
+};
+} // namespace maplert
+#endif // MRT_CLASS_LOCATOR_MANAGER_H_
diff --git a/src/mrt/maplert/include/mrt_cyclequeue.h b/src/mrt/maplert/include/mrt_cyclequeue.h
new file mode 100644
index 0000000000000000000000000000000000000000..20b8e9f01bc3696570afb1e8e3589e2e7d9f334e
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_cyclequeue.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_CYCLEQUEUE_H_
+#define MRT_CYCLEQUEUE_H_
+#include <queue>
+
+namespace maplert {
+template<typename T>
+class CycleQueue {
+ public:
+  CycleQueue() : frontIndex(0), rearIndex(0) {}
+
+  ~CycleQueue() {
+    if (UNLIKELY(queueBuffer != nullptr)) {
+      delete queueBuffer;
+    }
+  }
+
+  inline bool Empty() const {
+    return (queueBuffer == nullptr) ? EmptyArray() : EmptyQueue();
+  }
+
+  inline void Push(T ele) {
+    if (LIKELY(queueBuffer == nullptr)) {
+      if (PushArray(ele)) {
+        return;
+      } else {
+        // cycle array is full, move to std::queue
+        CopyElementToQueue();
+      }
+    }
+    PushQueue(ele);
+  }
+
+  inline void Pop() {
+    if (LIKELY(queueBuffer == nullptr)) {
+      PopArray();
+    } else {
+      PopQueue();
+    }
+  }
+
+  inline T Front() {
+    return (queueBuffer == nullptr) ? FrontArray() : FrontQueue();
+  }
+
+  static constexpr uint16_t kMaxSize = 30;
+  uint16_t frontIndex;
+  uint16_t rearIndex;
+  T arrayBuffer[kMaxSize];
+  std::queue<T> *queueBuffer = nullptr;
+
+ private:
+  inline bool EmptyArray() const {
+    return frontIndex == rearIndex;
+  }
+
+  inline bool PushArray(T ele) {
+    uint16_t tmpRear = (rearIndex + 1) % kMaxSize;
+    if (UNLIKELY(frontIndex == tmpRear)) {
+      return false;
+    }
+    arrayBuffer[rearIndex] = ele;
+    rearIndex = tmpRear;
+    return true;
+  }
+
+  // just adjust index, no pop value
+  inline void PopArray() {
+    frontIndex = (frontIndex + 1) % kMaxSize;
+  }
+
+  inline T FrontArray() {
+    return arrayBuffer[frontIndex];
+  }
+
+  inline bool EmptyQueue() const {
+    return queueBuffer->empty();
+  }
+
+  inline void PushQueue(T ele) {
+    queueBuffer->push(ele);
+  }
+
+  inline void PopQueue() {
+    queueBuffer->pop();
+  }
+
+  inline T FrontQueue() {
+    return queueBuffer->front();
+  }
+
+  inline void CopyElementToQueue() {
+    queueBuffer = new (std::nothrow) std::queue<T>;
+    CHECK(queueBuffer != nullptr) << "queueBuffer is nullptr" << maple::endl;
+    while (!EmptyArray()) {
+      PushQueue(FrontArray());
+      PopArray();
+    }
+  }
+};
+}
+
+#endif // MRT_CYCLEQUEUE_H_
diff --git a/src/mrt/maplert/include/mrt_handlecommon.h b/src/mrt/maplert/include/mrt_handlecommon.h
new file mode 100644
index 0000000000000000000000000000000000000000..0846bdafc2fa4e608bf9711672f1d2744a677fae
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_handlecommon.h
@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_HANDLECOMMON
+#define MAPLE_RUNTIME_HANDLECOMMON
+
+#include <jni.h>
+#include <iostream>
+#include <algorithm>
+#include <mutex>
+#include "cpphelper.h"
+#include "chelper.h"
+#include "mrt_libs_api.h"
+#include "exception/mrt_exception.h"
+#include "mrt_well_known.h"
+#include "mrt_primitive_util.h"
+namespace maplert{
+MClass *GetDcClasingFromFrame();
+void ParseSignatrueType(char *descriptor, const char *&methodSig);
+
+string GeneIllegalArgumentExceptionString(const MClass *from, const MClass *to);
+
+string GeneClassCastExceptionString(const MClass *from, const MClass *to) ;
+
+bool GetPrimShortType(const MClass *klass, char &type);
+
+bool CheckPrimitiveCanBoxed(char shortType);
+
+bool GetPrimShortTypeAndValue(const MObject *o, char &type, jvalue &value, const MClass *fromType);
+
+using DoubleLongConvert = union {
+  jlong j;
+  jdouble d;
+};
+using FloatIntConvert = union {
+  jint i;
+  jfloat f;
+};
+using FloatDoubleConvert = union {
+  jdouble d;
+  jfloat f;
+};
+
+
+class Arg {
+ public:
+  virtual jint GetJint() = 0;
+  virtual jfloat GetJfloat() = 0;
+  virtual jdouble GetJdouble() = 0;
+  virtual jlong GetJlong() = 0;
+  virtual MObject *GetObject() = 0;
+  virtual ~Arg() = default;
+};
+
+class VArg : public Arg {
+ public:
+  VArg(va_list ag) : args(ag) {}
+  jint GetJint() noexcept {
+    return va_arg(args, int);
+  }
+  jfloat GetJfloat() noexcept {
+    FloatDoubleConvert u;
+    u.d = va_arg(args, double);
+    return u.f;
+  }
+  jdouble GetJdouble() noexcept {
+    return va_arg(args, double);
+  }
+  jlong GetJlong() noexcept {
+    return va_arg(args, jlong);
+  }
+  MObject *GetObject() noexcept {
+    return reinterpret_cast<MObject*>(va_arg(args, MObject*));
+  }
+  virtual ~VArg() = default;
+ private:
+  va_list args;
+};
+
+class JValueArg : public Arg {
+ public:
+  JValueArg(jvalue *ag) : args(ag) {}
+  jint GetJint() noexcept {
+    return args[idx++].i;
+  }
+  jfloat GetJfloat() noexcept {
+    return args[idx++].f;
+  }
+  jdouble GetJdouble() noexcept {
+    return args[idx++].d;
+  }
+  jlong GetJlong() noexcept {
+    return args[idx++].j;
+  }
+  MObject *GetObject() noexcept {
+    return reinterpret_cast<MObject*>(args[idx++].l);
+  }
+  virtual ~JValueArg() {
+    args = nullptr;
+  }
+ private:
+  uint32_t idx = 0;
+  jvalue *args;
+};
+
+class Arm32Arg : public Arg {
+ public:
+  Arm32Arg(int32_t *params) : args(params) {}
+  jint GetJint() noexcept {
+    if (gRegIdx <= gRegMaxIdx) {
+      return *static_cast<jint*>(args + gRegIdx++);
+    }
+    return *static_cast<jint*>(args + stackIdx++);
+  }
+  jfloat GetJfloat() noexcept {
+    if (dRegIdx <= dRegMaxIdx) {
+      return *reinterpret_cast<jfloat*>(args + dRegIdx++);
+    }
+    return *reinterpret_cast<jfloat*>(args + stackIdx++);
+  }
+  jdouble GetJdouble() noexcept {
+    if ((dRegIdx <= dRegMaxIdx) && (dRegIdx & 1)) {
+      ++dRegIdx;
+    }
+    if (dRegIdx <= dRegMaxIdx) {
+      jdouble val = *reinterpret_cast<jdouble*>(args + dRegIdx);
+      dRegIdx = dRegIdx + kEightBytes;
+      return val;
+    }
+
+    if (stackIdx & 1) {
+      ++stackIdx;
+    }
+    jdouble val = *reinterpret_cast<jdouble*>(args + stackIdx);
+    stackIdx += kEightBytes;
+    return val;
+  }
+
+  jlong GetJlong() noexcept {
+    if (stackIdx & 1) {
+      ++stackIdx;
+    }
+    jlong val = *reinterpret_cast<jlong*>(args + stackIdx);
+    stackIdx += kEightBytes;
+    return val;
+  }
+
+  MObject *GetObject() noexcept {
+    return reinterpret_cast<MObject*>(GetJint());
+  }
+
+  virtual ~Arm32Arg() {
+    args = nullptr;
+  }
+
+ private:
+  constexpr static uint8_t kEightBytes = 2;
+  uint16_t gRegIdx = 0;
+  constexpr static uint8_t gRegMaxIdx = 3;
+  constexpr static uint8_t dRegIdxStart = 4;
+  constexpr static uint8_t dRegMaxIdx = 18;
+  uint16_t dRegIdx = dRegIdxStart;
+  constexpr static uint8_t stackStartIdx = 20;
+  uint16_t stackIdx = stackStartIdx;
+  int32_t *args;
+};
+
+class Arm32SoftFPArg : public Arg {
+ public:
+  Arm32SoftFPArg(int32_t *params) : args(params) {}
+  jint GetJint() noexcept {
+    if (gRegIdx <= gRegMaxIdx) {
+      return *static_cast<jint*>(args + gRegIdx++);
+    }
+    return *static_cast<jint*>(args + stackIdx++);
+  }
+  jfloat GetJfloat() noexcept {
+    if (gRegIdx <= gRegMaxIdx) {
+      return *reinterpret_cast<jfloat*>(args + gRegIdx++);
+    }
+    return *reinterpret_cast<jfloat*>(args + stackIdx++);
+  }
+  jdouble GetJdouble() noexcept {
+    if ((gRegIdx <= gRegMaxIdx) && (gRegIdx & 1)) {
+      ++gRegIdx;
+    }
+    if (gRegIdx == gRegMaxIdx) {
+      ++gRegIdx;
+    }
+    if (gRegIdx <= gRegMaxIdx) {
+      jdouble val = *reinterpret_cast<jdouble*>(args + gRegIdx);
+      gRegIdx = gRegIdx + kEightBytes;
+      return val;
+    }
+
+    if (stackIdx & 1) {
+      ++stackIdx;
+    }
+    jdouble val = *reinterpret_cast<jdouble*>(args + stackIdx);
+    stackIdx += kEightBytes;
+    return val;
+  }
+
+  jlong GetJlong() noexcept {
+    if (stackIdx & 1) {
+      ++stackIdx;
+    }
+    jlong val = *reinterpret_cast<jlong*>(args + stackIdx);
+    stackIdx += kEightBytes;
+    return val;
+  }
+
+  MObject *GetObject() noexcept {
+    return reinterpret_cast<MObject*>(GetJint());
+  }
+
+  virtual ~Arm32SoftFPArg() {
+    args = nullptr;
+  }
+
+ private:
+  constexpr static uint8_t kEightBytes = 2;
+  uint16_t gRegIdx = 0;
+  constexpr static uint8_t gRegMaxIdx = 3;
+  constexpr static uint8_t stackStartIdx = 4;
+  uint16_t stackIdx = stackStartIdx;
+  int32_t *args;
+};
+
+class ArgsWrapper {
+ public:
+  ArgsWrapper(Arg &ag) : arg(ag) {}
+  ~ArgsWrapper() = default;
+  jint GetJint() const noexcept {
+    return arg.GetJint();
+  }
+  jfloat GetJfloat() const noexcept {
+    return arg.GetJfloat();
+  }
+  jdouble GetJdouble() const noexcept {
+    return arg.GetJdouble();
+  }
+  jlong GetJlong() const noexcept {
+    return arg.GetJlong();
+  }
+  MObject *GetObject() const noexcept {
+    return arg.GetObject();
+  }
+ private:
+  Arg &arg;
+};
+
+class MethodType {
+ public:
+  MethodType(const MObject *methodTypeObj) {
+    MArray *ptypesVal =
+        reinterpret_cast<MArray*>(methodTypeObj->LoadObject(WellKnown::GetMFieldMethodHandlePTypesOffset()));
+    returnType =
+        reinterpret_cast<MClass*>(methodTypeObj->LoadObjectNoRc(WellKnown::GetMFieldMethodHandlepRTypeOffset()));
+    uint32_t num = ptypesVal->GetLength();
+    for (uint32_t i = 0; i < num; ++i) {
+      paramsType.push_back(static_cast<MClass*>(ptypesVal->GetObjectElementNoRc(i)));
+    }
+    RC_LOCAL_DEC_REF(ptypesVal);
+    typesArrSize = static_cast<uint32_t>(paramsType.size());
+    typesArr = nullptr;
+  }
+  MethodType(const MethodType&) = default;
+  MethodType& operator=(const MethodType&) = default;
+  std::string ToString() const noexcept;
+  ALWAYS_INLINE const MClass *GetReTType() const {
+    return returnType;
+  }
+  ALWAYS_INLINE const vector<MClass*> &GetParamsType() const noexcept {
+    return paramsType;
+  }
+  ALWAYS_INLINE uint32_t GetTypesArraySize() const noexcept {
+    return typesArrSize;
+  }
+  ALWAYS_INLINE MClass **GetTypesArray() {
+    if (typesArr == nullptr) {
+      typesArr = static_cast<MClass**>(malloc((paramsType.size() + 1) * sizeof(MClass*)));
+      if (typesArr == nullptr) {
+        LOG(ERROR) << "GetTypesArray malloc error" << maple::endl;
+      }
+    }
+    int idx = 0;
+    for (auto it = paramsType.begin(); it != paramsType.end(); ++it) {
+      typesArr[idx++] = *it;
+    }
+    typesArr[idx] = returnType;
+    return typesArr;
+  }
+  ~MethodType() {
+    if (typesArr != nullptr) {
+      free(typesArr);
+    }
+    returnType = nullptr;
+    typesArr = nullptr;
+  }
+
+ private:
+  MClass *returnType;
+  vector<MClass*> paramsType;
+  MClass **typesArr;
+  uint32_t typesArrSize;
+};
+
+void FillArgsInfoNoCheck(const ArgsWrapper&, const char *typesMark, uint32_t arrSize,
+                         BaseArgValue &paramArray, uint32_t begin = 0);
+void DoInvoke(const MethodMeta &method, jvalue &result, ArgValue &paramArray);
+}
+#endif
diff --git a/src/mrt/maplert/include/mrt_handleutil.h b/src/mrt/maplert/include/mrt_handleutil.h
new file mode 100644
index 0000000000000000000000000000000000000000..314afde3d2e8d7176a192e448f70363ce77bd7d2
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_handleutil.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_HANDLEUTIL
+#define MAPLE_RUNTIME_HANDLEUTIL
+
+#include "mrt_methodhandle.h"
+#include "mrt_handlecommon.h"
+namespace maplert {
+struct ConvertJStruct {
+  MClass **parameterTypes;
+  uint32_t arraySize;
+  jvalue *value;
+};
+struct TypeInfo {
+  MClass **types;
+  char *typesMark;
+};
+
+bool ConvertJvalue(ConvertJStruct&, const MethodHandle&, const MClass *from, const MClass *to, bool needDec = false);
+
+bool ConvertParams(CallParam&, const MethodHandle&, const ArgsWrapper&, BaseArgValue&, ScopedHandles&);
+
+string GeneExceptionString(const MethodHandle &mh, MClass **parameterTypes, uint32_t arraySize);
+
+bool ConvertReturnValue(const MethodHandle &mh, MClass **paramTypes, uint32_t arraySize, jvalue &value);
+
+void IsConvertibleOrThrow(uint32_t arraySize, const MethodHandle &mh, MClass **paramTypes, uint32_t paramNum);
+
+bool ClinitCheck(const MClass *mplFieldOrMethod);
+
+static inline bool IsConvertible(const MethodHandle &mh, uint32_t arraySize) {
+  const MethodType *methodTypeMplObj = mh.GetMethodTypeMplObj();
+  vector<MClass*> ptypesVal = methodTypeMplObj->GetParamsType();
+  if (arraySize - 1 != ptypesVal.size()) {
+    return false;
+  }
+  return true;
+}
+
+void GetParameterAndRtType(MClass **types, char *typesMark, MString *protoStr, SizeInfo &sz,
+                           const MClass *declareClass);
+jvalue PolymorphicCallEnter(const MString *calleeStr, const MString*,
+                            uint32_t, MObject *mhObj, Arg&, const MClass *declareClass = nullptr);
+MClass *GetContextCls(Arg &arg, MString *&calleeName);
+
+#if defined(__arm__)
+extern "C" int64_t PolymorphicCallEnter32(int32_t *args);
+#endif
+}
+#endif
diff --git a/src/mrt/maplert/include/mrt_linker.h b/src/mrt/maplert/include/mrt_linker.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8f65bf8379b976e7d017e574d763cc440fd4f24
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_linker.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_CLASS_MPLLINKER_IMPL_H_
+#define MRT_CLASS_MPLLINKER_IMPL_H_
+
+#include "jni.h"
+#include "linker_api.h"
+#include "linker/linker_model.h"
+#include "linker/linker.h"
+#include "linker/linker_inline.h"
+#include "linker/linker_hotfix.h"
+#include "linker/linker_debug.h"
+#include "linker/linker_cache.h"
+#include "linker/linker_method_builder.h"
+#ifdef LINKER_DECOUPLE
+#include "linker/decouple/linker_decouple.h"
+#endif
+#include "linker/linker_lazy_binding.h"
+
+namespace maplert {
+class MplLinkerImpl : public LinkerInvoker {
+ public:
+  MplLinkerImpl();
+  ~MplLinkerImpl() = default;
+ private:
+  Linker linkerFeature;
+  Hotfix hotfixFeature;
+  MethodBuilder methodBuilderFeature;
+#ifdef LINKER_DECOUPLE
+  Decouple decoupleFeature;
+#endif
+  LazyBinding lazyBindingFeature;
+#ifdef LINKER_RT_CACHE
+  LinkerCache linkerCacheFeature;
+#endif // LINKER_RT_CACHE
+  Debug debugFeature;
+};
+} // namespace maplert
+#endif // MRT_CLASS_MPLLINKER_IMPL_H_
diff --git a/src/mrt/maplert/include/mrt_methodhandle.h b/src/mrt/maplert/include/mrt_methodhandle.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe75bdd2b4b4ab7e7bfcb02cec2913c939a30dd1
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_methodhandle.h
@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_METHODHANDLE
+#define MAPLE_RUNTIME_METHODHANDLE
+#include <jni.h>
+#include <iostream>
+#include <algorithm>
+#include <mutex>
+#include "cpphelper.h"
+#include "chelper.h"
+#include "mrt_libs_api.h"
+#include "exception/mrt_exception.h"
+#include "mrt_well_known.h"
+#include "mrt_primitive_util.h"
+#include "mrt_handlecommon.h"
+#include "mstring_inline.h"
+namespace maplert {
+enum Kind : uint32_t {
+  kVirtualCall = 0,
+  kSuperCall,
+  kDirectCall,
+  kStaticCall,
+  kInterfaceCall,
+  kTransformCall,
+  kCallSiteTransformCall,
+  kInstanceGet = 9,
+  kInstancePut,
+  kStaticGet,
+  kStaticPut,
+};
+struct SizeInfo {
+  SizeInfo(uint32_t paramNum) : refNum(0), byteArrSize(0) {
+    arraySize = paramNum + 1;
+  }
+  uint32_t arraySize;
+  uint32_t refNum;
+  uint32_t byteArrSize;
+};
+struct CallParam {
+  uint32_t paramNum;
+  bool isExactMatched;
+  MClass **paramTypes;
+  char *typesMark;
+  bool isStaticMethod;
+  uint8_t beginIndex;
+  uint32_t arraySize;
+  uint32_t dregSize;
+};
+
+class EmStackFrame {
+ public:
+  EmStackFrame(MObject *emStackFrameObj) : emStackFrameJavaObj(emStackFrameObj) {}
+  ~EmStackFrame() {}
+  EmStackFrame(const EmStackFrame&) = default;
+  ALWAYS_INLINE uint32_t GetStackFrameNativeBytesCount() const noexcept {
+    MArray *stackFrameByteArray = reinterpret_cast<MArray*>(LoadRefField(
+        reinterpret_cast<address_t>(emStackFrameJavaObj), WellKnown::GetMFieldEmStackFrameStackFrameOffset()));
+    return stackFrameByteArray->GetLength();
+  }
+  ALWAYS_INLINE int8_t *GetStackFrameNativeBytes() const noexcept {
+    MArray *stackFrameByteArray = reinterpret_cast<MArray*>(LoadRefField(
+        reinterpret_cast<address_t>(emStackFrameJavaObj), WellKnown::GetMFieldEmStackFrameStackFrameOffset()));
+    int8_t *cArray = reinterpret_cast<int8_t*>(stackFrameByteArray->ConvertToCArray());
+    return cArray;
+  }
+  ALWAYS_INLINE MObject *GetReferencesReturnObj() const noexcept {
+    MArray *refArray = reinterpret_cast<MArray*>(LoadRefField(
+        reinterpret_cast<address_t>(emStackFrameJavaObj), WellKnown::GetMFieldEmStackFrameReferencesOffset()));
+    uint32_t idx = refArray->GetLength() - 1;
+    MObject *elem = refArray->GetObjectElementNoRc(idx);
+    return elem;
+  }
+  ALWAYS_INLINE MObject *GetReferencesObj(uint32_t idx) const noexcept {
+    MArray *refArray = reinterpret_cast<MArray*>(LoadRefField(
+        reinterpret_cast<address_t>(emStackFrameJavaObj), WellKnown::GetMFieldEmStackFrameReferencesOffset()));
+    if (idx >= refArray->GetLength()) {
+      return nullptr;
+    }
+    MObject *elem = refArray->GetObjectElementNoRc(idx);
+    return elem;
+  }
+  ALWAYS_INLINE void PutReferencesObj(const MObject *obj, uint32_t idx) const noexcept {
+    MArray *refArray = reinterpret_cast<MArray*>(LoadRefField(
+        reinterpret_cast<address_t>(emStackFrameJavaObj), WellKnown::GetMFieldEmStackFrameReferencesOffset()));
+    refArray->SetObjectElement(idx, obj);
+  }
+
+ private:
+  MObject *emStackFrameJavaObj;
+};
+
+class MethodHandle {
+ public:
+  Arg &args;
+  MethodHandle(MObject *methodHandleObj, Arg &argsP) : args(argsP), methodHandleJavaObj(methodHandleObj) {
+    validMethodTypeMplObjCache = nullptr;
+    handleKind = static_cast<Kind>(MRT_LOAD_JINT(methodHandleObj, WellKnown::GetMFieldMethodHandleHandleKindOffset()));
+    MObject *methodTypeObj = GetMethodTypeJavaObj();
+    mplFieldOrMethod = reinterpret_cast<MObject*>(
+        MRT_LOAD_JLONG(methodHandleObj, WellKnown::GetMFieldMethodHandleArtFieldOrMethodOffset()));
+    MObject *nominalType = GetNominalTypeJavaObj();
+    if (nominalType != nullptr) {
+      validMethodTypeMplObjCache = new MethodType(nominalType);
+      methodTypeMplObjCache = new MethodType(methodTypeObj);
+    } else {
+      validMethodTypeMplObjCache = new MethodType(methodTypeObj);
+      methodTypeMplObjCache = validMethodTypeMplObjCache;
+    }
+    handleClassType = methodHandleObj->GetClass();
+  }
+  ~MethodHandle() {
+    if (GetNominalTypeJavaObj() != nullptr) {
+      delete validMethodTypeMplObjCache;
+      delete methodTypeMplObjCache;
+    } else {
+      delete validMethodTypeMplObjCache;
+    }
+  }
+  MethodHandle(const MethodHandle&) = default;
+  bool FieldSGet(MClass **parameterTypes, bool doConvert, uint32_t arraySize, jvalue &result);
+  bool FieldAccess(MClass **parameterTypes, bool doConvert, uint32_t arraySize, jvalue &result);
+  void DirectCall(CallParam paramStruct, jvalue &result);
+  bool FillInvokeArgs(
+      const ArgsWrapper &argsWrapper, CallParam &paramStruct, BaseArgValue &paramArray, ScopedHandles&) const;
+  bool NoParamFastCall(CallParam &paramStruct, jvalue &result);
+  bool InvokeWithEmStackFrame(MObject *emStFrameObj, jvalue &result);
+  jvalue InvokeMethodNoParameter(MObject *obj, MethodMeta &mthd);
+  ALWAYS_INLINE MObject *GetMethodTypeJavaObj() const noexcept {
+    return reinterpret_cast<MObject*>(
+        LoadRefField(reinterpret_cast<address_t>(methodHandleJavaObj), WellKnown::GetMFieldMethodHandleTypeOffset()));
+  }
+  ALWAYS_INLINE const MethodType *GetMethodTypeMplObj() const noexcept {
+    return methodTypeMplObjCache;
+  }
+  ALWAYS_INLINE const MethodType *GetValidMethodTypeMplObj() const noexcept {
+    return validMethodTypeMplObjCache;
+  }
+  ALWAYS_INLINE Kind GetHandleKind() const noexcept {
+    return handleKind;
+  }
+  ALWAYS_INLINE MethodMeta *GetMethodMeta() const noexcept {
+    return reinterpret_cast<MethodMeta*>(mplFieldOrMethod);
+  }
+  ALWAYS_INLINE FieldMeta *GetFieldMeta() const noexcept {
+    return reinterpret_cast<FieldMeta*>(mplFieldOrMethod);
+  }
+  ALWAYS_INLINE MObject *GetNominalTypeJavaObj() const noexcept {
+    return reinterpret_cast<MObject*>(LoadRefField(
+        reinterpret_cast<address_t>(methodHandleJavaObj), WellKnown::GetMFieldMethodHandleNominalTypeOffset()));
+  }
+  ALWAYS_INLINE const MClass *GetHandleJClassType() const noexcept {
+    return handleClassType;
+  }
+  ALWAYS_INLINE const MObject *GetHandleJavaObj() const noexcept {
+    return methodHandleJavaObj;
+  }
+  ALWAYS_INLINE MethodMeta *GetRealMethod(MObject *obj) const noexcept;
+  ALWAYS_INLINE bool ExactInvokeCheck(const MString *calleeName, MClass **parameterTypes, uint32_t) const;
+  ALWAYS_INLINE bool InvokeTransform(const SizeInfo&, const char *mark, MClass **paramTypes, jvalue &retVal);
+
+  string ValidTypeToString() const noexcept;
+  static MObject *GetMemberInternal(const MObject *methodHandle);
+  ALWAYS_INLINE bool ParamsConvert(const MClass *from, const MClass *to, MClass**,
+                                   uint32_t arraySize, jvalue &internVal) const;
+
+ private:
+  bool FieldGet(MClass **parameterTypes, bool doConvert, uint32_t arraySize, jvalue &result);
+  bool FieldPut(MClass **parameterTypes, bool doConvert, uint32_t arraySize);
+  bool FieldSPut(MClass **parameterTypes, bool doConvert, uint32_t arraySize);
+  ALWAYS_INLINE void GetValFromVargs(jvalue &value, char shortFieldTypee);
+  ALWAYS_INLINE char GetReturnTypeMark(char markInProto) const noexcept;
+  ALWAYS_INLINE bool IsExactMatch() const noexcept;
+  ALWAYS_INLINE bool IsExactMatch(MClass **types, uint32_t arraySize, bool isNominal = false) const noexcept;
+  void InvokeTransformVirtualMethod(MObject *emStFrameObj, jvalue &retVal) const;
+  MObject *CreateEmStackFrame(const MArray *bArray, const MObject *refArray, MClass **types, uint32_t arraySize) const;
+  bool FillEmStackFrameArray(const char *mark, MClass **paramTypes, int8_t *cArray, const MArray*);
+
+  static constexpr char kInvokeMtd[] =
+      "Ljava_2Flang_2Finvoke_2FMethodHandle_3B_7Cinvoke_7C_28ALjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B";
+  static constexpr char kInvokeExactMtd[] =
+      "Ljava_2Flang_2Finvoke_2FMethodHandle_3B_7CinvokeExact_7C_28ALjava_2Flang_2FObject_3B_29Ljava_2Flang_2FObject_3B";
+
+  MObject *methodHandleJavaObj;
+  Kind handleKind;
+  MObject *mplFieldOrMethod;
+  MethodType *validMethodTypeMplObjCache;  // return nominal if nominal exist, or methodType
+  MethodType *methodTypeMplObjCache;
+  MClass *handleClassType;
+  uint32_t emByteIdx = 0;
+  uint32_t realParamNum = 0;
+};
+
+class EmStackFrameInvoker {
+ public:
+  EmStackFrameInvoker(MObject *frameObj, MethodHandle &handle) : emStFrameObj(frameObj), methodHandleMplObj(handle) {
+    emStackFrameMplObj = new EmStackFrame(emStFrameObj);
+    MObject *calleeMethodType = reinterpret_cast<MObject*>(
+        emStFrameObj->LoadObjectNoRc(WellKnown::GetMFieldEmStackFrameCallsiteOffset()));
+    calleeMethodTypeMplObj = new MethodType(calleeMethodType);
+    typesArr = calleeMethodTypeMplObj->GetTypesArray();
+    paramLength = calleeMethodTypeMplObj->GetTypesArraySize();
+
+    mplFieldOrMethodMeta = methodHandleMplObj.GetMethodMeta();
+    callerType = methodHandleMplObj.GetMethodTypeJavaObj();
+    callerTypeMplObj = new MethodType(callerType);
+    ptypesOfHandle = &callerTypeMplObj->GetParamsType();
+  }
+  ~EmStackFrameInvoker() {
+    delete emStackFrameMplObj;
+    delete calleeMethodTypeMplObj;
+    delete callerTypeMplObj;
+  }
+  bool Invoke(jvalue &result);
+
+ private:
+  bool InvokeInterpMethod(jvalue &result, MethodMeta &realMethod);
+  bool InvokeStaticCmpileMethod(jvalue &result, const MethodMeta &realMethod);
+  ALWAYS_INLINE bool FillParamsForEmStackFrame(BaseArgValue &paramArray);
+
+  MObject *emStFrameObj;
+  MethodHandle &methodHandleMplObj;
+  EmStackFrame *emStackFrameMplObj;
+
+  // typesinfo from callee
+  MethodType *calleeMethodTypeMplObj;
+  MClass **typesArr;
+  uint32_t paramLength;
+
+  // info of mpl field or method
+  const MethodMeta *mplFieldOrMethodMeta;
+
+  // info of caller
+  MObject *callerType;
+  MethodType *callerTypeMplObj;
+  const vector<MClass*> *ptypesOfHandle;
+
+  uint32_t byteIdx = 0;
+  uint32_t refIdx = 0;
+};
+
+static std::unordered_map<string, MethodMeta*> StringToStringFactoryMap = {};
+static std::set<string> stringInitMethodSet = { "newEmptyString",
+                                                "newStringFromBytes",
+                                                "newStringFromChars",
+                                                "newStringFromString",
+                                                "newStringFromStringBuffer",
+                                                "newStringFromCodePoints",
+                                                "newStringFromStringBuilder" };
+static std::mutex mtx;
+MethodMeta *RefineTargetMethod(Kind handleKind, MethodMeta *method, const MClass *referClass);
+
+class EMSFWriter {
+ public:
+  static void WriteByMark(char mark, int8_t *cArray, uint32_t &byteIdx, const jvalue &val, bool isDec = false);
+ private:
+  static inline void WriteToEmStackFrame(int8_t *array, uint32_t &idx, int32_t value) {
+    *reinterpret_cast<int*>(array + idx) = value;
+    idx += sizeof(int);
+  }
+  static inline void WriteToEmStackFrame(int8_t *array, uint32_t &idx, int64_t value) {
+    *reinterpret_cast<jlong*>(array + idx) = value;
+    idx += sizeof(jlong);
+  }
+  static inline void WriteToEmStackFrame(int8_t *array, uint32_t &idx, float value) {
+    *reinterpret_cast<float*>(array + idx) = value;
+    idx += sizeof(float);
+  }
+  static inline void WriteToEmStackFrame(int8_t *array, uint32_t &idx, double value) {
+    *reinterpret_cast<double*>(array + idx) = value;
+    idx += sizeof(double);
+  }
+};
+
+class EMSFReader {
+ public:
+  static jvalue GetRetValFromEmStackFrame(const MArray *refArray, uint32_t refNum, uint32_t, const int8_t*, char);
+  static inline int32_t GetIntFromEmStackFrame(const int8_t *array, uint32_t &idx) {
+    const uint32_t val = *reinterpret_cast<const uint32_t*>(array + idx);
+    idx += sizeof(int);
+    return val;
+  }
+  static inline int64_t GetLongFromEmStackFrame(const int8_t *array, uint32_t &idx) {
+    const int64_t val = *reinterpret_cast<const int64_t*>(array + idx);
+    idx += sizeof(jlong);
+    return val;
+  }
+};
+
+static inline bool IsCallerTransformerCStr(uint32_t paramNum, const std::string protoString) {
+  if (paramNum == 1 && strstr(protoString.c_str(), "(Ldalvik/system/EmulatedStackFrame;)") != nullptr) {
+    return true;
+  }
+  return false;
+}
+
+static inline bool IsCallerTransformerJStr(uint32_t paramNum, const MString *protoString) {
+  std::string protoStr(reinterpret_cast<char*>(protoString->GetContentsPtr()));
+  return IsCallerTransformerCStr(paramNum, protoStr);
+}
+
+inline bool IsFieldAccess(Kind handleKind) {
+  return (handleKind >= Kind::kInstanceGet && handleKind <= Kind::kStaticPut);
+}
+
+void DoCalculate(char name, uint32_t &byteArrSize, uint32_t &refNum);
+
+static inline void CalcFrameSize(const MClass *rType, vector<MClass*> &ptypes, uint32_t &byteSz, uint32_t &refNum) {
+  size_t size = ptypes.size();
+  for (size_t i = 0; i < size; ++i) {
+    MClass *type = ptypes[i];
+    const char *name = type->GetName();
+    DoCalculate(*name, byteSz, refNum);
+  }
+  DoCalculate(*rType->GetName(), byteSz, refNum);
+}
+
+#define STATEMENTCHECK(statement) \
+  if (statement) {                \
+    return false;                 \
+  }
+}
+#endif
diff --git a/src/mrt/maplert/include/mrt_methodhandle_mpl.h b/src/mrt/maplert/include/mrt_methodhandle_mpl.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad08f18945b5e6fd7dbb19a524f5e9452e6cf296
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_methodhandle_mpl.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_METHODHANDLEMPL
+#define MAPLE_RUNTIME_METHODHANDLEMPL
+
+#include <jni.h>
+#include <iostream>
+#include <algorithm>
+#include <mutex>
+#include "cpphelper.h"
+#include "chelper.h"
+#include "mrt_libs_api.h"
+#include "exception/mrt_exception.h"
+#include "mrt_well_known.h"
+#include "mrt_primitive_util.h"
+#include "mrt_handlecommon.h"
+namespace maplert {
+enum class OptionFlag : int32_t {
+  kFinal,
+  kDropArguments,
+  kFilterReturnValue,
+  kBindto,
+  kPermuteArguments
+};
+
+jvalue MethodHandleCallEnter(MString *calleeName, MString*, uint32_t paramNum,
+                             MObject *methodHandle, VArg &args, const MClass *declareClass);
+
+class MethodHandleMpl {
+ public:
+  MethodHandleMpl(MObject *obj, bool isExact) :methodHandle(obj), isInvokeExact(isExact) {
+    // maybe need check the array length
+    dataArray =
+        reinterpret_cast<MArray*>(methodHandle->LoadObjectNoRc(WellKnown::GetMFieldMethodHandleDataArrayOffset()));
+    metaArray =
+        reinterpret_cast<MArray*>(methodHandle->LoadObjectNoRc(WellKnown::GetMFieldMethodHandleMetaArrayOffset()));
+    opArray =
+        reinterpret_cast<MArray*>(methodHandle->LoadObjectNoRc(WellKnown::GetMFieldMethodHandleOpArrayOffset()));
+    typeArray =
+        reinterpret_cast<MArray*>(methodHandle->LoadObjectNoRc(WellKnown::GetMFieldMethodHandleTypeArrayOffset()));
+    transformNum =
+        static_cast<uint32_t>(maplert::MRT_LOAD_JINT(methodHandle, WellKnown::GetMFieldMethodHandleIndexOffset()));
+  }
+  ~MethodHandleMpl() = default;
+  static bool IsExactInvoke(MString *calleeName) {
+    constexpr char kInvokeExact[] =
+        "Ljava_2Flang_2Finvoke_2FMethodHandle_3B_7CinvokeExact_7C_28ALjava_2Flang_2FObject_3B_29" \
+        "Ljava_2Flang_2FObject_3B";
+    if (!strcmp(MRT_GetStringContentsPtrRaw(reinterpret_cast<jstring>(calleeName)), kInvokeExact)) {
+      return true;
+    }
+    return false;
+  }
+
+  void CheckReturnType();
+  string GeneNoSuchMethodExceptionString(const MethodType &methodType, const MethodMeta &method);
+  jvalue invoke(vector<jvalue>&paramPtr, uint32_t paramNum, vector<char>&typesMarkPtr, vector<MClass*>&paramTypes,
+                bool convertRetVal = true);
+ private:
+  MethodMeta *GetMeta(uint32_t index) const {
+    MethodMeta *type = reinterpret_cast<MethodMeta*>(metaArray->GetObjectElementNoRc(index));
+    return type;
+  }
+  bool CheckParamsType(vector<MClass*> &cSTypes, uint32_t csTypesNum, vector<jvalue>&, uint32_t, bool checkRet = true);
+  void PrepareVarg(vector<jvalue> &paramPtr, vector<char> &typesMark, vector<MClass*> &cSTypes, uint32_t &csTypesNum);
+  jvalue FilterReturnValue(vector<jvalue>&, const uint32_t, const MObject*, vector<char>&, vector<MClass*>&);
+  MObject *methodHandle;
+  MArray *dataArray;
+  MArray *metaArray;
+  MArray *opArray;
+  MArray *typeArray;
+  uint32_t transformNum;
+  bool isInvokeExact;
+};
+}
+#endif
diff --git a/src/mrt/maplert/include/mrt_object.h b/src/mrt/maplert/include/mrt_object.h
new file mode 100644
index 0000000000000000000000000000000000000000..7705cd436006be7e4c026c28dedc91fe174b5eea
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_object.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef JAVA_MRT_OBJECT_H_
+#define JAVA_MRT_OBJECT_H_
+#include "mobject.h"
+#include "base/logging.h"
+
+namespace maplert {
+uint32_t GetObjectDWordSize(const MObject &obj);
+
+inline void *MRT_GetAddress32ByAddress(uint64_t *addr) {
+  DCHECK(addr != nullptr) << "MRT_GetAddress32ByAddress: addr is nullptr!" << maple::endl;
+  return reinterpret_cast<void*>(uint64_t{ *reinterpret_cast<uint32_t*>(addr) });
+}
+
+inline void *MRT_GetAddressByAddress(uint64_t *addr) {
+  return reinterpret_cast<void*>(*addr);
+}
+} // namespace maplert
+#endif // JAVA_MRT_OBJECT_H_
diff --git a/src/mrt/maplert/include/mrt_primitive_util.h b/src/mrt/maplert/include/mrt_primitive_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..5fa329a223331a75810153ef7ed89b43f3cad1ad
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_primitive_util.h
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_PRIMITIVE_UTIL_H_
+#define MRT_PRIMITIVE_UTIL_H_
+#include "cpphelper.h"
+#include "mrt_well_known.h"
+#include "mrt_classloader_api.h"
+#include "mclass_inline.h"
+
+// 'V' : void
+// 'Z' : jboolean, uint8_t
+// 'B' : jbyte,    int8_t
+// 'S' : jshort,   int16_t
+// 'C' : jchar,    uint16_t
+// 'I' : jin,      int32_t
+// 'J' : jlong,    int64_t
+// 'F' : jfloat,   float
+// 'D' : jdouble,  double
+// 'N' : jobject,  MObject*, reflence type
+
+namespace maplert {
+using JValue = union JValueType {
+  uint8_t    z;
+  int8_t     b;
+  uint16_t   c;
+  int16_t    s;
+  int32_t    i;
+  int64_t    j;
+  float      f;
+  double     d;
+  MObject   *l;
+};
+
+namespace primitiveutil {
+  char GetPrimitiveTypeFromBoxType(const MClass &type);
+  bool IsBoxObject(const MObject &o, char srcType);
+  bool ConvertNarrowToWide(char srcType, char dstType, const jvalue &src, jvalue &dst);
+  bool CanConvertNarrowToWide(char srcType, char dstType);
+  bool ConvertToInt(char srcType, const jvalue &src, jvalue &dst);
+  bool ConvertToLong(char srcType, const jvalue &src, jvalue &dst);
+  bool ConvertToFloat(char srcType, const jvalue &src, jvalue &dst);
+  bool ConvertToDouble(char srcType, const jvalue &src, jvalue &dst);
+  bool UnBoxPrimitive(const MObject &elementObj, jvalue &boxedValue);
+  MObject *BoxPrimitive(char srcType, const jvalue &value);
+  MObject *BoxPrimitiveJint(int32_t value);
+
+  static constexpr int16_t kByteCacheOffset = 128;
+  static constexpr int16_t kShortCacheHigh = 127;
+  static constexpr int16_t kShortCacheLow = -128;
+  static constexpr uint16_t kCharCacheHigh = 127;
+  static constexpr int16_t kLongCacheHigh = 127;
+  static constexpr int16_t kLongCacheLow = -128;
+
+  static inline MObject *GetCacheMember(MClass &cls, const FieldMeta &cacheMeta, uint32_t value, bool tryInit = true) {
+    if (tryInit) {
+      if (!cls.InitClassIfNeeded()) {
+        LOG(ERROR) << "fail do clinit, " << "class: " << cls.GetName() << maple::endl;
+      }
+    }
+    MObject *addr = MObject::Cast<MObject>(cacheMeta.GetStaticAddr());
+    MArray *cachehArr = reinterpret_cast<MArray*>(addr->LoadObjectNoRc(0));
+    return cachehArr->GetObjectElement(value);
+  }
+
+  static inline MObject *BoxPrimitiveJboolean(uint8_t value) {
+    FieldMeta *cacheMeta = nullptr;
+    if (!WellKnown::GetMClassBoolean()->InitClassIfNeeded()) {
+      LOG(ERROR) << "fail do clinit, " << "class: " << WellKnown::GetMClassBoolean()->GetName() << maple::endl;
+    }
+    (value == 0) ? (cacheMeta = WellKnown::GetFieldMetaBooleanFalse())
+                 : (cacheMeta = WellKnown::GetFieldMetaBooleanTrue());
+    MObject *addr = MObject::Cast<MObject>(cacheMeta->GetStaticAddr());
+    return reinterpret_cast<MObject*>(addr->LoadObject(0));
+  }
+
+  static inline MObject *BoxPrimitiveJbyte(int8_t value) {
+    return GetCacheMember(*WellKnown::GetMClassByteCache(), *WellKnown::GetFieldMetaByteCache(),
+        static_cast<uint32_t>(value + kByteCacheOffset));
+  }
+
+  static inline MObject *BoxPrimitiveJshort(int16_t value) {
+    if (value >= kShortCacheLow && value <= kShortCacheHigh) {
+      return GetCacheMember(*WellKnown::GetMClassShortCache(), *WellKnown::GetFieldMetaShortCache(),
+          static_cast<uint32_t>(value + (-kShortCacheLow)));
+    }
+    MObject *ret = MObject::NewObject(*WellKnown::GetMClassShort());
+    ret->Store<jshort>(WellKnown::GetMFieldShortValueOffset(), value, false);
+    return ret;
+  }
+
+  static inline MObject *BoxPrimitiveJchar(uint16_t value) {
+    if (value <= kCharCacheHigh) {
+      return GetCacheMember(*WellKnown::GetMClassCharacterCache(), *WellKnown::GetFieldMetaCharacterCache(), value);
+    }
+    MObject *ret = MObject::NewObject(*WellKnown::GetMClassCharacter());
+    ret->Store<jchar>(WellKnown::GetMFieldCharacterValueOffset(), value, false);
+    return ret;
+  }
+
+  static inline MObject *BoxPrimitiveJlong(int64_t value) {
+    if (value >= kLongCacheLow && value <= kLongCacheHigh) {
+      return GetCacheMember(*WellKnown::GetMClassLongCache(), *WellKnown::GetFieldMetaLongCache(),
+          static_cast<uint32_t>(value + (-kLongCacheLow)));
+    }
+    MObject *ret = MObject::NewObject(*WellKnown::GetMClassLong());
+    ret->Store<jlong>(WellKnown::GetMFieldLongValueOffset(), value, false);
+    return ret;
+  }
+
+  static inline MObject *BoxPrimitiveJfloat(float value) {
+    MObject *ret = MObject::NewObject(*WellKnown::GetMClassFloat());
+    ret->Store<jfloat>(WellKnown::GetMFieldFloatValueOffset(), value, false);
+    return ret;
+  }
+
+  static inline MObject *BoxPrimitiveJdouble(double value) {
+    MObject *ret = MObject::NewObject(*WellKnown::GetMClassDouble());
+    ret->Store<jdouble>(WellKnown::GetMFieldDoubleValueOffset(), value, false);
+    return ret;
+  }
+
+  static inline char GetPrimitiveType(const MClass &type) {
+    if (&type == WellKnown::GetMClassZ()) {
+      return 'Z';
+    } else if (&type == WellKnown::GetMClassB()) {
+      return 'B';
+    } else if (&type == WellKnown::GetMClassS()) {
+      return 'S';
+    } else if (&type == WellKnown::GetMClassC()) {
+      return 'C';
+    } else if (&type == WellKnown::GetMClassI()) {
+      return 'I';
+    } else if (&type == WellKnown::GetMClassJ()) {
+      return 'J';
+    } else if (&type == WellKnown::GetMClassF()) {
+      return 'F';
+    } else if (&type == WellKnown::GetMClassD()) {
+      return 'D';
+    } else if (&type == WellKnown::GetMClassV()) {
+      return 'V';
+    }
+    return 'N';
+  }
+
+  template<typename T>
+  static T UnBoxPrimitive(const MObject &elementObj) {
+    MClass *elementObjClass = elementObj.GetClass();
+    char type = GetPrimitiveTypeFromBoxType(*elementObjClass);
+    size_t offset = 0;
+    switch (type) {
+      case 'Z':
+        offset = WellKnown::GetMFieldBooleanValueOffset();
+        return static_cast<T>(elementObj.Load<uint8_t>(offset));
+      case 'B':
+        offset = WellKnown::GetMFieldByteValueOffset();
+        return static_cast<T>(elementObj.Load<int8_t>(offset));
+      case 'C':
+        offset = WellKnown::GetMFieldCharacterValueOffset();
+        return static_cast<T>(elementObj.Load<uint16_t>(offset));
+      case 'D':
+        offset = WellKnown::GetMFieldDoubleValueOffset();
+        return static_cast<T>(elementObj.Load<double>(offset));
+      case 'F':
+        offset = WellKnown::GetMFieldFloatValueOffset();
+        return static_cast<T>(elementObj.Load<float>(offset));
+      case 'I':
+        offset = WellKnown::GetMFieldIntegerValueOffset();
+        return static_cast<T>(elementObj.Load<int32_t>(offset));
+      case 'J':
+        offset = WellKnown::GetMFieldLongValueOffset();
+        return static_cast<T>(elementObj.Load<int64_t>(offset));
+      case 'S':
+        offset = WellKnown::GetMFieldShortValueOffset();
+        return static_cast<T>(elementObj.Load<int16_t>(offset));
+      default: ;
+    }
+    return 0;
+  }
+};
+} // namespace maplert
+#endif // MRT_PRIMITIVE_UTIL_H_
diff --git a/src/mrt/maplert/include/mrt_profile.h b/src/mrt/maplert/include/mrt_profile.h
new file mode 100644
index 0000000000000000000000000000000000000000..9529e05623a5fe2eb44307ed0472e13a71fffdd8
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_profile.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_PROFILE_H_
+#define MRT_PROFILE_H_
+#include "jni.h"
+#include "mclass.h"
+#include "methodmeta.h"
+#include "fieldmeta.h"
+namespace maplert {
+class FieldMeta;
+class MethodMetaBase;
+void InsertReflectionString(const char *kHotString);
+void InsertClassMetadata(const MClass &klass);
+void InsertMethodMetadata(const MethodMetaBase *kMethod);
+void InsertMethodMetadata(const MClass &cls);
+void InsertFieldMetadata(FieldMeta *fieldMeta);
+void InsertFieldMetadata(const MClass &cls);
+void InsertMethodSignature(const MethodMeta &method);
+
+#define __MRT_Profile_CString(hotString)        if (VLOG_IS_ON(profiler))  InsertReflectionString(hotString);
+#define __MRT_Profile_ClassMeta(klass)          if (VLOG_IS_ON(profiler))  InsertClassMetadata(klass);
+#define __MRT_Profile_MethodMeta(methodOrCls) if (VLOG_IS_ON(profiler))  InsertMethodMetadata(methodOrCls);
+#define __MRT_Profile_FieldMeta(fieldOrCls)   if (VLOG_IS_ON(profiler))  InsertFieldMetadata(fieldOrCls);
+#define __MRT_Profile_MethodParameterTypes(method) if (VLOG_IS_ON(profiler))  InsertMethodSignature(method);
+} // namespace maplert
+
+#endif // MRT_PROFILE_H_
diff --git a/src/mrt/maplert/include/mrt_reflection.h b/src/mrt/maplert/include/mrt_reflection.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f743cb620a575c0b7d81a573d6c475dfeb472fc
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_reflection.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_REFLECTION_H_
+#define MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_REFLECTION_H_
+
+#include "mclass_inline.h"
+#include "modifier.h"
+#include "mrt_annotation.h"
+#include "interp_support.h"
+#include "mrt_classloader_api.h"
+
+using namespace std;
+namespace maplert {
+namespace reflection {
+static inline bool IsInSamePackage(const MClass &declaringClass, const MClass &callingClass, bool clFlag = true) {
+  MClass *class1 = const_cast<MClass*>(&declaringClass);
+  MClass *class2 = const_cast<MClass*>(&callingClass);
+  if (class1 == class2) {
+    return true;
+  }
+  // clFlag is used for classLoader.
+  if (clFlag) {
+    jobject classLoader1 = MRT_GetClassLoader(*class1);
+    jobject classLoader2 = MRT_GetClassLoader(*class2);
+    // The premise of comparison is the same class loader.
+    if (classLoader1 != classLoader2) {
+      return false;
+    }
+  }
+  // Find and compare elements of arrays.
+  while (class1->IsArrayClass()) {
+    class1 = class1->GetComponentClass();
+  }
+  while (class2->IsArrayClass()) {
+    class2 = class2->GetComponentClass();
+  }
+  if (class1 == class2) {
+    return true;
+  }
+  // Compare whether in the same package.
+  const char *declaringClassName = class1->GetName();
+  const char *callingClassName = class2->GetName();
+  const char *declaringPackageChar = strrchr(declaringClassName, '/');
+  const char *callingPackageChar = strrchr(callingClassName, '/');
+  if ((declaringPackageChar == nullptr) && (callingPackageChar == nullptr)) {
+    return true;
+  }
+  if ((declaringPackageChar == nullptr) || (callingPackageChar == nullptr)) {
+    return false;
+  }
+  size_t declaringPackageLen = static_cast<size_t>(declaringPackageChar - declaringClassName);
+  size_t callingPackageLen = static_cast<size_t>(callingPackageChar - callingClassName);
+  return (declaringPackageLen == callingPackageLen) ?
+      (strncmp(declaringClassName, callingClassName, declaringPackageLen) == 0) : false;
+}
+
+static inline MClass *GetCallerClass(uint32_t level) {
+  std::vector<UnwindContext> uwContextStack;
+  constexpr uint32_t kReserveSize = 10;
+  uwContextStack.reserve(kReserveSize);
+  MapleStack::FastRecordCurrentJavaStack(uwContextStack, level + 1);
+  MClass *klass = nullptr;
+  uint32_t size = static_cast<uint32_t>(uwContextStack.size());
+  if (size > level && !uwContextStack.empty()) {
+    if (!uwContextStack[level].IsInterpretedContext()) {
+      klass = MClass::JniCast(uwContextStack[level].frame.GetDeclaringClass());
+    } else {
+      klass = UnwindContextInterpEx::GetDeclaringClassFromUnwindContext(uwContextStack[level]);
+    }
+  }
+  return klass;
+}
+
+static ALWAYS_INLINE inline bool CanAccess(const MClass &thatKlass, const MClass &callerClass) {
+  return thatKlass.IsPublic() || IsInSamePackage(thatKlass, callerClass) ||
+         (modifier::IsAFOriginPublic(thatKlass.GetModifier()) && thatKlass.IsInnerClass());
+}
+
+static ALWAYS_INLINE inline bool VerifyAccess(const MObject *obj, const MClass *declaringClass,
+                                              uint32_t accessFlags, MClass *&callingClass, uint32_t level) {
+  DCHECK(declaringClass != nullptr) << "VerifyAccess: declaringClass is nullptr!" << maple::endl;
+  if (modifier::IsPublic(accessFlags)) {
+    return true;
+  }
+  if (callingClass == nullptr) {
+    callingClass = GetCallerClass(level);
+  }
+  if (declaringClass == callingClass || callingClass == nullptr) {
+    return true;
+  }
+  if (modifier::IsPrivate(accessFlags)) {
+    return false;
+  }
+  if (modifier::IsProtected(accessFlags)) {
+    if (obj != nullptr && !obj->IsInstanceOf(*callingClass) && !IsInSamePackage(*declaringClass, *callingClass)) {
+      return false;
+    } else if (declaringClass->IsAssignableFrom(*callingClass)) {
+      return true;
+    }
+  }
+  return IsInSamePackage(*declaringClass, *callingClass);
+}
+
+extern "C" void MRT_ThrowNewException(const char *className, const char *msg);
+static ALWAYS_INLINE inline bool CheckIsInstaceOf(const MClass &declaringClass, const MObject *mo) {
+  if (UNLIKELY(mo == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "null receiver");
+    return false;
+  }
+  if (mo->IsInstanceOf(declaringClass)) {
+    return true;
+  }
+  // Throw Exception
+  std::string declaringClassName, objectClassName;
+  declaringClass.GetTypeName(declaringClassName);
+  MClass *objectClass = mo->GetClass();
+  objectClass->GetTypeName(objectClassName);
+  std::ostringstream msg;
+  msg << "Expected receiver of type " << declaringClassName << ", but got " << objectClassName;
+  MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.str().c_str());
+  return false;
+}
+}
+}
+#endif // MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_REFLECTION_H_
diff --git a/src/mrt/maplert/include/mrt_reflection_class.h b/src/mrt/maplert/include/mrt_reflection_class.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d48e21fe53e8ee2e3c8f79827403b13dfdbfe43
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_reflection_class.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_REFLECTION_ClASS_H
+#define MRT_REFLECTION_ClASS_H
+#include <vector>
+#include <string>
+
+#include "mclass.h"
+namespace maplert {
+#ifndef USE_ARM32_MACRO
+#ifdef USE_32BIT_REF
+constexpr uint32_t leftShift32Bit = 32;
+#endif  // ~USE_32BIT_REF
+#endif  // ~USE_ARM32_MACRO
+#ifdef USE_32BIT_REF
+constexpr uint32_t kLowBitOfItabLength = 0xffff;
+constexpr uint32_t kHighBitOfItabLength = 0x7fffffff;
+#else
+constexpr uint64_t kLowBitOfItabLength = 0xffffffff;
+constexpr uint64_t kHighBitOfItabLength = 0x7fffffffffffffff;
+#endif
+
+#if PLATFORM_SDK_VERSION >= 27
+MObject *ReflectClassGetPrimitiveClass(const MClass &classObj, const MString *name);
+#endif
+// class.field  for reflection_class_jni.cpp
+MObject *ReflectClassGetField(const MClass &classObj, const MString *s);
+MObject *ReflectClassGetFields(const MClass &classObj);
+MObject *ReflectClassGetDeclaredField(const MClass &classObj, const MString *s);
+MObject *ReflectClassGetDeclaredFields(const MClass &classObj);
+MObject *ReflectClassGetDeclaredFieldsUnchecked(const MClass &classObj, bool publicOnly);
+
+// class.method & constructor for reflection_class_jni.cpp
+MObject *ReflectClassGetMethod(const MClass &classObj, const MString *name, const MArray *arrayClass);
+MObject *ReflectClassGetMethods(const MClass &classObj);
+MObject *ReflectClassGetDeclaredMethod(const MClass &classObj, const MString *name, const MArray *arrayClass);
+MObject *ReflectClassGetDeclaredMethods(const MClass &classObj);
+MObject *ReflectClassGetDeclaredMethodsUnchecked(const MClass &classObj, bool publicOnly);
+void ReflectClassGetPublicMethodsInternal(const MClass &classObj, MObject *listObject);
+MObject *ReflectClassGetDeclaredConstructorsInternal(const MClass &classObj, bool publicOnly);
+MObject *ReflectClassGetInstanceMethod(const MClass &classObj, const MString *name, const MArray *arrayClass);
+MObject *ReflectClassFindInterfaceMethod(const MClass &classObj, const MString *name, const MArray *arrayClass);
+MObject *ReflectClassGetDeclaredMethodInternal(const MClass &classObj, const MString *name, const MArray *arraycls);
+MObject *ReflectClassGetDeclaredConstructor(const MClass &classObj, const MArray *arrayClass);
+MObject *ReflectClassGetDeclaredConstructors(const MClass &classObj);
+MObject *ReflectClassGetDeclaredConstructorInternal(const MClass &classObj, const MArray *arrayClass);
+MObject *ReflectClassGetConstructor(const MClass &classObj, const MArray *arrayClass);
+MObject *ReflectClassGetConstructors(const MClass &classObj);
+void ReflectClassGetPublicFieldsRecursive(const MClass &classObj, MObject *listObject);
+MObject *ReflectClassGetPublicFieldRecursive(const MClass &classObj, const MString *s);
+MObject *ReflectClassGetPublicDeclaredFields(const MClass &classObj);
+MObject *ReflectClassNewInstance(const MClass &classObj);
+MObject *ReflectClassGetInterfacesInternal(const MClass &classObj);
+MObject *ReflectClassGetSignatureAnnotation(const MClass &classObj);
+MObject *ReflectClassGetEnclosingMethodNative(const MClass &classObj);
+MObject *ReflectClassGetEnclosingConstructorNative(const MClass &classObj);
+MObject *ReflectClassGetClassLoader(const MClass &classObj);
+MObject *ReflectClassGetDeclaredAnnotation(const MClass &classObj, const MClass *annoClass);
+MObject *ReflectClassGetClasses(const MClass &classObj);
+MObject *ReflectClassGetEnclosingClass(const MClass &classObj);
+MObject *ReflectClassGetInnerClassName(const MClass &classObj);
+bool ReflectClassIsDeclaredAnnotationPresent(const MClass &classObj, const MObject *annoObj);
+bool ReflectClassIsMemberClass(const MClass &classObj);
+bool ReflectClassIsLocalClass(const MClass &classObj);
+MObject *ReflectClassGetAnnotation(const MClass &klass, const MClass *annotationType);
+} // namespace maplert
+#endif
diff --git a/src/mrt/maplert/include/mrt_reflection_constructor.h b/src/mrt/maplert/include/mrt_reflection_constructor.h
new file mode 100644
index 0000000000000000000000000000000000000000..b94696d15f6e8111a0d25574fc2c1c7358eb4bc1
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_reflection_constructor.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_REFLECTION_CONSTRUCTOR_H
+#define MRT_REFLECTION_CONSTRUCTOR_H
+namespace maplert {
+} // namespace maplert
+#endif
+
diff --git a/src/mrt/maplert/include/mrt_reflection_executable.h b/src/mrt/maplert/include/mrt_reflection_executable.h
new file mode 100644
index 0000000000000000000000000000000000000000..697e9abad6d18baddf5bc5e8e4935385303feea0
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_reflection_executable.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_REFLECTION_EXECUTABLE_H_
+#define MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_REFLECTION_EXECUTABLE_H_
+#include "mrt_reflection_api.h" // some of the exported API defined here
+#ifdef __cplusplus
+namespace maplert {
+} // namespace maplert
+#endif
+
+#endif
diff --git a/src/mrt/maplert/include/mrt_reflection_field.h b/src/mrt/maplert/include/mrt_reflection_field.h
new file mode 100644
index 0000000000000000000000000000000000000000..3fa5087b98bb2ff7e1a17fd7d9f92afa0052cb6d
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_reflection_field.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_REFLECTION_FIELD_H
+#define MRT_REFLECTION_FIELD_H
+#include "fieldmeta.h"
+#include "mfield.h"
+namespace maplert {
+uint32_t ReflectFieldGetSize(const FieldMeta &fieldMeta);
+uint32_t ReflectCompactFieldGetSize(const std::string &name);
+// java/lang/reflect/Field native API implement
+// NOTE: fieldObj is field object(MField), not FieldMeta
+MObject *ReflectFieldGetDeclaredAnnotations(const MField &fieldObj);
+MObject *ReflectFieldGetAnnotation(const MField &fieldObj, const MClass *classArg);
+MObject *ReflectFieldGetNameInternal(const MField &fieldObj);
+MObject *ReflectFieldGetSignatureAnnotation(const MField &fieldObj);
+bool ReflectFieldIsAnnotationPresentNative(const MField &fieldObj, const MClass *classArg);
+FieldMeta *ReflectFieldGetArtField(const MField &fieldObj);
+uint8_t ReflectGetFieldNativeUint8(const MField &fieldObj, const MObject *obj);
+int8_t ReflectGetFieldNativeInt8(const MField &fieldObj, const MObject *obj);
+uint16_t ReflectGetFieldNativeUint16(const MField &fieldObj, const MObject *obj);
+int16_t ReflectGetFieldNativeInt16(const MField &fieldObj, const MObject *obj);
+int32_t ReflectGetFieldNativeInt32(const MField &fieldObj, const MObject *obj);
+int64_t ReflectGetFieldNativeInt64(const MField &fieldObj, const MObject *obj);
+float ReflectGetFieldNativeFloat(const MField &fieldObj, const MObject *obj);
+double ReflectGetFieldNativeDouble(const MField &fieldObj, const MObject *obj);
+MObject *ReflectGetFieldNativeObject(const MField &fieldObj, const MObject *obj);
+
+void ReflectSetFieldNativeUint8(const MField &fieldObj, MObject *obj, uint8_t value);
+void ReflectSetFieldNativeInt8(const MField &fieldObj, MObject *obj, int8_t value);
+void ReflectSetFieldNativeUint16(const MField &fieldObj, MObject *obj, uint16_t value);
+void ReflectSetFieldNativeInt16(const MField &fieldObj, MObject *obj, int16_t value);
+void ReflectSetFieldNativeInt32(const MField &fieldObj, MObject *obj, int32_t value);
+void ReflectSetFieldNativeInt64(const MField &fieldObj, MObject *obj, int64_t value);
+void ReflectSetFieldNativeFloat(const MField &fieldObj, MObject *obj, float value);
+void ReflectSetFieldNativeDouble(const MField &fieldObj, MObject *obj, double value);
+void ReflectSetFieldNativeObject(const MField &fieldObj, MObject *obj, const MObject *value);
+} // namespace maplert
+#endif
\ No newline at end of file
diff --git a/src/mrt/maplert/include/mrt_reflection_method.h b/src/mrt/maplert/include/mrt_reflection_method.h
new file mode 100644
index 0000000000000000000000000000000000000000..5d57aea69418fb38187c205435d1ff98e1e93618
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_reflection_method.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_REFLECTION_METHOD_H
+#define MRT_REFLECTION_METHOD_H
+#include "mrt_annotation.h"
+namespace maplert {
+// declaring method for use in method reflection
+MString *ReflectMethodGetName(const MMethod &methodObj);
+MObject *ReflectMethodGetReturnType(const MMethod &methodObj);
+MObject *ReflectMethodInvoke(const MMethod &methodObj, MObject *obj, const MArray *arg, uint8_t frames);
+MObject *ReflectInvokeJavaMethodFromArrayArgsJobject(MObject*, const MMethod&, const MArray*, uint8_t);
+void ReflectInvokeJavaMethodFromArrayArgsVoid(MObject *obj, const MMethod &method, const MArray *arg, uint8_t frames);
+}  // namespace maplert
+#endif  // MRT_REFLECTION_METHOD_H
diff --git a/src/mrt/maplert/include/mrt_reflection_proxy.h b/src/mrt/maplert/include/mrt_reflection_proxy.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb183b70e371915e185b014ea1808d3baadf8212
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_reflection_proxy.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_REFLECTION_PROXY_H
+#define MRT_REFLECTION_PROXY_H
+#include "mclass.h"
+#include "mrt_reflection_api.h"
+namespace maplert {
+} // namespace maplert
+#endif
diff --git a/src/mrt/maplert/include/mrt_string.h b/src/mrt/maplert/include/mrt_string.h
new file mode 100644
index 0000000000000000000000000000000000000000..bfee14169f08c5892401042bf4f8551f68a2618c
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_string.h
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef JAVA_MRT_STRING_H_
+#define JAVA_MRT_STRING_H_
+
+#include <cstdio>
+#include <iostream>
+#include <cstring>
+#include <functional>
+#include <jni.h>
+#include <limits.h>
+#include "cinterface.h"
+#include "address.h"
+#include "mrt_string_api.h"
+#include "collector/mpl_thread_pool.h"
+#include "mstring.h"
+#include "gc_callback.h"
+#include "panic.h"
+
+namespace maplert {
+// for GC root scanning.  This is a C++ function, not extern "C"
+// roots in the constant-string pool.
+void VisitStringPool(const RefVisitor &visitor);
+void CreateAppStringPool();
+
+// Return the size (in bytes) of a given String object.
+// It is a specialized function for GetObjectSize.
+size_t ConstStringPoolSize(bool literal);
+size_t ConstStringPoolNum(bool literal);
+size_t ConstStringAppPoolNum(bool literal);
+void DumpConstStringPool(std::ostream &os, bool literal);
+
+MString *NewStringUtfFromPoolForClassName(const MClass &classObj);
+MArray *MStringToMutf8(const MString &stringObj, int32_t offset, int32_t length, int compress);
+MArray *MStringToBytes(const MString &stringObj, int32_t offset, int32_t length, uint16_t maxValidChar, int compress);
+
+MString *StringNewStringFromString(const MString &stringObj);
+MString *StringNewStringFromCharArray(int32_t offset, uint32_t charCount, const MArray &arrayObj);
+MString *StringNewStringFromByteArray(const MArray &arrayObj, int32_t highByteT, int32_t offset, uint32_t byteLength);
+MString *StringNewStringFromSubstring(const MString &stringObj, int32_t start, uint32_t length);
+MString *JStringDoReplace(const MString &stringObj, uint16_t oldChar, uint16_t newChar);
+MString *StringConcat(MString &stringObj1, MString &stringObj2);
+int32_t StringFastIndexOf(const MString &stringObj, int32_t ch, int32_t start);
+MString *NewStringFromUTF16(const std::string &str);
+
+#ifdef __OPENJDK__
+// new native functions for openjdk
+int32_t StringNativeIndexOfP3(MString &subStrObj, MString &srcStrObj, int32_t fromIndex);
+int32_t StringNativeIndexOfP5(MString &subStrObj, MArray &srcArray,
+                              int32_t srcOffset, int32_t srcCount, int32_t fromIndex);
+int32_t StringNativeLastIndexOfP3(MString &subStrObj, MString &srcStrObj, int32_t fromIndex);
+int32_t StringNativeLastIndexOfP5(MString &subStrObj, MArray &srcArray,
+                                  int32_t srcOffset, int32_t srcCount, int32_t fromIndex);
+MString *StringNewStringFromCodePoints(MArray &mArray, int32_t offset, int32_t count);
+int32_t StringNativeCodePointAt(MString &strObj, int32_t index);
+int32_t StringNativeCodePointBefore(MString &strObj, int32_t index);
+int32_t StringNativeCodePointCount(MString &strObj, int32_t beginIndex, int32_t endIndex);
+int32_t StringNativeOffsetByCodePoint(MString &strObj, int32_t index, int32_t codePointOffset);
+#endif // __OPENJDK__
+
+// if c-string is in 16bit coding, then use CStrToJStr, otherwise use NewStringUTF
+MString *NewStringUTF(const char *kCStr, size_t cStrLen);
+
+// for normal MString internization, use GetOrInsertStringPool
+MString *GetOrInsertStringPool(MString &stringObj);
+// get/insert a MFile literal into const pool.
+// used by mpl-linker to insert literal (also stored in static-fields)
+MString *GetOrInsertLiteral(MString &literalObj);
+
+// only for RC
+void RemoveStringFromPool(MString &stringObj);
+size_t RemoveDeadStringFromPool();
+
+// for gc
+void StringPrepareConcurrentSweeping();
+size_t ConcurrentSweepDeadStrings(MplThreadPool *threadPool);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+class MStringRef {
+ public:
+#ifdef USE_32BIT_REF
+  using RawType = uint32_t;
+#else
+  using RawType = address_t;
+#endif
+
+  MStringRef() : ref(0) {} // default initialized to 0 as empty
+  RawType GetRef() const {
+    return ref;
+  }
+  RawType &GetRawRef() {
+    return ref;
+  }
+  void SetRef(const address_t addr) {
+    __MRT_ASSERT(addr <= std::numeric_limits<RawType>::max(), "String address overflow for MStringRef!");
+    ref = static_cast<RawType>(addr);
+  }
+  void SetRef(const MString *str) {
+    SetRef(reinterpret_cast<address_t>(str));
+  }
+  void Clear() {
+    ref = 0;
+  }
+  bool IsEmpty() const {
+    return ref == 0;
+  }
+ private:
+  RawType ref;
+};
+
+jstring CStrToJStr(const char *ca, jint len);
+// empty, hash and equal
+struct MStringHashEqual {
+  // compare mstring with MFile literal
+  size_t operator()(const MString *a) const {
+    return a->GetHash();
+  }
+
+  size_t operator()(const MStringRef a) const {
+    return reinterpret_cast<MString*>(a.GetRef())->GetHash();
+  }
+
+  bool operator()(const MString *a, const MStringRef b) const {
+    return a->Equals(*(reinterpret_cast<MString*>(b.GetRef())));
+  }
+
+  bool operator()(const MStringRef a, const MStringRef b) const {
+    return reinterpret_cast<MString*>(a.GetRef())->Equals(*(reinterpret_cast<MString*>(b.GetRef())));
+  }
+
+  void Clear(MStringRef &ref) const {
+    ref.Clear();
+  }
+
+  bool IsEmpty(const MStringRef ref) const {
+    return ref.IsEmpty();
+  }
+};
+
+struct MStringMapNotEqual {
+  // compare mstring with MFile literal
+  size_t operator()(const MString *a) const {
+    return a->GetHash();
+  }
+
+  bool operator()(const MString *a, const MString *b) const {
+    return !a->Equals(*b);
+  }
+};
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+} // namespace maplert
+#endif // JAVA_MRT_STRING_H_
diff --git a/src/mrt/maplert/include/mrt_util.h b/src/mrt/maplert/include/mrt_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..21a22f72072e0364c32955bc82216814f4c28fab
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_util.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef JAVA_MRT_UTIL_H_
+#define JAVA_MRT_UTIL_H_
+#include <string>
+
+// provide "secure" version of common utility functions
+#include "securec.h"
+
+#include "jni.h"
+
+#ifdef __cplusplus
+namespace maplert {
+std::string GetClassNametoDescriptor(const std::string &className);
+extern "C" {
+#endif
+#define OPENSSL_VERSION_TEXT "OpenSSL 1.0.2 (compatible; BoringSSL)"
+char *MRT_FuncnameToPrototypeNames(char *funcName, int argNum, char **typeNames);
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif // __cplusplus
+#endif // JAVA_MRT_UTIL_H_
diff --git a/src/mrt/maplert/include/mrt_well_known.h b/src/mrt/maplert/include/mrt_well_known.h
new file mode 100644
index 0000000000000000000000000000000000000000..01dfa260ca43803520407f6627f86497e566f89c
--- /dev/null
+++ b/src/mrt/maplert/include/mrt_well_known.h
@@ -0,0 +1,865 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_WELL_KNOWN_H_
+#define MRT_WELL_KNOWN_H_
+#include <vector>
+
+#include "mclass.h"
+namespace maplert {
+class WellKnown {
+ public:
+  // public fields
+  // array class interface always Ljava/lang/Cloneable; Ljava/io/Serializable;
+  static constexpr uint8_t kArrayInterfaceNum = 2;
+  static std::vector<MClass*> arrayInterface;
+  static size_t kReferenceReferentOffset; // java/lang/Reference::Referent
+  static size_t kReferenceQueueOffset; // java/lang/Reference::Queue
+  // java/lang/Reference::Pendingnext for libcore or java/lang/Reference::discovered for OpenJDK
+  static size_t kReferencePendingnextOffset;
+  // java/lang/ref/FinalizerReference::Zombie for libcore only
+  static size_t kFinalizereferenceZombieOffset;
+
+  // public methods
+  static inline MClass *GetMClassZ() {
+    return primitiveClassZ;
+  }
+
+  static inline MClass *GetMClassB() {
+    return primitiveClassB;
+  }
+
+  static inline MClass *GetMClassS() {
+    return primitiveClassS;
+  }
+
+  static inline MClass *GetMClassC() {
+    return primitiveClassC;
+  }
+
+  static inline MClass *GetMClassI() {
+    return primitiveClassI;
+  }
+
+  static inline MClass *GetMClassJ() {
+    return primitiveClassJ;
+  }
+
+  static inline MClass *GetMClassF() {
+    return primitiveClassF;
+  }
+
+  static inline MClass *GetMClassD() {
+    return primitiveClassD;
+  }
+
+  static inline MClass *GetMClassV() {
+    return primitiveClassV;
+  }
+
+  static inline MClass *GetMClassAZ() {
+    return primitiveClassAZ;
+  }
+
+  static inline MClass *GetMClassAB() {
+    return primitiveClassAB;
+  }
+
+  static inline MClass *GetMClassAS() {
+    return primitiveClassAS;
+  }
+
+  static inline MClass *GetMClassAC() {
+    return primitiveClassAC;
+  }
+
+  static inline MClass *GetMClassAI() {
+    return primitiveClassAI;
+  }
+
+  static inline MClass *GetMClassAJ() {
+    return primitiveClassAJ;
+  }
+
+  static inline MClass *GetMClassAF() {
+    return primitiveClassAF;
+  }
+
+  static inline MClass *GetMClassAD() {
+    return primitiveClassAD;
+  }
+
+  static inline MClass *GetMClassAAZ() {
+    return primitiveClassAAZ;
+  }
+
+  static inline MClass *GetMClassAAB() {
+    return primitiveClassAAB;
+  }
+
+  static inline MClass *GetMClassAAS() {
+    return primitiveClassAAS;
+  }
+
+  static inline MClass *GetMClassAAC() {
+    return primitiveClassAAC;
+  }
+
+  static inline MClass *GetMClassAAI() {
+    return primitiveClassAAI;
+  }
+
+  static inline MClass *GetMClassAAJ() {
+    return primitiveClassAAJ;
+  }
+
+  static inline MClass *GetMClassAAF() {
+    return primitiveClassAAF;
+  }
+
+  static inline MClass *GetMClassAAD() {
+    return primitiveClassAAD;
+  }
+
+  static inline MClass *GetMClassVoid() {
+    return Ljava_2Flang_2FVoid_3B;
+  }
+
+  static inline MClass *GetMClassBoolean() {
+    return Ljava_2Flang_2FBoolean_3B;
+  }
+
+  static inline MClass *GetMClassByte() {
+    return Ljava_2Flang_2FByte_3B;
+  }
+
+  static inline MClass *GetMClassCharacter() {
+    return Ljava_2Flang_2FCharacter_3B;
+  }
+
+  static inline MClass *GetMClassShort() {
+    return Ljava_2Flang_2FShort_3B;
+  }
+
+  static inline MClass *GetMClassInteger() {
+    return Ljava_2Flang_2FInteger_3B;
+  }
+
+  static inline MClass *GetMClassLong() {
+    return Ljava_2Flang_2FLong_3B;
+  }
+
+  static inline MClass *GetMClassFloat() {
+    return Ljava_2Flang_2FFloat_3B;
+  }
+
+  static inline MClass *GetMClassDouble() {
+    return Ljava_2Flang_2FDouble_3B;
+  }
+
+  static inline MClass *GetMClassNumber() {
+    return Ljava_2Flang_2FNumber_3B;
+  }
+
+  static inline MClass *GetMClassObject() {
+    return Ljava_2Flang_2FObject_3B;
+  }
+
+  static inline MClass *GetMClassClass() {
+    return Ljava_2Flang_2FClass_3B;
+  }
+
+  static inline MClass *GetMClassField() {
+    return Ljava_2Flang_2Freflect_2FField_3B;
+  }
+
+  static inline MClass *GetMClassConstructor() {
+    return Ljava_2Flang_2Freflect_2FConstructor_3B;
+  }
+
+  static inline MClass *GetMClassMethod() {
+    return Ljava_2Flang_2Freflect_2FMethod_3B;
+  }
+
+  static inline MClass *GetMClassProxy() {
+    return Ljava_2Flang_2Freflect_2FProxy_3B;
+  }
+
+  static inline MClass *GetMClassParameter() {
+    return Ljava_2Flang_2Freflect_2FParameter_3B;
+  }
+
+  static inline MClass *GetMClassGenericSignatureParser() {
+    return Llibcore_2Freflect_2FGenericSignatureParser_3B;
+  }
+
+  static inline MClass *GetMClassCloneable() {
+    return Ljava_2Flang_2FCloneable_3B;
+  }
+
+  static inline MClass *GetMClassSerializable() {
+    return Ljava_2Fio_2FSerializable_3B;
+  }
+
+  static inline MClass *GetMClassString() {
+    return Ljava_2Flang_2FString_3B;
+  }
+
+  static inline MClass *GetMClassStringFactory() {
+    return Ljava_2Flang_2FStringFactory_3B;
+  }
+
+  static inline MClass *GetMClassError() {
+    return Ljava_2Flang_2FError_3B;
+  }
+
+  static inline MClass *GetMClassThrowable() {
+    return Ljava_2Flang_2FThrowable_3B;
+  }
+
+  static inline MClass *GetMClassArithmeticException() {
+    return Ljava_2Flang_2FArithmeticException_3B;
+  }
+
+  static inline MClass *GetMClassInterruptedException() {
+    return Ljava_2Flang_2FInterruptedException_3B;
+  }
+
+  static inline MClass *GetMClassClassCastException() {
+    return Ljava_2Flang_2FClassCastException_3B;
+  }
+
+  static inline MClass *GetMClassUnsatisfiedLinkError() {
+    return Ljava_2Flang_2FUnsatisfiedLinkError_3B;
+  }
+
+  static inline MClass *GetMClassStringIndexOutOfBoundsException() {
+    return Ljava_2Flang_2FStringIndexOutOfBoundsException_3B;
+  }
+
+  static inline MClass *GetMClassNoClassDefFoundError() {
+    return Ljava_2Flang_2FNoClassDefFoundError_3B;
+  }
+
+  static inline MClass *GetMClassNoSuchMethodError() {
+    return Ljava_2Flang_2FNoSuchMethodError_3B;
+  }
+
+  static inline MClass *GetMClassNoSuchFieldError() {
+    return Ljava_2Flang_2FNoSuchFieldError_3B;
+  }
+
+  static inline MClass *GetMClassVerifyError() {
+    return Ljava_2Flang_2FVerifyError_3B;
+  }
+
+  static inline MClass *GetMClassExceptionInInitializerError() {
+    return Ljava_2Flang_2FExceptionInInitializerError_3B;
+  }
+
+  static inline MClass *GetMClassRuntimeException() {
+    return Ljava_2Flang_2FRuntimeException_3B;
+  }
+
+  static inline MClass *GetMClassSecurityException() {
+    return Ljava_2Flang_2FSecurityException_3B;
+  }
+
+  static inline MClass *GetMClassUndeclaredThrowableException() {
+    return Ljava_2Flang_2Freflect_2FUndeclaredThrowableException_3B;
+  }
+
+  static inline MClass *GetMClassArrayStoreException() {
+    return Ljava_2Flang_2FArrayStoreException_3B;
+  }
+
+  static inline MClass *GetMClassArrayIndexOutOfBoundsException() {
+    return Ljava_2Flang_2FArrayIndexOutOfBoundsException_3B;
+  }
+
+  static inline MClass *GetMClassNullPointerException() {
+    return Ljava_2Flang_2FNullPointerException_3B;
+  }
+
+  static inline MClass *GetMClassEnum() {
+    return Ljava_2Flang_2FEnum_3B;
+  }
+
+  static inline MClass *GetMClassAnnotation() {
+    return Ljava_2Flang_2Fannotation_2FAnnotation_3B;
+  }
+
+  static inline MClass *GetMClassAnnotationMember() {
+    return Llibcore_2Freflect_2FAnnotationMember_3B;
+  }
+
+  static inline MClass *GetMClassAnnotationFactory() {
+    return Llibcore_2Freflect_2FAnnotationFactory_3B;
+  }
+
+  static inline MClass *GetMClassDelegateLastClassLoader() {
+    return Ldalvik_2Fsystem_2FDelegateLastClassLoader_3B;
+  }
+
+  static inline MClass *GetMClassPathClassLoader() {
+    return Ldalvik_2Fsystem_2FPathClassLoader_3B;
+  }
+
+  static inline MClass *GetMClassDexClassLoader() {
+    return Ldalvik_2Fsystem_2FDexClassLoader_3B;
+  }
+
+  static inline MClass *GetMClassInMemoryDexClassLoader() {
+    return Ldalvik_2Fsystem_2FInMemoryDexClassLoader_3B;
+  }
+
+  static inline MClass *GetMClassMethodType() {
+    return Ljava_2Flang_2Finvoke_2FMethodType_3B;
+  }
+
+  static inline MClass *GetMClassMethodHandle() {
+    return Ljava_2Flang_2Finvoke_2FMethodHandle_3B;
+  }
+
+  static inline size_t GetMFieldMethodHandleDataArrayOffset() {
+    return Ljava_2Flang_2FMethodHandle_3B_dataArray_offset;
+  }
+
+  static inline size_t GetMFieldMethodHandleMetaArrayOffset() {
+    return Ljava_2Flang_2FMethodHandle_3B_metaArray_offset;
+  }
+
+  static inline size_t GetMFieldMethodHandleTypeArrayOffset() {
+    return Ljava_2Flang_2FMethodHandle_3B_typeArray_offset;
+  }
+
+  static inline size_t GetMFieldMethodHandleOpArrayOffset() {
+    return Ljava_2Flang_2FMethodHandle_3B_opArray_offset;
+  }
+
+  static inline size_t GetMFieldMethodHandleIndexOffset() {
+    return Ljava_2Flang_2FMethodHandle_3B_index_offset;
+  }
+
+  static inline size_t GetMFieldBindToDataReceiverOffset() {
+    return Ljava_2Flang_2FBindToData_3B_receiver_offset;
+  }
+
+  static inline size_t GetMFieldDropArgumentsDataNumDroppedOffset() {
+    return Ljava_2Flang_2FDropArgumentsData_3B_numDropped_offset;
+  }
+
+  static inline size_t GetMFieldDropArgumentsDataStartPosOffset() {
+    return Ljava_2Flang_2FDropArgumentsData_3B_startPos_offset;
+  }
+
+  static inline size_t GetMFieldFilterReturnValueDataTargetOffset() {
+    return Ljava_2Flang_2FFilterReturnValueData_3B_target_offset;
+  }
+
+  static inline size_t GetMFieldFilterReturnValueDataFilterOffset() {
+    return Ljava_2Flang_2FFilterReturnValueData_3B_filter_offset;
+  }
+
+  static inline size_t GetMFieldPermuteArgumentsDataTargetOffset() {
+    return Ljava_2Flang_2FPermuteArgumentsData_3B_target_offset;
+  }
+
+  static inline size_t GetMFieldPermuteArgumentsDataReorderOffset() {
+    return Ljava_2Flang_2FPermuteArgumentsData_3B_reorder_offset;
+  }
+
+  static inline MClass *GetMClassEmulatedStackFrame() {
+    return Ldalvik_2Fsystem_2FEmulatedStackFrame_3B;
+  }
+
+  static inline size_t GetMFieldMethodHandleArtFieldOrMethodOffset() {
+    return Ljava_2Flang_2FMethodHandle_3B_artFieldOrMethod_offset;
+  }
+
+  static inline size_t GetMFieldMethodHandleHandleKindOffset() {
+    return Ljava_2Flang_2FMethodHandle_3B_handleKind_offset;
+  }
+
+  static inline size_t GetMFieldMethodHandleNominalTypeOffset() {
+    return Ljava_2Flang_2FMethodHandle_3B_nominalType_offset;
+  }
+
+  static inline size_t GetMFieldMethodHandleTypeOffset() {
+    return Ljava_2Flang_2FMethodHandle_3B_type_offset;
+  }
+
+  static inline size_t GetMFieldEmStackFrameCallsiteOffset() {
+    return Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_callsiteType_offset;
+  }
+
+  static inline size_t GetMFieldEmStackFrameReferencesOffset() {
+    return Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_references_offset;
+  }
+
+  static inline size_t GetMFieldEmStackFrameStackFrameOffset() {
+    return Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_stackFrame_offset;
+  }
+
+  static inline size_t GetMFieldEmStackFrameTypeOffset() {
+    return Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_type_offset;
+  }
+
+#ifdef __OPENJDK__
+  static inline MClass *GetMClassHashMap() {
+    return Ljava_2Futil_2FHashMap_3B;
+  }
+
+  static inline MClass *GetMClassAnnotationParser() {
+    return Lsun_2Freflect_2Fannotation_2FAnnotationParser_3B;
+  }
+#endif // __OPENJDK__
+
+  static inline MClass *GetMClassIntegerCache() {
+    return Ljava_2Flang_2FInteger_24IntegerCache_3B;
+  }
+
+  static inline MClass *GetMClassByteCache() {
+    return Ljava_2Flang_2FByte_24ByteCache_3B;
+  }
+
+  static inline MClass *GetMClassShortCache() {
+    return Ljava_2Flang_2FShort_24ShortCache_3B;
+  }
+
+  static inline MClass *GetMClassCharacterCache() {
+    return Ljava_2Flang_2FCharacter_24CharacterCache_3B;
+  }
+
+  static inline MClass *GetMClassLongCache() {
+    return Ljava_2Flang_2FLong_24LongCache_3B;
+  }
+
+  static inline MClass *GetMClassReference() {
+    return Ljava_2Flang_2Fref_2FReference_3B;
+  }
+
+  static inline MClass *GetMClassFinalizerReference() {
+    return Ljava_2Flang_2Fref_2FFinalizerReference_3B;
+  }
+
+  static inline MClass *GetMClassAObject() {
+    return ALjava_2Flang_2FObject_3B;
+  }
+
+  static inline MClass *GetMClassAClass() {
+    return ALjava_2Flang_2FClass_3B;
+  }
+
+  static inline MClass *GetMClassAField() {
+    return ALjava_2Flang_2Freflect_2FField_3B;
+  }
+
+  static inline MClass *GetMClassAString() {
+    return ALjava_2Flang_2FString_3B;
+  }
+
+  static inline MClass *GetMClassABoolean() {
+    return ALjava_2Flang_2FBoolean_3B;
+  }
+
+  static inline MClass *GetMClassAByte() {
+    return ALjava_2Flang_2FByte_3B;
+  }
+
+  static inline MClass *GetMClassACharacter() {
+    return ALjava_2Flang_2FCharacter_3B;
+  }
+
+  static inline MClass *GetMClassAShort() {
+    return ALjava_2Flang_2FShort_3B;
+  }
+
+  static inline MClass *GetMClassAInteger() {
+    return ALjava_2Flang_2FInteger_3B;
+  }
+
+  static inline MClass *GetMClassALong() {
+    return ALjava_2Flang_2FLong_3B;
+  }
+
+  static inline MClass *GetMClassAFloat() {
+    return ALjava_2Flang_2FFloat_3B;
+  }
+
+  static inline MClass *GetMClassADouble() {
+    return ALjava_2Flang_2FDouble_3B;
+  }
+
+  static inline MClass *GetMClassAMethod() {
+    return ALjava_2Flang_2Freflect_2FMethod_3B;
+  }
+
+  static inline MClass *GetMClassAAnnotation() {
+    return ALjava_2Flang_2Fannotation_2FAnnotation_3B;
+  }
+
+  static inline MClass *GetMClassAConstructor() {
+    return ALjava_2Flang_2Freflect_2FConstructor_3B;
+  }
+
+  static inline MClass *GetMClassAParameter() {
+    return ALjava_2Flang_2Freflect_2FParameter_3B;
+  }
+
+  static inline MClass *GetMClassAAAnnotation() {
+    return AALjava_2Flang_2Fannotation_2FAnnotation_3B;
+  }
+
+  static inline MClass *GetPrimitiveArrayClass(maple::Primitive::Type pType) {
+    return primitiveArrayClass[pType];
+  }
+
+  static inline FieldMeta *GetFieldMetaIntegerCache() {
+    return Ljava_2Flang_2FInteger_24IntegerCache_3B_cache;
+  }
+
+  static inline FieldMeta *GetFieldMetaIntegerCacheLow() {
+    return Ljava_2Flang_2FInteger_24IntegerCache_3B_low;
+  }
+
+  static inline FieldMeta *GetFieldMetaIntegerCacheHigh() {
+    return Ljava_2Flang_2FInteger_24IntegerCache_3B_high;
+  }
+
+  static inline FieldMeta *GetFieldMetaBooleanTrue() {
+    return Ljava_2Flang_2FBoolean_3B_TRUE;
+  }
+
+  static inline FieldMeta *GetFieldMetaBooleanFalse() {
+    return Ljava_2Flang_2FBoolean_3B_FALSE;
+  }
+
+  static inline FieldMeta *GetFieldMetaByteCache() {
+    return Ljava_2Flang_2FByte_24ByteCache_3B_cache;
+  }
+
+  static inline FieldMeta *GetFieldMetaShortCache() {
+    return Ljava_2Flang_2FShort_24ShortCache_3B_cache;
+  }
+
+  static inline FieldMeta *GetFieldMetaCharacterCache() {
+    return Ljava_2Flang_2FCharacter_24CharacterCache_3B_cache;
+  }
+
+  static inline FieldMeta *GetFieldMetaLongCache() {
+    return Ljava_2Flang_2FLong_24LongCache_3B_cache;
+  }
+
+  static inline uintptr_t GetMMethodClassLoaderLoadClassAddr() {
+    return Ljava_2Flang_2FClassLoader_3B_LoadClass_Addr;
+  }
+
+  static inline uintptr_t GetMMethodAnnotationMemberInitAddr() {
+    return Llibcore_2Freflect_2FAnnotationMember_3B_7C_3Cinit_Addr;
+  }
+
+  static inline uintptr_t GetMMethodAnnotationFactoryCreateAnnotationAddr() {
+    return Llibcore_2Freflect_2FAnnotationFactory_3B_7CcreateAnnotation_Addr;
+  }
+
+  static inline uintptr_t GetMMethodBooleanValueOfAddr() {
+    return Ljava_2Flang_2FBoolean_3B_ValueOf_Addr;
+  }
+
+  static inline uintptr_t GetMMethodByteValueOfAddr() {
+    return Ljava_2Flang_2FByte_3B_ValueOf_Addr;
+  }
+
+  static inline uintptr_t GetMMethodCharacterValueOfAddr() {
+    return Ljava_2Flang_2FCharacter_3B_ValueOf_Addr;
+  }
+
+  static inline uintptr_t GetMMethodShortValueOfAddr() {
+    return Ljava_2Flang_2FShort_3B_ValueOf_Addr;
+  }
+
+  static inline uintptr_t GetMMethodIntegerValueOfAddr() {
+    return Ljava_2Flang_2FInteger_3B_ValueOf_Addr;
+  }
+
+  static inline uintptr_t GetMMethodLongValueOfAddr() {
+    return Ljava_2Flang_2FLong_3B_ValueOf_Addr;
+  }
+
+  static inline uintptr_t GetMMethodFloatValueOfAddr() {
+    return Ljava_2Flang_2FFloat_3B_ValueOf_Addr;
+  }
+
+  static inline uintptr_t GetMMethodDoubleValueOfAddr() {
+    return Ljava_2Flang_2FDouble_3B_ValueOf_Addr;
+  }
+
+  static inline size_t GetMFieldBooleanValueOffset() {
+    return Ljava_2Flang_2FBoolean_3B_value_offset;
+  }
+
+  static inline size_t GetMFieldByteValueOffset() {
+    return Ljava_2Flang_2FByte_3B_value_offset;
+  }
+
+  static inline size_t GetMFieldCharacterValueOffset() {
+    return Ljava_2Flang_2FCharacter_3B_value_offset;
+  }
+
+  static inline size_t GetMFieldShortValueOffset() {
+    return Ljava_2Flang_2FShort_3B_value_offset;
+  }
+
+  static inline size_t GetMFieldIntegerValueOffset() {
+    return Ljava_2Flang_2FInteger_3B_value_offset;
+  }
+
+  static inline size_t GetMFieldLongValueOffset() {
+    return Ljava_2Flang_2FLong_3B_value_offset;
+  }
+
+  static inline size_t GetMFieldFloatValueOffset() {
+    return Ljava_2Flang_2FFloat_3B_value_offset;
+  }
+
+  static inline size_t GetMFieldDoubleValueOffset() {
+    return Ljava_2Flang_2FDouble_3B_value_offset;
+  }
+
+  static inline size_t GetMFieldMethodHandlePTypesOffset() {
+    return Ljava_2Flang_2FMethodType_3B_ptypes_offset;
+  }
+
+  static inline size_t GetMFieldMethodHandlepRTypeOffset() {
+    return Ljava_2Flang_2FMethodType_3B_rtype_offset;
+  }
+
+  static void InitCache();
+  static void InitArrayInterfaceVector();
+  static void InitCacheClasses();
+  static void InitCacheMethodHandleClasses();
+  static void InitCachePrimitiveBoxClass();
+  static void InitCacheMethodAddrs();
+  static void InitCacheArrayClass();
+  static void InitCacheFieldOffsets();
+  static void InitCacheFieldMethodHandleOffsets();
+  static void InitCacheExceptionClass();
+  static void InitCacheFieldMetas();
+  static void InitCacheClass(MClass *&cls, const char *className);
+  static void InitCacheMethodAddr(uintptr_t &methodAddr, const MClass &cls,
+                                  const char *methodName, const char *signatureName);
+  static void InitCacheFieldOffset(size_t &fieldOffset, const MClass &cls, const char *fieldName);
+  static void InitCacheFieldMeta(FieldMeta *&fieldMeta, const MClass &cls, const char *fieldName);
+  static MClass *GetCacheArrayClass(const MClass &componentClass);
+  static MClass *GetWellKnowClassWithFlag(uint8_t classFlag, const MClass &caller, const char *className);
+  static MethodMeta *GetStringFactoryConstructor(const MethodMeta &stringConstructor);
+
+ private:
+  static constexpr uint8_t kMaxPrimitiveSize = 9;
+  static constexpr uint8_t kMaxFrameworksSize = 7;
+  static constexpr uint32_t kCacheArrayClassSize = 16;
+  static uint32_t currentCacheArrayClassIndex;
+
+  static MClass *primitiveClassZ;
+  static MClass *primitiveClassB;
+  static MClass *primitiveClassS;
+  static MClass *primitiveClassC;
+  static MClass *primitiveClassI;
+  static MClass *primitiveClassJ;
+  static MClass *primitiveClassF;
+  static MClass *primitiveClassD;
+  static MClass *primitiveClassV;
+
+  static MClass *primitiveClassAZ;
+  static MClass *primitiveClassAB;
+  static MClass *primitiveClassAS;
+  static MClass *primitiveClassAC;
+  static MClass *primitiveClassAI;
+  static MClass *primitiveClassAJ;
+  static MClass *primitiveClassAF;
+  static MClass *primitiveClassAD;
+
+  static MClass *primitiveClassAAZ;
+  static MClass *primitiveClassAAB;
+  static MClass *primitiveClassAAS;
+  static MClass *primitiveClassAAC;
+  static MClass *primitiveClassAAI;
+  static MClass *primitiveClassAAJ;
+  static MClass *primitiveClassAAF;
+  static MClass *primitiveClassAAD;
+
+  static MClass *Ljava_2Flang_2FVoid_3B;
+  static MClass *Ljava_2Flang_2FBoolean_3B;
+  static MClass *Ljava_2Flang_2FByte_3B;
+  static MClass *Ljava_2Flang_2FCharacter_3B;
+  static MClass *Ljava_2Flang_2FShort_3B;
+  static MClass *Ljava_2Flang_2FInteger_3B;
+  static MClass *Ljava_2Flang_2FLong_3B;
+  static MClass *Ljava_2Flang_2FFloat_3B;
+  static MClass *Ljava_2Flang_2FDouble_3B;
+  static MClass *Ljava_2Flang_2FNumber_3B;
+
+  static MClass *Ljava_2Flang_2FObject_3B;
+  static MClass *Ljava_2Flang_2FClass_3B;
+  static MClass *Ljava_2Flang_2FClassLoader_3B;
+  static MClass *Ljava_2Flang_2Freflect_2FField_3B;
+  static MClass *Ljava_2Flang_2Freflect_2FConstructor_3B;
+  static MClass *Ljava_2Flang_2Freflect_2FMethod_3B;
+  static MClass *Ljava_2Flang_2Freflect_2FProxy_3B;
+  static MClass *Ljava_2Flang_2Freflect_2FParameter_3B;
+  static MClass *Llibcore_2Freflect_2FGenericSignatureParser_3B;
+  static MClass *Ljava_2Flang_2Fref_2FReference_3B;
+  static MClass *Ljava_2Flang_2Fref_2FFinalizerReference_3B;
+
+  static MClass *Ljava_2Flang_2FCloneable_3B;
+  static MClass *Ljava_2Fio_2FSerializable_3B;
+
+  static MClass *Ljava_2Flang_2FString_3B;
+  static MClass *Ljava_2Flang_2FStringFactory_3B;
+
+  static MClass *Ljava_2Flang_2FError_3B;
+  static MClass *Ljava_2Flang_2FThrowable_3B;
+  static MClass *Ljava_2Flang_2FArithmeticException_3B;
+  static MClass *Ljava_2Flang_2FInterruptedException_3B;
+  static MClass *Ljava_2Flang_2FClassCastException_3B;
+  static MClass *Ljava_2Flang_2FUnsatisfiedLinkError_3B;
+  static MClass *Ljava_2Flang_2FStringIndexOutOfBoundsException_3B;
+  static MClass *Ljava_2Flang_2FNoClassDefFoundError_3B;
+  static MClass *Ljava_2Flang_2FNoSuchMethodError_3B;
+  static MClass *Ljava_2Flang_2FNoSuchFieldError_3B;
+  static MClass *Ljava_2Flang_2FVerifyError_3B;
+  static MClass *Ljava_2Flang_2FExceptionInInitializerError_3B;
+  static MClass *Ljava_2Flang_2FRuntimeException_3B;
+  static MClass *Ljava_2Flang_2FSecurityException_3B;
+  static MClass *Ljava_2Flang_2Freflect_2FUndeclaredThrowableException_3B;
+  static MClass *Ljava_2Flang_2FArrayStoreException_3B;
+  static MClass *Ljava_2Flang_2FArrayIndexOutOfBoundsException_3B;
+  static MClass *Ljava_2Flang_2FNullPointerException_3B;
+
+  static MClass *Ljava_2Flang_2FEnum_3B;
+  static MClass *Ljava_2Flang_2Fannotation_2FAnnotation_3B;
+  static MClass *Llibcore_2Freflect_2FAnnotationMember_3B;
+  static MClass *Llibcore_2Freflect_2FAnnotationFactory_3B;
+  static MClass *Ldalvik_2Fsystem_2FDelegateLastClassLoader_3B;
+  static MClass *Ldalvik_2Fsystem_2FPathClassLoader_3B;
+  static MClass *Ldalvik_2Fsystem_2FDexClassLoader_3B;
+  static MClass *Ldalvik_2Fsystem_2FInMemoryDexClassLoader_3B;
+
+  static MClass *Ljava_2Flang_2Finvoke_2FMethodType_3B;
+  static MClass *Ljava_2Flang_2Finvoke_2FMethodHandle_3B;
+
+#ifdef __OPENJDK__
+  static MClass *Ljava_2Futil_2FHashMap_3B;
+  static MClass *Lsun_2Freflect_2Fannotation_2FAnnotationParser_3B;
+
+#endif  // __OPENJDK__
+
+  static MClass *Ljava_2Flang_2FInteger_24IntegerCache_3B;
+  static MClass *Ljava_2Flang_2FByte_24ByteCache_3B;
+  static MClass *Ljava_2Flang_2FShort_24ShortCache_3B;
+  static MClass *Ljava_2Flang_2FCharacter_24CharacterCache_3B;
+  static MClass *Ljava_2Flang_2FLong_24LongCache_3B;
+
+  static MClass *Ljava_2Flang_2Finvoke_2FInvokeData_24BindToData_3B;
+  static MClass *Ljava_2Flang_2Finvoke_2FInvokeData_24DropArgumentsData_3B;
+  static MClass *Ljava_2Flang_2Finvoke_2FInvokeData_24FilterReturnValueData_3B;
+  static MClass *Ljava_2Flang_2Finvoke_2FInvokeData_24PermuteArgumentsData_3B;
+  static size_t Ljava_2Flang_2FMethodHandle_3B_dataArray_offset;
+  static size_t Ljava_2Flang_2FMethodHandle_3B_metaArray_offset;
+  static size_t Ljava_2Flang_2FMethodHandle_3B_typeArray_offset;
+  static size_t Ljava_2Flang_2FMethodHandle_3B_opArray_offset;
+  static size_t Ljava_2Flang_2FMethodHandle_3B_index_offset;
+  static size_t Ljava_2Flang_2FBindToData_3B_receiver_offset;
+  static size_t Ljava_2Flang_2FDropArgumentsData_3B_numDropped_offset;
+  static size_t Ljava_2Flang_2FDropArgumentsData_3B_startPos_offset;
+  static size_t Ljava_2Flang_2FFilterReturnValueData_3B_target_offset;
+  static size_t Ljava_2Flang_2FFilterReturnValueData_3B_filter_offset;
+  static size_t Ljava_2Flang_2FPermuteArgumentsData_3B_target_offset;
+  static size_t Ljava_2Flang_2FPermuteArgumentsData_3B_reorder_offset;
+
+  static MClass *Ldalvik_2Fsystem_2FEmulatedStackFrame_3B;
+  static size_t Ljava_2Flang_2FMethodHandle_3B_artFieldOrMethod_offset;
+  static size_t Ljava_2Flang_2FMethodHandle_3B_handleKind_offset;
+  static size_t Ljava_2Flang_2FMethodHandle_3B_nominalType_offset;
+  static size_t Ljava_2Flang_2FMethodHandle_3B_type_offset;
+  static size_t Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_callsiteType_offset;
+  static size_t Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_references_offset;
+  static size_t Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_stackFrame_offset;
+  static size_t Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_type_offset;
+
+  static MClass *ALjava_2Flang_2FObject_3B;
+  static MClass *ALjava_2Flang_2FClass_3B;
+  static MClass *ALjava_2Flang_2Freflect_2FField_3B;
+  static MClass *ALjava_2Flang_2Freflect_2FMethod_3B;
+  static MClass *ALjava_2Flang_2Fannotation_2FAnnotation_3B;
+  static MClass *ALjava_2Flang_2Freflect_2FConstructor_3B;
+  static MClass *ALjava_2Flang_2Freflect_2FParameter_3B;
+  static MClass *ALjava_2Flang_2FString_3B;
+  static MClass *ALjava_2Flang_2FBoolean_3B;
+  static MClass *ALjava_2Flang_2FByte_3B;
+  static MClass *ALjava_2Flang_2FCharacter_3B;
+  static MClass *ALjava_2Flang_2FShort_3B;
+  static MClass *ALjava_2Flang_2FInteger_3B;
+  static MClass *ALjava_2Flang_2FLong_3B;
+  static MClass *ALjava_2Flang_2FFloat_3B;
+  static MClass *ALjava_2Flang_2FDouble_3B;
+
+  static MClass *AALjava_2Flang_2Fannotation_2FAnnotation_3B;
+
+  static MClass *primitiveArrayClass[];
+  static MClass *cacheArrayClasses[];
+  static MClass *arrayFrameWorksClasses[];
+
+  static FieldMeta *Ljava_2Flang_2FBoolean_3B_TRUE;
+  static FieldMeta *Ljava_2Flang_2FBoolean_3B_FALSE;
+  static FieldMeta *Ljava_2Flang_2FByte_24ByteCache_3B_cache;
+  static FieldMeta *Ljava_2Flang_2FShort_24ShortCache_3B_cache;
+  static FieldMeta *Ljava_2Flang_2FCharacter_24CharacterCache_3B_cache;
+  static FieldMeta *Ljava_2Flang_2FLong_24LongCache_3B_cache;
+  static FieldMeta *Ljava_2Flang_2FInteger_24IntegerCache_3B_cache;
+  static FieldMeta *Ljava_2Flang_2FInteger_24IntegerCache_3B_low;
+  static FieldMeta *Ljava_2Flang_2FInteger_24IntegerCache_3B_high;
+
+  // method loadClass address
+  static uintptr_t Ljava_2Flang_2FClassLoader_3B_LoadClass_Addr;
+
+  // Annotation method address
+  static uintptr_t Llibcore_2Freflect_2FAnnotationMember_3B_7C_3Cinit_Addr;
+  static uintptr_t Llibcore_2Freflect_2FAnnotationFactory_3B_7CcreateAnnotation_Addr;
+
+  // method ValueOf address
+  static uintptr_t Ljava_2Flang_2FBoolean_3B_ValueOf_Addr;
+  static uintptr_t Ljava_2Flang_2FByte_3B_ValueOf_Addr;
+  static uintptr_t Ljava_2Flang_2FCharacter_3B_ValueOf_Addr;
+  static uintptr_t Ljava_2Flang_2FShort_3B_ValueOf_Addr;
+  static uintptr_t Ljava_2Flang_2FInteger_3B_ValueOf_Addr;
+  static uintptr_t Ljava_2Flang_2FLong_3B_ValueOf_Addr;
+  static uintptr_t Ljava_2Flang_2FFloat_3B_ValueOf_Addr;
+  static uintptr_t Ljava_2Flang_2FDouble_3B_ValueOf_Addr;
+
+  // field value offset
+  static size_t Ljava_2Flang_2FBoolean_3B_value_offset;
+  static size_t Ljava_2Flang_2FByte_3B_value_offset;
+  static size_t Ljava_2Flang_2FCharacter_3B_value_offset;
+  static size_t Ljava_2Flang_2FShort_3B_value_offset;
+  static size_t Ljava_2Flang_2FInteger_3B_value_offset;
+  static size_t Ljava_2Flang_2FLong_3B_value_offset;
+  static size_t Ljava_2Flang_2FFloat_3B_value_offset;
+  static size_t Ljava_2Flang_2FDouble_3B_value_offset;
+  static size_t Ljava_2Flang_2FMethodType_3B_ptypes_offset;
+  static size_t Ljava_2Flang_2FMethodType_3B_rtype_offset;
+};
+} // namespace maplert
+#endif // MRT_WELL_KNOWN_H_
diff --git a/src/mrt/maplert/include/mstring.h b/src/mrt/maplert/include/mstring.h
new file mode 100644
index 0000000000000000000000000000000000000000..81c19b8fef5e8b89d3677add1d82d41072aa564f
--- /dev/null
+++ b/src/mrt/maplert/include/mstring.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MSTRING_H_
+#define MRT_MAPLERT_INCLUDE_MSTRING_H_
+#include "mobject.h"
+#include <string>
+namespace maplert {
+class PACKED(4) MString : public MObject {
+ public:
+  uint32_t GetCountValue() const;
+  inline void SetCountValue(uint32_t value);
+  inline uint32_t GetLength() const;
+  uint32_t GetHash() const;
+  inline void SetHash(uint32_t hash);
+  uint8_t *GetContentsPtr() const;
+  bool IsCompress() const;
+  bool IsLiteral() const;
+  inline uint16_t CharAt(uint32_t index) const;
+  uint32_t GetStringSize() const;
+  inline bool Cmp(const std::string &src) const;
+  std::string GetChars() const;
+  MString *Intern();
+  bool Equals(const MString &src) const;
+  inline void SetStringClass();
+  static MString *InternUtf8(const std::string &str);
+  static MString *InternUtf16(const std::string &str);
+  static MString *InternUtf(const std::string &str);
+  static uint32_t GetStringBaseSize();
+  static uint32_t GetCountOffset();
+  static  bool GetCompressFlag();
+  template<typename Type>
+  static inline bool IsCompressChars(const Type *chars, uint32_t length);
+  static bool IsCompressChar(const uint16_t c);
+  static bool IsCompressedFromCount(const uint32_t countValue);
+  static inline bool IsCompressCharsExcept(const uint16_t *chars, uint32_t length, uint16_t except);
+  template<typename srcType, typename Func>
+  static inline MString *NewStringObject(uint32_t stringLen, const Func &fillContents, bool isJNI = false);
+  template<typename srcType>
+  static inline MString *NewStringObject(const srcType *src, uint32_t stringLen, bool isJNI = false);
+  template<typename srcType, typename dstType>
+  static inline MString *NewStringObject(const srcType *src, uint32_t stringLen, bool isJNI = false);
+  static inline MString *NewStringObject(const uint16_t *src, uint32_t stringLen, bool isJNI = false);
+  static MString *NewEmptyStringObject();
+  static MString *NewConstEmptyStringObject();
+  static MString *NewStringObjectFromUtf8(const std::string &str);
+  static MString *NewStringObjectFromUtf16(const std::string &str);
+  static MString *NewStringObjectFromUtf(const std::string &str);
+
+  template<typename T>
+  static inline MString *JniCast(T s);
+  template<typename T>
+  static inline MString *JniCastNonNull(T s);
+  jstring inline AsJstring() const;
+
+ private:
+  uint32_t count;
+  uint32_t hash;
+  uint8_t content[];
+  static constexpr bool enableStringCompression = true;
+};
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MSTRING_H_
diff --git a/src/mrt/maplert/include/mstring_inline.h b/src/mrt/maplert/include/mstring_inline.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f8f0293d3938592ede45a4be0440e71b7341038
--- /dev/null
+++ b/src/mrt/maplert/include/mstring_inline.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_MAPLERT_INCLUDE_MSTRING_INLINE_H_
+#define MRT_MAPLERT_INCLUDE_MSTRING_INLINE_H_
+
+#include "mstring.h"
+#include "heap_stats.h"
+#include "mobject_inline.h"
+#include "mrt_well_known.h"
+namespace maplert {
+inline uint32_t MString::GetCountValue() const {
+  return count;
+}
+
+inline void MString::SetCountValue(uint32_t countValue) {
+  count = countValue;
+}
+
+inline uint32_t MString::GetLength() const {
+  return GetCountValue() >> 1;
+}
+
+inline uint32_t MString::GetHash() const {
+  return hash;
+}
+
+inline void MString::SetHash(uint32_t hashCode) {
+  hash = hashCode;
+}
+
+inline uint8_t *MString::GetContentsPtr() const {
+  return reinterpret_cast<uint8_t*>(AsUintptr() + GetStringBaseSize());
+}
+
+inline uint32_t MString::GetCountOffset() {
+  return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&static_cast<MString*>(0)->count));
+}
+
+inline bool MString::GetCompressFlag() {
+  return enableStringCompression;
+}
+
+inline bool MString::IsCompress() const{
+  uint32_t countValue = GetCountValue();
+  return static_cast<unsigned int>(countValue) & 0x01;
+}
+
+inline bool MString::IsCompressedFromCount(const uint32_t countValue) {
+  return countValue & 0x01;
+}
+
+inline bool MString::IsLiteral() const {
+  // literal is off-heap java-string or string in PERM-space
+  return IsOffHeap();
+}
+
+inline uint16_t MString::CharAt(uint32_t index) const {
+  bool isCompress = IsCompress();
+  uint8_t *strContent = GetContentsPtr();
+  return isCompress ? *(strContent + index) : *(reinterpret_cast<uint16_t*>(strContent) + index);
+}
+
+inline bool MString::IsCompressChar(const uint16_t c) {
+  return (c - 1u) < 0x7fu;
+}
+
+template<typename Type>
+inline bool MString::IsCompressChars(const Type *chars, uint32_t length) {
+  if (!enableStringCompression) {
+    return false;
+  }
+  DCHECK(chars != nullptr) << "MString::IsCompressChars: chars is nullptr." << maple::endl;
+  for (uint32_t i = 0; i < length; ++i) {
+    if (!IsCompressChar(chars[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline bool MString::IsCompressCharsExcept(const uint16_t *chars, uint32_t length, uint16_t except) {
+  DCHECK(chars != nullptr) << "MString::IsCompressChars: chars is nullptr." << maple::endl;
+  for (uint32_t i = 0; i < length; ++i) {
+    uint16_t c = chars[i];
+    if (!IsCompressChar(c) && c != except) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline uint32_t MString::GetStringSize() const {
+  return IsCompress() ? GetStringBaseSize() + GetLength() : GetStringBaseSize() + GetCountValue();
+}
+
+inline uint32_t MString::GetStringBaseSize() {
+  return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&(static_cast<MString*>(0))->content));
+}
+
+inline bool MString::Cmp(const std::string &src) const {
+  bool isCompress = IsCompress();
+  bool res = true;
+  if (isCompress) {
+    size_t dstLen = GetLength(); // extended to size_t
+    size_t srcLen = src.length(); // may be > INT32_MAX
+    uint8_t *dstName = GetContentsPtr();
+    if (srcLen == dstLen) { // if srcLen > INT32_MAX, this must not be equal.
+      for (size_t i = 0; i < dstLen; ++i) {
+        if (src[i] != dstName[i]) {
+          res = false;
+          break;
+        }
+      }
+    } else {
+      res = false;
+    }
+  } else {
+    std::string charStr = GetChars();
+    res = (src == charStr);
+  }
+  return res;
+}
+
+template<typename srcType, typename Func>
+inline MString *MString::NewStringObject(uint32_t stringLen, const Func &fillContents, bool isJNI) {
+  constexpr bool compressible = (sizeof(uint8_t) == sizeof(srcType));
+  DCHECK(stringLen <= ((UINT32_MAX - GetStringBaseSize()) / sizeof(srcType))) << "stringLen must valid" << maple::endl;
+  size_t memLen = GetStringBaseSize() + stringLen * sizeof(srcType);
+  uint32_t stringCount = (stringLen != 0) ? (((static_cast<unsigned int>(stringLen) << 1)) | compressible) : 0;
+  MString *stringObj = static_cast<MString*>(MObject::NewObject(*WellKnown::GetMClassString(), memLen, isJNI));
+  if (UNLIKELY(stringObj == nullptr)) {
+    return nullptr;
+  }
+  stringObj->SetCountValue(stringCount);
+  fillContents(*stringObj);
+  // add memory order release
+  std::atomic_thread_fence(std::memory_order_release);
+  return stringObj;
+}
+
+template<typename srcType>
+inline MString *MString::NewStringObject(const srcType *src, uint32_t stringLen, bool isJNI) {
+  DCHECK(src != nullptr) << "MString::NewStringObject: src is nullptr." << maple::endl;
+  DCHECK(stringLen <= UINT32_MAX / sizeof(srcType)) << "stringLen must valid" << maple::endl;
+  size_t memLen = stringLen * sizeof(srcType);
+  MString *res = NewStringObject<srcType>(stringLen, [&](MString &stringObj) {
+    srcType *resDst = reinterpret_cast<srcType*>(stringObj.GetContentsPtr());
+    if (memLen != 0) {
+      if (memcpy_s(resDst, memLen, src, memLen) != EOK) {
+        LOG(ERROR) << "newStringObject memcpy_s() not return EOK" << maple::endl;
+      }
+    }
+  }, isJNI);
+  return res;
+}
+
+template<typename srcType, typename dstType>
+inline MString *MString::NewStringObject(const srcType *src, uint32_t stringLen, bool isJNI) {
+  DCHECK(src != nullptr) << "MString::NewStringObject: src is nullptr." << maple::endl;
+  MString *res = NewStringObject<dstType>(stringLen, [&](MString &stringObj) {
+    dstType *resDst = reinterpret_cast<dstType*>(stringObj.GetContentsPtr());
+    for (uint32_t i = 0; i < stringLen; ++i) {
+      resDst[i] = static_cast<dstType>(src[i]);
+    }
+  }, isJNI);
+  return res;
+}
+
+inline MString *MString::NewStringObject(const uint16_t *src, uint32_t stringLen, bool isJNI) {
+  bool isCompress = IsCompressChars<uint16_t>(src, stringLen);
+  return isCompress ? NewStringObject<uint16_t, uint8_t>(src, stringLen, isJNI) :
+                      NewStringObject<uint16_t>(src, stringLen, isJNI);
+}
+
+inline MString *MString::NewEmptyStringObject() {
+  return NewStringObject<uint8_t>(0, [](MString&) { });
+}
+
+inline void MString::SetStringClass() {
+  // only use to set literal string
+  if (GetClass() == nullptr) {
+    StoreObjectOffHeap(0, WellKnown::GetMClassString());
+    std::atomic_thread_fence(std::memory_order_release);
+  }
+}
+
+template<typename T>
+inline MString *MString::JniCast(T s) {
+  static_assert(std::is_same<T, jstring>::value || std::is_same<T, jobject>::value, "wrong type");
+  return reinterpret_cast<MString*>(s);
+}
+
+template<typename T>
+inline MString *MString::JniCastNonNull(T s) {
+  DCHECK(s != nullptr);
+  return JniCast(s);
+}
+
+inline jstring MString::AsJstring() const {
+  return reinterpret_cast<jstring>(const_cast<MString*>(this));
+}
+} // namespace maplert
+#endif // MRT_MAPLERT_INCLUDE_MSTRING_INLINE_H_
diff --git a/src/mrt/maplert/include/reflection_list.def b/src/mrt/maplert/include/reflection_list.def
new file mode 100644
index 0000000000000000000000000000000000000000..3f339ba88b2bb683695282bdcfa2e4f7362ae70c
--- /dev/null
+++ b/src/mrt/maplert/include/reflection_list.def
@@ -0,0 +1,30 @@
+"Ljava_2Flang_2FClass_3B_7CfindInterfaceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetAccessFlags_7C_28_29I",
+"Ljava_2Flang_2FClass_3B_7CgetClasses_7C_28_29ALjava_2Flang_2FClass_3B",
+"Ljava_2Flang_2FClass_3B_7CgetClassLoader_7C_28_29Ljava_2Flang_2FClassLoader_3B",
+"Ljava_2Flang_2FClass_3B_7CgetComponentType_7C_28_29Ljava_2Flang_2FClass_3B",
+"Ljava_2Flang_2FClass_3B_7CgetConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B",
+"Ljava_2Flang_2FClass_3B_7CgetConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B",
+"Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructor_7C_28ALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FConstructor_3B",
+"Ljava_2Flang_2FClass_3B_7CgetDeclaredConstructors_7C_28_29ALjava_2Flang_2Freflect_2FConstructor_3B",
+"Ljava_2Flang_2FClass_3B_7CgetDeclaredMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetDeclaredMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetField_7C_28Ljava_2Flang_2FString_3B_29Ljava_2Flang_2Freflect_2FField_3B",
+"Ljava_2Flang_2FClass_3B_7CgetFields_7C_28_29ALjava_2Flang_2Freflect_2FField_3B",
+"Ljava_2Flang_2FClass_3B_7CgetInstanceMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetInterfaces_7C_28_29ALjava_2Flang_2FClass_3B",
+"Ljava_2Flang_2FClass_3B_7CgetMethod_7C_28Ljava_2Flang_2FString_3BALjava_2Flang_2FClass_3B_29Ljava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetMethods_7C_28_29ALjava_2Flang_2Freflect_2FMethod_3B",
+"Ljava_2Flang_2FClass_3B_7CgetModifiers_7C_28_29I",
+"Ljava_2Flang_2FClass_3B_7CgetName_7C_28_29Ljava_2Flang_2FString_3B",
+"Ljava_2Flang_2FClass_3B_7CgetPublicFieldsRecursive_7C_28Ljava_2Futil_2FList_3B_29V",
+"Ljava_2Flang_2FClass_3B_7CgetPublicMethodsInternal_7C_28Ljava_2Futil_2FList_3B_29V",
+"Ljava_2Flang_2FClass_3B_7CgetSuperclass_7C_28_29Ljava_2Flang_2FClass_3B",
+"Ljava_2Flang_2FClass_3B_7CisAssignableFrom_7C_28Ljava_2Flang_2FClass_3B_29Z",
+"Ljava_2Flang_2FClass_3B_7CisInterface_7C_28_29Z",
+"Ljava_2Flang_2FClass_3B_7CisPrimitive_7C_28_29Z",
+"Ljava_2Flang_2FClass_3B_7CisProxy_7C_28_29Z",
+"Ljava_2Flang_2FClass_3B_7CisMemberClass_7C_28_29Z",
+"Ljava_2Flang_2FClass_3B_7CisLocalClass_7C_28_29Z",
+"Ljava_2Flang_2Fref_2FReference_3B_7Cget_7C_28_29Ljava_2Flang_2FObject_3B",
+"Ljava_2Flang_2Fref_2FReference_3B_7Cclear_7C_28_29V",
diff --git a/src/mrt/maplert/include/white_list.def b/src/mrt/maplert/include/white_list.def
new file mode 100644
index 0000000000000000000000000000000000000000..7ea27fede38d15e6317f912915c2880a3aac8d00
--- /dev/null
+++ b/src/mrt/maplert/include/white_list.def
@@ -0,0 +1,496 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+CLASS_PREFIX(Ljava_2Flang_2FOutOfMemoryError_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThreadGroup_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThread_3B)
+CLASS_PREFIX(Llibcore_2Futil_2FEmptyArray_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_3B)
+CLASS_PREFIX(Ljava_2Flang_2FFloat_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FDirectByteBuffer_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FVMRuntime_3B)
+CLASS_PREFIX(Ljava_2Futil_2FProperties_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDouble_3B)
+CLASS_PREFIX(Ljava_2Flang_2FMath_3B)
+CLASS_PREFIX(Llibcore_2Fio_2FLibcore_3B)
+CLASS_PREFIX(Llibcore_2Ficu_2FICU_3B)
+CLASS_PREFIX(Ljava_2Flang_2FAndroidHardcodedSystemProperties_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FReferenceQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2FArrayList_3B)
+CLASS_PREFIX(Ljava_2Flang_2FRuntime_3B)
+CLASS_PREFIX(Landroid_2Fsystem_2FOsConstants_3B)
+CLASS_PREFIX(Ljava_2Flang_2FInteger_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FUnsafe_3B)
+//CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B)
+//CLASS_PREFIX(Lsun_2Futil_2Flocale_2FBaseLocale_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flocale_2FBaseLocale_24Key_3B)
+//CLASS_PREFIX(Ljava_2Futil_2FLocale_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flocale_2FLanguageTag_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FVersion_3B)
+CLASS_PREFIX(Ljava_2Fio_2FFileDescriptor_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FCloseGuard_3B)
+CLASS_PREFIX(Ljava_2Flang_2FEnum_3B)
+CLASS_PREFIX(Llibcore_2Fio_2FIoTracker_24Mode_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceFieldUpdater_24AtomicReferenceFieldUpdaterImpl_3B)
+CLASS_PREFIX(Ljava_2Fio_2FBufferedInputStream_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FVM_3B)
+CLASS_PREFIX(Ljava_2Flang_2FSystem_3B)
+CLASS_PREFIX(Ljava_2Fio_2FFileSystem_3B)
+CLASS_PREFIX(Ljava_2Fio_2FUnixFileSystem_3B)
+CLASS_PREFIX(Ljava_2Fio_2FFile_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fregex_2FPattern_3B)
+CLASS_PREFIX(Ljava_2Fio_2FFile_24PathStatus_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThreadLocal_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FBlockGuard_3B)
+CLASS_PREFIX(Ljava_2Flang_2FString_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FBaseDexClassLoader_3B)
+CLASS_PREFIX(Ljava_2Flang_2FClassLoader_24SystemClassLoader_3B)
+CLASS_PREFIX(Ljava_2Flang_2FByte_3B)
+CLASS_PREFIX(Ljava_2Flang_2FInteger_24IntegerCache_3B)
+CLASS_PREFIX(Ljava_2Futil_2FUUID_3B)
+CLASS_PREFIX(Ljava_2Futil_2FHashSet_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharset_3B)
+CLASS_PREFIX(Llibcore_2Ficu_2FNativeConverter_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCodingErrorAction_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FCleaner_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteOrder_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FBits_3B)
+CLASS_PREFIX(Ljava_2Fio_2FBufferedReader_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCoderResult_3B)
+CLASS_PREFIX(Ljava_2Flang_2FLong_3B)
+CLASS_PREFIX(Ljava_2Flang_2FShort_3B)
+CLASS_PREFIX(Ljava_2Flang_2FCharacter_3B)
+CLASS_PREFIX(Ljava_2Flang_2FBoolean_3B)
+CLASS_PREFIX(Ljava_2Flang_2FStringBuffer_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FChunkHandler_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FDdmServer_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicBoolean_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCacheValue_24Strength_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCacheValue_3B)
+CLASS_PREFIX(Ljava_2Futil_2FLocale_24NoImagePreloadHolder_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FULocale_24Category_3B)
+CLASS_PREFIX(Ljava_2Futil_2FLocale_24Category_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FULocale_24JDKLocaleHelper_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FULocale_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNumberingSystem_3B)
+CLASS_PREFIX(Ljava_2Futil_2FResourceBundle_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FUResourceBundle_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeBin_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FVersionInfo_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUDebug_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24OpenType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FURI_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FZipFile_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fjar_2FJarFile_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FStandardCharsets_3B)
+CLASS_PREFIX(Ljava_2Futil_2FWeakHashMap_3B)
+CLASS_PREFIX(Ljava_2Futil_2FArrayDeque_3B)
+CLASS_PREFIX(Ljava_2Flang_2FVMClassLoader_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B)
+CLASS_PREFIX(Ljava_2Futil_2FBitSet_3B)
+CLASS_PREFIX(Lsun_2Fnet_2Fwww_2FParseUtil_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FURL_3B)
+CLASS_PREFIX(Ljava_2Flang_2FCaseMapper_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FURLConnection_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FInflater_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUConfig_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fchannels_2FFileChannel_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FNativeThreadSet_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fchannels_2FFileChannel_24MapMode_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FFileChannelImpl_24Unmapper_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUBinary_24DatPackageReader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUBinary_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsCharBuffer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FUResourceBundle_24RootType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUResource_24Key_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCurrencyData_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTreeSet_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTreeMap_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FBMPSet_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FMeasureUnit_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FLocaleIDs_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FCurrency_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUtility_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyFilter_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_24SpacingType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_24SpacingPattern_3B)
+CLASS_PREFIX(Ljava_2Flang_2FVoid_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThread_24State_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FAnnotationMember_24DefaultValues_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FAnnotationMember_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fannotation_2FAnnotation_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FAnnotationFactory_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLong_3B)
+//CLASS_PREFIX(Ljava_2Flang_2Freflect_2FProxy_24ProxyClassFactory_3B)
+CLASS_PREFIX(Ljava_2Flang_2Freflect_2FProxy_3B)
+//CLASS_PREFIX(Ljava_2Flang_2Freflect_2FWeakCache_24CacheKey_3B)
+CLASS_PREFIX(Ljava_2Flang_2Freflect_2FWeakCache_24Factory_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTimSort_3B)
+CLASS_PREFIX(Ljava_2Flang_2Freflect_2FMethod_3B)
+CLASS_PREFIX(Ljava_2Futil_2FHashMap_24TreeNode_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24EmptyIterator_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Flang_2FUScript_24ScriptUsage_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Flang_2FUScript_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsIntBuffer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUPropertyAliases_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FBytesTrie_24Result_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Flang_2FUScript_24ScriptMetadata_3B)
+CLASS_PREFIX(Lorg_2Fxmlpull_2Fv1_2FXmlPullParser_3B)
+//CLASS_PREFIX(Lorg_2Fkxml2_2Fio_2FKXmlParser_3B)
+//CLASS_PREFIX(Lorg_2Fkxml2_2Fio_2FKXmlParser_24ValueContext_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fregex_2FMatcher_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFloatingDecimal_24ExceptionalBinaryToASCIIBuffer_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFloatingDecimal_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFloatingDecimal_24ASCIIToBinaryBuffer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FTrie_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FCharTrie_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUCache_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_24Level_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FICUService_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FStringPrep_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FStringPrepDataReader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FTrie2_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FTrie2_24ValueWidth_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUBiDiProps_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FIDNA2003_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24NFKCSingleton_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FPatternProps_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FStandardPlural_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FPluralRulesLoader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2FUCaseProps_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fmath_2FMathContext_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fmath_2FBigDecimal_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FBreakIterator_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FBreakIteratorFactory_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FCaseMap_24Upper_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNumberFormat_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDisplayContext_24Type_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDisplayContext_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNormalizer_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNormalizer_24NFKDModeImpl_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FNumberFormat_24Field_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_24Operand_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_24PluralType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_24SampleType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FPluralRules_24SimpleTokenizer_3B)
+//CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FRBBIDataWrapper_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24LookAheadResults_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FStringPrepParseException_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24NameType_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FCurrency_24CurrencyUsage_3B)
+CLASS_PREFIX(Ljava_2Futil_2FEnumMap_3B)
+//CLASS_PREFIX(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FProxySelector_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FSSLSocketFactory_3B)
+CLASS_PREFIX(Landroid_2Fsystem_2FUnixSocketAddress_3B)
+CLASS_PREFIX(Ljava_2Flang_2FLong_24LongCache_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLevel_24KnownLevel_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLevel_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FHandler_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FReference_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FWeakReference_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_3B)
+CLASS_PREFIX(Llibcore_2Fnet_2Fevent_2FNetworkEventDispatcher_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FAbstractExecutorService_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReference_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FHttpURLConnection_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDebug_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FProvider_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCalendar_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FSocketTagger_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FVMDebug_3B)
+CLASS_PREFIX(Ljava_2Fio_2FConsole_3B)
+CLASS_PREFIX(Ljava_2Fio_2FObjectStreamConstants_3B)
+CLASS_PREFIX(Ljava_2Fio_2FObjectInputStream_3B)
+CLASS_PREFIX(Ljava_2Fio_2FObjectStreamClass_3B)
+CLASS_PREFIX(Ljava_2Flang_2FByte_24ByteCache_3B)
+CLASS_PREFIX(Ljava_2Flang_2FCharacter_24CharacterCache_3B)
+CLASS_PREFIX(Ljava_2Flang_2FCharacter_24UnicodeBlock_3B)
+CLASS_PREFIX(Ljava_2Flang_2FClass_24Caches_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FFinalizerReference_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDaemons_24FinalizerDaemon_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDaemons_24FinalizerWatchdogDaemon_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDaemons_24HeapTaskDaemon_3B)
+CLASS_PREFIX(Ljava_2Flang_2FDaemons_24ReferenceQueueDaemon_3B)
+CLASS_PREFIX(Ljava_2Futil_2FRandom_3B)
+CLASS_PREFIX(Ljava_2Flang_2FMath_24RandomNumberGeneratorHolder_3B)
+CLASS_PREFIX(Ljava_2Flang_2FPackage_3B)
+CLASS_PREFIX(Ljava_2Flang_2FProcessBuilder_3B)
+CLASS_PREFIX(Ljava_2Flang_2FProcessEnvironment_3B)
+CLASS_PREFIX(Ljava_2Flang_2FShort_24ShortCache_3B)
+CLASS_PREFIX(Ljava_2Flang_2FStrictMath_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThread_24Caches_3B)
+CLASS_PREFIX(Ljava_2Flang_2FThrowable_24SentinelHolder_3B)
+CLASS_PREFIX(Ljava_2Flang_2FUNIXProcess_24ProcessReaperThreadFactory_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_3B)
+CLASS_PREFIX(Ljava_2Flang_2FUNIXProcess_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodHandleStatics_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FCallSite_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodHandle_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodHandles_24Lookup_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodType_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodTypeForm_3B)
+CLASS_PREFIX(Ljava_2Flang_2Freflect_2FMethod_241_3B)
+CLASS_PREFIX(Llibcore_2Fmath_2FMathUtils_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FBigInt_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FBigInteger_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FMultiplication_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FBigDecimal_3B)
+CLASS_PREFIX(Ljava_2Fmath_2FRoundingMode_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInet6AddressImpl_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInetAddress_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInet4Address_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInet6Address_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FInetSocketAddress_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FNetworkInterface_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FProxy_24Type_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FProxy_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FServerSocket_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FSocket_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FSocksSocketImpl_3B)
+CLASS_PREFIX(Ljava_2Fnet_2FURLEncoder_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsDoubleBuffer_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsFloatBuffer_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsLongBuffer_3B)
+CLASS_PREFIX(Ljava_2Fnio_2FByteBufferAsShortBuffer_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fchannels_2FSocketChannel_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FCryptoPrimitive_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FKeyFactory_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FProvider_24Service_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FSecureRandom_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FSecurity_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FSignature_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2FSignature_24Delegate_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FObjectIdentifier_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2Fspec_2FECPoint_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FAttributedCharacterIterator_24Attribute_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDateFormat_24Field_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDateFormatSymbols_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FNumberFormat_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDecimalFormat_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDecimalFormatSymbols_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FDontCareFieldPosition_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FNormalizer_24Form_3B)
+CLASS_PREFIX(Ljava_2Futil_2FEnumSet_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FSimpleDateFormat_3B)
+CLASS_PREFIX(Ljava_2Futil_2FArrays_24NaturalOrder_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24CopiesList_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24EmptyEnumeration_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24EmptyListIterator_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24ReverseComparator_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24ReverseComparator2_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24UnmodifiableNavigableMap_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCollections_24UnmodifiableNavigableSet_3B)
+CLASS_PREFIX(Ljava_2Futil_2FComparableTimSort_3B)
+CLASS_PREFIX(Ljava_2Futil_2FComparators_24NaturalOrderComparator_3B)
+CLASS_PREFIX(Ljava_2Futil_2FCurrency_3B)
+CLASS_PREFIX(Lsun_2Futil_2Fcalendar_2FCalendarSystem_3B)
+CLASS_PREFIX(Ljava_2Futil_2FDate_3B)
+CLASS_PREFIX(Ljava_2Futil_2FFormatter_24Flags_3B)
+CLASS_PREFIX(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B)
+CLASS_PREFIX(Ljava_2Futil_2FGregorianCalendar_3B)
+CLASS_PREFIX(Ljava_2Futil_2FLocale_24FilteringMode_3B)
+CLASS_PREFIX(Ljava_2Futil_2FSimpleTimeZone_3B)
+CLASS_PREFIX(Ljava_2Futil_2FSpliterators_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24Node_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FExecutors_24DefaultThreadFactory_3B)
+// CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FFutureTask_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_24SNode_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceArray_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24Node_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2Flocks_2FLockSupport_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_3B)
+//CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogManager_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogManager_242_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogRecord_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLogger_3B)
+CLASS_PREFIX(Ljava_2Futil_2Flogging_2FLoggingProxyImpl_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fprefs_2FPreferences_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B)
+//CLASS_PREFIX(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fregex_2FPatternSyntaxException_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FStreamOpFlag_24Type_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FStreamOpFlag_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FStreamShape_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FAdler32_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FCRC32_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fzip_2FDeflater_3B)
+CLASS_PREFIX(Ljavax_2Fcrypto_2FCipher_24InitType_3B)
+CLASS_PREFIX(Ljavax_2Fcrypto_2FCipher_24NeedToSet_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FHttpsURLConnection_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FSNIServerName_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FSSLServerSocketFactory_3B)
+CLASS_PREFIX(Ljavax_2Fsecurity_2Fcert_2FX509Certificate_3B)
+CLASS_PREFIX(Llibcore_2Ficu_2FLocaleData_3B)
+//CLASS_PREFIX(Llibcore_2Fio_2FDropBox_3B)
+//CLASS_PREFIX(Llibcore_2Fio_2FEventLogger_3B)
+CLASS_PREFIX(Llibcore_2Fnet_2FNetworkSecurityPolicy_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FListOfTypes_3B)
+CLASS_PREFIX(Llibcore_2Freflect_2FTypes_3B)
+CLASS_PREFIX(Llibcore_2Futil_2FZoneInfo_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B)
+CLASS_PREFIX(Lorg_2Fjson_2FJSONObject_3B)
+CLASS_PREFIX(Lorg_2Fjson_2FJSONStringer_24Scope_3B)
+CLASS_PREFIX(Lsun_2Finvoke_2Futil_2FVerifyAccess_3B)
+CLASS_PREFIX(Lsun_2Finvoke_2Futil_2FWrapper_24Format_3B)
+CLASS_PREFIX(Lsun_2Finvoke_2Futil_2FWrapper_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFDBigInteger_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFormattedFloatingDecimal_3B)
+CLASS_PREFIX(Lsun_2Fmisc_2FFormattedFloatingDecimal_24Form_3B)
+CLASS_PREFIX(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_24NonProxyInfo_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FFileLockImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FIOUtil_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FNet_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FSharedFileLockTable_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FUtil_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fch_2FUtil_24BufferCache_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fjca_2FProviderConfig_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fjca_2FProviderList_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FCertificateExtensions_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attribute_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FAlgorithmDecomposer_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraints_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2FX509Factory_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdaptableX509CertSelector_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraint_24Operator_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FConstraintsChecker_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FKeyChecker_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIXCertPathValidator_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIXMasterCertPathValidator_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FBitArray_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Futil_2FDerOutputStream_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FAVA_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FX500Name_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FAVAKeyword_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FAccessDescription_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FAlgorithmId_3B)
+CLASS_PREFIX(Ljava_2Fsecurity_2Fcert_2FCRLReason_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FCRLReasonCodeExtension_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FDistributionPoint_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FExtendedKeyUsageExtension_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FInhibitAnyPolicyExtension_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FNetscapeCertTypeExtension_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FPKIXExtensions_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FOIDMap_3B)
+CLASS_PREFIX(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B)
+CLASS_PREFIX(Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flogging_2FLoggingSupport_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flogging_2FPlatformLogger_24Level_3B)
+CLASS_PREFIX(Lsun_2Futil_2Flogging_2FPlatformLogger_3B)
+CLASS_PREFIX(Ljava_2Fio_2FBufferedWriter_3B)
+//CLASS_PREFIX(Lsun_2Fsecurity_2Fjca_2FProviders_3B)
+//CLASS_PREFIX(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_3B)
+CLASS_PREFIX(Ljava_2Futil_2FScanner_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FCollectors_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FNodes_3B)
+CLASS_PREFIX(Ljava_2Futil_2Fstream_2FReferencePipeline_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTaskQueue_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTimer_3B)
+CLASS_PREFIX(Ljava_2Futil_2FTimerThread_3B)
+//CLASS_PREFIX(Ljavax_2Fcrypto_2FJceSecurity_3B)
+CLASS_PREFIX(Ljavax_2Fnet_2Fssl_2FSNIHostName_3B)
+CLASS_PREFIX(Ljavax_2Fxml_2Fparsers_2FFilePathToURI_3B)
+//CLASS_PREFIX(Llibcore_2Ficu_2FTimeZoneNames_3B)
+CLASS_PREFIX(Llibcore_2Futil_2FHexEncoding_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FCommentImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentTypeImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FTextImpl_3B)
+CLASS_PREFIX(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderImpl_3B)
+CLASS_PREFIX(Lsun_2Fnet_2FNetProperties_3B)
+CLASS_PREFIX(Lsun_2Fnet_2FProgressMonitor_3B)
+CLASS_PREFIX(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FNativeBuffer_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FNativeBuffers_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataReader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatin_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationLoader_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRoot_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FCollator_3B)
+//CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FDigitList_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FBytesTrie_3B)
+CLASS_PREFIX(Landroid_2Ficu_2Futil_2FTimeUnit_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FPathClassLoader_3B)
+CLASS_PREFIX(Ljava_2Ftext_2FMessageFormat_3B)
+CLASS_PREFIX(Llibcore_2Fio_2FStreams_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FUnixNativeDispatcher_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FUnixPath_3B)
+CLASS_PREFIX(Lsun_2Fnio_2Ffs_2FUtil_3B)
+CLASS_PREFIX(Lsun_2Futil_2Fcalendar_2FGregorian_3B)
+CLASS_PREFIX(Ljava_2Flang_2FInheritableThreadLocal_3B)
+CLASS_PREFIX(Ljava_2Flang_2Fref_2FPhantomReference_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B)
+CLASS_PREFIX(Ljava_2Fnio_2Ffile_2FFiles_3B)
+CLASS_PREFIX(Ljava_2Futil_2FIdentityHashMap_3B)
+CLASS_PREFIX(Ljava_2Futil_2FLinkedHashSet_3B)
+CLASS_PREFIX(Ljava_2Futil_2FRegularEnumSet_3B)
+//CLASS_PREFIX(Llibcore_2Futil_2FZoneInfoDB_3B)
+//CLASS_PREFIX(Ljava_2Flang_2FBootClassLoader_3B)
+CLASS_PREFIX(Ljava_2Flang_2Finvoke_2FMethodType_3B)
+CLASS_PREFIX(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B)
+CLASS_PREFIX(Ljava_2Flang_2FStringFactory_3B)
+CLASS_PREFIX(Ljava_2Flang_2FNumber_3B)
+CLASS_PREFIX(Ljava_2Futil_2FHashMap_3B)
diff --git a/src/mrt/maplert/linker/mapleArm32lld.so.lds b/src/mrt/maplert/linker/mapleArm32lld.so.lds
new file mode 100644
index 0000000000000000000000000000000000000000..42313648867d1882067c303a5210f637753c168e
--- /dev/null
+++ b/src/mrt/maplert/linker/mapleArm32lld.so.lds
@@ -0,0 +1,438 @@
+/* Script for -pie -z combreloc: position independent executable, combine & sort relocs */
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+OUTPUT_FORMAT("elf32-littlearm", "elf32-bigarm",
+              "elf32-littlearm")
+OUTPUT_ARCH(arm)
+SEARCH_DIR("=/usr/arm-linux-gnueabihf/lib"); SEARCH_DIR("=/lib/arm-linux-gnueabihf"); SEARCH_DIR("=/usr/lib/arm-linux-gnueabihf"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib"); SEARCH_DIR("=/usr/local/arm-linux-gnueabihf/lib");
+PHDRS
+{
+  text PT_LOAD FILEHDR PHDRS;
+  data PT_LOAD;
+  dynamic PT_DYNAMIC;
+  note PT_NOTE;
+  gnu_eh_frame PT_GNU_EH_FRAME;
+  gnu_stack PT_GNU_STACK;
+  gnu_relro PT_GNU_RELRO;
+  /*  headers PT_PHDR PHDRS; */ /* Reserve segment for lld */
+  /*  interp PT_INTERP;      */ /* Reserve segment for lld */
+  thread_local PT_TLS;          /* Reserve segment for lld */
+}
+
+SECTIONS
+{
+  PROVIDE_HIDDEN(__maple_start__ = .);
+  /* Read-only sections, merged into text segment: */
+  PROVIDE (__executable_start = SEGMENT_START("text-segment", 0)); . = SEGMENT_START("text-segment", 0) + SIZEOF_HEADERS;
+  .interp         : { *(.interp) }
+  .note.gnu.build-id :
+  {
+    PROVIDE_HIDDEN (__linkerHashSo_begin = .);
+    KEEP (*(.note.gnu.build-id))
+    PROVIDE_HIDDEN (__linkerHashSo_end = .);
+  } :text :note
+  .hash           : { *(.hash) } :text
+  .gnu.hash       : { *(.gnu.hash) }
+  .dynsym         : { *(.dynsym) }
+  .dynstr         : { *(.dynstr) }
+  .gnu.version    : { *(.gnu.version) }
+  .gnu.version_d  : { *(.gnu.version_d) }
+  .gnu.version_r  : { *(.gnu.version_r) }
+  .rela.dyn       :
+    {
+      *(.rela.init)
+      *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
+      *(.rela.fini)
+      *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
+      *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
+      *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
+      *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
+      *(.rela.ctors)
+      *(.rela.dtors)
+      *(.rela.got)
+      *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
+      *(.rela.ifunc)
+    }
+  .rela.plt       :
+    {
+      *(.rela.plt)
+      PROVIDE_HIDDEN (__rela_iplt_start = .);
+      *(.rela.iplt)
+      PROVIDE_HIDDEN (__rela_iplt_end = .);
+    }
+  .init           :
+  {
+    KEEP (*(.init))
+  } =0
+  .plt            : ALIGN(16) { *(.plt) *(.iplt) }
+  .text           :
+  {
+    *(.text.unlikely .text.*_unlikely .text.unlikely.*)
+    *(.text.exit .text.exit.*)
+    *(.text.startup .text.startup.*)
+    *(.text.hot .text.hot.*)
+    *(.text .stub .text.* .gnu.linkonce.t.*)
+    /* .gnu.warning sections are handled specially by elf32.em.  */
+    *(.gnu.warning)
+  } =0
+  .java_text     :
+  {
+    PROVIDE_HIDDEN (java_text_begin = .);
+    KEEP (*(.java_text))
+    PROVIDE_HIDDEN (java_text_end = .);
+  }
+  .fini           :
+  {
+    KEEP (*(.fini))
+  } =0
+  PROVIDE (__etext = .);
+  PROVIDE (_etext = .);
+  PROVIDE (etext = .);
+  .rodata         :
+  {
+    *(.rodata .rodata.* .gnu.linkonce.r.*)
+  }
+  .rometadata     :
+  {
+    mfile_rometadata_method_start = .;
+    KEEP (*(.rometadata.method))
+    mfile_rometadata_method_end = .;
+
+    mfile_rometadata_field_start = .;
+    KEEP (*(.rometadata.field))
+    mfile_rometadata_field_end = .;
+  }
+  .romuidtab      :
+  {
+    mfile_romuidtab_start = .;
+    KEEP (*(.__muid_ro_func_def_orig_tab))
+    KEEP (*(.__muid_ro_data_def_orig_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_func_inf_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_func_def_muid_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_data_def_muid_tab))
+    KEEP (*(.__muid_ro_func_undef_muid_tab))
+    KEEP (*(.__muid_ro_data_undef_muid_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_func_muid_idx_tab))
+    mfile_romuidtab_end = .;
+  }
+  .rodata1        : { *(.rodata1) }
+  .eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) } :text :gnu_eh_frame
+  .eh_frame       : ONLY_IF_RO
+  {
+    PROVIDE_HIDDEN ( __eh_frame_start = .);
+    KEEP (*(.eh_frame)) *(.eh_frame.*)
+    PROVIDE_HIDDEN ( __eh_frame_end = .);
+  } :text
+  .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table
+  .gcc_except_table.*) }
+  .gnu_extab   : ONLY_IF_RO { *(.gnu_extab*) }
+  /* These sections are generated by the Sun/Oracle C++ compiler.  */
+  .exception_ranges   : ONLY_IF_RO { *(.exception_ranges
+  .exception_ranges*) }
+
+  /* Adjust the address for the data segment.  We want to adjust up to
+     the same address within the page on the next page up.  */
+  . = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
+  /* Exception handling  */
+  .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
+  .gnu_extab      : ONLY_IF_RW { *(.gnu_extab) }
+  .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
+  .exception_ranges   : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
+  /* Thread Local Storage sections  */
+  .tdata      : { *(.tdata .tdata.* .gnu.linkonce.td.*) } :thread_local
+  .tbss       : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } :thread_local
+  .dynamic        : { *(.dynamic) } :data :gnu_relro :dynamic
+  .preinit_array     :
+  {
+    PROVIDE_HIDDEN (__preinit_array_start = .);
+    KEEP (*(.preinit_array))
+    PROVIDE_HIDDEN (__preinit_array_end = .);
+  }
+  .init_array     :
+  {
+    PROVIDE_HIDDEN (__init_array_start = .);
+    KEEP (*(.init_array.* .ctors.*))
+    KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
+    PROVIDE_HIDDEN (__init_array_end = .);
+  } :data :gnu_relro
+  .fini_array     :
+  {
+    PROVIDE_HIDDEN (__fini_array_start = .);
+    KEEP (*(.fini_array.* .dtors.*))
+    KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
+    PROVIDE_HIDDEN (__fini_array_end = .);
+  } :data :gnu_relro
+  .ctors          :
+  {
+    /* gcc uses crtbegin.o to find the start of
+       the constructors, so we make sure it is
+       first.  Because this is a wildcard, it
+       doesn't matter if the user does not
+       actually link against crtbegin.o; the
+       linker won't look for a file to match a
+       wildcard.  The wildcard also means that it
+       doesn't matter which directory crtbegin.o
+       is in.  */
+    KEEP (*crtbegin.o(.ctors))
+    KEEP (*crtbegin?.o(.ctors))
+    /* We don't want to include the .ctor section from
+       the crtend.o file until after the sorted ctors.
+       The .ctor section from the crtend file contains the
+       end of ctors marker and it must be last */
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
+    KEEP (*(SORT(.ctors.*)))
+    KEEP (*(.ctors))
+  }
+  .dtors          :
+  {
+    KEEP (*crtbegin.o(.dtors))
+    KEEP (*crtbegin?.o(.dtors))
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
+    KEEP (*(SORT(.dtors.*)))
+    KEEP (*(.dtors))
+  }
+  .jcr            : { KEEP (*(.jcr)) }
+  .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
+  .got            : { *(.got) *(.igot) } :data :gnu_relro
+  . = DATA_SEGMENT_RELRO_END (24, .);
+  .got.plt        : { *(.got.plt)  *(.igot.plt) } :data
+  .data           :
+  {
+    PROVIDE_HIDDEN (__data_section_begin = .);
+    *(.data .data.* .gnu.linkonce.d.*)
+    SORT(CONSTRUCTORS)
+    PROVIDE_HIDDEN (__data_section_end = .);
+  }
+  .data1          : { *(.data1) }
+  _edata = .; PROVIDE (edata = .);
+  /* maple specific sections */
+  . = ALIGN( 8 );
+  .maple_global_variable :
+  {
+    KEEP (*(.maple_global_variable))
+  }
+
+  . = ALIGN( 8 );
+  .maple_literal_string :
+  {
+    KEEP (*(.maple_literal_string))
+  }
+
+  . = ALIGN( 8 );
+  .maple.gcrootsmap :
+  {
+    KEEP (*(.maple.gcrootsmap))
+  }
+
+  . = ALIGN( 8 );
+  .reg_jni_tab :
+  {
+    PROVIDE_HIDDEN (__reg_jni_tab_begin = .);
+    KEEP (*(.reg_jni_tab))
+    PROVIDE_HIDDEN (__reg_jni_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .reg_jni_func_tab :
+  {
+    PROVIDE_HIDDEN (__reg_jni_func_tab_begin = .);
+    KEEP (*(.reg_jni_func_tab))
+    PROVIDE_HIDDEN (__reg_jni_func_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .bb_profile_strtab :
+  {
+    PROVIDE_HIDDEN (__bb_profile_strtab_begin = .);
+    KEEP (*(.__bb_profile_strtab))
+    PROVIDE_HIDDEN (__bb_profile_strtab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .bb_profile_tab :
+  {
+    PROVIDE_HIDDEN (__bb_profile_tab_begin = .);
+    KEEP (*(.__bb_profile_tab))
+    PROVIDE_HIDDEN (__bb_profile_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .muid_tab :
+  {
+    PROVIDE_HIDDEN (__muid_tab_start = .);
+
+    PROVIDE_HIDDEN (__decouple_start__ = .);
+    KEEP (*(.__decouple))
+    PROVIDE_HIDDEN (__decouple_end__ = .);
+
+    PROVIDE_HIDDEN (__muid_range_tab_begin__ = .);
+    KEEP (*(.__muid_range_tab))
+    PROVIDE_HIDDEN (__muid_range_tab_end__ = .);
+
+    PROVIDE_HIDDEN (__muid_conststr_start__ = .);
+    KEEP (*(.__muid_conststr))
+    PROVIDE_HIDDEN (__muid_conststr_end__ = .);
+
+    KEEP (*(.__muid_func_def_tab))
+    KEEP (*(.__muid_func_undef_tab))
+    KEEP (*(.__muid_data_def_tab))
+    KEEP (*(.__muid_data_undef_tab))
+    KEEP (*(.__muid_itab))
+    KEEP (*(.__muid_vtab))
+    KEEP (*(.__muid_vtab_offset_tab))
+    KEEP (*(.__muid_field_offset_tab))
+    KEEP (*(.__muid_superclass))
+    KEEP (*(.__muid_offset_value_table))
+    KEEP (*(.__muid_local_classinfo_tab))
+
+    PROVIDE_HIDDEN (__muid_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .mpl_version :
+  {
+    PROVIDE_HIDDEN (__compilerVersionNumTab_begin__ = .);
+    KEEP (*(.__compilerVersionNumTab))
+    PROVIDE_HIDDEN (__compilerVersionNumTab_end__ = .);
+
+    KEEP (*(.__sourceMuidTab))
+
+    PROVIDE_HIDDEN (__compiler_mfile_status_begin__ = .);
+    KEEP (*(.__compiler_mfile_status))
+    PROVIDE_HIDDEN (__compiler_mfile_status_end__ = .);
+  }
+
+  . = ALIGN( 8 );
+  .profile_tab :
+  {
+    KEEP (*(.__profile_func_tab))
+  }
+
+  . = ALIGN( 8 );
+  .classmetadata :
+  {
+    KEEP (*(.__muid_classmetadata))
+  }
+
+  . = ALIGN( 8 );
+  .classmetadata_bucket :
+  {
+    PROVIDE_HIDDEN (__muid_classmetadata_bucket_begin = .);
+    *(.__muid_classmetadata_bucket)
+    PROVIDE_HIDDEN (__muid_classmetadata_bucket_end = .);
+  }
+
+  .refl_strtab :
+  {
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_strtab_start__ = .);
+    KEEP (*(.reflection_strtab))
+    PROVIDE_HIDDEN(__reflection_strtab_end__ = .);
+  }
+
+  .refl_strtab.hot :
+  {
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_start_hot_strtab_start__ = .);
+    KEEP (*(.reflection_start_hot_strtab))
+    PROVIDE_HIDDEN(__reflection_start_hot_strtab_end__ = .);
+
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_both_hot_strtab_start__ = .);
+    KEEP (*(.reflection_both_hot_strtab))
+    PROVIDE_HIDDEN(__reflection_both_hot_strtab_end__ = .);
+
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_run_hot_strtab_start__ = .);
+    KEEP (*(.reflection_run_hot_strtab))
+    PROVIDE_HIDDEN(__reflection_run_hot_strtab_end__ = .);
+  }
+
+  . = ALIGN( 4096 );
+  __bss_start = . ;  __bss_start__ = . ;
+  .bss            :
+  {
+    PROVIDE_HIDDEN(__bss_section_begin = .);
+   *(.dynbss)
+   *(.bss .bss.* .gnu.linkonce.b.*)
+   *(COMMON)
+   /* Align here to ensure that the .bss section occupies space up to
+      _end.  Align after .bss to ensure correct alignment even if the
+      .bss section disappears because there are no input sections.
+      FIXME: Why do we need it? When there is no .bss section, we don't
+      pad the .data section.  */
+   . = ALIGN(. != 0 ? 64 / 8 : 1);
+    PROVIDE_HIDDEN(__bss_section_end = .);
+  }
+  _bss_end__ = . ; __bss_end__ = . ;
+
+  . = ALIGN(64 / 8);
+  . = SEGMENT_START("ldata-segment", .);
+  . = ALIGN(64 / 8);
+  __end__ = .;
+  PROVIDE_HIDDEN(__maple_end__ = .);
+  _end = .; PROVIDE (end = .);
+  . = DATA_SEGMENT_END (.);
+  /* Stabs debugging sections.  */
+  .stab          0 : { *(.stab) }
+  .stabstr       0 : { *(.stabstr) }
+  .stab.excl     0 : { *(.stab.excl) }
+  .stab.exclstr  0 : { *(.stab.exclstr) }
+  .stab.index    0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment       0 : { *(.comment) }
+  /* DWARF debug sections.
+     Symbols in the DWARF debugging sections are relative to the beginning
+     of the section so we begin them at 0.  */
+  /* DWARF 1 */
+  .debug          0 : { *(.debug) }
+  .line           0 : { *(.line) }
+  /* GNU DWARF 1 extensions */
+  .debug_srcinfo  0 : { *(.debug_srcinfo) }
+  .debug_sfnames  0 : { *(.debug_sfnames) }
+  /* DWARF 1.1 and DWARF 2 */
+  .debug_aranges  0 : { *(.debug_aranges) }
+  .maple_java_debug_aranges  0 : { KEEP(*(.maple_java_debug_aranges)) }
+  .debug_pubnames 0 : { *(.debug_pubnames) }
+  /* DWARF 2 */
+  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .maple_java_debug_info     0 : { KEEP(*(.maple_java_debug_info)) }
+  .debug_abbrev   0 : { *(.debug_abbrev) }
+  .maple_java_debug_abbrev   0 : { KEEP(*(.maple_java_debug_abbrev)) }
+  .debug_line     0 : { *(.debug_line .debug_line.* .debug_line_end ) }
+  .maple_java_debug_line     0 : { KEEP(*(.maple_java_debug_line)) }
+  .debug_frame    0 : { *(.debug_frame) }
+  .debug_str      0 : { *(.debug_str) }
+  .debug_loc      0 : { *(.debug_loc) }
+  .debug_macinfo  0 : { *(.debug_macinfo) }
+  /* SGI/MIPS DWARF 2 extensions */
+  .debug_weaknames 0 : { *(.debug_weaknames) }
+  .debug_funcnames 0 : { *(.debug_funcnames) }
+  .debug_typenames 0 : { *(.debug_typenames) }
+  .debug_varnames  0 : { *(.debug_varnames) }
+  /* DWARF 3 */
+  .debug_pubtypes 0 : { *(.debug_pubtypes) }
+  .debug_ranges   0 : { *(.debug_ranges) }
+  .maple_java_debug_ranges   0 : { KEEP(*(.maple_java_debug_ranges)) }
+  /* DWARF Extension.  */
+  .debug_macro    0 : { *(.debug_macro) }
+  .ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
+  .note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
+  /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
+}
diff --git a/src/mrt/maplert/linker/mapleld.so.lds b/src/mrt/maplert/linker/mapleld.so.lds
new file mode 100644
index 0000000000000000000000000000000000000000..1e676837225b9934da985f1896dc87cc22cc2174
--- /dev/null
+++ b/src/mrt/maplert/linker/mapleld.so.lds
@@ -0,0 +1,409 @@
+/* Script for -pie -z combreloc: position independent executable, combine & sort relocs */
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64",
+	      "elf64-littleaarch64")
+OUTPUT_ARCH(aarch64)
+SEARCH_DIR("=/usr/local/lib/aarch64-linux-gnu"); SEARCH_DIR("=/lib/aarch64-linux-gnu"); SEARCH_DIR("=/usr/lib/aarch64-linux-gnu"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib"); SEARCH_DIR("=/usr/aarch64-linux-gnu/lib");
+SECTIONS
+{
+  PROVIDE_HIDDEN(__maple_start__ = .);
+  /* Read-only sections, merged into text segment: */
+  PROVIDE (__executable_start = SEGMENT_START("text-segment", 0)); . = SEGMENT_START("text-segment", 0) + SIZEOF_HEADERS;
+  .interp         : { *(.interp) }
+  .note.gnu.build-id :
+  {
+    PROVIDE_HIDDEN (__linkerHashSo_begin = .);
+    KEEP (*(.note.gnu.build-id))
+    PROVIDE_HIDDEN (__linkerHashSo_end = .);
+  }
+  .hash           : { *(.hash) }
+  .gnu.hash       : { *(.gnu.hash) }
+  .dynsym         : { *(.dynsym) }
+  .dynstr         : { *(.dynstr) }
+  .gnu.version    : { *(.gnu.version) }
+  .gnu.version_d  : { *(.gnu.version_d) }
+  .gnu.version_r  : { *(.gnu.version_r) }
+  .rela.dyn       :
+    {
+      *(.rela.init)
+      *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
+      *(.rela.fini)
+      *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
+      *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
+      *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
+      *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
+      *(.rela.ctors)
+      *(.rela.dtors)
+      *(.rela.got)
+      *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
+      *(.rela.ifunc)
+    }
+  .rela.plt       :
+    {
+      *(.rela.plt)
+      PROVIDE_HIDDEN (__rela_iplt_start = .);
+      *(.rela.iplt)
+      PROVIDE_HIDDEN (__rela_iplt_end = .);
+    }
+  .init           :
+  {
+    KEEP (*(.init))
+  } =0
+  .plt            : ALIGN(16) { *(.plt) *(.iplt) }
+  .text           :
+  {
+    *(.text.unlikely .text.*_unlikely .text.unlikely.*)
+    *(.text.exit .text.exit.*)
+    *(.text.startup .text.startup.*)
+    *(.text.hot .text.hot.*)
+    *(.text .stub .text.* .gnu.linkonce.t.*)
+    /* .gnu.warning sections are handled specially by elf32.em.  */
+    *(.gnu.warning)
+  } =0
+  .java_text     :
+  {
+    PROVIDE_HIDDEN (java_text_begin = .);
+    KEEP (*(.java_text))
+    PROVIDE_HIDDEN (java_text_end = .);
+  }
+  .fini           :
+  {
+    KEEP (*(.fini))
+  } =0
+  PROVIDE (__etext = .);
+  PROVIDE (_etext = .);
+  PROVIDE (etext = .);
+  .rodata         :
+  {
+    *(.rodata .rodata.* .gnu.linkonce.r.*)
+  }
+  .rometadata     :
+  {
+    mfile_rometadata_method_start = .;
+    KEEP (*(.rometadata.method))
+    mfile_rometadata_method_end = .;
+
+    mfile_rometadata_field_start = .;
+    KEEP (*(.rometadata.field))
+    mfile_rometadata_field_end = .;
+  }
+  .romuidtab      :
+  {
+    mfile_romuidtab_start = .;
+    KEEP (*(.__muid_ro_func_def_orig_tab))
+    KEEP (*(.__muid_ro_data_def_orig_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_func_inf_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_func_def_muid_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_data_def_muid_tab))
+    KEEP (*(.__muid_ro_func_undef_muid_tab))
+    KEEP (*(.__muid_ro_data_undef_muid_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_func_muid_idx_tab))
+    mfile_romuidtab_end = .;
+  }
+  .rodata1        : { *(.rodata1) }
+  .eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
+  .eh_frame       : ONLY_IF_RO
+  {
+    PROVIDE_HIDDEN ( __eh_frame_start = .);
+    KEEP (*(.eh_frame)) *(.eh_frame.*)
+    PROVIDE_HIDDEN ( __eh_frame_end = .);
+  }
+  .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table
+  .gcc_except_table.*) }
+  .gnu_extab   : ONLY_IF_RO { *(.gnu_extab*) }
+  /* These sections are generated by the Sun/Oracle C++ compiler.  */
+  .exception_ranges   : ONLY_IF_RO { *(.exception_ranges
+  .exception_ranges*) }
+  /* Adjust the address for the data segment.  We want to adjust up to
+     the same address within the page on the next page up.  */
+  . = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
+  /* Exception handling  */
+  .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
+  .gnu_extab      : ONLY_IF_RW { *(.gnu_extab) }
+  .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
+  .exception_ranges   : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
+  /* Thread Local Storage sections  */
+  .tdata	  : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
+  .tbss		  : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
+  .preinit_array     :
+  {
+    PROVIDE_HIDDEN (__preinit_array_start = .);
+    KEEP (*(.preinit_array))
+    PROVIDE_HIDDEN (__preinit_array_end = .);
+  }
+  .init_array     :
+  {
+    PROVIDE_HIDDEN (__init_array_start = .);
+    KEEP (*(.init_array.* .ctors.*))
+    KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
+    PROVIDE_HIDDEN (__init_array_end = .);
+  }
+  .fini_array     :
+  {
+    PROVIDE_HIDDEN (__fini_array_start = .);
+    KEEP (*(.fini_array.* .dtors.*))
+    KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
+    PROVIDE_HIDDEN (__fini_array_end = .);
+  }
+  .ctors          :
+  {
+    /* gcc uses crtbegin.o to find the start of
+       the constructors, so we make sure it is
+       first.  Because this is a wildcard, it
+       doesn't matter if the user does not
+       actually link against crtbegin.o; the
+       linker won't look for a file to match a
+       wildcard.  The wildcard also means that it
+       doesn't matter which directory crtbegin.o
+       is in.  */
+    KEEP (*crtbegin.o(.ctors))
+    KEEP (*crtbegin?.o(.ctors))
+    /* We don't want to include the .ctor section from
+       the crtend.o file until after the sorted ctors.
+       The .ctor section from the crtend file contains the
+       end of ctors marker and it must be last */
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
+    KEEP (*(SORT(.ctors.*)))
+    KEEP (*(.ctors))
+  }
+  .dtors          :
+  {
+    KEEP (*crtbegin.o(.dtors))
+    KEEP (*crtbegin?.o(.dtors))
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
+    KEEP (*(SORT(.dtors.*)))
+    KEEP (*(.dtors))
+  }
+  .jcr            : { KEEP (*(.jcr)) }
+  .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
+  .dynamic        : { *(.dynamic) }
+  .got            : { *(.got) *(.igot) }
+  . = DATA_SEGMENT_RELRO_END (24, .);
+  .got.plt        : { *(.got.plt)  *(.igot.plt) }
+  .data           :
+  {
+    PROVIDE_HIDDEN (__data_section_begin = .);
+    *(.data .data.* .gnu.linkonce.d.*)
+    SORT(CONSTRUCTORS)
+    PROVIDE_HIDDEN (__data_section_end = .);
+  }
+  .data1          : { *(.data1) }
+  _edata = .; PROVIDE (edata = .);
+  /* maple specific sections */
+  . = ALIGN( 8 );
+  .maple.gcrootsmap :
+  {
+    KEEP (*(.maple.gcrootsmap))
+  }
+
+  . = ALIGN( 8 );
+  .reg_jni_tab :
+  {
+    PROVIDE_HIDDEN (__reg_jni_tab_begin = .);
+    KEEP (*(.reg_jni_tab))
+    PROVIDE_HIDDEN (__reg_jni_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .reg_jni_func_tab :
+  {
+    PROVIDE_HIDDEN (__reg_jni_func_tab_begin = .);
+    KEEP (*(.reg_jni_func_tab))
+    PROVIDE_HIDDEN (__reg_jni_func_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .bb_profile_strtab :
+  {
+    PROVIDE_HIDDEN (__bb_profile_strtab_begin = .);
+    KEEP (*(.__bb_profile_strtab))
+    PROVIDE_HIDDEN (__bb_profile_strtab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .bb_profile_tab :
+  {
+    PROVIDE_HIDDEN (__bb_profile_tab_begin = .);
+    KEEP (*(.__bb_profile_tab))
+    PROVIDE_HIDDEN (__bb_profile_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .muid_tab :
+  {
+    PROVIDE_HIDDEN (__muid_tab_start = .);
+
+    PROVIDE_HIDDEN (__decouple_start__ = .);
+    KEEP (*(.__decouple))
+    PROVIDE_HIDDEN (__decouple_end__ = .);
+
+    PROVIDE_HIDDEN (__muid_range_tab_begin__ = .);
+    KEEP (*(.__muid_range_tab))
+    PROVIDE_HIDDEN (__muid_range_tab_end__ = .);
+
+    PROVIDE_HIDDEN (__muid_conststr_start__ = .);
+    KEEP (*(.__muid_conststr))
+    PROVIDE_HIDDEN (__muid_conststr_end__ = .);
+
+    KEEP (*(.__muid_func_def_tab))
+    KEEP (*(.__muid_func_undef_tab))
+    KEEP (*(.__muid_data_def_tab))
+    KEEP (*(.__muid_data_undef_tab))
+    KEEP (*(.__muid_itab))
+    KEEP (*(.__muid_vtab))
+    KEEP (*(.__muid_vtab_offset_tab))
+    KEEP (*(.__muid_field_offset_tab))
+    KEEP (*(.__muid_superclass))
+
+    PROVIDE_HIDDEN (__muid_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .mpl_version :
+  {
+    PROVIDE_HIDDEN (__compilerVersionNumTab_begin__ = .);
+    KEEP (*(.__compilerVersionNumTab))
+    PROVIDE_HIDDEN (__compilerVersionNumTab_end__ = .);
+
+    KEEP (*(.__sourceMuidTab))
+
+    PROVIDE_HIDDEN (__compiler_mfile_status_begin__ = .);
+    KEEP (*(.__compiler_mfile_status))
+    PROVIDE_HIDDEN (__compiler_mfile_status_end__ = .);
+  }
+
+  . = ALIGN( 8 );
+  .profile_tab :
+  {
+    KEEP (*(.__profile_func_tab))
+  }
+
+  . = ALIGN( 8 );
+  .classmetadata :
+  {
+    KEEP (*(.__muid_classmetadata))
+  }
+
+  . = ALIGN( 8 );
+  .classmetadata_bucket :
+  {
+    PROVIDE_HIDDEN (__muid_classmetadata_bucket_begin = .);
+    *(.__muid_classmetadata_bucket)
+    PROVIDE_HIDDEN (__muid_classmetadata_bucket_end = .);
+  }
+
+  .refl_strtab :
+  {
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_strtab_start__ = .);
+    KEEP (*(.reflection_strtab))
+    PROVIDE_HIDDEN(__reflection_strtab_end__ = .);
+  }
+
+  .refl_strtab.hot :
+  {
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_start_hot_strtab_start__ = .);
+    KEEP (*(.reflection_start_hot_strtab))
+    PROVIDE_HIDDEN(__reflection_start_hot_strtab_end__ = .);
+
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_both_hot_strtab_start__ = .);
+    KEEP (*(.reflection_both_hot_strtab))
+    PROVIDE_HIDDEN(__reflection_both_hot_strtab_end__ = .);
+
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_run_hot_strtab_start__ = .);
+    KEEP (*(.reflection_run_hot_strtab))
+    PROVIDE_HIDDEN(__reflection_run_hot_strtab_end__ = .);
+  }
+
+  . = ALIGN( 4096 );
+  __bss_start = . ;  __bss_start__ = . ;
+  .bss            :
+  {
+    PROVIDE_HIDDEN(__bss_section_begin = .);
+   *(.dynbss)
+   *(.bss .bss.* .gnu.linkonce.b.*)
+   *(COMMON)
+   /* Align here to ensure that the .bss section occupies space up to
+      _end.  Align after .bss to ensure correct alignment even if the
+      .bss section disappears because there are no input sections.
+      FIXME: Why do we need it? When there is no .bss section, we don't
+      pad the .data section.  */
+   . = ALIGN(. != 0 ? 64 / 8 : 1);
+    PROVIDE_HIDDEN(__bss_section_end = .);
+  }
+  _bss_end__ = . ; __bss_end__ = . ;
+
+  . = ALIGN(64 / 8);
+  . = SEGMENT_START("ldata-segment", .);
+  . = ALIGN(64 / 8);
+  __end__ = .;
+  PROVIDE_HIDDEN(__maple_end__ = .);
+  _end = .; PROVIDE (end = .);
+  . = DATA_SEGMENT_END (.);
+  /* Stabs debugging sections.  */
+  .stab          0 : { *(.stab) }
+  .stabstr       0 : { *(.stabstr) }
+  .stab.excl     0 : { *(.stab.excl) }
+  .stab.exclstr  0 : { *(.stab.exclstr) }
+  .stab.index    0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment       0 : { *(.comment) }
+  /* DWARF debug sections.
+     Symbols in the DWARF debugging sections are relative to the beginning
+     of the section so we begin them at 0.  */
+  /* DWARF 1 */
+  .debug          0 : { *(.debug) }
+  .line           0 : { *(.line) }
+  /* GNU DWARF 1 extensions */
+  .debug_srcinfo  0 : { *(.debug_srcinfo) }
+  .debug_sfnames  0 : { *(.debug_sfnames) }
+  /* DWARF 1.1 and DWARF 2 */
+  .debug_aranges  0 : { *(.debug_aranges) }
+  .maple_java_debug_aranges  0 : { KEEP(*(.maple_java_debug_aranges)) }
+  .debug_pubnames 0 : { *(.debug_pubnames) }
+  /* DWARF 2 */
+  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .maple_java_debug_info     0 : { KEEP(*(.maple_java_debug_info)) }
+  .debug_abbrev   0 : { *(.debug_abbrev) }
+  .maple_java_debug_abbrev   0 : { KEEP(*(.maple_java_debug_abbrev)) }
+  .debug_line     0 : { *(.debug_line .debug_line.* .debug_line_end ) }
+  .maple_java_debug_line     0 : { KEEP(*(.maple_java_debug_line)) }
+  .debug_frame    0 : { *(.debug_frame) }
+  .debug_str      0 : { *(.debug_str) }
+  .debug_loc      0 : { *(.debug_loc) }
+  .debug_macinfo  0 : { *(.debug_macinfo) }
+  /* SGI/MIPS DWARF 2 extensions */
+  .debug_weaknames 0 : { *(.debug_weaknames) }
+  .debug_funcnames 0 : { *(.debug_funcnames) }
+  .debug_typenames 0 : { *(.debug_typenames) }
+  .debug_varnames  0 : { *(.debug_varnames) }
+  /* DWARF 3 */
+  .debug_pubtypes 0 : { *(.debug_pubtypes) }
+  .debug_ranges   0 : { *(.debug_ranges) }
+  .maple_java_debug_ranges   0 : { KEEP(*(.maple_java_debug_ranges)) }
+  /* DWARF Extension.  */
+  .debug_macro    0 : { *(.debug_macro) }
+  .ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
+  .note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
+  /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
+}
diff --git a/src/mrt/maplert/linker/maplelld.so.lds b/src/mrt/maplert/linker/maplelld.so.lds
new file mode 100644
index 0000000000000000000000000000000000000000..57dd331c50288db634d66c038250383fcf4dc869
--- /dev/null
+++ b/src/mrt/maplert/linker/maplelld.so.lds
@@ -0,0 +1,450 @@
+/* Script for -pie -z combreloc: position independent executable, combine & sort relocs */
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64",
+              "elf64-littleaarch64")
+OUTPUT_ARCH(aarch64)
+SEARCH_DIR("=/usr/local/lib/aarch64-linux-gnu"); SEARCH_DIR("=/lib/aarch64-linux-gnu"); SEARCH_DIR("=/usr/lib/aarch64-linux-gnu"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib"); SEARCH_DIR("=/usr/aarch64-linux-gnu/lib");
+PHDRS
+{
+  text PT_LOAD FILEHDR PHDRS;
+  data PT_LOAD;
+  dynamic PT_DYNAMIC;
+  note PT_NOTE;
+  gnu_eh_frame PT_GNU_EH_FRAME;
+  gnu_stack PT_GNU_STACK;
+  gnu_relro PT_GNU_RELRO;
+  /*  headers PT_PHDR PHDRS; */ /* Reserve segment for lld */
+  /*  interp PT_INTERP;      */ /* Reserve segment for lld */
+  thread_local PT_TLS;          /* Reserve segment for lld */
+}
+
+SECTIONS
+{
+  PROVIDE_HIDDEN(__maple_start__ = .);
+  /* Read-only sections, merged into text segment: */
+  PROVIDE (__executable_start = SEGMENT_START("text-segment", 0)); . = SEGMENT_START("text-segment", 0) + SIZEOF_HEADERS;
+  .interp         : { *(.interp) }
+  .note.gnu.build-id :
+  {
+    PROVIDE_HIDDEN (__linkerHashSo_begin = .);
+    KEEP (*(.note.gnu.build-id))
+    PROVIDE_HIDDEN (__linkerHashSo_end = .);
+  } :text :note
+  .hash           : { *(.hash) } :text
+  .gnu.hash       : { *(.gnu.hash) }
+  .dynsym         : { *(.dynsym) }
+  .dynstr         : { *(.dynstr) }
+  .gnu.version    : { *(.gnu.version) }
+  .gnu.version_d  : { *(.gnu.version_d) }
+  .gnu.version_r  : { *(.gnu.version_r) }
+  .rela.dyn       :
+    {
+      *(.rela.init)
+      *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
+      *(.rela.fini)
+      *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
+      *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
+      *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
+      *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
+      *(.rela.ctors)
+      *(.rela.dtors)
+      *(.rela.got)
+      *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
+      *(.rela.ifunc)
+    }
+  .rela.plt       :
+    {
+      *(.rela.plt)
+      PROVIDE_HIDDEN (__rela_iplt_start = .);
+      *(.rela.iplt)
+      PROVIDE_HIDDEN (__rela_iplt_end = .);
+    }
+  .init           :
+  {
+    KEEP (*(.init))
+  } =0
+  .plt            : ALIGN(16) { *(.plt) *(.iplt) }
+  .text           :
+  {
+    *(.text.unlikely .text.*_unlikely .text.unlikely.*)
+    *(.text.exit .text.exit.*)
+    *(.text.startup .text.startup.*)
+    *(.text.hot .text.hot.*)
+    *(.text .stub .text.* .gnu.linkonce.t.*)
+    /* .gnu.warning sections are handled specially by elf32.em.  */
+    *(.gnu.warning)
+  } =0
+  .java_text     :
+  {
+    PROVIDE_HIDDEN (java_text_begin = .);
+    KEEP (*(.java_text))
+    PROVIDE_HIDDEN (java_text_end = .);
+  }
+  .fini           :
+  {
+    KEEP (*(.fini))
+  } =0
+  PROVIDE (__etext = .);
+  PROVIDE (_etext = .);
+  PROVIDE (etext = .);
+  .rodata         :
+  {
+    *(.rodata .rodata.* .gnu.linkonce.r.*)
+  }
+  .rometadata     :
+  {
+    mfile_rometadata_method_start = .;
+    KEEP (*(.rometadata.method))
+    mfile_rometadata_method_end = .;
+
+    mfile_rometadata_field_start = .;
+    KEEP (*(.rometadata.field))
+    mfile_rometadata_field_end = .;
+  }
+  .romuidtab      :
+  {
+    mfile_romuidtab_start = .;
+    KEEP (*(.__muid_ro_func_def_orig_tab))
+    KEEP (*(.__muid_ro_data_def_orig_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_func_inf_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_func_def_muid_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_data_def_muid_tab))
+    KEEP (*(.__muid_ro_func_undef_muid_tab))
+    KEEP (*(.__muid_ro_data_undef_muid_tab))
+    /* madvised */
+    KEEP (*(.__muid_ro_func_muid_idx_tab))
+    mfile_romuidtab_end = .;
+  }
+  .rodata1        : { *(.rodata1) }
+  .eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) } :text :gnu_eh_frame
+  .eh_frame       : ONLY_IF_RO
+  {
+    PROVIDE_HIDDEN ( __eh_frame_start = .);
+    KEEP (*(.eh_frame)) *(.eh_frame.*)
+    PROVIDE_HIDDEN ( __eh_frame_end = .);
+  } :text
+  .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table
+  .gcc_except_table.*) }
+  .gnu_extab   : ONLY_IF_RO { *(.gnu_extab*) }
+  /* These sections are generated by the Sun/Oracle C++ compiler.  */
+  .exception_ranges   : ONLY_IF_RO { *(.exception_ranges
+  .exception_ranges*) }
+
+  /* Adjust the address for the data segment.  We want to adjust up to
+     the same address within the page on the next page up.  */
+  . = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
+  /* Exception handling  */
+  .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
+  .gnu_extab      : ONLY_IF_RW { *(.gnu_extab) }
+  .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
+  .exception_ranges   : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
+  /* Thread Local Storage sections  */
+  .tdata      : { *(.tdata .tdata.* .gnu.linkonce.td.*) } :thread_local
+  .tbss       : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } :thread_local
+  .dynamic        : { *(.dynamic) } :data :gnu_relro :dynamic
+  .preinit_array     :
+  {
+    PROVIDE_HIDDEN (__preinit_array_start = .);
+    KEEP (*(.preinit_array))
+    PROVIDE_HIDDEN (__preinit_array_end = .);
+  }
+  .init_array     :
+  {
+    PROVIDE_HIDDEN (__init_array_start = .);
+    KEEP (*(.init_array.* .ctors.*))
+    KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
+    PROVIDE_HIDDEN (__init_array_end = .);
+  } :data :gnu_relro
+  .fini_array     :
+  {
+    PROVIDE_HIDDEN (__fini_array_start = .);
+    KEEP (*(.fini_array.* .dtors.*))
+    KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
+    PROVIDE_HIDDEN (__fini_array_end = .);
+  } :data :gnu_relro
+  .ctors          :
+  {
+    /* gcc uses crtbegin.o to find the start of
+       the constructors, so we make sure it is
+       first.  Because this is a wildcard, it
+       doesn't matter if the user does not
+       actually link against crtbegin.o; the
+       linker won't look for a file to match a
+       wildcard.  The wildcard also means that it
+       doesn't matter which directory crtbegin.o
+       is in.  */
+    KEEP (*crtbegin.o(.ctors))
+    KEEP (*crtbegin?.o(.ctors))
+    /* We don't want to include the .ctor section from
+       the crtend.o file until after the sorted ctors.
+       The .ctor section from the crtend file contains the
+       end of ctors marker and it must be last */
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
+    KEEP (*(SORT(.ctors.*)))
+    KEEP (*(.ctors))
+  }
+  .dtors          :
+  {
+    KEEP (*crtbegin.o(.dtors))
+    KEEP (*crtbegin?.o(.dtors))
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
+    KEEP (*(SORT(.dtors.*)))
+    KEEP (*(.dtors))
+  }
+  .jcr            : { KEEP (*(.jcr)) }
+  .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
+  .got            : { *(.got) *(.igot) } :data :gnu_relro
+  . = DATA_SEGMENT_RELRO_END (24, .);
+  .got.plt        : { *(.got.plt)  *(.igot.plt) } :data
+  .data           :
+  {
+    PROVIDE_HIDDEN (__data_section_begin = .);
+    *(.data .data.* .gnu.linkonce.d.*)
+    SORT(CONSTRUCTORS)
+    PROVIDE_HIDDEN (__data_section_end = .);
+  }
+  .data1          : { *(.data1) }
+  _edata = .; PROVIDE (edata = .);
+  /* maple specific sections */
+  . = ALIGN( 8 );
+  .maple_global_variable :
+  {
+    KEEP (*(.maple_global_variable))
+  }
+
+  . = ALIGN( 8 );
+  .maple_literal_string :
+  {
+    KEEP (*(.maple_literal_string))
+  }
+
+  . = ALIGN( 8 );
+  .maple.gcrootsmap :
+  {
+    KEEP (*(.maple.gcrootsmap))
+  }
+
+  . = ALIGN( 8 );
+  .reg_jni_tab :
+  {
+    PROVIDE_HIDDEN (__reg_jni_tab_begin = .);
+    KEEP (*(.reg_jni_tab))
+    PROVIDE_HIDDEN (__reg_jni_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .reg_jni_func_tab :
+  {
+    PROVIDE_HIDDEN (__reg_jni_func_tab_begin = .);
+    KEEP (*(.reg_jni_func_tab))
+    PROVIDE_HIDDEN (__reg_jni_func_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .bb_profile_strtab :
+  {
+    PROVIDE_HIDDEN (__bb_profile_strtab_begin = .);
+    KEEP (*(.__bb_profile_strtab))
+    PROVIDE_HIDDEN (__bb_profile_strtab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .bb_profile_tab :
+  {
+    PROVIDE_HIDDEN (__bb_profile_tab_begin = .);
+    KEEP (*(.__bb_profile_tab))
+    PROVIDE_HIDDEN (__bb_profile_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .muid_tab :
+  {
+    PROVIDE_HIDDEN (__muid_tab_start = .);
+
+    PROVIDE_HIDDEN (__decouple_start__ = .);
+    KEEP (*(.__decouple))
+    PROVIDE_HIDDEN (__decouple_end__ = .);
+
+    PROVIDE_HIDDEN (__muid_range_tab_begin__ = .);
+    KEEP (*(.__muid_range_tab))
+    PROVIDE_HIDDEN (__muid_range_tab_end__ = .);
+
+    PROVIDE_HIDDEN (__muid_conststr_start__ = .);
+    KEEP (*(.__muid_conststr))
+    PROVIDE_HIDDEN (__muid_conststr_end__ = .);
+
+    KEEP (*(.__muid_func_def_tab))
+    KEEP (*(.__muid_func_undef_tab))
+    KEEP (*(.__muid_data_def_tab))
+    KEEP (*(.__muid_data_undef_tab))
+    KEEP (*(.__muid_vtab_offset_tab))
+    KEEP (*(.__muid_field_offset_tab))
+    KEEP (*(.__muid_superclass))
+    KEEP (*(.__muid_offset_value_table))
+    KEEP (*(.__muid_local_classinfo_tab))
+
+    PROVIDE_HIDDEN (__muid_tab_end = .);
+  }
+
+  . = ALIGN( 8 );
+  .muid_itab_conflict :
+  {
+    KEEP (*(.__muid_itab_conflict))
+    KEEP (*(.__muid_cold_itab_conflict))
+  }
+
+  . = ALIGN( 8 );
+  .muid_vtab_and_itab :
+  {
+    KEEP (*(.__muid_vtab_and_itab))
+    KEEP (*(.__muid_cold_vtab_and_itab))
+  }
+
+  . = ALIGN( 8 );
+  .mpl_version :
+  {
+    PROVIDE_HIDDEN (__compilerVersionNumTab_begin__ = .);
+    KEEP (*(.__compilerVersionNumTab))
+    PROVIDE_HIDDEN (__compilerVersionNumTab_end__ = .);
+
+    KEEP (*(.__sourceMuidTab))
+
+    PROVIDE_HIDDEN (__compiler_mfile_status_begin__ = .);
+    KEEP (*(.__compiler_mfile_status))
+    PROVIDE_HIDDEN (__compiler_mfile_status_end__ = .);
+  }
+
+  . = ALIGN( 8 );
+  .profile_tab :
+  {
+    KEEP (*(.__profile_func_tab))
+  }
+
+  . = ALIGN( 8 );
+  .classmetadata :
+  {
+    KEEP (*(.__muid_classmetadata))
+  }
+
+  . = ALIGN( 8 );
+  .classmetadata_bucket :
+  {
+    PROVIDE_HIDDEN (__muid_classmetadata_bucket_begin = .);
+    *(.__muid_classmetadata_bucket)
+    PROVIDE_HIDDEN (__muid_classmetadata_bucket_end = .);
+  }
+
+  .refl_strtab :
+  {
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_strtab_start__ = .);
+    KEEP (*(.reflection_strtab))
+    PROVIDE_HIDDEN(__reflection_strtab_end__ = .);
+  }
+
+  .refl_strtab.hot :
+  {
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_start_hot_strtab_start__ = .);
+    KEEP (*(.reflection_start_hot_strtab))
+    PROVIDE_HIDDEN(__reflection_start_hot_strtab_end__ = .);
+
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_both_hot_strtab_start__ = .);
+    KEEP (*(.reflection_both_hot_strtab))
+    PROVIDE_HIDDEN(__reflection_both_hot_strtab_end__ = .);
+
+    . = ALIGN( 8 );
+    PROVIDE_HIDDEN(__reflection_run_hot_strtab_start__ = .);
+    KEEP (*(.reflection_run_hot_strtab))
+    PROVIDE_HIDDEN(__reflection_run_hot_strtab_end__ = .);
+  }
+
+  . = ALIGN( 4096 );
+  __bss_start = . ;  __bss_start__ = . ;
+  .bss            :
+  {
+    PROVIDE_HIDDEN(__bss_section_begin = .);
+   *(.dynbss)
+   *(.bss .bss.* .gnu.linkonce.b.*)
+   *(COMMON)
+   /* Align here to ensure that the .bss section occupies space up to
+      _end.  Align after .bss to ensure correct alignment even if the
+      .bss section disappears because there are no input sections.
+      FIXME: Why do we need it? When there is no .bss section, we don't
+      pad the .data section.  */
+   . = ALIGN(. != 0 ? 64 / 8 : 1);
+    PROVIDE_HIDDEN(__bss_section_end = .);
+  }
+  _bss_end__ = . ; __bss_end__ = . ;
+
+  . = ALIGN(64 / 8);
+  . = SEGMENT_START("ldata-segment", .);
+  . = ALIGN(64 / 8);
+  __end__ = .;
+  PROVIDE_HIDDEN(__maple_end__ = .);
+  _end = .; PROVIDE (end = .);
+  . = DATA_SEGMENT_END (.);
+  /* Stabs debugging sections.  */
+  .stab          0 : { *(.stab) }
+  .stabstr       0 : { *(.stabstr) }
+  .stab.excl     0 : { *(.stab.excl) }
+  .stab.exclstr  0 : { *(.stab.exclstr) }
+  .stab.index    0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment       0 : { *(.comment) }
+  /* DWARF debug sections.
+     Symbols in the DWARF debugging sections are relative to the beginning
+     of the section so we begin them at 0.  */
+  /* DWARF 1 */
+  .debug          0 : { *(.debug) }
+  .line           0 : { *(.line) }
+  /* GNU DWARF 1 extensions */
+  .debug_srcinfo  0 : { *(.debug_srcinfo) }
+  .debug_sfnames  0 : { *(.debug_sfnames) }
+  /* DWARF 1.1 and DWARF 2 */
+  .debug_aranges  0 : { *(.debug_aranges) }
+  .maple_java_debug_aranges  0 : { KEEP(*(.maple_java_debug_aranges)) }
+  .debug_pubnames 0 : { *(.debug_pubnames) }
+  /* DWARF 2 */
+  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .maple_java_debug_info     0 : { KEEP(*(.maple_java_debug_info)) }
+  .debug_abbrev   0 : { *(.debug_abbrev) }
+  .maple_java_debug_abbrev   0 : { KEEP(*(.maple_java_debug_abbrev)) }
+  .debug_line     0 : { *(.debug_line .debug_line.* .debug_line_end ) }
+  .maple_java_debug_line     0 : { KEEP(*(.maple_java_debug_line)) }
+  .debug_frame    0 : { *(.debug_frame) }
+  .debug_str      0 : { *(.debug_str) }
+  .debug_loc      0 : { *(.debug_loc) }
+  .debug_macinfo  0 : { *(.debug_macinfo) }
+  /* SGI/MIPS DWARF 2 extensions */
+  .debug_weaknames 0 : { *(.debug_weaknames) }
+  .debug_funcnames 0 : { *(.debug_funcnames) }
+  .debug_typenames 0 : { *(.debug_typenames) }
+  .debug_varnames  0 : { *(.debug_varnames) }
+  /* DWARF 3 */
+  .debug_pubtypes 0 : { *(.debug_pubtypes) }
+  .debug_ranges   0 : { *(.debug_ranges) }
+  .maple_java_debug_ranges   0 : { KEEP(*(.maple_java_debug_ranges)) }
+  /* DWARF Extension.  */
+  .debug_macro    0 : { *(.debug_macro) }
+  .ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
+  .note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
+  /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
+}
diff --git a/src/mrt/maplert/linker/unified.macros.whitelist b/src/mrt/maplert/linker/unified.macros.whitelist
new file mode 100644
index 0000000000000000000000000000000000000000..fcf69297313c547da4a581b70a838d0bdeaa64a9
--- /dev/null
+++ b/src/mrt/maplert/linker/unified.macros.whitelist
@@ -0,0 +1,40 @@
+Ljava_2Flang_2FString_24CaseInsensitiveComparator
+Ljava_2Futil_2FSpliterators_24DoubleArraySpliterator
+Ljava_2Flang_2FClass
+Ljava_2Flang_2FString
+Ljava_2Flang_2FObject
+Ljava_2Flang_2Freflect_2FExecutable_3B
+Ljava_2Flang_2Freflect_2FConstructor
+Ljava_2Flang_2Freflect_2FMethod
+Ljava_2Flang_2Freflect_2FField
+Ljava_2Flang_2Freflect_2FAccessibleObject_3B
+Ljava_2Flang_2Fref_2FReference
+Ljava_2Flang_2Freflect_2FParameter
+Ljava_2Flang_2FThrowable
+Ljava_2Flang_2FCloneable
+Ljava_2Fio_2FSerializable
+Ljava_2Flang_2Freflect_2FType
+Ljava_2Flang_2FCharacter
+Ljava_2Flang_2FInteger
+Ljava_2Flang_2FThreadGroup
+Ljava_2Flang_2FThread_24State
+Ljava_2Flang_2FThread
+Ljava_2Flang_2FNullPointerException
+Ljava_2Flang_2FArithmeticException
+Ljava_2Flang_2FInterruptedException
+Ljava_2Flang_2FClassCastException
+Ljava_2Flang_2FArrayIndexOutOfBoundsException
+Ljava_2Flang_2FUnsatisfiedLinkError
+Llibcore_2Freflect_2FAnnotationMember
+Llibcore_2Freflect_2FAnnotationFactory
+Ljava_2Fnio_2FDirectByteBuffer
+Ljava_2Flang_2Fannotation_2FAnnotation
+Ljava_2Fnio_2FBuffer
+Ljava_2Flang_2Finvoke_2FMethodType
+Ldalvik_2Fsystem_2FEmulatedStackFrame
+Ljava_2Flang_2FStringFactory
+Ljava_2Flang_2Finvoke_2FArrayElementVarHandle
+Ljava_2Flang_2Finvoke_2FByteArrayViewVarHandle
+Ljava_2Flang_2Finvoke_2FByteBufferViewVarHandle
+Ljava_2Flang_2Finvoke_2FFieldVarHandle
+Ljava_2Flang_2Finvoke_2FVarHandle
diff --git a/src/mrt/maplert/public-headers/java2c_rule.h b/src/mrt/maplert/public-headers/java2c_rule.h
new file mode 100644
index 0000000000000000000000000000000000000000..847780777a72364eff549f208ef089ad8a615f29
--- /dev/null
+++ b/src/mrt/maplert/public-headers/java2c_rule.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_JAVA2C_RULE_H_
+#define MAPLE_JAVA2C_RULE_H_
+#include <iostream>
+
+#include "jni.h"
+#include "mobject.h"
+#include "exception/mrt_exception.h"
+
+namespace maplert {
+#define INIT_ARGS
+
+#define j2cRule(INIT_ARGS) j2cRule
+
+class Java2CRule {
+ public:
+  Java2CRule() = default;
+  ~Java2CRule() = default;
+  void Prologue() const { }
+  // when a java function exit, we need to call it
+  void Epilogue() const {
+    if (MRT_HasPendingException()) {
+      MRT_CheckThrowPendingExceptionRet();
+    }
+  }
+};
+} // namespace maplert
+
+#endif //MAPLE_JAVA2C_RULE_H_
diff --git a/src/mrt/maplert/public-headers/jsan.h b/src/mrt/maplert/public-headers/jsan.h
new file mode 100644
index 0000000000000000000000000000000000000000..b904afb45e3e5cb819190fac8e87f709fdb90bb7
--- /dev/null
+++ b/src/mrt/maplert/public-headers/jsan.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef JSAN_H
+#define JSAN_H
+
+
+#include <list>
+#include <queue>
+#include <unordered_map>
+#include "jni.h"
+#include "mrt_mm_config_common.h"
+
+namespace maplert {
+typedef uintptr_t address_t;
+
+#define JSAN_ADD_OBJ(objAddr, objSize)
+#define JSAN_ADD_CLASS_METADATA(objAddr)
+#define JSAN_FREE(obj, RealFreeFunc, internalSize) internalSize = RealFreeFunc(obj)
+#define JSAN_CHECK_OBJ(obj)
+
+static inline void JsanliteFree(address_t) {
+  return;
+}
+
+static inline void JsanliteError(address_t) {
+  return;
+}
+
+static inline size_t JsanliteGetPayloadSize(size_t) {
+  return 0;
+};
+
+static inline void JsanliteInit() {
+  return;
+}
+} // namespace maplert
+
+#endif
diff --git a/src/mrt/maplert/public-headers/mrt_api_common.h b/src/mrt/maplert/public-headers/mrt_api_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ef9c5fc0db96c276caf2512902f11704b0dcfbf
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_api_common.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_API_COMMON_H
+#define MRT_API_COMMON_H
+
+#define MRT_EXPORT __attribute__((visibility("default")))
+
+#endif
diff --git a/src/mrt/maplert/public-headers/mrt_array_api.h b/src/mrt/maplert/public-headers/mrt_array_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2e0a8af72309c93ae900e8b7512ba778d4da5c6
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_array_api.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_LIB_CORE_MPL_ARRAY_H_
+#define MAPLE_LIB_CORE_MPL_ARRAY_H_
+
+#include "mrt_api_common.h"
+#include "securec.h"
+#include "primitive.h"
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+// PrimitiveArray
+MRT_EXPORT jclass MRT_GetPrimitiveArrayClassJboolean(void);
+MRT_EXPORT jclass MRT_GetPrimitiveArrayClassJbyte(void);
+MRT_EXPORT jclass MRT_GetPrimitiveArrayClassJchar(void);
+MRT_EXPORT jclass MRT_GetPrimitiveArrayClassJdouble(void);
+MRT_EXPORT jclass MRT_GetPrimitiveArrayClassJfloat(void);
+MRT_EXPORT jclass MRT_GetPrimitiveArrayClassJint(void);
+MRT_EXPORT jclass MRT_GetPrimitiveArrayClassJlong(void);
+MRT_EXPORT jclass MRT_GetPrimitiveArrayClassJshort(void);
+
+MRT_EXPORT jobject MRT_NewArray(jint length, jclass elementClass, jint componentSize);
+MRT_EXPORT jobject MRT_NewPrimitiveArray(jint length, maple::Primitive::Type pType,
+                                         jint componentSize, jboolean isJNI = JNI_FALSE);
+MRT_EXPORT jobject MRT_NewObjArray(const jint length, const jclass elementClass, const jobject initialElement);
+
+MRT_EXPORT jint MRT_GetArrayElementCount(jarray ja);
+MRT_EXPORT jobject MRT_GetObjectArrayElement(jobjectArray javaArray, jsize index, jboolean maintainRC);
+MRT_EXPORT void MRT_SetObjectArrayElement(jobjectArray javaArray, jsize index,
+                                          jobject javaValue, jboolean maintainRC);
+
+// openjdk for primitiveArrayElement
+MRT_EXPORT jobject MRT_GetArrayElement(jobjectArray javaArray, jsize index, jboolean maintain);
+MRT_EXPORT void MRT_SetArrayElement(jobjectArray javaArray, jsize index, jobject javaValue);
+MRT_EXPORT jvalue MRT_GetPrimitiveArrayElement(jarray arr, jint index, char arrType);
+MRT_EXPORT void MRT_SetPrimitiveArrayElement(jarray arr, jint index, jvalue value, char arrType);
+MRT_EXPORT jboolean MRT_TypeWidenConvertCheck(char currentType, char wideType, const jvalue &srcVal, jvalue &dstVal);
+MRT_EXPORT jboolean MRT_TypeWidenConvertCheckObject(jobject val);
+MRT_EXPORT char MRT_GetPrimitiveType(jclass clazz);
+MRT_EXPORT char MRT_GetPrimitiveTypeFromBoxType(jclass clazz);
+
+MRT_EXPORT jboolean MRT_IsArray(jobject javaArray);
+MRT_EXPORT jboolean MRT_IsObjectArray(jobject javaArray);
+MRT_EXPORT jboolean MRT_IsPrimitveArray(jobject javaArray);
+MRT_EXPORT jboolean MRT_IsMultiDimArray(jobject javaArray);
+
+MRT_EXPORT void *MRT_JavaArrayToCArray(jarray javaArray);
+MRT_EXPORT jint MRT_GetArrayContentOffset(void);
+MRT_EXPORT jobject MRT_RecursiveCreateMultiArray(const jclass arrayClass,
+    const jint currentDimension, const jint dimensions, jint *dimArray);
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+
+#endif // MAPLE_LIB_CORE_MPL_ARRAY_H_
diff --git a/src/mrt/maplert/public-headers/mrt_class_api.h b/src/mrt/maplert/public-headers/mrt_class_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..f012c4969d986ae60a7f078bb3e1275560947656
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_class_api.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_LIB_CORE_MPL_CLASS_H_
+#define MAPLE_LIB_CORE_MPL_CLASS_H_
+
+#include "mrt_api_common.h"
+#include "jni.h"
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+MRT_EXPORT char    *MRT_ReflectGetClassCharName(const jclass klass);
+MRT_EXPORT jint     MRT_ReflectGetObjSize(const jclass klass);
+MRT_EXPORT jboolean MRT_ReflectClassIsPrimitive(jclass klass);
+MRT_EXPORT jstring  MRT_ReflectClassGetName(jclass klass);
+
+MRT_EXPORT jclass   MRT_GetClassObject(void);
+MRT_EXPORT jclass   MRT_GetClassClass(void);
+MRT_EXPORT jclass   MRT_GetClassString(void);
+MRT_EXPORT bool MRT_ClassIsSuperClassValid(jclass clazz);
+
+MRT_EXPORT bool     MRT_ClassInitialized(jclass classInfo);
+MRT_EXPORT void     MRT_InitProtectedMemoryForClinit();
+MRT_EXPORT void     MRT_DumpClassClinit(std::ostream &os);
+MRT_EXPORT int64_t  MRT_ClinitGetTotalTime();
+MRT_EXPORT int64_t  MRT_ClinitGetTotalCount();
+MRT_EXPORT void     MRT_ClinitResetStats();
+MRT_EXPORT void     MRT_ClinitEnableCount(bool enable);
+MRT_EXPORT void     MRT_BootstrapClinit(void);
+MRT_EXPORT void     MRT_BootstrapWellKnown();
+
+MRT_EXPORT void MRT_SaveProfile(const std::string &path, bool isSystemServer);
+MRT_EXPORT void MRT_EnableMetaProfile();
+MRT_EXPORT void MRT_DisableMetaProfile();
+MRT_EXPORT void MRT_ClearMetaProfile();
+
+// Returns the component size of the specified array class.
+MRT_EXPORT size_t MRT_ReflectClassGetComponentSize(jclass klass);
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+#endif //MAPLE_LIB_CORE_MPL_CLASS_H_
diff --git a/src/mrt/maplert/public-headers/mrt_classloader_api.h b/src/mrt/maplert/public-headers/mrt_classloader_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..580f6ca38ab333ba45c083257ce1d4bbc67c17e8
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_classloader_api.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_CLASS_CLASSLOADER_API_H_
+#define MRT_CLASS_CLASSLOADER_API_H_
+
+#include "jni.h"
+#include "mrt_api_common.h"
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+// C interfaces
+MRT_EXPORT bool MRT_IsClassInitialized(jclass klass);
+MRT_EXPORT jobject MRT_GetBootClassLoader();
+MRT_EXPORT jobject MRT_GetClassLoader(jclass klass);
+MRT_EXPORT jclass MRT_GetClassByClassLoader(jobject classLoader, const std::string className);
+MRT_EXPORT jclass MRT_GetClassByContextClass(jclass klass, const std::string className);
+MRT_EXPORT jclass MRT_GetClassByContextObject(jobject obj, const std::string className);
+MRT_EXPORT jclass MRT_GetNativeContexClass(); // Get the class loader by current native context
+MRT_EXPORT jobject MRT_GetNativeContexClassLoader(); // Get the contextclass by current native context
+MRT_EXPORT jclass MRT_GetClass(jclass klass, const std::string className);
+MRT_EXPORT void MRT_RegisterDynamicClass(jobject classLoader, jclass klass);
+MRT_EXPORT void MRT_UnregisterDynamicClass(jobject classLoader, jclass klass);
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+#endif // MRT_CLASS_LOCATOR_MGR_H_
diff --git a/src/mrt/maplert/public-headers/mrt_compiler_api.h b/src/mrt/maplert/public-headers/mrt_compiler_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f329555de3745eb209df392c98f7746706d414f
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_compiler_api.h
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_COMPILER_API_H
+#define MRT_COMPILER_API_H
+#include "cinterface.h"
+#include "exception/eh_personality.h"
+#include "metadata_layout.h"
+#include "mrt_api_common.h"
+#include "mclass.h"
+namespace maplert {
+// MCC_ prefixed function is external interface, the compiler guarantees parameter safety
+// when calling such interface during the compilation phase.
+extern "C" {
+// exception
+MRT_EXPORT void MCC_ThrowNullArrayNullPointerException();
+MRT_EXPORT void MCC_CheckThrowPendingException();
+MRT_EXPORT void MCC_ThrowNullPointerException();
+MRT_EXPORT void MCC_ThrowArithmeticException();
+MRT_EXPORT void MCC_ThrowInterruptedException();
+MRT_EXPORT void MCC_ThrowClassCastException(const char *msg);
+MRT_EXPORT void MCC_ThrowArrayIndexOutOfBoundsException(const char *msg);
+MRT_EXPORT void MCC_ThrowUnsatisfiedLinkError();
+MRT_EXPORT void MCC_ThrowSecurityException();
+MRT_EXPORT void MCC_ThrowExceptionInInitializerError(MrtClass cause);
+MRT_EXPORT void MCC_ThrowNoClassDefFoundError(MrtClass classInfo);
+MRT_EXPORT void MCC_ThrowStringIndexOutOfBoundsException();
+MRT_EXPORT void *MCC_JavaBeginCatch(const _Unwind_Exception *unwind_exception);
+MRT_EXPORT void MCC_ThrowException(MrtClass obj);
+MRT_EXPORT void MCC_ThrowPendingException();
+MRT_EXPORT void MCC_RethrowException(MrtClass obj);
+
+// fast stack unwind
+MRT_EXPORT void MCC_SetRiskyUnwindContext(uint32_t *pc, void *fp);
+MRT_EXPORT void MCC_SetReliableUnwindContext();
+
+// decouple for lazybinding, called while visiting offset table at first time
+MRT_EXPORT int32_t MCC_FixOffsetTableVtable(uint32_t offsetVal, char *offsetEntry);
+MRT_EXPORT int32_t MCC_FixOffsetTableField(uint32_t offsetVal, char *offsetEntry);
+
+// string
+MRT_EXPORT bool MCC_String_Equals_NotallCompress(jstring thisStr, jstring anotherStr);
+MRT_EXPORT jstring MCC_CStrToJStr(const char *ca, jint len);
+MRT_EXPORT jstring MCC_GetOrInsertLiteral(jstring literal);
+MRT_EXPORT jstring MCC_StringAppend(uint64_t toStringFlag, ...);
+MRT_EXPORT jstring MCC_StringAppend_StringString(jstring strObj1, jstring strObj2);
+MRT_EXPORT jstring MCC_StringAppend_StringInt(jstring strObj1, jint intValue);
+MRT_EXPORT jstring MCC_StringAppend_StringJcharString(jstring strObj1, uint16_t charValue, jstring strObj2);
+
+// mclasslocatormanager
+MRT_EXPORT jclass MCC_GetClass(jclass klass, const char *className);
+MRT_EXPORT jobject MCC_GetCurrentClassLoader(jobject obj);
+
+// class init
+MRT_EXPORT void MCC_PreClinitCheck(ClassMetadata &classInfo __attribute__((unused)));
+MRT_EXPORT void MCC_PostClinitCheck(ClassMetadata &classInfo __attribute__((unused)));
+
+// reflection class
+MRT_EXPORT void MCC_Array_Boundary_Check(jobjectArray javaArray, jint index);
+MRT_EXPORT void MCC_Reflect_ThrowCastException(const jclass sourceInfo, jobject targetObject, jint dim);
+MRT_EXPORT void MCC_Reflect_Check_Casting_Array(jclass sourceClass, jobject targetObject, jint arrayDim);
+MRT_EXPORT void MCC_ThrowCastException(jclass targetClass, jobject castObj);
+MRT_EXPORT void MCC_Reflect_Check_Arraystore(jobject arrayObject, jobject elemObject);
+MRT_EXPORT void MCC_Reflect_Check_Casting_NoArray(jclass sourceClass, jobject targetClass);
+MRT_EXPORT jboolean MCC_Reflect_IsInstance(jobject, jobject);
+
+MRT_EXPORT uintptr_t MCC_getFuncPtrFromItabSlow64(const MObject *obj, uintptr_t hashCode,
+                                                  uintptr_t secondHashCode, const char *signature);
+MRT_EXPORT uintptr_t MCC_getFuncPtrFromItabSlow32(const MObject *obj, uint32_t hashCode,
+                                                  uint32_t secondHashCode, const char *signature);
+MRT_EXPORT uintptr_t MCC_getFuncPtrFromItabInlineCache(uint64_t* cacheEntryAddr, const MClass *klass, uint32_t hashCode,
+                                                       uint32_t secondHashCode, const char *signature);
+MRT_EXPORT uintptr_t MCC_getFuncPtrFromItabSecondHash64(const uintptr_t *itab, uintptr_t hashCode,
+                                                        const char *signature);
+MRT_EXPORT uintptr_t MCC_getFuncPtrFromItabSecondHash32(const uint32_t *itab, uint32_t hashCode,
+                                                        const char *signature);
+#if defined(__arm__)
+MRT_EXPORT uintptr_t MCC_getFuncPtrFromItab(const uint32_t *itab, const char *signature, uint32_t hashCode);
+#else  // ~__arm__
+MRT_EXPORT uintptr_t MCC_getFuncPtrFromItab(const uint32_t *itab, uint32_t hashCode, const char *signature);
+#endif  // ~__arm__
+MRT_EXPORT uintptr_t MCC_getFuncPtrFromVtab64(const MObject *obj, uint32_t offset);
+MRT_EXPORT uintptr_t MCC_getFuncPtrFromVtab32(const MObject *obj, uint32_t offset);
+
+MRT_EXPORT void MCC_ArrayMap_String_Int_put(jstring key, jint value);
+MRT_EXPORT jint MCC_ArrayMap_String_Int_size();
+MRT_EXPORT jint MCC_ArrayMap_String_Int_getOrDefault(jstring key, jint defaultValue);
+MRT_EXPORT void MCC_ArrayMap_String_Int_clear();
+
+// reference api
+MRT_EXPORT void MCC_CheckObjAllocated(address_t obj);
+MRT_EXPORT address_t MCC_IncRef_NaiveRCFast(address_t obj);
+MRT_EXPORT address_t MCC_LoadRefField_NaiveRCFast(address_t obj, address_t *filedAddress);
+MRT_EXPORT address_t MCC_DecRef_NaiveRCFast(address_t obj);
+MRT_EXPORT void MCC_IncDecRef_NaiveRCFast(address_t incAddr, address_t decAddr);
+MRT_EXPORT void MCC_IncDecRefReset(address_t incAddr, address_t *decAddr);
+MRT_EXPORT void MCC_DecRefResetPair(address_t *incAddr, address_t *decAddr);
+MRT_EXPORT void MCC_CleanupLocalStackRef_NaiveRCFast(address_t *localStart, size_t count);
+MRT_EXPORT void MCC_CleanupLocalStackRefSkip_NaiveRCFast(address_t *localStart, size_t count, size_t skip);
+MRT_EXPORT void MCC_CleanupNonescapedVar(address_t obj);
+MRT_EXPORT void MCC_ClearLocalStackRef(address_t *var);
+MRT_EXPORT void MCC_WriteRefFieldStaticNoInc(address_t *field, address_t value);
+MRT_EXPORT void MCC_WriteRefFieldStaticNoDec(address_t *field, address_t value);
+MRT_EXPORT void MCC_WriteRefFieldStaticNoRC(address_t *field, address_t value);
+MRT_EXPORT void MCC_WriteVolatileStaticFieldNoInc(address_t *objAddr, address_t value);
+MRT_EXPORT void MCC_WriteVolatileStaticFieldNoDec(address_t *objAddr, address_t value);
+MRT_EXPORT void MCC_WriteVolatileStaticFieldNoRC(address_t *objAddr, address_t value);
+MRT_EXPORT void MCC_WriteRefFieldNoRC(address_t obj, address_t *field, address_t value);
+MRT_EXPORT void MCC_WriteRefFieldNoDec(address_t obj, address_t *field, address_t value);
+MRT_EXPORT void MCC_WriteRefFieldNoInc(address_t obj, address_t *field, address_t value);
+MRT_EXPORT void MCC_WriteVolatileFieldNoInc(address_t obj, address_t *objAddr, address_t value);
+MRT_EXPORT void MCC_WriteWeakField(address_t obj, address_t *fieldAddr, address_t value);
+MRT_EXPORT address_t MCC_LoadWeakField(address_t obj, address_t *fieldAddr);
+MRT_EXPORT void MCC_WriteVolatileWeakField(address_t obj, address_t *fieldAddr, address_t value);
+MRT_EXPORT address_t MCC_LoadVolatileWeakField(address_t obj, address_t *fieldAddr);
+MRT_EXPORT void MCC_CleanupLocalStackRef(const address_t *localStart, size_t count);
+MRT_EXPORT void MCC_CleanupLocalStackRefSkip(const address_t *localStart, size_t count, size_t skip);
+MRT_EXPORT address_t MCC_NewObj(size_t size, size_t align);
+MRT_EXPORT address_t MCC_LoadRefStatic(address_t *fieldAddr);
+MRT_EXPORT address_t MCC_LoadVolatileStaticField(address_t *fieldAddr);
+MRT_EXPORT address_t MCC_LoadReferentField(address_t obj, address_t *fieldAddr);
+MRT_EXPORT void MCC_WriteRefFieldStatic(address_t *field, address_t value);
+MRT_EXPORT void MCC_WriteVolatileStaticField(address_t *objAddr, address_t value);
+MRT_EXPORT address_t MCC_LoadVolatileField(address_t obj, address_t *fieldAddr);
+MRT_EXPORT void MCC_PreWriteRefField(address_t obj);
+MRT_EXPORT void MCC_WriteRefField(address_t obj, address_t *field, address_t value);
+MRT_EXPORT void MCC_WriteVolatileField(address_t obj, address_t *objAddr, address_t value);
+MRT_EXPORT void MCC_WriteReferent(address_t obj, address_t value);
+MRT_EXPORT void MCC_InitializeLocalStackRef(address_t *localStart, size_t count);
+MRT_EXPORT void MCC_RunFinalization();
+
+// Call fast native function with no more than 8 args.
+MRT_EXPORT void *MCC_CallFastNative(...);
+// Call fast native function with arbitrary number of args.
+MRT_EXPORT void *MCC_CallFastNativeExt(...);
+// Call slow native function with no more than 8 args.
+MRT_EXPORT void *MCC_CallSlowNative0(...);
+MRT_EXPORT void *MCC_CallSlowNative1(...);
+MRT_EXPORT void *MCC_CallSlowNative2(...);
+MRT_EXPORT void *MCC_CallSlowNative3(...);
+MRT_EXPORT void *MCC_CallSlowNative4(...);
+MRT_EXPORT void *MCC_CallSlowNative5(...);
+MRT_EXPORT void *MCC_CallSlowNative6(...);
+MRT_EXPORT void *MCC_CallSlowNative7(...);
+MRT_EXPORT void *MCC_CallSlowNative8(...);
+// Call slow native function with arbitrary number of args.
+MRT_EXPORT void *MCC_CallSlowNativeExt(...);
+MRT_EXPORT void MCC_RecordStaticField(address_t *field, const char *name);
+
+// libs fast
+MRT_EXPORT void MCC_SyncExitFast(address_t obj);
+MRT_EXPORT void MCC_SyncEnterFast2(address_t obj);
+MRT_EXPORT void MCC_SyncEnterFast0(address_t obj);
+MRT_EXPORT void MCC_SyncEnterFast1(address_t obj);
+MRT_EXPORT void MCC_SyncEnterFast3(address_t obj);
+MRT_EXPORT JNIEnv *MCC_PreNativeCall(jobject caller);
+MRT_EXPORT void MCC_PostNativeCall(JNIEnv *env);
+
+// libs
+MRT_EXPORT int32_t MCC_DexArrayLength(const void *p);
+MRT_EXPORT void MCC_DexArrayFill(void *d, void *s, int32_t len);
+MRT_EXPORT void *MCC_DexCheckCast(void *i, void *c);
+MRT_EXPORT void *MCC_GetReferenceToClass(void *c);
+MRT_EXPORT bool MCC_DexInstanceOf(void *i, void *c);
+MRT_EXPORT void MCC_DexInterfaceCall(void *dummy);
+MRT_EXPORT bool MCC_IsAssignableFrom(jclass subClass, jclass superClass);
+#if defined(__aarch64__)
+#define POLYRETURNTYPE jvalue
+#elif defined(__arm__)
+#define POLYRETURNTYPE jlong
+#endif
+
+MRT_EXPORT POLYRETURNTYPE MCC_DexPolymorphicCall(jstring calleeName,
+    jstring protoString, int paramNum, jobject methodHandle, ...);
+
+MRT_EXPORT int32_t MCC_JavaArrayLength(const void *p);
+MRT_EXPORT void MCC_JavaArrayFill(void *d, void *s, int32_t len);
+MRT_EXPORT void *MCC_JavaCheckCast(void *i, void *c);
+MRT_EXPORT bool MCC_JavaInstanceOf(void *i, void *c);
+MRT_EXPORT void MCC_JavaInterfaceCall(void *dummy);
+MRT_EXPORT POLYRETURNTYPE MCC_JavaPolymorphicCall(jstring calleeName,
+    jstring protoString, int paramNum, jobject methodHandle, ...);
+
+// chelper
+MRT_EXPORT void MCC_SetJavaClass(address_t objaddr, address_t klass);
+MRT_EXPORT void MCC_SetObjectPermanent(address_t objaddr);
+MRT_EXPORT address_t MCC_NewObj_fixed_class(address_t klass);
+MRT_EXPORT address_t MCC_Reflect_ThrowInstantiationError();
+MRT_EXPORT address_t MCC_NewObj_flexible_cname(size_t elemSize, size_t nElems,
+                                               const char *classNameOrclassObj,
+                                               address_t callerObj, unsigned long isClassObj);
+MRT_EXPORT address_t MCC_NewObject(address_t klass);
+MRT_EXPORT address_t MCC_NewArray8(size_t nElems, address_t klass);
+MRT_EXPORT address_t MCC_NewArray16(size_t nElems, address_t klass);
+MRT_EXPORT address_t MCC_NewArray32(size_t nElems, address_t klass);
+MRT_EXPORT address_t MCC_NewArray64(size_t nElems, address_t klass);
+MRT_EXPORT address_t MCC_NewArray(size_t nElems, const char *descriptor, address_t callerObj);
+MRT_EXPORT address_t MCC_NewPermanentObject(address_t klass);
+MRT_EXPORT address_t MCC_NewPermanentArray(size_t elemSize, size_t nElems,
+                                           const char *classNameOrclassObj, address_t callerObj,
+                                           unsigned long isClassObj);
+MRT_EXPORT address_t MCC_NewPermObject(address_t klass);
+MRT_EXPORT address_t MCC_NewPermArray8(size_t nElems, address_t klass);
+MRT_EXPORT address_t MCC_NewPermArray16(size_t nElems, address_t klass);
+MRT_EXPORT address_t MCC_NewPermArray32(size_t nElems, address_t klass);
+MRT_EXPORT address_t MCC_NewPermArray64(size_t nElems, address_t klass);
+MRT_EXPORT address_t MCC_NewPermArray(size_t nElems, const char *descriptor, address_t callerObj);
+
+// jsan
+MRT_EXPORT void MCC_CheckObjMem(void *obj);
+
+MRT_EXPORT void MCC_CheckRefCount(address_t obj, uint32_t index);
+
+// native binding
+MRT_EXPORT jobject MCC_CannotFindNativeMethod(const char *signature);
+MRT_EXPORT jstring MCC_CannotFindNativeMethod_S(const char *signature);
+MRT_EXPORT jobject MCC_CannotFindNativeMethod_A(const char *signature);
+MRT_EXPORT void *MCC_FindNativeMethodPtr(uintptr_t **regFuncTabAddr);
+MRT_EXPORT void *MCC_FindNativeMethodPtrWithoutException(uintptr_t **regFuncTabAddr);
+MRT_EXPORT void *MCC_DummyNativeMethodPtr();
+MRT_EXPORT jobject MCC_DecodeReference(jobject obj);
+
+// deferredaccess
+MRT_EXPORT void MCC_DeferredClinitCheck(address_t daiClass, const MObject *caller, const MString *className);
+MRT_EXPORT MClass *MCC_DeferredConstClass(address_t daiClass, const MObject *caller, const MString *className);
+MRT_EXPORT bool MCC_DeferredInstanceOf(address_t daiClass, const MObject *caller, const MString *className,
+                                       const MObject *obj);
+MRT_EXPORT MObject *MCC_DeferredCheckCast(address_t daiClass, const MObject *caller, const MString *className,
+                                          MObject *obj);
+MRT_EXPORT MObject *MCC_DeferredNewInstance(address_t daiClass, const MObject *caller, const MString *className);
+MRT_EXPORT MObject *MCC_DeferredNewArray(address_t daiClass, const MObject *caller, const MString *arrayTypeName,
+                                         uint32_t length);
+MRT_EXPORT MObject *MCC_DeferredFillNewArray(address_t daiClass, const MObject *caller,
+                                             const MString *arrayTypeName, uint32_t length, ...);
+MRT_EXPORT jvalue MCC_DeferredLoadField(address_t daiField, MObject *caller, const MString *className,
+                                        const MString *fieldName, const MString *fieldTypeName, const MObject *obj);
+MRT_EXPORT void MCC_DeferredStoreField(address_t daiField, MObject *caller, const MString *className,
+                                       const MString *fieldName, const MString *fieldTypeName, MObject *obj,
+                                       jvalue value);
+MRT_EXPORT jvalue MCC_DeferredInvoke(address_t daiMethod, int kind, const char *className, const char *methodName,
+                                     const char *signature, MObject *obj, ...);
+
+// type conversion, these two function is used to convert java double or java float to java long on arm32 platform
+MRT_EXPORT int64_t MCC_JDouble2JLong(double num);
+MRT_EXPORT int64_t MCC_JFloat2JLong(float num);
+
+// profile
+MRT_EXPORT void MCC_SaveProfile();
+
+}  // extern "C"
+}  // maplert
+#endif
diff --git a/src/mrt/maplert/public-headers/mrt_exception_api.h b/src/mrt/maplert/public-headers/mrt_exception_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..72b46d11ff2110a4fdae6982dc638c5ea747404b
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_exception_api.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_MRT_EXCEPTION_H_
+#define MAPLE_MRT_EXCEPTION_H_
+
+#include <csignal>
+#include "mrt_api_common.h"
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+MRT_EXPORT void MRT_ClearThrowingException();
+
+// null if no pending exception. if return value is not null, an exception is
+// raised earlier, and should be handled or rethrown some time later.
+MRT_EXPORT bool MRT_FaultHandler(int sig, siginfo_t *info, ucontext_t *context, bool isFromJava);
+MRT_EXPORT bool MRT_FaultDebugHandler(int sig, siginfo_t *info, void *context);
+
+
+typedef void (*RealHandler1)(const void*);
+MRT_EXPORT bool MRT_PrepareToHandleJavaSignal(
+    ucontext_t *ucontext, RealHandler1 handler, void *arg1, RealHandler1 rhandler = nullptr,
+    void *r1 = nullptr, int returnPCOffset = 1);
+
+MRT_EXPORT void MRT_ThrowExceptionSafe(jobject ex);   // check whether ex is throwable
+MRT_EXPORT void MRT_ThrowExceptionUnsafe(jobject ex); // do not check, throw anything
+MRT_EXPORT void MRT_ClearPendingException();
+MRT_EXPORT jobject MRT_PendingException();
+
+MRT_EXPORT void MRT_DumpException(jthrowable ex, std::string *exception_stack = nullptr);
+MRT_EXPORT void MRT_DumpExceptionForLog(jthrowable ex);
+MRT_EXPORT void MRT_DumpExceptionTypeCount(std::ostream &os);
+MRT_EXPORT void MRT_DumpExceptionStack(std::ostream &os);
+MRT_EXPORT void MRT_DumpNativeExceptionTypeCount(std::ostream &os);
+MRT_EXPORT void MRT_DumpNativeExceptionStack(std::ostream &os);
+MRT_EXPORT void MRT_CheckException(bool ok, std::string msg = "");
+MRT_EXPORT void MRT_ThrowNewExceptionUnw(const char *className, const char *msg = "unknown reason");
+MRT_EXPORT void MRT_ThrowNewExceptionRet(const char *className, const char *msg = "unknown reason");
+// check pending exception and raise it if existed.
+// MRT_CheckThrowPendingExceptionUnw is used only in runtime functions called
+// directly by java code, for example, fast path of some jni methods.
+// MRT_CheckThrowPendingExceptionUnw is different from MRT_CheckThrowPendingExceptionUnw
+MRT_EXPORT void MRT_CheckThrowPendingExceptionUnw();
+MRT_EXPORT void MRT_ThrowNullPointerExceptionUnw(); // when throwing NPE in signal handler
+MRT_EXPORT void MRT_ThrowArrayIndexOutOfBoundsException(int32_t length, int32_t index);
+MRT_EXPORT void MRT_ThrowArrayIndexOutOfBoundsExceptionUnw(int32_t length, int32_t index);
+
+// The function at the end of Ret is a fast exception handling interface,
+// which must be used to ensure that it is a tail function.
+MRT_EXPORT void MRT_CheckThrowPendingExceptionRet();
+
+// Unwind
+MRT_EXPORT void MRT_SetReliableUnwindContextStatus();
+MRT_EXPORT void MRT_SetIgnoredUnwindContextStatus();
+MRT_EXPORT void MRT_SetRiskyUnwindContext(const uint32_t *pc, void *fp);
+MRT_EXPORT void MRT_UpdateLastJavaFrame(const uint32_t *pc, void *fp);
+MRT_EXPORT void MRT_UpdateLastUnwindContextIfReliable(const uint32_t *pc, void *fp);
+
+// exception
+MRT_EXPORT void MRT_GetHandlerCatcherArgs(struct HandlerCatcherArgs *pArgs);
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+
+#endif //MAPLE_MRT_EXCEPTION_H_
diff --git a/src/mrt/maplert/public-headers/mrt_fields_api.h b/src/mrt/maplert/public-headers/mrt_fields_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..3bc56ea882601df25bcf748c06c9f7dab35df500
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_fields_api.h
@@ -0,0 +1,367 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_LIB_CORE_MPL_FILEDS_H_
+#define MAPLE_LIB_CORE_MPL_FILEDS_H_
+
+#include <atomic>
+#include <assert.h>
+
+#include "jsan.h"
+#include "gc_config.h"
+#include "address.h"
+#include "mrt_api_common.h"
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+// Load and store operations for fields
+MRT_EXPORT address_t MRT_LoadRefField(address_t obj, address_t *fieldAddr);
+MRT_EXPORT void      MRT_WriteRefField(address_t obj, address_t *field, address_t value);
+MRT_EXPORT address_t MRT_LoadVolatileField(address_t obj, address_t *fieldAddr);
+MRT_EXPORT void      MRT_WriteVolatileField(address_t obj, address_t *objAddr, address_t value);
+MRT_EXPORT void      MRT_WriteVolatileStaticField(address_t *fieldAddr, address_t value);
+MRT_EXPORT void      MRT_WriteRefFieldStatic(address_t *field, address_t value);
+
+// used for field with rc_weak_field annotation
+MRT_EXPORT void      MRT_WriteWeakField(address_t obj, address_t *field, address_t value, bool isVolatile);
+MRT_EXPORT address_t MRT_LoadWeakField(address_t obj, address_t *field, bool isVolatile);
+MRT_EXPORT void      MRT_WriteReferentField(address_t obj, address_t *fieldAddr, address_t value,
+                                            bool isResurrectWeak);
+MRT_EXPORT address_t MRT_LoadReferentField(address_t obj, address_t *fieldAddr);
+
+static inline bool MRT_LoadJBoolean(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return *reinterpret_cast<bool*>(obj + offset);
+}
+
+static inline bool MRT_LoadJBooleanVolatile(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return reinterpret_cast<std::atomic<bool>*>(obj + offset)->load(std::memory_order_seq_cst);
+}
+
+static inline int8_t MRT_LoadJByte(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return *reinterpret_cast<int8_t*>(obj + offset);
+}
+
+static inline int8_t MRT_LoadJByteVolatile(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return reinterpret_cast<std::atomic<int8_t>*>(obj + offset)->load(std::memory_order_seq_cst);
+}
+
+static inline int16_t MRT_LoadJShort(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return *reinterpret_cast<int16_t*>(obj + offset);
+}
+
+static inline int16_t MRT_LoadJShortVolatile(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return reinterpret_cast<std::atomic<int16_t>*>(obj + offset)->load(std::memory_order_seq_cst);
+}
+
+static inline uint16_t MRT_LoadJChar(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return *reinterpret_cast<uint16_t*>(obj + offset);
+}
+
+static inline uint16_t MRT_LoadJCharVolatile(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return reinterpret_cast<std::atomic<uint16_t>*>(obj + offset)->load(std::memory_order_seq_cst);
+}
+
+static inline int32_t MRT_LoadJInt(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return *reinterpret_cast<int32_t*>(obj + offset);
+}
+
+static inline int32_t MRT_LoadJIntVolatile(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return reinterpret_cast<std::atomic<int32_t>*>(obj + offset)->load(std::memory_order_seq_cst);
+}
+
+static inline int64_t MRT_LoadJLong(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return *reinterpret_cast<int64_t*>(obj + offset);
+}
+
+static inline int64_t MRT_LoadJLongVolatile(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return reinterpret_cast<std::atomic<int64_t>*>(obj + offset)->load(std::memory_order_seq_cst);
+}
+
+static inline float MRT_LoadJFloat(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return *reinterpret_cast<float*>(obj + offset);
+}
+
+static inline float MRT_LoadJFloatVolatile(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return reinterpret_cast<std::atomic<float>*>(obj + offset)->load(std::memory_order_seq_cst);
+}
+
+static inline double MRT_LoadJDouble(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return *reinterpret_cast<double*>(obj + offset);
+}
+
+static inline double MRT_LoadJDoubleVolatile(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return reinterpret_cast<std::atomic<double>*>(obj + offset)->load(std::memory_order_seq_cst);
+}
+
+static inline uintptr_t MRT_LoadJObject(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  return reinterpret_cast<uintptr_t>(LoadRefField(obj, offset));
+}
+
+static inline uintptr_t MRT_LoadJObjectInc(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  uintptr_t res = reinterpret_cast<uintptr_t>(MRT_LoadRefField(obj, reinterpret_cast<address_t*>(obj + offset)));
+  return res;
+}
+
+static inline uintptr_t MRT_LoadJObjectIncVolatile(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  uintptr_t res = reinterpret_cast<uintptr_t>(MRT_LoadVolatileField(obj, reinterpret_cast<address_t*>(obj + offset)));
+  return res;
+}
+
+static inline uintptr_t MRT_LoadJObjectIncReferent(address_t obj, size_t offset) {
+  JSAN_CHECK_OBJ(obj);
+  uintptr_t res = reinterpret_cast<uintptr_t>(MRT_LoadReferentField(obj, reinterpret_cast<address_t*>(obj + offset)));
+  return res;
+}
+
+static inline void MRT_StoreJBoolean(address_t obj, size_t offset, bool value) {
+  JSAN_CHECK_OBJ(obj);
+  *reinterpret_cast<bool*>(obj + offset) = value;
+}
+
+static inline void MRT_StoreJBooleanVolatile(address_t obj, size_t offset, bool value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<bool>*>(obj + offset)->store(value, std::memory_order_seq_cst);
+}
+
+static inline void MRT_StoreJByte(address_t obj, size_t offset, int8_t value) {
+  JSAN_CHECK_OBJ(obj);
+  *reinterpret_cast<int8_t*>(obj + offset) = value;
+}
+
+static inline void MRT_StoreJByteVolatile(address_t obj, size_t offset, int8_t value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<int8_t>*>(obj + offset)->store(value, std::memory_order_seq_cst);
+}
+
+static inline void MRT_StoreJShort(address_t obj, size_t offset, int16_t value) {
+  JSAN_CHECK_OBJ(obj);
+  *reinterpret_cast<int16_t*>(obj + offset) = value;
+}
+
+static inline void MRT_StoreJShortVolatile(address_t obj, size_t offset, int16_t value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<int16_t>*>(obj + offset)->store(value, std::memory_order_seq_cst);
+}
+
+static inline void MRT_StoreJChar(address_t obj, size_t offset, uint16_t value) {
+  JSAN_CHECK_OBJ(obj);
+  *reinterpret_cast<uint16_t*>(obj + offset) = value;
+}
+
+static inline void MRT_StoreJCharVolatile(address_t obj, size_t offset, uint16_t value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<uint16_t>*>(obj + offset)->store(value, std::memory_order_seq_cst);
+}
+
+static inline void MRT_StoreJInt(address_t obj, size_t offset, int32_t value) {
+  JSAN_CHECK_OBJ(obj);
+  *reinterpret_cast<int32_t*>(obj + offset) = value;
+}
+
+static inline void MRT_StoreJIntVolatile(address_t obj, size_t offset, int32_t value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<int32_t>*>(obj + offset)->store(value, std::memory_order_seq_cst);
+}
+
+static inline void MRT_StoreOrderedJInt(address_t obj, size_t offset, int32_t value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<int32_t>*>(obj + offset)->store(value, std::memory_order_release);
+}
+
+static inline void MRT_StoreJLong(address_t obj, size_t offset, int64_t value) {
+  JSAN_CHECK_OBJ(obj);
+  *reinterpret_cast<int64_t*>(obj + offset) = value;
+}
+
+static inline void MRT_StoreJLongVolatile(address_t obj, size_t offset, int64_t value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<int64_t>*>(obj + offset)->store(value, std::memory_order_seq_cst);
+}
+
+static inline void MRT_StoreOrderedJLong(address_t obj, size_t offset, int64_t value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<int64_t>*>(obj + offset)->store(value, std::memory_order_release);
+}
+
+
+static inline void MRT_StoreJFloat(address_t obj, size_t offset, float value) {
+  JSAN_CHECK_OBJ(obj);
+  *reinterpret_cast<float*>(obj + offset) = value;
+}
+
+static inline void MRT_StoreJFloatVolatile(address_t obj, size_t offset, float value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<float>*>(obj + offset)->store(value, std::memory_order_seq_cst);
+}
+
+static inline void MRT_StoreJDouble(address_t obj, size_t offset, double value) {
+  JSAN_CHECK_OBJ(obj);
+  *reinterpret_cast<double*>(obj + offset) = value;
+}
+
+static inline void MRT_StoreJDoubleVolatile(address_t obj, size_t offset, double value) {
+  JSAN_CHECK_OBJ(obj);
+  reinterpret_cast<std::atomic<double>*>(obj + offset)->store(value, std::memory_order_seq_cst);
+}
+
+static inline void MRT_StoreJObject(address_t obj, size_t offset, uintptr_t value) {
+  JSAN_CHECK_OBJ(obj);
+  MRT_WriteRefField(obj, reinterpret_cast<address_t*>(obj + offset), reinterpret_cast<address_t>(value));
+}
+
+static inline void MRT_StoreJObjectStatic(address_t *addr, uintptr_t value) {
+  JSAN_CHECK_OBJ(*addr);
+  MRT_WriteRefFieldStatic(addr, reinterpret_cast<address_t>(value));
+}
+
+static inline void MRT_StoreMetaJobject(address_t obj, size_t offset, uintptr_t value) {
+  JSAN_CHECK_OBJ(obj);
+  StoreRefField(obj, offset, reinterpret_cast<address_t>(value));
+}
+
+static inline void MRT_StoreJObjectNoRc(address_t obj, size_t offset, uintptr_t value) {
+  JSAN_CHECK_OBJ(obj);
+  StoreRefField(obj, offset, reinterpret_cast<address_t>(value));
+}
+
+static inline void MRT_StoreJObjectVolatile(address_t obj, size_t offset, uintptr_t value) {
+  JSAN_CHECK_OBJ(obj);
+  MRT_WriteVolatileField(obj, reinterpret_cast<address_t*>(obj + offset), reinterpret_cast<address_t>(value));
+}
+
+static inline void MRT_StoreJObjectVolatileStatic(address_t *addr, uintptr_t value) {
+  JSAN_CHECK_OBJ(*addr);
+  MRT_WriteVolatileStaticField(addr, reinterpret_cast<address_t>(value));
+}
+
+static inline void MRT_WriteReferent(address_t obj, size_t offset, uintptr_t value, bool isResurrectWeak) {
+  JSAN_CHECK_OBJ(obj);
+  MRT_WriteReferentField(obj, reinterpret_cast<address_t*>(obj + offset),
+                         reinterpret_cast<address_t>(value), isResurrectWeak);
+}
+
+#define MRT_LOAD_JBOOLEAN(obj, offset) MRT_LoadJBoolean(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JBYTE(obj, offset) MRT_LoadJByte(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JSHORT(obj, offset) MRT_LoadJShort(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JCHAR(obj, offset) MRT_LoadJChar(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JINT(obj, offset) MRT_LoadJInt(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JLONG(obj, offset) MRT_LoadJLong(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JFLOAT(obj, offset) MRT_LoadJFloat(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JDOUBLE(obj, offset) MRT_LoadJDouble(reinterpret_cast<address_t>(obj), offset)
+
+#define MRT_LOAD_JBOOLEAN_VOLATILE(obj, offset) MRT_LoadJBooleanVolatile(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JBYTE_VOLATILE(obj, offset) MRT_LoadJByteVolatile(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JSHORT_VOLATILE(obj, offset) MRT_LoadJShortVolatile(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JCHAR_VOLATILE(obj, offset) MRT_LoadJCharVolatile(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JINT_VOLATILE(obj, offset) MRT_LoadJIntVolatile(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JLONG_VOLATILE(obj, offset) MRT_LoadJLongVolatile(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JFLOAT_VOLATILE(obj, offset) MRT_LoadJFloatVolatile(reinterpret_cast<address_t>(obj), offset)
+#define MRT_LOAD_JDOUBLE_VOLATILE(obj, offset) MRT_LoadJDoubleVolatile(reinterpret_cast<address_t>(obj), offset)
+
+// not used in mrt, native(android-mrt) should use defines in
+// maplert/public-headers/mrt_fields_api.h
+// MRT_LOAD_JOBJECT_INC load object and IncRef
+#define MRT_LOAD_JOBJECT(obj, offset) \
+    MRT_LoadJObject(reinterpret_cast<address_t>(obj), offset) trigger_compiler_err  // should not use
+#define MRT_LOAD_JOBJECT_INC(obj, offset) \
+    MRT_LoadJObjectInc(reinterpret_cast<address_t>(obj), offset)  // used in runtime code (maplert)
+#define MRT_LOAD_JOBJECT_INC_VOLATILE(obj, offset) \
+    MRT_LoadJObjectIncVolatile(reinterpret_cast<address_t>(obj), offset)  // used in runtime code (maplert)
+#define MRT_LOAD_JOBJECT_INC_REFERENT(obj, offset) \
+    MRT_LoadJObjectIncReferent(reinterpret_cast<address_t>(obj), offset)  // used in runtime code (maplert)
+#define MRT_LOAD_META_JOBJECT(obj, offset) \
+    MRT_LoadJObject(reinterpret_cast<address_t>(obj), offset)  // used in runtime code (maplert)
+
+// ONLY use in mrt_array.cpp for unsafe array copying.
+#define __UNSAFE_MRT_LOAD_JOBJECT_NOINC(obj, offset) MRT_LoadJObject(reinterpret_cast<address_t>(obj), offset)
+#define __UNSAFE_MRT_STORE_JOBJECT_NORC(obj, offset, value) \
+    MRT_StoreJObjectNoRc(reinterpret_cast<address_t>(obj), offset, reinterpret_cast<uintptr_t>(value))
+
+#define MRT_STORE_JBOOLEAN(obj, offset, value) MRT_StoreJBoolean(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JBYTE(obj, offset, value) MRT_StoreJByte(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JSHORT(obj, offset, value) MRT_StoreJShort(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JCHAR(obj, offset, value) MRT_StoreJChar(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JINT(obj, offset, value) MRT_StoreJInt(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JLONG(obj, offset, value) MRT_StoreJLong(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JFLOAT(obj, offset, value) MRT_StoreJFloat(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JDOUBLE(obj, offset, value) MRT_StoreJDouble(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_ORDERED_JINT(obj, offset, value) \
+    MRT_StoreOrderedJInt(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_ORDERED_JLONG(obj, offset, value) \
+    MRT_StoreOrderedJLong(reinterpret_cast<address_t>(obj), offset, value)
+
+#define MRT_STORE_JBOOLEAN_VOLATILE(obj, offset, value) \
+    MRT_StoreJBooleanVolatile(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JBYTE_VOLATILE(obj, offset, value) \
+    MRT_StoreJByteVolatile(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JSHORT_VOLATILE(obj, offset, value) \
+    MRT_StoreJShortVolatile(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JCHAR_VOLATILE(obj, offset, value) \
+    MRT_StoreJCharVolatile(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JINT_VOLATILE(obj, offset, value) \
+    MRT_StoreJIntVolatile(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JLONG_VOLATILE(obj, offset, value) \
+    MRT_StoreJLongVolatile(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JFLOAT_VOLATILE(obj, offset, value) \
+    MRT_StoreJFloatVolatile(reinterpret_cast<address_t>(obj), offset, value)
+#define MRT_STORE_JDOUBLE_VOLATILE(obj, offset, value) \
+    MRT_StoreJDoubleVolatile(reinterpret_cast<address_t>(obj), offset, value)
+
+#define MRT_STORE_JOBJECT(obj, offset, value) \
+    MRT_StoreJObject(reinterpret_cast<address_t>(obj), offset, reinterpret_cast<uintptr_t>(value))
+
+#define MRT_STORE_JOBJECT_STATIC(addr, value) \
+    MRT_StoreJObjectStatic(addr, reinterpret_cast<uintptr_t>(value))
+
+#define MRT_STORE_META_JOBJECT(obj, offset, value) \
+    MRT_StoreMetaJobject(reinterpret_cast<address_t>(obj), offset, reinterpret_cast<uintptr_t>(value))
+
+#define MRT_STORE_JOBJECT_VOLATILE(obj, offset, value) \
+    MRT_StoreJObjectVolatile(reinterpret_cast<address_t>(obj), offset, reinterpret_cast<uintptr_t>(value))
+
+#define MRT_STORE_JOBJECT_VOLATILE_STATIC(addr, value) \
+    MRT_StoreJObjectVolatileStatic(addr, reinterpret_cast<uintptr_t>(value))
+
+#define MRT_WRITE_REFERENT(obj, offset, value, isResurrectWeak) \
+    MRT_WriteReferent(reinterpret_cast<address_t>(obj), offset, reinterpret_cast<uintptr_t>(value), isResurrectWeak)
+
+#ifdef __cplusplus
+} // namespace maplert
+} // extern "C"
+#endif
+
+#endif //MAPLE_LIB_CORE_MPL_FILEDS_H_
+
diff --git a/src/mrt/maplert/public-headers/mrt_libs_api.h b/src/mrt/maplert/public-headers/mrt_libs_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..146efb66dd1dd964fc44edc9ad2c4763e51c6ab1
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_libs_api.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_LIBS_H_
+#define MAPLE_RUNTIME_LIBS_H_
+
+#include "mrt_api_common.h"
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+MRT_EXPORT void MRT_DumpMethodUse(std::ostream &os);
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+#endif
diff --git a/src/mrt/maplert/public-headers/mrt_linker_api.h b/src/mrt/maplert/public-headers/mrt_linker_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..9be9d1d4a0967bf8681d91dc3ba39afbeb795d9a
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_linker_api.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_CLASS_LINKER_API_H_
+#define MRT_CLASS_LINKER_API_H_
+
+#include "mrt_api_common.h"
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+MRT_EXPORT bool MRT_LinkerIsJavaText(const void *addr);
+MRT_EXPORT void *MRT_LinkerGetSymbolAddr(void *handle, const char *symbol, bool isFunction);
+MRT_EXPORT void MRT_LinkerSetCachePath(const char *path);
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+#endif // MRT_CLASS_LOCATOR_MGR_H_
diff --git a/src/mrt/maplert/public-headers/mrt_mm_config_common.h b/src/mrt/maplert/public-headers/mrt_mm_config_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..730811666cd2b25a8157e32f5e1318bd7a15ab45
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_mm_config_common.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MM_CONFIG_COMMON_H
+#define MAPLE_RUNTIME_MM_CONFIG_COMMON_H
+
+#ifndef CONFIG_JSAN
+#define CONFIG_JSAN 0
+#endif
+
+// By default, enable unit test code on non-android
+// platform (for example: qemu on host linux).
+#ifndef MRT_UNIT_TEST
+#ifndef __ANDROID__
+#define MRT_UNIT_TEST 1
+#endif
+#endif
+
+namespace maplert {
+// Use this inline function to "use" a variable so that the compiler will not
+// complain about unused variables.  This is especially useful when implementing
+// gc-only where functions like RC_LOCAL_INC_REF and RC_LOCAL_DEC_REF do not
+// do anything.
+template<class ... Types>
+__attribute__((always_inline)) inline void MRT_DummyUse(Types&& ... args __attribute__((unused))) {}
+} // namespace maplert
+
+
+#endif //MAPLE_RUNTIME_MMCONFIG_COMMON_H
diff --git a/src/mrt/maplert/public-headers/mrt_monitor_api.h b/src/mrt/maplert/public-headers/mrt_monitor_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1a373bcc745486103e013edb28b25112b32a8ed
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_monitor_api.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_MONITOR_H_
+#define MAPLE_RUNTIME_MONITOR_H_
+
+#include "mrt_api_common.h"
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+MRT_EXPORT jobject MRT_CloneJavaObject(jobject obj);
+/*
+ * Returns memory used by the specified object.
+ * NOTICE: Includes the object header.
+ */
+MRT_EXPORT size_t MRT_SizeOfObject(jobject obj);
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+
+#endif //MAPLE_RUNTIME_MONITOR_H_
diff --git a/src/mrt/maplert/public-headers/mrt_naming_api.h b/src/mrt/maplert/public-headers/mrt_naming_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..77ec7dfd17a55ae290e968b11e6b83bf8c1ffabc
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_naming_api.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_NAMEMANGLER_API_H_
+#define MRT_NAMEMANGLER_API_H_
+
+#include <string>
+#include "mrt_api_common.h"
+
+// The namespace is shared between RT and compiler
+namespace namemanglerapi {
+MRT_EXPORT std::string MangleForJni(const std::string &s);
+MRT_EXPORT std::string MangleForJniDex(const std::string &s);
+}
+
+#endif //MRT_NAMEMANGLER_API_H_
diff --git a/src/mrt/maplert/public-headers/mrt_poisonstack.h b/src/mrt/maplert/public-headers/mrt_poisonstack.h
new file mode 100644
index 0000000000000000000000000000000000000000..9065efea27f11cb4c10e9d410ded56f8888709fd
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_poisonstack.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_POISIONSTACK_H_
+#define MAPLEALL_MAPLERT_JAVA_ANDROID_MRT_INCLUDE_MRT_POISIONSTACK_H_
+
+#include <cstdint>
+#include "mrt_api_common.h"
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif // __cplusplus
+
+MRT_EXPORT void MRT_InitPoisonStack(uintptr_t framePtr);
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif // __cplusplus
+#endif
diff --git a/src/mrt/maplert/public-headers/mrt_primitive_api.h b/src/mrt/maplert/public-headers/mrt_primitive_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7e699cd7e7f7c037942c4b155235f80b9b87d8f
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_primitive_api.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_LIB_CORE_MPL_PRIMITIVE_H_
+#define MAPLE_LIB_CORE_MPL_PRIMITIVE_H_
+
+#include "mrt_api_common.h"
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+//  PrimitiveClass
+MRT_EXPORT jclass MRT_GetPrimitiveClassJboolean(void);
+MRT_EXPORT jclass MRT_GetPrimitiveClassJbyte(void);
+MRT_EXPORT jclass MRT_GetPrimitiveClassJchar(void);
+MRT_EXPORT jclass MRT_GetPrimitiveClassJdouble(void);
+MRT_EXPORT jclass MRT_GetPrimitiveClassJfloat(void);
+MRT_EXPORT jclass MRT_GetPrimitiveClassJint(void);
+MRT_EXPORT jclass MRT_GetPrimitiveClassJlong(void);
+MRT_EXPORT jclass MRT_GetPrimitiveClassJshort(void);
+MRT_EXPORT jclass MRT_GetPrimitiveClassVoid(void);
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+
+#endif //MAPLE_LIB_CORE_MPL_PRIMITIVE_H_
diff --git a/src/mrt/maplert/public-headers/mrt_public_api.h b/src/mrt/maplert/public-headers/mrt_public_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0d01acf630f9ae49c2ad25b14a55caa3614ed16
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_public_api.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MRT_PUBLIC_API
+#define MRT_PUBLIC_API
+#include <stddef.h>
+#include "mrt_class_api.h"
+#include "mrt_string_api.h"
+#include "mrt_primitive_api.h"
+#include "mrt_reflection_api.h"
+#include "mrt_reference_api.h"
+#include "mrt_array_api.h"
+#include "mrt_monitor_api.h"
+#include "mrt_fields_api.h"
+#include "mrt_exception_api.h"
+#include "mrt_thread_api.h"
+#include "mrt_libs_api.h"
+#include "mrt_naming_api.h"
+#include "mrt_classloader_api.h"
+#include "mrt_linker_api.h"
+#endif
diff --git a/src/mrt/maplert/public-headers/mrt_reference_api.h b/src/mrt/maplert/public-headers/mrt_reference_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..844d2141e775c279ea439f5224f6b90c89ec2f13
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_reference_api.h
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_LIB_CORE_MPL_REFERENCE_H_
+#define MAPLE_LIB_CORE_MPL_REFERENCE_H_
+
+#include <functional>
+
+// mrt/libmrtbase/include/gc_config.h
+#include <vector>
+#include <map>
+#include "mrt_api_common.h"
+#include "jni.h"
+#include "gc_config.h"
+#include "gc_callback.h"
+#include "gc_reason.h"
+#include "gc_roots.h"
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+// cycle pattern valid flag
+const int kCycleValid = 0;
+const int kCycleNotValid = 1;
+const int kCyclePermernant = 2;
+// cycle pattern node flag
+const unsigned int kCycleNodeSubClass = 0x1;
+// cycle pattern edge flag
+const unsigned int kCycleEdgeSkipMatch = 0x1;
+
+MRT_EXPORT void MRT_IncRef(address_t obj);
+MRT_EXPORT void MRT_DecRef(address_t obj);
+MRT_EXPORT void MRT_IncDecRef(address_t incObj, address_t decObj);
+MRT_EXPORT void MRT_DecRefUnsync(address_t obj);
+MRT_EXPORT void MRT_IncResurrectWeak(address_t obj);
+
+MRT_EXPORT void MRT_ReleaseObj(address_t obj);
+MRT_EXPORT void MRT_CollectWeakObj(address_t obj);
+MRT_EXPORT address_t MRT_IncRefNaiveRCFast(address_t obj);
+MRT_EXPORT address_t MRT_DecRefNaiveRCFast(address_t obj);
+MRT_EXPORT void MRT_IncDecRefNaiveRCFast(address_t incAddr, address_t decAddr);
+// encoding the cycle pattern
+MRT_EXPORT void MRT_GetCyclePattern(std::ostream& os);
+MRT_EXPORT std::ostream *MRT_GetCycleLogFile();
+
+// collector specific JNI interface
+// Unsafe
+MRT_EXPORT bool MRT_UnsafeCompareAndSwapObject(address_t obj, ssize_t offset,
+                                               address_t expectedValue, address_t newValue);
+MRT_EXPORT address_t MRT_UnsafeGetObjectVolatile(address_t obj, ssize_t offset);
+MRT_EXPORT address_t MRT_UnsafeGetObject(address_t obj, ssize_t offset);
+MRT_EXPORT void MRT_UnsafePutObject(address_t obj, ssize_t offset, address_t newValue);
+MRT_EXPORT void MRT_UnsafePutObjectVolatile(address_t obj, ssize_t offset, address_t newValue);
+MRT_EXPORT void MRT_UnsafePutObjectOrdered(address_t obj, ssize_t offset, address_t newValue);
+
+// weak global reference decoding barrier
+MRT_EXPORT void MRT_WeakRefGetBarrier(address_t referent);
+
+// get the reference count of an object. only for external usage.
+MRT_EXPORT uint32_t MRT_RefCount(address_t obj);
+
+MRT_EXPORT bool MRT_CheckHeapObj(uintptr_t obj);
+MRT_EXPORT bool MRT_IsGarbage(address_t obj);
+MRT_EXPORT bool MRT_IsValidOffHeapObject(jobject obj);
+
+MRT_EXPORT bool MRT_EnterSaferegion(bool rememberLastJavaFrame = true);
+MRT_EXPORT bool MRT_LeaveSaferegion();
+
+MRT_EXPORT address_t MRT_GetHeapLowerBound();
+MRT_EXPORT address_t MRT_GetHeapUpperBound();
+MRT_EXPORT bool MRT_IsValidObjAddr(address_t obj);
+
+// Keep these consistent with compiler-rt/include/cinterface.h
+struct VMHeapParam {
+  size_t heapStartSize;
+  size_t heapSize;
+  size_t heapGrowthLimit;
+  size_t heapMinFree;
+  size_t heapMaxFree;
+  float heapTargetUtilization;
+  bool ignoreMaxFootprint;
+  bool gcOnly = false;
+  bool enableGCLog = false;
+  bool isZygote = false;
+};
+
+MRT_EXPORT bool MRT_GCInitGlobal(const VMHeapParam &vmHeapParam);
+MRT_EXPORT bool MRT_GCFiniGlobal();
+MRT_EXPORT bool MRT_GCInitThreadLocal(bool isMain);
+MRT_EXPORT bool MRT_GCFiniThreadLocal();
+MRT_EXPORT void MRT_GCStart();
+
+// fork handlers.
+MRT_EXPORT void MRT_GCPreFork();
+MRT_EXPORT void MRT_GCPostForkChild(bool isSystem);
+MRT_EXPORT void MRT_GCPostForkCommon(bool isZygote);
+MRT_EXPORT void MRT_ForkInGC(bool flag);
+MRT_EXPORT void MRT_GCLogPostFork();
+MRT_EXPORT void MRT_RegisterNativeAllocation(size_t byte);
+MRT_EXPORT void MRT_RegisterNativeFree(size_t byte);
+MRT_EXPORT void MRT_NotifyNativeAllocation();
+
+// returns number of GC occurred since this function was called last time and
+// stop-the-world time maximum in ms. both counts are reset after the call
+MRT_EXPORT void MRT_GetGcCounts(size_t &gcCount, uint64_t &maxGcMs);
+
+// returns info for memory leak identified by backup tracing
+// average leak and peak leak memory size in Bytes
+// both numbers are reset are the call
+MRT_EXPORT void MRT_GetMemLeak(size_t &avgLeak, size_t &peakLeak);
+
+// returns the memory utilization rate (higher the better)
+// and allocation
+MRT_EXPORT void MRT_GetMemAlloc(float &util, size_t &abnormalCount);
+
+// returns number of RC abnormal such as rc counts
+// increased from zero to one
+MRT_EXPORT void MRT_GetRCParam(size_t &abnormalCount);
+
+inline unsigned long MRT_GetGCUsedHeapMemoryTotal() {
+  return 0;
+};
+
+MRT_EXPORT void     MRT_ResetHeapStats();
+MRT_EXPORT size_t   MRT_AllocSize();
+MRT_EXPORT size_t   MRT_AllocCount();
+MRT_EXPORT size_t   MRT_FreeSize();
+MRT_EXPORT size_t   MRT_FreeCount();
+MRT_EXPORT size_t   MRT_TotalMemory();
+// returns the max memory usage
+MRT_EXPORT size_t   MRT_MaxMemory();
+// returns the free memory within the limit
+MRT_EXPORT size_t   MRT_FreeMemory();
+MRT_EXPORT void     MRT_SetHeapProfile(int hp);
+// return all live instances of the given class
+MRT_EXPORT void     MRT_GetInstances(jclass klass, bool includeAssignable,
+    size_t max_count, std::vector<jobject> &instances);
+
+MRT_EXPORT void  MRT_DebugCleanup();
+MRT_EXPORT void  MRT_RegisterGCRoots(address_t *gcroots[], size_t len);
+MRT_EXPORT void  MRT_RegisterRCCheckAddr(uint64_t *addr);
+
+MRT_EXPORT void  MRT_SetReferenceProcessMode(bool immediate);
+MRT_EXPORT void *MRT_ProcessReferences(void *args);
+MRT_EXPORT void  MRT_StopProcessReferences(bool doFinalizeOnStop = false);
+MRT_EXPORT void  MRT_WaitProcessReferencesStopped();
+MRT_EXPORT void  MRT_WaitProcessReferencesStarted();
+
+MRT_EXPORT void  MRT_WaitGCStopped();
+MRT_EXPORT void  MRT_CheckSaferegion(bool expect, const char *msg);
+
+// dump RC and GC information into stream os
+MRT_EXPORT void MRT_DumpRCAndGCPerformanceInfo(std::ostream &os);
+
+// Enable/disable GC triggers
+MRT_EXPORT void MRT_TriggerGC(maplert::GCReason reason);
+MRT_EXPORT bool MRT_IsGcThread();
+MRT_EXPORT bool MRT_IsNaiveRCCollector();
+
+MRT_EXPORT bool MRT_IsValidObjectAddress(address_t obj);
+MRT_EXPORT void MRT_VisitAllocatedObjects(maple::rootObjectFunc func);
+
+// Alloc tracking
+MRT_EXPORT void MRT_SetAllocRecordingCallback(std::function<void(address_t, size_t)> callback);
+
+// Trim memory
+MRT_EXPORT void MRT_Trim(bool aggressive);
+MRT_EXPORT void MRT_RequestTrim();
+
+MRT_EXPORT void MRT_SetHwBlobClass(jclass cls);
+MRT_EXPORT void MRT_SetSurfaceControlClass(jclass cls);
+MRT_EXPORT void MRT_SetBinderProxyClass(jclass cls);
+
+// Udpate process state
+MRT_EXPORT void MRT_UpdateProcessState(ProcessState processState, bool isSystemServer);
+
+// cycle pattern
+MRT_EXPORT void MRT_DumpDynamicCyclePatterns(std::ostream &os, size_t limit);
+MRT_EXPORT void MRT_SendCyclePatternJob(std::function<void()> job);
+MRT_EXPORT void MRT_SetPeriodicSaveCpJob(std::function<void()> job);
+MRT_EXPORT void MRT_SetPeriodicLearnCpJob(std::function<void()> job);
+MRT_EXPORT bool MRT_IsCyclePatternUpdated();
+
+// Set a callback function which is called after GC finished, but before
+// starting the world.  Useful for performing cleaning up after a GC.
+MRT_EXPORT void MRT_DumpStaticField(std::ostream &os);
+MRT_EXPORT void MRT_logRefqueuesSize();
+
+// MRT_PreWriteRefField should be called before we directly write a reference field
+// of an java heap object but not use write barrier such as MRT_WriteRefField().
+// This is required for concurrent marking.
+MRT_EXPORT void MRT_PreWriteRefField(address_t obj);
+MRT_EXPORT size_t MRT_GetNativeAllocBytes();
+MRT_EXPORT void   MRT_SetNativeAllocBytes(size_t size);
+
+MRT_EXPORT address_t MRT_LoadVolatileField(address_t obj, address_t *fieldAddr);
+MRT_EXPORT address_t MRT_LoadRefFieldCommon(address_t obj, address_t *fieldAddr);
+MRT_EXPORT void MRT_ClassInstanceNum(std::map<std::string, long> &objNameCntMp);
+
+// reference api
+MRT_EXPORT address_t MRT_ReferenceGetReferent(address_t javaThis);
+MRT_EXPORT void    MRT_ReferenceClearReferent(address_t javaThis);
+MRT_EXPORT void    MRT_RunFinalization();
+
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+
+#endif //MAPLE_LIB_CORE_MPL_REFERENCE_H_
diff --git a/src/mrt/maplert/public-headers/mrt_reflection_api.h b/src/mrt/maplert/public-headers/mrt_reflection_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..22c0b66f43532f2ef5d41df71f1a3c49944acdc0
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_reflection_api.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_MRT_REFLECTION_API_H
+#define MAPLE_MRT_REFLECTION_API_H
+
+#include "mrt_api_common.h"
+#include "jni.h"
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+// bridging API between JNI jmethodID/jfieldID to Java Method/Field object
+MRT_EXPORT jfieldID  MRT_ReflectFromReflectedField(jobject fieldObj);
+MRT_EXPORT jobject   MRT_ReflectToReflectedField(jclass clazz, jfieldID fid);
+MRT_EXPORT jmethodID MRT_ReflectFromReflectedMethod(jobject jobj);
+MRT_EXPORT jobject   MRT_ReflectToReflectedMethod(jclass clazz, jmethodID mid);
+
+MRT_EXPORT jclass   MRT_ReflectClassForCharName(const char *className, bool init,
+                                                jobject ClassLoader, bool internalName = false);
+MRT_EXPORT jclass   MRT_ReflectGetObjectClass(jobject jobj);
+MRT_EXPORT jobject  MRT_ReflectGetClassLoader(jobject jobj);
+MRT_EXPORT jint     MRT_ReflectGetArrayIndexScaleForComponentType(jclass componentClassObj);
+
+MRT_EXPORT bool         MRT_ClassSetGctib(jclass classObj, char *newBuffer, jint offset);
+MRT_EXPORT uint32_t     MRT_GetFieldOffset(jfieldID field);
+MRT_EXPORT jboolean     MRT_ReflectClassIsArray(jclass classObj);
+MRT_EXPORT jboolean     MRT_ReflectClassIsPrimitive(jclass classObj);
+MRT_EXPORT jboolean     MRT_ReflectIsString(const jclass classObj);
+MRT_EXPORT jboolean     MRT_ReflectIsClass(const jobject classObj);
+MRT_EXPORT jboolean     MRT_ReflectClassIsInterface(jclass classObj);
+MRT_EXPORT jboolean     MRT_ReflectIsInit(jclass classObj);
+MRT_EXPORT jboolean     MRT_ReflectInitialized(jclass classObj);
+MRT_EXPORT jclass       MRT_ReflectClassGetSuperClass(jclass clazz);
+MRT_EXPORT jboolean     MRT_ReflectIsInstanceOf(jobject jobj, jclass javaClass);
+MRT_EXPORT jboolean     MRT_ReflectClassIsAssignableFrom(jclass superClass, jclass subClass);
+MRT_EXPORT uint32_t     MRT_ReflectClassGetNumofFields(jclass cls);
+MRT_EXPORT jclass       MRT_ReflectClassGetComponentType(jclass classObj);
+MRT_EXPORT jint         MRT_ReflectClassGetAccessFlags(jclass classObj);
+MRT_EXPORT jobject      MRT_ReflectClassGetDeclaredMethods(jclass classObj, jboolean publicOnly);
+MRT_EXPORT jobjectArray MRT_ReflectClassGetInterfaces(jclass classObj);
+MRT_EXPORT jint         MRT_ReflectClassGetModifiers(jclass classObj);
+MRT_EXPORT jobject      MRT_ReflectClassGetDeclaredFields(jclass classObj, jboolean publicOnly);
+MRT_EXPORT jobject      MRT_ReflectClassGetDeclaredAnnotations(jclass classObj);
+MRT_EXPORT jobjectArray MRT_ReflectClassGetDeclaredClasses(jclass classObj);
+MRT_EXPORT jclass       MRT_ReflectClassGetDeclaringClass(jclass classObj);
+MRT_EXPORT jobject      MRT_ReflectClassGetDeclaredConstructors(jclass classObj, jboolean publicOnly);
+
+MRT_EXPORT bool     MRT_IsMetaObject(jobject jobj);
+MRT_EXPORT bool     MRT_IsValidMethod(jmethodID jmid);
+MRT_EXPORT bool     MRT_IsValidField(jfieldID jfid);
+MRT_EXPORT bool     MRT_IsValidClass(jclass jclazz);
+
+MRT_EXPORT jobject  MRT_ReflectAllocObject(const jclass javaClass, bool isJNI = false);
+MRT_EXPORT jobject  MRT_ReflectNewObjectA(const jclass javaClass, const jmethodID mid,
+                                          const jvalue *args, bool isJNI = false);
+
+MRT_EXPORT jfieldID MRT_ReflectClassGetFieldsPtr(jclass classObj);
+MRT_EXPORT jfieldID MRT_ReflectClassGetIndexField(jfieldID head, int i);
+
+MRT_EXPORT jfieldID MRT_ReflectGetCharField(jclass classObj, const char *fieldName, const char *fieldType = nullptr);
+MRT_EXPORT jfieldID MRT_ReflectGetStaticCharField(jclass classObj, const char *fieldName);
+MRT_EXPORT jclass   MRT_ReflectFieldGetDeclaringClass(jfieldID fieldMeta);
+MRT_EXPORT jboolean MRT_ReflectFieldIsStatic(jfieldID fieldObj);
+MRT_EXPORT char    *MRT_ReflectFieldGetCharFieldName(jfieldID obj);
+MRT_EXPORT char    *MRT_ReflectFieldGetTypeName(jfieldID fieldMeta);
+MRT_EXPORT jclass   MRT_ReflectFieldGetType(jfieldID fieldMeta);
+MRT_EXPORT jint     MRT_ReflectFieldGetOffset(jobject fieldMeta);
+
+MRT_EXPORT jboolean MRT_ReflectGetFieldjboolean(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jbyte    MRT_ReflectGetFieldjbyte(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jchar    MRT_ReflectGetFieldjchar(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jdouble  MRT_ReflectGetFieldjdouble(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jfloat   MRT_ReflectGetFieldjfloat(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jint     MRT_ReflectGetFieldjint(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jlong    MRT_ReflectGetFieldjlong(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jshort   MRT_ReflectGetFieldjshort(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jobject  MRT_ReflectGetFieldjobject(jfieldID fieldObj, jobject obj);
+
+MRT_EXPORT void MRT_ReflectSetFieldjboolean(jfieldID fieldObj, jobject obj, jboolean value);
+MRT_EXPORT void MRT_ReflectSetFieldjbyte(jfieldID fieldObj, jobject obj, jbyte value);
+MRT_EXPORT void MRT_ReflectSetFieldjchar(jfieldID fieldObj, jobject obj, jchar value);
+MRT_EXPORT void MRT_ReflectSetFieldjshort(jfieldID fieldObj, jobject obj, jshort value);
+MRT_EXPORT void MRT_ReflectSetFieldjint(jfieldID fieldObj, jobject obj, jint value);
+MRT_EXPORT void MRT_ReflectSetFieldjfloat(jfieldID fieldObj, jobject obj, jfloat value);
+MRT_EXPORT void MRT_ReflectSetFieldjlong(jfieldID fieldObj, jobject obj, jlong value);
+MRT_EXPORT void MRT_ReflectSetFieldjdouble(jfieldID fieldObj, jobject obj, jdouble value);
+MRT_EXPORT void MRT_ReflectSetFieldjobject(jfieldID fieldObj, jobject obj, jobject value);
+
+// function for dump heap
+MRT_EXPORT jboolean MRT_ReflectGetFieldjbooleanUnsafe(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jbyte    MRT_ReflectGetFieldjbyteUnsafe(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jchar    MRT_ReflectGetFieldjcharUnsafe(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jdouble  MRT_ReflectGetFieldjdoubleUnsafe(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jfloat   MRT_ReflectGetFieldjfloatUnsafe(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jint     MRT_ReflectGetFieldjintUnsafe(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jlong    MRT_ReflectGetFieldjlongUnsafe(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jshort   MRT_ReflectGetFieldjshortUnsafe(jfieldID fieldObj, jobject obj);
+MRT_EXPORT jobject  MRT_ReflectGetFieldjobjectUnsafe(jfieldID fieldObj, jobject obj);
+
+MRT_EXPORT jmethodID    MRT_ReflectGetCharMethod(jclass classObj, const char *methodName, const char *signatureName);
+MRT_EXPORT jmethodID    MRT_ReflectGetStaticCharMethod(jclass classObj, const char *methodName,
+                                                       const char *signatureName);
+MRT_EXPORT jmethodID    MRT_ReflectGetMethodFromMethodID(jclass clazz, jmethodID methodID, const char *signature);
+MRT_EXPORT char        *MRT_ReflectGetMethodName(jmethodID mid);
+MRT_EXPORT jint         MRT_ReflectGetMethodArgsize(jmethodID mid);
+MRT_EXPORT void         MRT_ReflectGetMethodArgsType(const char *signame, const jint argsize, char *shorty);
+MRT_EXPORT char        *MRT_ReflectGetMethodSig(jmethodID mid);
+MRT_EXPORT jclass       MRT_ReflectMethodGetDeclaringClass(jmethodID methodId);
+MRT_EXPORT jboolean     MRT_ReflectMethodIsStatic(jmethodID methodMeta);
+MRT_EXPORT jboolean     MRT_ReflectMethodIsConstructor(jmethodID methodMeta);
+MRT_EXPORT jobjectArray MRT_ReflectMethodGetExceptionTypes(jobject methodObj);
+MRT_EXPORT jobject      MRT_ReflectMethodGetDefaultValue(jobject methodObj);
+MRT_EXPORT jobject      MRT_ReflectMethodGetAnnotationNative(jobject executable, jint index, jclass annoClass);
+MRT_EXPORT void         MRT_ReflectMethodForward(jobject from, jobject to);
+MRT_EXPORT jmethodID    MRT_ReflectMethodClone(jmethodID methodObj);
+
+#ifndef TYIPLE_MRT_REFLECT_INVOKE_DECL
+#define TYIPLE_MRT_REFLECT_INVOKE_DECL(TYPE) \
+MRT_EXPORT TYPE MRT_ReflectInvokeMethodA##TYPE(jobject obj, const jmethodID mid, const jvalue *args); \
+MRT_EXPORT TYPE MRT_ReflectInvokeMethodAZ##TYPE(jobject obj, const jmethodID mid, const jvalue *args, \
+                                                uintptr_t calleeFuncAddr);
+#endif
+
+// invoke a slow method
+TYIPLE_MRT_REFLECT_INVOKE_DECL(void)
+TYIPLE_MRT_REFLECT_INVOKE_DECL(jboolean)
+TYIPLE_MRT_REFLECT_INVOKE_DECL(jbyte)
+TYIPLE_MRT_REFLECT_INVOKE_DECL(jchar)
+TYIPLE_MRT_REFLECT_INVOKE_DECL(jdouble)
+TYIPLE_MRT_REFLECT_INVOKE_DECL(jfloat)
+TYIPLE_MRT_REFLECT_INVOKE_DECL(jint)
+TYIPLE_MRT_REFLECT_INVOKE_DECL(jlong)
+TYIPLE_MRT_REFLECT_INVOKE_DECL(jobject)
+TYIPLE_MRT_REFLECT_INVOKE_DECL(jshort)
+
+// proxy interface api
+MRT_EXPORT jclass MRT_ReflectProxyGenerateProxy(jstring name, jobjectArray interfaces, jobject loader,
+                                                jobjectArray methods, jobjectArray throws);
+MRT_EXPORT jobject MRT_ReflectConstructorNewInstance0(jobject javaMethod, jobjectArray javaArgs);
+MRT_EXPORT jobject MRT_ReflectConstructorNewInstanceFromSerialization(jclass ctorClass, const jclass allocClass);
+// Executable interface api
+MRT_EXPORT jobject      MRT_ReflectExecutableGetSignatureAnnotation(jobject methodObj);
+MRT_EXPORT jobject      MRT_ReflectExecutableGetParameterAnnotationsNative(jobject method);
+MRT_EXPORT jboolean     MRT_ReflectExecutableIsAnnotationPresentNative(jobject methodObj, jclass annoObj);
+MRT_EXPORT jint         MRT_ReflectExecutableCompareMethodParametersInternal(jobject obj1, jobject obj2);
+MRT_EXPORT jobjectArray MRT_ReflectExecutableGetDeclaredAnnotationsNative(jobject methodObj);
+MRT_EXPORT jobject      MRT_ReflectExecutableGetAnnotationNative(jobject methodObj, jclass annoClass);
+MRT_EXPORT jobject      MRT_ReflectExecutableGetParameters0(jobject thisObj);
+MRT_EXPORT jobjectArray MRT_ReflectExecutableGetParameterTypesInternal(jobject methodObj);
+MRT_EXPORT jint         MRT_ReflectExecutableGetParameterCountInternal(jobject methodObj);
+MRT_EXPORT jclass       MRT_ReflectExecutableGetMethodReturnTypeInternal(jobject methodObj);
+MRT_EXPORT jstring      MRT_ReflectExecutableGetMethodNameInternal(jobject methodObj);
+// MethodHandleImpl interface api
+MRT_EXPORT jobject MRT_MethodHandleImplGetMemberInternal(jobject methodHandle);
+// openjdk
+MRT_EXPORT jclass MRT_ReflectGetOrCreateArrayClassObj(jclass elementClass);
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+
+#endif // MAPLE_MRT_REFLECTION_API_H
diff --git a/src/mrt/maplert/public-headers/mrt_string_api.h b/src/mrt/maplert/public-headers/mrt_string_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a09731cd60d00252f5e6b63c5d4bc4f7658dcb0
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_string_api.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_LIB_CORE_MPL_STRING_H_
+#define MAPLE_LIB_CORE_MPL_STRING_H_
+
+#include <functional>
+#include "mrt_api_common.h"
+#include "jni.h"
+
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+MRT_EXPORT jint MRT_StringGetStringLength(jstring jstr);
+MRT_EXPORT void MRT_ScanLiteralPoolRoots(std::function<void(uintptr_t)> visitRoot);
+MRT_EXPORT void MRT_ReleaseStringUTFChars(jstring jstr, const char *chars);
+MRT_EXPORT void MRT_ReleaseStringChars(jstring jstr, const jchar *chars);
+MRT_EXPORT jstring MRT_NewHeapJStr(const jchar *ca, jint len, bool isJNI = false);
+MRT_EXPORT bool MRT_IsStrCompressed(const jstring jstr);
+MRT_EXPORT char *MRT_GetStringContentsPtrRaw(jstring jstr);
+MRT_EXPORT jchar *MRT_GetStringContentsPtrCopy(jstring jstr, jboolean *isCopy);
+MRT_EXPORT size_t MRT_GetStringObjectSize(jstring jstr);
+// only for MUTF-8 string JNI
+MRT_EXPORT jstring MRT_NewStringMUTF(const char *inMutf, size_t inMutfLen, bool isJNI = false);
+MRT_EXPORT jsize MRT_GetStringMUTFLength(jstring jstr);
+MRT_EXPORT char *MRT_GetStringMUTFChars(jstring jstr, jboolean *isCopy);
+MRT_EXPORT void MRT_GetStringMUTFRegion(jstring jstr, jsize start, jsize length, char *buf);
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+
+#endif // MAPLE_LIB_CORE_MPL_STRING_H_
diff --git a/src/mrt/maplert/public-headers/mrt_thread_api.h b/src/mrt/maplert/public-headers/mrt_thread_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..c841273bf6bc6edac92df3b0b09aef647b97b01b
--- /dev/null
+++ b/src/mrt/maplert/public-headers/mrt_thread_api.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_MRT_CLINIT_H_
+#define MAPLE_MRT_CLINIT_H_
+
+#include "mrt_api_common.h"
+#ifdef __cplusplus
+namespace maplert {
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace maplert
+#endif
+
+#endif //MAPLE_MRT_CLINIT_H_
diff --git a/src/mrt/maplert/src/deferredaccess.cpp b/src/mrt/maplert/src/deferredaccess.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a40a80a74a671e076aa61d67047416142bc5a136
--- /dev/null
+++ b/src/mrt/maplert/src/deferredaccess.cpp
@@ -0,0 +1,470 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "deferredaccess.h"
+#include "fieldmeta_inline.h"
+#include "exception/mrt_exception.h"
+
+namespace maplert {
+using namespace deferredaccess;
+// implement MCC interface function
+extern "C" {
+MClass *MCC_DeferredConstClass(address_t daiClass, const MObject *caller, const MString *className) {
+  deferredaccess::DaiClass *dclass = reinterpret_cast<deferredaccess::DaiClass*>(daiClass);
+  if (dclass != nullptr && dclass->daiClass != nullptr) {
+    return dclass->daiClass;
+  }
+
+  if (className == nullptr) {
+    MRT_ThrowNullPointerExceptionUnw();
+    return nullptr;
+  }
+  std::string descriptor = className->GetChars();
+  MClass *classObject = deferredaccess::GetConstClass(*caller, descriptor.c_str());
+  if (classObject != nullptr) {
+    if (dclass != nullptr) {
+      dclass->daiClass = classObject;
+    }
+    return classObject;
+  }
+  MRT_CheckThrowPendingExceptionUnw();
+  return nullptr;
+}
+
+void MCC_DeferredClinitCheck(address_t daiClass, const MObject *caller, const MString *className) {
+  MClass *classObject = MCC_DeferredConstClass(daiClass, caller, className);
+  DCHECK(classObject != nullptr) << "MCC_DeferredClinitCheck: classObject is nullptr!" << maple::endl;
+  deferredaccess::ClinitCheck(*classObject);
+}
+
+bool MCC_DeferredInstanceOf(address_t daiClass, const MObject *caller, const MString *className, const MObject *obj) {
+  if (obj == nullptr) {
+    return false;
+  }
+  MClass *classObject = MCC_DeferredConstClass(daiClass, caller, className);
+  DCHECK(classObject != nullptr) << "MCC_DeferredInstanceOf: classObject is nullptr!" << maple::endl;
+  bool res = deferredaccess::IsInstanceOf(*classObject, *obj);
+  return res;
+}
+
+MObject *MCC_DeferredCheckCast(address_t daiClass, const MObject *caller, const MString *className, MObject *obj) {
+  MClass *classObject = MCC_DeferredConstClass(daiClass, caller, className);
+  DCHECK(classObject != nullptr) << "MCC_DeferredCheckCast: classObject is nullptr!" << maple::endl;
+  if (obj == nullptr) {
+    return obj;
+  }
+  if (classObject == nullptr) {
+    return nullptr;
+  }
+  bool res = deferredaccess::IsInstanceOf(*classObject, *obj);
+  if (res) {
+    RC_LOCAL_INC_REF(obj);
+    return obj;
+  }
+
+  {
+    // Cast Fail, ThrowClassCastException
+    MClass *targerObjClass = obj->GetClass();
+    std::string sourceName;
+    std::string targerName;
+    classObject->GetBinaryName(sourceName);
+    targerObjClass->GetBinaryName(targerName);
+    std::ostringstream msg;
+    msg << targerName << " cannot be cast to " << sourceName;
+    MRT_ThrowNewException("java/lang/ClassCastException", msg.str().c_str());
+  }
+  MRT_CheckThrowPendingExceptionUnw();
+  return nullptr;
+}
+
+MObject *MCC_DeferredNewInstance(address_t daiClass, const MObject *caller, const MString *className) {
+  MClass *classObject = MCC_DeferredConstClass(daiClass, caller, className);
+  if (classObject == nullptr) {
+    return nullptr;
+  }
+  MObject *object = deferredaccess::NewInstance(*classObject);
+  return object;
+}
+
+MObject *MCC_DeferredNewArray(address_t daiClass, const MObject *caller,
+                              const MString *arrayTypeName, uint32_t length) {
+  MClass *classObject = MCC_DeferredConstClass(daiClass, caller, arrayTypeName);
+  if (classObject == nullptr) {
+    return nullptr;
+  }
+  MArray *arrayObject = deferredaccess::NewArray(*classObject, length);
+  return arrayObject;
+}
+
+MObject *MCC_DeferredFillNewArray(address_t daiClass, const MObject *caller, const MString *arrayTypeName,
+                                  uint32_t length, ...) {
+  MClass *classObject = MCC_DeferredConstClass(daiClass, caller, arrayTypeName);
+  if (classObject == nullptr) {
+    return nullptr;
+  }
+  va_list args;
+  va_start(args, length);
+  MArray *arrayObject = deferredaccess::NewArray(*classObject, length, args);
+  va_end(args);
+  return arrayObject;
+}
+
+jvalue MCC_DeferredLoadField(address_t daiField, MObject *caller, const MString *className,
+                             const MString *fieldName, const MString *fieldTypeName, const MObject *obj) {
+  DCHECK(caller != 0);
+  DCHECK(fieldName != 0);
+  DCHECK(fieldTypeName != 0);
+  jvalue result;
+  result.l = 0UL;
+  MClass *classObject = MCC_DeferredConstClass(0, caller, className);
+  if (classObject == nullptr) {
+    return result;
+  }
+  deferredaccess::DaiField *dField = reinterpret_cast<deferredaccess::DaiField*>(daiField);
+  FieldMeta *fieldMeta = nullptr;
+  if (dField == nullptr || dField->fieldMeta == nullptr) {
+    fieldMeta = deferredaccess::InitDaiField(dField, *classObject, *fieldName, *fieldTypeName);
+    if (UNLIKELY(MRT_HasPendingException())) {
+      MRT_CheckThrowPendingExceptionUnw();
+      return result;
+    }
+  } else {
+    fieldMeta = dField->fieldMeta;
+  }
+
+  CHECK(fieldMeta != nullptr) << "fieldMeta is nullptr!";
+  if (!deferredaccess::CheckFieldAccess(*caller, *fieldMeta, obj)) {
+    MRT_CheckThrowPendingExceptionUnw();
+    return result;
+  }
+
+  result = deferredaccess::LoadField(*fieldMeta, obj);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    MRT_CheckThrowPendingExceptionUnw();
+  }
+  return result;
+}
+
+void MCC_DeferredStoreField(address_t daiField, MObject *caller, const MString *className,
+                            const MString *fieldName, const MString *fieldTypeName, MObject *obj, jvalue value) {
+  MClass *classObject = MCC_DeferredConstClass(0, caller, className);
+  if (classObject == nullptr) {
+    return;
+  }
+  DCHECK(caller != nullptr);
+  DCHECK(fieldName != nullptr);
+  DCHECK(fieldTypeName != nullptr);
+  deferredaccess::DaiField *dField = reinterpret_cast<deferredaccess::DaiField*>(daiField);
+  FieldMeta *fieldMeta = nullptr;
+  if (dField == nullptr || dField->fieldMeta == nullptr) {
+    fieldMeta = deferredaccess::InitDaiField(dField, *classObject, *fieldName, *fieldTypeName);
+    if (UNLIKELY(MRT_HasPendingException())) {
+      MRT_CheckThrowPendingExceptionUnw();
+      return;
+    }
+  } else {
+    fieldMeta = dField->fieldMeta;
+  }
+
+  CHECK(fieldMeta != nullptr) << "fieldMeta is nullptr!";
+  if (!deferredaccess::CheckFieldAccess(*caller, *fieldMeta, obj)) {
+    MRT_CheckThrowPendingExceptionUnw();
+    return;
+  }
+
+  deferredaccess::StoreField(*fieldMeta, obj, value);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    MRT_CheckThrowPendingExceptionUnw();
+  }
+}
+
+// compiler invoke MCC_DeferredInvoke, args order:
+// (address_t daiMethod, int32_t kind, const char *className, const char *methodName,
+//  const char *signature, MObject *obj, ...) {
+extern "C" int64_t EnterDeferredInvoke(intptr_t *stack) {
+  CHECK(stack != nullptr);
+  deferredaccess::DaiMethod *dMethod = reinterpret_cast<deferredaccess::DaiMethod*>(stack[kDaiMethod]);
+  deferredaccess::DeferredInvokeType invokeType = static_cast<deferredaccess::DeferredInvokeType>(stack[kInvokeType]);
+  const char *className = reinterpret_cast<char*>(stack[kClassName]);
+  const char *methodName = reinterpret_cast<char*>(stack[kMethodName]);
+  const char *signature = reinterpret_cast<char*>(stack[kSignature]);
+  MObject *obj = reinterpret_cast<MObject*>(stack[kThisObj]);
+  jvalue result;
+  result.l = 0UL;
+  if (UNLIKELY(obj == nullptr)) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "Attempt to invoke method on a null object reference");
+    return result.j;
+  }
+
+  MethodMeta *methodMeta = nullptr;
+  if (dMethod == nullptr || dMethod->methodMeta == nullptr) {
+    MClass *classObject = deferredaccess::GetConstClass(*obj, className);
+    if (classObject == nullptr) {
+      MRT_CheckThrowPendingExceptionUnw();
+      return result.j;
+    }
+    methodMeta = deferredaccess::InitDaiMethod(invokeType, dMethod, *classObject, methodName, signature);
+    if (UNLIKELY(MRT_HasPendingException())) {
+      MRT_CheckThrowPendingExceptionUnw();
+      return result.j;
+    }
+  } else {
+    methodMeta = dMethod->methodMeta;
+  }
+  {
+    DecodeStackArgs stackArgs(stack);
+    std::string prefix("IIIIIL");
+    methodMeta->BuildJValuesArgsFromStackMemeryPrefixSigNature(stackArgs, prefix);
+    result = deferredaccess::Invoke(invokeType, methodMeta, obj, &(stackArgs.GetData()[prefix.length()]));
+  }
+  if (UNLIKELY(MRT_HasPendingException())) {
+    MRT_CheckThrowPendingExceptionUnw();
+  }
+  return result.j;
+}
+} // extern "C"
+
+// implement deferredaccess functions
+MClass *deferredaccess::GetConstClass(const MObject &caller, const char *descriptor) {
+  MClass *classObject = MClass::GetClassFromDescriptor(&caller, descriptor);
+  return classObject;
+}
+
+void deferredaccess::ClinitCheck(const MClass &classObject) {
+  if (!classObject.InitClassIfNeeded()) {
+    // exception
+    MRT_CheckThrowPendingExceptionUnw();
+  }
+}
+
+bool deferredaccess::IsInstanceOf(const MClass &classObject, const MObject &obj) {
+  return obj.IsInstanceOf(classObject);
+}
+
+MObject *deferredaccess::NewInstance(const MClass &classObject) {
+  MObject *o = MObject::NewObject(classObject);
+  return o;
+}
+
+MArray *deferredaccess::NewArray(const MClass &classObject, uint32_t length) {
+  MClass *componentClass = classObject.GetComponentClass();
+  DCHECK(componentClass != nullptr) << "deferredaccess::NewArray: componentClass is nullptr!" << maple::endl;
+  bool isPrimitive = componentClass->IsPrimitiveClass();
+  CHECK(isPrimitive == false) << " always New Object Array, but get " <<
+      classObject.GetName() << maple::endl;
+  MArray *arrayObj = MArray::NewObjectArrayComponentClass(length, *componentClass);
+  return arrayObj;
+}
+
+MArray *deferredaccess::NewArray(const MClass &classObject, uint32_t length, va_list initialElement) {
+  MArray *mArrayObj = NewArray(classObject, length);
+  CHECK(mArrayObj->IsObjectArray()) << " always ObjectArray, but get " <<
+      classObject.GetName() << maple::endl;
+  for (uint32_t i = 0; i < length; ++i) {
+    MObject *value = reinterpret_cast<MObject*>(va_arg(initialElement, jobject));
+    mArrayObj->SetObjectElement(i, value);
+  }
+  return mArrayObj;
+}
+
+jvalue deferredaccess::LoadField(const FieldMeta &fieldMeta, const MObject *obj) {
+  jvalue result;
+  result.l = 0UL;
+  if (!fieldMeta.IsStatic() && obj == nullptr) {
+    std::string msg = "Attempt to read from field ";
+    std::string fieldFullName = fieldMeta.GetFullName(fieldMeta.GetDeclaringclass(), true);
+    msg += "'" + fieldFullName + "' " + "on a null object reference";
+    MRT_ThrowNewException("java/lang/NullPointerException", msg.c_str());
+    return result;
+  }
+  const char *fieldMetaTypeName = fieldMeta.GetTypeName();
+  DCHECK(fieldMetaTypeName != nullptr) << "fieldMetaTypeName cannot be nullptr." << maple::endl;
+  char srcType = fieldMetaTypeName[0];
+  switch (srcType) {
+    case 'Z':
+      result.z = fieldMeta.GetPrimitiveValue<uint8_t>(obj, srcType);
+      break;
+    case 'B':
+      result.b = fieldMeta.GetPrimitiveValue<int8_t>(obj, srcType);
+      break;
+    case 'C':
+      result.c = fieldMeta.GetPrimitiveValue<uint16_t>(obj, srcType);
+      break;
+    case 'S':
+      result.s = fieldMeta.GetPrimitiveValue<int16_t>(obj, srcType);
+      break;
+    case 'I':
+      result.i = fieldMeta.GetPrimitiveValue<int32_t>(obj, srcType);
+      break;
+    case 'J':
+      result.j = fieldMeta.GetPrimitiveValue<int64_t>(obj, srcType);
+      break;
+    case 'F':
+      result.f = fieldMeta.GetPrimitiveValue<float>(obj, srcType);
+      break;
+    case 'D':
+      result.d = fieldMeta.GetPrimitiveValue<double>(obj, srcType);
+      break;
+    default:
+      result.l = reinterpret_cast<jobject>(fieldMeta.GetObjectValue(obj));
+  }
+  return result;
+}
+
+void deferredaccess::StoreField(const FieldMeta &fieldMeta, MObject *obj, jvalue value) {
+  if (!fieldMeta.IsStatic() && obj == nullptr) {
+    std::string msg = "Attempt to write to field ";
+    std::string fieldFullName = fieldMeta.GetFullName(fieldMeta.GetDeclaringclass(), true);
+    msg += "'" + fieldFullName + "' " + "on a null object reference";
+    MRT_ThrowNewException("java/lang/NullPointerException", msg.c_str());
+    return;
+  }
+  const char *fieldMetaTypeName = fieldMeta.GetTypeName();
+  DCHECK(fieldMetaTypeName != nullptr) << "fieldMetaTypeName cannot be nullptr." << maple::endl;
+  DCHECK(obj != nullptr) << "obj cannot be nullptr." << maple::endl;
+  char srcType = fieldMetaTypeName[0];
+  switch (srcType) {
+    case 'Z':
+      fieldMeta.SetPrimitiveValue<uint8_t>(obj, srcType, value.z);
+      break;
+    case 'B':
+      fieldMeta.SetPrimitiveValue<int8_t>(obj, srcType, value.b);
+      break;
+    case 'C':
+      fieldMeta.SetPrimitiveValue<uint16_t>(obj, srcType, value.c);
+      break;
+    case 'S':
+      fieldMeta.SetPrimitiveValue<int16_t>(obj, srcType, value.s);
+      break;
+    case 'I':
+      fieldMeta.SetPrimitiveValue<int32_t>(obj, srcType, value.i);
+      break;
+    case 'J':
+      fieldMeta.SetPrimitiveValue<int64_t>(obj, srcType, value.j);
+      break;
+    case 'F':
+      fieldMeta.SetPrimitiveValue<float>(obj, srcType, value.f);
+      break;
+    case 'D':
+      fieldMeta.SetPrimitiveValue<double>(obj, srcType, value.d);
+      break;
+    default:
+      fieldMeta.SetObjectValue(obj, reinterpret_cast<MObject*>(value.l));
+  }
+}
+
+FieldMeta *deferredaccess::InitDaiField(DaiField *daiField, const MClass &classObject,
+                                        const MString &fieldName, const MString &fieldTypeName) {
+  std::string fName = fieldName.GetChars();
+  std::string tName = fieldTypeName.GetChars();
+  FieldMeta *fieldMeta = classObject.GetField(fName.c_str(), tName.c_str());
+  if (UNLIKELY(fieldMeta == nullptr)) {
+    std::string msg = "No field ";
+    msg += fName + std::string(" of type ") + tName +
+        " in class " + classObject.GetName() + " or its superclasses";
+    MRT_ThrowNewException("java/lang/NoSuchFieldError", msg.c_str());
+  } else {
+    if (daiField != nullptr) {
+      daiField->fieldMeta = fieldMeta;
+    }
+  }
+  return fieldMeta;
+}
+
+MethodMeta *deferredaccess::InitDaiMethod(DeferredInvokeType invokeType, DaiMethod *daiMethod, const MClass &classObj,
+                                          const char *methodName, const char *signatureName) {
+  MethodMeta *methodMeta = nullptr;
+  if (invokeType == kDirectCall) {
+    methodMeta = classObj.GetDeclaredMethod(methodName, signatureName);
+  } else {
+    // invokeType: kVirtualCall, kInterfaceCall, kSuperCall, kStaticCall
+    methodMeta = classObj.GetMethod(methodName, signatureName);
+  }
+
+  if (UNLIKELY(methodMeta == nullptr)) {
+    std::string msg = "No method ";
+    msg += methodName + std::string(signatureName) + " in class " + classObj.GetName() + " or its superclasses";
+    MRT_ThrowNewException("java/lang/NoSuchMethodError", msg.c_str());
+  } else {
+    if (daiMethod != nullptr) {
+      daiMethod->methodMeta = methodMeta;
+    }
+  }
+  return methodMeta;
+}
+
+jvalue deferredaccess::Invoke(DeferredInvokeType invokeType, const MethodMeta *methodMeta, MObject *obj,
+                              jvalue args[]) {
+  jvalue result;
+  result.l = 0UL;
+  DCHECK(obj != nullptr) << "deferredaccess::Invoke: obj is nullptr!" << maple::endl;
+  CHECK(methodMeta != nullptr) << "deferredaccess::Invoke: methodMeta must not be nullptr!" << maple::endl;
+  if (!methodMeta->IsDirectMethod() && ((invokeType == kVirtualCall) || (invokeType == kInterfaceCall))) {
+    methodMeta = obj->GetClass()->GetMethod(methodMeta->GetName(), methodMeta->GetSignature());
+  }
+  CHECK(methodMeta != nullptr) << "deferredaccess::Invoke: can not find method: " <<
+      obj->GetClass()->GetName() << maple::endl;
+  char *retTypeName = methodMeta->GetReturnTypeName();
+  DCHECK(retTypeName != nullptr) << "deferredaccess::retTypeName is nullptr!" << maple::endl;
+  char retType = retTypeName[0];
+  switch (retType) {
+    case 'Z':
+      result.z = methodMeta->Invoke<uint8_t, calljavastubconst::kJvalue>(obj, args);
+      break;
+    case 'B':
+      result.b = methodMeta->Invoke<int8_t, calljavastubconst::kJvalue>(obj, args);
+      break;
+    case 'C':
+      result.c = methodMeta->Invoke<uint16_t, calljavastubconst::kJvalue>(obj, args);
+      break;
+    case 'S':
+      result.s = methodMeta->Invoke<int16_t, calljavastubconst::kJvalue>(obj, args);
+      break;
+    case 'I':
+      result.i = methodMeta->Invoke<int32_t, calljavastubconst::kJvalue>(obj, args);
+      break;
+    case 'J':
+      result.j = methodMeta->Invoke<int64_t, calljavastubconst::kJvalue>(obj, args);
+      break;
+    case 'F':
+      result.f = methodMeta->Invoke<float, calljavastubconst::kJvalue>(obj, args);
+      break;
+    case 'D':
+      result.d = methodMeta->Invoke<double, calljavastubconst::kJvalue>(obj, args);
+      break;
+    default:
+      result.l = methodMeta->Invoke<jobject, calljavastubconst::kJvalue>(obj, args);
+  }
+  return result;
+}
+
+bool deferredaccess::CheckFieldAccess(MObject &caller, const FieldMeta &fieldMeta, const MObject *obj) {
+  uint32_t modifier = fieldMeta.GetMod();
+  MClass *declaringClass = fieldMeta.GetDeclaringclass();
+  obj = fieldMeta.IsStatic() ? declaringClass : obj;
+  MClass *callerClass =
+      caller.GetClass() == WellKnown::GetMClassClass() ? static_cast<MClass*>(&caller) : caller.GetClass();
+  if (!reflection::VerifyAccess(obj, declaringClass, modifier, callerClass, 0)) {
+    std::string callerStr, declearClassStr;
+    callerClass->GetTypeName(callerStr);
+    declaringClass->GetTypeName(declearClassStr);
+    std::ostringstream msg;
+    msg << "Field '" << declearClassStr << "." << fieldMeta.GetName() <<
+        "' is inaccessible to class '" << callerStr <<"'";
+    MRT_ThrowNewException("java/lang/IllegalAccessError", msg.str().c_str());
+    return false;
+  }
+  return true;
+}
+}
diff --git a/src/mrt/maplert/src/fieldmeta.cpp b/src/mrt/maplert/src/fieldmeta.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dd46bd355ecf211b6a7d9c0f519aefba45a398d7
--- /dev/null
+++ b/src/mrt/maplert/src/fieldmeta.cpp
@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fieldmeta.h"
+#include "mclass_inline.h"
+#include "fieldmeta_inline.h"
+#include "namemangler.h"
+namespace maplert {
+std::mutex FieldMetaCompact::resolveMutex;
+void FieldMetaCompact::SetCompactFieldMetaOffset(const MClass &cls, uint32_t index, int32_t fieldOffset) {
+  FieldMetaCompact *leb = cls.GetCompactFields();
+  uint32_t numOfField = cls.GetNumOfFields();
+  for (uint32_t i = 0; i < numOfField; ++i) {
+    if (i == index) {
+      leb->SetBitOffset(static_cast<uint32_t>(fieldOffset));
+      return;
+    }
+    const uint8_t *pLeb = leb->GetpCompact();
+    (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+    (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+    (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+    (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+    leb = reinterpret_cast<FieldMetaCompact*>(const_cast<uint8_t*>(pLeb));
+  }
+  LOG(FATAL) << "FieldMetaCompact::GetCompactFieldMetasOffsetAddr: " << cls.GetName() <<
+      ", index:" << index << maple::endl;
+}
+
+FieldMetaCompact *FieldMetaCompact::DecodeCompactFieldMetasToVector(
+    const MClass &cls, uint32_t vecSize, char **typeNameVec, char **fieldNameVec, size_t *offsetVec,
+    uint32_t *modifierVec, FieldMetaCompact **fieldMetaCompact, char **annotationVec) {
+  uint32_t numOfField = cls.GetNumOfFields();
+  if (numOfField == 0 || numOfField > vecSize) {
+    return nullptr;
+  }
+  FieldMetaCompact *leb = cls.GetCompactFields();
+  for (uint32_t i = 0; i < numOfField; ++i) {
+    if (fieldMetaCompact != nullptr) {
+      fieldMetaCompact[i] = leb;
+    }
+    const uint8_t *pLeb = leb->GetpCompact();
+    uint32_t modifier = namemangler::GetUnsignedLeb128Decode(&pLeb);
+    uintptr_t offset = leb->GetOffsetOrAddress(modifier::IsStatic(modifier));
+    if (offsetVec != nullptr) {
+      offsetVec[i] = offset;
+    }
+
+    if (modifierVec != nullptr) {
+      modifierVec[i] = modifier;
+    }
+    uint32_t typeNameIndex = namemangler::GetUnsignedLeb128Decode(&pLeb);
+    char *typeName = LinkerAPI::Instance().GetCString(cls.AsJclass(), typeNameIndex);
+    if (typeNameVec != nullptr) {
+      typeNameVec[i] = typeName;
+    }
+    uint32_t fieldNameIndex = namemangler::GetUnsignedLeb128Decode(&pLeb);
+    char *fieldName = LinkerAPI::Instance().GetCString(cls.AsJclass(), fieldNameIndex);
+    if (fieldNameVec != nullptr) {
+      fieldNameVec[i] = fieldName;
+    }
+    uint32_t annotationIndex = namemangler::GetUnsignedLeb128Decode(&pLeb);
+    char *annotation = LinkerAPI::Instance().GetCString(cls.AsJclass(), annotationIndex);
+    if (annotationVec != nullptr) {
+      annotationVec[i] = annotation;
+    }
+    leb = reinterpret_cast<FieldMetaCompact*>(const_cast<uint8_t*>(pLeb));
+  }
+  return cls.GetCompactFields();
+}
+
+FieldMeta *FieldMetaCompact::DecodeCompactFieldMetas(MClass &cls) {
+  uint32_t numOfField = cls.GetNumOfFields();
+  if (numOfField == 0) {
+    return nullptr;
+  }
+  CHECK(numOfField <= (std::numeric_limits<uint32_t>::max() / sizeof(FieldMeta))) <<
+      "field count too large. numOfField " << numOfField << maple::endl;
+  {
+    std::lock_guard<std::mutex> lock(resolveMutex);
+    FieldMeta *fields = cls.GetRawFieldMetas();
+    if (!cls.IsCompactMetaFields()) {
+      return fields;
+    }
+    // Compact, need resolve
+    char *typeNameVec[numOfField];
+    char *fieldNameVec[numOfField];
+    char *annotationVec[numOfField];
+    size_t offsetVec[numOfField];
+    uint32_t modifierVec[numOfField];
+    (void)DecodeCompactFieldMetasToVector(cls, numOfField, typeNameVec, fieldNameVec, offsetVec,
+                                          modifierVec, nullptr, annotationVec);
+#ifndef USE_32BIT_REF
+    for (uint32_t i = 0; i < numOfField; ++i) {
+      char *fieldNameStr = fieldNameVec[i];
+      char *annoStr = annotationVec[i];
+      size_t fieldNameStrLen = strlen(fieldNameStr) + 1;
+      size_t annoStrLen = strlen(annoStr) + 1;
+      char *strBuffer = reinterpret_cast<char*>(MRT_AllocFromMeta(fieldNameStrLen + annoStrLen, kNativeStringData));
+      char *fieldNameStrBuffer = strBuffer;
+      char *annoStrBuffer = strBuffer + fieldNameStrLen;
+      errno_t tmpResult1 = memcpy_s(fieldNameStrBuffer, fieldNameStrLen, fieldNameStr, fieldNameStrLen);
+      errno_t tmpResult2 = memcpy_s(annoStrBuffer, annoStrLen, annoStr, annoStrLen);
+      if (UNLIKELY(tmpResult1 != EOK || tmpResult2 != EOK)) {
+        LOG(FATAL) << "FieldMetaCompact::DecodeCompactFieldMetas : memcpy_s() failed" << maple::endl;
+        return nullptr;
+      }
+      fieldNameVec[i] = fieldNameStrBuffer;
+      annotationVec[i] = annoStrBuffer;
+    }
+#endif
+    size_t size = sizeof(FieldMeta) * numOfField;
+    FieldMeta *fieldMetas = FieldMeta::Cast(MRT_AllocFromMeta(size, kFieldMetaData));
+    for (uint32_t i = 0; i < numOfField; ++i) {
+      FieldMeta *newFieldMeta = fieldMetas + i;
+      newFieldMeta->FillFieldMeta(modifierVec[i], offsetVec[i], typeNameVec[i], modifier::kHashConflict,
+          static_cast<uint16_t>(i), fieldNameVec[i], annotationVec[i], cls);
+    }
+    cls.SetFields(*fieldMetas);
+    return fieldMetas;
+  }
+}
+
+uint8_t *FieldMetaCompact::GetpCompact() {
+  return &leb128Start;
+}
+
+FieldOffset *FieldMetaCompact::GetFieldpOffset() const {
+  // Compact is always ro
+  FieldOffset *fieldOffset = pOffset.GetDataRef<FieldOffset*>();
+  return fieldOffset;
+}
+
+uint32_t FieldMetaCompact::GetBitOffset() const {
+  FieldOffset *fieldOffset = GetFieldpOffset();
+  DCHECK(fieldOffset != nullptr) << "FieldMetaCompact::GetBitOffset(): fieldOffset is nullptr!" << maple::endl;
+  return fieldOffset->GetBitOffset();
+}
+
+void FieldMetaCompact::SetBitOffset(uint32_t offset) {
+  FieldOffset *fieldOffset = GetFieldpOffset();
+  fieldOffset->SetBitOffset(offset);
+}
+
+uintptr_t FieldMetaCompact::GetOffsetOrAddress(bool isStatic) const {
+  uintptr_t offsetOrAddress;
+  FieldOffset *fieldOffset = GetFieldpOffset();
+  DCHECK(fieldOffset != nullptr) << "FieldMetaCompact::GetOffsetOrAddress: fieldOffset is nullptr!" << maple::endl;
+  if (isStatic) {
+    offsetOrAddress = fieldOffset->GetAddress();
+  } else {
+    offsetOrAddress = fieldOffset->GetBitOffset();
+  }
+  return offsetOrAddress;
+}
+
+void FieldMeta::SetFieldName(const char *name) {
+  fieldName.SetDataRef(name);
+}
+
+void FieldMeta::SetAnnotation(const char *fieldAnnotation) {
+  annotation.SetDataRef(fieldAnnotation);
+}
+
+void FieldMeta::SetDeclaringClass(const MClass &dlClass) {
+  declaringClass.SetDataRef(&dlClass);
+}
+
+std::string FieldMeta::GetFullName(const MClass *dclClass, bool needType) const {
+  char *name = GetName();
+  DCHECK(name != nullptr) << "FieldMeta::GetFullName:name is nullptr" << maple::endl;
+  std::string fullName, declaringClassName;
+  if (dclClass != nullptr) {
+    dclClass->GetBinaryName(declaringClassName);
+  }
+  if (needType) {
+    std::string typeStr;
+    MClass *fieldType = GetType();
+    if (fieldType != nullptr) {
+      fieldType->GetTypeName(typeStr);
+    } else {
+      typeStr = GetTypeName();
+    }
+    fullName = typeStr + " ";
+  }
+  fullName += declaringClassName;
+  fullName += ".";
+  fullName += name;
+  return fullName;
+}
+
+MObject *FieldMeta::GetSignatureAnnotation() const {
+  std::string annotationSet = GetAnnotation();
+  if (annotationSet.empty()) {
+    return nullptr;
+  }
+  MObject *ret = AnnoParser::GetSignatureValue(annotationSet, GetDeclaringclass());
+  return ret;
+}
+
+void FieldMeta::FillFieldMeta(uint32_t modifier, size_t offset, const char *srcTypeName, uint16_t hash,
+                              uint16_t fieldIndex, const char *name, const char *strAnnotation, const MClass &cls) {
+  SetMod(modifier);
+  SetOffsetOrAddress(offset);
+  SetTypeName(srcTypeName);
+  SetHashCode(hash);
+  SetIndex(fieldIndex);
+  SetFieldName(name);
+  SetAnnotation(strAnnotation);
+  SetDeclaringClass(cls);
+}
+
+static MObject *ReflectGetField(const MObject *o, uint32_t modifier, size_t offset) {
+  const bool isVolatile = modifier::IsVolatile(modifier);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    if (modifier::IsWeakRef(modifier)) {
+      if (UNLIKELY(offset == 0)) {
+        LOG(FATAL) << "static field is rc weak ref " << maple::endl;
+      }
+      return MObject::Cast<MObject>(MRT_LoadWeakField(reinterpret_cast<address_t>(o),
+          reinterpret_cast<address_t*>(reinterpret_cast<address_t>(o) + offset), isVolatile));
+    } else if(modifier::IsUnowned(modifier)) {
+      if (UNLIKELY(offset == 0)) {
+        LOG(FATAL) << "static field is rc unowned ref " << maple::endl;
+      } else if (UNLIKELY(isVolatile)) {
+        LOG(FATAL) << "volatile can not be rc unowned " << o->GetClass()->GetName() << " " << offset << maple::endl;
+      }
+    }
+  }
+  return o->LoadObject(offset, isVolatile);
+}
+
+static void ReflectSetField(const MObject *o, uint32_t modifier, size_t offset, const MObject *newValue) {
+  const bool isVolatile = modifier::IsVolatile(modifier);
+  if (Collector::Instance().Type() == kNaiveRC) {
+    if (modifier::IsWeakRef(modifier)) {
+      if (UNLIKELY(offset == 0)) {
+        LOG(FATAL) << "static field is rc weak ref " << maple::endl;
+      }
+      MRT_WriteWeakField(reinterpret_cast<address_t>(o),
+          reinterpret_cast<address_t*>(reinterpret_cast<address_t>(o) + offset),
+          reinterpret_cast<address_t>(newValue), isVolatile);
+      return;
+    } else if(modifier::IsUnowned(modifier)) {
+      if (UNLIKELY(offset == 0)) {
+        LOG(FATAL) << "static field is rc unowned ref " << maple::endl;
+      } else if (UNLIKELY(isVolatile)) {
+        LOG(FATAL) << "volatile can not be rc unowned " << o->GetClass()->GetName() << " " << offset << maple::endl;
+      }
+      o->StoreObjectNoRc(offset, newValue);
+      return;
+    }
+  }
+  o->StoreObject(offset, newValue, isVolatile);
+}
+
+static void ReflectSetFieldStatic(uint32_t modifier, address_t *addr, const MObject *newValue) {
+  if (Collector::Instance().Type() == kNaiveRC) {
+    if (modifier::IsWeakRef(modifier)) {
+      LOG(FATAL) << "static field is rc weak ref " << maple::endl;
+    } else if(modifier::IsUnowned(modifier)) {
+      LOG(FATAL) << "static field is rc unowned ref " << maple::endl;
+    }
+  }
+  const bool isVolatile = modifier::IsVolatile(modifier);
+  if (isVolatile) {
+    MRT_STORE_JOBJECT_VOLATILE_STATIC(addr, newValue);
+  } else {
+    MRT_STORE_JOBJECT_STATIC(addr, newValue);
+  }
+}
+
+void FieldMeta::SetObjectValue(MObject *o, const MObject *value, bool clinitCheck) const {
+  o = GetRealMObject(o, clinitCheck);
+  if (UNLIKELY(o == nullptr)) {
+    return;
+  }
+  uint32_t offset = GetOffset();
+  uint32_t modifier = GetMod();
+  if (IsStatic()) {
+    ReflectSetFieldStatic(modifier, reinterpret_cast<address_t*>(o), value);
+  } else {
+    ReflectSetField(o, modifier, offset, value);
+  }
+}
+
+MObject *FieldMeta::GetObjectValue(const MObject *o) const {
+  o = GetRealMObject(o);
+  if (UNLIKELY(o == nullptr)) {
+    return nullptr;
+  }
+  uint32_t offset = GetOffset();
+  uint32_t modifier = GetMod();
+  return ReflectGetField(o, modifier, offset);
+}
+
+void FieldMeta::SetOffsetOrAddress(size_t setOffset) {
+  if (IsStatic()) {
+    SetStaticAddr(setOffset);
+  } else {
+    SetBitOffset(static_cast<uint32_t>(setOffset));
+  }
+}
+
+void FieldMeta::SetStaticAddr(uintptr_t addr) {
+  // static field address
+  DCHECK(IsStatic()) << "should be static field";
+  FieldOffset *fieldOffset = GetFieldpOffset();
+  DCHECK(fieldOffset != nullptr) << "fieldOffset is nullptr" << maple::endl;
+  fieldOffset->SetAddress(addr);
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/itab_util.cpp b/src/mrt/maplert/src/itab_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1983bdd2a64baa4cc06641c6638e2d29f56db42a
--- /dev/null
+++ b/src/mrt/maplert/src/itab_util.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "itab_util.h"
+#include <map>
+#include <mutex>
+#include <cstring>
+
+namespace maple {
+unsigned int DJBHash(const char *str) {
+  unsigned int hash = 5381; // initial value for DJB hash algorithm
+  while (*str) {
+    hash += (hash << 5) + static_cast<unsigned char>(*str++); // calculate the hash code of data
+  }
+  return (hash & 0x7FFFFFFF);
+}
+
+unsigned int GetHashIndex(const char *name) {
+  unsigned int hashcode = DJBHash(name);
+  return (hashcode % kHashSize);
+}
+struct CmpStr {
+  bool operator()(char const *a, char const *b) const {
+    return std::strcmp(a, b) < 0;
+  }
+};
+
+// optimization for hot method retrival.
+// check risk incurred by multi-threads.
+std::map<const char*, unsigned int, CmpStr> hotMethodCache;
+std::map<const char*, unsigned int>::const_iterator it;
+std::mutex mapLock;
+
+unsigned int GetSecondHashIndex(const char *name) {
+  std::lock_guard<std::mutex> guard(mapLock);
+  if (hotMethodCache.size() == 0) {
+    for (unsigned int i = 0; i < ITAB_HOTMETHOD_SIZE; ++i) {
+      hotMethodCache.emplace(itabHotMethod[i], i);
+    }
+  }
+
+  it = hotMethodCache.find(name);
+  if (it != hotMethodCache.end()) {
+    return it->second;
+  }
+  unsigned int hashcode = DJBHash(name);
+  return ITAB_HOTMETHOD_SIZE + (hashcode % (kItabSecondHashSize - ITAB_HOTMETHOD_SIZE));
+}
+}  // namespace maple
diff --git a/src/mrt/maplert/src/java2c_rule.cpp b/src/mrt/maplert/src/java2c_rule.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bfb190d3957e5202b33d9dd5ef7dba18a042bb60
--- /dev/null
+++ b/src/mrt/maplert/src/java2c_rule.cpp
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "java2c_rule.h"
+
+#ifndef UNIT_TEST
+#include "exception/mrt_exception.h"
+#endif
+
+namespace maplert {
+} // namespace maplert
diff --git a/src/mrt/maplert/src/literalstrname.cpp b/src/mrt/maplert/src/literalstrname.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d770982767532aaba4ca7fd5e457a50ade7e2a3d
--- /dev/null
+++ b/src/mrt/maplert/src/literalstrname.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "literalstrname.h"
+
+// literal string name is shared between maple compiler and runtime, thus not in namespace maplert
+// note there is a macor kConstString "_C_STR_" in literalstrname.h
+// which need to match
+static const std::string mplConstStr("_C_STR_00000000000000000000000000000000");
+const uint32_t kMaxBytesLength = 15;
+
+namespace {
+const char *kMplDigits = "0123456789abcdef";
+}
+
+// Return the hex string of bytes. The result is the combination of prefix "_C_STR_" and hex string of bytes.
+// The upper 4 bits and lower 4 bits of bytes[i] are transformed to hex form and restored separately in hex string.
+std::string LiteralStrName::GetHexStr(const uint8_t *bytes, uint32_t len) {
+  if (bytes == nullptr) {
+    return std::string();
+  }
+  std::string str(mplConstStr, 0, (len << 1) + kConstStringLen);
+  for (unsigned i = 0; i < len; ++i) {
+    str[2 * i + kConstStringLen] = kMplDigits[(bytes[i] & 0xf0) >> 4]; // get the hex value of upper 4 bits of bytes[i]
+    str[2 * i + kConstStringLen + 1] = kMplDigits[bytes[i] & 0x0f]; // get the hex value of lower 4 bits of bytes[i]
+  }
+  return str;
+}
+
+// Return the hash code of data. The hash code is computed as
+// s[0] * 31 ^ (len - 1) + s[1] * 31 ^ (len - 2) + ... + s[len - 1],
+// where s[i] is the value of swapping the upper 8 bits and lower 8 bits of data[i].
+int32_t LiteralStrName::CalculateHashSwapByte(const char16_t *data, uint32_t len) {
+  uint32_t hash = 0;
+  const char16_t *end = data + len;
+  while (data < end) {
+    hash = (hash << 5) - hash;
+    char16_t val = *data++;
+    hash += (((val << 8) & 0xff00) | ((val >> 8) & 0xff));
+  }
+  return static_cast<int32_t>(hash);
+}
+
+std::string LiteralStrName::GetLiteralStrName(const uint8_t *bytes, uint32_t len) {
+  if (len <= kMaxBytesLength) {
+    return GetHexStr(bytes, len);
+  }
+  return ComputeMuid(bytes, len);
+}
+
+std::string LiteralStrName::ComputeMuid(const uint8_t *bytes, uint32_t len) {
+  DigestHash digestHash = GetDigestHash(*bytes, len);
+  return GetHexStr(digestHash.bytes, kDigestHashLength);
+}
\ No newline at end of file
diff --git a/src/mrt/maplert/src/marray.cpp b/src/mrt/maplert/src/marray.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f47a08094efc5612bfaea805ea27e587b58633ac
--- /dev/null
+++ b/src/mrt/maplert/src/marray.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fast_alloc_inline.h"
+#include "sizes.h"
+#include "marray_inline.h"
+namespace maplert {
+void MArray::InitialObjectArray(const MObject *initialElement) const {
+  uint32_t length = GetLength();
+  for (uint32_t i = 0; i < length; ++i) {
+    SetObjectElement(i, initialElement);
+  }
+}
+
+MArray *MArray::NewPrimitiveArray(uint32_t length, const MClass &arrayClass, bool isJNI) {
+  uint32_t componentSize = arrayClass.GetComponentSize();
+  MArray *array = MObject::Cast<MArray>(MRT_TryNewArray(componentSize, static_cast<size_t>(length),
+      arrayClass.AsUintptr()));
+  if (LIKELY(array != nullptr)) {
+    return array;
+  }
+  if (isJNI) {
+    array = MObject::Cast<MArray>(MRT_NEW_PRIMITIVE_ARRAY_JNI(componentSize, length, &arrayClass, isJNI));
+  } else {
+    array = MObject::Cast<MArray>(MRT_NEW_PRIMITIVE_ARRAY(componentSize, length, &arrayClass));
+  }
+  return array;
+}
+
+// please supply the exponent (base 2) of the size of the elements (0, 1, 2, or 3)
+template<ArrayElemSize elemSizeExp>
+MArray *MArray::NewPrimitiveArray(uint32_t length, const MClass &arrayClass, bool isJNI) {
+  MArray *array = MObject::Cast<MArray>(MRT_TryNewArray<elemSizeExp>(static_cast<size_t>(length),
+      arrayClass.AsUintptr()));
+  if (LIKELY(array != nullptr)) {
+    return array;
+  }
+  return NewPrimitiveArray(length, arrayClass, isJNI);
+}
+
+template MArray *MArray::NewPrimitiveArray<kElemByte>(uint32_t length, const MClass&, bool);
+template MArray *MArray::NewPrimitiveArray<kElemHWord>(uint32_t length, const MClass&, bool);
+template MArray *MArray::NewPrimitiveArray<kElemWord>(uint32_t length, const MClass&, bool);
+template MArray *MArray::NewPrimitiveArray<kElemDWord>(uint32_t length, const MClass&, bool);
+
+MArray *MArray::NewPrimitiveArrayComponentClass(uint32_t length, const MClass &componentClass) {
+  MClass *arrayClass = WellKnown::GetCacheArrayClass(componentClass);
+  MArray *arrayObject = MArray::NewPrimitiveArray(length, *arrayClass);
+  return arrayObject;
+}
+
+template<ArrayElemSize elemSizeExp>
+MArray *MArray::NewPrimitiveArrayComponentClass(uint32_t length, const MClass &componentClass) {
+  MClass *arrayClass = WellKnown::GetCacheArrayClass(componentClass);
+  MArray *arrayObject = MArray::NewPrimitiveArray<elemSizeExp>(length, *arrayClass);
+  return arrayObject;
+}
+
+template MArray *MArray::NewPrimitiveArrayComponentClass<kElemByte>(uint32_t, const MClass&);
+template MArray *MArray::NewPrimitiveArrayComponentClass<kElemHWord>(uint32_t, const MClass&);
+template MArray *MArray::NewPrimitiveArrayComponentClass<kElemWord>(uint32_t, const MClass&);
+template MArray *MArray::NewPrimitiveArrayComponentClass<kElemDWord>(uint32_t, const MClass&);
+
+MArray *MArray::NewObjectArray(uint32_t length, const MClass &arrayClass) {
+  MArray *array = MObject::Cast<MArray>(MRT_TryNewArray<kElemWord>(static_cast<size_t>(length),
+      arrayClass.AsUintptr()));
+  if (LIKELY(array != nullptr)) {
+    return array;
+  }
+  array = MObject::Cast<MArray>(MRT_NEW_JOBJECT_ARRAY(length, &arrayClass));
+  return array;
+}
+
+MArray *MArray::NewObjectArrayComponentClass(uint32_t length, const MClass &componentClass) {
+  MClass *arrayJClass = maplert::WellKnown::GetCacheArrayClass(componentClass);
+  return MArray::NewObjectArray(length, *arrayJClass);
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mclass.cpp b/src/mrt/maplert/src/mclass.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c43129a4c534fa339e27322f08aee9ce16bcd5b3
--- /dev/null
+++ b/src/mrt/maplert/src/mclass.cpp
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mclass.h"
+#include "mclass_inline.h"
+#include "fieldmeta_inline.h"
+#include "mrt_cyclequeue.h"
+#include "exception/mrt_exception.h"
+#include <algorithm>
+namespace maplert {
+void MClass::GetPrettyClass(std::string &dstName) const {
+  std::string clsName;
+  GetBinaryName(clsName);
+  dstName = "java.lang.Class<";
+  dstName += clsName;
+  dstName += ">";
+}
+
+void MClass::GetBinaryName(std::string &dstName) const {
+  char *className = GetName();
+  if (IsProxy()) {
+    dstName = className;
+  } else {
+    ConvertDescriptorToBinaryName(className, dstName);
+  }
+}
+
+void MClass::GetTypeName(std::string &dstName) const {
+  ConvertDescriptorToTypeName(GetName(), dstName);
+}
+
+void MClass::ConvertDescriptorToBinaryName(const std::string &descriptor, std::string &binaryName) {
+  if (descriptor[0] != 'L' && descriptor[0] != '[') {
+    maple::Primitive::GetPrimitiveClassName(descriptor.c_str(), binaryName);
+  } else {
+    binaryName = descriptor;
+    std::replace(binaryName.begin(), binaryName.end(), '/', '.');
+    size_t len = binaryName.length();
+    // descriptor must > 2, like:LA;
+    if (binaryName[0] == 'L') {
+      binaryName = binaryName.substr(1, len - 2); // remove char 'L', ';'
+    }
+  }
+}
+
+void MClass::ConvertDescriptorToTypeName(const std::string &descriptor, std::string &defineName) {
+  uint32_t dim = GetDimensionFromDescriptor(descriptor);
+  ConvertDescriptorToBinaryName(descriptor.substr(dim), defineName);
+  for (uint32_t i = 0; i < dim; ++i) {
+    defineName += "[]";
+  }
+}
+
+void MClass::GetDescriptor(std::string &dstName) const {
+  dstName = GetName();
+}
+
+bool MClass::IsInnerClass() const {
+  std::string annoStr = GetAnnotation();
+  AnnoParser &parser = AnnoParser::ConstructParser(annoStr.c_str(), const_cast<MClass*>(this));
+  int32_t loc = parser.Find(parser.GetInnerClassStr());
+  delete &parser;
+  return loc != annoconstant::kNPos;
+}
+
+std::string MClass::GetAnnotation() const {
+  char *annotation = GetRawAnnotation();
+  return AnnotationUtil::GetAnnotationUtil(annotation);
+}
+
+FieldMetaCompact *MClass::GetCompactFields() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  FieldMetaCompact *compactFields = classInfoRo->fields.GetCompactData<FieldMetaCompact*>();
+  return compactFields;
+}
+
+MethodMetaCompact *MClass::GetCompactMethods() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  MethodMetaCompact *methodsCompact = classInfoRo->methods.GetCompactData<MethodMetaCompact*>();
+  return methodsCompact;
+}
+
+bool MClass::IsCompactMetaMethods() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->methods.IsCompact();
+}
+
+bool MClass::IsCompactMetaFields() const {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  return classInfoRo->fields.IsCompact();
+}
+
+void MClass::GetDeclaredMethods(std::vector<MethodMeta*> &methodsVector, bool publicOnly) const {
+  uint32_t numOfMethod = GetNumOfMethods();
+  MethodMeta *methodS = GetMethodMetas();
+  constexpr int kReserveTw = 20;
+  methodsVector.reserve(kReserveTw);
+  for (uint32_t i = 0; i < numOfMethod; ++i) {
+    MethodMeta *method = &methodS[i];
+    if (method->IsConstructor()) {
+      continue;
+    }
+    if (!publicOnly || (method->IsPublic())) {
+      methodsVector.push_back(method);
+    }
+  }
+}
+
+void MClass::GetDirectInterfaces(MClass *interfaceVector[], uint32_t size) const {
+  uint32_t numOfInterface = GetNumOfInterface();
+  CHECK(size <= numOfInterface) << "buffer size is wrong." << maple::endl;
+  if (IsArrayClass()) {
+    interfaceVector[0] = WellKnown::arrayInterface[0];
+    interfaceVector[1] = WellKnown::arrayInterface[1];
+  } else {
+    MClass **supers = GetSuperClassArray();
+    MClass **pInterfaces = IsInterface() ? supers : supers + 1;
+    for (uint32_t index = 0; index < numOfInterface; ++index) {
+      MClass *interface = ResolveSuperClass(pInterfaces + index);
+      interfaceVector[index] = interface;
+    }
+  }
+}
+
+void MClass::GetSuperClassInterfaces(uint32_t numOfSuperClass, MClass **superArray,
+                                     std::vector<MClass*> &interfaceVector, uint32_t firstSuperClass) const {
+  std::vector<MClass*> tempVector;
+  for (uint32_t i = firstSuperClass; i < numOfSuperClass; ++i) {
+    MClass *super = ResolveSuperClass(superArray + i);
+    std::vector<MClass*>::iterator it = std::find(interfaceVector.begin(), interfaceVector.end(), super);
+    if (it == interfaceVector.end()) {
+      interfaceVector.push_back(super);
+      tempVector.push_back(super);
+    }
+  }
+  for (auto itf : tempVector) {
+    itf->GetInterfaces(interfaceVector);
+  }
+}
+
+void MClass::GetInterfaces(std::vector<MClass*> &interfaceVector) const {
+  if (IsPrimitiveClass()) {
+    return;
+  } else if (IsArrayClass()) {
+    interfaceVector.push_back(WellKnown::arrayInterface[0]);
+    interfaceVector.push_back(WellKnown::arrayInterface[1]);
+    return;
+  } else {
+    uint32_t numOfSuperClass = GetNumOfSuperClasses();
+    MClass **superArray = GetSuperClassArray();
+    if (superArray == nullptr) {
+      return;
+    } else if (IsInterface()) {
+      GetSuperClassInterfaces(numOfSuperClass, superArray, interfaceVector, 0);
+    } else { // is class
+      GetSuperClassInterfaces(numOfSuperClass, superArray, interfaceVector, 1);
+
+      if (numOfSuperClass > 0) {
+        MClass *info = GetSuperClass();
+        if (info != nullptr) {
+          info->GetInterfaces(interfaceVector);
+        }
+      }
+    }
+  }
+}
+
+MethodMeta *MClass::GetInterfaceMethod(const char *methodName, const char *signatureName) const {
+  MethodMeta *method = nullptr;
+  std::vector<MClass*> interfaceVector;
+  constexpr int kReserveTw = 20;
+  interfaceVector.reserve(kReserveTw);
+  GetInterfaces(interfaceVector);
+  MethodMeta *resultMethod = nullptr;
+  for (auto interface : interfaceVector) {
+    method = interface->GetDeclaredMethod(methodName, signatureName);
+    if (method != nullptr) {
+      if (resultMethod == nullptr) {
+        resultMethod = method;
+      } else if (resultMethod->GetDeclaringClass()->IsAssignableFrom(*method->GetDeclaringClass())) {
+        resultMethod = method;
+      }
+    }
+  }
+  return resultMethod;
+}
+
+MethodMeta *MClass::GetMethod(const char *methodName, const char *signatureName) const {
+  MethodMeta *method = nullptr;
+  const MClass *superClass = this;
+  while (superClass != nullptr) {
+    method = superClass->GetDeclaredMethod(methodName, signatureName);
+    if (method != nullptr) {
+      return method;
+    } else {
+      superClass = superClass->GetSuperClass();
+    }
+  }
+  return GetInterfaceMethod(methodName, signatureName);
+}
+
+MethodMeta *MClass::GetMethodForVirtual(const MethodMeta &srcMethod) const {
+  MethodMeta *method = nullptr;
+  const MClass *superClass = this;
+  char *methodName = srcMethod.GetName();
+  char *signatureName = srcMethod.GetSignature();
+  while (superClass != nullptr) {
+    method = superClass->GetDeclaredMethod(methodName, signatureName);
+    if (method != nullptr && method->IsOverrideMethod(srcMethod)) {
+      return method;
+    } else {
+      superClass = superClass->GetSuperClass();
+    }
+  }
+  return GetInterfaceMethod(methodName, signatureName);
+}
+
+MethodMeta *MClass::GetDeclaredFinalizeMethod() const {
+  MethodMeta *methodS = GetMethodMetas();
+  uint32_t numOfMethod = GetNumOfMethods();
+  if (numOfMethod == 0) {
+    return nullptr;
+  }
+  MethodMeta *method = &methodS[numOfMethod - 1];
+  return method->IsFinalizeMethod() ? method : nullptr;
+}
+
+MethodMeta *MClass::GetFinalizeMethod() const {
+  MethodMeta *finalizeMethod = nullptr;
+  const MClass *superClass = this;
+  while (superClass != nullptr) {
+    finalizeMethod = superClass->GetDeclaredFinalizeMethod();
+    if (finalizeMethod != nullptr) {
+      break;
+    }
+    superClass = superClass->GetSuperClass();
+  }
+  return finalizeMethod;
+}
+
+bool MClass::IsAssignableFromInterface(const MClass &cls) const {
+  if (cls.IsArrayClass()) {
+    // array class has 2 interface
+    return (this == WellKnown::arrayInterface[0]) ? true : (this == WellKnown::arrayInterface[1]);
+  }
+  CycleQueue<const MClass*> interfaceQueue;
+  interfaceQueue.Push(&cls);
+  while (!interfaceQueue.Empty()) {
+    const MClass *tmpClass = interfaceQueue.Front();
+    interfaceQueue.Pop();
+    uint32_t numofsuperclass = tmpClass->GetNumOfSuperClasses();
+    MClass **superArray = tmpClass->GetSuperClassArray();
+    for (uint32_t i = 0; i < numofsuperclass; ++i) {
+      MClass *super = ResolveSuperClass(superArray + i);
+      if (super == this) {
+        return true;
+      }
+      interfaceQueue.Push(super);
+    }
+  }
+  return false;
+}
+
+bool MClass::IsAssignableFromImpl(const MClass &cls) const {
+  if (&cls == this) {
+    return true;
+  } else if (WellKnown::GetMClassObject() == this) {
+    return !cls.IsPrimitiveClass();
+  } else if (IsArrayClass()) {
+    return cls.IsArrayClass() && GetComponentClass()->IsAssignableFromImpl(*cls.GetComponentClass());
+  } else if (IsInterface()) {
+    return IsAssignableFromInterface(cls);
+  } else if (!cls.IsInterface()) {
+    MClass **superClassArray = cls.GetSuperClassArrayPtr();
+    MClass *super = cls.GetNumOfSuperClasses() == 0 ? nullptr : ResolveSuperClass(superClassArray);
+    while (super != nullptr) {
+      if (super == this) {
+        return true;
+      }
+      superClassArray = super->GetSuperClassArrayPtr();
+      super = super->GetNumOfSuperClasses() == 0 ? nullptr : ResolveSuperClass(superClassArray);
+    }
+  }
+  return false;
+}
+
+void MClass::SetName(const char *name) {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  classInfoRo->className.SetRef(name);
+}
+
+void MClass::SetModifier(uint32_t newMod) {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  classInfoRo->mod = newMod;
+}
+
+void MClass::SetGctib(uintptr_t newGctib) {
+  ClassMetadata *cls = GetClassMeta();
+  cls->gctib.SetGctibRef(newGctib);
+}
+
+void MClass::SetSuperClassArray(uintptr_t newValue) {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  classInfoRo->superclass.SetDataRef(newValue);
+}
+
+void MClass::SetObjectSize(uint32_t newSize) {
+  ClassMetadata *cls = GetClassMeta();
+  cls->sizeInfo.objSize = newSize;
+}
+
+void MClass::SetItable(uintptr_t itab) {
+  ClassMetadata *cls = GetClassMeta();
+  cls->iTable.SetDataRef(itab);
+}
+
+void MClass::SetVtable(uintptr_t vtab) {
+  ClassMetadata *cls = GetClassMeta();
+  cls->vTable.SetDataRef(vtab);
+}
+
+void MClass::SetNumOfFields(uint32_t newValue) {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  classInfoRo->numOfFields = newValue;
+}
+
+void MClass::SetNumOfMethods(uint32_t newValue) {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  classInfoRo->numOfMethods = newValue;
+}
+
+void MClass::SetMethods(const MethodMeta &newMethods) {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  classInfoRo->methods.SetDataRef(&newMethods);
+}
+
+void MClass::SetFields(const FieldMeta &newFields) {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  classInfoRo->fields.SetDataRef(&newFields);
+}
+
+void MClass::SetInitStateRawValue(uintptr_t newValue) {
+  ClassMetadata *cls = GetClassMeta();
+  cls->SetInitStateRawValue(newValue);
+}
+
+MClass *MClass::NewMClass(uintptr_t newClsMem) {
+  if (newClsMem == 0) {
+    newClsMem = reinterpret_cast<uintptr_t>(
+        MRT_AllocFromMeta(sizeof(ClassMetadata) + sizeof(ClassMetadataRO), kClassMetaData));
+  }
+  MClass *newMClass = MObject::Cast<MClass>(newClsMem);
+  uintptr_t newClsRo = newClsMem + sizeof(ClassMetadata);
+  newMClass->SetClassMetaRoData(newClsRo);
+  MClass *mClassClass = WellKnown::GetMClassClass();
+  // store java.lang.Class
+  newMClass->StoreObjectNoRc(0, mClassClass);
+  return newMClass;
+}
+
+MClass *MClass::GetArrayClass(const MClass &componentClass) {
+  return maplert::WellKnown::GetCacheArrayClass(componentClass);
+}
+
+MClass *MClass::GetClassFromDescriptorUtil(const MObject *context, const char *descriptor, bool throwException) {
+  CHECK(descriptor != nullptr);
+  // get context class
+  const MClass *contextClass = context != nullptr ?
+      (context->GetClass() == WellKnown::GetMClassClass() ?
+      static_cast<const MClass*>(context) : context->GetClass()) : nullptr;
+  MClass *cls = MClass::JniCast(MRT_GetClassByContextClass(*contextClass, descriptor));
+  if (UNLIKELY(throwException && (cls == nullptr))) {
+    std::string msg = "Failed resolution of: ";
+    msg += descriptor;
+    MRT_ThrowNewException("java/lang/NoClassDefFoundError", msg.c_str());
+    return nullptr;
+  }
+  return cls;
+}
+
+MObject *MClass::GetSignatureAnnotation() const {
+  std::string annotationSet = GetAnnotation();
+  if (annotationSet.empty()) {
+    return nullptr;
+  }
+  VLOG(reflect) << "Enter GetSignatureAnnotation, annoStr: " << annotationSet << maple::endl;
+  MObject *ret = AnnoParser::GetSignatureValue(annotationSet, const_cast<MClass*>(this));
+  return ret;
+}
+
+uint32_t MClass::GetArrayModifiers() const {
+  const MClass *componentClass = this;
+  while (componentClass->IsArrayClass()) {
+    componentClass = componentClass->GetComponentClass();
+  }
+  uint32_t componentModifiers = componentClass->GetModifier() & 0xFFFF;
+  if (modifier::IsInterface(componentModifiers)) {
+    componentModifiers &= ~(modifier::GetInterfaceModifier() | modifier::GetStaticModifier());
+  }
+  return modifier::GetAbstractModifier() | modifier::GetFinalModifier() | componentModifiers;
+}
+
+MethodMeta *MClass::GetClinitMethodMeta() const {
+  uint32_t numOfMethods = GetNumOfMethods();
+  MethodMeta *methodS = GetMethodMetas();
+  for (uint32_t i = 0; i < numOfMethods; ++i) {
+    MethodMeta *method = methodS + i;
+    bool isConstructor = method->IsConstructor();
+    bool isStatic = method->IsStatic();
+    if (isConstructor && isStatic) {
+      return method;
+    }
+  }
+  return nullptr;
+}
+
+void MClass::ResolveVtabItab() {
+  ClassMetadata *cls = GetClassMeta();
+  uint8_t *itab = cls->iTable.GetDataRef<uint8_t*>();
+  cls->iTable.SetDataRef(itab);
+
+  uint8_t *vtab = cls->vTable.GetDataRef<uint8_t*>();
+  cls->vTable.SetDataRef(vtab);
+}
+
+void MClass::SetComponentClass(const MClass &klass) {
+  ClassMetadataRO *classInfoRo = GetClassMetaRo();
+  classInfoRo->componentClass.SetDataRef(&klass);
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/methodmeta.cpp b/src/mrt/maplert/src/methodmeta.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2cdf661fcfe5833f2ff85945f320ce907ec8b2ad
--- /dev/null
+++ b/src/mrt/maplert/src/methodmeta.cpp
@@ -0,0 +1,872 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "methodmeta_inline.h"
+#include "exception/mrt_exception.h"
+namespace maplert {
+using namespace annoconstant;
+std::mutex MethodMetaCompact::resolveMutex;
+bool MethodMetaBase::IsMethodMetaCompact() const {
+  return (compactMetaFlag & modifier::kMethodMetaCompact) == modifier::kMethodMetaCompact;
+}
+
+char *MethodMetaBase::GetName() const {
+  __MRT_Profile_MethodMeta(this);
+  bool isMethodMetaCompact = IsMethodMetaCompact();
+  char *name = nullptr;
+  if (isMethodMetaCompact) {
+    const MethodMetaCompact *methodMetaCompact = reinterpret_cast<const MethodMetaCompact*>(this);
+    name = methodMetaCompact->GetName();
+  } else {
+    const MethodMeta *methodMeta = reinterpret_cast<const MethodMeta*>(this);
+    name = methodMeta->GetName();
+  }
+  return name;
+}
+
+void MethodMetaBase::GetSignature(std::string &signature) const {
+  bool isMethodMetaCompact = IsMethodMetaCompact();
+  if (isMethodMetaCompact) {
+    const MethodMetaCompact *methodMetaCompact = reinterpret_cast<const MethodMetaCompact*>(this);
+    methodMetaCompact->GetSignature(signature);
+  } else {
+    const MethodMeta *methodMeta = reinterpret_cast<const MethodMeta*>(this);
+    signature = methodMeta->GetSignature();
+  }
+}
+
+MClass *MethodMetaBase::GetDeclaringClass() const {
+  bool isMethodMetaCompact = IsMethodMetaCompact();
+  MClass *dclClass = nullptr;
+  if (isMethodMetaCompact) {
+    const MethodMetaCompact *methodMetaCompact = reinterpret_cast<const MethodMetaCompact*>(this);
+    dclClass = methodMetaCompact->GetDeclaringClass();
+  } else {
+    const MethodMeta *methodMeta = reinterpret_cast<const MethodMeta*>(this);
+    dclClass = methodMeta->GetDeclaringClass();
+  }
+  return dclClass;
+}
+
+uint16_t MethodMetaBase::GetFlag() const {
+  bool isMethodMetaCompact = IsMethodMetaCompact();
+  uint16_t flag = 0;
+  if (isMethodMetaCompact) {
+    const MethodMetaCompact *methodMetaCompact = reinterpret_cast<const MethodMetaCompact*>(this);
+    flag = methodMetaCompact->GetFlag();
+  } else {
+    const MethodMeta *methodMeta = reinterpret_cast<const MethodMeta*>(this);
+    flag = methodMeta->GetFlag();
+  }
+  return flag;
+}
+
+uint32_t MethodMetaBase::GetMod() const {
+  bool isMethodMetaCompact = IsMethodMetaCompact();
+  uint32_t mod = 0;
+  if (isMethodMetaCompact) {
+    const MethodMetaCompact *methodMetaCompact = reinterpret_cast<const MethodMetaCompact*>(this);
+    mod = methodMetaCompact->GetMod();
+  } else {
+    const MethodMeta *methodMeta = reinterpret_cast<const MethodMeta*>(this);
+    mod = methodMeta->GetMod();
+  }
+  return mod;
+}
+
+int16_t MethodMetaBase::GetVtabIndex() const {
+  bool isMethodMetaCompact = IsMethodMetaCompact();
+  int16_t vtabIndex = 0;
+  if (isMethodMetaCompact) {
+    const MethodMetaCompact *methodMetaCompact = reinterpret_cast<const MethodMetaCompact*>(this);
+    vtabIndex = methodMetaCompact->GetVtabIndex();
+  } else {
+    const MethodMeta *methodMeta = reinterpret_cast<const MethodMeta*>(this);
+    vtabIndex = methodMeta->GetVtabIndex();
+  }
+  return vtabIndex;
+}
+
+uintptr_t MethodMetaBase::GetFuncAddress() const {
+  bool isMethodMetaCompact = IsMethodMetaCompact();
+  uintptr_t funcAddr = 0;
+  if (isMethodMetaCompact) {
+    const MethodMetaCompact *methodMetaCompact = reinterpret_cast<const MethodMetaCompact*>(this);
+    funcAddr = methodMetaCompact->GetFuncAddress();
+  } else {
+    const MethodMeta *methodMeta = reinterpret_cast<const MethodMeta*>(this);
+    funcAddr = methodMeta->GetFuncAddress();
+  }
+  return funcAddr;
+}
+
+int16_t MethodMetaCompact::GetVtabIndex() const {
+  return vtabIndex;
+}
+
+uint16_t MethodMetaCompact::GetFlag() const {
+  return compactMetaFlag;
+}
+
+int32_t MethodMetaCompact::GetDefTabIndex() const {
+  MethodAddress *pMethodAddress = GetpMethodAddress();
+  if (pMethodAddress == nullptr) {
+    return -1;
+  }
+  return pMethodAddress->GetDefTabIndex();
+}
+
+MethodAddress *MethodMetaCompact::GetpMethodAddress() const {
+  if (IsAbstract()) {
+    return nullptr;
+  }
+  uintptr_t value = reinterpret_cast<const DataRefOffset32*>(&leb128Start)->GetDataRef<uintptr_t>();
+  // compile will +2 as flag, here need -2 to remove it
+  return reinterpret_cast<MethodAddress*>(value - 2);
+}
+
+uintptr_t MethodMetaCompact::GetFuncAddress() const {
+  if (IsAbstract()) {
+    return 0;
+  }
+  MethodAddress *pMethodAddress = GetpMethodAddress();
+  if (pMethodAddress == nullptr) {
+    return 0;
+  }
+  return pMethodAddress->GetAddr();
+}
+
+void MethodMetaCompact::SetFuncAddress(uintptr_t address) {
+  MethodAddress *pMethodAddress = GetpMethodAddress();
+  if (pMethodAddress != nullptr) {
+    pMethodAddress->SetAddr(address);
+  }
+}
+
+bool MethodMetaCompact::IsAbstract() const {
+  uint16_t flag = GetFlag();
+  return ((flag & modifier::kMethodAbstract) == modifier::kMethodAbstract);
+}
+
+const uint8_t *MethodMetaCompact::GetpCompact() const {
+  return &leb128Start;
+}
+
+char *MethodMetaCompact::GetName() const {
+  const uint8_t *pLeb = GetpCompact();
+  pLeb = IsAbstract() ? pLeb : (pLeb + sizeof(int32_t));
+  // ingore declaring Class index
+  (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // modifier
+  (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // methodname
+  uint32_t methodNameIndex = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  char *method = LinkerAPI::Instance().GetCString(reinterpret_cast<jclass>(GetDeclaringClass()), methodNameIndex);
+  __MRT_Profile_CString(method);
+  return method;
+}
+
+void MethodMetaCompact::GetSignature(std::string &signature) const {
+  const uint8_t *pLeb = GetpCompact();
+  pLeb = IsAbstract() ? pLeb : (pLeb + sizeof(int32_t));
+  // ingore declaring Class index
+  (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // modifier
+  uint32_t modifier = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // methodname
+  (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // args size
+  uint32_t argsSize = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // methodsignature
+  signature = "(";
+  // retrun type +1
+  uint32_t typeSize = modifier::IsStatic(modifier) ? argsSize + 1 : argsSize;
+  MClass *cls = GetDeclaringClass();
+  for (uint32_t i = 0; i < typeSize; ++i) {
+    uint32_t typeIndex = namemangler::GetUnsignedLeb128Decode(&pLeb);
+    char *typeCName = LinkerAPI::Instance().GetCString(reinterpret_cast<jclass>(cls), typeIndex);
+    if (UNLIKELY(typeCName == nullptr)) {
+      LOG(FATAL) << "MethodMetaCompact::GetSignature: typeName must not be nullptr!" << maple::endl;
+    }
+    std::string typeName = typeCName;
+    __MRT_Profile_CString(typeName.c_str());
+    if (i == (typeSize - 1)) {
+      signature += ")";
+      signature += typeName;
+    } else {
+      signature += typeName;
+    }
+  }
+}
+
+uint32_t MethodMetaCompact::GetMod() const {
+  const uint8_t *pLeb = GetpCompact();
+  pLeb = IsAbstract() ? pLeb : (pLeb + sizeof(int32_t));
+  // ingore declaring Class index
+  (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // modifier
+  uint32_t modifier = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  return modifier;
+}
+
+MClass *MethodMetaCompact::GetDeclaringClass() const {
+  const uint8_t *pLeb = GetpCompact();
+  pLeb = IsAbstract() ? pLeb : (pLeb + sizeof(int32_t));
+  const uint8_t *prePleb = pLeb;
+  uint32_t declClassOffset = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  const DataRefOffset32 *declClassAddr = reinterpret_cast<const DataRefOffset32*>(prePleb - declClassOffset);
+  MClass *declClass = declClassAddr->GetDataRef<MClass*>();
+  return declClass;
+}
+
+static MethodMetaCompact *Leb128DecodeOneByOne(MethodMetaCompact *leb) {
+  // start decode
+  const uint8_t *pLeb = leb->GetpCompact();
+  pLeb = leb->IsAbstract() ? pLeb : (pLeb + sizeof(int32_t));
+  // ingore declaring Class index
+  (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // modifier
+  uint32_t modifier = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // methodname
+  (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // args size
+  uint32_t argsSize = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // methodsignature
+  uint32_t typeSize = modifier::IsStatic(modifier) ? (argsSize + 1) : argsSize;
+  for (uint32_t j = 0; j < typeSize; ++j) {
+    (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  }
+  // annotation
+  (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  leb = reinterpret_cast<MethodMetaCompact*>(const_cast<uint8_t*>(pLeb));
+  return leb;
+}
+
+uintptr_t MethodMetaCompact::GetCompactFuncAddr(const MClass &cls, uint32_t index) {
+  uint32_t numOfMethod = cls.GetNumOfMethods();
+  MethodMetaCompact *leb = cls.GetCompactMethods();
+  for (uint32_t i = 0; i < numOfMethod; ++i) {
+    if (i == index) {
+      return leb->GetFuncAddress();
+    }
+    leb = Leb128DecodeOneByOne(leb);
+  }
+  LOG(FATAL) << "MethodMetaCompact::GetCompactFuncAddr class: " << cls.GetName() <<
+      ", index:" << index << maple::endl;
+  return 0;
+}
+
+MethodMetaCompact *MethodMetaCompact::GetMethodMetaCompact(const MClass &cls, uint32_t index) {
+  uint32_t numOfMethod = cls.GetNumOfMethods();
+  MethodMetaCompact *leb = cls.GetCompactMethods();
+  for (uint32_t i = 0; i < numOfMethod; ++i) {
+    if (i == index) {
+      return leb;
+    }
+    leb = Leb128DecodeOneByOne(leb);
+  }
+  LOG(FATAL) << "MethodMetaCompact::GetMethodMetaCompact class: " << cls.GetName() <<
+      ", index:" << index << maple::endl;
+  return 0;
+}
+
+uint8_t *MethodMetaCompact::DecodeCompactMethodMeta(const MClass &cls, uintptr_t &funcAddress, uint32_t &modifier,
+                                                    std::string &methodName, std::string &signatureName,
+                                                    std::string &annotationValue, int32_t &methodInVtabIndex,
+                                                    uint16_t &flags, uint16_t &argsSize) const {
+  methodInVtabIndex = GetVtabIndex();
+  flags = GetFlag();
+  funcAddress = reinterpret_cast<uintptr_t>(GetFuncAddress());
+  // start decode
+  const uint8_t *pLeb = GetpCompact();
+  pLeb = IsAbstract() ? pLeb : (pLeb + sizeof(int32_t));
+  // ingore declaring Class index
+  (void)namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // modifier
+  modifier = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  // methodname
+  uint32_t methodNameIndex = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  methodName = LinkerAPI::Instance().GetCString(cls.AsJclass(), methodNameIndex);
+  // args size
+  argsSize = static_cast<uint16_t>(namemangler::GetUnsignedLeb128Decode(&pLeb));
+  // methodsignature
+  std::string signature("(");
+  // retrun type +1
+  uint32_t typeSize = modifier::IsStatic(modifier) ? (argsSize + 1) : argsSize;
+  uint32_t parameterSize = typeSize - 1;
+  for (uint32_t j = 0; j < typeSize; ++j) {
+    uint32_t typeIndex = namemangler::GetUnsignedLeb128Decode(&pLeb);
+    std::string typeName = LinkerAPI::Instance().GetCString(cls.AsJclass(), typeIndex);
+    __MRT_Profile_CString(typeName.c_str());
+    if (j == parameterSize) {
+      signature += ")";
+      signature += typeName;
+    } else {
+      signature += typeName;
+    }
+  }
+  signatureName = signature;
+  // annotation
+  uint32_t annotationIndex = namemangler::GetUnsignedLeb128Decode(&pLeb);
+  annotationValue = LinkerAPI::Instance().GetCString(cls.AsJclass(), annotationIndex);
+  return const_cast<uint8_t*>(pLeb);
+}
+
+MethodMeta *MethodMetaCompact::DecodeCompactMethodMetas(MClass &cls) {
+  uint32_t numOfMethod = cls.GetNumOfMethods();
+  if (numOfMethod == 0) {
+    return nullptr;
+  }
+  {
+    std::lock_guard<std::mutex> lock(resolveMutex);
+    MethodMeta *methods = cls.GetRawMethodMetas();
+    if (!cls.IsCompactMetaMethods()) {
+      return methods;
+    }
+    // Compact, need resolve
+    MethodMetaCompact *leb = cls.GetCompactMethods();
+
+    CHECK(numOfMethod < (std::numeric_limits<uint32_t>::max() / sizeof(MethodMeta))) <<
+        "method count too large. numOfMethod " << numOfMethod << maple::endl;
+    MethodMeta *methodMetas = reinterpret_cast<MethodMeta*>(
+        MRT_AllocFromMeta(sizeof(MethodMeta) * numOfMethod, kMethodMetaData));
+    MethodMeta *methodMeta = methodMetas;
+    for (uint32_t i = 0; i < numOfMethod; ++i) {
+      uintptr_t funcAddress = 0;
+      uint32_t modifier = 0;
+      std::string methodName;
+      std::string signatureName;
+      std::string annotationValue;
+      int32_t methodInVtabIndex = 0;
+      uint16_t flags = 0;
+      uint16_t argsSize = 0;
+      uint8_t *pLeb = leb->DecodeCompactMethodMeta(cls, funcAddress, modifier, methodName, signatureName,
+                                                   annotationValue, methodInVtabIndex, flags, argsSize);
+      MethodSignature *mthSig = methodMeta->CreateMethodSignatureByName(signatureName.c_str());
+      methodMeta->FillMethodMeta(true, methodName.c_str(), mthSig, annotationValue.c_str(),
+                                 methodInVtabIndex, cls, funcAddress, modifier, flags, argsSize);
+      methodMeta++;
+      leb = reinterpret_cast<MethodMetaCompact*>(pLeb);
+    }
+    cls.SetMethods(*methodMetas);
+    return methodMetas;
+  }
+}
+
+MethodSignature *MethodMeta::CreateMethodSignatureByName(const char *signature) {
+  size_t sigStrLen = strlen(signature) + 1;
+  char *signatureBuffer = reinterpret_cast<char*>(MRT_AllocFromMeta(sigStrLen, kNativeStringData));
+  errno_t tmpResult = memcpy_s(signatureBuffer, sigStrLen, signature, sigStrLen);
+  if (UNLIKELY(tmpResult != EOK)) {
+    LOG(FATAL) << "MethodMeta::CreateMethodSignatureByName : memcpy_s() failed" << maple::endl;
+  }
+  signature = signatureBuffer;
+  MethodSignature *pMethodSignature = reinterpret_cast<MethodSignature*>(MRT_AllocFromMeta(sizeof(MethodSignature),
+                                                                         kMethodMetaData));
+  pMethodSignature->SetSignature(signature);
+  return pMethodSignature;
+}
+
+void MethodMeta::FillMethodMeta(bool copySignature, const char *name,
+    const MethodSignature *methodSignature, const char *annotation, int32_t inVtabIndex,
+    const MClass &methodDclClass, const uintptr_t funcAddr,
+    uint32_t modifier, uint16_t methodFlag, uint16_t argSize) {
+  DCHECK(name != nullptr) << "MethodMeta::FillMethodMeta: name is nullptr!" << maple::endl;
+  DCHECK(methodSignature != nullptr) << "MethodMeta::FillMethodMeta: methodSignature is nullptr!" << maple::endl;
+  DCHECK(annotation != nullptr) << "MethodMeta::FillMethodMeta: annotation is nullptr!" << maple::endl;
+#ifndef USE_32BIT_REF
+  size_t methodNameStrLen = strlen(name) + 1;
+  size_t annotationStrLen = strlen(annotation) + 1;
+  char *strBuffer = reinterpret_cast<char*>(MRT_AllocFromMeta(annotationStrLen + methodNameStrLen, kNativeStringData));
+  char *methodNameBuffer = strBuffer;
+  char *annoBuffer = strBuffer + methodNameStrLen;
+  errno_t tmpResult1 = memcpy_s(methodNameBuffer, methodNameStrLen, name, methodNameStrLen);
+  errno_t tmpResult2 = memcpy_s(annoBuffer, annotationStrLen, annotation, annotationStrLen);
+  if (UNLIKELY(tmpResult1 != EOK || tmpResult2 != EOK)) {
+    LOG(FATAL) << "MethodMeta::FillMethodMeta : memcpy_s() failed" << maple::endl;
+  }
+  name = methodNameBuffer;
+  annotation = annoBuffer;
+  methodFlag &= ~modifier::kMethodParametarType;
+  if (!copySignature) {
+    char *signature = methodSignature->GetSignature();
+    methodSignature = CreateMethodSignatureByName(signature);
+  }
+#endif
+  (void)copySignature;
+  SetMod(modifier);
+  SetName(name);
+  SetFlag(methodFlag);
+  SetMethodSignature(methodSignature);
+  SetAnnotation(annotation);
+  SetAddress(funcAddr);
+  SetDeclaringClass(methodDclClass);
+  SetVtabIndex(inVtabIndex);
+  SetArgsSize(argSize);
+}
+
+MClass *MethodMeta::GetReturnType() const {
+  __MRT_Profile_MethodParameterTypes(*this);
+  bool isEnableParametarType = IsEnableParametarType();
+  if (isEnableParametarType) {
+    MetaRef *pTypes = GetMethodSignature()->GetTypes();
+    uint32_t returnTypeIndex = GetParameterCount();
+    if (pTypes[returnTypeIndex] != 0) {
+      return reinterpret_cast<MClass*>(pTypes[returnTypeIndex]);
+    }
+  }
+
+  char *rtTypeName = GetReturnTypeName();
+  MClass *declClass = GetDeclaringClass();
+  MClass *returnType = MClass::GetClassFromDescriptor(declClass, rtTypeName);
+  if (isEnableParametarType) {
+    MetaRef *pTypes = GetMethodSignature()->GetTypes();
+    uint32_t returnTypeIndex = GetParameterCount();
+    pTypes[returnTypeIndex] = static_cast<MetaRef>(returnType->AsUintptr());
+  }
+  return returnType;
+}
+
+static void GetDescriptorBySignature(char *descriptor, char *&methodSig, char &c) {
+  char *tmpDescriptor = descriptor;
+  if (c == '[') {
+    while (c == '[') {
+      *tmpDescriptor++ = c;
+      c = *methodSig++;
+    }
+  }
+  if (c == 'L') {
+    while (c != ';') {
+      *tmpDescriptor++ = c;
+      c = *methodSig++;
+    }
+  }
+  *tmpDescriptor++ = c;
+  c = *methodSig++;
+  *tmpDescriptor = '\0';
+}
+
+bool MethodMeta::GetParameterTypesUtil(MClass *parameterTypes[], uint32_t size) const {
+  uint32_t parameterCount = GetParameterCount();
+  CHECK(parameterCount == size) << "size is wrong." << maple::endl;
+  if (parameterCount == 0) {
+    return true;
+  }
+  uint32_t index = 0;
+  char *methodSig = GetSignature();
+  __MRT_Profile_MethodParameterTypes(*this);
+  MClass *declClass = GetDeclaringClass();
+  size_t len = strlen(methodSig) + 1;
+  // skip first '('
+  methodSig++;
+  char descriptor[len];
+  char c = *methodSig++;
+  while (c != ')') {
+    GetDescriptorBySignature(descriptor, methodSig, c);
+    MClass *ptype = MClass::GetClassFromDescriptor(declClass, descriptor);
+    if (UNLIKELY(ptype == nullptr)) {
+      return false;
+    }
+    parameterTypes[index++] = ptype;
+  }
+  return true;
+}
+
+void MethodMeta::GetParameterTypes(std::vector<MClass*> &parameterTypes) const {
+  uint32_t parameterCount = GetParameterCount();
+  MClass *types[parameterCount];
+  bool isSuccess = GetParameterTypes(types, parameterCount);
+  if (!isSuccess) {
+    return;
+  }
+  for (uint32_t i = 0; i < parameterCount; ++i) {
+    parameterTypes.push_back(types[i]);
+  }
+}
+
+MArray *MethodMeta::GetParameterTypes() const {
+  std::vector<MClass*> parameterTypes;
+  GetParameterTypes(parameterTypes);
+  if (MRT_HasPendingException()) {
+    return nullptr;
+  }
+  uint32_t size = static_cast<uint32_t>(parameterTypes.size());
+  MArray *parameterTypesArray = MArray::NewObjectArray(size, *WellKnown::GetMClassAClass());
+  uint32_t currentIndex = 0;
+  for (auto parameterType : parameterTypes) {
+    parameterTypesArray->SetObjectElementOffHeap(currentIndex++, parameterType);
+  }
+  return parameterTypesArray;
+}
+
+void MethodMeta::GetParameterTypesDescriptor(std::vector<std::string> &descriptors) const {
+  char *methodSig = GetSignature();
+  size_t len = strlen(methodSig) + 1;
+  // skip first '('
+  methodSig++;
+  char descriptor[len];
+  char c = *methodSig++;
+  while (c != ')') {
+    GetDescriptorBySignature(descriptor, methodSig, c);
+    descriptors.push_back(descriptor);
+  }
+}
+
+MObject *MethodMeta::GetSignatureAnnotation() const {
+  std::string methodAnnoStr = GetAnnotation();
+  if (methodAnnoStr.empty()) {
+    return nullptr;
+  }
+  MObject *ret = AnnoParser::GetSignatureValue(methodAnnoStr, GetDeclaringClass());
+  return ret;
+}
+
+void MethodMeta::GetExceptionTypes(std::vector<MClass*> &types) const {
+  std::string annoStr = GetAnnotation();
+  if (annoStr.empty()) {
+    return;
+  }
+  MClass *cl = GetDeclaringClass();
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), cl);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  int32_t loc = parser->Find(parser->GetThrowsClassStr());
+  if (loc != kNPos) {
+    std::string exception = parser->ParseStr(kDefParseStrType);
+    int64_t annoType = parser->ParseNum(kValueInt);
+    if (exception == "value" && annoType == kValueArray) {
+      size_t start = annoStr.find(parser->GetAnnoArrayStartDelimiter(), parser->GetIdx());
+      size_t end = annoStr.find(parser->GetAnnoArrayEndDelimiter(), parser->GetIdx());
+      if ((start != std::string::npos) && (end != std::string::npos)) {
+        parser->SetIdx(static_cast<uint32_t>(start - kLabelSize));
+        int64_t exceptionNum = parser->ParseNum(kValueInt);
+        parser->SkipNameAndType();
+        std::string exceptionStr;
+        for (int64_t i = 0; i < exceptionNum; ++i) {
+          exceptionStr.clear();
+          exceptionStr = parser->ParseStr(kDefParseStrType);
+          MClass *exceptionClass = MClass::GetClassFromDescriptor(cl, exceptionStr.c_str(), false);
+          if (exceptionClass != nullptr) {
+            types.push_back(exceptionClass);
+          } else {
+            MRT_ThrowNewException("java/lang/TypeNotPresentException", nullptr);
+            break;
+          }
+        }
+      }
+    }
+  }
+  return;
+}
+
+MArray *MethodMeta::GetExceptionTypes() const {
+  std::vector<MClass*> exceptionTypes;
+  GetExceptionTypes(exceptionTypes);
+  if (MRT_HasPendingException()) {
+    return nullptr;
+  }
+  uint32_t size = static_cast<uint32_t>(exceptionTypes.size());
+  MArray *excetpionArray = MArray::NewObjectArray(size, *WellKnown::GetMClassAClass());
+  uint32_t index = 0;
+  for (auto type : exceptionTypes) {
+    excetpionArray->SetObjectElementOffHeap(index++, type);
+  }
+  return excetpionArray;
+}
+
+void MethodMeta::GetPrettyName(bool needSignature, std::string &dstName) const {
+  char *name = GetName();
+  MClass *declClass = GetDeclaringClass();
+  std::string declaringClassName;
+  declClass->GetTypeName(declaringClassName);
+  if (needSignature) {
+    std::string retTypeStr;
+    MClass::ConvertDescriptorToTypeName(GetReturnTypeName(), retTypeStr);
+    dstName = retTypeStr + " ";
+  }
+  dstName += declaringClassName + "." + name;
+  if (needSignature) {
+    dstName += "(";
+    std::vector<std::string> parameterTypes;
+    GetParameterTypesDescriptor(parameterTypes);
+    uint64_t numOfParam = static_cast<uint32_t>(parameterTypes.size());
+    auto it = parameterTypes.begin();
+    uint64_t i = 0;
+    std::string paramStr;
+    for (; it != parameterTypes.end(); ++it, ++i) {
+      paramStr.clear();
+      MClass::ConvertDescriptorToTypeName((*it).c_str(), paramStr);
+      dstName += paramStr;
+      if (i != (numOfParam - 1)) {
+        dstName += ", ";
+      }
+    }
+    dstName += ")";
+  }
+}
+
+// ([ZJSIDF[Ljava/lang/String;Ljava/lang/String;)V  -> [JSIDF[L
+void MethodMeta::GetShortySignatureUtil(const char srcSignature[], char shorty[], const uint32_t size) {
+  DCHECK(shorty != nullptr);
+  DCHECK(srcSignature != nullptr);
+  const char *name = srcSignature;
+  char *ret = shorty;
+  name++; // skip '('
+  while ((*name != '\0') && (*name != ')')) {
+    if (*name == '[') {
+      while (*name == '[') {
+        name++;
+      }
+      if (*name == 'L') {
+        while (*name != ';') {
+          name++;
+        }
+      }
+      name++;
+      *ret++ = '[';
+      continue;
+    }
+
+    if (*name == 'L') {
+      while (*name != ';') {
+        name++;
+      }
+      name++;
+      *ret++ = 'L';
+      continue;
+    }
+    *ret++ = *name++;
+  }
+  CHECK((ret - shorty) <= static_cast<const int32_t>(size));
+}
+
+void MethodMeta::SetMod(const uint32_t modifier) {
+  mod = modifier;
+}
+
+void MethodMeta::SetName(const char *name) {
+  methodName.SetDataRef(name);
+}
+
+void MethodMeta::SetSignature(const char *signature) {
+  GetMethodSignature()->SetSignature(signature);
+}
+
+void MethodMeta::SetMethodSignature(const MethodSignature *methodSignature) {
+  if (IsEnableParametarType()) {
+    pMethodSignature.SetDataRef(methodSignature);
+  } else {
+    char *signature = methodSignature->GetSignature();
+    SetSignature(signature);
+  }
+}
+
+void MethodMeta::SetAddress(const uintptr_t address) {
+  MethodAddress *pMethodAddress = GetpMethodAddress();
+  pMethodAddress->SetAddr(address);
+}
+
+void MethodMeta::SetAnnotation(const char *annotation) {
+  annotationValue.SetDataRef(annotation);
+}
+
+void MethodMeta::SetDeclaringClass(const MClass &dlClass) {
+  declaringClass.SetDataRef(&dlClass);
+}
+
+void MethodMeta::SetFlag(const uint16_t methodFlag) {
+  flag = methodFlag;
+}
+
+void MethodMeta::SetArgsSize(const uint16_t methodArgSize) {
+  argumentSize = methodArgSize;
+}
+
+void MethodMeta::SetVtabIndex(const int32_t methodVtabIndex) {
+  vtabIndex = methodVtabIndex;
+}
+
+void MethodMeta::GetJavaMethodFullName(std::string &name) const {
+  MClass *cls = GetDeclaringClass();
+  if (cls != nullptr) {
+    cls->GetBinaryName(name);
+  } else {
+    name.append("figo.internal.class");
+  }
+  char *mathodName = GetName();
+  char *sigName = GetSignature();
+  name.append(".").append(mathodName).append(sigName);
+}
+
+void MethodMeta::GetJavaClassName(std::string &name) const {
+  MClass *cls = GetDeclaringClass();
+  if (cls != nullptr) {
+    cls->GetBinaryName(name);
+  } else {
+    name.append("fig.internal.class");
+  }
+}
+
+void MethodMeta::GetJavaMethodName(std::string &name) const {
+  name = GetName();
+}
+
+bool MethodMeta::IsMethodAccessible(const MClass &curClass) const {
+  if (IsPublic() || IsProtected()) {
+    return true;
+  }
+  if (IsPrivate()) {
+    return false;
+  }
+  // package
+  return reflection::IsInSamePackage(curClass, *GetDeclaringClass());
+}
+
+// overrideMethod can be overrided by this method.
+bool MethodMeta::IsOverrideMethod(const MethodMeta &overrideMethod) const {
+  if (&overrideMethod == this) {
+    return true;
+  }
+  if (IsPrivate()) {
+    return false;
+  }
+  DCHECK(!overrideMethod.IsPrivate());
+  if (overrideMethod.IsPublic() || overrideMethod.IsProtected()) {
+    return true;
+  }
+
+  // package
+  return reflection::IsInSamePackage(*overrideMethod.GetDeclaringClass(), *GetDeclaringClass());
+}
+
+void MethodMeta::BuildJValuesArgsFromVaList(jvalue argsJvalue[], va_list args) const {
+  uint32_t parameterSize = GetParameterCount();
+  char retTypeNames[parameterSize];
+  GetShortySignature(retTypeNames, parameterSize);
+  char *result = retTypeNames;
+  DCHECK(argsJvalue != nullptr);
+  for (uint32_t i = 0; i < parameterSize; ++i) {
+    argsJvalue[i].j = 0;
+    switch (result[i]) {
+      case 'Z':
+        argsJvalue[i].z = static_cast<uint8_t>(va_arg(args, int32_t));
+        break;
+      case 'B':
+        argsJvalue[i].b = static_cast<int8_t>(va_arg(args, int32_t));
+        break;
+      case 'C':
+        argsJvalue[i].c = static_cast<uint16_t>(va_arg(args, int32_t));
+        break;
+      case 'S':
+        argsJvalue[i].s = static_cast<int16_t>(va_arg(args, int32_t));
+        break;
+      case 'I':
+        argsJvalue[i].i = va_arg(args, int32_t);
+        break;
+      case 'J':
+        argsJvalue[i].j = static_cast<int64_t>(va_arg(args, int64_t));
+        break;
+      case 'F': {
+        jvalue tmp;
+        tmp.d = va_arg(args, double);
+        argsJvalue[i].f = tmp.f;
+        break;
+      }
+      case 'D':
+        argsJvalue[i].d = va_arg(args, double);
+        break;
+      default:
+        argsJvalue[i].l = va_arg(args, jobject);
+    }
+  }
+}
+
+void MethodMeta::BuildMArrayArgsFromJValues(MArray &targetValue, jvalue args[]) const {
+  uint32_t parameterSize = GetParameterCount();
+  char retTypeNames[parameterSize];
+  GetShortySignature(retTypeNames, parameterSize);
+  char *result = retTypeNames;
+  MObject *obj = nullptr;
+  for (uint32_t i = 0; i < parameterSize; ++i) {
+    switch (result[i]) {
+      case 'B':
+        obj = primitiveutil::BoxPrimitiveJbyte(args[i].b);
+        targetValue.SetObjectElementNoRc(i, obj);
+        break;
+      case 'C':
+        obj = primitiveutil::BoxPrimitiveJchar(args[i].c);
+        targetValue.SetObjectElementNoRc(i, obj);
+        break;
+      case 'D':
+        obj = primitiveutil::BoxPrimitiveJdouble(args[i].d);
+        targetValue.SetObjectElementNoRc(i, obj);
+        break;
+      case 'F':
+        obj = primitiveutil::BoxPrimitiveJfloat(args[i].f);
+        targetValue.SetObjectElementNoRc(i, obj);
+        break;
+      case 'I':
+        obj = primitiveutil::BoxPrimitiveJint(args[i].i);
+        targetValue.SetObjectElementNoRc(i, obj);
+        break;
+      case 'J':
+        obj = primitiveutil::BoxPrimitiveJlong(args[i].j);
+        targetValue.SetObjectElementNoRc(i, obj);
+        break;
+      case 'S':
+        obj = primitiveutil::BoxPrimitiveJshort(args[i].s);
+        targetValue.SetObjectElementNoRc(i, obj);
+        break;
+      case 'Z':
+        obj = primitiveutil::BoxPrimitiveJboolean(args[i].z);
+        targetValue.SetObjectElementNoRc(i, obj);
+        break;
+      default: // default ref
+        obj = reinterpret_cast<MObject*>(args[i].l);
+        targetValue.SetObjectElement(i, obj);
+    }
+  }
+}
+
+void MethodMeta::BuildJValuesArgsFromStackMemeryPrefixSigNature(DecodeStackArgs &args, std::string prefix) {
+  uint32_t parameterSize = GetParameterCount();
+  size_t oldLen = prefix.length();
+  prefix.resize(prefix.length() + parameterSize);
+  char *prefixCStr = const_cast<char*>(prefix.c_str());
+  GetShortySignature(prefixCStr + oldLen, parameterSize);
+  BuildJValuesArgsFromStackMemery(args, prefix);
+}
+
+void MethodMeta::BuildJValuesArgsFromStackMemery(DecodeStackArgs &args, std::string &shorty) {
+  size_t len = shorty.length();
+  for (size_t i = 0; i < len; ++i) {
+    switch (shorty[i]) {
+      case 'F':
+        args.DecodeFloat();
+        break;
+      case 'D':
+        args.DecodeDouble();
+        break;
+      case 'J':
+        args.DecodeInt64();
+        break;
+      case 'L':
+      case '[':
+        args.DecodeReference();
+        break;
+      default:
+        args.DecodeInt32();
+    }
+  }
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mfield.cpp b/src/mrt/maplert/src/mfield.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad54db708b03146397909c46d95c20a9bfaff84c
--- /dev/null
+++ b/src/mrt/maplert/src/mfield.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mfield.h"
+#include "fieldmeta_inline.h"
+#include "chelper.h"
+#include "mrt_well_known.h"
+#include "mclass_inline.h"
+#ifndef UNIFIED_MACROS_DEF
+#define UNIFIED_MACROS_DEF
+#include "unified.macros.def"
+#endif
+
+namespace maplert {
+#ifndef __OPENJDK__
+uint32_t MField::accessFlagsOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FField_3B, accessFlags);
+uint32_t MField::declaringClassOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FField_3B, declaringClass);
+uint32_t MField::fieldMetaIndexOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FField_3B, dexFieldIndex);
+uint32_t MField::offsetOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FField_3B, offset);
+#else
+uint32_t MField::declaringClassOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FField_3B, clazz);
+uint32_t MField::accessFlagsOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FField_3B, modifiers);
+uint32_t MField::fieldMetaIndexOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FField_3B, slot);
+uint32_t MField::nameOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FField_3B, name);
+#endif
+uint32_t MField::typeOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FField_3B, type);
+uint32_t MField::overrideOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FAccessibleObject_3B, override);
+
+MField *MField::NewMFieldObject(const FieldMeta &fieldMeta) {
+  MClass *declaringClass = fieldMeta.GetDeclaringclass();
+  MClass *type = fieldMeta.GetType();
+  if (UNLIKELY(type == nullptr)) {
+    return nullptr;
+  }
+  MClass *fieldClass = WellKnown::GetMClassField();
+  MField *fieldObject = MObject::NewObject(*fieldClass)->AsMField();
+  if (UNLIKELY(fieldObject == nullptr)) {
+    return nullptr;
+  }
+  uint32_t accessFlags = fieldMeta.GetMod();
+  fieldObject->Store<int>(accessFlagsOffset, static_cast<int>(accessFlags), false);
+  fieldObject->StoreObjectOffHeap(declaringClassOffset, declaringClass);
+  uint16_t index = fieldMeta.GetIndex();
+  fieldObject->Store<int>(fieldMetaIndexOffset, index, false);
+  fieldObject->StoreObjectOffHeap(typeOffset, type);
+
+#ifndef __OPENJDK__
+  // set offset
+  int32_t offset =
+      fieldMeta.IsStatic() ? static_cast<int32_t>((fieldMeta.GetStaticAddr() - declaringClass->AsUintptr()))
+                           : static_cast<int32_t>(static_cast<uint32_t>(fieldMeta.GetOffset()));
+  fieldObject->Store<int32_t>(offsetOffset, offset, false);
+  return fieldObject;
+#else
+  ScopedHandles sHandles;
+  ObjHandle<MObject> o(fieldObject);
+  char *fieldName = fieldMeta.GetName();
+  MString *mStringName = MString::InternUtf(std::string(fieldName));
+  fieldObject->StoreObjectNoRc(nameOffset, mStringName);
+  return o.ReturnObj()->AsMField();
+#endif
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mmethod.cpp b/src/mrt/maplert/src/mmethod.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba480795f1f0b60dccc54e99879ba0687fbb63ee
--- /dev/null
+++ b/src/mrt/maplert/src/mmethod.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mmethod.h"
+#include "cpphelper.h"
+#include "mclass_inline.h"
+#include "methodmeta_inline.h"
+#ifndef UNIFIED_MACROS_DEF
+#define UNIFIED_MACROS_DEF
+#include "unified.macros.def"
+#endif
+
+namespace maplert {
+#ifndef __OPENJDK__
+uint32_t MMethod::methodMetaOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FExecutable_3B, artMethod);
+uint32_t MMethod::declaringClassOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FExecutable_3B, declaringClass);
+#else
+uint32_t MMethod::methodDeclaringClassOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FMethod_3B, clazz);
+uint32_t MMethod::methodSlotOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FMethod_3B, slot);
+uint32_t MMethod::methodNameOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FMethod_3B, name);
+uint32_t MMethod::methodReturnTypeOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FMethod_3B, returnType);
+uint32_t MMethod::methodParameterTypesOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FMethod_3B, parameterTypes);
+uint32_t MMethod::methodExceptionTypesOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FMethod_3B, exceptionTypes);
+uint32_t MMethod::methodModifiersOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FMethod_3B, modifiers);
+
+  // constructor
+uint32_t MMethod::constructorDeclaringClassOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FConstructor_3B, clazz);
+uint32_t MMethod::constructorSlotOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FConstructor_3B, slot);
+uint32_t MMethod::constructorParameterTypesOffset =
+    MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FConstructor_3B, parameterTypes);
+uint32_t MMethod::constructorExceptionTypesOffset =
+    MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FConstructor_3B, exceptionTypes);
+uint32_t MMethod::constructorModifiersOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FConstructor_3B, modifiers);
+#endif
+uint32_t MMethod::accessFlagsOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FExecutable_3B, accessFlags);
+uint32_t MMethod::overrideOffset = MRT_FIELD_OFFSET(Ljava_2Flang_2Freflect_2FAccessibleObject_3B, override);
+
+#ifndef __OPENJDK__
+MMethod *MMethod::NewMMethodObject(const MethodMeta &methodMeta) {
+  bool isConsrtuct = methodMeta.IsConstructor();
+  MClass *methodClass = isConsrtuct ? WellKnown::GetMClassConstructor() : WellKnown::GetMClassMethod();
+  MMethod *methodObject = MObject::NewObject(*methodClass)->AsMMethod();
+  uint32_t accessFlags = methodMeta.GetMod();
+  MClass *declearingClass = methodMeta.GetDeclaringClass();
+  methodObject->Store<uint32_t>(accessFlagsOffset, accessFlags, false);
+  methodObject->StoreObjectOffHeap(declaringClassOffset, declearingClass);
+  methodObject->Store<uint64_t>(methodMetaOffset, reinterpret_cast<uint64_t>(&methodMeta), false);
+  return methodObject;
+}
+#else
+MMethod *MMethod::NewMMethodObject(const MethodMeta &methodMeta) {
+  bool isConsrtuct = methodMeta.IsConstructor();
+  MClass *methodClass = isConsrtuct ? WellKnown::GetMClassConstructor() : WellKnown::GetMClassMethod();
+  MMethod *methodObject = MObject::NewObject(*methodClass)->AsMMethod();
+  uint32_t accessFlags = methodMeta.GetMod();
+  MClass *declearingClass = methodMeta.GetDeclaringClass();
+  ScopedHandles sHandles;
+  ObjHandle<MObject> o(methodObject);
+  if (!methodClass->InitClassIfNeeded()) {
+    LOG(FATAL) << "fail do clinit !!! " << "class: " << methodClass->GetName() << maple::endl;
+  }
+  uint32_t dclClzzOffset = isConsrtuct ? constructorDeclaringClassOffset : methodDeclaringClassOffset;
+  uint32_t slotOffset = isConsrtuct ? constructorSlotOffset : methodSlotOffset;
+  uint32_t nameOffset = methodNameOffset;
+  uint32_t returnTypeOffset = methodReturnTypeOffset;
+  uint32_t parameterTypesOffset = isConsrtuct ? constructorParameterTypesOffset : methodParameterTypesOffset;
+  uint32_t exceptionTypesOffset = isConsrtuct ? constructorExceptionTypesOffset : methodExceptionTypesOffset;
+  uint32_t modifiersOffset = isConsrtuct ? constructorModifiersOffset : methodModifiersOffset;
+  accessFlags = isConsrtuct ? accessFlags & (~modifier::kModifierConstructor) : accessFlags;
+  methodObject->StoreObjectOffHeap(dclClzzOffset, declearingClass);
+  uint32_t slot = declearingClass->GetMethodMetaIndex(methodMeta);
+  methodObject->Store<uint32_t>(slotOffset, slot, false);
+  if (!isConsrtuct) {
+    MString *methodNameObj = MString::InternUtf(std::string(methodMeta.GetName()));
+    methodObject->StoreObject(nameOffset, methodNameObj);
+    MClass *retType = methodMeta.GetReturnType();
+    if (retType == nullptr) {
+      return nullptr;
+    }
+    methodObject->StoreObjectOffHeap(returnTypeOffset, retType);
+  }
+  ObjHandle<MArray> parameterTypesArray(methodMeta.GetParameterTypes());
+  if (parameterTypesArray() == nullptr) {
+    return nullptr;
+  }
+  methodObject->StoreObject(parameterTypesOffset, parameterTypesArray.AsArray());
+  ObjHandle<MArray> excetpionArray(methodMeta.GetExceptionTypes());
+  if (excetpionArray() == nullptr) {
+    return nullptr;
+  }
+  methodObject->StoreObject(exceptionTypesOffset, excetpionArray.AsArray());
+  methodObject->Store<int>(modifiersOffset, accessFlags & 0xffff, false);
+  methodObject->Store<int>(accessFlagsOffset, accessFlags, false);
+  return o.ReturnObj()->AsMMethod();
+}
+#endif
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mobject.cpp b/src/mrt/maplert/src/mobject.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2455ce39758b6872b1da6bb5b730745c1b8cc3e1
--- /dev/null
+++ b/src/mrt/maplert/src/mobject.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "fast_alloc_inline.h"
+#include "sizes.h"
+namespace maplert {
+MObject *MObject::SetClass(const MClass &mClass) {
+  if (mClass.HasFinalizer()) {
+    ScopedHandles sHandles;
+    ObjHandle<MObject> newObj(this);
+    MRT_SetJavaClass(newObj.AsRaw(), mClass.AsUintptr());
+    return newObj.ReturnObj();
+  } else {
+    MRT_SetJavaClass(AsUintptr(), mClass.AsUintptr());
+    return this;
+  }
+}
+
+inline MObject *MObject::NewObjectInternal(const MClass &klass, size_t objectSize, bool isJNI) {
+  address_t addr = (*theAllocator).NewObj(objectSize);
+  if (UNLIKELY(addr == 0)) {
+    (*theAllocator).OutOfMemory(isJNI);
+  }
+  MObject *newObj = MObject::Cast<MObject>(addr);
+  if (UNLIKELY(newObj == nullptr)) {
+    CHECK(MRT_HasPendingException()) << "has no OOM exception when new obj is null" << maple::endl;
+    return nullptr;
+  }
+  newObj = newObj->SetClass(klass);
+  return newObj;
+}
+
+MObject *MObject::NewObject(const MClass &klass, size_t objectSize, bool isJNI) {
+  MObject *objAddr = MObject::Cast<MObject>(MRT_TryNewObject(klass.AsUintptr(), objectSize));
+  if (LIKELY(objAddr != nullptr)) {
+    return objAddr;
+  }
+  return NewObjectInternal(klass, objectSize, isJNI);
+}
+
+MObject *MObject::NewObject(const MClass &klass, bool isJNI) {
+  MObject *objAddr = MObject::Cast<MObject>(MRT_TryNewObject(klass.AsUintptr()));
+  if (LIKELY(objAddr != nullptr)) {
+    return objAddr;
+  }
+  size_t objectSize = klass.GetObjectSize();
+  CHECK(klass.IsArrayClass() == false) << "must not Array class." << maple::endl;
+  return NewObjectInternal(klass, objectSize, isJNI);
+}
+
+MObject *MObject::NewObject(const MClass &klass, const MethodMeta *constructor, ...) {
+  va_list args;
+  va_start(args, constructor);
+  if (UNLIKELY(!klass.InitClassIfNeeded())) {
+    va_end(args);
+    return nullptr;
+  }
+  ScopedHandles sHandles;
+  ObjHandle<MObject> obj(NewObject(klass));
+  DCHECK(obj.AsJObj() != nullptr) << "new object fail." << maple::endl;
+  DCHECK(constructor != nullptr) << "MObject::NewObject::constructor is nullptr" << maple::endl;
+  (void)constructor->Invoke<int, calljavastubconst::kVaArg>(obj.AsObject(), &args);
+  va_end(args);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    return nullptr;
+  }
+  return obj.ReturnObj();
+}
+
+MObject *MObject::NewObject(const MClass &klass, const MethodMeta &constructor, const jvalue &args, bool isJNI) {
+  ScopedHandles sHandles;
+  ObjHandle<MObject> obj(NewObject(klass, isJNI));
+  if (UNLIKELY(obj() == 0)) {
+    CHECK(MRT_HasPendingException()) << "has no OOM exception when new obj is null" << maple::endl;
+    return nullptr;
+  }
+  (void)constructor.Invoke<int, calljavastubconst::kJvalue>(obj.AsObject(), &args);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    return nullptr;
+  }
+  return obj.ReturnObj();
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/modifier.cpp b/src/mrt/maplert/src/modifier.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..460af4152bc9fe3c9cf717affcd5126a6572aa7f
--- /dev/null
+++ b/src/mrt/maplert/src/modifier.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "modifier.h"
+
+namespace maplert {
+void modifier::JavaAccessFlagsToString(uint32_t accessFlags, std::string &result) {
+  if ((accessFlags & kModifierPublic) != 0) {
+    result += "public ";
+  }
+  if ((accessFlags & kModifierProtected) != 0) {
+    result += "protected ";
+  }
+  if ((accessFlags & kModifierPrivate) != 0) {
+    result += "private ";
+  }
+  if ((accessFlags & kModifierFinal) != 0) {
+    result += "final ";
+  }
+  if ((accessFlags & kModifierStatic) != 0) {
+    result += "static ";
+  }
+  if ((accessFlags & kModifierAbstract) != 0) {
+    result += "abstract ";
+  }
+  if ((accessFlags & kModifierInterface) != 0) {
+    result += "interface ";
+  }
+  if ((accessFlags & kModifierTransient) != 0) {
+    result += "transient ";
+  }
+  if ((accessFlags & kModifierVolatile) != 0) {
+    result += "volatile ";
+  }
+  if ((accessFlags & kModifierSynchronized) != 0) {
+    result += "synchronized ";
+  }
+  if ((accessFlags & kModifierRCUnowned) != 0) {
+    result += "rcunowned ";
+  }
+  if ((accessFlags & kModifierRCWeak) != 0) {
+    result += "rcweak ";
+  }
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_annotation.cpp b/src/mrt/maplert/src/mrt_annotation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..87a1dca8401974b39589a7eb6a74df937f39f0f2
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_annotation.cpp
@@ -0,0 +1,563 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_annotation.h"
+#include <cstdlib>
+#include <cstdio>
+#include <cstdint>
+#include <cstring>
+#include <cinttypes>
+#include <cctype>
+#include <cassert>
+#include <iostream>
+#include <map>
+#include "jni.h"
+#include "chelper.h"
+#include "mrt_classloader_api.h"
+#include "exception/mrt_exception.h"
+#include "fieldmeta_inline.h"
+#ifndef UNIFIED_MACROS_DEF
+#define UNIFIED_MACROS_DEF
+#include "unified.macros.def"
+#endif
+namespace maplert {
+using namespace annoconstant;
+MObject *AnnotationUtil::GetDeclaredAnnotations(const string annoStr, MClass *classObj) {
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), classObj);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  uint32_t annoNum = static_cast<uint32_t>(parser->ParseNum(kValueInt));
+  uint32_t annoMemberCntArray[annoNum];
+  parser->InitAnnoMemberCntArray(annoMemberCntArray, annoNum);
+  ScopedHandles sHandles;
+  ObjHandle<MArray> prepareAnnotations(MArray::NewObjectArray(annoNum, *WellKnown::GetMClassAAnnotation()));
+  uint16_t realCount = 0;
+  for (uint32_t j = 0; j < annoNum; ++j) {
+    string retArr(parser->ParseStr(kDefParseStrType));
+    if (parser->ExceptAnnotationJudge(retArr) || parser->IsVerificationAnno(retArr)) {
+      // prevent unnecessary annotation objects from being created
+      parser->SkipAnnoMember(annoMemberCntArray[j]);
+      continue;
+    }
+    MClass *annoType = MClass::JniCast(MRT_GetClassByContextClass(*classObj, retArr));
+    if (annoType == nullptr) {
+      LOG(ERROR) << "AnnotationType: " << retArr << " Not Found, Location:GetDeclaredAnnotations" << maple::endl;
+      parser->SkipAnnoMember(annoMemberCntArray[j]);
+      continue;
+    }
+#ifdef __OPENJDK__
+    ObjHandle<MObject> hashMapInst(parser->GenerateMemberValueHashMap(classObj, annoType, annoMemberCntArray[j]));
+    ObjHandle<MObject> proxyInstance(
+        parser->InvokeAnnotationParser(hashMapInst.AsObject(), annoType));
+#else
+    ObjHandle<MObject> proxyInstance(
+        parser->GenerateAnnotationProxyInstance(classObj, annoType, annoMemberCntArray[j]));
+#endif
+    prepareAnnotations->SetObjectElement(realCount, proxyInstance.AsObject());
+    ++realCount;
+  }
+  if (realCount == 0) {
+    AnnotationUtil::UpdateCache(kHasNoDeclaredAnno, classObj, nullptr);
+  }
+  if (annoNum != realCount) {
+    MArray *retAnnotations = reinterpret_cast<MArray*>(
+        MRT_NewObjArray(realCount, *WellKnown::GetMClassAnnotation(), nullptr));
+    for (uint32_t i = 0; i < realCount; ++i) {
+      MObject *obj = prepareAnnotations->GetObjectElementNoRc(i);
+      // obj will be recorded in retAnnotations, no need to use slv.Push
+      retAnnotations->SetObjectElement(i, obj);
+    }
+    return retAnnotations;
+  }
+  return prepareAnnotations.ReturnObj();
+}
+
+bool AnnotationUtil::HasDeclaredAnnotation(MClass *klass, AnnotationClass annoType) {
+  // simply get the klass's raw annotation, and checks for compressed annoType string.
+  std::string annoStr = klass->GetAnnotation();
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), klass);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  const char *annoTypeName = nullptr;
+  if (annoType == kAnnotationInherited) {
+    annoTypeName = kInheritClass;
+  } else if (annoType == kAnnotationRepeatable) {
+    annoTypeName = kRepeatableClasss;
+  }
+
+  if (annoTypeName == nullptr) {
+    return false;
+  }
+  bool ret = parser->Find(annoTypeName) != kNPos;
+  return ret;
+}
+
+jboolean AnnotationUtil::IsDeclaredAnnotationPresent(const string &annoStr, const string &annoTypeName,
+                                                     MClass *currentCls) {
+  VLOG(reflect) << "Enter isDeclaredAnnotationPresent, annoStr: " << annoStr << " annotationTypeName: " <<
+      annoTypeName << maple::endl;
+  if (!AnnoParser::HasAnnoMember(annoStr)) {
+    return JNI_FALSE;
+  }
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), currentCls);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  uint32_t annoNum = static_cast<uint32_t>(parser->ParseNum(kValueInt));
+  uint32_t annoMemberCntArray[annoNum];
+  parser->InitAnnoMemberCntArray(annoMemberCntArray, annoNum);
+  for (uint32_t j = 0; j < annoNum; ++j) {
+    string currentAnnoType = parser->ParseStr(kDefParseStrType);
+    if (currentAnnoType == annoTypeName) {
+      return JNI_TRUE;
+    }
+    parser->SkipAnnoMember(annoMemberCntArray[j]);
+  }
+  return JNI_FALSE;
+}
+
+uint32_t AnnotationUtil::GetRealParaCntForConstructor(const MethodMeta &mthd, const char *kMthdAnnoStr) {
+  MClass *cls = mthd.GetDeclaringClass();
+  if (!mthd.IsConstructor() || cls->IsAnonymousClass()) {
+    return mthd.GetParameterCount();
+  }
+  string annoChar = cls->GetAnnotation();
+  if (annoChar.empty()) {
+    return mthd.GetParameterCount();
+  }
+  constexpr int paramsNum = 2;
+  if (cls->IsEnum()) {
+    if (kMthdAnnoStr != nullptr && kMthdAnnoStr[kLabelSize] == '0') {
+      return mthd.GetParameterCount();
+    }
+    // no implicit arguments for the enclosing instance, so fix for the compiler wrong params num
+    return mthd.GetParameterCount() - paramsNum;
+  }
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoChar.c_str(), cls);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  int32_t loc = parser->Find(parser->GetEnclosingClassStr());
+  if (loc != kNPos) {
+    return mthd.GetParameterCount();
+  }
+  parser->SetIdx(0);
+  if (parser->Find(parser->GetEncsloingMethodClassStr()) != kNPos) {
+    uint32_t outClassFieldNum = 0;
+    FieldMeta *fields = cls->GetFieldMetas();
+    uint32_t numOfFields = cls->GetNumOfFields();
+    for (uint32_t i = 0; i < numOfFields; ++i) {
+      FieldMeta *fieldMeta = &fields[i];
+      string fName = fieldMeta->GetName();
+      if (fName.find("$") != string::npos) {
+        ++outClassFieldNum;
+      }
+    }
+    uint32_t paramNum = mthd.GetParameterCount();
+    return paramNum - outClassFieldNum;
+  }
+  return mthd.GetParameterCount();
+}
+
+std::string AnnotationUtil::GetAnnotationUtil(const char *annotation) {
+  if (annotation == nullptr) {
+    return "";
+  }
+  __MRT_Profile_CString(annotation);
+#ifndef __OPENJDK__
+  if (annotation[0] == '0') {
+    std::string retArray(annotation);
+    DeCompressHighFrequencyStr(retArray);
+    return retArray;
+  }
+#endif
+  return annotation;
+}
+
+CacheItem AnnotationUtil::cache[];
+
+MObject *AnnotationUtil::GetEnclosingClass(MClass *classObj) noexcept {
+  if (classObj->IsProxy()) {
+    return nullptr;
+  }
+  MObject *declaringClass = GetDeclaringClassFromAnnotation(classObj);
+  if (declaringClass != nullptr) {
+    return declaringClass;
+  }
+  string annoChar = classObj->GetAnnotation();
+  if (annoChar.empty()) {
+    return nullptr;
+  }
+  VLOG(reflect) << "Enter __MRT_Reflect_Class_getEnclosingClass, annostr: " << annoChar << maple::endl;
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoChar.c_str(), classObj);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  int32_t emloc = parser->Find(parser->GetEncsloingMethodClassStr());
+  if (emloc == kNPos) {
+    return nullptr;
+  }
+  parser->SkipNameAndType();
+  string methodName = parser->ParseStr(kDefParseStrType);
+  size_t loc = methodName.find("|");
+  if (loc == string::npos) {
+    return nullptr;
+  }
+  return MObject::JniCast(MRT_GetClassByContextClass(*classObj, methodName.substr(0, loc)));
+}
+
+CacheValueType AnnotationUtil::Get(CacheLabel label, MClass *classObj) noexcept {
+  CHECK_E_P(classObj == nullptr, "Get: classObj is nullptr");
+  CacheValueType result = nullptr;
+  bool valid = AnnotationUtil::GetCache(label, classObj, result);
+  if (valid) {
+    return result;
+  }
+  switch (label) {
+    case kEnclosingClass:
+      result = GetEnclosingClass(classObj);
+      break;
+    case kDeclaringClass:
+      result = GetDeclaringClassFromAnnotation(classObj);
+      break;
+    case kDeclaredClasses:
+      result = new set<MClass*>();
+      GetDeclaredClasses(classObj, *reinterpret_cast<set<MClass*>*>(result));
+      break;
+    case kEnclosingMethod:
+      result = GetEnclosingMethod(classObj);
+      break;
+    default: {
+      LOG(ERROR) << "Wrong label in AnnotationUtil::Get" << maple::endl;
+      break;
+    }
+  }
+  UpdateCache(label, classObj, result);
+  return result;
+}
+
+MethodMeta *AnnotationUtil::GetEnclosingMethodValue(MClass *classObj, const std::string &annSet) {
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annSet.c_str(), classObj);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  int32_t loc = parser->Find(parser->GetEncsloingMethodClassStr());
+  if (loc == kNPos) {
+    return nullptr;
+  }
+  parser->SkipNameAndType();
+  std::string buffStr = parser->ParseStr(kDefParseStrType);
+  auto posClassName = buffStr.find("|");
+  auto posMethodName = buffStr.rfind("|");
+  if (posClassName == std::string::npos || posMethodName == std::string::npos) {
+    return nullptr;
+  }
+  std::string className = buffStr.substr(0, posClassName);
+  MClass *classData = MClass::JniCast(MRT_GetClassByContextClass(*classObj, className));
+  CHECK(classData != nullptr) << "GetEnclosingMethodValue : classData is nullptr" << maple::endl;
+  std::string mthName = buffStr.substr(posClassName + 1, posMethodName - posClassName - 1);
+  std::string sigName = buffStr.substr(posMethodName + 1, buffStr.length() - posMethodName - 1);
+  MethodMeta *mth = classData->GetMethod(mthName.c_str(), sigName.c_str());
+  if (mth == nullptr) {
+    return nullptr;
+  }
+  return mth;
+}
+
+jboolean AnnotationUtil::GetIsAnnoPresent(const string &annoStr, const string &annotationTypeName,
+    CacheValueType meta, MClass *annoObj, CacheLabel label) noexcept {
+  DcAnnoPresentKeyType key(meta, reinterpret_cast<CacheValueType>(annoObj));
+  jboolean result = JNI_FALSE;
+  CacheValueType resultP = &result;
+  if (AnnotationUtil::GetCache(label, &key, resultP)) {
+    result = *static_cast<jboolean*>(resultP);
+    return result;
+  }
+  switch (label) {
+    case kClassAnnoPresent:
+      result = IsDeclaredAnnotationPresent(annoStr, annotationTypeName, reinterpret_cast<MClass*>(meta));
+      break;
+    case kMethodAnnoPresent:
+      result = IsDeclaredAnnotationPresent(annoStr, annotationTypeName,
+                                           reinterpret_cast<MethodMeta*>(meta)->GetDeclaringClass());
+      break;
+    case kFieldAnnoPresent:
+      result = IsDeclaredAnnotationPresent(annoStr, annotationTypeName,
+                                           reinterpret_cast<FieldMeta*>(meta)->GetDeclaringclass());
+      break;
+    default:
+      LOG(ERROR) << "Wrong label in AnnotationUtil::GetIsAnnoPresent" << maple::endl;
+  }
+
+  AnnotationUtil::UpdateCache(label, &key, &result);
+  return result;
+}
+
+MethodMeta *AnnotationUtil::GetEnclosingMethod(MClass *argObj) noexcept {
+  string annotationSet = argObj->GetAnnotation();
+  if (annotationSet.empty()) {
+    return nullptr;
+  }
+  VLOG(reflect) << "Enter GetEnclosingMethod, annostr: " << annotationSet << maple::endl;
+  MethodMeta *ret = GetEnclosingMethodValue(argObj, annotationSet);
+  return ret;
+}
+
+bool AnnotationUtil::GetCache(CacheLabel label, CacheValueType target, CacheValueType &result) noexcept {
+  cache[label].lock.Lock();
+  if (label == kHasNoDeclaredAnno) {
+    set<MClass*> *cacheSet = reinterpret_cast<set<MClass*>*>(cache[label].key);
+    if (cacheSet != nullptr && cacheSet->find(reinterpret_cast<MClass*>(target)) != cacheSet->end()) {
+      cache[label].lock.Unlock();
+      return true;
+    }
+    cache[label].lock.Unlock();
+    return false;
+  }
+  if (label == kClassAnnoPresent || label == kMethodAnnoPresent || label == kFieldAnnoPresent) {
+    map<DcAnnoPresentKeyType, jboolean> *cacheMap = reinterpret_cast<
+        map<DcAnnoPresentKeyType, jboolean>*>(cache[label].key);
+
+    if (cacheMap != nullptr) {
+      auto findResult = cacheMap->find(*reinterpret_cast<DcAnnoPresentKeyType*>(target));
+      if (findResult != cacheMap->end()) {
+        cache[label].lock.Unlock();
+        if (result != nullptr) {
+          *static_cast<jboolean*>(result) = findResult->second;
+        }
+        return true;
+      }
+    }
+    cache[label].lock.Unlock();
+    return false;
+  }
+  if (target == cache[label].key) {
+    result = cache[label].value;
+    cache[label].lock.Unlock();
+    return true;
+  }
+  cache[label].lock.Unlock();
+  return false;
+}
+
+void AnnotationUtil::UpdateCache(CacheLabel label, CacheValueType target, CacheValueType result) noexcept {
+  cache[label].lock.Lock();
+  if (label == kHasNoDeclaredAnno) {
+    if (cache[label].key == nullptr) {
+      set<MClass*> *newCache = new set<MClass*>(); // cache, always living
+      cache[label].key = reinterpret_cast<CacheValueType>(newCache);
+    }
+    set<MClass*> *cacheSet = reinterpret_cast<set<MClass*>*>(cache[label].key);
+    if (cacheSet->size() > kRTCacheSize) {
+      cacheSet->clear();
+    }
+    cacheSet->insert(reinterpret_cast<MClass*>(target));
+    cache[label].lock.Unlock();
+    return;
+  }
+
+  if (label == kClassAnnoPresent || label == kMethodAnnoPresent || label == kFieldAnnoPresent) {
+    if (cache[label].key == nullptr) {
+      set<DcAnnoPresentKeyType> *newCache = new set<DcAnnoPresentKeyType>(); // cache, always living
+      cache[label].key = reinterpret_cast<CacheValueType>(newCache);
+    }
+    map<DcAnnoPresentKeyType, jboolean> *cacheMap =
+        reinterpret_cast<map<DcAnnoPresentKeyType, jboolean>*>(cache[label].key);
+    if (cacheMap->size() > kRTCacheSize) {
+      cacheMap->clear();
+    }
+    DcAnnoPresentKeyType tmp = *reinterpret_cast<DcAnnoPresentKeyType*>(target);
+    (*cacheMap)[tmp] = *reinterpret_cast<jboolean*>(result);
+    cache[label].lock.Unlock();
+    return;
+  }
+
+  cache[label].key = target;
+  if (label == kDeclaredClasses && cache[label].value != nullptr) {
+    delete static_cast<set<MClass*>*>(cache[label].value);
+  }
+  cache[label].value = result;
+  cache[label].lock.Unlock();
+}
+
+MObject *AnnotationUtil::GetDeclaringClassFromAnnotation(MClass *classObj) noexcept {
+  string annoStr = classObj->GetAnnotation();
+  if (annoStr.empty()) {
+    return nullptr;
+  }
+  VLOG(reflect) << "Enter getDeclaringClassFromAnnotation, annostr: " << annoStr << maple::endl;
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), classObj);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  int32_t loc = parser->Find(parser->GetEnclosingClassStr());
+  if (loc == kNPos) {
+    return nullptr;
+  }
+  parser->SkipNameAndType();
+  string retStr = parser->ParseStr(kDefParseStrType);
+  return MObject::JniCast(MRT_GetClassByContextClass(*classObj, retStr));
+}
+
+void AnnotationUtil::GetDeclaredClasses(MClass *classObj, std::set<MClass*> &metaList) noexcept {
+  string annoStr = classObj->GetAnnotation();
+  if (annoStr.empty()) {
+    return;
+  }
+  VLOG(reflect) << "Enter getDeclaredClasses, annoStr: " << annoStr << maple::endl;
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), classObj);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  int32_t loc = parser->Find(parser->GetMemberClassesStr());
+  if (loc == kNPos) {
+    return;
+  }
+  int32_t lloc = parser->Find(parser->GetAnnoArrayStartDelimiter());
+  if (lloc == kNPos) {
+    return;
+  }
+
+  uint32_t annoNum = static_cast<uint32_t>(parser->ParseNum(kValueInt));
+  parser->SkipNameAndType();
+  for (uint32_t j = 0; j < annoNum; ++j) {
+    string retArr = parser->ParseStr(kDefParseStrType);
+    metaList.insert(MClass::JniCast(MRT_GetClassByContextClass(*classObj, retArr)));
+  }
+}
+
+MObject *MethodDefaultUtil::GetDefaultPrimValue(const std::unique_ptr<AnnoParser> &uniqueParser, uint32_t type) {
+  switch (type) {
+    case kValueInt:
+      return primitiveutil::BoxPrimitiveJint(static_cast<jint>(uniqueParser->ParseNum(kValueInt)));
+    case kValueShort:
+      return primitiveutil::BoxPrimitiveJshort(uniqueParser->ParseNum(kValueShort));
+    case kValueChar:
+      return primitiveutil::BoxPrimitiveJchar(uniqueParser->ParseNum(kValueShort));
+    case kValueByte:
+      return primitiveutil::BoxPrimitiveJbyte(uniqueParser->ParseNum(kValueShort));
+    case kValueBoolean:
+      return primitiveutil::BoxPrimitiveJboolean(uniqueParser->ParseNum(kValueShort));
+    case kValueLong:
+      return primitiveutil::BoxPrimitiveJlong(uniqueParser->ParseNum(kValueLong));
+    case kValueFloat:
+      return primitiveutil::BoxPrimitiveJfloat(uniqueParser->ParseDoubleNum(kValueFloat));
+    case kValueDouble:
+      return primitiveutil::BoxPrimitiveJdouble(uniqueParser->ParseDoubleNum(kValueDouble));
+    default:
+      LOG(FATAL) << "Unexpected primitive type: " << type;
+  }
+  return nullptr;
+}
+
+MObject *MethodDefaultUtil::GetDefaultEnumValue(const std::unique_ptr<AnnoParser> &uniqueParser) {
+  MClass *enumType = methodMeta.GetReturnType();
+  if (enumType == nullptr) {
+    return nullptr;
+  }
+  string retArr = uniqueParser->ParseStr(kDefParseStrType);
+  FieldMeta *fieldMeta = enumType->GetDeclaredField(retArr.c_str());
+  CHECK_E_P(fieldMeta == nullptr, "GetDefaultEnumValue() : fieldMeta is nullptr.");
+  return fieldMeta->GetObjectValue(nullptr);
+}
+
+MObject *MethodDefaultUtil::GetDefaultAnnotationValue(const std::unique_ptr<AnnoParser> &uniqueParser) {
+  uint32_t memberNum = static_cast<uint32_t>(uniqueParser->ParseNum(kValueInt));
+  string retArr = uniqueParser->ParseStr(kDefParseStrType);
+  MClass *annoClass = MClass::JniCast(MRT_GetClassByContextClass(*declClass, retArr));
+  CHECK(annoClass != nullptr) << "GetDefaultAnnotationValue : annoClass is nullptr" << maple::endl;
+#ifdef __OPENJDK__
+  ScopedHandles sHandles;
+  ObjHandle<MObject> hashMapRef(uniqueParser->GenerateMemberValueHashMap(declClass, annoClass, memberNum));
+  MObject *proxyInstance = uniqueParser->InvokeAnnotationParser(hashMapRef(), annoClass);
+#else
+  MObject *proxyInstance = uniqueParser->GenerateAnnotationProxyInstance(declClass, annoClass, memberNum);
+#endif
+  return proxyInstance;
+}
+
+MObject *MethodDefaultUtil::GetDefaultValue(const std::unique_ptr<AnnoParser> &uniqueParser) {
+  uint32_t type = static_cast<uint32_t>(uniqueParser->ParseNum(kValueInt));
+  string retArr;
+  switch (type) {
+    case kValueInt:
+    case kValueShort:
+    case kValueChar:
+    case kValueByte:
+    case kValueBoolean:
+    case kValueLong:
+    case kValueFloat:
+    case kValueDouble:
+      return GetDefaultPrimValue(uniqueParser, type);
+    case kValueType:
+      retArr = uniqueParser->ParseStr(kDefParseStrType);
+      return MObject::JniCast(MRT_GetClassByContextClass(*declClass, retArr));
+    case kValueString: {
+      if (uniqueParser->GetCurrentChar() == ']') { // valid for AnnoAsciiParser
+        uniqueParser->IncIdx(1); // skip ']'
+      }
+      retArr = uniqueParser->ParseStr(kDefParseStrType);
+      return NewStringFromUTF16(retArr);
+    }
+    case kValueArray: {
+#ifdef __OPENJDK__
+      MObject *ret = uniqueParser->CaseArray(declClass, declClass, methodMeta);
+#else
+      ArgValue val(0);
+      MObject *ret = uniqueParser->CaseArray(declClass, declClass, val, methodMeta);
+#endif
+      return ret;
+    }
+    case kValueAnnotation:
+      return GetDefaultAnnotationValue(uniqueParser);
+    case kValueEnum:
+      return GetDefaultEnumValue(uniqueParser);
+    default:
+      LOG(FATAL) << "ParserType Not Found." << maple::endl;
+  }
+  return nullptr;
+}
+
+bool MethodDefaultUtil::HasDefaultValue(const char *methodName, AnnoParser &parser) {
+  parser.SkipNameAndType();
+  int64_t defaultNum = parser.ParseNum(kValueInt);
+  parser.NextItem(kDefSkipItemNum);
+  string str;
+  int64_t idx;
+  for (idx = 0; idx < defaultNum; ++idx) {
+    str = parser.ParseStr(kDefParseStrType);
+    if (str == methodName) {
+      break;
+    }
+    parser.SkipNameAndType();
+  }
+  if (idx == defaultNum) {
+    return false;
+  }
+  return true;
+}
+
+#ifndef __OPENJDK__
+// use char array rather than map for it have too much overhead
+namespace {
+constexpr uint8_t kMapSize = 7;
+constexpr uint8_t kKeySize = 4;
+constexpr uint8_t kValueSize = 34;
+constexpr char kHighFrequencyKey[kMapSize][kKeySize] = { "`IH", "`RP", "`Cl", "`Oj", "`ST", "`AF", "`VL" };
+constexpr char kHighFrequencyValue[kMapSize][kValueSize] = {
+    "Ljava/lang/annotation/Inherited;",
+    "Ljava/lang/annotation/Repeatable;", "Ljava/lang/Class", "Ljava/lang/Object;",
+    "Ljava/lang/String;", "accessFlags", "value"
+};
+}
+
+void AnnotationUtil::DeCompressHighFrequencyStr(string &str) {
+  constexpr uint8_t constCompressSize = 3;
+  size_t highFrequencyValueSize[kMapSize];
+  for (int i = 0; i < kMapSize; ++i) {
+    size_t loc = str.find(kHighFrequencyKey[i]);
+    while (loc != string::npos) {
+      str.replace(loc, constCompressSize, kHighFrequencyValue[i]);
+      loc = str.find(kHighFrequencyKey[i], loc + highFrequencyValueSize[i]);
+    }
+  }
+}
+#endif
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_annotation_parser.cpp b/src/mrt/maplert/src/mrt_annotation_parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..33644219096e8eed4dbd45e9a991b7c1317e4310
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_annotation_parser.cpp
@@ -0,0 +1,1445 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_annotation_parser.h"
+#include <cstdlib>
+#include <cstdio>
+#include <cstdint>
+#include <cstring>
+#include <cinttypes>
+#include <cctype>
+#include <cassert>
+#include <iostream>
+#include <map>
+#include <algorithm>
+#include "jni.h"
+#include "chelper.h"
+#include "mmethod_inline.h"
+#include "exception/mrt_exception.h"
+#include "mrt_classloader_api.h"
+#include "file_layout.h"
+
+namespace maplert {
+using namespace annoconstant;
+std::set<std::string> AnnoIndexParser::exceptIndexSet = {
+    kEncosilngClassIndex,
+    kInnerClassIndex,
+    kMemberClassesIndex,
+    kThrowsClassIndex,
+    kSignatureClassIndex,
+    kEncsloingMethodClassIndex,
+    kRepeatableClasssIndex,
+    kInheritClassIndex
+};
+
+std::set<std::string> AnnoAsciiParser::exceptAsciiSet = {
+    kEncosilngClass,
+    kInnerClass,
+    kMemberClasses,
+    kThrowsClass,
+    kSignatureClass,
+    kEncsloingMethodClass,
+    kRepeatableClasss,
+    kInheritClass
+};
+
+// Parameter::init need 4 params
+enum ParameterIdx : int8_t {
+  kParaNamePos,
+  kParaModifiersPos,
+  kParaExecutablePos,
+  kParaIndexPos,
+  kParaSize
+};
+
+AnnoParser::~AnnoParser() {
+  annoStr = nullptr;
+  declaringClass = nullptr;
+  if (strTab != nullptr) {
+    delete strTab;
+    strTab = nullptr;
+  }
+}
+
+std::string AnnoParser::RemoveParameterAnnoInfo(std::string &annoStr) {
+  size_t size = annoStr.size();
+  if (size != 0) {
+    for (size_t i = size - 1; i > 0; --i) {
+      if (annoStr[i] == '|') {
+        return annoStr.substr(0, i);
+      }
+    }
+  }
+  return "";
+}
+
+MObject *AnnoParser::AllocAnnoObject(MClass *classObj, MClass *annoClass) {
+  if (GetStr() == nullptr || annoClass == nullptr) {
+    return nullptr;
+  }
+  uint32_t annoNum = static_cast<uint32_t>(ParseNum(kValueInt));
+  if (annoNum == 0) {
+    return nullptr;
+  }
+  bool findLabel = false;
+  uint32_t whichAnno = 0;
+  uint32_t annoMemberCntArray[annoNum];
+  InitAnnoMemberCntArray(annoMemberCntArray, annoNum);
+  char *annotationName = annoClass->GetName();
+  for (uint32_t i = 0; i < annoNum; ++i) {
+    string currentAnnoName = ParseStr(kDefParseStrType);
+    if (currentAnnoName.compare(annotationName) == 0 && !IsVerificationAnno(currentAnnoName)) {
+      whichAnno = i;
+      findLabel = true;
+      break;
+    } else {
+      SkipAnnoMember(annoMemberCntArray[i]);
+    }
+  }
+  if (!findLabel) {
+    return nullptr;
+  }
+#ifdef __OPENJDK__
+  ScopedHandles sHandles;
+  ObjHandle<MObject> hashMapInst(GenerateMemberValueHashMap(classObj, annoClass, annoMemberCntArray[whichAnno]));
+  MObject *ret = InvokeAnnotationParser(hashMapInst(), annoClass);
+#else
+  MObject *ret = GenerateAnnotationProxyInstance(classObj, annoClass, annoMemberCntArray[whichAnno]);
+#endif
+  return ret;
+}
+
+std::string AnnoParser::GetParameterAnnotationInfo(const std::string &entireStr) {
+  std::string annoStr;
+  if (!IsIndexParser(entireStr.c_str())) {
+    annoStr = AnnoAsciiParser::GetParameterAnnotationInfoAscii(entireStr);
+    *annoStr.begin() = annoconstant::kOldMetaLabel;
+  } else {
+    annoStr = AnnoIndexParser::GetParameterAnnotationInfoIndex(entireStr);
+    *annoStr.begin() = annoconstant::kNewMetaLabel;
+  }
+  return annoStr;
+}
+
+MObject *AnnoParser::GetAnnotationNative(int32_t index, const MClass *annoClass) {
+  uint32_t annoNum = static_cast<uint32_t>(ParseNum(kValueInt));
+  uint32_t paramNumArray[annoNum];
+  uint32_t annoMemberCntArray[annoNum];
+  InitAnnoMemberCntArray(annoMemberCntArray, annoNum);
+  for (uint32_t i = 0; i < annoNum; ++i) {
+    paramNumArray[i] = static_cast<uint32_t>(ParseNum(kValueInt)) + 1;
+  }
+  bool haveIndexFlag = false;
+  for (int32_t i = 0; i < (int32_t)annoNum; ++i) {
+    if (static_cast<int32_t>(paramNumArray[i]) - 1 == index) {
+      haveIndexFlag = true;
+    }
+  }
+  if (!haveIndexFlag) {
+    return nullptr;
+  }
+  CHECK_E_P(annoClass == nullptr, "AnnoParser::GetAnnotationNative : annoClass is nullptr");
+  for (uint32_t i = 0; i < annoNum; ++i) {
+    if (paramNumArray[i] - 1 == static_cast<uint32_t>(index)) {
+      string currentAnnoName = ParseStr(kDefParseStrType);
+      if (currentAnnoName != annoClass->GetName()) {
+        // skip an annotationMember Info
+        SkipAnnoMember(annoMemberCntArray[i]);
+        continue;
+      }
+      MClass *annoType = MClass::JniCast(MRT_GetClassByContextClass(*annoClass, currentAnnoName));
+      if (annoType == nullptr) {
+        return nullptr;
+      }
+#ifdef __OPENJDK__
+      ScopedHandles sHandles;
+      ObjHandle<MObject> hashMapInst(GenerateMemberValueHashMap(declaringClass, annoType, annoMemberCntArray[i]));
+      MObject *proxyInstance = InvokeAnnotationParser(hashMapInst.AsObject(), annoType);
+#else
+      MObject *proxyInstance = GenerateAnnotationProxyInstance(declaringClass, annoType, annoMemberCntArray[i]);
+#endif
+      return proxyInstance;
+    }
+    else {
+      constexpr int8_t annoCountFlagNum = 1;
+      constexpr int8_t annoMemberComponentNum = 3;
+      NextItem(annoCountFlagNum + annoMemberComponentNum * annoMemberCntArray[i]); // skip an annotationinfo
+    }
+  }
+  return nullptr;
+}
+
+MObject *AnnoParser::GetParameterAnnotationsNative(const MethodMeta *methodMeta) {
+  string paramAnnoInfo = AnnoParser::GetParameterAnnotationInfo(methodMeta->GetAnnotation());
+  uint32_t annoNum = static_cast<uint32_t>(ParseNum(kValueInt));
+  uint32_t paramNum = AnnotationUtil::GetRealParaCntForConstructor(*methodMeta, paramAnnoInfo.c_str());
+  uint32_t paramNumArray[paramNum];
+  std::fill(paramNumArray, paramNumArray + paramNum, 0);
+  uint32_t annoMemberCntArray[annoNum];
+  InitAnnoMemberCntArray(annoMemberCntArray, annoNum);
+  for (uint32_t i = 0; i < annoNum; ++i) {
+    paramNumArray[ParseNum(kValueInt)]++;
+  }
+  uint32_t annoMemberCntArrayIdx = 0;
+  ScopedHandles sHandles;
+  ObjHandle<MArray> twoDimAnnos(MArray::NewObjectArray(paramNum, *WellKnown::GetMClassAAAnnotation()));
+  for (uint32_t i = 0; i < paramNum; ++i) {
+    if (paramNumArray[i] > 0) {
+      uint32_t index = 0;
+      ObjHandle<MArray> OneDimAnnos(MRT_NewObjArray(paramNumArray[i], *WellKnown::GetMClassAnnotation(), nullptr));
+      for (uint32_t j = 0; j < paramNumArray[i]; ++j) {
+        string retArr = ParseStr(kDefParseStrType);
+        MClass *annotationInfo = MClass::JniCast(MRT_GetClassByContextClass(*declaringClass, retArr));
+        if (annotationInfo == nullptr) {
+          return nullptr;
+        }
+#ifdef __OPENJDK__
+        ObjHandle<MObject> hashMapInst(GenerateMemberValueHashMap(declaringClass,
+            annotationInfo, annoMemberCntArray[annoMemberCntArrayIdx]));
+        ObjHandle<MObject> proxyInstance(InvokeAnnotationParser(hashMapInst.AsObject(), annotationInfo));
+#else
+        ObjHandle<MObject> proxyInstance(GenerateAnnotationProxyInstance(declaringClass,
+            annotationInfo, annoMemberCntArray[annoMemberCntArrayIdx]));
+#endif
+        ++annoMemberCntArrayIdx;
+        if (!proxyInstance()) {
+          return nullptr;
+        }
+        OneDimAnnos->SetObjectElement(index++, proxyInstance.AsObject());
+      }
+      twoDimAnnos->SetObjectElement(i, OneDimAnnos.AsObject());
+    } else {
+      ObjHandle<MArray> OneDimAnnos(MArray::NewObjectArray(0, *WellKnown::GetMClassAAnnotation()));
+      twoDimAnnos->SetObjectElement(i, OneDimAnnos.AsObject());
+    }
+  }
+  return twoDimAnnos.ReturnObj();
+}
+
+template<typename PrimType>
+void SetPrimArrayContent(const MObject *retInArray, AnnoParser &parser,
+                         uint32_t subArrayLength, uint8_t parseType, bool isFloat = false) {
+  CHECK_E_V(retInArray == nullptr, "SetPrimArrayContent: retInArray is nullptr");
+  MObject **p = reinterpret_cast<MObject**>(
+      reinterpret_cast<MArray*>(const_cast<MObject*>(retInArray))->ConvertToCArray());
+  parser.NextItem(kDefSkipItemNum);
+  PrimType *newP = reinterpret_cast<PrimType*>(p);
+  if (isFloat) {
+    for (uint32_t i = 0; i < subArrayLength; ++i) {
+      newP[i] = static_cast<PrimType>(parser.ParseDoubleNum(parseType));
+    }
+  } else {
+    for (uint32_t i = 0; i < subArrayLength; ++i) {
+      newP[i] = static_cast<PrimType>(parser.ParseNum(parseType));
+    }
+  }
+}
+
+#ifdef __OPENJDK__
+enum XregValIdx : uint8_t {
+  kAnnoInfoIdx = 0,
+  kHashMapInstIdx,
+  kXregValSize
+};
+enum ArgIdx : uint8_t {
+  kMapObjIdx = 0,
+  kKeyIdx,
+  kValueIdx,
+  kArgSize
+};
+
+class AnnoHashMapFactory {
+ public:
+  AnnoHashMapFactory(MClass *annoCls, MClass *dCls, AnnoParser &p)
+      : annoType(annoCls), classInfo(dCls), parser(p) {
+  }
+
+  ~AnnoHashMapFactory() = default;
+
+  MethodMeta *GetDefineMethod(const string &annoMemberName) {
+    MethodMeta *methodMetas = annoType->GetMethodMetas();
+    uint32_t numOfFields = annoType->GetNumOfMethods();
+    for (uint32_t methodIndex = 0; methodIndex < numOfFields; ++methodIndex) {
+      MethodMeta *methodMeta = &(methodMetas[methodIndex]);
+      if (methodMeta->GetName() == annoMemberName) {
+        return methodMeta;
+      }
+    }
+    return nullptr;
+  }
+
+  void GetPrimValue(jvalue &xregVal, uint32_t annoFlag) {
+    switch (annoFlag) {
+      case kValueChar:
+        (&xregVal)[kValueIdx].l =
+            reinterpret_cast<jobject>(primitiveutil::BoxPrimitiveJchar(parser.ParseNum(kValueShort)));
+        break;
+      case kValueInt:
+        (&xregVal)[kValueIdx].l = reinterpret_cast<jobject>(
+            primitiveutil::BoxPrimitiveJint(static_cast<int32_t>(parser.ParseNum(kValueInt))));
+        break;
+      case kValueShort:
+        (&xregVal)[kValueIdx].l =
+            reinterpret_cast<jobject>(primitiveutil::BoxPrimitiveJshort(parser.ParseNum(kValueShort)));
+        break;
+      case kValueByte:
+        (&xregVal)[kValueIdx].l =
+            reinterpret_cast<jobject>(primitiveutil::BoxPrimitiveJbyte(parser.ParseNum(kValueShort)));
+        break;
+      case kValueLong:
+        (&xregVal)[kValueIdx].l =
+           reinterpret_cast<jobject>(primitiveutil::BoxPrimitiveJlong(parser.ParseNum(kValueLong)));
+        break;
+      case kValueFloat:
+        (&xregVal)[kValueIdx].l = reinterpret_cast<jobject>(
+            primitiveutil::BoxPrimitiveJfloat(parser.ParseDoubleNum(kValueFloat)));
+        break;
+      case kValueDouble:
+        (&xregVal)[kValueIdx].l = reinterpret_cast<jobject>(
+            primitiveutil::BoxPrimitiveJdouble(parser.ParseDoubleNum(kValueDouble)));
+        break;
+      default:
+        LOG(FATAL) << "annoFlag Not Found." << maple::endl;
+    }
+  }
+
+  void GetAnnoValue(jvalue &xregVal) {
+    uint32_t subAnnoMemberNum = static_cast<uint32_t>(parser.ParseNum(kValueInt));
+    string retArr = parser.ParseStr(kDefParseStrType);
+    ScopedHandles sHandles;
+    MClass *annoInfo = MClass::JniCast(MRT_GetClassByContextClass(*classInfo, retArr));
+    CHECK(annoInfo) << "annoInfo is nullptr" << std::endl;
+    ObjHandle<MObject> hashMapIns(parser.GenerateMemberValueHashMap(classInfo, annoInfo, subAnnoMemberNum));
+    MObject *proxyInstance = parser.InvokeAnnotationParser(hashMapIns.AsObject(), annoInfo);
+    (&xregVal)[kValueIdx].l = reinterpret_cast<jobject>(proxyInstance);
+  }
+
+  void GetBooleanValue(jvalue &xregVal) {
+    jboolean value = parser.ParseNum(kValueInt) == 1 ? JNI_TRUE : JNI_FALSE;
+    (&xregVal)[kValueIdx].l = reinterpret_cast<jobject>(primitiveutil::BoxPrimitiveJboolean(value));
+  }
+
+  void GetEnumValue(jvalue &xregVal, string &annoMemberName) {
+    string valStr = parser.ParseStr(kDefParseStrType);
+    MethodMeta *method = GetDefineMethod(annoMemberName);
+    if (method == nullptr) {
+      return;
+    }
+    MClass *retType = method->GetReturnType();
+    CHECK(retType != nullptr) << "GetEnumValue : GetReturnType return nullptr" << maple::endl;
+    FieldMeta *fieldMeta = retType->GetDeclaredField(valStr.c_str());
+    CHECK(fieldMeta != nullptr) << "GetEnumValue : GetDeclaredField return nullptr" << maple::endl;
+    (&xregVal)[kValueIdx].l = fieldMeta->GetObjectValue(nullptr)->AsJobject();
+  }
+
+  void GetValue(jvalue &xregVal, uint32_t annoFlag, string &annoMemberName) {
+    switch (annoFlag) {
+      case kValueString: {
+        string valStr = parser.ParseStr(kDefParseStrType);
+        (&xregVal)[kValueIdx].l = reinterpret_cast<jobject>(NewStringFromUTF16(valStr.c_str()));
+        break;
+      }
+      case kValueChar:
+      case kValueInt:
+      case kValueShort:
+      case kValueByte:
+      case kValueLong:
+      case kValueFloat:
+      case kValueDouble:
+        GetPrimValue(xregVal, annoFlag);
+        break;
+      case kValueAnnotation:
+        GetAnnoValue(xregVal);
+        break;
+      case kValueArray: {
+        MethodMeta *defineMethod = GetDefineMethod(annoMemberName);
+        CHECK(defineMethod != nullptr) << "GetDefineMethod return nullptr" << maple::endl;
+        (&xregVal)[kValueIdx].l = reinterpret_cast<jobject>(parser.CaseArray(classInfo, annoType, *defineMethod));
+        break;
+      }
+      case kValueType: {
+        string valStr = parser.ParseStr(kDefParseStrType);
+        MClass *typeVal = MClass::JniCast(MRT_GetClassByContextClass(*classInfo, valStr));
+        (&xregVal)[kValueIdx].l = reinterpret_cast<jobject>(typeVal);
+        break;
+      }
+      case kValueEnum:
+        GetEnumValue(xregVal, annoMemberName);
+        break;
+      case kValueBoolean:
+        GetBooleanValue(xregVal);
+        break;
+      default: {
+        LOG(ERROR) << "GenerateMemberValueHashMap decode error: " << maple::endl;
+      }
+    }
+  }
+ private:
+  MClass *annoType;
+  MClass *classInfo;
+  AnnoParser &parser;
+};
+
+MObject *AnnoParser::GenerateMemberValueHashMap(MClass *classInfo, MClass *annotationInfo, uint32_t memberNum) {
+  ScopedHandles sHandles;
+  MClass *hashMapCls = WellKnown::GetMClassHashMap();
+  MethodMeta *hashMapConstruct = hashMapCls->GetDeclaredConstructor("()V");
+  ObjHandle<MObject> hashMapInst(MObject::NewObject(*hashMapCls, hashMapConstruct));
+  if (memberNum == 0) {
+    return reinterpret_cast<MObject*>(hashMapInst.Return());
+  }
+  MethodMeta *insertMthd = hashMapCls->GetDeclaredMethod("put",
+      "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+  CHECK(insertMthd != nullptr) << "__MRT_Reflect_GetCharDeclaredMethod return nullptr" << maple::endl;
+  jvalue xregVal[kArgSize]; // map_obj, key , value
+  xregVal[kMapObjIdx].l = reinterpret_cast<jobject>(hashMapInst());
+  AnnoHashMapFactory factory(annotationInfo, classInfo, *this);
+  for (uint32_t i = 0; i < memberNum; ++i) {
+    string annoMemberName = ParseStr(kDefParseStrType);
+    ObjHandle<MString> memberNameJ(NewStringFromUTF16(annoMemberName.c_str()));
+    xregVal[kKeyIdx].l = memberNameJ.AsJObj();
+    uint32_t annoType = static_cast<uint32_t>(ParseNum(kValueInt));
+    factory.GetValue(*xregVal, annoType, annoMemberName);
+    ObjHandle<MString> keepAlive(xregVal[kValueIdx].l);
+    constexpr int zeroConst = 0;
+    RuntimeStub<MObject*>::SlowCallCompiledMethod(insertMthd->GetFuncAddress(), xregVal, zeroConst, zeroConst);
+  }
+  return reinterpret_cast<MObject*>(hashMapInst.Return());
+}
+
+class AnnoArrayMemberFactory {
+ public:
+  AnnoArrayMemberFactory(MClass *cls, AnnoParser &par, MClass *annoCls, MethodMeta &mthd)
+      : classInfo(cls), parser(par), annotationInfo(annoCls), mthdObj(mthd) {
+    subArrayLength = static_cast<uint16_t>(parser.ParseNum(kValueInt));
+  }
+
+  ~AnnoArrayMemberFactory() = default;
+
+  MObject *GetZeroLenArray() noexcept {
+    MClass *returnType = mthdObj.GetReturnType();
+    CHECK_E_P(returnType == nullptr, "GetZeroLenArray() : GetReturnType() return nullptr.");
+    MArray *realRetArray = MArray::NewObjectArray(0, *returnType);
+    return reinterpret_cast<MObject*>(realRetArray);
+  }
+
+  MObject *GetAnnotationTypeValue() noexcept {
+    ScopedHandles sHandles;
+    ObjHandle<MArray> realRetArray(reinterpret_cast<address_t>(
+        parser.GenerateAnnotationTypeValue(classInfo, annotationInfo, subArrayLength)));
+    constexpr size_t skipStep = 2;
+    parser.IncIdx(skipStep); // skip ']!'
+    return reinterpret_cast<MObject*>(realRetArray.Return());
+  }
+
+  MObject *GetStringTypeArray() noexcept {
+    ScopedHandles sHandles;
+    ObjHandle<MArray> retInArray(MRT_NewObjArray(subArrayLength, *WellKnown::GetMClassString(), nullptr));
+    parser.NextItem(kDefSkipItemNum);
+    MArray *mArray = retInArray.AsArray();
+    for (uint16_t i = 0; i < subArrayLength; ++i) {
+      string valStr = parser.ParseStr(kDefParseStrType);
+      MString *memberVal = NewStringFromUTF16(valStr.c_str());
+      mArray->SetObjectElementNoRc(i, memberVal);
+    }
+    return reinterpret_cast<MObject*>(retInArray.Return());
+  }
+
+  MObject *GetTypeTypeArray() noexcept {
+    ScopedHandles sHandles;
+    MClass *type = mthdObj.GetReturnType();
+    CHECK_E_P(type == nullptr, "GetTypeTypeArray() : GetReturnType() return nullptr.");
+    ObjHandle<MArray> retInArray(MArray::NewObjectArray(subArrayLength, *type));
+    parser.NextItem(kDefSkipItemNum);
+    for (uint16_t i = 0; i < subArrayLength; ++i) {
+      string valStr = parser.ParseStr(kDefParseStrType);
+      MObject *clType = reinterpret_cast<MObject*>(MRT_GetClassByContextClass(*annotationInfo, valStr));
+      if (clType == nullptr) {
+        return nullptr;
+      }
+      retInArray->SetObjectElement(i, clType);
+    }
+    return retInArray.ReturnObj();
+  }
+
+  template<class jType>
+  MObject *GetPrimiTypeArray(MClass *primType, uint8_t parseType) noexcept {
+    MObject *retInArray = reinterpret_cast<MObject*>(MRT_NewArray(subArrayLength, *primType, sizeof(jType)));
+    SetPrimArrayContent<jType>(retInArray, parser, subArrayLength, parseType);
+    return retInArray;
+  }
+
+  template<class jType>
+  MObject *GetFloatPrimiTypeArray(MClass *primType, uint8_t parseType) noexcept {
+    MObject *retInArray = reinterpret_cast<MObject*>(MRT_NewArray(subArrayLength, *primType, sizeof(jType)));
+    SetPrimArrayContent<jType>(retInArray, parser, subArrayLength, parseType, true);
+    return retInArray;
+  }
+
+  MObject *GetEnumTypeArray() noexcept {
+    ScopedHandles sHandles;
+    parser.NextItem(kDefSkipItemNum);
+    MClass *returnType = mthdObj.GetReturnType();
+    CHECK_E_P(returnType == nullptr, "GetEnumTypeArray() : GetReturnType() return nullptr.");
+    MClass *enumType = returnType->GetComponentClass();
+    MArray *mArray = MArray::NewObjectArray(subArrayLength, *returnType);
+    ObjHandle<MArray> retInArray(mArray);
+    for (int32_t j = 0; j < subArrayLength; ++j) {
+      string valStr = parser.ParseStr(kDefParseStrType);
+      FieldMeta *fieldMeta = enumType->GetDeclaredField(valStr.c_str());
+      MObject *newObj = fieldMeta->GetObjectValue(nullptr);
+      mArray->SetObjectElementNoRc(j, newObj);
+    }
+    return reinterpret_cast<MObject*>(retInArray.Return());
+  }
+
+  MObject *GetBooleanTypeArray() noexcept {
+    MObject *retInArray = reinterpret_cast<MObject*>(
+        MRT_NewArray(subArrayLength, *WellKnown::GetMClassZ(), sizeof(jboolean)));
+    jboolean *p = reinterpret_cast<jboolean*>(reinterpret_cast<MArray*>(retInArray)->ConvertToCArray());
+    parser.NextItem(kDefSkipItemNum);
+    for (uint16_t i = 0; i < subArrayLength; ++i) {
+      p[i] = parser.ParseNum(kValueInt) == 1 ? JNI_TRUE : JNI_FALSE;
+    }
+    return retInArray;
+  }
+
+  uint16_t GetArrayLength() const noexcept {
+    return subArrayLength;
+  }
+
+ private:
+  MClass *classInfo;
+  AnnoParser &parser;
+  MClass *annotationInfo;
+  MethodMeta &mthdObj;
+  uint16_t subArrayLength;
+};
+
+MObject *AnnoParser::CaseArray(MClass *classInfo, MClass *annotationInfo, MethodMeta &mthdObj) {
+  AnnoArrayMemberFactory factory(classInfo, *this, annotationInfo, mthdObj);
+  if (factory.GetArrayLength() == 0) {
+    return factory.GetZeroLenArray();
+  }
+  uint32_t typeInArray = static_cast<uint32_t>(ParseNum(kValueInt)); // element type in array
+  switch (typeInArray) {
+    case kValueAnnotation: {
+      return factory.GetAnnotationTypeValue();
+    }
+    case kValueString:
+      return factory.GetStringTypeArray();
+    case kValueType:
+      return factory.GetTypeTypeArray();
+    case kValueInt:
+      return factory.GetPrimiTypeArray<int32_t>(WellKnown::GetMClassI(), kValueInt);
+    case kValueShort:
+      return factory.GetPrimiTypeArray<int16_t>(WellKnown::GetMClassS(), kValueShort);
+    case kValueByte:
+      return factory.GetPrimiTypeArray<int8_t>(WellKnown::GetMClassB(), kValueShort);
+    case kValueLong:
+      return factory.GetPrimiTypeArray<int64_t>(WellKnown::GetMClassJ(), kValueLong);
+    case kValueFloat:
+      return factory.GetFloatPrimiTypeArray<float>(WellKnown::GetMClassF(), kValueFloat);
+    case kValueDouble:
+      return factory.GetFloatPrimiTypeArray<double>(WellKnown::GetMClassD(), kValueDouble);
+    case kValueEnum:
+      return factory.GetEnumTypeArray();
+    case kValueBoolean:
+      return factory.GetBooleanTypeArray();
+    case kValueChar:
+      return factory.GetPrimiTypeArray<uint16_t>(WellKnown::GetMClassC(), kValueInt);
+    default:
+      LOG(FATAL) << "Unexpected primitive type: " << typeInArray;
+  }
+  return nullptr;
+}
+
+MObject *AnnoParser::InvokeAnnotationParser(MObject *hashMapInst, MObject *annotationInfo) {
+  MClass *annotationParserCls = WellKnown::GetMClassAnnotationParser();
+  MethodMeta *createMthd = annotationParserCls->GetDeclaredMethod("annotationForMap",
+      "(Ljava/lang/Class;Ljava/util/Map;)Ljava/lang/annotation/Annotation;");
+  CHECK(createMthd != nullptr) << "__MRT_Reflect_GetCharDeclaredMethod return nullptr" << maple::endl;
+  jvalue xregVal[kXregValSize]; // annotationForMap method has two params
+  xregVal[kHashMapInstIdx].l = reinterpret_cast<jobject>(hashMapInst);
+  xregVal[kAnnoInfoIdx].l = reinterpret_cast<jobject>(annotationInfo);
+  MObject *ret = RuntimeStub<MObject*>::SlowCallCompiledMethod(createMthd->GetFuncAddress(), xregVal, 0, 0);
+  CHECK(ret != nullptr) << "InvokeAnnotationParser : proxyInstance null " << maple::endl;
+  return ret;
+}
+
+#else
+
+class AnnoArrayMemberFactory {
+ public:
+  AnnoArrayMemberFactory(MClass *cls, AnnoParser &par, MClass *annoCls, ArgValue &val, MethodMeta &mthd)
+      : classInfo(cls), parser(par), annotationType(annoCls), argArr(val), mthdObj(mthd) {
+    subArrayLength = static_cast<uint32_t>(parser.ParseNum(kValueInt));
+  }
+
+  ~AnnoArrayMemberFactory() = default;
+
+  static void SetArray(ArgValue &xregVal, MObject *realRetArray, MClass *type) {
+    if (xregVal.GetGIdx() != 0) {
+      xregVal.AddReference(realRetArray);
+      xregVal.AddReference(type);
+    }
+  }
+  MObject *GetZeroLenArray() noexcept {
+    MClass *returnType = mthdObj.GetReturnType();
+    CHECK_E_P(returnType == nullptr, "GetZeroLenArray() : GetReturnType() return nullptr.");
+    MClass *type = returnType->GetComponentClass(); // remove A
+    MArray *realRetArray = MArray::NewObjectArray(0, *returnType);
+    SetArray(argArr, reinterpret_cast<MObject*>(realRetArray), type);
+    if (argArr.GetGIdx() == 0) {
+      return realRetArray;
+    }
+    return nullptr;
+  }
+
+  MObject *GetAnnotationTypeArray() noexcept {
+    MObject *realRetArray = parser.GenerateAnnotationTypeValue(classInfo, annotationType, subArrayLength);
+    MClass *retType = mthdObj.GetReturnType();
+    CHECK_E_P(retType == nullptr, "GetAnnotationTypeArray() : GetReturnType() return nullptr.");
+    SetArray(argArr, realRetArray, retType);
+    constexpr size_t skipStep = 2;
+    parser.IncIdx(skipStep); // skip '}!'
+    return realRetArray;
+  }
+
+  MObject *GetStringTypeArray() noexcept {
+    ScopedHandles sHandles;
+    MArray *mArray = reinterpret_cast<MArray*>(MRT_NewObjArray(subArrayLength, *WellKnown::GetMClassString(), nullptr));
+    ObjHandle<MArray> retInArray(mArray);
+    parser.NextItem(kDefSkipItemNum);
+    for (uint16_t i = 0; i < subArrayLength; ++i) {
+      string valStr;
+      if (i != subArrayLength - 1) {
+        valStr = parser.ParseStr(kDefParseStrType);
+      } else {
+        valStr = parser.ParseStrForLastStringArray();
+      }
+      MString *memberVal = NewStringFromUTF16(valStr.c_str());
+      mArray->SetObjectElementNoRc(i, memberVal);
+    }
+    SetArray(argArr, retInArray(), WellKnown::GetMClassAString());
+    return reinterpret_cast<MObject*>(retInArray.Return());
+  }
+
+  MObject *GetTypeTypeArray() noexcept {
+    ScopedHandles sHandles;
+    MClass *type = mthdObj.GetReturnType();
+    ObjHandle<MArray> retInArray(MArray::NewObjectArray(subArrayLength, *type));
+    parser.NextItem(kDefSkipItemNum);
+    for (uint32_t i = 0; i < subArrayLength; ++i) {
+      string valStr = parser.ParseStr(kDefParseStrType);
+      // clType is off heap
+      MObject *clType = reinterpret_cast<MObject*>(MRT_GetClassByContextClass(*annotationType, valStr));
+      if (clType == nullptr) {
+        return nullptr;
+      }
+      retInArray->SetObjectElement(i, clType);
+    }
+    SetArray(argArr, retInArray(), WellKnown::GetMClassAClass());
+    return retInArray.ReturnObj();
+  }
+
+  template<class jType>
+  MObject *GetPrimiTypeArray(MClass *boxedType, MClass *primType, uint8_t parseType) noexcept {
+    MObject *retInArray = reinterpret_cast<MObject*>(MRT_NewArray(subArrayLength, *primType, sizeof(jType)));
+    SetPrimArrayContent<jType>(retInArray, parser, subArrayLength, parseType);
+    SetArray(argArr, retInArray, boxedType);
+    return retInArray;
+  }
+
+  template<class jType>
+  MObject *GetFloatPrimiTypeArray(MClass *boxedType, MClass *primType, uint8_t parseType) noexcept {
+    MObject *retInArray = reinterpret_cast<MObject*>(MRT_NewArray(subArrayLength, *primType, sizeof(jType)));
+    SetPrimArrayContent<jType>(retInArray, parser, subArrayLength, parseType, true);
+    SetArray(argArr, retInArray, boxedType);
+    return retInArray;
+  }
+
+  MObject *GetEnumTypeArray() noexcept {
+    ScopedHandles sHandles;
+    parser.NextItem(kDefSkipItemNum);
+    MClass *returnType = mthdObj.GetReturnType();
+    CHECK_E_P(returnType == nullptr, "GetEnumTypeArray() : GetReturnType() return nullptr.");
+    MClass *enumType = returnType->GetComponentClass();
+    // array store exception might happen
+    MArray *mArray = MArray::NewObjectArray(subArrayLength, *returnType);
+    ObjHandle<MArray> retInArray(mArray);
+    for (uint32_t j = 0; j < subArrayLength; ++j) {
+      string valStr = parser.ParseStr(kDefParseStrType);
+      FieldMeta *fieldMeta = enumType->GetDeclaredField(valStr.c_str());
+      CHECK_E_P(fieldMeta == nullptr, "GetEnumTypeArray() : fieldMeta is nullptr.");
+      MObject *newObj = fieldMeta->GetObjectValue(nullptr); // skip slr
+      mArray->SetObjectElementNoRc(j, newObj);
+    }
+    SetArray(argArr, retInArray(), enumType);
+    return reinterpret_cast<MObject*>(retInArray.Return());
+  }
+
+  MObject *GetbooleanTypeArray() noexcept {
+    // parse and init boolean will not trigger GC
+    MArray *retInArray = reinterpret_cast<MArray*>(
+        MRT_NewArray(subArrayLength, *WellKnown::GetMClassZ(), sizeof(jboolean)));
+    jboolean *p = reinterpret_cast<jboolean*>(retInArray->ConvertToCArray());
+    parser.NextItem(kDefSkipItemNum);
+    for (uint32_t i = 0; i < subArrayLength; ++i) {
+      p[i] = parser.ParseNum(kValueInt) == 1 ? JNI_TRUE : JNI_FALSE;
+    }
+    SetArray(argArr, retInArray, WellKnown::GetMClassABoolean());
+    return retInArray;
+  }
+
+  uint32_t GetArrayLength() const noexcept{
+    return subArrayLength;
+  }
+
+ private:
+  MClass *classInfo;
+  AnnoParser &parser;
+  MClass *annotationType;
+  ArgValue &argArr;
+  MethodMeta &mthdObj;
+  uint32_t subArrayLength;
+};
+
+class AnnoMemberFactory {
+ public:
+  AnnoMemberFactory(MClass *annoCls, MClass *dCls, AnnoParser &p)
+      : annotationType(annoCls), declaringCls(dCls), parser(p) {
+  }
+
+  ~AnnoMemberFactory() = default;
+
+  MethodMeta *GetDefineMethod(const string &annoMemberName) {
+    MethodMeta *methodMetas = annotationType->GetMethodMetas();
+    uint32_t numOfMethod = annotationType->GetNumOfMethods();
+    for (uint32_t methodIndex = 0; methodIndex < numOfMethod; ++methodIndex) {
+      MethodMeta *methodMeta = methodMetas + methodIndex;
+      if (methodMeta->GetName() == annoMemberName) {
+        return methodMeta;
+      }
+    }
+    return nullptr;
+  }
+  void GetStringValAndType(ArgValue &xregVal) {
+    string valStr = parser.ParseStr(kDefParseStrType);
+    MString *memberVal = nullptr;
+    if (namemangler::NeedConvertUTF16(valStr)) {
+      memberVal = NewStringFromUTF16(valStr.c_str());
+    } else {
+      memberVal = NewStringUTF(valStr.c_str(), valStr.size());
+    }
+    xregVal.AddReference(memberVal);
+    xregVal.AddReference(WellKnown::GetMClassString());
+  }
+
+  void GetPrimValAndType(ArgValue &xregVal, uint32_t annoType) {
+    switch (annoType) {
+      case kValueChar: {
+        xregVal.AddReference(primitiveutil::BoxPrimitiveJchar(parser.ParseNum(kValueShort)));
+        xregVal.AddReference(WellKnown::GetMClassC());
+        break;
+      }
+      case kValueInt: {
+        xregVal.AddReference(primitiveutil::BoxPrimitiveJint(static_cast<jint>(parser.ParseNum(kValueInt))));
+        xregVal.AddReference(WellKnown::GetMClassI());
+        break;
+      }
+      case kValueShort: {
+        xregVal.AddReference(primitiveutil::BoxPrimitiveJshort(parser.ParseNum(kValueShort)));
+        xregVal.AddReference(WellKnown::GetMClassS());
+        break;
+      }
+      case kValueByte: {
+        xregVal.AddReference(primitiveutil::BoxPrimitiveJbyte(parser.ParseNum(kValueShort)));
+        xregVal.AddReference(WellKnown::GetMClassB());
+        break;
+      }
+      case kValueLong: {
+        xregVal.AddReference(primitiveutil::BoxPrimitiveJlong(parser.ParseNum(kValueLong)));
+        xregVal.AddReference(WellKnown::GetMClassJ());
+        break;
+      }
+      case kValueFloat: {
+        xregVal.AddReference(primitiveutil::BoxPrimitiveJfloat(parser.ParseDoubleNum(kValueFloat)));
+        xregVal.AddReference(WellKnown::GetMClassF());
+        break;
+      }
+      case kValueDouble: {
+        xregVal.AddReference(primitiveutil::BoxPrimitiveJdouble(parser.ParseDoubleNum(kValueDouble)));
+        xregVal.AddReference(WellKnown::GetMClassD());
+        break;
+      }
+      default: {}
+    }
+  }
+
+  void GetEnumValAndType(ArgValue &xregVal, const string &annoMemberName) {
+    string valStr = parser.ParseStr(kDefParseStrType);
+    MethodMeta *method = GetDefineMethod(annoMemberName);
+    CHECK_E_V(method == nullptr, "GetEnumValAndType() : method is nullptr.");
+    MClass *retType = method->GetReturnType();
+    CHECK_E_V(retType == nullptr, "GetEnumValAndType() : retType is nullptr.");
+    FieldMeta *fieldMeta = retType->GetDeclaredField(valStr.c_str());
+    CHECK_E_V(fieldMeta == nullptr, "GetEnumValAndType() : fieldMeta is nullptr.");
+    xregVal.AddReference(fieldMeta->GetObjectValue(nullptr));
+    xregVal.AddReference(retType);
+  }
+
+  void GetAnnoValAndType(ArgValue &xregVal) {
+    uint32_t subAnnoMemberNum = static_cast<uint32_t>(parser.ParseNum(kValueInt));
+    string valStr = parser.ParseStr(kDefParseStrType);
+    MClass *annoInfo = MClass::JniCast(MRT_GetClassByContextClass(*declaringCls, valStr));
+    CHECK(annoInfo != nullptr) << "annoInfo is nullptr" << maple::endl;
+    xregVal.AddReference(parser.GenerateAnnotationProxyInstance(declaringCls, annoInfo, subAnnoMemberNum));
+    xregVal.AddReference(WellKnown::GetMClassAnnotation());
+  }
+
+  void GetValAndType(ArgValue &xregVal, uint32_t annoType, const string &annoMemberName) {
+    switch (annoType) {
+      case kValueString: {
+        GetStringValAndType(xregVal);
+        break;
+      }
+      case kValueChar:
+      case kValueInt:
+      case kValueShort:
+      case kValueByte:
+      case kValueLong:
+      case kValueFloat:
+      case kValueDouble:
+        GetPrimValAndType(xregVal, annoType);
+        break;
+      case kValueAnnotation:
+        GetAnnoValAndType(xregVal);
+        break;
+      case kValueArray: {
+        MethodMeta *defMtd = GetDefineMethod(annoMemberName);
+        CHECK_E_V(defMtd == nullptr, "GetValAndType() : defMtd is nullptr.");
+        if (parser.CaseArray(declaringCls, annotationType, xregVal, *defMtd) == nullptr) {
+          LOG(ERROR) << "caseArray in GenerateAnnotationMemberArray() fail" << maple::endl;
+        }
+        break;
+      }
+      case kValueType: {
+        string valStr = parser.ParseStr(kDefParseStrType);
+        xregVal.AddReference(MObject::JniCast(MRT_GetClassByContextClass(*declaringCls, valStr)));
+        xregVal.AddReference(MObject::JniCast(MRT_GetClassByContextClass(*declaringCls, kMrtTypeClass)));
+        break;
+      }
+      case kValueEnum:
+        GetEnumValAndType(xregVal, annoMemberName);
+        break;
+      case kValueBoolean: {
+        jboolean value = parser.ParseNum(kValueInt) == 1 ? JNI_TRUE : JNI_FALSE;
+        xregVal.AddReference(primitiveutil::BoxPrimitiveJboolean(value));
+        xregVal.AddReference(WellKnown::GetMClassZ());
+        break;
+      }
+      default: {
+        LOG(ERROR) << "GenerateAnnotationMemberArray decode error: " << maple::endl;
+      }
+    }
+  }
+
+  MMethod *GetMethodObject(const string &annoMemberName, ArgValue &xregVal, const MethodMeta &definingMthd) {
+    MMethod *definingMthdObj = nullptr;
+    if (!MRT_IsNaiveRCCollector()) {
+      definingMthdObj = MMethod::NewMMethodObject(definingMthd);
+    } else {
+      CHECK_E_P(annotationType == nullptr, "AnnoMemberFactory::GetMethodObject : annotationType is nullptr");
+      string annoStr = annotationType->GetAnnotation();
+      AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), annotationType);
+      std::unique_ptr<AnnoParser> defParser(&annoParser);
+      int32_t loc = defParser->Find(parser.GetAnnoDefaultStr());
+      if (loc != kNPos) {
+        if (!MethodDefaultUtil::HasDefaultValue(annoMemberName.c_str(), *defParser)) {
+          definingMthdObj = MMethod::NewMMethodObject(definingMthd);
+        }
+      } else {
+        definingMthdObj = MMethod::NewMMethodObject(definingMthd);
+      }
+    }
+    xregVal.AddReference(definingMthdObj);
+    return definingMthdObj;
+  }
+
+ private:
+  MClass *annotationType;
+  MClass *declaringCls;
+  AnnoParser &parser;
+};
+
+MObject *AnnoParser::GenerateAnnotationMemberArray(MClass *classInfo, MClass *annotationInfo, uint32_t memberNum) {
+  if (memberNum == 0) {
+    return nullptr;
+  }
+  ScopedHandles sHandles;
+  ObjHandle<MArray> memberArr(MRT_NewObjArray(memberNum, *WellKnown::GetMClassObject(), nullptr));
+  AnnoMemberFactory factory(annotationInfo, classInfo, *this);
+  uint8_t constexpr memberValIdx = 2;
+  for (uint32_t i = 0; i < memberNum; ++i) {
+    string annoMemberName = ParseStr(kDefParseStrType);
+    MethodMeta *definingMthd = factory.GetDefineMethod(annoMemberName);
+    if (definingMthd == nullptr) {
+      return nullptr;
+    }
+    ArgValue xregVal(0); // AnnotationMember Constructor argument array
+    ObjHandle<MObject> obj(MObject::NewObject(*WellKnown::GetMClassAnnotationMember()));
+    MString *memberNameJ = nullptr;
+    if (namemangler::NeedConvertUTF16(annoMemberName)) {
+      memberNameJ = NewStringFromUTF16(annoMemberName.c_str());
+    } else {
+      memberNameJ = NewStringUTF(annoMemberName.c_str(), annoMemberName.size());
+    }
+    ObjHandle<MObject> memberNameJRef(memberNameJ);
+    xregVal.AddReference(obj.AsObject());
+    xregVal.AddReference(memberNameJRef.AsObject());
+
+    factory.GetValAndType(xregVal, static_cast<uint32_t>(ParseNum(kValueInt)), annoMemberName);
+
+    ObjHandle<MObject> memberVall(xregVal.GetReferenceFromGidx(memberValIdx));
+    // Keep return method Obj in LocalRefs, as it recorded in xregVal without strong reference
+    ObjHandle<MObject> retRef(factory.GetMethodObject(annoMemberName, xregVal, *definingMthd));
+    constexpr int zeroCnst = 0;
+    RuntimeStub<void>::SlowCallCompiledMethod(WellKnown::GetMMethodAnnotationMemberInitAddr(), xregVal.GetData(),
+                                              zeroCnst, zeroCnst);
+    memberArr->SetObjectElement(i, obj());
+  }
+  return memberArr.ReturnObj();
+}
+
+MObject *AnnoParser::GenerateAnnotationProxyInstance(MClass *classInfo, MClass *annotationInfo, uint32_t memberNum) {
+  ScopedHandles sHandles;
+  ObjHandle<MObject> memberArr(GenerateAnnotationMemberArray(classInfo, annotationInfo, memberNum));
+  uintptr_t createFactory = WellKnown::GetMMethodAnnotationFactoryCreateAnnotationAddr();
+  ArgValue xregVal(0);
+  xregVal.AddReference(annotationInfo);
+  xregVal.AddReference(memberArr());
+  constexpr int zeroConst = 0;
+  MObject *proxyInstance = RuntimeStub<MObject*>::SlowCallCompiledMethod(createFactory, xregVal.GetData(),
+                                                                         zeroConst, zeroConst);
+  CHECK(proxyInstance != nullptr) << "GenerateAnnotationProxyInstance : proxyInstance null " << maple::endl;
+  return proxyInstance;
+}
+
+
+MObject *AnnoParser::CaseArray(MClass *classInfo, MClass *annotationInfo, ArgValue &argArr, MethodMeta &mthdObj) {
+  AnnoArrayMemberFactory factory(classInfo, *this, annotationInfo, argArr, mthdObj);
+  if (factory.GetArrayLength() == 0) {
+    return factory.GetZeroLenArray();
+  }
+  uint32_t typeInArray = static_cast<uint32_t>(ParseNum(kValueInt)); // element type in array
+  switch (typeInArray) {
+    case kValueAnnotation:
+      return factory.GetAnnotationTypeArray();
+    case kValueString:
+      return factory.GetStringTypeArray();
+    case kValueType:
+      return factory.GetTypeTypeArray();
+    case kValueInt:
+      return factory.GetPrimiTypeArray<int32_t>(WellKnown::GetMClassAInteger(), WellKnown::GetMClassI(), kValueInt);
+    case kValueShort:
+      return factory.GetPrimiTypeArray<int16_t>(WellKnown::GetMClassAShort(), WellKnown::GetMClassS(), kValueShort);
+    case kValueByte:
+      return factory.GetPrimiTypeArray<int8_t>(WellKnown::GetMClassAByte(), WellKnown::GetMClassB(), kValueShort);
+    case kValueLong:
+      return factory.GetPrimiTypeArray<int64_t>(WellKnown::GetMClassALong(), WellKnown::GetMClassJ(), kValueLong);
+    case kValueFloat:
+      return factory.GetFloatPrimiTypeArray<float>(WellKnown::GetMClassAFloat(),
+                                                   WellKnown::GetMClassF(), kValueFloat);
+    case kValueDouble:
+      return factory.GetFloatPrimiTypeArray<double>(WellKnown::GetMClassADouble(),
+                                                    WellKnown::GetMClassD(), kValueDouble);
+    case kValueEnum:
+      return factory.GetEnumTypeArray();
+    case kValueBoolean:
+      return factory.GetbooleanTypeArray();
+    case kValueChar:
+      return factory.GetPrimiTypeArray<uint16_t>(WellKnown::GetMClassACharacter(), WellKnown::GetMClassC(), kValueInt);
+    default:
+      LOG(FATAL) << "Unexpected primitive type: " << typeInArray;
+  }
+  return nullptr;
+}
+#endif // __OPENJDK__
+
+MObject *AnnoParser::GenerateAnnotationTypeValue(MClass *classInfo, const MClass *annotationInfo,
+                                                 uint32_t subArrayLength) {
+  if (!subArrayLength) {
+    MObject *zeroLenArray = reinterpret_cast<MObject*>(MRT_NewObjArray(0, *WellKnown::GetMClassAnnotation(), nullptr));
+    return zeroLenArray;
+  }
+  ScopedHandles sHandles;
+  string classnameInArray = ParseStrNotMove();
+  MClass *annoInArray = MClass::JniCast(MRT_GetClassByContextClass(*annotationInfo, classnameInArray));
+  CHECK(annoInArray != nullptr) << "annoInArray is nullptr" << maple::endl;
+  MArray *mArray = reinterpret_cast<MArray*>(MRT_NewObjArray(subArrayLength, *annoInArray, nullptr));
+  ObjHandle<MArray> realRetArray(mArray);
+  for (uint32_t i = 0; i < subArrayLength; ++i) {
+    NextItem(kDefSkipItemNum);
+    uint32_t memberNum = static_cast<uint32_t>(ParseNum(kValueInt));
+#ifdef __OPENJDK__
+    ObjHandle<MObject> hashMapInst(GenerateMemberValueHashMap(classInfo, annoInArray, memberNum));
+    MObject *proxyInstance = InvokeAnnotationParser(hashMapInst.AsObject(), annoInArray);
+#else
+    MObject *proxyInstance = GenerateAnnotationProxyInstance(classInfo, annoInArray, memberNum);
+#endif
+    mArray->SetObjectElementNoRc(i, proxyInstance);
+  }
+  return realRetArray.ReturnObj();
+}
+
+static void SetNewPrameter(const std::string argsBuff, uint32_t argsAccessFlag,
+                           uint32_t i, const MArray &paraArray, MObject *obj) {
+  ScopedHandles sHandles;
+  ObjHandle<MString> js(NewStringUTF(argsBuff.c_str(), argsBuff.length()));
+  jvalue paraIns[kParaSize];
+  paraIns[kParaNamePos].l = js.AsJObj();
+  paraIns[kParaModifiersPos].j = argsAccessFlag;
+  paraIns[kParaExecutablePos].l = reinterpret_cast<jobject>(obj);
+  paraIns[kParaIndexPos].j = i;
+  MClass *parameterClass = WellKnown::GetMClassParameter();
+  MethodMeta *initMethod =
+      parameterClass->GetDeclaredConstructor("(Ljava/lang/String;ILjava/lang/reflect/Executable;I)V");
+  CHECK_E_V(initMethod == nullptr, "initMethod is nullptr");
+  MObject *paraObj = MObject::NewObject(*parameterClass, *initMethod, *paraIns);
+  paraArray.SetObjectElementNoRc(i, paraObj);
+}
+
+MObject *AnnoParser::GetParameters0(MMethod *method) {
+  MethodMeta *methodMeta = method->GetMethodMeta();
+  uint32_t cnt = methodMeta->GetParameterCount();
+  ScopedHandles sHandles;
+  ObjHandle<MArray> paraArray(MArray::NewObjectArray(cnt, *WellKnown::GetMClassAParameter()));
+
+  int32_t loc = Find(GetMethodParametersStr());
+  if (loc == kNPos) {
+    return nullptr;
+  }
+  (void)Find(kAnnoAccessFlags);
+  NextItem(kDefSkipItemNum);
+  uint32_t numParamsAccessFlags = static_cast<uint32_t>(ParseNum(kValueInt));
+  uint32_t accessFlagArray[numParamsAccessFlags];
+  SkipNameAndType();
+  for (uint32_t i = 0; i < numParamsAccessFlags; ++i) {
+    accessFlagArray[i] = static_cast<uint32_t>(ParseNum(kValueInt));
+  }
+  SetIdx(loc);
+  (void)Find("names");
+  NextItem(kDefSkipItemNum);
+  uint32_t numParamsNames = static_cast<uint32_t>(ParseNum(kValueInt));
+  uint32_t ParamsNamesType = static_cast<uint32_t>(ParseNum(kValueInt));
+  NextItem(kDefSkipItemNum);
+  string namesArray[numParamsNames];
+  for (uint32_t i = 0; i < numParamsNames; ++i) {
+    namesArray[i] = ParseStr(kDefParseStrType);
+  }
+  if (numParamsAccessFlags == 0 || numParamsNames == 0) {
+    return nullptr;
+  }
+  // check array sizes match each other
+  if (numParamsAccessFlags != numParamsNames || numParamsAccessFlags != cnt || numParamsNames != cnt) {
+    MRT_ThrowNewException("java/lang/IllegalArgumentException", "Inconsistent parameter metadata");
+    return nullptr;
+  }
+  // Parameters information get from annotations
+  for (uint32_t i = 0; i < cnt; ++i) {
+    uint32_t argsAccessFlag = accessFlagArray[i];
+    string argsName = ParamsNamesType == kValueNull ? "arg" + std::to_string(i) : namesArray[i];
+    if (argsName.empty()) {
+      MRT_ThrowNewException("java/lang/IllegalArgumentException", "Inconsistent parameter metadata");
+      return nullptr;
+    }
+    SetNewPrameter(argsName, argsAccessFlag, i, *paraArray.AsArray(), method);
+  }
+  return paraArray.ReturnObj();
+}
+
+MObject *AnnoParser::GetSignatureValue(const std::string &annSet, MClass *cls) {
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annSet.c_str(), cls);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  int32_t loc = parser->Find(parser->GetSignatureClassStr());
+  if (loc == kNPos) {
+    return nullptr;
+  }
+  parser->SkipNameAndType();
+  uint32_t arrLen = static_cast<uint32_t>(parser->ParseNum(kValueInt));
+  if (arrLen == 0) {
+    return nullptr;
+  }
+  parser->SkipNameAndType();
+  ScopedHandles sHandles;
+  MArray *mArray = reinterpret_cast<MArray*>(MRT_NewObjArray(arrLen, *WellKnown::GetMClassString(), nullptr));
+  ObjHandle<MArray> strArr(mArray);
+  for (uint32_t i = 0; i < arrLen; ++i) {
+    string buffStr = parser->ParseStr(true);
+    MString *stringObj = NewStringFromUTF16(buffStr.c_str());
+    mArray->SetObjectElementNoRc(i, stringObj);
+  }
+  return strArr.ReturnObj();
+}
+
+void AnnoParser::NextItem(int iter) {
+  for (int j = 0; j < iter; ++j) {
+    if (annoStr[annoStrIndex] == kAnnoArrayEndDelimiter) {
+      ++annoStrIndex;
+      if (annoStr[annoStrIndex] == kAnnoDelimiter) {
+        ++annoStrIndex;
+      }
+    }
+
+    for (size_t i = annoStrIndex; i < annoSize; ++i) {
+      if (annoStr[i] == kAnnoDelimiter) {
+        annoStrIndex = i;
+        break;
+      }
+      int leftBrackets = 0;
+      if (annoStr[i] == kAnnoArrayStartDelimiter && annoStr[i - 1] == kAnnoDelimiter) {
+        ++leftBrackets;
+        ++i;
+        while (i < annoSize) {
+          if (annoStr[i] == kAnnoArrayStartDelimiter && annoStr[i - 1] == kAnnoDelimiter) {
+            ++leftBrackets;
+          } else if (annoStr[i] == kAnnoArrayEndDelimiter) {
+            --leftBrackets;
+          }
+          if (leftBrackets != 0) {
+            break;
+          }
+          ++i;
+        }
+        annoStrIndex = i + 1;
+        break;
+      }
+    }
+    ++annoStrIndex; // skip delimiter '!'
+  }
+}
+
+void AnnoParser::SkipNameAndType(int iter) {
+  constexpr int skipItemNums = 2;
+  for (int j = 0; j < iter; ++j) {
+    NextItem(skipItemNums); // skip name & type
+  }
+}
+
+void AnnoParser::SkipAnnoMember(uint32_t iter) {
+  constexpr int skipItemNums = 3;
+  for (uint32_t j = 0; j < iter; ++j) {
+    NextItem(skipItemNums); // member has 3 items
+  }
+}
+
+void AnnoParser::InitAnnoMemberCntArray(uint32_t *annoMemberCntArray, uint32_t annoNum) {
+  for (uint32_t i = 0; i < annoNum; ++i) {
+    annoMemberCntArray[i] = static_cast<uint32_t>(ParseNum(kValueInt));
+  }
+}
+
+bool AnnoParser::IsVerificationAnno(const std::string &annotName) const {
+  auto *mClass = reinterpret_cast<const MClass*>(declaringClass);
+  if (mClass->IsVerified()) {
+    // if Verification is not enabled, no verification annotations will present
+    return false;
+  }
+  static const std::vector<const char*> verificationAnnos = {
+      kThrowVerifyError,
+      kDeferredOverrideFinalCheck,
+      kDeferredExtendFinalCheck,
+      kAssignableChecksContainer,
+      kDeferredAssignableCheck
+  };
+  auto cmpStr = [&annotName](const char *element) {
+    return annotName.compare(element) == 0;
+  };
+  return std::any_of(verificationAnnos.begin(), verificationAnnos.end(), cmpStr);
+}
+
+template<typename T>
+T AnnoParser::ParseNumImpl(int type) {
+  // digit , '-' , "inf", "nan" is valid
+  while (!isdigit(annoStr[annoStrIndex]) && annoStr[annoStrIndex] != '-' &&
+         annoStr[annoStrIndex] != 'i' && annoStr[annoStrIndex] != 'n' && annoStrIndex < annoSize) {
+    ++annoStrIndex;
+  }
+  size_t numStartIdx = annoStrIndex;
+  for (size_t i = annoStrIndex; i < annoSize; ++i) {
+    if (annoStr[i] == kAnnoDelimiter) {
+      annoStrIndex = i;
+      ++annoStrIndex; // skip delimiter '!'
+      break;
+    }
+  }
+  switch (type) {
+    case kValueFloat:
+    case kValueDouble:
+      return static_cast<T>(atof(annoStr + numStartIdx));
+    case kValueInt:
+    case kValueShort:
+      return static_cast<T>(atoi(annoStr + numStartIdx));
+    case kValueLong:
+      return static_cast<T>(atoll(annoStr + numStartIdx));
+    default:
+      LOG(ERROR) << " ParseNum type error" << maple::endl;
+      return 0;
+  }
+}
+
+int32_t AnnoParser::Find(char target) {
+  while (annoStrIndex < annoSize) {
+    if (annoStr[annoStrIndex] == target) {
+      ++annoStrIndex;
+      return static_cast<int32_t>(annoStrIndex);
+    }
+    ++annoStrIndex;
+  }
+  return kNPos;
+}
+
+char *AnnoParser::GetCStringFromStrTab(uint32_t srcIndex) const {
+  char *cStrStart = nullptr;
+  constexpr int32_t realIndexStart = 2;
+  uint32_t index = srcIndex & 0xFFFFFFFF;
+  // 0x03 is 0011, index & 0x03 is to check isHotReflectStr.
+  bool isHotReflectStr = (index & 0x03) != 0;
+  uint32_t cStrIndex = index >> realIndexStart;
+  if (isHotReflectStr) {
+    uint32_t tag = (index & 0x03) - maple::kCStringShift;
+    if (tag == static_cast<uint32_t>(maple::kLayoutBootHot)) {
+      cStrStart = strTab->startHotStrTab;
+    } else if (tag == static_cast<uint32_t>(maple::kLayoutBothHot)) {
+      cStrStart = strTab->bothHotStrTab;
+    } else {
+      cStrStart = strTab->runHotStrTab;
+    }
+  } else {
+    cStrStart = strTab->coldStrTab;
+  }
+  if (cStrStart == nullptr) {
+    return nullptr;
+  }
+  return cStrStart + cStrIndex;
+}
+
+string AnnoIndexParser::ParseStr(bool isSN __attribute__((unused))) {
+  while (annoStr[annoStrIndex] != kAnnoDelimiterPrefix) {
+    ++annoStrIndex;
+  }
+  return ParseStrImpl();
+}
+
+string AnnoIndexParser::GetParameterAnnotationInfoIndex(const std::string &entireStr) {
+  size_t size = entireStr.size();
+  if (size != 0) {
+    for (size_t i = size - 1; i > 0; --i) {
+      if (entireStr[i] == '|') {
+        return entireStr.substr(i - 1);
+      }
+    }
+  }
+  return "";
+}
+
+void AnnoIndexParser::NextItem(int iter) {
+  for (int j = 0; j < iter; ++j) {
+    if (annoStr[annoStrIndex] == kAnnoArrayEndDelimiterIndex) {
+      ++annoStrIndex;
+      if (annoStr[annoStrIndex] == kAnnoDelimiter) {
+        ++annoStrIndex;
+      }
+    }
+    for (size_t i = annoStrIndex; i < annoSize; ++i) {
+      if (annoStr[i] == kAnnoDelimiter) {
+        annoStrIndex = i;
+        break;
+      }
+      int leftBrackets = 0;
+      if (annoStr[i] == kAnnoArrayStartDelimiterIndex) {
+        ++leftBrackets;
+        ++i;
+        while (i < annoSize) {
+          if (annoStr[i] == kAnnoArrayStartDelimiterIndex) {
+            ++leftBrackets;
+          } else if (annoStr[i] == kAnnoArrayEndDelimiterIndex) {
+            --leftBrackets;
+          }
+          if (!leftBrackets) {
+            break;
+          }
+          ++i;
+        }
+        annoStrIndex = i + 1;
+        break;
+      }
+    }
+    ++annoStrIndex; // skip delimiter '!'
+  }
+}
+
+uint32_t AnnoIndexParser::ParseIndex() {
+  constexpr uint32_t base = 10;
+  int tmp = 0;
+  uint32_t index = 0;
+  for (size_t i = annoStrIndex; i < annoSize; ++i) {
+    if (annoStr[i] != kAnnoDelimiter && isdigit(annoStr[i])) {
+      tmp = annoStr[i] - '0';
+      index *= base;
+      index += static_cast<uint32_t>(tmp);
+    } else {
+      annoStrIndex = i;
+      while (annoStr[annoStrIndex] != kAnnoDelimiter) {
+        ++annoStrIndex;
+      }
+      ++annoStrIndex; // skip delimiter '!'
+      break;
+    }
+  }
+  return index;
+}
+
+string AnnoIndexParser::ParseStrImpl() {
+  if (annoStr[annoStrIndex] == kAnnoDelimiterPrefix) {
+    ++annoStrIndex;
+    uint32_t strIdx = ParseIndex();
+    --annoStrIndex;
+    if (declaringClass != nullptr && declaringClass->IsProxy()) {
+      if (declaringClass->GetNumOfSuperClasses() >= 1) {
+        declaringClass = declaringClass->GetSuperClassArray()[1];
+      } else {
+        ++annoStrIndex; // skip delimiter '!'
+        return "";
+      }
+    }
+    char *cPtr = nullptr;
+    if (declaringClass != nullptr) {
+      cPtr = GetCStringFromStrTab(strIdx);
+    }
+    ++annoStrIndex; // skip delimiter '!'
+    return cPtr == nullptr ? interpreter::GetStringFromInterpreterStrTable(static_cast<int>(strIdx)) : cPtr;
+  }
+  ++annoStrIndex; // skip delimiter '!'
+  LOG(ERROR) << "Annotation ParseStrImpl Exception" << annoStr << maple::endl;
+  return "";
+}
+
+int32_t AnnoIndexParser::Find(const string &target) {
+  while (annoStrIndex < annoSize) {
+    if (annoStr[annoStrIndex] != kAnnoDelimiterPrefix) {
+      ++annoStrIndex;
+      continue;
+    }
+    if (ParseStr(kDefParseStrType) == target) {
+      return static_cast<int32_t>(annoStrIndex);
+    }
+  }
+  return kNPos;
+}
+
+int32_t AnnoAsciiParser::Find(const string &target) {
+  string str = annoStr;
+  size_t loc = str.find(target, annoStrIndex);
+  if (loc == string::npos) {
+    return kNPos;
+  }
+  annoStrIndex = static_cast<uint32_t>(loc + target.size());
+  return static_cast<int32_t>(++annoStrIndex);
+}
+
+string AnnoAsciiParser::ParseStrImpl() {
+  uint8_t endLable = 0;
+  string retArr = "";
+  if (annoStr[annoStrIndex] == kAnnoDelimiterPrefix && annoStrIndex + 1 < annoSize &&
+      isdigit(annoStr[annoStrIndex + 1])) {
+    ++annoStrIndex;
+    uint32_t strIdx = static_cast<uint32_t>(ParseNum(kValueInt));
+    --annoStrIndex;
+    if (declaringClass->IsProxy()) {
+      if (declaringClass->GetNumOfSuperClasses() >= 1) {
+        declaringClass = declaringClass->GetSuperClassArray()[1];
+      } else {
+        ++annoStrIndex; // skip delimiter '!'
+        return retArr;
+      }
+    }
+    retArr = LinkerAPI::Instance().GetCString(*declaringClass, strIdx);
+    ++annoStrIndex; // skip delimiter '!'
+    return retArr;
+  }
+  for (size_t i = annoStrIndex; i < annoSize; ++i) {
+    if (annoStr[i] == kAnnoDelimiterPrefix && i + 1 < annoSize && (annoStr[i + 1] == kAnnoDelimiter ||
+        annoStr[i + 1] == '|' || annoStr[i + 1] == kAnnoDelimiterPrefix)) {
+      retArr += annoStr[i + 1];
+      ++i;
+      continue;
+    }
+    if (annoStr[i] != kAnnoDelimiter) {
+      retArr += annoStr[i];
+    } else {
+      annoStrIndex = i;
+      endLable = 1;
+      break;
+    }
+  }
+  if (endLable == 0) {
+    annoStrIndex = annoSize - 1;
+  }
+  while (*retArr.rbegin() == kAnnoArrayEndDelimiter) {
+    retArr.pop_back();
+  }
+  ++annoStrIndex; // skip delimiter '!'
+  return retArr;
+}
+
+std::string AnnoAsciiParser::ParseStr(bool isSN) {
+  if (!isSN) {
+    if (annoStr[annoStrIndex] == kAnnoArrayStartDelimiter ||
+        annoStr[annoStrIndex] == kAnnoArrayEndDelimiter) {
+      ++annoStrIndex;
+      if (annoStr[annoStrIndex] == kAnnoDelimiter) {
+        ++annoStrIndex;
+      }
+    }
+  }
+  return ParseStrImpl();
+}
+
+string AnnoAsciiParser::GetParameterAnnotationInfoAscii(const std::string &entireStr) {
+  size_t size = entireStr.size();
+  if (size != 0) {
+    for (size_t i = size - 1; i > 0; --i) {
+      if (entireStr[i] == '|' && (i - 1 < size) && entireStr[i - 1] != kAnnoDelimiterPrefix) {
+        return entireStr.substr(i - 1);
+      }
+    }
+  }
+  return "";
+}
+bool AnnoIndexParser::ExceptAnnotationJudge(const std::string &annoName) const {
+  if (exceptIndexSet.find(annoName) != exceptIndexSet.end()) {
+    return true;
+  }
+  return false;
+}
+
+bool AnnoAsciiParser::ExceptAnnotationJudge(const std::string &kAnnoName) const {
+  if (exceptAsciiSet.find(kAnnoName) != exceptAsciiSet.end()) {
+    return true;
+  }
+  return false;
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_array.cpp b/src/mrt/maplert/src/mrt_array.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3932eeb7fac4765de2996ccc60d3697b35c221de
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_array.cpp
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_array.h"
+#include "mrt_primitive_util.h"
+#include "mclass_inline.h"
+
+namespace maplert {
+// new primitive array
+jobject MRT_NewArray(jint length, jclass elementClass, jint componentSize __attribute__((unused))) {
+  MClass *elementCls = MClass::JniCastNonNull(elementClass);
+  MArray *arrayObject = MArray::NewPrimitiveArrayComponentClass(length, *elementCls);
+  return arrayObject->AsJobject();
+}
+
+// new primitive array, pType is element Type
+jobject MRT_NewPrimitiveArray(jint length, maple::Primitive::Type pType,
+                              jint componentSize __attribute__((unused)), jboolean isJNI) {
+  MClass *arrayJClass = WellKnown::GetPrimitiveArrayClass(pType);
+  DCHECK(arrayJClass != nullptr) << "arrayJClass is nullptr." << maple::endl;
+  MArray *arrayObject = MArray::NewPrimitiveArray(length, *arrayJClass, isJNI);
+  return arrayObject->AsJobject();
+}
+
+// new object array
+jobject MRT_NewObjArray(const jint length, const jclass elementClass, const jobject initialElement) {
+  ScopedHandles sHandles;
+  const MClass *elementCls = MClass::JniCastNonNull(elementClass);
+  MArray *arrayObject = MArray::NewObjectArrayComponentClass(length, *elementCls);
+  ObjHandle<MObject> arrayObjectRef(arrayObject);
+  if (UNLIKELY(initialElement != nullptr)) {
+    // might possible throw ArrayStoreException, need push slr
+    arrayObject->InitialObjectArray(MObject::JniCast(initialElement));
+  }
+  return arrayObjectRef.ReturnObj()->AsJobject();
+}
+
+void *MRT_JavaArrayToCArray(jarray javaArray) {
+  MArray *arrayObject = MArray::JniCastNonNull(javaArray);
+  return arrayObject->ConvertToCArray();
+}
+
+jboolean MRT_IsArray(jobject javaArray) {
+  MObject *o = MObject::JniCastNonNull(javaArray);
+  return o->IsArray();
+}
+
+jboolean MRT_IsObjectArray(jobject javaArray) {
+  MObject *o = MObject::JniCastNonNull(javaArray);
+  return o->IsObjectArray();
+}
+
+jboolean MRT_IsPrimitveArray(jobject javaArray) {
+  MObject *o = MObject::JniCastNonNull(javaArray);
+  return o->IsPrimitiveArray();
+}
+
+jboolean MRT_IsMultiDimArray(jobject javaArray) {
+  MObject *o = MObject::JniCastNonNull(javaArray);
+  MClass *arrayClass = o->GetClass();
+  MClass *arrayCompClass = arrayClass->GetComponentClass();
+  if (UNLIKELY(arrayCompClass == nullptr)) {
+    return false;
+  }
+  return arrayCompClass->IsArrayClass();
+}
+
+// ArrayIndexOutOfBoundsException: if index does not specify a valid index in the array.
+jobject MRT_GetObjectArrayElement(jobjectArray javaArray, jsize index, jboolean maintainRC) {
+  MArray *arrayObject = MArray::JniCastNonNull(javaArray);
+  MObject *elementObject = maintainRC ?
+      arrayObject->GetObjectElement(index) : arrayObject->GetObjectElementNoRc(index);
+  return elementObject->AsJobject();
+}
+
+jint MRT_GetArrayContentOffset(void) {
+  return MArray::GetArrayContentOffset();
+}
+
+static void SetJValueByArrayPrimitiveElement(MArray &arrayObject, const jsize index, jvalue &desVal, const char type) {
+  switch (type) {
+    case 'Z':
+      desVal.z = arrayObject.GetPrimitiveElement<uint8_t>(static_cast<uint32_t>(index));
+      break;
+    case 'C':
+      desVal.c = arrayObject.GetPrimitiveElement<uint16_t>(static_cast<uint32_t>(index));
+      break;
+    case 'F':
+      desVal.f = arrayObject.GetPrimitiveElement<float>(static_cast<uint32_t>(index));
+      break;
+    case 'D':
+      desVal.d = arrayObject.GetPrimitiveElement<double>(static_cast<uint32_t>(index));
+      break;
+    case 'B':
+      desVal.b = arrayObject.GetPrimitiveElement<int8_t>(static_cast<uint32_t>(index));
+      break;
+    case 'S':
+      desVal.s = arrayObject.GetPrimitiveElement<int16_t>(static_cast<uint32_t>(index));
+      break;
+    case 'I':
+      desVal.i = arrayObject.GetPrimitiveElement<int32_t>(static_cast<uint32_t>(index));
+      break;
+    case 'J':
+      desVal.j = arrayObject.GetPrimitiveElement<int64_t>(static_cast<uint32_t>(index));
+      break;
+    default:
+      BUILTIN_UNREACHABLE();
+  }
+}
+
+void MRT_SetObjectArrayElement(
+    jobjectArray javaArray, jsize index, jobject javaValue, jboolean maintainRC __attribute__((unused))) {
+  MArray *arrayObject = MArray::JniCastNonNull(javaArray);
+  MObject *o = MObject::JniCast(javaValue);
+  arrayObject->SetObjectElement(index, o);
+}
+
+jobject MRT_GetArrayElement(jobjectArray javaArray, jsize index, jboolean maintain) {
+  MArray *arrayObject = MArray::JniCast(javaArray);
+  if (UNLIKELY(arrayObject == nullptr)) {
+    return nullptr;
+  }
+  int length = arrayObject->GetLength();
+  if (UNLIKELY(index < 0 || index >= length)) {
+    return nullptr;
+  }
+
+  MObject *res = nullptr;
+  if (arrayObject->IsObjectArray()) {
+    res = maintain ? arrayObject->GetObjectElement(index) : arrayObject->GetObjectElementNoRc(index);
+  } else {
+    jvalue desVal;
+    desVal.l = 0;
+    MClass *javaArrayClass = arrayObject->GetClass();
+    MClass *arrayCompClass = javaArrayClass->GetComponentClass();
+    char type = primitiveutil::GetPrimitiveType(*arrayCompClass);
+    SetJValueByArrayPrimitiveElement(*arrayObject, index, desVal, type);
+    res = primitiveutil::BoxPrimitive(type, desVal);
+  }
+  return res->AsJobject();
+}
+
+void MRT_SetArrayElement(jobjectArray javaArray, jsize index, jobject value) {
+  MArray *arrayObject = MArray::JniCast(javaArray);
+  MObject *javaValue = MArray::JniCast(value);
+  if (UNLIKELY(arrayObject == nullptr)) {
+    return;
+  }
+  uint32_t length = arrayObject->GetLength();
+  if (UNLIKELY(index < 0 || index >= static_cast<jsize>(length))) {
+    return;
+  }
+  if (arrayObject->IsObjectArray()) {
+    arrayObject->SetObjectElement(index, javaValue);
+  } else {
+    jvalue primitiveValue;
+    __MRT_ASSERT(javaValue != nullptr, "MRT_SetArrayElement: javaValue is a null ptr!");
+    bool unBoxRet = primitiveutil::UnBoxPrimitive(*javaValue, primitiveValue);
+    if (unBoxRet == true) {
+      MClass *arrClass = arrayObject->GetClass();
+      MClass *arrCompClass = arrClass->GetComponentClass();
+      char arrType = primitiveutil::GetPrimitiveType(*arrCompClass);
+      MRT_SetPrimitiveArrayElement(javaArray, static_cast<jint>(index), primitiveValue, arrType);
+    }
+  }
+  return;
+}
+
+jint MRT_GetArrayElementCount(jarray ja) {
+  MArray *arrayObject = MArray::JniCastNonNull(ja);
+  return arrayObject->GetLength();
+}
+
+// openjdk for primitiveArrayElement
+jvalue MRT_GetPrimitiveArrayElement(jarray arr, jint index, char arrType) {
+  jvalue desVal;
+  MArray *arrayObject = MArray::JniCastNonNull(arr);
+  bool isPrimitiveArray = arrayObject->IsPrimitiveArray();
+  if (UNLIKELY(isPrimitiveArray == false)) {
+    desVal.l = nullptr;
+    return desVal;
+  }
+  int length = arrayObject->GetLength();
+  if (UNLIKELY(index < 0 || index >= length)) {
+    desVal.l = nullptr;
+    return desVal;
+  }
+  SetJValueByArrayPrimitiveElement(*arrayObject, index, desVal, arrType);
+  return desVal;
+}
+
+jboolean MRT_TypeWidenConvertCheckObject(jobject val) {
+  MObject *mVal = MObject::JniCastNonNull(val);
+  MClass *valueClass = mVal->GetClass();
+  char valueType = primitiveutil::GetPrimitiveTypeFromBoxType(*valueClass);
+  return valueType == 'N' ? true : false;
+}
+
+jboolean MRT_TypeWidenConvertCheck(char currentType, char wideType, const jvalue& srcVal, jvalue &dstVal) {
+  bool checkRet = primitiveutil::ConvertNarrowToWide(currentType, wideType, srcVal, dstVal);
+  return checkRet;
+}
+
+char MRT_GetPrimitiveType(jclass clazz) {
+  MClass *klass = MClass::JniCastNonNull(clazz);
+  return primitiveutil::GetPrimitiveType(*klass);
+}
+
+char MRT_GetPrimitiveTypeFromBoxType(jclass clazz) {
+  MClass *klass = MClass::JniCastNonNull(clazz);
+  char dstType = primitiveutil::GetPrimitiveTypeFromBoxType(*klass);
+  return dstType;
+}
+
+void MRT_SetPrimitiveArrayElement(jarray arr, jint index, jvalue value, char arrType) {
+  MArray *arrayObject = MArray::JniCastNonNull(arr);
+  bool isPrimitiveArray = arrayObject->IsPrimitiveArray();
+  if (UNLIKELY(isPrimitiveArray == false)) {
+    return;
+  }
+  uint32_t length = arrayObject->GetLength();
+  if (UNLIKELY(index < 0 || index >= static_cast<jint>(length))) {
+    return;
+  }
+  switch (arrType) {
+    case 'Z':
+      arrayObject->SetPrimitiveElement<uint8_t>(index, value.z);
+      break;
+    case 'C':
+      arrayObject->SetPrimitiveElement<uint16_t>(index, value.c);
+      break;
+    case 'F':
+      arrayObject->SetPrimitiveElement<float>(index, value.f);
+      break;
+    case 'D':
+      arrayObject->SetPrimitiveElement<double>(index, value.d);
+      break;
+    case 'B':
+      arrayObject->SetPrimitiveElement<int8_t>(index, value.b);
+      break;
+    case 'S':
+      arrayObject->SetPrimitiveElement<int16_t>(index, value.s);
+      break;
+    case 'I':
+      arrayObject->SetPrimitiveElement<int32_t>(index, value.i);
+      break;
+    case 'J':
+      arrayObject->SetPrimitiveElement<int64_t>(index, value.j);
+      break;
+    default:
+      LOG(ERROR) << "MRT_SetPrimitiveArrayElement array type not known" << maple::endl;
+  }
+  return;
+}
+
+static MObject *RecursiveCreateMultiArray(const MClass &arrayClass, const int currentDimension,
+                                          const int dimensions, uint32_t *dimArray) {
+  DCHECK(dimArray != nullptr) << "RecursiveCreateMultiArray: dimArray is nullptr!" << maple::endl;
+  MClass *componentClass = arrayClass.GetComponentClass();
+  DCHECK(componentClass != nullptr) << "RecursiveCreateMultiArray: componentClass is nullptr!" << maple::endl;
+  if (currentDimension == dimensions - 1) {
+    return componentClass->IsPrimitiveClass() ? MArray::NewPrimitiveArray(dimArray[currentDimension], arrayClass)
+                                              : MArray::NewObjectArray(dimArray[currentDimension], arrayClass);
+  }
+  ScopedHandles sHandles;
+  MArray *array = MArray::NewObjectArray(dimArray[currentDimension], arrayClass);
+  if (array == nullptr) {
+    return nullptr;
+  }
+  ObjHandle<MArray> res(array);
+  for (uint32_t j = 0; j < dimArray[currentDimension]; j++) {
+    MObject *element = RecursiveCreateMultiArray(*componentClass, currentDimension + 1, dimensions, dimArray);
+    if (element == nullptr) {
+      return nullptr;
+    }
+    res->SetObjectElementNoRc(j, element);
+  }
+  return res.ReturnObj();
+}
+
+jobject MRT_RecursiveCreateMultiArray(const jclass arrayClass, const jint currentDimension,
+                                      const jint dimensions, jint* dimArray) {
+  const MClass *mArrayClass = MClass::JniCastNonNull(arrayClass);
+  MObject *res = RecursiveCreateMultiArray(*mArrayClass, currentDimension,
+      dimensions, reinterpret_cast<uint32_t*>(dimArray));
+  return res->AsJobject();
+}
+
+void MRT_ObjectArrayCopy(address_t javaSrc, address_t javaDst, jint srcPos, jint dstPos, jint length, bool check) {
+  Collector::Instance().ObjectArrayCopy(javaSrc, javaDst, srcPos, dstPos, length, check);
+}
+
+void ThrowArrayStoreException(const MObject &srcComponent, int index, const MClass &dstComponentType) {
+  std::ostringstream msg;
+  std::string srcBinaryName;
+  std::string dstBinaryName;
+  srcComponent.GetClass()->GetBinaryName(srcBinaryName);
+  dstComponentType.GetBinaryName(dstBinaryName);
+  msg << "source[" << std::to_string(index) << "] of type " << srcBinaryName <<
+      " cannot be stored in destination array of type " << dstBinaryName << "[]";
+  MRT_ThrowNewExceptionUnw("java/lang/ArrayStoreException", msg.str().c_str());
+}
+
+bool AssignableCheckingObjectCopy(const MClass &dstComponentType, MClass *&lastAssignableComponentType,
+                                  const MObject *srcComponent) {
+  if (srcComponent != nullptr) {
+    MClass *srcComponentType = srcComponent->GetClass();
+    if (LIKELY(srcComponentType == lastAssignableComponentType)) {
+    } else if (LIKELY(dstComponentType.IsAssignableFrom(*srcComponentType))) {
+      lastAssignableComponentType = srcComponentType;
+    } else {
+      return false;
+    }
+    return true;
+  } else {
+    return true;
+  }
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_class_init.cpp b/src/mrt/maplert/src/mrt_class_init.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0495c4345898b23cfb7bd91d0ea6a9995f700db7
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_class_init.cpp
@@ -0,0 +1,489 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_class_init.h"
+#include <cassert>
+#include <cstdlib>
+#include <fstream>
+#include <vector>
+#include <sys/syscall.h>
+#include <sys/mman.h>
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <dlfcn.h>
+#include "libs.h"
+#include "object_base.h"
+#include "exception/mrt_exception.h"
+#include "allocator/mem_map.h"
+#include "verifier.h"
+
+namespace maplert {
+class ClinitLog {
+  static std::mutex logMtx;
+
+ public:
+  static std::ostringstream logStream;
+
+  ClinitLog() {
+    logMtx.lock();
+  }
+
+  ~ClinitLog() {
+    logMtx.unlock();
+  }
+
+  std::ostream &Stream() {
+    return logStream;
+  }
+};
+
+std::ostringstream ClinitLog::logStream;
+std::mutex ClinitLog::logMtx;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+__attribute__((aligned(4096), visibility("default")))
+uint8_t classInitProtectRegion[kPageSize];
+
+void MRT_InitProtectedMemoryForClinit() {
+  int err = mprotect(&classInitProtectRegion, kPageSize, PROT_NONE);
+  if (err != 0) {
+    EHLOG(FATAL) << "failed to protect classInitProtectRegion" << maple::endl;
+  }
+
+  MemMap::Option opt = MemMap::kDefaultOptions;
+  opt.tag = "maple_clinited_state";
+  opt.lowestAddr = kClInitStateAddrBase;
+  opt.highestAddr = kClInitStateAddrBase + kPageSize;
+  opt.prot = PROT_READ;
+  MemMap *memMap = MemMap::CreateMemMapAtExactAddress(reinterpret_cast<void*>(opt.lowestAddr), kPageSize, opt);
+  if (memMap == nullptr || reinterpret_cast<uintptr_t>(memMap->GetBaseAddr()) != opt.lowestAddr) {
+    EHLOG(FATAL) << "failed to initialize memory page for ClassInitState::kClassInitialized" << maple::endl;
+  }
+}
+
+static ClassInitState TryInitClass(const MClass &classObj, bool recursive);
+static void RecordKlassInitFailed(const MClass &klass);
+static void RecordKlassInitializing(const MClass &klass);
+static void RecordKlassInitialized(const MClass &klass);
+static void CallClinit(uintptr_t clinitFuncAddr, MClass &klass);
+static void RecordNoClinitFuncState(MClass &klass);
+bool MRT_ClassInitialized(const jclass klass) {
+  const MClass *classInfo = MClass::JniCast(klass);
+  return classInfo->IsInitialized();
+}
+
+static atomic<int> classCountEnable;
+struct ClassCountEnableInit {
+ public:
+  ClassCountEnableInit() {
+    classCountEnable.store(VLOG_IS_ON(classinit), std::memory_order_relaxed);
+  }
+};
+
+ClassCountEnableInit classCountEnableInit;
+
+extern "C" void MRT_ClinitEnableCount(bool enable) {
+  if (enable) {
+    classCountEnable.store(1, std::memory_order_relaxed);
+  } else {
+    classCountEnable.store(0, std::memory_order_relaxed);
+  }
+}
+
+inline int MrtGetClassCountEnable() {
+  return classCountEnable.load(std::memory_order_relaxed);
+}
+
+// only initialize its super class and interfaces, excluding itself.
+static void InitSuperClasses(MClass &mrtClass, bool recursive) {
+  MClass *klass = &mrtClass;
+  uint32_t numOfSuperClass = klass->GetNumOfSuperClasses();
+  MClass **superArray = klass->GetSuperClassArray();
+  if (superArray == nullptr || !recursive) {
+    return;
+  }
+
+  for (uint32_t i = 0; i < numOfSuperClass; ++i) {
+    MClass *superKlass = superArray[i];
+    if (UNLIKELY(superKlass == nullptr)) {
+      MRT_ThrowNoClassDefFoundError("Failed to init super class, maybe it is not defined!");
+      return;
+    }
+    if (superKlass->IsInterface()) {
+      if (VLOG_IS_ON(classinit)) {
+        ClinitLog().Stream() << "\t\t2. " << klass->GetName() << ": run <clinit> for super interface " <<
+            superKlass->GetName() << maple::endl;
+      }
+
+      // initialize the interface that declares a non-abstract, non-static method
+      std::vector<MethodMeta*> methodsVector;
+      superKlass->GetDeclaredMethods(methodsVector, false);
+      bool needclinit = std::any_of(methodsVector.cbegin(), methodsVector.cend(), [](const MethodMeta *elementObj) {
+          return elementObj->IsDefault();
+      });
+      if (needclinit) {
+        (void)TryInitClass(*superKlass, true);
+      } else {
+        InitSuperClasses(*superKlass, true);
+      }
+    } else {
+      if (VLOG_IS_ON(classinit)) {
+        ClinitLog().Stream() << "\t\t2. " << klass->GetName() << ": run <clinit> for super class " <<
+            superKlass->GetName() << maple::endl;
+      }
+      (void)TryInitClass(*superKlass, true);
+    }
+  }
+}
+
+static ClassInitState InitClassImpl(MClass &mrtclass, bool recursive) {
+  MClass *klass = &mrtclass;
+#ifdef LINKER_LAZY_BINDING
+  // We link the class forwardly when clinit.
+  if (klass->IsLazyBinding() && LinkerAPI::Instance().GetLinkerMFileInfoByAddress(klass, true) != nullptr) {
+    VLOG(lazybinding) << "InitClassImpl(), link lazily for " << klass->GetName() <<
+        ", lazy=" << klass->IsLazyBinding() << ", cold=" << klass->IsColdClass() << maple::endl;
+    (void)LinkerAPI::Instance().LinkClassLazily(reinterpret_cast<jclass>(klass));
+  }
+#endif // LINKER_LAZY_BINDING
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "\t\t0. " << klass->GetName() << ": try <clinit>" << maple::endl;
+  }
+  // class info won't free, so don't add ScopedObjectAccess
+  if (maple::ObjectBase::MonitorEnter(reinterpret_cast<address_t>(klass)) == JNI_ERR) {
+    EHLOG(ERROR) << "maple::ObjectBase::MonitorEnter in InitClassImpl() fail" << maple::endl;
+  }
+
+  // after we obtain the lock, we should double-check init state
+  ClassInitState state = klass->GetInitState();
+  // when state is failure, we should unlock
+  if (state == kClassInitFailed) {
+    RecordKlassInitFailed(*klass);
+    return state;
+  }
+  if (state == kClassInitializing) {
+    RecordKlassInitializing(*klass);
+    return state;
+  }
+  if (state == kClassInitialized) {
+    RecordKlassInitialized(*klass);
+    return state;
+  }
+
+  klass->SetInitState(kClassInitializing);
+
+  InitSuperClasses(*klass, recursive);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    klass->SetInitState(kClassInitFailed);
+    // pending exception indicates what the problem is
+    EHLOG(ERROR) << klass->GetName() << " failed to be initialized due to pending exception" << maple::endl;
+  } else {
+    // find <clinit> and prepare to call <clinit> if existed
+    uintptr_t clinitFuncAddr = klass->GetClinitFuncAddr();
+    if (clinitFuncAddr != 0) {
+      CallClinit(clinitFuncAddr, *klass);
+    } else {
+      RecordNoClinitFuncState(*klass);
+    }
+  }
+
+  if (maple::ObjectBase::MonitorExit(reinterpret_cast<address_t>(klass)) == JNI_ERR) {
+    EHLOG(ERROR) << "maple::ObjectBase::MonitorExit in InitClassImpl() fail" << maple::endl;
+  }
+
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "\t\t4. " << klass->GetName() << ": run <clinit> successfully" << maple::endl;
+  }
+  return klass->GetInitState();
+}
+
+
+// Record the state of klass init failed and throw exception
+static void RecordKlassInitFailed(const MClass &klass) {
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "\t\t1. " << klass.GetName() << ": <clinit> running failure" << maple::endl;
+  }
+  if (maple::ObjectBase::MonitorExit(reinterpret_cast<address_t>(const_cast<MClass*>(&klass))) == JNI_ERR) {
+    LOG(ERROR) << "maple::ObjectBase::MonitorExit in InitClassImpl() return false" << maple::endl;
+  }
+  std::string msg;
+  klass.GetTypeName(msg);
+  msg.insert(0, "Could not initialize class ");
+  MRT_ThrowNoClassDefFoundError(msg);
+}
+
+// Record the state of klass initializing
+static void RecordKlassInitializing(const MClass &klass) {
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "\t\t1. " << klass.GetName() << ": <clinit> running recursively" << maple::endl;
+  }
+  if (maple::ObjectBase::MonitorExit(reinterpret_cast<address_t>(const_cast<MClass*>(&klass))) == JNI_ERR) {
+    LOG(ERROR) << "maple::ObjectBase::MonitorExit in InitClassImpl() return false" << maple::endl;
+  }
+}
+
+// Record the state of klass initialized
+static void RecordKlassInitialized(const MClass &klass) {
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "\t\t1. " << klass.GetName() << ": <clinit> succeeded in other thread" << maple::endl;
+  }
+  if (maple::ObjectBase::MonitorExit(reinterpret_cast<address_t>(const_cast<MClass*>(&klass))) == JNI_ERR) {
+    LOG(ERROR) << "maple::ObjectBase::MonitorExit in InitClassImpl() return false" << maple::endl;
+  }
+}
+
+// Call clinit function when exists
+static void CallClinit(uintptr_t clinitFuncAddr, MClass &klass) {
+  uint64_t clinitStartTime = 0;
+  uint64_t clinitEndTime = 0;
+  if (VLOG_IS_ON(classinit) || MrtGetClassCountEnable()) {
+    clinitStartTime = timeutils::ThreadCpuTimeNs();
+  }
+  // Interp
+  if (clinitFuncAddr & 0x01) {
+    MethodMeta *clinitMethodMeta = reinterpret_cast<MClass*>(&klass)->GetClinitMethodMeta();
+    if (clinitMethodMeta != nullptr) {
+      // clinit method return void
+      (void)clinitMethodMeta->InvokeJavaMethodFast<uint8_t>(reinterpret_cast<MClass*>(&klass));
+    }
+  } else {
+    // clinit is a java method, so we use maplert::RuntimeStub<>::FastCallCompiledMethod.
+    maplert::RuntimeStub<void>::FastCallCompiledMethod(clinitFuncAddr);
+  }
+  if (VLOG_IS_ON(classinit) || MrtGetClassCountEnable()) {
+    clinitEndTime = timeutils::ThreadCpuTimeNs();
+  }
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "\t\t3. " << klass.GetName() << ": run <clinit> cost time (ns) " <<
+        (clinitEndTime - clinitStartTime) << maple::endl;
+  }
+  if (UNLIKELY(MRT_HasPendingException())) {
+    klass.SetInitState(kClassInitFailed);
+    // pending exception indicates what the problem is
+    LOG(ERROR) << klass.GetName() << " failed to be initialized due to pending exception" << maple::endl;
+  } else {
+    // tag this class is initialized already if no pending exception.
+    // any readable address is ok for now.
+    ClassInitState initState = klass.GetInitState();
+    if (initState == kClassInitializing) {
+      klass.SetInitStateRawValue(reinterpret_cast<uintptr_t>(&klass));
+    } else {
+      LOG(FATAL) << "class init state has been modified from kClassInitializing to " << initState << maple::endl;
+    }
+  }
+}
+
+// Record no clinit func state
+static void RecordNoClinitFuncState(MClass &klass) {
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "\t\t1. " << klass.GetName() << ": no <clinit>" << maple::endl;
+  }
+  ClassInitState initState = klass.GetInitState();
+  if (initState == kClassInitializing) {
+    klass.SetInitStateRawValue(reinterpret_cast<uintptr_t>(&klass));
+  } else {
+    LOG(FATAL) << "class init state has been modified from kClassInitializing to " << initState << maple::endl;
+  }
+}
+
+__thread std::vector<int64_t> *classTnitStartTimeStack = nullptr;
+__thread uint64_t classInitCurStartTime = 0;
+static int64_t classInitTotalTime  = 0;
+static int64_t classInitTotalCount = 0;
+static int64_t classInitTotalTryCount = 0;
+
+static int64_t clinitCheckTotalCount = 0;
+
+static inline int64_t IncClassInitTotalTime(int64_t delta) {
+  return __atomic_add_fetch(&classInitTotalTime, delta, __ATOMIC_ACQ_REL);
+}
+
+static inline int64_t IncClassInitTotalCount(int64_t count) {
+  return __atomic_add_fetch(&classInitTotalCount, count, __ATOMIC_ACQ_REL);
+}
+
+static inline int64_t IncClassInitTotalTryCount(int64_t count) {
+  return __atomic_add_fetch(&classInitTotalTryCount, count, __ATOMIC_ACQ_REL);
+}
+
+static inline int64_t IncClinitCheckTotalCount(int64_t count) {
+  return __atomic_add_fetch(&clinitCheckTotalCount, count, __ATOMIC_ACQ_REL);
+}
+
+extern "C" int64_t MRT_ClinitGetTotalTime() {
+  return classInitTotalTime;
+}
+
+extern "C" int64_t MRT_ClinitGetTotalCount() {
+  return classInitTotalCount;
+}
+
+extern "C" void MRT_ClinitResetStats() {
+  classInitTotalTime = 0;
+  classInitTotalCount = 0;
+}
+
+
+extern "C" void MCC_PreClinitCheck(ClassMetadata &classInfo __attribute__((unused))) {
+  int64_t totalCount = IncClinitCheckTotalCount(1);
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "-- clinit-check total count " << totalCount << maple::endl;
+  }
+}
+
+extern "C" void MCC_PostClinitCheck(ClassMetadata &classInfo __attribute__((unused))) {}
+
+static void PreInitClass(const MClass &classInfo) {
+  if (!(VLOG_IS_ON(classinit) || MrtGetClassCountEnable())) {
+    return;
+  }
+
+  int64_t totalCount = IncClassInitTotalCount(1);
+
+  if (classTnitStartTimeStack == nullptr) {
+    classTnitStartTimeStack = new std::vector<int64_t>();
+  }
+  classTnitStartTimeStack->push_back(classInitCurStartTime);
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "\t- init-class " << classInfo.GetName() <<
+        " start, recursive depth " << classTnitStartTimeStack->size() <<
+        ", total init count " << totalCount << maple::endl;
+  }
+  classInitCurStartTime = timeutils::ThreadCpuTimeNs();
+}
+
+static void PostInitClass(const MClass &classInfo) {
+  if (!(VLOG_IS_ON(classinit) || MrtGetClassCountEnable())) {
+    return;
+  }
+
+  uint64_t curEndTime = timeutils::ThreadCpuTimeNs();
+  int64_t cpuTime = curEndTime - classInitCurStartTime;
+  if (VLOG_IS_ON(classinit)) {
+    ClinitLog().Stream() << "\t- init-class " << classInfo.GetName() <<
+        " end, recursive depth " << classTnitStartTimeStack->size() << ", cost time (ns) " << cpuTime << maple::endl;
+  }
+  if (!classTnitStartTimeStack->empty()) {
+    classInitCurStartTime = classTnitStartTimeStack->back();
+    classTnitStartTimeStack->pop_back();
+  }
+  if (classTnitStartTimeStack->size() == 0) {
+    int64_t totalTime = IncClassInitTotalTime (cpuTime);
+    ClinitLog().Stream() << "\t- init-class total time (ns) " << totalTime << maple::endl;
+  }
+}
+
+static ClassInitState TryInitClass(const MClass &classObj, bool recursive) {
+  ClassInitState state = classObj.GetInitState();
+  switch (state) {
+    case kClassUninitialized:
+    case kClassInitializing: {
+      maplert::ScopedObjectAccess soa;
+      PreInitClass(classObj);
+      ClassInitState newState = InitClassImpl(const_cast<MClass&>(classObj), recursive);
+      PostInitClass(classObj);
+      return newState;
+    }
+    case kClassInitFailed: {
+      std::string msg;
+      classObj.GetTypeName(msg);
+      msg.insert(0, "Could not initialize class ");
+      // when a class initialization has failed (usually an exception is raised in <clinit> earlier)
+      MRT_ThrowNoClassDefFoundError(msg);
+      return state;
+    }
+    default: // default to "already initialized"
+      return state;
+  }
+}
+
+ClassInitState MRT_TryInitClass(const MClass &classInfo, bool recursive) {
+  if (VLOG_IS_ON(classinit) || MrtGetClassCountEnable()) {
+    int64_t totalCount = IncClassInitTotalTryCount(1);
+    ClinitLog().Stream() << "\ttry-init-class " << classInfo.GetName() <<
+        ", total try-init count " << totalCount << maple::endl;
+  }
+  if (UNLIKELY(!classInfo.IsVerified())) {
+    VLOG(bytecodeverify) << "Verify class " << classInfo.GetName() << " before <clinit>.\n";
+    VerifyClass(const_cast<MClass&>(classInfo), true);
+  }
+
+  ClassInitState state = TryInitClass(classInfo, !classInfo.IsInterface() && recursive);
+  MrtClass ex = MRT_PendingException();
+  // if we come to a pending exception due to <clinit>, this is an Initializer Error
+  if (ex != nullptr) {
+    MRT_ClearPendingException();
+    if (reinterpret_cast<MObject*>(ex)->IsInstanceOf(*WellKnown::GetMClassError())) {
+      MRT_ThrowExceptionSafe(reinterpret_cast<jobject>(ex));
+      RC_LOCAL_DEC_REF(ex);
+    } else {
+      MRT_ThrowExceptionInInitializerError(ex);
+    }
+  }
+  return state;
+}
+
+ClassInitState MRT_TryInitClassOnDemand(const MClass &classInfo) {
+  if (VLOG_IS_ON(classinit) || MrtGetClassCountEnable()) {
+    int64_t totalCount = IncClassInitTotalTryCount(1);
+    ClinitLog().Stream() << "\ttry-init-class-on-demand " << classInfo.GetName() <<
+        ", total try-init count " << totalCount << maple::endl;
+  }
+  if (UNLIKELY(!classInfo.IsVerified())) {
+    VLOG(bytecodeverify) << "Verify class " << classInfo.GetName() << " before <clinit> on demand.\n";
+    VerifyClass(const_cast<MClass&>(classInfo), false);
+  }
+  // clinit is triggered from signal
+  ClassInitState state = TryInitClass(classInfo, !classInfo.IsInterface());
+  MrtClass ex = MRT_PendingException();
+  if (ex != nullptr) {
+    MRT_ClearPendingException();
+    if (reinterpret_cast<MObject*>(ex)->IsInstanceOf(*WellKnown::GetMClassError())) {
+      ThrowExceptionUnw(ex);
+    } else {
+      MRT_ThrowExceptionInInitializerErrorUnw(ex);
+    }
+  }
+  return state;
+}
+
+bool MRT_InitClassIfNeeded(const MClass &classInfo) {
+  if (UNLIKELY(!MRT_ReflectIsInit(reinterpret_cast<jclass>(const_cast<MClass*>(&classInfo))))) {
+    if (UNLIKELY(MRT_TryInitClass(classInfo) == ClassInitState::kClassInitFailed)) {
+      EHLOG(ERROR) << "MRT_TryInitClass return fail" << maple::endl;
+    }
+    MrtClass ex = MRT_PendingException();
+    if (ex != nullptr) {
+      MRT_DumpExceptionForLog(reinterpret_cast<jthrowable>(ex));
+      RC_LOCAL_DEC_REF(ex);
+      return false;
+    }
+  }
+  return true;
+}
+
+void MRT_DumpClassClinit(std::ostream &os) {
+  os << ClinitLog::logStream.str();
+  ClinitLog::logStream.str("");
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_classloader.cpp b/src/mrt/maplert/src/mrt_classloader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5e7343c0635602e64df21416f48814879b8b58a0
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_classloader.cpp
@@ -0,0 +1,916 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "mrt_classloader.h"
+
+#include <cassert>
+#include <cstdio>
+#include <dlfcn.h>
+
+#include "cpphelper.h"
+#include "mrt_well_known.h"
+#include "exception/mrt_exception.h"
+#include "loader/object_locator.h"
+#include "yieldpoint.h"
+#include "interp_support.h"
+#include "mrt_primitive_class.def"
+#include "base/systrace.h"
+#include "chosen.h"
+namespace maplert {
+LoaderAPI *LoaderAPI::pInstance = nullptr;
+LoaderAPI &LoaderAPI::Instance() {
+  if (pInstance == nullptr) {
+    pInstance = new (std::nothrow) ClassLoaderImpl();
+    if (pInstance == nullptr) {
+      CL_LOG(FATAL) << "new ClassLoaderImpl failed" << maple::endl;
+    }
+  }
+  return *pInstance;
+}
+ClassLoaderImpl::ClassLoaderImpl() {
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALjava_2Flang_2FObject_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALjava_2Flang_2FString_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALjava_2Flang_2FClass_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALjava_2Futil_2FFormatter_24Flags_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALjava_2Futil_2FHashMap_24Node_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALjava_2Futil_2FFormatter_24FormatString_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALjava_2Flang_2FCharSequence_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(
+      &MRT_CLASSINFO(ALjava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B)));
+#ifdef __OPENJDK__
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALjava_2Futil_2FHashtable_24Entry_3B)));
+#else // libcore
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALjava_2Futil_2FHashtable_24HashtableEntry_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALlibcore_2Freflect_2FAnnotationMember_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALsun_2Fsecurity_2Futil_2FDerValue_3B)));
+  primitiveClasses.push_back(reinterpret_cast<MClass*>(&MRT_CLASSINFO(ALsun_2Fsecurity_2Fx509_2FAVA_3B)));
+#endif // __OPENJDK__
+}
+ClassLoaderImpl::~ClassLoaderImpl() {
+  mMappedClassLoader.clear();
+}
+
+void ClassLoaderImpl::UnInit() {
+  std::set<jobject> reqMplClsLoaders;
+  mMplFilesOther.GetObjLoaders(reqMplClsLoaders);
+  mMplFilesBoot.GetObjLoaders(reqMplClsLoaders);
+  for (auto it = reqMplClsLoaders.begin(); it != reqMplClsLoaders.end(); ++it) {
+    UnloadClasses(reinterpret_cast<const MObject*>(*it));
+  }
+
+  std::vector<const ObjFile*> regMplFiles;
+  mMplFilesOther.GetObjFiles(regMplFiles);
+  mMplFilesBoot.GetObjFiles(regMplFiles);
+
+  for (auto it = regMplFiles.begin(); it != regMplFiles.end(); ++it) {
+    delete *it;
+    *it = nullptr;
+  }
+  ObjectLoader::UnInit();
+}
+
+void ClassLoaderImpl::ResetCLCache() {
+  CLCache::instance.ResetCache();
+}
+
+jclass ClassLoaderImpl::GetCache(const jclass contextClass, const std::string &className,
+                                 uint32_t &index, bool &lockFail) {
+  return CLCache::instance.GetCache(contextClass, className, index, lockFail);
+}
+
+void ClassLoaderImpl::WriteCache(const jclass klass, const jclass contextClass, uint32_t index) {
+  CLCache::instance.WriteCache(klass, contextClass, index);
+}
+
+// API Interfaces Begin
+void ClassLoaderImpl::RegisterMplFile(const ObjFile &objFile) {
+  const ObjFile *pmf = mMplFilesOther.Get(objFile.GetName());
+
+  if (pmf == nullptr) {
+    mMplFilesOther.Put(objFile.GetName(), objFile);
+  }
+}
+
+bool ClassLoaderImpl::UnRegisterMplFile(const ObjFile &objFile) {
+  if (GetMplFileRegistered(objFile.GetName()) == nullptr) {
+    RemoveMappedClassLoader(objFile.GetName());
+    delete &objFile;
+    return true;
+  }
+  return false;
+}
+
+bool ClassLoaderImpl::RegisterJniClass(IEnv env, jclass javaClass, const std::string &mFileName,
+    const std::string &jniClassName, INativeMethod methods, int32_t methodCount, bool fake) {
+  if (mFileName.empty()) {
+    return mMplFilesOther.Register(env, javaClass, jniClassName, methods, methodCount, fake);
+  }
+  const ObjFile *mf = mMplFilesBoot.Get(mFileName);
+  if (mf == nullptr) {
+    mf = mMplFilesOther.Get(mFileName);
+  }
+  ObjFile *objFile = const_cast<ObjFile*>(mf);
+  if (mf != nullptr && objFile->CanRegisterNativeMethods(jniClassName) && (objFile->RegisterNativeMethods(env,
+      javaClass, jniClassName, methods, methodCount, fake) == true)) {
+    return true;
+  }
+  return false;
+}
+
+size_t ClassLoaderImpl::GetListSize(AdapterFileList type) {
+  if (type == kMplFileBootList) {
+    return mMplFilesBoot.GetRegisterSize();
+  } else {
+    return mMplFilesOther.GetRegisterSize();
+  }
+}
+
+const ObjFile *ClassLoaderImpl::GetMplFileRegistered(const std::string &name) {
+  const ObjFile *pmf = mMplFilesBoot.Get(name);
+
+  if (pmf != nullptr) {
+    return pmf;
+  }
+
+  return mMplFilesOther.Get(name);
+}
+
+const ObjFile *ClassLoaderImpl::GetAppMplFileRegistered(const std::string &packageApk) {
+  std::vector<const ObjFile*> files;
+  mMplFilesOther.GetObjFiles(files);
+  std::string package;
+  std::string apkName;
+  std::string::size_type index = packageApk.find("/");
+  if (index == std::string::npos) {
+    CL_LOG(ERROR) << "packageApk must $package_name/xx.apk " << packageApk.c_str() << maple::endl;
+    return nullptr;
+  } else {
+    package = packageApk.substr(0, index);
+    apkName = packageApk.substr(index + 1);
+  }
+  for (auto it = files.begin(); it != files.end(); ++it) {
+    std::string soName = (*it)->GetName();
+    // different installation, different so name
+    // adb push: /system/priv-app/Calendar/Calendar.apk!/maple/arm64/mapleclasses.so
+    // adb install: /data/app/com.android.calendar-C5VubFGVWn3V4prwdHIuHQ==/base.apk!/maple/arm64/mapleclasses.so
+    if ((soName.find(kAppSoPostfix) != std::string::npos || soName.find(kAppPartialSoPostfix) != std::string::npos) &&
+        (soName.find(package) != std::string::npos || soName.find(apkName) != std::string::npos)) {
+      return *it;
+    }
+  }
+  return nullptr;
+}
+
+bool ClassLoaderImpl::LoadMplFileInBootClassPath(const std::string &pathString) {
+  maple::ScopedTrace trace("LoadMplFileInBootClassPath, %p", pathString.c_str());
+  if (pathString.length() < 1) {
+    return false;
+  }
+  // split class_pathString to arraylist;
+  std::vector<std::string> classPaths = stringutils::Split(pathString, ':');
+  // store the boot class path
+  jobject classLoader = nullptr;
+  // loop to process boot classpath
+  std::vector<ObjFile*> objList;
+  pLinker->SetLoadState(kLoadStateBoot);
+  for (std::string &path : classPaths) {
+    std::string jarName = path;
+    size_t pos = path.rfind("/");
+    if (pos != std::string::npos && pos < path.length()) {
+      jarName = path.substr(pos + 1);
+    }
+    if (kIgnoreJarList.find(jarName) != std::string::npos) {
+      continue;
+    }
+
+    FileAdapter adapter(path, pAdapterEx);
+    ObjFile *objFile = adapter.OpenObjectFile(classLoader);
+
+    if (objFile == nullptr) {
+      std::string message = "Failed to dlopen " + path;
+      (void)(pAdapterEx->EnableMygote(false, message));
+      return false;
+    }
+
+    if (objFile->GetFileType() == FileType::kMFile) {
+      if (!pLinker->Add(*objFile, classLoader)) {
+        CL_LOG(ERROR) << "invalid maple file" << path << ", lazy=" << objFile->IsLazyBinding() << objFile->GetName() <<
+            maple::endl;
+        delete objFile;
+        continue;
+      }
+
+      mMplFilesBoot.Put(objFile->GetName(), *objFile);
+      objFile->Load();
+      objList.push_back(objFile);
+    } else {
+      CL_LOG(ERROR) << "open Non maple file: " << path << ", " << objFile->GetName() << maple::endl;
+      delete objFile;
+      objFile = nullptr;
+    }
+  }
+  if (!LoadClasses(reinterpret_cast<MObject*>(classLoader), objList)) {
+    (void)pAdapterEx->EnableMygote(false, "Failed to load classes.");
+    return false;
+  }
+  // For boot class loader, we just link when load so.
+  (void)(pLinker->Link());
+  SetLinked(classLoader, false);
+  return true;
+}
+
+bool ClassLoaderImpl::LoadMplFileInAppClassPath(jobject clLoader, FileAdapter &adapter) {
+  maple::ScopedTrace trace("LoadMplFileInAppClassPath, %p", adapter.GetConvertPath().c_str());
+  MObject *classLoader = reinterpret_cast<MObject*>(clLoader);
+  bool isFallBack = false;
+  do {
+    std::vector<std::string> pathList;
+    adapter.GetObjFileList(pathList, isFallBack);
+    // Load classes in all MplFiles and add LinkerMFileInfo
+    std::vector<LinkerMFileInfo*> mplInfoList;
+    for (auto path : pathList) {
+      // 1. check mpl file if registered
+      const ObjFile *pmfCookie = GetMplFileRegistered(path);
+      if (LIKELY(pmfCookie == nullptr)) {
+        // 2. open mpl file
+        ObjFile *pmf = adapter.OpenObjectFile(clLoader, isFallBack, path);
+        if (pmf == nullptr) {
+          CL_LOG(ERROR) << "failed to open maple file " << path << ", classloader:" << classLoader << maple::endl;
+          if (isFallBack) {
+            MRT_ThrowNewException("java/io/IOException", path.c_str());
+          }
+          continue;
+        }
+        if (!pLinker->IsFrontPatchMode(path) && classLoader != nullptr) {
+          // 3. load mpl file's classes to classloader
+          if (!LoadClassesFromMplFile(classLoader, *pmf, mplInfoList, adapter.HasSiblings())) {
+            delete pmf;
+            CL_LOG(ERROR) << "failed to load maple file " << path << ", classloader:" << classLoader << maple::endl;
+            MRT_ThrowNewException("java/io/IOException", path.c_str());
+            continue;
+          }
+        }
+        RegisterMplFile(*pmf);
+        pmfCookie = pmf;
+      } else if (pmfCookie->GetClassLoader() != clLoader) {
+        std::string message = "Attempt to load the same maple file " + path + " in with multiple class loaders";
+        CL_LOG(ERROR) << message << maple::endl;
+        if (!SetMappedClassLoader(path, classLoader, reinterpret_cast<MObject*>(pmfCookie->GetClassLoader()))) {
+          MRT_ThrowNewException("java/lang/InternalError", message.c_str());
+          continue;
+        } else if (VLOG_IS_ON(classloader)) {
+          adapter.DumpMethodName();
+        }
+      }
+      if (pmfCookie != nullptr) {
+        adapter.Put(adapter.GetOriginPath(), *pmfCookie);
+      }
+    }
+    // A workaround for class's muid failed to resolve issue when multi-so loading
+    if (!isFallBack && adapter.HasSiblings()) {
+      LinkStartUpAndMultiSo(mplInfoList, adapter.HasStartUp());
+    }
+    isFallBack = !isFallBack && (adapter.GetSize() == 0 || adapter.IsPartialAot());
+  } while (isFallBack);
+  return (adapter.GetSize() > 0) ? true : false;
+}
+
+#ifndef __ANDROID__
+// Only for QEMU mplsh test.
+bool ClassLoaderImpl::LoadMplFileInUserClassPath(const std::string &paths) {
+  maple::ScopedTrace trace("LoadMplFileInUserClassPath, %p", paths.c_str());
+  CL_VLOG(classloader) << paths << maple::endl;
+
+  if (paths.length() < 1) {
+    CL_LOG(ERROR) << "class path is null for SystemClassLoader!!" << maple::endl;
+    return true;
+  }
+
+  // split class path string (paths) to arraylist;
+  std::vector<std::string> clsPaths = stringutils::Split(paths, ':');
+
+  MObject *classLoader = mSystemClassLoader;
+  std::vector<ObjFile*> objList;
+  for (auto path : clsPaths) {
+    FileAdapter adapter(path, pAdapterEx);
+    ObjFile *objFile = adapter.OpenObjectFile(reinterpret_cast<jobject>(classLoader));  // check for MFile first
+    if (objFile != nullptr && objFile->GetFileType() == FileType::kMFile) {
+      // MFile open OK. continue the linking process
+      if (!pLinker->Add(*objFile, reinterpret_cast<jobject>(classLoader))) {
+        CL_LOG(ERROR) << "invalid maple file or multiple loading:" << path << ", " << objFile->GetName() << maple::endl;
+        delete objFile;
+        continue;
+      }
+      mMplFilesOther.Put(path, *objFile);
+      objFile->Load();
+      objList.push_back(objFile);
+    } else {
+      objFile = adapter.OpenObjectFile(reinterpret_cast<jobject>(classLoader), true);
+      // try MFile failed, then check for DFile
+      if (objFile == nullptr) {  // try DFile also failed, stop loading.
+        CL_LOG(ERROR) << "open " << path << "failed!" << maple::endl;
+        return false;
+      }
+      // DFile open OK. continue the linking process
+      // Note: objFile should be of type FileType::kDFile
+      std::vector<LinkerMFileInfo*> infoList;
+      if (!LoadClassesFromMplFile(classLoader, *objFile, infoList)) {
+        // loading the classes list in this dexFile failed
+        CL_LOG(ERROR) << "open " << path << "failed! size=" << infoList.size() << maple::endl;
+        delete objFile;
+        continue;
+      }
+      mMplFilesOther.Put(path, *objFile);
+    }
+  }
+  (void)(pLinker->Link());
+  SetLinked(reinterpret_cast<jobject>(classLoader), false);
+  if (!LoadClasses(classLoader, objList)) {
+    CL_LOG(ERROR) << "load class failed!!" << maple::endl;
+    return false;
+  }
+  return true;
+}
+#endif
+
+jclass ClassLoaderImpl::FindClass(const std::string &className, const SearchFilter &constFilter) {
+  std::string javaDescriptor; // Like Ljava/lang/Object;
+  MClass *klass = nullptr;
+  jobject systemClassLoader = reinterpret_cast<jobject>(mSystemClassLoader);
+  SearchFilter &filter = const_cast<SearchFilter&>(constFilter);
+  // Like Ljava/lang/Object;
+  javaDescriptor = filter.isInternalName ? GetClassNametoDescriptor(className) : className;
+  if (UNLIKELY(javaDescriptor.empty())) {
+    CL_LOG(ERROR) << "javaDescriptor is nullptr" << maple::endl;
+  }
+  filter.contextCL = IsBootClassLoader(filter.specificCL) ? nullptr : filter.specificCL;
+  if (filter.isLowerDelegate && filter.contextCL != nullptr) {
+    // For delegate last class loader, the search order is as below:
+    //  . boot class loader
+    //  . current class loader
+    //  . parent class loader
+    // Otherwise, the order is as below:
+    //  . parent class loader (Includes boot class loader)
+    //  . current class loader
+    if (filter.isDelegateLast) {
+      klass = LocateInCurrentClassLoader(javaDescriptor, filter.Reset());
+    } else {
+      klass = LocateInParentClassLoader(javaDescriptor, filter.Reset());
+    }
+    if (klass == nullptr && !filter.IsNullOrSystem(systemClassLoader)) {
+      filter.currentCL = systemClassLoader;
+      klass = reinterpret_cast<MClass*>(LocateClass(javaDescriptor, filter.ResetFile()));
+    }
+    if (klass == nullptr && !filter.IsBootOrSystem(systemClassLoader)) {
+      klass = reinterpret_cast<MClass*>(
+          LinkerAPI::Instance().InvokeClassLoaderLoadClass(filter.contextCL, javaDescriptor));
+    }
+  } else {
+    klass = FindClassInSingleClassLoader(javaDescriptor, filter.Reset());
+  }
+  // It could be normal here. We are searching class by parent-delegation-model, so we may not find class in parent
+  // classLoader temporarily.
+  if (UNLIKELY(klass == nullptr)) {
+    CL_DLOG(classloader) << "failed, classloader=" << filter.contextCL << ", cl name=" <<
+        (filter.contextCL == nullptr ? "BootCL(null)" : reinterpret_cast<MObject*>(
+        filter.contextCL)->GetClass()->GetName()) << ", class name=" << className << maple::endl;
+    return nullptr;
+  }
+  MObject *pendingClassLoader = GetClassCL(klass);
+  if (pendingClassLoader == nullptr && klass->IsLazyBinding()) {
+    CL_VLOG(classloader) << className << ", from boot, and lazy" << maple::endl;
+    SetClassCL(reinterpret_cast<jclass>(klass), filter.contextCL);
+  }
+  return reinterpret_cast<jclass>(klass);
+}
+
+void ClassLoaderImpl::DumpUnregisterNativeFunc(std::ostream &os) {
+  if (VLOG_IS_ON(binding)) {
+    CL_VLOG(classloader) << "boot class:" << maple::endl;
+    mMplFilesBoot.DumpUnregisterNativeFunc(os);
+    CL_VLOG(classloader) << "application class:" << maple::endl;
+    mMplFilesOther.DumpUnregisterNativeFunc(os);
+  }
+}
+
+void ClassLoaderImpl::VisitClasses(maple::rootObjectFunc &func) {
+  std::vector<const ObjFile*> files;
+  std::vector<const ObjFile*> files2;
+  mMplFilesOther.GetObjFiles(files);
+  mMplFilesBoot.GetObjFiles(files2);
+  std::unordered_set<const MObject*> loaders;
+
+  for (auto it = files.begin(); it != files.end(); ++it) {
+    (void)(loaders.insert(reinterpret_cast<const MObject*>((*it)->GetClassLoader())));  // de-duplicate
+  }
+
+  for (auto it = files2.begin(); it != files2.end(); ++it) {
+    (void)(loaders.insert(reinterpret_cast<const MObject*>((*it)->GetClassLoader())));  // de-duplicate
+  }
+
+  (void)(loaders.insert(nullptr));  // bootstrap class loader
+
+  for (auto it = loaders.begin(); it != loaders.end(); ++it) {
+    VisitClassesByLoader(*it, func);
+  }
+}
+
+// Get all mapped {classLoader, mpl_file_handle} by latter classloader.
+bool ClassLoaderImpl::GetMappedClassLoaders(const jobject classLoader,
+    std::vector<std::pair<jobject, const ObjFile*>> &mappedPairs) {
+  bool ret = false;
+
+  for (auto it = mMappedClassLoader.begin(); it != mMappedClassLoader.end(); ++it) {
+    std::string fileName = it->first;
+    jobject latterClassLoader = reinterpret_cast<jobject>(it->second.first);
+    jobject mappedClassLoader = reinterpret_cast<jobject>(it->second.second);
+
+    if (classLoader == latterClassLoader) {
+      const ObjFile *pmfCookies = GetMplFileRegistered(fileName);
+      mappedPairs.push_back(std::make_pair(mappedClassLoader, pmfCookies));
+      ret = true;
+      CL_LOG(INFO) << classLoader << "->{" << mappedClassLoader << "," << fileName << "}" << maple::endl;
+    }
+  }
+  return ret;
+}
+
+bool ClassLoaderImpl::GetMappedClassLoader(const std::string &fileName, jobject classLoader, jobject &realClassLoader) {
+  auto range = mMappedClassLoader.equal_range(fileName);
+
+  for (auto val = range.first; val != range.second; ++val) {
+    if (classLoader == reinterpret_cast<jobject>(val->second.first)) {
+      realClassLoader = reinterpret_cast<jobject>(val->second.second);
+      CL_LOG(INFO) << "get mapped classLoader from " << classLoader << ":" << realClassLoader << " for " << fileName <<
+          maple::endl;
+      return true;
+    }
+  }
+
+  CL_LOG(ERROR) << "failed, get mapped classLoader from " << classLoader << " for " << fileName << maple::endl;
+  return false;
+}
+
+bool ClassLoaderImpl::RegisterNativeMethods(ObjFile &objFile,
+    jclass klass, INativeMethod methods, int32_t methodCount) {
+  return MClassLocatorManagerInterpEx::RegisterNativeMethods(*this, objFile,
+      klass, methods.As<const JNINativeMethod*>(), methodCount);
+}
+// -----------------------MRT_EXPORT Split--------------------------------------
+jclass ClassLoaderImpl::LocateClass(const std::string &className, const SearchFilter &constFilter) {
+  SearchFilter &filter = const_cast<SearchFilter&>(constFilter);
+  ClassLocator *classLocator = GetCLClassTable(filter.currentCL).As<ClassLocator*>();
+  if (classLocator == nullptr) {
+    return nullptr;
+  }
+  MClass *klass = classLocator->InquireClass(className, filter);
+  if (klass == nullptr) {
+    return nullptr;
+  }
+
+  if (klass->GetClIndex() == kClIndexUnInit) { // For lazy binding.
+    SetClassCL(reinterpret_cast<jclass>(klass), filter.currentCL);
+  }
+
+  return reinterpret_cast<jclass>(klass);
+}
+// API Interfaces End
+bool ClassLoaderImpl::SetMappedClassLoader(const std::string &fileName,
+    MObject *classLoader, MObject *realClassLoader) {
+  auto range = mMappedClassLoader.equal_range(fileName);
+
+  for (auto val = range.first; val != range.second; ++val) {
+    if (classLoader == val->second.first) {
+      CL_LOG(ERROR) << "failed, shouldn't double map " << classLoader << " to " << realClassLoader << " for " <<
+          fileName << maple::endl;
+      return true;
+    }
+  }
+  (void)(mMappedClassLoader.emplace(fileName, std::make_pair(classLoader, realClassLoader)));
+  CL_LOG(INFO) << "mapped " << classLoader << " to " << realClassLoader << " for " << fileName << maple::endl;
+  return true;
+}
+
+void ClassLoaderImpl::RemoveMappedClassLoader(const std::string &fileName) {
+  (void)(mMappedClassLoader.erase(fileName));
+}
+
+// For delegate last class loader, the search order is as below:
+//  . boot class loader
+//  . current class loader
+//  . parent class loader
+MClass *ClassLoaderImpl::LocateInCurrentClassLoader(const std::string &className, SearchFilter &filter) {
+  MClass *klass = nullptr;
+  if (IsBootClassLoader(filter.contextCL)) { // Boot class loder
+    klass = reinterpret_cast<MClass*>(LocateClass(className, filter.Clear()));
+    return klass;
+  }
+
+  // Current class loader
+  klass = reinterpret_cast<MClass*>(LocateClass(className, filter.ResetClear()));
+  if (klass != nullptr) {
+    return klass;
+  }
+  // To traverse in parents.
+  filter.currentCL = GetCLParent(filter.contextCL);
+  filter.ignoreBootSystem = true;
+  klass = LocateInParentClassLoader(className, filter.ResetFile());
+  return klass;
+}
+
+MClass *ClassLoaderImpl::LocateInParentClassLoader(const std::string &className, SearchFilter &filter) {
+  MClass *klass = nullptr;
+  if (IsBootClassLoader(filter.currentCL)) { // Boot class loder
+    if (filter.ignoreBootSystem) { // Not to search in BootClassLoader and SystemClassLoader
+      return nullptr;
+    }
+    klass = reinterpret_cast<MClass*>(LocateClass(className, filter.ClearFile()));
+    return klass;
+  }
+
+  jobject classLoader = filter.currentCL;
+  filter.currentCL = GetCLParent(classLoader);
+  if ((klass = LocateInParentClassLoader(className, filter)) == nullptr) {
+    filter.currentCL = classLoader;
+    klass = reinterpret_cast<MClass*>(LocateClass(className, filter.ResetFile()));
+  }
+  return klass;
+}
+
+// Reduce cyclomatic complexity of FindClass().
+// Before find the class in current classloader, check the boot firstly.
+MClass *ClassLoaderImpl::FindClassInSingleClassLoader(const std::string &javaDescriptor, SearchFilter &filter) {
+  MClass *klass = nullptr;
+  jobject systemClassLoader = reinterpret_cast<jobject>(mSystemClassLoader);
+  // If current is boot classloader, or not boot but its parent is null, we check the boot classLoader firsly.
+  if (filter.contextCL == nullptr || GetCLParent(filter.contextCL) == nullptr) {
+    klass = reinterpret_cast<MClass*>(LocateClass(javaDescriptor, filter.Clear()));
+  }
+  // check the current classloader, if it's not boot or system classloader
+  if (klass == nullptr && !filter.IsBootOrSystem(systemClassLoader)) {
+    // Find in current classloader.
+    klass = reinterpret_cast<MClass*>(LocateClass(javaDescriptor, filter.Reset()));
+  }
+
+  // at last for the shared libraries, we check system classloader
+  if (klass == nullptr && filter.contextCL != nullptr && systemClassLoader != nullptr) {
+    // Find in systemclassloader.
+    filter.currentCL = systemClassLoader;
+    klass = reinterpret_cast<MClass*>(LocateClass(javaDescriptor, filter.ClearFile()));
+  }
+  return klass;
+}
+
+void ClassLoaderImpl::LinkStartUpAndMultiSo(std::vector<LinkerMFileInfo*> &mplInfoList, bool hasStartup) {
+  if (mplInfoList.size() > 0) {  // We always load the first one, no matter is startup or not.
+    (void)(pLinker->Link(*(mplInfoList[0]), false));
+  }
+  for (size_t i = 1; i < mplInfoList.size(); ++i) {
+    auto mplInfo = mplInfoList[i];
+    void *param[] = { reinterpret_cast<void*>(pLinker), reinterpret_cast<void*>(mplInfo) };
+    if (hasStartup) {
+      pAdapterEx->CreateThreadAndLoadFollowingClasses([](void *data)->void* {
+          void **p =  reinterpret_cast<void**>(data);
+          LinkerAPI *linker = reinterpret_cast<LinkerAPI*>(p[0]);
+          LinkerMFileInfo *info = reinterpret_cast<LinkerMFileInfo*>(p[1]);
+          (void)(linker->Link(*info, false));
+          return nullptr;
+      }, param);
+    } else {
+      (void)(pLinker->Link(*mplInfo, false));
+    }
+  }
+#ifdef LINKER_DECOUPLE
+  (void)pLinker->HandleDecouple(mplInfoList);
+#endif
+}
+
+MClass *ClassLoaderImpl::GetPrimitiveClass(const std::string &mplClassName) {
+  MClass *classInfo = nullptr;
+  // check the dimension of the type
+  size_t dim = 0;
+  while (mplClassName[dim] == '[') {
+    ++dim;
+  }
+  // predefined primitive types has a dimension <= 3
+  if (dim > 3) {
+    return nullptr;
+  }
+
+  char typeChar = mplClassName[0];
+  if (dim > 0) {
+    typeChar = mplClassName[dim];
+  }
+  switch (typeChar) {
+    case 'Z':
+      classInfo = reinterpret_cast<MClass*>(__mrt_pclasses_Z[dim]); // boolean
+      break;
+    case 'B':
+      classInfo = reinterpret_cast<MClass*>(__mrt_pclasses_B[dim]); // byte
+      break;
+    case 'S':
+      classInfo = reinterpret_cast<MClass*>(__mrt_pclasses_S[dim]); // short
+      break;
+    case 'C':
+      classInfo = reinterpret_cast<MClass*>(__mrt_pclasses_C[dim]); // char
+      break;
+    case 'I':
+      classInfo = reinterpret_cast<MClass*>(__mrt_pclasses_I[dim]); // int
+      break;
+    case 'F':
+      classInfo = reinterpret_cast<MClass*>(__mrt_pclasses_F[dim]); // float
+      break;
+    case 'D':
+      classInfo = reinterpret_cast<MClass*>(__mrt_pclasses_D[dim]); // double
+      break;
+    case 'J':
+      classInfo = reinterpret_cast<MClass*>(__mrt_pclasses_J[dim]); // long
+      break;
+    case 'V':
+      classInfo = reinterpret_cast<MClass*>(__mrt_pclasses_V[dim]); // void
+      break;
+    default:
+      break;
+  }
+  if (classInfo != nullptr) {
+    JSAN_ADD_CLASS_METADATA(classInfo); // Need move this func to init func.
+    classInfo->SetClIndex(static_cast<uint16_t>(kClIndexFlag | 0)); // Initialize each class cl index as boot cl.
+  }
+  return classInfo;
+}
+
+void ClassLoaderImpl::VisitPrimitiveClass(const maple::rootObjectFunc &func) {
+  // primitive and primitive array classes
+  func((maple::address_t)__mrt_pclasses_V[0]); // void
+  // predefined primitive types has a dimension <= 3
+  for (int dim = 0; dim <= 3; ++dim) {
+    func((maple::address_t)__mrt_pclasses_Z[dim]); // boolean
+    func((maple::address_t)__mrt_pclasses_B[dim]); // byte
+    func((maple::address_t)__mrt_pclasses_S[dim]); // short
+    func((maple::address_t)__mrt_pclasses_C[dim]); // char
+    func((maple::address_t)__mrt_pclasses_I[dim]); // int
+    func((maple::address_t)__mrt_pclasses_F[dim]); // float
+    func((maple::address_t)__mrt_pclasses_D[dim]); // double
+    func((maple::address_t)__mrt_pclasses_J[dim]); // long
+  }
+}
+
+MClass *ClassLoaderImpl::DoCreateArrayClass(MClass &klass, MClass &componentClass, const std::string &name) {
+  MRTSetMetadataShadow(reinterpret_cast<ClassMetadata*>(&klass), WellKnown::GetMClassClass());
+  klass.SetMonitor(0);
+  klass.SetClIndex(componentClass.GetClIndex());
+  klass.SetObjectSize(sizeof(reffield_t)); // here should all be object classes
+
+#ifdef USE_32BIT_REF
+  klass.SetFlag(FLAG_CLASS_ARRAY);
+  klass.SetNumOfSuperClasses(0);
+#endif // USE_32BIT_REF
+
+  ClassMetadataRO *classMetadataRo = reinterpret_cast<ClassMetadataRO*>(
+      reinterpret_cast<uintptr_t>(&klass) + sizeof(ClassMetadata));
+  klass.SetClassMetaRoData(reinterpret_cast<uintptr_t>(classMetadataRo));
+  klass.SetItable(0);
+  klass.SetVtable(VTAB_OBJECT);
+  klass.SetGctib(reinterpret_cast<uintptr_t>(GCTIB_OBJECT_ARRAY));
+  classMetadataRo->className.SetRef(name.c_str());
+  classMetadataRo->fields.SetDataRef(nullptr);
+  classMetadataRo->methods.SetDataRef(nullptr);
+  classMetadataRo->componentClass.SetDataRef(&componentClass);
+  uint32_t modifiers = componentClass.GetArrayModifiers();
+  classMetadataRo->numOfFields = 0;
+  classMetadataRo->numOfMethods = 0;
+#ifndef USE_32BIT_REF
+  classMetadataRo->flag = FLAG_CLASS_ARRAY;
+  classMetadataRo->numOfSuperclasses = 0;
+  classMetadataRo->padding = 0;
+#endif // !USE_32BIT_REF
+  classMetadataRo->mod = modifiers;
+  classMetadataRo->annotation.SetDataRef(nullptr);
+  classMetadataRo->clinitAddr.SetDataRef(nullptr);
+  // set this class as initialized with a readable address *klass*
+  klass.SetInitStateRawValue(reinterpret_cast<uintptr_t>(&klass));
+  return &klass;
+}
+
+// Only create this array class, don't recursively create missing ones
+MClass *ClassLoaderImpl::CreateArrayClass(const std::string &mplClassName, MClass &componentClass) {
+  if (mplClassName.empty()) {
+    CL_LOG(ERROR) << "failed, mplClassName is null." << maple::endl;
+    return nullptr;
+  }
+  MClass *klass = reinterpret_cast<MClass*>(MRT_AllocFromMeta(sizeof(ClassMetadata) + sizeof(ClassMetadataRO),
+                                                              kClassMetaData));
+  const std::string *allocName;
+  // must alloc head obj, otherwise mplClassName will be free in advance
+  allocName = new (std::nothrow) std::string(mplClassName);
+  if (allocName == nullptr) {
+    LOG(FATAL) << "ClassLoaderImpl::CreateArrayClass: new string failed" << maple::endl;
+  }
+  return DoCreateArrayClass(*klass, componentClass, *allocName);
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+// MRT API Interfaces Begin
+bool MRT_IsClassInitialized(jclass klass) {
+  return reinterpret_cast<MClass*>(klass)->GetClIndex() != static_cast<uint16_t>(-1);
+}
+
+jobject MRT_GetNativeContexClassLoader() {
+  jclass contextCls = MRT_GetNativeContexClass();
+  if (contextCls != nullptr) {
+    return MRT_GetClassLoader(contextCls);
+  }
+  return nullptr;
+}
+
+jclass MRT_GetNativeContexClass() {
+  UnwindContext context;
+  UnwindContext &lastContext = maplert::TLMutator().GetLastJavaContext();
+  (void)MapleStack::GetLastJavaContext(context, lastContext, 0);
+  jclass clazz = nullptr;
+  if (!TryGetNativeContexClassLoaderForInterp(context, clazz)) {
+    if (context.IsCompiledContext()) {
+      clazz = context.frame.GetDeclaringClass();
+    }
+  }
+  return clazz;
+}
+
+jobject MRT_GetClassLoader(jclass klass) {
+  if (klass == nullptr) {
+    CL_LOG(ERROR) << "failed, class object is null!" << maple::endl;
+    return nullptr;
+  }
+  MObject *classLoader = LoaderAPI::As<ClassLoaderImpl&>().GetClassCL(reinterpret_cast<MClass*>(klass));
+  if (classLoader == nullptr) {
+    CL_DLOG(classloader) << "failed, classLoader returns null" << maple::endl;
+  }
+  return reinterpret_cast<jobject>(classLoader);
+}
+
+jobject MRT_ReflectGetClassLoader(jobject jobj)
+__attribute__ ((alias ("MCC_GetCurrentClassLoader")));
+
+jobject MCC_GetCurrentClassLoader(jobject caller) {
+  MClass *callerObj = reinterpret_cast<MClass*>(caller);
+  MClass *callerClass = callerObj->GetClass();
+  // when the caller function is a static method, the caller itself is the classInfo
+  if (callerClass == WellKnown::GetMClassClass()) {
+    callerClass = callerObj;
+  }
+  jobject classLoader = MRT_GetClassLoader(reinterpret_cast<jclass>(callerClass));
+  if (classLoader != nullptr) {
+    RC_LOCAL_INC_REF(classLoader);
+  }
+  return classLoader;
+}
+
+jobject MRT_GetBootClassLoader() {
+  // nullptr represents BootClassLoader in lower implementation.
+  // For upper layer, always return BootClassLoader instance, but not nullptr.
+  return LoaderAPI::As<ClassLoaderImpl&>().GetBootClassLoaderInstance();
+}
+
+// Get class in specific classloader.
+// If classLoader is null, it means finding class in bootclassloader.
+jclass MRT_GetClassByClassLoader(jobject classLoader, const std::string className) {
+  bool isDelegateLast = false;
+  MObject *mapleCl = reinterpret_cast<MObject*>(classLoader);
+  if (classLoader != nullptr) {
+    MClass *classLoaderClass = mapleCl->GetClass();
+    isDelegateLast = classLoaderClass == WellKnown::GetMClassDelegateLastClassLoader();
+    if (isDelegateLast) {
+      CL_VLOG(classloader) << "name:" << className << ", clname:" << classLoaderClass->GetName() << maple::endl;
+    }
+  }
+  jclass klass = LoaderAPI::Instance().FindClass(className, SearchFilter(classLoader, false, true, isDelegateLast));
+  if (klass != nullptr) {
+    (void)LinkerAPI::Instance().LinkClassLazily(klass);
+  }
+  return klass;
+}
+
+// Get class by reference to class in context.
+// If context class is null, it means finding class in bootclassloader.
+jclass MRT_GetClassByContextClass(jclass contextClass, const std::string className) {
+  bool isInternalName = true;
+  size_t len = className.size();
+  if (len == 0) {
+    return nullptr;
+  }
+
+  // try cache first
+  uint32_t index = 0;
+  bool lockFail(false);
+  jclass cacheResult = CLCache::instance.GetCache(contextClass, className, index, lockFail);
+  if (cacheResult) {
+    return cacheResult;
+  }
+
+  if (className[len - 1] == ';') {
+    isInternalName = false;
+  }
+
+  jclass klass = nullptr;
+  if (contextClass == nullptr) {
+    klass = LoaderAPI::Instance().FindClass(className, SearchFilter(nullptr, isInternalName, true, false));
+  } else {
+    klass = LoaderAPI::Instance().FindClass(className,
+        SearchFilter(MRT_GetClassLoader(contextClass), isInternalName, true, false));
+  }
+  if (klass != nullptr) {
+    (void)LinkerAPI::Instance().LinkClassLazily(klass);
+  }
+  if (!lockFail) {
+    CLCache::instance.WriteCache(klass, contextClass, index);
+  }
+  return klass;
+}
+
+// Get class by reference to class in context.
+// If context object is null, it means finding class in bootclassloader.
+jclass MRT_GetClassByContextObject(jobject obj, const std::string className) {
+  if (obj == nullptr) {
+    return MRT_GetClassByContextClass(nullptr, className);;
+  }
+  MObject *clsObj = reinterpret_cast<MObject*>(obj);
+  return MRT_GetClassByContextClass(reinterpret_cast<jclass>(clsObj->GetClass()), className);
+}
+CLCache CLCache::instance;
+
+jclass MRT_GetClass(jclass caller, const std::string className) {
+  uint32_t index = 0;
+  bool lockFail(false);
+  jclass cacheResult = CLCache::instance.GetCache(caller, className, index, lockFail);
+  if (cacheResult != nullptr) {
+    return cacheResult;
+  }
+
+  MClass *callerCls = reinterpret_cast<MClass*>(caller);
+  MClass *callerClass = callerCls->GetClass();
+  // When the caller function is a static method, the caller itself is the classInfo
+  if (callerClass == WellKnown::GetMClassClass()) {
+    callerClass = callerCls;
+  }
+  jobject classLoader = MRT_GetClassLoader(reinterpret_cast<jclass>(callerClass));
+  jclass klass = LoaderAPI::Instance().FindClass(className, SearchFilter(classLoader, false, true, false));
+  if (klass != nullptr) {
+    (void)LinkerAPI::Instance().LinkClassLazily(klass);
+  } else {
+    CL_LOG(ERROR) << "callerClass=" << callerClass->GetName() << ", lazy=" << callerClass->IsLazyBinding() <<
+        ", classLoader=" << classLoader << ", className=" << className << maple::endl;
+  }
+  if (!lockFail) {
+    CLCache::instance.WriteCache(klass, caller, index);
+  }
+  return klass;
+}
+
+// Notice: It's invoked by compiler generating routine.
+jclass MCC_GetClass(jclass caller, const char *className) {
+  constexpr int eightBit = 256;
+  jclass klass = MRT_GetClass(caller, className);
+  if (UNLIKELY(klass == nullptr)) {
+    char msg[eightBit] = { 0 };
+
+    MClass *callerClass = reinterpret_cast<MClass*>(caller)->GetClass();
+    // When the caller function is a static method, the caller itself is the classInfo
+    if (callerClass == WellKnown::GetMClassClass()) {
+      callerClass = reinterpret_cast<MClass*>(caller);
+    }
+    if (sprintf_s(msg, sizeof(msg), "No class found for %s, by %s", className, callerClass->GetName()) < 0) {
+      CL_LOG(ERROR) << "sprintf_s failed" << maple::endl;
+    }
+    MRT_ThrowNoClassDefFoundErrorUnw(msg);
+    return nullptr;
+  }
+  return klass;
+}
+
+void MRT_RegisterDynamicClass(jobject classLoader, jclass klass) {
+  LoaderAPI::As<ClassLoaderImpl&>().RegisterDynamicClass(
+      reinterpret_cast<const MObject*>(classLoader), reinterpret_cast<const MClass*>(klass));
+}
+
+void MRT_UnregisterDynamicClass(jobject classLoader, jclass klass) {
+  LoaderAPI::As<ClassLoaderImpl&>().UnregisterDynamicClass(
+      reinterpret_cast<const MObject*>(classLoader), reinterpret_cast<const MClass*>(klass));
+}
+#ifdef __cplusplus
+}
+#endif
+}
diff --git a/src/mrt/maplert/src/mrt_handlecommon.cpp b/src/mrt/maplert/src/mrt_handlecommon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..36775e056ee094752792e06d24d89cf3577e03cb
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_handlecommon.cpp
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_handlecommon.h"
+namespace maplert{
+MClass *GetDcClasingFromFrame() {
+  JavaFrame frame;
+  (void)MapleStack::GetLastJavaFrame(frame);
+  frame.ResolveMethodMetadata();
+  MethodMetaBase *md = reinterpret_cast<MethodMetaBase*>(const_cast<uint64_t*>(frame.GetMetadata()));
+  return md->GetDeclaringClass();
+}
+
+void ParseSignatrueType(char *descriptor, const char *&methodSig) {
+  char *tmpDescriptor = descriptor;
+  DCHECK(tmpDescriptor != nullptr) << "ParseSignatrueType::tmpDescriptor is nullptr" << maple::endl;
+  if (*methodSig != 'L' && *methodSig != '[') {
+    *descriptor = *methodSig;
+  } else {
+    if (*methodSig == '[') {
+      while (*methodSig == '[') {
+        *tmpDescriptor++ = *methodSig++;
+      }
+    }
+    if (*methodSig != 'L') {
+      *tmpDescriptor = *methodSig;
+    } else {
+      while (*methodSig != ';') {
+        *tmpDescriptor++ = *methodSig++;
+      }
+      *tmpDescriptor = ';';
+    }
+  }
+}
+
+string GeneIllegalArgumentExceptionString(const MClass *from, const MClass *to) {
+  string fromClassName, toClassName;
+  string str = "Expected receiver of type ";
+  if (to != nullptr) {
+    to->GetTypeName(toClassName);
+    str += toClassName;
+  } else {
+    str += "void";
+  }
+  str += ", but got ";
+  if (from != nullptr) {
+    from->GetTypeName(fromClassName);
+    str += fromClassName;
+  } else {
+    str += "void";
+  }
+  return str;
+}
+
+string GeneClassCastExceptionString(const MClass *from, const MClass *to) {
+  string str, fromClassName, toClassName;
+  if (from != nullptr) {
+    from->GetTypeName(fromClassName);
+    str = fromClassName;
+  } else {
+    str = "void";
+  }
+  str += " cannot be cast to ";
+  if (to != nullptr) {
+    to->GetTypeName(toClassName);
+    str += toClassName;
+  } else {
+    str += "void";
+  }
+  return str;
+}
+
+void FillArgsInfoNoCheck(const ArgsWrapper &args, const char *typesMark, uint32_t arrSize,
+                         BaseArgValue &paramArray, uint32_t begin) {
+  uint32_t paramNum = arrSize - 1;
+  for (uint32_t i = begin; i < paramNum; i++) {
+    switch (typesMark[i]) {
+      case 'C':
+        paramArray.AddInt32(static_cast<jchar>(args.GetJint()));
+        break;
+      case 'S':
+        paramArray.AddInt32(static_cast<jshort>(args.GetJint()));
+        break;
+      case 'B':
+        paramArray.AddInt32(static_cast<jbyte>(args.GetJint()));
+        break;
+      case 'Z':
+        paramArray.AddInt32(static_cast<jboolean>(args.GetJint()));
+        break;
+      case 'I':
+        paramArray.AddInt32(args.GetJint());
+        break;
+      case 'D':
+        paramArray.AddDouble(args.GetJdouble());
+        break;
+      case 'F':
+        paramArray.AddFloat(args.GetJfloat());
+        break;
+      case 'J':
+        paramArray.AddInt64(args.GetJlong());
+        break;
+      default:
+        paramArray.AddReference(reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(args.GetObject())));
+        break;
+    }
+  }
+}
+
+void DoInvoke(const MethodMeta &method, jvalue &result, ArgValue &paramArray) {
+  MClass *retType = method.GetReturnType();
+  CHECK_E_V(retType == nullptr, "DoInvoke: reType is nullptr");
+  uintptr_t addr = method.GetFuncAddress();
+  char *mark = retType->GetName();
+  __MRT_ASSERT(mark != nullptr, "DoInvoke: mark is null");
+  uint32_t stackSize = paramArray.GetStackSize();
+  uint32_t dregSize = paramArray.GetFRegSize();
+  switch (*mark) {
+    case 'V':
+      RuntimeStub<void>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+    case 'I':
+      result.i = RuntimeStub<jint>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+    case 'B':
+      result.b = RuntimeStub<jbyte>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+    case 'C':
+      result.c = RuntimeStub<jchar>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+    case 'S':
+      result.s = RuntimeStub<jshort>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+    case 'Z':
+      result.z = RuntimeStub<jboolean>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+    case 'D':
+      result.d = RuntimeStub<jdouble>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+    case 'F':
+      result.f = RuntimeStub<jfloat>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+    case 'J':
+      result.j = RuntimeStub<jlong>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+    default: // L [
+      result.l = RuntimeStub<jobject>::SlowCallCompiledMethod(addr, paramArray.GetData(), stackSize, dregSize);
+      return;
+  }
+}
+
+bool GetPrimShortType(const MClass *klass, char &type) {
+  if (klass == nullptr) {
+    LOG(FATAL) << "klass is nullptr." << maple::endl;
+  }
+  const char *descriptor = klass->GetName();
+  if (!strcmp(descriptor, "Ljava/lang/Boolean;")) {
+    type = 'Z';
+    return true;
+  } else if (!strcmp(descriptor, "Ljava/lang/Byte;")) {
+    type = 'B';
+    return true;
+  } else if (!strcmp(descriptor, "Ljava/lang/Character;")) {
+    type = 'C';
+    return true;
+  } else if (!strcmp(descriptor, "Ljava/lang/Short;")) {
+    type = 'S';
+    return true;
+  } else if (!strcmp(descriptor, "Ljava/lang/Integer;")) {
+    type = 'I';
+    return true;
+  } else if (!strcmp(descriptor, "Ljava/lang/Long;")) {
+    type = 'J';
+    return true;
+  } else if (!strcmp(descriptor, "Ljava/lang/Float;")) {
+    type = 'F';
+    return true;
+  } else if (!strcmp(descriptor, "Ljava/lang/Double;")) {
+    type = 'D';
+    return true;
+  } else if (!strcmp(descriptor, "Ljava/lang/Void;")) {
+    type = 'V';
+    return true;
+  }
+  return false;
+}
+
+bool CheckPrimitiveCanBoxed(char shortType) {
+  switch (shortType) { // full through
+    case 'Z':
+    case 'B':
+    case 'C':
+    case 'S':
+    case 'I':
+    case 'F':
+    case 'D':
+    case 'J':
+      return true;
+    default:  // void or not primitive
+      return false;
+  }
+}
+
+bool GetPrimShortTypeAndValue(const MObject *o, char &type, jvalue &value, const MClass *fromType) {
+  const MClass *klass = (o == nullptr) ? fromType : o->GetClass();
+  if (fromType->IsAbstract() && o == nullptr) {
+    return true;
+  }
+  FieldMeta *valuefield = klass->GetDeclaredField("value");
+  if (valuefield == nullptr && klass != WellKnown::GetMClassObject()) {
+    return false;
+  }
+  if (o == nullptr) {
+    return true;
+  }
+  if (valuefield == nullptr) {
+    return false;
+  }
+  if (klass == WellKnown::GetMClassBoolean()) {
+    type = 'Z';
+    value.z = MRT_LOAD_JBOOLEAN(o, valuefield->GetOffset());
+  } else if (klass == WellKnown::GetMClassByte()) {
+    type = 'B';
+    value.b = MRT_LOAD_JBYTE(o, valuefield->GetOffset());
+  } else if (klass == WellKnown::GetMClassCharacter()) {
+    type = 'C';
+    value.c = MRT_LOAD_JCHAR(o, valuefield->GetOffset());
+  } else if (klass == WellKnown::GetMClassFloat()) {
+    type = 'F';
+    value.f = MRT_LOAD_JFLOAT(o, valuefield->GetOffset());
+  } else if (klass == WellKnown::GetMClassDouble()) {
+    type = 'D';
+    value.d = MRT_LOAD_JDOUBLE(o, valuefield->GetOffset());
+  } else if (klass == WellKnown::GetMClassInteger()) {
+    type = 'I';
+    value.i = MRT_LOAD_JINT(o, valuefield->GetOffset());
+  } else if (klass == WellKnown::GetMClassLong()) {
+    type = 'J';
+    value.j = MRT_LOAD_JLONG(o, valuefield->GetOffset());
+  } else if (klass == WellKnown::GetMClassShort()) {
+    type = 'S';
+    value.s = MRT_LOAD_JSHORT(o, valuefield->GetOffset());
+  }
+  if (type != '0') {
+    return true;
+  }
+  return false;
+}
+}
diff --git a/src/mrt/maplert/src/mrt_handleutil.cpp b/src/mrt/maplert/src/mrt_handleutil.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba471b50c96db1dd4848016598ca402f0b398f50
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_handleutil.cpp
@@ -0,0 +1,490 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_handleutil.h"
+namespace maplert {
+class Converter{
+ public:
+  Converter(ConvertJStruct &params, const MethodHandle &mh, const MClass *fromCls, const MClass *toCls, bool decFlag)
+      : from(fromCls), to(toCls), param(params), handle(mh), needDec(decFlag) {
+    toShortType = to ? *to->GetName() : 'V';
+    fromShortType = *from->GetName();
+    fromIsPrim = (from != nullptr) ? from->IsPrimitiveClass() : true;
+    toIsPrim = (to != nullptr) ? to->IsPrimitiveClass() : true;
+  }
+  ~Converter() = default;
+
+  bool Convert() noexcept {
+    if (!toIsPrim && (from == WellKnown::GetMClassVoid() || from == WellKnown::GetMClassV())) {
+      return true;
+    }
+    jvalue kSrcValue(*(param.value));
+    (*(param.value)).j = 0;
+    if (fromIsPrim && toIsPrim) {
+      if (UNLIKELY(!primitiveutil::ConvertNarrowToWide(fromShortType, toShortType, kSrcValue, *(param.value)))) {
+        ThrowWMT();
+        return false;
+      }
+      return true;
+    } else if (!fromIsPrim && !toIsPrim) {
+      if (kSrcValue.l) {
+        from = reinterpret_cast<MObject*>(kSrcValue.l)->GetClass();
+      }
+      param.value->l = kSrcValue.l;
+      if (UNLIKELY(!MRT_ReflectClassIsAssignableFrom(*to, *from))) {
+        MRT_ThrowNewException("java/lang/ClassCastException", GeneClassCastExceptionString(from, to).c_str());
+        return false;
+      }
+      return true;
+    } else if (!toIsPrim) {
+      return ConvertPrimToObj(kSrcValue);
+    } else {
+      return ConvertObjToPrim(kSrcValue);
+    }
+  }
+ private:
+  bool ConvertObjToPrim(const jvalue &kSrcValue) noexcept {
+    char unboxedType = '0';
+    jvalue unboxedVal;
+    unboxedVal.j = 0;
+    if (UNLIKELY(!GetPrimShortTypeAndValue(reinterpret_cast<MObject*>(kSrcValue.l), unboxedType, unboxedVal, from))) {
+      ThrowWMT();
+      return false;
+    }
+
+    if (UNLIKELY(kSrcValue.l == nullptr)) {
+      MRT_ThrowNewException("java/lang/NullPointerException", "");
+      return false;
+    }
+    if (needDec) {
+      RC_LOCAL_DEC_REF(kSrcValue.l);
+    }
+
+    if (UNLIKELY(!primitiveutil::ConvertNarrowToWide(unboxedType, toShortType, unboxedVal, *(param.value)))) {
+      if (from == WellKnown::GetMClassNumber()) { // boxed to type must be assignablefrom number
+        MRT_ThrowNewException("java/lang/ClassCastException", GeneClassCastExceptionString(from, to).c_str());
+      } else {
+        ThrowWMT();
+      }
+      return false;
+    }
+    return true;
+  }
+
+  bool ConvertPrimToObj(const jvalue &kSrcValue) noexcept {
+    char type;
+    if (!GetPrimShortType(to, type)) {
+      // to_type unboxed failed, so if from_type can be boxed(is prim type),
+      // it could be converted if to_type is Number or Object
+      if (CheckPrimitiveCanBoxed(fromShortType) && (to == WellKnown::GetMClassNumber() ||
+          to == WellKnown::GetMClassObject())) {
+        type = fromShortType;
+      } else {
+        ThrowWMT();
+        return false;
+      }
+    } else if (UNLIKELY(fromShortType != type)) {
+      ThrowWMT();
+      return false;
+    }
+
+    if (UNLIKELY(!primitiveutil::ConvertNarrowToWide(fromShortType, type, kSrcValue, *(param.value)))) {
+      ThrowWMT();
+      return false;
+    }
+    jobject boxed = reinterpret_cast<jobject>(primitiveutil::BoxPrimitive(type, kSrcValue));
+    param.value->l = boxed;
+    return true;
+  }
+
+  void ThrowWMT() const noexcept {
+    string exceptionStr = GeneExceptionString(handle, param.parameterTypes, param.arraySize);
+    MRT_ThrowNewException("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+  }
+
+  const MClass *from;
+  const MClass *to;
+  ConvertJStruct &param;
+  const MethodHandle &handle;
+  bool needDec;
+  char toShortType;
+  char fromShortType;
+  bool fromIsPrim;
+  bool toIsPrim;
+};
+
+bool ConvertJvalue(ConvertJStruct &param, const MethodHandle &handle,
+                   const MClass *from, const MClass *to, bool needDec) {
+  Converter converter(param, handle, from, to, needDec);
+  return converter.Convert();
+}
+
+bool IllegalArgumentCheck(const ArgsWrapper &args, MClass *from, MClass *to, jvalue &value) {
+  jobject obj = *args.GetObject();
+  value.l = obj;
+  if (from != to) {
+    if (obj != nullptr) {
+      from = reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(obj))->GetClass();
+    }
+    if (UNLIKELY(!MRT_ReflectClassIsAssignableFrom(*to, *from))) {
+      MRT_ThrowNewException("java/lang/IllegalArgumentException", GeneIllegalArgumentExceptionString(from, to).c_str());
+      return false;
+    }
+  }
+  return true;
+}
+
+bool DirectCallParamsConvert(jvalue &val, CallParam &param, const MethodHandle &mh,
+                             const MClass *from, const MClass *to) {
+  ConvertJStruct convertJStruct = { param.paramTypes, param.arraySize, &val };
+  if (to != from && !ConvertJvalue(convertJStruct, mh, from, to)) {
+    return false;
+  }
+  return true;
+}
+
+#define VALUECONVERT(statement)               \
+  STATEMENTCHECK(statement)                   \
+  if (to == WellKnown::GetMClassD()) {        \
+    paramArray.AddDouble(curValue.d);         \
+  } else if (to == WellKnown::GetMClassF()) { \
+    paramArray.AddFloat(curValue.f);          \
+  } else if (to == WellKnown::GetMClassJ()) { \
+    paramArray.AddInt64(curValue.j);          \
+  } else if (to == WellKnown::GetMClassI() || \
+             to == WellKnown::GetMClassZ() || \
+             to == WellKnown::GetMClassB() || \
+             to == WellKnown::GetMClassS() || \
+             to == WellKnown::GetMClassC()) { \
+    paramArray.AddInt32(curValue.i);          \
+  } else {                                    \
+    paramArray.AddReference(reinterpret_cast<MObject*>(reinterpret_cast<uintptr_t>(curValue.l)));\
+  }                                           \
+  break;
+
+// we put converted jobject to SLR, and will be destructed in caller
+bool ConvertParams(CallParam &param, const MethodHandle &mh,
+                   const ArgsWrapper &args, BaseArgValue &paramArray, ScopedHandles&) {
+  MethodMeta *method = mh.GetMethodMeta();
+  vector<MClass*> ptypesVal = mh.GetMethodTypeMplObj()->GetParamsType();
+  uint32_t size = param.arraySize - 1;
+  for (uint32_t i = param.beginIndex; i < size; ++i) {
+    MClass *to = ptypesVal[i];
+    MClass *from = param.paramTypes[i];
+    jvalue curValue;
+    curValue.j = 0;
+    switch (param.typesMark[i]) {
+      case 'B':
+        curValue.b = static_cast<jbyte>(args.GetJint());
+        VALUECONVERT(!DirectCallParamsConvert(curValue, param, mh, from, to))
+      case 'C':
+        curValue.c = static_cast<jchar>(args.GetJint());
+        VALUECONVERT(!DirectCallParamsConvert(curValue, param, mh, from, to))
+      case 'S':
+        curValue.s = static_cast<jshort>(args.GetJint());
+        VALUECONVERT(!DirectCallParamsConvert(curValue, param, mh, from, to))
+      case 'Z':
+        curValue.z = static_cast<jboolean>(args.GetJint());
+        VALUECONVERT(!DirectCallParamsConvert(curValue, param, mh, from, to))
+      case 'I':
+        curValue.i = args.GetJint();
+        VALUECONVERT(!DirectCallParamsConvert(curValue, param, mh, from, to))
+      case 'D':
+        curValue.d = args.GetJdouble();
+        VALUECONVERT(!DirectCallParamsConvert(curValue, param, mh, from, to))
+      case 'F':
+        curValue.f = args.GetJfloat();
+        VALUECONVERT(!DirectCallParamsConvert(curValue, param, mh, from, to))
+      case 'J':
+        curValue.j = args.GetJlong();
+        VALUECONVERT(!DirectCallParamsConvert(curValue, param, mh, from, to))
+      default: {
+        // maple throw IllegalArgumentException when this obj convert fail
+        if (i == 0 && !method->IsStatic() && from != to) {
+          VALUECONVERT(!IllegalArgumentCheck(args, from, to, curValue))
+        } else {
+          curValue.l = *args.GetObject();
+          VALUECONVERT(!DirectCallParamsConvert(curValue, param, mh, from, to))
+        }
+      }
+    }
+    if (from->IsPrimitiveClass() && !to->IsPrimitiveClass()) {
+      ObjHandle<MObject> keepAlive(curValue.l);
+    }
+  }
+  return true;
+}
+
+string GeneExceptionString(const MethodHandle &mh, MClass **parameterTypes, uint32_t arraySize) {
+  string str = "Expected ";
+  string className;
+  str += mh.ValidTypeToString();
+  str += " but was (";
+  uint32_t paraNum = arraySize - 1; // Remove the return value.
+  for (uint32_t i = 0; i < paraNum; ++i) {
+    if (parameterTypes[i] != nullptr) {
+      className.clear();
+      parameterTypes[i]->GetTypeName(className);
+      str += className;
+    } else {
+      str += "void";
+    }
+    if (i != paraNum - 1) {
+      str += ", ";
+    }
+  }
+  str += ")";
+  if (parameterTypes[arraySize - 1] != nullptr) {
+    className.clear();
+    parameterTypes[arraySize - 1]->GetTypeName(className);
+    str += className;
+  } else {
+    str += "void";
+  }
+  return str;
+}
+
+bool ConvertReturnValue(const MethodHandle &mh, MClass **parameterTypes, uint32_t arraySize, jvalue &value) {
+  const MClass *from = mh.GetMethodTypeMplObj()->GetReTType();
+  const MClass *to = parameterTypes[arraySize - 1];
+  if (from == to) {
+    return true;
+  }
+  if (to == WellKnown::GetMClassV()) {
+    if (!from->IsPrimitiveClass()) {
+      RC_LOCAL_DEC_REF(value.l);
+    }
+    return true;
+  }
+  if (from == WellKnown::GetMClassVoid() || from == WellKnown::GetMClassV()) {
+    value.j = 0UL;
+    return true;
+  }
+  ConvertJStruct convertJStruct = { parameterTypes, arraySize, &value };
+  bool convertResult = ConvertJvalue(convertJStruct, mh, from, to, true);
+  if (!convertResult) {
+    RC_LOCAL_DEC_REF(value.l);
+  }
+  return convertResult;
+}
+
+void IsConvertibleOrThrow(uint32_t arraySize, const MethodHandle &mh, MClass **parameterTypes, uint32_t paramNum) {
+  if (!IsConvertible(mh, arraySize)) {
+    if (paramNum == 1 && mh.GetHandleKind() != kStaticCall) {
+      MClass *from = parameterTypes[0];
+      const vector<MClass*> &paramVec = mh.GetMethodTypeMplObj()->GetParamsType();
+      MClass *to = paramVec.size() > 0 ? paramVec[0] : nullptr;
+      string msg = GeneIllegalArgumentExceptionString(to, from);
+      MRT_ThrowNewExceptionUnw("java/lang/IllegalArgumentException", msg.c_str());
+    } else {
+      string exceptionStr = GeneExceptionString(mh, parameterTypes, arraySize);
+      MRT_ThrowNewExceptionUnw("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+    }
+  }
+}
+
+bool ClinitCheck(const MClass *decCls) {
+  if (UNLIKELY(!MRT_ReflectIsInit(*decCls))) {
+    if (UNLIKELY(MRT_TryInitClass(*decCls) == ClassInitState::kClassInitFailed)) {
+      LOG(ERROR) << "MRT_TryInitClass return fail" << maple::endl;
+    }
+    if (UNLIKELY(MRT_HasPendingException())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static MClass *GetClassFromDescriptorAndCalSize(const char *descriptor, uint32_t &refNum, uint32_t &byteArrSize,
+                                                char *typesMark, const MClass *callerCls) {
+  DCHECK(typesMark != nullptr) << "typesMark is nullptr" << maple::endl;
+  DCHECK(descriptor != nullptr) << "GetClassFromDescriptorAndCalSize::descriptor is nullptr" << maple::endl;
+  switch (*descriptor) {
+    case 'I':
+      byteArrSize += sizeof(int);
+      *typesMark = 'I';
+      return WellKnown::GetMClassI();
+    case 'B':
+      byteArrSize += sizeof(int);
+      *typesMark = 'B';
+      return WellKnown::GetMClassB();
+    case 'F':
+      byteArrSize += sizeof(int);
+      *typesMark = 'F';
+      return WellKnown::GetMClassF();
+    case 'C':
+      byteArrSize += sizeof(int);
+      *typesMark = 'C';
+      return WellKnown::GetMClassC();
+    case 'S':
+      byteArrSize += sizeof(int);
+      *typesMark = 'S';
+      return WellKnown::GetMClassS();
+    case 'J':
+      byteArrSize += sizeof(double);
+      *typesMark = 'J';
+      return WellKnown::GetMClassJ();
+    case 'D':
+      byteArrSize += sizeof(double);
+      *typesMark = 'D';
+      return WellKnown::GetMClassD();
+    case 'Z':
+      byteArrSize += sizeof(int);
+      *typesMark = 'Z';
+      return WellKnown::GetMClassZ();
+    case 'V':
+      byteArrSize += sizeof(int);
+      *typesMark = 'V';
+      return WellKnown::GetMClassV();
+    default:
+      *typesMark = 'L';
+      ++refNum;
+      return MClass::JniCast(MRT_GetClassByContextClass(*callerCls, descriptor));
+  }
+}
+
+// the last element is return type
+void GetParameterAndRtType(MClass **types, char *typesMark, const MString *protoStr,
+                           SizeInfo &sz, const MClass *declareClass) {
+  DCHECK(protoStr != nullptr);
+  const char *methodSig = reinterpret_cast<const char*>(protoStr->GetContentsPtr());
+  uint32_t count = protoStr->GetLength();
+
+  int idx = 0;
+  DCHECK(methodSig != nullptr) << "GetParameterAndRtTypeA::methodSig is nullptr" << maple::endl;
+  ++methodSig;
+  size_t len = count + 1;
+  char *descriptor = reinterpret_cast<char*>(calloc(len, 1));
+  if (UNLIKELY(descriptor == nullptr)) {
+    return;
+  }
+  DCHECK(types != nullptr) << "rtTypeParam.types is nullptr" << maple::endl;
+  while (*methodSig != ')') {
+    if (memset_s(descriptor, len, 0, len) != EOK) {
+      LOG(FATAL) << "memset_s fail." << maple::endl;
+    }
+    ParseSignatrueType(descriptor, methodSig);
+    MClass *ptype = GetClassFromDescriptorAndCalSize(descriptor, sz.refNum, sz.byteArrSize,
+                                                     typesMark + idx, declareClass);
+    *(types + idx) = ptype;
+    ++idx;
+    ++methodSig;
+  }
+  ++methodSig;
+  if (memset_s(descriptor, len, 0, len) != EOK) {
+    LOG(FATAL) << "memset_s fail." << maple::endl;
+  }
+  ParseSignatrueType(descriptor, methodSig);
+  MClass *rtType = GetClassFromDescriptorAndCalSize(descriptor, sz.refNum, sz.byteArrSize,
+                                                    typesMark + idx, declareClass);
+  *(types + idx) = rtType;
+  free(descriptor);
+}
+
+static bool TransformEnter(MethodHandle &mh, SizeInfo &sz, const TypeInfo &typeInfo, jvalue &result) {
+  vector<MClass*> handleTypes = mh.GetMethodTypeMplObj()->GetParamsType();
+  Kind handleKind = mh.GetHandleKind();
+  // invoke transform , marshal EmStackFrame and invoke transform method
+  if (handleKind == kTransformCall || handleKind == kCallSiteTransformCall) {
+    if (handleKind != kCallSiteTransformCall) {
+      sz.byteArrSize = 0;
+      sz.refNum = 0;
+      CalcFrameSize(mh.GetMethodTypeMplObj()->GetReTType(), handleTypes, sz.byteArrSize, sz.refNum);
+    }
+    if (!mh.InvokeTransform(sz, typeInfo.typesMark, typeInfo.types, result)) {
+      MRT_CheckThrowPendingExceptionUnw();
+    }
+    return true;
+  }
+  return false;
+}
+
+MClass *GetContextCls(Arg &arg, MString *&calleeName) {
+  MClass *callerClass = nullptr;
+  constexpr int kNewABIFlag = 1;
+  if (reinterpret_cast<intptr_t>(calleeName) & kNewABIFlag) {
+    calleeName = reinterpret_cast<MString*>(reinterpret_cast<intptr_t>(calleeName) - kNewABIFlag);
+    MClass *callerCls = reinterpret_cast<MClass*>(arg.GetObject());
+    if (callerCls != nullptr) {
+      callerClass = callerCls->GetClass();
+    }
+    if (callerClass == WellKnown::GetMClassClass()) {
+      callerClass = callerCls;
+    }
+  }
+  return callerClass;
+}
+
+#if defined(__arm__)
+int64_t PolymorphicCallEnter32(int32_t *args) {
+#if defined(__ARM_PCS_VFP)
+  Arm32Arg argsHandle(args);
+#elif defined(__ARM_PCS)
+  Arm32SoftFPArg argsHandle(args);
+#endif
+  MString *calleeStr = reinterpret_cast<MString*>(argsHandle.GetObject());
+  MString *protoString = reinterpret_cast<MString*>(argsHandle.GetObject());
+  uint32_t paramNum = static_cast<uint32_t>(argsHandle.GetJint());
+  MObject *mhObj = argsHandle.GetObject();
+  MClass *callerClass = GetContextCls(argsHandle, calleeStr);
+  jvalue result = PolymorphicCallEnter(calleeStr, protoString, paramNum, mhObj, argsHandle, callerClass);
+  return result.j;
+}
+#endif
+
+jvalue PolymorphicCallEnter(const MString *calleeStr, const MString *protoString,
+    uint32_t paramNum, MObject *mhObj, Arg &args, const MClass *declareClass) {
+  if (mhObj == nullptr) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "");
+  }
+  SizeInfo sz(paramNum);
+  char typesMark[sz.arraySize];
+  MClass *paramTypes[sz.arraySize];
+
+  GetParameterAndRtType(paramTypes, typesMark, protoString, sz, declareClass);
+  jvalue result;
+  result.j = 0;
+  MethodHandle mh = MethodHandle(mhObj, args);
+  MethodMeta &mplFieldOrMethodMeta = *mh.GetMethodMeta();
+  bool isStaticMethod = mplFieldOrMethodMeta.IsStatic();
+  bool isExactMatched = mh.ExactInvokeCheck(calleeStr, paramTypes, sz.arraySize);
+  if (IsCallerTransformerJStr(paramNum, protoString)) { // handle EmStackFrame invoke
+    if (!mh.InvokeWithEmStackFrame(args.GetObject(), result)) {
+      MRT_CheckThrowPendingExceptionUnw();
+    }
+    return result;
+  }
+  if (IsFieldAccess(mh.GetHandleKind())) {
+    if (!mh.FieldAccess(paramTypes, !isExactMatched, sz.arraySize, result)) {
+      MRT_CheckThrowPendingExceptionUnw();
+    }
+    return result;
+  }
+  TypeInfo typeInfo = { paramTypes, typesMark };
+  if (TransformEnter(mh, sz, typeInfo, result) || !ClinitCheck(mplFieldOrMethodMeta.GetDeclaringClass())) {
+    return result;
+  }
+  if (!isExactMatched) { // isExactmatch check, if not we continue check IsConvertible
+    IsConvertibleOrThrow(sz.arraySize, mh, paramTypes, paramNum);
+  }
+  CallParam dCP = { paramNum,  isExactMatched, paramTypes, typesMark, isStaticMethod, 0, sz.arraySize, 0 };
+  if (!mh.NoParamFastCall(dCP, result)) {
+    mh.DirectCall(dCP, result);
+  }
+  if (UNLIKELY(MRT_HasPendingException() || !ConvertReturnValue(mh, paramTypes, sz.arraySize, result))) {
+    MRT_CheckThrowPendingExceptionUnw();
+  }
+  return result;
+}
+}  // namespace maple
diff --git a/src/mrt/maplert/src/mrt_linker.cpp b/src/mrt/maplert/src/mrt_linker.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..305d71a001949da44594f4f4fc237c1cbe7338c1
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_linker.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_linker.h"
+#include "mrt_linker_api.h"
+
+namespace maplert {
+LinkerAPI *LinkerAPI::pInstance = nullptr;
+LinkerAPI &LinkerAPI::Instance() {
+  if (pInstance == nullptr) {
+    pInstance = new (std::nothrow) MplLinkerImpl();
+    if (pInstance == nullptr) {
+      LINKER_LOG(FATAL) << "new MplLinkerImpl failed" << maple::endl;
+    }
+  }
+  return *pInstance;
+}
+MplLinkerImpl::MplLinkerImpl()
+    : linkerFeature(*this),
+      hotfixFeature(*this),
+      methodBuilderFeature(*this),
+#ifdef LINKER_DECOUPLE
+      decoupleFeature(*this, methodBuilderFeature),
+#endif
+      lazyBindingFeature(*this, methodBuilderFeature),
+#ifdef LINKER_RT_CACHE
+      linkerCacheFeature(*this),
+#endif // LINKER_RT_CACHE
+      debugFeature(*this) {
+  features[kFLinker] = &linkerFeature;
+  features[kFHotfix] = &hotfixFeature;
+  features[kFDebug] = &debugFeature;
+  features[kFMethodBuilder] = &methodBuilderFeature;
+#ifdef LINKER_DECOUPLE
+  features[kFDecouple] = &decoupleFeature;
+#endif
+  features[kFLazyBinding] = &lazyBindingFeature;
+#ifdef LINKER_RT_CACHE
+  features[kFLinkerCache] = &linkerCacheFeature;
+#endif // LINKER_RT_CACHE
+}
+#ifdef __cplusplus
+extern "C" {
+#endif
+bool MRT_LinkerIsJavaText(const void *addr) {
+  return LinkerAPI::Instance().IsJavaText(addr);
+}
+void *MRT_LinkerGetSymbolAddr(void *handle, const char *symbol, bool isFunction) {
+  return LinkerAPI::Instance().GetSymbolAddr(handle, symbol, isFunction);
+}
+void MRT_LinkerSetCachePath(const char *path) {
+#ifdef LINKER_RT_CACHE
+  LinkerAPI::Instance().SetCachePath(path);
+#else
+  (void)path;
+#endif // LINKER_RT_CACHE
+}
+#ifdef __cplusplus
+}
+#endif
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_methodhandle.cpp b/src/mrt/maplert/src/mrt_methodhandle.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..70778c252c0418b3942b979beefa3b157542e873
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_methodhandle.cpp
@@ -0,0 +1,950 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_methodhandle.h"
+#include "mrt_handleutil.h"
+#include "mstring_inline.h"
+
+namespace maplert {
+constexpr char MethodHandle::kInvokeMtd[];
+constexpr char MethodHandle::kInvokeExactMtd[];
+
+MethodMeta *RefineTargetMethod(Kind handleKind, MethodMeta *method, const MClass *referClass) {
+  MClass *decClass = method->GetDeclaringClass();
+  if (handleKind == kSuperCall) {
+    if (decClass == referClass) {
+      return method;
+    } else {
+      if (!MRT_ReflectClassIsInterface(*decClass)) {
+        CHECK_E_P(referClass == nullptr, "RefineTargetMethod: referClass is nullptr.");
+        MClass *superClass = referClass->GetSuperClass();
+        if (superClass != nullptr) {
+          return superClass->GetDeclaredMethod(method->GetName(), method->GetSignature());
+        }
+      }
+    }
+  } else if (handleKind == kVirtualCall || handleKind == kInterfaceCall) {
+    if (decClass != referClass && referClass != nullptr) {
+      MethodMeta *realMthd = referClass->GetMethod(method->GetName(), method->GetSignature());
+      if (realMthd == nullptr) {
+        string msg = GeneIllegalArgumentExceptionString(referClass, decClass);
+        MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.c_str());
+        return method;
+      }
+      return realMthd;
+    }
+  } else if (handleKind == kDirectCall && method->IsConstructor() && decClass == WellKnown::GetMClassString()) {
+    if (StringToStringFactoryMap.size() == 0) {
+      MClass *strFactory =
+          MClass::JniCast(MRT_GetClassByContextClass(NULL, "Ljava_2Flang_2FStringFactory_3B"));
+      CHECK_E_P(strFactory == nullptr, "MRT_GetClassByContextClass return nullptr.");
+      std::vector<MethodMeta*> methodsVec;
+      reinterpret_cast<MClass*>(strFactory)->GetDeclaredMethods(methodsVec, false);
+      std::lock_guard<std::mutex> guard(mtx);
+      std::for_each(methodsVec.begin(), methodsVec.end(), [](MethodMeta *mthd) {
+        if (stringInitMethodSet.find(mthd->GetName()) != stringInitMethodSet.end()) {
+          StringToStringFactoryMap[mthd->GetSignature()] = mthd;
+        }
+      });
+    }
+    string originSig = method->GetSignature();
+    originSig.replace(originSig.size() - 1, 1, "Ljava/lang/String;");
+    MethodMeta *realMthd = StringToStringFactoryMap[originSig];
+    return realMthd;
+  }
+  return method;
+}
+
+std::string MethodType::ToString() const noexcept {
+  string s = "(";
+  string className;
+  size_t size = paramsType.size();
+  for (size_t i = 0; i < size; ++i) {
+    if (paramsType[i] != nullptr) {
+      className.clear();
+      reinterpret_cast<MClass*>(paramsType[i])->GetTypeName(className);
+      s += className;
+    } else {
+      s += "void";
+    }
+    if (i != size - 1) {
+      s += ", ";
+    }
+  }
+  s += ")";
+  if (returnType != nullptr) {
+    className.clear();
+    reinterpret_cast<MClass*>(returnType)->GetTypeName(className);
+    s += className;
+  } else {
+    s += "void";
+  }
+  return s;
+}
+
+std::string MethodHandle::ValidTypeToString() const noexcept {
+  return validMethodTypeMplObjCache->ToString();
+}
+
+MethodMeta *MethodHandle::GetRealMethod(MObject *obj) const noexcept {
+  MethodMeta *realMethod = nullptr;
+  auto getRealMethod = std::bind(RefineTargetMethod, handleKind,
+                                 reinterpret_cast<MethodMeta*>(mplFieldOrMethod), placeholders::_1);
+  if (handleKind == kSuperCall) {
+    realMethod = getRealMethod(GetMethodTypeMplObj()->GetParamsType()[0]);
+  } else {
+    bool isLiteralString = false;
+    if (obj != nullptr && obj->GetClass() == WellKnown::GetMClassString()) {
+      MString *jstr = reinterpret_cast<MString*>(obj);
+      isLiteralString = jstr->IsLiteral();
+    }
+    if (IS_HEAP_ADDR(reinterpret_cast<address_t>(obj)) || isLiteralString) {
+      realMethod = getRealMethod(obj->GetClass());
+    } else {
+      realMethod = getRealMethod(nullptr);
+    }
+  }
+  if (realMethod == nullptr) {
+    LOG(ERROR) << "GetRealMethod return null" << maple::endl;
+  }
+  return realMethod;
+}
+
+char MethodHandle::GetReturnTypeMark(char markInProto) const noexcept {
+  char mark;
+  const MClass *retType = methodTypeMplObjCache->GetReTType();
+  if (handleKind != kCallSiteTransformCall) {
+    mark = *(retType->GetName());
+  } else {
+    mark = markInProto;
+  }
+  return mark;
+}
+
+MObject *MethodHandle::CreateEmStackFrame(const MArray *bArray, const MObject *refArray,
+                                          MClass **types, uint32_t arraySize) const {
+  ScopedHandles sHandles;
+  ObjHandle<MObject> callerType(MObject::NewObject(*WellKnown::GetMClassMethodType()));
+  if (callerType == 0) {
+    LOG(FATAL) << "CreateEmStackFrame: callerType is nullptr" << maple::endl;
+  }
+  callerType->StoreObjectNoRc(WellKnown::GetMFieldMethodHandlepRTypeOffset(), types[arraySize - 1]);
+  ObjHandle<MArray> paramArray(MRT_NewObjArray(static_cast<int>(arraySize) - 1, *WellKnown::GetMClassClass(), nullptr));
+  for (uint32_t i = 0; i < arraySize - 1; ++i) {
+    paramArray->SetObjectElement(i, types[i]);
+  }
+  callerType()->StoreObject(WellKnown::GetMFieldMethodHandlePTypesOffset(), paramArray());
+
+  ObjHandle<MObject> EmStackFrameObj(MObject::NewObject(*WellKnown::GetMClassEmulatedStackFrame()));
+  EmStackFrameObj->StoreObject(WellKnown::GetMFieldEmStackFrameCallsiteOffset(), callerType());
+
+  if (handleKind == kCallSiteTransformCall) {
+    EmStackFrameObj->StoreObject(WellKnown::GetMFieldEmStackFrameTypeOffset(), callerType());
+  } else {
+    EmStackFrameObj->StoreObject(WellKnown::GetMFieldEmStackFrameTypeOffset(), GetMethodTypeJavaObj());
+  }
+  EmStackFrameObj->StoreObject(WellKnown::GetMFieldEmStackFrameStackFrameOffset(), bArray);
+  EmStackFrameObj->StoreObject(WellKnown::GetMFieldEmStackFrameReferencesOffset(), refArray);
+  return EmStackFrameObj.ReturnObj();
+}
+
+bool MethodHandle::FieldSGet(MClass **parameterTypes, bool doConvert, uint32_t arraySize, jvalue &result) {
+  char shortFieldType = *(GetFieldMeta()->GetTypeName());
+  jfieldID field = reinterpret_cast<jfieldID>(GetFieldMeta());
+  switch (shortFieldType) {
+    case 'Z':
+      result.z = MRT_ReflectGetFieldjboolean(field, nullptr);
+      break;
+    case 'B':
+      result.b = MRT_ReflectGetFieldjbyte(field, nullptr);
+      break;
+    case 'C':
+      result.c = MRT_ReflectGetFieldjchar(field, nullptr);
+      break;
+    case 'S':
+      result.s = MRT_ReflectGetFieldjshort(field, nullptr);
+      break;
+    case 'I':
+      result.i = MRT_ReflectGetFieldjint(field, nullptr);
+      break;
+    case 'J':
+      result.j = MRT_ReflectGetFieldjlong(field, nullptr);
+      break;
+    case 'F':
+      result.f = MRT_ReflectGetFieldjfloat(field, nullptr);
+      break;
+    case 'D':
+      result.d = MRT_ReflectGetFieldjdouble(field, nullptr);
+      break;
+    case 'V':
+      LOG(FATAL) << "Unreachable: " << shortFieldType;
+      break;
+    default: {  // reference
+      result.l = MRT_ReflectGetFieldjobject(field, nullptr);
+      break;
+    }
+  }
+  if (doConvert && !ConvertReturnValue(*this, parameterTypes, arraySize, result)) {
+    return false;
+  }
+  return true;
+}
+
+bool MethodHandle::FieldSPut(MClass **parameterTypes, bool doConvert, uint32_t arraySize) {
+  jvalue setVal;
+  setVal.j = 0;
+  constexpr size_t paramTypeIndex = 0;
+  GetValFromVargs(setVal, *parameterTypes[paramTypeIndex]->GetName());
+  vector<MClass*> ptypesVal = MethodType(GetMethodTypeJavaObj()).GetParamsType();
+  if (doConvert) {
+    MClass *from = parameterTypes[paramTypeIndex];
+    MClass *to = ptypesVal[0];
+    if (from != to) {
+      ConvertJStruct convertJStruct = { parameterTypes, arraySize, &setVal };
+      STATEMENTCHECK(!ConvertJvalue(convertJStruct, *this, from, to))
+    }
+  }
+  jfieldID field = reinterpret_cast<jfieldID>(GetFieldMeta());
+  switch (*(GetFieldMeta()->GetTypeName())) {
+    case 'Z':
+      MRT_ReflectSetFieldjboolean(field, nullptr, setVal.z);
+      break;
+    case 'B':
+      MRT_ReflectSetFieldjbyte(field, nullptr, setVal.b);
+      break;
+    case 'C':
+      MRT_ReflectSetFieldjchar(field, nullptr, setVal.c);
+      break;
+    case 'S':
+      MRT_ReflectSetFieldjshort(field, nullptr, setVal.s);
+      break;
+    case 'I':
+      MRT_ReflectSetFieldjint(field, nullptr, setVal.i);
+      break;
+    case 'J':
+      MRT_ReflectSetFieldjlong(field, nullptr, setVal.j);
+      break;
+    case 'F':
+      MRT_ReflectSetFieldjfloat(field, nullptr, setVal.f);
+      break;
+    case 'D':
+      MRT_ReflectSetFieldjdouble(field, nullptr, setVal.d);
+      break;
+    case 'V':
+      LOG(FATAL) << "Unreachable: " << *(GetFieldMeta()->GetTypeName());
+      break;
+    default: {  // reference
+      MRT_ReflectSetFieldjobject(field, nullptr, setVal.l);
+      break;
+    }
+  }
+  return true;
+}
+
+bool MethodHandle::FieldPut(MClass **parameterTypes, bool doConvert, uint32_t arraySize) {
+  jobject obj = *args.GetObject();
+  jvalue setVal;
+  setVal.j = 0;
+  constexpr size_t paramTypeIndex = 1;
+  GetValFromVargs(setVal, *parameterTypes[paramTypeIndex]->GetName());
+  vector<MClass*> ptypesVal = MethodType(GetMethodTypeJavaObj()).GetParamsType();
+  if (doConvert) {
+    MClass *from = parameterTypes[paramTypeIndex];
+    MClass *to = ptypesVal[1];
+    ConvertJStruct convertJStruct = { parameterTypes, arraySize, &setVal };
+    STATEMENTCHECK(from != to && !ConvertJvalue(convertJStruct, *this, from, to))
+  }
+  char shortFieldType = *(GetFieldMeta()->GetTypeName());
+  jfieldID field = reinterpret_cast<jfieldID>(GetFieldMeta());
+  switch (shortFieldType) {
+    case 'Z':
+      MRT_ReflectSetFieldjboolean(field, obj, setVal.z);
+      break;
+    case 'B':
+      MRT_ReflectSetFieldjbyte(field, obj, setVal.b);
+      break;
+    case 'C':
+      MRT_ReflectSetFieldjchar(field, obj, setVal.c);
+      break;
+    case 'S':
+      MRT_ReflectSetFieldjshort(field, obj, setVal.s);
+      break;
+    case 'I':
+      MRT_ReflectSetFieldjint(field, obj, setVal.i);
+      break;
+    case 'J':
+      MRT_ReflectSetFieldjlong(field, obj, setVal.j);
+      break;
+    case 'F':
+      MRT_ReflectSetFieldjfloat(field, obj, setVal.f);
+      break;
+    case 'D':
+      MRT_ReflectSetFieldjdouble(field, obj, setVal.d);
+      break;
+    case 'V':
+      LOG(FATAL) << "Unreachable: " << shortFieldType;
+      break;
+    default: {  // reference
+      MRT_ReflectSetFieldjobject(field, obj, setVal.l);
+      break;
+    }
+  }
+  return true;
+}
+
+bool MethodHandle::FieldGet(MClass **parameterTypes, bool doConvert, uint32_t arraySize, jvalue &result) {
+  jobject obj = *args.GetObject();
+  char shortFieldType = *(GetFieldMeta()->GetTypeName());
+  jfieldID field = reinterpret_cast<jfieldID>(GetFieldMeta());
+  switch (shortFieldType) {
+    case 'Z':
+      result.z = MRT_ReflectGetFieldjbooleanUnsafe(field, obj);
+      break;
+    case 'B':
+      result.b = MRT_ReflectGetFieldjbyteUnsafe(field, obj);
+      break;
+    case 'C':
+      result.c = MRT_ReflectGetFieldjcharUnsafe(field, obj);
+      break;
+    case 'S':
+      result.s = MRT_ReflectGetFieldjshortUnsafe(field, obj);
+      break;
+    case 'I':
+      result.i = MRT_ReflectGetFieldjintUnsafe(field, obj);
+      break;
+    case 'J':
+      result.j = MRT_ReflectGetFieldjlongUnsafe(field, obj);
+      break;
+    case 'F':
+      result.f = MRT_ReflectGetFieldjfloatUnsafe(field, obj);
+      break;
+    case 'D':
+      result.d = MRT_ReflectGetFieldjdoubleUnsafe(field, obj);
+      break;
+    case 'V':
+      LOG(FATAL) << "Unreachable: " << shortFieldType;
+      break;
+    default: {  // reference
+      result.l = MRT_ReflectGetFieldjobject(field, obj);
+      break;
+    }
+  }
+  STATEMENTCHECK(doConvert && !ConvertReturnValue(*this, parameterTypes, arraySize, result))
+  return true;
+}
+
+void MethodHandle::GetValFromVargs(jvalue &value, char shortFieldType) {
+  switch (shortFieldType) {
+    case 'Z':
+      value.z = static_cast<jboolean>(args.GetJint());
+      break;
+    case 'B':
+      value.b = static_cast<jbyte>(args.GetJint());
+      break;
+    case 'C':
+      value.c = static_cast<jchar>(args.GetJint());
+      break;
+    case 'S':
+      value.s = static_cast<jshort>(args.GetJint());
+      break;
+    case 'I':
+      value.i = args.GetJint();
+      break;
+    case 'J':
+      value.j = args.GetJlong();
+      break;
+    case 'F':
+      value.f = args.GetJfloat();
+      break;
+    case 'D':
+      value.d = args.GetJdouble();
+      break;
+    case 'V':
+      LOG(FATAL) << "Unreachable: " << shortFieldType;
+      break;
+    default: {  // reference
+      value.l = *args.GetObject();
+      break;
+    }
+  }
+}
+
+bool MethodHandle::FieldAccess(MClass **paramTypes, bool doConvert, uint32_t arraySize, jvalue &result) {
+  switch (handleKind) {
+    case Kind::kInstanceGet: {
+      return FieldGet(paramTypes, doConvert, arraySize, result);
+    }
+    case Kind::kStaticGet: {
+      STATEMENTCHECK(!ClinitCheck(GetFieldMeta()->GetDeclaringclass()))
+      return FieldSGet(paramTypes, doConvert, arraySize, result);
+    }
+    case Kind::kInstancePut: {
+      return FieldPut(paramTypes, doConvert, arraySize);
+    }
+    case Kind::kStaticPut: {
+      STATEMENTCHECK(!ClinitCheck(GetFieldMeta()->GetDeclaringclass()))
+      return FieldSPut(paramTypes, doConvert, arraySize);
+    }
+    default:
+      LOG(FATAL) << "Unreachable: " << static_cast<uint32_t>(handleKind);
+      BUILTIN_UNREACHABLE();
+  }
+}
+
+bool MethodHandle::IsExactMatch() const noexcept {  // check for type and nominalType
+  vector<MClass*> ptypes = methodTypeMplObjCache->GetParamsType();
+  vector<MClass*> ptypesNominal = validMethodTypeMplObjCache->GetParamsType();
+  STATEMENTCHECK(ptypes.size() != ptypesNominal.size())
+  STATEMENTCHECK(!std::equal(ptypes.begin(), ptypes.end(), ptypesNominal.begin()))
+  return true;
+}
+
+bool MethodHandle::IsExactMatch(MClass **types, uint32_t arraySize, bool isNominal) const noexcept {
+  const MethodType *methodTypeMplObj = nullptr;
+  if (isNominal) {
+    methodTypeMplObj = GetValidMethodTypeMplObj();
+  } else {
+    methodTypeMplObj = GetMethodTypeMplObj();
+  }
+  vector<MClass*> ptypesVal = methodTypeMplObj->GetParamsType();
+  size_t calleePtypeSize = arraySize - 1;  // remove return type
+  STATEMENTCHECK(calleePtypeSize != ptypesVal.size())
+  STATEMENTCHECK(!std::equal(ptypesVal.begin(), ptypesVal.end(), types))
+  return methodTypeMplObj->GetReTType() == types[calleePtypeSize];
+}
+
+bool MethodHandle::ExactInvokeCheck(const MString *calleeName, MClass **parameterTypes, uint32_t arraySize) const {
+  DCHECK(calleeName != nullptr);
+  char *calleeNameStr = reinterpret_cast<char*>(calleeName->GetContentsPtr());
+  if (!strcmp(calleeNameStr, kInvokeExactMtd)) {
+    constexpr bool isNominal = true;
+    if (GetNominalTypeJavaObj() != nullptr) {
+      if (!IsExactMatch(parameterTypes, arraySize, isNominal)) {
+        string exceptionStr = GeneExceptionString(*this, parameterTypes, arraySize);
+        MRT_ThrowNewExceptionUnw("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+      }
+      if (IsExactMatch() && IsExactMatch(parameterTypes, arraySize)) {
+        return true;
+      }
+    } else {
+      if (!IsExactMatch(parameterTypes, arraySize)) {
+        string exceptionStr = GeneExceptionString(*this, parameterTypes, arraySize);
+        MRT_ThrowNewExceptionUnw("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+bool MethodHandle::FillInvokeArgs(const ArgsWrapper &argsWrapper, CallParam &paramStruct,
+                                  BaseArgValue &paramArray, ScopedHandles &sHandles) const {
+  if (paramStruct.isExactMatched) {
+    FillArgsInfoNoCheck(argsWrapper, paramStruct.typesMark, paramStruct.arraySize, paramArray, paramStruct.beginIndex);
+    return true;
+  }
+  return ConvertParams(paramStruct, *this, argsWrapper, paramArray, sHandles);
+}
+
+void MethodHandle::DirectCall(CallParam paramStruct, jvalue &result) {
+  ArgValue paramArray(0);
+  ArgValueInterp paramArrayInterp(0);
+  MethodMeta *method = GetMethodMeta();
+  ArgsWrapper argsWrapper(args);
+  ScopedHandles sHandles;
+
+  if (!paramStruct.isStaticMethod) {
+    // get first arg when arraySize >= 2
+    if (paramStruct.arraySize >= 2) {
+      uint32_t argArraySize = paramStruct.arraySize;
+      paramStruct.arraySize = 2; // Only get receiver
+      if (!FillInvokeArgs(argsWrapper, paramStruct, paramArray, sHandles)) {
+        return;
+      }
+      paramArrayInterp.AddReference(paramArray.GetReceiver());
+      paramStruct.arraySize = argArraySize;
+      paramStruct.beginIndex = 1; // Skip receiver
+    }
+    // GetReceiver will return nullptr if arraySize < 2
+    method = GetRealMethod(paramArray.GetReceiver());
+  }
+  CHECK_E_V(method == nullptr, "method is nullptr");
+
+  BaseArgValue *param = method->NeedsInterp() ? reinterpret_cast<BaseArgValue*>(&paramArrayInterp) :
+                                                reinterpret_cast<BaseArgValue*>(&paramArray);
+  // get remaining args.
+  if (!FillInvokeArgs(argsWrapper, paramStruct, *param, sHandles)) {
+    return;
+  }
+
+  if (method->NeedsInterp()) {
+    if (method->IsStatic()) {
+      result = maplert::interpreter::InterpJavaMethod<calljavastubconst::kJvalue>(method,
+          nullptr, reinterpret_cast<uintptr_t>(paramArrayInterp.GetData()));
+    } else {
+      result = maplert::interpreter::InterpJavaMethod<calljavastubconst::kJvalue>(method,
+          paramArrayInterp.GetReceiver(), reinterpret_cast<uintptr_t>(paramArrayInterp.GetData() + 1));
+    }
+  } else {
+    DoInvoke(*method, result, paramArray);
+  }
+}
+
+bool MethodHandle::NoParamFastCall(CallParam &paramStruct, jvalue &result) {
+  vector<MClass*> handleTypes = GetMethodTypeMplObj()->GetParamsType();
+  MethodMeta *mplFieldOrMethodMeta = GetMethodMeta();
+  uint32_t arraySize = paramStruct.paramNum + 1;
+  if (paramStruct.paramNum == 1 && !paramStruct.isStaticMethod) {
+    jvalue thisObj;
+    thisObj.l = *args.GetObject();
+    // NPE can not be thrown without this check when isExactMatched is true
+    if (paramStruct.isExactMatched == true && thisObj.l == nullptr) {
+      MRT_ThrowNewException("java/lang/NullPointerException", "");
+    }
+    MethodMeta *realMethod = nullptr;
+    ConvertJStruct convertJStruct = { paramStruct.paramTypes, arraySize, &thisObj };
+    if (!paramStruct.isExactMatched && !handleTypes.empty() &&
+        !ConvertJvalue(convertJStruct, *this, paramStruct.paramTypes[0], handleTypes[0])) {
+      MRT_CheckThrowPendingExceptionUnw();
+    }
+    realMethod = reinterpret_cast<MethodMeta*>(GetRealMethod(reinterpret_cast<MObject*>(thisObj.l)));
+    result = InvokeMethodNoParameter(reinterpret_cast<MObject*>(thisObj.l), *realMethod);
+    return true;
+  } else if (paramStruct.paramNum == 0 && paramStruct.isStaticMethod) {
+    result = InvokeMethodNoParameter(nullptr, *mplFieldOrMethodMeta);
+    return true;
+  }
+  return false;
+}
+
+void EMSFWriter::WriteByMark(char mark, int8_t *cArray, uint32_t &byteIdx, const jvalue &val, bool isDec) {
+  switch (mark) { // full through
+    case 'Z':
+    case 'B':
+    case 'C':
+    case 'S':
+    case 'I':
+      WriteToEmStackFrame(cArray, byteIdx, val.i);
+      break;
+    case 'F':
+      WriteToEmStackFrame(cArray, byteIdx, val.f);
+      break;
+    case 'J':
+      WriteToEmStackFrame(cArray, byteIdx, val.j);
+      break;
+    case 'D':
+      WriteToEmStackFrame(cArray, byteIdx, val.d);
+      break;
+    default:
+      if (isDec) {
+        RC_LOCAL_DEC_REF(val.l);
+      }
+      LOG(ERROR) << "WriteByMark() don't match mark: " << mark;
+  }
+}
+
+void DoCalculate(char name, uint32_t &byteArrSize, uint32_t &refNum) {
+  switch (name) { // full through
+    case 'I':
+    case 'B':
+    case 'F':
+    case 'C':
+    case 'S':
+    case 'Z':
+    case 'V':
+      byteArrSize += sizeof(int);
+      break;
+    case 'J':
+    case 'D':
+      byteArrSize += sizeof(double);
+      break;
+    default:
+      ++refNum;
+      break;
+  }
+}
+
+jvalue MethodHandle::InvokeMethodNoParameter(MObject *obj, MethodMeta &mthd) {
+  if (mthd.NeedsInterp()) {
+    if ((obj == nullptr) && (!mthd.IsStatic())) {
+      LOG(ERROR) << "obj can not be nullptr!" << maple::endl;
+      if (MRT_HasPendingException()) {
+        MRT_CheckThrowPendingExceptionUnw();
+      }
+      MRT_ThrowNullPointerExceptionUnw();
+    }
+    return interpreter::InterpJavaMethod<calljavastubconst::ArgsType::kNone>(
+        &mthd, obj, reinterpret_cast<uintptr_t>(nullptr));
+  } else {
+    MClass *methodReturnType = mthd.GetReturnType();
+    if (methodReturnType == WellKnown::GetMClassD() || methodReturnType == WellKnown::GetMClassF()) {
+      jvalue v;
+      v.d = RuntimeStub<jdouble>::FastCallCompiledMethod(mthd.GetFuncAddress(), obj);
+      return v;
+    } else {
+      return RuntimeStub<jvalue>::FastCallCompiledMethodJ(mthd.GetFuncAddress(), obj);
+    }
+  }
+}
+
+bool MethodHandle::FillEmStackFrameArray(const char *typesMark, MClass **parameterTypes,
+                                         int8_t *cArray, const MArray *refArray) {
+  uint32_t refIdx = 0;
+  const vector<MClass*> &ptypesVal = methodTypeMplObjCache->GetParamsType();
+  uint32_t returnTypeIdx = realParamNum;
+  for (uint32_t i = 0; i < returnTypeIdx; ++i) {
+    MClass *from = parameterTypes[i];
+    jvalue val;
+    val.j = 0;
+    GetValFromVargs(val, *from->GetName());
+    if (handleKind == kCallSiteTransformCall) { // write according by from type
+      if (typesMark[i] != 'L') {
+        EMSFWriter::WriteByMark(*parameterTypes[i]->GetName(), cArray, emByteIdx, val);
+      } else {
+        refArray->SetObjectElement(refIdx++, reinterpret_cast<MObject*>(val.l));
+      }
+      continue;
+    }
+
+    MClass *to = ptypesVal[i];
+    ConvertJStruct convertJStruct = { parameterTypes, returnTypeIdx + 1, &val };
+    if (from != to) {
+      STATEMENTCHECK(!ConvertJvalue(convertJStruct, *this, from, to))
+    }
+
+    if (MRT_ReflectClassIsPrimitive(*to)) {
+      EMSFWriter::WriteByMark(*to->GetName(), cArray, emByteIdx, val);
+    } else {
+      refArray->SetObjectElement(refIdx++, reinterpret_cast<MObject*>(val.l));
+    }
+
+    if (typesMark[i] != 'L' && !MRT_ReflectClassIsPrimitive(*to)) {
+      RC_LOCAL_DEC_REF(val.l);
+    }
+  }
+  return true;
+}
+
+jvalue EMSFReader::GetRetValFromEmStackFrame(const MArray *refArray, uint32_t refNum, uint32_t idx,
+                                             const int8_t *cArray, char mark) {
+  jvalue retVal;
+  retVal.j = 0UL;
+  switch (mark) {
+    case 'L':
+    case '[':
+      retVal.l = reinterpret_cast<jobject>(refArray->GetObjectElement(refNum - 1));
+      break;
+    case 'J':
+      retVal.j = GetLongFromEmStackFrame(cArray, idx);
+      break;
+    case 'D': {
+      DoubleLongConvert u;
+      u.j = GetLongFromEmStackFrame(cArray, idx);
+      retVal.d = u.d;
+      break;
+    }
+    case 'F': {
+      FloatIntConvert u;
+      u.i = GetIntFromEmStackFrame(cArray, idx);
+      retVal.f = u.f;
+      break;
+    }
+    default: { // I B C S Z
+      retVal.i = GetIntFromEmStackFrame(cArray, idx);
+      break;
+    }
+  }
+  return retVal;
+}
+
+void MethodHandle::InvokeTransformVirtualMethod(MObject *emStFrameObj, jvalue &retVal) const {
+  MethodMeta *transformMethod = GetHandleJClassType()->GetMethod("transform", "(Ldalvik/system/EmulatedStackFrame;)V");
+  CHECK_E_V(transformMethod == nullptr, "Class.GetMethod return nullptr");
+  ArgValue xregValue(0);
+  xregValue.AddReference(const_cast<MObject*>(GetHandleJavaObj()));
+  xregValue.AddReference(emStFrameObj);
+  if (transformMethod->NeedsInterp()) {
+    jvalue temp;
+    temp.l = reinterpret_cast<jobject>(emStFrameObj);
+    retVal = interpreter::InterpJavaMethod<calljavastubconst::kJvalue>(transformMethod,
+        const_cast<MObject*>(GetHandleJavaObj()), reinterpret_cast<uintptr_t>(&temp));
+  } else {
+    RuntimeStub<void>::SlowCallCompiledMethod(transformMethod->GetFuncAddress(), xregValue.GetData(), 0, 0);
+  }
+}
+
+// transform invoke, marshal EmStackFrame and invoke transform
+bool MethodHandle::InvokeTransform(const SizeInfo &sz, const char *typesMark, // 120
+                                   MClass **parameterTypes, jvalue &retVal) {
+  if (handleKind != kCallSiteTransformCall && sz.arraySize - 1 != methodTypeMplObjCache->GetParamsType().size()) {
+    if (!MRT_HasPendingException()) {
+      string exceptionStr = GeneExceptionString(*this, parameterTypes, sz.arraySize);
+      MRT_ThrowNewException("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+    }
+    return false;
+  }
+  ScopedHandles sHandles;
+  ObjHandle<MArray> byteArray(
+      MRT_NewPrimitiveArray(static_cast<int>(sz.byteArrSize), maple::Primitive::kByte, sizeof(int8_t)));
+  CHECK_E_B(byteArray() == 0, "MRT_NewPrimitiveArray return nullptr");
+  ObjHandle<MArray> referenceArray(
+      MRT_NewObjArray(static_cast<int>(sz.refNum), *WellKnown::GetMClassObject(), nullptr));
+  CHECK_E_B(referenceArray() == 0, "MRT_NewObjArray return nullptr");
+  int8_t *cArray = reinterpret_cast<int8_t*>(byteArray.AsArray()->ConvertToCArray());
+  realParamNum = sz.arraySize - 1;
+  if (!FillEmStackFrameArray(typesMark, parameterTypes, cArray, referenceArray.AsArray())) {
+    return false;
+  }
+  ObjHandle<MObject> emStFrameObj(
+      CreateEmStackFrame(byteArray.AsArray(), referenceArray.AsObject(), parameterTypes, sz.arraySize));
+  CHECK_E_B(emStFrameObj() == 0, "CreateEmStackFrame return nullptr");
+  InvokeTransformVirtualMethod(emStFrameObj.AsObject(), retVal);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    return false;
+  }
+  MClass *returnType = parameterTypes[sz.arraySize - 1];
+  if (MRT_ReflectClassIsPrimitive(*returnType)) {
+    emByteIdx = (returnType == WellKnown::GetMClassD() || returnType == WellKnown::GetMClassJ()) ?
+        sz.byteArrSize - sizeof(jlong) : sz.byteArrSize - sizeof(int);
+  }
+  retVal = EMSFReader::GetRetValFromEmStackFrame(
+      referenceArray.AsArray(), sz.refNum, emByteIdx, cArray, GetReturnTypeMark(typesMark[sz.arraySize - 1]));
+  if (handleKind != kCallSiteTransformCall) {
+    return ConvertReturnValue(*this, parameterTypes, sz.arraySize, retVal);
+  } else {
+    return !MRT_HasPendingException();
+  }
+}
+
+bool MethodHandle::ParamsConvert(const MClass *from, const MClass *to, MClass **parameterTypes,
+                                 uint32_t arraySize, jvalue &internVal) const {
+  ConvertJStruct convertJStruct = { parameterTypes, arraySize, &internVal };
+  STATEMENTCHECK(to != from && !ConvertJvalue(convertJStruct, *this, from, to))
+  return true;
+}
+
+static void GetReturnValue(MObject *emStFrameObj, jvalue &result) {
+    EmStackFrame emStackFrameMplObj = EmStackFrame(emStFrameObj);
+    MObject *callsiteObj = emStFrameObj->LoadObjectNoRc(WellKnown::GetMFieldEmStackFrameCallsiteOffset());
+    MClass *retFromType =
+       reinterpret_cast<MClass*>(callsiteObj->LoadObjectNoRc(WellKnown::GetMFieldMethodHandlepRTypeOffset()));
+    int8_t *cArray = emStackFrameMplObj.GetStackFrameNativeBytes();
+    uint32_t cArrayLen = emStackFrameMplObj.GetStackFrameNativeBytesCount();
+
+    int8_t constexpr doubleOrLongLength = 8;
+    int8_t constexpr intOrFloatLength = 4;
+    char mark = *(retFromType->GetName());
+    uint32_t idx;
+    switch (mark) {
+      case 'L':
+      case '[': {
+        result.l = reinterpret_cast<jobject>(emStackFrameMplObj.GetReferencesReturnObj());
+        break;
+      }
+      case 'D': {
+        DoubleLongConvert u;
+        idx = cArrayLen - doubleOrLongLength;
+        u.j = EMSFReader::GetLongFromEmStackFrame(cArray, idx);
+        result.d = u.d;
+        break;
+      }
+      case 'F': {
+        FloatIntConvert u;
+        idx = cArrayLen - intOrFloatLength;
+        u.i = EMSFReader::GetIntFromEmStackFrame(cArray, idx);
+        result.f = u.f;
+        break;
+      }
+      case 'J': {
+        idx = cArrayLen - doubleOrLongLength;
+        result.j = EMSFReader::GetLongFromEmStackFrame(cArray, idx);
+        break;
+      }
+      case 'V': {
+        break;
+      }
+      default: {
+        idx = cArrayLen - intOrFloatLength;
+        result.i = EMSFReader::GetIntFromEmStackFrame(cArray, idx);
+        break;
+      }
+    }
+}
+
+static bool RecursiveInvokePoly(MObject *emStFrameObj, const MethodHandle &methodHandleMplObj, jvalue &result) {
+  Kind handleKind = methodHandleMplObj.GetHandleKind();
+  if (handleKind == kTransformCall || handleKind == kCallSiteTransformCall) {
+    ArgValue xregValue(0);
+    xregValue.AddReference(const_cast<MObject*>(methodHandleMplObj.GetHandleJavaObj()));
+    xregValue.AddReference(emStFrameObj);
+    MethodMeta *transformMethod = methodHandleMplObj.GetHandleJClassType()->GetMethod(
+        "transform", "(Ldalvik/system/EmulatedStackFrame;)V");
+    __MRT_ASSERT(transformMethod != nullptr, "RecursiveInvokePoly: transformMethod is null");
+    if (transformMethod->NeedsInterp()) {
+      result = interpreter::InterpJavaMethod<calljavastubconst::kJvalue>(transformMethod,
+          reinterpret_cast<MObject*>(const_cast<MObject*>(methodHandleMplObj.GetHandleJavaObj())),
+          reinterpret_cast<uintptr_t>(emStFrameObj));
+    } else {
+      RuntimeStub<void>::SlowCallCompiledMethod(transformMethod->GetFuncAddress(), xregValue.GetData(), 0, 0);
+    }
+    MRT_CheckThrowPendingExceptionUnw();
+    GetReturnValue(emStFrameObj, result);
+    return true;
+  }
+  return false;
+}
+
+bool EmStackFrameInvoker::FillParamsForEmStackFrame(BaseArgValue &paramArray) {
+  int8_t *cArray = emStackFrameMplObj->GetStackFrameNativeBytes(); // object might moving in ParamsConvert
+  for (uint32_t i = 0; i < paramLength; ++i) {
+    MClass *from = typesArr[i];
+    MClass *to = (*ptypesOfHandle)[i];
+    switch (*to->GetName()) {
+      case 'I':
+      case 'B':
+      case 'C':
+      case 'S':
+      case 'Z': {
+        paramArray.AddInt32(EMSFReader::GetIntFromEmStackFrame(cArray, byteIdx));
+        break;
+      }
+      case 'D': {
+        DoubleLongConvert u;
+        u.j = EMSFReader::GetLongFromEmStackFrame(cArray, byteIdx);
+        paramArray.AddDouble(u.d);
+        break;
+      }
+      case 'F': {
+        FloatIntConvert u;
+        u.i = EMSFReader::GetIntFromEmStackFrame(cArray, byteIdx);
+        paramArray.AddFloat(u.f);
+        break;
+      }
+      case 'J': {
+        paramArray.AddInt64(EMSFReader::GetLongFromEmStackFrame(cArray, byteIdx));
+        break;
+      }
+      default: {
+        jvalue value;
+        value.l = reinterpret_cast<jobject>(emStackFrameMplObj->GetReferencesObj(refIdx++));
+        STATEMENTCHECK(!methodHandleMplObj.ParamsConvert(from, to, typesArr, paramLength, value));
+        paramArray.AddReference(reinterpret_cast<MObject*>(value.l));
+        break;
+      }
+    }
+  }
+  return true;
+}
+
+bool EmStackFrameInvoker::InvokeInterpMethod(jvalue &result, MethodMeta &realMethod) {
+  ArgValueInterp paramArray(0);
+  STATEMENTCHECK(!FillParamsForEmStackFrame(paramArray));
+  if (MRT_HasPendingException()) {
+    return false;
+  }
+  if (realMethod.IsStatic()) {
+    result = maplert::interpreter::InterpJavaMethod<calljavastubconst::kJvalue>(&realMethod,
+        nullptr, reinterpret_cast<uintptr_t>(paramArray.GetData()));
+  } else {
+    result = maplert::interpreter::InterpJavaMethod<calljavastubconst::kJvalue>(&realMethod,
+        paramArray.GetReceiver(), reinterpret_cast<uintptr_t>(paramArray.GetData() + 1));
+  }
+  return true;
+}
+
+bool EmStackFrameInvoker::InvokeStaticCmpileMethod(jvalue &result, const MethodMeta &realMethod) {
+  ArgValue paramArray(0);
+  STATEMENTCHECK(!FillParamsForEmStackFrame(paramArray));
+  if (MRT_HasPendingException()) {
+    return false;
+  }
+  DoInvoke(realMethod, result, paramArray);
+  return true;
+}
+
+bool EmStackFrameInvoker::Invoke(jvalue &result) {
+  if (RecursiveInvokePoly(emStFrameObj, methodHandleMplObj, result)) {
+    return true;
+  }
+  // check pramater length
+  if (paramLength != ptypesOfHandle->size()) {
+    string exceptionStr = GeneExceptionString(methodHandleMplObj, typesArr, paramLength);
+    MRT_ThrowNewException("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+    return false;
+  }  // check end
+  MObject *param0 = emStackFrameMplObj->GetReferencesObj(0);
+  if (!mplFieldOrMethodMeta->IsStatic() && param0 == nullptr) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "null receiver");
+  }
+  MethodMeta *realMethod = methodHandleMplObj.GetRealMethod(param0);
+  STATEMENTCHECK(UNLIKELY(MRT_HasPendingException()))
+  STATEMENTCHECK(!ClinitCheck(realMethod->GetDeclaringClass()))
+  // interpreter path
+  if (realMethod->NeedsInterp()) {
+    // Interp
+    STATEMENTCHECK(!InvokeInterpMethod(result, *realMethod));
+  } else {
+    // O2
+    STATEMENTCHECK(!InvokeStaticCmpileMethod(result, *realMethod));
+  }
+  STATEMENTCHECK(UNLIKELY(MRT_HasPendingException()))
+  MClass *retType = mplFieldOrMethodMeta->GetReturnType();
+  if (retType == WellKnown::GetMClassV()) {
+    return true;
+  }
+  MObject *callsiteObj = emStFrameObj->LoadObjectNoRc(WellKnown::GetMFieldEmStackFrameCallsiteOffset());
+  MClass *retFromType =
+      reinterpret_cast<MClass*>(callsiteObj->LoadObjectNoRc(WellKnown::GetMFieldMethodHandlepRTypeOffset()));
+  STATEMENTCHECK(retFromType != WellKnown::GetMClassV() && !ConvertReturnValue(methodHandleMplObj,
+      typesArr, paramLength + 1, result))
+
+  // set return value to EMStackFrame
+  if (!MRT_ReflectClassIsPrimitive(*retFromType)) {
+    emStackFrameMplObj->PutReferencesObj(reinterpret_cast<MObject*>(result.l), refIdx);
+    RC_LOCAL_DEC_REF(result.l);
+  } else {
+    char typeMark = *(retFromType->GetName());
+    int8_t *cArray = emStackFrameMplObj->GetStackFrameNativeBytes();
+    EMSFWriter::WriteByMark(typeMark, cArray, byteIdx, result, !mplFieldOrMethodMeta->IsConstructor());
+  }
+  return true;
+}
+
+bool MethodHandle::InvokeWithEmStackFrame(MObject *emStFrameObj, jvalue &result) {
+  CHECK_E_B(emStFrameObj == nullptr, "InvokeWithEmStackFrame : emStFrameObj is nullptr");
+  EmStackFrameInvoker invoker(emStFrameObj, *this);
+  return invoker.Invoke(result);
+}
+
+MObject *MethodHandle::GetMemberInternal(const MObject *methodHandle) {
+  DCHECK(methodHandle != nullptr);
+  Kind tkind = static_cast<Kind>(methodHandle->Load<int>(WellKnown::GetMFieldMethodHandleHandleKindOffset(), false));
+  long fieldOrMethodMeta = methodHandle->Load<long>(WellKnown::GetMFieldMethodHandleArtFieldOrMethodOffset(), false);
+  if (tkind >= Kind::kInstanceGet) {
+    FieldMeta *fieldMeta = reinterpret_cast<FieldMeta*>(fieldOrMethodMeta);
+    MObject *mField = MField::NewMFieldObject(*fieldMeta);
+    return mField;
+  } else {
+    MethodMeta *methodMeta = reinterpret_cast<MethodMeta*>(fieldOrMethodMeta);
+    MObject *mMethod = MMethod::NewMMethodObject(*methodMeta);
+    return mMethod;
+  }
+}
+
+extern "C" jobject MRT_MethodHandleImplGetMemberInternal(const jobject methodHandle) {
+  MObject *internal = MethodHandle::GetMemberInternal(MObject::JniCast(methodHandle));
+  DCHECK(internal != nullptr);
+  return internal->AsJobject();
+}
+}  // namespace maple
diff --git a/src/mrt/maplert/src/mrt_methodhandle_mpl.cpp b/src/mrt/maplert/src/mrt_methodhandle_mpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3845bca388791c991514ce98efc23c3fcaf7a26d
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_methodhandle_mpl.cpp
@@ -0,0 +1,766 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_methodhandle_mpl.h"
+namespace maplert {
+static MClass *GetClassFromDescriptorAndCalSize(const char *desc, vector<char> &typesMark, const MClass *callerCls) {
+  DCHECK(desc != nullptr) << "GetClassFromDescriptorAndCalSize::descriptor is nullptr" << maple::endl;
+  switch (*desc) {
+    case 'I':
+      typesMark.push_back('I');
+      return WellKnown::GetMClassI();
+    case 'B':
+      typesMark.push_back('B');
+      return WellKnown::GetMClassB();
+    case 'F':
+      typesMark.push_back('F');
+      return WellKnown::GetMClassF();
+    case 'C':
+      typesMark.push_back('C');
+      return WellKnown::GetMClassC();
+    case 'S':
+      typesMark.push_back('S');
+      return WellKnown::GetMClassS();
+    case 'J':
+      typesMark.push_back('J');
+      return WellKnown::GetMClassJ();
+    case 'D':
+      typesMark.push_back('D');
+      return WellKnown::GetMClassD();
+    case 'Z':
+      typesMark.push_back('Z');
+      return WellKnown::GetMClassZ();
+    case 'V':
+      typesMark.push_back('V');
+      return WellKnown::GetMClassV();
+    default:
+      typesMark.push_back('L');
+      string str(desc);
+      return reinterpret_cast<MClass*>(MRT_GetClassByContextClass(*callerCls, str));
+  }
+}
+
+// the last element is return type
+void GetParameterAndRtType(vector<MClass*> &types, vector<char> &typesMark,
+                           MObject *protoStr, const MClass *declareClass) {
+  const char *methodSig = MRT_GetStringContentsPtrRaw(reinterpret_cast<jstring>(protoStr));
+  int count = MRT_StringGetStringLength(reinterpret_cast<jstring>(protoStr));
+
+  DCHECK(methodSig != nullptr) << "GetParameterAndRtType::methodSig is nullptr" << maple::endl;
+  ++methodSig;
+  size_t len = static_cast<size_t>(count) + 1;
+  char descriptor[len];
+
+  while (*methodSig != ')') {
+    if (memset_s(descriptor, len, 0, len) != EOK) {
+      LOG(FATAL) << "memset_s fail." << maple::endl;
+    }
+    ParseSignatrueType(descriptor, methodSig);
+    MClass *ptype = GetClassFromDescriptorAndCalSize(descriptor, typesMark, declareClass);
+    types.push_back(ptype);
+    ++methodSig;
+  }
+  ++methodSig;
+  if (memset_s(descriptor, len, 0, len) != EOK) {
+    LOG(FATAL) << "memset_s fail." << maple::endl;
+  }
+  ParseSignatrueType(descriptor, methodSig);
+  MClass *rtType = GetClassFromDescriptorAndCalSize(descriptor, typesMark, declareClass);
+  types.push_back(rtType);
+}
+
+void VargToJvalueArray(vector<jvalue> &paramArray, VArg &varg, uint32_t paramNum, vector<char> &typesMark) {
+  for (uint32_t i = 0; i < paramNum; ++i) {
+    jvalue val;
+    switch (typesMark[i]) {
+      case 'C':
+        val.c = static_cast<jchar>(varg.GetJint());
+        break;
+      case 'B':
+        val.b = static_cast<jbyte>(varg.GetJint());
+        break;
+      case 'S':
+        val.s = static_cast<jshort>(varg.GetJint());
+        break;
+      case 'Z':
+        val.z = static_cast<jboolean>(varg.GetJint());
+        break;
+      case 'I':
+        val.i = varg.GetJint();
+        break;
+      case 'D':
+        val.d = varg.GetJdouble();
+        break;
+      case 'F':
+        val.f = varg.GetJfloat();
+        break;
+      case 'J':
+        val.j = varg.GetJlong();
+        break;
+      default:
+        val.l = *varg.GetObject();
+        break;
+    }
+    paramArray.push_back(val);
+  }
+}
+
+jvalue MethodHandleCallEnter(MString *calleeName, MString *protoString, uint32_t paramNum,
+                             MObject *methodHandle, VArg &args, const MClass *declareClass) {
+  if (methodHandle == nullptr) {
+    maplert::MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "");
+  }
+  vector<char> typesMark;
+  vector<MClass*> paramTypes;
+  vector<jvalue> paramValueArray;
+
+  GetParameterAndRtType(paramTypes, typesMark, protoString, declareClass);
+  VargToJvalueArray(paramValueArray, args, paramNum, typesMark);
+  MethodHandleMpl methodHandleMplObj(methodHandle, MethodHandleMpl::IsExactInvoke(calleeName));
+  methodHandleMplObj.CheckReturnType();
+  jvalue val = methodHandleMplObj.invoke(paramValueArray, paramNum, typesMark, paramTypes);
+  MRT_CheckThrowPendingExceptionUnw();
+  return val;
+}
+
+void DropArguments(vector<jvalue> &paramArray, uint32_t &paramNum, const MObject *data,
+                   vector<char> &typesMark, vector<MClass*> &cSTypes) {
+  size_t numDroppedOffset = WellKnown::GetMFieldDropArgumentsDataNumDroppedOffset();
+  size_t startPosOffset = WellKnown::GetMFieldDropArgumentsDataStartPosOffset();
+  int32_t numDropped = MRT_LOAD_JINT(data, numDroppedOffset);
+  int32_t startPos = MRT_LOAD_JINT(data, startPosOffset);
+  uint32_t newSize = paramNum - static_cast<uint32_t>(numDropped);
+  typesMark.erase(typesMark.begin() + startPos, typesMark.begin() + numDropped + startPos);
+  cSTypes.erase(cSTypes.begin() + startPos, cSTypes.begin() + numDropped + startPos);
+  paramArray.erase(paramArray.begin() + startPos, paramArray.begin() + numDropped + startPos);
+  paramNum = newSize;
+}
+
+void BindTo(vector<jvalue> &paramArray, const MObject *data, uint32_t &paramNum, vector<char> &typesMark,
+            vector<MClass*> &cSTypes) {
+  size_t receiverOffset = WellKnown::GetMFieldBindToDataReceiverOffset();
+  MObject *receiver = reinterpret_cast<MObject*>(data->LoadObjectNoRc(receiverOffset));
+  if (receiver == nullptr) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "");
+    return;
+  }
+  MClass *receiverCls = receiver->GetClass();
+  jvalue val;
+  val.l = reinterpret_cast<jobject>(receiver);
+  paramArray.insert(paramArray.begin(), val);
+  typesMark.insert(typesMark.begin(), 'L');
+  cSTypes.insert(cSTypes.begin(), receiverCls);
+  ++paramNum;
+}
+
+jvalue MethodHandleMpl::FilterReturnValue(vector<jvalue> &paramArray, const uint32_t paramNum,
+    const MObject *data, vector<char> &typesMark, vector<MClass*> &cSTypes) {
+  size_t targetOffset = WellKnown::GetMFieldFilterReturnValueDataTargetOffset();
+  size_t filterOffset = WellKnown::GetMFieldFilterReturnValueDataFilterOffset();
+  MObject *target = reinterpret_cast<MObject*>(data->LoadObjectNoRc(targetOffset));
+  MObject *filter = reinterpret_cast<MObject*>(data->LoadObjectNoRc(filterOffset));
+  MethodHandleMpl targetHandle(target, isInvokeExact);
+  MethodHandleMpl filterHandle(filter, isInvokeExact);
+
+  jvalue val = targetHandle.invoke(paramArray, paramNum, typesMark, cSTypes, false);
+  vector<jvalue> filterParams;
+  filterParams.push_back(val); // no needed if returnytpe=V
+  MObject *finalType = targetHandle.typeArray->GetObjectElementNoRc(0);
+  MethodType mt(finalType);
+  MClass *returnType = const_cast<MClass*>(mt.GetReTType());
+  vector<char> retTypeMark;
+  retTypeMark.push_back(returnType->GetName()[0]);
+  if (returnType != WellKnown::GetMClassV() && returnType != WellKnown::GetMClassVoid()) {
+    MClass *csRetType = cSTypes.back();
+    cSTypes.clear();
+    cSTypes.push_back(returnType);
+    cSTypes.push_back(csRetType);
+    jvalue ret = filterHandle.invoke(filterParams, 1, retTypeMark, cSTypes);
+    if (!returnType->IsPrimitiveClass()) {
+      RC_LOCAL_DEC_REF(val.l);
+    }
+    return ret;
+    // filterReturnValue Transform just have one param
+  } else {
+    MClass *csRetType = cSTypes.back();
+    cSTypes.clear();
+    cSTypes.push_back(csRetType);
+    return filterHandle.invoke(filterParams, 0, retTypeMark, cSTypes);
+  }
+}
+
+void PermuteArguments(vector<jvalue> &paramArray, const uint32_t paramNum, const MObject *data, vector<char> &typesMark,
+                      vector<MClass*> &cSTypes) {
+  size_t targetOffset = WellKnown::GetMFieldPermuteArgumentsDataTargetOffset();
+  size_t reorderOffset = WellKnown::GetMFieldPermuteArgumentsDataReorderOffset();
+  jobject target = reinterpret_cast<jobject>(data->LoadObjectNoRc(targetOffset));
+  if (target == nullptr) {
+    MRT_ThrowNewExceptionUnw("java/lang/NullPointerException", "");
+    return;
+  }
+  int *reorder = reinterpret_cast<int*>(
+      reinterpret_cast<MArray*>(data->LoadObjectNoRc(reorderOffset))->ConvertToCArray());
+  vector<jvalue> paramArrayS = paramArray;
+  vector<char> typesMarkS = typesMark;
+  vector<MClass*> cSTypeS = cSTypes;
+  for (uint32_t i = 0; i < paramNum; ++i) {
+    uint32_t idx = static_cast<uint32_t>(reorder[i]);
+    paramArray[i] = paramArrayS[idx];
+    typesMark[i] = typesMarkS[idx];
+    cSTypes[i] = cSTypeS[idx];
+  }
+}
+
+static MethodMeta *RefineTargetMethodMpl(MethodMeta *method, const MObject *ref) {
+  MClass *decClass = method->GetDeclaringClass();
+  MClass *referClass = ref->GetClass();
+  if (decClass != referClass && referClass != nullptr) {
+    MethodMeta *realMthd = referClass->GetMethod(method->GetName(), method->GetSignature());
+    if (realMthd == nullptr) {
+      string msg = GeneIllegalArgumentExceptionString(referClass, decClass);
+      MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.c_str());
+      return method;
+    }
+    return realMthd;
+  }
+  return method;
+}
+
+jvalue FinalNode(uint32_t paramNum, vector<jvalue> &paramPtr, vector<char> &typesMarkPtr, MObject *meta) {
+  ArgValue paramArray(0);
+  JValueArg valueArg(paramPtr.data());
+  ArgsWrapper argsWrapper(valueArg);
+  FillArgsInfoNoCheck(argsWrapper, typesMarkPtr.data(), paramNum + 1, paramArray);
+  jvalue result;
+  result.l = 0UL;
+  MethodMeta *method = reinterpret_cast<MethodMeta*>(meta);
+  if (!method->IsStatic()) {
+    method = RefineTargetMethodMpl(reinterpret_cast<MethodMeta*>(meta), paramArray.GetReceiver());
+  }
+  DoInvoke(*method, result, paramArray);
+  return result;
+}
+
+string GeneExpectedNotMatchExceptionString(const MethodType &mt, vector<MClass*> cSTypes) {
+  string str = "expected (";
+  string className;
+  vector<MClass*> types = mt.GetParamsType();
+  size_t typeSize = types.size();
+  for (size_t i = 0; i < typeSize; ++i) {
+    className.clear();
+    types[i]->GetTypeName(className);
+    size_t idx = className.rfind(".");
+    str += className.substr(idx + 1);
+    if (i != typeSize - 1) {
+      str += ",";
+    }
+  }
+  str += ")";
+  className.clear();
+  const MClass *retType = mt.GetReTType(); // return type
+  retType->GetTypeName(className);
+  size_t index = className.rfind(".");
+  str += className.substr(index + 1);
+
+  str += " but found (";
+  size_t paramNum = cSTypes.size() - 1; // Remove the return value.
+  for (size_t i = 0; i < paramNum; ++i) {
+    className.clear();
+    cSTypes[i]->GetTypeName(className);
+    size_t idx = className.rfind(".");
+    str += className.substr(idx + 1);
+    if (i != paramNum - 1) {
+      str += ",";
+    }
+  }
+  str += ")";
+  className.clear();
+  cSTypes[paramNum]->GetTypeName(className); // return value
+  str += className;
+  return str;
+}
+
+class ConverterMPL {
+ public:
+  ConverterMPL(const MethodType mt, const vector<MClass*> types, jvalue *val, const MClass *from, const MClass *to)
+      : from(from), to(to), value(val), methodType(mt), cSTypes(types) {
+    toShortType = to ? *to->GetName() : 'V';
+    fromShortType = *from->GetName();
+  }
+
+  ~ConverterMPL() {
+    from = nullptr;
+    to = nullptr;
+    value = nullptr;
+  }
+
+  bool Convert() noexcept {
+    if (from == to) {
+      return true;
+    }
+    bool toIsPrim = (to != nullptr) ? to->IsPrimitiveClass() : true;
+    if (!toIsPrim && (from == WellKnown::GetMClassVoid() || from == WellKnown::GetMClassV())) {
+      return true;
+    }
+    jvalue kSrcValue(*(value));
+    (*(value)).j = 0;
+    bool fromIsPrim = (from != nullptr) ? from->IsPrimitiveClass() : true;
+    if (fromIsPrim && toIsPrim) {
+      if (UNLIKELY(!primitiveutil::ConvertNarrowToWide(fromShortType, toShortType, kSrcValue, *(value)))) {
+        ThrowWMT();
+        return false;
+      }
+      return true;
+    } else if (!fromIsPrim && !toIsPrim) {
+      if (kSrcValue.l) {
+        from = reinterpret_cast<MObject*>(kSrcValue.l)->GetClass();
+      }
+      value->l = kSrcValue.l;
+      if (UNLIKELY(!MRT_ReflectClassIsAssignableFrom(*to, *from))) {
+        MRT_ThrowNewException("java/lang/ClassCastException", GeneClassCastExceptionString(from, to).c_str());
+        return false;
+      }
+      return true;
+    } else if (!toIsPrim) {
+      return ConvertPrimToObj(kSrcValue);
+    } else {
+      bool ret = ConvertObjToPrim(kSrcValue);
+      if (ret == false) {
+        value->j = kSrcValue.j;
+      }
+      return ret;
+    }
+  }
+
+  void SetDec() {
+    needDec = true;
+  }
+
+ private:
+  bool ConvertObjToPrim(const jvalue &kSrcValue) noexcept {
+    char unboxedType = '0';
+    jvalue unboxedVal;
+    unboxedVal.j = 0;
+    if (UNLIKELY(!GetPrimShortTypeAndValue(reinterpret_cast<MObject*>(kSrcValue.l), unboxedType, unboxedVal, from))) {
+      ThrowWMT();
+      return false;
+    }
+
+    if (UNLIKELY(kSrcValue.l == nullptr)) {
+      MRT_ThrowNewException("java/lang/NullPointerException", "");
+      return false;
+    }
+    if (needDec) {
+      RC_LOCAL_DEC_REF(kSrcValue.l);
+    }
+
+    if (UNLIKELY(!primitiveutil::ConvertNarrowToWide(unboxedType, toShortType, unboxedVal, *(value)))) {
+      if (from == WellKnown::GetMClassNumber()) { // boxed to type must be assignablefrom number
+        MRT_ThrowNewException("java/lang/ClassCastException", GeneClassCastExceptionString(from, to).c_str());
+      } else {
+        ThrowWMT();
+      }
+      return false;
+    }
+    return true;
+  }
+
+  bool ConvertPrimToObj(const jvalue &kSrcValue) noexcept {
+    char type;
+    if (!GetPrimShortType(to, type)) {
+      if (CheckPrimitiveCanBoxed(fromShortType) && (to == WellKnown::GetMClassNumber() ||
+          to == WellKnown::GetMClassObject())) {
+        type = fromShortType;
+      } else {
+        ThrowWMT();
+        return false;
+      }
+    } else if (UNLIKELY(fromShortType != type)) {
+      ThrowWMT();
+      return false;
+    }
+
+    if (UNLIKELY(!primitiveutil::ConvertNarrowToWide(fromShortType, type, kSrcValue, *(value)))) {
+      ThrowWMT();
+      return false;
+    }
+    jobject boxed = reinterpret_cast<jobject>(primitiveutil::BoxPrimitive(type, kSrcValue));
+    value->l = boxed;
+    return true;
+  }
+
+  string GeneConvertFailExceptionString(const MethodType mt, vector<MClass*> callsiteTypes) const {
+    string str = "cannot convert MethodHandle(";
+    string className;
+    vector<MClass*> types = mt.GetParamsType();
+    size_t paramNum = callsiteTypes.size() - 1; // Remove the return value.
+    uint32_t typesIdx = 0;
+    for (size_t i = 0; i < paramNum; ++i) {
+      className.clear();
+      if (types[typesIdx]->IsArrayClass()) {
+        types[typesIdx]->GetTypeName(className);
+        size_t idxL = className.rfind(".");
+        size_t idxR = className.rfind("[");
+        str += className.substr(idxL + 1, idxR - idxL - 1);
+      } else {
+        types[i]->GetTypeName(className);
+        size_t idx = className.rfind(".");
+        str += className.substr(idx + 1);
+        ++typesIdx;
+      }
+      if (i != paramNum - 1) {
+        str += ",";
+      }
+    }
+    str += ")";
+    className.clear();
+    const MClass *retType = mt.GetReTType(); // return type
+    retType->GetTypeName(className);
+    size_t index = className.rfind(".");
+    str += className.substr(index + 1);
+    str += " to (";
+    for (size_t i = 0; i < paramNum; ++i) {
+      className.clear();
+      callsiteTypes[i]->GetTypeName(className);
+      size_t idx = className.rfind(".");
+      str += className.substr(idx + 1);
+      if (i != paramNum - 1) {
+        str += ",";
+      }
+    }
+    str += ")";
+    className.clear();
+    callsiteTypes[paramNum]->GetTypeName(className); // return value
+    index = className.rfind(".");
+    str += className.substr(index + 1);
+    return str;
+  }
+
+  void ThrowWMT() const noexcept {
+    string exceptionStr = GeneConvertFailExceptionString(methodType, cSTypes);
+    MRT_ThrowNewException("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+  }
+
+  const MClass *from;
+  const MClass *to;
+  jvalue *value;
+  bool needDec = false;
+  char toShortType;
+  char fromShortType;
+  MethodType methodType;
+  vector<MClass*> cSTypes;
+};
+
+bool ConvertJvalueMPL(const MethodType mt, const vector<MClass*> cSTypes,
+                      jvalue *val, const MClass *from, const MClass *to) {
+  ConverterMPL converter(mt, cSTypes, val, from, to);
+  return converter.Convert();
+}
+
+bool ConvertJvalueWithDecMPL(const MethodType mt, const vector<MClass*> cSTypes, jvalue *val,
+                             const MClass *from, const MClass *to) {
+  ConverterMPL converter(mt, cSTypes, val, from, to);
+  converter.SetDec();
+  return converter.Convert();
+}
+
+bool MethodHandleMpl::CheckParamsType(vector<MClass*> &cSTypes, uint32_t csTypesNum, vector<jvalue> &paramPtr,
+                                      uint32_t idx, bool checkRet) {
+  MObject *type = typeArray->GetObjectElementNoRc(idx);
+  MethodType mt(type);
+  const vector<MClass*> &paramsVec = mt.GetParamsType();
+  if (paramsVec.size() != csTypesNum) {
+    string exceptionStr = GeneExpectedNotMatchExceptionString(mt, cSTypes);
+    MRT_ThrowNewException("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+    return false;
+  }
+  if (isInvokeExact) { // todo, consider nominal type
+    if (std::equal(paramsVec.begin(), paramsVec.end(), cSTypes.begin()) &&
+        (!checkRet || mt.GetReTType() == cSTypes[csTypesNum])) {
+      return true;
+    }
+    string exceptionStr = GeneExpectedNotMatchExceptionString(mt, cSTypes);
+    MRT_ThrowNewException("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+    return false;
+  }
+  for (uint32_t i = 0; i < csTypesNum; ++i) {
+    if (!ConvertJvalueMPL(mt, cSTypes, &paramPtr[i], cSTypes[i], paramsVec[i])) {
+      string exceptionStr = GeneExpectedNotMatchExceptionString(mt, cSTypes);
+      MRT_ThrowNewException("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+      return false;
+    }
+    bool fromIsPrim = (cSTypes[i] != nullptr) ? cSTypes[i]->IsPrimitiveClass() : true;
+    bool toIsPrim = (paramsVec[i] != nullptr) ? paramsVec[i]->IsPrimitiveClass() : true;
+    if (fromIsPrim && !toIsPrim) {
+      ObjHandle<MObject> convertedVal(reinterpret_cast<MObject*>(paramPtr[i].j));
+    }
+  }
+  if (checkRet && mt.GetReTType() != cSTypes[csTypesNum]) {
+    string exceptionStr = GeneExpectedNotMatchExceptionString(mt, cSTypes);
+    MRT_ThrowNewException("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+    return false;
+  }
+  return true;
+}
+
+bool ConvertReturnValueMPL(const MethodType mt, const vector<MClass*> cSTypes,
+                           const MClass *from, const MClass *to, jvalue *val) {
+  if (from == to) {
+    return true;
+  }
+  if (to == WellKnown::GetMClassV()) {
+    if (!from->IsPrimitiveClass()) {
+      RC_LOCAL_DEC_REF(val->l);
+    }
+    return true;
+  }
+  if (from == WellKnown::GetMClassVoid() || from == WellKnown::GetMClassV()) {
+    val->l = 0L;
+    return true;
+  }
+  bool convertResult = ConvertJvalueWithDecMPL(mt, cSTypes, val, from, to);
+  if (!convertResult) {
+    RC_LOCAL_DEC_REF(val->l);
+  }
+  return convertResult;
+}
+static MArray *GeneratePrimMArray(const MethodType mt, uint32_t arrayLength, vector<MClass*> &cSTypes,
+                                  vector<jvalue> &paramPtr, const MClass *elemType) {
+  ObjHandle<MArray> arrayHandle(MArray::NewPrimitiveArrayComponentClass(arrayLength, *elemType));
+  for (uint32_t i = 0; i < arrayLength; ++i) {
+    uint32_t idx = static_cast<uint32_t>(cSTypes.size()) - arrayLength + i - 1;
+    jvalue val = paramPtr[idx];
+    if (!ConvertJvalueMPL(mt, cSTypes, &val, cSTypes[idx], elemType)) {
+      return nullptr;
+    }
+    switch (*elemType->GetName()) {
+      case 'I':
+        arrayHandle()->SetPrimitiveElement(i, val.i);
+        break;
+      case 'B':
+        arrayHandle()->SetPrimitiveElement(i, val.b);
+        break;
+      case 'S':
+        arrayHandle()->SetPrimitiveElement(i, val.s);
+        break;
+      case 'C':
+        arrayHandle()->SetPrimitiveElement(i, val.c);
+        break;
+      case 'Z':
+        arrayHandle()->SetPrimitiveElement(i, val.z);
+        break;
+      case 'D':
+        arrayHandle()->SetPrimitiveElement(i, val.d);
+        break;
+      case 'F':
+        arrayHandle()->SetPrimitiveElement(i, val.f);
+        break;
+      case 'J':
+        arrayHandle()->SetPrimitiveElement(i, val.j);
+        break;
+      default:
+        arrayHandle()->SetPrimitiveElement(i, val.l);
+        break;
+    }
+  }
+  return reinterpret_cast<MArray*>(arrayHandle.Return());
+}
+
+static MArray *GenerateObjMArray(const MethodType mt, uint32_t arrayLength, vector<MClass*> &cSTypes,
+                                 vector<jvalue> &paramPtr, const MClass *elemType) {
+  ObjHandle<MArray> arrayHandle(MArray::NewObjectArrayComponentClass(arrayLength, *WellKnown::GetMClassObject()));
+  for (uint32_t i = 0; i < arrayLength; ++i) {
+    uint32_t idx = static_cast<uint32_t>(cSTypes.size()) - arrayLength + i - 1;
+    jvalue val = paramPtr[idx];
+    if (!ConvertJvalueMPL(mt, cSTypes, &val, cSTypes[idx], elemType)) {
+      return nullptr;
+    }
+    if (cSTypes[idx]->IsPrimitiveClass()) {
+      ObjHandle<MObject> convertedVal(reinterpret_cast<MObject*>(val.j));
+    }
+    arrayHandle()->SetObjectElement(i, reinterpret_cast<MObject*>(val.l));
+  }
+  return reinterpret_cast<MArray*>(arrayHandle.Return());
+}
+
+static MArray *GenerateMArray(const MethodType mt, uint32_t arrayLength, vector<MClass*> &cSTypes,
+                              vector<jvalue> &paramPtr, const MClass *elemType) {
+  if (elemType->IsPrimitiveClass()) {
+    return GeneratePrimMArray(mt, arrayLength, cSTypes, paramPtr, elemType);
+  }
+  return GenerateObjMArray(mt, arrayLength, cSTypes, paramPtr, elemType);
+}
+
+class ReturnInfoClosure {
+ public:
+  ReturnInfoClosure(vector<char> &mark, vector<MClass*> &cls) : typesMark(mark), cSTypes(cls) {
+    returnMark = typesMark.back();
+    typesMark.pop_back();
+    returnType = cSTypes.back();
+    cSTypes.pop_back();
+  }
+  ~ReturnInfoClosure() noexcept {
+    typesMark.push_back(returnMark);
+    cSTypes.push_back(returnType);
+    returnType = nullptr;
+  }
+
+ private:
+  vector<char> &typesMark;
+  vector<MClass*> &cSTypes;
+  char returnMark;
+  MClass *returnType;
+};
+
+void MethodHandleMpl::PrepareVarg(vector<jvalue> &param, vector<char> &mark,
+                                  vector<MClass*> &types, uint32_t &csTypesNum) {
+  // do not prepare for invokeExact
+  if (isInvokeExact) {
+    return;
+  }
+  MethodMeta *method = GetMeta(transformNum - 1);
+  if (method != nullptr && modifier::IsVarargs(method->GetMod())) {
+    MethodType mt(typeArray->GetObjectElementNoRc(transformNum - 1));
+    constexpr int8_t nParamNum = 2;
+    if (1 + mt.GetParamsType().size() == types.size() &&
+        (types.size() > 1 && types[types.size() - nParamNum]->IsArrayClass())) {
+      // do nothing ? or check last param type isAssignableFrom
+    } else if (types.size() < mt.GetParamsType().size() - 1) {
+      string exceptionStr = GeneExpectedNotMatchExceptionString(mt, types);
+      MRT_ThrowNewException("java/lang/invoke/WrongMethodTypeException", exceptionStr.c_str());
+    } else { // convert callsite param to a java array
+      size_t arrayLength; // calculate convert num
+      if (mt.GetParamsType().size() == 1) { // one param,  just an object array,  convert all callsite params
+        arrayLength = method->IsStatic() ? types.size() - 1 : types.size();
+      } else {
+        arrayLength = types.size() - mt.GetParamsType().size();
+      }
+      ObjHandle<MObject> arrayHandle(GenerateMArray(
+          mt, static_cast<uint32_t>(arrayLength), types, param, mt.GetParamsType().back()->GetComponentClass()));
+      if (arrayHandle() == nullptr) {
+        return;
+      }
+      {
+        size_t iter = arrayLength;
+        ReturnInfoClosure info(mark, types);
+        while (iter-- != 0) {
+          param.pop_back();
+          mark.pop_back();
+          types.pop_back();
+        }
+        jvalue val;
+        val.l = reinterpret_cast<jobject>(arrayHandle());
+        param.push_back(val);
+        mark.push_back('L');
+        types.push_back(mt.GetParamsType().back());
+      }
+    }
+    csTypesNum = static_cast<uint32_t>(param.size());
+  }
+}
+
+string MethodHandleMpl::GeneNoSuchMethodExceptionString(const MethodType &methodType, const MethodMeta &method) {
+  string str = "no such method: ";
+  string className;
+  MClass *cls = method.GetDeclaringClass();
+  cls->GetTypeName(className);
+  str += className;
+  str += ".";
+  str += method.GetName();
+  vector<MClass*> types = methodType.GetParamsType();
+  size_t typesSize = types.size();
+  str += "(";
+  for (size_t i = 0; i < typesSize; ++i) {
+    className.clear();
+    types[i]->GetTypeName(className);
+    size_t idx = className.rfind(".");
+    str += className.substr(idx + 1);
+    if (i != typesSize - 1) {
+      str += ",";
+    }
+  }
+  str += ")";
+  const MClass *retType = methodType.GetReTType();
+  className.clear();
+  retType->GetTypeName(className);
+  str += className;
+  // add invokeVirtual/invokeStatic
+  return str;
+}
+
+void MethodHandleMpl::CheckReturnType() {
+  MethodMeta *method = GetMeta(transformNum - 1);
+  MObject *type = typeArray->GetObjectElementNoRc(0);
+  if (type != nullptr && method != nullptr) {
+    MethodType mt(type);
+    if (mt.GetReTType() != method->GetReturnType()) {
+      string exceptionStr = GeneNoSuchMethodExceptionString(mt, *method);
+      MRT_ThrowNewException("java/lang/NoSuchMethodException", exceptionStr.c_str());
+    }
+  }
+}
+
+jvalue MethodHandleMpl::invoke(vector<jvalue> &paramPtr, uint32_t csTypesNum, vector<char> &typesMark,
+                               vector<MClass*> &cSTypes, bool convertRetVal) {
+  jvalue result;
+  result.l = 0;
+  ScopedHandles sHandles;
+  PrepareVarg(paramPtr, typesMark, cSTypes, csTypesNum);
+  if (MRT_HasPendingException()) {
+    return result;
+  }
+  int32_t *opCArray = reinterpret_cast<int32_t*>(MRT_JavaArrayToCArray(opArray->AsJarray()));
+  for (int64_t i = transformNum - 1; i >= 0; --i) {
+    uint32_t idx = static_cast<uint32_t>(i);
+    MObject *data = dataArray->GetObjectElementNoRc(idx);
+    switch ((OptionFlag)opCArray[idx]) {
+      case OptionFlag::kDropArguments: {
+        if (!CheckParamsType(cSTypes, csTypesNum, paramPtr, idx)) {
+          return result;
+        }
+        DropArguments(paramPtr, csTypesNum, data, typesMark, cSTypes);
+        break;
+      }
+      case OptionFlag::kFinal: {
+        if (!CheckParamsType(cSTypes, csTypesNum, paramPtr, idx, false)) {
+          return result;
+        }
+        result = FinalNode(csTypesNum, paramPtr, typesMark, metaArray->GetObjectElementNoRc(idx));
+        break;
+      }
+      case OptionFlag::kFilterReturnValue:
+        // filterReturnValueChecks in java, so unnecessary check
+        result = FilterReturnValue(paramPtr, csTypesNum, data, typesMark, cSTypes);
+        break;
+      case OptionFlag::kBindto: {
+        BindTo(paramPtr, data, csTypesNum, typesMark, cSTypes);
+        if (MRT_HasPendingException()) {
+          return result;
+        }
+        break;
+      }
+      case OptionFlag::kPermuteArguments:
+        // permuteArgumentChecks in java, so unnecessary check
+        PermuteArguments(paramPtr, csTypesNum, data, typesMark, cSTypes);
+        break;
+    }
+  }
+  MObject *finalType = typeArray->GetObjectElementNoRc(0);
+  if (convertRetVal && finalType != nullptr) { // filterReturnValueChecks in java, so unnecessary check
+    MethodType finalMT(finalType);
+    ConvertReturnValueMPL(finalMT, cSTypes, finalMT.GetReTType(), cSTypes[csTypesNum], &result);
+  }
+  return result;
+}
+}
diff --git a/src/mrt/maplert/src/mrt_module_init.c__ b/src/mrt/maplert/src/mrt_module_init.c__
new file mode 100644
index 0000000000000000000000000000000000000000..e9b65d23592142276599407af0928ce49aa99296
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_module_init.c__
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+// This file shouldn't be included in libmaplert, instead,
+// it should be linked statically into each linking target (be it an executable or a shared library)
+extern "C" {
+
+#define MRT_EXPORT __attribute__((visibility("default")))
+
+extern char *__reflection_strtab_start__;
+extern char *__reflection_strtab_end__;
+extern char *__reflection_start_hot_strtab_start__;
+extern char *__reflection_start_hot_strtab_end__;
+extern char *__reflection_both_hot_strtab_start__;
+extern char *__reflection_both_hot_strtab_end__;
+extern char *__reflection_run_hot_strtab_start__;
+extern char *__reflection_run_hot_strtab_end__;
+
+extern char *__muid_range_tab_begin__;
+extern char *__muid_range_tab_end__;
+
+extern char *__compilerVersionNumTab_begin__;
+extern char *__compilerVersionNumTab_end__;
+
+extern char *__compiler_mfile_status_begin__;
+extern char *__compiler_mfile_status_end__;
+
+extern char *__decouple_start__;
+extern char *__decouple_end__;
+
+extern char *__muid_tab_start;
+extern char *__muid_tab_end;
+extern char *__eh_frame_start;
+extern char *__eh_frame_end;
+
+extern void *mfile_rometadata_method_start;
+extern void *mfile_rometadata_method_end;
+extern void *mfile_rometadata_field_start;
+extern void *mfile_rometadata_field_end;
+extern void *mfile_romuidtab_start;
+extern void *mfile_romuidtab_end;
+
+extern void *__maple_start__;
+extern void *__maple_end__;
+
+extern char *__bb_profile_strtab_begin;
+extern char *__bb_profile_strtab_end;
+extern char *__bb_profile_tab_begin;
+extern char *__bb_profile_tab_end;
+
+MRT_EXPORT char *MRT_GetMapleStart() {
+  return (char*)&__maple_start__;
+}
+
+MRT_EXPORT char *MRT_GetMapleEnd() {
+  return (char*)&__maple_end__;
+}
+
+// version query interface;
+MRT_EXPORT char *MRT_GetVersionTabBegin() {
+  return (char*)&__compilerVersionNumTab_begin__;
+}
+
+MRT_EXPORT char *MRT_GetVersionTabEnd() {
+  return (char*)&__compilerVersionNumTab_end__;
+}
+
+MRT_EXPORT char *MRT_GetMFileStatusBegin() {
+  return (char*)&__compiler_mfile_status_begin__;
+}
+
+MRT_EXPORT char *MRT_GetMFileStatusEnd() {
+  return (char*)&__compiler_mfile_status_end__;
+}
+
+// reflection strtab query interface;
+MRT_EXPORT char *MRT_GetColdStrTabBegin() {
+  return (char*)&__reflection_strtab_start__;
+}
+
+MRT_EXPORT char *MRT_GetColdStrTabEnd() {
+  return (char*)&__reflection_strtab_end__;
+}
+
+MRT_EXPORT char *MRT_GetStartHotStrTabBegin() {
+  return (char*)&__reflection_start_hot_strtab_start__;
+}
+
+MRT_EXPORT char *MRT_GetStartHotStrTabEnd() {
+  return (char*)&__reflection_start_hot_strtab_end__;
+}
+
+MRT_EXPORT char *MRT_GetBothHotStrTabBegin() {
+  return (char*)&__reflection_both_hot_strtab_start__;
+}
+
+MRT_EXPORT char *MRT_GetBothHotStrTabEnd() {
+  return (char*)&__reflection_both_hot_strtab_end__;
+}
+
+MRT_EXPORT char *MRT_GetRunHotStrTabBegin() {
+  return (char*)&__reflection_run_hot_strtab_start__;
+}
+
+MRT_EXPORT char *MRT_GetRunHotStrTabEnd() {
+  return (char*)&__reflection_run_hot_strtab_end__;
+}
+
+MRT_EXPORT void *MRT_GetRangeTableBegin() {
+  return reinterpret_cast<void*>(&__muid_range_tab_begin__);
+}
+
+MRT_EXPORT void *MRT_GetRangeTableEnd() {
+  return reinterpret_cast<void*>(&__muid_range_tab_end__);
+}
+
+MRT_EXPORT void *MRT_GetMuidTabBegin() {
+  return reinterpret_cast<void*>(&__muid_tab_start);
+}
+
+MRT_EXPORT void *MRT_GetMuidTabEnd() {
+  return reinterpret_cast<void*>(&__muid_tab_end);
+}
+
+MRT_EXPORT void *MRT_GetDecoupleTabBegin() {
+  return reinterpret_cast<void*>(&__decouple_start__);
+}
+
+MRT_EXPORT void *MRT_GetDecoupleTabEnd() {
+  return reinterpret_cast<void*>(&__decouple_end__);
+}
+
+MRT_EXPORT void *MRT_GetEhframeStart() {
+  return reinterpret_cast<void*>(&__eh_frame_start);
+}
+
+MRT_EXPORT void *MRT_GetEhframeEnd() {
+  return reinterpret_cast<void*>(&__eh_frame_end);
+}
+
+MRT_EXPORT void *MRT_GetMFileROMetadataMethodStart() {
+  return reinterpret_cast<void*>(&mfile_rometadata_method_start);
+}
+
+MRT_EXPORT void *MRT_GetMFileROMetadataMethodEnd() {
+  return reinterpret_cast<void*>(&mfile_rometadata_method_end);
+}
+
+MRT_EXPORT void *MRT_GetMFileROMetadataFieldStart() {
+  return reinterpret_cast<void*>(&mfile_rometadata_field_start);
+}
+
+MRT_EXPORT void *MRT_GetMFileROMetadataFieldEnd() {
+  return reinterpret_cast<void*>(&mfile_rometadata_field_end);
+}
+
+MRT_EXPORT void *MRT_GetMFileROMuidtabStart() {
+  return reinterpret_cast<void*>(&mfile_romuidtab_start);
+}
+
+MRT_EXPORT void *MRT_GetMFileROMuidtabEnd() {
+  return reinterpret_cast<void*>(&mfile_romuidtab_end);
+}
+
+MRT_EXPORT void *MRT_GetBBProfileTabBegin() {
+  return reinterpret_cast<void*>(&__bb_profile_tab_begin);
+}
+
+MRT_EXPORT void *MRT_GetBBProfileTabEnd() {
+  return reinterpret_cast<void*>(&__bb_profile_tab_end);
+}
+
+MRT_EXPORT void *MRT_GetBBProfileStrTabBegin() {
+  return reinterpret_cast<void*>(&__bb_profile_strtab_begin);
+}
+
+MRT_EXPORT void *MRT_GetBBProfileStrTabEnd() {
+  return reinterpret_cast<void*>(&__bb_profile_strtab_end);
+}
+
+__attribute__((weak))
+MRT_EXPORT void MRT_PreinitModuleClasses() {
+  return ;
+}
+
+#ifdef __MUSL__ // using musl as the C library
+// gcc/llvm generated code may need symbol __dso_handle
+// which is not provided by __MUSL__. Add it here to satisfy the link requirement.
+void *__dso_handle = nullptr;
+
+#endif // __MUSL__
+} // extern "C"
diff --git a/src/mrt/maplert/src/mrt_object.cpp b/src/mrt/maplert/src/mrt_object.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5177b34bb56eb6d880a9c5e99448bbfc85ee44ff
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_object.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <cstring>
+#include <cstdlib>
+#include <cstdio>
+#include <cassert>
+#include <cctype>
+#include <cstdint>
+#include "jni.h"
+#include "mrt_monitor_api.h"
+#include "sizes.h"
+#include "mstring_inline.h"
+
+using namespace std;
+namespace maplert {
+uint32_t GetObjectDWordSize(const MObject &obj) {
+  uint32_t objSize = obj.GetSize();
+  return (objSize + sizeof(void*) - 1) / sizeof(void*);
+}
+
+// Make and return shallow copy of object.
+jobject MRT_CloneJavaObject(jobject jObj) {
+  ScopedHandles sHandles;
+  ObjHandle<MObject, false> mObj(MObject::JniCastNonNull(jObj));
+  size_t objSz = static_cast<size_t>(mObj->GetSize());
+  ObjHandle<MObject> newObj(MObject::NewObject(*(mObj->GetClass()), objSz));
+  if (newObj() != 0) {
+    errno_t tmpResult = memcpy_s(reinterpret_cast<uint8_t*>(newObj()), objSz,
+                                 reinterpret_cast<uint8_t*>(mObj()), objSz);
+    if (UNLIKELY(tmpResult != EOK)) {
+      LOG(FATAL) << "memcpy_s() in MRT_CloneJavaObject() return " << tmpResult << " rather than 0." << maple::endl;
+    }
+    uint32_t *paddr = reinterpret_cast<uint32_t*>(newObj.AsRaw() + sizeof(MetaRef));
+    *paddr = 0;
+    Collector::Instance().PostObjectClone(mObj.AsRaw(), newObj.AsRaw());
+  }
+  return newObj.ReturnJObj();
+}
+
+size_t MRT_SizeOfObject(jobject obj) {
+  return kHeaderSize + MObject::JniCastNonNull(obj)->GetSize();
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_poisonstack.cpp b/src/mrt/maplert/src/mrt_poisonstack.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8da122dbedda07499714e2a93f7e5d9eabd743ae
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_poisonstack.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_poisonstack.h"
+#include <memory.h>
+#include <pthread.h>
+#include <cstdlib>
+#include "securec.h"
+#include "base/logging.h"
+
+namespace maplert {
+extern "C" {
+#if CONFIG_JSAN
+static bool GetThreadStack(pthread_attr_t *attr, uintptr_t *spBegin, uintptr_t *spEnd) {
+  size_t v = 0;
+  void *stkAddr = nullptr;
+  if (pthread_attr_getstack(attr, &stkAddr, &v)) {
+    return false;
+  }
+
+  v &= ~(0x1000 - 1);  // workaround for guard page
+
+  *spEnd = reinterpret_cast<uintptr_t>(stkAddr);
+  *spBegin = *spBegin + v;
+
+  if (*spBegin > *spEnd) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+static bool FetchLocalThreadStack(uintptr_t *spBegin, uintptr_t *spEnd) {
+  pthread_attr_t myAttr;
+  if (pthread_getattr_np(pthread_self(), &myAttr)) {
+    return false;
+  }
+  return GetThreadStack(&myAttr, spBegin, spEnd);
+}
+
+static void poison_stack(uintptr_t framePtr) {
+  if (framePtr) {
+    return;
+  }
+
+  uintptr_t spBegin = 0;
+  uintptr_t spEnd = 0;
+  if (FetchLocalThreadStack(&spBegin, &spEnd)) {
+    if (memset_s(reinterpret_cast<void*>(framePtr), sizeof(uintptr_t) * (spEnd - static_cast<uintptr_t>(framePtr)),
+                 0xba, sizeof(uintptr_t) * (spEnd - static_cast<uintptr_t>(framePtr))) != EOK) {
+      LOG(ERROR) << "memset_s fail" << maple::endl;
+    }
+  }
+}
+#endif
+
+void MRT_InitPoisonStack(uintptr_t framePtr) {
+#if CONFIG_JSAN
+  void *fa = framePtr ? reinterpret_cast<void*>(framePtr) : __builtin_frame_address(1);
+  poison_stack(reinterpret_cast<uintptr_t>(fa));
+#else
+  (void)framePtr;
+#endif
+}
+} // extern "C"
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_preload_class.cpp b/src/mrt/maplert/src/mrt_preload_class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5f1a5d8709b7461f2bfa0df893d041610043a8a9
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_preload_class.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "chelper.h"
+#include "mrt_class_init.h"
+
+#define CLASS_PREFIX(className) extern void *MRT_CLASSINFO(className);
+#define MRT_CLASSINFO(className) __MRT_MAGIC_PASTE(CLASSINFO_PREFIX, className)
+#include "white_list.def"
+#undef MRT_CLASSINFO
+#undef CLASS_PREFIX
+
+namespace maplert {
+extern "C" {
+
+void MRT_BootstrapClinit(void) {
+#define CLASS_PREFIX(className) (void)MRT_TryInitClass(*reinterpret_cast<MClass*>(&MRT_CLASSINFO(className)));
+#define MRT_CLASSINFO(className) __MRT_MAGIC_PASTE(CLASSINFO_PREFIX, className)
+#ifdef __ANDROID__
+
+#include "white_list.def"
+
+#else
+  (void)MRT_TryInitClass(*reinterpret_cast<MClass*>(&MRT_CLASSINFO(Ljava_2Flang_2FString_3B)));
+  (void)MRT_TryInitClass(*reinterpret_cast<MClass*>(&MRT_CLASSINFO(Ljava_2Flang_2FByte_24ByteCache_3B)));
+  (void)MRT_TryInitClass(*reinterpret_cast<MClass*>(&MRT_CLASSINFO(Ljava_2Flang_2FByte_3B)));
+#endif
+#undef MRT_CLASSINFO
+#undef CLASS_PREFIX
+}
+
+} // extern "C"
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_primitive_class.def b/src/mrt/maplert/src/mrt_primitive_class.def
new file mode 100644
index 0000000000000000000000000000000000000000..72234f83fe106c8017716d8cbe8042c14619494f
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_primitive_class.def
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+
+// predefined common classes for primitive types. should be generated.
+using namespace maplert;
+extern "C" {
+
+extern void *MRT_CLASSINFO(Ljava_2Flang_2FObject_3B);
+extern void *MRT_CLASSINFO(Ljava_2Flang_2Freflect_2FField_3B);
+extern void *MRT_CLASSINFO(Ljava_2Flang_2FCharSequence_3B);
+extern void *MRT_CLASSINFO(Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B);
+#ifdef __OPENJDK__
+extern void *MRT_CLASSINFO(Ljava_2Futil_2FHashtable_24Entry_3B);
+#else // libcore
+extern void *MRT_CLASSINFO(Ljava_2Futil_2FHashtable_24HashtableEntry_3B);
+extern void *MRT_CLASSINFO(Llibcore_2Freflect_2FAnnotationMember_3B);
+#endif // __OPENJDK__
+extern void *MRT_CLASSINFO(Ljava_2Futil_2FFormatter_24Flags_3B);
+extern void *MRT_CLASSINFO(Ljava_2Futil_2FHashMap_24Node_3B);
+extern void *MRT_CLASSINFO(Ljava_2Futil_2FFormatter_24FormatString_3B);
+extern void *MRT_CLASSINFO(Ljava_2Flang_2FString_3B);
+extern void *MRT_CLASSINFO(Ljava_2Flang_2FClass_3B);
+extern void *MRT_CLASSINFO(Ljava_2Flang_2Freflect_2FMethod_3B);
+extern void *MRT_CLASSINFO(Ljava_2Flang_2Fannotation_2FAnnotation_3B);
+extern void *MRT_CLASSINFO(Ljava_2Flang_2Freflect_2FConstructor_3B);
+extern void *MRT_CLASSINFO(Ljava_2Flang_2Freflect_2FParameter_3B);
+extern void *MRT_CLASSINFO(Lsun_2Fsecurity_2Futil_2FDerValue_3B);
+extern void *MRT_CLASSINFO(Lsun_2Fsecurity_2Fx509_2FAVA_3B);
+
+// These definition are from maple_ir/include/reflection_analysis.h
+#define FLAG_CLASS_PRIMITIVE    0x0001
+#define FLAG_CLASS_ARRAY        0x0002
+#define MODIFIER_PUBLIC         0x00000001
+#define MODIFIER_PRIM           0x00000411  //Abstract Final Public
+#define MODIFIER_ARRAY          0x00000411  //Abstract Final Public
+
+#define NAME_STRING_(name) #name
+#define NAME_STRING(name) ((uintptr_t)NAME_STRING_(name))
+#define NAME_CONCAT(prefix, name) prefix##name
+#define NAME_LENGTH(name) (sizeof(NAME_STRING_(name))-1)  // only for constant string
+
+extern void (*MRT_ITABLE(Ljava_2Flang_2FObject_3B))();
+extern void (*MRT_VTABLE(Ljava_2Flang_2FObject_3B))();
+extern void *MRT_FIELDS(Ljava_2Flang_2FObject_3B);
+extern void *MRT_METHODS(Ljava_2Flang_2FObject_3B);
+extern void *MRT_GCTIB(Ljava_2Flang_2FObject_3B);
+
+#ifdef USE_32BIT_REF
+#define FIELD_CLASS \
+    (static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&MRT_CLASSINFO(Ljava_2Flang_2Freflect_2FField_3B))))
+#define CLASS_CLASS (static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&MRT_CLASSINFO(Ljava_2Flang_2FClass_3B))))
+#define GET_OFFSET_REF(base, target) ((int32_t)((char*)(base) - (char*)(target)))
+#else
+#define FIELD_CLASS ((uintptr_t)(&MRT_CLASSINFO(Ljava_2Flang_2Freflect_2FField_3B)))
+#define CLASS_CLASS ((uintptr_t)(&MRT_CLASSINFO(Ljava_2Flang_2FClass_3B)))
+#define GET_OFFSET_REF(base, target) ((intptr_t)((char*)(base) - (char*)(target)))
+#endif //USE_32BIT_REF
+
+#define GET_OFFSET(base, target) ((uintptr_t)((char*)(base) - (char*)(target)))
+#define VTAB_OBJECT ((uintptr_t)(&MRT_VTABLE(Ljava_2Flang_2FObject_3B)))
+#define GCTIB_OBJECT ((void*)(&MRT_GCTIB(Ljava_2Flang_2FObject_3B)))
+#define GCTIB_OBJECT_ARRAY ((void*)(&MRT_GCTIB(_ArrayOfObject)))
+#define GCTIB_PRIMITIVE_ARRAY ((void*)(&MRT_GCTIB(_ArrayOfPrimitive)))
+#define FIELDS_OBJECT ((FieldMeta*)(&MRT_FIELDS(Ljava_2Flang_2FObject_3B)))
+#define FIELDS_SIZE_OBJECT 2
+#define METHODS_OBJECT ((MethodMetadata*)(&MRT_METHODS(Ljava_2Flang_2FObject_3B)))
+#define METHODS_SIZE_OBJECT 11
+// compiler will complaints about using ClassMetadata *
+#define CLASS_PRIMITIVE(name) ((uintptr_t)(&MRT_PRIMITIVECLASSINFO(name)))
+#define CLASS(name) ((uintptr_t)(&MRT_CLASSINFO(name)))
+
+#ifdef USE_32BIT_REF
+// classinfo for primitive-type classinfo itself
+#define DEFINE_PRIMITIVE_CLASSINFO_RO(name) \
+static ClassMetadataRO __primitiveclassinforo__##name = { { NAME_STRING(name) }, \
+    { 0 }, { 0 },\
+    { { 0 } },\
+    0, 0,\
+    MODIFIER_PRIM, { 0 }, { 0 } };
+
+#define DEFINE_PRIMITIVE_CLASSINFO(name, size) \
+ClassMetadata MRT_EXPORT MRT_PRIMITIVECLASSINFO(name) = { CLASS_CLASS, 0, 0, { size }, \
+    FLAG_CLASS_PRIMITIVE, 0, { 0 }, \
+    { VTAB_OBJECT }, \
+    { GET_OFFSET(GCTIB_OBJECT, &(__pinf_##name.gctib)) }, \
+    { (uint32_t)(uintptr_t)&__primitiveclassinforo__##name }, { 0 }, { (uintptr_t)&MRT_PRIMITIVECLASSINFO(name) } };
+
+// classinfo for array-of-primitive-type classinfo
+#define DEFINE_ARRAY_PRIMCLASSINFO_RO(name, reflectname, elemname) \
+static ClassMetadataRO __primitiveclassinforo__##name = { { NAME_STRING(reflectname) }, \
+    { 0 }, { 0 },\
+    { { CLASS_PRIMITIVE(elemname) } }, \
+    0, 0,\
+    MODIFIER_ARRAY, { 0 }, { 0 } };
+
+#define DEFINE_ARRAY_PRIMCLASSINFO(name, elemname, gcTIB, componentSize) \
+ClassMetadata MRT_EXPORT MRT_PRIMITIVECLASSINFO(name) = { CLASS_CLASS, 0, 0, { componentSize }, \
+    FLAG_CLASS_ARRAY, 0, { 0 }, \
+    { VTAB_OBJECT }, \
+    { GET_OFFSET(gcTIB, &(__pinf_##name.gctib)) },\
+    { (uint32_t)(uintptr_t)&__primitiveclassinforo__##name }, { 0 }, { (uintptr_t)&MRT_PRIMITIVECLASSINFO(name) } };
+
+#define REF_SIZE  4   // 4B for a single reference
+
+#else //!USE_32BIT_REF
+
+// classinfo for primitive-type classinfo itself
+#define DEFINE_PRIMITIVE_CLASSINFO_RO(name) \
+static ClassMetadataRO __primitiveclassinforo__##name = { { NAME_STRING(name) }, \
+    { 0 }, { 0 },\
+    { { 0 } },\
+    0, 0, FLAG_CLASS_PRIMITIVE, 0, 0, \
+    MODIFIER_PRIM, { 0 }, { 0 } };
+
+#define DEFINE_PRIMITIVE_CLASSINFO(name, size) \
+ClassMetadata MRT_EXPORT MRT_PRIMITIVECLASSINFO(name) = { CLASS_CLASS, 0, 0, { size }, { 0 }, \
+    { VTAB_OBJECT }, \
+    { GET_OFFSET(GCTIB_OBJECT, &(__pinf_##name.gctib)) }, \
+    { (uintptr_t)&__primitiveclassinforo__##name }, { (uintptr_t)&MRT_PRIMITIVECLASSINFO(name) } };
+
+// classinfo for array-of-primitive-type classinfo
+#define DEFINE_ARRAY_PRIMCLASSINFO_RO(name, reflectname, elemname) \
+static ClassMetadataRO __primitiveclassinforo__##name = { { NAME_STRING(reflectname) }, \
+    { 0 }, { 0 },\
+    { { CLASS_PRIMITIVE(elemname) } }, \
+    0, 0, FLAG_CLASS_ARRAY, 0, 0, \
+    MODIFIER_ARRAY, { 0 }, { 0 } };
+
+#define DEFINE_ARRAY_PRIMCLASSINFO(name, elemname, gcTIB, componentSize) \
+ClassMetadata MRT_EXPORT MRT_PRIMITIVECLASSINFO(name) = { CLASS_CLASS, 0, 0, { componentSize }, { 0 }, \
+    { VTAB_OBJECT }, \
+    { GET_OFFSET(gcTIB, &(__pinf_##name.gctib)) },\
+    { (uintptr_t)&__primitiveclassinforo__##name }, { (uintptr_t)&MRT_PRIMITIVECLASSINFO(name) } };
+
+#define REF_SIZE  8   // 8B for a single reference
+
+#endif //USE_32BIT_REF
+
+// up to 3-dim array. higher dimensional array and array of object will be
+// generated at runtime.
+#define DEFINE_PRIMITIVE_CLASSINFOS(ptype, type1d, type1dname, type2d, type2dname, type3d, type3dname, size) \
+DEFINE_PRIMITIVE_CLASSINFO_RO(ptype) \
+DEFINE_PRIMITIVE_CLASSINFO(ptype, size) \
+DEFINE_ARRAY_PRIMCLASSINFO_RO(type1d, type1dname, ptype) \
+DEFINE_ARRAY_PRIMCLASSINFO(type1d, ptype, GCTIB_PRIMITIVE_ARRAY, size) \
+DEFINE_ARRAY_PRIMCLASSINFO_RO(type2d, type2dname, type1d) \
+DEFINE_ARRAY_PRIMCLASSINFO(type2d, type1d, GCTIB_OBJECT_ARRAY, REF_SIZE) \
+DEFINE_ARRAY_PRIMCLASSINFO_RO(type3d, type3dname, type2d) \
+DEFINE_ARRAY_PRIMCLASSINFO(type3d, type2d, GCTIB_OBJECT_ARRAY, REF_SIZE) \
+static ClassMetadata *__mrt_pclasses_##ptype[4] = { &MRT_PRIMITIVECLASSINFO(ptype), &MRT_PRIMITIVECLASSINFO(type1d),\
+                                                    &MRT_PRIMITIVECLASSINFO(type2d), &MRT_PRIMITIVECLASSINFO(type3d) };
+
+DEFINE_PRIMITIVE_CLASSINFOS(Z, AZ, [Z, AAZ, [[Z, AAAZ, [[[Z, 1)
+DEFINE_PRIMITIVE_CLASSINFOS(B, AB, [B, AAB, [[B, AAAB, [[[B, 1)
+DEFINE_PRIMITIVE_CLASSINFOS(S, AS, [S, AAS, [[S, AAAS, [[[S, 2)
+DEFINE_PRIMITIVE_CLASSINFOS(C, AC, [C, AAC, [[C, AAAC, [[[C, 2)
+DEFINE_PRIMITIVE_CLASSINFOS(I, AI, [I, AAI, [[I, AAAI, [[[I, 4)
+DEFINE_PRIMITIVE_CLASSINFOS(F, AF, [F, AAF, [[F, AAAF, [[[F, 4)
+DEFINE_PRIMITIVE_CLASSINFOS(D, AD, [D, AAD, [[D, AAAD, [[[D, 8)
+DEFINE_PRIMITIVE_CLASSINFOS(J, AJ, [J, AAJ, [[J, AAAJ, [[[J, 8)
+DEFINE_PRIMITIVE_CLASSINFOS(V, AV, [V, AAV, [[V, AAAV, [[[V, 0)
+
+// classinfo for array-of-hotclass
+
+#ifdef USE_32BIT_REF
+#define DEFINE_ARRAY_CLASSINFO_RO(name, reflectname, elemname) \
+ClassMetadataRO __cinfro__##name = { { NAME_STRING(reflectname) }, \
+    { 0 }, { 0 }, \
+    { { CLASS(elemname) } }, \
+    0, 0, \
+    MODIFIER_ARRAY, { 0 }, { 0 } };
+
+// Will be registered to boot-class-loader when initialized
+#define DEFINE_ARRAY_CLASSINFO(name, componentSize) \
+ClassMetadata MRT_EXPORT MRT_CLASSINFO(name) = { CLASS_CLASS, 0, 0, { componentSize }, \
+    FLAG_CLASS_ARRAY, 0, { 0 },\
+    { VTAB_OBJECT }, \
+    { GET_OFFSET(GCTIB_OBJECT_ARRAY, &(__cinf_##name.gctib)) },\
+    { (uint32_t)(uintptr_t)&__cinfro__##name }, { 0 }, { (uintptr_t)&MRT_CLASSINFO(name) } };
+
+#else //!USE_32BIT_REF
+
+#define DEFINE_ARRAY_CLASSINFO_RO(name, reflectname, elemname) \
+ClassMetadataRO __cinfro__##name = { { NAME_STRING(reflectname) }, \
+    { 0 }, { 0 }, \
+    { { CLASS(elemname) } }, \
+    0, 0, FLAG_CLASS_ARRAY,  0, 0, \
+    MODIFIER_ARRAY, { 0 }, { 0 } };
+
+// Will be registered to boot-class-loader when initialized
+#define DEFINE_ARRAY_CLASSINFO(name, componentSize) \
+ClassMetadata MRT_EXPORT MRT_CLASSINFO(name) = { CLASS_CLASS, 0, 0, { componentSize }, { 0 },\
+    { VTAB_OBJECT }, \
+    { GET_OFFSET(GCTIB_OBJECT_ARRAY, &(__cinf_##name.gctib)) },\
+    { (uintptr_t)&__cinfro__##name }, { (uintptr_t)&MRT_CLASSINFO(name) } };
+
+#endif //USE_32BIT_REF
+
+#define DEFINE_CLASSINFOS(name, reflectname, elemname) \
+    DEFINE_ARRAY_CLASSINFO_RO(name, reflectname, elemname) \
+    DEFINE_ARRAY_CLASSINFO(name, REF_SIZE)
+
+DEFINE_CLASSINFOS(ALjava_2Flang_2FObject_3B, [Ljava/lang/Object;, Ljava_2Flang_2FObject_3B)
+DEFINE_CLASSINFOS(ALjava_2Flang_2FClass_3B, [Ljava/lang/Class;, Ljava_2Flang_2FClass_3B)
+DEFINE_CLASSINFOS(ALjava_2Flang_2FString_3B, [Ljava/lang/String;, Ljava_2Flang_2FString_3B)
+DEFINE_CLASSINFOS(ALjava_2Futil_2FFormatter_24Flags_3B, [Ljava/util/Formatter$Flags;, Ljava_2Futil_2FFormatter_24Flags_3B)
+DEFINE_CLASSINFOS(ALjava_2Futil_2FHashMap_24Node_3B, [Ljava/util/HashMap$Node;, Ljava_2Futil_2FHashMap_24Node_3B)
+DEFINE_CLASSINFOS(ALjava_2Futil_2FFormatter_24FormatString_3B, [Ljava/util/Formatter$FormatString;, Ljava_2Futil_2FFormatter_24FormatString_3B)
+DEFINE_CLASSINFOS(ALjava_2Flang_2FCharSequence_3B, [Ljava/lang/CharSequence;, Ljava_2Flang_2FCharSequence_3B)
+DEFINE_CLASSINFOS(ALjava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B, [Ljava/lang/ThreadLocal$ThreadLocalMap$Entry;, Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B)
+DEFINE_CLASSINFOS(ALsun_2Fsecurity_2Futil_2FDerValue_3B, [Lsun/security/util/DerValue;, Lsun_2Fsecurity_2Futil_2FDerValue_3B)
+DEFINE_CLASSINFOS(ALsun_2Fsecurity_2Fx509_2FAVA_3B, [Lsun/security/x509/AVA;, Lsun_2Fsecurity_2Fx509_2FAVA_3B)
+#ifdef __OPENJDK__
+DEFINE_CLASSINFOS(ALjava_2Futil_2FHashtable_24Entry_3B, [Ljava/util/Hashtable$Entry;, Ljava_2Futil_2FHashtable_24Entry_3B)
+#else // libcore
+DEFINE_CLASSINFOS(ALjava_2Futil_2FHashtable_24HashtableEntry_3B, [Ljava/util/Hashtable$HashtableEntry;, Ljava_2Futil_2FHashtable_24HashtableEntry_3B)
+DEFINE_CLASSINFOS(ALlibcore_2Freflect_2FAnnotationMember_3B, [Llibcore/reflect/AnnotationMember;,
+                  Llibcore_2Freflect_2FAnnotationMember_3B);
+#endif // __OPENJDK__
+}
diff --git a/src/mrt/maplert/src/mrt_primitive_util.cpp b/src/mrt/maplert/src/mrt_primitive_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..16eff8e864253fdcb53820bc492bc5168649b18d
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_primitive_util.cpp
@@ -0,0 +1,317 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_primitive_util.h"
+#include "mclass_inline.h"
+namespace maplert {
+MObject *primitiveutil::BoxPrimitiveJint(int32_t value) {
+  if (!WellKnown::GetMClassIntegerCache()->InitClassIfNeeded()) {
+    LOG(ERROR) << "fail do clinit, " << "class: " << WellKnown::GetMClassIntegerCache()->GetName() << maple::endl;
+  }
+  int32_t low = *reinterpret_cast<int*>(WellKnown::GetFieldMetaIntegerCacheLow()->GetStaticAddr());
+  int32_t high = *reinterpret_cast<int*>(WellKnown::GetFieldMetaIntegerCacheHigh()->GetStaticAddr());
+  if (value >= low && value <= high) {
+    return GetCacheMember(*WellKnown::GetMClassIntegerCache(), *WellKnown::GetFieldMetaIntegerCache(),
+        static_cast<uint32_t>(value + (-low)), false);
+  }
+  MObject *ret = MObject::NewObject(*WellKnown::GetMClassInteger());
+  ret->Store<jint>(WellKnown::GetMFieldIntegerValueOffset(), value, false);
+  return ret;
+}
+
+char primitiveutil::GetPrimitiveTypeFromBoxType(const MClass &type) {
+  if (&type == WellKnown::GetMClassInteger()) {
+    return 'I';
+  } else if (&type == WellKnown::GetMClassBoolean()) {
+    return 'Z';
+  } else if (&type == WellKnown::GetMClassByte()) {
+    return 'B';
+  } else if (&type == WellKnown::GetMClassShort()) {
+    return 'S';
+  } else if (&type == WellKnown::GetMClassCharacter()) {
+    return 'C';
+  } else if (&type == WellKnown::GetMClassLong()) {
+    return 'J';
+  } else if (&type == WellKnown::GetMClassFloat()) {
+    return 'F';
+  } else if (&type == WellKnown::GetMClassDouble()) {
+    return 'D';
+  }
+  return 'N';
+}
+
+bool primitiveutil::IsBoxObject(const MObject &o, char srcType) {
+  MClass *klass = o.GetClass();
+  switch (srcType) {
+    case 'Z':
+      return klass == WellKnown::GetMClassBoolean();
+    case 'B':
+      return klass == WellKnown::GetMClassByte();
+    case 'S':
+      return klass == WellKnown::GetMClassShort();
+    case 'C':
+      return klass == WellKnown::GetMClassCharacter();
+    case 'I':
+      return klass == WellKnown::GetMClassInteger();
+    case 'J':
+      return klass == WellKnown::GetMClassLong();
+    case 'F':
+      return klass == WellKnown::GetMClassFloat();
+    case 'D':
+      return klass == WellKnown::GetMClassDouble();
+    default:
+      return false;
+  }
+}
+
+MObject *primitiveutil::BoxPrimitive(char srcType, const jvalue &value) {
+  MObject *retObj = nullptr;
+  switch (srcType) {
+    case 'Z':
+      retObj = BoxPrimitiveJboolean(value.z);
+      break;
+    case 'B':
+      retObj = BoxPrimitiveJbyte(value.b);
+      break;
+    case 'C':
+      retObj = BoxPrimitiveJchar(value.c);
+      break;
+    case 'D':
+      retObj = BoxPrimitiveJdouble(value.d);
+      break;
+    case 'F':
+      retObj = BoxPrimitiveJfloat(value.f);
+      break;
+    case 'I':
+      retObj = BoxPrimitiveJint(value.i);
+      break;
+    case 'J':
+      retObj = BoxPrimitiveJlong(value.j);
+      break;
+    case 'S':
+      retObj = BoxPrimitiveJshort(value.s);
+      break;
+    default: ;
+  }
+  return retObj;
+}
+
+bool primitiveutil::UnBoxPrimitive(const MObject &elementObj, jvalue &boxedValue) {
+  boxedValue.j = 0;
+  MClass *elementObjClass = elementObj.GetClass();
+  char type = GetPrimitiveTypeFromBoxType(*elementObjClass);
+  size_t offset = 0;
+  switch (type) {
+    case 'Z':
+      offset = WellKnown::GetMFieldBooleanValueOffset();
+      boxedValue.z = elementObj.Load<uint8_t>(offset);
+      break;
+    case 'B':
+      offset = WellKnown::GetMFieldByteValueOffset();
+      boxedValue.b = elementObj.Load<int8_t>(offset);
+      break;
+    case 'C':
+      offset = WellKnown::GetMFieldCharacterValueOffset();
+      boxedValue.c = elementObj.Load<uint16_t>(offset);
+      break;
+    case 'D':
+      offset = WellKnown::GetMFieldDoubleValueOffset();
+      boxedValue.d = elementObj.Load<double>(offset);
+      break;
+    case 'F':
+      offset = WellKnown::GetMFieldFloatValueOffset();
+      boxedValue.f = elementObj.Load<float>(offset);
+      break;
+    case 'I':
+      offset = WellKnown::GetMFieldIntegerValueOffset();
+      boxedValue.i = elementObj.Load<int32_t>(offset);
+      break;
+    case 'J':
+      offset = WellKnown::GetMFieldLongValueOffset();
+      boxedValue.j = elementObj.Load<int64_t>(offset);
+      break;
+    case 'S':
+      offset = WellKnown::GetMFieldShortValueOffset();
+      boxedValue.s = elementObj.Load<int16_t>(offset);
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+
+bool primitiveutil::ConvertToInt(char srcType, const jvalue &src, jvalue &dst) {
+  switch (srcType) {
+    case 'B':
+      dst.i = src.b;
+      return true;
+    case 'C':
+      dst.i = src.c;
+      return true;
+    case 'S':
+      dst.i = src.s;
+      return true;
+    case 'I':
+      dst.i = src.i;
+      return true;
+    default: ;
+  }
+  return false;
+}
+
+bool primitiveutil::ConvertToLong(char srcType, const jvalue &src, jvalue &dst) {
+  switch (srcType) {
+    case 'B':
+      dst.j = src.b;
+      return true;
+    case 'C':
+      dst.j = src.c;
+      return true;
+    case 'S':
+      dst.j = src.s;
+      return true;
+    case 'I':
+      dst.j = src.i;
+      return true;
+    case 'J':
+      dst.j = src.j;
+      return true;
+    default: ;
+  }
+  return false;
+}
+
+bool primitiveutil::ConvertToFloat(char srcType, const jvalue &src, jvalue &dst) {
+  switch (srcType) {
+    case 'B':
+      dst.f = src.b;
+      return true;
+    case 'C':
+      dst.f = src.c;
+      return true;
+    case 'S':
+      dst.f = src.s;
+      return true;
+    case 'I':
+      dst.f = src.i;
+      return true;
+    case 'J':
+      dst.f = src.j;
+      return true;
+    case 'F':
+      dst.f = src.f;
+      return true;
+    default: ;
+  }
+  return false;
+}
+
+bool primitiveutil::ConvertToDouble(char srcType, const jvalue &src, jvalue &dst) {
+  switch (srcType) {
+    case 'B':
+      dst.d = src.b;
+      return true;
+    case 'C':
+      dst.d = src.c;
+      return true;
+    case 'S':
+      dst.d = src.s;
+      return true;
+    case 'I':
+      dst.d = src.i;
+      return true;
+    case 'J':
+      dst.d = src.j;
+      return true;
+    case 'F':
+      dst.d = src.f;
+      return true;
+    case 'D':
+      dst.d = src.d;
+      return true;
+    default: ;
+  }
+  return false;
+}
+
+bool primitiveutil::ConvertNarrowToWide(char srcType, char dstType, const jvalue &src, jvalue &dst) {
+  dst.j = 0;
+  if (LIKELY(srcType == dstType)) {
+    dst = src;
+    return true;
+  }
+  switch (dstType) {
+    case 'Z':
+    case 'C':
+    case 'B':
+      break;
+    case 'S':
+      if (srcType == 'B') {
+        dst.s = src.b;
+        return true;
+      }
+      break;
+    case 'I':
+      return ConvertToInt(srcType, src, dst);
+    case 'J':
+      return ConvertToLong(srcType, src, dst);
+    case 'F':
+      return ConvertToFloat(srcType, src, dst);
+    case 'D':
+      return ConvertToDouble(srcType, src, dst);
+    default:
+      break;
+  }
+  return false;
+}
+
+bool primitiveutil::CanConvertNarrowToWide(char srcType, char dstType) {
+  if (LIKELY(srcType == dstType)) {
+    return true;
+  }
+  switch (dstType) {
+    case 'Z':
+    case 'C':
+    case 'B':
+      break;
+    case 'S':
+      if (srcType == 'B') {
+        return true;
+      }
+      break;
+    case 'I':
+      if (srcType == 'B' || srcType == 'C' || srcType == 'S') {
+        return true;
+      }
+      break;
+    case 'J':
+      if (srcType == 'B' || srcType == 'C' || srcType == 'S' || srcType == 'I') {
+        return true;
+      }
+      break;
+    case 'F':
+      if (srcType == 'B' || srcType == 'C' || srcType == 'S' || srcType == 'I' || srcType == 'J') {
+        return true;
+      }
+      break;
+    case 'D':
+      if (srcType == 'B' || srcType == 'C' || srcType == 'S' || srcType == 'I' || srcType == 'J' || srcType == 'F') {
+        return true;
+      }
+      break;
+    default:;
+  }
+  return false;
+}
+} // namespace maplert
\ No newline at end of file
diff --git a/src/mrt/maplert/src/mrt_profile.cpp b/src/mrt/maplert/src/mrt_profile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..442bb740c3286234a89371479927adbfb107f885
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_profile.cpp
@@ -0,0 +1,596 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_profile.h"
+#include <cstring>
+#include <algorithm>
+#include <atomic>
+#include <fstream>
+#include <unordered_set>
+#include <set>
+#include <vector>
+#include <sstream>
+#include "mclass_inline.h"
+#include "fieldmeta_inline.h"
+#include "methodmeta_inline.h"
+#include "profile_type.h"
+#include "file_layout.h"
+#include "linker_api.h"
+#include "utils/time_utils.h"
+#include "mrt_string.h"
+#include "gc_log.h"
+using namespace maple;
+
+namespace maplert {
+namespace {
+std::unordered_set<const MClass*> hotClassMetaSet;
+std::unordered_set<const MClass*> hotMethodMetaSet;
+std::unordered_set<const MClass*> hotFieldMetaSet;
+std::unordered_set<const MethodMeta*> hotMethodSignatureSet;
+std::unordered_map<const char*, LayoutType> hotRefectionStrInfo;
+std::vector<std::string> strTab;
+std::unordered_map<std::string, uint32_t> str2idx;
+const char *kMapleSoPrefix = "libmaple";
+std::atomic<bool> runPhase(false);
+std::mutex reflectStrMtx;
+std::mutex classMetaMtx;
+std::mutex fieldMetaMtx;
+std::mutex methodMetaMtx;
+std::mutex methodSignatureMtx;
+std::atomic<bool> profileEnable(true);
+}
+
+template<typename T> using MapleProfile = std::unordered_map<uint32_t, std::vector<T>>;
+using MapleIRProf = std::unordered_map<std::string, MFileIRProfInfo>;
+
+static uint32_t GetorInsertStrInTab(const std::string &str) {
+  static uint32_t idx = 0;
+  auto item = str2idx.find(str);
+  if (item == str2idx.end()) {
+    uint32_t oldIdx = idx;
+    str2idx.insert(std::make_pair(str, oldIdx));
+    strTab.push_back(str);
+    idx++;
+    return oldIdx;
+  } else {
+    return item->second;
+  }
+}
+
+template<typename Out>
+static void Split(const std::string &s, char delim, Out result) {
+  std::stringstream ss;
+  ss.str(s);
+  std::string item;
+  while (std::getline(ss, item, delim)) {
+    *(result++) = item;
+  }
+}
+// system/lib64/libmaplecore-all.so  --> core-all
+static std::string GetBaseName(const std::string &str) {
+  size_t pos = str.find(kMapleSoPrefix);
+  std::string baseName(str);
+  if (pos != std::string::npos) {
+    size_t posEnd = str.find_last_of('.');
+    baseName = str.substr(pos + strlen(kMapleSoPrefix), posEnd - pos - strlen(kMapleSoPrefix));
+  }
+  if (!LOG_NDEBUG) {
+    LOG(INFO) << "Base name of " << str << " is " << baseName << maple::endl;
+  }
+  return baseName;
+}
+extern "C" void MRT_EnableMetaProfile() {
+  profileEnable = true;
+}
+
+extern "C" void MRT_DisableMetaProfile() {
+  profileEnable = false;
+}
+
+extern "C" void MRT_ClearMetaProfile() {
+  runPhase  = true;
+}
+
+void InsertReflectionString(const char *kHotString) {
+  if (kHotString == nullptr) {
+    return;
+  }
+  if (profileEnable) {
+    std::lock_guard<std::mutex> lock(reflectStrMtx);
+    if (runPhase) {
+      auto item = hotRefectionStrInfo.find(kHotString);
+      if (item != hotRefectionStrInfo.end()) {
+        if (item->second == kLayoutBootHot) {
+          item->second = kLayoutBothHot;
+        } else {
+          return ;
+        }
+      } else {
+        hotRefectionStrInfo.insert(std::make_pair(kHotString, kLayoutRunHot));
+      }
+    } else {
+      hotRefectionStrInfo.insert(std::make_pair(kHotString, kLayoutBootHot));
+    }
+  }
+}
+
+void InsertClassMetadata(const MClass &klass) {
+  std::lock_guard<std::mutex> lock(classMetaMtx);
+  (void)hotClassMetaSet.insert(&klass);
+}
+
+void InsertMethodMetadata(const MethodMetaBase *kMethod) {
+  if (kMethod == nullptr) {
+    return;
+  }
+  if (profileEnable) {
+    MClass *declaringClass = kMethod->GetDeclaringClass();
+    std::lock_guard<std::mutex> lock(methodMetaMtx);
+    hotMethodMetaSet.insert(declaringClass);
+  }
+}
+
+void InsertMethodMetadata(const MClass &cls) {
+  std::lock_guard<std::mutex> lock(methodMetaMtx);
+  (void)hotMethodMetaSet.insert(&cls);
+}
+
+void InsertFieldMetadata(FieldMeta *fieldMeta) {
+  if (fieldMeta == nullptr) {
+    return;
+  }
+  MClass *declearingclass = fieldMeta->GetDeclaringclass();
+  std::lock_guard<std::mutex> lock(fieldMetaMtx);
+  hotFieldMetaSet.insert(declearingclass);
+}
+
+void InsertFieldMetadata(const MClass &cls) {
+  std::lock_guard<std::mutex> lock(fieldMetaMtx);
+  (void)hotFieldMetaSet.insert(&cls);
+}
+
+void InsertMethodSignature(const MethodMeta &method) {
+  std::lock_guard<std::mutex> lock(methodSignatureMtx);
+  (void)hotMethodSignatureSet.insert(&method);
+}
+
+void GenStrData(std::vector<char> &strData) {
+  for (auto str : strTab) {
+    strData.insert(strData.end(), str.c_str(), str.c_str() + str.size() + 1);
+  }
+}
+
+class ProfileWriter {
+ public:
+  ProfileWriter(const std::string &path, bool isSystemServer) : path(path), isSystemServer(isSystemServer) {}
+  ~ProfileWriter() = default;
+  void WriteToFile();
+ private:
+  std::string path;
+  bool isSystemServer = false;
+  uint8_t profileDataNum = 0;
+  uint32_t profileDataSize = 0;
+  static constexpr uint64_t nsPerUs = 1000UL;
+  std::vector<char> profileData;
+  std::vector<ProfileDataInfo> profileHeaders;
+  void RemoveProfile();
+  void GenReflectStrMetaData(MapleProfile<ReflectionStrItem> &metaProfile,
+                             std::unordered_map<const char*, LayoutType> &data);
+  void GenMetaData(MapleProfile<MetaItem> &metaProfile, std::unordered_set<const MClass*> &data);
+  void GenFuncData(MapleProfile<FunctionItem> &funcProfile,
+                   std::unordered_map<std::string, std::vector<FuncProfInfo>> &data);
+  void GenMethodSignatureData(MapleProfile<MethodSignatureItem> &metaProfile,
+                              std::unordered_set<const MethodMeta*> &data);
+  template<class T>
+  void WriteProfileData(MapleProfile<T> &data, ProfileType profileType);
+  void WriteIRProfData(MapleIRProf &data);
+  void ProcessMetaData();
+  void ProcessFuncProf();
+  void ProcessRawProf();
+  void InitFileHeader(Header &header);
+  void Init();
+  void ProcessProfData(); // used to transfer the raw profdata to file format
+  void WriteFormatDataToFile();
+};
+
+void ProfileWriter::GenReflectStrMetaData(MapleProfile<ReflectionStrItem> &metaProfile,
+                                          std::unordered_map<const char*, LayoutType> &data) {
+  for (auto item : data) {
+    void *pc = static_cast<void*>(const_cast<char*>(item.first));
+    LinkerMFileInfo *soInfo = LinkerAPI::Instance().GetLinkerMFileInfoByAddress(pc, false);
+    if (soInfo == nullptr) {
+      LOG(ERROR) << "find reflect str so failed  " << std::hex << pc << std::dec << maple::endl;
+      continue;
+    }
+    // skip system so when save app profile
+    if (!isSystemServer && !soInfo->BelongsToApp()) {
+      continue;
+    }
+    std::string belongSo = soInfo->name;
+    std::string baseName = GetBaseName(belongSo);
+    std::string name = item.first;
+    uint32_t soIdx = GetorInsertStrInTab(baseName);
+    uint32_t strIdx = GetorInsertStrInTab(name);
+    auto metaData = metaProfile.find(soIdx);
+    if (metaData == metaProfile.end()) {
+      std::vector<ReflectionStrItem> metaList { ReflectionStrItem(strIdx, static_cast<uint8_t>(item.second)) };
+      metaProfile.insert(std::make_pair(soIdx, metaList));
+    } else {
+      (metaData->second).emplace_back(strIdx, item.second);
+    }
+  }
+}
+
+// gen meta data from the raw data
+void ProfileWriter::GenMetaData(MapleProfile<MetaItem> &metaProfile, std::unordered_set<const MClass*> &data) {
+  for (auto item : data) {
+    LinkerMFileInfo *soInfo = LinkerAPI::Instance().GetLinkerMFileInfoByAddress(item, false);
+    if (soInfo == nullptr) {
+      LOG(ERROR) << "find Meta str so failed  " << std::hex << item << std::dec << maple::endl;
+      continue;
+    }
+    if (!isSystemServer && !soInfo->BelongsToApp()) {
+      continue;
+    }
+    std::string belongSo = soInfo->name;
+    std::string baseName = GetBaseName(belongSo);
+    char *className = item->GetName();
+    std::string name = className;
+    uint32_t soIdx = GetorInsertStrInTab(baseName);
+    uint32_t strIdx = GetorInsertStrInTab(name);
+    auto metaData = metaProfile.find(soIdx);
+    if (metaData == metaProfile.end()) {
+      std::vector<MetaItem> metaList { MetaItem(strIdx) };
+      metaProfile.insert(std::make_pair(soIdx, metaList));
+    } else {
+      (metaData->second).emplace_back(strIdx);
+    }
+  }
+}
+
+void ProfileWriter::GenFuncData(MapleProfile<FunctionItem> &funcProfile,
+                                std::unordered_map<std::string, std::vector<FuncProfInfo>> &data) {
+  for (auto item : data) {
+    auto &rawFunclist = item.second;
+    std::string baseName = GetBaseName(item.first);
+    uint32_t soIdx = GetorInsertStrInTab(baseName);
+    auto &list = funcProfile[soIdx];
+    for (auto &funcProfileData : rawFunclist) {
+      std::vector<std::string> soNames;
+      Split(funcProfileData.funcName, '|', std::back_inserter(soNames));
+      // funcname ==> className|funcName|signaturename
+      // so className idx in vector is 0, funcName is 1, signatureName is 2
+      uint32_t classIdx = GetorInsertStrInTab(soNames[0]);
+      uint32_t funcIdx = GetorInsertStrInTab(soNames[1]);
+      uint32_t sigIdx = GetorInsertStrInTab(soNames[2]);
+      list.emplace_back(classIdx, funcIdx, sigIdx, funcProfileData.callTimes, funcProfileData.layoutType);
+    }
+  }
+}
+
+void ProfileWriter::GenMethodSignatureData(MapleProfile<MethodSignatureItem> &metaProfile,
+                                           std::unordered_set<const MethodMeta*> &data) {
+  for (auto item : data) {
+    LinkerMFileInfo *metghodSoInfo = LinkerAPI::Instance().GetLinkerMFileInfoByAddress(item, false);
+    LinkerMFileInfo *sigSoInfo = LinkerAPI::Instance().GetLinkerMFileInfoByAddress(item->GetSignature(), false);
+    LinkerMFileInfo *soInfo;
+    if (sigSoInfo == nullptr && metghodSoInfo == nullptr) {
+      LOG(ERROR) << "find Meta str so failed  " << std::hex << item << std::dec << maple::endl;
+      continue;
+    } else if (metghodSoInfo == nullptr) {
+      soInfo = sigSoInfo;
+    } else {
+      soInfo = metghodSoInfo;
+    }
+    if (!isSystemServer && !soInfo->BelongsToApp()) {
+      continue;
+    }
+    std::string belongSo = soInfo->name;
+    std::string baseName = GetBaseName(belongSo);
+    char *methodName = item->GetName();
+    char *signatureName = item->GetSignature();
+    uint32_t soIdx = GetorInsertStrInTab(baseName);
+    uint32_t methodIdx = GetorInsertStrInTab(methodName);
+    uint32_t sigIdx = GetorInsertStrInTab(signatureName);
+    auto metaData = metaProfile.find(soIdx);
+    if (metaData == metaProfile.end()) {
+      std::vector<MethodSignatureItem> metaList { MethodSignatureItem(methodIdx, sigIdx) };
+      metaProfile.insert(std::make_pair(soIdx, metaList));
+    } else {
+      (metaData->second).emplace_back(methodIdx, sigIdx);
+    }
+  }
+}
+
+// profiledata are arranged by [header][dataArray][header][dataArray] and so on
+template<typename T>
+void ProfileWriter::WriteProfileData(MapleProfile<T> &data, ProfileType profileType) {
+  uint32_t realNum = 0;
+  uint32_t lastProfileDataSize = profileDataSize;
+  for (auto &item : data) {
+    auto typeTProfdataArray = item.second;
+    uint32_t num = static_cast<uint32_t>(typeTProfdataArray.size());
+    // if size overflow, or num is 0 skip this data
+    if ((num > (UINT32_MAX / sizeof(T))) || num == 0) {
+      continue;
+    }
+    realNum++;
+    char *str = nullptr;
+    uint32_t soIdx = item.first;
+    str = reinterpret_cast<char*>(&soIdx);
+    profileData.insert(profileData.end(), str, str + sizeof(soIdx));
+    uint32_t size = num * sizeof(T);
+
+    str = reinterpret_cast<char*>(&num);
+    profileData.insert(profileData.end(), str, str + sizeof(num));
+
+    str = reinterpret_cast<char*>(&size);
+    profileData.insert(profileData.end(), str, str + sizeof(size));
+
+    str = reinterpret_cast<char*>(typeTProfdataArray.data());
+    profileData.insert(profileData.end(), str, str + size);
+    // update profileDataSize
+    profileDataSize  = profileDataSize + sizeof(num) + sizeof(size) + sizeof(soIdx) + size;;
+  }
+  if (realNum != 0) {
+    profileHeaders.emplace_back(lastProfileDataSize, static_cast<uint8_t>(profileType), realNum);
+    profileDataNum++;
+  } else {
+    return ;
+  }
+}
+
+void ProfileWriter::WriteIRProfData(MapleIRProf &data) {
+  MapleProfile<FunctionIRProfItem> funcDescTab;
+  MapleProfile<FuncCounterItem> funcCounterTab;
+  for (auto item : data) {
+    auto &rawFuncList = item.second;
+    std::string baseName = GetBaseName(item.first);
+    uint32_t soIdx = GetorInsertStrInTab(baseName);
+    auto &descTab = rawFuncList.descTab;
+    auto &counterTab = rawFuncList.counterTab;
+    // gen file counter tab
+    auto &counterList = funcCounterTab[soIdx];
+    for (auto &counter : counterTab) {
+      counterList.emplace_back(counter);
+    }
+
+    // gen file func desc tab
+    auto &list = funcDescTab[soIdx];
+    for (auto &funcDesc : descTab) {
+      std::vector<std::string> soNames;
+      Split(funcDesc.funcName, '|', std::back_inserter(soNames));
+      uint32_t classIdx = GetorInsertStrInTab(soNames[0]);
+      uint32_t funcIdx = GetorInsertStrInTab(soNames[1]);
+      uint32_t sigIdx = GetorInsertStrInTab(soNames[2]);
+      list.emplace_back(funcDesc.hash, classIdx, funcIdx, sigIdx, funcDesc.start, funcDesc.end);
+    }
+    VLOG(profiler) << baseName << " counterTab size " << counterList.size()  << " descTab size " <<
+        list.size() <<  "\n";
+  }
+  // because profile desc tab depends on profile counter Tab, so must write counterTab first
+  WriteProfileData<FuncCounterItem>(funcCounterTab, kIRCounter);
+  WriteProfileData<FunctionIRProfItem>(funcDescTab, kBBInfo);
+}
+
+// process classmeta/fieldmeta/methodmeta/reflectionstr profile data;
+void ProfileWriter::ProcessMetaData() {
+  MapleProfile<MetaItem> classMeta;
+  {
+    std::lock_guard<std::mutex> lock(classMetaMtx);
+    GenMetaData(classMeta, hotClassMetaSet);
+  }
+  WriteProfileData<MetaItem>(classMeta, kClassMeta);
+
+  MapleProfile<MetaItem> methodMeta;
+  {
+    std::lock_guard<std::mutex> lock(methodMetaMtx);
+    GenMetaData(methodMeta, hotMethodMetaSet);
+  }
+  WriteProfileData<MetaItem>(methodMeta, kMethodMeta);
+
+  MapleProfile<MetaItem> fieldMeta;
+  {
+    std::lock_guard<std::mutex> lock(fieldMetaMtx);
+    GenMetaData(fieldMeta, hotFieldMetaSet);
+  }
+  WriteProfileData<MetaItem>(fieldMeta, kFieldMeta);
+
+  // process reflection str profile data;
+  MapleProfile<ReflectionStrItem> reflectStrMeta;
+  {
+    std::lock_guard<std::mutex> lock(reflectStrMtx);
+    GenReflectStrMetaData(reflectStrMeta, hotRefectionStrInfo);
+  }
+  WriteProfileData<ReflectionStrItem>(reflectStrMeta, kReflectionStr);
+
+  MapleProfile<MethodSignatureItem> methodSignature;
+  {
+    std::lock_guard<std::mutex> lock(methodSignatureMtx);
+    GenMethodSignatureData(methodSignature, hotMethodSignatureSet);
+  }
+  WriteProfileData<MethodSignatureItem>(methodSignature, kMethodSig);
+}
+
+void ProfileWriter::ProcessFuncProf() {
+  // when get the profile data of metdata and function will case some reflection str recored
+  // so first disble meta profile
+  MRT_DisableMetaProfile();
+  std::unordered_map<std::string, std::vector<FuncProfInfo>> funcProfileRaw;
+  MapleIRProf funcIRProfRaw;
+  MapleProfile<FunctionItem> funcProfile;
+  LinkerAPI::Instance().DumpAllMplFuncProfile(funcProfileRaw);
+  LinkerAPI::Instance().DumpAllMplFuncIRProfile(funcIRProfRaw);
+  MRT_EnableMetaProfile();
+  GenFuncData(funcProfile, funcProfileRaw);
+  WriteProfileData<FunctionItem>(funcProfile, kFunction);
+  // write func ir prof
+  WriteIRProfData(funcIRProfRaw);
+}
+// some kind prof data save the raw data in profile directly like literal and BB profile
+// because raw prof data is readable,and compact
+void ProfileWriter::ProcessRawProf() {
+  // process literal string
+  std::stringstream literalProfile;
+  std::string literalContent;
+  DumpConstStringPool(literalProfile, true);
+  literalContent = literalProfile.str();
+  uint32_t literalContentSize = static_cast<uint32_t>(literalContent.size());
+  if (literalContentSize != 0) {
+    profileHeaders.emplace_back(profileDataSize, kLiteral, 0);
+    profileDataNum++;
+    profileDataSize += literalContentSize;
+    (void)profileData.insert(profileData.end(), literalContent.c_str(), literalContent.c_str() + literalContentSize);
+  }
+  // process BB profile
+  std::ostringstream bbProfile;
+  LinkerAPI::Instance().DumpBBProfileInfo(bbProfile);
+  std::string bbProfileContent = bbProfile.str();
+  uint32_t bbProfileContentSize = static_cast<uint32_t>(bbProfileContent.size());
+  if (bbProfileContentSize != 0) {
+    profileHeaders.emplace_back(profileDataSize, kBBInfo, 0);
+    profileDataNum++;
+    profileDataSize += bbProfileContentSize;
+    (void)profileData.insert(profileData.end(), bbProfileContent.c_str(),
+                             bbProfileContent.c_str() + bbProfileContentSize);
+  }
+}
+
+void ProfileWriter::RemoveProfile() {
+  if (std::remove(path.c_str())) {
+    if (errno != ENOENT) {
+      LOG(ERROR) << "RemoveProfile failed to remove " << path << ", " << strerror(errno);
+    }
+    return;
+  }
+  LOG(INFO) << "RemoveProfile remove " << path << " successfully";
+  return;
+}
+
+void ProfileWriter::Init() {
+  if (!isSystemServer) {
+    char *str = nullptr;
+    std::string packageName = LinkerAPI::Instance().GetAppPackageName();
+    uint32_t packageNameIdx = GetorInsertStrInTab(packageName);
+    profileHeaders.emplace_back(profileDataSize, kFileDesc, 1);
+    profileDataNum++;
+    str = reinterpret_cast<char*>(&packageNameIdx);
+    profileData.insert(profileData.end(), str, str + sizeof(packageNameIdx));
+    profileDataSize  = profileDataSize + sizeof(packageNameIdx);
+  }
+}
+
+void ProfileWriter::ProcessProfData() {
+  uint64_t processProfileStart = timeutils::NanoSeconds();
+  ProcessMetaData();
+  ProcessFuncProf();
+  ProcessRawProf();
+  uint64_t processProfileEnd = timeutils::NanoSeconds();
+  uint64_t processProfileCost = processProfileEnd - processProfileStart;
+  LOG(INFO) << "Total process Profile time: " << Pretty(processProfileCost / nsPerUs) << "us" << maple::endl;
+}
+
+void ProfileWriter::InitFileHeader(Header &header) {
+  std::copy_n(kProfileMagic, sizeof(kProfileMagic), header.magic);
+  std::copy_n(kVer, sizeof(kVer), header.ver);
+  header.profileNum = profileDataNum;
+  if (!isSystemServer) {
+    header.profileFileType = kApp;
+  } else {
+    header.profileFileType = kSystemServer;
+  }
+  uint32_t headerSize = sizeof(Header) + (profileDataNum - 1) * sizeof(ProfileDataInfo);
+  // adjust the offset
+  header.stringTabOff = headerSize + profileDataSize;
+  header.stringCount = static_cast<uint32_t>(strTab.size());
+  for (auto &item : profileHeaders) {
+    item.profileDataOff = item.profileDataOff + headerSize;
+  }
+}
+
+void ProfileWriter::WriteFormatDataToFile() {
+  uint64_t processProfileEnd = timeutils::NanoSeconds();
+  Header header;
+  InitFileHeader(header);
+  bool res = true;
+  bool removeIfFailed = true;
+  std::vector<char> strData;
+  std::ofstream out(path, std::ios::binary | std::ios::trunc);
+  if (!out) {
+    if (errno != EACCES) {
+      LOG(ERROR) << "SaveProfile failed to open " << path << ", " << strerror(errno);
+    } else {
+      removeIfFailed = false;
+    }
+    res = false;
+    goto END;
+  }
+  // write header
+  if (!out.write(reinterpret_cast<char*>(&header), sizeof(Header) - sizeof(ProfileDataInfo))) {
+    LOG(ERROR) << "SaveProfile  failed to write header for " << path << ", " << strerror(errno);
+    res = false;
+    goto END;
+  }
+  // write profile date info
+  if (!out.write(reinterpret_cast<char*>(profileHeaders.data()), profileHeaders.size() * sizeof(ProfileDataInfo))) {
+    LOG(ERROR) << "SaveProfile  failed to write ProfileDataInfo for " << path << ", " << strerror(errno);
+    res = false;
+    goto END;
+  }
+  // write profile date
+  if (!out.write(reinterpret_cast<char*>(profileData.data()), profileData.size())) {
+    LOG(ERROR) << "SaveProfile  failed to write ProfileData for " << path << ", " << strerror(errno);
+    res = false;
+    goto END;
+  }
+  GenStrData(strData);
+  // write strTab
+  if (!out.write(reinterpret_cast<char*>(strData.data()), strData.size())) {
+    LOG(ERROR) << "SaveProfile  failed to write strData for " << path << ", " << strerror(errno);
+    res = false;
+    goto END;
+  }
+
+END:
+  LOG(INFO) << "SaveProfile res=" << res;
+  if (!res && removeIfFailed) {
+    LOG(INFO) << "SaveProfile to remove ";
+    RemoveProfile(); // In case of more exceptions, from here to re-save the cache.
+  }
+  uint64_t saveProfileEnd = timeutils::NanoSeconds();
+  uint64_t saveProfileCost = saveProfileEnd - processProfileEnd;
+  LOG(INFO) << "Total save Profile time: " << Pretty(saveProfileCost / nsPerUs) << "us" << maple::endl;
+}
+
+void ProfileWriter::WriteToFile() {
+  Init();
+  ProcessProfData();
+  if (!profileDataNum) {
+    LOG(INFO) << "dump profile no data for save" << maple::endl;
+    return ;
+  }
+  WriteFormatDataToFile();
+}
+
+extern "C" void MRT_SaveProfile(const std::string &path, bool isSystemServer) {
+  ProfileWriter profileWriter(path, isSystemServer);
+  profileWriter.WriteToFile();
+}
+
+void MCC_SaveProfile() {
+  LOG(INFO) << "SaveProfile starting...";
+  std::string saveName = "/data/anr/maple_all.prof";
+  MRT_SaveProfile(saveName, false);
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_reflection_class.cpp b/src/mrt/maplert/src/mrt_reflection_class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dba6bc5eb7d6a2a2841d7f749d27ca576488ca08
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_reflection_class.cpp
@@ -0,0 +1,1593 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_reflection_class.h"
+#include <set>
+#include <list>
+#include "libs.h"
+#include "collector/cp_generator.h"
+#include "itab_util.h"
+#include "utils/name_utils.h"
+#include "mrt_class_api.h"
+#include "mrt_reflection_api.h"
+#include "mclass_inline.h"
+#include "mstring_inline.h"
+#include "fieldmeta_inline.h"
+
+using namespace maple;
+
+namespace maplert {
+using namespace annoconstant;
+
+// This method is only used in cycle pattern load and all patterns are predefined
+// Or saved before reboot
+bool MRT_ClassSetGctib(jclass cls, char *newBuffer, jint offset) {
+  MClass *klass = MClass::JniCastNonNull(cls);
+  GCTibGCInfo *gctibInfo = reinterpret_cast<struct GCTibGCInfo*>(klass->GetGctib());
+  DCHECK(gctibInfo != nullptr) << "Cyclepattern: gctib is null" << maple::endl;
+  DCHECK(newBuffer != nullptr) << "Cyclepattern: newBuffer is null" << maple::endl;
+  size_t gctibSize = sizeof(GCTibGCInfo) + (gctibInfo->nBitmapWords * kDWordBytes);
+  int32_t tempSize = static_cast<int32_t>(gctibSize) + offset;
+  constexpr int32_t kMaxSize = 64 * 1024 * 1024; // 64M
+  if (tempSize <= 0 || tempSize > kMaxSize) {
+    return false;
+  }
+  char *newAddress = static_cast<char*>(malloc(tempSize));
+  if (newAddress == nullptr) {
+    LOG(ERROR) << "MRT_ClassSetGctib malloc error" << maple::endl;
+    return false;
+  }
+  // set header and cyclepattern
+  errno_t returnValueOfMemcpyS1 = memcpy_s(newAddress, gctibSize, gctibInfo, gctibSize);
+  errno_t returnValueOfMemcpyS2 = memcpy_s(newAddress + gctibSize, offset, newBuffer, offset);
+  if (returnValueOfMemcpyS1 != EOK || returnValueOfMemcpyS2 != EOK) {
+    free(newAddress);
+    return false;
+  }
+  uint32_t maxRC = 0;
+  uint32_t minRC = 0;
+  bool valid = ClassCycleManager::GetRCThreshold(maxRC, minRC, newBuffer);
+  if (valid == false) {
+    LOG(ERROR) << "Cyclepattern: invalid min/max rc threshold " << maple::endl;
+    free(newAddress);
+    return false;
+  }
+  auto newGctib = reinterpret_cast<GCTibGCInfo*>(newAddress);
+  newGctib->headerProto = SetCycleMaxRC(gctibInfo->headerProto, maxRC) | SetCycleMinRC(gctibInfo->headerProto, minRC) |
+                          maplert::kCyclePatternBit;
+  LOG2FILE(kLogtypeCycle) << klass->GetName() << " max min: " << maxRC << " " << minRC << std::hex <<
+      " " << newGctib->headerProto << std::dec << std::endl;
+  if (!ClassCycleManager::CheckValidPattern(klass, newAddress)) {
+    LOG2FILE(kLogtypeCycle) << "cycle_check: verify fail " << klass->GetName() << std::endl;
+    free(newAddress);
+    return false;
+  }
+  klass->SetGctib(reinterpret_cast<uintptr_t>(newAddress));
+  if (ClassCycleManager::HasDynamicLoadPattern(klass)) {
+    free(gctibInfo);
+  } else {
+    ClassCycleManager::AddDynamicLoadPattern(klass, true);
+  }
+  return true;
+}
+
+// interface to access frequently used class-es
+jclass MRT_ReflectGetObjectClass(jobject mObj) {
+  MObject *obj = MObject::JniCastNonNull(mObj);
+  return obj->GetClass()->AsJclass();
+}
+
+jclass MRT_ReflectClassForCharName(const char *className, bool init, jobject classLoader, bool internalName) {
+  DCHECK(className != nullptr);
+  std::string descriptor = internalName ? string(className) : nameutils::DotNameToSlash(className);
+  MClass *klass = MClass::JniCastNonNull(MRT_GetClassByClassLoader(classLoader, descriptor));
+  if (init && (klass != nullptr)) {
+    bool ret = klass->InitClassIfNeeded();
+    if (ret) {
+      LOG(ERROR) << "MRT_TryInitClass return fail" << maple::endl;
+    }
+  }
+  if (klass != nullptr) {
+    return klass->AsJclass();
+  }
+  return nullptr;
+}
+
+bool MRT_ClassIsSuperClassValid(jclass clazz) {
+  MClass *cls = MClass::JniCast(clazz);
+  if (UNLIKELY(cls == nullptr)) {
+    return false;
+  }
+  if (UNLIKELY(cls->IsInterface())) {
+    return true;
+  }
+  if (UNLIKELY(cls->IsPrimitiveClass())) {
+    return true;
+  }
+  if (UNLIKELY(cls->IsArrayClass())) {
+    return true;
+  }
+
+  while (cls != WellKnown::GetMClassObject()) {
+    uint32_t numOfSuperClass = cls->GetNumOfSuperClasses();
+    if (UNLIKELY(numOfSuperClass == 0)) {
+      return true;
+    }
+    MClass **superArray = cls->GetSuperClassArray();
+    if (UNLIKELY(superArray == nullptr)) {
+      LOG(WARNING) << "\"" << cls->GetName() << "\"'s superclass array should not be null." << maple::endl;
+      return false;
+    }
+    for (uint32_t i = 0; i < numOfSuperClass; ++i) {
+      ClassMetadata *tempSuper = reinterpret_cast<ClassMetadata*>(superArray[i]);
+      MClass *super = reinterpret_cast<MClass*>(LinkerAPI::Instance().GetSuperClass(&tempSuper));
+      if (UNLIKELY(super == nullptr)) {
+        LOG(WARNING) << "\"" << cls->GetName() << "\"'s superclass[" << i << "] should not be null." <<
+            maple::endl;
+        return false;
+      }
+    }
+    cls = superArray[0];
+  }
+  return true;
+}
+
+bool ReflectClassIsDeclaredAnnotationPresent(const MClass &classObj, const MObject *annoObj) {
+  string annoStr = classObj.GetAnnotation();
+  CHECK(annoObj != nullptr);
+  char *annotationTypeName = annoObj->AsMClass()->GetName();
+  if (annoStr.empty() || annotationTypeName == nullptr) {
+    return false;
+  }
+  return AnnotationUtil::GetIsAnnoPresent(annoStr, annotationTypeName,
+                                          reinterpret_cast<CacheValueType>(const_cast<MClass*>(&classObj)),
+                                          annoObj->AsMClass(), kClassAnnoPresent);
+}
+
+MObject *ReflectClassGetDeclaredAnnotation(const MClass &classObj, const MClass *annoClass) {
+  if (annoClass == nullptr) {
+    MRT_ThrowNewException("java/lang/NullPointerException", nullptr);
+    return nullptr;
+  }
+  if (classObj.IsProxy()) {
+    return nullptr;
+  }
+  string annoStr = classObj.GetAnnotation();
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), const_cast<MClass*>(&classObj));
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  MObject *ret = parser->AllocAnnoObject(&const_cast<MClass&>(classObj), const_cast<MClass*>(annoClass));
+  return ret;
+}
+
+jobject MRT_ReflectClassGetDeclaredAnnotations(jclass cls) {
+  MClass *classObj = MClass::JniCastNonNull(cls);
+  string annoStr = classObj->GetAnnotation();
+  CacheValueType placeHolder = nullptr;
+  if (annoStr.empty() || !AnnoParser::HasAnnoMember(annoStr) ||
+      AnnotationUtil::GetCache(kHasNoDeclaredAnno, classObj, placeHolder)) {
+    MArray *nullArray = MArray::NewObjectArray(0, *WellKnown::GetMClassAAnnotation());
+    return nullArray->AsJobject();
+  }
+  VLOG(reflect) << "Enter MRT_ReflectClassGetDeclaredAnnotations, annoStr: " << annoStr << maple::endl;
+  return AnnotationUtil::GetDeclaredAnnotations(annoStr, classObj)->AsJobject();
+}
+
+MObject *ReflectClassGetAnnotation(const MClass &klass, const MClass *annotationType) {
+  DCHECK(annotationType != nullptr) << "ReflectClassGetAnnotation: annotationType nullptr !" << maple::endl;
+  // NEED: check annotationType for null
+  MObject *anno = ReflectClassGetDeclaredAnnotation(klass, annotationType);
+  if (anno != nullptr) {
+    return anno;
+  }
+
+  if (AnnotationUtil::HasDeclaredAnnotation(const_cast<MClass*>(annotationType), kAnnotationInherited)) {
+    // then annotations from super class-chain
+    MClass *superKlass = klass.GetSuperClass();
+    for (; superKlass != nullptr; superKlass = superKlass->GetSuperClass()) {
+      anno = ReflectClassGetDeclaredAnnotation(*superKlass, annotationType);
+      if (anno != nullptr) {
+        return anno;
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+MObject *ReflectClassGetClasses(const MClass &classObj) {
+  set<MClass*> metaList;
+  AnnotationUtil::GetDeclaredClasses(const_cast<MClass*>(&classObj), metaList);
+  MClass *superCl = classObj.GetSuperClass();
+  while (superCl != nullptr) {
+    AnnotationUtil::GetDeclaredClasses(superCl, metaList);
+    superCl = superCl->GetSuperClass();
+  }
+  auto it = metaList.begin();
+  while (it != metaList.end()) {
+    if (!(*it)->IsPublic()) {
+      it = metaList.erase(it);
+    } else {
+      ++it;
+    }
+  }
+  uint32_t size = static_cast<uint32_t>(metaList.size());
+  MArray *jarray = MArray::NewObjectArray(size, *WellKnown::GetMClassAClass());
+  it = metaList.begin();
+  for (uint32_t i = 0; i < size; ++i, ++it) {
+    jarray->SetObjectElementNoRc(i, *it);
+  }
+  return jarray;
+}
+
+jobjectArray MRT_ReflectClassGetDeclaredClasses(jclass cls) {
+  MClass *classObj = MClass::JniCastNonNull(cls);
+  set<MClass*> *metalist = reinterpret_cast<set<MClass*>*>(AnnotationUtil::Get(kDeclaredClasses, classObj));
+
+  uint32_t arrSize = static_cast<uint32_t>(metalist->size());
+  MArray *arrayObj = MArray::NewObjectArray(arrSize, *WellKnown::GetMClassAClass());
+  auto it = metalist->begin();
+  for (uint32_t i = 0; i < arrSize; ++i, ++it) {
+    arrayObj->SetObjectElementOffHeap(i, *it);
+  }
+  return arrayObj->AsJobjectArray();
+}
+
+MObject *ReflectClassGetInnerClassName(const MClass &classObj) {
+  string annoStr = classObj.GetAnnotation();
+  if (annoStr.empty()) {
+    return nullptr;
+  }
+  VLOG(reflect) << "Enter __MRT_Reflect_Class_getInnerClassName, annoStr: " << annoStr << maple::endl;
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), const_cast<MClass*>(&classObj));
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  int32_t loc = parser->Find(parser->GetInnerClassStr());
+  if (loc == kNPos) {
+    return nullptr;
+  }
+
+  constexpr int kSteps = 4; // jump to InnerClass value
+  parser->NextItem(kSteps);
+  std::string retArr;
+  if (parser->ParseNum(kValueInt) == kValueNull) {
+    retArr = "NULL";
+  } else {
+    retArr = parser->ParseStr(kDefParseStrType);
+  }
+  MString *res = MString::InternUtf(retArr);
+  return res;
+}
+
+// the following API get java/lang/reflect/Field Object, Java heap Object
+// implement API for java/lang/Class Native
+static void ThrowNoSuchFieldException(const MClass &classObj, const MString &fieldName) {
+  std::ostringstream msg;
+  std::string temp;
+  classObj.GetDescriptor(temp);
+  std::string fieldCharName = fieldName.GetChars();
+  msg << "No field " << fieldCharName << " in class " << temp;
+  MRT_ThrowNewException("java/lang/NoSuchFieldException", msg.str().c_str());
+}
+
+MObject *ReflectClassGetField(const MClass &classObj, const MString *fieldName) {
+  if (UNLIKELY(fieldName == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "name == null");
+    return nullptr;
+  }
+
+  FieldMeta *field = classObj.GetField(fieldName, true);
+  MField *mField = nullptr;
+  if (field != nullptr) {
+    mField = MField::NewMFieldObject(*field);
+  } else {
+    ThrowNoSuchFieldException(classObj, *fieldName);
+  }
+  return mField;
+}
+
+MObject *ReflectClassGetPublicFieldRecursive(const MClass &classObj, const MString *fieldName) {
+  if (UNLIKELY(fieldName == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "name == null");
+    return nullptr;
+  }
+
+  FieldMeta *field = classObj.GetField(fieldName, true);
+  MField *mField = nullptr;
+  if (field != nullptr) {
+    mField = MField::NewMFieldObject(*field);
+  }
+  return mField;
+}
+
+MObject *ReflectClassGetDeclaredFields(const MClass &classObj) {
+  ScopedHandles sHandles;
+  uint32_t numOfField = classObj.GetNumOfFields();
+  FieldMeta *fields = classObj.GetFieldMetas();
+  ObjHandle<MArray> fieldArray(MArray::NewObjectArray(numOfField, *WellKnown::GetMClassAField()));
+  for (uint32_t i = 0; i < numOfField; ++i) {
+    FieldMeta *field = fields + i;
+    MField *mField = MField::NewMFieldObject(*field);
+    if (UNLIKELY(mField == nullptr)) {
+      return nullptr;
+    }
+    fieldArray->SetObjectElementNoRc(i, mField);
+  }
+  return fieldArray.ReturnObj();
+}
+
+MObject *ReflectClassGetDeclaredField(const MClass &classObj, const MString *fieldName) {
+  if (UNLIKELY((fieldName) == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "name == null");
+    return nullptr;
+  }
+  if (&classObj == WellKnown::GetMClassString() && fieldName->Cmp("value")) {
+    // We log the error for this specific case, as the user might just swallow the exception.
+    // This helps diagnose crashes when applications rely on the String#value field being
+    // there.
+    // Also print on the error stream to test it through run-test.
+    std::string message("The String#value field is not present on Android versions >= 6.0");
+    LOG(ERROR) << message << maple::endl;
+    std::cerr << message << std::endl;
+  }
+
+  FieldMeta *fieldMeta = classObj.GetDeclaredField(fieldName);
+  if ((fieldMeta != nullptr) && (&classObj == WellKnown::GetMClassClass()) && !fieldMeta->IsStatic()) {
+    LOG(ERROR) << "The Class instance field is not present on maple" << maple::endl;
+    fieldMeta = nullptr;
+  }
+  if (fieldMeta == nullptr) {
+    ThrowNoSuchFieldException(classObj, *fieldName);
+    return nullptr;
+  }
+
+  MField *mField = MField::NewMFieldObject(*fieldMeta);
+  return mField;
+}
+
+static void GetDeclaredFields(const MClass &classObj, std::vector<FieldMeta*> &fieldsVector, bool publicOnly) {
+  uint32_t numOfField = classObj.GetNumOfFields();
+  FieldMeta *fields = classObj.GetFieldMetas();
+  for (uint32_t i = 0; i < numOfField; ++i) {
+    FieldMeta *field = fields + i;
+    if (!publicOnly || field->IsPublic()) {
+      fieldsVector.push_back(field);
+    }
+  }
+}
+
+static MObject *GetFieldsObjectArray(std::vector<FieldMeta*> fieldsVector) {
+  ScopedHandles sHandles;
+  uint32_t numOfFields = static_cast<uint32_t>(fieldsVector.size());
+  uint32_t currentIndex = 0;
+  ObjHandle<MArray> fieldArray(MArray::NewObjectArray(numOfFields, *WellKnown::GetMClassAField()));
+  for (auto fieldMeta : fieldsVector) {
+    MField *mField = MField::NewMFieldObject(*fieldMeta);
+    if (UNLIKELY(mField == nullptr)) {
+      return nullptr;
+    }
+    fieldArray->SetObjectElementNoRc(currentIndex++, mField);
+  }
+  return fieldArray.ReturnObj();
+}
+
+MObject *ReflectClassGetDeclaredFieldsUnchecked(const MClass &classObj, bool publicOnly) {
+  std::vector<FieldMeta*> fieldsVector;
+  GetDeclaredFields(classObj, fieldsVector, publicOnly);
+  return GetFieldsObjectArray(fieldsVector);
+}
+
+static void GetPublicFieldsRecursive(const MClass &classObj, std::vector<FieldMeta*> &fieldsVector) {
+  for (const MClass *super = &classObj; super != nullptr; super = super->GetSuperClass()) {
+    GetDeclaredFields(*super, fieldsVector, true);
+  }
+  // search iftable which has a flattened and uniqued list of interfaces
+  std::vector<MClass*> interfaceList;
+  classObj.GetInterfaces(interfaceList);
+  for (auto itfInfo : interfaceList) {
+    GetDeclaredFields(*itfInfo, fieldsVector, true);
+  }
+}
+
+MObject *ReflectClassGetFields(const MClass &classObj) {
+  std::vector<FieldMeta*> fieldsVector;
+  GetPublicFieldsRecursive(classObj, fieldsVector);
+  return GetFieldsObjectArray(fieldsVector);
+}
+
+void ReflectClassGetPublicFieldsRecursive(const MClass &classObj, MObject *listObject) {
+  std::vector<FieldMeta*> fieldsVector;
+  GetPublicFieldsRecursive(classObj, fieldsVector);
+  MClass *collectionsClass = MClass::GetClassFromDescriptor(nullptr, "Ljava/util/ArrayList;");
+  MethodMeta *addMethod = collectionsClass->GetMethod("add", "(Ljava/lang/Object;)Z");
+  if (UNLIKELY(addMethod == nullptr)) {
+    return;
+  }
+
+  ScopedHandles sHandles;
+  for (auto field : fieldsVector) {
+    ObjHandle<MObject> fieldObject(MField::NewMFieldObject(*field));
+    if (UNLIKELY(fieldObject() == nullptr)) {
+      return;
+    }
+
+    jvalue arg[1];
+    arg[0].l = fieldObject.AsJObj();
+    bool isSuccess = addMethod->Invoke<bool, calljavastubconst::kJvalue>(listObject, arg);
+    if (isSuccess == false) {
+      return;
+    }
+  }
+}
+
+jobject MRT_ReflectClassGetDeclaredFields(jclass classObj, jboolean publicOnly) {
+  MClass *klass = MClass::JniCastNonNull(classObj);
+  MObject *ret = ReflectClassGetDeclaredFieldsUnchecked(*klass, publicOnly == JNI_TRUE);
+  return ret->AsJobject();
+}
+
+MObject *ReflectClassGetPublicDeclaredFields(const MClass &classObj) {
+  return ReflectClassGetDeclaredFieldsUnchecked(classObj, true);
+}
+
+// the following API get FieldMeta
+uint32_t MRT_ReflectClassGetNumofFields(jclass cls) {
+  MClass *mClassObj = MClass::JniCastNonNull(cls);
+  return mClassObj->GetNumOfFields();
+}
+
+jfieldID MRT_ReflectClassGetFieldsPtr(jclass classObj) {
+  MClass *mClassObj = MClass::JniCastNonNull(classObj);
+  FieldMeta *fields = mClassObj->GetFieldMetas();
+  return fields->AsJfieldID();
+}
+
+jfieldID MRT_ReflectClassGetIndexField(jfieldID head, int i) {
+  FieldMeta *fieldMeta = FieldMeta::JniCast(head) + i;
+  return fieldMeta->AsJfieldID();
+}
+
+// find fieldMeta recursively in classObj
+jfieldID MRT_ReflectGetCharField(jclass classObj, const char *fieldName, const char *fieldType) {
+  MClass *mClassObj = MClass::JniCastNonNull(classObj);
+  FieldMeta *retObj = mClassObj->GetField(fieldName, fieldType, false);
+  return retObj->AsJfieldID();
+}
+
+jfieldID MRT_ReflectGetStaticCharField(jclass classObj, const char *fieldName) {
+  MClass *mClassObj = MClass::JniCastNonNull(classObj);
+  FieldMeta *field = mClassObj->GetField(fieldName, nullptr, false);
+  if (field != nullptr && field->IsStatic()) {
+    return field->AsJfieldID();
+  }
+  return nullptr;
+}
+
+// find fieldMeta declared *just* in classObj
+MObject *ReflectClassGetDeclaredMethodInternal(const MClass &classObj, const MString *methodName,
+                                               const MArray *arrayClass) {
+  if (UNLIKELY((methodName) == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "name == null");
+    return nullptr;
+  }
+  MethodMeta *methodMeta = classObj.GetDeclaredMethod(methodName, arrayClass);
+  if (methodMeta == nullptr) {
+    return nullptr;
+  }
+  MMethod *methodObject = MMethod::NewMMethodObject(*methodMeta);
+  return methodObject;
+}
+
+static MethodMeta *FindInterfaceMethod(const MClass &classObj, const MString *methodName, const MArray *arrayClass) {
+  std::vector<MClass*> interfaceVector;
+  MethodMeta *resultMethod = nullptr;
+  classObj.GetInterfaces(interfaceVector);
+  for (auto interface : interfaceVector) {
+    MethodMeta *method = interface->GetDeclaredMethod(methodName, arrayClass);
+    if ((method != nullptr) && (method->IsPublic())) {
+      if (resultMethod == nullptr) {
+        resultMethod = method;
+      } else if (resultMethod->GetDeclaringClass()->IsAssignableFrom(*method->GetDeclaringClass())) {
+        resultMethod = method;
+      }
+    }
+  }
+  return resultMethod;
+}
+
+MObject *ReflectClassFindInterfaceMethod(const MClass &classObj, const MString *methodName, const MArray *arrayClass) {
+  if (UNLIKELY((methodName) == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "name == null");
+    return nullptr;
+  }
+  MethodMeta *methodMeta = FindInterfaceMethod(classObj, methodName, arrayClass);
+  if (methodMeta == nullptr) {
+    return nullptr;
+  }
+  MMethod *methodObject = MMethod::NewMMethodObject(*methodMeta);
+  return methodObject;
+}
+
+static MethodMeta *GetPublicMethodRecursive(const MClass &classObj, const MString *methodName,
+                                            const MArray *arrayClass) {
+  MethodMeta *method = nullptr;
+  for (const MClass *superClass = &classObj; superClass != nullptr; superClass = superClass->GetSuperClass()) {
+    method = superClass->GetDeclaredMethod(methodName, arrayClass);
+    if ((method != nullptr) && (method->IsPublic())) {
+      return method;
+    }
+  }
+  method = FindInterfaceMethod(classObj, methodName, arrayClass);
+  return method;
+}
+
+static void ThrowNoSuchMethodException(const MClass &classObj, const MString *methodName,
+                                       const MArray *arrayClass, bool isInit = false) {
+  std::ostringstream msg;
+  std::string className;
+  classObj.GetBinaryName(className);
+  if (isInit) {
+    msg << className << "." << "<init>" << " [";
+  } else if (methodName != nullptr) {
+    std::string methodCharName = methodName->GetChars();
+    msg << className << "." << methodCharName << " [";
+  }
+  if (arrayClass != nullptr) {
+    uint32_t len = arrayClass->GetLength();
+    std::string name;
+    for (uint32_t i = 0; i < len; ++i) {
+      MClass *elementObj = arrayClass->GetObjectElementNoRc(i)->AsMClass();
+      name.clear();
+      elementObj->GetBinaryName(name);
+      if (elementObj->IsInterface()) {
+        msg << "interface ";
+      } else if (!elementObj->IsPrimitiveClass()) {
+        msg << "class ";
+      }
+      msg << name;
+      if (i != (len - 1)) {
+        msg << ", ";
+      }
+    }
+  }
+  msg << "]";
+  MRT_ThrowNewException("java/lang/NoSuchMethodException", msg.str().c_str());
+}
+
+static MethodMeta *GetMethod(const MClass &classObj, const MString *methodName,
+                             const MArray *arrayClass, bool recursive) {
+  if (UNLIKELY((methodName) == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "name == null");
+    return nullptr;
+  }
+  if (UNLIKELY((arrayClass != nullptr) && arrayClass->HasNullElement())) {
+    MRT_ThrowNewException("java/lang/NoSuchMethodException", "parameter type is null");
+    return nullptr;
+  }
+
+  MethodMeta *method = recursive ? GetPublicMethodRecursive(classObj, methodName, arrayClass) :
+      classObj.GetDeclaredMethod(methodName, arrayClass);
+  if (method != nullptr) {
+    return method;
+  }
+  ThrowNoSuchMethodException(classObj, methodName, arrayClass);
+  return nullptr;
+}
+
+MObject *ReflectClassGetMethod(const MClass &classObj, const MString *methodName, const MArray *arrayClass) {
+  MethodMeta *method = GetMethod(classObj, methodName, arrayClass, true);
+  if (method == nullptr) {
+    return nullptr;
+  }
+  MMethod *methodObject = MMethod::NewMMethodObject(*method);
+  return methodObject;
+}
+
+MObject *ReflectClassGetDeclaredMethod(const MClass &classObj, const MString *methodName, const MArray *arrayClass) {
+  MethodMeta *methodMeta = GetMethod(classObj, methodName, arrayClass, false);
+  if (methodMeta == nullptr) {
+    return nullptr;
+  }
+  MMethod *methodObject = MMethod::NewMMethodObject(*methodMeta);
+  return methodObject;
+}
+
+MObject *ReflectClassGetDeclaredMethods(const MClass &classObj) {
+  MObject *methodArray = ReflectClassGetDeclaredMethodsUnchecked(classObj, false);
+  return methodArray;
+}
+
+MObject *ReflectClassGetMethods(const MClass &classObj) {
+  std::vector<MethodMeta*> methodsVector;
+  for (const MClass *superClass = &classObj; superClass != nullptr; superClass = superClass->GetSuperClass()) {
+    superClass->GetDeclaredMethods(methodsVector, true);
+  }
+  std::vector<MClass*> interfaceList;
+  classObj.GetInterfaces(interfaceList);
+  for (auto it = interfaceList.begin(); it != interfaceList.end(); ++it) {
+    MClass *interface = *it;
+    interface->GetDeclaredMethods(methodsVector, true);
+  }
+
+  std::vector<MethodMeta*> methodsUnique;
+  for (auto mth : methodsVector) {
+    char *methodName0 = mth->GetName();
+    char *sigName0 = mth->GetSignature();
+    auto itMethod = methodsUnique.begin();
+    for (; itMethod != methodsUnique.end(); ++itMethod) {
+      char *methodName1 = (*itMethod)->GetName();
+      char *sigName1 = (*itMethod)->GetSignature();
+      if (!strcmp(methodName0, methodName1) && !strcmp(sigName0, sigName1)) {
+        break;
+      }
+    }
+    if (itMethod == methodsUnique.end()) {
+      methodsUnique.push_back(mth);
+    }
+  }
+  ScopedHandles sHandles;
+  uint32_t numOfMethod = static_cast<uint32_t>(methodsUnique.size());
+  ObjHandle<MArray> methodArray(MArray::NewObjectArray(numOfMethod, *WellKnown::GetMClassAMethod()));
+  uint32_t currentIndex = 0;
+  for (auto methodMeta : methodsUnique) {
+    MMethod *methodObject = MMethod::NewMMethodObject(*methodMeta);
+    if (UNLIKELY(methodObject == nullptr)) {
+      return nullptr;
+    }
+    methodArray->SetObjectElementNoRc(currentIndex++, methodObject);
+  }
+  return methodArray.ReturnObj();
+}
+
+void ReflectClassGetPublicMethodsInternal(const MClass &classObj, MObject *listObject) {
+  std::vector<MethodMeta*> methodsVector;
+  for (const MClass *superClass = &classObj; superClass != nullptr; superClass = superClass->GetSuperClass()) {
+    superClass->GetDeclaredMethods(methodsVector, true);
+  }
+  std::vector<MClass*> interfaceList;
+  classObj.GetInterfaces(interfaceList);
+  for (auto interface : interfaceList) {
+    interface->GetDeclaredMethods(methodsVector, true);
+  }
+  MClass *collectionsClass = MClass::GetClassFromDescriptor(nullptr, "Ljava/util/ArrayList;");
+  MethodMeta *addMethod = collectionsClass->GetMethod("add", "(Ljava/lang/Object;)Z");
+  if (UNLIKELY(addMethod == nullptr)) {
+    return;
+  }
+  ScopedHandles sHandles;
+  for (auto m : methodsVector) {
+    ObjHandle<MObject> methodObject(MMethod::NewMMethodObject(*m));
+    if (UNLIKELY(methodObject() == nullptr)) {
+      return;
+    }
+    jvalue arg[1];
+    arg[0].l = methodObject.AsJObj();
+    bool isSuccess = addMethod->Invoke<bool, calljavastubconst::kJvalue>(listObject, arg);
+    if (isSuccess == false) {
+      return;
+    }
+  }
+}
+
+MObject *ReflectClassGetDeclaredMethodsUnchecked(const MClass &classObj, bool publicOnly) {
+  ScopedHandles sHandles;
+  std::vector<MethodMeta*> methodsVector;
+  classObj.GetDeclaredMethods(methodsVector, publicOnly);
+  uint32_t numOfMethod = static_cast<uint32_t>(methodsVector.size());
+  ObjHandle<MArray> methodArray(MArray::NewObjectArray(numOfMethod, *WellKnown::GetMClassAMethod()));
+  uint32_t currentIndex = 0;
+  for (auto methodMeta : methodsVector) {
+    MMethod *methodObject = MMethod::NewMMethodObject(*methodMeta);
+    if (UNLIKELY(methodObject == nullptr)) {
+      return nullptr;
+    }
+    methodArray->SetObjectElementNoRc(currentIndex++, methodObject);
+  }
+  return methodArray.ReturnObj();
+}
+
+jobject MRT_ReflectClassGetDeclaredMethods(jclass classObj, jboolean publicOnly) {
+  MClass *klass = MClass::JniCastNonNull(classObj);
+  MObject *m = ReflectClassGetDeclaredMethodsUnchecked(*klass, publicOnly == JNI_TRUE);
+  return m->AsJobject();
+}
+
+MObject *ReflectClassGetInstanceMethod(const MClass &classObj, const MString *methodName, const MArray *arrayClass) {
+  if (UNLIKELY((methodName) == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "name == null");
+    return nullptr;
+  }
+  MethodMeta *method = nullptr;
+  for (const MClass *superClass = &classObj; superClass != nullptr; superClass = superClass->GetSuperClass()) {
+    method = superClass->GetDeclaredMethod(methodName, arrayClass);
+    if ((method != nullptr) && (!method->IsStatic()) && (!method->IsConstructor())) {
+      MMethod *methodObject = MMethod::NewMMethodObject(*method);
+      return methodObject;
+    }
+  }
+  method = FindInterfaceMethod(classObj, methodName, arrayClass);
+  if (method == nullptr) {
+    return nullptr;
+  }
+  MMethod *methodObject = MMethod::NewMMethodObject(*method);
+  return methodObject;
+}
+
+MObject *ReflectClassGetDeclaredConstructorInternal(const MClass &classObj, const MArray *arrayClass) {
+  MethodMeta *constructor = classObj.GetDeclaredConstructor(arrayClass);
+  if (constructor == nullptr) {
+    return nullptr;
+  }
+  MMethod *methodObject = MMethod::NewMMethodObject(*constructor);
+  return methodObject;
+}
+
+MObject *ReflectClassGetDeclaredConstructor(const MClass &classObj, const MArray *arrayClass) {
+  if (UNLIKELY((arrayClass != nullptr) && arrayClass->HasNullElement())) {
+    MRT_ThrowNewException("java/lang/NoSuchMethodException", "parameter type is null");
+    return nullptr;
+  }
+
+  MethodMeta *method = classObj.GetDeclaredConstructor(arrayClass);
+  if (method != nullptr) {
+    MMethod *methodObject = MMethod::NewMMethodObject(*method);
+    return methodObject;
+  }
+
+  ThrowNoSuchMethodException(classObj, nullptr, arrayClass, true);
+  return nullptr;
+}
+
+static MObject *GetDeclaredConstructors(const MClass &classObj, bool publicOnly) {
+  std::vector<MethodMeta*> constructorsVector;
+  uint32_t numOfMethod = classObj.GetNumOfMethods();
+  MethodMeta *methodS = classObj.GetMethodMetas();
+  for (uint32_t i = 0; i < numOfMethod; ++i) {
+    MethodMeta *method = &methodS[i];
+    if (method->IsConstructor() && !method->IsStatic()) {
+      if (!publicOnly || (method->IsPublic())) {
+        constructorsVector.push_back(method);
+      }
+    }
+  }
+  ScopedHandles sHandles;
+  numOfMethod = static_cast<uint32_t>(constructorsVector.size());
+  ObjHandle<MArray> constructorArray(MArray::NewObjectArray(numOfMethod, *WellKnown::GetMClassAConstructor()));
+  uint32_t currentIndex = 0;
+  for (auto methodMeta : constructorsVector) {
+    MMethod *constructorObject = MMethod::NewMMethodObject(*methodMeta);
+    if (UNLIKELY(constructorObject == nullptr)) {
+      return nullptr;
+    }
+    constructorArray->SetObjectElementNoRc(currentIndex++, constructorObject);
+  }
+  return constructorArray.ReturnObj();
+}
+
+MObject *ReflectClassGetDeclaredConstructorsInternal(const MClass &classObj, bool publicOnly) {
+  MObject *constructorArray = GetDeclaredConstructors(classObj, publicOnly);
+  return constructorArray;
+}
+
+MObject *ReflectClassGetDeclaredConstructors(const MClass &classObj) {
+  MObject *constructorArray = GetDeclaredConstructors(classObj, false);
+  return constructorArray;
+}
+
+jobject MRT_ReflectClassGetDeclaredConstructors(jclass classObj, jboolean publicOnly) {
+  MClass *mClassObj = MClass::JniCastNonNull(classObj);
+  MObject *ret = GetDeclaredConstructors(*mClassObj, publicOnly == JNI_TRUE);
+  return ret->AsJobject();
+}
+
+MObject *ReflectClassGetConstructor(const MClass &classObj, const MArray *arrayClass) {
+  if (UNLIKELY((arrayClass != nullptr) && arrayClass->HasNullElement())) {
+    MRT_ThrowNewException("java/lang/NoSuchMethodException", "parameter type is null");
+    return nullptr;
+  }
+
+  MethodMeta *constructor = classObj.GetDeclaredConstructor(arrayClass);
+  if ((constructor != nullptr) && (constructor->IsPublic())) {
+    MMethod *constructorObject = MMethod::NewMMethodObject(*constructor);
+    return constructorObject;
+  }
+
+  ThrowNoSuchMethodException(classObj, nullptr, arrayClass, true);
+  return nullptr;
+}
+
+MObject *ReflectClassGetConstructors(const MClass &classObj) {
+  MObject *constructorArray = GetDeclaredConstructors(classObj, true);
+  return constructorArray;
+}
+
+jmethodID MRT_ReflectGetCharMethod(jclass classObj, const char *methodName, const char *signatureName) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  MethodMeta *methodMeta = mClass->GetMethod(methodName, signatureName);
+  return methodMeta->AsJmethodID();
+}
+
+jmethodID MRT_ReflectGetMethodFromMethodID(jclass clazz, jmethodID methodID, const char *signature ATTR_UNUSED) {
+  MethodMeta *methodMeta = MethodMeta::JniCastNonNull(methodID);
+  MClass *mClass = MClass::JniCastNonNull(clazz);
+  methodMeta = mClass->GetVirtualMethod(*methodMeta);
+  CHECK(methodMeta != nullptr);
+  return methodMeta->AsJmethodID();
+}
+
+jmethodID MRT_ReflectGetStaticCharMethod(jclass classObj, const char *methodName, const char *signatureName) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  MethodMeta *methodMeta = mClass->GetMethod(methodName, signatureName);
+  if (methodMeta != nullptr && (methodMeta->IsStatic())) {
+    return methodMeta->AsJmethodID();
+  }
+  return nullptr;
+}
+
+jint MRT_ReflectClassGetAccessFlags(jclass classObj) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  uint32_t mod = mClass->GetModifier();
+  return static_cast<jint>(mod & 0x7FFFFFFF);
+}
+
+jclass MRT_ReflectClassGetComponentType(jclass classObj) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  MClass *component = mClass->GetComponentClass();
+  return component->AsJclass();
+}
+
+jclass MRT_ReflectClassGetSuperClass(jclass classObj) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  MClass *supercls = mClass->GetSuperClass();
+  return supercls->AsJclass();
+}
+
+static MArray *GetInterfacesInternal(const MClass &klass) {
+  uint32_t numOfInterface = klass.GetNumOfInterface();
+  MClass *interfaceVector[numOfInterface];
+  klass.GetDirectInterfaces(interfaceVector, numOfInterface);
+  MArray *interfacesArray = MArray::NewObjectArray(numOfInterface, *WellKnown::GetMClassAClass());
+  for (uint32_t index = 0; index < numOfInterface; ++index) {
+    interfacesArray->SetObjectElementOffHeap(index, interfaceVector[index]);
+  }
+  return interfacesArray;
+}
+
+jobjectArray MRT_ReflectClassGetInterfaces(jclass classObj) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  MArray *interfacesArray = GetInterfacesInternal(*mClass);
+  return interfacesArray->AsJobjectArray();
+}
+
+MObject *ReflectClassGetInterfacesInternal(const MClass &classObj) {
+  MArray *interfacesArray = nullptr;
+  if (!classObj.IsArrayClass()) {
+    uint32_t numOfInterface = classObj.GetNumOfInterface();
+    if (numOfInterface != 0) {
+      interfacesArray = GetInterfacesInternal(classObj);
+    }
+  }
+  return interfacesArray;
+}
+
+jint MRT_ReflectClassGetModifiers(jclass classObj) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  const uint32_t kJavaFlagsMask = 0xFFFF;
+  return mClass->GetModifier() & kJavaFlagsMask;
+}
+
+jstring MRT_ReflectClassGetName(jclass classObj) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  MString *res = NewStringUtfFromPoolForClassName(*mClass);
+  return res->AsJstring();
+}
+
+MObject *ReflectClassGetSignatureAnnotation(const MClass &classObj) {
+  MObject *ret = classObj.GetSignatureAnnotation();
+  return ret;
+}
+
+MObject *ReflectClassGetEnclosingMethodNative(const MClass &classObj) {
+  MethodMeta *ret = MethodMeta::Cast(AnnotationUtil::Get(kEnclosingMethod, const_cast<MClass*>(&classObj)));
+  if ((ret != nullptr) && (!ret->IsConstructor())) {
+    MMethod *methodObj = MMethod::NewMMethodObject(*ret);
+    return methodObj;
+  }
+  return nullptr;
+}
+
+MObject *ReflectClassGetEnclosingConstructorNative(const MClass &classObj) {
+  MethodMeta *mthMeta = MethodMeta::Cast(AnnotationUtil::Get(kEnclosingMethod, const_cast<MClass*>(&classObj)));
+  if ((mthMeta != nullptr) && (mthMeta->IsConstructor())) {
+    MMethod *methodObj = MMethod::NewMMethodObject(*mthMeta);
+    return methodObj;
+  }
+  return nullptr;
+}
+
+MObject *ReflectClassGetEnclosingClass(const MClass &classObj) {
+  MObject *result = MObject::Cast<MObject>(AnnotationUtil::Get(kEnclosingClass, const_cast<MClass*>(&classObj)));
+  return result;
+}
+
+jclass MRT_ReflectClassGetDeclaringClass(jclass classObj) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  if (mClass->IsAnonymousClass() || mClass->IsProxy()) {
+    VLOG(reflect) << "Enter MRT_ReflectClassGetDeclaringClass, return NULL " << maple::endl;
+    return nullptr;
+  }
+  return MObject::Cast<MClass>(AnnotationUtil::Get(kDeclaringClass, mClass))->AsJclass();
+}
+
+bool ReflectClassIsMemberClass(const MClass &classObj) {
+  char *annotation = classObj.GetRawAnnotation();
+  bool isValid = false;
+  bool result = (annotation != nullptr) ? AnnoParser::IsMemberClass(annotation, isValid) :
+      AnnoParser::IsMemberClass("", isValid);
+  if (isValid) {
+    return result;
+  }
+  return MRT_ReflectClassGetDeclaringClass(classObj) != nullptr;
+}
+
+
+bool ReflectClassIsLocalClass(const MClass &classObj) {
+  if (classObj.IsAnonymousClass()) {
+    return false;
+  }
+  bool isValid = modifier::IsLocalClassVaild(classObj.GetModifier());
+  if (isValid) {
+    return modifier::IsLocalClass(classObj.GetModifier());
+  }
+  MObject *enclosingMethod = ReflectClassGetEnclosingMethodNative(classObj);
+  if (enclosingMethod != nullptr) {
+    MRT_DecRef(reinterpret_cast<address_t>(enclosingMethod));
+    return true;
+  }
+  MObject *enclosingConstructor = ReflectClassGetEnclosingConstructorNative(classObj);
+  if (enclosingConstructor != nullptr) {
+    MRT_DecRef(reinterpret_cast<address_t>(enclosingConstructor));
+    return true;
+  }
+  return false;
+}
+
+MObject *ReflectClassGetClassLoader(const MClass &classObj) {
+  jobject classLoader = MRT_GetClassLoader(reinterpret_cast<jclass>(&const_cast<MClass&>(classObj)));
+  if (classLoader == nullptr) {
+    classLoader = MRT_GetBootClassLoader();
+  }
+  if (classLoader != nullptr) {
+    RC_LOCAL_INC_REF(classLoader);
+  }
+  return MObject::JniCast(classLoader); // inc ref by runtime and dec ref by caller
+}
+
+static bool CheckNewInstanceAccess(const MClass &classObj) {
+  uint32_t mod = classObj.GetModifier();
+  uint32_t flag = classObj.GetFlag();
+  if (modifier::IsAbstract(mod) || modifier::IsInterface(mod) ||
+      modifier::IsArrayClass(flag) || modifier::IsPrimitiveClass(flag)) {
+    std::string classPrettyName;
+    std::ostringstream msg;
+    classObj.GetPrettyClass(classPrettyName);
+    msg << classPrettyName << " cannot be instantiated";
+    MRT_ThrowNewException("java/lang/InstantiationException", msg.str().c_str());
+    return false;
+  }
+  // check access the class.
+  if (!modifier::IsPublic(mod)) {
+    MClass *callerClass = reflection::GetCallerClass(1);
+    if (callerClass && !reflection::CanAccess(classObj, *callerClass)) {
+      std::string callerClassStr, classObjStr, msg;
+      callerClass->GetPrettyClass(callerClassStr);
+      classObj.GetPrettyClass(classObjStr);
+      msg = classObjStr + " is not accessible from " + callerClassStr;
+      MRT_ThrowNewException("java/lang/IllegalAccessException", msg.c_str());
+      return false;
+    }
+  }
+  return true;
+}
+
+MObject *ReflectClassNewInstance(const MClass &classObj) {
+  if (!CheckNewInstanceAccess(classObj)) {
+    return nullptr;
+  }
+
+  if (UNLIKELY(!classObj.InitClassIfNeeded())) {
+    return nullptr;
+  }
+
+  // find constructor, an empty argument list
+  MethodMeta *constructor = classObj.GetDefaultConstructor();
+  if (UNLIKELY(constructor == nullptr)) {
+    std::string classPrettyName;
+    std::ostringstream msg;
+    classObj.GetPrettyClass(classPrettyName);
+    msg << classPrettyName << " has no zero argument constructor";
+    MRT_ThrowNewException("java/lang/InstantiationException", msg.str().c_str());
+    return nullptr;
+  }
+
+  // Invoke the string allocator to return an empty string for the string class.
+  if (classObj.IsStringClass()) {
+    return MString::NewEmptyStringObject();
+  }
+
+  {
+    ScopedHandles sHandles;
+    ObjHandle<MObject> newInstance(MObject::NewObject(classObj));
+    // Verify that we can access the constructor.
+    if (!constructor->IsPublic()) {
+      MClass *callerClass = nullptr;
+      if (!reflection::VerifyAccess(newInstance(), &classObj, constructor->GetMod(), callerClass, 1)) {
+        std::string constructorStr, msg, callerClassStr;
+        constructor->GetPrettyName(true, constructorStr);
+        callerClass->GetPrettyClass(callerClassStr);
+        msg = constructorStr + " is not accessible from " + callerClassStr;
+        MRT_ThrowNewException("java/lang/IllegalAccessException", msg.c_str());
+        return nullptr;
+      }
+    }
+
+     // constructor no return value
+    (void)constructor->InvokeJavaMethodFast<int>(newInstance());
+    if (!MRT_HasPendingException()) {
+      return newInstance.ReturnObj();
+    }
+  }
+
+  if (UNLIKELY(MRT_HasPendingException())) {
+    MRT_CheckThrowPendingExceptionUnw();
+  }
+  return nullptr;
+}
+
+jboolean MRT_ReflectClassIsPrimitive(jclass classObj) {
+  MClass *mClassObj = MClass::JniCastNonNull(classObj);
+  return mClassObj->IsPrimitiveClass();
+}
+
+jboolean MRT_ReflectClassIsInterface(jclass classObj) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  return mClass->IsInterface();
+}
+
+jboolean MRT_ReflectClassIsArray(jclass classObj) {
+  MClass *mClass = MClass::JniCastNonNull(classObj);
+  return mClass->IsArrayClass();
+}
+
+jboolean MRT_ReflectClassIsAssignableFrom(jclass superClass, jclass subClass) {
+  MClass *mSuperClass = MClass::JniCastNonNull(superClass);
+  MClass *mSubClass = MClass::JniCastNonNull(subClass);
+  return mSuperClass->IsAssignableFrom(*mSubClass);
+}
+
+#if PLATFORM_SDK_VERSION >= 27
+MObject *ReflectClassGetPrimitiveClass(const MClass &classObj __attribute__((unused)), const MString *name) {
+  if (name == nullptr) {
+    MRT_ThrowNullPointerExceptionUnw();
+  }
+  std::string className = name->GetChars();
+  char hash = className[0] ^ ((className[1] & 0x10) << 1);
+  switch (hash) {
+    case 'i':
+      return WellKnown::GetMClassI();
+    case 'f':
+      return WellKnown::GetMClassF();
+    case 'B':
+      return WellKnown::GetMClassB();
+    case 'c':
+      return WellKnown::GetMClassC();
+    case 's':
+      return WellKnown::GetMClassS();
+    case 'l':
+      return WellKnown::GetMClassJ();
+    case 'd':
+      return WellKnown::GetMClassD();
+    case 'b':
+      return WellKnown::GetMClassZ();
+    case 'v':
+      return WellKnown::GetMClassV();
+    default:
+      MRT_ThrowNewException("java/lang/ClassNotFoundException", nullptr);
+  }
+  BUILTIN_UNREACHABLE();
+}
+#endif
+
+jboolean MRT_ReflectIsString(const jclass classObj) {
+  return MClass::JniCastNonNull(classObj)->IsStringClass();
+}
+
+jboolean MRT_ReflectIsClass(const jobject obj) {
+  return MObject::JniCastNonNull(obj)->IsClass() ? JNI_TRUE : JNI_FALSE;
+}
+
+jboolean MRT_ReflectIsInstanceOf(jobject jobj, jclass javaClass) {
+  MObject *mObj = MObject::JniCastNonNull(jobj);
+  MClass *mJavaClass = MClass::JniCastNonNull(javaClass);
+  return mObj->IsInstanceOf(*mJavaClass) ? JNI_TRUE : JNI_FALSE;
+}
+
+jint MRT_ReflectGetObjSize(const jclass classObj) {
+  return static_cast<jint>(MClass::JniCastNonNull(classObj)->GetObjectSize());
+}
+
+jint MRT_ReflectGetArrayIndexScaleForComponentType(jclass componentClassObj) {
+  MClass *classObj = MClass::JniCastNonNull(componentClassObj);
+  return classObj->IsPrimitiveClass() ? classObj->GetObjectSize() : MObject::GetReffieldSize();
+}
+
+jclass MRT_ReflectGetOrCreateArrayClassObj(jclass elementClass) {
+  MClass *elementCls = MClass::JniCastNonNull(elementClass);
+  MClass *arrayClass = maplert::WellKnown::GetCacheArrayClass(*elementCls);
+  return arrayClass->AsJclass();
+}
+
+char *MRT_ReflectGetClassCharName(const jclass javaClass) {
+  return MClass::JniCastNonNull(javaClass)->GetName();
+}
+
+jobject MRT_ReflectAllocObject(const jclass javaClass, bool isJNI) {
+  MClass *mClass = MClass::JniCastNonNull(javaClass);
+  MObject *o = MObject::NewObject(*mClass, isJNI);
+  return o->AsJobject();
+}
+
+jobject MRT_ReflectNewObjectA(const jclass javaClass, const jmethodID mid, const jvalue *args, bool isJNI) {
+  const MethodMeta *constructor = MethodMeta::JniCastNonNull(mid);
+  const MClass *klass = MClass::JniCastNonNull(javaClass);
+  MObject *obj = MObject::NewObject(*klass, *constructor, *args, isJNI);
+  if (obj == nullptr) {
+    return nullptr;
+  }
+  return obj->AsJobject();
+}
+
+#ifdef DISABLE_MCC_FAST_FUNCS
+// used in compiler, be careful if change name
+void MCC_Array_Boundary_Check(jobjectArray javaArray, jint index) {
+  if (javaArray == nullptr) {
+    MRT_ThrowNullPointerExceptionUnw();
+    return;
+  }
+  MArray *mArrayObj = MArray::JniCast(javaArray);
+  int32_t length = static_cast<int32_t>(mArrayObj->GetLength());
+  if (index < 0) {
+    MRT_ThrowArrayIndexOutOfBoundsException(length, index);
+    return;
+  } else if (index >= length) {
+    MRT_ThrowArrayIndexOutOfBoundsException(length, index);
+    return;
+  }
+}
+#endif // DISABLE_MCC_FAST_FUNCS
+
+void MCC_ThrowCastException(jclass targetClass, jobject castObj) {
+  std::ostringstream msg;
+  MClass *mTargetClass = MClass::JniCast(targetClass);
+  MObject *mCastObj = MObject::JniCast(castObj);
+  if (mCastObj == nullptr || mTargetClass == nullptr) {
+    return;
+  }
+  std::string targetClassName, objClassName;
+  mTargetClass->GetTypeName(targetClassName);
+  mCastObj->GetClass()->GetTypeName(objClassName);
+  msg << objClassName << " cannot be cast to " << targetClassName;
+  MRT_ThrowClassCastExceptionUnw(msg.str().c_str());
+}
+
+static void ReflectThrowCastException(const MClass *sourceInfo, const MObject &targetObject, int dim) {
+  std::ostringstream msg;
+  if (sourceInfo != nullptr) {
+    std::string sourceName, targerName;
+    sourceInfo->GetTypeName(sourceName);
+    while (dim--) {
+      sourceName += "[]";
+    }
+    targetObject.GetClass()->GetTypeName(targerName);
+    msg << targerName << " cannot be cast to " << sourceName;
+  }
+  MRT_ThrowClassCastExceptionUnw(msg.str().c_str());
+}
+
+void MCC_Reflect_ThrowCastException(const jclass sourceinfo, jobject targetObject, jint dim) {
+  MObject *mTargetObject = MObject::JniCast(targetObject);
+  if (mTargetObject == nullptr) {
+    return;
+  }
+  ReflectThrowCastException(MClass::JniCast(sourceinfo), *mTargetObject, dim);
+}
+
+void MCC_Reflect_Check_Arraystore(jobject arrayObject, jobject elemObject){
+  if (UNLIKELY(elemObject == nullptr || arrayObject == nullptr)) {
+    return;
+  }
+  MObject *mArrayObject = MObject::JniCast(arrayObject);
+  MObject *mElemObject = MObject::JniCast(elemObject);
+  MClass *arryElemInfo = mArrayObject->GetClass()->GetComponentClass();
+  if (arryElemInfo == nullptr) {
+    return;
+  }
+  if (!mElemObject->IsInstanceOf(*arryElemInfo)) {
+    std::string elemName;
+    mElemObject->GetClass()->GetTypeName(elemName);
+    MRT_ThrowArrayStoreExceptionUnw(elemName.c_str());
+  }
+}
+
+void MCC_Reflect_Check_Casting_Array(jclass sourceClass, jobject targetObject, jint arrayDim) {
+  if (UNLIKELY(targetObject == nullptr || sourceClass == nullptr)) {
+    return;
+  }
+  MClass *sourceInfo = MClass::JniCast(sourceClass);
+  MObject *mTargetObject = MObject::JniCast(targetObject);
+  MClass *targetInfo = mTargetObject->GetClass();
+  int dim = arrayDim;
+  while (arrayDim--) {
+    uint32_t targetFlag = targetInfo->GetFlag();
+    if (!modifier::IsArrayClass(targetFlag)) {
+      ReflectThrowCastException(sourceInfo, *mTargetObject, dim);
+    }
+    targetInfo = targetInfo->GetComponentClass();
+  }
+  DCHECK(targetInfo != nullptr) << "MCC_Reflect_Check_Casting_Array: targetInfo is nullptr!" << maple::endl;
+  if (!sourceInfo->IsAssignableFrom(*targetInfo)) {
+    ReflectThrowCastException(sourceInfo, *mTargetObject, dim);
+  }
+}
+
+void MCC_Reflect_Check_Casting_NoArray(jclass sourceClass, jobject targetObject) {
+  MClass *sourceInfo = MClass::JniCastNonNull(sourceClass);
+  MObject *mTargetObject = MObject::JniCastNonNull(targetObject);
+
+  if (!mTargetObject->IsInstanceOf(*sourceInfo)) {
+    ReflectThrowCastException(sourceInfo, *mTargetObject, 0);
+  }
+  return;
+}
+
+// used in compiler, be careful if change name
+jboolean MCC_Reflect_IsInstance(jobject sourceClass, jobject targetObject) {
+  if (sourceClass == nullptr || targetObject == nullptr) {
+    return JNI_FALSE;
+  }
+  MObject *o = MObject::JniCastNonNull(targetObject);
+  MClass *c = MClass::JniCastNonNull(sourceClass);
+  return o->IsInstanceOf(*c);
+}
+
+extern "C"
+uintptr_t MCC_getFuncPtrFromItabSlow64(const MObject *obj, uintptr_t hashCode,
+                                       uintptr_t secondHashCode, const char *signature) {
+  if (UNLIKELY(obj == nullptr)) {
+    ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassNullPointerException(), "unknown reason");
+    return 0;
+  }
+
+  const MClass *klass = obj->GetClass();
+  auto itab = reinterpret_cast<uintptr_t*>(klass->GetItab());
+  auto addr = reinterpret_cast<uintptr_t*>(itab + hashCode);
+  if (*addr != 0) {
+    return *addr;
+  } else {
+    return MCC_getFuncPtrFromItabSecondHash64(itab, secondHashCode, signature);
+  }
+}
+
+static uintptr_t SearchConflictTable64(const uintptr_t *itabConflictBegin, const char *signature) {
+  constexpr uint8_t addrOffset = 2;
+  constexpr uint8_t slotSize = 2;
+  // search conflict table
+  const uintptr_t *conflict =
+      itabConflictBegin + (((*itabConflictBegin) & kLowBitOfItabLength) * slotSize) + addrOffset;
+#if defined(__aarch64__)
+  // Get the high 32bit and set the highest bit zero
+  uintptr_t conflictLength = (itabConflictBegin[0] & kHighBitOfItabLength) >> 32;
+#elif defined(__arm__)
+  // Get the high 16bit and set the highest bit zero
+  uintptr_t conflictLength = (itabConflictBegin[0] & kHighBitOfItabLength) >> 16;
+#endif
+  for (uintptr_t index = 0; index < conflictLength * slotSize; index += slotSize) {
+    if (!strcmp(signature, reinterpret_cast<char*>(*(conflict + index)))) {
+      uintptr_t addr = conflict[index + 1];
+      return addr;
+    }
+  }
+  MRT_ThrowNewExceptionUnw("java/lang/AbstractMethodError", signature);
+  return 0;
+}
+
+extern "C"
+uintptr_t MCC_getFuncPtrFromItabSecondHash64(const uintptr_t *itab, uintptr_t hashCode, const char *signature) {
+  DCHECK(itab != nullptr) << "MCC_getFuncPtrFromItabSecondHash64: itab is nullptr!" << maple::endl;
+  DCHECK(signature != nullptr) << "MCC_getFuncPtrFromItabSecondHash64: signature is nullptr!" << maple::endl;
+  constexpr uint8_t itabConflictBeginOffset = 2;
+  constexpr uint8_t slotSize = 2;
+  auto itabConflictBegin = reinterpret_cast<uintptr_t*>(*(itab + kItabFirstHashSize));
+  auto itabActualBegin = itabConflictBegin + itabConflictBeginOffset;
+  if (itabConflictBegin == nullptr) {
+    MRT_ThrowNewExceptionUnw("java/lang/AbstractMethodError", signature);
+    return 0;
+  }
+
+  // search normal
+  uintptr_t low = 0;
+  // Get the low 32bit
+  uintptr_t high = itabConflictBegin[0] & kLowBitOfItabLength;
+  uintptr_t index = 0;
+  while (low <= high) {
+    index = (low + high) >> 1;
+    uintptr_t srchash = itabActualBegin[index << 1];
+    if (srchash == hashCode) {
+      // find
+      break;
+    }
+    if (srchash < hashCode) {
+      low = index + 1;
+    } else {
+      high = index - 1;
+    }
+  }
+  uintptr_t addr = itabActualBegin[index * slotSize + 1];
+  if (LIKELY(addr != 1)) {
+    return addr;
+  }
+  return SearchConflictTable64(itabConflictBegin, signature);
+}
+
+#ifndef USE_ARM32_MACRO
+#ifdef USE_32BIT_REF
+extern "C"
+uintptr_t MCC_getFuncPtrFromItabInlineCache(uint64_t *cacheEntryAddr, const MClass *klass,
+                                            uint32_t hashCode, uint32_t secondHashCode, const char *signature) {
+  if (UNLIKELY(cacheEntryAddr == nullptr || klass == nullptr || signature == nullptr)) {
+    MRT_ThrowNewException("java/lang/NullPointerException", "cacheEntryAddr or klass or signature == null");
+    return 0;
+  }
+  uint32_t *itab = reinterpret_cast<uint32_t*>(klass->GetItab());
+  uint32_t *addr = itab + hashCode;
+  uint64_t result = *addr;
+  if (result == 0) {
+#if defined(__arm__)
+    result = MCC_getFuncPtrFromItabSecondHash32(itab, secondHashCode, signature);
+#else  // ~__arm__
+    result = MCC_getFuncPtrFromItab(itab, secondHashCode, signature);
+#endif  // ~__arm__
+  }
+  *cacheEntryAddr = (reinterpret_cast<uint64_t>(klass)) | (result << leftShift32Bit);
+  return static_cast<uintptr_t>(result);
+}
+#endif  // ~USE_32BIT_REF
+#endif  // ~USE_ARM32_MACRO
+
+extern "C"
+uintptr_t MCC_getFuncPtrFromItabSlow32(const MObject *obj, uint32_t hashCode, uint32_t secondHashCode,
+                                       const char *signature) {
+  if (UNLIKELY(obj == nullptr)) {
+    ThrowNewExceptionInternalTypeUnw(*WellKnown::GetMClassNullPointerException(), "unknown reason");
+    return 0;
+  }
+
+  const MClass *klass = obj->GetClass();
+  uint32_t *itab = reinterpret_cast<uint32_t*>(klass->GetItab());
+  uint32_t *addr = itab + hashCode;
+  if (*addr != 0) {
+    return *addr;
+  } else {
+    return MCC_getFuncPtrFromItabSecondHash32(itab, secondHashCode, signature);
+  }
+}
+
+static uintptr_t SearchConflictTable32(const uint32_t *itabConflictBegin, const char *signature) {
+  constexpr uint8_t addrOffset = 2;
+  constexpr uint8_t slotSize = 2;
+  // search conflict table
+  uint32_t conflictIndex = ((*itabConflictBegin) & static_cast<uint32_t>(kLowBitOfItabLength)) * slotSize + addrOffset;
+  auto conflict = itabConflictBegin + conflictIndex;
+  uint32_t conflictLength = 0;
+  // This check is for compatible the old version
+  if (itabConflictBegin[0] & 0x80000000) {
+    conflictLength =  (itabConflictBegin[0] & kHighBitOfItabLength) >> 16; // high 16 bit is conflictLength
+  } else {
+    // The max value
+    conflictLength =  0x7fffffff;
+  }
+  for (uint32_t index = 0; index < conflictLength * slotSize; index += slotSize) {
+    if (!strcmp(signature, reinterpret_cast<char*>(*(conflict + index)))) {
+      return *(conflict + index + 1);
+    }
+  }
+  MRT_ThrowNewExceptionUnw("java/lang/AbstractMethodError", signature);
+  return 0;
+}
+
+extern "C"
+uintptr_t MCC_getFuncPtrFromItabSecondHash32(const uint32_t *itab, uint32_t hashCode, const char *signature) {
+  DCHECK(itab != nullptr) << "MCC_getFuncPtrFromItabSecondHash32: itab is nullptr!" << maple::endl;
+  DCHECK(signature != nullptr) << "MCC_getFuncPtrFromItabSecondHash32: signature is nullptr!" << maple::endl;
+  constexpr uint8_t itabConflictBeginOffset = 2;
+  constexpr uint8_t slotSize = 2;
+  uint32_t *itabConflictBegin = reinterpret_cast<uint32_t*>(*(itab + kItabFirstHashSize));
+  uint32_t *itabActualBegin = itabConflictBegin + itabConflictBeginOffset;
+  if (itabConflictBegin == nullptr) {
+    MRT_ThrowNewExceptionUnw("java/lang/AbstractMethodError", signature);
+    return 0;
+  }
+  // search normal
+  uint32_t low = 0;
+  uint32_t high = itabConflictBegin[0] & kLowBitOfItabLength;
+  uint32_t index = 0;
+  while (low <= high) {
+    index = (low + high) >> 1;
+    uint32_t srchash = itabActualBegin[index << 1];
+    if (srchash == hashCode) {
+      break;
+    }
+    (srchash < hashCode) ? (low = index + 1) : (high = index - 1);
+  }
+  uint32_t actualIndex = index * slotSize + 1;
+  uint32_t retFunc = *(itabActualBegin + actualIndex);
+  if (LIKELY(retFunc != 1)) {
+    return retFunc;
+  }
+  return SearchConflictTable32(itabConflictBegin, signature);
+}
+
+#if defined(__arm__)
+extern "C" uintptr_t MCC_getFuncPtrFromItab(const uint32_t *itab, const char *signature, uint32_t hashCode) {
+  return MCC_getFuncPtrFromItabSecondHash32(itab, hashCode, signature);
+}
+#endif
+
+template<typename T>
+static uintptr_t GetFuncPtrFromVtab(const MObject *obj, uint32_t offset) {
+  if (obj == nullptr) {
+    MRT_ThrowNullPointerExceptionUnw();
+    return 0;
+  }
+
+  const MClass *klass = obj->GetClass();
+  T *vtab = reinterpret_cast<T*>(klass->GetVtab());
+  T *funcAddr = vtab + offset;
+  return *funcAddr;
+}
+
+extern "C" uintptr_t MCC_getFuncPtrFromVtab64(const MObject *obj, uint32_t offset) {
+  return GetFuncPtrFromVtab<uintptr_t>(obj, offset);
+}
+
+extern "C" uintptr_t MCC_getFuncPtrFromVtab32(const MObject *obj, uint32_t offset) {
+  return GetFuncPtrFromVtab<uint32_t>(obj, offset);
+}
+
+jboolean MRT_ReflectIsInit(const jclass classObj) {
+  return (MRT_ClassInitialized(classObj) ? JNI_TRUE : JNI_FALSE);
+}
+
+jboolean MRT_ReflectInitialized(jclass classObj) {
+  MClass *classInfo = MClass::JniCastNonNull(classObj);
+  if (classInfo == nullptr) {
+    LOG(ERROR) << "NULL class object!" << maple::endl;
+    return JNI_FALSE;
+  }
+  ClassInitState state = MRT_TryInitClass(*classInfo);
+  if ((state == kClassUninitialized) || (state == kClassInitFailed)) {
+    LOG(ERROR) << "MRT_ReflectInitialized failed! class: " << classInfo->GetName() << maple::endl;
+    return JNI_FALSE;
+  }
+  return JNI_TRUE;
+}
+
+bool MRT_IsValidOffHeapObject(jobject obj __MRT_UNUSED) {
+#if __MRT_DEBUG
+  MObject *mObj = MObject::JniCastNonNull(obj);
+  MClass *clazz = mObj->GetClass();
+  // NEED: using interface from perm-space allocator
+#ifdef __ANDROID__
+  return ((clazz == WellKnown::GetMClassString()) ||
+          (MRT_IsMetaObject(obj)) ||
+          (MRT_IsPermJavaObj(mObj->AsUintptr())));
+#else // !__ANDROID__
+  return ((MRT_IsMetaObject(obj)) ||
+          (clazz == WellKnown::GetMClassString()) ||
+          (clazz == WellKnown::GetMClassAI()) ||
+          (MRT_IsPermJavaObj(mObj->AsUintptr()))); // used by "native_binding_utils.cpp"
+#endif // __ANDROID__
+#else
+  return true;
+#endif // __MRT_DEBUG
+}
+
+bool MRT_IsMetaObject(jobject obj) {
+  MObject *mObj = MObject::JniCastNonNull(obj);
+  return mObj->GetClass() == WellKnown::GetMClassClass();
+}
+
+bool MRT_IsValidClass(jclass jclazz) {
+  MClass *mClassObj = MClass::JniCastNonNull(jclazz);
+  return mClassObj->GetClass() == WellKnown::GetMClassClass();
+}
+
+bool MRT_IsValidMethod(jmethodID jmid) {
+  MethodMeta *methodMeta = MethodMeta::JniCastNonNull(jmid);
+  MClass *declaringClass = methodMeta->GetDeclaringClass();
+  return declaringClass->GetClass() == WellKnown::GetMClassClass();
+}
+
+bool MRT_IsValidField(jfieldID jfid) {
+  FieldMeta *fieldMeta = FieldMeta::JniCastNonNull(jfid);
+  MClass *declaringClass = fieldMeta->GetDeclaringclass();
+  return declaringClass->GetClass() == WellKnown::GetMClassClass();
+}
+
+// guard some macro
+#if defined(__aarch64__)
+GUARD_OFFSETOF_MEMBER(ClassMetadata, monitor, kLockWordOffset);
+#elif defined(__arm__)
+#endif
+
+static std::map<MString*, int, MStringMapNotEqual> stringToInt;
+void ArrayMapStringIntInit () {
+}
+
+void MCC_ArrayMap_String_Int_put(jstring key, jint value) {
+  MString *input = MString::JniCast(key);
+  unsigned long size = stringToInt.size();
+  size_t objSize = MRT_GetStringObjectSize(key);
+  MString *localJstring = MObject::Cast<MString>(calloc(sizeof(char), objSize + 1));
+  if (localJstring != nullptr) {
+    if (memcpy_s(reinterpret_cast<uint8_t*>(localJstring), objSize,
+                 reinterpret_cast<uint8_t*>(input), objSize) != EOK) {
+      LOG(ERROR) << "copy string" << maple::endl;
+    }
+    stringToInt[input] = value;
+    if (size == stringToInt.size()) {
+      free(localJstring);
+    }
+  }
+}
+
+jint MCC_ArrayMap_String_Int_size() {
+  return static_cast<jint>(stringToInt.size());
+}
+
+jint MCC_ArrayMap_String_Int_getOrDefault(jstring key, jint defaultValue) {
+  MString *input = MString::JniCast(key);
+  auto it = stringToInt.find(input);
+  if (it != stringToInt.end()) {
+    return it->second;
+  } else {
+    return defaultValue;
+  }
+}
+
+void MCC_ArrayMap_String_Int_clear() {
+  std::vector<MString*> tmpVector;
+  for (auto it = stringToInt.begin(); it != stringToInt.end(); ++it) {
+    tmpVector.push_back(it->first);
+  }
+  stringToInt.clear();
+  for (auto it = tmpVector.begin(); it != tmpVector.end(); ++it) {
+    free(*it);
+    *it = nullptr;
+  }
+}
+
+size_t MRT_ReflectClassGetComponentSize(jclass classObj) {
+  MClass *mClassObj = MClass::JniCastNonNull(classObj);
+  return mClassObj->GetComponentSize();
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_reflection_constructor.cpp b/src/mrt/maplert/src/mrt_reflection_constructor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..88d7e51169dd43c3829bbdbff10cc36c65530d8a
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_reflection_constructor.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_reflection_constructor.h"
+#include "mrt_reflection_method.h"
+#include "methodmeta_inline.h"
+#include "mmethod_inline.h"
+#include "exception/mrt_exception.h"
+namespace maplert {
+jobject MRT_ReflectConstructorNewInstanceFromSerialization(jclass ctorClass, const jclass allocClass) {
+  MClass *ctorMClass = MClass::JniCastNonNull(ctorClass);
+  MethodMeta *ctor = ctorMClass->GetDeclaredConstructor("()V");
+  if (ctor == nullptr) {
+    return nullptr;
+  }
+  MObject *newObject = MObject::NewObject(*MClass::JniCastNonNull(allocClass), ctor);
+  return newObject->AsJobject();
+}
+
+static MObject *ConstructorNewInstance(const MMethod &methodObject, const MClass &classObj,
+                                       const MethodMeta &methodMeta, const MArray *javaArgs, uint8_t numFrames) {
+  ScopedHandles sHandles;
+  if (classObj.IsStringClass()) {
+    MethodMeta *stringFactroyCon = WellKnown::GetStringFactoryConstructor(methodMeta);
+    ObjHandle<MMethod> stringFactroyConObject(MMethod::NewMMethodObject(*stringFactroyCon));
+    bool isAccessible = methodObject.IsAccessible();
+    stringFactroyConObject->SetAccessible(isAccessible);
+    MObject *stringObj = ReflectInvokeJavaMethodFromArrayArgsJobject(nullptr,
+        *stringFactroyConObject(), javaArgs, numFrames);
+    return stringObj;
+  }
+  ObjHandle<MObject> o(MObject::NewObject(classObj));
+  ReflectInvokeJavaMethodFromArrayArgsVoid(o(), methodObject, javaArgs, numFrames);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    return nullptr;
+  }
+  return o.ReturnObj();
+}
+
+static MObject *ConstructorNewInstance0(const MMethod &methodObject, const MArray *argsArray) {
+  MethodMeta *methodMeta = methodObject.GetMethodMeta();
+  MClass *classObj = methodMeta->GetDeclaringClass();
+  if (UNLIKELY(classObj->IsAbstract())) {
+    std::string classPrettyName, str;
+    std::ostringstream msg;
+    classObj->GetPrettyClass(classPrettyName);
+    str = (classObj->IsInterface()) ? "interface " : "abstract class ";
+    msg << "Can't instantiate " << str << classPrettyName;
+    MRT_ThrowNewException("java/lang/InstantiationException", msg.str().c_str());
+    return nullptr;
+  }
+
+  // Verify that we can access the class.
+  if (!methodObject.IsAccessible() && !classObj->IsPublic()) {
+    MClass *callerClass = reflection::GetCallerClass(2); // 2 means unwind step
+    if (callerClass && !reflection::CanAccess(*classObj, *callerClass)) {
+      std::string classPrettyName;
+      classObj->GetPrettyClass(classPrettyName);
+      if (classPrettyName == "java.lang.Class<dalvik.system.DexPathList$Element>") {
+        LOG(WARNING) << "The dalvik.system.DexPathList$Element constructor is not accessible by "
+                        "default. This is a temporary workaround for backwards compatibility "
+                        "with class-loader hacks. Please update your application." << maple::endl;
+      } else {
+        std::string classObjStr;
+        std::string callerStr;
+        std::string msg;
+        classObj->GetPrettyClass(classObjStr);
+        callerClass->GetPrettyClass(callerStr);
+        msg = classObjStr + " is not accessible from " + callerStr;
+        MRT_ThrowNewException("java/lang/IllegalAccessException", msg.c_str());
+        return nullptr;
+      }
+    }
+  }
+  // NewInstance 2 java frame
+  return ConstructorNewInstance(methodObject, *classObj, *methodMeta, argsArray, 2);
+}
+
+jobject MRT_ReflectConstructorNewInstance0(jobject javaMethod, jobjectArray javaArgs) {
+  MMethod *methodObject = MMethod::JniCastNonNull(javaMethod);
+  MArray *argsArray = MArray::JniCast(javaArgs);
+  return ConstructorNewInstance0(*methodObject, argsArray)->AsJobject();
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_reflection_executable.cpp b/src/mrt/maplert/src/mrt_reflection_executable.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4b1e206a094cd6b309da65242ee9c2aed4bd82b
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_reflection_executable.cpp
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_reflection_executable.h"
+#include "mrt_reflection_method.h"
+#include "mmethod_inline.h"
+#include "mstring_inline.h"
+#include "exception/mrt_exception.h"
+#include "mrt_classloader_api.h"
+
+namespace maplert {
+jobject MRT_ReflectExecutableGetAnnotationNative(jobject methodObj, jclass annoClass) {
+  MMethod *method = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = method->GetMethodMeta();
+  string annoStr = methodMeta->GetAnnotation();
+  if (annoStr.empty()) {
+    return nullptr;
+  }
+  annoStr = AnnoParser::RemoveParameterAnnoInfo(annoStr);
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), methodMeta->GetDeclaringClass());
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  MObject *ret = parser->AllocAnnoObject(methodMeta->GetDeclaringClass(), MClass::JniCast(annoClass));
+  return ret->AsJobject();
+}
+
+jobjectArray MRT_ReflectExecutableGetDeclaredAnnotationsNative(jobject methodObj) {
+  MethodMeta *methodMeta = MMethod::JniCastNonNull(methodObj)->GetMethodMeta();
+  string annoStr = methodMeta->GetAnnotation();
+  if (annoStr.empty()) {
+    return MArray::NewObjectArray(0, *WellKnown::GetMClassAAnnotation())->AsJobjectArray();
+  }
+  MClass *declCls = methodMeta->GetDeclaringClass();
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), declCls);
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  uint32_t annoNum = static_cast<uint32_t>(parser->ParseNum(annoconstant::kValueInt));
+  uint32_t annoMemberCntArray[annoNum];
+  parser->InitAnnoMemberCntArray(annoMemberCntArray, annoNum);
+  ScopedHandles sHandles;
+  ObjHandle<MArray> prepareAnnotations(MArray::NewObjectArray(annoNum, *WellKnown::GetMClassAAnnotation()));
+  uint32_t realCount = 0;
+  for (uint32_t j = 0; j < annoNum; ++j) {
+    string retArr = parser->ParseStr(annoconstant::kDefParseStrType);
+    if (parser->ExceptAnnotationJudge(retArr) || parser->IsVerificationAnno(retArr)) {
+      parser->SkipAnnoMember(annoMemberCntArray[j]);
+      continue;
+    }
+
+    MClass *annotationInfo = MClass::JniCast(MRT_GetClassByContextClass(*declCls, retArr));
+    if (annotationInfo == nullptr) {
+      MArray *nullArray = MArray::NewObjectArray(0, *WellKnown::GetMClassAAnnotation());
+      return nullArray->AsJobjectArray();
+    }
+#ifdef __OPENJDK__
+    ObjHandle<MObject> hashMapInst(
+        parser->GenerateMemberValueHashMap(declCls, annotationInfo, annoMemberCntArray[j]));
+    ObjHandle<MObject> proxyInstance(
+        parser->InvokeAnnotationParser(hashMapInst.AsObject(), annotationInfo));
+#else
+    ObjHandle<MObject> proxyInstance(
+        parser->GenerateAnnotationProxyInstance(declCls, annotationInfo, annoMemberCntArray[j]));
+#endif
+    prepareAnnotations->SetObjectElement(realCount, proxyInstance.AsObject());
+    realCount++;
+  }
+  if (annoNum != realCount) {
+    MArray *retAnnotations = MArray::NewObjectArray(realCount, *WellKnown::GetMClassAAnnotation());
+    for (uint32_t i = 0; i < realCount; ++i) {
+      MObject *obj = prepareAnnotations->GetObjectElementNoRc(i);
+      retAnnotations->SetObjectElement(i, obj);
+    }
+    return retAnnotations->AsJobjectArray();
+  }
+  return static_cast<MArray*>(prepareAnnotations.ReturnObj())->AsJobjectArray();
+}
+
+jobject MRT_ReflectExecutableGetSignatureAnnotation(jobject methodObj) {
+  MMethod *method = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = method->GetMethodMeta();
+  return methodMeta->GetSignatureAnnotation()->AsJobject();
+}
+
+jint MRT_ReflectExecutableCompareMethodParametersInternal(jobject methodObj1, jobject methodObj2) {
+  MMethod *method1 = MMethod::JniCastNonNull(methodObj1);
+  MethodMeta *methodMeta1 = method1->GetMethodMeta();
+  MMethod *method2 = MMethod::JniCastNonNull(methodObj2);
+  MethodMeta *methodMeta2 = method2->GetMethodMeta();
+  uint32_t thisSize = methodMeta1->GetParameterCount();
+  uint32_t otherSize = methodMeta2->GetParameterCount();
+  if (thisSize != otherSize) {
+    return (thisSize - otherSize);
+  }
+  char *signature1 = methodMeta1->GetSignature();
+  char *signature2 = methodMeta2->GetSignature();
+  uint32_t signature1Len = 0;
+  uint32_t signature2Len = 0;
+  while ((signature1[signature1Len] != '\0') && (signature1[signature1Len++] != ')')) {}
+  while ((signature2[signature2Len] != '\0') && (signature2[signature2Len++] != ')')) {}
+  uint32_t sigLenMin = (signature1Len > signature2Len) ?  signature2Len : signature1Len;
+  int cmp = strncmp(signature1, signature2, sigLenMin);
+  if (cmp != 0) {
+    return (cmp < 0) ? -1 : 1;
+  }
+  return 0;
+}
+
+jboolean MRT_ReflectExecutableIsAnnotationPresentNative(jobject methodObj, jclass annoObj) {
+  MMethod *method = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = method->GetMethodMeta();
+  string annoStr = methodMeta->GetAnnotation();
+  if (annoStr.empty() || annoObj == nullptr) {
+    return JNI_FALSE;
+  }
+
+  char *annotationTypeName = MClass::JniCast(annoObj)->GetName();
+  return AnnotationUtil::GetIsAnnoPresent(annoStr, annotationTypeName, reinterpret_cast<CacheValueType>(methodMeta),
+                                          MClass::JniCast(annoObj), annoconstant::kMethodAnnoPresent);
+}
+
+jobject MRT_ReflectExecutableGetParameterAnnotationsNative(jobject methodObj) {
+  MMethod *method = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = method->GetMethodMeta();
+  string executableAnnoStr = methodMeta->GetAnnotation();
+  if (executableAnnoStr.empty()) {
+    return nullptr;
+  }
+  string annoStr = AnnoParser::GetParameterAnnotationInfo(executableAnnoStr);
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), methodMeta->GetDeclaringClass());
+  unique_ptr<AnnoParser> parser(&annoParser);
+  return parser->GetParameterAnnotationsNative(methodMeta)->AsJobject();
+}
+
+jobject MRT_ReflectExecutableGetParameters0(jobject methodObj) {
+  MMethod *method = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = method->GetMethodMeta();
+  string annotationStr = methodMeta->GetAnnotation();
+
+  AnnoParser &parser = AnnoParser::ConstructParser(annotationStr.c_str(), method->GetDeclaringClass());
+  std::unique_ptr<AnnoParser> uniqueParser(&parser);
+  return uniqueParser->GetParameters0(method)->AsJobject();
+}
+
+jobjectArray MRT_ReflectExecutableGetParameterTypesInternal(jobject methodObj) {
+  MMethod *method = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = method->GetMethodMeta();
+  std::vector<MClass*> parameterTypes;
+  methodMeta->GetParameterTypes(parameterTypes);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    return nullptr;
+  }
+  uint32_t size = static_cast<uint32_t>(parameterTypes.size());
+  if (size == 0) {
+    return nullptr;
+  }
+  MArray *parameterTypesArray = MArray::NewObjectArray(size, *WellKnown::GetMClassAClass());
+  uint32_t currentIndex = 0;
+  for (auto it = parameterTypes.begin(); it != parameterTypes.end(); ++it) {
+    parameterTypesArray->SetObjectElementNoRc(currentIndex++, *it);
+  }
+  return parameterTypesArray->AsJobjectArray();
+}
+
+jint MRT_ReflectExecutableGetParameterCountInternal(jobject methodObj) {
+  MMethod *method = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = method->GetMethodMeta();
+  return static_cast<jint>(methodMeta->GetParameterCount());
+}
+
+jclass MRT_ReflectExecutableGetMethodReturnTypeInternal(jobject methodObj) {
+  MMethod *method = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = method->GetMethodMeta();
+  MClass *rtType = methodMeta->GetReturnType();
+  if (UNLIKELY(rtType == nullptr)) {
+    CHECK(MRT_HasPendingException()) << "must pending exception." << maple::endl;
+  }
+  return rtType->AsJclass();
+}
+
+jstring MRT_ReflectExecutableGetMethodNameInternal(jobject methodObj) {
+  MMethod *method = MMethod::JniCastNonNull(methodObj);
+  return ReflectMethodGetName(*method)->AsJstring();
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_reflection_field.cpp b/src/mrt/maplert/src/mrt_reflection_field.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ba7ed352335a76fb30bc44fc24c4937df345bbf
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_reflection_field.cpp
@@ -0,0 +1,644 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_reflection_field.h"
+#include "fieldmeta_inline.h"
+#include "mfield_inline.h"
+#include "exception/mrt_exception.h"
+#include "mrt_reflection_api.h"
+namespace maplert {
+static inline char GetFieldPrimitiveType(const MField &field) {
+  MClass *fieldType = field.GetType();
+  return primitiveutil::GetPrimitiveType(*fieldType);
+}
+
+template<bool isSetFinal>
+static void ThrowIllegalAccessException(const MField &field, const FieldMeta &fieldMeta, const MClass *callingClass) {
+  uint32_t modifier = fieldMeta.GetMod();
+  MClass *declaringClass = field.GetDeclaringClass();
+  std::ostringstream msg;
+  if (isSetFinal) {
+    std::string modifierStr, className;
+    modifier::JavaAccessFlagsToString(modifier, modifierStr);
+    std::string fieldName = fieldMeta.GetFullName(declaringClass, true);
+    declaringClass->GetTypeName(className);
+    msg << "Cannot set " << modifierStr << " field " << fieldName << " of class " << className;
+  } else {
+    std::string callingClassStr, fieldStr, modifierStr, declearClassStr, fieldstr;
+    callingClass->GetPrettyClass(callingClassStr);
+    modifier::JavaAccessFlagsToString(modifier, modifierStr);
+    declaringClass->GetPrettyClass(declearClassStr);
+    fieldstr = fieldMeta.GetFullName(declaringClass, true);
+    msg << "Class " << callingClassStr << " cannot access " << modifierStr << " field " << fieldstr <<
+        " of class " << declearClassStr;
+  }
+  MRT_ThrowNewException("java/lang/IllegalAccessException", msg.str().c_str());
+}
+
+template<bool isSet>
+static ALWAYS_INLINE inline bool CheckIsAccess(const MField &field, const FieldMeta &fieldMeta, const MObject *obj) {
+  if (field.IsAccessible()) {
+    return true;
+  }
+
+  uint32_t modifier = fieldMeta.GetMod();
+  MClass *declaringClass = field.GetDeclaringClass();
+  if (isSet && (fieldMeta.IsFinal())) {
+    ThrowIllegalAccessException<true>(field, fieldMeta, nullptr);
+    return false;
+  }
+  MClass *callingClass = nullptr;
+  obj = fieldMeta.IsStatic() ? declaringClass : obj;
+  if (!reflection::VerifyAccess(obj, declaringClass, modifier, callingClass, 1)) {
+    ThrowIllegalAccessException<false>(field, fieldMeta, callingClass);
+    return false;
+  }
+  return true;
+}
+
+static inline MObject *GetObjectOrBoxPrimitive(const MObject *mObj, const FieldMeta &fieldMeta, char fieldType) {
+  size_t offset = fieldMeta.GetOffset();
+  const bool isVolatile = fieldMeta.IsVolatile();
+  mObj = fieldMeta.GetRealMObject(mObj);
+  if (UNLIKELY(mObj == nullptr)) {
+    return nullptr;
+  }
+  MObject *boxObject = nullptr;
+  switch (fieldType) {
+    case 'Z':
+      boxObject = primitiveutil::BoxPrimitiveJboolean(mObj->Load<uint8_t>(offset, isVolatile));
+      break;
+    case 'B':
+      boxObject = primitiveutil::BoxPrimitiveJbyte(mObj->Load<int8_t>(offset, isVolatile));
+      break;
+    case 'C':
+      boxObject = primitiveutil::BoxPrimitiveJchar(mObj->Load<uint16_t>(offset, isVolatile));
+      break;
+    case 'I':
+      boxObject = primitiveutil::BoxPrimitiveJint(mObj->Load<int32_t>(offset, isVolatile));
+      break;
+    case 'F':
+      boxObject = primitiveutil::BoxPrimitiveJfloat(mObj->Load<float>(offset, isVolatile));
+      break;
+    case 'J':
+      boxObject = primitiveutil::BoxPrimitiveJlong(mObj->Load<int64_t>(offset, isVolatile));
+      break;
+    case 'D':
+      boxObject = primitiveutil::BoxPrimitiveJdouble(mObj->Load<double>(offset, isVolatile));
+      break;
+    case 'S':
+      boxObject = primitiveutil::BoxPrimitiveJshort(mObj->Load<int16_t>(offset, isVolatile));
+      break;
+    case 'N':
+      boxObject = fieldMeta.GetObjectValue(mObj);
+      break;
+    default:;
+  }
+  return boxObject;
+}
+
+static MObject *GetObjectValueOfField(const MField &field, const MObject *object) {
+  MClass *declaringClass = field.GetDeclaringClass();
+  FieldMeta *fieldMeta = field.GetFieldMeta();
+  if (fieldMeta->IsStatic()) {
+    if (!declaringClass->InitClassIfNeeded()) {
+      return nullptr;
+    }
+  } else {
+    if (!reflection::CheckIsInstaceOf(*declaringClass, object)) {
+      return nullptr;
+    }
+  }
+  if (!CheckIsAccess<false>(field, *fieldMeta, object)) {
+    return nullptr;
+  }
+
+  char fieldType = GetFieldPrimitiveType(field);
+  MObject *retObject = GetObjectOrBoxPrimitive(object, *fieldMeta, fieldType);
+  return retObject;
+}
+
+template<typename T, char kPrimitiveType>
+static inline T GetPrimitiveValueOfField(const MField &field, const MObject *object) {
+  MClass *declaringClass = field.GetDeclaringClass();
+  FieldMeta *fieldMeta = field.GetFieldMeta();
+  if (fieldMeta->IsStatic()) {
+    if (!declaringClass->InitClassIfNeeded()) {
+      return 0;
+    }
+  } else {
+    if (!reflection::CheckIsInstaceOf(*declaringClass, object)) {
+      return 0;
+    }
+  }
+  if (!CheckIsAccess<false>(field, *fieldMeta, object)) {
+    return 0;
+  }
+
+  char fieldType = GetFieldPrimitiveType(field);
+  if (UNLIKELY(fieldType == 'N')) {
+    std::string fieldTypeName = fieldMeta->GetFullName(declaringClass, true);
+    std::string msg = "Not a primitive field: " + fieldTypeName;
+    MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.c_str());
+    return 0;
+  }
+
+  T value = fieldMeta->GetPrimitiveValue<T>(object, fieldType);
+  if (fieldType == kPrimitiveType ||
+      primitiveutil::CanConvertNarrowToWide(fieldType, kPrimitiveType)) {
+    return value;
+  }
+
+  // Throw Exception
+  std::string srcDescriptor, dstDescriptor;
+  maple::Primitive::PrettyDescriptor_forField(maple::Primitive::GetType(fieldType), srcDescriptor);
+  maple::Primitive::PrettyDescriptor_forField(maple::Primitive::GetType(kPrimitiveType), dstDescriptor);
+  std::ostringstream msg;
+  msg << "Invalid primitive conversion from " << srcDescriptor << " to " << dstDescriptor;
+  MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.str().c_str());
+  return 0;
+}
+
+uint8_t ReflectGetFieldNativeUint8(const MField &field, const MObject *object) {
+  return GetPrimitiveValueOfField<uint8_t, 'Z'>(field, object);
+}
+
+int8_t ReflectGetFieldNativeInt8(const MField &field, const MObject *object) {
+  return GetPrimitiveValueOfField<int8_t, 'B'>(field, object);
+}
+
+uint16_t ReflectGetFieldNativeUint16(const MField &field, const MObject *object) {
+  return GetPrimitiveValueOfField<uint16_t, 'C'>(field, object);
+}
+
+double ReflectGetFieldNativeDouble(const MField &field, const MObject *object) {
+  return GetPrimitiveValueOfField<double, 'D'>(field, object);
+}
+
+float ReflectGetFieldNativeFloat(const MField &field, const MObject *object) {
+  return GetPrimitiveValueOfField<float, 'F'>(field, object);
+}
+
+int32_t ReflectGetFieldNativeInt32(const MField &field, const MObject *object) {
+  return GetPrimitiveValueOfField<int32_t, 'I'>(field, object);
+}
+
+int64_t ReflectGetFieldNativeInt64(const MField &field, const MObject *object) {
+  return GetPrimitiveValueOfField<int64_t, 'J'>(field, object);
+}
+
+int16_t ReflectGetFieldNativeInt16(const MField &field, const MObject *object) {
+  return GetPrimitiveValueOfField<int16_t, 'S'>(field, object);
+}
+
+MObject *ReflectGetFieldNativeObject(const MField &field, const MObject *object) {
+  return GetObjectValueOfField(field, object);
+}
+
+static void UnBoxAndSetPrimitiveField(const FieldMeta &fieldMeta, char type, const MObject *obj, const MObject &val) {
+  const bool isVolatile = fieldMeta.IsVolatile();
+  MObject *object = fieldMeta.GetRealMObject(obj);
+  DCHECK(object != nullptr);
+  uint32_t offset = fieldMeta.GetOffset();
+  switch (type) {
+    case 'Z': {
+      uint8_t z = primitiveutil::UnBoxPrimitive<uint8_t>(val);
+      object->Store<uint8_t>(offset, z, isVolatile);
+      break;
+    }
+    case 'B': {
+      int8_t b = primitiveutil::UnBoxPrimitive<int8_t>(val);
+      object->Store<int8_t>(offset, b, isVolatile);
+      break;
+    }
+    case 'C': {
+      uint16_t c = primitiveutil::UnBoxPrimitive<uint16_t>(val);
+      object->Store<uint16_t>(offset, c, isVolatile);
+      break;
+    }
+    case 'S': {
+      int16_t s = primitiveutil::UnBoxPrimitive<int16_t>(val);
+      object->Store<int16_t>(offset, s, isVolatile);
+      break;
+    }
+    case 'I': {
+      int32_t i = primitiveutil::UnBoxPrimitive<int32_t>(val);
+      object->Store<int32_t>(offset, i, isVolatile);
+      break;
+    }
+    case 'F': {
+      float f = primitiveutil::UnBoxPrimitive<float>(val);
+      object->Store<float>(offset, f, isVolatile);
+      break;
+    }
+    case 'J': {
+      int64_t l = primitiveutil::UnBoxPrimitive<int64_t>(val);
+      object->Store<int64_t>(offset, l, isVolatile);
+      break;
+    }
+    case 'D': {
+      double d = primitiveutil::UnBoxPrimitive<double>(val);
+      object->Store<double>(offset, d, isVolatile);
+      break;
+    }
+    default:
+      LOG(ERROR) << "UnBoxAndSetPrimitiveField fail" << maple::endl;
+  }
+}
+
+static inline void SetObjectOrUnBoxPrimitive(const MField &field, MObject *object, const MObject *value) {
+  FieldMeta *fieldMeta = field.GetFieldMeta();
+  MClass *fieldType = field.GetType();
+  MClass *declaringClass = field.GetDeclaringClass();
+  char fieldPrimitiveType = primitiveutil::GetPrimitiveType(*fieldType);
+  if (fieldPrimitiveType == 'N') {
+    // ref, set object
+    if (value == nullptr || value->IsInstanceOf(*fieldType)) {
+      fieldMeta->SetObjectValue(object, value);
+    } else {
+      std::string fieldTypeName, valueClassName;
+      std::string fieldName = fieldMeta->GetFullName(declaringClass, false);
+      fieldType->GetTypeName(fieldTypeName);
+      value->GetClass()->GetTypeName(valueClassName);
+      std::string msg = "field " + fieldName + " has type " + fieldTypeName + ", got " + valueClassName;
+      MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.c_str());
+    }
+    return;
+  }
+
+  // Primitive, UnBox first, then set Primitive
+  if (UNLIKELY(value == nullptr)) {
+    std::string fieldTypeName;
+    std::string fieldName = fieldMeta->GetFullName(declaringClass, false);
+    fieldType->GetTypeName(fieldTypeName);
+    std::string msg = "field " + fieldName + " has type " + fieldTypeName + ", got null";
+    MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.c_str());
+    return;
+  }
+
+  MClass *valueClass = value->GetClass();
+  char valuePrimitiveType = primitiveutil::GetPrimitiveTypeFromBoxType(*valueClass);
+  if (valuePrimitiveType == 'N') {
+    // not Box object
+    std::string fieldTypeName, valueClassName;
+    std::string fieldName = fieldMeta->GetFullName(declaringClass, false);
+    fieldType->GetTypeName(fieldTypeName);
+    valueClass->GetTypeName(valueClassName);
+    std::string msg = "field " + fieldName + " has type " + fieldTypeName + ", got " + valueClassName;
+    MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.c_str());
+    return;
+  }
+
+  // check can convert
+  if (!primitiveutil::CanConvertNarrowToWide(valuePrimitiveType, fieldPrimitiveType)) {
+    std::string srcDescriptor, dstDescriptor;
+    maple::Primitive::PrettyDescriptor_forField(maple::Primitive::GetType(valuePrimitiveType), srcDescriptor);
+    maple::Primitive::PrettyDescriptor_forField(maple::Primitive::GetType(fieldPrimitiveType), dstDescriptor);
+    std::ostringstream msg;
+    msg << "Invalid primitive conversion from " << srcDescriptor << " to " << dstDescriptor;
+    MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.str().c_str());
+    return;
+  }
+
+  // set Primitive
+  UnBoxAndSetPrimitiveField(*fieldMeta, fieldPrimitiveType, object, *value);
+}
+
+static bool CheckFieldIsValid(const MField &field, const MObject *object) {
+  MClass *declaringClass = field.GetDeclaringClass();
+  FieldMeta *fieldMeta = field.GetFieldMeta();
+  if (fieldMeta->IsStatic()) {
+    if (!declaringClass->InitClassIfNeeded()) {
+      return false;
+    }
+  } else {
+    if (!reflection::CheckIsInstaceOf(*declaringClass, object)) {
+      return false;
+    }
+  }
+  if (!CheckIsAccess<true>(field, *fieldMeta, object)) {
+    return false;
+  }
+  return true;
+}
+static void SetObjectValueOfField(const MField &field, MObject *object, const MObject *value) {
+  if (!CheckFieldIsValid(field, object)) {
+    return;
+  }
+  SetObjectOrUnBoxPrimitive(field, object, value);
+}
+
+template<typename valueType, char srcType>
+static void SetPrimitiveValueOfField(const MField &field, MObject *object, valueType value) {
+  MClass *declaringClass = field.GetDeclaringClass();
+  FieldMeta *fieldMeta = field.GetFieldMeta();
+  if (!CheckFieldIsValid(field, object)) {
+    return;
+  }
+
+  char fieldPrimitiveType = GetFieldPrimitiveType(field);
+  if (UNLIKELY(fieldPrimitiveType == 'N')) {
+    std::string fieldTypeName = fieldMeta->GetFullName(declaringClass, true);
+    std::string msg = "Not a primitive field: " + fieldTypeName;
+    MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.c_str());
+    return;
+  }
+
+  // check can convert
+  if (!primitiveutil::CanConvertNarrowToWide(srcType, fieldPrimitiveType)) {
+    std::string srcDescriptor, dstDescriptor;
+    maple::Primitive::PrettyDescriptor_forField(maple::Primitive::GetType(srcType), srcDescriptor);
+    maple::Primitive::PrettyDescriptor_forField(maple::Primitive::GetType(fieldPrimitiveType), dstDescriptor);
+    std::ostringstream msg;
+    msg << "Invalid primitive conversion from " << srcDescriptor << " to " << dstDescriptor;
+    MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.str().c_str());
+    return;
+  }
+  fieldMeta->SetPrimitiveValue<valueType>(object, fieldPrimitiveType, value);
+}
+
+void ReflectSetFieldNativeUint8(const MField &fieldObj, MObject *obj, uint8_t z) {
+  SetPrimitiveValueOfField<uint8_t, 'Z'>(fieldObj, obj, z);
+}
+
+void ReflectSetFieldNativeInt8(const MField &fieldObj, MObject *obj, int8_t b) {
+  SetPrimitiveValueOfField<int8_t, 'B'>(fieldObj, obj, b);
+}
+
+void ReflectSetFieldNativeUint16(const MField &fieldObj, MObject *obj, uint16_t c) {
+  SetPrimitiveValueOfField<uint16_t, 'C'>(fieldObj, obj, c);
+}
+
+void ReflectSetFieldNativeInt16(const MField &fieldObj, MObject *obj, int16_t s) {
+  SetPrimitiveValueOfField<int16_t, 'S'>(fieldObj, obj, s);
+}
+
+void ReflectSetFieldNativeInt32(const MField &fieldObj, MObject *obj, int32_t i) {
+  SetPrimitiveValueOfField<int32_t, 'I'>(fieldObj, obj, i);
+}
+
+void ReflectSetFieldNativeInt64(const MField &fieldObj, MObject *obj, int64_t j) {
+  SetPrimitiveValueOfField<int64_t, 'J'>(fieldObj, obj, j);
+}
+
+void ReflectSetFieldNativeFloat(const MField &fieldObj, MObject *obj, float f) {
+  SetPrimitiveValueOfField<float, 'F'>(fieldObj, obj, f);
+}
+
+void ReflectSetFieldNativeDouble(const MField &fieldObj, MObject *obj, double d) {
+  SetPrimitiveValueOfField<double, 'D'>(fieldObj, obj, d);
+}
+
+void ReflectSetFieldNativeObject(const MField &fieldObj, MObject *obj, const MObject *value) {
+  SetObjectValueOfField(fieldObj, obj, value);
+}
+
+jint MRT_ReflectFieldGetOffset(jobject fieldObj) {
+  MField *f = MField::JniCastNonNull(fieldObj);
+#ifdef __OPENJDK__
+  FieldMeta *fieldMeta = f->GetFieldMeta();
+  int32_t offset = fieldMeta->IsStatic() ?
+      static_cast<int32_t>((fieldMeta->GetStaticAddr() - fieldMeta->GetDeclaringclass()->AsUintptr())) :
+      static_cast<int32_t>(fieldMeta->GetOffset());
+  return offset;
+#else
+  return static_cast<int32_t>(f->GetOffset());
+#endif
+}
+
+MObject *ReflectFieldGetSignatureAnnotation(const MField &fieldObj) {
+  FieldMeta *fieldMeta = fieldObj.GetFieldMeta();
+  MObject *ret = fieldMeta->GetSignatureAnnotation();
+  return ret;
+}
+
+bool ReflectFieldIsAnnotationPresentNative(const MField &fieldObj, const MClass *annoObj) {
+  if (annoObj == nullptr) {
+    MRT_ThrowNewException("java/lang/NullPointerException", nullptr);
+    return false;
+  }
+  FieldMeta *fieldMeta = fieldObj.GetFieldMeta();
+  string annoStr = fieldMeta->GetAnnotation();
+  char *annotationTypeName = annoObj->GetName();
+  if (annoStr.empty() || annotationTypeName == nullptr) {
+    return JNI_FALSE;
+  }
+  return AnnotationUtil::GetIsAnnoPresent(annoStr, annotationTypeName, reinterpret_cast<CacheValueType>(fieldMeta),
+                                          const_cast<MClass*>(annoObj), annoconstant::kFieldAnnoPresent);
+}
+
+MObject *ReflectFieldGetAnnotation(const MField &fieldObj, const MClass *annoClass) {
+  FieldMeta *fieldMeta = fieldObj.GetFieldMeta();
+  string annoStr = fieldMeta->GetAnnotation();
+  if (annoStr.empty()) {
+    return nullptr;
+  }
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), fieldObj.GetDeclaringClass());
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  MObject *ret = parser->AllocAnnoObject(fieldObj.GetDeclaringClass(), const_cast<MClass*>(annoClass));
+  return ret;
+}
+
+MObject *ReflectFieldGetDeclaredAnnotations(const MField &fieldObj) {
+  FieldMeta *fieldMeta = fieldObj.GetFieldMeta();
+  string annoStr = fieldMeta->GetAnnotation();
+  if (annoStr.empty()) {
+    return nullptr;
+  }
+
+  MObject *ret = AnnotationUtil::GetDeclaredAnnotations(annoStr, fieldObj.GetDeclaringClass());
+  return ret;
+}
+
+MObject *ReflectFieldGetNameInternal(const MField &fieldObj) {
+  FieldMeta *fieldMeta = fieldObj.GetFieldMeta();
+  char *fieldName = fieldMeta->GetName();
+  MString *fieldNameObj = MString::InternUtf(std::string(fieldName));
+  return fieldNameObj;
+}
+
+FieldMeta *ReflectFieldGetArtField(const MField &fieldObj) {
+  FieldMeta *fieldMeta = fieldObj.GetFieldMeta();
+  return fieldMeta;
+}
+
+#define MRT_REFLECT_SETFIELD(TYPE) \
+void MRT_ReflectSetField##TYPE(jfieldID fieldMeta, jobject obj, TYPE value) { \
+  FieldMeta *field = FieldMeta::JniCastNonNull(fieldMeta); \
+  MObject *mObj = MObject::JniCast(obj); \
+  mObj = field->GetRealMObject(mObj); \
+  if (UNLIKELY(mObj == nullptr)) { \
+    return; \
+  } \
+  uint32_t offset = field->GetOffset(); \
+  mObj->Store<TYPE>(offset, value, field->IsVolatile()); \
+}
+
+#define MRT_REFLECT_GETFIELD(TYPE) \
+TYPE MRT_ReflectGetField##TYPE(jfieldID fieldMeta, jobject obj) { \
+  FieldMeta *field = FieldMeta::JniCastNonNull(fieldMeta); \
+  MObject *mObj = MObject::JniCast(obj); \
+  mObj = field->GetRealMObject(mObj); \
+  if (UNLIKELY(mObj == nullptr)) { \
+    return 0; \
+  } \
+  uint32_t offset = field->GetOffset(); \
+  return mObj->Load<TYPE>(offset, field->IsVolatile()); \
+}
+
+// ONLY use in hprof.cc for heap dump
+jboolean MRT_ReflectGetFieldjbooleanUnsafe(jfieldID fieldMeta, jobject javaObj)
+  __attribute__ ((alias ("MRT_ReflectGetFieldjboolean")));
+
+jbyte MRT_ReflectGetFieldjbyteUnsafe(jfieldID fieldMeta, jobject javaObj)
+  __attribute__ ((alias ("MRT_ReflectGetFieldjbyte")));
+
+jchar MRT_ReflectGetFieldjcharUnsafe(jfieldID fieldMeta, jobject javaObj)
+  __attribute__ ((alias ("MRT_ReflectGetFieldjchar")));
+
+jdouble MRT_ReflectGetFieldjdoubleUnsafe(jfieldID fieldMeta, jobject javaObj)
+  __attribute__ ((alias ("MRT_ReflectGetFieldjdouble")));
+jfloat MRT_ReflectGetFieldjfloatUnsafe(jfieldID fieldMeta, jobject javaObj)
+  __attribute__ ((alias ("MRT_ReflectGetFieldjfloat")));
+
+jint MRT_ReflectGetFieldjintUnsafe(jfieldID fieldMeta, jobject javaObj)
+  __attribute__ ((alias ("MRT_ReflectGetFieldjint")));
+
+jlong MRT_ReflectGetFieldjlongUnsafe(jfieldID fieldMeta, jobject javaObj)
+  __attribute__ ((alias ("MRT_ReflectGetFieldjlong")));
+
+jshort MRT_ReflectGetFieldjshortUnsafe(jfieldID fieldMeta, jobject javaObj)
+  __attribute__ ((alias ("MRT_ReflectGetFieldjshort")));
+
+// ONLY use in hprof.cc for dump heap
+// Returns the object referenced by an instance field (if 'obj' is not null)
+// or a static field (if 'obj' is not null)without RC increment
+jobject MRT_ReflectGetFieldjobjectUnsafe(jfieldID fieldMeta, jobject obj) {
+  FieldMeta *field = FieldMeta::JniCastNonNull(fieldMeta);
+  MObject *mObj = MObject::JniCast(obj);
+  mObj = field->GetRealMObject(mObj);
+  if (UNLIKELY(mObj == nullptr)) {
+    return nullptr;
+  }
+  uint32_t offset = field->GetOffset();
+  return mObj->LoadObjectNoRc(offset)->AsJobject();
+}
+
+// TYPE MRT_Reflect_GetField_##TYPE(jobject fieldObj, jobject obj)
+MRT_REFLECT_GETFIELD(jboolean)
+MRT_REFLECT_GETFIELD(jbyte)
+MRT_REFLECT_GETFIELD(jchar)
+MRT_REFLECT_GETFIELD(jdouble)
+MRT_REFLECT_GETFIELD(jfloat)
+MRT_REFLECT_GETFIELD(jint)
+MRT_REFLECT_GETFIELD(jlong)
+MRT_REFLECT_GETFIELD(jshort)
+
+// void MRT_Reflect_SetField_##TYPE(jobject fieldObj, jobject obj, TYPE value)
+MRT_REFLECT_SETFIELD(jboolean)
+MRT_REFLECT_SETFIELD(jbyte)
+MRT_REFLECT_SETFIELD(jchar)
+MRT_REFLECT_SETFIELD(jdouble)
+MRT_REFLECT_SETFIELD(jfloat)
+MRT_REFLECT_SETFIELD(jint)
+MRT_REFLECT_SETFIELD(jlong)
+MRT_REFLECT_SETFIELD(jshort)
+
+void MRT_ReflectSetFieldjobject(jfieldID fieldMeta, jobject obj, jobject value) {
+  FieldMeta *fm = FieldMeta::JniCastNonNull(fieldMeta);
+  MObject *mObj = MObject::JniCast(obj);
+  MObject *mValue = MObject::JniCast(value);
+  fm->SetObjectValue(mObj, mValue);
+}
+
+jobject MRT_ReflectGetFieldjobject(jfieldID fieldMeta, jobject obj) {
+  FieldMeta *fm = FieldMeta::JniCastNonNull(fieldMeta);
+  MObject *mObj = MObject::JniCast(obj);
+  return fm->GetObjectValue(mObj)->AsJobject();
+}
+
+char *MRT_ReflectFieldGetCharFieldName(jfieldID fieldMeta) {
+  FieldMeta *fm = FieldMeta::JniCastNonNull(fieldMeta);
+  return fm->GetName();
+}
+
+jboolean MRT_ReflectFieldIsStatic(jfieldID fieldMeta) {
+  FieldMeta *fm = FieldMeta::JniCastNonNull(fieldMeta);
+  return fm->IsStatic();
+}
+
+jclass MRT_ReflectFieldGetType(jfieldID fieldMeta) {
+  FieldMeta *fm = FieldMeta::JniCastNonNull(fieldMeta);
+  return fm->GetType()->AsJclass();
+}
+
+char *MRT_ReflectFieldGetTypeName(jfieldID fieldMeta) {
+  FieldMeta *fm = FieldMeta::JniCastNonNull(fieldMeta);
+  return fm->GetTypeName();
+}
+
+jclass MRT_ReflectFieldGetDeclaringClass(jfieldID fieldMeta) {
+  FieldMeta *fm = FieldMeta::JniCastNonNull(fieldMeta);
+  return fm->GetDeclaringclass()->AsJclass();
+}
+
+jfieldID MRT_ReflectFromReflectedField(jobject fieldObj) {
+  MField *mField = MField::JniCastNonNull(fieldObj);
+  FieldMeta *fieldMeta = mField->GetFieldMeta();
+  return fieldMeta->AsJfieldID();
+}
+
+jobject MRT_ReflectToReflectedField(jclass clazz __attribute__((unused)), jfieldID fid) {
+  FieldMeta *fieldMeta = FieldMeta::JniCastNonNull(fid);
+  MField *mField = MField::NewMFieldObject(*fieldMeta);
+  return mField->AsJobject();
+}
+
+uint32_t MRT_GetFieldOffset(jfieldID fieldMeta) {
+  FieldMeta *fm = FieldMeta::JniCastNonNull(fieldMeta);
+  return fm->GetOffset();
+}
+
+uint32_t ReflectFieldGetSize(const FieldMeta &fieldMeta) {
+  char *fieldTypeName = fieldMeta.GetTypeName();
+  return ReflectCompactFieldGetSize(fieldTypeName);
+}
+
+uint32_t ReflectCompactFieldGetSize(const std::string &fieldTypeName) {
+  switch (fieldTypeName[0]) {
+    case 'Z':
+    case 'B':
+      return 1; // jboolean, jbyte size
+    case 'C':
+    case 'S':
+      return 2; // jchar, jshort size
+    case 'I':
+    case 'F':
+      return 4; // jint, jfloat size
+    case 'J':
+    case 'D':
+      return 8; // jlong, jdouble size
+    case '[':
+    case 'L':
+#ifdef USE_32BIT_REF
+      return 4; // ref size
+#else
+      return 8; // ref size
+#endif // USE_32BIT_REF
+    default:
+      __MRT_ASSERT(false, "Unknown Field Type For GetSize!");
+      return 0;
+  }
+}
+} // namespace maplert
\ No newline at end of file
diff --git a/src/mrt/maplert/src/mrt_reflection_method.cpp b/src/mrt/maplert/src/mrt_reflection_method.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7aae488bfd540df516ad25cb39014f8a80b99ccd
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_reflection_method.cpp
@@ -0,0 +1,443 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_reflection_method.h"
+#include "mmethod_inline.h"
+#include "methodmeta_inline.h"
+#include "exception/mrt_exception.h"
+namespace maplert {
+MString *ReflectMethodGetName(const MMethod &methodObj) {
+  MethodMeta *methodMeta = methodObj.GetMethodMeta();
+  char *methodName = methodMeta->GetName();
+  MString *ret = MString::InternUtf(std::string(methodName));
+  return ret;
+}
+
+MObject *ReflectMethodGetReturnType(const MMethod &methodObj) {
+  MethodMeta *methodMeta = methodObj.GetMethodMeta();
+  MClass *rtType = methodMeta->GetReturnType();
+  if (UNLIKELY(rtType == nullptr)) {
+    CHECK(MRT_HasPendingException()) << "must pending exception." << maple::endl;
+  }
+  return rtType;
+}
+
+jclass MRT_ReflectMethodGetDeclaringClass(jmethodID methodId) {
+  MethodMeta *methodMeta = MethodMeta::JniCastNonNull(methodId);
+  return methodMeta->GetDeclaringClass()->AsJclass();
+}
+
+jobjectArray MRT_ReflectMethodGetExceptionTypes(jobject methodObj) {
+  MMethod *methodObject = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = methodObject->GetMethodMeta();
+  std::vector<MClass*> types;
+  methodMeta->GetExceptionTypes(types);
+  if (MRT_HasPendingException()) {
+    return nullptr;
+  }
+  MArray *excetpionArray = MArray::NewObjectArray(static_cast<uint32_t>(types.size()), *WellKnown::GetMClassAClass());
+  uint32_t index = 0;
+  for (auto type : types) {
+    excetpionArray->SetObjectElementOffHeap(index++, type);
+  }
+  return excetpionArray->AsJobjectArray();
+}
+
+static void ThrowInvocationTargetException() {
+  ScopedHandles sHandles;
+  ObjHandle<MObject> exception(MRT_PendingException());
+  MRT_ClearPendingException();
+
+  MClass *invocationTargetExceptionClass =
+      MClass::GetClassFromDescriptor(nullptr, "Ljava/lang/reflect/InvocationTargetException;");
+  CHECK(invocationTargetExceptionClass != nullptr) << "Not find InvocationTargetException class" << maple::endl;
+  MethodMeta *exceptionConstruct =
+      invocationTargetExceptionClass->GetDeclaredConstructor("(Ljava/lang/Throwable;)V");
+  CHECK(exceptionConstruct != nullptr) << "Not find InvocationTargetException's Constructor" << maple::endl;
+
+  ObjHandle<MObject> exceptionInstance(
+      MObject::NewObject(*invocationTargetExceptionClass, exceptionConstruct, exception.AsRaw()));
+  if (UNLIKELY(exceptionInstance() == 0)) {
+    CHECK(MRT_HasPendingException()) << "Must Has PendingException" << maple::endl;
+    return;
+  }
+
+  MRT_ThrowExceptionSafe(exceptionInstance.AsJObj());
+  return;
+}
+
+static void FailCheckParameter(const MethodMeta &methodMeta, const MClass *receObjectCls,
+                               const MClass &paramType, uint32_t num) {
+  std::string methodName, srcClassName, dstClassName;
+  methodMeta.GetPrettyName(false, methodName);
+  if (receObjectCls != nullptr) {
+    receObjectCls->GetTypeName(srcClassName);
+  } else {
+    srcClassName = "null";
+  }
+  paramType.GetTypeName(dstClassName);
+  std::ostringstream msg;
+  msg << "method " << methodName << " argument " << std::to_string(num) << " has type " <<
+      dstClassName << ", got " << srcClassName;
+  MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.str().c_str());
+}
+
+static bool DecodeArgs(const MethodMeta &methodMeta, MObject *receObject, jvalue &arg,
+                       const MClass &paramType, uint32_t index) {
+  if (!paramType.IsPrimitiveClass()) {
+    if ((receObject != nullptr) && (!receObject->IsInstanceOf(paramType))) {
+      MClass *receObjectCls = receObject->GetClass();
+      FailCheckParameter(methodMeta, receObjectCls, paramType, index + 1);
+      return false;
+    } else {
+      // copy ref parameter.
+      arg.l = reinterpret_cast<jobject>(receObject);
+    }
+  } else {
+    // Primitive Parameter
+    if (receObject == nullptr) {
+      FailCheckParameter(methodMeta, nullptr, paramType, index + 1);
+      return false;
+    }
+    MClass *receObjectClass = receObject->GetClass();
+    char srcType = primitiveutil::GetPrimitiveTypeFromBoxType(*receObjectClass);
+    if (srcType != 'N') {
+      char dstType = primitiveutil::GetPrimitiveType(paramType);
+      jvalue src;
+      // copy primitive parameter, ingore return value, we will check again next.
+      (void)primitiveutil::UnBoxPrimitive(*receObject, src);
+      if (!primitiveutil::ConvertNarrowToWide(srcType, dstType, src, arg)) {
+        FailCheckParameter(methodMeta, receObjectClass, paramType, index + 1);
+        return false;
+      }
+    } else {
+      FailCheckParameter(methodMeta, receObjectClass, paramType, index + 1);
+      return false;
+    }
+  }
+  return true;
+}
+
+static ALWAYS_INLINE bool CheckReceiveParameterAndDecodeArgs(const MethodMeta &methodMeta, const MArray *receiveParam,
+                                                             jvalue decodeArgs[], uint32_t parameterCount) {
+  // here decodeArgs length equals parameterTypes.size
+  DCHECK(parameterCount == methodMeta.GetParameterCount()) << "parameterCount is wrong." << maple::endl;
+  MClass *parameterTypes[parameterCount];
+  uint32_t receNum = (receiveParam != nullptr) ? receiveParam->GetLength() : 0;
+  if (UNLIKELY(parameterCount != receNum)) {
+    std::ostringstream msg;
+    msg << "Wrong number of arguments; expected " << std::to_string(parameterCount) <<
+        ", got " << std::to_string(receNum);
+    MRT_ThrowNewException("java/lang/IllegalArgumentException", msg.str().c_str());
+    return false;
+  }
+  bool isSuccess = methodMeta.GetParameterTypes(parameterTypes, parameterCount);
+  if (UNLIKELY(!isSuccess)) {
+    return false;
+  }
+
+  for (uint32_t i = 0; i < parameterCount; ++i) {
+    MObject *receObject = receiveParam->GetObjectElementNoRc(i);
+    MClass *paramType = parameterTypes[i];
+    if (!DecodeArgs(methodMeta, receObject, decodeArgs[i], *paramType, i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static ALWAYS_INLINE bool CheckAccess(const MethodMeta &methodMeta, const MObject *obj,
+                                      const MClass &declarClass, uint8_t numFrames) {
+  uint32_t mod = methodMeta.GetMod();
+  MClass *caller = nullptr;
+  if (!reflection::VerifyAccess(obj, &declarClass, mod, caller, static_cast<uint32_t>(numFrames))) {
+    std::string declaringClassStr, callerStr, modifyStr, prettyMethodStr, retTypeStr;
+    MClass *declaringClass = methodMeta.GetDeclaringClass();
+    MClass *retType = methodMeta.GetReturnType();
+    if (UNLIKELY(retType == nullptr)) {
+      return false;
+    }
+    modifier::JavaAccessFlagsToString(mod, modifyStr);
+    declaringClass->GetPrettyClass(declaringClassStr);
+    caller->GetPrettyClass(callerStr);
+    retType->GetBinaryName(retTypeStr);
+    methodMeta.GetPrettyName(true, prettyMethodStr);
+    std::ostringstream msg;
+    msg << "Class " << callerStr << " cannot access " << modifyStr << " method " << prettyMethodStr << " of class " <<
+        declaringClassStr;
+    MRT_ThrowNewException("java/lang/IllegalAccessException", msg.str().c_str());
+    return false;
+  }
+  return true;
+}
+
+template<typename T>
+static T InvokeJavaMethodFromArrayArgs(MObject *obj, const MMethod &methodObj, const MArray *arrayObj, uint8_t frames) {
+  MethodMeta *methodMeta = methodObj.GetMethodMeta();
+  bool isStaticMethod = methodMeta->IsStatic();
+  MClass *declarClass = methodMeta->GetDeclaringClass();
+  if (!isStaticMethod) {
+    if (!reflection::CheckIsInstaceOf(*declarClass, obj)) {
+      return 0;
+    }
+    MClass *classObj = obj->GetClass();
+    methodMeta = classObj->GetVirtualMethod(*methodMeta);
+    CHECK(methodMeta != nullptr);
+    declarClass = methodMeta->GetDeclaringClass();
+  }
+
+  if (UNLIKELY(!declarClass->InitClassIfNeeded())) {
+    return 0;
+  }
+
+  uint32_t parameterCount = methodMeta->GetParameterCount();
+  jvalue decodeArgs[parameterCount];
+  if (!CheckReceiveParameterAndDecodeArgs(*methodMeta, arrayObj, decodeArgs, parameterCount)) {
+    return 0;
+  }
+
+  const bool accessible = methodObj.IsAccessible();
+  if (!accessible && !CheckAccess(*methodMeta, obj, *declarClass, frames)) {
+    return 0;
+  }
+
+  T result = methodMeta->Invoke<T, calljavastubconst::kJvalue>(obj, decodeArgs);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    ThrowInvocationTargetException();
+    return 0;
+  }
+  return result;
+}
+
+void ReflectInvokeJavaMethodFromArrayArgsVoid(MObject *mObj, const MMethod &methodObject,
+                                              const MArray *argsArrayObj, uint8_t numFrames) {
+  (void)InvokeJavaMethodFromArrayArgs<int32_t>(mObj, methodObject, argsArrayObj, numFrames);
+}
+
+MObject *ReflectInvokeJavaMethodFromArrayArgsJobject(MObject *mObj, const MMethod &methodObject,
+                                                     const MArray *argsArrayObj, uint8_t numFrames) {
+  return reinterpret_cast<MObject*>(
+      InvokeJavaMethodFromArrayArgs<jobject>(mObj, methodObject, argsArrayObj, numFrames));
+}
+
+MObject *ReflectMethodInvoke(const MMethod &methodObject, MObject *mObj, const MArray *argsObj, uint8_t frames) {
+  MObject *retObj = nullptr;
+  jvalue retJvalue;
+  retJvalue.l = 0UL;
+  char returnTypeName = methodObject.GetMethodMeta()->GetReturnPrimitiveType();
+  switch (returnTypeName) {
+    case 'V':
+      (void)InvokeJavaMethodFromArrayArgs<int32_t>(mObj, methodObject, argsObj, frames);
+      break;
+    case 'Z':
+      retJvalue.z = InvokeJavaMethodFromArrayArgs<uint8_t>(mObj, methodObject, argsObj, frames);
+      retObj = primitiveutil::BoxPrimitiveJboolean(retJvalue.z);
+      break;
+    case 'I':
+      retJvalue.i = InvokeJavaMethodFromArrayArgs<int32_t>(mObj, methodObject, argsObj, frames);
+      retObj = primitiveutil::BoxPrimitiveJint(retJvalue.i);
+      break;
+    case 'B':
+      retJvalue.b = InvokeJavaMethodFromArrayArgs<int8_t>(mObj, methodObject, argsObj, frames);
+      retObj = primitiveutil::BoxPrimitiveJbyte(retJvalue.b);
+      break;
+    case 'C':
+      retJvalue.c = InvokeJavaMethodFromArrayArgs<uint16_t>(mObj, methodObject, argsObj, frames);
+      retObj = primitiveutil::BoxPrimitiveJchar(retJvalue.c);
+      break;
+    case 'D':
+      retJvalue.d = InvokeJavaMethodFromArrayArgs<double>(mObj, methodObject, argsObj, frames);
+      retObj = primitiveutil::BoxPrimitiveJdouble(retJvalue.d);
+      break;
+    case 'F':
+      retJvalue.f = InvokeJavaMethodFromArrayArgs<float>(mObj, methodObject, argsObj, frames);
+      retObj = primitiveutil::BoxPrimitiveJfloat(retJvalue.f);
+      break;
+    case 'J':
+      retJvalue.j = InvokeJavaMethodFromArrayArgs<int64_t>(mObj, methodObject, argsObj, frames);
+      retObj = primitiveutil::BoxPrimitiveJlong(retJvalue.j);
+      break;
+    case 'S':
+      retJvalue.s = InvokeJavaMethodFromArrayArgs<int16_t>(mObj, methodObject, argsObj, frames);
+      retObj = primitiveutil::BoxPrimitiveJshort(retJvalue.s);
+      break;
+    default:
+      retObj = reinterpret_cast<MObject*>(InvokeJavaMethodFromArrayArgs<jobject>(mObj, methodObject, argsObj, frames));
+  }
+  if (UNLIKELY(MRT_HasPendingException())) {
+    RC_LOCAL_DEC_REF(retObj);
+    return nullptr;
+  }
+  return retObj;
+}
+
+char *MRT_ReflectGetMethodName(jmethodID methodMeta) {
+  MethodMeta *method = MethodMeta::JniCastNonNull(methodMeta);
+  return method->GetName();
+}
+
+char *MRT_ReflectGetMethodSig(jmethodID methodMeta) {
+  MethodMeta *method = MethodMeta::JniCastNonNull(methodMeta);
+  return method->GetSignature();
+}
+
+jint MRT_ReflectGetMethodArgsize(jmethodID methodMeta) {
+  MethodMeta *method = MethodMeta::JniCastNonNull(methodMeta);
+  return method->GetArgSize();
+}
+
+jboolean MRT_ReflectMethodIsStatic(jmethodID methodMeta) {
+  MethodMeta *method = MethodMeta::JniCastNonNull(methodMeta);
+  return method->IsStatic();
+}
+
+jboolean MRT_ReflectMethodIsConstructor(jmethodID methodMeta) {
+  MethodMeta *method = MethodMeta::JniCastNonNull(methodMeta);
+  return method->IsConstructor();
+}
+
+void MRT_ReflectGetMethodArgsType(const char *signame, const jint argSize, char *shorty) {
+  MethodMeta::GetShortySignature(signame, shorty, static_cast<const uint32_t>(argSize));
+}
+
+template<typename T>
+static T InvokeJavaMethodFromJvalue(MObject *obj, const MethodMeta *methodMeta, const jvalue *args,
+                                    uintptr_t calleeFuncAddr = 0) {
+  if (UNLIKELY(methodMeta->IsAbstract() && (obj != nullptr))) {
+    char *methodName = methodMeta->GetName();
+    char *sigName = methodMeta->GetSignature();
+    methodMeta = obj->GetClass()->GetMethod(methodName, sigName);
+  }
+
+  DCHECK(methodMeta != nullptr) << "method must not be nullptr!" << maple::endl;
+  T result = methodMeta->Invoke<T, calljavastubconst::kJvalue>(obj, args, calleeFuncAddr);
+  // Interpreter should skip MRT_HasPendingException
+  // and handle exception in the place where ExecuteSwitchImplCpp.
+  if (UNLIKELY(!methodMeta->NeedsInterp() && MRT_HasPendingException())) {
+    return 0;
+  }
+  return result;
+}
+
+void MRT_ReflectInvokeMethodAvoid(jobject obj, const jmethodID methodMeta, const jvalue *args) {
+  (void)InvokeJavaMethodFromJvalue<int>(
+      MObject::JniCast(obj), MethodMeta::JniCastNonNull(methodMeta), args);
+}
+
+void MRT_ReflectInvokeMethodAZvoid(jobject obj, const jmethodID methodMeta, const jvalue *args,
+                                   uintptr_t calleeFuncAddr) {
+  (void)InvokeJavaMethodFromJvalue<int>(
+      MObject::JniCast(obj), MethodMeta::JniCastNonNull(methodMeta), args, calleeFuncAddr);
+}
+
+#define MRT_REFLECT_INVOKE_A(TYPE) \
+TYPE MRT_ReflectInvokeMethodA##TYPE(jobject obj, const jmethodID methodMeta, const jvalue *args) { \
+  return (TYPE)InvokeJavaMethodFromJvalue<TYPE>( \
+    MObject::JniCast(obj), MethodMeta::JniCastNonNull(methodMeta), args);}
+
+#define MRT_REFLECT_INVOKE_AZ(TYPE) \
+TYPE MRT_ReflectInvokeMethodAZ##TYPE(jobject obj, const jmethodID methodMeta, const jvalue *args, \
+                                     uintptr_t calleeFuncAddr) { \
+  return (TYPE)InvokeJavaMethodFromJvalue<TYPE>( \
+    MObject::JniCast(obj), MethodMeta::JniCastNonNull(methodMeta), args, calleeFuncAddr);}
+
+#define TRIPLE_MRT_REFLECT_INVOKE(TYPE) \
+MRT_REFLECT_INVOKE_A(TYPE) \
+MRT_REFLECT_INVOKE_AZ(TYPE)
+
+TRIPLE_MRT_REFLECT_INVOKE(jboolean)
+TRIPLE_MRT_REFLECT_INVOKE(jbyte)
+TRIPLE_MRT_REFLECT_INVOKE(jchar)
+TRIPLE_MRT_REFLECT_INVOKE(jint)
+TRIPLE_MRT_REFLECT_INVOKE(jlong)
+TRIPLE_MRT_REFLECT_INVOKE(jobject)
+TRIPLE_MRT_REFLECT_INVOKE(jshort)
+TRIPLE_MRT_REFLECT_INVOKE(jfloat)
+TRIPLE_MRT_REFLECT_INVOKE(jdouble)
+
+jobject MRT_ReflectMethodGetDefaultValue(jobject methodObj) {
+  MMethod *methodObject = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = methodObject->GetMethodMeta();
+  MClass *declClass = methodMeta->GetDeclaringClass();
+  if (!modifier::IsAnnotation(declClass->GetModifier())) {
+    return nullptr;
+  }
+
+  string annoStr = declClass->GetAnnotation();
+  if (annoStr.empty()) {
+    return nullptr;
+  }
+  AnnoParser &parser = AnnoParser::ConstructParser(annoStr.c_str(), declClass);
+  std::unique_ptr<AnnoParser> uniqueParser(&parser);
+  int32_t loc = uniqueParser->Find(uniqueParser->GetAnnoDefaultStr());
+  if (loc == annoconstant::kNPos) {
+    return nullptr;
+  }
+  MethodDefaultUtil mthDefaultUtil(*methodMeta, declClass);
+  if (!MethodDefaultUtil::HasDefaultValue(methodMeta->GetName(), *uniqueParser)) {
+    return nullptr;
+  }
+  return mthDefaultUtil.GetDefaultValue(uniqueParser)->AsJobject();
+}
+
+jobject MRT_ReflectMethodGetAnnotationNative(jobject executable, jint index, jclass annoClass) {
+  MMethod *methodObject = MMethod::JniCastNonNull(executable);
+  MethodMeta *methodMeta = methodObject->GetMethodMeta();
+  string executableAnnoStr = methodMeta->GetAnnotation();
+  if (executableAnnoStr.empty()) {
+    return nullptr;
+  }
+  string annoStr = AnnoParser::GetParameterAnnotationInfo(executableAnnoStr);
+  VLOG(reflect) << "Enter MRT_ReflectMethodGetAnnotationNative, annostr: " << annoStr << maple::endl;
+  AnnoParser &annoParser = AnnoParser::ConstructParser(annoStr.c_str(), methodMeta->GetDeclaringClass());
+  std::unique_ptr<AnnoParser> parser(&annoParser);
+  return parser->GetAnnotationNative(index, MClass::JniCast(annoClass))->AsJobject();
+}
+
+jmethodID MRT_ReflectFromReflectedMethod(jobject methodObj) {
+  MMethod *mMethod = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = mMethod->GetMethodMeta();
+  return methodMeta->AsJmethodID();
+}
+
+jobject MRT_ReflectToReflectedMethod(jclass clazz __attribute__((unused)), jmethodID methodMeta) {
+  MethodMeta *method = MethodMeta::JniCastNonNull(methodMeta);
+  MMethod *mMethod = MMethod::NewMMethodObject(*method);
+  return mMethod->AsJobject();
+}
+
+void MRT_ReflectMethodForward(jobject from, jobject to) {
+  MethodMeta *methodFrom = MMethod::JniCastNonNull(from)->GetMethodMeta();
+  MethodMeta *methodTo = MMethod::JniCastNonNull(to)->GetMethodMeta();
+  if (LinkerAPI::Instance().UpdateMethodSymbolAddress(methodFrom->AsJmethodID(), methodTo->GetFuncAddress())) {
+    methodFrom->SetAddress(methodTo->GetFuncAddress());
+  }
+}
+
+jobject MRT_ReflectMethodClone(jobject methodObj) {
+  MMethod *mMethod = MMethod::JniCastNonNull(methodObj);
+  MethodMeta *methodMeta = mMethod->GetMethodMeta();
+
+  MethodMeta *newMeta = MethodMeta::Cast(MRT_AllocFromMeta(sizeof(MethodMeta), kMethodMetaData));
+  // force to be direct method, this method will NOT be discarded in InvokeJavaMethodFromArrayArgs()
+  newMeta->SetMod(methodMeta->GetMod() | modifier::kModifierPrivate);
+  newMeta->SetName(methodMeta->GetName());
+  newMeta->SetSignature(methodMeta->GetSignature());
+  newMeta->SetAddress(methodMeta->GetFuncAddress());
+  newMeta->SetDeclaringClass(*methodMeta->GetDeclaringClass());
+  newMeta->SetFlag(methodMeta->GetFlag());
+  newMeta->SetArgsSize(methodMeta->GetArgSize());
+  return MMethod::NewMMethodObject(*newMeta)->AsJobject();
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_reflection_proxy.cpp b/src/mrt/maplert/src/mrt_reflection_proxy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..da0bcbf8f52c066789bb8a4ca09372e4b88e908c
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_reflection_proxy.cpp
@@ -0,0 +1,592 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_reflection_proxy.h"
+#include <algorithm>
+#include <securec.h>
+#include "itab_util.h"
+#include "mclass_inline.h"
+#include "mstring_inline.h"
+#include "mmethod_inline.h"
+#include "methodmeta_inline.h"
+#include "exception/mrt_exception.h"
+#include "mrt_reflection_stubfuncforproxy.def"
+#ifdef USE_32BIT_REF
+using VOID_PTR = uint32_t;
+#else
+using VOID_PTR = uint64_t;
+#endif
+
+using namespace maple;
+namespace maplert {
+MethodMeta *GetProxySuperMethod(const MObject &obj, uint32_t num);
+jvalue ProcessProxyMethodInvoke(MObject &obj, const MethodMeta &proxySuperMethod, jvalue args[]);
+MObject *InvokeInvocationHandler(MObject &obj, jvalue args[], const MethodMeta &proxySuperMethod);
+void DoProxyThrowableException(const MObject &proxyObj, const MObject &exceptionObj, const MethodMeta &method);
+extern "C"
+int64_t EnterProxyMethodInvoke(intptr_t *stack, uint32_t num) {
+  // this proxy object always put index 0
+  CHECK(stack != nullptr);
+  MObject *obj = reinterpret_cast<MObject*>(stack[0]);
+  CHECK(obj != nullptr);
+  MethodMeta *proxySuperMethod = GetProxySuperMethod(*obj, num);
+  CHECK(proxySuperMethod != nullptr) << "proxySuperMethod return nullptr." << maple::endl;
+  jvalue ret;
+  ret.j = 0L;
+  {
+    DecodeStackArgs stackArgs(stack);
+    std::string prefix("L");
+    proxySuperMethod->BuildJValuesArgsFromStackMemeryPrefixSigNature(stackArgs, prefix);
+    ret = ProcessProxyMethodInvoke(*obj, *proxySuperMethod, &(stackArgs.GetData()[prefix.length()]));
+  }
+  if (MRT_HasPendingException()) {
+    MRT_CheckThrowPendingExceptionUnw();
+    return ret.j;
+  }
+  return ret.j;
+}
+
+jvalue ProcessProxyMethodInvoke(MObject &obj, const MethodMeta &proxySuperMethod, jvalue args[]) {
+  ScopedHandles sHandles;
+  jvalue retValue;
+  retValue.l = 0UL;
+  MObject *value = InvokeInvocationHandler(obj, args, proxySuperMethod);
+  ObjHandle<MObject> valueRef(value);
+  if (UNLIKELY(MRT_HasPendingException())) {
+    ObjHandle<MObject> th(MRT_PendingException());
+    DoProxyThrowableException(obj, *(th()), proxySuperMethod);
+    return retValue;
+  }
+  char retPrimitiveType = proxySuperMethod.GetReturnPrimitiveType();
+  switch (retPrimitiveType) {
+    case 'V':
+      return retValue;
+    case 'L':
+    case '[': {
+      MClass *retType = proxySuperMethod.GetReturnType();
+      if (retType == nullptr) {
+        return retValue;
+      }
+      if (valueRef() != 0 && !valueRef->IsInstanceOf(*retType)) {
+        MRT_ThrowNewException("java/lang/ClassCastException", nullptr);
+        return retValue;
+      }
+      retValue.l = valueRef.ReturnJObj();
+      return retValue;
+    }
+    default: { // primitive value
+      if (UNLIKELY(valueRef() == 0)) {
+        MRT_ThrowNewException("java/lang/NullPointerException", nullptr);
+        return retValue;
+      }
+      if (!primitiveutil::IsBoxObject(*value, retPrimitiveType)) {
+        MRT_ThrowNewException("java/lang/ClassCastException", nullptr);
+        return retValue;
+      }
+      bool success = primitiveutil::UnBoxPrimitive(*value, retValue);
+      if (!success) {
+        MRT_ThrowNewException("java/lang/ClassCastException", nullptr);
+        return retValue;
+      }
+      return retValue;
+    }
+  }
+}
+
+static void ThrowUndeclaredThrowableException(const MObject &exceptionObj) {
+  MRT_ClearPendingException();
+  MClass *exceptionClass = WellKnown::GetMClassUndeclaredThrowableException();
+  MethodMeta *exceptionConstruct = exceptionClass->GetDeclaredConstructor("(Ljava/lang/Throwable;)V");
+  DCHECK(exceptionConstruct != nullptr) << "exception Construct nullptr." << maple::endl;
+  MObject *exceptionInstance = MObject::NewObject(*exceptionClass, exceptionConstruct, &exceptionObj);
+  if (UNLIKELY(exceptionInstance == nullptr)) {
+    return;
+  }
+  MRT_ThrowExceptionSafe(exceptionInstance->AsJobject());
+  RC_LOCAL_DEC_REF(exceptionInstance);
+  return;
+}
+
+void DoProxyThrowableException(const MObject &proxyObj, const MObject &exceptionObj, const MethodMeta &method) {
+  if (exceptionObj.IsInstanceOf(*WellKnown::GetMClassError()) ||
+      exceptionObj.IsInstanceOf(*WellKnown::GetMClassRuntimeException())) {
+    return;
+  }
+  ScopedHandles sHandles;
+  MClass *proxyCls = proxyObj.GetClass();
+  char *methodName = method.GetName();
+  char *methodSig = method.GetSignature();
+  MClass **superClassArray = proxyCls->GetSuperClassArray();
+  DCHECK(superClassArray != nullptr) << "Proxy Cls super class array nullptr." << maple::endl;
+  uint32_t numofsuper = proxyCls->GetNumOfSuperClasses();
+  uint32_t assignableNum = 0;
+  uint32_t duplicatedMethodNum = 0;
+  for (uint32_t i = 1; i < numofsuper; ++i) {
+    MClass *interfaceclass = MClass::ResolveSuperClass(&superClassArray[i]);
+    MethodMeta *methodMeta = interfaceclass->GetDeclaredMethod(methodName, methodSig);
+    if (methodMeta != nullptr) {
+      ++duplicatedMethodNum;
+      std::vector<MClass*> types;
+      methodMeta->GetExceptionTypes(types);
+      bool isCurrentAssignable = false;
+      size_t numOfException = types.size();
+      for (size_t j = 0; j < numOfException; ++j) {
+        MClass *decExCls = types[j];
+        if (exceptionObj.IsInstanceOf(*decExCls)) {
+          isCurrentAssignable = true;
+          break;
+        }
+      }
+      if (isCurrentAssignable == true) {
+        ++assignableNum;
+      }
+    }
+  }
+  if (assignableNum != duplicatedMethodNum) {
+    ThrowUndeclaredThrowableException(exceptionObj);
+  }
+  return;
+}
+
+static MethodMeta *GetHandlerInvokeMethod(const MClass &handlerClass) {
+  MethodMeta *invokeMethod = handlerClass.GetMethod("invoke",
+      "(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;");
+  if (UNLIKELY(invokeMethod == nullptr || (invokeMethod->GetFuncAddress() == 0))) {
+    std::string msg = "No Method: jobject invoke(Object, Method, Object[]) in class ";
+    msg += handlerClass.GetName();
+    msg += " or super class";
+    MRT_ThrowNewException("java/lang/NoSuchMethodError", msg.c_str());
+    return nullptr;
+  }
+  return invokeMethod;
+}
+
+static MethodMeta *GetSuperMethod(const MethodMeta &srcMethod, const MClass &proxyClass) {
+  MethodMeta *superMethod = nullptr;
+  char *methodName = srcMethod.GetName();
+  char *methodSig = srcMethod.GetSignature();
+  MClass *objectClass = WellKnown::GetMClassObject();
+  if (!strcmp("equals", methodName) && !strcmp("(Ljava/lang/Object;)Z", methodSig)) {
+    superMethod = objectClass->GetDeclaredMethod(methodName, methodSig);
+  } else if (!strcmp("hashCode", methodName) && !strcmp("()I", methodSig)) {
+    superMethod = objectClass->GetDeclaredMethod(methodName, methodSig);
+  } else if (!strcmp("toString", methodName) && !strcmp("()Ljava/lang/String;", methodSig)) {
+    superMethod = objectClass->GetDeclaredMethod(methodName, methodSig);
+  } else {
+    MClass **superClassArray = proxyClass.GetSuperClassArray();
+    CHECK(superClassArray != nullptr) << "Super Class Array is nullptr in proxy class." << maple::endl;
+    uint32_t numofsuper = proxyClass.GetNumOfSuperClasses();
+    for (uint32_t i = 1; i < numofsuper; ++i) {
+      MClass *interfaceclass = MClass::ResolveSuperClass(&superClassArray[i]);
+      MethodMeta *method = interfaceclass->GetMethod(methodName, methodSig);
+      if (method != nullptr) {
+        superMethod = method;
+        break;
+      }
+    }
+  }
+  return superMethod;
+}
+
+MethodMeta *GetProxySuperMethod(const MObject &obj, uint32_t num) {
+  MClass *proxyClass = obj.GetClass();
+  MethodMeta *proxyMethod = &(proxyClass->GetMethodMetas()[num]);
+  MethodMeta *superMethod = GetSuperMethod(*proxyMethod, *proxyClass);
+  return superMethod;
+}
+
+MObject *InvokeInvocationHandler(MObject &obj, jvalue args[], const MethodMeta &proxySuperMethod) {
+  ScopedHandles sHandles;
+  FieldMeta *hfield = WellKnown::GetMClassProxy()->GetDeclaredField("h");
+  CHECK(hfield != nullptr) << "Can't find h field in proxy class." << maple::endl;
+  ObjHandle<MObject> hobj(hfield->GetObjectValue(&obj));
+  CHECK(hobj() != 0) << "proxy's h field is nullptr." << maple::endl;
+  MethodMeta *invokeMethod = GetHandlerInvokeMethod(*(hobj()->GetClass()));
+  if (invokeMethod == nullptr) {
+    return nullptr;
+  }
+
+  uint32_t parameterSize = proxySuperMethod.GetParameterCount();
+  MArray *arrayP = nullptr;
+  if (parameterSize > 0) {
+    arrayP = MArray::NewObjectArray(parameterSize, *WellKnown::GetMClassAObject());
+    CHECK(arrayP != nullptr) << "NewObjectArray return nullptr." << maple::endl;
+    proxySuperMethod.BuildMArrayArgsFromJValues(*arrayP, args);
+  }
+  ObjHandle<MArray> arrayPRef(arrayP);
+  ObjHandle<MObject> interfaceMethodObj(MMethod::NewMMethodObject(proxySuperMethod));
+  jvalue methodArgs[3]; // invokeMethod has 3 args
+  methodArgs[0].l = reinterpret_cast<jobject>(&obj);
+  methodArgs[1].l = interfaceMethodObj.AsJObj();
+  methodArgs[2].l = arrayPRef.AsJObj();
+  jobject retvalue = invokeMethod->Invoke<jobject, calljavastubconst::ArgsType::kJvalue>(hobj(), methodArgs);
+  return reinterpret_cast<MObject*>(retvalue);
+}
+
+static void SortMethodFromProxyClassbyName(MClass &proxyCls, std::vector<MethodMeta*> &objectMethod) {
+  uint32_t numOfMethods = proxyCls.GetNumOfMethods();
+  MethodMeta *objectMethods = proxyCls.GetMethodMetas();
+  DCHECK(objectMethods != nullptr) << "GetMethodMetas() fail in SortMethodFromProxyClassbyName." << maple::endl;
+  for (uint32_t i = 0; i < numOfMethods; ++i) {
+    objectMethod.push_back(&objectMethods[i]);
+  }
+
+  std::sort(objectMethod.begin(), objectMethod.end(), [](MethodMeta *a, MethodMeta *b) {
+    char *nameA = a->GetName();
+    std::string sa(nameA);
+    char *nameB = b->GetName();
+    std::string sb(nameB);
+    return sa < sb;
+  });
+}
+
+static void GenProxyVtab(MClass &proxyCls, MArray &methods) {
+  const uint32_t numVMethodsObjectVtab = 11; // 11 is number of methods in objectVtab
+  MClass *objectMClass = WellKnown::GetMClassObject();
+  const static int16_t equalsVtabSlot = objectMClass->GetMethod("equals", "(Ljava/lang/Object;)Z")->GetVtabIndex();
+  const static int16_t hashCodeVtabSlot = objectMClass->GetMethod("hashCode", "()I")->GetVtabIndex();
+  const static int16_t toStringVtabSlot = objectMClass->GetMethod("toString", "()Ljava/lang/String;")->GetVtabIndex();
+  uint32_t numVirtualMethods = methods.GetLength();
+  auto vtab  = reinterpret_cast<VOID_PTR*>(calloc(numVMethodsObjectVtab + numVirtualMethods, sizeof(VOID_PTR)));
+  CHECK(vtab != nullptr) << "calloc fail in GenProxyVtab." << maple::endl;
+  if (vtab == nullptr) {
+    return;
+  }
+
+  uint32_t vtabCnt = 0;
+  auto objectVtab = reinterpret_cast<VOID_PTR*>(objectMClass->GetVtab());
+  DCHECK(objectVtab != nullptr) << "object Vtab is nullptr." << maple::endl;
+  for (uint32_t i = 0; i < numVMethodsObjectVtab; ++i) {
+    vtab[i] = objectVtab[i];
+  }
+  vtabCnt += numVMethodsObjectVtab;
+
+  std::vector<MethodMeta*> proxyMethods;
+  SortMethodFromProxyClassbyName(proxyCls, proxyMethods);
+  for (auto it = proxyMethods.begin(); it != proxyMethods.end(); ++it) {
+    MethodMeta *method = *it;
+    char *methodName = method->GetName();
+    char *sigName = method->GetSignature();
+    uintptr_t address = method->GetFuncAddress();
+    if (!strcmp("equals", methodName) && !strcmp("(Ljava/lang/Object;)Z", sigName)) {
+      vtab[equalsVtabSlot] = static_cast<VOID_PTR>(address);
+      continue;
+    } else if (!strcmp("hashCode", methodName) && !strcmp("()I", sigName)) {
+      vtab[hashCodeVtabSlot] = static_cast<VOID_PTR>(address);
+      continue;
+    } else if (!strcmp("toString", methodName) && !strcmp("()Ljava/lang/String;", sigName)) {
+      vtab[toStringVtabSlot] = static_cast<VOID_PTR>(address);
+      continue;
+    }
+    vtab[vtabCnt++] = static_cast<VOID_PTR>(address);
+  }
+  proxyCls.SetVtable(reinterpret_cast<uintptr_t>(vtab));
+}
+
+static void SortMethodWithHashCode(std::vector<MethodMeta*> &methodVec) {
+  std::sort(methodVec.begin(), methodVec.end(), [](const MethodMeta *a, const MethodMeta *b) {
+    uint16_t hashCodeA = a->GetHashCode();
+    uint32_t hashCodeB = b->GetHashCode();
+    if (a->IsFinalizeMethod() && !b->IsFinalizeMethod()) {
+      return false;
+    }
+    if (!a->IsFinalizeMethod() && b->IsFinalizeMethod()) {
+      return true;
+    }
+    return hashCodeA < hashCodeB;
+  });
+}
+
+static void GenProxyConstructor(MClass &proxyCls, MethodMeta &proxyClsMth, MethodMeta &constructor) {
+  char *mthMethodName = constructor.GetName();
+  MethodSignature *mthSig = constructor.GetMethodSignature();
+  uint32_t modifier = (constructor.GetMod() & (~modifier::kModifierProtected)) | modifier::kModifierPublic;
+  proxyClsMth.FillMethodMeta(false, mthMethodName, mthSig, constructor.GetAnnotationRaw(),
+                             constructor.GetVtabIndex(), proxyCls,
+                             reinterpret_cast<uintptr_t>(constructor.GetFuncAddress()),
+                             modifier, constructor.GetFlag(), constructor.GetArgSize());
+}
+
+static uintptr_t FillItab(const std::map<unsigned long, std::pair<unsigned long, std::string>> &itabMap,
+                          const std::vector<std::pair<unsigned long, std::string>> &itabConflictVector,
+                          const std::map<unsigned long, std::pair<unsigned long, std::string>> &itabSecondMap,
+                          const std::vector<std::pair<unsigned long, std::string>> &itabSecondConflictVector) {
+  size_t size1 = itabConflictVector.size();
+  size_t itabSecondMapSize = itabSecondMap.size();
+  size_t itabSecondConflictSize = itabSecondConflictVector.size();
+  unsigned long itabSize = 0;
+  if (size1 == 0) {
+    itabSize = kItabFirstHashSize;
+  } else {
+    // 1 is first tab, 2 is second tab, * 2 for hash value and methods adress in second tab,
+    // itabSecondConflict * 2 name and signature, function addr
+    itabSize = kItabFirstHashSize + 1 + 2 + itabSecondMapSize * 2 + itabSecondConflictSize * 2;
+  }
+  VOID_PTR *itab = reinterpret_cast<VOID_PTR*>(MRT_AllocFromMeta(itabSize * sizeof(VOID_PTR), kITabMetaData));
+  for (auto item : itabMap) {
+    if (item.second.first == 1) {
+      continue;
+    }
+    *(itab + item.first) = item.second.first;
+  }
+  if (size1 != 0) {
+    unsigned long tmp = reinterpret_cast<unsigned long>(itab + kItabFirstHashSize + 1);
+    *(itab + kItabFirstHashSize) = tmp;
+  }
+  uint32_t index = 0;
+  if (size1 != 0) {
+    index = kItabFirstHashSize + 1;
+#ifdef USE_32BIT_REF
+    uint64_t shiftCountBit = 4 * 4;
+#else
+    uint64_t shiftCountBit = 8 * 4;
+#endif
+    itab[index++] = ((itabSecondConflictSize | (1UL << (shiftCountBit - 1))) << shiftCountBit) + itabSecondMapSize;
+    itab[index++] = 1;
+    for (auto item : itabSecondMap) {
+      itab[index++] = item.first;
+      itab[index++] = item.second.first;
+    }
+    for (auto item : itabSecondConflictVector) {
+      std::string methodName = item.second;
+      size_t len = methodName.length() + 1;
+      char *name = reinterpret_cast<char*>(MRT_AllocFromMeta(len, kNativeStringData));
+      if (strcpy_s(name, len, methodName.c_str()) != EOK) {
+        LOG(FATAL) << "FillItab strcpy_s() not return 0" << maple::endl;
+        return 0;
+      }
+      itab[index++] = reinterpret_cast<uintptr_t>(name);
+      itab[index++] = item.first;
+    }
+  }
+  return reinterpret_cast<uintptr_t>(itab);
+}
+
+static uintptr_t GenProxyItab(const std::map<unsigned long, std::pair<unsigned long, std::string>> itabMap,
+                              std::vector<std::pair<unsigned long, std::string>> itabConflictVector) {
+  size_t size1 = itabConflictVector.size();
+  std::map<unsigned long, std::pair<unsigned long, std::string>> itabSecondMap;
+  std::vector<std::pair<unsigned long, std::string>> itabSecondConflictVector;
+  if (size1 != 0) {
+    for (auto item :itabConflictVector) {
+      std::string methodName = item.second;
+      unsigned long hashIdex = GetSecondHashIndex(methodName.c_str());
+      if (itabSecondMap.find(hashIdex) == itabSecondMap.end()) {
+        std::pair<unsigned long, std::pair<unsigned long, std::string> > hashPair(hashIdex, item);
+        itabSecondMap.insert(hashPair);
+      } else {
+        if (itabSecondMap[hashIdex].first == 1) {
+          itabSecondConflictVector.push_back(item);
+        } else {
+          itabSecondConflictVector.push_back(item);
+          auto oldItem = itabSecondMap[hashIdex];
+          itabSecondConflictVector.push_back(oldItem);
+          itabSecondMap[hashIdex].first = 1;
+        }
+      }
+    }
+  }
+  return FillItab(itabMap, itabConflictVector, itabSecondMap, itabSecondConflictVector);
+}
+
+static void ResolveConstructHashConflict(MethodMeta &constructor, std::vector<MethodMeta*> &methodVec,
+                                         std::vector<MethodMeta*> &methodHashConflict) {
+  bool isConflict = false;
+  for (auto it = methodVec.begin(); it != methodVec.end(); ++it) {
+    MethodMeta *methodMeta = *it;
+    if ((methodMeta != &constructor) && ((methodMeta->GetHashCode() == constructor.GetHashCode()) ||
+        (methodMeta->GetHashCode() == modifier::kHashConflict))) {
+      if (isConflict == false) {
+        methodHashConflict.push_back(&constructor);
+        isConflict = true;
+      }
+      methodHashConflict.push_back(methodMeta);
+    }
+  }
+
+  for (auto methodConflict : methodHashConflict) {
+    auto it = std::find(methodVec.begin(), methodVec.end(), methodConflict);
+    if (it != methodVec.end()) {
+      methodVec.erase(it);
+    }
+  }
+}
+
+static void ReomveRepeatMethod(const MArray &methodsArray, std::vector<MethodMeta*> &methodVec, uint32_t &rmNum) {
+  uint32_t numMethods = methodsArray.GetLength();
+  for (uint32_t i = numMethods; i > 0; --i) {
+    MMethod *method = methodsArray.GetObjectElementNoRc(i - 1)->AsMMethod();
+    if (method == nullptr) {
+      continue;
+    }
+    MethodMeta *methodMeta = method->GetMethodMeta();
+    char *signature = methodMeta->GetSignature();
+    char *name = methodMeta->GetName();
+    bool hasGen = false;
+    for (auto it = methodVec.begin(); it != methodVec.end(); ++it) {
+      MethodMeta *temp = *it;
+      if (!strcmp(signature, temp->GetSignature()) && !strcmp(name, temp->GetName())) {
+        hasGen = true;
+        break ;
+      }
+    }
+    if (hasGen) {
+      ++rmNum;
+      continue;
+    }
+    methodVec.push_back(methodMeta);
+  }
+}
+
+static void GenProxyMethod(const MClass &proxyCls, MethodMeta &proxyClsMth, const MethodMeta &mobj,
+                           const uint32_t &currentNum,
+                           std::map<unsigned long, std::pair<unsigned long, std::string>> &itabMap,
+                           std::vector<std::pair<unsigned long, std::string>> &itabConflictVector) {
+  constexpr uint32_t kRemoveFlags = modifier::kModifierAbstract | modifier::kModifierDefault;
+  constexpr uint32_t kAddFlags = modifier::kModifierFinal;
+  char *methodName = mobj.GetName();
+  MethodSignature *mthSig = mobj.GetMethodSignature();
+  char *sigName = mobj.GetSignature();
+  std::string innerMethodname = std::string(methodName) + "|" + std::string(sigName);
+  unsigned long hashIdex = GetHashIndex(innerMethodname.c_str());
+  auto address = reinterpret_cast<uintptr_t>(gstubfunc[currentNum]);
+  uint32_t modifier = (mobj.GetMod() & (~kRemoveFlags)) | kAddFlags;
+  proxyClsMth.FillMethodMeta(false, methodName, mthSig, mobj.GetAnnotationRaw(),
+                             mobj.GetVtabIndex(), proxyCls, address, modifier,
+                             mobj.GetFlag(), mobj.GetArgSize());
+  std::pair<unsigned long, std::string> addressPair(address, innerMethodname);
+  auto hasExist = itabMap.find(hashIdex);
+  if (hasExist != itabMap.end()) {
+    // conflict
+    if (hasExist->second.first == 1) {
+      itabConflictVector.push_back(addressPair);
+    } else {
+      auto tmp = hasExist->second;
+      itabConflictVector.push_back(tmp);
+      hasExist->second.first = 1;
+      itabConflictVector.push_back(addressPair);
+    }
+  } else {
+    std::pair<unsigned long, std::pair<unsigned long, std::string>> hashcodePair(hashIdex, addressPair);
+    itabMap.insert(hashcodePair);
+  }
+}
+
+static void GenProxyMethodAndConstructor(MClass &proxyCls, MethodMeta *&proxyClsMth, uint32_t &currentNum,
+                                         std::vector<MethodMeta*> &methodVec,
+                                         std::map<unsigned long, std::pair<unsigned long, std::string>> &itabMap,
+                                         std::vector<std::pair<unsigned long, std::string>> &itabConflictVector,
+                                         bool isConflictVector) {
+  for (auto mobj : methodVec) {
+    if (mobj->IsConstructor()) {
+      GenProxyConstructor(proxyCls, *proxyClsMth, *mobj);
+    } else {
+      GenProxyMethod(proxyCls, *proxyClsMth, *mobj, currentNum, itabMap, itabConflictVector);
+    }
+    if (isConflictVector) {
+      proxyClsMth->SetHashCode(modifier::kHashConflict);
+    }
+    ++currentNum;
+    ++proxyClsMth;
+  }
+}
+
+static void GenerateProxyMethods(MClass &proxyCls, MArray &methods) {
+  uint32_t currentNum = 0;
+  const uint32_t numDirectMethods = 1; // for constructor
+  uint32_t numVirtualMethods = methods.GetLength();
+  uint32_t methodNumSum = numVirtualMethods + numDirectMethods;
+  uint32_t rmNum = 0;
+  if (methodNumSum > kSupportMaxInterfaceMethod) {
+    LOG(FATAL) << " number: " << methodNumSum << maple::endl;
+  }
+
+  std::vector<MethodMeta*> methodVec;
+  ReomveRepeatMethod(methods, methodVec, rmNum);
+
+  // constructor
+  MClass *reflectProxyMCls = WellKnown::GetMClassProxy();
+  MethodMeta *constructor = reflectProxyMCls->GetDeclaredConstructor("(Ljava/lang/reflect/InvocationHandler;)V");
+  methodVec.push_back(constructor);
+  SortMethodWithHashCode(methodVec);
+  std::vector<MethodMeta*> methodHashConflict;
+  ResolveConstructHashConflict(*constructor, methodVec, methodHashConflict);
+
+  MethodMeta *proxyClsMthBase = MethodMeta::CastNonNull(MRT_AllocFromMeta(methodNumSum * sizeof(MethodMeta),
+                                                                          kMethodMetaData));
+  MethodMeta *proxyClsMth = proxyClsMthBase;
+  std::map<unsigned long, std::pair<unsigned long, std::string>> itabMap;
+  std::vector<std::pair<unsigned long, std::string>> itabConflictVector;
+
+  GenProxyMethodAndConstructor(proxyCls, proxyClsMth, currentNum, methodVec, itabMap, itabConflictVector, false);
+  GenProxyMethodAndConstructor(proxyCls, proxyClsMth, currentNum, methodHashConflict,
+                               itabMap, itabConflictVector, true);
+  uintptr_t itab = GenProxyItab(itabMap, itabConflictVector);
+  proxyCls.SetItable(itab);
+  proxyCls.SetMethods(*proxyClsMthBase);
+  proxyCls.SetNumOfMethods(methodNumSum - rmNum);
+  GenProxyVtab(proxyCls, methods);
+}
+
+static void GenerateProxyFields(MClass &proxyCls) {
+  // set proxy declaring field 0
+  proxyCls.SetNumOfFields(0);
+}
+
+jclass MRT_ReflectProxyGenerateProxy(jstring name, jobjectArray interfaces, jobject loader,
+                                     jobjectArray methods, jobjectArray throws __attribute__((unused))) {
+  MString *proxyName = MString::JniCastNonNull(name);
+  MArray *interfacesArray = MArray::JniCastNonNull(interfaces);
+  MArray *methodArray = MArray::JniCastNonNull(methods);
+  MClass *proxyCls = MClass::NewMClass();
+  std::string classNameStr = proxyName->GetChars();
+  const char *classNameStrMeta = strdup(classNameStr.c_str()); // Does not need to be free-ed. See below.
+  // Note: Why not std::string?  It is used as the name of a MClass, and it needs to be a C-style char*.
+  if (classNameStrMeta == nullptr) {
+    int myErrno = errno;
+    LOG(FATAL) << "strdup: Failed to allocate classNameStrMeta. errno: " << myErrno << maple::endl;
+    MRT_Panic();
+  }
+  proxyCls->SetName(classNameStrMeta); // This keeps classNameStrMeta alive. proxyCls is permanent.
+  constexpr uint32_t accessFlag = modifier::kModifierProxy | modifier::kModifierPublic | modifier::kModifierFinal;
+  proxyCls->SetModifier(accessFlag);
+  MClass *javaProxy = WellKnown::GetMClassProxy();
+  proxyCls->SetObjectSize(javaProxy->GetObjectSize());
+  uintptr_t gctib = reinterpret_cast<uintptr_t>(javaProxy->GetGctib());
+  proxyCls->SetGctib(gctib);
+  // proxy super class always java.lang.proxy.
+  uint32_t numOfSuper = interfacesArray->GetLength() + 1;
+  MObject **itf = reinterpret_cast<MObject**>(calloc(numOfSuper, sizeof(MObject*)));
+  CHECK(itf != nullptr) << "calloc Proxy itf fail." << maple::endl;
+  itf[0] = javaProxy;
+  // interfaces is class object which is out of heap.
+  uint32_t srcIndex = 0;
+  for (uint32_t i = 1; i < numOfSuper; ++i) {
+    itf[i] = interfacesArray->GetObjectElementOffHeap(srcIndex++);
+  }
+  proxyCls->SetSuperClassArray(reinterpret_cast<uintptr_t>(itf));
+  proxyCls->SetNumOfSuperClasses(numOfSuper);
+
+  GenerateProxyMethods(*proxyCls, *methodArray);
+  GenerateProxyFields(*proxyCls);
+  // flag 0
+  // annotation 0
+  // clinitAddr 0
+  MRT_RegisterDynamicClass(loader, *proxyCls);
+  // mark this generated class as initialized
+  proxyCls->SetInitStateRawValue(reinterpret_cast<uintptr_t>(proxyCls));
+  std::atomic_thread_fence(std::memory_order_release);
+  return proxyCls->AsJclass();
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_reflection_reference.cpp b/src/mrt/maplert/src/mrt_reflection_reference.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f81d1946313f425e7b3699fac6a9100c58802396
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_reflection_reference.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "collector/rp_base.h"
+
+namespace maplert {
+address_t MRT_ReferenceGetReferent(address_t javaThis) {
+  if (javaThis != 0) {
+    SetReferenceActive(javaThis);
+  }
+  address_t referent = MRT_LOAD_JOBJECT_INC_REFERENT(javaThis, WellKnown::kReferenceReferentOffset);
+  if (referent != 0) {
+    // Apply barrier to ensure that concurrent marking sees the referent and
+    // does not prematurely reclaim it.
+    MRT_WeakRefGetBarrier(referent);
+  }  else {
+    ClearReferenceActive(javaThis);
+  }
+  return referent;
+}
+
+void MRT_ReferenceClearReferent(address_t javaThis) {
+  bool clearResurrectWeak = false;
+  if (javaThis != 0) {
+    MClass *klass = reinterpret_cast<MObject*>(javaThis)->GetClass();
+    uint32_t classFlag = klass->GetFlag();
+    clearResurrectWeak = ((classFlag & (modifier::kClassCleaner | modifier::kClassPhantomReference)) == 0);
+  }
+  MRT_WRITE_REFERENT(javaThis, WellKnown::kReferenceReferentOffset, nullptr, clearResurrectWeak);
+}
+
+
+// Only one thread can invoke MRT_RunFinalization at same time
+// 1. Only one runFinalizationFinalizers list in system.
+// 2. Swap runFinalizationFinalizers and finalizers list two time, might cause same object finalize two times.
+void MCC_RunFinalization() __attribute__((alias("MRT_RunFinalization")));
+void MRT_RunFinalization() {
+  ReferenceProcessor::Instance().RunFinalization();
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_reflection_stubfuncforproxy.def b/src/mrt/maplert/src/mrt_reflection_stubfuncforproxy.def
new file mode 100644
index 0000000000000000000000000000000000000000..e970a18baf0b4c7decd7499d0540c97fa753e1a2
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_reflection_stubfuncforproxy.def
@@ -0,0 +1,928 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+namespace maplert {
+constexpr int kSupportMaxInterfaceMethod = 600;
+
+// this stub is defined in proxy_stub_arm.S/roxy_stub_arm64.S
+#define STUBFUNCPROXY_TYPE_NUM(TYPE, NUM) \
+extern "C" int64_t sfp_##TYPE##_##NUM();
+
+#define STUBFUNCPROXY_NUM(NUM)\
+STUBFUNCPROXY_TYPE_NUM(jlong, NUM)\
+
+STUBFUNCPROXY_NUM(0) STUBFUNCPROXY_NUM(1)
+STUBFUNCPROXY_NUM(2) STUBFUNCPROXY_NUM(3)
+STUBFUNCPROXY_NUM(4) STUBFUNCPROXY_NUM(5)
+STUBFUNCPROXY_NUM(6) STUBFUNCPROXY_NUM(7)
+STUBFUNCPROXY_NUM(8) STUBFUNCPROXY_NUM(9)
+STUBFUNCPROXY_NUM(10) STUBFUNCPROXY_NUM(11)
+STUBFUNCPROXY_NUM(12) STUBFUNCPROXY_NUM(13)
+STUBFUNCPROXY_NUM(14) STUBFUNCPROXY_NUM(15)
+STUBFUNCPROXY_NUM(16) STUBFUNCPROXY_NUM(17)
+STUBFUNCPROXY_NUM(18) STUBFUNCPROXY_NUM(19)
+STUBFUNCPROXY_NUM(20) STUBFUNCPROXY_NUM(21)
+STUBFUNCPROXY_NUM(22) STUBFUNCPROXY_NUM(23)
+STUBFUNCPROXY_NUM(24) STUBFUNCPROXY_NUM(25)
+STUBFUNCPROXY_NUM(26) STUBFUNCPROXY_NUM(27)
+STUBFUNCPROXY_NUM(28) STUBFUNCPROXY_NUM(29)
+STUBFUNCPROXY_NUM(30) STUBFUNCPROXY_NUM(31)
+STUBFUNCPROXY_NUM(32) STUBFUNCPROXY_NUM(33)
+STUBFUNCPROXY_NUM(34) STUBFUNCPROXY_NUM(35)
+STUBFUNCPROXY_NUM(36) STUBFUNCPROXY_NUM(37)
+STUBFUNCPROXY_NUM(38) STUBFUNCPROXY_NUM(39)
+STUBFUNCPROXY_NUM(40) STUBFUNCPROXY_NUM(41)
+STUBFUNCPROXY_NUM(42) STUBFUNCPROXY_NUM(43)
+STUBFUNCPROXY_NUM(44) STUBFUNCPROXY_NUM(45)
+STUBFUNCPROXY_NUM(46) STUBFUNCPROXY_NUM(47)
+STUBFUNCPROXY_NUM(48) STUBFUNCPROXY_NUM(49)
+STUBFUNCPROXY_NUM(50) STUBFUNCPROXY_NUM(51)
+STUBFUNCPROXY_NUM(52) STUBFUNCPROXY_NUM(53)
+STUBFUNCPROXY_NUM(54) STUBFUNCPROXY_NUM(55)
+STUBFUNCPROXY_NUM(56) STUBFUNCPROXY_NUM(57)
+STUBFUNCPROXY_NUM(58) STUBFUNCPROXY_NUM(59)
+STUBFUNCPROXY_NUM(60) STUBFUNCPROXY_NUM(61)
+STUBFUNCPROXY_NUM(62) STUBFUNCPROXY_NUM(63)
+STUBFUNCPROXY_NUM(64) STUBFUNCPROXY_NUM(65)
+STUBFUNCPROXY_NUM(66) STUBFUNCPROXY_NUM(67)
+STUBFUNCPROXY_NUM(68) STUBFUNCPROXY_NUM(69)
+STUBFUNCPROXY_NUM(70) STUBFUNCPROXY_NUM(71)
+STUBFUNCPROXY_NUM(72) STUBFUNCPROXY_NUM(73)
+STUBFUNCPROXY_NUM(74) STUBFUNCPROXY_NUM(75)
+STUBFUNCPROXY_NUM(76) STUBFUNCPROXY_NUM(77)
+STUBFUNCPROXY_NUM(78) STUBFUNCPROXY_NUM(79)
+STUBFUNCPROXY_NUM(80) STUBFUNCPROXY_NUM(81)
+STUBFUNCPROXY_NUM(82) STUBFUNCPROXY_NUM(83)
+STUBFUNCPROXY_NUM(84) STUBFUNCPROXY_NUM(85)
+STUBFUNCPROXY_NUM(86) STUBFUNCPROXY_NUM(87)
+STUBFUNCPROXY_NUM(88) STUBFUNCPROXY_NUM(89)
+STUBFUNCPROXY_NUM(90) STUBFUNCPROXY_NUM(91)
+STUBFUNCPROXY_NUM(92) STUBFUNCPROXY_NUM(93)
+STUBFUNCPROXY_NUM(94) STUBFUNCPROXY_NUM(95)
+STUBFUNCPROXY_NUM(96) STUBFUNCPROXY_NUM(97)
+STUBFUNCPROXY_NUM(98) STUBFUNCPROXY_NUM(99)
+STUBFUNCPROXY_NUM(100) STUBFUNCPROXY_NUM(101)
+STUBFUNCPROXY_NUM(102) STUBFUNCPROXY_NUM(103)
+STUBFUNCPROXY_NUM(104) STUBFUNCPROXY_NUM(105)
+STUBFUNCPROXY_NUM(106) STUBFUNCPROXY_NUM(107)
+STUBFUNCPROXY_NUM(108) STUBFUNCPROXY_NUM(109)
+STUBFUNCPROXY_NUM(110) STUBFUNCPROXY_NUM(111)
+STUBFUNCPROXY_NUM(112) STUBFUNCPROXY_NUM(113)
+STUBFUNCPROXY_NUM(114) STUBFUNCPROXY_NUM(115)
+STUBFUNCPROXY_NUM(116) STUBFUNCPROXY_NUM(117)
+STUBFUNCPROXY_NUM(118) STUBFUNCPROXY_NUM(119)
+STUBFUNCPROXY_NUM(120) STUBFUNCPROXY_NUM(121)
+STUBFUNCPROXY_NUM(122) STUBFUNCPROXY_NUM(123)
+STUBFUNCPROXY_NUM(124) STUBFUNCPROXY_NUM(125)
+STUBFUNCPROXY_NUM(126) STUBFUNCPROXY_NUM(127)
+STUBFUNCPROXY_NUM(128) STUBFUNCPROXY_NUM(129)
+STUBFUNCPROXY_NUM(130) STUBFUNCPROXY_NUM(131)
+STUBFUNCPROXY_NUM(132) STUBFUNCPROXY_NUM(133)
+STUBFUNCPROXY_NUM(134) STUBFUNCPROXY_NUM(135)
+STUBFUNCPROXY_NUM(136) STUBFUNCPROXY_NUM(137)
+STUBFUNCPROXY_NUM(138) STUBFUNCPROXY_NUM(139)
+STUBFUNCPROXY_NUM(140) STUBFUNCPROXY_NUM(141)
+STUBFUNCPROXY_NUM(142) STUBFUNCPROXY_NUM(143)
+STUBFUNCPROXY_NUM(144) STUBFUNCPROXY_NUM(145)
+STUBFUNCPROXY_NUM(146) STUBFUNCPROXY_NUM(147)
+STUBFUNCPROXY_NUM(148) STUBFUNCPROXY_NUM(149)
+STUBFUNCPROXY_NUM(150) STUBFUNCPROXY_NUM(151)
+STUBFUNCPROXY_NUM(152) STUBFUNCPROXY_NUM(153)
+STUBFUNCPROXY_NUM(154) STUBFUNCPROXY_NUM(155)
+STUBFUNCPROXY_NUM(156) STUBFUNCPROXY_NUM(157)
+STUBFUNCPROXY_NUM(158) STUBFUNCPROXY_NUM(159)
+STUBFUNCPROXY_NUM(160) STUBFUNCPROXY_NUM(161)
+STUBFUNCPROXY_NUM(162) STUBFUNCPROXY_NUM(163)
+STUBFUNCPROXY_NUM(164) STUBFUNCPROXY_NUM(165)
+STUBFUNCPROXY_NUM(166) STUBFUNCPROXY_NUM(167)
+STUBFUNCPROXY_NUM(168) STUBFUNCPROXY_NUM(169)
+STUBFUNCPROXY_NUM(170) STUBFUNCPROXY_NUM(171)
+STUBFUNCPROXY_NUM(172) STUBFUNCPROXY_NUM(173)
+STUBFUNCPROXY_NUM(174) STUBFUNCPROXY_NUM(175)
+STUBFUNCPROXY_NUM(176) STUBFUNCPROXY_NUM(177)
+STUBFUNCPROXY_NUM(178) STUBFUNCPROXY_NUM(179)
+STUBFUNCPROXY_NUM(180) STUBFUNCPROXY_NUM(181)
+STUBFUNCPROXY_NUM(182) STUBFUNCPROXY_NUM(183)
+STUBFUNCPROXY_NUM(184) STUBFUNCPROXY_NUM(185)
+STUBFUNCPROXY_NUM(186) STUBFUNCPROXY_NUM(187)
+STUBFUNCPROXY_NUM(188) STUBFUNCPROXY_NUM(189)
+STUBFUNCPROXY_NUM(190) STUBFUNCPROXY_NUM(191)
+STUBFUNCPROXY_NUM(192) STUBFUNCPROXY_NUM(193)
+STUBFUNCPROXY_NUM(194) STUBFUNCPROXY_NUM(195)
+STUBFUNCPROXY_NUM(196) STUBFUNCPROXY_NUM(197)
+STUBFUNCPROXY_NUM(198) STUBFUNCPROXY_NUM(199)
+STUBFUNCPROXY_NUM(200) STUBFUNCPROXY_NUM(201)
+STUBFUNCPROXY_NUM(202) STUBFUNCPROXY_NUM(203)
+STUBFUNCPROXY_NUM(204) STUBFUNCPROXY_NUM(205)
+STUBFUNCPROXY_NUM(206) STUBFUNCPROXY_NUM(207)
+STUBFUNCPROXY_NUM(208) STUBFUNCPROXY_NUM(209)
+STUBFUNCPROXY_NUM(210) STUBFUNCPROXY_NUM(211)
+STUBFUNCPROXY_NUM(212) STUBFUNCPROXY_NUM(213)
+STUBFUNCPROXY_NUM(214) STUBFUNCPROXY_NUM(215)
+STUBFUNCPROXY_NUM(216) STUBFUNCPROXY_NUM(217)
+STUBFUNCPROXY_NUM(218) STUBFUNCPROXY_NUM(219)
+STUBFUNCPROXY_NUM(220) STUBFUNCPROXY_NUM(221)
+STUBFUNCPROXY_NUM(222) STUBFUNCPROXY_NUM(223)
+STUBFUNCPROXY_NUM(224) STUBFUNCPROXY_NUM(225)
+STUBFUNCPROXY_NUM(226) STUBFUNCPROXY_NUM(227)
+STUBFUNCPROXY_NUM(228) STUBFUNCPROXY_NUM(229)
+STUBFUNCPROXY_NUM(230) STUBFUNCPROXY_NUM(231)
+STUBFUNCPROXY_NUM(232) STUBFUNCPROXY_NUM(233)
+STUBFUNCPROXY_NUM(234) STUBFUNCPROXY_NUM(235)
+STUBFUNCPROXY_NUM(236) STUBFUNCPROXY_NUM(237)
+STUBFUNCPROXY_NUM(238) STUBFUNCPROXY_NUM(239)
+STUBFUNCPROXY_NUM(240) STUBFUNCPROXY_NUM(241)
+STUBFUNCPROXY_NUM(242) STUBFUNCPROXY_NUM(243)
+STUBFUNCPROXY_NUM(244) STUBFUNCPROXY_NUM(245)
+STUBFUNCPROXY_NUM(246) STUBFUNCPROXY_NUM(247)
+STUBFUNCPROXY_NUM(248) STUBFUNCPROXY_NUM(249)
+STUBFUNCPROXY_NUM(250) STUBFUNCPROXY_NUM(251)
+STUBFUNCPROXY_NUM(252) STUBFUNCPROXY_NUM(253)
+STUBFUNCPROXY_NUM(254) STUBFUNCPROXY_NUM(255)
+STUBFUNCPROXY_NUM(256) STUBFUNCPROXY_NUM(257)
+STUBFUNCPROXY_NUM(258) STUBFUNCPROXY_NUM(259)
+STUBFUNCPROXY_NUM(260) STUBFUNCPROXY_NUM(261)
+STUBFUNCPROXY_NUM(262) STUBFUNCPROXY_NUM(263)
+STUBFUNCPROXY_NUM(264) STUBFUNCPROXY_NUM(265)
+STUBFUNCPROXY_NUM(266) STUBFUNCPROXY_NUM(267)
+STUBFUNCPROXY_NUM(268) STUBFUNCPROXY_NUM(269)
+STUBFUNCPROXY_NUM(270) STUBFUNCPROXY_NUM(271)
+STUBFUNCPROXY_NUM(272) STUBFUNCPROXY_NUM(273)
+STUBFUNCPROXY_NUM(274) STUBFUNCPROXY_NUM(275)
+STUBFUNCPROXY_NUM(276) STUBFUNCPROXY_NUM(277)
+STUBFUNCPROXY_NUM(278) STUBFUNCPROXY_NUM(279)
+STUBFUNCPROXY_NUM(280) STUBFUNCPROXY_NUM(281)
+STUBFUNCPROXY_NUM(282) STUBFUNCPROXY_NUM(283)
+STUBFUNCPROXY_NUM(284) STUBFUNCPROXY_NUM(285)
+STUBFUNCPROXY_NUM(286) STUBFUNCPROXY_NUM(287)
+STUBFUNCPROXY_NUM(288) STUBFUNCPROXY_NUM(289)
+STUBFUNCPROXY_NUM(290) STUBFUNCPROXY_NUM(291)
+STUBFUNCPROXY_NUM(292) STUBFUNCPROXY_NUM(293)
+STUBFUNCPROXY_NUM(294) STUBFUNCPROXY_NUM(295)
+STUBFUNCPROXY_NUM(296) STUBFUNCPROXY_NUM(297)
+STUBFUNCPROXY_NUM(298) STUBFUNCPROXY_NUM(299)
+STUBFUNCPROXY_NUM(300) STUBFUNCPROXY_NUM(301)
+STUBFUNCPROXY_NUM(302) STUBFUNCPROXY_NUM(303)
+STUBFUNCPROXY_NUM(304) STUBFUNCPROXY_NUM(305)
+STUBFUNCPROXY_NUM(306) STUBFUNCPROXY_NUM(307)
+STUBFUNCPROXY_NUM(308) STUBFUNCPROXY_NUM(309)
+STUBFUNCPROXY_NUM(310) STUBFUNCPROXY_NUM(311)
+STUBFUNCPROXY_NUM(312) STUBFUNCPROXY_NUM(313)
+STUBFUNCPROXY_NUM(314) STUBFUNCPROXY_NUM(315)
+STUBFUNCPROXY_NUM(316) STUBFUNCPROXY_NUM(317)
+STUBFUNCPROXY_NUM(318) STUBFUNCPROXY_NUM(319)
+STUBFUNCPROXY_NUM(320) STUBFUNCPROXY_NUM(321)
+STUBFUNCPROXY_NUM(322) STUBFUNCPROXY_NUM(323)
+STUBFUNCPROXY_NUM(324) STUBFUNCPROXY_NUM(325)
+STUBFUNCPROXY_NUM(326) STUBFUNCPROXY_NUM(327)
+STUBFUNCPROXY_NUM(328) STUBFUNCPROXY_NUM(329)
+STUBFUNCPROXY_NUM(330) STUBFUNCPROXY_NUM(331)
+STUBFUNCPROXY_NUM(332) STUBFUNCPROXY_NUM(333)
+STUBFUNCPROXY_NUM(334) STUBFUNCPROXY_NUM(335)
+STUBFUNCPROXY_NUM(336) STUBFUNCPROXY_NUM(337)
+STUBFUNCPROXY_NUM(338) STUBFUNCPROXY_NUM(339)
+STUBFUNCPROXY_NUM(340) STUBFUNCPROXY_NUM(341)
+STUBFUNCPROXY_NUM(342) STUBFUNCPROXY_NUM(343)
+STUBFUNCPROXY_NUM(344) STUBFUNCPROXY_NUM(345)
+STUBFUNCPROXY_NUM(346) STUBFUNCPROXY_NUM(347)
+STUBFUNCPROXY_NUM(348) STUBFUNCPROXY_NUM(349)
+STUBFUNCPROXY_NUM(350) STUBFUNCPROXY_NUM(351)
+STUBFUNCPROXY_NUM(352) STUBFUNCPROXY_NUM(353)
+STUBFUNCPROXY_NUM(354) STUBFUNCPROXY_NUM(355)
+STUBFUNCPROXY_NUM(356) STUBFUNCPROXY_NUM(357)
+STUBFUNCPROXY_NUM(358) STUBFUNCPROXY_NUM(359)
+STUBFUNCPROXY_NUM(360) STUBFUNCPROXY_NUM(361)
+STUBFUNCPROXY_NUM(362) STUBFUNCPROXY_NUM(363)
+STUBFUNCPROXY_NUM(364) STUBFUNCPROXY_NUM(365)
+STUBFUNCPROXY_NUM(366) STUBFUNCPROXY_NUM(367)
+STUBFUNCPROXY_NUM(368) STUBFUNCPROXY_NUM(369)
+STUBFUNCPROXY_NUM(370) STUBFUNCPROXY_NUM(371)
+STUBFUNCPROXY_NUM(372) STUBFUNCPROXY_NUM(373)
+STUBFUNCPROXY_NUM(374) STUBFUNCPROXY_NUM(375)
+STUBFUNCPROXY_NUM(376) STUBFUNCPROXY_NUM(377)
+STUBFUNCPROXY_NUM(378) STUBFUNCPROXY_NUM(379)
+STUBFUNCPROXY_NUM(380) STUBFUNCPROXY_NUM(381)
+STUBFUNCPROXY_NUM(382) STUBFUNCPROXY_NUM(383)
+STUBFUNCPROXY_NUM(384) STUBFUNCPROXY_NUM(385)
+STUBFUNCPROXY_NUM(386) STUBFUNCPROXY_NUM(387)
+STUBFUNCPROXY_NUM(388) STUBFUNCPROXY_NUM(389)
+STUBFUNCPROXY_NUM(390) STUBFUNCPROXY_NUM(391)
+STUBFUNCPROXY_NUM(392) STUBFUNCPROXY_NUM(393)
+STUBFUNCPROXY_NUM(394) STUBFUNCPROXY_NUM(395)
+STUBFUNCPROXY_NUM(396) STUBFUNCPROXY_NUM(397)
+STUBFUNCPROXY_NUM(398) STUBFUNCPROXY_NUM(399)
+STUBFUNCPROXY_NUM(400) STUBFUNCPROXY_NUM(401)
+STUBFUNCPROXY_NUM(402) STUBFUNCPROXY_NUM(403)
+STUBFUNCPROXY_NUM(404) STUBFUNCPROXY_NUM(405)
+STUBFUNCPROXY_NUM(406) STUBFUNCPROXY_NUM(407)
+STUBFUNCPROXY_NUM(408) STUBFUNCPROXY_NUM(409)
+STUBFUNCPROXY_NUM(410) STUBFUNCPROXY_NUM(411)
+STUBFUNCPROXY_NUM(412) STUBFUNCPROXY_NUM(413)
+STUBFUNCPROXY_NUM(414) STUBFUNCPROXY_NUM(415)
+STUBFUNCPROXY_NUM(416) STUBFUNCPROXY_NUM(417)
+STUBFUNCPROXY_NUM(418) STUBFUNCPROXY_NUM(419)
+STUBFUNCPROXY_NUM(420) STUBFUNCPROXY_NUM(421)
+STUBFUNCPROXY_NUM(422) STUBFUNCPROXY_NUM(423)
+STUBFUNCPROXY_NUM(424) STUBFUNCPROXY_NUM(425)
+STUBFUNCPROXY_NUM(426) STUBFUNCPROXY_NUM(427)
+STUBFUNCPROXY_NUM(428) STUBFUNCPROXY_NUM(429)
+STUBFUNCPROXY_NUM(430) STUBFUNCPROXY_NUM(431)
+STUBFUNCPROXY_NUM(432) STUBFUNCPROXY_NUM(433)
+STUBFUNCPROXY_NUM(434) STUBFUNCPROXY_NUM(435)
+STUBFUNCPROXY_NUM(436) STUBFUNCPROXY_NUM(437)
+STUBFUNCPROXY_NUM(438) STUBFUNCPROXY_NUM(439)
+STUBFUNCPROXY_NUM(440) STUBFUNCPROXY_NUM(441)
+STUBFUNCPROXY_NUM(442) STUBFUNCPROXY_NUM(443)
+STUBFUNCPROXY_NUM(444) STUBFUNCPROXY_NUM(445)
+STUBFUNCPROXY_NUM(446) STUBFUNCPROXY_NUM(447)
+STUBFUNCPROXY_NUM(448) STUBFUNCPROXY_NUM(449)
+STUBFUNCPROXY_NUM(450) STUBFUNCPROXY_NUM(451)
+STUBFUNCPROXY_NUM(452) STUBFUNCPROXY_NUM(453)
+STUBFUNCPROXY_NUM(454) STUBFUNCPROXY_NUM(455)
+STUBFUNCPROXY_NUM(456) STUBFUNCPROXY_NUM(457)
+STUBFUNCPROXY_NUM(458) STUBFUNCPROXY_NUM(459)
+STUBFUNCPROXY_NUM(460) STUBFUNCPROXY_NUM(461)
+STUBFUNCPROXY_NUM(462) STUBFUNCPROXY_NUM(463)
+STUBFUNCPROXY_NUM(464) STUBFUNCPROXY_NUM(465)
+STUBFUNCPROXY_NUM(466) STUBFUNCPROXY_NUM(467)
+STUBFUNCPROXY_NUM(468) STUBFUNCPROXY_NUM(469)
+STUBFUNCPROXY_NUM(470) STUBFUNCPROXY_NUM(471)
+STUBFUNCPROXY_NUM(472) STUBFUNCPROXY_NUM(473)
+STUBFUNCPROXY_NUM(474) STUBFUNCPROXY_NUM(475)
+STUBFUNCPROXY_NUM(476) STUBFUNCPROXY_NUM(477)
+STUBFUNCPROXY_NUM(478) STUBFUNCPROXY_NUM(479)
+STUBFUNCPROXY_NUM(480) STUBFUNCPROXY_NUM(481)
+STUBFUNCPROXY_NUM(482) STUBFUNCPROXY_NUM(483)
+STUBFUNCPROXY_NUM(484) STUBFUNCPROXY_NUM(485)
+STUBFUNCPROXY_NUM(486) STUBFUNCPROXY_NUM(487)
+STUBFUNCPROXY_NUM(488) STUBFUNCPROXY_NUM(489)
+STUBFUNCPROXY_NUM(490) STUBFUNCPROXY_NUM(491)
+STUBFUNCPROXY_NUM(492) STUBFUNCPROXY_NUM(493)
+STUBFUNCPROXY_NUM(494) STUBFUNCPROXY_NUM(495)
+STUBFUNCPROXY_NUM(496) STUBFUNCPROXY_NUM(497)
+STUBFUNCPROXY_NUM(498) STUBFUNCPROXY_NUM(499)
+STUBFUNCPROXY_NUM(500) STUBFUNCPROXY_NUM(501)
+STUBFUNCPROXY_NUM(502) STUBFUNCPROXY_NUM(503)
+STUBFUNCPROXY_NUM(504) STUBFUNCPROXY_NUM(505)
+STUBFUNCPROXY_NUM(506) STUBFUNCPROXY_NUM(507)
+STUBFUNCPROXY_NUM(508) STUBFUNCPROXY_NUM(509)
+STUBFUNCPROXY_NUM(510) STUBFUNCPROXY_NUM(511)
+STUBFUNCPROXY_NUM(512) STUBFUNCPROXY_NUM(513)
+STUBFUNCPROXY_NUM(514) STUBFUNCPROXY_NUM(515)
+STUBFUNCPROXY_NUM(516) STUBFUNCPROXY_NUM(517)
+STUBFUNCPROXY_NUM(518) STUBFUNCPROXY_NUM(519)
+STUBFUNCPROXY_NUM(520) STUBFUNCPROXY_NUM(521)
+STUBFUNCPROXY_NUM(522) STUBFUNCPROXY_NUM(523)
+STUBFUNCPROXY_NUM(524) STUBFUNCPROXY_NUM(525)
+STUBFUNCPROXY_NUM(526) STUBFUNCPROXY_NUM(527)
+STUBFUNCPROXY_NUM(528) STUBFUNCPROXY_NUM(529)
+STUBFUNCPROXY_NUM(530) STUBFUNCPROXY_NUM(531)
+STUBFUNCPROXY_NUM(532) STUBFUNCPROXY_NUM(533)
+STUBFUNCPROXY_NUM(534) STUBFUNCPROXY_NUM(535)
+STUBFUNCPROXY_NUM(536) STUBFUNCPROXY_NUM(537)
+STUBFUNCPROXY_NUM(538) STUBFUNCPROXY_NUM(539)
+STUBFUNCPROXY_NUM(540) STUBFUNCPROXY_NUM(541)
+STUBFUNCPROXY_NUM(542) STUBFUNCPROXY_NUM(543)
+STUBFUNCPROXY_NUM(544) STUBFUNCPROXY_NUM(545)
+STUBFUNCPROXY_NUM(546) STUBFUNCPROXY_NUM(547)
+STUBFUNCPROXY_NUM(548) STUBFUNCPROXY_NUM(549)
+STUBFUNCPROXY_NUM(550) STUBFUNCPROXY_NUM(551)
+STUBFUNCPROXY_NUM(552) STUBFUNCPROXY_NUM(553)
+STUBFUNCPROXY_NUM(554) STUBFUNCPROXY_NUM(555)
+STUBFUNCPROXY_NUM(556) STUBFUNCPROXY_NUM(557)
+STUBFUNCPROXY_NUM(558) STUBFUNCPROXY_NUM(559)
+STUBFUNCPROXY_NUM(560) STUBFUNCPROXY_NUM(561)
+STUBFUNCPROXY_NUM(562) STUBFUNCPROXY_NUM(563)
+STUBFUNCPROXY_NUM(564) STUBFUNCPROXY_NUM(565)
+STUBFUNCPROXY_NUM(566) STUBFUNCPROXY_NUM(567)
+STUBFUNCPROXY_NUM(568) STUBFUNCPROXY_NUM(569)
+STUBFUNCPROXY_NUM(570) STUBFUNCPROXY_NUM(571)
+STUBFUNCPROXY_NUM(572) STUBFUNCPROXY_NUM(573)
+STUBFUNCPROXY_NUM(574) STUBFUNCPROXY_NUM(575)
+STUBFUNCPROXY_NUM(576) STUBFUNCPROXY_NUM(577)
+STUBFUNCPROXY_NUM(578) STUBFUNCPROXY_NUM(579)
+STUBFUNCPROXY_NUM(580) STUBFUNCPROXY_NUM(581)
+STUBFUNCPROXY_NUM(582) STUBFUNCPROXY_NUM(583)
+STUBFUNCPROXY_NUM(584) STUBFUNCPROXY_NUM(585)
+STUBFUNCPROXY_NUM(586) STUBFUNCPROXY_NUM(587)
+STUBFUNCPROXY_NUM(588) STUBFUNCPROXY_NUM(589)
+STUBFUNCPROXY_NUM(590) STUBFUNCPROXY_NUM(591)
+STUBFUNCPROXY_NUM(592) STUBFUNCPROXY_NUM(593)
+STUBFUNCPROXY_NUM(594) STUBFUNCPROXY_NUM(595)
+STUBFUNCPROXY_NUM(596) STUBFUNCPROXY_NUM(597)
+STUBFUNCPROXY_NUM(598) STUBFUNCPROXY_NUM(599)
+
+void (*gstubfunc[kSupportMaxInterfaceMethod])(void) = {
+    (void (*)(void))sfp_jlong_0,
+    (void (*)(void))sfp_jlong_1,
+    (void (*)(void))sfp_jlong_2,
+    (void (*)(void))sfp_jlong_3,
+    (void (*)(void))sfp_jlong_4,
+    (void (*)(void))sfp_jlong_5,
+    (void (*)(void))sfp_jlong_6,
+    (void (*)(void))sfp_jlong_7,
+    (void (*)(void))sfp_jlong_8,
+    (void (*)(void))sfp_jlong_9,
+    (void (*)(void))sfp_jlong_10,
+    (void (*)(void))sfp_jlong_11,
+    (void (*)(void))sfp_jlong_12,
+    (void (*)(void))sfp_jlong_13,
+    (void (*)(void))sfp_jlong_14,
+    (void (*)(void))sfp_jlong_15,
+    (void (*)(void))sfp_jlong_16,
+    (void (*)(void))sfp_jlong_17,
+    (void (*)(void))sfp_jlong_18,
+    (void (*)(void))sfp_jlong_19,
+    (void (*)(void))sfp_jlong_20,
+    (void (*)(void))sfp_jlong_21,
+    (void (*)(void))sfp_jlong_22,
+    (void (*)(void))sfp_jlong_23,
+    (void (*)(void))sfp_jlong_24,
+    (void (*)(void))sfp_jlong_25,
+    (void (*)(void))sfp_jlong_26,
+    (void (*)(void))sfp_jlong_27,
+    (void (*)(void))sfp_jlong_28,
+    (void (*)(void))sfp_jlong_29,
+    (void (*)(void))sfp_jlong_30,
+    (void (*)(void))sfp_jlong_31,
+    (void (*)(void))sfp_jlong_32,
+    (void (*)(void))sfp_jlong_33,
+    (void (*)(void))sfp_jlong_34,
+    (void (*)(void))sfp_jlong_35,
+    (void (*)(void))sfp_jlong_36,
+    (void (*)(void))sfp_jlong_37,
+    (void (*)(void))sfp_jlong_38,
+    (void (*)(void))sfp_jlong_39,
+    (void (*)(void))sfp_jlong_40,
+    (void (*)(void))sfp_jlong_41,
+    (void (*)(void))sfp_jlong_42,
+    (void (*)(void))sfp_jlong_43,
+    (void (*)(void))sfp_jlong_44,
+    (void (*)(void))sfp_jlong_45,
+    (void (*)(void))sfp_jlong_46,
+    (void (*)(void))sfp_jlong_47,
+    (void (*)(void))sfp_jlong_48,
+    (void (*)(void))sfp_jlong_49,
+    (void (*)(void))sfp_jlong_50,
+    (void (*)(void))sfp_jlong_51,
+    (void (*)(void))sfp_jlong_52,
+    (void (*)(void))sfp_jlong_53,
+    (void (*)(void))sfp_jlong_54,
+    (void (*)(void))sfp_jlong_55,
+    (void (*)(void))sfp_jlong_56,
+    (void (*)(void))sfp_jlong_57,
+    (void (*)(void))sfp_jlong_58,
+    (void (*)(void))sfp_jlong_59,
+    (void (*)(void))sfp_jlong_60,
+    (void (*)(void))sfp_jlong_61,
+    (void (*)(void))sfp_jlong_62,
+    (void (*)(void))sfp_jlong_63,
+    (void (*)(void))sfp_jlong_64,
+    (void (*)(void))sfp_jlong_65,
+    (void (*)(void))sfp_jlong_66,
+    (void (*)(void))sfp_jlong_67,
+    (void (*)(void))sfp_jlong_68,
+    (void (*)(void))sfp_jlong_69,
+    (void (*)(void))sfp_jlong_70,
+    (void (*)(void))sfp_jlong_71,
+    (void (*)(void))sfp_jlong_72,
+    (void (*)(void))sfp_jlong_73,
+    (void (*)(void))sfp_jlong_74,
+    (void (*)(void))sfp_jlong_75,
+    (void (*)(void))sfp_jlong_76,
+    (void (*)(void))sfp_jlong_77,
+    (void (*)(void))sfp_jlong_78,
+    (void (*)(void))sfp_jlong_79,
+    (void (*)(void))sfp_jlong_80,
+    (void (*)(void))sfp_jlong_81,
+    (void (*)(void))sfp_jlong_82,
+    (void (*)(void))sfp_jlong_83,
+    (void (*)(void))sfp_jlong_84,
+    (void (*)(void))sfp_jlong_85,
+    (void (*)(void))sfp_jlong_86,
+    (void (*)(void))sfp_jlong_87,
+    (void (*)(void))sfp_jlong_88,
+    (void (*)(void))sfp_jlong_89,
+    (void (*)(void))sfp_jlong_90,
+    (void (*)(void))sfp_jlong_91,
+    (void (*)(void))sfp_jlong_92,
+    (void (*)(void))sfp_jlong_93,
+    (void (*)(void))sfp_jlong_94,
+    (void (*)(void))sfp_jlong_95,
+    (void (*)(void))sfp_jlong_96,
+    (void (*)(void))sfp_jlong_97,
+    (void (*)(void))sfp_jlong_98,
+    (void (*)(void))sfp_jlong_99,
+    (void (*)(void))sfp_jlong_100,
+    (void (*)(void))sfp_jlong_101,
+    (void (*)(void))sfp_jlong_102,
+    (void (*)(void))sfp_jlong_103,
+    (void (*)(void))sfp_jlong_104,
+    (void (*)(void))sfp_jlong_105,
+    (void (*)(void))sfp_jlong_106,
+    (void (*)(void))sfp_jlong_107,
+    (void (*)(void))sfp_jlong_108,
+    (void (*)(void))sfp_jlong_109,
+    (void (*)(void))sfp_jlong_110,
+    (void (*)(void))sfp_jlong_111,
+    (void (*)(void))sfp_jlong_112,
+    (void (*)(void))sfp_jlong_113,
+    (void (*)(void))sfp_jlong_114,
+    (void (*)(void))sfp_jlong_115,
+    (void (*)(void))sfp_jlong_116,
+    (void (*)(void))sfp_jlong_117,
+    (void (*)(void))sfp_jlong_118,
+    (void (*)(void))sfp_jlong_119,
+    (void (*)(void))sfp_jlong_120,
+    (void (*)(void))sfp_jlong_121,
+    (void (*)(void))sfp_jlong_122,
+    (void (*)(void))sfp_jlong_123,
+    (void (*)(void))sfp_jlong_124,
+    (void (*)(void))sfp_jlong_125,
+    (void (*)(void))sfp_jlong_126,
+    (void (*)(void))sfp_jlong_127,
+    (void (*)(void))sfp_jlong_128,
+    (void (*)(void))sfp_jlong_129,
+    (void (*)(void))sfp_jlong_130,
+    (void (*)(void))sfp_jlong_131,
+    (void (*)(void))sfp_jlong_132,
+    (void (*)(void))sfp_jlong_133,
+    (void (*)(void))sfp_jlong_134,
+    (void (*)(void))sfp_jlong_135,
+    (void (*)(void))sfp_jlong_136,
+    (void (*)(void))sfp_jlong_137,
+    (void (*)(void))sfp_jlong_138,
+    (void (*)(void))sfp_jlong_139,
+    (void (*)(void))sfp_jlong_140,
+    (void (*)(void))sfp_jlong_141,
+    (void (*)(void))sfp_jlong_142,
+    (void (*)(void))sfp_jlong_143,
+    (void (*)(void))sfp_jlong_144,
+    (void (*)(void))sfp_jlong_145,
+    (void (*)(void))sfp_jlong_146,
+    (void (*)(void))sfp_jlong_147,
+    (void (*)(void))sfp_jlong_148,
+    (void (*)(void))sfp_jlong_149,
+    (void (*)(void))sfp_jlong_150,
+    (void (*)(void))sfp_jlong_151,
+    (void (*)(void))sfp_jlong_152,
+    (void (*)(void))sfp_jlong_153,
+    (void (*)(void))sfp_jlong_154,
+    (void (*)(void))sfp_jlong_155,
+    (void (*)(void))sfp_jlong_156,
+    (void (*)(void))sfp_jlong_157,
+    (void (*)(void))sfp_jlong_158,
+    (void (*)(void))sfp_jlong_159,
+    (void (*)(void))sfp_jlong_160,
+    (void (*)(void))sfp_jlong_161,
+    (void (*)(void))sfp_jlong_162,
+    (void (*)(void))sfp_jlong_163,
+    (void (*)(void))sfp_jlong_164,
+    (void (*)(void))sfp_jlong_165,
+    (void (*)(void))sfp_jlong_166,
+    (void (*)(void))sfp_jlong_167,
+    (void (*)(void))sfp_jlong_168,
+    (void (*)(void))sfp_jlong_169,
+    (void (*)(void))sfp_jlong_170,
+    (void (*)(void))sfp_jlong_171,
+    (void (*)(void))sfp_jlong_172,
+    (void (*)(void))sfp_jlong_173,
+    (void (*)(void))sfp_jlong_174,
+    (void (*)(void))sfp_jlong_175,
+    (void (*)(void))sfp_jlong_176,
+    (void (*)(void))sfp_jlong_177,
+    (void (*)(void))sfp_jlong_178,
+    (void (*)(void))sfp_jlong_179,
+    (void (*)(void))sfp_jlong_180,
+    (void (*)(void))sfp_jlong_181,
+    (void (*)(void))sfp_jlong_182,
+    (void (*)(void))sfp_jlong_183,
+    (void (*)(void))sfp_jlong_184,
+    (void (*)(void))sfp_jlong_185,
+    (void (*)(void))sfp_jlong_186,
+    (void (*)(void))sfp_jlong_187,
+    (void (*)(void))sfp_jlong_188,
+    (void (*)(void))sfp_jlong_189,
+    (void (*)(void))sfp_jlong_190,
+    (void (*)(void))sfp_jlong_191,
+    (void (*)(void))sfp_jlong_192,
+    (void (*)(void))sfp_jlong_193,
+    (void (*)(void))sfp_jlong_194,
+    (void (*)(void))sfp_jlong_195,
+    (void (*)(void))sfp_jlong_196,
+    (void (*)(void))sfp_jlong_197,
+    (void (*)(void))sfp_jlong_198,
+    (void (*)(void))sfp_jlong_199,
+    (void (*)(void))sfp_jlong_200,
+    (void (*)(void))sfp_jlong_201,
+    (void (*)(void))sfp_jlong_202,
+    (void (*)(void))sfp_jlong_203,
+    (void (*)(void))sfp_jlong_204,
+    (void (*)(void))sfp_jlong_205,
+    (void (*)(void))sfp_jlong_206,
+    (void (*)(void))sfp_jlong_207,
+    (void (*)(void))sfp_jlong_208,
+    (void (*)(void))sfp_jlong_209,
+    (void (*)(void))sfp_jlong_210,
+    (void (*)(void))sfp_jlong_211,
+    (void (*)(void))sfp_jlong_212,
+    (void (*)(void))sfp_jlong_213,
+    (void (*)(void))sfp_jlong_214,
+    (void (*)(void))sfp_jlong_215,
+    (void (*)(void))sfp_jlong_216,
+    (void (*)(void))sfp_jlong_217,
+    (void (*)(void))sfp_jlong_218,
+    (void (*)(void))sfp_jlong_219,
+    (void (*)(void))sfp_jlong_220,
+    (void (*)(void))sfp_jlong_221,
+    (void (*)(void))sfp_jlong_222,
+    (void (*)(void))sfp_jlong_223,
+    (void (*)(void))sfp_jlong_224,
+    (void (*)(void))sfp_jlong_225,
+    (void (*)(void))sfp_jlong_226,
+    (void (*)(void))sfp_jlong_227,
+    (void (*)(void))sfp_jlong_228,
+    (void (*)(void))sfp_jlong_229,
+    (void (*)(void))sfp_jlong_230,
+    (void (*)(void))sfp_jlong_231,
+    (void (*)(void))sfp_jlong_232,
+    (void (*)(void))sfp_jlong_233,
+    (void (*)(void))sfp_jlong_234,
+    (void (*)(void))sfp_jlong_235,
+    (void (*)(void))sfp_jlong_236,
+    (void (*)(void))sfp_jlong_237,
+    (void (*)(void))sfp_jlong_238,
+    (void (*)(void))sfp_jlong_239,
+    (void (*)(void))sfp_jlong_240,
+    (void (*)(void))sfp_jlong_241,
+    (void (*)(void))sfp_jlong_242,
+    (void (*)(void))sfp_jlong_243,
+    (void (*)(void))sfp_jlong_244,
+    (void (*)(void))sfp_jlong_245,
+    (void (*)(void))sfp_jlong_246,
+    (void (*)(void))sfp_jlong_247,
+    (void (*)(void))sfp_jlong_248,
+    (void (*)(void))sfp_jlong_249,
+    (void (*)(void))sfp_jlong_250,
+    (void (*)(void))sfp_jlong_251,
+    (void (*)(void))sfp_jlong_252,
+    (void (*)(void))sfp_jlong_253,
+    (void (*)(void))sfp_jlong_254,
+    (void (*)(void))sfp_jlong_255,
+    (void (*)(void))sfp_jlong_256,
+    (void (*)(void))sfp_jlong_257,
+    (void (*)(void))sfp_jlong_258,
+    (void (*)(void))sfp_jlong_259,
+    (void (*)(void))sfp_jlong_260,
+    (void (*)(void))sfp_jlong_261,
+    (void (*)(void))sfp_jlong_262,
+    (void (*)(void))sfp_jlong_263,
+    (void (*)(void))sfp_jlong_264,
+    (void (*)(void))sfp_jlong_265,
+    (void (*)(void))sfp_jlong_266,
+    (void (*)(void))sfp_jlong_267,
+    (void (*)(void))sfp_jlong_268,
+    (void (*)(void))sfp_jlong_269,
+    (void (*)(void))sfp_jlong_270,
+    (void (*)(void))sfp_jlong_271,
+    (void (*)(void))sfp_jlong_272,
+    (void (*)(void))sfp_jlong_273,
+    (void (*)(void))sfp_jlong_274,
+    (void (*)(void))sfp_jlong_275,
+    (void (*)(void))sfp_jlong_276,
+    (void (*)(void))sfp_jlong_277,
+    (void (*)(void))sfp_jlong_278,
+    (void (*)(void))sfp_jlong_279,
+    (void (*)(void))sfp_jlong_280,
+    (void (*)(void))sfp_jlong_281,
+    (void (*)(void))sfp_jlong_282,
+    (void (*)(void))sfp_jlong_283,
+    (void (*)(void))sfp_jlong_284,
+    (void (*)(void))sfp_jlong_285,
+    (void (*)(void))sfp_jlong_286,
+    (void (*)(void))sfp_jlong_287,
+    (void (*)(void))sfp_jlong_288,
+    (void (*)(void))sfp_jlong_289,
+    (void (*)(void))sfp_jlong_290,
+    (void (*)(void))sfp_jlong_291,
+    (void (*)(void))sfp_jlong_292,
+    (void (*)(void))sfp_jlong_293,
+    (void (*)(void))sfp_jlong_294,
+    (void (*)(void))sfp_jlong_295,
+    (void (*)(void))sfp_jlong_296,
+    (void (*)(void))sfp_jlong_297,
+    (void (*)(void))sfp_jlong_298,
+    (void (*)(void))sfp_jlong_299,
+    (void (*)(void))sfp_jlong_300,
+    (void (*)(void))sfp_jlong_301,
+    (void (*)(void))sfp_jlong_302,
+    (void (*)(void))sfp_jlong_303,
+    (void (*)(void))sfp_jlong_304,
+    (void (*)(void))sfp_jlong_305,
+    (void (*)(void))sfp_jlong_306,
+    (void (*)(void))sfp_jlong_307,
+    (void (*)(void))sfp_jlong_308,
+    (void (*)(void))sfp_jlong_309,
+    (void (*)(void))sfp_jlong_310,
+    (void (*)(void))sfp_jlong_311,
+    (void (*)(void))sfp_jlong_312,
+    (void (*)(void))sfp_jlong_313,
+    (void (*)(void))sfp_jlong_314,
+    (void (*)(void))sfp_jlong_315,
+    (void (*)(void))sfp_jlong_316,
+    (void (*)(void))sfp_jlong_317,
+    (void (*)(void))sfp_jlong_318,
+    (void (*)(void))sfp_jlong_319,
+    (void (*)(void))sfp_jlong_320,
+    (void (*)(void))sfp_jlong_321,
+    (void (*)(void))sfp_jlong_322,
+    (void (*)(void))sfp_jlong_323,
+    (void (*)(void))sfp_jlong_324,
+    (void (*)(void))sfp_jlong_325,
+    (void (*)(void))sfp_jlong_326,
+    (void (*)(void))sfp_jlong_327,
+    (void (*)(void))sfp_jlong_328,
+    (void (*)(void))sfp_jlong_329,
+    (void (*)(void))sfp_jlong_330,
+    (void (*)(void))sfp_jlong_331,
+    (void (*)(void))sfp_jlong_332,
+    (void (*)(void))sfp_jlong_333,
+    (void (*)(void))sfp_jlong_334,
+    (void (*)(void))sfp_jlong_335,
+    (void (*)(void))sfp_jlong_336,
+    (void (*)(void))sfp_jlong_337,
+    (void (*)(void))sfp_jlong_338,
+    (void (*)(void))sfp_jlong_339,
+    (void (*)(void))sfp_jlong_340,
+    (void (*)(void))sfp_jlong_341,
+    (void (*)(void))sfp_jlong_342,
+    (void (*)(void))sfp_jlong_343,
+    (void (*)(void))sfp_jlong_344,
+    (void (*)(void))sfp_jlong_345,
+    (void (*)(void))sfp_jlong_346,
+    (void (*)(void))sfp_jlong_347,
+    (void (*)(void))sfp_jlong_348,
+    (void (*)(void))sfp_jlong_349,
+    (void (*)(void))sfp_jlong_350,
+    (void (*)(void))sfp_jlong_351,
+    (void (*)(void))sfp_jlong_352,
+    (void (*)(void))sfp_jlong_353,
+    (void (*)(void))sfp_jlong_354,
+    (void (*)(void))sfp_jlong_355,
+    (void (*)(void))sfp_jlong_356,
+    (void (*)(void))sfp_jlong_357,
+    (void (*)(void))sfp_jlong_358,
+    (void (*)(void))sfp_jlong_359,
+    (void (*)(void))sfp_jlong_360,
+    (void (*)(void))sfp_jlong_361,
+    (void (*)(void))sfp_jlong_362,
+    (void (*)(void))sfp_jlong_363,
+    (void (*)(void))sfp_jlong_364,
+    (void (*)(void))sfp_jlong_365,
+    (void (*)(void))sfp_jlong_366,
+    (void (*)(void))sfp_jlong_367,
+    (void (*)(void))sfp_jlong_368,
+    (void (*)(void))sfp_jlong_369,
+    (void (*)(void))sfp_jlong_370,
+    (void (*)(void))sfp_jlong_371,
+    (void (*)(void))sfp_jlong_372,
+    (void (*)(void))sfp_jlong_373,
+    (void (*)(void))sfp_jlong_374,
+    (void (*)(void))sfp_jlong_375,
+    (void (*)(void))sfp_jlong_376,
+    (void (*)(void))sfp_jlong_377,
+    (void (*)(void))sfp_jlong_378,
+    (void (*)(void))sfp_jlong_379,
+    (void (*)(void))sfp_jlong_380,
+    (void (*)(void))sfp_jlong_381,
+    (void (*)(void))sfp_jlong_382,
+    (void (*)(void))sfp_jlong_383,
+    (void (*)(void))sfp_jlong_384,
+    (void (*)(void))sfp_jlong_385,
+    (void (*)(void))sfp_jlong_386,
+    (void (*)(void))sfp_jlong_387,
+    (void (*)(void))sfp_jlong_388,
+    (void (*)(void))sfp_jlong_389,
+    (void (*)(void))sfp_jlong_390,
+    (void (*)(void))sfp_jlong_391,
+    (void (*)(void))sfp_jlong_392,
+    (void (*)(void))sfp_jlong_393,
+    (void (*)(void))sfp_jlong_394,
+    (void (*)(void))sfp_jlong_395,
+    (void (*)(void))sfp_jlong_396,
+    (void (*)(void))sfp_jlong_397,
+    (void (*)(void))sfp_jlong_398,
+    (void (*)(void))sfp_jlong_399,
+    (void (*)(void))sfp_jlong_400,
+    (void (*)(void))sfp_jlong_401,
+    (void (*)(void))sfp_jlong_402,
+    (void (*)(void))sfp_jlong_403,
+    (void (*)(void))sfp_jlong_404,
+    (void (*)(void))sfp_jlong_405,
+    (void (*)(void))sfp_jlong_406,
+    (void (*)(void))sfp_jlong_407,
+    (void (*)(void))sfp_jlong_408,
+    (void (*)(void))sfp_jlong_409,
+    (void (*)(void))sfp_jlong_410,
+    (void (*)(void))sfp_jlong_411,
+    (void (*)(void))sfp_jlong_412,
+    (void (*)(void))sfp_jlong_413,
+    (void (*)(void))sfp_jlong_414,
+    (void (*)(void))sfp_jlong_415,
+    (void (*)(void))sfp_jlong_416,
+    (void (*)(void))sfp_jlong_417,
+    (void (*)(void))sfp_jlong_418,
+    (void (*)(void))sfp_jlong_419,
+    (void (*)(void))sfp_jlong_420,
+    (void (*)(void))sfp_jlong_421,
+    (void (*)(void))sfp_jlong_422,
+    (void (*)(void))sfp_jlong_423,
+    (void (*)(void))sfp_jlong_424,
+    (void (*)(void))sfp_jlong_425,
+    (void (*)(void))sfp_jlong_426,
+    (void (*)(void))sfp_jlong_427,
+    (void (*)(void))sfp_jlong_428,
+    (void (*)(void))sfp_jlong_429,
+    (void (*)(void))sfp_jlong_430,
+    (void (*)(void))sfp_jlong_431,
+    (void (*)(void))sfp_jlong_432,
+    (void (*)(void))sfp_jlong_433,
+    (void (*)(void))sfp_jlong_434,
+    (void (*)(void))sfp_jlong_435,
+    (void (*)(void))sfp_jlong_436,
+    (void (*)(void))sfp_jlong_437,
+    (void (*)(void))sfp_jlong_438,
+    (void (*)(void))sfp_jlong_439,
+    (void (*)(void))sfp_jlong_440,
+    (void (*)(void))sfp_jlong_441,
+    (void (*)(void))sfp_jlong_442,
+    (void (*)(void))sfp_jlong_443,
+    (void (*)(void))sfp_jlong_444,
+    (void (*)(void))sfp_jlong_445,
+    (void (*)(void))sfp_jlong_446,
+    (void (*)(void))sfp_jlong_447,
+    (void (*)(void))sfp_jlong_448,
+    (void (*)(void))sfp_jlong_449,
+    (void (*)(void))sfp_jlong_450,
+    (void (*)(void))sfp_jlong_451,
+    (void (*)(void))sfp_jlong_452,
+    (void (*)(void))sfp_jlong_453,
+    (void (*)(void))sfp_jlong_454,
+    (void (*)(void))sfp_jlong_455,
+    (void (*)(void))sfp_jlong_456,
+    (void (*)(void))sfp_jlong_457,
+    (void (*)(void))sfp_jlong_458,
+    (void (*)(void))sfp_jlong_459,
+    (void (*)(void))sfp_jlong_460,
+    (void (*)(void))sfp_jlong_461,
+    (void (*)(void))sfp_jlong_462,
+    (void (*)(void))sfp_jlong_463,
+    (void (*)(void))sfp_jlong_464,
+    (void (*)(void))sfp_jlong_465,
+    (void (*)(void))sfp_jlong_466,
+    (void (*)(void))sfp_jlong_467,
+    (void (*)(void))sfp_jlong_468,
+    (void (*)(void))sfp_jlong_469,
+    (void (*)(void))sfp_jlong_470,
+    (void (*)(void))sfp_jlong_471,
+    (void (*)(void))sfp_jlong_472,
+    (void (*)(void))sfp_jlong_473,
+    (void (*)(void))sfp_jlong_474,
+    (void (*)(void))sfp_jlong_475,
+    (void (*)(void))sfp_jlong_476,
+    (void (*)(void))sfp_jlong_477,
+    (void (*)(void))sfp_jlong_478,
+    (void (*)(void))sfp_jlong_479,
+    (void (*)(void))sfp_jlong_480,
+    (void (*)(void))sfp_jlong_481,
+    (void (*)(void))sfp_jlong_482,
+    (void (*)(void))sfp_jlong_483,
+    (void (*)(void))sfp_jlong_484,
+    (void (*)(void))sfp_jlong_485,
+    (void (*)(void))sfp_jlong_486,
+    (void (*)(void))sfp_jlong_487,
+    (void (*)(void))sfp_jlong_488,
+    (void (*)(void))sfp_jlong_489,
+    (void (*)(void))sfp_jlong_490,
+    (void (*)(void))sfp_jlong_491,
+    (void (*)(void))sfp_jlong_492,
+    (void (*)(void))sfp_jlong_493,
+    (void (*)(void))sfp_jlong_494,
+    (void (*)(void))sfp_jlong_495,
+    (void (*)(void))sfp_jlong_496,
+    (void (*)(void))sfp_jlong_497,
+    (void (*)(void))sfp_jlong_498,
+    (void (*)(void))sfp_jlong_499,
+    (void (*)(void))sfp_jlong_500,
+    (void (*)(void))sfp_jlong_501,
+    (void (*)(void))sfp_jlong_502,
+    (void (*)(void))sfp_jlong_503,
+    (void (*)(void))sfp_jlong_504,
+    (void (*)(void))sfp_jlong_505,
+    (void (*)(void))sfp_jlong_506,
+    (void (*)(void))sfp_jlong_507,
+    (void (*)(void))sfp_jlong_508,
+    (void (*)(void))sfp_jlong_509,
+    (void (*)(void))sfp_jlong_510,
+    (void (*)(void))sfp_jlong_511,
+    (void (*)(void))sfp_jlong_512,
+    (void (*)(void))sfp_jlong_513,
+    (void (*)(void))sfp_jlong_514,
+    (void (*)(void))sfp_jlong_515,
+    (void (*)(void))sfp_jlong_516,
+    (void (*)(void))sfp_jlong_517,
+    (void (*)(void))sfp_jlong_518,
+    (void (*)(void))sfp_jlong_519,
+    (void (*)(void))sfp_jlong_520,
+    (void (*)(void))sfp_jlong_521,
+    (void (*)(void))sfp_jlong_522,
+    (void (*)(void))sfp_jlong_523,
+    (void (*)(void))sfp_jlong_524,
+    (void (*)(void))sfp_jlong_525,
+    (void (*)(void))sfp_jlong_526,
+    (void (*)(void))sfp_jlong_527,
+    (void (*)(void))sfp_jlong_528,
+    (void (*)(void))sfp_jlong_529,
+    (void (*)(void))sfp_jlong_530,
+    (void (*)(void))sfp_jlong_531,
+    (void (*)(void))sfp_jlong_532,
+    (void (*)(void))sfp_jlong_533,
+    (void (*)(void))sfp_jlong_534,
+    (void (*)(void))sfp_jlong_535,
+    (void (*)(void))sfp_jlong_536,
+    (void (*)(void))sfp_jlong_537,
+    (void (*)(void))sfp_jlong_538,
+    (void (*)(void))sfp_jlong_539,
+    (void (*)(void))sfp_jlong_540,
+    (void (*)(void))sfp_jlong_541,
+    (void (*)(void))sfp_jlong_542,
+    (void (*)(void))sfp_jlong_543,
+    (void (*)(void))sfp_jlong_544,
+    (void (*)(void))sfp_jlong_545,
+    (void (*)(void))sfp_jlong_546,
+    (void (*)(void))sfp_jlong_547,
+    (void (*)(void))sfp_jlong_548,
+    (void (*)(void))sfp_jlong_549,
+    (void (*)(void))sfp_jlong_550,
+    (void (*)(void))sfp_jlong_551,
+    (void (*)(void))sfp_jlong_552,
+    (void (*)(void))sfp_jlong_553,
+    (void (*)(void))sfp_jlong_554,
+    (void (*)(void))sfp_jlong_555,
+    (void (*)(void))sfp_jlong_556,
+    (void (*)(void))sfp_jlong_557,
+    (void (*)(void))sfp_jlong_558,
+    (void (*)(void))sfp_jlong_559,
+    (void (*)(void))sfp_jlong_560,
+    (void (*)(void))sfp_jlong_561,
+    (void (*)(void))sfp_jlong_562,
+    (void (*)(void))sfp_jlong_563,
+    (void (*)(void))sfp_jlong_564,
+    (void (*)(void))sfp_jlong_565,
+    (void (*)(void))sfp_jlong_566,
+    (void (*)(void))sfp_jlong_567,
+    (void (*)(void))sfp_jlong_568,
+    (void (*)(void))sfp_jlong_569,
+    (void (*)(void))sfp_jlong_570,
+    (void (*)(void))sfp_jlong_571,
+    (void (*)(void))sfp_jlong_572,
+    (void (*)(void))sfp_jlong_573,
+    (void (*)(void))sfp_jlong_574,
+    (void (*)(void))sfp_jlong_575,
+    (void (*)(void))sfp_jlong_576,
+    (void (*)(void))sfp_jlong_577,
+    (void (*)(void))sfp_jlong_578,
+    (void (*)(void))sfp_jlong_579,
+    (void (*)(void))sfp_jlong_580,
+    (void (*)(void))sfp_jlong_581,
+    (void (*)(void))sfp_jlong_582,
+    (void (*)(void))sfp_jlong_583,
+    (void (*)(void))sfp_jlong_584,
+    (void (*)(void))sfp_jlong_585,
+    (void (*)(void))sfp_jlong_586,
+    (void (*)(void))sfp_jlong_587,
+    (void (*)(void))sfp_jlong_588,
+    (void (*)(void))sfp_jlong_589,
+    (void (*)(void))sfp_jlong_590,
+    (void (*)(void))sfp_jlong_591,
+    (void (*)(void))sfp_jlong_592,
+    (void (*)(void))sfp_jlong_593,
+    (void (*)(void))sfp_jlong_594,
+    (void (*)(void))sfp_jlong_595,
+    (void (*)(void))sfp_jlong_596,
+    (void (*)(void))sfp_jlong_597,
+    (void (*)(void))sfp_jlong_598,
+    (void (*)(void))sfp_jlong_599
+};
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_string.cpp b/src/mrt/maplert/src/mrt_string.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db6fe9ae40e6786b229700cb58d6a0a2236784bd
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_string.cpp
@@ -0,0 +1,1646 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "mrt_string.h"
+#include <unordered_set>
+#include "jni.h"
+#include "allocator/page_allocator.h"
+#include "mstring_inline.h"
+#include "base/low_mem_set.h"
+#include "libs.h"
+#include "exception/mrt_exception.h"
+#include "literalstrname.h"
+using namespace std;
+
+namespace maplert {
+enum ZeroCodeT {
+  kZeroNotcode = 0,
+  kZeroDocode
+};
+
+int GetMUtf8ByteCount(const uint16_t *utf16Raw, size_t charCount, ZeroCodeT zCode, int charSet);
+void MUtf8Encode(uint8_t *utf8Res, const uint16_t *utf16Raw, size_t charCount, ZeroCodeT zCode, int charSet);
+void MUtf8Decode(const uint8_t *utf8, size_t utf8Len, uint16_t *utf16Res);
+uint32_t CountInMutfLen(const char *utf8, size_t utf8Len);
+extern "C" char *MRT_GetStringContentsPtrRaw(jstring jstr) {
+  MString *stringObj = MString::JniCastNonNull(jstr);
+  return reinterpret_cast<char*>(stringObj->GetContentsPtr());
+}
+
+extern "C" jchar *MRT_GetStringContentsPtrCopy(jstring jstr, jboolean *isCopy) {
+  MString *stringObj = MString::JniCastNonNull(jstr);
+  if (stringObj->IsCompress()) {
+    uint32_t len = stringObj->GetLength();
+    jchar *chars = reinterpret_cast<jchar*>(malloc(len * sizeof(jchar) + 1));
+    if (UNLIKELY(chars == nullptr)) {
+      return nullptr;
+    }
+    const uint8_t *src = stringObj->GetContentsPtr();
+    jchar *pos = chars;
+    jchar *end = pos + len;
+    while (pos < end) {
+      *pos++ = *src++;
+    }
+    if (isCopy != nullptr) {
+      *isCopy = JNI_TRUE;
+    }
+    return chars;
+  } else {
+    if (isCopy != nullptr) {
+      *isCopy = JNI_FALSE;
+    }
+    return reinterpret_cast<jchar*>(stringObj->GetContentsPtr());
+  }
+}
+
+extern "C" jstring MRT_NewHeapJStr(const jchar *ca, jint len, bool isJNI) {
+  MString *res = MString::NewStringObject(ca, static_cast<uint32_t>(len), isJNI);
+  if (res == nullptr) {
+    return nullptr;
+  }
+  return res->AsJstring();
+}
+
+extern "C" jstring MCC_CStrToJStr(const char *ca, jint len) {
+  MString *res = MString::NewStringObject(reinterpret_cast<const uint8_t*>(ca), static_cast<uint32_t>(len));
+  return reinterpret_cast<jstring>(res);
+}
+
+extern "C" jstring CStrToJStr(const char *ca, jint len)
+__attribute__((alias("MCC_CStrToJStr")));
+
+MString *StringNewStringFromString(const MString &stringObj) {
+  uint32_t length = stringObj.GetLength();
+  uint8_t *contents = stringObj.GetContentsPtr();
+  MString *res = nullptr;
+  if (stringObj.IsCompress()) {
+    res = MString::NewStringObject<uint8_t>(contents, length);
+  } else {
+    res = MString::NewStringObject<uint16_t>(reinterpret_cast<uint16_t*>(contents), length);
+  }
+  return res;
+}
+
+MString *StringNewStringFromSubstring(const MString &stringObj, int32_t start, uint32_t length) {
+  MString *res = nullptr;
+  const uint8_t *src = stringObj.GetContentsPtr();
+  if (stringObj.IsCompress()) {
+    res = MString::NewStringObject<uint8_t>(src + start, length);
+  } else {
+    const uint16_t *srcStart = reinterpret_cast<const uint16_t*>(src) + start;
+    bool isCompress = false;
+    if (stringObj.GetCountValue() < static_cast<uint32_t>(start)) {
+      isCompress = false;
+    } else {
+      isCompress = MString::IsCompressChars<uint16_t>(srcStart, static_cast<uint32_t>(length));
+    }
+    res = isCompress ? MString::NewStringObject<uint16_t, uint8_t>(srcStart, length) :
+                       MString::NewStringObject<uint16_t>(srcStart, length);
+  }
+  return res;
+}
+
+MString *StringNewStringFromCharArray(int32_t offset, uint32_t charCount, const MArray &arrayObj) {
+  uint16_t *arrayData = reinterpret_cast<uint16_t*>(arrayObj.ConvertToCArray());
+  uint16_t *content = arrayData + offset;
+  const bool compressible = MString::IsCompressChars<uint16_t>(content, charCount);
+  MString *res = compressible ? MString::NewStringObject<uint16_t, uint8_t>(content, charCount) :
+                                MString::NewStringObject<uint16_t>(content, charCount);
+  return res;
+}
+
+MString *StringNewStringFromByteArray(const MArray &arrayObj, int32_t highByteT, int32_t offset, uint32_t byteLength) {
+  uint8_t *arrayData = reinterpret_cast<uint8_t*>(arrayObj.ConvertToCArray());
+  uint8_t *content = arrayData + offset;
+  const bool compressible = (highByteT == 0) && MString::IsCompressChars<uint8_t>(content, byteLength);
+  MString *res = nullptr;
+  if (compressible) {
+    res = MString::NewStringObject<uint8_t>(content, byteLength);
+  } else {
+    res = MString::NewStringObject<uint16_t>(byteLength, [&](MString &stringObj) {
+      uint32_t highByte = (static_cast<uint32_t>(highByteT)) << 8; // shift one byte to obtain highbyte
+      uint16_t *resDst = reinterpret_cast<uint16_t*>(stringObj.GetContentsPtr());
+      for (uint32_t i = 0; i < byteLength; ++i) {
+        resDst[i] = highByte | content[i];
+      }
+    });
+  }
+  return res;
+}
+
+template<typename srcType, typename dstType>
+static inline void MStringDoReplace(const MString &srcStrObj, const MString &dstStrObj, uint16_t oldChar,
+                                    uint16_t newChar, uint32_t len) {
+  srcType *src = reinterpret_cast<srcType*>(srcStrObj.GetContentsPtr());
+  dstType *dst = reinterpret_cast<dstType*>(dstStrObj.GetContentsPtr());
+  for (uint32_t i = 0; i < len; ++i) {
+    srcType c = src[i];
+    dst[i] = (c == oldChar) ? newChar : c;
+  }
+}
+
+MString *JStringDoReplace(const MString &stringObj, uint16_t oldChar, uint16_t newChar) {
+  bool srcIsCompressible = stringObj.IsCompress();
+  uint32_t srcLength = stringObj.GetLength();
+  uint8_t *srcValue = stringObj.GetContentsPtr();
+  bool compressible = MString::GetCompressFlag() && MString::IsCompressChar(newChar) && (srcIsCompressible ||
+                      (!MString::IsCompressChar(oldChar) &&
+                      MString::IsCompressCharsExcept(reinterpret_cast<uint16_t*>(srcValue), srcLength, oldChar)));
+  MString *res = nullptr;
+  if (compressible) {
+    res = MString::NewStringObject<uint8_t>(srcLength, [&](MString &newStringObj) {
+      if (srcIsCompressible) {
+        MStringDoReplace<uint8_t, uint8_t>(stringObj, newStringObj, oldChar, newChar, srcLength);
+      } else {
+        MStringDoReplace<uint16_t, uint8_t>(stringObj, newStringObj, oldChar, newChar, srcLength);
+      }
+    });
+  } else {
+    res = MString::NewStringObject<uint16_t>(srcLength, [&](MString &newStringObj) {
+      if (srcIsCompressible) {
+        MStringDoReplace<uint8_t, uint16_t>(stringObj, newStringObj, oldChar, newChar, srcLength);
+      } else {
+        MStringDoReplace<uint16_t, uint16_t>(stringObj, newStringObj, oldChar, newChar, srcLength);
+      }
+    });
+  }
+  return res;
+}
+
+static void GetCompressedNewValue(const bool stringCompress, const MString &stringObj, uint32_t stringLen,
+                                  uint32_t string1Len, uint16_t *newValue) {
+  if (stringCompress) {
+    uint8_t *value = stringObj.GetContentsPtr();
+    for (uint32_t i = 0; i < stringLen; ++i) {
+      newValue[i + string1Len] = value[i];
+    }
+  } else {
+    const int doubleSize = 2;
+    uint16_t *value = reinterpret_cast<uint16_t*>(stringObj.GetContentsPtr());
+    uint32_t cpyLen = 0;
+    if (stringLen <= UINT32_MAX / doubleSize) {
+      cpyLen = stringLen * doubleSize;
+    } else {
+      LOG(FATAL) << "stringLen * doubleSize >  UINT32_MAX" << maple::endl;
+    }
+    if (memcpy_s(newValue + string1Len, cpyLen, value, cpyLen) != EOK) {
+      LOG(ERROR) << "memcpy_s() not return 0 in GetCompressedNewValue()" << maple::endl;
+    }
+  }
+}
+
+// This Function is to concat two String, the String maybe compress or uncompress, when it's compress,
+// the String is saved as uint8_t and when it's uncompress, it's saved double the storage as uint16_t
+MString *StringConcat(MString &stringObj1, MString &stringObj2) {
+  uint32_t string1Count = stringObj1.GetCountValue();
+  uint32_t string2Count = stringObj2.GetCountValue();
+  uint32_t string1Len = string1Count >> 1;
+  uint32_t string2Len = string2Count >> 1;
+  if (string1Len == 0) {
+    RC_LOCAL_INC_REF(&stringObj2);
+    return &stringObj2;
+  }
+  if (string2Len == 0) {
+    RC_LOCAL_INC_REF(&stringObj1);
+    return &stringObj1;
+  }
+
+  const bool string1Compress = MString::IsCompressedFromCount(string1Count);
+  const bool string2Compress = MString::IsCompressedFromCount(string2Count);
+  const bool compressible = MString::GetCompressFlag() && string1Compress && string2Compress;
+  uint32_t len = string1Len + string2Len;
+  MString *res = nullptr;
+  if (compressible) {
+    res = MString::NewStringObject<uint8_t>(len, [&](MString &newStringObj) {
+      uint8_t *newValue = newStringObj.GetContentsPtr();
+      uint8_t *value1 = stringObj1.GetContentsPtr();
+      uint8_t *value2 = stringObj2.GetContentsPtr();
+      errno_t returnValueOfMemcpyS1 = memcpy_s(newValue, string1Len, value1, string1Len);
+      errno_t returnValueOfMemcpyS2 = memcpy_s(newValue + string1Len, string2Len, value2, string2Len);
+      if (returnValueOfMemcpyS1 != EOK || returnValueOfMemcpyS2 != EOK) {
+        LOG(ERROR) << "memcpy_s() not return 0 in StringConcat()" << maple::endl;
+      }
+    });
+  } else {
+    res = MString::NewStringObject<uint16_t>(len, [&](MString &newStringObj) {
+      uint16_t *newValue = reinterpret_cast<uint16_t*>(newStringObj.GetContentsPtr());
+      GetCompressedNewValue(string1Compress, stringObj1, string1Len, 0, newValue);
+      GetCompressedNewValue(string2Compress, stringObj2, string2Len, string1Len, newValue);
+    });
+  }
+  return res;
+}
+
+template<typename MemoryType>
+static inline int32_t FastIndexOf(const MemoryType &chars, int32_t ch, int32_t start, int32_t length) {
+  const MemoryType *p = &chars + start;
+  const MemoryType *end = &chars + length;
+  while (p < end) {
+    if (*p++ == ch) {
+      return static_cast<int32_t>((p - 1) - &chars);
+    }
+  }
+  return -1;
+}
+
+int32_t StringFastIndexOf(const MString &stringObj, int32_t ch, int32_t start) {
+  uint32_t count = stringObj.GetCountValue();
+  int32_t len = static_cast<int32_t>(count >> 1);
+  if (start < 0) {
+    start = 0;
+  } else if (start > len) {
+    start = len;
+  }
+
+  if (MString::IsCompressedFromCount(count)) {
+    uint8_t *value = stringObj.GetContentsPtr();
+    return FastIndexOf<uint8_t>(*value, ch, start, len);
+  } else {
+    uint16_t *value = reinterpret_cast<uint16_t*>(stringObj.GetContentsPtr());
+    return FastIndexOf<uint16_t>(*value, ch, start, len);
+  }
+}
+
+// Create and return Java string  from c string (in UTF-8)
+MString *NewStringUTF(const char *kCStr, size_t cStrLen) {
+  MString *res = MString::NewStringObject<uint8_t, uint8_t>(
+      reinterpret_cast<const uint8_t*>(kCStr), static_cast<uint32_t>(cStrLen));
+  return res;
+}
+
+// Create and return Java string from UTF-16/UTF-8
+MString *NewStringFromUTF16(const std::string &str) {
+  return MString::NewStringObjectFromUtf16(str);
+}
+
+extern "C" void MRT_ReleaseStringUTFChars(jstring jstr __attribute__((unused)), const char *chars) {
+  free(const_cast<char*>(chars));
+  return;
+}
+
+extern "C" void MRT_ReleaseStringChars(jstring jstr, const jchar *chars) {
+  MString *stringObj = MString::JniCastNonNull(jstr);
+  jchar *contents = reinterpret_cast<jchar*>(stringObj->GetContentsPtr());
+  if (stringObj->IsCompress() || chars != contents) {
+    free(const_cast<jchar*>(chars));
+  }
+}
+
+extern "C" jint MRT_StringGetStringLength(jstring jstr) {
+  MString *stringObj = MString::JniCastNonNull(jstr);
+  return stringObj->GetLength();
+}
+
+size_t MRT_GetStringObjectSize(jstring jstr) {
+  MString *stringObj = MString::JniCast(jstr);
+  return stringObj == nullptr ? MString::GetStringBaseSize() : stringObj->GetStringSize();
+}
+
+MArray *MStringToBytes(const MString &stringObj, int32_t offset, int32_t length, uint16_t maxValidChar, int compress) {
+  char *src = reinterpret_cast<char*>(stringObj.GetContentsPtr());
+  uint32_t srcContentSize = stringObj.GetLength();
+  if (UNLIKELY(offset < 0 || length < 0 || static_cast<uint32_t>(offset + length) > srcContentSize)) {
+    LOG(FATAL) << "the index to access stringObj is illegal" << maple::endl;
+    return nullptr;
+  }
+  MArray *dst = MArray::NewPrimitiveArray<kElemByte>(static_cast<uint32_t>(length),
+      *WellKnown::GetPrimitiveArrayClass(maple::Primitive::kByte));
+  int8_t *buf = reinterpret_cast<int8_t*>(dst->ConvertToCArray());
+  int8_t *end = buf + length;
+  uint16_t tmp = 0;
+  if (compress != 0) {
+    src = src + offset;
+    while (buf < end) {
+      tmp = *src++;
+      tmp = (tmp > maxValidChar) ? '?' : tmp;
+      *buf++ = static_cast<int8_t>(tmp);
+    }
+  } else {
+    src = src + static_cast<int64_t>(offset) * 2; // not compress, offset should be twice
+    while (buf < end) {
+      tmp = *(reinterpret_cast<uint16_t*>(src));
+      src += 2; // uint16_t is u16, when read char*, char ptr need to move 2 at a time
+      tmp = (tmp > maxValidChar) ? '?' : tmp;
+      *buf++ = static_cast<int8_t>(tmp);
+    }
+  }
+  return dst;
+}
+
+// MUTF-8 format string start
+MArray *MStringToMutf8(const MString &stringObj, int32_t offset, int32_t length, int compress) {
+  char *src = reinterpret_cast<char*>(stringObj.GetContentsPtr());
+  MArray *dst = nullptr;
+  uint32_t srcContentSize = stringObj.GetLength();
+  if (UNLIKELY(offset < 0 || length < 0 || static_cast<uint32_t>(offset + length) > srcContentSize)) {
+    LOG(FATAL) << "the index to access stringObj is illegal" << maple::endl;
+    return nullptr;
+  }
+  if (compress != 0) {
+    src += offset;
+    dst = MArray::NewPrimitiveArray<kElemByte>(static_cast<uint32_t>(length),
+        *WellKnown::GetPrimitiveArrayClass(maple::Primitive::kByte));
+    int8_t *buf = reinterpret_cast<int8_t*>(dst->ConvertToCArray());
+    for (int i = 0; i < length; ++i) {
+      buf[i] = src[i];
+    }
+  } else {
+    uint16_t *pos = reinterpret_cast<uint16_t*>(src) + offset;
+    int count = GetMUtf8ByteCount(pos, length, kZeroNotcode, 1);
+    dst = MArray::NewPrimitiveArray<kElemByte>(static_cast<uint32_t>(count),
+        *WellKnown::GetPrimitiveArrayClass(maple::Primitive::kByte));
+    uint8_t *buf = reinterpret_cast<uint8_t*>(dst->ConvertToCArray());
+    MUtf8Encode(buf, pos, static_cast<uint32_t>(length), kZeroNotcode, 1);
+  }
+  return dst;
+}
+
+extern "C" jstring MRT_NewStringMUTF(const char *inMutf, size_t inMutfLen, bool isJNI) {
+  MString *res = nullptr;
+  uint32_t length = CountInMutfLen(inMutf, inMutfLen);
+  const bool kCompressible = MString::GetCompressFlag() && (length > 0) && (inMutfLen == length);
+  if (kCompressible) {
+    res = MString::NewStringObject<uint8_t>(reinterpret_cast<const uint8_t*>(inMutf), length, isJNI);
+    if (res == nullptr) {
+      return nullptr;
+    }
+  } else {
+    res = MString::NewStringObject<uint16_t>(length, [&](MString &newStringObj) {
+      uint16_t *outUnicode = reinterpret_cast<uint16_t*>(newStringObj.GetContentsPtr());
+      MUtf8Decode(reinterpret_cast<const uint8_t*>(inMutf), inMutfLen, outUnicode);
+    }, isJNI);
+  }
+  return res->AsJstring();
+}
+
+extern "C" jsize MRT_GetStringMUTFLength(jstring jstr) {
+  MString *stringObj = MString::JniCastNonNull(jstr);
+  uint32_t length = stringObj->GetLength();
+  uint16_t *utf16Raw = nullptr;
+  jint res;
+  if (stringObj->IsCompress()) {
+    res = static_cast<int>(length);
+  } else {
+    utf16Raw = reinterpret_cast<uint16_t*>(stringObj->GetContentsPtr());
+    res = GetMUtf8ByteCount(utf16Raw, length, kZeroDocode, 0);
+  }
+  return res;
+}
+
+extern "C" char *MRT_GetStringMUTFChars(jstring jstr, jboolean *isCopy) {
+  MString *stringObj = MString::JniCastNonNull(jstr);
+  if (isCopy != nullptr) {
+    *isCopy = JNI_TRUE;
+  }
+  uint32_t count = stringObj->GetCountValue();
+  char *res = nullptr;
+  uint32_t len = count >> 1;
+  if (MString::IsCompressedFromCount(count)) {
+    res = reinterpret_cast<char*>(malloc((len + 1) * sizeof(char)));
+    if (UNLIKELY(res == nullptr)) {
+      if (isCopy != nullptr) {
+        *isCopy = JNI_FALSE;
+      }
+      return nullptr;
+    }
+    res[len] = 0;
+    const char *data = reinterpret_cast<char*>(stringObj->GetContentsPtr());
+    for (uint32_t i = 0; i < len; ++i) {
+      res[i] = data[i];
+    }
+  } else {
+    uint16_t *utf16Raw = reinterpret_cast<uint16_t*>(stringObj->GetContentsPtr());
+    uint32_t length = static_cast<uint32_t>(GetMUtf8ByteCount(utf16Raw, len, kZeroDocode, 0));
+    uint8_t *mutfStr = nullptr;
+    mutfStr = reinterpret_cast<uint8_t*>(malloc((length + 1) * sizeof(uint8_t)));
+    if (UNLIKELY(mutfStr == nullptr)) {
+      if (isCopy != nullptr) {
+        *isCopy = JNI_FALSE;
+      }
+      return nullptr;
+    }
+    mutfStr[length] = 0;
+    if (length == 0) {
+      return reinterpret_cast<char*>(mutfStr);
+    }
+    MUtf8Encode(mutfStr, utf16Raw, len, kZeroDocode, 0);
+    res = reinterpret_cast<char*>(mutfStr);
+  }
+  return res;
+}
+
+extern "C" void MRT_GetStringMUTFRegion(jstring jstr, jsize start, jsize length, char *buf) {
+  MString *stringObj = MString::JniCastNonNull(jstr);
+  if (UNLIKELY(buf == nullptr)) {
+    return;
+  }
+  if (stringObj->IsCompress()) {
+    const char *data = reinterpret_cast<char*>(stringObj->GetContentsPtr());
+    data = data + start;
+    for (jint i = 0; i < length; ++i) {
+      buf[i] = data[i];
+    }
+  } else {
+    char *src = reinterpret_cast<char*>(stringObj->GetContentsPtr());
+    uint16_t *utf16Raw = nullptr;
+    utf16Raw = reinterpret_cast<uint16_t*>(src) + start;
+    uint8_t *mutfStr = reinterpret_cast<uint8_t*>(buf);
+    if (length == 0) {
+      return;
+    }
+    MUtf8Encode(mutfStr, utf16Raw, length, kZeroDocode, 0);
+  }
+} // MUTF-8 format string end
+
+// literals in MFile (with only jstring_payload) cannot be inserted into MapleStringPool directly,
+// instead, a new string in PERM-space will be created.
+// thus, all jstring_payload_p points to the middle of a valid java string object. the begin of
+// the MString object can be obtained by a negtive offset from jstring_payload_p
+const int kZygotePoolBucketNum = 997; // prime number
+const int kAppPoolBucketNum = 113; // prime number
+const int kPoolNum = 47;  // prime number
+const int kClassNameNum = 1024;
+static maple::SpinLock mtx[kPoolNum];
+using  MapleStringPool = maple::LowMemSet<MStringRef, MStringHashEqual>;
+static MapleStringPool zygoteStringPool[kPoolNum];
+static MapleStringPool *appStringAppPool = nullptr;
+
+enum SweepState : uint8_t {
+  kClean,
+  kReadyToSweep
+};
+
+using MUnorderedMap = std::unordered_map<char*, MStringRef, std::hash<char*>,
+    std::equal_to<char*>, StdContainerAllocator<std::pair<char * const, MStringRef>, kClassNameStringPool>>;
+static MUnorderedMap classnameMap(kClassNameNum);
+static maple::SpinLock mtxForClassname;
+uint8_t sweepingStateForClassName;
+static size_t deadClassNameNum = 0;
+
+void RemoveDeadClassNameFromPoolLocked(MUnorderedMap &pool, uint8_t &state) {
+  if (LIKELY(state != static_cast<uint8_t>(kReadyToSweep))) {
+    if (UNLIKELY(state != static_cast<uint8_t>(kClean))) {
+      LOG(FATAL) << "[StringPool] Concurrent Sweeping ilegal state" << maple::endl;
+    }
+    return;
+  }
+
+  size_t curDead = 0;
+  for (auto it = pool.begin(); it != pool.end();) {
+    address_t addr = (it->second).GetRef();
+    if (IS_HEAP_OBJ(addr) && MRT_IsGarbage(addr)) {
+      it = pool.erase(it);
+      ++curDead;
+    } else {
+      ++it;
+    }
+  }
+  deadClassNameNum += curDead;
+  state = static_cast<uint8_t>(kClean);
+}
+
+MString *NewStringUtfFromPoolForClassName(const MClass &classObj) {
+  char *cStr = classObj.GetName();
+  if (UNLIKELY(cStr == nullptr)) {
+    return nullptr;
+  }
+  if (!MRT_EnterSaferegion()) {
+    __MRT_ASSERT(false, "calling NewStringUtfFromPoolForClassName from saferegion");
+  }
+  mtxForClassname.Lock();
+  (void)MRT_LeaveSaferegion();
+  RemoveDeadClassNameFromPoolLocked(classnameMap, sweepingStateForClassName);
+  auto it = classnameMap.find(cStr);
+  MStringRef newStrObj;
+  if (it == classnameMap.end()) {
+    mtxForClassname.Unlock();
+    string binaryName;
+    classObj.GetBinaryName(binaryName);
+    newStrObj.SetRef(NewStringFromUTF16(binaryName));
+    ScopedHandles sHandles;
+    ObjHandle<MStringRef, false> stringInst(newStrObj.GetRef());
+    if (!MRT_EnterSaferegion()) {
+      __MRT_ASSERT(false, "calling NewStringUtfFromPoolForClassName from saferegion");
+    }
+    mtxForClassname.Lock();
+    (void)MRT_LeaveSaferegion();
+    it = classnameMap.find(cStr);
+  }
+
+  if (it == classnameMap.end()) {
+    RC_LOCAL_INC_REF(reinterpret_cast<MString*>(newStrObj.GetRef()));
+    classnameMap[cStr] = newStrObj;
+    mtxForClassname.Unlock();
+    return reinterpret_cast<MString*>(newStrObj.GetRef());
+  } else {
+    // When we reuse a string from pool, the string may have been dead in java world,
+    // we should set it as renewed to make concurrent marking happy.
+    if (reinterpret_cast<MString*>(newStrObj.GetRef()) != nullptr) {
+      RC_LOCAL_DEC_REF(reinterpret_cast<MString*>(newStrObj.GetRef()));
+    }
+    MRT_PreRenewObject((it->second).GetRef());
+    RC_LOCAL_INC_REF(reinterpret_cast<MString*>((it->second).GetRef()));
+    mtxForClassname.Unlock();
+    return reinterpret_cast<MString*>((it->second).GetRef());
+  }
+}
+
+void CreateAppStringPool() {
+  if (appStringAppPool == nullptr) {
+    appStringAppPool = new (std::nothrow) MapleStringPool[kPoolNum];
+    __MRT_ASSERT(appStringAppPool != nullptr, "fail to allocate app const string pool!");
+    for (int i = 0; i < kPoolNum; ++i) {
+      appStringAppPool[i].Reserve(kAppPoolBucketNum);
+    }
+  }
+}
+
+int InitializeMapleStringPool() {
+  for (int i = 0; i < kPoolNum; ++i) {
+    zygoteStringPool[i].Reserve(kZygotePoolBucketNum);
+  }
+  sweepingStateForClassName = static_cast<uint8_t>(kClean);
+  return 0;
+}
+
+static int initialize = InitializeMapleStringPool();
+
+void StringPrepareConcurrentSweeping() {
+  sweepingStateForClassName = static_cast<uint8_t>(kReadyToSweep);
+  deadClassNameNum = 0;
+}
+
+size_t ConstStringPoolSize(bool literal) {
+  size_t cspSize = 0;
+  auto visitor = [literal, &cspSize](const MStringRef strRef) {
+    MString *jstr = reinterpret_cast<MString*>(strRef.GetRef());
+    if (literal == jstr->IsLiteral()) {
+      cspSize += jstr->GetStringSize();
+    }
+  };
+  for (int i = 0; i < kPoolNum; ++i) {
+    maple::SpinAutoLock guard(mtx[i]);
+    zygoteStringPool[i].ForEach(visitor);
+    if (appStringAppPool != nullptr) {
+      appStringAppPool[i].ForEach(visitor);
+    }
+  }
+  return cspSize;
+}
+
+size_t ConstStringPoolNum(bool literal) {
+  size_t cspNum = 0;
+  auto visitor = [literal, &cspNum](const MStringRef strRef) {
+    MString *s = reinterpret_cast<MString*>(strRef.GetRef());
+    if (literal == s->IsLiteral()) {
+      ++cspNum;
+    }
+  };
+  for (int i = 0; i < kPoolNum; ++i) {
+    maple::SpinAutoLock guard(mtx[i]);
+    zygoteStringPool[i].ForEach(visitor);
+    if (appStringAppPool != nullptr) {
+      appStringAppPool[i].ForEach(visitor);
+    }
+  }
+  return cspNum;
+}
+
+size_t ConstStringAppPoolNum(bool literal) {
+  size_t cspNum = 0;
+  if (appStringAppPool != nullptr) {
+    for (int i = 0; i < kPoolNum; ++i) {
+      maple::SpinAutoLock guard(mtx[i]);
+      appStringAppPool[i].ForEach([literal, &cspNum](const MStringRef strRef) {
+        MString *s = reinterpret_cast<MString*>(strRef.GetRef());
+        if (literal == s->IsLiteral()) {
+          ++cspNum;
+        }
+      });
+    }
+  }
+  return cspNum;
+}
+
+void DumpJString(std::ostream &os, const MString &stringObj, bool dumpName) {
+  uint32_t len = stringObj.GetLength();
+  const uint8_t *data = stringObj.GetContentsPtr();
+  std::ios::fmtflags f(os.flags());
+
+  if (dumpName) {
+    if (stringObj.IsCompress()) {
+      // need to convert to utf16 to calculate LiteralStrName
+      int constexpr maxLiteralLength = 1024; // up to 2KB local stack
+      if (len > maxLiteralLength) {
+        return; // just skip it
+      }
+
+      uint16_t utf16Raw[maxLiteralLength] = { 0 };
+      for (uint32_t i = 0; i < len; ++i) {
+        utf16Raw[i] = data[i];
+      }
+      os << LiteralStrName::GetLiteralStrName(reinterpret_cast<const uint8_t*>(utf16Raw), len << 1);
+    } else {
+      os << LiteralStrName::GetLiteralStrName(data, len << 1);
+    }
+  } else {
+    if (!stringObj.IsCompress()) {
+      len = len << 1;
+    }
+    for (uint32_t i = 0; i < len; ++i) {
+      os << std::setfill('0') << std::setw(2) << std::hex << static_cast<int>(data[i]);
+    }
+  }
+  os << "\n";
+  os.flags(f);
+}
+
+void DumpConstStringPool(std::ostream &os, bool literal) {
+  auto visitor = [literal, &os](const MStringRef strRef) {
+    MString *s = reinterpret_cast<MString*>(strRef.GetRef());
+    if (literal == s->IsLiteral()) {
+      DumpJString(os, *s, true); // uuid name only
+    }
+  };
+  for (int i = 0; i < kPoolNum; ++i) {
+    maple::SpinAutoLock guard(mtx[i]);
+    zygoteStringPool[i].ForEach(visitor);
+    if (appStringAppPool != nullptr) {
+      appStringAppPool[i].ForEach(visitor);
+    }
+  }
+}
+
+void VisitStringPool(const RefVisitor &visitor) {
+  for (auto iter = classnameMap.begin(); iter != classnameMap.end(); ++iter) {
+    visitor(reinterpret_cast<address_t&>((iter->second).GetRawRef())); // pass direct root ref for moving gc
+  }
+}
+
+void MRT_ScanLiteralPoolRoots(function<void(uintptr_t)> visitRoot) {
+  auto visitor = [&visitRoot](const MStringRef strRef) {
+    MString *s = reinterpret_cast<MString*>(strRef.GetRef());
+    if (s->IsLiteral()) {
+      visitRoot(reinterpret_cast<address_t>(s));
+    }
+  };
+  for (int i = 0; i < kPoolNum; ++i) {
+    zygoteStringPool[i].ForEach(visitor);
+    if (appStringAppPool != nullptr) {
+      appStringAppPool[i].ForEach(visitor);
+    }
+  }
+}
+
+size_t ConcurrentSweepDeadStrings(maplert::MplThreadPool*) {
+  maple::SpinAutoLock guard(mtxForClassname);
+  RemoveDeadClassNameFromPoolLocked(classnameMap, sweepingStateForClassName);
+  return deadClassNameNum;
+}
+
+size_t RemoveDeadStringFromPool() {
+  size_t count = 0;
+  for (auto it = classnameMap.begin(); it != classnameMap.end();) {
+    address_t addr = (it->second).GetRef();
+    // dead string might already cleared in early sweep
+    // object already cleared, only fast check is enough
+    if ((IS_HEAP_OBJ(addr) && MRT_IsGarbage(addr))) {
+      it = classnameMap.erase(it);
+      MRT_DecRefUnsync(addr);
+      ++count;
+    } else {
+      ++it;
+    }
+  }
+  return count;
+}
+
+// non-literal strings using this interface, it always returns a off-heap MString.
+MString *GetOrInsertStringPool(MString &stringObj) {
+  uint32_t count = stringObj.GetCountValue();
+  const uint8_t *data = stringObj.GetContentsPtr();
+
+  uint32_t hash = stringObj.GetHash();
+  if (hash == 0) {
+    hash = LiteralStrName::CalculateHash(reinterpret_cast<const char16_t*>(data),
+                                         count >> 1, MString::IsCompressedFromCount(count));
+    // this is not thead safe
+    stringObj.SetHash(hash);
+  }
+
+  uint32_t num = hash % kPoolNum;
+  maple::SpinAutoLock guard(mtx[num]);
+  // try to find existing string first
+  MStringRef retStrObj;
+  auto iter = zygoteStringPool[num].Find(&stringObj);
+  if (iter != zygoteStringPool[num].End()) { // found
+    retStrObj = zygoteStringPool[num].Element(iter);
+    return reinterpret_cast<MString*>(retStrObj.GetRef());
+  } else if (appStringAppPool != nullptr) {
+    iter = appStringAppPool[num].Find(&stringObj);
+    if (iter != appStringAppPool[num].End()) { // found
+      retStrObj = appStringAppPool[num].Element(iter);
+      return reinterpret_cast<MString*>(retStrObj.GetRef());
+    }
+  }
+
+  // not found: create a new stringObj in perm-spaceto and insert
+  uint32_t strObjSize = stringObj.GetStringSize();
+  // is there possibly a deadlock here (with mtx[num].lock)?
+  address_t newStringObj = MRT_AllocFromPerm(strObjSize);
+  if (UNLIKELY(newStringObj == 0)) {
+    return nullptr;
+  }
+  retStrObj.SetRef(newStringObj);
+  char *pDstStr = reinterpret_cast<char*>(retStrObj.GetRef());
+  char *pSrcStr = reinterpret_cast<char*>(&stringObj);
+  for (uint32_t i = 0; i < strObjSize; ++i) {
+    pDstStr[i] = pSrcStr[i];
+  }
+
+  if (appStringAppPool != nullptr) {
+    appStringAppPool[num].Insert(retStrObj);
+  } else {
+    zygoteStringPool[num].Insert(retStrObj);
+  }
+  mtx[num].Unlock();
+  return reinterpret_cast<MString*>(retStrObj.GetRef());
+}
+// Note:only used to insert literal (stored in static fields) into pool,
+//      currently only used by mpl-linker
+// literal might be a full MString object, or only the jstring_payload
+MString *GetOrInsertLiteral(MString &literalObj) {
+  // all literals already has hash set ready.
+  uint32_t num = literalObj.GetHash() % kPoolNum;
+  mtx[num].Lock();
+  literalObj.SetStringClass();
+  MStringRef retStrObj;
+  auto iter = zygoteStringPool[num].Find(&literalObj);
+  if (iter != zygoteStringPool[num].End()) { // found
+    retStrObj = zygoteStringPool[num].Element(iter);
+    mtx[num].Unlock();
+    return reinterpret_cast<MString*>(retStrObj.GetRef());
+  } else if (appStringAppPool != nullptr) {
+    iter = appStringAppPool[num].Find(&literalObj);
+    if (iter != appStringAppPool[num].End()) {
+      retStrObj = appStringAppPool[num].Element(iter);
+      mtx[num].Unlock();
+      return reinterpret_cast<MString*>(retStrObj.GetRef());
+    }
+  }
+
+  retStrObj.SetRef(&literalObj);
+  if (appStringAppPool != nullptr) {
+    appStringAppPool[num].Insert(retStrObj);
+  } else {
+    zygoteStringPool[num].Insert(retStrObj);
+  }
+  mtx[num].Unlock();
+  return reinterpret_cast<MString*>(retStrObj.GetRef());
+}
+
+// Note: used to insert literal into pool, only for compiler generated code
+extern "C" jstring MCC_GetOrInsertLiteral(jstring literal) {
+  MString *literalObj = reinterpret_cast<MString*>(literal);
+  DCHECK(literalObj != nullptr);
+  jstring retJstr = reinterpret_cast<jstring>(GetOrInsertLiteral(*literalObj));
+  return retJstr;
+}
+
+void RemoveStringFromPool(MString &stringObj) {
+  uint32_t judgeHash = stringObj.GetHash();
+  uint32_t num = judgeHash % kPoolNum;
+  mtx[num].Lock();
+  auto iter = zygoteStringPool[num].Find(&stringObj);
+  if (iter != zygoteStringPool[num].End()) {
+    zygoteStringPool[num].Erase(iter);
+  } else if (appStringAppPool != nullptr) {
+    iter = appStringAppPool[num].Find(&stringObj);
+    if (iter != appStringAppPool[num].End()) { // found
+      appStringAppPool[num].Erase(iter);
+    }
+  }
+  mtx[num].Unlock();
+  return;
+} // String pool function interface end
+
+// String compress start
+int GetMUtf8ByteCount(const uint16_t *utf16Raw, size_t charCount, ZeroCodeT zCode, int charSet) {
+  DCHECK(utf16Raw != nullptr);
+  int res = 0;
+  for (size_t i = 0; i < charCount; ++i) {
+    uint16_t ch = utf16Raw[i];
+    if ((!static_cast<bool>(zCode) || ch != 0) && ch <= 0x7f) {
+      ++res;
+    } else if (ch <= 0x7ff) {
+      res += 2;
+    } else {
+      if (!charSet) {
+        if ((ch >= 0xd800 && ch <= 0xdbff) && (i < charCount - 1)) {
+          uint16_t ch1 = utf16Raw[i + 1];
+          if (ch1 >= 0xdc00 && ch1 <= 0xdfff) {
+            ++i;
+            res += 4;
+            continue;
+          }
+        }
+        res += 3;
+      } else {
+        if ((ch & 0xfffff800) == 0xd800) {
+          uint16_t ch1 = (i < charCount - 1) ? utf16Raw[i + 1] : 0;
+          if (!((ch & 0x400) == 0) || !((ch1 & 0x400) != 0)) {
+            ++res;
+            continue;
+          }
+          ++i;
+          res += 4;
+        } else {
+          res += 3;
+        }
+      }
+    }
+  }
+  return res;
+}
+
+const int kCodepointOffset1 = 6; // U+0080 - U+07FF   110xxxxx 10xxxxxx
+const int kCodepointOffset2 = 12; // U+0800 - U+FFFF   1110xxxx 10xxxxxx 10xxxxxx
+const int kCodepointOffset3 = 18; // U+10000- U+10FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+const int kCodeAfterMinusOffset = 10; // codepoint equals itself minus 0x10000
+const int kUtf16Bits = 16;  // UTF_16 16 bits
+void MUtf8Encode(uint8_t *utf8Res, const uint16_t *utf16Raw, size_t charCount, ZeroCodeT zCode, int charSet) {
+  DCHECK(utf16Raw != nullptr);
+  DCHECK(utf8Res != nullptr);
+  uint32_t offset = 0;
+  for (size_t i = 0; i < charCount; ++i) {
+    uint16_t ch = utf16Raw[i];
+    if ((!static_cast<bool>(zCode) || ch != 0) && ch <= 0x7f) {
+      utf8Res[offset++] = ch;
+    } else if (ch <= 0x7ff) {
+      utf8Res[offset++] = (0xc0 | (0x1f & (ch >> kCodepointOffset1)));
+      utf8Res[offset++] = (0x80 | (0x3f & ch));
+    } else {
+      if (!charSet) {
+        if ((ch >= 0xd800 && ch <= 0xdbff) && (i < charCount - 1)) {
+          uint16_t ch1 = utf16Raw[i + 1];
+          if (ch1 >= 0xdc00 && ch1 <= 0xdfff) {
+            i++;
+            const uint32_t tmp = (ch << kCodeAfterMinusOffset) + ch1 - 0x035fdc00;
+            utf8Res[offset++] = (tmp >> kCodepointOffset3) | 0xf0;
+            utf8Res[offset++] = ((tmp >> kCodepointOffset2) &  0x3f) | 0x80;
+            utf8Res[offset++] = ((tmp >> kCodepointOffset1) & 0x3f) | 0x80;
+            utf8Res[offset++] = (tmp & 0x3f) | 0x80;
+            continue;
+          }
+        }
+        utf8Res[offset++] = (0xe0 | (0x0f & (ch >> kCodepointOffset2)));
+        utf8Res[offset++] = (0x80 | (0x3f & (ch >> kCodepointOffset1)));
+        utf8Res[offset++] = (0x80 | (0x3f & ch));
+      } else {
+        if ((ch & 0xfffff800) == 0xd800) {
+          uint16_t ch1 = (i < charCount - 1) ? utf16Raw[i + 1] : 0;
+          if (!((ch & 0x400) == 0) || !((ch1 & 0x400) != 0)) {
+            utf8Res[offset++] = 0x3f;
+            continue;
+          }
+          ++i;
+          const uint32_t tmp = (ch << kCodeAfterMinusOffset) + ch1 - 0x035fdc00;
+          utf8Res[offset++] = (tmp >> kCodepointOffset3) | 0xf0;
+          utf8Res[offset++] = ((tmp >> kCodepointOffset2) &  0x3f) | 0x80;
+          utf8Res[offset++] = ((tmp >> kCodepointOffset1) & 0x3f) | 0x80;
+          utf8Res[offset++] = (tmp & 0x3f) | 0x80;
+        } else {
+          utf8Res[offset++] = (0xe0 | (0x0f & (ch >> kCodepointOffset2)));
+          utf8Res[offset++] = (0x80 | (0x3f & (ch >> kCodepointOffset1)));
+          utf8Res[offset++] = (0x80 | (0x3f & ch));
+        }
+      }
+    }
+  }
+}
+
+uint32_t CountInMutfLen(const char *utf8, size_t utf8Len) {
+  DCHECK(utf8 != nullptr);
+  size_t count = 0;
+  uint32_t res = 0;
+  while (true) {
+    uint8_t ch = utf8[count] & 0xff;
+    ++count;
+    if (count > utf8Len) {
+      return res;
+    }
+    if (ch < 0x80) {
+      ++res;
+    } else if ((ch & 0xe0) == 0xc0) {
+      ++count;
+      ++res;
+    } else if ((ch & 0xf0) == 0xe0) {
+      count += 2;
+      ++res;
+    } else {
+      count += 3;
+      res += 2;
+    }
+  }
+}
+
+void MUtf8Decode(const uint8_t *utf8, size_t utf8Len, uint16_t *utf16Res) {
+  DCHECK(utf8 != nullptr);
+  DCHECK(utf16Res != nullptr);
+  size_t count = 0;
+  int outCount = 0;
+  while (true) {
+    uint8_t ch = utf8[count++] & 0xff;
+    if (count > utf8Len) {
+      return;
+    }
+    if (ch < 0x80) {
+      utf16Res[outCount++] = ch;
+    } else if ((ch & 0xe0) == 0xc0) {
+      uint8_t sch = utf8[count++] & 0xff;
+      utf16Res[outCount++] = (static_cast<uint16_t>(ch & 0x1f) << kCodepointOffset1) | (sch & 0x3f);
+    } else if ((ch & 0xf0) == 0xe0) {
+      uint8_t sch = utf8[count++] & 0xff;
+      uint8_t tch = utf8[count++] & 0xff;
+      utf16Res[outCount++] = (static_cast<uint16_t>(ch & 0x0f) << kCodepointOffset2) |
+          (static_cast<uint16_t>(sch & 0x3f) << kCodepointOffset1) | (tch & 0x3f);
+    } else {
+      uint8_t sch = utf8[count++] & 0xff;
+      uint8_t tch = utf8[count++] & 0xff;
+      uint8_t fch = utf8[count++] & 0xff;
+      const uint32_t tmp = ((ch & 0x0f) << kCodepointOffset3) | ((sch & 0x3f) << kCodepointOffset2) |
+                           ((tch & 0x3f) << kCodepointOffset1) | (fch & 0x3f);
+      uint32_t pair = 0;
+      pair |= ((tmp >> kCodeAfterMinusOffset) + 0xd7c0) & 0xffff;
+      pair |= ((tmp & 0x03ff) + 0xdc00) << kUtf16Bits;
+      utf16Res[outCount++] = static_cast<uint16_t>(pair & 0xffff);
+      utf16Res[outCount++] = static_cast<uint16_t>(pair >> kUtf16Bits);
+    }
+  }
+}
+
+extern "C" bool MRT_IsStrCompressed(const jstring jstr) {
+  MString *strObj = MString::JniCastNonNull(jstr);
+  return strObj->IsCompress();
+}
+
+// invoke by compiler
+bool MCC_String_Equals_NotallCompress(jstring thisStr, jstring anotherStr) {
+  MString *thisStrObj = MString::JniCastNonNull(thisStr);
+  MString *anotherStrObj = MString::JniCastNonNull(anotherStr);
+  bool thisIsCompress = thisStrObj->IsCompress();
+  uint8_t *thisStrSrc = thisStrObj->GetContentsPtr();
+  uint8_t *anotherStrSrc = anotherStrObj->GetContentsPtr();
+  uint32_t thisStrLen = thisStrObj->GetLength();
+  uint8_t *compressChars = nullptr;
+  uint16_t *uncompressChars = nullptr;
+  if (thisIsCompress) {
+    compressChars = thisStrSrc;
+    uncompressChars = reinterpret_cast<uint16_t*>(anotherStrSrc);
+  } else {
+    compressChars = anotherStrSrc;
+    uncompressChars = reinterpret_cast<uint16_t*>(thisStrSrc);
+  }
+  for (uint32_t i = 0; i < thisStrLen; ++i) {
+    if (compressChars[i] != uncompressChars[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static MString *StringAppend(uint8_t *stringsContent[], const uint32_t stringsLen[], const bool isStringsCompress[],
+                             int32_t sumLength, uint32_t numOfStringAppend) {
+  if (UNLIKELY(stringsContent == nullptr)) {
+    return nullptr;
+  } else if (UNLIKELY(sumLength == 0)) {
+    return MString::NewConstEmptyStringObject();
+  } else if (UNLIKELY(sumLength < 0)) {
+    MRT_ThrowNewExceptionUnw("java/lang/OutOfMemoryError");
+    return nullptr;
+  }
+  MString *newStringObj = nullptr;
+  bool isAllCompress = true;
+  for (uint32_t i = 0; i < numOfStringAppend; ++i) {
+    isAllCompress = isAllCompress && isStringsCompress[i];
+  }
+  if (isAllCompress) {
+    newStringObj = MString::NewStringObject<uint8_t>(static_cast<uint32_t>(sumLength), [&](MString &stringObj) {
+      uint8_t *newContent = stringObj.GetContentsPtr();
+      for (uint32_t i = 0; i < numOfStringAppend; ++i) {
+        if (stringsLen[i] != 0) {
+          errno_t tmpResult = memcpy_s(newContent, stringsLen[i], stringsContent[i], stringsLen[i]);
+          if (UNLIKELY(tmpResult != EOK)) {
+            LOG(FATAL) << "memcpy_s()#1 in StringAppend() return " << tmpResult << "rather than 0.";
+          }
+          newContent += stringsLen[i];
+        }
+      }
+    });
+  } else {
+    newStringObj = MString::NewStringObject<uint16_t>(static_cast<uint32_t>(sumLength), [&](MString &stringObj) {
+      uint16_t *newContent = reinterpret_cast<uint16_t*>(stringObj.GetContentsPtr());
+      for (uint32_t i = 0; i < numOfStringAppend; ++i) {
+        if (stringsLen[i] != 0) {
+          if (isStringsCompress[i]) {
+            uint8_t *content = stringsContent[i];
+            for (uint32_t j = 0; j < stringsLen[i]; ++j) {
+              newContent[j] = content[j];
+            }
+          } else {
+            uint32_t copyLen = stringsLen[i] << 1;
+            errno_t tmpResult = memcpy_s(newContent, copyLen, reinterpret_cast<uint16_t*>(stringsContent[i]), copyLen);
+            CHECK(tmpResult == EOK);
+          }
+          newContent += stringsLen[i];
+        }
+      }
+    });
+  }
+  return newStringObj;
+}
+
+enum TYPESTRINGAPPEND {
+  kString = 0x01,
+  kChar = 0x02,
+  kBoolean = 0x03,
+  kInt = 0x04
+};
+const int kMaxIntcharLen = 13;
+const int kMaxNunmberString = 20;
+const int kSwitchTypeOffset = 3;
+
+uint8_t nullBuff[4] = { 'n', 'u', 'l', 'l' };
+uint8_t trueBuff[4] = { 't', 'r', 'u', 'e' };
+uint8_t falseBuff[5] = { 'f', 'a', 'l', 's', 'e' };
+extern "C" jstring MCC_StringAppend(uint64_t toStringFlag, ...) {
+  uint32_t numOfString = 0;
+  uint8_t *stringsContent[kMaxNunmberString];
+  uint32_t stringsLen[kMaxNunmberString];
+  bool isStringsCompress[kMaxNunmberString];
+  uint16_t charbuff[kMaxNunmberString];
+  char intBuff[kMaxNunmberString][kMaxIntcharLen];
+  jint sumLength = 0;
+
+  va_list args;
+  va_start(args, toStringFlag);
+
+  uint32_t type = toStringFlag & 0x07;
+  while (toStringFlag) {
+    switch (type) {
+      case kChar: {
+        jchar c = static_cast<jchar>(va_arg(args, int32_t));
+        charbuff[numOfString] = c;
+        stringsContent[numOfString] = reinterpret_cast<uint8_t*>(&charbuff[numOfString]);
+        stringsLen[numOfString] = 1;
+        sumLength += 1;
+        isStringsCompress[numOfString] = MString::IsCompressChar(c);
+        break;
+      }
+      case kBoolean: {
+        jboolean b = static_cast<jboolean>(va_arg(args, int32_t));
+        if (b) {
+          stringsContent[numOfString] = trueBuff;
+          stringsLen[numOfString] = 4;
+          sumLength += 4;
+        } else {
+          stringsContent[numOfString] = falseBuff;
+          stringsLen[numOfString] = 5;
+          sumLength += 5;
+        }
+        isStringsCompress[numOfString] = true;
+        break;
+      }
+      case kInt: {
+        jint intValue = static_cast<jint>(va_arg(args, int32_t));
+        char *intChar = intBuff[numOfString];
+        stringsContent[numOfString] = reinterpret_cast<uint8_t*>(intChar);
+        int len = sprintf_s(intChar, kMaxIntcharLen, "%d", intValue);
+        if (UNLIKELY(len < 0)) {
+          LOG(ERROR) << "MCC_StringAppend sprintf_s fail" << maple::endl;
+          len = 0;
+        }
+        stringsLen[numOfString] = len;
+        sumLength += len;
+        isStringsCompress[numOfString] = true;
+        break;
+      }
+      case kString: {
+        jstring tmpString = reinterpret_cast<jstring>(va_arg(args, jstring));
+        uint32_t count;
+        if (tmpString == nullptr) {
+          stringsContent[numOfString] = nullBuff;
+          count = 9;
+        } else {
+          MString *string = MString::JniCastNonNull(tmpString);
+          stringsContent[numOfString] = string->GetContentsPtr();
+          count = string->GetCountValue();
+        }
+        bool isCompressTmp = (count == 0) ? true : MString::IsCompressedFromCount(count);
+        isStringsCompress[numOfString] = isCompressTmp;
+        uint32_t len = count >> 1;
+        sumLength += len;
+        stringsLen[numOfString] = len;
+        break;
+      }
+      default: {
+        LOG(FATAL) << "Unexpected primitive type: " << type;
+      }
+    }
+
+    toStringFlag = toStringFlag >> kSwitchTypeOffset;
+    type = toStringFlag & 0x07;
+    ++numOfString;
+  }
+  va_end(args);
+  MString *newStringObj = StringAppend(stringsContent, stringsLen, isStringsCompress, sumLength, numOfString);
+  if (newStringObj == nullptr) {
+    return nullptr;
+  }
+  return newStringObj->AsJstring();
+}
+
+extern "C" jstring MCC_StringAppend_StringString(jstring strObj1, jstring strObj2) {
+  MString *stringObj1 = MString::JniCast(strObj1);
+  MString *stringObj2 = MString::JniCast(strObj2);
+  const int arrayLen = 2;
+  uint8_t *stringsContent[arrayLen];
+  uint32_t stringsLen[arrayLen];
+  bool isStringsCompress[arrayLen];
+  jint sumLength = 0;
+
+  for (uint32_t i = 0; i < arrayLen; ++i) {
+    MString *tmpString = (i == 0) ? stringObj1 : stringObj2;
+    uint32_t count;
+    if (tmpString == nullptr) {
+      stringsContent[i] = nullBuff;
+      count = 9;
+    } else {
+      stringsContent[i] = tmpString->GetContentsPtr();
+      count = tmpString->GetCountValue();
+    }
+    bool isCompressTmp = (count == 0) ? true : MString::IsCompressedFromCount(count);
+    isStringsCompress[i] = isCompressTmp;
+    uint32_t len = count >> 1;
+    sumLength += len;
+    stringsLen[i] = len;
+  }
+  MString *newStringObj = StringAppend(stringsContent, stringsLen, isStringsCompress, sumLength, arrayLen);
+  if (newStringObj == nullptr) {
+    return nullptr;
+  }
+  return newStringObj->AsJstring();
+}
+
+// count value of String is the length shift left 1 bit and use the last bit to save whether the string is compress
+extern "C" jstring MCC_StringAppend_StringInt(jstring strObj1, jint intValue) {
+  MString *stringObj = MString::JniCast(strObj1);
+  const int arraySize = 2;
+  uint8_t *stringsContent[arraySize];
+  char intBuff[kMaxIntcharLen];
+  uint32_t stringsLen[arraySize];
+  bool isStringsCompress[arraySize];
+  jint sumLength = 0;
+
+  MString *tmpString = stringObj;
+  uint32_t count;
+  if (tmpString == nullptr) {
+    stringsContent[0] = nullBuff;
+    count = 9;
+  } else {
+    stringsContent[0] = tmpString->GetContentsPtr();
+    count = tmpString->GetCountValue();
+  }
+  bool isCompressTmp = (count == 0) ? true : MString::IsCompressedFromCount(count);
+  isStringsCompress[0] = isCompressTmp;
+  uint32_t len = count >> 1;
+  sumLength += len;
+  stringsLen[0] = len;
+
+  stringsContent[1] = reinterpret_cast<uint8_t*>(intBuff);
+  int intLen = sprintf_s(intBuff, kMaxIntcharLen, "%d", intValue);
+  if (UNLIKELY(intLen < 0)) {
+    LOG(ERROR) << "MCC_StringAppend sprintf_s fail" << maple::endl;
+    intLen = 0;
+  }
+  stringsLen[1] = intLen;
+  sumLength += intLen;
+  isStringsCompress[1] = true;
+  MString *newStringObj = StringAppend(stringsContent, stringsLen, isStringsCompress, sumLength, arraySize);
+  if (newStringObj == nullptr) {
+    return nullptr;
+  }
+  return newStringObj->AsJstring();
+}
+
+extern "C" jstring MCC_StringAppend_StringJcharString(jstring strObj1, uint16_t charValue, jstring strObj2) {
+  MString *stringObj1 = MString::JniCast(strObj1);
+  MString *stringObj2 = MString::JniCast(strObj2);
+  const int arraySize = 3;
+  uint8_t *stringsContent[arraySize];
+  uint32_t stringsLen[arraySize];
+  bool isStringsCompress[arraySize];
+  jint sumLength = 0;
+
+  for (uint32_t i = 0; i < arraySize; ++i) {
+    if (i == 1) {
+      continue;
+    }
+    MString *tmpString = (i == 0) ? stringObj1 : stringObj2;
+    uint32_t count;
+    if (tmpString == nullptr) {
+      stringsContent[i] = nullBuff;
+      count = 9;
+    } else {
+      stringsContent[i] = tmpString->GetContentsPtr();
+      count = tmpString->GetCountValue();
+    }
+    bool isCompressTmp = (count == 0) ? true : MString::IsCompressedFromCount(count);
+    isStringsCompress[i] = isCompressTmp;
+    uint32_t len = count >> 1;
+    sumLength += len;
+    stringsLen[i] = len;
+  }
+
+  stringsContent[1] = reinterpret_cast<uint8_t*>(&charValue);
+  stringsLen[1] = 1;
+  sumLength += 1;
+  isStringsCompress[1] = MString::IsCompressChar(charValue);
+  MString *newStringObj = StringAppend(stringsContent, stringsLen, isStringsCompress, sumLength, arraySize);
+  if (newStringObj == nullptr) {
+    return nullptr;
+  }
+  return newStringObj->AsJstring();
+}
+
+#ifdef __OPENJDK__
+template<typename subType, typename srcType>
+int32_t StringNativeIndexOf(MString &subStrObj, const srcType *srcArrayData,
+                            int32_t srcOffset, int32_t srcCount,
+                            int32_t fromIndex, int32_t subLen) {
+  if (UNLIKELY(srcArrayData == nullptr)) {
+    return -1;
+  }
+  if (fromIndex >= srcCount) {
+    return (subLen == 0 ? srcCount : -1);
+  }
+  if (fromIndex < 0) {
+    fromIndex = 0;
+  }
+  if (subLen == 0) {
+    return fromIndex;
+  }
+  subType *subStrArrayData = reinterpret_cast<subType*>(subStrObj.GetContentsPtr());
+  subType first = subStrArrayData[0];
+  int32_t max = srcOffset + (srcCount - subLen);
+
+  for (int i = srcOffset + fromIndex; i <= max; ++i) {
+    if (srcArrayData[i] != first) {
+      while ((++i <= max) && (srcArrayData[i] != first)) {}
+    }
+
+    if (i <= max) {
+      int j = i + 1;
+      int end = j + subLen - 1;
+      for (int k = 1; (j < end) && (srcArrayData[j] == subStrArrayData[k]); ++j, ++k) {}
+      if (j == end) {
+        return i - srcOffset;
+      }
+    }
+  }
+  return -1;
+}
+
+int32_t StringNativeIndexOfP3(MString &subStrObj, MString &srcStrObj, int32_t fromIndex) {
+  bool srcIsCompress = srcStrObj.IsCompress();
+  bool subStrIsCompress = subStrObj.IsCompress();
+  char *srcChar = reinterpret_cast<char*>(srcStrObj.GetContentsPtr());
+  uint32_t srcCount = srcStrObj.GetLength();
+  uint32_t subLen = subStrObj.GetLength();
+  uint32_t res = -1;
+  if (srcIsCompress && !subStrIsCompress) {
+    res = StringNativeIndexOf<uint16_t, char>(subStrObj, srcChar, 0, srcCount, fromIndex, subLen);
+  } else if (srcIsCompress && subStrIsCompress) {
+    res = StringNativeIndexOf<char, char>(subStrObj, srcChar, 0, srcCount, fromIndex, subLen);
+  } else {
+    uint16_t *srcArrayData = reinterpret_cast<uint16_t*>(srcChar);
+    if (subStrIsCompress) {
+      res = StringNativeIndexOf<char, uint16_t>(subStrObj, srcArrayData, 0, srcCount, fromIndex, subLen);
+    } else {
+      res = StringNativeIndexOf<uint16_t, uint16_t>(subStrObj, srcArrayData, 0, srcCount, fromIndex, subLen);
+    }
+  }
+  return res;
+}
+
+int32_t StringNativeIndexOfP5(MString &subStrObj, MArray &srcArray,
+                              int32_t srcOffset, int32_t srcCount, int32_t fromIndex) {
+  uint16_t *srcArrayData = reinterpret_cast<uint16_t*>(srcArray.ConvertToCArray());
+  uint32_t subLen = subStrObj.GetLength();
+  bool subStrIsCompress = subStrObj.IsCompress();
+  int32_t res = -1;
+  if (subStrIsCompress) {
+    res = StringNativeIndexOf<char, uint16_t>(subStrObj, srcArrayData, srcOffset, srcCount, fromIndex, subLen);
+  } else {
+    res = StringNativeIndexOf<uint16_t, uint16_t>(subStrObj, srcArrayData, srcOffset, srcCount, fromIndex, subLen);
+  }
+  return res;
+}
+
+template<typename subType, typename srcType>
+int32_t StringNativeLastIndexOf(MString &subStrObj, const srcType *srcArrayData, int32_t srcOffset,
+                                int32_t srcCount, int32_t fromIndex, int32_t subLen) {
+  if (UNLIKELY(srcArrayData == nullptr)) {
+    return -1;
+  }
+  int32_t rightIndex = srcCount - subLen;
+  if (fromIndex < 0) {
+    return -1;
+  }
+  if (fromIndex > rightIndex) {
+    fromIndex = rightIndex;
+  }
+  if (subLen == 0) {
+    return fromIndex;
+  }
+
+  subType *subStrArrayData = reinterpret_cast<subType*>(subStrObj.GetContentsPtr());
+  int32_t strLastIndex = subLen - 1;
+  uint16_t strLastChar = subStrArrayData[strLastIndex];
+  int32_t min = srcOffset + subLen - 1;
+  int i = min + fromIndex;
+
+  while (true) {
+    bool flag = false;
+    while (i >= min && srcArrayData[i] != strLastChar) {
+      --i;
+    }
+    if (i < min) {
+      return -1;
+    }
+    int j = i - 1;
+    int start = j - (subLen - 1);
+    int k = strLastIndex - 1;
+    while (j > start) {
+      if (srcArrayData[j--] != subStrArrayData[k--]) {
+        --i;
+        flag = true;
+        break;
+      }
+    }
+    if (flag) {
+      continue;
+    }
+    return start - srcOffset + 1;
+  }
+}
+
+int32_t StringNativeLastIndexOfP3(MString &subStrObj, MString &srcStrObj, int32_t fromIndex) {
+  uint32_t subLen = subStrObj.GetLength();
+  uint32_t srcCount = srcStrObj.GetLength();
+  int32_t res = 0;
+  char *srcChar = reinterpret_cast<char*>(srcStrObj.GetContentsPtr());
+  bool subStrIsCompress = subStrObj.IsCompress();
+  bool srcStrIsCompress = srcStrObj.IsCompress();
+  if (srcStrIsCompress && !subStrIsCompress) {
+    res = StringNativeLastIndexOf<uint16_t, char>(subStrObj, srcChar, 0, srcCount, fromIndex, subLen);
+  } else if (srcStrIsCompress && subStrIsCompress) {
+    res = StringNativeLastIndexOf<char, char>(subStrObj, srcChar, 0, srcCount, fromIndex, subLen);
+  } else {
+    uint16_t *srcArrayData = reinterpret_cast<uint16_t*>(srcChar);
+    if (subStrIsCompress) {
+      res = StringNativeLastIndexOf<char, uint16_t>(subStrObj, srcArrayData, 0, srcCount, fromIndex, subLen);
+    } else {
+      res = StringNativeLastIndexOf<uint16_t, uint16_t>(subStrObj, srcArrayData, 0, srcCount, fromIndex, subLen);
+    }
+  }
+  return res;
+}
+
+int32_t StringNativeLastIndexOfP5(MString &subStrObj, MArray &srcArray,
+                                  int32_t srcOffset, int32_t srcCount, int32_t fromIndex) {
+  uint16_t *srcArrayData = reinterpret_cast<uint16_t*>(srcArray.ConvertToCArray());
+  uint32_t subLen = subStrObj.GetLength();
+  bool subStrIsCompress = subStrObj.IsCompress();
+  int32_t res = 0;
+  if (subStrIsCompress) {
+    res = StringNativeLastIndexOf<char, uint16_t>(subStrObj, srcArrayData, srcOffset,
+                                                  srcCount, fromIndex, subLen);
+  } else {
+    res = StringNativeLastIndexOf<uint16_t, uint16_t>(subStrObj, srcArrayData, srcOffset,
+                                                      srcCount, fromIndex, subLen);
+  }
+  return res;
+}
+
+const int kSurrogatesBits = 10;
+
+static int minSupplementaryCodePoint = 0x010000;
+static uint16_t minHighSurrogate = 0xd800;
+static uint16_t minLowSurrogate = 0xdc00;
+static uint16_t maxHighSurrogate = 0xdbff;
+static uint16_t maxLowSurrogate = 0xdfff;
+
+static uint32_t validMaxCodePoint = ((0X10FFFF + 1) >> kUtf16Bits);
+static uint16_t validMinHighSurrogate = (minHighSurrogate - (minSupplementaryCodePoint >> kSurrogatesBits));
+static uint16_t validMinLowSurrogatee = minLowSurrogate;
+
+// codepoint hava two part, each part is u16
+// the leading surrogate code unit used to represent the character in the UTF-16 encoding
+MString *StringNewStringFromCodePoints(MArray &mArray, int32_t offset, int32_t count) {
+  uint32_t *jintArray = reinterpret_cast<uint32_t*>(mArray.ConvertToCArray());
+  if (count <= 0) {
+    return nullptr;
+  }
+  uint16_t *jcharArray = reinterpret_cast<uint16_t*>(malloc(count * 2 * sizeof(uint16_t))); // codepoint hava two part
+  if (UNLIKELY(jcharArray == nullptr)) {
+    return nullptr;
+  }
+  int32_t end = offset + count;
+  int32_t length = 0;
+
+  for (int i = offset; i < end; ++i) {
+    if ((jintArray[i] >> kUtf16Bits) == 0) {
+      jcharArray[length] = static_cast<uint16_t>(jintArray[i]);
+      ++length;
+    } else if((jintArray[i] >> kUtf16Bits) < validMaxCodePoint) {
+      jcharArray[length++] = ((jintArray[i] >> kSurrogatesBits) + validMinHighSurrogate);
+      jcharArray[length++] = ((jintArray[i] & 0x3ff) + validMinLowSurrogatee);
+    } else {
+      free(jcharArray);
+      jcharArray = nullptr;
+      MRT_ThrowNewException("java/lang/IllegalArgumentException",
+                            "Exception IllegalArgumentException in newStringFromCodePoints");
+      return nullptr;
+    }
+  }
+
+  const bool compressible = MString::IsCompressChars<uint16_t>(jcharArray, length);
+  MString *res = nullptr;
+  if (compressible) {
+    res = MString::NewStringObject<uint16_t, uint8_t>(jcharArray, length);
+  } else {
+    res = MString::NewStringObject<uint16_t>(jcharArray, length);
+  }
+  free(jcharArray);
+  jcharArray = nullptr;
+  return res;
+}
+
+static inline bool IsHighSurrogate(uint16_t ch) {
+  return (ch >= minHighSurrogate && ch < (maxHighSurrogate + 1));
+}
+
+static inline bool IsLowSurrogate(uint16_t ch) {
+  return (ch >= minLowSurrogate && ch < (maxLowSurrogate + 1));
+}
+
+static inline int32_t ToCodePoint(uint16_t high, uint16_t low) {
+  return ((high << kSurrogatesBits) + low) +
+      (minSupplementaryCodePoint - (minHighSurrogate << kSurrogatesBits) - minLowSurrogate);
+}
+
+int32_t StringNativeCodePointAt(MString &strObj, int32_t index) {
+  uint32_t length = strObj.GetLength();
+  if (index < 0 || static_cast<uint32_t>(index) >= length) {
+    MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException",
+                          "StringNativeCodePointAt(): input index out of Bounds");
+    return -1;
+  }
+  bool strIsCompress = strObj.IsCompress();
+  if (strIsCompress) {
+    char *strDataC = reinterpret_cast<char*>(strObj.GetContentsPtr());
+    char ch = strDataC[index];
+    return ch;
+  }
+
+  uint16_t *strData = reinterpret_cast<uint16_t*>(strObj.GetContentsPtr());
+  uint16_t c1 = strData[index];
+  if (IsHighSurrogate(c1) && static_cast<uint32_t>(++index) < length) {
+    uint16_t c2 = strData[index];
+    if (IsLowSurrogate(c2)) {
+      return ToCodePoint(c1, c2);
+    }
+  }
+  return c1;
+}
+
+int32_t StringNativeCodePointBefore(MString &strObj, int32_t index) {
+  uint32_t length = strObj.GetLength();
+  if (index < 1 || static_cast<uint32_t>(index) > length) {
+    MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException",
+                          "StringNativeCodePointBefore(): input index out of Bounds");
+    return -1;
+  }
+  bool strIsCompress = strObj.IsCompress();
+  if (strIsCompress) {
+    char *strDataC = reinterpret_cast<char*>(strObj.GetContentsPtr());
+    char ch = strDataC[--index];
+    return ch;
+  }
+
+  uint16_t *strData = reinterpret_cast<uint16_t*>(strObj.GetContentsPtr());
+  uint16_t c2 = strData[--index];
+  if (IsLowSurrogate(c2) && index > 0) {
+    uint16_t c1 = strData[--index];
+    if (IsHighSurrogate(c1)) {
+      return ToCodePoint(c1, c2);
+    }
+  }
+  return c2;
+}
+
+int32_t StringNativeCodePointCount(MString &strObj, int32_t beginIndex, int32_t endIndex) {
+  uint32_t length = strObj.GetLength();
+  if (beginIndex < 0 || static_cast<uint32_t>(endIndex) > length || beginIndex > endIndex) {
+    MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException",
+                          "StringNativeCodePointCount(): input index out of Bounds");
+    return -1;
+  }
+  int n = endIndex - beginIndex;
+  bool strIsCompress = strObj.IsCompress();
+  if (strIsCompress) {
+    return n;
+  }
+  uint16_t *strData = reinterpret_cast<uint16_t*>(strObj.GetContentsPtr());
+  for (int i = beginIndex; i < endIndex;) {
+    if (IsHighSurrogate(strData[i++]) && i < endIndex && IsLowSurrogate(strData[i])) {
+      --n;
+      ++i;
+    }
+  }
+  return n;
+}
+
+int32_t StringNativeOffsetByCodePoint(MString &strObj, int32_t index, int32_t codePointOffset) {
+  uint32_t length = strObj.GetLength();
+  if (index < 0 || static_cast<uint32_t>(index) > length) {
+    MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException",
+                          "StringNativeOffsetByCodePoint(): input index out of Bounds");
+    return -1;
+  }
+  bool strIsCompress = strObj.IsCompress();
+  uint16_t *strData = reinterpret_cast<uint16_t*>(strObj.GetContentsPtr());
+  int x = index;
+  int resCount = x + codePointOffset;
+  if (codePointOffset >= 0) {
+    if (strIsCompress) {
+      if (static_cast<uint32_t>(resCount) < length) {
+        return resCount;
+      } else {
+        MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException",
+                              "StringNativeOffsetByCodePoint(): input index out of Bounds");
+        return -1;
+      }
+    }
+    int i = 0;
+    while (static_cast<uint32_t>(x) < length && i < codePointOffset) {
+      if (IsHighSurrogate(strData[x++]) && static_cast<uint32_t>(x) < length && IsLowSurrogate(strData[x])) {
+        ++x;
+      }
+      ++i;
+    }
+    if (i < codePointOffset) {
+      MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException",
+                            "StringNativeOffsetByCodePoint(): input index out of Bounds");
+      return -1;
+    }
+  } else {
+    if (strIsCompress) {
+      if (resCount < 0) {
+        MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException",
+                              "StringNativeOffsetByCodePoint(): input index out of Bounds");
+        return -1;
+      } else {
+        return resCount;
+      }
+    }
+    int j = codePointOffset;
+    while (x > 0 && j < 0) {
+      if (IsLowSurrogate(strData[--x]) && x > 0 && IsHighSurrogate(strData[x - 1])) {
+        --x;
+      }
+      ++j;
+    }
+    if (j < 0) {
+      MRT_ThrowNewException("java/lang/StringIndexOutOfBoundsException",
+                            "StringNativeOffsetByCodePoint(): input index out of Bounds");
+      return -1;
+    }
+  }
+  return x;
+}
+#endif // __OPENJDK__
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_util.cpp b/src/mrt/maplert/src/mrt_util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7a47e1a1dbab058a66dce32c783774a57cb60f58
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_util.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_util.h"
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <cassert>
+#include <cctype>
+#include <map>
+#include "namemangler.h"
+#include "panic.h"
+#include "mrt_reflection_class.h"
+#include "itab_util.h"
+
+namespace maplert {
+// string _3B, _7C, _29 is the ascii code for some special character
+const int kAsciiStrLength = 3;
+
+// typechar
+//  V   void
+//  Z   boolean u8
+//  B   byte    i8
+//  S   short   i16
+//  C   char    u16
+//  I   int     i32
+//  J   long    i64
+//  F   float   f32
+//  D   double  f64
+//  L   ref     u64
+//  A   array
+//  _   not array
+
+// two usages:
+// short form: when typenames passed as NULL
+//    return a string for its prototype
+//    each argument is represented by two charactors, A/_ + typechar
+//    followed by 2 charactors for return type
+// normal form:
+//    typenames contains char* for arg types and return type
+//    in this case, return is NULL
+extern "C" char *MRT_FuncnameToPrototypeNames(char *funcName, int argNum, char **typeNames) {
+  bool shortForm = true;
+  if (typeNames != nullptr) {
+    shortForm = false;
+  }
+  DCHECK(funcName != nullptr) << "MRT_FuncnameToPrototypeNames: funcName is nullptr" << maple::endl;
+  // arg type names and return type name
+  char *name = funcName;
+  unsigned index = 0;
+  int protoArgNum = 0;
+  unsigned endPos = 0;
+  while (*name) {
+    if (*name == '_') {
+      if (strncmp(name, "_28", kAsciiStrLength) == 0) {
+        name += kAsciiStrLength;
+        break;
+      } else if (endPos == 0 && strncmp(name, "_7C", kAsciiStrLength) == 0) {
+        endPos = static_cast<unsigned>(name - funcName);
+      }
+    }
+    name++;
+  }
+
+  // collect protoArgNum, whether need to insert this
+  char *name0 = name;
+  while (*name) {
+    if (*name == '[') {
+      name++;
+    }
+    if (*name == 'L') {
+      while (!(*name == '_' && strncmp(name, "_3B", kAsciiStrLength) == 0)) {
+        name++;
+      }
+      // when the current pointer meet substring of "_3B", pointer skip 2 steps firstly.
+      // then skip more 1 step to skip over substring of "_3B" for code name++;
+      name += 2;
+    } else if (*name == '_' && strncmp(name, "_29", kAsciiStrLength) == 0) {
+      break;
+    }
+    name++;
+    protoArgNum++;
+  }
+
+  if (protoArgNum != argNum) {
+    printf("argnum = %d; protoargnum = %d\n", argNum, protoArgNum);
+    __MRT_ASSERT(0, "");
+  }
+
+  char *retPtr = nullptr;
+  size_t size;
+  if (shortForm) {
+    size = static_cast<size_t>(argNum) * 2 + 3; // args*2 + ret*2 + '\0'
+  } else {
+    size = strlen(funcName) + protoArgNum;
+  }
+  if (size == 0) {
+    return nullptr;
+  }
+  retPtr = reinterpret_cast<char*>(calloc(size, 1));
+  if (retPtr == nullptr) {
+    return nullptr;
+  }
+  char *ret = retPtr;
+
+  name = name0;
+  while (*name) {
+    char *ret0 = ret;
+    if (*name == '[') {
+      name++;
+      *ret++ = '[';
+    } else {
+      if (shortForm) {
+        *ret++ = '_';
+      }
+    }
+
+    if (*name == 'L') {
+      *ret++ = 'L';
+      name++;
+      while (!(*name == '_' && strncmp(name, "_3B", kAsciiStrLength) == 0)) {
+        if (!shortForm) {
+          *ret++ = *name;
+        }
+        name++;
+      }
+      name += 2; // skip 2 steps
+      if (!shortForm) {
+        *ret++ = '_';
+        *ret++ = '3';
+        *ret++ = 'B';
+      }
+    } else if (*name == '_' && strncmp(name, "_29", kAsciiStrLength) == 0) {
+      if (shortForm) {
+        ret--;
+      }
+      name += 3; // skip 3 steps
+      continue;
+    } else {
+      *ret++ = *name;
+    }
+
+    name++;
+
+    if (!shortForm) {
+      ret++;
+      typeNames[index++] = ret0;
+    }
+  }
+
+  return retPtr;
+}
+
+// function GetClassNametoDescriptor calloc space for javaDescriptor
+// remember to free when used in another place
+// the className after Decode is shorter so that the classNameLength is large Enough
+std::string GetClassNametoDescriptor(const std::string &className) {
+  std::string name = className;
+  std::string descriptor;
+  namemangler::DecodeMapleNameToJavaDescriptor(name, descriptor);
+  return descriptor;
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mrt_well_known.cpp b/src/mrt/maplert/src/mrt_well_known.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2538c3cab4eaac4308e1affae4a4a21efc9660a0
--- /dev/null
+++ b/src/mrt/maplert/src/mrt_well_known.cpp
@@ -0,0 +1,706 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mrt_well_known.h"
+#include "mrt_classloader_api.h"
+#include "chelper.h"
+#include "mclass_inline.h"
+#include "fieldmeta_inline.h"
+#include "methodmeta_inline.h"
+#include "mrt_primitive_api.h"
+#include "mrt_array_api.h"
+namespace maplert {
+// Init Ljava_2Flang_2FString_3B direct
+// mpl-linker use it when load const jstring
+extern "C" {
+  extern void *MRT_CLASSINFO(Ljava_2Flang_2FString_3B);
+  extern void *MRT_CLASSINFO(Ljava_2Flang_2FClass_3B);
+}
+
+MClass *WellKnown::Ljava_2Flang_2FString_3B = reinterpret_cast<MClass*>(&MRT_CLASSINFO(Ljava_2Flang_2FString_3B));
+MClass *WellKnown::Ljava_2Flang_2FClass_3B = reinterpret_cast<MClass*>(&MRT_CLASSINFO(Ljava_2Flang_2FClass_3B));
+
+MClass *WellKnown::primitiveClassZ;
+MClass *WellKnown::primitiveClassB;
+MClass *WellKnown::primitiveClassS;
+MClass *WellKnown::primitiveClassC;
+MClass *WellKnown::primitiveClassI;
+MClass *WellKnown::primitiveClassJ;
+MClass *WellKnown::primitiveClassF;
+MClass *WellKnown::primitiveClassD;
+MClass *WellKnown::primitiveClassV;
+
+MClass *WellKnown::primitiveClassAZ;
+MClass *WellKnown::primitiveClassAB;
+MClass *WellKnown::primitiveClassAS;
+MClass *WellKnown::primitiveClassAC;
+MClass *WellKnown::primitiveClassAI;
+MClass *WellKnown::primitiveClassAJ;
+MClass *WellKnown::primitiveClassAF;
+MClass *WellKnown::primitiveClassAD;
+
+MClass *WellKnown::primitiveClassAAZ;
+MClass *WellKnown::primitiveClassAAB;
+MClass *WellKnown::primitiveClassAAS;
+MClass *WellKnown::primitiveClassAAC;
+MClass *WellKnown::primitiveClassAAI;
+MClass *WellKnown::primitiveClassAAJ;
+MClass *WellKnown::primitiveClassAAF;
+MClass *WellKnown::primitiveClassAAD;
+
+MClass *WellKnown::Ljava_2Flang_2FVoid_3B;
+MClass *WellKnown::Ljava_2Flang_2FBoolean_3B;
+MClass *WellKnown::Ljava_2Flang_2FByte_3B;
+MClass *WellKnown::Ljava_2Flang_2FCharacter_3B;
+MClass *WellKnown::Ljava_2Flang_2FShort_3B;
+MClass *WellKnown::Ljava_2Flang_2FInteger_3B;
+MClass *WellKnown::Ljava_2Flang_2FLong_3B;
+MClass *WellKnown::Ljava_2Flang_2FFloat_3B;
+MClass *WellKnown::Ljava_2Flang_2FDouble_3B;
+MClass *WellKnown::Ljava_2Flang_2FNumber_3B;
+
+MClass *WellKnown::Ljava_2Flang_2FObject_3B;
+MClass *WellKnown::Ljava_2Flang_2FClassLoader_3B;
+MClass *WellKnown::Ljava_2Flang_2Freflect_2FField_3B;
+MClass *WellKnown::Ljava_2Flang_2Freflect_2FConstructor_3B;
+MClass *WellKnown::Ljava_2Flang_2Freflect_2FMethod_3B;
+MClass *WellKnown::Ljava_2Flang_2Freflect_2FProxy_3B;
+MClass *WellKnown::Ljava_2Flang_2Freflect_2FParameter_3B;
+MClass *WellKnown::Llibcore_2Freflect_2FGenericSignatureParser_3B;
+MClass *WellKnown::Ljava_2Flang_2Fref_2FReference_3B;
+MClass *WellKnown::Ljava_2Flang_2Fref_2FFinalizerReference_3B;
+
+MClass *WellKnown::Ljava_2Flang_2FCloneable_3B;
+MClass *WellKnown::Ljava_2Fio_2FSerializable_3B;
+
+MClass *WellKnown::Ljava_2Flang_2FStringFactory_3B;
+MClass *WellKnown::Ljava_2Flang_2FError_3B;
+MClass *WellKnown::Ljava_2Flang_2FThrowable_3B;
+MClass *WellKnown::Ljava_2Flang_2FArithmeticException_3B;
+MClass *WellKnown::Ljava_2Flang_2FInterruptedException_3B;
+MClass *WellKnown::Ljava_2Flang_2FClassCastException_3B;
+MClass *WellKnown::Ljava_2Flang_2FUnsatisfiedLinkError_3B;
+MClass *WellKnown::Ljava_2Flang_2FStringIndexOutOfBoundsException_3B;
+MClass *WellKnown::Ljava_2Flang_2FNoClassDefFoundError_3B;
+MClass *WellKnown::Ljava_2Flang_2FNoSuchMethodError_3B;
+MClass *WellKnown::Ljava_2Flang_2FNoSuchFieldError_3B;
+MClass *WellKnown::Ljava_2Flang_2FVerifyError_3B;
+MClass *WellKnown::Ljava_2Flang_2FExceptionInInitializerError_3B;
+MClass *WellKnown::Ljava_2Flang_2FRuntimeException_3B;
+MClass *WellKnown::Ljava_2Flang_2FSecurityException_3B;
+MClass *WellKnown::Ljava_2Flang_2Freflect_2FUndeclaredThrowableException_3B;
+MClass *WellKnown::Ljava_2Flang_2FArrayStoreException_3B;
+MClass *WellKnown::Ljava_2Flang_2FArrayIndexOutOfBoundsException_3B;
+MClass *WellKnown::Ljava_2Flang_2FNullPointerException_3B;
+
+MClass *WellKnown::Ljava_2Flang_2FEnum_3B;
+MClass *WellKnown::Ljava_2Flang_2Fannotation_2FAnnotation_3B;
+MClass *WellKnown::Llibcore_2Freflect_2FAnnotationMember_3B;
+MClass *WellKnown::Llibcore_2Freflect_2FAnnotationFactory_3B;
+MClass *WellKnown::Ldalvik_2Fsystem_2FDelegateLastClassLoader_3B;
+MClass *WellKnown::Ldalvik_2Fsystem_2FPathClassLoader_3B;
+MClass *WellKnown::Ldalvik_2Fsystem_2FDexClassLoader_3B;
+MClass *WellKnown::Ldalvik_2Fsystem_2FInMemoryDexClassLoader_3B;
+
+MClass *WellKnown::Ljava_2Flang_2Finvoke_2FMethodType_3B;
+MClass *WellKnown::Ljava_2Flang_2Finvoke_2FMethodHandle_3B;
+
+#ifdef __OPENJDK__
+MClass *WellKnown::Ljava_2Futil_2FHashMap_3B;
+MClass *WellKnown::Lsun_2Freflect_2Fannotation_2FAnnotationParser_3B;
+#endif // __OPENJDK__
+
+MClass *WellKnown::Ljava_2Flang_2FInteger_24IntegerCache_3B;
+MClass *WellKnown::Ljava_2Flang_2FByte_24ByteCache_3B;
+MClass *WellKnown::Ljava_2Flang_2FShort_24ShortCache_3B;
+MClass *WellKnown::Ljava_2Flang_2FCharacter_24CharacterCache_3B;
+MClass *WellKnown::Ljava_2Flang_2FLong_24LongCache_3B;
+
+MClass *WellKnown::Ljava_2Flang_2Finvoke_2FInvokeData_24BindToData_3B;
+MClass *WellKnown::Ljava_2Flang_2Finvoke_2FInvokeData_24DropArgumentsData_3B;
+MClass *WellKnown::Ljava_2Flang_2Finvoke_2FInvokeData_24FilterReturnValueData_3B;
+MClass *WellKnown::Ljava_2Flang_2Finvoke_2FInvokeData_24PermuteArgumentsData_3B;
+size_t WellKnown::Ljava_2Flang_2FMethodHandle_3B_dataArray_offset;
+size_t WellKnown::Ljava_2Flang_2FMethodHandle_3B_metaArray_offset;
+size_t WellKnown::Ljava_2Flang_2FMethodHandle_3B_typeArray_offset;
+size_t WellKnown::Ljava_2Flang_2FMethodHandle_3B_opArray_offset;
+size_t WellKnown::Ljava_2Flang_2FMethodHandle_3B_index_offset;
+size_t WellKnown::Ljava_2Flang_2FBindToData_3B_receiver_offset;
+size_t WellKnown::Ljava_2Flang_2FDropArgumentsData_3B_numDropped_offset;
+size_t WellKnown::Ljava_2Flang_2FDropArgumentsData_3B_startPos_offset;
+size_t WellKnown::Ljava_2Flang_2FFilterReturnValueData_3B_target_offset;
+size_t WellKnown::Ljava_2Flang_2FFilterReturnValueData_3B_filter_offset;
+size_t WellKnown::Ljava_2Flang_2FPermuteArgumentsData_3B_target_offset;
+size_t WellKnown::Ljava_2Flang_2FPermuteArgumentsData_3B_reorder_offset;
+
+MClass *WellKnown::Ldalvik_2Fsystem_2FEmulatedStackFrame_3B;
+size_t WellKnown::Ljava_2Flang_2FMethodHandle_3B_artFieldOrMethod_offset;
+size_t WellKnown::Ljava_2Flang_2FMethodHandle_3B_handleKind_offset;
+size_t WellKnown::Ljava_2Flang_2FMethodHandle_3B_nominalType_offset;
+size_t WellKnown::Ljava_2Flang_2FMethodHandle_3B_type_offset;
+size_t WellKnown::Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_callsiteType_offset;
+size_t WellKnown::Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_references_offset;
+size_t WellKnown::Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_stackFrame_offset;
+size_t WellKnown::Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_type_offset;
+
+MClass *WellKnown::ALjava_2Flang_2FObject_3B;
+MClass *WellKnown::ALjava_2Flang_2FClass_3B;
+MClass *WellKnown::ALjava_2Flang_2Freflect_2FField_3B;
+MClass *WellKnown::ALjava_2Flang_2Freflect_2FMethod_3B;
+MClass *WellKnown::ALjava_2Flang_2Fannotation_2FAnnotation_3B;
+MClass *WellKnown::ALjava_2Flang_2Freflect_2FConstructor_3B;
+MClass *WellKnown::ALjava_2Flang_2Freflect_2FParameter_3B;
+MClass *WellKnown::ALjava_2Flang_2FString_3B;
+MClass *WellKnown::ALjava_2Flang_2FBoolean_3B;
+MClass *WellKnown::ALjava_2Flang_2FByte_3B;
+MClass *WellKnown::ALjava_2Flang_2FCharacter_3B;
+MClass *WellKnown::ALjava_2Flang_2FShort_3B;
+MClass *WellKnown::ALjava_2Flang_2FInteger_3B;
+MClass *WellKnown::ALjava_2Flang_2FLong_3B;
+MClass *WellKnown::ALjava_2Flang_2FFloat_3B;
+MClass *WellKnown::ALjava_2Flang_2FDouble_3B;
+
+MClass *WellKnown::AALjava_2Flang_2Fannotation_2FAnnotation_3B;
+
+FieldMeta *WellKnown::Ljava_2Flang_2FBoolean_3B_TRUE;
+FieldMeta *WellKnown::Ljava_2Flang_2FBoolean_3B_FALSE;
+FieldMeta *WellKnown::Ljava_2Flang_2FByte_24ByteCache_3B_cache;
+FieldMeta *WellKnown::Ljava_2Flang_2FShort_24ShortCache_3B_cache;
+FieldMeta *WellKnown::Ljava_2Flang_2FCharacter_24CharacterCache_3B_cache;
+FieldMeta *WellKnown::Ljava_2Flang_2FLong_24LongCache_3B_cache;
+FieldMeta *WellKnown::Ljava_2Flang_2FInteger_24IntegerCache_3B_cache;
+FieldMeta *WellKnown::Ljava_2Flang_2FInteger_24IntegerCache_3B_low;
+FieldMeta *WellKnown::Ljava_2Flang_2FInteger_24IntegerCache_3B_high;
+
+uintptr_t WellKnown::Ljava_2Flang_2FClassLoader_3B_LoadClass_Addr;
+uintptr_t WellKnown::Llibcore_2Freflect_2FAnnotationMember_3B_7C_3Cinit_Addr;
+uintptr_t WellKnown::Llibcore_2Freflect_2FAnnotationFactory_3B_7CcreateAnnotation_Addr;
+uintptr_t WellKnown::Ljava_2Flang_2FBoolean_3B_ValueOf_Addr;
+uintptr_t WellKnown::Ljava_2Flang_2FByte_3B_ValueOf_Addr;
+uintptr_t WellKnown::Ljava_2Flang_2FCharacter_3B_ValueOf_Addr;
+uintptr_t WellKnown::Ljava_2Flang_2FShort_3B_ValueOf_Addr;
+uintptr_t WellKnown::Ljava_2Flang_2FInteger_3B_ValueOf_Addr;
+uintptr_t WellKnown::Ljava_2Flang_2FLong_3B_ValueOf_Addr;
+uintptr_t WellKnown::Ljava_2Flang_2FFloat_3B_ValueOf_Addr;
+uintptr_t WellKnown::Ljava_2Flang_2FDouble_3B_ValueOf_Addr;
+
+size_t WellKnown::Ljava_2Flang_2FBoolean_3B_value_offset;
+size_t WellKnown::Ljava_2Flang_2FByte_3B_value_offset;
+size_t WellKnown::Ljava_2Flang_2FCharacter_3B_value_offset;
+size_t WellKnown::Ljava_2Flang_2FShort_3B_value_offset;
+size_t WellKnown::Ljava_2Flang_2FInteger_3B_value_offset;
+size_t WellKnown::Ljava_2Flang_2FLong_3B_value_offset;
+size_t WellKnown::Ljava_2Flang_2FFloat_3B_value_offset;
+size_t WellKnown::Ljava_2Flang_2FDouble_3B_value_offset;
+size_t WellKnown::Ljava_2Flang_2FMethodType_3B_ptypes_offset;
+size_t WellKnown::Ljava_2Flang_2FMethodType_3B_rtype_offset;
+
+size_t WellKnown::kReferenceReferentOffset;
+size_t WellKnown::kReferenceQueueOffset;
+size_t WellKnown::kReferencePendingnextOffset;
+size_t WellKnown::kFinalizereferenceZombieOffset;
+uint32_t WellKnown::currentCacheArrayClassIndex = 0;
+
+std::vector<MClass*> WellKnown::arrayInterface;
+
+MClass *WellKnown::primitiveArrayClass[kMaxPrimitiveSize];
+
+MClass *WellKnown::cacheArrayClasses[kCacheArrayClassSize];
+
+// frameworks
+// ALandroid_2Fcontent_2Fpm_2FPackageParser_24ActivityIntentInfo_3B         0x01
+// ALandroid_2Fcontent_2Fpm_2FSignature_3B                                  0x02
+// ALcom_2Fandroid_2Fserver_2Fam_2FBroadcastFilter_3B                       0x03
+// ALandroid_2Fcontent_2Fpm_2FPackageParser_24ServiceIntentInfo_3B          0x04
+// ALandroid_2Fcontent_2FIntent_3B                                          0x05
+// ALcom_2Fandroid_2Finternal_2Fos_2FBatteryStatsImpl_24StopwatchTimer_3B   0x06
+MClass *WellKnown::arrayFrameWorksClasses[kMaxPrimitiveSize] = { nullptr };
+
+MClass *WellKnown::GetCacheArrayClass(const MClass &componentClass) {
+  for (uint32_t i = 0; i < kCacheArrayClassSize; ++i) {
+    MClass *arrayClass = cacheArrayClasses[i];
+    if (arrayClass != nullptr && arrayClass->GetComponentClass() == &componentClass) {
+      return arrayClass;
+    }
+  }
+
+  std::string arrayName("[");
+  arrayName.append(componentClass.GetName());
+  MClass *arrayClass = MClass::GetClassFromDescriptor(&componentClass, arrayName.c_str());
+  CHECK(arrayClass != nullptr) << "Get array class fail." << maple::endl;
+  uint32_t index = currentCacheArrayClassIndex;
+  cacheArrayClasses[index] = arrayClass;
+  currentCacheArrayClassIndex = (index + 1) % kCacheArrayClassSize;
+  return arrayClass;
+}
+
+MClass *WellKnown::GetWellKnowClassWithFlag(uint8_t classFlag, const MClass &caller, const char *className) {
+  MClass *arrayClass = nullptr;
+  if (classFlag < kMaxFrameworksSize) {
+    arrayClass = arrayFrameWorksClasses[classFlag];
+    if (arrayClass == nullptr) {
+      arrayClass = MClass::JniCast(MRT_GetClass(caller.AsJclass(), className));
+      arrayFrameWorksClasses[classFlag] = arrayClass;
+    }
+  }
+  return arrayClass;
+}
+
+void WellKnown::InitArrayInterfaceVector() {
+  arrayInterface.push_back(Ljava_2Flang_2FCloneable_3B);
+  arrayInterface.push_back(Ljava_2Fio_2FSerializable_3B);
+}
+
+void WellKnown::InitCacheClass(MClass *&cls, const char *className) {
+  // boot class loader
+  cls = MClass::JniCast(MRT_GetClassByContextClass(nullptr, className));
+  CHECK(cls != nullptr) << "InitCacheClass fail, not find class: " << className << maple::endl;
+}
+
+void WellKnown::InitCacheMethodAddr(uintptr_t &methodAddr, const MClass &cls, const char *methodName,
+                                    const char *signatureName) {
+  MethodMeta *methodMeta = cls.GetDeclaredMethod(methodName, signatureName);
+  if (methodMeta == nullptr) {
+    LOG(FATAL) << "InitCacheMethodAddr, init fail, " << cls.GetName() << ", " <<
+        methodName << signatureName << maple::endl;
+    return;
+  }
+  methodAddr = methodMeta->GetFuncAddress();
+}
+
+void WellKnown::InitCacheFieldOffset(size_t &fieldOffset, const MClass &cls, const char *fieldName) {
+  FieldMeta *fieldMeta = cls.GetDeclaredField(fieldName);
+  if (fieldMeta == nullptr) {
+    LOG(FATAL) << "InitCacheFieldOffset, init fail, " << cls.GetName() << ", " << fieldName << maple::endl;
+    return;
+  }
+  fieldOffset = fieldMeta->GetOffset();
+}
+
+void WellKnown::InitCacheFieldMeta(FieldMeta *&fieldMeta, const MClass &cls, const char *fieldName) {
+  fieldMeta = cls.GetDeclaredField(fieldName);
+  if (fieldMeta == nullptr) {
+    LOG(FATAL) << "InitCacheFieldOffset, init fail, " << cls.GetName() << ", " << fieldName << maple::endl;
+    return;
+  }
+}
+
+void WellKnown::InitCachePrimitiveBoxClass() {
+  InitCacheClass(primitiveClassZ, "Z");
+  InitCacheClass(primitiveClassB, "B");
+  InitCacheClass(primitiveClassS, "S");
+  InitCacheClass(primitiveClassC, "C");
+  InitCacheClass(primitiveClassI, "I");
+  InitCacheClass(primitiveClassJ, "J");
+  InitCacheClass(primitiveClassF, "F");
+  InitCacheClass(primitiveClassD, "D");
+  InitCacheClass(primitiveClassV, "V");
+
+  InitCacheClass(primitiveClassAZ, "[Z");
+  InitCacheClass(primitiveClassAB, "[B");
+  InitCacheClass(primitiveClassAS, "[S");
+  InitCacheClass(primitiveClassAC, "[C");
+  InitCacheClass(primitiveClassAI, "[I");
+  InitCacheClass(primitiveClassAJ, "[J");
+  InitCacheClass(primitiveClassAF, "[F");
+  InitCacheClass(primitiveClassAD, "[D");
+
+  InitCacheClass(primitiveClassAAZ, "[[Z");
+  InitCacheClass(primitiveClassAAB, "[[B");
+  InitCacheClass(primitiveClassAAS, "[[S");
+  InitCacheClass(primitiveClassAAC, "[[C");
+  InitCacheClass(primitiveClassAAI, "[[I");
+  InitCacheClass(primitiveClassAAJ, "[[J");
+  InitCacheClass(primitiveClassAAF, "[[F");
+  InitCacheClass(primitiveClassAAD, "[[D");
+
+  InitCacheClass(Ljava_2Flang_2FVoid_3B, "Ljava/lang/Void;");
+  InitCacheClass(Ljava_2Flang_2FBoolean_3B, "Ljava/lang/Boolean;");
+  InitCacheClass(Ljava_2Flang_2FByte_3B, "Ljava/lang/Byte;");
+  InitCacheClass(Ljava_2Flang_2FCharacter_3B, "Ljava/lang/Character;");
+  InitCacheClass(Ljava_2Flang_2FShort_3B, "Ljava/lang/Short;");
+  InitCacheClass(Ljava_2Flang_2FInteger_3B, "Ljava/lang/Integer;");
+  InitCacheClass(Ljava_2Flang_2FLong_3B, "Ljava/lang/Long;");
+  InitCacheClass(Ljava_2Flang_2FFloat_3B, "Ljava/lang/Float;");
+  InitCacheClass(Ljava_2Flang_2FDouble_3B, "Ljava/lang/Double;");
+  InitCacheClass(Ljava_2Flang_2FNumber_3B, "Ljava/lang/Number;");
+}
+
+void WellKnown::InitCacheArrayClass() {
+  InitCacheClass(ALjava_2Flang_2FObject_3B, "[Ljava/lang/Object;");
+  InitCacheClass(ALjava_2Flang_2FClass_3B, "[Ljava/lang/Class;");
+  InitCacheClass(ALjava_2Flang_2Freflect_2FField_3B, "[Ljava/lang/reflect/Field;");
+  InitCacheClass(ALjava_2Flang_2Freflect_2FMethod_3B, "[Ljava/lang/reflect/Method;");
+  InitCacheClass(ALjava_2Flang_2Fannotation_2FAnnotation_3B, "[Ljava/lang/annotation/Annotation;");
+  InitCacheClass(ALjava_2Flang_2Freflect_2FConstructor_3B, "[Ljava/lang/reflect/Constructor;");
+  InitCacheClass(ALjava_2Flang_2Freflect_2FParameter_3B, "[Ljava/lang/reflect/Parameter;");
+  InitCacheClass(ALjava_2Flang_2FString_3B, "[Ljava/lang/String;");
+  InitCacheClass(ALjava_2Flang_2FBoolean_3B, "[Ljava/lang/Boolean;");
+  InitCacheClass(ALjava_2Flang_2FByte_3B, "[Ljava/lang/Byte;");
+  InitCacheClass(ALjava_2Flang_2FCharacter_3B, "[Ljava/lang/Character;");
+  InitCacheClass(ALjava_2Flang_2FShort_3B, "[Ljava/lang/Short;");
+  InitCacheClass(ALjava_2Flang_2FInteger_3B, "[Ljava/lang/Integer;");
+  InitCacheClass(ALjava_2Flang_2FLong_3B, "[Ljava/lang/Long;");
+  InitCacheClass(ALjava_2Flang_2FFloat_3B, "[Ljava/lang/Float;");
+  InitCacheClass(ALjava_2Flang_2FDouble_3B, "[Ljava/lang/Double;");
+  InitCacheClass(AALjava_2Flang_2Fannotation_2FAnnotation_3B, "[[Ljava/lang/annotation/Annotation;");
+}
+
+void WellKnown::InitCacheExceptionClass() {
+  InitCacheClass(Ljava_2Flang_2FError_3B, "Ljava/lang/Error;");
+  InitCacheClass(Ljava_2Flang_2FThrowable_3B, "Ljava/lang/Throwable;");
+  InitCacheClass(Ljava_2Flang_2FArithmeticException_3B, "Ljava/lang/ArithmeticException;");
+  InitCacheClass(Ljava_2Flang_2FInterruptedException_3B, "Ljava/lang/InterruptedException;");
+  InitCacheClass(Ljava_2Flang_2FClassCastException_3B, "Ljava/lang/ClassCastException;");
+  InitCacheClass(Ljava_2Flang_2FUnsatisfiedLinkError_3B, "Ljava/lang/UnsatisfiedLinkError;");
+  InitCacheClass(Ljava_2Flang_2FStringIndexOutOfBoundsException_3B, "Ljava/lang/StringIndexOutOfBoundsException;");
+  InitCacheClass(Ljava_2Flang_2FNoClassDefFoundError_3B, "Ljava/lang/NoClassDefFoundError;");
+  InitCacheClass(Ljava_2Flang_2FNoSuchMethodError_3B, "Ljava/lang/NoSuchMethodError;");
+  InitCacheClass(Ljava_2Flang_2FNoSuchFieldError_3B, "Ljava/lang/NoSuchFieldError;");
+  InitCacheClass(Ljava_2Flang_2FVerifyError_3B, "Ljava/lang/VerifyError;");
+  InitCacheClass(Ljava_2Flang_2FExceptionInInitializerError_3B, "Ljava/lang/ExceptionInInitializerError;");
+  InitCacheClass(Ljava_2Flang_2FRuntimeException_3B, "Ljava/lang/RuntimeException;");
+  InitCacheClass(Ljava_2Flang_2FSecurityException_3B, "Ljava/lang/SecurityException;");
+  InitCacheClass(Ljava_2Flang_2Freflect_2FUndeclaredThrowableException_3B,
+                 "Ljava/lang/reflect/UndeclaredThrowableException;");
+  InitCacheClass(Ljava_2Flang_2FArrayStoreException_3B, "Ljava/lang/ArrayStoreException;");
+  InitCacheClass(Ljava_2Flang_2FArrayIndexOutOfBoundsException_3B, "Ljava/lang/ArrayIndexOutOfBoundsException;");
+  InitCacheClass(Ljava_2Flang_2FNullPointerException_3B, "Ljava/lang/NullPointerException;");
+}
+
+void WellKnown::InitCacheMethodAddrs() {
+  InitCacheMethodAddr(Ljava_2Flang_2FClassLoader_3B_LoadClass_Addr, *Ljava_2Flang_2FClassLoader_3B,
+                      "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+#ifndef __OPENJDK__
+  InitCacheMethodAddr(Llibcore_2Freflect_2FAnnotationMember_3B_7C_3Cinit_Addr,
+                      *Llibcore_2Freflect_2FAnnotationMember_3B,
+                      "<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/reflect/Method;)V");
+  InitCacheMethodAddr(Llibcore_2Freflect_2FAnnotationFactory_3B_7CcreateAnnotation_Addr,
+                      *Llibcore_2Freflect_2FAnnotationFactory_3B, "createAnnotation",
+                      "(Ljava/lang/Class;[Llibcore/reflect/AnnotationMember;)Ljava/lang/annotation/Annotation;");
+#endif
+  InitCacheMethodAddr(Ljava_2Flang_2FBoolean_3B_ValueOf_Addr, *Ljava_2Flang_2FBoolean_3B,
+                      "valueOf", "(Z)Ljava/lang/Boolean;");
+  InitCacheMethodAddr(Ljava_2Flang_2FByte_3B_ValueOf_Addr, *Ljava_2Flang_2FByte_3B, "valueOf", "(B)Ljava/lang/Byte;");
+  InitCacheMethodAddr(Ljava_2Flang_2FCharacter_3B_ValueOf_Addr, *Ljava_2Flang_2FCharacter_3B,
+                      "valueOf", "(C)Ljava/lang/Character;");
+  InitCacheMethodAddr(Ljava_2Flang_2FShort_3B_ValueOf_Addr, *Ljava_2Flang_2FShort_3B,
+                      "valueOf", "(S)Ljava/lang/Short;");
+  InitCacheMethodAddr(Ljava_2Flang_2FInteger_3B_ValueOf_Addr, *Ljava_2Flang_2FInteger_3B,
+                      "valueOf", "(I)Ljava/lang/Integer;");
+  InitCacheMethodAddr(Ljava_2Flang_2FLong_3B_ValueOf_Addr, *Ljava_2Flang_2FLong_3B, "valueOf", "(J)Ljava/lang/Long;");
+  InitCacheMethodAddr(Ljava_2Flang_2FFloat_3B_ValueOf_Addr, *Ljava_2Flang_2FFloat_3B,
+                      "valueOf", "(F)Ljava/lang/Float;");
+  InitCacheMethodAddr(Ljava_2Flang_2FDouble_3B_ValueOf_Addr, *Ljava_2Flang_2FDouble_3B,
+                      "valueOf", "(D)Ljava/lang/Double;");
+}
+
+void WellKnown::InitCacheFieldMethodHandleOffsets() {
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodType_3B_ptypes_offset, *Ljava_2Flang_2Finvoke_2FMethodType_3B, "ptypes");
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodType_3B_rtype_offset, *Ljava_2Flang_2Finvoke_2FMethodType_3B, "rtype");
+#ifdef METHODHANDLE_OPENJDK
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodHandle_3B_dataArray_offset,
+                       *Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "dataArray");
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodHandle_3B_metaArray_offset,
+                       *Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "metaArray");
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodHandle_3B_typeArray_offset,
+                       *Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "typeArray");
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodHandle_3B_opArray_offset,
+                       *Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "opArray");
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodHandle_3B_index_offset,
+                       *Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "index");
+  InitCacheFieldOffset(Ljava_2Flang_2FBindToData_3B_receiver_offset,
+                       *Ljava_2Flang_2Finvoke_2FInvokeData_24BindToData_3B, "receiver");
+  InitCacheFieldOffset(Ljava_2Flang_2FDropArgumentsData_3B_numDropped_offset,
+                       *Ljava_2Flang_2Finvoke_2FInvokeData_24DropArgumentsData_3B, "numDropped");
+  InitCacheFieldOffset(Ljava_2Flang_2FDropArgumentsData_3B_startPos_offset,
+                       *Ljava_2Flang_2Finvoke_2FInvokeData_24DropArgumentsData_3B, "startPos");
+  InitCacheFieldOffset(Ljava_2Flang_2FFilterReturnValueData_3B_target_offset,
+                       *Ljava_2Flang_2Finvoke_2FInvokeData_24FilterReturnValueData_3B, "target");
+  InitCacheFieldOffset(Ljava_2Flang_2FFilterReturnValueData_3B_filter_offset,
+                       *Ljava_2Flang_2Finvoke_2FInvokeData_24FilterReturnValueData_3B, "filter");
+  InitCacheFieldOffset(Ljava_2Flang_2FPermuteArgumentsData_3B_target_offset,
+                       *Ljava_2Flang_2Finvoke_2FInvokeData_24PermuteArgumentsData_3B, "target");
+  InitCacheFieldOffset(Ljava_2Flang_2FPermuteArgumentsData_3B_reorder_offset,
+                       *Ljava_2Flang_2Finvoke_2FInvokeData_24PermuteArgumentsData_3B, "reorder");
+#else
+#ifndef __OPENJDK__
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodHandle_3B_artFieldOrMethod_offset,
+                       *Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "artFieldOrMethod");
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodHandle_3B_handleKind_offset,
+                       *Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "handleKind");
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodHandle_3B_nominalType_offset,
+                       *Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "nominalType");
+  InitCacheFieldOffset(Ljava_2Flang_2FMethodHandle_3B_type_offset,
+                       *Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "type");
+  InitCacheFieldOffset(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_callsiteType_offset,
+                       *Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, "callsiteType");
+  InitCacheFieldOffset(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_references_offset,
+                       *Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, "references");
+  InitCacheFieldOffset(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_stackFrame_offset,
+                       *Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, "stackFrame");
+  InitCacheFieldOffset(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B_type_offset,
+                       *Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, "type");
+#endif // OPENJDK
+#endif // METHODHANDLE_OPENJDK
+}
+
+void WellKnown::InitCacheFieldOffsets() {
+  InitCacheFieldOffset(Ljava_2Flang_2FBoolean_3B_value_offset, *Ljava_2Flang_2FBoolean_3B, "value");
+  InitCacheFieldOffset(Ljava_2Flang_2FByte_3B_value_offset, *Ljava_2Flang_2FByte_3B, "value");
+  InitCacheFieldOffset(Ljava_2Flang_2FCharacter_3B_value_offset, *Ljava_2Flang_2FCharacter_3B, "value");
+  InitCacheFieldOffset(Ljava_2Flang_2FShort_3B_value_offset, *Ljava_2Flang_2FShort_3B, "value");
+  InitCacheFieldOffset(Ljava_2Flang_2FInteger_3B_value_offset, *Ljava_2Flang_2FInteger_3B, "value");
+  InitCacheFieldOffset(Ljava_2Flang_2FLong_3B_value_offset, *Ljava_2Flang_2FLong_3B, "value");
+  InitCacheFieldOffset(Ljava_2Flang_2FFloat_3B_value_offset, *Ljava_2Flang_2FFloat_3B, "value");
+  InitCacheFieldOffset(Ljava_2Flang_2FDouble_3B_value_offset, *Ljava_2Flang_2FDouble_3B, "value");
+  InitCacheFieldOffset(kReferenceReferentOffset, *Ljava_2Flang_2Fref_2FReference_3B, "referent");
+  InitCacheFieldOffset(kReferenceQueueOffset, *Ljava_2Flang_2Fref_2FReference_3B, "queue");
+  InitCacheFieldMethodHandleOffsets();
+#ifdef __OPENJDK__
+  InitCacheFieldOffset(kReferencePendingnextOffset, *Ljava_2Flang_2Fref_2FReference_3B, "discovered");
+#else // libcore
+  InitCacheFieldOffset(kReferencePendingnextOffset, *Ljava_2Flang_2Fref_2FReference_3B, "pendingNext");
+  InitCacheFieldOffset(kFinalizereferenceZombieOffset, *Ljava_2Flang_2Fref_2FFinalizerReference_3B, "zombie");
+#endif // __OPENJDK__
+}
+
+void WellKnown::InitCacheMethodHandleClasses() {
+  InitCacheClass(Ljava_2Flang_2Finvoke_2FMethodHandle_3B, "Ljava/lang/invoke/MethodHandle;");
+  InitCacheClass(Ljava_2Flang_2Finvoke_2FMethodType_3B, "Ljava/lang/invoke/MethodType;");
+#ifdef METHODHANDLE_OPENJDK
+  InitCacheClass(Ljava_2Flang_2Finvoke_2FInvokeData_24BindToData_3B,
+      "Ljava/lang/invoke/InvokeData$BindToData;");
+  InitCacheClass(Ljava_2Flang_2Finvoke_2FInvokeData_24DropArgumentsData_3B,
+      "Ljava/lang/invoke/InvokeData$DropArgumentsData;");
+  InitCacheClass(Ljava_2Flang_2Finvoke_2FInvokeData_24FilterReturnValueData_3B,
+      "Ljava/lang/invoke/InvokeData$FilterReturnValueData;");
+  InitCacheClass(Ljava_2Flang_2Finvoke_2FInvokeData_24PermuteArgumentsData_3B,
+      "Ljava/lang/invoke/InvokeData$PermuteArgumentsData;");
+#else
+#ifndef __OPENJDK__
+  InitCacheClass(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, "Ldalvik/system/EmulatedStackFrame;");
+#endif // __OPENJDK__
+#endif // METHODHANDLE_OPENJDK
+}
+
+void WellKnown::InitCacheClasses() {
+  InitCachePrimitiveBoxClass();
+  InitCacheArrayClass();
+  InitCacheExceptionClass();
+  InitCacheMethodHandleClasses();
+  InitCacheClass(Ljava_2Flang_2FObject_3B, "Ljava/lang/Object;");
+  InitCacheClass(Ljava_2Flang_2FClassLoader_3B, "Ljava/lang/ClassLoader;");
+  InitCacheClass(Ljava_2Flang_2Freflect_2FField_3B, "Ljava/lang/reflect/Field;");
+  InitCacheClass(Ljava_2Flang_2Freflect_2FConstructor_3B, "Ljava/lang/reflect/Constructor;");
+  InitCacheClass(Ljava_2Flang_2Freflect_2FMethod_3B, "Ljava/lang/reflect/Method;");
+  InitCacheClass(Ljava_2Flang_2Freflect_2FProxy_3B, "Ljava/lang/reflect/Proxy;");
+  InitCacheClass(Ljava_2Flang_2Freflect_2FParameter_3B, "Ljava/lang/reflect/Parameter;");
+#ifndef __OPENJDK__
+  InitCacheClass(Llibcore_2Freflect_2FGenericSignatureParser_3B, "Llibcore/reflect/GenericSignatureParser;");
+#endif // __OPENJDK__
+  InitCacheClass(Ljava_2Flang_2FCloneable_3B, "Ljava/lang/Cloneable;");
+  InitCacheClass(Ljava_2Fio_2FSerializable_3B, "Ljava/io/Serializable;");
+  InitCacheClass(Ljava_2Flang_2FStringFactory_3B, "Ljava/lang/StringFactory;");
+  InitCacheClass(Ljava_2Flang_2FEnum_3B, "Ljava/lang/Enum;");
+  InitCacheClass(Ljava_2Flang_2Fannotation_2FAnnotation_3B, "Ljava/lang/annotation/Annotation;");
+#ifndef __OPENJDK__
+  InitCacheClass(Llibcore_2Freflect_2FAnnotationMember_3B, "Llibcore/reflect/AnnotationMember;");
+  InitCacheClass(Llibcore_2Freflect_2FAnnotationFactory_3B, "Llibcore/reflect/AnnotationFactory;");
+  InitCacheClass(Ldalvik_2Fsystem_2FDelegateLastClassLoader_3B, "Ldalvik/system/DelegateLastClassLoader;");
+  InitCacheClass(Ldalvik_2Fsystem_2FPathClassLoader_3B, "Ldalvik/system/PathClassLoader;");
+  InitCacheClass(Ldalvik_2Fsystem_2FDexClassLoader_3B, "Ldalvik/system/DexClassLoader;");
+  InitCacheClass(Ldalvik_2Fsystem_2FInMemoryDexClassLoader_3B, "Ldalvik/system/InMemoryDexClassLoader;");
+#endif // __OPENJDK__
+#ifdef __OPENJDK__
+  InitCacheClass(Ljava_2Futil_2FHashMap_3B, "Ljava/util/HashMap;");
+  InitCacheClass(Lsun_2Freflect_2Fannotation_2FAnnotationParser_3B, "Lsun/reflect/annotation/AnnotationParser;");
+#else // libcore
+  InitCacheClass(Ljava_2Flang_2Fref_2FFinalizerReference_3B, "Ljava/lang/ref/FinalizerReference;");
+#endif // __OPENJDK__
+  InitCacheClass(Ljava_2Flang_2Fref_2FReference_3B, "Ljava/lang/ref/Reference;");
+
+  InitCacheClass(Ljava_2Flang_2FInteger_24IntegerCache_3B, "Ljava/lang/Integer$IntegerCache;");
+  InitCacheClass(Ljava_2Flang_2FByte_24ByteCache_3B, "Ljava/lang/Byte$ByteCache;");
+  InitCacheClass(Ljava_2Flang_2FShort_24ShortCache_3B, "Ljava/lang/Short$ShortCache;");
+  InitCacheClass(Ljava_2Flang_2FCharacter_24CharacterCache_3B, "Ljava/lang/Character$CharacterCache;");
+  InitCacheClass(Ljava_2Flang_2FLong_24LongCache_3B, "Ljava/lang/Long$LongCache;");
+
+  InitArrayInterfaceVector();
+  // keep order with maple::Primitive::Type
+  primitiveArrayClass[maple::Primitive::kNot] = nullptr;
+  primitiveArrayClass[maple::Primitive::kBoolean] = primitiveClassAZ;
+  primitiveArrayClass[maple::Primitive::kByte] = primitiveClassAB;
+  primitiveArrayClass[maple::Primitive::kChar] = primitiveClassAC;
+  primitiveArrayClass[maple::Primitive::kShort] = primitiveClassAS;
+  primitiveArrayClass[maple::Primitive::kInt] = primitiveClassAI;
+  primitiveArrayClass[maple::Primitive::kLong] = primitiveClassAJ;
+  primitiveArrayClass[maple::Primitive::kFloat] = primitiveClassAF;
+  primitiveArrayClass[maple::Primitive::kDouble] = primitiveClassAD;
+};
+
+void WellKnown::InitCacheFieldMetas() {
+  InitCacheFieldMeta(Ljava_2Flang_2FBoolean_3B_TRUE, *Ljava_2Flang_2FBoolean_3B, "TRUE");
+  InitCacheFieldMeta(Ljava_2Flang_2FBoolean_3B_FALSE, *Ljava_2Flang_2FBoolean_3B, "FALSE");
+  InitCacheFieldMeta(Ljava_2Flang_2FByte_24ByteCache_3B_cache, *Ljava_2Flang_2FByte_24ByteCache_3B, "cache");
+  InitCacheFieldMeta(Ljava_2Flang_2FShort_24ShortCache_3B_cache, *Ljava_2Flang_2FShort_24ShortCache_3B, "cache");
+  InitCacheFieldMeta(Ljava_2Flang_2FCharacter_24CharacterCache_3B_cache,
+                     *Ljava_2Flang_2FCharacter_24CharacterCache_3B, "cache");
+  InitCacheFieldMeta(Ljava_2Flang_2FLong_24LongCache_3B_cache, *Ljava_2Flang_2FLong_24LongCache_3B, "cache");
+  InitCacheFieldMeta(Ljava_2Flang_2FInteger_24IntegerCache_3B_cache,
+                     *Ljava_2Flang_2FInteger_24IntegerCache_3B, "cache");
+  InitCacheFieldMeta(Ljava_2Flang_2FInteger_24IntegerCache_3B_low,
+                     *Ljava_2Flang_2FInteger_24IntegerCache_3B, "low");
+  InitCacheFieldMeta(Ljava_2Flang_2FInteger_24IntegerCache_3B_high,
+                     *Ljava_2Flang_2FInteger_24IntegerCache_3B, "high");
+}
+
+MethodMeta *WellKnown::GetStringFactoryConstructor(const MethodMeta &stringConstructor) {
+  struct StringInitMap {
+    const char *initSignature;
+    const char *stringFacName;
+    const char *stringFacSignature;
+    MethodMeta *stringFactoryConstructor;
+  };
+  StringInitMap initMap[] = {
+      { "()V", "newEmptyString", "()Ljava/lang/String;", nullptr },
+      { "([B)V", "newStringFromBytes", "([B)Ljava/lang/String;", nullptr },
+      { "([BI)V", "newStringFromBytes", "([BI)Ljava/lang/String;", nullptr },
+      { "([BII)V", "newStringFromBytes", "([BII)Ljava/lang/String;", nullptr },
+      { "([BIII)V", "newStringFromBytes", "([BIII)Ljava/lang/String;", nullptr },
+      { "([BIILjava/lang/String;)V", "newStringFromBytes", "([BIILjava/lang/String;)Ljava/lang/String;", nullptr },
+      { "([BLjava/lang/String;)V", "newStringFromBytes", "([BLjava/lang/String;)Ljava/lang/String;", nullptr },
+      { "([BIILjava/nio/charset/Charset;)V", "newStringFromBytes",
+          "([BIILjava/nio/charset/Charset;)Ljava/lang/String;", nullptr },
+      { "([BLjava/nio/charset/Charset;)V", "newStringFromBytes",
+          "([BLjava/nio/charset/Charset;)Ljava/lang/String;", nullptr },
+      { "([C)V", "newStringFromChars", "([C)Ljava/lang/String;", nullptr },
+      { "([CII)V", "newStringFromChars", "([CII)Ljava/lang/String;", nullptr },
+      { "(II[C)V", "newStringFromChars", "(II[C)Ljava/lang/String;", nullptr },
+      { "(Ljava/lang/String;)V", "newStringFromString", "(Ljava/lang/String;)Ljava/lang/String;", nullptr },
+      { "(Ljava/lang/StringBuffer;)V", "newStringFromStringBuffer",
+          "(Ljava/lang/StringBuffer;)Ljava/lang/String;", nullptr },
+      { "([III)V", "newStringFromCodePoints", "([III)Ljava/lang/String;", nullptr },
+      { "(Ljava/lang/StringBuilder;)V", "newStringFromStringBuilder",
+          "(Ljava/lang/StringBuilder;)Ljava/lang/String;", nullptr }
+  };
+  MClass *classObj = stringConstructor.GetDeclaringClass();
+  CHECK(classObj->IsStringClass()) << "must String Class." << maple::endl;
+  CHECK(stringConstructor.IsConstructor()) << "must String Constructor." << maple::endl;
+  const char *signature = stringConstructor.GetSignature();
+  constexpr uint32_t length = sizeof(initMap) / sizeof(struct StringInitMap);
+  uint32_t index = 0;
+  for (; index < length; ++index) {
+    if (strcmp(signature, initMap[index].initSignature) == 0) {
+      break;
+    }
+  }
+  CHECK(index < length) << "Not find String constructor from StringFactory" << maple::endl;
+  MethodMeta *stringFactoryCtor = initMap[index].stringFactoryConstructor;
+  if (stringFactoryCtor != nullptr) {
+    return stringFactoryCtor;
+  }
+  MethodMeta *ctor = WellKnown::GetMClassStringFactory()->GetDeclaredMethod(initMap[index].stringFacName,
+      initMap[index].stringFacSignature);
+  initMap[index].stringFactoryConstructor = ctor;
+  return ctor;
+}
+
+void MRT_BootstrapWellKnown(void) {
+  WellKnown::InitCacheClasses();
+  WellKnown::InitCacheMethodAddrs();
+  WellKnown::InitCacheFieldOffsets();
+  WellKnown::InitCacheFieldMetas();
+}
+
+jclass MRT_GetPrimitiveClassVoid(void) {
+  return WellKnown::GetMClassV()->AsJclass();
+}
+
+jclass MRT_GetClassClass(void) {
+  return WellKnown::GetMClassClass()->AsJclass();
+}
+
+jclass MRT_GetClassObject(void) {
+  return WellKnown::GetMClassObject()->AsJclass();
+}
+
+jclass MRT_GetClassString(void) {
+  return WellKnown::GetMClassString()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveArrayClassJboolean(void) {
+  return WellKnown::GetMClassAZ()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveArrayClassJbyte(void) {
+  return WellKnown::GetMClassAB()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveArrayClassJchar(void) {
+  return WellKnown::GetMClassAC()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveArrayClassJdouble(void) {
+  return WellKnown::GetMClassAD()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveArrayClassJfloat(void) {
+  return WellKnown::GetMClassAF()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveArrayClassJint(void) {
+  return WellKnown::GetMClassAI()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveArrayClassJlong(void) {
+  return WellKnown::GetMClassAJ()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveArrayClassJshort(void) {
+  return WellKnown::GetMClassAS()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveClassJboolean(void) {
+  return WellKnown::GetMClassZ()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveClassJbyte(void) {
+  return WellKnown::GetMClassB()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveClassJchar(void) {
+  return WellKnown::GetMClassC()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveClassJdouble(void) {
+  return WellKnown::GetMClassD()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveClassJfloat(void) {
+  return WellKnown::GetMClassF()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveClassJint(void) {
+  return WellKnown::GetMClassI()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveClassJlong(void) {
+  return WellKnown::GetMClassJ()->AsJclass();
+}
+
+jclass MRT_GetPrimitiveClassJshort(void) {
+  return WellKnown::GetMClassS()->AsJclass();
+}
+} // namespace maplert
diff --git a/src/mrt/maplert/src/mstring.cpp b/src/mrt/maplert/src/mstring.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7c86bccd25e2ec5e3292103bffc9098e54aea2ea
--- /dev/null
+++ b/src/mrt/maplert/src/mstring.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "mstring.h"
+#include "mstring_inline.h"
+#include "mrt_string.h"
+#include "chelper.h"
+
+namespace maplert {
+std::string MString::GetChars() const {
+  uint32_t length = GetLength();
+  uint8_t *src = GetContentsPtr();
+
+  // Prepare result string
+  std::string res;
+  res.reserve(length);
+
+  if (IsCompress()) {
+    // If it is compressed, just copy the content.
+    for (uint32_t i = 0; i < length; ++i) {
+      // IsCompress() implies each character is within 1 <= ch <= 0x7f
+      res.push_back(static_cast<char>(src[i])); // safe to cast
+    }
+    __MRT_ASSERT(res.length() == length, "Length is different after copying");
+  } else if (IsCompressChars<uint16_t>(reinterpret_cast<uint16_t*>(src), length)) {
+    // If the string itself is not compressed, but every character is compressible, we compress on the fly.
+    for (uint32_t i = 0; i < length; ++i) {
+      // IsCompressChars() implies each character is within 1 <= ch <= 0x7f
+      res.push_back(static_cast<char>(src[i * sizeof(uint16_t)])); // For little endian. Safe to cast.
+    }
+    __MRT_ASSERT(res.length() == length, "Length is different after conversion");
+  } else {
+    // It contains non-ASCII characters.  We need to handle it with care.
+    std::u16string str16(reinterpret_cast<char16_t*>(src));
+    // Note: The last parameter of UTF16ToUTF8 is called "isBigEndian", but it really means whether the endianness of
+    // each str16 character needs to be swapped.  We do not need to swap endianness, thus we pass `true`.
+    uint32_t ret = namemangler::UTF16ToUTF8(res, str16, 0, true);
+    CHECK(ret <= str16.length()) << "namemangler::UTF16ToUTF8 in GetChars() fail" << maple::endl;
+  }
+  return res;
+}
+
+MString *MString::Intern() {
+  return GetOrInsertStringPool(*this);
+}
+
+MString *MString::InternUtf8(const std::string &str) {
+  uint32_t length = static_cast<uint32_t>(str.length());
+  MString *strObj = NewStringObject<uint8_t, uint8_t>(reinterpret_cast<const uint8_t*>(str.c_str()), length);
+  if (UNLIKELY(strObj == nullptr)) {
+    return nullptr;
+  }
+  MString *internedString = strObj->Intern();
+  RC_LOCAL_DEC_REF(strObj);
+  return internedString;
+}
+
+MString *MString::InternUtf16(const std::string &str) {
+  MString *strObj = NewStringObjectFromUtf16(str.c_str());
+  if (UNLIKELY(strObj == nullptr)) {
+    return nullptr;
+  }
+  MString *internedString = strObj->Intern();
+  RC_LOCAL_DEC_REF(strObj);
+  return internedString;
+}
+
+MString *MString::InternUtf(const std::string &str) {
+  uint32_t length = static_cast<uint32_t>(str.length());
+  bool isCompress = IsCompressChars<uint8_t>(reinterpret_cast<const uint8_t*>(str.c_str()), length);
+  return isCompress ? InternUtf8(str) : InternUtf16(str);
+}
+
+MString *MString::NewStringObjectFromUtf8(const std::string &str) {
+  uint32_t length = static_cast<uint32_t>(str.length());
+  MString *strObj = NewStringObject<uint8_t, uint8_t>(reinterpret_cast<const uint8_t*>(str.c_str()), length);
+  return strObj;
+}
+
+MString *MString::NewStringObjectFromUtf16(const std::string &str) {
+  std::u16string str16;
+  (void)namemangler::UTF8ToUTF16(str16, str, 0, true);
+  MString *jStr = NewStringObject(
+      reinterpret_cast<const uint16_t*>(str16.c_str()), static_cast<uint32_t>(str16.length()));
+  return jStr;
+}
+
+MString *MString::NewStringObjectFromUtf(const std::string &str) {
+  uint32_t length = static_cast<uint32_t>(str.length());
+  bool isCompress = IsCompressChars<uint8_t>(reinterpret_cast<const uint8_t*>(str.c_str()), length);
+  return isCompress ? NewStringObjectFromUtf8(str) : NewStringObjectFromUtf16(str);
+}
+
+MString *MString::NewConstEmptyStringObject() {
+  static MString *constEmptyString = nullptr;
+  if (constEmptyString == nullptr) {
+    MString *emptyStr = NewEmptyStringObject();
+    constEmptyString = emptyStr->Intern();
+    RC_LOCAL_DEC_REF(emptyStr);
+  }
+  return constEmptyString;
+}
+
+bool MString::Equals(const MString &src) const {
+  if (&src == this) {
+    return true;
+  }
+  uint32_t lenA = this->count;
+  uint32_t lenB = src.count;
+  bool aIscompress = (lenA & 0x1u) == 0x1u;
+  bool bIscompress = (lenB & 0x1u) == 0x1u;
+  lenA = lenA >> 1;
+  lenB = lenB >> 1;
+  if (lenA != lenB) {
+    return false;
+  }
+  // at here hash code should already been the same
+  const uint8_t *srcA = this->content;
+  const uint8_t *srcB = src.content;
+  if (aIscompress && bIscompress) {
+    return (memcmp(srcA, srcB, lenA) == 0);
+  } else if (!aIscompress && !bIscompress) {
+    return (memcmp(srcA, srcB, lenA * sizeof(uint16_t)) == 0);
+  } else {
+    const uint8_t *compressChars = nullptr;
+    const uint16_t *uncompressChars = nullptr;
+    if (aIscompress) {
+      compressChars = srcA;
+      uncompressChars = reinterpret_cast<const uint16_t*>(srcB);
+    } else {
+      compressChars = srcB;
+      uncompressChars = reinterpret_cast<const uint16_t*>(srcA);
+    }
+    for (uint32_t i = 0; i < lenA; ++i) {
+      if (compressChars[i] != uncompressChars[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+} // namespace maplert
diff --git a/src/mrt/unified.macros.def b/src/mrt/unified.macros.def
new file mode 100644
index 0000000000000000000000000000000000000000..d384df702866201b66c37df4cb956598780438a9
--- /dev/null
+++ b/src/mrt/unified.macros.def
@@ -0,0 +1,14725 @@
+__MRT_CLASS(Ljava_2Flang_2FObject_3B, 12, THIS_IS_ROOT)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FObject_3B, shadow_24__klass__, 0, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FObject_3B, shadow_24__monitor__, 8, 4)
+__MRT_CLASS(Ljava_2Flang_2FClass_3B, 160, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, accessFlags, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, classFlags, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, classLoader, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, classSize, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, clinitThreadId, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, componentType, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, copiedMethodsOffset, 36, 2)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, dexCache, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, dexClassDefIndex, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, dexTypeIndex, 60, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, extData, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, iFields, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, ifTable, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, methods, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, name, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, numReferenceInstanceFields, 104, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, numReferenceStaticFields, 108, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, objectSize, 112, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, objectSizeAllocFastPath, 116, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, primitiveType, 120, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, referenceInstanceOffsets, 124, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, sFields, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, status, 136, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, superClass, 144, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, virtualMethodsOffset, 38, 2)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClass_3B, vtable, 152, 8)
+__MRT_CLASS(Ljava_2Flang_2FClassLoader_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClassLoader_3B, allocator, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClassLoader_3B, classTable, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClassLoader_3B, packages, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClassLoader_3B, parent, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClassLoader_3B, proxyCache, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_3B, 64, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_3B, entrySet, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_3B, loadFactor, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_3B, modCount, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_3B, size, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_3B, table, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_3B, threshold, 52, 4)
+__MRT_CLASS(Ljava_2Flang_2FString_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FString_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FString_3B, hash, 16, 4)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FSerializedLambda_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamField_3B, 49, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamField_3B, field, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamField_3B, name, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamField_3B, offset, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamField_3B, signature, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamField_3B, type, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamField_3B, unshared, 48, 1)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FField_3B, 48, Ljava_2Flang_2Freflect_2FAccessibleObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FField_3B, accessFlags, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FField_3B, declaringClass, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FField_3B, dexFieldIndex, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FField_3B, offset, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FField_3B, type, 40, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FAccessibleObject_3B, 13, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FAccessibleObject_3B, override, 12, 1)
+__MRT_CLASS(Ljava_2Flang_2Fannotation_2FRetentionPolicy_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Flang_2FEnum_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FEnum_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FEnum_3B, ordinal, 12, 4)
+__MRT_CLASS(Llibcore_2Futil_2FBasicLruCache_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FBasicLruCache_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FBasicLruCache_3B, maxSize, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashMap_3B, 88, Ljava_2Futil_2FHashMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_3B, accessOrder, 64, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_3B, head, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_3B, tail, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashMap_24LinkedHashMapEntry_3B, 56, Ljava_2Futil_2FHashMap_24Node_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedHashMapEntry_3B, after, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedHashMapEntry_3B, before, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24Node_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24Node_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24Node_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24Node_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24Node_3B, value, 32, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectOutputStream_3B, 80, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, bout, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, curContext, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, curPut, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, debugInfoStack, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, depth, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, enableOverride, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, enableReplace, 49, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, handles, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, primVals, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, protocol, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_3B, subs, 72, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectOutputStream_24BlockDataOutputStream_3B, 60, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24BlockDataOutputStream_3B, blkmode, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24BlockDataOutputStream_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24BlockDataOutputStream_3B, cbuf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24BlockDataOutputStream_3B, dout, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24BlockDataOutputStream_3B, hbuf, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24BlockDataOutputStream_3B, out, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24BlockDataOutputStream_3B, pos, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24BlockDataOutputStream_3B, warnOnceWhenWriting, 13, 1)
+__MRT_CLASS(Ljava_2Fio_2FDataOutputStream_3B, 44, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FDataOutputStream_3B, bytearr, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FDataOutputStream_3B, writeBuffer, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FDataOutputStream_3B, written, 40, 4)
+__MRT_CLASS(Ljava_2Fio_2FOutputStream_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FFilterOutputStream_3B, 24, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFilterOutputStream_3B, out, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FSerialCallbackContext_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FSerialCallbackContext_3B, desc, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FSerialCallbackContext_3B, obj, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FSerialCallbackContext_3B, thread, 32, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_3B, 176, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, cl, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, cons, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, dataLayout, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, defaultSerializeEx, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, deserializeEx, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, externalizable, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, fieldRefl, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, fields, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, hasBlockExternalData, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, hasWriteObjectData, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, initialized, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, isEnum, 72, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, isProxy, 73, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, localDesc, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, name, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, numObjFields, 76, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, primDataSize, 96, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, readObjectMethod, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, readObjectNoDataMethod, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, readResolveMethod, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, resolveEx, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, serializable, 74, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, serializeEx, 136, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, suid, 144, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, superDesc, 152, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, writeObjectMethod, 160, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_3B, writeReplaceMethod, 168, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FConstructor_3B, 72, Ljava_2Flang_2Freflect_2FExecutable_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FConstructor_3B, serializationClass, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FConstructor_3B, serializationCtor, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2FStringBuilder_3B, 24, Ljava_2Flang_2FAbstractStringBuilder_3B)
+__MRT_CLASS(Ljava_2Futil_2FOptionalDouble_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FOptionalDouble_3B, isPresent, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FOptionalDouble_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FCollector_24Characteristics_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2FOptional_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FOptional_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FOptionalLong_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FOptionalLong_3B, isPresent, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FOptionalLong_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FLong_3B, 24, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FLong_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Fmath_2FBigInteger_3B, 60, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, bigInt, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, digits, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, firstNonzeroDigit, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, hashCode, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, javaIsValid, 36, 1)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, magnitude, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, nativeIsValid, 37, 1)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, numberLength, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, sign, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInteger_3B, signum, 56, 4)
+__MRT_CLASS(Ljava_2Fmath_2FBigInt_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigInt_3B, bignum, 16, 8)
+__MRT_CLASS(Llibcore_2Futil_2FNativeAllocationRegistry_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FNativeAllocationRegistry_3B, classLoader, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FNativeAllocationRegistry_3B, freeFunction, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FNativeAllocationRegistry_3B, size, 32, 8)
+__MRT_CLASS(Ljava_2Flang_2FNumberFormatException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Ljava_2Flang_2FIllegalArgumentException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2FThrowable_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThrowable_3B, backtrace, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThrowable_3B, cause, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThrowable_3B, detailMessage, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThrowable_3B, stackTrace, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThrowable_3B, suppressedExceptions, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2FStackTraceElement_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FStackTraceElement_3B, declaringClass, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FStackTraceElement_3B, fileName, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FStackTraceElement_3B, lineNumber, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FStackTraceElement_3B, methodName, 32, 8)
+__MRT_CLASS(Ljava_2Flang_2FThrowable_24PrintStreamOrWriter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FThrowable_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_3B, 64, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, bin, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, closed, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, curContext, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, defaultDataEnd, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, depth, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, enableOverride, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, enableResolve, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, handles, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, passHandle, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, primVals, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_3B, vlist, 56, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, 76, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, blkmode, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, cbuf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, din, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, end, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, hbuf, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, in, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, pos, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, this_240, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24BlockDataInputStream_3B, unread, 72, 4)
+__MRT_CLASS(Ljava_2Fio_2FDataInputStream_3B, 56, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FDataInputStream_3B, bytearr, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FDataInputStream_3B, chararr, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FDataInputStream_3B, lineBuffer, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FDataInputStream_3B, readBuffer, 48, 8)
+__MRT_CLASS(Ljava_2Fio_2FInputStream_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FFilterInputStream_3B, 24, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFilterInputStream_3B, in, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2Fannotation_2FElementType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24PeekInputStream_3B, 32, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24PeekInputStream_3B, in, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24PeekInputStream_3B, peekb, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24PeekInputStream_3B, totalBytesRead, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24HandleTable_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24HandleTable_3B, deps, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24HandleTable_3B, entries, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24HandleTable_3B, lowDep, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24HandleTable_3B, size, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24HandleTable_3B, status, 40, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24HandleTable_24HandleList_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24HandleTable_24HandleList_3B, list, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24HandleTable_24HandleList_3B, size, 12, 4)
+__MRT_CLASS(Ljava_2Flang_2FClassNotFoundException_3B, 64, Ljava_2Flang_2FReflectiveOperationException_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FClassNotFoundException_3B, ex, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2FReflectiveOperationException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Flang_2FException_3B, 56, Ljava_2Flang_2FThrowable_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24ValidationList_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24ValidationList_3B, list, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24ValidationList_24Callback_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24ValidationList_24Callback_3B, acc, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24ValidationList_24Callback_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24ValidationList_24Callback_3B, obj, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24ValidationList_24Callback_3B, priority, 12, 4)
+__MRT_CLASS(Ljava_2Fsecurity_2FAccessControlContext_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FProtectionDomain_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FCodeSource_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FCodeSource_3B, location, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURL_3B, 112, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, authority, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, file, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, handler, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, hashCode, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, host, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, hostAddress, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, path, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, port, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, protocol, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, query, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, ref, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, tempState, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURL_3B, userInfo, 104, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLStreamHandler_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FInetAddress_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetAddress_3B, canonicalHostName, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetAddress_3B, holder, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FInetAddress_24InetAddressHolder_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetAddress_24InetAddressHolder_3B, address, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetAddress_24InetAddressHolder_3B, family, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetAddress_24InetAddressHolder_3B, hostName, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetAddress_24InetAddressHolder_3B, originalHostName, 32, 8)
+__MRT_CLASS(Ljava_2Fnet_2FNetworkInterface_3B, 73, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_3B, addrs, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_3B, bindings, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_3B, childs, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_3B, displayName, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_3B, hardwareAddr, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_3B, name, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_3B, parent, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_3B, virtual, 72, 1)
+__MRT_CLASS(Ljava_2Fnet_2FInterfaceAddress_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInterfaceAddress_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInterfaceAddress_3B, broadcast, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInterfaceAddress_3B, maskLength, 12, 2)
+__MRT_CLASS(Ljava_2Fnet_2FInet4Address_3B, 32, Ljava_2Fnet_2FInetAddress_3B)
+__MRT_CLASS(Ljava_2Fnet_2FURLConnection_3B, 49, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, allowUserInteraction, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, connectTimeout, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, connected, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, doInput, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, doOutput, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, ifModifiedSince, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, readTimeout, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, requests, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, url, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLConnection_3B, useCaches, 48, 1)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2FMessageHeader_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMessageHeader_3B, keys, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMessageHeader_3B, nkeys, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMessageHeader_3B, values, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FPrintStream_3B, 64, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintStream_3B, autoFlush, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintStream_3B, charOut, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintStream_3B, charset, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintStream_3B, closing, 25, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintStream_3B, formatter, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintStream_3B, textOut, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintStream_3B, trouble, 26, 1)
+__MRT_CLASS(Ljava_2Fio_2FOutputStreamWriter_3B, 40, Ljava_2Fio_2FWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FOutputStreamWriter_3B, se, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, 88, Ljava_2Fio_2FWriter_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, bb, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, ch, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, cs, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, encoder, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, haveLeftoverChar, 64, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, isOpen, 65, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, lcb, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, leftoverChar, 66, 2)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamEncoder_3B, out, 80, 8)
+__MRT_CLASS(Ljava_2Fnio_2FByteBuffer_3B, 56, Ljava_2Fnio_2FBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBuffer_3B, bigEndian, 40, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBuffer_3B, hb, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBuffer_3B, isReadOnly, 41, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBuffer_3B, nativeByteOrder, 42, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBuffer_3B, offset, 44, 4)
+__MRT_CLASS(Ljava_2Fnio_2FCharBuffer_3B, 56, Ljava_2Fnio_2FBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FCharBuffer_3B, hb, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FCharBuffer_3B, isReadOnly, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FCharBuffer_3B, offset, 52, 4)
+__MRT_CLASS(Ljava_2Fnio_2FBuffer_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FBuffer_3B, __elementSizeShift, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FBuffer_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FBuffer_3B, capacity, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FBuffer_3B, limit, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FBuffer_3B, mark, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FBuffer_3B, position, 36, 4)
+__MRT_CLASS(Ljava_2Fnio_2FByteOrder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteOrder_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2FDoubleBuffer_3B, 56, Ljava_2Fnio_2FBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDoubleBuffer_3B, hb, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDoubleBuffer_3B, isReadOnly, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDoubleBuffer_3B, offset, 52, 4)
+__MRT_CLASS(Ljava_2Fnio_2FFloatBuffer_3B, 56, Ljava_2Fnio_2FBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FFloatBuffer_3B, hb, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FFloatBuffer_3B, isReadOnly, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FFloatBuffer_3B, offset, 52, 4)
+__MRT_CLASS(Ljava_2Fnio_2FIntBuffer_3B, 56, Ljava_2Fnio_2FBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FIntBuffer_3B, hb, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FIntBuffer_3B, isReadOnly, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FIntBuffer_3B, offset, 52, 4)
+__MRT_CLASS(Ljava_2Fnio_2FLongBuffer_3B, 56, Ljava_2Fnio_2FBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FLongBuffer_3B, hb, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FLongBuffer_3B, isReadOnly, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FLongBuffer_3B, offset, 52, 4)
+__MRT_CLASS(Ljava_2Fnio_2FShortBuffer_3B, 56, Ljava_2Fnio_2FBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FShortBuffer_3B, hb, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FShortBuffer_3B, isReadOnly, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FShortBuffer_3B, offset, 52, 4)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharset_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharset_3B, aliasSet, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharset_3B, aliases, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharset_3B, name, 32, 8)
+__MRT_CLASS(Ljava_2Flang_2FThreadLocal_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadLocal_3B, threadLocalHashCode, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B, 16, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B, value, 12, 4)
+__MRT_CLASS(Lsun_2Fmisc_2FUnsafe_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FNumber_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_3B, size, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_3B, table, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_3B, threshold, 24, 4)
+__MRT_CLASS(Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B, 56, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B, value, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FWeakReference_3B, 48, Ljava_2Flang_2Fref_2FReference_3B)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FReferenceQueue_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FReferenceQueue_3B, head, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FReferenceQueue_3B, lock, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FReferenceQueue_3B, tail, 32, 8)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FReference_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FReference_3B, pendingNext, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FReference_3B, queue, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FReference_3B, queueNext, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FReference_3B, referent, 40, 8)
+__MRT_CLASS(Ljava_2Flang_2FThreadLocal_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FThread_3B, 176, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, blocker, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, blockerLock, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, contextClassLoader, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, daemon, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, eetop, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, group, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, inheritableThreadLocals, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, inheritedAccessControlContext, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, lock, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, name, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, nativePeer, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, parkBlocker, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, priority, 104, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, single__step, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, stackSize, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, started, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, stillborn, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, systemDaemon, 108, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, target, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, threadLocalRandomProbe, 128, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, threadLocalRandomSecondarySeed, 132, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, threadLocalRandomSeed, 136, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, threadLocals, 144, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, threadQ, 152, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, tid, 160, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, uncaughtExceptionHandler, 168, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_3B, unparkedBeforeStart, 109, 1)
+__MRT_CLASS(Ljava_2Flang_2FThreadGroup_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, daemon, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, destroyed, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, groups, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, maxPriority, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, nUnstartedThreads, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, ngroups, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, nthreads, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, parent, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, threads, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadGroup_3B, vmAllowSuspension, 14, 1)
+__MRT_CLASS(Ljava_2Flang_2FVoid_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FRuntimePermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FBasicPermission_3B, 24, Ljava_2Fsecurity_2FPermission_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FPermission_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FPermission_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FPermissionCollection_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FThread_24State_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2FLocale_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_3B, baseLocale, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_3B, hashCodeValue, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_3B, languageTag, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_3B, localeExtensions, 32, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FBaseLocale_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_3B, language, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_3B, region, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_3B, script, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_3B, variant, 40, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FBaseLocale_24Cache_3B, 32, Lsun_2Futil_2Flocale_2FLocaleObjectCache_3B)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FBaseLocale_24Key_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_24Key_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_24Key_3B, lang, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_24Key_3B, normalized, 24, 1)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_24Key_3B, regn, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_24Key_3B, scrt, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FBaseLocale_24Key_3B, vart, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FSoftReference_3B, 56, Ljava_2Flang_2Fref_2FReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FSoftReference_3B, timestamp, 48, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FBaseLocale_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FLocaleObjectCache_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLocaleObjectCache_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLocaleObjectCache_3B, queue, 24, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FLocaleExtensions_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLocaleExtensions_3B, extensionMap, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLocaleExtensions_3B, id, 24, 8)
+__MRT_CLASS(Ljava_2Flang_2FCharacter_3B, 14, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FCharacter_3B, value, 12, 2)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FExtension_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FExtension_3B, id, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FExtension_3B, key, 12, 2)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FExtension_3B, value, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FLocale_24Cache_3B, 32, Lsun_2Futil_2Flocale_2FLocaleObjectCache_3B)
+__MRT_CLASS(Ljava_2Futil_2FLocale_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FLocale_24LocaleKey_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24LocaleKey_3B, base, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24LocaleKey_3B, exts, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24LocaleKey_3B, hash, 12, 4)
+__MRT_CLASS(Ljava_2Ftext_2FMessageFormat_3B, 56, Ljava_2Ftext_2FFormat_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMessageFormat_3B, argumentNumbers, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMessageFormat_3B, formats, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMessageFormat_3B, locale, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMessageFormat_3B, maxOffset, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMessageFormat_3B, offsets, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMessageFormat_3B, pattern, 48, 8)
+__MRT_CLASS(Ljava_2Ftext_2FFormat_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftext_2FAttributedCharacterIterator_24Attribute_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedCharacterIterator_24Attribute_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FStringBuffer_3B, 32, Ljava_2Flang_2FAbstractStringBuilder_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FStringBuffer_3B, toStringCache, 24, 8)
+__MRT_CLASS(Ljava_2Flang_2FAbstractStringBuilder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FAbstractStringBuilder_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FAbstractStringBuilder_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Ftext_2FFieldPosition_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FFieldPosition_3B, attribute, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FFieldPosition_3B, beginIndex, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FFieldPosition_3B, endIndex, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FFieldPosition_3B, field, 28, 4)
+__MRT_CLASS(Ljava_2Ftext_2FFormat_24Field_3B, 24, Ljava_2Ftext_2FAttributedCharacterIterator_24Attribute_3B)
+__MRT_CLASS(Ljava_2Ftext_2FParsePosition_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FParsePosition_3B, errorIndex, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FParsePosition_3B, index, 16, 4)
+__MRT_CLASS(Ljava_2Futil_2FLocale_24FilteringMode_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2FLocale_24Category_3B, 56, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24Category_3B, countryKey, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24Category_3B, languageKey, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24Category_3B, scriptKey, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24Category_3B, variantKey, 48, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B, averageCharsPerByte, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B, charset, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B, malformedInputAction, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B, maxCharsPerByte, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B, replacement, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B, state, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B, unmappableCharacterAction, 48, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCodingErrorAction_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCodingErrorAction_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCoderResult_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCoderResult_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCoderResult_3B, type, 16, 4)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCoderResult_24Cache_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCoderResult_24Cache_3B, cache, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCoderResult_241_3B, 24, Ljava_2Fnio_2Fcharset_2FCoderResult_24Cache_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B, averageBytesPerChar, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B, cachedDecoder, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B, charset, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B, malformedInputAction, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B, maxBytesPerChar, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B, replacement, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B, state, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B, unmappableCharacterAction, 56, 8)
+__MRT_CLASS(Ljava_2Fio_2FWriter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FWriter_3B, lock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FWriter_3B, writeBuffer, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FFormatter_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_3B, a, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_3B, l, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_3B, lastException, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_3B, zero, 12, 2)
+__MRT_CLASS(Ljava_2Fio_2FIOException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Fio_2FFile_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFile_3B, filePath, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFile_3B, path, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFile_3B, prefixLength, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFile_3B, status, 32, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileSystem_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FUserPrincipalLookupService_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_3B, principals, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_3B, privCredentials, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_3B, pubCredentials, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_3B, readOnly, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FTimeUnit_241_3B, 24, Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fspi_2FFileSystemProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FAccessMode_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FLinkOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileStore_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FURI_3B, 144, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, authority, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, decodedAuthority, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, decodedFragment, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, decodedPath, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, decodedQuery, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, decodedSchemeSpecificPart, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, decodedUserInfo, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, fragment, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, host, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, path, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, port, 96, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, query, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, scheme, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, schemeSpecificPart, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, string, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_3B, userInfo, 136, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FAsynchronousFileChannel_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FFileLock_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FFileLock_3B, channel, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FFileLock_3B, position, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FFileLock_3B, shared, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FFileLock_3B, size, 32, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FFileChannel_3B, 40, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_3B)
+__MRT_CLASS(Ljava_2Fnio_2FMappedByteBuffer_3B, 64, Ljava_2Fnio_2FByteBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FMappedByteBuffer_3B, fd, 56, 8)
+__MRT_CLASS(Ljava_2Fio_2FFileDescriptor_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileDescriptor_3B, descriptor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileDescriptor_3B, ownerId, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FFileChannel_24MapMode_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FFileChannel_24MapMode_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_3B, closeLock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_3B, interrupted, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_3B, interruptor, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_3B, open, 12, 1)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FFileTime_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FFileTime_3B, instant, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FFileTime_3B, unit, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FFileTime_3B, value, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FFileTime_3B, valueAsString, 40, 8)
+__MRT_CLASS(Ljava_2Ftime_2FInstant_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FInstant_3B, nanos, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FInstant_3B, seconds, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2FDuration_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FDuration_3B, nanos, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FDuration_3B, seconds, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fregex_2FPattern_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPattern_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPattern_3B, flags, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPattern_3B, pattern, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fregex_2FMatcher_3B, 76, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, anchoringBounds, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, appendPos, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, from, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, groups, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, matchFound, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, nativeFinalizer, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, originalInput, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, parentPattern, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, text, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, to, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_3B, transparentBounds, 14, 1)
+__MRT_CLASS(Ljava_2Fmath_2FBigDecimal_3B, 56, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigDecimal_3B, bitLength, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigDecimal_3B, hashCode, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigDecimal_3B, intVal, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigDecimal_3B, precision, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigDecimal_3B, scale, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigDecimal_3B, smallValue, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FBigDecimal_3B, toStringImage, 48, 8)
+__MRT_CLASS(Ljava_2Fmath_2FMathContext_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FMathContext_3B, precision, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FMathContext_3B, roundingMode, 16, 8)
+__MRT_CLASS(Ljava_2Fmath_2FRoundingMode_3B, 28, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Fmath_2FRoundingMode_3B, bigDecimalRM, 24, 4)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FValueRange_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FValueRange_3B, maxLargest, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FValueRange_3B, maxSmallest, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FValueRange_3B, minLargest, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FValueRange_3B, minSmallest, 40, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FResolverStyle_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2FClock_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FZoneId_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FZoneOffset_3B, 24, Ljava_2Ftime_2FZoneId_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FZoneOffset_3B, id, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FZoneOffset_3B, totalSeconds, 12, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FZoneRules_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneRules_3B, lastRules, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneRules_3B, lastRulesCache, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneRules_3B, savingsInstantTransitions, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneRules_3B, savingsLocalTransitions, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneRules_3B, standardOffsets, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneRules_3B, standardTransitions, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneRules_3B, wallOffsets, 64, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, dom, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, dow, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, month, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, offsetAfter, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, offsetBefore, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, standardOffset, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, time, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, timeDefinition, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_3B, timeEndOfDay, 13, 1)
+__MRT_CLASS(Ljava_2Ftime_2FDayOfWeek_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FTextStyle_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FTextStyle_3B, calendarStyle, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FTextStyle_3B, zoneNameStyleIndex, 28, 4)
+__MRT_CLASS(Ljava_2Ftime_2FMonth_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2FLocalTime_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FLocalTime_3B, hour, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FLocalTime_3B, minute, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FLocalTime_3B, nano, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FLocalTime_3B, second, 14, 1)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_3B, chrono, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_3B, decimalStyle, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_3B, locale, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_3B, printerParser, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_3B, resolverFields, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_3B, resolverStyle, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_3B, zone, 64, 8)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FChronoField_3B, 64, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FChronoField_3B, baseUnit, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FChronoField_3B, displayNameKey, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FChronoField_3B, name, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FChronoField_3B, range, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FChronoField_3B, rangeUnit, 56, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDecimalStyle_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDecimalStyle_3B, decimalSeparator, 12, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDecimalStyle_3B, negativeSign, 14, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDecimalStyle_3B, positiveSign, 16, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDecimalStyle_3B, zeroDigit, 18, 2)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24CompositePrinterParser_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24CompositePrinterParser_3B, optional, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24CompositePrinterParser_3B, printerParsers, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimePrintContext_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimePrintContext_3B, formatter, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimePrintContext_3B, optional, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimePrintContext_3B, temporal, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeParseContext_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeParseContext_3B, caseSensitive, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeParseContext_3B, chronoListeners, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeParseContext_3B, formatter, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeParseContext_3B, parsed, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeParseContext_3B, strict, 13, 1)
+__MRT_CLASS(Ljava_2Futil_2FArrayList_3B, 28, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_3B, elementData, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_3B, size, 24, 4)
+__MRT_CLASS(Ljava_2Futil_2FAbstractList_3B, 16, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractList_3B, modCount, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2FAbstractCollection_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FParsed_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FParsed_3B, chrono, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FParsed_3B, date, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FParsed_3B, excessDays, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FParsed_3B, fieldValues, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FParsed_3B, leapSecond, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FParsed_3B, resolverStyle, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FParsed_3B, time, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FParsed_3B, zone, 64, 8)
+__MRT_CLASS(Ljava_2Ftime_2FPeriod_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FPeriod_3B, days, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FPeriod_3B, months, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FPeriod_3B, years, 20, 4)
+__MRT_CLASS(Ljava_2Ftime_2FLocalDate_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FLocalDate_3B, day, 12, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FLocalDate_3B, month, 14, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FLocalDate_3B, year, 16, 4)
+__MRT_CLASS(Ljava_2Ftime_2FLocalDateTime_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FLocalDateTime_3B, date, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FLocalDateTime_3B, time, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2FOffsetDateTime_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FOffsetDateTime_3B, dateTime, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FOffsetDateTime_3B, offset, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2FZonedDateTime_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FZonedDateTime_3B, dateTime, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FZonedDateTime_3B, offset, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FZonedDateTime_3B, zone, 32, 8)
+__MRT_CLASS(Ljava_2Ftime_2FOffsetTime_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FOffsetTime_3B, offset, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FOffsetTime_3B, time, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FIsoChronology_3B, 12, Ljava_2Ftime_2Fchrono_2FAbstractChronology_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FIsoEra_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FAbstractChronology_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, 104, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, baseCount, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, cellsBusy, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, counterCells, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, entrySet, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, keySet, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, nextTable, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, sizeCtl, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, table, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, transferIndex, 88, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_3B, values, 96, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24CounterCell_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24CounterCell_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24EntrySetView_3B, 24, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24CollectionView_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24CollectionView_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24CollectionView_3B, map, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24KeySetView_3B, 32, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24CollectionView_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24KeySetView_3B, value, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Node_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Node_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Node_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Node_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Node_3B, val, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ValuesView_3B, 24, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24CollectionView_3B)
+__MRT_CLASS(Ljava_2Futil_2FAbstractMap_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_3B, keySet, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_3B, values, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeParseException_3B, 72, Ljava_2Ftime_2FDateTimeException_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeParseException_3B, errorIndex, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeParseException_3B, parsedString, 64, 8)
+__MRT_CLASS(Ljava_2Ftime_2FDateTimeException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2FRuntimeException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Flang_2FBoolean_3B, 13, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FBoolean_3B, value, 12, 1)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FFormatStyle_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_24TimeDefinition_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FZoneOffsetTransition_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransition_3B, offsetAfter, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransition_3B, offsetBefore, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FZoneOffsetTransition_3B, transition, 32, 8)
+__MRT_CLASS(Ljava_2Fio_2FFile_24PathStatus_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fio_2FFileSystem_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FBufferedWriter_3B, 64, Ljava_2Fio_2FWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedWriter_3B, cb, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedWriter_3B, lineSeparator, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedWriter_3B, nChars, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedWriter_3B, nextChar, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedWriter_3B, out, 56, 8)
+__MRT_CLASS(Ljava_2Fnet_2FContentHandler_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FHashtable_3B, 64, Ljava_2Futil_2FDictionary_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_3B, entrySet, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_3B, keySet, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_3B, loadFactor, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_3B, modCount, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_3B, table, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_3B, threshold, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_3B, values, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashtable_24HashtableEntry_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24HashtableEntry_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24HashtableEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24HashtableEntry_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24HashtableEntry_3B, value, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FDictionary_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FProxy_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FProxy_3B, sa, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FProxy_3B, type, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FSocketAddress_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FProxy_24Type_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnet_2FUrlDeserializedState_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FUrlDeserializedState_3B, authority, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FUrlDeserializedState_3B, file, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FUrlDeserializedState_3B, hashCode, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FUrlDeserializedState_3B, host, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FUrlDeserializedState_3B, port, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FUrlDeserializedState_3B, protocol, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FUrlDeserializedState_3B, ref, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2FSecurityManager_3B, 13, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FSecurityManager_3B, inCheck, 12, 1)
+__MRT_CLASS(Ljava_2Fsecurity_2FCodeSigner_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FCodeSigner_3B, myhash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FCodeSigner_3B, signerCertPath, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FCodeSigner_3B, timestamp, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPath_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPath_3B, type, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FTimestamp_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FTimestamp_3B, myhash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FTimestamp_3B, signerCertPath, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FTimestamp_3B, timestamp, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FDate_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FDate_3B, cdate, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FDate_3B, fastTime, 24, 8)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B, 108, Lsun_2Futil_2Fcalendar_2FCalendarDate_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B, cachedFixedDateJan1, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B, cachedFixedDateNextJan1, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B, cachedYear, 104, 4)
+__MRT_CLASS(Ljava_2Futil_2FTimeZone_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimeZone_3B, ID, 16, 8)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, dayOfMonth, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, dayOfWeek, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, daylightSaving, 20, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, era, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, forceStandardTime, 32, 1)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, fraction, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, hours, 36, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, leapYear, 33, 1)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, locale, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, millis, 56, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, minutes, 60, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, month, 64, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, normalized, 34, 1)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, seconds, 68, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, year, 72, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, zoneOffset, 76, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FCalendarDate_3B, zoneinfo, 80, 8)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FEra_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FEra_3B, abbr, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FEra_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FEra_3B, localTime, 24, 1)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FEra_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FEra_3B, since, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FEra_3B, sinceDate, 48, 8)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B, 24, Lsun_2Futil_2Fcalendar_2FAbstractCalendar_3B)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FAbstractCalendar_3B, 24, Lsun_2Futil_2Fcalendar_2FCalendarSystem_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FAbstractCalendar_3B, eras, 16, 8)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FCalendarSystem_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FGregorian_3B, 24, Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FGregorian_24Date_3B, 108, Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B)
+__MRT_CLASS(Ljava_2Futil_2FProperties_3B, 72, Ljava_2Futil_2FHashtable_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FProperties_3B, defaults, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FProperties_24LineReader_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FProperties_24LineReader_3B, inByteBuf, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FProperties_24LineReader_3B, inCharBuf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FProperties_24LineReader_3B, inLimit, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FProperties_24LineReader_3B, inOff, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FProperties_24LineReader_3B, inStream, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FProperties_24LineReader_3B, lineBuf, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FProperties_24LineReader_3B, reader, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FProperties_24LineReader_3B, this_240, 64, 8)
+__MRT_CLASS(Ljava_2Fio_2FReader_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FReader_3B, lock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FReader_3B, skipBuffer, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FPrintWriter_3B, 72, Ljava_2Fio_2FWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintWriter_3B, autoFlush, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintWriter_3B, formatter, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintWriter_3B, lineSeparator, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintWriter_3B, out, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintWriter_3B, psOut, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPrintWriter_3B, trouble, 33, 1)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificate_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificate_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificate_3B, type, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FProvider_3B, 144, Ljava_2Futil_2FProperties_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, entrySet, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, entrySetCallCount, 80, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, info, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, initialized, 84, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, legacyChanged, 85, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, legacyMap, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, legacyStrings, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, name, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, registered, 86, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, serviceMap, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, serviceSet, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, servicesChanged, 87, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_3B, version, 136, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDebug_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDebug_3B, prefix, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FProvider_24ServiceKey_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24ServiceKey_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24ServiceKey_3B, originalAlgorithm, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24ServiceKey_3B, type, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FProvider_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FProvider_24Service_3B, 96, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, aliases, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, attributes, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, className, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, classRef, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, hasKeyAttributes, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, provider, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, registered, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, supportedClasses, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, supportedFormats, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24Service_3B, type, 88, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24GetField_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FSerializablePermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljava_2Futil_2FRandom_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_3B, haveNextNextGaussian, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_3B, nextNextGaussian, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_3B, seed, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLong_3B, 24, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLong_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FLongSummaryStatistics_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLongSummaryStatistics_3B, count, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLongSummaryStatistics_3B, max, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLongSummaryStatistics_3B, min, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLongSummaryStatistics_3B, sum, 40, 8)
+__MRT_CLASS(Ljava_2Flang_2FDouble_3B, 24, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDouble_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FDoubleSummaryStatistics_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FDoubleSummaryStatistics_3B, count, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FDoubleSummaryStatistics_3B, max, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FDoubleSummaryStatistics_3B, min, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FDoubleSummaryStatistics_3B, simpleSum, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FDoubleSummaryStatistics_3B, sum, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FDoubleSummaryStatistics_3B, sumCompensation, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FOptionalInt_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FOptionalInt_3B, isPresent, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FOptionalInt_3B, value, 16, 4)
+__MRT_CLASS(Ljava_2Flang_2FInteger_3B, 16, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FInteger_3B, value, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2FIntSummaryStatistics_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIntSummaryStatistics_3B, count, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIntSummaryStatistics_3B, max, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIntSummaryStatistics_3B, min, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIntSummaryStatistics_3B, sum, 32, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FExecutable_3B, 56, Ljava_2Flang_2Freflect_2FAccessibleObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_3B, accessFlags, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_3B, artMethod, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_3B, declaringClass, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_3B, declaringClassOfOverriddenMethod, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_3B, dexMethodIndex, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_3B, hasRealParameterData, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_3B, parameters, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FParameter_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FParameter_3B, executable, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FParameter_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FParameter_3B, modifiers, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FParameter_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FParameter_3B, parameterClassCache, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FParameter_3B, parameterTypeCache, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FMethod_3B, 56, Ljava_2Flang_2Freflect_2FExecutable_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FExecutable_24GenericInfo_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_24GenericInfo_3B, formalTypeParameters, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_24GenericInfo_3B, genericExceptionTypes, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_24GenericInfo_3B, genericParameterTypes, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FExecutable_24GenericInfo_3B, genericReturnType, 40, 8)
+__MRT_CLASS(Llibcore_2Freflect_2FListOfTypes_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FListOfTypes_3B, resolvedTypes, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FListOfTypes_3B, types, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_24ClassDataSlot_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24ClassDataSlot_3B, desc, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24ClassDataSlot_3B, hasData, 12, 1)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_24ExceptionInfo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24ExceptionInfo_3B, className, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24ExceptionInfo_3B, message, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FInvalidClassException_3B, 64, Ljava_2Fio_2FObjectStreamException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FInvalidClassException_3B, classname, 56, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_24FieldReflector_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflector_3B, fields, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflector_3B, numPrimFields, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflector_3B, offsets, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflector_3B, readKeys, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflector_3B, typeCodes, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflector_3B, types, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflector_3B, writeKeys, 56, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectOutputStream_24PutFieldImpl_3B, 48, Ljava_2Fio_2FObjectOutputStream_24PutField_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24PutFieldImpl_3B, desc, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24PutFieldImpl_3B, objVals, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24PutFieldImpl_3B, primVals, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24PutFieldImpl_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectOutputStream_24PutField_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectOutputStream_24DebugTraceInfoStack_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24DebugTraceInfoStack_3B, stack, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectOutputStream_24HandleTable_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24HandleTable_3B, loadFactor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24HandleTable_3B, next, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24HandleTable_3B, objs, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24HandleTable_3B, size, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24HandleTable_3B, spine, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24HandleTable_3B, threshold, 36, 4)
+__MRT_CLASS(Ljava_2Fio_2FObjectOutputStream_24ReplaceTable_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24ReplaceTable_3B, htab, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_24ReplaceTable_3B, reps, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24TreeNode_3B, 96, Ljava_2Futil_2FLinkedHashMap_24LinkedHashMapEntry_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24TreeNode_3B, left, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24TreeNode_3B, parent, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24TreeNode_3B, prev, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24TreeNode_3B, red, 80, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24TreeNode_3B, right, 88, 8)
+__MRT_CLASS(Ljava_2Flang_2FPackage_3B, 96, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, implTitle, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, implVendor, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, implVersion, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, loader, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, packageInfo, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, pkgName, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, sealBase, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, specTitle, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, specVendor, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_3B, specVersion, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FManifest_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FManifest_3B, attr, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FManifest_3B, entries, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FAttributes_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FAttributes_3B, map, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FAttributes_24Name_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FAttributes_24Name_3B, hashCode, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FAttributes_24Name_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FManifest_24FastInputStream_3B, 40, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FManifest_24FastInputStream_3B, buf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FManifest_24FastInputStream_3B, count, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FManifest_24FastInputStream_3B, pos, 36, 4)
+__MRT_CLASS(Ljava_2Flang_2FPackage_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_241_3B, val_24fn, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_241_3B, val_24iname, 24, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FClassExt_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FClassExt_3B, obsoleteDexCaches, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FClassExt_3B, obsoleteMethods, 24, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FClassExt_3B, originalDexFile, 32, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FClassExt_3B, preRedefineClassDefIndex, 12, 4)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FClassExt_3B, preRedefineDexFilePtr, 40, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FClassExt_3B, verifyError, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FAssert_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FBMPSet_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FBMPSet_3B, bmpBlockBits, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FBMPSet_3B, latin1Contains, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FBMPSet_3B, list, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FBMPSet_3B, list4kStarts, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FBMPSet_3B, listLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FBMPSet_3B, table7FF, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24SpanCondition_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FOutputInt_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FOutputInt_3B, value, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCacheBase_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCacheValue_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCacheValue_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCacheValue_24Strength_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24Equatorial_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24Equatorial_3B, ascension, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24Equatorial_3B, declination, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24Ecliptic_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24Ecliptic_3B, latitude, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24Ecliptic_3B, longitude, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24Horizon_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24Horizon_3B, altitude, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24Horizon_3B, azimuth, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24MoonAge_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24MoonAge_3B, value, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24SolarLongitude_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_24SolarLongitude_3B, value, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, 128, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, eclipObliquity, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, fGmtOffset, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, fLatitude, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, fLongitude, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, julianCentury, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, julianDay, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, meanAnomalySun, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, moonEclipLong, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, moonLongitude, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, moonPosition, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, siderealT0, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, siderealTime, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, sunLongitude, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_3B, time, 120, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarCache_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarCache_3B, arraySize, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarCache_3B, keys, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarCache_3B, pIndex, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarCache_3B, size, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarCache_3B, threshold, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarCache_3B, values, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FULocale_3B, baseLocale, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FULocale_3B, extensions, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FULocale_3B, locale, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FULocale_3B, localeID, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_3B, __hash, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_3B, __language, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_3B, __region, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_3B, __script, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_3B, __variant, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_24Cache_3B, 32, Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleObjectCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_24Key_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_24Key_3B, __hash, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_24Key_3B, __lang, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_24Key_3B, __regn, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_24Key_3B, __scrt, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_24Key_3B, __vart, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleObjectCache_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleObjectCache_3B, __map, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleObjectCache_3B, __queue, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FBaseLocale_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleExtensions_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleExtensions_3B, __id, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleExtensions_3B, __map, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FExtension_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FExtension_3B, __key, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FExtension_3B, __value, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_24Type_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_241_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FSoftCache_3B, 24, Landroid_2Ficu_2Fimpl_2FCacheBase_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FSoftCache_3B, map, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_24Category_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_24Minimize_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24GreekUpper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEdits_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_3B, delta, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_3B, length, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_3B, numChanges, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, 60, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, changed, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, coarse, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, destIndex, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, dir, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, index, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, length, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, newLength__, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, oldLength__, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, onlyChanges__, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, remaining, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, replIndex, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEdits_24Iterator_3B, srcIndex, 56, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEdits_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2__16_3B, 76, Landroid_2Ficu_2Fimpl_2FTrie2_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2_3B, 76, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, data16, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, data32, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, dataLength, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, dataNullOffset, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, errorValue, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, fHash, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, header, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, highStart, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, highValueIndex, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, index, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, index2NullOffset, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, indexLength, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_3B, initialValue, 72, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2_24UTrie2Header_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24UTrie2Header_3B, dataNullOffset, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24UTrie2Header_3B, index2NullOffset, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24UTrie2Header_3B, indexLength, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24UTrie2Header_3B, options, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24UTrie2Header_3B, shiftedDataLength, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24UTrie2Header_3B, shiftedHighStart, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24UTrie2Header_3B, signature, 36, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceIterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceIterator_3B, fResults, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceIterator_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceIterator_3B, text, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceIterator_3B, textLength, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceValues_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceValues_3B, codePoint, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceValues_3B, index, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24CharSequenceValues_3B, value, 20, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBreakIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakIterator_3B, actualLocale, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakIterator_3B, validLocale, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBreakIterator_24BreakIteratorServiceShim_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24StringContextIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24StringContextIterator_3B, cpLimit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24StringContextIterator_3B, cpStart, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24StringContextIterator_3B, dir, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24StringContextIterator_3B, index, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24StringContextIterator_3B, limit, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24StringContextIterator_3B, s, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCharacterIteration_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCharacterPropertiesImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B, 72, Landroid_2Ficu_2Ftext_2FUnicodeFilter_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B, bmpSet, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B, buffer, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B, len, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B, list, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B, pat, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B, rangeList, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B, stringSpan, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_3B, strings, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_3B, all, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_3B, maxLength16, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_3B, offsets, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_3B, someRelevant, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_3B, spanLengths, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_3B, spanNotSet, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_3B, spanSet, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_3B, strings, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_24OffsetList_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_24OffsetList_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_24OffsetList_3B, list, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeSetStringSpan_24OffsetList_3B, start, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FVersionInfo_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FVersionInfo_3B, m__version__, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24XSymbolTable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRuleCharacterIterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRuleCharacterIterator_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRuleCharacterIterator_3B, bufPos, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRuleCharacterIterator_3B, isEscaped, 24, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRuleCharacterIterator_3B, pos, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRuleCharacterIterator_3B, sym, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRuleCharacterIterator_3B, text, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24ComparisonStyle_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeFilter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FClassLoaderUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencyDisplayInfo_3B, 12, Landroid_2Ficu_2Ftext_2FCurrencyDisplayNames_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencyFormatInfo_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencyFormatInfo_3B, currencyPattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencyFormatInfo_3B, isoCode, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencyFormatInfo_3B, monetaryDecimalSeparator, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencyFormatInfo_3B, monetaryGroupingSeparator, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_3B, hasAfterCurrency, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_3B, hasBeforeCurrency, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_3B, symbols, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_24SpacingType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencySpacingInfo_24SpacingPattern_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCurrencyDisplayNames_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCurrencyData_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesData_3B, localesToRuleSetNumMap, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesData_3B, maxRuleSetNum, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesData_3B, rules, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_3B, dayPeriodForHour, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_3B, hasMidnight, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_3B, hasNoon, 13, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriod_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FEraRules_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FEraRules_3B, currentEra, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FEraRules_3B, numEras, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FEraRules_3B, startDates, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalType_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalType_3B, id, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FGrego_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUBinary_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUBinary_24DatPackageReader_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUBinary_24DatPackageReader_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUBinary_24DataFile_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUBinary_24DataFile_3B, itemPath, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUBinary_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUConfig_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24FormattingData_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24FormattingData_3B, displayName, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24FormattingData_3B, formatInfo, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24FormattingData_3B, isoCode, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24FormattingData_3B, symbol, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24NarrowSymbol_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24NarrowSymbol_3B, isoCode, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24NarrowSymbol_3B, narrowSymbol, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24ParsingData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24ParsingData_3B, nameToIsoCode, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24ParsingData_3B, symbolToIsoCode, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_24UniqueList_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_24UniqueList_3B, list, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_24UniqueList_3B, seen, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUData_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogger_3B, 120, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, anonymous, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, callersClassLoaderRef, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, catalog, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, catalogLocale, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, catalogName, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, filter, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, handlers, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, isSystemLogger, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, kids, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, levelObject, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, levelValue, 80, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, loggerBundle, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, manager, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, name, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, parent, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_3B, useParentHandlers, 14, 1)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_3B, cacheKey, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_3B, expired, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_3B, keySet, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_3B, locale, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_3B, name, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_3B, parent, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24CacheKey_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24CacheKey_3B, cause, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24CacheKey_3B, expirationTime, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24CacheKey_3B, format, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24CacheKey_3B, hashCodeCache, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24CacheKey_3B, loadTime, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24CacheKey_3B, loaderRef, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24CacheKey_3B, locale, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24CacheKey_3B, name, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24LoaderReference_3B, 56, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24LoaderReference_3B, cacheKey, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24Control_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24Control_24CandidateListCache_3B, 32, Lsun_2Futil_2Flocale_2FLocaleObjectCache_3B)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_241_3B, 56, Ljava_2Futil_2FResourceBundle_3B)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogRecord_3B, 112, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, level, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, loggerName, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, message, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, millis, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, needToInferCaller, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, parameters, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, resourceBundle, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, resourceBundleName, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, sequenceNumber, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, sourceClassName, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, sourceMethodName, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, threadID, 96, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogRecord_3B, thrown, 104, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLevel_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLevel_3B, cachedLocale, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLevel_3B, localizedLevelName, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLevel_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLevel_3B, resourceBundleName, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLevel_3B, value, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLevel_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_3B, lock, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogger_24LoggerBundle_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_24LoggerBundle_3B, resourceBundleName, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_24LoggerBundle_3B, userBundle, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogger_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_241_3B, val_24locale, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, contextsMap, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, controlPermission, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, deathImminent, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, initializationDone, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, initializedCalled, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, initializedGlobalHandlers, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, listenerMap, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, loggerRefQueue, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, props, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, readPrimordialConfiguration, 56, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, rootLogger, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, systemContext, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_3B, userContext, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_3B, 72, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_3B, entrySet, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_3B, loadFactor, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_3B, modCount, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_3B, queue, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_3B, size, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_3B, table, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_3B, threshold, 60, 4)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24Entry_3B, 72, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24Entry_3B, hash, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24Entry_3B, next, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24Entry_3B, value, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_3B, namedLoggers, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_3B, root, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_24LogNode_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LogNode_3B, children, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LogNode_3B, context, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LogNode_3B, loggerRef, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LogNode_3B, parent, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_24LoggerWeakRef_3B, 88, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerWeakRef_3B, disposed, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerWeakRef_3B, name, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerWeakRef_3B, node, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerWeakRef_3B, parentRef, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerWeakRef_3B, this_240, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fbeans_2FPropertyChangeEvent_3B, 56, Ljava_2Futil_2FEventObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fbeans_2FPropertyChangeEvent_3B, newValue, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fbeans_2FPropertyChangeEvent_3B, oldValue, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fbeans_2FPropertyChangeEvent_3B, propagationId, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fbeans_2FPropertyChangeEvent_3B, propertyName, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FEventObject_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEventObject_3B, source, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FFormatter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FHandler_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FHandler_3B, encoding, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FHandler_3B, errorManager, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FHandler_3B, filter, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FHandler_3B, formatter, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FHandler_3B, logLevel, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FHandler_3B, manager, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FHandler_3B, sealed, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FErrorManager_3B, 13, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FErrorManager_3B, reported, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUDataVersion_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUDebug_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUNotifier_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUNotifier_3B, listeners, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUNotifier_3B, notifyLock, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUNotifier_3B, notifyThread, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUNotifier_24NotifyThread_3B, 192, Ljava_2Flang_2FThread_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUNotifier_24NotifyThread_3B, notifier, 176, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUNotifier_24NotifyThread_3B, queue, 184, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICURWLock_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICURWLock_24Stats_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICURWLock_24Stats_3B, __mrc, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICURWLock_24Stats_3B, __rc, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICURWLock_24Stats_3B, __wc, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICURWLock_24Stats_3B, __wrc, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICURWLock_24Stats_3B, __wwc, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICURWLock_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICURWLock_3B, rwl, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICURWLock_3B, stats, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_3B, readerLock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_3B, sync, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_3B, writerLock, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24ReadLock_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24ReadLock_3B, sync, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_3B, 80, Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_3B, cachedHoldCounter, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_3B, firstReader, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_3B, firstReaderHoldCount, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_3B, readHolds, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_24HoldCounter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_24HoldCounter_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_24HoldCounter_3B, tid, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_24ThreadLocalHoldCounter_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Ljava_2Flang_2FIllegalMonitorStateException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24ConditionObject_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24ConditionObject_3B, firstWaiter, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24ConditionObject_3B, lastWaiter, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24ConditionObject_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24Node_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24Node_3B, next, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24Node_3B, nextWaiter, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24Node_3B, prev, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24Node_3B, thread, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_24Node_3B, waitStatus, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B, 48, Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractOwnableSynchronizer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B, head, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B, state, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B, tail, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractOwnableSynchronizer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractOwnableSynchronizer_3B, exclusiveOwnerThread, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24WriteLock_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24WriteLock_3B, sync, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24AvailEntry_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24AvailEntry_3B, fullNameSet, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24AvailEntry_3B, loader, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24AvailEntry_3B, locales, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24AvailEntry_3B, nameSet, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24AvailEntry_3B, prefix, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24AvailEntry_3B, ulocales, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24Loader_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_241_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_3B, 80, Landroid_2Ficu_2Futil_2FUResourceBundle_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_3B, container, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_3B, key, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_3B, wholeBundle, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24WholeBundle_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24WholeBundle_3B, baseName, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24WholeBundle_3B, loader, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24WholeBundle_3B, localeID, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24WholeBundle_3B, reader, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24WholeBundle_3B, topLevelKeys, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24WholeBundle_3B, ulocale, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, b16BitUnits, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, bytes, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, dataVersion, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, isPoolBundle, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, keyBytes, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, localKeyLimit, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, noFallback, 33, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, poolBundleReader, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, poolCheckSum, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, poolStringIndex16Limit, 60, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, poolStringIndexLimit, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, resourceCache, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, rootRes, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_3B, usesPoolBundle, 34, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_3B, keys, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_3B, levelBitsList, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_3B, maxOffsetBits, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_3B, rootLevel, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_3B, values, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_24Level_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_24Level_3B, keys, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_24Level_3B, levelBitsList, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_24Level_3B, mask, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_24Level_3B, shift, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ResourceCache_24Level_3B, values, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ReaderCache_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ReaderCacheKey_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ReaderCacheKey_3B, baseName, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ReaderCacheKey_3B, localeID, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Array_3B, 20, Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Container_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUResource_24Value_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUResource_24Key_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUResource_24Key_3B, bytes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUResource_24Key_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUResource_24Key_3B, offset, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUResource_24Key_3B, s, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Container_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Container_3B, itemsOffset, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Container_3B, size, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Table_3B, 40, Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Container_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Table_3B, key32Offsets, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Table_3B, keyOffsets, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24OpenType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FUResourceBundle_3B, 56, Ljava_2Futil_2FResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FUResourceBundle_24RootType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FUResourceBundleIterator_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUResourceBundleIterator_3B, bundle, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUResourceBundleIterator_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUResourceBundleIterator_3B, size, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ReaderValue_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Value_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ReaderValue_3B, reader, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24ReaderValue_3B, res, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceTableAccess_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUService_24CacheEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_24CacheEntry_3B, actualDescriptor, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_24CacheEntry_3B, service, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUService_24Key_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_24Key_3B, id, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUService_3B, 96, Landroid_2Ficu_2Fimpl_2FICUNotifier_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_3B, cache, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_3B, defaultSize, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_3B, dnref, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_3B, factories, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_3B, factoryLock, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_3B, idcache, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_3B, name, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUService_24LocaleRef_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_24LocaleRef_3B, com, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_24LocaleRef_3B, dnCache, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_24LocaleRef_3B, locale, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FIDNA2003_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringPrep_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_3B, bdp, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_3B, checkBiDi, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_3B, doNFKC, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_3B, indexes, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_3B, mappingData, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_3B, normCorrVer, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_3B, sprepTrie, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_3B, sprepUniVer, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUBiDiProps_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUBiDiProps_3B, indexes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUBiDiProps_3B, jgArray, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUBiDiProps_3B, jgArray2, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUBiDiProps_3B, mirrors, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUBiDiProps_3B, trie, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCharTrie_3B, 56, Landroid_2Ficu_2Fimpl_2FTrie_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCharTrie_3B, m__data__, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCharTrie_3B, m__initialValue__, 44, 2)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie_3B, m__dataLength__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie_3B, m__dataManipulate__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie_3B, m__dataOffset__, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie_3B, m__index__, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie_3B, m__isLatin1Linear__, 28, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie_3B, m__options__, 40, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringPrep_24Values_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_24Values_3B, isIndex, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_24Values_3B, type, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrep_24Values_3B, value, 20, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringPrep_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUCharacterIterator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24Cache_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24Cache_3B, cache, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24Cache_3B, capitalization, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24Cache_3B, dialectHandling, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24Cache_3B, locale, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24Cache_3B, nameLength, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24Cache_3B, substituteHandling, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24DialectHandling_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDisplayContext_3B, 36, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDisplayContext_3B, type, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDisplayContext_3B, value, 32, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDisplayContext_24Type_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24DataTable_3B, 13, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24DataTable_3B, nullIfNotFound, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24DataTables_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24LangDataTables_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24RegionDataTables_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_3B, baseName, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_3B, buffer, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_3B, canonicalize, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_3B, hadCountry, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_3B, id, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_3B, index, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_3B, keywords, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleIDs_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleUtility_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24NFCSingleton_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24Norm2AllModesSingleton_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24Norm2AllModesSingleton_3B, allModes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24Norm2AllModesSingleton_3B, exception, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_3B, comp, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_3B, decomp, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_3B, fcc, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_3B, fcd, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_3B, impl, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24ComposeNormalizer2_3B, 25, Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24Normalizer2WithImpl_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24ComposeNormalizer2_3B, onlyContiguous, 24, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, 120, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, canonIterData, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, canonStartSets, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, centerNoNoDelta, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, dataVersion, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, extraData, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, limitNoNo, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, maybeYesCompositions, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minCompNoMaybeCP, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minDecompNoCP, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minLcccCP, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minMaybeYes, 72, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minNoNo, 76, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minNoNoCompBoundaryBefore, 80, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minNoNoCompNoMaybeCC, 84, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minNoNoEmpty, 88, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minYesNo, 92, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, minYesNoMappingsOnly, 96, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, normTrie, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_3B, smallFCD, 112, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_3B, 56, Landroid_2Ficu_2Futil_2FCodePointMap_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_3B, ascii, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_3B, data, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_3B, dataLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_3B, dataNullOffset, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_3B, highStart, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_3B, index, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_3B, index3NullOffset, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_3B, nullValue, 52, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Data_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24ValueWidth_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Type_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointMap_24Range_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24Range_3B, end, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24Range_3B, start, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24Range_3B, value, 20, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointMap_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointMap_24RangeOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointMap_24StringIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24StringIterator_3B, c, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24StringIterator_3B, s, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24StringIterator_3B, sIndex, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24StringIterator_3B, this_240, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24StringIterator_3B, value, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast16_3B, 64, Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast16_3B, dataArray, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast_3B, 56, Landroid_2Ficu_2Futil_2FCodePointTrie_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, 76, Landroid_2Ficu_2Futil_2FCodePointMap_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, dataLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, dataNullOffset, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, errorValue, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, flags, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, highStart, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, highValue, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, index, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, index16, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, index3NullOffset, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, initialValue, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_3B, origInitialValue, 72, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24MixedBlocks_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24MixedBlocks_3B, blockLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24MixedBlocks_3B, length, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24MixedBlocks_3B, mask, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24MixedBlocks_3B, shift, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24MixedBlocks_3B, table, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24AllSameBlocks_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24AllSameBlocks_3B, indexes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24AllSameBlocks_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24AllSameBlocks_3B, mostRecent, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24AllSameBlocks_3B, refCounts, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMutableCodePointTrie_24AllSameBlocks_3B, values, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24ReorderingBuffer_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24ReorderingBuffer_3B, app, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24ReorderingBuffer_3B, appIsStringBuilder, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24ReorderingBuffer_3B, codePointLimit, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24ReorderingBuffer_3B, codePointStart, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24ReorderingBuffer_3B, impl, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24ReorderingBuffer_3B, lastCC, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24ReorderingBuffer_3B, reorderStart, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24ReorderingBuffer_3B, str, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24QuickCheckResult_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24Normalizer2WithImpl_3B, 24, Landroid_2Ficu_2Ftext_2FNormalizer2_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24Normalizer2WithImpl_3B, impl, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer2_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer2_24Mode_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24DecomposeNormalizer2_3B, 24, Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24Normalizer2WithImpl_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24FCDNormalizer2_3B, 24, Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24Normalizer2WithImpl_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24NoopNormalizer2_3B, 12, Landroid_2Ficu_2Ftext_2FNormalizer2_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_241_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24NFKCSingleton_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNorm2AllModes_24NFKC__CFSingleton_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24Hangul_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FNormalizer2Impl_24UTF16Plus_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPair_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPair_3B, first, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPair_3B, second, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPatternProps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, escapeCharacters, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, extraQuotingCharacters, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, ignorableCharacters, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, limit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, needingQuoteCharacters, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, pattern, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, start, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, syntaxCharacters, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, usingQuote, 60, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPatternTokenizer_3B, usingSlash, 61, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPropsVectors_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPropsVectors_3B, columns, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPropsVectors_3B, isCompacted, 16, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPropsVectors_3B, maxRows, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPropsVectors_3B, prevRow, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPropsVectors_3B, rows, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPropsVectors_3B, v, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FIntTrie_3B, 56, Landroid_2Ficu_2Fimpl_2FTrie_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FIntTrie_3B, m__data__, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FIntTrie_3B, m__initialValue__, 44, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPunycode_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fCatCount, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fFTable, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fFTableLen, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fFormatVersion, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fLength, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fMagic, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fRTable, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fRTableLen, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fRuleSource, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fRuleSourceLen, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fStatusTable, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fStatusTableLen, 60, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fTrie, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIDataHeader_3B, fTrieLen, 68, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIStateTable_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIStateTable_3B, fFlags, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIStateTable_3B, fNumStates, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIStateTable_3B, fReserved, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIStateTable_3B, fRowLen, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24RBBIStateTable_3B, fTable, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_3B, fFTable, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_3B, fHeader, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_3B, fRTable, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_3B, fRuleSource, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_3B, fStatusTable, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_3B, fTrie, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRBBIDataWrapper_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_24URelativeString_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_24URelativeString_3B, offset, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_24URelativeString_3B, string, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_24Loader_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_241_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_3B, 88, Landroid_2Ficu_2Futil_2FUResourceBundle_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_3B, baseName, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_3B, bundle, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_3B, keys, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_3B, localeID, 80, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FSimpleFormatterImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FSortedSetRelation_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStaticUnicodeSets_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStaticUnicodeSets_24Key_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStringRange_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FLinkedList_3B, 36, Ljava_2Futil_2FAbstractSequentialList_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_3B, first, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_3B, last, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_3B, size, 32, 4)
+__MRT_CLASS(Ljava_2Futil_2FLinkedList_24Node_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24Node_3B, item, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24Node_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24Node_3B, prev, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FAbstractSequentialList_3B, 16, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNameInfo_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNameInfo_3B, ambiguousType, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNameInfo_3B, mzID, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNameInfo_3B, parseRegions, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNameInfo_3B, type, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24NameType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNames_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNames_3B, __names, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNames_3B, __parseRegions, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTextTrieMap_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24Node_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24Node_3B, __children, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24Node_3B, __text, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24Node_3B, __values, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24Node_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTextTrieMap_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_3B, __ignoreCase, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_3B, __root, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24CharIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24CharIterator_3B, __ignoreCase, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24CharIterator_3B, __nextIdx, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24CharIterator_3B, __remainingChar, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24CharIterator_3B, __startIdx, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24CharIterator_3B, __text, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24Output_3B, 17, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24Output_3B, matchLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24Output_3B, partialMatch, 16, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericMatchInfo_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericMatchInfo_3B, matchLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericMatchInfo_3B, nameType, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericMatchInfo_3B, timeType, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericMatchInfo_3B, tzID, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericNameType_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericNameType_3B, __fallbackTypeOf, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24TimeType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24NameInfo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24NameInfo_3B, type, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24NameInfo_3B, tzID, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24MZMapEntry_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24MZMapEntry_3B, __from, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24MZMapEntry_3B, __mzID, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24MZMapEntry_3B, __to, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24NameInfo_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24NameInfo_3B, mzID, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24NameInfo_3B, type, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24NameInfo_3B, tzID, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZNames_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZNames_3B, __names, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZNames_3B, didAddIntoTrie, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2_24Range_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Range_3B, endCodePoint, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Range_3B, leadSurrogate, 16, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Range_3B, startCodePoint, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Range_3B, value, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2Writable_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrieBuilder_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieBuilder_3B, m__dataCapacity__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieBuilder_3B, m__dataLength__, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieBuilder_3B, m__indexLength__, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieBuilder_3B, m__index__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieBuilder_3B, m__isCompacted__, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieBuilder_3B, m__isLatin1Linear__, 33, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieBuilder_3B, m__map__, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUBiDiProps_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCaseProps_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCaseProps_24LatinCase_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCaseProps_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCaseProps_3B, exceptions, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCaseProps_3B, indexes, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCaseProps_3B, trie, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCaseProps_3B, unfold, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, m__factor__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, m__factorstring__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, m__prefix__, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, m__rangeend__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, m__rangestart__, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, m__type__, 44, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, m__utilIntBuffer__, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, m__utilStringBuffer__, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_24AlgorithmName_3B, m__variant__, 45, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, 120, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__ISOCommentSet__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__algorithm__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__groupcount__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__groupinfo__, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__grouplengths__, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__groupoffsets__, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__groupsize__, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__groupstring__, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__maxISOCommentLength__, 60, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__maxNameLength__, 72, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__nameSet__, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__tokenstring__, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__tokentable__, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__utilIntBuffer__, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterName_3B, m__utilStringBuffer__, 112, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B, column, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B, mask, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B, this_240, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, binProps, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, intProps, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, m__additionalColumnsCount__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, m__additionalTrie__, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, m__additionalVectors__, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, m__maxBlockScriptValue__, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, m__maxJTGValue__, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, m__scriptExtensions__, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, m__trie__, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_3B, m__unicodeVersion__, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B, column, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B, mask, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B, shift, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B, this_240, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24InPCTrie_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24InSCTrie_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24VoTrie_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterUtility_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUPropertyAliases_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUPropertyAliases_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUPropertyAliases_3B, bytesTries, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUPropertyAliases_3B, nameGroups, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUPropertyAliases_3B, valueMaps, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUPropertyAliases_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBytesTrie_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_3B, bytes__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_3B, pos__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_3B, remainingMatchLength__, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_3B, root__, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBytesTrie_24Result_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBytesTrie_24Iterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Iterator_3B, bytes__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Iterator_3B, entry__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Iterator_3B, initialPos__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Iterator_3B, initialRemainingMatchLength__, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Iterator_3B, maxLength__, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Iterator_3B, pos__, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Iterator_3B, remainingMatchLength__, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Iterator_3B, stack__, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBytesTrie_24Entry_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Entry_3B, bytes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Entry_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24Entry_3B, value, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBytesTrie_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBytesTrie_24State_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24State_3B, bytes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24State_3B, pos, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24State_3B, remainingMatchLength, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrie_24State_3B, root, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FURLHandler_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUResource_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUSerializedSet_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUSerializedSet_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUSerializedSet_3B, arrayOffset, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUSerializedSet_3B, bmpLength, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUSerializedSet_3B, length, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUtility_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUtilityExtensions_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliterator_24Position_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterator_24Position_3B, contextLimit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterator_24Position_3B, contextStart, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterator_24Position_3B, limit, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterator_24Position_3B, start, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FReplaceableString_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableString_3B, buf, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FValidIdentifiers_24ValidityData_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FValidIdentifiers_24ValiditySet_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FValidIdentifiers_24ValiditySet_3B, regularData, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FValidIdentifiers_24ValiditySet_3B, subdivisionData, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FValidIdentifiers_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FValidIdentifiers_24Datasubtype_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FValidIdentifiers_24Datatype_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FZoneMeta_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FZoneMeta_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FZoneMeta_24CustomTimeZoneCache_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, 128, Landroid_2Ficu_2Futil_2FBasicTimeZone_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, dst, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, dstRule, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, endDay, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, endDayOfWeek, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, endMode, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, endMonth, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, endTime, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, endTimeMode, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, firstTransition, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, initialRule, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, isFrozen, 60, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, raw, 80, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, startDay, 84, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, startDayOfWeek, 88, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, startMode, 92, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, startMonth, 96, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, startTime, 100, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, startTimeMode, 104, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, startYear, 108, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, stdRule, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, transitionRulesInitialized, 61, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, useDaylight, 62, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleTimeZone_3B, xinfo, 120, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FAnnualTimeZoneRule_3B, 44, Landroid_2Ficu_2Futil_2FTimeZoneRule_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FAnnualTimeZoneRule_3B, dateTimeRule, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FAnnualTimeZoneRule_3B, endYear, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FAnnualTimeZoneRule_3B, startYear, 40, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FDateTimeRule_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FDateTimeRule_3B, dateRuleType, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FDateTimeRule_3B, dayOfMonth, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FDateTimeRule_3B, dayOfWeek, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FDateTimeRule_3B, millisInDay, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FDateTimeRule_3B, month, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FDateTimeRule_3B, timeRuleType, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FDateTimeRule_3B, weekInMonth, 36, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTimeZoneRule_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeZoneRule_3B, dstSavings, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeZoneRule_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeZoneRule_3B, rawOffset, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTimeZoneTransition_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeZoneTransition_3B, from, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeZoneTransition_3B, time, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeZoneTransition_3B, to, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FInitialTimeZoneRule_3B, 28, Landroid_2Ficu_2Futil_2FTimeZoneRule_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FSTZInfo_3B, 60, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, ea, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, edm, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, edw, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, edwm, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, em, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, et, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, sa, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, sdm, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, sdw, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, sdwm, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, sm, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, st, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSTZInfo_3B, sy, 56, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTimeZone_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeZone_3B, ID, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTimeZone_24SystemTimeZoneType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBasicTimeZone_3B, 24, Landroid_2Ficu_2Futil_2FTimeZone_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FZoneMeta_24SystemTimeZoneCache_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, 136, Landroid_2Ficu_2Futil_2FBasicTimeZone_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, canonicalID, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, finalStartMillis, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, finalStartYear, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, finalZone, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, finalZoneWithStartYear, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, firstFinalTZTransition, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, firstTZTransition, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, firstTZTransitionIdx, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, historicRules, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, initialRule, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, isFrozen, 96, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, serialVersionOnStream, 100, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, transitionCount, 104, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, transitionRulesInitialized, 97, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, transitionTimes64, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, typeCount, 108, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, typeMapData, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FOlsonTimeZone_3B, typeOffsets, 128, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTimeArrayTimeZoneRule_3B, 40, Landroid_2Ficu_2Futil_2FTimeZoneRule_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeArrayTimeZoneRule_3B, startTimes, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeArrayTimeZoneRule_3B, timeType, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FOutput_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FOutput_3B, value, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FBOCSU_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FByteArrayWrapper_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FByteArrayWrapper_3B, bytes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FByteArrayWrapper_3B, size, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollation_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationCompare_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B, ceBuffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B, cesIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B, data, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B, isNumeric, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B, numCpFwd, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B, skipped, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B, trie, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_24CEBuffer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_24CEBuffer_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_24CEBuffer_3B, length, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, 136, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, base, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, ce32s, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, ces, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, compressibleBytes, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, contexts, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, fastLatinTable, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, fastLatinTableHeader, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, jamoCE32s, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, nfcImpl, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, numScripts, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, numericPrimary, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, rootElements, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, scriptStarts, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, scriptsIndex, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, trie, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationData_3B, unsafeBackwardSet, 128, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2__32_3B, 76, Landroid_2Ficu_2Fimpl_2FTrie2_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FUVector32_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FUVector32_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FUVector32_3B, length, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_24SkippedState_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_24SkippedState_3B, newBuffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_24SkippedState_3B, oldBuffer, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_24SkippedState_3B, pos, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_24SkippedState_3B, skipLengthAtMatch, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_24SkippedState_3B, state, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCharsTrie_24State_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24State_3B, chars, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24State_3B, pos, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24State_3B, remainingMatchLength, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24State_3B, root, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCharsTrie_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_3B, chars__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_3B, pos__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_3B, remainingMatchLength__, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_3B, root__, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, chars__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, entry__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, initialPos__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, initialRemainingMatchLength__, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, maxLength__, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, pos__, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, remainingMatchLength__, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, skipValue__, 48, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, stack__, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Iterator_3B, str__, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCharsTrie_24Entry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Entry_3B, chars, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrie_24Entry_3B, value, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCharsTrie_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B, 80, Landroid_2Ficu_2Fimpl_2Fcoll_2FSharedObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B, fastLatinOptions, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B, fastLatinPrimaries, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B, minHighNoReorder, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B, options, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B, reorderCodes, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B, reorderRanges, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B, reorderTable, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationSettings_3B, variableTop, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FSharedObject_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FSharedObject_3B, refCount, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24ConditionalCE32_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24ConditionalCE32_3B, builtCE32, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24ConditionalCE32_3B, ce32, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24ConditionalCE32_3B, context, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24ConditionalCE32_3B, defaultCE32, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24ConditionalCE32_3B, next, 32, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24CopyHelper_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24CopyHelper_3B, dest, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24CopyHelper_3B, modifiedCEs, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24CopyHelper_3B, modifier, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24CopyHelper_3B, src, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, 112, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, base, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, baseSettings, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, ce32s, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, ce64s, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, collIter, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, conditionalCE32s, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, contextChars, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, contexts, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, fastLatinBuilder, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, fastLatinEnabled, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, modified, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, nfcImpl, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, trie, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_3B, unsafeBackwardSet, 104, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FUVector64_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FUVector64_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FUVector64_3B, length, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24DataBuilderCollationIterator_3B, 96, Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24DataBuilderCollationIterator_3B, builder, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24DataBuilderCollationIterator_3B, builderData, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24DataBuilderCollationIterator_3B, jamoCE32s, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24DataBuilderCollationIterator_3B, pos, 80, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataBuilder_24DataBuilderCollationIterator_3B, s, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, 120, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, ce0, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, ce1, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, charCEs, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, contractionCEs, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, firstDigitPrimary, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, firstLatinPrimary, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, firstShortPrimary, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, headerLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, lastLatinPrimary, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, lastSpecialPrimaries, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, miniCEs, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, result, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, shortPrimaryOverflow, 104, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatinBuilder_3B, uniqueCEs, 112, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, 128, Landroid_2Ficu_2Fimpl_2FTrie2_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, UTRIE2__DEBUG, 76, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, data, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, dataCapacity, 88, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, firstFreeBlock, 92, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, index1, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, index2, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, index2Length, 112, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, index2NullOffset, 116, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, isCompacted, 77, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2Writable_3B, map, 120, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2_24ValueWidth_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCharsTrieBuilder_3B, 80, Landroid_2Ficu_2Futil_2FStringTrieBuilder_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrieBuilder_3B, chars, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrieBuilder_3B, charsLength, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCharsTrieBuilder_3B, intUnits, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24Option_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_3B, lookupFinalValueNode, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_3B, nodes, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_3B, root, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_3B, state, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_3B, strings, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ValueNode_3B, 24, Landroid_2Ficu_2Futil_2FStringTrieBuilder_24Node_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ValueNode_3B, hasValue, 16, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ValueNode_3B, value, 20, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24Node_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24Node_3B, offset, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24State_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataReader_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataReader_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationDataReader_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, actualLocale, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, data, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, maxExpansions, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, ownedData, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, rules, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, rulesResource, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, settings, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, trie, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, unsafeBackwardSet, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationTailoring_3B, version, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FSharedObject_24Reference_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FSharedObject_24Reference_3B, ref, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFCD_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationFastLatin_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationKeys_24LevelCallback_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationKeys_24SortKeyByteSink_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationKeys_24SortKeyByteSink_3B, appended__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationKeys_24SortKeyByteSink_3B, buffer__, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationKeys_24SortKeyLevel_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationKeys_24SortKeyLevel_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationKeys_24SortKeyLevel_3B, len, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationKeys_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationLoader_24ASCII_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationLoader_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRoot_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRootElements_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRootElements_3B, elements, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_24Sink_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, baseData, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, importer, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, nfc, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, nfd, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, rawBuilder, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, ruleIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, rules, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, settings, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_3B, sink, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_24Position_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftext_2FParseException_3B, 60, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FParseException_3B, errorOffset, 56, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_3B, maxBytes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_3B, middleLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_3B, minBytes, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_3B, rangeCount, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_3B, rangeIndex, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_3B, ranges, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_24WeightRange_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_24WeightRange_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_24WeightRange_3B, end, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_24WeightRange_3B, length, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationWeights_24WeightRange_3B, start, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, 96, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, addPrefixes, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, ces, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, checkTailored, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, contractions, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, data, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, expansions, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, ranges, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, sink, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, suffix, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, tailored, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FContractionsAndExpansions_3B, unreversedPrefix, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FTailoredSet_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FTailoredSet_3B, baseData, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FTailoredSet_3B, data, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FTailoredSet_3B, suffix, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FTailoredSet_3B, tailored, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FTailoredSet_3B, unreversedPrefix, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FTokenIterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FTokenIterator_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FTokenIterator_3B, done, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FTokenIterator_3B, lastpos, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FTokenIterator_3B, line, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FTokenIterator_3B, pos, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FTokenIterator_3B, reader, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FResourceReader_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FResourceReader_3B, encoding, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FResourceReader_3B, lineNo, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FResourceReader_3B, reader, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FResourceReader_3B, resourceName, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fdata_2FResourceReader_3B, root, 40, 8)
+__MRT_CLASS(Ljava_2Fio_2FBufferedReader_3B, 68, Ljava_2Fio_2FReader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_3B, cb, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_3B, in, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_3B, markedChar, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_3B, markedSkipLF, 52, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_3B, nChars, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_3B, nextChar, 60, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_3B, readAheadLimit, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_3B, skipLF, 53, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, 50, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, allowMillis, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, allowZero, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, inUse, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, maxLimit, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, maxUnit, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, minLimit, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, minUnit, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, this_240, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, uset, 48, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_24Settings_3B, weeksAloneOnly, 15, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FTimeUnit_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FTimeUnit_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FTimeUnit_3B, ordinal, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_3B, ds, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodBuilderFactory_3B, settings, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FPeriodFormatterDataService_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FPeriodFormatterData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FPeriodFormatterData_3B, dr, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FPeriodFormatterData_3B, localeName, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, 211, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, allowZero, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, countSep, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, decimalHandling, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, decimalSep, 14, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, digitPrefix, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, fifteenMinutes, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, fiveMinutes, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, fractionHandling, 48, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, genders, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, halfNames, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, halfPlacements, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, halfSupport, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, halves, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, measures, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, mediumNames, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, numberNames, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, numberSystem, 49, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, omitDualCount, 50, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, omitSingularCount, 51, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, optSuffixes, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, pl, 52, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, pluralNames, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, requiresDigitSeparator, 53, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, requiresSkipMarker, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, rqdSuffixes, 144, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, scopeData, 152, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, shortNames, 160, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, shortUnitSep, 168, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, singularNames, 176, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, skippedUnitMarker, 184, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, unitSep, 192, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, unitSepRequiresDP, 200, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, useMilliseconds, 54, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, weeksAloneOnly, 55, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, zero, 208, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_3B, zeroHandling, 210, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_24ScopeData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_24ScopeData_3B, prefix, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_24ScopeData_3B, requiresDigitPrefix, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FDataRecord_24ScopeData_3B, suffix, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FPeriod_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FPeriod_3B, counts, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FPeriod_3B, inFuture, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FPeriod_3B, timeLimit, 13, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_24Customizations_3B, 17, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_24Customizations_3B, countVariant, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_24Customizations_3B, displayDirection, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_24Customizations_3B, displayLimit, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_24Customizations_3B, separatorVariant, 15, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_24Customizations_3B, unitVariant, 16, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FUtils_24ChineseDigits_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FUtils_24ChineseDigits_3B, digits, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FUtils_24ChineseDigits_3B, ko, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FUtils_24ChineseDigits_3B, levels, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FUtils_24ChineseDigits_3B, liang, 14, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FUtils_24ChineseDigits_3B, units, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FAsciiUtil_24CaseInsensitiveKey_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FAsciiUtil_24CaseInsensitiveKey_3B, __hash, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FAsciiUtil_24CaseInsensitiveKey_3B, __key, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FAsciiUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveChar_3B, 14, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveChar_3B, __c, 12, 2)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveString_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveString_3B, __s, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_3B, __extensions, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_3B, __language, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_3B, __region, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_3B, __script, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_3B, __uattributes, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_3B, __ukeywords, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FInternalLocaleBuilder_3B, __variant, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashSet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashSet_3B, map, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FAbstractSet_3B, 12, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FLanguageTag_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLanguageTag_3B, __extensions, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLanguageTag_3B, __extlangs, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLanguageTag_3B, __language, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLanguageTag_3B, __privateuse, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLanguageTag_3B, __region, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLanguageTag_3B, __script, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLanguageTag_3B, __variants, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FParseStatus_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FParseStatus_3B, __errorIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FParseStatus_3B, __errorMsg, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FParseStatus_3B, __parseLength, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FStringTokenIterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FStringTokenIterator_3B, __dlms, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FStringTokenIterator_3B, __done, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FStringTokenIterator_3B, __end, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FStringTokenIterator_3B, __start, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FStringTokenIterator_3B, __text, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FStringTokenIterator_3B, __token, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24KeyData_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24KeyData_3B, bcpId, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24KeyData_3B, legacyId, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24KeyData_3B, specialTypes, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24KeyData_3B, typeMap, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FEnumSet_3B, 32, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumSet_3B, elementType, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumSet_3B, universe, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24SpecialTypeHandler_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24Type_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24Type_3B, bcpId, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24Type_3B, legacyId, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24ValueType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleValidityChecker_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleValidityChecker_24Where_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleValidityChecker_24Where_3B, codeFailure, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleValidityChecker_24Where_3B, fieldFailure, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleValidityChecker_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleValidityChecker_3B, allowsDeprecated, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleValidityChecker_3B, datasubtypes, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24CollectionUtilities_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24FileUtilities_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24ImmutableMap_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24ImmutableMultimap_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Multimap_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Multimap_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Multimap_3B, setClass, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24ImmutableSet_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Joiner_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Joiner_3B, separator, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Multimaps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24RegexUtilities_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Splitter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Splitter_3B, pattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Splitter_3B, trimResults, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24Aliases_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24Aliases_3B, toAliases, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24Aliases_3B, toCanonical, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24LSR_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24LSR_3B, language, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24LSR_3B, region, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24LSR_3B, script, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24Maker_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_3B, langTable, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24DistanceNode_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24DistanceNode_3B, distance, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24DistanceTable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionMapper_24Builder_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionMapper_24Builder_3B, paradigms, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionMapper_24Builder_3B, regionSet, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionMapper_24Builder_3B, regionToRawPartition, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionSet_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionSet_3B, operation, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionSet_3B, tempRegions, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionSet_24Operation_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionMapper_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionMapper_3B, macroToPartitions, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionMapper_3B, paradigms, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionMapper_3B, regionToPartition, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24RegionMapper_3B, variableToPartition, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_3B, defaultLanguageDistance, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_3B, defaultRegionDistance, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_3B, defaultScriptDistance, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_3B, languageDesired2Supported, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_3B, regionMapper, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24StringDistanceTable_3B, 24, Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24DistanceTable_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24StringDistanceTable_3B, subtables, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24IdMakerFull_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24IdMakerFull_3B, intToObject, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24IdMakerFull_3B, name, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24IdMakerFull_3B, objectToInt, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24TreeMultimap_3B, 32, Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Multimap_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24DistanceOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_24Builder_3B, 52, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_24Builder_3B, defaultLanguage, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_24Builder_3B, demotionPerAdditionalDesiredLocale, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_24Builder_3B, distanceOption, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_24Builder_3B, localeDistance, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_24Builder_3B, supportedLanguagesList, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_24Builder_3B, thresholdDistance, 48, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_3B, 60, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_3B, defaultLanguage, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_3B, demotionPerAdditionalDesiredLocale, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_3B, distanceOption, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_3B, exactSupportedLocales, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_3B, localeDistance, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_3B, supportedLanguages, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleMatcher_3B, thresholdDistance, 56, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocalePriorityList_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocalePriorityList_3B, languagesAndWeights, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocalePriorityList_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocalePriorityList_24Builder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocalePriorityList_24Builder_3B, languageToWeight, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FAffixPatternProvider_24Flags_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FAffixUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberFormat_24Field_3B, 24, Ljava_2Ftext_2FFormat_24Field_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FNumberStringBuilder_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FNumberStringBuilder_3B, chars, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FNumberStringBuilder_3B, fields, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FNumberStringBuilder_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FNumberStringBuilder_3B, zero, 32, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FGrouper_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FGrouper_3B, 18, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FGrouper_3B, grouping1, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FGrouper_3B, grouping2, 14, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FGrouper_3B, minGrouping, 16, 2)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, 237, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, compactCustomData, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, compactStyle, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, currency, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, currencyPluralInfo, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, currencyUsage, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, decimalPatternMatchRequired, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, decimalSeparatorAlwaysShown, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, exponentSignAlwaysShown, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, formatWidth, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, groupingSize, 60, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, groupingUsed, 15, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, magnitudeMultiplier, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, mathContext, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, maximumFractionDigits, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, maximumIntegerDigits, 80, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, maximumSignificantDigits, 84, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, minimumExponentDigits, 88, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, minimumFractionDigits, 92, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, minimumGroupingDigits, 96, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, minimumIntegerDigits, 100, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, minimumSignificantDigits, 104, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, multiplier, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, negativePrefix, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, negativePrefixPattern, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, negativeSuffix, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, negativeSuffixPattern, 144, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, padPosition, 152, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, padString, 160, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, parseCaseSensitive, 108, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, parseIntegerOnly, 109, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, parseMode, 168, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, parseNoExponent, 110, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, parseToBigDecimal, 111, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, pluralRules, 176, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, positivePrefix, 184, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, positivePrefixPattern, 192, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, positiveSuffix, 200, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, positiveSuffixPattern, 208, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, roundingIncrement, 216, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, roundingMode, 224, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, secondaryGroupingSize, 232, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_3B, signAlwaysShown, 236, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCompactDecimalFormat_24CompactStyle_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrency_3B, 40, Landroid_2Ficu_2Futil_2FMeasureUnit_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCurrency_3B, isoCode, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrency_24ServiceShim_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FCurrency_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCurrency_3B, currencyCode, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCurrency_3B, icuCurrency, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyFilter_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyFilter_3B, currency, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyFilter_3B, from, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyFilter_3B, region, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyFilter_3B, tenderOnly, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyFilter_3B, to, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrency_24CurrencyUsage_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMeasureUnit_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMeasureUnit_3B, subType, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMeasureUnit_3B, type, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTimeUnit_3B, 36, Landroid_2Ficu_2Futil_2FMeasureUnit_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeUnit_3B, index, 32, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCurrencyPluralInfo_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyPluralInfo_3B, pluralCountToCurrencyUnitPattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyPluralInfo_3B, pluralRules, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyPluralInfo_3B, ulocale, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_3B, keywords, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_3B, rules, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24RuleList_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24RuleList_3B, hasExplicitBoundingInfo, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24RuleList_3B, rules, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24Operand_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24SampleType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24Rule_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24Rule_3B, constraint, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24Rule_3B, decimalSamples, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24Rule_3B, integerSamples, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24Rule_3B, keyword, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimalSamples_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimalSamples_3B, bounded, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimalSamples_3B, sampleType, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimalSamples_3B, samples, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, 60, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, baseFactor, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, decimalDigits, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, decimalDigitsWithoutTrailingZeros, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, hasIntegerValue, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, integerValue, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, isNegative, 33, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, source, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, visibleDecimalDigitCount, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimal_3B, visibleDecimalDigitCountWithoutTrailingZeros, 56, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24PluralType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24KeywordStatus_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPadder_24PadPosition_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalFormatProperties_24ParseMode_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberFormatter_24GroupingStrategy_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStandardPlural_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStandardPlural_3B, keyword, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedPatternInfo_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedPatternInfo_3B, negative, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedPatternInfo_3B, pattern, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedPatternInfo_3B, positive, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, 108, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, exponentHasPlusSign, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, exponentZeros, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, fractionHashSigns, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, fractionNumerals, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, fractionTotal, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, groupingSizes, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, hasCurrencySign, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, hasDecimal, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, hasMinusSign, 15, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, hasPerMilleSign, 40, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, hasPercentSign, 41, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, hasPlusSign, 42, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, integerAtSigns, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, integerLeadingHashSigns, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, integerNumerals, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, integerTotal, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, integerTrailingHashSigns, 60, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, paddingEndpoints, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, paddingLocation, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, prefixEndpoints, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, rounding, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, suffixEndpoints, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParsedSubpatternInfo_3B, widthExceptAffixes, 104, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__DualStorageBCD_3B, 72, Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__DualStorageBCD_3B, bcdBytes, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__DualStorageBCD_3B, bcdLong, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__DualStorageBCD_3B, usingBytes, 52, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, 52, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, explicitExactDouble, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, flags, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, isApproximate, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, lOptPos, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, lReqPos, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, origDelta, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, origDouble, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, precision, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, rOptPos, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, rReqPos, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FDecimalQuantity__AbstractBCD_3B, scale, 48, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, 96, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, decimal, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, exhausted, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, grouping, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, immutable, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, integerWidth, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, modInner, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, modMiddle, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, modOuter, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, padding, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, rounder, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, sign, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, symbols, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMicroProps_3B, useCurrency, 14, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberFormatter_24DecimalSeparatorDisplay_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FIntegerWidth_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FIntegerWidth_3B, maxInt, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FIntegerWidth_3B, minInt, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FModifier_24Parameters_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FModifier_24Parameters_3B, obj, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FModifier_24Parameters_3B, plural, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FModifier_24Parameters_3B, signum, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPadder_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPadder_3B, paddingString, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPadder_3B, position, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPadder_3B, targetWidth, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FPrecision_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_3B, mathContext, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FPrecision_24FracSigRounderImpl_3B, 40, Landroid_2Ficu_2Fnumber_2FPrecision_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24FracSigRounderImpl_3B, maxFrac, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24FracSigRounderImpl_3B, maxSig, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24FracSigRounderImpl_3B, minFrac, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24FracSigRounderImpl_3B, minSig, 36, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FPrecision_24FractionRounderImpl_3B, 32, Landroid_2Ficu_2Fnumber_2FFractionPrecision_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24FractionRounderImpl_3B, maxFrac, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24FractionRounderImpl_3B, minFrac, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FFractionPrecision_3B, 24, Landroid_2Ficu_2Fnumber_2FPrecision_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FPrecision_24SignificantRounderImpl_3B, 32, Landroid_2Ficu_2Fnumber_2FPrecision_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24SignificantRounderImpl_3B, maxSig, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24SignificantRounderImpl_3B, minSig, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FPrecision_24CurrencyRounderImpl_3B, 32, Landroid_2Ficu_2Fnumber_2FCurrencyPrecision_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24CurrencyRounderImpl_3B, usage, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FCurrencyPrecision_3B, 24, Landroid_2Ficu_2Fnumber_2FPrecision_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FPrecision_24IncrementRounderImpl_3B, 32, Landroid_2Ficu_2Fnumber_2FPrecision_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FPrecision_24IncrementRounderImpl_3B, increment, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FPrecision_24InfiniteRounderImpl_3B, 24, Landroid_2Ficu_2Fnumber_2FPrecision_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FPrecision_24PassThroughRounderImpl_3B, 24, Landroid_2Ficu_2Fnumber_2FPrecision_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberFormatter_24SignDisplay_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, 240, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, NaN, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, actualLocale, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, codePointZero, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, currency, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, currencyPattern, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, currencySpcAfterSym, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, currencySpcBeforeSym, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, currencySymbol, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, decimalSeparator, 72, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, decimalSeparatorString, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, digit, 74, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, digitStrings, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, digits, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, exponentMultiplicationSign, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, exponentSeparator, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, exponential, 76, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, groupingSeparator, 78, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, groupingSeparatorString, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, infinity, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, intlCurrencySymbol, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, minusSign, 144, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, minusString, 152, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, monetaryGroupingSeparator, 146, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, monetaryGroupingSeparatorString, 160, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, monetarySeparator, 148, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, monetarySeparatorString, 168, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, padEscape, 150, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, patternSeparator, 176, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, perMill, 178, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, perMillString, 184, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, percent, 180, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, percentString, 192, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, plusSign, 182, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, plusString, 200, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, requestedLocale, 208, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, serialVersionOnStream, 216, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, sigDigit, 220, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, ulocale, 224, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, validLocale, 232, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_3B, zeroDigit, 222, 2)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberingSystem_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberingSystem_3B, algorithmic, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberingSystem_3B, desc, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberingSystem_3B, name, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberingSystem_3B, radix, 32, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberingSystem_24LocaleLookupData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberingSystem_24LocaleLookupData_3B, locale, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberingSystem_24LocaleLookupData_3B, numbersKeyword, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_24CacheData_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_24CacheData_3B, digits, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_24CacheData_3B, numberElements, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_24CacheData_3B, validLocale, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPadder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParserState_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParserState_3B, offset, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_24ParserState_3B, pattern, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringParser_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringUtils_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPatternStringUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FRoundingUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FScale_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScale_3B, arbitrary, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScale_3B, magnitude, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScale_3B, mc, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScale_3B, reciprocal, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixTokenMatcherFactory_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixTokenMatcherFactory_3B, currency, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixTokenMatcherFactory_3B, ignorables, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixTokenMatcherFactory_3B, locale, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixTokenMatcherFactory_3B, parseFlags, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixTokenMatcherFactory_3B, symbols, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FIgnorablesMatcher_3B, 32, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStringSegment_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStringSegment_3B, end, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStringSegment_3B, foldCase, 16, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStringSegment_3B, start, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStringSegment_3B, str, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FParsedNumber_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FParsedNumber_3B, charEnd, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FParsedNumber_3B, currencyCode, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FParsedNumber_3B, flags, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FParsedNumber_3B, prefix, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FParsedNumber_3B, quantity, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FParsedNumber_3B, suffix, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B, string, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B, uniSet, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCombinedCurrencyMatcher_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCombinedCurrencyMatcher_3B, afterPrefixInsert, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCombinedCurrencyMatcher_3B, beforeSuffixInsert, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCombinedCurrencyMatcher_3B, currency1, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCombinedCurrencyMatcher_3B, currency2, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCombinedCurrencyMatcher_3B, isoCode, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCombinedCurrencyMatcher_3B, localLongNames, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCombinedCurrencyMatcher_3B, longNameTrie, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCombinedCurrencyMatcher_3B, symbolTrie, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FMinusSignMatcher_3B, 33, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FMinusSignMatcher_3B, allowTrailing, 32, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FPercentMatcher_3B, 32, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FPermilleMatcher_3B, 32, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FPlusSignMatcher_3B, 33, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FPlusSignMatcher_3B, allowTrailing, 32, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FNumberParserImpl_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FNumberParserImpl_3B, frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FNumberParserImpl_3B, matchers, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FNumberParserImpl_3B, parseFlags, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrencyAmount_3B, 32, Landroid_2Ficu_2Futil_2FMeasure_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMeasure_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMeasure_3B, number, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMeasure_3B, unit, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FParsingUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FPrefixInfixSuffixLengthHelper_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FPrefixInfixSuffixLengthHelper_3B, length1, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FPrefixInfixSuffixLengthHelper_3B, length2, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FPrefixInfixSuffixLengthHelper_3B, lengthInfix, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FPrefixInfixSuffixLengthHelper_3B, lengthPrefix, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FPrefixInfixSuffixLengthHelper_3B, lengthSuffix, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FRangeMacroProps_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FRangeMacroProps_3B, collapse, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FRangeMacroProps_3B, formatter1, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FRangeMacroProps_3B, formatter2, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FRangeMacroProps_3B, identityFallback, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FRangeMacroProps_3B, loc, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FRangeMacroProps_3B, sameFormatters, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatter_24RangeCollapse_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FUnlocalizedNumberFormatter_3B, 40, Landroid_2Ficu_2Fnumber_2FNumberFormatterSettings_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberFormatterSettings_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberFormatterSettings_3B, key, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberFormatterSettings_3B, parent, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberFormatterSettings_3B, resolvedMacros, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberFormatterSettings_3B, value, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, 152, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, affixProvider, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, decimal, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, grouping, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, integerWidth, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, loc, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, notation, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, padder, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, perUnit, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, precision, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, roundingMode, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, rules, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, scale, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, sign, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, symbols, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, threshold, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, unit, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMacroProps_3B, unitWidth, 144, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNotation_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FCompactNotation_3B, 32, Landroid_2Ficu_2Fnumber_2FNotation_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FCompactNotation_3B, compactCustomData, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FCompactNotation_3B, compactStyle, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FCompactData_24CompactType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, 96, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, currency, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, currentAffix, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, isStrong, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, parent, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, patternInfo, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, perMilleReplacesPercent, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, plural, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, rules, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, signDisplay, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, signum, 72, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, symbols, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_3B, unitWidth, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberFormatter_24UnitWidth_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantMultiFieldModifier_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantMultiFieldModifier_3B, overwrite, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantMultiFieldModifier_3B, parameters, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantMultiFieldModifier_3B, prefixChars, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantMultiFieldModifier_3B, prefixFields, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantMultiFieldModifier_3B, strong, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantMultiFieldModifier_3B, suffixChars, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantMultiFieldModifier_3B, suffixFields, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_24ImmutablePatternModifier_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_24ImmutablePatternModifier_3B, parent, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_24ImmutablePatternModifier_3B, pm, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMutablePatternModifier_24ImmutablePatternModifier_3B, rules, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FAdoptingModifierStore_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FAdoptingModifierStore_3B, frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FAdoptingModifierStore_3B, mods, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FAdoptingModifierStore_3B, negative, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FAdoptingModifierStore_3B, positive, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FAdoptingModifierStore_3B, zero, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FScientificNotation_3B, 29, Landroid_2Ficu_2Fnumber_2FNotation_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_3B, engineeringInterval, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_3B, exponentSignDisplay, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_3B, minExponentDigits, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_3B, requireMinInt, 28, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FSimpleNotation_3B, 12, Landroid_2Ficu_2Fnumber_2FNotation_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FLocalizedNumberFormatter_3B, 64, Landroid_2Ficu_2Fnumber_2FNumberFormatterSettings_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FLocalizedNumberFormatter_3B, callCountInternal, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FLocalizedNumberFormatter_3B, compiled, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FLocalizedNumberFormatter_3B, savedWithUnit, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberFormatterImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberFormatterImpl_3B, microPropsGenerator, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FFormattedNumber_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FFormattedNumber_3B, fq, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FFormattedNumber_3B, nsb, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatter_24RangeIdentityFallback_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FStandardPluralRanges_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FStandardPluralRanges_3B, flatTriples, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FStandardPluralRanges_3B, numTriples, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Ftext_2FRbnfScannerProviderImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FCharSequences_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FCharacterProperties_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacter_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacterEnums_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUScript_24ScriptMetadata_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUScript_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUScript_24ScriptUsage_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2FBitSet_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBitSet_3B, sizeIsSticky, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBitSet_3B, words, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBitSet_3B, wordsInUse, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUScriptRun_24ParenStackEntry_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_24ParenStackEntry_3B, pairIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_24ParenStackEntry_3B, scriptCode, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUScriptRun_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, emptyCharArray, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, fixupCount, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, parenSP, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, pushCount, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, scriptCode, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, scriptLimit, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, scriptStart, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, text, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, textIndex, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, textLimit, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUScriptRun_3B, textStart, 60, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FCompactNotation_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FFormattedNumberRange_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FFormattedNumberRange_3B, identityResult, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FFormattedNumberRange_3B, quantity1, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FFormattedNumberRange_3B, quantity2, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FFormattedNumberRange_3B, string, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatter_24RangeIdentityResult_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberFormatter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberPropertyMapper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FUnlocalizedNumberRangeFormatter_3B, 40, Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterSettings_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterSettings_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterSettings_3B, key, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterSettings_3B, parent, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterSettings_3B, resolvedMacros, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterSettings_3B, value, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FLocalizedNumberRangeFormatter_3B, 48, Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterSettings_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FLocalizedNumberRangeFormatter_3B, fImpl, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_3B, fApproximatelyModifier, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_3B, fCollapse, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_3B, fIdentityFallback, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_3B, fPluralRanges, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_3B, fRangePattern, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_3B, fSameFormatters, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_3B, formatterImpl1, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_3B, formatterImpl2, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FSimpleModifier_3B, 52, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FSimpleModifier_3B, compiledPattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FSimpleModifier_3B, field, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FSimpleModifier_3B, parameters, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FSimpleModifier_3B, prefixLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FSimpleModifier_3B, strong, 40, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FSimpleModifier_3B, suffixLength, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FSimpleModifier_3B, suffixOffset, 48, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberSkeletonImpl_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberSkeletonImpl_24BlueprintHelpers_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberSkeletonImpl_24EnumToStemString_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberSkeletonImpl_24GeneratorHelpers_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberSkeletonImpl_24StemToObject_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberSkeletonImpl_24StemEnum_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberSkeletonImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberSkeletonImpl_24ParseState_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FScientificNotation_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Record_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Record_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Record_3B, name, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_241_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, buckets, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, collatorExternal, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, collatorOriginal, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, collatorPrimaryOnly, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, firstCharsInScripts, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, inflowLabel, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, initialLabels, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, inputList, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, maxLabelCount, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, overflowLabel, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, recordComparator, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_3B, underflowLabel, 96, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24BucketList_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24BucketList_3B, bucketList, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24BucketList_3B, immutableVisibleList, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollator_24ServiceShim_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollator_24CollatorFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B, 64, Landroid_2Ficu_2Ftext_2FCollator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B, actualLocaleIsSameAsValid, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B, collationBuffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B, data, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B, frozenLock, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B, settings, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B, tailoring, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_3B, validLocale, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, leftFCDUTF16Iter, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, leftFCDUTF16NFDIter, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, leftUTF16CollIter, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, leftUTF16NFDIter, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, rawCollationKey, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, rightFCDUTF16Iter, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, rightFCDUTF16NFDIter, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, rightUTF16CollIter, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationBuffer_3B, rightUTF16NFDIter, 80, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDUTF16CollationIterator_3B, 116, Landroid_2Ficu_2Fimpl_2Fcoll_2FUTF16CollationIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDUTF16CollationIterator_3B, checkDir, 76, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDUTF16CollationIterator_3B, nfcImpl, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDUTF16CollationIterator_3B, normalized, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDUTF16CollationIterator_3B, rawLimit, 96, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDUTF16CollationIterator_3B, rawSeq, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDUTF16CollationIterator_3B, segmentLimit, 100, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDUTF16CollationIterator_3B, segmentStart, 112, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FUTF16CollationIterator_3B, 76, Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FUTF16CollationIterator_3B, limit, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FUTF16CollationIterator_3B, pos, 60, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FUTF16CollationIterator_3B, seq, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FUTF16CollationIterator_3B, start, 72, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24FCDUTF16NFDIterator_3B, 48, Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24UTF16NFDIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24FCDUTF16NFDIterator_3B, str, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24UTF16NFDIterator_3B, 40, Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24NFDIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24UTF16NFDIterator_3B, pos, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24UTF16NFDIterator_3B, s, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24NFDIterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24NFDIterator_3B, decomp, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24NFDIterator_3B, index, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRawCollationKey_3B, 24, Landroid_2Ficu_2Futil_2FByteArrayWrapper_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollationKey_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationKey_3B, m__hashCode__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationKey_3B, m__key__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationKey_3B, m__length__, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationKey_3B, m__source__, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationKeyByteSink_3B, 32, Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationKeys_24SortKeyByteSink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedCollator_24CollationKeyByteSink_3B, key__, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollationElementIterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationElementIterator_3B, dir__, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationElementIterator_3B, iter__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationElementIterator_3B, offsets__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationElementIterator_3B, otherHalf__, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationElementIterator_3B, rbc__, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationElementIterator_3B, string__, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24ImmutableIndex_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24ImmutableIndex_3B, buckets, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24ImmutableIndex_3B, collatorPrimaryOnly, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Bucket_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Bucket_3B, displayBucket, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Bucket_3B, displayIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Bucket_3B, label, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Bucket_3B, labelType, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Bucket_3B, lowerBoundary, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Bucket_3B, records, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAlphabeticIndex_24Bucket_24LabelType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAnyTransliterator_24ScriptRunIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_24ScriptRunIterator_3B, limit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_24ScriptRunIterator_3B, scriptCode, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_24ScriptRunIterator_3B, start, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_24ScriptRunIterator_3B, text, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_24ScriptRunIterator_3B, textLimit, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_24ScriptRunIterator_3B, textStart, 36, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FArabicShaping_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FArabicShaping_3B, isLogical, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FArabicShaping_3B, options, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FArabicShaping_3B, spacesRelativeToTextBeginEnd, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FArabicShaping_3B, tailChar, 14, 2)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_24BracketData_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24BracketData_3B, isNumbersSpecial, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24BracketData_3B, isoRunLast, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24BracketData_3B, isoRuns, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24BracketData_3B, openings, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_24IsoRun_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24IsoRun_3B, contextDir, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24IsoRun_3B, contextPos, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24IsoRun_3B, lastBase, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24IsoRun_3B, lastStrong, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24IsoRun_3B, level, 15, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24IsoRun_3B, limit, 20, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24IsoRun_3B, start, 22, 2)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_24Opening_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Opening_3B, contextDir, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Opening_3B, contextPos, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Opening_3B, flags, 14, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Opening_3B, match, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Opening_3B, position, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_24ImpTabPair_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24ImpTabPair_3B, impact, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24ImpTabPair_3B, imptab, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_24InsertPoints_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24InsertPoints_3B, confirmed, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24InsertPoints_3B, points, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24InsertPoints_3B, size, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_24Point_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Point_3B, flag, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Point_3B, pos, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_24Isolate_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Isolate_3B, start1, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Isolate_3B, startON, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Isolate_3B, state, 20, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24Isolate_3B, stateImp, 22, 2)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_24LevState_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24LevState_3B, impAct, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24LevState_3B, impTab, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24LevState_3B, lastStrongRTL, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24LevState_3B, runLevel, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24LevState_3B, runStart, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24LevState_3B, startL2EN, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24LevState_3B, startON, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_24LevState_3B, state, 34, 2)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidi_3B, 220, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, bdp, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, controlCount, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, customClassifier, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, defaultParaLevel, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, dirProps, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, dirPropsMemory, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, direction, 33, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, epilogue, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, flags, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, impTabPair, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, insertPoints, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, isGoodLogicalToVisualRunsMap, 34, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, isInverse, 35, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, isolateCount, 80, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, isolates, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, lastArabicPos, 84, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, length, 96, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, levels, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, levelsMemory, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, logicalToVisualRunsMap, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, mayAllocateRuns, 100, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, mayAllocateText, 101, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, orderParagraphsLTR, 102, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, originalLength, 128, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, paraBidi, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, paraCount, 132, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, paraLevel, 103, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, paras__level, 144, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, paras__limit, 152, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, prologue, 160, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, reorderingMode, 168, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, reorderingOptions, 172, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, resultLength, 176, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, runCount, 180, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, runs, 184, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, runsMemory, 192, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, simpleRuns, 200, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, text, 208, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidi_3B, trailingWSStart, 216, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiClassifier_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidiClassifier_3B, context, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiRun_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidiRun_3B, insertRemove, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidiRun_3B, level, 16, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidiRun_3B, limit, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidiRun_3B, start, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiLine_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidiTransform_3B, bidi, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidiTransform_3B, reorderingOptions, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidiTransform_3B, shapingOptions, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBidiTransform_3B, text, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24Order_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24Mirroring_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiWriter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBreakIterator_24BreakIteratorCache_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakIterator_24BreakIteratorCache_3B, iter, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakIterator_24BreakIteratorCache_3B, where, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCanonicalIterator_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCanonicalIterator_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCanonicalIterator_3B, current, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCanonicalIterator_3B, done, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCanonicalIterator_3B, nfcImpl, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCanonicalIterator_3B, nfd, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCanonicalIterator_3B, pieces, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCanonicalIterator_3B, source, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCaseMap_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCaseMap_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCaseMap_3B, internalOptions, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCaseMap_24Fold_3B, 16, Landroid_2Ficu_2Ftext_2FCaseMap_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCaseMap_24Lower_3B, 16, Landroid_2Ficu_2Ftext_2FCaseMap_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCaseMap_24Title_3B, 16, Landroid_2Ficu_2Ftext_2FCaseMap_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCaseMap_24Upper_3B, 16, Landroid_2Ficu_2Ftext_2FCaseMap_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetDetector_24CSRecognizerInfo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_24CSRecognizerInfo_3B, isDefaultEnabled, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_24CSRecognizerInfo_3B, recognizer, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecognizer_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetMatch_3B, 52, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetMatch_3B, fCharsetName, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetMatch_3B, fConfidence, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetMatch_3B, fInputStream, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetMatch_3B, fLang, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetMatch_3B, fRawInput, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetMatch_3B, fRawLength, 48, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fByteStats, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fC1Bytes, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fDeclaredEncoding, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fEnabledRecognizers, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fInputBytes, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fInputLen, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fInputStream, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fRawInput, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fRawLength, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetDetector_3B, fStripTags, 13, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24iteratedChar_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24iteratedChar_3B, charValue, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24iteratedChar_3B, done, 16, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24iteratedChar_3B, error, 17, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24iteratedChar_3B, nextIndex, 20, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser_3B, byteIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser_3B, byteMap, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser_3B, hitCount, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser_3B, ngram, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser_3B, ngramCount, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser_3B, ngramList, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser_3B, spaceChar, 36, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramsPlusLang_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramsPlusLang_3B, fLang, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramsPlusLang_3B, fNGrams, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollationKey_24BoundMode_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollator_24ASCII_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FComposedCharIter_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FComposedCharIter_3B, curChar, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FComposedCharIter_3B, decompBuf, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FComposedCharIter_3B, n2impl, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FComposedCharIter_3B, nextChar, 32, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyDigits_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyDigits_3B, fractionDigits, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyDigits_3B, roundingIncrement, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyInfo_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyInfo_3B, code, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyInfo_3B, from, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyInfo_3B, priority, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyInfo_3B, region, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyInfo_3B, tender, 40, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_24CurrencyInfo_3B, to, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_24BestMatchInfo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_24BestMatchInfo_3B, bestMatchDistanceInfo, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_24BestMatchInfo_3B, bestMatchSkeleton, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_24SkeletonAndItsBestMatch_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_24SkeletonAndItsBestMatch_3B, bestMatchSkeleton, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_24SkeletonAndItsBestMatch_3B, skeleton, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DistanceInfo_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DistanceInfo_3B, extraFieldMask, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DistanceInfo_3B, missingFieldMask, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24FormatParser_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24FormatParser_3B, items, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24FormatParser_3B, tokenizer, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24PatternInfo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24PatternInfo_3B, conflictingPattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24PatternInfo_3B, status, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24PatternWithMatcher_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24PatternWithMatcher_3B, matcherWithSkeleton, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24PatternWithMatcher_3B, pattern, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DateTimeMatcher_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DateTimeMatcher_3B, addedDefaultDayPeriod, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DateTimeMatcher_3B, baseOriginal, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DateTimeMatcher_3B, original, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DateTimeMatcher_3B, type, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24SkeletonFields_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24SkeletonFields_3B, chars, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24SkeletonFields_3B, lengths, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24PatternWithSkeletonFlag_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24PatternWithSkeletonFlag_3B, pattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24PatternWithSkeletonFlag_3B, skeletonWasSpecified, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24VariableField_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24VariableField_3B, canonicalIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24VariableField_3B, string, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_24AffixForCurrency_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_24AffixForCurrency_3B, negPrefixPatternForCurrency, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_24AffixForCurrency_3B, negSuffixPatternForCurrency, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_24AffixForCurrency_3B, patternType, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_24AffixForCurrency_3B, posPrefixPatternForCurrency, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_24AffixForCurrency_3B, posSuffixPatternForCurrency, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_24Unit_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_24Unit_3B, prefix, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_24Unit_3B, suffix, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24PossibleWord_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24PossibleWord_3B, count, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24PossibleWord_3B, current, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24PossibleWord_3B, lengths, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24PossibleWord_3B, mark, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24PossibleWord_3B, offset, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24PossibleWord_3B, prefix, 40, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDictionaryMatcher_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDictionaryData_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDigitList__Android_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDigitList__Android_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDigitList__Android_3B, decimalAt, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDigitList__Android_3B, didRound, 20, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDigitList__Android_3B, digits, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fmath_2FBigDecimal_3B, 32, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fmath_2FBigDecimal_3B, exp, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fmath_2FBigDecimal_3B, form, 16, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fmath_2FBigDecimal_3B, ind, 17, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fmath_2FBigDecimal_3B, mant, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fmath_2FMathContext_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fmath_2FMathContext_3B, digits, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fmath_2FMathContext_3B, form, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fmath_2FMathContext_3B, lostDigits, 20, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fmath_2FMathContext_3B, roundingMode, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FFilteredBreakIteratorBuilder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FIDNA_24Info_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FIDNA_24Info_3B, errors, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FIDNA_24Info_3B, isBiDi, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FIDNA_24Info_3B, isOkBiDi, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FIDNA_24Info_3B, isTransDiff, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FIDNA_24Info_3B, labelErrors, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FIDNA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FIDNA_24Error_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24DequeI_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24DequeI_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24DequeI_3B, firstIdx, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_24DequeI_3B, lastIdx, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FListFormatter_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FListFormatter_24Cache_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FListFormatter_24Cache_3B, cache, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FListFormatter_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FListFormatter_3B, end, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FListFormatter_3B, locale, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FListFormatter_3B, middle, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FListFormatter_3B, start, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FListFormatter_3B, two, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FListFormatter_24Style_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FListFormatter_24Style_3B, name, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FListFormatter_24FormattedListBuilder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FListFormatter_24FormattedListBuilder_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FListFormatter_24FormattedListBuilder_3B, offset, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24UiListItem_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24UiListItem_3B, minimized, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24UiListItem_3B, modified, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24UiListItem_3B, nameInDisplayLocale, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24UiListItem_3B, nameInSelf, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMeasureFormat_24NumberFormatterCacheEntry_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24NumberFormatterCacheEntry_3B, formatter, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24NumberFormatterCacheEntry_3B, perUnit, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24NumberFormatterCacheEntry_3B, type, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24NumberFormatterCacheEntry_3B, unit, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMeasureFormat_24NumericFormatters_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24NumericFormatters_3B, hourMinute, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24NumericFormatters_3B, hourMinuteSecond, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24NumericFormatters_3B, minuteSecond, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateFormat_3B, 68, Landroid_2Ficu_2Ftext_2FUFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormat_3B, booleanAttributes, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormat_3B, calendar, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormat_3B, capitalizationSetting, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormat_3B, numberFormat, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormat_3B, serialVersionOnStream, 64, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCalendar_3B, 128, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, actualLocale, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, areAllFieldsSet, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, areFieldsSet, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, areFieldsVirtuallySet, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, fields, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, firstDayOfWeek, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, gregorianDayOfMonth, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, gregorianDayOfYear, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, gregorianMonth, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, gregorianYear, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, internalSetMask, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, isTimeSet, 15, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, lenient, 56, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, minimalDaysInFirstWeek, 60, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, nextStamp, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, repeatedWallTime, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, skippedWallTime, 72, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, stamp, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, time, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, validLocale, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, weekendCease, 76, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, weekendCeaseMillis, 104, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, weekendOnset, 108, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, weekendOnsetMillis, 112, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_3B, zone, 120, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCalendar_24WeekDataCache_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCalendar_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCalendar_24WeekData_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24WeekData_3B, firstDayOfWeek, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24WeekData_3B, minimalDaysInFirstWeek, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24WeekData_3B, weekendCease, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24WeekData_3B, weekendCeaseMillis, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24WeekData_3B, weekendOnset, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24WeekData_3B, weekendOnsetMillis, 32, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCalendar_24PatternData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24PatternData_3B, overrides, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24PatternData_3B, patterns, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, 76, Landroid_2Ficu_2Ftext_2FUFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, capitalizationSetting, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, currency, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, groupingUsed, 48, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, maxFractionDigits, 49, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, maxIntegerDigits, 50, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, maximumFractionDigits, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, maximumIntegerDigits, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, minFractionDigits, 51, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, minIntegerDigits, 60, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, minimumFractionDigits, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, minimumIntegerDigits, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, parseIntegerOnly, 61, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, parseStrict, 62, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_3B, serialVersionOnStream, 72, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberFormat_24NumberFormatShim_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberFormat_24NumberFormatFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUFormat_3B, 32, Ljava_2Ftext_2FFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUFormat_3B, actualLocale, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUFormat_3B, validLocale, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateFormat_24BooleanAttribute_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessageFormat_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessageFormat_24AppendableWrapper_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24AppendableWrapper_3B, app, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24AppendableWrapper_3B, attributes, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24AppendableWrapper_3B, length, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessageFormat_24AttributeAndPosition_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24AttributeAndPosition_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24AttributeAndPosition_3B, limit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24AttributeAndPosition_3B, start, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24AttributeAndPosition_3B, value, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorContext_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorContext_3B, argName, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorContext_3B, forReplaceNumber, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorContext_3B, formatter, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorContext_3B, number, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorContext_3B, numberArgIndex, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorContext_3B, numberString, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorContext_3B, offset, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorContext_3B, startIndex, 44, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePattern_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePattern_24Part_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_24Part_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_24Part_3B, length, 16, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_24Part_3B, limitPartIndex, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_24Part_3B, type, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_24Part_3B, value, 18, 2)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePattern_24Part_24Type_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePattern_24ArgType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24Node_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ArgNode_3B, 72, Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24MessageContentsNode_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ArgNode_3B, argType, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ArgNode_3B, complexStyle, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ArgNode_3B, name, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ArgNode_3B, number, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ArgNode_3B, style, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ArgNode_3B, typeName, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ComplexArgStyleNode_3B, 40, Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24Node_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ComplexArgStyleNode_3B, argType, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ComplexArgStyleNode_3B, explicitOffset, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ComplexArgStyleNode_3B, list, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24ComplexArgStyleNode_3B, offset, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24VariantNode_3B, 40, Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24Node_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24VariantNode_3B, msgNode, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24VariantNode_3B, numericValue, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24VariantNode_3B, selector, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24MessageNode_3B, 24, Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24Node_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24MessageNode_3B, list, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24MessageContentsNode_3B, 24, Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24Node_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24MessageContentsNode_3B, type, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24MessageContentsNode_24Type_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePattern_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_3B, aposMode, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_3B, frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_3B, hasArgNames, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_3B, hasArgNumbers, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_3B, msg, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_3B, needsAutoQuoting, 15, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_3B, numericValues, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePattern_3B, parts, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePattern_24ApostropheMode_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNFRule_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRule_3B, baseValue, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRule_3B, decimalPoint, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRule_3B, exponent, 14, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRule_3B, formatter, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRule_3B, radix, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRule_3B, rulePatternFormat, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRule_3B, ruleText, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRule_3B, sub1, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRule_3B, sub2, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, 208, Landroid_2Ficu_2Ftext_2FNumberFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, capitalizationBrkIter, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, capitalizationForListOrMenu, 76, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, capitalizationForStandAlone, 77, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, capitalizationInfoIsSet, 78, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, decimalFormat, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, decimalFormatSymbols, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, defaultInfinityRule, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, defaultNaNRule, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, defaultRuleSet, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, lenientParse, 79, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, lenientParseRules, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, locale, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, lookedForScanner, 144, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, postProcessRules, 152, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, postProcessor, 160, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, publicRuleSetNames, 168, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, roundingMode, 148, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, ruleSetDisplayNames, 176, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, ruleSets, 184, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, ruleSetsMap, 192, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedNumberFormat_3B, scannerProvider, 200, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B, 136, Landroid_2Ficu_2Ftext_2FNumberFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B, currencyParser, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B, exportedProperties, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B, formatter, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B, icuMathContextForm, 76, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B, parser, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B, properties, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B, serialVersionOnStream, 120, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat_3B, symbols, 128, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNFRuleSet_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRuleSet_3B, fractionRules, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRuleSet_3B, isFractionRuleSet, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRuleSet_3B, isParseable, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRuleSet_3B, name, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRuleSet_3B, nonNumericalRules, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRuleSet_3B, owner, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFRuleSet_3B, rules, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralFormat_3B, 96, Landroid_2Ficu_2Ftext_2FUFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralFormat_3B, msgPattern, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralFormat_3B, numberFormat, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralFormat_3B, offset, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralFormat_3B, parsedValues, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralFormat_3B, pattern, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralFormat_3B, pluralRules, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralFormat_3B, pluralRulesWrapper, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralFormat_3B, ulocale, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralFormat_24PluralSelectorAdapter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralFormat_24PluralSelectorAdapter_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralFormat_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNFSubstitution_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFSubstitution_3B, numberFormat, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFSubstitution_3B, pos, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNFSubstitution_3B, ruleSet, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24CmpEquivLevel_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_24CmpEquivLevel_3B, cs, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_24CmpEquivLevel_3B, s, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24FCD32ModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24ModeImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_24ModeImpl_3B, normalizer2, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24FCDModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24Mode_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFC32ModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFCModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFD32ModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFDModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFKC32ModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFKCModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFKD32ModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFKDModeImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24Unicode32_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer2_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24Factory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPluralRulesLoader_3B, 48, Landroid_2Ficu_2Ftext_2FPluralRules_24Factory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPluralRulesLoader_3B, localeIdToCardinalRulesId, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPluralRulesLoader_3B, localeIdToOrdinalRulesId, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPluralRulesLoader_3B, rulesIdToEquivalentULocale, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPluralRulesLoader_3B, rulesIdToRules, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRanges_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRanges_3B, explicit, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRanges_3B, isFrozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRanges_3B, matrix, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRanges_24Matrix_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRanges_24Matrix_3B, data, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimalRange_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimalRange_3B, end, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24FixedDecimalRange_3B, start, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24SimpleTokenizer_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralSamples_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralSamples_3B, __fractionSamples, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralSamples_3B, __keyFractionSamplesMap, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralSamples_3B, __keyLimitedMap, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralSamples_3B, __keySamplesMap, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralSamples_3B, pluralRules, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FQuantityFormatter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FQuantityFormatter_3B, templates, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSimpleFormatter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleFormatter_3B, compiledPattern, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBINode_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fChainIn, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fFirstPos, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fFirstPosSet, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fFollowPos, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fInputSet, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fLastPos, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fLastPosSet, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fLeftChild, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fLookAheadEnd, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fNullable, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fParent, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fPrecedence, 72, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fRightChild, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fRuleRoot, 15, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fSerialNum, 76, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fText, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fType, 96, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBINode_3B, fVal, 100, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_24IntPair_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_24IntPair_3B, first, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_24IntPair_3B, second, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fChainRules, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fDebugEnv, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fDefaultTree, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fForwardTable, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fLBCMNoChain, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fLookAheadHardBreak, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fRuleStatusVals, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fRules, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fScanner, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fSetBuilder, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fStatusSets, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fStrippedRules, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fTreeRoots, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleBuilder_3B, fUSetNodes, 96, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_3B, fDStates, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_3B, fRB, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_3B, fRootIx, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_3B, fSafeTable, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, 112, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fC, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fCharNum, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fLastChar, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fLineNum, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fLookAheadRule, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fNextIndex, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fNoChainInRule, 33, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fNodeStack, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fNodeStackPtr, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fOptionStart, 52, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fQuoteMode, 34, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fRB, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fReverseRule, 35, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fRuleNum, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fRuleSets, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fScanIndex, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fSetTable, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fStack, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fStackPtr, 96, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_3B, fSymbolTable, 104, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_24RBBIRuleChar_3B, 17, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_24RBBIRuleChar_3B, fChar, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_24RBBIRuleChar_3B, fEscaped, 16, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBISymbolTable_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISymbolTable_3B, fCachedSetLookup, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISymbolTable_3B, fHashTable, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISymbolTable_3B, fRuleScanner, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISymbolTable_3B, ffffString, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_3B, fFrozenTrie, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_3B, fGroupCount, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_3B, fRB, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_3B, fRangeList, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_3B, fSawBOF, 40, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_3B, fTrie, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_24RangeDescriptor_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_24RangeDescriptor_3B, fEndChar, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_24RangeDescriptor_3B, fIncludesSets, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_24RangeDescriptor_3B, fNext, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_24RangeDescriptor_3B, fNum, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISetBuilder_24RangeDescriptor_3B, fStartChar, 36, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBIRuleParseTable_24RBBIRuleTableElement_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleParseTable_24RBBIRuleTableElement_3B, fAction, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleParseTable_24RBBIRuleTableElement_3B, fCharClass, 14, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleParseTable_24RBBIRuleTableElement_3B, fNextChar, 16, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleParseTable_24RBBIRuleTableElement_3B, fNextState, 18, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleParseTable_24RBBIRuleTableElement_3B, fPushState, 20, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleParseTable_24RBBIRuleTableElement_3B, fStateName, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBIRuleParseTable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_24RBBISetTableEl_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_24RBBISetTableEl_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBIRuleScanner_24RBBISetTableEl_3B, val, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBISymbolTable_24RBBISymbolTableEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISymbolTable_24RBBISymbolTableEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBISymbolTable_24RBBISymbolTableEntry_3B, val, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_24RBBIStateDescriptor_3B, 52, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_24RBBIStateDescriptor_3B, fAccepting, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_24RBBIStateDescriptor_3B, fDtran, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_24RBBIStateDescriptor_3B, fLookAhead, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_24RBBIStateDescriptor_3B, fMarked, 28, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_24RBBIStateDescriptor_3B, fPositions, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_24RBBIStateDescriptor_3B, fTagVals, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBBITableBuilder_24RBBIStateDescriptor_3B, fTagsIdx, 48, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24Cache_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24Cache_3B, cache, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelativeDateTimeFormatterData_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelativeDateTimeFormatterData_3B, dateTimePattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelativeDateTimeFormatterData_3B, qualitativeUnitMap, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelativeDateTimeFormatterData_3B, relUnitPatternMap, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_3B, 72, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_3B, entrySet, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_3B, keyType, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_3B, keyUniverse, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_3B, size, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_3B, vals, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24Loader_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24Loader_3B, ulocale, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, breakIterator, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, capitalizationContext, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, combinedDateAndTime, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, dateFormatSymbols, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, locale, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, numberFormat, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, patternMap, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, pluralRules, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, qualitativeUnitMap, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, style, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_3B, styleToDateFormatSymbolsWidth, 96, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, 328, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, abbreviatedDayPeriods, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, actualLocale, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, ampms, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, ampmsNarrow, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, capitalization, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, eraNames, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, eras, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, leapMonthPatterns, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, localPatternChars, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, months, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, narrowDayPeriods, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, narrowEras, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, narrowMonths, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, narrowWeekdays, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, quarters, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, requestedLocale, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, shortMonths, 144, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, shortQuarters, 152, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, shortWeekdays, 160, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, shortYearNames, 168, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, shortZodiacNames, 176, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, shorterWeekdays, 184, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneAbbreviatedDayPeriods, 192, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneMonths, 200, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneNarrowDayPeriods, 208, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneNarrowMonths, 216, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneNarrowWeekdays, 224, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneQuarters, 232, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneShortMonths, 240, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneShortQuarters, 248, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneShortWeekdays, 256, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneShorterWeekdays, 264, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneWeekdays, 272, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, standaloneWideDayPeriods, 280, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, timeSeparator, 288, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, validLocale, 296, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, weekdays, 304, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, wideDayPeriods, 312, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B, zoneStrings, 320, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_241_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24Style_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24Direction_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24AbsoluteUnit_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelativeUnit_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelativeDateTimeUnit_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24BreakCache_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24BreakCache_3B, fBoundaries, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24BreakCache_3B, fBufIdx, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24BreakCache_3B, fEndBufIdx, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24BreakCache_3B, fSideBuffer, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24BreakCache_3B, fStartBufIdx, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24BreakCache_3B, fStatuses, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24BreakCache_3B, fTextIdx, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24BreakCache_3B, this_240, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, 96, Landroid_2Ficu_2Ftext_2FBreakIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fBreakCache, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fBreakEngines, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fDictionaryCache, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fDictionaryCharCount, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fDone, 60, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fLookAheadMatches, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fPosition, 72, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fRData, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fRuleStatusIndex, 76, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_3B, fText, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, fBoundary, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, fBreaks, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, fFirstRuleStatusIndex, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, fLimit, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, fOtherRuleStatusIndex, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, fPositionInCache, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, fStart, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, fStatusIndex, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24DictionaryCache_3B, this_240, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24LookAheadResults_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24LookAheadResults_3B, fKeys, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24LookAheadResults_3B, fPositions, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedBreakIterator_24LookAheadResults_3B, fUsedSlotLimit, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnhandledBreakEngine_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnhandledBreakEngine_3B, fHandled, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedTransliterator_24Data_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedTransliterator_24Data_3B, ruleSet, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedTransliterator_24Data_3B, variableNames, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedTransliterator_24Data_3B, variables, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedTransliterator_24Data_3B, variablesBase, 12, 2)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliterationRuleSet_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRuleSet_3B, index, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRuleSet_3B, maxContextLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRuleSet_3B, ruleVector, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRuleSet_3B, rules, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, anteContext, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, anteContextLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, data, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, flags, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, key, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, keyLength, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, output, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, pattern, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, postContext, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterationRule_3B, segments, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringMatcher_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringMatcher_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringMatcher_3B, matchLimit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringMatcher_3B, matchStart, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringMatcher_3B, pattern, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringMatcher_3B, segmentNumber, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_24Style_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_3B, fmt, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_3B, preExponent, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_3B, style, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSearchIterator_24Search_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_24Search_3B, elementComparisonType__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_24Search_3B, internalBreakIter__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_24Search_3B, isCanonicalMatch__, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_24Search_3B, isForwardSearching__, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_24Search_3B, isOverlap__, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_24Search_3B, matchedIndex__, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_24Search_3B, reset__, 15, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_24Search_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSearchIterator_24ElementComparisonType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSearchIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_3B, breakIterator, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_3B, matchLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_3B, search__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSearchIterator_3B, targetText, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_24PatternItem_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_24PatternItem_3B, isNumeric, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_24PatternItem_3B, length, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_24PatternItem_3B, type, 14, 2)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSourceTargetUtility_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSourceTargetUtility_3B, sourceCache, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSourceTargetUtility_3B, sourceStrings, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSourceTargetUtility_3B, transform, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterator_3B, ID, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterator_3B, filter, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliterator_3B, maximumContextLength, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_3B, availableIDs, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_3B, registry, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_3B, specDAG, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24Spec_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24Spec_3B, isNextLocale, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24Spec_3B, isSpecLocale, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24Spec_3B, nextSpec, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24Spec_3B, res, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24Spec_3B, scriptName, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24Spec_3B, spec, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24Spec_3B, top, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_24SPUString_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_24SPUString_3B, fCharOrStrTableIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_24SPUString_3B, fStr, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_24SPUStringPool_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_24SPUStringPool_3B, fHash, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_24SPUStringPool_3B, fVec, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FVector_3B, 32, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_3B, capacityIncrement, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_3B, elementCount, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_3B, elementData, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, fKeySet, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, fKeyVec, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, fLineNum, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, fParseHexNum, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, fParseLine, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, fStringTable, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, fTable, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, fValueVec, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_3B, stringPool, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24SpoofData_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24SpoofData_3B, fCFUKeys, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24SpoofData_3B, fCFUStrings, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24SpoofData_3B, fCFUValues, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24SpoofData_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_3B, fAllowedCharsSet, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_3B, fAllowedLocales, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_3B, fChecks, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_3B, fRestrictionLevel, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_3B, fSpoofData, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24RestrictionLevel_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_3B, fAllowedCharsSet, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_3B, fAllowedLocales, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_3B, fChecks, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_3B, fRestrictionLevel, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_3B, fSpoofData, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24ScriptSet_3B, 28, Ljava_2Futil_2FBitSet_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24CheckResult_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24CheckResult_3B, checks, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24CheckResult_3B, numerics, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24CheckResult_3B, position, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSpoofChecker_24CheckResult_3B, restrictionLevel, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24ConfusableDataUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24SpoofData_24DefaultData_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24CEBuffer_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CEBuffer_3B, bufSize__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CEBuffer_3B, buf__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CEBuffer_3B, firstIx__, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CEBuffer_3B, limitIx__, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CEBuffer_3B, strSearch__, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24CEI_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CEI_3B, ce__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CEI_3B, highIndex__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CEI_3B, lowIndex__, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_3B, 104, Landroid_2Ficu_2Ftext_2FSearchIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, ceMask__, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, collator__, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, nfd__, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, pattern__, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, strength__, 44, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, textIter__, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, textProcessedIter__, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, toShift__, 88, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, utilIter__, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_3B, variableTop__, 92, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24Pattern_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24Pattern_3B, CELength__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24Pattern_3B, CE__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24Pattern_3B, PCELength__, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24Pattern_3B, PCE__, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24Pattern_3B, text__, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_3B, cei__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_3B, isShifted__, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_3B, pceBuffer__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_3B, strength__, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_3B, toShift__, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_3B, variableTop__, 36, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24PCEBuffer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24PCEBuffer_3B, bufferIndex__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24PCEBuffer_3B, buffer__, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24PCEI_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24PCEI_3B, ce__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24PCEI_3B, high__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24PCEI_3B, low__, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24Range_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24Range_3B, ixHigh__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24Range_3B, ixLow__, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24Match_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24Match_3B, limit__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24Match_3B, start__, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24RCEBuffer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24RCEBuffer_3B, bufferIndex__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24RCEBuffer_3B, buffer__, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24RCEI_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24RCEI_3B, ce__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24RCEI_3B, high__, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringSearch_24CollationPCE_24RCEI_3B, low__, 20, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24GMTOffsetField_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24GMTOffsetField_3B, __type, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24GMTOffsetField_3B, __width, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneNames_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24Factory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneNames_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24Cache_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24MatchInfo_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24MatchInfo_3B, __matchLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24MatchInfo_3B, __mzID, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24MatchInfo_3B, __nameType, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24MatchInfo_3B, __tzID, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24SingleID_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24SingleID_3B, basicID, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24SingleID_3B, canonID, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24SingleID_3B, filter, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24Specs_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24Specs_3B, filter, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24Specs_3B, sawSource, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24Specs_3B, source, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24Specs_3B, target, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_24Specs_3B, variant, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorIDParser_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorParser_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleBody_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, anchorEnd, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, anchorStart, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, ante, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, cursor, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, cursorOffset, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, cursorOffsetPos, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, nextSegmentNumber, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, post, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleHalf_3B, text, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, compoundFilter, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, curData, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, dataVector, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, direction, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, dotStandIn, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, idBlockVector, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, parseData, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, segmentObjects, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, segmentStandins, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, undefinedVariableName, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, variableLimit, 44, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, variableNames, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, variableNext, 46, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_3B, variablesVector, 96, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24ParseData_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24ParseData_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24AliasEntry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24AliasEntry_3B, alias, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24CompoundRBTEntry_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24CompoundRBTEntry_3B, ID, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24CompoundRBTEntry_3B, compoundFilter, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24CompoundRBTEntry_3B, dataVector, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24CompoundRBTEntry_3B, idBlockVector, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24LocaleEntry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24LocaleEntry_3B, direction, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24LocaleEntry_3B, rule, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24ResourceEntry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24ResourceEntry_3B, direction, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24ResourceEntry_3B, resource, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUTF16_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24EntryRange_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24EntryRange_3B, codepoint, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24EntryRange_3B, codepointEnd, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, codepoint, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, codepointEnd, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, endElement, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, endRange, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, nextElement, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, range, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, set, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, string, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetIterator_3B, stringIterator, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSetSpanner_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSetSpanner_3B, unicodeSet, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSetSpanner_24CountMethod_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSetSpanner_24TrimOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCalendar_24FormatConfiguration_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24FormatConfiguration_3B, cal, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24FormatConfiguration_3B, formatData, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24FormatConfiguration_3B, loc, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24FormatConfiguration_3B, override, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCalendar_24FormatConfiguration_3B, pattern, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCaseInsensitiveString_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCaseInsensitiveString_3B, folded, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCaseInsensitiveString_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCaseInsensitiveString_3B, string, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointMap_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrency_24CurrencyStringInfo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCurrency_24CurrencyStringInfo_3B, currencyString, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCurrency_24CurrencyStringInfo_3B, isoCode, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FGenderInfo_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FGenderInfo_24Cache_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGenderInfo_24Cache_3B, cache, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FGenderInfo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGenderInfo_3B, style, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FGenderInfo_24ListGenderStyle_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FGenderInfo_24Gender_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleData_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleData_24MeasurementSystem_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleData_24PaperSize_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleData_24PaperSize_3B, height, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleData_24PaperSize_3B, width, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleData_3B, bundle, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleData_3B, langBundle, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleData_3B, noSubstitute, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleMatcher_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LocalePatternMatcher_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LocalePatternMatcher_3B, lang, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LocalePatternMatcher_3B, level, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LocalePatternMatcher_3B, region, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LocalePatternMatcher_3B, script, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleMatcher_24Level_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24Level_3B, worst, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleMatcher_24OutputDouble_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24OutputDouble_3B, value, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, defaultLanguage, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, desiredLanguageToPossibleLocalesToMaxLocaleToData, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, languagePriorityList, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, localeToMaxLocaleAndWeight, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, matcherData, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, threshold, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, xDefaultLanguage, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, xFavorScript, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_3B, xLocaleMatcher, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LanguageMatcherData_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LanguageMatcherData_3B, frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LanguageMatcherData_3B, languageScores, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LanguageMatcherData_3B, matchingLanguages, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LanguageMatcherData_3B, regionScores, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24LanguageMatcherData_3B, scriptScores, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FLocaleMatcher_24ScoreData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24ScoreData_3B, frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24ScoreData_3B, level, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FLocaleMatcher_24ScoreData_3B, scores, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashSet_3B, 24, Ljava_2Futil_2FHashSet_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRow_24R3_3B, 24, Landroid_2Ficu_2Fimpl_2FRow_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRow_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRow_3B, frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRow_3B, items, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRow_24R2_3B, 24, Landroid_2Ficu_2Fimpl_2FRow_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRow_24R4_3B, 24, Landroid_2Ficu_2Fimpl_2FRow_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRow_24R5_3B, 24, Landroid_2Ficu_2Fimpl_2FRow_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRelation_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelation_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelation_3B, frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelation_3B, setComparatorParam, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelation_3B, setCreator, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FRange_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRange_3B, rule, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRange_3B, start, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FRangeValueIterator_24Element_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRangeValueIterator_24Element_3B, limit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRangeValueIterator_24Element_3B, start, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRangeValueIterator_24Element_3B, value, 20, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTimeZone_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_24Builder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FULocale_24Builder_3B, __locbld, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_24JDKLocaleHelper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FUResourceBundle_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, epochOffset, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, epochOffsetM1, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, epochOffsetP1, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, fromMax, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, fromMin, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, maxRound, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, minRound, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, toMax, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, toMin, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, units, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FUniversalTimeScale_24TimeScaleData_3B, unitsRound, 96, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FUniversalTimeScale_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FValueIterator_24Element_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FValueIterator_24Element_3B, integer, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FValueIterator_24Element_3B, value, 16, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FInt32Ref_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FInt32Ref_3B, value, 12, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FInt64Ref_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FInt64Ref_3B, value, 16, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FOs_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FInetSocketAddress_3B, 24, Ljava_2Fnet_2FSocketAddress_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetSocketAddress_3B, holder, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FInetSocketAddress_24InetSocketAddressHolder_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetSocketAddress_24InetSocketAddressHolder_3B, addr, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetSocketAddress_24InetSocketAddressHolder_3B, hostname, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetSocketAddress_24InetSocketAddressHolder_3B, port, 12, 4)
+__MRT_CLASS(Ljava_2Fnet_2FInetSocketAddress_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Fsystem_2FStructAddrinfo_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructAddrinfo_3B, ai__addr, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructAddrinfo_3B, ai__family, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructAddrinfo_3B, ai__flags, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructAddrinfo_3B, ai__next, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructAddrinfo_3B, ai__protocol, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructAddrinfo_3B, ai__socktype, 40, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FStructCapUserData_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructCapUserData_3B, effective, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructCapUserData_3B, inheritable, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructCapUserData_3B, permitted, 20, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FStructCapUserHeader_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructCapUserHeader_3B, pid, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructCapUserHeader_3B, version, 16, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FStructFlock_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructFlock_3B, l__len, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructFlock_3B, l__pid, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructFlock_3B, l__start, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructFlock_3B, l__type, 32, 2)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructFlock_3B, l__whence, 34, 2)
+__MRT_CLASS(Landroid_2Fsystem_2FStructStat_3B, 128, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__atim, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__atime, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__blksize, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__blocks, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__ctim, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__ctime, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__dev, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__gid, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__ino, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__mode, 80, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__mtim, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__mtime, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__nlink, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__rdev, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__size, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStat_3B, st__uid, 84, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FStructTimespec_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructTimespec_3B, tv__nsec, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructTimespec_3B, tv__sec, 24, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FStructStatVfs_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__bavail, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__bfree, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__blocks, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__bsize, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__favail, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__ffree, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__files, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__flag, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__frsize, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__fsid, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructStatVfs_3B, f__namemax, 96, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FStructIfaddrs_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructIfaddrs_3B, hwaddr, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructIfaddrs_3B, ifa__addr, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructIfaddrs_3B, ifa__broadaddr, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructIfaddrs_3B, ifa__flags, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructIfaddrs_3B, ifa__name, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructIfaddrs_3B, ifa__netmask, 48, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FStructPasswd_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructPasswd_3B, pw__dir, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructPasswd_3B, pw__gid, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructPasswd_3B, pw__name, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructPasswd_3B, pw__shell, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructPasswd_3B, pw__uid, 40, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FStructRlimit_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructRlimit_3B, rlim__cur, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructRlimit_3B, rlim__max, 24, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FStructLinger_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructLinger_3B, l__linger, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructLinger_3B, l__onoff, 16, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FStructTimeval_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructTimeval_3B, tv__sec, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructTimeval_3B, tv__usec, 24, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FStructUcred_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructUcred_3B, gid, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructUcred_3B, pid, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructUcred_3B, uid, 20, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FStructPollfd_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructPollfd_3B, events, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructPollfd_3B, fd, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructPollfd_3B, revents, 14, 2)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructPollfd_3B, userData, 24, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FStructGroupReq_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructGroupReq_3B, gr__group, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructGroupReq_3B, gr__interface, 12, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FStructUtsname_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructUtsname_3B, machine, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructUtsname_3B, nodename, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructUtsname_3B, release, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructUtsname_3B, sysname, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructUtsname_3B, version, 48, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FOsConstants_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Fsystem_2FStructIcmpHdr_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FStructIcmpHdr_3B, packet, 16, 8)
+__MRT_CLASS(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_24ContentSource_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_24ContentSource_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_24ContentSource_3B, limit, 12, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_24ContentSource_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_24ContentSource_3B, position, 32, 4)
+__MRT_CLASS(Ldalvik_2Fbytecode_2FOpcodeInfo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FAnnotatedStackTraceElement_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FAnnotatedStackTraceElement_3B, blockedOn, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FAnnotatedStackTraceElement_3B, heldLocks, 24, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FAnnotatedStackTraceElement_3B, stackTraceElement, 32, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FBlockGuard_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FCloseGuard_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FCloseGuard_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FCloseGuard_3B, closerNameOrAllocationInfo, 16, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDalvikLogging_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDexFile_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDexFile_24OptimizationInfo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexFile_24OptimizationInfo_3B, reason, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexFile_24OptimizationInfo_3B, status, 24, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDexFile_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexFile_3B, mCookie, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexFile_3B, mFileName, 24, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexFile_3B, mInternalCookie, 32, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDexPathList_24Element_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_24Element_3B, dexFile, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_24Element_3B, initialized, 12, 1)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_24Element_3B, path, 24, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_24Element_3B, pathIsDirectory, 32, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_24Element_3B, urlHandler, 40, 8)
+__MRT_CLASS(Llibcore_2Fio_2FClassPathURLStreamHandler_3B, 32, Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FHandler_3B)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FClassPathURLStreamHandler_3B, fileUri, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FClassPathURLStreamHandler_3B, jarFile, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarFile_3B, 112, Ljava_2Futil_2Fzip_2FZipFile_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_3B, hasCheckedSpecialAttributes, 80, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_3B, hasClassPathAttribute, 81, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_3B, jv, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_3B, jvInitialized, 82, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_3B, manEntry, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_3B, manifest, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_3B, verify, 83, 1)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarVerifier_3B, 160, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, anyToVerify, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, baos, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, csdomain, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, eagerValidation, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, emptyEnumeration, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, emptySigner, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, jarCodeSigners, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, lastURL, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, lastURLMap, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, manDig, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, manifestDigests, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, manifestRawBytes, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, parsingBlockOrSF, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, parsingMeta, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, pendingBlocks, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, sigFileData, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, sigFileSigners, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, signerCache, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, signerMap, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, signerToCodeSource, 136, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, urlToCodeSourceMap, 144, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_3B, verifiedSigners, 152, 8)
+__MRT_CLASS(Ljava_2Fio_2FByteArrayOutputStream_3B, 24, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FByteArrayOutputStream_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FByteArrayOutputStream_3B, count, 12, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FManifestDigester_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_3B, entries, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_3B, rawBytes, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Position_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Position_3B, endOfFirstLine, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Position_3B, endOfSection, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Position_3B, startOfNext, 20, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Entry_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Entry_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Entry_3B, lengthWithBlankLine, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Entry_3B, offset, 20, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Entry_3B, oldStyle, 24, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestDigester_24Entry_3B, rawBytes, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FMessageDigest_3B, 44, Ljava_2Fsecurity_2FMessageDigestSpi_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FMessageDigest_3B, algorithm, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FMessageDigest_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FMessageDigest_3B, state, 40, 4)
+__MRT_CLASS(Ljava_2Fsecurity_2FMessageDigestSpi_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FMessageDigestSpi_3B, tempArray, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_3B, createdDigests, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_3B, digests, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_3B, entry, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_3B, man, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_3B, manifestHashes, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_3B, name, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_3B, signers, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_3B, skip, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarEntry_3B, 136, Ljava_2Futil_2Fzip_2FZipEntry_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarEntry_3B, attr, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarEntry_3B, certs, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarEntry_3B, signers, 128, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipEntry_3B, 112, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, atime, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, comment, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, crc, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, csize, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, ctime, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, dataOffset, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, extra, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, flag, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, method, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, mtime, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, name, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, size, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipEntry_3B, xdostime, 104, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipFile_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, closeRequested, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, fileToRemoveOnClose, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, guard, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, inflaterCache, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, jzfile, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, locsig, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, name, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, streams, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, total, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_3B, zc, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipCoder_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipCoder_3B, cs, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipCoder_3B, dec, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipCoder_3B, enc, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipCoder_3B, isUTF8, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipCoder_3B, utf8, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FInflater_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflater_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflater_3B, bytesRead, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflater_3B, bytesWritten, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflater_3B, finished, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflater_3B, guard, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflater_3B, len, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflater_3B, needDict, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflater_3B, off, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflater_3B, zsRef, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZStreamRef_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZStreamRef_3B, address, 16, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FHandler_3B, 12, Ljava_2Fnet_2FURLStreamHandler_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDexPathList_24NativeLibraryElement_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_24NativeLibraryElement_3B, initialized, 12, 1)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_24NativeLibraryElement_3B, path, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_24NativeLibraryElement_3B, urlHandler, 24, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_24NativeLibraryElement_3B, zipDir, 32, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDexPathList_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_3B, definingContext, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_3B, dexElements, 24, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_3B, dexElementsSuppressedExceptions, 32, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_3B, nativeLibraryDirectories, 40, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_3B, nativeLibraryPathElements, 48, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexPathList_3B, systemNativeLibraryDirectories, 56, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FEmulatedStackFrame_24Range_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_24Range_3B, numBytes, 12, 4)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_24Range_3B, numReferences, 16, 4)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_24Range_3B, referencesStart, 20, 4)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_24Range_3B, stackFrameStart, 24, 4)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodType_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodType_3B, form, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodType_3B, methodDescriptor, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodType_3B, ptypes, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodType_3B, rtype, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodType_3B, wrapAlt, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodTypeForm_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodTypeForm_3B, argCounts, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodTypeForm_3B, argToSlotTable, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodTypeForm_3B, basicType, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodTypeForm_3B, erasedType, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodTypeForm_3B, primCounts, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodTypeForm_3B, slotToArgTable, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodType_24ConcurrentWeakInternSet_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodType_24ConcurrentWeakInternSet_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodType_24ConcurrentWeakInternSet_3B, stale, 24, 8)
+__MRT_CLASS(Ljava_2Flang_2FIndexOutOfBoundsException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameAccessor_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameAccessor_3B, argumentIdx, 12, 4)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameAccessor_3B, frame, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameAccessor_3B, frameBuf, 24, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameAccessor_3B, numArgs, 32, 4)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameAccessor_3B, referencesOffset, 36, 4)
+__MRT_CLASS(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, callsiteType, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, references, 24, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, stackFrame, 32, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FEmulatedStackFrame_3B, type, 40, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameReader_3B, 40, Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameAccessor_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameWriter_3B, 40, Ldalvik_2Fsystem_2FEmulatedStackFrame_24StackFrameAccessor_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FNativeStart_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FRuntimeHooks_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FSocketTagger_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FDatagramSocket_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, bound, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, bytesLeftToFilter, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, closeLock, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, closed, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, connectState, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, connectedAddress, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, connectedPort, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, created, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, explicitFilter, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, impl, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, oldImpl, 44, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_3B, pendingConnectException, 56, 8)
+__MRT_CLASS(Ljava_2Fnet_2FDatagramSocketImpl_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocketImpl_3B, fd, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocketImpl_3B, localPort, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocketImpl_3B, socket, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FDatagramPacket_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramPacket_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramPacket_3B, buf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramPacket_3B, bufLength, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramPacket_3B, length, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramPacket_3B, offset, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramPacket_3B, port, 40, 4)
+__MRT_CLASS(Ljava_2Fnet_2FSocketException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FDatagramChannel_3B, 80, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FSelectorProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FPipe_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FPipe_24SinkChannel_3B, 80, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B, 80, Ljava_2Fnio_2Fchannels_2FSelectableChannel_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B, blocking, 40, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B, keyCount, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B, keyLock, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B, keys, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B, provider, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B, regLock, 72, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FSelectionKey_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FSelectionKey_3B, attachment, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceFieldUpdater_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FSelectableChannel_3B, 40, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FSelector_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FPipe_24SourceChannel_3B, 80, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelector_3B, 48, Ljava_2Fnio_2Fchannels_2FSelector_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelector_3B, cancelledKeys, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelector_3B, interruptor, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelector_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelector_3B, selectorOpen, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicBoolean_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicBoolean_3B, value, 12, 4)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectionKey_3B, 25, Ljava_2Fnio_2Fchannels_2FSelectionKey_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectionKey_3B, valid, 24, 1)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FServerSocketChannel_3B, 80, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FSocketChannel_3B, 80, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectableChannel_3B)
+__MRT_CLASS(Ljava_2Fnet_2FSocket_3B, 35, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_3B, bound, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_3B, closeLock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_3B, closed, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_3B, connected, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_3B, created, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_3B, impl, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_3B, oldImpl, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_3B, shutIn, 33, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_3B, shutOut, 34, 1)
+__MRT_CLASS(Ljava_2Fnet_2FSocketImpl_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketImpl_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketImpl_3B, fd, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketImpl_3B, localport, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketImpl_3B, port, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketImpl_3B, serverSocket, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketImpl_3B, socket, 48, 8)
+__MRT_CLASS(Ljava_2Fnet_2FServerSocket_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FServerSocket_3B, bound, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FServerSocket_3B, closeLock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FServerSocket_3B, closed, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FServerSocket_3B, created, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FServerSocket_3B, impl, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FServerSocket_3B, oldImpl, 15, 1)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FMembershipKey_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FTemporaryDirectory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FVMDebug_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FVMRuntime_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FVMRuntime_3B, allocationCount, 16, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FVMRuntime_3B, notifyNativeInterval, 12, 4)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FVMRuntime_3B, targetSdkVersion, 24, 4)
+__MRT_CLASS(Ldalvik_2Fsystem_2FVMStack_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FVersionCodes_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FZygoteHooks_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fbeans_2FChangeListenerMap_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fbeans_2FChangeListenerMap_3B, map, 16, 8)
+__MRT_CLASS(Ljava_2Fbeans_2FPropertyChangeSupport_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FBits_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FDefaultFileSystem_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FDeleteOnExitHook_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FExpiringCache_24Entry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FExpiringCache_24Entry_3B, timestamp, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FExpiringCache_24Entry_3B, val, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FExpiringCache_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FExpiringCache_3B, MAX__ENTRIES, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FExpiringCache_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FExpiringCache_3B, millisUntilExpiration, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FExpiringCache_3B, queryCount, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FExpiringCache_3B, queryOverflow, 36, 4)
+__MRT_CLASS(Ljava_2Fio_2FFile_24TempDirectory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24Caches_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectOutputStream_24Caches_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_24Caches_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_24EntryFuture_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24EntryFuture_3B, entry, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24EntryFuture_3B, owner, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_24MemberSignature_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24MemberSignature_3B, member, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24MemberSignature_3B, name, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24MemberSignature_3B, signature, 32, 8)
+__MRT_CLASS(Ljava_2Fio_2FStreamTokenizer_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, LINENO, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, ctype, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, eolIsSignificantP, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, forceLower, 33, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, input, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, nval, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, peekc, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, pushedBack, 34, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, reader, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, slashSlashCommentsP, 35, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, slashStarCommentsP, 64, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, sval, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStreamTokenizer_3B, ttype, 68, 4)
+__MRT_CLASS(Ljava_2Flang_2FAndroidHardcodedSystemProperties_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FByte_24ByteCache_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FByte_3B, 13, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FByte_3B, value, 12, 1)
+__MRT_CLASS(Ljava_2Flang_2FCaseMapper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FCharacter_24CharacterCache_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FCharacter_24Subset_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FCharacter_24Subset_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FClass_24Caches_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FClassLoader_24SystemClassLoader_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FCompiler_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FDaemons_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FDaemons_24Daemon_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDaemons_24Daemon_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDaemons_24Daemon_3B, postZygoteFork, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDaemons_24Daemon_3B, thread, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCountDownLatch_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCountDownLatch_3B, sync, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCountDownLatch_24Sync_3B, 48, Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B)
+__MRT_CLASS(Ljava_2Flang_2FDexCache_3B, 112, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, dexFile, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, location, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, numPreResolvedStrings, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, numResolvedCallSites, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, numResolvedFields, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, numResolvedMethodTypes, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, numResolvedMethods, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, numResolvedTypes, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, numStrings, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, preResolvedStrings, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, resolvedCallSites, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, resolvedFields, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, resolvedMethodTypes, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, resolvedMethods, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, resolvedTypes, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDexCache_3B, strings, 104, 8)
+__MRT_CLASS(Ljava_2Flang_2FInteger_24IntegerCache_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FLong_24LongCache_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FMath_24RandomNumberGeneratorHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FMath_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FPackage_241PackageInfoProxy_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FPackage_241PackageInfoProxy_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcess_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_24Redirect_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_24Redirect_24Type_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessBuilder_3B, command, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessBuilder_3B, directory, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessBuilder_3B, environment, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessBuilder_3B, redirectErrorStream, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessBuilder_3B, redirects, 40, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24ExternalData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24ExternalData_3B, bytes, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24ExternalData_3B, str, 24, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FRuntime_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FRuntime_3B, mLibPaths, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FRuntime_3B, shutdownHooks, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FRuntime_3B, shuttingDown, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FRuntime_3B, tracingMethods, 13, 1)
+__MRT_CLASS(Ljava_2Flang_2FShort_24ShortCache_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FShort_3B, 14, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FShort_3B, value, 12, 2)
+__MRT_CLASS(Ljava_2Flang_2FStrictMath_24RandomNumberGeneratorHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FStrictMath_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FString_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FStringFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FSystem_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FConsole_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_3B, cs, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_3B, formatter, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_3B, out, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_3B, pw, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_3B, rcb, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_3B, readLock, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_3B, reader, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_3B, writeLock, 72, 8)
+__MRT_CLASS(Ljava_2Fio_2FFileOutputStream_3B, 64, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileOutputStream_3B, append, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileOutputStream_3B, channel, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileOutputStream_3B, closeLock, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileOutputStream_3B, closed, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileOutputStream_3B, fd, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileOutputStream_3B, guard, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileOutputStream_3B, isFdOwner, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileOutputStream_3B, path, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileOutputStream_3B, tracker, 56, 8)
+__MRT_CLASS(Llibcore_2Fio_2FIoTracker_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FIoTracker_3B, isOpen, 12, 1)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FIoTracker_3B, mode, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FIoTracker_3B, opCount, 24, 4)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FIoTracker_3B, totalByteCount, 28, 4)
+__MRT_CLASS(Llibcore_2Fio_2FIoTracker_24Mode_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Flang_2FThread_24Caches_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FThrowable_24SentinelHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FVMClassLoader_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FCallSite_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FCallSite_3B, target, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodHandle_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandle_3B, artFieldOrMethod, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandle_3B, cachedSpreadInvoker, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandle_3B, handleKind, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandle_3B, nominalType, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandle_3B, type, 40, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FWrongMethodTypeException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FLambdaMetafactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodHandles_24Lookup_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandles_24Lookup_3B, allowedModes, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandles_24Lookup_3B, lookupClass, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FVarHandle_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FVarHandle_3B, accessModesBitMask, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FVarHandle_3B, coordinateType0, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FVarHandle_3B, coordinateType1, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FVarHandle_3B, varType, 32, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FVarHandle_24AccessMode_3B, 40, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FVarHandle_24AccessMode_3B, at, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FVarHandle_24AccessMode_3B, methodName, 32, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FVarHandle_24AccessType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodHandleNatives_24Constants_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodHandleNatives_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodHandleStatics_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FError_3B, 56, Ljava_2Flang_2FThrowable_3B)
+__MRT_CLASS(Ljava_2Flang_2FInternalError_3B, 56, Ljava_2Flang_2FVirtualMachineError_3B)
+__MRT_CLASS(Ljava_2Flang_2FVirtualMachineError_3B, 56, Ljava_2Flang_2FError_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodHandles_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodHandleImpl_3B, 56, Ljava_2Flang_2Finvoke_2FMethodHandle_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandleImpl_3B, info, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodHandleImpl_24HandleInfo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandleImpl_24HandleInfo_3B, handle, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodHandleImpl_24HandleInfo_3B, member, 24, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FVarHandle_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FFinalizerReference_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FFinalizerReference_24Sentinel_3B, 13, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FFinalizerReference_24Sentinel_3B, finalized, 12, 1)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FReference_24SinkHolder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FReference_24SinkHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FArray_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FModifier_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FProxy_24KeyX_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FProxy_24KeyX_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FProxy_24KeyX_3B, refs, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FWeakCache_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_3B, refQueue, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_3B, reverseMap, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_3B, subKeyFactory, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_3B, valueFactory, 48, 8)
+__MRT_CLASS(Ljava_2Fmath_2FBigDecimal_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fmath_2FBitLevel_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fmath_2FConversion_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fmath_2FDivision_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fmath_2FLogical_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fmath_2FMultiplication_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fmath_2FNativeBN_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fmath_2FPrimality_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FAddressCache_24AddressCacheEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAddressCache_24AddressCacheEntry_3B, expiryNanos, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAddressCache_24AddressCacheEntry_3B, value, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FAddressCache_24AddressCacheKey_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAddressCache_24AddressCacheKey_3B, mHostname, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAddressCache_24AddressCacheKey_3B, mNetId, 12, 4)
+__MRT_CLASS(Ljava_2Fnet_2FAddressCache_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAddressCache_3B, cache, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FAuthenticator_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAuthenticator_3B, requestingAuthType, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAuthenticator_3B, requestingHost, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAuthenticator_3B, requestingPort, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAuthenticator_3B, requestingPrompt, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAuthenticator_3B, requestingProtocol, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAuthenticator_3B, requestingScheme, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAuthenticator_3B, requestingSite, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAuthenticator_3B, requestingURL, 64, 8)
+__MRT_CLASS(Ljava_2Fnet_2FAuthenticator_24RequestorType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnet_2FPasswordAuthentication_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FPasswordAuthentication_3B, password, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FPasswordAuthentication_3B, userName, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FCacheRequest_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FCacheResponse_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FCookieHandler_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, comment, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, commentURL, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, domain, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, header, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, httpOnly, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, maxAge, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, name, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, path, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, portlist, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, secure, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, toDiscard, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, value, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, version, 88, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpCookie_3B, whenCreated, 96, 8)
+__MRT_CLASS(Ljava_2Fnet_2FDefaultDatagramSocketImplFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FDefaultInterface_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FIDN_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FInet6Address_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FInet6Address_24Inet6AddressHolder_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInet6Address_24Inet6AddressHolder_3B, ipaddress, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInet6Address_24Inet6AddressHolder_3B, scope__id, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInet6Address_24Inet6AddressHolder_3B, scope__id__set, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInet6Address_24Inet6AddressHolder_3B, scope__ifname, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInet6Address_24Inet6AddressHolder_3B, scope__ifname__set, 25, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInet6Address_24Inet6AddressHolder_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Fnet_2FInet6Address_3B, 40, Ljava_2Fnet_2FInetAddress_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInet6Address_3B, holder6, 32, 8)
+__MRT_CLASS(Ljava_2Fnet_2FInetAddressContainer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInetAddressContainer_3B, addr, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FParts_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FParts_3B, path, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FParts_3B, query, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FParts_3B, ref, 32, 8)
+__MRT_CLASS(Ljava_2Fnet_2FProxySelector_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FResponseCache_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FSocketSecrets_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FStandardSocketOptions_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FURI_24Parser_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_24Parser_3B, input, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_24Parser_3B, ipv6byteCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_24Parser_3B, requireServerAuthority, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURI_24Parser_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLDecoder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FURLEncoder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2FBits_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2FDirectByteBuffer_24MemoryRef_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDirectByteBuffer_24MemoryRef_3B, allocatedAddress, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDirectByteBuffer_24MemoryRef_3B, buffer, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDirectByteBuffer_24MemoryRef_3B, isAccessible, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDirectByteBuffer_24MemoryRef_3B, isFreed, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDirectByteBuffer_24MemoryRef_3B, offset, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDirectByteBuffer_24MemoryRef_3B, originalBufferObject, 40, 8)
+__MRT_CLASS(Ljava_2Fnio_2FNIOAccess_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2FNioUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FAsynchronousChannelGroup_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FAsynchronousChannelGroup_3B, provider, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FAsynchronousChannelProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FAsynchronousServerSocketChannel_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FAsynchronousServerSocketChannel_3B, provider, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FAsynchronousSocketChannel_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FAsynchronousSocketChannel_3B, provider, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FChannels_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FAsynchronousChannelProvider_24ProviderHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FModifiedUtf8_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FStandardCharsets_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2Fspi_2FCharsetProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FCopyMoveHelper_24CopyOptions_3B, 15, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FCopyMoveHelper_24CopyOptions_3B, copyAttributes, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FCopyMoveHelper_24CopyOptions_3B, followLinks, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FCopyMoveHelper_24CopyOptions_3B, replaceExisting, 14, 1)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FCopyMoveHelper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileSystems_24DefaultFileSystemHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileSystems_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileTreeWalker_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24DirectoryNode_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24DirectoryNode_3B, dir, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24DirectoryNode_3B, iterator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24DirectoryNode_3B, key, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24DirectoryNode_3B, skipped, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24DirectoryNode_3B, stream, 40, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24Event_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24Event_3B, attrs, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24Event_3B, file, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24Event_3B, ioe, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24Event_3B, type, 40, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileTreeWalker_24EventType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileVisitResult_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFiles_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFiles_24FileTypeDetectors_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fspi_2FFileTypeDetector_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFiles_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileVisitOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FPaths_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FStandardWatchEventKinds_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FTempFileHelper_24PosixPermissions_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FTempFileHelper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FSecureRandom_3B, 96, Ljava_2Futil_2FRandom_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureRandom_3B, algorithm, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureRandom_3B, counter, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureRandom_3B, digest, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureRandom_3B, provider, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureRandom_3B, randomBytes, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureRandom_3B, randomBytesUsed, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureRandom_3B, secureRandomSpi, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureRandom_3B, state, 88, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FSecureRandomSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_24Builder_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_24Builder_3B, flags, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_24Builder_3B, perms, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_24Builder_3B, type, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_24Builder_3B, who, 40, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntryType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_3B, flags, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_3B, perms, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_3B, type, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntry_3B, who, 40, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntryFlag_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FAclEntryPermission_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FFileTime_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FPosixFilePermissions_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FAccessController_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FAlgorithmParameters_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FAlgorithmParameters_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FAlgorithmParameters_3B, initialized, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FAlgorithmParameters_3B, paramSpi, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FAlgorithmParameters_3B, provider, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FAlgorithmParametersSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FAlgorithmParameterGenerator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FAlgorithmParameterGenerator_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FAlgorithmParameterGenerator_3B, paramGenSpi, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FAlgorithmParameterGenerator_3B, provider, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FAlgorithmParameterGeneratorSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyFactory_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyFactory_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyFactory_3B, lock, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyFactory_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyFactory_3B, serviceIterator, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyFactory_3B, spi, 48, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyFactorySpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyPairGeneratorSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyPair_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPair_3B, privateKey, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPair_3B, publicKey, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24Builder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_3B, initialized, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_3B, keyStoreSpi, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_3B, provider, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_3B, type, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStoreSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FPolicy_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FPolicySpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FProvider_24EngineDescription_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24EngineDescription_3B, constructorParameterClass, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24EngineDescription_3B, constructorParameterClassName, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24EngineDescription_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24EngineDescription_3B, supportsParameter, 12, 1)
+__MRT_CLASS(Ljava_2Fsecurity_2FProvider_24UString_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24UString_3B, lowerString, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FProvider_24UString_3B, string, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FSecureRandom_24StrongPatternHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FSecurity_24ProviderProperty_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecurity_24ProviderProperty_3B, className, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecurity_24ProviderProperty_3B, provider, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FSecurity_241_3B, 13, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecurity_241_3B, val_24pa, 12, 1)
+__MRT_CLASS(Ljava_2Fsecurity_2FSecurity_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FSignatureSpi_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignatureSpi_3B, appRandom, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCRL_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCRL_3B, type, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathBuilder_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPathBuilder_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPathBuilder_3B, builderSpi, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPathBuilder_3B, provider, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathBuilderSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathValidator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPathValidator_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPathValidator_3B, provider, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPathValidator_3B, validatorSpi, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathValidatorSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertStore_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertStore_3B, params, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertStore_3B, provider, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertStore_3B, storeSpi, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertStore_3B, type, 40, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertStoreSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FNoSuchAlgorithmException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FGeneralSecurityException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificateFactory_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificateFactory_3B, certFacSpi, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificateFactory_3B, provider, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificateFactory_3B, type, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificateFactorySpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FPolicyQualifierInfo_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPolicyQualifierInfo_3B, mData, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPolicyQualifierInfo_3B, mEncoded, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPolicyQualifierInfo_3B, mId, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPolicyQualifierInfo_3B, pqiString, 40, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FTrustAnchor_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FTrustAnchor_3B, caName, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FTrustAnchor_3B, caPrincipal, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FTrustAnchor_3B, nc, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FTrustAnchor_3B, ncBytes, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FTrustAnchor_3B, pubKey, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FTrustAnchor_3B, trustedCert, 56, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2Fx500_2FX500Principal_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2Fx500_2FX500Principal_3B, thisX500Name, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, allAvaList, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, canonicalDn, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, dn, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, encoded, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, names, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, rdnList, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, rfc1779Dn, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, rfc2253Dn, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX500Name_3B, x500Principal, 80, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FRDN_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FRDN_3B, assertion, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FRDN_3B, avaList, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FRDN_3B, canonicalString, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FAVA_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAVA_3B, oid, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAVA_3B, value, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FObjectIdentifier_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FObjectIdentifier_3B, componentLen, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FObjectIdentifier_3B, components, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FObjectIdentifier_3B, componentsCalculated, 24, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FObjectIdentifier_3B, encoding, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FObjectIdentifier_3B, stringForm, 40, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDerInputBuffer_3B, 32, Ljava_2Fio_2FByteArrayInputStream_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FBitArray_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FBitArray_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FBitArray_3B, repn, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FByteArrayInputStream_3B, 32, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FByteArrayInputStream_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FByteArrayInputStream_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FByteArrayInputStream_3B, mark, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FByteArrayInputStream_3B, pos, 28, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDerInputStream_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerInputStream_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerInputStream_3B, tag, 12, 1)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDerValue_3B, 41, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerValue_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerValue_3B, data, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerValue_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerValue_3B, originalEncodedForm, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerValue_3B, tag, 40, 1)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDerOutputStream_3B, 24, Ljava_2Fio_2FByteArrayOutputStream_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FByteArrayLexOrder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FByteArrayTagOrder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FNameConstraintsExtension_3B, 56, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FNameConstraintsExtension_3B, excluded, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FNameConstraintsExtension_3B, hasMax, 40, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FNameConstraintsExtension_3B, hasMin, 41, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FNameConstraintsExtension_3B, minMaxValid, 42, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FNameConstraintsExtension_3B, permitted, 48, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FGeneralSubtrees_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FGeneralSubtrees_3B, trees, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FGeneralSubtree_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FGeneralSubtree_3B, maximum, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FGeneralSubtree_3B, minimum, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FGeneralSubtree_3B, myhash, 20, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FGeneralSubtree_3B, name, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FGeneralName_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FGeneralName_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FX509Certificate_3B, 40, Ljava_2Fsecurity_2Fcert_2FCertificate_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509Certificate_3B, issuerX500Principal, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509Certificate_3B, subjectX500Principal, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FExtension_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FExtension_3B, critical, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FExtension_3B, extensionId, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FExtension_3B, extensionValue, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FECParameterSpec_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECParameterSpec_3B, curve, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECParameterSpec_3B, curveName, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECParameterSpec_3B, g, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECParameterSpec_3B, h, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECParameterSpec_3B, n, 40, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FEllipticCurve_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FEllipticCurve_3B, a, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FEllipticCurve_3B, b, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FEllipticCurve_3B, field, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FEllipticCurve_3B, seed, 40, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FECPoint_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECPoint_3B, x, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECPoint_3B, y, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FRSAOtherPrimeInfo_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAOtherPrimeInfo_3B, crtCoefficient, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAOtherPrimeInfo_3B, prime, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAOtherPrimeInfo_3B, primeExponent, 32, 8)
+__MRT_CLASS(Ljava_2Fsql_2FDate_3B, 32, Ljava_2Futil_2FDate_3B)
+__MRT_CLASS(Ljava_2Futil_2FCalendar_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, areAllFieldsSet, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, areFieldsSet, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, fields, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, firstDayOfWeek, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, isSet, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, isTimeSet, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, lenient, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, minimalDaysInFirstWeek, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, nextStamp, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, serialVersionOnStream, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, sharedZone, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, stamp, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, time, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_3B, zone, 72, 8)
+__MRT_CLASS(Ljava_2Ftext_2FDateFormatSymbols_3B, 168, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, ampms, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, cachedHashCode, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, eras, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, isZoneStringsSet, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, lastZoneIndex, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, localPatternChars, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, locale, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, months, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, serialVersionOnStream, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, shortMonths, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, shortStandAloneMonths, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, shortStandAloneWeekdays, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, shortWeekdays, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, standAloneMonths, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, standAloneWeekdays, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, tinyMonths, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, tinyStandAloneMonths, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, tinyStandAloneWeekdays, 136, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, tinyWeekdays, 144, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, weekdays, 152, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormatSymbols_3B, zoneStrings, 160, 8)
+__MRT_CLASS(Llibcore_2Ficu_2FLocaleData_3B, 384, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, NaN, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, amPm, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, currencyPattern, 32, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, currencySymbol, 40, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, decimalSeparator, 12, 2)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, eras, 48, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, exponentSeparator, 56, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, firstDayOfWeek, 64, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, fullDateFormat, 72, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, fullTimeFormat, 80, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, groupingSeparator, 14, 2)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, infinity, 88, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, integerPattern, 96, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, internationalCurrencySymbol, 104, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, longDateFormat, 112, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, longMonthNames, 120, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, longStandAloneMonthNames, 128, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, longStandAloneWeekdayNames, 136, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, longTimeFormat, 144, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, longWeekdayNames, 152, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, mediumDateFormat, 160, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, mediumTimeFormat, 168, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, minimalDaysInFirstWeek, 176, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, minusSign, 184, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, monetarySeparator, 192, 2)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, narrowAm, 200, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, narrowPm, 208, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, numberPattern, 216, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, patternSeparator, 194, 2)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, perMill, 224, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, percent, 232, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, percentPattern, 240, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, shortDateFormat, 248, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, shortMonthNames, 256, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, shortStandAloneMonthNames, 264, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, shortStandAloneWeekdayNames, 272, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, shortTimeFormat, 280, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, shortWeekdayNames, 288, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, timeFormat__Hm, 296, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, timeFormat__Hms, 304, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, timeFormat__hm, 312, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, timeFormat__hms, 320, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, tinyMonthNames, 328, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, tinyStandAloneMonthNames, 336, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, tinyStandAloneWeekdayNames, 344, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, tinyWeekdayNames, 352, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, today, 360, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, tomorrow, 368, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, yesterday, 376, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FLocaleData_3B, zeroDigit, 196, 2)
+__MRT_CLASS(Ljava_2Fsql_2FRowIdLifetime_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLWarning_3B, 76, Ljava_2Fsql_2FSQLException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLException_3B, 76, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FSQLException_3B, SQLState, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FSQLException_3B, next, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FSQLException_3B, vendorCode, 72, 4)
+__MRT_CLASS(Ljava_2Fsql_2FTime_3B, 32, Ljava_2Futil_2FDate_3B)
+__MRT_CLASS(Ljava_2Fsql_2FTimestamp_3B, 36, Ljava_2Futil_2FDate_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FTimestamp_3B, nanos, 32, 4)
+__MRT_CLASS(Ljava_2Fsql_2FDriverPropertyInfo_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDriverPropertyInfo_3B, choices, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDriverPropertyInfo_3B, description, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDriverPropertyInfo_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDriverPropertyInfo_3B, required, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDriverPropertyInfo_3B, value, 40, 8)
+__MRT_CLASS(Ljava_2Fsql_2FDriverInfo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDriverInfo_3B, driver, 16, 8)
+__MRT_CLASS(Ljava_2Fsql_2FDriverManager_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljava_2Fsql_2FTypes_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftext_2FAnnotation_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAnnotation_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Ftext_2FAttributedString_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_3B, runArraySize, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_3B, runAttributeValues, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_3B, runAttributes, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_3B, runCount, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_3B, runStarts, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_3B, text, 48, 8)
+__MRT_CLASS(Ljava_2Ftext_2FBidi_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FBidi_3B, bidiBase, 16, 8)
+__MRT_CLASS(Ljava_2Ftext_2FCalendarBuilder_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FCalendarBuilder_3B, field, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FCalendarBuilder_3B, maxFieldIndex, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FCalendarBuilder_3B, nextStamp, 24, 4)
+__MRT_CLASS(Ljava_2Ftext_2FCollationElementIterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FCollationElementIterator_3B, icuIterator, 16, 8)
+__MRT_CLASS(Ljava_2Ftext_2FDecimalFormat_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftext_2FEntryPair_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FEntryPair_3B, entryName, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FEntryPair_3B, fwd, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FEntryPair_3B, value, 24, 4)
+__MRT_CLASS(Ljava_2Ftext_2FFieldPosition_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftext_2FMergeCollation_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMergeCollation_3B, BITARRAYMASK, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMergeCollation_3B, BYTEMASK, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMergeCollation_3B, BYTEPOWER, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMergeCollation_3B, excess, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMergeCollation_3B, lastEntry, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMergeCollation_3B, patterns, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMergeCollation_3B, saveEntry, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FMergeCollation_3B, statusArray, 56, 8)
+__MRT_CLASS(Ljava_2Ftext_2FPatternEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FPatternEntry_3B, chars, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FPatternEntry_3B, extension, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FPatternEntry_3B, strength, 12, 4)
+__MRT_CLASS(Ljava_2Ftext_2FNormalizer_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftext_2FNormalizer_24Form_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNormalizer_24Form_3B, icuMode, 24, 8)
+__MRT_CLASS(Ljava_2Ftext_2FPatternEntry_24Parser_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FPatternEntry_24Parser_3B, i, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FPatternEntry_24Parser_3B, newChars, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FPatternEntry_24Parser_3B, newExtension, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FPatternEntry_24Parser_3B, pattern, 32, 8)
+__MRT_CLASS(Ljava_2Ftime_2FDuration_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FDuration_24DurationUnits_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FInstant_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FLocalDate_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FLocalDateTime_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FLocalTime_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FMonth_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FMonthDay_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FOffsetDateTime_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FOffsetTime_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FYear_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FYearMonth_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FZonedDateTime_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FChronoLocalDateImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FChronoLocalDateTimeImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FChronoZonedDateTime_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FChronoZonedDateTimeImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FHijrahChronology_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FHijrahDate_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FJapaneseChronology_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FJapaneseDate_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FMinguoChronology_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FMinguoDate_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FThaiBuddhistChronology_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FThaiBuddhistDate_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_3B, c0, 12, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_3B, child, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_3B, key, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_3B, sibling, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_3B, value, 40, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_241_3B, 32, Ljava_2Ftime_2Fformat_2FDateTimeTextProvider_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_241_3B, val_24store, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_3B, active, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_3B, optional, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_3B, padNextChar, 14, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_3B, padNextWidth, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_3B, parent, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_3B, printerParsers, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_3B, valueParserIndex, 28, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24NumberPrinterParser_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24NumberPrinterParser_3B, field, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24NumberPrinterParser_3B, maxWidth, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24NumberPrinterParser_3B, minWidth, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24NumberPrinterParser_3B, signStyle, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24NumberPrinterParser_3B, subsequentWidth, 28, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FSignStyle_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeTextProvider_24LocaleStore_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeTextProvider_24LocaleStore_3B, parsable, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeTextProvider_24LocaleStore_3B, valueTextMap, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeTextProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeTextProvider_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FZoneName_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FChronoField_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FIsoFields_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FIsoFields_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FJulianFields_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FTemporalAdjusters_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FTemporalQueries_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FZoneOffsetTransitionRule_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FZoneRulesProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FAbstractList_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArrayDeque_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArrayList_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArrayPrefixHelpers_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArrays_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FBase64_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FBase64_24Decoder_3B, 14, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24Decoder_3B, isMIME, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24Decoder_3B, isURL, 13, 1)
+__MRT_CLASS(Ljava_2Futil_2FBase64_24Encoder_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24Encoder_3B, doPadding, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24Encoder_3B, isURL, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24Encoder_3B, linemax, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24Encoder_3B, newline, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FBase64_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FCalendar_24AvailableCalendarTypes_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FCalendar_24Builder_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, fields, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, firstDayOfWeek, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, instant, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, lenient, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, locale, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, maxFieldIndex, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, minimalDaysInFirstWeek, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, nextStamp, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, type, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCalendar_24Builder_3B, zone, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FCalendar_24CalendarAccessControlContext_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FComparableTimSort_3B, 60, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparableTimSort_3B, a, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparableTimSort_3B, minGallop, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparableTimSort_3B, runBase, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparableTimSort_3B, runLen, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparableTimSort_3B, stackSize, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparableTimSort_3B, tmp, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparableTimSort_3B, tmpBase, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparableTimSort_3B, tmpLen, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FComparators_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FDualPivotQuicksort_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FFormattableFlags_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FFormatter_24Conversion_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FFormatter_24DateTime_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FFormatter_24Flags_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24Flags_3B, flags, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2FFormatter_24FormatSpecifier_24BigDecimalLayout_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_24BigDecimalLayout_3B, dot, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_24BigDecimalLayout_3B, exp, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_24BigDecimalLayout_3B, mant, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_24BigDecimalLayout_3B, scale, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_24BigDecimalLayout_3B, this_241, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B, c, 12, 2)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B, dt, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B, f, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B, index, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B, precision, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B, this_240, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifier_3B, width, 40, 4)
+__MRT_CLASS(Ljava_2Futil_2FFormatter_24BigDecimalLayoutForm_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, conv, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, flags, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, format, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, fs, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, index, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, precision, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, tT, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, this_240, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FormatSpecifierParser_3B, width, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24HashIterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashIterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashIterator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashIterator_3B, index, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashIterator_3B, next, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B, est, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B, expectedModCount, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B, fence, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B, index, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B, map, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashtable_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapSpliterator_3B, est, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapSpliterator_3B, expectedModCount, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapSpliterator_3B, fence, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapSpliterator_3B, index, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapSpliterator_3B, map, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_3B, 56, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_3B, entrySet, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_3B, modCount, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_3B, size, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_3B, table, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashMap_24LinkedHashIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedHashIterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedHashIterator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedHashIterator_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedHashIterator_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedList_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FLocale_24Builder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24Builder_3B, localeBuilder, 16, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B, extensions, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B, language, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B, region, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B, script, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B, uattributes, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B, ukeywords, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_3B, variant, 64, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveChar_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveChar_3B, ch, 12, 2)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveChar_3B, lowerCh, 14, 2)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FLanguageTag_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLanguageTag_3B, extensions, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLanguageTag_3B, extlangs, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLanguageTag_3B, language, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLanguageTag_3B, privateuse, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLanguageTag_3B, region, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLanguageTag_3B, script, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLanguageTag_3B, variants, 64, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FParseStatus_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FParseStatus_3B, errorIndex, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FParseStatus_3B, errorMsg, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FParseStatus_3B, parseLength, 24, 4)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FStringTokenIterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FStringTokenIterator_3B, delimiterChar, 12, 2)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FStringTokenIterator_3B, dlms, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FStringTokenIterator_3B, done, 14, 1)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FStringTokenIterator_3B, end, 24, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FStringTokenIterator_3B, start, 28, 4)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FStringTokenIterator_3B, text, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FStringTokenIterator_3B, token, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FLocale_24LanguageRange_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24LanguageRange_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24LanguageRange_3B, range, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLocale_24LanguageRange_3B, weight, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FLocale_24NoImagePreloadHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FObjects_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FObservable_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FObservable_3B, changed, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FObservable_3B, obs, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FPriorityQueue_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24EmptySpliterator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FSplittableRandom_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_3B, gamma, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_3B, seed, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FStringJoiner_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringJoiner_3B, delimiter, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringJoiner_3B, emptyValue, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringJoiner_3B, prefix, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringJoiner_3B, suffix, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringJoiner_3B, value, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FTaskQueue_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTaskQueue_3B, queue, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTaskQueue_3B, size, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2FTimerTask_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimerTask_3B, lock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimerTask_3B, nextExecutionTime, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimerTask_3B, period, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimerTask_3B, state, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2FTimSort_3B, 68, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimSort_3B, a, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimSort_3B, c, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimSort_3B, minGallop, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimSort_3B, runBase, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimSort_3B, runLen, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimSort_3B, stackSize, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimSort_3B, tmp, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimSort_3B, tmpBase, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimSort_3B, tmpLen, 64, 4)
+__MRT_CLASS(Ljava_2Futil_2FTimeZone_24NoImagePreloadHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FTimer_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimer_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FTimer_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimer_3B, queue, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimer_3B, thread, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimer_3B, threadReaper, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FTimerThread_3B, 192, Ljava_2Flang_2FThread_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimerThread_3B, newTasksMayBeScheduled, 176, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTimerThread_3B, queue, 184, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B, est, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B, expectedModCount, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B, fence, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B, side, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B, tree, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24TreeMapEntry_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapEntry_3B, color, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapEntry_3B, left, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapEntry_3B, parent, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapEntry_3B, right, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24TreeMapEntry_3B, value, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_3B, 80, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_3B, comparator, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_3B, descendingMap, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_3B, entrySet, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_3B, modCount, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_3B, navigableKeySet, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_3B, root, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_3B, size, 60, 4)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24EntrySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24EntrySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24KeySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24KeySet_3B, m, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FTripwire_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FUUID_24Holder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B, est, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B, expectedModCount, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B, fence, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B, index, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B, map, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FXMLUtils_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FXMLUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itrs_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itrs_3B, cycles, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itrs_3B, head, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itrs_3B, sweeper, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itrs_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itrs_24Node_3B, 64, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itrs_24Node_3B, next, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itrs_24Node_3B, this_241, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itr_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itr_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itr_3B, lastItem, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itr_3B, lastRet, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itr_3B, nextIndex, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itr_3B, nextItem, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itr_3B, prevCycles, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itr_3B, prevTakeIndex, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_24Itr_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_3B, 64, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_3B, items, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_3B, itrs, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_3B, lock, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_3B, notEmpty, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_3B, notFull, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_3B, putIndex, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FArrayBlockingQueue_3B, takeIndex, 60, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantLock_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantLock_3B, sync, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantLock_24Sync_3B, 48, Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B)
+__MRT_CLASS(Ljava_2Futil_2FAbstractQueue_3B, 12, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24AltResult_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24AltResult_3B, ex, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Delayer_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_3B, 107, Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_3B, continueExistingPeriodicTasksAfterShutdown, 104, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_3B, executeExistingDelayedTasksAfterShutdown, 105, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_3B, removeOnCancel, 106, 1)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, 104, Ljava_2Futil_2Fconcurrent_2FAbstractExecutorService_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, allowCoreThreadTimeOut, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, completedTaskCount, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, corePoolSize, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, ctl, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, handler, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, keepAliveTime, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, largestPoolSize, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, mainLock, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, maximumPoolSize, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, termination, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, threadFactory, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, workQueue, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_3B, workers, 96, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_24Worker_3B, 80, Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_24Worker_3B, completedTasks, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_24Worker_3B, firstTask, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_24Worker_3B, this_240, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_24Worker_3B, thread, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FAbstractExecutorService_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_3B, result, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_3B, stack, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Completion_3B, 24, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Completion_3B, next, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B, status, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24ExceptionNode_3B, 80, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24ExceptionNode_3B, ex, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24ExceptionNode_3B, hashCode, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24ExceptionNode_3B, next, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24ExceptionNode_3B, thrower, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B, 72, Ljava_2Futil_2Fconcurrent_2FAbstractExecutorService_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B, auxState, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B, config, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B, ctl, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B, factory, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B, runState, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B, ueh, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B, workQueues, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_3B, workerNamePrefix, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24AuxState_3B, 40, Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantLock_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24AuxState_3B, indexSeed, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24AuxState_3B, stealCount, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinWorkerThread_3B, 192, Ljava_2Flang_2FThread_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinWorkerThread_3B, pool, 176, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinWorkerThread_3B, workQueue, 184, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, 92, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, base, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, config, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, currentJoin, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, currentSteal, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, hint, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, nsteals, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, owner, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, parker, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, pool, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, qlock, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, scanState, 80, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, stackPred, 84, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24WorkQueue_3B, top, 88, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B, 28, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B, completer, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B, pending, 24, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24MinimalStage_3B, 32, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiAccept_3B, 64, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiAccept_3B, fn, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B, snd, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B, 48, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Completion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B, dep, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B, executor, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B, src, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiApply_3B, 64, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiApply_3B, fn, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiRun_3B, 64, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiRun_3B, fn, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24OrAccept_3B, 64, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24OrAccept_3B, fn, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24OrApply_3B, 64, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24OrApply_3B, fn, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24OrRun_3B, 64, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24OrRun_3B, fn, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniAccept_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniAccept_3B, fn, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniApply_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniApply_3B, fn, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompose_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompose_3B, fn, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniExceptionally_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniExceptionally_3B, fn, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniHandle_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniHandle_3B, fn, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniRun_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniRun_3B, fn, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniWhenComplete_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniWhenComplete_3B, fn, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TableStack_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TableStack_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TableStack_3B, length, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TableStack_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TableStack_3B, tab, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B, baseIndex, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B, baseLimit, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B, baseSize, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B, index, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B, next, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B, spare, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B, stack, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B, tab, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24Node_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24Node_3B, item, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24Node_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24Node_3B, prev, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24Node_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24Node_3B, item, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24Node_3B, next, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24CSLMSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24CSLMSpliterator_3B, comparator, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24CSLMSpliterator_3B, current, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24CSLMSpliterator_3B, est, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24CSLMSpliterator_3B, fence, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24CSLMSpliterator_3B, row, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Node_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Node_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Node_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Node_3B, value, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FAbstractMap_24SimpleImmutableEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_24SimpleImmutableEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_24SimpleImmutableEntry_3B, value, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Index_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Index_3B, down, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Index_3B, node, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Index_3B, right, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_24Generation_3B, 13, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_24Generation_3B, broken, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_3B, barrierCommand, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_3B, generation, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_3B, lock, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_3B, parties, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCyclicBarrier_3B, trip, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExchanger_24Node_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_24Node_3B, bound, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_24Node_3B, collides, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_24Node_3B, hash, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_24Node_3B, index, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_24Node_3B, item, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_24Node_3B, match, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_24Node_3B, parked, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExchanger_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_3B, arena, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_3B, bound, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_3B, participant, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExchanger_3B, slot, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExchanger_24Participant_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FFutureTask_24WaitNode_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FFutureTask_24WaitNode_3B, next, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FFutureTask_24WaitNode_3B, thread, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FHelpers_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24Node_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24Node_3B, item, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24Node_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24Node_3B, prev, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24Node_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24Node_3B, item, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24Node_3B, next, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Node_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Node_3B, isData, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Node_3B, item, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Node_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Node_3B, waiter, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FPhaser_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_3B, evenQ, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_3B, oddQ, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_3B, parent, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_3B, root, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_3B, state, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReference_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReference_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, deadline, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, interruptible, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, nanos, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, next, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, phase, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, phaser, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, thread, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, timed, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPhaser_24QNode_3B, wasInterrupted, 14, 1)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferQueue_24QNode_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferQueue_24QNode_3B, isData, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferQueue_24QNode_3B, item, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferQueue_24QNode_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferQueue_24QNode_3B, waiter, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_24SNode_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_24SNode_3B, item, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_24SNode_3B, match, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_24SNode_3B, mode, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_24SNode_3B, next, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_24SNode_3B, waiter, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24Transferer_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicIntegerFieldUpdater_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicMarkableReference_24Pair_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicMarkableReference_24Pair_3B, mark, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicMarkableReference_24Pair_3B, reference, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicMarkableReference_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicMarkableReference_3B, pair, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicStampedReference_24Pair_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicStampedReference_24Pair_3B, reference, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicStampedReference_24Pair_3B, stamp, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicStampedReference_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicStampedReference_3B, pair, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_24Cell_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_24Cell_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FLockSupport_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24WNode_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24WNode_3B, cowait, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24WNode_3B, mode, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24WNode_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24WNode_3B, prev, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24WNode_3B, status, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24WNode_3B, thread, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarFile_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarInputStream_3B, 160, Ljava_2Futil_2Fzip_2FZipInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarInputStream_3B, doVerify, 120, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarInputStream_3B, first, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarInputStream_3B, jv, 136, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarInputStream_3B, man, 144, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarInputStream_3B, mev, 152, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarInputStream_3B, tryManifest, 121, 1)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipInputStream_3B, 120, Ljava_2Futil_2Fzip_2FInflaterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipInputStream_3B, b, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipInputStream_3B, closed, 72, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipInputStream_3B, crc, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipInputStream_3B, entry, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipInputStream_3B, entryEOF, 73, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipInputStream_3B, flag, 76, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipInputStream_3B, remaining, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipInputStream_3B, tmpbuf, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipInputStream_3B, zc, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FCRC32_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FCRC32_3B, crc, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FInflaterInputStream_3B, 64, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterInputStream_3B, b, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterInputStream_3B, buf, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterInputStream_3B, closed, 40, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterInputStream_3B, inf, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterInputStream_3B, len, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterInputStream_3B, reachEOF, 41, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterInputStream_3B, singleByteBuf, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarOutputStream_3B, 121, Ljava_2Futil_2Fzip_2FZipOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarOutputStream_3B, firstEntry, 120, 1)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, 120, Ljava_2Futil_2Fzip_2FDeflaterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, closed, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, comment, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, crc, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, current, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, finished, 49, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, locoff, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, method, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, names, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, written, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, xentries, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_3B, zc, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipOutputStream_24XEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_24XEntry_3B, entry, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipOutputStream_24XEntry_3B, offset, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FDeflaterOutputStream_3B, 48, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterOutputStream_3B, buf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterOutputStream_3B, closed, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterOutputStream_3B, def, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterOutputStream_3B, syncFlush, 33, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterOutputStream_3B, usesDefaultDeflater, 34, 1)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FDeflater_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, bytesRead, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, bytesWritten, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, finish, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, finished, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, guard, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, len, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, level, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, off, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, setParams, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, strategy, 60, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflater_3B, zsRef, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FPack200_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLevel_24KnownLevel_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLevel_24KnownLevel_3B, levelObject, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLevel_24KnownLevel_3B, mirroredLevel, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_24Beans_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogger_24SystemLoggerHelper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FBase64_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Change_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Change_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B, 144, Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B, changeLog, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B, dir, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B, isUserNode, 96, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B, lastSyncTime, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B, nodeCreate, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B, prefsCache, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B, prefsFile, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_3B, tmpFile, 136, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24NodeCreate_3B, 32, Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Change_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24NodeCreate_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FPreferences_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FNodeChangeEvent_3B, 32, Ljava_2Futil_2FEventObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FNodeChangeEvent_3B, child, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FPreferenceChangeEvent_3B, 40, Ljava_2Futil_2FEventObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FPreferenceChangeEvent_3B, key, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FPreferenceChangeEvent_3B, newValue, 32, 8)
+__MRT_CLASS(Lsun_2Futil_2Flogging_2FPlatformLogger_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flogging_2FPlatformLogger_3B, javaLoggerProxy, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flogging_2FPlatformLogger_3B, loggerProxy, 24, 8)
+__MRT_CLASS(Lsun_2Futil_2Flogging_2FPlatformLogger_24JavaLoggerProxy_3B, 32, Lsun_2Futil_2Flogging_2FPlatformLogger_24LoggerProxy_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flogging_2FPlatformLogger_24JavaLoggerProxy_3B, javaLogger, 24, 8)
+__MRT_CLASS(Lsun_2Futil_2Flogging_2FPlatformLogger_24Level_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flogging_2FPlatformLogger_24Level_3B, javaLevel, 24, 8)
+__MRT_CLASS(Lsun_2Futil_2Flogging_2FPlatformLogger_24LoggerProxy_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flogging_2FPlatformLogger_24LoggerProxy_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, 80, Ljava_2Futil_2Fprefs_2FPreferences_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, absolutePath, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, kidCache, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, lock, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, name, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, newNode, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, nodeListeners, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, parent, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, prefListeners, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, removed, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_3B, root, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2FStringTokenizer_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, currentPosition, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, delimiterCodePoints, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, delimiters, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, delimsChanged, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, hasSurrogates, 33, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, maxDelimCodePoint, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, maxPosition, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, newPosition, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, retDelims, 34, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FStringTokenizer_3B, str, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FXmlSupport_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FXmlSupport_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FAbstractSpinedBuffer_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractSpinedBuffer_3B, elementIndex, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractSpinedBuffer_3B, initialChunkPower, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractSpinedBuffer_3B, priorElementCount, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractSpinedBuffer_3B, spineIndex, 20, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FCollectors_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FCollectors_24Partition_3B, 48, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_24Partition_3B, forFalse, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_24Partition_3B, forTrue, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FCollectors_241OptionalBox_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_241OptionalBox_3B, present, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_241OptionalBox_3B, val_24op, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_241OptionalBox_3B, value, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDistinctOps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_3B, 80, Ljava_2Futil_2Fstream_2FAbstractPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, 80, Ljava_2Futil_2Fstream_2FPipelineHelper_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, combinedFlags, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, depth, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, linkedOrConsumed, 20, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, nextStage, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, parallel, 21, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, previousStage, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, sourceAnyStateful, 22, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, sourceCloseAction, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, sourceOrOpFlags, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, sourceSpliterator, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, sourceStage, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractPipeline_3B, sourceSupplier, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FPipelineHelper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamShape_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FFindOps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FForEachOps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FMatchOps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FMatchOps_24BooleanTerminalSink_3B, 14, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_24BooleanTerminalSink_3B, stop, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_24BooleanTerminalSink_3B, value, 13, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FMatchOps_24MatchKind_3B, 26, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_24MatchKind_3B, shortCircuitResult, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_24MatchKind_3B, stopOnPredicateMatches, 25, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_24Box_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_24Box_3B, state, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_245_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamOpFlag_24MaskBuilder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamOpFlag_24MaskBuilder_3B, map, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamOpFlag_24Type_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_3B, index, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_3B, fence, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_3B, index, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_3B, s, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_3B, sliceFence, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_3B, sliceOrigin, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_3B, permits, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_3B, s, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_3B, skipThreshold, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_3B, unlimited, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24PermitStatus_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSupport_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FTripwire_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipConstants64_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipher_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipher_24CipherSpiAndProvider_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24CipherSpiAndProvider_3B, cipherSpi, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24CipherSpiAndProvider_3B, provider, 24, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipherSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipher_24InitParams_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24InitParams_3B, initType, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24InitParams_3B, key, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24InitParams_3B, opmode, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24InitParams_3B, params, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24InitParams_3B, random, 40, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24InitParams_3B, spec, 48, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipher_24InitType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipher_24SpiAndProviderUpdater_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24SpiAndProviderUpdater_3B, initSpiLock, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24SpiAndProviderUpdater_3B, specifiedProvider, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24SpiAndProviderUpdater_3B, specifiedSpi, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24SpiAndProviderUpdater_3B, this_240, 40, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipher_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_3B, exmech, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_3B, initialized, 12, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_3B, opmode, 24, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_3B, spi, 40, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_3B, spiAndProviderUpdater, 48, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_3B, tokenizedTransformation, 56, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_3B, transformation, 64, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FExemptionMechanism_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FExemptionMechanism_3B, done, 12, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FExemptionMechanism_3B, exmechSpi, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FExemptionMechanism_3B, initialized, 13, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FExemptionMechanism_3B, keyStored, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FExemptionMechanism_3B, mechanism, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FExemptionMechanism_3B, provider, 40, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FExemptionMechanismSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipher_24NeedToSet_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipher_24Transform_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24Transform_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipher_24Transform_3B, needToSet, 24, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCryptoPolicyParser_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCryptoPermission_3B, 24, Ljava_2Fsecurity_2FPermission_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FEncryptedPrivateKeyInfo_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FEncryptedPrivateKeyInfo_3B, algid, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FEncryptedPrivateKeyInfo_3B, encoded, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FEncryptedPrivateKeyInfo_3B, encryptedData, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FAlgorithmId_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAlgorithmId_3B, algParams, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAlgorithmId_3B, algid, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAlgorithmId_3B, constructedFromDer, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAlgorithmId_3B, params, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FPKCS8EncodedKeySpec_3B, 24, Ljava_2Fsecurity_2Fspec_2FEncodedKeySpec_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FEncodedKeySpec_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FEncodedKeySpec_3B, encodedKey, 16, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FJarVerifier_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FJarVerifier_3B, appPerms, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FJarVerifier_3B, jarURL, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FJarVerifier_3B, savePerms, 12, 1)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCryptoPermissions_3B, 12, Ljava_2Fsecurity_2FPermissionCollection_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FJceSecurity_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FGetInstance_24Instance_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FGetInstance_24Instance_3B, impl, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FGetInstance_24Instance_3B, provider, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FGetInstance_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FKeyAgreement_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyAgreement_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyAgreement_3B, lock, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyAgreement_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyAgreement_3B, spi, 40, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FKeyAgreementSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FKeyGenerator_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyGenerator_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyGenerator_3B, initKeySize, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyGenerator_3B, initParams, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyGenerator_3B, initRandom, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyGenerator_3B, initType, 40, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyGenerator_3B, lock, 48, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyGenerator_3B, provider, 56, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyGenerator_3B, serviceIterator, 64, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FKeyGenerator_3B, spi, 72, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FKeyGeneratorSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FMacSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FSecretKeyFactory_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FSecretKeyFactory_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FSecretKeyFactory_3B, lock, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FSecretKeyFactory_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FSecretKeyFactory_3B, serviceIterator, 40, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FSecretKeyFactory_3B, spi, 48, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FSecretKeyFactorySpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FDHParameterSpec_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHParameterSpec_3B, g, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHParameterSpec_3B, l, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHParameterSpec_3B, p, 24, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FPSource_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FPSource_3B, pSrcName, 16, 8)
+__MRT_CLASS(Ljavax_2Fnet_2FServerSocketFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fnet_2FSocketFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fcert_2FX509Certificate_3B, 12, Ljavax_2Fsecurity_2Fcert_2FCertificate_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fcert_2FCertificate_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FHttpsURLConnection_24NoPreloadHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FKeyManagerFactory_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FKeyManagerFactory_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FKeyManagerFactory_3B, factorySpi, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FKeyManagerFactory_3B, provider, 32, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FKeyManagerFactorySpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSNIMatcher_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSNIMatcher_3B, type, 12, 4)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSNIServerName_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSNIServerName_3B, encoded, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSNIServerName_3B, type, 12, 4)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLContext_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLContext_3B, contextSpi, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLContext_3B, protocol, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLContext_3B, provider, 32, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLContextSpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLSocket_3B, 35, Ljava_2Fnet_2FSocket_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FHandshakeCompletedEvent_3B, 32, Ljava_2Futil_2FEventObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FHandshakeCompletedEvent_3B, session, 24, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, algorithmConstraints, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, applicationProtocols, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, cipherSuites, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, identificationAlgorithm, 40, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, needClientAuth, 12, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, preferLocalCipherSuites, 13, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, protocols, 48, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, sniMatchers, 56, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, sniNames, 64, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLParameters_3B, wantClientAuth, 14, 1)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLEngine_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLEngine_3B, peerHost, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLEngine_3B, peerPort, 12, 4)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLEngineResult_24HandshakeStatus_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLEngineResult_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLEngineResult_3B, bytesConsumed, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLEngineResult_3B, bytesProduced, 16, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLEngineResult_3B, handshakeStatus, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLEngineResult_3B, status, 32, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLEngineResult_24Status_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLServerSocketFactory_3B, 12, Ljavax_2Fnet_2FServerSocketFactory_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLSocketFactory_3B, 12, Ljavax_2Fnet_2FSocketFactory_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FStandardConstants_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FTrustManagerFactory_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FTrustManagerFactory_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FTrustManagerFactory_3B, factorySpi, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FTrustManagerFactory_3B, provider, 32, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FTrustManagerFactorySpi_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24AuthPermissionHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FAuthPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljavax_2Fsql_2FConnectionEvent_3B, 32, Ljava_2Futil_2FEventObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsql_2FConnectionEvent_3B, ex, 24, 8)
+__MRT_CLASS(Ljavax_2Fsql_2FStatementEvent_3B, 40, Ljava_2Futil_2FEventObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsql_2FStatementEvent_3B, exception, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsql_2FStatementEvent_3B, statement, 32, 8)
+__MRT_CLASS(Ljavax_2Fxml_2FXMLConstants_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FDatatypeConstants_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FDatatypeConstants_24Field_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fdatatype_2FDatatypeConstants_24Field_3B, id, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fdatatype_2FDatatypeConstants_24Field_3B, str, 16, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FDatatypeConstants_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fnamespace_2FQName_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fnamespace_2FQName_3B, localPart, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fnamespace_2FQName_3B, namespaceURI, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fnamespace_2FQName_3B, prefix, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fnamespace_2FQName_3B, qNameAsString, 40, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FDatatypeFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FDuration_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FXMLGregorianCalendar_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FGregorianCalendar_3B, 152, Ljava_2Futil_2FCalendar_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, cachedFixedDate, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, calsys, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, cdate, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, gdate, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, gregorianCutover, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, gregorianCutoverDate, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, gregorianCutoverYear, 128, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, gregorianCutoverYearJulian, 132, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, originalFields, 136, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FGregorianCalendar_3B, zoneOffsets, 144, 8)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FJulianCalendar_3B, 24, Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FJulianCalendar_24Date_3B, 108, Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FFactoryFinder_24CacheHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FFactoryFinder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fparsers_2FDocumentBuilder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fvalidation_2FSchema_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fvalidation_2FValidator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2FSAXParseException_3B, 88, Lorg_2Fxml_2Fsax_2FSAXException_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FSAXParseException_3B, columnNumber, 64, 4)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FSAXParseException_3B, lineNumber, 68, 4)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FSAXParseException_3B, publicId, 72, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FSAXParseException_3B, systemId, 80, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2FSAXException_3B, 64, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FSAXException_3B, exception, 56, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Fvalidation_2FValidatorHandler_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fvalidation_2FTypeInfoProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2FInputSource_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FInputSource_3B, byteStream, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FInputSource_3B, characterStream, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FInputSource_3B, encoding, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FInputSource_3B, publicId, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2FInputSource_3B, systemId, 48, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Fparsers_2FDocumentBuilderFactory_3B, 18, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fparsers_2FDocumentBuilderFactory_3B, coalescing, 12, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fparsers_2FDocumentBuilderFactory_3B, expandEntityRef, 13, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fparsers_2FDocumentBuilderFactory_3B, ignoreComments, 14, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fparsers_2FDocumentBuilderFactory_3B, namespaceAware, 15, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fparsers_2FDocumentBuilderFactory_3B, validating, 16, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fparsers_2FDocumentBuilderFactory_3B, whitespace, 17, 1)
+__MRT_CLASS(Ljavax_2Fxml_2Fparsers_2FFilePathToURI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fparsers_2FSAXParser_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2FHandlerBase_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FDefaultHandler_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fparsers_2FSAXParserFactory_3B, 14, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fparsers_2FSAXParserFactory_3B, namespaceAware, 12, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fparsers_2FSAXParserFactory_3B, validating, 13, 1)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2FTransformerException_3B, 72, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2FTransformerException_3B, containedException, 56, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2FTransformerException_3B, locator, 64, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2FOutputKeys_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2FTransformer_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2FTransformerFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2Fstream_2FFilePathToURI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fvalidation_2FSchemaFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fvalidation_2FSchemaFactoryFinder_24CacheHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fvalidation_2FSchemaFactoryFinder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fvalidation_2FSchemaFactoryFinder_3B, classLoader, 16, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Fvalidation_2FSchemaFactoryLoader_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fxpath_2FXPathConstants_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fxpath_2FXPathFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fxpath_2FXPathFactoryFinder_24CacheHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fxpath_2FXPathFactoryFinder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fxpath_2FXPathFactoryFinder_3B, classLoader, 16, 8)
+__MRT_CLASS(Ljdk_2Fnet_2FExtendedSocketOptions_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljdk_2Fnet_2FSocketFlow_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljdk_2Fnet_2FSocketFlow_3B, bandwidth, 16, 8)
+__MRT_CLASS_FIELD(Ljdk_2Fnet_2FSocketFlow_3B, priority, 12, 4)
+__MRT_CLASS_FIELD(Ljdk_2Fnet_2FSocketFlow_3B, status, 24, 8)
+__MRT_CLASS(Ljdk_2Fnet_2FSocketFlow_24Status_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljdk_2Fnet_2FSockets_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FDateIntervalFormat_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, 105, Landroid_2Ficu_2Ftext_2FUFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, fDateFormat, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, fDatePattern, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, fDateTimeFormat, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, fFromCalendar, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, fInfo, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, fIntervalPatterns, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, fSkeleton, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, fTimePattern, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, fToCalendar, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalFormat_3B, isDateIntervalInfoDefault, 104, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, 184, Landroid_2Ficu_2Ftext_2FDateFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, capitalizationBrkIter, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, decDigits, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, decimalBuf, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, defaultCenturyBase, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, defaultCenturyStart, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, defaultCenturyStartYear, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, formatData, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, hasMinute, 120, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, hasSecond, 121, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, locale, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, numberFormatters, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, override, 144, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, overrideMap, 152, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, pattern, 160, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, patternItems, 168, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, serialVersionOnStream, 124, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, tzFormat, 176, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, useFastFormat, 122, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B, useLocalZeroPaddingNumberFormat, 123, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, 136, Landroid_2Ficu_2Ftext_2FUFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __abuttingOffsetHoursAndMinutes, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __frozen, 33, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __gmtOffsetDigits, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __gmtOffsetPatternItems, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __gmtOffsetPatterns, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __gmtPattern, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __gmtPatternPrefix, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __gmtPatternSuffix, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __gmtZeroFormat, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __gnames, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __locale, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __parseAllStyles, 34, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __parseTZDBNames, 35, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __region, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __tzdbNames, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_3B, __tznames, 128, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __genericLocationNamesMap, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __genericPartialLocationNamesMap, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __gnamesTrie, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __gnamesTrieFullyLoaded, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __locale, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __localeDisplayNamesRef, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __patternFormatters, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __region, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_3B, __tznames, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24Cache_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24Pattern_3B, 40, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24Pattern_3B, __defaultVal, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24Pattern_3B, __key, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24GMTOffsetPatternType_3B, 48, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24GMTOffsetPatternType_3B, __defaultPattern, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24GMTOffsetPatternType_3B, __isPositive, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24GMTOffsetPatternType_3B, __required, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24TimeZoneFormatCache_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24OffsetFields_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24Style_3B, 28, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24Style_3B, flag, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateFormat_24Field_3B, 28, Ljava_2Ftext_2FFormat_24Field_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormat_24Field_3B, calendarField, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessageFormat_3B, 96, Landroid_2Ficu_2Ftext_2FUFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_3B, cachedFormatters, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_3B, customFormatArgStarts, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_3B, msgPattern, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_3B, ordinalProvider, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_3B, pluralProvider, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_3B, stockDateFormatter, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_3B, stockNumberFormatter, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_3B, ulocale, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorProvider_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorProvider_3B, msgFormat, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorProvider_3B, rules, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessageFormat_24PluralSelectorProvider_3B, type, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_3B, fFallbackIntervalPattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_3B, fFirstDateInPtnIsLaterDate, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_3B, fIntervalPatterns, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_3B, fIntervalPatternsReadOnly, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_3B, frozen, 14, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_24PatternInfo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_24PatternInfo_3B, fFirstDateInPtnIsLaterDate, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_24PatternInfo_3B, fIntervalPatternFirstPart, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_24PatternInfo_3B, fIntervalPatternSecondPart, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, __distanceInfo, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, allowedHourFormats, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, appendItemFormats, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, basePattern__pattern, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, cldrAvailableFormatKeys, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, current, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, dateTimeFormat, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, decimal, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, defaultHourFormatChar, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, fieldDisplayNames, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, fp, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, frozen, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_3B, skeleton2pattern, 96, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DisplayWidth_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DisplayWidth_3B, cldrKey, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeSet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeSet_3B, m, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FDateInterval_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FDateInterval_3B, fromDate, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FDateInterval_3B, toDate, 24, 8)
+__MRT_CLASS(Llibcore_2Ficu_2FDateTimeFormat_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FDateTimeFormat_24FormatterCache_3B, 24, Llibcore_2Futil_2FBasicLruCache_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FDateUtilsBridge_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FICU_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FNativeConverter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FRelativeDateTimeFormatter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FRelativeDateTimeFormatter_24FormatterCache_3B, 24, Llibcore_2Futil_2FBasicLruCache_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FTimeZoneNames_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FTimeZoneNames_24ZoneStringsCache_3B, 24, Llibcore_2Futil_2FBasicLruCache_3B)
+__MRT_CLASS(Llibcore_2Finternal_2FJava9LanguageFeatures_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Finternal_2FStringPool_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Finternal_2FStringPool_3B, pool, 16, 8)
+__MRT_CLASS(Llibcore_2Fio_2FAsynchronousCloseMonitor_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fio_2FBufferIterator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fio_2FIoBridge_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Fsystem_2FErrnoException_3B, 72, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FErrnoException_3B, errno, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FErrnoException_3B, functionName, 64, 8)
+__MRT_CLASS(Llibcore_2Fio_2FIoUtils_24FileReader_3B, 33, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FIoUtils_24FileReader_3B, bytes, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FIoUtils_24FileReader_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FIoUtils_24FileReader_3B, fd, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FIoUtils_24FileReader_3B, unknownLength, 32, 1)
+__MRT_CLASS(Llibcore_2Fio_2FIoUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fio_2FLibcore_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fio_2FMemory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fio_2FStreams_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fmath_2FMathUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fnet_2FInetAddressUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fnet_2FMimeUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fnet_2FNetworkSecurityPolicy_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fnet_2Fevent_2FNetworkEventDispatcher_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Fnet_2Fevent_2FNetworkEventDispatcher_3B, listeners, 16, 8)
+__MRT_CLASS(Llibcore_2Fnet_2Fevent_2FNetworkEventListener_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fnet_2Fhttp_2FHttpDate_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fnet_2Fhttp_2FResponseUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Freflect_2FAnnotatedElements_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Freflect_2FGenericSignatureParser_3B, 112, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, eof, 12, 1)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, exceptionTypes, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, fieldType, 32, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, formalTypeParameters, 40, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, genericDecl, 48, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, identifier, 56, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, interfaceTypes, 64, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, loader, 72, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, parameterTypes, 80, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, pos, 88, 4)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, returnType, 96, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, superclassType, 104, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericSignatureParser_3B, symbol, 14, 2)
+__MRT_CLASS(Llibcore_2Freflect_2FTypeVariableImpl_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FTypeVariableImpl_3B, bounds, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FTypeVariableImpl_3B, declOfVarUser, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FTypeVariableImpl_3B, formalVar, 32, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FTypeVariableImpl_3B, genericDeclaration, 40, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FTypeVariableImpl_3B, name, 48, 8)
+__MRT_CLASS(Llibcore_2Freflect_2FInternalNames_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Freflect_2FListOfVariables_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FListOfVariables_3B, array, 16, 8)
+__MRT_CLASS(Llibcore_2Freflect_2FTypes_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ftimezone_2FCountryTimeZones_24OffsetResult_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_24OffsetResult_3B, mOneMatch, 12, 1)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_24OffsetResult_3B, mTimeZone, 16, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FCountryTimeZones_24TimeZoneMapping_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_24TimeZoneMapping_3B, notUsedAfter, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_24TimeZoneMapping_3B, showInPicker, 12, 1)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_24TimeZoneMapping_3B, timeZoneId, 24, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FCountryTimeZones_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_3B, countryIso, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_3B, defaultTimeZoneId, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_3B, everUsesUtc, 12, 1)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_3B, icuDefaultTimeZone, 32, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_3B, icuTimeZones, 40, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryTimeZones_3B, timeZoneMappings, 48, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FCountryZonesFinder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FCountryZonesFinder_3B, countryTimeZonesList, 16, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FTimeZoneDataFiles_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ftimezone_2FTimeZoneFinder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ftimezone_2FTimeZoneFinder_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTimeZoneFinder_3B, lastCountryTimeZones, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTimeZoneFinder_3B, xmlSource, 24, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FTzDataSetVersion_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTzDataSetVersion_3B, formatMajorVersion, 12, 4)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTzDataSetVersion_3B, formatMinorVersion, 16, 4)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTzDataSetVersion_3B, revision, 20, 4)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTzDataSetVersion_3B, rulesVersion, 24, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FZoneInfoDB_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_3B, byteOffsets, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_3B, cache, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_3B, closed, 12, 1)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_3B, ids, 32, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_3B, mappedFile, 40, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_3B, rawUtcOffsetsCache, 48, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_3B, version, 56, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_3B, zoneTab, 64, 8)
+__MRT_CLASS(Llibcore_2Fio_2FMemoryMappedFile_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FMemoryMappedFile_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FMemoryMappedFile_3B, closed, 12, 1)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FMemoryMappedFile_3B, size, 24, 4)
+__MRT_CLASS(Llibcore_2Futil_2FZoneInfo_3B, 72, Ljava_2Futil_2FTimeZone_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_3B, mDstSavings, 24, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_3B, mEarliestRawOffset, 28, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_3B, mIsDsts, 32, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_3B, mOffsets, 40, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_3B, mRawOffset, 48, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_3B, mTransitions, 56, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_3B, mTypes, 64, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_3B, mUseDst, 52, 1)
+__MRT_CLASS(Llibcore_2Futil_2FArrayUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FCharsetUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FCollectionUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FCoreLibraryDebug_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FDebugInfo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FDebugInfo_3B, entries, 16, 8)
+__MRT_CLASS(Llibcore_2Futil_2FDebugInfo_24DebugEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FDebugInfo_24DebugEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FDebugInfo_24DebugEntry_3B, stringValue, 24, 8)
+__MRT_CLASS(Llibcore_2Futil_2FEmptyArray_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FHexEncoding_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FObjects_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FSneakyThrow_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FXmlObjectFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FZoneInfo_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Futil_2FZoneInfo_24OffsetInterval_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24OffsetInterval_3B, endWallTimeSeconds, 12, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24OffsetInterval_3B, isDst, 16, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24OffsetInterval_3B, startWallTimeSeconds, 20, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24OffsetInterval_3B, totalOffsetSeconds, 24, 4)
+__MRT_CLASS(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, 60, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, calendar, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, gmtOffsetSeconds, 12, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, hour, 24, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, isDst, 28, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, minute, 32, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, month, 36, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, monthDay, 40, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, second, 44, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, weekDay, 48, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, year, 52, 4)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FZoneInfo_24WallTime_3B, yearDay, 56, 4)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fdalvik_2FNativeTestTarget_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FChunk_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FChunk_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FChunk_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FChunk_3B, offset, 24, 4)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FChunk_3B, type, 28, 4)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FChunkHandler_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FDdmServer_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fdalvik_2Fddmc_2FDdmVmInternal_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, attributeCount, 12, 4)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, attributePointer, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, attributes, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, encoding, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, inStartElement, 40, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, locator, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, pointer, 56, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, publicId, 64, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, systemId, 72, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B, xmlReader, 80, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatAttributes_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatReader_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatReader_3B, contentHandler, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatReader_3B, dtdHandler, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatReader_3B, entityResolver, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatReader_3B, errorHandler, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatReader_3B, lexicalHandler, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatReader_3B, processNamespacePrefixes, 12, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatReader_3B, processNamespaces, 13, 1)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatReader_24Feature_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, cdataSections, 12, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, comments, 13, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, datatypeNormalization, 14, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, entities, 15, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, errorHandler, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, namespaces, 24, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, schemaLocation, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, schemaType, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, splitCdataSections, 25, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, validate, 26, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_3B, wellFormed, 27, 1)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeImpl_24UserData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeImpl_24UserData_3B, handler, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeImpl_24UserData_3B, value, 24, 8)
+__MRT_CLASS(Lorg_2Fjson_2FJSON_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fjson_2FJSONException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Lorg_2Fjson_2FJSONArray_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fjson_2FJSONArray_3B, values, 16, 8)
+__MRT_CLASS(Lorg_2Fjson_2FJSONTokener_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fjson_2FJSONTokener_3B, in, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fjson_2FJSONTokener_3B, pos, 12, 4)
+__MRT_CLASS(Lorg_2Fjson_2FJSONObject_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fjson_2FJSONObject_3B, nameValuePairs, 16, 8)
+__MRT_CLASS(Lorg_2Fjson_2FJSONStringer_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fjson_2FJSONStringer_3B, indent, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fjson_2FJSONStringer_3B, out, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fjson_2FJSONStringer_3B, stack, 32, 8)
+__MRT_CLASS(Lorg_2Fjson_2FJSONStringer_24Scope_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lorg_2Fjson_2FJSONObject_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, attributeNameTable, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, declSeen, 12, 1)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, declarations, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, declsOK, 13, 1)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, defaultNS, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, elementNameTable, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, parent, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, prefixTable, 56, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, this_240, 64, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_24Context_3B, uriTable, 72, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_3B, 33, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_3B, contextPos, 12, 4)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_3B, contexts, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_3B, currentContext, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FNamespaceSupport_3B, namespaceDeclUris, 32, 1)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FNewInstance_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLReaderFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fxmlpull_2Fv1_2FXmlPullParserFactory_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2FXmlPullParserFactory_3B, classNamesLocation, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2FXmlPullParserFactory_3B, features, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2FXmlPullParserFactory_3B, parserClasses, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2FXmlPullParserFactory_3B, serializerClasses, 40, 8)
+__MRT_CLASS(Lorg_2Fxmlpull_2Fv1_2FXmlPullParserException_3B, 72, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2FXmlPullParserException_3B, column, 56, 4)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2FXmlPullParserException_3B, detail, 64, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2FXmlPullParserException_3B, row, 60, 4)
+__MRT_CLASS(Lsun_2Finvoke_2Futil_2FBytecodeDescriptor_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Finvoke_2Futil_2FVerifyAccess_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Finvoke_2Futil_2FWrapper_24Format_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FCharacterDecoder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FPushbackInputStream_3B, 36, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPushbackInputStream_3B, buf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPushbackInputStream_3B, pos, 32, 4)
+__MRT_CLASS(Lsun_2Fmisc_2FCharacterEncoder_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FCharacterEncoder_3B, pStream, 16, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FDoubleConsts_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FFDBigInteger_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFDBigInteger_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFDBigInteger_3B, isImmutable, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFDBigInteger_3B, nWords, 24, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFDBigInteger_3B, offset, 28, 4)
+__MRT_CLASS(Lsun_2Fmisc_2FFileURLMapper_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFileURLMapper_3B, path, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFileURLMapper_3B, url, 24, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FFloatConsts_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FFloatingDecimal_24HexFloatPattern_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FFloatingDecimal_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B, decExponent, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B, decimalDigitsRoundedUp, 24, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B, digits, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B, exactDecimalConversion, 25, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B, firstDigitIndex, 28, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B, isNegative, 26, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24BinaryToASCIIBuffer_3B, nDigits, 40, 4)
+__MRT_CLASS(Lsun_2Fmisc_2FFormattedFloatingDecimal_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FFormattedFloatingDecimal_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFormattedFloatingDecimal_3B, decExponentRounded, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFormattedFloatingDecimal_3B, exponent, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFormattedFloatingDecimal_3B, mantissa, 24, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FFormattedFloatingDecimal_24Form_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FFpUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FIOUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FJarIndex_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FJarIndex_3B, indexMap, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FJarIndex_3B, jarFiles, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FJarIndex_3B, jarMap, 32, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FMetaIndex_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FMetaIndex_3B, contents, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FMetaIndex_3B, isClassOnlyJar, 12, 1)
+__MRT_CLASS(Lsun_2Fmisc_2FLRUCache_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FLRUCache_3B, oa, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FLRUCache_3B, size, 12, 4)
+__MRT_CLASS(Lsun_2Fmisc_2FMessageUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FRegexpNode_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpNode_3B, c, 12, 2)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpNode_3B, depth, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpNode_3B, exact, 14, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpNode_3B, firstchild, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpNode_3B, nextsibling, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpNode_3B, re, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpNode_3B, result, 48, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FRegexpPool_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpPool_3B, lastDepth, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpPool_3B, prefixMachine, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FRegexpPool_3B, suffixMachine, 24, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FResource_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FResource_3B, cis, 16, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FSharedSecrets_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_3B, acc, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_3B, closed, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_3B, jarHandler, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_3B, lmap, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_3B, loaders, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_3B, lookupCacheLoader, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_3B, lookupCacheURLs, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_3B, path, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_3B, urls, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2FStack_3B, 32, Ljava_2Futil_2FVector_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_24Loader_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24Loader_3B, base, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24Loader_3B, jarfile, 24, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FVM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FVersion_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2FExtendedOptionsImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2FNetHooks_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2FNetProperties_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2FNetworkClient_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_3B, connectTimeout, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_3B, proxy, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_3B, readTimeout, 24, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_3B, serverInput, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_3B, serverOutput, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_3B, serverSocket, 48, 8)
+__MRT_CLASS(Lsun_2Fnet_2FProgressMonitor_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressMonitor_3B, progressListenerList, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressMonitor_3B, progressSourceList, 24, 8)
+__MRT_CLASS(Lsun_2Fnet_2FProgressEvent_3B, 72, Ljava_2Futil_2FEventObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressEvent_3B, contentType, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressEvent_3B, expected, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressEvent_3B, method, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressEvent_3B, progress, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressEvent_3B, state, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressEvent_3B, url, 64, 8)
+__MRT_CLASS(Lsun_2Fnet_2FProgressSource_24State_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fnet_2FProgressSource_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, connected, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, contentType, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, expected, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, lastProgress, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, method, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, progress, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, progressMonitor, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, state, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, threshold, 72, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FProgressSource_3B, url, 80, 8)
+__MRT_CLASS(Lsun_2Fnet_2FResourceManager_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpClientProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpClient_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpReplyCode_3B, 28, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpReplyCode_3B, value, 24, 4)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, created, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, facts, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, group, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, lastModified, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, name, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, permissions, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, size, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, type, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_3B, user, 80, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpDirEntry_24Type_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpDirEntry_24Permission_3B, 28, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpDirEntry_24Permission_3B, value, 24, 4)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpClient_24TransferType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_24NonProxyInfo_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_24NonProxyInfo_3B, defaultVal, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_24NonProxyInfo_3B, hostsSource, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_24NonProxyInfo_3B, pattern, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_24NonProxyInfo_3B, property, 40, 8)
+__MRT_CLASS(Lsun_2Fnet_2Futil_2FIPAddressUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2Futil_2FURLUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2FParseUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAbstractPollArrayWrapper_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollArrayWrapper_3B, pollArray, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollArrayWrapper_3B, pollArrayAddress, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollArrayWrapper_3B, totalChannels, 12, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAllocatedNativeObject_3B, 32, Lsun_2Fnio_2Fch_2FNativeObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FNativeObject_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FNativeObject_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FNativeObject_3B, allocationAddress, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_24DefaultOptionsHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_24DefaultOptionsHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FPendingFuture_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPendingFuture_3B, attachment, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPendingFuture_3B, channel, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPendingFuture_3B, context, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPendingFuture_3B, exc, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPendingFuture_3B, handler, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPendingFuture_3B, haveResult, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPendingFuture_3B, latch, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPendingFuture_3B, result, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPendingFuture_3B, timeoutTask, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCancellationException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Flang_2FIllegalStateException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_24DefaultOptionsHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FDefaultAsynchronousChannelProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FDefaultSelectorProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FCleaner_3B, 72, Ljava_2Flang_2Fref_2FPhantomReference_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FCleaner_3B, next, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FCleaner_3B, prev, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FCleaner_3B, thunk, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FPhantomReference_3B, 48, Ljava_2Flang_2Fref_2FReference_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FEPoll_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FEPollPort_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FEPollPort_24Event_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_24Event_3B, channel, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_24Event_3B, events, 12, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FExtendedSocketOption_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileChannelImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileKey_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileKey_3B, st__dev, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileKey_3B, st__ino, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileLockTable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_3B, 80, Ljava_2Fnio_2Fchannels_2FAsynchronousChannelGroup_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_3B, pool, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_3B, shutdown, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_3B, shutdownNowLock, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_3B, taskQueue, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_3B, terminateInitiated, 56, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_3B, threadCount, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_3B, timeoutExecutor, 72, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FThreadPool_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FThreadPool_3B, executor, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FThreadPool_3B, isFixed, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FThreadPool_3B, poolSize, 24, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FIOStatus_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FIOUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FNativeDispatcher_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FIOVecWrapper_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FIOVecWrapper_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FIOVecWrapper_3B, buf, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FIOVecWrapper_3B, position, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FIOVecWrapper_3B, remaining, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FIOVecWrapper_3B, shadow, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FIOVecWrapper_3B, size, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FIOVecWrapper_3B, vecArray, 56, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FInvoker_24GroupAndInvokeCount_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_24GroupAndInvokeCount_3B, group, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_24GroupAndInvokeCount_3B, handlerInvokeCount, 12, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FInvoker_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FMembershipRegistry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipRegistry_3B, groups, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B, 64, Ljava_2Fnio_2Fchannels_2FMembershipKey_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B, blockedSet, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B, ch, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B, group, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B, interf, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B, source, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B, stateLock, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B, valid, 12, 1)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FNativeThread_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FNativeThreadSet_3B, 25, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FNativeThreadSet_3B, elts, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FNativeThreadSet_3B, used, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FNativeThreadSet_3B, waitingToEmpty, 24, 1)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FNet_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FOptionKey_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FOptionKey_3B, level, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FOptionKey_3B, name, 16, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_24DefaultOptionsHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_24DefaultExecutorHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketChannelImpl_24DefaultOptionsHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketOptionRegistry_24LazyInitialization_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketOptionRegistry_24RegistryKey_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketOptionRegistry_24RegistryKey_3B, family, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketOptionRegistry_24RegistryKey_3B, name, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketOptionRegistry_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FThreadPool_24DefaultThreadPoolHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUtil_24BufferCache_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUtil_24BufferCache_3B, buffers, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUtil_24BufferCache_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUtil_24BufferCache_3B, start, 24, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fcs_2FThreadLocalCoders_24Cache_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FThreadLocalCoders_24Cache_3B, cache, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FThreadLocalCoders_24Cache_3B, size, 12, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fcs_2FThreadLocalCoders_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractBasicFileAttributeView_24AttributesBuilder_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractBasicFileAttributeView_24AttributesBuilder_3B, copyAll, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractBasicFileAttributeView_24AttributesBuilder_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractBasicFileAttributeView_24AttributesBuilder_3B, names, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractPoller_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractPoller_24Request_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPoller_24Request_3B, completed, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPoller_24Request_3B, params, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPoller_24Request_3B, result, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPoller_24Request_3B, type, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractPoller_24RequestType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FDefaultFileSystemProvider_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FDefaultFileTypeDetector_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FGlobs_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxFileSystem_24SupportedFileFileAttributeViewsHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FNativeBuffer_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FNativeBuffer_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FNativeBuffer_3B, cleaner, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FNativeBuffer_3B, owner, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FNativeBuffer_3B, size, 12, 4)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FNativeBuffers_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FPollingWatchService_24CacheEntry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24CacheEntry_3B, lastModified, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24CacheEntry_3B, lastTickCount, 12, 4)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, 22, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, append, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, create, 13, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, createNew, 14, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, deleteOnClose, 15, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, dsync, 16, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, noFollowLinks, 17, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, read, 18, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, sync, 19, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, truncateExisting, 20, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_24Flags_3B, write, 21, 1)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixChannelFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixPath_3B, 48, Lsun_2Fnio_2Ffs_2FAbstractPath_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixPath_3B, fs, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixPath_3B, hash, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixPath_3B, offsets, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixPath_3B, path, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixPath_3B, stringValue, 40, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystem_3B, 40, Ljava_2Fnio_2Ffile_2FFileSystem_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_3B, defaultDirectory, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_3B, needToResolveAgainstDefaultDirectory, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_3B, provider, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_3B, rootDirectory, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystemProvider_3B, 24, Lsun_2Fnio_2Ffs_2FAbstractFileSystemProvider_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystemProvider_3B, theFileSystem, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractFileTypeDetector_3B, 12, Ljava_2Fnio_2Ffile_2Fspi_2FFileTypeDetector_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractFileSystemProvider_3B, 12, Ljava_2Fnio_2Ffile_2Fspi_2FFileSystemProvider_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixMountEntry_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixMountEntry_3B, dev, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixMountEntry_3B, dir, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixMountEntry_3B, fstype, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixMountEntry_3B, fstypeAsString, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixMountEntry_3B, name, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixMountEntry_3B, optionsAsString, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixMountEntry_3B, opts, 64, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractPath_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixConstants_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, 22, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, atomicMove, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, copyBasicAttributes, 13, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, copyNonPosixAttributes, 14, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, copyPosixAttributes, 15, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, failIfUnableToCopyBasic, 16, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, failIfUnableToCopyNonPosix, 17, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, failIfUnableToCopyPosix, 18, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, followLinks, 19, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, interruptible, 20, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_24Flags_3B, replaceExisting, 21, 1)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixCopyFile_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, 140, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, group, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, key, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, owner, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__atime__nsec, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__atime__sec, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__birthtime__sec, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__ctime__nsec, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__ctime__sec, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__dev, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__gid, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__ino, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__mode, 96, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__mtime__nsec, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__mtime__sec, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__nlink, 100, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__rdev, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__size, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_3B, st__uid, 136, 4)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileKey_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileKey_3B, st__dev, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileKey_3B, st__ino, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileAttributeViews_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileAttributeViews_24Basic_3B, 24, Lsun_2Fnio_2Ffs_2FAbstractBasicFileAttributeView_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributeViews_24Basic_3B, file, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributeViews_24Basic_3B, followLinks, 12, 1)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractBasicFileAttributeView_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FFileOwnerAttributeViewImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FFileOwnerAttributeViewImpl_3B, isPosixView, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FFileOwnerAttributeViewImpl_3B, view, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileAttributeViews_24Posix_3B, 24, Lsun_2Fnio_2Ffs_2FUnixFileAttributeViews_24Basic_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileAttributeViews_24Unix_3B, 24, Lsun_2Fnio_2Ffs_2FUnixFileAttributeViews_24Posix_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileModeAttribute_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileModeAttribute_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileStoreAttributes_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileStoreAttributes_3B, f__bavail, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileStoreAttributes_3B, f__bfree, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileStoreAttributes_3B, f__blocks, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileStoreAttributes_3B, f__frsize, 40, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystem_24LookupService_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystemProvider_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixNativeDispatcher_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixUriUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixUserPrincipals_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixUserPrincipals_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixUserPrincipals_24User_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixUserPrincipals_24User_3B, id, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixUserPrincipals_24User_3B, isGroup, 16, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixUserPrincipals_24User_3B, name, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixUserPrincipals_24Group_3B, 32, Lsun_2Fnio_2Ffs_2FUnixUserPrincipals_24User_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Freflect_2FReflection_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Freflect_2Fmisc_2FReflectUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FGetInstance_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FJCAUtil_24CachedSecureRandomHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FJCAUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderConfig_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderConfig_3B, argument, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderConfig_3B, className, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderConfig_3B, isLoading, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderConfig_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderConfig_3B, tries, 40, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderList_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_3B, allLoaded, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_3B, configs, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_3B, userList, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderList_241_3B, 144, Ljava_2Fsecurity_2FProvider_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviders_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FServiceId_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FServiceId_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FServiceId_3B, type, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FContentInfo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FContentInfo_3B, content, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FContentInfo_3B, contentType, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FESSCertId_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FESSCertId_3B, certHash, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FESSCertId_3B, issuer, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FESSCertId_3B, serialNumber, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FGeneralNames_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FGeneralNames_3B, names, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FSerialNumber_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FSerialNumber_3B, serialNum, 16, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FHexDumpEncoder_3B, 44, Lsun_2Fmisc_2FCharacterEncoder_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FHexDumpEncoder_3B, currentByte, 24, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FHexDumpEncoder_3B, offset, 28, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FHexDumpEncoder_3B, thisLine, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FHexDumpEncoder_3B, thisLineLength, 40, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, certIssuerNames, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, certificates, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, contentInfo, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, contentType, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, crls, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, digestAlgorithmIds, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, oldStyle, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, signerInfos, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_3B, version, 72, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FX509CRL_3B, 32, Ljava_2Fsecurity_2Fcert_2FCRL_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CRL_3B, issuerPrincipal, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FX509CRLEntry_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCRLReason_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, authenticatedAttributes, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, certificateSerialNumber, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, digestAlgorithmId, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, digestEncryptionAlgorithmId, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, encryptedDigest, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, hasTimestamp, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, issuerName, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, timestamp, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, unauthenticatedAttributes, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSignerInfo_3B, version, 80, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attributes_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attributes_3B, attributes, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attributes_3B, derEncoding, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attributes_3B, ignoreUnsupportedAttributes, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attributes_3B, permittedAttributes, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attribute_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attribute_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attribute_3B, oid, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS9Attribute_3B, value, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_3B, 40, Lsun_2Fsecurity_2Futil_2FAbstractAlgorithmConstraints_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_3B, algorithmConstraints, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_3B, disabledAlgorithms, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraints_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraints_3B, constraintsMap, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FCertConstraintParameters_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FCertConstraintParameters_3B, cert, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FCertConstraintParameters_3B, trustedMatch, 12, 1)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FAlgorithmDecomposer_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FAbstractAlgorithmConstraints_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FAbstractAlgorithmConstraints_3B, decomposer, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Ftimestamp_2FTimestampToken_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Ftimestamp_2FTimestampToken_3B, genTime, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Ftimestamp_2FTimestampToken_3B, hashAlgorithm, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Ftimestamp_2FTimestampToken_3B, hashedMessage, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Ftimestamp_2FTimestampToken_3B, nonce, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Ftimestamp_2FTimestampToken_3B, policy, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Ftimestamp_2FTimestampToken_3B, serialNumber, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Ftimestamp_2FTimestampToken_3B, version, 12, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FSigningCertificateInfo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSigningCertificateInfo_3B, ber, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FSigningCertificateInfo_3B, certId, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2FX509Factory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FCache_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, 152, Ljava_2Fsecurity_2Fcert_2FX509CRL_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, extensions, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, infoSigAlgId, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, issuer, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, issuerPrincipal, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, nextUpdate, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, readOnly, 72, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, revokedList, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, revokedMap, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, sigAlgId, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, signature, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, signedCRL, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, tbsCertList, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, thisUpdate, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, verifiedProvider, 136, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, verifiedPublicKey, 144, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_3B, version, 76, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCRLExtensions_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCRLExtensions_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCRLExtensions_3B, unsupportedCritExt, 12, 1)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX509CRLEntryImpl_3B, 56, Ljava_2Fsecurity_2Fcert_2FX509CRLEntry_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLEntryImpl_3B, certIssuer, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLEntryImpl_3B, extensions, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLEntryImpl_3B, revocationDate, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLEntryImpl_3B, revokedCert, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLEntryImpl_3B, serialNumber, 48, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificateIssuerExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateIssuerExtension_3B, names, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FKeyIdentifier_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FKeyIdentifier_3B, octetString, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FAuthorityKeyIdentifierExtension_3B, 56, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAuthorityKeyIdentifierExtension_3B, id, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAuthorityKeyIdentifierExtension_3B, names, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAuthorityKeyIdentifierExtension_3B, serialNum, 48, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCRLNumberExtension_3B, 56, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCRLNumberExtension_3B, crlNumber, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCRLNumberExtension_3B, extensionLabel, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCRLNumberExtension_3B, extensionName, 48, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FDeltaCRLIndicatorExtension_3B, 56, Lsun_2Fsecurity_2Fx509_2FCRLNumberExtension_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FIssuerAlternativeNameExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIssuerAlternativeNameExtension_3B, names, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FIssuingDistributionPointExtension_3B, 56, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIssuingDistributionPointExtension_3B, distributionPoint, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIssuingDistributionPointExtension_3B, hasOnlyAttributeCerts, 40, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIssuingDistributionPointExtension_3B, hasOnlyCACerts, 41, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIssuingDistributionPointExtension_3B, hasOnlyUserCerts, 42, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIssuingDistributionPointExtension_3B, isIndirectCRL, 43, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIssuingDistributionPointExtension_3B, revocationReasons, 48, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FDistributionPointName_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FDistributionPointName_3B, fullName, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FDistributionPointName_3B, hashCode, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FDistributionPointName_3B, relativeName, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FReasonFlags_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FReasonFlags_3B, bitString, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, 136, Ljava_2Fsecurity_2Fcert_2FX509Certificate_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, algId, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, authInfoAccess, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, extKeyUsage, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, fingerprints, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, info, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, issuerAlternativeNames, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, readOnly, 88, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, signature, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, signedCert, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, subjectAlternativeNames, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, verificationResult, 89, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, verifiedProvider, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertImpl_3B, verifiedPublicKey, 128, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, 104, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, algId, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, extensions, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, interval, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, issuer, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, issuerUniqueId, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, pubKey, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, rawCertInfo, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, serialNum, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, subject, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, subjectUniqueId, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CertInfo_3B, version, 96, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificateAlgorithmId_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateAlgorithmId_3B, algId, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificateExtensions_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateExtensions_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateExtensions_3B, unparseableExtensions, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateExtensions_3B, unsupportedCritExt, 12, 1)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificateValidity_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateValidity_3B, notAfter, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateValidity_3B, notBefore, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FUniqueIdentity_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FUniqueIdentity_3B, id, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificateX509Key_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateX509Key_3B, key, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificateSerialNumber_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateSerialNumber_3B, serial, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificateVersion_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateVersion_3B, version, 12, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FAuthorityInfoAccessExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAuthorityInfoAccessExtension_3B, accessDescriptions, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FBasicConstraintsExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FBasicConstraintsExtension_3B, ca, 32, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FBasicConstraintsExtension_3B, pathLen, 36, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCRLDistributionPointsExtension_3B, 48, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCRLDistributionPointsExtension_3B, distributionPoints, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCRLDistributionPointsExtension_3B, extensionName, 40, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificatePoliciesExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificatePoliciesExtension_3B, certPolicies, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FExtendedKeyUsageExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FExtendedKeyUsageExtension_3B, keyUsages, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FPolicyConstraintsExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FPolicyConstraintsExtension_3B, inhibit, 32, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FPolicyConstraintsExtension_3B, require, 36, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FPolicyMappingsExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FPolicyMappingsExtension_3B, maps, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FPrivateKeyUsageExtension_3B, 48, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FPrivateKeyUsageExtension_3B, notAfter, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FPrivateKeyUsageExtension_3B, notBefore, 40, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FSubjectAlternativeNameExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FSubjectAlternativeNameExtension_3B, names, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FSubjectKeyIdentifierExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FSubjectKeyIdentifierExtension_3B, id, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdjacencyList_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdjacencyList_3B, mOrigList, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdjacencyList_3B, mStepList, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuildStep_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuildStep_3B, cert, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuildStep_3B, result, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuildStep_3B, throwable, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuildStep_3B, vertex, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FVertex_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FVertex_3B, cert, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FVertex_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FVertex_3B, throwable, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuilder_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuilder_3B, buildParams, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuilder_3B, matchingPolicies, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuilder_3B, targetCertConstraints, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24BuilderParams_3B, 112, Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24BuilderParams_3B, params, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24BuilderParams_3B, stores, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24BuilderParams_3B, targetSubject, 104, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FPKIXBuilderParameters_3B, 84, Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXBuilderParameters_3B, maxPathLength, 80, 4)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, anyPolicyInhibited, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, certPathCheckers, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, certSelector, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, certStores, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, date, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, explicitPolicyRequired, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, policyMappingInhibited, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, policyQualifiersRejected, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, revocationEnabled, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, sigProvider, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, unmodInitialPolicies, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXParameters_3B, unmodTrustAnchors, 72, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FPKIXCertPathChecker_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, 200, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, authorityKeyID, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, basicConstraints, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, certificateValid, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, issuer, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, keyPurposeOIDSet, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, keyPurposeSet, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, keyUsage, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, matchAllSubjectAltNames, 64, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, nc, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, ncBytes, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, pathToGeneralNames, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, pathToNames, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, policy, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, policySet, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, privateKeyValid, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, serialNumber, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, subject, 136, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, subjectAlternativeGeneralNames, 144, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, subjectAlternativeNames, 152, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, subjectKeyID, 160, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, subjectPublicKey, 168, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, subjectPublicKeyAlgID, 176, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, subjectPublicKeyBytes, 184, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B, x509Cert, 192, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificatePolicySet_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificatePolicySet_3B, ids, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, anchors, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, certPath, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, certs, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, checkers, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, constraints, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, date, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, gotConstraints, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, gotDate, 13, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, params, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, policies, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24ValidatorParams_3B, stores, 80, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertId_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertId_3B, certSerialNumber, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertId_3B, hashAlgId, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertId_3B, issuerKeyHash, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertId_3B, issuerNameHash, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertId_3B, myhash, 12, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertPathHelper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FX509CRLSelector_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CRLSelector_3B, certChecking, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CRLSelector_3B, dateAndTime, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CRLSelector_3B, issuerNames, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CRLSelector_3B, issuerX500Principals, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CRLSelector_3B, maxCRL, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CRLSelector_3B, minCRL, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FX509CRLSelector_3B, skew, 64, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertStoreHelper_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertStoreException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FDistributionPointFetcher_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FURIName_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FURIName_3B, host, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FURIName_3B, hostDNS, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FURIName_3B, hostIP, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FURIName_3B, uri, 40, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FDNSName_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FDNSName_3B, name, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FIPAddressName_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIPAddressName_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIPAddressName_3B, isIPv4, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FIPAddressName_3B, name, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FDistributionPoint_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FDistributionPoint_3B, crlIssuer, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FDistributionPoint_3B, fullName, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FDistributionPoint_3B, hashCode, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FDistributionPoint_3B, reasonFlags, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FDistributionPoint_3B, relativeName, 40, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSP_24RevocationStatus_24CertStatus_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSP_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, 96, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, certs, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, responderKeyId, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, responderName, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, responseNonce, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, responseStatus, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, sigAlgId, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, signature, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, signerCert, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, singleResponseMap, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_3B, tbsResponseData, 88, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_24ResponseStatus_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_24SingleResponse_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_24SingleResponse_3B, certId, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_24SingleResponse_3B, certStatus, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_24SingleResponse_3B, nextUpdate, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_24SingleResponse_3B, revocationReason, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_24SingleResponse_3B, revocationTime, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_24SingleResponse_3B, singleExtensions, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_24SingleResponse_3B, thisUpdate, 64, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPResponse_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPRequest_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPRequest_3B, certIds, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPRequest_3B, extensions, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FOCSPRequest_3B, nonce, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIXMasterCertPathValidator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RevocationProperties_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RevocationProperties_3B, crlDPEnabled, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RevocationProperties_3B, ocspEnabled, 13, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RevocationProperties_3B, ocspIssuer, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RevocationProperties_3B, ocspSerial, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RevocationProperties_3B, ocspSubject, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RevocationProperties_3B, ocspUrl, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RevocationProperties_3B, onlyEE, 14, 1)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FX509CertificatePair_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FX509CertificatePair_3B, encoded, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FX509CertificatePair_3B, forward, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FX509CertificatePair_3B, reverse, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FAnchorCertificates_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FCache_24EqualByteArray_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FCache_24EqualByteArray_3B, b, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FCache_24EqualByteArray_3B, hash, 12, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, 60, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, dataPos, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, dataSize, 24, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, index, 28, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, ndefsList, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, newData, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, newDataPos, 48, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, numOfTotalLenBytes, 52, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDerIndefLenConverter_3B, unresolved, 56, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraint_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraint_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraint_3B, nextConstraint, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FKeyUtil_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FManifestEntryVerifier_24SunProviderHolder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FPropertyExpander_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FResourcesMgr_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FSecurityConstants_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FAllPermission_3B, 24, Ljava_2Fsecurity_2FPermission_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FSecurityPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljava_2Fnet_2FNetPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljava_2Fnet_2FSocketPermission_3B, 24, Ljava_2Fsecurity_2FPermission_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FSignatureFileVerifier_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FSignatureFileVerifier_3B, block, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FSignatureFileVerifier_3B, certificateFactory, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FSignatureFileVerifier_3B, createdDigests, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FSignatureFileVerifier_3B, md, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FSignatureFileVerifier_3B, name, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FSignatureFileVerifier_3B, sfBytes, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FSignatureFileVerifier_3B, signerCache, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FSignatureFileVerifier_3B, workaround, 12, 1)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FAVAKeyword_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAVAKeyword_3B, keyword, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAVAKeyword_3B, oid, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAVAKeyword_3B, rfc1779Compliant, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAVAKeyword_3B, rfc2253Compliant, 13, 1)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FAccessDescription_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAccessDescription_3B, accessLocation, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAccessDescription_3B, accessMethod, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FAccessDescription_3B, myhash, 12, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificatePolicyId_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificatePolicyId_3B, id, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificatePolicyMap_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificatePolicyMap_3B, issuerDomain, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificatePolicyMap_3B, subjectDomain, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FNetscapeCertTypeExtension_24MapEntry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FNetscapeCertTypeExtension_24MapEntry_3B, mName, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FNetscapeCertTypeExtension_24MapEntry_3B, mPosition, 12, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FOIDMap_24OIDInfo_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FOIDMap_24OIDInfo_3B, clazz, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FOIDMap_24OIDInfo_3B, name, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FOIDMap_24OIDInfo_3B, oid, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FOIDMap_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FPKIXExtensions_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FPolicyInformation_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FPolicyInformation_3B, policyIdentifier, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FPolicyInformation_3B, policyQualifiers, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX509AttributeName_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509AttributeName_3B, prefix, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509AttributeName_3B, suffix, 24, 8)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FCalendarUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveString_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveString_3B, lowerStr, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FInternalLocaleBuilder_24CaseInsensitiveString_3B, str, 24, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FLocaleEquivalentMaps_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FLocaleMatcher_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FLocaleUtils_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2Fprovider_2FCalendarDataUtility_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flogging_2FLoggingSupport_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCacheValue_24NullValue_3B, 12, Landroid_2Ficu_2Fimpl_2FCacheValue_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCacheValue_24SoftValue_3B, 24, Landroid_2Ficu_2Fimpl_2FCacheValue_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCacheValue_24SoftValue_3B, ref, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCacheValue_24StrongValue_3B, 24, Landroid_2Ficu_2Fimpl_2FCacheValue_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCacheValue_24StrongValue_3B, value, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_241_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_242_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_243_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_244_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarAstronomer_244_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCalendarUtil_24CalendarPreferences_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCalendarUtil_24CalendarPreferences_3B, prefs, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FClassLoaderUtil_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FClassLoaderUtil_24BootstrapClassLoader_3B, 56, Ljava_2Flang_2FClassLoader_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCurrencyData_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesCountSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesCountSink_3B, data, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesDataSink_3B, 48, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesDataSink_3B, cutoffType, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesDataSink_3B, cutoffs, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesDataSink_3B, data, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesDataSink_3B, period, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24DayPeriodRulesDataSink_3B, ruleSetNum, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FDayPeriodRules_24CutoffType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FDontCareFieldPosition_3B, 32, Ljava_2Ftext_2FFieldPosition_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUBinary_24PackageDataFile_3B, 32, Landroid_2Ficu_2Fimpl_2FICUBinary_24DataFile_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUBinary_24PackageDataFile_3B, pkgBytes, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUBinary_24SingleDataFile_3B, 32, Landroid_2Ficu_2Fimpl_2FICUBinary_24DataFile_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUBinary_24SingleDataFile_3B, path, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUConfig_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUConfig_241_3B, val_24fname, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_3B, 72, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_3B, entrypointTable, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_3B, formattingData, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_3B, narrowSymbol, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_3B, noRoot, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_3B, parsingData, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_3B, pluralsData, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_3B, spacingInfo, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_3B, unitPatterns, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_24CurrencySink_24EntrypointTable_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_3B, currencyDisplayInfoCache, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, 80, Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencyDisplayInfo_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, fallback, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, formattingDataCache, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, locale, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, narrowSymbolCache, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, parsingDataCache, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, pluralsDataCache, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, rb, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, spacingInfoCache, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyDisplayInfoProvider_24ICUCurrencyDisplayInfo_3B, unitPatternsCache, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_24CurrencyCollector_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_24CurrencyCollector_3B, result, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_24InfoCollector_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_24InfoCollector_3B, result, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_24RegionCollector_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_24RegionCollector_3B, result, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_3B, 32, Landroid_2Ficu_2Ftext_2FCurrencyMetaInfo_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_3B, digitInfo, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUCurrencyMetaInfo_3B, regionInfo, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUData_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUData_241_3B, val_24resourceName, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUData_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUData_242_3B, val_24resourceName, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUData_242_3B, val_24root, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUData_243_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUData_243_3B, val_24loader, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUData_243_3B, val_24resourceName, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKey_3B, 56, Landroid_2Ficu_2Fimpl_2FICUService_24Key_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKey_3B, currentID, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKey_3B, fallbackID, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKey_3B, kind, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKey_3B, primaryID, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKey_3B, varstart, 44, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKeyFactory_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKeyFactory_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKeyFactory_3B, visible, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_242_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_242_241_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_242_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_242_3B, val_24bn, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_242_3B, val_24names, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_242_3B, val_24root, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_244_3B, 64, Landroid_2Ficu_2Fimpl_2FICUResourceBundle_24Loader_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_244_3B, val_24baseName, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_244_3B, val_24defaultID, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_244_3B, val_24fullName, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_244_3B, val_24localeID, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_244_3B, val_24openType, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_244_3B, val_24root, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUService_24SimpleFactory_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_24SimpleFactory_3B, id, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_24SimpleFactory_3B, instance, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUService_24SimpleFactory_3B, visible, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FIntTrieBuilder_3B, 64, Landroid_2Ficu_2Fimpl_2FTrieBuilder_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FIntTrieBuilder_3B, m__data__, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FIntTrieBuilder_3B, m__initialValue__, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FIntTrieBuilder_3B, m__leadUnitValue__, 60, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FIterableComparator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FIterableComparator_3B, comparator, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FIterableComparator_3B, shorterFirst, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24CapitalizationContextSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24CapitalizationContextSink_3B, hasCapitalizationUsage, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24CapitalizationContextSink_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, 128, Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, capitalization, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, capitalizationBrkIter, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, capitalizationUsage, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, currencyDisplayInfo, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, dialectHandling, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, format, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, formatCloseParen, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, formatOpenParen, 14, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, formatReplaceCloseParen, 64, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, formatReplaceOpenParen, 66, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, keyTypeFormat, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, langData, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, locale, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, nameLength, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, regionData, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, separatorFormat, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_3B, substituteHandling, 120, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24CapitalizationContextUsage_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24DataTableType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24DataTables_241_3B, 12, Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24DataTables_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24ICUDataTable_3B, 24, Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24DataTable_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24ICUDataTable_3B, bundle, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24ICUDataTables_3B, 24, Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24DataTables_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24ICUDataTables_3B, path, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FLocaleIDParser_241_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPVecToTrieCompactHandler_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPVecToTrieCompactHandler_3B, builder, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPVecToTrieCompactHandler_3B, initialValue, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPropsVectors_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPropsVectors_241_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPropsVectors_24DefaultGetFoldedValue_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FPropsVectors_24DefaultGetFoldedValue_3B, builder, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FPropsVectors_24DefaultGetFoldingOffset_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRelation_24SimpleEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelation_24SimpleEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelation_24SimpleEntry_3B, value, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_24RelDateFmtDataSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_24RelDateFmtDataSink_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, 152, Landroid_2Ficu_2Ftext_2FDateFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, capitalizationBrkIter, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, capitalizationInfoIsSet, 68, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, capitalizationOfRelativeUnitsForListOrMenu, 69, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, capitalizationOfRelativeUnitsForStandAlone, 70, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, combinedFormatHasDateAtStart, 71, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fCombinedFormat, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fDateFormat, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fDatePattern, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fDateStyle, 104, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fDateTimeFormat, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fDates, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fLocale, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fTimeFormat, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fTimePattern, 144, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FRelativeDateFormat_3B, fTimeStyle, 108, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_241_3B, val_24resName, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_3B, 56, Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_24Loader_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_3B, val_24baseName, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_3B, val_24defaultID, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_3B, val_24disableFallback, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_3B, val_24localeID, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_3B, val_24name, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FResourceBundleWrapper_242_3B, val_24root, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FSimpleCache_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FSimpleCache_3B, cacheRef, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FSimpleCache_3B, capacity, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FSimpleCache_3B, type, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FSimpleFilteredSentenceBreakIterator_24Builder_3B, 24, Landroid_2Ficu_2Ftext_2FFilteredBreakIteratorBuilder_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FSimpleFilteredSentenceBreakIterator_24Builder_3B, filterSet, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStaticUnicodeSets_24ParseDataSink_3B, 12, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStringPrepDataReader_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStringPrepDataReader_3B, byteBuffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStringPrepDataReader_3B, unicodeVersion, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStringRange_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStringRange_24Range_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStringRange_24Range_3B, max, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStringRange_24Range_3B, min, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FStringRange_24Ranges_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FStringRange_24Ranges_3B, ranges, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNameSearchHandler_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNameSearchHandler_3B, __matches, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNameSearchHandler_3B, __nameTypes, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_24TZDBNameSearchHandler_3B, __region, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24LongestMatchHandler_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24LongestMatchHandler_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTextTrieMap_24LongestMatchHandler_3B, matches, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericNameSearchHandler_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericNameSearchHandler_3B, __matches, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericNameSearchHandler_3B, __maxMatchLen, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneGenericNames_24GenericNameSearchHandler_3B, __types, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesFactoryImpl_3B, 12, Landroid_2Ficu_2Ftext_2FTimeZoneNames_24Factory_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24NameSearchHandler_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24NameSearchHandler_3B, __matches, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24NameSearchHandler_3B, __maxMatchLen, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24NameSearchHandler_3B, __nameTypes, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZNamesLoader_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZNamesLoader_3B, names, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZNames_24NameTypeIndex_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZoneStringsLoader_3B, 40, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZoneStringsLoader_3B, keyToLoader, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZoneStringsLoader_3B, sb, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24ZoneStringsLoader_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_3B, 48, Landroid_2Ficu_2Ftext_2FTimeZoneNames_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_3B, __mzNamesMap, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_3B, __namesFullyLoaded, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_3B, __namesTrie, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_3B, __namesTrieFullyLoaded, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_3B, __tzNamesMap, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_3B, __zoneStrings, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24MZ2TZsCache_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneNamesImpl_24TZ2MZsCache_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie_24DefaultGetFoldingOffset_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrie2_24Trie2Iterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Trie2Iterator_3B, doLeadSurrogates, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Trie2Iterator_3B, doingCodePoints, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Trie2Iterator_3B, limitCP, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Trie2Iterator_3B, mapper, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Trie2Iterator_3B, nextStart, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Trie2Iterator_3B, returnValue, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrie2_24Trie2Iterator_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, m__currentCodepoint__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, m__initialValue__, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, m__nextBlockIndex__, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, m__nextBlock__, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, m__nextCodepoint__, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, m__nextIndex__, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, m__nextTrailIndexOffset__, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, m__nextValue__, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTrieIterator_3B, m__trie__, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUBiDiProps_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCaseProps_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterNameReader_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterNameReader_3B, m__algnamesindex__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterNameReader_3B, m__byteBuffer__, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterNameReader_3B, m__groupindex__, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterNameReader_3B, m__groupstringindex__, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterNameReader_3B, m__tokenstringindex__, 32, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2410_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2410_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2411_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2411_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2412_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2412_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2413_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2413_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2416_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2416_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2419_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2419_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_241_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_241_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2420_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2420_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2421_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2421_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2425_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2425_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2426_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2426_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2427_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2427_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_242_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_242_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_243_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_243_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_244_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_244_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_245_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_245_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_246_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_246_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_247_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_247_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_248_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_248_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_249_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_249_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BiDiIntProperty_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BiDiIntProperty_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24CaseBinaryProperty_3B, 44, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24CaseBinaryProperty_3B, this_240, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24CaseBinaryProperty_3B, which, 40, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24CombiningClassIntProperty_3B, 40, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24CombiningClassIntProperty_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IsAcceptable_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24NormInertBinaryProperty_3B, 44, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BinaryProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24NormInertBinaryProperty_3B, this_240, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24NormInertBinaryProperty_3B, which, 40, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24NormQuickCheckIntProperty_3B, 48, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24IntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24NormQuickCheckIntProperty_3B, max, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24NormQuickCheckIntProperty_3B, this_240, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24NormQuickCheckIntProperty_3B, which, 36, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FURLHandler_24FileURLHandler_3B, 24, Landroid_2Ficu_2Fimpl_2FURLHandler_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FURLHandler_24FileURLHandler_3B, file, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FURLHandler_24JarURLHandler_3B, 32, Landroid_2Ficu_2Fimpl_2FURLHandler_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FURLHandler_24JarURLHandler_3B, jarFile, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FURLHandler_24JarURLHandler_3B, prefix, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUTS46_3B, 16, Landroid_2Ficu_2Ftext_2FIDNA_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUTS46_3B, options, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUnicodeRegex_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeRegex_241_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUnicodeRegex_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeRegex_3B, LongestFirst, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeRegex_3B, bnfCommentString, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeRegex_3B, bnfLineSeparator, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeRegex_3B, bnfVariableInfix, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUnicodeRegex_3B, symbolTable, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_24BundleImporter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_24CEFinalizer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_24CEFinalizer_3B, finalCEs, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, 120, Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationRuleParser_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, base, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, baseData, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, ces, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, cesLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, dataBuilder, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, fastLatinEnabled, 48, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, fcd, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, nfcImpl, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, nfd, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, nodes, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, optimizeSet, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, rootElements, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, rootPrimaryIndexes, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationBuilder_3B, variableTop, 112, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FIterCollationIterator_3B, 64, Landroid_2Ficu_2Fimpl_2Fcoll_2FCollationIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FIterCollationIterator_3B, iter, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatter_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatter_3B, builder, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatter_3B, fallback, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatter_3B, fallbackLimit, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatter_3B, formatter, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatter_3B, localeName, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatter_3B, timeZone, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatterFactory_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatterFactory_3B, builder, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatterFactory_3B, f, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatterFactory_3B, fallback, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatterFactory_3B, fallbackLimit, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatterFactory_3B, formatter, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatterFactory_3B, localeName, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatterFactory_3B, ps, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormatterFactory_3B, timeZone, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterService_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterService_3B, ds, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatter_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatter_3B, customs, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatter_3B, data, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatter_3B, factory, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatter_3B, localeName, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_3B, customizations, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_3B, customizationsInUse, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_3B, data, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_3B, ds, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicPeriodFormatterFactory_3B, localeName, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FPeriodBuilderImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FPeriodBuilderImpl_3B, settings, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FResourceBasedPeriodFormatterDataService_3B, 48, Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FPeriodFormatterDataService_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FResourceBasedPeriodFormatterDataService_3B, availableLocales, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FResourceBasedPeriodFormatterDataService_3B, cache, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FResourceBasedPeriodFormatterDataService_3B, lastData, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FResourceBasedPeriodFormatterDataService_3B, lastLocale, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FXMLRecordReader_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FXMLRecordReader_3B, atTag, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FXMLRecordReader_3B, nameStack, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FXMLRecordReader_3B, r, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FXMLRecordReader_3B, tag, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FXMLRecordWriter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FXMLRecordWriter_3B, nameStack, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2Fimpl_2FXMLRecordWriter_3B, w, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24CodepointsTypeHandler_3B, 12, Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24SpecialTypeHandler_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24PrivateUseKeyValueTypeHandler_3B, 12, Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24SpecialTypeHandler_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24ReorderCodeTypeHandler_3B, 12, Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24SpecialTypeHandler_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24RgKeyValueTypeHandler_3B, 12, Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24SpecialTypeHandler_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24SubdivisionKeyValueTypeHandler_3B, 12, Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24SpecialTypeHandler_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FUnicodeLocaleExtension_3B, 40, Landroid_2Ficu_2Fimpl_2Flocale_2FExtension_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FUnicodeLocaleExtension_3B, __attributes, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FUnicodeLocaleExtension_3B, __keywords, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24HashMultimap_3B, 32, Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Multimap_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24LinkedHashMultimap_3B, 32, Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24Multimap_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24MultimapIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24MultimapIterator_3B, entry, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24MultimapIterator_3B, it1, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24MultimapIterator_3B, it2, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24ReusableEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24ReusableEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXCldrStub_24ReusableEntry_3B, value, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24Maker_241_3B, 12, Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24Maker_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24Maker_242_3B, 12, Landroid_2Ficu_2Fimpl_2Flocale_2FXLikelySubtags_24Maker_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24AddSub_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24AddSub_3B, desiredSub, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24AddSub_3B, r, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24AddSub_3B, supportedSub, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24CopyIfEmpty_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24CopyIfEmpty_3B, toCopy, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24StringDistanceNode_3B, 24, Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24DistanceNode_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24StringDistanceNode_3B, distanceTable, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FCompactData_24CompactDataSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCompactData_24CompactDataSink_3B, data, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FCompactData_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCompactData_3B, isEmpty, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCompactData_3B, largestMagnitude, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCompactData_3B, multipliers, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCompactData_3B, patterns, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantAffixModifier_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantAffixModifier_3B, field, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantAffixModifier_3B, prefix, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantAffixModifier_3B, strong, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantAffixModifier_3B, suffix, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FCurrencyPluralInfoAffixProvider_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCurrencyPluralInfoAffixProvider_3B, affixesByPlural, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FPropertiesAffixPatternProvider_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPropertiesAffixPatternProvider_3B, negPrefix, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPropertiesAffixPatternProvider_3B, negSuffix, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPropertiesAffixPatternProvider_3B, posPrefix, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FPropertiesAffixPatternProvider_3B, posSuffix, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FLongNameHandler_24PluralTableSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FLongNameHandler_24PluralTableSink_3B, outArray, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FLongNameHandler_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FLongNameHandler_3B, modifiers, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FLongNameHandler_3B, parent, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FLongNameHandler_3B, rules, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FMultiplierFormatHandler_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMultiplierFormatHandler_3B, multiplier, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FMultiplierFormatHandler_3B, parent, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FProperties_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FProperties_3B, instance, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixMatcher_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixMatcher_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixMatcher_3B, flags, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixMatcher_3B, prefix, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixMatcher_3B, suffix, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixPatternMatcher_3B, 52, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSeriesMatcher_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixPatternMatcher_3B, affixPattern, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixPatternMatcher_3B, factory, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixPatternMatcher_3B, ignorables, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FAffixPatternMatcher_3B, lastTypeOrCp, 48, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSeriesMatcher_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSeriesMatcher_3B, frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSeriesMatcher_3B, matchers, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCodePointMatcher_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FCodePointMatcher_3B, cp, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, decimalSeparator, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, decimalUniSet, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, digitStrings, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, grouping1, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, grouping2, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, groupingDisabled, 44, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, groupingSeparator, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, groupingUniSet, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, integerOnly, 45, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, leadSet, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, requireGroupingMatch, 46, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FDecimalMatcher_3B, separatorSet, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FParsedNumber_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FScientificMatcher_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FScientificMatcher_3B, customMinusSign, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FScientificMatcher_3B, customPlusSign, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FScientificMatcher_3B, exponentMatcher, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FScientificMatcher_3B, exponentSeparatorString, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FValidationMatcher_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FStandardPluralRanges_24PluralRangesDataSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Frange_2FStandardPluralRanges_24PluralRangesDataSink_3B, output, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Ftext_2FRbnfScannerProviderImpl_24RbnfLenientScannerImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Ftext_2FRbnfScannerProviderImpl_24RbnfLenientScannerImpl_3B, collator, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Ftext_2FRbnfScannerProviderImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Ftext_2FRbnfScannerProviderImpl_3B, cache, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacter_24DummyValueIterator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacter_24UCharacterTypeIterator_24MaskType_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacter_24UCharacterTypeIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacter_24UCharacterTypeIterator_3B, range, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacter_24UCharacterTypeIterator_3B, trieIterator, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacter_24UnicodeBlock_3B, 28, Ljava_2Flang_2FCharacter_24Subset_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacter_24UnicodeBlock_3B, m__id__, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacterCategory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacterDirection_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Flang_2FUCharacterNameIterator_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacterNameIterator_3B, m__algorithmIndex__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacterNameIterator_3B, m__choice__, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacterNameIterator_3B, m__current__, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacterNameIterator_3B, m__groupIndex__, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacterNameIterator_3B, m__limit__, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacterNameIterator_3B, m__name__, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Flang_2FUCharacterNameIterator_3B, m__start__, 40, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FCompactNotation_24CompactHandler_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FCompactNotation_24CompactHandler_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FCompactNotation_24CompactHandler_3B, parent, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FCompactNotation_24CompactHandler_3B, precomputedMods, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FCompactNotation_24CompactHandler_3B, rules, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_24NumberRangeDataSink_3B, 40, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_24NumberRangeDataSink_3B, approximatelyPattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_24NumberRangeDataSink_3B, rangePattern, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FNumberRangeFormatterImpl_24NumberRangeDataSink_3B, sb, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FScientificNotation_24ScientificHandler_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_24ScientificHandler_3B, exponent, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_24ScientificHandler_3B, notation, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_24ScientificHandler_3B, parent, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_24ScientificHandler_3B, precomputedMods, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_24ScientificHandler_3B, symbols, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FScientificNotation_24ScientificModifier_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_24ScientificModifier_3B, exponent, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fnumber_2FScientificNotation_24ScientificModifier_3B, handler, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAbsoluteValueSubstitution_3B, 32, Landroid_2Ficu_2Ftext_2FNFSubstitution_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBreakIteratorFactory_3B, 12, Landroid_2Ficu_2Ftext_2FBreakIterator_24BreakIteratorServiceShim_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICULocaleService_3B, 112, Landroid_2Ficu_2Fimpl_2FICUService_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_3B, fallbackLocale, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_3B, fallbackLocaleName, 104, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBytesDictionaryMatcher_3B, 24, Landroid_2Ficu_2Ftext_2FDictionaryMatcher_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBytesDictionaryMatcher_3B, characters, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBytesDictionaryMatcher_3B, transform, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCaseFoldTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCaseFoldTransliterator_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCaseFoldTransliterator_242_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCaseFoldTransliterator_3B, 56, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCaseFoldTransliterator_3B, csp, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCaseFoldTransliterator_3B, iter, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCaseFoldTransliterator_3B, result, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, contextLimit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, contextStart, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, cpLimit, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, cpStart, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, dir, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, index, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, limit, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, reachedLimit, 40, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FReplaceableContextIterator_3B, rep, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsDictionaryMatcher_3B, 24, Landroid_2Ficu_2Ftext_2FDictionaryMatcher_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsDictionaryMatcher_3B, characters, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecognizer_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__UTF8_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecognizer_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecognizer_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecognizer_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser__IBM420_3B, 49, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24NGramParser__IBM420_3B, alef, 48, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecognizer_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollationElementIterator_24MaxExpSink_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollationElementIterator_24MaxExpSink_3B, maxExpansions, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollator_24KeywordsSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollator_24KeywordsSink_3B, hasDefault, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollator_24KeywordsSink_3B, values, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollatorServiceShim_3B, 12, Landroid_2Ficu_2Ftext_2FCollator_24ServiceShim_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CalendarDataSink_3B, 72, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CalendarDataSink_3B, aliasPathPairs, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CalendarDataSink_3B, aliasRelativePath, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CalendarDataSink_3B, arrays, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CalendarDataSink_3B, currentCalendarType, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CalendarDataSink_3B, maps, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CalendarDataSink_3B, nextCalendarType, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CalendarDataSink_3B, resourcesToVisit, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CalendarDataSink_24AliasType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_24DateIntervalSink_3B, 32, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_24DateIntervalSink_3B, dateIntervalInfo, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateIntervalInfo_24DateIntervalSink_3B, nextCalendarType, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24AppendItemFormatsSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24AppendItemFormatsSink_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24AppendItemNamesSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24AppendItemNamesSink_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24AvailableFormatsSink_3B, 32, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24AvailableFormatsSink_3B, returnInfo, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24AvailableFormatsSink_3B, this_240, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DayPeriodAllowedHoursSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DayPeriodAllowedHoursSink_3B, tempMap, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_24DecFmtDataSink_3B, 24, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_24DecFmtDataSink_3B, numberElements, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_3B, fSet, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_244_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_245_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_246_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_247_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_248_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FFilteredNormalizer2_3B, 32, Landroid_2Ficu_2Ftext_2FNormalizer2_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FFilteredNormalizer2_3B, norm2, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FFilteredNormalizer2_3B, set, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FFractionalPartSubstitution_3B, 34, Landroid_2Ficu_2Ftext_2FNFSubstitution_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FFractionalPartSubstitution_3B, byDigits, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FFractionalPartSubstitution_3B, useSpaces, 33, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FFunctionReplacer_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FFunctionReplacer_3B, replacer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FFunctionReplacer_3B, translit, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FIntegralPartSubstitution_3B, 32, Landroid_2Ficu_2Ftext_2FNFSubstitution_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24LastResortLocaleDisplayNames_3B, 32, Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24LastResortLocaleDisplayNames_3B, contexts, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24LastResortLocaleDisplayNames_3B, locale, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24UiListItem_24UiListItemComparator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24UiListItem_24UiListItemComparator_3B, collator, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLocaleDisplayNames_24UiListItem_24UiListItemComparator_3B, useSelf, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_242_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_3B, 80, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_3B, caseLocale, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_3B, csp, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_3B, iter, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_3B, locale, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_3B, result, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLowercaseTransliterator_3B, sourceTargetUtility, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FModulusSubstitution_3B, 48, Landroid_2Ficu_2Ftext_2FNFSubstitution_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FModulusSubstitution_3B, divisor, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FModulusSubstitution_3B, ruleToUse, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMultiplierSubstitution_3B, 40, Landroid_2Ficu_2Ftext_2FNFSubstitution_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMultiplierSubstitution_3B, divisor, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNameUnicodeTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_244_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_245_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_246_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_24NormalizingTransform_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_24NormalizingTransform_3B, norm2, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24CharsAppendable_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_24CharsAppendable_3B, chars, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_24CharsAppendable_3B, limit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_24CharsAppendable_3B, offset, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_24CharsAppendable_3B, start, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24FCDMode_3B, 12, Landroid_2Ficu_2Ftext_2FNormalizer_24Mode_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFCMode_3B, 12, Landroid_2Ficu_2Ftext_2FNormalizer_24Mode_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFDMode_3B, 12, Landroid_2Ficu_2Ftext_2FNormalizer_24Mode_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFKCMode_3B, 12, Landroid_2Ficu_2Ftext_2FNormalizer_24Mode_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NFKDMode_3B, 12, Landroid_2Ficu_2Ftext_2FNormalizer_24Mode_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_24NONEMode_3B, 12, Landroid_2Ficu_2Ftext_2FNormalizer_24Mode_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizer_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_3B, bufferPos, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_3B, currentIndex, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_3B, mode, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_3B, nextIndex, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_3B, norm2, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_3B, options, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizer_3B, text, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberFormat_24SimpleNumberFormatFactory_3B, 24, Landroid_2Ficu_2Ftext_2FNumberFormat_24NumberFormatFactory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_24SimpleNumberFormatFactory_3B, localeNames, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormat_24SimpleNumberFormatFactory_3B, visible, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberFormatServiceShim_3B, 12, Landroid_2Ficu_2Ftext_2FNumberFormat_24NumberFormatShim_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumeratorSubstitution_3B, 41, Landroid_2Ficu_2Ftext_2FNFSubstitution_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumeratorSubstitution_3B, denominator, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumeratorSubstitution_3B, withZeros, 40, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRulesSerialProxy_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRulesSerialProxy_3B, data, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FQuantifier_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FQuantifier_3B, matcher, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FQuantifier_3B, maxCount, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FQuantifier_3B, minCount, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRBNFChinesePostProcessor_3B, 17, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBNFChinesePostProcessor_3B, format, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRBNFChinesePostProcessor_3B, longForm, 16, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_3B, 56, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_3B, pastFutureIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_3B, qualitativeUnitMap, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_3B, sb, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_3B, style, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_3B, styleRelUnitPatterns, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_3B, unit, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_24DateTimeUnit_3B, 40, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_24DateTimeUnit_3B, absUnit, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24RelDateTimeDataSink_24DateTimeUnit_3B, relUnit, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRemoveTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSameValueSubstitution_3B, 32, Landroid_2Ficu_2Ftext_2FNFSubstitution_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_24MarkupStyle_3B, 32, Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_24Style_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_24MarkupStyle_3B, beginMarkup, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_24MarkupStyle_3B, endMarkup, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_24SuperscriptStyle_3B, 12, Landroid_2Ficu_2Ftext_2FScientificNumberFormatter_24Style_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSpoofChecker_24Builder_24ConfusabledataBuilder_24SPUStringComparator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringReplacer_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringReplacer_3B, cursorPos, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringReplacer_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringReplacer_3B, hasCursor, 24, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringReplacer_3B, isComplex, 25, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringReplacer_3B, output, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_24TimeUnitFormatSetupSink_3B, 48, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_24TimeUnitFormatSetupSink_3B, beenHere, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_24TimeUnitFormatSetupSink_3B, locale, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_24TimeUnitFormatSetupSink_3B, pluralKeywords, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_24TimeUnitFormatSetupSink_3B, style, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_24TimeUnitFormatSetupSink_3B, timeUnitToCountToPatterns, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24DefaultTimeZoneNames_24FactoryImpl_3B, 12, Landroid_2Ficu_2Ftext_2FTimeZoneNames_24Factory_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_242_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_3B, 80, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_3B, caseLocale, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_3B, csp, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_3B, iter, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_3B, locale, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_3B, result, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTitlecaseTransliterator_3B, sourceTargetUtility, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleArray_3B, 24, Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleBody_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleArray_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorParser_24RuleArray_3B, i, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24IDEnumeration_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTransliteratorRegistry_24IDEnumeration_3B, en, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUFieldPosition_3B, 48, Ljava_2Ftext_2FFieldPosition_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUFieldPosition_3B, countVisibleFractionDigits, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUFieldPosition_3B, fractionDigits, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUTF16_24StringComparator_3B, 21, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUTF16_24StringComparator_3B, m__codePointCompare__, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUTF16_24StringComparator_3B, m__foldCase__, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUTF16_24StringComparator_3B, m__ignoreCase__, 20, 1)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnescapeTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnescapeTransliterator_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnescapeTransliterator_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnescapeTransliterator_244_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnescapeTransliterator_245_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnescapeTransliterator_246_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnescapeTransliterator_247_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeCompressor_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeCompressor_3B, fCurrentWindow, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeCompressor_3B, fIndexCount, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeCompressor_3B, fMode, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeCompressor_3B, fOffsets, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeCompressor_3B, fTimeStamp, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeCompressor_3B, fTimeStamps, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeDecompressor_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeDecompressor_3B, fBuffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeDecompressor_3B, fBufferLength, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeDecompressor_3B, fCurrentWindow, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeDecompressor_3B, fMode, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeDecompressor_3B, fOffsets, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeNameTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24EntryRangeIterable_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24EntryRangeIterable_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24EntryRangeIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24EntryRangeIterator_3B, pos, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24EntryRangeIterator_3B, result, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24EntryRangeIterator_3B, this_240, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24GeneralCategoryMaskFilter_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24GeneralCategoryMaskFilter_3B, mask, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24IntPropertyFilter_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24IntPropertyFilter_3B, prop, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24IntPropertyFilter_3B, value, 16, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24NumericValueFilter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24NumericValueFilter_3B, value, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24ScriptExtensionsFilter_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24ScriptExtensionsFilter_3B, script, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24UnicodeSetIterator2_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24UnicodeSetIterator2_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24UnicodeSetIterator2_3B, current, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24UnicodeSetIterator2_3B, item, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24UnicodeSetIterator2_3B, len, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24UnicodeSetIterator2_3B, limit, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24UnicodeSetIterator2_3B, sourceList, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24UnicodeSetIterator2_3B, sourceStrings, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24UnicodeSetIterator2_3B, stringIterator, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeSet_24VersionFilter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnicodeSet_24VersionFilter_3B, version, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_242_3B, this_240, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_3B, 80, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_3B, caseLocale, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_3B, csp, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_3B, iter, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_3B, locale, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_3B, result, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUppercaseTransliterator_3B, sourceTargetUtility, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBytesTrieBuilder_24BytesAsCharSequence_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrieBuilder_24BytesAsCharSequence_3B, len, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrieBuilder_24BytesAsCharSequence_3B, s, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBytesTrieBuilder_3B, 80, Landroid_2Ficu_2Futil_2FStringTrieBuilder_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrieBuilder_3B, bytes, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrieBuilder_3B, bytesLength, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FBytesTrieBuilder_3B, intBytes, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointMap_24RangeIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24RangeIterator_3B, range, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointMap_24RangeIterator_3B, this_240, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Data16_3B, 24, Landroid_2Ficu_2Futil_2FCodePointTrie_24Data_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_24Data16_3B, array, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Data32_3B, 24, Landroid_2Ficu_2Futil_2FCodePointTrie_24Data_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_24Data32_3B, array, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Data8_3B, 24, Landroid_2Ficu_2Futil_2FCodePointTrie_24Data_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_24Data8_3B, array, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast_24FastStringIterator_3B, 48, Landroid_2Ficu_2Futil_2FCodePointMap_24StringIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast_24FastStringIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Small_24SmallStringIterator_3B, 48, Landroid_2Ficu_2Futil_2FCodePointMap_24StringIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_24Small_24SmallStringIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Small_3B, 56, Landroid_2Ficu_2Futil_2FCodePointTrie_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCompactByteArray_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactByteArray_3B, defaultValue, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactByteArray_3B, hashes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactByteArray_3B, indices, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactByteArray_3B, isCompact, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactByteArray_3B, values, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCompactCharArray_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactCharArray_3B, defaultValue, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactCharArray_3B, hashes, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactCharArray_3B, indices, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactCharArray_3B, isCompact, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCompactCharArray_3B, values, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrency_24CurrencyNameResultHandler_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCurrency_24CurrencyNameResultHandler_3B, bestCurrencyISOCode, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCurrency_24CurrencyNameResultHandler_3B, bestMatchLength, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrency_241_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrencyServiceShim_3B, 12, Landroid_2Ficu_2Futil_2FCurrency_24ServiceShim_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FEasterRule_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FEasterRule_3B, calendar, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FEasterRule_3B, daysAfterEaster, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FGregorianCalendar_3B, 146, Landroid_2Ficu_2Futil_2FCalendar_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGregorianCalendar_3B, cutoverJulianDay, 128, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGregorianCalendar_3B, gregorianCutover, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGregorianCalendar_3B, gregorianCutoverYear, 132, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGregorianCalendar_3B, invertGregorian, 144, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGregorianCalendar_3B, isGregorian, 145, 1)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FHoliday_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FHoliday_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FHoliday_3B, rule, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMeasureUnit_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMeasureUnit_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMeasureUnit_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMeasureUnit_244_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMeasureUnit_24CurrencyNumericCodeSink_3B, 12, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMeasureUnit_24MeasureUnitSink_3B, 12, Landroid_2Ficu_2Fimpl_2FUResource_24Sink_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FRangeDateRule_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRangeDateRule_3B, ranges, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FRegion_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRegion_3B, code, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRegion_3B, containedRegions, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRegion_3B, containingRegion, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRegion_3B, id, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRegion_3B, preferredValues, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRegion_3B, type, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FRegion_24RegionType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FSimpleDateRule_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleDateRule_3B, calendar, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleDateRule_3B, dayOfMonth, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleDateRule_3B, dayOfWeek, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FSimpleDateRule_3B, month, 28, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, delims, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__coalesceDelimiters__, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__delimiters__, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__length__, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__nextOffset__, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__returnDelimiters__, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__source__, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__tokenLimit__, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__tokenOffset__, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__tokenSize__, 60, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTokenizer_3B, m__tokenStart__, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24BranchNode_3B, 24, Landroid_2Ficu_2Futil_2FStringTrieBuilder_24Node_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24BranchNode_3B, firstEdgeNumber, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24BranchNode_3B, hash, 20, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTimeUnitAmount_3B, 32, Landroid_2Ficu_2Futil_2FMeasure_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_241ULocaleAcceptLanguageQ_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FULocale_241ULocaleAcceptLanguageQ_3B, q, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FULocale_241ULocaleAcceptLanguageQ_3B, serial, 24, 8)
+__MRT_CLASS(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, 88, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, auto, 12, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, depth, 16, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, elementStack, 24, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, encoding, 32, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, indent, 40, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, mPos, 20, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, mText, 48, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, nspCounts, 56, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, nspStack, 64, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, pending, 72, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, unicode, 73, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlSerializer_3B, writer, 80, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2F_2D_24_24Lambda_24DexPathList_24__CyMypnZmV6ArWiPOPB4EkAIeUc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FBaseDexClassLoader_3B, 72, Ljava_2Flang_2FClassLoader_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FBaseDexClassLoader_3B, pathList, 56, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FBaseDexClassLoader_3B, sharedLibraryLoaders, 64, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FBlockGuard_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FBlockGuard_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FBlockGuard_243_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FCloseGuard_24DefaultReporter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDexFile_24DFEnum_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexFile_24DFEnum_3B, mIndex, 12, 4)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDexFile_24DFEnum_3B, mNameList, 16, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FSocketTagger_241_3B, 12, Ldalvik_2Fsystem_2FSocketTagger_3B)
+__MRT_CLASS(Ljava_2Fawt_2Ffont_2FNumericShaper_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fawt_2Ffont_2FNumericShaper_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_3B, currentRange, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_3B, key, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_3B, mask, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_3B, rangeArray, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_3B, rangeSet, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_3B, shapingRange, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_3B, stCache, 28, 4)
+__MRT_CLASS(Ljava_2Fawt_2Ffont_2FNumericShaper_24Range_3B, 36, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_24Range_3B, base, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_24Range_3B, end, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Fawt_2Ffont_2FNumericShaper_24Range_3B, start, 32, 4)
+__MRT_CLASS(Ljava_2Fbeans_2FPropertyChangeSupport_24PropertyChangeListenerMap_3B, 24, Ljava_2Fbeans_2FChangeListenerMap_3B)
+__MRT_CLASS(Ljava_2Fbeans_2FPropertyChangeSupport_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fbeans_2FPropertyChangeSupport_3B, map, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fbeans_2FPropertyChangeSupport_3B, source, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2F_2D_24_24Lambda_24ObjectStreamClass_24GVMp__c_2DBEBrBo__ZKh__HiLSO_2DfGo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FBufferedReader_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_241_3B, nextLine, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedReader_241_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FFileDescriptor_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_241_3B, val_24subcl, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24GetFieldImpl_3B, 56, Ljava_2Fio_2FObjectInputStream_24GetField_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24GetFieldImpl_3B, desc, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24GetFieldImpl_3B, objHandles, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24GetFieldImpl_3B, objVals, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24GetFieldImpl_3B, primVals, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24GetFieldImpl_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectInputStream_24ValidationList_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectInputStream_24ValidationList_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectOutputStream_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectOutputStream_241_3B, val_24subcl, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_242_3B, val_24cl, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_244_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_245_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_24EntryFuture_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24EntryFuture_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FUnixFileSystem_3B, 40, Ljava_2Fio_2FFileSystem_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FUnixFileSystem_3B, cache, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FUnixFileSystem_3B, colon, 12, 2)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FUnixFileSystem_3B, javaHome, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FUnixFileSystem_3B, javaHomePrefixCache, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FUnixFileSystem_3B, slash, 14, 2)
+__MRT_CLASS(Ljava_2Flang_2F_2D_24_24Lambda_24CharSequence_24lS6BYp9KMNOi2HcboXLiOooqoX8_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2F_2D_24_24Lambda_24CharSequence_24lS6BYp9KMNOi2HcboXLiOooqoX8_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2F_2D_24_24Lambda_24CharSequence_24lnrrVTEPDeRteHnQDz8kEht4CY8_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2F_2D_24_24Lambda_24CharSequence_24lnrrVTEPDeRteHnQDz8kEht4CY8_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FBootClassLoader_3B, 56, Ljava_2Flang_2FClassLoader_3B)
+__MRT_CLASS(Ljava_2Flang_2FCaseMapper_241_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Ljava_2Flang_2FCharacter_24UnicodeBlock_3B, 24, Ljava_2Flang_2FCharacter_24Subset_3B)
+__MRT_CLASS(Ljava_2Flang_2FEnum_241_3B, 24, Llibcore_2Futil_2FBasicLruCache_3B)
+__MRT_CLASS(Ljava_2Flang_2FInheritableThreadLocal_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_24Redirect_241_3B, 12, Ljava_2Flang_2FProcessBuilder_24Redirect_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_24Redirect_242_3B, 12, Ljava_2Flang_2FProcessBuilder_24Redirect_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_24Redirect_243_3B, 24, Ljava_2Flang_2FProcessBuilder_24Redirect_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessBuilder_24Redirect_243_3B, val_24file, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_24Redirect_244_3B, 24, Ljava_2Flang_2FProcessBuilder_24Redirect_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessBuilder_24Redirect_244_3B, val_24file, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_24Redirect_245_3B, 24, Ljava_2Flang_2FProcessBuilder_24Redirect_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessBuilder_24Redirect_245_3B, val_24file, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24StringEntry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringEntry_3B, e, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24StringEntrySet_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringEntrySet_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringEntrySet_241_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24StringEntrySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringEntrySet_3B, s, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24StringEntrySet_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringEntrySet_242_3B, val_24o, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24Variable_3B, 32, Ljava_2Flang_2FProcessEnvironment_24ExternalData_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24Value_3B, 32, Ljava_2Flang_2FProcessEnvironment_24ExternalData_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24StringKeySet_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringKeySet_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringKeySet_241_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24StringKeySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringKeySet_3B, s, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24StringValues_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringValues_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringValues_241_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24StringValues_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringValues_3B, c, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FString_24CaseInsensitiveComparator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FThread_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_241_3B, val_24subcl, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FThreadLocal_24SuppliedThreadLocal_3B, 24, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThreadLocal_24SuppliedThreadLocal_3B, supplier, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FThrowable_24WrappedPrintStream_3B, 24, Ljava_2Flang_2FThrowable_24PrintStreamOrWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThrowable_24WrappedPrintStream_3B, printStream, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FThrowable_24WrappedPrintWriter_3B, 24, Ljava_2Flang_2FThrowable_24PrintStreamOrWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThrowable_24WrappedPrintWriter_3B, printWriter, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FUNIXProcess_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FUNIXProcess_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FUNIXProcess_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FUNIXProcess_242_3B, val_24fds, 24, 8)
+__MRT_CLASS(Ljava_2Flang_2FUNIXProcess_3B, 48, Ljava_2Flang_2FProcess_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FUNIXProcess_3B, exitcode, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FUNIXProcess_3B, hasExited, 16, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FUNIXProcess_3B, pid, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FUNIXProcess_3B, stderr, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FUNIXProcess_3B, stdin, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FUNIXProcess_3B, stdout, 40, 8)
+__MRT_CLASS(Ljava_2Flang_2FUNIXProcess_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FUNIXProcess_243_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FUNIXProcess_24ProcessReaperThreadFactory_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2FUNIXProcess_24ProcessReaperThreadFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FArrayElementVarHandle_3B, 40, Ljava_2Flang_2Finvoke_2FVarHandle_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FByteArrayViewVarHandle_3B, 41, Ljava_2Flang_2Finvoke_2FVarHandle_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FByteArrayViewVarHandle_3B, nativeByteOrder, 40, 1)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FByteBufferViewVarHandle_3B, 41, Ljava_2Flang_2Finvoke_2FVarHandle_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FByteBufferViewVarHandle_3B, nativeByteOrder, 40, 1)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FConstantCallSite_3B, 25, Ljava_2Flang_2Finvoke_2FCallSite_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FConstantCallSite_3B, isFrozen, 24, 1)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FFieldVarHandle_3B, 48, Ljava_2Flang_2Finvoke_2FVarHandle_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FFieldVarHandle_3B, artField, 40, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMutableCallSite_3B, 24, Ljava_2Flang_2Finvoke_2FCallSite_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B, 48, Ljava_2Flang_2Finvoke_2FMethodHandle_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FVolatileCallSite_3B, 24, Ljava_2Flang_2Finvoke_2FCallSite_3B)
+__MRT_CLASS(Ljava_2Flang_2Fref_2FFinalizerReference_3B, 72, Ljava_2Flang_2Fref_2FReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FFinalizerReference_3B, next, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FFinalizerReference_3B, prev, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fref_2FFinalizerReference_3B, zombie, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FMethod_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FProxy_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FProxy_24KeyFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FProxy_24ProxyClassFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FProxy_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FProxy_3B, h, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FWeakCache_24Factory_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_24Factory_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_24Factory_3B, parameter, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_24Factory_3B, subKey, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_24Factory_3B, this_240, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_24Factory_3B, valuesMap, 48, 8)
+__MRT_CLASS(Ljava_2Fnet_2FCookieManager_24CookiePathComparator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FCookieManager_3B, 32, Ljava_2Fnet_2FCookieHandler_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FCookieManager_3B, cookieJar, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FCookieManager_3B, policyCallback, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FCookiePolicy_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FCookiePolicy_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FCookiePolicy_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FDatagramSocket_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FDatagramSocket_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FDefaultFileNameMap_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_2410_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_2411_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_244_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_245_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_246_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_247_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_248_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpCookie_249_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FHttpURLConnection_3B, 88, Ljava_2Fnet_2FURLConnection_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpURLConnection_3B, chunkLength, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpURLConnection_3B, fixedContentLength, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpURLConnection_3B, fixedContentLengthLong, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpURLConnection_3B, instanceFollowRedirects, 49, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpURLConnection_3B, method, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpURLConnection_3B, responseCode, 60, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpURLConnection_3B, responseMessage, 80, 8)
+__MRT_CLASS(Ljava_2Fnet_2FInMemoryCookieStore_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInMemoryCookieStore_3B, applyMCompatibility, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInMemoryCookieStore_3B, lock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FInMemoryCookieStore_3B, uriIndex, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FInet6AddressImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FInetAddress_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnet_2FJarURLConnection_3B, 80, Ljava_2Fnet_2FURLConnection_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FJarURLConnection_3B, entryName, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FJarURLConnection_3B, jarFileURL, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FJarURLConnection_3B, jarFileURLConnection, 72, 8)
+__MRT_CLASS(Ljava_2Fnet_2FNetworkInterface_241checkedAddresses_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_241checkedAddresses_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_241checkedAddresses_3B, i, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_241checkedAddresses_3B, local__addrs, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FNetworkInterface_241checkedAddresses_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Fnet_2FSecureCacheResponse_3B, 12, Ljava_2Fnet_2FCacheResponse_3B)
+__MRT_CLASS(Ljava_2Fnet_2FServerSocket_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FServerSocket_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FSocket_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FSocket_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_242_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FSocket_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocket_243_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FSocksSocketImpl_241_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_241_3B, val_24host, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_241_3B, val_24port, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_241_3B, val_24timeout, 32, 4)
+__MRT_CLASS(Ljava_2Fnet_2FSocksSocketImpl_3B, 172, Ljava_2Fnet_2FPlainSocketImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_3B, applicationSetProxy, 124, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_3B, cmdIn, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_3B, cmdOut, 136, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_3B, cmdsock, 144, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_3B, external__address, 152, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_3B, server, 160, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_3B, serverPort, 168, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_3B, useV4, 125, 1)
+__MRT_CLASS(Ljava_2Fio_2FBufferedOutputStream_3B, 36, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedOutputStream_3B, buf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedOutputStream_3B, count, 32, 4)
+__MRT_CLASS(Ljava_2Fnet_2FPlainSocketImpl_3B, 124, Ljava_2Fnet_2FAbstractPlainSocketImpl_3B)
+__MRT_CLASS(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, 124, Ljava_2Fnet_2FSocketImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, CONNECTION__NOT__RESET, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, CONNECTION__RESET, 60, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, CONNECTION__RESET__PENDING, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, closePending, 68, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, fdLock, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, fdUseCount, 80, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, guard, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, resetLock, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, resetState, 84, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, shut__rd, 69, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, shut__wr, 70, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, socketInputStream, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, socketOutputStream, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, stream, 71, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainSocketImpl_3B, timeout, 120, 4)
+__MRT_CLASS(Ljava_2Fnet_2FSocketInputStream_3B, 96, Ljava_2Fio_2FFileInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketInputStream_3B, closing, 64, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketInputStream_3B, eof, 65, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketInputStream_3B, impl, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketInputStream_3B, socket, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketInputStream_3B, temp, 88, 8)
+__MRT_CLASS(Ljava_2Fio_2FFileInputStream_3B, 64, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileInputStream_3B, channel, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileInputStream_3B, closeLock, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileInputStream_3B, closed, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileInputStream_3B, fd, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileInputStream_3B, guard, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileInputStream_3B, isFdOwner, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileInputStream_3B, path, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFileInputStream_3B, tracker, 56, 8)
+__MRT_CLASS(Ljava_2Fnet_2FSocketOutputStream_3B, 96, Ljava_2Fio_2FFileOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketOutputStream_3B, closing, 64, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketOutputStream_3B, impl, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketOutputStream_3B, socket, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocketOutputStream_3B, temp, 88, 8)
+__MRT_CLASS(Ljava_2Fnet_2FSocksSocketImpl_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FSocksSocketImpl_242_3B, val_24addr, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FStandardSocketOptions_24StdSocketOption_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FStandardSocketOptions_24StdSocketOption_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FStandardSocketOptions_24StdSocketOption_3B, type, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLClassLoader_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_241_3B, val_24name, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLClassLoader_3B, 96, Ljava_2Fsecurity_2FSecureClassLoader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_3B, acc, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_3B, closeables, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_3B, ucp, 88, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FSecureClassLoader_3B, 72, Ljava_2Flang_2FClassLoader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureClassLoader_3B, initialized, 56, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSecureClassLoader_3B, pdcache, 64, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLClassLoader_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_242_3B, val_24name, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLClassLoader_243_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_243_241_3B, this_241, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLClassLoader_243_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_243_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_243_3B, url, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_243_3B, val_24e, 32, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLClassLoader_244_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_244_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_244_3B, val_24fp, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_244_3B, val_24sm, 32, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLClassLoader_245_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_245_3B, val_24acc, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_245_3B, val_24parent, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_245_3B, val_24urls, 32, 8)
+__MRT_CLASS(Ljava_2Fnet_2FURLClassLoader_246_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_246_3B, val_24acc, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURLClassLoader_246_3B, val_24urls, 24, 8)
+__MRT_CLASS(Ljava_2Fnet_2FUnknownContentHandler_3B, 12, Ljava_2Fnet_2FContentHandler_3B)
+__MRT_CLASS(Ljava_2Fnio_2F_2D_24_24Lambda_24CharBuffer_24Nm0aKlKPFJdqsfIc00Gd0NEZ8I0_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2F_2D_24_24Lambda_24CharBuffer_24Nm0aKlKPFJdqsfIc00Gd0NEZ8I0_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelector_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelector_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FAsynchronousChannelProvider_24ProviderHolder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2Fspi_2FSelectorProvider_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharset_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharset_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharset_241_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharset_241_3B, sl, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FServiceLoader_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_3B, loader, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_3B, lookupIterator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_3B, providers, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_3B, service, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FServiceLoader_24LazyIterator_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_24LazyIterator_3B, configs, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_24LazyIterator_3B, loader, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_24LazyIterator_3B, nextName, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_24LazyIterator_3B, pending, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_24LazyIterator_3B, service, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_24LazyIterator_3B, this_240, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FServiceLoader_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_241_3B, knownProviders, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FServiceLoader_241_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharset_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharset_242_3B, val_24charsetName, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharset_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B, 112, Ljava_2Fnio_2Fcharset_2FCharsetDecoder_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B, allocatedInput, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B, allocatedOutput, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B, converterHandle, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B, data, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B, inEnd, 88, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B, input, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B, outEnd, 92, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetDecoderICU_3B, output, 104, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B, 120, Ljava_2Fnio_2Fcharset_2FCharsetEncoder_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B, allocatedInput, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B, allocatedOutput, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B, converterHandle, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B, data, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B, inEnd, 96, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B, input, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B, outEnd, 100, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetEncoderICU_3B, output, 112, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCoderResult_242_3B, 24, Ljava_2Fnio_2Fcharset_2FCoderResult_24Cache_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2F_2D_24_24Lambda_24Files_244idNQbLxq4bhe2g1MNnC6cjfF5E_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2F_2D_24_24Lambda_24Files_244idNQbLxq4bhe2g1MNnC6cjfF5E_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2F_2D_24_24Lambda_24Files_24cNMxoBpYNc__xj__crDjR6l6JHUZ0_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2F_2D_24_24Lambda_24Files_24powUktDqIsUPxzmcqaqk0NiO6iA_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2F_2D_24_24Lambda_24Files_24powUktDqIsUPxzmcqaqk0NiO6iA_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2F_2D_24_24Lambda_24Files_24troLqSRHugOdjQwE7dW2qp22ctc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2F_2D_24_24Lambda_24sYbGIj22XbOmrXSY16DZsES4BAM_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2F_2D_24_24Lambda_24sYbGIj22XbOmrXSY16DZsES4BAM_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileTreeIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeIterator_3B, next, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeIterator_3B, walker, 24, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileTreeWalker_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_3B, closed, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_3B, followLinks, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_3B, linkOptions, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_3B, maxDepth, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileTreeWalker_3B, stack, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FArrayDeque_3B, 28, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_3B, elements, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_3B, head, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_3B, tail, 24, 4)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileSystems_24DefaultFileSystemHolder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFiles_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFiles_241_3B, val_24matcher, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFiles_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFiles_242_3B, val_24delegate, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFiles_24AcceptAllFilter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFiles_24FileTypeDetectors_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFiles_24FileTypeDetectors_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FSimpleFileVisitor_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FStandardWatchEventKinds_24StdWatchEventKind_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FStandardWatchEventKinds_24StdWatchEventKind_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FStandardWatchEventKinds_24StdWatchEventKind_3B, type, 24, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FPosixFilePermissions_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FPosixFilePermissions_241_3B, val_24value, 16, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fspi_2FFileSystemProvider_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FDomainLoadStoreParameter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FDomainLoadStoreParameter_3B, configuration, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FDomainLoadStoreParameter_3B, protectionParams, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FGuardedObject_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FGuardedObject_3B, guard, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FGuardedObject_3B, object, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FIdentity_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FIdentity_3B, certificates, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FIdentity_3B, info, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FIdentity_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FIdentity_3B, publicKey, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FIdentity_3B, scope, 48, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FIdentityScope_3B, 56, Ljava_2Fsecurity_2FIdentity_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FIdentityScope_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyPairGenerator_3B, 32, Ljava_2Fsecurity_2FKeyPairGeneratorSpi_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPairGenerator_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPairGenerator_3B, provider, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyRep_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyRep_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyRep_3B, encoded, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyRep_3B, format, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyRep_3B, type, 40, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyRep_24Type_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24Builder_241_3B, 32, Ljava_2Fsecurity_2FKeyStore_24Builder_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_241_3B, getCalled, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_241_3B, val_24keyStore, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_241_3B, val_24protectionParameter, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24Builder_242_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_242_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24Builder_242_3B, 64, Ljava_2Fsecurity_2FKeyStore_24Builder_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_242_3B, action, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_242_3B, getCalled, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_242_3B, oldException, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_242_3B, val_24context, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_242_3B, val_24protection, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_242_3B, val_24provider, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_242_3B, val_24type, 56, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_3B, 80, Ljava_2Fsecurity_2FKeyStore_24Builder_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_3B, context, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_3B, file, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_3B, keyProtection, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_3B, keyStore, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_3B, oldException, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_3B, protection, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_3B, provider, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24Builder_24FileBuilder_3B, type, 72, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24CallbackHandlerProtection_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24CallbackHandlerProtection_3B, handler, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24PasswordProtection_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24PasswordProtection_3B, destroyed, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24PasswordProtection_3B, password, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24PasswordProtection_3B, protectionAlgorithm, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24PasswordProtection_3B, protectionParameters, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24PrivateKeyEntry_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24PrivateKeyEntry_3B, attributes, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24PrivateKeyEntry_3B, chain, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24PrivateKeyEntry_3B, privKey, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24SecretKeyEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24SecretKeyEntry_3B, attributes, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24SecretKeyEntry_3B, sKey, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24SimpleLoadStoreParameter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24SimpleLoadStoreParameter_3B, protection, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStore_24TrustedCertificateEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24TrustedCertificateEntry_3B, attributes, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyStore_24TrustedCertificateEntry_3B, cert, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FPKCS12Attribute_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FPKCS12Attribute_3B, encoded, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FPKCS12Attribute_3B, hashValue, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FPKCS12Attribute_3B, name, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FPKCS12Attribute_3B, value, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FSecureRandom_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FSignature_24CipherAdapter_3B, 40, Ljava_2Fsecurity_2FSignatureSpi_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignature_24CipherAdapter_3B, cipher, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignature_24CipherAdapter_3B, data, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FSignature_3B, 44, Ljava_2Fsecurity_2FSignatureSpi_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignature_3B, algorithm, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignature_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignature_3B, state, 40, 4)
+__MRT_CLASS(Ljava_2Fsecurity_2FSignedObject_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignedObject_3B, content, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignedObject_3B, signature, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignedObject_3B, thealgorithm, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FSigner_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSigner_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSigner_241_3B, val_24pub, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FSigner_3B, 64, Ljava_2Fsecurity_2FIdentity_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSigner_3B, privateKey, 56, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPath_24CertPathRep_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPath_24CertPathRep_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPath_24CertPathRep_3B, type, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathBuilder_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathHelperImpl_3B, 12, Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertPathHelper_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathValidator_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertStore_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificate_24CertificateRep_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificate_24CertificateRep_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificate_24CertificateRep_3B, type, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FDSAParameterSpec_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAParameterSpec_3B, g, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAParameterSpec_3B, p, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAParameterSpec_3B, q, 32, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FDSAPrivateKeySpec_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAPrivateKeySpec_3B, g, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAPrivateKeySpec_3B, p, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAPrivateKeySpec_3B, q, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAPrivateKeySpec_3B, x, 40, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FDSAPublicKeySpec_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAPublicKeySpec_3B, g, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAPublicKeySpec_3B, p, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAPublicKeySpec_3B, q, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FDSAPublicKeySpec_3B, y, 40, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FECFieldF2m_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECFieldF2m_3B, ks, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECFieldF2m_3B, m, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECFieldF2m_3B, rp, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FECFieldFp_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECFieldFp_3B, p, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FECGenParameterSpec_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECGenParameterSpec_3B, name, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FECPrivateKeySpec_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECPrivateKeySpec_3B, params, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECPrivateKeySpec_3B, s, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FECPublicKeySpec_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECPublicKeySpec_3B, params, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FECPublicKeySpec_3B, w, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FMGF1ParameterSpec_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FMGF1ParameterSpec_3B, mdName, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FPSSParameterSpec_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FPSSParameterSpec_3B, mdName, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FPSSParameterSpec_3B, mgfName, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FPSSParameterSpec_3B, mgfSpec, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FPSSParameterSpec_3B, saltLen, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FPSSParameterSpec_3B, trailerField, 40, 4)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FRSAKeyGenParameterSpec_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAKeyGenParameterSpec_3B, keysize, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAKeyGenParameterSpec_3B, publicExponent, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FRSAPrivateKeySpec_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPrivateKeySpec_3B, modulus, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPrivateKeySpec_3B, privateExponent, 24, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FRSAPublicKeySpec_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPublicKeySpec_3B, modulus, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPublicKeySpec_3B, publicExponent, 24, 8)
+__MRT_CLASS(Ljava_2Fsql_2FDriverManager_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsql_2FDriverManager_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLException_241_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FSQLException_241_3B, cause, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FSQLException_241_3B, firstException, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FSQLException_241_3B, nextException, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FSQLException_241_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Ftext_2FAttributeEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributeEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributeEntry_3B, value, 24, 8)
+__MRT_CLASS(Ljava_2Ftext_2FBreakIterator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftext_2FCharacterIteratorFieldDelegate_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FCharacterIteratorFieldDelegate_3B, attributedStrings, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FCharacterIteratorFieldDelegate_3B, size, 12, 4)
+__MRT_CLASS(Ljava_2Ftext_2FCollationKey_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FCollationKey_3B, source, 16, 8)
+__MRT_CLASS(Ljava_2Ftext_2FCollator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FCollator_3B, icuColl, 16, 8)
+__MRT_CLASS(Ljava_2Ftext_2FDecimalFormatSymbols_3B, 100, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, NaN, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, cachedIcuDFS, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, currency, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, currencySymbol, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, decimalSeparator, 12, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, digit, 14, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, exponential, 48, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, exponentialSeparator, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, groupingSeparator, 50, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, infinity, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, intlCurrencySymbol, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, locale, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, minusSign, 52, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, monetarySeparator, 54, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, patternSeparator, 88, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, perMill, 90, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, percent, 92, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, serialVersionOnStream, 96, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormatSymbols_3B, zeroDigit, 94, 2)
+__MRT_CLASS(Ljava_2Ftext_2FDontCareFieldPosition_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDontCareFieldPosition_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Ftext_2FDontCareFieldPosition_3B, 40, Ljava_2Ftext_2FFieldPosition_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDontCareFieldPosition_3B, noDelegate, 32, 8)
+__MRT_CLASS(Ljava_2Ftext_2FFieldPosition_24Delegate_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FFieldPosition_24Delegate_3B, encounteredField, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FFieldPosition_24Delegate_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_24102LK_2DVjqD__Dw4HKR2kUw_2DBMsRk_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_241t2bycXU085eFZcwODXkbd0X4Bk_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_242Dm__gBEmfWAFyI8wDj__HTrgAgUc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_24Bq8PKq1YWr8nyVk9SSfRYKrOu4A_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_24I08rBDhAPdxOG__R3AeLRKYX7Z_2Do_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_24JBWLm7jbzHiLhHxYdB__IuO__vFO8_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_24OffsetDateTime_24d2QSmDYEJWeXCg2rcQuxVNPk3n4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_24PTL8WkLA4o_2D1z4zIUBjrvwi808w_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_24sL__1zXqh7GXCv2G9X40ozp__OBMA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_24sdbO4BiAEcJ0Ab_2DaR8ZYLiX9zuo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2F_2D_24_24Lambda_24up1HpCqucM__DXyY_2DrpDOyCcdmIA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2FClock_24FixedClock_3B, 32, Ljava_2Ftime_2FClock_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FClock_24FixedClock_3B, instant, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FClock_24FixedClock_3B, zone, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2FClock_24OffsetClock_3B, 32, Ljava_2Ftime_2FClock_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FClock_24OffsetClock_3B, baseClock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FClock_24OffsetClock_3B, offset, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2FClock_24SystemClock_3B, 24, Ljava_2Ftime_2FClock_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FClock_24SystemClock_3B, zone, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2FClock_24TickClock_3B, 32, Ljava_2Ftime_2FClock_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FClock_24TickClock_3B, baseClock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FClock_24TickClock_3B, tickNanos, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2FMonthDay_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FMonthDay_3B, day, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FMonthDay_3B, month, 16, 4)
+__MRT_CLASS(Ljava_2Ftime_2FZoneId_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FZoneId_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2F_2D_24_24Lambda_24AbstractChronology_245b0W7uLeaWkn0HLPDKwPXzJ7HPo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2F_2D_24_24Lambda_24AbstractChronology_24j22w8kHhJoqCd56hhLQK1G0VLFw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2F_2D_24_24Lambda_24AbstractChronology_24onW9aZyLFliH5Gg1qLodD__GoPfA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FChronology_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronology_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2F_2D_24_24Lambda_24DateTimeFormatter_24GhpE1dbCMFpBqvhZZgrqVYpzk8E_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2F_2D_24_24Lambda_24DateTimeFormatter_24QqeEAMXK7Qf5gsmaSCLmrVwQ1Ns_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2F_2D_24_24Lambda_24DateTimeFormatterBuilder_24M_2DGACNxm6552EiylPRPw4dyNXKo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2F_2D_24_24Lambda_24DateTimeFormatterBuilder_24ReducedPrinterParser_24O7fxxUm4cHduGbldToNj0T92oIo_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2F_2D_24_24Lambda_24DateTimeFormatterBuilder_24ReducedPrinterParser_24O7fxxUm4cHduGbldToNj0T92oIo_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2F_2D_24_24Lambda_24DateTimeFormatterBuilder_24ReducedPrinterParser_24O7fxxUm4cHduGbldToNj0T92oIo_3B, f_241, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2F_2D_24_24Lambda_24DateTimeFormatterBuilder_24ReducedPrinterParser_24O7fxxUm4cHduGbldToNj0T92oIo_3B, f_242, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2F_2D_24_24Lambda_24DateTimeFormatterBuilder_24ReducedPrinterParser_24O7fxxUm4cHduGbldToNj0T92oIo_3B, f_243, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2F_2D_24_24Lambda_24DateTimeFormatterBuilder_24ReducedPrinterParser_24O7fxxUm4cHduGbldToNj0T92oIo_3B, f_244, 40, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ReducedPrinterParser_3B, 52, Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24NumberPrinterParser_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ReducedPrinterParser_3B, baseDate, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ReducedPrinterParser_3B, baseValue, 48, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24CharLiteralPrinterParser_3B, 14, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24CharLiteralPrinterParser_3B, literal, 12, 2)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ChronoPrinterParser_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ChronoPrinterParser_3B, textStyle, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24DefaultValueParser_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24DefaultValueParser_3B, field, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24DefaultValueParser_3B, value, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24FractionPrinterParser_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24FractionPrinterParser_3B, decimalPoint, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24FractionPrinterParser_3B, field, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24FractionPrinterParser_3B, maxWidth, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24FractionPrinterParser_3B, minWidth, 28, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24InstantPrinterParser_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24InstantPrinterParser_3B, fractionalDigits, 12, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24LocalizedOffsetIdPrinterParser_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24LocalizedOffsetIdPrinterParser_3B, style, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24LocalizedPrinterParser_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24LocalizedPrinterParser_3B, dateStyle, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24LocalizedPrinterParser_3B, timeStyle, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24OffsetIdPrinterParser_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24OffsetIdPrinterParser_3B, noOffsetText, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24OffsetIdPrinterParser_3B, type, 12, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PadPrinterParserDecorator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PadPrinterParserDecorator_3B, padChar, 12, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PadPrinterParserDecorator_3B, padWidth, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PadPrinterParserDecorator_3B, printerParser, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_24CI_3B, 48, Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24StringLiteralPrinterParser_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24StringLiteralPrinterParser_3B, literal, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24TextPrinterParser_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24TextPrinterParser_3B, field, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24TextPrinterParser_3B, numberPrinterParser, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24TextPrinterParser_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24TextPrinterParser_3B, textStyle, 40, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24WeekBasedFieldPrinterParser_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24WeekBasedFieldPrinterParser_3B, chr, 12, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24WeekBasedFieldPrinterParser_3B, count, 16, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ZoneIdPrinterParser_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ZoneIdPrinterParser_3B, description, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ZoneIdPrinterParser_3B, query, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimePrintContext_241_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimePrintContext_241_3B, val_24effectiveChrono, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimePrintContext_241_3B, val_24effectiveDate, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimePrintContext_241_3B, val_24effectiveZone, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimePrintContext_241_3B, val_24temporal, 40, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeTextProvider_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_248EK8KVP193YLBVkxtkiyg8uZHVo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24A9OZwfMlHD1vy7_2DnYt5NssACu7Q_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24A9OZwfMlHD1vy7_2DnYt5NssACu7Q_3B, f_240, 12, 4)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24Aa2HtcpQrtdU2tm9_2DWsArYNyfqM_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24Aa2HtcpQrtdU2tm9_2DWsArYNyfqM_3B, f_240, 12, 4)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24BioX0XAyDebBQX3h4Lqog9Ofj58_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24BioX0XAyDebBQX3h4Lqog9Ofj58_3B, f_240, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24BioX0XAyDebBQX3h4Lqog9Ofj58_3B, f_241, 16, 4)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24CLbEgdXQzFe17bbP1cAR86Ccar4_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24CLbEgdXQzFe17bbP1cAR86Ccar4_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24Hr69XZXcuTp7qqn22qJMcjGgXGw_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24Hr69XZXcuTp7qqn22qJMcjGgXGw_3B, f_240, 12, 4)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24P7__rZO2XINPKRC8__LcPrXpeSbek_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24TKkfUVRu__GUECdXqtmzzXrayVY8_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24TKkfUVRu__GUECdXqtmzzXrayVY8_3B, f_240, 12, 4)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24WAuzLMCz_2D2_2DSwnlcREz0tiYj3XA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24iS4EYkMA1JewgnCHCuVtjW33u14_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24lxLY_2D2BERW0kc72bWr7fARmx5Z8_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24tdo0RtAvE1xjo0CFx2_2D92T1yRzQ_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24tdo0RtAvE1xjo0CFx2_2D92T1yRzQ_3B, f_240, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24tdo0RtAvE1xjo0CFx2_2D92T1yRzQ_3B, f_241, 16, 4)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalAdjusters_24w9cWh2WC9cZ6gKDdIl4UmC4HmUM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalQueries_24IZUinmsZUz98YXPe0ftAd27ByiE_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalQueries_24JPrXwgedeqexYxypO8VpPKV4l3c_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalQueries_24PBpYKRiwkxqQNlcU_2DBOJfaQoONg_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalQueries_24WGGw7SkRcanjtxRiTk5p0dKf__jc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalQueries_24bI5NESEXE4DqyC7TnOvbkx1GlvM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalQueries_24okxqZ6ZoOhHd__zSzW7k5qRIaLxM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2F_2D_24_24Lambda_24TemporalQueries_24thd4JmExRUYKd7nNlE7b5oT19ms_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FWeekFields_24ComputedDayOfField_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_24ComputedDayOfField_3B, baseUnit, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_24ComputedDayOfField_3B, name, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_24ComputedDayOfField_3B, range, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_24ComputedDayOfField_3B, rangeUnit, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_24ComputedDayOfField_3B, weekDef, 48, 8)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FWeekFields_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_3B, dayOfWeek, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_3B, firstDayOfWeek, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_3B, minimalDays, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_3B, weekBasedYear, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_3B, weekOfMonth, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_3B, weekOfWeekBasedYear, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FWeekFields_3B, weekOfYear, 56, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FIcuZoneRulesProvider_24ZoneRulesCache_3B, 24, Llibcore_2Futil_2FBasicLruCache_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FIcuZoneRulesProvider_3B, 24, Ljava_2Ftime_2Fzone_2FZoneRulesProvider_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FIcuZoneRulesProvider_3B, cache, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_242CyTD4Tuo1NS84gjxzFA3u1LWl0_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_242CyTD4Tuo1NS84gjxzFA3u1LWl0_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_249llQTmDvC2fDr_2DGds5d6BexJH00_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_249llQTmDvC2fDr_2DGds5d6BexJH00_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24H0YqaggIxZUqId4__BJ1BLcUa93k_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24H0YqaggIxZUqId4__BJ1BLcUa93k_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24H0YqaggIxZUqId4__BJ1BLcUa93k_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24KFf05FUz26CqVc__cf2bKY9C927o_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24KFf05FUz26CqVc__cf2bKY9C927o_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24KFf05FUz26CqVc__cf2bKY9C927o_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24aBSX__SvA5f2Q1t8__MODHDGhokzk_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24aBSX__SvA5f2Q1t8__MODHDGhokzk_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24aBSX__SvA5f2Q1t8__MODHDGhokzk_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24x0HcRDlColwoPupFWmOW7TREPtM_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24x0HcRDlColwoPupFWmOW7TREPtM_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Arrays_24x0HcRDlColwoPupFWmOW7TREPtM_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24BitSet_24ifk7HV8_2D2uu42BYsPVrvRaHrugk_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24BitSet_24ifk7HV8_2D2uu42BYsPVrvRaHrugk_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedMap_245MCuh91__pd5SsNapFva5jp8gVs8_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedMap_245MCuh91__pd5SsNapFva5jp8gVs8_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedMap_245MCuh91__pd5SsNapFva5jp8gVs8_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedMap_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_3B, entrySet, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_3B, keyType, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_3B, m, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_3B, valueType, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedMap_24UHd__dm3NjSdMnE1bZpQe0MXp__Gk_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedMap_24UHd__dm3NjSdMnE1bZpQe0MXp__Gk_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedMap_24UHd__dm3NjSdMnE1bZpQe0MXp__Gk_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedMap_24hvicTzt8soLX23klS8sBMiCuEvk_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedMap_24hvicTzt8soLX23klS8sBMiCuEvk_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedMap_24hvicTzt8soLX23klS8sBMiCuEvk_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CopiesList_24JkPuGMNhrKbnEHjebm8AvHc2xHw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CopiesList_24JkPuGMNhrKbnEHjebm8AvHc2xHw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CopiesList_3B, 28, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CopiesList_3B, element, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CopiesList_3B, n, 24, 4)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CopiesList_24uHL7LkfEBowvpXOMQGFkZqUGxm4_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CopiesList_24uHL7LkfEBowvpXOMQGFkZqUGxm4_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24UnmodifiableMap_24UnmodifiableEntrySet_24W5VhpDb0JlKqrRuOSf__2RiCnSgo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24UnmodifiableMap_24UnmodifiableEntrySet_24W5VhpDb0JlKqrRuOSf__2RiCnSgo_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_244V5k8aLimtS0VsEILEAqQ9UGZYo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_244V5k8aLimtS0VsEILEAqQ9UGZYo_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24BZSVCoA8i87ehjxxZ1weEounfDQ_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24BZSVCoA8i87ehjxxZ1weEounfDQ_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24BZSVCoA8i87ehjxxZ1weEounfDQ_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24DNgpxUFZqmT4lOBzlVyPjWwvEvw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24DNgpxUFZqmT4lOBzlVyPjWwvEvw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24KVN0LWz1D1wyrL2gs1CbubvLa9o_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24KVN0LWz1D1wyrL2gs1CbubvLa9o_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24KVN0LWz1D1wyrL2gs1CbubvLa9o_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24SPB8K9Yj7Pw1mljm7LpasV7zxWw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24SPB8K9Yj7Pw1mljm7LpasV7zxWw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24edSxqANnwdmzeJ1aMMcwJWE2wII_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Comparator_24edSxqANnwdmzeJ1aMMcwJWE2wII_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24E08DiBhfezKzcLFK_2D72WvmuOUJs_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24E08DiBhfezKzcLFK_2D72WvmuOUJs_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Map_24Entry_24Y3nKRmSXx8yzU__Ap_2DvOwqAqvBas_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Map_24Entry_24Y3nKRmSXx8yzU__Ap_2DvOwqAqvBas_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Map_24Entry_24acJOHw6hO1wh4v9r2vtUuCFe5vI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Map_24Entry_24g8sc1MgjjhwTaK8zHulzMasixMw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Map_24Entry_24g8sc1MgjjhwTaK8zHulzMasixMw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Map_24Entry_24zJtjVuaqJl6rzQLvCcTd4dnXnnw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24TreeMap_24EntrySpliterator_24YqCulUmBGNzQr1PJ__ERFnbxUmTQ_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Tripwire_2403Zb3z_2Drd6SqpmwW72AFPa8slaw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FAbstractList_24Itr_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractList_24Itr_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractList_24Itr_3B, expectedModCount, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractList_24Itr_3B, lastRet, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractList_24Itr_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FAbstractMap_241_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_241_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_241_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FAbstractMap_241_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FAbstractMap_242_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_242_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_242_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FAbstractMap_242_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_242_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FAbstractMap_24SimpleEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_24SimpleEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractMap_24SimpleEntry_3B, value, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FArrayDeque_24DeqIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DeqIterator_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DeqIterator_3B, fence, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DeqIterator_3B, lastRet, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DeqIterator_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FArrayDeque_24DeqSpliterator_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DeqSpliterator_3B, deq, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DeqSpliterator_3B, fence, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DeqSpliterator_3B, index, 24, 4)
+__MRT_CLASS(Ljava_2Futil_2FArrayDeque_24DescendingIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DescendingIterator_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DescendingIterator_3B, fence, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DescendingIterator_3B, lastRet, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayDeque_24DescendingIterator_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FArrayList_24ArrayListSpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24ArrayListSpliterator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24ArrayListSpliterator_3B, fence, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24ArrayListSpliterator_3B, index, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24ArrayListSpliterator_3B, list, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FArrayList_24Itr_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24Itr_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24Itr_3B, expectedModCount, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24Itr_3B, lastRet, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24Itr_3B, limit, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24Itr_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FArrays_24NaturalOrder_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_241_3B, hasNext, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_241_3B, val_24e, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_242_3B, est, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_242_3B, val_24element, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_243_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_243_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_243_3B, val_24c, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedCollection_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedCollection_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedCollection_241_3B, val_24it, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedCollection_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedCollection_3B, c, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedCollection_3B, type, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedCollection_3B, zeroLengthElementArray, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_241_3B, val_24i, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_241_3B, val_24valueType, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_3B, s, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_3B, valueType, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_24CheckedEntry_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_24CheckedEntry_3B, e, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedMap_24CheckedEntrySet_24CheckedEntry_3B, valueType, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24EmptyEnumeration_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24EmptyIterator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24ReverseComparator2_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24ReverseComparator2_3B, cmp, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24ReverseComparator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SynchronizedMap_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedMap_3B, entrySet, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedMap_3B, keySet, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedMap_3B, m, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedMap_3B, mutex, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedMap_3B, values, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableCollection_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableCollection_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableCollection_241_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableCollection_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableCollection_3B, c, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableMap_24UnmodifiableEntrySet_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableMap_24UnmodifiableEntrySet_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableMap_24UnmodifiableEntrySet_241_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableMap_24UnmodifiableEntrySet_3B, 24, Ljava_2Futil_2FCollections_24UnmodifiableSet_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableSet_3B, 24, Ljava_2Futil_2FCollections_24UnmodifiableCollection_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableMap_24UnmodifiableEntrySet_24UnmodifiableEntry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableMap_24UnmodifiableEntrySet_24UnmodifiableEntry_3B, e, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableMap_24UnmodifiableEntrySet_24UnmodifiableEntrySetSpliterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableMap_24UnmodifiableEntrySet_24UnmodifiableEntrySetSpliterator_3B, s, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableMap_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableMap_3B, entrySet, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableMap_3B, keySet, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableMap_3B, m, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableMap_3B, values, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FComparators_24NullComparator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparators_24NullComparator_3B, nullFirst, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FComparators_24NullComparator_3B, real, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_24EntryIterator_24Entry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24EntryIterator_24Entry_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24EntryIterator_24Entry_3B, this_241, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_24EntryIterator_3B, 48, Ljava_2Futil_2FEnumMap_24EnumMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24EntryIterator_3B, lastReturnedEntry, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24EntryIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_24EnumMapIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24EnumMapIterator_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24EnumMapIterator_3B, lastReturnedIndex, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24EnumMapIterator_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FEnumSet_24SerializationProxy_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumSet_24SerializationProxy_3B, elementType, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumSet_24SerializationProxy_3B, elements, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FEventListenerProxy_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEventListenerProxy_3B, listener, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FFormatter_24FixedString_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FixedString_3B, s, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatter_24FixedString_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24EntryIterator_3B, 56, Ljava_2Futil_2FHashMap_24HashIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24EntryIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24EntrySpliterator_3B, 48, Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24KeyIterator_3B, 56, Ljava_2Futil_2FHashMap_24HashIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24KeyIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24KeySpliterator_3B, 48, Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24ValueIterator_3B, 56, Ljava_2Futil_2FHashMap_24HashIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24ValueIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24ValueSpliterator_3B, 48, Ljava_2Futil_2FHashMap_24HashMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FHashtable_24Enumerator_3B, 60, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24Enumerator_3B, entry, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24Enumerator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24Enumerator_3B, index, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24Enumerator_3B, iterator, 28, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24Enumerator_3B, lastReturned, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24Enumerator_3B, table, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24Enumerator_3B, this_240, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24Enumerator_3B, type, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24EntryIterator_24Entry_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24EntryIterator_24Entry_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24EntryIterator_24Entry_3B, this_241, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24EntryIterator_3B, 64, Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24EntryIterator_3B, lastReturnedEntry, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24EntryIterator_3B, this_240, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B, index, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B, indexValid, 20, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B, lastReturnedIndex, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B, this_240, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B, traversalTable, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24EntrySpliterator_3B, 40, Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24KeySpliterator_3B, 40, Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24ValueSpliterator_3B, 40, Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FJumboEnumSet_24EnumSetIterator_3B, 44, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJumboEnumSet_24EnumSetIterator_3B, lastReturned, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJumboEnumSet_24EnumSetIterator_3B, lastReturnedIndex, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJumboEnumSet_24EnumSetIterator_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJumboEnumSet_24EnumSetIterator_3B, unseen, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJumboEnumSet_24EnumSetIterator_3B, unseenIndex, 40, 4)
+__MRT_CLASS(Ljava_2Futil_2FJumboEnumSet_3B, 44, Ljava_2Futil_2FEnumSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJumboEnumSet_3B, elements, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJumboEnumSet_3B, size, 40, 4)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashMap_24LinkedEntryIterator_3B, 48, Ljava_2Futil_2FLinkedHashMap_24LinkedHashIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedEntryIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashMap_24LinkedKeyIterator_3B, 48, Ljava_2Futil_2FLinkedHashMap_24LinkedHashIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedKeyIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashMap_24LinkedValueIterator_3B, 48, Ljava_2Futil_2FLinkedHashMap_24LinkedHashIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedValueIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedList_24DescendingIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24DescendingIterator_3B, itr, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24DescendingIterator_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedList_24ListItr_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24ListItr_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24ListItr_3B, lastReturned, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24ListItr_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24ListItr_3B, nextIndex, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24ListItr_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedList_24LLSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24LLSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24LLSpliterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24LLSpliterator_3B, est, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24LLSpliterator_3B, expectedModCount, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedList_24LLSpliterator_3B, list, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FListResourceBundle_3B, 64, Ljava_2Futil_2FResourceBundle_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FListResourceBundle_3B, lookup, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FPriorityQueue_24Itr_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24Itr_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24Itr_3B, expectedModCount, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24Itr_3B, forgetMeNot, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24Itr_3B, lastRet, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24Itr_3B, lastRetElt, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24Itr_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FPriorityQueue_3B, 36, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_3B, comparator, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_3B, modCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_3B, queue, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_3B, size, 32, 4)
+__MRT_CLASS(Ljava_2Futil_2FPriorityQueue_24PriorityQueueSpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24PriorityQueueSpliterator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24PriorityQueueSpliterator_3B, fence, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24PriorityQueueSpliterator_3B, index, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPriorityQueue_24PriorityQueueSpliterator_3B, pq, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FPropertyResourceBundle_3B, 64, Ljava_2Futil_2FResourceBundle_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FPropertyResourceBundle_3B, lookup, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FRegularEnumSet_24EnumSetIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRegularEnumSet_24EnumSetIterator_3B, lastReturned, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRegularEnumSet_24EnumSetIterator_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRegularEnumSet_24EnumSetIterator_3B, unseen, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FRegularEnumSet_3B, 40, Ljava_2Futil_2FEnumSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRegularEnumSet_3B, elements, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24Control_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24Control_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24Control_241_3B, val_24classLoader, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24Control_241_3B, val_24reloadFlag, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24Control_241_3B, val_24resourceName, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24RBClassLoader_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24RBClassLoader_3B, 56, Ljava_2Flang_2FClassLoader_3B)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24SingleFormatControl_3B, 24, Ljava_2Futil_2FResourceBundle_24Control_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24SingleFormatControl_3B, formats, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FScanner_241_3B, 32, Lsun_2Fmisc_2FLRUCache_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_241_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FScanner_3B, 232, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, SIMPLE__GROUP__INDEX, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, buf, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, closed, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, decimalPattern, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, decimalSeparator, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, defaultRadix, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, delimPattern, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, digits, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, floatPattern, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, groupSeparator, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, hasNextPattern, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, hasNextPosition, 88, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, hasNextResult, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, infinityString, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, integerPattern, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, lastException, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, locale, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, matchValid, 25, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, matcher, 136, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, nanString, 144, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, needInput, 26, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, negativePrefix, 152, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, negativeSuffix, 160, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, non0Digit, 168, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, patternCache, 176, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, position, 92, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, positivePrefix, 184, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, positiveSuffix, 192, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, radix, 200, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, savedScannerPosition, 204, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, skipped, 27, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, source, 208, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, sourceClosed, 216, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FScanner_3B, typeCache, 224, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_241Adapter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_241Adapter_3B, nextElement, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_241Adapter_3B, val_24spliterator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_241Adapter_3B, valueReady, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24AbstractDoubleSpliterator_24HoldingDoubleConsumer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractDoubleSpliterator_24HoldingDoubleConsumer_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24AbstractIntSpliterator_24HoldingIntConsumer_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractIntSpliterator_24HoldingIntConsumer_3B, value, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24AbstractLongSpliterator_24HoldingLongConsumer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractLongSpliterator_24HoldingLongConsumer_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24AbstractSpliterator_24HoldingConsumer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractSpliterator_24HoldingConsumer_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24AbstractSpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractSpliterator_3B, characteristics, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractSpliterator_3B, est, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24ArraySpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24ArraySpliterator_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24ArraySpliterator_3B, characteristics, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24ArraySpliterator_3B, fence, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24ArraySpliterator_3B, index, 28, 4)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24EmptySpliterator_24OfRef_3B, 12, Ljava_2Futil_2FSpliterators_24EmptySpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24IteratorSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IteratorSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IteratorSpliterator_3B, characteristics, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IteratorSpliterator_3B, collection, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IteratorSpliterator_3B, est, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IteratorSpliterator_3B, it, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FSplittableRandom_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24DescendingKeySpliterator_3B, 48, Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24EntrySpliterator_3B, 48, Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24KeySpliterator_3B, 48, Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B, fenceKey, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B, lastReturned, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B, next, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, 88, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, descendingMapView, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, entrySetView, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, fromStart, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, hi, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, hiInclusive, 49, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, lo, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, loInclusive, 50, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, m, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, navigableKeySetView, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B, toEnd, 51, 1)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24EntrySetView_3B, 32, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24EntrySetView_3B, size, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24EntrySetView_3B, sizeModCount, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24EntrySetView_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24PrivateEntryIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24PrivateEntryIterator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24PrivateEntryIterator_3B, lastReturned, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24PrivateEntryIterator_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24PrivateEntryIterator_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24ValueSpliterator_3B, 48, Ljava_2Futil_2FTreeMap_24TreeMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FUUID_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FUUID_3B, leastSigBits, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FUUID_3B, mostSigBits, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FVector_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_241_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FVector_24Itr_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24Itr_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24Itr_3B, expectedModCount, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24Itr_3B, lastRet, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24Itr_3B, limit, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24Itr_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FVector_24VectorSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24VectorSpliterator_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24VectorSpliterator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24VectorSpliterator_3B, fence, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24VectorSpliterator_3B, index, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24VectorSpliterator_3B, list, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24EntrySpliterator_3B, 48, Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24HashIterator_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24HashIterator_3B, currentKey, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24HashIterator_3B, entry, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24HashIterator_3B, expectedModCount, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24HashIterator_3B, index, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24HashIterator_3B, lastReturned, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24HashIterator_3B, nextKey, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24HashIterator_3B, this_240, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24KeySpliterator_3B, 48, Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24ValueSpliterator_3B, 48, Ljava_2Futil_2FWeakHashMap_24WeakHashMapSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FXMLUtils_24EH_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2FXMLUtils_24Resolver_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2F_2D_24_24Lambda_24ConcurrentMap_24T12JRbgGLhxGbYCuTfff6__dTrMk_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2F_2D_24_24Lambda_24ConcurrentMap_24T12JRbgGLhxGbYCuTfff6__dTrMk_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2F_2D_24_24Lambda_24ConcurrentMap_24T12JRbgGLhxGbYCuTfff6__dTrMk_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2F_2D_24_24Lambda_24ConcurrentSkipListMap_24EntrySpliterator_24y0KdhWWpZC4eKUM6bCtPBgl2u2o_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Canceller_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Canceller_3B, f, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24DelayedCompleter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24DelayedCompleter_3B, f, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24DelayedCompleter_3B, u, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24DelayedExecutor_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24DelayedExecutor_3B, delay, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24DelayedExecutor_3B, executor, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24DelayedExecutor_3B, unit, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Delayer_24DaemonThreadFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24TaskSubmitter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24TaskSubmitter_3B, action, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24TaskSubmitter_3B, executor, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24ThreadPerTaskExecutor_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Timeout_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Timeout_3B, f, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BaseIterator_3B, 80, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BaseIterator_3B, lastReturned, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BaseIterator_3B, map, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24EntrySpliterator_3B, 80, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24EntrySpliterator_3B, est, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24EntrySpliterator_3B, map, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24KeySpliterator_3B, 72, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24KeySpliterator_3B, est, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapEntry_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapEntry_3B, key, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapEntry_3B, map, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapEntry_3B, val, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ValueSpliterator_3B, 72, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Traverser_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ValueSpliterator_3B, est, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24AbstractItr_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24AbstractItr_3B, lastRet, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24AbstractItr_3B, nextItem, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24AbstractItr_3B, nextNode, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24AbstractItr_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_3B, 32, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_3B, head, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_3B, tail, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24CLDSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24CLDSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24CLDSpliterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24CLDSpliterator_3B, exhausted, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24CLDSpliterator_3B, queue, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24CLQSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24CLQSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24CLQSpliterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24CLQSpliterator_3B, exhausted, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24CLQSpliterator_3B, queue, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_3B, 32, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_3B, head, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_3B, tail, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24Itr_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24Itr_3B, lastRet, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24Itr_3B, nextItem, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24Itr_3B, nextNode, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedQueue_24Itr_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24EntrySpliterator_3B, 48, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24CSLMSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24HeadIndex_3B, 44, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Index_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24HeadIndex_3B, level, 40, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Iter_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Iter_3B, lastReturned, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Iter_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Iter_3B, nextValue, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Iter_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_3B, 80, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_3B, comparator, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_3B, descendingMap, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_3B, entrySet, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_3B, head, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_3B, keySet, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_3B, values, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24EntrySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24EntrySet_3B, m, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24KeySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24KeySet_3B, m, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Values_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Values_3B, m, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24KeySpliterator_3B, 48, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24CSLMSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24ValueSpliterator_3B, 48, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24CSLMSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapIter_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapIter_3B, lastReturned, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapIter_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapIter_3B, nextValue, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapIter_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, 88, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, entrySetView, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, hi, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, hiInclusive, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, isDescending, 49, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, keySetView, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, lo, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, loInclusive, 50, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, m, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_3B, valuesView, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FDelayQueue_24Itr_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FDelayQueue_24Itr_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FDelayQueue_24Itr_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FDelayQueue_24Itr_3B, lastRet, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FDelayQueue_24Itr_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FDelayQueue_3B, 48, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FDelayQueue_3B, available, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FDelayQueue_3B, leader, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FDelayQueue_3B, lock, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FDelayQueue_3B, q, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutorCompletionService_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutorCompletionService_3B, aes, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutorCompletionService_3B, completionQueue, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutorCompletionService_3B, executor, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_241_3B, val_24action, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_242_3B, val_24action, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24DefaultThreadFactory_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24DefaultThreadFactory_3B, group, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24DefaultThreadFactory_3B, namePrefix, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24DefaultThreadFactory_3B, threadNumber, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallable_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallable_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallable_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallable_3B, acc, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallable_3B, task, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallableUsingCurrentClassLoader_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallableUsingCurrentClassLoader_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallableUsingCurrentClassLoader_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallableUsingCurrentClassLoader_3B, acc, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallableUsingCurrentClassLoader_3B, ccl, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedCallableUsingCurrentClassLoader_3B, task, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedThreadFactory_241_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedThreadFactory_241_241_3B, this_241, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedThreadFactory_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedThreadFactory_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedThreadFactory_241_3B, val_24r, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedThreadFactory_3B, 56, Ljava_2Futil_2Fconcurrent_2FExecutors_24DefaultThreadFactory_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedThreadFactory_3B, acc, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24PrivilegedThreadFactory_3B, ccl, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24RunnableAdapter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24RunnableAdapter_3B, result, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24RunnableAdapter_3B, task, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24DefaultForkJoinWorkerThreadFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24InnocuousForkJoinWorkerThreadFactory_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24InnocuousForkJoinWorkerThreadFactory_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24InnocuousForkJoinWorkerThreadFactory_241_3B, val_24pool, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24InnocuousForkJoinWorkerThreadFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24AbstractItr_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24AbstractItr_3B, lastRet, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24AbstractItr_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24AbstractItr_3B, nextItem, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24AbstractItr_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_3B, 64, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_3B, capacity, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_3B, count, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_3B, first, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_3B, last, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_3B, lock, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_3B, notEmpty, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_3B, notFull, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24LBDSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24LBDSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24LBDSpliterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24LBDSpliterator_3B, est, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24LBDSpliterator_3B, exhausted, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24LBDSpliterator_3B, queue, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24Itr_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24Itr_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24Itr_3B, currentElement, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24Itr_3B, lastRet, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24Itr_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_3B, 72, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_3B, capacity, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_3B, count, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_3B, head, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_3B, last, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_3B, notEmpty, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_3B, notFull, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_3B, putLock, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_3B, takeLock, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24LBQSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24LBQSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24LBQSpliterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24LBQSpliterator_3B, est, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24LBQSpliterator_3B, exhausted, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingQueue_24LBQSpliterator_3B, queue, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Itr_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Itr_3B, lastPred, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Itr_3B, lastRet, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Itr_3B, nextItem, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Itr_3B, nextNode, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24Itr_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_3B, 32, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_3B, head, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_3B, sweepVotes, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_3B, tail, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24LTQSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24LTQSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24LTQSpliterator_3B, current, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24LTQSpliterator_3B, exhausted, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedTransferQueue_24LTQSpliterator_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24Itr_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24Itr_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24Itr_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24Itr_3B, lastRet, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24Itr_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B, 60, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B, allocationSpinLock, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B, comparator, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B, lock, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B, notEmpty, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B, q, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B, queue, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_3B, size, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24PBQSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24PBQSpliterator_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24PBQSpliterator_3B, fence, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24PBQSpliterator_3B, index, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FPriorityBlockingQueue_24PBQSpliterator_3B, queue, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_24Itr_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_24Itr_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_24Itr_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_24Itr_3B, lastRet, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_24Itr_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_3B, 48, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_3B, available, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_3B, leader, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_3B, lock, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_3B, queue, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24DelayedWorkQueue_3B, size, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSemaphore_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSemaphore_3B, sync, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSemaphore_24Sync_3B, 48, Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedSynchronizer_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferQueue_3B, 40, Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24Transferer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferQueue_3B, cleanMe, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferQueue_3B, head, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferQueue_3B, tail, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_3B, 24, Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24Transferer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24TransferStack_3B, head, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24WaitQueue_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_24AbortPolicy_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_24CallerRunsPolicy_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_24DiscardOldestPolicy_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadPoolExecutor_24DiscardPolicy_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicIntegerArray_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicIntegerArray_3B, array, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicIntegerFieldUpdater_24AtomicIntegerFieldUpdaterImpl_3B, 40, Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicIntegerFieldUpdater_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicIntegerFieldUpdater_24AtomicIntegerFieldUpdaterImpl_3B, cclass, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicIntegerFieldUpdater_24AtomicIntegerFieldUpdaterImpl_3B, offset, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicIntegerFieldUpdater_24AtomicIntegerFieldUpdaterImpl_3B, tclass, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongArray_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongArray_3B, array, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_24CASUpdater_3B, 40, Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_24CASUpdater_3B, cclass, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_24CASUpdater_3B, offset, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_24CASUpdater_3B, tclass, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_24LockedUpdater_3B, 40, Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_24LockedUpdater_3B, cclass, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_24LockedUpdater_3B, offset, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicLongFieldUpdater_24LockedUpdater_3B, tclass, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceArray_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceArray_3B, array, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceFieldUpdater_24AtomicReferenceFieldUpdaterImpl_3B, 48, Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceFieldUpdater_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceFieldUpdater_24AtomicReferenceFieldUpdaterImpl_3B, cclass, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceFieldUpdater_24AtomicReferenceFieldUpdaterImpl_3B, offset, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceFieldUpdater_24AtomicReferenceFieldUpdaterImpl_3B, tclass, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReferenceFieldUpdater_24AtomicReferenceFieldUpdaterImpl_3B, vclass, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAccumulator_24SerializationProxy_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAccumulator_24SerializationProxy_3B, function, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAccumulator_24SerializationProxy_3B, identity, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAccumulator_24SerializationProxy_3B, value, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAdder_24SerializationProxy_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAdder_24SerializationProxy_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAdder_3B, 32, Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_3B, 32, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_3B, base, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_3B, cells, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_3B, cellsBusy, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAccumulator_24SerializationProxy_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAccumulator_24SerializationProxy_3B, function, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAccumulator_24SerializationProxy_3B, identity, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAccumulator_24SerializationProxy_3B, value, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAdder_24SerializationProxy_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAdder_24SerializationProxy_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAdder_3B, 32, Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedLongSynchronizer_24ConditionObject_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedLongSynchronizer_24ConditionObject_3B, firstWaiter, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedLongSynchronizer_24ConditionObject_3B, lastWaiter, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedLongSynchronizer_24ConditionObject_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedLongSynchronizer_3B, 48, Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractOwnableSynchronizer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedLongSynchronizer_3B, head, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedLongSynchronizer_3B, state, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FAbstractQueuedLongSynchronizer_3B, tail, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24ReadLockView_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24ReadLockView_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_3B, readLockView, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_3B, readWriteLockView, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_3B, readerOverflow, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_3B, state, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_3B, whead, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_3B, writeLockView, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_3B, wtail, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24ReadWriteLockView_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24ReadWriteLockView_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24WriteLockView_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Flocks_2FStampedLock_24WriteLockView_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiConsumer_24V89VXFfSN6jmL_2DaAoQrZCMiBju4_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiConsumer_24V89VXFfSN6jmL_2DaAoQrZCMiBju4_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiConsumer_24V89VXFfSN6jmL_2DaAoQrZCMiBju4_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiFunction_24q_2D2HhQ1fzCu6oYNirKhp1W__vpSM_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiFunction_24q_2D2HhQ1fzCu6oYNirKhp1W__vpSM_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiFunction_24q_2D2HhQ1fzCu6oYNirKhp1W__vpSM_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiPredicate_24_2DZiDuSsQaw4dQsCoX8HU1cLSeS8_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiPredicate_24_2DZiDuSsQaw4dQsCoX8HU1cLSeS8_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiPredicate_24OpXxJPTnCjvZwHcfaL3bBDqxCyQ_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiPredicate_24OpXxJPTnCjvZwHcfaL3bBDqxCyQ_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiPredicate_24OpXxJPTnCjvZwHcfaL3bBDqxCyQ_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiPredicate_24uIXzGqdBtyDdYjd7p0mbJFqyjRE_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiPredicate_24uIXzGqdBtyDdYjd7p0mbJFqyjRE_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BiPredicate_24uIXzGqdBtyDdYjd7p0mbJFqyjRE_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Consumer_24fZIgy__f2Fa5seBa8ztxXTExq2p4_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Consumer_24fZIgy__f2Fa5seBa8ztxXTExq2p4_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Consumer_24fZIgy__f2Fa5seBa8ztxXTExq2p4_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleConsumer_24HNSB3MjwB_2DDXE7Kpt1C_2DBT9h3T8_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleConsumer_24HNSB3MjwB_2DDXE7Kpt1C_2DBT9h3T8_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleConsumer_24HNSB3MjwB_2DDXE7Kpt1C_2DBT9h3T8_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoublePredicate_2401E7YsTWsjaQSI72YV852C1Uqco_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoublePredicate_2401E7YsTWsjaQSI72YV852C1Uqco_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoublePredicate_249YmJG7lS_2DNUbb1veFxbs9aIWObk_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoublePredicate_249YmJG7lS_2DNUbb1veFxbs9aIWObk_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoublePredicate_249YmJG7lS_2DNUbb1veFxbs9aIWObk_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoublePredicate_24M8n9M3rXNLuHyZ2e0F7hUxAtVx0_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoublePredicate_24M8n9M3rXNLuHyZ2e0F7hUxAtVx0_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoublePredicate_24M8n9M3rXNLuHyZ2e0F7hUxAtVx0_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleUnaryOperator_24EzzlhUGRoL66wVBCG_2D__euZgC_2DCA_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleUnaryOperator_24EzzlhUGRoL66wVBCG_2D__euZgC_2DCA_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleUnaryOperator_24EzzlhUGRoL66wVBCG_2D__euZgC_2DCA_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleUnaryOperator_24TV17Df571GWp0dWUym3y8OK6ZbM_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleUnaryOperator_24TV17Df571GWp0dWUym3y8OK6ZbM_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleUnaryOperator_24TV17Df571GWp0dWUym3y8OK6ZbM_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24DoubleUnaryOperator_24i7wtM__8Ous_2DCB32HCfZ4usZ4zaQ_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Function_241mm3dZ9IMG2T6zAULCCEh3eoHSY_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Function_24T8wYIfMRq5hbW0Q4qNkHIIrI_2DBA_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Function_24T8wYIfMRq5hbW0Q4qNkHIIrI_2DBA_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Function_24T8wYIfMRq5hbW0Q4qNkHIIrI_2DBA_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Function_24kjgb589uNKoZ3YFTNw1Kwl_2DDNBo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Function_24kjgb589uNKoZ3YFTNw1Kwl_2DDNBo_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Function_24kjgb589uNKoZ3YFTNw1Kwl_2DDNBo_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntConsumer_24Zkqv8__f6uSuSHCYm5dVGj2OCUKA_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntConsumer_24Zkqv8__f6uSuSHCYm5dVGj2OCUKA_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntConsumer_24Zkqv8__f6uSuSHCYm5dVGj2OCUKA_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntPredicate_246LuiLiTSEVs3MpquRl2gnnnEIxg_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntPredicate_246LuiLiTSEVs3MpquRl2gnnnEIxg_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntPredicate_24Gjqjw1UkLLbkSrWX6rKKkHJDvzI_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntPredicate_24Gjqjw1UkLLbkSrWX6rKKkHJDvzI_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntPredicate_24Gjqjw1UkLLbkSrWX6rKKkHJDvzI_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntPredicate_24K711jAs3Mu_2DdbXoV61T3AbYlIaU_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntPredicate_24K711jAs3Mu_2DdbXoV61T3AbYlIaU_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntPredicate_24K711jAs3Mu_2DdbXoV61T3AbYlIaU_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntUnaryOperator_24DKxG0_2DoyUAYjk17nXTQ5x_2DEXFgU_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntUnaryOperator_24F5l8VUrgGacAzg6VKzynJCfDBx4_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntUnaryOperator_24F5l8VUrgGacAzg6VKzynJCfDBx4_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntUnaryOperator_24F5l8VUrgGacAzg6VKzynJCfDBx4_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntUnaryOperator_24HBwqtJWwVkNFC818pCzqJ5KBLm0_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntUnaryOperator_24HBwqtJWwVkNFC818pCzqJ5KBLm0_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24IntUnaryOperator_24HBwqtJWwVkNFC818pCzqJ5KBLm0_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongConsumer_242wx0fq0YJI8kSCwhsFrV0qxRiZ4_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongConsumer_242wx0fq0YJI8kSCwhsFrV0qxRiZ4_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongConsumer_242wx0fq0YJI8kSCwhsFrV0qxRiZ4_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongPredicate_24_2DcsV2YowuwbIk10M6jhbu2oq5to_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongPredicate_24_2DcsV2YowuwbIk10M6jhbu2oq5to_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongPredicate_24_2DcsV2YowuwbIk10M6jhbu2oq5to_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongPredicate_24DaAkBBvcfHLiOGrLHthRI1hFBUQ_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongPredicate_24DaAkBBvcfHLiOGrLHthRI1hFBUQ_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongPredicate_24DaAkBBvcfHLiOGrLHthRI1hFBUQ_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongPredicate_24Qy6TdFCh7weCJdG_2DMkUTh3wmWoA_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongPredicate_24Qy6TdFCh7weCJdG_2DMkUTh3wmWoA_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongUnaryOperator_24MxQtG8PPTeFzxiwgpkR3tXC_2DHLU_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongUnaryOperator_24MxQtG8PPTeFzxiwgpkR3tXC_2DHLU_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongUnaryOperator_24MxQtG8PPTeFzxiwgpkR3tXC_2DHLU_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongUnaryOperator_24e52YMvir03pwSw7KvpRuqEbSDRg_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongUnaryOperator_24e52YMvir03pwSw7KvpRuqEbSDRg_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongUnaryOperator_24e52YMvir03pwSw7KvpRuqEbSDRg_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24LongUnaryOperator_24kI3lBaNH3h6ldTmGeiEUd61CYJI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_2417UUIF1CH__K9duk0ChtjSwOycuM_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_2417UUIF1CH__K9duk0ChtjSwOycuM_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_2417UUIF1CH__K9duk0ChtjSwOycuM_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_24GyIVQ08CWbeMZxHDkkrN_2D5apRkc_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_24GyIVQ08CWbeMZxHDkkrN_2D5apRkc_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_24GyIVQ08CWbeMZxHDkkrN_2D5apRkc_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_24L51YwfosqnYQ8QKStSMYaDgSslA_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_24L51YwfosqnYQ8QKStSMYaDgSslA_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_24SDsDck317M7uJ9htNLy7zOBr1L8_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24Predicate_24SDsDck317M7uJ9htNLy7zOBr1L8_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24wLIh0GiBW9398cTP8uaTH8KoGwo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarFile_24JarEntryIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_24JarEntryIterator_3B, e, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_24JarEntryIterator_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarVerifier_241_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_241_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_241_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_241_3B, val_24enum2, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_241_3B, val_24itor, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_241_3B, val_24signersReq, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarVerifier_242_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_242_3B, entry, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_242_3B, signers, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_242_3B, this_240, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_242_3B, val_24enum__, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_242_3B, val_24jar, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_242_3B, val_24map, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarVerifier_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_243_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarVerifier_244_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_244_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_244_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_244_3B, val_24entries, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_244_3B, val_24map, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FFileHandler_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FFileHandler_3B, 144, Ljava_2Futil_2Flogging_2FStreamHandler_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_3B, append, 88, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_3B, count, 92, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_3B, files, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_3B, limit, 104, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_3B, lockFileChannel, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_3B, lockFileName, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_3B, meter, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_3B, pattern, 136, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FFileHandler_24MeteredStream_3B, 32, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_24MeteredStream_3B, out, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_24MeteredStream_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_24MeteredStream_3B, written, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FStreamHandler_3B, 88, Ljava_2Futil_2Flogging_2FHandler_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FStreamHandler_3B, doneHeader, 64, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FStreamHandler_3B, output, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FStreamHandler_3B, writer, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FFileHandler_24InitializationErrorManager_3B, 24, Ljava_2Futil_2Flogging_2FErrorManager_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FFileHandler_24InitializationErrorManager_3B, lastException, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_242_3B, val_24owner, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_243_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_244_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_244_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_244_3B, val_24l, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_244_3B, val_24sysLogger, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_245_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_245_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_245_3B, val_24handlersPropertyName, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_245_3B, val_24logger, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_246_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_246_3B, val_24level, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_246_3B, val_24logger, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_247_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_247_3B, val_24logger, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_247_3B, val_24parent, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_241_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_241_3B, this_241, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_241_3B, val_24logger, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_241_3B, val_24name, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_241_3B, val_24owner, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_24RootLogger_3B, 128, Ljava_2Futil_2Flogging_2FLogger_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24RootLogger_3B, this_240, 120, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_24SystemLoggerContext_3B, 48, Ljava_2Futil_2Flogging_2FLogManager_24LoggerContext_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24SystemLoggerContext_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogger_24SystemLoggerHelper_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogger_24SystemLoggerHelper_241_3B, val_24key, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogging_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLoggingProxyImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FMemoryHandler_3B, 104, Ljava_2Futil_2Flogging_2FHandler_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FMemoryHandler_3B, buffer, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FMemoryHandler_3B, count, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FMemoryHandler_3B, pushLevel, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FMemoryHandler_3B, size, 76, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FMemoryHandler_3B, start, 88, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FMemoryHandler_3B, target, 96, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FSimpleFormatter_3B, 24, Ljava_2Futil_2Flogging_2FFormatter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FSimpleFormatter_3B, dat, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FXMLFormatter_3B, 24, Ljava_2Futil_2Flogging_2FFormatter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FXMLFormatter_3B, manager, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FAbstractPreferences_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_244_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_244_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_245_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_245_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_246_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_246_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_247_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_247_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_248_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_248_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_249_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_249_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_249_3B, val_24newModTime, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Put_3B, 48, Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Change_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Put_3B, key, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Put_3B, this_240, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Put_3B, value, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Remove_3B, 40, Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Change_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Remove_3B, key, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_24Remove_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferencesFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FXmlSupport_24EH_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FXmlSupport_24NodeListAdapter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FXmlSupport_24NodeListAdapter_3B, delegate, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FXmlSupport_24Resolver_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fregex_2F_2D_24_24Lambda_24Pattern_242enjXc1GhR_2DFNtcTfhbg9qy2smk_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2F_2D_24_24Lambda_24Pattern_242enjXc1GhR_2DFNtcTfhbg9qy2smk_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fregex_2FMatcher_24OffsetBasedMatchResult_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_24OffsetBasedMatchResult_3B, input, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FMatcher_24OffsetBasedMatchResult_3B, offsets, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fregex_2FPattern_241MatcherIterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPattern_241MatcherIterator_3B, current, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPattern_241MatcherIterator_3B, emptyElementCount, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPattern_241MatcherIterator_3B, matcher, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPattern_241MatcherIterator_3B, nextElement, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPattern_241MatcherIterator_3B, this_240, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPattern_241MatcherIterator_3B, val_24input, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_2402PZAQlwu7SKkigJ7EI4kdTzqnI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_240HimmAYr5h1pFdNckEhxJ9y9Zqk_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_246eeAyFpmvaed9kw3uuEs0ErN7sg_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24745FUy7cYwYu7KrMQTYh2DNqh1I_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_248ABiL5PN53c8rr14__yI2__4o5Zlo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_249_2Dclh6DyAY2rGfAxuH1sO9aEBuU_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Abl7XfE0Z4AgkViLas9vhsO9mjw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Abl7XfE0Z4AgkViLas9vhsO9mjw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24AbstractPipeline_24ImXhRLJT29W8lJFXpTT__PieAotg_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24AbstractPipeline_24ImXhRLJT29W8lJFXpTT__PieAotg_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24AbstractPipeline_24i18ybop3uEZwLQyKh7zmnuTXiFw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24AbstractPipeline_24i18ybop3uEZwLQyKh7zmnuTXiFw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24AbstractPipeline_24wEsmW74nQaCA9FYTjN7e9qkJaXE_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24B6rBjxAejI5kqKK9J3AHwY__L9ag_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24BZcmU4lh1MU8ke57orLk6ELdvT4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_240hO4kVeN9EGHZquOI__a__qZ75htQ_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_240hO4kVeN9EGHZquOI__a__qZ75htQ_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_2449j2hRW8u6KMoxsVt77YSpMRb1g_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_2449j2hRW8u6KMoxsVt77YSpMRb1g_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_245sBFPk12YoFTd83smSoPj46DB__A_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_245sBFPk12YoFTd83smSoPj46DB__A_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_248qmKppCC__QJwGcQ9bUPPu3l_2D5Bg_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_248wf84PB5r3lvvid_2DSVfjAcFbHXg_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24AI86aRAtMJ__TFLEAd_2DUERhgg_2DkI_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24AI86aRAtMJ__TFLEAd_2DUERhgg_2DkI_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24AfO__bLozmdhHTtbBN7DysDzpfYM_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24AfO__bLozmdhHTtbBN7DysDzpfYM_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24AfO__bLozmdhHTtbBN7DysDzpfYM_3B, f_241, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24AfO__bLozmdhHTtbBN7DysDzpfYM_3B, f_242, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24BwzHl6O1mjAgxLE58ctIeFoVBAM_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24BwzHl6O1mjAgxLE58ctIeFoVBAM_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24DPpNNyj_2DGqDgBuGvO0w__46Z3Jl8_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24DPpNNyj_2DGqDgBuGvO0w__46Z3Jl8_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24DPpNNyj_2DGqDgBuGvO0w__46Z3Jl8_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24EsYSkkQ7p405z0qsCjjJsUR3Wfk_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24EsYSkkQ7p405z0qsCjjJsUR3Wfk_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24F7_2Dwe3W7I2plNaGHqh__d2lzmvho_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24F7_2Dwe3W7I2plNaGHqh__d2lzmvho_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24F7_2Dwe3W7I2plNaGHqh__d2lzmvho_3B, f_241, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24F7_2Dwe3W7I2plNaGHqh__d2lzmvho_3B, f_242, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24IFopD1JhOBkpZfx3JTKDGTwaQTo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24IFopD1JhOBkpZfx3JTKDGTwaQTo_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24J__JAZ0tPN2SF0mqc6rtXc__aK03k_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24LdN__EEy4nb6271v6ZFmttzZvNwg_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24Nv3GWD5X6YPdKFD8ca__9SG7qCDI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24P_2D_2DH40qXgNc8jDetutxHAPBu2pw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24PTd6jsJ7t0481HRFfH8tnGifDqw_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24PTd6jsJ7t0481HRFfH8tnGifDqw_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24PTd6jsJ7t0481HRFfH8tnGifDqw_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24PkbZGUBauY6_2Du1ZrRakcFQjTln0_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24PkbZGUBauY6_2Du1ZrRakcFQjTln0_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24QJ1yoZI6qBLk2NH_2DgWkdN8XN8yQ_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24TRHsqgEycZfemtQqwivCY4ecHDM_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24TRHsqgEycZfemtQqwivCY4ecHDM_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24TRHsqgEycZfemtQqwivCY4ecHDM_3B, f_241, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24TRHsqgEycZfemtQqwivCY4ecHDM_3B, f_242, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24WGmHV8Rrm8a3qqTLJPLQv6fpb8o_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24WGmHV8Rrm8a3qqTLJPLQv6fpb8o_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24WTLZnkfYyw3lURYA1kkAz43vGhw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24ZHtBI7Du2F__qzRSEqDnG6y4R0Lw_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24ZHtBI7Du2F__qzRSEqDnG6y4R0Lw_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24ZHtBI7Du2F__qzRSEqDnG6y4R0Lw_3B, f_241, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24ZHtBI7Du2F__qzRSEqDnG6y4R0Lw_3B, f_242, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24bL3PuvFDr85ZCgwmUxFPHSRIrgE_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24bqboixg1w__Miq_2DJsFAc1_2DDEO__aI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24cFIm0q5Hl8z7ocxLjJsCwiKceEI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24chTZg9lp1htTW8rBDwbte7J_2DEOo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24chTZg9lp1htTW8rBDwbte7J_2DEOo_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24dk4em1jXH8zNd7gZJwP7T1HgMsc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24eESkXUxzUQd__kZxyXI8noD7gpIw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24eESkXUxzUQd__kZxyXI8noD7gpIw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24f0IPpRuyw9HZC8FIP30mNjUUUhw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24f68RHYk8qNU7alEHPPrPoFuCJO4_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24f68RHYk8qNU7alEHPPrPoFuCJO4_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24h1ksXokknmXSWBYxKkYfY6ov7ME_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24h1ksXokknmXSWBYxKkYfY6ov7ME_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24hNSw8Kk0nIafeklCUz0r3g25T08_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24hNSw8Kk0nIafeklCUz0r3g25T08_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24hPhWWwdsY4xpBbhcwNVuU8dcJDw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24hPhWWwdsY4xpBbhcwNVuU8dcJDw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24il2gZbqqrAa81yW3okSBWeJddGk_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24jDXjrt99im0xRBROpkCAqoLkqR4_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24jDXjrt99im0xRBROpkCAqoLkqR4_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24kPvxljbEEMQktNHySoxXCZ_2D5cu4_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24kPvxljbEEMQktNHySoxXCZ_2D5cu4_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24l57H1aRUHKWOcUoknXahrBTCBzM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24nKlT6uFghrTzWO44dlFAJFeRr34_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24nKlT6uFghrTzWO44dlFAJFeRr34_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24nKlT6uFghrTzWO44dlFAJFeRr34_3B, f_241, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24nKlT6uFghrTzWO44dlFAJFeRr34_3B, f_242, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24o91A_2Dj5OVnHv9w5Hj__r9fFUMiDY_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24oKi5061mJjDn56eRJcmESyO7x9k_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24oKi5061mJjDn56eRJcmESyO7x9k_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24pzPeDl3rCgtNVSeZPHZk5f2se60_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24pzPeDl3rCgtNVSeZPHZk5f2se60_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24pzPeDl3rCgtNVSeZPHZk5f2se60_3B, f_241, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24pzPeDl3rCgtNVSeZPHZk5f2se60_3B, f_242, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24vmLceJDpkkH4HVeqPcL08DnO8yg_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24vmLceJDpkkH4HVeqPcL08DnO8yg_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24vmLceJDpkkH4HVeqPcL08DnO8yg_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24xODDB9V1Y7uzjD3f8OY1Ck4IN4k_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24xODDB9V1Y7uzjD3f8OY1Ck4IN4k_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24xmuLwoAlFtOfbPB5C1jdMenPWHE_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24xyNVxvHgGD7IIanzX9Sm9NxmODA_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24xyNVxvHgGD7IIanzX9Sm9NxmODA_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24zuotCFMPpEd__pFOpcqCzvWNwmcE_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24zuotCFMPpEd__pFOpcqCzvWNwmcE_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DistinctOps_241_24y8chmSlaKpIKb__VPPBaXdCNT51c_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DistinctOps_241_24y8chmSlaKpIKb__VPPBaXdCNT51c_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DistinctOps_241_24y8chmSlaKpIKb__VPPBaXdCNT51c_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_245_241_24kqJiVK7sQB3kKvPk9DB9gInHJq4_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_245_241_24kqJiVK7sQB3kKvPk9DB9gInHJq4_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_245_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_245_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_245_3B, 96, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_245_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_245_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_3B, 80, Ljava_2Futil_2Fstream_2FAbstractPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B, 80, Ljava_2Futil_2Fstream_2FDoublePipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B, downstream, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_248lpXAdS4oGMq6Yo__dNhNdoP_2Dgg0_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24KYIKJiRuFnKlAv02sN6Y0G5US7E_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24O7F4ENrC3oYj9E0vblCKW9Dec60_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24V2mM4__kocaa0EZ7g04Qc6__Yd13E_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24VwL6T93St4bY9lzEXgl24N__DcA4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24btJQIF5a5bk658mbj9AIl0UV19Q_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24gq0fD9NZ938fl5Zgm1Lwm9G2tpI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24jsM76ecD5K__oP4TaArM1RdmdjOw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24lWQTyY6EPN0Xvhyjp5Lr5ZKBDCA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Drw47GGUtPrz9CklhlT0v26u_2D5c_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24FZ2W1z3RReutoY2tFnI__NsF0lTk_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ForEachOps_24ForEachOrderedTask_24XLqga2XPr4V7tlS8H12fiz_2DIn_2Do_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24G0LLxk8pWitjFgsOx2bYtRO_2DrGg_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24G0LLxk8pWitjFgsOx2bYtRO_2DrGg_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24HJTpjoyUrBGPZyR69XwKllqU1YY_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_240s__rkIyKzlnj__M_2DbqfCTpum__W2c_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_247_241_24E2wwNE1UnVxs0E9_2Dn47lRWmnJGM_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_247_241_24E2wwNE1UnVxs0E9_2Dn47lRWmnJGM_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_247_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_247_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_247_3B, 96, Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_247_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_247_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_3B, 80, Ljava_2Futil_2Fstream_2FAbstractPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B, 80, Ljava_2Futil_2Fstream_2FIntPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B, downstream, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_24MrivqBp4YhHB__ix11jxmkPQ1lbE_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_24Q__Wb7uDnZZMCasMbsGNAwSlprMo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_24R_2DE7oGjPWog3HR9X_2D8MdhU1ZGRE_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_24hMFCZ84F0UujzJhdWtPfESTkN2A_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_24ozedusDMANE__B8aDthWCd1L_2Dna4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24JNjUhnscc8mcsjlQNaAi4qIfRDQ_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24KCZEjYEMhxUzZZN6W26atKG9NZc_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24KCZEjYEMhxUzZZN6W26atKG9NZc_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LfPL0444L8HcP6gPtdKqQiCTSfM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_246_241_24fLvJH__Wq0Kv_2DMEJSFU3IOaEtvxk_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_246_241_24fLvJH__Wq0Kv_2DMEJSFU3IOaEtvxk_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_246_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_246_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_246_3B, 96, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_246_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_246_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_3B, 80, Ljava_2Futil_2Fstream_2FAbstractPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B, 80, Ljava_2Futil_2Fstream_2FLongPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B, downstream, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_24C2qxkG_2D7ctBwIL2ufjYSA46AbOM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_24HjmjwoQcQfPYnTF2E4GrQONBjyM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_24LTFlNC6dzl63DE63FJGC_2DsG7H__c_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_24doop4YO9hzEFGaLnLB3xKA404M4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_24sfTgyfHS4klE7h4z5M_2DNXsSIFcQ_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_24unkecqyY0oPqnMvfYdq__wAGb9pY_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24VXR1J72V6WzQCN_2D3NkesXDVJ1uc_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24VXR1J72V6WzQCN_2D3NkesXDVJ1uc_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24VXR1J72V6WzQCN_2D3NkesXDVJ1uc_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24__LtFSpSMfVwoPv_2D8p__1cMGGcaHA_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24__LtFSpSMfVwoPv_2D8p__1cMGGcaHA_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24__LtFSpSMfVwoPv_2D8p__1cMGGcaHA_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24emK14UX33I4_2DnqH2o5l7hLEVAy8_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24emK14UX33I4_2DnqH2o5l7hLEVAy8_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24emK14UX33I4_2DnqH2o5l7hLEVAy8_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24kCrOdGmndcbZklBaJ6Z4blQ1F5M_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24kCrOdGmndcbZklBaJ6Z4blQ1F5M_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24MatchOps_24kCrOdGmndcbZklBaJ6Z4blQ1F5M_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Node_24OfDouble_245XMtiGLC0wkQzF2OIEVEnEBoYWM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Node_24OfInt_24SR5qcq7S0oCtehCDXAgbRdnvBbw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Node_24OfLong_24bPdsg__NFhPin_2Dja__QQPm0P0wq9s_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Node_24fa69PlTVbbnR3yr46T9Wo0__bIhg_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Nodes_24CollectorTask_24OfRef_24Zd2fdoB_2DmZW0DbPHybIpYjf_2DPyo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Nodes_24CollectorTask_24OfRef_24Zd2fdoB_2DmZW0DbPHybIpYjf_2DPyo_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24OExyAlU04fvFLvnsXWOUeFS6K6Y_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ReferencePipeline_24i_2DWMOWw_2DbzoH__v_2DeRIvtIHIFvko_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ReferencePipeline_24i_2DWMOWw_2DbzoH__v_2DeRIvtIHIFvko_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ReferencePipeline_24i_2DWMOWw_2DbzoH__v_2DeRIvtIHIFvko_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ReferencePipeline_24mk6xSsLZAKvG89IyN8pzBoM6otw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ReferencePipeline_24n3O__UMTjTSOeDSKD1yhh__2N2rRU_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24S_2D3JQ3_2DufQOqvkvYGc3Sza_2D87R0_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24SliceOps_242_24pJKvYyBs7HGPiOPTm__fxpciSsG8_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24SliceOps_243_24iKJ8R9VMhJpW3rzcr1q_2D11o2TH4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24SliceOps_244_24JdMLhF4N5dBS3gGxMct4lK2SQ04_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24SliceOps_24T0eS2B9nWeCpmA7G2QlMnW3G2UA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24DistinctSpliterator_24ojM_2DHxa6O4_2DMX3G2cGvIRG3GI58_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24DistinctSpliterator_24ojM_2DHxa6O4_2DMX3G2cGvIRG3GI58_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24DistinctSpliterator_24ojM_2DHxa6O4_2DMX3G2cGvIRG3GI58_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DistinctSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DistinctSpliterator_3B, s, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DistinctSpliterator_3B, seen, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DistinctSpliterator_3B, tmpSlot, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24DoubleWrappingSpliterator_24vGvekEV3XchaSAEI93tmYCeVG9A_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24DoubleWrappingSpliterator_24vGvekEV3XchaSAEI93tmYCeVG9A_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DoubleWrappingSpliterator_3B, 72, Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, bufferSink, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, finished, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, isParallel, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, nextToConsume, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, ph, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, pusher, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, spliterator, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B, spliteratorSupplier, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24IntWrappingSpliterator_24js67IRBzuEwtfp5Z3OTF_2DGfmUTw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24IntWrappingSpliterator_24js67IRBzuEwtfp5Z3OTF_2DGfmUTw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24IntWrappingSpliterator_3B, 72, Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24LongWrappingSpliterator_24sXmxiR9mZHUX9mr52PfuVCxTtPw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24LongWrappingSpliterator_24sXmxiR9mZHUX9mr52PfuVCxTtPw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24LongWrappingSpliterator_3B, 72, Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24SliceSpliterator_24OfDouble_24F1bBlpqcoM__HwaVPMQ3Q9zUwTCw_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24SliceSpliterator_24OfInt_24GDCU9wlqIN8f_2Dnp3lkzlBdIGmvc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24SliceSpliterator_24OfLong_24gbTno__el7bKUjUiBqsBq7RYjcY8_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24SliceSpliterator_24OfRef_24NUGTWbZg9cfpPm623I8CORYtfns_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24SliceSpliterator_24OfRef_24WQsOrB6TN5sHvsPJU2O20DZGElU_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24WrappingSpliterator_24Ky6g3CKkCccuRWAvbAL1cAsdkNk_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24StreamSpliterators_24WrappingSpliterator_24Ky6g3CKkCccuRWAvbAL1cAsdkNk_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24WrappingSpliterator_3B, 72, Ljava_2Futil_2Fstream_2FStreamSpliterators_24AbstractWrappingSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Tripwire_24h_2DWLrZCXxuA6HLdDg4eUp2SowfQ_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24UowTf7vzuMsu4sv1_2DeMs5iEeNh0_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24VQnU3Jki1_2DRCSS5B_2DYg__Kf6hQAY_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24XcCQq8gYss3OrVBeBIbyvBZpOz8_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Xsl4nKeYydTETtdRjTtEXmjJItE_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Y__fORtDI6zkwP__Z__VGSwO2GcnS0_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24YcgMAuDDScc4HC6CSMDq1R0qa40_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24YpedFjT304pmSbvYSkjP1adjrAo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24__Ea__sNpqZAwihIOCRBaP7hHgWWI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24bjSXRjZ5UYwAzkW_2DXPKwqbJ9BRQ_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24cfwqIEDg0Z3A7MGDNrQPTyjrF9M_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24dplkPhACWDPIy18ogwdupEQaN40_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ihOtgw0eLCrsEBOphyN7SwoAlDg_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24kZuTETptiPwvB1J27Na7j760aLU_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24l1vHMFuOMPAI8WfDQT6zNBh__B7U_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24lG52Z65fM3qwbieoOBUupMhmr2E_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24mpgi0fNdNmnu9LkjGowG335UgGc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24o8baRh54JSyOHAKgObeucNn1Zos_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24okJigbB9kSn____oCZ5Do9uFNyF6A_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ono9Bp0lMrKbIRfAAYdycY0__qag_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24opQ7JxjVCJzqzgTxGU3LVtqC7is_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24r_2D8H__R__mZJjp9wd0XTLoEAHMNQ0_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24r6LgDiay3Ow5w51ifJiV4dn8S84_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ry7iWszBr7beYy31SdRxibDyciQ_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24sKPaOkcQePGTRevrwmKVVhCTmTo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24timJ2__RnT5GwsTSax4Q0EMpi4pc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24uJ6CkL42Bk73jN5EzP0Fx7o1eVA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24w4zz3RuWVbX94KiVllUNB6u__ygA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24wDsxx48ovPSGeNEb3P6H9u7YX0k_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24wDsxx48ovPSGeNEb3P6H9u7YX0k_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24wFoiz_2DRiPqYBPe0X4aSzbj2iL3g_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24xi7ZBZfKmkbt5CSsaL8qlNeHupc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24yTqQxkqu88ZhKI6fWaTTLwOLF60_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24yrGzfUbU__IPNM4mz8V8FlMUHCw4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24zQ_2D9PoG_2DPFOA3MjNNbaERnRB6ik_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24zQ_2D9PoG_2DPFOA3MjNNbaERnRB6ik_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24zcFI7bYCRDtB1UMy72aPExbc6R4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FCollectors_24CollectorImpl_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_24CollectorImpl_3B, accumulator, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_24CollectorImpl_3B, characteristics, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_24CollectorImpl_3B, combiner, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_24CollectorImpl_3B, finisher, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_24CollectorImpl_3B, supplier, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FFindOps_24FindOp_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FFindOps_24FindOp_3B, emptyValue, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FFindOps_24FindOp_3B, mustFindFirst, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FFindOps_24FindOp_3B, presentPredicate, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FFindOps_24FindOp_3B, shape, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FFindOps_24FindOp_3B, sinkSupplier, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FMatchOps_24MatchOp_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_24MatchOp_3B, inputShape, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_24MatchOp_3B, matchKind, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_24MatchOp_3B, sinkSupplier, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24AbstractConcNode_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24AbstractConcNode_3B, left, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24AbstractConcNode_3B, right, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24AbstractConcNode_3B, size, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ArrayNode_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24ArrayNode_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24ArrayNode_3B, curSize, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24CollectionNode_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24CollectionNode_3B, c, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24EmptyNode_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_3B, curChildIndex, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_3B, curNode, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_3B, lastNodeSpliterator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_3B, tryAdvanceSpliterator, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_3B, tryAdvanceStack, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B, inputShape, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_241Splitr_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_241Splitr_3B, lastSpineElementFence, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_241Splitr_3B, lastSpineIndex, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_241Splitr_3B, splChunk, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_241Splitr_3B, splElementIndex, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_241Splitr_3B, splSpineIndex, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_241Splitr_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_3B, 48, Ljava_2Futil_2Fstream_2FAbstractSpinedBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_3B, curChunk, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_3B, spine, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_3B, 48, Ljava_2Futil_2Fstream_2FAbstractSpinedBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_3B, curChunk, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_3B, spine, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStream_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStream_241_3B, t, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStream_241_3B, val_24f, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStream_241_3B, val_24seed, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfPrimitive_3B, 20, Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfPrimitive_3B, index, 16, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfRef_3B, 24, Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfRef_3B, array, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_3B, s, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_3B, supplier, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_3B, estimate, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_24OfRef_3B, 56, Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfRef_3B, 48, Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfRef_3B, tmpSlot, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_241_3B, val_24a, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_241_3B, val_24b, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_242_3B, val_24a, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_242_3B, val_24b, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24AbstractStreamBuilderImpl_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24AbstractStreamBuilderImpl_3B, count, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_3B, aSpliterator, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_3B, bSpliterator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_3B, beforeSplit, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_3B, unsized, 13, 1)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FAdler32_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FAdler32_3B, adler, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipFile_24ZipEntryIterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipEntryIterator_3B, i, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipEntryIterator_3B, this_240, 16, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FJarVerifier_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FJarVerifier_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FJarVerifier_241_3B, val_24url, 24, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FJceSecurity_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FJceSecurity_241_3B, val_24clazz, 16, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FJceSecurityManager_3B, 13, Ljava_2Flang_2FSecurityManager_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FMac_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FMac_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FMac_3B, initialized, 12, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FMac_3B, lock, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FMac_3B, provider, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FMac_3B, spi, 40, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FNullCipher_3B, 72, Ljavax_2Fcrypto_2FCipher_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FNullCipherSpi_3B, 12, Ljavax_2Fcrypto_2FCipherSpi_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FSealedObject_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FSealedObject_3B, encodedParams, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FSealedObject_3B, encryptedContent, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FSealedObject_3B, paramsAlg, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FSealedObject_3B, sealAlg, 40, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FDESKeySpec_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDESKeySpec_3B, key, 16, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FDESedeKeySpec_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDESedeKeySpec_3B, key, 16, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FDHGenParameterSpec_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHGenParameterSpec_3B, exponentSize, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHGenParameterSpec_3B, primeSize, 16, 4)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FDHPrivateKeySpec_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHPrivateKeySpec_3B, g, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHPrivateKeySpec_3B, p, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHPrivateKeySpec_3B, x, 32, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FDHPublicKeySpec_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHPublicKeySpec_3B, g, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHPublicKeySpec_3B, p, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FDHPublicKeySpec_3B, y, 32, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FGCMParameterSpec_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FGCMParameterSpec_3B, iv, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FGCMParameterSpec_3B, tLen, 12, 4)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FIvParameterSpec_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FIvParameterSpec_3B, iv, 16, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FOAEPParameterSpec_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FOAEPParameterSpec_3B, mdName, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FOAEPParameterSpec_3B, mgfName, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FOAEPParameterSpec_3B, mgfSpec, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FOAEPParameterSpec_3B, pSrc, 40, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FPBEKeySpec_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FPBEKeySpec_3B, iterationCount, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FPBEKeySpec_3B, keyLength, 16, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FPBEKeySpec_3B, password, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FPBEKeySpec_3B, salt, 32, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FPBEParameterSpec_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FPBEParameterSpec_3B, iterationCount, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FPBEParameterSpec_3B, paramSpec, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FPBEParameterSpec_3B, salt, 24, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FPSource_24PSpecified_3B, 32, Ljavax_2Fcrypto_2Fspec_2FPSource_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FPSource_24PSpecified_3B, p, 24, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FRC2ParameterSpec_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FRC2ParameterSpec_3B, effectiveKeyBits, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FRC2ParameterSpec_3B, iv, 16, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FRC5ParameterSpec_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FRC5ParameterSpec_3B, iv, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FRC5ParameterSpec_3B, rounds, 12, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FRC5ParameterSpec_3B, version, 24, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FRC5ParameterSpec_3B, wordSize, 28, 4)
+__MRT_CLASS(Ljavax_2Fnet_2FDefaultServerSocketFactory_3B, 12, Ljavax_2Fnet_2FServerSocketFactory_3B)
+__MRT_CLASS(Ljavax_2Fnet_2FDefaultSocketFactory_3B, 12, Ljavax_2Fnet_2FSocketFactory_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FCertPathTrustManagerParameters_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FCertPathTrustManagerParameters_3B, parameters, 16, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FExtendedSSLSession_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FKeyManagerFactory_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FKeyStoreBuilderParameters_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FKeyStoreBuilderParameters_3B, parameters, 16, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSNIHostName_24SNIHostNameMatcher_3B, 24, Ljavax_2Fnet_2Fssl_2FSNIMatcher_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSNIHostName_24SNIHostNameMatcher_3B, pattern, 16, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSNIHostName_3B, 32, Ljavax_2Fnet_2Fssl_2FSNIServerName_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSNIHostName_3B, hostname, 24, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLSessionBindingEvent_3B, 32, Ljava_2Futil_2FEventObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLSessionBindingEvent_3B, name, 24, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLSocketFactory_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FSSLSocketFactory_241_3B, val_24name, 16, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FTrustManagerFactory_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_241_3B, val_24acc, 16, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_242_3B, val_24acc, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_242_3B, val_24subject, 24, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24ClassSet_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24ClassSet_241_3B, this_241, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24ClassSet_241_3B, val_24iterator, 24, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24ClassSet_3B, 40, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24ClassSet_3B, c, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24ClassSet_3B, set, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24ClassSet_3B, this_240, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24ClassSet_3B, which, 12, 4)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_241_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_241_3B, val_24list, 32, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_3B, 32, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_3B, elements, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_3B, subject, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_3B, which, 12, 4)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_242_3B, val_24e, 24, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_243_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_243_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_243_3B, val_24e, 24, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_244_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_244_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_244_3B, val_24e, 24, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_245_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_245_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_245_3B, val_24e, 24, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_246_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_246_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2FSubject_24SecureSet_246_3B, val_24e, 24, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FSubjectDomainCombiner_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2Fcallback_2FPasswordCallback_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2Fcallback_2FPasswordCallback_3B, echoOn, 12, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2Fcallback_2FPasswordCallback_3B, inputPassword, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2Fcallback_2FPasswordCallback_3B, prompt, 24, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fcert_2FX509Certificate_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fsql_2FRowSetEvent_3B, 24, Ljava_2Futil_2FEventObject_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2Fdom_2FDOMResult_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fdom_2FDOMResult_3B, nextSibling, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fdom_2FDOMResult_3B, node, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fdom_2FDOMResult_3B, systemId, 32, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2Fdom_2FDOMSource_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fdom_2FDOMSource_3B, node, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fdom_2FDOMSource_3B, systemID, 24, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2Fsax_2FSAXResult_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fsax_2FSAXResult_3B, handler, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fsax_2FSAXResult_3B, lexhandler, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fsax_2FSAXResult_3B, systemId, 32, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2Fsax_2FSAXSource_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fsax_2FSAXSource_3B, inputSource, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fsax_2FSAXSource_3B, reader, 24, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2Fsax_2FSAXTransformerFactory_3B, 12, Ljavax_2Fxml_2Ftransform_2FTransformerFactory_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2Fstream_2FStreamResult_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fstream_2FStreamResult_3B, outputStream, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fstream_2FStreamResult_3B, systemId, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fstream_2FStreamResult_3B, writer, 32, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2Fstream_2FStreamSource_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fstream_2FStreamSource_3B, inputStream, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fstream_2FStreamSource_3B, publicId, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fstream_2FStreamSource_3B, reader, 32, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2Fstream_2FStreamSource_3B, systemId, 40, 8)
+__MRT_CLASS(Ljdk_2Fnet_2FExtendedSocketOptions_24ExtSocketOption_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljdk_2Fnet_2FExtendedSocketOptions_24ExtSocketOption_3B, name, 16, 8)
+__MRT_CLASS_FIELD(Ljdk_2Fnet_2FExtendedSocketOptions_24ExtSocketOption_3B, type, 24, 8)
+__MRT_CLASS(Ljdk_2Fnet_2FSockets_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FTimeZoneNames_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fio_2FForwardingOs_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FForwardingOs_3B, os, 16, 8)
+__MRT_CLASS(Llibcore_2Fio_2FLinux_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Llibcore_2Fio_2FNioBufferIterator_3B, 37, Llibcore_2Fio_2FBufferIterator_3B)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FNioBufferIterator_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FNioBufferIterator_3B, file, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FNioBufferIterator_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FNioBufferIterator_3B, position, 32, 4)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FNioBufferIterator_3B, swap, 36, 1)
+__MRT_CLASS(Llibcore_2Fnet_2FNetworkSecurityPolicy_24DefaultNetworkSecurityPolicy_3B, 12, Llibcore_2Fnet_2FNetworkSecurityPolicy_3B)
+__MRT_CLASS(Llibcore_2Fnet_2Fhttp_2FHttpDate_241_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Ljava_2Ftext_2FDateFormat_3B, 32, Ljava_2Ftext_2FFormat_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormat_3B, calendar, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormat_3B, numberFormat, 24, 8)
+__MRT_CLASS(Ljava_2Ftext_2FNumberFormat_3B, 40, Ljava_2Ftext_2FFormat_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, groupingUsed, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, maxFractionDigits, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, maxIntegerDigits, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, maximumFractionDigits, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, maximumIntegerDigits, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, minFractionDigits, 15, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, minIntegerDigits, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, minimumFractionDigits, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, minimumIntegerDigits, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, parseIntegerOnly, 25, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FNumberFormat_3B, serialVersionOnStream, 36, 4)
+__MRT_CLASS(Llibcore_2Freflect_2FAnnotationFactory_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FAnnotationFactory_3B, elements, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FAnnotationFactory_3B, klazz, 24, 8)
+__MRT_CLASS(Llibcore_2Freflect_2FAnnotationMember_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FAnnotationMember_3B, definingMethod, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FAnnotationMember_3B, elementType, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FAnnotationMember_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FAnnotationMember_3B, tag, 12, 2)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FAnnotationMember_3B, value, 40, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2F_2D_24_24Lambda_24TimeZoneFinder_24ReaderSupplier_24Q2dnwJWibh29nQ77BtDmdnZnbdI_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2F_2D_24_24Lambda_24TimeZoneFinder_24ReaderSupplier_24Q2dnwJWibh29nQ77BtDmdnZnbdI_3B, f_240, 16, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2F_2D_24_24Lambda_24TimeZoneFinder_24ReaderSupplier_24gDAfECMWS__ohJ__Rfk1HN7JyDSJA_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2F_2D_24_24Lambda_24TimeZoneFinder_24ReaderSupplier_24gDAfECMWS__ohJ__Rfk1HN7JyDSJA_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2F_2D_24_24Lambda_24TimeZoneFinder_24ReaderSupplier_24gDAfECMWS__ohJ__Rfk1HN7JyDSJA_3B, f_241, 24, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FTimeZoneFinder_24CountryZonesLookupExtractor_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTimeZoneFinder_24CountryZonesLookupExtractor_3B, countryTimeZonesList, 16, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FTimeZoneFinder_24IanaVersionExtractor_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTimeZoneFinder_24IanaVersionExtractor_3B, ianaVersion, 16, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FTimeZoneFinder_24SelectiveCountryTimeZonesExtractor_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTimeZoneFinder_24SelectiveCountryTimeZonesExtractor_3B, countryCodeToMatch, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTimeZoneFinder_24SelectiveCountryTimeZonesExtractor_3B, validatedCountryTimeZones, 24, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FTimeZoneFinder_24TimeZonesValidator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FTimeZoneFinder_24TimeZonesValidator_3B, knownCountryCodes, 16, 8)
+__MRT_CLASS(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_241_3B, 32, Llibcore_2Futil_2FBasicLruCache_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ftimezone_2FZoneInfoDB_24TzData_241_3B, this_240, 24, 8)
+__MRT_CLASS(Llibcore_2Futil_2FCollectionUtils_241_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FCollectionUtils_241_241_3B, delegate, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FCollectionUtils_241_241_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FCollectionUtils_241_241_3B, removeIsOkay, 12, 1)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FCollectionUtils_241_241_3B, this_240, 32, 8)
+__MRT_CLASS(Llibcore_2Futil_2FCollectionUtils_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FCollectionUtils_241_3B, val_24iterable, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FCollectionUtils_241_3B, val_24trim, 12, 1)
+__MRT_CLASS(Llibcore_2Futil_2FNativeAllocationRegistry_24CleanerRunner_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FNativeAllocationRegistry_24CleanerRunner_3B, cleaner, 16, 8)
+__MRT_CLASS(Llibcore_2Futil_2FNativeAllocationRegistry_24CleanerThunk_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FNativeAllocationRegistry_24CleanerThunk_3B, nativePtr, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Futil_2FNativeAllocationRegistry_24CleanerThunk_3B, this_240, 24, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24EntityParser_3B, 92, Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24EntityParser_3B, depth, 88, 4)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24ExpatLocator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24ExpatLocator_3B, this_240, 16, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_2413_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_2413_3B, val_24result, 16, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_245_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_248_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_249_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24FixedParameter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24FixedParameter_3B, onlyValue, 16, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMErrorImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMErrorImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMErrorImpl_3B, severity, 12, 2)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMErrorImpl_3B, type, 16, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMImplementationImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_24ElementAttrNamedNodeMapImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_24ElementAttrNamedNodeMapImpl_3B, this_240, 16, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_3B, 88, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FInnerNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_3B, attributes, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_3B, localName, 56, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_3B, namespaceAware, 64, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_3B, namespaceURI, 72, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FElementImpl_3B, prefix, 80, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B, 104, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FInnerNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B, documentUri, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B, domConfiguration, 56, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B, domImplementation, 64, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B, inputEncoding, 72, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B, nodeToUserData, 80, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B, strictErrorChecking, 88, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B, xmlStandalone, 89, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentImpl_3B, xmlVersion, 96, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeImpl_3B, document, 16, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FAttrImpl_3B, 72, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FAttrImpl_3B, isId, 24, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FAttrImpl_3B, localName, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FAttrImpl_3B, namespaceAware, 25, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FAttrImpl_3B, namespaceURI, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FAttrImpl_3B, ownerElement, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FAttrImpl_3B, prefix, 56, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FAttrImpl_3B, value, 64, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FCDATASectionImpl_3B, 48, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FTextImpl_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FTextImpl_3B, 48, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FCharacterDataImpl_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FCharacterDataImpl_3B, 48, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FLeafNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FCharacterDataImpl_3B, buffer, 40, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FLeafNodeImpl_3B, 40, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FLeafNodeImpl_3B, index, 24, 4)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FLeafNodeImpl_3B, parent, 32, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FInnerNodeImpl_3B, 48, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FLeafNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FInnerNodeImpl_3B, children, 40, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeListImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeListImpl_3B, children, 16, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FCommentImpl_3B, 48, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FCharacterDataImpl_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentFragmentImpl_3B, 48, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FInnerNodeImpl_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FEntityReferenceImpl_3B, 48, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FLeafNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FEntityReferenceImpl_3B, name, 40, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FProcessingInstructionImpl_3B, 56, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FLeafNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FProcessingInstructionImpl_3B, data, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FProcessingInstructionImpl_3B, target, 48, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeImpl_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderFactoryImpl_3B, 18, Ljavax_2Fxml_2Fparsers_2FDocumentBuilderFactory_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderImpl_3B, 32, Ljavax_2Fxml_2Fparsers_2FDocumentBuilder_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderImpl_3B, coalescing, 12, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderImpl_3B, entityResolver, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderImpl_3B, errorHandler, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderImpl_3B, ignoreComments, 13, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderImpl_3B, ignoreElementContentWhitespace, 14, 1)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FDocumentBuilderImpl_3B, namespaceAware, 15, 1)
+__MRT_CLASS(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, 232, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, attributeCount, 12, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, attributes, 16, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, buffer, 24, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, bufferCapture, 32, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, bufferStartColumn, 40, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, bufferStartLine, 44, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, defaultAttributes, 48, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, degenerated, 56, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, depth, 60, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, documentEntities, 64, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, elementStack, 72, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, encoding, 80, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, error, 88, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, isWhitespace, 57, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, keepNamespaceAttributes, 58, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, limit, 96, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, location, 104, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, name, 112, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, namespace, 120, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, nextContentSource, 128, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, nspCounts, 136, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, nspStack, 144, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, parsedTopLevelStartTag, 59, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, position, 100, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, prefix, 152, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, processDocDecl, 160, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, processNsp, 161, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, publicId, 168, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, reader, 176, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, relaxed, 162, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, rootElementName, 184, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, standalone, 192, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, stringPool, 200, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, systemId, 208, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, text, 216, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, type, 164, 4)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, unresolved, 163, 1)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_3B, version, 224, 8)
+__MRT_CLASS(Lcom_2Fandroid_2Forg_2Fkxml2_2Fio_2FKXmlParser_24ValueContext_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FSAXParserFactoryImpl_3B, 24, Ljavax_2Fxml_2Fparsers_2FSAXParserFactory_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FSAXParserFactoryImpl_3B, features, 16, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FSAXParserImpl_3B, 40, Ljavax_2Fxml_2Fparsers_2FSAXParser_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FSAXParserImpl_3B, initialFeatures, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FSAXParserImpl_3B, parser, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fparsers_2FSAXParserImpl_3B, reader, 32, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FAttributeListImpl_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FAttributeListImpl_3B, names, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FAttributeListImpl_3B, types, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FAttributeListImpl_3B, values, 32, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FAttributesImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FAttributesImpl_3B, data, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FAttributesImpl_3B, length, 12, 4)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FLocatorImpl_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FLocatorImpl_3B, columnNumber, 12, 4)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FLocatorImpl_3B, lineNumber, 16, 4)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FLocatorImpl_3B, publicId, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FLocatorImpl_3B, systemId, 32, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_24AttributeListAdapter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_24AttributeListAdapter_3B, qAtts, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_24AttributeListAdapter_3B, this_240, 24, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, 96, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, attAdapter, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, atts, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, contentHandler, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, dtdHandler, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, entityResolver, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, errorHandler, 56, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, locator, 64, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, nameParts, 72, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, namespaces, 12, 1)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, nsSupport, 80, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, parser, 88, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, parsing, 13, 1)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, prefixes, 14, 1)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FParserAdapter_3B, uris, 15, 1)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLReaderAdapter_24AttributesAdapter_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLReaderAdapter_24AttributesAdapter_3B, attributes, 16, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLReaderAdapter_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLReaderAdapter_3B, documentHandler, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLReaderAdapter_3B, qAtts, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLReaderAdapter_3B, xmlReader, 32, 8)
+__MRT_CLASS(Lorg_2Fxmlpull_2Fv1_2Fsax2_2FDriver_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2Fsax2_2FDriver_3B, contentHandler, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2Fsax2_2FDriver_3B, errorHandler, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2Fsax2_2FDriver_3B, pp, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxmlpull_2Fv1_2Fsax2_2FDriver_3B, systemId, 40, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FASCIICaseInsensitiveComparator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FBASE64Decoder_3B, 24, Lsun_2Fmisc_2FCharacterDecoder_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FBASE64Decoder_3B, decode__buffer, 16, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FBASE64Encoder_3B, 24, Lsun_2Fmisc_2FCharacterEncoder_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FCleaner_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FCleaner_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FCleaner_241_3B, val_24x, 24, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FCompoundEnumeration_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FCompoundEnumeration_3B, enums, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FCompoundEnumeration_3B, index, 12, 4)
+__MRT_CLASS(Lsun_2Fmisc_2FFloatingDecimal_241_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FFloatingDecimal_24ASCIIToBinaryBuffer_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24ASCIIToBinaryBuffer_3B, decExponent, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24ASCIIToBinaryBuffer_3B, digits, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24ASCIIToBinaryBuffer_3B, isNegative, 24, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24ASCIIToBinaryBuffer_3B, nDigits, 28, 4)
+__MRT_CLASS(Lsun_2Fmisc_2FFloatingDecimal_24ExceptionalBinaryToASCIIBuffer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24ExceptionalBinaryToASCIIBuffer_3B, image, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24ExceptionalBinaryToASCIIBuffer_3B, isNegative, 12, 1)
+__MRT_CLASS(Lsun_2Fmisc_2FFloatingDecimal_24PreparedASCIIToBinaryBuffer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24PreparedASCIIToBinaryBuffer_3B, doubleVal, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FFloatingDecimal_24PreparedASCIIToBinaryBuffer_3B, floatVal, 12, 4)
+__MRT_CLASS(Lsun_2Fmisc_2FFormattedFloatingDecimal_241_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_241_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_241_3B, cache, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_241_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_241_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_241_3B, url, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_241_3B, val_24check, 40, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_241_3B, val_24name, 48, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_242_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_242_3B, cache, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_242_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_242_3B, res, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_242_3B, this_240, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_242_3B, val_24check, 40, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_242_3B, val_24name, 48, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_243_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_243_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_243_3B, val_24url, 24, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_24FileLoader_241_3B, 56, Lsun_2Fmisc_2FResource_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24FileLoader_241_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24FileLoader_241_3B, val_24file, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24FileLoader_241_3B, val_24name, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24FileLoader_241_3B, val_24url, 48, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_24FileLoader_3B, 40, Lsun_2Fmisc_2FURLClassPath_24Loader_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24FileLoader_3B, dir, 32, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_24JarLoader_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_241_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_24JarLoader_3B, 96, Lsun_2Fmisc_2FURLClassPath_24Loader_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_3B, acc, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_3B, closed, 40, 1)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_3B, csu, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_3B, handler, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_3B, index, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_3B, jar, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_3B, lmap, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_3B, metaIndex, 88, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_24JarLoader_242_3B, 56, Lsun_2Fmisc_2FResource_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_242_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_242_3B, val_24entry, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_242_3B, val_24name, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_242_3B, val_24url, 48, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_24JarLoader_243_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_243_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24JarLoader_243_3B, val_24url, 24, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FURLClassPath_24Loader_241_3B, 56, Lsun_2Fmisc_2FResource_3B)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24Loader_241_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24Loader_241_3B, val_24name, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24Loader_241_3B, val_24uc, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fmisc_2FURLClassPath_24Loader_241_3B, val_24url, 48, 8)
+__MRT_CLASS(Lsun_2Fnet_2FApplicationProxy_3B, 32, Ljava_2Fnet_2FProxy_3B)
+__MRT_CLASS(Lsun_2Fnet_2FDefaultProgressMeteringPolicy_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2FNetProperties_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2FNetworkClient_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_241_3B, val_24encs, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_241_3B, val_24vals, 24, 8)
+__MRT_CLASS(Lsun_2Fnet_2FNetworkClient_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_242_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnet_2FNetworkClient_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FNetworkClient_243_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnet_2FSocksProxy_3B, 36, Ljava_2Fnet_2FProxy_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FSocksProxy_3B, version, 32, 4)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpClientProvider_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2Fimpl_2FDefaultFtpClientProvider_3B, 12, Lsun_2Fnet_2Fftp_2FFtpClientProvider_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_241_3B, val_24encs, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_241_3B, val_24vals, 24, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_242_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, 160, Lsun_2Fnet_2Fftp_2FFtpClient_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, connectTimeout, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, df, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, in, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, lastFileName, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, lastReplyCode, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, lastTransSize, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, loggedIn, 56, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, mlsxParser, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, oldSocket, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, out, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, parser, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, passiveMode, 57, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, proxy, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, readTimeout, 60, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, replyPending, 58, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, restartOffset, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, server, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, serverAddr, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, serverResponse, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, sslFact, 136, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, type, 144, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, useCrypto, 59, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_3B, welcomeMsg, 152, 8)
+__MRT_CLASS(Ljava_2Ftext_2FSimpleDateFormat_3B, 112, Ljava_2Ftext_2FDateFormat_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, compiledPattern, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, defaultCenturyStart, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, defaultCenturyStartYear, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, formatData, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, hasFollowingMinusSign, 52, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, locale, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, minusSign, 54, 2)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, originalNumberFormat, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, originalNumberPattern, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, pattern, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, serialVersionOnStream, 96, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, timeZoneNames, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, useDateFormatSymbols, 53, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FSimpleDateFormat_3B, zeroDigit, 100, 2)
+__MRT_CLASS(Ljava_2Ftext_2FDateFormat_24Field_3B, 28, Ljava_2Ftext_2FFormat_24Field_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDateFormat_24Field_3B, calendarField, 24, 4)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_243_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_244_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_244_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24DefaultParser_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24DefaultParser_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24MLSxParser_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24MLSxParser_3B, df, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24MLSxParser_3B, this_240, 24, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_241_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_241_3B, val_24nprop, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_241_3B, val_24proto, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_241_3B, val_24urlhost, 40, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fspi_2FDefaultProxySelector_3B, 12, Ljava_2Fnet_2FProxySelector_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2FMessageHeader_24HeaderIterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMessageHeader_24HeaderIterator_3B, haveNext, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMessageHeader_24HeaderIterator_3B, index, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMessageHeader_24HeaderIterator_3B, key, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMessageHeader_24HeaderIterator_3B, lock, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMessageHeader_24HeaderIterator_3B, next, 20, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMessageHeader_24HeaderIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2FURLConnection_3B, 72, Ljava_2Fnet_2FURLConnection_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FURLConnection_3B, contentLength, 52, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FURLConnection_3B, contentType, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FURLConnection_3B, properties, 64, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FHandler_3B, 12, Ljava_2Fnet_2FURLStreamHandler_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_241_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, 176, Lsun_2Fnet_2Fwww_2FURLConnection_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, connectTimeout, 72, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, filename, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, ftp, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, fullpath, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, host, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, instProxy, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, is, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, os, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, password, 136, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, pathname, 144, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, permission, 152, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, port, 76, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, readTimeout, 160, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, type, 164, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_3B, user, 168, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FHandler_3B, 12, Ljava_2Fnet_2FURLStreamHandler_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarFileFactory_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_241_3B, val_24closeController, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_241_3B, val_24in, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2F_2D_24_24Lambda_24ThreadPool_24N88rfRTSpCtnK5fgJO_2DWA6OwVQM_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_241_3B, val_24task, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_241_3B, val_24thisGroup, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_242_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_242_3B, val_24task, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_243_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_244_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_244_241_3B, this_241, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_244_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_244_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_244_3B, val_24acc, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_244_3B, val_24delegate, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FCompletedFuture_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FCompletedFuture_3B, exc, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FCompletedFuture_3B, result, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FDatagramDispatcher_3B, 12, Lsun_2Fnio_2Fch_2FNativeDispatcher_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FEPollPort_24EventHandlerTask_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_24EventHandlerTask_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FEPollPort_3B, 152, Lsun_2Fnio_2Fch_2FPort_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_3B, EXECUTE__TASK__OR__SHUTDOWN, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_3B, NEED__TO__POLL, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_3B, address, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_3B, closed, 120, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_3B, epfd, 124, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_3B, queue, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_3B, sp, 136, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FEPollPort_3B, wakeupCount, 144, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FPort_3B, 96, Lsun_2Fnio_2Fch_2FAsynchronousChannelGroupImpl_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPort_3B, fdToChannel, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPort_3B, fdToChannelLock, 88, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FExtendedSocketOption_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileChannelImpl_24SimpleFileLockTable_3B, 24, Lsun_2Fnio_2Fch_2FFileLockTable_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_24SimpleFileLockTable_3B, lockList, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileChannelImpl_24Unmapper_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_24Unmapper_3B, address, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_24Unmapper_3B, cap, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_24Unmapper_3B, fd, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_24Unmapper_3B, size, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileDispatcher_3B, 12, Lsun_2Fnio_2Fch_2FNativeDispatcher_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FIOVecWrapper_24Deallocator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FIOVecWrapper_24Deallocator_3B, obj, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FInvoker_241_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FInvoker_242_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_242_3B, val_24attachment, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_242_3B, val_24exc, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_242_3B, val_24handler, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_242_3B, val_24result, 40, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FInvoker_243_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_243_3B, val_24attachment, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_243_3B, val_24exc, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_243_3B, val_24handler, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FInvoker_243_3B, val_24value, 40, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FLinuxAsynchronousChannelProvider_3B, 12, Ljava_2Fnio_2Fchannels_2Fspi_2FAsynchronousChannelProvider_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FNet_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FNet_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FNet_242_3B, val_24interf, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FNet_243_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FNet_244_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FPipeImpl_3B, 32, Ljava_2Fnio_2Fchannels_2FPipe_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPipeImpl_3B, sink, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPipeImpl_3B, source, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FPollArrayWrapper_3B, 36, Lsun_2Fnio_2Fch_2FAbstractPollArrayWrapper_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPollArrayWrapper_3B, interruptFD, 32, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSelectionKeyImpl_3B, 56, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelectionKey_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSelectionKeyImpl_3B, channel, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSelectionKeyImpl_3B, index, 28, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSelectionKeyImpl_3B, interestOps, 40, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSelectionKeyImpl_3B, readyOps, 44, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSelectionKeyImpl_3B, selector, 48, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSelectorImpl_3B, 80, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractSelector_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSelectorImpl_3B, keys, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSelectorImpl_3B, publicKeys, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSelectorImpl_3B, publicSelectedKeys, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSelectorImpl_3B, selectedKeys, 72, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSelectorProviderImpl_3B, 12, Ljava_2Fnio_2Fchannels_2Fspi_2FSelectorProvider_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSharedFileLockTable_3B, 32, Lsun_2Fnio_2Fch_2FFileLockTable_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSharedFileLockTable_3B, channel, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSharedFileLockTable_3B, fileKey, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_241_3B, 72, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_241_3B, val_24attachment, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_241_3B, val_24fli, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_241_3B, val_24handler, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_241_3B, val_24position, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_241_3B, val_24result, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_241_3B, val_24shared, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_241_3B, val_24size, 64, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_3B, 56, Lsun_2Fnio_2Fch_2FAsynchronousFileChannelImpl_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_3B, threads, 48, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileLockImpl_3B, 41, Ljava_2Fnio_2Fchannels_2FFileLock_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileLockImpl_3B, valid, 40, 1)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousFileChannelImpl_3B, 48, Ljava_2Fnio_2Fchannels_2FAsynchronousFileChannel_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousFileChannelImpl_3B, closeLock, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousFileChannelImpl_3B, closed, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousFileChannelImpl_3B, executor, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousFileChannelImpl_3B, fdObj, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousFileChannelImpl_3B, fileLockTable, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousFileChannelImpl_3B, reading, 13, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousFileChannelImpl_3B, writing, 14, 1)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_242_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_242_3B, val_24attachment, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_242_3B, val_24dst, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_242_3B, val_24handler, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_242_3B, val_24position, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_242_3B, val_24result, 56, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_243_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_243_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_243_3B, val_24attachment, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_243_3B, val_24handler, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_243_3B, val_24position, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_243_3B, val_24result, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSimpleAsynchronousFileChannelImpl_243_3B, val_24src, 56, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketAdaptor_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketAdaptor_241_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketAdaptor_3B, 56, Ljava_2Fnet_2FSocket_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketAdaptor_3B, sc, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketAdaptor_3B, socketInputStream, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketAdaptor_3B, timeout, 36, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, 176, Ljava_2Fnio_2Fchannels_2FSocketChannel_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, fd, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, fdVal, 88, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, guard, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, isInputOpen, 92, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, isOutputOpen, 93, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, isReuseAddress, 94, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, localAddress, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, readLock, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, readerThread, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, readyToConnect, 95, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, remoteAddress, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, socket, 136, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, state, 144, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, stateLock, 152, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, writeLock, 160, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketChannelImpl_3B, writerThread, 168, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketAdaptor_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketAdaptor_242_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketDispatcher_3B, 12, Lsun_2Fnio_2Fch_2FNativeDispatcher_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_241_3B, val_24remote, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, 136, Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, acceptAcc, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, acceptAttachment, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, acceptFuture, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, acceptHandler, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, acceptPending, 96, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, accepting, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, fdVal, 100, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, guard, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, port, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousServerSocketChannelImpl_3B, updateLock, 128, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_3B, 64, Ljava_2Fnio_2Fchannels_2FAsynchronousServerSocketChannel_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_3B, acceptKilled, 24, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_3B, closeLock, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_3B, fd, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_3B, isReuseAddress, 25, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_3B, localAddress, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_3B, open, 26, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousServerSocketChannelImpl_3B, stateLock, 56, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_241_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, 280, Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, connectAttachment, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, connectFuture, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, connectHandler, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, connectPending, 120, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, fdVal, 124, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, guard, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, isGatheringWrite, 121, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, isScatteringRead, 122, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, pendingRemote, 136, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, port, 144, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, readAttachment, 152, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, readBuffer, 160, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, readBuffers, 168, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, readFuture, 176, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, readHandler, 184, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, readPending, 123, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, readTimeoutTask, 192, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, readTimer, 200, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, updateLock, 208, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, writeAttachment, 216, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, writeBuffer, 224, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, writeBuffers, 232, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, writeFuture, 240, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, writeHandler, 248, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, writePending, 256, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, writeTimeoutTask, 264, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_3B, writeTimer, 272, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, 96, Ljava_2Fnio_2Fchannels_2FAsynchronousSocketChannel_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, closeLock, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, fd, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, isReuseAddress, 40, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, localAddress, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, open, 41, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, readKilled, 42, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, readLock, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, readShutdown, 43, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, reading, 44, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, remoteAddress, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, state, 72, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, stateLock, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, writeKilled, 45, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, writeLock, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, writeShutdown, 46, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAsynchronousSocketChannelImpl_3B, writing, 47, 1)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_242_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUtil_241_3B, 16, Ljava_2Flang_2FThreadLocal_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUtil_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fcs_2FThreadLocalCoders_241_3B, 24, Lsun_2Fnio_2Fcs_2FThreadLocalCoders_24Cache_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fcs_2FThreadLocalCoders_242_3B, 24, Lsun_2Fnio_2Fcs_2FThreadLocalCoders_24Cache_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractPath_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPath_241_3B, i, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPath_241_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractPoller_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPoller_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPoller_241_3B, val_24thisRunnable, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractPoller_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPoller_3B, requestList, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractPoller_3B, shutdown, 12, 1)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_24Event_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_24Event_3B, context, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_24Event_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_24Event_3B, kind, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_3B, dir, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_3B, events, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_3B, lastModifyEvents, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_3B, state, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_3B, watcher, 48, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractWatchKey_24State_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractWatchService_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchService_3B, CLOSE__KEY, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchService_3B, closeLock, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchService_3B, closed, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchService_3B, pendingKeys, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FCancellable_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FCancellable_3B, completed, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FCancellable_3B, exception, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FCancellable_3B, lock, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FCancellable_3B, pollingAddress, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxNativeDispatcher_3B, 12, Lsun_2Fnio_2Ffs_2FUnixNativeDispatcher_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FNativeBuffer_24Deallocator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FNativeBuffer_24Deallocator_3B, address, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FPollingWatchService_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_241_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FPollingWatchService_3B, 56, Lsun_2Fnio_2Ffs_2FAbstractWatchService_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_3B, map, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_3B, scheduledExecutor, 48, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_3B, 101, Lsun_2Fnio_2Ffs_2FAbstractWatchKey_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_3B, entries, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_3B, events, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_3B, fileKey, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_3B, poller, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_3B, this_240, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_3B, tickCount, 96, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_3B, valid, 100, 1)
+__MRT_CLASS(Lcom_2Fsun_2Fnio_2Ffile_2FSensitivityWatchEventModifier_3B, 28, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Lcom_2Fsun_2Fnio_2Ffile_2FSensitivityWatchEventModifier_3B, sensitivity, 24, 4)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FPollingWatchService_242_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_242_3B, val_24eventSet, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_242_3B, val_24path, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_242_3B, val_24s, 40, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FPollingWatchService_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_243_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FPollingWatchService_24PollingWatchKey_241_3B, this_241, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_24UnixDirectoryIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_24UnixDirectoryIterator_3B, atEof, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_24UnixDirectoryIterator_3B, nextEntry, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_24UnixDirectoryIterator_3B, stream, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_24UnixDirectoryIterator_3B, this_240, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_3B, dir, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_3B, dp, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_3B, filter, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_3B, guard, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_3B, isClosed, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_3B, iterator, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixDirectoryStream_3B, streamLock, 56, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_24UnixAsBasicFileAttributes_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileAttributes_24UnixAsBasicFileAttributes_3B, attrs, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileStore_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileStore_241_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileStore_3B, 40, Ljava_2Fnio_2Ffile_2FFileStore_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileStore_3B, dev, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileStore_3B, entry, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileStore_3B, file, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileStore_24FeatureStatus_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystem_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_241_3B, val_24allowedList, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystem_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_242_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystem_243_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_243_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_243_3B, val_24pattern, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystem_24FileStoreIterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_24FileStoreIterator_3B, entries, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_24FileStoreIterator_3B, next, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystem_24FileStoreIterator_3B, this_240, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystem_24LookupService_241_3B, 12, Ljava_2Fnio_2Ffile_2Fattribute_2FUserPrincipalLookupService_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Faction_2FGetBooleanAction_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Faction_2FGetBooleanAction_3B, theProp, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Faction_2FGetIntegerAction_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Faction_2FGetIntegerAction_3B, defaultSet, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Faction_2FGetIntegerAction_3B, defaultVal, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Faction_2FGetIntegerAction_3B, theProp, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Faction_2FGetPropertyAction_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Faction_2FGetPropertyAction_3B, defaultVal, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Faction_2FGetPropertyAction_3B, theProp, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderConfig_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderConfig_241_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderConfig_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderConfig_242_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderConfig_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderConfig_243_3B, val_24value, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderList_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_241_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_241_3B, this_241, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_3B, 72, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_3B, firstService, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_3B, ids, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_3B, providerIndex, 40, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_3B, services, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_3B, this_240, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_24ServiceList_3B, type, 64, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertStoreHelper_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertStoreHelper_241_3B, val_24cl, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FCertStoreHelper_241_3B, val_24type, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_24PKIXCertComparator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_24PKIXCertComparator_3B, certSkidSelector, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_24PKIXCertComparator_3B, trustedSubjectDNs, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_3B, 104, Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBuilder_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_3B, caSelector, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_3B, caTargetSelector, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_3B, eeSelector, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_3B, searchAllCertStores, 64, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_3B, trustAnchor, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_3B, trustAnchors, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_3B, trustedCerts, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardBuilder_3B, trustedSubjectDNs, 96, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdaptableX509CertSelector_3B, 232, Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdaptableX509CertSelector_3B, endDate, 200, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdaptableX509CertSelector_3B, serial, 208, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdaptableX509CertSelector_3B, ski, 216, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAdaptableX509CertSelector_3B, startDate, 224, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardState_3B, 52, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardState_3B, cert, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardState_3B, forwardCheckers, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardState_3B, init, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardState_3B, issuerDN, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardState_3B, keyParamsNeededFlag, 13, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardState_3B, subjectNamesTraversed, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FForwardState_3B, traversedCACerts, 48, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24CertStoreComparator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIXCertPathValidator_3B, 12, Ljava_2Fsecurity_2Fcert_2FCertPathValidatorSpi_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FPKIXCertPathValidatorResult_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXCertPathValidatorResult_3B, policyTree, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXCertPathValidatorResult_3B, subjectPublicKey, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXCertPathValidatorResult_3B, trustAnchor, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, isImmutable, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, mChildren, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, mCriticalityIndicator, 13, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, mDepth, 24, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, mExpectedPolicySet, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, mOriginalExpectedPolicySet, 14, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, mParent, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, mQualifierSet, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyNodeImpl_3B, mValidPolicy, 56, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilder_3B, 56, Ljava_2Fsecurity_2Fcert_2FCertPathBuilderSpi_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilder_3B, buildParams, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilder_3B, cf, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilder_3B, finalPublicKey, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilder_3B, pathCompleted, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilder_3B, policyTreeResult, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilder_3B, trustAnchor, 48, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FPKIXCertPathBuilderResult_3B, 48, Ljava_2Fsecurity_2Fcert_2FPKIXCertPathValidatorResult_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXCertPathBuilderResult_3B, certPath, 40, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_24UCS_3B, 48, Ljava_2Fsecurity_2Fcert_2FCertStore_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, 88, Ljava_2Fsecurity_2Fcert_2FCertStoreSpi_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, certs, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, crl, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, factory, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, lastChecked, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, lastModified, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, ldap, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, ldapCertStore, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, ldapHelper, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, ldapPath, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_3B, uri, 80, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_24URICertStoreParameters_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_24URICertStoreParameters_3B, hashCode, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FURICertStore_24URICertStoreParameters_3B, uri, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FAbstractAlgorithmConstraints_241_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FAbstractAlgorithmConstraints_241_3B, val_24propertyName, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FAnchorCertificates_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24KeySizeConstraint_3B, 44, Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraint_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24KeySizeConstraint_3B, maxSize, 32, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24KeySizeConstraint_3B, minSize, 36, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24KeySizeConstraint_3B, prohibitedSize, 40, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraint_24Operator_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24jdkCAConstraint_3B, 32, Lsun_2Fsecurity_2Futil_2FDisabledAlgorithmConstraints_24Constraint_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FMemoryCache_24HardCacheEntry_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FMemoryCache_24HardCacheEntry_3B, expirationTime, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FMemoryCache_24HardCacheEntry_3B, key, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FMemoryCache_24HardCacheEntry_3B, value, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FMemoryCache_3B, 40, Lsun_2Fsecurity_2Futil_2FCache_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FMemoryCache_3B, cacheMap, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FMemoryCache_3B, lifetime, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FMemoryCache_3B, maxSize, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FMemoryCache_3B, queue, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FNullCache_3B, 12, Lsun_2Fsecurity_2Futil_2FCache_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FObjectIdentifier_24HugeOidNotSupportedByOldJDK_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FResourcesMgr_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FResourcesMgr_242_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FResourcesMgr_242_3B, val_24altBundleName, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FAVAComparator_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificateIssuerName_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateIssuerName_3B, dnName, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateIssuerName_3B, dnPrincipal, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCertificateSubjectName_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateSubjectName_3B, dnName, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCertificateSubjectName_3B, dnPrincipal, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FEDIPartyName_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FEDIPartyName_3B, assigner, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FEDIPartyName_3B, myhash, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FEDIPartyName_3B, party, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FOIDName_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FOIDName_3B, oid, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FOtherName_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FOtherName_3B, gni, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FOtherName_3B, myhash, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FOtherName_3B, name, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FOtherName_3B, nameValue, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FOtherName_3B, oid, 40, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FRFC822Name_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FRFC822Name_3B, name, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX400Address_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX400Address_3B, nameValue, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX500Name_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_24X509IssuerSerial_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_24X509IssuerSerial_3B, hashcode, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_24X509IssuerSerial_3B, issuer, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509CRLImpl_24X509IssuerSerial_3B, serial, 24, 8)
+__MRT_CLASS(Lsun_2Futil_2FResourceBundleEnumeration_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2FResourceBundleEnumeration_3B, enumeration, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2FResourceBundleEnumeration_3B, iterator, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2FResourceBundleEnumeration_3B, next, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2FResourceBundleEnumeration_3B, set, 40, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FUnicodeLocaleExtension_3B, 48, Lsun_2Futil_2Flocale_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FUnicodeLocaleExtension_3B, attributes, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FUnicodeLocaleExtension_3B, keywords, 40, 8)
+__MRT_CLASS(Lsun_2Futil_2Flogging_2FLoggingSupport_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flogging_2FLoggingSupport_242_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flogging_2FPlatformLogger_241_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Futil_2Flogging_2FPlatformLogger_24DefaultLoggerProxy_3B, 48, Lsun_2Futil_2Flogging_2FPlatformLogger_24LoggerProxy_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flogging_2FPlatformLogger_24DefaultLoggerProxy_3B, date, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flogging_2FPlatformLogger_24DefaultLoggerProxy_3B, effectiveLevel, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flogging_2FPlatformLogger_24DefaultLoggerProxy_3B, level, 40, 8)
+__MRT_CLASS(Lsun_2Futil_2Fresources_2FOpenListResourceBundle_3B, 72, Ljava_2Futil_2FResourceBundle_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fresources_2FOpenListResourceBundle_3B, keyset, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fresources_2FOpenListResourceBundle_3B, lookup, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCSCharacterIterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCSCharacterIterator_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCSCharacterIterator_3B, seq, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24WholeStringBreakIterator_3B, 36, Landroid_2Ficu_2Ftext_2FBreakIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCaseMapImpl_24WholeStringBreakIterator_3B, length, 32, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCharacterIteratorWrapper_3B, 24, Landroid_2Ficu_2Ftext_2FUCharacterIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCharacterIteratorWrapper_3B, iterator, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCurrencyData_24DefaultInfo_3B, 13, Landroid_2Ficu_2Fimpl_2FCurrencyData_24CurrencyDisplayInfo_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCurrencyData_24DefaultInfo_3B, fallback, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICULangDataTables_3B, 24, Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24ICUDataTables_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICULocaleService_24ICUResourceBundleFactory_3B, 32, Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKeyFactory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24ICUResourceBundleFactory_3B, bundleName, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICULocaleService_24SimpleLocaleKeyFactory_3B, 48, Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKeyFactory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24SimpleLocaleKeyFactory_3B, id, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24SimpleLocaleKeyFactory_3B, kind, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICULocaleService_24SimpleLocaleKeyFactory_3B, obj, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICURegionDataTables_3B, 24, Landroid_2Ficu_2Fimpl_2FLocaleDisplayNamesImpl_24ICUDataTables_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundle_243_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Array16_3B, 20, Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Array_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Array32_3B, 20, Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Array_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Table1632_3B, 40, Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Table_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Table16_3B, 40, Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Table_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Table32_3B, 40, Landroid_2Ficu_2Fimpl_2FICUResourceBundleReader_24Table_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FReplaceableUCharacterIterator_3B, 24, Landroid_2Ficu_2Ftext_2FUCharacterIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FReplaceableUCharacterIterator_3B, currentIndex, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FReplaceableUCharacterIterator_3B, replaceable, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FSimpleFilteredSentenceBreakIterator_3B, 64, Landroid_2Ficu_2Ftext_2FBreakIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FSimpleFilteredSentenceBreakIterator_3B, backwardsTrie, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FSimpleFilteredSentenceBreakIterator_3B, delegate, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FSimpleFilteredSentenceBreakIterator_3B, forwardsPartialTrie, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FSimpleFilteredSentenceBreakIterator_3B, text, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_3B, 32, Landroid_2Ficu_2Ftext_2FTimeZoneNames_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_3B, __locale, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTZDBTimeZoneNames_3B, __region, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FTimeZoneAdapter_3B, 32, Ljava_2Futil_2FTimeZone_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FTimeZoneAdapter_3B, zone, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharArrayIterator_3B, 32, Landroid_2Ficu_2Ftext_2FUCharacterIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharArrayIterator_3B, limit, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharArrayIterator_3B, pos, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharArrayIterator_3B, start, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharArrayIterator_3B, text, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterIteratorWrapper_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterIteratorWrapper_3B, iterator, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2414_3B, 48, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BiDiIntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2414_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2415_3B, 48, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24CombiningClassIntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2415_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2417_3B, 48, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BiDiIntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2417_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2418_3B, 48, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BiDiIntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2418_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2422_3B, 48, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24CombiningClassIntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2422_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2423_3B, 48, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24CombiningClassIntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2423_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2424_3B, 48, Landroid_2Ficu_2Fimpl_2FUCharacterProperty_24BiDiIntProperty_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FUCharacterProperty_2424_3B, this_240, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDIterCollationIterator_24State_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDIterCollationIterator_3B, 112, Landroid_2Ficu_2Fimpl_2Fcoll_2FIterCollationIterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDIterCollationIterator_3B, limit, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDIterCollationIterator_3B, nfcImpl, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDIterCollationIterator_3B, normalized, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDIterCollationIterator_3B, pos, 68, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDIterCollationIterator_3B, s, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDIterCollationIterator_3B, start, 96, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fcoll_2FFCDIterCollationIterator_3B, state, 104, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__da_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__da__DK_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__de_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__de__AT_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__de__DE_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__el_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__el__GR_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__en_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__en__CA_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__en__GB_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__en__US_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__es_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__es__MX_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__fr_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__fr__CA_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__fr__FR_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__it_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__it__IT_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__iw_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__iw__IL_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fdata_2FHolidayBundle__ja__JP_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FFixedUnitBuilder_3B, 32, Landroid_2Ficu_2Fimpl_2Fduration_2FPeriodBuilderImpl_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FFixedUnitBuilder_3B, unit, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FMultiUnitBuilder_3B, 28, Landroid_2Ficu_2Fimpl_2Fduration_2FPeriodBuilderImpl_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FMultiUnitBuilder_3B, nPeriods, 24, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FOneOrTwoUnitBuilder_3B, 24, Landroid_2Ficu_2Fimpl_2Fduration_2FPeriodBuilderImpl_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FSingleUnitBuilder_3B, 24, Landroid_2Ficu_2Fimpl_2Fduration_2FPeriodBuilderImpl_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24KeyInfoType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24SpecialType_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24SpecialType_3B, handler, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FKeyTypeData_24TypeInfoType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleObjectCache_24CacheEntry_3B, 64, Ljava_2Flang_2Fref_2FSoftReference_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleObjectCache_24CacheEntry_3B, __key, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleValidityChecker_24SpecialCase_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24CompactAndImmutablizer_3B, 40, Landroid_2Ficu_2Fimpl_2Flocale_2FXLocaleDistance_24IdMakerFull_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FCurrencySpacingEnabledModifier_3B, 88, Landroid_2Ficu_2Fimpl_2Fnumber_2FConstantMultiFieldModifier_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCurrencySpacingEnabledModifier_3B, afterPrefixInsert, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCurrencySpacingEnabledModifier_3B, afterPrefixUnicodeSet, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCurrencySpacingEnabledModifier_3B, beforeSuffixInsert, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCurrencySpacingEnabledModifier_3B, beforeSuffixUnicodeSet, 80, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FLocalizedNumberFormatterAsFormat_24Proxy_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FLocalizedNumberFormatterAsFormat_24Proxy_3B, languageTag, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FLocalizedNumberFormatterAsFormat_24Proxy_3B, skeleton, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FLocalizedNumberFormatterAsFormat_3B, 32, Ljava_2Ftext_2FFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FLocalizedNumberFormatterAsFormat_3B, formatter, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FLocalizedNumberFormatterAsFormat_3B, locale, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FInfinityMatcher_3B, 32, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FMultiplierParseHandler_3B, 24, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FValidationMatcher_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FMultiplierParseHandler_3B, multiplier, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FNanMatcher_3B, 32, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FPaddingMatcher_3B, 32, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FSymbolMatcher_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FRequireAffixValidator_3B, 12, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FValidationMatcher_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FRequireCurrencyValidator_3B, 12, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FValidationMatcher_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FRequireDecimalSeparatorValidator_3B, 13, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FValidationMatcher_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FRequireDecimalSeparatorValidator_3B, patternHasDecimalSeparator, 12, 1)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FRequireNumberValidator_3B, 12, Landroid_2Ficu_2Fimpl_2Fnumber_2Fparse_2FValidationMatcher_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FNumberSkeletonImpl_241_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FRounder_3B, 24, Landroid_2Ficu_2Fnumber_2FPrecision_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBreakTransliterator_24ReplaceableCharacterIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakTransliterator_24ReplaceableCharacterIterator_3B, begin, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakTransliterator_24ReplaceableCharacterIterator_3B, end, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakTransliterator_24ReplaceableCharacterIterator_3B, pos, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakTransliterator_24ReplaceableCharacterIterator_3B, text, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBurmeseBreakEngine_3B, 32, Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBurmeseBreakEngine_3B, fDictionary, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_24CharsetRecog__2022CN_3B, 24, Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_24CharsetRecog__2022CN_3B, escapeSequences, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_24CharsetRecog__2022JP_3B, 24, Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_24CharsetRecog__2022JP_3B, escapeSequences, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_24CharsetRecog__2022KR_3B, 24, Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCharsetRecog__2022_24CharsetRecog__2022KR_3B, escapeSequences, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_24CharsetRecog__UTF__16__BE_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_24CharsetRecog__UTF__16__LE_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_24CharsetRecog__UTF__32_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24CharsetRecog__big5_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24CharsetRecog__euc_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24CharsetRecog__gb__18030_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24CharsetRecog__sjis_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__1_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__2_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__5_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__6_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__7_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__8_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__9_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM420__ar_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM424__he_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__KOI8__R_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__windows__1251_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__windows__1256_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FChineseDateFormatSymbols_3B, 336, Landroid_2Ficu_2Ftext_2FDateFormatSymbols_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FChineseDateFormatSymbols_3B, isLeapMonth, 328, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCjkBreakEngine_3B, 32, Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCjkBreakEngine_3B, fDictionary, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollatorServiceShim_241CFactory_3B, 40, Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKeyFactory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollatorServiceShim_241CFactory_3B, delegate, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollatorServiceShim_241CFactory_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateFormatSymbols_24CapitalizationContextUsage_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDateTimePatternGenerator_24DTPGflags_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDecimalFormatSymbols_241_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FKhmerBreakEngine_3B, 32, Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FKhmerBreakEngine_3B, fDictionary, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FLaoBreakEngine_3B, 32, Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FLaoBreakEngine_3B, fDictionary, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMeasureFormat_24FormatWidth_3B, 48, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24FormatWidth_3B, currencyWidth, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24FormatWidth_3B, listFormatterStyle, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24FormatWidth_3B, unitWidth, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMeasureFormat_24MeasureProxy_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24MeasureProxy_3B, formatWidth, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24MeasureProxy_3B, keyValues, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24MeasureProxy_3B, locale, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24MeasureProxy_3B, numberFormat, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_24MeasureProxy_3B, subClass, 12, 4)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_3B, 136, Landroid_2Ficu_2Ftext_2FMeasureFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_3B, format, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_3B, isReady, 104, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_3B, locale, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_3B, pluralRules, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_3B, style, 108, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FTimeUnitFormat_3B, timeUnitToCountToPatterns, 128, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMeasureFormat_3B, 96, Landroid_2Ficu_2Ftext_2FUFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_3B, formatWidth, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_3B, formatter1, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_3B, formatter2, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_3B, formatter3, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_3B, numberFormat, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_3B, numberFormatter, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_3B, numericFormatters, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMeasureFormat_3B, rules, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24TextNode_3B, 32, Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24MessageContentsNode_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FMessagePatternUtil_24TextNode_3B, text, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberFormatServiceShim_24NFFactory_3B, 32, Landroid_2Ficu_2Fimpl_2FICULocaleService_24LocaleKeyFactory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormatServiceShim_24NFFactory_3B, delegate, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberingSystem_241_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberingSystem_242_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24BinaryConstraint_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24BinaryConstraint_3B, a, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24BinaryConstraint_3B, b, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24RangeConstraint_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24RangeConstraint_3B, inRange, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24RangeConstraint_3B, integersOnly, 13, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24RangeConstraint_3B, lowerBound, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24RangeConstraint_3B, mod, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24RangeConstraint_3B, operand, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24RangeConstraint_3B, range__list, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FPluralRules_24RangeConstraint_3B, upperBound, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24Cache_241_3B, 32, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRelativeDateTimeFormatter_24Cache_241_3B, this_240, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSelectFormat_3B, 32, Ljava_2Ftext_2FFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSelectFormat_3B, msgPattern, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FSelectFormat_3B, pattern, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FSimpleDateFormat_24ContextValue_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringCharacterIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringCharacterIterator_3B, begin, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringCharacterIterator_3B, end, 16, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringCharacterIterator_3B, pos, 20, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringCharacterIterator_3B, text, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FThaiBreakEngine_3B, 32, Landroid_2Ficu_2Ftext_2FDictionaryBreakEngine_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FThaiBreakEngine_3B, fDictionary, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneFormat_24ParseOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FTimeZoneNames_24DefaultTimeZoneNames_3B, 12, Landroid_2Ficu_2Ftext_2FTimeZoneNames_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCECalendar_3B, 128, Landroid_2Ficu_2Futil_2FCalendar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FChineseCalendar_3B, 168, Landroid_2Ficu_2Futil_2FCalendar_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FChineseCalendar_3B, astro, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FChineseCalendar_3B, epochYear, 136, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FChineseCalendar_3B, isLeapYear, 140, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FChineseCalendar_3B, newYearCache, 144, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FChineseCalendar_3B, winterSolsticeCache, 152, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FChineseCalendar_3B, zoneAstro, 160, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FEasterHoliday_3B, 32, Landroid_2Ficu_2Futil_2FHoliday_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, 96, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, breakIterators, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, calendar, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, collator, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, currency, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, dateFormats, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, frozen, 12, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, implicitLocales, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, locales, 64, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, numberFormats, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, territory, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FGlobalizationPreferences_3B, timezone, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FHebrewCalendar_3B, 128, Landroid_2Ficu_2Futil_2FCalendar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FHebrewHoliday_3B, 32, Landroid_2Ficu_2Futil_2FHoliday_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FIndianCalendar_3B, 128, Landroid_2Ficu_2Futil_2FCalendar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FIslamicCalendar_24CalculationType_3B, 32, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FIslamicCalendar_24CalculationType_3B, bcpType, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FIslamicCalendar_3B, 137, Landroid_2Ficu_2Futil_2FCalendar_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FIslamicCalendar_3B, cType, 128, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FIslamicCalendar_3B, civil, 136, 1)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FMeasureUnit_24MeasureUnitProxy_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMeasureUnit_24MeasureUnitProxy_3B, subType, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FMeasureUnit_24MeasureUnitProxy_3B, type, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FNoUnit_3B, 32, Landroid_2Ficu_2Futil_2FMeasureUnit_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FPersianCalendar_3B, 128, Landroid_2Ficu_2Futil_2FCalendar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FSimpleHoliday_3B, 32, Landroid_2Ficu_2Futil_2FHoliday_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24BranchHeadNode_3B, 40, Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ValueNode_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24BranchHeadNode_3B, length, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24BranchHeadNode_3B, next, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24DynamicBranchNode_3B, 40, Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ValueNode_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24DynamicBranchNode_3B, chars, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24DynamicBranchNode_3B, equal, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24IntermediateValueNode_3B, 32, Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ValueNode_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24IntermediateValueNode_3B, next, 24, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24LinearMatchNode_3B, 56, Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ValueNode_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24LinearMatchNode_3B, hash, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24LinearMatchNode_3B, length, 28, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24LinearMatchNode_3B, next, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24LinearMatchNode_3B, stringOffset, 40, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24LinearMatchNode_3B, strings, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ListBranchNode_3B, 56, Landroid_2Ficu_2Futil_2FStringTrieBuilder_24BranchNode_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ListBranchNode_3B, equal, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ListBranchNode_3B, length, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ListBranchNode_3B, units, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24ListBranchNode_3B, values, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24SplitBranchNode_3B, 42, Landroid_2Ficu_2Futil_2FStringTrieBuilder_24BranchNode_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24SplitBranchNode_3B, greaterOrEqual, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24SplitBranchNode_3B, lessThan, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FStringTrieBuilder_24SplitBranchNode_3B, unit, 40, 2)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FULocale_242_3B, 24, Landroid_2Ficu_2Fimpl_2FSoftCache_3B)
+__MRT_CLASS(Landroid_2Fsystem_2FNetlinkSocketAddress_3B, 20, Ljava_2Fnet_2FSocketAddress_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FNetlinkSocketAddress_3B, nlGroupsMask, 12, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FNetlinkSocketAddress_3B, nlPortId, 16, 4)
+__MRT_CLASS(Landroid_2Fsystem_2FPacketSocketAddress_3B, 30, Ljava_2Fnet_2FSocketAddress_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FPacketSocketAddress_3B, sll__addr, 16, 8)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FPacketSocketAddress_3B, sll__hatype, 12, 2)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FPacketSocketAddress_3B, sll__ifindex, 24, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FPacketSocketAddress_3B, sll__pkttype, 14, 1)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FPacketSocketAddress_3B, sll__protocol, 28, 2)
+__MRT_CLASS(Landroid_2Fsystem_2FUnixSocketAddress_3B, 24, Ljava_2Fnet_2FSocketAddress_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FUnixSocketAddress_3B, sun__path, 16, 8)
+__MRT_CLASS(Lcom_2Fsun_2Fnet_2Fssl_2Finternal_2Fssl_2FX509ExtendedTrustManager_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lcom_2Fsun_2Fnio_2Ffile_2FExtendedCopyOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lcom_2Fsun_2Fnio_2Ffile_2FExtendedOpenOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lcom_2Fsun_2Fnio_2Ffile_2FExtendedWatchEventModifier_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lcom_2Fsun_2Fsecurity_2Fcert_2Finternal_2Fx509_2FX509V1CertImpl_3B, 24, Ljavax_2Fsecurity_2Fcert_2FX509Certificate_3B)
+__MRT_CLASS_FIELD(Lcom_2Fsun_2Fsecurity_2Fcert_2Finternal_2Fx509_2FX509V1CertImpl_3B, wrappedCert, 16, 8)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDexClassLoader_3B, 72, Ldalvik_2Fsystem_2FBaseDexClassLoader_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FInMemoryDexClassLoader_3B, 72, Ldalvik_2Fsystem_2FBaseDexClassLoader_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FPathClassLoader_3B, 72, Ldalvik_2Fsystem_2FBaseDexClassLoader_3B)
+__MRT_CLASS(Ljava_2Fawt_2Ffont_2FTextAttribute_3B, 24, Ljava_2Ftext_2FAttributedCharacterIterator_24Attribute_3B)
+__MRT_CLASS(Ljava_2Flang_2FFloat_3B, 16, Ljava_2Flang_2FNumber_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FFloat_3B, value, 12, 4)
+__MRT_CLASS(Ljava_2Fbeans_2FPropertyChangeListenerProxy_3B, 32, Ljava_2Futil_2FEventListenerProxy_3B)
+__MRT_CLASS_FIELD(Ljava_2Fbeans_2FPropertyChangeListenerProxy_3B, propertyName, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FDeleteOnExitHook_241_3B, 176, Ljava_2Flang_2FThread_3B)
+__MRT_CLASS(Ljava_2Fio_2FFilePermission_3B, 24, Ljava_2Fsecurity_2FPermission_3B)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_24FieldReflectorKey_3B, 64, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflectorKey_3B, hash, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflectorKey_3B, nullClass, 52, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24FieldReflectorKey_3B, sigs, 56, 8)
+__MRT_CLASS(Ljava_2Fio_2FObjectStreamClass_24WeakClassKey_3B, 52, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FObjectStreamClass_24WeakClassKey_3B, hash, 48, 4)
+__MRT_CLASS(Ljava_2Fio_2FRandomAccessFile_3B, 80, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, channel, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, closeLock, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, closed, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, fd, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, flushAfterWrite, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, guard, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, ioTracker, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, mode, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, path, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, rw, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FRandomAccessFile_3B, scratch, 72, 8)
+__MRT_CLASS(Ljava_2Flang_2FCharacter_24UnicodeScript_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Flang_2FDaemons_24FinalizerDaemon_3B, 56, Ljava_2Flang_2FDaemons_24Daemon_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDaemons_24FinalizerDaemon_3B, finalizingObject, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDaemons_24FinalizerDaemon_3B, progressCounter, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDaemons_24FinalizerDaemon_3B, queue, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2FDaemons_24FinalizerWatchdogDaemon_3B, 41, Ljava_2Flang_2FDaemons_24Daemon_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDaemons_24FinalizerWatchdogDaemon_3B, finalizerTimeoutMs, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FDaemons_24FinalizerWatchdogDaemon_3B, needToWork, 40, 1)
+__MRT_CLASS(Ljava_2Flang_2FDaemons_24HeapTaskDaemon_3B, 32, Ljava_2Flang_2FDaemons_24Daemon_3B)
+__MRT_CLASS(Ljava_2Flang_2FDaemons_24ReferenceQueueDaemon_3B, 32, Ljava_2Flang_2FDaemons_24Daemon_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessEnvironment_24StringEnvironment_3B, 40, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FProcessEnvironment_24StringEnvironment_3B, m, 32, 8)
+__MRT_CLASS(Ljava_2Flang_2FThread_24WeakClassKey_3B, 52, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FThread_24WeakClassKey_3B, hash, 48, 4)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FMethodType_24ConcurrentWeakInternSet_24WeakEntry_3B, 52, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FMethodType_24ConcurrentWeakInternSet_24WeakEntry_3B, hashcode, 48, 4)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24AlwaysThrow_3B, 56, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24AlwaysThrow_3B, exceptionType, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24BindTo_3B, 72, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24BindTo_3B, delegate, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24BindTo_3B, range, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24BindTo_3B, receiver, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24CatchException_3B, 80, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CatchException_3B, exType, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CatchException_3B, handler, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CatchException_3B, handlerArgsRange, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CatchException_3B, target, 72, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24CollectArguments_3B, 104, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CollectArguments_3B, collector, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CollectArguments_3B, collectorRange, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CollectArguments_3B, pos, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CollectArguments_3B, range1, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CollectArguments_3B, range2, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CollectArguments_3B, referencesOffset, 68, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CollectArguments_3B, stackFrameOffset, 88, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24CollectArguments_3B, target, 96, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24Collector_3B, 80, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Collector_3B, arrayOffset, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Collector_3B, arrayTypeChar, 52, 2)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Collector_3B, copyRange, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Collector_3B, numArrayArgs, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Collector_3B, target, 72, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24Constant_3B, 90, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Constant_3B, asDouble, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Constant_3B, asFloat, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Constant_3B, asInt, 60, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Constant_3B, asLong, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Constant_3B, asReference, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Constant_3B, type, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Constant_3B, typeChar, 88, 2)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24Construct_3B, 64, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Construct_3B, callerRange, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Construct_3B, constructorHandle, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24DropArguments_3B, 72, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24DropArguments_3B, delegate, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24DropArguments_3B, range1, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24DropArguments_3B, range2, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24ExplicitCastArguments_3B, 56, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24ExplicitCastArguments_3B, target, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24FilterArguments_3B, 72, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FilterArguments_3B, filters, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FilterArguments_3B, pos, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FilterArguments_3B, target, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24FilterReturnValue_3B, 72, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FilterReturnValue_3B, allArgs, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FilterReturnValue_3B, filter, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FilterReturnValue_3B, target, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24FoldArguments_3B, 88, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FoldArguments_3B, combiner, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FoldArguments_3B, combinerArgs, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FoldArguments_3B, referencesOffset, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FoldArguments_3B, stackFrameOffset, 68, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FoldArguments_3B, target, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24FoldArguments_3B, targetArgs, 80, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24GuardWithTest_3B, 80, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24GuardWithTest_3B, fallback, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24GuardWithTest_3B, target, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24GuardWithTest_3B, test, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24GuardWithTest_3B, testArgsRange, 72, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24InsertArguments_3B, 88, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24InsertArguments_3B, pos, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24InsertArguments_3B, range1, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24InsertArguments_3B, range2, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24InsertArguments_3B, target, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24InsertArguments_3B, values, 80, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24Invoker_3B, 72, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Invoker_3B, copyRange, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Invoker_3B, isExactInvoker, 56, 1)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Invoker_3B, targetType, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24PermuteArguments_3B, 64, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24PermuteArguments_3B, reorder, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24PermuteArguments_3B, target, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24ReferenceArrayElementGetter_3B, 56, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24ReferenceArrayElementGetter_3B, arrayClass, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24ReferenceArrayElementSetter_3B, 56, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24ReferenceArrayElementSetter_3B, arrayClass, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24ReferenceIdentity_3B, 56, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24ReferenceIdentity_3B, type, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24Spreader_3B, 80, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Spreader_3B, arrayOffset, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Spreader_3B, arrayTypeChar, 52, 2)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Spreader_3B, copyRange, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Spreader_3B, numArrayArgs, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24Spreader_3B, target, 72, 8)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FTransformers_24VarargsCollector_3B, 56, Ljava_2Flang_2Finvoke_2FTransformers_24Transformer_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Finvoke_2FTransformers_24VarargsCollector_3B, target, 48, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FProxy_24Key1_3B, 52, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FProxy_24Key1_3B, hash, 48, 4)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FProxy_24Key2_3B, 64, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FProxy_24Key2_3B, hash, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FProxy_24Key2_3B, ref2, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FWeakCache_24CacheKey_3B, 52, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_24CacheKey_3B, hash, 48, 4)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FWeakCache_24CacheValue_3B, 52, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_24CacheValue_3B, hash, 48, 4)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FWeakCache_24LookupValue_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FWeakCache_24LookupValue_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Fnet_2FAbstractPlainDatagramSocketImpl_3B, 64, Ljava_2Fnet_2FDatagramSocketImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainDatagramSocketImpl_3B, connected, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainDatagramSocketImpl_3B, connectedAddress, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainDatagramSocketImpl_3B, connectedPort, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainDatagramSocketImpl_3B, guard, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainDatagramSocketImpl_3B, timeout, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FAbstractPlainDatagramSocketImpl_3B, trafficClass, 60, 4)
+__MRT_CLASS(Ljava_2Fnet_2FStandardProtocolFamily_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2FByteBufferAsCharBuffer_3B, 80, Ljava_2Fnio_2FCharBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsCharBuffer_3B, bb, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsCharBuffer_3B, offset, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsCharBuffer_3B, order, 72, 8)
+__MRT_CLASS(Ljava_2Fnio_2FByteBufferAsDoubleBuffer_3B, 80, Ljava_2Fnio_2FDoubleBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsDoubleBuffer_3B, bb, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsDoubleBuffer_3B, offset, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsDoubleBuffer_3B, order, 72, 8)
+__MRT_CLASS(Ljava_2Fnio_2FByteBufferAsFloatBuffer_3B, 80, Ljava_2Fnio_2FFloatBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsFloatBuffer_3B, bb, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsFloatBuffer_3B, offset, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsFloatBuffer_3B, order, 72, 8)
+__MRT_CLASS(Ljava_2Fnio_2FByteBufferAsIntBuffer_3B, 80, Ljava_2Fnio_2FIntBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsIntBuffer_3B, bb, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsIntBuffer_3B, offset, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsIntBuffer_3B, order, 72, 8)
+__MRT_CLASS(Ljava_2Fnio_2FByteBufferAsLongBuffer_3B, 80, Ljava_2Fnio_2FLongBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsLongBuffer_3B, bb, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsLongBuffer_3B, offset, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsLongBuffer_3B, order, 72, 8)
+__MRT_CLASS(Ljava_2Fnio_2FByteBufferAsShortBuffer_3B, 80, Ljava_2Fnio_2FShortBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsShortBuffer_3B, bb, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsShortBuffer_3B, offset, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FByteBufferAsShortBuffer_3B, order, 72, 8)
+__MRT_CLASS(Ljava_2Fnio_2FHeapByteBuffer_3B, 56, Ljava_2Fnio_2FByteBuffer_3B)
+__MRT_CLASS(Ljava_2Fnio_2FHeapCharBuffer_3B, 56, Ljava_2Fnio_2FCharBuffer_3B)
+__MRT_CLASS(Ljava_2Fnio_2FHeapDoubleBuffer_3B, 56, Ljava_2Fnio_2FDoubleBuffer_3B)
+__MRT_CLASS(Ljava_2Fnio_2FHeapFloatBuffer_3B, 56, Ljava_2Fnio_2FFloatBuffer_3B)
+__MRT_CLASS(Ljava_2Fnio_2FHeapIntBuffer_3B, 56, Ljava_2Fnio_2FIntBuffer_3B)
+__MRT_CLASS(Ljava_2Fnio_2FHeapLongBuffer_3B, 56, Ljava_2Fnio_2FLongBuffer_3B)
+__MRT_CLASS(Ljava_2Fnio_2FHeapShortBuffer_3B, 56, Ljava_2Fnio_2FShortBuffer_3B)
+__MRT_CLASS(Ljava_2Fnio_2FStringCharBuffer_3B, 64, Ljava_2Fnio_2FCharBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FStringCharBuffer_3B, str, 56, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharsetICU_3B, 48, Ljava_2Fnio_2Fcharset_2FCharset_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FCharsetICU_3B, icuCanonicalName, 40, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FStandardCopyOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FStandardOpenOption_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FPosixFilePermission_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FCryptoPrimitive_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyPairGenerator_24Delegate_3B, 80, Ljava_2Fsecurity_2FKeyPairGenerator_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPairGenerator_24Delegate_3B, initKeySize, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPairGenerator_24Delegate_3B, initParams, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPairGenerator_24Delegate_3B, initRandom, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPairGenerator_24Delegate_3B, initType, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPairGenerator_24Delegate_3B, lock, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPairGenerator_24Delegate_3B, serviceIterator, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FKeyPairGenerator_24Delegate_3B, spi, 72, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FMessageDigest_24Delegate_3B, 56, Ljava_2Fsecurity_2FMessageDigest_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FMessageDigest_24Delegate_3B, digestSpi, 48, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FPermissions_3B, 12, Ljava_2Fsecurity_2FPermissionCollection_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FPolicy_24UnsupportedEmptyCollection_3B, 12, Ljava_2Fsecurity_2FPermissionCollection_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FSignature_24Delegate_3B, 64, Ljava_2Fsecurity_2FSignature_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignature_24Delegate_3B, lock, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FSignature_24Delegate_3B, sigSpi, 56, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FUnresolvedPermission_3B, 24, Ljava_2Fsecurity_2FPermission_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FUnresolvedPermissionCollection_3B, 24, Ljava_2Fsecurity_2FPermissionCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FUnresolvedPermissionCollection_3B, perms, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathValidatorException_24BasicReason_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCollectionCertStoreParameters_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCollectionCertStoreParameters_3B, coll, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FLDAPCertStoreParameters_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FLDAPCertStoreParameters_3B, port, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FLDAPCertStoreParameters_3B, serverName, 16, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FPKIXReason_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FPKIXRevocationChecker_24Option_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FPKIXRevocationChecker_3B, 56, Ljava_2Fsecurity_2Fcert_2FPKIXCertPathChecker_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXRevocationChecker_3B, ocspExtensions, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXRevocationChecker_3B, ocspResponder, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXRevocationChecker_3B, ocspResponderCert, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXRevocationChecker_3B, ocspResponses, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FPKIXRevocationChecker_3B, options, 48, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FRSAMultiPrimePrivateCrtKeySpec_3B, 88, Ljava_2Fsecurity_2Fspec_2FRSAPrivateKeySpec_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAMultiPrimePrivateCrtKeySpec_3B, crtCoefficient, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAMultiPrimePrivateCrtKeySpec_3B, otherPrimeInfo, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAMultiPrimePrivateCrtKeySpec_3B, primeExponentP, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAMultiPrimePrivateCrtKeySpec_3B, primeExponentQ, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAMultiPrimePrivateCrtKeySpec_3B, primeP, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAMultiPrimePrivateCrtKeySpec_3B, primeQ, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAMultiPrimePrivateCrtKeySpec_3B, publicExponent, 80, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FRSAPrivateCrtKeySpec_3B, 80, Ljava_2Fsecurity_2Fspec_2FRSAPrivateKeySpec_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPrivateCrtKeySpec_3B, crtCoefficient, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPrivateCrtKeySpec_3B, primeExponentP, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPrivateCrtKeySpec_3B, primeExponentQ, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPrivateCrtKeySpec_3B, primeP, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPrivateCrtKeySpec_3B, primeQ, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fspec_2FRSAPrivateCrtKeySpec_3B, publicExponent, 72, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FX509EncodedKeySpec_3B, 24, Ljava_2Fsecurity_2Fspec_2FEncodedKeySpec_3B)
+__MRT_CLASS(Ljava_2Fsql_2FClientInfoStatus_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftext_2FAttributedString_24AttributeMap_3B, 56, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributeMap_3B, beginIndex, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributeMap_3B, endIndex, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributeMap_3B, runIndex, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributeMap_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Ftext_2FIcuIteratorWrapper_3B, 24, Ljava_2Ftext_2FBreakIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FIcuIteratorWrapper_3B, wrapped, 16, 8)
+__MRT_CLASS(Ljava_2Ftext_2FRuleBasedCollator_3B, 24, Ljava_2Ftext_2FCollator_3B)
+__MRT_CLASS(Ljava_2Ftext_2FStringCharacterIterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FStringCharacterIterator_3B, begin, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FStringCharacterIterator_3B, end, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FStringCharacterIterator_3B, pos, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FStringCharacterIterator_3B, text, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2FSer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FSer_3B, object, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FSer_3B, type, 12, 1)
+__MRT_CLASS(Ljava_2Ftime_2FYear_3B, 16, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FYear_3B, year, 12, 4)
+__MRT_CLASS(Ljava_2Ftime_2FYearMonth_3B, 20, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FYearMonth_3B, month, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FYearMonth_3B, year, 16, 4)
+__MRT_CLASS(Ljava_2Ftime_2FZoneRegion_3B, 32, Ljava_2Ftime_2FZoneId_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FZoneRegion_3B, id, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2FZoneRegion_3B, rules, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FChronoPeriodImpl_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronoPeriodImpl_3B, chrono, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronoPeriodImpl_3B, days, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronoPeriodImpl_3B, months, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronoPeriodImpl_3B, years, 28, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FHijrahEra_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FJapaneseEra_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FJapaneseEra_3B, eraValue, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FJapaneseEra_3B, since, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FMinguoEra_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FSer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FSer_3B, object, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FSer_3B, type, 12, 1)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FThaiBuddhistEra_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_24ClassicFormat_3B, 32, Ljava_2Ftext_2FFormat_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_24ClassicFormat_3B, formatter, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatter_24ClassicFormat_3B, parseType, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_24LENIENT_3B, 48, Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24PrefixTree_24CI_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24SettingsParser_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ZoneTextPrinterParser_3B, 64, Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ZoneIdPrinterParser_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ZoneTextPrinterParser_3B, cachedTree, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ZoneTextPrinterParser_3B, cachedTreeCI, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ZoneTextPrinterParser_3B, preferredZones, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fformat_2FDateTimeFormatterBuilder_24ZoneTextPrinterParser_3B, textStyle, 56, 8)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FChronoUnit_3B, 40, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FChronoUnit_3B, duration, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FChronoUnit_3B, name, 32, 8)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FIsoFields_24Field_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FIsoFields_24Unit_3B, 40, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FIsoFields_24Unit_3B, duration, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FIsoFields_24Unit_3B, name, 32, 8)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FJulianFields_24Field_3B, 64, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FJulianFields_24Field_3B, baseUnit, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FJulianFields_24Field_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FJulianFields_24Field_3B, offset, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FJulianFields_24Field_3B, range, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Ftemporal_2FJulianFields_24Field_3B, rangeUnit, 56, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FSer_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FSer_3B, object, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fzone_2FSer_3B, type, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedList_24gXIP1Db1__l1aVeW3UfOh4dLyESo_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedList_24gXIP1Db1__l1aVeW3UfOh4dLyESo_3B, f_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2F_2D_24_24Lambda_24Collections_24CheckedList_24gXIP1Db1__l1aVeW3UfOh4dLyESo_3B, f_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedList_3B, 48, Ljava_2Futil_2FCollections_24CheckedCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedList_3B, list, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FAbstractList_24ListItr_3B, 40, Ljava_2Futil_2FAbstractList_24Itr_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FAbstractList_24ListItr_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FArrayList_24ListItr_3B, 48, Ljava_2Futil_2FArrayList_24Itr_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24ListItr_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FArrayList_24SubList_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_241_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_241_3B, expectedModCount, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_241_3B, lastRet, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_241_3B, this_241, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_241_3B, val_24index, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_241_3B, val_24offset, 36, 4)
+__MRT_CLASS(Ljava_2Futil_2FArrayList_24SubList_3B, 48, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_3B, offset, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_3B, parent, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_3B, parentOffset, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_3B, size, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayList_24SubList_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedList_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedList_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedList_241_3B, val_24i, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedSortedMap_3B, 56, Ljava_2Futil_2FCollections_24CheckedMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedSortedMap_3B, sm, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24EmptyListIterator_3B, 12, Ljava_2Futil_2FCollections_24EmptyIterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24EmptyMap_3B, 32, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SingletonMap_3B, 72, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SingletonMap_3B, entrySet, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SingletonMap_3B, k, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SingletonMap_3B, keySet, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SingletonMap_3B, v, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SingletonMap_3B, values, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SynchronizedCollection_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedCollection_3B, c, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedCollection_3B, mutex, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SynchronizedSortedMap_3B, 64, Ljava_2Futil_2FCollections_24SynchronizedMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedSortedMap_3B, sm, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableList_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableList_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableList_241_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableList_241_3B, val_24index, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableList_3B, 32, Ljava_2Futil_2FCollections_24UnmodifiableCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableList_3B, list, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableSortedMap_3B, 56, Ljava_2Futil_2FCollections_24UnmodifiableMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableSortedMap_3B, sm, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FComparators_24NaturalOrderComparator_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_24KeyIterator_3B, 40, Ljava_2Futil_2FEnumMap_24EnumMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24KeyIterator_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_24ValueIterator_3B, 40, Ljava_2Futil_2FEnumMap_24EnumMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24ValueIterator_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24KeyIterator_3B, 56, Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24KeyIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24ValueIterator_3B, 56, Ljava_2Futil_2FIdentityHashMap_24IdentityHashMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24ValueIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FJapaneseImperialCalendar_3B, 112, Ljava_2Futil_2FCalendar_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJapaneseImperialCalendar_3B, cachedFixedDate, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJapaneseImperialCalendar_3B, jdate, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJapaneseImperialCalendar_3B, originalFields, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FJapaneseImperialCalendar_3B, zoneOffsets, 104, 8)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FLocalGregorianCalendar_24Date_3B, 112, Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FLocalGregorianCalendar_24Date_3B, gregorianYear, 108, 4)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FLocalGregorianCalendar_3B, 40, Lsun_2Futil_2Fcalendar_2FBaseCalendar_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FLocalGregorianCalendar_3B, eras, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FLocalGregorianCalendar_3B, name, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24BundleReference_3B, 64, Ljava_2Flang_2Fref_2FSoftReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FResourceBundle_24BundleReference_3B, cacheKey, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FResourceBundle_24NoFallbackControl_3B, 24, Ljava_2Futil_2FResourceBundle_24SingleFormatControl_3B)
+__MRT_CLASS(Ljava_2Futil_2FSimpleTimeZone_3B, 121, Ljava_2Futil_2FTimeZone_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, cacheEnd, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, cacheStart, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, cacheYear, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, dstSavings, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, endDay, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, endDayOfWeek, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, endMode, 60, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, endMonth, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, endTime, 68, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, endTimeMode, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, monthLength, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, rawOffset, 76, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, serialVersionOnStream, 88, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, startDay, 92, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, startDayOfWeek, 96, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, startMode, 100, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, startMonth, 104, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, startTime, 108, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, startTimeMode, 112, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, startYear, 116, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSimpleTimeZone_3B, useDaylight, 120, 1)
+__MRT_CLASS(Ljava_2Futil_2FSortedSet_241_3B, 56, Ljava_2Futil_2FSpliterators_24IteratorSpliterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSortedSet_241_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FSubList_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSubList_241_3B, i, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSubList_241_3B, this_240, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSubList_241_3B, val_24index, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2FSubList_3B, 32, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSubList_3B, l, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSubList_3B, offset, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSubList_3B, size, 28, 4)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24DescendingKeyIterator_3B, 48, Ljava_2Futil_2FTreeMap_24PrivateEntryIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24DescendingKeyIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24EntryIterator_3B, 48, Ljava_2Futil_2FTreeMap_24PrivateEntryIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24EntryIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24KeyIterator_3B, 48, Ljava_2Futil_2FTreeMap_24PrivateEntryIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24KeyIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24DescendingSubMapEntryIterator_3B, 56, Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24DescendingSubMapEntryIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24DescendingSubMapKeyIterator_3B, 56, Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24DescendingSubMapKeyIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapEntryIterator_3B, 56, Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapEntryIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapKeyIterator_3B, 56, Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24NavigableSubMap_24SubMapKeyIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24SubMap_3B, 64, Ljava_2Futil_2FAbstractMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24SubMap_3B, fromKey, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24SubMap_3B, fromStart, 40, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24SubMap_3B, this_240, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24SubMap_3B, toEnd, 41, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24SubMap_3B, toKey, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24ValueIterator_3B, 48, Ljava_2Futil_2FTreeMap_24PrivateEntryIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24ValueIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FVector_24ListItr_3B, 48, Ljava_2Futil_2FVector_24Itr_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FVector_24ListItr_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24EntryIterator_3B, 72, Ljava_2Futil_2FWeakHashMap_24HashIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24EntryIterator_3B, this_240, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24KeyIterator_3B, 72, Ljava_2Futil_2FWeakHashMap_24HashIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24KeyIterator_3B, this_240, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24ValueIterator_3B, 72, Ljava_2Futil_2FWeakHashMap_24HashIterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24ValueIterator_3B, this_240, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24AsyncRun_3B, 32, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24AsyncRun_3B, dep, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24AsyncRun_3B, fn, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24AsyncSupply_3B, 32, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24AsyncSupply_3B, dep, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24AsyncSupply_3B, fn, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24EntryIterator_3B, 80, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BaseIterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForwardingNode_3B, 48, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Node_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForwardingNode_3B, nextTable, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24KeyIterator_3B, 80, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BaseIterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReservationNode_3B, 40, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Node_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Segment_3B, 28, Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantLock_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Segment_3B, loadFactor, 24, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeBin_3B, 72, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Node_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeBin_3B, first, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeBin_3B, lockState, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeBin_3B, root, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeBin_3B, waiter, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeNode_3B, 80, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24Node_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeNode_3B, left, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeNode_3B, parent, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeNode_3B, prev, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeNode_3B, red, 64, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24TreeNode_3B, right, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ValueIterator_3B, 80, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BaseIterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24DescendingItr_3B, 56, Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24AbstractItr_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24DescendingItr_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24Itr_3B, 56, Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24AbstractItr_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentLinkedDeque_24Itr_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24EntryIterator_3B, 56, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Iter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24EntryIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24KeyIterator_3B, 56, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Iter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24KeyIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapEntryIterator_3B, 56, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapIter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapEntryIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapKeyIterator_3B, 56, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapIter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapKeyIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapValueIterator_3B, 56, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapIter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24SubMap_24SubMapValueIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24ValueIterator_3B, 56, Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24Iter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListMap_24ValueIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWIterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWIterator_3B, cursor, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWIterator_3B, snapshot, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWSubListIterator_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWSubListIterator_3B, it, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWSubListIterator_3B, offset, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWSubListIterator_3B, size, 24, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinPool_24EmptyTask_3B, 16, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24AdaptedCallable_3B, 32, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24AdaptedCallable_3B, callable, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24AdaptedCallable_3B, result, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24AdaptedRunnable_3B, 32, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24AdaptedRunnable_3B, result, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24AdaptedRunnable_3B, runnable, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24AdaptedRunnableAction_3B, 24, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24AdaptedRunnableAction_3B, runnable, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24RunnableExecuteAction_3B, 24, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FForkJoinTask_24RunnableExecuteAction_3B, runnable, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FFutureTask_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FFutureTask_3B, callable, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FFutureTask_3B, outcome, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FFutureTask_3B, runner, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FFutureTask_3B, state, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FFutureTask_3B, waiters, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24DescendingItr_3B, 56, Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24AbstractItr_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24DescendingItr_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24Itr_3B, 56, Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24AbstractItr_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FLinkedBlockingDeque_24Itr_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FRecursiveAction_3B, 16, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FRecursiveTask_3B, 24, Ljava_2Futil_2Fconcurrent_2FForkJoinTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FRecursiveTask_3B, result, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24FifoWaitQueue_3B, 12, Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24WaitQueue_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24LifoWaitQueue_3B, 12, Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_24WaitQueue_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_3B, 33, Ljava_2Futil_2FRandom_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_3B, initialized, 32, 1)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BinaryOperator_24V__WUclL0kAOZvMw9EtWtwAvmNJc_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BinaryOperator_24V__WUclL0kAOZvMw9EtWtwAvmNJc_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BinaryOperator_24WKN0kahVeFfmJEk__tKszY8tRayo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24BinaryOperator_24WKN0kahVeFfmJEk__tKszY8tRayo_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Ffunction_2F_2D_24_24Lambda_24UnaryOperator_24p7kKvUH5OpW1KFw__KNJNdNw8HUE_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierCodeSource_3B, 56, Ljava_2Fsecurity_2FCodeSource_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierCodeSource_3B, csdomain, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierCodeSource_3B, vcerts, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierCodeSource_3B, vlocation, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierCodeSource_3B, vsigners, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FConsoleHandler_3B, 88, Ljava_2Futil_2Flogging_2FStreamHandler_3B)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLogManager_24Cleaner_3B, 184, Ljava_2Flang_2FThread_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FLogManager_24Cleaner_3B, this_240, 176, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FSocketHandler_3B, 112, Ljava_2Futil_2Flogging_2FStreamHandler_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FSocketHandler_3B, host, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FSocketHandler_3B, port, 96, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Flogging_2FSocketHandler_3B, sock, 104, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FAbstractPreferences_24EventDispatchThread_3B, 176, Ljava_2Flang_2FThread_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FFileSystemPreferences_243_3B, 176, Ljava_2Flang_2FThread_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_240y__EMl863H__U7B4kxyGscB4vAag_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24Fu6GEjokQxdzbR0jNzU39_2DPLUqs_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24GYNZB08upNxJa3yuZVQ1065S1eU_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24GYNZB08upNxJa3yuZVQ1065S1eU_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24GoEBVVc1WwW27RacBqhtFczthrA_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24HtCSWMKsL2vCjP__AudE9j5Li4Q4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24KLie_2DyPxAsuZwFd2lh_2D9gJpGlzE_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24SMVdf7W0ks2OOmS3zJw7DHc_2DNhc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24TzSZZBK0laNSWMge__uuxANwkkMo_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24TzSZZBK0laNSWMge__uuxANwkkMo_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24ZKsdGxiJ4anQHtwhYmSwD0W3jAc_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24__Q0YP__0ibAqPtQetwby3vyMbjys_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24ad8ZNOGiSpsXDY_2DHtABmtE9E1UA_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24ad8ZNOGiSpsXDY_2DHtABmtE9E1UA_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24efY8VAGaEUr4IwuGz__Jkpfl5lH8_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24iab6bVO3ydceISRiUEq__MRHYzoU_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24jubWCCHaIIJ__0UWKVLWqWh9ZDdk_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24kXZFmh6iM6xf9lJWimhd2Ef6NEs_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24oMCfAR_2D__eVSty8GsYzK5sec1Kag_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24o__hw0Qu0KMLozTwiY9jr8AKG0__0_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24rc3oE9Q2XtMlukYSsVA6bDVPVLY_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24xWcI8qM0AfOYfxDSjg08D8ztBFg_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Collectors_24xWcI8qM0AfOYfxDSjg08D8ztBFg_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24IBZGhEgRy1ddKsqLtAJ_2DJIbQPE8_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24DoublePipeline_24IBZGhEgRy1ddKsqLtAJ_2DJIbQPE8_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24GF_2Ds38TgrG6hfxe____ZFdhGp_2DwPw_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24GF_2Ds38TgrG6hfxe____ZFdhGp_2DwPw_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_24gTDhYg7hsRI2br4NmAxtQnW5i6Y_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24IntPipeline_24gTDhYg7hsRI2br4NmAxtQnW5i6Y_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24KTexUmxMdHIv08L4oU8j9HXK__go_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_24_2DBxZA1c1Y79VaVw54W8s5K5ji__0_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24LongPipeline_24_2DBxZA1c1Y79VaVw54W8s5K5ji__0_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24Mo9_2DryI3XUGyoHfpnRL3BoFhaqY_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24O4iFzVwtlyKFZkWcnfXHIHbxaTY_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24R8aE88Z140TFfTli76Hdc3YzhU4_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24btpzqYSQDsLykCcQbI2__g5D3_2Dzs_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24btpzqYSQDsLykCcQbI2__g5D3_2Dzs_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24eeRvX3cGN3C3qCAoKtOxCHIW8Lo_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24i0Jl5dMkfWphZviqg6QdkkWPWRI_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ConcNode_24OfPrimitive_3B, 40, Ljava_2Futil_2Fstream_2FNodes_24AbstractConcNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ConcNode_3B, 40, Ljava_2Futil_2Fstream_2FNodes_24AbstractConcNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24EmptyNode_24OfRef_3B, 12, Ljava_2Futil_2Fstream_2FNodes_24EmptyNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_24OfPrimitive_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_24OfRef_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_2410_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2410_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2410_3B, val_24combiner, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2410_3B, val_24supplier, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_2410ReducingSink_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24Box_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2410ReducingSink_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2410ReducingSink_3B, val_24combiner, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2410ReducingSink_3B, val_24supplier, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_2411_3B, 40, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2411_3B, val_24identity, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2411_3B, val_24operator, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_2411ReducingSink_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2411ReducingSink_3B, state, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2411ReducingSink_3B, val_24identity, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2411ReducingSink_3B, val_24operator, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_2412_3B, 32, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2412_3B, val_24operator, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_2412ReducingSink_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2412ReducingSink_3B, empty, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2412ReducingSink_3B, state, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2412ReducingSink_3B, val_24operator, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_2413_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2413_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2413_3B, val_24combiner, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2413_3B, val_24supplier, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_2413ReducingSink_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24Box_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2413ReducingSink_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2413ReducingSink_3B, val_24combiner, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_2413ReducingSink_3B, val_24supplier, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_241_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_241_3B, val_24combiner, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_241_3B, val_24reducer, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_241_3B, val_24seed, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_241ReducingSink_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24Box_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_241ReducingSink_3B, val_24combiner, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_241ReducingSink_3B, val_24reducer, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_241ReducingSink_3B, val_24seed, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_242_3B, 32, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_242_3B, val_24operator, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_242ReducingSink_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_242ReducingSink_3B, empty, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_242ReducingSink_3B, state, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_242ReducingSink_3B, val_24operator, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_243_3B, 56, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_243_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_243_3B, val_24collector, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_243_3B, val_24combiner, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_243_3B, val_24supplier, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_243ReducingSink_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24Box_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_243ReducingSink_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_243ReducingSink_3B, val_24combiner, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_243ReducingSink_3B, val_24supplier, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_244_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_244_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_244_3B, val_24reducer, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_244_3B, val_24seedFactory, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_244ReducingSink_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24Box_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_244ReducingSink_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_244ReducingSink_3B, val_24reducer, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_244ReducingSink_3B, val_24seedFactory, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_245_3B, 40, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_245_3B, val_24identity, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_245_3B, val_24operator, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_245ReducingSink_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_245ReducingSink_3B, state, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_245ReducingSink_3B, val_24identity, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_245ReducingSink_3B, val_24operator, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_246_3B, 32, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_246_3B, val_24operator, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_246ReducingSink_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_246ReducingSink_3B, empty, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_246ReducingSink_3B, state, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_246ReducingSink_3B, val_24operator, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_247_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_247_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_247_3B, val_24combiner, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_247_3B, val_24supplier, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_247ReducingSink_3B, 48, Ljava_2Futil_2Fstream_2FReduceOps_24Box_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_247ReducingSink_3B, val_24accumulator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_247ReducingSink_3B, val_24combiner, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_247ReducingSink_3B, val_24supplier, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_248_3B, 40, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_248_3B, val_24identity, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_248_3B, val_24operator, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_248ReducingSink_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_248ReducingSink_3B, state, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_248ReducingSink_3B, val_24identity, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_248ReducingSink_3B, val_24operator, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_249_3B, 32, Ljava_2Futil_2Fstream_2FReduceOps_24ReduceOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_249_3B, val_24operator, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_249ReducingSink_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_249ReducingSink_3B, empty, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_249ReducingSink_3B, state, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_249ReducingSink_3B, val_24operator, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B, downstream, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfDouble_3B, 48, Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfInt_3B, 48, Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfLong_3B, 48, Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B, lastSpineElementFence, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B, lastSpineIndex, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B, splChunk, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B, splElementIndex, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B, splSpineIndex, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamOpFlag_3B, 48, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamOpFlag_3B, bitPosition, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamOpFlag_3B, clear, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamOpFlag_3B, maskTable, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamOpFlag_3B, preserve, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamOpFlag_3B, set, 44, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfDouble_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfPrimitive_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfDouble_3B, array, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfInt_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfPrimitive_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfInt_3B, array, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfLong_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfPrimitive_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24ArrayBuffer_24OfLong_3B, array, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_24OfPrimitive_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_24OfRef_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_24OfRef_3B, s, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_24OfPrimitive_3B, 56, Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfPrimitive_3B, 40, Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_24OfPrimitive_3B, 32, Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_24OfRef_3B, 32, Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24StreamBuilderImpl_3B, 32, Ljava_2Futil_2Fstream_2FStreams_24AbstractStreamBuilderImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24StreamBuilderImpl_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24StreamBuilderImpl_3B, first, 24, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FDefaultSSLServerSocketFactory_3B, 24, Ljavax_2Fnet_2Fssl_2FSSLServerSocketFactory_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FDefaultSSLServerSocketFactory_3B, reason, 16, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FDefaultSSLSocketFactory_3B, 24, Ljavax_2Fnet_2Fssl_2FSSLSocketFactory_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FDefaultSSLSocketFactory_3B, reason, 16, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FHttpsURLConnection_3B, 104, Ljava_2Fnet_2FHttpURLConnection_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FHttpsURLConnection_3B, hostnameVerifier, 88, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fnet_2Fssl_2FHttpsURLConnection_3B, sslSocketFactory, 96, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FX509ExtendedKeyManager_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FX509ExtendedTrustManager_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FPrivateCredentialPermission_3B, 24, Ljava_2Fsecurity_2FPermission_3B)
+__MRT_CLASS(Llibcore_2Ficu_2FCollationKeyICU_3B, 32, Ljava_2Ftext_2FCollationKey_3B)
+__MRT_CLASS_FIELD(Llibcore_2Ficu_2FCollationKeyICU_3B, key, 24, 8)
+__MRT_CLASS(Llibcore_2Finternal_2FJava9LanguageFeatures_241_3B, 32, Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicReference_3B)
+__MRT_CLASS_FIELD(Llibcore_2Finternal_2FJava9LanguageFeatures_241_3B, this_240, 24, 8)
+__MRT_CLASS(Llibcore_2Fio_2FBlockGuardOs_3B, 24, Llibcore_2Fio_2FForwardingOs_3B)
+__MRT_CLASS(Llibcore_2Fio_2FClassPathURLStreamHandler_24ClassPathURLConnection_3B, 120, Ljava_2Fnet_2FJarURLConnection_3B)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FClassPathURLStreamHandler_24ClassPathURLConnection_3B, closed, 80, 1)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FClassPathURLStreamHandler_24ClassPathURLConnection_3B, connectionJarFile, 88, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FClassPathURLStreamHandler_24ClassPathURLConnection_3B, jarEntry, 96, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FClassPathURLStreamHandler_24ClassPathURLConnection_3B, jarInput, 104, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FClassPathURLStreamHandler_24ClassPathURLConnection_3B, this_240, 112, 8)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FClassPathURLStreamHandler_24ClassPathURLConnection_3B, useCachedJarFile, 81, 1)
+__MRT_CLASS(Llibcore_2Freflect_2FAnnotationMember_24DefaultValues_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Llibcore_2Freflect_2FGenericArrayTypeImpl_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FGenericArrayTypeImpl_3B, componentType, 16, 8)
+__MRT_CLASS(Llibcore_2Freflect_2FParameterizedTypeImpl_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FParameterizedTypeImpl_3B, args, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FParameterizedTypeImpl_3B, loader, 24, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FParameterizedTypeImpl_3B, ownerType0, 32, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FParameterizedTypeImpl_3B, ownerTypeRes, 40, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FParameterizedTypeImpl_3B, rawType, 48, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FParameterizedTypeImpl_3B, rawTypeName, 56, 8)
+__MRT_CLASS(Llibcore_2Freflect_2FWildcardTypeImpl_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FWildcardTypeImpl_3B, extendsBound, 16, 8)
+__MRT_CLASS_FIELD(Llibcore_2Freflect_2FWildcardTypeImpl_3B, superBound, 24, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24ClonedAttributes_3B, 32, Lorg_2Fapache_2Fharmony_2Fxml_2FExpatAttributes_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24ClonedAttributes_3B, length, 12, 4)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24ClonedAttributes_3B, parserPointer, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24ClonedAttributes_3B, pointer, 24, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24CurrentAttributes_3B, 24, Lorg_2Fapache_2Fharmony_2Fxml_2FExpatAttributes_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24CurrentAttributes_3B, this_240, 16, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_2410_3B, 12, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_2411_3B, 12, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_2412_3B, 12, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_241_3B, 12, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_242_3B, 12, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_243_3B, 12, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_244_3B, 12, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_246_3B, 12, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_247_3B, 12, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDOMConfigurationImpl_24BooleanParameter_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FEntityImpl_3B, 48, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FEntityImpl_3B, notationName, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FEntityImpl_3B, publicID, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FEntityImpl_3B, systemID, 40, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fext_2FAttributes2Impl_3B, 40, Lorg_2Fxml_2Fsax_2Fhelpers_2FAttributesImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fext_2FAttributes2Impl_3B, declared, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fext_2FAttributes2Impl_3B, specified, 32, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fext_2FDefaultHandler2_3B, 12, Lorg_2Fxml_2Fsax_2Fhelpers_2FDefaultHandler_3B)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fext_2FLocator2Impl_3B, 56, Lorg_2Fxml_2Fsax_2Fhelpers_2FLocatorImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fext_2FLocator2Impl_3B, encoding, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fext_2FLocator2Impl_3B, version, 48, 8)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLFilterImpl_3B, 64, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLFilterImpl_3B, contentHandler, 16, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLFilterImpl_3B, dtdHandler, 24, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLFilterImpl_3B, entityResolver, 32, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLFilterImpl_3B, errorHandler, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLFilterImpl_3B, locator, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fxml_2Fsax_2Fhelpers_2FXMLFilterImpl_3B, parent, 56, 8)
+__MRT_CLASS(Lsun_2Finvoke_2Futil_2FWrapper_3B, 80, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS_FIELD(Lsun_2Finvoke_2Futil_2FWrapper_3B, basicTypeChar, 24, 2)
+__MRT_CLASS_FIELD(Lsun_2Finvoke_2Futil_2FWrapper_3B, emptyArray, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Finvoke_2Futil_2FWrapper_3B, format, 28, 4)
+__MRT_CLASS_FIELD(Lsun_2Finvoke_2Futil_2FWrapper_3B, primitiveSimpleName, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Finvoke_2Futil_2FWrapper_3B, primitiveType, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Finvoke_2Futil_2FWrapper_3B, wrapperSimpleName, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Finvoke_2Futil_2FWrapper_3B, wrapperType, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Finvoke_2Futil_2FWrapper_3B, zero, 72, 8)
+__MRT_CLASS(Ljava_2Flang_2FClassCastException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24FtpFileIterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24FtpFileIterator_3B, eof, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24FtpFileIterator_3B, fparser, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24FtpFileIterator_3B, in, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24FtpFileIterator_3B, nextFile, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2Fimpl_2FFtpClient_24FtpFileIterator_3B, this_240, 40, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, 144, Lsun_2Fnet_2Fwww_2FURLConnection_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, contentType, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, exists, 80, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, file, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, filename, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, files, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, initializedHeaders, 81, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, is, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, isDirectory, 82, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, lastModified, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, length, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Ffile_2FFileURLConnection_3B, permission, 136, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_3B, 136, Ljava_2Fnet_2FJarURLConnection_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_3B, contentType, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_3B, entryName, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_3B, jarEntry, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_3B, jarFile, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_3B, jarFileURL, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_3B, jarFileURLConnection, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_3B, permission, 128, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FDatagramSocketAdaptor_241_3B, 32, Ljava_2Fnet_2FDatagramSocketImpl_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileDescriptorHolderSocketImpl_3B, 56, Ljava_2Fnet_2FSocketImpl_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileDispatcherImpl_3B, 12, Lsun_2Fnio_2Fch_2FFileDispatcher_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_24Type4_3B, 76, Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_24Type4_3B, groupAddress, 64, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_24Type4_3B, interfAddress, 68, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_24Type4_3B, sourceAddress, 72, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_24Type6_3B, 88, Lsun_2Fnio_2Fch_2FMembershipKeyImpl_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_24Type6_3B, groupAddress, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_24Type6_3B, index, 72, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FMembershipKeyImpl_24Type6_3B, sourceAddress, 80, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FPollSelectorProvider_3B, 12, Lsun_2Fnio_2Fch_2FSelectorProviderImpl_3B)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSharedFileLockTable_24FileLockReference_3B, 56, Ljava_2Flang_2Fref_2FWeakReference_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSharedFileLockTable_24FileLockReference_3B, fileKey, 48, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUnixAsynchronousSocketChannelImpl_24OpType_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractWatchService_241_3B, 64, Lsun_2Fnio_2Ffs_2FAbstractWatchKey_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FAbstractWatchService_241_3B, this_240, 56, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxDosFileAttributeView_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxDosFileAttributeView_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxDosFileAttributeView_241_3B, val_24attrs, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxDosFileAttributeView_241_3B, val_24dosAttribute, 12, 4)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxDosFileAttributeView_3B, 24, Lsun_2Fnio_2Ffs_2FUnixFileAttributeViews_24Basic_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxFileStore_3B, 42, Lsun_2Fnio_2Ffs_2FUnixFileStore_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxFileStore_3B, xattrChecked, 40, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxFileStore_3B, xattrEnabled, 41, 1)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24LinuxWatchKey_3B, 64, Lsun_2Fnio_2Ffs_2FAbstractWatchKey_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24LinuxWatchKey_3B, ifd, 56, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24LinuxWatchKey_3B, wd, 60, 4)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxWatchService_3B, 48, Lsun_2Fnio_2Ffs_2FAbstractWatchService_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_3B, poller, 40, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24Poller_3B, 80, Lsun_2Fnio_2Ffs_2FAbstractPoller_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24Poller_3B, address, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24Poller_3B, fs, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24Poller_3B, guard, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24Poller_3B, ifd, 48, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24Poller_3B, socketpair, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24Poller_3B, watcher, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxWatchService_24Poller_3B, wdToKey, 72, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FMimeTypesFileTypeDetector_3B, 12, Lsun_2Fnio_2Ffs_2FAbstractFileTypeDetector_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixCopyFile_241_3B, 72, Lsun_2Fnio_2Ffs_2FCancellable_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_241_3B, val_24attrsToCopy, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_241_3B, val_24flags, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_241_3B, val_24source, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixCopyFile_241_3B, val_24target, 64, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystemProvider_241_3B, 24, Lsun_2Fnio_2Ffs_2FAbstractFileTypeDetector_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystemProvider_241_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixFileSystemProvider_242_3B, 32, Lsun_2Fnio_2Ffs_2FAbstractFileTypeDetector_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystemProvider_242_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixFileSystemProvider_242_3B, val_24detectors, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAlgorithmChecker_3B, 40, Ljava_2Fsecurity_2Fcert_2FPKIXCertPathChecker_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAlgorithmChecker_3B, constraints, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAlgorithmChecker_3B, prevPubKey, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAlgorithmChecker_3B, trustedMatch, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FAlgorithmChecker_3B, trustedPubKey, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B, 64, Ljava_2Fsecurity_2Fcert_2FPKIXCertPathChecker_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B, caName, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B, date, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B, prevPubKey, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B, prevSubject, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B, sigOnly, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B, sigProvider, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FBasicChecker_3B, trustedPubKey, 56, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FConstraintsChecker_3B, 40, Ljava_2Fsecurity_2Fcert_2FPKIXCertPathChecker_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FConstraintsChecker_3B, certPathLength, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FConstraintsChecker_3B, i, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FConstraintsChecker_3B, maxPathLength, 20, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FConstraintsChecker_3B, prevNC, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FConstraintsChecker_3B, supportedExts, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FKeyChecker_3B, 40, Ljava_2Fsecurity_2Fcert_2FPKIXCertPathChecker_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FKeyChecker_3B, certPathLen, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FKeyChecker_3B, remainingCerts, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FKeyChecker_3B, supportedExts, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FKeyChecker_3B, targetConstraints, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, 64, Ljava_2Fsecurity_2Fcert_2FPKIXCertPathChecker_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, anyPolicyInhibited, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, certIndex, 16, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, certPathLen, 20, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, expPolicyRequired, 13, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, explicitPolicy, 24, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, inhibitAnyPolicy, 28, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, initPolicies, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, polMappingInhibited, 14, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, policyMapping, 40, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, rejectPolicyQualifiers, 15, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, rootNode, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPolicyChecker_3B, supportedExts, 56, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24Mode_3B, 24, Ljava_2Flang_2FEnum_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FX509CertPath_3B, 32, Ljava_2Fsecurity_2Fcert_2FCertPath_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FX509CertPath_3B, certs, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FMemoryCache_24SoftCacheEntry_3B, 72, Ljava_2Flang_2Fref_2FSoftReference_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FMemoryCache_24SoftCacheEntry_3B, expirationTime, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Futil_2FMemoryCache_24SoftCacheEntry_3B, key, 64, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FResources_3B, 64, Ljava_2Futil_2FListResourceBundle_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FCRLReasonCodeExtension_3B, 36, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FCRLReasonCodeExtension_3B, reasonCode, 32, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FInhibitAnyPolicyExtension_3B, 36, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FInhibitAnyPolicyExtension_3B, skipCerts, 32, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FInvalidityDateExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FInvalidityDateExtension_3B, date, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FKeyUsageExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FKeyUsageExtension_3B, bitString, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FNetscapeCertTypeExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FNetscapeCertTypeExtension_3B, bitString, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FOCSPNoCheckExtension_3B, 32, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FSubjectInfoAccessExtension_3B, 40, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FSubjectInfoAccessExtension_3B, accessDescriptions, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FUnparseableExtension_3B, 48, Lsun_2Fsecurity_2Fx509_2FExtension_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FUnparseableExtension_3B, name, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FUnparseableExtension_3B, why, 40, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FLocaleObjectCache_24CacheEntry_3B, 64, Ljava_2Flang_2Fref_2FSoftReference_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLocaleObjectCache_24CacheEntry_3B, key, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FCollectionSet_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FCollectionSet_3B, data, 16, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_3B, 84, Landroid_2Ficu_2Fimpl_2FICUResourceBundle_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_3B, resource, 80, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FInvalidFormatException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FJavaTimeZone_3B, 48, Landroid_2Ficu_2Futil_2FTimeZone_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FJavaTimeZone_3B, isFrozen, 24, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FJavaTimeZone_3B, javacal, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FJavaTimeZone_3B, javatz, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleSyntaxException_3B, 60, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Flocale_2FLocaleSyntaxException_3B, __index, 56, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fnumber_2FCustomSymbolCurrency_3B, 56, Landroid_2Ficu_2Futil_2FCurrency_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCustomSymbolCurrency_3B, symbol1, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fnumber_2FCustomSymbolCurrency_3B, symbol2, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FCurrencyRounder_3B, 24, Landroid_2Ficu_2Fnumber_2FCurrencyPrecision_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FFractionRounder_3B, 24, Landroid_2Ficu_2Fnumber_2FFractionPrecision_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FAnyTransliterator_3B, 64, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_3B, cache, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_3B, target, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_3B, targetScript, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FAnyTransliterator_3B, widthFix, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FArabicShapingException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_2410_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_2411_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_2412_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_2413_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_2414_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_2415_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_2416_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_241_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_242_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_243_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_244_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_245_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_246_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_247_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_248_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_249_3B, 24, Landroid_2Ficu_2Ftext_2FBidiTransform_24ReorderingScheme_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBreakIteratorFactory_24BFService_241RBBreakIteratorFactory_3B, 40, Landroid_2Ficu_2Fimpl_2FICULocaleService_24ICUResourceBundleFactory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakIteratorFactory_24BFService_241RBBreakIteratorFactory_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBreakIteratorFactory_24BFService_3B, 112, Landroid_2Ficu_2Fimpl_2FICULocaleService_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FBreakTransliterator_3B, 64, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakTransliterator_3B, bi, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakTransliterator_3B, boundaries, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakTransliterator_3B, boundaryCount, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FBreakTransliterator_3B, insertion, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_24CharsetRecog__UTF__32__BE_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_24CharsetRecog__UTF__32_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_24CharsetRecog__UTF__32__LE_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__Unicode_24CharsetRecog__UTF__32_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24CharsetRecog__euc_24CharsetRecog__euc__jp_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24CharsetRecog__euc_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24CharsetRecog__euc_24CharsetRecog__euc__kr_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__mbcs_24CharsetRecog__euc_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__5__ru_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__5_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__6__ar_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__6_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__7__el_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__7_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__8__I__he_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__8_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__8__he_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__8_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__9__tr_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__8859__9_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM420__ar__ltr_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM420__ar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM420__ar__rtl_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM420__ar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM424__he__ltr_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM424__he_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM424__he__rtl_3B, 12, Landroid_2Ficu_2Ftext_2FCharsetRecog__sbcs_24CharsetRecog__IBM424__he_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollatorServiceShim_24CService_241CollatorFactory_3B, 40, Landroid_2Ficu_2Fimpl_2FICULocaleService_24ICUResourceBundleFactory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCollatorServiceShim_24CService_241CollatorFactory_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCollatorServiceShim_24CService_3B, 112, Landroid_2Ficu_2Fimpl_2FICULocaleService_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCompoundTransliterator_3B, 48, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCompoundTransliterator_3B, numAnonymousRBTs, 32, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FCompoundTransliterator_3B, trans, 40, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDurationFormat_3B, 32, Landroid_2Ficu_2Ftext_2FUFormat_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_3B, 72, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_3B, grokSupplementals, 32, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_3B, minDigits, 36, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_3B, prefix, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_3B, radix, 48, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_3B, suffix, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FEscapeTransliterator_3B, supplementalHandler, 64, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FMessageFormat_24Field_3B, 24, Ljava_2Ftext_2FFormat_24Field_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNameUnicodeTransliterator_3B, 32, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_3B, 40, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNormalizationTransliterator_3B, norm2, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNullTransliterator_3B, 32, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberFormatServiceShim_24NFService_241RBNumberFormatFactory_3B, 40, Landroid_2Ficu_2Fimpl_2FICULocaleService_24ICUResourceBundleFactory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FNumberFormatServiceShim_24NFService_241RBNumberFormatFactory_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FNumberFormatServiceShim_24NFService_3B, 112, Landroid_2Ficu_2Fimpl_2FICULocaleService_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24AndConstraint_3B, 32, Landroid_2Ficu_2Ftext_2FPluralRules_24BinaryConstraint_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FPluralRules_24OrConstraint_3B, 32, Landroid_2Ficu_2Ftext_2FPluralRules_24BinaryConstraint_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRemoveTransliterator_3B, 32, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FRuleBasedTransliterator_3B, 40, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FRuleBasedTransliterator_3B, data, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnescapeTransliterator_3B, 40, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FUnescapeTransliterator_3B, spec, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FUnicodeNameTransliterator_3B, 32, Landroid_2Ficu_2Ftext_2FTransliterator_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FBuddhistCalendar_3B, 146, Landroid_2Ficu_2Futil_2FGregorianCalendar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCopticCalendar_3B, 128, Landroid_2Ficu_2Futil_2FCECalendar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrencyServiceShim_24CFService_241CurrencyFactory_3B, 40, Landroid_2Ficu_2Fimpl_2FICULocaleService_24ICUResourceBundleFactory_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCurrencyServiceShim_24CFService_241CurrencyFactory_3B, this_240, 32, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCurrencyServiceShim_24CFService_3B, 112, Landroid_2Ficu_2Fimpl_2FICULocaleService_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FDangiCalendar_3B, 168, Landroid_2Ficu_2Futil_2FChineseCalendar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FEthiopicCalendar_3B, 132, Landroid_2Ficu_2Futil_2FCECalendar_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FEthiopicCalendar_3B, eraType, 128, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FJapaneseCalendar_3B, 146, Landroid_2Ficu_2Futil_2FGregorianCalendar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTaiwanCalendar_3B, 146, Landroid_2Ficu_2Futil_2FGregorianCalendar_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FTimeZone_24ConstantZone_3B, 32, Landroid_2Ficu_2Futil_2FTimeZone_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeZone_24ConstantZone_3B, isFrozen, 24, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FTimeZone_24ConstantZone_3B, rawOffset, 28, 4)
+__MRT_CLASS(Ldalvik_2Fsystem_2FDelegateLastClassLoader_3B, 73, Ldalvik_2Fsystem_2FPathClassLoader_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FDelegateLastClassLoader_3B, delegateResourceLoading, 72, 1)
+__MRT_CLASS(Ljava_2Fawt_2Ffont_2FNumericShaper_24Range_241_3B, 36, Ljava_2Fawt_2Ffont_2FNumericShaper_24Range_3B)
+__MRT_CLASS(Ljava_2Fbeans_2FIndexedPropertyChangeEvent_3B, 60, Ljava_2Fbeans_2FPropertyChangeEvent_3B)
+__MRT_CLASS_FIELD(Ljava_2Fbeans_2FIndexedPropertyChangeEvent_3B, index, 56, 4)
+__MRT_CLASS(Ljava_2Fio_2FCharArrayReader_3B, 52, Ljava_2Fio_2FReader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FCharArrayReader_3B, buf, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FCharArrayReader_3B, count, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FCharArrayReader_3B, markedPos, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FCharArrayReader_3B, pos, 48, 4)
+__MRT_CLASS(Ljava_2Fio_2FCharArrayWriter_3B, 44, Ljava_2Fio_2FWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FCharArrayWriter_3B, buf, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FCharArrayWriter_3B, count, 40, 4)
+__MRT_CLASS(Ljava_2Fio_2FConsole_24LineReader_3B, 72, Ljava_2Fio_2FReader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_24LineReader_3B, cb, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_24LineReader_3B, in, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_24LineReader_3B, leftoverLF, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_24LineReader_3B, nChars, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_24LineReader_3B, nextChar, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_24LineReader_3B, this_240, 64, 8)
+__MRT_CLASS(Ljava_2Fio_2FFileInputStream_24UseManualSkipException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Fio_2FFilterReader_3B, 40, Ljava_2Fio_2FReader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFilterReader_3B, in, 32, 8)
+__MRT_CLASS(Ljava_2Fio_2FFilterWriter_3B, 40, Ljava_2Fio_2FWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FFilterWriter_3B, out, 32, 8)
+__MRT_CLASS(Ljava_2Fio_2FIOError_3B, 56, Ljava_2Flang_2FError_3B)
+__MRT_CLASS(Ljava_2Fio_2FInputStreamReader_3B, 40, Ljava_2Fio_2FReader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FInputStreamReader_3B, sd, 32, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, 80, Ljava_2Fio_2FReader_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, bb, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, ch, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, cs, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, decoder, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, haveLeftoverChar, 64, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, in, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, isOpen, 65, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, leftoverChar, 66, 2)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fcs_2FStreamDecoder_3B, needsFlush, 68, 1)
+__MRT_CLASS(Ljava_2Fio_2FPipedInputStream_3B, 48, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedInputStream_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedInputStream_3B, closedByReader, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedInputStream_3B, closedByWriter, 13, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedInputStream_3B, connected, 14, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedInputStream_3B, in, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedInputStream_3B, out, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedInputStream_3B, readSide, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedInputStream_3B, writeSide, 40, 8)
+__MRT_CLASS(Ljava_2Fio_2FPipedOutputStream_3B, 24, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedOutputStream_3B, sink, 16, 8)
+__MRT_CLASS(Ljava_2Fio_2FPipedReader_3B, 72, Ljava_2Fio_2FReader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedReader_3B, buffer, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedReader_3B, closedByReader, 40, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedReader_3B, closedByWriter, 41, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedReader_3B, connected, 42, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedReader_3B, in, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedReader_3B, out, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedReader_3B, readSide, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedReader_3B, writeSide, 64, 8)
+__MRT_CLASS(Ljava_2Fio_2FPipedWriter_3B, 48, Ljava_2Fio_2FWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedWriter_3B, closed, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPipedWriter_3B, sink, 40, 8)
+__MRT_CLASS(Ljava_2Fio_2FSequenceInputStream_3B, 32, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FSequenceInputStream_3B, e, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FSequenceInputStream_3B, in, 24, 8)
+__MRT_CLASS(Ljava_2Fio_2FStringBufferInputStream_3B, 28, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStringBufferInputStream_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStringBufferInputStream_3B, count, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStringBufferInputStream_3B, pos, 24, 4)
+__MRT_CLASS(Ljava_2Fio_2FStringReader_3B, 56, Ljava_2Fio_2FReader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStringReader_3B, length, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStringReader_3B, mark, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStringReader_3B, next, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStringReader_3B, str, 48, 8)
+__MRT_CLASS(Ljava_2Fio_2FStringWriter_3B, 40, Ljava_2Fio_2FWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FStringWriter_3B, buf, 32, 8)
+__MRT_CLASS(Ljava_2Flang_2FAssertionError_3B, 56, Ljava_2Flang_2FError_3B)
+__MRT_CLASS(Ljava_2Flang_2FCharSequence_241CharIterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FCharSequence_241CharIterator_3B, cur, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FCharSequence_241CharIterator_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FCharSequence_241CodePointIterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FCharSequence_241CodePointIterator_3B, cur, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FCharSequence_241CodePointIterator_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Flang_2FCloneNotSupportedException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Flang_2FInterruptedException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Flang_2FLinkageError_3B, 56, Ljava_2Flang_2FError_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_24NullInputStream_3B, 12, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS(Ljava_2Flang_2FProcessBuilder_24NullOutputStream_3B, 12, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS(Ljava_2Flang_2FSystem_24PropertiesWithNonOverrideableDefaults_3B, 72, Ljava_2Futil_2FProperties_3B)
+__MRT_CLASS(Ljava_2Flang_2FThreadDeath_3B, 56, Ljava_2Flang_2FError_3B)
+__MRT_CLASS(Ljava_2Flang_2Fannotation_2FAnnotationFormatError_3B, 56, Ljava_2Flang_2FError_3B)
+__MRT_CLASS(Ljava_2Flang_2Finvoke_2FLambdaConversionException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FReflectPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljava_2Fnet_2FFactoryURLClassLoader_3B, 96, Ljava_2Fnet_2FURLClassLoader_3B)
+__MRT_CLASS(Ljava_2Fnet_2FMulticastSocket_3B, 96, Ljava_2Fnet_2FDatagramSocket_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FMulticastSocket_3B, infAddress, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FMulticastSocket_3B, infLock, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FMulticastSocket_3B, interfaceSet, 80, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FMulticastSocket_3B, ttlLock, 88, 8)
+__MRT_CLASS(Ljava_2Fnet_2FPlainDatagramSocketImpl_3B, 64, Ljava_2Fnet_2FAbstractPlainDatagramSocketImpl_3B)
+__MRT_CLASS(Ljava_2Fnet_2FURISyntaxException_3B, 72, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURISyntaxException_3B, index, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FURISyntaxException_3B, input, 64, 8)
+__MRT_CLASS(Ljava_2Fnio_2FCharBufferSpliterator_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FCharBufferSpliterator_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FCharBufferSpliterator_3B, index, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FCharBufferSpliterator_3B, limit, 24, 4)
+__MRT_CLASS(Ljava_2Fnio_2FDirectByteBuffer_3B, 80, Ljava_2Fnio_2FMappedByteBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDirectByteBuffer_3B, cleaner, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2FDirectByteBuffer_3B, memoryRef, 72, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FChannels_241_3B, 48, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_241_3B, b1, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_241_3B, bb, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_241_3B, bs, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_241_3B, val_24ch, 40, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FChannels_242_3B, 48, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_242_3B, b1, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_242_3B, bb, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_242_3B, bs, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_242_3B, val_24ch, 40, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FChannels_243_3B, 48, Ljava_2Fio_2FOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_243_3B, b1, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_243_3B, bb, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_243_3B, bs, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_243_3B, val_24ch, 40, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCoderMalfunctionError_3B, 56, Ljava_2Flang_2FError_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FLinkPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FPrivilegedActionException_3B, 64, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FPrivilegedActionException_3B, exception, 56, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Facl_2FAclNotFoundException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Facl_2FLastOwnerException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Facl_2FNotOwnerException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Ftext_2FAttributedString_24AttributedStringIterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributedStringIterator_3B, beginIndex, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributedStringIterator_3B, currentIndex, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributedStringIterator_3B, currentRunIndex, 20, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributedStringIterator_3B, currentRunLimit, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributedStringIterator_3B, currentRunStart, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributedStringIterator_3B, endIndex, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributedStringIterator_3B, relevantAttributes, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FAttributedString_24AttributedStringIterator_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Ftext_2FChoiceFormat_3B, 56, Ljava_2Ftext_2FNumberFormat_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FChoiceFormat_3B, choiceFormats, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FChoiceFormat_3B, choiceLimits, 48, 8)
+__MRT_CLASS(Ljava_2Ftext_2FDecimalFormat_3B, 80, Ljava_2Ftext_2FNumberFormat_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormat_3B, icuDecimalFormat, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormat_3B, maximumFractionDigits, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormat_3B, maximumIntegerDigits, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormat_3B, minimumFractionDigits, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormat_3B, minimumIntegerDigits, 60, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormat_3B, roundingMode, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftext_2FDecimalFormat_3B, symbols, 72, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, 312, Landroid_2Ficu_2Ftext_2FNumberFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, PARSE__MAX__EXPONENT, 76, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, actualRoundingIncrement, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, actualRoundingIncrementICU, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, affixPatternsForCurrency, 96, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, attributes, 104, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, currencyChoice, 112, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, currencyPluralInfo, 120, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, currencySignCount, 128, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, currencyUsage, 136, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, decimalSeparatorAlwaysShown, 132, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, digitList, 144, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, exponentSignAlwaysShown, 133, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, formatPattern, 152, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, formatWidth, 160, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, groupingSize, 134, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, groupingSize2, 135, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, isReadyForParsing, 164, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, mathContext, 168, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, maxSignificantDigits, 176, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, minExponentDigits, 165, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, minSignificantDigits, 180, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, multiplier, 184, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, negPrefixPattern, 192, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, negSuffixPattern, 200, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, negativePrefix, 208, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, negativeSuffix, 216, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, pad, 166, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, padPosition, 188, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, parseBigDecimal, 224, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, parseRequireDecimalPoint, 225, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, posPrefixPattern, 232, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, posSuffixPattern, 240, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, positivePrefix, 248, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, positiveSuffix, 256, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, roundingDouble, 264, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, roundingDoubleReciprocal, 272, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, roundingIncrement, 280, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, roundingIncrementICU, 288, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, roundingMode, 228, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, serialVersionOnStream, 296, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, style, 300, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, symbols, 304, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, useExponentialNotation, 226, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FDecimalFormat__ICU58__Android_3B, useSignificantDigits, 227, 1)
+__MRT_CLASS(Ljava_2Ftext_2FNumberFormat_24Field_3B, 24, Ljava_2Ftext_2FFormat_24Field_3B)
+__MRT_CLASS(Ljava_2Ftext_2FMessageFormat_24Field_3B, 24, Ljava_2Ftext_2FFormat_24Field_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FChronoLocalDateImpl_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FChronoLocalDateTimeImpl_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronoLocalDateTimeImpl_3B, date, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronoLocalDateTimeImpl_3B, time, 24, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FChronoZonedDateTimeImpl_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronoZonedDateTimeImpl_3B, dateTime, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronoZonedDateTimeImpl_3B, offset, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FChronoZonedDateTimeImpl_3B, zone, 32, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, 72, Ljava_2Ftime_2Fchrono_2FAbstractChronology_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, calendarType, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, hijrahEpochMonthStartDays, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, hijrahStartEpochMonth, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, initComplete, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, maxEpochDay, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, maxMonthLength, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, maxYearLength, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, minEpochDay, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, minMonthLength, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, minYearLength, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahChronology_3B, typeId, 64, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FHijrahDate_3B, 32, Ljava_2Ftime_2Fchrono_2FChronoLocalDateImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahDate_3B, chrono, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahDate_3B, dayOfMonth, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahDate_3B, monthOfYear, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FHijrahDate_3B, prolepticYear, 28, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FJapaneseChronology_3B, 12, Ljava_2Ftime_2Fchrono_2FAbstractChronology_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FJapaneseDate_3B, 32, Ljava_2Ftime_2Fchrono_2FChronoLocalDateImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FJapaneseDate_3B, era, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FJapaneseDate_3B, isoDate, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FJapaneseDate_3B, yearOfEra, 12, 4)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FMinguoChronology_3B, 12, Ljava_2Ftime_2Fchrono_2FAbstractChronology_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FMinguoDate_3B, 24, Ljava_2Ftime_2Fchrono_2FChronoLocalDateImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FMinguoDate_3B, isoDate, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FThaiBuddhistChronology_3B, 12, Ljava_2Ftime_2Fchrono_2FAbstractChronology_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fchrono_2FThaiBuddhistDate_3B, 24, Ljava_2Ftime_2Fchrono_2FChronoLocalDateImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Ftime_2Fchrono_2FThaiBuddhistDate_3B, isoDate, 16, 8)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FIsoFields_24Field_241_3B, 24, Ljava_2Ftime_2Ftemporal_2FIsoFields_24Field_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FIsoFields_24Field_242_3B, 24, Ljava_2Ftime_2Ftemporal_2FIsoFields_24Field_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FIsoFields_24Field_243_3B, 24, Ljava_2Ftime_2Ftemporal_2FIsoFields_24Field_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FIsoFields_24Field_244_3B, 24, Ljava_2Ftime_2Ftemporal_2FIsoFields_24Field_3B)
+__MRT_CLASS(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, array, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, fence, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, function, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, hi, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, in, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, left, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, lo, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, origin, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, out, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, right, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24CumulateTask_3B, threshold, 76, 4)
+__MRT_CLASS(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, array, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, fence, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, function, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, hi, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, in, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, left, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, lo, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, origin, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, out, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, right, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24DoubleCumulateTask_3B, threshold, 76, 4)
+__MRT_CLASS(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, 88, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, array, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, fence, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, function, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, hi, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, in, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, left, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, lo, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, origin, 68, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, out, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, right, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24IntCumulateTask_3B, threshold, 76, 4)
+__MRT_CLASS(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, array, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, fence, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, function, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, hi, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, in, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, left, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, lo, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, origin, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, out, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, right, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrayPrefixHelpers_24LongCumulateTask_3B, threshold, 76, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24EmptyCompleter_3B, 28, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Merger_3B, 68, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Merger_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Merger_3B, gran, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Merger_3B, lbase, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Merger_3B, lsize, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Merger_3B, rbase, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Merger_3B, rsize, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Merger_3B, w, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Merger_3B, wbase, 64, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Sorter_3B, 60, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Sorter_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Sorter_3B, base, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Sorter_3B, gran, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Sorter_3B, size, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Sorter_3B, w, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJByte_24Sorter_3B, wbase, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Merger_3B, 68, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Merger_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Merger_3B, gran, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Merger_3B, lbase, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Merger_3B, lsize, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Merger_3B, rbase, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Merger_3B, rsize, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Merger_3B, w, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Merger_3B, wbase, 64, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Sorter_3B, 60, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Sorter_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Sorter_3B, base, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Sorter_3B, gran, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Sorter_3B, size, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Sorter_3B, w, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJChar_24Sorter_3B, wbase, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Merger_3B, 68, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Merger_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Merger_3B, gran, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Merger_3B, lbase, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Merger_3B, lsize, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Merger_3B, rbase, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Merger_3B, rsize, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Merger_3B, w, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Merger_3B, wbase, 64, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Sorter_3B, 60, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Sorter_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Sorter_3B, base, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Sorter_3B, gran, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Sorter_3B, size, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Sorter_3B, w, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJDouble_24Sorter_3B, wbase, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Merger_3B, 68, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Merger_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Merger_3B, gran, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Merger_3B, lbase, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Merger_3B, lsize, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Merger_3B, rbase, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Merger_3B, rsize, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Merger_3B, w, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Merger_3B, wbase, 64, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Sorter_3B, 60, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Sorter_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Sorter_3B, base, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Sorter_3B, gran, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Sorter_3B, size, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Sorter_3B, w, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJFloat_24Sorter_3B, wbase, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Merger_3B, 68, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Merger_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Merger_3B, gran, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Merger_3B, lbase, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Merger_3B, lsize, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Merger_3B, rbase, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Merger_3B, rsize, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Merger_3B, w, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Merger_3B, wbase, 64, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Sorter_3B, 60, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Sorter_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Sorter_3B, base, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Sorter_3B, gran, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Sorter_3B, size, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Sorter_3B, w, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJInt_24Sorter_3B, wbase, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Merger_3B, 68, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Merger_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Merger_3B, gran, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Merger_3B, lbase, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Merger_3B, lsize, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Merger_3B, rbase, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Merger_3B, rsize, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Merger_3B, w, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Merger_3B, wbase, 64, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Sorter_3B, 60, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Sorter_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Sorter_3B, base, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Sorter_3B, gran, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Sorter_3B, size, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Sorter_3B, w, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJLong_24Sorter_3B, wbase, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, 76, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, comparator, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, gran, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, lbase, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, lsize, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, rbase, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, rsize, 60, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, w, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Merger_3B, wbase, 72, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Sorter_3B, 68, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Sorter_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Sorter_3B, base, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Sorter_3B, comparator, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Sorter_3B, gran, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Sorter_3B, size, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Sorter_3B, w, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJObject_24Sorter_3B, wbase, 64, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Merger_3B, 68, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Merger_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Merger_3B, gran, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Merger_3B, lbase, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Merger_3B, lsize, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Merger_3B, rbase, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Merger_3B, rsize, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Merger_3B, w, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Merger_3B, wbase, 64, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Sorter_3B, 60, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Sorter_3B, a, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Sorter_3B, base, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Sorter_3B, gran, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Sorter_3B, size, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Sorter_3B, w, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24FJShort_24Sorter_3B, wbase, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FArraysParallelSortHelpers_24Relay_3B, 40, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArraysParallelSortHelpers_24Relay_3B, task, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FBase64_24DecInputStream_3B, 56, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24DecInputStream_3B, base64, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24DecInputStream_3B, bits, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24DecInputStream_3B, closed, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24DecInputStream_3B, eof, 25, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24DecInputStream_3B, is, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24DecInputStream_3B, isMIME, 26, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24DecInputStream_3B, nextin, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24DecInputStream_3B, nextout, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24DecInputStream_3B, sbBuf, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FBitSet_241BitSetIterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBitSet_241BitSetIterator_3B, next, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBitSet_241BitSetIterator_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedNavigableMap_3B, 64, Ljava_2Futil_2FCollections_24CheckedSortedMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedNavigableMap_3B, nm, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedQueue_3B, 48, Ljava_2Futil_2FCollections_24CheckedCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedQueue_3B, queue, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedSet_3B, 40, Ljava_2Futil_2FCollections_24CheckedCollection_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SynchronizedList_3B, 40, Ljava_2Futil_2FCollections_24SynchronizedCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedList_3B, list, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SynchronizedNavigableMap_3B, 72, Ljava_2Futil_2FCollections_24SynchronizedSortedMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedNavigableMap_3B, nm, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SynchronizedSet_3B, 32, Ljava_2Futil_2FCollections_24SynchronizedCollection_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableNavigableMap_3B, 64, Ljava_2Futil_2FCollections_24UnmodifiableSortedMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableNavigableMap_3B, nm, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableNavigableMap_24EmptyNavigableMap_3B, 64, Ljava_2Futil_2FCollections_24UnmodifiableNavigableMap_3B)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_24Values_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24Values_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24Values_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24Values_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashtable_24ValueCollection_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24ValueCollection_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24Values_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24Values_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashMap_24LinkedValues_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedValues_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FPropertyPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljava_2Futil_2FRandom_24RandomDoublesSpliterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomDoublesSpliterator_3B, bound, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomDoublesSpliterator_3B, fence, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomDoublesSpliterator_3B, index, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomDoublesSpliterator_3B, origin, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomDoublesSpliterator_3B, rng, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FRandom_24RandomIntsSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomIntsSpliterator_3B, bound, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomIntsSpliterator_3B, fence, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomIntsSpliterator_3B, index, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomIntsSpliterator_3B, origin, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomIntsSpliterator_3B, rng, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FRandom_24RandomLongsSpliterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomLongsSpliterator_3B, bound, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomLongsSpliterator_3B, fence, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomLongsSpliterator_3B, index, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomLongsSpliterator_3B, origin, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FRandom_24RandomLongsSpliterator_3B, rng, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FServiceConfigurationError_3B, 56, Ljava_2Flang_2FError_3B)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_242Adapter_3B, 25, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_242Adapter_3B, nextElement, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_242Adapter_3B, val_24spliterator, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_242Adapter_3B, valueReady, 24, 1)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_243Adapter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_243Adapter_3B, nextElement, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_243Adapter_3B, val_24spliterator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_243Adapter_3B, valueReady, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_244Adapter_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_244Adapter_3B, nextElement, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_244Adapter_3B, val_24spliterator, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_244Adapter_3B, valueReady, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24AbstractDoubleSpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractDoubleSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractDoubleSpliterator_3B, characteristics, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractDoubleSpliterator_3B, est, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24AbstractIntSpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractIntSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractIntSpliterator_3B, characteristics, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractIntSpliterator_3B, est, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24AbstractLongSpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractLongSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractLongSpliterator_3B, characteristics, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24AbstractLongSpliterator_3B, est, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24DoubleArraySpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24DoubleArraySpliterator_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24DoubleArraySpliterator_3B, characteristics, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24DoubleArraySpliterator_3B, fence, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24DoubleArraySpliterator_3B, index, 28, 4)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24DoubleIteratorSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24DoubleIteratorSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24DoubleIteratorSpliterator_3B, characteristics, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24DoubleIteratorSpliterator_3B, est, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24DoubleIteratorSpliterator_3B, it, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24EmptySpliterator_24OfDouble_3B, 12, Ljava_2Futil_2FSpliterators_24EmptySpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24EmptySpliterator_24OfInt_3B, 12, Ljava_2Futil_2FSpliterators_24EmptySpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24EmptySpliterator_24OfLong_3B, 12, Ljava_2Futil_2FSpliterators_24EmptySpliterator_3B)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24IntArraySpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IntArraySpliterator_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IntArraySpliterator_3B, characteristics, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IntArraySpliterator_3B, fence, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IntArraySpliterator_3B, index, 28, 4)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24IntIteratorSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IntIteratorSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IntIteratorSpliterator_3B, characteristics, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IntIteratorSpliterator_3B, est, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24IntIteratorSpliterator_3B, it, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24LongArraySpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24LongArraySpliterator_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24LongArraySpliterator_3B, characteristics, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24LongArraySpliterator_3B, fence, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24LongArraySpliterator_3B, index, 28, 4)
+__MRT_CLASS(Ljava_2Futil_2FSpliterators_24LongIteratorSpliterator_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24LongIteratorSpliterator_3B, batch, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24LongIteratorSpliterator_3B, characteristics, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24LongIteratorSpliterator_3B, est, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSpliterators_24LongIteratorSpliterator_3B, it, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FSplittableRandom_24RandomDoublesSpliterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomDoublesSpliterator_3B, bound, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomDoublesSpliterator_3B, fence, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomDoublesSpliterator_3B, index, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomDoublesSpliterator_3B, origin, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomDoublesSpliterator_3B, rng, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FSplittableRandom_24RandomIntsSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomIntsSpliterator_3B, bound, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomIntsSpliterator_3B, fence, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomIntsSpliterator_3B, index, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomIntsSpliterator_3B, origin, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomIntsSpliterator_3B, rng, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FSplittableRandom_24RandomLongsSpliterator_3B, 56, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomLongsSpliterator_3B, bound, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomLongsSpliterator_3B, fence, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomLongsSpliterator_3B, index, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomLongsSpliterator_3B, origin, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FSplittableRandom_24RandomLongsSpliterator_3B, rng, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FTooManyListenersException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24Values_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24Values_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24Values_3B, 24, Ljava_2Futil_2FAbstractCollection_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24Values_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FBrokenBarrierException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24CoCompletion_3B, 32, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Completion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24CoCompletion_3B, base, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Signaller_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Completion_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Signaller_3B, deadline, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Signaller_3B, interrupted, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Signaller_3B, interruptible, 33, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Signaller_3B, nanos, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24Signaller_3B, thread, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, 80, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, baseIndex, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, baseLimit, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, baseSize, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, batch, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, index, 44, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, next, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, spare, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, stack, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B, tab, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutionException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutorCompletionService_24QueueingFuture_3B, 64, Ljava_2Futil_2Fconcurrent_2FFutureTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutorCompletionService_24QueueingFuture_3B, completionQueue, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutorCompletionService_24QueueingFuture_3B, task, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24DelegatedExecutorService_3B, 24, Ljava_2Futil_2Fconcurrent_2FAbstractExecutorService_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24DelegatedExecutorService_3B, e, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FForkJoinWorkerThread_24InnocuousForkJoinWorkerThread_3B, 192, Ljava_2Futil_2Fconcurrent_2FForkJoinWorkerThread_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomDoublesSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomDoublesSpliterator_3B, bound, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomDoublesSpliterator_3B, fence, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomDoublesSpliterator_3B, index, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomDoublesSpliterator_3B, origin, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomIntsSpliterator_3B, 36, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomIntsSpliterator_3B, bound, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomIntsSpliterator_3B, fence, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomIntsSpliterator_3B, index, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomIntsSpliterator_3B, origin, 32, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomLongsSpliterator_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomLongsSpliterator_3B, bound, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomLongsSpliterator_3B, fence, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomLongsSpliterator_3B, index, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FThreadLocalRandom_24RandomLongsSpliterator_3B, origin, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FTimeUnit_242_3B, 24, Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FTimeUnit_243_3B, 24, Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FTimeUnit_244_3B, 24, Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FTimeUnit_245_3B, 24, Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FTimeUnit_246_3B, 24, Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FTimeUnit_247_3B, 24, Ljava_2Futil_2Fconcurrent_2FTimeUnit_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FTimeoutException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAccumulator_3B, 48, Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAccumulator_3B, function, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FDoubleAccumulator_3B, identity, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAccumulator_3B, 48, Ljava_2Futil_2Fconcurrent_2Fatomic_2FStriped64_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAccumulator_3B, function, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2Fatomic_2FLongAccumulator_3B, identity, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarFile_24JarFileEntry_3B, 144, Ljava_2Futil_2Fjar_2FJarEntry_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarFile_24JarFileEntry_3B, this_240, 136, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierStream_3B, 48, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierStream_3B, is, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierStream_3B, jv, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierStream_3B, mev, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fjar_2FJarVerifier_24VerifierStream_3B, numLeft, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Flogging_2FLoggingPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FAbstractPreferences_24NodeAddedEvent_3B, 40, Ljava_2Futil_2Fprefs_2FNodeChangeEvent_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_24NodeAddedEvent_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FAbstractPreferences_24NodeRemovedEvent_3B, 40, Ljava_2Futil_2Fprefs_2FNodeChangeEvent_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fprefs_2FAbstractPreferences_24NodeRemovedEvent_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FBackingStoreException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fprefs_2FInvalidPreferencesFormatException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_246BdNjvJJOqgXMfHsEogzyrab_2D60_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_246BdNjvJJOqgXMfHsEogzyrab_2D60_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24C9lt__0Cg_2DSARhdNFJsMyHSsCsGA_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24C9lt__0Cg_2DSARhdNFJsMyHSsCsGA_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24G3FiaNZPcIIAnGkHVY7Mdu42X5g_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24G3FiaNZPcIIAnGkHVY7Mdu42X5g_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ZgCkHA78fnu8poGzKYmvya_2Dev3U_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24ZgCkHA78fnu8poGzKYmvya_2Dev3U_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24fgFAI1gk0hw2h3IP9CmHWlY3YkM_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24fgFAI1gk0hw2h3IP9CmHWlY3YkM_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24xWqUKn_2Dt__aBWo9sD9bohYsGFiXg_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2F_2D_24_24Lambda_24xWqUKn_2Dt__aBWo9sD9bohYsGFiXg_3B, f_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FAbstractTask_3B, 80, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractTask_3B, helper, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractTask_3B, leftChild, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractTask_3B, localResult, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractTask_3B, rightChild, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractTask_3B, spliterator, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractTask_3B, targetSize, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDistinctOps_241_241_3B, 48, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDistinctOps_241_241_3B, lastSeen, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDistinctOps_241_241_3B, seenNull, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDistinctOps_241_241_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDistinctOps_241_3B, 80, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatefulOp_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_24StatefulOp_3B, 80, Ljava_2Futil_2Fstream_2FReferencePipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDistinctOps_241_242_3B, 40, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDistinctOps_241_242_3B, seen, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDistinctOps_241_242_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoubleStream_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoubleStream_241_3B, t, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoubleStream_241_3B, val_24f, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoubleStream_241_3B, val_24seed, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FFindOps_24FindSink_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FFindOps_24FindSink_3B, hasValue, 12, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FFindOps_24FindSink_3B, value, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_3B, 13, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_3B, ordered, 12, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOrderedTask_3B, 88, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOrderedTask_3B, action, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOrderedTask_3B, completionMap, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOrderedTask_3B, helper, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOrderedTask_3B, leftPredecessor, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOrderedTask_3B, node, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOrderedTask_3B, spliterator, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOrderedTask_3B, targetSize, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachTask_3B, 64, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachTask_3B, helper, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachTask_3B, sink, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachTask_3B, spliterator, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachTask_3B, targetSize, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntStream_241_3B, 28, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntStream_241_3B, t, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntStream_241_3B, val_24f, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntStream_241_3B, val_24seed, 24, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongStream_241_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongStream_241_3B, t, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongStream_241_3B, val_24f, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongStream_241_3B, val_24seed, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FMatchOps_241MatchSink_3B, 32, Ljava_2Futil_2Fstream_2FMatchOps_24BooleanTerminalSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_241MatchSink_3B, val_24matchKind, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_241MatchSink_3B, val_24predicate, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FMatchOps_242MatchSink_3B, 32, Ljava_2Futil_2Fstream_2FMatchOps_24BooleanTerminalSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_242MatchSink_3B, val_24matchKind, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_242MatchSink_3B, val_24predicate, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FMatchOps_243MatchSink_3B, 32, Ljava_2Futil_2Fstream_2FMatchOps_24BooleanTerminalSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_243MatchSink_3B, val_24matchKind, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_243MatchSink_3B, val_24predicate, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FMatchOps_244MatchSink_3B, 32, Ljava_2Futil_2Fstream_2FMatchOps_24BooleanTerminalSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_244MatchSink_3B, val_24matchKind, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_244MatchSink_3B, val_24predicate, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ConcNode_24OfDouble_3B, 40, Ljava_2Futil_2Fstream_2FNodes_24ConcNode_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ConcNode_24OfInt_3B, 40, Ljava_2Futil_2Fstream_2FNodes_24ConcNode_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ConcNode_24OfLong_3B, 40, Ljava_2Futil_2Fstream_2FNodes_24ConcNode_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24DoubleArrayNode_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24DoubleArrayNode_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24DoubleArrayNode_3B, curSize, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24EmptyNode_24OfDouble_3B, 12, Ljava_2Futil_2Fstream_2FNodes_24EmptyNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24EmptyNode_24OfInt_3B, 12, Ljava_2Futil_2Fstream_2FNodes_24EmptyNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24EmptyNode_24OfLong_3B, 12, Ljava_2Futil_2Fstream_2FNodes_24EmptyNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24FixedNodeBuilder_3B, 24, Ljava_2Futil_2Fstream_2FNodes_24ArrayNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24IntArrayNode_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24IntArrayNode_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24IntArrayNode_3B, curSize, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_24OfDouble_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_24OfInt_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_24OfLong_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24InternalNodeSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24LongArrayNode_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24LongArrayNode_3B, array, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24LongArrayNode_3B, curSize, 12, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B, 80, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B, fence, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B, helper, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B, index, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B, length, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B, offset, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B, spliterator, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B, targetSize, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24SpinedNodeBuilder_3B, 49, Ljava_2Futil_2Fstream_2FSpinedBuffer_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SpinedNodeBuilder_3B, building, 48, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_3B, 40, Ljava_2Futil_2Fconcurrent_2FCountedCompleter_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_3B, node, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_3B, offset, 28, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_2410_241_3B, 40, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_2410_241_3B, downstreamAsLong, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_2410_241_3B, this_241, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_2410_3B, 96, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_2410_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_2410_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_2411_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_2411_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_2411_3B, 96, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_2411_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_2411_3B, val_24action, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_24StatelessOp_3B, 80, Ljava_2Futil_2Fstream_2FReferencePipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_242_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_242_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_242_3B, 96, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_242_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_242_3B, val_24predicate, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_243_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_243_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_243_3B, 96, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_243_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_243_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_244_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_244_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_244_3B, 96, Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_244_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_244_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_245_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_245_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_245_3B, 96, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_245_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_245_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_246_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_246_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_246_3B, 96, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_246_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_246_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_247_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_247_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_247_3B, 96, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_247_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_247_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_248_241_3B, 40, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_248_241_3B, downstreamAsInt, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_248_241_3B, this_241, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_248_3B, 96, Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_248_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_248_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_249_241_3B, 40, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_249_241_3B, downstreamAsDouble, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_249_241_3B, this_241, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_249_3B, 96, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_249_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_249_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_241_241_3B, 48, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_241_241_3B, m, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_241_241_3B, n, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_241_241_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_241_3B, 96, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatefulOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_241_3B, val_24limit, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_241_3B, val_24skip, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24AbstractRefSortingSink_3B, 40, Ljava_2Futil_2Fstream_2FSink_24ChainedReference_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24AbstractRefSortingSink_3B, cancellationWasRequested, 24, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24AbstractRefSortingSink_3B, comparator, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfDouble_241Splitr_3B, 56, Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfDouble_241Splitr_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfInt_241Splitr_3B, 56, Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfInt_241Splitr_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfLong_241Splitr_3B, 56, Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfPrimitive_24BaseSpliterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfLong_241Splitr_3B, this_240, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_24OfDouble_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_24OfInt_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_24OfLong_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24DelegatingSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_24OfDouble_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_24OfDouble_3B, s, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_24OfInt_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_24OfInt_3B, s, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_24OfLong_3B, 32, Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24InfiniteSupplyingSpliterator_24OfLong_3B, s, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_24OfDouble_3B, 56, Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_24OfInt_3B, 56, Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_24OfLong_3B, 56, Ljava_2Futil_2Fstream_2FStreamSpliterators_24SliceSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfDouble_3B, 48, Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfPrimitive_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfDouble_3B, tmpValue, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfInt_3B, 44, Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfPrimitive_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfInt_3B, tmpValue, 40, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfLong_3B, 48, Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfPrimitive_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreamSpliterators_24UnorderedSliceSpliterator_24OfLong_3B, tmpValue, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_24OfDouble_3B, 32, Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_24OfInt_3B, 32, Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_24OfLong_3B, 32, Ljava_2Futil_2Fstream_2FStreams_24ConcatSpliterator_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24DoubleStreamBuilderImpl_3B, 32, Ljava_2Futil_2Fstream_2FStreams_24AbstractStreamBuilderImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24DoubleStreamBuilderImpl_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24DoubleStreamBuilderImpl_3B, first, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24IntStreamBuilderImpl_3B, 28, Ljava_2Futil_2Fstream_2FStreams_24AbstractStreamBuilderImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24IntStreamBuilderImpl_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24IntStreamBuilderImpl_3B, first, 24, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24LongStreamBuilderImpl_3B, 32, Ljava_2Futil_2Fstream_2FStreams_24AbstractStreamBuilderImpl_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24LongStreamBuilderImpl_3B, buffer, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24LongStreamBuilderImpl_3B, first, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24RangeIntSpliterator_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24RangeIntSpliterator_3B, from, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24RangeIntSpliterator_3B, last, 16, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24RangeIntSpliterator_3B, upTo, 20, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FStreams_24RangeLongSpliterator_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24RangeLongSpliterator_3B, from, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24RangeLongSpliterator_3B, last, 12, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FStreams_24RangeLongSpliterator_3B, upTo, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FDataFormatException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInputStream_3B, 56, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInputStream_3B, jzentry, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInputStream_3B, pos, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInputStream_3B, rem, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInputStream_3B, size, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInputStream_3B, this_240, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInputStream_3B, zfisCloseRequested, 12, 1)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCryptoAllPermission_3B, 24, Ljavax_2Fcrypto_2FCryptoPermission_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2Fspec_2FSecretKeySpec_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FSecretKeySpec_3B, algorithm, 16, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2Fspec_2FSecretKeySpec_3B, key, 24, 8)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLServerSocket_3B, 32, Ljava_2Fnet_2FServerSocket_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2FDestroyFailedException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2Fcallback_2FUnsupportedCallbackException_3B, 64, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fsecurity_2Fauth_2Fcallback_2FUnsupportedCallbackException_3B, callback, 56, 8)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fcert_2FCertificateException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FDatatypeConfigurationException_3B, 65, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fdatatype_2FDatatypeConfigurationException_3B, causeOnJDK13OrBelow, 56, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fdatatype_2FDatatypeConfigurationException_3B, isJDK14OrAbove, 64, 1)
+__MRT_CLASS(Ljavax_2Fxml_2Fdatatype_2FFactoryFinder_24ConfigurationError_3B, 64, Ljava_2Flang_2FError_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fdatatype_2FFactoryFinder_24ConfigurationError_3B, exception, 56, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Fparsers_2FFactoryConfigurationError_3B, 64, Ljava_2Flang_2FError_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fparsers_2FFactoryConfigurationError_3B, exception, 56, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Fparsers_2FParserConfigurationException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2FTransformerFactoryConfigurationError_3B, 64, Ljava_2Flang_2FError_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Ftransform_2FTransformerFactoryConfigurationError_3B, exception, 56, 8)
+__MRT_CLASS(Ljavax_2Fxml_2Fxpath_2FXPathException_3B, 64, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fxml_2Fxpath_2FXPathException_3B, cause, 56, 8)
+__MRT_CLASS(Ljdk_2Fnet_2FNetworkPermission_3B, 24, Ljava_2Fsecurity_2FBasicPermission_3B)
+__MRT_CLASS(Llibcore_2Ftimezone_2FTzDataSetVersion_24TzDataSetException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Llibcore_2Futil_2FZoneInfo_24CheckedArithmeticException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentTypeImpl_3B, 64, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FLeafNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentTypeImpl_3B, publicId, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentTypeImpl_3B, qualifiedName, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FDocumentTypeImpl_3B, systemId, 56, 8)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNotationImpl_3B, 64, Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FLeafNodeImpl_3B)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNotationImpl_3B, notationName, 40, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNotationImpl_3B, publicID, 48, 8)
+__MRT_CLASS_FIELD(Lorg_2Fapache_2Fharmony_2Fxml_2Fdom_2FNotationImpl_3B, systemID, 56, 8)
+__MRT_CLASS(Lsun_2Fmisc_2FREException_3B, 56, Ljava_2Flang_2FException_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpProtocolException_3B, 64, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fftp_2FFtpProtocolException_3B, code, 56, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_24URLJarFileEntry_3B, 152, Ljava_2Futil_2Fjar_2FJarEntry_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_24URLJarFileEntry_3B, je, 136, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_24URLJarFileEntry_3B, this_240, 144, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_3B, 144, Ljava_2Futil_2Fjar_2FJarFile_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_3B, closeController, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_3B, superAttr, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_3B, superEntries, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FURLJarFile_3B, superMan, 136, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FChannelInputStream_3B, 48, Ljava_2Fio_2FInputStream_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FChannelInputStream_3B, b1, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FChannelInputStream_3B, bb, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FChannelInputStream_3B, bs, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FChannelInputStream_3B, ch, 40, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FDatagramSocketAdaptor_3B, 76, Ljava_2Fnet_2FDatagramSocket_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramSocketAdaptor_3B, dc, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramSocketAdaptor_3B, timeout, 72, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, 208, Ljava_2Fnio_2Fchannels_2FDatagramChannel_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, cachedSenderInetAddress, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, cachedSenderPort, 88, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, family, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, fd, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, fdVal, 92, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, guard, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, isReuseAddress, 120, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, localAddress, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, readLock, 136, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, readerThread, 144, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, registry, 152, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, remoteAddress, 160, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, reuseAddressEmulated, 121, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, sender, 168, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, socket, 176, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, state, 124, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, stateLock, 184, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, writeLock, 192, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FDatagramChannelImpl_3B, writerThread, 200, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FPort_241_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPort_241_3B, this_240, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPort_241_3B, val_24channel, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FServerSocketAdaptor_3B, 44, Ljava_2Fnet_2FServerSocket_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketAdaptor_3B, ssc, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketAdaptor_3B, timeout, 40, 4)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, 144, Ljava_2Fnio_2Fchannels_2FServerSocketChannel_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, fd, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, fdVal, 88, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, isReuseAddress, 92, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, localAddress, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, lock, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, socket, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, state, 120, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, stateLock, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FServerSocketChannelImpl_3B, thread, 136, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FUtil_243_3B, 24, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FUtil_243_3B, val_24s, 16, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FAbstractUserDefinedFileAttributeView_3B, 12, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxFileSystemProvider_3B, 24, Lsun_2Fnio_2Ffs_2FUnixFileSystemProvider_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxFileSystem_3B, 40, Lsun_2Fnio_2Ffs_2FUnixFileSystem_3B)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixException_3B, 72, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixException_3B, errno, 56, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixException_3B, msg, 64, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_24BasicFileAttributeViewImpl_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_24BasicFileAttributeViewImpl_3B, file, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_24BasicFileAttributeViewImpl_3B, followLinks, 12, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_24BasicFileAttributeViewImpl_3B, this_240, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_3B, 32, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_3B, dfd, 12, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_3B, ds, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_3B, guard, 24, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_24WrappedX509Certificate_3B, 48, Ljava_2Fsecurity_2Fcert_2FX509Certificate_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_24WrappedX509Certificate_3B, wrapped, 40, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FPKCS8Key_3B, 40, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS8Key_3B, algid, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS8Key_3B, encodedKey, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS8Key_3B, key, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RejectKeySelector_3B, 208, Ljava_2Fsecurity_2Fcert_2FX509CertSelector_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_24RejectKeySelector_3B, badKeySet, 200, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, 160, Ljava_2Fsecurity_2Fcert_2FPKIXRevocationChecker_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, anchor, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, certIndex, 64, 4)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, certStores, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, crlDP, 68, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, crlSignFlag, 69, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, issuerCert, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, legacy, 70, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, mode, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, ocspExtensions, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, ocspResponses, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, onlyEE, 71, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, params, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, prevPubKey, 120, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, responderCert, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, responderURI, 136, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, softFail, 144, 1)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FRevocationChecker_3B, softFailExceptions, 152, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathValidatorException_3B, 80, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPathValidatorException_3B, certPath, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPathValidatorException_3B, index, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertPathValidatorException_3B, reason, 72, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FFreshestCRLExtension_3B, 48, Lsun_2Fsecurity_2Fx509_2FCRLDistributionPointsExtension_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FX509Key_3B, 48, Ljava_2Flang_2FObject_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509Key_3B, algid, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509Key_3B, bitStringKey, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509Key_3B, encodedKey, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509Key_3B, key, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fx509_2FX509Key_3B, unusedBits, 12, 4)
+__MRT_CLASS(Lsun_2Futil_2Fcalendar_2FImmutableGregorianDate_3B, 120, Lsun_2Futil_2Fcalendar_2FBaseCalendar_24Date_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Fcalendar_2FImmutableGregorianDate_3B, date, 112, 8)
+__MRT_CLASS(Lsun_2Futil_2Flocale_2FLocaleSyntaxException_3B, 60, Ljava_2Flang_2FException_3B)
+__MRT_CLASS_FIELD(Lsun_2Futil_2Flocale_2FLocaleSyntaxException_3B, index, 56, 4)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FDateNumberFormat_3B, 106, Landroid_2Ficu_2Ftext_2FNumberFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDateNumberFormat_3B, decimalBuf, 80, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDateNumberFormat_3B, digits, 88, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDateNumberFormat_3B, maxIntDigits, 76, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDateNumberFormat_3B, minIntDigits, 96, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDateNumberFormat_3B, minusSign, 100, 2)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDateNumberFormat_3B, positiveOnly, 102, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FDateNumberFormat_3B, zeroDigit, 104, 2)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceBinary_3B, 84, Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceContainer_3B, 96, Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceContainer_3B, value, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceInt_3B, 84, Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceIntVector_3B, 84, Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceString_3B, 96, Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceString_3B, value, 88, 8)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormat_3B, 56, Landroid_2Ficu_2Ftext_2FDurationFormat_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormat_3B, formatter, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormat_3B, pformatter, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Fimpl_2Fduration_2FBasicDurationFormat_3B, pfs, 48, 8)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FChineseDateFormat_24Field_3B, 28, Landroid_2Ficu_2Ftext_2FDateFormat_24Field_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCurrencyFormat_3B, 96, Landroid_2Ficu_2Ftext_2FMeasureFormat_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FStringPrepParseException_3B, 88, Ljava_2Ftext_2FParseException_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrepParseException_3B, error, 60, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrepParseException_3B, line, 64, 4)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrepParseException_3B, postContext, 72, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Ftext_2FStringPrepParseException_3B, preContext, 80, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast32_3B, 64, Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast32_3B, dataArray, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast8_3B, 64, Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FCodePointTrie_24Fast8_3B, dataArray, 56, 8)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Small16_3B, 56, Landroid_2Ficu_2Futil_2FCodePointTrie_24Small_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Small32_3B, 56, Landroid_2Ficu_2Futil_2FCodePointTrie_24Small_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FCodePointTrie_24Small8_3B, 56, Landroid_2Ficu_2Futil_2FCodePointTrie_24Small_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FICUException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FICUUncheckedIOException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FIllformedLocaleException_3B, 60, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FIllformedLocaleException_3B, __errIdx, 56, 4)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FRuleBasedTimeZone_3B, 58, Landroid_2Ficu_2Futil_2FBasicTimeZone_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRuleBasedTimeZone_3B, finalRules, 24, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRuleBasedTimeZone_3B, historicRules, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRuleBasedTimeZone_3B, historicTransitions, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRuleBasedTimeZone_3B, initialRule, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRuleBasedTimeZone_3B, isFrozen, 56, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FRuleBasedTimeZone_3B, upToDate, 57, 1)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FUResourceTypeMismatchException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FVTimeZone_3B, 72, Landroid_2Ficu_2Futil_2FBasicTimeZone_3B)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FVTimeZone_3B, isFrozen, 24, 1)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FVTimeZone_3B, lastmod, 32, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FVTimeZone_3B, olsonzid, 40, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FVTimeZone_3B, tz, 48, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FVTimeZone_3B, tzurl, 56, 8)
+__MRT_CLASS_FIELD(Landroid_2Ficu_2Futil_2FVTimeZone_3B, vtzlines, 64, 8)
+__MRT_CLASS(Landroid_2Fsystem_2FGaiException_3B, 72, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FGaiException_3B, error, 56, 4)
+__MRT_CLASS_FIELD(Landroid_2Fsystem_2FGaiException_3B, functionName, 64, 8)
+__MRT_CLASS(Ljava_2Fnet_2FUnknownHostException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FAllocationLimitError_3B, 56, Ljava_2Flang_2FVirtualMachineError_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FBlockGuard_24BlockGuardPolicyException_3B, 72, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FBlockGuard_24BlockGuardPolicyException_3B, mMessage, 56, 8)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FBlockGuard_24BlockGuardPolicyException_3B, mPolicyState, 64, 4)
+__MRT_CLASS_FIELD(Ldalvik_2Fsystem_2FBlockGuard_24BlockGuardPolicyException_3B, mPolicyViolated, 68, 4)
+__MRT_CLASS(Ldalvik_2Fsystem_2FPotentialDeadlockError_3B, 56, Ljava_2Flang_2FVirtualMachineError_3B)
+__MRT_CLASS(Ljava_2Fio_2FBufferedInputStream_3B, 48, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedInputStream_3B, buf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedInputStream_3B, count, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedInputStream_3B, marklimit, 36, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedInputStream_3B, markpos, 40, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FBufferedInputStream_3B, pos, 44, 4)
+__MRT_CLASS(Ljava_2Fio_2FCharConversionException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fio_2FConsole_241_3B, 80, Ljava_2Fio_2FPrintWriter_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FConsole_241_3B, this_240, 72, 8)
+__MRT_CLASS(Ljava_2Fio_2FEOFException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fio_2FExpiringCache_241_3B, 96, Ljava_2Futil_2FLinkedHashMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FExpiringCache_241_3B, this_240, 88, 8)
+__MRT_CLASS(Ljava_2Fio_2FFileNotFoundException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fio_2FFileReader_3B, 40, Ljava_2Fio_2FInputStreamReader_3B)
+__MRT_CLASS(Ljava_2Fio_2FFileWriter_3B, 40, Ljava_2Fio_2FOutputStreamWriter_3B)
+__MRT_CLASS(Ljava_2Fio_2FInterruptedIOException_3B, 60, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FInterruptedIOException_3B, bytesTransferred, 56, 4)
+__MRT_CLASS(Ljava_2Fio_2FLineNumberInputStream_3B, 40, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FLineNumberInputStream_3B, lineNumber, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FLineNumberInputStream_3B, markLineNumber, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FLineNumberInputStream_3B, markPushBack, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FLineNumberInputStream_3B, pushBack, 36, 4)
+__MRT_CLASS(Ljava_2Fio_2FLineNumberReader_3B, 88, Ljava_2Fio_2FBufferedReader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FLineNumberReader_3B, lineNumber, 68, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FLineNumberReader_3B, markedLineNumber, 72, 4)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FLineNumberReader_3B, markedSkipLF, 76, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FLineNumberReader_3B, skipBuffer, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FLineNumberReader_3B, skipLF, 77, 1)
+__MRT_CLASS(Ljava_2Fio_2FPushbackReader_3B, 52, Ljava_2Fio_2FFilterReader_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPushbackReader_3B, buf, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FPushbackReader_3B, pos, 48, 4)
+__MRT_CLASS(Ljava_2Fio_2FSyncFailedException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fio_2FUTFDataFormatException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fio_2FUncheckedIOException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Fio_2FUnsupportedEncodingException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Flang_2FArithmeticException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2FArrayStoreException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2FBootstrapMethodError_3B, 56, Ljava_2Flang_2FLinkageError_3B)
+__MRT_CLASS(Ljava_2Flang_2FClassCircularityError_3B, 56, Ljava_2Flang_2FLinkageError_3B)
+__MRT_CLASS(Ljava_2Flang_2FClassFormatError_3B, 56, Ljava_2Flang_2FLinkageError_3B)
+__MRT_CLASS(Ljava_2Flang_2FEnumConstantNotPresentException_3B, 72, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FEnumConstantNotPresentException_3B, constantName, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FEnumConstantNotPresentException_3B, enumType, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2FExceptionInInitializerError_3B, 64, Ljava_2Flang_2FLinkageError_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FExceptionInInitializerError_3B, exception, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2FIllegalAccessException_3B, 56, Ljava_2Flang_2FReflectiveOperationException_3B)
+__MRT_CLASS(Ljava_2Flang_2FIncompatibleClassChangeError_3B, 56, Ljava_2Flang_2FLinkageError_3B)
+__MRT_CLASS(Ljava_2Flang_2FInstantiationException_3B, 56, Ljava_2Flang_2FReflectiveOperationException_3B)
+__MRT_CLASS(Ljava_2Flang_2FNegativeArraySizeException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2FNoClassDefFoundError_3B, 56, Ljava_2Flang_2FLinkageError_3B)
+__MRT_CLASS(Ljava_2Flang_2FNoSuchFieldException_3B, 56, Ljava_2Flang_2FReflectiveOperationException_3B)
+__MRT_CLASS(Ljava_2Flang_2FNoSuchMethodException_3B, 56, Ljava_2Flang_2FReflectiveOperationException_3B)
+__MRT_CLASS(Ljava_2Flang_2FNullPointerException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2FOutOfMemoryError_3B, 56, Ljava_2Flang_2FVirtualMachineError_3B)
+__MRT_CLASS(Ljava_2Flang_2FSecurityException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2FStackOverflowError_3B, 56, Ljava_2Flang_2FVirtualMachineError_3B)
+__MRT_CLASS(Ljava_2Flang_2FTypeNotPresentException_3B, 64, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2FTypeNotPresentException_3B, typeName, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2FUnknownError_3B, 56, Ljava_2Flang_2FVirtualMachineError_3B)
+__MRT_CLASS(Ljava_2Flang_2FUnsatisfiedLinkError_3B, 56, Ljava_2Flang_2FLinkageError_3B)
+__MRT_CLASS(Ljava_2Flang_2FUnsupportedOperationException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2FVerifyError_3B, 56, Ljava_2Flang_2FLinkageError_3B)
+__MRT_CLASS(Ljava_2Flang_2Fannotation_2FAnnotationTypeMismatchException_3B, 72, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fannotation_2FAnnotationTypeMismatchException_3B, element, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fannotation_2FAnnotationTypeMismatchException_3B, foundType, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2Fannotation_2FIncompleteAnnotationException_3B, 72, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fannotation_2FIncompleteAnnotationException_3B, annotationType, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Fannotation_2FIncompleteAnnotationException_3B, elementName, 64, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FInvocationTargetException_3B, 64, Ljava_2Flang_2FReflectiveOperationException_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FInvocationTargetException_3B, target, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FMalformedParameterizedTypeException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FMalformedParametersException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FUndeclaredThrowableException_3B, 64, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Ljava_2Flang_2Freflect_2FUndeclaredThrowableException_3B, undeclaredThrowable, 56, 8)
+__MRT_CLASS(Ljava_2Fnet_2FHttpRetryException_3B, 68, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpRetryException_3B, location, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnet_2FHttpRetryException_3B, responseCode, 64, 4)
+__MRT_CLASS(Ljava_2Fnet_2FMalformedURLException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fnet_2FProtocolException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fnet_2FUnknownServiceException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fnio_2FBufferOverflowException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Fnio_2FBufferUnderflowException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FClosedChannelException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FFileLockInterruptionException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FInterruptedByTimeoutException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FCharacterCodingException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileSystemAlreadyExistsException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileSystemException_3B, 72, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileSystemException_3B, file, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FFileSystemException_3B, other, 64, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileSystemNotFoundException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FProviderNotFoundException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2Fattribute_2FUserPrincipalNotFoundException_3B, 64, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2Fattribute_2FUserPrincipalNotFoundException_3B, name, 56, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FAuthProvider_3B, 144, Ljava_2Fsecurity_2FProvider_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FDigestException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FDigestInputStream_3B, 33, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FDigestInputStream_3B, digest, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FDigestInputStream_3B, on, 32, 1)
+__MRT_CLASS(Ljava_2Fsecurity_2FDigestOutputStream_3B, 33, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FDigestOutputStream_3B, digest, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FDigestOutputStream_3B, on, 32, 1)
+__MRT_CLASS(Ljava_2Fsecurity_2FInvalidAlgorithmParameterException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyStoreException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FNoSuchProviderException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FProviderException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FSignatureException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FUnrecoverableEntryException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCRLException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertPathBuilderException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificateException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FInvalidKeySpecException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fspec_2FInvalidParameterSpecException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FBatchUpdateException_3B, 88, Ljava_2Fsql_2FSQLException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FBatchUpdateException_3B, updateCounts, 80, 8)
+__MRT_CLASS(Ljava_2Fsql_2FSQLClientInfoException_3B, 88, Ljava_2Fsql_2FSQLException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FSQLClientInfoException_3B, failedProperties, 80, 8)
+__MRT_CLASS(Ljava_2Fsql_2FSQLNonTransientException_3B, 76, Ljava_2Fsql_2FSQLException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLRecoverableException_3B, 76, Ljava_2Fsql_2FSQLException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLTransientException_3B, 76, Ljava_2Fsql_2FSQLException_3B)
+__MRT_CLASS(Ljava_2Futil_2FArrays_24ArrayList_3B, 24, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FArrays_24ArrayList_3B, a, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FBase64_24EncOutputStream_3B, 72, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, b0, 24, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, b1, 28, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, b2, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, base64, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, closed, 36, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, doPadding, 37, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, leftover, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, linemax, 52, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, linepos, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FBase64_24EncOutputStream_3B, newline, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24AsLIFOQueue_3B, 24, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24AsLIFOQueue_3B, q, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedRandomAccessList_3B, 48, Ljava_2Futil_2FCollections_24CheckedList_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedSortedSet_3B, 48, Ljava_2Futil_2FCollections_24CheckedSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedSortedSet_3B, ss, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24EmptyList_3B, 16, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24EmptySet_3B, 12, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SetFromMap_3B, 32, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SetFromMap_3B, m, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SetFromMap_3B, s, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SingletonList_3B, 24, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SingletonList_3B, element, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SingletonSet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SingletonSet_3B, element, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SynchronizedRandomAccessList_3B, 40, Ljava_2Futil_2FCollections_24SynchronizedList_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SynchronizedSortedSet_3B, 40, Ljava_2Futil_2FCollections_24SynchronizedSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedSortedSet_3B, ss, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableRandomAccessList_3B, 32, Ljava_2Futil_2FCollections_24UnmodifiableList_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableSortedSet_3B, 32, Ljava_2Futil_2FCollections_24UnmodifiableSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableSortedSet_3B, ss, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2FConcurrentModificationException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Futil_2FEmptyStackException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_24EntrySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24EntrySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FEnumMap_24KeySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FEnumMap_24KeySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24EntrySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24EntrySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashMap_24KeySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashMap_24KeySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashtable_24EntrySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24EntrySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FHashtable_24KeySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FHashtable_24KeySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24EntrySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24EntrySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FIdentityHashMap_24KeySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIdentityHashMap_24KeySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FIllformedLocaleException_3B, 60, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIllformedLocaleException_3B, __errIdx, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FInvalidPropertiesFormatException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashMap_24LinkedEntrySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedEntrySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FLinkedHashMap_24LinkedKeySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FLinkedHashMap_24LinkedKeySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FMissingResourceException_3B, 72, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FMissingResourceException_3B, className, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FMissingResourceException_3B, key, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FNoSuchElementException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24AscendingSubMap_3B, 88, Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24DescendingSubMap_3B, 96, Ljava_2Futil_2FTreeMap_24NavigableSubMap_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24DescendingSubMap_3B, reverseComparator, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24EntrySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24EntrySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2FWeakHashMap_24KeySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FWeakHashMap_24KeySet_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniRelay_3B, 48, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24UniCompletion_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletionException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachEntryTask_3B, 88, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachEntryTask_3B, action, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachKeyTask_3B, 88, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachKeyTask_3B, action, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachMappingTask_3B, 88, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachMappingTask_3B, action, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedEntryTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedEntryTask_3B, action, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedEntryTask_3B, transformer, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedKeyTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedKeyTask_3B, action, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedKeyTask_3B, transformer, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedMappingTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedMappingTask_3B, action, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedMappingTask_3B, transformer, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedValueTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedValueTask_3B, action, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachTransformedValueTask_3B, transformer, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachValueTask_3B, 88, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ForEachValueTask_3B, action, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesTask_3B, 120, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesTask_3B, nextRight, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesTask_3B, reducer, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesTask_3B, result, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesTask_3B, rights, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesTask_3B, transformer, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToDoubleTask_3B, 128, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToDoubleTask_3B, basis, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToDoubleTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToDoubleTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToDoubleTask_3B, result, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToDoubleTask_3B, rights, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToDoubleTask_3B, transformer, 120, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToIntTask_3B, 120, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToIntTask_3B, basis, 80, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToIntTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToIntTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToIntTask_3B, result, 84, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToIntTask_3B, rights, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToIntTask_3B, transformer, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToLongTask_3B, 128, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToLongTask_3B, basis, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToLongTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToLongTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToLongTask_3B, result, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToLongTask_3B, rights, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceEntriesToLongTask_3B, transformer, 120, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysTask_3B, 120, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysTask_3B, nextRight, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysTask_3B, reducer, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysTask_3B, result, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysTask_3B, rights, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysTask_3B, transformer, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToDoubleTask_3B, 128, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToDoubleTask_3B, basis, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToDoubleTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToDoubleTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToDoubleTask_3B, result, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToDoubleTask_3B, rights, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToDoubleTask_3B, transformer, 120, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToIntTask_3B, 120, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToIntTask_3B, basis, 80, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToIntTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToIntTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToIntTask_3B, result, 84, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToIntTask_3B, rights, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToIntTask_3B, transformer, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToLongTask_3B, 128, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToLongTask_3B, basis, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToLongTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToLongTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToLongTask_3B, result, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToLongTask_3B, rights, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceKeysToLongTask_3B, transformer, 120, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsTask_3B, 120, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsTask_3B, nextRight, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsTask_3B, reducer, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsTask_3B, result, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsTask_3B, rights, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsTask_3B, transformer, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToDoubleTask_3B, 128, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToDoubleTask_3B, basis, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToDoubleTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToDoubleTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToDoubleTask_3B, result, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToDoubleTask_3B, rights, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToDoubleTask_3B, transformer, 120, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToIntTask_3B, 120, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToIntTask_3B, basis, 80, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToIntTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToIntTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToIntTask_3B, result, 84, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToIntTask_3B, rights, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToIntTask_3B, transformer, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToLongTask_3B, 128, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToLongTask_3B, basis, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToLongTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToLongTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToLongTask_3B, result, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToLongTask_3B, rights, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceMappingsToLongTask_3B, transformer, 120, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesTask_3B, 120, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesTask_3B, nextRight, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesTask_3B, reducer, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesTask_3B, result, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesTask_3B, rights, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesTask_3B, transformer, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToDoubleTask_3B, 128, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToDoubleTask_3B, basis, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToDoubleTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToDoubleTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToDoubleTask_3B, result, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToDoubleTask_3B, rights, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToDoubleTask_3B, transformer, 120, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToIntTask_3B, 120, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToIntTask_3B, basis, 80, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToIntTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToIntTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToIntTask_3B, result, 84, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToIntTask_3B, rights, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToIntTask_3B, transformer, 112, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToLongTask_3B, 128, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToLongTask_3B, basis, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToLongTask_3B, nextRight, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToLongTask_3B, reducer, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToLongTask_3B, result, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToLongTask_3B, rights, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24MapReduceValuesToLongTask_3B, transformer, 120, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceEntriesTask_3B, 112, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceEntriesTask_3B, nextRight, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceEntriesTask_3B, reducer, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceEntriesTask_3B, result, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceEntriesTask_3B, rights, 104, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceKeysTask_3B, 112, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceKeysTask_3B, nextRight, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceKeysTask_3B, reducer, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceKeysTask_3B, result, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceKeysTask_3B, rights, 104, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceValuesTask_3B, 112, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceValuesTask_3B, nextRight, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceValuesTask_3B, reducer, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceValuesTask_3B, result, 96, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24ReduceValuesTask_3B, rights, 104, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchEntriesTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchEntriesTask_3B, result, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchEntriesTask_3B, searchFunction, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchKeysTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchKeysTask_3B, result, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchKeysTask_3B, searchFunction, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchMappingsTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchMappingsTask_3B, result, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchMappingsTask_3B, searchFunction, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchValuesTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24BulkTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchValuesTask_3B, result, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentHashMap_24SearchValuesTask_3B, searchFunction, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWSubList_3B, 40, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWSubList_3B, expectedArray, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWSubList_3B, l, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWSubList_3B, offset, 32, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArrayList_24COWSubList_3B, size, 36, 4)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArraySet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FCopyOnWriteArraySet_3B, al, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24DelegatedScheduledExecutorService_3B, 32, Ljava_2Futil_2Fconcurrent_2FExecutors_24DelegatedExecutorService_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FExecutors_24DelegatedScheduledExecutorService_3B, e, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FExecutors_24FinalizableDelegatedExecutorService_3B, 24, Ljava_2Futil_2Fconcurrent_2FExecutors_24DelegatedExecutorService_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FRejectedExecutionException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24ScheduledFutureTask_3B, 96, Ljava_2Futil_2Fconcurrent_2FFutureTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24ScheduledFutureTask_3B, heapIndex, 48, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24ScheduledFutureTask_3B, outerTask, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24ScheduledFutureTask_3B, period, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24ScheduledFutureTask_3B, sequenceNumber, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24ScheduledFutureTask_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FScheduledThreadPoolExecutor_24ScheduledFutureTask_3B, time, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSemaphore_24FairSync_3B, 48, Ljava_2Futil_2Fconcurrent_2FSemaphore_24Sync_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSemaphore_24NonfairSync_3B, 48, Ljava_2Futil_2Fconcurrent_2FSemaphore_24Sync_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_3B, 48, Ljava_2Futil_2FAbstractQueue_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_3B, qlock, 16, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_3B, transferer, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_3B, waitingConsumers, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FSynchronousQueue_3B, waitingProducers, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantLock_24FairSync_3B, 48, Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantLock_24Sync_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantLock_24NonfairSync_3B, 48, Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantLock_24Sync_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24FairSync_3B, 80, Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24NonfairSync_3B, 80, Ljava_2Futil_2Fconcurrent_2Flocks_2FReentrantReadWriteLock_24Sync_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FAbstractShortCircuitTask_3B, 96, Ljava_2Futil_2Fstream_2FAbstractTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractShortCircuitTask_3B, canceled, 80, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FAbstractShortCircuitTask_3B, sharedResult, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FCollectors_24Partition_241_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FCollectors_24Partition_241_3B, this_240, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_241_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_241_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_241_3B, 96, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_241_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_241_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_242_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_242_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_242_3B, 96, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_242_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_242_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_243_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_243_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_243_3B, 96, Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_243_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_243_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_244_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_244_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_244_3B, 96, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_244_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_244_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_247_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_247_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_247_3B, 96, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_247_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_247_3B, val_24predicate, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_248_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_248_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_248_3B, 96, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_248_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_248_3B, val_24action, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_24Head_3B, 80, Ljava_2Futil_2Fstream_2FDoublePipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_24StatefulOp_3B, 80, Ljava_2Futil_2Fstream_2FDoublePipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FFindOps_24FindSink_24OfDouble_3B, 24, Ljava_2Futil_2Fstream_2FFindOps_24FindSink_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FFindOps_24FindSink_24OfInt_3B, 24, Ljava_2Futil_2Fstream_2FFindOps_24FindSink_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FFindOps_24FindSink_24OfLong_3B, 24, Ljava_2Futil_2Fstream_2FFindOps_24FindSink_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FFindOps_24FindSink_24OfRef_3B, 24, Ljava_2Futil_2Fstream_2FFindOps_24FindSink_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_24OfDouble_3B, 24, Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_24OfDouble_3B, consumer, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_24OfInt_3B, 24, Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_24OfInt_3B, consumer, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_24OfLong_3B, 24, Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_24OfLong_3B, consumer, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_24OfRef_3B, 24, Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FForEachOps_24ForEachOp_24OfRef_3B, consumer, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_241_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_241_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_241_3B, 88, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_241_3B, this_240, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_2410_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_2410_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_2410_3B, 96, Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_2410_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_2410_3B, val_24action, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_242_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_242_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_242_3B, 88, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_242_3B, this_240, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_243_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_243_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_243_3B, 96, Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_243_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_243_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_244_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_244_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_244_3B, 96, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_244_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_244_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_245_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_245_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_245_3B, 96, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_245_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_245_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_246_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_246_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_246_3B, 96, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_246_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_246_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_249_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_249_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_249_3B, 96, Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_249_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_249_3B, val_24predicate, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_24Head_3B, 80, Ljava_2Futil_2Fstream_2FIntPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_24StatefulOp_3B, 80, Ljava_2Futil_2Fstream_2FIntPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_241_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_241_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_241_3B, 88, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_241_3B, this_240, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_242_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_242_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_242_3B, 96, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_242_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_242_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_243_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_243_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_243_3B, 96, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_243_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_243_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_244_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_244_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_244_3B, 96, Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_244_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_244_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_245_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_245_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_245_3B, 96, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_245_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_245_3B, val_24mapper, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_248_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_248_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_248_3B, 96, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_248_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_248_3B, val_24predicate, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_249_241_3B, 32, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_249_241_3B, this_241, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_249_3B, 96, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_249_3B, this_240, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_249_3B, val_24action, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_24Head_3B, 80, Ljava_2Futil_2Fstream_2FLongPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_24StatefulOp_3B, 80, Ljava_2Futil_2Fstream_2FLongPipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_3B, 104, Ljava_2Futil_2Fstream_2FAbstractTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_3B, builderFactory, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_3B, concFactory, 88, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_3B, helper, 96, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24DoubleFixedNodeBuilder_3B, 24, Ljava_2Futil_2Fstream_2FNodes_24DoubleArrayNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24DoubleSpinedNodeBuilder_3B, 49, Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24DoubleSpinedNodeBuilder_3B, building, 48, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24IntFixedNodeBuilder_3B, 24, Ljava_2Futil_2Fstream_2FNodes_24IntArrayNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24IntSpinedNodeBuilder_3B, 49, Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24IntSpinedNodeBuilder_3B, building, 48, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24LongFixedNodeBuilder_3B, 24, Ljava_2Futil_2Fstream_2FNodes_24LongArrayNode_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24LongSpinedNodeBuilder_3B, 49, Ljava_2Futil_2Fstream_2FSpinedBuffer_24OfLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24LongSpinedNodeBuilder_3B, building, 48, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_24OfDouble_3B, 88, Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_24OfDouble_3B, array, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_24OfInt_3B, 88, Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_24OfInt_3B, array, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_24OfLong_3B, 88, Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_24OfLong_3B, array, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_24OfRef_3B, 88, Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24SizedCollectorTask_24OfRef_3B, array, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfPrimitive_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfPrimitive_3B, array, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfRef_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfRef_3B, array, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReduceOps_24ReduceTask_3B, 88, Ljava_2Futil_2Fstream_2FAbstractTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReduceOps_24ReduceTask_3B, op, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_24Head_3B, 80, Ljava_2Futil_2Fstream_2FReferencePipeline_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_242_241_3B, 48, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_242_241_3B, m, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_242_241_3B, n, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_242_241_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_242_3B, 96, Ljava_2Futil_2Fstream_2FIntPipeline_24StatefulOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_242_3B, val_24limit, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_242_3B, val_24skip, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_243_241_3B, 48, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_243_241_3B, m, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_243_241_3B, n, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_243_241_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_243_3B, 96, Ljava_2Futil_2Fstream_2FLongPipeline_24StatefulOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_243_3B, val_24limit, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_243_3B, val_24skip, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_244_241_3B, 48, Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_244_241_3B, m, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_244_241_3B, n, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_244_241_3B, this_240, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_244_3B, 96, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatefulOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_244_3B, val_24limit, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_244_3B, val_24skip, 88, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24AbstractDoubleSortingSink_3B, 25, Ljava_2Futil_2Fstream_2FSink_24ChainedDouble_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24AbstractDoubleSortingSink_3B, cancellationWasRequested, 24, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24AbstractIntSortingSink_3B, 25, Ljava_2Futil_2Fstream_2FSink_24ChainedInt_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24AbstractIntSortingSink_3B, cancellationWasRequested, 24, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24AbstractLongSortingSink_3B, 25, Ljava_2Futil_2Fstream_2FSink_24ChainedLong_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24AbstractLongSortingSink_3B, cancellationWasRequested, 24, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24RefSortingSink_3B, 48, Ljava_2Futil_2Fstream_2FSortedOps_24AbstractRefSortingSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24RefSortingSink_3B, list, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24SizedRefSortingSink_3B, 52, Ljava_2Futil_2Fstream_2FSortedOps_24AbstractRefSortingSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24SizedRefSortingSink_3B, array, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24SizedRefSortingSink_3B, offset, 48, 4)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FCheckedInputStream_3B, 32, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FCheckedInputStream_3B, cksum, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FCheckedOutputStream_3B, 32, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FCheckedOutputStream_3B, cksum, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FDeflaterInputStream_3B, 50, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterInputStream_3B, buf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterInputStream_3B, def, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterInputStream_3B, rbuf, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterInputStream_3B, reachEOF, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FDeflaterInputStream_3B, usesDefaultDeflater, 49, 1)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FGZIPInputStream_241_3B, 32, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FGZIPInputStream_241_3B, this_240, 24, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FGZIPInputStream_3B, 88, Ljava_2Futil_2Fzip_2FInflaterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FGZIPInputStream_3B, closed, 64, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FGZIPInputStream_3B, crc, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FGZIPInputStream_3B, eos, 65, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FGZIPInputStream_3B, tmpbuf, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FInflaterOutputStream_3B, 56, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterOutputStream_3B, buf, 24, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterOutputStream_3B, closed, 32, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterOutputStream_3B, inf, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterOutputStream_3B, usesDefaultInflater, 33, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FInflaterOutputStream_3B, wbuf, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FBadPaddingException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipherInputStream_3B, 68, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherInputStream_3B, cipher, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherInputStream_3B, closed, 32, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherInputStream_3B, done, 33, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherInputStream_3B, ibuffer, 40, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherInputStream_3B, input, 48, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherInputStream_3B, obuffer, 56, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherInputStream_3B, ofinish, 36, 4)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherInputStream_3B, ostart, 64, 4)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCipherOutputStream_3B, 64, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherOutputStream_3B, cipher, 24, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherOutputStream_3B, closed, 32, 1)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherOutputStream_3B, ibuffer, 40, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherOutputStream_3B, obuffer, 48, 8)
+__MRT_CLASS_FIELD(Ljavax_2Fcrypto_2FCipherOutputStream_3B, output, 56, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FCryptoPolicyParser_24ParsingException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FExemptionMechanismException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FIllegalBlockSizeException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FNoSuchPaddingException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FShortBufferException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljavax_2Fcrypto_2FextObjectInputStream_3B, 64, Ljava_2Fio_2FObjectInputStream_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fauth_2Flogin_2FLoginException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fcert_2FCertificateEncodingException_3B, 56, Ljavax_2Fsecurity_2Fcert_2FCertificateException_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fcert_2FCertificateExpiredException_3B, 56, Ljavax_2Fsecurity_2Fcert_2FCertificateException_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fcert_2FCertificateNotYetValidException_3B, 56, Ljavax_2Fsecurity_2Fcert_2FCertificateException_3B)
+__MRT_CLASS(Ljavax_2Fsecurity_2Fcert_2FCertificateParsingException_3B, 56, Ljavax_2Fsecurity_2Fcert_2FCertificateException_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Ftransform_2FTransformerConfigurationException_3B, 72, Ljavax_2Fxml_2Ftransform_2FTransformerException_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fxpath_2FXPathExpressionException_3B, 64, Ljavax_2Fxml_2Fxpath_2FXPathException_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fxpath_2FXPathFactoryConfigurationException_3B, 64, Ljavax_2Fxml_2Fxpath_2FXPathException_3B)
+__MRT_CLASS(Llibcore_2Fio_2FClassPathURLStreamHandler_24ClassPathURLConnection_241_3B, 32, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Llibcore_2Fio_2FClassPathURLStreamHandler_24ClassPathURLConnection_241_3B, this_241, 24, 8)
+__MRT_CLASS(Lorg_2Fw3c_2Fdom_2FDOMException_3B, 58, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Lorg_2Fw3c_2Fdom_2FDOMException_3B, code, 56, 2)
+__MRT_CLASS(Lorg_2Fw3c_2Fdom_2Fls_2FLSException_3B, 58, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS_FIELD(Lorg_2Fw3c_2Fdom_2Fls_2FLSException_3B, code, 56, 2)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2FSAXNotRecognizedException_3B, 64, Lorg_2Fxml_2Fsax_2FSAXException_3B)
+__MRT_CLASS(Lorg_2Fxml_2Fsax_2FSAXNotSupportedException_3B, 64, Lorg_2Fxml_2Fsax_2FSAXException_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FCEFormatException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FCEStreamExhausted_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Lsun_2Fmisc_2FInvalidJarIndexException_3B, 56, Ljava_2Flang_2FRuntimeException_3B)
+__MRT_CLASS(Lsun_2Fnet_2FTelnetInputStream_3B, 27, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FTelnetInputStream_3B, binaryMode, 24, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FTelnetInputStream_3B, seenCR, 25, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FTelnetInputStream_3B, stickyCRLF, 26, 1)
+__MRT_CLASS(Lsun_2Fnet_2FTelnetProtocolException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fftp_2FFtpLoginException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2FMeteredStream_3B, 64, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMeteredStream_3B, closed, 24, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMeteredStream_3B, count, 32, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMeteredStream_3B, expected, 40, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMeteredStream_3B, markLimit, 28, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMeteredStream_3B, markedCount, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2FMeteredStream_3B, pi, 56, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_24FtpInputStream_3B, 40, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_24FtpInputStream_3B, ftp, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_24FtpInputStream_3B, this_240, 32, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_24FtpOutputStream_3B, 40, Ljava_2Fio_2FFilterOutputStream_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_24FtpOutputStream_3B, ftp, 24, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fftp_2FFtpURLConnection_24FtpOutputStream_3B, this_240, 32, 8)
+__MRT_CLASS(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_24JarURLInputStream_3B, 32, Ljava_2Fio_2FFilterInputStream_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2Fwww_2Fprotocol_2Fjar_2FJarURLConnection_24JarURLInputStream_3B, this_240, 24, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSocketAdaptor_24SocketInputStream_3B, 56, Lsun_2Fnio_2Fch_2FChannelInputStream_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSocketAdaptor_24SocketInputStream_3B, this_240, 48, 8)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FLinuxUserDefinedFileAttributeView_3B, 24, Lsun_2Fnio_2Ffs_2FAbstractUserDefinedFileAttributeView_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxUserDefinedFileAttributeView_3B, file, 16, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FLinuxUserDefinedFileAttributeView_3B, followLinks, 12, 1)
+__MRT_CLASS(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_24PosixFileAttributeViewImpl_3B, 40, Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_24BasicFileAttributeViewImpl_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Ffs_2FUnixSecureDirectoryStream_24PosixFileAttributeViewImpl_3B, this_240, 32, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fjca_2FProviderList_243_3B, 24, Ljava_2Futil_2FAbstractList_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fjca_2FProviderList_243_3B, this_240, 16, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_24VerbatimX509Certificate_3B, 56, Lsun_2Fsecurity_2Fpkcs_2FPKCS7_24WrappedX509Certificate_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fpkcs_2FPKCS7_24VerbatimX509Certificate_3B, encodedVerbatim, 48, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fpkcs_2FParsingException_3B, 56, Ljava_2Fio_2FIOException_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2FCertPathProvider_3B, 144, Ljava_2Fsecurity_2FProvider_3B)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilderResult_3B, 56, Ljava_2Fsecurity_2Fcert_2FPKIXCertPathBuilderResult_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilderResult_3B, adjList, 48, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Futil_2FPropertyExpander_24ExpandException_3B, 56, Ljava_2Fsecurity_2FGeneralSecurityException_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceArray_3B, 96, Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceContainer_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceTable_3B, 96, Landroid_2Ficu_2Fimpl_2FICUResourceBundleImpl_24ResourceContainer_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fimpl_2FIllegalIcuArgumentException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Landroid_2Ficu_2Fnumber_2FSkeletonSyntaxException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FChineseDateFormat_3B, 184, Landroid_2Ficu_2Ftext_2FSimpleDateFormat_3B)
+__MRT_CLASS(Landroid_2Ficu_2Ftext_2FCompactDecimalFormat_3B, 136, Landroid_2Ficu_2Ftext_2FDecimalFormat_3B)
+__MRT_CLASS(Landroid_2Ficu_2Futil_2FICUCloneNotSupportedException_3B, 56, Landroid_2Ficu_2Futil_2FICUException_3B)
+__MRT_CLASS(Ldalvik_2Fsystem_2FTransactionAbortError_3B, 56, Ljava_2Flang_2FInternalError_3B)
+__MRT_CLASS(Ljava_2Fio_2FInvalidObjectException_3B, 56, Ljava_2Fio_2FObjectStreamException_3B)
+__MRT_CLASS(Ljava_2Fio_2FNotActiveException_3B, 56, Ljava_2Fio_2FObjectStreamException_3B)
+__MRT_CLASS(Ljava_2Fio_2FNotSerializableException_3B, 56, Ljava_2Fio_2FObjectStreamException_3B)
+__MRT_CLASS(Ljava_2Fio_2FOptionalDataException_3B, 64, Ljava_2Fio_2FObjectStreamException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FOptionalDataException_3B, eof, 56, 1)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FOptionalDataException_3B, length, 60, 4)
+__MRT_CLASS(Ljava_2Fio_2FStreamCorruptedException_3B, 56, Ljava_2Fio_2FObjectStreamException_3B)
+__MRT_CLASS(Ljava_2Fio_2FWriteAbortedException_3B, 64, Ljava_2Fio_2FObjectStreamException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fio_2FWriteAbortedException_3B, detail, 56, 8)
+__MRT_CLASS(Ljava_2Flang_2FAbstractMethodError_3B, 56, Ljava_2Flang_2FIncompatibleClassChangeError_3B)
+__MRT_CLASS(Ljava_2Flang_2FArrayIndexOutOfBoundsException_3B, 56, Ljava_2Flang_2FIndexOutOfBoundsException_3B)
+__MRT_CLASS(Ljava_2Flang_2FIllegalAccessError_3B, 56, Ljava_2Flang_2FIncompatibleClassChangeError_3B)
+__MRT_CLASS(Ljava_2Flang_2FIllegalThreadStateException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Ljava_2Flang_2FInstantiationError_3B, 56, Ljava_2Flang_2FIncompatibleClassChangeError_3B)
+__MRT_CLASS(Ljava_2Flang_2FNoSuchFieldError_3B, 56, Ljava_2Flang_2FIncompatibleClassChangeError_3B)
+__MRT_CLASS(Ljava_2Flang_2FNoSuchMethodError_3B, 56, Ljava_2Flang_2FIncompatibleClassChangeError_3B)
+__MRT_CLASS(Ljava_2Flang_2FStringIndexOutOfBoundsException_3B, 56, Ljava_2Flang_2FIndexOutOfBoundsException_3B)
+__MRT_CLASS(Ljava_2Flang_2FUNIXProcess_24ProcessPipeInputStream_3B, 48, Ljava_2Fio_2FBufferedInputStream_3B)
+__MRT_CLASS(Ljava_2Flang_2FUNIXProcess_24ProcessPipeOutputStream_3B, 36, Ljava_2Fio_2FBufferedOutputStream_3B)
+__MRT_CLASS(Ljava_2Flang_2FUnsupportedClassVersionError_3B, 56, Ljava_2Flang_2FClassFormatError_3B)
+__MRT_CLASS(Ljava_2Flang_2Freflect_2FGenericSignatureFormatError_3B, 56, Ljava_2Flang_2FClassFormatError_3B)
+__MRT_CLASS(Ljava_2Fnet_2FBindException_3B, 56, Ljava_2Fnet_2FSocketException_3B)
+__MRT_CLASS(Ljava_2Fnet_2FConnectException_3B, 56, Ljava_2Fnet_2FSocketException_3B)
+__MRT_CLASS(Ljava_2Fnet_2FNoRouteToHostException_3B, 56, Ljava_2Fnet_2FSocketException_3B)
+__MRT_CLASS(Ljava_2Fnet_2FPortUnreachableException_3B, 56, Ljava_2Fnet_2FSocketException_3B)
+__MRT_CLASS(Ljava_2Fnet_2FSocketTimeoutException_3B, 60, Ljava_2Fio_2FInterruptedIOException_3B)
+__MRT_CLASS(Ljava_2Fnio_2FInvalidMarkException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2FReadOnlyBufferException_3B, 56, Ljava_2Flang_2FUnsupportedOperationException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FAcceptPendingException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FAlreadyBoundException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FAlreadyConnectedException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FAsynchronousCloseException_3B, 56, Ljava_2Fnio_2Fchannels_2FClosedChannelException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FCancelledKeyException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FChannels_24ReadableByteChannelImpl_3B, 72, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_24ReadableByteChannelImpl_3B, buf, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_24ReadableByteChannelImpl_3B, in, 48, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_24ReadableByteChannelImpl_3B, open, 56, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_24ReadableByteChannelImpl_3B, readLock, 64, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FChannels_24WritableByteChannelImpl_3B, 72, Ljava_2Fnio_2Fchannels_2Fspi_2FAbstractInterruptibleChannel_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_24WritableByteChannelImpl_3B, buf, 40, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_24WritableByteChannelImpl_3B, open, 48, 1)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_24WritableByteChannelImpl_3B, out, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fchannels_2FChannels_24WritableByteChannelImpl_3B, writeLock, 64, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FClosedSelectorException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FConnectionPendingException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FIllegalBlockingModeException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FIllegalChannelGroupException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FIllegalSelectorException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FNoConnectionPendingException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FNonReadableChannelException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FNonWritableChannelException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FNotYetBoundException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FNotYetConnectedException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FOverlappingFileLockException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FReadPendingException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FShutdownChannelGroupException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FUnresolvedAddressException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FUnsupportedAddressTypeException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FWritePendingException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FIllegalCharsetNameException_3B, 64, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FIllegalCharsetNameException_3B, charsetName, 56, 8)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FMalformedInputException_3B, 60, Ljava_2Fnio_2Fcharset_2FCharacterCodingException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FMalformedInputException_3B, inputLength, 56, 4)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FUnmappableCharacterException_3B, 60, Ljava_2Fnio_2Fcharset_2FCharacterCodingException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FUnmappableCharacterException_3B, inputLength, 56, 4)
+__MRT_CLASS(Ljava_2Fnio_2Fcharset_2FUnsupportedCharsetException_3B, 64, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Fcharset_2FUnsupportedCharsetException_3B, charsetName, 56, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FAccessDeniedException_3B, 72, Ljava_2Fnio_2Ffile_2FFileSystemException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FAtomicMoveNotSupportedException_3B, 72, Ljava_2Fnio_2Ffile_2FFileSystemException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FClosedDirectoryStreamException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FClosedFileSystemException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FClosedWatchServiceException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FDirectoryIteratorException_3B, 56, Ljava_2Futil_2FConcurrentModificationException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FDirectoryNotEmptyException_3B, 72, Ljava_2Fnio_2Ffile_2FFileSystemException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileAlreadyExistsException_3B, 72, Ljava_2Fnio_2Ffile_2FFileSystemException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FFileSystemLoopException_3B, 72, Ljava_2Fnio_2Ffile_2FFileSystemException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FInvalidPathException_3B, 72, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FInvalidPathException_3B, index, 56, 4)
+__MRT_CLASS_FIELD(Ljava_2Fnio_2Ffile_2FInvalidPathException_3B, input, 64, 8)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FNoSuchFileException_3B, 72, Ljava_2Fnio_2Ffile_2FFileSystemException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FNotDirectoryException_3B, 72, Ljava_2Fnio_2Ffile_2FFileSystemException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FNotLinkException_3B, 72, Ljava_2Fnio_2Ffile_2FFileSystemException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FProviderMismatchException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Ljava_2Fnio_2Ffile_2FReadOnlyFileSystemException_3B, 56, Ljava_2Flang_2FUnsupportedOperationException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FAccessControlException_3B, 64, Ljava_2Flang_2FSecurityException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2FAccessControlException_3B, perm, 56, 8)
+__MRT_CLASS(Ljava_2Fsecurity_2FInvalidKeyException_3B, 56, Ljava_2Fsecurity_2FKeyException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FInvalidParameterException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FKeyManagementException_3B, 56, Ljava_2Fsecurity_2FKeyException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2FUnrecoverableKeyException_3B, 56, Ljava_2Fsecurity_2FUnrecoverableEntryException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificateEncodingException_3B, 56, Ljava_2Fsecurity_2Fcert_2FCertificateException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificateExpiredException_3B, 56, Ljava_2Fsecurity_2Fcert_2FCertificateException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificateNotYetValidException_3B, 56, Ljava_2Fsecurity_2Fcert_2FCertificateException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificateParsingException_3B, 56, Ljava_2Fsecurity_2Fcert_2FCertificateException_3B)
+__MRT_CLASS(Ljava_2Fsecurity_2Fcert_2FCertificateRevokedException_3B, 88, Ljava_2Fsecurity_2Fcert_2FCertificateException_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificateRevokedException_3B, authority, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificateRevokedException_3B, extensions, 64, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificateRevokedException_3B, reason, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Fsecurity_2Fcert_2FCertificateRevokedException_3B, revocationDate, 80, 8)
+__MRT_CLASS(Ljava_2Fsql_2FDataTruncation_3B, 92, Ljava_2Fsql_2FSQLWarning_3B)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDataTruncation_3B, dataSize, 76, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDataTruncation_3B, index, 80, 4)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDataTruncation_3B, parameter, 84, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDataTruncation_3B, read, 85, 1)
+__MRT_CLASS_FIELD(Ljava_2Fsql_2FDataTruncation_3B, transferSize, 88, 4)
+__MRT_CLASS(Ljava_2Fsql_2FSQLDataException_3B, 76, Ljava_2Fsql_2FSQLNonTransientException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLFeatureNotSupportedException_3B, 76, Ljava_2Fsql_2FSQLNonTransientException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLIntegrityConstraintViolationException_3B, 76, Ljava_2Fsql_2FSQLNonTransientException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLInvalidAuthorizationSpecException_3B, 76, Ljava_2Fsql_2FSQLNonTransientException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLNonTransientConnectionException_3B, 76, Ljava_2Fsql_2FSQLNonTransientException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLSyntaxErrorException_3B, 76, Ljava_2Fsql_2FSQLNonTransientException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLTimeoutException_3B, 76, Ljava_2Fsql_2FSQLTransientException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLTransactionRollbackException_3B, 76, Ljava_2Fsql_2FSQLTransientException_3B)
+__MRT_CLASS(Ljava_2Fsql_2FSQLTransientConnectionException_3B, 76, Ljava_2Fsql_2FSQLTransientException_3B)
+__MRT_CLASS(Ljava_2Ftime_2Ftemporal_2FUnsupportedTemporalTypeException_3B, 56, Ljava_2Ftime_2FDateTimeException_3B)
+__MRT_CLASS(Ljava_2Ftime_2Fzone_2FZoneRulesException_3B, 56, Ljava_2Ftime_2FDateTimeException_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24CheckedNavigableSet_3B, 56, Ljava_2Futil_2FCollections_24CheckedSortedSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24CheckedNavigableSet_3B, ns, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24SynchronizedNavigableSet_3B, 48, Ljava_2Futil_2FCollections_24SynchronizedSortedSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24SynchronizedNavigableSet_3B, ns, 40, 8)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableNavigableSet_3B, 40, Ljava_2Futil_2FCollections_24UnmodifiableSortedSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FCollections_24UnmodifiableNavigableSet_3B, ns, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FFormatterClosedException_3B, 56, Ljava_2Flang_2FIllegalStateException_3B)
+__MRT_CLASS(Ljava_2Futil_2FIllegalFormatException_3B, 56, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS(Ljava_2Futil_2FInputMismatchException_3B, 56, Ljava_2Futil_2FNoSuchElementException_3B)
+__MRT_CLASS(Ljava_2Futil_2FRandomAccessSubList_3B, 32, Ljava_2Futil_2FSubList_3B)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24AscendingSubMap_24AscendingEntrySetView_3B, 40, Ljava_2Futil_2FTreeMap_24NavigableSubMap_24EntrySetView_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24AscendingSubMap_24AscendingEntrySetView_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2FTreeMap_24DescendingSubMap_24DescendingEntrySetView_3B, 40, Ljava_2Futil_2FTreeMap_24NavigableSubMap_24EntrySetView_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FTreeMap_24DescendingSubMap_24DescendingEntrySetView_3B, this_240, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiRelay_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24OrRelay_3B, 56, Ljava_2Futil_2Fconcurrent_2FCompletableFuture_24BiCompletion_3B)
+__MRT_CLASS(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListSet_3B, 24, Ljava_2Futil_2FAbstractSet_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fconcurrent_2FConcurrentSkipListSet_3B, m, 16, 8)
+__MRT_CLASS(Ljava_2Futil_2Fjar_2FJarException_3B, 56, Ljava_2Futil_2Fzip_2FZipException_3B)
+__MRT_CLASS(Ljava_2Futil_2Fregex_2FPatternSyntaxException_3B, 80, Ljava_2Flang_2FIllegalArgumentException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPatternSyntaxException_3B, desc, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPatternSyntaxException_3B, index, 64, 4)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fregex_2FPatternSyntaxException_3B, pattern, 72, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FDoublePipeline_246_3B, 88, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FDoublePipeline_246_3B, this_240, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FFindOps_24FindTask_3B, 104, Ljava_2Futil_2Fstream_2FAbstractShortCircuitTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FFindOps_24FindTask_3B, op, 96, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FIntPipeline_248_3B, 88, Ljava_2Futil_2Fstream_2FIntPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FIntPipeline_248_3B, this_240, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FLongPipeline_247_3B, 88, Ljava_2Futil_2Fstream_2FLongPipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FLongPipeline_247_3B, this_240, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FMatchOps_24MatchTask_3B, 104, Ljava_2Futil_2Fstream_2FAbstractShortCircuitTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FMatchOps_24MatchTask_3B, op, 96, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_24OfDouble_3B, 104, Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_24OfInt_3B, 104, Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_24OfLong_3B, 104, Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_24OfRef_3B, 104, Ljava_2Futil_2Fstream_2FNodes_24CollectorTask_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfDouble_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfInt_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfLong_3B, 48, Ljava_2Futil_2Fstream_2FNodes_24ToArrayTask_24OfPrimitive_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FReferencePipeline_241_3B, 88, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatelessOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FReferencePipeline_241_3B, this_240, 80, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSliceOps_24SliceTask_3B, 144, Ljava_2Futil_2Fstream_2FAbstractShortCircuitTask_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_24SliceTask_3B, completed, 96, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_24SliceTask_3B, generator, 104, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_24SliceTask_3B, op, 112, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_24SliceTask_3B, targetOffset, 120, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_24SliceTask_3B, targetSize, 128, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSliceOps_24SliceTask_3B, thisNodeSize, 136, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24DoubleSortingSink_3B, 40, Ljava_2Futil_2Fstream_2FSortedOps_24AbstractDoubleSortingSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24DoubleSortingSink_3B, b, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24IntSortingSink_3B, 40, Ljava_2Futil_2Fstream_2FSortedOps_24AbstractIntSortingSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24IntSortingSink_3B, b, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24LongSortingSink_3B, 40, Ljava_2Futil_2Fstream_2FSortedOps_24AbstractLongSortingSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24LongSortingSink_3B, b, 32, 8)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24OfDouble_3B, 80, Ljava_2Futil_2Fstream_2FDoublePipeline_24StatefulOp_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24OfInt_3B, 80, Ljava_2Futil_2Fstream_2FIntPipeline_24StatefulOp_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24OfLong_3B, 80, Ljava_2Futil_2Fstream_2FLongPipeline_24StatefulOp_3B)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24OfRef_3B, 89, Ljava_2Futil_2Fstream_2FReferencePipeline_24StatefulOp_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24OfRef_3B, comparator, 80, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24OfRef_3B, isNaturalSort, 88, 1)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24SizedDoubleSortingSink_3B, 40, Ljava_2Futil_2Fstream_2FSortedOps_24AbstractDoubleSortingSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24SizedDoubleSortingSink_3B, array, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24SizedDoubleSortingSink_3B, offset, 28, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24SizedIntSortingSink_3B, 40, Ljava_2Futil_2Fstream_2FSortedOps_24AbstractIntSortingSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24SizedIntSortingSink_3B, array, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24SizedIntSortingSink_3B, offset, 28, 4)
+__MRT_CLASS(Ljava_2Futil_2Fstream_2FSortedOps_24SizedLongSortingSink_3B, 40, Ljava_2Futil_2Fstream_2FSortedOps_24AbstractLongSortingSink_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24SizedLongSortingSink_3B, array, 32, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fstream_2FSortedOps_24SizedLongSortingSink_3B, offset, 28, 4)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FGZIPOutputStream_3B, 56, Ljava_2Futil_2Fzip_2FDeflaterOutputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FGZIPOutputStream_3B, crc, 48, 8)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipError_3B, 56, Ljava_2Flang_2FInternalError_3B)
+__MRT_CLASS(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInflaterInputStream_3B, 88, Ljava_2Futil_2Fzip_2FInflaterInputStream_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInflaterInputStream_3B, closeRequested, 64, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInflaterInputStream_3B, eof, 65, 1)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInflaterInputStream_3B, this_240, 72, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2Fzip_2FZipFile_24ZipFileInflaterInputStream_3B, zfin, 80, 8)
+__MRT_CLASS(Ljavax_2Fcrypto_2FAEADBadTagException_3B, 56, Ljavax_2Fcrypto_2FBadPaddingException_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLHandshakeException_3B, 56, Ljavax_2Fnet_2Fssl_2FSSLException_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLKeyException_3B, 56, Ljavax_2Fnet_2Fssl_2FSSLException_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLPeerUnverifiedException_3B, 56, Ljavax_2Fnet_2Fssl_2FSSLException_3B)
+__MRT_CLASS(Ljavax_2Fnet_2Fssl_2FSSLProtocolException_3B, 56, Ljavax_2Fnet_2Fssl_2FSSLException_3B)
+__MRT_CLASS(Ljavax_2Fxml_2Fxpath_2FXPathFunctionException_3B, 64, Ljavax_2Fxml_2Fxpath_2FXPathExpressionException_3B)
+__MRT_CLASS(Lorg_2Fapache_2Fharmony_2Fxml_2FExpatParser_24ParseException_3B, 88, Lorg_2Fxml_2Fsax_2FSAXParseException_3B)
+__MRT_CLASS(Lsun_2Fnet_2FConnectionResetException_3B, 56, Ljava_2Fnet_2FSocketException_3B)
+__MRT_CLASS(Lsun_2Fnet_2FTelnetOutputStream_3B, 39, Ljava_2Fio_2FBufferedOutputStream_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FTelnetOutputStream_3B, binaryMode, 36, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FTelnetOutputStream_3B, seenCR, 37, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnet_2FTelnetOutputStream_3B, stickyCRLF, 38, 1)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FAbstractPollSelectorImpl_3B, 120, Lsun_2Fnio_2Fch_2FSelectorImpl_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollSelectorImpl_3B, INIT__CAP, 80, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollSelectorImpl_3B, channelArray, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollSelectorImpl_3B, channelOffset, 84, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollSelectorImpl_3B, closeLock, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollSelectorImpl_3B, closed, 104, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollSelectorImpl_3B, pollWrapper, 112, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FAbstractPollSelectorImpl_3B, totalChannels, 108, 4)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24CertStoreTypeException_3B, 64, Ljava_2Fsecurity_2Fcert_2FCertStoreException_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FPKIX_24CertStoreTypeException_3B, type, 56, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilderException_3B, 64, Ljava_2Fsecurity_2Fcert_2FCertPathBuilderException_3B)
+__MRT_CLASS_FIELD(Lsun_2Fsecurity_2Fprovider_2Fcertpath_2FSunCertPathBuilderException_3B, adjList, 56, 8)
+__MRT_CLASS(Lsun_2Fsecurity_2Fx509_2FAttributeNameEnumeration_3B, 32, Ljava_2Futil_2FVector_3B)
+__MRT_CLASS(Ljava_2Fnio_2Fchannels_2FClosedByInterruptException_3B, 56, Ljava_2Fnio_2Fchannels_2FAsynchronousCloseException_3B)
+__MRT_CLASS(Ljava_2Futil_2FCollections_24UnmodifiableNavigableSet_24EmptyNavigableSet_3B, 40, Ljava_2Futil_2FCollections_24UnmodifiableNavigableSet_3B)
+__MRT_CLASS(Ljava_2Futil_2FDuplicateFormatFlagsException_3B, 64, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FDuplicateFormatFlagsException_3B, flags, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FFormatFlagsConversionMismatchException_3B, 72, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatFlagsConversionMismatchException_3B, c, 56, 2)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FFormatFlagsConversionMismatchException_3B, f, 64, 8)
+__MRT_CLASS(Ljava_2Futil_2FIllegalFormatCodePointException_3B, 60, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIllegalFormatCodePointException_3B, c, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FIllegalFormatConversionException_3B, 66, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIllegalFormatConversionException_3B, arg, 56, 8)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIllegalFormatConversionException_3B, c, 64, 2)
+__MRT_CLASS(Ljava_2Futil_2FIllegalFormatFlagsException_3B, 64, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIllegalFormatFlagsException_3B, flags, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FIllegalFormatPrecisionException_3B, 60, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIllegalFormatPrecisionException_3B, p, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FIllegalFormatWidthException_3B, 60, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FIllegalFormatWidthException_3B, w, 56, 4)
+__MRT_CLASS(Ljava_2Futil_2FMissingFormatArgumentException_3B, 64, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FMissingFormatArgumentException_3B, s, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FMissingFormatWidthException_3B, 64, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FMissingFormatWidthException_3B, s, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FUnknownFormatConversionException_3B, 64, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FUnknownFormatConversionException_3B, s, 56, 8)
+__MRT_CLASS(Ljava_2Futil_2FUnknownFormatFlagsException_3B, 64, Ljava_2Futil_2FIllegalFormatException_3B)
+__MRT_CLASS_FIELD(Ljava_2Futil_2FUnknownFormatFlagsException_3B, flags, 56, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FPollSelectorImpl_3B, 137, Lsun_2Fnio_2Fch_2FAbstractPollSelectorImpl_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPollSelectorImpl_3B, fd0, 120, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPollSelectorImpl_3B, fd1, 124, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPollSelectorImpl_3B, interruptLock, 128, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FPollSelectorImpl_3B, interruptTriggered, 136, 1)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, 112, Ljava_2Fnio_2Fchannels_2FFileChannel_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, append, 40, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, fd, 48, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, fileLockTable, 56, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, guard, 64, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, nd, 72, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, parent, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, path, 88, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, positionLock, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, readable, 41, 1)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, threads, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FFileChannelImpl_3B, writable, 42, 1)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSinkChannelImpl_3B, 120, Ljava_2Fnio_2Fchannels_2FPipe_24SinkChannel_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSinkChannelImpl_3B, fd, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSinkChannelImpl_3B, fdVal, 88, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSinkChannelImpl_3B, lock, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSinkChannelImpl_3B, state, 92, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSinkChannelImpl_3B, stateLock, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSinkChannelImpl_3B, thread, 112, 8)
+__MRT_CLASS(Lsun_2Fnio_2Fch_2FSourceChannelImpl_3B, 120, Ljava_2Fnio_2Fchannels_2FPipe_24SourceChannel_3B)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSourceChannelImpl_3B, fd, 80, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSourceChannelImpl_3B, fdVal, 88, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSourceChannelImpl_3B, lock, 96, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSourceChannelImpl_3B, state, 92, 4)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSourceChannelImpl_3B, stateLock, 104, 8)
+__MRT_CLASS_FIELD(Lsun_2Fnio_2Fch_2FSourceChannelImpl_3B, thread, 112, 8)
+__MRT_CLASS_FIELD(Lcom_2Fandroid_2Finternal_2Fos_2FBinderCallsStats_3B, mCallSessionsPoolSize, 0, 4)
diff --git a/src/mrt/verifier/include/verifier.h b/src/mrt/verifier/include/verifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..04421a17966a5ab6ca85abe252b1fe365674ed12
--- /dev/null
+++ b/src/mrt/verifier/include/verifier.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#ifndef MAPLE_RUNTIME_VERIFIER_H
+#define MAPLE_RUNTIME_VERIFIER_H
+#include "mclass.h"
+
+namespace maplert {
+// stub for opensource, do nothing
+static inline void VerifyClass(MClass &, bool, bool = true) {}
+} // namespace maplert
+#endif // MAPLE_RUNTIME_VERIFIER_H
diff --git a/test/Makefile b/test/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..1c9b70cfce9438051a2ee89064a3bf0877a7d2e9
--- /dev/null
+++ b/test/Makefile
@@ -0,0 +1,41 @@
+#
+# Copyright (c) [2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+.PHONY: demo
+demo:
+	make -C c_demo
+
+.PHONY: all
+all: test_irbuild test_ourboros c_test
+
+.PHONY: test1
+test1:
+	python3 main.py testsuite/ouroboros/string_test/RT0001-rt-string-ReflectString/ReflectString.java --test_cfg=testsuite/ouroboros/test.cfg --verbose --debug
+
+.PHONY: test_irbuild
+test_irbuild:
+	python3 main.py testsuite/irbuild_test --test_cfg=testsuite/irbuild_test/test.cfg -j20 -pFAIL
+
+.PHONY: test_ourboros
+test_ourboros:
+	python3 main.py testsuite/ouroboros --test_cfg=testsuite/ouroboros/test.cfg --timeout=180 -j20 --retry 1 --fail_exit -pFAIL
+
+.PHONY: c_test
+c_test:
+	make -C c_test
+
+.PHONY: clean
+clean:
+	@rm -rf $(MAPLE_BUILD_OUTPUT)/test
diff --git a/test/Makefile.in b/test/Makefile.in
new file mode 100644
index 0000000000000000000000000000000000000000..2f99e3165f9efe05a3c48c7af33cd48855b73d15
--- /dev/null
+++ b/test/Makefile.in
@@ -0,0 +1,20 @@
+#
+# Copyright (c) [2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+CCMD := $(MAPLE_ROOT)/test/maple_aarch64_with_clang2mpl.sh
+
+OPTIMIZE := 0
+
+VERBOSE := 0
diff --git a/test/README.md b/test/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4b49d3cb3e7e2cc5365ebd337bf2f856cf9232fa
--- /dev/null
+++ b/test/README.md
@@ -0,0 +1,322 @@
+# Maple 测试框架
+
+## 目录结构
+
+```shell
+test
+├── main.py   运行测试套入口
+├── maple_test    测试框架代码
+│   ├── compare.py    结果校验模块
+│   ├── configs.py    参数设置与框架配置文件模块
+│   ├── __init__.py
+│   ├── main.py    内部入口
+│   ├── maple_test.cfg    测试框架配置文件
+│   ├── run.py    命令运行模块
+│   ├── task.py   测试任务准备与运行模块
+│   ├── template.cfg    测试套配置文件模板
+│   ├── test.py   测试用例模块
+│   └── utils.py    通用模块
+├── README.md   测试框架说明
+└── testsuite
+    ├── irbuild_test    irbuild测试套
+    ├── ouroboros 	ouroboros测试套
+    │	├──test.cfg		测试套配置文件
+    │	└──testlist		测试内容
+    ├──maple.py		用例编译脚本
+    └──run.py	 用例执行脚本
+```
+
+## 运行要求
+
+- python版本>=3.5.2
+
+## 修改框架配置
+
+文件：maple_test.cfg
+
+```ini
+[test-home]
+# 指定测试套路径，以‘：’划分
+dir = ../testsuite/irbuild_test:../testsuite/ouroboros:
+
+[running]
+# 指定运行时的临时路径
+temp_dir = ../test_temp/run
+
+[logging]
+# 指定运行时保存日志的路径
+name = ../test_temp/log
+level = INFO
+```
+
+## 运行说明
+
+依赖环境变量：MAPLE_ROOT
+
+### 运行测试套
+
+#### irbuild_test
+
+```
+python3 test/main.py test/testsuite/irbuild_test --test_cfg=test/testsuite/irbuild_test/<test_cfg_file> -j20 -pFAIL
+```
+
+#### ouroboros
+
+```
+python3 test/main.py test/testsuite/ouroboros --test_cfg=test/testsuite/ouroboros/<test_cfg_file> -j20 -pFAIL
+```
+
+参数说明：指定参数会覆盖框架配置文件中的设置
+
+```txt
+usage: main.py [-h] [--cfg CFG] [-j <mum>] [--retry <num>] [--output <file>]
+               [--debug] [--fail_exit]
+               [-p {PASS,FAIL,XFAIL,XPASS,UNSUPPORTED,UNRESOLVED}]
+               [--progress {silent,normal,no_flush_progress}]
+               [--test_cfg <TEST_CFG_FILE>] [--test_list <TEST_LIST_FILE>]
+               [-c config set path] [-C key=value] [-E key=value]
+               [--temp_dir <TEMP_DIR_PATH>] [--timeout TIMEOUT]
+               [--log_dir <LOG_DIR_FILE_PATH>] [--log_level LOG_LEVEL]
+               [--verbose]
+               [test_paths [test_paths ...]]
+
+optional arguments:
+  -h, --help            show this help message and exit
+
+Test FrameWork arguments:
+  --cfg CFG             Test framework configuration file
+  -j <mum>              Run <num> cases in parallel
+  --retry <num>         Re-run unsuccessful test cases
+  --output <file>       Store test result at <file>
+  --debug               keep test temp file
+  --fail_exit           Execute test framework with a non-zero exit code if
+                        any tests fail
+  -p {PASS,FAIL,XFAIL,XPASS,UNSUPPORTED,UNRESOLVED}
+                        Print test cases with specified results, -pPASS
+                        -pFAIL, to print all test case that failed or passed，
+                        UNRESOLVED test case results are not displayed by
+                        default.
+  --progress {silent,normal,no_flush_progress}
+                        set progress type, silent: Don't show progress,
+                        normal: one line progress bar, update per
+                        second,no_flush_progress: print test progress per 10
+                        seconds
+
+Test Suite arguments:
+  test_paths            Test suite path
+  --test_cfg <TEST_CFG_FILE>
+                        test suite config file, needed when run a single case
+                        or with --test_list
+  --test_list <TEST_LIST_FILE>
+                        testlist path for filter test cases
+  -c config set path, --config_set config set path
+                        Run a test set with the specified config set path
+  -C key=value, --config key=value
+                        Add 'key' = 'val' to the user defined configs
+  -E key=value, --env key=value
+                        Add 'key' = 'val' to the user defined environment
+                        variable
+
+Running arguments:
+  --temp_dir <TEMP_DIR_PATH>
+                        Location for test execute.
+  --timeout TIMEOUT     test case timeout
+
+Log arguments:
+  --log_dir <LOG_DIR_FILE_PATH>
+                        Where to store test log
+  --log_level LOG_LEVEL, -l LOG_LEVEL
+                        set log level from: CRITICAL, ERROR, WARNING, INFO,
+                        DEBUG, NOTSET
+  --verbose             enable verbose output
+```
+
+## 测试框架编码支持说明
+
+当前测试框架仅支持编码格式为 `UTF-8`，测试用例和配置文件仅支持 `UTF-8` 编码格式，如果测试用例编码非 `UTF-8` 测试用例会被认定为 `UNRESOLVED`
+
+## ouroboros 测试套
+
+ouroboros测试套是基于 `Java` 测试用例的测试套。
+
+### 测试环境准备
+
+* 本地测试前请首先执行完成`make libcore`。
+
+### 运行测试套
+
+* 参数`--test_cfg`设定选择的测试套配置，默认使用`test.cfg`进行本地测试。
+
+批量运行ouroboros：参数 `-j20` 设定并行为20。
+
+`python3 test/main.py test/testsuite/ouroboros/ --test_cfg=test/testsuite/ouroboros/<test_cfg_file> -j20`
+
+运行ourobors下的子文件夹：
+
+`python3 test/main.py test/testsuite/ouroboros/string_test --test_cfg=test/testsuite/ouroboros/<test_cfg_file> -j20`
+
+运行ourobors下的单一测试用例：
+
+`python3 test/main.py test/testsuite/ouroboros/string_test/RT0001-rt-string-ReflectString/ReflectString.java --test_cfg=test/testsuite/ouroboros/<test_cfg_file>`
+
+只输出失败用例：
+
+`python3 test/main.py test/testsuite/ouroboros/string_test/RT0001-rt-string-ReflectString/ReflectString.java --test_cfg=test/testsuite/ouroboros/<test_cfg_file> -pFAIL`
+
+屏幕输出详细运行日志：
+
+`python3 test/main.py test/testsuite/ouroboros/string_test/RT0001-rt-string-ReflectString/ReflectString.java --test_cfg=test/testsuite/ouroboros/<test_cfg_file> --verbose`
+
+### 测试套配置
+
+测试套配置文件路径在 `testsuite/ourobors/`下, 以`test.cfg`为例，其中含有测试套的一些设置和内部变量
+
+```ini
+[suffix]
+java = //
+
+[internal-var]
+maple = <用例编译脚本>
+run = <用运行脚本>
+build_option = <编译脚本参数>
+run_option = <运行脚本参数>
+
+[description]
+title = Maple Ouroboros Test
+```
+
+**`[suffix]`**：限定搜索测试用例文件的后缀，以及测试用例中注释符，注释符后会跟随执行语句或者校验语句，当前测试套中的用例为 `java` 文件，`//` 作为注释符。
+
+**`[internal-val]`**：内部变量，此处的内部变量会替换用例中相应的变量。例如配置文件中的 `maple = python3 ${MAPLE_ROOT}/test/testsuite/maple.py` ，将会将用例中跟随在 `\\ EXEC: ` 之后的执行语句中的 `%maple` 替换为 `python3 ${MAPLE_ROOT}/test/testsuite/maple.py`。
+
+**`[description]`**：测试套的描述信息。
+
+### 测试套列表
+
+默认测试列表路径为 `testsuite/ourobors/testlist`，测试列表规定了运行测试用例的范围，同时指定了排除的测试用例。
+
+```ini
+[ALL-TEST-CASE]
+    arrayboundary_test
+    clinit_test
+    eh_test
+    fuzzapi_test
+    other_test
+    parent_test
+    reflection_test
+    stmtpre_test
+    string_test
+    subsumeRC_test
+    thread_test
+    unsafe_test
+    memory_management
+
+[EXCLUDE-TEST-CASE]
+    memory_management/Annotation
+```
+
+由两个部分组成：`[ALL-TEST-CASE]` 与 `[EXCLUDE-TEST-CASE]`
+
+**`[ALL-TEST-CASE]`**: 指定了运行测试用例的范围。
+
+**`[EXCLUDE-TEST-CASE]`**: 不运行的测试用例。
+
+当前测试用例排除了测试套 `testsuite/ourobors` 下子文件夹 `memory_management/Annotation` 中所有的用例文件，及部分其他用例。
+
+
+## irbuild测试套
+
+irbuild用于对maple中端产物进行测试，仅进行本地测试，不支持手机测试。
+
+irbuild测试套配置：testsuite/irbuild_test/test.cfg
+如果涉及脚本的运行路径需要填写绝对路径或者在环境变量（PATH）中，例如：
+
+配置文件中：如果cmp在PATH中，则 cmp = cmp 即可，如果不在则 cmp = /usr/bin/cmp
+
+```ini
+[suffix]
+mpl = #
+
+[internal-var]
+irbuild = ${MAPLE_ROOT}/output/bin/irbuild
+cmp = /usr/bin/cmp -s
+
+[description]
+title = Maple Irbuild Test
+```
+
+### 运行单个irbuild用例
+
+```shell
+python3 main.py -pFAIL -pPASS --timeout=180 --test_cfg=testsuite/irbuild_test/test.cfg testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32
+```
+
+### 运行文件夹内的所有用例
+
+```shell
+python3 main.py -pFAIL -pPASS --timeout=180 --test_cfg=testsuite/irbuild_test/test.cfg testsuite/irbuild_test
+```
+
+### irbuild测试套文件结构
+
+```shell
+    testsuite/irbuild 测试套路径
+    ├── I0001-mapleall-irbuild-edge-addf32
+    │   ├── Main.mpl 测试用例
+    ├── ...
+    └── ...
+```
+
+### irbuild_test 测试用例说明
+
+#### 完整Main.mpl
+
+```
+ func &addf32r(
+  var %i f32, var %j f32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i, dread f32 %j))}
+
+ func &addf32I (
+  var %i f32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i,
+       constval f32 1.234f))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
+```
+
+#### 1. 测试案例部分
+
+```
+ func &addf32r(
+  var %i f32, var %j f32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i, dread f32 %j))}
+
+ func &addf32I (
+  var %i f32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i,
+       constval f32 1.234f))}
+```
+
+#### 2. 测试案例运行部分
+
+```
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
+```
+
+三条执行语句：
+
+1. EXEC语句，利用%irbuild，编译Main.mpl为Main.irb.mpl
+2. EXEC语句，利用%irbuild，编译Main.irb.mpl为Main.irb.irb.mpl
+3. EXEC语句，利用%cmp，比较Main.irb.irb.mpl与Main.irb.mpl是否一致，一致测试通过
\ No newline at end of file
diff --git a/test/c_demo/Makefile b/test/c_demo/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..2161836347dc460623e33f6c2987a607cb61830a
--- /dev/null
+++ b/test/c_demo/Makefile
@@ -0,0 +1,19 @@
+#
+# Copyright (c) [2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+.PHONY: default
+default:
+	../maple_aarch64_with_hir2mpl.sh . printHuawei 1 1
+	../maple_aarch64_with_clang2mpl.sh . printHuawei 1 1
diff --git a/test/c_demo/README.md b/test/c_demo/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3405632c66e760c1b6a97afe692c58a62d48c92f
--- /dev/null
+++ b/test/c_demo/README.md
@@ -0,0 +1,30 @@
+```
+#
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# Licensed under the Mulan Permissive Software License v2.
+# You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+# You may obtain a copy of MulanPSL - 2.0 at:
+#
+#   https://opensource.org/licenses/MulanPSL-2.0
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the MulanPSL - 2.0 for more details.
+#
+```
+
+# Maple compiler for C Language
+
+#### 介绍
+example of Maple Compiler for C Language
+
+Besides maple compiler, included are processes using C front end tools:
+  1. clang2mpl - Front end using clang AST
+     source code is available at https://gitee.com/openarkcompiler-incubator/clang2mpl
+
+#### 使用说明
+  run the following scripts for details
+
+  ../maple_aarch64_with_clang2mpl.sh . printHuawei 1 1
diff --git a/test/c_demo/printHuawei.c b/test/c_demo/printHuawei.c
new file mode 100644
index 0000000000000000000000000000000000000000..f83d4c1fc8f62a8b453d5abb1eccafea9aadfa78
--- /dev/null
+++ b/test/c_demo/printHuawei.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+
+int main() {
+  int width = 142;
+  char *str = "\
+     F efifdfifkehfhfhfgnefb;efifdfifjghffhffgoefb; \
+     U efifdfifiigffhfffpefb;efifdfifiigfeiffeqefb; \
+     T efifdfifhkgeejeeegpfb;efifdfifhkgfdjdfefqfb; \
+     U efifdfifgfafffckdfdfrfb;eudfifgfafgeceafceesefb; \
+     R eudfifffcfffbebebfesefb;eudfifffcfffafbfaefsefb; \
+     E eudfifefefefaecfaefsefb;efifdfifeqfeaedeaeffrfb; \
+     W efifdfifdsekdkffrfb;efifdfifdsejfjfgqfb; \
+     E efifdfifcueifihfqfb;efifefgfdfifeifihhofb; \
+     I efifescfkfdhhhiqefb;efiffqdfkfdhhhjpefb; \
+       efifgodfmfdghgmnefb;efifikffmfdfjfolefb;";
+  putchar('\n');
+  char c;
+  int idx = 0;
+  int loc = 0;
+  while ((c = str[idx++])) {
+    char fillChar = (idx & 1) ? 'H' : ' ';
+    for(char b = 'a'; b <= c; b++) {
+      if (loc++ == width) {
+        loc = 0;
+        fillChar = '\n';
+      }
+      putchar(fillChar);
+    }
+  }
+  putchar('\n');
+  return 0;
+}
diff --git a/test/c_test/Makefile b/test/c_test/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..2674a3c4d948bd9256d0968690b24e39ea922c63
--- /dev/null
+++ b/test/c_test/Makefile
@@ -0,0 +1,21 @@
+#
+# Copyright (c) [2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+.PHONY: all
+all: sanity
+
+.PHONY: sanity
+sanity:
+	make -C sanity
diff --git a/test/c_test/sanity/Makefile b/test/c_test/sanity/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..eaa099be82038ee9a29bf2d17cd6449e5193673c
--- /dev/null
+++ b/test/c_test/sanity/Makefile
@@ -0,0 +1,25 @@
+#
+# Copyright (c) [2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+include $(MAPLE_ROOT)/test/Makefile.in
+
+CASES=$(basename $(wildcard *.c))
+
+.PHONY: all
+all: $(CASES)
+
+% : %.c
+	$(CCMD) . $@ $(OPTIMIZE) $(VERBOSE)
+
diff --git a/test/c_test/sanity/addr.c b/test/c_test/sanity/addr.c
new file mode 100644
index 0000000000000000000000000000000000000000..1e0281a16f456474f3638644f422a077bcf4ba10
--- /dev/null
+++ b/test/c_test/sanity/addr.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int deref(int *iptr) {
+  return *iptr;
+}
+
+int deref1(int *iptr) {
+  int j = 8;
+  j = *iptr + j;
+  return j;
+}
+
+int addrof(int *iptr) {
+  int j = 8;
+  int *jptr = &j;
+  *jptr = *iptr;
+  return *jptr;
+}
+
+int main()
+{
+  int v = 5;
+  int *vptr = &v;
+
+  if (*vptr != 5) {
+    abort();
+  }
+  if (deref(&v) != 5) {
+    abort();
+  }
+  if (deref1(&v) != 13) {
+    abort();
+  }
+  if (addrof(&v) != 5) {
+    abort();
+  }
+}
+
diff --git a/test/c_test/sanity/argc.c b/test/c_test/sanity/argc.c
new file mode 100644
index 0000000000000000000000000000000000000000..2358a1da299fc3197592af44374d8cbea5d88707
--- /dev/null
+++ b/test/c_test/sanity/argc.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+  int i = 1;
+  if (i > argc) {
+    abort();
+  }
+  return 0;
+}
diff --git a/test/c_test/sanity/array_single.c b/test/c_test/sanity/array_single.c
new file mode 100644
index 0000000000000000000000000000000000000000..22c881cddefb5e4cfddcf11a505305631cf2659e
--- /dev/null
+++ b/test/c_test/sanity/array_single.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int A[5];
+int foo(int i) {
+  A[3] = i + A[2];
+  return A[(i >= 0 && i < 5) ? i : 0];
+}
+
+float B[15];
+float bar(int i) {
+  B[3] = i + B[2];
+  return B[(i >= 0 && i < 5) ? i : 0];
+}
+
+// variable array type
+void vararr(int sz) {
+  int my[sz];
+  int i;
+  for (i = 0; i < sz; ++i) {
+    my[i] = i;
+  }
+  for (i = 0; i < sz; ++i) {
+    if (my[i] != i) {
+      abort();
+    }
+  }
+}
+
+int main()
+{
+  vararr(4);
+
+  A[0] = 0;
+  A[2] = A[3] = 2;
+  if (A[3] != 2) {
+    abort();
+  }
+  if (foo(2) != 2) {
+    abort();
+  }
+  if (A[3] != 4) {
+    abort();
+  }
+  if (foo(5) != 0) {
+    abort();
+  }
+  if (A[3] != 7) {
+    abort();
+  }
+
+  B[0] = 0;
+  B[1] = B[2] = B[3] = 3;
+  if (B[3] != 3) {
+    abort();
+  }
+  if (bar(1) != 3) {
+    abort();
+  }
+  if (B[3] != 4) {
+    abort();
+  }
+  if (bar(5) != 0) {
+    abort();
+  }
+  if (B[3] != 8) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/test/c_test/sanity/binop.c b/test/c_test/sanity/binop.c
new file mode 100644
index 0000000000000000000000000000000000000000..733be02b68f2a7772f5decac6204c75f079fdbf8
--- /dev/null
+++ b/test/c_test/sanity/binop.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int a = 0x80000001;
+unsigned int ua = 0x00000002;
+unsigned int val = 0xffffff84;
+
+int main()
+{
+  int c = a;
+
+  c += a | 0;
+  c += a & 1;
+  c += a ^ 0;
+  c += a >> 0;
+  c += a << 0;
+
+  c += a | 1;
+  c += a & 5;
+  c += a ^ 1;
+  c += a >> 1;
+  c += a << 1;
+
+  c += a | 0x7ff;
+  c += a & 0x7ff;
+  c += a ^ 0x7ff;
+  c += a >> 16;
+  c += a << 16;
+
+  c += a | 0xfff;
+  c += a & 0xfff;
+  c += a ^ 0xfff;
+  c += a >> 24;
+  c += a << 24;
+
+  c += a | 0xffff;
+  c += a & 0xffff;
+  c += a ^ 0xffff;
+  c += a >> 31;
+  c += a << 31;
+
+  unsigned int u = ua;
+  u += ua >> 0;
+  u += ua >> 1;
+  u += ua >> 16;
+  u += a >> 24;
+  u += a >> 31;
+
+  if (c != 0xc102af83) {
+    abort();
+  }
+  if (u != 0xffffff84) {
+    abort();
+  }
+  if (u != val) {
+    abort();
+  }
+}
diff --git a/test/c_test/sanity/cand.c b/test/c_test/sanity/cand.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa71bffcbb09d2873f2181fb4b43616789eccb50
--- /dev/null
+++ b/test/c_test/sanity/cand.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int i = 2;
+int main() {
+  int v = (((i > 0) && (i < 3)) ? 1 : 2);
+  if ( v != 1 ) {
+    abort();
+  }
+
+  v = (((i > 0) && (i < 2)) ? 1 : 2);
+  if ( v != 2 ) {
+    abort();
+  }
+
+  v = (((i > 2) && (i < 3)) ? 1 : 2);
+  if ( v != 2 ) {
+    abort();
+  }
+}
diff --git a/test/c_test/sanity/goto.c b/test/c_test/sanity/goto.c
new file mode 100644
index 0000000000000000000000000000000000000000..a0bad57bf41a655f6006851822ecfd95008cbf1a
--- /dev/null
+++ b/test/c_test/sanity/goto.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int g = 5;
+
+int main() {
+  for (int i = 0; i < 10; i++) {
+    if (i == 1) {
+      goto label;
+    }
+    g = i;  // 0
+  }
+  abort();
+
+label:
+  if (g != 0) {
+    abort();
+  }
+  return 0;
+}
diff --git a/test/c_test/sanity/hello.c b/test/c_test/sanity/hello.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b6d7b83d5d7fe7586ce7c78400810e67555c8e9
--- /dev/null
+++ b/test/c_test/sanity/hello.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  char str[32];
+  int v = sprintf(str,"hello world\n");
+
+  if (v != 12) {
+    abort();
+  }
+  return 0;
+}
diff --git a/test/c_test/sanity/if_call_return.c b/test/c_test/sanity/if_call_return.c
new file mode 100644
index 0000000000000000000000000000000000000000..e55533bd1fbb89fdce2b16381c6ee2fc19d2f68a
--- /dev/null
+++ b/test/c_test/sanity/if_call_return.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int i = 1;
+float f = 2.2;
+long long ll = 3;
+double d = 4.4;
+
+int fi(){ return i; }
+float ff(){ return f; }
+long long fll(){ return ll; }
+double fd(){ return d; }
+
+int main() {
+  if (fi() != 1) {
+    abort();
+  }
+  if (ff() != (float)2.2) {
+    abort();
+  }
+  if (fll() != 3) {
+    abort();
+  }
+  if (fd() != 4.4) {
+    abort();
+  }
+  return 0;
+}
+
diff --git a/test/c_test/sanity/if_else.c b/test/c_test/sanity/if_else.c
new file mode 100644
index 0000000000000000000000000000000000000000..63d19c2a83f1279f55ed509df7466dd9a0b7bd6f
--- /dev/null
+++ b/test/c_test/sanity/if_else.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  int i = 1;
+
+  if (i > 1) {
+    abort();
+  } else {
+    printf("");
+  }
+  return 0;
+}
diff --git a/test/c_test/sanity/if_else_fp.c b/test/c_test/sanity/if_else_fp.c
new file mode 100644
index 0000000000000000000000000000000000000000..65d0609a1489f46caf46379efc995592b250c304
--- /dev/null
+++ b/test/c_test/sanity/if_else_fp.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  double d1 = 10;
+  double d2 = 20;
+  int i = 0;
+
+  if (d1 <= d2) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (d2 >= d1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (d2 > d1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (d1 < d2 && d2 > d1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (d1 != d2) {
+    i++;
+  } else {
+    abort();
+  }
+
+  d1 = 20;
+  if (d1 <= d2) {
+    if (d1 == d2) {
+      i++;
+    } else {
+      abort();
+    }
+  }
+
+  float f1 = 10;
+  float f2 = 20;
+
+  if (f1 <= f2) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (f2 >= f1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (f2 > f1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (f1 < f2 && f2 > f1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (f1 != f2) {
+    i++;
+  } else {
+    abort();
+  }
+
+  f1 = 20;
+  if (f1 <= f2) {
+    if (f1 == f2) {
+      i++;
+    } else {
+      abort();
+    }
+  }
+
+  if (i != 12) {
+    abort();
+  }
+}
diff --git a/test/c_test/sanity/ind_call.c b/test/c_test/sanity/ind_call.c
new file mode 100644
index 0000000000000000000000000000000000000000..6cfda4c04c7b1e4ec4e4dd1b32131e525baeda3e
--- /dev/null
+++ b/test/c_test/sanity/ind_call.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int x = 1;
+
+int foo(){return x;}
+
+int main() {
+  int (*fptr)() = foo;
+  int v = fptr();
+
+  if (v != 1) {
+    abort();
+  }
+  return 0;
+}
diff --git a/test/c_test/sanity/large_stack.c b/test/c_test/sanity/large_stack.c
new file mode 100644
index 0000000000000000000000000000000000000000..41bc2c2449dc29ad6d971eeae6b762abac286bdc
--- /dev/null
+++ b/test/c_test/sanity/large_stack.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define asize 500
+int sum = 0;
+void vararr(int sz) {
+  int my[sz];
+  volatile int a[asize], b[asize], c[asize];
+
+  for (int i = 0; i< asize; i++) {
+    a[i] = i; b[i] = i + 1; c[i] = i + 2;
+    sum = a[i] + b[i] * c[i];
+    if (i < sz) {
+      my[i] = sum;
+    }
+  }
+
+  if ((my[0] != 2) ||
+      (my[1] != 7) ||
+      (my[2] != 14) ||
+      (my[3] != 23)) {
+    abort();
+  }
+}
+
+int main() {
+  vararr(4);
+}
diff --git a/test/c_test/sanity/memexpr.c b/test/c_test/sanity/memexpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..5417248d6ae6a5757952d51a5cfd07e6decb21e8
--- /dev/null
+++ b/test/c_test/sanity/memexpr.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  struct PSas {
+    short a, b;
+    int *p;
+  }(*PSas0), (*PSas1);
+
+  struct PSas pSas0, pSas1, pSasa[10];
+
+  int i = 5;
+  PSas0 = &pSas0;
+  PSas1 = &pSas1;
+
+  pSasa[8].a = 2;
+  (*PSas0).a = 3;
+  (*PSas1).p = &i;
+
+  if (pSasa[8].a != 2 || (*PSas0).a != 3 || *((*PSas1).p) != 5) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/test/c_test/sanity/select.c b/test/c_test/sanity/select.c
new file mode 100644
index 0000000000000000000000000000000000000000..dfe621fe53908cd13d10df3ee9138b9534cc03c0
--- /dev/null
+++ b/test/c_test/sanity/select.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+  int i = (argc != 1) ? ((argc != 2) ? ((argc != 3) ? 6 : 7) : 5) : ((argc == 4) ? 8 : 9);
+
+  if (i != 9) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/test/c_test/sanity/select_fp.c b/test/c_test/sanity/select_fp.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c3019a9757473356ce65272bf2d8a258c0bb115
--- /dev/null
+++ b/test/c_test/sanity/select_fp.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+  float f = 2000;
+  int i = (argc == 1) ? ((f != 200) ? ((f == 2000) ? 6 : 7) : 5) : ((argc == 4) ? 8 : 9);
+
+  if (i != 6) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/test/c_test/sanity/set.c b/test/c_test/sanity/set.c
new file mode 100644
index 0000000000000000000000000000000000000000..3eaca49ef8540270ebd929be1991220138a2a3cd
--- /dev/null
+++ b/test/c_test/sanity/set.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdlib.h>
+
+void foo1(int x) { // x = (0, 1, -1, 1, 0, 0)
+  int a1 = x++ == 0;
+  int a2 = x-- != 0;
+  int a3 = --x < 0;
+  int a4 = x+2 > 0;
+  int a5 = ++x <= 0;
+  int a6 = x >= 0;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo2(int x) { // x = (1, 2, 0, 2, 1, 1)
+  int a1 = x == 1;
+  int a2 = ++x != 1;
+  int a3 = x-2 < 1;
+  int a4 = x > 1;
+  int a5 = --x <= 1;
+  int a6 = x >= 1;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo3(int x, int y) { // x&y = (1==1, 1!=2, 0<2, 0>-1, 0<=0, 0>=0)
+  int a1 = x == y;
+  int a2 = x != ++y;
+  int a3 = --x < y--;
+  int a4 = x > y-2;
+  int a5 = x <= --y;
+  int a6 = x >= --y;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo4(unsigned x) { // x = (0, 1, 0xf-f, 1, 0, 0)
+  unsigned a1 = x++ == 0;
+  unsigned a2 = x-- != 0;
+  unsigned a3 = (--x < 0) + 1;
+  unsigned a4 = x+2 > 0;
+  unsigned a5 = ++x <= 0;
+  unsigned a6 = x >= 0;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo5(unsigned x) { // x = (1, 2, 0, 0xf-f, 1, 1)
+  unsigned a1 = x == 1;
+  unsigned a2 = ++x != 1;
+  unsigned a3 = x-2 < 1;
+  unsigned a4 = x-3 > 1;
+  unsigned a5 = --x <= 1;
+  unsigned a6 = x >= 1;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo6(unsigned x, unsigned y) { // x&y = (1==1, 1!=2, 0<2, 0xf-f>1, 0<=0, 0>=0,
+  //        0xf-f>=0)
+  unsigned a1 = x == y;
+  unsigned a2 = x != ++y;
+  unsigned a3 = --x < y--;
+  unsigned a4 = --x > y;
+  unsigned a5 = ++x <= --y;
+  unsigned a6 = x >= y;
+  unsigned a7 = --x >= y;
+  if (a1+a2+a3+a4+a5+a6+a7 != 7) {
+    abort();
+  }
+}
+
+void foo7(unsigned x) { // x = (4096, 4097, 4094, 4097, 4096, 4096)
+  unsigned a1 = x == 4096;
+  unsigned a2 = ++x != 4096;
+  unsigned a3 = x-3 < 4095;
+  unsigned a4 = x > 4096;
+  unsigned a5 = --x <= 4096;
+  unsigned a6 = x >= 4096;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+int main() {
+  foo1(0);
+  foo2(1);
+  foo3(1, 1);
+  foo4(0);
+  foo5(1);
+  foo6(1, 1);
+  foo7(4096);
+}
diff --git a/test/c_test/sanity/struct_bits.c b/test/c_test/sanity/struct_bits.c
new file mode 100644
index 0000000000000000000000000000000000000000..7deea9e24a201a0bd0c6dfedae98d77c622d64e8
--- /dev/null
+++ b/test/c_test/sanity/struct_bits.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct x {
+  long x;
+  unsigned int z1:3;
+  unsigned int z2:12;
+  int z3:2;
+  int z4:10;
+  int z5:5;
+  int y;
+  char z[32];
+} x;
+
+typedef struct y {
+  long x;
+  long long x1 : 5;
+  long long x2 : 16;
+  unsigned long long x3 : 33;
+  long long x4 : 10;
+  int y;
+} y;
+
+void foo() {
+  x xxx;
+  xxx.x = 1;
+  xxx.y = 2;
+  xxx.z1 = 0x7;
+  xxx.z2 = 0x800;
+  xxx.z3 = 0x3;
+  xxx.z4 = 0x201;
+  xxx.z5 = 0x11;
+  xxx.z[0] = 4;
+  xxx.z[31] = 6;
+  xxx.z[1] = 5;
+
+  if (xxx.z1 != 7) {
+    abort();
+  }
+  if (xxx.z2 != 0x800) {
+    abort();
+  }
+  if (xxx.z3 != -1) {
+    abort();
+  }
+  if (xxx.z4 != -511) {
+    abort();
+  }
+  if (xxx.z5 != -15) {
+    abort();
+  }
+}
+
+void bar() {
+  y yyy;
+
+  yyy.x = 3;
+  yyy.y = 4;
+  yyy.x1 = 7;
+  yyy.x2 = 0xff;
+  yyy.x3 = 0x800f0008;
+  yyy.x4 = 0x15;
+}
+
+int main() {
+  foo();
+  bar();
+  return 0;
+}
+
diff --git a/test/c_test/sanity/sum.c b/test/c_test/sanity/sum.c
new file mode 100644
index 0000000000000000000000000000000000000000..d49699cfd26d73c389f2019cd01402cf89ec2e9b
--- /dev/null
+++ b/test/c_test/sanity/sum.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  int sum = 0;
+
+  for (int i = 0; i < 10; i++) {
+    sum += i;
+  }
+
+  if (sum != 45) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/test/c_test/sanity/sum_array.c b/test/c_test/sanity/sum_array.c
new file mode 100644
index 0000000000000000000000000000000000000000..9235f2768dda33a9b7443afc85956afa6d08933e
--- /dev/null
+++ b/test/c_test/sanity/sum_array.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+//int main(int argc, char *argv[])
+int main()
+{
+  int a[10], b[10], c[10], i;
+
+  for (i = 0; i < 10; i++) {
+    b[i] = i << 2;
+    c[i] = i << (b[i] % (sizeof(int)*CHAR_BIT));
+  }
+
+  for (i = 0; i < 10; i++) {
+    a[i] = b[i] + c[9-i];
+  }
+
+  int sum = 0;
+  for (i = 0; i < 10; i++) {
+    sum += a[i];
+  }
+
+  if (sum != 1985229660) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/test/c_test/sanity/vararg2.c b/test/c_test/sanity/vararg2.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb0fcd53dd5c71d78156cdf6819bfd6e76dc106a
--- /dev/null
+++ b/test/c_test/sanity/vararg2.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdarg.h>
+
+static double f (float a, ...);
+static double (*fp) (float a, ...);
+
+main () {
+  fp = f;
+  if (fp ((float) 1, (double)2) != 3.0) {
+    abort ();
+  }
+  exit (0);
+}
+
+static double
+f (float a, ...) {
+  va_list ap;
+
+  va_start(ap, a);
+  float i = va_arg(ap, double);
+  return (double)a + i;
+}
diff --git a/test/main.py b/test/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..18d8b40dd924fc399fbc5bd0b5e592744444cb88
--- /dev/null
+++ b/test/main.py
@@ -0,0 +1,20 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+from maple_test import main
+
+if __name__ == "__main__":
+    main()
diff --git a/test/maple_aarch64_with_clang2mpl.sh b/test/maple_aarch64_with_clang2mpl.sh
new file mode 100755
index 0000000000000000000000000000000000000000..9df5a92e302b1709c7d9835f1a0e5dde61772860
--- /dev/null
+++ b/test/maple_aarch64_with_clang2mpl.sh
@@ -0,0 +1,70 @@
+#!/bin/bash
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# Licensed under the Mulan Permissive Software License v2
+# You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+# You may obtain a copy of MulanPSL - 2.0 at:
+#
+#   https://opensource.org/licenses/MulanPSL-2.0
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the MulanPSL - 2.0 for more details.
+#
+
+set -e
+
+[ -n "$MAPLE_ROOT" ] || { echo MAPLE_ROOT not set. Please source envsetup.sh.; exit 1; }
+
+[ -f "$MAPLE_EXECUTE_BIN/clang2mpl" ] || { echo; echo ">>>>>> clang2mpl not built. Please make clang2mpl"; echo; exit 1; }
+
+CURRDIR=`pwd`
+rel=`realpath --relative-to=$MAPLE_ROOT $CURRDIR`
+
+dir=$1
+src=$2
+opt=$3
+if [ $# -le 3 ]; then
+  verbose=0
+else
+  verbose=$4
+fi
+
+WORKDIR=$MAPLE_BUILD_OUTPUT/$rel/$dir/aarch64_with_clang2mpl
+
+mkdir -p $WORKDIR
+cp $dir/$src.c $WORKDIR
+cd $WORKDIR
+
+echo ======================================================================== > cmd.log
+echo ==================== use clang2mpl as C Frontend ======================= >> cmd.log
+echo ======================================================================== >> cmd.log
+echo cd $WORKDIR >> cmd.log
+
+echo $MAPLE_EXECUTE_BIN/clang2mpl --ascii $src.c -- --target=aarch64-linux-elf >> cmd.log
+$MAPLE_EXECUTE_BIN/clang2mpl --ascii $src.c -- --target=aarch64-linux-elf >> doit.log 2>&1
+
+if [ $opt -eq 0 ]; then
+  echo $MAPLE_EXECUTE_BIN/maple --run=mplcg --option=\"-quiet\" $src.mpl >> cmd.log
+  $MAPLE_EXECUTE_BIN/maple --run=mplcg --option="-quiet" $src.mpl >> doit.log 2>&1
+else
+  echo $MAPLE_EXECUTE_BIN/maple --run=mplcg --option=\"-O2 -quiet\" $src.mpl >> cmd.log
+  $MAPLE_EXECUTE_BIN/maple --run=mplcg --option="-O2 -quiet" $src.mpl >> doit.log 2>&1
+fi
+
+LINARO=$MAPLE_ROOT/tools/gcc-linaro-7.5.0
+
+echo $LINARO/bin/aarch64-linux-gnu-gcc -o $src.out $src.s >> cmd.log
+$LINARO/bin/aarch64-linux-gnu-gcc -o $src.out $src.s
+
+echo $MAPLE_ROOT/tools/bin/qemu-aarch64 -L $LINARO/aarch64-linux-gnu/libc $src.out >> cmd.log
+$MAPLE_ROOT/tools/bin/qemu-aarch64 -L $LINARO/aarch64-linux-gnu/libc $src.out > output.log
+
+cat cmd.log >> allcmd.log
+
+if [ $verbose -eq 1 ]; then
+  cat cmd.log
+  cat output.log
+fi
+
diff --git a/test/maple_aarch64_with_hir2mpl.sh b/test/maple_aarch64_with_hir2mpl.sh
new file mode 100755
index 0000000000000000000000000000000000000000..6f934b000a716ae4dfd9ef22a90fc7f8b59078da
--- /dev/null
+++ b/test/maple_aarch64_with_hir2mpl.sh
@@ -0,0 +1,71 @@
+#!/bin/bash
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# Licensed under the Mulan Permissive Software License v2
+# You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+# You may obtain a copy of MulanPSL - 2.0 at:
+#
+#   https://opensource.org/licenses/MulanPSL-2.0
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the MulanPSL - 2.0 for more details.
+#
+
+set -e
+
+[ -n "$MAPLE_ROOT" ] || { echo MAPLE_ROOT not set. Please source envsetup.sh.; exit 1; }
+
+CURRDIR=`pwd`
+rel=`realpath --relative-to=$MAPLE_ROOT $CURRDIR`
+
+dir=$1
+src=$2
+opt=$3
+if [ $# -le 3 ]; then
+  verbose=0
+else
+  verbose=$4
+fi
+
+WORKDIR=$MAPLE_BUILD_OUTPUT/$rel/$dir/aarch64_with_hir2mpl
+
+mkdir -p $WORKDIR
+cp $dir/$src.c $WORKDIR
+cd $WORKDIR
+
+echo ======================================================================== > cmd.log
+echo ====================== use hir2mpl as C Frontend ========================= >> cmd.log
+echo ======================================================================== >> cmd.log
+echo cd $WORKDIR >> cmd.log
+
+echo $MAPLE_ROOT/tools/bin/clang -emit-ast -o $src.ast $src.c >> cmd.log
+$MAPLE_ROOT/tools/bin/clang -emit-ast -o $src.ast $src.c >> doit.log 2>&1
+
+echo $MAPLE_EXECUTE_BIN/hir2mpl $src.ast -o $src.mpl >> cmd.log
+$MAPLE_EXECUTE_BIN/hir2mpl $src.ast -o $src.mpl >> doit.log 2>&1
+
+if [ $opt -eq 0 ]; then
+  echo $MAPLE_EXECUTE_BIN/maple --run=mplcg --option=\"-quiet\" $src.mpl >> cmd.log
+  $MAPLE_EXECUTE_BIN/maple --run=mplcg --option="-quiet" $src.mpl >> doit.log 2>&1
+else
+  echo $MAPLE_EXECUTE_BIN/maple --run=mplcg --option=\"-O2 -quiet\" $src.mpl >> cmd.log
+  $MAPLE_EXECUTE_BIN/maple --run=mplcg --option="-O2 -quiet" $src.mpl >> doit.log 2>&1
+fi
+
+LINARO=$MAPLE_ROOT/tools/gcc-linaro-7.5.0
+
+echo $LINARO/bin/aarch64-linux-gnu-gcc -o $src.out $src.s >> cmd.log
+$LINARO/bin/aarch64-linux-gnu-gcc -o $src.out $src.s
+
+echo $MAPLE_ROOT/tools/bin/qemu-aarch64 -L $LINARO/aarch64-linux-gnu/libc $src.out >> cmd.log
+$MAPLE_ROOT/tools/bin/qemu-aarch64 -L $LINARO/aarch64-linux-gnu/libc $src.out > output.log
+
+cat cmd.log >> allcmd.log
+
+if [ $verbose -eq 1 ]; then
+  cat cmd.log
+  cat output.log
+fi
+
diff --git a/test/maple_test/__init__.py b/test/maple_test/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b6088e86f70b69539b4fa72ac98b8f3c203f1af
--- /dev/null
+++ b/test/maple_test/__init__.py
@@ -0,0 +1,17 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+from .main import main
diff --git a/test/maple_test/compare.py b/test/maple_test/compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..01f962f72c925962ffd3e198ebaf4ecb24478c53
--- /dev/null
+++ b/test/maple_test/compare.py
@@ -0,0 +1,329 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import argparse
+import logging
+import re
+import sys
+from textwrap import indent
+from functools import partial
+
+from utils import complete_path, read_file
+from utils import split_comment, filter_line, escape
+
+ASSERT_FLAG = "ASSERT"
+EXPECTED_FLAG = "EXPECTED"
+EXPECTED_REGEX = r"\:{line_num}\:.*\:.*"
+
+SCAN_KEYWORDS = ["full", "not", "begin", "next", "end"]
+REGEX_KEYWORDS = ["auto", "not", "next", "end"]
+EXPECTED_KEYWORDS = ["regex", "regex-auto", "regex-not"]
+
+
+class CompareError(Exception):
+    pass
+
+
+def main():
+    opts = parse_cli()
+    case_path = opts.case_path
+    comment = opts.comment
+    compare_object = opts.compare_object
+    assert_flags = opts.assert_flag
+    if not assert_flags:
+        assert_flags.append(ASSERT_FLAG)
+    expected_flags = opts.expected_flag
+    if not expected_flags:
+        expected_flags.append(EXPECTED_FLAG)
+    try:
+        content = compare_object.read()
+    except UnicodeDecodeError as e:
+        print("Wrong stdin encoding:{}\n{}".format(e.object, e))
+        sys.exit(1)
+    content_line_map = gen_line_map(content)
+
+    print("compare.py input:")
+    print(indent(content, "\t", lambda line: True))
+    print("compare.py input end\n")
+
+    if compare_object.isatty():
+        sys.stderr.write("ERROR: require compare objects, filepath or stdin \n")
+        sys.exit(253)
+    compare_line_regex = gen_compare_regex(comment, assert_flags, expected_flags)
+    compare_lines = extract_compare_lines(case_path, compare_line_regex)
+
+    compare_result = True
+    start = 0
+    print("Starting Compare:")
+    for compare_line in compare_lines:
+        output_line_num = text_index_to_line_num(content_line_map, start)
+
+        compare_line, line_num = compare_line
+        flag, compare_pattern = split_compare_line(compare_line)
+        pattern_flag, pattern = split_pattern_line(compare_pattern)
+
+        info = ""
+        keywords = pattern_flag.split("-")
+        if flag.strip() in assert_flags:
+            info = "It's a assert, "
+        elif flag.strip() in expected_flags:
+            if "auto" in keywords:
+                pattern = r"\s+".join([re.escape(word) for word in pattern.split()])
+                keywords.remove("auto")
+            pattern = EXPECTED_REGEX.format(line_num=line_num) + pattern
+            if pattern_flag.strip() not in EXPECTED_KEYWORDS:
+                raise CompareError(
+                    "Unsupport expected keywords: {!r}".format(pattern_flag)
+                )
+        else:
+            raise CompareError("Unsupport flag: {!r}".format(flag))
+
+        match_func = gen_match_func(keywords)
+        if "next" not in keywords and "end" not in keywords:
+            start = 0
+        result, start = match_func(content, content_line_map, pattern, start)
+        info += "flag: {}, pattern: {} , result: {}, matached at output line: {}".format(
+            pattern_flag, pattern, result, output_line_num
+        )
+        print(info.encode(encoding='utf-8', errors='ignore'))
+
+        if result is False:
+            print("Match End!, Compare Failed")
+        compare_result &= result
+
+    if compare_result is True:
+        print("Match End !!!")
+        print("Compare Passed: {}".format(compare_result))
+        return 0
+    sys.exit(1)
+
+
+def split_compare_line(compare_line):
+    if len(compare_line.lstrip().split(":", 1)) < 2:
+        print(
+            "Please check compare line, found compare flag but no actual compare content!!!"
+        )
+        raise CompareError(
+            "Please check compare line, found compare flag but no actual compare content!!!"
+        )
+    else:
+        return compare_line.lstrip().split(":", 1)
+
+
+def split_pattern_line(compare_pattern):
+    try:
+        pattern_flag, pattern = compare_pattern.lstrip().split(" ", 1)
+    except ValueError:
+        pattern_flag = compare_pattern.lstrip()
+        pattern = ""
+    return pattern_flag, pattern
+
+
+def gen_match_func(keywords):
+    valid_keywords = []
+    assert_mode = keywords[0]
+    match_func = None
+    if assert_mode == "scan":
+        match_func = in_match
+        valid_keywords = SCAN_KEYWORDS
+    elif assert_mode == "regex":
+        match_func = regex_match
+        valid_keywords = REGEX_KEYWORDS
+    else:
+        raise CompareError("scan mode: {} is not valid".format(assert_mode))
+    for keyword in keywords[1:]:
+        if keyword not in valid_keywords:
+            raise CompareError(
+                "keyword: {} is not valid for {}".format(keyword, assert_mode)
+            )
+        if keyword == "auto":
+            match_func = partial(auto_regex_match, match_func=match_func)
+        elif keyword == "not":
+            match_func = partial(not_match, match_func=match_func)
+        elif keyword == "next":
+            match_func = partial(next_match, match_func=match_func)
+        elif keyword == "begin":
+            match_func = partial(begin_match, match_func=match_func)
+        elif keyword == "end":
+            match_func = end_match
+        elif keyword == "full":
+            match_func = full_match
+    return match_func
+
+
+def is_valid_pattern(pattern):
+    try:
+        re.compile(pattern)
+    except re.error:
+        logging.error("Error pattern: {!r}".format(pattern))
+        return False
+    except TypeError:
+        logging.error(type(pattern), repr(pattern))
+    return True
+
+
+def regex_match(content, line_map, pattern, start=0):
+    if not is_valid_pattern(pattern):
+        raise CompareError("Not valid pattern: {!r}".format(pattern))
+    matches = re.finditer(str(pattern), content, re.MULTILINE)
+    end = 0
+    for _, match in enumerate(matches, start=1):
+        end = match.end() + start
+        line_num = text_index_to_line_num(line_map, end)
+        if line_num + 1 >= len(line_map):
+            return True, end
+        return True, line_map[line_num] + 1
+    return False, start
+
+
+def begin_match(content, line_map, pattern, start=0, match_func=regex_match):
+    return match_func(content.splitlines()[0], line_map, pattern, start=0, match_func=regex_match)
+
+
+def auto_regex_match(content, line_map, pattern, start=0, match_func=regex_match):
+    pattern = r"\s+".join([re.escape(word) for word in pattern.split()])
+    return match_func(content, line_map, pattern, start)
+
+
+def not_match(content, line_map, pattern, start=0, match_func=regex_match):
+    result, end = match_func(content, line_map, pattern, start)
+    if not result:
+        line_num = text_index_to_line_num(line_map, start)
+        return not result, line_map[line_num] + 1
+    return not result, start
+
+
+def next_match(content, line_map, pattern, start=0, match_func=regex_match):
+    line_num = text_index_to_line_num(line_map, start)
+    return match_func(content.splitlines()[line_num], line_map, pattern, start)
+
+
+def end_match(content, line_map, pattern, start=0, match_func=regex_match):
+    line_num = text_index_to_line_num(line_map, start)
+    if line_num < len(line_map):
+        return False, start
+    return True, start
+
+
+def full_match(content, line_map, pattern, start=0, match_func=regex_match):
+    line_num = text_index_to_line_num(line_map, start)
+    pattern = re.sub(r'([^\u0100-\uffff]+)', lambda x:(x.group(1) + r' ').encode("utf-8").decode("unicode_escape")[:-1], pattern)
+    if content != pattern:
+        return False, start
+    return True, line_map[line_num] + 1
+
+
+def in_match(content, line_map, pattern, start=0, match_func=regex_match):
+    line_num = text_index_to_line_num(line_map, start)
+    pattern = re.sub(r'([^\u0100-\uffff]+)', lambda x:(x.group(1) + r' ').encode("utf-8").decode("unicode_escape")[:-1], pattern)
+    if content.find(pattern) == -1:
+        return False, start
+    return True, line_map[line_num] + 1
+
+
+def gen_line_map(text):
+    regex = ".*\n?"
+    line_map = []
+    for match in re.finditer(regex, text):
+        line_map.append(match.end())
+    return line_map
+
+
+def text_index_to_line_num(line_map, index):
+    for line_num, end in enumerate(line_map):
+        if end >= index:
+            return line_num
+    return line_num + 1
+
+
+def gen_compare_regex(comment, assert_flags, expected_flag):
+    regex = ""
+    for flag in expected_flag:
+        excepted_regex = r"(?:{comment}\s*)({flag}[\t ]*\:[\t ]*.*$)".format(
+            comment=escape("\\$()*+.[]?^{}|", comment), flag=flag
+        )
+        if regex != "":
+            regex = "{}|{}".format(regex, excepted_regex)
+        else:
+            regex = excepted_regex
+    for flag in assert_flags:
+        assert_regex = r"(?:^[\t ]*{comment}\s*)({flag}[\t ]*\:[\t ]*.*$)".format(
+            comment=escape("\\$()*+.[]?^{}|", comment), flag=flag
+        )
+        if regex != "":
+            regex = "{}|{}".format(regex, assert_regex)
+        else:
+            regex = assert_regex
+    return regex
+
+
+def extract_compare_lines(file_path, regex):
+    with file_path.open(encoding="utf-8") as f:
+        content = f.read()
+    matches = re.finditer(regex, content, re.MULTILINE)
+
+    compare_lines = []
+    end_regex = ".*\n?"
+    line_map = []
+    for match in re.finditer(end_regex, content):
+        line_map.append(match.end())
+    for match in matches:
+        for group_num in range(0, len(match.groups())):
+            group_num = group_num + 1
+            if match.group(group_num) is None:
+                continue
+            for line_num, end in enumerate(line_map):
+                if end > match.start(group_num):
+                    compare_lines.append((match.group(group_num), line_num + 1))
+                    break
+    return compare_lines
+
+
+def parse_cli():
+    parser = argparse.ArgumentParser(prog="compare.py")
+    parser.add_argument("--comment", help="Test case comment")
+    parser.add_argument(
+        "--assert_flag",
+        help="Test case assert flag, default ASSERT",
+        action="append",
+        default=[],
+    )
+    parser.add_argument(
+        "--expected_flag",
+        help="Test case expected flag for compile, default EXCEPTED",
+        action="append",
+        default=[],
+    )
+    parser.add_argument(
+        "case_path", type=complete_path, help="Source path: read compare rules"
+    )
+    parser.add_argument(
+        "--compare_object",
+        nargs="?",
+        type=argparse.FileType("r"),
+        default=sys.stdin,
+        help="compare object, default stdin",
+    )
+    opts = parser.parse_args()
+    return opts
+
+
+if __name__ == "__main__":
+    logging.basicConfig(
+        format="\t%(message)s", level=logging.DEBUG, stream=sys.stderr,
+    )
+    main()
diff --git a/test/maple_test/configs.py b/test/maple_test/configs.py
new file mode 100644
index 0000000000000000000000000000000000000000..c42beef0954ead5b9528dd0a895554a8951e0ae1
--- /dev/null
+++ b/test/maple_test/configs.py
@@ -0,0 +1,397 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+"""
+store config file and command line config
+
+"""
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from maple_test.utils import ALL, BASE_DIR, OS_SEP
+from maple_test.utils import complete_path, read_config, get_config_value, is_relative
+
+TEST_CONFIG = {}
+LOGGER = None
+LOG_CONFIG = {}
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    test_framework_parser = parser.add_argument_group("Test FrameWork arguments")
+    test_framework_parser.add_argument(
+        "--cfg",
+        default=Path(BASE_DIR / "maple_test.cfg"),
+        type=complete_path,
+        help="Test framework configuration file",
+    )
+    test_framework_parser.add_argument(
+        "-j",
+        type=bigger_than_one_integer,
+        metavar="<mum>",
+        dest="processes",
+        default=1,
+        help="Run <num> cases in parallel",
+    )
+    test_framework_parser.add_argument(
+        "--retry",
+        metavar="<num>",
+        default=0,
+        type=bigger_than_one_integer,
+        help="Re-run unsuccessful test cases",
+    )
+    test_framework_parser.add_argument(
+        "--output",
+        metavar="<file>",
+        type=complete_path,
+        help="Store test result at <file>",
+    )
+    test_framework_parser.add_argument(
+        "--xml_output",
+        metavar="<file>",
+        type=complete_path,
+        help="Store test result as xunit xml format at <file>",
+    )
+    test_framework_parser.add_argument(
+        "--json_output",
+        metavar="<file>",
+        type=complete_path,
+        help="Store test result as josn format at <file>",
+    )
+    test_framework_parser.add_argument(
+        "--debug", action="store_true", help="keep test temp file"
+    )
+    test_framework_parser.add_argument(
+        "--fail_exit",
+        action="store_true",
+        help="Execute test framework with a non-zero exit code if any tests fail",
+    )
+    test_framework_parser.add_argument(
+        "-p",
+        type=str,
+        dest="print_type",
+        action="append",
+        default=[],
+        choices=ALL[:],
+        help="Print test cases with specified results, "
+        "-pPASS -pFAIL, to print all test case that failed or passed， "
+        "UNRESOLVED test case results are not displayed by default.",
+    )
+    test_framework_parser.add_argument(
+        "--progress",
+        choices=["silent", "normal", "no_flush_progress"],
+        default="normal",
+        help="set progress type, silent: Don't show progress, "
+        "normal: one line progress bar, update per second,"
+        "no_flush_progress: print test progress per 10 seconds",
+    )
+
+    test_suite_parser = parser.add_argument_group("Test Suite arguments")
+    test_suite_parser.add_argument(
+        "test_paths", nargs="*", type=complete_path, help="Test suite path",
+    )
+    test_suite_parser.add_argument(
+        "--test_cfg",
+        metavar="<TEST_CFG_FILE>",
+        type=complete_path,
+        help="test suite config file, "
+        "needed when run a single case or with --test_list",
+    )
+    test_suite_parser.add_argument(
+        "--test_list",
+        metavar="<TEST_LIST_FILE>",
+        type=complete_path,
+        default=None,
+        help="testlist path for filter test cases",
+    )
+    test_suite_parser.add_argument(
+        "-c",
+        "--config_set",
+        action="append",
+        dest="user_config_set",
+        default=[],
+        metavar="config set path",
+        help="Run a test set with the specified config set path",
+        type=complete_path,
+    )
+    test_suite_parser.add_argument(
+        "-C",
+        "--config",
+        dest="user_config",
+        metavar="key=value",
+        help="Add 'key' = 'val' to the user defined configs",
+        type=str,
+        action=StoreDictKeyPair,
+        default={},
+    )
+    test_suite_parser.add_argument(
+        "-E",
+        "--env",
+        dest="user_env",
+        metavar="key=value",
+        help="Add 'key' = 'val' to the user defined environment variable",
+        action=StoreDictKeyPair,
+        default={},
+    )
+
+    running_parser = parser.add_argument_group("Running arguments")
+    running_parser.add_argument(
+        "--temp_dir",
+        metavar="<TEMP_DIR_PATH>",
+        type=complete_path,
+        default=None,
+        help="Location for test execute. ",
+    )
+    running_parser.add_argument(
+        "--timeout", type=float, dest="timeout", default=600, help="test case timeout"
+    )
+
+    log_parser = parser.add_argument_group("Log arguments")
+    log_parser.add_argument(
+        "--log_dir",
+        metavar="<LOG_DIR_FILE_PATH>",
+        type=complete_path,
+        default=None,
+        help="Where to store test log",
+    )
+    log_parser.add_argument(
+        "--log_level",
+        "-l",
+        type=get_level_name,
+        default=None,
+        help="set log level from: CRITICAL, ERROR, WARNING, INFO, DEBUG, NOTSET",
+    )
+    log_parser.add_argument(
+        "--verbose", action="store_true", help="enable verbose output"
+    )
+    log_parser.add_argument(
+        "--fail-verbose",
+        dest="fail_verbose",
+        action="store_true",
+        help="enable not pass testcase verbose output",
+    )
+
+    args = parser.parse_args()
+
+    test_framework_config = {
+        "cfg": args.cfg,
+        "processes": args.processes,
+        "retry": args.retry,
+        "output": args.output,
+        "xml_output": args.xml_output,
+        "json_output": args.json_output,
+        "debug": args.debug,
+        "fail_exit": args.fail_exit,
+        "print_type": args.print_type,
+        "progress": args.progress,
+        "fail_verbose": args.fail_verbose,
+    }
+
+    test_suite_config = {
+        "test_paths": args.test_paths or None,
+        "test_cfg": args.test_cfg,
+        "cli_running_config": {
+            "test_list": args.test_list,
+            "user_config_set": args.user_config_set,
+            "user_config": args.user_config,
+            "user_env": args.user_env,
+        },
+    }
+
+    running_config = {
+        "temp_dir": args.temp_dir,
+        "timeout": args.timeout,
+    }
+
+    log_config = {
+        "dir": args.log_dir,
+        "level": args.log_level,
+        "verbose": args.verbose,
+    }
+
+    return test_framework_config, test_suite_config, running_config, log_config
+
+
+def parser_maple_test_config_file(maple_test_cfg_file):
+    raw_config = read_config(maple_test_cfg_file)
+    test_paths = get_config_value(raw_config, "test-home", "dir")
+    if test_paths:
+        test_paths = test_paths.replace("\n", "").split(":")
+    else:
+        test_paths = []
+    test_suite_config = {
+        "test_paths": [complete_path(BASE_DIR / path) for path in test_paths if path],
+    }
+    log_config = {
+        "dir": complete_path(
+            BASE_DIR / Path(get_config_value(raw_config, "logging", "name"))
+        ),
+        "level": get_level_name(get_config_value(raw_config, "logging", "level")),
+    }
+
+    running_config = {
+        "temp_dir": complete_path(
+            BASE_DIR / Path(get_config_value(raw_config, "running", "temp_dir"))
+        ),
+    }
+
+    return test_suite_config, running_config, log_config
+
+
+def init_config():
+    global TEST_CONFIG
+    (
+        TEST_CONFIG,
+        cli_test_suite_config,
+        cli_running_config,
+        cli_log_config,
+    ) = parse_args()
+
+    (
+        file_test_suite_config,
+        file_running_config,
+        file_log_config,
+    ) = parser_maple_test_config_file(TEST_CONFIG.get("cfg"))
+
+    cli_test_paths = cli_test_suite_config.get("test_paths") or []
+    file_test_paths = file_test_suite_config.get("test_paths") or []
+
+    for path1 in cli_test_paths:
+        for path2 in file_test_paths:
+            if is_relative(path1, path2):
+                user_test_cfg = cli_test_suite_config.get("test_cfg")
+                if not user_test_cfg:
+                    cli_test_suite_config["test_cfg"] = complete_path(
+                        path2 / "test.cfg"
+                    )
+
+    test_suite_config = merge_config(cli_test_suite_config, file_test_suite_config)
+    running_config = merge_config(cli_running_config, file_running_config)
+    log_config = merge_config(cli_log_config, file_log_config)
+
+    if log_config.get("dir") is None:
+        log_dir = complete_path(Path("./maple_test_log"))
+        print(
+            "No log dir find in cfg file and cli args, will create lod gir at: {}".format(
+                log_dir
+            )
+        )
+        log_config["dir"] = log_dir
+
+    global LOGGER
+    maple_test_log_config = log_config.copy()
+    maple_test_log_config["verbose"] = True
+    maple_test_log_config["level"] = min(20, maple_test_log_config.get("level"))
+    stream_fmt = logging.Formatter("%(message)s")
+    log_dir = maple_test_log_config.get("dir")
+    if not log_dir.exists():
+        log_dir.mkdir(parents=True, exist_ok=True)
+    LOGGER = construct_logger(
+        maple_test_log_config,
+        "Maple_Test",
+        stream_fmt=stream_fmt,
+        stream_level=min(20, maple_test_log_config.get("level")),
+    )
+    LOGGER.info("Test log saved to {}".format(log_dir))
+    running_config["log_config"] = log_config.copy()
+
+    return test_suite_config, running_config, log_config
+
+
+def merge_config(cli_config, maple_test_config):
+    config = {}
+    config.update(maple_test_config)
+    for key, value in cli_config.items():
+        if value is not None:
+            config[key] = value
+    return config
+
+
+def get_val(key):
+    global TEST_CONFIG
+    return TEST_CONFIG.get(key)
+
+
+class StoreDictKeyPair(argparse.Action):
+    def __init__(self, option_strings, dest, nargs=None, **kwargs):
+        self._nargs = nargs
+        super().__init__(option_strings, dest, nargs=nargs, **kwargs)
+
+    def __call__(self, parser, namespace, value, option_string=None):
+        my_dict = getattr(namespace, self.dest)
+        k = value.strip().split("=")[0].strip()
+        v = "=".join(value.strip().split("=")[1:]).strip()
+        my_dict[k] = v
+        setattr(namespace, self.dest, my_dict)
+
+
+def construct_logger(
+    log_config,
+    name,
+    stream_fmt=None,
+    file_fmt=None,
+    stream_level=None,
+    file_level=logging.DEBUG,
+):
+    name = str(name)
+    log_dir = str(log_config["dir"])
+    level = log_config["level"]
+    verbose = log_config["verbose"]
+    formatter = logging.Formatter(
+        "%(asctime)s %(levelname)s %(name)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+    )
+    if stream_fmt is None:
+        stream_fmt = formatter
+    if file_fmt is None:
+        file_fmt = formatter
+    logger = logging.getLogger(name)
+    if logger.handlers:
+        return logger
+    logger.setLevel(logging.DEBUG)
+
+    handler1 = logging.StreamHandler()
+    handler1.setFormatter(stream_fmt)
+    if not verbose:
+        level = logging.WARNING
+    else:
+        level = logging.DEBUG
+    if stream_level:
+        level = stream_level
+    handler1.setLevel(level)
+    logger.addHandler(handler1)
+
+    log_path = "{}{}{}.log".format(log_dir, OS_SEP, name)
+    handler2 = logging.FileHandler(filename=log_path, mode="w")
+    handler2.setLevel(file_level)
+    handler2.setFormatter(file_fmt)
+    logger.addHandler(handler2)
+
+    logger.debug("Log file at: {}".format(log_path))
+    return logger
+
+
+def get_level_name(name: str):
+    name = name.upper()
+    return logging.getLevelName(name)
+
+
+def bigger_than_one_integer(num):
+    inum = int(num)
+    if inum < 1:
+        raise argparse.ArgumentTypeError("{} is not bigger than one".format(num))
+    return inum
diff --git a/test/maple_test/main.py b/test/maple_test/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..64017c15a9730402f45d69009d81476816e290af
--- /dev/null
+++ b/test/maple_test/main.py
@@ -0,0 +1,114 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+"""
+maple test - Maple Tester
+
+
+"""
+import shutil
+import time
+from xml.etree import ElementTree
+
+from maple_test import configs
+from maple_test.task import TestSuiteTask
+from maple_test.utils import timer, FAIL, UNRESOLVED, OS_SEP
+from maple_test.run import TestError
+
+
+def main():
+    test_suite_config, running_config, log_config = configs.init_config()
+    logger = configs.LOGGER
+    log_dir = log_config.get("dir")
+
+    test_paths = test_suite_config.get("test_paths")
+    cli_test_cfg = test_suite_config.get("test_cfg")
+    cli_running_config = test_suite_config.get("cli_running_config")
+
+    root = ElementTree.Element("testsuites")
+    json_result = []
+
+    retry = configs.get_val("retry")
+    result = ""
+    failed = False
+    for test in test_paths:
+        test_cfg = cli_test_cfg
+        test_result = None
+        test_failed = False
+        if test.exists():
+            if not test_cfg:
+                test_cfg = test / "test.cfg"
+            try:
+                task = TestSuiteTask(test, test_cfg, running_config, cli_running_config)
+            except TestError as e:
+                logger.info(e)
+                continue
+            if not task.task_set:
+                continue
+            for run_time in range(1, retry + 2):
+                logger.info("Run {} times".format(run_time))
+                failed_num = task.run(configs.get_val("processes"))
+                if failed_num > 0:
+                    test_failed = True
+                else:
+                    test_failed = False
+                test_result = task.gen_summary([])
+            failed |= test_failed
+            result += test_result
+            task.gen_xml_result(root)
+            json_result.append(task.gen_json_result())
+        else:
+            logger.info("Test path: {} does not exist, please check".format(test))
+
+    xml_output = configs.get_val("xml_output")
+    if xml_output:
+        with xml_output.open("w") as f:
+            f.write(ElementTree.tostring(root).decode("utf-8"))
+
+    json_output = configs.get_val("json_output")
+    if json_output:
+        with json_output.open("w") as f:
+            import json
+
+            json.dump(json_result, f, indent=2)
+
+    output = configs.get_val("output")
+    if output:
+        if output.exists() and output.is_file():
+            name = "{}_{}{}".format(output.stem, int(time.time()), output.suffix)
+            logger.info(
+                "result file: {} exists, will move exists file to: {}".format(
+                    output, name
+                )
+            )
+            shutil.move(str(output), str(output.parent / name))
+        logger.info("Save test result at: {}".format(output))
+        with output.open("w", encoding="utf-8") as f:
+            f.write(result)
+
+    temp_dir = running_config.get("temp_dir")
+    if configs.get_val("debug"):
+        logger.debug("Keep temp file at %s", temp_dir)
+    elif temp_dir.exists():
+        logger.debug("remove temp_dir %s", temp_dir)
+        shutil.rmtree(str(temp_dir))
+
+    if configs.get_val("fail_exit") and failed:
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/test/maple_test/maple_test.cfg b/test/maple_test/maple_test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e2c0cab928fd7bef9fa6ae4cbb2fbfbd64e557a5
--- /dev/null
+++ b/test/maple_test/maple_test.cfg
@@ -0,0 +1,14 @@
+# 测试框架配置文件，当前框架仅支持通过配置文件配置测试套，测试运行时的临时路径，测试日志的保存
+[test-home]
+# 指定测试套路径，以‘：’划分
+dir =
+    ../testsuite/irbuild_test:
+
+[running]
+#指定运行时的临时路径
+temp_dir = ../test_temp/run
+
+[logging]
+#指定运行时保存日志的路径
+name = ../test_temp/log
+level = INFO
\ No newline at end of file
diff --git a/test/maple_test/run.py b/test/maple_test/run.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ff9a5c8b29ae9feb8e359e1d0ad354654ce8da3
--- /dev/null
+++ b/test/maple_test/run.py
@@ -0,0 +1,213 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+import os
+import signal
+import subprocess
+import sys
+import time
+import timeit
+import logging
+import platform
+import ctypes
+from textwrap import indent, shorten
+
+from maple_test.configs import construct_logger, get_val
+from maple_test.utils import PASS, FAIL, UNRESOLVED, NOT_RUN, ENCODING
+from maple_test.utils import add_run_path
+
+
+class TestError(Exception):
+    pass
+
+
+def handle_result_encoding(com_out, com_err, logger):
+    try:
+        com_out = com_out.decode(ENCODING, errors="strict")
+        com_err = com_err.decode(ENCODING, errors="strict")
+    except UnicodeDecodeError:
+        com_out = com_out.decode('utf-8', errors="strict")
+        com_err = com_err.decode('utf_8', errors="strict")
+        logger.debug("Can not decode stdout/stderr with {}, using utf-8!".format(ENCODING))
+    return com_out, com_err
+
+
+def run_command_win(cmd, work_dir, timeout, logger, env=None):
+    """Run commands using subprocess on Windows
+
+    We set PYTHONIOENCODING to utf-8 on Windows to keep up with
+    test case file`s read encoding in compare.py to avoid some
+    character set issues.
+
+    """
+    new_env = add_run_path(str(work_dir))
+    new_env.update(env)
+    encoding_env = {'PYTHONIOENCODING': 'utf-8'}
+    new_env.update(encoding_env)
+    process_command = subprocess.Popen(
+        cmd,
+        shell=True,
+        cwd=str(work_dir),
+        env=new_env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    logger.debug("execute cmd ===>>>: %s", cmd)
+    return_code = com_out = com_err = None
+    try:
+        com_out, com_err = process_command.communicate(timeout=timeout)
+    except subprocess.CalledProcessError as err:
+        return_code, com_out, com_err = err.returncode, "", err
+        logger.exception(err)
+        return return_code, com_out, com_err
+    except subprocess.TimeoutExpired:
+        return_code, com_out, com_err = 3, "TimeOut", "TimeOut"
+        return return_code, com_out, com_err
+    else:
+        return_code = process_command.returncode
+        com_out, com_err = handle_result_encoding(com_out, com_err, logger)
+        return return_code, com_out, com_err
+    finally:
+        handle = ctypes.windll.kernel32.OpenProcess(1, False, process_command.pid)
+        ctypes.windll.kernel32.TerminateProcess(handle, -1)
+        ctypes.windll.kernel32.CloseHandle(handle)
+        logger.debug("return code: %d", return_code)
+        logger.debug("stdout : \n%s",
+                     indent(com_out, "+\t", lambda line: True).encode().decode(ENCODING, errors='ignore'))
+        logger.debug("stderr : \n%s",
+                     indent(com_err, "@\t", lambda line: True).encode().decode(ENCODING, errors='ignore'))
+
+
+def run_command_linux(cmd, work_dir, timeout, logger, env=None):
+    new_env = add_run_path(str(work_dir))
+    new_env.update(env)
+    process_command = subprocess.Popen(
+        cmd,
+        shell=True,
+        cwd=str(work_dir),
+        env=new_env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        close_fds=True,
+        start_new_session=True,
+    )
+    logger.debug("execute cmd ===>>>: %s", cmd)
+    return_code = com_out = com_err = None
+    try:
+        com_out, com_err = process_command.communicate(timeout=timeout)
+    except subprocess.CalledProcessError as err:
+        return_code, com_out, com_err = err.returncode, "", err
+        logger.exception(err)
+        return return_code, com_out, com_err
+    except subprocess.TimeoutExpired:
+        return_code, com_out, com_err = 3, "", "TimeOut"
+        return return_code, com_out, com_err
+    else:
+        return_code = process_command.returncode
+        com_out, com_err = handle_result_encoding(com_out, com_err, logger)
+        return return_code, com_out, com_err
+    finally:
+        process_command.kill()
+        try:
+            os.killpg(process_command.pid, signal.SIGTERM)
+        except ProcessLookupError:
+            pass
+        logger.debug("return code: %d", return_code)
+        logger.debug("stdout : \n%s",
+                     indent(com_out, "+\t", lambda line: True).encode().decode(ENCODING, errors='ignore'))
+        logger.debug("stderr : \n%s",
+                     indent(com_err, "@\t", lambda line: True).encode().decode(ENCODING, errors='ignore'))
+
+
+def run_commands(
+    position, old_result, commands, work_dir, timeout, log_config, env=None
+):
+    name = "{}_{}".format(log_config[1], int(time.time()))
+    name = log_config[1]
+    formatter = logging.Formatter(
+        "%(asctime)s %(levelname)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+    )
+    logger = construct_logger(log_config[0], log_config[1], file_fmt=formatter)
+    if not commands:
+        err = "Run task exit unexpected : {}, Log file at: {}.log".format(
+            old_result[-1], log_config[0].get("dir") / name
+        )
+        logger.error(err)
+        return position, old_result
+    remain_time = timeout
+    result = (PASS, None)
+    logger.debug("Work directory: {}".format(work_dir))
+
+    if platform.system() == "Windows":
+        run_command = run_command_win
+    else:
+        run_command = run_command_linux
+
+    commands_result = []
+    for command in commands:
+        start = timeit.default_timer()
+
+        return_code, com_out, com_err = run_command(
+            command, work_dir, remain_time, logger, env
+        )
+        run_time = timeit.default_timer() - start
+        remain_time = remain_time - run_time
+        logger.debug(
+            "Run time: {:.2}, remain time: {:.2}".format(run_time, remain_time)
+        )
+        command_result = {}
+        command_result["cmd"] = command
+        command_result["return_code"] = return_code
+        command_result["stdout"] = com_out
+        command_result["stderr"] = com_err
+        commands_result.append(command_result)
+        if return_code != 0:
+            result = (FAIL, commands_result)
+            err = "Failed, Log file at: {}.log".format(log_config[0].get("dir") / name)
+            logger.error(err)
+            break
+        else:
+            result = (PASS, commands_result)
+    if result[0] == PASS:
+        logger.debug("Task executed successfully")
+    handlers = logger.handlers[:]
+    for handler in handlers:
+        handler.close()
+        logger.removeHandler(handler)
+    return position, result
+
+
+def progress(results, progress_type):
+    """Output test progress"""
+
+    if progress_type == "silent":
+        return 0
+    if progress_type == "normal":
+        time_gape = 1
+        print_progress = sys.stdout.write
+    else:
+        time_gape = 10
+        print_progress = print
+    finished = 0
+    total = len(results)
+    while total != finished:
+        time.sleep(time_gape)
+        finished = sum([result.ready() for result in results])
+        rate = finished / total
+        print_progress(
+            "\rRunning test cases: {:.2%} ({}/{}) ".format(rate, finished, total)
+        )
+        sys.stdout.flush()
diff --git a/test/maple_test/task.py b/test/maple_test/task.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed90249516c9dfb0092d2e4d87bad0118498d5a5
--- /dev/null
+++ b/test/maple_test/task.py
@@ -0,0 +1,593 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+import copy
+import multiprocessing
+import shlex
+import shutil
+import time
+import platform
+from collections import defaultdict, OrderedDict
+from pathlib import Path
+
+from maple_test import configs
+from maple_test.run import run_commands, progress, TestError
+from maple_test.test import Case, read_list
+from maple_test.utils import (
+    EXECUTABLE,
+    COMPARE,
+    PASS,
+    FAIL,
+    NOT_RUN,
+    UNRESOLVED,
+    DEFAULT_PRINT,
+    OS_SEP,
+)
+from maple_test.utils import (
+    read_config,
+    config_section_to_dict,
+    get_config_value,
+    ls_all,
+    complete_path,
+    is_relative,
+    quote,
+)
+
+
+class TaskConfig:
+    def __init__(self, path, config, top_config, user_config=None, user_env=None):
+        if top_config is None:
+            name = path.name
+            self.internal_var = {}
+            self.env = {}
+            self.suffix_comments = {}
+        else:
+            self.inherit_top_config(top_config)
+            name = str(path.relative_to(top_config.path.parent)).replace(OS_SEP, "_")
+        self.name = name.replace(".", "_")
+        self.path = complete_path(path)
+        self.base_dir = self.path.parent
+        self.update_sub_config(config)
+        self.update_by_user_config(user_config, user_env)
+
+    def inherit_top_config(self, top_config):
+        self.internal_var = copy.deepcopy(top_config.internal_var)
+        self.env = copy.deepcopy(top_config.env)
+        self.suffix_comments = copy.deepcopy(top_config.suffix_comments)
+
+    def update_by_user_config(self, user_config, user_env):
+        if user_config is None:
+            user_config = {}
+        if user_env is None:
+            user_env = {}
+        self.internal_var.update(user_config)
+        self.env.update(user_env)
+
+    def update_sub_config(self, config):
+        if self.path.exists():
+            self.internal_var.update(config_section_to_dict(config, "internal-var"))
+            self.env.update(config_section_to_dict(config, "env"))
+            self.suffix_comments.update(config_section_to_dict(config, "suffix"))
+        else:
+            print(
+                "config file: {}, not exists, will use upper config".format(self.path)
+            )
+
+    def get_case_config(self, case):
+        case_config = {
+            "internal_var": copy.deepcopy(self.internal_var),
+            "env": copy.deepcopy(self.env),
+        }
+        case_config["internal_var"]["f"] = str(case.path.name)
+        case_config["internal_var"]["n"] = str(case.path.stem)
+        return case_config
+
+    def __repr__(self):
+        return str(self.name)
+
+
+class TestSuiteTask:
+    def __init__(self, test_path, cfg_path, running_config, cli_running_config=None):
+        if cli_running_config is None:
+            cli_running_config = {}
+
+        self.path = complete_path(test_path)
+        self.cfg_path = cfg_path
+
+        config = read_config(self.cfg_path)
+        if config is None:
+            raise TestError(
+                "Test suite config path:{} not found, skip!!!!!".format(self.cfg_path)
+            )
+        try:
+            self.name = config["description"]["title"].replace(" ", "")
+        except KeyError:
+            self.name = self.path.name
+        self.suffix_comments = config_section_to_dict(config, "suffix")
+
+        self.result = defaultdict(int)
+
+        self.config_set = {}
+        self.testlist_set = {}
+
+        self.task_set = defaultdict(list)
+        self.task_set_result = {}
+        self.all_cases = {}
+        self._form_task_set(running_config, cli_running_config)
+
+    def _form_task_set(self, running_config, cli_running_config):
+        logger = configs.LOGGER
+        user_test_list = cli_running_config.get("test_list")
+        user_config_set = cli_running_config.get("user_config_set")
+        user_config = cli_running_config.get("user_config")
+        user_env = cli_running_config.get("user_env")
+
+        raw_top_config = read_config(self.cfg_path)
+        top_config = TaskConfig(
+            self.cfg_path, raw_top_config, None, user_config, user_env
+        )
+        top_dir = top_config.base_dir
+        if user_test_list is None:
+            top_testlist_path = self._get_testlist(raw_top_config, top_dir)
+        else:
+            top_testlist_path = top_dir / user_test_list
+
+        if user_config_set:
+            run_config_set = user_config_set
+        else:
+            run_config_set = [self.cfg_path]
+
+        for cfg in run_config_set:
+            if not cfg.exists():
+                logger.error("Error: cfg file: {} not found, will skip".format(cfg))
+                continue
+            try:
+                raw_config = read_config(cfg)
+            except:
+                logger.error(
+                    "The found configuration file {} has an error and will "
+                    "skip the test configuration file, please modify the "
+                    "configuration file or ignore the message. ".format(cfg)
+                )
+                continue
+            config = TaskConfig(cfg, raw_config, top_config, user_config, user_env)
+            name = config.name
+            base_dir = config.base_dir
+            if cfg == self.cfg_path:
+                testlist_path = top_testlist_path
+            else:
+                testlist_path = self._get_testlist(raw_config, base_dir)
+            self.task_set_result[name] = OrderedDict(
+                {PASS: 0, FAIL: 0, NOT_RUN: 0, UNRESOLVED: 0}
+            )
+            for case in self._search_list(base_dir, testlist_path):
+                task = SingleTask(case, config, running_config)
+                self.task_set[name].append(task)
+                self.task_set_result[name][task.result[0]] += 1
+        if sum([len(case) for case in self.task_set.values()]) < 1:
+            logger.info(
+                "Path %s not in testlist, be sure add path to testlist", str(self.path),
+            )
+
+    @staticmethod
+    def _get_testlist(config, base_dir):
+        testlist_path = get_config_value(config, "testlist", "path")
+        if testlist_path is None:
+            testlist_path = base_dir / "testlist"
+        else:
+            testlist_path = base_dir / testlist_path
+        return testlist_path
+
+    def _search_list(self, base_dir, testlist_path):
+        logger = configs.LOGGER
+        suffixes = self.suffix_comments.keys()
+        include, exclude = read_list(testlist_path)
+        case_files = set()
+        cases = []
+        all_test_case, exclude_test_case = self._search_case(
+            include, exclude, base_dir, suffixes
+        )
+        case_files = set()
+        for pattern in all_test_case:
+            _cases = all_test_case[pattern]
+            if _cases:
+                case_files.update(_cases)
+            else:
+                logger.info(
+                    "Testlist: {}, ALL-TEST-CASE: {} is invalid test case".format(
+                        testlist_path, pattern
+                    )
+                )
+        for pattern in exclude_test_case:
+            _cases = exclude_test_case[pattern]
+            if _cases:
+                case_files -= _cases
+            else:
+                logger.info(
+                    "Testlist: {}, EXCLUDE-TEST-CASE: {} is invalid test case".format(
+                        testlist_path, pattern
+                    )
+                )
+
+        if self.path.is_file():
+            case_files = [self.path]
+        else:
+            case_files = [
+                file.relative_to(self.path)
+                for file in case_files
+                if is_relative(file, self.path)
+            ]
+        for case_file in case_files:
+            case_name = str(case_file).replace(".", "_")
+            comment = self.suffix_comments[case_file.suffix[1:]]
+            if case_name not in self.all_cases:
+                case = Case(case_file, self.path, comment,)
+                self.all_cases[case_name] = case
+            cases.append(self.all_cases[case_name])
+        return cases
+
+    @staticmethod
+    def _search_case(include, exclude, base_dir, suffixes):
+        case_files = set()
+        all_test_case = {}
+        exclude_test_case = {}
+        for glob_pattern in include:
+            all_test_case[glob_pattern] = set()
+            for include_path in base_dir.glob(glob_pattern):
+                case_files.update(ls_all(include_path, suffixes))
+                all_test_case[glob_pattern].update(ls_all(include_path, suffixes))
+        for glob_pattern in exclude:
+            exclude_test_case[glob_pattern] = set()
+            for exclude_path in base_dir.glob(glob_pattern):
+                case_files -= set(ls_all(exclude_path, suffixes))
+                exclude_test_case[glob_pattern].update(ls_all(exclude_path, suffixes))
+        return all_test_case, exclude_test_case
+
+    def serial_run_task(self):
+        for tasks_name in self.task_set:
+            for index, task in enumerate(self.task_set[tasks_name]):
+                if task.result[0] == PASS or task.result[0] == UNRESOLVED:
+                    continue
+                self.task_set_result[tasks_name][task.result[0]] -= 1
+                _, task.result = run_commands(
+                    (tasks_name, index),
+                    task.result,
+                    task.commands,
+                    **task.running_config
+                )
+                if configs.get_val("fail_verbose"):
+                    self.output_failed((_, task.result))
+                status, _ = task.result
+                self.task_set_result[tasks_name][status] += 1
+
+    def output_failed(self, result):
+        output_template = (
+            "\n--------\n"
+            "TestCase Failed: \n"
+            "Name           : {name}\n"
+            "CMD list       : \n--------\n"
+            "{cmd_list}"
+            "--------\n"
+            "Output         : \n{cmd_output}"
+            "--------\n"
+        )
+
+        cmd_list_template = "{0: <15}:{1}\n"
+
+        cmd_template = (
+            "\n"
+            "CMD            : {cmd}\n"
+            "Return code    : {return_code}\n"
+            "Stdout         : {stdout}\n"
+            "Stderr         : {stderr}\n"
+        )
+
+        postion, result = result
+        case = self.task_set[postion[0]][postion[1]]
+        output = {}
+        output["name"] = str(case)
+        output["cmd_list"] = ""
+        output["cmd_output"] = ""
+        if result[0] == PASS:
+            return
+        if result[0] != PASS and not isinstance(result[1], str):
+            for cmd_result in result[1]:
+                output["cmd_output"] += cmd_template.format(**cmd_result)
+            for cmd in case.commands[: len(result[1]) - 1]:
+                output["cmd_list"] += cmd_list_template.format(PASS, cmd)
+            output["cmd_list"] += cmd_list_template.format(
+                FAIL, case.commands[len(result[1]) - 1]
+            )
+            for cmd in case.commands[len(result[1]) :]:
+                output["cmd_list"] += cmd_list_template.format(NOT_RUN, cmd)
+        else:
+            output["cmd_list"] = "Test case preparation failed, " + result[1] + "\n"
+            output["cmd_output"] = output["cmd_list"]
+        print(output_template.format(**output))
+
+    def parallel_run_task(self, process_num):
+        multiprocessing.freeze_support()
+        pool = multiprocessing.Pool(min(multiprocessing.cpu_count(), process_num))
+        result_queue = []
+        if configs.get_val("fail_verbose"):
+            callback_func = self.output_failed
+        else:
+            callback_func = None
+        for tasks_name in self.task_set:
+            for index, task in enumerate(self.task_set[tasks_name]):
+                if task.result[0] == PASS or task.result[0] == UNRESOLVED:
+                    continue
+                result_queue.append(
+                    pool.apply_async(
+                        run_commands,
+                        args=((tasks_name, index), task.result, task.commands,),
+                        kwds=task.running_config,
+                        callback=callback_func,
+                    )
+                )
+        progress(result_queue, configs.get_val("progress"))
+        pool.close()
+        pool.join()
+
+        result_queue = [result.get() for result in result_queue]
+        for position, result in result_queue:
+            tasks_name, index = position
+            task = self.task_set[tasks_name][index]
+            self.task_set_result[tasks_name][task.result[0]] -= 1
+            task.result = result
+            self.task_set_result[tasks_name][result[0]] += 1
+
+    def run(self, process_num=1):
+        logger = configs.LOGGER
+        if process_num == 1:
+            logger.debug("The number of running processes is 1, which will run serial")
+            self.serial_run_task()
+        else:
+            logger.debug(
+                "The number of running processes is {}, and will run in parallel".format(
+                    process_num
+                )
+            )
+            self.parallel_run_task(process_num)
+        print_type = configs.get_val("print_type")
+        for line in self.gen_summary(print_type).splitlines():
+            logger.info(line)
+        return self.result[FAIL]
+
+    def gen_brief_summary(self, print_type):
+        total = sum(self.result.values())
+        result = copy.deepcopy(self.result)
+        total -= result.pop(NOT_RUN)
+        if UNRESOLVED not in print_type:
+            total -= result.pop(UNRESOLVED)
+
+        total_summary = "TestSuiteTask: {}, Total: {}, ".format(
+            self.name, total
+        ) + "".join(
+            [
+                "{}: {}, ".format(k, v)
+                for k, v in sort_dict_items(result, index=1, reverse=True)
+            ]
+        )
+        task_set_summary = ""
+        for tasks_name in self.task_set:
+            total = sum(self.task_set_result[tasks_name].values())
+            task_result = copy.deepcopy(self.task_set_result[tasks_name])
+            total -= task_result.pop(NOT_RUN)
+            if UNRESOLVED not in print_type:
+                total -= task_result.pop(UNRESOLVED)
+            task_set_summary += (
+                "\n  "
+                + tasks_name
+                + ", total: {}, ".format(total)
+                + "".join(
+                    [
+                        "{}: {}, ".format(k, v)
+                        for k, v in sort_dict_items(task_result, index=1, reverse=True)
+                    ]
+                )
+            )
+        return total_summary + task_set_summary + "\n"
+
+    def gen_summary(self, print_type=None):
+        self.result = defaultdict(int)
+        for name in self.task_set_result:
+            for status, num in self.task_set_result[name].items():
+                self.result[status] += num
+        if print_type is None:
+            print_type = configs.get_val("print_type")
+        brief_summary = self.gen_brief_summary(print_type)
+        summary = "-" * 120
+        summary += "\nTestSuite Path: {}\n".format(self.path)
+        for tasks_name in self.task_set:
+            for task in sorted(self.task_set[tasks_name], key=lambda task: task.name):
+                result = task.result[0]
+                if result in print_type or (not print_type and result in DEFAULT_PRINT):
+                    summary += "  {}, Case: {}, Result: {}\n".format(
+                        tasks_name, task.case_path, result
+                    )
+        summary += "\n" + brief_summary
+        summary += "-" * 120
+        return summary
+
+    def gen_result(self):
+        from maple_test.test import Result
+
+        results = []
+        for task_name in self.task_set:
+            for task in self.task_set[task_name]:
+                result = Result(
+                    task.case_path,
+                    self.cfg_path.parent.name,
+                    task_name,
+                    task.result[0],
+                    task.commands,
+                    task.result[-1],
+                )
+                results.append(result)
+        return results
+
+    def gen_xml_result(self, root):
+        from xml.etree import ElementTree
+
+        suite = ElementTree.SubElement(
+            root,
+            "testsuite",
+            failures=str(self.result[FAIL]),
+            tests=str(sum(self.result.values())),
+            name="{} {}".format(self.name, self.path),
+        )
+        for result in sorted(self.gen_result()):
+            result.gen_xml(suite)
+        return suite
+
+    def gen_json_result(self):
+        json_result = OrderedDict()
+        json_result["name"] = "{} {}".format(self.name, self.path)
+        json_result["total"] = sum(self.result.values())
+        for status in self.result:
+            if status == NOT_RUN:
+                continue
+            json_result[status] = self.result[status]
+        json_result["tests"] = []
+        for result in sorted(self.gen_result()):
+            json_result["tests"].append(result.gen_json_result())
+        return json_result
+
+
+class SingleTask:
+    def __init__(self, case, config, running_config):
+        self.name = "{}{}{}_{}".format(case.test_name, OS_SEP, case.name, config.name)
+        self.path = Path(self.name)
+        config = config.get_case_config(case)
+        temp_dir = "{}_{}".format(self.path.name.replace(".", "_"), int(time.time()))
+        self.work_dir = running_config["temp_dir"] / self.path.parent / temp_dir
+        self.running_config = {
+            "work_dir": self.work_dir,
+            "log_config": (running_config["log_config"], self.name),
+            "timeout": running_config["timeout"],
+            "env": config["env"],
+        }
+        self.case_path = case.relative_path
+        if case.commands:
+            prepare_result = self.prepare(case, self.work_dir, config)
+            self.result = (NOT_RUN, None)
+            log_dir = (running_config.get("log_config").get("dir") / self.name).parent
+            self.prepare_dir(log_dir)
+            self.result = prepare_result
+        else:
+            self.result = (UNRESOLVED, (1, "", "No valid command statement was found."))
+
+        self.commands = []
+        if self.result[0] == NOT_RUN:
+            self._form_commands(case, config)
+
+    def prepare(self, case, dest, config):
+        src_path = case.path
+        logger = configs.LOGGER
+        if not src_path.exists():
+            err = "Source: {} is not existing.\n".format(src_path)
+            logger.debug(err)
+            return FAIL, err
+        self.prepare_dir(dest)
+        shutil.copy(str(src_path), str(dest))
+        logger.debug("Copy {} => {}".format(src_path, dest))
+        return self.prepare_dependence(src_path.parent, case.dependence, dest, config)
+
+    def prepare_dependence(self, src_dir, dependence, dest, config):
+        logger = configs.LOGGER
+        src_files = []
+        for file in dependence:
+            file = SingleTask._form_line(file, config)
+            src_path = src_dir / file
+            if src_path.exists():
+                src_files.append(src_path)
+            else:
+                err = "DEPENDENCE keyword error, file: {} NotFound".format(file)
+                logger.debug(err)
+                return FAIL, err
+        src_files = set(src_files)
+        for file in src_files:
+            if file.is_file():
+                shutil.copy(str(file), str(dest))
+            else:
+                name = file.name
+                try:
+                    shutil.copytree(str(file), str(dest / name))
+                except:
+                    pass
+        if src_files:
+            logger.debug("Copy {} => {}".format(src_files, dest))
+        return NOT_RUN, None
+
+    @staticmethod
+    def prepare_dir(directory):
+        logger = configs.LOGGER
+        if not directory.exists():
+            try:
+                directory.mkdir(parents=True, exist_ok=True)
+                logger.debug("Create directory: {}".format(directory))
+            except FileExistsError as err:
+                logger.debug(err)
+                logger.debug(
+                    "File: {} is not an existing non-directory file.".format(directory)
+                )
+
+    def _form_commands(self, case, config):
+        for command in case.commands:
+            command = self._form_line(command, config)
+            compare_cmd = " {} {} --comment={} ".format(
+                EXECUTABLE, COMPARE, quote(case.comment)
+            )
+            self.commands.append(format_compare_command(command, compare_cmd))
+
+    @staticmethod
+    def _form_line(line, config):
+        for key, value in config.get("internal_var").items():
+            end = 0
+            while end < len(line):
+                start = line.find("%{}".format(key), end)
+                if start == -1:
+                    break
+                end = len(key) + start + 1
+                if end == len(line):
+                    line = line[:start] + value + line[end:]
+                elif not line[end].isalnum() and line[end] != "_":
+                    line = line[:start] + value + line[end:]
+        return line
+
+    def __repr__(self):
+        return "{}".format(self.path)
+
+
+def format_compare_command(raw_command, compare_cmd):
+    end = 0
+    while end < len(raw_command):
+        start = raw_command.find("compare ", end)
+        if start == -1:
+            break
+        end = start + len("compare ")
+        if start == 0:
+            prev_char = ""
+        else:
+            prev_char = raw_command[start - 1]
+        if not prev_char.isalnum() and prev_char != "_":
+            raw_command = raw_command[:start] + compare_cmd + raw_command[end:]
+    return raw_command
+
+
+def sort_dict_items(d, index=0, reverse=False):
+    return sorted(d.items(), key=lambda item: item[index], reverse=reverse)
diff --git a/test/maple_test/template.cfg b/test/maple_test/template.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e7b991274cde1151277aa03e907210b92cb95758
--- /dev/null
+++ b/test/maple_test/template.cfg
@@ -0,0 +1,15 @@
+# template.cfg： 测试套模板配置文件，编写测试套时，可参考该文件，注意测试套下的配置文件名应为test.cfg
+# 当前主要由三个部分组成：
+# suffix: 测试用例后缀和测试用例中的注释符
+# internal-val: 测试用例中的内置变量，变量名由支持字符串和下划线构成，运行时将替换，例如：%swarn -S 2.c -o - ==》  gcc -S 2.c -o -
+# description: 测试套描述
+
+[suffix]
+s=//
+c=//
+
+[internal-var]
+swarn=gcc
+
+[description]
+title=C Test
diff --git a/test/maple_test/test.py b/test/maple_test/test.py
new file mode 100644
index 0000000000000000000000000000000000000000..b67f29ff2089f694a8b7201efd795f5e4d83ee61
--- /dev/null
+++ b/test/maple_test/test.py
@@ -0,0 +1,179 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+import shlex
+from functools import total_ordering
+
+from maple_test.utils import PASS, EXEC_FLAG, ERRCHECK_FLAG, EXPECT_FLAG, DEPENDENCE_FLAG
+from maple_test.utils import read_file
+from maple_test.utils import split_comment, filter_line, filter_command_line
+from maple_test.utils import FAIL, UNRESOLVED
+
+
+class Case:
+    def __init__(self, path, test_path, comment):
+        if path != test_path:
+            self.name = str(path).replace(".", "_")
+            self.path = test_path / path
+            self.test_name = test_path.name
+        else:
+            self.name = "{}_{}".format(path.parent.name, path.name).replace(".", "_")
+            self.path = path
+            self.test_name = path.parent.name
+        self.test_path = test_path
+        self.relative_path = path
+        self.comment = comment
+        try:
+            _, comment_lines = split_comment(comment, read_file(self.path),)
+        except UnicodeDecodeError as e:
+            print(e)
+            self.commands = []
+            self.expect = []
+            self.dependence = {}
+        else:
+            self.commands = extract_commands(comment_lines)
+            self.expect = extract_expect(comment_lines)
+            self.dependence = extract_dependence(comment_lines)
+
+    def __repr__(self):
+        return str(self.relative_path)
+
+
+def extract_expect(comment_lines):
+    expect_line = [filter_line(line, EXPECT_FLAG) for line in comment_lines]
+    expect_line = [line for line in expect_line if line]
+    if not expect_line:
+        return PASS
+    return expect_line[-1]
+
+
+def extract_dependence(comment_lines):
+    support_separartor = ",; "
+    dependence = []
+    for line in comment_lines:
+        line = filter_line(line, DEPENDENCE_FLAG)
+        if not line:
+            continue
+        parser = shlex.shlex(line)
+        parser.whitespace += support_separartor
+        parser.whitespace_split = True
+        dependence += list(parser)
+    return set(dependence)
+
+
+def extract_commands(comment_lines):
+    commands = []
+    flag = False
+    merge_command = ""
+    for command in comment_lines:
+        command = filter_command_line(command)
+        if not command:
+            continue
+        if command.strip()[-1] == "\\":
+            flag = True
+            merge_command += "{} ".format(command.strip()[:-1])
+        else:
+            if flag:
+                merge_command += "{} ".format(command)
+            flag = False
+            if merge_command == "":
+                commands.append(command)
+            else:
+                commands.append(merge_command)
+                merge_command = ""
+    if not commands and merge_command.strip():
+        commands.append(merge_command)
+    return commands
+
+
+def read_list(path):
+    if not path.exists():
+        return {"*"}, {}
+    valid_lines, _ = split_comment("#", read_file(path))
+    include_flag = "[ALL-TEST-CASE]"
+    exclude_flag = "[EXCLUDE-TEST-CASE]"
+    case_list = set()
+    exclude_case_list = set()
+    is_exclude = False
+    for line in valid_lines:
+        if line.find(include_flag) != -1:
+            is_exclude = False
+        elif line.find(exclude_flag) != -1:
+            is_exclude = True
+        elif is_exclude:
+            exclude_case_list.add(line)
+        else:
+            case_list.add(line)
+    if not case_list:
+        case_list = {"*"}
+    return case_list, exclude_case_list
+
+
+@total_ordering
+class Result:
+    def __init__(self, case, task, cfg, status, commands, commands_result):
+        self.case = case
+        self.task = task
+        self.cfg = cfg
+        self.time = None
+        self.status = status
+        self.commands = commands
+        self.commands_result = commands_result
+
+    def gen_xml(self, root):
+        from xml.etree import ElementTree
+
+        case = ElementTree.SubElement(
+            root,
+            "testcase",
+            name=str(self.case),
+            classname="{}.{}".format(self.task, self.cfg),
+        )
+
+        if self.status == FAIL:
+            failure = ElementTree.SubElement(case, "failure")
+            if isinstance(self.commands_result, str):
+                failure.text = "Test case preparation failed, "
+                failure.text += self.commands_result
+            else:
+                failure.text = "List of commands:\n"
+                for cmd in self.commands:
+                    failure.text += "EXEC: {}\n".format(cmd)
+                failure.text += "----\n"
+                failure.text += self.command_result_to_text(self.commands_result[-1])
+        elif self.status == UNRESOLVED:
+            skipped = ElementTree.SubElement(case, "skipped")
+            skipped.text = "No valid command statement was found."
+
+    def command_result_to_text(self, result):
+        text = "EXEC: {}\n".format(result.get("cmd"))
+        text += "Return code: {}\n".format(result.get("return_code"))
+        text += "Stdout: \n{}\n".format(result.get("stdout"))
+        text += "Stderr: \n{}\n".format(result.get("stderr"))
+        return text
+
+    def gen_json_result(self):
+        from collections import OrderedDict
+
+        result = OrderedDict()
+        result["name"] = "{}/{} :: {}".format(self.task, self.case, self.cfg)
+        result["result"] = self.status
+        result["commands"] = self.commands
+        result["output"] = self.commands_result
+        return result
+
+    def __lt__(self, other):
+        return self.case < other.case
diff --git a/test/maple_test/utils.py b/test/maple_test/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f9dba4ffefd10f1a246273601fbaa199ab3cdba
--- /dev/null
+++ b/test/maple_test/utils.py
@@ -0,0 +1,242 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import configparser
+import locale
+import os
+import sys
+import timeit
+import re
+import platform
+import shlex
+from functools import wraps
+from pathlib import Path
+
+EXEC_FLAG = "EXEC"
+ERRCHECK_FLAG = "ERRCHECK"
+ASSERT_FLAG = "ASSERT"
+EXPECT_FLAG = "EXPECT"
+DEPENDENCE_FLAG = "DEPENDENCE"
+PASS = "PASS"
+FAIL = "FAIL"
+XFAIL = "XFAIL"
+XPASS = "XPASS"
+NOT_RUN = "NOT_RUN"
+UNRESOLVED = "UNRESOLVED"
+UNSUPPORTED = "UNSUPPORTED"
+UNSUCCESSFUL = [FAIL, UNSUPPORTED, UNRESOLVED, NOT_RUN]
+ALL = [PASS, FAIL, XFAIL, XPASS, UNSUPPORTED, UNRESOLVED]
+DEFAULT_PRINT = [PASS, FAIL, XFAIL, XPASS, UNSUPPORTED]
+RESULT = {
+    PASS: 0,
+    FAIL: 0,
+    NOT_RUN: 0,
+    UNRESOLVED: 0,
+    XFAIL: 0,
+    XPASS: 0,
+}
+BASE_DIR = Path(__file__).parent.absolute()
+
+ENCODING = locale.getpreferredencoding(False)
+OS_SEP = os.path.sep
+OS = platform.system()
+if OS == 'Windows' and ' ' in sys.executable:
+    EXECUTABLE = '"' + sys.executable + '"'
+else:
+    EXECUTABLE = sys.executable
+COMPARE = BASE_DIR / "compare.py"
+
+
+def read_file(file_path):
+    """Read files based on encoding and return all file lines
+
+    :param file_path: Path
+    :param encoding: str
+    :return:
+    """
+    lines = []
+    with file_path.open(encoding="utf-8") as file:
+        all_lines = file.readlines()
+    for line in all_lines:
+        if line.strip():
+            lines.append(line.strip())
+    return lines
+
+
+def read_config(file_path):
+    """Read config file based on encoding and return test config"""
+    if not file_path.exists() or not file_path.is_file():
+        return None
+    config = configparser.ConfigParser()
+    config.optionxform = str
+    config.read(str(file_path), encoding="utf-8")
+    return config
+
+
+def get_config_value(config, section, option):
+    """Read config value from test config"""
+    try:
+        return config[section][option]
+    except KeyError:
+        return None
+
+
+def config_section_to_dict(config, section):
+    try:
+        return {k: v for k, v in config.items(section)}
+    except configparser.NoSectionError:
+        return {}
+
+
+def ls_all(path, suffix=None):
+    """Output all files in a directory"""
+    all_files = []
+    _path = complete_path(path)
+    if _path.is_file() and is_case(_path, suffix):
+        return [_path]
+    for name, _, files in os.walk(str(_path)):
+        for file in files:
+            if is_case(Path(name) / file, suffix):
+                all_files.append(Path(name) / file)
+    return all_files
+
+
+def is_case(path, suffix):
+    """Determine if it is a test case based on the suffix
+
+    :param suffix: tuple
+    :param path: Path
+    :return:
+    """
+    if suffix is None:
+        return True
+    elif isinstance(suffix, str):
+        return path.suffix[1:] == suffix
+    return path.suffix[1:] in suffix
+
+
+def complete_path(path):
+    """Returns the canonical path of a path"""
+    path = Path(path)
+    if not path.exists():
+        return Path(os.path.realpath(str(path)))
+    return path.expanduser().resolve()
+
+
+def filter_line(line, flag=None):
+    """Returns the line starting with the flag"""
+    if flag is None:
+        return line
+    line_flag = line.strip().split(":")[0].strip()
+    if line_flag == flag:
+        new_line = line.strip()[len(flag) + 1:].strip().lstrip(":").strip()
+        return new_line
+    return None
+
+
+def filter_command_line(line):
+    """Returns and updates the command line starting with the flag"""
+    line_flag = line.strip().split(":")[0].strip()
+    new_line = line.strip()[len(line_flag) + 1:].strip().lstrip(":").strip()
+    if line_flag == EXEC_FLAG:
+        return new_line
+    elif line_flag == ERRCHECK_FLAG:
+        if platform.system() == "Windows":
+            return new_line + " 2>&1 1>$NUL | compare %f"
+        else:
+            return new_line + " 2>&1 1>/dev/null | compare %f"
+    return None
+
+
+def split_comment(comment, lines):
+    """Split text based on comments"""
+    comment_lines = []
+    uncomment_lines = []
+    comment_len = len(comment)
+    for line in lines:
+        if line.strip()[:comment_len] == comment:
+            comment_lines.append(line.strip()[comment_len:])
+        else:
+            uncomment_lines.append(line)
+    return uncomment_lines, comment_lines
+
+
+def add_run_path(new_path):
+    """Add path to PATH"""
+    run_env = os.environ.copy()
+    old_path = run_env.get("PATH")
+    if old_path:
+        run_env["PATH"] = old_path + os.pathsep + new_path
+    else:
+        run_env["PATH"] = new_path
+    return run_env
+
+
+def timer(func):
+    """Decorator that reports the execution time."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start = timeit.default_timer()
+        result = func(*args, **kwargs)
+        end = timeit.default_timer()
+        print(
+            "Function: {}, args: {}, kwargs: {}, Time Consuming: {}s\n".format(
+                func.__name__, str(args), str(kwargs), end - start
+            )
+        )
+        return result
+
+    return wrapper
+
+
+def is_relative(path1, path2):
+    """Is path1 relative to path2"""
+    _p1 = complete_path(path1)
+    _p2 = complete_path(path2)
+    try:
+        _p1.relative_to(_p2)
+    except ValueError:
+        return 0
+    return 1
+
+
+def merge_result(multi_results):
+    for result in multi_results:
+        if result in UNSUCCESSFUL:
+            return result
+    return PASS
+
+
+def escape(special_chars, original_string):
+    special_re = re.compile(
+        "(" + "|".join(re.escape(char) for char in list(special_chars)) + ")"
+    )
+    special_map = {char: "\\%s" % char for char in special_chars}
+
+    def escape_special_char(m):
+        char = m.group(1)
+        return special_map[char]
+
+    return special_re.sub(escape_special_char, original_string)
+
+
+def quote(original_string):
+    if platform.system() == "Windows":
+        return '"' + escape('\\"', original_string) + '"'
+    else:
+        return shlex.quote(original_string)
diff --git a/test/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Main.mpl b/test/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..ed1c250fcdf70fc71419fbbb69e39c86aa0c1180
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Main.mpl
@@ -0,0 +1,15 @@
+ func &addf32r(
+  var %i f32, var %j f32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i, dread f32 %j))}
+
+ func &addf32I (
+  var %i f32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i,
+       constval f32 1.234f))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl b/test/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..b93dc8e37e7b9e31edbb1d181f3d54481aea05fe
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl
@@ -0,0 +1,15 @@
+ func $fooi64 (
+  var %i i64, var %j i64
+  ) i64 { 
+   return (
+     add i64(dread i64 %i, dread i64 %j))}
+
+ func $addi64I (
+  var %i i64
+  ) i64 { 
+   return (
+#add i64(dread i64 %i, constval i64 0x123456789))}
+     add i64(dread i64 %i, constval i64 0x800000115))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl b/test/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..4164e27feb5fcfc12b594bec646e87429eb9e62b
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl
@@ -0,0 +1,17 @@
+ func $foo1 (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i, dread i32 %j))}
+
+ func $addi32I (
+  var %i i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i,
+#constval i32 0xfff))}
+#       constval i32 0xffff))}
+       constval i32 0xfffff))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/Main.mpl b/test/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..f0229b09393423172997ee3f56ca7795d711216a
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/Main.mpl
@@ -0,0 +1,69 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i, 
+       constval i32 -998))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i, dread i32 %j))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i, constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     add i64(dread i64 %i, constval i64 0x111111111))}
+
+ func $foo4 (
+  var %i i64, var %j i64, var %k i32
+  )i64  { 
+   return (
+     add i64(dread i64 %i, dread i64 %j))}
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     add i64(dread i64 %i, constval i64 0x11111))}
+
+ func $foo6 (
+  var %i f64, var %j f64, var %k i32
+  ) f64 { 
+   return (
+     add f64(dread f64 %i, constval f64 2.237))}
+
+ func $foo66 (
+  var %i f64, var %j f64, var %k i32
+  ) f64 {
+   return (
+     add f64(dread f64 %i, constval f64 2.237))}
+ func $foo7 (
+  var %i f32, var %j f32, var %k i32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i, dread f32 %j))}
+
+ func $foo8 (
+  var %i f32, var %j f32, var %k i32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i, constval f32 2.237f))}
+
+ func $foo9 (
+  var %i i8, var %j u8, var %k i32) i32 { 
+   return (
+     add i32(dread i32 %i, dread u32 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl b/test/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..6a12bf5e8c4014a5c556bf8d1f8946cad643fbc1
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl
@@ -0,0 +1,24 @@
+var $arr1 <[10] i32>
+var $arr2 <[10] i32>
+var $arr3 <[10] i32>
+
+func $ArrayAdd () void {
+ var %i i32
+ doloop %i ( 
+  constval i32 0, 
+  lt i32 i32 (dread i32 %i, constval i32 10), 
+  add i32(dread i32 %i, constval i32 1)){
+   iassign <* [10] i32>(
+    array 1 a32 <* [10] i32>(addrof a32 $arr1, dread i32 %i),
+    add i32(
+     iread i32 <* [10] i32>(
+      array 1 a32 <* [10] i32>(addrof a32 $arr2, dread i32 %i)), 
+     iread i32 <* [10] i32>(
+      array 1 a32 <* [10] i32>(addrof a32 $arr3, dread i32 %i))
+     ))
+  }
+  return() 
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/Main.mpl b/test/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3f0dd9f3814eb67a6c31c9f1bb03414579ba1105
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/Main.mpl
@@ -0,0 +1,12 @@
+var $iconst1 <[4] [4] i32> = [ [1007, 707, -273, 75], [0113, 0x4b, 75u, 75l], [75ul, 75lu, 31425926, 60223], [60223, 1619, 30, 314159]]
+var $fconst1 <[4] [4] f64> = [ [1007.0, 707.0, -273.0, 75.0], [113.1, 4.0, 75.0, 75.1], [75.0, 75.1, 3.1425926, 6.02e23], [6.02e+23, 1.6e-19, 3.0, 3.14159]]
+func &printf (var %p1 <* i8>)void
+func &main ( ) i32 {
+   call &printf (addrof a32 $fconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/Main.mpl b/test/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..82200c59f71e249301b6c4fefb811eb4b7a8dae3
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/Main.mpl
@@ -0,0 +1,19 @@
+var $i i32 align(4) = 987
+type $SS1 <struct {
+  @f1 i32 volatile const,
+  @f2 i32 align(8),
+  @f3 i32 const } > 
+var $iconst1 <[4] [4] i32> const = [ [1007, 707, -273, 75], [0113, 0x4b, 75u, 75l], [75ul, 75lu, 31425926, 60223], [60223, 1619, 30, 314159]]
+var $fconst1 <[4] [4] f64 > volatile = [ [1007.0, 707.0, -273.0, 75.0], [113.1, 4.0, 75.0, 75.1], [75.0, 75.1, 3.1425926, 6.02e23], [6.02e+23, 1.6e-19, 3.0, 3.14159]]
+func &printf const static varargs (var %p1 <* i8 > volatile const, var %p2 <* i32> volatile)void 
+func &noarg varargs ( ... ) void
+func $main static ( ) i32 {
+   var %jj i32 volatile align(16)
+   call &printf (addrof a32 $fconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/Main.mpl b/test/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..6b716d0e83ed8c381af78ebf3ce46eb3f8e73b8d
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/Main.mpl
@@ -0,0 +1,41 @@
+ func $band32I (
+  var %i i32
+  ) i32 { 
+   return (
+     band i32(dread i32 %i,
+       constval i32 0x12))}	  
+ func $band32I_2 (
+  var %i i32
+  ) i32 { 
+   return (
+     band i32(dread i32 %i,
+       constval i32 0x112))}	 
+ func $band32RR (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     band i32(dread i32 %i,
+       dread i32 %j))}	   
+
+ func $band64I (
+  var %i i64
+  ) i64 {
+   return (
+     band i64(dread i64 %i,
+       constval i64 0x1200000015))}
+ func $band64I_2 (
+  var %i i64
+  ) i64 {
+   return (
+     band i64(dread i64 %i,
+       constval i64 0x1200000115))}
+ func $band64RR (
+  var %i i64,
+  var %j i64
+  ) i64 {
+   return (
+     band i64(dread i64 %i,
+              dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0009-mapleall-irbuild-edge-binary/Main.mpl b/test/testsuite/irbuild_test/I0009-mapleall-irbuild-edge-binary/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..1dcae2c67515a5a94043e0e666c2d37414537327
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0009-mapleall-irbuild-edge-binary/Main.mpl
@@ -0,0 +1,32 @@
+ # a function returning (i + j) * -998
+ func $foo (
+# var %i xxx,
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 {
+   assertge (dread i32 %i, constval i32 0)
+   assertlt (dread i32 %i, dread i32 %k)
+   return (
+     ashr i32(
+      mul i32 (
+       add i32 ( 
+        band i32 (dread i32 %i, dread i32 %j),
+        bior i32 ( 
+         bxor i32(dread i32 %i1, dread i32 %k1), 
+         eq i32 i32 (
+          depositbits i32 1 23 (
+           land i32 (dread i32 %j1, dread i32 %k), 
+           lior i32 (
+             min i32 (
+              shl i32 (dread i32 %k1, dread i32 %j), 
+              sub i32 (dread i32 %j1, dread i32 %i)), 
+             rem i32 (dread i32 %i, dread i32 %k))), 
+          div i32( 
+           lshr i32 ( dread i32 %k, dread i32 %i), 
+           max i32 ( dread i32 %i, dread i32 %j))))), 
+       constval i32 -998), 
+      dread i32 %i))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/Main.mpl b/test/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..7f5f81bb65f0dc026ae77f120f478fde986cc779
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/Main.mpl
@@ -0,0 +1,41 @@
+ func $bior32I (
+  var %i i32
+  ) i32 { 
+   return (
+     bior i32(dread i32 %i,
+       constval i32 0x12))}	  
+ func $bior32I_2 (
+  var %i i32
+  ) i32 { 
+   return (
+     bior i32(dread i32 %i,
+       constval i32 0x112))}	 
+ func $bior32RR (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     bior i32(dread i32 %i,
+       dread i32 %j))}	   
+
+ func $bior64I (
+  var %i i64
+  ) i64 {
+   return (
+     bior i64(dread i64 %i,
+       constval i64 0x1200000015))}
+ func $bior64I_2 (
+  var %i i64
+  ) i64 {
+   return (
+     bior i64(dread i64 %i,
+       constval i64 0x1200000115))}
+ func $bior64RR (
+  var %i i64,
+  var %j i64
+  ) i64 {
+   return (
+     bior i64(dread i64 %i,
+              dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/Main.mpl b/test/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..67004f9cf3559aadc39fd54273cbebf9b4e74884
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/Main.mpl
@@ -0,0 +1,37 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     bnot i32(dread i32 %i))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     bnot i32(dread i32 %i))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     bnot i32(constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     bnot i64(dread i64 %i))}
+
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     bnot i64(constval i64 0x11111))}
+
+# todo float bnot
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/Main.mpl b/test/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..1ab362e93145a2e23cdce26fa55806c416ca0f45
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/Main.mpl
@@ -0,0 +1,12 @@
+func $fact (
+ var %n i32) i32 {
+@fred2
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+     brfalse @fred2 (dread i32 %n)
+@fred1
+     return (constval i32 0) } 
+ else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/Main.mpl b/test/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8f622b06a1ec5b674f9bebea4bd9ed0b8a34f242
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/Main.mpl
@@ -0,0 +1,23 @@
+func $singlefoo(var %a i32) i32 {
+  return (dread i32 %a)
+}
+
+func $fact(var %n i32) i32 {
+  var %m i32
+  var %r1 i32
+  var  %r2 i32
+  var  %r3 i32
+  callassigned &singlefoo(dread i32 %n) {
+    dassign %m 0
+  }
+  # Not correct, but for parse and dump test.
+  callassigned &singlefoo(dread i32 %n) {
+    dassign %r1 1
+    dassign %r2 2
+    dassign %r3 3
+  }
+  return (dread i32 %n)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/Main.mpl b/test/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..452853a54d985de2e3cdffec63b7965ff8661cf3
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/Main.mpl
@@ -0,0 +1,29 @@
+ func $ceilf64toi32 (
+  var %i f64
+  ) i32 { 
+   return (
+     ceil i32 f64(dread f64 %i))}
+
+ func $ceilf64toi64 (
+  var %i f64
+  ) i64 { 
+   return (
+     ceil i64 f64(dread f64 %i))}
+
+ func $ceilf32toi32 (
+  var %i f32
+  ) i32 { 
+   return (
+     ceil i32 f32(dread f32 %i))}
+
+
+ func $ceilf32toi64 (
+  var %i f32
+  ) i64 { 
+   return (
+     ceil i64 f32(dread f32 %i))}
+
+# todo float ceil
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/Main.mpl b/test/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8e05e65c4c36851a22091b6477713bfaa2c83c03
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/Main.mpl
@@ -0,0 +1,21 @@
+ flavor 1
+ func &ciori32 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   if (cior i32 ( cior i32(dread i32 %i, dread i32 %j), dread i32 %k)) {
+     return (constval i32 1)
+   }
+   return (
+     cior i32(dread i32 %i, dread i32 %j))}
+
+ func &candi64 (
+  var %i i64, var %j i64, var %k i64
+  ) i32 { 
+   if (cand i32 (cand i32(dread i32 %i, dread i32 %j), dread i32 %k)) {
+     return (constval i32 1)
+   }
+   return (
+     cand i64(dread i64 %i, dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/Main.mpl b/test/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a2c9a0952c01e35aa66c27e97e3cbae948813cd4
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/Main.mpl
@@ -0,0 +1,11 @@
+type $RR <class {@e1 i32, @e2 f32, @e3 f64}>
+type $SS <class <$RR> {@f1 i32, @f2 i8, @f3 i8}>
+type $TT <class {@e1 i32, @e2 f32, @e3 f64}>
+type $UU <class <$RR> {@f1 i32, @f2 i8, @f3 i8}>
+func &foo ( var %x <$SS>) void {
+  var %y <$UU>
+  dassign %y 0 ( dread agg %x 0 )
+  return () }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/Main.mpl b/test/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..5c446b85b76fe2954a1e5951ade166130449e877
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/Main.mpl
@@ -0,0 +1,10 @@
+type $RR <class {@e1 i32, @e2 f32, @e3 f64}>
+type $SS <classincomplete <$RR> {@f1 i32, @f2 i8, @f3 i8}>
+javaclass $TT <$SS> public static
+func &foo (
+	var %x <$SS>) i32 {
+  dassign %x 2 ( constval i32 32 )
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl b/test/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..d476e46c4586f3ba3a39abfb9bae814690b0fe04
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl
@@ -0,0 +1,15 @@
+var $nan_f32 <f32> = nanf
+var $nan_f64 <f64> = nan
+var $inf_f32 <f32> = -inff
+var $inf_f64 <f64> = inf
+var $g_f32 <f32> = -1.2f
+var $g_f64 <f64> = 1.2
+func $add_f32 () f32 {
+  return (
+    add f32(dread f32 $g_f32, constval f32 inff))}
+func $add_f64 () f64 {
+  return (
+    add f64(dread f64 $g_f64, constval f64 -inf))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/Main.mpl b/test/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..d0b562cc934797ab3ecb9e62d007de68e85cb57c
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/Main.mpl
@@ -0,0 +1,582 @@
+# 1 + 8 -> 9
+func $testSum (var %i i32) i32 {
+  return (
+    add i32(constval i32 1, constval i32 8))
+}
+
+# sqrt(4.0) -> 2.0
+func $testSqrt (var %i i32) f32 {
+  return (
+    sqrt f32(constval f32 4.0f))
+}
+
+# 5 + (5 + a) -> a + 10
+func &testConstVarFold00 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 5,
+    add i32 (constval i32 5, dread i32 %a)))
+}
+
+# 5 + (5 - a) -> 10 - a
+func &testConstVarFold01 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 5,
+    sub i32 (constval i32 5, dread i32 %a)))
+}
+
+# 5 + (a + 5) ->  a + 10
+func &testConstVarFold02 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 5,
+    add i32 (dread i32 %a, constval i32 5)))
+}
+
+# 6 + (a - 5) ->  a + 1
+func &testConstVarFold03 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 6,
+    sub i32 (dread i32 %a, constval i32 5)))
+}
+
+# 5 * (5 * a) -> 5 * (5 * a)
+func &testConstVarFold04 (var %a i32) i32 {
+  return (mul i32 (
+    constval i32 5,
+    mul i32 (constval i32 5, dread i32 %a)))
+}
+
+# 5 * (a * 5) -> 5 * (a * 5)
+func &testConstVarFold05 (var %a i32) i32 {
+  return (mul i32 (
+    constval i32 5,
+    mul i32 (dread i32 %a, constval i32 5)))
+}
+
+# 3 - (2 - a) -> a + 1
+func &testConstVarFold06 (var %a i32) i32 {
+  return (sub i32 (
+    constval i32 3,
+    sub i32 (constval i32 2, dread i32 %a)))
+}
+
+# 3 - (2 + a) -> 1 - a
+func &testConstVarFold07 (var %a i32) i32 {
+  return (sub i32 (
+    constval i32 3,
+    add i32 (constval i32 2, dread i32 %a)))
+}
+
+# 3 - (a + 2) -> 1 - a
+func &testConstVarFold08 (var %a i32) i32 {
+  return (sub i32 (
+    constval i32 3,
+    add i32 (dread i32 %a, constval i32 2)))
+}
+
+# 3 - (a - 2) -> 5 - a
+func &testConstVarFold09 (var %a i32) i32 {
+  return (sub i32 (
+    constval i32 3,
+    sub i32 (dread i32 %a, constval i32 2)))
+}
+
+# (2 + a) - 3 -> a - 1
+func &testConstVarFold10 (var %a i32) i32 {
+  return (sub i32 (
+    add i32 (constval i32 2, dread i32 %a),
+    constval i32 3))
+}
+
+# (2 - a) - 3 -> -a - 1
+func &testConstVarFold11 (var %a i32) i32 {
+  return (sub i32 (
+    sub i32 (constval i32 2, dread i32 %a),
+    constval i32 3))
+}
+
+# (a + 2) - 3 -> a - 1
+func &testConstVarFold12 (var %a i32) i32 {
+  return (sub i32 (
+    add i32 (dread i32 %a, constval i32 2),
+    constval i32 3))
+}
+
+#  (a - 2) - 3 -> a - 5
+func &testConstVarFold13 (var %a i32) i32 {
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 2),
+    constval i32 3))
+}
+
+# 1 + (5 + ((5 - a) - 3)) -> 8 - a
+func &testConstVarFold15 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 1,
+    add i32 (
+      constval i32 5,
+      sub i32 (
+        sub i32 (constval i32 5, dread i32 %a),
+        constval i32 3))))
+}
+
+# 1 + (5 + ((5 - a) * 3)) -> ((5 - a) * 3) + 6
+func &testConstVarFold16 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 1,
+    add i32 (
+      constval i32 5,
+      mul i32 (
+        sub i32 (constval i32 5, dread i32 %a),
+        constval i32 3))))
+}
+
+# (-a) + b --> (-a) + b
+func &testConstantFoldAdd00 (var %a i32, var %b i32) i32 {
+  return (add i32 (
+    neg i32 (dread i32 %a),
+    dread i32 %b))
+}
+
+#  a + (-b) --> a + (-b)
+func &testConstantFoldAdd01 (var %a i32, var %b i32) i32 {
+  return (add i32 (
+    dread i32 %a,
+    neg i32 (dread i32 %b)))
+}
+
+
+# 5.0f + (5 - a) -> same, no folding with floating point numbers
+func &testConstVarFold20 (var %a i32) i32 {
+  return (add f32 (
+    constval f32 5.0f,
+    sub i32 (constval i32 5, dread i32 %a)))
+}
+
+
+func &testConstFold0 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a + 5) + ((2 + c) + (4 + 2))) -> ((a + c) + 13)
+  return (add i32 (
+    add i32 (dread i32 %a, constval i32 0x5),
+    add i32 (
+      add i32 (constval i32 0x2, dread i32 %c),
+      add i32 (constval i32 0x4, constval i32 0x2))))
+}
+
+func &testConstFold1 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a + 5) + (2 + c)) -> ((a + c) + 7)
+  return (add i32 (
+    add i32 (dread i32 %a, constval i32 0x5),
+    add i32 (constval i32 0x2, dread i32 %c)))
+}
+
+func &testConstFold2 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((b - c) - (4 - 2))) -> ((a - (b - c)) - 3)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      sub i32 (dread i32 %b, dread i32 %c),
+      sub i32 (constval i32 0x4, constval i32 0x2))))
+}
+
+func &testConstFold3 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) + ((b - c) - (4 - 2))) -> ((a + (b - c)) - 7)
+  return (add i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      sub i32 (dread i32 %b, dread i32 %c),
+      sub i32 (constval i32 0x4, constval i32 0x2))))
+}
+
+func &testConstFold4 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((4 - 2) - (4 - b))) -> ((a - b) - 3)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      sub i32 (constval i32 0x4, constval i32 0x2),
+      sub i32 (constval i32 0x4, dread i32 %b))))
+}
+
+func &testConstFold5 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((5 - a) - ((b - 4) - (4 - b))) -> (((-a) - (b - (-b))) + 13)
+  return (sub i32 (
+    sub i32 (constval i32 0x5, dread i32 %a),
+    sub i32 (
+      sub i32 (dread i32 %b, constval i32 0x4),
+      sub i32 (constval i32 0x4, dread i32 %b))))
+}
+
+func &testConstFold6 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((5 - a) - ((4 - b) - (b - 4))) -> (((-a) - ((-b) - b)) - 3)
+  return (sub i32 (
+    sub i32 (constval i32 0x5, dread i32 %a),
+    sub i32 (
+      sub i32 (constval i32 0x4, dread i32 %b),
+      sub i32 (dread i32 %b, constval i32 0x4))))
+}
+
+func &testConstFold7 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((4 + 2) - (4 - (b - c)))) -> ((a - (b - c)) - 7)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      add i32 (constval i32 0x4, constval i32 0x2),
+      sub i32 (
+        constval i32 0x4,
+        sub i32 (dread i32 %b, dread i32 %c)))))
+}
+
+func &testConstFold8 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((4 + 2) - (4 * (b - c)))) -> ((a - (-(4 * (b - c)))) - 11)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      add i32 (constval i32 0x4, constval i32 0x2),
+      mul i32 (
+        constval i32 0x4,
+        sub i32 (dread i32 %b, dread i32 %c)))))
+}
+
+func &testConstFold9 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((4 + 2) - (-(4 - (b - c))))) -> ((a - (-(b - c))) - 15)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      add i32 (constval i32 0x4, constval i32 0x2),
+      neg i32 (sub i32 (
+        constval i32 0x4,
+        sub i32 (dread i32 %b, dread i32 %c))))))
+}
+
+func &testConstFold10 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((4 + 2) * (-(4 - (3 - c)))) -> (6 * ((-c) - 1))
+  return (mul i32 (
+    add i32 (constval i32 0x4, constval i32 0x2),
+    neg i32 (sub i32 (
+      constval i32 0x4,
+      sub i32 (constval i32 0x3, dread i32 %c)))))
+}
+
+func &testConstFold11 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((4 + 2) * (4 - (3 - c))) -> (6 * (c + 1))
+  return (mul i32 (
+    add i32 (constval i32 0x4, constval i32 0x2),
+    sub i32 (
+      constval i32 0x4,
+      sub i32 (constval i32 0x3, dread i32 %c))))
+}
+
+func &testConstFold12 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((4 + 2) * (~(4 - (3 - c)))) -> (6 * (~(c + 1)))
+  return (mul i32 (
+    add i32 (constval i32 0x4, constval i32 0x2),
+    bnot i32 (sub i32 (
+      constval i32 0x4,
+      sub i32 (constval i32 0x3, dread i32 %c)))))
+}
+
+func &testConstFold13 (var %a i32, var %b i32, var %c i32) i32 {
+  # (5 * (((4 - 2) + (2 & 4)) - (4 - (c | 3)))) -> (5 * ((c | 3) - 2))
+  return (mul i32 (
+    constval i32 0x5,
+    sub i32 (
+      add i32 (
+        sub i32 (constval i32 0x4, constval i32 0x2),
+        band i32 (constval i32 0x2, constval i32 0x4)),
+      sub i32 (
+        constval i32 0x4,
+        bior i32 (dread i32 %c, constval i32 0x3)))))
+}
+
+func &testConstFold14 (var %a i32, var %b i32, var %c i32) i32 {
+  # (5 * (((4 - 2) + (2 & 4)) * (4 - (c | 3)))) -> (5 * (2 * (4 - (c | 3))))
+  return (mul i32 (
+    constval i32 0x5,
+    mul i32 (
+      add i32 (
+        sub i32 (constval i32 0x4, constval i32 0x2),
+        band i32 (constval i32 0x2, constval i32 0x4)),
+      sub i32 (
+        constval i32 0x4,
+        bior i32 (dread i32 %c, constval i32 0x3)))))
+}
+
+func &testConstFold15 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((1 + 0) * (~(4 - (0 * c)))) -> (~4)
+  return (mul i32 (
+    add i32 (constval i32 0x1, constval i32 0x0),
+    bnot i32 (sub i32 (
+      constval i32 0x4,
+      mul i32 (constval i32 0x0, dread i32 %c)))))
+}
+
+func &testConstFold16 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((~(4 - (c * 0))) * (1 + 0)) -> (~4)
+  return (mul i32 (
+    bnot i32 (sub i32 (
+      constval i32 0x4,
+      mul i32 (dread i32 %c, constval i32 0x0))),
+    add i32 (constval i32 0x1, constval i32 0x0)))
+}
+
+
+func &testConstFoldDiv0 (var %a i32, var %b i32, var %c i32) i32 {
+  # (5 / 0) * (1 + 1) -> 2
+  return (mul i32 (
+    div i32 (constval i32 0x5, constval i32 0x0),
+    add i32 (constval i32 0x1, constval i32 0x1)))
+}
+
+func &testConstFoldFloor00 (var %a i32, var %b i32, var %c i32) i32 {
+  # (floor(4.25) + c) * (1 + 1) -> (c + 4) * 2
+  return (mul i32 (
+    add i32 (floor i32 f32 (constval f32 4.25f), dread i32 %c),
+    add i32 (constval i32 0x1, constval i32 0x1)))
+}
+
+func &testConstFoldFloor01 (var %a i32, var %b i32, var %c i32) i32 {
+  # (floor(4.25) + 2) * (1 + 1) -> 12
+  return (mul i32 (
+    add i32 (floor i32 f32 (constval f32 4.25f), constval i32 0x2),
+    add i32 (constval i32 0x1, constval i32 0x1)))
+}
+
+func &testConstFoldFloor02 (var %a i32, var %b i32, var %c i32) i32 {
+  # floor((floor(4.25) + 1) + (1 + a)) -> floor(a + 6)
+  return (floor i32 i32 (add i32 (
+    add i32 (floor i32 f32 (constval f32 4.25f), constval i32 0x1),
+    add i32 (constval i32 0x1, dread i32 %a))))
+}
+
+func &testConstFoldExtractbitsNode00 () i32 {
+  # 487 = 00111100111
+  # extractbits i32 6 5 (487) = 7 = 0111
+  return (extractbits i32 6 5 (constval i32 487))
+}
+
+func &testConstFoldExtractbitsNode01 () i32 {
+  # 487 = 00111100111
+  # extractbits i32 4 5 (487) = -2 = 0xfffffffffffffffe
+  return (extractbits i32 4 5 (constval i32 487))
+}
+
+func &testConstFoldExtractbitsNode02 (var %a i32, var %b i32, var %c i32) i32 {
+  # 487 = 00111100111
+  # extractbits i32 4 5 (487) = -2 = 0xfffffffffffffffe
+  # extractbits((extractbits(487) + 1) + (1 + a)) -> extractbits(a)
+  return (extractbits i32 4 5 (add i32 (
+    add i32 (extractbits i32 4 5 (constval i32 487), constval i32 0x1),
+    add i32 (constval i32 0x1, dread i32 %a))))
+}
+
+func &testConstFoldExtractbitsNode03 (var %a i32, var %b i32, var %c i32) i32 {
+  # 487 = 00111100111
+  # extractbits i32 6 5 (487) = 7 = 0111
+  # extractbits((extractbits(487) + 1) + (1 + a)) -> extractbits(a + 9)
+  return (extractbits i32 6 5 (add i32 (
+    add i32 (extractbits i32 6 5 (constval i32 487), constval i32 0x1),
+    add i32 (constval i32 0x1, dread i32 %a))))
+}
+
+func &testConstFoldCompareNode00 (var %a i32, var %b i32, var %c i32) i32 {
+  # (ge(6, 2) + 1) + (1 + 2) -> 5
+  return (add i32 (
+    add i32 (
+      ge i32 i32 (constval i32 6, constval i32 2),
+      constval i32 1),
+    add i32 (constval i32 1, constval i32 2)))
+}
+
+func &testConstFoldCompareNode01 (var %a i32, var %b i32, var %c i32) i32 {
+  # ge((ge(6, 2) + 1), (1 + a)) -> ge(2, a + 1)
+  return (ge i32 i32 (
+    add i32 (
+      ge i32 i32 (constval i32 6, constval i32 2),
+      constval i32 1),
+    add i32 (constval i32 1, dread i32 %a)))
+}
+
+func &testConstFoldTernaryNode00 (var %a i32, var %b i32, var %c i32) i32 {
+  # (6 > 2 ? 5 : 0) + (1 + 2) -> 8
+  return ( add i32 (
+    select i32 (
+      ge i32 i32 (constval i32 6, constval i32 2),
+      constval i32 5,
+      constval i32 0),
+    add i32 (constval i32 1,  constval i32 2)))
+}
+
+func &testConstFoldTernaryNode01 (var %a i32, var %b i32, var %c i32) i32 {
+  # (6 > 10 ? 5 : 0) + (1 + a) -> (a + 1)
+  return ( add i32 (
+    select i32 (
+      ge i32 i32 (constval i32 6, constval i32 10),
+      constval i32 5,
+      constval i32 0),
+    add i32 (constval i32 1, dread i32 %a)))
+}
+
+func &testConstFoldTernaryNode02 (var %a i32, var %b i32, var %c i32) i32 {
+  # 6 > a ? (1 + 6) + (1 + a) : 0 -> 6 > a ? a + 8 : 0
+  return ( select i32 (
+    ge i32 i32 (constval i32 6, dread i32 %a),
+    add i32 (
+      add i32 (constval i32 1, constval i32 6),
+      add i32 (constval i32 1, dread i32 %a)),
+    constval i32 0))
+}
+
+type $Hello <struct {
+    @h i32,
+    @e i32,
+    @l i32,
+    @o i32
+  }>
+
+type $Person <struct {
+  @age i32,
+  @extra <$Hello>,
+  @sex u1}>
+
+
+func &testConstFoldIassignNode00 (var %a i32) void {
+  # this is equivalent to dassign %a 0 (constval i32 0x6)
+  iassign <* i32> 0 (addrof ptr %a 0, add i32 (constval i32 1, constval i32 5))
+}
+
+func &testConstFoldIassignNode01 (var %a i32) void {
+  var %bob $Person
+
+  # this is equivalent to dassign %bob 5 (constval i32 0x6)
+  iassign <* $Hello> 3 (addrof ptr %bob 2, add i32 (constval i32 1, constval i32 5))
+}
+
+
+func &testConstFoldIassignNode02 (var %a i32) void {
+  # this is equivalent to dassign %a 0 (constval i32 0x6)
+  iassign <* i32> 0 (
+    iaddrof ptr <* i32> 0 (addrof ptr %a 0),
+    add i32 (constval i32 1, constval i32 5))
+}
+
+func &testConstFoldIassignNode03 (var %a i32) void {
+
+  var %bob $Person
+  # this is equivalent to dassign %bob 5 (constval i32 0x6)
+  iassign <* <$Hello>> 3 (
+    iaddrof ptr <* <$Person>> 2 (addrof ptr %bob 0),
+    add i32 (constval i32 1, constval i32 5))
+}
+
+func &testConstFoldIassignNode04 (var %a i32) void {
+
+  var %bob $Person
+  # this is equivalent to dassign %bob 5 (constval i32 0x6)
+  iassign <* <$Hello>> 3 (
+    iaddrof ptr <* <$Hello>> 0 (addrof ptr %bob 2),
+    add i32 (constval i32 1, constval i32 5))
+}
+
+
+func &testConstFoldIassignNode05 (var %a i32) void {
+  var %b <* i32>
+
+  dassign %b (addrof ptr %a 0)
+
+  # this is equivalent to iassign <* i32> 0 (dread ptr %a, constval i32 0x6)
+  iassign <* i32> 0 (
+    iaddrof ptr <* i32> 0 (dread ptr %a),
+    add i32 (constval i32 1, constval i32 5))
+}
+
+func &testConstFoldIassignNode06 (var %a i32) void {
+  var %bob $Person
+  # this is equivalent to dassign %a 0 (dread i32 %bob 1)
+  dassign %a 0 (iread agg <* <$Person>> 1 (addrof ptr %bob 0))
+}
+
+func &testConstFoldSwitchNode00 () void {
+  # switch (1+4) ... -> goto @lab1
+  switch ( add i32 (constval i32 1, constval i32 4)) @labdft {
+  -2: goto @lab0
+  5: goto @lab1
+  8: goto @lab9 }
+
+  @lab0
+   return (constval i32 1)
+  @labdft
+   return (constval i32 2)
+  @lab9
+   return (constval i32 3)
+  @lab1
+   return (constval i32 4)
+}
+
+func &testConstFoldSwitchNode01 () void {
+  # switch (1 + 10) ... -> goto @labdft
+  switch ( add i32 (constval i32 1, constval i32 10)) @labdft {
+  -2: goto @lab0
+  5: goto @lab1
+  8: goto @lab9 }
+
+  @lab0
+   return (constval i32 1)
+  @labdft
+   return (constval i32 2)
+  @lab9
+   return (constval i32 3)
+  @lab1
+   return (constval i32 4)
+}
+
+func &testConstFoldSwitchNode02 (var %a i32) void {
+  # switch (5 + (5 - a)) ... -> switch (10 - a) ...
+  switch (add i32 (
+    constval i32 5,
+    sub i32 (constval i32 5, dread i32 %a))) @labdft {
+  -2: goto @lab0
+  5: goto @lab1
+  8: goto @lab9 }
+
+  @lab0
+   return (constval i32 1)
+  @labdft
+   return (constval i32 2)
+  @lab9
+   return (constval i32 3)
+  @lab1
+   return (constval i32 4)
+}
+
+
+func &testConstFoldArrayNode00 (var %x i32) void {
+  var %a <* [15][15] i32>
+  # fold indexes -> array ptr <* <[15][15] i32>> (constval i32 0x6, constval i32 0x4)
+  dassign %x (
+    iread i32 <* i32> (
+      array 1 ptr <* [15][15] i32> (addrof ptr %a,
+                                add i32 (constval i32 1, constval i32 5),
+                                sub i32 (constval i32 5, constval i32 1))))
+}
+
+func &testDepositbitsNodeNode00 (var %a i32, var %c i32) i32 {
+  return ( depositbits i32 1 23 (
+             add i32 (
+               add i32 (dread i32 %a, constval i32 0x5),
+               add i32 (
+                 add i32 (constval i32 0x2, dread i32 %c),
+                 add i32 (constval i32 0x4, constval i32 0x2))),
+             add i32 (constval i32 0x4, constval i32 0x8)))
+}
+
+func &testDepositbitsNodeNode01 () i32 {
+  return ( depositbits i32 1 23 (
+             add i32 (
+               add i32 (constval i32 0x5, constval i32 0x5),
+               add i32 (
+                 add i32 (constval i32 0x2, constval i32 0x2),
+                 add i32 (constval i32 0x4, constval i32 0x2))),
+             add i32 (constval i32 0x4, constval i32 0x8)))
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/Main.mpl b/test/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..b3a908413eb2eed59812f58d46face8b5c1503f3
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/Main.mpl
@@ -0,0 +1,8 @@
+ func $cvtu64tof32 (
+  var %i u64
+  ) f32 { 
+   return (
+     cvt f32 u64(dread u64 %i))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/Main.mpl b/test/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8cfabdb80ae05938b81b862982b79bb3bcdccb07
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/Main.mpl
@@ -0,0 +1,8 @@
+ func $cvtu64tof64 (
+  var %i u64
+  ) f64 { 
+   return (
+     cvt f64 u64(dread u64 %i))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl b/test/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..80efe03affd5546fc7b9db7a81a16ba23539695e
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl
@@ -0,0 +1,10 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     depositbits i32 1 23(
+       constval i32 0xfff, constval i32 0x11))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/Main.mpl b/test/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..daf3d347ea19797fdba977e824add6046ea88b6a
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/Main.mpl
@@ -0,0 +1,61 @@
+#This test case covers the following items:
+            
+#MapleIR Direct read/write 
+#Direct acfgrecesses are associated with scalar variables and fixed fields inside 
+#structures. Direct accesses can be mapped to pseudo-register if the variable 
+#or field has no alias.  
+#In MAPLE IR, dassign and dread are the opcodes for direct assignments and 
+#direct references; 
+
+#Syntax
+#dread<prim-type><var-name><field-id>
+#dassign<var-name><field-id>(<rhs-expression>)
+#Type syntax
+#type <id-name><derived-type>
+func $strcpy ( var %dest <*i8>, var %src <*i8> ) <*i8> 
+
+type $People < struct{
+     @name <[10] i8>, 
+     @age i8 }>
+
+type $Info < struct{
+     @number i32,
+     @employee <$People> }>
+
+var $p <$People>
+var $temp<[6] i8>= [ 104, 117, 97, 119, 101, 105 ]
+
+func $main ( )i32 {
+     var %a i8
+     dassign %a ( constval i8 120 )
+     var %b i8
+     dassign %b ( dread i32 %a )
+     var %i i32
+     dassign %i ( constval i32 5 )
+     var %ii i32
+     dassign %ii ( dread i32 %i )
+     var %j f32
+     dassign %j ( constval f32 12.9f )
+     var %jj f32
+     dassign %jj ( dread f32 %j )
+     var %k f64
+     dassign %k ( constval f64 20.5 )
+     var %kk f64
+     dassign %kk ( dread f64 %k )
+     var %p < $People >
+     var %pp < $People >
+     dassign $p 2 ( constval i32 25)
+     # dassign $p 1 ( constval i32 0 )
+     #call <pu-name>(<opnd0>,...,<opndn>)
+     call &strcpy ( addrof a64 %p, addrof a64 $temp)
+     call &strcpy ( addrof a64 %pp, addrof a64 %p)
+     var %info < $Info >
+     var %info2 < $Info >
+     dassign %info 2( dread agg %p )
+     dassign %info2 2( dread agg %info 2)
+     return ( constval i32 444 )
+}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/Main.mpl b/test/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..67b210a10c947e8fefa363e1db8c5c391e3bd07d
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/Main.mpl
@@ -0,0 +1,12 @@
+func $foo (var %i i32) i32 {
+  dowhile {
+    dassign %i (
+      mul i32 (dread i32 %i, dread i32 %i))
+    dassign %i (
+      add i32 (dread i32 %i, constval i32 1) )} (
+        lt i32 i32 ( dread i32 %i, constval i32 10) )
+  return ( constval i32 0 )
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/Main.mpl b/test/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..880fd8705f0a5a85ed6f46d5721c1bcb79334cd8
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/Main.mpl
@@ -0,0 +1,7 @@
+var $g <*ptr>
+var $h <*ptr> = addrof ptr $g
+var $g <*ptr> = addrof ptr $h
+var $h <*ptr>
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/Main.mpl b/test/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3a797ae50b147b854397f72ee724e260840ae412
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/Main.mpl
@@ -0,0 +1,19 @@
+func $foo ( var %i i32 ) i32 
+func $fact ( var %n i32) i32 
+func $fact ( var %n i32) i32 
+func $foo ( var %i i32 ) i32 
+
+func $fact (
+ var %n i32) i32 {
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    call &foo(
+      sub i32 (dread i32 %n, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     return (constval i32 1) } }
+
+func $foo ( var %i i32 ) i32 {
+  return (dread i32 %i) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/Main.mpl b/test/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8739173e937d4869d8ea5bf327a6ddbaadbbab8e
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/Main.mpl
@@ -0,0 +1,7 @@
+var $extern_var extern i32 public
+
+func $test_extern_var ( var %i i32 ) i32 {
+  return (dread i32 $extern_var) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/Main.mpl b/test/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..4b33225b45ac0c3615f02dc00297bde74bd6d9ef
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/Main.mpl
@@ -0,0 +1,83 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     extractbits i32 1 23(
+       constval i32 -998))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     extractbits i32 0 5(dread i32 %i))}
+
+ func $foo11 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) u32 { 
+   return (
+     extractbits u32 0 5(dread i32 %i))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     extractbits i32 3 20(constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     extractbits i64 5 50(dread i64 %i))}
+
+ func $foo4 (
+  var %i i64, var %j i64, var %k i32
+  )i64  { 
+   return (
+     extractbits i64 6 44 (dread i64 %i))}
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     extractbits i64 1 10(constval i64 0x11111))}
+
+ func $foo9 (
+  var %i i8, var %j u8, var %k i32) u32 { 
+   return (
+     extractbits u32 1 31(dread u32 %j))}
+
+ func $foo51 (
+  var %i u64
+  ) u64 { 
+   return (
+     extractbits u64 0 15(constval i64 0x11111))}
+
+ func $foo52 (
+  var %i i32
+  ) i32 { 
+   return (
+     sext i32 11 (constval i32 99))}
+
+ func $foo53 (
+  var %i u64
+  ) u64 { 
+   return (
+     zext u64 11 (constval u64 88))}
+
+ func $foo54 (
+  var %i i32
+  ) i32 { 
+   return (
+     sext i32 11 (dread i32 %i))}
+
+ func $foo55 (
+  var %i u64
+  ) u64 { 
+   return (
+     zext u64 41 (dread u64 %i))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/Main.mpl b/test/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..31a0f83b6c8f2854e8adf0bc09555df2d874588b
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/Main.mpl
@@ -0,0 +1,17 @@
+#int fact(int n) {
+#  if (n == 1)
+#    return 1;
+#  return n * fact(n-1);
+#}
+
+func $fact (var %n i32) i32 {
+  if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+       call &fact (sub i32 (dread i32 %n, constval i32 1))
+            return (mul i32 (dread i32 %n, regread i32 %%retval)) 
+             }
+  return (constval i32 1) 
+}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/Main.mpl b/test/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a329387a2862f5e25d90e3bbf08806dfe07918d4
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/Main.mpl
@@ -0,0 +1,18 @@
+# typedef struct { int f1, char f2, unsigned short f3[]} SS;
+# void foo(SS *x, SS *y) {
+#   int i, j;
+#   x->f3[ij] = y->f3[j];
+# }
+
+type $SS <struct {@f1 i32, @f2 i8, @f3 <[] u16>}>
+func $foo ( var %x <*<$SS>>, var %y <*<$SS>>) void {
+  var %i i32
+  var %j i32
+  iassign <* u16> ( array 1 ptr <*[]u16> (
+                iaddrof ptr <* <$SS>> 3 (dread ptr %x), dread i32 %i),
+                iread u16 <* u16> ( array 1 ptr <*[]u16> (
+                    iaddrof ptr <* <$SS>> 3 (dread ptr %y), dread i32 %j)))
+  return()  }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/Main.mpl b/test/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..5bb0c2903e534d3fa66d7c2c16a6a0067464d350
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/Main.mpl
@@ -0,0 +1,38 @@
+fileinfo{ 
+  @magic 345, 
+  @filename "adir/thisisafile.dex",
+  @dexoffset 560,
+  @flags 0x01ef,
+  @linksize 100
+}
+type $SS <class {
+        @real f32,
+        @imag f32}>
+var $sconst1 <class {
+        @classidx 22,
+        @f11 i32,
+        @f22 <$SS>,
+        @f33 i32,
+        @accessflag 0x45e,
+        @classdataoffset 118,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32,
+        @superclassid 3333
+           }>
+func $fact () i32 {
+  funcinfo{ 
+    @funcname "afunc",
+    @registers 345, 
+    @ins 560,
+    @outs 444
+  }
+  return (dread i32 $sconst1 1)
+  funcinfo{ 
+    @funcidx 345, 
+    @classidx 560
+  }
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/Main.mpl b/test/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..911d3a1d307e80de543ab6d0bfe28b53c46b3306
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/Main.mpl
@@ -0,0 +1,13 @@
+ # a function returning (i + j) * -998
+ func $foo (
+# var %i xxx,
+  var %i i32,
+   var %j i32) i32 { 
+   return (
+     mul i32 (
+       add i32 ( dread i32 %i, dread i32 %j), 
+       constval i32 -998))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/Main.mpl b/test/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..9e14dbb7d094b91c67fec8de6880f6d23143eef9
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/Main.mpl
@@ -0,0 +1,29 @@
+ func $floorf64toi32 (
+  var %i f64
+  ) i32 { 
+   return (
+     floor i32 f64(dread f64 %i))}
+
+ func $floorf64toi64 (
+  var %i f64
+  ) i64 { 
+   return (
+     floor i64 f64(dread f64 %i))}
+
+ func $floorf32toi32 (
+  var %i f32
+  ) i32 { 
+   return (
+     floor i32 f32(dread f32 %i))}
+
+
+ func $floorf32toi64 (
+  var %i f32
+  ) i64 { 
+   return (
+     floor i64 f32(dread f32 %i))}
+
+# todo float floor
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/Main.mpl b/test/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3a903d4dfd942181c787ac7bbe5183f6f39c0e89
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/Main.mpl
@@ -0,0 +1,14 @@
+var $arr1 <[10] f32>
+
+func $ArrayAdd () f32 {
+ var %ff i32
+ var %sum f32
+ dassign %sum ( constval f32 0.0f )
+ foreachelem %ff $arr1 { 
+   dassign %sum ( add f32 ( dread f32 %sum, dread f32 %ff ) )
+ }
+ return ( dread f32 %sum ) 
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/Main.mpl b/test/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..f84b8d638026709ef8f764f798d49cefa5f40550
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/Main.mpl
@@ -0,0 +1,10 @@
+var $test_var i32 public
+
+func $test_extern_var ( var %i i32 ) i32 {
+  return (dread i32 $test_var) 
+}
+
+var $test_var i32 public = 0
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/Main.mpl b/test/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..20e537607e60a307e1a9f6d4046efdfbe7292903
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/Main.mpl
@@ -0,0 +1,12 @@
+func $fact (
+ var %n i32) i32 {
+ var %foo <func(i32) i32>
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    icall ( dread a64 %foo,
+      sub i32 (dread i32 %n, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/Main.mpl b/test/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..d3875879ee5b2321a4c34fd2828552cc283e5549
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/Main.mpl
@@ -0,0 +1,31 @@
+type $ss1 <struct {@b <!T>,
+                       @x <* f32>}>
+type $ss2 <struct {@b1 <struct {@b <!SS>, 
+                                    @x <* f32>}>,
+                       @pa <* <struct {@b f64, 
+                                       @x <* f32>}>>, 
+                       @x1 <[10] f64>,
+                       @dx <!U>}>
+type $ss3 <[] <!AAA>>
+func &foo (var %x <!W>) i32 { 
+  var %y <!W>
+  dassign %y (dread agg %x)
+  return (dread i32 %y 1)
+}
+var $g <$ss1{!T=i32}>
+var $h <$ss2{!U=i32,!SS=<$ss1{!T=f32}>}>
+func &bar () i32 {
+  var %i i32
+  callinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g )
+  callinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 }
+  virtualcallinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g )
+  virtualcallinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 }
+  superclasscallinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g )
+  superclasscallinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 }
+  interfacecallinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g )
+  interfacecallinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 }
+  return ( dread i32 %i )
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/Main.mpl b/test/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..37e344e4952365c8ef1546107276b9eb9e6356ac
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/Main.mpl
@@ -0,0 +1,114 @@
+var $g_i8_u <i8>
+var $g_i8 <i8> = 8
+var $g_u8_u <u8>
+var $g_u8 <u8> = 8
+
+var $g_i16_u <i16>
+var $g_i16 <i16> = 16
+var $g_u16_u <u16>
+var $g_u16 <u16> = 16
+
+var $g_i32_u <i32>
+var $g_i32 <i32> = 32
+var $g_u32_u <u32>
+var $g_u32 <u32> = 32
+
+var $g_i64_u <i64>
+var $g_i64 <i64> = 0x123456789a
+var $g_u64_u <u64>
+var $g_u64 <u64> = 0x123456789a
+
+var $g_f32_u <f32>
+var $g_f32 <f32> = 1.2f
+
+var $g_f64_u <f64>
+var $g_f64 <f64> = 2.4
+
+# i8/u8
+func $add_i8_u () i8 { 
+   return (
+     add i32(dread i32 $g_i8_u, constval i32 0))}
+
+func $add_i8 () i8 { 
+   return (
+     add i32(dread i32 $g_i8, constval i32 0))}
+	 
+func $add_u8_u () u8 { 
+   return (
+     add u32(dread u32 $g_u8_u, constval u32 0))}
+
+func $add_u8 () u8 { 
+   return (
+     add u32(dread u32 $g_u8, constval u32 0))}
+	 
+# i16/u16
+func $add_i16_u () i16 { 
+   return (
+     add i32(dread i32 $g_i16_u, constval i32 0))}
+
+func $add_i16 () i16 { 
+   return (
+     add i32(dread i32 $g_i16, constval i32 0))}
+	 
+func $add_u16_u () u16 { 
+   return (
+     add u32(dread u32 $g_u16_u, constval u32 0))}
+
+func $add_u16 () u16 { 
+   return (
+     add u32(dread u32 $g_u16, constval u32 0))}
+	 
+# i32/u32
+func $add_i32_u () i32 { 
+   return (
+     add i32(dread i32 $g_i32_u, constval i32 0))}
+
+func $add_i32 () i32 { 
+   return (
+     add i32(dread i32 $g_i32, constval i32 0))}
+	 
+func $add_u32_u () u32 { 
+   return (
+     add u32(dread u32 $g_u32_u, constval u32 0))}
+
+func $add_u32 () u32 { 
+   return (
+     add u32(dread u32 $g_u32, constval u32 0))}
+	 
+# i64/u64
+func $add_i64_u () i64 { 
+   return (
+     add i64(dread i64 $g_i64_u, constval i64 0))}
+
+func $add_i64 () i64 { 
+   return (
+     add i64(dread i64 $g_i64, constval i64 0))}
+	 
+func $add_u64_u () u64 { 
+   return (
+     add u64(dread u64 $g_u64_u, constval u64 0))}
+
+func $add_u64 () u64 { 
+   return (
+     add u64(dread u64 $g_u64, constval u64 0))}
+	 
+# # f32
+# func $add_f32_u () f32 { 
+   # return (
+     # add f32(dread f32 $g_f32_u, constval f32 0.0f))}
+
+# func $add_f32 () f32 { 
+   # return (
+     # add f32(dread f32 $g_f32, constval f32 0.0f))}
+	 
+# # f64
+# func $add_f64_u () f64 { 
+   # return (
+     # add f64(dread f64 $g_f64_u, constval f64 0))}
+
+# func $add_f64 () f64 { 
+   # return (
+     # add f64(dread f64 $g_f64, constval f64 0))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/Main.mpl b/test/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..6983956b7ccf14a7801288ec8887bf70579dbfc1
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/Main.mpl
@@ -0,0 +1,11 @@
+var $const1 <[13] i8> = [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 10, 0 ]
+func $printf (var %p1 <* i8>)void
+func $main ( ) i32 {
+   call &printf (addrof a32 $const1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/Main.mpl b/test/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..0a253eb2ee7cc4a4b61403d9a4c2734562f855ba
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/Main.mpl
@@ -0,0 +1,24 @@
+func $fact (
+ var %n i32) i32 {
+ var %foo <func(i32) i32>
+ var %r1 i32
+ var %r2 i32
+ var %r3 i32
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    icallassigned ( dread a64 %foo,
+      sub i32 (dread i32 %n, constval i32 1)) {
+      dassign %r1 0
+    }
+    # Not correct, but for parse and dump test.
+    icallassigned ( dread a64 %foo,
+      sub i32 (dread i32 %n, constval i32 1)) {
+      dassign %r1 1
+      dassign %r2 2
+      dassign %r3 3
+    }
+    return (dread i32 %n)
+  }
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/Main.mpl b/test/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..cf4e726d1e75fab5eeec53aa40476ff0470a8ec4
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/Main.mpl
@@ -0,0 +1,13 @@
+#int fact (int n) {
+#  if(n != 1)
+#    return foo(n - 1);
+#  else return 1;
+#}
+
+func $fact (
+ var %n i32) i32 {
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+     return (constval i32 0) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/Main.mpl b/test/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..640bba9d4007aff19ef3460b6c74d17c05b3d301
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/Main.mpl
@@ -0,0 +1,15 @@
+#int fact (int n) {
+#  if(n != 1)
+#    return foo(n - 1);
+#  else return 1;
+#}
+
+func $fact (
+ var %n i32) i32 {
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+     return (constval i32 0) } 
+ else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/Main.mpl b/test/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..4a29fa4fe34b7e25cc49e14be1b25673fd4c9386
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/Main.mpl
@@ -0,0 +1,21 @@
+type $atyp <[10] f32>
+var $fff <i32> = 7789
+func $foo ( var %i i32 )i32 
+
+func $fact (
+ var %n i32, var %m f32) i32 {
+ type %i32ty <struct {
+        @FF1 i32,
+        @FF2 f64 }>
+ var %alocal <%i32ty>
+ dassign %alocal (constval i32 999)
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    eval (dread i32 %n)
+    call &foo(
+      add i32 (dread i32 %n, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/Main.mpl b/test/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a6810f4fe2fd556964c776f3e9bd713f9a3aadbb
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/Main.mpl
@@ -0,0 +1,11 @@
+importpath "."
+importpath ".."
+importpath "../ff"
+var $x i32
+importpath "/a/bb/ccc/"
+func $foo (var %y i32) void {
+  dassign $x (dread i32 %y)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/Main.mpl b/test/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..743f6913fa4ad0756e9812d8b312871e93ca51e4
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/Main.mpl
@@ -0,0 +1,12 @@
+var $p <* i32>
+func $Foo (var %i i32) void {
+ iassign <* i32>(
+    dread a64 $p,
+    add i32(
+     iread i32 <* i32> ( dread a64 $p ), 
+     dread i32 %i))
+  return() 
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/Main.mpl b/test/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..7abf80f7dd59d7f1a0f09af448f8e3ef9340269d
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/Main.mpl
@@ -0,0 +1,191 @@
+#indirect access are associated with pionters and arrays
+#iassign<type><field-id>(<addr-expr>, <rhs-expr>)
+# type gives the high level type of <addr-expr> and must be a pointer type
+# <addr-expr> is computed to return an address
+# <rhs-expr> return a value
+#iread<prim-type><type><field-id>(<addr-expr>)
+# 
+func $new ( var %n i32 )a64 
+func $strcpy ( var %dest <*i8>, var %src <*i8> )<*i8> 
+type $People < struct{
+     @name < * i8 >,
+     @number < * i32> }>
+func $addition ( var %a i32, var %b i32 )i32 {
+     return(
+	add i32( dread i32 %a, dread i32 %b ))}
+var $name < [6] i8 > = [ 104, 117, 97, 119, 101, 105 ]
+var $temp<[6] i8> = [ 104, 117, 97, 119, 101, 105 ]
+func $main ( ) i32 {
+     var %cPtr < * i8 >
+     dassign %cPtr ( constval a64 0)
+     dassign %cPtr (
+     	     addrof a64 $name)
+     
+     var %cPtr1 i8
+     dassign %cPtr1(
+     	     iread i32 < * i8 >( dread a64 %cPtr ))
+     dassign %cPtr(
+     	     add u64(
+	     	 dread a64 %cPtr,
+		 constval u64 1))
+     var %cPtr2 <* i8>
+     dassign %cPtr2(
+     	     add u64(
+	     	 dread a64 %cPtr,
+		 constval u64 1))
+     
+     var %iPtr1 <* i32 >
+     var %iPtr2 <* i32 >	     
+     iassign < * i32>(
+     	     dread a64 %iPtr1,
+	     constval i32 10)
+     iassign < * i32 >(
+     	     dread a64 %iPtr2,
+	     iread i32 < * i32> (
+	     	   dread a64 %iPtr1))
+     var %sPtr <* $People >
+     #call $new(
+     #	  iread <>)
+     call &new (constval u32 128)
+     dassign %sPtr(
+         regread a64 %%retval
+         )
+     call &strcpy ( dread a64 %sPtr 0 ,
+     	  	    addrof a64 $temp)               
+     iassign <* i32>(
+     	     dread a64 %sPtr 0,
+	     constval i32 5)
+     var %i i32
+     var %j i32
+     var %aPtr1 < [10] i32 >
+     var %aPtr2	< [10][10] i32 >  
+     var %aPtr3	< [10][10][10] i32 >
+     dassign %i ( constval i32 0 )
+     while(
+       lt i32 i32 ( dread i32 %i, constval i32 10 )){
+       	  iassign < *[10] i32 >(
+	  	  array 1 a64 < *[10] i32 >(addrof a64 %aPtr1, 
+		  		          dread i32 %i),
+                  constval i32 10 )
+
+          iassign< *[10] i32 >(
+	  	  array 1 a64 < *[10] i32 >( addrof a64 %aPtr1,
+		  	                   dread i32 %i),
+		  dread i32 %i )
+
+          iassign < *[10] i32 >(
+	  	  array 1 a64 < *[10] i32 >( addrof a64 %aPtr1,
+		  	      	    	   dread i32 %i ),
+		  iread i32 <* i32 >(
+		  	addrof a64 %aPtr1 ))
+       dassign %i(
+	 	 add i32(
+		     dread i32 %i,	
+		     constval i32 1))}
+
+
+     dassign %i ( constval i32 0 )
+     while(
+	lt i32 i32 ( dread i32 %i, constval i32 10 )){
+	dassign %j ( constval i32 0 )
+	while(
+		lt i32 i32 ( dread i32 %j, constval i32 10 )){
+		   iassign < *[10][10] i32 >( 
+		   	   array 1 a64 < *[10][10] i32 >( addrof a64 %aPtr2,
+		   	   	 dread i32 %i,
+				 dread i32 %j),
+		           constval i32 10 )
+	           iassign < *[10][10] i32 >(
+		   	  array 1 a64< *[10][10] i32 >( addrof a64 %aPtr2,
+			  	dread i32 %i,
+				dread i32 %j),
+			  mul i32 (
+			      dread i32 %i,
+			      dread i32 %j))
+		   iassign< *[10][10] i32 >(
+		   	    array 1 a64 < *[10][10] i32 >( addrof a64 %aPtr2,
+			    	  dread i32 %i,
+				  dread i32 %j),
+		            iread i32 < *[10] i32 >(
+			    	  array 1 a64< *[10] i32 >(
+				  	addrof a64 %aPtr1,
+				  	rem i32 (
+					    mul i32 (
+					    	dread i32 %i,
+						dread i32 %j),
+					    constval i32 10))))
+                dassign %j(
+			add i32(
+		 	    dread i32 %j,	
+		     	    constval i32 1))}
+     dassign %i(
+     	     add i32(
+	     	 dread i32 %i,	
+		 constval i32 1))}
+     var %k i32
+     dassign %i ( constval i32 0)
+     while(
+	lt i32 i32 ( dread i32 %i, constval i32 10 )){
+	dassign %j ( constval i32 0)
+	while(
+	lt i32 i32 ( dread i32 %j, constval i32 10)){
+	   while(
+		lt i32 i32 ( dread i32 %k, constval i32 10)){
+		iassign < *[10][10][10] i32 >(
+			array 1 a64 < *[10][10][10] i32 >(addrof a64 %aPtr3,
+			dread i32 %i, 
+			dread i32 %j,
+			dread i32 %k),
+			constval i32 10)
+		iassign < *[10][10][10] i32 >(
+			array 1 a64 < *[10][10][10] i32>(addrof a64 %aPtr3,
+			dread i32 %i, 
+			dread i32 %j,
+			dread i32 %k),
+			mul i32 (
+			    mul i32 (
+			    	dread i32 %i,
+				dread i32 %j),
+			    dread i32 %k))
+	        iassign < *[10][10][10] i32 >(
+			array 1 a64 < *[10][10][10] i32 >(addrof a64 %aPtr3,
+			dread i32 %i, 
+			dread i32 %j,
+			dread i32 %k),
+			mul i32 (
+			    iread i32 < *[10][10] i32>(
+			    	  array 1 a64 <*[10][10] i32>( addrof a64 %aPtr1,
+				  dread i32 %i,
+				  dread i32 %j)),
+				  constval i32 10))
+ 		dassign %k(
+			add i32(
+			    dread i32 %k,
+			    constval i32 1))}
+         dassign %j(
+	 	 add i32(
+		     dread i32 %j,	
+		     constval i32 1))}
+    dassign %i(
+    	    add i32(
+	    	dread i32 %i,	
+		constval i32 1))}
+    
+    var %fPtr1 <func( i32, i32) i32 >
+    var %fPtr2 <func( i32, i32) i32 >
+    
+    dassign %fPtr1(
+          addrof a64 $addition)
+    dassign %fPtr2(
+          addrof a64 $addition)
+    var %result i32
+    icall ( dread a64 %fPtr1, constval i32 2, constval i32 3)
+    dassign %result(
+    	    regread i32 %%retval)
+    return ( dread i32 %result)}
+			
+    
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/Main.mpl b/test/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..f4c0354e7f513018cdfffc17dc64f8cd1a7b09c0
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/Main.mpl
@@ -0,0 +1,9 @@
+type $I1 <interface {@g0 i32}>
+type $I2 <interfaceincomplete {@g1 i32}>
+type $RR <interface <$I1> <$I2> {@e1 i32, &method1(agg)agg, &method2(void)void}>
+javainterface $UU <$RR> public static
+type $CC <interface {@h0 i32}>
+type $TT <class <$CC> {@f1 i32, @f2 i8, @f3 i8, $I1, $I2, $RR}>
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/Main.mpl b/test/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..02dfd61c5161647183736fddc408c1032e8cab79
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/Main.mpl
@@ -0,0 +1,13 @@
+srclang 3
+type $SS <struct {@f1 i32, @f2 i8, @f3 <[] u16>}>
+func $foo ( var %x <*<$SS>>, var %y <*<$SS>>) void {
+  var %i i32
+  var %j i32
+  iassign <* u16> ( array 1 ptr <*[]u16> (
+                iaddrof ptr <* <$SS>> 3 (dread ptr %x), dread i32 %i),
+                iread u16 <* u16> ( array 1 ptr <*[]u16> (
+                    iaddrof ptr <* <$SS>> 3 (dread ptr %y), dread i32 %j)))
+  return()  }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/Main.mpl b/test/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..1a95394d113ffa191e4887dfe1fd0b536d2389c3
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/Main.mpl
@@ -0,0 +1,10 @@
+type $atyp <[10] f32>
+var $fff <i32> = 7789
+func $foo ( var %i i32 )i32 
+
+func $fact (
+ var %n i32, var %m f32) void {
+  return () }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/Main.mpl b/test/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a69899900b708d617827eb390e793be96bb06431
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/Main.mpl
@@ -0,0 +1,14 @@
+ func $landi32 (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     land i32(dread i32 %i, dread i32 %j))}
+
+ func $landi64 (
+  var %i i64, var %j i64
+  ) i32 { 
+   return (
+     land i64(dread i64 %i, dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/Main.mpl b/test/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..900ffdf6706556ad56c9170525f2e0a7f332c8ea
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/Main.mpl
@@ -0,0 +1,14 @@
+ func $liori32 (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     lior i32(dread i32 %i, dread i32 %j))}
+
+ func $liori64 (
+  var %i i64, var %j i64
+  ) i32 { 
+   return (
+     lior i64(dread i64 %i, dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/Main.mpl b/test/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..84b8db30091eeeb9ba22d273cdad94f6a7d5c0c6
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/Main.mpl
@@ -0,0 +1,37 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     lnot i32(dread i32 %i))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     lnot i32(dread i32 %i))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     lnot i32(constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     lnot i64(dread i64 %i))}
+
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     lnot i64(constval i64 0x11111))}
+
+# todo float lnot
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl b/test/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3b8711cb5f6b2307bf4a3e30da208114bc67be4a
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl
@@ -0,0 +1,22 @@
+# float a[10];
+# void init(void) {
+#   int i;
+#   for (i=0; i<10; i++)
+#     a[i] = i*3;
+# }
+
+var $a <[10] f32>
+var $f1 f32
+func $init () void {
+  var %i i32
+  dassign %i ( constval i32 0 )
+  while (
+    lt i32 i32 ( dread i32 %i, constval i32 10) ) {
+      iassign <* [10] f32> (
+        array 1 a32 <* [10] f32> (addrof a32 $a, dread i32 %i),
+	      mul f32 (dread f32 $f1, constval f32 3.33f) ) 
+      dassign %i (
+        add i32 (dread i32 %i, constval i32 1) )} }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/Main.mpl b/test/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..9f93b5a3d9b94f69fb189e2aa8609e0e562f288e
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/Main.mpl
@@ -0,0 +1,12 @@
+func &foo ( var %i i32 ) void {
+   var %p ptr
+   dassign %p ( malloc ptr ( constval i32 8 ))
+   dassign %p ( alloca ptr ( constval i32 16 ))
+   dassign %p ( gcmalloc ref i32 )
+   dassign %p ( gcmallocjarray ref <[] i32> ( constval i32 5 ))
+   free ( dread ref %p)
+}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/Main.mpl b/test/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..96ff02f6b439a646334b5bff704ed4d7f77b361e
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/Main.mpl
@@ -0,0 +1,15 @@
+type $RR <class {
+  @e1 i32, 
+  @e2 f32, 
+  @classname "foo",
+  @e3 f64}>
+type $SS <class <$RR> { @accessflag 1234, 
+                        &method1(agg)agg,
+                        &method2(void)void}>
+func $foo (
+	var %x <$SS>) i32 {
+  dassign %x 2 ( constval i32 32 )
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/Main.mpl b/test/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..178efb2aacea200a522e16652939f486bc6bf9d7
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/Main.mpl
@@ -0,0 +1,21 @@
+func &meth1() void
+func &meth3() i32
+var $sconst1 <struct {
+        @f11 i32,
+        @f22:15 i32,
+        @f33 i32,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32,
+        &meth1 () void,
+        &meth3 (i32, f64) i32 }> = [ 6=10.07f, 2=699, 3=-273, 4=75, 1=31425926, 5=6.02e+23f ]
+func &printf (var %p1 <* i8>)void
+func &main ( ) i32 {
+   call &printf (addrof a32 $sconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/Main.mpl b/test/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..bf7891e3f110b036719a3e9487acf6baf492f50b
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/Main.mpl
@@ -0,0 +1,20 @@
+var $g i32
+var $h i32
+func $multiwayfunc ( var %n i32) i32 {
+ multiway (dread i32 %n) @labdft {
+   (add i32 (dread i32 $g, dread i32 $h)): goto @lab0
+   (dread i32 $h): goto @lab1
+   (constval i32 888): goto @lab0
+   (constval i32 'Y'): goto @lab0
+   (neg i32 (dread i32 $h)) : goto @lab9 }
+@lab0
+ return (constval i32 -3)
+@labdft
+ return (constval i32 100)
+@lab9
+ return (constval i32 9)
+@lab1
+ return (constval i32 1) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/Main.mpl b/test/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..de974cbccd567b7c4d3b64835b2104cf7a1d1da1
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/Main.mpl
@@ -0,0 +1,18 @@
+var $g ptr
+var $h i32
+func $multiwayfunc ( var %p ptr) ptr {
+ multiway (dread ptr %p) @labdft {
+   (dread ptr $g): goto @lab1
+   (add ptr (dread i32 $g, dread i32 $h)): goto @lab0
+   (conststr ptr "world"): goto @lab9 }
+@lab0
+ return (dread ptr $g)
+@labdft
+ return (conststr ptr "hello")
+@lab9
+ return (add ptr (conststr ptr "foo", dread i32 $h))
+@lab1
+ return (addrof ptr $h) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/Main.mpl b/test/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..c06bc9c2dc1ae05dea9f5f4fe868265d9c01833e
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/Main.mpl
@@ -0,0 +1,60 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     neg i32(dread i32 %i))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     neg i32(dread i32 %i))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     neg i32(constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     neg i64(dread i64 %i))}
+
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     neg i64(constval i64 0x11111))}
+
+ func $foo6 (
+  var %i f64
+  ) f64 { 
+   return (
+     neg f64(dread f64 %i))}
+
+ func $foo7 (
+  var %i f32
+  ) f32 { 
+   return (
+     neg f32(dread f32 %i))}
+
+ func $foo8 (
+  var %i f64
+  ) f64 { 
+   return (
+     neg f64(constval f64 -1.24))}
+
+ func $foo9 (
+  var %i f32
+  ) f32 { 
+   return (
+     neg f32(constval f32 -1.24f))}
+# todo float neg
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/Main.mpl b/test/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..d10a0c552fb09ee5e75b886b371159aa59d9d2a9
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/Main.mpl
@@ -0,0 +1,10 @@
+type $RR <class {@e1 i32, ^e2 f32, @e3 f64}>
+type $SS <class <$RR> {^f1 i32, @f2 i8, ^f3 i8}>
+javaclass $TT <$SS> public static
+func &foo (
+	var %x <$SS>) i32 {
+  dassign %x -1 ( constval i32 32 )
+  return ( dread i32 %x -2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/Main.mpl b/test/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..693163aa4e9b8647df64e52ee812ac1e311a4351
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/Main.mpl
@@ -0,0 +1,15 @@
+type $SS <class {@f1 i32, @f2 i8, @f3 i8, &fun(i32) i32}>
+javaclass $TT <$SS> public static
+
+func &bar (var %y i32) i32 {
+  return (dread i32 %y)
+}
+
+func &foo (var %x <$SS>) i32 {
+  var %ret i32
+  polymorphiccallassigned <func(i32) i32> &bar (dread i32 %x 1) {dassign %ret 0}
+  return (dread i32 %ret)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/Main.mpl b/test/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..cb0fed58de37945afa50bf4e958e411d7e8d77cd
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/Main.mpl
@@ -0,0 +1,20 @@
+type $atyp <[10] f32>
+type $aaaa <f32>
+var $fff <$atyp>
+func $foo ( var %i i32 )i32 
+
+func $fact (
+ var %n i32, var %m f32) i32 {
+ regassign i32 %987 (constval i32 '0')
+ if (ne i32 i32 (regread i32 %987, constval i32 10)) {
+    eval (regread i32 %987)
+    call &foo(
+      sub i32 (regread i32 %1, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     regassign i32 %987 (constval i32 111)
+     return (constval i32 '1') } 
+ }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/Main.mpl b/test/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8222d5e88729be1684f178d5341f398d7ff92176
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/Main.mpl
@@ -0,0 +1,46 @@
+var $myStruct < struct{
+    @number i32,
+    @p <* i8> }>
+func $main ()i32{
+     #Character
+     var %sChar i8
+     var %usChar i8
+     #signed and unsigned short integer
+     var %shortInt i16
+     var %shortInt2 i16
+     var %sShortInt i16
+     var %sShortInt2 i16
+     var %usShortInt i16
+     var %usShortInt2 i16
+     #signed and unsigned integer
+     var %int1 i32
+     var %sInt i32
+     var %usInt i32
+     var %usInt2 i32
+     #signed and unsigned long integer
+     var %long1 i64
+     var %long2 i64
+     var %sLong1 i64
+     var %sLong2 i64
+     var %usLong i64
+     var %usLong2 i64
+     var %lLong1 i64
+     var %iLong2 i64
+     var %sLlong1 i64
+     var %sLlonog2 i64
+     var %usLlong i64
+     var %usLlong2 i64
+     #float
+     var %Float f32
+     #double
+     var %Double f64
+     #long double
+     var %lDouble f64
+     #Address
+     var %array <[10] i8>
+     iassign<* i8>(
+      array 1 a64<*[10] i8>(addrof a64 %array, constval i64 1),
+      constval i32 120)}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/Main.mpl b/test/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..e1f91e8403cba11e0be313b1778910f20a6976ae
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/Main.mpl
@@ -0,0 +1,27 @@
+ func $foo6 (
+  var %i f64
+  ) f64 { 
+   return (
+     recip f64(dread f64 %i))}
+
+ func $foo7 (
+  var %i f32
+  ) f32 { 
+   return (
+     recip f32(dread f32 %i))}
+
+ func $foo8 (
+  var %i f64
+  ) f64 { 
+   return (
+     recip f64(constval f64 -1.24))}
+
+ func $foo9 (
+  var %i f32
+  ) f32 { 
+   return (
+     recip f32(constval f32 -1.24f))}
+# todo float recip
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/Main.mpl b/test/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..7ac65fa78234fc15668f4661677acc4ff28ee764
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/Main.mpl
@@ -0,0 +1,26 @@
+ func $retypef64toi64 (
+  var %i f64
+  ) i64 { 
+   return (
+     retype i64 <i64> (dread f64 %i))}
+
+ func $retypei64tof64 (
+  var %i i64
+  ) f64 { 
+   return (
+     retype f64 <f64> (dread i64 %i))}
+
+ func $retypef32toi32 (
+  var %i f32
+  ) i32 { 
+   return (
+     retype i32 <i32> (dread f32 %i))}
+
+ func $retypei32tof32 (
+  var %i i32
+  ) f32 { 
+   return (
+     retype f32 <f32> (dread i32 %i))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/Main.mpl b/test/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..6a5e4beebaa091088129cf5c4f9b621a9cbfe697
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/Main.mpl
@@ -0,0 +1,42 @@
+ func $selecti32 (
+  var %i i32,
+   var %j i32,
+   var %k i32) i32 { 
+   return (
+     select i32 (
+      dread i32 %i, 
+      dread i32 %j, 
+      dread i32 %k))}
+
+ func $selecti64 (
+  var %i i32,
+   var %j i64,
+   var %k i64) i64 { 
+   return (
+     select i64 (
+      dread i32 %i, 
+      dread i64 %j, 
+      dread i64 %k))}
+
+ func $selectf32 (
+  var %i i32,
+   var %j f32,
+   var %k f32) f32 { 
+   return (
+     select f32 (
+      dread i32 %i, 
+      dread f32 %j, 
+      dread f32 %k))}
+
+ func $selectf64 (
+  var %i i32,
+   var %j f64,
+   var %k f64) f64 { 
+   return (
+     select f64 (
+      dread i32 %i, 
+      dread f64 %j, 
+      dread f64 %k))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/Main.mpl b/test/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..741f792157a2a19c6c36b013260e4b746d45a159
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/Main.mpl
@@ -0,0 +1,10 @@
+# ;, / and | are allowed name characters, but they cannot be the starting char
+ func $foo (
+  var %i; i32,
+  var %j|/ i32 
+  ) i32 { 
+   return (
+     add i32(dread i32 %i;, dread i32 %j|/))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/Main.mpl b/test/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..5ce01267dbaf3f0ef76a58313b389d49e89b76c9
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/Main.mpl
@@ -0,0 +1,27 @@
+ func $foo6 (
+  var %i f64
+  ) f64 {
+   return (
+     sqrt f64(dread f64 %i))}
+
+ func $foo7 (
+  var %i f32
+  ) f32 {
+   return (
+     sqrt f32(dread f32 %i))}
+
+ func $foo8 (
+  var %i f64
+  ) f64 {
+   return (
+     sqrt f64(constval f64 4.0))}
+
+ func $foo9 (
+  var %i f32
+  ) f32 {
+   return (
+     sqrt f32(constval f32 4.0f))}
+# todo float sqrt
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/Main.mpl b/test/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..0c2404ec4c8e2667691f6b2deef5f289f0da2521
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/Main.mpl
@@ -0,0 +1,16 @@
+type $SS <struct {
+        @real f32,
+        @imag f32}>
+var $sconst1 <struct {
+        @f11 i32,
+        @f22 <$SS>,
+        @f33 i32,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32}> = [ 1=1007, 2= [1=11.11f, 2=22.22f], 5=-273f, 6=75f, 4=6023 ]
+func $fact () i32 {
+  return (dread i32 $sconst1 1)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/Main.mpl b/test/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..41ff062188c1aedd365c357399d0f84399d9d0de
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/Main.mpl
@@ -0,0 +1,13 @@
+type $__field_meta__ <struct {
+  @fieldname i32,
+  @offset i32,
+  @declaringclass <* void>,
+  @type <* void>}>
+var $v1 <* void> public
+var $v2 <* void> public
+var $vs <[1] <$__field_meta__>> public = [[1= 0x35ad1b, 2= 0xabcd, 3= addrof ptr $v2, 4= addrof ptr $v1]]
+var $vvs <[2][1] <$__field_meta__>> public = [[[1= 11, 2= 22, 3= addrof ptr $v1, 4= addrof ptr $v1]],
+                                              [[1= 33, 2= 44, 3= addrof ptr $v2, 4= addrof ptr $v2]]]
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/Main.mpl b/test/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..84c7a1cebd7852237570d41822cce2f7c25c634f
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/Main.mpl
@@ -0,0 +1,17 @@
+var $sconst1 <struct {
+        @f11 i32,
+        @f22:15 i32,
+        @f33 i32,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32}> = [ 6=10.07f, 2=699, 3=-273, 4=75, 1=31425926, 5=6.02e+23f ]
+func &printf (var %p1 <* i8>)void
+func &main ( ) i32 {
+   call &printf (addrof a32 $sconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/Main.mpl b/test/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..972dfaabacc967135306ac668068391c9d282ad7
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/Main.mpl
@@ -0,0 +1,17 @@
+# typedef struct ss {
+#   int f1;
+#   char f2:3;
+#   char f3:5;
+# } SS;
+# SS foo(SS x) {
+#   x.f2 = 32;
+#   return x;
+# }
+type $SS <struct {@f1 i32, @f2:3 i8, @f3:5 i8}>
+func $foo (
+	var %x <$SS>) i32 {
+  dassign %x 2 ( constval i32 32 )
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/Main.mpl b/test/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8ec155e6f829f1a086a61fa49f3f0df909bddc44
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/Main.mpl
@@ -0,0 +1,54 @@
+#struct aa{
+#  double b;
+#  float *x;
+#};
+
+#struct bb {
+#  struct aa b1;
+#  struct aa *pa;
+#  double x1[10];
+#  double dx;
+#};
+
+#typedef struct ss {
+#  int f1;
+#  char f2:3;
+#  struct aa a3;
+#  struct aa *pa1;
+#  char f3:5;
+#  struct bb *b3;
+#  struct bb *b2;
+#  struct aa xt[23];
+#  struct aa(* funcc)(int, int, double);
+#}SS;
+
+type $unname1 <struct {@b f64,
+                       @x <* f32>}>
+type $unname2 <struct {@b1 <struct {@b f64, 
+                                    @x <* f32>}>,
+                       @pa <* <struct {@b f64, 
+                                       @x <* f32>}>>, 
+                       @x1 <[10] f64>,
+                       @dx f64}>
+type $SS      <struct {@f1 i32,
+                       @f2:3 i8,
+                       @a3 <structincomplete {@b f64, 
+                                    @x <*f32>}>,
+                       @pa1 <* <struct {@b f64, 
+                                       @x <* f32> } >>,
+                       @f3:5 i32,
+                       @b3 <* <struct {@b1 <struct {@b f64,
+                                                    @x <* f32>}>,
+                                       @pa <* <struct {@b f64,
+                                                       @x <* f32>}>>,
+                                       @x1 <[10] f64>,
+                                       @dx f64}>>,
+                       @b2 <* $unname2>,
+                       @xt <[23] <struct {@b f64, 
+                                          @a <*f32>}>>,
+                       @funcc <func(i32, i32, f64)<struct {@b f64,
+                                                           @x <* f32>}>>}>
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/Main.mpl b/test/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3d75348527b70cb616949e1d317070b8870a1152
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/Main.mpl
@@ -0,0 +1,64 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     sub i32(dread i32 %i, 
+       constval i32 -998))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     sub i32(dread i32 %i, dread i32 %j))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     sub i32(dread i32 %i, constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     sub i64(dread i64 %i, constval i64 0x111111111))}
+
+ func $foo4 (
+  var %i i64, var %j i64, var %k i32
+  )i64  { 
+   return (
+     sub i64(dread i64 %i, dread i64 %j))}
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     sub i64(dread i64 %i, constval i64 0x11111))}
+
+ func $foo6 (
+  var %i f64, var %j f64, var %k i32
+  ) f64 { 
+   return (
+     sub f64(dread f64 %i, constval f64 2.237))}
+
+ func $foo66 (
+  var %i f64, var %j f64, var %k i32
+  ) f64 {
+   return (
+     sub f64(dread f64 %i, constval f64 2.237))}
+ func $foo7 (
+  var %i f32, var %j f32, var %k i32
+  ) f32 { 
+   return (
+     sub f32(dread f32 %i, dread f32 %j))}
+
+ func $foo8 (
+  var %i f32, var %j f64, var %k i32
+  ) f32 { 
+   return (
+     sub f32(dread f32 %i, constval f32 2.237f))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/Main.mpl b/test/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..9638fbf39340b71964c889d8cce691f5a61921be
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/Main.mpl
@@ -0,0 +1,20 @@
+type $SS <struct {
+        @real f32,
+        @imag f32}>
+var $sconst1 <struct {
+        @f11 i32,
+        @f22 <$SS>,
+        @f33 i32,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32}> = [ 6=1007f, 2= [1=11.11f, 2=22.22f], 3=-273, 4=75, 1=1425926, 5=6023f ]
+func $printf (var %p1 <* i8>)void
+func $main ( ) i32 {
+   call &printf (addrof a32 $sconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/Main.mpl b/test/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8750d119201ac691f3c2c067808eb86ec0f2c23b
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/Main.mpl
@@ -0,0 +1,17 @@
+func $switchfunc ( var %n i32) i32 {
+ var %alocal i32
+ switch (dread i32 %n) @labdft {
+   -3: goto @lab0
+   1: goto @lab1
+   9: goto @lab9 }
+@lab0
+ return (constval i32 -3)
+@labdft
+ return (constval i32 100)
+@lab9
+ return (constval i32 9)
+@lab1
+ return (constval i32 1) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/Main.mpl b/test/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..bac9bc95caf5a9ae4a8d54c0fd0735f5c063ada5
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/Main.mpl
@@ -0,0 +1,42 @@
+#     1  public class sync {
+#     2      private Object go = new Object();
+#     3      private int waiters = 0;
+#     4
+#     5      public void foo() {
+#     6          synchronized (go) {
+#     7              waiters++;
+#     8          }
+#     9      }
+#    10  }
+
+# some unrelated functions are removed
+type $Ljava/lang/Object; <class  {}>
+type $Lsync; <class <$Ljava/lang/Object;> {
+  @go <* <$Ljava/lang/Object;>> private,
+  @waiters i32 private,
+  &Lsync;|foo|__V|(<* <$Lsync;>>) void}>
+func &Lsync;|foo|__V| (var %_this <* <$Lsync;>>) void {
+  var %Reg1_R33 <* <$Ljava/lang/Object;>>
+  var %Reg0_I i32
+  var %Reg0_R38 <* void>
+  #LINE sync.java:6 
+  dassign %Reg1_R33 0 (iread ptr <* <$Lsync;>> 1 (dread ptr %_this 0))
+  syncenter (dread ptr %Reg1_R33 0)
+  #LINE sync.java:7 
+  dassign %Reg0_I 0 (iread i32 <* <$Lsync;>> 2 (dread ptr %_this 0))
+  dassign %Reg0_I 0 (add i32 (
+      dread i32 %Reg0_I 0,
+      cvt i32 i8 (constval i8 1)))
+  iassign <* <$Lsync;>> 2 (dread ptr %_this 0, dread i32 %Reg0_I 0)
+  #LINE sync.java:8 
+  syncexit (dread ptr %Reg1_R33 0)
+  #LINE sync.java:9 
+  return ()
+  #LINE sync.java:8 
+  dassign %Reg0_R38 0 (regread ptr %%thrownval)
+  syncexit (dread ptr %Reg1_R33 0)
+  throw (dread ptr %Reg0_R38 0)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/Main.mpl b/test/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..12acd02e4a9d9cc1617d25cfab42c5ff660b8eb0
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/Main.mpl
@@ -0,0 +1,15 @@
+ # a function returning (i + j) * -998
+ func $foo (
+# var %i xxx,
+  var %i i32,
+   var %j i32,
+   var %k i32) i32 { 
+   return (
+     select i32 (
+      dread i32 %i, 
+      dread i32 %j, 
+      dread i32 %k))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/Main.mpl b/test/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..e88694db1e68f23b1867e83018b1fe3fd68b2783
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/Main.mpl
@@ -0,0 +1,15 @@
+#var $const1 <[13] i8> [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 10, 0 ]
+var $fconst1 <[18] f64> = [ 1007, 707, -273, 75, 0113, 0x4b, 75u, 75l, 75ul, 75lu, 3.1425926, 6.02e23, 6.02e+23, 1.6e-19, 3.0, 3.14159, 6.02e23, .233 ]
+func $printf (var %p1 <* i8>)void
+func $main ( ) i32 {
+   call &printf (addrof a32 $fconst1)
+   call &printf (conststr ptr "\"hello maple\"", conststr a32 "\nworld\n")
+   # 你好: E4 BD A0 E5 A5 BD  中国: E4 B8 AD E5 9B BD
+   call &printf (conststr16 ptr "\xE4\xBD\xA0\xE5\xA5\xBD", conststr16 a32 "\xE4\xB8\xAD\xE5\x9B\xBD")
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/Main.mpl b/test/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..9f79476c5eae1a8a1a207845375cb1bbae5a9114
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/Main.mpl
@@ -0,0 +1,50 @@
+func $foo1 (var %p1 i8, var %p2 i16, var %p3 i32, var %p4 i64, ...)i32 {
+   return (
+       constval i32 33)}
+func $foo2 (var %p1 u8, var %p2 u16, var %p3 u32, var %p4 u64,...) i32 {
+   return (
+       constval i32 33)}
+func $foo4 (var %p1 f32, var %p2 f64, ... ) i32 {
+   return (
+       constval i32 33)}
+
+func $foo5 (var %p1 a32, var %p2 a64,...) i32 
+func $foo6 (var %p1 c64, var %p2 c128, ...) i32
+
+func $foo7 (var %p1 <* i8>, var %p2 <* i16>, var %p3 <* i32>, var %p4 <* i64>) i32 {
+   return (
+       constval i32 33)}
+func $foo8 (var %p1 <* u8>, var %p2 <* u16>, var %p3 <* u32>, var %p4 <* u64>) i32 {
+   return (
+       constval i32 33)}
+func $foo9 (var %p1 <* u1>) i32 {
+   return (
+       constval i32 33)}
+func $foo10 (var %p1 <* f32>, var %p2 <* f64>) i32 {
+   return (
+       constval i32 33)}
+func $foo11 (var %p1 <* void>)void
+
+func $foo12 (var %p1 <[10] i8>) i32 {
+   return (
+       constval i32 33)}
+func $foo13 (var %p1 <[10][32] i32>) i32 {
+   return (
+       constval i32 33)}
+func $foo14 (var %p1 <[10][32][43] i32>) i32 {
+   return (
+       constval i32 33)}
+func $foo15 (var %p1 <[10][32][43][54][56][78][90][122][223][334] i32>) i32 {
+   return (
+       constval i32 33)}
+
+type $SS <struct {@f1 i32, @f2:3 i8, @f3:5 i8}>
+func $foo16 (var %x <$SS>) i32 {
+   return (
+       constval i32 33)}
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/Main.mpl b/test/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3aa3c48c666596cdfeb9f0a77fe301eadaeebc5b
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/Main.mpl
@@ -0,0 +1,21 @@
+#int fact (int n) {
+#  if(n != 1)
+#    return foo(n - 1);
+#  else return 1;
+#}
+func $foo varargs ( var %i i32, ... ) i32 {
+  return (dread i32 %i) }
+func $foo1 varargs ( ... ) i32 {
+  return (constval i32 99) }
+
+func $fact (
+ var %n i32) i32 {
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    call &foo(
+      sub i32 (dread i32 %n, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/Main.mpl b/test/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..1ee6f5f094c9ebf9bc4d9b8c82986505690ee583
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/Main.mpl
@@ -0,0 +1,13 @@
+ # a function returning unary(i + j) * -998
+#type $SS <struct {@f1 f32}>
+ func $foo (
+  var %k <struct {@f1 f32}>,
+  var %f f32,
+  var %i i32,
+   var %j i32)i64  { 
+   return (
+       cvt i64 i32 (constval i32 12345))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl b/test/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a6e95d9cb500cfd1abc4b544e778c26dc97f53ea
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl
@@ -0,0 +1,15 @@
+ # a function returning unary(i + j) * -998
+ func $foo (
+  var %i i32,
+   var %j i32) f32 { 
+   return (
+     recip f32(
+       sqrt f32(  
+      cvt f32 i32(
+        mul i32 (
+         extractbits i32 1 23 ( add i32 ( bnot i32 (dread i32 %i), lnot i32 (dread i32 %j))), 
+         neg i32 ( constval i32 -998))))))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/Main.mpl b/test/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3529c000291396e1a9125c91d7d3294bff33d3da
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/Main.mpl
@@ -0,0 +1,29 @@
+type $RR <class {@e1 i32, @e2 f32, @e3 f64}>
+type $SS <class <$RR> { &method1(agg)agg,
+                        &method2(void)void}>
+func $foo (
+  var %x <$SS>) i32 {
+  var %r1 i32
+  var  %r2 i32
+  var  %r3 i32
+  dassign %x 2 ( constval i32 32 )
+  # Not correct, but for parse and dump test.
+  virtualcallassigned &method2(addrof ptr %x) {
+    dassign %r1 1
+    dassign %r2 2
+    dassign %r3 3
+  }
+  superclasscallassigned &method2(addrof ptr %x) {
+    dassign %r1 1
+    dassign %r2 2
+    dassign %r3 3
+  }
+  interfacecallassigned &method2(addrof ptr %x) {
+    dassign %r1 1
+    dassign %r2 2
+    dassign %r3 3
+  }
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/Main.mpl b/test/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..02a30ee4d9a7178e22106ac402dbbe802fda2db8
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/Main.mpl
@@ -0,0 +1,13 @@
+type $RR <class {@e1 i32, @e2 f32, @e3 f64}>
+type $SS <class <$RR> { &method1(agg)agg,
+                        &method2(void)void}>
+func $foo (
+	var %x <$SS>) i32 {
+  dassign %x 2 ( constval i32 32 )
+  virtualcall &method2(addrof ptr %x)
+  superclasscall &method2(addrof ptr %x)
+  interfacecall &method2(addrof ptr %x)
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/Main.mpl b/test/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..b00128d06ff9aa81b73e85db6abae1a9bf934348
--- /dev/null
+++ b/test/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/Main.mpl
@@ -0,0 +1,19 @@
+# int foo(void) {
+#   int n = 1;
+#   int i;
+#   for (i=1; i<10; i++)
+#     n = n * i;
+# }
+
+func $foo (var %i i32) i32 {
+  while (
+    lt i32 i32 ( dread i32 %i, constval i32 10) ) {
+      dassign %i (
+	mul i32 (dread i32 %i, dread i32 %i))
+      dassign %i (
+        add i32 (dread i32 %i, constval i32 1) )} 
+  return ( constval i32 1 )
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/test/testsuite/irbuild_test/test.cfg b/test/testsuite/irbuild_test/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2298a3e84b92a2a5e07567fadd8a1700b0440a97
--- /dev/null
+++ b/test/testsuite/irbuild_test/test.cfg
@@ -0,0 +1,10 @@
+[suffix]
+mpl = #
+
+[internal-var]
+irbuild = ${MAPLE_BUILD_OUTPUT}/bin/irbuild
+cmp = /usr/bin/cmp -s 
+
+[description]
+title = Maple Irbuild Test
+
diff --git a/test/testsuite/maple.py b/test/testsuite/maple.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8c3cb56fa0a91816265945088905764a806634d
--- /dev/null
+++ b/test/testsuite/maple.py
@@ -0,0 +1,338 @@
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import argparse
+import collections
+import logging
+import os
+import subprocess
+import time
+import re
+from functools import wraps
+
+
+limitation = 0
+output_name = ""
+input_name = ""
+logger = logging.getLogger("COMPILE")
+logger.setLevel(logging.DEBUG)
+ch = logging.StreamHandler()
+ch.setLevel(logging.DEBUG)
+# create formatter and add it to the handlers
+formatter = logging.Formatter("%(asctime)-18s - %(name)s - %(levelname)s - %(message)s")
+ch.setFormatter(formatter)
+# add the handlers to the logger
+logger.addHandler(ch)
+
+
+def timing(func):
+    # Decorator that reports the execution time.
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        end = time.time()
+        logger.info("Time Consuming:" + str(end - start) + "s")
+        return result
+
+    return wrapper
+
+
+# exec the compile command
+@timing
+def build(cmd):
+    global limitation
+    run_cmd = " ".join(cmd)
+    logger.info(run_cmd)
+    com = subprocess.Popen(run_cmd,
+                           stdout=subprocess.PIPE,
+                           stderr=subprocess.PIPE,
+                           shell=True,
+                           cwd="./",
+                           universal_newlines=True)
+    com_out, com_err = "", ""
+    try:
+        com_out, com_err = com.communicate(timeout=limitation)
+        if com_out is not None:
+            logger.debug(com_out)
+        if not com.returncode == 0:
+            logger.error(com_err)
+            exit(1)
+    except subprocess.TimeoutExpired as e:
+        com.kill()
+        logger.error(e)
+        exit(3)
+    except Exception as ee:
+        com.kill()
+        logger.error(ee)
+        exit(1)
+    return com_out, com_err, com.returncode
+
+
+class MultiCompiler:
+    def __init__(self, name, in_suffix, out_suffix, options):
+        self._in_files_name = ""
+        self._out_file_name = ""
+        self._is_skipped = True
+        self._name = name
+        self._in_suffix = in_suffix
+        self._out_suffix = out_suffix
+        self._options = options
+
+    def get_in_suffix(self):
+        return self._in_suffix
+
+    def update_info(self, path, options):
+        if path is not None:
+            self._name = path + self._name
+        if options is not None:
+            self._options = self._options + " " + options
+
+    def prepare(self, file_list):
+        temp_list = file_list.copy()
+        for in_file in temp_list:
+            name = in_file[0:-len(self._in_suffix)]
+            if in_file == name + self._in_suffix:
+                self._is_skipped = False
+                file_list.remove(in_file)
+                self._in_files_name = self._in_files_name + in_file + " "
+                self._out_file_name = name + self._out_suffix
+                file_list.append(self._out_file_name)
+            else:
+                continue
+
+    def build(self):
+        if not self._is_skipped:
+            return build(self._gen_cmd())
+
+    def _gen_cmd(self):
+        cmd = [self._name]
+        cmd.extend(self._make_opts())
+        cmd.extend(re.sub(r"\s+", " ", self._in_files_name).strip().split(" "))
+        return cmd
+
+    def _make_opts(self):
+        options = self._options.strip()
+        opts = []
+        opts.append(options)
+        return opts
+
+class java2mpl(MultiCompiler):
+    def prepare(self, file_list):
+        global output_name
+        temp_list = file_list.copy()
+        for in_file in temp_list:
+            name = in_file[0:-len(self._in_suffix)]
+            if in_file == name + self._in_suffix:
+                self._is_skipped = False
+                file_list.remove(in_file)
+                self._in_files_name = self._in_files_name + in_file + " "
+            else:
+                continue
+        # Use the first input file name as the output file name
+        if not self._is_skipped:
+            self._out_file_name = output_name.split("/")[-1].split(".")[0] + self._out_suffix
+            file_list.append(self._out_file_name)
+
+class SingleCompiler(MultiCompiler):
+    def prepare(self, file_list):
+        is_single = 0
+        temp_list = file_list.copy()
+        for in_file in temp_list:
+            name = in_file[0:-len(self._in_suffix)]
+            if in_file == name + self._in_suffix:
+                self._is_skipped = False
+                is_single = is_single + 1
+                if is_single > 1:
+                    logger.error("Not support multi .jar")
+                    exit(1)
+                file_list.remove(in_file)
+                self._in_files_name = in_file
+                self._out_file_name = name + self._out_suffix
+                file_list.append(self._out_file_name)
+            else:
+                continue
+
+
+class Ld(MultiCompiler):
+    def _gen_cmd(self):
+        # Specify the output file name
+        cmd = [self._name]
+        cmd.extend(re.sub(r"\s+", " ", self._in_files_name).strip().split(" "))
+        cmd.extend(self._make_opts())
+        return cmd
+
+
+# ------------------------------------------------------------------------
+#
+# initial parser and parse the args
+# Add parser arguments by tool chain components name
+#
+# ------------------------------------------------------------------------
+def do_init(components):
+    parser = argparse.ArgumentParser(prog="maple", usage="maple [options] <inputs>")
+    # choose toolchain target
+    parser.add_argument("-p", "--platform", dest="target", choices=["aarch64"], default="aarch64",
+                        help="choose toolchain target, default is aarch64")
+    # Select compile phase
+    parser.add_argument("-s", "--stage", dest="stage", choices=["java2d8", "dex2mpl", "maple", "as", "ld"], default="ld",
+                        help="Select the compiler stage, default is ld")
+    # set timeout limitation
+    parser.add_argument("--timeout", metavar="TIMEOUT", dest="timeout", default=None, type=int,
+                        help="set the timeout limitation")
+    # set the output name
+    parser.add_argument("-o", metavar="OUTPUT", dest="output", default="",
+                        help="set the output file name")
+    suffixes = set()
+    for name in components.keys():
+        parser.add_argument("--" + name, metavar=name.upper(),
+                            help="set the options for component " + name)
+        suffixes.add(components[name].get_in_suffix())
+    # check the legal inputs
+    parser.add_argument("filename", metavar="<inputs>", nargs="+",
+                        help="legal input files include: " + str(suffixes))
+    args = parser.parse_args()
+    return vars(args)
+
+
+# ------------------------------------------------------------------------
+#
+#  set the tool path and compile options
+#
+# -----------------------------------------------------------------------
+def do_prepare(components, info, maple_root):
+    global output_name
+    maple_out_path = os.environ.get("MAPLE_BUILD_OUTPUT")
+    maple_out_lib_path = maple_out_path + "/ops"
+    maple_out_bin_path = maple_out_path + "/bin/"
+    gnu_bin_path = maple_root + "/tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/bin/"
+    if "OLD_OS" in os.environ.keys():
+        if os.environ.get("OLD_OS") == "0":
+            gnu_bin_path = "/usr/bin/"
+    as_options = "-g3 -O2 -x assembler-with-cpp -march=armv8-a -target aarch64-linux-gnu -c "
+    cc_options = "-g3 -O2 -c -march=armv8-a -target aarch64-linux-gnu"
+    cxx_options = "-g3 -O2 -c -fPIC -march=armv8-a -target aarch64-linux-gnu"
+    linker_options = "-g3 -O2 -march=armv8-a -target aarch64-linux-gnu -fPIC -shared -o "\
+                   + output_name + " " + maple_out_lib_path + "/mrt_module_init.o "\
+                   + "-fuse-ld=lld -rdynamic -lcore-all -lcommon-bridge -Wl,-z,notext -Wl,-T"\
+                   + maple_out_lib_path + "/linker/maplelld.so.lds"
+
+    components["java2d8"].update_info(maple_out_bin_path, info["java2d8"])
+    components["dex2mpl"].update_info(maple_out_bin_path, info["dex2mpl"])
+    components["maple"].update_info(maple_out_bin_path, info["maple"])
+    components["as"].update_info(gnu_bin_path, info["as"])
+    components["cc"].update_info(gnu_bin_path, info["cc"])
+    components["cxx"].update_info(gnu_bin_path, info["cxx"])
+    components["ld"].update_info(gnu_bin_path, info["ld"])
+
+    components["as"].update_info(None, as_options)
+    components["cc"].update_info(None, cc_options)
+    components["cxx"].update_info(None, cxx_options)
+    components["ld"].update_info(None, linker_options)
+
+# ------------------------------------------------------------------------
+#
+#  Select compile phase: "javac", "jar", "maple", "as", "ld"
+#
+# -----------------------------------------------------------------------
+def do_update(components, file_type):
+    if file_type == "java2d8":
+        components.pop("dex2mpl")
+        components.pop("maple")
+        components.pop("as")
+        components.pop("cc")
+        components.pop("cxx")
+        components.pop("ld")
+    elif file_type == "dex2mpl":
+        components.pop("maple")
+        components.pop("as")
+        components.pop("cc")
+        components.pop("cxx")
+        components.pop("ld")
+    elif file_type == "maple":
+        components.pop("as")
+        components.pop("cc")
+        components.pop("cxx")
+        components.pop("ld")
+    elif file_type == "as":
+        components.pop("ld")
+
+
+# ------------------------------------------------------------------------
+#
+#  compile files one by one
+#
+# -----------------------------------------------------------------------
+def do_check(components, file_list):
+    # del the repeat input files
+    for in_file in file_list:
+        while file_list.count(in_file) > 1:
+            file_list.remove(in_file)
+        if not os.path.isfile(in_file):
+            logger.error("No such file or directory: " + in_file)
+            exit(1)
+    # compile accord with pre-install phases
+    for phase in list(components.keys()):
+        components[phase].prepare(file_list)
+
+
+# ------------------------------------------------------------------------
+#
+#  Main entry for maple java driver
+#
+# ------------------------------------------------------------------------
+def main():
+    maple_root = os.environ.get("MAPLE_ROOT")
+    if maple_root is None:
+        logger.error("Not found system environment: MAPLE_ROOT")
+        exit(1)
+    # initial all tool chain components:
+    # set the default name, input suffix, output suffix, and if it support multi-inputs
+    components = collections.OrderedDict()
+    components["java2d8"] = java2mpl("java2d8", ".java", ".dex", "")
+    components["dex2mpl"] = java2mpl("dex2mpl", ".dex", ".mpl", "")
+    components["maple"] = SingleCompiler("maple", ".mpl", ".s", "")
+    components["as"] = MultiCompiler("clang++", ".s", ".o", "")
+    components["cc"] = MultiCompiler("clang", ".c", ".o", "")
+    components["cxx"] = MultiCompiler("clang++", ".cpp", ".o", "")
+    components["ld"] = Ld("clang++", ".o", ".so", "")
+
+    # set the parser and collect the args
+    info = do_init(components)
+    # set the limitation and output file name
+    global limitation, output_name, input_name
+    limitation = info["timeout"]
+    output_name = info["output"]
+    file_list = info["filename"]
+    file_type = info["stage"]
+    input_name = file_list[0]
+    input_name = input_name.split("/")[-1].split(".")[0]
+    if output_name == "":
+        output_name = input_name + ".so"
+    # set the compile options and tool path
+    do_prepare(components, info, maple_root)
+    # Select compile phase
+    do_update(components, file_type)
+    # check files one by one
+    do_check(components, file_list)
+    # compile accord with pre-install phases
+    for phase in list(components.keys()):
+        components[phase].build()
+    logger.info("Compile Finished!")
+
+if __name__ == "__main__":
+    main()
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/ABCOcatchArrayIndexOutOfBoundsException.java b/test/testsuite/ouroboros/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/ABCOcatchArrayIndexOutOfBoundsException.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad45f985497e0294efa8310914e89e7fbf32aa1c
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/ABCOcatchArrayIndexOutOfBoundsException.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOcatchArrayIndexOutOfBoundsException.java
+ * -@TestCaseName: ArrayIndexOutOfBoundsException is throw
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 编译优化,Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[1024], c = a[1024]
+ * -#step2: ArrayIndexOutOfBoundsException is throw
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOcatchArrayIndexOutOfBoundsException.java
+ * -@ExecuteClass: ABCOcatchArrayIndexOutOfBoundsException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOcatchArrayIndexOutOfBoundsException {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        try {
+            func();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        } catch (Exception e) {
+            res = res + 2;
+        }
+        return res;
+    }
+
+    public static void func() throws Exception {
+        int[] a = new int[1024];
+        int c = a[1024];
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/ABCOcatchIndexOutOfBoundsException.java b/test/testsuite/ouroboros/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/ABCOcatchIndexOutOfBoundsException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4fbbdfeead529c5460c88d45c8f2868f260f6a7
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/ABCOcatchIndexOutOfBoundsException.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOcatchIndexOutOfBoundsException.java
+ * -@TestCaseName: IndexOutOfBoundsException is throw
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[1024], c = a[1024]
+ * -#step2: IndexOutOfBoundsException is throw
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOcatchIndexOutOfBoundsException.java
+ * -@ExecuteClass: ABCOcatchIndexOutOfBoundsException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOcatchIndexOutOfBoundsException {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        try {
+            func();
+        } catch (IndexOutOfBoundsException e) {
+            res--;
+        } catch (Exception e) {
+            res = res + 2;
+        }
+        return res;
+    }
+
+    public static void func() throws Exception {
+        int[] a = new int[1024];
+        int c = a[1024];
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/ABCOcatchStringIndexOutOfBoundsException.java b/test/testsuite/ouroboros/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/ABCOcatchStringIndexOutOfBoundsException.java
new file mode 100644
index 0000000000000000000000000000000000000000..21f95086a4a2cb2a40aad72262508f2b40dccf87
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/ABCOcatchStringIndexOutOfBoundsException.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOcatchStringIndexOutOfBoundsException.java
+ * -@TestCaseName: StringIndexOutOfBoundsException is throw
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new char[1024], change char[] to String.
+ * -#step2: call String.charAt(1024), StringIndexOutOfBoundsException is throw
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOcatchStringIndexOutOfBoundsException.java
+ * -@ExecuteClass: ABCOcatchStringIndexOutOfBoundsException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOcatchStringIndexOutOfBoundsException {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        try {
+            func();
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        } catch (Exception e) {
+            res = res + 2;
+        }
+        return res;
+    }
+
+    public static void func() throws Exception {
+        char[] a = new char[1024];
+        int index = 0;
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'a';
+            index++;
+        }
+        String joinLine = a.toString();
+        char c = joinLine.charAt(index);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/ABCOconstOperation.java b/test/testsuite/ouroboros/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/ABCOconstOperation.java
new file mode 100644
index 0000000000000000000000000000000000000000..ced04f935a81f9be763da5252c349ee5f66c006b
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/ABCOconstOperation.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOconstOperation.java
+ * -@TestCaseName: index is X,  X = Y +/-/X///&/|/ Const
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: visit index is X,  X = Y +/-/X///&/|/ Const, X is large than arr.length
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOconstOperation.java
+ * -@ExecuteClass: ABCOconstOperation
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOconstOperation {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 10 /*STATUS_FAILED*/;
+        int[] arr1 = new int[15];
+        for (int i = 0; i < arr1.length; i++) {
+            arr1[i] = i;
+        }
+        int index = 1;
+
+        int y = 6;
+        try {
+            index = index + y + 9;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = y - 16 - index;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = y * y * index;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = index + 937;
+            index = (y / index) * y;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = (y + 9) & 15;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = y | index;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = ~index;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = 15;
+            index = index ^ 16;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = index % 16;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/ABCOcustomClass.java b/test/testsuite/ouroboros/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/ABCOcustomClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..45391ae9277a1013750d93a2e4c671847128dbfc
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/ABCOcustomClass.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOcustomClass.java
+ * -@TestCaseName: index and array is in same customClass, and another class call array[index].
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: create customClass include index and arrays
+ * -#step2: get customClass.arrays[index], index is arrays.length
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOcustomClass.java
+ * -@ExecuteClass: ABCOcustomClass
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOcustomClass {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        People p = new People(3);
+        int x = p.n;
+        try {
+            Student a = p.s[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+
+class People {
+    int n;
+    Student s[] = new Student[n];
+
+    public People(int n) {
+        this.n = n;
+    }
+}
+
+class Student {
+    int number;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/ABCOdoWhile.java b/test/testsuite/ouroboros/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/ABCOdoWhile.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b9c05aab2ea4126e4acf2b5586e115faa29a0c0
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/ABCOdoWhile.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOdoWhile.java
+ * -@TestCaseName: do while visit Array element
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: do while visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOdoWhile.java
+ * -@ExecuteClass: ABCOdoWhile
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOdoWhile {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] c = new int[a.length];
+        int x = 0;
+        int y = a.length;
+        try {
+            do {
+                c[x] = a[x];
+                x++;
+            } while (x <= y);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/ABCOemptyArray.java b/test/testsuite/ouroboros/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/ABCOemptyArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a4ddaf151f584bb7af861638c1a99224e26c35c
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/ABCOemptyArray.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOemptyArray.java
+ * -@TestCaseName: new Array[0]
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[0]
+ * -#step2: visit index of const, index is 0 and -1
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOemptyArray.java
+ * -@ExecuteClass: ABCOemptyArray
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOemptyArray {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        int result2 = 4;
+        try {
+            result = test1();
+            result2 = test2();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && result2 == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        Object[] a = new Object[0];
+        try {
+            a[0] = new Object[0];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            Object c = a[-1];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+
+    public static int test2() {
+        int res = 2 /*STATUS_FAILED*/;
+        String[] data;
+        try {
+            data = new String[] {}; // 初始化
+            data[0] = "lisi";
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/ABCOemptyString.java b/test/testsuite/ouroboros/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/ABCOemptyString.java
new file mode 100644
index 0000000000000000000000000000000000000000..6fbccb977c4c58bf0f09c19aed7b375d640b9489
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/ABCOemptyString.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOemptyString.java
+ * -@TestCaseName: String is "", index is 0
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: String is "" or new String("")
+ * -#step2: index is 0, call charAt and codePointAt
+ * -#step3: catch Exception StringIndexOutOfBoundsException
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOemptyString.java
+ * -@ExecuteClass: ABCOemptyString
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOemptyString {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+
+        try {
+            String string = "";
+            char c = string.charAt(0);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            String string = new String("");
+            int c = string.codePointAt(0);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/ABCOfor.java b/test/testsuite/ouroboros/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/ABCOfor.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff70b0e0523102ac89d0ea270643db27ed238f16
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/ABCOfor.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOfor.java
+ * -@TestCaseName: for visit Array[index], index visit 0 to Array.length.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: for visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOfor.java
+ * -@ExecuteClass: ABCOfor
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOfor {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[1024];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+
+        int[] b = new int[a.length];
+        try {
+            for (int i = 0; i <= a.length; i++) {
+                b[i] = a[i];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/ABCOglobalArray.java b/test/testsuite/ouroboros/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/ABCOglobalArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..dce83a67eeb0b913eee58aa8715f7a64eb8d0688
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/ABCOglobalArray.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOglobalArray.java
+ * -@TestCaseName: new Array[5] in global
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5] in global
+ * -#step2: while visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOglobalArray.java
+ * -@ExecuteClass: ABCOglobalArray
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+public class ABCOglobalArray {
+    static int RES_PROCESS = 99;
+    static int[] a = new int[5];
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] b = new int[6];
+        Arrays.fill(a, 9);
+        for (int i = 0; i <= a.length; i++) {
+            b[i] = i;
+        }
+        int[] c = new int[6];
+        try {
+            for (int j = 0; j <= a.length; j++) {
+                int x = b[j];
+                c[x] = a[x];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/ABCOglobalIndex.java b/test/testsuite/ouroboros/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/ABCOglobalIndex.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f90771f3390909a23967dac3751108b3a73800a
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/ABCOglobalIndex.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOglobalIndex.java
+ * -@TestCaseName: Index in global
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5], Index in global
+ * -#step2: while visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOglobalIndex.java
+ * -@ExecuteClass: ABCOglobalIndex
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOglobalIndex {
+    static int RES_PROCESS = 99;
+    static int x = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+
+        int[] a = new int[1024];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+
+        int y = a.length;
+        try {
+            while (x < y) {
+                x = a[x + 1];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/ABCOglobalString.java b/test/testsuite/ouroboros/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/ABCOglobalString.java
new file mode 100644
index 0000000000000000000000000000000000000000..a42240c00c084e32d78ec8964c80b3b217882522
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/ABCOglobalString.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOglobalString.java
+ * -@TestCaseName: new Array[5] in global
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5] in global
+ * -#step2: while visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOglobalString.java
+ * -@ExecuteClass: ABCOglobalString
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOglobalString {
+    static int RES_PROCESS = 99;
+    static String joinLine = new String();
+    static int index = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        joinLine = a.toString();
+
+        char[] b = new char[joinLine.length()];
+        try {
+            for (int j = 0; j <= joinLine.length(); j++) {
+                index = j;
+                b[index] = joinLine.charAt(index);
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/ABCOif.java b/test/testsuite/ouroboros/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/ABCOif.java
new file mode 100644
index 0000000000000000000000000000000000000000..e98cd8737398f90f29e2a5e98d0522f048a6f520
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/ABCOif.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOif.java
+ * -@TestCaseName: if visit Array
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: if visit Array
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOif.java
+ * -@ExecuteClass: ABCOif
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOif {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] arr = new int[5];
+        int[] arrCp = arr;
+        for (int i = 0; i < arr.length; i++) {
+            arrCp[i] = i;
+        }
+
+        int y = arr.length;
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/ABCOincreaseArray.java b/test/testsuite/ouroboros/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/ABCOincreaseArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..d76c18787ee7df58b37ddeadacddff7e15ad7103
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/ABCOincreaseArray.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOincreaseArray.java
+ * -@TestCaseName: Array is increase length
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[10] a, use System.arraycopy to create new Array[20] newArray
+ * -#step2: visit a[9], no exception throw
+ * -#step3: visit newArray[20], catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOincreaseArray.java
+ * -@ExecuteClass: ABCOincreaseArray
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+public class ABCOincreaseArray {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        int[] a = new int[10];
+        Arrays.fill(a, 20);
+        int[] newArray = (int[]) func(a);
+        int index = newArray[0];
+
+        try {
+            int c = a[index - 11];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 5;
+        }
+
+        try {
+            int c = newArray[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        return res;
+    }
+
+    public static Object func(Object array) {
+        Class<?> clazz = array.getClass();
+        if (clazz.isArray()) {
+            Class<?> componentType = clazz.getComponentType();
+            int length = Array.getLength(array);
+            Object newArray = Array.newInstance(componentType, length + 10);
+            System.arraycopy(array, 0, newArray, 0, length);
+            return newArray;
+        }
+        return null;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/ABCOindexAssociation.java b/test/testsuite/ouroboros/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/ABCOindexAssociation.java
new file mode 100644
index 0000000000000000000000000000000000000000..a926f73b469e119f44fd61bf046ba4cd5fb4c203
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/ABCOindexAssociation.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOindexAssociation.java
+ * -@TestCaseName: for visit Array[index], index visit 0 to Array.length.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5] a, make c = a
+ * -#step2: for visit Array element, give index (0~length) to a
+ * -#step3: catch Exception
+ * -#step4: new Array[5] a, make c = a
+ * -#step5: for visit Array element, give index (0~length-1) to a
+ * -#step6: for visit Array element, give a[index] to index
+ * -#step7: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOindexAssociation.java
+ * -@ExecuteClass: ABCOindexAssociation
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOindexAssociation {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        int result2 = 4;
+        try {
+            result = test1();
+            result2 = test2();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && result2 == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] c = a;
+
+        try {
+            for (int i = 0; i <= a.length; i++) {
+                c[i] = i;
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int test2() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+
+        try {
+            for (int j = 1; j <= a.length; j++) {
+                if (a[j] > a[j - 1]) {
+                    j = a[j];
+                }
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/ABCOindexDoWhile.java b/test/testsuite/ouroboros/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/ABCOindexDoWhile.java
new file mode 100644
index 0000000000000000000000000000000000000000..9012b3af59d2761d35f77e1eb75941abfdd358c5
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/ABCOindexDoWhile.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOindexDoWhile.java
+ * -@TestCaseName: do while visit Array index
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: do while visit Array index
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOindexDoWhile.java
+ * -@ExecuteClass: ABCOindexDoWhile
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOindexDoWhile {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        // catch ArrayIndexOutOfBoundsException
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[1000];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+
+        int[] b = new int[a.length];
+        int x = funx(100);
+        int y = funx(1000);
+        try {
+            do {
+                b[x] = a[x];
+                x++;
+            } while (x <= y);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index = 0;
+        do {
+            index = funy(index);
+        } while (index < endIndex);
+        return index;
+    }
+
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/ABCOindexFor.java b/test/testsuite/ouroboros/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/ABCOindexFor.java
new file mode 100644
index 0000000000000000000000000000000000000000..353ba33e69dcc6eee00de83a01f596c3efae38ae
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/ABCOindexFor.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOindexFor.java
+ * -@TestCaseName: for visit Array[index], index visit 0 to Array.length.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: for visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOindexFor.java
+ * -@ExecuteClass: ABCOindexFor
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOindexFor {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[1000];
+        int[] c = a;
+        for (int ii = 0; ii < a.length; ii++) {
+            c[ii] = ii;
+        }
+
+        int[] b = new int[a.length];
+        try {
+            for (int i = funx(100); i <= funx(1000); i++) {
+                if (i >= 1000) {
+                    for (int j = i; j > 0; j--) {
+                        int index = funx(1000);
+                        b[index] = a[index];
+                    }
+                }
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index;
+
+        for (index = 0; index <= endIndex; index++) {
+            index = funy(index);
+        }
+
+        return index;
+    }
+
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/ABCOindexFromArrayFromParam.java b/test/testsuite/ouroboros/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/ABCOindexFromArrayFromParam.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6b3c908a4780930a34c6e3c3d857f1d3b3f903e
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/ABCOindexFromArrayFromParam.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOindexFromArrayFromParam.java
+ * -@TestCaseName: index From Array element, element From Param
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2:  while visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOindexFromArrayFromParam.java
+ * -@ExecuteClass: ABCOindexFromArrayFromParam
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOindexFromArrayFromParam {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            int num = 5;
+            result = test1(num);
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1(int num) {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        a[4] = num;
+        int[] c = a.clone();
+        int x = c[4];
+        try {
+            int b = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/ABCOindexIf.java b/test/testsuite/ouroboros/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/ABCOindexIf.java
new file mode 100644
index 0000000000000000000000000000000000000000..10bcbd44df8d3716ad0a3bd71693025517655dd6
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/ABCOindexIf.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOindexIf.java
+ * -@TestCaseName: if visit Array
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: if visit Array
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOindexIf.java
+ * -@ExecuteClass: ABCOindexIf
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Random;
+
+public class ABCOindexIf {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] arr = new int[5];
+        int[] arrCp = arr;
+        for (int i = 0; i < arr.length; i++) {
+            arrCp[i] = i;
+        }
+
+        int y = func();
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int func() {
+        Random r = new Random();
+        int get = r.nextInt(6);
+        if (get >= 5) {
+            return get;
+        } else {
+            get = func();
+            return get;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/ABCOindexMutiLoop.java b/test/testsuite/ouroboros/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/ABCOindexMutiLoop.java
new file mode 100644
index 0000000000000000000000000000000000000000..fde290c4fbc338b6c6f5f5354a5f23fc841b291f
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/ABCOindexMutiLoop.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOindexMutiLoop.java
+ * -@TestCaseName: index from multi-layer loop
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: visit index of multi-layer loop
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOindexMutiLoop.java
+ * -@ExecuteClass: ABCOindexMutiLoop
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+public class ABCOindexMutiLoop {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        Arrays.fill(a, 8000);
+
+        int x;
+        try {
+            x = func();
+            int c = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        return res;
+    }
+
+    public static int func() {
+        int index = 0;
+        for (int i = 0; i < 5; i++) {
+            for (int j = 0; j < 5; j++) {
+                for (int k = 0; k < 5; k++) {
+                    for (int ii = 0; ii < 5; ii++) {
+                        for (int jj = 0; jj < 5; jj++) {
+                            for (int kk = 0; kk < 5; kk++) {
+                                for (int iii = 0; iii < 5; iii++) {
+                                    for (int jjj = 0; jjj < 5; jjj++) {
+                                        for (int kkk = 0; kkk < 5; kkk++) {
+                                            for (int n = 0; n < 5; n++) {
+                                                index = index + n;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return index;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/ABCOindexNesting.java b/test/testsuite/ouroboros/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/ABCOindexNesting.java
new file mode 100644
index 0000000000000000000000000000000000000000..755e9d8c892688e56d41113cbf3807fa3f71b86c
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/ABCOindexNesting.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOindexNesting.java
+ * -@TestCaseName: give nesting fun to index
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[1023] a, make c = a, visit Array element, give index (0~length) to c
+ * -#step2: for visit Array index j, nestint func, funx, funy，funw to give value to index
+ * -#step3: let j = a[index], when j > a.length, will catch ArrayIndexOutOfBoundsException
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOindexNesting.java
+ * -@ExecuteClass: ABCOindexNesting
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOindexNesting {
+    static int RES_PROCESS = 99;
+    static int arrNum = 1023;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[arrNum];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+
+        int index = 0;
+        try {
+            for (int j = 1; j <= a.length; j++) {
+                if (j == a.length) {
+                    index = func(j, index);
+                    j = a[index];
+                }
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+
+    public static int func(int index, int getIndex) {
+        getIndex = funx(getIndex, index);
+        getIndex = getIndex + 10;
+        if (getIndex < index) {
+            getIndex = func(index, getIndex);
+        }
+        return getIndex;
+    }
+
+    public static int funx(int getIndex, int index) {
+        getIndex = getIndex + index;
+        getIndex = funy(getIndex, index);
+        return getIndex;
+    }
+
+    public static int funy(int getIndex, int index) {
+        getIndex = getIndex * index;
+        getIndex = funz(getIndex, index);
+        return getIndex;
+    }
+
+    public static int funz(int getIndex, int index) {
+        getIndex = getIndex / index;
+        getIndex = funw(getIndex, index);
+        return getIndex;
+    }
+
+    public static int funw(int getIndex, int index) {
+        getIndex = getIndex - index;
+        return getIndex;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/ABCOindexSwitch.java b/test/testsuite/ouroboros/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/ABCOindexSwitch.java
new file mode 100644
index 0000000000000000000000000000000000000000..6eb137f55dcdce19da3625141d2d8632c3213a0d
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/ABCOindexSwitch.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOindexSwitch.java
+ * -@TestCaseName: switch visit index
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: switch visit Array index
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOindexSwitch.java
+ * -@ExecuteClass: ABCOindexSwitch
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Random;
+
+public class ABCOindexSwitch {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] arrCp = a;
+        for (int i = 0; i < a.length; i++) {
+            arrCp[i] = i;
+        }
+
+        int c;
+        int x = func();
+        try {
+            c = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int func() {
+        Random r = new Random();
+        int getI = r.nextInt(3);
+        int y = getI % 3;
+        getI = getI + 5;
+        switch (y) {
+            case 0:
+                getI = getI + 0;
+                break;
+            case 1:
+                getI = getI + 1;
+                break;
+            default:
+                getI = getI + 2;
+        }
+        return getI;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/ABCOlength.java b/test/testsuite/ouroboros/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/ABCOlength.java
new file mode 100644
index 0000000000000000000000000000000000000000..72ea67c0fd15bc334a362c65c976c58f7838a61a
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/ABCOlength.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOlength.java
+ * -@TestCaseName: index is X, X is arrays.length
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: visit index of arrays.length
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOlength.java
+ * -@ExecuteClass: ABCOlength
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOlength {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        try {
+            int b = a.length;
+            int c = a[b];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/ABCOlistToArray.java b/test/testsuite/ouroboros/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/ABCOlistToArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..22e95207b8733cf192310c9c1a2f7473c3e3c875
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/ABCOlistToArray.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOlistToArray.java
+ * -@TestCaseName: index from Integer.parseInt, Array from list.toArray
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array, Array from list.toArray
+ * -#step2: index from Integer.parseInt
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOlistToArray.java
+ * -@ExecuteClass: ABCOlistToArray
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ABCOlistToArray {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        String[] a = func();
+        int x = -1;
+        try {
+            String c = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        x = Integer.parseInt(a[a.length - 1]);
+        try {
+            String c = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+
+    public static String[] func() {
+        List<String> list = new ArrayList<>();
+        list.add("1");
+        list.add("2");
+        list.add("3");
+        list.add("4");
+        list.add("5");
+        String[] arr = new String[list.size()];
+        try {
+            list.toArray(arr);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return arr;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/ABCOlocalArray.java b/test/testsuite/ouroboros/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/ABCOlocalArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..50f8571fb26c00bc5eb8a16362d6dda23bbbc4c8
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/ABCOlocalArray.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOlocalArray.java
+ * -@TestCaseName: new Array[5] in local variable
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5] in local variable
+ * -#step2: while visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOlocalArray.java
+ * -@ExecuteClass: ABCOlocalArray
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOlocalArray {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[][] arr = {{1, 2, 3}, {4, 5}, {6, 7, 8, 9}, {0}};
+
+        int y = arr.length - 1;
+        try {
+            int c = arr[-1][y];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            int c = arr[y][1];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/ABCOlocalIndex.java b/test/testsuite/ouroboros/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/ABCOlocalIndex.java
new file mode 100644
index 0000000000000000000000000000000000000000..86eed098f10a474777e66217a8dd07ffd2f3daf0
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/ABCOlocalIndex.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOlocalIndex.java
+ * -@TestCaseName: Index in local variable
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5] and index in local variable
+ * -#step2: while visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOlocalIndex.java
+ * -@ExecuteClass: ABCOlocalIndex
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOlocalIndex {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[][] arr = {{1, 2, 3}, {4, 5}, {6, 7, 8, 9}, {0}};
+
+        int y = func();
+        try {
+            int c = arr[0][y];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            int c = arr[y][0];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+
+    public static int func() {
+        int getRand = 0;
+        for (int i = 0; i < 100; i++) {
+            getRand = getRand + i;
+            if (getRand > 100) {
+                break;
+            }
+        }
+        getRand = getRand + 4;
+        return getRand;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/ABCOnewArraySize.java b/test/testsuite/ouroboros/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/ABCOnewArraySize.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c6e589d937cf708208831e4d8c1934b9c6122a3
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/ABCOnewArraySize.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOnewArraySize.java
+ * -@TestCaseName: index is X, X is Array[size]
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: visit index of new Array[size]
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOnewArraySize.java
+ * -@ExecuteClass: ABCOnewArraySize
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOnewArraySize {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] d = {0, 1, -1, 5};
+        try {
+            int b = d[2];
+            int c = a[b];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            int b = d[3];
+            int c = a[b];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/ABCOnormal.java b/test/testsuite/ouroboros/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/ABCOnormal.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a0b2facf1998991fdfef65181ee4bb569c0a762
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/ABCOnormal.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOnormal.java
+ * -@TestCaseName: index is constant
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: visit index of const
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOnormal.java
+ * -@ExecuteClass: ABCOnormal
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOnormal {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        try {
+            int c = a[-1];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            int c = a[6];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/ABCOparamIndex.java b/test/testsuite/ouroboros/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/ABCOparamIndex.java
new file mode 100644
index 0000000000000000000000000000000000000000..62213ab277d92822c5bb1dad8f79df925234b571
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/ABCOparamIndex.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOparamIndex.java
+ * -@TestCaseName: Array is get by function param
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5], Array is get by function param
+ * -#step2: if visit Array
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOparamIndex.java
+ * -@ExecuteClass: ABCOparamIndex
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOparamIndex {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            int[] a = new int[5];
+            int[] c = a;
+            for (int i = 0; i < a.length; i++) {
+                c[i] = i + 1;
+            }
+            int y = c[4];
+            result = test1(a, y);
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1(int[] arr, int index) {
+        int res = 3 /*STATUS_FAILED*/;
+
+        try {
+            if (index >= 0) {
+                int c = arr[index];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/ABCOparam.java b/test/testsuite/ouroboros/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/ABCOparam.java
new file mode 100644
index 0000000000000000000000000000000000000000..b852d5aac76ec8841870e90a5882d9a043886a7e
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/ABCOparam.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOparam.java
+ * -@TestCaseName: Array is get by function param
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5], Array is get by function param
+ * -#step2: if visit Array
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOparam.java
+ * -@ExecuteClass: ABCOparam
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOparam {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            int[] arr = new int[5];
+            result = test1(arr);
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1(int[] arr) {
+        int res = 3 /*STATUS_FAILED*/;
+
+        int y = arr.length;
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/ABCOreflectArray.java b/test/testsuite/ouroboros/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/ABCOreflectArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fa83588020cd89afaaf0eeedeefdbde188a610d
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/ABCOreflectArray.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOreflectArray.java
+ * -@TestCaseName: index is from Array.get
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: index is from Array.get, call Array.get and Array.set
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOreflectArray.java
+ * -@ExecuteClass: ABCOreflectArray
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Array;
+
+public class ABCOreflectArray {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        Array.setInt(a, 4, 5);
+        int x = (int) Array.get(a, 4);
+        try {
+            int c = (int) Array.get(a, x);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            Array.setInt(a, x, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/ABCOreturnArray.java b/test/testsuite/ouroboros/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/ABCOreturnArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f2380a40825ae0985068c5ce6f3a5cbeb1ea885
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/ABCOreturnArray.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOreturnArray.java
+ * -@TestCaseName: Array is get by function return
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5], Array is get by function return
+ * -#step2: if visit Array
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOreturnArray.java
+ * -@ExecuteClass: ABCOreturnArray
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOreturnArray {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int[] func() {
+        int[] arr = new int[5];
+        return arr;
+    }
+
+    public static int test1() {
+        int[] arr = func();
+        int res = 3 /*STATUS_FAILED*/;
+
+        int y = arr.length;
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/ABCOreturnIndex.java b/test/testsuite/ouroboros/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/ABCOreturnIndex.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1cff2acc91462824e060b98cd2d43f363d64f7a
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/ABCOreturnIndex.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOreturnIndex.java
+ * -@TestCaseName: Array is get by function return, Index is get by function return
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5], Array is get by function return, Index is get by function return
+ * -#step2: if visit Array
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOreturnIndex.java
+ * -@ExecuteClass: ABCOreturnIndex
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOreturnIndex {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int func() {
+        int getRand = 0;
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                for (int k = 0; k < 10; k++) {
+                    getRand = getRand + k;
+                    if (getRand > 200) {
+                        break;
+                    }
+                }
+            }
+        }
+        return getRand;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+
+        int[] arr = new int[100];
+        int[] arrCopy = arr;
+        for (int i = 0; i < arr.length; i++) {
+            arrCopy[i] = i;
+        }
+
+        int y = func();
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/ABCOreturnString.java b/test/testsuite/ouroboros/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/ABCOreturnString.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d7881606f15582e269241ed6fb43bbae123ceb2
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/ABCOreturnString.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOreturnString.java
+ * -@TestCaseName: Array is get by function return, Index is get by function return
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new String, String and index is get by function return value
+ * -#step2: if visit String, index >= length
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOreturnString.java
+ * -@ExecuteClass: ABCOreturnString
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+public class ABCOreturnString {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+
+        String joinLine = funx();
+        int y = func();
+        try {
+            if (y >= 0) {
+                char c = joinLine.charAt(y);
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int func() {
+        int getRand = 0;
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                for (int k = 0; k < 10; k++) {
+                    getRand = getRand + k;
+                    if (getRand > 300) {
+                        break;
+                    }
+                }
+            }
+        }
+        return getRand;
+    }
+
+    public static String funx() {
+        char[] a = new char[100];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+        return joinLine;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/ABCOStringBuilderCatchEx.java b/test/testsuite/ouroboros/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/ABCOStringBuilderCatchEx.java
new file mode 100644
index 0000000000000000000000000000000000000000..a20aa6b8d0ed0a94a259775c202073d6c3fc94de
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/ABCOStringBuilderCatchEx.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOStringBuilderCatchEx.java
+ * -@TestCaseName: StringIndexOutOfBoundsException is throw by StringBuilder toString
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new StringBuilder().
+ * -#step2: call StringBuilder.toString().substring(), StringIndexOutOfBoundsException is throw
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOStringBuilderCatchEx.java
+ * -@ExecuteClass: ABCOStringBuilderCatchEx
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ABCOStringBuilderCatchEx {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        try {
+            func();
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        } catch (Exception e) {
+            res = res + 2;
+        }
+        return res;
+    }
+
+    public static void func() throws Exception {
+        StringBuilder sbu = new StringBuilder();
+        List<String> lii = new ArrayList<>();
+        lii.add("welcome");
+        lii.add("to");
+        lii.add("hang");
+        lii.add("zhou");
+        lii.add("huawei");
+        lii.add("company");
+        for (String str : lii) {
+            sbu.append(str).append(",");
+        }
+        int endIndex = (sbu.toString()).length() + 1;
+        String getStr = sbu.toString().substring(0, endIndex);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/ABCOStringConstOperation.java b/test/testsuite/ouroboros/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/ABCOStringConstOperation.java
new file mode 100644
index 0000000000000000000000000000000000000000..4aebaddbf665b48ddd655ea7dd94f36b3ff04b81
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/ABCOStringConstOperation.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOStringConstOperation.java
+ * -@TestCaseName: index is X,  X = Y +/-/X///&/|/ Const
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new char[1024], change char[] to String.
+ * -#step2: visit index is X,  X = Y +/-/X///&/|/ Const, X is large than length
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOStringConstOperation.java
+ * -@ExecuteClass: ABCOStringConstOperation
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+public class ABCOStringConstOperation {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 10 /*STATUS_FAILED*/;
+        byte[] a = new byte[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = '1';
+        }
+        String joinLine = Arrays.toString(a);
+
+        int index = 1;
+        int y = joinLine.length();
+        try {
+            index = index + y + 9;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = y - joinLine.length() - index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = y * y * index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = index + 167772161;
+            index = (y / index) * y;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = index & index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = y | index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = ~index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = y + y;
+            index = index ^ y;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            index = index + index;
+            y = 8195;
+            index = index % y;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/ABCOstringDoWhile.java b/test/testsuite/ouroboros/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/ABCOstringDoWhile.java
new file mode 100644
index 0000000000000000000000000000000000000000..5706e77b127b87d147c22851fbf7555a6daf3004
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/ABCOstringDoWhile.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOstringDoWhile.java
+ * -@TestCaseName: do while visit String element and index from do while
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: String a is copy of String b
+ * -#step2: do while visit String element and index from do while
+ * -#step3: when index is large than length, catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOstringDoWhile.java
+ * -@ExecuteClass: ABCOstringDoWhile
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOstringDoWhile {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        String aCp = new String();
+        int x = 0;
+        do {
+            aCp = aCp + "hashl@^&@&2894684";
+            x++;
+        } while (x <= 9999);
+        String a = aCp;
+
+        x = funx(1000);
+        int y = funx(170000);
+        try {
+            do {
+                char c = a.charAt(x);
+                x++;
+            } while (x <= y);
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index = 0;
+        do {
+            index = funy(index);
+        } while (index < endIndex);
+        return index;
+    }
+
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/ABCOstringFor.java b/test/testsuite/ouroboros/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/ABCOstringFor.java
new file mode 100644
index 0000000000000000000000000000000000000000..ceed551db142dba7d77d44cec197daf1807d5d73
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/ABCOstringFor.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOstringFor.java
+ * -@TestCaseName: for visit String.charAt[index], index visit 0 to length.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: for visit String element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOstringFor.java
+ * -@ExecuteClass: ABCOstringFor
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+public class ABCOstringFor {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+
+        char[] b = new char[joinLine.length()];
+        try {
+            for (int i = 0; i <= joinLine.length(); i++) {
+                int index = funx(i);
+                b[index] = joinLine.charAt(index);
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index;
+
+        for (index = 0; index <= endIndex; index++) {
+            index = funy(index);
+        }
+
+        return index;
+    }
+
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/ABCOstringIf.java b/test/testsuite/ouroboros/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/ABCOstringIf.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2e4aae65ae848cac8d80696fc22b1e7038867df
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/ABCOstringIf.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOstringIf.java
+ * -@TestCaseName: if visit String
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new String
+ * -#step2: if visit String, index = String.length()
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOstringIf.java
+ * -@ExecuteClass: ABCOstringIf
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.Random;
+
+public class ABCOstringIf {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        int result2 = 4;
+        try {
+            result = test1();
+            result2 = test2();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && result2 == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+
+        int y = func();
+        try {
+            if (y >= 0) {
+                char c = joinLine.charAt(y);
+                ;
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int test2() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+
+        try {
+            for (int i = 0; i < joinLine.length(); i++) {
+                if (joinLine.charAt(i) == joinLine.charAt(i + 1)) {
+                    char c = joinLine.charAt(i);
+                }
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int func() {
+        Random r = new Random();
+        int get = r.nextInt(6);
+        if (get >= 5) {
+            return get + 3072;
+        } else {
+            return get + 3072;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/ABCOstringIndexNesting.java b/test/testsuite/ouroboros/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/ABCOstringIndexNesting.java
new file mode 100644
index 0000000000000000000000000000000000000000..5477a68b4e1203496f2e449cb442935a32cee75c
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/ABCOstringIndexNesting.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOstringIndexNesting.java
+ * -@TestCaseName: give nesting fun to String index
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new char[1024], change char[] to String
+ * -#step2: for visit index, nestint func, funx, funy，funw to give value to index
+ * -#step3: let char c = joinLine.charAt(index), when index > a.length, will catch ArrayIndexOutOfBoundsException
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOstringIndexNesting.java
+ * -@ExecuteClass: ABCOstringIndexNesting
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+public class ABCOstringIndexNesting {
+    static int RES_PROCESS = 99;
+    static int arrNum = 1023;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'w';
+        }
+        String joinLine = Arrays.toString(a);
+
+        int index = 0;
+        try {
+            for (int j = 1; j <= joinLine.length(); j++) {
+                if (j == joinLine.length()) {
+                    index = func(j, index);
+                    char c = joinLine.charAt(index);
+                }
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+
+    public static int func(int index, int getIndex) {
+        getIndex = funx(getIndex, index);
+        getIndex = getIndex + 10;
+        if (getIndex < index) {
+            getIndex = func(index, getIndex);
+        }
+        return getIndex;
+    }
+
+    public static int funx(int getIndex, int index) {
+        getIndex = getIndex + index;
+        getIndex = funy(getIndex, index);
+        return getIndex;
+    }
+
+    public static int funy(int getIndex, int index) {
+        getIndex = getIndex * index;
+        getIndex = funz(getIndex, index);
+        return getIndex;
+    }
+
+    public static int funz(int getIndex, int index) {
+        getIndex = getIndex / index;
+        getIndex = funw(getIndex, index);
+        return getIndex;
+    }
+
+    public static int funw(int getIndex, int index) {
+        getIndex = getIndex - index;
+        return getIndex;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/ABCOStringMaxValue.java b/test/testsuite/ouroboros/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/ABCOStringMaxValue.java
new file mode 100644
index 0000000000000000000000000000000000000000..81c1e378d5f5c35dac49f21276bdb2f75c0adc37
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/ABCOStringMaxValue.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOStringMaxValue.java
+ * -@TestCaseName: index is MAX_VALUE or MIN_VALUE
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new char[1024], change char[] to String.
+ * -#step2: visit index of MAX_VALUE or MIN_VALUE const, use codePointCount
+ * -#step3: catch Exception IndexOutOfBoundsException
+ * -#step4: visit index of MAX_VALUE or MIN_VALUE const, use charAt
+ * -#step5: catch Exception StringIndexOutOfBoundsException
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOStringMaxValue.java
+ * -@ExecuteClass: ABCOStringMaxValue
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+public class ABCOStringMaxValue {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 5 /*STATUS_FAILED*/;
+
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+
+        int max = Integer.MAX_VALUE;
+        int min = Integer.MIN_VALUE;
+        try {
+            int c = joinLine.codePointCount(min, 2);
+        } catch (IndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            char c = joinLine.charAt(min);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            int c = joinLine.codePointCount(0, max);
+        } catch (IndexOutOfBoundsException e) {
+            res--;
+        }
+
+        try {
+            char c = joinLine.charAt(max);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/ABCOstringMutiLoop.java b/test/testsuite/ouroboros/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/ABCOstringMutiLoop.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d07339813283637679449ae83b1462babc42dc9
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/ABCOstringMutiLoop.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOstringMutiLoop.java
+ * -@TestCaseName: index from multi-layer loop
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new String[8000]
+ * -#step2: visit index of multi-layer loop
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOstringMutiLoop.java
+ * -@ExecuteClass: ABCOstringMutiLoop
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+public class ABCOstringMutiLoop {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+
+        char[] a = new char[8000];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+
+        int x;
+        try {
+            x = func();
+            char c = joinLine.charAt(x);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        return res;
+    }
+
+    public static int func() {
+        int index = 0;
+        for (int i = 0; i < 5; i++) {
+            for (int j = 0; j < 5; j++) {
+                for (int k = 0; k < 5; k++) {
+                    for (int ii = 0; ii < 5; ii++) {
+                        for (int jj = 0; jj < 5; jj++) {
+                            for (int kk = 0; kk < 5; kk++) {
+                                for (int iii = 0; iii < 5; iii++) {
+                                    for (int jjj = 0; jjj < 5; jjj++) {
+                                        for (int kkk = 0; kkk < 5; kkk++) {
+                                            for (int n = 0; n < 5; n++) {
+                                                index = index + n;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return index;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/ABCOstringSwitch.java b/test/testsuite/ouroboros/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/ABCOstringSwitch.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9c36b534c1a8ce9be9634e6bac499eed9fb7733
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/ABCOstringSwitch.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOstringSwitch.java
+ * -@TestCaseName: switch visit Array element
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: switch visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOstringSwitch.java
+ * -@ExecuteClass: ABCOstringSwitch
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.Random;
+
+public class ABCOstringSwitch {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[3000];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+
+        char c;
+        int x = func();
+        int y = x % 2;
+        try {
+            switch (y) {
+                case 0:
+                    c = joinLine.charAt(x);
+                    break;
+                default:
+                    c = joinLine.charAt(x);
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int func() {
+        Random r = new Random();
+        int getI = r.nextInt(3);
+        int y = getI % 3;
+        getI = getI + 9000;
+        switch (y) {
+            case 0:
+                getI = getI + 0;
+                break;
+            case 1:
+                getI = getI + 1;
+                break;
+            default:
+                getI = getI + 2;
+        }
+        return getI;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/ABCOswitch.java b/test/testsuite/ouroboros/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/ABCOswitch.java
new file mode 100644
index 0000000000000000000000000000000000000000..6157f005f2d0d64dd1fe76d651bef58a77546707
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/ABCOswitch.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOswitch.java
+ * -@TestCaseName: switch visit Array element
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: switch visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOswitch.java
+ * -@ExecuteClass: ABCOswitch
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Random;
+
+public class ABCOswitch {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int c;
+        Random r = new Random();
+        int x = r.nextInt(2);
+        int y = x % 2;
+        x = x + 5;
+        try {
+            switch (y) {
+                case 0:
+                    c = a[x];
+                    break;
+                default:
+                    c = a[x];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/ABCOtryExtEh.java b/test/testsuite/ouroboros/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/ABCOtryExtEh.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1b48c22228d993209c5b978e126fd5e81ee5345
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/ABCOtryExtEh.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOtryExtEh.java
+ * -@TestCaseName: ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: visit index of const, try catch ArrayIndexOutOfBoundsException and IndexOutOfBoundsException
+ * -#step3: catch ArrayIndexOutOfBoundsException
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOtryExtEh.java
+ * -@ExecuteClass: ABCOtryExtEh
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOtryExtEh {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        try {
+            int c = a[-1];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        } catch (IndexOutOfBoundsException e) {
+            res++;
+        }
+
+        try {
+            int c = a[6];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        } catch (IndexOutOfBoundsException e) {
+            res++;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/ABCOmaxValue.java b/test/testsuite/ouroboros/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/ABCOmaxValue.java
new file mode 100644
index 0000000000000000000000000000000000000000..863cb93f3876288b03e3de423ed92082a6483dc6
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/ABCOmaxValue.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOmaxValue.java
+ * -@TestCaseName: index is MAX_VALUE or MIN_VALUE
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: visit index of MAX_VALUE or MIN_VALUE const
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOmaxValue.java
+ * -@ExecuteClass: ABCOmaxValue
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOmaxValue {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int max = Integer.MAX_VALUE;
+        int min = Integer.MIN_VALUE;
+        try {
+            int c = a[min];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            int c = a[max];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/ABCOwhile.java b/test/testsuite/ouroboros/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/ABCOwhile.java
new file mode 100644
index 0000000000000000000000000000000000000000..0589b207f0cbc16fbb411f0d23a6a868aeb9233d
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/ABCOwhile.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOwhile.java
+ * -@TestCaseName: while visit Array element
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: while visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOwhile.java
+ * -@ExecuteClass: ABCOwhile
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ABCOwhile {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] c = new int[a.length];
+        int x = 0;
+        int y = a.length;
+        try {
+            while (x <= y) {
+                c[x] = a[x];
+                x++;
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/ABCOwhileString.java b/test/testsuite/ouroboros/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/ABCOwhileString.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7038624bd0c2273c0f30c3adfdfe46892cad554
--- /dev/null
+++ b/test/testsuite/ouroboros/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/ABCOwhileString.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_ArrayBoundary_ABCOwhileString.java
+ * -@TestCaseName: while visit Array element
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Array Bounds Check优化
+ * -@Brief:
+ * -#step1: new Array[5]
+ * -#step2: while visit Array element
+ * -#step3: catch Exception
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ABCOwhileString.java
+ * -@ExecuteClass: ABCOwhileString
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Arrays;
+
+public class ABCOwhileString {
+    static int RES_PROCESS = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+
+        char[] a = new char[100];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+
+        char[] c = new char[joinLine.length()];
+        int x = funx(1000);
+        int y = funx(170000);
+        try {
+            while (x <= y) {
+                c[x] = joinLine.charAt(y);
+                ;
+                x++;
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+
+        return res;
+    }
+
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index = 0;
+        while (index < endIndex) {
+            index = funy(index);
+        }
+        return index;
+    }
+
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0001-rt-clinit-clinit_base_001/ClinitBase001.java b/test/testsuite/ouroboros/clinit_test/RT0001-rt-clinit-clinit_base_001/ClinitBase001.java
new file mode 100644
index 0000000000000000000000000000000000000000..afc979c2acd1623f522a3b6f5b8f9a1b4e3452cf
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0001-rt-clinit-clinit_base_001/ClinitBase001.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitBase001
+ * -@TestCaseName: ClinitBase001.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 首次创建实例，触发类初始化
+ * -@Brief: 首次各种实例，确认其触发初始化操作的正确性
+ *  -#step1: 创建内部静态类实例，触发内部静态类初始化，不触发外部类的初始化
+ *  -#step2: 创建外部类实例，触发外部类初始化，不触发内部类的初始化
+ *  -#step3: 创建内部静态类的实例，触发内部静态类初始化，不触发它内部类的初始化
+ *  -#step4: new数组实例，不触发对应类的初始化
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitBase001.java
+ * -@ExecuteClass: ClinitBase001
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+class TopLevelClass1 {
+    static int field;
+
+    static {
+        if (ClinitBase001.getCount() == 3) {
+            field = ClinitBase001.getCount();
+        }
+    }
+
+    int getField() {
+        return field;
+    }
+
+    static class StaticClass {
+        static int field;
+
+        static {
+            if (ClinitBase001.getCount() == 5) {
+                field = ClinitBase001.getCount();
+            }
+        }
+
+        int getField() {
+            return field;
+        }
+
+        static class StaticNestClass {
+            static int field;
+
+            static {
+                if (ClinitBase001.getCount() == 7) {
+                    field = ClinitBase001.getCount();
+                }
+            }
+
+            int getField() {
+                return field;
+            }
+
+            static class StaticInnerClass {
+                static int field;
+
+                static {
+                    if (ClinitBase001.getCount() == 1) {
+                        field = ClinitBase001.getCount();
+                    }
+                }
+
+                int getField() {
+                    return field;
+                }
+            }
+        }
+    }
+}
+
+public class ClinitBase001 {
+    static private int count = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0/*STATUS_PASSED*/;
+
+        // 创建内部静态类实例，触发内部静态类初始化，不触发外部类的初始化
+        TopLevelClass1.StaticClass.StaticNestClass.StaticInnerClass case4 =
+                new TopLevelClass1.StaticClass.StaticNestClass.StaticInnerClass();
+
+        // 创建外部类实例，触发外部类初始化，不触发内部类的初始化
+        TopLevelClass1 case1 = new TopLevelClass1();
+
+        // 创建内部静态类的实例，触发内部静态类初始化，不触发它内部类的初始化
+        TopLevelClass1.StaticClass case2 = new TopLevelClass1.StaticClass();
+        TopLevelClass1.StaticClass.StaticNestClass case3 =
+                new TopLevelClass1.StaticClass.StaticNestClass();
+
+
+        if (case1.getField() != 4) {
+            out.println("Error: TopLevelClass1 initialized Failed");
+            res = 2;
+        }
+        if (case2.getField() != 6) {
+            out.println("Error: TopLevelClass1.StaticClass initialized Failed");
+            res = 2;
+        }
+        if (case3.getField() != 8) {
+            out.println("Error: TopLevelClass1.StaticClass.StaticNestClass initialized Failed");
+            res = 2;
+        }
+        if (case4.getField() != 2) {
+            out.println("Error: TopLevelClass1.StaticClass.StaticNestClass initialized Failed");
+            res = 2;
+        }
+
+        //  new数组不触发对应类的初始化
+        TopLevelClass1[] array = new TopLevelClass1[4];
+        if (array.length != 4) {
+            res = 2;
+        }
+
+        if (count != 8) {
+            out.println("Error: class initialized should not be invoked twice");
+            res = 2;
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0002-rt-clinit-clinit_base_002/ClinitBase002.java b/test/testsuite/ouroboros/clinit_test/RT0002-rt-clinit-clinit_base_002/ClinitBase002.java
new file mode 100644
index 0000000000000000000000000000000000000000..6621f24179ccbb4ffa87150c27a39caebb7884ef
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0002-rt-clinit-clinit_base_002/ClinitBase002.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitBase002
+ * -@TestCaseName: ClinitBase002.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 首次调用类的静态方法，触发类初始化
+ * -@Brief: 首次调用类的静态方法，触发类初始化
+ *  -#step1: 创建继承内部静态类的局部类
+ *  -#step2: 访问局部类的静态方法，触发父类初始化
+ *  -#step3: 创建继承外部类的局部类
+ *  -#step4: 访问局部类的静态方法，触发父类初始化
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitBase002.java
+ * -@ExecuteClass: ClinitBase002
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+abstract class CaseClass {
+    static float field;
+
+    static {
+        if (ClinitBase002.getCount() == 3) {
+            field = ClinitBase002.getCount();
+        }
+    }
+
+    static float getField() {
+        return (float) (field * 1.2);
+    }
+
+    public abstract int uselessFunction();
+
+    static class StaticClass {
+        static float field;
+
+        static {
+            if (ClinitBase002.getCount() == 1) {
+                field = ClinitBase002.getCount();
+            }
+        }
+
+        static float getField() {
+            return (float) (field * 1.2);
+        }
+    }
+}
+
+public class ClinitBase002 {
+    static private float count = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    static float getCount() {
+        count += 1.0f;
+        return count;
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+
+        // 创建继承内部静态类的局部类
+        class AnonymousClass extends CaseClass.StaticClass {
+        }
+        // 访问局部类的静态方法，触发父类初始化
+        if (AnonymousClass.getField() != 2.4f) {
+            res = 2;
+            out.println("Error: CaseClass.StaticClass not initialized");
+        }
+
+        // 创建继承外部类的局部类
+        class ClassChild extends CaseClass {
+            public int uselessFunction() {
+                return 0;
+            }
+        }
+        // 访问局部类的静态方法，触发父类初始化
+        if (ClassChild.getField() != 4.8f) {
+            res = 2;
+            out.println("Error: CaseClass not initialized");
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0003-rt-clinit-clinit_base_003/ClinitBase003.java b/test/testsuite/ouroboros/clinit_test/RT0003-rt-clinit-clinit_base_003/ClinitBase003.java
new file mode 100644
index 0000000000000000000000000000000000000000..dccda426176e1ff80d41632ca85c5d9828d9a484
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0003-rt-clinit-clinit_base_003/ClinitBase003.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitBase003
+ * -@TestCaseName: ClinitBase003.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 首次为类的静态字段赋值，触发类初始化
+ * -@Brief: 首次为类的静态字段赋值，触发类初始化
+ *  -#step1: 对局部类的内部类的静态字段赋值，触发此类的初始化
+ *  -#step2: 对局部类的静态字段赋值，触发此类的初始化
+ *  -#step3:
+ *  -#step4:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitBase003.java
+ * -@ExecuteClass: ClinitBase003
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+class CaseClass {
+    static float field;
+
+    static {
+        if (ClinitBase003.getCount() == 3) {
+            field = ClinitBase003.getCount();
+        }
+    }
+
+    public static class StaticClass {
+        public static float field;
+
+        static {
+            if (ClinitBase003.getCount() == 1) {
+                field = ClinitBase003.getCount();
+            }
+        }
+    }
+}
+
+public class ClinitBase003 {
+    static private float count = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    static float getCount() {
+        count += 1.0f;
+        return count;
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+
+        class CaseChild extends CaseClass {
+            class CaseStaticChild extends StaticClass {
+            }
+        }
+        // 对局部类的内部类的静态字段赋值，触发此类的初始化
+        CaseChild.CaseStaticChild.field = 20.0f;
+        // 对局部类的静态字段赋值，触发此类的初始化
+        CaseChild.field = 10.0f;
+
+        if (CaseClass.field != 10.0f) {
+            res = 2;
+            out.println("Error: CaseClass not initialized");
+        }
+
+        if (CaseClass.StaticClass.field != 20.0f) {
+            out.println(CaseClass.StaticClass.field);
+            res = 2;
+            out.println("Error: CaseClass.StaticClass not initialized");
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0004-rt-clinit-clinit_base_004/ClinitBase004.java b/test/testsuite/ouroboros/clinit_test/RT0004-rt-clinit-clinit_base_004/ClinitBase004.java
new file mode 100644
index 0000000000000000000000000000000000000000..39165daf6adcaee95a05b42bcd31c30018f33e83
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0004-rt-clinit-clinit_base_004/ClinitBase004.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitBase004
+ * -@TestCaseName: ClinitBase004.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 首次为使用类的静态字段，触发类初始化
+ * -@Brief: 首次为使用类的静态字段，触发类初始化
+ *  -#step1: 访问静态常量不应该触发类初始化
+ *  -#step2: 访问静态变量应该触发类初始化
+ *  -#step3:
+ *  -#step4:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitBase004.java
+ * -@ExecuteClass: ClinitBase004
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+class Other {
+
+}
+
+class CaseClass {
+    static final float FIELD1 = ClinitBase004.getCount1();
+    static final String FIELD2 = ClinitBase004.getCount2();
+    static Other field3;
+
+    static {
+        if (ClinitBase004.count == 12) {
+            field3 = ClinitBase004.getCount3();
+        }
+    }
+}
+
+public class ClinitBase004 {
+
+    public static int count;
+
+    static {
+        count = 10;
+    }
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    static float getCount1() {
+        count += 1;
+        return (float) count;
+    }
+
+    static String getCount2() {
+        count += 1;
+        return String.valueOf(count);
+    }
+
+    static Other getCount3() {
+        count += 1;
+        return new Other();
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+
+        // 访问静态常量不应该触发类初始化
+        if (CaseClass.FIELD1 != 11.0f) {
+            res = 2;
+            out.println("Error1: CaseClass should not be initialized");
+        }
+        count++;
+        if (!CaseClass.FIELD2.equals("12")) {
+            res = 2;
+            out.println("Error2: CaseClass should not be initialized");
+        }
+        count++;
+        // 访问静态变量触发类初始化
+        if (CaseClass.field3 == null || count != 15) {
+            res = 2;
+            out.println("Error3: CaseClass not initialized");
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0005-rt-clinit-clinit_base_005/ClinitBase005.java b/test/testsuite/ouroboros/clinit_test/RT0005-rt-clinit-clinit_base_005/ClinitBase005.java
new file mode 100644
index 0000000000000000000000000000000000000000..899a58340e51a6e2e5f516d44c961f414c5dee57
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0005-rt-clinit-clinit_base_005/ClinitBase005.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitBase005
+ * -@TestCaseName: ClinitBase005.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 首次为使用接口的静态字段，触发类初始化
+ * -@Brief: 首次为使用接口的静态字段，触发类初始化
+ *  -#step1: 使用primitive类型或string的静态常量不触发接口初始化
+ *  -#step2: 使用object类型的静态常量触发接口初始化
+ *  -#step3:
+ *  -#step4:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitBase005.java
+ * -@ExecuteClass: ClinitBase005
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+interface CaseInterface {
+    float FIELD1 = ClinitBase005.getCount1();
+    String FIELD2 = ClinitBase005.getCount2();
+    OtherCase FIELD3 = (ClinitBase005.count == 12) ? ClinitBase005.getCount3() : null;
+}
+
+class OtherCase {
+
+}
+
+class CaseClass implements CaseInterface {
+
+}
+
+public class ClinitBase005 {
+
+    public static int count;
+
+    static {
+        count = 10;
+    }
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    static float getCount1() {
+        count += 1;
+        return (float) count;
+    }
+
+    static String getCount2() {
+        count += 1;
+        return String.valueOf(count);
+    }
+
+    static OtherCase getCount3() {
+        count += 1;
+        return new OtherCase();
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+
+        if (CaseClass.FIELD1 != 11.0f) {
+            res = 2;
+            out.println("Error1: interface should not be initialized");
+        }
+        count++;
+        if (!CaseClass.FIELD2.equals("12")) {
+            res = 2;
+            out.println("Error2: interface should not be initialized");
+        }
+        count++;
+        if (CaseClass.FIELD3 == null || count != 15) {
+            res = 2;
+            out.println("Error3: interface not initialized");
+        }
+
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0006-rt-clinit-clinit_base_006/ClinitBase006.java b/test/testsuite/ouroboros/clinit_test/RT0006-rt-clinit-clinit_base_006/ClinitBase006.java
new file mode 100644
index 0000000000000000000000000000000000000000..50a7fc41449ded18178db2c43c32d595f54596d5
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0006-rt-clinit-clinit_base_006/ClinitBase006.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitBase006
+ * -@TestCaseName: ClinitBase006.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 首次为使用反射方式访问类的方法、字段、构造器，触发类初始化
+ * -@Brief: 首次为使用反射方式访问类的方法、字段、构造器，触发类初始化
+ *  -#step1: 调用forName不触发类初始化
+ *  -#step2: 调用getDeclaredField触发类初始化
+ *  -#step3: 调用newInstance触发类初始化
+ *  -#step4:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitBase006.java
+ * -@ExecuteClass: ClinitBase006
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+class CaseForName1 {
+    static int field;
+
+    static {
+        if (ClinitBase006.getCount() == 1) {
+            field = ClinitBase006.getCount();
+        }
+    }
+}
+
+class CaseForName2 {
+    static int field;
+
+    static {
+        if (ClinitBase006.getCount() == 3) {
+            field = ClinitBase006.getCount();
+        }
+    }
+}
+
+class CaseForName3 {
+    static int field;
+
+    static {
+        if (ClinitBase006.getCount() == 5) {
+            field = ClinitBase006.getCount();
+        }
+    }
+}
+
+class CaseClassInstance {
+    static int field;
+
+    static {
+        if (ClinitBase006.getCount() == 7) {
+            field = ClinitBase006.getCount();
+        }
+    }
+}
+
+class CaseClassMethod {
+    static int field;
+
+    static {
+        if (ClinitBase006.getCount() == 5) {
+            field = ClinitBase006.getCount();
+        }
+        System.out.println("hello");
+    }
+
+    static int getField() {
+        return field;
+    }
+}
+
+public class ClinitBase006 {
+
+    public static int count;
+
+    public static void main(String[] argv) {
+        ClinitBase006 test = new ClinitBase006();
+        System.out.println(test.run(argv, System.out)/*STATUS_TEMP*/);
+    }
+
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+
+    private int run(String[] argv, PrintStream out) {
+        int res = 0;
+
+        try {
+            Class forName1 = Class.forName("CaseForName1");
+            if (count != 2 || forName1.getDeclaredField("field").getInt(null) != 2) {
+                res = 2;
+                out.println("Error, CaseForName1 not initialized");
+            }
+
+            Class forName2 = Class.forName("CaseForName2", true, this.getClass().getClassLoader());
+            if (count != 4 || forName2.getDeclaredField("field").getInt(null) != 4) {
+                res = 2;
+                out.println("Error, CaseForName2 not initialized");
+            }
+
+            Class forName3 = Class.forName("CaseForName3", false, this.getClass().getClassLoader());
+            if (count != 4 || forName3.getDeclaredField("field").getInt(null) != 6) {
+                res = 2;
+                out.println("Error, CaseForName3 not initialized");
+            }
+
+            CaseClassInstance caseInstance = CaseClassInstance.class.newInstance();
+            if (count != 8 || CaseClassInstance.field != 8) {
+                res = 2;
+                out.println("Error, case6_instance not initialized");
+            }
+        } catch (Exception e) {
+            res = 2;
+            out.println(e);
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0008-rt-clinit-clinit_base_008/ClinitBase008.java b/test/testsuite/ouroboros/clinit_test/RT0008-rt-clinit-clinit_base_008/ClinitBase008.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb28c68a15a0d2b3edea05419cdc4c9b1126cce4
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0008-rt-clinit-clinit_base_008/ClinitBase008.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitBase008
+ * -@TestCaseName: ClinitBase008.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 针对"初始类"ClinitBase008，测试其能触发静态域的初始化
+ * -@Brief: 针对"初始类"ClinitBase008，测试其能触发静态域的初始化
+ *  -#step1: 针对"初始类"ClinitBase008，测试其能触发静态域的初始化
+ *  -#step2:
+ *  -#step3:
+ *  -#step4:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitBase008.java
+ * -@ExecuteClass: ClinitBase008
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ClinitBase008 {
+    static int res = 0;
+
+    static {
+        res = 1;
+    }
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        if (res == 1) {
+            return 0;
+        } else {
+            return 1;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0009-rt-clinit-clinit_seq_001/ClinitSeq001.java b/test/testsuite/ouroboros/clinit_test/RT0009-rt-clinit-clinit_seq_001/ClinitSeq001.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d4971e31cee4860144b62fdc0a5e78f04ffef5e
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0009-rt-clinit-clinit_seq_001/ClinitSeq001.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitSeq001
+ * -@TestCaseName: ClinitSeq001.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 触发子类初始化前优先触发未初始化的父类
+ * -@Brief: 触发子类初始化前优先触发未初始化的父类
+ *  -#step1: 访问子类字段
+ *  -#step2: 触发父类初始化
+ *  -#step3: 触发子类初始化
+ *  -#step4:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitSeq001.java
+ * -@ExecuteClass: ClinitSeq001
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+class FatherClass {
+    static int field;
+
+    static {
+        if (ClinitSeq001.getCount() == 1) {
+            field = ClinitSeq001.getCount();
+        }
+    }
+}
+
+class ChildClass extends FatherClass {
+    static int field;
+
+    static {
+        if (ClinitSeq001.getCount() == 3) {
+            field = ClinitSeq001.getCount();
+        }
+    }
+
+}
+
+public class ClinitSeq001 {
+
+    static private int count = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out) /*STATUS_TEMP*/);
+    }
+
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0/*STATUS_PASSED*/;
+
+        if (ChildClass.field != 4) {
+            res = 2;
+            out.println("Error, ChildClass not initialized");
+        }
+
+        if (FatherClass.field != 2) {
+            res = 2;
+            out.println("Error, FatherClass not initialized");
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0010-rt-clinit-clinit_seq_002/ClinitSeq002.java b/test/testsuite/ouroboros/clinit_test/RT0010-rt-clinit-clinit_seq_002/ClinitSeq002.java
new file mode 100644
index 0000000000000000000000000000000000000000..a21d4b06c4a099d94bae9847a0528cd8f3d0a443
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0010-rt-clinit-clinit_seq_002/ClinitSeq002.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitSeq002
+ * -@TestCaseName: ClinitSeq002.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 含有default方法的class将优先于子类被初始化
+ * -@Brief:
+ *  -#step1: 访问CaseChild触发interface初始化
+ *  -#step2: interface触发OtherClass初始化
+ *  -#step3: 最后触发CaseChild的初始化
+ *  -#step4:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitSeq002.java
+ * -@ExecuteClass: ClinitSeq002
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+interface CaseInterface {
+    int FIELD = ClinitSeq002.getCount();
+    CaseOtherClass MEMBER = new CaseOtherClass();
+
+    default int uselessFunction(int a, int b) {
+        return a + b;
+    }
+}
+
+class CaseOtherClass {
+    static int field;
+
+    static {
+        if (ClinitSeq002.getCount() == 2) {
+            field = ClinitSeq002.getCount();
+        }
+    }
+}
+
+class CaseChild implements CaseInterface {
+    static int field;
+
+    static {
+        if (ClinitSeq002.getCount() == 4) {
+            field = ClinitSeq002.getCount();
+        }
+    }
+}
+
+public class ClinitSeq002 {
+
+    static private int count = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out) /*STATUS_TEMP*/);
+    }
+
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+
+        // 访问child field触发类初始化
+        if (CaseChild.field != 5) {
+            res = 2;
+            out.println("Error, child not initialized");
+        }
+
+        // 访问CaseOtherClass field触发类初始化
+        if (CaseOtherClass.field != 3) {
+            res = 2;
+            out.println("Error, other not initialized");
+        }
+
+        // 访问interface常量，触发初始化
+        if (CaseInterface.FIELD != 1) {
+            res = 2;
+            out.println("Error, interface not initialized");
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0011-rt-clinit-clinit_seq_003/ClinitSeq003.java b/test/testsuite/ouroboros/clinit_test/RT0011-rt-clinit-clinit_seq_003/ClinitSeq003.java
new file mode 100644
index 0000000000000000000000000000000000000000..99b1fdd1d87f961cefa9ac8a84025222348b3486
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0011-rt-clinit-clinit_seq_003/ClinitSeq003.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitSeq003
+ * -@TestCaseName: ClinitSeq003.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 触发子类初始化前优先触发未初始化的包含default方法的超接口与继承的父类
+ * -@Brief: 触发子类初始化前优先触发未初始化的包含default方法的超接口与继承的父类
+ *  -#step1: 访问CaseChild触发父类初始化
+ *  -#step2: 接着触发接口初始化
+ *  -#step3: 再触发接口字段中对象的类的初始化
+ *  -#step4: 最后触发自己的初始化
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitSeq003.java
+ * -@ExecuteClass: ClinitSeq003
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+interface CaseInterface {
+    int FIELD = ClinitSeq003.getCount();
+    CaseOtherClass MEMBER = new CaseOtherClass();
+
+    default int uselessFunction(int a, int b) {
+        return a + b;
+    }
+}
+
+class CaseOtherClass {
+    static int field;
+
+    static {
+        if (ClinitSeq003.getCount() == 4) {
+            field = ClinitSeq003.getCount();
+        }
+    }
+}
+
+class CaseFather {
+    static int field;
+
+    static {
+        if (ClinitSeq003.getCount() == 1) {
+            field = ClinitSeq003.getCount();
+        }
+    }
+}
+
+class CaseChild extends CaseFather implements CaseInterface {
+    static int field;
+
+    static {
+        if (ClinitSeq003.getCount() == 6) {
+            field = ClinitSeq003.getCount();
+        }
+    }
+}
+
+public class ClinitSeq003 {
+
+    static private int count = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out) /*STATUS_TEMP*/);
+    }
+
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+
+        // 访问子类的字段
+        if (CaseChild.field != 7) {
+            res = 2;
+            out.println(CaseChild.field);
+            out.println("Error, child not initialized");
+        }
+
+        // 接口中的字段对应的类被触发初始化
+        if (CaseOtherClass.field != 5) {
+            res = 2;
+            out.println("Error, other not initialized");
+        }
+
+        // 包含有default方法的接口被触发初始化
+        if (CaseInterface.FIELD != 3) {
+            res = 2;
+            out.println("Error, interface not initialized");
+        }
+
+        // 父类被触发初始化
+        if (CaseFather.field != 2) {
+            res = 2;
+            out.println("Error, father not initialized");
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0012-rt-clinit-clinit_seq_004/ClinitSeq004.java b/test/testsuite/ouroboros/clinit_test/RT0012-rt-clinit-clinit_seq_004/ClinitSeq004.java
new file mode 100644
index 0000000000000000000000000000000000000000..f52b5d45e092b42deb2136ce4d9d31bdd80bf1fb
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0012-rt-clinit-clinit_seq_004/ClinitSeq004.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitSeq004
+ * -@TestCaseName: ClinitSeq004.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 触发子接口初始化前不触发未初始化的包含default方法的超接口
+ * -@Brief: 触发子接口初始化前不触发未初始化的包含default方法的超接口
+ *  -#step1: 访问子接口字段,触发子接口的初始化，不触发父接口的初始化
+ *  -#step2: 访问父接口字段，触发父接口初始化
+ *  -#step3: 触发父接口中对象类的初始化
+ *  -#step4:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitSeq004.java
+ * -@ExecuteClass: ClinitSeq004
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+interface CaseInterface {
+    int FIELD = ClinitSeq004.getCount();
+    CaseOtherClass MEMBER = new CaseOtherClass();
+
+    default int uselessFunction(int a, int b) {
+        return a + b;
+    }
+}
+
+interface CaseChild extends CaseInterface {
+    int FIELD_CHILD = ClinitSeq004.getCount();
+}
+
+class CaseOtherClass {
+    static int field;
+
+    static {
+        if (ClinitSeq004.getCount() == 3) {
+            field = ClinitSeq004.getCount();
+        }
+    }
+}
+
+public class ClinitSeq004 {
+
+    static private int count = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+
+        if (CaseChild.FIELD_CHILD != 1) {
+            res = 2;
+            out.println("Error, child not initialized");
+        }
+
+        if (CaseInterface.FIELD != 2) {
+            res = 2;
+            out.println("Error, interface not initialized");
+        }
+
+        if (CaseOtherClass.field != 4) {
+            res = 2;
+            out.println("Error, other not initialized");
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/clinit_test/RT0013-rt-clinit-clinit_seq_005/ClinitSeq005.java b/test/testsuite/ouroboros/clinit_test/RT0013-rt-clinit-clinit_seq_005/ClinitSeq005.java
new file mode 100644
index 0000000000000000000000000000000000000000..701564efe29818460f33f216659101b004bbaa7b
--- /dev/null
+++ b/test/testsuite/ouroboros/clinit_test/RT0013-rt-clinit-clinit_seq_005/ClinitSeq005.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClinitSeq005
+ * -@TestCaseName: ClinitSeq005.java
+ * -@RequirementName: Java class initialization
+ * -@Title/Destination: 触发子类初始化前不触发未初始化的不包含default方法的超接口
+ * -@Brief: 触发子类初始化前不触发未初始化的包含default方法的超接口
+ *  -#step1: 触发子类初始化前不触发未初始化的包含default方法的超接口
+ *  -#step2: 通过访问接口对象的类字段，优先触发接口初始化，再触发接口对象的类初始化
+ *  -#step3:
+ *  -#step4:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClinitSeq005.java
+ * -@ExecuteClass: ClinitSeq005
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+interface CaseInterface {
+    int FIELD = ClinitSeq005.getCount();
+    CaseOtherClass MEMBER = new CaseOtherClass();
+
+    int uselessFunction(int a, int b);
+}
+
+class CaseOtherClass {
+    static int field;
+
+    static {
+        if (ClinitSeq005.getCount() == 4) {
+            field = ClinitSeq005.getCount();
+        }
+    }
+}
+
+class CaseChild implements CaseInterface {
+    static int field;
+
+    static {
+        if (ClinitSeq005.getCount() == 1) {
+            field = ClinitSeq005.getCount();
+        }
+    }
+
+    public int uselessFunction(int a, int b) {
+        return a + b;
+    }
+}
+
+public class ClinitSeq005 {
+
+    static private int count = 0;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+
+        if (CaseChild.field != 2) {
+            res = 2;
+            out.println("Error, child not initialized");
+        }
+
+        if (CaseInterface.MEMBER.field != 5) {
+            res = 2;
+            out.println("Error, other not initialized");
+        }
+
+        if (CaseInterface.FIELD != 3) {
+            res = 2;
+            out.println("Error, interface not initialized");
+        }
+        return res;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/compact_test/RT0001-rt-compact-ReflectingetConstructor1/ReflectingGetConstructor1.java b/test/testsuite/ouroboros/compact_test/RT0001-rt-compact-ReflectingetConstructor1/ReflectingGetConstructor1.java
new file mode 100755
index 0000000000000000000000000000000000000000..6cc7015419689f8ebd492a6e7e8e3cf80af6bf1a
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0001-rt-compact-ReflectingetConstructor1/ReflectingGetConstructor1.java
@@ -0,0 +1,59 @@
+/*
+ *- @TestCaseID: ReflectingGetConstructor1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectingGetConstructor1.java
+ *- @Title/Destination: Getting public constructors of different arguments from reflection by calling
+ *                      Class.getConstructor()
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName获得GetConstructor1类的一个实例对象getConstructor1；
+ * -#step2: 分别调用GetConstructor1类的三个构造方法，从而实现从反射中获取不同参数的公共构造函数constructor1、constructor2、
+ *          constructor3；
+ * -#step3: 判断三个构造方法获取成功；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectingGetConstructor1.java
+ *- @ExecuteClass: ReflectingGetConstructor1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetConstructor1 {
+    public GetConstructor1() {
+    }
+
+    public GetConstructor1(String name) {
+    }
+
+    public GetConstructor1(String name, int number) {
+    }
+
+    GetConstructor1(int number) {
+    }
+}
+
+public class ReflectingGetConstructor1 {
+    public static void main(String[] args) {
+        try {
+            Class getConstructor1 = Class.forName("GetConstructor1");
+            Constructor constructor1 = getConstructor1.getConstructor(String.class);
+            Constructor constructor2 = getConstructor1.getConstructor();
+            Constructor constructor3 = getConstructor1.getConstructor(String.class, int.class);
+            if (constructor1.toString().equals("public GetConstructor1(java.lang.String)")
+                    && constructor2.toString().equals("public GetConstructor1()")
+                    && constructor3.toString().equals("public GetConstructor1(java.lang.String,int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0002-rt-compact-ReflectingetConstructor2/ReflectingGetConstructor2.java b/test/testsuite/ouroboros/compact_test/RT0002-rt-compact-ReflectingetConstructor2/ReflectingGetConstructor2.java
new file mode 100755
index 0000000000000000000000000000000000000000..6cfe2a771072e0a5460cb21791b9bf6edc16dbca
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0002-rt-compact-ReflectingetConstructor2/ReflectingGetConstructor2.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ReflectingGetConstructor2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectingGetConstructor2.java
+ *- @Title/Destination: When the specified constructor could not be found by reflection, NoSuchMethodException is thrown
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获得GetConstructor2类的一个实例对象getConstructor21；
+ * -#step2: 以int.class为参数，尝试通过getConstructor()方法获取GetConstructor2类的构造函数并记为constructor1；
+ * -#step3: 通过Class.forName()方法获得GetConstructor2类的一个实例对象getConstructor22；
+ * -#step4: 以String.class, char.class, int.class为参数，尝试通过getConstructor()方法获取GetConstructor2类的构造函数并记
+ *          为constructor2；
+ * -#step5: 确定step2和step4中的构造函数constructor1、constructor2获取失败，并且会抛出NoSuchMethodException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectingGetConstructor2.java
+ *- @ExecuteClass: ReflectingGetConstructor2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetConstructor2 {
+    public GetConstructor2() {
+    }
+
+    public GetConstructor2(String name) {
+    }
+
+    public GetConstructor2(String name, int number) {
+    }
+
+    GetConstructor2(int number) {
+    }
+}
+
+public class ReflectingGetConstructor2 {
+    public static void main(String[] args) {
+        try {
+            Class getConstructor21 = Class.forName("GetConstructor2");
+            Constructor constructor1 = getConstructor21.getConstructor(int.class);
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e) {
+            try {
+                Class getConstructor22 = Class.forName("GetConstructor2");
+                Constructor constructor2 = getConstructor22.getConstructor(String.class, char.class, int.class);
+                System.out.println(2);
+            } catch (ClassNotFoundException ee) {
+                System.err.println(ee);
+                System.out.println(2);
+            } catch (NoSuchMethodException ee) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0003-rt-compact-ReflectingetConstructors/ReflectingGetConstructors.java b/test/testsuite/ouroboros/compact_test/RT0003-rt-compact-ReflectingetConstructors/ReflectingGetConstructors.java
new file mode 100755
index 0000000000000000000000000000000000000000..c03f91b63e6c946ae9ff617ba0d1110fb718902d
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0003-rt-compact-ReflectingetConstructors/ReflectingGetConstructors.java
@@ -0,0 +1,81 @@
+/*
+ *- @TestCaseID: ReflectingGetConstructors
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectingGetConstructors.java
+ *- @Title/Destination: Call Class.GetConstructors() to get all the public constructors in a class by reflection
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过反射的方法获得GetConstructors_a类的一个实例对象getConstructors_a；
+ * -#step2: 通过调用getConstructors_a的getConstructors()方法，获取到它的所有公共构造函数并记为constructors；
+ * -#step3: 确定step2中成功获取到getConstructors_a对象的所有公共构造函数constructors，并且其长度等于3，并且对于
+ *          constructors[i].toString()（此处i < constructors.length = 3）不包含字符串"GetConstructors_a(int)"；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectingGetConstructors.java
+ *- @ExecuteClass: ReflectingGetConstructors
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetConstructors {
+    public GetConstructors() {
+    }
+
+    public GetConstructors(String name) {
+    }
+
+    public GetConstructors(String name, int number) {
+    }
+
+    GetConstructors(int number) {
+    }
+
+    GetConstructors(double id) {
+    }
+
+    public GetConstructors(double id, String name) {
+    }
+}
+
+class GetConstructors_a extends GetConstructors {
+    public GetConstructors_a() {
+    }
+
+    public GetConstructors_a(String name) {
+    }
+
+    public GetConstructors_a(String name, int number) {
+    }
+
+    GetConstructors_a(int number) {
+    }
+}
+
+public class ReflectingGetConstructors {
+    public static void main(String[] args) {
+        try {
+            Class getConstructors_a = Class.forName("GetConstructors_a");
+            Constructor<?>[] constructors = getConstructors_a.getConstructors();
+            if (constructors.length == 3) {
+                for (int i = 0; i < constructors.length; i++) {
+                    if (constructors[i].toString().indexOf("GetConstructors_a(int)") != -1) {
+                        System.out.println(2);
+                    }
+                }
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (ArrayIndexOutOfBoundsException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java b/test/testsuite/ouroboros/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java
new file mode 100755
index 0000000000000000000000000000000000000000..db1d9e1e62eefc56a94084bb8b5c1085356e5ae4
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java
@@ -0,0 +1,61 @@
+/*
+ *- @TestCaseID: ReflectingGetDeclaredConstructor1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectingGetDeclaredConstructor1.java
+ *- @Title/Destination: Call Class.getDeclaredConstructor() to get the local constructor of a class by reflection
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过反射的方法获得GetDeclaredConstructor1类的一个实例对象getDeclaredConstructor1；
+ * -#step2: 通过step1中获得的getDeclaredConstructor1分别调用GetDeclaredConstructor1类的三个构造方法，从而实现从反射中获
+ *          取不同参数的本地构造函数constructor1、constructor2、constructor3；
+ * -#step3: step2中所获取到的三个公共构造函数constructor1、constructor2、constructor3分别对应于
+ *          GetDeclaredConstructor1类的三个构造函数，表明本地构造函数获取成功；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectingGetDeclaredConstructor1.java
+ *- @ExecuteClass: ReflectingGetDeclaredConstructor1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetDeclaredConstructor1 {
+    public GetDeclaredConstructor1() {
+    }
+
+    private GetDeclaredConstructor1(String name) {
+    }
+
+    protected GetDeclaredConstructor1(String name, int number) {
+    }
+
+    GetDeclaredConstructor1(int number) {
+    }
+}
+
+public class ReflectingGetDeclaredConstructor1 {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructor1 = Class.forName("GetDeclaredConstructor1");
+            Constructor constructor1 = getDeclaredConstructor1.getDeclaredConstructor(String.class);
+            Constructor constructor2 = getDeclaredConstructor1.getDeclaredConstructor();
+            Constructor constructor3 = getDeclaredConstructor1.getDeclaredConstructor(String.class, int.class);
+            Constructor constructor4 = getDeclaredConstructor1.getDeclaredConstructor(int.class);
+            if (constructor1.toString().equals("private GetDeclaredConstructor1(java.lang.String)")
+                    && constructor2.toString().equals("public GetDeclaredConstructor1()")
+                    && constructor3.toString().equals("protected GetDeclaredConstructor1(java.lang.String,int)")
+                    && constructor4.toString().equals("GetDeclaredConstructor1(int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java b/test/testsuite/ouroboros/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java
new file mode 100755
index 0000000000000000000000000000000000000000..ab07af12d0c061dc95d1982f105fa21c4064bd01
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java
@@ -0,0 +1,52 @@
+/*
+ *- @TestCaseID: ReflectingGetDeclaredConstructor2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectingGetDeclaredConstructor2.java
+ *- @Title/Destination: When the specified local constructor for the class can not be retrieved by reflection using
+ *                      Class.getDeclaredConstructors(), NoSuchMethodException will be thrown
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过反射的方法获得GetDeclaredConstructor2类的一个实例对象getDeclaredConstructor2；
+ * -#step2: 尝试通过step1中的getDeclaredConstructor2对象调用GetDeclaredConstructor2类的不存在的本地构造函数；
+ * -#step3: step2中获取getDeclaredConstructor2对象的不存在的本地构造函数不成功，会抛出NoSuchMethodException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectingGetDeclaredConstructor2.java
+ *- @ExecuteClass: ReflectingGetDeclaredConstructor2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetDeclaredConstructor2 {
+    public GetDeclaredConstructor2() {
+    }
+
+    private GetDeclaredConstructor2(String name) {
+    }
+
+    protected GetDeclaredConstructor2(String name, int number) {
+    }
+
+    GetDeclaredConstructor2(int number) {
+    }
+}
+
+public class ReflectingGetDeclaredConstructor2 {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructor2 = Class.forName("GetDeclaredConstructor2");
+            Constructor constructor = getDeclaredConstructor2.getDeclaredConstructor(String.class, char.class, int.class);
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java b/test/testsuite/ouroboros/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java
new file mode 100755
index 0000000000000000000000000000000000000000..24736160df2d5094ac76ffc6a2c668823917fd52
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java
@@ -0,0 +1,51 @@
+/*
+ *- @TestCaseID: ReflectingGetDeclaredConstructors
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectingGetDeclaredConstructors.java
+ *- @Title/Destination: Call Class.getDeclaredConstructors() to get all the local constructors of a class by reflection
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过反射的方法获得GetDeclaredConstructors类的一个实例对象getDeclaredConstructors；
+ * -#step2: 通过调用getDeclaredConstructors的GetDeclaredConstructors()方法，获取到它的所有本地构造函数并记为constructors；
+ * -#step3: 确定step2中获取getDeclaredConstructors对象的所有本地构造函数constructors成功，并且其长度为4；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectingGetDeclaredConstructors.java
+ *- @ExecuteClass: ReflectingGetDeclaredConstructors
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetDeclaredConstructors {
+    public GetDeclaredConstructors() {
+    }
+
+    private GetDeclaredConstructors(String name) {
+    }
+
+    protected GetDeclaredConstructors(String name, int number) {
+    }
+
+    GetDeclaredConstructors(int number) {
+    }
+}
+
+public class ReflectingGetDeclaredConstructors {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructors = Class.forName("GetDeclaredConstructors");
+            Constructor<?>[] constructors = getDeclaredConstructors.getDeclaredConstructors();
+            if (constructors.length == 4) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0007-rt-compact-ReflectionasSubclass1/ReflectionAsSubclass1.java b/test/testsuite/ouroboros/compact_test/RT0007-rt-compact-ReflectionasSubclass1/ReflectionAsSubclass1.java
new file mode 100755
index 0000000000000000000000000000000000000000..ef1cfaefde744bb7eb2697d1693e0e642ac559d6
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0007-rt-compact-ReflectionasSubclass1/ReflectionAsSubclass1.java
@@ -0,0 +1,51 @@
+/*
+ *- @TestCaseID: ReflectionAsSubclass1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionAsSubclass1.java
+ *- @Title/Destination: child class calls Class.asSubclass() on father class/interface. Get the instance of the subclass
+ *                      that casts the class to the target class by reflection gets the target
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过反射获取A_1类的运行时类，并对其返回值以A.class为参数调用asSubclass()方法，获得a_2；同理，通过反射获取
+ *          A_2类的运行时类，并对其返回值以A.class为参数调用asSubclass()方法，获得a_1；
+ * -#step2: 经判断得知a_2.newInstance()是A的一个实例，a_1.newInstance()也是A的一个实例；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionAsSubclass1.java
+ *- @ExecuteClass: ReflectionAsSubclass1
+ *- @ExecuteArgs:
+ */
+
+interface A {
+}
+
+class A1 implements A {
+}
+
+class A2 extends A1 {
+}
+
+public class ReflectionAsSubclass1 {
+    public static void main(String[] args) {
+        try {
+            Class a2 = Class.forName("A1").asSubclass(A.class);
+            Class a1 = Class.forName("A2").asSubclass(A.class);
+            if (a2.newInstance() instanceof A) {
+                if (a1.newInstance() instanceof A) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(e1);
+        } catch (InstantiationException e2) {
+            System.out.println(e2);
+        } catch (IllegalAccessException e3) {
+            System.out.println(e3);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0008-rt-compact-ReflectionasSubclass2/ReflectionAsSubclass2.java b/test/testsuite/ouroboros/compact_test/RT0008-rt-compact-ReflectionasSubclass2/ReflectionAsSubclass2.java
new file mode 100755
index 0000000000000000000000000000000000000000..3d6c25ac2401cce2f19817fb919f76f3c80bfce0
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0008-rt-compact-ReflectionasSubclass2/ReflectionAsSubclass2.java
@@ -0,0 +1,38 @@
+/*
+ *- @TestCaseID: ReflectionAsSubclass2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionAsSubclass2.java
+ *- @Title/Destination: To cast a subclass of another class by reflection get a class
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName("B_1")，再对其返回值调用asSubclass()方法可以获得B类的子类B_1类；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionAsSubclass2.java
+ *- @ExecuteClass: ReflectionAsSubclass2
+ *- @ExecuteArgs:
+ */
+
+class B {
+}
+
+class B_1 extends B {
+}
+
+public class ReflectionAsSubclass2 {
+    public static void main(String[] args) {
+        try {
+            Class.forName("B_1").asSubclass(B.class);
+        } catch (ClassCastException e) {
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0009-rt-compact-ReflectionasSubclass3/ReflectionAsSubclass3.java b/test/testsuite/ouroboros/compact_test/RT0009-rt-compact-ReflectionasSubclass3/ReflectionAsSubclass3.java
new file mode 100755
index 0000000000000000000000000000000000000000..ed93e3e256506ac6abdc00f17fb15a478d89ed4f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0009-rt-compact-ReflectionasSubclass3/ReflectionAsSubclass3.java
@@ -0,0 +1,61 @@
+/*
+ *- @TestCaseID: ReflectionAsSubclass3
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionAsSubclass3.java
+ *- @Title/Destination: class A calls Class.asSubclass on class B, if A is not a subclass of B, throws ClassCastException
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过反射C_1类，并对其返回值以D.class为参数调用asSubclass()方法；
+ * -#step2: 同理，通过反射C_2类，并对其返回值以D.class为参数调用asSubclass()方法；
+ * -#step3: 通过反射D_1类，并对其返回值以C.class为参数调用asSubclass()方法；
+ * -#step4: step1、step2、step3中方法均调用失败，即无法获取到对应类的子类，会抛出ClassCastException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionAsSubclass3.java
+ *- @ExecuteClass: ReflectionAsSubclass3
+ *- @ExecuteArgs:
+ */
+
+interface C {
+}
+
+class C_1 implements C {
+}
+
+class C_2 extends C_1 {
+}
+
+class D {
+}
+
+class D_1 extends D {
+}
+
+public class ReflectionAsSubclass3 {
+    public static void main(String[] args) {
+        try {
+            Class.forName("C_1").asSubclass(D.class);
+        } catch (ClassCastException e1) {
+            try {
+                Class.forName("C_2").asSubclass(D.class);
+            } catch (ClassCastException e2) {
+                try {
+                    Class.forName("D_1").asSubclass(C.class);
+                } catch (ClassCastException e3) {
+                    System.out.println(0);
+                } catch (ClassNotFoundException e4) {
+                    System.out.println(2);
+                }
+            } catch (ClassNotFoundException e5) {
+                System.out.println(2);
+            }
+        } catch (ClassNotFoundException e6) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0010-rt-compact-Reflectioncast1/ReflectionCast1.java b/test/testsuite/ouroboros/compact_test/RT0010-rt-compact-Reflectioncast1/ReflectionCast1.java
new file mode 100755
index 0000000000000000000000000000000000000000..9a6331ddd79ee548567b72bcc283db7d98441882
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0010-rt-compact-Reflectioncast1/ReflectionCast1.java
@@ -0,0 +1,38 @@
+/*
+ *- @TestCaseID: ReflectionCast1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionCast1.java
+ *- @Title/Destination: Casts an object to the class or interface represented by this Class object
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 创建一个Cast1_a类的实例对象cast1_a，创建一个Cast1类的实例对象cast1；
+ * -#step2: 将step1中的Cast1类的实例对象cast1强制转换为Cast1_a类型；
+ * -#step3: 经转换后的cast1对象和Cast1_a类是同一类型；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionCast1.java
+ *- @ExecuteClass: ReflectionCast1
+ *- @ExecuteArgs:
+ */
+
+class Cast1 {
+}
+
+class Cast1_a extends Cast1 {
+}
+
+public class ReflectionCast1 {
+    public static void main(String[] args) {
+        Cast1_a cast1_a = new Cast1_a();
+        Cast1 cast1 = new Cast1();
+        cast1 = Cast1.class.cast(cast1_a);
+        if (cast1.getClass().toString().equals("class Cast1_a")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0011-rt-compact-Reflectioncast2/ReflectionCast2.java b/test/testsuite/ouroboros/compact_test/RT0011-rt-compact-Reflectioncast2/ReflectionCast2.java
new file mode 100755
index 0000000000000000000000000000000000000000..06540ae388f4d60076375b5b59966bc41e568171
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0011-rt-compact-Reflectioncast2/ReflectionCast2.java
@@ -0,0 +1,40 @@
+/*
+ *- @TestCaseID: ReflectionCast2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionCast2.java
+ *- @Title/Destination: An exception is reported when the parent object cannot be cast to the class represented by this
+ *                      class object
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 创建一个Cast2类的实例对象cast2,创建一个Cast2类的子类Cast2_a类的实例对象cast2_a；
+ * -#step2: 将Cast2_a类的对象cast2_a强制转换为父类Cast2类型；
+ * -#step3: step2中的转换不能转换成功，会发生ClassCastException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionCast2.java
+ *- @ExecuteClass: ReflectionCast2
+ *- @ExecuteArgs:
+ */
+
+class Cast2 {
+}
+
+class Cast2_a extends Cast2 {
+}
+
+public class ReflectionCast2 {
+    public static void main(String[] args) {
+        Cast2_a cast2_a = new Cast2_a();
+        Cast2 cast2 = new Cast2();
+        try {
+            cast2_a = Cast2_a.class.cast(cast2);
+        } catch (ClassCastException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0012-rt-compact-Reflectioncast3/ReflectionCast3.java b/test/testsuite/ouroboros/compact_test/RT0012-rt-compact-Reflectioncast3/ReflectionCast3.java
new file mode 100755
index 0000000000000000000000000000000000000000..232a3f4485365b1a2778cd7207d0ad14ce6ffd54
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0012-rt-compact-Reflectioncast3/ReflectionCast3.java
@@ -0,0 +1,40 @@
+/*
+ *- @TestCaseID: ReflectionCast3
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionCast3.java
+ *- @Title/Destination: An exception is reported when a relationship-free object cannot be cast to a class represented
+ *                      by this class object
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 创建一个Cast3_a类的实例对象cast3_a，创建一个Cast3类的实例对象cast3；
+ * -#step2: 将Cast3_a类的对象cast3_a强制转换为Cast3类型；
+ * -#step3: step2中的转换不能转换成功，会发生ClassCastException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionCast3.java
+ *- @ExecuteClass: ReflectionCast3
+ *- @ExecuteArgs:
+ */
+
+class Cast3 {
+}
+
+class Cast3_a {
+}
+
+public class ReflectionCast3 {
+    public static void main(String[] args) {
+        Cast3_a cast3_a = new Cast3_a();
+        Cast3 cast3 = new Cast3();
+        try {
+            cast3_a = Cast3_a.class.cast(cast3);
+        } catch (ClassCastException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0013-rt-compact-Reflectioncast4/ReflectionCast4.java b/test/testsuite/ouroboros/compact_test/RT0013-rt-compact-Reflectioncast4/ReflectionCast4.java
new file mode 100755
index 0000000000000000000000000000000000000000..d01d544107dd3689bf382126dd43c7a314ed5559
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0013-rt-compact-Reflectioncast4/ReflectionCast4.java
@@ -0,0 +1,35 @@
+/*
+ *- @TestCaseID: ReflectionCast4
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionCast4.java
+ *- @Title/Destination: Object cast to NULL
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 创建一个Cast4类的实例对象cast4，创建一个Object类的变量object，并赋初值为null；
+ * -#step2: 将Cast4类的实例对象cast4强制转换为null；
+ * -#step3: step2中成功将cast4对象转换为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionCast4.java
+ *- @ExecuteClass: ReflectionCast4
+ *- @ExecuteArgs:
+ */
+
+class Cast4 {
+}
+
+public class ReflectionCast4 {
+    public static void main(String[] args) {
+        Object object = null;
+        Cast4 cast4 = new Cast4();
+        cast4 = Cast4.class.cast(object);
+        if (cast4 == null) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java b/test/testsuite/ouroboros/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java
new file mode 100755
index 0000000000000000000000000000000000000000..cf218ca0357c9b1e90ec3fbc419849629844e8a5
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java
@@ -0,0 +1,31 @@
+/*
+ *- @TestCaseID: ReflectionDesiredAssertionStatus
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionDesiredAssertionStatus.java
+ *- @Title/Destination: When a class's assertionStatus is not set, desiredAssertionStatus() return false
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 创建一个ReflectionDesiredAssertionStatus类的实例对象reflectionDesiredAssertionStatus；
+ * -#step2: 通过reflectionDesiredAssertionStatus的getClass()方法获取其所属的类型并记为clazz；
+ * -#step3: 调用clazz的desiredAssertionStatus()方法得到的返回值为false；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionDesiredAssertionStatus.java
+ *- @ExecuteClass: ReflectionDesiredAssertionStatus
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionDesiredAssertionStatus {
+    public static void main(String[] args) {
+        ReflectionDesiredAssertionStatus reflectionDesiredAssertionStatus = new ReflectionDesiredAssertionStatus();
+        Class clazz = reflectionDesiredAssertionStatus.getClass();
+        if (!clazz.desiredAssertionStatus()) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0015-rt-compact-ReflectionforName1/ReflectionForName1.java b/test/testsuite/ouroboros/compact_test/RT0015-rt-compact-ReflectionforName1/ReflectionForName1.java
new file mode 100755
index 0000000000000000000000000000000000000000..1e76aa99da692fa502aa22ed5cb65a609746a2c8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0015-rt-compact-ReflectionforName1/ReflectionForName1.java
@@ -0,0 +1,32 @@
+/*
+ *- @TestCaseID: ReflectionForName1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionForName1.java
+ *- @Title/Destination: Use Class.forName() To find a class by class name
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName的方法获取ForName1类的类型clazz；
+ * -#step2: 确定step1中的clazz与ForName1类是同一类型；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionForName1.java
+ *- @ExecuteClass: ReflectionForName1
+ *- @ExecuteArgs:
+ */
+
+class ForName1 {
+}
+
+public class ReflectionForName1 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        Class clazz = Class.forName("ForName1");
+        if (clazz.toString().equals("class ForName1")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0016-rt-compact-ReflectionforName4/ReflectionForName4.java b/test/testsuite/ouroboros/compact_test/RT0016-rt-compact-ReflectionforName4/ReflectionForName4.java
new file mode 100755
index 0000000000000000000000000000000000000000..bdf2102e50eb45360672b6d257dc0ae374f91c95
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0016-rt-compact-ReflectionforName4/ReflectionForName4.java
@@ -0,0 +1,40 @@
+/*
+ *- @TestCaseID: ReflectionForName4
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionForName4.java
+ *- @Title/Destination: An exception is reported when a class is not found with reflection through a class name
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 以“for*”、true、ForName4_a.class.getClassLoader()为参数，通过Class.forName()获取相关类的运行时类时会
+ *          抛出ClassNotFoundException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionForName4.java
+ *- @ExecuteClass: ReflectionForName4
+ *- @ExecuteArgs:
+ */
+
+class ForName4 {
+    static {
+    }
+}
+
+class ForName4_a {
+    static {
+    }
+}
+
+public class ReflectionForName4 extends Thread {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("for*", true, ForName4_a.class.getClassLoader());
+        } catch (ClassNotFoundException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0017-rt-compact-ReflectionforName5/ReflectionForName5.java b/test/testsuite/ouroboros/compact_test/RT0017-rt-compact-ReflectionforName5/ReflectionForName5.java
new file mode 100755
index 0000000000000000000000000000000000000000..2af68e4514031efa93ba34210c2661a3497aaed9
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0017-rt-compact-ReflectionforName5/ReflectionForName5.java
@@ -0,0 +1,62 @@
+/*
+ *- @TestCaseID: ReflectionForName5
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionForName5.java
+ *- @Title/Destination: Use Class.forName() to get a multilevel inherited class by reflection
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取ForName5类的类型clazz，且clazz和ForName5类是同一类型；
+ * -#step2: 通过Class.forName()方法获取ForName55类的类型clazz2，且clazz2和ForName55类是同一类型；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionForName5.java
+ *- @ExecuteClass: ReflectionForName5
+ *- @ExecuteArgs:
+ */
+
+interface ForName55_c {
+}
+
+class ForName55_b implements ForName55_c {
+}
+
+class ForName55_a extends ForName55_b {
+}
+
+class ForName55 extends ForName55_a {
+}
+
+class ForName5_e {
+}
+
+class ForName5_d extends ForName5_e {
+}
+
+class ForName5_c extends ForName5_d {
+}
+
+class ForName5_b extends ForName5_c {
+}
+
+class ForName5_a extends ForName5_b {
+}
+
+class ForName5 extends ForName5_a {
+}
+
+public class ReflectionForName5 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        Class clazz = Class.forName("ForName5");
+        if (clazz.toString().equals("class ForName5")) {
+            Class clazz2 = Class.forName("ForName55");
+            if (clazz2.toString().equals("class ForName55")) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java b/test/testsuite/ouroboros/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c7be90abfe1728d49a163699b36164c1f451747
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java
@@ -0,0 +1,58 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotation1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotation1.java
+ *- @Title/Destination: call class.getAnnotation to get annotation of a target class according to annotation class by
+ *                      reflection
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetAnnotation1_a类的类型clazz1，通过Class.forName()方法获取GetAnnotation1_b类的
+ *          类型clazz2；
+ * -#step2: 以Zzz1.class为参数，通过getAnnotation()方法，分别获取clazz1、clazz2的注解，并且clazz1的注解中包含字符串
+ *          "t=getAnnotation"和"i=333"，而clazz2的注解等于null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotation1.java
+ *- @ExecuteClass: ReflectionGetAnnotation1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz1 {
+int i() default 0;
+
+String t() default "";
+}
+
+@Zzz1(i = 333, t = "getAnnotation")
+class GetAnnotation1_a {
+}
+
+class GetAnnotation1_b {
+}
+
+public class ReflectionGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetAnnotation1_a");
+            Class clazz2 = Class.forName("GetAnnotation1_b");
+            if (clazz1.getAnnotation(Zzz1.class).toString().indexOf("t=getAnnotation") != -1
+                    && clazz1.getAnnotation(Zzz1.class).toString().indexOf("i=333") != -1
+                    && clazz2.getAnnotation(Zzz1.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/ReflectionGetAnnotation2.java b/test/testsuite/ouroboros/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/ReflectionGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..958e6d340fcc0464922f49f7d1cb30bc953dd1fd
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/ReflectionGetAnnotation2.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotation2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotation2.java
+ *- @Title/Destination: Call class.getAnnotation to get annotation of a field in class according to annotation class by
+ *                      reflection.
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 定义含注解的类GetAnnotation2_a，通过调用getField()获取注解成员，调用getAnnotation(Class<T> annotationClass)
+ *           获取注解，确认获取的注解正确。
+ *  -#step2：GetAnnotation2_a通过调用getField()获取非注解成员，调用getAnnotation(Class<T> annotationClass)
+ *           获取注解，确认获取的注解为空。
+ *  -#step3：定义不含注解的类GetAnnotation2_b，通过调用getField()获取成员，调用getAnnotation(Class<T> annotationClass)
+ *           获取注解，确认获取的注解为空。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotation2.java
+ *- @ExecuteClass: ReflectionGetAnnotation2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+
+class GetAnnotation2_a {
+    @IF2(i = 333, t = "getAnnotation")
+    public int i_a;
+    public String t_a;
+}
+
+class GetAnnotation2_b {
+    public int i_b;
+    public String t_b;
+}
+
+public class ReflectionGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls1 = Class.forName("GetAnnotation2_a");
+            Class cls2 = Class.forName("GetAnnotation2_b");
+            Field instance1 = cls1.getField("i_a");
+            Field instance2 = cls1.getField("t_a");
+            Field instance3 = cls2.getField("i_b");
+            if (instance1.getAnnotation(IF2.class).i() == 333 && instance1.getAnnotation(IF2.class).
+                    t().equals("getAnnotation") && instance2.getAnnotation(IF2.class) == null &&
+                    instance3.getAnnotation(IF2.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java b/test/testsuite/ouroboros/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java
new file mode 100755
index 0000000000000000000000000000000000000000..2c34759e7753bcd1ba89838cc17419905b181a87
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java
@@ -0,0 +1,86 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotation3
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotation3.java
+ *- @Title/Destination: Call Class.getAnnotation in functions of target class to get annotation by reflection, if the
+ *                      function does not have the expected annotation, throws exception.
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 定义含注解的内部类GetAnnotation3_a。
+ *  -#step2：通过调用getField()从内部类GetAnnotation3_a中获取成员。
+ *  -#step3：调用getAnnotation(Class<T> annotationClass)获取GetAnnotation3_a的注解并抛出NullPointerException。
+ *  -#step4：定义不含注解的类GetAnnotation3_b，通过getAnnotation()方法获取成员方法，并抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotation3.java
+ *- @ExecuteClass: ReflectionGetAnnotation3
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz3 {
+    int i() default 0;
+    String t() default "";
+}
+
+class GetAnnotation3_a {
+    @Zzz3(i = 333, t = "getAnnotation")
+    public void qqq() {
+    };
+
+    public void rrr() {
+    };
+}
+
+class GetAnnotation3_b {
+    public void www() {
+    };
+}
+
+public class ReflectionGetAnnotation3 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation3_a");
+            Method zhu1 = zqp1.getMethod("qqq");
+            Method zhu2 = zqp1.getMethod("rrr");
+            zhu1.getAnnotation(Zzz3.class).t();
+            zhu2.getAnnotation(Zzz3.class).i();
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+
+            try {
+                Class zqp2 = Class.forName("GetAnnotation3_b");
+                Method zhu3 = zqp2.getMethod("www");
+                zhu3.getAnnotation(Zzz3.class).i();
+                System.out.println(2);
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                System.out.println(2);
+            } catch (NoSuchMethodException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NullPointerException e5){
+                System.out.println(0);
+            }
+        }
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java b/test/testsuite/ouroboros/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java
new file mode 100755
index 0000000000000000000000000000000000000000..b3b1783d6dd58e4712e911c408606a0142d38b90
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java
@@ -0,0 +1,75 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotation4
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotation4.java
+ *- @Title/Destination: Call Class.getAnnotation in functions of target class to get annotation by reflection, if the
+ *                      function does not have the expected annotation, throws exception.
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 定义含注解的内部类GetAnnotation4_a。
+ *  -#step2：通过调用getMethod()从内部类GetAnnotation4_a中获取成员方法。
+ *  -#step3：调用getAnnotation(Class<T> annotationClass)获取GetAnnotation4_a成员方法的注解并抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotation4.java
+ *- @ExecuteClass: ReflectionGetAnnotation4
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz4 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@interface Zzz4_a {
+int ii() default 0;
+
+String tt() default "";
+}
+
+class GetAnnotation4_a {
+    @Zzz4(i = 333, t = "getAnnotation")
+    public void qqq() {
+    };
+
+    @Zzz4_a(ii = 555, tt = "test")
+    public void rrr() {
+    };
+}
+
+public class ReflectionGetAnnotation4 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation4_a");
+            Method zhu1 = zqp1.getMethod("qqq");
+            Method zhu2 = zqp1.getMethod("rrr");
+            if (zhu1.getAnnotation(Zzz4_a.class) == null && zhu2.getAnnotation(Zzz4.class) == null) {
+                zhu1.getAnnotation(Zzz4_a.class).ii();
+                System.out.println(2);
+            }
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/ReflectionGetAnnotation5.java b/test/testsuite/ouroboros/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/ReflectionGetAnnotation5.java
new file mode 100755
index 0000000000000000000000000000000000000000..1a9f0281685c446b3d2cd9e64b2a313aaa2f97a2
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/ReflectionGetAnnotation5.java
@@ -0,0 +1,79 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotation5
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotation5.java
+ *- @Title/Destination: Child class call Class.GetAnnotation to get class annotations inherited from parent classes
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 定义含注解的内部类GetAnnotation5。
+ *  -#step2：创建类GetAnnotation5_a继承GetAnnotation5，创建类GetAnnotation5_a的子类GetAnnotation5_b。
+ *  -#step3: 通过forName()获取GetAnnotation5_b的类名对象。
+ *  -#step4：调用getAnnotation(Class<T> annotationClass)获取GetAnnotation5_b的注解。
+ *  -#step5：对获取的注解结果进行判断
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotation5.java
+ *- @ExecuteClass: ReflectionGetAnnotation5
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz5 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz5_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Zzz5(i = 333, t = "test1")
+class GetAnnotation5 {
+    public int i;
+    public String t;
+}
+
+@Zzz5_a(i_a = 666, t_a = "right1")
+class GetAnnotation5_a extends GetAnnotation5 {
+    public int i_a;
+    public String t_a;
+}
+
+class GetAnnotation5_b extends GetAnnotation5_a {
+}
+
+public class ReflectionGetAnnotation5 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation5_b");
+            if (zqp1.getAnnotation(Zzz5.class).toString().indexOf("t=test1") != -1 && zqp1.getAnnotation(Zzz5.class).
+                    toString().indexOf("i=333") != -1) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/ReflectionGetAnnotation6.java b/test/testsuite/ouroboros/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/ReflectionGetAnnotation6.java
new file mode 100755
index 0000000000000000000000000000000000000000..471086dbf59e58140e6ac1d5391e2a4ccc47ac8a
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/ReflectionGetAnnotation6.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotation6
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotation6.java
+ *- @Title/Destination: Call Class.GetAnnotation() to get annotations of inner classes by reflection
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 定义含注解的类GetAnnotation6的静态内部类GetAnnotation6_a。
+ *  -#step2: 通过forName()获取GetAnnotation6_a的类名对象。
+ *  -#step3：调用getAnnotation(Class<T> annotationClass)获取GetAnnotation6_b的注解。
+ *  -#step4：对获取的注解结果进行判断
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotation6.java
+ *- @ExecuteClass: ReflectionGetAnnotation6
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz6 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz6_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Zzz6(i = 333, t = "test1")
+class GetAnnotation6 {
+    public int i;
+    public String t;
+
+    @Zzz6_a(i_a = 666, t_a = "right1")
+    public static class GetAnnotation6_a {
+        public int j;
+    }
+}
+
+public class ReflectionGetAnnotation6 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation6");
+            Class[] zhu1 = zqp1.getDeclaredClasses();
+            if (zhu1[0].getAnnotation(Zzz6_a.class).toString().indexOf("t_a=right1") != -1 && zhu1[0].
+                    getAnnotation(Zzz6_a.class).toString().indexOf("i_a=666") != -1) {
+                if (zhu1[0].getAnnotation(Zzz6.class) == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/ReflectionGetAnnotation7.java b/test/testsuite/ouroboros/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/ReflectionGetAnnotation7.java
new file mode 100755
index 0000000000000000000000000000000000000000..6c02613381f96993e4da8ed8ede5e49a8e378584
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/ReflectionGetAnnotation7.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotation7
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotation7.java
+ *- @Title/Destination: Use Class.GetAnnotation to get native basic annotations through reflection.
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 创建类GetAnnotation7的子类GetAnnotation7_a且重写父类中废弃的aa()方法。
+ *  -#step2: 通过forName()获取GetAnnotation7_a的类名对象。
+ *  -#step3: 通过getMethod()获取GetAnnotation7_a内的方法。
+ *  -#step4：调用getAnnotation(Class<T> annotationClass)获取Deprecated.class的值。
+ *  -#step5：对获取的注解结果进行判断
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotation7.java
+ *- @ExecuteClass: ReflectionGetAnnotation7
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+
+class GetAnnotation7 {
+    @Deprecated
+    public int aa(int num) {
+        return 0;
+    }
+}
+
+class GetAnnotation7_a extends GetAnnotation7 {
+    @Override
+    public int aa(int num) {
+        return 2;
+    }
+}
+
+public class ReflectionGetAnnotation7 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation7_a");
+            Method zhu1 = zqp1.getMethod("aa", int.class);
+            Annotation[] j = zhu1.getAnnotations();
+            if (j.length == 0) {
+                try {
+                    Class zqp2 = Class.forName("GetAnnotation7");
+                    Method zhu2 = zqp2.getMethod("aa", int.class);
+                    if (zhu2.getAnnotation(Deprecated.class).toString().indexOf("Deprecated") != -1) {
+                        System.out.println(0);
+                    }
+                } catch (ClassNotFoundException e1) {
+                    System.err.println(e1);
+                    System.out.println(2);
+                } catch (NoSuchMethodException e2) {
+                    System.err.println(e2);
+                    System.out.println(2);
+                } catch (NullPointerException e3) {
+                    System.err.println(e3);
+                    System.out.println(2);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/ReflectionGetAnnotationsByType1.java b/test/testsuite/ouroboros/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/ReflectionGetAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..0358208c6968caaa6825ed044c94c318bb667fb8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/ReflectionGetAnnotationsByType1.java
@@ -0,0 +1,86 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotationsByType1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotationsByType1.java
+ *- @Title/Destination: Call Class.GetAnnotationsByType() to gets the annotation of the field in the target class by
+ *                      reflection, returning the annotation array.
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 创建类GetAnnotationsByType1_a，且定义含注解的变量。
+ *  -#step2: 通过forName()获取GetAnnotationsByType1_a的类名对象。
+ *  -#step3: 通过getMethod()获取GetAnnotationsByType1_a内对应名称的变量。
+ *  -#step4：调用getAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的注解。
+ *  -#step5：对获取的注解结果进行判断
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotationsByType1.java
+ *- @ExecuteClass: ReflectionGetAnnotationsByType1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz1 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@interface Zzzz1_a {
+}
+
+@interface Zzzz1_b {
+}
+
+class GetAnnotationsByType1_a {
+    @Zzzz1(i = 333, t = "GetAnnotationsByType")
+    public int i_a;
+    @Zzzz1(i = 333, t = "GetAnnotationsByType")
+    public int i_aa;
+    @Zzzz1(i = 333, t = "GetAnnotationsByType")
+    public int i_aaa;
+    public String t_a;
+    @Zzzz1_a
+    public String t_aa;
+    @Zzzz1_b
+    public String t_aaa;
+}
+
+public class ReflectionGetAnnotationsByType1 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType1_a");
+            Field zhu1 = zqp1.getField("i_a");
+            Field zhu2 = zqp1.getField("t_a");
+            if (zqp1.getAnnotationsByType(Zzzz1.class).length == 0) {
+                if (zhu2.getAnnotationsByType(Zzzz1_a.class).length == 0) {
+                    Annotation[] k = zhu1.getAnnotationsByType(Zzzz1.class);
+                    if (k[0].toString().indexOf("t=GetAnnotationsByType") != -1 && k[0].toString().indexOf("i=333")
+                            != -1) {
+                        System.out.println(0);
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java b/test/testsuite/ouroboros/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java
new file mode 100755
index 0000000000000000000000000000000000000000..359f8cc435e1308300557888b39b67cff9a9a37a
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java
@@ -0,0 +1,82 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotationsByType2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotationsByType2.java
+ *- @Title/Destination: Retrieving an empty annotation of a field in a target class by reflection reports an exception.
+ *                      Class.GetAnnotationsByType(null) throws NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 创建含注解的类GetAnnotationsByType2_a，不含注解的类GetAnnotationsByType2_b。
+ *  -#step2: 通过forName()获取GetAnnotationsByType2_a的类名对象，通过getField()获取GetAnnotationsByType2_a内对应名称的成员。
+ *  -#step3: 调用getAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的数组并抛出NullPointerException。
+ *  -#step4：通过forName()获取GetAnnotationsByType2_b的类名对象，通过getField()获取GetAnnotationsByType2_b内对应名称的成员。
+ *  -#step5：调用getAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的数组并抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotationsByType2.java
+ *- @ExecuteClass: ReflectionGetAnnotationsByType2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz2 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+class GetAnnotationsByType2_a {
+    @Zzzz2(i = 333, t = "GetAnnotationsByType")
+    public int i_a;
+    public String t_a;
+}
+
+class GetAnnotationsByType2_b {
+    public int i_b;
+    public String t_b;
+}
+
+public class ReflectionGetAnnotationsByType2 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType2_a");
+            Field zhu1 = zqp1.getField("t_a");
+            Annotation[] j = zhu1.getAnnotationsByType(null);
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+
+            try {
+                Class zqp2 = Class.forName("GetAnnotationsByType2_b");
+                Field zhu2 = zqp2.getField("i_b");
+                Annotation[] k = zhu2.getAnnotationsByType(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                System.out.println(2);
+            } catch (NoSuchFieldException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/ReflectionGetAnnotationsByType3.java b/test/testsuite/ouroboros/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/ReflectionGetAnnotationsByType3.java
new file mode 100755
index 0000000000000000000000000000000000000000..9056f6a092073af719af28ea75472e5b6d725630
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/ReflectionGetAnnotationsByType3.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID: ReflectionGetAnnotationsByType3
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetAnnotationsByType3.java
+ *- @Title/Destination: Child class calls Class.GetAnnotationsByType to gets the annotations inherited from parent class
+  *                     by reflection, and returns an array of annotations.
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 创建类GetAnnotationsByType3_a继承于含注解的GetAnnotationsByType3的子类GetAnnotationsByType3_a。
+ *  -#step2: 通过forName()获取GetAnnotationsByType1_a的类名对象。
+ *  -#step3：调用getAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的数组。
+ *  -#step5：对获取的注解结果进行判断。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetAnnotationsByType3.java
+ *- @ExecuteClass: ReflectionGetAnnotationsByType3
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz3 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz3_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Zzzz3(i = 333, t = "test1")
+class GetAnnotationsByType3 {
+    public int i;
+    public String t;
+}
+
+@Zzzz3_a(i_a = 666, t_a = "right1")
+class GetAnnotationsByType3_a extends GetAnnotationsByType3 {
+    public int i_a;
+    public String t_a;
+}
+
+class GetAnnotationsByType3_b extends GetAnnotationsByType3_a {
+}
+
+public class ReflectionGetAnnotationsByType3 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType3_b");
+            Annotation[] j = zqp1.getAnnotationsByType(Zzzz3.class);
+            if (j[0].toString().indexOf("t=test1") != -1 && j[0].toString().indexOf("i=333") != -1) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java b/test/testsuite/ouroboros/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java
new file mode 100755
index 0000000000000000000000000000000000000000..60a5f94086f40319eaa65c5e3eb12da0f22f071f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java
@@ -0,0 +1,41 @@
+/*
+ *- @TestCaseID: ReflectionGetCanonicalName
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetCanonicalName.java
+ *- @Title/Destination: Class.getCanonicalName() returns class name by reflection.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Define an empty class.
+ * -#step2: Get Class instance by calling ForName(String className)
+ * -#step3: Test getCanonicalName() returns class name correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetCanonicalName.java
+ *- @ExecuteClass: ReflectionGetCanonicalName
+ *- @ExecuteArgs:
+ */
+
+class GetCanonicalNameTest {
+}
+
+public class ReflectionGetCanonicalName {
+
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+
+        try {
+            Class zqp = Class.forName("GetCanonicalNameTest");
+            if (zqp.getCanonicalName().equals("GetCanonicalNameTest")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0029-rt-compact-ReflectiongetComponentType/ReflectionGetComponentType.java b/test/testsuite/ouroboros/compact_test/RT0029-rt-compact-ReflectiongetComponentType/ReflectionGetComponentType.java
new file mode 100755
index 0000000000000000000000000000000000000000..4141e47d4bc54ba9e8c91f31bc1c5baa1b157ffc
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0029-rt-compact-ReflectiongetComponentType/ReflectionGetComponentType.java
@@ -0,0 +1,33 @@
+/*
+ *- @TestCaseID: ReflectionGetComponentType
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetComponentType.java
+ *- @Title/Destination: Class.getComponentType() returns the Class representing the component type of an array. If
+ *                      this class does not represent an array class ,then this method returns null.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Test Class.getComponentType() when char,string[] and int[] call it.
+ * -#step2: Check Class.getComponentType() returns right component type when an array calls it.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetComponentType.java
+ *- @ExecuteClass: ReflectionGetComponentType
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionGetComponentType {
+
+    public static void main(String[] args) {
+        if (char.class.getComponentType() == null && String[].class.getComponentType().toString().
+                equals("class java.lang.String") && int[].class.getComponentType().toString().equals("int")) {
+            System.out.println(0);
+        }else{
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java b/test/testsuite/ouroboros/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..6155348ec892b01ba8fd44202392fc860593e47e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredAnnotations1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredAnnotations1.java
+ *- @Title/Destination: Class.GetDeclaredAnnotations() retrieve all annotations from the target class by reflection,
+ *                      and result an array of annotations.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Define two annotations.
+ * -#step2: Use classloader to load class.R
+ * -#step3: Return an array of annotations by calling GetDeclaredAnnotations().
+ * -#step4: Check that Class.GetDeclaredAnnotations() retrieves all annotations.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredAnnotations1.java
+ *- @ExecuteClass: ReflectionGetDeclaredAnnotations1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd1 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd1_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Ddd1(i = 333, t = "test1")
+class GetDeclaredAnnotations1 {
+    public int i;
+    public String t;
+}
+
+@Ddd1_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotations1_a extends GetDeclaredAnnotations1 {
+    public int i_a;
+    public String t_a;
+}
+
+public class ReflectionGetDeclaredAnnotations1 {
+
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotations1_a");
+            if (zqp1.getDeclaredAnnotations().length == 1) {
+                Annotation[] j = zqp1.getDeclaredAnnotations();
+                if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                    result = 0;
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..070138c9554ab34b4619c701d3917402044a18ad
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredAnnotations2.java
+ *- @Title/Destination: Class.GetDeclaredAnnotations() does not result annotations that inherited from parent class.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Define two annotation.
+ * -#step2：Use classloader to load class.
+ * -#step3：Return an array of annotations by calling GetDeclaredAnnotations().
+ * -#step4: Check that Class.GetDeclaredAnnotations() retrieves all annotations but annotations those inherited from
+ *          parent class.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredAnnotations2.java
+ *- @ExecuteClass: ReflectionGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd2 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd2_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Ddd2(i = 333, t = "test1")
+class GetDeclaredAnnotations2 {
+    public int i;
+    public String t;
+}
+
+@Ddd2_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotations2_a extends GetDeclaredAnnotations2 {
+    public int i_a;
+    public String t_a;
+}
+
+class GetDeclaredAnnotations2_b extends GetDeclaredAnnotations2_a {
+}
+
+public class ReflectionGetDeclaredAnnotations2 {
+
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotations2_b");
+            if (zqp1.getDeclaredAnnotations().length == 0) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/ReflectionGetDeclaredAnnotationsByType1.java b/test/testsuite/ouroboros/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/ReflectionGetDeclaredAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..214812fe1e07029309f2c82285b2b1a07d7711f9
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/ReflectionGetDeclaredAnnotationsByType1.java
@@ -0,0 +1,85 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredAnnotationsByType1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredAnnotationsByType1.java
+ *- @Title/Destination: Class.GetDeclaredAnnotationsByType() returns the target class local annotation of expected type
+ *                      through reflection, and returns the annotation array.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Define two annotation.
+ * -#step2: Use classloader to load class.
+ * -#step3: result an array of annotations by calling GetDeclaredAnnotationsByType().
+ * -#step4: Check that Class.GetDeclaredAnnotationsByType() returns all annotations but annotations those inherited from
+ *          parent class.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredAnnotationsByType1.java
+ *- @ExecuteClass: ReflectionGetDeclaredAnnotationsByType1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd1 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd1_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Dddd1(i = 333, t = "test1")
+class GetDeclaredAnnotationsByType1 {
+    public int i;
+    public String t;
+}
+
+@Dddd1_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotationsByType1_a extends GetDeclaredAnnotationsByType1 {
+    public int i_a;
+    public String t_a;
+}
+
+class GetDeclaredAnnotationsByType1_b extends GetDeclaredAnnotationsByType1_a {
+}
+
+public class ReflectionGetDeclaredAnnotationsByType1 {
+
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotationsByType1_b");
+            Class zqp2 = Class.forName("GetDeclaredAnnotationsByType1_a");
+            if (zqp1.getDeclaredAnnotationsByType(Dddd1.class).length == 0) {
+                Annotation[] j = zqp2.getDeclaredAnnotationsByType(Dddd1_a.class);
+                if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                    result = 0;
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java b/test/testsuite/ouroboros/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..a6354ccfef83555ae936c598dbd1658cba04bb43
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,77 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredAnnotationsByTypeNullPointerException
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
+ *- @Title/Destination: Class.GetDeclaredAnnotationsByType(null) throws NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Define two annotation.
+ * -#step2: Use classloader to load class.
+ * -#step3: Test Class.GetDeclaredAnnotationsByType() with null parameter.
+ * -#step4: Check that NullPointerException was threw.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
+ *- @ExecuteClass: ReflectionGetDeclaredAnnotationsByTypeNullPointerException
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd2 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd2_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Dddd2(i = 333, t = "test1")
+class GetDeclaredAnnotationsByType2 {
+    public int i;
+    public String t;
+}
+
+@Dddd2_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotationsByType2_a extends GetDeclaredAnnotationsByType2 {
+    public int i_a;
+    public String t_a;
+}
+
+class GetDeclaredAnnotationsByType2_b extends GetDeclaredAnnotationsByType2_a {
+}
+
+public class ReflectionGetDeclaredAnnotationsByTypeNullPointerException {
+
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotationsByType2_b");
+            Annotation[] j = zqp1.getDeclaredAnnotationsByType(null);
+            result = 0;
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java b/test/testsuite/ouroboros/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java
new file mode 100755
index 0000000000000000000000000000000000000000..a63b9f522b9a123e9fff1b5b8635ea214b577acc
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java
@@ -0,0 +1,65 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredClasses
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredClasses.java
+ *- @Title/Destination: Class.getDeclaredClasses() result an array of class objects that represent all declared members
+ *                      of this class,includes public, protected, default (package) access, and private classes and
+ *                      interfaces,excludes inherited classes and interfaces
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Create a class include inner class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Return an array of class objects by calling Class.getDeclaredClasses().
+ * -#step4: Check that the array of class objects exclude inherited classes and interfaces.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredClasses.java
+ *- @ExecuteClass: ReflectionGetDeclaredClasses
+ *- @ExecuteArgs:
+ */
+
+class ReflectiongetDeclaredClasses_a {
+    public class getDeclaredClasses_a1 {
+    }
+
+    private class getDeclaredClasses_a2 {
+    }
+
+    protected class getDeclaredClasses_a3 {
+    }
+}
+
+public class ReflectionGetDeclaredClasses extends ReflectiongetDeclaredClasses_a {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("ReflectionGetDeclaredClasses");
+            Class<?>[] j = zqp.getDeclaredClasses();
+            if (j.length == 3) {
+                for (int i = 0; i < j.length; i++) {
+                    if (j[i].getName().indexOf("getDeclaredClasses_a") != -1) {
+                        result = -1;
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+
+    public class getDeclaredClassestest1 {
+    }
+
+    private class getDeclaredClassestest2 {
+    }
+
+    protected class getDeclaredClassestest3 {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java b/test/testsuite/ouroboros/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java
new file mode 100755
index 0000000000000000000000000000000000000000..1a93bbe60490b946268dcdc929f69f8baefb0059
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java
@@ -0,0 +1,58 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredField1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredField1.java
+ *- @Title/Destination: Class.GetDeclaredField() Returns a Field object that reflects the specified declared field of
+ *                      the class or interface represented by this Class object.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Create a test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Check that return field objects are correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredField1.java
+ *- @ExecuteClass: ReflectionGetDeclaredField1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetDeclaredField1 {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+
+public class ReflectionGetDeclaredField1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("GetDeclaredField1");
+            Field zhu1 = zqp.getDeclaredField("i");
+            Field zhu2 = zqp.getDeclaredField("s");
+            Field zhu3 = zqp.getDeclaredField("d");
+            Field zhu4 = zqp.getDeclaredField("f");
+            if (zhu1.getName().equals("i") && zhu2.getName().equals("s") && zhu3.getName().equals("d") &&
+                    zhu4.getName().equals("f")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            result = -1;
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java b/test/testsuite/ouroboros/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..8f87de6ac591191e6764628b6abacb13d2ef8f2d
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredFieldNullPointerException.
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredFieldNullPointerException.java
+ *- @Title/Destination: Class.GetDeclaredField(null) throws NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Create two test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Test Class.GetDeclaredField() with null parameter.
+ * -#step4: Check that NullPointerException was threw.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredFieldNullPointerException.java
+ *- @ExecuteClass: ReflectionGetDeclaredFieldNullPointerException
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetDeclaredField2_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+
+class GetDeclaredField2 extends GetDeclaredField2_a {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+
+public class ReflectionGetDeclaredFieldNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("GetDeclaredField2");
+            Field zhu1 = zqp.getDeclaredField("i_a");
+            result = -1;
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        } catch (NoSuchFieldException e3) {
+            try {
+                Class zqp = Class.forName("GetDeclaredField2");
+                Field zhu1 = zqp.getDeclaredField(null);
+                result = -1;
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                result = -1;
+            } catch (NoSuchFieldException e5) {
+                System.err.println(e5);
+                result = -1;
+            } catch (NullPointerException e6) {
+                result = 0;
+            }
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java b/test/testsuite/ouroboros/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java
new file mode 100755
index 0000000000000000000000000000000000000000..8cf8d260e4df56fd586ec710a6106e70153e0981
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java
@@ -0,0 +1,61 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredFields1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredFields1.java
+ *- @Title/Destination: Class.GetDeclaredFields() returns an array of Field objects reflecting all the fields declared
+ *                      by the class or interface represented by this Class object. This includes public, protected,
+ *                      default (package) access, and private fields, but excludes inherited fields.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Create test classes and interface.
+ * -#step2: Use classloader to load class.
+ * -#step3: Check that return Field objects array correctly by calling GetDeclaredFields().
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredFields1.java
+ *- @ExecuteClass: ReflectionGetDeclaredFields1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetDeclaredFields1_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+
+class GetDeclaredFields1 extends GetDeclaredFields1_a {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+
+interface GetDeclaredFields1_b {
+    public int i_b = 2;
+    String s_b = "ccc";
+}
+
+public class ReflectionGetDeclaredFields1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("GetDeclaredFields1");
+            Class zqp2 = Class.forName("GetDeclaredFields1_b");
+            Field[] j = zqp1.getDeclaredFields();
+            Field[] k = zqp2.getDeclaredFields();
+            if (j.length == 4 && k.length == 2) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java b/test/testsuite/ouroboros/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java
new file mode 100755
index 0000000000000000000000000000000000000000..d0835a60fd439ad4f0f926a2b8532bad62cf7458
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java
@@ -0,0 +1,56 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredFields
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredFields.java
+ *- @Title/Destination: Class.getDeclaredFields() returns an array of Field objects reflecting all the fields declared
+ *                      by the class or interface represented by this Class object. This includes public, protected,
+ *                      default (package) access, and private fields, but excludes inherited fields.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Create test classes and enum.
+ * -#step2: Use classloader to load class.
+ * -#step3: Check that return Field objects array  which exclude inherited fields which  by calling GetDeclaredFields().
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredFields.java
+ *- @ExecuteClass: ReflectionGetDeclaredFields
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetDeclaredFields_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+
+class GetDeclaredFields extends GetDeclaredFields_a {
+}
+
+enum GetDeclaredFields_b {
+    i_b, s_b, f_b
+}
+
+public class ReflectionGetDeclaredFields {
+    public static void main(String[] args) {
+        int result = 0;
+        try {
+            Class zqp1 = Class.forName("GetDeclaredFields");
+            Class zqp2 = Class.forName("GetDeclaredFields_b");
+            Field[] j = zqp1.getDeclaredFields();
+            Field[] k = zqp2.getDeclaredFields();
+            if (j.length == 0 && k.length == 4) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java b/test/testsuite/ouroboros/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java
new file mode 100755
index 0000000000000000000000000000000000000000..54545d676ea91122b5f7f44bb0f501a11beb3d39
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredMethod1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredMethod1.java
+ *- @Title/Destination: Class.getDeclaredMethod() Returns a Method object that reflects the specified declared method
+ *                      of the class or interface represented by this Class object.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获得GetDeclaredMethod1类的运行时类clazz；
+ * -#step2: 分别以（"empty1", int.class）、"getDd"、"empty1"、"empty2"、"getZero"和（"getZero", String.class）为参数，通过
+ *          clazz的getDeclaredMethod()方法，获取Method类的不同的方法对象method1、method2、method3、method4、method5、method6；
+ * -#step3: 确定step2中的方法对象method1、method2、method3、method4、method5、method6获取成功，并且分别是
+ *          GetDeclaredMethod1类的指定的声明方法。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredMethod1.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethod1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetDeclaredMethod1 {
+    public void empty1() {
+    }
+
+    void empty2() {
+    }
+
+    int getZero() {
+        return 0;
+    }
+
+    private String getDd() {
+        return "dd";
+    }
+
+    public void empty1(int number) {
+    }
+
+    int getZero(String name) {
+        return 2;
+    }
+}
+
+public class ReflectionGetDeclaredMethod1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethod1");
+            Method method1 = clazz.getDeclaredMethod("empty1", int.class);
+            Method method2 = clazz.getDeclaredMethod("getDd");
+            Method method3 = clazz.getDeclaredMethod("empty1");
+            Method method4 = clazz.getDeclaredMethod("empty2");
+            Method method5 = clazz.getDeclaredMethod("getZero");
+            Method method6 = clazz.getDeclaredMethod("getZero", String.class);
+            if (method1.toString().equals("public void GetDeclaredMethod1.empty1(int)")
+                    && method2.toString().equals("private java.lang.String GetDeclaredMethod1.getDd()")
+                    && method3.toString().equals("public void GetDeclaredMethod1.empty1()")
+                    && method4.toString().equals("void GetDeclaredMethod1.empty2()")
+                    && method5.toString().equals("int GetDeclaredMethod1.getZero()")
+                    && method6.toString().equals("int GetDeclaredMethod1.getZero(java.lang.String)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java b/test/testsuite/ouroboros/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java
new file mode 100755
index 0000000000000000000000000000000000000000..1ba2cf3a0157ec2838012cd749050ef6fda501aa
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java
@@ -0,0 +1,87 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredMethod2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredMethod2.java
+ *- @Title/Destination: Class.getDeclaredMethod() throws NoSuchMethodException when expected method not found in class;
+ *                      Class.getDeclaredMethod(null) throws NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaredMethod2类的运行时类clazz1；
+ * -#step2: 以empty1为参数，尝试通过getDeclaredMethod()方法尝试获取clazz1的方法对象并记为method1；
+ * -#step3: 通过Class.forName()方法获取GetDeclaredMethod2类的运行时类clazz2；
+ * -#step4: 以null为参数，尝试通过getDeclaredMethod()方法尝试获取clazz2的方法对象并记为method2；
+ * -#step5: method1和method2获取失败，并且会抛出NullPointerException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredMethod2.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethod2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetDeclaredMethod2_a {
+    public void empty1() {
+    }
+
+    public void empty2() {
+    }
+}
+
+class GetDeclaredMethod2 extends GetDeclaredMethod2_a {
+    public void void1() {
+    }
+
+    void void2() {
+    }
+
+    int getZero() {
+        return 0;
+    }
+
+    private String getDd() {
+        return "dd";
+    }
+
+    public void setNumber(int number) {
+    }
+
+    int setName(String name) {
+        return 2;
+    }
+}
+
+public class ReflectionGetDeclaredMethod2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetDeclaredMethod2");
+            Method method1 = clazz1.getDeclaredMethod("empty1");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            try {
+                Class clazz2 = Class.forName("GetDeclaredMethod2");
+                Method method2 = clazz2.getDeclaredMethod(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchMethodException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java b/test/testsuite/ouroboros/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java
new file mode 100755
index 0000000000000000000000000000000000000000..c1eb9c8fa6a446b833381c4c2a5bd74abe54dbe6
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java
@@ -0,0 +1,52 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredMethod3
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredMethod3.java
+ *- @Title/Destination: Class.getDeclaredMethod() can return abstract methods of target class
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaredMethod3类的运行时类clazz；
+ * -#step2: 以aa为参数，通过getDeclaredMethod()方法获取clazz的方法对象method1；同理，以bb为参数，通过getMethod()方法获取
+ *          clazz的方法对象method2；
+ * -#step3: 确定method1和method2获取成功，并且是GetDeclaredMethod3类的指定的运行方法；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredMethod3.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethod3
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+abstract class GetDeclaredMethod3 {
+    abstract void empty1();
+    abstract public int empty2();
+}
+
+public class ReflectionGetDeclaredMethod3 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethod3");
+            Method method1 = clazz.getDeclaredMethod("empty1");
+            Method method2 = clazz.getMethod("empty2");
+            if (method1.toString().equals("abstract void GetDeclaredMethod3.empty1()")
+                    && method2.toString().equals("public abstract int GetDeclaredMethod3.empty2()")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java b/test/testsuite/ouroboros/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java
new file mode 100755
index 0000000000000000000000000000000000000000..98f2d94027e15f558be858c59bc6e54d36d3144f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java
@@ -0,0 +1,84 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredMethods1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredMethods1.java
+ *- @Title/Destination: Class.GetDeclaredMethods returns an array containing Method objects reflecting all the declared
+ *                      methods of the class or interface represented by this Class object, including public, protected,
+  *                     default (package) access, and private methods. If class has multiple declared methods with the
+  *                     same name and parameter types but different return types, each method will be returned.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaredMethods1类的运行时类clazz1；
+ * -#step2: 通过Class.forName()方法获取GetDeclaredMethods1_b类的运行时类clazz2；
+ * -#step3: 通过getDeclaredMethods()方法，分别获取clazz1、clazz2的所有的方法对象，返回值分别为methods1和methods2；
+ * -#step4: 确定step3中methods1和methods2都成功获取，即成功获取到clazz1、clazz2的所有的方法对象，并且methods1、methods2
+ *          的长度分别为6和2。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredMethods1.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethods1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetDeclaredMethods1_a {
+    public void empty1() {
+    }
+
+    public void empty2() {
+    }
+}
+
+class GetDeclaredMethods1 extends GetDeclaredMethods1_a {
+    public void void1() {
+    }
+
+    void void2() {
+    }
+
+    int getZero() {
+        return 0;
+    }
+
+    private String getDd() {
+        return "dd";
+    }
+
+    public void setNumber(int number) {
+    }
+
+    int setName(String name) {
+        return 2;
+    }
+}
+
+interface GetDeclaredMethods1_b {
+    public default void test1() {
+    }
+
+    default void test2() {
+    }
+}
+
+public class ReflectionGetDeclaredMethods1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetDeclaredMethods1");
+            Class clazz2 = Class.forName("GetDeclaredMethods1_b");
+            Method[] methods1 = clazz1.getDeclaredMethods();
+            Method[] methods2 = clazz2.getDeclaredMethods();
+            if (methods1.length == 6 && methods2.length == 2) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java b/test/testsuite/ouroboros/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java
new file mode 100755
index 0000000000000000000000000000000000000000..7814e27040e8161317f8c5e4f1cdae7f11c4ff7e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java
@@ -0,0 +1,49 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaredMethods2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaredMethods2.java
+ *- @Title/Destination: Class.getDeclaredMethods() does not return inherited methods.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaredMethods2类的运行时类clazz；
+ * -#step2: 通过getDeclaredMethods()方法获取clazz的所有的方法对象，返回值为一个数组，并记为method；
+ * -#step3: 确定method的长度为0，即返回的数组为空，证明通过getDeclaredMethods()方法不返回继承的方法。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaredMethods2.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethods2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetDeclaredMethods2_a {
+    public void empty1() {
+    }
+
+    public void empty2() {
+    }
+}
+
+class GetDeclaredMethods2 extends GetDeclaredMethods2_a {
+}
+
+public class ReflectionGetDeclaredMethods2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethods2");
+            Method[] method = clazz.getDeclaredMethods();
+            if (method.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java b/test/testsuite/ouroboros/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f25662ff50e5568f5898b2a367a401caa36fcc1
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID: ReflectionGetDeclaringClass
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetDeclaringClass.java
+ *- @Title/Destination: If the class or interface represented by this Class object is a member of another class,
+ *                      Class.GetDeclaringClass() returns the Class object representing the class in which it was
+ *                      declared. This method returns null if this class or interface is not a member of any other class.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaringClass类的运行时类clazz；
+ * -#step2: 通过getDeclaredFields()方法获取clazz的所有的成员，返回值为一个数组记为fields；
+ * -#step3: 通过getDeclaredConstructors()方法获取clazz的所有的构造方法，返回值为一个数组记为constructors；
+ * -#step4: 对于num < fields.length，fields[i].getDeclaringClass().getName()的返回值与GetDeclaringClass类是同一类型，同时
+ *          对于str < constructors.length，constructors[s].getDeclaringClass().getName()的返回值与GetDeclaringClass类是同
+ *          一类型；
+ * -#step5: 在step4的基础上，通过Class.forName()方法获取GetDeclaringClass_a类的运行时类clazz2，并且通过
+ *          clazz2.getDeclaringClass()的返回值均为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetDeclaringClass.java
+ *- @ExecuteClass: ReflectionGetDeclaringClass
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
+class GetDeclaringClass {
+    public int num;
+    String str;
+    float fNum;
+
+    public GetDeclaringClass() {
+    }
+
+    GetDeclaringClass(int number) {
+    }
+
+    GetDeclaringClass(String name) {
+    }
+
+    GetDeclaringClass(int number, String name) {
+    }
+}
+
+class GetDeclaringClass_a {
+}
+
+public class ReflectionGetDeclaringClass {
+    public static void main(String[] args) {
+        try {
+            int num = 0;
+            Class clazz = Class.forName("GetDeclaringClass");
+            Field[] fields = clazz.getDeclaredFields();
+            Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+            for (int i = 0; i < fields.length; i++) {
+                if (fields[i].getDeclaringClass().getName().equals("GetDeclaringClass")) {
+                    for (int j = 0; j < constructors.length; j++) {
+                        if (constructors[j].getDeclaringClass().getName().equals("GetDeclaringClass")) {
+                            Class clazz2 = Class.forName("GetDeclaringClass_a");
+                            if (clazz2.getDeclaringClass() == null) {
+                                num++;
+                            }
+                        }
+                    }
+                }
+            }
+            if (num == 12) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/ReflectionGetEnclosingClass1.java b/test/testsuite/ouroboros/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/ReflectionGetEnclosingClass1.java
new file mode 100755
index 0000000000000000000000000000000000000000..4f605b4306043958b40fd0131457c9f4129498a4
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/ReflectionGetEnclosingClass1.java
@@ -0,0 +1,49 @@
+/*
+ *- @TestCaseID: ReflectionGetEnclosingClass1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetEnclosingClass1.java
+ *- @Title/Destination: Class.getEnclosingClass() Get the immediately enclosing class of the underlying class by
+ *                      reflection.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过(new GetEnclosingClassTest1()).test1().getClass()获取ReflectionGetEnclosingClass1类的内部类
+ *          GetEnclosingClassTest1类并记为clazz1；
+ * -#step2: 通过(new GetEnclosingClassTest1()).test2().getClass()获取ReflectionGetEnclosingClass1类的内部类
+ *          GetEnclosingClassTest1类并记为clazz2；
+ * -#step3: 确定step1和step2中成功获取到ReflectionGetEnclosingClass1类的两个内部类clazz1、clazz2；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetEnclosingClass1.java
+ *- @ExecuteClass: ReflectionGetEnclosingClass1
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionGetEnclosingClass1 {
+    public static void main(String[] args) {
+        Class clazz1 = (new GetEnclosingClassTest1()).test1().getClass();
+        Class clazz2 = (new GetEnclosingClassTest1()).test2().getClass();
+        if (clazz1.getEnclosingClass().getName().equals("ReflectionGetEnclosingClass1$GetEnclosingClassTest1")
+                && clazz2.getEnclosingClass().getName().equals("ReflectionGetEnclosingClass1$GetEnclosingClassTest1")) {
+            System.out.println(0);
+        }
+    }
+
+    public static class GetEnclosingClassTest1 {
+        public Object test1() {
+            class classA {
+            }
+            return new classA();
+        }
+
+        Object test2() {
+            class classB {
+            }
+            return new classB();
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/ReflectionGetEnclosingClass2.java b/test/testsuite/ouroboros/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/ReflectionGetEnclosingClass2.java
new file mode 100755
index 0000000000000000000000000000000000000000..1df5a384fa4869563df93fc8190d9e7d9e6b2c06
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/ReflectionGetEnclosingClass2.java
@@ -0,0 +1,52 @@
+/*
+ *- @TestCaseID: ReflectionGetEnclosingClass2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetEnclosingClass2.java
+ *- @Title/Destination: Returns null if the underlying class is a top-level class.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetEnclosingClassTest2类的运行时类clazz1；
+ * -#step2: 通过(new GetEnclosingClassTest2()).test2().getClass()获取GetEnclosingClassTest2类的内部类classB类并记
+ *          为clazz2；
+ * -#step3: 通过clazz1.getEnclosingClass()的返回值为null，而通过clazz2.getEnclosingClass().getName()的返回值的类型
+ *          与GetEnclosingClassTest2类相同；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetEnclosingClass2.java
+ *- @ExecuteClass: ReflectionGetEnclosingClass2
+ *- @ExecuteArgs:
+ */
+
+class GetEnclosingClassTest2 {
+    public Object test1() {
+        class classA {
+        }
+        return new classA();
+    }
+
+    Object test2() {
+        class classB {
+        }
+        return new classB();
+    }
+}
+
+public class ReflectionGetEnclosingClass2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetEnclosingClassTest2");
+            Class clazz2 = (new GetEnclosingClassTest2()).test2().getClass();
+            if (clazz1.getEnclosingClass() == null
+                    && clazz2.getEnclosingClass().getName().equals("GetEnclosingClassTest2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java b/test/testsuite/ouroboros/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java
new file mode 100755
index 0000000000000000000000000000000000000000..af01f5ce55ddd1eac41384bbd7106c4f6041f0d7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java
@@ -0,0 +1,102 @@
+/*
+ *- @TestCaseID: ReflectionGetEnumConstants
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetEnumConstants.java
+ *- @Title/Destination: Returns an array of the values of the enumeration classes that are represented in the order
+ *                      declared by this class object.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法分别获取Weekday类、GetEnumConstants类的运行时类clazz1、clazz2；
+ * -#step2: 分别通过clazz1.getEnumConstants()和clazz2.getEnumConstants()获取枚举类的数组并记为objects1、objects2；
+ * -#step3: 确定step2中成功获取到枚举类数组objects1、objects2，并且objects1数组的长度为7，objects2数组为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetEnumConstants.java
+ *- @ExecuteClass: ReflectionGetEnumConstants
+ *- @ExecuteArgs:
+ */
+
+enum Weekday {
+    MONDAY {
+        Object test1() {
+            class classA {
+            }
+
+            return new classA();
+        }
+    },
+    TUESDAY {
+        Object test2() {
+            class classB {
+            }
+
+            return new classB();
+        }
+    },
+    WEDNESDAY {
+        Object test3() {
+            class classC {
+            }
+
+            return new classC();
+        }
+    },
+    THURSDAY {
+        Object test4() {
+            class classD {
+            }
+
+            return new classD();
+        }
+    },
+    FRIDAY {
+        Object test5() {
+            class classE {
+            }
+
+            return new classE();
+        }
+    },
+    SATURDAY {
+        Object test6() {
+            class classF {
+            }
+
+            return new classF();
+        }
+    },
+    SUNDAY {
+        Object test7() {
+            class classG {
+            }
+
+            return new classG();
+        }
+    }
+}
+
+class GetEnumConstants {
+}
+
+public class ReflectionGetEnumConstants {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("Weekday");
+            Class clazz2 = Class.forName("GetEnumConstants");
+            Object[] objects1 = clazz1.getEnumConstants();
+            Object[] objects2 = clazz2.getEnumConstants();
+            if (objects1.length == 7) {
+                if (objects2 == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0048-rt-compact-ReflectiongetField1/ReflectionGetField1.java b/test/testsuite/ouroboros/compact_test/RT0048-rt-compact-ReflectiongetField1/ReflectionGetField1.java
new file mode 100755
index 0000000000000000000000000000000000000000..178e1457a5aee709fbcad4f7dd12bdb4e818d952
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0048-rt-compact-ReflectiongetField1/ReflectionGetField1.java
@@ -0,0 +1,58 @@
+/*
+ *- @TestCaseID: ReflectionGetField1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetField1.java
+ *- @Title/Destination: Class.getField() returns a Field object that reflects the specified public member field,
+ *                      including the inherited public fields.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetField1类的运行时类clazz；
+ * -#step2: 分别以num、str为参数，通过getField()方法分别获取GetField1类、GetField1_a类的公共字段并记为field1、field2；
+ * -#step3: 确定step2中成功获取到两个字段field1、field2，并且field1等于i，field2等于str。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetField1.java
+ *- @ExecuteClass: ReflectionGetField1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetField1_a {
+    int num2 = 5;
+    public String str = "bbb";
+}
+
+class GetField1 extends GetField1_a {
+    public int num = 1;
+    String string = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+
+public class ReflectionGetField1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetField1");
+            Field field1 = clazz.getField("num");
+            Field field2 = clazz.getField("str");
+            if (field1.getName().equals("num") && field2.getName().equals("str")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0049-rt-compact-ReflectiongetField2/ReflectionGetField2.java b/test/testsuite/ouroboros/compact_test/RT0049-rt-compact-ReflectiongetField2/ReflectionGetField2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1c1d69566da5a6244165dd54bfdf0d81fadb123
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0049-rt-compact-ReflectiongetField2/ReflectionGetField2.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID: ReflectionGetField2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetField2.java
+ *- @Title/Destination: If expected Field not found, throws NoSuchFieldException; Class.getField(null) throws
+ *                      NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetField2类的运行时类clazz1；
+ * -#step2: 以s为参数，通过getField()方法尝试获取GetField2类的default类型的字段并记为field1；
+ * -#step3: 通过Class.forName()方法获取GetField2类的运行时类clazz2；
+ * -#step4: 以null为参数，通过getField()方法尝试获取GetField2类的字段并记为field2；
+ * -#step5: 确定step2和step4中field1、field2获取失败，并且会抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetField2.java
+ *- @ExecuteClass: ReflectionGetField2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetField2_a {
+    int num = 5;
+    public String str = "bbb";
+}
+
+class GetField2 extends GetField2_a {
+    public int num = 1;
+    String str2 = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+
+public class ReflectionGetField2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetField2");
+            Field field1 = clazz1.getField("str2");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            try {
+                Class clazz2 = Class.forName("GetField2");
+                Field field2 = clazz2.getField(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchFieldException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0050-rt-compact-ReflectiongetFields/ReflectionGetFields.java b/test/testsuite/ouroboros/compact_test/RT0050-rt-compact-ReflectiongetFields/ReflectionGetFields.java
new file mode 100755
index 0000000000000000000000000000000000000000..b35823bb4694f2b1f729788fbb9f7763946cbf9d
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0050-rt-compact-ReflectiongetFields/ReflectionGetFields.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ReflectionGetFields
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetFields.java
+ *- @Title/Destination: Class.GetFields() returns an array containing Field objects reflecting all the accessible public
+  *                     fields of the class or interface represented by this Class object. Including inherited public
+  *                     fields.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法分别获取GetFields类、GetFields_b类、GetFields_c类的运行时类clazz1、clazz2、clazz3；
+ * -#step2: 通过getFields()方法分别获取clazz1、clazz2、clazz3的所有可访问的公共字段并记为fields1、fields2、fields3；
+ * -#step3: 确定step2中fields1、fields2、fields3获取成功，并且fields1和fields2的长度为2，fields的长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetFields.java
+ *- @ExecuteClass: ReflectionGetFields
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetFields_a {
+    public int num = 5;
+    String str = "bbb";
+}
+
+class GetFields extends GetFields_a {
+    public int num = 1;
+    String str = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+
+interface GetFields_b {
+    public int num = 2;
+    String str = "ccc";
+}
+
+class GetFields_c {
+}
+
+public class ReflectionGetFields {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetFields");
+            Class clazz2 = Class.forName("GetFields_b");
+            Class clazz3 = Class.forName("GetFields_c");
+            Field[] fields1 = clazz1.getFields();
+            Field[] fields2 = clazz2.getFields();
+            Field[] fields3 = clazz3.getFields();
+            if (fields1.length == 2 && fields2.length == 2 && fields3.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0051-rt-compact-ReflectiongetMethod1/ReflectionGetMethod1.java b/test/testsuite/ouroboros/compact_test/RT0051-rt-compact-ReflectiongetMethod1/ReflectionGetMethod1.java
new file mode 100755
index 0000000000000000000000000000000000000000..2d4330ae2897a22c451b8d9d3f2cbe7bb8abe8f6
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0051-rt-compact-ReflectiongetMethod1/ReflectionGetMethod1.java
@@ -0,0 +1,85 @@
+/*
+ *- @TestCaseID: ReflectionGetMethod1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetMethod1.java
+ *- @Title/Destination: Class.getMethod Returns a Method object that reflects the specified public member method of the
+ *                      class or interface represented by this Class object. Include inherited public methods.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetMethod1类的运行时类clazz；
+ * -#step2: 分别以empty、（empty，int.class）、（setName，String.class）、getStr为参数，获取clazz的指定的公共成员方法并记为
+ *          method1、method2、method3、method4；
+ * -#step3: 确定step2中成功获取到method1、method2、method3、method4，并且正好是GetMethod1类的指定的公共成员方法；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetMethod1.java
+ *- @ExecuteClass: ReflectionGetMethod1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetMethod1_a {
+    public int setName(String name) {
+        return 10;
+    }
+
+    public String getStr() {
+        return "getDda";
+    }
+}
+
+class GetMethod1 extends GetMethod1_a {
+    public void empty() {
+    }
+
+    void emptyB() {
+    }
+
+    int getNum() {
+        return 0;
+    }
+
+    private String getDd() {
+        return "getDd";
+    }
+
+    public void empty(int number) {
+    }
+
+    int getNum(String name) {
+        return 2;
+    }
+}
+
+public class ReflectionGetMethod1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetMethod1");
+            Method method1 = clazz.getMethod("empty");
+            Method method2 = clazz.getMethod("empty", int.class);
+            Method method3 = clazz.getMethod("setName", String.class);
+            Method method4 = clazz.getMethod("getStr");
+            if (method1.toString().equals("public void GetMethod1.empty()")
+                    && method2.toString().equals("public void GetMethod1.empty(int)")
+                    && method3.toString().equals("public int GetMethod1_a.setName(java.lang.String)")
+                    && method4.toString().equals("public java.lang.String GetMethod1_a.getStr()")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0052-rt-compact-ReflectiongetMethod2/ReflectionGetMethod2.java b/test/testsuite/ouroboros/compact_test/RT0052-rt-compact-ReflectiongetMethod2/ReflectionGetMethod2.java
new file mode 100755
index 0000000000000000000000000000000000000000..f478a317423f0510dcc1b158a183aecc17e2efa2
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0052-rt-compact-ReflectiongetMethod2/ReflectionGetMethod2.java
@@ -0,0 +1,91 @@
+/*
+ *- @TestCaseID: ReflectionGetMethod2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetMethod2.java
+ *- @Title/Destination: If expected method is not found, getMethod throws NoSuchMethodException; Class.getMethod(NULL)
+ *                      throws NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetMethod2类的运行时类clazz1；
+ * -#step2: 以empty为参数，通过getMethod()方法获取clazz1的公共成员方法并记为method1；
+ * -#step3: 通过Class.forName()方法获取GetMethod2类的运行时类clazz2；
+ * -#step4: 以null为参数，通过getMethod()方法获取clazz2的公共成员方法并记为method2；
+ * -#step5: 确定step2和step4中的method1、method2获取失败，并且会抛出NullPointerException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetMethod2.java
+ *- @ExecuteClass: ReflectionGetMethod2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetMethod2_a {
+    public int getName(String name) {
+        return 10;
+    }
+
+    public String getString() {
+        return "dda";
+    }
+}
+
+class GetMethod2 extends GetMethod2_a {
+    public void getVoid() {
+    }
+
+    void empty() {
+    }
+
+    int getZero() {
+        return 0;
+    }
+
+    private String getStr() {
+        return "dd";
+    }
+
+    public void setNum(int number) {
+    }
+
+    int getSecondNum(String name) {
+        return 2;
+    }
+}
+
+public class ReflectionGetMethod2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetMethod2");
+            Method method1 = clazz1.getMethod("empty");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            // NoSuchMethodException is thrown when method not exist.
+            try {
+                Class clazz2 = Class.forName("GetMethod2");
+                Method method2 = clazz2.getMethod(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchMethodException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                // Expected result: NullPointerException is thrown when method is null.
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0053-rt-compact-ReflectiongetSigners/ReflectionGetSigners.java b/test/testsuite/ouroboros/compact_test/RT0053-rt-compact-ReflectiongetSigners/ReflectionGetSigners.java
new file mode 100755
index 0000000000000000000000000000000000000000..e3f7cea41037a8dae35e18e70844cad3396dbca6
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0053-rt-compact-ReflectiongetSigners/ReflectionGetSigners.java
@@ -0,0 +1,38 @@
+/*
+ *- @TestCaseID: ReflectionGetSigners
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetSigners.java
+ *- @Title/Destination: Gets the signers of this class.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetSigners类的运行时类clazz；
+ * -#step2: 通过getSigners()方法获取clazz的所有的标签并记为objects；
+ * -#step3: 确定step2中成功获取到objects，并且objects等于null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetSigners.java
+ *- @ExecuteClass: ReflectionGetSigners
+ *- @ExecuteArgs:
+ */
+
+class GetSigners {
+}
+
+public class ReflectionGetSigners {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetSigners");
+            Object[] objects = clazz.getSigners();
+            if (objects == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/ReflectionGetSimpleName.java b/test/testsuite/ouroboros/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/ReflectionGetSimpleName.java
new file mode 100755
index 0000000000000000000000000000000000000000..cca2066d3ba9d8746f45f7945db7bf8c80c7169c
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/ReflectionGetSimpleName.java
@@ -0,0 +1,38 @@
+/*
+ *- @TestCaseID: ReflectionGetSimpleName
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetSimpleName.java
+ *- @Title/Destination: Returns the simple name of the underlying class as given in the source code.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetSimpleName类的运行时类clazz；
+ * -#step2: 通过getSimpleName()方法获取clazz的类名并记为string；
+ * -#step3: 确定step2中成功获取到string并且其类型与GetSimpleName类是同一类型；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetSimpleName.java
+ *- @ExecuteClass: ReflectionGetSimpleName
+ *- @ExecuteArgs:
+ */
+
+class GetSimpleName {
+}
+
+public class ReflectionGetSimpleName {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetSimpleName");
+            String string = clazz.getSimpleName();
+            if (string.equals("GetSimpleName")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/ReflectionGetTypeParameters.java b/test/testsuite/ouroboros/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/ReflectionGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..1f32cb2557471b10eeecf56993ad7d4a50a03d56
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/ReflectionGetTypeParameters.java
@@ -0,0 +1,43 @@
+/*
+ *- @TestCaseID: ReflectionGetTypeParameters
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionGetTypeParameters.java
+ *- @Title/Destination: getTypeParameters() returns an array of TypeVariable objects that represent the type variables
+ *                      declared by the generic declaration represented by this GenericDeclaration object, in
+ *                      declaration order.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetTypeParameters类的运行时类clazz；
+ * -#step2: 通过getTypeParameters()方法获取clazz的可变类型参数的数组并记为typeParameters；
+ * -#step3: 确定step2中成功获取到typeParameters，并且typeParameters的长度为2，其第一个参数与“s”相同，第二个参数与“T”相同；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionGetTypeParameters.java
+ *- @ExecuteClass: ReflectionGetTypeParameters
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.TypeVariable;
+
+class GetTypeParameters<s, T> {
+}
+
+public class ReflectionGetTypeParameters {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetTypeParameters");
+            TypeVariable[] typeParameters = clazz.getTypeParameters();
+            if (typeParameters.length == 2 && typeParameters[0].getName().equals("s")
+                    && typeParameters[1].getName().equals("T")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0056-rt-compact-ReflectionisArray/ReflectionIsArray.java b/test/testsuite/ouroboros/compact_test/RT0056-rt-compact-ReflectionisArray/ReflectionIsArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..8b1e7002358b0ba7d70012c48657cc6f1bf437f0
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0056-rt-compact-ReflectionisArray/ReflectionIsArray.java
@@ -0,0 +1,47 @@
+/*
+ *- @TestCaseID: ReflectionIsArray
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionIsArray.java
+ *- @Title/Destination: Determines if this Class object represents an array class.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取IsArray类的运行时类clazz；
+ * -#step2: 通过getDeclaredFields()方法获取clazz的所有的声明的字段并记为fields；
+ * -#step3: 通过fields.getClass()获取当前的运行时类并记为clazz1；
+ * -#step4: 确定step1和step3成功获取clazz和clazz1，并且clazz1是一个数组，而clazz不是一个数组。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionIsArray.java
+ *- @ExecuteClass: ReflectionIsArray
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class IsArray {
+    public int num;
+    String str;
+    float fNum;
+}
+
+public class ReflectionIsArray {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("IsArray");
+            Field[] fields = clazz.getDeclaredFields();
+            Class clazz1 = fields.getClass();
+            if (clazz1.isArray()) {
+                if (!clazz.isArray()) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java b/test/testsuite/ouroboros/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java
new file mode 100755
index 0000000000000000000000000000000000000000..e54ba81b58325f560d1b77646df14c3903c8d0ac
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java
@@ -0,0 +1,51 @@
+/*
+ *- @TestCaseID: ReflectionIsAssignableFrom1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionIsAssignableFrom1.java
+ *- @Title/Destination: Class.isAssignableFrom(cls) return true when Class is superclass of cls.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法分别获取AssignableFrom1类、AssignableFrom1_a类、AssignableFromTest1类和
+ *          AssignableFromTest1_a类的运行时类并记为clazz1、clazz2、clazz3、clazz4；
+ * -#step2: 调用isAssignableFrom确定step1中成功获取到clazz1、clazz2、clazz3、clazz4并且clazz1是clazz2的父类，而clazz2不是
+ *          clazz1的父类；同理，clazz3是clazz4的父类，clazz4不是clazz3的父类；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionIsAssignableFrom1.java
+ *- @ExecuteClass: ReflectionIsAssignableFrom1
+ *- @ExecuteArgs:
+ */
+
+class AssignableFrom1 {
+}
+
+class AssignableFrom1_a extends AssignableFrom1 {
+}
+
+interface AssignableFromTest1 {
+}
+
+interface AssignableFromTest1_a extends AssignableFromTest1 {
+}
+
+public class ReflectionIsAssignableFrom1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("AssignableFrom1");
+            Class clazz2 = Class.forName("AssignableFrom1_a");
+            Class clazz3 = Class.forName("AssignableFromTest1");
+            Class clazz4 = Class.forName("AssignableFromTest1_a");
+            if (clazz1.isAssignableFrom(clazz2) && !clazz2.isAssignableFrom(clazz1) && clazz3.isAssignableFrom(clazz4)
+                    && !clazz4.isAssignableFrom(clazz3)) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java b/test/testsuite/ouroboros/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..5c4eaa62ebb704115d7a965af166b41d9bc8a717
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java
@@ -0,0 +1,40 @@
+/*
+ *- @TestCaseID: ReflectionIsAssignableFromNullPointerException
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionIsAssignableFromNullPointerException.java
+ *- @Title/Destination: Class.isAssignableFrom(null) throws NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Use classloader load class.
+ * -#step2: Test Class.isAssignableFrom() whit null param.
+ * -#step3: Check that NullPointerException occurs when Class.isAssignableFrom()'s is null.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionIsAssignableFromNullPointerException.java
+ *- @ExecuteClass: ReflectionIsAssignableFromNullPointerException
+ *- @ExecuteArgs:
+ */
+
+class AssignableFromNullPointerException {
+}
+
+public class ReflectionIsAssignableFromNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("AssignableFromNullPointerException");
+            zqp1.isAssignableFrom(null);
+            result = -1;
+        } catch (ClassNotFoundException e1) {
+            result = -1;
+        } catch (NullPointerException e2) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0059-rt-compact-ReflectionisLocalClass/ReflectionIsLocalClass.java b/test/testsuite/ouroboros/compact_test/RT0059-rt-compact-ReflectionisLocalClass/ReflectionIsLocalClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..53c66b5044839f617db2940d807e32e497d942e3
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0059-rt-compact-ReflectionisLocalClass/ReflectionIsLocalClass.java
@@ -0,0 +1,59 @@
+/*
+ *- @TestCaseID: ReflectionIsLocalClass
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionIsLocalClass.java
+ *- @Title/Destination: isLocalClass() returns true if and only if the underlying class is a local class(defined in the
+ *                      body of a method)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Define a class in method and two class out of the method.
+ * -#step2: Get Class object of the class.
+ * -#step3: Test isLocalClass() with different the Class object of the class.
+ * -#step4: Check that isLocalClass() identifies local class correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionIsLocalClass.java
+ *- @ExecuteClass: ReflectionIsLocalClass
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionIsLocalClass {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        class isLocalClass {
+        }
+        try {
+            Class zqp1 = isLocalClass.class;
+            Class zqp2 = Class.forName("ReflectionIsLocalClass");
+            Class zqp3 = IsLocalClass_a.class;
+            Class zqp4 = IsLocalClass_b.class;
+            Class zqp5 = (new isLocalClass() {
+            }).getClass();
+            if (!zqp2.isLocalClass()) {
+                if (!zqp3.isLocalClass()) {
+                    if (!zqp4.isLocalClass()) {
+                        if (!zqp5.isLocalClass()) {
+                            if (zqp1.isLocalClass()) {
+                                result = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = 2;
+        }
+        System.out.println(result);
+    }
+
+    class IsLocalClass_a {
+    }
+
+    static class IsLocalClass_b {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0060-rt-compact-ReflectionisMemberClass/ReflectionIsMemberClass.java b/test/testsuite/ouroboros/compact_test/RT0060-rt-compact-ReflectionisMemberClass/ReflectionIsMemberClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..86cd06217fd096ecbf3f8d42ec49c7a7b528fbbe
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0060-rt-compact-ReflectionisMemberClass/ReflectionIsMemberClass.java
@@ -0,0 +1,59 @@
+/*
+ *- @TestCaseID: ReflectionIsMemberClass
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionIsMemberClass.java
+ *- @Title/Destination: Class.IsMemberClass() returns true if and only if the underlying class is a member
+ *                      class(class inside another class, but not inside a method).
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Define a class in method and two inner class but not inside the method.
+ * -#step2: Get Class object of the class.
+ * -#step3: Test isMemberClass() with different the Class object of the class.
+ * -#step4: Check that isMemberClass() identifies member class correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionIsMemberClass.java
+ *- @ExecuteClass: ReflectionIsMemberClass
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionIsMemberClass {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        class IsMemberClass_a {
+        }
+        try {
+            Class zqp1 = IsMemberClass.class;
+            Class zqp2 = Class.forName("ReflectionIsMemberClass");
+            Class zqp3 = IsMemberClass_a.class;
+            Class zqp4 = IsMemberClass_b.class;
+            Class zqp5 = (new IsMemberClass_b() {
+            }).getClass();
+            if (!zqp2.isMemberClass()) {
+                if (!zqp3.isMemberClass()) {
+                    if (zqp4.isMemberClass()) {
+                        if (!zqp5.isMemberClass()) {
+                            if (zqp1.isMemberClass()) {
+                                result = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+
+    class IsMemberClass {
+    }
+
+    static class IsMemberClass_b {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0061-rt-compact-ReflectionisPrimitive/ReflectionIsPrimitive.java b/test/testsuite/ouroboros/compact_test/RT0061-rt-compact-ReflectionisPrimitive/ReflectionIsPrimitive.java
new file mode 100755
index 0000000000000000000000000000000000000000..f4fec72bc7aa715af7a67f97e8bf8206ffc3e2e7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0061-rt-compact-ReflectionisPrimitive/ReflectionIsPrimitive.java
@@ -0,0 +1,44 @@
+/*
+ *- @TestCaseID: ReflectionIsPrimitive
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionIsPrimitive.java
+ *- @Title/Destination: Determines if the specified Class object represents a primitive type.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Get nine Class Pre-defined object and a normal Class object of class.
+ * -#step2: Test isPrimitive() with the 10 primitive type object.
+ * -#step3: Check that isPrimitive() identifies primitive type of the object correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionIsPrimitive.java
+ *- @ExecuteClass: ReflectionIsPrimitive
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionIsPrimitive {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+
+        Class zqp1 = ReflectionIsPrimitive.class;
+        Class zqp2 = int.class;
+        Class zqp3 = boolean.class;
+        Class zqp4 = byte.class;
+        Class zqp5 = char.class;
+        Class zqp6 = short.class;
+        Class zqp7 = long.class;
+        Class zqp8 = float.class;
+        Class zqp9 = double.class;
+        Class zqp10 = void.class;
+        if (!zqp1.isPrimitive() && zqp2.isPrimitive() && zqp3.isPrimitive() && zqp4.isPrimitive() && zqp5.isPrimitive()
+                && zqp6.isPrimitive() && zqp7.isPrimitive() && zqp8.isPrimitive() && zqp9.isPrimitive() &&
+                zqp10.isPrimitive()) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0062-rt-compact-ReflectionisSynthetic/ReflectionIsSynthetic.java b/test/testsuite/ouroboros/compact_test/RT0062-rt-compact-ReflectionisSynthetic/ReflectionIsSynthetic.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd53aba10121544076ac0277cb5a55f3d8e3f1d1
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0062-rt-compact-ReflectionisSynthetic/ReflectionIsSynthetic.java
@@ -0,0 +1,46 @@
+/*
+ *- @TestCaseID: ReflectionIsSynthetic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionIsSynthetic.java
+ *- @Title/Destination: Returns true if this class is a synthetic class
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Define a test class IsSynthetic.
+ * -#step2: Test isSynthetic() with three different type object.
+ * -#step3: Check that isSynthetic() identifies synthetic class correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionIsSynthetic.java
+ *- @ExecuteClass: ReflectionIsSynthetic
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionIsSynthetic {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        new IsSynthetic();
+        try {
+            Class zqp1 = IsSynthetic.class;
+            Class zqp2 = int.class;
+            Class zqp3 = Class.forName("ReflectionIsSynthetic$1");
+            if (!zqp2.isSynthetic()) {
+                if (!zqp1.isSynthetic()) {
+                    if (zqp3.isSynthetic()) {
+                        result = 0;
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+
+    private static class IsSynthetic {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0063-rt-compact-ReflectionnewInstance1/ReflectionNewInstance1.java b/test/testsuite/ouroboros/compact_test/RT0063-rt-compact-ReflectionnewInstance1/ReflectionNewInstance1.java
new file mode 100755
index 0000000000000000000000000000000000000000..2ed02e3c425e1a1745843768def30687621c6ec1
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0063-rt-compact-ReflectionnewInstance1/ReflectionNewInstance1.java
@@ -0,0 +1,50 @@
+/*
+ *- @TestCaseID: ReflectionNewInstance1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionNewInstance1.java
+ *- @Title/Destination: Instantiating a class by reflection:class.newInstance() creates a new instance of the class
+ *                      represented by this Class object. The class is instantiated as if by a new expression with an
+ *                      empty argument list.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Use classloader load class.
+ * -#step2: Instantiating the class by class.newInstance().
+ * -#step3: Check that the object is  instance of class NewInstance1
+ * -#step4: Try to catch exceptions those occurs possibly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionNewInstance1.java
+ *- @ExecuteClass: ReflectionNewInstance1
+ *- @ExecuteArgs:
+ */
+
+class NewInstance1 {
+}
+
+public class ReflectionNewInstance1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("NewInstance1");
+            Object zhu = zqp.newInstance();
+            if (zhu.toString().indexOf("NewInstance1@") != -1) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0064-rt-compact-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java b/test/testsuite/ouroboros/compact_test/RT0064-rt-compact-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
new file mode 100755
index 0000000000000000000000000000000000000000..1b68acca219fb9bbd78944a0f01781996947d4e5
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0064-rt-compact-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
@@ -0,0 +1,63 @@
+/*
+ *- @TestCaseID: ReflectionNewInstanceInstantiationExceptionIllegalAccessException
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
+ *- @Title/Destination: call newInstance() on an interface object throws InstantiationException; if the class's
+ *                      constructor is not accessible, throws IllegalAccessException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Create a test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Instantiating the class by class.newInstance().
+ * -#step4: It will throw InstantiationException because we used class which dose not exit.
+ * -#step5: Then check that IllegalAccessException was threw when class constructor is not accessible.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
+ *- @ExecuteClass: ReflectionNewInstanceInstantiationExceptionIllegalAccessException
+ *- @ExecuteArgs:
+ */
+
+interface NewInstance2 {
+}
+
+class NewInstance2_a {
+    private NewInstance2_a() {
+    }
+}
+
+public class ReflectionNewInstanceInstantiationExceptionIllegalAccessException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("NewInstance2");
+            Object zhu1 = zqp1.newInstance();
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (InstantiationException e1) {
+
+            try {
+                Class zqp2 = Class.forName("NewInstance2_a");
+                Object zhu2 = zqp2.newInstance();
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                result = -1;
+            } catch (InstantiationException e4) {
+                System.err.println(e4);
+                result = -1;
+            } catch (IllegalAccessException e5) {
+                result = 0;
+            }
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0065-rt-compact-ReflectiontoGenericString/ReflectionToGenericString.java b/test/testsuite/ouroboros/compact_test/RT0065-rt-compact-ReflectiontoGenericString/ReflectionToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..2e4400cb1295ac9416db6b35fc52ef89fc957993
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0065-rt-compact-ReflectiontoGenericString/ReflectionToGenericString.java
@@ -0,0 +1,46 @@
+/*
+ *- @TestCaseID: ReflectionToGenericString
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionToGenericString.java
+ *- @Title/Destination: getGenericString() returns a string description of this class, including information about
+ *                      modifiers and type parameters.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Create a abstract test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Test getGenericString() with Class object of the test class.
+ * -#step4: Check that getGenericString() returns a string description of class information correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionToGenericString.java
+ *- @ExecuteClass: ReflectionToGenericString
+ *- @ExecuteArgs:
+ */
+
+@interface Eee {
+}
+
+@Eee
+abstract class ToGenericString<t> {
+}
+
+public class ReflectionToGenericString {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("ToGenericString");
+            String zhu = zqp.toGenericString();
+            if (zhu.equals("abstract class ToGenericString<t>")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0066-rt-compact-ReflectiontoString/ReflectionToString.java b/test/testsuite/ouroboros/compact_test/RT0066-rt-compact-ReflectiontoString/ReflectionToString.java
new file mode 100755
index 0000000000000000000000000000000000000000..52e1e762a48b3485058618118d4de79620dfb610
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0066-rt-compact-ReflectiontoString/ReflectionToString.java
@@ -0,0 +1,45 @@
+/*
+ *- @TestCaseID: ReflectionToString
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionToString.java
+ *- @Title/Destination: To obtain a class for string output by reflection.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Create a test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Test toString() by reflection.
+ * -#step4: Check that reflection result is correct.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionToString.java
+ *- @ExecuteClass: ReflectionToString
+ *- @ExecuteArgs:
+ */
+
+@interface Fff {
+}
+
+@Fff
+abstract class ToString_$<t> {
+}
+
+public class ReflectionToString {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("ToString_$");
+            String zhu = zqp.toString();
+            if (zhu.equals("class ToString_$")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/RTConstructorGetAnnotation1.java b/test/testsuite/ouroboros/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/RTConstructorGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..dd151fc0f072bd4d2ed21e7688954683d0669b72
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/RTConstructorGetAnnotation1.java
@@ -0,0 +1,87 @@
+/*
+ *- @TestCaseID: RTConstructorGetAnnotation1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTConstructorGetAnnotation1.java
+ *- @Title/Destination: Use Constructor.getAnnotation() to get the annotation of the target class's constructor by 
+ *                      reflection.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Create a class include four constructors with annotation or without.
+ * -#step2: Use classloader to load class.
+ * -#step3: Get constructors by getConstructor() and getDeclaredConstructor(Class...<?> parameterTypes) and
+ *          getConstructor(Class<?>... parameterTypes).
+ * -#step4: Constructor object get the get the annotation of the target class's constructor by calling
+ *          getAnnotation(Class<T> annotationClass)
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTConstructorGetAnnotation1.java
+ *- @ExecuteClass: RTConstructorGetAnnotation1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Www1 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Www1_a {
+    int c() default 0;
+
+    String d() default "";
+}
+
+class ConstructorGetAnnotation1 {
+    @Www1(i = 333, t = "ConstructorgetAnnotation")
+    public ConstructorGetAnnotation1() {
+    }
+
+    public ConstructorGetAnnotation1(String name) {
+    }
+
+    @Www1_a(c = 666, d = "Constructor")
+    ConstructorGetAnnotation1(int number) {
+    }
+
+    ConstructorGetAnnotation1(String name, int number) {
+    }
+}
+
+public class RTConstructorGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class zqp = Class.forName("ConstructorGetAnnotation1");
+            Constructor zhu1 = zqp.getDeclaredConstructor(int.class);
+            Constructor zhu2 = zqp.getConstructor();
+            Constructor zhu3 = zqp.getConstructor(String.class);
+            if ((zhu1.getAnnotation(Www1_a.class).toString().indexOf("c=666") != -1 &&
+                    zhu1.getAnnotation(Www1_a.class).toString().indexOf("d=Constructor") != -1 &&
+                    zhu2.getAnnotation(Www1.class).toString().indexOf("i=333") != -1 &&
+                    zhu2.getAnnotation(Www1.class).toString().indexOf("t=ConstructorgetAnnotation") != -1)) {
+                if (zhu3.getAnnotation(Www1.class) == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java b/test/testsuite/ouroboros/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..f968b325b6a045ad70824447512453f31cc5b030
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java
@@ -0,0 +1,102 @@
+/*
+ *- @TestCaseID: RTConstructorGetAnnotation2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTConstructorGetAnnotation2.java
+ *- @Title/Destination: When try to get annotation of target class's constructor by reflection and the annotation does
+ *                      not exist, Constructor.getAnnotation() throws NullPointerException.
+ *- @Condition: no
+ *- @Brief:no
+ * -#step1: 定义类1有含注解的构造方法，类2有无注解的构造方法。
+ * -#step2：通过Class.forName获取类1的class。
+ * -#step3：通过getDeclaredConstructor(Class...<?> parameterTypes)获取构造方法1，通过getConstructor()获取无参构造方法2、
+ * -#step4：构造方法1，2调用getAnnotation(Class<T> annotationClass)，annotationClass为不匹配的注解类型，判断返回的注解为空。
+ * -#step5：通过Class.forName获取类2的class。
+ * -#step6：通过getDeclaredConstructor(Class...<?> parameterTypes)获取构造方法3。
+ * -#step7：构造方法3调用getAnnotation(Class<T> annotationClass)，annotationClass为注解类型，判断返回的注解为空。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTConstructorGetAnnotation2.java
+ *- @ExecuteClass: RTConstructorGetAnnotation2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ConstructorGetAnnotation2 {
+    @IF2(i = 333, t = "ConstructorGetAnnotation")
+    public ConstructorGetAnnotation2() {
+    }
+
+    @IF2_a(c = 666, d = "Constructor")
+    ConstructorGetAnnotation2(int number) {
+    }
+}
+
+class ConstructorGetAnnotation2_a {
+    ConstructorGetAnnotation2_a(String name, int number) {
+    }
+}
+
+public class RTConstructorGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetAnnotation2");
+            Constructor instance1 = cls.getDeclaredConstructor(int.class);
+            Constructor instance2 = cls.getConstructor();
+            if (instance1.getAnnotation(IF2.class) == null && instance2.getAnnotation(IF2_a.class) == null) {
+                instance1.getAnnotation(IF2.class).toString();
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(1);
+            return;
+        } catch (NullPointerException e3) {
+            try {
+                Class cls = Class.forName("ConstructorGetAnnotation2_a");
+                Constructor instance3 = cls.getDeclaredConstructor(String.class, int.class);
+                if (instance3.getAnnotation(IF2.class) == null && instance3.getAnnotation(IF2_a.class) == null) {
+                    instance3.getAnnotation(IF2.class).toString();
+                }
+                System.out.println(1);
+                return;
+            } catch (ClassNotFoundException e4) {
+                System.out.println(2);
+                return;
+            } catch (NoSuchMethodException e5) {
+                System.out.println(3);
+                return;
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+                return;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/RTConstructorGetDeclaredAnnotations1.java b/test/testsuite/ouroboros/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/RTConstructorGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..716cbc2e42e0a0ca5f90df59580db8fdde06c3a8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/RTConstructorGetDeclaredAnnotations1.java
@@ -0,0 +1,101 @@
+/*
+ *- @TestCaseID: RTConstructorGetDeclaredAnnotations1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTConstructorGetDeclaredAnnotations1.java
+ *- @Title/Destination: Use Constructor.getDeclaredAnnotations() To obtain all annotations for constructor of the target
+ *                      class by reflection.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义两个类，有父子关系，都含有注解的构造方法。
+ * -#step2：调用getConstructor(Class...<?> parameterTypes)从子类中获取有两个注解的构造方法。
+ * -#step3：调用getDeclaredAnnotations()获取注解数组，判断数组长度为2。
+ * -#step4：调用getConstructor(Class...<?> parameterTypes)从子类中获取有一个注解的构造方法。
+ * -#step5：调用getDeclaredAnnotations()获取注解数组，判断数组长度为1，获取注解成员正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTConstructorGetDeclaredAnnotations1.java
+ *- @ExecuteClass: RTConstructorGetDeclaredAnnotations1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+
+class ConstructorGetDeclaredAnnotations1 {
+    public ConstructorGetDeclaredAnnotations1() {
+    }
+
+    @IF1(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations1(String name) {
+    }
+
+    @IF1(i = 333, t = "test1")
+    ConstructorGetDeclaredAnnotations1(int number) {
+    }
+}
+
+class ConstructorGetDeclaredAnnotations1_a extends ConstructorGetDeclaredAnnotations1 {
+    @IF1_a(i_a = 666, t_a = "right1")
+    @IF1(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations1_a(String name) {
+    }
+
+    @IF1_a(i_a = 666, t_a = "right1")
+    ConstructorGetDeclaredAnnotations1_a(int number) {
+    }
+}
+
+public class RTConstructorGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetDeclaredAnnotations1_a");
+            Constructor instance1 = cls.getConstructor(String.class);
+            if (instance1.getDeclaredAnnotations().length == 2) {
+                Constructor instance2 = cls.getDeclaredConstructor(int.class);
+                if (instance2.getDeclaredAnnotations().length == 1) {
+                    Annotation[] j = instance2.getDeclaredAnnotations();
+                    if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                        System.out.println(0);
+                        return;
+                    }
+                }
+                System.out.println(1);
+                return;
+            }
+            System.out.println(2);
+            return;
+        } catch (ClassNotFoundException e) {
+            System.out.println(3);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(4);
+            return;
+        } catch (NullPointerException e2) {
+            System.out.println(5);
+            return;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..42176d5649253cd3300baa3786c86f2e0063c96c
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java
@@ -0,0 +1,90 @@
+/*
+ *- @TestCaseID: RTConstructorGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTConstructorGetDeclaredAnnotations2.java
+ *- @Title/Destination: Constructor.getDeclaredAnnotations() does not return annotations inherited from parent class.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义两个类，有父子关系，父类含有注解的构造方法，子类的构造方法没有注解。
+ * -#step2：调用getConstructor(Class...<?> parameterTypes)从子类中获取构造方法1。
+ * -#step3：调用getDeclaredAnnotations()获取注解数组，判断数组长度为0。
+ * -#step4：调用getConstructor(Class...<?> parameterTypes)从子类中获取构造方法2。
+ * -#step5：调用getDeclaredAnnotations()获取注解数组，判断数组长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTConstructorGetDeclaredAnnotations2.java
+ *- @ExecuteClass: RTConstructorGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+
+class ConstructorGetDeclaredAnnotations2 {
+    public ConstructorGetDeclaredAnnotations2() {
+    }
+
+    @IF2(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations2(String name) {
+    }
+
+    @IF2(i = 333, t = "test1")
+    ConstructorGetDeclaredAnnotations2(int number) {
+    }
+}
+
+class ConstructorGetDeclaredAnnotations2_a extends ConstructorGetDeclaredAnnotations2 {
+    public ConstructorGetDeclaredAnnotations2_a(String name) {
+    }
+
+    ConstructorGetDeclaredAnnotations2_a(int number) {
+    }
+}
+
+public class RTConstructorGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetDeclaredAnnotations2_a");
+            Constructor instance1 = cls.getConstructor(String.class);
+            Constructor instance2 = cls.getDeclaredConstructor(int.class);
+            if (instance1.getDeclaredAnnotations().length == 0 && instance2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        } catch (NullPointerException e2) {
+            System.out.println(4);
+            return;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/RTConstructorGetExceptionTypes.java b/test/testsuite/ouroboros/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/RTConstructorGetExceptionTypes.java
new file mode 100755
index 0000000000000000000000000000000000000000..459955fe8641a47719ef4da812b33d7615f85891
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/RTConstructorGetExceptionTypes.java
@@ -0,0 +1,53 @@
+/*
+ *- @TestCaseID: RTConstructorGetExceptionTypes
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTConstructorGetExceptionTypes.java
+ *- @Title/Destination: Constructor.getExceptionTypes() returns an array of Class objects that represent the types of
+ *                      exceptions declared to be thrown by the underlying executable represented by this object.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义一个类含有构造方法。
+ * -#step2：调用Class.forName获取相应的class.
+ * -#step3: 使用class调用getDeclaredConstructor()获取相应的构造方法。
+ * -#step4：使用构造方法调用getExceptionTypes()获取异常类型的Class对象数组。
+ * -#step5：判断数组长度为2。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTConstructorGetExceptionTypes.java
+ *- @ExecuteClass: RTConstructorGetExceptionTypes
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class ConstructorGetExceptionTypes {
+    ConstructorGetExceptionTypes() throws ExceptionInInitializerError, InstantiationException {
+    }
+}
+
+public class RTConstructorGetExceptionTypes {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetExceptionTypes");
+            Constructor cons = cls.getDeclaredConstructor();
+            Class<?>[] exClass = cons.getExceptionTypes();
+            if (exClass.length == 2) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(3);
+            return;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/RTConstructorGetTypeParameters.java b/test/testsuite/ouroboros/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/RTConstructorGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..1986ab63677230a5e0566afc83f9bba0bb055ed7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/RTConstructorGetTypeParameters.java
@@ -0,0 +1,61 @@
+/*
+ *- @TestCaseID: RTConstructorGetTypeParameters
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTConstructorGetTypeParameters.java
+ *- @Title/Destination: Constructor.getTypeParameters() Returns an array of TypeVariable objects that represent the type
+ *                      variables declared by the generic declaration represented by this GenericDeclaration object, in
+ *                      declaration order.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义一个类，含有类型变量的有参构造方法和无参的构造方法。
+ * -#step2：调用Class.forName获取相应的class.
+ * -#step3：使用class调用getConstructor(Class...<?> parameterTypes)从类中获取含有类型变量的构造方法1。
+ * -#step4：调用getTypeParameters()获取TypeVariable数组，确认数组长度为5。
+ * -#step5：使用class调用getDeclaredConstructor()从类中获取无参的构造方法。
+ * -#step6：调用getTypeParameters()获取TypeVariable数组，确认数组长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTConstructorGetTypeParameters.java
+ *- @ExecuteClass: RTConstructorGetTypeParameters
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.TypeVariable;
+
+class ConstructorGetTypeParameters {
+    public <t, s, d, f, g> ConstructorGetTypeParameters(int number) {
+    }
+
+    ConstructorGetTypeParameters() {
+    }
+}
+
+public class RTConstructorGetTypeParameters {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetTypeParameters");
+            Constructor instance1 = cls.getConstructor(int.class);
+            Constructor instance2 = cls.getDeclaredConstructor();
+            TypeVariable[] q1 = instance1.getTypeParameters();
+            TypeVariable[] q2 = instance2.getTypeParameters();
+            if (q1.length == 5 && q2.length == 0) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(3);
+            return;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0073-rt-compact-RTConstructortoGenericString/RTConstructorToGenericString1.java b/test/testsuite/ouroboros/compact_test/RT0073-rt-compact-RTConstructortoGenericString/RTConstructorToGenericString1.java
new file mode 100755
index 0000000000000000000000000000000000000000..476273cf686621716eae2ed359b9d619e0281684
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0073-rt-compact-RTConstructortoGenericString/RTConstructorToGenericString1.java
@@ -0,0 +1,52 @@
+/*
+ *- @TestCaseID: RTConstructorToGenericString
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTConstructorToGenericString1.java
+ *- @Title/Destination: Constructor.ToGenericString() returns a string describing this Constructor, including type
+ *                      parameters.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义一个类，含有类型变量的有参构造方法。
+ * -#step2：调用Class.forName获取相应的class.
+ * -#step3：使用class调用getConstructor(Class...<?> parameterTypes)从类中获取含有类型变量的构造方法。
+ * -#step4：调用toGenericString()获取描述此Method的字符串。
+ * -#step5：确认返回的描述正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTConstructorToGenericString1.java
+ *- @ExecuteClass: RTConstructorToGenericString1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class ConstructorToGenericString1 {
+    public <t, s, d, f, g> ConstructorToGenericString1(int number) {
+    }
+}
+
+public class RTConstructorToGenericString1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorToGenericString1");
+            Constructor instance1 = cls.getConstructor(int.class);
+            if (instance1.toGenericString().equals("public <t,s,d,f,g> ConstructorToGenericString1(int)")) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0074-rt-compact-RTFieldget1/RTFieldGet1.java b/test/testsuite/ouroboros/compact_test/RT0074-rt-compact-RTFieldget1/RTFieldGet1.java
new file mode 100755
index 0000000000000000000000000000000000000000..8d754fb2940844bc2d1dfdd9dea7e84b9cb7bdc1
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0074-rt-compact-RTFieldget1/RTFieldGet1.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID: RTFieldGet1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGet1.java
+ *- @Title/Destination: Field.get() returns the value of the field represented by this field on the target object.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 创建类FieldGet1_a和它的子类FieldGet1。
+ * -#step2：通过forName()方法加载FieldGet1并调用newInstance()生成实例对象。
+ * -#step3：通过getField()方法获取实例对象中的成员变量，并确认值正确。
+ * -#step4：通过forName()方法加载FieldGet1_a并生成实例对象,通过getField()方法获取对应的成员变量并核对值正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGet1.java
+ *- @ExecuteClass: RTFieldGet1
+ *- @ExecuteArgs:
+ */
+
+class FieldGet1_a {
+    public static String str = "aaa";
+    public int num = 2;
+    public int num1 = 5;
+    public static boolean aBoolean = false;
+}
+
+class FieldGet1 extends FieldGet1_a {
+    public static String str = "bbb";
+    public int number = 1;
+    public int test = super.num1 + 1;
+    public static boolean bBoolean = true;
+    public char aChar = '国';
+}
+
+public class RTFieldGet1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet1");
+            Object obj = cls.newInstance();
+            Object q1 = cls.getField("str").get(obj);
+            Object q2 = cls.getField("number").get(obj);
+            Object q3 = cls.getField("test").get(obj);
+            Object q4 = cls.getField("bBoolean").get(obj);
+            Object q5 = cls.getField("aChar").get(obj);
+            Object q6 = cls.getField("num").get(obj);
+            Object q7 = cls.getField("aBoolean").get(null);
+            if (q1.toString().equals("bbb") && (int) q2 == 1 && (int) q3 == 6 && (boolean) q4 && q5.toString().
+                    equals("国") && (int) q6 == 2) {
+                Class cls1 = Class.forName("FieldGet1_a");
+                Object instance1 = cls1.newInstance();
+                Object q8 = cls1.getField("str").get(instance1);
+                if (q8.toString().equals("aaa")) {
+                    if (!(boolean) q7) {
+                        System.out.println(0);
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0075-rt-compact-RTFieldget2/RTFieldGet2.java b/test/testsuite/ouroboros/compact_test/RT0075-rt-compact-RTFieldget2/RTFieldGet2.java
new file mode 100755
index 0000000000000000000000000000000000000000..43a3481f6ceab5d47c5ad295f459b26951731031
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0075-rt-compact-RTFieldget2/RTFieldGet2.java
@@ -0,0 +1,94 @@
+/*
+ *- @TestCaseID: RTFieldGet2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGet2.java
+ *- @Title/Destination: Field.get throws IllegalAccessException when the Field is inaccessible; throws
+ *                      IllegalArgumentException when the object is not an instance of the class; Field.get(null) throws
+ *                      NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 创建类FieldGet2_a，FieldGet2_a的子类FieldGet2且含有私有成员变量，定义FieldGet2_b。
+ * -#step2：通过forName()方法加载FieldGet2并调用newInstance()生成实例对象。
+ * -#step3：通过getDeclaredField()方法获取FieldGet2中的私有变量，确认会抛出IllegalAccessException。
+ * -#step4：加载FieldGet2实例对象，通过getDeclaredField()方法获取public变量域，构造FieldGet2_b实例，并取对应变量域值。
+ * -#step5：确认会抛出IllegalArgumentException异常，通过getDeclaredField()方法获取FieldGet2的public变量域。
+ * -#step6：调用get(Object obj)方法，obj为NULL，确认NullPointerException抛出。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGet2.java
+ *- @ExecuteClass: RTFieldGet2
+ *- @ExecuteArgs:
+ */
+
+class FieldGet2_a {
+    public int num;
+}
+
+class FieldGet2 extends FieldGet2_a {
+    private int number = 1;
+    public boolean aBoolean = true;
+    public int number1 = 8;
+}
+
+class FieldGet2_b {
+    public int number1 = 18;
+}
+
+public class RTFieldGet2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet2");
+            Object obj = cls.newInstance();
+            Object q1 = cls.getDeclaredField("number").get(obj);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            try {
+                Class cls = Class.forName("FieldGet2");
+                Class cls1 = Class.forName("FieldGet2_b");
+                Object instance1 = cls1.newInstance();
+                Object q2 = cls.getDeclaredField("number1").get(instance1);
+            } catch (ClassNotFoundException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (InstantiationException e6) {
+                System.err.println(e6);
+                System.out.println(2);
+            } catch (NoSuchFieldException e7) {
+                System.err.println(e7);
+                System.out.println(2);
+            } catch (IllegalAccessException e8) {
+                System.err.println(e8);
+                System.out.println(2);
+            } catch (IllegalArgumentException e9) {
+                try {
+                    Class cls = Class.forName("FieldGet2");
+                    Object q3 = cls.getDeclaredField("aBoolean").get(null);
+                } catch (ClassNotFoundException e10) {
+                    System.err.println(e10);
+                    System.out.println(2);
+                } catch (NoSuchFieldException e11) {
+                    System.err.println(e11);
+                    System.out.println(2);
+                } catch (IllegalAccessException e12) {
+                    System.err.println(e12);
+                    System.out.println(2);
+                } catch (NullPointerException e13) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0076-rt-compact-RTFieldget3/RTFieldGet3.java b/test/testsuite/ouroboros/compact_test/RT0076-rt-compact-RTFieldget3/RTFieldGet3.java
new file mode 100755
index 0000000000000000000000000000000000000000..53c4f6eca609018449236d93041f516703ce467c
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0076-rt-compact-RTFieldget3/RTFieldGet3.java
@@ -0,0 +1,56 @@
+/*
+ *- @TestCaseID: RTFieldGet3
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGet3.java
+ *- @Title/Destination: If the filed is not given a value, the default value is returned by reflection。
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义类FieldGet3_a，定义FieldGet3_a的子类FieldGet3。
+ * -#step2: 通过调用forName()方法加载类FieldGet3，调用newInstance()生产实例对象。
+ * -#step3: 通过调用getField()获取对应名称的未初始化的成员变量。
+ * -#step4: 调用get(Object obj)方法作出判断，确认String类型为null,int类型为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGet3.java
+ *- @ExecuteClass: RTFieldGet3
+ *- @ExecuteArgs:
+ */
+
+class FieldGet3_a {
+    public int num;
+}
+
+class FieldGet3 extends FieldGet3_a {
+    public static String str;
+}
+
+public class RTFieldGet3 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet3");
+            Object obj = cls.newInstance();
+            Object obj1 = cls.getField("str").get(obj);
+            Object obj2 = cls.getField("num").get(obj);
+            if (obj1 == null && (int) obj2 == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/RTFieldGetAnnotation1.java b/test/testsuite/ouroboros/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/RTFieldGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..8dd5ba9d6257632dbda6e1f25a7ae58a191d6cfd
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/RTFieldGetAnnotation1.java
@@ -0,0 +1,70 @@
+/*
+ *- @TestCaseID: RTFieldGetAnnotation1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGetAnnotation1.java
+ *- @Title/Destination: Field.GetAnnotation() returns null when the expected annotation is not present.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义含注解类FieldGetAnnotation1。
+ * -#step2: 通过调用forName()方法加载类FieldGetAnnotation1。
+ * -#step3: 通过调用getField()获取对应名称的成员变量。
+ * -#step4: 调用getAnnotation(Class<T> annotationClass)，annotationClass为不匹配的类型，确认返回null。
+ * -#step5: 调用返回空注解类型进行.number()的调用，确认抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGetAnnotation1.java
+ *- @ExecuteClass: RTFieldGetAnnotation1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface4 {
+    int num() default 0;
+    String str() default "";
+}
+
+@interface interface4_a {
+    int number() default 0;
+    String string() default "";
+}
+
+class FieldGetAnnotation1 {
+    @interface4(num = 333, str = "GetAnnotation")
+    public int num1;
+    @interface4_a(number = 555, string = "test")
+    public String str1;
+}
+
+public class RTFieldGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls1 = Class.forName("FieldGetAnnotation1");
+            Field instance1 = cls1.getField("num1");
+            Field instance2 = cls1.getField("str1");
+            if (instance1.getAnnotation(interface4_a.class) == null && instance2.getAnnotation(interface4.class) == null)
+            {
+                instance1.getAnnotation(interface4_a.class).number();
+            }
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/RTFieldGetDeclaredAnnotations1.java b/test/testsuite/ouroboros/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/RTFieldGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..7d1f452f9a233b83d3fc6a18b19907fdce742146
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/RTFieldGetDeclaredAnnotations1.java
@@ -0,0 +1,90 @@
+/*
+ *- @TestCaseID: RTFieldGetDeclaredAnnotations1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGetDeclaredAnnotations1.java
+ *- @Title/Destination: Field.GetDeclaredAnnotations() returns annotations that are directly present on this element.
+ *                      This method ignores inherited annotations.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义含注解类FieldGetDeclaredAnnotations1，定义含注解的类FieldGetDeclaredAnnotations1的子类
+ *          FieldGetDeclaredAnnotations1_a。
+ * -#step2: 通过调用forName()方法加载类FieldGetDeclaredAnnotations1_a。
+ * -#step3: 通过调用getField()获取对应名称的成员变量。
+ * -#step4: 通过调用getAnnotation(Class<T> annotationClass)获取注解，调用indexOf()方法进行判断获取正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGetDeclaredAnnotations1.java
+ *- @ExecuteClass: RTFieldGetDeclaredAnnotations1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface1 {
+    int num() default 0;
+    String str() default "";
+}
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface1_a {
+    int num_a() default 2;
+    String str_a() default "";
+}
+
+class FieldGetDeclaredAnnotations1 {
+    @interface1(num = 333, str = "test1")
+    public int num;
+    @interface1(num = 333, str = "test1")
+    public String str;
+}
+
+class FieldGetDeclaredAnnotations1_a extends FieldGetDeclaredAnnotations1 {
+    @interface1_a(num_a = 666, str_a = "right1")
+    public int num;
+    @interface1_a(num_a = 666, str_a = "right1")
+    public String str;
+}
+
+public class RTFieldGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaredAnnotations1_a");
+            Field instance1 = cls.getField("num");
+            if (instance1.getDeclaredAnnotations().length == 1) {
+                Annotation[] j = instance1.getDeclaredAnnotations();
+                if (j[0].toString().indexOf("num_a=666") != -1 && j[0].toString().indexOf("str_a=right1") != -1) {
+                    Field instance2 = cls.getDeclaredField("str");
+                    if (instance2.getDeclaredAnnotations().length == 1) {
+                        Annotation[] k = instance2.getDeclaredAnnotations();
+                        if (k[0].toString().indexOf("num_a=666") != -1 && k[0].toString().indexOf("str_a=right1") != -1)
+                        {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..57f25c07fb483692e80490d74f3b03877e4b39a3
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java
@@ -0,0 +1,79 @@
+/*
+ *- @TestCaseID: RTFieldGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGetDeclaredAnnotations2.java
+ *- @Title/Destination: Field.GetDeclaredAnnotations() ignores inherited annotations.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义含注解类FieldGetDeclaredAnnotations2，定义含注解的类FieldGetDeclaredAnnotations2的子类
+ *          FieldGetDeclaredAnnotations2_a。
+ * -#step2: 通过调用forName()方法加载类FieldGetDeclaredAnnotations2_a。
+ * -#step3: 通过调用 getField()获取对应名称的成员变量。
+ * -#step4: 通过调用getAnnotation(Class<T> annotationClass)获取注解，调用equals()方法进行判断获取正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGetDeclaredAnnotations2.java
+ *- @ExecuteClass: RTFieldGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface2 {
+    int num() default 0;
+    String str() default "";
+}
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+
+class FieldGetDeclaredAnnotations2 {
+    @interface2(num = 333, str = "test1")
+    public int num;
+    @interface2(num = 333, str = "test1")
+    public String str;
+}
+
+class FieldGetDeclaredAnnotations2_a extends FieldGetDeclaredAnnotations2 {
+    @interface2_a(i_a = 666, t_a = "right1")
+    public int num;
+    public String str;
+}
+
+public class RTFieldGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaredAnnotations2_a");
+            Field instance1 = cls.getField("str");
+            Field instance2 = cls.getDeclaredField("str");
+            if (instance1.getDeclaredAnnotations().length == 0 && instance2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java b/test/testsuite/ouroboros/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..1caca41b1d110d3d447e4a5823999aaa6f8c720b
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java
@@ -0,0 +1,51 @@
+/*
+ *- @TestCaseID: RTFieldGetDeclaringClass
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGetDeclaringClass.java
+ *- @Title/Destination: Field.GetDeclaringClass() returns the class object of the class declaring the field represented
+ *                      by this Field object.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义类FieldGetDeclaringClass。
+ * -#step2: 通过调用forName()方法加载类FieldGetDeclaringClass。
+ * -#step3: 通过调用 getField()、getDeclaredField()获取对应名称的成员变量。
+ * -#step4: 通过调用FieldGetDeclaringClass()获取类对象，调用equals()方法进行判断获取正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGetDeclaringClass.java
+ *- @ExecuteClass: RTFieldGetDeclaringClass
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldGetDeclaringClass {
+    public int num;
+    char aChar;
+}
+
+public class RTFieldGetDeclaringClass {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaringClass");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("aChar");
+            Class<?> j = instance1.getDeclaringClass();
+            Class<?> k = instance2.getDeclaringClass();
+            if (j.getName().equals("FieldGetDeclaringClass") && k.getName().equals("FieldGetDeclaringClass")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0081-rt-compact-RTFieldgetModifiers/RTFieldGetModifiers.java b/test/testsuite/ouroboros/compact_test/RT0081-rt-compact-RTFieldgetModifiers/RTFieldGetModifiers.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1ec1905ae2d2461e06053063105debb6f581c30
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0081-rt-compact-RTFieldgetModifiers/RTFieldGetModifiers.java
@@ -0,0 +1,55 @@
+/*
+ *- @TestCaseID: RTFieldGetModifiers
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGetModifiers.java
+ *- @Title/Destination: Field.GetModifiers() Returns the Java language modifiers for the field represented by this Field
+ *                      object, as an integer.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义含受保护的今天成员变量的类FieldGetModifiers。
+ * -#step2: 通过调用forName()方法加载类FieldGetModifiers。
+ * -#step3: 通过调用getField()、getDeclaredField()获取对应名称的成员变量。
+ * -#step4: 通过调用getModifiers()获取对应字段的Java语言修饰符,调用equals()方法进行判断描述正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGetModifiers.java
+ *- @ExecuteClass: RTFieldGetModifiers
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldGetModifiers {
+    public static int num;
+    final String str = "aaa";
+    private String string = "ccc";
+    protected static int number;
+}
+
+public class RTFieldGetModifiers {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetModifiers");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("str");
+            Field instance3 = cls.getDeclaredField("string");
+            Field field = cls.getDeclaredField("number");
+            if (instance1.getModifiers() == 9 && instance2.getModifiers() == 16 && instance3.getModifiers() == 2
+                    && field.getModifiers()
+                    == 12) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0082-rt-compact-RTFieldgetName/RTFieldGetName.java b/test/testsuite/ouroboros/compact_test/RT0082-rt-compact-RTFieldgetName/RTFieldGetName.java
new file mode 100755
index 0000000000000000000000000000000000000000..6af11968f7119b783e08106e1b20f09154f07eca
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0082-rt-compact-RTFieldgetName/RTFieldGetName.java
@@ -0,0 +1,48 @@
+/*
+ *- @TestCaseID: RTFieldGetName
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGetName.java
+ *- @Title/Destination: Field.GetName() Returns the name of the field represented by this Field object.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义类FieldGetName。
+ * -#step2: 通过调用forName()方法加载类FieldGetModifiers。
+ * -#step3: 通过调用getField()、getDeclaredField()获取对应名称的成员变量。
+ * -#step4: 通过调用getName()方法获取对应字段，调用equals()方法进行判断字段值正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGetName.java
+ *- @ExecuteClass: RTFieldGetName
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldGetName {
+    public static int num;
+    final String str = "aaa";
+}
+
+public class RTFieldGetName {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetName");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("str");
+            if (instance1.getName().equals("num") && instance2.getName().equals("str")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0083-rt-compact-RTFieldgetType/RTFieldGetType.java b/test/testsuite/ouroboros/compact_test/RT0083-rt-compact-RTFieldgetType/RTFieldGetType.java
new file mode 100755
index 0000000000000000000000000000000000000000..86b869a65bf2b043e3f2dc6d705f544cb28f24de
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0083-rt-compact-RTFieldgetType/RTFieldGetType.java
@@ -0,0 +1,52 @@
+/*
+ *- @TestCaseID: RTFieldGetType
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldGetType.java
+ *- @Title/Destination: Field.GetType() Returns a Class object that identifies the declared type for the field
+ *                      represented by this Field object.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义类FieldGetType。
+ * -#step2: 调用forName()方法加载类FieldGetType。
+ * -#step3: 调用getField()、getDeclaredField()方法获取对应的成员变量。
+ * -#step4: 调用getType().getName()获取相应的类型,调用equals()方法与相应的类型比较，判断通过字段值正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldGetType.java
+ *- @ExecuteClass: RTFieldGetType
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldGetType {
+    public static short sNum;
+    final char aChar = '什';
+    private float fNum;
+}
+
+public class RTFieldGetType {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetType");
+            Field instance1 = cls.getField("sNum");
+            Field instance2 = cls.getDeclaredField("aChar");
+            Field instance3 = cls.getDeclaredField("fNum");
+            if (instance1.getType().getName().equals("short") && instance2.getType().getName().equals("char")
+                    && instance3.getType().getName().equals("float")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0084-rt-compact-RTFieldset1/RTFieldSet1.java b/test/testsuite/ouroboros/compact_test/RT0084-rt-compact-RTFieldset1/RTFieldSet1.java
new file mode 100755
index 0000000000000000000000000000000000000000..45d1c03bde7fb83a6c5dc80fe3fc0a5772fe5b31
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0084-rt-compact-RTFieldset1/RTFieldSet1.java
@@ -0,0 +1,90 @@
+/*
+ *- @TestCaseID: RTFieldSet1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldSet1.java
+ *- @Title/Destination: Field.set() sets the field on the specified object argument to the new value.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义类FieldSet1_a，定义类FieldSet1_a的子类FieldSet1。
+ * -#step2: 通过调用forName()方法加载类FieldSet1，调用newInstance()方法生成实例对象。
+ * -#step3: 通过调用getField()获取对应名称的成员变量，调用set()方法设置变量的值。
+ * -#step4: 通过调用get()方法获取对应字段的值并作比较，确认字段值正确。
+ * -#step5: 通过调用forName()方法加载类FieldSet1_a，调用newInstance()方法生成实例对象。
+ * -#step6: 通过调用getDeclaredField()获取对应名称的成员变量，调用set()方法设置变量的值。
+ * -#step7: 通过调用get()方法获取对应字段的值并作比较，确认字段值正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldSet1.java
+ *- @ExecuteClass: RTFieldSet1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldSet1_a {
+    public static String str = "aaa";
+    public int num2 = 2;
+    public int number = 5;
+    public static int num1;
+}
+
+class FieldSet1 extends FieldSet1_a {
+    public static String str = "bbb";
+    public int num = 1;
+    public int test = super.number + 1;
+    public static boolean aBoolean = true;
+    public char aChar;
+}
+
+public class RTFieldSet1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet1");
+            Object obj = cls.newInstance();
+            Field f1 = cls.getField("str");
+            Field f2 = cls.getField("num");
+            Field f3 = cls.getField("aBoolean");
+            Field f4 = cls.getField("aChar");
+            Field f5 = cls.getField("num1");
+            Field f6 = cls.getField("num2");
+            Field f7 = cls.getField("number");
+            f1.set(obj, "ccc");
+            f2.set(obj, 10);
+            f3.set(obj, false);
+            f4.set(obj, '国');
+            f5.set(obj, 20);
+            f6.set(obj, 30);
+            f7.set(obj, 40);
+            if (f1.get(obj).toString().equals("ccc") && (int) f2.get(obj) == 10 && !(boolean) f3.get(obj) && (int)
+                    f6.get(obj) == 30) {
+                if (f4.get(obj).toString().equals("国") && (int) f5.get(obj) == 20) {
+                    if ((int) cls.getField("test").get(obj) == 6) {
+                        Class cls1 = Class.forName("FieldSet1_a");
+                        Object instance1 = cls1.newInstance();
+                        Object p = cls1.getDeclaredField("str").get(instance1);
+                        if (p.toString().equals("aaa")) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0085-rt-compact-RTFieldset2/RTFieldSet2.java b/test/testsuite/ouroboros/compact_test/RT0085-rt-compact-RTFieldset2/RTFieldSet2.java
new file mode 100755
index 0000000000000000000000000000000000000000..1ae8be5462cc0c4396b4c4353cd1dfdd1276b461
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0085-rt-compact-RTFieldset2/RTFieldSet2.java
@@ -0,0 +1,102 @@
+/*
+ *- @TestCaseID: RTFieldSet2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldSet2.java
+ *- @Title/Destination: If this Field object is inaccessible or final, throws IllegalAccessException; if the field
+ *                      doesn't exist in the class object, throws IllegalArgumentException; trying to set a non-static
+ *                      field on a null object throws NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义类FieldSet2_a的子类FieldSet2，含有私有变量。
+ * -#step2: 通过调用forName()方法加载类FieldSet2，调用newInstance()方法生成实例对象，通过调用 getField()获取对应名称的
+ *          成员变量，通过set()方法设值，抛出IllegalAccessException。
+ * -#step3: 定义类FieldSet2_a，通过调用forName()方法加载类FieldSet2和FieldSet2_b，调用newInstance()方法生成实例对象，
+ *          通过调用 getField()获取对应名称的成员变量，通过set()方法设值，抛出IllegalArgumentException。
+ * -#step4: 通过调用forName()方法加载类FieldSet2，调用getDeclaredField()方法获取对应名称的成员变量，通过set()方法设值，
+ *          抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldSet2.java
+ *- @ExecuteClass: RTFieldSet2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldSet2_a {
+    public static String str = "aaa";
+    public int num;
+}
+
+class FieldSet2 extends FieldSet2_a {
+    public static String str;
+    private int num = 1;
+    public boolean aBoolean = true;
+    public int num1 = 8;
+}
+
+class FieldSet2_b {
+    public int num = 18;
+}
+
+public class RTFieldSet2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet2");
+            Object obj = cls.newInstance();
+            Field field = cls.getDeclaredField("num");
+            field.set(obj, 10);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            try {
+                Class cls = Class.forName("FieldSet2");
+                Class cls1 = Class.forName("FieldSet2_b");
+                Object instance1 = cls1.newInstance();
+                Field f1 = cls.getDeclaredField("aBoolean");
+                f1.set(instance1, 10);
+            } catch (ClassNotFoundException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (InstantiationException e6) {
+                System.err.println(e6);
+                System.out.println(2);
+            } catch (NoSuchFieldException e7) {
+                System.err.println(e7);
+                System.out.println(2);
+            } catch (IllegalAccessException e8) {
+                System.err.println(e8);
+                System.out.println(2);
+            } catch (IllegalArgumentException e9) {
+                try {
+                    Class cls = Class.forName("FieldSet2");
+                    Field f2 = cls.getDeclaredField("aBoolean");
+                    f2.set(null, false);
+                } catch (ClassNotFoundException e10) {
+                    System.err.println(e10);
+                    System.out.println(2);
+                } catch (NoSuchFieldException e11) {
+                    System.err.println(e11);
+                    System.out.println(2);
+                } catch (IllegalAccessException e12) {
+                    System.err.println(e12);
+                    System.out.println(2);
+                } catch (NullPointerException e13) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0086-rt-compact-RTFieldset3/RTFieldSet3.java b/test/testsuite/ouroboros/compact_test/RT0086-rt-compact-RTFieldset3/RTFieldSet3.java
new file mode 100755
index 0000000000000000000000000000000000000000..545971e9640abba1756034a593161f6ceaa8613b
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0086-rt-compact-RTFieldset3/RTFieldSet3.java
@@ -0,0 +1,56 @@
+/*
+ *- @TestCaseID: RTFieldSet3
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldSet3.java
+ *- @Title/Destination: Setting on a final field throws IllegalAccessException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义类FieldSet3_a，包含final修饰的变量。定义类FieldSet3_a的子类FieldSet3，包含final修饰的变量。
+ * -#step2: 通过调用forName()方法加载类FieldSet3，调用newInstance()方法生成实例对象。
+ * -#step3: 通过调用 getField()获取对应名称的成员变量，调用set()方法设置变量的值，抛出IllegalAccessException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldSet3.java
+ *- @ExecuteClass: RTFieldSet3
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldSet3_a {
+    public final static String str = "aaa";
+    public int num = 2;
+}
+
+class FieldSet3 extends FieldSet3_a {
+    public final int num = 1;
+}
+
+public class RTFieldSet3 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet3");
+            Object obj = cls.newInstance();
+            Field q1 = cls.getField("str");
+            Field q2 = cls.getField("num");
+            q1.set(obj, "bbb");
+            q2.set(obj, 10);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0087-rt-compact-RTFieldset4/RTFieldSet4.java b/test/testsuite/ouroboros/compact_test/RT0087-rt-compact-RTFieldset4/RTFieldSet4.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e65a38c9c5ebd13a58fbb69e630ace0c4248ae8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0087-rt-compact-RTFieldset4/RTFieldSet4.java
@@ -0,0 +1,54 @@
+/*
+ *- @TestCaseID: RTFieldSet4
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldSet4.java
+ *- @Title/Destination: To set a value with no corresponding object on a static field by reflection.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义含私有变量的类FieldSet4。
+ * -#step2: 通过调用forName()方法加载类FieldSet4，调用newInstance()方法生成实例对象。
+ * -#step3: 通过调用getDeclaredField()获取对应名称的成员变量，调用set()方法设置变量的值。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldSet4.java
+ *- @ExecuteClass: RTFieldSet4
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldSet4 {
+    public static String str;
+    private int num = 1;
+    public boolean aBoolean = true;
+    public int num1 = 8;
+}
+
+public class RTFieldSet4 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet4");
+            Object obj = cls.newInstance();
+            Field field = cls.getDeclaredField("str");
+            field.set(null, "aaa");
+            System.out.println(0);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0088-rt-compact-RTFieldtoGenericString/RTFieldToGenericString.java b/test/testsuite/ouroboros/compact_test/RT0088-rt-compact-RTFieldtoGenericString/RTFieldToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..fb1600a728b24f3eead42365adfcc29416134c9e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0088-rt-compact-RTFieldtoGenericString/RTFieldToGenericString.java
@@ -0,0 +1,51 @@
+/*
+ *- @TestCaseID: RTFieldToGenericString
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldToGenericString.java
+ *- @Title/Destination: Field.toGenericString() Returns a string describing this Field, including its generic type.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义含私有变量的类FieldToGenericString。
+ * -#step2: 通过调用forName()方法加载类FieldToGenericString，调用newInstance()方法生成实例对象。
+ * -#step3: 通过调用toGenericString()返回对象的string，确认返回的字符串描述正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldToGenericString.java
+ *- @ExecuteClass: RTFieldToGenericString
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+class FieldToGenericString<E, F> {
+    public List<F> list1;
+    private List<E> list2;
+}
+
+public class RTFieldToGenericString {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldToGenericString");
+            Field instance1 = cls.getField("list1");
+            Field instance2 = cls.getDeclaredField("list2");
+            String q1 = instance1.toGenericString();
+            String q2 = instance2.toGenericString();
+            if (q1.equals("public java.util.List<F> FieldToGenericString.list1") && q2.equals
+                    ("private java.util.List<E> FieldToGenericString.list2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0089-rt-compact-RTFieldtoString/RTFieldToString.java b/test/testsuite/ouroboros/compact_test/RT0089-rt-compact-RTFieldtoString/RTFieldToString.java
new file mode 100755
index 0000000000000000000000000000000000000000..ab9b500f343a9009e28c47dd9f0f2dac83f182dd
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0089-rt-compact-RTFieldtoString/RTFieldToString.java
@@ -0,0 +1,51 @@
+/*
+ *- @TestCaseID: RTFieldToString
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTFieldToString.java
+ *- @Title/Destination: Field.ToString() returns a string describing this Field.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 定义含私有变量的类FieldToGenericString<E, F>。
+ * -#step2: 通过调用forName()方法加载类FieldToGenericString，调用getField()、getDeclaredField()分别获取相应的成员。
+ * -#step3: 通过调用toString()()返回对象的string，确认字符串描述正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTFieldToString.java
+ *- @ExecuteClass: RTFieldToString
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+class FieldToString<E, F> {
+    public List<F> list1;
+    private List<E> list2;
+}
+
+public class RTFieldToString {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldToString");
+            Field instance1 = cls.getField("list1");
+            Field instance2 = cls.getDeclaredField("list2");
+            String q1 = instance1.toString();
+            String q2 = instance2.toString();
+            if (q1.equals("public java.util.List FieldToString.list1")
+                    && q2.equals("private java.util.List FieldToString.list2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/RTMethodGetAnnotation1.java b/test/testsuite/ouroboros/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/RTMethodGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..cad562414ffa1b9a8e6aa3dba47cf3c8978686c0
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/RTMethodGetAnnotation1.java
@@ -0,0 +1,87 @@
+/*
+ *- @TestCaseID: RTMethodGetAnnotation1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTMethodGetAnnotation1.java
+ *- @Title/Destination: Method.getAnnotation() Returns the Method's annotation for the specified type if such an
+ *                      annotation is present, else null.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodGetAnnotation1类的运行时类clazz；
+ * -#step2: 以test3、int.class为参数，通过getDeclaredMethod()方法获取clazz的声明方法并记为method1；
+ * -#step3: 分别以test1、（test2、String.class）为参数，通过getMethod()方法获取clazz的方法对象method2、method3；
+ * -#step4: 分别以IF1_a.class、IF1.class为参数，通过getAnnotation()方法获取method1、method2的注解，且因为存在这样的
+ *          注解，因此可以返回成功；
+ * -#step5: 以IF1.class为参数，通过getAnnotation()方法获取method3的注解，因不存在这样的注解，因此返回为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTMethodGetAnnotation1.java
+ *- @ExecuteClass: RTMethodGetAnnotation1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i_a() default 0;
+    String t_b() default "";
+}
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class MethodGetAnnotation1 {
+    @IF1(i_a = 333, t_b = "MethodGetAnnotation")
+    public void test1() {
+    }
+
+    public void test2(String name) {
+    }
+
+    @IF1_a(c = 666, d = "Method")
+    void test3(int number) {
+    }
+
+    void test4(String name, int number) {
+    }
+}
+
+public class RTMethodGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetAnnotation1");
+            Method method1 = clazz.getDeclaredMethod("test3", int.class);
+            Method method2 = clazz.getMethod("test1");
+            Method method3 = clazz.getMethod("test2", String.class);
+            if (method1.getAnnotation(IF1_a.class).c() == 666
+                    && method1.getAnnotation(IF1_a.class).d().equals("Method")
+                    && method2.getAnnotation(IF1.class).i_a() == 333
+                    && method2.getAnnotation(IF1.class).t_b().equals("MethodGetAnnotation")) {
+                if (method3.getAnnotation(IF1.class) == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java b/test/testsuite/ouroboros/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..fac42fe4054e79c17460d47d5b8115c74c21ab97
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java
@@ -0,0 +1,73 @@
+/*
+ *- @TestCaseID: RTMethodGetAnnotation2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTMethodGetAnnotation2.java
+ *- @Title/Destination: Annotations are not acting at the runtime stage, and the annotation to obtain the target class
+ *                      method by reflection is null
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodGetAnnotation2类的运行时类clazz；
+ * -#step2: 以test3、int.class为参数，通过getDeclaredMethod()方法获取clazz的声明方法并记为method1；
+ * -#step3: 以test1为参数，通过getMethod()方法获取clazz的方法对象method2；
+ * -#step4: 以IF2_a.class为参数，通过getAnnotation()方法分别获取method1、method2的注解，其返回值均为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTMethodGetAnnotation2.java
+ *- @ExecuteClass: RTMethodGetAnnotation2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.CLASS)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.SOURCE)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class MethodGetAnnotation2 {
+    @IF2(i = 333, t = "MethodGetAnnotation")
+    public void test1() {
+    }
+
+    @IF2_a(c = 666, d = "Method")
+    void test3(int number) {
+    }
+}
+
+public class RTMethodGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetAnnotation2");
+            Method method1 = clazz.getDeclaredMethod("test3", int.class);
+            Method method2 = clazz.getMethod("test1");
+            if (method1.getAnnotation(IF2_a.class) == null && method2.getAnnotation(IF2.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/RTMethodGetDeclaredAnnotations1.java b/test/testsuite/ouroboros/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/RTMethodGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..32444d303d0ea293476d1a641524ddcbb4f294b8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/RTMethodGetDeclaredAnnotations1.java
@@ -0,0 +1,101 @@
+/*
+ *- @TestCaseID: RTMethodGetDeclaredAnnotations1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTMethodGetDeclaredAnnotations1.java
+ *- @Title/Destination: Method.getDeclaredAnnotations() returns annotations that are directly present on this element.
+ *                      Ignores inherited annotations.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodGetDeclaredAnnotations1_a类的运行时类clazz；
+ * -#step2: 以ii、String.class为参数，通过getMethod()方法获取clazz的方法对象并记为method1；
+ * -#step3: 通过判断得出method1.getDeclaredAnnotations().length的返回值为1，并通过getDeclaredAnnotations()方法获取
+ *          method1的所有被声明的注解并记为annotations1；
+ * -#step4: 经过判断得出annotations1[0].toString()包含字符串i_a=666和t_a=right1；
+ * -#step5: 以tt、int.class为参数，通过getDeclaredMethod()方法获取clazz的声明方法并记为method2；
+ * -#step6: 通过判断得出method2.getDeclaredAnnotations().length的返回值为1，并通过getDeclaredAnnotations()方法获取
+ *          method2的所有被声明的注解并记为annotations2；
+ * -#step7: 经过判断得出annotations2[0].toString()包含字符串i_a=666和t_a=right1；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTMethodGetDeclaredAnnotations1.java
+ *- @ExecuteClass: RTMethodGetDeclaredAnnotations1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw1 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+
+class MethodGetDeclaredAnnotations1 {
+    @IFw1(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+
+    @IFw1(i = 333, t = "test1")
+    void tt(int number) {
+    }
+}
+
+class MethodGetDeclaredAnnotations1_a extends MethodGetDeclaredAnnotations1 {
+    @IFw1_a(i_a = 666, t_a = "right1")
+    public static void ii(String name) {
+    }
+
+    @IFw1_a(i_a = 666, t_a = "right1")
+    void tt(int number) {
+    }
+}
+
+public class RTMethodGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetDeclaredAnnotations1_a");
+            Method method1 = clazz.getMethod("ii", String.class);
+            if (method1.getDeclaredAnnotations().length == 1) {
+                Annotation[] annotations1 = method1.getDeclaredAnnotations();
+                if (annotations1[0].toString().indexOf("i_a=666") != -1
+                        && annotations1[0].toString().indexOf("t_a=right1") != -1) {
+                    Method method2 = clazz.getDeclaredMethod("tt", int.class);
+                    if (method2.getDeclaredAnnotations().length == 1) {
+                        Annotation[] annotations2 = method2.getDeclaredAnnotations();
+                        if (annotations2[0].toString().indexOf("i_a=666") != -1
+                                && annotations2[0].toString().indexOf("t_a=right1") != -1) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..40327b25fcd2fc3d90ac2b9f5711d752543ef8d2
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java
@@ -0,0 +1,85 @@
+/*
+ *- @TestCaseID: RTMethodGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTMethodGetDeclaredAnnotations2.java
+ *- @Title/Destination: When the target class method has the same name as its parent class method, it is obtained by
+ *                      reflection as the annotation of the method in the target class, not the method of its parent
+ *                      class
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodGetDeclaredAnnotations2_a类的运行时类clazz；
+ * -#step2: 以ii、String.class为参数，通过getMethod()方法获取clazz的方法对象并记为method1；
+ * -#step3: 以tt为参数，通过getDeclaredMethod()方法获取clazz的声明方法并记为method2；
+ * -#step4: 经判断得知method1.getDeclaredAnnotations()和method2.getDeclaredAnnotations()的返回值的长度均为0；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTMethodGetDeclaredAnnotations2.java
+ *- @ExecuteClass: RTMethodGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+
+class MethodGetDeclaredAnnotations2 {
+    @IFw2(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+
+    @IFw2_a(i_a = 666, t_a = "right1")
+    void tt(int number) {
+    }
+}
+
+class MethodGetDeclaredAnnotations2_a extends MethodGetDeclaredAnnotations2 {
+    public static void ii(String name) {
+    }
+
+    void tt() {
+    }
+}
+
+public class RTMethodGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetDeclaredAnnotations2_a");
+            Method method1 = clazz.getMethod("ii", String.class);
+            Method method2 = clazz.getDeclaredMethod("tt");
+            if (method1.getDeclaredAnnotations().length == 0 && method2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/RTMethodGetDefaultValue1.java b/test/testsuite/ouroboros/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/RTMethodGetDefaultValue1.java
new file mode 100755
index 0000000000000000000000000000000000000000..e257eebb9d9353e723bab99ea5663723169d5f64
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/RTMethodGetDefaultValue1.java
@@ -0,0 +1,93 @@
+/*
+ *- @TestCaseID: RTMethodGetDefaultValue1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTMethodGetDefaultValue1.java
+ *- @Title/Destination: Method.getDefaultValue() Returns the default value for the annotation member represented by this
+  *                     Method instance. IF no default, return null.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法分别获取IF1_a类、IF1类、MethodGetDefaultValue1类的运行时类clazz1、clazz2、clazz3；
+ * -#step2: 分别以i_a、t为参数，通过getDeclaredMethod()方法分别获取clazz1、clazz2的声明方法并记为method1、method3；
+ * -#step3: 以t_a为参数，通过getMethod()方法获取clazz1的方法对象并记为method2；
+ * -#step4: 通过getMethods()方法获取clazz3的所有的方法对象并记为methods；
+ * -#step5: 分别以(tt、int.class)和s为参数，通过getDeclaredMethod()方法分别获取clazz3、clazz1的声明方法并记为method5、
+ *          method6；
+ * -#step6: 经判断得知method1.getDefaultValue()的返回值为2，method2.getDefaultValue().toString()的返回值与字符串
+ *          "string default value"相同；
+ * -#step7: 经判断得知method3.getDefaultValue()的返回值为空；
+ * -#step8: 经判断得知methods[0].getDefaultValue()、method5.getDefaultValue()的返回值均为null；
+ * -#step9: 经判断得知method6.getDefaultValue()的返回值为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTMethodGetDefaultValue1.java
+ *- @ExecuteClass: RTMethodGetDefaultValue1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    public int i_a() default 2;
+    String t_a() default "string default value";
+    String s();
+}
+
+class MethodGetDefaultValue1 {
+    @IF1(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+
+    void tt(int number) {
+    }
+}
+
+public class RTMethodGetDefaultValue1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("IF1_a");
+            Class clazz2 = Class.forName("IF1");
+            Class clazz3 = Class.forName("MethodGetDefaultValue1");
+            Method method1 = clazz1.getDeclaredMethod("i_a");
+            Method method2 = clazz1.getMethod("t_a");
+            Method method3 = clazz2.getDeclaredMethod("t");
+            Method[] methods = clazz3.getMethods();
+            Method method5 = clazz3.getDeclaredMethod("tt", int.class);
+            Method method6 = clazz1.getDeclaredMethod("s");
+            if ((int) method1.getDefaultValue() == 2
+                    && method2.getDefaultValue().toString().equals("string default value")) {
+                if (method3.getDefaultValue().equals("")) {
+                    if (methods[0].getDefaultValue() == null && method5.getDefaultValue() == null) {
+                        if (method6.getDefaultValue() == null) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/RTMethodGetParameterCount.java b/test/testsuite/ouroboros/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/RTMethodGetParameterCount.java
new file mode 100755
index 0000000000000000000000000000000000000000..6cf66206981c39b527fe05888ab3296ad831b939
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/RTMethodGetParameterCount.java
@@ -0,0 +1,55 @@
+/*
+ *- @TestCaseID: RTMethodGetParameterCount
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTMethodGetParameterCount.java
+ *- @Title/Destination: Method.GetParameterCount() Returns the number of formal parameters (whether explicitly declared
+ *                      or implicitly declared or neither) for the executable represented by this object.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodGetParameterCount2类的运行时类clazz；
+ * -#step2: 以test1为参数，通过getDeclaredMethod()方法获取clazz的声明方法并记为method1；
+ * -#step3: 通过getMethods()方法获取clazz的所有的方法对象并记为methods；
+ * -#step4: 经判断得知method.getParameterCount()的返回值为0，即method的参数个数为0；而methods[0].getParameterCount()的返
+ *          回值为9，即methods[0]的所有的参数个数为9；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTMethodGetParameterCount.java
+ *- @ExecuteClass: RTMethodGetParameterCount
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class MethodGetParameterCount2 {
+    void test1() {
+    }
+
+    public void test2(String name, int number, char c, short s, float f, double d, long l, boolean b, byte bb) {
+    }
+}
+
+public class RTMethodGetParameterCount {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetParameterCount2");
+            Method method = clazz.getDeclaredMethod("test1");
+            Method[] methods = clazz.getMethods();
+            if (method.getParameterCount() == 0) {
+                if (methods[0].getParameterCount() == 9) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/RTMethodGetTypeParameters.java b/test/testsuite/ouroboros/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/RTMethodGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..45cb699c52345fc32f8dc9622f4a6368941bc3ea
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/RTMethodGetTypeParameters.java
@@ -0,0 +1,56 @@
+/*
+ *- @TestCaseID: RTMethodGetTypeParameters
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTMethodGetTypeParameters.java
+ *- @Title/Destination: Method.GetTypeParameters() returns an array of TypeVariable objects that represent the type
+ *                      variables declared by the generic declaration in declaration order.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodGetTypeParameters2类的运行时类clazz；
+ * -#step2: 以ss、int.class为参数，通过getMethod()方法获取clazz的方法对象并记为method1；
+ * -#step3: 以kk为参数，通过getDeclaredMethod()方法获取clazz的声明方法并记为method2；
+ * -#step4: 通过getTypeParameters()方法分别获取method1、method2的所有的类型参数并记为typeVariables1、typeVariables2；
+ * -#step5: 经判断得知typeVariables1的长度为5，typeVariables2的长度为0；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTMethodGetTypeParameters.java
+ *- @ExecuteClass: RTMethodGetTypeParameters
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+import java.lang.reflect.TypeVariable;
+
+class MethodGetTypeParameters2 {
+    public <t, s, d, f, g> void ss(int number) {
+    }
+
+    void kk() {
+    }
+}
+
+public class RTMethodGetTypeParameters {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetTypeParameters2");
+            Method method1 = clazz.getMethod("ss", int.class);
+            Method method2 = clazz.getDeclaredMethod("kk");
+            TypeVariable[] typeVariables1 = method1.getTypeParameters();
+            TypeVariable[] typeVariables2 = method2.getTypeParameters();
+            if (typeVariables1.length == 5 && typeVariables2.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0097-rt-compact-RTMethonisDefault/RTMethodIsDefault.java b/test/testsuite/ouroboros/compact_test/RT0097-rt-compact-RTMethonisDefault/RTMethodIsDefault.java
new file mode 100755
index 0000000000000000000000000000000000000000..c8d4318cab3be82bc79b2fd1556be8d25927036b
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0097-rt-compact-RTMethonisDefault/RTMethodIsDefault.java
@@ -0,0 +1,63 @@
+/*
+ *- @TestCaseID: RTMethodIsDefault
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTMethodIsDefault.java
+ *- @Title/Destination: Verify through reflection whether the default method in the interface.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法分别获取MethodIsDefault_A类、MethodIsDefault类的运行时类clazz1、clazz2；
+ * -#step2: 以run为参数，通过getMethod()方法分别获取clazz1、clazz2的方法对象并记为method1、method2；
+ * -#step3: 以ss、int.class为参数，通过getDeclaredMethod()方法获取clazz2的声明方法并记为method3；
+ * -#step4: 经isDefault()判断得知method1是默认的；
+ * -#step5: 经isDefault()判断得知method2、method3不是默认的；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTMethodIsDefault.java
+ *- @ExecuteClass: RTMethodIsDefault
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+interface MethodIsDefault_A {
+    default public void run() {
+        String i;
+    }
+}
+
+class MethodIsDefault implements MethodIsDefault_A {
+    public void run() {
+        String i = "abc";
+    }
+
+    void ss(int number) {
+    }
+}
+
+public class RTMethodIsDefault {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("MethodIsDefault_A");
+            Class clazz2 = Class.forName("MethodIsDefault");
+            Method method1 = clazz1.getMethod("run");
+            Method method2 = clazz2.getMethod("run");
+            Method method3 = clazz2.getDeclaredMethod("ss", int.class);
+            if (method1.isDefault()) {
+                if (!method2.isDefault() && !method3.isDefault()) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e) {
+            System.err.println(e);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0098-rt-compact-RTMethontoGenericString/RTMethodToGenericString.java b/test/testsuite/ouroboros/compact_test/RT0098-rt-compact-RTMethontoGenericString/RTMethodToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..d6726a60546362606a350467a19e1d7535bc146c
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0098-rt-compact-RTMethontoGenericString/RTMethodToGenericString.java
@@ -0,0 +1,47 @@
+/*
+ *- @TestCaseID: RTMethodToGenericString
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTMethodToGenericString.java
+ *- @Title/Destination: Method.toGenericString() Returns a string describing this Method, including type parameters.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodToGenericString类的运行时类clazz；
+ * -#step2: 以ss、int.class为参数，通过getMethod()方法获取clazz的方法对象并记为method；
+ * -#step3: 通过method.toGenericString()返回的表示method的方法名称和类型参数与字符串
+ *          “public <t,s,d,f,g> void MethodToGenericString.ss(int)”相同；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTMethodToGenericString.java
+ *- @ExecuteClass: RTMethodToGenericString
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class MethodToGenericString {
+    public <t, s, d, f, g> void ss(int number) {
+    }
+}
+
+public class RTMethodToGenericString {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodToGenericString");
+            Method method = clazz.getMethod("ss", int.class);
+            if (method.toGenericString().equals("public <t,s,d,f,g> void MethodToGenericString.ss(int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/RTModifierParameterModifiers.java b/test/testsuite/ouroboros/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/RTModifierParameterModifiers.java
new file mode 100755
index 0000000000000000000000000000000000000000..23aeb744e0542388a22788887b6222ee96357905
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/RTModifierParameterModifiers.java
@@ -0,0 +1,31 @@
+/*
+ *- @TestCaseID: RTModifierParameterModifiers
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTModifierParameterModifiers.java
+ *- @Title/Destination: Verify that the integer value of the parameter modifier for the modifier class is 16.
+ *                      Modifier.parameterModifiers() return an int value OR-ing together the source language modifiers
+ *                      that can be applied to a parameter.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 经判断得知Modifier.parameterModifiers()的返回值为16，即修饰符类的参数修饰符的整数值为16；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTModifierParameterModifiers.java
+ *- @ExecuteClass: RTModifierParameterModifiers
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class RTModifierParameterModifiers {
+    public static void main(String[] args) {
+        if (Modifier.parameterModifiers() == 16) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/RTParameterGetAnnotation1.java b/test/testsuite/ouroboros/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/RTParameterGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..e6016177d96125d85cdc689fa98ba026b7d63179
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/RTParameterGetAnnotation1.java
@@ -0,0 +1,91 @@
+/*
+ *- @TestCaseID: RTParameterGetAnnotation1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTParameterGetAnnotation1.java
+ *- @Title/Destination: Parameter.getAnnotation() returns the method parameter's annotations for the specified type if
+ *                      such an annotation is present, else null.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法，不含注解的构造方法和有注解的方法。
+ * -#step2：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)获取注解，确认获取成功。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)获取注解，确认获取成功。
+ * -#step4：通过调用getDeclaredConstructor获取自定义类的不含注解的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)获取注解，确认获取为空。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTParameterGetAnnotation1.java
+ *- @ExecuteClass: RTParameterGetAnnotation1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetAnnotation1 {
+    ParameterGetAnnotation1(@IF1(i = 222, t = "Parameter") int number) {
+    }
+
+    public ParameterGetAnnotation1(String name) {
+    }
+
+    public void test1(@IF1_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+
+public class RTParameterGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotation1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            if (p1[0].getAnnotation(IF1.class).i() == 222 && p1[0].getAnnotation(IF1.class).t().equals("Parameter")
+                    && p3[0].getAnnotation(IF1_a.class).c() == 666
+                    && p3[0].getAnnotation(IF1_a.class).d().equals("Happy new year")) {
+                if (p2[0].getAnnotation(IF1.class) == null) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(2);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(3);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(4);
+            return;
+        }
+        System.out.println(5);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/RTParameterGetAnnotation2.java b/test/testsuite/ouroboros/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/RTParameterGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..cfc775269f73c57d31ca322d1da31391f7b2dbd7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/RTParameterGetAnnotation2.java
@@ -0,0 +1,101 @@
+/*
+ *- @TestCaseID: RTParameterGetAnnotation2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTParameterGetAnnotation2.java
+ *- @Title/Destination: If expected annotation not exist, getAnnotation() return null; if the given annotation class is
+ *                      null, getAnnotation() throws NullPointerException;
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法，和有注解的方法。
+ * -#step2：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)获取注解，参数annotationClass类型与实际注解类型不匹配，确认返回为空。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)获取注解，参数annotationClass类型与实际注解类型不匹配，确认返回为空。
+ * -#step4：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)并且继续调用注解的方法，参数annotationClass类型与实际注解类型不匹配，
+ *          确认抛出NullPointerException异常。
+ * -#step5：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)获取注解，参数annotationClass为null，确认抛出NullPointerException异常。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTParameterGetAnnotation2.java
+ *- @ExecuteClass: RTParameterGetAnnotation2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetAnnotation2 {
+    ParameterGetAnnotation2(@IF2(i = 222, t = "Parameter") int number) {
+    }
+
+    public void test1(@IF2_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+
+public class RTParameterGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotation2");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getAnnotation(IF2_a.class) == null && p2[0].getAnnotation(IF2.class) == null) {
+                p1[0].getAnnotation(IF2_a.class).c();
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        } catch (NullPointerException e2) {
+            try {
+                Class cls1 = Class.forName("ParameterGetAnnotation2");
+                Method method2 = cls1.getMethod("test1", int.class);
+                Parameter[] p3 = method2.getParameters();
+                p3[0].getAnnotation(null);
+                System.out.println(3);
+                return;
+            } catch (ClassNotFoundException e3) {
+                System.out.println(4);
+                return;
+            } catch (NoSuchMethodException e4) {
+                System.out.println(5);
+                return;
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(6);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/RTParameterGetAnnotations1.java b/test/testsuite/ouroboros/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/RTParameterGetAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..e9a5be1c41c3609004476b843025a9f425b7fd5e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/RTParameterGetAnnotations1.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: RTParameterGetAnnotations1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTParameterGetAnnotations1.java
+ *- @Title/Destination: Get all annotations of target class method parameters by reflection.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法，和不含注解的方法。
+ * -#step2：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用getAnnotations()获
+ *          取注解数组，确认注解数组长度为2。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用getAnnotations()获取注解数组，确认注
+ *          解数组长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTParameterGetAnnotations1.java
+ *- @ExecuteClass: RTParameterGetAnnotations1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF3 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF3_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetAnnotations1 {
+    ParameterGetAnnotations1(@IF3(i = 222, t = "Parameter") @IF3_a(c = 666, d = "Happy new year") int number) {
+    }
+
+    public void test1(String name) {
+    }
+}
+
+public class RTParameterGetAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotations1");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getAnnotations().length == 2 && p2[0].getAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/RTParameterGetAnnotationsByType1.java b/test/testsuite/ouroboros/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/RTParameterGetAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..27181e125d1979ede5fa6704a1a48f6090c71b81
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/RTParameterGetAnnotationsByType1.java
@@ -0,0 +1,96 @@
+/*
+ *- @TestCaseID: RTParameterGetAnnotationsByType1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTParameterGetAnnotationsByType1.java
+ *- @Title/Destination: Parameters.getAnnotationsByType returns all this element's annotations for the specified
+ *                     annotation type if associated with this element, else an array of length zero。
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法，不含注解的构造方法，含注解的方法。
+ * -#step2：通过调用getConstructor获取自定义类的不含注解的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为注解类型，确认注解数组长度为0。
+ * -#step3：通过调用getDeclaredConstructor获取自定义类的含注解的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为对应的注解类型，对注解数组调用
+ *          toString().indexOf(str)判断注解的值是否正确。
+ * -#step4：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为对应的注解类型，对注解数组调用
+ *          toString().indexOf(str)判断注解的值是否正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTParameterGetAnnotationsByType1.java
+ *- @ExecuteClass: RTParameterGetAnnotationsByType1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF7 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF7_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetAnnotationsByType1 {
+    ParameterGetAnnotationsByType1(@IF7(i = 222, t = "Parameter") int number) {
+    }
+
+    public ParameterGetAnnotationsByType1(String name) {
+    }
+
+    public void test1(@IF7_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+
+public class RTParameterGetAnnotationsByType1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotationsByType1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            Annotation[] q1 = p1[0].getAnnotationsByType(IF7.class);
+            Annotation[] q3 = p3[0].getAnnotationsByType(IF7_a.class);
+            if (p2[0].getAnnotationsByType(IF7.class).length == 0) {
+                if (q1[0].toString().indexOf("i=222") != -1 && q1[0].toString().indexOf("t=Parameter") != -1
+                        && q3[0].toString().indexOf("c=666") != -1
+                        && q3[0].toString().indexOf("d=Happy new year") != -1) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(1);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(4);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java b/test/testsuite/ouroboros/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java
new file mode 100755
index 0000000000000000000000000000000000000000..9f09e26dd6103e1db50ecced97a3b176ea29c480
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java
@@ -0,0 +1,102 @@
+/*
+ *- @TestCaseID: RTParameterGetAnnotationsByType2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTParameterGetAnnotationsByType2.java
+ *- @Title/Destination:Parameter.getAnnotationsByType() return an array of length zero if no expected annotation found;
+ *                     getAnnotationsByType(null) throws NullPointerException.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法，和不含注解的方法。
+ * -#step2：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为非对应的注解类型，对注解数组q1
+ *          调用q1[0].toString(), 检查会有ArrayIndexOutOfBoundsException抛出。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为非对应的注解类型，对注解数组q2
+ *          调用q2[0].toString(), 检查会有ArrayIndexOutOfBoundsException抛出。
+ * -#step4：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为null，检查会有
+ *          NullPointerException抛出。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTParameterGetAnnotationsByType2.java
+ *- @ExecuteClass: RTParameterGetAnnotationsByType2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF8 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF8_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetAnnotationsByType2 {
+    ParameterGetAnnotationsByType2(@IF8(i = 222, t = "Parameter") int number) {
+    }
+
+    public void test1(@IF8_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+
+public class RTParameterGetAnnotationsByType2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotationsByType2");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            Annotation[] q1 = p1[0].getAnnotationsByType(IF8_a.class);
+            Annotation[] q2 = p2[0].getAnnotationsByType(IF8.class);
+            q1[0].toString();
+            q2[0].toString();
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        } catch (ArrayIndexOutOfBoundsException e2) {
+            try {
+                Class cls1 = Class.forName("ParameterGetAnnotationsByType2");
+                Constructor cons1 = cls1.getDeclaredConstructor(int.class);
+                Parameter[] p3 = cons1.getParameters();
+                Annotation[] q3 = p3[0].getAnnotationsByType(null);
+                System.out.println(3);
+                return;
+            } catch (ClassNotFoundException e3) {
+                System.out.println(4);
+                return;
+            } catch (NoSuchMethodException e4) {
+                System.out.println(5);
+                return;
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(6);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/RTParameterGetDeclaredAnnotation1.java b/test/testsuite/ouroboros/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/RTParameterGetDeclaredAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..100c7b6bef8399cfd4bfc2459c3d045afde903b3
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/RTParameterGetDeclaredAnnotation1.java
@@ -0,0 +1,94 @@
+/*
+ *- @TestCaseID: RTParameterGetDeclaredAnnotation1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTParameterGetDeclaredAnnotation1.java
+ *- @Title/Destination: Parameter.getDeclaredAnnotation() Returns this element's annotation for the specified type if
+ *                     such an annotation is directly present, else null. This method ignores inherited annotations.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法，不含注解的构造方法和含注解的方法。
+ * -#step2：通过调用getDeclaredConstructor获取有注解的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getDeclaredAnnotation(Class<T> annotationClass)获取注解，annotationClass为对应的注解类型，确认获取的注解内容
+ *          正确。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getDeclaredAnnotation(Class<T> annotationClass)获取注解，annotationClass为对应的注解类型，确认获取的注解内容
+ *          正确。
+ * -#step4：通过调用getDeclaredConstructor获取不含注解的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getDeclaredAnnotation(Class<T> annotationClass)获取注解，annotationClass为注解类型，确认返回为空。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTParameterGetDeclaredAnnotation1.java
+ *- @ExecuteClass: RTParameterGetDeclaredAnnotation1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF6 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF6_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetDeclaredAnnotation1 {
+    ParameterGetDeclaredAnnotation1(@IF6(i = 222, t = "Parameter") int number) {
+    }
+
+    public ParameterGetDeclaredAnnotation1(String name) {
+    }
+
+    public void test1(@IF6_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+
+public class RTParameterGetDeclaredAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotation1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            if (p1[0].getDeclaredAnnotation(IF6.class).i() == 222 && p1[0].getDeclaredAnnotation(IF6.class).t()
+                    .equals("Parameter") && p3[0].getDeclaredAnnotation(IF6_a.class).c() == 666
+                    && p3[0].getDeclaredAnnotation(IF6_a.class).d().equals("Happy new year")) {
+                if (p2[0].getDeclaredAnnotation(IF6.class) == null) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(1);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(4);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/RTParameterGetDeclaredAnnotations1.java b/test/testsuite/ouroboros/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/RTParameterGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..2dc36e8e034a7836216bfe41dd87337519f663bd
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/RTParameterGetDeclaredAnnotations1.java
@@ -0,0 +1,79 @@
+/*
+ *- @TestCaseID: RTParameterGetDeclaredAnnotations1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTParameterGetDeclaredAnnotations1.java
+ *- @Title/Destination: Parameter.getDeclaredAnnotations() returns annotations that are directly present on this element.
+ *                      This method ignores inherited annotations.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法和不含注解的方法。
+ * -#step2：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getDeclaredAnnotations()获取注解数组，检查数组长度为2。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用getDeclaredAnnotations()获取注
+ *          解数组，检查数组长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTParameterGetDeclaredAnnotations1.java
+ *- @ExecuteClass: RTParameterGetDeclaredAnnotations1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF5 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF5_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetDeclaredAnnotations1 {
+    ParameterGetDeclaredAnnotations1(@IF5(i = 222, t = "Parameter") @IF5_a(c = 666, d = "Happy new year") int number) {
+    }
+
+    public void test1(String name) {
+    }
+}
+
+public class RTParameterGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotations1");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getDeclaredAnnotations().length == 2 && p2[0].getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..48baeff31a61473c4f73fe2354dea29edb75d89e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java
@@ -0,0 +1,103 @@
+/*
+ *- @TestCaseID: RTParameterGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTParameterGetDeclaredAnnotations2.java
+ *- @Title/Destination: Parameter.getDeclaredAnnotations() returns annotations that are directly present on this element.
+ *                      This method ignores inherited annotations. If there are no annotations directly present on this
+ *                      element, the return value is an array of length 0.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1：创建一个类1，含有注解和无注解的构造方法和有注解方法。创建一个子类2继承类1，含有注解和无注解的构造方法和有注
+ *          解方法。创建子类3继承类2，重写构造方法和方法，均为无注解。
+ * -#step2：通过调用getDeclaredConstructor获取自定义类3的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getDeclaredAnnotations()获取注解数组，检查数组长度为0。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用getDeclaredAnnotations()获取注
+ *          解数组，检查数组长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTParameterGetDeclaredAnnotations2.java
+ *- @ExecuteClass: RTParameterGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF4 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF4_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetDeclaredAnnotations2 {
+    ParameterGetDeclaredAnnotations2() {
+    }
+
+    ParameterGetDeclaredAnnotations2(@IF4(i = 222, t = "Parameter") int number) {
+    }
+
+    public void test1(@IF4(i = 222, t = "Parameter") String name) {
+    }
+}
+
+class ParameterGetDeclaredAnnotations2_a extends ParameterGetDeclaredAnnotations2 {
+    ParameterGetDeclaredAnnotations2_a() {
+    }
+
+    ParameterGetDeclaredAnnotations2_a(@IF4_a(c = 666, d = "Happy new year") int number) {
+    }
+
+    public void test1(@IF4_a(c = 666, d = "Happy new year") String name) {
+    }
+}
+
+class ParameterGetDeclaredAnnotations2_b extends ParameterGetDeclaredAnnotations2_a {
+    ParameterGetDeclaredAnnotations2_b(int number) {
+    }
+
+    public void test1(String name) {
+    }
+}
+
+public class RTParameterGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotations2_b");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getDeclaredAnnotations().length == 0 && p2[0].getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/RTParameterGetDeclaredAnnotationsByType1.java b/test/testsuite/ouroboros/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/RTParameterGetDeclaredAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..e6d4cf7723a480b267f4e74aac40c112f234d656
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/RTParameterGetDeclaredAnnotationsByType1.java
@@ -0,0 +1,98 @@
+/*
+ *- @TestCaseID: RTParameterGetDeclaredAnnotationsByType1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTParameterGetDeclaredAnnotationsByType1.java
+ *- @Title/Destination: Parameter.getDeclaredAnnotationsByType() returns this element's annotation(s) for the specified
+ *                      type if such annotations are either directly present or indirectly present. This method ignores
+ *                      inherited annotations.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法，不含注解的构造方法和含注解的方法。
+ * -#step2：通过调用getConstructor获取自定义类的不含注解的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getDeclaredAnnotationsByType(Class annotationClass)获取注解数组，annotationClass为注解类型，确认注解数组长度
+ *          为0。
+ * -#step3：通过调用getDeclaredConstructor获取自定义类的含注解的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getDeclaredAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为对应的注解类型，对注解
+ *          数组调用toString().indexOf(str)判断注解的值是否正确。
+ * -#step4：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getDeclaredAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为对应的注解类型，对注解
+ *          数组调用toString().indexOf(str)判断注解的值是否正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTParameterGetDeclaredAnnotationsByType1.java
+ *- @ExecuteClass: RTParameterGetDeclaredAnnotationsByType1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF9 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF9_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetDeclaredAnnotationsByType1 {
+    ParameterGetDeclaredAnnotationsByType1(@IF9(i = 222, t = "Parameter") int number) {
+    }
+
+    public ParameterGetDeclaredAnnotationsByType1(String name) {
+    }
+
+    public void test1(@IF9_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+
+public class RTParameterGetDeclaredAnnotationsByType1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotationsByType1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            Annotation[] q1 = p1[0].getDeclaredAnnotationsByType(IF9.class);
+            Annotation[] q3 = p3[0].getDeclaredAnnotationsByType(IF9_a.class);
+            if (p2[0].getDeclaredAnnotationsByType(IF9.class).length == 0) {
+                if (q1[0].toString().indexOf("i=222") != -1 && q1[0].toString().indexOf("t=Parameter") != -1
+                        && q3[0].toString().indexOf("c=666") != -1
+                        && q3[0].toString().indexOf("d=Happy new year") != -1) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(1);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(4);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/RTProxyGetProxyClass1.java b/test/testsuite/ouroboros/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/RTProxyGetProxyClass1.java
new file mode 100755
index 0000000000000000000000000000000000000000..ba24db6743c4cd46760ba3f15897787c7fdadf60
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/RTProxyGetProxyClass1.java
@@ -0,0 +1,144 @@
+/*
+ *- @TestCaseID: RTProxyGetProxyClass1
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:RTProxyGetProxyClass1.java
+ *- @Title/Destination: Verify that there are more than 30 methods in the class that perform the proxy, and you can
+ *                     construct the proxy function normally.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: 构造接口1有30个default方法，接口2继承接口1，接口3有1个方法。
+ * -#step2：创建参数1loader为接口1的类加载器，参数2interfaces为class数组，成员为接口1的class,接口2的class。
+ * -#step3：调用Proxy的静态方法getProxyClass(ClassLoader loader, Class<?>... interfaces)。
+ * -#step4：确认无异常抛出。
+ * -#step5：创建参数1loader为接口1的类加载器，参数2interfaces为class数组，成员为接口1的class,接口3的class。
+ * -#step6：调用Proxy的静态方法getProxyClass(ClassLoader loader, Class<?>... interfaces)。
+ * -#step7：确认无异常抛出。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: RTProxyGetProxyClass1.java
+ *- @ExecuteClass: RTProxyGetProxyClass1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Proxy;
+
+interface ProxyGetProxyClass1_1 {
+    default void test1() {
+    }
+
+    default void test2() {
+    }
+
+    default void test3() {
+    }
+
+    default void test4() {
+    }
+
+    default void test5() {
+    }
+
+    default void test6() {
+    }
+
+    default void test7() {
+    }
+
+    default void test8() {
+    }
+
+    default void test9() {
+    }
+
+    default void test10() {
+    }
+
+    default void test11() {
+    }
+
+    default void test12() {
+    }
+
+    default void test13() {
+    }
+
+    default void test14() {
+    }
+
+    default void test15() {
+    }
+
+    default void test16() {
+    }
+
+    default void test17() {
+    }
+
+    default void test18() {
+    }
+
+    default void test19() {
+    }
+
+    default void test20() {
+    }
+
+    default void test21() {
+    }
+
+    default void test22() {
+    }
+
+    default void test23() {
+    }
+
+    default void test24() {
+    }
+
+    default void test25() {
+    }
+
+    default void test26() {
+    }
+
+    default void test27() {
+    }
+
+    default void test28() {
+    }
+
+    default void test29() {
+    }
+
+    default void test30() {
+    }
+}
+
+interface ProxyGetProxyClass1_2 extends ProxyGetProxyClass1_1 {
+    default void test30() {
+    }
+}
+
+interface ProxyGetProxyClass1_3 {
+    default void test31() {
+    }
+}
+
+public class RTProxyGetProxyClass1 {
+    public static void main(String[] args) {
+        try {
+            Proxy.getProxyClass(ProxyGetProxyClass1_1.class.getClassLoader(), new Class[] {ProxyGetProxyClass1_1.class,
+                    ProxyGetProxyClass1_2.class});
+            Proxy.getProxyClass(ProxyGetProxyClass1_1.class.getClassLoader(), new Class[] {ProxyGetProxyClass1_1.class,
+                    ProxyGetProxyClass1_3.class});
+        } catch (IllegalArgumentException e) {
+            System.err.println(e);
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java b/test/testsuite/ouroboros/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java
new file mode 100755
index 0000000000000000000000000000000000000000..de4bb54a6531b031c1a3a260aa73978a3fc48df2
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java
@@ -0,0 +1,58 @@
+/*
+ *- @TestCaseID: ClassGetDeclaredAnnotationNPE
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassGetDeclaredAnnotationNPE.java
+ *- @Title/Destination: Class.getDeclaredAnnotation(null) throws NullPointerException
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 定义内部类MyClass, 获取class MyClass。
+ *  -#step2：调用getDeclaredAnnotation(Class<A> annotationClass), annotationClass为Deprecated.class。
+ *  -#step3：确认无异常抛出。
+ *  -#step4：调用getDeclaredAnnotation(Class<A> annotationClass), annotationClass为null。
+ *  -#step5：确认抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassGetDeclaredAnnotationNPE.java
+ *- @ExecuteClass: ClassGetDeclaredAnnotationNPE
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.Annotation;
+
+public class ClassGetDeclaredAnnotationNPE {
+    public static void main(String argv[]) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = ClassGetDeclaredAnnotationNPE_1();
+        } catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetDeclaredAnnotationNPE_1() {
+        try {
+            Annotation a = MyClass.class.getDeclaredAnnotation(Deprecated.class);
+            a = MyClass.class.getDeclaredAnnotation(null);
+        } catch (NullPointerException e) {
+            return 0;
+        }
+        return 4;
+    }
+
+    @Deprecated
+    class MyClass extends MySuperClass {
+    }
+
+    @MyAnnotation
+    class MySuperClass {
+    }
+
+    @interface MyAnnotation {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java b/test/testsuite/ouroboros/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java
new file mode 100755
index 0000000000000000000000000000000000000000..a186e156bc69dcdcdc63dd4813708cd3b4a38b69
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java
@@ -0,0 +1,48 @@
+/*
+ *- @TestCaseID: ClassIsAssignableFromNPE
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassIsAssignableFromNPE.java
+ *- @Title/Destination: Test isAssignableFrom( null ) throws NullPointerException of class.
+ *- @Condition: no
+ *- @Brief:no:
+ *  -#step1: 定义一个int数组intArray，获取intArray的class。
+ *  -#step2：调用isAssignableFrom(Class<?> cls), cls为null。
+ *  -#step3：确认抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassIsAssignableFromNPE.java
+ *- @ExecuteClass: ClassIsAssignableFromNPE
+ *- @ExecuteArgs:
+ */
+
+public class ClassIsAssignableFromNPE {
+    public static void main(String argv[]) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = ClassIsAssignableFromNPE_1();
+        } catch (Exception e) {
+            System.out.println(e);
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassIsAssignableFromNPE_1() {
+        int result1 = 4; /* STATUS_FAILED */
+        int intArray[] = {1, 2, 3, 4, 5};
+        Class cl = null;
+        try {
+            intArray.getClass().isAssignableFrom(cl);
+        } catch (SecurityException e) {
+            return 1;
+        } catch (NullPointerException e) {
+            return 0;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java b/test/testsuite/ouroboros/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..f0c2f92fab7c7b1967d3774ad8e2e0a40cadff31
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java
@@ -0,0 +1,78 @@
+/*
+ * - @TestCaseID: ClassGetAnnotationsByType
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassGetAnnotationsByType.java
+ * - @Title/Destination: Class have no Annotation and method have annotation, Class.getAnnotationsByType() return an
+ *                       array of length 0.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest0。
+ *  -#step2：获取class MyTargetTest0。
+ *  -#step3：调用getAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的注解数组。
+ *  -#step4：确认获取的注解数组个数大于0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ClassGetAnnotationsByType.java
+ * - @ExecuteClass: ClassGetAnnotationsByType
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ClassGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetAnnotationsByType1() {
+        Class<MyTargetTest0> m;
+        try {
+            m = MyTargetTest0.class;
+            MyTarget[] Target = m.getAnnotationsByType(MyTarget.class);
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest0 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest0(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0113-rt-compact-ClassGetCanonicalName/ClassGetCanonicalName.java b/test/testsuite/ouroboros/compact_test/RT0113-rt-compact-ClassGetCanonicalName/ClassGetCanonicalName.java
new file mode 100755
index 0000000000000000000000000000000000000000..bbb5d83a1fbf4e70691415690f76620b26fafe9e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0113-rt-compact-ClassGetCanonicalName/ClassGetCanonicalName.java
@@ -0,0 +1,78 @@
+/*
+ * - @TestCaseID: ClassGetCanonicalName
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassGetCanonicalName.java
+ * - @Title/Destination: Class.getCanonicalName() Returns the canonical name of the underlying class as defined by the
+ *                       Java Language Specification.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest1。
+ *  -#step2：获取class MyTargetTest1。
+ *  -#step3：调用getCanonicalName()获取所定义的底层类的规范化名称。
+ *  -#step4：确认返回的规范化名称正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ClassGetCanonicalName.java
+ * - @ExecuteClass: ClassGetCanonicalName
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ClassGetCanonicalName {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetCanonicalName1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetCanonicalName1() {
+        Class<MyTargetTest1> m;
+        try {
+            m = MyTargetTest1.class;
+            String str = m.getCanonicalName();
+            if ("ClassGetCanonicalName.MyTargetTest1".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest1 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest1(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/ClassGetEnclosingClass.java b/test/testsuite/ouroboros/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/ClassGetEnclosingClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..1ef7a2933694c01728308d28e17ce5489ef7f867
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/ClassGetEnclosingClass.java
@@ -0,0 +1,77 @@
+/*
+ * - @TestCaseID: ClassGetEnclosingClass
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassGetEnclosingClass.java
+ * - @Title/Destination: Class.getEnclosingClass() Returns the immediately enclosing class of the underlying class.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest2。
+ *  -#step2：获取class MyTargetTest2。
+ *  -#step3：调用getEnclosingClass()获取底层类的立即封闭类。
+ *  -#step4：确认返回不为空。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ClassGetEnclosingClass.java
+ * - @ExecuteClass: ClassGetEnclosingClass
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ClassGetEnclosingClass {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetEnclosingClass1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetEnclosingClass1() {
+        Class<MyTargetTest2> m;
+        try {
+            m = MyTargetTest2.class;
+            Class<?> cl = m.getEnclosingClass();
+            if (cl != null) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest2 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest2(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0115-rt-compact-ClassGetEnumConstants/ClassGetEnumConstants.java b/test/testsuite/ouroboros/compact_test/RT0115-rt-compact-ClassGetEnumConstants/ClassGetEnumConstants.java
new file mode 100755
index 0000000000000000000000000000000000000000..5fc17a64f11d5ee3caffc2c4a1a3a233d283dc1b
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0115-rt-compact-ClassGetEnumConstants/ClassGetEnumConstants.java
@@ -0,0 +1,77 @@
+/*
+ * - @TestCaseID: ClassGetEnumConstants
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassGetEnumConstants.java
+ * - @Title/Destination: Class getEnumConstants() return null when there is no enum in the class。
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest3。
+ *  -#step2：获取class MyTargetTest3。
+ *  -#step3：调用getEnumConstants()获取枚举类的元素。
+ *  -#step4：确认返回为空。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ClassGetEnumConstants.java
+ * - @ExecuteClass: ClassGetEnumConstants
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ClassGetEnumConstants {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetEnumConstants1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetEnumConstants1() {
+        Class<MyTargetTest3> m;
+        try {
+            m = MyTargetTest3.class;
+            MyTargetTest3[] target = m.getEnumConstants();
+            if (target == null) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest3 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest3(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0116-rt-compact-ClassGetSimpleName/ClassGetSimpleName.java b/test/testsuite/ouroboros/compact_test/RT0116-rt-compact-ClassGetSimpleName/ClassGetSimpleName.java
new file mode 100755
index 0000000000000000000000000000000000000000..ec136fa745cc8a818adf8bb1195025b6a6b0385e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0116-rt-compact-ClassGetSimpleName/ClassGetSimpleName.java
@@ -0,0 +1,78 @@
+/*
+ * - @TestCaseID: ClassGetSimpleName
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassGetSimpleName.java
+ * - @Title/Destination: Class.getSimpleName() return Returns the simple name of the underlying class as given in the
+ *                       source code。
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest4。
+ *  -#step2：获取class MyTargetTest4。
+ *  -#step3：调用getSimpleName()获取底层类的简称。
+ *  -#step4：确认返回的名称正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ClassGetSimpleName.java
+ * - @ExecuteClass: ClassGetSimpleName
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ClassGetSimpleName {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetSimpleName1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetSimpleName1() {
+        Class<MyTargetTest4> m;
+        try {
+            m = MyTargetTest4.class;
+            String str = m.getSimpleName();
+            if ("MyTargetTest4".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest4 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest4(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0117-rt-compact-ClassGetTypeParameters/ClassGetTypeParameters.java b/test/testsuite/ouroboros/compact_test/RT0117-rt-compact-ClassGetTypeParameters/ClassGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..b69f5a81baf206c2dd40f9a095297af87e6d3ca1
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0117-rt-compact-ClassGetTypeParameters/ClassGetTypeParameters.java
@@ -0,0 +1,80 @@
+/*
+ * - @TestCaseID: ClassGetTypeParameters
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassGetTypeParameters.java
+ * - @Title/Destination: Class.getTypeParameters() return an array of TypeVariable objects that represent the type
+ *                       variables declared by the generic declaration represented by this GenericDeclaration object,
+ *                       in declaration order.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest5。
+ *  -#step2：获取class MyTargetTest5。
+ *  -#step3：调用getTypeParameters()获取TypeVariable对象的一个数组。
+ *  -#step4：确认返回的数组的长度为0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ClassGetTypeParameters.java
+ * - @ExecuteClass: ClassGetTypeParameters
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.TypeVariable;
+
+public class ClassGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetTypeParameters1() {
+        Class<MyTargetTest5> m;
+        try {
+            m = MyTargetTest5.class;
+            TypeVariable<Class<MyTargetTest5>>[] target = m.getTypeParameters();
+            if (target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest5 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest5(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0118-rt-compact-ClassToGenericString/ClassToGenericString.java b/test/testsuite/ouroboros/compact_test/RT0118-rt-compact-ClassToGenericString/ClassToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..350b8843ca514365043ee39bfdf6277ea088fe2e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0118-rt-compact-ClassToGenericString/ClassToGenericString.java
@@ -0,0 +1,79 @@
+/*
+ * - @TestCaseID: ClassToGenericString
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassToGenericString.java
+ * - @Title/Destination: Class.toGenericString() returns a string describing this Class, including information about
+ *                       modifiers and type parameters.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest5。
+ *  -#step2：获取class MyTargetTest5。
+ *  -#step3：调用toGenericString()获取描述此class的字符串。
+ *  -#step4：确认返回的描述正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ClassToGenericString.java
+ * - @ExecuteClass: ClassToGenericString
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ClassToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+
+        try {
+            result = ClassToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassToGenericString1() {
+        Class<MyTargetTest6> m;
+        try {
+            m = MyTargetTest6.class;
+            String str = m.toGenericString();
+            if ("class ClassToGenericString$MyTargetTest6".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest6 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest6(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/ConstructorGetAnnotation.java b/test/testsuite/ouroboros/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/ConstructorGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..394b7effb1d7886a8169b28947bb95502f3f1d84
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/ConstructorGetAnnotation.java
@@ -0,0 +1,81 @@
+/*
+ * - @TestCaseID: ConstructorGetAnnotation.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ConstructorGetAnnotation.java
+ * - @Title/Destination: Constructor.getAnnotation() return the annotation as expected.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest00。
+ *  -#step2：通过调用getConstructor(Class[])从内部类MyTargetTest00中获取对应的构造方法。
+ *  -#step3：调用getAnnotation(Class<T> annotationClass)从构造方法中获取类型为MyTarget的注解。
+ *  -#step4：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ConstructorGetAnnotation.java
+ * - @ExecuteClass: ConstructorGetAnnotation
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+
+public class ConstructorGetAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+
+        try {
+            result = ConstructorAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ConstructorAnnotation1() {
+        Constructor<?> m;
+        try {
+            m = MyTargetTest00.class.getConstructor(new Class[] {ConstructorGetAnnotation.class, String.class});
+            MyTarget Target = m.getAnnotation(MyTarget.class);
+            if ("@ConstructorGetAnnotation$MyTarget(name=cons, value=constructor)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest00 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest00(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/ConstructorGetDeclaredAnnotations.java b/test/testsuite/ouroboros/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/ConstructorGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..e139086ae950956f4b51d52859fb17686650a3c8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/ConstructorGetDeclaredAnnotations.java
@@ -0,0 +1,80 @@
+/*
+ * - @TestCaseID: ConstructorGetDeclaredAnnotations.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ConstructorGetDeclaredAnnotations.java
+ * - @Title/Destination: Constructor.getDeclaredAnnotation() returns this element's annotation for the specified type if such an annotation is directly present.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest01。
+ *  -#step2：通过调用getConstructor(Class[])从内部类MyTargetTest01中获取对应的构造方法。
+ *  -#step3：调用getDeclaredAnnotation(Class<T> annotationClass)从构造方法中获取类型为MyTarget的注解。
+ *  -#step4：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ConstructorGetDeclaredAnnotations.java
+ * - @ExecuteClass: ConstructorGetDeclaredAnnotations
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+
+public class ConstructorGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ConstructorGetDeclaredAnnotations1() {
+        Constructor<MyTargetTest01> m;
+        try {
+            m = MyTargetTest01.class.getConstructor(new Class[] {ConstructorGetDeclaredAnnotations.class, String.class});
+            MyTarget Target = m.getDeclaredAnnotation(MyTarget.class);
+            if ("@ConstructorGetDeclaredAnnotations$MyTarget(name=cons, value=constructor)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest01 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest01(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java b/test/testsuite/ouroboros/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java
new file mode 100755
index 0000000000000000000000000000000000000000..ffaf0ef1bf8ce88eb49b617d8618636671cd68d0
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java
@@ -0,0 +1,81 @@
+/*
+ * - @TestCaseID: ConstructorGetExceptionTypes.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ConstructorGetExceptionTypes.java
+ * - @Title/Destination: Constructor.getExceptionTypes() returns an array of length 0 if the executable declares no
+ *                       exceptions in its throws clause.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest02。
+ *  -#step2：通过调用getConstructor(Class[])从内部类MyTargetTest02中获取对应的构造方法。
+ *  -#step3：调用getExceptionTypes()获取抛出的异常类型的Class对象的数组。
+ *  -#step4：确认返回的数组长度是0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ConstructorGetExceptionTypes.java
+ * - @ExecuteClass: ConstructorGetExceptionTypes
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+
+public class ConstructorGetExceptionTypes {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetExceptionTypes1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ConstructorGetExceptionTypes1() {
+        Constructor<MyTargetTest02> m;
+        try {
+            m = MyTargetTest02.class.getConstructor(new Class[] {ConstructorGetExceptionTypes.class, String.class});
+            Class<?>[] Target = m.getExceptionTypes();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest02 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest02(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java b/test/testsuite/ouroboros/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..0009de70c4d77f19c228baee1805db370f72ab54
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java
@@ -0,0 +1,82 @@
+/*
+ * - @TestCaseID: ConstructorGetTypeParameters.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ConstructorGetTypeParameters.java
+ * - @Title/Destination: Constructor.getTypeParameters() returns an array of length 0 if the underlying generic
+ *                       declaration declares no type variables.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest03。
+ *  -#step2：通过调用getConstructor(Class[])从内部类MyTargetTest03中获取对应的构造方法。
+ *  -#step3：调用getTypeParameters()获取TypeVariable对象的数组。
+ *  -#step4：确认返回的数组长度是0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ConstructorGetTypeParameters.java
+ * - @ExecuteClass: ConstructorGetTypeParameters
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.TypeVariable;
+
+public class ConstructorGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ConstructorGetTypeParameters1() {
+        Constructor<MyTargetTest03> m;
+        try {
+            m = MyTargetTest03.class.getConstructor(new Class[] {ConstructorGetTypeParameters.class, String.class});
+            TypeVariable<Constructor<MyTargetTest03>>[] Target = m.getTypeParameters();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest03 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest03(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0123-rt-compact-ConstructorToGenericString/ConstructorToGenericString.java b/test/testsuite/ouroboros/compact_test/RT0123-rt-compact-ConstructorToGenericString/ConstructorToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..5769f5834bb95a82f3ebc555c1fa31788094d2d4
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0123-rt-compact-ConstructorToGenericString/ConstructorToGenericString.java
@@ -0,0 +1,82 @@
+/*
+ * - @TestCaseID: ConstructorToGenericString.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ConstructorToGenericString.java
+ * - @Title/Destination: Constructor.toGenericString() returns a string describing this Constructor, including type
+ *                       parameters.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest04。
+ *  -#step2：通过调用getConstructor(Class[])从内部类MyTargetTest04中获取对应的构造方法。
+ *  -#step3：调用toGenericString()获取描述此Field的字符串。
+ *  -#step4：确认返回的描述正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ConstructorToGenericString.java
+ * - @ExecuteClass: ConstructorToGenericString
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+
+public class ConstructorToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ConstructorToGenericString1() {
+        Constructor<MyTargetTest04> m;
+        try {
+            m = MyTargetTest04.class.getConstructor(new Class[] {ConstructorToGenericString.class, String.class});
+            String str = m.toGenericString();
+            if ("public ConstructorToGenericString$MyTargetTest04(ConstructorToGenericString,java.lang.String)"
+                    .equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest04 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest04(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0124-rt-compact-FieldGetAnnotation/FieldGetAnnotation.java b/test/testsuite/ouroboros/compact_test/RT0124-rt-compact-FieldGetAnnotation/FieldGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..a7d47f865288b6b80c18baf73f300bcbffa08ce2
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0124-rt-compact-FieldGetAnnotation/FieldGetAnnotation.java
@@ -0,0 +1,72 @@
+/*
+ * - @TestCaseID: FieldGetAnnotation.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:FieldGetAnnotation.java
+ * - @Title/Destination: Field.getAnnotation() Returns the Field's annotation for the specified type if such an
+ *                       annotation is present.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest06。
+ *  -#step2：通过调用getField()从内部类MyTargetTest06中获取home。
+ *  -#step3：调用getAnnotation(Class<T> annotationClass)获取类型为MyTarget的注解。
+ *  -#step4：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: FieldGetAnnotation.java
+ * - @ExecuteClass: FieldGetAnnotation
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+
+public class FieldGetAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldGetAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int FieldGetAnnotation1() {
+        Field m;
+        try {
+            m = MyTargetTest06.class.getField("home");
+            MyTarget Target = m.getAnnotation(MyTarget.class);
+            if ("@FieldGetAnnotation$MyTarget(name=newName, value=newValue)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest06 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/FieldGetAnnotationsByType.java b/test/testsuite/ouroboros/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/FieldGetAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..44d19ffaad762bc287c53f8fd586ba4f3234bc65
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/FieldGetAnnotationsByType.java
@@ -0,0 +1,80 @@
+/*
+ * - @TestCaseID: FieldGetAnnotationsByType.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:FieldGetAnnotationsByType.java
+ * - @Title/Destination: Field.getAnnotationsByType() returns annotations that are associated with this element.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest07。
+ *  -#step2：通过调用getField()从内部类MyTargetTest07中获取home。
+ *  -#step3：调用getAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的注解数组。
+ *  -#step4：确认获取的注解数组个数大于0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: FieldGetAnnotationsByType.java
+ * - @ExecuteClass: FieldGetAnnotationsByType
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+
+public class FieldGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int FieldGetAnnotationsByType1() {
+        Field m;
+        try {
+            m = MyTargetTest07.class.getField("home");
+            MyTarget[] Target = m.getAnnotationsByType(MyTarget.class);
+            if (Target.length > 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest07 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest07(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/FieldGetDeclaredAnnotations.java b/test/testsuite/ouroboros/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/FieldGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..c5ad4e66401a3793bcda73b5607e091e0e91e875
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/FieldGetDeclaredAnnotations.java
@@ -0,0 +1,80 @@
+/*
+ * - @TestCaseID: FieldGetDeclaredAnnotations.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:FieldGetDeclaredAnnotations.java
+ * - @Title/Destination: Field.getDeclaredAnnotation returns annotations that are directly present on this element.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest08。
+ *  -#step2：通过调用getField()从内部类MyTargetTest08中获取home。
+ *  -#step3：调用getDeclaredAnnotation(Class<T> annotationClass)获取类型为MyTarget的注解。
+ *  -#step4：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: FieldGetDeclaredAnnotations.java
+ * - @ExecuteClass: FieldGetDeclaredAnnotations
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+
+public class FieldGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodGetDeclaredAnnotations1() {
+        Field m;
+        try {
+            m = MyTargetTest08.class.getField("home");
+            MyTarget Target = m.getDeclaredAnnotation(MyTarget.class);
+            if ("@FieldGetDeclaredAnnotations$MyTarget(name=newName, value=newValue)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest08 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest08(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/FieldIsAnnotationPresent.java b/test/testsuite/ouroboros/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/FieldIsAnnotationPresent.java
new file mode 100755
index 0000000000000000000000000000000000000000..a84ffed06e60e506e9c7b2e803fb9761da3f7bc8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/FieldIsAnnotationPresent.java
@@ -0,0 +1,80 @@
+/*
+ * - @TestCaseID: FieldIsAnnotationPresent.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:FieldIsAnnotationPresent.java
+ * - @Title/Destination: Field.isAnnotationPresent() Returns true if an annotation for the specified type is present on this element, else false
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest09。
+ *  -#step2：通过调用getField()从内部类MyTargetTest08中获取home。
+ *  -#step3：调用isAnnotationPresent(Class<T> annotationClass)判断是否存在类型为MyTarget的注解。
+ *  -#step4：确认返回true。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: FieldIsAnnotationPresent.java
+ * - @ExecuteClass: FieldIsAnnotationPresent
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+
+public class FieldIsAnnotationPresent {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodIsAnnotationPresent1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodIsAnnotationPresent1() {
+        Field m;
+        try {
+            m = MyTargetTest09.class.getField("home");
+            boolean flag = m.isAnnotationPresent(MyTarget.class);
+            if (flag) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest09 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest09(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0128-rt-compact-FieldToGenericString/FieldToGenericString.java b/test/testsuite/ouroboros/compact_test/RT0128-rt-compact-FieldToGenericString/FieldToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..949696013fafc5b820227a36712263a237455a1c
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0128-rt-compact-FieldToGenericString/FieldToGenericString.java
@@ -0,0 +1,80 @@
+/*
+ * - @TestCaseID: FieldToGenericString
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:FieldToGenericString.java
+ * - @Title/Destination: Field.toGenericString() returns a string describing this Field, including its generic type.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest10。
+ *  -#step2：通过调用getField()从内部类MyTargetTest10中获取home。
+ *  -#step3：调用toGenericString()获取描述此Field的字符串。
+ *  -#step4：确认返回的描述正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: FieldToGenericString.java
+ * - @ExecuteClass: FieldToGenericString
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+
+public class FieldToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int FieldToGenericString1() {
+        Field m;
+        try {
+            m = MyTargetTest10.class.getField("home");
+            String str = m.toGenericString();
+            if ("public java.lang.String FieldToGenericString$MyTargetTest10.home".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest10 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest10(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0129-rt-compact-MethodGetAnnotation/MethodGetAnnotation.java b/test/testsuite/ouroboros/compact_test/RT0129-rt-compact-MethodGetAnnotation/MethodGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..fa3602c7fc45e8b389a839eee4f92723aea42315
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0129-rt-compact-MethodGetAnnotation/MethodGetAnnotation.java
@@ -0,0 +1,70 @@
+/*
+ * - @TestCaseID: MethodGetAnnotation
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodGetAnnotation.java
+ * - @Title/Destination: Method.getAnnotation Returns this element's annotation for the specified type if such an
+ *                       annotation is present, else null.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest11。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest11中获取MyTargetTest_1。
+ *  -#step3：调用getAnnotation(Class<T> annotationClass)获取类型为MyTarget的注解。
+ *  -#step4：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: MethodGetAnnotation.java
+ * - @ExecuteClass: MethodGetAnnotation
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+public class MethodGetAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodGetAnnotation1() {
+        Method m;
+        try {
+            m = MyTargetTest11.class.getMethod("MyTargetTest_1");
+            MyTarget Target = m.getAnnotation(MyTarget.class);
+            if ("@MethodGetAnnotation$MyTarget(name=name, value=value)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest11 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/MethodGetDeclaredAnnotations.java b/test/testsuite/ouroboros/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/MethodGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..4ab360c3f2b359fbeccefc25ffb02351d0dd41ca
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/MethodGetDeclaredAnnotations.java
@@ -0,0 +1,79 @@
+/*
+ * - @TestCaseID: MethodGetDeclaredAnnotations
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodGetDeclaredAnnotations.java
+ * - @Title/Destination: Method.getDeclaredAnnotation() returns this element's annotation for the specified type if such
+ *                       an annotation is directly present。
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest12。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest12中获取MyTargetTest_1。
+ *  -#step3：调用getDeclaredAnnotation(Class<T> annotationClass)获取类型为MyTarget的注解。
+ *  -#step4：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: MethodGetDeclaredAnnotations.java
+ * - @ExecuteClass: MethodGetDeclaredAnnotations
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+public class MethodGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodGetDeclaredAnnotations1() {
+        Method m;
+        try {
+            m = MyTargetTest12.class.getMethod("MyTargetTest_1");
+            MyTarget Target = m.getDeclaredAnnotation(MyTarget.class);
+            if ("@MethodGetDeclaredAnnotations$MyTarget(name=name, value=value)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest12 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest12(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0131-rt-compact-MethodgetDefaultValue/MethodGetDefaultValue.java b/test/testsuite/ouroboros/compact_test/RT0131-rt-compact-MethodgetDefaultValue/MethodGetDefaultValue.java
new file mode 100755
index 0000000000000000000000000000000000000000..87a7d5249441d94463c43de0c3a8aa8502714320
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0131-rt-compact-MethodgetDefaultValue/MethodGetDefaultValue.java
@@ -0,0 +1,63 @@
+/*
+ * - @TestCaseID: MethodGetDefaultValue
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodGetDefaultValue.java
+ * - @Title/Destination: Method.getDefaultValue returns the default value for the annotation member represented by this
+ *                       Method instance. Returns null if no default is associated with the member。
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest13。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest13中获取MyTargetTest_1。
+ *  -#step3：调用getDefaultValue()获取注解成员的默认值。
+ *  -#step4：确认获取为null，无异常抛出。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: MethodGetDefaultValue.java
+ * - @ExecuteClass: MethodGetDefaultValue
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+public class MethodGetDefaultValue {
+    public static void main(String[] argv) {
+        int result = 2/* STATUS_FAILED */;
+        try {
+            result = MethodGetDefaultValueTypeNotPresent_1();
+        } catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodGetDefaultValueTypeNotPresent_1() {
+        try {
+            Method m = MyTargetTest13.class.getMethod("MyTargetTest_1");
+            Object a = m.getDefaultValue();
+        } catch (TypeNotPresentException e) {
+            return 3;
+        } catch (NoSuchMethodException e) {
+            return 4;
+        }
+        return 0;
+    }
+
+    @Target(ElementType.TYPE)
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        Class style() default String.class;
+    }
+
+    @MyTarget()
+    class MyTargetTest13 {
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0132-rt-compact-MethodGetParameterCount/MethodGetParameterCount.java b/test/testsuite/ouroboros/compact_test/RT0132-rt-compact-MethodGetParameterCount/MethodGetParameterCount.java
new file mode 100755
index 0000000000000000000000000000000000000000..b505f49595be2e78636fd64742b8da01559166da
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0132-rt-compact-MethodGetParameterCount/MethodGetParameterCount.java
@@ -0,0 +1,79 @@
+/*
+ * - @TestCaseID: MethodGetParameterCount
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodGetParameterCount.java
+ * - @Title/Destination: Method.getParameterCount() returns the number of formal parameters.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest14。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest14中获取MyTargetTest_1。
+ *  -#step3：调用getParameterCount()获取参数个数。
+ *  -#step4：确认返回的参数个数是0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: MethodGetParameterCount.java
+ * - @ExecuteClass: MethodGetParameterCount
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+public class MethodGetParameterCount {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+
+        try {
+            result = MethodGetParameterCount1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodGetParameterCount1() {
+        Method m;
+        try {
+            m = MyTargetTest14.class.getMethod("MyTargetTest_1");
+            int num = m.getParameterCount();
+            if (num == 0) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest14 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest14(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0133-rt-compact-MethodGetTypeParameters/MethodGetTypeParameters.java b/test/testsuite/ouroboros/compact_test/RT0133-rt-compact-MethodGetTypeParameters/MethodGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..885a4f7b946ec70a93d66b7dfa8345b57931a0a3
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0133-rt-compact-MethodGetTypeParameters/MethodGetTypeParameters.java
@@ -0,0 +1,79 @@
+/*
+ * - @TestCaseID: MethodGetTypeParameters
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodGetTypeParameters.java
+ * - @Title/Destination: Method.getTypeParameters() returns an array of TypeVariable objects.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest15。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest15中获取MyTargetTest_1。
+ *  -#step3：调用getTypeParameters()获取TypeVariable对象的数组。
+ *  -#step4：确认返回的数组长度是0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: MethodGetTypeParameters.java
+ * - @ExecuteClass: MethodGetTypeParameters
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.TypeVariable;
+
+public class MethodGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodGetTypeParameters1() {
+        Method m;
+        try {
+            m = MyTargetTest15.class.getMethod("MyTargetTest_1");
+            TypeVariable<Method>[] Target = m.getTypeParameters();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest15 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest15(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0134-rt-compact-MethodIsDefault/MethodIsDefault.java b/test/testsuite/ouroboros/compact_test/RT0134-rt-compact-MethodIsDefault/MethodIsDefault.java
new file mode 100755
index 0000000000000000000000000000000000000000..10b6ec57735dc1c8f795636e413b92fbfbcfdf28
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0134-rt-compact-MethodIsDefault/MethodIsDefault.java
@@ -0,0 +1,78 @@
+/*
+ * - @TestCaseID: MethodIsDefault
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodIsDefault.java
+ * - @Title/Destination: Method.isDefault() Returns true if this method is a default method。
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest16。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest16中获取MyTargetTest_1。
+ *  -#step3：调用isDefault()判断是否是default method。
+ *  -#step4：确认返回false。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: MethodIsDefault.java
+ * - @ExecuteClass: MethodIsDefault
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+public class MethodIsDefault {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodIsDefault1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodIsDefault1() {
+        Method m;
+        try {
+            m = MyTargetTest16.class.getMethod("MyTargetTest_1");
+            boolean flag = m.isDefault();
+            if (!flag) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest16 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest16(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0135-rt-compact-MethodToGenericString/MethodToGenericString.java b/test/testsuite/ouroboros/compact_test/RT0135-rt-compact-MethodToGenericString/MethodToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..6c6f3c3c9b58facb6bd5108b349dfb27918b9c27
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0135-rt-compact-MethodToGenericString/MethodToGenericString.java
@@ -0,0 +1,78 @@
+/*
+ * - @TestCaseID: MethodToGenericString
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodToGenericString.java
+ * - @Title/Destination: Method.toGenericString() Returns a string describing this Method, including type parameters.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest15。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest15中获取MyTargetTest_1。
+ *  -#step3：调用toGenericString()获取描述此Method的字符串。
+ *  -#step4：确认返回的描述正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: MethodToGenericString.java
+ * - @ExecuteClass: MethodToGenericString
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+public class MethodToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodToGenericString1() {
+        Method m;
+        try {
+            m = MyTargetTest17.class.getMethod("MyTargetTest_1");
+            String str = m.toGenericString();
+            if ("public void MethodToGenericString$MyTargetTest17.MyTargetTest_1()".equals(str)) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest17 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest17(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0136-rt-compact-ParameterGetAnnotation/ParameterGetAnnotation.java b/test/testsuite/ouroboros/compact_test/RT0136-rt-compact-ParameterGetAnnotation/ParameterGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..95db4dea68ac9fa5bfe4187ab423cfd3c6ec77ff
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0136-rt-compact-ParameterGetAnnotation/ParameterGetAnnotation.java
@@ -0,0 +1,79 @@
+/*
+ * - @TestCaseID: ParameterGetAnnotation
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ParameterGetAnnotation.java
+ * - @Title/Destination: Parameter.getAnnotation() Returns this element's annotation for the specified type if such an
+ *                       annotation is present, else null.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest18。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest18中获取newMethod。
+ *  -#step3：调用getParameters()获取所有的参数。
+ *  -#step4：调用getAnnotation(Class<T> annotationClass)获取类型为MyTarget的注解。
+ *  -#step5：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ParameterGetAnnotation.java
+ * - @ExecuteClass: ParameterGetAnnotation
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterGetAnnotation {
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ParameterGetAnnotation1() {
+        Method m;
+        try {
+            m = MyTargetTest18.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget Target = parameters[0].getAnnotation(MyTarget.class);
+            if ("@ParameterGetAnnotation$MyTarget(name=name1, value=value1)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest18 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0137-rt-compact-ParameterGetAnnotations/ParameterGetAnnotations.java b/test/testsuite/ouroboros/compact_test/RT0137-rt-compact-ParameterGetAnnotations/ParameterGetAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..6fe4853d7cbe9eabfbc5b380d321c6ea69bce27f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0137-rt-compact-ParameterGetAnnotations/ParameterGetAnnotations.java
@@ -0,0 +1,84 @@
+/*
+ * - @TestCaseID: ParameterGetAnnotations
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ParameterGetAnnotations.java
+ * - @Title/Destination: Parameter.getAnnotations() Returns annotations that are present on this element.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest19。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest19中获取newMethod。
+ *  -#step3：调用getParameters()获取所有的参数。
+ *  -#step4：调用getAnnotations()获取类型为MyTarget的注解。
+ *  -#step5：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ParameterGetAnnotations.java
+ * - @ExecuteClass: ParameterGetAnnotations
+ * - @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ParameterGetAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ParameterGetAnnotations1() {
+        Method m;
+        try {
+            m = MyTargetTest19.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            Annotation[] Target = parameters[0].getAnnotations();
+            if ("@ParameterGetAnnotations$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest19 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest19(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/ParameterGetAnnotationsByType.java b/test/testsuite/ouroboros/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/ParameterGetAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..7417dc914e5b4df4d816565258f72928a663b1b3
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/ParameterGetAnnotationsByType.java
@@ -0,0 +1,85 @@
+/*
+ * - @TestCaseID: ParameterGetAnnotationsByType.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ParameterGetAnnotationsByType.java
+ * - @Title/Destination: Parameter.getAnnotationsByType(Class<T> annotationClass) Returns annotations that are
+ *                       associated with this element.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest20。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest20中获取newMethod。
+ *  -#step3：调用getParameters()获取所有的参数。
+ *  -#step4：调用getAnnotationsByType(Class<T> annotationClass)获取所有类型为MyTarget的注解。
+ *  -#step5：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ParameterGetAnnotationsByType.java
+ * - @ExecuteClass: ParameterGetAnnotationsByType
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+
+        try {
+            result = ParameterGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ParameterGetAnnotationsByType1() {
+        Method m;
+        try {
+            m = MyTargetTest20.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget[] Target = parameters[0].getAnnotationsByType(MyTarget.class);
+            if ("@ParameterGetAnnotationsByType$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest20 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest20(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/ParameterGetDeclaredAnnotation.java b/test/testsuite/ouroboros/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/ParameterGetDeclaredAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..f2e8ebe0b928d91e853c8ccbef9f617434c23760
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/ParameterGetDeclaredAnnotation.java
@@ -0,0 +1,85 @@
+/*
+ * - @TestCaseID: ParameterGetDeclaredAnnotation.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ParameterGetDeclaredAnnotation.java
+ * - @Title/Destination: Parameter.getDeclaredAnnotation(Class<T> annotationClass) returns this element's annotation for
+ *                       the specified type if such an annotation is directly present, else null.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest21。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest21中获取newMethod。
+ *  -#step3：调用getParameters()获取所有的参数。
+ *  -#step4：调用getDeclaredAnnotation(Class<T> annotationClass)获取所有类型为MyTarget的注解。
+ *  -#step5：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ParameterGetDeclaredAnnotation.java
+ * - @ExecuteClass: ParameterGetDeclaredAnnotation
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterGetDeclaredAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+
+        try {
+            result = ParameterGetDeclaredAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ParameterGetDeclaredAnnotation1() {
+        Method m;
+        try {
+            m = MyTargetTest21.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget Target = parameters[0].getDeclaredAnnotation(MyTarget.class);
+            if ("@ParameterGetDeclaredAnnotation$MyTarget(name=name1, value=value1)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest21 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest21(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/ParameterGetDeclaredAnnotations.java b/test/testsuite/ouroboros/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/ParameterGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..15027aec94cf663d1362267a6dd31cf421d58f92
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/ParameterGetDeclaredAnnotations.java
@@ -0,0 +1,84 @@
+/*
+ * - @TestCaseID: ParameterGetDeclaredAnnotations.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ParameterGetDeclaredAnnotations.java
+ * - @Title/Destination: Parameter.getDeclaredAnnotations() return annotations that are directly present on this element.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest22。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest22中获取newMethod。
+ *  -#step3：调用getParameters()获取所有的参数。
+ *  -#step4：调用getDeclaredAnnotations()获取所有注解。
+ *  -#step5：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ParameterGetDeclaredAnnotations.java
+ * - @ExecuteClass: ParameterGetDeclaredAnnotations
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ParameterGetDeclaredAnnotations1() {
+        Method m;
+        try {
+            m = MyTargetTest22.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            Annotation[] Target = parameters[0].getDeclaredAnnotations();
+            if ("@ParameterGetDeclaredAnnotations$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest22 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest22(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/ParameterGetDeclaredAnnotationsByType.java b/test/testsuite/ouroboros/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/ParameterGetDeclaredAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..ea06f447dd53e0671e78485b02e81524bcf88034
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/ParameterGetDeclaredAnnotationsByType.java
@@ -0,0 +1,85 @@
+/*
+ * - @TestCaseID: ParameterGetDeclaredAnnotationsByType.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ParameterGetDeclaredAnnotationsByType.java
+ * - @Title/Destination: Parameter.getDeclaredAnnotationsByType(Class<T> annotationClass) Returns this element's
+ *                       annotation(s) for the specified type if such annotations are either directly present or
+ *                       indirectly present.
+ * - @Condition: no
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest22。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest22中获取newMethod。
+ *  -#step3：调用getParameters()获取所有的参数。
+ *  -#step4：调用getDeclaredAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的注解。
+ *  -#step5：确认获取的注解正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Remark:
+ * - @Source: ParameterGetDeclaredAnnotationsByType.java
+ * - @ExecuteClass: ParameterGetDeclaredAnnotationsByType
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterGetDeclaredAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetDeclaredAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ParameterGetDeclaredAnnotationsByType1() {
+        Method m;
+        try {
+            m = MyTargetTest23.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget[] Target = parameters[0].getDeclaredAnnotationsByType(MyTarget.class);
+            if ("@ParameterGetDeclaredAnnotationsByType$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest23 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest23(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java b/test/testsuite/ouroboros/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..0eec1a947cbd33592439e19a6a795b265bed43c4
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java
@@ -0,0 +1,65 @@
+/*
+ *- @testCaseID: ReflectionAnnotationGetClass
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectionAnnotationGetClass.java
+ *- @Title/Destination: Try to getClass of an Annotation, the result should contain "class $Proxy". add for
+ *                      DTS2018122012009.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Define an Annotation A0 and define Class Two has one annotation A0.
+ * -#step2: Get class by forName("Two"), call getAnnotations() of the get class.
+ * -#step3: Check the Class of get annotation is "class $Proxy0".
+ * -#step4: Get class by forName("java.lang.annotation.Documented"), call getAnnotations() of the get class.
+ * -#step5: Check the three Class of get annotation is "class $Proxy1", "class $Proxy2", "class $Proxy3".
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ReflectionAnnotationGetClass.java
+ *- @ExecuteClass: ReflectionAnnotationGetClass
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.util.Arrays;
+
+public class ReflectionAnnotationGetClass {
+    public static void main(String[] args) {
+        int result = 2;
+        try{
+            // Check point 1 : only 1 annotation in user-defined Class Two.
+            Annotation[] annotations1 = Class.forName("Two").getAnnotations();
+            if (annotations1.length == 1){
+                if (annotations1[0].getClass().toString().startsWith("class $Proxy")) {
+                    result --;
+                }
+            }
+
+            // Check point 2 : 3 annotations in Class java.lang.annotation.Documented.
+            Annotation[] annotations2 = Class.forName("java.lang.annotation.Documented").getAnnotations();
+            String [] annoClazz = new String[annotations2.length];
+            for (int i = 0; i < annoClazz.length; i++) {
+                annoClazz[i] = annotations2[i].getClass().toString();
+            }
+            Arrays.sort(annoClazz);
+            if (annotations2.length == 3) {
+                if (annoClazz[0].startsWith("class $Proxy") && annoClazz[1]
+                        .startsWith("class $Proxy")
+                        && annoClazz[2].startsWith("class $Proxy")) {
+                    result --;
+                }
+            }
+        }catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+}
+
+@A0
+class Two{}
+
+@Retention(RetentionPolicy.RUNTIME) @interface A0 {}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0143-rt-compact-ClinitClassNewInstance/ClassInitClassNewInstance.java b/test/testsuite/ouroboros/compact_test/RT0143-rt-compact-ClinitClassNewInstance/ClassInitClassNewInstance.java
new file mode 100755
index 0000000000000000000000000000000000000000..f900cbc3382b9cd8fd1d5a4f67c85257fdd15589
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0143-rt-compact-ClinitClassNewInstance/ClassInitClassNewInstance.java
@@ -0,0 +1,154 @@
+/*
+ *- @TestCaseID: ClassInitClassNewInstance
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitClassNewInstance.java
+ *- @Title/Destination: When call Class.newInstance, class is initialized; when call other methods of Class, class is
+ *                      not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) to get the class One.
+ * -#step2: Call methods of Class except newInstance() and forName(), class One is not initialized.
+ * -#step3: call method newInstance(), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitClassNewInstance.java
+ *- @ExecuteClass: ClassInitClassNewInstance
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+public class ClassInitClassNewInstance {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try{
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+
+            /* Check point 1: no class initialization when calling following methods of Class
+             * not test clazz.cast(Object obj) because it success only when obj is an instance of One or Two,
+             * and need to call new One(), which result in Class initialization. */
+            clazz.asSubclass(clazz);
+            clazz.desiredAssertionStatus();
+            clazz.getAnnotation(A.class);
+            clazz.getAnnotations();
+            clazz.getAnnotationsByType(A.class);
+            clazz.getCanonicalName();
+            clazz.getClasses();
+            clazz.getClassLoader();
+            clazz.getComponentType();
+            clazz.getConstructor(String.class);
+            clazz.getConstructors();
+            clazz.getDeclaredAnnotation(A.class);
+            clazz.getDeclaredAnnotations();
+            clazz.getDeclaredAnnotationsByType(A.class);
+            clazz.getDeclaredClasses();
+            clazz.getDeclaredConstructor(String.class);
+            clazz.getDeclaredConstructors();
+            clazz.getDeclaredField("what");
+            clazz.getDeclaredFields();
+            clazz.getDeclaredMethod("testOne", String.class);
+            clazz.getDeclaredMethods();
+            clazz.getDeclaringClass();
+            clazz.getEnclosingClass();
+            clazz.getEnclosingConstructor();
+            clazz.getEnclosingMethod();
+            clazz.getEnumConstants();
+            clazz.getField("hi");
+            clazz.getFields();
+            clazz.getGenericInterfaces();
+            clazz.getGenericSuperclass();
+            clazz.getInterfaces();
+            clazz.getMethod("testOne",String.class);
+            clazz.getMethods();
+            clazz.getModifiers();
+            clazz.getName();
+            clazz.getPackage();
+            clazz.getProtectionDomain();
+            clazz.getSigners();
+            clazz.getSimpleName();
+            clazz.getSuperclass();
+            clazz.getTypeName();
+            clazz.getTypeParameters();
+            clazz.isAnnotation();
+            clazz.isAnnotationPresent(A.class);
+            clazz.isAnonymousClass();
+            clazz.isArray();
+            clazz.isAssignableFrom(clazz);
+            clazz.isEnum();
+            clazz.isInstance(new Object());
+            clazz.isInterface();
+            clazz.isLocalClass();
+            clazz.isMemberClass();
+            clazz.isPrimitive();
+            clazz.isSynthetic();
+            clazz.toString();
+            clazz.toGenericString();
+            clazz.getResource("hi");
+            clazz.getResourceAsStream("hi");
+
+            // Check point 2: when call newInstance, start class initialization
+            if (result.toString().compareTo("") == 0) {
+                clazz.newInstance();
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitClassNewInstance.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitClassNewInstance.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitClassNewInstance.result.append("One");
+    }
+
+    String what = "lala";
+    public String hi = "";
+    One(){}
+
+    public One(String s){
+        what = s;
+        System.out.println(s);
+    }
+
+    public int testOne(String a){
+        System.out.println(a);
+        return 0;
+    }
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitClassNewInstance.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitClassNewInstance.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java b/test/testsuite/ouroboros/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java
new file mode 100755
index 0000000000000000000000000000000000000000..8b282ae9ccdaa2019146cbd315243502b18b3bfc
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java
@@ -0,0 +1,107 @@
+/*
+ *- @TestCaseID: ClassInitConstructorNewInstance
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitConstructorNewInstance.java
+ *- @Title/Destination: When call Constructor.newInstance, class is initialized; when call other methods of Constructor,
+ *                      class is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getConstructor to get Constructor of
+ *          class One.
+ * -#step2: Call methods of Class except newInstance(), class One is not initialized.
+ * -#step3: call method newInstance(), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark: getAnnotatedReceiverType and getAnnotatedReturnType not support in Android
+ *- @Source: ClassInitConstructorNewInstance.java
+ *- @ExecuteClass: ClassInitConstructorNewInstance
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+
+public class ClassInitConstructorNewInstance {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Constructor constructor = clazz.getConstructor(String.class);
+            //check point 1: calling following methods, class not initialized
+            constructor.equals(constructor);
+            constructor.getAnnotation(A.class);
+            constructor.getDeclaredAnnotations();
+            constructor.getDeclaringClass();
+            constructor.getExceptionTypes();
+            constructor.getGenericExceptionTypes();
+            constructor.getGenericParameterTypes();
+            constructor.getModifiers();
+            constructor.getName();
+            constructor.getParameterAnnotations();
+            constructor.getParameterCount();
+            constructor.getParameterTypes();
+            constructor.hashCode();
+            constructor.isSynthetic();
+            constructor.isVarArgs();
+            constructor.toString();
+            constructor.toGenericString();
+
+            //check point 2: after call newInstance(), class initialized
+            if (result.toString().compareTo("") == 0) {
+                constructor.newInstance("newInstance");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitConstructorNewInstance.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitConstructorNewInstance.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitConstructorNewInstance.result.append("One");
+    }
+
+    String what = "lala";
+
+    One(){}
+
+    public One(String s){
+        what = s;
+    }
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitConstructorNewInstance.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitConstructorNewInstance.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java b/test/testsuite/ouroboros/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..d725d9b397c55f829d1d88d1008b1fd4d967a0f0
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetBooleanStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetBooleanStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getBoolean(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getBoolean(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetBooleanStatic.java
+ *- @ExecuteClass: ClassInitFieldGetBooleanStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetBooleanStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.getBoolean(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetBooleanStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("One");
+    }
+
+    public static boolean hiBoolean = false;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetBooleanStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java b/test/testsuite/ouroboros/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..0c1e9f530a9341d80ddda03dc0eb5ad705185ba3
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetByteStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetByteStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getByte(), class One is initialized
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getByte(null), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetByteStatic.java
+ *- @ExecuteClass: ClassInitFieldGetByteStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetByteStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.getByte(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetByteStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetByteStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetByteStatic.result.append("One");
+    }
+
+    public static byte hiByte = (byte)0;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetByteStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetByteStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java b/test/testsuite/ouroboros/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..fd1b6522ede4bbbe8e5bb654d578bb8ee773e9a0
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetCharStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetCharStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getChar(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getChar(null), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetCharStatic.java
+ *- @ExecuteClass: ClassInitFieldGetCharStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetCharStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.getChar(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetCharStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetCharStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetCharStatic.result.append("One");
+    }
+
+    public static char hiChar = (char)45;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetCharStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetCharStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java b/test/testsuite/ouroboros/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..1de0037098202802d257980b8b1196e545a90487
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetDoubleStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetDoubleStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getDouble(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getDouble(null), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetDoubleStatic.java
+ *- @ExecuteClass: ClassInitFieldGetDoubleStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetDoubleStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.getDouble(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetDoubleStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("One");
+    }
+
+    public static double hiDouble = 4.5;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetDoubleStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java b/test/testsuite/ouroboros/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..205f645d06d60e3e5b4989663530cba08eb113d7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java
@@ -0,0 +1,77 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetFloatStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetFloatStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getFloat(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getFloat(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetFloatStatic.java
+ *- @ExecuteClass: ClassInitFieldGetFloatStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetFloatStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.getFloat(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetFloatStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("One");
+    }
+    public static float hiFloat = 0.25f;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetFloatStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java b/test/testsuite/ouroboros/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..b27b36faf911851fb84ca2856e46e46aa7f9a112
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java
@@ -0,0 +1,77 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetIntStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetIntStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getInt(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getInt(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetIntStatic.java
+ *- @ExecuteClass: ClassInitFieldGetIntStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetIntStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.getInt(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetIntStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetIntStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetIntStatic.result.append("One");
+    }
+    public static int hiInt = 0;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetIntStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetIntStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java b/test/testsuite/ouroboros/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..b29c8d397683fb42cce4724d81299ff415049551
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetLongStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetLongStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getLong(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getLong(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetLongStatic.java
+ *- @ExecuteClass: ClassInitFieldGetLongStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetLongStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.getLong(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetLongStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetLongStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetLongStatic.result.append("One");
+    }
+
+    public static long hiLong = 4859l;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetLongStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetLongStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java b/test/testsuite/ouroboros/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..545c8d6cb9ee094fc3f278cedea8a0a4eecbed77
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java
@@ -0,0 +1,77 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetShortStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetShortStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getShort(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class.
+ * -#step2: Call method f.getShort(null), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetShortStatic.java
+ *- @ExecuteClass: ClassInitFieldGetShortStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetShortStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.getShort(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetShortStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetShortStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetShortStatic.result.append("One");
+    }
+
+    public static short hiShort = 48;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetShortStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetShortStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/ClassInitFieldGetStatic.java b/test/testsuite/ouroboros/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/ClassInitFieldGetStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..de1f5ac8af2d805f1e6f3201741c05dcfa94f2a8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/ClassInitFieldGetStatic.java
@@ -0,0 +1,81 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.get(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class.
+ * -#step2: Call method f.get(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetStatic.java
+ *- @ExecuteClass: ClassInitFieldGetStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        String fValue = "";
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                fValue = (String)f.get(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0 && fValue.compareTo("hi") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetStatic.result.append("One");
+    }
+
+    public static String hi = "hi";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java b/test/testsuite/ouroboros/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java
new file mode 100755
index 0000000000000000000000000000000000000000..cf93997494e5db79118a4658d53f7203aa2b4d69
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java
@@ -0,0 +1,98 @@
+/*
+ *- @TestCaseID: ClassInitFieldOtherMethod
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldOtherMethod.java
+ *- @Title/Destination: When f is a static field of class One and call method except setXX/getXX, class is not
+ *                      initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class.
+ * -#step2: Call method of Field except setXX/getXX, class One is not initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldOtherMethod.java
+ *- @ExecuteClass: ClassInitFieldOtherMethod
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldOtherMethod {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+
+            f.equals(f);
+            f.getAnnotation(B.class);
+            f.getAnnotationsByType(B.class);
+            f.getDeclaredAnnotations();
+            f.getDeclaringClass();
+            f.getGenericType();
+            f.getModifiers();
+            f.getName();
+            f.getType();
+            f.hashCode();
+            f.isEnumConstant();
+            f.isSynthetic();
+            f.toGenericString();
+            f.toString();
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if(result.toString().compareTo("") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldOtherMethod.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldOtherMethod.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldOtherMethod.result.append("One");
+    }
+
+    @B("hello")
+    public static String hi = "value";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldOtherMethod.result.append("|InterfaceA|").toString();
+}
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@interface B{
+    String value() default "hi";
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldOtherMethod.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java b/test/testsuite/ouroboros/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..8689833f94492647851291ca7e4018e61cccff90
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java
@@ -0,0 +1,91 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetBooleanStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetBooleanStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setBoolean(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setBoolean(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetBooleanStatic.java
+ *- @ExecuteClass: ClassInitFieldSetBooleanStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetBooleanStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.setBoolean(null, false);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetBooleanStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("One");
+    }
+
+    String what = "lala";
+    public static boolean hiBoolean = false;
+    One(){}
+
+    public One(String s){
+        what = s;
+        System.out.println(s);
+    }
+
+    public int testOne(String a){
+        System.out.println(a);
+        return 0;
+    }
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetBooleanStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java b/test/testsuite/ouroboros/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..937769cbd9a272c32e05c396fe818a89ff9c2585
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetByteStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetByteStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setByte(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setByte(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetByteStatic.java
+ *- @ExecuteClass: ClassInitFieldSetByteStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetByteStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.setByte(null, (byte)1);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetByteStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetByteStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetByteStatic.result.append("One");
+    }
+
+    public static byte hiByte = (byte)0;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetByteStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetByteStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java b/test/testsuite/ouroboros/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..9393eeba2c9335b78e47b74524370073ad340103
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetCharStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetCharStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setChar(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setChar(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetCharStatic.java
+ *- @ExecuteClass: ClassInitFieldSetCharStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetCharStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.setChar(null, (char)1);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetCharStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetCharStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetCharStatic.result.append("One");
+    }
+
+    public static char hiChar = (char)45;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetCharStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetCharStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java b/test/testsuite/ouroboros/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..b4a4bfb816ae29bad75059955d91d117993eaa9f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetDoubleStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetDoubleStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setDouble(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setDouble(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetDoubleStatic.java
+ *- @ExecuteClass: ClassInitFieldSetDoubleStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetDoubleStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.setDouble(null, 0.2589);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetDoubleStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("One");
+    }
+
+    public static double hiDouble = 4.5;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetDoubleStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java b/test/testsuite/ouroboros/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d27b8abb470b01d9e61eb3cddb8d91a18114f60
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetFloatStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetFloatStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setFloat(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setFloat(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetFloatStatic.java
+ *- @ExecuteClass: ClassInitFieldSetFloatStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetFloatStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.setFloat(null, 0.2589f);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetFloatStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("One");
+    }
+
+    public static float hiFloat = 0.25f;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetFloatStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java b/test/testsuite/ouroboros/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..8064ba36c688305f9c109bd67d40a0819ecd62be
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetIntStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetIntStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setInt(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setInt(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetIntStatic.java
+ *- @ExecuteClass: ClassInitFieldSetIntStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetIntStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.setInt(null, 25);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetIntStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetIntStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetIntStatic.result.append("One");
+    }
+
+    public static int hiInt = 0;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetIntStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetIntStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java b/test/testsuite/ouroboros/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..43be5a429b10330c3149204a2b2dd5177dfd7007
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetLongStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetLongStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setLong(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setLong(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetLongStatic.java
+ *- @ExecuteClass: ClassInitFieldSetLongStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetLongStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.setLong(null, 25l);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetLongStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetLongStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetLongStatic.result.append("One");
+    }
+
+    public static long hiLong = 4859l;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetLongStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetLongStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java b/test/testsuite/ouroboros/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..97f984846037ddc11a5b32c185b5cbb81f941cc5
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetShortStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetShortStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setShort(), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setShort(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetShortStatic.java
+ *- @ExecuteClass: ClassInitFieldSetShortStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetShortStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.setShort(null, (short)25);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetShortStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetShortStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetShortStatic.result.append("One");
+    }
+
+    public static short hiShort = 48;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetShortStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetShortStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/ClassInitFieldSetStatic.java b/test/testsuite/ouroboros/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/ClassInitFieldSetStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..fcce4284d8729434e085097d87d91ec29c7d5b5d
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/ClassInitFieldSetStatic.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.set(), class One is initialized
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One
+ * -#step2: Call method f.set(null, newValue), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetStatic.java
+ *- @ExecuteClass: ClassInitFieldSetStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.set(null, "what");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetStatic.result.append("One");
+    }
+
+    public static String hi = "hi";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java b/test/testsuite/ouroboros/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..eecb58c010495e51fb4a17e54273535417a624ea
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java
@@ -0,0 +1,108 @@
+/*
+ *- @TestCaseID: ClassInitMethodInvokeStatic
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitMethodInvokeStatic.java
+ *- @Title/Destination: When m is a static method of class One and call m.invoke(null, args), class One is initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getDeclaredMethod to get a static method
+ *          m of class One.
+ * -#step2: Call methods of Method except invoke(), class One is not initialized.
+ * -#step3: Call method invoke(), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitMethodInvokeStatic.java
+ *- @ExecuteClass: ClassInitMethodInvokeStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+public class ClassInitMethodInvokeStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Method m = clazz.getDeclaredMethod("testOne", String.class);
+            // Check point 1: calling following methods, class not initialized.
+            m.equals(m);
+            m.getAnnotation(A.class);
+            m.getDeclaredAnnotations();
+            m.getDeclaringClass();
+            m.getDefaultValue();
+            m.getExceptionTypes();
+            m.getGenericExceptionTypes();
+            m.getGenericParameterTypes();
+            m.getGenericReturnType();
+            m.getModifiers();
+            m.getName();
+            m.getParameterAnnotations();
+            m.getParameterCount();
+            m.getParameterTypes();
+            m.getReturnType();
+            m.getTypeParameters();
+            m.hashCode();
+            m.isBridge();
+            m.isDefault();
+            m.isSynthetic();
+            m.isVarArgs();
+            m.toString();
+            m.toGenericString();
+
+            // Check point 2: after newInstance, class initialized.
+            if (result.toString().compareTo("") == 0) {
+                m.invoke(null, "hi");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitMethodInvokeStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitMethodInvokeStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitMethodInvokeStatic.result.append("One");
+    }
+
+    public static int testOne(String a){
+        return 0;
+    }
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitMethodInvokeStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitMethodInvokeStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java b/test/testsuite/ouroboros/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..14b4ba61474a0f225515ce42cb5d7155bf5c9a83
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetBooleanInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetBooleanInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getBoolean(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getBoolean(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetBooleanInterface.java
+ *- @ExecuteClass: ClassInitFieldGetBooleanInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetBooleanInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.getBoolean(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetBooleanInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetBooleanInterface.result.append("One").toString();
+    boolean hiBoolean = false;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetBooleanInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetBooleanInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java b/test/testsuite/ouroboros/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..2f8b9ff3968802630a45b11ecbf54b368d6afc27
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetByteInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetByteInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getByte(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getByte(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetByteInterface.java
+ *- @ExecuteClass: ClassInitFieldGetByteInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetByteInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.getByte(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetByteInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetByteInterface.result.append("One").toString();
+    byte hiByte = (byte)1;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetByteInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetByteInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java b/test/testsuite/ouroboros/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..9a2002e368803a9c03957be42c88e68ab7e32ee8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetCharInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetCharInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getChar(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getChar(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetCharInterface.java
+ *- @ExecuteClass: ClassInitFieldGetCharInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetCharInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.getChar(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetCharInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetCharInterface.result.append("One").toString();
+    char hiChar = (char)45;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetCharInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetCharInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java b/test/testsuite/ouroboros/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..9446574085004e7938698bf68be643e916998a07
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetDoubleInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetDoubleInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getDouble(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getDouble(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetDoubleInterface.java
+ *- @ExecuteClass: ClassInitFieldGetDoubleInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetDoubleInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.getDouble(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetDoubleInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetDoubleInterface.result.append("One").toString();
+    double hiDouble = 0.1532;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetDoubleInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetDoubleInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java b/test/testsuite/ouroboros/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..a84927d15002088a75a8a3499cdced24757f4c37
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetFloatInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetFloatInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getFloat(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getFloat(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetFloatInterface.java
+ *- @ExecuteClass: ClassInitFieldGetFloatInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetFloatInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.getFloat(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetFloatInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetFloatInterface.result.append("One").toString();
+    float hiFloat = 0.25f;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetFloatInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetFloatInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/ClassInitFieldGetInterface.java b/test/testsuite/ouroboros/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/ClassInitFieldGetInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..8fe272d19f07fbe1cdab8d36500ebd407d8615c8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/ClassInitFieldGetInterface.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.get(), OneInterface is initialized, it's
+ *                      parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.get(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetInterface.java
+ *- @ExecuteClass: ClassInitFieldGetInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.get(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetInterface.result.append("One").toString();
+    String hi = "hiField";
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java b/test/testsuite/ouroboros/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..e085ca8fd58d23f0084c41e8c3dc9ecd0c16b742
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetIntInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetIntInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getInt(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getInt(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetIntInterface.java
+ *- @ExecuteClass: ClassInitFieldGetIntInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetIntInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.getInt(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetIntInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetIntInterface.result.append("One").toString();
+    int hiInt = 125;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetIntInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetIntInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java b/test/testsuite/ouroboros/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..abd590c1588b8b93e734d50a5ed962575333d026
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetLongInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetLongInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getLong(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getLong(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetLongInterface.java
+ *- @ExecuteClass: ClassInitFieldGetLongInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetLongInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.getLong(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetLongInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetLongInterface.result.append("One").toString();
+    long hiLong = 4859l;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetLongInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetLongInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java b/test/testsuite/ouroboros/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..0c4473af0d3f797320fb15f7b0afcb5c9770525d
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID: ClassInitFieldGetShortInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldGetShortInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getShort(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getShort(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldGetShortInterface.java
+ *- @ExecuteClass: ClassInitFieldGetShortInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetShortInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.getShort(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetShortInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetShortInterface.result.append("One").toString();
+    short hiShort = 14;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetShortInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetShortInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java b/test/testsuite/ouroboros/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..7caa109c8e8068c3d3cf334ef49f58138dce3c69
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID: ClassInitFieldOtherMethodInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldOtherMethodInterface.java
+ *- @Title/Destination: When f is a field of of interface OneInterface and call method except setXX/getXX, class is not
+ *                      initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method of Field except setXX/getXX, class One is not initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldOtherMethodInterface.java
+ *- @ExecuteClass: ClassInitFieldOtherMethodInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldOtherMethodInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+
+            f.equals(f);
+            f.getAnnotation(A.class);
+            f.getAnnotationsByType(A.class);
+            f.getDeclaredAnnotations();
+            f.getDeclaringClass();
+            f.getGenericType();
+            f.getModifiers();
+            f.getName();
+            f.getType();
+            f.hashCode();
+            f.isEnumConstant();
+            f.isSynthetic();
+            f.toGenericString();
+            f.toString();
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if(result.toString().compareTo("") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldOtherMethodInterface.result.append("Super").toString();
+}
+
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldOtherMethodInterface.result.append("One").toString();
+    @A
+    short hi = 14;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldOtherMethodInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldOtherMethodInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java b/test/testsuite/ouroboros/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..33698ad9774a92f822ada24050bc51d284f59a45
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetBooleanInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetBooleanInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setBoolean(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setBoolean(null, true), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetBooleanInterface.java
+ *- @ExecuteClass: ClassInitFieldSetBooleanInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetBooleanInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.setBoolean(null, true);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetBooleanInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetBooleanInterface.result.append("One").toString();
+    boolean hiBoolean = false;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetBooleanInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetBooleanInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java b/test/testsuite/ouroboros/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..bacc9d576432e67188bd4628c928a720257bc71d
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetByteInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetByteInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setByte(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setByte(null, (byte)0), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetByteInterface.java
+ *- @ExecuteClass: ClassInitFieldSetByteInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetByteInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.setByte(null, (byte)0);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetByteInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetByteInterface.result.append("One").toString();
+    byte hiByte = (byte)1;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetByteInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetByteInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java b/test/testsuite/ouroboros/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..a111fba5a0a4cae7f35dea6af643a230850d1320
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetFloatInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetFloatInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setFloat(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setFloat(null, 0.654f), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetFloatInterface.java
+ *- @ExecuteClass: ClassInitFieldSetFloatInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetFloatInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.setFloat(null, 0.654f);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetFloatInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetFloatInterface.result.append("One").toString();
+    float hiFloat = 0.25f;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetFloatInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetFloatInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/ClassInitFieldSetInterface.java b/test/testsuite/ouroboros/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/ClassInitFieldSetInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..3b604e7456887a47457a2bf7eabf20444b547a66
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/ClassInitFieldSetInterface.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.set(), OneInterface is initialized, it's
+ *                      parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.set(null, newValue), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetInterface.java
+ *- @ExecuteClass: ClassInitFieldSetInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.set(null, "newString");
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetInterface.result.append("One").toString();
+    String hi = "hiField";
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java b/test/testsuite/ouroboros/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..61ba9f13932d5f294f46cf61743c0a6ba32d4a3c
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetIntInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetIntInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setInt(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setInt(null, 98), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetIntInterface.java
+ *- @ExecuteClass: ClassInitFieldSetIntInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetIntInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.setInt(null, 98);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetIntInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetIntInterface.result.append("One").toString();
+    int hiInt = 125;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetIntInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetIntInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java b/test/testsuite/ouroboros/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..e1f0652963abc73962f54950c5d3b55d120b4ea8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetLongInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetLongInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setLong(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setLong(null, 7456l), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetLongInterface.java
+ *- @ExecuteClass: ClassInitFieldSetLongInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetLongInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.setLong(null, 7456l);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetLongInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetLongInterface.result.append("One").toString();
+    long hiLong = 4859l;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetLongInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetLongInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java b/test/testsuite/ouroboros/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..2b1b456bb41f767a1c66093c44dec54c28d480b2
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID: ClassInitFieldSetShortInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitFieldSetShortInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setShort(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setShort(null, 124), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitFieldSetShortInterface.java
+ *- @ExecuteClass: ClassInitFieldSetShortInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetShortInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.setShort(null, (short)124);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetShortInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetShortInterface.result.append("One").toString();
+    short hiShort = 14;
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetShortInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetShortInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java b/test/testsuite/ouroboros/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..069cd30d3ef0976f6bda8e4bf66780a5f86b5449
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java
@@ -0,0 +1,93 @@
+/*
+ *- @TestCaseID: ClassInitMethodInvokeInterface
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ClassInitMethodInvokeInterface.java
+ *- @Title/Destination: When m is a static method of interface OneInterface and call m.invoke(), OneInterface is
+ *                      initialized, it's parent interface is not initialized.
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getDeclaredMethod to get
+ *          a static method m of OneInterface.
+ * -#step2: Call methods of Method except invoke(), class One is not initialized.
+ * -#step3: Call method invoke(), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ClassInitMethodInvokeInterface.java
+ *- @ExecuteClass: ClassInitMethodInvokeInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+public class ClassInitMethodInvokeInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Method m = clazz.getDeclaredMethod("runInterface", String.class);
+            //check point 1: calling following methods, class not initialized
+            m.equals(m);
+            m.getAnnotation(A.class);
+            m.getDeclaredAnnotations();
+            m.getDeclaringClass();
+            m.getDefaultValue();
+            m.getExceptionTypes();
+            m.getGenericExceptionTypes();
+            m.getGenericParameterTypes();
+            m.getGenericReturnType();
+            m.getModifiers();
+            m.getName();
+            m.getParameterAnnotations();
+            m.getParameterCount();
+            m.getParameterTypes();
+            m.getReturnType();
+            m.getTypeParameters();
+            m.hashCode();
+            m.isBridge();
+            m.isDefault();
+            m.isSynthetic();
+            m.isVarArgs();
+            m.toString();
+            m.toGenericString();
+
+            //check point 2: after newInstance, class initialized
+            if (result.toString().compareTo("") == 0) {
+                m.invoke(null, "hi");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneRunInterface") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface{
+    String aSuper = ClassInitMethodInvokeInterface.result.append("Super").toString();
+}
+
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitMethodInvokeInterface.result.append("One").toString();
+    @A
+    static void runInterface(String a){
+        ClassInitMethodInvokeInterface.result.append("RunInterface");
+    }
+}
+
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitMethodInvokeInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitMethodInvokeInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0183-rt-compact-FieldMultiThreadTest/FieldMultiThreadTest.java b/test/testsuite/ouroboros/compact_test/RT0183-rt-compact-FieldMultiThreadTest/FieldMultiThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6600b483578ec6b98ad9afac7c4bc86a0268f4e4
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0183-rt-compact-FieldMultiThreadTest/FieldMultiThreadTest.java
@@ -0,0 +1,100 @@
+/*
+ *- @TestCaseID: FieldMultiThreadTest.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:FieldMultiThreadTest.java
+ *- @Title/Destination: when one thread changes the accessiblity of field by Field object A, the other thread will not know if it access the field by another Field object B
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. TestMultiThread have fields with different access modifier(public/protected/default/private), thread A keep setAccessible(true) for Field object of these fields
+ * -#step2. thread B get new Field object for same field in TestMultiThread, and verify isAccessible() return false.
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: FieldMultiThreadTest.java
+ *- @ExecuteClass: FieldMultiThreadTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class FieldMultiThreadTest {
+    volatile static boolean keepRunning = true;
+    static int passCnt = 0;
+    static int executeCnt = 0;
+
+    public static void main(String[] args) {
+        try {
+            fieldMultithread();
+            System.out.println(passCnt/executeCnt - 10);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+
+    private static int fieldMultithread() throws Exception {
+        Class clazz = Class.forName("TestMultiThread");
+        String[] allFields = new String[] {"charPub", "fieldIntPri", "fieldIntPro", "fieldString"};
+        Thread writer = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (String s : allFields) {
+                        Field field = clazz.getDeclaredField(s);
+                        field.setAccessible(true);
+                    }
+                    for (Field f: clazz.getDeclaredFields()) {
+                        f.setAccessible(true);
+                    }
+                    Field field = clazz.getField("charPub");
+                    field.setAccessible(true);
+                    for (Field f: clazz.getFields()) {
+                        f.setAccessible(true);
+                    }
+                }
+            } catch (Exception e) {
+                System.out.println(e);
+            }
+        });
+
+        Thread reader = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (String s : allFields) {
+                        Field field = clazz.getDeclaredField(s);
+                        passCnt += field.isAccessible()== false ? 1 : 0;
+                    }
+                    for (Field f: clazz.getDeclaredFields()) {
+                        passCnt += f.isAccessible()== false ? 1 : 0;
+                    }
+                    Field field = clazz.getField("charPub");
+                    passCnt += field.isAccessible()== false ? 1 : 0;
+                    for (Field f: clazz.getFields()) {
+                        passCnt += f.isAccessible()== false ? 1 : 0;
+                    }
+                    executeCnt++;
+                }
+            } catch (Exception e) {
+                System.out.println(e);
+            }
+        });
+
+        writer.start();
+        reader.start();
+        Thread.sleep(100);
+        keepRunning = false;
+        Thread.sleep(100);
+        writer.join();
+        reader.join();
+        return passCnt;
+    }
+}
+
+class TestMultiThread {
+    public char charPub = 'a';
+    private int fieldIntPri = 416;
+    protected int[] fieldIntPro = {123};
+    String fieldString = "hey, hello";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0184-rt-compact-MethodTest/MethodTest.java b/test/testsuite/ouroboros/compact_test/RT0184-rt-compact-MethodTest/MethodTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..80b845210f72372779a6c4f875a84792b83b5ebd
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0184-rt-compact-MethodTest/MethodTest.java
@@ -0,0 +1,450 @@
+/*
+ *- @TestCaseID: MethodTest.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodTest.java
+ *- @Title/Destination: for the same method, different Method object is return when call following API twice: Class.getMethods(), Class.getEnclosingMethod(), Class.getDeclaredMethods(), Class.getMethod(String name, Class<?>... parameterTypes), Class.getDeclaredMethod(String name, Class<?>... parameterTypes). tests method with different return return type, parameter type, modifier, annotation and declaring class
+ *- @Condition: no
+ *- @Brief:no: see steps of separate test cases
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: MethodTest.java
+ *- @ExecuteClass: MethodTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+public class MethodTest {
+    /**
+     * Verify that for the same method, different Method object is return when call following API twice:
+     * - Class.getMethods(),
+     * - Class.getEnclosingMethod(),
+     * - Class.getDeclaredMethods(),
+     * - Class.getMethod(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredMethod(String name, Class<?>... parameterTypes),
+     * if any Method failed the check, will print error message including testcase and method name;
+     * after all check is pass, casePassed will be increased;
+     */
+    private static void classAllMethodTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getMethods()
+        Method[] methods1 = clazz.getMethods();
+        Method[] methods2 = clazz.getMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 2. Class.getMethod(String name)
+            Method m1 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed");
+            }
+        }
+
+        // checkpoint 3. Class.getDeclaredMethods()
+        methods1 = clazz.getDeclaredMethods();
+        methods2 = clazz.getDeclaredMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 4. Class.getDeclaredMethod(String name)
+            Method m1 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for declared method");
+            }
+        }
+
+        // checkpoint 5. Class.getEnclosingMethod()
+        if (clazz.getEnclosingMethod() != null) {
+            Method m1 = clazz.getEnclosingMethod();
+            Method m2 = clazz.getEnclosingMethod();
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for Enclosing method");
+            }
+        }
+
+        casesPassed++;
+    }
+
+    private static void checkMethods(Method[] methods1, Method[] methods2) {
+        for (Method m1: methods1) {
+            for (Method m2: methods2) {
+                // only when modifers and class and name is same, two Method object is for same method
+                if(m1.toString().equals(m2.toString())) {
+                    if (singleMethodCheck(m1, m2) != 3) {
+                        System.out.println(m1.getName()+" failed in checkMethods");
+                    }
+                }
+            }
+        }
+    }
+
+    private static int singleMethodCheck(Method m1, Method m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    static int casesPassed = 0;
+
+    public static void main(String [] args) {
+        method01();
+        method02();
+        method03();
+        method04();
+        method05();
+        method06();
+        method07();
+        method08();
+        method09();
+        method10();
+        method11();
+        System.out.println(casesPassed - 11);
+    }
+
+    /**
+     *- @TestCaseID: method01
+     *- @Title/Destination: for same method in pre-defined class, certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. all test in classAllMethodTest() passed for pre-defined class java.lang.Thread
+     */
+    private static void method01() {
+        try {
+            classAllMethodTest(Class.forName("java.lang.Thread"), "method01");
+        } catch (Exception e) {
+            System.out.println("Case method01 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method02
+     *- @Title/Destination: for same method in user-defined class with different return_type/parameter_type/modifier/annotation, certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. classAllMethodTest() passed for methods with different return type and parameter type
+     * -#step2. classAllMethodTest() passed for methods with different access modifier: public, private, protected
+     * -#step3. classAllMethodTest() passed for methods with different modifier: transient, final, volatile, static
+     * -#step4. classAllMethodTest() passed for methods with annotation
+     */
+    private static void method02() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod02"), "method02");
+        } catch (Exception e) {
+            System.out.println("Case method02 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method03
+     *- @Title/Destination: check all test in classAllMethodTest passed for methods in interface
+     *- @Condition: no
+     *- @Brief:no:
+     * -step1. check all test in classAllMethodTest passed for methods in interface
+     */
+    private static void method03() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod03"), "method03");
+        } catch (Exception e) {
+            System.out.println("Case method03 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method04
+     *- @Title/Destination: for same method in abstract class, certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in abstract class
+     */
+    private static void method04() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod04"), "method04");
+        } catch (Exception e) {
+            System.out.println("Case method04 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method05
+     *- @Title/Destination: for same method in anonymous class, certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. get the class instance of anonymous class
+     * -#step2. check all test in classAllMethodTest passed for methods in anonymous class
+     */
+    private static void method05() {
+        try {
+            // step 1
+            Class clazz = Class.forName("MethodTest");
+            MethodTest mainClass = new MethodTest();
+            Field method = clazz.getDeclaredField("testMethod05");
+
+            classAllMethodTest(method.get(mainClass).getClass(), "method05");
+        } catch (Exception e) {
+            System.out.println("Case method05 failed with exception" + e);
+        }
+    }
+
+    private Runnable testMethod05 = new Runnable() {
+        private final synchronized int intRunnable() {
+            return 1;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    /**
+     *- @TestCaseID: method06
+     *- @Title/Destination: for same method in local class(class in a function), certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in local class
+     */
+    private static void method06() {
+        class TestMethod06 {
+            private final int intLocalMethod() {
+                return 9;
+            }
+            public synchronized String stringLocal() {
+                return "a fake behind the fear";
+            }
+        }
+        try {
+            classAllMethodTest(Class.forName("MethodTest$1TestMethod06"), "method06");
+        } catch (Exception e) {
+            System.out.println("Case method06 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method07
+     *- @Title/Destination: for same method in inner class, certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in inner class
+     */
+    private static void method07() {
+        try {
+            classAllMethodTest(Class.forName("MethodTest$TestMethod07"), "method07");
+        } catch (Exception e) {
+            System.out.println("Case method07 failed with exception" + e);
+        }
+    }
+
+    class TestMethod07 {
+        private char charInnerMethod(int a, double... b) {
+            return 'l';
+        }
+        final public double doubleInnerMethod() {
+            return 1988.0416;
+        }
+    }
+
+    /**
+     *- @TestCaseID: method08
+     *- @Title/Destination: for same method in enum class, certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in enum class
+     */
+    private static void method08() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod08"), "method08");
+        } catch (Exception e) {
+            System.out.println("Case method08 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method09
+     *- @Title/Destination: for same method in parent class, certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in parent class
+     */
+    private static void method09() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod09"), "method09");
+        } catch (Exception e) {
+            System.out.println("Case method09 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method10
+     *- @Title/Destination: for same method in child class with implemented interface, certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in child class with implemented interface
+     */
+    private static void method10() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod10"), "method10");
+        } catch (Exception e) {
+            System.out.println("Case method10 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method11
+     *- @Title/Destination: for same method in interface implemented by another class, certain APIs return different Method object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in interface implemented by another class
+     */
+    private static void method11() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod11"), "method11");
+        } catch (Exception e) {
+            System.out.println("Case method11 failed with exception" + e);
+        }
+    }
+}
+
+class TestMethod02 {
+    // step1
+    void voidMethod() {}
+    boolean booleanMethod() {
+        return true;
+    }
+    byte byteMethod() {
+        return (byte)1;
+    }
+    short shortMethod() {
+        return (short)2;
+    }
+    int intMethod() {
+        return 3;
+    }
+    long longMethod() {
+        return 4l;
+    }
+    char charMethod() {
+        return 'a';
+    }
+    float floatMethod() {
+        return 0.9f;
+    }
+    double doubleMethod() {
+        return 0.416;
+    }
+    String stringMethod() {
+        return "The queerest of the queer";
+    }
+    Runnable[] rArrayMethod() {
+        return null;
+    }
+    boolean[][][][][][][] booleanArray7Method() {
+        return new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    }
+    String[][][] stringArray3Method() {
+        return new String[][][] {{{"the strangest of the strange"}}};
+    }
+
+    int parameterMethod(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                        boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                        String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+        return 1;
+    }
+
+    // step2
+    public int publicIntMethod(boolean a) {
+        return 88;
+    }
+    protected double protectedDoubleMethod(byte a) {
+        return 99;
+    }
+    private String privateStringMethod(String a) {
+        return "the coldest of the cool";
+    }
+
+    // step3
+    strictfp double[][] transientDoubleArrayMethod(float[][] a) {
+        return new double[][] {{1988, 4.16}};
+    }
+    final int finalIntMethod() {
+        return 9876;
+    }
+    synchronized String volatileStringMethod() {
+        return "the lamest of the lame";
+    }
+    static Character staticCharacterMethod(Thread.State a) {
+        return 'd';
+    }
+
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotationMethod() {
+        return new String[][] {{"the numbest of the dumb"}};
+    }
+}
+
+interface TestMethod03 {
+    String stringInterfaceMethod(int[] a);
+    char[][][] charArrayInterfaceMethod(double... a);
+}
+
+abstract class TestMethod04 {
+    public static final synchronized String[] stringsAbstractArrayMethod() {
+        return new String[] {"i hate to see you here", "you choke behind a smile"};
+    }
+    abstract Runnable runnableAbstractMethod();
+}
+
+enum TestMethod08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnumMethod() {
+        return (short)6;
+    }
+    public final String stringEnumMethod(int... a) {
+        return "Dry Martini";
+    }
+}
+
+class TestMethod09 {
+    public int int09Method() {
+        return 1;
+    }
+    protected boolean boolean09Method() {
+        return false;
+    }
+    char[] chars09Method() {
+        return new char[] {'a', 'b', 'c'};
+    }
+    private String string09Method() {
+        return "I'm only happy when it rains";
+    }
+}
+
+class TestMethod10 extends TestMethod09 implements TestMethod11 {
+    public boolean boolean09Method() {
+        return true;
+    }
+    public double double10Method() {
+        return 0.416;
+    }
+    public char[] chars09Method() {
+        return new char[] {'a'};
+    }
+    public String string09Method() {
+        return "SHALALALA";
+    }
+}
+
+interface TestMethod11 {
+    int int09Method();
+    boolean boolean09Method();
+    char[] chars09Method();
+    String string09Method();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0185-rt-compact-MethodMultiThreadTest/MethodMultiThreadTest.java b/test/testsuite/ouroboros/compact_test/RT0185-rt-compact-MethodMultiThreadTest/MethodMultiThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..847cea630e45bcd514123b3f27847ae101b83675
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0185-rt-compact-MethodMultiThreadTest/MethodMultiThreadTest.java
@@ -0,0 +1,105 @@
+/*
+ *- @TestCaseID: MethodMultiThreadTest.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodMultiThreadTest.java
+ *- @Title/Destination: when one thread changes the accessiblity of method by Method object A, the other thread will not know if it access the method by another Method object B
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. MethodMultiThreadTest have methods with different access modifier(public/protected/default/private), thread A keep setAccessible(true) for Method object of these methods
+ * -#step2. thread B get new Method object for same method in MethodMultiThreadTest, and verify isAccessible() return false.
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: MethodMultiThreadTest.java
+ *- @ExecuteClass: MethodMultiThreadTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+public class MethodMultiThreadTest {
+    volatile static boolean keepRunning = true;
+    static int passCnt = 0;
+    static int executeCnt = 0;
+
+    public static void main(String[] args) {
+        try {
+            methodMultithread();
+            System.out.println(passCnt/executeCnt - 28);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+
+    private static int methodMultithread() throws Exception {
+        Class clazz = Class.forName("TestMultiThreadM");
+        Thread writer = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Method m: clazz.getDeclaredMethods()) {
+                        m.setAccessible(true);
+                        Method method = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+                        method.setAccessible(true);
+                    }
+                    for (Method m: clazz.getMethods()) {
+                        m.setAccessible(true);
+                        Method method = clazz.getMethod(m.getName(), m.getParameterTypes());
+                        method.setAccessible(true);
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+
+        Thread reader = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Method m: clazz.getDeclaredMethods()) {
+                        passCnt += m.isAccessible()== false ? 1 : 0;
+                        Method method = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+                        passCnt += method.isAccessible()== false ? 1 : 0;
+                    }
+                    for (Method m: clazz.getMethods()) {
+                        passCnt += m.isAccessible()== false ? 1 : 0;
+                        Method method = clazz.getMethod(m.getName(), m.getParameterTypes());
+                        passCnt += method.isAccessible()== false ? 1 : 0;
+                    }
+                    executeCnt++;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+
+        writer.start();
+        reader.start();
+        Thread.sleep(100);
+        keepRunning = false;
+        Thread.sleep(100);
+        writer.join();
+        reader.join();
+        return passCnt;
+    }
+}
+
+class TestMultiThreadM {
+    public char charPubMethod(int... a) {
+        return 'a';
+    }
+    private int intPriMethod() {
+        return 416;
+    }
+    protected int[] intProMethod(Double... b) {
+        return new int[] {123};
+    }
+    String stringMethod() {
+        return "hey, hello";
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0186-rt-compact-ConstructorTest/ConstructorTest.java b/test/testsuite/ouroboros/compact_test/RT0186-rt-compact-ConstructorTest/ConstructorTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..498c10e0da719e22af6043d37841963c1c3b38d2
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0186-rt-compact-ConstructorTest/ConstructorTest.java
@@ -0,0 +1,376 @@
+/*
+ *- @TestCaseID: ConstructorTest.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ConstructorTest.java
+ *- @Title/Destination: for the same constructor, different Constructor object is return when call following API twice: Class.getConstructors(), Class.getEnclosingConstructor(), Class.getDeclaredConstructors(), Class.getConstructor(String name, Class<?>... parameterTypes), Class.getDeclaredConstructor(String name, Class<?>... parameterTypes)
+ *- @Condition: no
+ *- @Brief:no: see steps of separate test cases
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ConstructorTest.java
+ *- @ExecuteClass: ConstructorTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Constructor;
+
+public class ConstructorTest {
+    /**
+     * Verify that for the same constructor, different Constructor object is return when call following API twice:
+     * - Class.getConstructors(),
+     * - Class.getEnclosingConstructor(),
+     * - Class.getDeclaredConstructors(),
+     * - Class.getConstructor(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredConstructor(String name, Class<?>... parameterTypes),
+     * if any Constructor failed the check, will print error message including testcase and constructor name;
+     * after all check is pass, casePassed will be increased;
+     */
+    private static void classAllConstructorTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getConstructors()
+        Constructor[] constructors1 = clazz.getConstructors();
+        Constructor[] constructors2 = clazz.getConstructors();
+        checkConstructors(constructors1, constructors2);
+        for (Constructor c : constructors1) {
+            // checkpoint 2. Class.getConstructor(String name)
+            Constructor c1 = clazz.getConstructor(c.getParameterTypes());
+            Constructor c2 = clazz.getConstructor(c.getParameterTypes());
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed");
+            }
+        }
+
+        // checkpoint 3. Class.getDeclaredConstructors()
+        constructors1 = clazz.getDeclaredConstructors();
+        constructors2 = clazz.getDeclaredConstructors();
+        checkConstructors(constructors1, constructors2);
+        for (Constructor c : constructors1) {
+            // checkpoint 4. Class.getDeclaredConstructor(String name)
+            Constructor c1 = clazz.getDeclaredConstructor(c.getParameterTypes());
+            Constructor c2 = clazz.getDeclaredConstructor(c.getParameterTypes());
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed for declared constructor");
+            }
+        }
+
+        // checkpoint 5. Class.getEnclosingConstructor()
+        if (clazz.getEnclosingConstructor() != null) {
+            Constructor c1 = clazz.getEnclosingConstructor();
+            Constructor c2 = clazz.getEnclosingConstructor();
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed for Enclosing constructor");
+            }
+        }
+
+        casesPassed++;
+    }
+
+    private static void checkConstructors(Constructor[] constructors1, Constructor[] constructors2) {
+        for (Constructor c1: constructors1) {
+            for (Constructor c2: constructors2) {
+                // only when modifers and class and name is same, two Constructor object is for same constructor
+                if(c1.toString().equals(c2.toString())) {
+                    if (singleConstructorCheck(c1, c2) != 3) {
+                        System.out.println(c1.getName()+" failed in checkConstructors");
+                    }
+                }
+            }
+        }
+    }
+
+    private static int singleConstructorCheck(Constructor c1, Constructor c2) {
+        int passCnt = 0;
+        passCnt += c1 == c2 ? 0 : 1;
+        passCnt += c1.equals(c2) ? 1 : 0;
+        passCnt += c1.hashCode() == c2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    static int casesPassed = 0;
+
+    public static void main(String [] args) {
+        constructor01();
+        constructor02();
+        constructor03();
+        constructor04();
+        constructor05();
+        constructor06();
+        constructor07();
+        constructor08();
+        constructor09();
+        constructor10();
+        constructor11();
+        System.out.println(casesPassed - 11);
+    }
+
+    /**
+     *- @TestCaseID: constructor01
+     *- @Title/Destination: for same constructor in pre-defined class, certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. all test in classAllConstructorTest() passed for pre-defined class java.lang.Thread
+     */
+    private static void constructor01() {
+        try {
+            classAllConstructorTest(Class.forName("java.lang.Thread"), "constructor01");
+        } catch (Exception e) {
+            System.out.println("Case constructor01 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor02
+     *- @Title/Destination: for same constructor in user-defined class with different parameter_type/modifier/annotation, certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. classAllConstructorTest() passed for constructors with different parameter type
+     * -#step2. classAllConstructorTest() passed for constructors with different access modifier: public, private, protected
+     * -#step3. classAllConstructorTest() passed for constructors with annotation
+     */
+    private static void constructor02() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor02"), "constructor02");
+        } catch (Exception e) {
+            System.out.println("Case constructor02 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor03
+     *- @Title/Destination: check all test in classAllConstructorTest passed for constructors in class with modifier strictfp
+     *- @Condition: no
+     *- @Brief:no:
+     * -step1. check all test in classAllConstructorTest passed for constructors in class with modifier strictfp
+     */
+    private static void constructor03() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor03"), "constructor03");
+        } catch (Exception e) {
+            System.out.println("Case constructor03 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor04
+     *- @Title/Destination: for same constructor in abstract class, certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in abstract class
+     */
+    private static void constructor04() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor04"), "constructor04");
+        } catch (Exception e) {
+            System.out.println("Case constructor04 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor05
+     *- @Title/Destination: for same constructor in anonymous class, certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. get the class instance of anonymous class by getting constructor value of otter class instance
+     * -#step2. check all test in classAllConstructorTest passed for constructors in anonymous class
+     */
+    private static void constructor05() {
+        try {
+            Class clazz = Class.forName("ConstructorTest");
+            ConstructorTest mainClass = new ConstructorTest();
+            Field constructor = clazz.getDeclaredField("testConstructor05");
+
+            classAllConstructorTest(constructor.get(mainClass).getClass(), "constructor05");
+        } catch (Exception e) {
+            System.out.println("Case constructor05 failed with exception" + e);
+        }
+    }
+
+    private Runnable testConstructor05 = new Runnable() {
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    /**
+     *- @TestCaseID: constructor06
+     *- @Title/Destination: for same constructor in local class(class in a function), certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in local class
+     */
+    private static void constructor06() {
+        class TestConstructor06 {
+            private TestConstructor06(int a) {
+            }
+            public TestConstructor06(String[][][] a) {
+            }
+        }
+        try {
+            classAllConstructorTest(Class.forName("ConstructorTest$1TestConstructor06"), "constructor06");
+        } catch (Exception e) {
+            System.out.println("Case constructor06 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor07
+     *- @Title/Destination: for same constructor in inner class, certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in inner class
+     */
+    private static void constructor07() {
+        try {
+            classAllConstructorTest(Class.forName("ConstructorTest$TestConstructor07"), "constructor07");
+        } catch (Exception e) {
+            System.out.println("Case constructor07 failed with exception" + e);
+        }
+    }
+
+    class TestConstructor07 {
+        private TestConstructor07(int a, double... b) {
+        }
+        public TestConstructor07() {
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor08
+     *- @Title/Destination: for same constructor in user-defined class, certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in
+     */
+    private static void constructor08() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor08"), "constructor08");
+        } catch (Exception e) {
+            System.out.println("Case constructor08 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor09
+     *- @Title/Destination: for same constructor in father class, certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in father class
+     */
+    private static void constructor09() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor09"), "constructor09");
+        } catch (Exception e) {
+            System.out.println("Case constructor09 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor10
+     *- @Title/Destination: for same constructor in class extends another class and implements interface, certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in class extends another class and implements interface
+     */
+    private static void constructor10() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor10"), "constructor10");
+        } catch (Exception e) {
+            System.out.println("Case constructor10 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor11
+     *- @Title/Destination: for same constructor in interface implemented by another class, certain APIs return different Constructor object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in interface implemented by another class
+     */
+    private static void constructor11() {
+        try {
+            Class clazz = (new TestConstructor11()).c.getClass();
+            classAllConstructorTest(clazz, "constructor11");
+        } catch (Exception e) {
+            System.out.println("Case constructor11 failed with exception" + e);
+        }
+    }
+}
+
+class TestConstructor02 {
+    // step1
+    TestConstructor02() {
+    }
+    TestConstructor02(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                      boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                      String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+    }
+
+    // step2
+    public TestConstructor02(int a) {}
+    TestConstructor02(byte a) {}
+    protected TestConstructor02(String a) {}
+    private TestConstructor02(Runnable[] a) {}
+
+    // step3
+    @Deprecated
+    TestConstructor02(int... a) {}
+}
+
+strictfp class TestConstructor03 {
+    public TestConstructor03(float... a) {
+    }
+    TestConstructor03(float a, double b) {
+    }
+}
+
+abstract class TestConstructor04 {
+    public TestConstructor04() {
+    }
+    TestConstructor04(int a) {
+    }
+}
+
+enum TestConstructor08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    TestConstructor08() {
+    }
+    TestConstructor08(String a) {
+    }
+}
+
+class TestConstructor09 {
+    public TestConstructor09() {
+    }
+    TestConstructor09(int... a) {
+    }
+    protected TestConstructor09(double[] a) {
+    }
+    private TestConstructor09(int a) {
+    }
+}
+
+class TestConstructor10 extends TestConstructor09 {
+    public TestConstructor10() {
+    }
+    TestConstructor10(int... a) {
+    }
+    protected TestConstructor10(double[] a) {
+    }
+    private TestConstructor10(int a) {
+    }
+}
+
+class TestConstructor11 {
+    public Object c;
+    public TestConstructor11( ) {
+        class ClassA { }
+        c = new ClassA( );
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/ConstructorMultiThreadTest.java b/test/testsuite/ouroboros/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/ConstructorMultiThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e2c78b8a62d8aaad9b25cbcfcb4f7c462a1f71f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/ConstructorMultiThreadTest.java
@@ -0,0 +1,104 @@
+/*
+ *- @TestCaseID: ConstructorMultiThreadTest.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ConstructorMultiThreadTest.java
+ *- @Title/Destination: when one thread changes the accessiblity of constructor by Constructor object A, the other thread will not know if it access the constructor by another Constructor object B
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. ConstructorMultiThreadTest have constructors with different access modifier(public/protected/default/private), thread A keep setAccessible(true) for Constructor object of these constructors
+ * -#step2. thread B get new Constructor object for same constructor in ConstructorMultiThreadTest, and verify isAccessible() return false.
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: ConstructorMultiThreadTest.java
+ *- @ExecuteClass: ConstructorMultiThreadTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+public class ConstructorMultiThreadTest {
+    volatile static boolean keepRunning = true;
+    static int passCnt = 0;
+    static int executeCnt = 0;
+
+    public static void main(String[] args) {
+        try {
+            constructorMultithread();
+            System.out.println(passCnt/executeCnt - 10);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+
+    private static int constructorMultithread() throws Exception {
+        Class clazz = Class.forName("TestMultiThreadC");
+        Thread writer = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Constructor c: clazz.getDeclaredConstructors()) {
+                        c.setAccessible(true);
+                        Constructor constructor = clazz.getDeclaredConstructor(c.getParameterTypes());
+                        constructor.setAccessible(true);
+                    }
+                    for (Constructor c: clazz.getConstructors()) {
+                        c.setAccessible(true);
+                        Constructor constructor = clazz.getConstructor(c.getParameterTypes());
+                        constructor.setAccessible(true);
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+
+        Thread reader = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Constructor c: clazz.getDeclaredConstructors()) {
+                        passCnt += c.isAccessible()== false ? 1 : 0;
+                        Constructor constructor = clazz.getDeclaredConstructor(c.getParameterTypes());
+                        passCnt += constructor.isAccessible()== false ? 1 : 0;
+                    }
+                    for (Constructor c: clazz.getConstructors()) {
+                        passCnt += c.isAccessible()== false ? 1 : 0;
+                        Constructor constructor = clazz.getConstructor(c.getParameterTypes());
+                        passCnt += constructor.isAccessible()== false ? 1 : 0;
+                    }
+                    executeCnt++;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+
+        writer.start();
+        reader.start();
+        Thread.sleep(100);
+        keepRunning = false;
+        Thread.sleep(100);
+        writer.join();
+        reader.join();
+        return passCnt;
+    }
+}
+
+class TestMultiThreadC {
+    public TestMultiThreadC(int... a) {
+    }
+
+    private TestMultiThreadC(String a) {
+    }
+
+    protected TestMultiThreadC(Double... a) {
+    }
+
+    TestMultiThreadC() {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java b/test/testsuite/ouroboros/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2ba98c2e7d8be903b2058441f1c24fb1820ab2a
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java
@@ -0,0 +1,104 @@
+/*
+ *- @TestCaseID: MethodHandleReflectCombineTest.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:MethodHandleReflectCombineTest.java
+ *- @Title/Destination: Test Field/Method/Constructor object return by MethodHandles.reflectAs(Class<T> expected, MethodHandle target) is heap object
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. testData including methodHandles for virtual method, static method, private method, constructor with primitive parameter and array parameter, field with primitive type, array type, static field;
+ * -#step2. for methodHandles in testData, call reflectAs(Member.class, methodhandle) twice, the Field/Constructor/Method returned is two object
+ * -#step3. for private constructor, try to setAccessible(true) for it first and then get method handle for it and check reflectAs return a new Constructor object
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: MethodHandleReflectCombineTest.java
+ *- @ExecuteClass: MethodHandleReflectCombineTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+
+import static java.lang.invoke.MethodHandles.lookup;
+import static java.lang.invoke.MethodHandles.reflectAs;
+import static java.lang.invoke.MethodType.methodType;
+
+public class MethodHandleReflectCombineTest {
+    static int passCnt = 0;
+
+    private static <T extends Member> int singleMethodCheck(T m1, T m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    public static void main(String[] args) {
+        try {
+            System.out.println(run());
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static int run() throws Throwable {
+        Object[][] testData = new Object[][] {
+            {Member.class, lookup().findVirtual(String.class, "concat", methodType(String.class, String.class))},
+            {Member.class, lookup().findStatic(String.class, "copyValueOf", methodType(String.class, char[].class))},
+            {Member.class, RATest.LOOKUP().findSpecial(RATest.class, "mhVar", methodType(int.class, Object[].class), RATest.class)},
+            {Constructor.class, lookup().findConstructor(RATest.class, methodType(void.class, int.class))},
+            {Constructor.class, lookup().findConstructor(RATest.class, methodType(void.class, double[].class))},
+            {Field.class, lookup().findStaticGetter(RATest.class, "svi", int.class)},
+            {Field.class, lookup().findStaticSetter(RATest.class, "svi", int.class)},
+            {Field.class, RATest.LOOKUP().findGetter(RATest.class, "vd", double.class)},
+            {Field.class, lookup().findGetter(RATest.class, "vs", String[].class)},
+            {Field.class, lookup().findSetter(RATest.class, "vs", String[].class)}
+        };
+
+        for (int i = 0; i<testData.length; i++) {
+            passCnt += singleMethodCheck(reflectAs((Class)testData[i][0], (MethodHandle) testData[i][1]), reflectAs((Class)testData[i][0], (MethodHandle) testData[i][1])) == 3 ? 1 : 0;
+        }
+
+        Constructor privC = Class.forName("RATest").getDeclaredConstructor();
+        privC.setAccessible(true);
+        MethodHandle raCon = lookup().unreflectConstructor(privC);
+        passCnt += singleMethodCheck(privC, reflectAs( Constructor.class, raCon))==3 ? 1 : 0;
+
+        return passCnt - 11;
+    }
+}
+
+class RATest {
+    public static MethodHandles.Lookup LOOKUP() {
+        return lookup();
+    }
+
+    static public double count = 0;
+    protected static int svi = 333;
+    private double vd = 136;
+    String[] vs = {"hi"};
+
+    RATest(int i) {
+        count = i;
+    }
+
+    public RATest(double[] i) {
+        count = i.length;
+    }
+
+    private RATest() {
+        count = -1;
+    }
+
+    private int mhVar(Object... a) {
+        return a.length;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0189-rt-compact-FieldTest/FieldTest.java b/test/testsuite/ouroboros/compact_test/RT0189-rt-compact-FieldTest/FieldTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..45e42a14e903008a01dce4284c26194b6b6f0027
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0189-rt-compact-FieldTest/FieldTest.java
@@ -0,0 +1,388 @@
+/*
+ *- @TestCaseID: FieldTest.java
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:FieldTest.java
+ *- @Title/Destination: for the same field, different Field object is return when call following API twice: Class.getFields(), Class.getDeclaredFields(), Class.getField(String name), Class.getDeclareedField(String name). tests field with different data type, modifier, annotation and declaring class
+ *- @Condition: no
+ *- @Brief:no: see steps of separate test cases
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Remark:
+ *- @Source: FieldTest.java
+ *- @ExecuteClass: FieldTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class FieldTest {
+    /**
+     * Verify that for the same field, different Field object is return when call following API twice:
+     * - Class.getFields()
+     * - Class.getDeclaredFields()
+     * - Class.getField(String name)
+     * - Class.getDeclareedField(String name)
+     * if any Field failed the check, will print error message including testcase and field name;
+     * after all check is pass, casePassed will be increased;
+     */
+    private static void classAllFieldTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getFields()
+        Field[] fields1 = clazz.getFields();
+        Field[] fields2 = clazz.getFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 2. Class.getDeclaredFields()
+            Field f1 = clazz.getField(f.getName());
+            Field f2 = clazz.getField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed");
+            }
+        }
+
+        // checkpoint 3. Class.getField(String name)
+        fields1 = clazz.getDeclaredFields();
+        fields2 = clazz.getDeclaredFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 4. Class.getDeclareedField(String name)
+            Field f1 = clazz.getDeclaredField(f.getName());
+            Field f2 = clazz.getDeclaredField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed for declared fields");
+            }
+        }
+        casesPassed++;
+    }
+
+    private static void checkFields(Field[] fields1, Field[] fields2) {
+        for (Field f1: fields1) {
+            for (Field f2: fields2) {
+                // only when modifers and class and name is same, two Field object is for same field
+                if(f1.toGenericString().equals(f2.toGenericString())) {
+                    if (singleFieldCheck(f1, f2) != 3) {
+                        System.out.println(f1.getName()+" failed in checkFields");
+                    }
+                }
+            }
+        }
+    }
+
+    private static int singleFieldCheck(Field f1, Field f2) {
+        int passCnt = 0;
+        passCnt += f1 == f2 ? 0 : 1;
+        passCnt += f1.equals(f2) ? 1 : 0;
+        passCnt += f1.hashCode() == f2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    static int casesPassed = 0;
+
+    public static void main(String [] args) {
+        field01();
+        field02();
+        field03();
+        field04();
+        field05();
+        field06();
+        field07();
+        field08();
+        field09();
+        field10();
+        field11();
+        field12();
+        System.out.println(casesPassed - 12);
+    }
+
+    /**
+     *- @TestCaseID: field01
+     *- @Title/Destination: for same field in pre-defined class, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. all test in classAllFieldTest() passed for pre-defined class java.lang.Thread
+     */
+    private static void field01() {
+        try {
+            classAllFieldTest(Class.forName("java.lang.Thread"), "field01");
+        } catch (Exception e) {
+            System.out.println("Case field01 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field02
+     *- @Title/Destination: for same field in user-defined class with different type/modifier/annotation, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. classAllFieldTest() passed for fields with different type
+     * -#step2. classAllFieldTest() passed for fields with different access modifier: public, private, protected
+     * -#step3. classAllFieldTest() passed for fields with different modifier: transient, final, volatile, static
+     * -#step4. classAllFieldTest() passed for fields with annotation
+     */
+    private static void field02() {
+        try {
+            classAllFieldTest(Class.forName("TestField02"), "field02");
+        } catch (Exception e) {
+            System.out.println("Case field02 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field03
+     *- @Title/Destination: for same field in strictfp class, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -step1. all test in classAllFieldTest() passed for class with modifier strictfp
+     */
+    private static void field03() {
+        try {
+            classAllFieldTest(Class.forName("TestField03"), "field03");
+        } catch (Exception e) {
+            System.out.println("Case field03 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field04
+     *- @Title/Destination: for same field in interface, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -step1. check all test in classAllFieldTest passed for fields in interface
+     */
+    private static void field04() {
+        try {
+            classAllFieldTest(Class.forName("TestField04"), "field04");
+        } catch (Exception e) {
+            System.out.println("Case field04 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field05
+     *- @Title/Destination: for same field in abstract class, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in abstract class
+     */
+    private static void field05() {
+        try {
+            classAllFieldTest(Class.forName("TestField05"), "field05");
+        } catch (Exception e) {
+            System.out.println("Case field05 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field06
+     *- @Title/Destination: for same field in anonymous class, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. get the class instance of an anonymous class
+     * -#step2. check all test in classAllFieldTest passed for fields in anonymous class
+     */
+    private static void field06() {
+        try {
+            // step 1
+            Class clazz = Class.forName("FieldTest");
+            FieldTest mainClass = new FieldTest();
+            Field field = clazz.getDeclaredField("testField06");
+
+            classAllFieldTest(field.get(mainClass).getClass(), "field06");
+        } catch (Exception e) {
+            System.out.println("Case field06 failed with exception" + e);
+        }
+    }
+
+    private Runnable testField06 = new Runnable() {
+        int intAnonymous = 10;
+        public double doubleAnonymous = 1988.416;
+
+        @Override
+        public void run() {
+            for (int i = 0; i < intAnonymous; i++) {
+                intAnonymous += i;
+            }
+        }
+    };
+
+    /**
+     *- @TestCaseID: field07
+     *- @Title/Destination: for same field in local class(class in a function), certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in local class
+     */
+    private static void field07() {
+        class TestField07 {
+            private final transient int intLocal = 9;
+            public volatile String stringLocal = "a fake behind the fear";
+        }
+        try {
+            classAllFieldTest(Class.forName("FieldTest$1TestField07"), "field07");
+        } catch (Exception e) {
+            System.out.println("Case field07 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field08
+     *- @Title/Destination: for same field in inner class, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in inner class
+     */
+    private static void field08() {
+        try {
+            classAllFieldTest(Class.forName("FieldTest$TestField08"), "field08");
+        } catch (Exception e) {
+            System.out.println("Case field08 failed with exception" + e);
+        }
+    }
+
+    class TestField08 {
+        volatile private char charInner = 'l';
+        public final static transient double doubleInner = 0.88;
+    }
+
+    /**
+     *- @TestCaseID: field09
+     *- @Title/Destination: for same field in user-defined enum class, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in enum class
+     */
+    private static void field09() {
+        try {
+            classAllFieldTest(Class.forName("TestField09"), "field09");
+        } catch (Exception e) {
+            System.out.println("Case field09 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field10
+     *- @Title/Destination: for same field in parent class, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in parent class
+     */
+    private static void field10() {
+        try {
+            classAllFieldTest(Class.forName("TestField10"), "field10");
+        } catch (Exception e) {
+            System.out.println("Case field10 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field11
+     *- @Title/Destination: for same field in child class with implemented interface, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in child class with implemented interface
+     */
+    private static void field11() {
+        try {
+            classAllFieldTest(Class.forName("TestField11"), "field11");
+        } catch (Exception e) {
+            System.out.println("Case field11 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field12
+     *- @Title/Destination: for same field in interface implemented by another class, certain APIs return different Field object when called twice
+     *- @Condition: no
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in interface implemented by another class
+     */
+    private static void field12() {
+        try {
+            classAllFieldTest(Class.forName("TestField12"), "field12");
+        } catch (Exception e) {
+            System.out.println("Case field12 failed with exception" + e);
+        }
+    }
+}
+
+class TestField02 {
+    // step1
+    boolean booleanField = true;
+    byte byteField = (byte)2;
+    short shortField = (short)4;
+    int intField = 6;
+    long longField = 8;
+    char charField = 10;
+    float floatField = 0.4f;
+    double doubleField = 0.8;
+
+    String stringField = "The queerest of the queer";
+    Runnable r = null;
+
+    boolean[][][][][][][] booleanArray7 = new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    String[][][] stringArray3 = new String[][][] {{{"the strangest of the strange"}}};
+
+    // step2
+    public int publicInt = 88;
+    protected double protectedDouble = 99;
+    private String privateString = "the coldest of the cool";
+
+    // step3
+    transient double[][] transientDoubleArray = new double[][] {{1988, 4.16}};
+    final int finalInt = 9876;
+    volatile String volatileString = "the lamest of the lame";
+    static Character staticCharacter = 'd';
+
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotation = new String[][] {{"the numbest of the dumb"}};
+}
+
+strictfp class TestField03 {
+    float floatField = 4.16f;
+    public double doubleField = 19.88;
+}
+
+interface TestField04 {
+    String stringInterface = "i know what's good for you";
+    char[] charInterface = new char[] {'l', 'e', 't'};
+}
+
+abstract class TestField05 {
+    String[] stringsAbstractArray = {"i hate to see you here", "you choke behind a smile"};
+    Runnable[] runnableAbstractArray = {new Runnable() {
+            @Override
+            public void run() {
+            }
+        }
+    };
+}
+
+enum TestField09 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnum = (short)6;
+    public final String stringEnum = "Dry Martini";
+}
+
+class TestField10 {
+    public int int10;
+    protected boolean boolean10;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    private String string10 = "I'm only happy when it rains";
+}
+
+class TestField11 extends TestField10 implements TestField12 {
+    boolean boolean10 = true;
+    public double double11 = 0.416;
+
+}
+
+interface TestField12 {
+    int int10 = 9;
+    boolean boolean10 = false;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    String string10 = "I'm only happy when it rains";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..38b433b809c7c2a96b03bb16cb8c86551969baa7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnotationTypeSetTest.java b/test/testsuite/ouroboros/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnotationTypeSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8bd62e6869afdd0c9e0a340aa86b718243a03631
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnotationTypeSetTest.java
@@ -0,0 +1,75 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationTypeSetTest.java
+ *- @TestCaseName: AnnotationTypeSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value on class
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationTypeSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationTypeSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationTypeSetTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+class Test{
+
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..38b433b809c7c2a96b03bb16cb8c86551969baa7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnotationTypeInterfaceSetTest.java b/test/testsuite/ouroboros/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnotationTypeInterfaceSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ff210001021fa81819fb318f7021aaabb10177a9
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnotationTypeInterfaceSetTest.java
@@ -0,0 +1,75 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationTypeInterfaceSetTest.java
+ *- @TestCaseName: AnnotationTypeInterfaceSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value on an interface
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationTypeInterfaceSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationTypeInterfaceSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationTypeInterfaceSetTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+interface Test{
+
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..38b433b809c7c2a96b03bb16cb8c86551969baa7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnotationTypeEnumSetTest.java b/test/testsuite/ouroboros/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnotationTypeEnumSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..82fef1625d767da166b624c14eb0ee1c8e994b13
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnotationTypeEnumSetTest.java
@@ -0,0 +1,75 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationTypeEnumSetTest.java
+ *- @TestCaseName: AnnotationTypeEnumSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value on an enum class
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationTypeEnumSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationTypeEnumSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationTypeEnumSetTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+enum Test{
+
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..e0a8a16214fd6e393ebc8b39ad14a6d4b5e985c4
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnotationFieldSetTest.java b/test/testsuite/ouroboros/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnotationFieldSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..c7b032484d6e68903582686e0a5f5494d07d0790
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnotationFieldSetTest.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationFieldSetTest.java
+ *- @TestCaseName: AnnotationFieldSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.FIELD)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.FIELD) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value for non-static field
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationFieldSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationFieldSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationFieldSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchFieldException {
+        AnnoA anno = Test.class.getDeclaredField("a").getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    String a;
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..e0a8a16214fd6e393ebc8b39ad14a6d4b5e985c4
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnotationStaticFieldSetTest.java b/test/testsuite/ouroboros/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnotationStaticFieldSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..1b843cfe79bd8b70f5fa50e2ac9e0193ad173c0f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnotationStaticFieldSetTest.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationStaticFieldSetTest.java
+ *- @TestCaseName: AnnotationStaticFieldSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.FIELD)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.FIELD) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationStaticFieldSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationStaticFieldSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationStaticFieldSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchFieldException {
+        AnnoA anno = Test.class.getDeclaredField("a").getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    private static int[] a;
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..441f8aabe58ff94dfcaaf88a4c7b2b8539379f0f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnotationMethodSetTest.java b/test/testsuite/ouroboros/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnotationMethodSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..5e277e2b01a8bbdcc4071b1f3b73e821f47547d9
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnotationMethodSetTest.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationMethodSetTest.java
+ *- @TestCaseName: AnnotationMethodSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.METHOD)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.METHOD) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationMethodSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationMethodSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationMethodSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchMethodException {
+        AnnoA anno = Test.class.getDeclaredMethod("a").getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        // arrays
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    private Thread.State[] a(){
+        return new Thread.State[]{};
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..2b3175497dc9b3fb7c686e6f5e7df7cda4b05d7a
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnotationParameterSetTest.java b/test/testsuite/ouroboros/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnotationParameterSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f74891893e1e424b786f82893abb95aa673e47e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnotationParameterSetTest.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationParameterSetTest.java
+ *- @TestCaseName: AnnotationParameterSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.PARAMETER)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.PARAMETER) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationParameterSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationParameterSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationParameterSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchMethodException {
+//        System.out.println(Test.class.getDeclaredMethod("a"));
+        AnnoA anno = (AnnoA) Test.class.getDeclaredMethod("a", Object[].class).getParameterAnnotations()[0][0];
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+
+class Test{
+    private Thread.State[] a(@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) Object... aaa){
+        return new Thread.State[]{};
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..71066df8aed8011a1e4d536fa61768ea7bded240
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnotationConstructorSetTest.java b/test/testsuite/ouroboros/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnotationConstructorSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b73399bb20cc63ccc518fd328bd1b59edb293a2d
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnotationConstructorSetTest.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationConstructorSetTest.java
+ *- @TestCaseName: AnnotationConstructorSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.CONSTRUCTOR)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.CONSTRUCTOR) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationConstructorSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationConstructorSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationConstructorSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchMethodException {
+//        System.out.println(Test.class.getDeclaredMethod("a"));
+        AnnoA anno = Test.class.getDeclaredConstructor(Object[].class).getDeclaredAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    Test(Object... aaa){
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..bf270f2082a1e443ce53d16e620315c9582ce08b
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..011df9fb8d0e1efc74624c3a377f63cb4418a2cd
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoB.java
@@ -0,0 +1,15 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnotationAnnotationTypeSetTest.java b/test/testsuite/ouroboros/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnotationAnnotationTypeSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b44cfbe3f436a2efe31b8f0870463889e9f6190a
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnotationAnnotationTypeSetTest.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationAnnotationTypeSetTest.java
+ *- @TestCaseName: AnnotationAnnotationTypeSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.ANNOTATION_TYPE)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.ANNOTATION_TYPE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationAnnotationTypeSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationAnnotationTypeSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationAnnotationTypeSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        AnnoA anno = AnnoB.class.getDeclaredAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/Run.java b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/Run.java
new file mode 100755
index 0000000000000000000000000000000000000000..4ea6966ab3956dee5ad1a20347f6062df8f86077
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/Run.java
@@ -0,0 +1,21 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:Run.java
+ *- @TestCaseName: com.huawei.AnnotationPackageSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.PACKAGE)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.PACKAGE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: com.huawei.AnnotationPackageSetTest.jar
+ *- @ExecuteClass: com.huawei.AnnotationPackageSetTest
+ *- @ExecuteArgs:
+ */
diff --git a/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..ca1d82efdaef2db4e8e5eb9366347b078818bc6e
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoA.java
@@ -0,0 +1,36 @@
+package com.huawei;
+
+import com.huawei.AnnoB;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.PACKAGE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..c5050f206c0e8549d6ae15f608d0de4610083eb0
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoB.java
@@ -0,0 +1,11 @@
+package com.huawei;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnotationPackageSetTest.java b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnotationPackageSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b45e949dc9ca727614c608645af9cbb41b5807dc
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnotationPackageSetTest.java
@@ -0,0 +1,47 @@
+package com.huawei;
+
+import java.util.Arrays;
+
+public class AnnotationPackageSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        Package packageInfo = Package.getPackage("com.huawei");
+        AnnoA anno = packageInfo.getDeclaredAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@com.huawei.AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@com.huawei.AnnoB(intB=999), @com.huawei.AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java package-info.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java package-info.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/package-info.java b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/package-info.java
new file mode 100755
index 0000000000000000000000000000000000000000..d5562d57f1338baebbc2a4344324c2ce58cede8b
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/package-info.java
@@ -0,0 +1,32 @@
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+package com.huawei;
+
+class PackageInfo{
+    public void say(){
+        System.out.println("hello");
+    }
+}
+
+class PackageInfoGeneric<T extends Throwable>{
+    private T obj;
+
+    public void setObj(T obj) {
+        this.obj = obj;
+    }
+    public void say(){
+        System.out.println("hello "+obj);
+    }
+}
+
+interface PackageInfoInterface {
+    void test();
+}
+
+class PackageInfoConst {
+    public static final String MESSAGE="Annotation Study";
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c2ab1b3973a77248c3afcf1b038b6603a3aeb21
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java b/test/testsuite/ouroboros/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..c0b1d69b328e665a0f83428c1c3f3924e117f3fc
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationTypeParameterSetTest.java
+ *- @TestCaseName: AnnotationTypeParameterSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE_PARAMETER)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE_PARAMETER) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationTypeParameterSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationTypeParameterSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationTypeParameterSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+
+        System.out.println(Test.class.getAnnotations().length);
+//      TypeVeriable.getAnnotation not supported in ART
+/*      AnnoA anno = Test.class.getTypeParameters()[0].getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));*/
+    }
+}
+
+class Test<@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) T> {
+
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..063bd569435d45bd8139ac3522fa94efa6dc779f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java b/test/testsuite/ouroboros/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6c39fe980f0ffb4bbe178ee051e34e81476fe1b6
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationTypeUseSetTest.java
+ *- @TestCaseName: AnnotationTypeUseSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE_USE)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE_USE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationTypeUseSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationTypeUseSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationTypeUseSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        System.out.println(Test.class.getAnnotations().length);
+/*        AnnoA anno = Test.class.getTypeParameters()[0].getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));*/
+    }
+}
+
+class Test<@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) T> {
+
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..c46a1ae1813abd9c73b5abb163a5f82eca4109e1
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoA.java
@@ -0,0 +1,17 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA() default Integer.MAX_VALUE;
+
+    double doubleA() default Double.MIN_VALUE;
+
+    String stringA() default "";
+
+    AnnoB annoBA();
+
+    ENUMA enumA() default ENUMA.A;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoC.java b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoC.java
new file mode 100755
index 0000000000000000000000000000000000000000..e86c63e3d1ae797fc234241ee0cabf8bddf12093
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoC.java
@@ -0,0 +1,17 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoC {
+    int[] intA() default Integer.MAX_VALUE;
+
+    double[] doubleA() default Double.MIN_VALUE;
+
+    String[] stringA() default "";
+
+    AnnoB[] annoBA() default @AnnoB;
+
+    ENUMA[] enumA() default ENUMA.A;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoD.java b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoD.java
new file mode 100755
index 0000000000000000000000000000000000000000..eb15087f77423ad5cb389033d9f5b987f9192d8a
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoD.java
@@ -0,0 +1,17 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoD {
+    int intA() default Integer.MAX_VALUE;
+
+    double doubleA() default Double.MIN_VALUE;
+
+    String stringA() default "";
+
+    AnnoB annoBA();
+
+    ENUMA enumA() default ENUMA.A;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnotationMultiThread.java b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnotationMultiThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..531fc94fddf753e35c8f7e3d83b70dcbe6bf0048
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnotationMultiThread.java
@@ -0,0 +1,185 @@
+/*
+ *- @TestCaseID: Maple_MethodHandle_invoke_AnnotationMultiThread
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationMultiThread.java
+ *- @TestCaseName: AnnotationMultiThread
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation, verify when multiple thread try to use annotations, working fine
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value under multithread
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationMultiThread.java AnnoA.java AnnoB.java AnnoC.java AnnoD.java ENUMA.java
+ *- @ExecuteClass: AnnotationMultiThread
+ *- @ExecuteArgs:
+ *- @Author:linxiaojun/l00473412
+ */
+
+import java.lang.annotation.Annotation;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class AnnotationMultiThread {
+    static AtomicInteger passCnt = new AtomicInteger();
+    public static void main(String[] args) throws ClassNotFoundException {
+        ThreadGroup threadGroup = new ThreadGroup("myGroup");
+
+        String[][] expectedGF = new String[][]{
+                {"@AnnoA", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+                {"@AnnoB(intB=999)"},
+                {"@AnnoC", "annoBA=[@AnnoB(intB=999)]", "intA=[2147483647]", "enumA=[A]", "stringA=[]", "doubleA=[4.9E-324]"}
+        };
+
+        String[][] expectedF = new String[][]{
+                {"@AnnoA", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+                {"@AnnoB(intB=999)"},
+                {"@AnnoC", "annoBA=[@AnnoB(intB=999)]", "intA=[2147483647]", "enumA=[A]", "stringA=[]", "doubleA=[4.9E-324]"},
+                {"@AnnoD", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+        };
+
+        new AnnotationGetter("GrandFather", expectedGF, expectedGF, threadGroup, "threadGF").start();
+        new AnnotationGetter("Father", expectedF, expectedF, threadGroup, "threadF").start();
+        new AnnotationGetter("Interface", expectedF, expectedF, threadGroup, "threadI").start();
+        new AnnotationGetter("Son", expectedF, new String[][]{}, threadGroup, "threadS").start();
+        new AnnotationGetter("Son2", expectedF, new String[][]{}, threadGroup, "threadS2").start();
+        new AnnotationGetter("GrandFather", expectedGF, expectedGF, threadGroup, "threadGF").start();
+        new AnnotationGetter("Father", expectedF, expectedF, threadGroup, "threadF").start();
+        new AnnotationGetter("Interface", expectedF, expectedF, threadGroup, "threadI").start();
+        new AnnotationGetter("Son", expectedF, new String[][]{}, threadGroup, "threadI").start();
+        new AnnotationGetter("Son2", expectedF, new String[][]{}, threadGroup, "threadI").start();
+
+        int i = 0;
+        while (threadGroup.activeCount() > 0){
+            i++;
+            try {
+                Thread.sleep(100);
+            }catch (InterruptedException e){
+                System.out.println(e);
+            }
+            if(i > 1000){
+                break;
+            }
+        }
+
+        System.out.println(passCnt.get() - 200);
+    }
+
+
+    public static boolean checkAllAnnotations(Annotation[] annotations, String[][] expected){
+        String[] actual = new String[annotations.length];
+
+        for (int i = 0; i < annotations.length; i++){
+            actual[i] = annotations[i].toString();
+        }
+        Arrays.sort(actual);
+        if (actual.length != expected.length){
+            return false;
+        }
+//        System.out.println(Arrays.toString(actual));
+        for (int i = 0; i < annotations.length; i++){
+            if (expected[i].length == 1){
+                if (actual[i].compareTo(expected[i][0])!=0){
+                    System.out.println(actual[i]);
+                    System.out.println(expected[i][0]);
+                    return false;
+                }
+            }else {
+                for (int j = 0; j < expected[i].length; j++){
+                    if (!actual[i].contains(expected[i][j])){
+                        System.out.println(actual[i]);
+                        System.out.println(expected[i][j]);
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+}
+
+class AnnotationGetter extends Thread{
+    String name;
+    String[][] expected;
+    String[][] expectedD;
+
+    AnnotationGetter(String nameI, String[][] expectedI, String[][] expectedDI, ThreadGroup threadGroup, String thread_name){
+        super(threadGroup, thread_name);
+        name = nameI;
+        expected = expectedI;
+        expectedD = expectedDI;
+    }
+
+    @Override
+    public void run() {
+        try {
+            for (int i = 0; i < 10; i++) {
+                if (AnnotationMultiThread.checkAllAnnotations(Class.forName(this.name).getAnnotations(), this.expected)){
+                    AnnotationMultiThread.passCnt.incrementAndGet();
+                }
+                if (AnnotationMultiThread.checkAllAnnotations(Class.forName(this.name).getDeclaredAnnotations(), this.expectedD)){
+                    AnnotationMultiThread.passCnt.incrementAndGet();
+                }
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+
+    }
+}
+
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+class GrandFather{
+    public void method1(int a, double b, Object... objects){
+    }
+}
+
+@SuppressWarnings("all")
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+@AnnoD(annoBA = @AnnoB)
+class Father extends GrandFather implements Interface{
+    @Override
+    public void method1(int a, double b, Object... objects) {
+    }
+
+    @Deprecated
+    public void method2(){
+    }
+}
+
+class Son extends Father{
+    @Override
+    @Deprecated
+    public void method2(){
+    }
+}
+
+class Son2 extends Father{
+    @Override
+    @Deprecated
+    public void method2(){
+    }
+}
+
+@SuppressWarnings("all")
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+@AnnoD(annoBA = @AnnoB)
+interface Interface{
+
+}
+// DEPENDENCE: AnnoA.java AnnoB.java AnnoC.java AnnoD.java ENUMA.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java AnnoC.java AnnoD.java ENUMA.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/ENUMA.java b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/ENUMA.java
new file mode 100755
index 0000000000000000000000000000000000000000..4b216d8166bb042e50ac85d8587f07f857be7646
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0202-rt-compact-AnnotationMultiThread/ENUMA.java
@@ -0,0 +1,5 @@
+public enum  ENUMA {
+    A,
+    B,
+    C
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/ReflectClassNameTest.java b/test/testsuite/ouroboros/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/ReflectClassNameTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8161e0039384c67404a6d78a5939bc60a3bc81fa
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/ReflectClassNameTest.java
@@ -0,0 +1,70 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:ReflectClassNameTest.java
+ *- @TestCaseName: ReflectClassNameTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for reflection, able to get class, method, field with non-english
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. class, method, field with non-english name
+ * -#step2. able to be get by reflection
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: ReflectClassNameTest.java
+ *- @ExecuteClass: ReflectClassNameTest
+ *- @ExecuteArgs:
+ */
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+
+public class ReflectClassNameTest {
+    static int[] passCnt = new int[6];
+    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {
+        int i = 0;
+        Class clazz = Class.forName("一");
+        passCnt[i++] = clazz.getName().compareTo("一") == 0 ? 1 : 0;
+        Method method = clazz.getDeclaredMethod("дракон");
+        passCnt[i++] = method.getName().compareTo("дракон") == 0 ? 1 : 0;
+        Field field = clazz.getDeclaredField("Rồng");
+        passCnt[i++] = field.getName().compareTo("Rồng") == 0 ? 1 : 0;
+
+        Class clazz2 = Class.forName("二");
+        passCnt[i++] = clazz2.getName().compareTo("二") == 0 ? 1 : 0;
+
+        class 三{
+
+        }
+        Class clazz3 = Class.forName("ReflectClassNameTest$1三");
+        passCnt[i++] = clazz3.getName().compareTo("ReflectClassNameTest$1三") == 0 ? 1 : 0;
+
+        Class clazz4 = Class.forName("ReflectClassNameTest$二");
+        passCnt[i++] = clazz4.getName().compareTo("ReflectClassNameTest$二") == 0 ? 1 : 0;
+
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1]"));
+    }
+
+    class 二{
+
+    }
+}
+
+class 一{
+    int Rồng;
+
+    public void дракон(){
+
+    }
+}
+
+interface 二{
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..fecde3f71beb4f0c425a8fb6223ebec7ca2d79d8
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int 整型();
+    byte 字节();
+    char 字符();
+    double 双精度浮点();
+    boolean 布尔();
+    long 长整();
+    float 浮点();
+    short 短整型();
+    int[] あ();
+    byte[] い();
+    char[] う();
+    double[] え();
+    boolean[] お();
+    long[] か();
+    float[] き();
+    short[] く();
+    String 长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长();
+    String[] 神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马();
+    Class 类();
+    Class[] 类类();
+    Thread.State 类类类();
+    Thread.State[] 类类类类();
+    AnnoB 类类类类类();
+    AnnoB[] 类类类类类类();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnotationNotAscii.java b/test/testsuite/ouroboros/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnotationNotAscii.java
new file mode 100755
index 0000000000000000000000000000000000000000..09e5395c8503c8341272ef6e8628321cc31320cb
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnotationNotAscii.java
@@ -0,0 +1,75 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationNotAscii.java
+ *- @TestCaseName: AnnotationNotAscii
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value on class
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationNotAscii.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationNotAscii
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationNotAscii {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.整型() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.字节() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.字符() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.双精度浮点()) ? 1: 0;
+        passCnt[i++] += anno.布尔() ? 1: 0;
+        passCnt[i++] += anno.长整() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.浮点())? 1: 0;
+        passCnt[i++] += anno.短整型() == Short.MAX_VALUE ? 1: 0;
+
+        // enum, string, annotation, class
+        passCnt[i++] += anno.类类类() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.类() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.あ()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        // array
+        passCnt[i++] += (anno.い().length == 1 && anno.い()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.う().length == 1 && anno.う()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.え().length == 3 && Double.isNaN(anno.え()[0]) && Double.isInfinite(anno.え()[1]) && Double.isInfinite(anno.え()[2]))? 1: 0;
+        passCnt[i++] += (anno.お().length == 1 && anno.お()[0]) ? 1: 0;
+        passCnt[i++] += (anno.か().length == 1 && anno.か()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.き().length == 3 && Float.isNaN(anno.き()[0]) && Float.isInfinite(anno.き()[1]) && Float.isInfinite(anno.き()[2])) ? 1: 0;
+        passCnt[i++] += (anno.く().length == 1 && anno.く()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马().length == 1 && anno.神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.类类().length == 1 && anno.类类()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.类类类类().length == 1 && anno.类类类类()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.类类类类类().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.类类类类类类()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+
+@AnnoA(整型 = Integer.MAX_VALUE, 字节 = Byte.MAX_VALUE, 字符 = Character.MAX_VALUE, 双精度浮点 = Double.NaN,
+        布尔 = true, 长整 = Long.MAX_VALUE, 浮点 = Float.NaN, 短整型 = Short.MAX_VALUE,
+        あ = {1,2}, い = {0}, う = {' '}, え = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        お = {true}, か = {Long.MAX_VALUE}, き = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, く = {0},
+        长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长 = "", 神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马 = "", 类 = Thread.class, 类类 = Thread.class, 类类类 = Thread.State.BLOCKED,
+        类类类类 = Thread.State.NEW, 类类类类类 = @AnnoB, 类类类类类类 = {@AnnoB, @AnnoB})
+class Test{
+
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..c3c78b6b3e1ef2567d287191e49a7d707f71eec0
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoA.java
@@ -0,0 +1,53 @@
+import java.lang.annotation.*;
+
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Repeatable(Test.class)
+@AnnoB(intB = 1)
+@AnnoB(intB = 2)
+@AnnoB(intB = 3)
+@AnnoB(intB = 4)
+@AnnoB(intB = 5)
+@AnnoB(intB = 6)
+@AnnoB(intB = 7)
+@AnnoB(intB = 8)
+@AnnoB(intB = 9)
+@AnnoB(intB = 10)
+@AnnoB(intB = 11)
+@AnnoB(intB = 12)
+@AnnoB(intB = 13)
+@AnnoB(intB = 14)
+@AnnoB(intB = 15)
+@AnnoB(intB = 16)
+@AnnoB(intB = 17)
+@AnnoB(intB = 18)
+public @interface AnnoA {
+    int intA() default 0;
+    byte byteA() default 0;
+    char charA() default 0;
+    double doubleA() default 0;
+    boolean booleanA() default true;
+    long longA() default 0;
+    float floatA() default 0;
+    short shortA() default 0;
+    int[] intAA() default 0;
+    byte[] byteAA() default 0;
+    char[] charAA() default 0;
+    double[] doubleAA() default 0;
+    boolean[] booleanAA() default true;
+    long[] longAA() default 0;
+    float[] floatAA() default 0;
+    short[] shortAA() default 0;
+    String stringA() default "";
+    String[] stringAA() default "";
+    Class classA() default Thread.class;
+    Class[] classAA() default Thread.class;
+    Thread.State stateA() default Thread.State.BLOCKED;
+    Thread.State[] stateAA() default Thread.State.BLOCKED;
+    AnnoB annoBA() default @AnnoB;
+    AnnoB[] annoBAA() default @AnnoB;
+    AnnoB[] value();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..08e0bcc447bcbbbdf290eb9ccd2beea172a473af
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoB.java
@@ -0,0 +1,10 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Repeatable(AnnoA.class)
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnotationRepeatable.java b/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnotationRepeatable.java
new file mode 100755
index 0000000000000000000000000000000000000000..12f2bbaa2451f6dfa5efb8ffa9c914d3dc2e1bdb
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnotationRepeatable.java
@@ -0,0 +1,87 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationRepeatable.java
+ *- @TestCaseName: AnnotationRepeatable
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Repeatable
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Repeatable can be used more than one time on annotation type
+ * -#step2. verify able to set and get value on class
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationRepeatable.java AnnoA.java AnnoB.java Test.java
+ *- @ExecuteClass: AnnotationRepeatable
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationRepeatable {
+    static int[] passCnt = new int[25];
+    public static void main(String[] args) {
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[0], "[@AnnoB(intB=-1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[1], "[@AnnoB(intB=-2), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[2], "[@AnnoB(intB=-3), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[3], "[@AnnoB(intB=-4), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[4], "[@AnnoB(intB=-5), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[5], "[@AnnoB(intB=-6), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[6], "[@AnnoB(intB=-7), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[7], "[@AnnoB(intB=-8), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[8], "[@AnnoB(intB=-9), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[9], "[@AnnoB(intB=-10), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+
+        boolean checkAnnoA = Arrays.toString(passCnt).compareTo("[1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]") == 0;
+        boolean checkAnnoB = Arrays.toString(AnnoA.class.getAnnotation(AnnoA.class).value()).compareTo("[@AnnoB(intB=1), @AnnoB(intB=2), @AnnoB(intB=3), @AnnoB(intB=4), @AnnoB(intB=5), @AnnoB(intB=6), @AnnoB(intB=7), @AnnoB(intB=8), @AnnoB(intB=9), @AnnoB(intB=10), @AnnoB(intB=11), @AnnoB(intB=12), @AnnoB(intB=13), @AnnoB(intB=14), @AnnoB(intB=15), @AnnoB(intB=16), @AnnoB(intB=17), @AnnoB(intB=18)]") == 0;
+
+        if (checkAnnoA && checkAnnoB){
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+
+    private static void checkAnnoA(AnnoA anno, String value){
+        int i = 0;
+        passCnt[i++] = anno.intA() == 0 ? 1: 0;
+        passCnt[i++] += anno.byteA() == 0 ? 1: 0;
+        passCnt[i++] += anno.charA() == 0 ? 1: 0;
+        passCnt[i++] += anno.doubleA() == 0 ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == 0 ? 1: 0;
+        passCnt[i++] += anno.floatA() == 0? 1: 0;
+        passCnt[i++] += anno.shortA() == 0 ? 1: 0;
+
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+
+        // array
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[0]") == 0 ? 1: 0;
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 1 && anno.doubleAA()[0] == 0)? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 1 && anno.floatAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.BLOCKED) ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999)]") == 0 ? 1: 0;
+
+        // value
+        passCnt[i++] += Arrays.toString(anno.value()).compareTo(value) == 0 ? 1: 0;
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java Test.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java Test.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/Test.java b/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/Test.java
new file mode 100755
index 0000000000000000000000000000000000000000..6294012adeef4ccfd5ce06a5a4528c60d712d611
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0205-rt-compact-AnnotationRepeatable/Test.java
@@ -0,0 +1,19 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@AnnoA( value = @AnnoB(intB = -1))
+@AnnoA( value = {@AnnoB(intB = -2), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -3), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -4), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -5), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -6), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -7), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -8), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -9), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -10), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+public @interface Test{
+    AnnoA[] value();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..38b433b809c7c2a96b03bb16cb8c86551969baa7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnotationTypeInnerClassSet.java b/test/testsuite/ouroboros/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnotationTypeInnerClassSet.java
new file mode 100755
index 0000000000000000000000000000000000000000..a2f27d5ead13c9f81c8f1f9f6547a3bb555dd776
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnotationTypeInnerClassSet.java
@@ -0,0 +1,79 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationTypeInnerClassSet.java
+ *- @TestCaseName: AnnotationTypeInnerClassSet
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value on inner class
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationTypeInnerClassSet.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationTypeInnerClassSet
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationTypeInnerClassSet {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) throws ClassNotFoundException {
+        AnnoA anno = Class.forName("AnnotationTypeInnerClassSet$Test").getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) &&
+                Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) &&
+                Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt)
+                .compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY,
+            Double.POSITIVE_INFINITY}, booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN,
+            Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    class Test{
+
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoA.java b/test/testsuite/ouroboros/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..38b433b809c7c2a96b03bb16cb8c86551969baa7
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoA.java
@@ -0,0 +1,32 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoB.java b/test/testsuite/ouroboros/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a77a033f61b181a8783b74f2eabec2b75dca3f
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoB.java
@@ -0,0 +1,9 @@
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnotationTypeLocalClassSet.java b/test/testsuite/ouroboros/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnotationTypeLocalClassSet.java
new file mode 100755
index 0000000000000000000000000000000000000000..a9e468b97e6f6908631ab71b5621a52f9044e433
--- /dev/null
+++ b/test/testsuite/ouroboros/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnotationTypeLocalClassSet.java
@@ -0,0 +1,77 @@
+/*
+ *- @TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @RequirementID: SR000B7N9H
+ *- @TestCaseName:AnnotationTypeLocalClassSet.java
+ *- @TestCaseName: AnnotationTypeLocalClassSet
+ *- @TestCaseType: Function Testing
+ *- @RequirementID: AR000D0OR6
+  *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE)
+ *- @Condition: no
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value on inner class
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Remark:
+ *- @Source: AnnotationTypeLocalClassSet.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationTypeLocalClassSet
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationTypeLocalClassSet {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) throws ClassNotFoundException {
+        @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+                booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+                intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+                booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+                stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+                stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+        class Test{
+
+        }
+
+        AnnoA anno = Class.forName("AnnotationTypeLocalClassSet$1Test").getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+
+
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/eh_test/RT0023-rt-eh-NativeCatchExceptionTest/NativeCatchExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0023-rt-eh-NativeCatchExceptionTest/NativeCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7884234e20f98d1d93a3bb3ee982dd412ecaf1f1
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0023-rt-eh-NativeCatchExceptionTest/NativeCatchExceptionTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NativeCatchExceptionTest.java
+ * -@TestCaseName: Asynchronous: Native(exception at callback from Java), captured by Java.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Declare a native method, Create the native method in C file.
+ * -#step2: The C file Method will Call java method callback, the callback will throw NumberFormatException.
+ * -#step3: Invoke this native method.
+ * -#step4: Check NumberFormatException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: NativeCatchExceptionTest.java jniNativeCatchExceptionTest.cpp
+ * -@ExecuteClass: NativeCatchExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class NativeCatchExceptionTest extends Exception {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+
+    private native void nativeNativeCatchExceptionTest() throws IllegalStateException;
+
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = nativeCatchExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Asynchronous: Native(exception at callback from Java), captured by Java.
+     * @return status code
+     */
+    public static int nativeCatchExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED */
+
+        NativeCatchExceptionTest cTest = new NativeCatchExceptionTest();
+        try {
+            cTest.nativeNativeCatchExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 1;
+            processResult--;
+        } catch (IllegalStateException e2) {
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            processResult -= 10;
+        }
+
+        processResult -= 3;
+        return result1;
+    }
+}
+
+// DEPENDENCE: jniNativeCatchExceptionTest.cpp
+// EXEC:%maple  NativeCatchExceptionTest.java jniNativeCatchExceptionTest.cpp %build_option -o %n.so
+// EXEC:%run %n.so NativeCatchExceptionTest %run_option | compare %f
+// ASSERT: scan-full ------>CheckPoint:CcanContinue\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0023-rt-eh-NativeCatchExceptionTest/jniNativeCatchExceptionTest.cpp b/test/testsuite/ouroboros/eh_test/RT0023-rt-eh-NativeCatchExceptionTest/jniNativeCatchExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d7b31e7054c0f3a58c1400697bc6b8698c0efd36
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0023-rt-eh-NativeCatchExceptionTest/jniNativeCatchExceptionTest.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCatchExceptionTest_nativeNativeCatchExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if ( cls == NULL ) {
+        return;
+    }
+
+    mid = env->GetMethodID(cls, "callback", "()V");
+    if ( mid == NULL ) {
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+    printf("------>CheckPoint:CcanContinue\n");
+}
+}
diff --git a/test/testsuite/ouroboros/eh_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/NativeCodeCheckExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/NativeCodeCheckExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..70f67980077ebf750a8bde3bd3d12cb4292f7d8f
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/NativeCodeCheckExceptionTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NativeCodeCheckExceptionTest.java
+ * -@TestCaseName: Asynchronous: Native(exception at callback from Java, then throw)，captured by Java.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Declare a native method, Create the native method in C file.
+ * -#step2: The C file Method will Call java method callback, the callback will throw NumberFormatException.
+ * -#step3: Invoke this native method.
+ * -#step4: Check NumberFormatException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: NativeCodeCheckExceptionTest.java jniNativeCodeCheckExceptionTest.cpp
+ * -@ExecuteClass: NativeCodeCheckExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class NativeCodeCheckExceptionTest extends Exception {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+
+    private native void nativeNativeCodeCheckExceptionTest() throws IllegalStateException;
+
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = nativeCodeCheckExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 3 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Asynchronous: Native(exception at callback from Java, then throw)，captured by Java.
+     * @return status code
+     */
+    public static int nativeCodeCheckExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED */
+        NativeCodeCheckExceptionTest cTest = new NativeCodeCheckExceptionTest();
+        try {
+            cTest.nativeNativeCodeCheckExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 3;
+            processResult -= 1;
+        } catch (IllegalStateException e2) {
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            processResult -= 10;
+        } finally {
+            processResult -= 3;
+            return result1;
+        }
+    }
+}
+
+// DEPENDENCE: jniNativeCodeCheckExceptionTest.cpp
+// EXEC:%maple  NativeCodeCheckExceptionTest.java jniNativeCodeCheckExceptionTest.cpp %build_option -o %n.so
+// EXEC:%run %n.so NativeCodeCheckExceptionTest  %run_option | compare %f
+// ASSERT: scan-full ------>CheckPoint:CcanContinue\n
diff --git a/test/testsuite/ouroboros/eh_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/jniNativeCodeCheckExceptionTest.cpp b/test/testsuite/ouroboros/eh_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/jniNativeCodeCheckExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..38a80215511a1de3a04bc0107ca72efd71f9a3c8
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/jniNativeCodeCheckExceptionTest.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCodeCheckExceptionTest_nativeNativeCodeCheckExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jthrowable j_exc = NULL;
+    j_exc = env->ExceptionOccurred();
+
+    if(j_exc){
+        env->Throw(j_exc);
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+}
diff --git a/test/testsuite/ouroboros/eh_test/RT0025-rt-eh-NativeNewExceptionTest/NativeNewExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0025-rt-eh-NativeNewExceptionTest/NativeNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0ebc4ec3843c0601b69ef1f9cfbdad26e0a3b1d
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0025-rt-eh-NativeNewExceptionTest/NativeNewExceptionTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NativeNewExceptionTest.java
+ * -@TestCaseName: Asynchronous: Native(exception-throw new), captured by Java.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Declare a native method that throws an exception, Create the native method throws new exception in C file.
+ * -#step2: The C file Method will Call java method callback.
+ * -#step3: Invoke this native method.
+ * -#step4: Check new Exception StringIndexOutOfBoundsException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: NativeNewExceptionTest.java jniNativeNewExceptionTest.cpp
+ * -@ExecuteClass: NativeNewExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class NativeNewExceptionTest extends Exception {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+
+    private native void nativeNativeNewExceptionTest() throws IllegalStateException;
+
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = nativeNewExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 3 && processResult == 95) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Asynchronous: Native(exception-throw new), captured by Java.
+     * @return status code
+     */
+    public static int nativeNewExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED */
+
+        NativeNewExceptionTest cTest = new NativeNewExceptionTest();
+        try {
+            cTest.nativeNativeNewExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            processResult -= 10;
+        } catch (IllegalStateException e2) {
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 3;
+            processResult--;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
+
+// DEPENDENCE: jniNativeNewExceptionTest.cpp
+// EXEC:%maple  NativeNewExceptionTest.java jniNativeNewExceptionTest.cpp %build_option -o %n.so
+// EXEC:%run %n.so NativeNewExceptionTest  %run_option | compare %f
+// ASSERT: scan-full ------>CheckPoint:CcanContinue\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0025-rt-eh-NativeNewExceptionTest/jniNativeNewExceptionTest.cpp b/test/testsuite/ouroboros/eh_test/RT0025-rt-eh-NativeNewExceptionTest/jniNativeNewExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b80654c89c4bdf325e8090f431f0820a0b253221
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0025-rt-eh-NativeNewExceptionTest/jniNativeNewExceptionTest.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeNewExceptionTest_nativeNativeNewExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+    jclass newExcCls = NULL;
+    newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+    if (newExcCls == NULL){
+        return;
+    }
+
+    env->ThrowNew(newExcCls,"NativeThrowNew");
+    printf("------>CheckPoint:CcanContinue\n");
+}
+}
diff --git a/test/testsuite/ouroboros/eh_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/NativeTryCatchNewExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/NativeTryCatchNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..90c0eac1f2941c2a0afbbe937fc0c06687f5b399
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/NativeTryCatchNewExceptionTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:NativeTryCatchNewExceptionTest.java
+ * -@TestCaseName: Asynchronous: Native(exception at callback from Java-throw new), captured by Java(try-catch).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Declare a native method that throws an exception, Create the native method throws new exception in C file.
+ * -#step2: The C file Method will Call java method callback.
+ * -#step3: Invoke this native method.
+ * -#step4: Check new Exception StringIndexOutOfBoundsException is thrown by Java(try-catch).
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source:NativeTryCatchNewExceptionTest.java jniNativeTryCatchNewExceptionTest.cpp
+ * -@ExecuteClass: NativeTryCatchNewExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class NativeTryCatchNewExceptionTest extends Exception {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+
+    private native void nativeNativeTryCatchNewExceptionTest() throws IllegalArgumentException;
+
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = nativeTryCatchNewExceptionTest();
+        } catch (Exception e) {
+            processResult--;
+        }
+
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Asynchronous: Native(exception at callback from Java-throw new), captured by Java(try-catch).
+     * @return status code
+     */
+    public static int nativeTryCatchNewExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED */
+
+        NativeTryCatchNewExceptionTest cTest = new NativeTryCatchNewExceptionTest();
+        try {
+            cTest.nativeNativeTryCatchNewExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            processResult -= 10;
+        } catch (IllegalStateException e2) {
+            processResult -= 10;
+        } finally {
+            processResult -= 3;
+        }
+        return result1;
+    }
+}
+
+// DEPENDENCE: jniNativeTryCatchNewExceptionTest.cpp
+// EXEC:%maple  NativeTryCatchNewExceptionTest.java jniNativeTryCatchNewExceptionTest.cpp %build_option -o %n.so
+// EXEC:%run %n.so NativeTryCatchNewExceptionTest  %run_option | compare %f
+// ASSERT: scan-full ------>CheckPoint:CcanContinue\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/jniNativeTryCatchNewExceptionTest.cpp b/test/testsuite/ouroboros/eh_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/jniNativeTryCatchNewExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..854cf2629ddd4479a4704ebd751ae9f62b9416b0
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/jniNativeTryCatchNewExceptionTest.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeTryCatchNewExceptionTest_nativeNativeTryCatchNewExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jclass newExcCls = NULL;
+    newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+    if (newExcCls == NULL){
+        return;
+    }
+
+    env->ThrowNew(newExcCls,"NativeThrowNew");
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+}
diff --git a/test/testsuite/ouroboros/eh_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/NativeCodeCheckNewExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/NativeCodeCheckNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f71f50cbbe08bc677ebf58f2679f54d74fbe4a1d
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/NativeCodeCheckNewExceptionTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NativeCodeCheckNewExceptionTest.java
+ * -@TestCaseName: Asynchronous: Native(exception at callback from Java, then Occurred-throw new), catch by Java.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Declare a native method that throws an exception, Create the native method throws new exception in C file.
+ * -#step2: The C file Method will Call java method callback, use ExceptionOccurred check Exception.
+ * -#step3: Invoke this native method.
+ * -#step4: Check new Exception StringIndexOutOfBoundsException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: NativeCodeCheckNewExceptionTest.java jniNativeCodeCheckNewExceptionTest.cpp
+ * -@ExecuteClass: NativeCodeCheckNewExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+
+public class NativeCodeCheckNewExceptionTest extends Exception {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+
+    private native void nativeNativeCodeCheckNewExceptionTest() throws InvalidPathException;
+
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = nativeCodeCheckNewExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Asynchronous: Native(exception at callback from Java, then Occurred-throw new), catch by Java.
+     * @return status code
+     */
+    public static int nativeCodeCheckNewExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED */
+
+        NativeCodeCheckNewExceptionTest cTest = new NativeCodeCheckNewExceptionTest();
+        try {
+            cTest.nativeNativeCodeCheckNewExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 3;
+            System.out.println("======>" + e1.getMessage());
+            processResult -= 10;
+        } catch (InvalidPathException e2) {
+            result1 = 3;
+            System.out.println("======>" + e2.getMessage());
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 1;
+            processResult--;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
+
+// DEPENDENCE: jniNativeCodeCheckNewExceptionTest.cpp
+// EXEC:%maple  NativeCodeCheckNewExceptionTest.java jniNativeCodeCheckNewExceptionTest.cpp %build_option -o %n.so
+// EXEC:%run %n.so NativeCodeCheckNewExceptionTest  %run_option | compare %f
+// ASSERT: scan-full ------>CheckPoint:CcanContinue\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/jniNativeCodeCheckNewExceptionTest.cpp b/test/testsuite/ouroboros/eh_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/jniNativeCodeCheckNewExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d462318e34c366505fa253157a6f1591e8a96eb9
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/jniNativeCodeCheckNewExceptionTest.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCodeCheckNewExceptionTest_nativeNativeCodeCheckNewExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jthrowable j_exc =NULL;
+    j_exc=env->ExceptionOccurred();
+    if (j_exc == NULL){
+        return;
+    }
+
+    if (j_exc){
+        jclass newExcCls = NULL;
+        newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+        if (newExcCls == NULL){
+            return;
+        }
+        env->ThrowNew(newExcCls,"NativeThrowNew");
+    }
+    printf("------>CheckPoint:CcanContinue\n");
+}
+}
diff --git a/test/testsuite/ouroboros/eh_test/RT0028-rt-eh-NativeClearExceptionTest/NativeClearExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0028-rt-eh-NativeClearExceptionTest/NativeClearExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..93005799826b781ef737c152dffefa5fb7a22d07
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0028-rt-eh-NativeClearExceptionTest/NativeClearExceptionTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NativeClearExceptionTest.java
+ * -@TestCaseName: Asynchronous: Native(exception at callback from Java, then Occurred-throw new-clear).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Declare a native method that throws an exception.
+ * -#step2: Create the native method throws new exception in C file.
+ * -#step3: The C file Method will Call java method callback, use ExceptionOccurred check Exception, use ExceptionClear
+ *          clear Exception.
+ * -#step4: Invoke this native method.
+ * -#step5: Check new Exception StringIndexOutOfBoundsException is not thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: NativeClearExceptionTest.java jniNativeClearExceptionTest.cpp
+ * -@ExecuteClass: NativeClearExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+
+public class NativeClearExceptionTest extends Exception {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+
+    private native void nativeNativeClearExceptionTest() throws InvalidPathException;
+
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = nativeClearExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 95) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Asynchronous: Native(exception at callback from Java, then Occurred-throw new-clear).
+     * @return status code
+     */
+    public static int nativeClearExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED */
+
+        NativeClearExceptionTest cTest = new NativeClearExceptionTest();
+        try {
+            cTest.nativeNativeClearExceptionTest();
+            processResult -= 1;
+        } catch (NumberFormatException e1) {
+            result1 = 3;
+            System.out.println("======>" + e1.getMessage());
+            processResult -= 10;
+        } catch (InvalidPathException e2) {
+            result1 = 3;
+            System.out.println("======>" + e2.getMessage());
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 3;
+            System.out.println("======>" + e3.getMessage());
+            processResult -= 10;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
+
+// DEPENDENCE: jniNativeClearExceptionTest.cpp
+// EXEC:%maple  NativeClearExceptionTest.java jniNativeClearExceptionTest.cpp %build_option -o %n.so
+// EXEC:%run %n.so NativeClearExceptionTest  %run_option | compare %f
+// ASSERT: scan-full ------>CheckPoint:CcanContinue\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0028-rt-eh-NativeClearExceptionTest/jniNativeClearExceptionTest.cpp b/test/testsuite/ouroboros/eh_test/RT0028-rt-eh-NativeClearExceptionTest/jniNativeClearExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2ec5f8439a9fac7a2b643a6a330a1229983c381e
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0028-rt-eh-NativeClearExceptionTest/jniNativeClearExceptionTest.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeClearExceptionTest_nativeNativeClearExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jthrowable j_exc =NULL;
+    j_exc=env->ExceptionOccurred();
+    if (j_exc == NULL){
+        return;
+    }
+
+    if (j_exc){
+        jclass newExcCls = NULL;
+        newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+        if (newExcCls == NULL){
+            return;
+        }
+        env->ThrowNew(newExcCls,"NativeThrowNew");
+        env->ExceptionClear();
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+
+}
+}
diff --git a/test/testsuite/ouroboros/eh_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/NativeCodeCatchThrowNewExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/NativeCodeCatchThrowNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b305a95ac2de5b8c63701a88578a280073eb2a73
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/NativeCodeCatchThrowNewExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NativeCodeCatchThrowNewExceptionTest.java
+ * -@TestCaseName: Asynchronous: Native(exception at callback from Java, then check-throw new), captured by Java.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Declare a native method that throws an exception e1.
+ * -#step2: Invoke this native method.
+ * -#step3: The exception e1 is captured by C code, when e1 get, then new Exception e2 is thrown.
+ * -#step4: Check new Exception e2 is captured by java(try/catch).
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: NativeCodeCatchThrowNewExceptionTest.java jniNativeCodeCatchThrowNewExceptionTest.cpp
+ * -@ExecuteClass: NativeCodeCatchThrowNewExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+
+public class NativeCodeCatchThrowNewExceptionTest extends Exception {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+
+    private native void nativeNativeCodeCatchThrowNewExceptionTest() throws InvalidPathException;
+
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = nativeCodeCatchThrowNewExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     *  Asynchronous: Native(exception at callback from Java, then check-throw new), captured by Java.
+     * @return status code
+     */
+    public static int nativeCodeCatchThrowNewExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED */
+
+        NativeCodeCatchThrowNewExceptionTest cTest = new NativeCodeCatchThrowNewExceptionTest();
+        try {
+            cTest.nativeNativeCodeCatchThrowNewExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 3;
+            System.out.println("======>" + e1.getMessage());
+            processResult -= 10;
+        } catch (InvalidPathException e2) {
+            result1 = 3;
+            System.out.println("======>" + e2.getMessage());
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 1;
+            processResult--;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
+
+// DEPENDENCE: jniNativeCodeCatchThrowNewExceptionTest.cpp
+// EXEC:%maple  NativeCodeCatchThrowNewExceptionTest.java jniNativeCodeCatchThrowNewExceptionTest.cpp %build_option -o %n.so
+// EXEC:%run %n.so NativeCodeCatchThrowNewExceptionTest  %run_option | compare %f
+// ASSERT: scan-full ------>CheckPoint:CcanContinue\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/jniNativeCodeCatchThrowNewExceptionTest.cpp b/test/testsuite/ouroboros/eh_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/jniNativeCodeCatchThrowNewExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..30192c3742343d523c2e60e2c4f9374a5b566177
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/jniNativeCodeCatchThrowNewExceptionTest.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCodeCatchThrowNewExceptionTest_nativeNativeCodeCatchThrowNewExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jboolean chk = NULL;
+    chk = env->ExceptionCheck();
+    if (chk == NULL){
+        return;
+    }
+
+    if (chk){
+        jclass newExcCls = NULL;
+        newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+        if (newExcCls == NULL){
+            return;
+        }
+        env->ThrowNew(newExcCls,"NativeThrowNew");
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+}
diff --git a/test/testsuite/ouroboros/eh_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/NativeCheckFatalErrorExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/NativeCheckFatalErrorExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd19f69dc9bf8353122502cad81a372af1735098
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/NativeCheckFatalErrorExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NativeCheckFatalErrorExceptionTest.java
+ * -@TestCaseName: Asynchronous: Native(exception at callback from Java, then FatalError), catch by Java.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Declare a native method that throws an exception NumberFormatException.
+ * -#step2: Invoke this native method.
+ * -#step3: Use FatalError to check FatalError.
+ * -#step4: Check Exception NumberFormatException is captured by java(try/catch).
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: NativeCheckFatalErrorExceptionTest.java jniNativeCheckFatalErrorExceptionTest.cpp
+ * -@ExecuteClass: NativeCheckFatalErrorExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+
+public class NativeCheckFatalErrorExceptionTest extends Exception {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+
+    private native void nativeNativeCheckFatalErrorExceptionTest() throws InvalidPathException;
+
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = nativeCheckFatalErrorExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     *  Asynchronous: Native(exception at callback from Java, then FatalError), catch by Java.
+     * @return status code
+     */
+    public static int nativeCheckFatalErrorExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED */
+
+        NativeCheckFatalErrorExceptionTest cTest = new NativeCheckFatalErrorExceptionTest();
+        try {
+            cTest.nativeNativeCheckFatalErrorExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 1;
+            System.out.println("======>" + e1.getMessage());
+            processResult--;
+        } catch (InvalidPathException e2) {
+            result1 = 3;
+            System.out.println("======>" + e2.getMessage());
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 3;
+            processResult -= 10;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
+
+// DEPENDENCE: jniNativeCheckFatalErrorExceptionTest.cpp
+// EXEC:%maple  NativeCheckFatalErrorExceptionTest.java jniNativeCheckFatalErrorExceptionTest.cpp %build_option -o %n.so
+// EXEC:%run %n.so NativeCheckFatalErrorExceptionTest %run_option | compare %f
+// ASSERT: scan-full ------>CheckPoint:CcanContinue\n======>JavaMethodThrows\n
diff --git a/test/testsuite/ouroboros/eh_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/jniNativeCheckFatalErrorExceptionTest.cpp b/test/testsuite/ouroboros/eh_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/jniNativeCheckFatalErrorExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f642787fbb903664627ff638b74c611e95d46df7
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/jniNativeCheckFatalErrorExceptionTest.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCheckFatalErrorExceptionTest_nativeNativeCheckFatalErrorExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+    env->FatalError("------>CheckPoint:FatalError");
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+}
diff --git a/test/testsuite/ouroboros/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/TryFinallyExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/TryFinallyExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f740e781644c57d91ba2c4122bce703b731fe85
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/TryFinallyExceptionTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryFinallyExceptionTest.java
+ * -@TestCaseName: Test try-finally mode: try{exception}-finally-->caller.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-finally test static int parseInt(String s).
+ * -#step3: Check finally is test and NumberFormatException is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryFinallyExceptionTest.java
+ * -@ExecuteClass: TryFinallyExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryFinallyExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+
+        try {
+            tryFinallyExceptionTest();
+        } catch (NumberFormatException e) {
+            processResult -= 3;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try-finally mode: try{exception}-finally-->caller.
+     */
+    public static void tryFinallyExceptionTest() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } finally {
+            processResult--;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0033-rt-eh-TryCatchExceptionTest/TryCatchExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0033-rt-eh-TryCatchExceptionTest/TryCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2875caffcd6e8a614a7843734280a3ea97474a77
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0033-rt-eh-TryCatchExceptionTest/TryCatchExceptionTest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryCatchExceptionTest.java
+ * -@TestCaseName: Test try-catch mode.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#case1
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch test static int parseInt(String s).
+ * -#step3: Check NumberFormatException is thrown.
+ * -#case2
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch test static int parseInt(String s).
+ * -#step3: Check IllegalArgumentException is thrown.
+ * -#case3
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch test static int parseInt(String s).
+ * -#step3: Check RuntimeException is thrown.
+ * -#case4
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch test static int parseInt(String s).
+ * -#step3: Check Exception is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryCatchExceptionTest.java
+ * -@ExecuteClass: TryCatchExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryCatchExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+        try {
+            tryCatchExceptionTest1();
+            tryCatchExceptionTest2();
+            tryCatchExceptionTest3();
+            tryCatchExceptionTest4();
+        } catch (Exception e) {
+            processResult -= 10;
+            result = 3;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Check NumberFormatException
+     */
+    public static void tryCatchExceptionTest1() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        }
+    }
+
+    /**
+     * Check IllegalArgumentException
+     */
+    public static void tryCatchExceptionTest2() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+        }
+    }
+
+    /**
+     * Check RuntimeException
+     */
+    public static void tryCatchExceptionTest3() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (RuntimeException e) {
+            processResult--;
+        }
+    }
+
+    /**
+     * Check Exception
+     */
+    public static void tryCatchExceptionTest4() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (Exception e) {
+            processResult--;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/TryMultiCatchExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/TryMultiCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..797402cdaa53c058ed646e3300632b41f4fe1d4f
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/TryMultiCatchExceptionTest.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryMultiCatchExceptionTest.java
+ * -@TestCaseName: Test try-catch/catch/...(multi-catch) mode.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#case1
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in first
+ *          catch.
+ * -#step3: Check NumberFormatException is thrown.
+ * -#case2
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in second
+ *          catch.
+ * -#step3: Check NumberFormatException is thrown.
+ * -#case3
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in third
+ *          catch.
+ * -#step3: Check NumberFormatException is thrown.
+ * -#case4
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in fourth
+ *          catch.
+ * -#step3: Check NumberFormatException is thrown.
+ * -#case5
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in fifth
+ *          catch.
+ * -#step3: Check NumberFormatException is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryMultiCatchExceptionTest.java
+ * -@ExecuteClass: TryMultiCatchExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+
+public class TryMultiCatchExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+        try {
+            tryMultiCatchExceptionTest1();
+            tryMultiCatchExceptionTest2();
+            tryMultiCatchExceptionTest3();
+            tryMultiCatchExceptionTest4();
+            tryMultiCatchExceptionTest5();
+        } catch (Exception e) {
+            processResult -= 10;
+            result = 3;
+        }
+
+        if (result == 2 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in first catch.
+     */
+    public static void tryMultiCatchExceptionTest1() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult -= 10;
+        }
+    }
+
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in second catch.
+     */
+    public static void tryMultiCatchExceptionTest2() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult -= 10;
+        }
+    }
+
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in third catch.
+     */
+    public static void tryMultiCatchExceptionTest3() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult -= 10;
+        }
+    }
+
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in forth catch.
+     */
+    public static void tryMultiCatchExceptionTest4() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        } catch (IllegalArgumentException e) {
+            processResult -= 10;
+        }
+    }
+
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in fifth catch.
+     */
+    public static void tryMultiCatchExceptionTest5() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/TryMultiCatchMatchFirstExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/TryMultiCatchMatchFirstExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..06fce8d57236dff55052c4ca23ba4a83a823fc5d
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/TryMultiCatchMatchFirstExceptionTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryMultiCatchMatchFirstExceptionTest.java
+ * -@TestCaseName: Test try-catch/catch/...(multi-catch) mode.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in first
+ *          catch, IllegalArgumentException is in second catch, RuntimeException is in third match, Exception is in
+ *          fourth catch.
+ * -#step3: Check NumberFormatException is caught.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryMultiCatchMatchFirstExceptionTest.java
+ * -@ExecuteClass: TryMultiCatchMatchFirstExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryMultiCatchMatchFirstExceptionTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        result = tryMultiCatchMatchFirstExceptionTest1();
+        if (result != 0) {
+            return 2;
+        }
+        return result;
+    }
+
+    /**
+     * Test try-catch/catch/...(multi-catch) mode.
+     *
+     * @return status code
+     */
+    public static int tryMultiCatchMatchFirstExceptionTest1() {
+        int result1 = 2; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            result1 = 0;
+        } catch (IllegalArgumentException e) {
+            result1 = 2;
+        } catch (RuntimeException e) {
+            result1 = 2;
+        } catch (Exception e) {
+            result1 = 2;
+        }
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/TryCatchPipelineExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/TryCatchPipelineExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1c43f8284728759122a037ba55a48bb6e294f47
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/TryCatchPipelineExceptionTest.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryCatchPipelineExceptionTest.java
+ * -@TestCaseName: Test try-catch(type1 | type 2 | ...).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in first
+ *          type.
+ * -#step3: Check NumberFormatException is thrown.
+ * -#case2
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in
+ *          second type.
+ * -#step3: Check NumberFormatException is thrown.
+ * -#case3
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in third
+ *          type.
+ * -#step3: Check NumberFormatException is thrown.
+ * -#case4
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in
+ *          fourth type.
+ * -#step3: Check NumberFormatException is thrown.
+ * -#case5
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in fifth
+ *          type.
+ * -#step3: Check NumberFormatException is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryCatchPipelineExceptionTest.java
+ * -@ExecuteClass: TryCatchPipelineExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+
+public class TryCatchPipelineExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+        try {
+            tryCatchPipelineExceptionTest1();
+            tryCatchPipelineExceptionTest2();
+            tryCatchPipelineExceptionTest3();
+            tryCatchPipelineExceptionTest4();
+            tryCatchPipelineExceptionTest5();
+        } catch (Exception e) {
+            processResult -= 10;
+            result = 3;
+        }
+
+        if (result == 2 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in first type.
+     */
+    public static void tryCatchPipelineExceptionTest1() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (NumberFormatException
+                | ClassCastException
+                | InvalidPathException
+                | IllegalStateException
+                | IndexOutOfBoundsException e) {
+            processResult--;
+        }
+    }
+
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in second type.
+     */
+    public static void tryCatchPipelineExceptionTest2() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException
+                | NumberFormatException
+                | InvalidPathException
+                | IllegalStateException
+                | IndexOutOfBoundsException e) {
+            processResult--;
+        }
+    }
+
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in third type.
+     */
+    public static void tryCatchPipelineExceptionTest3() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException
+                | InvalidPathException
+                | NumberFormatException
+                | IllegalStateException
+                | IndexOutOfBoundsException e) {
+            processResult--;
+        }
+    }
+
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in fourth type.
+     */
+    public static void tryCatchPipelineExceptionTest4() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException
+                | InvalidPathException
+                | IllegalStateException
+                | NumberFormatException
+                | IndexOutOfBoundsException e) {
+            processResult--;
+        }
+    }
+
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in fifth+ type.
+     */
+    public static void tryCatchPipelineExceptionTest5() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException
+                | InvalidPathException
+                | IllegalStateException
+                | IndexOutOfBoundsException
+                | NumberFormatException e) {
+            processResult--;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/TryMultiCatchFinallyExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/TryMultiCatchFinallyExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b0671d15f3ae99551a7aca690602c5f39e3ed78
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/TryMultiCatchFinallyExceptionTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryMultiCatchFinallyExceptionTest.java
+ * -@TestCaseName: Test try-catch/catch…-finally mode.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#case1
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch/catch…-finally to test static int parseInt(String s), NumberFormatException is in catch.
+ * -#step3: Check NumberFormatException is caught, finally is traversed.
+ * -#case1
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Use try-catch/catch…-finally to test static int parseInt(String s), NumberFormatException is not in catch.
+ * -#step3: Check NumberFormatException is thrown, finally is traversed.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryMultiCatchFinallyExceptionTest.java
+ * -@ExecuteClass: TryMultiCatchFinallyExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryMultiCatchFinallyExceptionTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+
+        result = tryMultiCatchFinallyExceptionTest();
+        if (result != 0) {
+            return 2;
+        }
+
+        try {
+            result = tryMultiCatchFinallyExceptionTest2();
+        } catch (NumberFormatException e) {
+            if (result != 0) {
+                return 2;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Use try-catch/catch…-finally to test static int parseInt(String s), NumberFormatException is in catch.
+     *
+     * @return status code
+     */
+    public static int tryMultiCatchFinallyExceptionTest() {
+        int result1 = 2; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            result1--;
+        } catch (IllegalArgumentException e) {
+            result1 = 2;
+        } catch (RuntimeException e) {
+            result1 = 2;
+        } catch (Exception e) {
+            result1 = 2;
+        } finally {
+            result1--;
+        }
+        return result1;
+    }
+
+    /**
+     * Use try-catch/catch…-finally to test static int parseInt(String s), NumberFormatException is not in catch.
+     *
+     * @return status code
+     * @throws NumberFormatException
+     */
+    public static int tryMultiCatchFinallyExceptionTest2() throws NumberFormatException {
+        int result2 = 2; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (IndexOutOfBoundsException e) {
+            result2 = 2;
+        } finally {
+            result2 = 0;
+        }
+        return result2;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/TryCatchResourceExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/TryCatchResourceExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..05530cde597f0407ad42ffee6139079fa53e91b4
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/TryCatchResourceExceptionTest.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryCatchResourceExceptionTest.java
+ * -@TestCaseName: Test try with resource.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Test no Exception occur: conn.start->conn.close->finally.
+ * -#step2: Test Exception in try: conn.start->conn.close->catch(catch e in try, ignore e in close)->finally.
+ * -#step3: Test Exception in try: conn.start->conn.close->catch(catch e in start, ignore e in try & close)->finally.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryCatchResourceExceptionTest.java
+ * -@ExecuteClass: TryCatchResourceExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryCatchResourceExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 4; /* STATUS_FAILED */
+
+        try {
+            // No Exception occur: conn.start->conn.close->finally.
+            result = result - tryCatchResourceExceptionTest1();
+            // Exception in try: conn.start->conn.close->catch(catch e in try,ignore e in close)->finally.
+            result = result - tryCatchResourceExceptionTest2();
+            // Exception in try: conn.start->conn.close->catch(catch e in start,ignore e in try & close)->finally.
+            result = result - tryCatchResourceExceptionTest3();
+        } catch (Exception e) {
+            processResult += 10;
+        }
+        if (result == 1 && processResult == 90) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * No Exception occur: conn.start->conn.close->finally.
+     *
+     * @return status code
+     */
+    public static int tryCatchResourceExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        try (MyResourceA conn = new MyResourceA()) {
+            conn.start();
+            result1 = 1;
+            processResult--;
+        } catch (Exception e) {
+            System.out.println("catch ......");
+            processResult -= 10;
+            result1++;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+
+    /**
+     * Exception in try: conn.start->conn.close->catch(catch e in try,ignore e in close)->finally.
+     *
+     * @return status code
+     */
+    public static int tryCatchResourceExceptionTest2() {
+        int result1 = 4; /* STATUS_FAILED */
+        try (MyResourceB conn = new MyResourceB()) {
+            conn.start();
+            int num = 1 / (result1 - 4);
+            processResult -= 10;
+        } catch (Exception e) {
+            processResult--;
+            result1 = 1;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+
+    /**
+     * Exception in try: conn.start->conn.close->catch(catch e in start,ignore e in try & close)->finally.
+     *
+     * @return status code
+     */
+    public static int tryCatchResourceExceptionTest3() {
+        int result1 = 4; /* STATUS_FAILED */
+        try (MyResourceC conn = new MyResourceC()) {
+            conn.start();
+            int num = 1 / (result1 - 4);
+            processResult -= 10;
+        } catch (Exception e) {
+            processResult--;
+            result1 = 1;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+
+    public static class MyResourceA implements AutoCloseable {
+        /**
+         * start fun
+         */
+        public void start() {
+            processResult = processResult * 2;
+        }
+
+        @Override
+        public void close() {
+            processResult = processResult / 2;
+        }
+    }
+
+    public static class MyResourceB implements AutoCloseable {
+        /**
+         * start fun
+         */
+        public void start() {
+            processResult = processResult * 2;
+        }
+
+        @Override
+        public void close() throws Exception {
+            processResult = processResult / 2;
+            throw new NoSuchFieldException("ee");
+        }
+    }
+
+    public static class MyResourceC implements AutoCloseable {
+        /**
+         * start fun
+         */
+        public void start() throws Exception {
+            processResult = processResult * 2;
+            throw new NoSuchMethodException("mm");
+        }
+
+        @Override
+        public void close() throws Exception {
+            processResult = processResult / 2;
+            throw new NoSuchFieldException("ee");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/TryCatchThrowExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/TryCatchThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f31d2237e5f6f294e957e1a076c50f8ba225feea
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/TryCatchThrowExceptionTest.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryCatchThrowExceptionTest.java
+ * -@TestCaseName: Test throws and throw in try-catch.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#case1
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s).
+ * -#step3: NumberFormatException is caught by catch, throw NumberFormatException correctly in catch.
+ * -#case2
+ * -#step1: Create a new Exception extends from Exception.
+ * -#step2: Throw the new Exception in method correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryCatchThrowExceptionTest.java
+ * -@ExecuteClass: TryCatchThrowExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryCatchThrowExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryCatchThrowExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult--;
+        }
+
+        if (processResult == 97) {
+            result--;
+        }
+
+        try {
+            tryCatchThrowExceptionTest3();
+        } catch (Exception3 e) {
+            processResult--;
+        }
+        if (processResult == 95) {
+            result--;
+        }
+        return result;
+    }
+
+    /**
+     * Test static int parseInt(String s), NumberFormatException is caught by catch
+     *
+     * @return status code
+     * @throws NumberFormatException
+     */
+    public static int tryCatchThrowExceptionTest1() throws NumberFormatException {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            processResult--;
+            throw e;
+        }
+        processResult -= 10; // Compiled successfully, but cannot execute.
+        return result1;
+    }
+
+    /**
+     * Create a new Exception extends from Exception.
+     *
+     * @return status code
+     * @throws Exception3
+     */
+    public static int tryCatchThrowExceptionTest3() throws Exception3 {
+        int result3 = 3; /* STATUS_FAILED */
+        if (result3 != 4) {
+            processResult--;
+            throw new Exception3();
+        }
+        processResult -= 10; // Compiled successfully, but cannot execute.
+        return result3;
+    }
+
+    static class Exception3 extends Exception {
+        Exception3() {
+            super("yes");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/TryExceptionFinallyExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/TryExceptionFinallyExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2081b30bf110690f0baebcb3bea81fb39ced644
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/TryExceptionFinallyExceptionTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryExceptionFinallyExceptionTest.java
+ * -@TestCaseName: Test try{exception}-finally：handler is caller.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-finally.
+ * -#step3: Check NumberFormatException is thrown in outside try-finally, finally is walked.
+ * -#step4: Check NumberFormatException is thrown, outside finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryExceptionFinallyExceptionTest.java
+ * -@ExecuteClass: TryExceptionFinallyExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryExceptionFinallyExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryExceptionFinallyExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 2;
+        }
+
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try{exception}-finally：handler is caller.
+     *
+     * @return status code
+     */
+    public static int tryExceptionFinallyExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } finally {
+                processResult--;
+            }
+            processResult -= 10;
+        } finally {
+            processResult--;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/TryTryThrowExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/TryTryThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e6c708b32381c7f019eb9d12c20b651f10e3dac
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/TryTryThrowExceptionTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryTryThrowExceptionTest.java
+ * -@TestCaseName: Test try{exception}-catch（x）-finally：handler is caller.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-finally.
+ * -#step3: Check NumberFormatException is thrown in outside try-Multi catch-finally, finally is walked.
+ * -#step4: Check NumberFormatException is thrown, outside finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryTryThrowExceptionTest.java
+ * -@ExecuteClass: TryTryThrowExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryTryThrowExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryTryThrowExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 2;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try{exception}-catch（x）-finally：handler is caller.
+     *
+     * @return status code
+     */
+    public static int tryTryThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } finally {
+                processResult--;
+            }
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/TryTryCatchExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/TryTryCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea07cb12b8cb6a296632c4ad78923cca441dd936
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/TryTryCatchExceptionTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryTryCatchExceptionTest.java
+ * -@TestCaseName: Test try{exception}-catch（e）-finally.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-finally.
+ * -#step3: Check NumberFormatException is thrown in outside try-Multi catch-finally, finally is walked.
+ * -#step4: Check NumberFormatException is caught by outside catch, outside finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryTryCatchExceptionTest.java
+ * -@ExecuteClass: TryTryCatchExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryTryCatchExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryTryCatchExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try{exception}-catch（e）-finally.
+     *
+     * @return status code
+     */
+    public static int tryTryCatchExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } finally {
+                processResult--;
+            }
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+            result1 = 1;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/TryCatchTryExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/TryCatchTryExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d4346e31c0457c4daf4d26548071e313f7d5f65
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/TryCatchTryExceptionTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryCatchTryExceptionTest.java
+ * -@TestCaseName: Test try{try{exception} catch(e)}-catch-finally.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-finally.
+ * -#step3: Check NumberFormatException is caught by inside catch.
+ * -#step4: Check outside catch is not used, outside finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryCatchTryExceptionTest.java
+ * -@ExecuteClass: TryCatchTryExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryCatchTryExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryCatchTryExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try{try{exception} catch(e)}-catch-finally.
+     *
+     * @return status code
+     */
+    public static int tryCatchTryExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (NumberFormatException e) {
+                result1 = 1;
+                processResult--;
+            }
+            processResult--;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            System.out.println("=====See:ERROR!!!");
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/DoubleTryCatchFinallyExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/DoubleTryCatchFinallyExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba7eae94504018aff146f26eb90e09c4790589f0
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/DoubleTryCatchFinallyExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: DoubleTryCatchFinallyExceptionTest.java
+ * -@TestCaseName: Test try{try{exception} catch(x)}-finally -->caller.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-finally.
+ * -#step3: Check NumberFormatException is thrown in outside try-Multi catch-finally, finally is walked.
+ * -#step4: Check NumberFormatException is thrown, outside finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: DoubleTryCatchFinallyExceptionTest.java
+ * -@ExecuteClass: DoubleTryCatchFinallyExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class DoubleTryCatchFinallyExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = doubleTryCatchFinallyExceptionTest1();
+        } catch (IllegalArgumentException e) {
+            processResult -= 2;
+        }
+
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try{try{exception} catch(x)}-finally -->caller.
+     *
+     * @return status code
+     */
+    public static int doubleTryCatchFinallyExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (ClassCastException e) {
+                result1 = 3;
+                processResult -= 10;
+            } finally {
+                processResult--;
+            }
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/TryCatchTryCatchFinallyExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/TryCatchTryCatchFinallyExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6cc6741dc8667698e0b12a1e3fbf3704b4c88d1f
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/TryCatchTryCatchFinallyExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryCatchTryCatchFinallyExceptionTest.java
+ * -@TestCaseName: Test try{try{exception} catch(x)}-catch()-finally --> caller.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-catch.
+ * -#step3: Check NumberFormatException is thrown in outside try-Multi catch-finally.
+ * -#step4: Check NumberFormatException is thrown, outside finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryCatchTryCatchFinallyExceptionTest.java
+ * -@ExecuteClass: TryCatchTryCatchFinallyExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.FormatterClosedException;
+
+public class TryCatchTryCatchFinallyExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryCatchTryCatchFinallyExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult--;
+        }
+
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try{try{exception} catch(x)}-catch()-finally --> caller.
+     *
+     * @return status code
+     */
+    public static int tryCatchTryCatchFinallyExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (IllegalStateException e113) {
+                System.out.println("=====See:ERROR!!!");
+                processResult -= 10;
+            }
+            processResult -= 10;
+        } catch (FormatterClosedException e1132) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 3;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/TryCatchTryCatchExceptionFinallyTest.java b/test/testsuite/ouroboros/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/TryCatchTryCatchExceptionFinallyTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef587afc9c288e330a17b5eeb9e84ce6486358e5
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/TryCatchTryCatchExceptionFinallyTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryCatchTryCatchExceptionFinallyTest.java
+ * -@TestCaseName: Test try{try{exception} catch(x)}-catch(e)-finally.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-catch.
+ * -#step3: Check NumberFormatException is thrown in outside try-Multi catch-finally.
+ * -#step4: Check NumberFormatException is caught by catch, outside finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryCatchTryCatchExceptionFinallyTest.java
+ * -@ExecuteClass: TryCatchTryCatchExceptionFinallyTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.FormatterClosedException;
+
+public class TryCatchTryCatchExceptionFinallyTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryCatchTryCatchExceptionFinallyTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try{try{exception} catch(x)}-catch(e)-finally.
+     *
+     * @return status code
+     */
+    public static int tryCatchTryCatchExceptionFinallyTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (IllegalStateException e113) {
+                System.out.println("=====See:ERROR!!!");
+                processResult -= 10;
+            }
+            processResult -= 10;
+        } catch (FormatterClosedException e1132) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IllegalArgumentException e111) {
+            result1 = 1;
+        } catch (IndexOutOfBoundsException e112) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 1;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/CatchThrowNewExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/CatchThrowNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..44b977f201d6018bfed510d80334d3ef50f729ec
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/CatchThrowNewExceptionTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CatchThrowNewExceptionTest.java
+ * -@TestCaseName: Test catch(){exception}, handler is caller.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-catch.
+ * -#step3: Check NumberFormatException is caught by catch.
+ * -#step4: Create parameter beginIndex < 0, test method String substring(int beginIndex) in catch.
+ * -#step5: Check StringIndexOutOfBoundsException is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: CatchThrowNewExceptionTest.java
+ * -@ExecuteClass: CatchThrowNewExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class CatchThrowNewExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = catchThrowNewExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            if (result == 2 && processResult == 95) {
+                return 0;
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Test catch(){exception}, handler is caller.
+     *
+     * @return status code
+     */
+    public static int catchThrowNewExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            processResult -= 2;
+            System.out.println(str.substring(-5));
+            System.out.println("=====See:ERROR!!!");
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 2;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/CatchTryCatchNewExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/CatchTryCatchNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ccecce91edbcc32adcd8eb3afde16f0efa9f5e80
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/CatchTryCatchNewExceptionTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CatchTryCatchNewExceptionTest.java
+ * -@TestCaseName: Test try-catch(){try{exception},catch(e)}-finally.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-catch.
+ * -#step3: Check NumberFormatException is caught by catch.
+ * -#step4: Create parameter beginIndex < 0, test method String substring(int beginIndex) in new try-catch in old catch.
+ * -#step5: Check StringIndexOutOfBoundsException is caught by new catch.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: CatchTryCatchNewExceptionTest.java
+ * -@ExecuteClass: CatchTryCatchNewExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class CatchTryCatchNewExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = catchTryCatchNewExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try-catch(){try{exception},catch(e)}-finally.
+     *
+     * @return status code
+     */
+    public static int catchTryCatchNewExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            try {
+                System.out.println(str.substring(-5));
+            } catch (StringIndexOutOfBoundsException e2) {
+                processResult--;
+            }
+            result1 = 1;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+        }
+        processResult -= 2;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/CatchTryThrowNewExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/CatchTryThrowNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2387779bde5426971c694d7092fc7b4a29d2c422
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/CatchTryThrowNewExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CatchTryThrowNewExceptionTest.java
+ * -@TestCaseName: Test try-catch(){try{exception},catch(x)}-finally --> caller.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-catch.
+ * -#step3: Check NumberFormatException is caught by catch.
+ * -#step4: Create parameter beginIndex < 0, test method String substring(int beginIndex) in new try-catch in old catch.
+ * -#step5: Check StringIndexOutOfBoundsException is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: CatchTryThrowNewExceptionTest.java
+ * -@ExecuteClass: CatchTryThrowNewExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class CatchTryThrowNewExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = catchTryThrowNewExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult--;
+        }
+
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try-catch(){try{exception},catch(x)}-finally --> caller.
+     *
+     * @return status code
+     */
+    public static int catchTryThrowNewExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            result1 = 1;
+            try {
+                System.out.println(str.substring(-5));
+            } catch (NumberFormatException e2) {
+                processResult -= 10;
+            }
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 3;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/FinallyThrowExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/FinallyThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b3d818eb599d236b113ad979b5d5f1111abc7b8
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/FinallyThrowExceptionTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FinallyThrowExceptionTest.java
+ * -@TestCaseName: Test finally{exception}, handler is caller.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-catch.
+ * -#step3: Check NumberFormatException is caught by catch.
+ * -#step4: Create parameter beginIndex < 0, test method String substring(int beginIndex) in finally.
+ * -#step5: Check StringIndexOutOfBoundsException is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FinallyThrowExceptionTest.java
+ * -@ExecuteClass: FinallyThrowExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class FinallyThrowExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = finallyThrowExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            if (result == 2 && processResult == 95) {
+                return 0;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Test finally{exception}, handler is caller.
+     *
+     * @return status code
+     */
+    public static int finallyThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            result1 = 1;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 4;
+            System.out.println(str.substring(-5));
+            System.out.println("=====See:ERROR!!!");
+            processResult -= 10;
+        }
+        System.out.println("=====See:ERROR!!!");
+        processResult -= 10;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/FinallyTryCatchExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/FinallyTryCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0611ef071eb3908497921d67ec09ba0a3a7eb59
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/FinallyTryCatchExceptionTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FinallyTryCatchExceptionTest.java
+ * -@TestCaseName: Test try-catch-finally{try{exception},catch(e)}.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-catch.
+ * -#step3: Check NumberFormatException is caught by catch.
+ * -#step4: Create parameter beginIndex < 0, test method String substring(int beginIndex) in finally.
+ * -#step5: Check StringIndexOutOfBoundsException is caught by inside try-catch.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FinallyTryCatchExceptionTest.java
+ * -@ExecuteClass: FinallyTryCatchExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class FinallyTryCatchExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = finallyTryCatchExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try-catch-finally{try{exception},catch(e)}.
+     *
+     * @return status code
+     */
+    public static int finallyTryCatchExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            result1 = 1;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+            try {
+                System.out.println(str.substring(-5));
+            } catch (StringIndexOutOfBoundsException e) {
+                processResult--;
+            }
+        }
+        processResult -= 2;
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/FinallyTryThrowExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/FinallyTryThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..299013dce57f97124f1ca5a1bcdacb4432e09de4
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/FinallyTryThrowExceptionTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FinallyTryThrowExceptionTest.java
+ * -@TestCaseName: Test try-catch-finally{try{exception},catch(x)}--> caller.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s) in try-catch.
+ * -#step3: Check NumberFormatException is caught by catch.
+ * -#step4: Create parameter beginIndex < 0, test method String substring(int beginIndex) in finally.
+ * -#step5: Check StringIndexOutOfBoundsException is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FinallyTryThrowExceptionTest.java
+ * -@ExecuteClass: FinallyTryThrowExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class FinallyTryThrowExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = finallyTryThrowExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 3;
+        }
+
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try-catch-finally{try{exception},catch(x)}--> caller.
+     *
+     * @return status code
+     */
+    public static int finallyTryThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            result1 = 1;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+            try {
+                System.out.println(str.substring(-5));
+            } catch (NumberFormatException e) {
+                processResult -= 10;
+            }
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/TryResourceStartThrowExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/TryResourceStartThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a7627046cbed15855321e1f83d97ce5d8faa2f6
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/TryResourceStartThrowExceptionTest.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryResourceStartThrowExceptionTest.java
+ * -@TestCaseName: Test try(exception){}-catch(e){}-close()-finally.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create self class by implements AutoCloseable.
+ * -#step2: Create resource instance by new self class.
+ * -#step3: Test start() method.
+ * -#step4: Check NumberFormatException is thrown and finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryResourceStartThrowExceptionTest.java
+ * -@ExecuteClass: TryResourceStartThrowExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryResourceStartThrowExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryResourceStartThrowExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static class MyResource implements AutoCloseable {
+        /**
+         * start fun
+         *
+         * @throws NumberFormatException
+         */
+        public void start() throws NumberFormatException {
+            processResult--;
+            throw new NumberFormatException("start:exception!!!");
+        }
+
+        @Override
+        public void close() throws StringIndexOutOfBoundsException {
+            processResult--;
+        }
+    }
+
+    /**
+     * Test try(exception){}-catch(e){}-close()-finally.
+     *
+     * @return status code
+     */
+    public static int tryResourceStartThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        try (MyResource conn = new MyResource()) {
+            conn.start();
+        } catch (NumberFormatException e) {
+            processResult--;
+            result1 = 1;
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+            result1 = 3;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/TryResourceCloseThrowExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/TryResourceCloseThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..264221ce45f2d3a1b38b35ef2b65d2b0177684f4
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/TryResourceCloseThrowExceptionTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryResourceCloseThrowExceptionTest.java
+ * -@TestCaseName: Test try(){}-catch(e){}-close(exception)-finally.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create self class by implements AutoCloseable.
+ * -#step2: Create resource instance by new self class.
+ * -#step3: Test start() method and close() method.
+ * -#step4: Check StringIndexOutOfBoundsException is thrown and finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryResourceCloseThrowExceptionTest.java
+ * -@ExecuteClass: TryResourceCloseThrowExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryResourceCloseThrowExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryResourceCloseThrowExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static class MyResource implements AutoCloseable {
+        /**
+         * start fun
+         *
+         * @throws NumberFormatException
+         */
+        public void start() throws NumberFormatException {
+            processResult--;
+        }
+
+        @Override
+        public void close() throws StringIndexOutOfBoundsException {
+            processResult--;
+            throw new StringIndexOutOfBoundsException("end:exception!!!");
+        }
+    }
+
+    /**
+     * Test try(){}-catch(e){}-close(exception)-finally.
+     *
+     * @return status code
+     */
+    public static int tryResourceCloseThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        try (MyResource conn = new MyResource()) {
+            conn.start();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+            e.printStackTrace();
+            result1 = 3;
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult--;
+            result1 = 1;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/TryResourceStartAndCloseExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/TryResourceStartAndCloseExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..60622fdc3bba0211ccabb5ea75db7316fb83e0d3
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/TryResourceStartAndCloseExceptionTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryResourceStartAndCloseExceptionTest.java
+ * -@TestCaseName: Test try(exception1){}-catch(e1){}-close(exception2)-finally.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create self class by implements AutoCloseable.
+ * -#step2: Create resource instance by new self class.
+ * -#step3: Test start() method and close() method.
+ * -#step4: Check NumberFormatException is thrown and finally is walked.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryResourceStartAndCloseExceptionTest.java
+ * -@ExecuteClass: TryResourceStartAndCloseExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryResourceStartAndCloseExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryResourceStartAndCloseExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static class MyResource implements AutoCloseable {
+        /**
+         * start fun
+         *
+         * @throws NumberFormatException
+         */
+        public void start() throws NumberFormatException {
+            processResult--;
+            throw new NumberFormatException("start:exception!!!");
+        }
+
+        @Override
+        public void close() throws StringIndexOutOfBoundsException {
+            processResult--;
+            throw new StringIndexOutOfBoundsException("end:exception!!!");
+        }
+    }
+
+    /**
+     * Test try(exception1){}-catch(e1){}-close(exception2)-finally.
+     *
+     * @return status code
+     */
+    public static int tryResourceStartAndCloseExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        try (MyResource conn = new MyResource()) {
+            conn.start();
+        } catch (NumberFormatException e) {
+            processResult--;
+            result1 = 1;
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+            result1 = 3;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/JvmArrayIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/JvmArrayIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..951675b74d49a7ff3f0cc8ab207504f8fef4426f
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/JvmArrayIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: JvmArrayIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test jvm instr: Invoke Initialization thrown ArrayIndexOutOfBoundsException.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a object array instance objs.
+ * -#step2: Get a object instance by the num element of objs, num is objs.length.
+ * -#step3: Check ArrayIndexOutOfBoundsException is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: JvmArrayIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: JvmArrayIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class JvmArrayIndexOutOfBoundsExceptionTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    static final int len = 10;
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        Object[] objs = new Object[len];
+        try {
+            Object obj1 = objs[len];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            return 0; // STATUS_PASSED
+        }
+        return 2; // STATUS_FAILED
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/JvmStaticExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/JvmStaticExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..22fac3fa94720e3e7167c1063bf66c7c14998452
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/JvmStaticExceptionInInitializerErrorTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: JvmStaticExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Test jvm instr: invoke static thrown ExceptionInInitializerError.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a static variable that initialize will be fault of a class.
+ * -#step2: Test static method of the class.
+ * -#step3: Check ExceptionInInitializerError is caught by catch.
+ * -#step4: Try test static method of the class.
+ * -#step5: Check NoClassDefFoundError is caught by catch.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: JvmStaticExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: JvmStaticExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+class JvmStaticExceptionInInitializerErrorTesta {
+    static int other_class_test_field = 21;
+    static int local_field = 5 / 0;
+
+    static int testFail() {
+        int aNum = 1;
+        return aNum;
+    }
+}
+
+public class JvmStaticExceptionInInitializerErrorTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        try {
+            int tmp = JvmStaticExceptionInInitializerErrorTesta.testFail();
+        } catch (ExceptionInInitializerError e1) {
+            try {
+                int tmp = JvmStaticExceptionInInitializerErrorTesta.testFail();
+            } catch (NoClassDefFoundError e2) {
+                return 0; // STATUS_PASSED
+            }
+        }
+        return 2; // STATUS_FAILED
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/MultiTryNoExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/MultiTryNoExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9adf08485a9855bc58ff892813476ece5981d740
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/MultiTryNoExceptionTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MultiTryNoExceptionTest.java
+ * -@TestCaseName: Test no Exception in try-multi catch-finally.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number in double try-multi catch-finally.
+ * -#step2: Test static int parseInt(String s) in double try-multi catch-finally.
+ * -#step3: Check method is invoke correctly, no Exception is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: MultiTryNoExceptionTest.java
+ * -@ExecuteClass: MultiTryNoExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class MultiTryNoExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = multiTryNoExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test no Exception in try-multi catch-finally.
+     *
+     * @return status code
+     */
+    public static int multiTryNoExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (ClassCastException e) {
+                result1 = 3;
+            } catch (IllegalStateException e) {
+                result1 = 3;
+            } catch (IndexOutOfBoundsException e) {
+                result1 = 3;
+            } finally {
+                processResult--;
+            }
+            processResult--;
+        } catch (ClassCastException e) {
+            result1 = 3;
+        } catch (IllegalStateException e) {
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            result1 = 3;
+        } finally {
+            processResult--;
+            result1 = 1;
+        }
+        processResult--;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/TryCatchReturnExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/TryCatchReturnExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..073b1f60fc7603668a0e356cabf7a7cd5f91b6a3
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/TryCatchReturnExceptionTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryCatchReturnExceptionTest.java
+ * -@TestCaseName: Test try{exception return_x}-catch（e){return_x}-finally{return_v}.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s).
+ * -#step3: Check NumberFormatException is caught by catch.
+ * -#step4: Return value in the catch.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryCatchReturnExceptionTest.java
+ * -@ExecuteClass: TryCatchReturnExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryCatchReturnExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryCatchReturnExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Test try{exception return_x}-catch（e){return_x}-finally{return_v}.
+     *
+     * @return status code
+     */
+    public static int tryCatchReturnExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            processResult -= 1;
+            result1 = 1;
+            return result1;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 3;
+            result1++;
+            return result1; // Execute return 2
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/TryReturnValueExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/TryReturnValueExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0552c56e57240a31841b84d1a089e383d92aa1dd
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/TryReturnValueExceptionTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryReturnValueExceptionTest.java
+ * -@TestCaseName: try{return_v}-catch（x){return_x}-finally{return_x}
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number.
+ * -#step2: Test static int parseInt(String s).
+ * -#step3: Return value in try, no exception is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryReturnValueExceptionTest.java
+ * -@ExecuteClass: TryReturnValueExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryReturnValueExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryReturnValueExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+
+        if (result == 5 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * try{return_v}-catch（x){return_x}-finally{return_x}
+     *
+     * @return status code
+     */
+    public static int tryReturnValueExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123456";
+        try {
+            Integer.parseInt(str);
+            return result1; // Execute return result1++.
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return 3;
+        } catch (NumberFormatException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return 3;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return 3;
+        } finally {
+            processResult -= 4;
+            result1++;
+            return result1;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/TryCatchReturnValueExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/TryCatchReturnValueExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0b0aaa257e68f64bc1c4115fb29bdac7e8f077b
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/TryCatchReturnValueExceptionTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TryCatchReturnValueExceptionTest.java
+ * -@TestCaseName: Try{exception return_x}-catch（e){return_v}-finally{}.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a String s include number and special symbol.
+ * -#step2: Test static int parseInt(String s).
+ * -#step3: NumberFormatException is caught by catch, return value in catch.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: TryCatchReturnValueExceptionTest.java
+ * -@ExecuteClass: TryCatchReturnValueExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class TryCatchReturnValueExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = tryCatchReturnValueExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Try{exception return_x}-catch（e){return_v}-finally{}.
+     *
+     * @return status code
+     */
+    public static int tryCatchReturnValueExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            processResult--;
+            result1 = 1;
+            return result1; // Execute return 1.
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 3;
+            result1++;
+        }
+        processResult -= 10;
+        return processResult;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0077-rt-eh-ExcpReturn04140/ExcpReturn04140.java b/test/testsuite/ouroboros/eh_test/RT0077-rt-eh-ExcpReturn04140/ExcpReturn04140.java
new file mode 100644
index 0000000000000000000000000000000000000000..52fa1b803a1384babf56d0d9b448891027bae399
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0077-rt-eh-ExcpReturn04140/ExcpReturn04140.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ExcpReturn04140.java
+ * -@TestCaseName: try{exception return_x}-catch（e){}-finally{},return_v
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:occur exception in try{}
+ * -#step2:catch by catch{}
+ * -#step3:excute finally{}
+ * -#step4:excute return{}
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ExcpReturn04140.java
+ * -@ExecuteClass: ExcpReturn04140
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ExcpReturn04140 {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = excpReturn041401();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * try{exception return_x}-catch（e){}-finally{},return_v
+     *
+     * @return status code
+     */
+    public static int excpReturn041401() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            processResult--;
+            result1 = 1;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+            result1++;
+        }
+        processResult -= 2;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0078-rt-eh-ExcpReturn04150/ExcpReturn04150.java b/test/testsuite/ouroboros/eh_test/RT0078-rt-eh-ExcpReturn04150/ExcpReturn04150.java
new file mode 100644
index 0000000000000000000000000000000000000000..c45aa0faade7d4eec484b8e68f5feaf86e55fd16
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0078-rt-eh-ExcpReturn04150/ExcpReturn04150.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ExcpReturn04150.java
+ * -@TestCaseName: try{exception return_x}-catch（x){}-finally{return_v},-->caller(x)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:occur EH it try{} when return
+ * -#step2:no catch in catch{}
+ * -#step3:excute finally{}
+ * -#step4:catch by caller
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ExcpReturn04150.java
+ * -@ExecuteClass: ExcpReturn04150
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ExcpReturn04150 {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = excpReturn04150();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 5 && processResult == 95) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * try{exception return_x}-catch（x){}-finally{return_v},-->caller(x)
+     *
+     * @return status code
+     */
+    public static int excpReturn04150() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } catch (StringIndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } finally {
+            processResult -= 4;
+            result1++;
+            return result1; // execute return 5
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0079-rt-eh-ExcpReturn04160/ExcpReturn04160.java b/test/testsuite/ouroboros/eh_test/RT0079-rt-eh-ExcpReturn04160/ExcpReturn04160.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a5c599ab40e31db4ffe417e5bae2fa33756b439
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0079-rt-eh-ExcpReturn04160/ExcpReturn04160.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ExcpReturn04160.java
+ * -@TestCaseName: try{exception return_x}-catch（x){}-finally{},return_x-->caller(v)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:occur exception in try{} when retrun
+ * -#step2:cannot catch by catch{}
+ * -#step3:excute finally{}
+ * -#step4:cannot excute return{}
+ * -#step5:catch by caller
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ExcpReturn04160.java
+ * -@ExecuteClass: ExcpReturn04160
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ExcpReturn04160 {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = excpReturn04160();
+        } catch (Exception e) {
+            processResult -= 2;
+        }
+
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * try{exception return_x}-catch（x){}-finally{},return_x-->caller(v)
+     *
+     * @return status code
+     */
+    public static int excpReturn04160() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (StringIndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } finally {
+            processResult -= 2;
+            result1++;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a7cabd2693522ca1aac791e80df0a0bad217993b
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest.java
+ * -@TestCaseName: Exception in addSuppressed:public T[] getAnnotationsByType(Class<T> annotationClass).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Get AccessibleObject object by getMethod(String name,Class<?>... parameterTypes).
+ * -#step2: Test method getAnnotationsByType(), parameter annotationClass is null.
+ * -#step3: Check that if NullPointerException occurs.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest.java
+ * -@ExecuteClass: AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = accessibleObjectgAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in addSuppressed:public T[] getAnnotationsByType(Class<T> annotationClass).
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int accessibleObjectgAnnotationsByTypeNullPointerException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        AccessibleObject accessibleObject = Test013.class.getMethod("getName", new Class[]{});
+        try {
+            Object file1 = accessibleObject.getAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class Test013 {
+    private String name = "default";
+
+    public String getName() {
+        return name;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/AccessibleObjectGetDeclaredAnnotationExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/AccessibleObjectGetDeclaredAnnotationExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..51d99fb0d5f8bf357ac3de4d1c169e7ce620e76d
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/AccessibleObjectGetDeclaredAnnotationExceptionTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectGetDeclaredAnnotationExceptionTest.java
+ * -@TestCaseName: Exception in AccessibleObject: T getDeclaredAnnotation(Class<T> annotationClass).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Get AccessibleObject by getMethod(String name,Class<?>... parameterTypes).
+ * -#step2: Test method getDeclaredAnnotation(Class<T> annotationClass), Create parameter annotationClass is null.
+ * -#step3: Check that if NullPointerException occurs.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectGetDeclaredAnnotationExceptionTest.java
+ * -@ExecuteClass: AccessibleObjectGetDeclaredAnnotationExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectGetDeclaredAnnotationExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = accessibleObjectgDeclaredAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in AccessibleObject: T getDeclaredAnnotation(Class<T> annotationClass).
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int accessibleObjectgDeclaredAnnotationNullPointerException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /* STATUS_FAILED */
+        AccessibleObject accessibleObject = Test02aa.class.getMethod("getName", new Class[]{});
+        try {
+            Object file1 = accessibleObject.getDeclaredAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class Test02aa {
+    private String name = "default";
+
+    public String getName() {
+        return name;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..39e75eb37254454bfd4ccdfb0efefdce266448c5
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest.java
+ * -@TestCaseName: Exception in AccessibleObject:public T[] getAnnotationsByType(Class<T> annotationClass).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Get AccessibleObject object by getMethod(String name,Class<?>... parameterTypes).
+ * -#step2: Test method getAnnotationsByType(Class<T> annotationClass), create parameter annotationClass is null.
+ * -#step3: Check that NullPointerException thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest.java
+ * -@ExecuteClass: AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = accessibleObjectgDeclaredAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in AccessibleObject:public T[] getAnnotationsByType(Class<T> annotationClass).
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int accessibleObjectgDeclaredAnnotationsByTypeNullPointerException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        AccessibleObject mt = Test01a.class.getMethod("getName", new Class[]{});
+
+        try {
+            Object file1 = mt.getDeclaredAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
+
+class Test01a {
+    private String name = "default";
+
+    public String getName() {
+        return name;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/CharacterCodePointCountIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/CharacterCodePointCountIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5387cdf1375f2c9f6e6414b007a70a7db3f9d02f
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/CharacterCodePointCountIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterCodePointCountIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Exception in Character: public static int codePointCount(char[] seq, int offset, int count),
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * case1:
+ * -#step1: Create char[] seq, create offset >=0, count > seq.length.
+ * -#step2: Test method codePointCount(char[] seq, int offset, int count).
+ * -#step3: Check that IndexOutOfBoundsException thrown correctly.
+ * case2:
+ * -#step1: Define CharSequence seq, create offset >=0, count > seq.length.
+ * -#step2: Test method codePointCount(CharSequence seq, int beginIndex, int endIndex).
+ * -#step3: Check that IndexOutOfBoundsException thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: CharacterCodePointCountIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: CharacterCodePointCountIndexOutOfBoundsExceptionTest
+ */
+
+import java.io.PrintStream;
+
+public class CharacterCodePointCountIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = charactercodePointCountIndexOutOfBoundsException1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        try {
+            result = charactercodePointCountIndexOutOfBoundsException2();
+        } catch (Exception e) {
+            processResult -= 40;
+        }
+
+        if (result == 4 && processResult == 97) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Test method codePointCount(char[] seq, int offset, int count).
+     *
+     * @return status code
+     */
+    public static int charactercodePointCountIndexOutOfBoundsException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        char[] chars = new char[]{'a', 'b', 'c', 'd', 'e'};
+        int offset = 1;
+        int count = 10;
+        try {
+            int obj = Character.codePointCount(chars, offset, count);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult -= 1;
+        }
+
+        return result1;
+    }
+
+    /**
+     * Test method codePointCount(CharSequence seq, int beginIndex, int endIndex).
+     *
+     * @return status code
+     */
+    public static int charactercodePointCountIndexOutOfBoundsException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        CharSequence seq = "a b c d e";
+        int offset = 1;
+        int count = 10;
+        try {
+            int obj = Character.codePointCount(seq, offset, count);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/CharactercodePointCountNullPointerException.java b/test/testsuite/ouroboros/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/CharactercodePointCountNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef9d9ebd1040c042032240e1c250095e7d5dff5e
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/CharactercodePointCountNullPointerException.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharactercodePointCountNullPointerException.java
+ * -@TestCaseName: Exception in Character:public static int codePointCount
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:codePointCount(CharSequence seq, int beginIndex, int endIndex),seq is null
+ * -#step2:catch Exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharactercodePointCountNullPointerException.java
+ * -@ExecuteClass: CharactercodePointCountNullPointerException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class CharactercodePointCountNullPointerException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = charactercodePointCountNullPointerException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        try {
+            result = charactercodePointCountNullPointerException2();
+        } catch (Exception e) {
+            processResult -= 40;
+        }
+
+        if (result == 4 && processResult == 97) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * codePointCount(char[] a, int offset, int count),a is null,catch NullPointerException
+     *
+     * @return status code
+     */
+    public static int charactercodePointCountNullPointerException() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NullPointerException - if seq is null.
+        //
+        // public static int codePointCount(char[] a, int offset, int count)
+        int offset = 1;
+        int count = 4;
+        char[] chars = null;
+        try {
+            int obj = Character.codePointCount(chars, offset, count);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+
+    /**
+     * codePointCount(CharSequence seq, int beginIndex, int endIndex), seq is null,catch NullPointerException
+     *
+     * @return status code
+     */
+    public static int charactercodePointCountNullPointerException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NullPointerException - if seq is null.
+        //
+        // public static int codePointCount(CharSequence seq, int beginIndex, int endIndex)
+        int offset = 1;
+        int count = 4;
+        CharSequence seq = null;
+        try {
+            int obj = Character.codePointCount(seq, offset, count);
+            processResult -= 30;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/CharacteroffsetByCodePointsIndexOutOfBoundsException.java b/test/testsuite/ouroboros/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/CharacteroffsetByCodePointsIndexOutOfBoundsException.java
new file mode 100644
index 0000000000000000000000000000000000000000..25cecf8d596741323b8730c36b32834f9a6b574b
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/CharacteroffsetByCodePointsIndexOutOfBoundsException.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacteroffsetByCodePointsIndexOutOfBoundsException.java
+ * -@TestCaseName: Exception in Character:public static int offsetByCodePoints
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:prepare index out of bounds
+ * -#step2:invoke offsetByCodePoints with Parameters of step1
+ * -#step3:catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacteroffsetByCodePointsIndexOutOfBoundsException.java
+ * -@ExecuteClass: CharacteroffsetByCodePointsIndexOutOfBoundsException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class CharacteroffsetByCodePointsIndexOutOfBoundsException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = characteroffsetByCodePointsIndexOutOfBoundsException1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        try {
+            result = characteroffsetByCodePointsIndexOutOfBoundsException2();
+        } catch (Exception e) {
+            processResult -= 40;
+        }
+
+        if (result == 4 && processResult == 97) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset), check IndexOutOfBoundsException
+     *
+     * @return status code
+     */
+    public static int characteroffsetByCodePointsIndexOutOfBoundsException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // IndexOutOfBoundsException -if start or count is negative, or if start + count is larger than the length
+        // of the given array, or if index is less than start or larger then start + count, or if codePointOffset
+        // is positive and the text range starting with index and ending with start + count - 1 has fewer than
+        // codePointOffset code points, or if codePointOffset is negative and the text range starting with start and
+        // ending with index - 1 has fewer than the absolute value of codePointOffset code points.
+        //
+        // public static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)
+        int offset = 0;
+        int count = 10;
+        char[] chars = new char[]{'a', 'b', 'c', 'd', 'e'};
+        try {
+            int obj = Character.offsetByCodePoints(chars, offset, count, 0, 0);
+            System.out.println(obj);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+
+    /**
+     * offsetByCodePoints(CharSequence seq, int index, int codePointOffset), catch IndexOutOfBoundsException
+     *
+     * @return status code
+     */
+    public static int characteroffsetByCodePointsIndexOutOfBoundsException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // IndexOutOfBoundsException -if start or count is negative, or if start + count is larger than the length
+        // of the given array, or if index is less than start or larger then start + count, or if codePointOffset
+        // is positive and the text range starting with index and ending with start + count - 1 has fewer than
+        // codePointOffset code points, or if codePointOffset is negative and the text range starting with start and
+        // ending with index - 1 has fewer than the absolute value of codePointOffset code points.
+        //
+        // public static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset)
+
+        int offset = 0;
+        int count = 10;
+        CharSequence seq = "a b c d e";
+        try {
+            int obj = Character.offsetByCodePoints(seq, offset, count);
+            System.out.println(obj);
+            processResult -= 30;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/CharacteroffsetByCodePointsNullPointerException.java b/test/testsuite/ouroboros/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/CharacteroffsetByCodePointsNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..8a216ed50f1d5522cff99a1991e0e54cba161de6
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/CharacteroffsetByCodePointsNullPointerException.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacteroffsetByCodePointsNullPointerException.java
+ * -@TestCaseName: Exception in Character:public static int offsetByCodePoints
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset),a is null,occur NPE
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacteroffsetByCodePointsNullPointerException.java
+ * -@ExecuteClass: CharacteroffsetByCodePointsNullPointerException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class CharacteroffsetByCodePointsNullPointerException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        ;
+        try {
+            result = characteroffsetByCodePointsNullPointerException1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        try {
+            result = characteroffsetByCodePointsNullPointerException2();
+        } catch (Exception e) {
+            processResult -= 40;
+        }
+
+        if (result == 4 && processResult == 97) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset), catch NullPointerException
+     *
+     * @return status code
+     */
+    public static int characteroffsetByCodePointsNullPointerException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NullPointerException - if seq is null.
+        //
+        // public static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)
+        int offset = 1;
+        int count = 4;
+        char[] chars = null;
+        try {
+            int obj = Character.offsetByCodePoints(chars, offset, count, 0, 2);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+
+    /**
+     * offsetByCodePoints(CharSequence seq, int index, int codePointOffset), catch NullPointerException
+     *
+     * @return status code
+     */
+    public static int characteroffsetByCodePointsNullPointerException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NullPointerException - if seq is null.
+        //
+        // public static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset)
+
+        int offset = 1;
+        int count = 4;
+        CharSequence seq = null;
+        try {
+            int obj = Character.offsetByCodePoints(seq, offset, count);
+            processResult -= 30;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/ClassasSubclassClassCastException.java b/test/testsuite/ouroboros/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/ClassasSubclassClassCastException.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9597942a4957b57e545d9e9b4d50d243d89e47c
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/ClassasSubclassClassCastException.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassasSubclassClassCastException.java
+ * -@TestCaseName: Exception in Class:public Class<? extends U> asSubclass(Class<U> clazz)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:create "subclass" includes the class itself
+ * -#step2:this Class object does not represent a subclass of the specified class
+ * -#step3:catch exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassasSubclassClassCastException.java
+ * -@ExecuteClass: ClassasSubclassClassCastException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.List;
+
+public class ClassasSubclassClassCastException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = classAsSubclassClassCastException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * asSubclass(Class<U> clazz), check ClassCastException
+     *
+     * @return status code
+     */
+    public static int classAsSubclassClassCastException() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // ClassCastException - if this Class object does not represent a subclass of the specified class
+        // (here "subclass" includes the class itself).
+        //
+        // public Class<? extends U> asSubclass(Class<U> clazz)
+        La1 la1 = new La1();
+        try {
+            Class<? extends List> strListCast = la1.getClass().asSubclass(List.class);
+            processResult -= 10;
+        } catch (ClassCastException e1) {
+            processResult -= 1;
+        }
+
+        return result1;
+    }
+}
+
+class La1 {
+    /**
+     * just for test
+     */
+    public int field1 = 1;
+    /**
+     * just for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * just for test
+     */
+    public static int field3 = field2[3];
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0524-rt-eh-ClasscastClassCastException/ClasscastClassCastException.java b/test/testsuite/ouroboros/eh_test/RT0524-rt-eh-ClasscastClassCastException/ClasscastClassCastException.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ae672b54abbfe28ce0d6f8d301879796eb02d0c
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0524-rt-eh-ClasscastClassCastException/ClasscastClassCastException.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClasscastClassCastException.java
+ * -@TestCaseName: Exception in Class:public T cast(Object obj)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: this Class object does not represent a subclass of the specified class
+ * -#step2: catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClasscastClassCastException.java
+ * -@ExecuteClass: ClasscastClassCastException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ClasscastClassCastException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = classCastClassCastException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in Class:public T cast(Object obj)
+     *
+     * @return status code
+     */
+    public static int classCastClassCastException() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // ClassCastException - if this Class object does not represent a subclass of the specified class
+        // (here "subclass" includes the class itself).
+        //
+        // public T cast(Object obj)
+        Object obj1 = new Cast1();
+        Cast2 cast22 = new Cast2();
+        try {
+            Object type1 = Cast1.class.cast(cast22);
+            System.out.println(type1.getClass());
+            processResult -= 10;
+        } catch (ClassCastException e1) {
+            processResult -= 1;
+        }
+
+        return result1;
+    }
+}
+
+class Cast1 {
+    String str1 = "str1";
+
+    /**
+     * set String method1
+     */
+    public static void setStr() {
+        String method1 = "1";
+    }
+}
+
+class Cast2 {
+    String str2 = "str2";
+
+    /**
+     * set String method2
+     */
+    public static void setInt() {
+        int method2 = 2;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/ClassforName1ParExceptionInInitializerError.java b/test/testsuite/ouroboros/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/ClassforName1ParExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a879b974e44714716c6fef8a7d98a67f40d2dea
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/ClassforName1ParExceptionInInitializerError.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassforName1ParExceptionInInitializerError.java
+ * -@TestCaseName: Exception in Class :public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:prepare a Class contain RuntimeEH in its static block
+ * -#step2:catch InInitializerError
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassforName1ParExceptionInInitializerError.java
+ * -@ExecuteClass: ClassforName1ParExceptionInInitializerError
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ClassforName1ParExceptionInInitializerError {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = classForName1ParExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in Class :public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     */
+    public static int classForName1ParExceptionInInitializerError() throws ClassNotFoundException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // ExceptionInInitializerError - if the initialization provoked by this method fails
+        //
+        // public static Class<?> forName(String className)
+        Class cls = Class.forName("ClassforName1ParExceptionInInitializerError");
+        ClassLoader cLoader = cls.getClassLoader();
+
+        try {
+            Class cls2 = Class.forName("Cast6");
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class Cast6 {
+    String str1 = "str1";
+
+    /**
+     * set String method1
+     */
+    public static void setStr() {
+        String method1 = "1";
+    }
+
+    static {
+        int num = 1 / 0;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/ClassforNameExceptionInInitializerError.java b/test/testsuite/ouroboros/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/ClassforNameExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1732e18726a1cf58acf00b173ceabe45e766f6b
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/ClassforNameExceptionInInitializerError.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassforNameExceptionInInitializerError.java
+ * -@TestCaseName: Exception in Class :public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:Class contain RuntimeEH in its static block
+ * -#step2:Init by Class.forName,occur InitializerError
+ * -#step3:catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassforNameExceptionInInitializerError.java
+ * -@ExecuteClass: ClassforNameExceptionInInitializerError
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ClassforNameExceptionInInitializerError {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = classForNameExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in Class :public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     */
+    public static int classForNameExceptionInInitializerError() throws ClassNotFoundException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // ExceptionInInitializerError - if the initialization provoked by this method fails
+        //
+        // public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
+        Class cls = Class.forName("ClassforNameExceptionInInitializerError");
+        ClassLoader cLoader = cls.getClassLoader();
+
+        try {
+            Class cls2 = Class.forName("Cast5", true, cLoader);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class Cast5 {
+    String str1 = "str1";
+
+    /**
+     * set String method1
+     */
+    public static void setStr() {
+        String method1 = "1";
+    }
+
+    static {
+        int num = 1 / 0;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/ClassgAnnotationsByTypeNullPointerException.java b/test/testsuite/ouroboros/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/ClassgAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6e867caa04c0ca72ccb16574a0658caec5247d2
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/ClassgAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassgAnnotationsByTypeNullPointerException.java
+ * -@TestCaseName:Exception in AccessibleObject:public A[] getAnnotationsByType(Class<A> annotationClass)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:annotaitonClass is null,invoke getAnnotationsByType(Class<A> annotationClass)
+ * -#step2:catch NPE
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassgAnnotationsByTypeNullPointerException.java
+ * -@ExecuteClass: ClassgAnnotationsByTypeNullPointerException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ClassgAnnotationsByTypeNullPointerException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = classGAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in AccessibleObject:public A[] getAnnotationsByType(Class<A> annotationClass)
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int classGAnnotationsByTypeNullPointerException() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NullPointerException- Null pointer exception
+        // public A[] getAnnotationsByType(Class<A> annotationClass)
+
+        Class class1 = Class.class;
+
+        try {
+            Object file1 = class1.getAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class Test01c {
+    private String name = "default";
+
+    public String getName() {
+        return name;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/ClassgetDeclaredAnnotationNullPointerException.java b/test/testsuite/ouroboros/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/ClassgetDeclaredAnnotationNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..095aa765934adbd5e407943f82ceb1ae37ff87e9
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/ClassgetDeclaredAnnotationNullPointerException.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassgetDeclaredAnnotationNullPointerException.java
+ * -@TestCaseName: Exception in AccessibleObject:public A getDeclaredAnnotation
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:getDeclaredAnnotation(Class<A> annotationClass),annotationClass is null
+ * -#step2:catch Exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassgetDeclaredAnnotationNullPointerException.java
+ * -@ExecuteClass: ClassgetDeclaredAnnotationNullPointerException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.annotation.Annotation;
+
+public class ClassgetDeclaredAnnotationNullPointerException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = classGetDeclaredAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in AccessibleObject:public A getDeclaredAnnotation
+     *
+     * @return status code
+     */
+    public static int classGetDeclaredAnnotationNullPointerException() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException- Null pointer exception
+        // public A getDeclaredAnnotation(Class<A> annotationClass)
+
+        Class class1 = Class.class;
+
+        try {
+            // Object file1  = m. getAnnotationsByType(null);
+            // getDeclaredAnnotation
+            Annotation file1 = class1.getDeclaredAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/ClassgetDeclaredFieldNoSuchFieldException.java b/test/testsuite/ouroboros/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/ClassgetDeclaredFieldNoSuchFieldException.java
new file mode 100644
index 0000000000000000000000000000000000000000..49a936e221fcd92b92f7000b8bb2509cd0819cdd
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/ClassgetDeclaredFieldNoSuchFieldException.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassgetDeclaredFieldNoSuchFieldException.java
+ * -@TestCaseName: Exception in Class constructor:public Field getDeclaredField(String name)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:invoke getDeclaredField(String name) without this field name
+ * -#step1:invoke getDeclaredField(String name) without this field name
+ * -#step2:catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassgetDeclaredFieldNoSuchFieldException.java
+ * -@ExecuteClass: ClassgetDeclaredFieldNoSuchFieldException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class ClassgetDeclaredFieldNoSuchFieldException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = classGetDeclaredFieldNoSuchFieldException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in Class constructor:public Field getDeclaredField(String name)
+     *
+     * @return status code
+     */
+    public static int classGetDeclaredFieldNoSuchFieldException() {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NoSuchFieldException - if a field with the specified name is not found.
+        //
+        // public Field getDeclaredField(String name)
+        Class class1 = Class.class;
+        try {
+            Field file1 = class1.getDeclaredField("abc123");
+            processResult -= 10;
+        } catch (NoSuchFieldException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/ClassgetDeclaredFieldNullPointerException.java b/test/testsuite/ouroboros/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/ClassgetDeclaredFieldNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d25342e77acef3271dd33b3d671ef9df79e657c
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/ClassgetDeclaredFieldNullPointerException.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassgetDeclaredFieldNullPointerException.java
+ * -@TestCaseName: Exception in Class constructor:public Field getDeclaredField(String name)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:getDeclaredField(String name),name is null
+ * -#step2:catch Exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassgetDeclaredFieldNullPointerException.java
+ * -@ExecuteClass: ClassgetDeclaredFieldNullPointerException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class ClassgetDeclaredFieldNullPointerException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = classGetDeclaredFieldNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in Class constructor:public Field getDeclaredField(String name)
+     *
+     * @return status code
+     * @throws NoSuchFieldException
+     */
+    public static int classGetDeclaredFieldNullPointerException() throws NoSuchFieldException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NullPointerException -     if name is null.
+        //
+        // public Field getDeclaredField(String name)
+
+        String string = null;
+        Class class1 = Class.class;
+        try {
+            Field file1 = class1.getDeclaredField(string);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/ConstructorgAnnotationNullPointerException.java b/test/testsuite/ouroboros/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/ConstructorgAnnotationNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..50104e4b3fd546ba801fd79d118021784b207250
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/ConstructorgAnnotationNullPointerException.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorgAnnotationNullPointerException.java
+ * -@TestCaseName:Exception in Constructor:public T getAnnotation
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: getAnnotation(Class<T> annotationClass),annotationClass is null
+ * -#step2: catch NPE
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorgAnnotationNullPointerException.java
+ * -@ExecuteClass: ConstructorgAnnotationNullPointerException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Constructor;
+
+public class ConstructorgAnnotationNullPointerException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = constructorGAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in Constructor:public T getAnnotation
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int constructorGAnnotationNullPointerException() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NullPointerException - Null pointer exception
+        // public T getAnnotation(Class<T> annotationClass)
+        Class<Test01b> class1 = Test01b.class;
+        Constructor<Test01b> c1 = class1.getConstructor(new Class[]{String.class});
+        //        Constructor m = Class.class.getMethod("getName", new Class[] {});
+
+        try {
+            Object file1 = c1.getAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
+
+class Test01b {
+    /**
+     * just for test
+     */
+    public String name = "default";
+
+    public String getName() {
+        return name;
+    }
+
+    public Test01b(String hh) {
+        this.name = hh;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/ConstructornewInstanceExceptionInInitializerError.java b/test/testsuite/ouroboros/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/ConstructornewInstanceExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..490d5a069577efd1a9d5584054a42ff49950fa62
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/ConstructornewInstanceExceptionInInitializerError.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructornewInstanceExceptionInInitializerError.java
+ * -@TestCaseName: In a static variable initialization exception occurs
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:In a static variable initialization exception occurs
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructornewInstanceExceptionInInitializerError.java
+ * -@ExecuteClass: ConstructornewInstanceExceptionInInitializerError
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+public class ConstructornewInstanceExceptionInInitializerError {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = constructorNewInstanceExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        //        System.out.println("result: " + result);
+        //        System.out.println("ConstructornewInstanceExceptionInInitializerError.res: " +
+        // ConstructornewInstanceExceptionInInitializerError.res);
+        return result;
+    }
+
+    /**
+     * In a static variable initialization exception occurs
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     * @throws InstantiationException
+     * @throws IllegalAccessException
+     * @throws IllegalArgumentException
+     * @throws InvocationTargetException
+     */
+    public static int constructorNewInstanceExceptionInInitializerError()
+            throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException,
+            IllegalArgumentException, InvocationTargetException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // ExceptionInInitializerError - In a static variable initialization exception occurs
+        // public T newInstance(Object... initargs)
+        Class<Test01n> class1 = Test01n.class;
+        Constructor<Test01n> c1 = class1.getConstructor(new Class[]{});
+
+        try {
+            Object file1 = c1.newInstance();
+            // System.out.println(file1);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
+
+class Test01n {
+    /**
+     * test a String val
+     */
+    public String name = "default";
+
+    public String getName() {
+        return name;
+    }
+
+    public Test01n() {
+        this.name = "init";
+    }
+
+    static {
+        int num = 1 / 0;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/FieldgetAnnotationNullPointerException.java b/test/testsuite/ouroboros/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/FieldgetAnnotationNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..fedfa2f9b8e27efd9cf39c97627f35b5bfa47c4d
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/FieldgetAnnotationNullPointerException.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldgetAnnotationNullPointerException.java
+ * -@TestCaseName: Exception in Class reflect Field:public T getAnnotation(Class<T> annotationClass)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:getAnnotation(Class<T> annotationClass),annotationClass is null
+ * -#step:catch Exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldgetAnnotationNullPointerException.java
+ * -@ExecuteClass: FieldgetAnnotationNullPointerException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldgetAnnotationNullPointerException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldGetAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in Class reflect Field:public T getAnnotation(Class<T> annotationClass)
+     *
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     */
+    public static int fieldGetAnnotationNullPointerException() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NullPointerException -         if the specified object is null and the field is an instance field.
+        // public T getAnnotation(Class<T> annotationClass)
+
+        Field field = Test01a.class.getDeclaredField("field1");
+        try {
+            Object value = field.getAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+
+    class Test01a {
+        /**
+         * a field for test
+         */
+        public int field1 = 1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/FieldgetAnnotationsByTypeNullPointerException.java b/test/testsuite/ouroboros/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/FieldgetAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..ccb586341bcbffa3fe55574264a34362f10b1de6
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/FieldgetAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldgetAnnotationsByTypeNullPointerException.java
+ * -@TestCaseName: Exception in reflect Field:public T[] getAnnotationsByType(Class<T> annotationClass)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:invoke getAnnotationsByType(Class<T> annotationClass) with null(annotationClass)
+ * -#step2:catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldgetAnnotationsByTypeNullPointerException.java
+ * -@ExecuteClass: FieldgetAnnotationsByTypeNullPointerException
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldgetAnnotationsByTypeNullPointerException {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldGetAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in reflect Field:public T[] getAnnotationsByType(Class<T> annotationClass)
+     *
+     * @return status code
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     */
+    public static int fieldGetAnnotationsByTypeNullPointerException()
+            throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // NullPointerException -         if the specified object is null and the field is an instance field.
+        // public T[] getAnnotationsByType(Class<T> annotationClass)
+
+        Field field = Test01a.class.getDeclaredField("field1");
+        try {
+            Object value = field.getAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult -= 1;
+        }
+
+        return result1;
+    }
+
+    class Test01a {
+        /**
+         * a field for test
+         */
+        public int field1 = 1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/FieldgetByteExceptionInInitializerError.java b/test/testsuite/ouroboros/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/FieldgetByteExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f05b337efebd2a6e741723fce17bcd4a5eef892
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/FieldgetByteExceptionInInitializerError.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldgetByteExceptionInInitializerError.java
+ * -@TestCaseName: Exception in reflect filed:public byte getByte(Object obj)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:prepare Class with wrong init order
+ * -#step2:trigger class init by Field.getByte
+ * -#step3:catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldgetByteExceptionInInitializerError.java
+ * -@ExecuteClass: FieldgetByteExceptionInInitializerError
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldgetByteExceptionInInitializerError {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldGetByteExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed:public byte getByte(Object obj)
+     *
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldGetByteExceptionInInitializerError()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public byte getByte(Object obj)
+        Field field = Test03aa.class.getDeclaredField("field6");
+        try {
+            byte obj = field.getByte(new Test03aa());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class Test03aa {
+    /**
+     * define a byte for test
+     */
+    public static byte field6 = selfByte();
+    /**
+     * define a int[] filed for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set bValue and return
+     *
+     * @return bValue
+     */
+    public static byte selfByte() {
+        int self1 = field2[2];
+        byte bValue = 11;
+        return bValue;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/FieldgetCharExceptionInInitializerError.java b/test/testsuite/ouroboros/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/FieldgetCharExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..075314a8058b5a91ec50b00d60796d96057d8ad5
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/FieldgetCharExceptionInInitializerError.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldgetCharExceptionInInitializerError.java
+ * -@TestCaseName: Exception in reflect filed:public byte getByte(Object obj)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:Class contain RuntimeEH in static block
+ * -#step2:init by getChar,occur InitializerError
+ * -#step3:catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldgetCharExceptionInInitializerError.java
+ * -@ExecuteClass: FieldgetCharExceptionInInitializerError
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldgetCharExceptionInInitializerError {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldGetCharExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed:public byte getByte(Object obj)
+     *
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldGetCharExceptionInInitializerError()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public char getChar(Object obj)
+        Field field = TestChar.class.getDeclaredField("field6");
+        try {
+            char obj = field.getChar(new TestChar());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class TestChar {
+    /**
+     * a char field for test
+     */
+    public static char field6 = selfChar();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set cValue and return
+     */
+    public static char selfChar() {
+        int self1 = field2[2];
+        char cValue = 11;
+        return cValue;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/FieldgetDoubleExceptionInInitializerError.java b/test/testsuite/ouroboros/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/FieldgetDoubleExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb442bc69f02c20be0a56018c45fa041d0f28a20
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/FieldgetDoubleExceptionInInitializerError.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldgetDoubleExceptionInInitializerError.java
+ * -@TestCaseName: Exception in reflect filed:public double getDouble(Object obj)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:prepare Class with wrong init order
+ * -#step2:invoke this Class's Field,use Field.getDouble to trigger class init
+ * -#step3:catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldgetDoubleExceptionInInitializerError.java
+ * -@ExecuteClass: FieldgetDoubleExceptionInInitializerError
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldgetDoubleExceptionInInitializerError {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldGetDoubleExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed:public double getDouble(Object obj)
+     *
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldGetDoubleExceptionInInitializerError()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public double getDouble(Object obj)
+        Field field = TestDouble.class.getDeclaredField("field6");
+        try {
+            double obj = field.getDouble(new TestDouble());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class TestDouble {
+    /**
+     * a double field for test
+     */
+    public static double field6 = selfDouble();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set dValue and return
+     */
+    public static double selfDouble() {
+        int self1 = field2[2];
+        double dValue = 11;
+        return dValue;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/FieldgetExceptionInInitializerError.java b/test/testsuite/ouroboros/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/FieldgetExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..60b157cb85d6fb293553da5b3589db67e727c45d
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/FieldgetExceptionInInitializerError.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldgetExceptionInInitializerError.java
+ * -@TestCaseName: Exception in reflect field:public Object get(Object obj)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:prepare Class with RuntimeEH
+ * -#step2:trigger class init by invoke Field
+ * -#step3:catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldgetExceptionInInitializerError.java
+ * -@ExecuteClass: FieldgetExceptionInInitializerError
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldgetExceptionInInitializerError {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldGetExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in reflect field:public Object get(Object obj)
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldGetExceptionInInitializerError()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public Object get(Object obj)
+        //        Test01aa class1 = new Test01aa();
+        Field field = Test01aa.class.getDeclaredField("field1");
+        try {
+            Object obj = field.get(new Test01aa());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class Test01aa {
+    /**
+     * a int field for test
+     */
+    public int field1 = 1;
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * a int field for test
+     */
+    public static int field3 = field2[3];
+
+    static {
+        int field4 = 1 / 0;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/FieldgetFloatExceptionInInitializerError.java b/test/testsuite/ouroboros/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/FieldgetFloatExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..72a1ddec736aff6d1a11401c3f6a2b1d1f879be0
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/FieldgetFloatExceptionInInitializerError.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldgetFloatExceptionInInitializerError.java
+ * -@TestCaseName: Exception in reflect filed:public float getFloat(Object obj)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1:prepare Class have wrong init order
+ * -#step2:trigger class init by Field.getFloat
+ * -#step3:catch EH
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldgetFloatExceptionInInitializerError.java
+ * -@ExecuteClass: FieldgetFloatExceptionInInitializerError
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldgetFloatExceptionInInitializerError {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldGetFloatExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed:public float getFloat(Object obj)
+     *
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldGetFloatExceptionInInitializerError()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public float getFloat(Object obj)
+        Field field = TestFloat.class.getDeclaredField("field6");
+        try {
+            float obj = field.getFloat(new TestFloat());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class TestFloat {
+    /**
+     * a float field for test
+     */
+    public static float field6 = selfDouble();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set fValue and return
+     *
+     * @return fValue
+     */
+    public static float selfDouble() {
+        int self1 = field2[2];
+        float fValue = 11;
+        return fValue;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/FieldGetIntExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/FieldGetIntExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4333deafb8828475cb06abc92b16d7d1116cfd0c
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/FieldGetIntExceptionInInitializerErrorTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldGetIntExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Exception in reflect filed: public int getInt(Object obj).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a TestInt class, and create a public static selfDouble method and static area has expression
+ *          error.
+ * -#step2: Create a Field instance f by calling the getDeclareFiled method on the TestInt object.
+ * -#step3: Test method getInt(Object obj).
+ * -#step4：Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldGetIntExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: FieldGetIntExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldGetIntExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = fieldGetIntExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public int getInt(Object obj).
+     *
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldGetIntExceptionInInitializerErrorTest()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Field field = TestInt.class.getDeclaredField("field6");
+        try {
+            int obj = field.getInt(new TestInt());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestInt {
+    /**
+     * a int field for test
+     */
+    public static int field6 = selfDouble();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set iValue and return
+     *
+     * @return iValue
+     */
+    public static int selfDouble() {
+        int self1 = field2[2];
+        int iValue = 11;
+        return iValue;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/FieldGetLongExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/FieldGetLongExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b75834ab7476ef93f6dcbbbd68d16999cf9ca58
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/FieldGetLongExceptionInInitializerErrorTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldGetLongExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Exception in reflect filed: public double getLong(Object obj).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a TestGetLong class, and create a public static selfDouble method and static area has expression
+ *          error.
+ * -#step2: Create a Field instance f by calling the getDeclareFiled method on the TestGetLong object.
+ * -#step3: Test method getLong(Object obj).
+ * -#step4：Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldGetLongExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: FieldGetLongExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldGetLongExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = fieldGetLongExceptionInInitializerErrorTes1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public double getLong(Object obj).
+     *
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldGetLongExceptionInInitializerErrorTes1()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Field fe = TestLong.class.getDeclaredField("field6");
+        try {
+            long obj = fe.getLong(new TestLong());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestLong {
+    /**
+     * a long field for test
+     */
+    public static long field6 = selfDouble();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set lValue and return
+     *
+     * @return lValue
+     */
+    public static long selfDouble() {
+        int self1 = field2[2];
+        long lValue = 11;
+        return lValue;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/FieldGetShortExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/FieldGetShortExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8014a22e19d8124ccd13b3ada737e52fa97b5743
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/FieldGetShortExceptionInInitializerErrorTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldGetShortExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Exception in reflect filed: public short getShort(Object obj).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a TestGetShort class, and create a public static selfShort method and static area has expression
+ *          error.
+ * -#step2: Create a Field instance f by calling the getDeclareFiled method on the TestGetShort object.
+ * -#step3: Test method getShort(Object obj).
+ * -#step4：Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldGetShortExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: FieldGetShortExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldGetShortExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = fieldGetShortExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public short getShort(Object obj).
+     *
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldGetShortExceptionInInitializerErrorTest()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Field field = TestShort.class.getDeclaredField("field6");
+        try {
+            short obj = field.getShort(new TestShort());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestShort {
+    /**
+     * a short field for test
+     */
+    public static short field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static short selfShort() {
+        int self1 = field2[2];
+        short value = 11;
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/FieldSetBooleanExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/FieldSetBooleanExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c6f2d528803b3387bc3ff4791d08273ba6ca5da
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/FieldSetBooleanExceptionInInitializerErrorTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldSetBooleanExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Exception in reflect filed: public void setBoolean(Object obj, boolean z).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a TestSetBoolean class, and create a public static selfShort method and static area has expression
+ *          error.
+ * -#step2: Create a Field instance f by calling the getDeclareFiled method on the TestSetBoolean object.
+ * -#step3: Test method setBoolean(Object obj, boolean z).
+ * -#step4：Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldSetBooleanExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: FieldSetBooleanExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldSetBooleanExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = fieldSetBooleanExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public void setBoolean(Object obj, boolean z).
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldSetBooleanExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Field field = TestSetBoolean.class.getDeclaredField("field6");
+        try {
+            field.setBoolean(new TestSetBoolean(), false);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestSetBoolean {
+    /**
+     * a boolean field for test
+     */
+    public static boolean field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static boolean selfShort() {
+        int self1 = field2[2];
+        boolean value = true;
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/FieldSetByteExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/FieldSetByteExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..212d91e3ead8686f3183dead8dd835851a8f4003
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/FieldSetByteExceptionInInitializerErrorTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldSetByteExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Exception in reflect filed: public void setByte(Object obj, byte b).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a TestSetByte class, and create a public static selfShort method and static area has expression
+ *          error.
+ * -#step2: Create a Field instance f by calling the getDeclareFiled method on the TestSetByte object.
+ * -#step3: Test method setByte(Object obj, byte b).
+ * -#step4：Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldSetByteExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: FieldSetByteExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldSetByteExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = fieldSetByteExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public void setByte(Object obj, byte b).
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldSetByteExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Field field = TestSetByte.class.getDeclaredField("field6");
+        try {
+            field.setByte(new TestSetByte(), (byte) 1);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestSetByte {
+    /**
+     * a byte field for test
+     */
+    public static byte field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static byte selfShort() {
+        int self1 = field2[2];
+        byte value = (byte) 2;
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/FieldSetCharExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/FieldSetCharExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6e29780b74af3cacc55c008b42bf80acef74ce5
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/FieldSetCharExceptionInInitializerErrorTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldSetCharExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Exception in reflect filed:public void setChar(Object obj, char c).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a TestSetChar class, and create a public static selfShort method and static area has expression
+ *          error.
+ * -#step2: Create a Field instance f by calling the getDeclareFiled method on the TestSetChar object.
+ * -#step3: Test method setChar(Object obj, char c).
+ * -#step4：Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldSetCharExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: FieldSetCharExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldSetCharExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = fieldSetCharExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed:public void setChar(Object obj, char c).
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldSetCharExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Field field = TestSetChar.class.getDeclaredField("field6");
+        try {
+            field.setChar(new TestSetChar(), 'c');
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestSetChar {
+    /**
+     * a char field for test
+     */
+    public static char field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static char selfShort() {
+        int self1 = field2[2];
+        char value = 'a';
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/FieldSetDoubleExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/FieldSetDoubleExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b94c570594d2511b7cde96e5da09d4f193bdb476
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/FieldSetDoubleExceptionInInitializerErrorTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldSetDoubleExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Exception in reflect filed:public void setDouble(Object obj, double d).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a TestSetDouble class, and create a public static selfShort method and static area has expression
+ *          error.
+ * -#step2: Create a Field instance f by calling the getDeclareFiled method on the TestSetDouble object.
+ * -#step3: Test method setDouble(Object obj, double d).
+ * -#step4：Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldSetDoubleExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: FieldSetDoubleExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldSetDoubleExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = fieldSetDoubleExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed:public void setDouble(Object obj, double d).
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldSetDoubleExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Field field = TestSetDouble.class.getDeclaredField("field6");
+        try {
+            field.setDouble(new TestSetDouble(), 23);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestSetDouble {
+    /**
+     * a double field for test
+     */
+    public static double field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static double selfShort() {
+        int self1 = field2[2];
+        double value = 12;
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/FieldSetExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/FieldSetExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..af8a7269e925f5c4ab3984679c6469aac0b8f107
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/FieldSetExceptionInInitializerErrorTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldSetExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Exception in reflect filed: public void set(Object obj, Object value).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a TestSet class, and create a public static selfShort method and static area has expression error.
+ * -#step2: Create a Field instance f by calling the getDeclareFiled method on the TestSet object.
+ * -#step3: Test method set(Object obj, Object value).
+ * -#step4：Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldSetExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: FieldSetExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldSetExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = fieldSetExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public void set(Object obj, Object value).
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldSetExceptionInInitializerError()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Field field = TestSet.class.getDeclaredField("field6");
+        try {
+            field.set(new TestSet(), 123);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestSet {
+    /**
+     * a int field for test
+     */
+    public static int field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static int selfShort() {
+        int self1 = field2[2];
+        int value = 11;
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/FieldSetFloatExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/FieldSetFloatExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..47959bfa51d736869ab019a9522568831ce4d54e
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/FieldSetFloatExceptionInInitializerErrorTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldSetFloatExceptionInInitializerError.java
+ * -@TestCaseName: Exception in reflect filed: public void setFloat(Object obj, float f).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a TestFloat class, and create a public static selfFloat method and static area has expression error.
+ * -#step2: Create a Field instance f by calling the getDeclareFiled method on the TestSetFloat object.
+ * -#step3: Test method setFloat(Object obj, float f).
+ * -#step4：Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldSetFloatExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: FieldSetFloatExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldSetFloatExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = fieldSetFloatExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public void setFloat(Object obj, float f).
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldSetFloatExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Field field = TestSetFloat.class.getDeclaredField("field6");
+        try {
+            field.setFloat(new TestSetFloat(), (float) 0.12);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestSetFloat {
+    /**
+     * a float field for test
+     */
+    public static float field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static float selfShort() {
+        int self1 = field2[2];
+        float value = (float) 12.54;
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/FieldSetIntExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/FieldSetIntExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a0123fef656e6c598aa512dc5d85f451c9c52886
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/FieldSetIntExceptionTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldSetIntExceptionTest.java
+ * -@TestCaseName: Exception in reflect filed: public void setInt(Object obj, int i).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Get Field object by getDeclaredField(String name).
+ * -#step2: Test method setInt(Object obj, int i) to change the field object's value to int type.
+ * -#step3: Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldSetIntExceptionTest.java
+ * -@ExecuteClass: FieldSetIntExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldSetIntExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldSetIntExceptionTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public void setInt(Object obj, int i).
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldSetIntExceptionTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        Field field = TestSetInt.class.getDeclaredField("field6");
+        try {
+            field.setInt(new TestSetInt(), 123);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class TestSetInt {
+    /**
+     * a int field for test
+     */
+    public static int field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static int selfShort() {
+        int self1 = field2[2];
+        int value = 11;
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/FieldSetLongExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/FieldSetLongExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..475a0df86ebaf3c2f120b2ad1c1d10e82d675edb
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/FieldSetLongExceptionTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldSetLongExceptionTest.java
+ * -@TestCaseName: Exception in reflect filed: public void setLong(Object obj, long l).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Get Field object by getDeclaredField(String name).
+ * -#step2: Test method setLong(Object obj, long l) to change the field object's value to long type.
+ * -#step3: Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldSetLongExceptionTest.java
+ * -@ExecuteClass: FieldSetLongExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldSetLongExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldSetLongExceptionTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public void setLong(Object obj, long l).
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldSetLongExceptionTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        Field field = TestSetLong.class.getDeclaredField("field6");
+        try {
+            field.setLong(new TestSetLong(), 123);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class TestSetLong {
+    /**
+     * a long field for test
+     */
+    public static long field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static long selfShort() {
+        int self1 = field2[2];
+        long value = 11;
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/FieldSetShortExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/FieldSetShortExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..61b8bc254879a21a5a2786b7cd7f32cb7e3a8475
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/FieldSetShortExceptionTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldSetShortExceptionTest.java
+ * -@TestCaseName: Exception in reflect filed: public void setShort(Object obj, short s).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Get Field object by getDeclaredField(String name).
+ * -#step2: Test method setShort(Object obj, short s) change the field object's value to short type.
+ * -#step3: Check ExceptionInInitializerError is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: FieldSetShortExceptionTest.java
+ * -@ExecuteClass: FieldSetShortExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class FieldSetShortExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = fieldSetShortExceptionTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect filed: public void setShort(Object obj, short s).
+     *
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     */
+    public static int fieldSetShortExceptionTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+            IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        Field field = TestSetShort.class.getDeclaredField("field6");
+        try {
+            field.setShort(new TestSetShort(), (short) 12);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class TestSetShort {
+    /**
+     * a short field for test
+     */
+    public static short field6 = selfShort();
+    /**
+     * a int[] field for test
+     */
+    public static int[] field2 = {1, 2, 3, 4};
+
+    /**
+     * set value and return
+     *
+     * @return value
+     */
+    public static short selfShort() {
+        int self1 = field2[2];
+        short value = 11;
+        return value;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/MethodGetAnnotationExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/MethodGetAnnotationExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bac74f01d3d31ca5fb1ec7a7dfc53f96df8eef1d
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/MethodGetAnnotationExceptionTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodGetAnnotationExceptionTest.java
+ * -@TestCaseName: Exception in reflect Method: public T getAnnotation(Class<T> annotationClass).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create self class.
+ * -#step2: Get class method instance from self class.
+ * -#step3: Test method getAnnotation(Class<T> annotationClass), parameter annotationClass is null.
+ * -#step4: Check NullPointerException exception is thrown correctly.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: MethodGetAnnotationExceptionTest.java
+ * -@ExecuteClass: MethodGetAnnotationExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+
+public class MethodGetAnnotationExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = methodGetAnnotationExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect Method: public T getAnnotation(Class<T> annotationClass).
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int methodGetAnnotationExceptionTest() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Method method = Test02a.class.getMethod("getName", new Class[]{});
+        try {
+            Object value = method.getAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class Test02a {
+    private String name = "default";
+
+    public String getName() {
+        return name;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/MethodInvokeExceptionInInitializerErrorTest.java b/test/testsuite/ouroboros/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/MethodInvokeExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..20f9984eccc5c01021b41b851c6a0bf72c0ff4da
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/MethodInvokeExceptionInInitializerErrorTest.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodInvokeExceptionInInitializerErrorTest.java
+ * -@TestCaseName: Exception in reflect method : public Object invoke(Object obj, Object... args).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create self class has fault static, create class instance by self class construct.
+ * -#step2: Get class method from self class.
+ * -#step3: Test invoke(Object obj, Object... args), args is a new object Array.
+ * -#step4: Check that if ExceptionInInitializerError exception occurs.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: MethodInvokeExceptionInInitializerErrorTest.java
+ * -@ExecuteClass: MethodInvokeExceptionInInitializerErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class MethodInvokeExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = methodInvokeExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    /**
+     * Exception in reflect method : public Object invoke(Object obj, Object... args).
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     * @throws IllegalAccessException
+     * @throws IllegalArgumentException
+     * @throws InvocationTargetException
+     */
+    public static int methodInvokeExceptionInInitializerError()
+            throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException,
+            InvocationTargetException {
+        int result1 = 4; /*STATUS_FAILED*/
+        Class<TestExceptionInInitializerError> class1 = TestExceptionInInitializerError.class;
+        Method method = class1.getMethod("setInt", new Class[]{int.class});
+        try {
+            method.invoke(new TestExceptionInInitializerError(10), new Object[]{20});
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class TestExceptionInInitializerError {
+    int nu;
+
+    /**
+     * set num
+     *
+     * @param num for test
+     */
+    public static void setInt(int num) {
+        int num1 = num;
+    }
+
+    public TestExceptionInInitializerError(int num) {
+        this.nu = num;
+    }
+
+    static {
+        int num = 1 / 0;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/ParameterGetAnnotationNullPointerExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/ParameterGetAnnotationNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8daf7466942da9dca0277f8e8bb111fda24d2122
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/ParameterGetAnnotationNullPointerExceptionTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ParameterGetAnnotationNullPointerExceptionTest.java
+ * -@TestCaseName: Exception in reflect.Parameter: public T getAnnotation(Class<T> annotationClass).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create method instance by self class.
+ * -#step2: Get method parameters by getParameters() from method instance.
+ * -#step3: Test method getAnnotation(Class<T> annotationClass), parameter annotationClass is null.
+ * -#step3: Check that if NullPointerException occurs.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ParameterGetAnnotationNullPointerExceptionTest.java
+ * -@ExecuteClass: ParameterGetAnnotationNullPointerExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterGetAnnotationNullPointerExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterGetAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect.Parameter: public T getAnnotation(Class<T> annotationClass).
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int parameterGetAnnotationNullPointerException() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        Method method = Test03a.class.getMethod("getName", new Class[]{String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            Object value = parameters[0].getAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class Test03a {
+    private String name = "default";
+
+    public String getName(String str1) {
+        return str1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/ParameterGetAnnotationsByTypeNullPointerExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/ParameterGetAnnotationsByTypeNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..430e6f9b689c40788df8382ffd1f95d014e74412
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/ParameterGetAnnotationsByTypeNullPointerExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ParameterGetAnnotationsByTypeNullPointerExceptionTest.java
+ * -@TestCaseName: Exception in reflect.Parameter: public T[] getAnnotationsByType(Class<T> annotationClass).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create method instance by self class.
+ * -#step2: Get method parameters by getParameters() from method instance.
+ * -#step3: Test method getAnnotationsByType(Class<T> annotationClass), parameter annotationClass is null.
+ * -#step4: Check that if NullPointerException exception occurs.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ParameterGetAnnotationsByTypeNullPointerExceptionTest.java
+ * -@ExecuteClass: ParameterGetAnnotationsByTypeNullPointerExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterGetAnnotationsByTypeNullPointerExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = parameterGetAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect.Parameter: public T[] getAnnotationsByType(Class<T> annotationClass).
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int parameterGetAnnotationsByTypeNullPointerException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        Method method = Test04a.class.getMethod("getName", new Class[]{String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            Object value = parameters[0].getAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+
+        return result1;
+    }
+}
+
+class Test04a {
+    private String name = "default";
+
+    public String getName(String str1) {
+        return str1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/ParameterGetDeclaredAnnotationNullPointerExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/ParameterGetDeclaredAnnotationNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b85e3c942cb8bcaf16d2dc604138d8f0c661247c
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/ParameterGetDeclaredAnnotationNullPointerExceptionTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ParameterGetDeclaredAnnotationNullPointerExceptionTest.java
+ * -@TestCaseName: Exception in reflect.Parameter: public T getDeclaredAnnotation(Class<T> annotationClass).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create method instance by self class.
+ * -#step2: Get method parameters by getParameters() from method instance.
+ * -#step3: Test method getDeclaredAnnotation(Class<T> annotationClass), parameter annotationClass is null.
+ * -#step4: Check that if NullPointerException exception occurs.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ParameterGetDeclaredAnnotationNullPointerExceptionTest.java
+ * -@ExecuteClass: ParameterGetDeclaredAnnotationNullPointerExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterGetDeclaredAnnotationNullPointerExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterGetDeclaredAnnotationNullPointerException1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in reflect.Parameter: public T getDeclaredAnnotation(Class<T> annotationClass).
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int parameterGetDeclaredAnnotationNullPointerException1()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+
+        Method method = Test05a.class.getMethod("getName", new Class[]{String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            Object value = parameters[0].getDeclaredAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class Test05a {
+    private String name = "default";
+
+    public String getName(String str1) {
+        return str1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/ParameterGetDeclaredAnnotationsByTypeExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/ParameterGetDeclaredAnnotationsByTypeExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e84d60c1e7bdf8aa584c07c3a05fb826a51951f6
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/ParameterGetDeclaredAnnotationsByTypeExceptionTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ParameterGetDeclaredAnnotationsByTypeExceptionTest.java
+ * -@TestCaseName: Exception in Parameter: public T[] getDeclaredAnnotationsByType(Class<T> annotationClass).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create method instance by self class.
+ * -#step2: Get method parameters by getParameters() from method instance.
+ * -#step3: Test method getDeclaredAnnotationsByType(Class<T> annotationClass), parameter annotationClass is null.
+ * -#step4: Check that if NullPointerException exception occurs.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ParameterGetDeclaredAnnotationsByTypeExceptionTest.java
+ * -@ExecuteClass: ParameterGetDeclaredAnnotationsByTypeExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterGetDeclaredAnnotationsByTypeExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = parameterGetDeclaredAnnotationsByTypeException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in Parameter: public T[] getDeclaredAnnotationsByType(Class<T> annotationClass).
+     *
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     */
+    public static int parameterGetDeclaredAnnotationsByTypeException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /* STATUS_FAILED */
+
+        Method method = Test06a.class.getMethod("getName", new Class[]{String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            Object value = parameters[0].getDeclaredAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class Test06a {
+    private String name = "default";
+
+    public String getName(String str1) {
+        return str1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/ThrowableAddSuppressedExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/ThrowableAddSuppressedExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..627a77a2663e8856a52471c92fefd95ff4803a2a
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/ThrowableAddSuppressedExceptionTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThrowableAddSuppressedExceptionTest.java
+ * -@TestCaseName: Exception in Throwable: public final void addSuppressed(Throwable exception).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create throwable instance and parameter throwable instance exception.
+ * -#step2: Test method addSuppressed(Throwable exception).
+ * -#step3: Check that if IllegalArgumentException occurs.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ThrowableAddSuppressedExceptionTest.java
+ * -@ExecuteClass: ThrowableAddSuppressedExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ThrowableAddSuppressedExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            result = throwableAddSuppressedException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in Throwable: public final void addSuppressed(Throwable exception).
+     *
+     * @return status code
+     */
+    public static int throwableAddSuppressedException() {
+        int result1 = 4; /* STATUS_FAILED */
+        Throwable cause = new Throwable();
+
+        try {
+            cause.addSuppressed(cause);
+            processResult -= 10;
+        } catch (IllegalArgumentException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/ThrowableAddSuppressedNullPointerExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/ThrowableAddSuppressedNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c042b1d81bd6a794876473beec276aa52c474c8
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/ThrowableAddSuppressedNullPointerExceptionTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThrowableAddSuppressedNullPointerExceptionTest.java
+ * -@TestCaseName: Exception in Throwable: public final void addSuppressed(Throwable exception).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create Throwable instance.
+ * -#step2: Test method addSuppressed(Throwable exception), exception is null.
+ * -#step3: Check that if NullPointerException occurs.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ThrowableAddSuppressedNullPointerExceptionTest.java
+ * -@ExecuteClass: ThrowableAddSuppressedNullPointerExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ThrowableAddSuppressedNullPointerExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = throwableAddSuppressedNullPointerException1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    /**
+     * Exception in Throwable: public final void addSuppressed(Throwable exception).
+     *
+     * @return status code
+     */
+    public static int throwableAddSuppressedNullPointerException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        Throwable cause = new Throwable();
+        try {
+            cause.addSuppressed((Throwable) null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+class Test02ga {
+    private String name = "default";
+
+    public String getName() {
+        return name;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/MethodInvokeExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/MethodInvokeExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1974e9ab137a0be54957705a9d5fad512a201cf9
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/MethodInvokeExceptionTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodInvokeExceptionTest.java
+ * -@TestCaseName: Test Exception in invoke of method.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#case1
+ * -#step1: Create a method from getConstructor of java.lang.Class.
+ * -#step2: Generate an instance from java.security.CodeSigner. Assign parameters is Class[].
+ * -#step3: Test Object invoke(Object obj, Object... args), check exception is thrown correctly.
+ * -#case2
+ * -#step1: Create a method from CharConversionException of java.lang.Character.
+ * -#step2: Generate an instance by class java.security.CodeSigner. Assign parameters is Class[].
+ * -#step3: Test Object invoke(Object obj, Object... args), check exception is thrown correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: MethodInvokeExceptionTest.java
+ * -@ExecuteClass: MethodInvokeExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+
+public class MethodInvokeExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    private static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED */
+
+        try {
+            invokeMethod();
+        } catch (Exception e) {
+            processResult--;
+            System.out.println(3);
+        }
+
+        try {
+            invokeMethodTest();
+        } catch (Exception e) {
+            processResult--;
+            System.out.println(6);
+        }
+
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    static void invokeMethod() throws Exception {
+        Method method = Class.forName("java.lang.Class").getDeclaredMethod("getConstructor", Class[].class);
+        Object instance = Class.forName("java.security.CodeSigner");
+        Object[] parameters = new Object[1];
+        parameters[0] =
+                new Class[]{
+                        java.security.CodeSigner.class,
+                        java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                        java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                        java.util.LinkedHashMap.class,
+                        java.nio.channels.AsynchronousFileChannel.class,
+                        java.sql.Time.class,
+                        java.util.EnumMap.class,
+                        java.nio.channels.FileLock.class,
+                        java.util.WeakHashMap.class
+                };
+        System.out.println(1);
+        method.invoke(instance, parameters);
+        System.out.println(2);
+    }
+
+    static void invokeMethodTest() throws Exception {
+        Method method =
+                Class.forName("java.lang.Character").getDeclaredMethod("CharConversionException", Class[].class);
+        Object instance = Class.forName("java.security.CodeSigner");
+        Object[] parameters = new Object[1];
+
+        parameters[0] =
+                new Class[]{
+                        java.security.CodeSigner.class,
+                        java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                        java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                        java.util.LinkedHashMap.class,
+                        java.nio.channels.AsynchronousFileChannel.class,
+                        java.sql.Time.class,
+                        java.util.EnumMap.class,
+                        java.nio.channels.FileLock.class,
+                        java.util.WeakHashMap.class
+                };
+        System.out.println(4);
+        method.invoke(instance, parameters);
+        System.out.println(5);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 1\n3\n6\n0\n
diff --git a/test/testsuite/ouroboros/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/MethodInvokeObjectObjectsTest.java b/test/testsuite/ouroboros/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/MethodInvokeObjectObjectsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c2d4a955aebc12fd503e1b5d4850fb5f17fca4c
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/MethodInvokeObjectObjectsTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodInvokeObjectObjectsTest.java
+ * -@TestCaseName: Test Object invoke(Object obj, Object... args) of Method, check Exception order.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1：Create an instance of a method from class java.util.concurrent.ConcurrentHashMap.
+ * -#step2: Create Parameter param1 as a StringBuffer, Create Parameter param2 as a Object[].
+ * -#step3: Test the method invoke(Object obj, Object... args), and check the Exception is thrown correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: MethodInvokeObjectObjectsTest.java
+ * -@ExecuteClass: MethodInvokeObjectObjectsTest
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.*;
+import java.nio.charset.Charset;
+import java.util.*;
+
+public class MethodInvokeObjectObjectsTest {
+    /**
+     * test class
+     */
+    public static Class<?> clazz;
+
+    public static void main(String[] args) {
+        try {
+            System.out.println(run());
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run() {
+        try {
+            clazz = Class.forName("java.lang.reflect.Method");
+            Method method = clazz.getMethod("invoke", Object.class, Object[].class);
+            String fcn2 = "java.util.concurrent.ConcurrentHashMap";
+            int mIndex6 = 1;
+            Method[] methods2 = Class.forName(fcn2).getDeclaredMethods();
+            Arrays.sort(methods2, new ConstructorComparator());
+            Object instance = methods2[mIndex6];
+            Constructor con = java.lang.StringBuffer.class.getDeclaredConstructor();
+            Object param1 = con.newInstance();
+            Object[] param2 = new Object[4];
+            Constructor con0 = java.lang.StringBuffer.class.getDeclaredConstructor();
+            param2[0] = con0.newInstance();
+            Constructor con1 =
+                    java.security.spec.MGF1ParameterSpec.class.getDeclaredConstructor(java.lang.String.class);
+            param2[1] = con1.newInstance("abcdefghijklmnopqrstuvwxxzABCDEFGHIJKLMNOPQRSTUVWXYZ-9223372036854775551");
+            Constructor con2 = java.util.Stack.class.getDeclaredConstructor();
+            param2[2] = con2.newInstance();
+            Constructor con3 =
+                    java.security.spec.ECGenParameterSpec.class.getDeclaredConstructor(java.lang.String.class);
+            param2[3] = con3.newInstance("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
+            Object result = method.invoke(instance, param1, param2);
+            System.out.println(result);
+        } catch (Exception e) {
+            if (e.toString().equals("java.lang.reflect.InvocationTargetException")
+                    && e.getCause().getClass().getName().toString().equals("java.lang.IllegalArgumentException")) {
+                return 0;
+            }
+        }
+        return -1;
+    }
+}
+
+class ConstructorComparator implements Comparator<Object> {
+    @Override
+    public int compare(Object c1, Object c2) {
+        byte[] b1 = c1.toString().getBytes(Charset.defaultCharset());
+        byte[] b2 = c2.toString().getBytes(Charset.defaultCharset());
+        int len = (b1.length < b2.length ? b1.length : b2.length);
+        for (int i = 0; i < len; i++) {
+            if (b1[i] < b2[i]) {
+                return 1;
+            } else if (b1[i] > b2[i]) {
+                return -1;
+            }
+        }
+        if (b1.length > b2.length) {
+            return -1;
+        } else if (b1.length < b2.length) {
+            return 1;
+        }
+        return 1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/MethodInvokeInvocationTargetExceptionTest.java b/test/testsuite/ouroboros/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/MethodInvokeInvocationTargetExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..167d0a1d7a414e2e151979129feddd86ee3bc48d
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/MethodInvokeInvocationTargetExceptionTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodInvokeInvocationTargetExceptionTest
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Create a Method method.
+ * -#step2: Generate an instance object of the method and assign parameters.
+ * -#step3: Call the method's invoke method.
+ * -#step4: Check the InvocationTargetException thrown by invoke Method.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: MethodInvokeInvocationTargetExceptionTest.java
+ * -@ExecuteClass: MethodInvokeInvocationTargetExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class MethodInvokeInvocationTargetExceptionTest {
+    public static void main(String[] args) {
+        try {
+            invokeMethod();
+        } catch (InvocationTargetException e) {
+            System.out.println(0);
+        } catch (Exception e) {
+            System.out.println(3);
+        }
+    }
+
+    static void invokeMethod()
+            throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InvocationTargetException {
+        Method method = Class.forName("java.lang.Class").getDeclaredMethod("getConstructor", Class[].class);
+        Object instance = Class.forName("java.security.CodeSigner");
+        Object[] parameters = new Object[1];
+
+        parameters[0] =
+                new Class[]{
+                        java.security.CodeSigner.class,
+                        java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                        java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                        java.util.LinkedHashMap.class,
+                        java.nio.channels.AsynchronousFileChannel.class,
+                        java.sql.Time.class,
+                        java.util.EnumMap.class,
+                        java.nio.channels.FileLock.class,
+                        java.util.WeakHashMap.class
+                };
+
+        method.invoke(instance, parameters);
+        System.out.println(2);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/UninitializedExNullPointerExceptionTest.java b/test/testsuite/ouroboros/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/UninitializedExNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c93bec627bb886aeb9f545511bec650ee930918
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/UninitializedExNullPointerExceptionTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UninitializedExNullPointerExceptionTest.java
+ * -@TestCaseName: Test Jvm instr: invoke special throw NullPointException.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Declare a static class.
+ * -#step2: Invoke a method of static class.
+ * -#step3: Check NullPointException is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: UninitializedExNullPointerExceptionTest.java
+ * -@ExecuteClass: UninitializedExNullPointerExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class UninitializedExNullPointerExceptionTest {
+    static int processResult = 2;
+    static UninitializedExNullPointerExceptionTest iv;
+
+    private void proc2() {
+    }
+
+    /**
+     * Test Jvm instr: invoke special throw NullPointException.
+     */
+    public static void proc1() {
+        try {
+            iv.proc2(); // the invoke special instruction is used here
+        } catch (NullPointerException e) {
+            processResult = 0; // STATUS_PASSED
+        }
+    }
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        proc1();
+        return processResult;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/JvmInitializeOutOfMemoryErrorTest.java b/test/testsuite/ouroboros/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/JvmInitializeOutOfMemoryErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..270168b14a7d92b6b6a9a349d500e0af5a3bc42a
--- /dev/null
+++ b/test/testsuite/ouroboros/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/JvmInitializeOutOfMemoryErrorTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: JvmInitializeOutOfMemoryErrorTest.java
+ * -@TestCaseName: Test jvm instr: invoke virtual thrown Exception InInitializerError.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: [运行时需求]支持Java异常处理
+ * -@Brief:
+ * -#step1: Initialize a big int param, beyond 512M.
+ * -#step2: Check OutOfMemoryError is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: JvmInitializeOutOfMemoryErrorTest.java
+ * -@ExecuteClass: JvmInitializeOutOfMemoryErrorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class JvmInitializeOutOfMemoryErrorTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run(String[] argv, PrintStream out) {
+        JvmInitializeOutOfMemoryErrorTest tTest = new JvmInitializeOutOfMemoryErrorTest();
+        return tTest.test();
+    }
+
+    /**
+     * Test jvm instr: invoke virtual thrown Exception InInitializerError.
+     *
+     * @return status code
+     */
+    public static int test() {
+        try {
+            int[] num;
+            num = new int[1024 * 1024 * 1280]; // 1024*1024*4B = 4M, *128=512M
+            num[0] = 1; // If no this, y = new int[] will be optimizated and deleted.
+        } catch (OutOfMemoryError e2) {
+            return 0;
+        }
+        return 2;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/Message125004.java b/test/testsuite/ouroboros/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/Message125004.java
new file mode 100644
index 0000000000000000000000000000000000000000..98a1c713db28ac3c368f27aafb000c5bf0322aa9
--- /dev/null
+++ b/test/testsuite/ouroboros/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/Message125004.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Message125004.java
+ *- @Title/Destination: PipedReader.getField() should get correct unstack when EH
+ *- @Brief:
+ *- @Expect:expected.txt
+ *- @Priority: High
+ *- @Source: Message125004.java
+ *- @ExecuteClass: Message125004
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class Message125004 {
+    private static int RES = 99;
+    private static Class<?> clazz;
+
+    public static void main(String[] args) {
+        int result;
+        try {
+            result = message125004();
+            if (result == 4 && Message125004.RES == 89) {
+                result = 0;
+            }
+            System.out.println(result);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+
+    /**测试实例：[{NeedRandomClass=java.io.PipedReader}]     测试入参：abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ257     测试api信息：java.lang.Class
+     *  测试api信息：getField
+     测试api信息：String
+     */
+    public static int message125004() {
+        try {
+            clazz = Class.forName("java.lang.Class");
+            Method method = clazz.getMethod("getField",java.lang.String.class);
+            String parameters1 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ257";
+            Class instance = Class.forName("java.io.PipedReader") ;
+            Object result1 = method.invoke(instance, parameters1);
+            Message125004.RES -= 10;
+            return 4;
+            } catch (InvocationTargetException e) {
+                // 只打印类型 由Agent端接受进行对比
+                // 打印全错误信息
+//                e.printStackTrace();
+                Message125004.RES -= 10;
+                return 4;
+            } catch (Exception e) {
+            // 只打印类型 由Agent端接受进行对比
+            // 打印全错误信息
+//            e.printStackTrace();
+            Message125004.RES -= 10;
+            return 4;
+        }
+    }
+
+
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/Message011706.java b/test/testsuite/ouroboros/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/Message011706.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d4def986faa2fd805b7c37aac9db2288e2b2661
--- /dev/null
+++ b/test/testsuite/ouroboros/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/Message011706.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Message011706.java
+ *- @Title/Destination: java.lang.reflect.Method/invoke/ObjectAndObject[],check EH order
+ *- @Brief:
+ *- @Expect:expected.txt
+ *- @Priority: High
+ *- @Source: Message011706.java
+ *- @ExecuteClass: Message011706
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.*;
+import java.util.*;
+
+public class Message011706 {
+    public static Class<?> clazz;
+    private static List<Object> resultlist = new LinkedList<>();
+
+    public static void main(String[] args) {
+        try {
+            System.out.println(messageCommonUse());
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+
+
+    public static int messageCommonUse() {
+        try {
+            clazz = Class.forName("java.lang.reflect.Method");
+            Method method = clazz.getMethod("invoke",Object.class,Object[].class);
+            String fcn2 = "java.util.concurrent.ConcurrentHashMap";
+            int mIndex6 = 1;
+            Method[] methods2 = Class.forName(fcn2).getDeclaredMethods();
+            Arrays.sort(methods2, new ConstructorComparator());
+            Object instance =  methods2[mIndex6];
+            Constructor con = java.lang.StringBuffer.class.getDeclaredConstructor();
+            Object param1 = con.newInstance();
+            Object param2[] = new Object[4];
+            Constructor con0 = java.lang.StringBuffer.class.getDeclaredConstructor();
+            param2[0] = con0.newInstance();
+            Constructor con1 = java.security.spec.MGF1ParameterSpec.class.getDeclaredConstructor(java.lang.String.class);
+            param2[1] = con1.newInstance("abcdefghijklmnopqrstuvwxxzABCDEFGHIJKLMNOPQRSTUVWXYZ-9223372036854775551");
+            Constructor con2 = java.util.Stack.class.getDeclaredConstructor();
+            param2[2] = con2.newInstance();
+            Constructor con3 = java.security.spec.ECGenParameterSpec.class.getDeclaredConstructor(java.lang.String.class);
+            param2[3] = con3.newInstance("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
+            Object Result = method.invoke(instance,param1,param2);
+            System.out.println(Result);
+        }  catch (Exception e) {
+            if (e.toString().equals("java.lang.reflect.InvocationTargetException") &&
+                    e.getCause().getClass().getName().toString().equals("java.lang.IllegalArgumentException")) {
+                return 0;
+            }
+        }
+        return -1;
+    }
+}
+
+class ConstructorComparator implements Comparator<Object>{
+    @Override
+    public int compare(Object c1, Object c2) {
+        byte[] b1 = c1.toString().getBytes();
+        byte[] b2 = c2.toString().getBytes();
+        int len = (b1.length<b2.length?b1.length:b2.length);
+        for(int i = 0; i<len; i++) {
+            if (b1[i]<b2[i]) {
+                return 1;
+            } else if (b1[i]>b2[i]) {
+                return -1;
+            }
+        }
+        if (b1.length > b2.length) {
+            return -1;
+        } else if (b1.length < b2.length) {
+            return 1;
+        }
+        return 1;
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/ThreadcountStackFramesTest.java b/test/testsuite/ouroboros/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/ThreadcountStackFramesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1887595c9313a17c88df75100bb80b3a0cd0a772
--- /dev/null
+++ b/test/testsuite/ouroboros/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/ThreadcountStackFramesTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadcountStackFramesTest.java
+ *- @Title/Destination: Thread api: countStackFrames()
+ *- @Brief:
+ *- @Expect:expected.txt
+ *- @Priority: High
+ *- @Source: ThreadcountStackFramesTest.java
+ *- @ExecuteClass: ThreadcountStackFramesTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadcountStackFramesTest {
+    static int RES = 99;
+    public static void main(String[] args) {
+        System.out.println(run());
+    }
+
+    private static int run() {
+        int result;
+        result = countStackFramesTest();
+        if (result == 4 && ThreadcountStackFramesTest.RES == 89) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int countStackFramesTest() {
+        Runnable ra = new MyThread1();
+        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ4294967295";
+        Thread t = new Thread(ra, str);
+        @SuppressWarnings("deprecation")
+        int i = t.countStackFrames();
+        if (i == 0) {
+            ThreadcountStackFramesTest.RES -= 10;
+        }
+        return 4;
+    }
+}
+
+class MyThread1 implements Runnable {
+    private int ticket = 10;
+    @SuppressWarnings("unused")
+    private String name;
+
+    public void run() {
+            for (int i = 0; i < 500; i++) {
+                    if (this.ticket > 0) {
+                            System.out.println(Thread.currentThread().getName() + "---->" + (this.ticket--));
+                    }
+            }
+    }
+
+    public Object handler() {
+            Thread thread = new Thread(new MyThread1());
+            thread.setUncaughtExceptionHandler(new MyExceptionHandler());
+            thread.start();
+            return thread.getUncaughtExceptionHandler();
+    }
+
+    class MyExceptionHandler implements Thread.UncaughtExceptionHandler {
+
+            public void uncaughtException(Thread t, Throwable e) {
+                    System.out.printf("An exception has been captured\n");
+                    System.out.printf("Thread:%s\n", t.getName());
+                    System.out.printf("Exception: %s: %s:\n", e.getClass().getName(), e.getMessage());
+                    System.out.printf("Stack Trace:\n");
+                    e.printStackTrace();
+                    System.out.printf("Thread status:%s\n", t.getState());
+            }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/Message021404.java b/test/testsuite/ouroboros/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/Message021404.java
new file mode 100644
index 0000000000000000000000000000000000000000..9699d67de5f131d46c27dc86af1ea9e73cc0212f
--- /dev/null
+++ b/test/testsuite/ouroboros/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/Message021404.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Message021404.java
+ *- @Title/Destination: Unsafe api: getUnsafe().when invoke use reflect,stack frame will miss one
+ *- @Brief:
+ *- @Expect:expected.txt
+ *- @Priority: High
+ *- @Source: Message021404.java
+ *- @ExecuteClass: Message021404
+ *- @ExecuteArgs:
+ */
+
+
+import sun.misc.Unsafe;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class Message021404 {
+    private static int res = 99;
+    public static void main(String[] args) {
+        try {
+            System.out.println(run());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static int run() throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
+        int result;
+        result = message021404();
+        if (result == 4 && Message021404.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int message021404() throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
+        Field f = Unsafe.class.getDeclaredField("theUnsafe");
+        f.setAccessible(true);
+        Unsafe s = (Unsafe)f.get(null);
+        Method m = Unsafe.class.getDeclaredMethod("getUnsafe");
+        m.invoke(s);
+        Message021404.res -= 10;
+        return 4;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/Message61004.java b/test/testsuite/ouroboros/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/Message61004.java
new file mode 100644
index 0000000000000000000000000000000000000000..eaaf0ab240ccbaff17116602701fbe677591114e
--- /dev/null
+++ b/test/testsuite/ouroboros/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/Message61004.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Message61004.java
+ *- @Title/Destination: String api: subString(),OOM
+ *- @Brief:
+ *- @Expect:expected.txt
+ *- @Priority: High
+ *- @Source: Message61004.java
+ *- @ExecuteClass: Message61004
+ *- @ExecuteArgs:
+ */
+
+
+public class Message61004 {
+
+    private static int RES = 99;
+    private static Class<?> clazz;
+
+    public static void main(String[] args) {
+//message61104();
+        int result = 2;
+        try {
+            result = message61004();
+            if (result == 4 && Message61004.RES == 89) {
+                result = 0;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        System.out.println(result);
+    }
+
+    /*    测试实例：测试入参：1389308892测试入参：-1727641912测试api信息：java.lang.String测试api信息：substring测试api信息：int测试api信息：int
+     */
+    private static int message61004() {
+        String str = null;
+        try {
+            clazz = Class.forName("java.lang.String");
+//            Method[] met = clazz.getMethods();
+//            Method method = clazz.getMethod("substring", int.class, int.class);
+            int parameters1 = 1389308892;
+            int parameters2 = -1727641912;
+            String instance = new String();
+            instance.substring(parameters1, parameters2);
+//            Object result1 = method.invoke(instance, parameters1, parameters2);
+        } catch (Error e) {
+            str = e.getClass().toString();
+            //System.out.println(str);
+            //e.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (str != null && str.equals("class java.lang.OutOfMemoryError")) {
+            Message61004.RES -= 10;
+        }
+        return 4;
+    }
+
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0380-rc-Annotation-RCWeakRefTest/RCWeakRefTest.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0380-rc-Annotation-RCWeakRefTest/RCWeakRefTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2616de3f01a36d16d72a5f3c7e5a3916245a5b8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0380-rc-Annotation-RCWeakRefTest/RCWeakRefTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:rc/unownedRef/RCWeakRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Test the basic function of @Weak
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCWeakRefTest.java
+ *- @ExecuteClass: RCWeakRefTest
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Weak;
+
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+
+class Test_A {
+    @Weak
+    Test_B bb;
+    Test_B bb2;
+
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");
+        }
+        bb2.run();
+    }
+
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+    }
+}
+
+public class RCWeakRefTest {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0381-rc-Annotation-RCWeakRefTest2/RCWeakRefTest2.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0381-rc-Annotation-RCWeakRefTest2/RCWeakRefTest2.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7e2c8b9c29088b46b32c61f1e8c8a44666d6ba0
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0381-rc-Annotation-RCWeakRefTest2/RCWeakRefTest2.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:rc/unownedRef/RCWeakRefTest2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Test the basic function of the @Weak
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCWeakRefTest2.java
+ *- @ExecuteClass: RCWeakRefTest2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Field;
+
+import com.huawei.ark.annotation.Weak;
+
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+
+class Test_A {
+    @Weak
+    Test_B bb;
+    @Weak
+    volatile Test_B bv;
+
+    public void test() {
+        foo();
+        new Thread(new TriggerRef()).start();
+
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");  //expect to be null
+        }
+        try {
+            bv.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");  //expect to be null
+        }
+    }
+
+    private void foo() {
+        //bb = new Test_B();
+        try {
+            Field m = Test_A.class.getDeclaredField("bb");
+            Test_B b1 = new Test_B();
+            m.set(this, b1);
+            Field m1 = Test_A.class.getDeclaredField("bv");
+            m1.set(this, b1);
+
+            Test_B temp1 = (Test_B) m.get(this);
+            if (temp1 != b1) {
+                System.out.println("error 1");
+            }
+            Test_B temp2 = (Test_B) m1.get(this);
+            if (temp2 != b1) {
+                System.out.println("error 1");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+
+    class TriggerRef implements Runnable {
+        public void run() {
+            for (int i = 0; i < 100; i++) {
+                WeakReference ref = new WeakReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+
+public class RCWeakRefTest2 {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0383-rc-Annotation-RCWeakRefTest4/RCWeakRefTest4.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0383-rc-Annotation-RCWeakRefTest4/RCWeakRefTest4.java
new file mode 100644
index 0000000000000000000000000000000000000000..c168c3e3c9ccc9a5b43e3990199ffe9939068a15
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0383-rc-Annotation-RCWeakRefTest4/RCWeakRefTest4.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RCWeakRefTest4.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00010 for @Weak Test
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCWeakRefTest4.java
+ *- @ExecuteClass: RCWeakRefTest4
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_B_1_00010_A1 {
+    @Weak
+    Cycle_B_1_00010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00010_A1() {
+        a1_0 = null;
+        a = 123;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class RCWeakRefTest4 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        if (nsum == 246)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0384-rc-Annotation-RCWeakRefThreadTest/RCWeakRefThreadTest.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0384-rc-Annotation-RCWeakRefThreadTest/RCWeakRefThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..81b01f4326342cbf68ed542f63c3fd85a9fa7e02
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0384-rc-Annotation-RCWeakRefThreadTest/RCWeakRefThreadTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/RCWeakRefThreadTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCWeakRefTest4 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCWeakRefThreadTest.java
+ *- @ExecuteClass: RCWeakRefThreadTest
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_Bm_1_00010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 246)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00010_A1 {
+        @Weak
+        Cycle_B_1_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00010_A1() {
+            a1_0 = null;
+            a = 123;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class RCWeakRefThreadTest {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00010 A1_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A2_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A3_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A4_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A5_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A6_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+
+        A1_Cycle_Bm_1_00010.start();
+        A2_Cycle_Bm_1_00010.start();
+        A3_Cycle_Bm_1_00010.start();
+        A4_Cycle_Bm_1_00010.start();
+        A5_Cycle_Bm_1_00010.start();
+        A6_Cycle_Bm_1_00010.start();
+
+        try {
+            A1_Cycle_Bm_1_00010.join();
+            A2_Cycle_Bm_1_00010.join();
+            A3_Cycle_Bm_1_00010.join();
+            A4_Cycle_Bm_1_00010.join();
+            A5_Cycle_Bm_1_00010.join();
+            A6_Cycle_Bm_1_00010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00010.check() && A2_Cycle_Bm_1_00010.check() && A3_Cycle_Bm_1_00010.check() && A4_Cycle_Bm_1_00010.check() && A5_Cycle_Bm_1_00010.check() && A6_Cycle_Bm_1_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0386-rc-Annotation-RCUnownedRefTest2/RCUnownedRefTest2.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0386-rc-Annotation-RCUnownedRefTest2/RCUnownedRefTest2.java
new file mode 100644
index 0000000000000000000000000000000000000000..7aa2cf69d35c23044febf31626f23723212f8f51
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0386-rc-Annotation-RCUnownedRefTest2/RCUnownedRefTest2.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:rc/unownedRef/RCUnownedRefTest2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Test the basic function of @Unowned
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefTest2.java
+ *- @ExecuteClass: RCUnownedRefTest2
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+class Test_B {
+    @Unowned
+    Test_B bself;
+
+    protected void run() {
+        System.out.println("ExpectResult");
+    }
+}
+
+class Test_A {
+
+    Test_B bb;
+
+    Test_B bb2;
+
+    public void test() {
+        foo();
+        bb.bself.run();
+        bb2.bself.run();
+    }
+
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+        bb.bself = bb;
+        bb2.bself = bb;
+    }
+}
+
+public class RCUnownedRefTest2 {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0387-rc-Annotation-RCUnownedRefUnCycle/RCUnownedRefUnCycle.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0387-rc-Annotation-RCUnownedRefUnCycle/RCUnownedRefUnCycle.java
new file mode 100644
index 0000000000000000000000000000000000000000..64a8399cf2e9d41d89320712fdabb76bf742b9b8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0387-rc-Annotation-RCUnownedRefUnCycle/RCUnownedRefUnCycle.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RCUnownedRefUnCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00150 for @Unowned function Test
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefUnCycle.java
+ *- @ExecuteClass: RCUnownedRefUnCycle
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+class Nocycle_a_00150_A1 {
+    Nocycle_a_00150_B1 b1_0;
+    @Unowned
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00150_A2 {
+    @Unowned
+    Nocycle_a_00150_B1 b1_0;
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00150_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00150_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class RCUnownedRefUnCycle {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.b2_0 = a2_main.b2_0;
+        a2_main.b1_0 = a1_main.b1_0;
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 1815)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0389-rc-Annotation-RCUnownedRefUncycleThread/RCUnownedRefUncycleThread.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0389-rc-Annotation-RCUnownedRefUncycleThread/RCUnownedRefUncycleThread.java
new file mode 100644
index 0000000000000000000000000000000000000000..130c478800883a2ac52db8376f3fe193b70b9d6d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0389-rc-Annotation-RCUnownedRefUncycleThread/RCUnownedRefUncycleThread.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/RCUnownedRefUncycleThread.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCUnownedRefUncycle to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefUncycleThread.java
+ *- @ExecuteClass: RCUnownedRefUncycleThread
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+class ThreadRc_00150 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = a1_main.b1_0;
+        a1_main.b2_0 = a2_main.b2_0;
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00150_A1 {
+        Nocycle_a_00150_B1 b1_0;
+        @Unowned
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_A2 {
+        @Unowned
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00150_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class RCUnownedRefUncycleThread {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00150 A1_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A2_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A3_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A4_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A5_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A6_00150 = new ThreadRc_00150();
+
+        A1_00150.start();
+        A2_00150.start();
+        A3_00150.start();
+        A4_00150.start();
+        A5_00150.start();
+        A6_00150.start();
+
+        try {
+            A1_00150.join();
+            A2_00150.join();
+            A3_00150.join();
+            A4_00150.join();
+            A5_00150.join();
+            A6_00150.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00150.check() && A2_00150.check() && A3_00150.check() && A4_00150.check() && A5_00150.check() && A6_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0391-rc-Annotation-RCAnnotationThread01/RCAnnotationThread01.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0391-rc-Annotation-RCAnnotationThread01/RCAnnotationThread01.java
new file mode 100644
index 0000000000000000000000000000000000000000..40b6fea39760b983c9cd5594fb5610f78a3e6e47
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0391-rc-Annotation-RCAnnotationThread01/RCAnnotationThread01.java
@@ -0,0 +1,445 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RCAnnotationThread01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationThread01.java
+ *- @ExecuteClass: RCAnnotationThread01
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+class RCAnnotationThread01_1 extends Thread {
+    public void run() {
+        RCAnnotationThread01 rcth01 = new RCAnnotationThread01();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread01_2 extends Thread {
+    public void run() {
+        RCAnnotationThread01 rcth01 = new RCAnnotationThread01();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread01_3 extends Thread {
+    public void run() {
+        RCAnnotationThread01 rcth01 = new RCAnnotationThread01();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RCAnnotationThread01_4 extends Thread {
+    public void run() {
+        RCAnnotationThread01 rcth01 = new RCAnnotationThread01();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread01_5 extends Thread {
+    public void run() {
+        RCAnnotationThread01 rcth01 = new RCAnnotationThread01();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RCAnnotationThread01 {
+    private volatile static RCAnnotationThread01_A1 a1_main = null;
+    private volatile static RCAnnotationThread01_A2 a2_main = null;
+    private volatile static RCAnnotationThread01_A3 a3_main = null;
+    private volatile static RCAnnotationThread01_A4 a4_main = null;
+
+    RCAnnotationThread01() {
+        synchronized (this) {
+            try {
+                a1_main = new RCAnnotationThread01_A1("a1_main");
+                a2_main = new RCAnnotationThread01_A2("a2_main");
+                a3_main = new RCAnnotationThread01_A3("a3_main");
+                a4_main = new RCAnnotationThread01_A4("a4_main");
+                a1_main.b1_0 = new RCAnnotationThread01_B1("b1_0");
+                a1_main.d1_0 = new RCAnnotationThread01_D1("d1_0");
+                a1_main.b1_0.d2_0 = new RCAnnotationThread01_D2("d2_0");
+
+                a2_main.b2_0 = new RCAnnotationThread01_B2("b2_0");
+                a2_main.b2_0.c1_0 = new RCAnnotationThread01_C1("c1_0");
+                a2_main.b2_0.d1_0 = a1_main.d1_0;
+                a2_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+                a2_main.b2_0.d3_0 = new RCAnnotationThread01_D3("d3_0");
+                a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+
+                a3_main.b2_0 = a2_main.b2_0;
+                a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+                a3_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+                a3_main.b2_0.d1_0 = a1_main.d1_0;
+                a3_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+                a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+
+                a3_main.c2_0 = new RCAnnotationThread01_C2("c2_0");
+                a3_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+                a3_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+
+                a4_main.b3_0 = new RCAnnotationThread01_B3("b3_0");
+                a4_main.b3_0.c1_0 = a2_main.b2_0.c1_0;
+                a4_main.b3_0.c1_0.d1_0 = a1_main.d1_0;
+                a4_main.c2_0 = a3_main.c2_0;
+                a4_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+                a4_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+            } catch (NullPointerException e) {
+
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread01_1 t1 = new RCAnnotationThread01_1();
+        RCAnnotationThread01_2 t2 = new RCAnnotationThread01_2();
+        RCAnnotationThread01_3 t3 = new RCAnnotationThread01_3();
+        RCAnnotationThread01_4 t4 = new RCAnnotationThread01_4();
+        RCAnnotationThread01_5 t5 = new RCAnnotationThread01_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA2null() {
+        a2_main = null;
+    }
+
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RCAnnotationThread01_D2("new");
+            a3_main = new RCAnnotationThread01_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        a3_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    class RCAnnotationThread01_A1 {
+        volatile RCAnnotationThread01_B1 b1_0;
+        volatile RCAnnotationThread01_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+
+    class RCAnnotationThread01_A2 {
+        volatile RCAnnotationThread01_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+
+    class RCAnnotationThread01_A3 {
+        @Unowned
+        volatile RCAnnotationThread01_B2 b2_0;
+        volatile RCAnnotationThread01_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class RCAnnotationThread01_A4 {
+        volatile RCAnnotationThread01_B3 b3_0;
+        @Unowned
+        volatile RCAnnotationThread01_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+
+    class RCAnnotationThread01_B1 {
+        volatile RCAnnotationThread01_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+
+    class RCAnnotationThread01_B2 {
+        volatile RCAnnotationThread01_C1 c1_0;
+        @Unowned
+        volatile RCAnnotationThread01_D1 d1_0;
+        @Unowned
+        volatile RCAnnotationThread01_D2 d2_0;
+        volatile RCAnnotationThread01_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RCAnnotationThread01_B3 {
+        @Unowned
+        volatile RCAnnotationThread01_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+
+    class RCAnnotationThread01_C1 {
+        @Unowned
+        volatile RCAnnotationThread01_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class RCAnnotationThread01_C2 {
+        @Unowned
+        volatile RCAnnotationThread01_D2 d2_0;
+        @Unowned
+        volatile RCAnnotationThread01_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RCAnnotationThread01_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RCAnnotationThread01_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RCAnnotationThread01_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread01_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0392-rc-Annotation-RCAnnotationThread02/RCAnnotationThread02.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0392-rc-Annotation-RCAnnotationThread02/RCAnnotationThread02.java
new file mode 100644
index 0000000000000000000000000000000000000000..e84e464e42078b253cb399f0f5d7bc65ad3cdf16
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0392-rc-Annotation-RCAnnotationThread02/RCAnnotationThread02.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RCAnnotationThread02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationThread02.java
+ *- @ExecuteClass: RCAnnotationThread02
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+
+class RCAnnotationThread02_1 extends Thread {
+    public void run() {
+        RCAnnotationThread02 rcth01 = new RCAnnotationThread02();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread02_2 extends Thread {
+    public void run() {
+        RCAnnotationThread02 rcth01 = new RCAnnotationThread02();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread02_3 extends Thread {
+    public void run() {
+        RCAnnotationThread02 rcth01 = new RCAnnotationThread02();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RCAnnotationThread02 {
+    private volatile static RCAnnotationThread02_A1 a1_main = null;
+    private volatile static RCAnnotationThread02_A4 a4_main = null;
+    private volatile static RCAnnotationThread02_A5 a5_main = null;
+
+    RCAnnotationThread02() {
+        synchronized (this) {
+            try {
+                RCAnnotationThread02_A1 a1 = new RCAnnotationThread02_A1();
+                a1.a2_0 = new RCAnnotationThread02_A2();
+                a1.a2_0.a3_0 = new RCAnnotationThread02_A3();
+                RCAnnotationThread02_A4 a4 = new RCAnnotationThread02_A4();
+                RCAnnotationThread02_A5 a5 = new RCAnnotationThread02_A5();
+                a4.a1_0 = a1;
+                a5.a1_0 = a1;
+                a1.a2_0.a3_0.a1_0 = a1;
+                a1_main = a1;
+                a4_main = a4;
+                a5_main = a5;
+            } catch (NullPointerException e) {
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread02_1 t1 = new RCAnnotationThread02_1();
+        RCAnnotationThread02_2 t2 = new RCAnnotationThread02_2();
+        RCAnnotationThread02_3 t3 = new RCAnnotationThread02_3();
+        t1.start();
+        t2.start();
+        t3.start();
+
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RCAnnotationThread02_A1 {
+        volatile RCAnnotationThread02_A2 a2_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread02_A2 {
+        volatile RCAnnotationThread02_A3 a3_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread02_A3 {
+        @Weak
+        volatile RCAnnotationThread02_A1 a1_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    static class RCAnnotationThread02_A4 {
+        @Unowned
+        volatile RCAnnotationThread02_A1 a1_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread02_A5 {
+        @Unowned
+        volatile RCAnnotationThread02_A1 a1_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0393-rc-Annotation-RCAnnotationThread03/RCAnnotationThread03.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0393-rc-Annotation-RCAnnotationThread03/RCAnnotationThread03.java
new file mode 100644
index 0000000000000000000000000000000000000000..b67c39d6a8cca6e61f48897835c0af6703962222
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0393-rc-Annotation-RCAnnotationThread03/RCAnnotationThread03.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RCAnnotationThread03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationThread03.java
+ *- @ExecuteClass: RCAnnotationThread03
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+
+class RCAnnotationThread03_1 extends Thread {
+    public void run() {
+        RCAnnotationThread03 rcth01 = new RCAnnotationThread03();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RCAnnotationThread03_2 extends Thread {
+    public void run() {
+        RCAnnotationThread03 rcth01 = new RCAnnotationThread03();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RCAnnotationThread03_3 extends Thread {
+    public void run() {
+        RCAnnotationThread03 rcth01 = new RCAnnotationThread03();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+
+    }
+}
+
+public class RCAnnotationThread03 {
+    private volatile static RCAnnotationThread03_A1 a1_main = null;
+    private volatile static RCAnnotationThread03_A5 a5_main = null;
+
+    RCAnnotationThread03() {
+        synchronized (this) {
+            try {
+                a1_main = new RCAnnotationThread03_A1();
+                a1_main.a2_0 = new RCAnnotationThread03_A2();
+                a1_main.a2_0.a3_0 = new RCAnnotationThread03_A3();
+                a1_main.a2_0.a3_0.a4_0 = new RCAnnotationThread03_A4();
+                a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+                a5_main = new RCAnnotationThread03_A5();
+                a1_main.a2_0.a3_0.a4_0.a6_0 = new RCAnnotationThread03_A6();
+                a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+                a5_main.a3_0 = a1_main.a2_0.a3_0;
+            } catch (NullPointerException e) {
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread03_1 t1 = new RCAnnotationThread03_1();
+        RCAnnotationThread03_2 t2 = new RCAnnotationThread03_2();
+        RCAnnotationThread03_3 t3 = new RCAnnotationThread03_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        try {
+            a1_main.a2_0.a3_0.a4_0 = null;
+            a5_main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RCAnnotationThread03_A1 {
+        volatile RCAnnotationThread03_A2 a2_0;
+        volatile RCAnnotationThread03_A4 a4_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread03_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread03_A2 {
+        volatile RCAnnotationThread03_A3 a3_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread03_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread03_A3 {
+        volatile RCAnnotationThread03_A4 a4_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread03_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread03_A4 {
+        @Weak
+        volatile RCAnnotationThread03_A1 a1_0;
+        volatile RCAnnotationThread03_A6 a6_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread03_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RCAnnotationThread03_A5 {
+        @Unowned
+        volatile RCAnnotationThread03_A3 a3_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread03_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RCAnnotationThread03_A6 {
+        @Unowned
+        volatile RCAnnotationThread03_A5 a5_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread03_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0394-rc-Annotation-RCAnnotationThread04/RCAnnotationThread04.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0394-rc-Annotation-RCAnnotationThread04/RCAnnotationThread04.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f27968b6b60251f90fa072769ec963c7c53b0e0
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0394-rc-Annotation-RCAnnotationThread04/RCAnnotationThread04.java
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RCAnnotationThread04.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationThread04.java
+ *- @ExecuteClass: RCAnnotationThread04
+ *- @ExecuteArgs:
+ *
+ */
+
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+
+class RCAnnotationThread04_1 extends Thread {
+    public void run() {
+        RCAnnotationThread04 rcth01 = new RCAnnotationThread04();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread04_2 extends Thread {
+    public void run() {
+        RCAnnotationThread04 rcth01 = new RCAnnotationThread04();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread04_3 extends Thread {
+    public void run() {
+        RCAnnotationThread04 rcth01 = new RCAnnotationThread04();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RCAnnotationThread04 {
+    private volatile static RCAnnotationThread04_A1 a1_main = null;
+    private volatile static RCAnnotationThread04_A4 a4_main = null;
+    private volatile static RCAnnotationThread04_A6 a6_main = null;
+
+    RCAnnotationThread04() {
+        synchronized (this) {
+            try {
+                RCAnnotationThread04_A1 a1 = new RCAnnotationThread04_A1("a1");
+                RCAnnotationThread04_A4 a4 = new RCAnnotationThread04_A4("a4");
+                RCAnnotationThread04_A6 a6 = new RCAnnotationThread04_A6("a6");
+                a1.a2_0 = new RCAnnotationThread04_A2("a2_0");
+                a1.a2_0.a3_0 = new RCAnnotationThread04_A3("a3_0");
+                a1.a2_0.a3_0.a1_0 = a1;
+                a1.a2_0.a3_0.a5_0 = new RCAnnotationThread04_A5("a5_0");
+                a1.a2_0.a3_0.a5_0.a6_0 = a6;
+                a6.a1_0 = a1;
+                a6.a3_0 = a1.a2_0.a3_0;
+                a4.a5_0 = a1.a2_0.a3_0.a5_0;
+                a6.a4_0 = a4;
+                a1_main = a1;
+                a4_main = a4;
+                a6_main = a6;
+            } catch (NullPointerException e) {
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread04_1 t_00010 = new RCAnnotationThread04_1();
+        RCAnnotationThread04_2 t_00020 = new RCAnnotationThread04_2();
+        RCAnnotationThread04_3 t_00030 = new RCAnnotationThread04_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RCAnnotationThread04_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RCAnnotationThread04_A3 a3 = new RCAnnotationThread04_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RCAnnotationThread04_A1 {
+        volatile RCAnnotationThread04_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RCAnnotationThread04_A2 {
+        volatile RCAnnotationThread04_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RCAnnotationThread04_A3 {
+        @Weak
+        volatile RCAnnotationThread04_A1 a1_0;
+        volatile RCAnnotationThread04_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread04_A4 {
+        volatile RCAnnotationThread04_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RCAnnotationThread04_A5 {
+        @Unowned
+        volatile RCAnnotationThread04_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RCAnnotationThread04_A6 {
+        @Unowned
+        volatile RCAnnotationThread04_A1 a1_0;
+        @Unowned
+        volatile RCAnnotationThread04_A3 a3_0;
+        @Unowned
+        volatile RCAnnotationThread04_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0395-rc-Annotation-RCAnnotationThread05/RCAnnotationThread05.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0395-rc-Annotation-RCAnnotationThread05/RCAnnotationThread05.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e8c5b0e8213fd48a421f19e8448014f3b62f4bb
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0395-rc-Annotation-RCAnnotationThread05/RCAnnotationThread05.java
@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RCAnnotationThread05.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationThread05.java
+ *- @ExecuteClass: RCAnnotationThread05
+ *- @ExecuteArgs:
+ *
+ */
+
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+
+class RCAnnotationThread05_1 extends Thread {
+    public void run() {
+        RCAnnotationThread05 rcth01 = new RCAnnotationThread05();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread05_2 extends Thread {
+    public void run() {
+        RCAnnotationThread05 rcth01 = new RCAnnotationThread05();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread05_3 extends Thread {
+    public void run() {
+        RCAnnotationThread05 rcth01 = new RCAnnotationThread05();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RCAnnotationThread05 {
+    private volatile static RCAnnotationThread05_A1 a1_main = null;
+    private volatile static RCAnnotationThread05_A4 a4_main = null;
+    private volatile static RCAnnotationThread05_A6 a6_main = null;
+    private static RCAnnotationThread05_A2 a2 = null;
+
+    RCAnnotationThread05() {
+        synchronized (this) {
+            try {
+                RCAnnotationThread05_A1 a1 = new RCAnnotationThread05_A1("a1");
+                RCAnnotationThread05_A4 a4 = new RCAnnotationThread05_A4("a4");
+                RCAnnotationThread05_A6 a6 = new RCAnnotationThread05_A6("a6");
+                a2 = new RCAnnotationThread05_A2("a2_0");
+                a1.a2_0 = a2;
+                a1.a2_0.a3_0 = new RCAnnotationThread05_A3("a3_0");
+                a1.a2_0.a3_0.a1_0 = a1;
+                a1.a2_0.a3_0.a5_0 = new RCAnnotationThread05_A5("a5_0");
+                a1.a2_0.a3_0.a5_0.a6_0 = a6;
+                a6.a1_0 = a1;
+                a6.a3_0 = a1.a2_0.a3_0;
+                a4.a5_0 = a1.a2_0.a3_0.a5_0;
+                a6.a4_0 = a4;
+                a1_main = a1;
+                a4_main = a4;
+                a6_main = a6;
+            } catch (NullPointerException e) {
+
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread05_1 t_00010 = new RCAnnotationThread05_1();
+        RCAnnotationThread05_2 t_00020 = new RCAnnotationThread05_2();
+        RCAnnotationThread05_3 t_00030 = new RCAnnotationThread05_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RCAnnotationThread05_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RCAnnotationThread05_A3 a3 = new RCAnnotationThread05_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RCAnnotationThread05_A1 {
+        volatile RCAnnotationThread05_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RCAnnotationThread05_A2 {
+        volatile RCAnnotationThread05_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RCAnnotationThread05_A3 {
+        @Weak
+        volatile RCAnnotationThread05_A1 a1_0;
+        volatile RCAnnotationThread05_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread05_A4 {
+        @Unowned
+        volatile RCAnnotationThread05_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RCAnnotationThread05_A5 {
+        @Unowned
+        volatile RCAnnotationThread05_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RCAnnotationThread05_A6 {
+        @Unowned
+        volatile RCAnnotationThread05_A1 a1_0;
+        @Unowned
+        volatile RCAnnotationThread05_A3 a3_0;
+        @Unowned
+        volatile RCAnnotationThread05_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0396-rc-Annotation-RCAnnotationOneCycle/RCAnnotationOneCycle.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0396-rc-Annotation-RCAnnotationOneCycle/RCAnnotationOneCycle.java
new file mode 100644
index 0000000000000000000000000000000000000000..f381659444a3a982ca50431978407fb6a64ab1dd
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0396-rc-Annotation-RCAnnotationOneCycle/RCAnnotationOneCycle.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RCAnnotationOneCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00180 for @Weak and @Unowned Test
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationOneCycle.java
+ *- @ExecuteClass: RCAnnotationOneCycle
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_B_1_00180_A1 {
+    Cycle_B_1_00180_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A2 {
+    Cycle_B_1_00180_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A3 {
+    @Weak
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_00180_A4 {
+    @Unowned
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A5 {
+    @Unowned
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class RCAnnotationOneCycle {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 23)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0397-rc-Annotation-RCAnnotationOneCycleThread/RCAnnotationOneCycleThread.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0397-rc-Annotation-RCAnnotationOneCycleThread/RCAnnotationOneCycleThread.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7124fc47811a96706ec57016acf595ec46fc4ad
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0397-rc-Annotation-RCAnnotationOneCycleThread/RCAnnotationOneCycleThread.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationOneCycleThread.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationOneCycle to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationOneCycleThread.java
+ *- @ExecuteClass: RCAnnotationOneCycleThread
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_Bm_1_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 23)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00180_A1 {
+        Cycle_B_1_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A2 {
+        Cycle_B_1_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A3 {
+        @Weak
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A4 {
+        @Unowned
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A5 {
+        @Unowned
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationOneCycleThread {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00180 A1_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A2_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A3_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A4_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A5_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A6_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+
+        A1_Cycle_Bm_1_00180.start();
+        A2_Cycle_Bm_1_00180.start();
+        A3_Cycle_Bm_1_00180.start();
+        A4_Cycle_Bm_1_00180.start();
+        A5_Cycle_Bm_1_00180.start();
+        A6_Cycle_Bm_1_00180.start();
+
+        try {
+            A1_Cycle_Bm_1_00180.join();
+            A2_Cycle_Bm_1_00180.join();
+            A3_Cycle_Bm_1_00180.join();
+            A4_Cycle_Bm_1_00180.join();
+            A5_Cycle_Bm_1_00180.join();
+            A6_Cycle_Bm_1_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00180.check() && A2_Cycle_Bm_1_00180.check() && A3_Cycle_Bm_1_00180.check() && A4_Cycle_Bm_1_00180.check() && A5_Cycle_Bm_1_00180.check() && A6_Cycle_Bm_1_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0398-rc-Annotation-RCAnnotationTwoCycle/RCAnnotationTwoCycle.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0398-rc-Annotation-RCAnnotationTwoCycle/RCAnnotationTwoCycle.java
new file mode 100644
index 0000000000000000000000000000000000000000..170a20a84cdf218e865d55a998538241a248a20e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0398-rc-Annotation-RCAnnotationTwoCycle/RCAnnotationTwoCycle.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RCAnnotationTwoCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00080 for @Weak and @Unowned Test.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationTwoCycle.java
+ *- @ExecuteClass: RCAnnotationTwoCycle
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_B_2_00080_A1 {
+    Cycle_B_2_00080_A2 a2_0;
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A1() {
+        a2_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A2 {
+    Cycle_B_2_00080_A3 a3_0;
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A3 {
+    @Weak
+    Cycle_B_2_00080_A1 a1_0;
+    @Unowned
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A4 {
+    @Unowned
+    Cycle_B_2_00080_A3 a3_0;
+    @Unowned
+    Cycle_B_2_00080_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A4() {
+        a3_0 = null;
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A5 {
+    @Unowned
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class RCAnnotationTwoCycle {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a1_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a1_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0399-rc-Annotation-RCAnnotationTwoCycle2/RCAnnotationTwoCycle2.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0399-rc-Annotation-RCAnnotationTwoCycle2/RCAnnotationTwoCycle2.java
new file mode 100644
index 0000000000000000000000000000000000000000..2516967eb6d6f141ac0476f772df4f24a884e102
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0399-rc-Annotation-RCAnnotationTwoCycle2/RCAnnotationTwoCycle2.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RCAnnotationTwoCycle2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00230 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationTwoCycle2.java
+ *- @ExecuteClass: RCAnnotationTwoCycle2
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_B_2_00230_A1 {
+    Cycle_B_2_00230_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A2 {
+    Cycle_B_2_00230_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A3 {
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A4 {
+    Cycle_B_2_00230_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A5 {
+    Cycle_B_2_00230_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A6 {
+    @Weak
+    Cycle_B_2_00230_A1 a1_0;
+    @Unowned
+    Cycle_B_2_00230_A10 a10_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A6() {
+        a1_0 = null;
+        a10_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a10_0.a;
+    }
+}
+
+class Cycle_B_2_00230_A8 {
+    Cycle_B_2_00230_A9 a9_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A9 {
+    Cycle_B_2_00230_A7 a7_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A7 {
+    @Unowned
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A10 {
+    Cycle_B_2_00230_A8 a8_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A10() {
+        a8_0 = null;
+        a = 10;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+
+public class RCAnnotationTwoCycle2 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        //System.out.println(nsum);
+        if (nsum == 97)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/RCAnnotationTwoCycleThread.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/RCAnnotationTwoCycleThread.java
new file mode 100644
index 0000000000000000000000000000000000000000..87e73c193580571ea67a088e1b32a27d06496115
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/RCAnnotationTwoCycleThread.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationTwoCycleThread.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationTwoCycle to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationTwoCycleThread.java
+ *- @ExecuteClass: RCAnnotationTwoCycleThread
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_Bm_2_00080 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a1_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a1_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00080_A1 {
+        Cycle_B_2_00080_A2 a2_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A2 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A3 {
+        @Weak
+        Cycle_B_2_00080_A1 a1_0;
+        @Unowned
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A4 {
+        @Unowned
+        Cycle_B_2_00080_A3 a3_0;
+        @Unowned
+        Cycle_B_2_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A4() {
+            a3_0 = null;
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A5 {
+        @Unowned
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationTwoCycleThread {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00080 A1_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A2_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A3_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A4_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A5_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A6_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+
+        A1_Cycle_Bm_2_00080.start();
+        A2_Cycle_Bm_2_00080.start();
+        A3_Cycle_Bm_2_00080.start();
+        A4_Cycle_Bm_2_00080.start();
+        A5_Cycle_Bm_2_00080.start();
+        A6_Cycle_Bm_2_00080.start();
+
+        try {
+            A1_Cycle_Bm_2_00080.join();
+            A2_Cycle_Bm_2_00080.join();
+            A3_Cycle_Bm_2_00080.join();
+            A4_Cycle_Bm_2_00080.join();
+            A5_Cycle_Bm_2_00080.join();
+            A6_Cycle_Bm_2_00080.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00080.check() && A2_Cycle_Bm_2_00080.check() && A3_Cycle_Bm_2_00080.check() && A4_Cycle_Bm_2_00080.check() && A5_Cycle_Bm_2_00080.check() && A6_Cycle_Bm_2_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/RCAnnotationTwoCycleThread2.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/RCAnnotationTwoCycleThread2.java
new file mode 100644
index 0000000000000000000000000000000000000000..267b7ba4fca56043a88a7cb3d947cbe5bd43c9a3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/RCAnnotationTwoCycleThread2.java
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationTwoCycleThread2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationTwoCycle2  to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationTwoCycleThread2.java
+ *- @ExecuteClass: RCAnnotationTwoCycleThread2
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_Bm_2_00230 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        if (nsum == 97)
+            checkout = true;
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00230_A1 {
+        Cycle_B_2_00230_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A2 {
+        Cycle_B_2_00230_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A3 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A4 {
+        Cycle_B_2_00230_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A5 {
+        Cycle_B_2_00230_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A6 {
+        @Weak
+        Cycle_B_2_00230_A1 a1_0;
+        @Unowned
+        Cycle_B_2_00230_A10 a10_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A6() {
+            a1_0 = null;
+            a10_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A8 {
+        Cycle_B_2_00230_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A9 {
+        Cycle_B_2_00230_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A7 {
+        @Unowned
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A10 {
+        Cycle_B_2_00230_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A10() {
+            a8_0 = null;
+            a = 10;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationTwoCycleThread2 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00230 A1_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A2_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A3_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A4_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A5_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A6_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+
+        A1_Cycle_Bm_2_00230.start();
+        A2_Cycle_Bm_2_00230.start();
+        A3_Cycle_Bm_2_00230.start();
+        A4_Cycle_Bm_2_00230.start();
+        A5_Cycle_Bm_2_00230.start();
+        A6_Cycle_Bm_2_00230.start();
+
+        try {
+            A1_Cycle_Bm_2_00230.join();
+            A2_Cycle_Bm_2_00230.join();
+            A3_Cycle_Bm_2_00230.join();
+            A4_Cycle_Bm_2_00230.join();
+            A5_Cycle_Bm_2_00230.join();
+            A6_Cycle_Bm_2_00230.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00230.check() && A2_Cycle_Bm_2_00230.check() && A3_Cycle_Bm_2_00230.check() && A4_Cycle_Bm_2_00230.check() && A5_Cycle_Bm_2_00230.check() && A6_Cycle_Bm_2_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0402-rc-Annotation-RCAnnotationMultiCycle/RCAnnotationMultiCycle.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0402-rc-Annotation-RCAnnotationMultiCycle/RCAnnotationMultiCycle.java
new file mode 100644
index 0000000000000000000000000000000000000000..2312b45074ff51717ca44af31f939170c70554a5
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0402-rc-Annotation-RCAnnotationMultiCycle/RCAnnotationMultiCycle.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RCAnnotationMultiCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00280 for @Weak and @Unowned Test
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationMultiCycle.java
+ *- @ExecuteClass: RCAnnotationMultiCycle
+ *- @ExecuteArgs:
+ *  A1 depend A2 A3;  A6 depend A3
+ * A2 depend A1 A3; A3 depend A1 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+103)+(102+101+103)+(103+101+102+105)+(105+106)+(106+103)=1443
+ *
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_a_00280_A1 {
+    Cycle_a_00280_A2 a2_0;
+    @Unowned
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00280_A2 {
+    @Weak
+    Cycle_a_00280_A1 a1_0;
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00280_A3 {
+    @Weak
+    Cycle_a_00280_A1 a1_0;
+    @Weak
+    Cycle_a_00280_A2 a2_0;
+    Cycle_a_00280_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00280_A5 {
+    @Unowned
+    Cycle_a_00280_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00280_A6 {
+    @Unowned
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class RCAnnotationMultiCycle {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1443)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0403-rc-Annotation-RCAnnotationMultiCycle2/RCAnnotationMultiCycle2.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0403-rc-Annotation-RCAnnotationMultiCycle2/RCAnnotationMultiCycle2.java
new file mode 100644
index 0000000000000000000000000000000000000000..94c5400a0038758ae8999fe2f1c4f2488f81cbdb
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0403-rc-Annotation-RCAnnotationMultiCycle2/RCAnnotationMultiCycle2.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RCAnnotationMultiCycle2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00370 for @Weak and @Unowned Test
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationMultiCycle2.java
+ *- @ExecuteClass: RCAnnotationMultiCycle2
+ *- @ExecuteArgs:
+ *  A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5 A10; A5 depend A6 A8
+ * A7 depend A2 ; A8 depend A7;
+ * A8 depend A6 ; A10 depend A9;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109 A10.a=1001
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105+110)+(104+101)+(105+106+108)+(106+101+103)+(107+102)+(108+107)+(109+106)+(110+109)=2623
+ *
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_a_00370_A1 {
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00370_A2 {
+    Cycle_a_00370_A3 a3_0;
+    @Unowned
+    Cycle_a_00370_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00370_A3 {
+    @Weak
+    Cycle_a_00370_A1 a1_0;
+    Cycle_a_00370_A5 a5_0;
+    Cycle_a_00370_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a10_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a10_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A4 {
+    @Unowned
+    Cycle_a_00370_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00370_A5 {
+    @Unowned
+    Cycle_a_00370_A6 a6_0;
+    Cycle_a_00370_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00370_A6 {
+    @Unowned
+    Cycle_a_00370_A1 a1_0;
+    @Unowned
+    Cycle_a_00370_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A7 {
+    @Unowned
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A8 {
+    Cycle_a_00370_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A9 {
+    @Unowned
+    Cycle_a_00370_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A9(String strObjectName) {
+        a6_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00370_A10 {
+    @Unowned
+    Cycle_a_00370_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A10(String strObjectName) {
+        a9_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+public class RCAnnotationMultiCycle2 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.sum + a1_main.a2_0.a3_0.a10_0.sum;
+
+        if (result == 2623)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/RCAnnotationMultiCycleThread.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/RCAnnotationMultiCycleThread.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d6277689479c4a5b9011f251b3fc59026ef9720
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/RCAnnotationMultiCycleThread.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationMultiCycleThread.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationMultiCycle to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationMultiCycleThread.java
+ *- @ExecuteClass: RCAnnotationMultiCycleThread
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_am_00280 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1443)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00280_A1 {
+        Cycle_a_00280_A2 a2_0;
+        @Unowned
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A2 {
+        @Weak
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A3 {
+        @Weak
+        Cycle_a_00280_A1 a1_0;
+        @Weak
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A5 {
+        @Unowned
+        Cycle_a_00280_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A6 {
+        @Unowned
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationMultiCycleThread {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00280 A1_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A2_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A3_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A4_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A5_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A6_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+
+        A1_Cycle_am_00280.start();
+        A2_Cycle_am_00280.start();
+        A3_Cycle_am_00280.start();
+        A4_Cycle_am_00280.start();
+        A5_Cycle_am_00280.start();
+        A6_Cycle_am_00280.start();
+
+        try {
+            A1_Cycle_am_00280.join();
+            A2_Cycle_am_00280.join();
+            A3_Cycle_am_00280.join();
+            A4_Cycle_am_00280.join();
+            A5_Cycle_am_00280.join();
+            A6_Cycle_am_00280.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00280.check() && A2_Cycle_am_00280.check() && A3_Cycle_am_00280.check() && A4_Cycle_am_00280.check() && A5_Cycle_am_00280.check() && A6_Cycle_am_00280.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/RCAnnotationMultiCycleThread2.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/RCAnnotationMultiCycleThread2.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd0f1f0e58cf8f44043f71940b8338534de4cd05
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/RCAnnotationMultiCycleThread2.java
@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationMultiCycleThread2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationMultiCycle2 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationMultiCycleThread2.java
+ *- @ExecuteClass: RCAnnotationMultiCycleThread2
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_am_00370 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.sum + a1_main.a2_0.a3_0.a10_0.sum;
+
+        if (result == 2623)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00370_A1 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A2 {
+        Cycle_a_00370_A3 a3_0;
+        @Unowned
+        Cycle_a_00370_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A3 {
+        @Weak
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A5 a5_0;
+        Cycle_a_00370_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A4 {
+        @Unowned
+        Cycle_a_00370_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A5 {
+        @Unowned
+        Cycle_a_00370_A6 a6_0;
+        Cycle_a_00370_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A6 {
+        @Unowned
+        Cycle_a_00370_A1 a1_0;
+        @Unowned
+        Cycle_a_00370_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A7 {
+        @Unowned
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A8 {
+        Cycle_a_00370_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A9 {
+        @Unowned
+        Cycle_a_00370_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A10 {
+        @Unowned
+        Cycle_a_00370_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationMultiCycleThread2 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00370 A1_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A2_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A3_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A4_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A5_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A6_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+
+        A1_Cycle_am_00370.start();
+        A2_Cycle_am_00370.start();
+        A3_Cycle_am_00370.start();
+        A4_Cycle_am_00370.start();
+        A5_Cycle_am_00370.start();
+        A6_Cycle_am_00370.start();
+
+        try {
+            A1_Cycle_am_00370.join();
+            A2_Cycle_am_00370.join();
+            A3_Cycle_am_00370.join();
+            A4_Cycle_am_00370.join();
+            A5_Cycle_am_00370.join();
+            A6_Cycle_am_00370.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00370.check() && A2_Cycle_am_00370.check() && A3_Cycle_am_00370.check() && A4_Cycle_am_00370.check() && A5_Cycle_am_00370.check() && A6_Cycle_am_00370.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0419-rc-Annotation-RCUnownedLocalTest/RCUnownedLocalTest.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0419-rc-Annotation-RCUnownedLocalTest/RCUnownedLocalTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf5bfc07c788e287a4be621b54c86fde5b7a7c38
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0419-rc-Annotation-RCUnownedLocalTest/RCUnownedLocalTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/annotation/RCUnownedLocalTest
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:方法中添加@UnownedLocal,没有环泄露
+ *- @Brief:functionTest
+ * 方法中添加@UnownedLocal,没有环泄露
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedLocalTest.java
+ *- @ExecuteClass: RCUnownedLocalTest
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.UnownedLocal;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class RCUnownedLocalTest {
+    static Integer a = new Integer(1);
+    static Object[] arr = new Object[]{1, 2, 3};
+
+    @UnownedLocal
+    static int method(Integer a, Object[] arr) {
+        int check = 0;
+        Integer c = a + a;
+        if (c == 2) {
+            check++;
+        } else {
+            check--;
+        }
+        for (Object array : arr) {
+            //System.out.println(array);
+            check++;
+        }
+        return check;
+    }
+
+    public static void main(String[] args) {
+        int result = method(a, arr);
+        if (result == 4) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0420-rc-Annotation-RCUnownedLocalThreadTest/RCUnownedLocalThreadTest.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0420-rc-Annotation-RCUnownedLocalThreadTest/RCUnownedLocalThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c63a9d49ea0386c650ac131025a09c899f34f966
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0420-rc-Annotation-RCUnownedLocalThreadTest/RCUnownedLocalThreadTest.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/RCUnownedLocalThreadTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change CaseRC0419 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedLocalThreadTest.java
+ *- @ExecuteClass: RCUnownedLocalThreadTest
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.*;
+
+import java.util.LinkedList;
+import java.util.List;
+
+class RCUnownedLocalTest extends Thread {
+    private boolean checkout;
+
+    Integer a = new Integer(1);
+    Object[] arr = new Object[]{1, 2, 3};
+
+    @UnownedLocal
+    int method(Integer a, Object[] arr) {
+        int check = 0;
+        Integer c = a + a;
+        if (c == 2) {
+            check++;
+        } else {
+            check--;
+        }
+        for (Object array : arr) {
+            //System.out.println(array);
+            check++;
+        }
+        return check;
+    }
+
+    public void run() {
+        int result = method(a, arr);
+        if (result == 4) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println("result:" + result);
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+public class RCUnownedLocalThreadTest {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RCUnownedLocalTest rcTest1 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest2 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest3 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest4 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest5 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest6 = new RCUnownedLocalTest();
+
+        rcTest1.start();
+        rcTest2.start();
+        rcTest3.start();
+        rcTest4.start();
+        rcTest5.start();
+        rcTest6.start();
+
+        try {
+            rcTest1.join();
+            rcTest2.join();
+            rcTest3.join();
+            rcTest4.join();
+            rcTest5.join();
+            rcTest6.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (rcTest1.check() && rcTest2.check() && rcTest3.check() && rcTest4.check() && rcTest5.check() && rcTest6.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0421-rc-Annotation-RCUnownedOuterTest/RCUnownedOuterTest.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0421-rc-Annotation-RCUnownedOuterTest/RCUnownedOuterTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..884b379667c8f1f988acad39808db37c1750265e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0421-rc-Annotation-RCUnownedOuterTest/RCUnownedOuterTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/annotation/RCUnownedOuterTest
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:在内部类和内部匿名类添加@UnownedOuter,没有环泄露
+ *- @Brief:functionTest
+ * 在内部匿名类和内部类添加@UnownedOuter,没有环泄露
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedOuterTest.java
+ *- @ExecuteClass: RCUnownedOuterTest
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.UnownedOuter;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class RCUnownedOuterTest {
+
+
+    public static void main(String[] args) {
+        UnownedAnnoymous unownedAnnoymous = new UnownedAnnoymous();
+        unownedAnnoymous.anonymousCapture();
+
+        UnownedInner unownedInner = new UnownedInner();
+        unownedInner.method();
+        UnownedInner.InnerClass innerClass = unownedInner.new InnerClass();
+        innerClass.myName();
+        if (unownedAnnoymous.checkAnnoy == 1 && unownedInner.checkInner == 1) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("unownedAnnoymous.checkAnnoy:" + unownedAnnoymous.checkAnnoy);
+            System.out.println("unownedInner.checkInner:" + unownedInner.checkInner);
+        }
+    }
+
+}
+
+class UnownedInner {
+    String name = "test";
+    int checkInner = 0;
+    InnerClass innerClass;
+
+    void method() {
+        innerClass = new InnerClass();
+    }
+
+    @UnownedOuter
+    class InnerClass {
+        void myName() {
+            checkInner = 0;
+            String myname;
+            myname = name + name;
+            if (myname.equals("testtest")) {
+                checkInner++;
+            }
+        }
+    }
+}
+
+class UnownedAnnoymous {
+    String name = "test";
+    static int checkAnnoy;
+
+    void anonymousCapture() {
+        Runnable r = new Runnable() {
+            @UnownedOuter
+            @Override
+            public void run() {
+                checkAnnoy = 0;
+                String myName = name + name;
+                if (myName.equals("testtest")) {
+                    checkAnnoy++;
+                }
+            }
+        };
+        r.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/RC0428-rc-Annotation-RCMixThreadTest/RCMixThreadTest.java b/test/testsuite/ouroboros/memory_management/Annotation/RC0428-rc-Annotation-RCMixThreadTest/RCMixThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a76c53eed60300c81e89ff251e9820a39cf14fbd
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/RC0428-rc-Annotation-RCMixThreadTest/RCMixThreadTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/annotation/Permanent/RCMixThreadTest
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:多线程下调用Weak 或Unowned和Permanent一起用在一个对象的case，验证是否能够正常被释放
+ *- @Brief:functionTest
+ * 多线程下调用Weak 或Unowned和Permanent一起用在一个对象的case，验证是否能够正常被释放
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCMixThreadTest.java
+ *- @ExecuteClass: RCMixThreadTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.*;
+
+
+public class RCMixThreadTest {
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+    }
+
+    public static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCMixTest_Weak rcMixTest_weak = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak2 = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak3 = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak4 = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak5 = new RCMixTest_Weak();
+
+        rcMixTest_weak.start();
+        rcMixTest_weak2.start();
+        rcMixTest_weak3.start();
+        rcMixTest_weak4.start();
+        rcMixTest_weak5.start();
+
+        rcMixTest_weak.join();
+        rcMixTest_weak2.join();
+        rcMixTest_weak3.join();
+        rcMixTest_weak4.join();
+        rcMixTest_weak5.join();
+    }
+}
+
+
+class RCMixTest_Weak extends Thread {
+
+    public void run() {
+        new Test_A_Weak().test();
+    }
+}
+
+
+class Test_A_Weak {
+    @Weak
+    Test_B_Weak bb;
+    Test_B_Weak bb2;
+
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("NullPointerException");
+        }
+        bb2.run();
+    }
+
+    private void foo() {
+        bb = new @Permanent Test_B_Weak();
+        bb2 = new Test_B_Weak();
+    }
+}
+
+class Test_B_Weak {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02/RCUnownedRefUncycle02.java b/test/testsuite/ouroboros/memory_management/Annotation/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02/RCUnownedRefUncycle02.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc7565609d3a767e7d68a64fad3af3b4da68d2d8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02/RCUnownedRefUncycle02.java
@@ -0,0 +1,363 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RCUnownedRefUncycle02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00180 for @Unowned Test
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefUncycle02.java
+ *- @ExecuteClass: RCUnownedRefUncycle02
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+class Nocycle_a_00180_A1 {
+    Nocycle_a_00180_B1 b1_0;
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_A2 {
+    Nocycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_A3 {
+    @Unowned
+    Nocycle_a_00180_B2 b2_0;
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_a_00180_A4 {
+    Nocycle_a_00180_B3 b3_0;
+    @Unowned
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_B1 {
+    Nocycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_B2 {
+    Nocycle_a_00180_C1 c1_0;
+    @Unowned
+    Nocycle_a_00180_D1 d1_0;
+    @Unowned
+    Nocycle_a_00180_D2 d2_0;
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_B3 {
+    @Unowned
+    Nocycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_C1 {
+    @Unowned
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_00180_C2 {
+    @Unowned
+    Nocycle_a_00180_D2 d2_0;
+    @Unowned
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class RCUnownedRefUncycle02 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+        a3_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = a2_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a1_main.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+        a4_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a3_main.c2_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum + a1_main.d1_0.sum + a2_main.b2_0.c1_0.sum;
+        if (result == 9260)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Annotation/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2/RCUnownedRefUncycleThread2.java b/test/testsuite/ouroboros/memory_management/Annotation/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2/RCUnownedRefUncycleThread2.java
new file mode 100644
index 0000000000000000000000000000000000000000..c464180a52e25e37058f1bbd548c31f46d9ebf09
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Annotation/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2/RCUnownedRefUncycleThread2.java
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/RCUnownedRefUncycleThread2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCUnownedRefUncycle02 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefUncycleThread2.java
+ *- @ExecuteClass: RCUnownedRefUncycleThread2
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+class ThreadRc_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+        a3_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = a2_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a1_main.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+        a4_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a3_main.c2_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum + a1_main.d1_0.sum + a2_main.b2_0.c1_0.sum;
+
+        if (result == 9260)
+            checkout = true;
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00180_A1 {
+        Nocycle_a_00180_B1 b1_0;
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A2 {
+        Nocycle_a_00180_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A3 {
+        @Unowned
+        Nocycle_a_00180_B2 b2_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A4 {
+        Nocycle_a_00180_B3 b3_0;
+        @Unowned
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B1 {
+        Nocycle_a_00180_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B2 {
+        Nocycle_a_00180_C1 c1_0;
+        @Unowned
+        Nocycle_a_00180_D1 d1_0;
+        @Unowned
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B3 {
+        @Unowned
+        Nocycle_a_00180_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C1 {
+        @Unowned
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C2 {
+        @Unowned
+        Nocycle_a_00180_D2 d2_0;
+        @Unowned
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class RCUnownedRefUncycleThread2 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00180 A1_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A2_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A3_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A4_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A5_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A6_00180 = new ThreadRc_00180();
+
+        A1_00180.start();
+        A2_00180.start();
+        A3_00180.start();
+        A4_00180.start();
+        A5_00180.start();
+        A6_00180.start();
+
+        try {
+            A1_00180.join();
+            A2_00180.join();
+            A3_00180.join();
+            A4_00180.join();
+            A5_00180.join();
+            A6_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00180.check() && A2_00180.check() && A3_00180.check() && A4_00180.check() && A5_00180.check() && A6_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0366-rc-ArrayOptimization-RC_Array_01/RC_Array_01.java b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0366-rc-ArrayOptimization-RC_Array_01/RC_Array_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..90e9b42f2eaac14c582549ea1eed5aa1397bf6f9
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0366-rc-ArrayOptimization-RC_Array_01/RC_Array_01.java
@@ -0,0 +1,432 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/optimization/RC_Array_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D int array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_01.java
+ *- @ExecuteClass: RC_Array_01
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_001 {
+    //Parent interface
+    volatile int[] base1;
+    int[][] base2;
+    int[][] base21;
+    int[][][] base3;
+}
+
+public class RC_Array_01 extends Base_001 {
+    static int check_count = 0;
+    static int[] arr1 = {10, 20, 30, 40};
+    static int[][] arr2 = {{10, 20, 30, 40}, {40, 50}, {60}};
+    static int[][] arr21 = {{40, 50, 60, 30}, {70, 80}, {90}};
+    static int[][][] arr3 = {arr2, arr21};
+
+    private RC_Array_01() {
+        base1 = new int[]{10, 20, 30, 40};
+        base2 = new int[][]{{10, 20, 30, 40}, {40, 50}, {60}};
+        base21 = new int[][]{{40, 50, 60, 30}, {70, 80}, {90}};
+        base3 = new int[][][]{{{10, 20, 30, 40}, {40, 50}, {60}}, {{40, 50, 60, 30}, {70, 80}, {90}}};
+    }
+
+    private RC_Array_01(int[] intar) {
+        base1 = intar;
+    }
+
+    private RC_Array_01(int[][] intarr) {
+        base2 = intarr;
+    }
+
+    private RC_Array_01(int[][][] intarrr) {
+        base3 = intarrr;
+    }
+
+    private RC_Array_01(int[] intar, int[][] intarr, int[][][] intarrr) {
+        base1 = intar;
+        base2 = intarr;
+        base3 = intarrr;
+    }
+
+    public static void main(String[] args) {
+        final int[] TEST1 = {10, 20, 30, 40};
+        final int[][] TEST2 = {TEST1, {40, 50}, {60}};
+        final int[][] TEST21 = {{40, 50, 60, 30}, {70, 80}, {90}};
+        final int[][][] TEST3 = {TEST2, TEST21};
+        //Initialization check
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4, TEST1, TEST2, TEST3);
+        test01(4, arr1, arr2, arr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4, TEST1, TEST2, TEST3);
+        test02(4, arr1, arr2, arr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2 && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_01_test01 function return value to the parameter third and judged.
+        //RC_Array_01_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if (TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_01 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_01_test02();
+
+        //Get an array object by returning a function call
+        int[] getarr1 = RC_Array_get01();
+        int[][] getarr2 = RC_Array_get02();
+        int[][][] getarr3 = RC_Array_get03();
+        if (getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        Boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if (check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, int[] second, int[][] third, int[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        int[] xyz = {23, 24, 25, 26};
+        int[][] xyz2 = {{23, 24, 25, 26}, {23, 24}, {23}};
+        int[][][] xyz3 = {xyz2, xyz2};
+        if (second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2) {
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, int[] second, int[][] third, int[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        int[] xyz = {23, 24, 25, 26};
+        int[][] xyz2 = {{23, 24, 25, 26}, {23, 24}, {23}};
+        int[][][] xyz3 = {xyz2, xyz2};
+        second = (int[]) change(second, xyz);
+        third = (int[][]) change(third, xyz2);
+        four = (int[][][]) change(four, xyz3);
+        if (second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(int[][] third) {
+        //The test03 interface is called, and the RC_Array_01_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_01_test01();
+        if (third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static int[] RC_Array_get01() {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static int[][] RC_Array_get02() {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static int[][][] RC_Array_get03() {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static int[] RC_Array_set01() {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        int[] value1 = {23, 24, 25, 26};
+        RC_Array_01 rctest = new RC_Array_01(value1);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new int[]{88, 10, 02, 11};
+        if (rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static int[][] RC_Array_set02() {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        int[][] value2 = {{23, 24, 25, 26}, {23, 24}, {23}};
+        RC_Array_01 rctest = new RC_Array_01(value2);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base2 = new int[][]{{88, 10, 02, 11}, {10, 92}, {16}};
+        if (rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static int[][][] RC_Array_set03() {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        int[][][] value3 = {{{10, 20, 30, 40}, {40, 50}, {60}}, {{40, 50, 60, 30}, {70, 80}, {90}}};
+        RC_Array_01 rctest = new RC_Array_01(value3);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base3 = new int[][][]{{{88, 10, 02, 11}, {10, 92}, {12}}, {{88, 10, 02, 11}, {10, 92}, {16}}};
+        if (rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static int[][] RC_Array_01_test01() {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to the newly created
+        // object field, and judge the result
+        int[] value1 = {23, 24, 25, 26};
+        int[][] value2 = {{23, 24, 25, 26}, {23, 24}, {23}};
+        int[][][] value3 = {value2, value2};
+        RC_Array_01 rctest = new RC_Array_01(value1, value2, value3);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new int[]{88, 10, 02, 11};
+        rctest.base2 = new int[][]{{88, 10, 02, 11}, {10, 92}, {16}};
+        rctest.base21 = new int[][]{{88, 10, 02, 11}, {10, 92}, {12}};
+        rctest.base3 = new int[][][]{{{88, 10, 02, 11}, {10, 92}, {12}}, {{88, 10, 02, 11}, {10, 92}, {16}}};
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_01_test01");
+        return rctest.base21;
+    }
+
+    private static int[] RC_Array_final01() {
+        final int[] VALUE1 = {23, 24, 25, 26};
+        return VALUE1;
+    }
+
+    private static int[][] RC_Array_final02() {
+        final int[][] VALUE2 = {{23, 24, 25, 26}, {23, 24}, {23}};
+        return VALUE2;
+    }
+
+    private static int[][][] RC_Array_final03() {
+        final int[][][] VALUE3 = {{{10, 20, 30, 40}, {40, 50}, {60}}, {{40, 50, 60, 30}, {70, 80}, {90}}};
+        return VALUE3;
+    }
+
+    private static int[][] RC_Array_01_test02() {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_01 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final int[] VALUE1 = RC_Array_final01();
+        final int[][] VALUE2 = RC_Array_final02();
+        final int[][][] VALUE3 = RC_Array_final03();
+        RC_Array_01 rctest = new RC_Array_01();
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_01_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_01_test02_2");
+        return VALUE2;
+    }
+
+    private static Boolean RC_Array_Exception() {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        int[] value1 = RC_Array_final01();
+        int[][] value2 = RC_Array_final02();
+        int[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getInt(value1, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            value1[5] = 23;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.setInt(value1, 5, 10);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getInt(RC_Array_final01(), 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getInt(value2[5], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getInt(value2[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getInt(RC_Array_final02()[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getInt(value3[0][3], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getInt(value3[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getInt(RC_Array_final03()[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getInt(value2, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        try {
+            Array.getInt(value3, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        //NumberFormatException
+        try {
+            Integer i = new Integer(10);
+            Array.setInt(value1, 0, i.decode("abc"));
+        } catch (NumberFormatException e) {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_01 rc1 = new RC_Array_01();
+        try {
+            Base_001 bs1 = new Base_001();
+            rc1 = (RC_Array_01) bs1;
+            rc1.base1[0] = 123;
+        } catch (ClassCastException e) {
+            if (rc1.base1[0] != 123)
+                check++;
+        }
+
+        //Whether the judgment value is normal after Exception
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getInt(value1, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getInt(value2, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getInt(value3, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        if (check == 19)
+            return true;
+        else
+            return false;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0367-rc-ArrayOptimization-RC_Array_02/RC_Array_02.java b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0367-rc-ArrayOptimization-RC_Array_02/RC_Array_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..95799427e1f3e88e761215f82c21d7f720b45ba2
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0367-rc-ArrayOptimization-RC_Array_02/RC_Array_02.java
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/optimization/RC_Array_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D String array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static、literial
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_02.java
+ *- @ExecuteClass: RC_Array_02
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.regex.PatternSyntaxException;
+
+class Base_002 {
+    //Parent interface
+    volatile String[] base1;
+    String[][] base2;
+    String[][] base21;
+    String[][][] base3;
+}
+
+public class RC_Array_02 extends Base_002 {
+    static int check_count = 0;
+    static String[] arr1 = {"10", "20", "30", "40"};
+    static String[][] arr2 = {{"10", "20", "30", "40"}, {"40", "50"}, {"60"}};
+    static String[][] arr21 = {{"40", "50", "60", "30"}, {"70", "80"}, {"90"}};
+    static String[][][] arr3 = {arr2, arr21};
+    //literial type data
+    static String literial_v = "abc";
+    static String[] arstr1 = {literial_v, literial_v, literial_v, literial_v};
+    static String[][] arstr2 = {{"abc", "abc", "abc", "abc"}, {"abc", "abc"}, {literial_v}};
+    static String[][][] arstr3 = {arstr2, arstr2};
+
+    private RC_Array_02() {
+        base1 = new String[]{"10", "20", "30", "40"};
+        base2 = new String[][]{{"10", "20", "30", "40"}, {"40", "50"}, {"60"}};
+        base21 = new String[][]{{"40", "50", "60", "30"}, {"70", "80"}, {"90"}};
+        base3 = new String[][][]{{{"10", "20", "30", "40"}, {"40", "50"}, {"60"}}, {{"40", "50", "60", "30"}, {"70", "80"}, {"90"}}};
+    }
+
+    private RC_Array_02(String[] Stringar) {
+        base1 = Stringar;
+    }
+
+    private RC_Array_02(String[][] Stringarr) {
+        base2 = Stringarr;
+    }
+
+    private RC_Array_02(String[][][] Stringarrr) {
+        base3 = Stringarrr;
+    }
+
+    private RC_Array_02(String[] Stringar, String[][] Stringarr, String[][][] Stringarrr) {
+        base1 = Stringar;
+        base2 = Stringarr;
+        base3 = Stringarrr;
+    }
+
+    public static void main(String[] args) {
+        final String[] TEST1 = {"10", "20", "30", "40"};
+        final String[][] TEST2 = {TEST1, {"40", "50"}, {"60"}};
+        final String[][] TEST21 = {{"40", "50", "60", "30"}, {"70", "80"}, {"90"}};
+        final String[][][] TEST3 = {TEST2, TEST21};
+        //literial type data
+        final String literial_v = "abc";
+        final String[] arstrr1 = {literial_v, literial_v, literial_v, literial_v};
+        final String[][] arstrr2 = {{"abc", "abc", "abc", "abc"}, {"abc", "abc"}, {literial_v}};
+        final String[][][] arstrr3 = {arstrr2, arstrr2};
+
+        //Initialization check
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2
+                && arstrr1.length == 4 && arstrr2.length == 3 && arstrr3.length == 2
+                && arstr1.length == 4 && arstr2.length == 3 && arstr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult String step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4, TEST1, TEST2, TEST3);
+        test01(4, arr1, arr2, arr3);
+        test01(4, arstr1, arstr2, arstr3);
+        test01(4, arstrr1, arstrr2, arstrr3);
+
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2
+                && arstrr1.length == 4 && arstrr2.length == 3 && arstrr3.length == 2
+                && arstr1.length == 4 && arstr2.length == 3 && arstr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4, TEST1, TEST2, TEST3);
+        test02(4, arr1, arr2, arr3);
+        test02(4, arstr1, arstr2, arstr3);
+        test02(4, arstrr1, arstrr2, arstrr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2
+                && arstrr1.length == 4 && arstrr2.length == 3 && arstrr3.length == 2
+                && arstr1.length == 4 && arstr2.length == 3 && arstr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_02_test01 function return value to the parameter third and judged.
+        //RC_Array_02_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if (TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_02() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_02_test02();
+
+        //Get an array object by returning a function call
+        String[] getarr1 = RC_Array_get01();
+        String[][] getarr2 = RC_Array_get02();
+        String[][][] getarr3 = RC_Array_get03();
+        if (getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        Boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if (check_count == 28)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, String[] second, String[][] third, String[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        String[] xyz = {"23", "24", "25", "26"};
+        String[][] xyz2 = {{"23", "24", "25", "26"}, {"23", "24"}, {"23"}};
+        String[][][] xyz3 = {xyz2, xyz2};
+        if (second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2) {
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, String[] second, String[][] third, String[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        String[] xyz = {"23", "24", "25", "26"};
+        String[][] xyz2 = {{"23", "24", "25", "26"}, {"23", "24"}, {"23"}};
+        String[][][] xyz3 = {xyz2, xyz2};
+        second = (String[]) change(second, xyz);
+        third = (String[][]) change(third, xyz2);
+        four = (String[][][]) change(four, xyz3);
+        if (second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(String[][] third) {
+        //The test03 interface is called, and the RC_Array_02_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_02_test01();
+        if (third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static String[] RC_Array_get01() {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static String[][] RC_Array_get02() {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static String[][][] RC_Array_get03() {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static String[] RC_Array_set01() {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        String[] value1 = {"23", "24", "25", "26"};
+        RC_Array_02 rctest = new RC_Array_02(value1);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new String[]{"88", "10", "02", "11"};
+        if (rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static String[][] RC_Array_set02() {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        String[][] value2 = {{"23", "24", "25", "26"}, {"23", "24"}, {"23"}};
+        RC_Array_02 rctest = new RC_Array_02(value2);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base2 = new String[][]{{"88", "10", "02", "11"}, {"10", "92"}, {"16"}};
+        if (rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static String[][][] RC_Array_set03() {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        String[][][] value3 = {{{"10", "20", "30", "40"}, {"40", "50"}, {"60"}}, {{"40", "50", "60", "30"}, {"70", "80"}, {"90"}}};
+        RC_Array_02 rctest = new RC_Array_02(value3);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base3 = new String[][][]{{{"88", "10", "02", "11"}, {"10", "92"}, {"12"}}, {{"88", "10", "02", "11"}, {"10", "92"}, {"16"}}};
+        if (rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static String[][] RC_Array_02_test01() {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_02, and assign a value to the newly created
+        // object field, and judge the result
+        String[] value1 = {"23", "24", "25", "26"};
+        String[][] value2 = {{"23", "24", "25", "26"}, {"23", "24"}, {"23"}};
+        String[][][] value3 = {value2, value2};
+        RC_Array_02 rctest = new RC_Array_02(value1, value2, value3);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new String[]{"88", "10", "02", "11"};
+        rctest.base2 = new String[][]{{"88", "10", "02", "11"}, {"10", "92"}, {"16"}};
+        rctest.base21 = new String[][]{{"88", "10", "02", "11"}, {"10", "92"}, {"12"}};
+        rctest.base3 = new String[][][]{{{"88", "10", "02", "11"}, {"10", "92"}, {"12"}}, {{"88", "10", "02", "11"}, {"10", "92"}, {"16"}}};
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_02_test01");
+        return rctest.base21;
+    }
+
+    private static String[] RC_Array_final01() {
+        final String[] VALUE1 = {"23", "24", "25", "26"};
+        return VALUE1;
+    }
+
+    private static String[][] RC_Array_final02() {
+        final String[][] VALUE2 = {{"23", "24", "25", "26"}, {"23", "24"}, {"23"}};
+        return VALUE2;
+    }
+
+    private static String[][][] RC_Array_final03() {
+        final String[][][] VALUE3 = {{{"10", "20", "30", "40"}, {"40", "50"}, {"60"}}, {{"40", "50", "60", "30"}, {"70", "80"}, {"90"}}};
+        return VALUE3;
+    }
+
+    private static String[][] RC_Array_02_test02() {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_02 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final String[] VALUE1 = RC_Array_final01();
+        final String[][] VALUE2 = RC_Array_final02();
+        final String[][][] VALUE3 = RC_Array_final03();
+        RC_Array_02 rctest = new RC_Array_02();
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_02_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_02_test02_2");
+        return VALUE2;
+    }
+
+    private static Boolean RC_Array_Exception() {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        String[] value1 = RC_Array_final01();
+        String[][] value2 = RC_Array_final02();
+        String[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.get(value1, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            value1[5] = "error";
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.set(value1, 5, "10");
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.get(RC_Array_final01(), 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.get(value2[5], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.get(value2[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.get(RC_Array_final02()[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.get(value3[0][3], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.get(value3[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.get(RC_Array_final03()[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+
+        //IndexOutOfBoundsException
+        try {
+            char[] ch1 = {'h', 'x', 'c', 't'};
+            Array.set(RC_Array_final03()[0][0], 0, String.valueOf(ch1, 5, 2));
+        } catch (IndexOutOfBoundsException e) {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_02 rc1 = new RC_Array_02();
+        try {
+            Base_002 bs1 = new Base_002();
+            rc1 = (RC_Array_02) bs1;
+            rc1.base1[0] = "kitty";
+        } catch (ClassCastException e) {
+            if (rc1.base1[0] != "kitty")
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.get(value1, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.get(value2, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.get(value3, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 17)
+            return true;
+        else
+            return false;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0368-rc-ArrayOptimization-RC_Array_03/RC_Array_03.java b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0368-rc-ArrayOptimization-RC_Array_03/RC_Array_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c2335152598ec00989688ba760ea68782dfa069
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0368-rc-ArrayOptimization-RC_Array_03/RC_Array_03.java
@@ -0,0 +1,427 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/optimization/RC_Array_03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D Char array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_03.java
+ *- @ExecuteClass: RC_Array_03
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_003 {
+    //Parent interface
+    volatile char[] base1;
+    char[][] base2;
+    char[][] base21;
+    char[][][] base3;
+}
+
+public class RC_Array_03 extends Base_003 {
+    static int check_count = 0;
+    static char[] arr1 = {'a', 'b', 'c', 'd'};
+    static char[][] arr2 = {{'a', 'b', 'c', 'd'}, {'e', 'f'}, {'g'}};
+    static char[][] arr21 = {{'h', 'i', 'j', 'k'}, {'l', 'm'}, {'n'}};
+    static char[][][] arr3 = {arr2, arr21};
+
+    private RC_Array_03() {
+        base1 = new char[]{'a', 'b', 'c', 'd'};
+        base2 = new char[][]{{'a', 'b', 'c', 'd'}, {'e', 'f'}, {'g'}};
+        base21 = new char[][]{{'h', 'i', 'j', 'k'}, {'l', 'm'}, {'n'}};
+        base3 = new char[][][]{{{'a', 'b', 'c', 'd'}, {'e', 'f'}, {'g'}}, {{'h', 'i', 'j', 'k'}, {'l', 'm'}, {'n'}}};
+    }
+
+    private RC_Array_03(char[] charar) {
+        base1 = charar;
+    }
+
+    private RC_Array_03(char[][] chararr) {
+        base2 = chararr;
+    }
+
+    private RC_Array_03(char[][][] chararrr) {
+        base3 = chararrr;
+    }
+
+    private RC_Array_03(char[] charar, char[][] chararr, char[][][] chararrr) {
+        base1 = charar;
+        base2 = chararr;
+        base3 = chararrr;
+    }
+
+    public static void main(String[] args) {
+        final char[] TEST1 = {'1', '2', '3', '4'};
+        final char[][] TEST2 = {TEST1, {'4', '5'}, {'6'}};
+        final char[][] TEST21 = {{'4', '5', '6', '3'}, {'7', '8'}, {'9'}};
+        final char[][][] TEST3 = {TEST2, TEST21};
+
+        //Initialization check
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult char step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4, TEST1, TEST2, TEST3);
+        test01(4, arr1, arr2, arr3);
+
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4, TEST1, TEST2, TEST3);
+        test02(4, arr1, arr2, arr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_03_test01 function return value to the parameter third and judged.
+        //RC_Array_03_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if (TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_03() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_03_test02();
+
+        //Get an array object by returning a function call
+        char[] getarr1 = RC_Array_get01();
+        char[][] getarr2 = RC_Array_get02();
+        char[][][] getarr3 = RC_Array_get03();
+        if (getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        Boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if (check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, char[] second, char[][] third, char[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        char[] xyz = {'h', 'x', 'w', 'g'};
+        char[][] xyz2 = {{'h', 'x', 'w', 'g'}, {'w', 'g'}, {'q'}};
+        char[][][] xyz3 = {xyz2, xyz2};
+        if (second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2) {
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, char[] second, char[][] third, char[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        char[] xyz = {'h', 'x', 'w', 'g'};
+        char[][] xyz2 = {{'h', 'x', 'w', 'g'}, {'w', 'g'}, {'q'}};
+        char[][][] xyz3 = {xyz2, xyz2};
+        second = (char[]) change(second, xyz);
+        third = (char[][]) change(third, xyz2);
+        four = (char[][][]) change(four, xyz3);
+        if (second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(char[][] third) {
+        //The test03 interface is called, and the RC_Array_03_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_03_test01();
+        if (third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static char[] RC_Array_get01() {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static char[][] RC_Array_get02() {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static char[][][] RC_Array_get03() {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static char[] RC_Array_set01() {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        char[] value1 = {'h', 'x', 'w', 'g'};
+        RC_Array_03 rctest = new RC_Array_03(value1);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new char[]{'8', '0', '2', '3'};
+        if (rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static char[][] RC_Array_set02() {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        char[][] value2 = {{'h', 'x', 'w', 'g'}, {'w', 'g'}, {'q'}};
+        RC_Array_03 rctest = new RC_Array_03(value2);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base2 = new char[][]{{'8', '0', '2', '3'}, {'w', 'g'}, {'q'}};
+        if (rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static char[][][] RC_Array_set03() {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        char[][][] value3 = {{{'1', '2', '3', '4'}, {'4', '5'}, {'6'}}, {{'4', '5', '6', '3'}, {'7', '8'}, {'9'}}};
+        RC_Array_03 rctest = new RC_Array_03(value3);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base3 = new char[][][]{{{'w', 'a', 'n', 'g'}, {'s', 'u'}, {'n'}}, {{'w', 'a', 'n', 'g'}, {'w', 'g'}, {'q'}}};
+        if (rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static char[][] RC_Array_03_test01() {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_03, and assign a value to the newly created
+        // object field, and judge the result
+        char[] value1 = {'h', 'x', 'w', 'g'};
+        char[][] value2 = {{'h', 'x', 'w', 'g'}, {'w', 'g'}, {'q'}};
+        char[][][] value3 = {value2, value2};
+        RC_Array_03 rctest = new RC_Array_03(value1, value2, value3);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new char[]{'w', 'a', 'n', 'g'};
+        rctest.base2 = new char[][]{{'w', 'a', 'n', 'g'}, {'w', 'g'}, {'q'}};
+        rctest.base21 = new char[][]{{'w', 'a', 'n', 'g'}, {'s', 'u'}, {'n'}};
+        rctest.base3 = new char[][][]{{{'w', 'a', 'n', 'g'}, {'s', 'u'}, {'n'}}, {{'w', 'a', 'n', 'g'}, {'w', 'g'}, {'q'}}};
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_03_test01");
+        return rctest.base21;
+    }
+
+    private static char[] RC_Array_final01() {
+        final char[] VALUE1 = {'h', 'x', 'w', 'g'};
+        return VALUE1;
+    }
+
+    private static char[][] RC_Array_final02() {
+        final char[][] VALUE2 = {{'h', 'x', 'w', 'g'}, {'w', 'g'}, {'q'}};
+        return VALUE2;
+    }
+
+    private static char[][][] RC_Array_final03() {
+        final char[][][] VALUE3 = {{{'1', '2', '3', '4'}, {'4', '5'}, {'6'}}, {{'4', '5', '6', '3'}, {'7', '8'}, {'9'}}};
+        return VALUE3;
+    }
+
+    private static char[][] RC_Array_03_test02() {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_03 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final char[] VALUE1 = RC_Array_final01();
+        final char[][] VALUE2 = RC_Array_final02();
+        final char[][][] VALUE3 = RC_Array_final03();
+        RC_Array_03 rctest = new RC_Array_03();
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_03_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_03_test02_2");
+        return VALUE2;
+    }
+
+    private static Boolean RC_Array_Exception() {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        char[] value1 = RC_Array_final01();
+        char[][] value2 = RC_Array_final02();
+        char[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getChar(value1, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            value1[5] = 'e';
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.setChar(value1, 5, '1');
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getChar(RC_Array_final01(), 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getChar(value2[5], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getChar(value2[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getChar(RC_Array_final02()[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getChar(value3[0][3], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getChar(value3[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getChar(RC_Array_final03()[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getChar(value2, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        try {
+            Array.getChar(value3, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_03 rc1 = new RC_Array_03();
+        try {
+            Base_003 bs1 = new Base_003();
+            rc1 = (RC_Array_03) bs1;
+            rc1.base1[0] = 'p';
+        } catch (ClassCastException e) {
+            if (rc1.base1[0] != 'p')
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getChar(value1, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getChar(value2, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getChar(value3, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0369-rc-ArrayOptimization-RC_Array_04/RC_Array_04.java b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0369-rc-ArrayOptimization-RC_Array_04/RC_Array_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f2f2a6f64d2de57fac2dcfb351e706728a5f8d5
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0369-rc-ArrayOptimization-RC_Array_04/RC_Array_04.java
@@ -0,0 +1,427 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/optimization/RC_Array_04.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D boolean array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_04.java
+ *- @ExecuteClass: RC_Array_04
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_004 {
+    //Parent interface
+    volatile boolean[] base1;
+    boolean[][] base2;
+    boolean[][] base21;
+    boolean[][][] base3;
+}
+
+public class RC_Array_04 extends Base_004 {
+    static int check_count = 0;
+    static boolean[] arr1 = {true, false, false, true};
+    static boolean[][] arr2 = {{true, false, false, true}, {false, false}, {true, true}};
+    static boolean[][] arr21 = {{false, true, false, true}, {true, false}, {false, true}};
+    static boolean[][][] arr3 = {arr2, arr21};
+
+    private RC_Array_04() {
+        base1 = new boolean[]{true, true, true, true};
+        base2 = new boolean[][]{{true, true, true, true}, {false, false}, {true, true}};
+        base21 = new boolean[][]{{false, true, true, true}, {false, true}, {true, true}};
+        base3 = new boolean[][][]{{{true, true, true, true}, {false, false}, {true, true}}, {{false, true, true, true}, {false, true}, {true, true}}};
+    }
+
+    private RC_Array_04(boolean[] booleanar) {
+        base1 = booleanar;
+    }
+
+    private RC_Array_04(boolean[][] booleanarr) {
+        base2 = booleanarr;
+    }
+
+    private RC_Array_04(boolean[][][] booleanarrr) {
+        base3 = booleanarrr;
+    }
+
+    private RC_Array_04(boolean[] booleanar, boolean[][] booleanarr, boolean[][][] booleanarrr) {
+        base1 = booleanar;
+        base2 = booleanarr;
+        base3 = booleanarrr;
+    }
+
+    public static void main(String[] args) {
+        final boolean[] TEST1 = {true, true, true, true};
+        final boolean[][] TEST2 = {TEST1, {false, false}, {true, true}};
+        final boolean[][] TEST21 = {{false, true, true, true}, {false, true}, {true, true}};
+        final boolean[][][] TEST3 = {TEST2, TEST21};
+
+        //Initialization check
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult boolean step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4, TEST1, TEST2, TEST3);
+        test01(4, arr1, arr2, arr3);
+
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4, TEST1, TEST2, TEST3);
+        test02(4, arr1, arr2, arr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_04_test01 function return value to the parameter third and judged.
+        //RC_Array_04_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if (TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_04() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_04_test02();
+
+        //Get an array object by returning a function call
+        boolean[] getarr1 = RC_Array_get01();
+        boolean[][] getarr2 = RC_Array_get02();
+        boolean[][][] getarr3 = RC_Array_get03();
+        if (getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if (check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, boolean[] second, boolean[][] third, boolean[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        boolean[] xyz = {false, true, false, true};
+        boolean[][] xyz2 = {{true, true, true, true}, {false, false}, {true}};
+        boolean[][][] xyz3 = {xyz2, xyz2};
+        if (second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2) {
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, boolean[] second, boolean[][] third, boolean[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        boolean[] xyz = {false, true, false, true};
+        boolean[][] xyz2 = {{true, true, true, true}, {false, false}, {true}};
+        boolean[][][] xyz3 = {xyz2, xyz2};
+        second = (boolean[]) change(second, xyz);
+        third = (boolean[][]) change(third, xyz2);
+        four = (boolean[][][]) change(four, xyz3);
+        if (second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(boolean[][] third) {
+        //The test03 interface is called, and the RC_Array_04_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_04_test01();
+        if (third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static boolean[] RC_Array_get01() {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static boolean[][] RC_Array_get02() {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static boolean[][][] RC_Array_get03() {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static boolean[] RC_Array_set01() {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        boolean[] value1 = {false, false, false, false};
+        RC_Array_04 rctest = new RC_Array_04(value1);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new boolean[]{true, true, true, true};
+        if (rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static boolean[][] RC_Array_set02() {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        boolean[][] value2 = {{true, true, true, true}, {false, false}, {true}};
+        RC_Array_04 rctest = new RC_Array_04(value2);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base2 = new boolean[][]{{false, false, false, false}, {false, false}, {true}};
+        if (rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static boolean[][][] RC_Array_set03() {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        boolean[][][] value3 = {{{true, true, true, true}, {false, false}, {true}}, {{false, false, false, false}, {false, false}, {true}}};
+        RC_Array_04 rctest = new RC_Array_04(value3);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base3 = new boolean[][][]{{{false, false, false, false}, {false, false}, {true}}, {{true, true, true, true}, {false, false}, {true}}};
+        if (rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static boolean[][] RC_Array_04_test01() {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_04, and assign a value to the newly created
+        // object field, and judge the result
+        boolean[] value1 = {true, true, true, true};
+        boolean[][] value2 = {{true, true, true, true}, {false, false}, {true}};
+        boolean[][][] value3 = {value2, value2};
+        RC_Array_04 rctest = new RC_Array_04(value1, value2, value3);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new boolean[]{false, false, false, false};
+        rctest.base2 = new boolean[][]{{false, false, false, false}, {false, false}, {true}};
+        rctest.base21 = new boolean[][]{{false, true, true, false}, {false, false}, {true}};
+        rctest.base3 = new boolean[][][]{{{false, false, false, false}, {false, false}, {true}}, {{false, true, true, false}, {false, false}, {true}}};
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_04_test01");
+        return rctest.base21;
+    }
+
+    private static boolean[] RC_Array_final01() {
+        final boolean[] VALUE1 = {true, true, true, true};
+        return VALUE1;
+    }
+
+    private static boolean[][] RC_Array_final02() {
+        final boolean[][] VALUE2 = {{false, false, false, false}, {false, false}, {true}};
+        return VALUE2;
+    }
+
+    private static boolean[][][] RC_Array_final03() {
+        final boolean[][][] VALUE3 = {{{false, true, true, false}, {false, false}, {true}}, {{false, false, false, false}, {false, false}, {true}}};
+        return VALUE3;
+    }
+
+    private static boolean[][] RC_Array_04_test02() {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_04 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final boolean[] VALUE1 = RC_Array_final01();
+        final boolean[][] VALUE2 = RC_Array_final02();
+        final boolean[][][] VALUE3 = RC_Array_final03();
+        RC_Array_04 rctest = new RC_Array_04();
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_04_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_04_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception() {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        boolean[] value1 = RC_Array_final01();
+        boolean[][] value2 = RC_Array_final02();
+        boolean[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getBoolean(value1, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            value1[5] = false;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.setBoolean(value1, 5, true);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(RC_Array_final01(), 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(value2[5], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(value2[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(RC_Array_final02()[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(value3[0][3], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(value3[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(RC_Array_final03()[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getBoolean(value2, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(value3, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_04 rc1 = new RC_Array_04();
+        try {
+            Base_004 bs1 = new Base_004();
+            rc1 = (RC_Array_04) bs1;
+            rc1.base1[0] = false;
+        } catch (ClassCastException e) {
+            if (rc1.base1[0] != false)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getBoolean(value1, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(value2, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getBoolean(value3, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0370-rc-ArrayOptimization-RC_Array_05/RC_Array_05.java b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0370-rc-ArrayOptimization-RC_Array_05/RC_Array_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..ffa833a991dd46f75e32d18f182d94771c1811ec
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0370-rc-ArrayOptimization-RC_Array_05/RC_Array_05.java
@@ -0,0 +1,427 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/optimization/RC_Array_05.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D byte array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_05.java
+ *- @ExecuteClass: RC_Array_05
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_005 {
+    //Parent interface
+    volatile byte[] base1;
+    byte[][] base2;
+    byte[][] base21;
+    byte[][][] base3;
+}
+
+public class RC_Array_05 extends Base_005 {
+    static int check_count = 0;
+    static byte[] arr1 = {1, 2, 3, 4};
+    static byte[][] arr2 = {{1, 2, 3, 4}, {5, 6}, {7, 8}};
+    static byte[][] arr21 = {{4, 5, 6, 7}, {8, 9}, {10, 11}};
+    static byte[][][] arr3 = {arr2, arr21};
+
+    private RC_Array_05() {
+        base1 = new byte[]{1, 2, 3, 4};
+        base2 = new byte[][]{{1, 2, 3, 4}, {5, 6}, {7, 8}};
+        base21 = new byte[][]{{4, 5, 6, 7}, {8, 9}, {10, 11}};
+        base3 = new byte[][][]{{{1, 2, 3, 4}, {5, 6}, {7, 8}}, {{4, 5, 6, 7}, {8, 9}, {10, 11}}};
+    }
+
+    private RC_Array_05(byte[] bytear) {
+        base1 = bytear;
+    }
+
+    private RC_Array_05(byte[][] bytearr) {
+        base2 = bytearr;
+    }
+
+    private RC_Array_05(byte[][][] bytearrr) {
+        base3 = bytearrr;
+    }
+
+    private RC_Array_05(byte[] bytear, byte[][] bytearr, byte[][][] bytearrr) {
+        base1 = bytear;
+        base2 = bytearr;
+        base3 = bytearrr;
+    }
+
+    public static void main(String[] args) {
+        final byte[] TEST1 = {1, 2, 3, 4};
+        final byte[][] TEST2 = {TEST1, {5, 6}, {7, 8}};
+        final byte[][] TEST21 = {{4, 5, 6, 7}, {8, 9}, {10, 11}};
+        final byte[][][] TEST3 = {TEST2, TEST21};
+
+        //Initialization check
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult byte step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4, TEST1, TEST2, TEST3);
+        test01(4, arr1, arr2, arr3);
+
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4, TEST1, TEST2, TEST3);
+        test02(4, arr1, arr2, arr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_05_test01 function return value to the parameter third and judged.
+        //RC_Array_05_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if (TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_05() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_05_test02();
+
+        //Get an array object by returning a function call
+        byte[] getarr1 = RC_Array_get01();
+        byte[][] getarr2 = RC_Array_get02();
+        byte[][][] getarr3 = RC_Array_get03();
+        if (getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if (check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, byte[] second, byte[][] third, byte[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        byte[] xyz = {8, 8, 1, 0};
+        byte[][] xyz2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        byte[][][] xyz3 = {xyz2, xyz2};
+        if (second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2) {
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, byte[] second, byte[][] third, byte[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        byte[] xyz = {8, 8, 1, 0};
+        byte[][] xyz2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        byte[][][] xyz3 = {xyz2, xyz2};
+        second = (byte[]) change(second, xyz);
+        third = (byte[][]) change(third, xyz2);
+        four = (byte[][][]) change(four, xyz3);
+        if (second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(byte[][] third) {
+        //The test03 interface is called, and the RC_Array_05_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_05_test01();
+        if (third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static byte[] RC_Array_get01() {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static byte[][] RC_Array_get02() {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static byte[][][] RC_Array_get03() {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static byte[] RC_Array_set01() {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        byte[] value1 = {9, 2, 8, 8};
+        RC_Array_05 rctest = new RC_Array_05(value1);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new byte[]{1, 2, 3, 4};
+        if (rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static byte[][] RC_Array_set02() {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        byte[][] value2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        RC_Array_05 rctest = new RC_Array_05(value2);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base2 = new byte[][]{{9, 2, 8, 8}, {1, 1}, {0}};
+        if (rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static byte[][][] RC_Array_set03() {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        byte[][][] value3 = {{{1, 2, 3, 4}, {1, 1}, {0}}, {{9, 2, 8, 8}, {1, 1}, {0}}};
+        RC_Array_05 rctest = new RC_Array_05(value3);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base3 = new byte[][][]{{{9, 2, 8, 8}, {1, 1}, {0}}, {{1, 2, 3, 4}, {1, 1}, {0}}};
+        if (rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static byte[][] RC_Array_05_test01() {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_05, and assign a value to the newly created
+        // object field, and judge the result
+        byte[] value1 = {1, 2, 3, 4};
+        byte[][] value2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        byte[][][] value3 = {value2, value2};
+        RC_Array_05 rctest = new RC_Array_05(value1, value2, value3);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new byte[]{9, 2, 8, 8};
+        rctest.base2 = new byte[][]{{9, 2, 8, 8}, {1, 1}, {0}};
+        rctest.base21 = new byte[][]{{6, 6, 6, 5}, {1, 1}, {0}};
+        rctest.base3 = new byte[][][]{{{9, 2, 8, 8}, {1, 1}, {0}}, {{6, 6, 6, 5}, {1, 1}, {0}}};
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_05_test01");
+        return rctest.base21;
+    }
+
+    private static byte[] RC_Array_final01() {
+        final byte[] VALUE1 = {1, 2, 3, 4};
+        return VALUE1;
+    }
+
+    private static byte[][] RC_Array_final02() {
+        final byte[][] VALUE2 = {{9, 2, 8, 8}, {1, 1}, {0}};
+        return VALUE2;
+    }
+
+    private static byte[][][] RC_Array_final03() {
+        final byte[][][] VALUE3 = {{{6, 6, 6, 5}, {1, 1}, {0}}, {{9, 2, 8, 8}, {1, 1}, {0}}};
+        return VALUE3;
+    }
+
+    private static byte[][] RC_Array_05_test02() {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_05 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final byte[] VALUE1 = RC_Array_final01();
+        final byte[][] VALUE2 = RC_Array_final02();
+        final byte[][][] VALUE3 = RC_Array_final03();
+        RC_Array_05 rctest = new RC_Array_05();
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_05_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_05_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception() {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        byte[] value1 = RC_Array_final01();
+        byte[][] value2 = RC_Array_final02();
+        byte[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getByte(value1, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            value1[5] = 'h';
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.setByte(value1, 5, (byte) 0x19);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getByte(RC_Array_final01(), 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getByte(value2[5], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getByte(value2[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getByte(RC_Array_final02()[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getByte(value3[0][3], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getByte(value3[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getByte(RC_Array_final03()[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getByte(value2, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        try {
+            Array.getByte(value3, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_05 rc1 = new RC_Array_05();
+        try {
+            Base_005 bs1 = new Base_005();
+            rc1 = (RC_Array_05) bs1;
+            rc1.base1[0] = 8;
+        } catch (ClassCastException e) {
+            if (rc1.base1[0] != 8)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getByte(value1, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getByte(value2, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getByte(value3, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0371-rc-ArrayOptimization-RC_Array_06/RC_Array_06.java b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0371-rc-ArrayOptimization-RC_Array_06/RC_Array_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a1f6083cc04c84c2336d38356c65f54be18747e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0371-rc-ArrayOptimization-RC_Array_06/RC_Array_06.java
@@ -0,0 +1,427 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/optimization/RC_Array_06.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D short array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_06.java
+ *- @ExecuteClass: RC_Array_06
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_006 {
+    //Parent interface
+    volatile short[] base1;
+    short[][] base2;
+    short[][] base21;
+    short[][][] base3;
+}
+
+public class RC_Array_06 extends Base_006 {
+    static int check_count = 0;
+    static short[] arr1 = {1, 2, 3, 4};
+    static short[][] arr2 = {{1, 2, 3, 4}, {5, 6}, {7, 8}};
+    static short[][] arr21 = {{4, 5, 6, 7}, {8, 9}, {10, 11}};
+    static short[][][] arr3 = {arr2, arr21};
+
+    private RC_Array_06() {
+        base1 = new short[]{1, 2, 3, 4};
+        base2 = new short[][]{{1, 2, 3, 4}, {5, 6}, {7, 8}};
+        base21 = new short[][]{{4, 5, 6, 7}, {8, 9}, {10, 11}};
+        base3 = new short[][][]{{{1, 2, 3, 4}, {5, 6}, {7, 8}}, {{4, 5, 6, 7}, {8, 9}, {10, 11}}};
+    }
+
+    private RC_Array_06(short[] shortar) {
+        base1 = shortar;
+    }
+
+    private RC_Array_06(short[][] shortarr) {
+        base2 = shortarr;
+    }
+
+    private RC_Array_06(short[][][] shortarrr) {
+        base3 = shortarrr;
+    }
+
+    private RC_Array_06(short[] shortar, short[][] shortarr, short[][][] shortarrr) {
+        base1 = shortar;
+        base2 = shortarr;
+        base3 = shortarrr;
+    }
+
+    public static void main(String[] args) {
+        final short[] TEST1 = {1, 2, 3, 4};
+        final short[][] TEST2 = {TEST1, {5, 6}, {7, 8}};
+        final short[][] TEST21 = {{4, 5, 6, 7}, {8, 9}, {10, 11}};
+        final short[][][] TEST3 = {TEST2, TEST21};
+
+        //Initialization check
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult short step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4, TEST1, TEST2, TEST3);
+        test01(4, arr1, arr2, arr3);
+
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4, TEST1, TEST2, TEST3);
+        test02(4, arr1, arr2, arr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_06_test01 function return value to the parameter third and judged.
+        //RC_Array_06_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if (TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_06() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_06_test02();
+
+        //Get an array object by returning a function call
+        short[] getarr1 = RC_Array_get01();
+        short[][] getarr2 = RC_Array_get02();
+        short[][][] getarr3 = RC_Array_get03();
+        if (getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if (check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, short[] second, short[][] third, short[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        short[] xyz = {8, 8, 1, 0};
+        short[][] xyz2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        short[][][] xyz3 = {xyz2, xyz2};
+        if (second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2) {
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, short[] second, short[][] third, short[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        short[] xyz = {8, 8, 1, 0};
+        short[][] xyz2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        short[][][] xyz3 = {xyz2, xyz2};
+        second = (short[]) change(second, xyz);
+        third = (short[][]) change(third, xyz2);
+        four = (short[][][]) change(four, xyz3);
+        if (second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(short[][] third) {
+        //The test03 interface is called, and the RC_Array_06_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_06_test01();
+        if (third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static short[] RC_Array_get01() {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static short[][] RC_Array_get02() {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static short[][][] RC_Array_get03() {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static short[] RC_Array_set01() {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        short[] value1 = {9, 2, 8, 8};
+        RC_Array_06 rctest = new RC_Array_06(value1);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new short[]{1, 2, 3, 4};
+        if (rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static short[][] RC_Array_set02() {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        short[][] value2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        RC_Array_06 rctest = new RC_Array_06(value2);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base2 = new short[][]{{9, 2, 8, 8}, {1, 1}, {0}};
+        if (rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static short[][][] RC_Array_set03() {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        short[][][] value3 = {{{1, 2, 3, 4}, {1, 1}, {0}}, {{9, 2, 8, 8}, {1, 1}, {0}}};
+        RC_Array_06 rctest = new RC_Array_06(value3);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base3 = new short[][][]{{{9, 2, 8, 8}, {1, 1}, {0}}, {{1, 2, 3, 4}, {1, 1}, {0}}};
+        if (rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static short[][] RC_Array_06_test01() {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_06, and assign a value to the newly created
+        // object field, and judge the result
+        short[] value1 = {1, 2, 3, 4};
+        short[][] value2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        short[][][] value3 = {value2, value2};
+        RC_Array_06 rctest = new RC_Array_06(value1, value2, value3);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new short[]{9, 2, 8, 8};
+        rctest.base2 = new short[][]{{9, 2, 8, 8}, {1, 1}, {0}};
+        rctest.base21 = new short[][]{{6, 6, 6, 5}, {1, 1}, {0}};
+        rctest.base3 = new short[][][]{{{9, 2, 8, 8}, {1, 1}, {0}}, {{6, 6, 6, 5}, {1, 1}, {0}}};
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_06_test01");
+        return rctest.base21;
+    }
+
+    private static short[] RC_Array_final01() {
+        final short[] VALUE1 = {1, 2, 3, 4};
+        return VALUE1;
+    }
+
+    private static short[][] RC_Array_final02() {
+        final short[][] VALUE2 = {{9, 2, 8, 8}, {1, 1}, {0}};
+        return VALUE2;
+    }
+
+    private static short[][][] RC_Array_final03() {
+        final short[][][] VALUE3 = {{{6, 6, 6, 5}, {1, 1}, {0}}, {{9, 2, 8, 8}, {1, 1}, {0}}};
+        return VALUE3;
+    }
+
+    private static short[][] RC_Array_06_test02() {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_06() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final short[] VALUE1 = RC_Array_final01();
+        final short[][] VALUE2 = RC_Array_final02();
+        final short[][][] VALUE3 = RC_Array_final03();
+        RC_Array_06 rctest = new RC_Array_06();
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_06_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_06_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception() {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        short[] value1 = RC_Array_final01();
+        short[][] value2 = RC_Array_final02();
+        short[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getShort(value1, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            value1[5] = 88;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.setShort(value1, 5, (short) 12);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getShort(RC_Array_final01(), 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getShort(value2[5], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getShort(value2[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getShort(RC_Array_final02()[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getShort(value3[0][3], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getShort(value3[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getShort(RC_Array_final03()[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getShort(value2, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        try {
+            Array.getShort(value3, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_06 rc1 = new RC_Array_06();
+        try {
+            Base_006 bs1 = new Base_006();
+            rc1 = (RC_Array_06) bs1;
+            rc1.base1[0] = 8;
+        } catch (ClassCastException e) {
+            if (rc1.base1[0] != 8)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getShort(value1, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getShort(value2, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getShort(value3, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0372-rc-ArrayOptimization-RC_Array_07/RC_Array_07.java b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0372-rc-ArrayOptimization-RC_Array_07/RC_Array_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..4aad46f02a56a408df266b09a280841fe39d2f8f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0372-rc-ArrayOptimization-RC_Array_07/RC_Array_07.java
@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/optimization/RC_Array_07.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D long array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_07.java
+ *- @ExecuteClass: RC_Array_07
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_007 {
+    //Parent interface
+    volatile long[] base1;
+    long[][] base2;
+    long[][] base21;
+    long[][][] base3;
+}
+
+public class RC_Array_07 extends Base_007 {
+    static int check_count = 0;
+    static long[] arr1 = {1, 2, 3, 4};
+    static long[][] arr2 = {{1, 2, 3, 4}, {5, 6}, {7, 8}};
+    static long[][] arr21 = {{4, 5, 6, 7}, {8, 9}, {10, 11}};
+    static long[][][] arr3 = {arr2, arr21};
+
+    private RC_Array_07() {
+        base1 = new long[]{1, 2, 3, 4};
+        base2 = new long[][]{{1, 2, 3, 4}, {5, 6}, {7, 8}};
+        base21 = new long[][]{{4, 5, 6, 7}, {8, 9}, {10, 11}};
+        base3 = new long[][][]{{{1, 2, 3, 4}, {5, 6}, {7, 8}}, {{4, 5, 6, 7}, {8, 9}, {10, 11}}};
+    }
+
+    private RC_Array_07(long[] longar) {
+        base1 = longar;
+    }
+
+    private RC_Array_07(long[][] longarr) {
+        base2 = longarr;
+    }
+
+    private RC_Array_07(long[][][] longarrr) {
+        base3 = longarrr;
+    }
+
+    private RC_Array_07(long[] longar, long[][] longarr, long[][][] longarrr) {
+        base1 = longar;
+        base2 = longarr;
+        base3 = longarrr;
+    }
+
+    public static void main(String[] args) {
+        final long[] TEST1 = {1, 2, 3, 4};
+        final long[][] TEST2 = {TEST1, {5, 6}, {7, 8}};
+        final long[][] TEST21 = {{4, 5, 6, 7}, {8, 9}, {10, 11}};
+        final long[][][] TEST3 = {TEST2, TEST21};
+
+        //Initialization check
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult long step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4, TEST1, TEST2, TEST3);
+        test01(4, arr1, arr2, arr3);
+
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4, TEST1, TEST2, TEST3);
+        test02(4, arr1, arr2, arr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_07_test01 function return value to the parameter third and judged.
+        //RC_Array_07_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if (TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_07() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_07_test02();
+
+        //Get an array object by returning a function call
+        long[] getarr1 = RC_Array_get01();
+        long[][] getarr2 = RC_Array_get02();
+        long[][][] getarr3 = RC_Array_get03();
+        if (getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if (check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, long[] second, long[][] third, long[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        long[] xyz = {8, 8, 1, 0};
+        long[][] xyz2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        long[][][] xyz3 = {xyz2, xyz2};
+        if (second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2) {
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, long[] second, long[][] third, long[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        long[] xyz = {8, 8, 1, 0};
+        long[][] xyz2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        long[][][] xyz3 = {xyz2, xyz2};
+        second = (long[]) change(second, xyz);
+        third = (long[][]) change(third, xyz2);
+        four = (long[][][]) change(four, xyz3);
+        if (second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(long[][] third) {
+        //The test03 interface is called, and the RC_Array_07_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_07_test01();
+        if (third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static long[] RC_Array_get01() {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static long[][] RC_Array_get02() {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static long[][][] RC_Array_get03() {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static long[] RC_Array_set01() {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        long[] value1 = {9, 2, 8, 8};
+        RC_Array_07 rctest = new RC_Array_07(value1);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new long[]{1, 2, 3, 4};
+        if (rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static long[][] RC_Array_set02() {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        long[][] value2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        RC_Array_07 rctest = new RC_Array_07(value2);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base2 = new long[][]{{9, 2, 8, 8}, {1, 1}, {0}};
+        if (rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static long[][][] RC_Array_set03() {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        long[][][] value3 = {{{1, 2, 3, 4}, {1, 1}, {0}}, {{9, 2, 8, 8}, {1, 1}, {0}}};
+        RC_Array_07 rctest = new RC_Array_07(value3);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base3 = new long[][][]{{{9, 2, 8, 8}, {1, 1}, {0}}, {{1, 2, 3, 4}, {1, 1}, {0}}};
+        if (rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static long[][] RC_Array_07_test01() {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_07, and assign a value to the newly created
+        // object field, and judge the result
+        long[] value1 = {1, 2, 3, 4};
+        long[][] value2 = {{1, 2, 3, 4}, {1, 1}, {0}};
+        long[][][] value3 = {value2, value2};
+        RC_Array_07 rctest = new RC_Array_07(value1, value2, value3);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new long[]{9, 2, 8, 8};
+        rctest.base2 = new long[][]{{9, 2, 8, 8}, {1, 1}, {0}};
+        rctest.base21 = new long[][]{{6, 6, 6, 5}, {1, 1}, {0}};
+        rctest.base3 = new long[][][]{{{9, 2, 8, 8}, {1, 1}, {0}}, {{6, 6, 6, 5}, {1, 1}, {0}}};
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_07_test01");
+        return rctest.base21;
+    }
+
+    private static long[] RC_Array_final01() {
+        final long[] VALUE1 = {1, 2, 3, 4};
+        return VALUE1;
+    }
+
+    private static long[][] RC_Array_final02() {
+        final long[][] VALUE2 = {{9, 2, 8, 8}, {1, 1}, {0}};
+        return VALUE2;
+    }
+
+    private static long[][][] RC_Array_final03() {
+        final long[][][] VALUE3 = {{{6, 6, 6, 5}, {1, 1}, {0}}, {{9, 2, 8, 8}, {1, 1}, {0}}};
+        return VALUE3;
+    }
+
+    private static long[][] RC_Array_07_test02() {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_07() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final long[] VALUE1 = RC_Array_final01();
+        final long[][] VALUE2 = RC_Array_final02();
+        final long[][][] VALUE3 = RC_Array_final03();
+        RC_Array_07 rctest = new RC_Array_07();
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_07_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_07_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception() {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        long[] value1 = RC_Array_final01();
+        long[][] value2 = RC_Array_final02();
+        long[][][] value3 = RC_Array_final03();
+
+        //Is the value as expect after the assignment?
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getLong(value1, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            value1[5] = 92;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.setLong(value1, 5, (long) 12);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getLong(RC_Array_final01(), 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getLong(value2[5], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getLong(value2[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getLong(RC_Array_final02()[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getLong(value3[0][3], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getLong(value3[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getLong(RC_Array_final03()[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getLong(value2, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        try {
+            Array.getLong(value3, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_07 rc1 = new RC_Array_07();
+        try {
+            Base_007 bs1 = new Base_007();
+            rc1 = (RC_Array_07) bs1;
+            rc1.base1[0] = 8;
+        } catch (ClassCastException e) {
+            if (rc1.base1[0] != 8)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getLong(value1, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getLong(value2, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getLong(value3, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0373-rc-ArrayOptimization-RC_Array_08/RC_Array_08.java b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0373-rc-ArrayOptimization-RC_Array_08/RC_Array_08.java
new file mode 100644
index 0000000000000000000000000000000000000000..61eb2dc739a1c4417fa4c4105fd34e88be79c5a5
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0373-rc-ArrayOptimization-RC_Array_08/RC_Array_08.java
@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/optimization/RC_Array_08.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D float array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_08.java
+ *- @ExecuteClass: RC_Array_08
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_008 {
+    //Parent interface
+    volatile float[] base1;
+    float[][] base2;
+    float[][] base21;
+    float[][][] base3;
+}
+
+public class RC_Array_08 extends Base_008 {
+    static int check_count = 0;
+    static float[] arr1 = {1.1f, 2.2f, 3.3f, 4.4f};
+    static float[][] arr2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {5.5f, 6.6f}, {7.7f, 8.8f}};
+    static float[][] arr21 = {{4.1f, 5.1f, 6.1f, 7.1f}, {8.1f, 9.1f}, {10.3f, 11.10f}};
+    static float[][][] arr3 = {arr2, arr21};
+
+    private RC_Array_08() {
+        base1 = new float[]{1.1f, 2.2f, 3.3f, 4.4f};
+        base2 = new float[][]{{1.1f, 2.2f, 3.3f, 4.4f}, {5.5f, 6.6f}, {7.7f, 8.8f}};
+        base21 = new float[][]{{4.1f, 5.1f, 6.1f, 7.1f}, {8.1f, 9.1f}, {10.3f, 11.10f}};
+        base3 = new float[][][]{{{1.1f, 2.2f, 3.3f, 4.4f}, {5.5f, 6.6f}, {7.7f, 8.8f}}, {{4.1f, 5.1f, 6.1f, 7.1f}, {8.1f, 9.1f}, {10.3f, 11.10f}}};
+    }
+
+    private RC_Array_08(float[] floatar) {
+        base1 = floatar;
+    }
+
+    private RC_Array_08(float[][] floatarr) {
+        base2 = floatarr;
+    }
+
+    private RC_Array_08(float[][][] floatarrr) {
+        base3 = floatarrr;
+    }
+
+    private RC_Array_08(float[] floatar, float[][] floatarr, float[][][] floatarrr) {
+        base1 = floatar;
+        base2 = floatarr;
+        base3 = floatarrr;
+    }
+
+    public static void main(String[] args) {
+        final float[] TEST1 = {1.1f, 2.2f, 3.3f, 4.4f};
+        final float[][] TEST2 = {TEST1, {5.5f, 6.6f}, {7.7f, 8.8f}};
+        final float[][] TEST21 = {{4.1f, 5.1f, 6.1f, 7.1f}, {8.1f, 9.1f}, {10.3f, 11.10f}};
+        final float[][][] TEST3 = {TEST2, TEST21};
+
+        //Initialization check
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult float step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4, TEST1, TEST2, TEST3);
+        test01(4, arr1, arr2, arr3);
+
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4, TEST1, TEST2, TEST3);
+        test02(4, arr1, arr2, arr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_08_test01 function return value to the parameter third and judged.
+        //RC_Array_08_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if (TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_08() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_08_test02();
+
+        //Get an array object by returning a function call
+        float[] getarr1 = RC_Array_get01();
+        float[][] getarr2 = RC_Array_get02();
+        float[][][] getarr3 = RC_Array_get03();
+        if (getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if (check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, float[] second, float[][] third, float[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        float[] xyz = {8.5f, 8.3f, 1.2f, 0.5f};
+        float[][] xyz2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}};
+        float[][][] xyz3 = {xyz2, xyz2};
+        if (second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2) {
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, float[] second, float[][] third, float[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        float[] xyz = {8.5f, 8.3f, 1.2f, 0.5f};
+        float[][] xyz2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}};
+        float[][][] xyz3 = {xyz2, xyz2};
+        second = (float[]) change(second, xyz);
+        third = (float[][]) change(third, xyz2);
+        four = (float[][][]) change(four, xyz3);
+        if (second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(float[][] third) {
+        //The test03 interface is called, and the RC_Array_08_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_08_test01();
+        if (third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static float[] RC_Array_get01() {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static float[][] RC_Array_get02() {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static float[][][] RC_Array_get03() {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static float[] RC_Array_set01() {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        float[] value1 = {9.2f, 2.2f, 8.8f, 8.8f};
+        RC_Array_08 rctest = new RC_Array_08(value1);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new float[]{1.1f, 2.2f, 3.3f, 4.4f};
+        if (rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static float[][] RC_Array_set02() {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        float[][] value2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}};
+        RC_Array_08 rctest = new RC_Array_08(value2);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base2 = new float[][]{{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}};
+        if (rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static float[][][] RC_Array_set03() {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        float[][][] value3 = {{{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}}, {{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}}};
+        RC_Array_08 rctest = new RC_Array_08(value3);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base3 = new float[][][]{{{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}}, {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}}};
+        if (rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static float[][] RC_Array_08_test01() {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_08, and assign a value to the newly created
+        // object field, and judge the result
+        float[] value1 = {1.1f, 2.2f, 3.3f, 4.4f};
+        float[][] value2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}};
+        float[][][] value3 = {value2, value2};
+        RC_Array_08 rctest = new RC_Array_08(value1, value2, value3);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new float[]{9.2f, 2.2f, 8.8f, 8.8f};
+        rctest.base2 = new float[][]{{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}};
+        rctest.base21 = new float[][]{{6, 6, 6, 5}, {1.3f, 1.1f}, {0.5f}};
+        rctest.base3 = new float[][][]{{{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}}, {{6, 6, 6, 5}, {1.3f, 1.1f}, {0.5f}}};
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_08_test01");
+        return rctest.base21;
+    }
+
+    private static float[] RC_Array_final01() {
+        final float[] VALUE1 = {1.1f, 2.2f, 3.3f, 4.4f};
+        return VALUE1;
+    }
+
+    private static float[][] RC_Array_final02() {
+        final float[][] VALUE2 = {{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}};
+        return VALUE2;
+    }
+
+    private static float[][][] RC_Array_final03() {
+        final float[][][] VALUE3 = {{{6.4f, 6.1f, 6.3f, 5.5f}, {1.3f, 1.1f}, {0.5f}}, {{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}}};
+        return VALUE3;
+    }
+
+    private static float[][] RC_Array_08_test02() {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_08() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final float[] VALUE1 = RC_Array_final01();
+        final float[][] VALUE2 = RC_Array_final02();
+        final float[][][] VALUE3 = RC_Array_final03();
+        RC_Array_08 rctest = new RC_Array_08();
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_08_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_08_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception() {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        float[] value1 = RC_Array_final01();
+        float[][] value2 = RC_Array_final02();
+        float[][][] value3 = RC_Array_final03();
+
+        //Is the value as expect after the assignment?
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getFloat(value1, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            value1[5] = 88.10f;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.setFloat(value1, 5, 12.5f);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(RC_Array_final01(), 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(value2[5], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(value2[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(RC_Array_final02()[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(value3[0][3], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(value3[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(RC_Array_final03()[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getFloat(value2, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(value3, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_08 rc1 = new RC_Array_08();
+        try {
+            Base_008 bs1 = new Base_008();
+            rc1 = (RC_Array_08) bs1;
+            rc1.base1[0] = 8.9f;
+        } catch (ClassCastException e) {
+            if (rc1.base1[0] != 8.9f)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getFloat(value1, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(value2, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getFloat(value3, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0374-rc-ArrayOptimization-RC_Array_09/RC_Array_09.java b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0374-rc-ArrayOptimization-RC_Array_09/RC_Array_09.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e33a036fff9cc71eb97b4fe327d69e1d19aaa7e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/ArrayOptimization/RC0374-rc-ArrayOptimization-RC_Array_09/RC_Array_09.java
@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/optimization/RC_Array_09.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D double array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_09.java
+ *- @ExecuteClass: RC_Array_09
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_009 {
+    //Parent interface
+    volatile double[] base1;
+    double[][] base2;
+    double[][] base21;
+    double[][][] base3;
+}
+
+public class RC_Array_09 extends Base_009 {
+    static int check_count = 0;
+    static double[] arr1 = {1.1f, 2.2f, 3.3f, 4.4f};
+    static double[][] arr2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {5.5f, 6.6f}, {7.7f, 8.8f}};
+    static double[][] arr21 = {{4.1f, 5.1f, 6.1f, 7.1f}, {8.1f, 9.1f}, {10.3f, 11.10f}};
+    static double[][][] arr3 = {arr2, arr21};
+
+    private RC_Array_09() {
+        base1 = new double[]{1.1f, 2.2f, 3.3f, 4.4f};
+        base2 = new double[][]{{1.1f, 2.2f, 3.3f, 4.4f}, {5.5f, 6.6f}, {7.7f, 8.8f}};
+        base21 = new double[][]{{4.1f, 5.1f, 6.1f, 7.1f}, {8.1f, 9.1f}, {10.3f, 11.10f}};
+        base3 = new double[][][]{{{1.1f, 2.2f, 3.3f, 4.4f}, {5.5f, 6.6f}, {7.7f, 8.8f}}, {{4.1f, 5.1f, 6.1f, 7.1f}, {8.1f, 9.1f}, {10.3f, 11.10f}}};
+    }
+
+    private RC_Array_09(double[] doublear) {
+        base1 = doublear;
+    }
+
+    private RC_Array_09(double[][] doublearr) {
+        base2 = doublearr;
+    }
+
+    private RC_Array_09(double[][][] doublearrr) {
+        base3 = doublearrr;
+    }
+
+    private RC_Array_09(double[] doublear, double[][] doublearr, double[][][] doublearrr) {
+        base1 = doublear;
+        base2 = doublearr;
+        base3 = doublearrr;
+    }
+
+    public static void main(String[] args) {
+        final double[] TEST1 = {1.1f, 2.2f, 3.3f, 4.4f};
+        final double[][] TEST2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {5.5f, 6.6f}, {7.7f, 8.8f}};
+        final double[][] TEST21 = {{4.1f, 5.1f, 6.1f, 7.1f}, {8.1f, 9.1f}, {10.3f, 11.10f}};
+        final double[][][] TEST3 = {TEST2, TEST21};
+
+        //Initialization check
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult double step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4, TEST1, TEST2, TEST3);
+        test01(4, arr1, arr2, arr3);
+
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4, TEST1, TEST2, TEST3);
+        test02(4, arr1, arr2, arr3);
+        if (TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_09_test01 function return value to the parameter third and judged.
+        //RC_Array_09_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if (TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_09() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_09_test02();
+
+        //Get an array object by returning a function call
+        double[] getarr1 = RC_Array_get01();
+        double[][] getarr2 = RC_Array_get02();
+        double[][][] getarr3 = RC_Array_get03();
+        if (getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if (check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, double[] second, double[][] third, double[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        double[] xyz = {8.5f, 8.3f, 1.2f, 0.5f};
+        double[][] xyz2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}};
+        double[][][] xyz3 = {xyz2, xyz2};
+        if (second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2) {
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, double[] second, double[][] third, double[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        double[] xyz = {8.5f, 8.3f, 1.2f, 0.5f};
+        double[][] xyz2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}};
+        double[][][] xyz3 = {xyz2, xyz2};
+        second = (double[]) change(second, xyz);
+        third = (double[][]) change(third, xyz2);
+        four = (double[][][]) change(four, xyz3);
+        if (second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(double[][] third) {
+        //The test03 interface is called, and the RC_Array_09_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_09_test01();
+        if (third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static double[] RC_Array_get01() {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static double[][] RC_Array_get02() {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static double[][][] RC_Array_get03() {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static double[] RC_Array_set01() {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        double[] value1 = {9.2f, 2.2f, 8.8f, 8.8f};
+        RC_Array_09 rctest = new RC_Array_09(value1);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new double[]{1.1f, 2.2f, 3.3f, 4.4f};
+        if (rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static double[][] RC_Array_set02() {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        double[][] value2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}};
+        RC_Array_09 rctest = new RC_Array_09(value2);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, null) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base2 = new double[][]{{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}};
+        if (rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static double[][][] RC_Array_set03() {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        double[][][] value3 = {{{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}}, {{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}}};
+        RC_Array_09 rctest = new RC_Array_09(value3);
+        if (Arrays.equals(rctest.base1, null) && Arrays.equals(rctest.base2, null)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base3 = new double[][][]{{{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}}, {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}}};
+        if (rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static double[][] RC_Array_09_test01() {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_09, and assign a value to the newly created
+        // object field, and judge the result
+        double[] value1 = {1.1f, 2.2f, 3.3f, 4.4f};
+        double[][] value2 = {{1.1f, 2.2f, 3.3f, 4.4f}, {1.3f, 1.1f}, {0.5f}};
+        double[][][] value3 = {value2, value2};
+        RC_Array_09 rctest = new RC_Array_09(value1, value2, value3);
+        if (Arrays.equals(rctest.base1, value1) && Arrays.equals(rctest.base2, value2)
+                && Arrays.equals(rctest.base3, value3) && Arrays.equals(rctest.base21, null))
+            check_count++;
+        rctest.base1 = new double[]{9.2f, 2.2f, 8.8f, 8.8f};
+        rctest.base2 = new double[][]{{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}};
+        rctest.base21 = new double[][]{{6, 6, 6, 5}, {1.3f, 1.1f}, {0.5f}};
+        rctest.base3 = new double[][][]{{{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}}, {{6, 6, 6, 5}, {1.3f, 1.1f}, {0.5f}}};
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_09_test01");
+        return rctest.base21;
+    }
+
+    private static double[] RC_Array_final01() {
+        final double[] VALUE1 = {1.1f, 2.2f, 3.3f, 4.4f};
+        return VALUE1;
+    }
+
+    private static double[][] RC_Array_final02() {
+        final double[][] VALUE2 = {{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}};
+        return VALUE2;
+    }
+
+    private static double[][][] RC_Array_final03() {
+        final double[][][] VALUE3 = {{{6.4f, 6.1f, 6.3f, 5.5f}, {1.3f, 1.1f}, {0.5f}}, {{9.2f, 2.2f, 8.8f, 8.8f}, {1.3f, 1.1f}, {0.5f}}};
+        return VALUE3;
+    }
+
+    private static double[][] RC_Array_09_test02() {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_09() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final double[] VALUE1 = RC_Array_final01();
+        final double[][] VALUE2 = RC_Array_final02();
+        final double[][][] VALUE3 = RC_Array_final03();
+        RC_Array_09 rctest = new RC_Array_09();
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_09_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if (rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_09_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception() {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        double[] value1 = RC_Array_final01();
+        double[][] value2 = RC_Array_final02();
+        double[][][] value3 = RC_Array_final03();
+
+        //Is the value as expect after the assignment?
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getDouble(value1, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            value1[5] = 10.16f;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.setDouble(value1, 5, 12.5f);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getDouble(value2[5], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getDouble(value2[0], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getDouble(value3[0][3], 0);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        try {
+            Array.getDouble(value3[0][1], 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getDouble(value2, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        try {
+            Array.getDouble(value3, 1);
+        } catch (IllegalArgumentException e) {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_09 rc1 = new RC_Array_09();
+        try {
+            Base_009 bs1 = new Base_009();
+            rc1 = (RC_Array_09) bs1;
+            rc1.base1[0] = 8.9f;
+        } catch (ClassCastException e) {
+            if (rc1.base1[0] != 8.9f)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if (value1.length == 4 && value2.length == 3 && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getDouble(value1, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getDouble(value2, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+        try {
+            Array.getDouble(value3, 1);
+        } catch (NullPointerException e) {
+            check++;
+        }
+
+        //System.out.println(check);
+        if (check == 15)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/BindingMethod/RC0468-rc-BindingMethod-ArrayCloneTest/ArrayCloneTest.java b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0468-rc-BindingMethod-ArrayCloneTest/ArrayCloneTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..abc5cf7fdcd8f9b8532b52a75cf63233450a5f37
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0468-rc-BindingMethod-ArrayCloneTest/ArrayCloneTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_ArrayCloneTest
+ *- @TestCaseName: ArrayCloneTest
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:clone()函数专项测试：验证数组的clone()方法的基本功能正常。
+ *  -#step1:测试正常数组拷贝
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: ArrayCloneTest.java
+ *- @ExecuteClass: ArrayCloneTest
+ *- @ExecuteArgs:
+ */
+
+public class ArrayCloneTest {
+    public static void main(String[] args) {
+        if (functionTest01()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    private static boolean functionTest01() {
+        String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+        String[] test2 = test1.clone();
+        if (test2 != test1 && test2.length == 10 && test2[0].equals("test1") && test2[9].equals("test10")) {
+            return true;
+        }
+        return false;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/BindingMethod/RC0469-rc-BindingMethod-ArrayCloneTest02/ArrayCloneTest02.java b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0469-rc-BindingMethod-ArrayCloneTest02/ArrayCloneTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3b4726a8429390a0db74ffbb449b5d88a80a50a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0469-rc-BindingMethod-ArrayCloneTest02/ArrayCloneTest02.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_ArrayCloneTest02
+ *- @TestCaseName: ArrayCloneTest02
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:clone()函数专项测试：验证数组的clone()方法的基本功能正常。
+ *  -#step1:测试数组拷贝时报CloneNotSupportedException异常
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: ArrayCloneTest02.java
+ *- @ExecuteClass: ArrayCloneTest02
+ *- @ExecuteArgs:
+ */
+
+public class ArrayCloneTest02 {
+    private Integer id;
+
+    public ArrayCloneTest02(Integer id) {
+        this.id = id;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    @Override
+    public String toString() {
+        return "CloneTest{" +
+                "id=" + id +
+                '}';
+    }
+
+    public static void main(String[] args) {
+        try {
+            ArrayCloneTest02 cloneTest = new ArrayCloneTest02(1);
+            ArrayCloneTest02 cloneTest1 = (ArrayCloneTest02) cloneTest.clone();
+            System.out.println("ErrorResult");
+        } catch (CloneNotSupportedException e) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/BindingMethod/RC0470-rc-BindingMethod-ArrayCopyTest/ArrayCopyTest.java b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0470-rc-BindingMethod-ArrayCopyTest/ArrayCopyTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fb6a606923590b8628ccb889512849701a7a182
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0470-rc-BindingMethod-ArrayCopyTest/ArrayCopyTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_ArrayCopyTest
+ *- @TestCaseName: ArrayCopyTest
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:ArrayCopy函数专项测试：验证ArrayCopy方法的基本功能正常。
+ *  -#step1:测试正常数组拷贝
+ *  -#step2:测试拷贝过程中出现ArrayStoreException异常
+ *  -#step3:测试拷贝过程中出现ArrayIndexOutOfBoundsException异常
+ *  -#step4:测试拷贝过程中出现NullPointerException异常
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: ArrayCopyTest.java
+ *- @ExecuteClass: ArrayCopyTest
+ *- @ExecuteArgs:
+ */
+
+public class ArrayCopyTest {
+    public static void main(String[] args) {
+        if (functionTest01() && functionTest02() && functionTest03() && functionTest04()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    private static boolean functionTest01() {
+        String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+        String[] test2 = new String[10];
+        System.arraycopy(test1, 0, test2, 0, 10);
+        if (test2[0].equals("test1") && test2[9].equals("test10")) {
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean functionTest02() {
+        try {
+            String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+            int[] test2 = new int[10];
+            System.arraycopy(test1, 0, test2, 0, 10);
+
+        } catch (ArrayStoreException e) {
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean functionTest03() {
+        try {
+            String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+            String[] test2 = new String[9];
+            System.arraycopy(test1, 0, test2, 0, 10);
+
+        } catch (ArrayIndexOutOfBoundsException e) {
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean functionTest04() {
+        try {
+            String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+            String[] test2 = null;
+            System.arraycopy(test1, 0, test2, 0, 10);
+
+        } catch (NullPointerException e) {
+            return true;
+        }
+        return false;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/BindingMethod/RC0471-rc-BindingMethod-UnsafeTest01/UnsafeTest01.java b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0471-rc-BindingMethod-UnsafeTest01/UnsafeTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf66926be9327a0970d198b062d96b3f1b7603d4
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0471-rc-BindingMethod-UnsafeTest01/UnsafeTest01.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_UnsafeTest01
+ *- @TestCaseName: UnsafeTest01
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:unsafe.compareAndSwapObject()函数专项测试：验证compareAndSwapObject()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest01.java
+ *- @ExecuteClass:UnsafeTest01
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest01 {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecompareAndSwapObjectTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeTest01.res = UnsafeTest01.res - 10;
+        }
+        if (result == 3 && UnsafeTest01.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int UnsafecompareAndSwapObjectTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Field param;
+        Object obj;
+        long offset;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            obj = new Billie5();
+            param = Billie5.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            unsafe.compareAndSwapObject(obj, offset, "Me", "billie5");
+            result = unsafe.getObject(obj, offset);
+            if (result.equals("billie5")) {
+                UnsafeTest01.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie5 {
+    public int height = 8;
+    private String[] color = {"black", "white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day", "wet"};
+    private long weight = 100L;
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/BindingMethod/RC0472-rc-BindingMethod-UnsafeTest02/UnsafeTest02.java b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0472-rc-BindingMethod-UnsafeTest02/UnsafeTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..26f48949878f231d2254a526d2aec88e5a0f4309
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0472-rc-BindingMethod-UnsafeTest02/UnsafeTest02.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_UnsafeTest02
+ *- @TestCaseName: UnsafeTest02
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:unsafe.getObjectVolatile()函数专项测试：验证getObjectVolatile()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest02.java
+ *- @ExecuteClass:UnsafeTest02
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest02 {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectVolatileTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeTest02.res -= 2;
+        }
+
+        if (result == 3 && UnsafeTest02.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetObjectVolatileTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            param = Billie10.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie10();
+            result = unsafe.getObjectVolatile(obj, offset);
+            if (result.equals("eilish")) {
+                UnsafeTest02.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie10 {
+    public int height = 8;
+    private String[] color = {"black", "white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day", "wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/BindingMethod/RC0473-rc-BindingMethod-UnsafeTest03/UnsafeTest03.java b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0473-rc-BindingMethod-UnsafeTest03/UnsafeTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..070407a278853e6ba979ef142c4f994320bf02dd
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0473-rc-BindingMethod-UnsafeTest03/UnsafeTest03.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_UnsafeTest03
+ *- @TestCaseName: UnsafeTest03
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:unsafe.getObject()函数专项测试：验证getObject()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest03.java
+ *- @ExecuteClass:UnsafeTest03
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest03 {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeTest03.res -= 2;
+        }
+        if (result == 3 && UnsafeTest03.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetObjectTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            param = Billie18.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie18();
+            result = unsafe.getObject(obj, offset);
+            if (result.equals("Me")) {
+                UnsafeTest03.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie18 {
+    public int height = 8;
+    private String[] color = {"black", "white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day", "wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/BindingMethod/RC0474-rc-BindingMethod-UnsafeTest04/UnsafeTest04.java b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0474-rc-BindingMethod-UnsafeTest04/UnsafeTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb7ba7a9f08ee36fd7c5ae55fbd4ec41c221c2d2
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0474-rc-BindingMethod-UnsafeTest04/UnsafeTest04.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_UnsafeTest04
+ *- @TestCaseName: UnsafeTest04
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:unsafe.putObject()函数专项测试：验证putObject()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest04.java
+ *- @ExecuteClass:UnsafeTest04
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest04 {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeTest04.res -= 2;
+        }
+        if (result == 3 && UnsafeTest04.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputObjectTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            param = Billie19.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie19();
+            result = unsafe.getObject(obj, offset);
+            unsafe.putObject(obj, offset, "she");
+            result = unsafe.getObject(obj, offset);
+            if (result.equals("she")) {
+                UnsafeTest04.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie19 {
+    public int height = 8;
+    private String[] color = {"black", "white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day", "wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/BindingMethod/RC0475-rc-BindingMethod-UnsafeTest05/UnsafeTest05.java b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0475-rc-BindingMethod-UnsafeTest05/UnsafeTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d4fcb853584dc7073ad574486fb979e7aa8f4db
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0475-rc-BindingMethod-UnsafeTest05/UnsafeTest05.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_UnsafeTest05
+ *- @TestCaseName: UnsafeTest05
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:unsafe.putObjectVolatile()函数专项测试：验证putObjectVolatile()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest05.java
+ *- @ExecuteClass:UnsafeTest05
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest05 {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectVolatileTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeTest05.res -= 2;
+        }
+        if (result == 3 && UnsafeTest05.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputObjectVolatileTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            param = Billie11.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie11();
+            result = unsafe.getObjectVolatile(obj, offset);
+            unsafe.putObjectVolatile(obj, offset, "Eilish");
+            result = unsafe.getObjectVolatile(obj, offset);
+            if (result.equals("Eilish")) {
+                UnsafeTest05.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie11 {
+    public int height = 8;
+    private String[] color = {"black", "white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day", "wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/BindingMethod/RC0476-rc-BindingMethod-UnsafeTest06/UnsafeTest06.java b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0476-rc-BindingMethod-UnsafeTest06/UnsafeTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..534db210bad9a86da1ad75b59f856b805f9b8772
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/BindingMethod/RC0476-rc-BindingMethod-UnsafeTest06/UnsafeTest06.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_UnsafeTest06
+ *- @TestCaseName: UnsafeTest06
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:unsafe.putOrderedObject()函数专项测试：验证putOrderedObject()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest06.java
+ *- @ExecuteClass:UnsafeTest06
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest06 {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputOrderedObjectTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeTest06.res -= 2;
+        }
+        if (result == 3 && UnsafeTest06.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputOrderedObjectTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            param = Billie20.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie20();
+            result = unsafe.getObject(obj, offset);
+            unsafe.putOrderedObject(obj, offset, "she");
+            result = unsafe.getObject(obj, offset);
+            if (result.equals("she")) {
+                UnsafeTest06.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie20 {
+    public int height = 8;
+    private String[] color = {"black", "white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day", "wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/DTS/RC0406-rc-DTS-stringIntern/stringIntern.java b/test/testsuite/ouroboros/memory_management/DTS/RC0406-rc-DTS-stringIntern/stringIntern.java
new file mode 100644
index 0000000000000000000000000000000000000000..bef0e77af9daa1576f22de71cc09cbb63d3083da
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/DTS/RC0406-rc-DTS-stringIntern/stringIntern.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:String_intern.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:test Intern() API of String
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: stringIntern.java
+ *- @ExecuteClass: stringIntern
+ *- @ExecuteArgs:
+
+ *
+ */
+public class stringIntern {
+    private static int check = 0;
+
+    public static void main(String[] args) {
+        String s1 = new String("aaa");
+        String s2 = "aaa";
+        if (s1 != s2) {
+            check++;    //=1
+        }
+
+        s1 = new String("bbb").intern();
+        s2 = "bbb";
+        if (s1 == s2) {
+            check++;    //=2
+        }
+
+        s1 = "ccc";
+        s2 = "ccc";
+        if (s1 == s2) {
+            check++;    //=3
+        }
+
+        s1 = new String("ddd").intern();
+        s2 = new String("ddd").intern();
+        if (s1 == s2) {
+            check++;    //=4
+        }
+
+        s1 = "ab" + "cd";
+        s2 = "abcd";
+        if (s1 == s2) {
+            check++;    //=5
+        }
+
+        String temp = "hh";
+        s1 = "a" + temp;
+        s2 = "ahh";
+        if (s1 != s2) {
+            check++;    //=6
+        }
+
+        temp = "hh".intern();
+        s1 = "a" + temp;
+        s2 = "ahh";
+        if (s1 != s2) {
+            check++;    //=7
+        }
+
+        temp = "hh".intern();
+        s1 = ("a" + temp).intern();
+        s2 = "ahh";
+        if (s1 == s2) {
+            check++;    //=8
+        }
+
+        s1 = new String("1");
+        s1.intern();
+        s2 = "1";
+        if (s1 != s2) {
+            check++;    //=9
+        }
+
+        String s3 = new String("1") + new String("1");
+        s3.intern();
+        String s4 = "11";
+        if (s1 != s2) {
+            check++;    //=10
+        }
+
+        s3 = new String("2") + new String("2");
+        s4 = "22";
+        s3.intern();
+        if (s1 != s2) {
+            check++;    //=11
+        }
+        if (check == 11) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/DTS/RC0407-rc-DTS-stackAllocField/stackAllocField.java b/test/testsuite/ouroboros/memory_management/DTS/RC0407-rc-DTS-stackAllocField/stackAllocField.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b4e78097eaaea19c1ad652cd369e6af8a56e72c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/DTS/RC0407-rc-DTS-stackAllocField/stackAllocField.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:stackAllocField.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:test Intern() API of String
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: stackAllocField.java
+ *- @ExecuteClass: stackAllocField
+ *- @ExecuteArgs:
+
+ *
+ */
+public class stackAllocField {
+    private static A a1 = new A();
+    private static A a2 = new A();
+    private static A a3 = new A();
+    private static A a4 = new A();
+
+    public static void main(String[] args) {
+        wrapper(a1, a2, a3, a4);
+    }
+
+    public static void wrapper(A tempa1, A tempa2, A tempa3, A tempa4) {
+        A testa1 = new A();
+        testa1.a = tempa1;
+        A testa2 = new A();
+        testa2.a = tempa2;
+        A testa3 = new A();
+        testa3.a = tempa3;
+        A testa4 = new A();
+        testa4.a = tempa4;
+        tempa1 = null;
+        tempa2 = null;
+        tempa3 = null;
+        tempa4 = null;
+        a1 = null;
+        a2 = null;
+        a3 = null;
+        a4 = null;
+        for (int i = 0; i <= 50; i++) {
+            Runtime.getRuntime().gc();
+        }
+        if (testa1.a != null && testa2.a != null && testa3.a != null && testa4.a != null) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    private static class A {
+        A a;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/DTS/RC0408-rc-DTS-OOMtest/OOMtest.java b/test/testsuite/ouroboros/memory_management/DTS/RC0408-rc-DTS-OOMtest/OOMtest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9af3eb395736c70d7cc0e6980d1dfb5630f398a9
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/DTS/RC0408-rc-DTS-OOMtest/OOMtest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:OOMtest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: OOMtest.java
+ *- @ExecuteClass: OOMtest
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.util.ArrayList;
+
+public class OOMtest {
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 * 1024 * 10; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        try {
+            int result = alloc_test();
+        } catch (OutOfMemoryError o) {
+            System.out.println("ExpectResult");
+        }
+        if (store == null) {
+            System.out.println("Error");
+        } else {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/DTS/RC0409-rc-DTS-Ex_eight_arguments/Ex_eight_arguments.java b/test/testsuite/ouroboros/memory_management/DTS/RC0409-rc-DTS-Ex_eight_arguments/Ex_eight_arguments.java
new file mode 100644
index 0000000000000000000000000000000000000000..58242eee1b6e0181389e1c7759dfca16fc6d1e0a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/DTS/RC0409-rc-DTS-Ex_eight_arguments/Ex_eight_arguments.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Ex_eight_arguments_static.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: more than 8 arguments method test, include static ,no static, has return value, no return, throw
+ *                      Exception,not throw Exception
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ex_eight_arguments.java
+ *- @ExecuteClass: Ex_eight_arguments
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+
+public class Ex_eight_arguments {
+    static int check_count = 0;
+
+    public static void main(String[] args) {
+        int first = 1988;
+        byte second = 2;
+        char third = 'g';
+        long four = 19881110;
+        float five = 601.5f;
+        double six = 60.15f;
+        String seven = "huawei";
+        boolean eight = true;
+        Object nine = new String("CC is a cat");
+        int[] ten = {2012, 2020, 2019, 2040, 3301};
+        Ex_eight_arguments Test = new Ex_eight_arguments();
+
+        //test static method no return no exception
+        test01(first, second, third, four, five, six, seven, eight, nine, ten);
+
+        //test no static method no return no exception
+        Test.test02(first, second, third, four, five, six, seven, eight, nine, ten);
+
+        //test no static method return value no exception
+        first = Test.test03(first, second, third, four, five, six, seven, eight, nine, ten);
+
+        //test no static method no return throws exception
+        try {
+            Test.test04(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test04 not catch Exception");
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check_count++;
+        }
+
+        //test static method return value no exception
+        seven = test05(first, second, third, four, five, six, seven, eight, nine, ten);
+
+        //test static method no return value throws exception
+        try {
+            test06(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test06 not catch Exception");
+        } catch (IllegalArgumentException e) {
+            check_count++;
+        }
+
+        //test no static method return value throws exception
+        try {
+            boolean result7 = Test.test07(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test07 not catch Exception");
+        } catch (ArithmeticException e) {
+            check_count++;
+        }
+
+        //test static method return value throws exception
+        try {
+            int[] result8 = test08(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test08 not catch Exception");
+        } catch (NegativeArraySizeException e) {
+            check_count++;
+        }
+
+        //Result judgment
+        if (check_count == 12)
+            System.out.println("ExpectResult");
+        //System.out.println(check_count);
+    }
+
+    private static void test01(int first, byte second, char third, long four, float five, double six, String seven,
+                               boolean eight, Object nine, int[] ten) {
+        /*test static method no return no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1989 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static String test05(int first, byte second, char third, long four, float five, double six, String seven,
+                                 Boolean eight, Object nine, int[] ten) {
+        /*test static method return value no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test05");
+        return new String("test05 is End");
+    }
+
+    private static void test06(int first, byte second, char third, long four, float five, double six, String seven,
+                               Boolean eight, Object nine, int[] ten) throws IllegalArgumentException {
+        /*test static method no return value throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        int[][] test_ten = {ten, ten, ten, ten, ten, ten};
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test06");
+        Array.getInt(test_ten, 5);
+    }
+
+    private static int[] test08(int first, byte second, char third, long four, float five, double six, String seven,
+                                Boolean eight, Object nine, int[] ten) throws NegativeArraySizeException {
+        /*test static method return value throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        int[][] test_ten = {ten, ten, ten, ten, ten, ten};
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test08");
+        int[] chck = new int[-1];
+        return chck;
+    }
+
+    private void test02(int first, byte second, char third, long four, float five, double six, String seven,
+                        Boolean eight, Object nine, int[] ten) {
+        /*test no static method no return no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1989 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private int test03(int first, byte second, char third, long four, float five, double six, String seven,
+                       Boolean eight, Object nine, int[] ten) {
+        /*test no static method return value no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1989 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+        return first;
+    }
+
+    private void test04(int first, byte second, char third, long four, float five, double six, String seven,
+                        Boolean eight, Object nine, int[] ten) throws ArrayIndexOutOfBoundsException {
+        /*test no static method no return throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test04");
+        ten[5] = 1988;
+    }
+
+    private boolean test07(int first, byte second, char third, long four, float five, double six, String seven,
+                           Boolean eight, Object nine, int[] ten) throws ArithmeticException {
+        /*test no static method return value throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        int[][] test_ten = {ten, ten, ten, ten, ten, ten};
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test07");
+
+        first = first / 0;
+        return true;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0001-rc-function-Cycle_a_00180/Cycle_a_00180.java b/test/testsuite/ouroboros/memory_management/Function/RC0001-rc-function-Cycle_a_00180/Cycle_a_00180.java
new file mode 100644
index 0000000000000000000000000000000000000000..58e8b095b1ab4d3af84b55f2ef60438f592771d3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0001-rc-function-Cycle_a_00180/Cycle_a_00180.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00180 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00180.java
+ *- @ExecuteClass: Cycle_a_00180
+ *- @ExecuteArgs:
+ * A1 depend A2 A8;
+ * A2 depend A3 ; A3 depend A4; A4 depend A5 ; A5 depend A6; A6 depend A1 ;
+ * A8 depend A9 ; A9 depend A7; A7 depend A4
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+108)+(102+103)+(103+104)+(104+105)+(105+106)+(106+101)+(107+104)+(108+109)+(109+107)=1994
+ *
+ */
+
+class Cycle_a_00180_A1 {
+    Cycle_a_00180_A2 a2_0;
+    Cycle_a_00180_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A1(String strObjectName) {
+        a2_0 = null;
+        a8_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00180_A2 {
+    Cycle_a_00180_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00180_A3 {
+    Cycle_a_00180_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00180_A4 {
+    Cycle_a_00180_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00180_A5 {
+    Cycle_a_00180_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00180_A6 {
+    Cycle_a_00180_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A6(String strObjectName) {
+        a1_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00180_A7 {
+    Cycle_a_00180_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A7(String strObjectName) {
+        a4_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00180_A8 {
+    Cycle_a_00180_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A8(String strObjectName) {
+        a9_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+class Cycle_a_00180_A9 {
+    Cycle_a_00180_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A9(String strObjectName) {
+        a7_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+public class Cycle_a_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00180_A1 a1_main = new Cycle_a_00180_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00180_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00180_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00180_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00180_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00180_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a8_0 = new Cycle_a_00180_A8("a8_0");
+        a1_main.a8_0.a9_0 = new Cycle_a_00180_A9("a9_0");
+        a1_main.a8_0.a9_0.a7_0 = new Cycle_a_00180_A7("a7_0");
+        a1_main.a8_0.a9_0.a7_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_main.a8_0.add();
+        a1_main.a8_0.a9_0.add();
+        a1_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_main.a8_0.sum + a1_main.a8_0.a9_0.sum + a1_main.a8_0.a9_0.a7_0.sum;
+        if (result == 1994)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0002-rc-function-Cycle_a_00190/Cycle_a_00190.java b/test/testsuite/ouroboros/memory_management/Function/RC0002-rc-function-Cycle_a_00190/Cycle_a_00190.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ffd22c332398a2868f01f55d530208c711b7895
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0002-rc-function-Cycle_a_00190/Cycle_a_00190.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00190 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00190.java
+ *- @ExecuteClass: Cycle_a_00190
+ *- @ExecuteArgs:
+ A1 depend A2;  A10 depend A8 ;
+ * A2 depend A3 ; A3 depend A4; A4 depend A5 ; A5 depend A6; A6 depend A1 A10 ;
+ * A8 depend A9 ; A9 depend A7; A7 depend A5
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+104)+(104+105)+(105+106)+(106+101+110)+(107+105)+(108+109)+(109+107)+(110+108)=2215
+ *
+ */
+
+class Cycle_a_00190_A1 {
+    Cycle_a_00190_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00190_A2 {
+    Cycle_a_00190_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00190_A3 {
+    Cycle_a_00190_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00190_A4 {
+    Cycle_a_00190_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00190_A5 {
+    Cycle_a_00190_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00190_A6 {
+    Cycle_a_00190_A1 a1_0;
+    Cycle_a_00190_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A6(String strObjectName) {
+        a1_0 = null;
+        a10_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a10_0.a;
+    }
+}
+
+class Cycle_a_00190_A7 {
+    Cycle_a_00190_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A7(String strObjectName) {
+        a5_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00190_A8 {
+    Cycle_a_00190_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A8(String strObjectName) {
+        a9_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+class Cycle_a_00190_A9 {
+    Cycle_a_00190_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A9(String strObjectName) {
+        a7_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00190_A10 {
+    Cycle_a_00190_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A10(String strObjectName) {
+        a8_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+public class Cycle_a_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00190_A1 a1_main = new Cycle_a_00190_A1("a1_main");
+        Cycle_a_00190_A10 a10_main = new Cycle_a_00190_A10("a10_main");
+        a1_main.a2_0 = new Cycle_a_00190_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00190_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00190_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00190_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00190_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_main;
+
+        a10_main.a8_0 = new Cycle_a_00190_A8("a8_0");
+        a10_main.a8_0.a9_0 = new Cycle_a_00190_A9("a9_0");
+        a10_main.a8_0.a9_0.a7_0 = new Cycle_a_00190_A7("a7_0");
+        a10_main.a8_0.a9_0.a7_0.a5_0 = a1_main.a2_0.a3_0.a4_0.a5_0;
+
+        a1_main.add();
+        a10_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_main.a8_0.add();
+        a10_main.a8_0.a9_0.add();
+        a10_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a10_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_main.a8_0.sum + a10_main.a8_0.a9_0.sum + a10_main.a8_0.a9_0.a7_0.sum;
+        if (result == 2215)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0003-rc-function-Cycle_a_00200/Cycle_a_00200.java b/test/testsuite/ouroboros/memory_management/Function/RC0003-rc-function-Cycle_a_00200/Cycle_a_00200.java
new file mode 100644
index 0000000000000000000000000000000000000000..733119b9f47164f5b391f709ed8a848b69db5bb3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0003-rc-function-Cycle_a_00200/Cycle_a_00200.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00200 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00200.java
+ *- @ExecuteClass: Cycle_a_00200
+ *- @ExecuteArgs:
+ * A1 depend A2;  A4 depend A3 ;
+ * A2 depend A3 A6 A7; A3 depend A1 A5; A5 depend A4; A6 depend A7 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+106+107)+(102+103)+(103+101+105)+(104+103)+(105+104)+(106+107)+(107+107)=1773
+ *
+ */
+
+class Cycle_a_00200_A1 {
+    Cycle_a_00200_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00200_A2 {
+    Cycle_a_00200_A3 a3_0;
+    Cycle_a_00200_A6 a6_0;
+    Cycle_a_00200_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A2(String strObjectName) {
+        a3_0 = null;
+        a6_0 = null;
+        a7_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a6_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00200_A3 {
+    Cycle_a_00200_A1 a1_0;
+    Cycle_a_00200_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_00200_A4 {
+    Cycle_a_00200_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00200_A5 {
+    Cycle_a_00200_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A5(String strObjectName) {
+        a4_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00200_A6 {
+    Cycle_a_00200_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00200_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Cycle_a_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00200_A1 a1_main = new Cycle_a_00200_A1("a1_main");
+        Cycle_a_00200_A4 a4_main = new Cycle_a_00200_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00200_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00200_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00200_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a6_0 = new Cycle_a_00200_A6("a6_0");
+        a1_main.a2_0.a6_0.a7_0 = new Cycle_a_00200_A7("a7_0");
+        a1_main.a2_0.a7_0 = a1_main.a2_0.a6_0.a7_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a6_0.add();
+        a1_main.a2_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a6_0.sum + a1_main.a2_0.a6_0.a7_0.sum;
+        if (result == 1773)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0004-rc-function-Cycle_a_00210/Cycle_a_00210.java b/test/testsuite/ouroboros/memory_management/Function/RC0004-rc-function-Cycle_a_00210/Cycle_a_00210.java
new file mode 100644
index 0000000000000000000000000000000000000000..cce5367e44fddbe286228565199e00fb1e85a164
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0004-rc-function-Cycle_a_00210/Cycle_a_00210.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00210 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00210.java
+ *- @ExecuteClass: Cycle_a_00210
+ *- @ExecuteArgs:
+ * A1 depend A2;  A4 depend A3 ;
+ * A2 depend A3; A3 depend A1 A5 A6; A5 depend A4; A6 depend A7 ; A7 depend A3;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+105+106)+(104+103)+(105+104)+(106+107)+(107+103)=1662
+ *
+ */
+
+class Cycle_a_00210_A1 {
+    Cycle_a_00210_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00210_A2 {
+    Cycle_a_00210_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00210_A3 {
+    Cycle_a_00210_A1 a1_0;
+    Cycle_a_00210_A5 a5_0;
+    Cycle_a_00210_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a6_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00210_A4 {
+    Cycle_a_00210_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00210_A5 {
+    Cycle_a_00210_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A5(String strObjectName) {
+        a4_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00210_A6 {
+    Cycle_a_00210_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00210_A7 {
+    Cycle_a_00210_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A7(String strObjectName) {
+        a3_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00210 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00210_A1 a1_main = new Cycle_a_00210_A1("a1_main");
+        Cycle_a_00210_A4 a4_main = new Cycle_a_00210_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00210_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00210_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00210_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00210_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0 = new Cycle_a_00210_A7("a7_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        a1_main.a2_0.a3_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a6_0.sum + a1_main.a2_0.a3_0.a6_0.a7_0.sum;
+        if (result == 1662)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0005-rc-function-Cycle_a_00220/Cycle_a_00220.java b/test/testsuite/ouroboros/memory_management/Function/RC0005-rc-function-Cycle_a_00220/Cycle_a_00220.java
new file mode 100644
index 0000000000000000000000000000000000000000..4530d9ffe5b90061f056f8d8579e0991aace3241
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0005-rc-function-Cycle_a_00220/Cycle_a_00220.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00220.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00220 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00220.java
+ *- @ExecuteClass: Cycle_a_00220
+ *- @ExecuteArgs:
+ * A1 depend A2;  A5 depend A4 A7;
+ * A2 depend A3; A3 depend A1 A5; A4 depend A3 ; A6 depend A5 A7 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+105)+(104+103)+(105+104+107)+(106+105+107)+(107+107)=1772
+ *
+ */
+
+class Cycle_a_00220_A1 {
+    Cycle_a_00220_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00220_A2 {
+    Cycle_a_00220_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00220_A3 {
+    Cycle_a_00220_A1 a1_0;
+    Cycle_a_00220_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_00220_A4 {
+    Cycle_a_00220_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00220_A5 {
+    Cycle_a_00220_A4 a4_0;
+    Cycle_a_00220_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A5(String strObjectName) {
+        a4_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00220_A6 {
+    Cycle_a_00220_A5 a5_0;
+    Cycle_a_00220_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A6(String strObjectName) {
+        a5_0 = null;
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00220_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Cycle_a_00220 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00220_A1 a1_main = new Cycle_a_00220_A1("a1_main");
+        Cycle_a_00220_A4 a4_main = new Cycle_a_00220_A4("a4_main");
+        Cycle_a_00220_A6 a6_main = new Cycle_a_00220_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00220_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00220_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00220_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_00220_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        if (result == 1772)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0006-rc-function-Cycle_a_00230/Cycle_a_00230.java b/test/testsuite/ouroboros/memory_management/Function/RC0006-rc-function-Cycle_a_00230/Cycle_a_00230.java
new file mode 100644
index 0000000000000000000000000000000000000000..25e907b0932cd85388b7d45b26042170c33fbcdb
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0006-rc-function-Cycle_a_00230/Cycle_a_00230.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00230.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00230 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00230.java
+ *- @ExecuteClass: Cycle_a_00230
+ *- @ExecuteArgs:
+ * A1 depend A2;  A5 depend A3 A6 A7;
+ * A2 depend A3; A3 depend A1 A4; A4 depend A5 ; A6 depend A7 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+104)+(104+105)+(105+103+106+107)+(106+107)+(107+107)=1773
+ *
+ */
+
+class Cycle_a_00230_A1 {
+    Cycle_a_00230_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00230_A2 {
+    Cycle_a_00230_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00230_A3 {
+    Cycle_a_00230_A1 a1_0;
+    Cycle_a_00230_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00230_A4 {
+    Cycle_a_00230_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00230_A5 {
+    Cycle_a_00230_A3 a3_0;
+    Cycle_a_00230_A6 a6_0;
+    Cycle_a_00230_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A5(String strObjectName) {
+        a3_0 = null;
+        a6_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a6_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00230_A6 {
+    Cycle_a_00230_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00230_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Cycle_a_00230 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00230_A1 a1_main = new Cycle_a_00230_A1("a1_main");
+        Cycle_a_00230_A5 a5_main = new Cycle_a_00230_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00230_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00230_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00230_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a7_0 = new Cycle_a_00230_A7("a7_0");
+        a5_main.a6_0 = new Cycle_a_00230_A6("a6_0");
+        a5_main.a6_0.a7_0 = a5_main.a7_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a5_main.a7_0.add();
+        a5_main.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a5_main.a6_0.sum + a5_main.a7_0.sum;
+        if (result == 1773)
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0007-rc-function-Cycle_a_00240/Cycle_a_00240.java b/test/testsuite/ouroboros/memory_management/Function/RC0007-rc-function-Cycle_a_00240/Cycle_a_00240.java
new file mode 100644
index 0000000000000000000000000000000000000000..280ab102671e285870b46f25f67594b9bfe0a051
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0007-rc-function-Cycle_a_00240/Cycle_a_00240.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00240 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00240.java
+ *- @ExecuteClass: Cycle_a_00240
+ *- @ExecuteArgs:
+ * A1 depend A2 A6;  A5 depend A3;
+ * A2 depend A3; A3 depend A1 A4; A4 depend A5 ; A6 depend A7 ; A7 depend A1;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+106)+(102+103)+(103+101+104)+(104+105)+(105+103)+(106+107)+(107+101)=1660
+ *
+ */
+
+class Cycle_a_00240_A1 {
+    Cycle_a_00240_A2 a2_0;
+    Cycle_a_00240_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A1(String strObjectName) {
+        a2_0 = null;
+        a6_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00240_A2 {
+    Cycle_a_00240_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00240_A3 {
+    Cycle_a_00240_A1 a1_0;
+    Cycle_a_00240_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00240_A4 {
+    Cycle_a_00240_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00240_A5 {
+    Cycle_a_00240_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00240_A6 {
+    Cycle_a_00240_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00240_A7 {
+    Cycle_a_00240_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A7(String strObjectName) {
+        a1_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_a_00240 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00240_A1 a1_main = new Cycle_a_00240_A1("a1_main");
+        Cycle_a_00240_A5 a5_main = new Cycle_a_00240_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00240_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00240_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a6_0 = new Cycle_a_00240_A6("a6_0");
+        a1_main.a6_0.a7_0 = new Cycle_a_00240_A7("a7_0");
+        a1_main.a6_0.a7_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a6_0.add();
+        a1_main.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a6_0.sum + a1_main.a6_0.a7_0.sum;
+        if (result == 1660)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0008-rc-function-Cycle_a_00250/Cycle_a_00250.java b/test/testsuite/ouroboros/memory_management/Function/RC0008-rc-function-Cycle_a_00250/Cycle_a_00250.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a1ffbc0b8b165d4fb044db2d400957f25932c02
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0008-rc-function-Cycle_a_00250/Cycle_a_00250.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00250.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00250 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00250.java
+ *- @ExecuteClass: Cycle_a_00250
+ *- @ExecuteArgs:
+ * A1 depend A2;  A6 depend A3
+ * A2 depend A3; A3 depend A1 A2 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+101+103)+(103+101+105)+(105+106)+(106+103)=1238
+ *
+ */
+
+class Cycle_a_00250_A1 {
+    Cycle_a_00250_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00250_A2 {
+    Cycle_a_00250_A1 a1_0;
+    Cycle_a_00250_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00250_A3 {
+    Cycle_a_00250_A1 a1_0;
+    Cycle_a_00250_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00250_A5 {
+    Cycle_a_00250_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00250_A6 {
+    Cycle_a_00250_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00250 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00250_A1 a1_main = new Cycle_a_00250_A1("a1_main");
+        Cycle_a_00250_A6 a6_main = new Cycle_a_00250_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00250_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00250_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00250_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1238)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0009-rc-function-Cycle_a_00260/Cycle_a_00260.java b/test/testsuite/ouroboros/memory_management/Function/RC0009-rc-function-Cycle_a_00260/Cycle_a_00260.java
new file mode 100644
index 0000000000000000000000000000000000000000..424f4bff581dbb98d6f8ab1150d7bbefd8eb482f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0009-rc-function-Cycle_a_00260/Cycle_a_00260.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00260.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00260 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00260.java
+ *- @ExecuteClass: Cycle_a_00260
+ *- @ExecuteArgs:
+ ** A1 depend A2;  A6 depend A3
+ * A2 depend A3; A3 depend A1 A2 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+102+105)+(105+106)+(106+103)=1239
+ *
+ */
+
+class Cycle_a_00260_A1 {
+    Cycle_a_00260_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00260_A2 {
+    Cycle_a_00260_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00260_A3 {
+    Cycle_a_00260_A1 a1_0;
+    Cycle_a_00260_A2 a2_0;
+    Cycle_a_00260_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00260_A5 {
+    Cycle_a_00260_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00260_A6 {
+    Cycle_a_00260_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00260 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00260_A1 a1_main = new Cycle_a_00260_A1("a1_main");
+        Cycle_a_00260_A6 a6_main = new Cycle_a_00260_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00260_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00260_A3("a3_0");
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00260_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1239)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0010-rc-function-Cycle_a_00270/Cycle_a_00270.java b/test/testsuite/ouroboros/memory_management/Function/RC0010-rc-function-Cycle_a_00270/Cycle_a_00270.java
new file mode 100644
index 0000000000000000000000000000000000000000..a5f5e90910eba9318fbbdb1c60c5313636d2312c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0010-rc-function-Cycle_a_00270/Cycle_a_00270.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00270.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00270 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00270.java
+ *- @ExecuteClass: Cycle_a_00270
+ *- @ExecuteArgs:
+ *  A1 depend A2 A3;  A6 depend A3
+ * A2 depend A3; A3 depend A1 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+103)+(102+103)+(103+101+105)+(105+106)+(106+103)=1240
+ *
+ */
+
+class Cycle_a_00270_A1 {
+    Cycle_a_00270_A2 a2_0;
+    Cycle_a_00270_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00270_A2 {
+    Cycle_a_00270_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00270_A3 {
+    Cycle_a_00270_A1 a1_0;
+    Cycle_a_00270_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00270_A5 {
+    Cycle_a_00270_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00270_A6 {
+    Cycle_a_00270_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00270 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00270_A1 a1_main = new Cycle_a_00270_A1("a1_main");
+        Cycle_a_00270_A6 a6_main = new Cycle_a_00270_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00270_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00270_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00270_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1240)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0011-rc-function-Cycle_a_00280/Cycle_a_00280.java b/test/testsuite/ouroboros/memory_management/Function/RC0011-rc-function-Cycle_a_00280/Cycle_a_00280.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb98d73f7c01383a48e00ede2374f44cc3043c12
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0011-rc-function-Cycle_a_00280/Cycle_a_00280.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00280.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00280 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00280.java
+ *- @ExecuteClass: Cycle_a_00280
+ *- @ExecuteArgs:
+ *  A1 depend A2 A3;  A6 depend A3
+ * A2 depend A1 A3; A3 depend A1 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+103)+(102+101+103)+(103+101+102+105)+(105+106)+(106+103)=1443
+ *
+ */
+
+class Cycle_a_00280_A1 {
+    Cycle_a_00280_A2 a2_0;
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00280_A2 {
+    Cycle_a_00280_A1 a1_0;
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00280_A3 {
+    Cycle_a_00280_A1 a1_0;
+    Cycle_a_00280_A2 a2_0;
+    Cycle_a_00280_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00280_A5 {
+    Cycle_a_00280_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00280_A6 {
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00280 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1443)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0012-rc-function-Cycle_a_00290/Cycle_a_00290.java b/test/testsuite/ouroboros/memory_management/Function/RC0012-rc-function-Cycle_a_00290/Cycle_a_00290.java
new file mode 100644
index 0000000000000000000000000000000000000000..7403fd7594dbbb222677aaac8dec3a328718e194
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0012-rc-function-Cycle_a_00290/Cycle_a_00290.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00290.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00290 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00290.java
+ *- @ExecuteClass: Cycle_a_00290
+ *- @ExecuteArgs:
+ *  A1 depend A2;  A5 depend A3
+ * A2 depend A3; A3 depend A1 A4 A6; A4 depend A5 ;A6 depend A2;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+104+106)+(104+105)+(105+103)+(106+102)=1447
+ *
+ */
+
+class Cycle_a_00290_A1 {
+    Cycle_a_00290_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00290_A2 {
+    Cycle_a_00290_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00290_A3 {
+    Cycle_a_00290_A1 a1_0;
+    Cycle_a_00290_A4 a4_0;
+    Cycle_a_00290_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a6_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a6_0.a;
+    }
+}
+
+
+class Cycle_a_00290_A4 {
+    Cycle_a_00290_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00290_A5 {
+    Cycle_a_00290_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00290_A6 {
+    Cycle_a_00290_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A6(String strObjectName) {
+        a2_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00290 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00290_A1 a1_main = new Cycle_a_00290_A1("a1_main");
+        Cycle_a_00290_A5 a5_main = new Cycle_a_00290_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00290_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00290_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00290_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00290_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a2_0 = a1_main.a2_0;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a6_0.sum;
+
+        if (result == 1447)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0013-rc-function-Cycle_a_00300/Cycle_a_00300.java b/test/testsuite/ouroboros/memory_management/Function/RC0013-rc-function-Cycle_a_00300/Cycle_a_00300.java
new file mode 100644
index 0000000000000000000000000000000000000000..155e91acaf84cb26318278a05178ebabfb2fd36d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0013-rc-function-Cycle_a_00300/Cycle_a_00300.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00300.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00300 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00300.java
+ *- @ExecuteClass: Cycle_a_00300
+ *- @ExecuteArgs:
+ * A1 depend A2;  A5 depend A3
+ * A2 depend A3; A3 depend A1 A4; A4 depend A5 A6 ;A6 depend A3 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+104)+(104+105+106)+(105+103)+(106+103)=1448
+ *
+ */
+
+class Cycle_a_00300_A1 {
+    Cycle_a_00300_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00300_A2 {
+    Cycle_a_00300_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00300_A3 {
+    Cycle_a_00300_A1 a1_0;
+    Cycle_a_00300_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00300_A4 {
+    Cycle_a_00300_A5 a5_0;
+    Cycle_a_00300_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A4(String strObjectName) {
+        a5_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00300_A5 {
+    Cycle_a_00300_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00300_A6 {
+    Cycle_a_00300_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00300 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00300_A1 a1_main = new Cycle_a_00300_A1("a1_main");
+        Cycle_a_00300_A5 a5_main = new Cycle_a_00300_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00300_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00300_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00300_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a6_0 = new Cycle_a_00300_A6("a6_0");
+        a5_main.a3_0.a4_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a5_0 = a5_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1448)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0014-rc-function-Cycle_a_00310/Cycle_a_00310.java b/test/testsuite/ouroboros/memory_management/Function/RC0014-rc-function-Cycle_a_00310/Cycle_a_00310.java
new file mode 100644
index 0000000000000000000000000000000000000000..5647c4df4936bf0582ccdee8bbc715eddb18f79c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0014-rc-function-Cycle_a_00310/Cycle_a_00310.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00310.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00310 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00310.java
+ *- @ExecuteClass: Cycle_a_00310
+ *- @ExecuteArgs:
+ *  A1 depend A2 A4; A4 depend A6 ; A6 depend A1 A3
+ * A2 depend A3; A3 depend A1 A5; A5 depend A6 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+104)+(102+103)+(103+101+105)+(104+106)+(105+106)+(106+101+103)=1552
+ *
+ */
+
+class Cycle_a_00310_A1 {
+    Cycle_a_00310_A2 a2_0;
+    Cycle_a_00310_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A1(String strObjectName) {
+        a2_0 = null;
+        a4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00310_A2 {
+    Cycle_a_00310_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00310_A3 {
+    Cycle_a_00310_A1 a1_0;
+    Cycle_a_00310_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00310_A4 {
+    Cycle_a_00310_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A4(String strObjectName) {
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00310_A5 {
+    Cycle_a_00310_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00310_A6 {
+    Cycle_a_00310_A1 a1_0;
+    Cycle_a_00310_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00310 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00310_A1 a1_main = new Cycle_a_00310_A1("a1_main");
+        Cycle_a_00310_A4 a4_main = new Cycle_a_00310_A4("a4_main");
+        Cycle_a_00310_A6 a6_main = new Cycle_a_00310_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00310_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00310_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00310_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a4_0 = a4_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a4_main.a6_0 = a6_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+
+        if (result == 1552)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0015-rc-function-Cycle_a_00320/Cycle_a_00320.java b/test/testsuite/ouroboros/memory_management/Function/RC0015-rc-function-Cycle_a_00320/Cycle_a_00320.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb8d301ff081ff5eb5ee415174b60c9fb39cd022
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0015-rc-function-Cycle_a_00320/Cycle_a_00320.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00320.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00320 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00320.java
+ *- @ExecuteClass: Cycle_a_00320
+ *- @ExecuteArgs:
+ *  A1 depend A2 ; A4 depend A5 ; A6 depend A1 A3 A4; A6 depend A1 A3 A4;
+ * A2 depend A3; A3 depend A1 A5; A5 depend A6 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+105)+(104+105)+(105+106)+(106+101+103+104)=1551
+ *
+ */
+
+class Cycle_a_00320_A1 {
+    Cycle_a_00320_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00320_A2 {
+    Cycle_a_00320_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00320_A3 {
+    Cycle_a_00320_A1 a1_0;
+    Cycle_a_00320_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00320_A4 {
+    Cycle_a_00320_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00320_A5 {
+    Cycle_a_00320_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00320_A6 {
+    Cycle_a_00320_A1 a1_0;
+    Cycle_a_00320_A3 a3_0;
+    Cycle_a_00320_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+
+
+public class Cycle_a_00320 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00320_A1 a1_main = new Cycle_a_00320_A1("a1_main");
+        Cycle_a_00320_A4 a4_main = new Cycle_a_00320_A4("a4_main");
+        Cycle_a_00320_A6 a6_main = new Cycle_a_00320_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00320_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00320_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00320_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a6_main.a4_0 = a4_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+
+        if (result == 1551)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0016-rc-function-Cycle_a_00330/Cycle_a_00330.java b/test/testsuite/ouroboros/memory_management/Function/RC0016-rc-function-Cycle_a_00330/Cycle_a_00330.java
new file mode 100644
index 0000000000000000000000000000000000000000..d27a02e09e4745610ad7fe5ed991dfbf9e536367
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0016-rc-function-Cycle_a_00330/Cycle_a_00330.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00330.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00330 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00330.java
+ *- @ExecuteClass: Cycle_a_00330
+ *- @ExecuteArgs:
+ * A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5 A8; A5 depend A6 A8;
+ * A7 depend A3 ; A8 depend A7;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105)+(104+101)+(105+106+108)+(106+101+103)+(107+103)+(108+107)=2080
+ *
+ */
+
+class Cycle_a_00330_A1 {
+    Cycle_a_00330_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00330_A2 {
+    Cycle_a_00330_A3 a3_0;
+    Cycle_a_00330_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00330_A3 {
+    Cycle_a_00330_A1 a1_0;
+    Cycle_a_00330_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00330_A4 {
+    Cycle_a_00330_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00330_A5 {
+    Cycle_a_00330_A6 a6_0;
+    Cycle_a_00330_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00330_A6 {
+    Cycle_a_00330_A1 a1_0;
+    Cycle_a_00330_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00330_A7 {
+    Cycle_a_00330_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A7(String strObjectName) {
+        a3_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00330_A8 {
+    Cycle_a_00330_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+public class Cycle_a_00330 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00330_A1 a1_main = new Cycle_a_00330_A1("a1_main");
+        Cycle_a_00330_A4 a4_main = new Cycle_a_00330_A4("a4_main");
+        Cycle_a_00330_A6 a6_main = new Cycle_a_00330_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00330_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00330_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00330_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00330_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00330_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+
+        if (result == 2080)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0017-rc-function-Cycle_a_00340/Cycle_a_00340.java b/test/testsuite/ouroboros/memory_management/Function/RC0017-rc-function-Cycle_a_00340/Cycle_a_00340.java
new file mode 100644
index 0000000000000000000000000000000000000000..80d2a25135bbf71f45876e9905c67d09b71bc2d8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0017-rc-function-Cycle_a_00340/Cycle_a_00340.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00340.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00340 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00340.java
+ *- @ExecuteClass: Cycle_a_00340
+ *- @ExecuteArgs:
+ *  A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5 A8; A5 depend A6;
+ * A7 depend A2 ; A8 depend A7;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105+108)+(104+101)+(105+106)+(106+101+103)+(107+102)+(108+107)=2079
+ *
+ */
+
+class Cycle_a_00340_A1 {
+    Cycle_a_00340_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00340_A2 {
+    Cycle_a_00340_A3 a3_0;
+    Cycle_a_00340_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00340_A3 {
+    Cycle_a_00340_A1 a1_0;
+    Cycle_a_00340_A5 a5_0;
+    Cycle_a_00340_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a8_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a8_0.a;
+    }
+}
+
+
+class Cycle_a_00340_A4 {
+    Cycle_a_00340_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00340_A5 {
+    Cycle_a_00340_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00340_A6 {
+    Cycle_a_00340_A1 a1_0;
+    Cycle_a_00340_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00340_A7 {
+    Cycle_a_00340_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_00340_A8 {
+    Cycle_a_00340_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+public class Cycle_a_00340 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00340_A1 a1_main = new Cycle_a_00340_A1("a1_main");
+        Cycle_a_00340_A4 a4_main = new Cycle_a_00340_A4("a4_main");
+        Cycle_a_00340_A6 a6_main = new Cycle_a_00340_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00340_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00340_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00340_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a8_0 = new Cycle_a_00340_A8("a8_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0 = new Cycle_a_00340_A7("a7_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a8_0.add();
+        a1_main.a2_0.a3_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a8_0.a7_0.sum + a6_main.a3_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2079)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0018-rc-function-Cycle_a_00350/Cycle_a_00350.java b/test/testsuite/ouroboros/memory_management/Function/RC0018-rc-function-Cycle_a_00350/Cycle_a_00350.java
new file mode 100644
index 0000000000000000000000000000000000000000..1aee1e42825a4d3cb1b941bbc117a90d98f5dbf1
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0018-rc-function-Cycle_a_00350/Cycle_a_00350.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00350.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination: Cycle_a_00350 in RC测试-Cycle-01
+ * -@Brief:functionTest
+ * -@Expect:ExpectResult\nExpectResult\n
+ * -@Priority: High
+ * -@Source: Cycle_a_00350.java
+ * -@ExecuteClass: Cycle_a_00350
+ * -@ExecuteArgs:
+ * A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5; A5 depend A6 A8;
+ * A7 depend A2 ; A8 depend A7;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105)+(104+101)+(105+106+108)+(106+101+103)+(107+102)+(108+107)=2079
+ */
+
+class Cycle_a_00350_A1 {
+    Cycle_a_00350_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00350_A2 {
+    Cycle_a_00350_A3 a3_0;
+    Cycle_a_00350_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00350_A3 {
+    Cycle_a_00350_A1 a1_0;
+    Cycle_a_00350_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_00350_A4 {
+    Cycle_a_00350_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00350_A5 {
+    Cycle_a_00350_A6 a6_0;
+    Cycle_a_00350_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00350_A6 {
+    Cycle_a_00350_A1 a1_0;
+    Cycle_a_00350_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00350_A7 {
+    Cycle_a_00350_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00350_A8 {
+    Cycle_a_00350_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+public class Cycle_a_00350 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00350_A1 a1_main = new Cycle_a_00350_A1("a1_main");
+        Cycle_a_00350_A4 a4_main = new Cycle_a_00350_A4("a4_main");
+        Cycle_a_00350_A6 a6_main = new Cycle_a_00350_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00350_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00350_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00350_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00350_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00350_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum
+                + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        if (result == 2079) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0019-rc-function-Cycle_a_00360/Cycle_a_00360.java b/test/testsuite/ouroboros/memory_management/Function/RC0019-rc-function-Cycle_a_00360/Cycle_a_00360.java
new file mode 100644
index 0000000000000000000000000000000000000000..b7f61d735a83ad7a5bec1d2ac4e4e73d89fdc270
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0019-rc-function-Cycle_a_00360/Cycle_a_00360.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00360.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00360 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00360.java
+ *- @ExecuteClass: Cycle_a_00360
+ *- @ExecuteArgs:
+ *  A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5; A5 depend A6 A8 A9;
+ * A7 depend A2 ; A8 depend A7;
+ * A9 depend A2 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105)+(104+101)+(105+106+108+109)+(106+101+103)+(107+102)+(108+107)+(109+102)=2399
+ *
+ */
+
+class Cycle_a_00360_A1 {
+    Cycle_a_00360_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00360_A2 {
+    Cycle_a_00360_A3 a3_0;
+    Cycle_a_00360_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00360_A3 {
+    Cycle_a_00360_A1 a1_0;
+    Cycle_a_00360_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00360_A4 {
+    Cycle_a_00360_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00360_A5 {
+    Cycle_a_00360_A6 a6_0;
+    Cycle_a_00360_A8 a8_0;
+    Cycle_a_00360_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a9_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a + a9_0.a;
+    }
+}
+
+class Cycle_a_00360_A6 {
+    Cycle_a_00360_A1 a1_0;
+    Cycle_a_00360_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00360_A7 {
+    Cycle_a_00360_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_00360_A8 {
+    Cycle_a_00360_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_00360_A9 {
+    Cycle_a_00360_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A9(String strObjectName) {
+        a2_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00360 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00360_A1 a1_main = new Cycle_a_00360_A1("a1_main");
+        Cycle_a_00360_A4 a4_main = new Cycle_a_00360_A4("a4_main");
+        Cycle_a_00360_A6 a6_main = new Cycle_a_00360_A6("a6_main");
+        Cycle_a_00360_A9 a9_main = new Cycle_a_00360_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00360_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00360_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00360_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00360_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00360_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0.a9_0 = a9_main;
+        a9_main.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2399)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0020-rc-function-Cycle_a_00370/Cycle_a_00370.java b/test/testsuite/ouroboros/memory_management/Function/RC0020-rc-function-Cycle_a_00370/Cycle_a_00370.java
new file mode 100644
index 0000000000000000000000000000000000000000..26c1fef856776e94e0b77563645b2c928cc7e403
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0020-rc-function-Cycle_a_00370/Cycle_a_00370.java
@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00370.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00370 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00370.java
+ *- @ExecuteClass: Cycle_a_00370
+ *- @ExecuteArgs:
+ *  A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5 A10; A5 depend A6 A8
+ * A7 depend A2 ; A8 depend A7;
+ * A8 depend A6 ; A10 depend A9;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109 A10.a=1001
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105+110)+(104+101)+(105+106+108)+(106+101+103)+(107+102)+(108+107)+(109+106)+(110+109)=2623
+ *
+ */
+
+class Cycle_a_00370_A1 {
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00370_A2 {
+    Cycle_a_00370_A3 a3_0;
+    Cycle_a_00370_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00370_A3 {
+    Cycle_a_00370_A1 a1_0;
+    Cycle_a_00370_A5 a5_0;
+    Cycle_a_00370_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a10_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a10_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A4 {
+    Cycle_a_00370_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00370_A5 {
+    Cycle_a_00370_A6 a6_0;
+    Cycle_a_00370_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00370_A6 {
+    Cycle_a_00370_A1 a1_0;
+    Cycle_a_00370_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A7 {
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A8 {
+    Cycle_a_00370_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A9 {
+    Cycle_a_00370_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A9(String strObjectName) {
+        a6_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00370_A10 {
+    Cycle_a_00370_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A10(String strObjectName) {
+        a9_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+public class Cycle_a_00370 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2623)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0021-rc-function-Cycle_a_00380/Cycle_a_00380.java b/test/testsuite/ouroboros/memory_management/Function/RC0021-rc-function-Cycle_a_00380/Cycle_a_00380.java
new file mode 100644
index 0000000000000000000000000000000000000000..b61979bd8c56146baf279dc7f490c3a7154285ed
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0021-rc-function-Cycle_a_00380/Cycle_a_00380.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00380.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00380 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00380.java
+ *- @ExecuteClass: Cycle_a_00380
+ *- @ExecuteArgs:
+ * A1 depend A2 A3; A2 depend A1 A3; A3 depend A1
+ * A1.a=101 A2.a=102 A3.a=103
+ * RC-Testing_Result=(101+102)+(102+101+103)+(103++101+102)=815
+ *
+ */
+
+class Cycle_a_00380_A1 {
+    Cycle_a_00380_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00380_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00380_A2 {
+    Cycle_a_00380_A1 a1_0;
+    Cycle_a_00380_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00380_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00380_A3 {
+    Cycle_a_00380_A1 a1_0;
+    Cycle_a_00380_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00380_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00380 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00380_A1 a1_main = new Cycle_a_00380_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00380_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00380_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 815)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0022-rc-function-Cycle_a_00390/Cycle_a_00390.java b/test/testsuite/ouroboros/memory_management/Function/RC0022-rc-function-Cycle_a_00390/Cycle_a_00390.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d74ea879d0bbbc4f30e4bd4b8061750937ed057
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0022-rc-function-Cycle_a_00390/Cycle_a_00390.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00390.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00390 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00390.java
+ *- @ExecuteClass: Cycle_a_00390
+ *- @ExecuteArgs:
+ * A1 depend A2 A3; A2 depend A1 A3; A3 depend A1 A2
+ * A1.a=101 A2.a=102 A3.a=103
+ * RC-Testing_Result=(101+102+103)+(102+101+103)+(103+101+102)=918
+ *
+ */
+
+class Cycle_a_00390_A1 {
+    Cycle_a_00390_A2 a2_0;
+    Cycle_a_00390_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00390_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00390_A2 {
+    Cycle_a_00390_A1 a1_0;
+    Cycle_a_00390_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00390_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00390_A3 {
+    Cycle_a_00390_A1 a1_0;
+    Cycle_a_00390_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00390_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00390 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00390_A1 a1_main = new Cycle_a_00390_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00390_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00390_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 918)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0023-rc-function-Cycle_a_00400/Cycle_a_00400.java b/test/testsuite/ouroboros/memory_management/Function/RC0023-rc-function-Cycle_a_00400/Cycle_a_00400.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bb0ac07321229c9763e6a831e20550add853e30
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0023-rc-function-Cycle_a_00400/Cycle_a_00400.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00400.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00400 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00400.java
+ *- @ExecuteClass: Cycle_a_00400
+ *- @ExecuteArgs:
+ * A1 depend A2 A4; A2 depend A3; A3 depend A1 ; A4 depend A3
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106 A7.a=107
+ * RC-Testing_Result=(101+102+104)+(102+103)+(103+101)+(104+103)=923
+ *
+ */
+
+class Cycle_a_00400_A1 {
+    Cycle_a_00400_A2 a2_0;
+    Cycle_a_00400_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00400_A1(String strObjectName) {
+        a2_0 = null;
+        a4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00400_A2 {
+    Cycle_a_00400_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00400_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00400_A3 {
+    Cycle_a_00400_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00400_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00400_A4 {
+    Cycle_a_00400_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00400_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00400 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00400_A1 a1_main = new Cycle_a_00400_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00400_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00400_A3("a3_0");
+        a1_main.a4_0 = new Cycle_a_00400_A4("a4_0");
+        a1_main.a4_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 923)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0024-rc-function-Cycle_a_00410/Cycle_a_00410.java b/test/testsuite/ouroboros/memory_management/Function/RC0024-rc-function-Cycle_a_00410/Cycle_a_00410.java
new file mode 100644
index 0000000000000000000000000000000000000000..65c241f3163016056f7f3033df713fe65c0f9fbf
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0024-rc-function-Cycle_a_00410/Cycle_a_00410.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00410.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00410 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00410.java
+ *- @ExecuteClass: Cycle_a_00410
+ *- @ExecuteArgs:
+ * A1 depend A2 ; A2 depend A3 A4; A3 depend A1 ; A4 depend A1
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106 A7.a=107
+ * RC-Testing_Result=(101+102)+(102++103+104)+(103+101)+(104+101)=921
+ *
+ */
+
+class Cycle_a_00410_A1 {
+    Cycle_a_00410_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00410_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00410_A2 {
+    Cycle_a_00410_A3 a3_0;
+    Cycle_a_00410_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00410_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00410_A3 {
+    Cycle_a_00410_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00410_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00410_A4 {
+    Cycle_a_00410_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00410_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_a_00410 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00410_A1 a1_main = new Cycle_a_00410_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00410_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00410_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00410_A4("a4_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 921)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0025-rc-function-Cycle_a_00420/Cycle_a_00420.java b/test/testsuite/ouroboros/memory_management/Function/RC0025-rc-function-Cycle_a_00420/Cycle_a_00420.java
new file mode 100644
index 0000000000000000000000000000000000000000..faed521dfeec7924879fdd0f6377cbe259754ca4
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0025-rc-function-Cycle_a_00420/Cycle_a_00420.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00420.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00420 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00420.java
+ *- @ExecuteClass: Cycle_a_00420
+ *- @ExecuteArgs:
+ * A1 depend A2 A3 ; A2 depend A3 ; A3 depend A4 ; A4 depend A1
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106 A7.a=107
+ * RC-Testing_Result=(101+102+103)+(102+103)+(103+104)+(104+101)=923
+ *
+ */
+
+class Cycle_a_00420_A1 {
+    Cycle_a_00420_A2 a2_0;
+    Cycle_a_00420_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00420_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00420_A2 {
+    Cycle_a_00420_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00420_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00420_A3 {
+    Cycle_a_00420_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00420_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00420_A4 {
+    Cycle_a_00420_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00420_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_a_00420 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00420_A1 a1_main = new Cycle_a_00420_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00420_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00420_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00420_A4("a4_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum;
+        if (result == 923)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0026-rc-function-Cycle_a_00430/Cycle_a_00430.java b/test/testsuite/ouroboros/memory_management/Function/RC0026-rc-function-Cycle_a_00430/Cycle_a_00430.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d14b6a06a40a1e0cec324899236b9fdfcdefad6
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0026-rc-function-Cycle_a_00430/Cycle_a_00430.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00430.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00430 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00430.java
+ *- @ExecuteClass: Cycle_a_00430
+ *- @ExecuteArgs:
+ * A1 depend A2  ; A2 depend A1 A3 A4 ; A3 depend A1 ; A4 depend  A1 A2
+ * A1.a=101 A2.a=102 A3.a=103 ... A4.a=104
+ * RC-Testing_Result=(101+102)+(102+101+103+104)+(103+101)+(104+101+102)=1124
+ *
+ */
+
+class Cycle_a_00430_A1 {
+    Cycle_a_00430_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00430_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00430_A2 {
+    Cycle_a_00430_A1 a1_0;
+    Cycle_a_00430_A3 a3_0;
+    Cycle_a_00430_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00430_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00430_A3 {
+    Cycle_a_00430_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00430_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00430_A4 {
+    Cycle_a_00430_A1 a1_0;
+    Cycle_a_00430_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00430_A4(String strObjectName) {
+        a2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00430 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00430_A1 a1_main = new Cycle_a_00430_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00430_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00430_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00430_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1124)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0027-rc-function-Cycle_a_00440/Cycle_a_00440.java b/test/testsuite/ouroboros/memory_management/Function/RC0027-rc-function-Cycle_a_00440/Cycle_a_00440.java
new file mode 100644
index 0000000000000000000000000000000000000000..98765818399812b4283d066700229d4f888d8378
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0027-rc-function-Cycle_a_00440/Cycle_a_00440.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00440.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00440 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00440.java
+ *- @ExecuteClass: Cycle_a_00440
+ *- @ExecuteArgs:
+ * A1 depend A2  ; A2 depend A1 A3 A4 ; A3 depend A1 ; A4 depend A2
+ * A1.a=101 A2.a=102 A3.a=103 ... A4.a=104
+ * RC-Testing_Result=(101+102)+(102+101+103+104)+(103+101)+(104+102)=1023
+ *
+ */
+
+class Cycle_a_00440_A1 {
+    Cycle_a_00440_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00440_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00440_A2 {
+    Cycle_a_00440_A1 a1_0;
+    Cycle_a_00440_A3 a3_0;
+    Cycle_a_00440_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00440_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00440_A3 {
+    Cycle_a_00440_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00440_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00440_A4 {
+    Cycle_a_00440_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00440_A4(String strObjectName) {
+        a2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00440 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00440_A1 a1_main = new Cycle_a_00440_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00440_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00440_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00440_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        if (result == 1023)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0028-rc-function-Cycle_a_00450/Cycle_a_00450.java b/test/testsuite/ouroboros/memory_management/Function/RC0028-rc-function-Cycle_a_00450/Cycle_a_00450.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0a7f7122544886c4704806dbad62e6811e90792
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0028-rc-function-Cycle_a_00450/Cycle_a_00450.java
@@ -0,0 +1,189 @@
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00450.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00450 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00450.java
+ *- @ExecuteClass: Cycle_a_00450
+ *- @ExecuteArgs:
+ * A1 depend A2  ; A2 depend A3 ; A3 depend A1 A5 ; A5 depend A6 A7
+ * A6 depend A3 ; A7 depend A2
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106 A7.a=107
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+105)+(105+106+107)+(106+103)+(107+102)=1453
+ *
+ */
+
+class Cycle_a_00450_A1 {
+    Cycle_a_00450_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00450_A2 {
+    Cycle_a_00450_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00450_A3 {
+    Cycle_a_00450_A1 a1_0;
+    Cycle_a_00450_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00450_A5 {
+    Cycle_a_00450_A6 a6_0;
+    Cycle_a_00450_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A5(String strObjectName) {
+        a6_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00450_A6 {
+    Cycle_a_00450_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00450_A7 {
+    Cycle_a_00450_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00450 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00450_A1 a1_main = new Cycle_a_00450_A1("a1_main");
+        Cycle_a_00450_A6 a6_main = new Cycle_a_00450_A6("a6_main");
+        Cycle_a_00450_A7 a7_main = new Cycle_a_00450_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00450_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00450_A3("a3_0");
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00450_A5("a5_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = a7_main;
+        a7_main.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a6_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1453)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0029-rc-function-Cycle_a_00460/Cycle_a_00460.java b/test/testsuite/ouroboros/memory_management/Function/RC0029-rc-function-Cycle_a_00460/Cycle_a_00460.java
new file mode 100644
index 0000000000000000000000000000000000000000..86b7158a55fc0f28feda29a62650153730ecddf3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0029-rc-function-Cycle_a_00460/Cycle_a_00460.java
@@ -0,0 +1,194 @@
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00460.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00460 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00460.java
+ *- @ExecuteClass: Cycle_a_00460
+ *- @ExecuteArgs:
+ * A1 depend A2 A4 ; A2 depend A3 ; A3 depend A4 ; A4 depend A1 A6
+ * A5 depend A3 ; A6 depend A1 A5
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106
+ * RC-Testing_Result=(101+102+104)+(102+103)+(103+104)+(104+106+101)+(105+103)+(106+105+101)=1550
+ *
+ */
+
+class Cycle_a_00460_A1 {
+    Cycle_a_00460_A2 a2_0;
+    Cycle_a_00460_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A1(String strObjectName) {
+        a2_0 = null;
+        a4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00460_A2 {
+    Cycle_a_00460_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00460_A3 {
+    Cycle_a_00460_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00460_A4 {
+    Cycle_a_00460_A1 a1_0;
+    Cycle_a_00460_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00460_A5 {
+    Cycle_a_00460_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00460_A6 {
+    Cycle_a_00460_A1 a1_0;
+    Cycle_a_00460_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A6(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+public class Cycle_a_00460 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00460_A1 a1_main = new Cycle_a_00460_A1("a1_main");
+        Cycle_a_00460_A5 a5_main = new Cycle_a_00460_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00460_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00460_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00460_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00460_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1550)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0030-rc-function-Cycle_a_00470/Cycle_a_00470.java b/test/testsuite/ouroboros/memory_management/Function/RC0030-rc-function-Cycle_a_00470/Cycle_a_00470.java
new file mode 100644
index 0000000000000000000000000000000000000000..6cf8b4a081738007822bd01162f1b501e8e212a6
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0030-rc-function-Cycle_a_00470/Cycle_a_00470.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00470.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00470 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00470.java
+ *- @ExecuteClass: Cycle_a_00470
+ *- @ExecuteArgs:
+ * A1 depend A2 ; A2 depend A3 ; A3 depend A4 ; A4 depend A1 A6
+ * A5 depend A3 A1 ; A6 depend A5
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106
+ * RC-Testing_Result=(101+102)+(102+103)+(103+104)+(104+106+101)+(105+103+101)+(106+105)=1446
+ *
+ */
+
+class Cycle_a_00470_A1 {
+    Cycle_a_00470_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00470_A2 {
+    Cycle_a_00470_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00470_A3 {
+    Cycle_a_00470_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00470_A4 {
+    Cycle_a_00470_A1 a1_0;
+    Cycle_a_00470_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00470_A5 {
+    Cycle_a_00470_A1 a1_0;
+    Cycle_a_00470_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A5(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00470_A6 {
+    Cycle_a_00470_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A6(String strObjectName) {
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+public class Cycle_a_00470 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00470_A1 a1_main = new Cycle_a_00470_A1("a1_main");
+        Cycle_a_00470_A5 a5_main = new Cycle_a_00470_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00470_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00470_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00470_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00470_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a1_0 = a1_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        if (result == 1446)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0031-rc-function-Cycle_a_00480/Cycle_a_00480.java b/test/testsuite/ouroboros/memory_management/Function/RC0031-rc-function-Cycle_a_00480/Cycle_a_00480.java
new file mode 100644
index 0000000000000000000000000000000000000000..f93fd68934c5460b0ca75ad457e2029e8f0725f6
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0031-rc-function-Cycle_a_00480/Cycle_a_00480.java
@@ -0,0 +1,193 @@
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00480.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00480 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00480.java
+ *- @ExecuteClass: Cycle_a_00480
+ *- @ExecuteArgs:
+ * A1 depend A2 ; A2 depend A3 ; A3 depend A4 ; A4 depend A1 A6
+ * A5 depend A3 ; A6 depend A1 A4 A5
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106
+ * RC-Testing_Result=(101+102)+(102+103)+(103+104)+(104+106+101)+(105+103)+(106+101+104+105)=1550
+ *
+ */
+
+class Cycle_a_00480_A1 {
+    Cycle_a_00480_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00480_A2 {
+    Cycle_a_00480_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00480_A3 {
+    Cycle_a_00480_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00480_A4 {
+    Cycle_a_00480_A1 a1_0;
+    Cycle_a_00480_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00480_A5 {
+    Cycle_a_00480_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00480_A6 {
+    Cycle_a_00480_A1 a1_0;
+    Cycle_a_00480_A4 a4_0;
+    Cycle_a_00480_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A6(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a5_0.a;
+    }
+}
+
+public class Cycle_a_00480 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00480_A1 a1_main = new Cycle_a_00480_A1("a1_main");
+        Cycle_a_00480_A5 a5_main = new Cycle_a_00480_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00480_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00480_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00480_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00480_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        a5_main.a3_0.add();
+        a5_main.a3_0.a4_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        if (result == 1550)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0032-rc-function-Cycle_a_00490/Cycle_a_00490.java b/test/testsuite/ouroboros/memory_management/Function/RC0032-rc-function-Cycle_a_00490/Cycle_a_00490.java
new file mode 100644
index 0000000000000000000000000000000000000000..b82ca760f0dfa2e05c8c3ffede490670d671ef6f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0032-rc-function-Cycle_a_00490/Cycle_a_00490.java
@@ -0,0 +1,263 @@
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00490.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00490 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00490.java
+ *- @ExecuteClass: Cycle_a_00490
+ *- @ExecuteArgs:
+ * A1 depend A2 ; A2 depend A3 ; A3 depend A1
+ * A4 depend A5 ; A5 depend A6 ; A6 depend A4
+ * A8 depend A7 A5 ; A7 depend A9 ; A9 depend A8
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101)+(104+105)+(105+106)+(106+104+103)+(107+109)+(108+107+105)+(109+108)=2098
+ *
+ */
+
+class Cycle_a_00490_A1 {
+    Cycle_a_00490_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00490_A2 {
+    Cycle_a_00490_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00490_A3 {
+    Cycle_a_00490_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00490_A4 {
+    Cycle_a_00490_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00490_A5 {
+    Cycle_a_00490_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00490_A6 {
+    Cycle_a_00490_A3 a3_0;
+    Cycle_a_00490_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A6(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00490_A7 {
+    Cycle_a_00490_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A7(String strObjectName) {
+        a9_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_a_00490_A8 {
+    Cycle_a_00490_A5 a5_0;
+    Cycle_a_00490_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A8(String strObjectName) {
+        a5_0 = null;
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00490_A9 {
+    Cycle_a_00490_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A9(String strObjectName) {
+        a8_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+
+public class Cycle_a_00490 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00490_A1 a1_main = new Cycle_a_00490_A1("a1_main");
+        Cycle_a_00490_A4 a4_main = new Cycle_a_00490_A4("a4_main");
+        Cycle_a_00490_A7 a7_main = new Cycle_a_00490_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00490_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a5_0 = new Cycle_a_00490_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00490_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+        a4_main.a5_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0.a6_0.a3_0.a1_0 = a1_main;
+        a7_main.a9_0 = new Cycle_a_00490_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00490_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0.a8_0.a5_0 = a4_main.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a6_0.a3_0.add();
+        a4_main.a5_0.a6_0.a3_0.a1_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        a7_main.a9_0.a8_0.a5_0.add();
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        if (result == 2098)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0033-rc-function-Cycle_a_00500/Cycle_a_00500.java b/test/testsuite/ouroboros/memory_management/Function/RC0033-rc-function-Cycle_a_00500/Cycle_a_00500.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f0be56f30c0a5d8d52416e2bba8672cacf27ca3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0033-rc-function-Cycle_a_00500/Cycle_a_00500.java
@@ -0,0 +1,266 @@
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00500.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00500 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00500.java
+ *- @ExecuteClass: Cycle_a_00500
+ *- @ExecuteArgs:
+ * A1 depend A2 ; A2 depend A3 ; A3 depend A1
+ * A4 depend A5 ; A5 depend A6 ; A6 depend A4 ; A4 depend A1
+ * A5 depend A8 ; A8 depend A7 ; A7 depend A9 ; A9 depend A8
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101)+(104+101+105)+(106+104)+(105+106+108)+(107+109)+(108+107)+(109+108)=2099
+ *
+ */
+
+class Cycle_a_00500_A1 {
+    Cycle_a_00500_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00500_A2 {
+    Cycle_a_00500_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00500_A3 {
+    Cycle_a_00500_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00500_A4 {
+    Cycle_a_00500_A1 a1_0;
+    Cycle_a_00500_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A4(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_00500_A5 {
+    Cycle_a_00500_A6 a6_0;
+    Cycle_a_00500_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00500_A6 {
+    Cycle_a_00500_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A6(String strObjectName) {
+        a4_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00500_A7 {
+    Cycle_a_00500_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A7(String strObjectName) {
+        a9_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_a_00500_A8 {
+    Cycle_a_00500_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_00500_A9 {
+    Cycle_a_00500_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A9(String strObjectName) {
+        a8_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+
+public class Cycle_a_00500 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00500_A1 a1_main = new Cycle_a_00500_A1("a1_main");
+        Cycle_a_00500_A4 a4_main = new Cycle_a_00500_A4("a4_main");
+        Cycle_a_00500_A7 a7_main = new Cycle_a_00500_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00500_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00500_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00500_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00500_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+
+        a4_main.a5_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a4_main.a5_0.a8_0.a7_0 = a7_main;
+
+        a7_main.a9_0 = new Cycle_a_00500_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a8_0.add();
+        a4_main.a5_0.a8_0.a7_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        if (result == 2099)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0034-rc-function-Cycle_a_10010/Cycle_a_10010.java b/test/testsuite/ouroboros/memory_management/Function/RC0034-rc-function-Cycle_a_10010/Cycle_a_10010.java
new file mode 100644
index 0000000000000000000000000000000000000000..13b51e8d7bc2c7640f89bcff4fb3118f178227de
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0034-rc-function-Cycle_a_10010/Cycle_a_10010.java
@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_10010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_10010 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_10010.java
+ *- @ExecuteClass: Cycle_a_10010
+ *- @ExecuteArgs:
+ */
+class Cycle_a_10010_A1 {
+    Cycle_a_10010_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_10010_A2 {
+    Cycle_a_10010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_10010_A3 {
+    Cycle_a_10010_A1 a1_0;
+    Cycle_a_10010_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_10010_A4 {
+    Cycle_a_10010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_10010_A5 {
+    Cycle_a_10010_A4 a4_0;
+    Cycle_a_10010_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A5(String strObjectName) {
+        a4_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_10010_A6 {
+    Cycle_a_10010_A5 a5_0;
+    Cycle_a_10010_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A6(String strObjectName) {
+        a5_0 = null;
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_10010_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Cycle_a_10010_2A1 {
+    Cycle_a_10010_2A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_10010_2A2 {
+    Cycle_a_10010_2A3 a3_0;
+    Cycle_a_10010_2A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_10010_2A3 {
+    Cycle_a_10010_2A1 a1_0;
+    Cycle_a_10010_2A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_10010_2A4 {
+    Cycle_a_10010_2A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_10010_2A5 {
+    Cycle_a_10010_2A6 a6_0;
+    Cycle_a_10010_2A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_10010_2A6 {
+    Cycle_a_10010_2A1 a1_0;
+    Cycle_a_10010_2A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_10010_2A7 {
+    Cycle_a_10010_2A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A7(String strObjectName) {
+        a3_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_10010_2A8 {
+    Cycle_a_10010_2A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+public class Cycle_a_10010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_10010_A1 a1_main = new Cycle_a_10010_A1("a1_main");
+        Cycle_a_10010_A4 a4_main = new Cycle_a_10010_A4("a4_main");
+        Cycle_a_10010_A6 a6_main = new Cycle_a_10010_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_10010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10010_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10010_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_10010_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        Cycle_a_10010_2A1 a1_2main = new Cycle_a_10010_2A1("a1_2main");
+        Cycle_a_10010_2A4 a4_2main = new Cycle_a_10010_2A4("a4_2main");
+        Cycle_a_10010_2A6 a6_2main = new Cycle_a_10010_2A6("a6_2main");
+        a1_2main.a2_0 = new Cycle_a_10010_2A2("a2_0");
+        a1_2main.a2_0.a3_0 = new Cycle_a_10010_2A3("a3_0");
+        a1_2main.a2_0.a4_0 = a4_2main;
+        a4_2main.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a5_0 = new Cycle_a_10010_2A5("a5_0");
+        a1_2main.a2_0.a3_0.a5_0.a6_0 = a6_2main;
+        a1_2main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10010_2A8("a8_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10010_2A7("a7_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_2main.a2_0.a3_0;
+        a6_2main.a1_0 = a1_2main;
+        a6_2main.a3_0 = a1_2main.a2_0.a3_0;
+        a1_2main.add();
+        a4_2main.add();
+        a6_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        a1_2main.a2_0.a3_0.a5_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result2 = a1_2main.sum + a4_2main.sum + a6_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum + a1_2main.a2_0.a3_0.a5_0.sum + a6_2main.a3_0.a5_0.a8_0.a7_0.sum + a6_2main.a3_0.a5_0.a8_0.sum;
+        result += result2;
+        if (result == 3852)
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0035-rc-function-Cycle_a_10020/Cycle_a_10020.java b/test/testsuite/ouroboros/memory_management/Function/RC0035-rc-function-Cycle_a_10020/Cycle_a_10020.java
new file mode 100644
index 0000000000000000000000000000000000000000..e513f3ecc5129715ad64e3d8a856c22cbe4144d1
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0035-rc-function-Cycle_a_10020/Cycle_a_10020.java
@@ -0,0 +1,351 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_10020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_10020 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_10020.java
+ *- @ExecuteClass: Cycle_a_10020
+ *- @ExecuteArgs:
+ */
+class Cycle_a_10020_A1 {
+    Cycle_a_10020_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_10020_A2 {
+    Cycle_a_10020_A3 a3_0;
+    Cycle_a_10020_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_10020_A3 {
+    Cycle_a_10020_A1 a1_0;
+    Cycle_a_10020_A5 a5_0;
+    Cycle_a_10020_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a10_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a10_0.a;
+    }
+}
+
+
+class Cycle_a_10020_A4 {
+    Cycle_a_10020_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_10020_A5 {
+    Cycle_a_10020_A6 a6_0;
+    Cycle_a_10020_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_10020_A6 {
+    Cycle_a_10020_A1 a1_0;
+    Cycle_a_10020_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_10020_A7 {
+    Cycle_a_10020_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_10020_A8 {
+    Cycle_a_10020_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_10020_A9 {
+    Cycle_a_10020_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A9(String strObjectName) {
+        a6_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_10020_A10 {
+    Cycle_a_10020_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A10(String strObjectName) {
+        a9_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+class Cycle_a_10020_2A1 {
+    Cycle_a_10020_2A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_2A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_10020_2A2 {
+    Cycle_a_10020_2A1 a1_0;
+    Cycle_a_10020_2A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_2A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_10020_2A3 {
+    Cycle_a_10020_2A1 a1_0;
+    Cycle_a_10020_2A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_2A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_10020_A1 a1_main = new Cycle_a_10020_A1("a1_main");
+        Cycle_a_10020_A4 a4_main = new Cycle_a_10020_A4("a4_main");
+        Cycle_a_10020_A6 a6_main = new Cycle_a_10020_A6("a6_main");
+        Cycle_a_10020_A9 a9_main = new Cycle_a_10020_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_10020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10020_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10020_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_10020_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10020_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10020_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10020_2A1 a1_2main = new Cycle_a_10020_2A1("a1_2main");
+        a1_2main.a2_0 = new Cycle_a_10020_2A2("a2_0");
+        a1_2main.a2_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0 = new Cycle_a_10020_2A3("a3_0");
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a2_0 = a1_2main.a2_0;
+        a1_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        int result2 = a1_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+        if (result == (2623 + 815))
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0036-rc-function-Cycle_B_1_00010/Cycle_B_1_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0036-rc-function-Cycle_B_1_00010/Cycle_B_1_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..dcc56225f717a3cd3e827adf568567702326c9e7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0036-rc-function-Cycle_B_1_00010/Cycle_B_1_00010.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00010 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00010.java
+ *- @ExecuteClass: Cycle_B_1_00010
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00010_A1 {
+    Cycle_B_1_00010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00010_A1() {
+        a1_0 = null;
+        a = 123;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_1_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        if (nsum == 246)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0037-rc-function-Cycle_B_1_00020/Cycle_B_1_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0037-rc-function-Cycle_B_1_00020/Cycle_B_1_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..33501a0edbf6844f61d22f232966bd6c1e74452f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0037-rc-function-Cycle_B_1_00020/Cycle_B_1_00020.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00020 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00020.java
+ *- @ExecuteClass: Cycle_B_1_00020
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00020_A1 {
+    Cycle_B_1_00020_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00020_A2 {
+    Cycle_B_1_00020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00020_A2() {
+        a1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_1_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00020_A1 a1_0 = new Cycle_B_1_00020_A1();
+        a1_0.a2_0 = new Cycle_B_1_00020_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+
+        if (nsum == 6)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0038-rc-function-Cycle_B_1_00030/Cycle_B_1_00030.java b/test/testsuite/ouroboros/memory_management/Function/RC0038-rc-function-Cycle_B_1_00030/Cycle_B_1_00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ce39be0604f8b2c0ccdb36e828237b67722c9a1
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0038-rc-function-Cycle_B_1_00030/Cycle_B_1_00030.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00030 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00030.java
+ *- @ExecuteClass: Cycle_B_1_00030
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00030_A1 {
+    Cycle_B_1_00030_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00030_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00030_A2 {
+    Cycle_B_1_00030_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00030_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00030_A3 {
+    Cycle_B_1_00030_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00030_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_1_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00030_A1 a1_0 = new Cycle_B_1_00030_A1();
+        a1_0.a2_0 = new Cycle_B_1_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00030_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+
+        if (nsum == 12)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0039-rc-function-Cycle_B_1_00040/Cycle_B_1_00040.java b/test/testsuite/ouroboros/memory_management/Function/RC0039-rc-function-Cycle_B_1_00040/Cycle_B_1_00040.java
new file mode 100644
index 0000000000000000000000000000000000000000..3fda3c3fc32aa564468d7da11858470ff34ce448
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0039-rc-function-Cycle_B_1_00040/Cycle_B_1_00040.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00040 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00040.java
+ *- @ExecuteClass: Cycle_B_1_00040
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00040_A1 {
+    Cycle_B_1_00040_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00040_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00040_A2 {
+    Cycle_B_1_00040_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00040_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00040_A3 {
+    Cycle_B_1_00040_A1 a1_0;
+    Cycle_B_1_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00040_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00040_A4 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00040_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+
+public class Cycle_B_1_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00040_A1 a1_0 = new Cycle_B_1_00040_A1();
+        a1_0.a2_0 = new Cycle_B_1_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00040_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00040_A4();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0040-rc-function-Cycle_B_1_00050/Cycle_B_1_00050.java b/test/testsuite/ouroboros/memory_management/Function/RC0040-rc-function-Cycle_B_1_00050/Cycle_B_1_00050.java
new file mode 100644
index 0000000000000000000000000000000000000000..eba86b70dc6bab8feee3f870acdb6aa77f012453
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0040-rc-function-Cycle_B_1_00050/Cycle_B_1_00050.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00050 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00050.java
+ *- @ExecuteClass: Cycle_B_1_00050
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00050_A1 {
+    Cycle_B_1_00050_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00050_A2 {
+    Cycle_B_1_00050_A3 a3_0;
+    Cycle_B_1_00050_A4 a4_0;
+    Cycle_B_1_00050_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00050_A3 {
+    Cycle_B_1_00050_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00050_A4 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+
+class Cycle_B_1_00050_A5 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A5() {
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 7;
+    }
+}
+
+public class Cycle_B_1_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00050_A1 a1_0 = new Cycle_B_1_00050_A1();
+        a1_0.a2_0 = new Cycle_B_1_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00050_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00050_A4();
+        a1_0.a2_0.a5_0 = new Cycle_B_1_00050_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 34)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0041-rc-function-Cycle_B_1_00060/Cycle_B_1_00060.java b/test/testsuite/ouroboros/memory_management/Function/RC0041-rc-function-Cycle_B_1_00060/Cycle_B_1_00060.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5c2ac5a85863c8a812c0bb20135f2ee335441dd
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0041-rc-function-Cycle_B_1_00060/Cycle_B_1_00060.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00060 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00060.java
+ *- @ExecuteClass: Cycle_B_1_00060
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00060_A1 {
+    Cycle_B_1_00060_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00060_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00060_A2 {
+    Cycle_B_1_00060_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00060_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00060_A3 {
+    Cycle_B_1_00060_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00060_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00060_A4 {
+    Cycle_B_1_00060_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00060_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_1_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00060_A1 a1_0 = new Cycle_B_1_00060_A1();
+        a1_0.a2_0 = new Cycle_B_1_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00060_A3();
+        Cycle_B_1_00060_A4 a4_0 = new Cycle_B_1_00060_A4();
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum;
+
+        if (nsum == 19)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0042-rc-function-Cycle_B_1_00070/Cycle_B_1_00070.java b/test/testsuite/ouroboros/memory_management/Function/RC0042-rc-function-Cycle_B_1_00070/Cycle_B_1_00070.java
new file mode 100644
index 0000000000000000000000000000000000000000..88f1b8164ecb6b3e15aab943765fb88d18d224d0
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0042-rc-function-Cycle_B_1_00070/Cycle_B_1_00070.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00070 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00070.java
+ *- @ExecuteClass: Cycle_B_1_00070
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00070_A1 {
+    Cycle_B_1_00070_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00070_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00070_A2 {
+    Cycle_B_1_00070_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00070_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00070_A3 {
+    Cycle_B_1_00070_A1 a1_0;
+    Cycle_B_1_00070_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00070_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00070_A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00070_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+public class Cycle_B_1_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00070_A1 a1_0 = new Cycle_B_1_00070_A1();
+        a1_0.a2_0 = new Cycle_B_1_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00070_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00070_A4();
+
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0043-rc-function-Cycle_B_1_00080/Cycle_B_1_00080.java b/test/testsuite/ouroboros/memory_management/Function/RC0043-rc-function-Cycle_B_1_00080/Cycle_B_1_00080.java
new file mode 100644
index 0000000000000000000000000000000000000000..505922c98f4169af33788ffd8339e91c36b46183
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0043-rc-function-Cycle_B_1_00080/Cycle_B_1_00080.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00080 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00080.java
+ *- @ExecuteClass: Cycle_B_1_00080
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00080_A1 {
+    Cycle_B_1_00080_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00080_A2 {
+    Cycle_B_1_00080_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00080_A3 {
+    Cycle_B_1_00080_A1 a1_0;
+    Cycle_B_1_00080_A4 a4_0;
+    Cycle_B_1_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        a4_0.add();
+        a5_0.add();
+        sum = a + a1_0.a + a4_0.sum + a5_0.sum;
+    }
+}
+
+
+class Cycle_B_1_00080_A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+
+class Cycle_B_1_00080_A5 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A5() {
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 7;
+    }
+}
+
+public class Cycle_B_1_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00080_A1 a1_0 = new Cycle_B_1_00080_A1();
+        a1_0.a2_0 = new Cycle_B_1_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00080_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00080_A4();
+        a1_0.a2_0.a3_0.a5_0 = new Cycle_B_1_00080_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 56)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0044-rc-function-Cycle_B_1_00090/Cycle_B_1_00090.java b/test/testsuite/ouroboros/memory_management/Function/RC0044-rc-function-Cycle_B_1_00090/Cycle_B_1_00090.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8400fc4c31f484ca2fd4e14dafb6eae989165f8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0044-rc-function-Cycle_B_1_00090/Cycle_B_1_00090.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00090 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00090.java
+ *- @ExecuteClass: Cycle_B_1_00090
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00090_A1 {
+    Cycle_B_1_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00090_A2 {
+    Cycle_B_1_00090_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00090_A3 {
+    Cycle_B_1_00090_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00090_A4 {
+    Cycle_B_1_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00090_A5 {
+    Cycle_B_1_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A5() {
+        a2_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+public class Cycle_B_1_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00090_A1 a1_0 = new Cycle_B_1_00090_A1();
+        a1_0.a2_0 = new Cycle_B_1_00090_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00090_A3();
+        Cycle_B_1_00090_A4 a4_0 = new Cycle_B_1_00090_A4();
+        Cycle_B_1_00090_A5 a5_0 = new Cycle_B_1_00090_A5();
+        a4_0.a2_0 = a1_0.a2_0;
+        a5_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 25)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0045-rc-function-Cycle_B_1_00100/Cycle_B_1_00100.java b/test/testsuite/ouroboros/memory_management/Function/RC0045-rc-function-Cycle_B_1_00100/Cycle_B_1_00100.java
new file mode 100644
index 0000000000000000000000000000000000000000..99dd044cd4e0cc693c5b475f99f1ad022d849a0f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0045-rc-function-Cycle_B_1_00100/Cycle_B_1_00100.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00100 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00100.java
+ *- @ExecuteClass: Cycle_B_1_00100
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00100_A1 {
+    Cycle_B_1_00100_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00100_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00100_A2 {
+    Cycle_B_1_00100_A3 a3_0;
+    Cycle_B_1_00100_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00100_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00100_A3 {
+    Cycle_B_1_00100_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00100_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00100_A4 {
+
+    int a;
+    int sum;
+    Cycle_B_1_00100_A5 a5_0;
+
+    Cycle_B_1_00100_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        a5_0.add();
+        sum = a + a5_0.sum;
+    }
+}
+
+class Cycle_B_1_00100_A5 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00100_A5() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+public class Cycle_B_1_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00100_A1 a1_0 = new Cycle_B_1_00100_A1();
+        a1_0.a2_0 = new Cycle_B_1_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00100_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00100_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_1_00100_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0046-rc-function-Cycle_B_1_00110/Cycle_B_1_00110.java b/test/testsuite/ouroboros/memory_management/Function/RC0046-rc-function-Cycle_B_1_00110/Cycle_B_1_00110.java
new file mode 100644
index 0000000000000000000000000000000000000000..712562058dee50b2311206ae2d5f843c1d5904d3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0046-rc-function-Cycle_B_1_00110/Cycle_B_1_00110.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00110 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00110.java
+ *- @ExecuteClass: Cycle_B_1_00110
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00110_A1 {
+    Cycle_B_1_00110_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00110_A2 {
+    Cycle_B_1_00110_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00110_A3 {
+    Cycle_B_1_00110_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00110_A4 {
+    Cycle_B_1_00110_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_B_1_00110_A5 {
+    Cycle_B_1_00110_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_1_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00110_A1 a1_0 = new Cycle_B_1_00110_A1();
+        a1_0.a2_0 = new Cycle_B_1_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00110_A3();
+        Cycle_B_1_00110_A5 a5_0 = new Cycle_B_1_00110_A5();
+        a5_0.a4_0 = new Cycle_B_1_00110_A4();
+        a5_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 27)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0047-rc-function-Cycle_B_1_00120/Cycle_B_1_00120.java b/test/testsuite/ouroboros/memory_management/Function/RC0047-rc-function-Cycle_B_1_00120/Cycle_B_1_00120.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea3dc38c1d0a9340796e4965afeced99657d168b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0047-rc-function-Cycle_B_1_00120/Cycle_B_1_00120.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00120 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00120.java
+ *- @ExecuteClass: Cycle_B_1_00120
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00120_A1 {
+    Cycle_B_1_00120_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00120_A2 {
+    Cycle_B_1_00120_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00120_A3 {
+    Cycle_B_1_00120_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00120_A4 {
+    Cycle_B_1_00120_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_B_1_00120_A5 {
+    Cycle_B_1_00120_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_1_00120 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00120_A1 a1_0 = new Cycle_B_1_00120_A1();
+        a1_0.a2_0 = new Cycle_B_1_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00120_A3();
+        Cycle_B_1_00120_A5 a5_0 = new Cycle_B_1_00120_A5();
+        a5_0.a4_0 = new Cycle_B_1_00120_A4();
+        a5_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0048-rc-function-Cycle_B_1_00130/Cycle_B_1_00130.java b/test/testsuite/ouroboros/memory_management/Function/RC0048-rc-function-Cycle_B_1_00130/Cycle_B_1_00130.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a670e070d2676c6483763af960a66a4d8e93177
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0048-rc-function-Cycle_B_1_00130/Cycle_B_1_00130.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00130 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00130.java
+ *- @ExecuteClass: Cycle_B_1_00130
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00130_A1 {
+    Cycle_B_1_00130_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00130_A1() {
+        a3_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00130_A2 {
+    Cycle_B_1_00130_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00130_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00130_A3 {
+    Cycle_B_1_00130_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00130_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_1_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00130_A1 a1_0 = new Cycle_B_1_00130_A1();
+        Cycle_B_1_00130_A2 a2_0 = new Cycle_B_1_00130_A2();
+        Cycle_B_1_00130_A3 a3_0 = new Cycle_B_1_00130_A3();
+        a1_0.a3_0 = a3_0;
+        a2_0.a3_0 = a3_0;
+        a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0049-rc-function-Cycle_B_1_00140/Cycle_B_1_00140.java b/test/testsuite/ouroboros/memory_management/Function/RC0049-rc-function-Cycle_B_1_00140/Cycle_B_1_00140.java
new file mode 100644
index 0000000000000000000000000000000000000000..1fb39f06464fcb5432bc5156b5c77ade4230e0e5
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0049-rc-function-Cycle_B_1_00140/Cycle_B_1_00140.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00140 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00140.java
+ *- @ExecuteClass: Cycle_B_1_00140
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00140_A1 {
+    Cycle_B_1_00140_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00140_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00140_A2 {
+    Cycle_B_1_00140_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00140_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00140_A3 {
+    Cycle_B_1_00140_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00140_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00140_A4 {
+    Cycle_B_1_00140_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00140_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_1_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00140_A1 a1_0 = new Cycle_B_1_00140_A1();
+        a1_0.a2_0 = new Cycle_B_1_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00140_A3();
+        Cycle_B_1_00140_A4 a4_0 = new Cycle_B_1_00140_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 12)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0050-rc-function-Cycle_B_1_00150/Cycle_B_1_00150.java b/test/testsuite/ouroboros/memory_management/Function/RC0050-rc-function-Cycle_B_1_00150/Cycle_B_1_00150.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5e84ad7dd800cf67a6dae487b60e64b114b4ef3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0050-rc-function-Cycle_B_1_00150/Cycle_B_1_00150.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00150 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00150.java
+ *- @ExecuteClass: Cycle_B_1_00150
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00150_A1 {
+    Cycle_B_1_00150_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00150_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00150_A2 {
+    Cycle_B_1_00150_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00150_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00150_A3 {
+    Cycle_B_1_00150_A1 a1_0;
+    Cycle_B_1_00150_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00150_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00150_A4 {
+
+    int a;
+    int sum;
+    Cycle_B_1_00150_A5 a5_0;
+
+    Cycle_B_1_00150_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        a5_0.add();
+        sum = a + a5_0.sum;
+    }
+}
+
+class Cycle_B_1_00150_A5 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00150_A5() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+public class Cycle_B_1_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00150_A1 a1_0 = new Cycle_B_1_00150_A1();
+        a1_0.a2_0 = new Cycle_B_1_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00150_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_1_00150_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0051-rc-function-Cycle_B_1_00160/Cycle_B_1_00160.java b/test/testsuite/ouroboros/memory_management/Function/RC0051-rc-function-Cycle_B_1_00160/Cycle_B_1_00160.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c8b4d933b5ccc5935c7c048e70d4758e5a75386
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0051-rc-function-Cycle_B_1_00160/Cycle_B_1_00160.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00160 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00160.java
+ *- @ExecuteClass: Cycle_B_1_00160
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00160_A1 {
+    Cycle_B_1_00160_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00160_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00160_A2 {
+    Cycle_B_1_00160_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00160_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00160_A3 {
+    Cycle_B_1_00160_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00160_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_00160_A4 {
+    Cycle_B_1_00160_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00160_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_1_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00160_A1 a1_0 = new Cycle_B_1_00160_A1();
+        a1_0.a2_0 = new Cycle_B_1_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00160_A3();
+        Cycle_B_1_00160_A4 a4_0 = new Cycle_B_1_00160_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 17)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0052-rc-function-Cycle_B_1_00170/Cycle_B_1_00170.java b/test/testsuite/ouroboros/memory_management/Function/RC0052-rc-function-Cycle_B_1_00170/Cycle_B_1_00170.java
new file mode 100644
index 0000000000000000000000000000000000000000..618d7091e4014a9b9498dc341dd56c8d002bdae7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0052-rc-function-Cycle_B_1_00170/Cycle_B_1_00170.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00170 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00170.java
+ *- @ExecuteClass: Cycle_B_1_00170
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00170_A1 {
+    Cycle_B_1_00170_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00170_A2 {
+    Cycle_B_1_00170_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00170_A3 {
+    Cycle_B_1_00170_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_00170_A4 {
+    Cycle_B_1_00170_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00170_A5 {
+    Cycle_B_1_00170_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+public class Cycle_B_1_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00170_A1 a1_0 = new Cycle_B_1_00170_A1();
+        a1_0.a2_0 = new Cycle_B_1_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00170_A3();
+        Cycle_B_1_00170_A4 a4_0 = new Cycle_B_1_00170_A4();
+        Cycle_B_1_00170_A5 a5_0 = new Cycle_B_1_00170_A5();
+        a5_0.a4_0 = a4_0;
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 26)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0053-rc-function-Cycle_B_1_00180/Cycle_B_1_00180.java b/test/testsuite/ouroboros/memory_management/Function/RC0053-rc-function-Cycle_B_1_00180/Cycle_B_1_00180.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b89585be7d66b03766cf73cebb27dbf12226d98
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0053-rc-function-Cycle_B_1_00180/Cycle_B_1_00180.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00180 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00180.java
+ *- @ExecuteClass: Cycle_B_1_00180
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00180_A1 {
+    Cycle_B_1_00180_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A2 {
+    Cycle_B_1_00180_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A3 {
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_00180_A4 {
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A5 {
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_1_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 23)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0054-rc-function-Cycle_B_1_00190/Cycle_B_1_00190.java b/test/testsuite/ouroboros/memory_management/Function/RC0054-rc-function-Cycle_B_1_00190/Cycle_B_1_00190.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c0d4ac9b97b5533165a8a8923226642cbe22e69
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0054-rc-function-Cycle_B_1_00190/Cycle_B_1_00190.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00190 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00190.java
+ *- @ExecuteClass: Cycle_B_1_00190
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00190_A1 {
+    Cycle_B_1_00190_A2 a2_0;
+    Cycle_B_1_00190_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00190_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00190_A2 {
+    Cycle_B_1_00190_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00190_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00190_A3 {
+    Cycle_B_1_00190_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00190_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00190_A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00190_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+
+public class Cycle_B_1_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00190_A1 a1_0 = new Cycle_B_1_00190_A1();
+        a1_0.a2_0 = new Cycle_B_1_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00190_A3();
+        Cycle_B_1_00190_A4 a4_0 = new Cycle_B_1_00190_A4();
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0055-rc-function-Cycle_B_1_00200/Cycle_B_1_00200.java b/test/testsuite/ouroboros/memory_management/Function/RC0055-rc-function-Cycle_B_1_00200/Cycle_B_1_00200.java
new file mode 100644
index 0000000000000000000000000000000000000000..b558c39340eab7d564ece0582b0922cc3d521ffe
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0055-rc-function-Cycle_B_1_00200/Cycle_B_1_00200.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00200 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00200.java
+ *- @ExecuteClass: Cycle_B_1_00200
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_00200_A1 {
+    Cycle_B_1_00200_A2 a2_0;
+    Cycle_B_1_00200_A4 a4_0;
+    Cycle_B_1_00200_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00200_A2 {
+    Cycle_B_1_00200_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00200_A3 {
+    Cycle_B_1_00200_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00200_A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A4() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+class Cycle_B_1_00200_A5 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A5() {
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 8;
+    }
+}
+
+
+public class Cycle_B_1_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00200_A1 a1_0 = new Cycle_B_1_00200_A1();
+        a1_0.a2_0 = new Cycle_B_1_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00200_A3();
+        Cycle_B_1_00200_A4 a4_0 = new Cycle_B_1_00200_A4();
+        Cycle_B_1_00200_A5 a5_0 = new Cycle_B_1_00200_A5();
+        a1_0.a4_0 = a4_0;
+        a1_0.a5_0 = a5_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 38)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0056-rc-function-Cycle_B_1_10010/Cycle_B_1_10010.java b/test/testsuite/ouroboros/memory_management/Function/RC0056-rc-function-Cycle_B_1_10010/Cycle_B_1_10010.java
new file mode 100644
index 0000000000000000000000000000000000000000..27c5ba9208ed88762493f9d1c6d714921cb655e0
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0056-rc-function-Cycle_B_1_10010/Cycle_B_1_10010.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_10010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_10010 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_10010.java
+ *- @ExecuteClass: Cycle_B_1_10010
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_10010_A1 {
+    Cycle_B_1_10010_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_10010_A2 {
+    Cycle_B_1_10010_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_10010_A3 {
+    Cycle_B_1_10010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_10010_2A1 {
+    Cycle_B_1_10010_2A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_2A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_10010_2A2 {
+    Cycle_B_1_10010_2A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_2A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_10010_2A3 {
+    Cycle_B_1_10010_2A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_2A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_1_10010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_10010_A1 a1_0 = new Cycle_B_1_10010_A1();
+        a1_0.a2_0 = new Cycle_B_1_10010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10010_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        Cycle_B_1_10010_2A1 a1_10 = new Cycle_B_1_10010_2A1();
+        a1_10.a2_0 = new Cycle_B_1_10010_2A2();
+        a1_10.a2_0.a3_0 = new Cycle_B_1_10010_2A3();
+        a1_10.a2_0.a3_0.a1_0 = a1_10;
+        a1_10.add();
+        a1_10.a2_0.add();
+        a1_10.a2_0.a3_0.add();
+        int nsum2 = (a1_10.sum + a1_10.a2_0.sum + a1_10.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        nsum += nsum2;
+        if (nsum == 24)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0057-rc-function-Cycle_B_1_10020/Cycle_B_1_10020.java b/test/testsuite/ouroboros/memory_management/Function/RC0057-rc-function-Cycle_B_1_10020/Cycle_B_1_10020.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fed40659f19927cca7bdf2be11e5d8aac2caa31
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0057-rc-function-Cycle_B_1_10020/Cycle_B_1_10020.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_1_10020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_10020 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_10020.java
+ *- @ExecuteClass: Cycle_B_1_10020
+ *- @ExecuteArgs:
+ */
+class Cycle_B_1_10020_A1 {
+    Cycle_B_1_10020_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_A2 {
+    Cycle_B_1_10020_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_A3 {
+    Cycle_B_1_10020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_10020_A4 {
+    Cycle_B_1_10020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_A5 {
+    Cycle_B_1_10020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_10020_2A1 {
+    Cycle_B_1_10020_2A2 a2_0;
+    Cycle_B_1_10020_2A4 a4_0;
+    Cycle_B_1_10020_2A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_2A2 {
+    Cycle_B_1_10020_2A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_2A3 {
+    Cycle_B_1_10020_2A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_10020_2A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A4() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+class Cycle_B_1_10020_2A5 {
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A5() {
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 8;
+    }
+}
+
+
+public class Cycle_B_1_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_10020_A1 a1_0 = new Cycle_B_1_10020_A1();
+        a1_0.a2_0 = new Cycle_B_1_10020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10020_A3();
+        Cycle_B_1_10020_A4 a4_0 = new Cycle_B_1_10020_A4();
+        Cycle_B_1_10020_A5 a5_0 = new Cycle_B_1_10020_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        Cycle_B_1_10020_2A1 a1_20 = new Cycle_B_1_10020_2A1();
+        a1_20.a2_0 = new Cycle_B_1_10020_2A2();
+        a1_20.a2_0.a3_0 = new Cycle_B_1_10020_2A3();
+        Cycle_B_1_10020_2A4 a4_20 = new Cycle_B_1_10020_2A4();
+        Cycle_B_1_10020_2A5 a5_20 = new Cycle_B_1_10020_2A5();
+        a1_20.a4_0 = a4_20;
+        a1_20.a5_0 = a5_20;
+        a1_20.a2_0.a3_0.a1_0 = a1_20;
+        a1_20.add();
+        a1_20.a2_0.add();
+        a1_20.a2_0.a3_0.add();
+        a4_20.add();
+        a5_20.add();
+        int nsum1 = (a1_20.sum + a1_20.a2_0.sum + a1_20.a2_0.a3_0.sum + a4_20.sum + a5_20.sum);
+        nsum += nsum1;
+        if (nsum == 61)
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0058-rc-function-Cycle_B_2_00010/Cycle_B_2_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0058-rc-function-Cycle_B_2_00010/Cycle_B_2_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7514523c3a114506c2d745021f67cb4a2aa59c7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0058-rc-function-Cycle_B_2_00010/Cycle_B_2_00010.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00010 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00010.java
+ *- @ExecuteClass: Cycle_B_2_00010
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00010_A1 {
+    Cycle_B_2_00010_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00010_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00010_A2 {
+    Cycle_B_2_00010_A3 a3_0;
+    Cycle_B_2_00010_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00010_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00010_A3 {
+    Cycle_B_2_00010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00010_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00010_A4 {
+    Cycle_B_2_00010_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00010_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+public class Cycle_B_2_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00010_A1 a1_0 = new Cycle_B_2_00010_A1();
+        a1_0.a2_0 = new Cycle_B_2_00010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00010_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00010_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 18)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0059-rc-function-Cycle_B_2_00020/Cycle_B_2_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0059-rc-function-Cycle_B_2_00020/Cycle_B_2_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..a58e203e52e6868a48ec283c5de2361f0445bed8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0059-rc-function-Cycle_B_2_00020/Cycle_B_2_00020.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00020 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00020.java
+ *- @ExecuteClass: Cycle_B_2_00020
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00020_A1 {
+    Cycle_B_2_00020_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00020_A2 {
+    Cycle_B_2_00020_A3 a3_0;
+    Cycle_B_2_00020_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00020_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00020_A3 {
+    Cycle_B_2_00020_A1 a1_0;
+    Cycle_B_2_00020_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00020_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00020_A4 {
+    Cycle_B_2_00020_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00020_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_2_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00020_A1 a1_0 = new Cycle_B_2_00020_A1();
+        a1_0.a2_0 = new Cycle_B_2_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00020_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00020_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0060-rc-function-Cycle_B_2_00030/Cycle_B_2_00030.java b/test/testsuite/ouroboros/memory_management/Function/RC0060-rc-function-Cycle_B_2_00030/Cycle_B_2_00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..6eef2a1d2313e1cb92d2adb43f15a3407b668f21
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0060-rc-function-Cycle_B_2_00030/Cycle_B_2_00030.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_2_00030 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00030.java
+ *- @ExecuteClass: Cycle_B_2_00030
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00030_A1 {
+    Cycle_B_2_00030_A2 a2_0;
+    Cycle_B_2_00030_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00030_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00030_A2 {
+    Cycle_B_2_00030_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00030_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00030_A3 {
+    Cycle_B_2_00030_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00030_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00030_A4 {
+    Cycle_B_2_00030_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00030_A4() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00030_A1 a1_0 = new Cycle_B_2_00030_A1();
+        a1_0.a2_0 = new Cycle_B_2_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00030_A3();
+        Cycle_B_2_00030_A4 a4_0 = new Cycle_B_2_00030_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0061-rc-function-Cycle_B_2_00040/Cycle_B_2_00040.java b/test/testsuite/ouroboros/memory_management/Function/RC0061-rc-function-Cycle_B_2_00040/Cycle_B_2_00040.java
new file mode 100644
index 0000000000000000000000000000000000000000..03bfb56aad0bdcbe35cfed56a5657d1137083fc6
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0061-rc-function-Cycle_B_2_00040/Cycle_B_2_00040.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00040 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00040.java
+ *- @ExecuteClass: Cycle_B_2_00040
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00040_A1 {
+    Cycle_B_2_00040_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00040_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00040_A2 {
+    Cycle_B_2_00040_A3 a3_0;
+    Cycle_B_2_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00040_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00040_A3 {
+    Cycle_B_2_00040_A1 a1_0;
+    Cycle_B_2_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00040_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00040_A4 {
+    Cycle_B_2_00040_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00040_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_2_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00040_A1 a1_0 = new Cycle_B_2_00040_A1();
+        a1_0.a2_0 = new Cycle_B_2_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00040_A3();
+        Cycle_B_2_00040_A4 a4_0 = new Cycle_B_2_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0062-rc-function-Cycle_B_2_00050/Cycle_B_2_00050.java b/test/testsuite/ouroboros/memory_management/Function/RC0062-rc-function-Cycle_B_2_00050/Cycle_B_2_00050.java
new file mode 100644
index 0000000000000000000000000000000000000000..9efa927266ba19881e50330699b63408aac5c532
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0062-rc-function-Cycle_B_2_00050/Cycle_B_2_00050.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00050 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00050.java
+ *- @ExecuteClass: Cycle_B_2_00050
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00050_A1 {
+    Cycle_B_2_00050_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00050_A2 {
+    Cycle_B_2_00050_A3 a3_0;
+    Cycle_B_2_00050_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00050_A3 {
+    Cycle_B_2_00050_A1 a1_0;
+    Cycle_B_2_00050_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00050_A4 {
+    Cycle_B_2_00050_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00050_A5 {
+    Cycle_B_2_00050_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_2_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00050_A1 a1_0 = new Cycle_B_2_00050_A1();
+        a1_0.a2_0 = new Cycle_B_2_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00050_A3();
+        Cycle_B_2_00050_A4 a4_0 = new Cycle_B_2_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00050_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0063-rc-function-Cycle_B_2_00060/Cycle_B_2_00060.java b/test/testsuite/ouroboros/memory_management/Function/RC0063-rc-function-Cycle_B_2_00060/Cycle_B_2_00060.java
new file mode 100644
index 0000000000000000000000000000000000000000..a31984f55c00144aada8ee2c9ba94c01a7ce656d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0063-rc-function-Cycle_B_2_00060/Cycle_B_2_00060.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00060 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00060.java
+ *- @ExecuteClass: Cycle_B_2_00060
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00060_A1 {
+    Cycle_B_2_00060_A2 a2_0;
+    Cycle_B_2_00060_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A1() {
+        a2_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00060_A2 {
+    Cycle_B_2_00060_A3 a3_0;
+    Cycle_B_2_00060_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00060_A3 {
+    Cycle_B_2_00060_A1 a1_0;
+    Cycle_B_2_00060_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00060_A4 {
+    Cycle_B_2_00060_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00060_A5 {
+    Cycle_B_2_00060_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_2_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00060_A1 a1_0 = new Cycle_B_2_00060_A1();
+        a1_0.a2_0 = new Cycle_B_2_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00060_A3();
+        Cycle_B_2_00060_A4 a4_0 = new Cycle_B_2_00060_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00060_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0064-rc-function-Cycle_B_2_00070/Cycle_B_2_00070.java b/test/testsuite/ouroboros/memory_management/Function/RC0064-rc-function-Cycle_B_2_00070/Cycle_B_2_00070.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c717a63743dac3af6f4932defdc3f7ff6c3b501
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0064-rc-function-Cycle_B_2_00070/Cycle_B_2_00070.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00070 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00070.java
+ *- @ExecuteClass: Cycle_B_2_00070
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00070_A1 {
+    Cycle_B_2_00070_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A2 {
+    Cycle_B_2_00070_A3 a3_0;
+    Cycle_B_2_00070_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A3 {
+    Cycle_B_2_00070_A1 a1_0;
+    Cycle_B_2_00070_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A4 {
+    Cycle_B_2_00070_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A5 {
+    Cycle_B_2_00070_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A6 {
+    Cycle_B_2_00070_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A6() {
+        a3_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_2_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00070_A1 a1_0 = new Cycle_B_2_00070_A1();
+        a1_0.a2_0 = new Cycle_B_2_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00070_A3();
+        Cycle_B_2_00070_A4 a4_0 = new Cycle_B_2_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00070_A5();
+        Cycle_B_2_00070_A6 a6_0 = new Cycle_B_2_00070_A6();
+        a6_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a6_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum + a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 37)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0065-rc-function-Cycle_B_2_00080/Cycle_B_2_00080.java b/test/testsuite/ouroboros/memory_management/Function/RC0065-rc-function-Cycle_B_2_00080/Cycle_B_2_00080.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3e1cfbcf028bc4f82e5eed3063833c02b08b2bc
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0065-rc-function-Cycle_B_2_00080/Cycle_B_2_00080.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00080 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00080.java
+ *- @ExecuteClass: Cycle_B_2_00080
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00080_A1 {
+    Cycle_B_2_00080_A2 a2_0;
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A1() {
+        a2_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A2 {
+    Cycle_B_2_00080_A3 a3_0;
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A3 {
+    Cycle_B_2_00080_A1 a1_0;
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A4 {
+    Cycle_B_2_00080_A3 a3_0;
+    Cycle_B_2_00080_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A4() {
+        a3_0 = null;
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A5 {
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_2_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0066-rc-function-Cycle_B_2_00090/Cycle_B_2_00090.java b/test/testsuite/ouroboros/memory_management/Function/RC0066-rc-function-Cycle_B_2_00090/Cycle_B_2_00090.java
new file mode 100644
index 0000000000000000000000000000000000000000..5fb3161ed95fa8332b22c83c99df8b9aa5a98232
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0066-rc-function-Cycle_B_2_00090/Cycle_B_2_00090.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00090 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00090.java
+ *- @ExecuteClass: Cycle_B_2_00090
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00090_A1 {
+    Cycle_B_2_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00090_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00090_A2 {
+    Cycle_B_2_00090_A1 a1_0;
+    Cycle_B_2_00090_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00090_A2() {
+        a1_0 = null;
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00090_A3 {
+    Cycle_B_2_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00090_A3() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+public class Cycle_B_2_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00090_A1 a1_0 = new Cycle_B_2_00090_A1();
+        Cycle_B_2_00090_A3 a3_0 = new Cycle_B_2_00090_A3();
+        a1_0.a2_0 = new Cycle_B_2_00090_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a3_0.a2_0 = a1_0.a2_0;
+        a3_0.a2_0.a3_0 = a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 9)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0067-rc-function-Cycle_B_2_00100/Cycle_B_2_00100.java b/test/testsuite/ouroboros/memory_management/Function/RC0067-rc-function-Cycle_B_2_00100/Cycle_B_2_00100.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb749c7674bdab788a40dca903aee724df6aa0d2
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0067-rc-function-Cycle_B_2_00100/Cycle_B_2_00100.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00100 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00100.java
+ *- @ExecuteClass: Cycle_B_2_00100
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00100_A1 {
+    Cycle_B_2_00100_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00100_A2 {
+    Cycle_B_2_00100_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00100_A3 {
+    Cycle_B_2_00100_A1 a1_0;
+    Cycle_B_2_00100_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00100_A4 {
+    Cycle_B_2_00100_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_B_2_00100_A5 {
+    Cycle_B_2_00100_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A5() {
+        a3_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_2_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00100_A1 a1_0 = new Cycle_B_2_00100_A1();
+        a1_0.a2_0 = new Cycle_B_2_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00100_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00100_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00100_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 29)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0068-rc-function-Cycle_B_2_00110/Cycle_B_2_00110.java b/test/testsuite/ouroboros/memory_management/Function/RC0068-rc-function-Cycle_B_2_00110/Cycle_B_2_00110.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8f0c304a0a1f720ea647e594101f7f28e4b2926
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0068-rc-function-Cycle_B_2_00110/Cycle_B_2_00110.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_2_00110 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00110.java
+ *- @ExecuteClass: Cycle_B_2_00110
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00110_A1 {
+    Cycle_B_2_00110_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00110_A2 {
+    Cycle_B_2_00110_A3 a3_0;
+    Cycle_B_2_00110_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00110_A3 {
+    Cycle_B_2_00110_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00110_A4 {
+    Cycle_B_2_00110_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_B_2_00110_A5 {
+    Cycle_B_2_00110_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A5() {
+        a2_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+public class Cycle_B_2_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00110_A1 a1_0 = new Cycle_B_2_00110_A1();
+        a1_0.a2_0 = new Cycle_B_2_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00110_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00110_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_2_00110_A5();
+        a1_0.a2_0.a4_0.a5_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0069-rc-function-Cycle_B_2_00120/Cycle_B_2_00120.java b/test/testsuite/ouroboros/memory_management/Function/RC0069-rc-function-Cycle_B_2_00120/Cycle_B_2_00120.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8b956a9f2e88cfadcc2dc5467cf8d8bc42d7765
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0069-rc-function-Cycle_B_2_00120/Cycle_B_2_00120.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00120 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00120.java
+ *- @ExecuteClass: Cycle_B_2_00120
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00120_A1 {
+    Cycle_B_2_00120_A2 a2_0;
+    Cycle_B_2_00120_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00120_A2 {
+    Cycle_B_2_00120_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00120_A3 {
+    Cycle_B_2_00120_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00120_A4 {
+    Cycle_B_2_00120_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_B_2_00120_A5 {
+    Cycle_B_2_00120_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_2_00120 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00120_A1 a1_0 = new Cycle_B_2_00120_A1();
+        a1_0.a2_0 = new Cycle_B_2_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00120_A3();
+        a1_0.a4_0 = new Cycle_B_2_00120_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a4_0.a5_0 = new Cycle_B_2_00120_A5();
+        a1_0.a4_0.a5_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a4_0.add();
+        a1_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a4_0.sum + a1_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 27)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0070-rc-function-Cycle_B_2_00130/Cycle_B_2_00130.java b/test/testsuite/ouroboros/memory_management/Function/RC0070-rc-function-Cycle_B_2_00130/Cycle_B_2_00130.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c1f2aacaadc6b059c25b04f05021ed6d23da88c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0070-rc-function-Cycle_B_2_00130/Cycle_B_2_00130.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00130 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00130.java
+ *- @ExecuteClass: Cycle_B_2_00130
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00130_A1 {
+    Cycle_B_2_00130_A2 a2_0;
+    Cycle_B_2_00130_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00130_A2 {
+    Cycle_B_2_00130_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00130_A3 {
+    Cycle_B_2_00130_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00130_A4 {
+    Cycle_B_2_00130_A1 a1_0;
+    Cycle_B_2_00130_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A4() {
+        a1_0 = null;
+        a6_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_B_2_00130_A5 {
+    Cycle_B_2_00130_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A5() {
+        a3_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_B_2_00130_A6 {
+    Cycle_B_2_00130_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A6() {
+        a5_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+public class Cycle_B_2_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00130_A1 a1_0 = new Cycle_B_2_00130_A1();
+        a1_0.a2_0 = new Cycle_B_2_00130_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00130_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00130_A4();
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        Cycle_B_2_00130_A5 a5_0 = new Cycle_B_2_00130_A5();
+        a1_0.a2_0.a3_0.a4_0.a6_0 = new Cycle_B_2_00130_A6();
+        a1_0.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_0;
+        a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a6_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a5_0.sum + a1_0.a2_0.a3_0.a4_0.a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 45)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0071-rc-function-Cycle_B_2_00140/Cycle_B_2_00140.java b/test/testsuite/ouroboros/memory_management/Function/RC0071-rc-function-Cycle_B_2_00140/Cycle_B_2_00140.java
new file mode 100644
index 0000000000000000000000000000000000000000..264da683e2c9b3f308ddcc98f9ad09dd08e636e5
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0071-rc-function-Cycle_B_2_00140/Cycle_B_2_00140.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00140 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00140.java
+ *- @ExecuteClass: Cycle_B_2_00140
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00140_A1 {
+    Cycle_B_2_00140_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00140_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00140_A2 {
+    Cycle_B_2_00140_A3 a3_0;
+    Cycle_B_2_00140_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00140_A2() {
+        a3_0 = null;
+        a1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00140_A3 {
+    Cycle_B_2_00140_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00140_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00140_A1 a1_0 = new Cycle_B_2_00140_A1();
+        a1_0.a2_0 = new Cycle_B_2_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00140_A3();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0072-rc-function-Cycle_B_2_00150/Cycle_B_2_00150.java b/test/testsuite/ouroboros/memory_management/Function/RC0072-rc-function-Cycle_B_2_00150/Cycle_B_2_00150.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2c771027c18fcdd9c919af7ccf8ace11d7d75d1
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0072-rc-function-Cycle_B_2_00150/Cycle_B_2_00150.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00150 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00150.java
+ *- @ExecuteClass: Cycle_B_2_00150
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00150_A1 {
+    Cycle_B_2_00150_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00150_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00150_A2 {
+    Cycle_B_2_00150_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00150_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00150_A3 {
+    Cycle_B_2_00150_A1 a1_0;
+    Cycle_B_2_00150_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00150_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00150_A1 a1_0 = new Cycle_B_2_00150_A1();
+        a1_0.a2_0 = new Cycle_B_2_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 14)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0073-rc-function-Cycle_B_2_00160/Cycle_B_2_00160.java b/test/testsuite/ouroboros/memory_management/Function/RC0073-rc-function-Cycle_B_2_00160/Cycle_B_2_00160.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8082d59cdd8a21282ea5abdd8578e9ccd2eb17d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0073-rc-function-Cycle_B_2_00160/Cycle_B_2_00160.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00160 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00160.java
+ *- @ExecuteClass: Cycle_B_2_00160
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00160_A1 {
+    Cycle_B_2_00160_A2 a2_0;
+    Cycle_B_2_00160_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00160_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00160_A2 {
+    Cycle_B_2_00160_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00160_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00160_A3 {
+    Cycle_B_2_00160_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00160_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00160_A1 a1_0 = new Cycle_B_2_00160_A1();
+        a1_0.a2_0 = new Cycle_B_2_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00160_A3();
+        a1_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0074-rc-function-Cycle_B_2_00170/Cycle_B_2_00170.java b/test/testsuite/ouroboros/memory_management/Function/RC0074-rc-function-Cycle_B_2_00170/Cycle_B_2_00170.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5726d4be17c77c8fa3182b72af611871808a20c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0074-rc-function-Cycle_B_2_00170/Cycle_B_2_00170.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00170 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00170.java
+ *- @ExecuteClass: Cycle_B_2_00170
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00170_A1 {
+    Cycle_B_2_00170_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00170_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00170_A2 {
+    Cycle_B_2_00170_A3 a3_0;
+    Cycle_B_2_00170_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00170_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00170_A3 {
+    Cycle_B_2_00170_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00170_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00170_A4 {
+    Cycle_B_2_00170_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00170_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00170_A1 a1_0 = new Cycle_B_2_00170_A1();
+        a1_0.a2_0 = new Cycle_B_2_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00170_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00170_A4();
+        a1_0.a2_0.a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0075-rc-function-Cycle_B_2_00180/Cycle_B_2_00180.java b/test/testsuite/ouroboros/memory_management/Function/RC0075-rc-function-Cycle_B_2_00180/Cycle_B_2_00180.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ec9213ba780428c357a10e1dfa1d45fe7ec854e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0075-rc-function-Cycle_B_2_00180/Cycle_B_2_00180.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00180 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00180.java
+ *- @ExecuteClass: Cycle_B_2_00180
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00180_A1 {
+    Cycle_B_2_00180_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00180_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00180_A2 {
+    Cycle_B_2_00180_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00180_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00180_A3 {
+    Cycle_B_2_00180_A1 a1_0;
+    Cycle_B_2_00180_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00180_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00180_A4 {
+    Cycle_B_2_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00180_A4() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00180_A1 a1_0 = new Cycle_B_2_00180_A1();
+        a1_0.a2_0 = new Cycle_B_2_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00180_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00180_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            System.out.println("ExpectResult");
+    }
+
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0076-rc-function-Cycle_B_2_00190/Cycle_B_2_00190.java b/test/testsuite/ouroboros/memory_management/Function/RC0076-rc-function-Cycle_B_2_00190/Cycle_B_2_00190.java
new file mode 100644
index 0000000000000000000000000000000000000000..85e88932e9976ef92f29d416f01979cbe6cef49e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0076-rc-function-Cycle_B_2_00190/Cycle_B_2_00190.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00190 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00190.java
+ *- @ExecuteClass: Cycle_B_2_00190
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00190_A1 {
+    Cycle_B_2_00190_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00190_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00190_A2 {
+    Cycle_B_2_00190_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00190_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00190_A3 {
+    Cycle_B_2_00190_A1 a1_0;
+    Cycle_B_2_00190_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00190_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00190_A4 {
+    Cycle_B_2_00190_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00190_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00190_A1 a1_0 = new Cycle_B_2_00190_A1();
+        a1_0.a2_0 = new Cycle_B_2_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00190_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00190_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0077-rc-function-Cycle_B_2_00200/Cycle_B_2_00200.java b/test/testsuite/ouroboros/memory_management/Function/RC0077-rc-function-Cycle_B_2_00200/Cycle_B_2_00200.java
new file mode 100644
index 0000000000000000000000000000000000000000..0fccb4bee9b33fbd7448fa5e7ef5cbb40e94bd13
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0077-rc-function-Cycle_B_2_00200/Cycle_B_2_00200.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00200 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00200.java
+ *- @ExecuteClass: Cycle_B_2_00200
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00200_A1 {
+    Cycle_B_2_00200_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00200_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00200_A2 {
+    Cycle_B_2_00200_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00200_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00200_A3 {
+    Cycle_B_2_00200_A1 a1_0;
+    Cycle_B_2_00200_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00200_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00200_A4 {
+    Cycle_B_2_00200_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00200_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00200_A1 a1_0 = new Cycle_B_2_00200_A1();
+        a1_0.a2_0 = new Cycle_B_2_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00200_A3();
+        Cycle_B_2_00200_A4 a4_0 = new Cycle_B_2_00200_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0078-rc-function-Cycle_B_2_00210/Cycle_B_2_00210.java b/test/testsuite/ouroboros/memory_management/Function/RC0078-rc-function-Cycle_B_2_00210/Cycle_B_2_00210.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2a719037d1dba2cf7f10db682018d80fe478e6a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0078-rc-function-Cycle_B_2_00210/Cycle_B_2_00210.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00210 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00210.java
+ *- @ExecuteClass: Cycle_B_2_00210
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00210_A1 {
+    Cycle_B_2_00210_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A2 {
+    Cycle_B_2_00210_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A3 {
+    Cycle_B_2_00210_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A4 {
+    Cycle_B_2_00210_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A5 {
+    Cycle_B_2_00210_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A6 {
+    Cycle_B_2_00210_A1 a1_0;
+    Cycle_B_2_00210_A8 a8_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A6() {
+        a1_0 = null;
+        a8_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a8_0.a;
+    }
+}
+
+class Cycle_B_2_00210_A8 {
+    Cycle_B_2_00210_A9 a9_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A9 {
+    Cycle_B_2_00210_A7 a7_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A7 {
+    Cycle_B_2_00210_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00210 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00210_A1 a1_0 = new Cycle_B_2_00210_A1();
+        a1_0.a2_0 = new Cycle_B_2_00210_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00210_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00210_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00210_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00210_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0 = new Cycle_B_2_00210_A8();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0 = new Cycle_B_2_00210_A9();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00210_A7();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0079-rc-function-Cycle_B_2_00220/Cycle_B_2_00220.java b/test/testsuite/ouroboros/memory_management/Function/RC0079-rc-function-Cycle_B_2_00220/Cycle_B_2_00220.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2eba1fb51ab3a1361d27d958164e40a5546afa9
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0079-rc-function-Cycle_B_2_00220/Cycle_B_2_00220.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00220.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00220 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00220.java
+ *- @ExecuteClass: Cycle_B_2_00220
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00220_A1 {
+    Cycle_B_2_00220_A2 a2_0;
+    Cycle_B_2_00220_A8 a8_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A1() {
+        a2_0 = null;
+        a8_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a8_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A2 {
+    Cycle_B_2_00220_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A3 {
+    Cycle_B_2_00220_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A4 {
+    Cycle_B_2_00220_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A5 {
+    Cycle_B_2_00220_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A6 {
+    Cycle_B_2_00220_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A6() {
+        a1_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_2_00220_A8 {
+    Cycle_B_2_00220_A9 a9_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A9 {
+    Cycle_B_2_00220_A7 a7_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A7 {
+    Cycle_B_2_00220_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00220 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00220_A1 a1_0 = new Cycle_B_2_00220_A1();
+        a1_0.a2_0 = new Cycle_B_2_00220_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00220_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00220_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00220_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00220_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a8_0 = new Cycle_B_2_00220_A8();
+        a1_0.a8_0.a9_0 = new Cycle_B_2_00220_A9();
+        a1_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00220_A7();
+        a1_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a8_0.add();
+        a1_0.a8_0.a9_0.add();
+        a1_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a8_0.sum + a1_0.a8_0.a9_0.sum + a1_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0080-rc-function-Cycle_B_2_00230/Cycle_B_2_00230.java b/test/testsuite/ouroboros/memory_management/Function/RC0080-rc-function-Cycle_B_2_00230/Cycle_B_2_00230.java
new file mode 100644
index 0000000000000000000000000000000000000000..85b221ed37733d34c50c6a214113958f9b0926db
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0080-rc-function-Cycle_B_2_00230/Cycle_B_2_00230.java
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00230.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00230 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00230.java
+ *- @ExecuteClass: Cycle_B_2_00230
+ *- @ExecuteArgs:
+ */
+class Cycle_B_2_00230_A1 {
+    Cycle_B_2_00230_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A2 {
+    Cycle_B_2_00230_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A3 {
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A4 {
+    Cycle_B_2_00230_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A5 {
+    Cycle_B_2_00230_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A6 {
+    Cycle_B_2_00230_A1 a1_0;
+    Cycle_B_2_00230_A10 a10_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A6() {
+        a1_0 = null;
+        a10_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a10_0.a;
+    }
+}
+
+class Cycle_B_2_00230_A8 {
+    Cycle_B_2_00230_A9 a9_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A9 {
+    Cycle_B_2_00230_A7 a7_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A7 {
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A10 {
+    Cycle_B_2_00230_A8 a8_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A10() {
+        a8_0 = null;
+        a = 10;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00230 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        //System.out.println(nsum);
+        if (nsum == 97)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0081-rc-function-Cycle_B_2_00240/Cycle_B_2_00240.java b/test/testsuite/ouroboros/memory_management/Function/RC0081-rc-function-Cycle_B_2_00240/Cycle_B_2_00240.java
new file mode 100644
index 0000000000000000000000000000000000000000..69c2e711ee2d10c943147bc0205f47b4f9f86338
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0081-rc-function-Cycle_B_2_00240/Cycle_B_2_00240.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_B_2_00240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00240 in RC测试-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00240.java
+ *- @ExecuteClass: Cycle_B_2_00240
+ *- @ExecuteArgs:
+ */
+
+class Cycle_B_2_00240_A1 {
+    Cycle_B_2_00240_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_B_2_00240_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_B_2_00240_A2 {
+    Cycle_B_2_00240_A1 a1_0;
+    Cycle_B_2_00240_A3 a3_0;
+    Cycle_B_2_00240_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_B_2_00240_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_B_2_00240_A3 {
+    Cycle_B_2_00240_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_B_2_00240_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00240_A4 {
+    Cycle_B_2_00240_A1 a1_0;
+    Cycle_B_2_00240_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_B_2_00240_A4(String strObjectName) {
+        a2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+class Cycle_B_2_00240_B1 {
+    Cycle_B_2_00240_A3 a3_0;
+    Cycle_B_2_00240_B2 b2_0;
+    Nocycle_B_2_00240_C2 c2_0;
+
+
+    int a;
+    int sum;
+
+    Cycle_B_2_00240_B1() {
+        a3_0 = null;
+        b2_0 = null;
+        c2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a + b2_0.a + c2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00240_B2 {
+    Cycle_B_2_00240_B1 b1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00240_B2() {
+        b1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_B_2_00240_C1 {
+    Nocycle_B_2_00240_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_B_2_00240_C1(String strObjectName) {
+        c2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+    void add() {
+        sum = a + c2_0.a;
+    }
+}
+
+class Nocycle_B_2_00240_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_B_2_00240_C2(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Cycle_B_2_00240 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00240_A1 a1_main = new Cycle_B_2_00240_A1("a1_main");
+        a1_main.a2_0 = new Cycle_B_2_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_B_2_00240_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_B_2_00240_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+
+        Cycle_B_2_00240_B1 b1_0 = new Cycle_B_2_00240_B1();
+        b1_0.a3_0 = new Cycle_B_2_00240_A3("a3_b1");
+        b1_0.b2_0 = new Cycle_B_2_00240_B2();
+        b1_0.c2_0 = new Nocycle_B_2_00240_C2("c2_b1");
+        b1_0.b2_0.b1_0 = b1_0;
+        b1_0.add();
+        b1_0.b2_0.add();
+        int nsum = (b1_0.sum + b1_0.b2_0.sum);
+        Nocycle_B_2_00240_C1 c1_main = new Nocycle_B_2_00240_C1("c1_main");
+        c1_main.c2_0 = new Nocycle_B_2_00240_C2("c2_0");
+        c1_main.add();
+        c1_main.c2_0.add();
+        int result2 = c1_main.sum + c1_main.c2_0.sum;
+        if (result == 1124 && nsum == 310 && result2 == 704)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0082-rc-function-Nocycle_a_00010/Nocycle_a_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0082-rc-function-Nocycle_a_00010/Nocycle_a_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..2547d3f636ec8d400c15ff06b1a1e825bf71fbcc
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0082-rc-function-Nocycle_a_00010/Nocycle_a_00010.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00010 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00010.java
+ *- @ExecuteClass: Nocycle_a_00010
+ *- @ExecuteArgs:
+ */
+
+class Nocycle_a_00010_A1 {
+    Nocycle_a_00010_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00010_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00010_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00010_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        Nocycle_a_00010_A1 a1_main = new Nocycle_a_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00010_B1("b1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 704)
+            System.out.println("ExpectResult");
+
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0083-rc-function-Nocycle_a_00020/Nocycle_a_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0083-rc-function-Nocycle_a_00020/Nocycle_a_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f6ab592ada44881fcd20aaa8b0cd16f69bb422a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0083-rc-function-Nocycle_a_00020/Nocycle_a_00020.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00020 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00020.java
+ *- @ExecuteClass: Nocycle_a_00020
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00020_A1 {
+    Nocycle_a_00020_B1 b1_0;
+    Nocycle_a_00020_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00020_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00020_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00020_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00020_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00020_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00020_A1 a1_main = new Nocycle_a_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00020_B2("b2_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1310)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0084-rc-function-Nocycle_a_00030/Nocycle_a_00030.java b/test/testsuite/ouroboros/memory_management/Function/RC0084-rc-function-Nocycle_a_00030/Nocycle_a_00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e2b634ca17422664ff1a1c2a5a76cc52c8ef8ed
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0084-rc-function-Nocycle_a_00030/Nocycle_a_00030.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00030 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00030.java
+ *- @ExecuteClass: Nocycle_a_00030
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00030_A1 {
+    Nocycle_a_00030_B1 b1_0;
+    Nocycle_a_00030_B2 b2_0;
+    Nocycle_a_00030_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00030_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+class Nocycle_a_00030_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00030_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00030_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00030_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00030_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00030_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00030_A1 a1_main = new Nocycle_a_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00030_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00030_B3("b3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        if (result == 1919)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0085-rc-function-Nocycle_a_00040/Nocycle_a_00040.java b/test/testsuite/ouroboros/memory_management/Function/RC0085-rc-function-Nocycle_a_00040/Nocycle_a_00040.java
new file mode 100644
index 0000000000000000000000000000000000000000..ddeb505fa5405af4ecba0771e7454df16e04d657
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0085-rc-function-Nocycle_a_00040/Nocycle_a_00040.java
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00040 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00040.java
+ *- @ExecuteClass: Nocycle_a_00040
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00040_A1 {
+    Nocycle_a_00040_B1 b1_0;
+    Nocycle_a_00040_B2 b2_0;
+    Nocycle_a_00040_B3 b3_0;
+    Nocycle_a_00040_B4 b4_0;
+    Nocycle_a_00040_B5 b5_0;
+    Nocycle_a_00040_B6 b6_0;
+    Nocycle_a_00040_B7 b7_0;
+    Nocycle_a_00040_B8 b8_0;
+    Nocycle_a_00040_B9 b9_0;
+    Nocycle_a_00040_B10 b10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        b5_0 = null;
+        b6_0 = null;
+        b7_0 = null;
+        b8_0 = null;
+        b9_0 = null;
+        b10_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + b5_0.a + b6_0.a + b7_0.a + b8_0.a + b9_0.a + b10_0.a;
+    }
+}
+
+class Nocycle_a_00040_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00040_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B5 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B5(String strObjectName) {
+        a = 205;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B6 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B6(String strObjectName) {
+        a = 206;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B7(String strObjectName) {
+        a = 207;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00040_B8 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B8(String strObjectName) {
+        a = 208;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B9 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B9(String strObjectName) {
+        a = 209;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B10 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B10(String strObjectName) {
+        a = 210;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00040_A1 a1_main = new Nocycle_a_00040_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00040_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00040_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00040_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00040_B4("b4_0");
+        a1_main.b5_0 = new Nocycle_a_00040_B5("b5_0");
+        a1_main.b6_0 = new Nocycle_a_00040_B6("b6_0");
+        a1_main.b7_0 = new Nocycle_a_00040_B7("b7_0");
+        a1_main.b8_0 = new Nocycle_a_00040_B8("b8_0");
+        a1_main.b9_0 = new Nocycle_a_00040_B9("b9_0");
+        a1_main.b10_0 = new Nocycle_a_00040_B10("b10_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b5_0.add();
+        a1_main.b6_0.add();
+        a1_main.b7_0.add();
+        a1_main.b8_0.add();
+        a1_main.b9_0.add();
+        a1_main.b10_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b5_0.sum + a1_main.b6_0.sum + a1_main.b7_0.sum + a1_main.b8_0.sum + a1_main.b9_0.sum + a1_main.b10_0.sum;
+        if (result == 6266)
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0086-rc-function-Nocycle_a_00050/Nocycle_a_00050.java b/test/testsuite/ouroboros/memory_management/Function/RC0086-rc-function-Nocycle_a_00050/Nocycle_a_00050.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1834837f51564f51d2db3f11f0d6875b8befcb2
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0086-rc-function-Nocycle_a_00050/Nocycle_a_00050.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00050 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00050.java
+ *- @ExecuteClass: Nocycle_a_00050
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00050_A1 {
+    Nocycle_a_00050_B1 b1_0;
+    Nocycle_a_00050_B2 b2_0;
+    Nocycle_a_00050_B3 b3_0;
+    Nocycle_a_00050_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_a_00050_B1 {
+    Nocycle_a_00050_C1 c1_0;
+    Nocycle_a_00050_C2 c2_0;
+    Nocycle_a_00050_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+class Nocycle_a_00050_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00050_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00050_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00050_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00050_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00050_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00050_A1 a1_main = new Nocycle_a_00050_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00050_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00050_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_a_00050_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_a_00050_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_a_00050_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00050_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00050_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        a1_main.b1_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c2_0.sum+a1_main.b1_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum + a1_main.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5048)
+            System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0087-rc-function-Nocycle_a_00060/Nocycle_a_00060.java b/test/testsuite/ouroboros/memory_management/Function/RC0087-rc-function-Nocycle_a_00060/Nocycle_a_00060.java
new file mode 100644
index 0000000000000000000000000000000000000000..df2390963d5a06c41c22a5167f134e9e3b050c81
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0087-rc-function-Nocycle_a_00060/Nocycle_a_00060.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00060 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00060.java
+ *- @ExecuteClass: Nocycle_a_00060
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00060_A1 {
+    Nocycle_a_00060_B1 b1_0;
+    Nocycle_a_00060_B2 b2_0;
+    Nocycle_a_00060_B3 b3_0;
+    Nocycle_a_00060_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_a_00060_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_B2 {
+    Nocycle_a_00060_C1 c1_0;
+    Nocycle_a_00060_C2 c2_0;
+    Nocycle_a_00060_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_B2(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+
+class Nocycle_a_00060_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00060_A1 a1_main = new Nocycle_a_00060_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00060_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00060_B2("b2_0");
+        a1_main.b2_0.c1_0 = new Nocycle_a_00060_C1("c1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00060_C2("c2_0");
+        a1_main.b2_0.c3_0 = new Nocycle_a_00060_C3("c3_0");
+        a1_main.b3_0 = new Nocycle_a_00060_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00060_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c1_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b2_0.c3_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c1_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b2_0.c3_0.sum;
+        if (result == 5047)
+            System.out.println("ExpectResult");
+
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0088-rc-function-Nocycle_a_00070/Nocycle_a_00070.java b/test/testsuite/ouroboros/memory_management/Function/RC0088-rc-function-Nocycle_a_00070/Nocycle_a_00070.java
new file mode 100644
index 0000000000000000000000000000000000000000..8490a8731c8870bec628a0daad63f20346633e09
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0088-rc-function-Nocycle_a_00070/Nocycle_a_00070.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00070 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00070.java
+ *- @ExecuteClass: Nocycle_a_00070
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00070_A1 {
+    Nocycle_a_00070_B1 b1_0;
+    Nocycle_a_00070_B2 b2_0;
+    Nocycle_a_00070_B3 b3_0;
+    Nocycle_a_00070_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_a_00070_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00070_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00070_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00070_B4 {
+    Nocycle_a_00070_C1 c1_0;
+    Nocycle_a_00070_C2 c2_0;
+    Nocycle_a_00070_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_B4(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+
+class Nocycle_a_00070_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00070_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00070_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00070_A1 a1_main = new Nocycle_a_00070_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00070_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00070_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00070_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00070_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_00070_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_00070_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00070_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5045)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0089-rc-function-Nocycle_a_00080/Nocycle_a_00080.java b/test/testsuite/ouroboros/memory_management/Function/RC0089-rc-function-Nocycle_a_00080/Nocycle_a_00080.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9ef45aabf8af8e3cb91d1333e47842c73a6346f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0089-rc-function-Nocycle_a_00080/Nocycle_a_00080.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00080 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00080.java
+ *- @ExecuteClass: Nocycle_a_00080
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00080_A1 {
+    Nocycle_a_00080_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00080_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00080_B1 {
+    Nocycle_a_00080_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00080_B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00080_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00080_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00080_A1 a1_main = new Nocycle_a_00080_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00080_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00080_C1("c1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1406)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0090-rc-function-Nocycle_a_00090/Nocycle_a_00090.java b/test/testsuite/ouroboros/memory_management/Function/RC0090-rc-function-Nocycle_a_00090/Nocycle_a_00090.java
new file mode 100644
index 0000000000000000000000000000000000000000..a891b1b741ca4fe6e6cd451f2ff1b5ef7c6e799b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0090-rc-function-Nocycle_a_00090/Nocycle_a_00090.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00090 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00090.java
+ *- @ExecuteClass: Nocycle_a_00090
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00090_A1 {
+    Nocycle_a_00090_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00090_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00090_B1 {
+    Nocycle_a_00090_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00090_B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00090_C1 {
+    Nocycle_a_00090_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00090_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_00090_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00090_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00090_A1 a1_main = new Nocycle_a_00090_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00090_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00090_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00090_D1("d1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2308)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0091-rc-function-Nocycle_a_00100/Nocycle_a_00100.java b/test/testsuite/ouroboros/memory_management/Function/RC0091-rc-function-Nocycle_a_00100/Nocycle_a_00100.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f8ae5120be0705466f807bb8fc4eeb047e53dea
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0091-rc-function-Nocycle_a_00100/Nocycle_a_00100.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00100 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00100.java
+ *- @ExecuteClass: Nocycle_a_00100
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00100_A1 {
+    Nocycle_a_00100_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00100_B1 {
+    Nocycle_a_00100_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00100_C1 {
+    Nocycle_a_00100_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_00100_D1 {
+    Nocycle_a_00100_E1 e1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_D1(String strObjectName) {
+        e1_0 = null;
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + e1_0.a;
+    }
+}
+
+class Nocycle_a_00100_E1 {
+    Nocycle_a_00100_F1 f1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_E1(String strObjectName) {
+        f1_0 = null;
+        a = 501;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + f1_0.a;
+    }
+}
+
+
+class Nocycle_a_00100_F1 {
+    Nocycle_a_00100_G1 g1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_F1(String strObjectName) {
+        g1_0 = null;
+        a = 601;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + g1_0.a;
+    }
+}
+
+class Nocycle_a_00100_G1 {
+    Nocycle_a_00100_H1 h1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_G1(String strObjectName) {
+        h1_0 = null;
+        a = 701;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + h1_0.a;
+    }
+}
+
+
+class Nocycle_a_00100_H1 {
+    Nocycle_a_00100_I1 i1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_H1(String strObjectName) {
+        i1_0 = null;
+        a = 801;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + i1_0.a;
+    }
+}
+
+
+class Nocycle_a_00100_I1 {
+    Nocycle_a_00100_J1 j1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_I1(String strObjectName) {
+        j1_0 = null;
+        a = 901;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + j1_0.a;
+    }
+}
+
+class Nocycle_a_00100_J1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_J1(String strObjectName) {
+        a = 1001;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00100_A1 a1_main = new Nocycle_a_00100_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00100_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00100_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00100_D1("d1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_00100_E1("e1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_00100_F1("f1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_00100_G1("g1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_00100_H1("h1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_00100_I1("i1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_00100_J1("j1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        if (result == 11920)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0092-rc-function-Nocycle_a_00110/Nocycle_a_00110.java b/test/testsuite/ouroboros/memory_management/Function/RC0092-rc-function-Nocycle_a_00110/Nocycle_a_00110.java
new file mode 100644
index 0000000000000000000000000000000000000000..bae9f0df90a61544ebb1260e771146c336cbf447
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0092-rc-function-Nocycle_a_00110/Nocycle_a_00110.java
@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00110 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00110.java
+ *- @ExecuteClass: Nocycle_a_00110
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00110_A1 {
+    Nocycle_a_00110_B1 b1_0;
+    Nocycle_a_00110_B2 b2_0;
+    Nocycle_a_00110_B3 b3_0;
+    Nocycle_a_00110_B4 b4_0;
+    Nocycle_a_00110_D5 d5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        d5_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + d5_0.a;
+    }
+}
+
+class Nocycle_a_00110_B1 {
+    Nocycle_a_00110_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+
+class Nocycle_a_00110_B2 {
+    Nocycle_a_00110_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_B2(String strObjectName) {
+        c2_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c2_0.a;
+    }
+}
+
+
+class Nocycle_a_00110_B3 {
+    Nocycle_a_00110_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00110_B4 {
+    Nocycle_a_00110_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_B4(String strObjectName) {
+        c3_0 = null;
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c3_0.a;
+    }
+}
+
+
+class Nocycle_a_00110_C1 {
+    Nocycle_a_00110_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_C1(String strObjectName) {
+        d2_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+class Nocycle_a_00110_C2 {
+    Nocycle_a_00110_D3 d3_0;
+    Nocycle_a_00110_D4 d4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_C2(String strObjectName) {
+        d3_0 = null;
+        d4_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d3_0.a + d4_0.a;
+    }
+}
+
+class Nocycle_a_00110_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00110_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00110_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00110_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00110_D4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D4(String strObjectName) {
+        a = 404;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00110_D5 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D5(String strObjectName) {
+        a = 405;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00110_A1 a1_main = new Nocycle_a_00110_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00110_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00110_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00110_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00110_B4("b4_0");
+        a1_main.b1_0.d1_0 = new Nocycle_a_00110_D1("d1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00110_C2("c2_0");
+        a1_main.b3_0.c1_0 = new Nocycle_a_00110_C1("c1_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00110_C3("c3_0");
+        a1_main.b3_0.c1_0.d2_0 = new Nocycle_a_00110_D2("d2_0");
+        a1_main.b2_0.c2_0.d3_0 = new Nocycle_a_00110_D3("d3_0");
+        a1_main.b2_0.c2_0.d4_0 = new Nocycle_a_00110_D4("d4_0");
+        a1_main.d5_0 = new Nocycle_a_00110_D5("d5_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b3_0.c1_0.add();
+        a1_main.b4_0.c3_0.add();
+        a1_main.b1_0.d1_0.add();
+        a1_main.b3_0.c1_0.d2_0.add();
+        a1_main.b2_0.c2_0.d3_0.add();
+        a1_main.b2_0.c2_0.d4_0.add();
+        a1_main.d5_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b3_0.c1_0.sum + a1_main.b4_0.c3_0.sum + a1_main.b1_0.d1_0.sum + a1_main.b3_0.c1_0.d2_0.sum + a1_main.b2_0.c2_0.d3_0.sum + a1_main.b2_0.c2_0.d4_0.sum + a1_main.d5_0.sum;
+        if (result == 9881)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0093-rc-function-Nocycle_a_00120/Nocycle_a_00120.java b/test/testsuite/ouroboros/memory_management/Function/RC0093-rc-function-Nocycle_a_00120/Nocycle_a_00120.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fa9b117ff9fec8362b99b399b9e86efd5b49194
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0093-rc-function-Nocycle_a_00120/Nocycle_a_00120.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00120.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination: Nocycle_a_00120 in RC测试-No-Cycle-00.vsd.
+ * -@Brief:functionTest
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Nocycle_a_00120.java
+ * -@ExecuteClass: Nocycle_a_00120
+ * -@ExecuteArgs:
+ */
+class Nocycle_a_00120_A1 {
+    Nocycle_a_00120_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00120_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00120_A2 {
+    Nocycle_a_00120_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00120_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00120_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00120_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00120 {
+
+    public static void main(String[] args) {
+        Nocycle_a_00120_A1 a1_main = new Nocycle_a_00120_A1("a1_main");
+        Nocycle_a_00120_A2 a2_main = new Nocycle_a_00120_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum;
+        if (result == 1007) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0094-rc-function-Nocycle_a_00130/Nocycle_a_00130.java b/test/testsuite/ouroboros/memory_management/Function/RC0094-rc-function-Nocycle_a_00130/Nocycle_a_00130.java
new file mode 100644
index 0000000000000000000000000000000000000000..65b876f4aa974da71cb3b2669bfea74bd6895e71
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0094-rc-function-Nocycle_a_00130/Nocycle_a_00130.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00130 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00130.java
+ *- @ExecuteClass: Nocycle_a_00130
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00130_A1 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A2 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class Nocycle_a_00130_A3 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A3(String strObjectName) {
+        b1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A4 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A4(String strObjectName) {
+        b1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A5 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A5(String strObjectName) {
+        b1_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class Nocycle_a_00130_A6 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A6(String strObjectName) {
+        b1_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A7 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A7(String strObjectName) {
+        b1_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A8 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A8(String strObjectName) {
+        b1_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A9 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A9(String strObjectName) {
+        b1_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A10 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A10(String strObjectName) {
+        b1_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class Nocycle_a_00130_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00130_A1 a1_main = new Nocycle_a_00130_A1("a1_main");
+        Nocycle_a_00130_A2 a2_main = new Nocycle_a_00130_A2("a2_main");
+        Nocycle_a_00130_A3 a3_main = new Nocycle_a_00130_A3("a3_main");
+        Nocycle_a_00130_A4 a4_main = new Nocycle_a_00130_A4("a4_main");
+        Nocycle_a_00130_A5 a5_main = new Nocycle_a_00130_A5("a5_main");
+        Nocycle_a_00130_A6 a6_main = new Nocycle_a_00130_A6("a6_main");
+        Nocycle_a_00130_A7 a7_main = new Nocycle_a_00130_A7("a7_main");
+        Nocycle_a_00130_A8 a8_main = new Nocycle_a_00130_A8("a8_main");
+        Nocycle_a_00130_A9 a9_main = new Nocycle_a_00130_A9("a9_main");
+        Nocycle_a_00130_A10 a10_main = new Nocycle_a_00130_A10("a10_main");
+        a1_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a3_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a4_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a5_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a6_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a7_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a8_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a9_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a10_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        a3_main.b1_0.add();
+        a4_main.b1_0.add();
+        a5_main.b1_0.add();
+        a6_main.b1_0.add();
+        a7_main.b1_0.add();
+        a8_main.b1_0.add();
+        a9_main.b1_0.add();
+        a10_main.b1_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + a1_main.b1_0.sum;
+
+        if (result == 3467)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0095-rc-function-Nocycle_a_00140/Nocycle_a_00140.java b/test/testsuite/ouroboros/memory_management/Function/RC0095-rc-function-Nocycle_a_00140/Nocycle_a_00140.java
new file mode 100644
index 0000000000000000000000000000000000000000..b54160e1215714f0c2faf00ce68ecb55aaee04d3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0095-rc-function-Nocycle_a_00140/Nocycle_a_00140.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00140 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00140.java
+ *- @ExecuteClass: Nocycle_a_00140
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00140_A1 {
+    Nocycle_a_00140_B1 b1_0;
+    Nocycle_a_00140_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00140_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00140_A2 {
+    Nocycle_a_00140_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00140_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class Nocycle_a_00140_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00140_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00140_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00140_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00140_A1 a1_main = new Nocycle_a_00140_A1("a1_main");
+        Nocycle_a_00140_A2 a2_main = new Nocycle_a_00140_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00140_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 1613)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0096-rc-function-Nocycle_a_00150/Nocycle_a_00150.java b/test/testsuite/ouroboros/memory_management/Function/RC0096-rc-function-Nocycle_a_00150/Nocycle_a_00150.java
new file mode 100644
index 0000000000000000000000000000000000000000..b58df5f785eb387e1f1a6425b16c5cec5aec4686
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0096-rc-function-Nocycle_a_00150/Nocycle_a_00150.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00150 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00150.java
+ *- @ExecuteClass: Nocycle_a_00150
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00150_A1 {
+    Nocycle_a_00150_B1 b1_0;
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00150_A2 {
+    Nocycle_a_00150_B1 b1_0;
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00150_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00150_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 1815)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0097-rc-function-Nocycle_a_00160/Nocycle_a_00160.java b/test/testsuite/ouroboros/memory_management/Function/RC0097-rc-function-Nocycle_a_00160/Nocycle_a_00160.java
new file mode 100644
index 0000000000000000000000000000000000000000..7092e46f29b38482d1e44675071e7b283f2aed04
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0097-rc-function-Nocycle_a_00160/Nocycle_a_00160.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00160 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00160.java
+ *- @ExecuteClass: Nocycle_a_00160
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00160_A1 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00160_A2 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00160_A3 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_A3(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00160_A4 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_A4(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00160_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00160_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00160_A1 a1_main = new Nocycle_a_00160_A1("a1_main");
+        Nocycle_a_00160_A2 a2_main = new Nocycle_a_00160_A2("a2_main");
+        Nocycle_a_00160_A3 a3_main = new Nocycle_a_00160_A3("a3_main");
+        Nocycle_a_00160_A4 a4_main = new Nocycle_a_00160_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a3_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a4_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+
+        if (result == 2828)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0098-rc-function-Nocycle_a_00170/Nocycle_a_00170.java b/test/testsuite/ouroboros/memory_management/Function/RC0098-rc-function-Nocycle_a_00170/Nocycle_a_00170.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a85ae1b666c8cee99affb5d755597973db8ecb3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0098-rc-function-Nocycle_a_00170/Nocycle_a_00170.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00170 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00170.java
+ *- @ExecuteClass: Nocycle_a_00170
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00170_A1 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+class Nocycle_a_00170_A2 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+
+class Nocycle_a_00170_A3 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_A3(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+class Nocycle_a_00170_A4 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_A4(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+
+class Nocycle_a_00170_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00170_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00170_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00170_A1 a1_main = new Nocycle_a_00170_A1("a1_main");
+        Nocycle_a_00170_A2 a2_main = new Nocycle_a_00170_A2("a2_main");
+        Nocycle_a_00170_A3 a3_main = new Nocycle_a_00170_A3("a3_main");
+        Nocycle_a_00170_A4 a4_main = new Nocycle_a_00170_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a2_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a2_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a3_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a3_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a4_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a4_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a2_main.b3_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b3_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        a4_main.b3_0.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        if (result == 4046)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0099-rc-function-Nocycle_a_00180/Nocycle_a_00180.java b/test/testsuite/ouroboros/memory_management/Function/RC0099-rc-function-Nocycle_a_00180/Nocycle_a_00180.java
new file mode 100644
index 0000000000000000000000000000000000000000..7bbaea408eab01b1f0a11faf7697cbcf192d47b5
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0099-rc-function-Nocycle_a_00180/Nocycle_a_00180.java
@@ -0,0 +1,356 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00180 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00180.java
+ *- @ExecuteClass: Nocycle_a_00180
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_00180_A1 {
+    Nocycle_a_00180_B1 b1_0;
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_A2 {
+    Nocycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_A3 {
+    Nocycle_a_00180_B2 b2_0;
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_a_00180_A4 {
+    Nocycle_a_00180_B3 b3_0;
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_B1 {
+    Nocycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_B2 {
+    Nocycle_a_00180_C1 c1_0;
+    Nocycle_a_00180_D1 d1_0;
+    Nocycle_a_00180_D2 d2_0;
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_B3 {
+    Nocycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_C1 {
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_00180_C2 {
+    Nocycle_a_00180_D2 d2_0;
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        if (result == 9260)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0100-rc-function-Nocycle_a_2_00010/Nocycle_a_2_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0100-rc-function-Nocycle_a_2_00010/Nocycle_a_2_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..e98653ad109de578c621f32716a40aec0eaa1264
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0100-rc-function-Nocycle_a_2_00010/Nocycle_a_2_00010.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_2_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_2_00010 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_2_00010.java
+ *- @ExecuteClass: Nocycle_a_2_00010
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_2_00010_A1 {
+    Nocycle_a_2_00010_B1 b1_0;
+    Nocycle_a_2_00010_B2 b2_0;
+    Nocycle_a_2_00010_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+class Nocycle_a_2_00010_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00010_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00010_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00010_A2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_A2(String strObjectName) {
+        a = 10;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_2_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_2_00010_A1 a1_main = new Nocycle_a_2_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00010_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00010_B3("b3_0");
+        Nocycle_a_2_00010_A2 a2_main = new Nocycle_a_2_00010_A2("a2_main");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a2_main.sum;
+        if (result == 1939)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0101-rc-function-Nocycle_a_2_00020/Nocycle_a_2_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0101-rc-function-Nocycle_a_2_00020/Nocycle_a_2_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..204c805a99fe476dc1fde530532d31206ddf6775
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0101-rc-function-Nocycle_a_2_00020/Nocycle_a_2_00020.java
@@ -0,0 +1,734 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_2_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_2_00020 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_2_00020.java
+ *- @ExecuteClass: Nocycle_a_2_00020
+ *- @ExecuteArgs:
+ */
+class Nocycle_a_2_00020_A1 {
+    Nocycle_a_2_00020_B1 b1_0;
+    Nocycle_a_2_00020_B2 b2_0;
+    Nocycle_a_2_00020_B3 b3_0;
+    Nocycle_a_2_00020_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_2_00020_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_2_00020_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_2_00020_B4 {
+    Nocycle_a_2_00020_C1 c1_0;
+    Nocycle_a_2_00020_C2 c2_0;
+    Nocycle_a_2_00020_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_B4(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_2A1 {
+    Nocycle_a_2_00020_2B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2B1 {
+    Nocycle_a_2_00020_2C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_2C1 {
+    Nocycle_a_2_00020_2D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2D1 {
+    Nocycle_a_2_00020_2E1 e1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2D1(String strObjectName) {
+        e1_0 = null;
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + e1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2E1 {
+    Nocycle_a_2_00020_2F1 f1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2E1(String strObjectName) {
+        f1_0 = null;
+        a = 501;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + f1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_2F1 {
+    Nocycle_a_2_00020_2G1 g1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2F1(String strObjectName) {
+        g1_0 = null;
+        a = 601;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + g1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2G1 {
+    Nocycle_a_2_00020_2H1 h1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2G1(String strObjectName) {
+        h1_0 = null;
+        a = 701;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + h1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_2H1 {
+    Nocycle_a_2_00020_2I1 i1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2H1(String strObjectName) {
+        i1_0 = null;
+        a = 801;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + i1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_2I1 {
+    Nocycle_a_2_00020_2J1 j1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2I1(String strObjectName) {
+        j1_0 = null;
+        a = 901;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + j1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2J1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2J1(String strObjectName) {
+        a = 1001;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_3A1 {
+    Nocycle_a_2_00020_3B1 b1_0;
+    Nocycle_a_2_00020_3D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3A2 {
+    Nocycle_a_2_00020_3B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3A3 {
+    Nocycle_a_2_00020_3B2 b2_0;
+    Nocycle_a_2_00020_3C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_3A4 {
+    Nocycle_a_2_00020_3B3 b3_0;
+    Nocycle_a_2_00020_3C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3B1 {
+    Nocycle_a_2_00020_3D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3B2 {
+    Nocycle_a_2_00020_3C1 c1_0;
+    Nocycle_a_2_00020_3D1 d1_0;
+    Nocycle_a_2_00020_3D2 d2_0;
+    Nocycle_a_2_00020_3D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3B3 {
+    Nocycle_a_2_00020_3C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3C1 {
+    Nocycle_a_2_00020_3D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_3C2 {
+    Nocycle_a_2_00020_3D2 d2_0;
+    Nocycle_a_2_00020_3D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_3D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_3D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_2_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_2_00020_A1 a1_main = new Nocycle_a_2_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_2_00020_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_2_00020_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_2_00020_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_2_00020_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result1 = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result1);
+        Nocycle_a_2_00020_2A1 a1_main2 = new Nocycle_a_2_00020_2A1("a1_main2");
+        a1_main2.b1_0 = new Nocycle_a_2_00020_2B1("b1_0");
+        a1_main2.b1_0.c1_0 = new Nocycle_a_2_00020_2C1("c1_0");
+        a1_main2.b1_0.c1_0.d1_0 = new Nocycle_a_2_00020_2D1("d1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_2_00020_2E1("e1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_2_00020_2F1("f1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_2_00020_2G1("g1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_2_00020_2H1("h1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_2_00020_2I1("i1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_2_00020_2J1("j1_0");
+        a1_main2.add();
+        a1_main2.b1_0.add();
+        a1_main2.b1_0.c1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+
+        int result2 = a1_main2.sum + a1_main2.b1_0.sum + a1_main2.b1_0.c1_0.sum + a1_main2.b1_0.c1_0.d1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+        Nocycle_a_2_00020_3A1 a1_main3 = new Nocycle_a_2_00020_3A1("a1_main3");
+        Nocycle_a_2_00020_3A2 a2_main = new Nocycle_a_2_00020_3A2("a2_main");
+        Nocycle_a_2_00020_3A3 a3_main = new Nocycle_a_2_00020_3A3("a3_main");
+        Nocycle_a_2_00020_3A4 a4_main = new Nocycle_a_2_00020_3A4("a4_main");
+        a1_main3.b1_0 = new Nocycle_a_2_00020_3B1("b1_0");
+        a1_main3.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a1_main3.b1_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a3_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a4_main.b3_0 = new Nocycle_a_2_00020_3B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a1_main3.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main3.b1_0.add();
+        a1_main3.d1_0.add();
+        a1_main3.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result3 = a1_main3.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main3.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main3.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+
+        int result = result1 + result2 + result3;
+        if (result == 26225)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0102-rc-function-RC_basic/RC_basic.java b/test/testsuite/ouroboros/memory_management/Function/RC0102-rc-function-RC_basic/RC_basic.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2843525581f1a0d9b38bf76d0f29e73f8d96268
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0102-rc-function-RC_basic/RC_basic.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_basic.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test RC basic operation.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_basic.java
+ *- @ExecuteClass: RC_basic
+ *- @ExecuteArgs:
+ */
+public class RC_basic {
+    private Object obj;
+    private String[] str;
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        RC_basic rc = new RC_basic();
+        rc.obj = new Object();
+        rc.str = new String[10];
+        Test1();
+        Test2();
+        Test3();
+        Test4(rc);
+        Test5(rc);
+        Test6(rc);
+        Test7(rc);
+        Test8();
+        Test9();
+        Test10();
+    }
+
+    // simple new and recycle
+    static void Test1() {
+        RC_basic obj = new RC_basic();
+        consume(obj);
+    }
+
+    // new and return
+    static RC_basic Test2() {
+        RC_basic obj = new RC_basic();
+        return obj;
+    }
+
+    // new and consume and return
+    static Object Test3() {
+        RC_basic obj = new RC_basic();
+        consume(obj);
+        return obj;
+    }
+
+    // load and dec
+    static void Test4(RC_basic rc) {
+        Object obj = rc.obj;
+        consume(obj);
+    }
+
+    // load and dec
+    static void Test5(RC_basic rc) {
+        consume(rc.obj);
+    }
+
+    // load and return
+    static Object Test6(RC_basic rc) {
+        return rc.obj;
+    }
+
+    // load consume and return
+    static Object Test7(RC_basic rc) {
+        Object o = rc.str;
+        consume(o);
+        return o;
+    }
+
+
+    // call and consume
+    static void Test8() {
+        RC_basic obj = Test2();
+        consume(obj);
+    }
+
+    // call consume and return
+    static Object Test9() {
+        RC_basic obj = Test2();
+        consume(obj);
+        return obj;
+    }
+
+    // call and not consume
+    static void Test10() {
+        Test2();
+    }
+
+    public static void consume(Object obj) {
+        //System.out.println("do noting");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0103-rc-function-RC_eh_01/RC_eh_01.java b/test/testsuite/ouroboros/memory_management/Function/RC0103-rc-function-RC_eh_01/RC_eh_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ef95451536e4a7fe233651be33801bf8c4c8cd7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0103-rc-function-RC_eh_01/RC_eh_01.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_eh_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test eh for RC.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_eh_01.java
+ *- @ExecuteClass: RC_eh_01
+ *- @ExecuteArgs:
+ */
+
+import java.nio.charset.IllegalCharsetNameException;
+
+public class RC_eh_01 {
+    static int res = 0;
+
+    public static void main(String argv[]) {
+        run1();
+        System.out.println("ExpectResult");
+    }
+
+    public static void run1() {
+
+        try {
+            new RC_eh_01().run2();
+        } catch (IllegalArgumentException e) {
+            RC_eh_01.res = 1;
+
+        }
+
+    }
+
+    public void run2() {
+        Foo f1 = new Foo(1);
+        Foo f2 = new Foo(2);
+        run3();
+        int result = f1.i + f2.i;
+
+    }
+
+    public static void run3() {
+        try {
+            Integer.parseInt("123#456");
+        } catch (IllegalCharsetNameException e) {
+            RC_eh_01.res = 3;
+
+        }
+    }
+
+    class Foo {
+        public int i;
+
+        public Foo(int i) {
+            this.i = i;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0104-rc-function-RC_Finalize_01/RC_Finalize_01.java b/test/testsuite/ouroboros/memory_management/Function/RC0104-rc-function-RC_Finalize_01/RC_Finalize_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..298a1adea63c7ecda62b88fdf168bcf84982be61
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0104-rc-function-RC_Finalize_01/RC_Finalize_01.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Finalize_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test Finalizer for RC .
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Finalize_01.java
+ *- @ExecuteClass: RC_Finalize_01
+ *- @ExecuteArgs:
+ */
+class C {
+    static A a;
+}
+
+class A {
+    B b;
+
+    public A(B b) {
+
+        this.b = b;
+
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("A finalize");
+
+        C.a = this;
+
+    }
+
+}
+
+
+class B {
+    int num1;
+    int num2;
+
+    public B(int num1, int num2) {
+        this.num1 = num1;
+        this.num2 = num2;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("B finalize");
+    }
+
+    public int sum() {
+        return num1 + num2;
+    }
+
+}
+
+public class RC_Finalize_01 {
+
+    public static void main(String[] args) throws Exception {
+        A a = new A(new B(12, 18));
+        a = null;
+        //System.gc();
+
+        Thread.sleep(5000);
+        System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0105-rc-function-RC_flow/RC_flow.java b/test/testsuite/ouroboros/memory_management/Function/RC0105-rc-function-RC_flow/RC_flow.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc251cad475d420d6e3b69715e1814b1f2f27312
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0105-rc-function-RC_flow/RC_flow.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_flow.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test RC basic operation in For flow.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_flow.java
+ *- @ExecuteClass: RC_flow
+ *- @ExecuteArgs:
+ */
+public class RC_flow {
+    private Object obj;
+    private byte[] b;
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        TestFlow1(21);
+        TestFlow2(30);
+        TestFlow3(56);
+    }
+
+    static Object TestFlow1(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = new RC_flow();
+            }
+        }
+        return rc;
+    }
+
+    static Object TestFlow2(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = Test2();
+            }
+        }
+        return rc;
+    }
+
+    static void TestFlow3(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = Test2();
+            }
+        }
+
+    }
+
+    static RC_flow Test2() {
+        RC_flow obj = new RC_flow();
+        return obj;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0106-rc-function-RC_multest/RC_multest.java b/test/testsuite/ouroboros/memory_management/Function/RC0106-rc-function-RC_multest/RC_multest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2d3a54d9f23b458bc38c8b82cf511632b5f7529
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0106-rc-function-RC_multest/RC_multest.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_multest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test RC basic operation in For flow.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_multest.java
+ *- @ExecuteClass: RC_multest
+ *- @ExecuteArgs:
+ */
+public class RC_multest {
+    static Foo f;
+    private Object obj;
+    private byte[] b;
+
+    {
+        f = new Bar();
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        TestSimple();
+        TestParam();
+        TestFlow();
+        f = null;
+    }
+
+    static void TestSimple() {
+        RC_multest rc = new RC_multest();
+        rc.obj = new Object();
+        rc.b = new byte[10];
+        Test1();
+        Test2();
+        Test3();
+        Test4(rc);
+        Test5(rc);
+        Test6(rc);
+        Test7(rc);
+        Test8();
+        Test9();
+        Test10();
+    }
+
+    static void TestParam() {
+        RC_multest rc = new RC_multest();
+        rc.obj = new Object();
+        rc.b = new byte[10];
+        TestParam1(rc);
+        TestParam2(rc);
+        TestParam3(rc);
+    }
+
+    static void TestFlow() {
+        TestFlow1(21);
+        TestFlow2(30);
+    }
+
+    // simple new and recycle
+    static void Test1() {
+        RC_multest obj = new RC_multest();
+        consume(obj);
+    }
+
+    // new and return
+    static RC_multest Test2() {
+        RC_multest obj = new RC_multest();
+        return obj;
+    }
+
+    // new and consume and return
+    static Object Test3() {
+        RC_multest obj = new RC_multest();
+        consume(obj);
+        return obj;
+    }
+
+    // load and dec
+    static void Test4(RC_multest rc) {
+        Object obj = rc.obj;
+        consume(obj);
+    }
+
+    // load and dec
+    static void Test5(RC_multest rc) {
+        consume(rc.obj);
+    }
+
+    // load and return
+    static Object Test6(RC_multest rc) {
+        return rc.obj;
+    }
+
+    // load consume and return
+    static Object Test7(RC_multest rc) {
+        Object o = rc.b;
+        consume(o);
+        return o;
+    }
+
+    // call and consume
+    static void Test8() {
+        RC_multest obj = Test2();
+        consume(obj);
+    }
+
+    // call consume and return
+    static Object Test9() {
+        RC_multest obj = Test2();
+        consume(obj);
+        return obj;
+    }
+
+    // call and not consume
+    static void Test10() {
+        Test2();
+    }
+
+    // parameter related
+    // 1. parameter is returned
+    // 2. parameter is redefined
+    // 3. parameter is redefined conditionally
+    static Object TestParam1(RC_multest rc) {
+        consume(rc);
+        return rc;
+    }
+
+    static Object TestParam2(RC_multest rc) {
+        consume(rc);
+        rc = Test2();
+        return rc;
+    }
+
+    static Object TestParam3(RC_multest rc) {
+        consume(rc);
+        if (rc.b != null) {
+            rc = Test2();
+        }
+        return rc;
+    }
+
+    static Object TestParam4() {
+        RC_multest rc = new RC_multest();
+        consume_return(rc);
+        return rc;
+    }
+
+    // object field store
+
+    // local variable
+    // 1. local varaible is redefined in if/loop
+    static Object TestFlow1(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = new RC_multest();
+            }
+        }
+        return rc;
+    }
+
+    static Object TestFlow2(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = Test2();
+            }
+        }
+        return rc;
+    }
+
+    // class info
+    // exception
+    static Object consume_return(Object obj) {
+        return obj;
+    }
+
+    static void consume(Object obj) {
+        f.consume(obj);
+    }
+}
+
+class Foo {
+    void consume(Object obj) {
+    }
+}
+
+class Bar extends Foo {
+    void consume(Object obj) {
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/Cycle_aDec_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/Cycle_aDec_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..605999cbab3a25b38d87d67c066f5046269e0d3f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/Cycle_aDec_00010.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/ Cycle_aDec_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:  Cycle_aDec_00010 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source:Cycle_aDec_00010.java
+ *- @ExecuteClass:Cycle_aDec_00010
+ *- @ExecuteArgs:
+ *
+ */
+
+class Cycle_aDec_00010_A1 {
+    Cycle_aDec_00010_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_aDec_00010_A2 {
+    Cycle_aDec_00010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_aDec_00010_A3 {
+    Cycle_aDec_00010_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_aDec_00010_A4 {
+    Cycle_aDec_00010_A1 a1_0;
+    Cycle_aDec_00010_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_aDec_00010_A5 {
+    Cycle_aDec_00010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_aDec_00010_A6 {
+    Cycle_aDec_00010_A1 a1_0;
+    Cycle_aDec_00010_A4 a4_0;
+    Cycle_aDec_00010_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A6(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a5_0.a;
+    }
+}
+
+
+public class Cycle_aDec_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void Modify(Cycle_aDec_00010_A1 a1_main) {
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_aDec_00010_A1 a1_main = new Cycle_aDec_00010_A1("a1_main");
+        Cycle_aDec_00010_A5 a5_main = new Cycle_aDec_00010_A5("a5_main");
+        a1_main.a2_0 = new Cycle_aDec_00010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_aDec_00010_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_aDec_00010_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_aDec_00010_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        Modify(a1_main);
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0 = null;
+        int result = a1_main.sum + a5_main.sum + a5_main.a3_0.sum + a5_main.a3_0.a4_0.sum + a5_main.a3_0.a4_0.a6_0.sum;
+        if (result == 1137)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/Cycle_aDec_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/Cycle_aDec_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..61448989ecb57ab888d4d400143d332163f0ab8b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/Cycle_aDec_00020.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/ Cycle_aDec_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:  Cycle_aDec_00020 in RC测试-Cycle-01
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source:  Cycle_aDec_00020.java
+ *- @ExecuteClass:  Cycle_aDec_00020
+ *- @ExecuteArgs:
+ *
+ */
+
+class Cycle_aDec_00020_A1 {
+    Cycle_aDec_00020_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Cycle_aDec_00020_A2 {
+    Cycle_aDec_00020_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_aDec_00020_A3 {
+    Cycle_aDec_00020_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_aDec_00020_A4 {
+    Cycle_aDec_00020_A1 a1_0;
+    Cycle_aDec_00020_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_aDec_00020_A5 {
+    Cycle_aDec_00020_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_aDec_00020_A6 {
+    Cycle_aDec_00020_A1 a1_0;
+    Cycle_aDec_00020_A4 a4_0;
+    Cycle_aDec_00020_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A6(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a5_0.a;
+    }
+}
+
+
+public class Cycle_aDec_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+    }
+
+    private static void Modify(Cycle_aDec_00020_A1 a1_main) {
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_aDec_00020_A1 a1_main = new Cycle_aDec_00020_A1("a1_main");
+        Cycle_aDec_00020_A5 a5_main = new Cycle_aDec_00020_A5("a5_main");
+        a1_main.a2_0 = new Cycle_aDec_00020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_aDec_00020_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_aDec_00020_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_aDec_00020_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        Modify(a1_main);
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0 = null;
+        a5_main = null;
+        a1_main.add();
+        int result = a1_main.sum;
+        if (result == 202)
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/Cycle_BDec_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/Cycle_BDec_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c15c42b9cd40c0cfa12141197580561b84f87b3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/Cycle_BDec_00010.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00010 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00010.java
+ *- @ExecuteClass: Cycle_BDec_00010
+ *- @ExecuteArgs:
+ */
+class Cycle_BDec_00010_A1 {
+    Cycle_BDec_00010_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00010_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00010_A2 {
+    Cycle_BDec_00010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00010_A2() {
+        a1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_BDec_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static boolean ModifyA1(Cycle_BDec_00010_A1 a1_0) {
+        a1_0.add();
+        a1_0.a2_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 6)
+            return true;
+        else
+            return false;
+
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00010_A1 a1_0 = new Cycle_BDec_00010_A1();
+        a1_0.a2_0 = new Cycle_BDec_00010_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        boolean ret = ModifyA1(a1_0);
+        a1_0 = null;
+        if (ret == true && a1_0 == null)
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/Cycle_BDec_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/Cycle_BDec_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..e51815af81a25250e8af1cccae2ca0a8a2fe0758
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/Cycle_BDec_00020.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00020 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00020.java
+ *- @ExecuteClass: Cycle_BDec_00020
+ *- @ExecuteArgs:
+ */
+class Cycle_BDec_00020_A1 {
+    Cycle_BDec_00020_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00020_A2 {
+    Cycle_BDec_00020_A3 a3_0;
+    Cycle_BDec_00020_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00020_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_BDec_00020_A3 {
+    Cycle_BDec_00020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00020_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_BDec_00020_A4 {
+
+    int a;
+    int sum;
+    Cycle_BDec_00020_A5 a5_0;
+
+    Cycle_BDec_00020_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        a5_0.add();
+        sum = a + a5_0.sum;
+    }
+}
+
+class Cycle_BDec_00020_A5 {
+
+    int a;
+    int sum;
+
+    Cycle_BDec_00020_A5() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+public class Cycle_BDec_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void ModifyA1(Cycle_BDec_00020_A1 a1) {
+        a1.add();
+        a1.a2_0.add();
+        a1.a2_0.a3_0.add();
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00020_A1 a1_0 = new Cycle_BDec_00020_A1();
+        a1_0.a2_0 = new Cycle_BDec_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00020_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_BDec_00020_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_BDec_00020_A5();
+        ModifyA1(a1_0);
+        a1_0.a2_0.a4_0 = null;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int result = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum;
+        if (result == 12)
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/Cycle_BDec_00030.java b/test/testsuite/ouroboros/memory_management/Function/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/Cycle_BDec_00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..153549a4ab2f10cc1305fb6c6f4e7e468d669bbd
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/Cycle_BDec_00030.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00030 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00030.java
+ *- @ExecuteClass: Cycle_BDec_00030
+ *- @ExecuteArgs:
+ */
+class Cycle_BDec_00030_A1 {
+    Cycle_BDec_00030_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00030_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00030_A2 {
+    Cycle_BDec_00030_A3 a3_0;
+    Cycle_BDec_00030_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00030_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_BDec_00030_A3 {
+    Cycle_BDec_00030_A1 a1_0;
+    Cycle_BDec_00030_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00030_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_BDec_00030_A4 {
+    Cycle_BDec_00030_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00030_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_BDec_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void ModifyA1(Cycle_BDec_00030_A1 a1) {
+        a1 = null;
+        a1 = new Cycle_BDec_00030_A1();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00030_A1 a1_0 = new Cycle_BDec_00030_A1();
+        a1_0.a2_0 = new Cycle_BDec_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00030_A3();
+        Cycle_BDec_00030_A4 a4_0 = new Cycle_BDec_00030_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        ModifyA1(a1_0);
+        a1_0 = null;
+        a4_0.add();
+        a4_0.a3_0.add();
+        int nsum = (a4_0.a3_0.sum + a4_0.sum);
+        if (nsum == 14)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/Cycle_BDec_00040.java b/test/testsuite/ouroboros/memory_management/Function/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/Cycle_BDec_00040.java
new file mode 100644
index 0000000000000000000000000000000000000000..146ad95aeffe92ebee094ae73193d17b0331596d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/Cycle_BDec_00040.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00040 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00040.java
+ *- @ExecuteClass: Cycle_BDec_00040
+ *- @ExecuteArgs:
+ */
+class Cycle_BDec_00040_A1 {
+    Cycle_BDec_00040_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00040_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00040_A2 {
+    Cycle_BDec_00040_A3 a3_0;
+    Cycle_BDec_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00040_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_BDec_00040_A3 {
+    Cycle_BDec_00040_A1 a1_0;
+    Cycle_BDec_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00040_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_BDec_00040_A4 {
+    Cycle_BDec_00040_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00040_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_BDec_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void modifyA1(Cycle_BDec_00040_A1 a1) {
+        a1.add();
+        a1.a2_0.add();
+        a1.a2_0.a3_0.add();
+        a1.a2_0.a3_0.a4_0.add();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00040_A1 a1_0 = new Cycle_BDec_00040_A1();
+        a1_0.a2_0 = new Cycle_BDec_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00040_A3();
+        Cycle_BDec_00040_A4 a4_0 = new Cycle_BDec_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        modifyA1(a1_0);
+        a1_0 = null;
+        a4_0 = null;
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/Cycle_BDec_00050.java b/test/testsuite/ouroboros/memory_management/Function/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/Cycle_BDec_00050.java
new file mode 100644
index 0000000000000000000000000000000000000000..dcd058a56baa16f9426702fcee7ed9bea135a274
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/Cycle_BDec_00050.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00050 in RC测试-Cycle-00.vsd
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00050.java
+ *- @ExecuteClass: Cycle_BDec_00050
+ *- @ExecuteArgs:
+ */
+class Cycle_BDec_00050_A1 {
+    Cycle_BDec_00050_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00050_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00050_A2 {
+    Cycle_BDec_00050_A3 a3_0;
+    Cycle_BDec_00050_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00050_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_BDec_00050_A3 {
+    Cycle_BDec_00050_A1 a1_0;
+    Cycle_BDec_00050_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00050_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_BDec_00050_A4 {
+    Cycle_BDec_00050_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00050_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_BDec_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+
+    }
+
+    private static void modifyA1(Cycle_BDec_00050_A1 a1) {
+        a1.add();
+        a1.a2_0.add();
+        a1.a2_0.a3_0.add();
+        a1.a2_0.a3_0.a4_0.add();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00050_A1 a1_0 = new Cycle_BDec_00050_A1();
+        a1_0.a2_0 = new Cycle_BDec_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00050_A3();
+        Cycle_BDec_00050_A4 a4_0 = new Cycle_BDec_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        modifyA1(a1_0);
+        //cancel inline by for flow
+        int sum = 0;
+        for (int i = 0; i < 100; i++)
+            sum += i;
+        a1_0.a2_0.a3_0.a1_0 = null;
+        a4_0.a3_0 = null;
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/Nocycle_aDec_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/Nocycle_aDec_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..114e28814398ec95ada07c394e7e2588055671e9
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/Nocycle_aDec_00010.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00010 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00010.java
+ *- @ExecuteClass: Nocycle_aDec_00010
+ *- @ExecuteArgs:
+ */
+
+
+class Nocycle_aDec_00010_A1 {
+    Nocycle_aDec_00010_B1 b1_0;
+    Nocycle_aDec_00010_B2 b2_0;
+    Nocycle_aDec_00010_B3 b3_0;
+    Nocycle_aDec_00010_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_aDec_00010_B1 {
+    Nocycle_aDec_00010_C1 c1_0;
+    Nocycle_aDec_00010_C2 c2_0;
+    Nocycle_aDec_00010_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+class Nocycle_aDec_00010_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_aDec_00010_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00010_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00010_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00010_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00010_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_aDec_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00010_A1 a1_main = new Nocycle_aDec_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_aDec_00010_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_aDec_00010_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_aDec_00010_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_aDec_00010_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_aDec_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_aDec_00010_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_aDec_00010_B4("b4_0");
+        Nocycle_aDec_00010_A1 a1_copy = modifyA1(a1_main);
+        a1_main = null;
+        a1_copy.add();
+        a1_copy.b1_0.add();
+        a1_copy.b2_0.add();
+        a1_copy.b3_0.add();
+        a1_copy.b4_0.add();
+        a1_copy.b1_0.c1_0.add();
+        a1_copy.b1_0.c2_0.add();
+        a1_copy.b1_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_copy.sum+a1_copy.b1_0.sum+a1_copy.b2_0.sum+a1_copy.b3_0.sum+a1_copy.b4_0.sum+a1_copy.b1_0.c1_0.sum+a1_copy.b1_0.c2_0.sum+a1_copy.b1_0.c3_0.sum);
+
+        int result = a1_copy.sum + a1_copy.b1_0.sum + a1_copy.b2_0.sum + a1_copy.b3_0.sum + a1_copy.b4_0.sum + a1_copy.b1_0.c1_0.sum + a1_copy.b1_0.c2_0.sum + a1_copy.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5049)
+            System.out.println("ExpectResult");
+    }
+
+    public static Nocycle_aDec_00010_A1 modifyA1(Nocycle_aDec_00010_A1 a1) {
+        a1.a = 102;
+        return a1;
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/Nocycle_aDec_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/Nocycle_aDec_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..cab859b985683df600ac3c6b239e7cb7da7166e7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/Nocycle_aDec_00020.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00020 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00020.java
+ *- @ExecuteClass: Nocycle_aDec_00020
+ *- @ExecuteArgs:
+ */
+
+class Nocycle_aDec_00020_A1 {
+    Nocycle_aDec_00020_B1 b1_0;
+    Nocycle_aDec_00020_B2 b2_0;
+    Nocycle_aDec_00020_B3 b3_0;
+    Nocycle_aDec_00020_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_aDec_00020_B1 {
+    Nocycle_aDec_00020_C1 c1_0;
+    Nocycle_aDec_00020_C2 c2_0;
+    Nocycle_aDec_00020_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+class Nocycle_aDec_00020_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+
+class Nocycle_aDec_00020_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+class Nocycle_aDec_00020_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+class Nocycle_aDec_00020_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00020_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00020_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_aDec_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00020_A1 a1_main = new Nocycle_aDec_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_aDec_00020_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_aDec_00020_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_aDec_00020_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_aDec_00020_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_aDec_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_aDec_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_aDec_00020_B4("b4_0");
+        modifyB1(a1_main.b1_0);
+        a1_main.b1_0 = null;
+        a1_main.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        int result = a1_main.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum;
+
+        if (result == 1928)
+            System.out.println("ExpectResult");
+    }
+
+    public static void modifyB1(Nocycle_aDec_00020_B1 b1) {
+        b1.a = 202;
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/Nocycle_aDec_00030.java b/test/testsuite/ouroboros/memory_management/Function/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/Nocycle_aDec_00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..8adfdd2981accb1081d724db583494a99627f6cc
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/Nocycle_aDec_00030.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00030 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00030.java
+ *- @ExecuteClass: Nocycle_aDec_00030
+ *- @ExecuteArgs:
+ */
+
+class Nocycle_aDec_00030_A1 {
+    Nocycle_aDec_00030_B1 b1_0;
+    Nocycle_aDec_00030_B2 b2_0;
+    Nocycle_aDec_00030_B3 b3_0;
+    Nocycle_aDec_00030_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_aDec_00030_B1 {
+    Nocycle_aDec_00030_C1 c1_0;
+    Nocycle_aDec_00030_C2 c2_0;
+    Nocycle_aDec_00030_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_aDec_00030_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+
+class Nocycle_aDec_00030_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+class Nocycle_aDec_00030_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+class Nocycle_aDec_00030_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00030_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00030_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_aDec_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00030_A1 a1_main = new Nocycle_aDec_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_aDec_00030_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_aDec_00030_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_aDec_00030_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_aDec_00030_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_aDec_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_aDec_00030_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_aDec_00030_B4("b4_0");
+        modifyC3(a1_main.b1_0.c3_0);
+        a1_main.b1_0.c3_0 = null;
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum;
+        if (result == 4139)
+            System.out.println("ExpectResult");
+    }
+
+    public static void modifyC3(Nocycle_aDec_00030_C3 c3) {
+        c3.a += 1;
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/Nocycle_aDec_00040.java b/test/testsuite/ouroboros/memory_management/Function/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/Nocycle_aDec_00040.java
new file mode 100644
index 0000000000000000000000000000000000000000..1267e961d597c86f680e16ada4935710e7570541
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/Nocycle_aDec_00040.java
@@ -0,0 +1,363 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00040 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00040.java
+ *- @ExecuteClass: Nocycle_aDec_00040
+ *- @ExecuteArgs:
+ */
+
+
+class Nocycle_aDec_00040_A1 {
+    Nocycle_aDec_00040_B1 b1_0;
+    Nocycle_aDec_00040_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_A2 {
+    Nocycle_aDec_00040_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_A3 {
+    Nocycle_aDec_00040_B2 b2_0;
+    Nocycle_aDec_00040_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_aDec_00040_A4 {
+    Nocycle_aDec_00040_B3 b3_0;
+    Nocycle_aDec_00040_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_B1 {
+    Nocycle_aDec_00040_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_B2 {
+    Nocycle_aDec_00040_C1 c1_0;
+    Nocycle_aDec_00040_D1 d1_0;
+    Nocycle_aDec_00040_D2 d2_0;
+    Nocycle_aDec_00040_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_B3 {
+    Nocycle_aDec_00040_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_C1 {
+    Nocycle_aDec_00040_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_aDec_00040_C2 {
+    Nocycle_aDec_00040_D2 d2_0;
+    Nocycle_aDec_00040_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00040_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00040_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_aDec_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00040_A1 a1_main = new Nocycle_aDec_00040_A1("a1_main");
+        Nocycle_aDec_00040_A2 a2_main = new Nocycle_aDec_00040_A2("a2_main");
+        Nocycle_aDec_00040_A3 a3_main = new Nocycle_aDec_00040_A3("a3_main");
+        Nocycle_aDec_00040_A4 a4_main = new Nocycle_aDec_00040_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_aDec_00040_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_aDec_00040_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_aDec_00040_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_aDec_00040_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_aDec_00040_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = new Nocycle_aDec_00040_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_aDec_00040_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a2_main.b2_0.c1_0.d1_0;
+        a3_main.b2_0.d1_0 = a2_main.b2_0.d1_0;
+        a3_main.b2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a3_main.c2_0 = new Nocycle_aDec_00040_C2("c2_0");
+        a3_main.c2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.c2_0.d3_0 = new Nocycle_aDec_00040_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_aDec_00040_B3("b3_0");
+        a4_main.b3_0.c1_0 = a3_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a3_main.b2_0.c1_0.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a3_main.c2_0.d2_0;
+        a4_main.c2_0.d3_0 = a3_main.c2_0.d3_0;
+        modifyA1(a1_main);
+        a1_main = null;
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result = a2_main.sum + a3_main.sum + a4_main.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a4_main.b3_0.c1_0.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        if (result == 7954)
+            System.out.println("ExpectResult");
+    }
+
+    private static void modifyA1(Nocycle_aDec_00040_A1 a1) {
+        a1.a += 1;
+        a1.add();
+        a1.b1_0.add();
+        a1.d1_0.add();
+        a1.b1_0.d2_0.add();
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/Nocycle_aDec_00050.java b/test/testsuite/ouroboros/memory_management/Function/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/Nocycle_aDec_00050.java
new file mode 100644
index 0000000000000000000000000000000000000000..6377bb213c0fdc344a5fafab765035a805d48182
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/Nocycle_aDec_00050.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00050 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00050.java
+ *- @ExecuteClass: Nocycle_aDec_00050
+ *- @ExecuteArgs:
+ */
+
+class Nocycle_aDec_00050_A1 {
+    Nocycle_aDec_00050_B1 b1_0;
+    Nocycle_aDec_00050_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_A2 {
+    Nocycle_aDec_00050_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_aDec_00050_A3 {
+    Nocycle_aDec_00050_B2 b2_0;
+    Nocycle_aDec_00050_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c2_0.a;
+    }
+}
+
+class Nocycle_aDec_00050_A4 {
+    Nocycle_aDec_00050_B3 b3_0;
+    Nocycle_aDec_00050_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_B1 {
+    Nocycle_aDec_00050_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_B2 {
+    Nocycle_aDec_00050_C1 c1_0;
+    Nocycle_aDec_00050_D1 d1_0;
+    Nocycle_aDec_00050_D2 d2_0;
+    Nocycle_aDec_00050_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_B3 {
+    Nocycle_aDec_00050_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_C1 {
+    Nocycle_aDec_00050_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_aDec_00050_C2 {
+    Nocycle_aDec_00050_D2 d2_0;
+    Nocycle_aDec_00050_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00050_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00050_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_aDec_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00050_A1 a1_main = new Nocycle_aDec_00050_A1("a1_main");
+        Nocycle_aDec_00050_A2 a2_main = new Nocycle_aDec_00050_A2("a2_main");
+        Nocycle_aDec_00050_A3 a3_main = new Nocycle_aDec_00050_A3("a3_main");
+        Nocycle_aDec_00050_A4 a4_main = new Nocycle_aDec_00050_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_aDec_00050_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_aDec_00050_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_aDec_00050_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_aDec_00050_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_aDec_00050_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = new Nocycle_aDec_00050_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_aDec_00050_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a2_main.b2_0.c1_0.d1_0;
+        a3_main.b2_0.d1_0 = a2_main.b2_0.d1_0;
+        a3_main.b2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a3_main.c2_0 = new Nocycle_aDec_00050_C2("c2_0");
+        a3_main.c2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.c2_0.d3_0 = new Nocycle_aDec_00050_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_aDec_00050_B3("b3_0");
+        a4_main.b3_0.c1_0 = a3_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a3_main.b2_0.c1_0.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a3_main.c2_0.d2_0;
+        a4_main.c2_0.d3_0 = a3_main.c2_0.d3_0;
+        modifyB2(a2_main.b2_0);
+        a2_main.b2_0 = null;
+        a3_main.b2_0 = null;
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a4_main.b3_0.sum + a4_main.b3_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+
+        if (result == 7249)
+            System.out.println("ExpectResult");
+    }
+
+    private static void modifyB2(Nocycle_aDec_00050_B2 b2) {
+        b2.a += 1;
+        b2.add();
+        b2.c1_0.add();
+        b2.d1_0.add();
+        b2.d2_0.add();
+        b2.d3_0.add();
+        b2.c1_0.d1_0.add();
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/Nocycle_aDec_00060.java b/test/testsuite/ouroboros/memory_management/Function/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/Nocycle_aDec_00060.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b6c5e27a54a40b2495f82d5dd819fe9b5baad1f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/Nocycle_aDec_00060.java
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00060 in RC测试-No-Cycle-00.vsd.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00060.java
+ *- @ExecuteClass: Nocycle_aDec_00060
+ *- @ExecuteArgs:
+ */
+
+
+class Nocycle_aDec_00060_A1 {
+    Nocycle_aDec_00060_B1 b1_0;
+    Nocycle_aDec_00060_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_A2 {
+    Nocycle_aDec_00060_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_A3 {
+    Nocycle_aDec_00060_B2 b2_0;
+    Nocycle_aDec_00060_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_aDec_00060_A4 {
+    Nocycle_aDec_00060_B3 b3_0;
+    Nocycle_aDec_00060_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_B1 {
+    Nocycle_aDec_00060_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_B2 {
+    Nocycle_aDec_00060_C1 c1_0;
+    Nocycle_aDec_00060_D1 d1_0;
+    Nocycle_aDec_00060_D2 d2_0;
+    Nocycle_aDec_00060_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_B3 {
+    Nocycle_aDec_00060_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_C1 {
+    Nocycle_aDec_00060_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_aDec_00060_C2 {
+    Nocycle_aDec_00060_D2 d2_0;
+    Nocycle_aDec_00060_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00060_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00060_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_aDec_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00060_A1 a1_main = new Nocycle_aDec_00060_A1("a1_main");
+        Nocycle_aDec_00060_A2 a2_main = new Nocycle_aDec_00060_A2("a2_main");
+        Nocycle_aDec_00060_A3 a3_main = new Nocycle_aDec_00060_A3("a3_main");
+        Nocycle_aDec_00060_A4 a4_main = new Nocycle_aDec_00060_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_aDec_00060_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_aDec_00060_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_aDec_00060_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_aDec_00060_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_aDec_00060_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = new Nocycle_aDec_00060_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_aDec_00060_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a2_main.b2_0.c1_0.d1_0;
+        a3_main.b2_0.d1_0 = a2_main.b2_0.d1_0;
+        a3_main.b2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a3_main.c2_0 = new Nocycle_aDec_00060_C2("c2_0");
+        a3_main.c2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.c2_0.d3_0 = new Nocycle_aDec_00060_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_aDec_00060_B3("b3_0");
+        a4_main.b3_0.c1_0 = a3_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a3_main.b2_0.c1_0.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a3_main.c2_0.d2_0;
+        a4_main.c2_0.d3_0 = a3_main.c2_0.d3_0;
+        ModifyA1(a1_main);
+        ModifyA2(a2_main);
+        ModifyA3(a3_main);
+        a4_main.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result = a4_main.sum + a4_main.b3_0.sum + a4_main.b3_0.c1_0.sum + a4_main.c2_0.sum + a4_main.b3_0.c1_0.d1_0.sum + a4_main.c2_0.d2_0.sum + a4_main.c2_0.d3_0.sum;
+
+        if (result == 5334)
+            System.out.println("ExpectResult");
+    }
+
+    private static void ModifyA1(Nocycle_aDec_00060_A1 a1) {
+        a1.a += 1;
+        a1.add();
+        a1.b1_0.add();
+        a1.d1_0.add();
+        a1.b1_0.d2_0.add();
+    }
+
+    private static void ModifyA2(Nocycle_aDec_00060_A2 a2) {
+        a2.a += 1;
+        a2.add();
+        a2.b2_0.add();
+        a2.b2_0.c1_0.add();
+        a2.b2_0.d1_0.add();
+        a2.b2_0.d2_0.add();
+        a2.b2_0.d3_0.add();
+        a2.b2_0.c1_0.d1_0.add();
+    }
+
+    private static void ModifyA3(Nocycle_aDec_00060_A3 a3) {
+        a3.a += 1;
+        a3.add();
+        a3.b2_0.add();
+        a3.b2_0.c1_0.add();
+        a3.b2_0.c1_0.d1_0.add();
+        a3.b2_0.d1_0.add();
+        a3.b2_0.d2_0.add();
+        a3.b2_0.d3_0.add();
+        a3.c2_0.add();
+        a3.c2_0.d2_0.add();
+        a3.c2_0.d3_0.add();
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0120-rc-function-RC_Thread01-Cycle_am_00180/Cycle_am_00180.java b/test/testsuite/ouroboros/memory_management/Function/RC0120-rc-function-RC_Thread01-Cycle_am_00180/Cycle_am_00180.java
new file mode 100644
index 0000000000000000000000000000000000000000..3045872cc65e59e23b7efc76f0e5d1018a4490a1
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0120-rc-function-RC_Thread01-Cycle_am_00180/Cycle_am_00180.java
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00180 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00180.java
+ *- @ExecuteClass: Cycle_am_00180
+ *- @ExecuteArgs:
+ * A1 depend A2 A8;
+ * A2 depend A3 ; A3 depend A4; A4 depend A5 ; A5 depend A6; A6 depend A1 ;
+ * A8 depend A9 ; A9 depend A7; A7 depend A4
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+108)+(102+103)+(103+104)+(104+105)+(105+106)+(106+101)+(107+104)+(108+109)+(109+107)=1994
+ *
+ */
+class ThreadRc_Cycle_am_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00180_A1 a1_main = new Cycle_a_00180_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00180_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00180_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00180_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00180_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00180_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a8_0 = new Cycle_a_00180_A8("a8_0");
+        a1_main.a8_0.a9_0 = new Cycle_a_00180_A9("a9_0");
+        a1_main.a8_0.a9_0.a7_0 = new Cycle_a_00180_A7("a7_0");
+        a1_main.a8_0.a9_0.a7_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_main.a8_0.add();
+        a1_main.a8_0.a9_0.add();
+        a1_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_main.a8_0.sum + a1_main.a8_0.a9_0.sum + a1_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1994)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00180_A1 {
+        Cycle_a_00180_A2 a2_0;
+        Cycle_a_00180_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A1(String strObjectName) {
+            a2_0 = null;
+            a8_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A2 {
+        Cycle_a_00180_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A3 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A4 {
+        Cycle_a_00180_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A5 {
+        Cycle_a_00180_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A6 {
+        Cycle_a_00180_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A6(String strObjectName) {
+            a1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A7 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A7(String strObjectName) {
+            a4_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A8 {
+        Cycle_a_00180_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A9 {
+        Cycle_a_00180_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00180 A1_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A2_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A3_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A4_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A5_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A6_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+
+        A1_Cycle_am_00180.start();
+        A2_Cycle_am_00180.start();
+        A3_Cycle_am_00180.start();
+        A4_Cycle_am_00180.start();
+        A5_Cycle_am_00180.start();
+        A6_Cycle_am_00180.start();
+
+        try {
+            A1_Cycle_am_00180.join();
+            A2_Cycle_am_00180.join();
+            A3_Cycle_am_00180.join();
+            A4_Cycle_am_00180.join();
+            A5_Cycle_am_00180.join();
+            A6_Cycle_am_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00180.check() && A2_Cycle_am_00180.check() && A3_Cycle_am_00180.check() && A4_Cycle_am_00180.check() && A5_Cycle_am_00180.check() && A6_Cycle_am_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0121-rc-function-RC_Thread01-Cycle_am_00190/Cycle_am_00190.java b/test/testsuite/ouroboros/memory_management/Function/RC0121-rc-function-RC_Thread01-Cycle_am_00190/Cycle_am_00190.java
new file mode 100644
index 0000000000000000000000000000000000000000..dadf7339284f678c11d80d809957116243ec5587
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0121-rc-function-RC_Thread01-Cycle_am_00190/Cycle_am_00190.java
@@ -0,0 +1,302 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00190 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00190.java
+ *- @ExecuteClass: Cycle_am_00190
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_am_00190 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00190_A1 a1_main = new Cycle_a_00190_A1("a1_main");
+        Cycle_a_00190_A10 a10_main = new Cycle_a_00190_A10("a10_main");
+        a1_main.a2_0 = new Cycle_a_00190_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00190_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00190_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00190_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00190_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_main;
+
+        a10_main.a8_0 = new Cycle_a_00190_A8("a8_0");
+        a10_main.a8_0.a9_0 = new Cycle_a_00190_A9("a9_0");
+        a10_main.a8_0.a9_0.a7_0 = new Cycle_a_00190_A7("a7_0");
+        a10_main.a8_0.a9_0.a7_0.a5_0 = a1_main.a2_0.a3_0.a4_0.a5_0;
+
+        a1_main.add();
+        a10_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_main.a8_0.add();
+        a10_main.a8_0.a9_0.add();
+        a10_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a10_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_main.a8_0.sum + a10_main.a8_0.a9_0.sum + a10_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2215)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00190_A1 {
+        Cycle_a_00190_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A2 {
+        Cycle_a_00190_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A3 {
+        Cycle_a_00190_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A4 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A5 {
+        Cycle_a_00190_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A6 {
+        Cycle_a_00190_A1 a1_0;
+        Cycle_a_00190_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A6(String strObjectName) {
+            a1_0 = null;
+            a10_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A7 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A7(String strObjectName) {
+            a5_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A8 {
+        Cycle_a_00190_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A9 {
+        Cycle_a_00190_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A10 {
+        Cycle_a_00190_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A10(String strObjectName) {
+            a8_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00190 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00190 A1_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A2_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A3_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A4_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A5_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A6_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+
+        A1_Cycle_am_00190.start();
+        A2_Cycle_am_00190.start();
+        A3_Cycle_am_00190.start();
+        A4_Cycle_am_00190.start();
+        A5_Cycle_am_00190.start();
+        A6_Cycle_am_00190.start();
+
+        try {
+            A1_Cycle_am_00190.join();
+            A2_Cycle_am_00190.join();
+            A3_Cycle_am_00190.join();
+            A4_Cycle_am_00190.join();
+            A5_Cycle_am_00190.join();
+            A6_Cycle_am_00190.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00190.check() && A2_Cycle_am_00190.check() && A3_Cycle_am_00190.check() && A4_Cycle_am_00190.check() && A5_Cycle_am_00190.check() && A6_Cycle_am_00190.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0122-rc-function-RC_Thread01-Cycle_am_00200/Cycle_am_00200.java b/test/testsuite/ouroboros/memory_management/Function/RC0122-rc-function-RC_Thread01-Cycle_am_00200/Cycle_am_00200.java
new file mode 100644
index 0000000000000000000000000000000000000000..185434c539b00c70c343a02d3bf9bec754da6b93
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0122-rc-function-RC_Thread01-Cycle_am_00200/Cycle_am_00200.java
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00200 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00200.java
+ *- @ExecuteClass: Cycle_am_00200
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_am_00200 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00200_A1 a1_main = new Cycle_a_00200_A1("a1_main");
+        Cycle_a_00200_A4 a4_main = new Cycle_a_00200_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00200_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00200_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00200_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a6_0 = new Cycle_a_00200_A6("a6_0");
+        a1_main.a2_0.a6_0.a7_0 = new Cycle_a_00200_A7("a7_0");
+        a1_main.a2_0.a7_0 = a1_main.a2_0.a6_0.a7_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a6_0.add();
+        a1_main.a2_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a6_0.sum + a1_main.a2_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00200_A1 {
+        Cycle_a_00200_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A2 {
+        Cycle_a_00200_A3 a3_0;
+        Cycle_a_00200_A6 a6_0;
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A2(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A3 {
+        Cycle_a_00200_A1 a1_0;
+        Cycle_a_00200_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A4 {
+        Cycle_a_00200_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A5 {
+        Cycle_a_00200_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A6 {
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Cycle_am_00200 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00200 A1_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A2_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A3_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A4_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A5_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A6_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+
+        A1_Cycle_am_00200.start();
+        A2_Cycle_am_00200.start();
+        A3_Cycle_am_00200.start();
+        A4_Cycle_am_00200.start();
+        A5_Cycle_am_00200.start();
+        A6_Cycle_am_00200.start();
+
+        try {
+            A1_Cycle_am_00200.join();
+            A2_Cycle_am_00200.join();
+            A3_Cycle_am_00200.join();
+            A4_Cycle_am_00200.join();
+            A5_Cycle_am_00200.join();
+            A6_Cycle_am_00200.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00200.check() && A2_Cycle_am_00200.check() && A3_Cycle_am_00200.check() && A4_Cycle_am_00200.check() && A5_Cycle_am_00200.check() && A6_Cycle_am_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0123-rc-function-RC_Thread01-Cycle_am_00210/Cycle_am_00210.java b/test/testsuite/ouroboros/memory_management/Function/RC0123-rc-function-RC_Thread01-Cycle_am_00210/Cycle_am_00210.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3a8bd92011490ab6931ffbe8d581fa11518e628
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0123-rc-function-RC_Thread01-Cycle_am_00210/Cycle_am_00210.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00210 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00210.java
+ *- @ExecuteClass: Cycle_am_00210
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_am_00210 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00210_A1 a1_main = new Cycle_a_00210_A1("a1_main");
+        Cycle_a_00210_A4 a4_main = new Cycle_a_00210_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00210_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00210_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00210_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00210_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0 = new Cycle_a_00210_A7("a7_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        a1_main.a2_0.a3_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a6_0.sum + a1_main.a2_0.a3_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1662)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00210_A1 {
+        Cycle_a_00210_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A2 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A3 {
+        Cycle_a_00210_A1 a1_0;
+        Cycle_a_00210_A5 a5_0;
+        Cycle_a_00210_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A4 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A5 {
+        Cycle_a_00210_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A6 {
+        Cycle_a_00210_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A7 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00210 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00210 A1_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A2_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A3_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A4_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A5_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A6_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+
+        A1_Cycle_am_00210.start();
+        A2_Cycle_am_00210.start();
+        A3_Cycle_am_00210.start();
+        A4_Cycle_am_00210.start();
+        A5_Cycle_am_00210.start();
+        A6_Cycle_am_00210.start();
+
+        try {
+            A1_Cycle_am_00210.join();
+            A2_Cycle_am_00210.join();
+            A3_Cycle_am_00210.join();
+            A4_Cycle_am_00210.join();
+            A5_Cycle_am_00210.join();
+            A6_Cycle_am_00210.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00210.check() && A2_Cycle_am_00210.check() && A3_Cycle_am_00210.check() && A4_Cycle_am_00210.check() && A5_Cycle_am_00210.check() && A6_Cycle_am_00210.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0124-rc-function-RC_Thread01-Cycle_am_00220/Cycle_am_00220.java b/test/testsuite/ouroboros/memory_management/Function/RC0124-rc-function-RC_Thread01-Cycle_am_00220/Cycle_am_00220.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c108cd500b1126c89c3b1b8a572ebf264e383f7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0124-rc-function-RC_Thread01-Cycle_am_00220/Cycle_am_00220.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00220.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00220 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00220.java
+ *- @ExecuteClass: Cycle_am_00220
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00220 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00220_A1 a1_main = new Cycle_a_00220_A1("a1_main");
+        Cycle_a_00220_A4 a4_main = new Cycle_a_00220_A4("a4_main");
+        Cycle_a_00220_A6 a6_main = new Cycle_a_00220_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00220_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00220_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00220_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_00220_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1772)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00220_A1 {
+        Cycle_a_00220_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A2 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A3 {
+        Cycle_a_00220_A1 a1_0;
+        Cycle_a_00220_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A4 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A5 {
+        Cycle_a_00220_A4 a4_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A6 {
+        Cycle_a_00220_A5 a5_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Cycle_am_00220 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00220 A1_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A2_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A3_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A4_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A5_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A6_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+
+        A1_Cycle_am_00220.start();
+        A2_Cycle_am_00220.start();
+        A3_Cycle_am_00220.start();
+        A4_Cycle_am_00220.start();
+        A5_Cycle_am_00220.start();
+        A6_Cycle_am_00220.start();
+
+        try {
+            A1_Cycle_am_00220.join();
+            A2_Cycle_am_00220.join();
+            A3_Cycle_am_00220.join();
+            A4_Cycle_am_00220.join();
+            A5_Cycle_am_00220.join();
+            A6_Cycle_am_00220.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00220.check() && A2_Cycle_am_00220.check() && A3_Cycle_am_00220.check() && A4_Cycle_am_00220.check() && A5_Cycle_am_00220.check() && A6_Cycle_am_00220.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0125-rc-function-RC_Thread01-Cycle_am_00230/Cycle_am_00230.java b/test/testsuite/ouroboros/memory_management/Function/RC0125-rc-function-RC_Thread01-Cycle_am_00230/Cycle_am_00230.java
new file mode 100644
index 0000000000000000000000000000000000000000..01938ab64326b0623a4d242a949da04687291a80
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0125-rc-function-RC_Thread01-Cycle_am_00230/Cycle_am_00230.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00230.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00230 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00230.java
+ *- @ExecuteClass: Cycle_am_00230
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00230 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00230_A1 a1_main = new Cycle_a_00230_A1("a1_main");
+        Cycle_a_00230_A5 a5_main = new Cycle_a_00230_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00230_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00230_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00230_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a7_0 = new Cycle_a_00230_A7("a7_0");
+        a5_main.a6_0 = new Cycle_a_00230_A6("a6_0");
+        a5_main.a6_0.a7_0 = a5_main.a7_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a5_main.a7_0.add();
+        a5_main.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a5_main.a6_0.sum + a5_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00230_A1 {
+        Cycle_a_00230_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A2 {
+        Cycle_a_00230_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A3 {
+        Cycle_a_00230_A1 a1_0;
+        Cycle_a_00230_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A4 {
+        Cycle_a_00230_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A5 {
+        Cycle_a_00230_A3 a3_0;
+        Cycle_a_00230_A6 a6_0;
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A5(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A6 {
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Cycle_am_00230 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00230 A1_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A2_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A3_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A4_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A5_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A6_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+
+        A1_Cycle_am_00230.start();
+        A2_Cycle_am_00230.start();
+        A3_Cycle_am_00230.start();
+        A4_Cycle_am_00230.start();
+        A5_Cycle_am_00230.start();
+        A6_Cycle_am_00230.start();
+
+        try {
+            A1_Cycle_am_00230.join();
+            A2_Cycle_am_00230.join();
+            A3_Cycle_am_00230.join();
+            A4_Cycle_am_00230.join();
+            A5_Cycle_am_00230.join();
+            A6_Cycle_am_00230.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00230.check() && A2_Cycle_am_00230.check() && A3_Cycle_am_00230.check() && A4_Cycle_am_00230.check() && A5_Cycle_am_00230.check() && A6_Cycle_am_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0126-rc-function-RC_Thread01-Cycle_am_00240/Cycle_am_00240.java b/test/testsuite/ouroboros/memory_management/Function/RC0126-rc-function-RC_Thread01-Cycle_am_00240/Cycle_am_00240.java
new file mode 100644
index 0000000000000000000000000000000000000000..8925f7b7bbe1d420b5dcb8a15385e4ad65c2e632
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0126-rc-function-RC_Thread01-Cycle_am_00240/Cycle_am_00240.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00240 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00240.java
+ *- @ExecuteClass: Cycle_am_00240
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00240 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00240_A1 a1_main = new Cycle_a_00240_A1("a1_main");
+        Cycle_a_00240_A5 a5_main = new Cycle_a_00240_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00240_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00240_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a6_0 = new Cycle_a_00240_A6("a6_0");
+        a1_main.a6_0.a7_0 = new Cycle_a_00240_A7("a7_0");
+        a1_main.a6_0.a7_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a6_0.add();
+        a1_main.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a6_0.sum + a1_main.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1660)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00240_A1 {
+        Cycle_a_00240_A2 a2_0;
+        Cycle_a_00240_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A1(String strObjectName) {
+            a2_0 = null;
+            a6_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A2 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A3 {
+        Cycle_a_00240_A1 a1_0;
+        Cycle_a_00240_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A4 {
+        Cycle_a_00240_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A5 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A6 {
+        Cycle_a_00240_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A7 {
+        Cycle_a_00240_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A7(String strObjectName) {
+            a1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00240 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00240 A1_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A2_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A3_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A4_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A5_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A6_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+
+        A1_Cycle_am_00240.start();
+        A2_Cycle_am_00240.start();
+        A3_Cycle_am_00240.start();
+        A4_Cycle_am_00240.start();
+        A5_Cycle_am_00240.start();
+        A6_Cycle_am_00240.start();
+
+        try {
+            A1_Cycle_am_00240.join();
+            A2_Cycle_am_00240.join();
+            A3_Cycle_am_00240.join();
+            A4_Cycle_am_00240.join();
+            A5_Cycle_am_00240.join();
+            A6_Cycle_am_00240.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00240.check() && A2_Cycle_am_00240.check() && A3_Cycle_am_00240.check() && A4_Cycle_am_00240.check() && A5_Cycle_am_00240.check() && A6_Cycle_am_00240.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0127-rc-function-RC_Thread01-Cycle_am_00250/Cycle_am_00250.java b/test/testsuite/ouroboros/memory_management/Function/RC0127-rc-function-RC_Thread01-Cycle_am_00250/Cycle_am_00250.java
new file mode 100644
index 0000000000000000000000000000000000000000..dbcd7e82c8afe9da3e7b10e75ea60a0d011f872f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0127-rc-function-RC_Thread01-Cycle_am_00250/Cycle_am_00250.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00250.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00250 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00250.java
+ *- @ExecuteClass: Cycle_am_00250
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00250 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00250_A1 a1_main = new Cycle_a_00250_A1("a1_main");
+        Cycle_a_00250_A6 a6_main = new Cycle_a_00250_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00250_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00250_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00250_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1238)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00250_A1 {
+        Cycle_a_00250_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A2 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A3 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A5 {
+        Cycle_a_00250_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A6 {
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00250 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00250 A1_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A2_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A3_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A4_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A5_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A6_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+
+        A1_Cycle_am_00250.start();
+        A2_Cycle_am_00250.start();
+        A3_Cycle_am_00250.start();
+        A4_Cycle_am_00250.start();
+        A5_Cycle_am_00250.start();
+        A6_Cycle_am_00250.start();
+
+        try {
+            A1_Cycle_am_00250.join();
+            A2_Cycle_am_00250.join();
+            A3_Cycle_am_00250.join();
+            A4_Cycle_am_00250.join();
+            A5_Cycle_am_00250.join();
+            A6_Cycle_am_00250.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00250.check() && A2_Cycle_am_00250.check() && A3_Cycle_am_00250.check() && A4_Cycle_am_00250.check() && A5_Cycle_am_00250.check() && A6_Cycle_am_00250.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0128-rc-function-RC_Thread01-Cycle_am_00260/Cycle_am_00260.java b/test/testsuite/ouroboros/memory_management/Function/RC0128-rc-function-RC_Thread01-Cycle_am_00260/Cycle_am_00260.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad3e8461f55ec55c72fd40beaca7c79b1768549d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0128-rc-function-RC_Thread01-Cycle_am_00260/Cycle_am_00260.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00260.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00260 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00260.java
+ *- @ExecuteClass: Cycle_am_00260
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00260 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00260_A1 a1_main = new Cycle_a_00260_A1("a1_main");
+        Cycle_a_00260_A6 a6_main = new Cycle_a_00260_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00260_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00260_A3("a3_0");
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00260_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1239)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00260_A1 {
+        Cycle_a_00260_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A2 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A3 {
+        Cycle_a_00260_A1 a1_0;
+        Cycle_a_00260_A2 a2_0;
+        Cycle_a_00260_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A5 {
+        Cycle_a_00260_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A6 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00260 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00260 A1_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A2_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A3_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A4_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A5_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A6_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+
+        A1_Cycle_am_00260.start();
+        A2_Cycle_am_00260.start();
+        A3_Cycle_am_00260.start();
+        A4_Cycle_am_00260.start();
+        A5_Cycle_am_00260.start();
+        A6_Cycle_am_00260.start();
+
+        try {
+            A1_Cycle_am_00260.join();
+            A2_Cycle_am_00260.join();
+            A3_Cycle_am_00260.join();
+            A4_Cycle_am_00260.join();
+            A5_Cycle_am_00260.join();
+            A6_Cycle_am_00260.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00260.check() && A2_Cycle_am_00260.check() && A3_Cycle_am_00260.check() && A4_Cycle_am_00260.check() && A5_Cycle_am_00260.check() && A6_Cycle_am_00260.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0129-rc-function-RC_Thread01-Cycle_am_00270/Cycle_am_00270.java b/test/testsuite/ouroboros/memory_management/Function/RC0129-rc-function-RC_Thread01-Cycle_am_00270/Cycle_am_00270.java
new file mode 100644
index 0000000000000000000000000000000000000000..87a7fd0ccffb0b72ee19b475fcb0596d0d429e7c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0129-rc-function-RC_Thread01-Cycle_am_00270/Cycle_am_00270.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00270.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00270 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00270.java
+ *- @ExecuteClass: Cycle_am_00270
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00270 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00270_A1 a1_main = new Cycle_a_00270_A1("a1_main");
+        Cycle_a_00270_A6 a6_main = new Cycle_a_00270_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00270_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00270_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00270_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1240)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00270_A1 {
+        Cycle_a_00270_A2 a2_0;
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A2 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A3 {
+        Cycle_a_00270_A1 a1_0;
+        Cycle_a_00270_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A5 {
+        Cycle_a_00270_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A6 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00270 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00270 A1_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A2_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A3_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A4_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A5_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A6_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+
+        A1_Cycle_am_00270.start();
+        A2_Cycle_am_00270.start();
+        A3_Cycle_am_00270.start();
+        A4_Cycle_am_00270.start();
+        A5_Cycle_am_00270.start();
+        A6_Cycle_am_00270.start();
+
+        try {
+            A1_Cycle_am_00270.join();
+            A2_Cycle_am_00270.join();
+            A3_Cycle_am_00270.join();
+            A4_Cycle_am_00270.join();
+            A5_Cycle_am_00270.join();
+            A6_Cycle_am_00270.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00270.check() && A2_Cycle_am_00270.check() && A3_Cycle_am_00270.check() && A4_Cycle_am_00270.check() && A5_Cycle_am_00270.check() && A6_Cycle_am_00270.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0130-rc-function-RC_Thread01-Cycle_am_00280/Cycle_am_00280.java b/test/testsuite/ouroboros/memory_management/Function/RC0130-rc-function-RC_Thread01-Cycle_am_00280/Cycle_am_00280.java
new file mode 100644
index 0000000000000000000000000000000000000000..6eeddc6afd7e8d4a2031f04ae6db45b5a1d273df
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0130-rc-function-RC_Thread01-Cycle_am_00280/Cycle_am_00280.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00280.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00280 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00280.java
+ *- @ExecuteClass: Cycle_am_00280
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00280 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1443)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00280_A1 {
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A2 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A3 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A5 {
+        Cycle_a_00280_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A6 {
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00280 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00280 A1_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A2_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A3_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A4_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A5_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A6_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+
+        A1_Cycle_am_00280.start();
+        A2_Cycle_am_00280.start();
+        A3_Cycle_am_00280.start();
+        A4_Cycle_am_00280.start();
+        A5_Cycle_am_00280.start();
+        A6_Cycle_am_00280.start();
+
+        try {
+            A1_Cycle_am_00280.join();
+            A2_Cycle_am_00280.join();
+            A3_Cycle_am_00280.join();
+            A4_Cycle_am_00280.join();
+            A5_Cycle_am_00280.join();
+            A6_Cycle_am_00280.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00280.check() && A2_Cycle_am_00280.check() && A3_Cycle_am_00280.check() && A4_Cycle_am_00280.check() && A5_Cycle_am_00280.check() && A6_Cycle_am_00280.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0131-rc-function-RC_Thread01-Cycle_am_00290/Cycle_am_00290.java b/test/testsuite/ouroboros/memory_management/Function/RC0131-rc-function-RC_Thread01-Cycle_am_00290/Cycle_am_00290.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce93a4bb03d5fdf860b0e4f3376ea87be71183fa
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0131-rc-function-RC_Thread01-Cycle_am_00290/Cycle_am_00290.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00290.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00290 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00290.java
+ *- @ExecuteClass: Cycle_am_00290
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00290 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00290_A1 a1_main = new Cycle_a_00290_A1("a1_main");
+        Cycle_a_00290_A5 a5_main = new Cycle_a_00290_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00290_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00290_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00290_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00290_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a2_0 = a1_main.a2_0;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1447)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00290_A1 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A2 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A3 {
+        Cycle_a_00290_A1 a1_0;
+        Cycle_a_00290_A4 a4_0;
+        Cycle_a_00290_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A4 {
+        Cycle_a_00290_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A5 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A6 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A6(String strObjectName) {
+            a2_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00290 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00290 A1_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A2_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A3_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A4_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A5_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A6_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+
+        A1_Cycle_am_00290.start();
+        A2_Cycle_am_00290.start();
+        A3_Cycle_am_00290.start();
+        A4_Cycle_am_00290.start();
+        A5_Cycle_am_00290.start();
+        A6_Cycle_am_00290.start();
+
+        try {
+            A1_Cycle_am_00290.join();
+            A2_Cycle_am_00290.join();
+            A3_Cycle_am_00290.join();
+            A4_Cycle_am_00290.join();
+            A5_Cycle_am_00290.join();
+            A6_Cycle_am_00290.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00290.check() && A2_Cycle_am_00290.check() && A3_Cycle_am_00290.check() && A4_Cycle_am_00290.check() && A5_Cycle_am_00290.check() && A6_Cycle_am_00290.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0132-rc-function-RC_Thread01-Cycle_am_00300/Cycle_am_00300.java b/test/testsuite/ouroboros/memory_management/Function/RC0132-rc-function-RC_Thread01-Cycle_am_00300/Cycle_am_00300.java
new file mode 100644
index 0000000000000000000000000000000000000000..3eda39abd1819a828714e491982ed97787f88e79
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0132-rc-function-RC_Thread01-Cycle_am_00300/Cycle_am_00300.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00300.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00300 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00300.java
+ *- @ExecuteClass: Cycle_am_00300
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00300 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00300_A1 a1_main = new Cycle_a_00300_A1("a1_main");
+        Cycle_a_00300_A5 a5_main = new Cycle_a_00300_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00300_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00300_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00300_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a6_0 = new Cycle_a_00300_A6("a6_0");
+        a5_main.a3_0.a4_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a5_0 = a5_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1448)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00300_A1 {
+        Cycle_a_00300_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A2 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A3 {
+        Cycle_a_00300_A1 a1_0;
+        Cycle_a_00300_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A4 {
+        Cycle_a_00300_A5 a5_0;
+        Cycle_a_00300_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A4(String strObjectName) {
+            a5_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A5 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A6 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00300 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00300 A1_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A2_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A3_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A4_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A5_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A6_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+
+        A1_Cycle_am_00300.start();
+        A2_Cycle_am_00300.start();
+        A3_Cycle_am_00300.start();
+        A4_Cycle_am_00300.start();
+        A5_Cycle_am_00300.start();
+        A6_Cycle_am_00300.start();
+
+        try {
+            A1_Cycle_am_00300.join();
+            A2_Cycle_am_00300.join();
+            A3_Cycle_am_00300.join();
+            A4_Cycle_am_00300.join();
+            A5_Cycle_am_00300.join();
+            A6_Cycle_am_00300.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00300.check() && A2_Cycle_am_00300.check() && A3_Cycle_am_00300.check() && A4_Cycle_am_00300.check() && A5_Cycle_am_00300.check() && A6_Cycle_am_00300.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0133-rc-function-RC_Thread01-Cycle_am_00310/Cycle_am_00310.java b/test/testsuite/ouroboros/memory_management/Function/RC0133-rc-function-RC_Thread01-Cycle_am_00310/Cycle_am_00310.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f8d1b516198dc105f188487d548cc690a246d60
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0133-rc-function-RC_Thread01-Cycle_am_00310/Cycle_am_00310.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00310.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00310 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00310.java
+ *- @ExecuteClass: Cycle_am_00310
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00310 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00310_A1 a1_main = new Cycle_a_00310_A1("a1_main");
+        Cycle_a_00310_A4 a4_main = new Cycle_a_00310_A4("a4_main");
+        Cycle_a_00310_A6 a6_main = new Cycle_a_00310_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00310_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00310_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00310_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a4_0 = a4_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a4_main.a6_0 = a6_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1552)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00310_A1 {
+        Cycle_a_00310_A2 a2_0;
+        Cycle_a_00310_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A2 {
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A3 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A4 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A4(String strObjectName) {
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A5 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A6 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00310 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00310 A1_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A2_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A3_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A4_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A5_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A6_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+
+        A1_Cycle_am_00310.start();
+        A2_Cycle_am_00310.start();
+        A3_Cycle_am_00310.start();
+        A4_Cycle_am_00310.start();
+        A5_Cycle_am_00310.start();
+        A6_Cycle_am_00310.start();
+
+        try {
+            A1_Cycle_am_00310.join();
+            A2_Cycle_am_00310.join();
+            A3_Cycle_am_00310.join();
+            A4_Cycle_am_00310.join();
+            A5_Cycle_am_00310.join();
+            A6_Cycle_am_00310.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00310.check() && A2_Cycle_am_00310.check() && A3_Cycle_am_00310.check() && A4_Cycle_am_00310.check() && A5_Cycle_am_00310.check() && A6_Cycle_am_00310.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0134-rc-function-RC_Thread01-Cycle_am_00320/Cycle_am_00320.java b/test/testsuite/ouroboros/memory_management/Function/RC0134-rc-function-RC_Thread01-Cycle_am_00320/Cycle_am_00320.java
new file mode 100644
index 0000000000000000000000000000000000000000..27894f42513cf69d26dfe5ec6bff2c5ff22025ab
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0134-rc-function-RC_Thread01-Cycle_am_00320/Cycle_am_00320.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00320.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00320 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00320.java
+ *- @ExecuteClass: Cycle_am_00320
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00320 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00320_A1 a1_main = new Cycle_a_00320_A1("a1_main");
+        Cycle_a_00320_A4 a4_main = new Cycle_a_00320_A4("a4_main");
+        Cycle_a_00320_A6 a6_main = new Cycle_a_00320_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00320_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00320_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00320_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a6_main.a4_0 = a4_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1551)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00320_A1 {
+        Cycle_a_00320_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A2 {
+        Cycle_a_00320_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A3 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A4 {
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A5 {
+        Cycle_a_00320_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A6 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A3 a3_0;
+        Cycle_a_00320_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00320 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00320 A1_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A2_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A3_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A4_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A5_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A6_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+
+        A1_Cycle_am_00320.start();
+        A2_Cycle_am_00320.start();
+        A3_Cycle_am_00320.start();
+        A4_Cycle_am_00320.start();
+        A5_Cycle_am_00320.start();
+        A6_Cycle_am_00320.start();
+
+        try {
+            A1_Cycle_am_00320.join();
+            A2_Cycle_am_00320.join();
+            A3_Cycle_am_00320.join();
+            A4_Cycle_am_00320.join();
+            A5_Cycle_am_00320.join();
+            A6_Cycle_am_00320.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00320.check() && A2_Cycle_am_00320.check() && A3_Cycle_am_00320.check() && A4_Cycle_am_00320.check() && A5_Cycle_am_00320.check() && A6_Cycle_am_00320.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0135-rc-function-RC_Thread01-Cycle_am_00330/Cycle_am_00330.java b/test/testsuite/ouroboros/memory_management/Function/RC0135-rc-function-RC_Thread01-Cycle_am_00330/Cycle_am_00330.java
new file mode 100644
index 0000000000000000000000000000000000000000..e618de2de8fad2bcf0930ffefd5315dbfb57ce7a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0135-rc-function-RC_Thread01-Cycle_am_00330/Cycle_am_00330.java
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00330.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00330 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00330.java
+ *- @ExecuteClass: Cycle_am_00330
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00330 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00330_A1 a1_main = new Cycle_a_00330_A1("a1_main");
+        Cycle_a_00330_A4 a4_main = new Cycle_a_00330_A4("a4_main");
+        Cycle_a_00330_A6 a6_main = new Cycle_a_00330_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00330_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00330_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00330_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00330_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00330_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2080)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00330_A1 {
+        Cycle_a_00330_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A2 {
+        Cycle_a_00330_A3 a3_0;
+        Cycle_a_00330_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A3 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A4 {
+        Cycle_a_00330_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A5 {
+        Cycle_a_00330_A6 a6_0;
+        Cycle_a_00330_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A6 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A7 {
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A8 {
+        Cycle_a_00330_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00330 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00330 A1_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A2_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A3_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A4_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A5_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A6_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+
+        A1_Cycle_am_00330.start();
+        A2_Cycle_am_00330.start();
+        A3_Cycle_am_00330.start();
+        A4_Cycle_am_00330.start();
+        A5_Cycle_am_00330.start();
+        A6_Cycle_am_00330.start();
+
+        try {
+            A1_Cycle_am_00330.join();
+            A2_Cycle_am_00330.join();
+            A3_Cycle_am_00330.join();
+            A4_Cycle_am_00330.join();
+            A5_Cycle_am_00330.join();
+            A6_Cycle_am_00330.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00330.check() && A2_Cycle_am_00330.check() && A3_Cycle_am_00330.check() && A4_Cycle_am_00330.check() && A5_Cycle_am_00330.check() && A6_Cycle_am_00330.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0136-rc-function-RC_Thread01-Cycle_am_00340/Cycle_am_00340.java b/test/testsuite/ouroboros/memory_management/Function/RC0136-rc-function-RC_Thread01-Cycle_am_00340/Cycle_am_00340.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e02db0f7e5de4a5d220cadbecb31a2fe57a6064
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0136-rc-function-RC_Thread01-Cycle_am_00340/Cycle_am_00340.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00340.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00340 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00340.java
+ *- @ExecuteClass: Cycle_am_00340
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00340 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00340_A1 a1_main = new Cycle_a_00340_A1("a1_main");
+        Cycle_a_00340_A4 a4_main = new Cycle_a_00340_A4("a4_main");
+        Cycle_a_00340_A6 a6_main = new Cycle_a_00340_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00340_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00340_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00340_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a8_0 = new Cycle_a_00340_A8("a8_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0 = new Cycle_a_00340_A7("a7_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a8_0.add();
+        a1_main.a2_0.a3_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a8_0.a7_0.sum + a6_main.a3_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00340_A1 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A2 {
+        Cycle_a_00340_A3 a3_0;
+        Cycle_a_00340_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A3 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A5 a5_0;
+        Cycle_a_00340_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a8_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A4 {
+        Cycle_a_00340_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A5 {
+        Cycle_a_00340_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A6 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A7 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A8 {
+        Cycle_a_00340_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00340 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00340 A1_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A2_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A3_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A4_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A5_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A6_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+
+        A1_Cycle_am_00340.start();
+        A2_Cycle_am_00340.start();
+        A3_Cycle_am_00340.start();
+        A4_Cycle_am_00340.start();
+        A5_Cycle_am_00340.start();
+        A6_Cycle_am_00340.start();
+
+        try {
+            A1_Cycle_am_00340.join();
+            A2_Cycle_am_00340.join();
+            A3_Cycle_am_00340.join();
+            A4_Cycle_am_00340.join();
+            A5_Cycle_am_00340.join();
+            A6_Cycle_am_00340.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00340.check() && A2_Cycle_am_00340.check() && A3_Cycle_am_00340.check() && A4_Cycle_am_00340.check() && A5_Cycle_am_00340.check() && A6_Cycle_am_00340.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0137-rc-function-RC_Thread01-Cycle_am_00350/Cycle_am_00350.java b/test/testsuite/ouroboros/memory_management/Function/RC0137-rc-function-RC_Thread01-Cycle_am_00350/Cycle_am_00350.java
new file mode 100644
index 0000000000000000000000000000000000000000..699a2c4ccc3e1d3e5087d17919d8ef99aa74d45b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0137-rc-function-RC_Thread01-Cycle_am_00350/Cycle_am_00350.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00350.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00350 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00350.java
+ *- @ExecuteClass: Cycle_am_00350
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00350 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00350_A1 a1_main = new Cycle_a_00350_A1("a1_main");
+        Cycle_a_00350_A4 a4_main = new Cycle_a_00350_A4("a4_main");
+        Cycle_a_00350_A6 a6_main = new Cycle_a_00350_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00350_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00350_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00350_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00350_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00350_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00350_A1 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A2 {
+        Cycle_a_00350_A3 a3_0;
+        Cycle_a_00350_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A3 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A4 {
+        Cycle_a_00350_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A5 {
+        Cycle_a_00350_A6 a6_0;
+        Cycle_a_00350_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A6 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A7 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A8 {
+        Cycle_a_00350_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00350 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00350 A1_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A2_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A3_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A4_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A5_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A6_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+
+        A1_Cycle_am_00350.start();
+        A2_Cycle_am_00350.start();
+        A3_Cycle_am_00350.start();
+        A4_Cycle_am_00350.start();
+        A5_Cycle_am_00350.start();
+        A6_Cycle_am_00350.start();
+
+        try {
+            A1_Cycle_am_00350.join();
+            A2_Cycle_am_00350.join();
+            A3_Cycle_am_00350.join();
+            A4_Cycle_am_00350.join();
+            A5_Cycle_am_00350.join();
+            A6_Cycle_am_00350.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00350.check() && A2_Cycle_am_00350.check() && A3_Cycle_am_00350.check() && A4_Cycle_am_00350.check() && A5_Cycle_am_00350.check() && A6_Cycle_am_00350.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0138-rc-function-RC_Thread01-Cycle_am_00360/Cycle_am_00360.java b/test/testsuite/ouroboros/memory_management/Function/RC0138-rc-function-RC_Thread01-Cycle_am_00360/Cycle_am_00360.java
new file mode 100644
index 0000000000000000000000000000000000000000..927bd67306a509b4d7586af95bcada6d25ff26e4
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0138-rc-function-RC_Thread01-Cycle_am_00360/Cycle_am_00360.java
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00360.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00360 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00360.java
+ *- @ExecuteClass: Cycle_am_00360
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00360 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00360_A1 a1_main = new Cycle_a_00360_A1("a1_main");
+        Cycle_a_00360_A4 a4_main = new Cycle_a_00360_A4("a4_main");
+        Cycle_a_00360_A6 a6_main = new Cycle_a_00360_A6("a6_main");
+        Cycle_a_00360_A9 a9_main = new Cycle_a_00360_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00360_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00360_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00360_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00360_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00360_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0.a9_0 = a9_main;
+        a9_main.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2399)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00360_A1 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A2 {
+        Cycle_a_00360_A3 a3_0;
+        Cycle_a_00360_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A3 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A4 {
+        Cycle_a_00360_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A5 {
+        Cycle_a_00360_A6 a6_0;
+        Cycle_a_00360_A8 a8_0;
+        Cycle_a_00360_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a9_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A6 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A7 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A8 {
+        Cycle_a_00360_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A9 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A9(String strObjectName) {
+            a2_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00360 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00360 A1_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A2_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A3_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A4_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A5_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A6_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+
+        A1_Cycle_am_00360.start();
+        A2_Cycle_am_00360.start();
+        A3_Cycle_am_00360.start();
+        A4_Cycle_am_00360.start();
+        A5_Cycle_am_00360.start();
+        A6_Cycle_am_00360.start();
+
+        try {
+            A1_Cycle_am_00360.join();
+            A2_Cycle_am_00360.join();
+            A3_Cycle_am_00360.join();
+            A4_Cycle_am_00360.join();
+            A5_Cycle_am_00360.join();
+            A6_Cycle_am_00360.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00360.check() && A2_Cycle_am_00360.check() && A3_Cycle_am_00360.check() && A4_Cycle_am_00360.check() && A5_Cycle_am_00360.check() && A6_Cycle_am_00360.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0139-rc-function-RC_Thread01-Cycle_am_00370/Cycle_am_00370.java b/test/testsuite/ouroboros/memory_management/Function/RC0139-rc-function-RC_Thread01-Cycle_am_00370/Cycle_am_00370.java
new file mode 100644
index 0000000000000000000000000000000000000000..158d69683ed79b69461a645c4559a91ff435076b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0139-rc-function-RC_Thread01-Cycle_am_00370/Cycle_am_00370.java
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00370.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00370 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00370.java
+ *- @ExecuteClass: Cycle_am_00370
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00370 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2623)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00370_A1 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A2 {
+        Cycle_a_00370_A3 a3_0;
+        Cycle_a_00370_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A3 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A5 a5_0;
+        Cycle_a_00370_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A4 {
+        Cycle_a_00370_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A5 {
+        Cycle_a_00370_A6 a6_0;
+        Cycle_a_00370_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A6 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A7 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A8 {
+        Cycle_a_00370_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A9 {
+        Cycle_a_00370_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A10 {
+        Cycle_a_00370_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00370 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00370 A1_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A2_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A3_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A4_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A5_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A6_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+
+        A1_Cycle_am_00370.start();
+        A2_Cycle_am_00370.start();
+        A3_Cycle_am_00370.start();
+        A4_Cycle_am_00370.start();
+        A5_Cycle_am_00370.start();
+        A6_Cycle_am_00370.start();
+
+        try {
+            A1_Cycle_am_00370.join();
+            A2_Cycle_am_00370.join();
+            A3_Cycle_am_00370.join();
+            A4_Cycle_am_00370.join();
+            A5_Cycle_am_00370.join();
+            A6_Cycle_am_00370.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00370.check() && A2_Cycle_am_00370.check() && A3_Cycle_am_00370.check() && A4_Cycle_am_00370.check() && A5_Cycle_am_00370.check() && A6_Cycle_am_00370.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0140-rc-function-RC_Thread01-Cycle_am_00380/Cycle_am_00380.java b/test/testsuite/ouroboros/memory_management/Function/RC0140-rc-function-RC_Thread01-Cycle_am_00380/Cycle_am_00380.java
new file mode 100644
index 0000000000000000000000000000000000000000..29a2cd1513b0b04db084b97228acb8b04398e8a2
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0140-rc-function-RC_Thread01-Cycle_am_00380/Cycle_am_00380.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00380.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00380 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00380.java
+ *- @ExecuteClass: Cycle_am_00380
+ *- @ExecuteArgs:
+ */
+
+
+class ThreadRc_Cycle_am_00380 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00380_A1 a1_main = new Cycle_a_00380_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00380_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00380_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00380_A1 {
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00380_A2 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00380_A3 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00380 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00380 A1_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A2_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A3_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A4_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A5_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A6_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+
+        A1_Cycle_am_00380.start();
+        A2_Cycle_am_00380.start();
+        A3_Cycle_am_00380.start();
+        A4_Cycle_am_00380.start();
+        A5_Cycle_am_00380.start();
+        A6_Cycle_am_00380.start();
+
+        try {
+            A1_Cycle_am_00380.join();
+            A2_Cycle_am_00380.join();
+            A3_Cycle_am_00380.join();
+            A4_Cycle_am_00380.join();
+            A5_Cycle_am_00380.join();
+            A6_Cycle_am_00380.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00380.check() && A2_Cycle_am_00380.check() && A3_Cycle_am_00380.check() && A4_Cycle_am_00380.check() && A5_Cycle_am_00380.check() && A6_Cycle_am_00380.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0141-rc-function-RC_Thread01-Cycle_am_00390/Cycle_am_00390.java b/test/testsuite/ouroboros/memory_management/Function/RC0141-rc-function-RC_Thread01-Cycle_am_00390/Cycle_am_00390.java
new file mode 100644
index 0000000000000000000000000000000000000000..956213557b0b33b4dadf7e0dec636b14e808c4fe
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0141-rc-function-RC_Thread01-Cycle_am_00390/Cycle_am_00390.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00390.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00390 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00390.java
+ *- @ExecuteClass: Cycle_am_00390
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00390 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00390_A1 a1_main = new Cycle_a_00390_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00390_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00390_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 918)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00390_A1 {
+        Cycle_a_00390_A2 a2_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00390_A2 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00390_A3 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00390 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00390 A1_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A2_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A3_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A4_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A5_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A6_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+
+        A1_Cycle_am_00390.start();
+        A2_Cycle_am_00390.start();
+        A3_Cycle_am_00390.start();
+        A4_Cycle_am_00390.start();
+        A5_Cycle_am_00390.start();
+        A6_Cycle_am_00390.start();
+
+        try {
+            A1_Cycle_am_00390.join();
+            A2_Cycle_am_00390.join();
+            A3_Cycle_am_00390.join();
+            A4_Cycle_am_00390.join();
+            A5_Cycle_am_00390.join();
+            A6_Cycle_am_00390.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00390.check() && A2_Cycle_am_00390.check() && A3_Cycle_am_00390.check() && A4_Cycle_am_00390.check() && A5_Cycle_am_00390.check() && A6_Cycle_am_00390.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0142-rc-function-RC_Thread01-Cycle_am_00400/Cycle_am_00400.java b/test/testsuite/ouroboros/memory_management/Function/RC0142-rc-function-RC_Thread01-Cycle_am_00400/Cycle_am_00400.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d866ba83e8587c238be7214da0c4a03514a3763
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0142-rc-function-RC_Thread01-Cycle_am_00400/Cycle_am_00400.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00400.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00400 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00400.java
+ *- @ExecuteClass: Cycle_am_00400
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00400 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00400_A1 a1_main = new Cycle_a_00400_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00400_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00400_A3("a3_0");
+        a1_main.a4_0 = new Cycle_a_00400_A4("a4_0");
+        a1_main.a4_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00400_A1 {
+        Cycle_a_00400_A2 a2_0;
+        Cycle_a_00400_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A2 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A3 {
+        Cycle_a_00400_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A4 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00400 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00400 A1_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A2_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A3_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A4_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A5_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A6_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+
+        A1_Cycle_am_00400.start();
+        A2_Cycle_am_00400.start();
+        A3_Cycle_am_00400.start();
+        A4_Cycle_am_00400.start();
+        A5_Cycle_am_00400.start();
+        A6_Cycle_am_00400.start();
+
+        try {
+            A1_Cycle_am_00400.join();
+            A2_Cycle_am_00400.join();
+            A3_Cycle_am_00400.join();
+            A4_Cycle_am_00400.join();
+            A5_Cycle_am_00400.join();
+            A6_Cycle_am_00400.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00400.check() && A2_Cycle_am_00400.check() && A3_Cycle_am_00400.check() && A4_Cycle_am_00400.check() && A5_Cycle_am_00400.check() && A6_Cycle_am_00400.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0143-rc-function-RC_Thread01-Cycle_am_00410/Cycle_am_00410.java b/test/testsuite/ouroboros/memory_management/Function/RC0143-rc-function-RC_Thread01-Cycle_am_00410/Cycle_am_00410.java
new file mode 100644
index 0000000000000000000000000000000000000000..844ff2f16fbe428f9f038bc506360064fa1f9bc2
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0143-rc-function-RC_Thread01-Cycle_am_00410/Cycle_am_00410.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00410.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00410 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00410.java
+ *- @ExecuteClass: Cycle_am_00410
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00410 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00410_A1 a1_main = new Cycle_a_00410_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00410_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00410_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00410_A4("a4_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 921)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00410_A1 {
+        Cycle_a_00410_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A2 {
+        Cycle_a_00410_A3 a3_0;
+        Cycle_a_00410_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A3 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A4 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00410 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00410 A1_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A2_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A3_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A4_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A5_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A6_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+
+        A1_Cycle_am_00410.start();
+        A2_Cycle_am_00410.start();
+        A3_Cycle_am_00410.start();
+        A4_Cycle_am_00410.start();
+        A5_Cycle_am_00410.start();
+        A6_Cycle_am_00410.start();
+
+        try {
+            A1_Cycle_am_00410.join();
+            A2_Cycle_am_00410.join();
+            A3_Cycle_am_00410.join();
+            A4_Cycle_am_00410.join();
+            A5_Cycle_am_00410.join();
+            A6_Cycle_am_00410.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00410.check() && A2_Cycle_am_00410.check() && A3_Cycle_am_00410.check() && A4_Cycle_am_00410.check() && A5_Cycle_am_00410.check() && A6_Cycle_am_00410.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0144-rc-function-RC_Thread01-Cycle_am_00420/Cycle_am_00420.java b/test/testsuite/ouroboros/memory_management/Function/RC0144-rc-function-RC_Thread01-Cycle_am_00420/Cycle_am_00420.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a3befdca86ddbcabeee0cbe639b14e9353e7bc8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0144-rc-function-RC_Thread01-Cycle_am_00420/Cycle_am_00420.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00420.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00420 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00420.java
+ *- @ExecuteClass: Cycle_am_00420
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00420 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00420_A1 a1_main = new Cycle_a_00420_A1("a1_main");
+//         Cycle_a_00420_A4 a4_main = new Cycle_a_00420_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00420_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00420_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00420_A4("a4_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00420_A1 {
+        Cycle_a_00420_A2 a2_0;
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A2 {
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A3 {
+        Cycle_a_00420_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A4 {
+        Cycle_a_00420_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00420 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00420 A1_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A2_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A3_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A4_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A5_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A6_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+
+        A1_Cycle_am_00420.start();
+        A2_Cycle_am_00420.start();
+        A3_Cycle_am_00420.start();
+        A4_Cycle_am_00420.start();
+        A5_Cycle_am_00420.start();
+        A6_Cycle_am_00420.start();
+
+        try {
+            A1_Cycle_am_00420.join();
+            A2_Cycle_am_00420.join();
+            A3_Cycle_am_00420.join();
+            A4_Cycle_am_00420.join();
+            A5_Cycle_am_00420.join();
+            A6_Cycle_am_00420.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00420.check() && A2_Cycle_am_00420.check() && A3_Cycle_am_00420.check() && A4_Cycle_am_00420.check() && A5_Cycle_am_00420.check() && A6_Cycle_am_00420.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0145-rc-function-RC_Thread01-Cycle_am_00430/Cycle_am_00430.java b/test/testsuite/ouroboros/memory_management/Function/RC0145-rc-function-RC_Thread01-Cycle_am_00430/Cycle_am_00430.java
new file mode 100644
index 0000000000000000000000000000000000000000..57e4d9dd2589a656fbef9fe721aaef0fcd3d601e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0145-rc-function-RC_Thread01-Cycle_am_00430/Cycle_am_00430.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00430.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00430 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00430.java
+ *- @ExecuteClass: Cycle_am_00430
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00430 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00430_A1 a1_main = new Cycle_a_00430_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00430_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00430_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00430_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1124)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00430_A1 {
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A2 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A3 a3_0;
+        Cycle_a_00430_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A3 {
+        Cycle_a_00430_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A4 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00430 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00430 A1_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A2_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A3_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A4_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A5_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A6_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+
+        A1_Cycle_am_00430.start();
+        A2_Cycle_am_00430.start();
+        A3_Cycle_am_00430.start();
+        A4_Cycle_am_00430.start();
+        A5_Cycle_am_00430.start();
+        A6_Cycle_am_00430.start();
+
+        try {
+            A1_Cycle_am_00430.join();
+            A2_Cycle_am_00430.join();
+            A3_Cycle_am_00430.join();
+            A4_Cycle_am_00430.join();
+            A5_Cycle_am_00430.join();
+            A6_Cycle_am_00430.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00430.check() && A2_Cycle_am_00430.check() && A3_Cycle_am_00430.check() && A4_Cycle_am_00430.check() && A5_Cycle_am_00430.check() && A6_Cycle_am_00430.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0146-rc-function-RC_Thread01-Cycle_am_00440/Cycle_am_00440.java b/test/testsuite/ouroboros/memory_management/Function/RC0146-rc-function-RC_Thread01-Cycle_am_00440/Cycle_am_00440.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4ad0aa434a3be721da1de917a3de34aa5c0158a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0146-rc-function-RC_Thread01-Cycle_am_00440/Cycle_am_00440.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00440.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00440 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00440.java
+ *- @ExecuteClass: Cycle_am_00440
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00440 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00440_A1 a1_main = new Cycle_a_00440_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00440_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00440_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00440_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1023)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00440_A1 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A2 {
+        Cycle_a_00440_A1 a1_0;
+        Cycle_a_00440_A3 a3_0;
+        Cycle_a_00440_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A3 {
+        Cycle_a_00440_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A4 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00440 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00440 A1_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A2_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A3_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A4_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A5_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A6_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+
+        A1_Cycle_am_00440.start();
+        A2_Cycle_am_00440.start();
+        A3_Cycle_am_00440.start();
+        A4_Cycle_am_00440.start();
+        A5_Cycle_am_00440.start();
+        A6_Cycle_am_00440.start();
+
+        try {
+            A1_Cycle_am_00440.join();
+            A2_Cycle_am_00440.join();
+            A3_Cycle_am_00440.join();
+            A4_Cycle_am_00440.join();
+            A5_Cycle_am_00440.join();
+            A6_Cycle_am_00440.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00440.check() && A2_Cycle_am_00440.check() && A3_Cycle_am_00440.check() && A4_Cycle_am_00440.check() && A5_Cycle_am_00440.check() && A6_Cycle_am_00440.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0147-rc-function-RC_Thread01-Cycle_am_00450/Cycle_am_00450.java b/test/testsuite/ouroboros/memory_management/Function/RC0147-rc-function-RC_Thread01-Cycle_am_00450/Cycle_am_00450.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c8c0cbc89d7d24b33740439e64c1187cd73c161
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0147-rc-function-RC_Thread01-Cycle_am_00450/Cycle_am_00450.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00450.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00450 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00450.java
+ *- @ExecuteClass: Cycle_am_00450
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00450 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00450_A1 a1_main = new Cycle_a_00450_A1("a1_main");
+        Cycle_a_00450_A6 a6_main = new Cycle_a_00450_A6("a6_main");
+        Cycle_a_00450_A7 a7_main = new Cycle_a_00450_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00450_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00450_A3("a3_0");
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00450_A5("a5_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = a7_main;
+        a7_main.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a6_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+
+        int result = a1_main.sum + a6_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1453)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00450_A1 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A2 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A3 {
+        Cycle_a_00450_A1 a1_0;
+        Cycle_a_00450_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A5 {
+        Cycle_a_00450_A6 a6_0;
+        Cycle_a_00450_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A5(String strObjectName) {
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A6 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A7 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00450 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00450 A1_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A2_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A3_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A4_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A5_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A6_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+
+        A1_Cycle_am_00450.start();
+        A2_Cycle_am_00450.start();
+        A3_Cycle_am_00450.start();
+        A4_Cycle_am_00450.start();
+        A5_Cycle_am_00450.start();
+        A6_Cycle_am_00450.start();
+
+        try {
+            A1_Cycle_am_00450.join();
+            A2_Cycle_am_00450.join();
+            A3_Cycle_am_00450.join();
+            A4_Cycle_am_00450.join();
+            A5_Cycle_am_00450.join();
+            A6_Cycle_am_00450.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00450.check() && A2_Cycle_am_00450.check() && A3_Cycle_am_00450.check() && A4_Cycle_am_00450.check() && A5_Cycle_am_00450.check() && A6_Cycle_am_00450.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0148-rc-function-RC_Thread01-Cycle_am_00460/Cycle_am_00460.java b/test/testsuite/ouroboros/memory_management/Function/RC0148-rc-function-RC_Thread01-Cycle_am_00460/Cycle_am_00460.java
new file mode 100644
index 0000000000000000000000000000000000000000..1290e77f331b1a5d10f543c8cbce6a3606678b6b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0148-rc-function-RC_Thread01-Cycle_am_00460/Cycle_am_00460.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00460.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00460 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00460.java
+ *- @ExecuteClass: Cycle_am_00460
+ *- @ExecuteArgs:
+ */
+
+
+class ThreadRc_Cycle_am_00460 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00460_A1 a1_main = new Cycle_a_00460_A1("a1_main");
+        Cycle_a_00460_A5 a5_main = new Cycle_a_00460_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00460_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00460_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00460_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00460_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00460_A1 {
+        Cycle_a_00460_A2 a2_0;
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A2 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A3 {
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A4 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A5 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A6 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A6(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00460 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00460 A1_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A2_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A3_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A4_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A5_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A6_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+
+        A1_Cycle_am_00460.start();
+        A2_Cycle_am_00460.start();
+        A3_Cycle_am_00460.start();
+        A4_Cycle_am_00460.start();
+        A5_Cycle_am_00460.start();
+        A6_Cycle_am_00460.start();
+
+        try {
+            A1_Cycle_am_00460.join();
+            A2_Cycle_am_00460.join();
+            A3_Cycle_am_00460.join();
+            A4_Cycle_am_00460.join();
+            A5_Cycle_am_00460.join();
+            A6_Cycle_am_00460.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00460.check() && A2_Cycle_am_00460.check() && A3_Cycle_am_00460.check() && A4_Cycle_am_00460.check() && A5_Cycle_am_00460.check() && A6_Cycle_am_00460.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0149-rc-function-RC_Thread01-Cycle_am_00470/Cycle_am_00470.java b/test/testsuite/ouroboros/memory_management/Function/RC0149-rc-function-RC_Thread01-Cycle_am_00470/Cycle_am_00470.java
new file mode 100644
index 0000000000000000000000000000000000000000..02ee0fb5876b2909e1ed08fe14b5ed5cdd4fd557
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0149-rc-function-RC_Thread01-Cycle_am_00470/Cycle_am_00470.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00470.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00470 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00470.java
+ *- @ExecuteClass: Cycle_am_00470
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00470 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00470_A1 a1_main = new Cycle_a_00470_A1("a1_main");
+        Cycle_a_00470_A5 a5_main = new Cycle_a_00470_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00470_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00470_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00470_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00470_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a1_0 = a1_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1446)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00470_A1 {
+        Cycle_a_00470_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A2 {
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A3 {
+        Cycle_a_00470_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A4 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A5 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A5(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A6 {
+        Cycle_a_00470_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A6(String strObjectName) {
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00470 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00470 A1_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A2_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A3_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A4_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A5_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A6_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+
+        A1_Cycle_am_00470.start();
+        A2_Cycle_am_00470.start();
+        A3_Cycle_am_00470.start();
+        A4_Cycle_am_00470.start();
+        A5_Cycle_am_00470.start();
+        A6_Cycle_am_00470.start();
+
+        try {
+            A1_Cycle_am_00470.join();
+            A2_Cycle_am_00470.join();
+            A3_Cycle_am_00470.join();
+            A4_Cycle_am_00470.join();
+            A5_Cycle_am_00470.join();
+            A6_Cycle_am_00470.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00470.check() && A2_Cycle_am_00470.check() && A3_Cycle_am_00470.check() && A4_Cycle_am_00470.check() && A5_Cycle_am_00470.check() && A6_Cycle_am_00470.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0150-rc-function-RC_Thread01-Cycle_am_00480/Cycle_am_00480.java b/test/testsuite/ouroboros/memory_management/Function/RC0150-rc-function-RC_Thread01-Cycle_am_00480/Cycle_am_00480.java
new file mode 100644
index 0000000000000000000000000000000000000000..b50183c76d511be2f5b6041c81b5e66d549d1577
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0150-rc-function-RC_Thread01-Cycle_am_00480/Cycle_am_00480.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00480.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00480 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00480.java
+ *- @ExecuteClass: Cycle_am_00480
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00480 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00480_A1 a1_main = new Cycle_a_00480_A1("a1_main");
+        Cycle_a_00480_A5 a5_main = new Cycle_a_00480_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00480_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00480_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00480_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00480_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+//         a1_main.a2_0.a3_0.a4_0.a6_0.a5_0.add();
+//         a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.add();
+//         a1_main.a2_0.a3_0.a4_0.a6_0.a1_0.add();
+
+        a5_main.a3_0.add();
+        a5_main.a3_0.a4_0.add();
+
+//         System.out.println("a1_main.sum:"+a1_main.sum);
+//         System.out.println("a4_main.sum:"+a5_main.sum);
+//         System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum);
+
+
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a5_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a1_main.a2_0.a3_0.a4_0.sum+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00480_A1 {
+        Cycle_a_00480_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A2 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A3 {
+        Cycle_a_00480_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A4 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A5 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A6 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A4 a4_0;
+        Cycle_a_00480_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A6(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a5_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00480 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00480 A1_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A2_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A3_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A4_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A5_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A6_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+
+        A1_Cycle_am_00480.start();
+        A2_Cycle_am_00480.start();
+        A3_Cycle_am_00480.start();
+        A4_Cycle_am_00480.start();
+        A5_Cycle_am_00480.start();
+        A6_Cycle_am_00480.start();
+
+        try {
+            A1_Cycle_am_00480.join();
+            A2_Cycle_am_00480.join();
+            A3_Cycle_am_00480.join();
+            A4_Cycle_am_00480.join();
+            A5_Cycle_am_00480.join();
+            A6_Cycle_am_00480.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00480.check() && A2_Cycle_am_00480.check() && A3_Cycle_am_00480.check() && A4_Cycle_am_00480.check() && A5_Cycle_am_00480.check() && A6_Cycle_am_00480.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0151-rc-function-RC_Thread01-Cycle_am_00490/Cycle_am_00490.java b/test/testsuite/ouroboros/memory_management/Function/RC0151-rc-function-RC_Thread01-Cycle_am_00490/Cycle_am_00490.java
new file mode 100644
index 0000000000000000000000000000000000000000..746297fe2c09c15ec581845d604777bf9987c375
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0151-rc-function-RC_Thread01-Cycle_am_00490/Cycle_am_00490.java
@@ -0,0 +1,310 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00490.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00490 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00490.java
+ *- @ExecuteClass: Cycle_am_00490
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_am_00490 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00490_A1 a1_main = new Cycle_a_00490_A1("a1_main");
+        Cycle_a_00490_A4 a4_main = new Cycle_a_00490_A4("a4_main");
+        Cycle_a_00490_A7 a7_main = new Cycle_a_00490_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00490_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a5_0 = new Cycle_a_00490_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00490_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+//         a4_main.a5_0.a6_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a4_main.a5_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0.a6_0.a3_0.a1_0 = a1_main;
+
+        a7_main.a9_0 = new Cycle_a_00490_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00490_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0.a8_0.a5_0 = a4_main.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a6_0.a3_0.add();
+        a4_main.a5_0.a6_0.a3_0.a1_0.add();
+
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        a7_main.a9_0.a8_0.a5_0.add();
+//
+//         System.out.println("a1_main.sum:"+a1_main.sum);
+//         System.out.println("a4_main.sum:"+a4_main.sum);
+//         System.out.println("a7_main.sum:"+a7_main.sum);
+//         System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//         System.out.println("a4_main.a5_0.sum:"+a4_main.a5_0.sum);
+//         System.out.println("a4_main.a5_0.a6_0.sum:"+a4_main.a5_0.a6_0.sum);
+//         System.out.println("a7_main.a9_0.sum:"+a7_main.a9_0.sum);
+//         System.out.println("a7_main.a9_0.a8_0.sum:"+a7_main.a9_0.a8_0.sum);
+
+
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a4_main.sum+a7_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a4_main.a5_0.sum+a4_main.a5_0.a6_0.sum+a7_main.a9_0.sum+a7_main.a9_0.a8_0.sum);
+
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2098)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00490_A1 {
+        Cycle_a_00490_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A2 {
+        Cycle_a_00490_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A3 {
+        Cycle_a_00490_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A4 {
+        Cycle_a_00490_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A5 {
+        Cycle_a_00490_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A6 {
+        Cycle_a_00490_A3 a3_0;
+        Cycle_a_00490_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A6(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A7 {
+        Cycle_a_00490_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A8 {
+        Cycle_a_00490_A5 a5_0;
+        Cycle_a_00490_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A8(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A9 {
+        Cycle_a_00490_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00490 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00490 A1_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A2_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A3_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A4_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A5_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A6_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+
+        A1_Cycle_am_00490.start();
+        A2_Cycle_am_00490.start();
+        A3_Cycle_am_00490.start();
+        A4_Cycle_am_00490.start();
+        A5_Cycle_am_00490.start();
+        A6_Cycle_am_00490.start();
+
+        try {
+            A1_Cycle_am_00490.join();
+            A2_Cycle_am_00490.join();
+            A3_Cycle_am_00490.join();
+            A4_Cycle_am_00490.join();
+            A5_Cycle_am_00490.join();
+            A6_Cycle_am_00490.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00490.check() && A2_Cycle_am_00490.check() && A3_Cycle_am_00490.check() && A4_Cycle_am_00490.check() && A5_Cycle_am_00490.check() && A6_Cycle_am_00490.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0152-rc-function-RC_Thread01-Cycle_am_00500/Cycle_am_00500.java b/test/testsuite/ouroboros/memory_management/Function/RC0152-rc-function-RC_Thread01-Cycle_am_00500/Cycle_am_00500.java
new file mode 100644
index 0000000000000000000000000000000000000000..bde9fc5e0c4e3ba46c2ea8538e81d8d6b91e1df4
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0152-rc-function-RC_Thread01-Cycle_am_00500/Cycle_am_00500.java
@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00500.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00500 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00500.java
+ *- @ExecuteClass: Cycle_am_00500
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_am_00500 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00500_A1 a1_main = new Cycle_a_00500_A1("a1_main");
+        Cycle_a_00500_A4 a4_main = new Cycle_a_00500_A4("a4_main");
+        Cycle_a_00500_A7 a7_main = new Cycle_a_00500_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00500_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00500_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00500_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00500_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+
+        a4_main.a5_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a4_main.a5_0.a8_0.a7_0 = a7_main;
+
+        a7_main.a9_0 = new Cycle_a_00500_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a8_0.add();
+        a4_main.a5_0.a8_0.a7_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+
+
+//         System.out.println("a1_main.sum:"+a1_main.sum);
+//         System.out.println("a4_main.sum:"+a4_main.sum);
+//         System.out.println("a7_main.sum:"+a7_main.sum);
+//         System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//         System.out.println("a4_main.a5_0.sum:"+a4_main.a5_0.sum);
+//         System.out.println("a4_main.a5_0.a6_0.sum:"+a4_main.a5_0.a6_0.sum);
+//         System.out.println("a7_main.a9_0.sum:"+a7_main.a9_0.sum);
+//         System.out.println("a7_main.a9_0.a8_0.sum:"+a7_main.a9_0.a8_0.sum);
+
+
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a4_main.sum+a7_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a4_main.a5_0.sum+a4_main.a5_0.a6_0.sum+a7_main.a9_0.sum+a7_main.a9_0.a8_0.sum);
+
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2099)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00500_A1 {
+        Cycle_a_00500_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A2 {
+        Cycle_a_00500_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A3 {
+        Cycle_a_00500_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A4 {
+        Cycle_a_00500_A1 a1_0;
+        Cycle_a_00500_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A4(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A5 {
+        Cycle_a_00500_A6 a6_0;
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A6 {
+        Cycle_a_00500_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A6(String strObjectName) {
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A7 {
+        Cycle_a_00500_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A8 {
+        Cycle_a_00500_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A9 {
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00500 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00500 A1_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A2_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A3_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A4_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A5_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A6_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+
+        A1_Cycle_am_00500.start();
+        A2_Cycle_am_00500.start();
+        A3_Cycle_am_00500.start();
+        A4_Cycle_am_00500.start();
+        A5_Cycle_am_00500.start();
+        A6_Cycle_am_00500.start();
+
+        try {
+            A1_Cycle_am_00500.join();
+            A2_Cycle_am_00500.join();
+            A3_Cycle_am_00500.join();
+            A4_Cycle_am_00500.join();
+            A5_Cycle_am_00500.join();
+            A6_Cycle_am_00500.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00500.check() && A2_Cycle_am_00500.check() && A3_Cycle_am_00500.check() && A4_Cycle_am_00500.check() && A5_Cycle_am_00500.check() && A6_Cycle_am_00500.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0153-rc-function-RC_Thread01-Cycle_am_00510/Cycle_am_00510.java b/test/testsuite/ouroboros/memory_management/Function/RC0153-rc-function-RC_Thread01-Cycle_am_00510/Cycle_am_00510.java
new file mode 100644
index 0000000000000000000000000000000000000000..427ef6c51109efc520fe107963dd3603093e98b3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0153-rc-function-RC_Thread01-Cycle_am_00510/Cycle_am_00510.java
@@ -0,0 +1,5650 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00510.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:make all Cycle_a_xx together to this Multi thread testcase for Performance Testing.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00510.java
+ *- @ExecuteClass: Cycle_am_00510
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_am_00180B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00180_A1 a1_main = new Cycle_a_00180_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00180_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00180_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00180_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00180_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00180_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a8_0 = new Cycle_a_00180_A8("a8_0");
+        a1_main.a8_0.a9_0 = new Cycle_a_00180_A9("a9_0");
+        a1_main.a8_0.a9_0.a7_0 = new Cycle_a_00180_A7("a7_0");
+        a1_main.a8_0.a9_0.a7_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_main.a8_0.add();
+        a1_main.a8_0.a9_0.add();
+        a1_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_main.a8_0.sum + a1_main.a8_0.a9_0.sum + a1_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1994)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00180_A1 {
+        Cycle_a_00180_A2 a2_0;
+        Cycle_a_00180_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A1(String strObjectName) {
+            a2_0 = null;
+            a8_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A2 {
+        Cycle_a_00180_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A3 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A4 {
+        Cycle_a_00180_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A5 {
+        Cycle_a_00180_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A6 {
+        Cycle_a_00180_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A6(String strObjectName) {
+            a1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A7 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A7(String strObjectName) {
+            a4_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A8 {
+        Cycle_a_00180_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A9 {
+        Cycle_a_00180_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00190B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00190_A1 a1_main = new Cycle_a_00190_A1("a1_main");
+        Cycle_a_00190_A10 a10_main = new Cycle_a_00190_A10("a10_main");
+        a1_main.a2_0 = new Cycle_a_00190_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00190_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00190_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00190_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00190_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_main;
+
+        a10_main.a8_0 = new Cycle_a_00190_A8("a8_0");
+        a10_main.a8_0.a9_0 = new Cycle_a_00190_A9("a9_0");
+        a10_main.a8_0.a9_0.a7_0 = new Cycle_a_00190_A7("a7_0");
+        a10_main.a8_0.a9_0.a7_0.a5_0 = a1_main.a2_0.a3_0.a4_0.a5_0;
+
+        a1_main.add();
+        a10_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_main.a8_0.add();
+        a10_main.a8_0.a9_0.add();
+        a10_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a10_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_main.a8_0.sum + a10_main.a8_0.a9_0.sum + a10_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2215)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00190_A1 {
+        Cycle_a_00190_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A2 {
+        Cycle_a_00190_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A3 {
+        Cycle_a_00190_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A4 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A5 {
+        Cycle_a_00190_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A6 {
+        Cycle_a_00190_A1 a1_0;
+        Cycle_a_00190_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A6(String strObjectName) {
+            a1_0 = null;
+            a10_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A7 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A7(String strObjectName) {
+            a5_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A8 {
+        Cycle_a_00190_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A9 {
+        Cycle_a_00190_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A10 {
+        Cycle_a_00190_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A10(String strObjectName) {
+            a8_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00200B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00200_A1 a1_main = new Cycle_a_00200_A1("a1_main");
+        Cycle_a_00200_A4 a4_main = new Cycle_a_00200_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00200_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00200_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00200_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a6_0 = new Cycle_a_00200_A6("a6_0");
+        a1_main.a2_0.a6_0.a7_0 = new Cycle_a_00200_A7("a7_0");
+        a1_main.a2_0.a7_0 = a1_main.a2_0.a6_0.a7_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a6_0.add();
+        a1_main.a2_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a6_0.sum + a1_main.a2_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00200_A1 {
+        Cycle_a_00200_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A2 {
+        Cycle_a_00200_A3 a3_0;
+        Cycle_a_00200_A6 a6_0;
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A2(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A3 {
+        Cycle_a_00200_A1 a1_0;
+        Cycle_a_00200_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A4 {
+        Cycle_a_00200_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A5 {
+        Cycle_a_00200_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A6 {
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00210B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00210_A1 a1_main = new Cycle_a_00210_A1("a1_main");
+        Cycle_a_00210_A4 a4_main = new Cycle_a_00210_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00210_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00210_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00210_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00210_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0 = new Cycle_a_00210_A7("a7_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        a1_main.a2_0.a3_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a6_0.sum + a1_main.a2_0.a3_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1662)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00210_A1 {
+        Cycle_a_00210_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A2 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A3 {
+        Cycle_a_00210_A1 a1_0;
+        Cycle_a_00210_A5 a5_0;
+        Cycle_a_00210_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A4 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A5 {
+        Cycle_a_00210_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A6 {
+        Cycle_a_00210_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A7 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00220B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00220_A1 a1_main = new Cycle_a_00220_A1("a1_main");
+        Cycle_a_00220_A4 a4_main = new Cycle_a_00220_A4("a4_main");
+        Cycle_a_00220_A6 a6_main = new Cycle_a_00220_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00220_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00220_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00220_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_00220_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1772)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00220_A1 {
+        Cycle_a_00220_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A2 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A3 {
+        Cycle_a_00220_A1 a1_0;
+        Cycle_a_00220_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A4 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A5 {
+        Cycle_a_00220_A4 a4_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A6 {
+        Cycle_a_00220_A5 a5_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00230B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00230_A1 a1_main = new Cycle_a_00230_A1("a1_main");
+        Cycle_a_00230_A5 a5_main = new Cycle_a_00230_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00230_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00230_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00230_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a7_0 = new Cycle_a_00230_A7("a7_0");
+        a5_main.a6_0 = new Cycle_a_00230_A6("a6_0");
+        a5_main.a6_0.a7_0 = a5_main.a7_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a5_main.a7_0.add();
+        a5_main.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a5_main.a6_0.sum + a5_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00230_A1 {
+        Cycle_a_00230_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A2 {
+        Cycle_a_00230_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A3 {
+        Cycle_a_00230_A1 a1_0;
+        Cycle_a_00230_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A4 {
+        Cycle_a_00230_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A5 {
+        Cycle_a_00230_A3 a3_0;
+        Cycle_a_00230_A6 a6_0;
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A5(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A6 {
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00240B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00240_A1 a1_main = new Cycle_a_00240_A1("a1_main");
+        Cycle_a_00240_A5 a5_main = new Cycle_a_00240_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00240_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00240_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a6_0 = new Cycle_a_00240_A6("a6_0");
+        a1_main.a6_0.a7_0 = new Cycle_a_00240_A7("a7_0");
+        a1_main.a6_0.a7_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a6_0.add();
+        a1_main.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a6_0.sum + a1_main.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1660)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00240_A1 {
+        Cycle_a_00240_A2 a2_0;
+        Cycle_a_00240_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A1(String strObjectName) {
+            a2_0 = null;
+            a6_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A2 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A3 {
+        Cycle_a_00240_A1 a1_0;
+        Cycle_a_00240_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A4 {
+        Cycle_a_00240_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A5 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A6 {
+        Cycle_a_00240_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A7 {
+        Cycle_a_00240_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A7(String strObjectName) {
+            a1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00250B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00250_A1 a1_main = new Cycle_a_00250_A1("a1_main");
+        Cycle_a_00250_A6 a6_main = new Cycle_a_00250_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00250_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00250_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00250_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1238)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00250_A1 {
+        Cycle_a_00250_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A2 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A3 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A5 {
+        Cycle_a_00250_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A6 {
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00260B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00260_A1 a1_main = new Cycle_a_00260_A1("a1_main");
+        Cycle_a_00260_A6 a6_main = new Cycle_a_00260_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00260_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00260_A3("a3_0");
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00260_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1239)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00260_A1 {
+        Cycle_a_00260_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A2 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A3 {
+        Cycle_a_00260_A1 a1_0;
+        Cycle_a_00260_A2 a2_0;
+        Cycle_a_00260_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A5 {
+        Cycle_a_00260_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A6 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00270B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00270_A1 a1_main = new Cycle_a_00270_A1("a1_main");
+        Cycle_a_00270_A6 a6_main = new Cycle_a_00270_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00270_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00270_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00270_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1240)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00270_A1 {
+        Cycle_a_00270_A2 a2_0;
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A2 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A3 {
+        Cycle_a_00270_A1 a1_0;
+        Cycle_a_00270_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A5 {
+        Cycle_a_00270_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A6 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00280B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1443)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00280_A1 {
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A2 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A3 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A5 {
+        Cycle_a_00280_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A6 {
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00290B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00290_A1 a1_main = new Cycle_a_00290_A1("a1_main");
+        Cycle_a_00290_A5 a5_main = new Cycle_a_00290_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00290_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00290_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00290_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00290_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a2_0 = a1_main.a2_0;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1447)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00290_A1 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A2 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A3 {
+        Cycle_a_00290_A1 a1_0;
+        Cycle_a_00290_A4 a4_0;
+        Cycle_a_00290_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A4 {
+        Cycle_a_00290_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A5 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A6 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A6(String strObjectName) {
+            a2_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00300B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00300_A1 a1_main = new Cycle_a_00300_A1("a1_main");
+        Cycle_a_00300_A5 a5_main = new Cycle_a_00300_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00300_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00300_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00300_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a6_0 = new Cycle_a_00300_A6("a6_0");
+        a5_main.a3_0.a4_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a5_0 = a5_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1448)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00300_A1 {
+        Cycle_a_00300_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A2 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A3 {
+        Cycle_a_00300_A1 a1_0;
+        Cycle_a_00300_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A4 {
+        Cycle_a_00300_A5 a5_0;
+        Cycle_a_00300_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A4(String strObjectName) {
+            a5_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A5 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A6 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00310B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00310_A1 a1_main = new Cycle_a_00310_A1("a1_main");
+        Cycle_a_00310_A4 a4_main = new Cycle_a_00310_A4("a4_main");
+        Cycle_a_00310_A6 a6_main = new Cycle_a_00310_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00310_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00310_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00310_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a4_0 = a4_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a4_main.a6_0 = a6_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1552)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00310_A1 {
+        Cycle_a_00310_A2 a2_0;
+        Cycle_a_00310_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A2 {
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A3 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A4 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A4(String strObjectName) {
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A5 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A6 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00320B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00320_A1 a1_main = new Cycle_a_00320_A1("a1_main");
+        Cycle_a_00320_A4 a4_main = new Cycle_a_00320_A4("a4_main");
+        Cycle_a_00320_A6 a6_main = new Cycle_a_00320_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00320_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00320_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00320_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a6_main.a4_0 = a4_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1551)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00320_A1 {
+        Cycle_a_00320_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A2 {
+        Cycle_a_00320_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A3 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A4 {
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A5 {
+        Cycle_a_00320_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A6 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A3 a3_0;
+        Cycle_a_00320_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00330B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00330_A1 a1_main = new Cycle_a_00330_A1("a1_main");
+        Cycle_a_00330_A4 a4_main = new Cycle_a_00330_A4("a4_main");
+        Cycle_a_00330_A6 a6_main = new Cycle_a_00330_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00330_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00330_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00330_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00330_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00330_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2080)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00330_A1 {
+        Cycle_a_00330_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A2 {
+        Cycle_a_00330_A3 a3_0;
+        Cycle_a_00330_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A3 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A4 {
+        Cycle_a_00330_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A5 {
+        Cycle_a_00330_A6 a6_0;
+        Cycle_a_00330_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A6 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A7 {
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A8 {
+        Cycle_a_00330_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00340B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00340_A1 a1_main = new Cycle_a_00340_A1("a1_main");
+        Cycle_a_00340_A4 a4_main = new Cycle_a_00340_A4("a4_main");
+        Cycle_a_00340_A6 a6_main = new Cycle_a_00340_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00340_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00340_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00340_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a8_0 = new Cycle_a_00340_A8("a8_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0 = new Cycle_a_00340_A7("a7_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a8_0.add();
+        a1_main.a2_0.a3_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a8_0.a7_0.sum + a6_main.a3_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00340_A1 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A2 {
+        Cycle_a_00340_A3 a3_0;
+        Cycle_a_00340_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A3 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A5 a5_0;
+        Cycle_a_00340_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a8_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A4 {
+        Cycle_a_00340_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A5 {
+        Cycle_a_00340_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A6 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A7 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A8 {
+        Cycle_a_00340_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00350B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00350_A1 a1_main = new Cycle_a_00350_A1("a1_main");
+        Cycle_a_00350_A4 a4_main = new Cycle_a_00350_A4("a4_main");
+        Cycle_a_00350_A6 a6_main = new Cycle_a_00350_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00350_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00350_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00350_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00350_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00350_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00350_A1 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A2 {
+        Cycle_a_00350_A3 a3_0;
+        Cycle_a_00350_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A3 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A4 {
+        Cycle_a_00350_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A5 {
+        Cycle_a_00350_A6 a6_0;
+        Cycle_a_00350_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A6 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A7 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A8 {
+        Cycle_a_00350_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00360B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00360_A1 a1_main = new Cycle_a_00360_A1("a1_main");
+        Cycle_a_00360_A4 a4_main = new Cycle_a_00360_A4("a4_main");
+        Cycle_a_00360_A6 a6_main = new Cycle_a_00360_A6("a6_main");
+        Cycle_a_00360_A9 a9_main = new Cycle_a_00360_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00360_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00360_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00360_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00360_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00360_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0.a9_0 = a9_main;
+        a9_main.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2399)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00360_A1 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A2 {
+        Cycle_a_00360_A3 a3_0;
+        Cycle_a_00360_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A3 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A4 {
+        Cycle_a_00360_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A5 {
+        Cycle_a_00360_A6 a6_0;
+        Cycle_a_00360_A8 a8_0;
+        Cycle_a_00360_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a9_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A6 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A7 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A8 {
+        Cycle_a_00360_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A9 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A9(String strObjectName) {
+            a2_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00370B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2623)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00370_A1 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A2 {
+        Cycle_a_00370_A3 a3_0;
+        Cycle_a_00370_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A3 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A5 a5_0;
+        Cycle_a_00370_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A4 {
+        Cycle_a_00370_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A5 {
+        Cycle_a_00370_A6 a6_0;
+        Cycle_a_00370_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A6 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A7 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A8 {
+        Cycle_a_00370_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A9 {
+        Cycle_a_00370_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A10 {
+        Cycle_a_00370_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00380B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00380_A1 a1_main = new Cycle_a_00380_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00380_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00380_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00380_A1 {
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00380_A2 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00380_A3 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00390B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00390_A1 a1_main = new Cycle_a_00390_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00390_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00390_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 918)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00390_A1 {
+        Cycle_a_00390_A2 a2_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00390_A2 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00390_A3 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00400B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00400_A1 a1_main = new Cycle_a_00400_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00400_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00400_A3("a3_0");
+        a1_main.a4_0 = new Cycle_a_00400_A4("a4_0");
+        a1_main.a4_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00400_A1 {
+        Cycle_a_00400_A2 a2_0;
+        Cycle_a_00400_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A2 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A3 {
+        Cycle_a_00400_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A4 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00410B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00410_A1 a1_main = new Cycle_a_00410_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00410_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00410_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00410_A4("a4_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 921)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00410_A1 {
+        Cycle_a_00410_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A2 {
+        Cycle_a_00410_A3 a3_0;
+        Cycle_a_00410_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A3 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A4 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00420B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00420_A1 a1_main = new Cycle_a_00420_A1("a1_main");
+//         Cycle_a_00420_A4 a4_main = new Cycle_a_00420_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00420_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00420_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00420_A4("a4_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00420_A1 {
+        Cycle_a_00420_A2 a2_0;
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A2 {
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A3 {
+        Cycle_a_00420_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A4 {
+        Cycle_a_00420_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00430B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00430_A1 a1_main = new Cycle_a_00430_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00430_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00430_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00430_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1124)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00430_A1 {
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A2 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A3 a3_0;
+        Cycle_a_00430_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A3 {
+        Cycle_a_00430_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A4 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00440B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00440_A1 a1_main = new Cycle_a_00440_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00440_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00440_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00440_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1023)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00440_A1 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A2 {
+        Cycle_a_00440_A1 a1_0;
+        Cycle_a_00440_A3 a3_0;
+        Cycle_a_00440_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A3 {
+        Cycle_a_00440_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A4 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00450B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00450_A1 a1_main = new Cycle_a_00450_A1("a1_main");
+        Cycle_a_00450_A6 a6_main = new Cycle_a_00450_A6("a6_main");
+        Cycle_a_00450_A7 a7_main = new Cycle_a_00450_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00450_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00450_A3("a3_0");
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00450_A5("a5_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = a7_main;
+        a7_main.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a6_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+
+        int result = a1_main.sum + a6_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1453)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00450_A1 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A2 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A3 {
+        Cycle_a_00450_A1 a1_0;
+        Cycle_a_00450_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A5 {
+        Cycle_a_00450_A6 a6_0;
+        Cycle_a_00450_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A5(String strObjectName) {
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A6 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A7 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00460B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00460_A1 a1_main = new Cycle_a_00460_A1("a1_main");
+        Cycle_a_00460_A5 a5_main = new Cycle_a_00460_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00460_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00460_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00460_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00460_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00460_A1 {
+        Cycle_a_00460_A2 a2_0;
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A2 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A3 {
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A4 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A5 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A6 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A6(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00470B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00470_A1 a1_main = new Cycle_a_00470_A1("a1_main");
+        Cycle_a_00470_A5 a5_main = new Cycle_a_00470_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00470_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00470_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00470_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00470_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a1_0 = a1_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1446)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00470_A1 {
+        Cycle_a_00470_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A2 {
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A3 {
+        Cycle_a_00470_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A4 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A5 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A5(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A6 {
+        Cycle_a_00470_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A6(String strObjectName) {
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00480B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00480_A1 a1_main = new Cycle_a_00480_A1("a1_main");
+        Cycle_a_00480_A5 a5_main = new Cycle_a_00480_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00480_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00480_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00480_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00480_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+//         a1_main.a2_0.a3_0.a4_0.a6_0.a5_0.add();
+//         a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.add();
+//         a1_main.a2_0.a3_0.a4_0.a6_0.a1_0.add();
+
+        a5_main.a3_0.add();
+        a5_main.a3_0.a4_0.add();
+
+//         System.out.println("a1_main.sum:"+a1_main.sum);
+//         System.out.println("a4_main.sum:"+a5_main.sum);
+//         System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum);
+
+
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a5_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a1_main.a2_0.a3_0.a4_0.sum+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00480_A1 {
+        Cycle_a_00480_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A2 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A3 {
+        Cycle_a_00480_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A4 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A5 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A6 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A4 a4_0;
+        Cycle_a_00480_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A6(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a5_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00490B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00490_A1 a1_main = new Cycle_a_00490_A1("a1_main");
+        Cycle_a_00490_A4 a4_main = new Cycle_a_00490_A4("a4_main");
+        Cycle_a_00490_A7 a7_main = new Cycle_a_00490_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00490_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a5_0 = new Cycle_a_00490_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00490_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+//         a4_main.a5_0.a6_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a4_main.a5_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0.a6_0.a3_0.a1_0 = a1_main;
+
+        a7_main.a9_0 = new Cycle_a_00490_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00490_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0.a8_0.a5_0 = a4_main.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a6_0.a3_0.add();
+        a4_main.a5_0.a6_0.a3_0.a1_0.add();
+
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        a7_main.a9_0.a8_0.a5_0.add();
+//
+//         System.out.println("a1_main.sum:"+a1_main.sum);
+//         System.out.println("a4_main.sum:"+a4_main.sum);
+//         System.out.println("a7_main.sum:"+a7_main.sum);
+//         System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//         System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//         System.out.println("a4_main.a5_0.sum:"+a4_main.a5_0.sum);
+//         System.out.println("a4_main.a5_0.a6_0.sum:"+a4_main.a5_0.a6_0.sum);
+//         System.out.println("a7_main.a9_0.sum:"+a7_main.a9_0.sum);
+//         System.out.println("a7_main.a9_0.a8_0.sum:"+a7_main.a9_0.a8_0.sum);
+
+
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a4_main.sum+a7_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a4_main.a5_0.sum+a4_main.a5_0.a6_0.sum+a7_main.a9_0.sum+a7_main.a9_0.a8_0.sum);
+
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2098)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00490_A1 {
+        Cycle_a_00490_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A2 {
+        Cycle_a_00490_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A3 {
+        Cycle_a_00490_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A4 {
+        Cycle_a_00490_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A5 {
+        Cycle_a_00490_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A6 {
+        Cycle_a_00490_A3 a3_0;
+        Cycle_a_00490_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A6(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A7 {
+        Cycle_a_00490_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A8 {
+        Cycle_a_00490_A5 a5_0;
+        Cycle_a_00490_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A8(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A9 {
+        Cycle_a_00490_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00500B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00500_A1 a1_main = new Cycle_a_00500_A1("a1_main");
+        Cycle_a_00500_A4 a4_main = new Cycle_a_00500_A4("a4_main");
+        Cycle_a_00500_A7 a7_main = new Cycle_a_00500_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00500_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00500_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00500_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00500_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+
+        a4_main.a5_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a4_main.a5_0.a8_0.a7_0 = a7_main;
+
+        a7_main.a9_0 = new Cycle_a_00500_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a8_0.add();
+        a4_main.a5_0.a8_0.a7_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2099)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00500_A1 {
+        Cycle_a_00500_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A2 {
+        Cycle_a_00500_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A3 {
+        Cycle_a_00500_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A4 {
+        Cycle_a_00500_A1 a1_0;
+        Cycle_a_00500_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A4(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A5 {
+        Cycle_a_00500_A6 a6_0;
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A6 {
+        Cycle_a_00500_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A6(String strObjectName) {
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A7 {
+        Cycle_a_00500_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A8 {
+        Cycle_a_00500_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A9 {
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+public class Cycle_am_00510 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00180B A1_Cycle_am_00180 = new ThreadRc_Cycle_am_00180B();
+        ThreadRc_Cycle_am_00180B A2_Cycle_am_00180 = new ThreadRc_Cycle_am_00180B();
+        ThreadRc_Cycle_am_00190B A1_Cycle_am_00190 = new ThreadRc_Cycle_am_00190B();
+        ThreadRc_Cycle_am_00190B A2_Cycle_am_00190 = new ThreadRc_Cycle_am_00190B();
+        ThreadRc_Cycle_am_00200B A1_Cycle_am_00200 = new ThreadRc_Cycle_am_00200B();
+        ThreadRc_Cycle_am_00200B A2_Cycle_am_00200 = new ThreadRc_Cycle_am_00200B();
+        ThreadRc_Cycle_am_00210B A1_Cycle_am_00210 = new ThreadRc_Cycle_am_00210B();
+        ThreadRc_Cycle_am_00210B A2_Cycle_am_00210 = new ThreadRc_Cycle_am_00210B();
+        ThreadRc_Cycle_am_00220B A1_Cycle_am_00220 = new ThreadRc_Cycle_am_00220B();
+        ThreadRc_Cycle_am_00220B A2_Cycle_am_00220 = new ThreadRc_Cycle_am_00220B();
+        ThreadRc_Cycle_am_00230B A1_Cycle_am_00230 = new ThreadRc_Cycle_am_00230B();
+        ThreadRc_Cycle_am_00230B A2_Cycle_am_00230 = new ThreadRc_Cycle_am_00230B();
+        ThreadRc_Cycle_am_00240B A1_Cycle_am_00240 = new ThreadRc_Cycle_am_00240B();
+        ThreadRc_Cycle_am_00240B A2_Cycle_am_00240 = new ThreadRc_Cycle_am_00240B();
+        ThreadRc_Cycle_am_00250B A1_Cycle_am_00250 = new ThreadRc_Cycle_am_00250B();
+        ThreadRc_Cycle_am_00250B A2_Cycle_am_00250 = new ThreadRc_Cycle_am_00250B();
+        ThreadRc_Cycle_am_00260B A1_Cycle_am_00260 = new ThreadRc_Cycle_am_00260B();
+        ThreadRc_Cycle_am_00260B A2_Cycle_am_00260 = new ThreadRc_Cycle_am_00260B();
+        ThreadRc_Cycle_am_00270B A1_Cycle_am_00270 = new ThreadRc_Cycle_am_00270B();
+        ThreadRc_Cycle_am_00270B A2_Cycle_am_00270 = new ThreadRc_Cycle_am_00270B();
+        ThreadRc_Cycle_am_00280B A1_Cycle_am_00280 = new ThreadRc_Cycle_am_00280B();
+        ThreadRc_Cycle_am_00280B A2_Cycle_am_00280 = new ThreadRc_Cycle_am_00280B();
+        ThreadRc_Cycle_am_00290B A1_Cycle_am_00290 = new ThreadRc_Cycle_am_00290B();
+        ThreadRc_Cycle_am_00290B A2_Cycle_am_00290 = new ThreadRc_Cycle_am_00290B();
+        ThreadRc_Cycle_am_00300B A1_Cycle_am_00300 = new ThreadRc_Cycle_am_00300B();
+        ThreadRc_Cycle_am_00300B A2_Cycle_am_00300 = new ThreadRc_Cycle_am_00300B();
+        ThreadRc_Cycle_am_00310B A1_Cycle_am_00310 = new ThreadRc_Cycle_am_00310B();
+        ThreadRc_Cycle_am_00310B A2_Cycle_am_00310 = new ThreadRc_Cycle_am_00310B();
+        ThreadRc_Cycle_am_00320B A1_Cycle_am_00320 = new ThreadRc_Cycle_am_00320B();
+        ThreadRc_Cycle_am_00320B A2_Cycle_am_00320 = new ThreadRc_Cycle_am_00320B();
+        ThreadRc_Cycle_am_00330B A1_Cycle_am_00330 = new ThreadRc_Cycle_am_00330B();
+        ThreadRc_Cycle_am_00330B A2_Cycle_am_00330 = new ThreadRc_Cycle_am_00330B();
+        ThreadRc_Cycle_am_00340B A1_Cycle_am_00340 = new ThreadRc_Cycle_am_00340B();
+        ThreadRc_Cycle_am_00340B A2_Cycle_am_00340 = new ThreadRc_Cycle_am_00340B();
+        ThreadRc_Cycle_am_00350B A1_Cycle_am_00350 = new ThreadRc_Cycle_am_00350B();
+        ThreadRc_Cycle_am_00350B A2_Cycle_am_00350 = new ThreadRc_Cycle_am_00350B();
+        ThreadRc_Cycle_am_00360B A1_Cycle_am_00360 = new ThreadRc_Cycle_am_00360B();
+        ThreadRc_Cycle_am_00360B A2_Cycle_am_00360 = new ThreadRc_Cycle_am_00360B();
+        ThreadRc_Cycle_am_00370B A1_Cycle_am_00370 = new ThreadRc_Cycle_am_00370B();
+        ThreadRc_Cycle_am_00370B A2_Cycle_am_00370 = new ThreadRc_Cycle_am_00370B();
+        ThreadRc_Cycle_am_00380B A1_Cycle_am_00380 = new ThreadRc_Cycle_am_00380B();
+        ThreadRc_Cycle_am_00380B A2_Cycle_am_00380 = new ThreadRc_Cycle_am_00380B();
+        ThreadRc_Cycle_am_00390B A1_Cycle_am_00390 = new ThreadRc_Cycle_am_00390B();
+        ThreadRc_Cycle_am_00390B A2_Cycle_am_00390 = new ThreadRc_Cycle_am_00390B();
+        ThreadRc_Cycle_am_00400B A1_Cycle_am_00400 = new ThreadRc_Cycle_am_00400B();
+        ThreadRc_Cycle_am_00400B A2_Cycle_am_00400 = new ThreadRc_Cycle_am_00400B();
+        ThreadRc_Cycle_am_00410B A1_Cycle_am_00410 = new ThreadRc_Cycle_am_00410B();
+        ThreadRc_Cycle_am_00410B A2_Cycle_am_00410 = new ThreadRc_Cycle_am_00410B();
+        ThreadRc_Cycle_am_00420B A1_Cycle_am_00420 = new ThreadRc_Cycle_am_00420B();
+        ThreadRc_Cycle_am_00420B A2_Cycle_am_00420 = new ThreadRc_Cycle_am_00420B();
+        ThreadRc_Cycle_am_00430B A1_Cycle_am_00430 = new ThreadRc_Cycle_am_00430B();
+        ThreadRc_Cycle_am_00430B A2_Cycle_am_00430 = new ThreadRc_Cycle_am_00430B();
+        ThreadRc_Cycle_am_00440B A1_Cycle_am_00440 = new ThreadRc_Cycle_am_00440B();
+        ThreadRc_Cycle_am_00440B A2_Cycle_am_00440 = new ThreadRc_Cycle_am_00440B();
+        ThreadRc_Cycle_am_00450B A1_Cycle_am_00450 = new ThreadRc_Cycle_am_00450B();
+        ThreadRc_Cycle_am_00450B A2_Cycle_am_00450 = new ThreadRc_Cycle_am_00450B();
+        ThreadRc_Cycle_am_00460B A1_Cycle_am_00460 = new ThreadRc_Cycle_am_00460B();
+        ThreadRc_Cycle_am_00460B A2_Cycle_am_00460 = new ThreadRc_Cycle_am_00460B();
+        ThreadRc_Cycle_am_00470B A1_Cycle_am_00470 = new ThreadRc_Cycle_am_00470B();
+        ThreadRc_Cycle_am_00470B A2_Cycle_am_00470 = new ThreadRc_Cycle_am_00470B();
+        ThreadRc_Cycle_am_00480B A1_Cycle_am_00480 = new ThreadRc_Cycle_am_00480B();
+        ThreadRc_Cycle_am_00480B A2_Cycle_am_00480 = new ThreadRc_Cycle_am_00480B();
+        ThreadRc_Cycle_am_00490B A1_Cycle_am_00490 = new ThreadRc_Cycle_am_00490B();
+        ThreadRc_Cycle_am_00490B A2_Cycle_am_00490 = new ThreadRc_Cycle_am_00490B();
+        ThreadRc_Cycle_am_00500B A1_Cycle_am_00500 = new ThreadRc_Cycle_am_00500B();
+        ThreadRc_Cycle_am_00500B A2_Cycle_am_00500 = new ThreadRc_Cycle_am_00500B();
+        A1_Cycle_am_00180.start();
+        A2_Cycle_am_00180.start();
+        A1_Cycle_am_00190.start();
+        A2_Cycle_am_00190.start();
+        A1_Cycle_am_00200.start();
+        A2_Cycle_am_00200.start();
+        A1_Cycle_am_00210.start();
+        A2_Cycle_am_00210.start();
+        A1_Cycle_am_00220.start();
+        A2_Cycle_am_00220.start();
+        A1_Cycle_am_00230.start();
+        A2_Cycle_am_00230.start();
+        A1_Cycle_am_00240.start();
+        A2_Cycle_am_00240.start();
+        A1_Cycle_am_00250.start();
+        A2_Cycle_am_00250.start();
+        A1_Cycle_am_00260.start();
+        A2_Cycle_am_00260.start();
+        A1_Cycle_am_00270.start();
+        A2_Cycle_am_00270.start();
+        A1_Cycle_am_00280.start();
+        A2_Cycle_am_00280.start();
+        A1_Cycle_am_00290.start();
+        A2_Cycle_am_00290.start();
+        A1_Cycle_am_00300.start();
+        A2_Cycle_am_00300.start();
+        A1_Cycle_am_00310.start();
+        A2_Cycle_am_00310.start();
+        A1_Cycle_am_00320.start();
+        A2_Cycle_am_00320.start();
+        A1_Cycle_am_00330.start();
+        A2_Cycle_am_00330.start();
+        A1_Cycle_am_00340.start();
+        A2_Cycle_am_00340.start();
+        A1_Cycle_am_00350.start();
+        A2_Cycle_am_00350.start();
+        A1_Cycle_am_00360.start();
+        A2_Cycle_am_00360.start();
+        A1_Cycle_am_00370.start();
+        A2_Cycle_am_00370.start();
+        A1_Cycle_am_00380.start();
+        A2_Cycle_am_00380.start();
+        A1_Cycle_am_00390.start();
+        A2_Cycle_am_00390.start();
+        A1_Cycle_am_00400.start();
+        A2_Cycle_am_00400.start();
+        A1_Cycle_am_00410.start();
+        A2_Cycle_am_00410.start();
+        A1_Cycle_am_00420.start();
+        A2_Cycle_am_00420.start();
+        A1_Cycle_am_00430.start();
+        A2_Cycle_am_00430.start();
+        A1_Cycle_am_00440.start();
+        A2_Cycle_am_00440.start();
+        A1_Cycle_am_00450.start();
+        A2_Cycle_am_00450.start();
+        A1_Cycle_am_00460.start();
+        A2_Cycle_am_00460.start();
+        A1_Cycle_am_00470.start();
+        A2_Cycle_am_00470.start();
+        A1_Cycle_am_00480.start();
+        A2_Cycle_am_00480.start();
+        A1_Cycle_am_00490.start();
+        A2_Cycle_am_00490.start();
+        A1_Cycle_am_00500.start();
+        A2_Cycle_am_00500.start();
+        try {
+            A1_Cycle_am_00180.join();
+            A2_Cycle_am_00180.join();
+            A1_Cycle_am_00190.join();
+            A2_Cycle_am_00190.join();
+            A1_Cycle_am_00200.join();
+            A2_Cycle_am_00200.join();
+            A1_Cycle_am_00210.join();
+            A2_Cycle_am_00210.join();
+            A1_Cycle_am_00220.join();
+            A2_Cycle_am_00220.join();
+            A1_Cycle_am_00230.join();
+            A2_Cycle_am_00230.join();
+            A1_Cycle_am_00240.join();
+            A2_Cycle_am_00240.join();
+            A1_Cycle_am_00250.join();
+            A2_Cycle_am_00250.join();
+            A1_Cycle_am_00260.join();
+            A2_Cycle_am_00260.join();
+            A1_Cycle_am_00270.join();
+            A2_Cycle_am_00270.join();
+            A1_Cycle_am_00280.join();
+            A2_Cycle_am_00280.join();
+            A1_Cycle_am_00290.join();
+            A2_Cycle_am_00290.join();
+            A1_Cycle_am_00300.join();
+            A2_Cycle_am_00300.join();
+            A1_Cycle_am_00310.join();
+            A2_Cycle_am_00310.join();
+            A1_Cycle_am_00320.join();
+            A2_Cycle_am_00320.join();
+            A1_Cycle_am_00330.join();
+            A2_Cycle_am_00330.join();
+            A1_Cycle_am_00340.join();
+            A2_Cycle_am_00340.join();
+            A1_Cycle_am_00350.join();
+            A2_Cycle_am_00350.join();
+            A1_Cycle_am_00360.join();
+            A2_Cycle_am_00360.join();
+            A1_Cycle_am_00370.join();
+            A2_Cycle_am_00370.join();
+            A1_Cycle_am_00380.join();
+            A2_Cycle_am_00380.join();
+            A1_Cycle_am_00390.join();
+            A2_Cycle_am_00390.join();
+            A1_Cycle_am_00400.join();
+            A2_Cycle_am_00400.join();
+            A1_Cycle_am_00410.join();
+            A2_Cycle_am_00410.join();
+            A1_Cycle_am_00420.join();
+            A2_Cycle_am_00420.join();
+            A1_Cycle_am_00430.join();
+            A2_Cycle_am_00430.join();
+            A1_Cycle_am_00440.join();
+            A2_Cycle_am_00440.join();
+            A1_Cycle_am_00450.join();
+            A2_Cycle_am_00450.join();
+            A1_Cycle_am_00460.join();
+            A2_Cycle_am_00460.join();
+            A1_Cycle_am_00470.join();
+            A2_Cycle_am_00470.join();
+            A1_Cycle_am_00480.join();
+            A2_Cycle_am_00480.join();
+            A1_Cycle_am_00490.join();
+            A2_Cycle_am_00490.join();
+            A1_Cycle_am_00500.join();
+            A2_Cycle_am_00500.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00180.check() && A2_Cycle_am_00180.check() && A1_Cycle_am_00190.check() && A2_Cycle_am_00190.check() && A1_Cycle_am_00200.check() && A2_Cycle_am_00200.check() && A1_Cycle_am_00210.check() && A2_Cycle_am_00210.check() && A1_Cycle_am_00220.check() && A2_Cycle_am_00220.check() && A1_Cycle_am_00230.check() && A2_Cycle_am_00230.check() && A1_Cycle_am_00240.check() && A2_Cycle_am_00240.check() && A1_Cycle_am_00250.check() && A2_Cycle_am_00250.check() && A1_Cycle_am_00260.check() && A2_Cycle_am_00260.check() && A1_Cycle_am_00270.check() && A2_Cycle_am_00270.check() && A1_Cycle_am_00280.check() && A2_Cycle_am_00280.check() && A1_Cycle_am_00290.check() && A2_Cycle_am_00290.check() && A1_Cycle_am_00300.check() && A2_Cycle_am_00300.check() && A1_Cycle_am_00310.check() && A2_Cycle_am_00310.check() && A1_Cycle_am_00320.check() && A2_Cycle_am_00320.check() && A1_Cycle_am_00330.check() && A2_Cycle_am_00330.check() && A1_Cycle_am_00340.check() && A2_Cycle_am_00340.check() && A1_Cycle_am_00350.check() && A2_Cycle_am_00350.check() && A1_Cycle_am_00360.check() && A2_Cycle_am_00360.check() && A1_Cycle_am_00370.check() && A2_Cycle_am_00370.check() && A1_Cycle_am_00380.check() && A2_Cycle_am_00380.check() && A1_Cycle_am_00390.check() && A2_Cycle_am_00390.check() && A1_Cycle_am_00400.check() && A2_Cycle_am_00400.check() && A1_Cycle_am_00410.check() && A2_Cycle_am_00410.check() && A1_Cycle_am_00420.check() && A2_Cycle_am_00420.check() && A1_Cycle_am_00430.check() && A2_Cycle_am_00430.check() && A1_Cycle_am_00440.check() && A2_Cycle_am_00440.check() && A1_Cycle_am_00450.check() && A2_Cycle_am_00450.check() && A1_Cycle_am_00460.check() && A2_Cycle_am_00460.check() && A1_Cycle_am_00470.check() && A2_Cycle_am_00470.check() && A1_Cycle_am_00480.check() && A2_Cycle_am_00480.check() && A1_Cycle_am_00490.check() && A2_Cycle_am_00490.check() && A1_Cycle_am_00500.check() && A2_Cycle_am_00500.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0154-rc-function-RC_Thread01-Cycle_am_10010/Cycle_am_10010.java b/test/testsuite/ouroboros/memory_management/Function/RC0154-rc-function-RC_Thread01-Cycle_am_10010/Cycle_am_10010.java
new file mode 100644
index 0000000000000000000000000000000000000000..34859d3eb0d47b3e94df83f38362989b51fa9407
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0154-rc-function-RC_Thread01-Cycle_am_10010/Cycle_am_10010.java
@@ -0,0 +1,431 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_10010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_10010 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_10010.java
+ *- @ExecuteClass: Cycle_am_10010
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_am_10010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_10010_A1 a1_main = new Cycle_a_10010_A1("a1_main");
+        Cycle_a_10010_A4 a4_main = new Cycle_a_10010_A4("a4_main");
+        Cycle_a_10010_A6 a6_main = new Cycle_a_10010_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_10010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10010_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10010_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_10010_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        Cycle_a_10010_2A1 a1_2main = new Cycle_a_10010_2A1("a1_2main");
+        Cycle_a_10010_2A4 a4_2main = new Cycle_a_10010_2A4("a4_2main");
+        Cycle_a_10010_2A6 a6_2main = new Cycle_a_10010_2A6("a6_2main");
+        a1_2main.a2_0 = new Cycle_a_10010_2A2("a2_0");
+        a1_2main.a2_0.a3_0 = new Cycle_a_10010_2A3("a3_0");
+        a1_2main.a2_0.a4_0 = a4_2main;
+        a4_2main.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a5_0 = new Cycle_a_10010_2A5("a5_0");
+        a1_2main.a2_0.a3_0.a5_0.a6_0 = a6_2main;
+        a1_2main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10010_2A8("a8_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10010_2A7("a7_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_2main.a2_0.a3_0;
+        a6_2main.a1_0 = a1_2main;
+        a6_2main.a3_0 = a1_2main.a2_0.a3_0;
+
+
+        a1_2main.add();
+        a4_2main.add();
+        a6_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        a1_2main.a2_0.a3_0.a5_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result2 = a1_2main.sum + a4_2main.sum + a6_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum + a1_2main.a2_0.a3_0.a5_0.sum + a6_2main.a3_0.a5_0.a8_0.a7_0.sum + a6_2main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+
+        if (result == 3852)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_10010_A1 {
+        Cycle_a_10010_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A2 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A3 {
+        Cycle_a_10010_A1 a1_0;
+        Cycle_a_10010_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A4 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A5 {
+        Cycle_a_10010_A4 a4_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A6 {
+        Cycle_a_10010_A5 a5_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Cycle_a_10010_2A1 {
+        Cycle_a_10010_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A2 {
+        Cycle_a_10010_2A3 a3_0;
+        Cycle_a_10010_2A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A3 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A4 {
+        Cycle_a_10010_2A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A5 {
+        Cycle_a_10010_2A6 a6_0;
+        Cycle_a_10010_2A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A6 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A7 {
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A8 {
+        Cycle_a_10010_2A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_10010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_10010 A1_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A2_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A3_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A4_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A5_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A6_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+
+        A1_Cycle_am_10010.start();
+        A2_Cycle_am_10010.start();
+        A3_Cycle_am_10010.start();
+        A4_Cycle_am_10010.start();
+        A5_Cycle_am_10010.start();
+        A6_Cycle_am_10010.start();
+
+        try {
+            A1_Cycle_am_10010.join();
+            A2_Cycle_am_10010.join();
+            A3_Cycle_am_10010.join();
+            A4_Cycle_am_10010.join();
+            A5_Cycle_am_10010.join();
+            A6_Cycle_am_10010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_10010.check() && A2_Cycle_am_10010.check() && A3_Cycle_am_10010.check() && A4_Cycle_am_10010.check() && A5_Cycle_am_10010.check() && A6_Cycle_am_10010.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0155-rc-function-RC_Thread01-Cycle_am_10020/Cycle_am_10020.java b/test/testsuite/ouroboros/memory_management/Function/RC0155-rc-function-RC_Thread01-Cycle_am_10020/Cycle_am_10020.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba31a7cc8547329c2ebcdafe548d3311d409b61c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0155-rc-function-RC_Thread01-Cycle_am_10020/Cycle_am_10020.java
@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_10020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_10020 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_10020.java
+ *- @ExecuteClass: Cycle_am_10020
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_am_10020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_10020_A1 a1_main = new Cycle_a_10020_A1("a1_main");
+        Cycle_a_10020_A4 a4_main = new Cycle_a_10020_A4("a4_main");
+        Cycle_a_10020_A6 a6_main = new Cycle_a_10020_A6("a6_main");
+        Cycle_a_10020_A9 a9_main = new Cycle_a_10020_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_10020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10020_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10020_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_10020_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10020_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10020_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10020_2A1 a1_2main = new Cycle_a_10020_2A1("a1_2main");
+        a1_2main.a2_0 = new Cycle_a_10020_2A2("a2_0");
+        a1_2main.a2_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0 = new Cycle_a_10020_2A3("a3_0");
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a2_0 = a1_2main.a2_0;
+
+
+        a1_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+
+        int result2 = a1_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+
+        if (result == 3438)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_10020_A1 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A2 {
+        Cycle_a_10020_A3 a3_0;
+        Cycle_a_10020_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A3 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A5 a5_0;
+        Cycle_a_10020_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A4 {
+        Cycle_a_10020_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A5 {
+        Cycle_a_10020_A6 a6_0;
+        Cycle_a_10020_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A6 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A7 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A8 {
+        Cycle_a_10020_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A9 {
+        Cycle_a_10020_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A10 {
+        Cycle_a_10020_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A1 {
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A2 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A3 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_10020 A1_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A2_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A3_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A4_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A5_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A6_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+
+        A1_Cycle_am_10020.start();
+        A2_Cycle_am_10020.start();
+        A3_Cycle_am_10020.start();
+        A4_Cycle_am_10020.start();
+        A5_Cycle_am_10020.start();
+        A6_Cycle_am_10020.start();
+
+        try {
+            A1_Cycle_am_10020.join();
+            A2_Cycle_am_10020.join();
+            A3_Cycle_am_10020.join();
+            A4_Cycle_am_10020.join();
+            A5_Cycle_am_10020.join();
+            A6_Cycle_am_10020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_10020.check() && A2_Cycle_am_10020.check() && A3_Cycle_am_10020.check() && A4_Cycle_am_10020.check() && A5_Cycle_am_10020.check() && A6_Cycle_am_10020.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0156-rc-function-RC_Thread01-Cycle_am_10030/Cycle_am_10030.java b/test/testsuite/ouroboros/memory_management/Function/RC0156-rc-function-RC_Thread01-Cycle_am_10030/Cycle_am_10030.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c323af34d1945ec5cf65801d534bf4165f3e837
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0156-rc-function-RC_Thread01-Cycle_am_10030/Cycle_am_10030.java
@@ -0,0 +1,772 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_10030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_10030 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_10030.java
+ *- @ExecuteClass: Cycle_am_10030
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_am_10020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_10020_A1 a1_main = new Cycle_a_10020_A1("a1_main");
+        Cycle_a_10020_A4 a4_main = new Cycle_a_10020_A4("a4_main");
+        Cycle_a_10020_A6 a6_main = new Cycle_a_10020_A6("a6_main");
+        Cycle_a_10020_A9 a9_main = new Cycle_a_10020_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_10020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10020_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10020_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_10020_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10020_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10020_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10020_2A1 a1_2main = new Cycle_a_10020_2A1("a1_2main");
+        a1_2main.a2_0 = new Cycle_a_10020_2A2("a2_0");
+        a1_2main.a2_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0 = new Cycle_a_10020_2A3("a3_0");
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a2_0 = a1_2main.a2_0;
+
+
+        a1_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+
+        int result2 = a1_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+
+        if (result == 3438)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_10020_A1 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A2 {
+        Cycle_a_10020_A3 a3_0;
+        Cycle_a_10020_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A3 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A5 a5_0;
+        Cycle_a_10020_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A4 {
+        Cycle_a_10020_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A5 {
+        Cycle_a_10020_A6 a6_0;
+        Cycle_a_10020_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A6 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A7 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A8 {
+        Cycle_a_10020_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A9 {
+        Cycle_a_10020_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A10 {
+        Cycle_a_10020_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A1 {
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A2 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A3 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_10010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_10010_A1 a1_main = new Cycle_a_10010_A1("a1_main");
+        Cycle_a_10010_A4 a4_main = new Cycle_a_10010_A4("a4_main");
+        Cycle_a_10010_A6 a6_main = new Cycle_a_10010_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_10010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10010_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10010_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_10010_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        Cycle_a_10010_2A1 a1_2main = new Cycle_a_10010_2A1("a1_2main");
+        Cycle_a_10010_2A4 a4_2main = new Cycle_a_10010_2A4("a4_2main");
+        Cycle_a_10010_2A6 a6_2main = new Cycle_a_10010_2A6("a6_2main");
+        a1_2main.a2_0 = new Cycle_a_10010_2A2("a2_0");
+        a1_2main.a2_0.a3_0 = new Cycle_a_10010_2A3("a3_0");
+        a1_2main.a2_0.a4_0 = a4_2main;
+        a4_2main.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a5_0 = new Cycle_a_10010_2A5("a5_0");
+        a1_2main.a2_0.a3_0.a5_0.a6_0 = a6_2main;
+        a1_2main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10010_2A8("a8_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10010_2A7("a7_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_2main.a2_0.a3_0;
+        a6_2main.a1_0 = a1_2main;
+        a6_2main.a3_0 = a1_2main.a2_0.a3_0;
+
+
+        a1_2main.add();
+        a4_2main.add();
+        a6_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        a1_2main.a2_0.a3_0.a5_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result2 = a1_2main.sum + a4_2main.sum + a6_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum + a1_2main.a2_0.a3_0.a5_0.sum + a6_2main.a3_0.a5_0.a8_0.a7_0.sum + a6_2main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+
+        if (result == 3852)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_10010_A1 {
+        Cycle_a_10010_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A2 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A3 {
+        Cycle_a_10010_A1 a1_0;
+        Cycle_a_10010_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A4 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A5 {
+        Cycle_a_10010_A4 a4_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A6 {
+        Cycle_a_10010_A5 a5_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Cycle_a_10010_2A1 {
+        Cycle_a_10010_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A2 {
+        Cycle_a_10010_2A3 a3_0;
+        Cycle_a_10010_2A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A3 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A4 {
+        Cycle_a_10010_2A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A5 {
+        Cycle_a_10010_2A6 a6_0;
+        Cycle_a_10010_2A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A6 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A7 {
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A8 {
+        Cycle_a_10010_2A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+public class Cycle_am_10030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_10010B A1_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A2_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A3_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A4_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A5_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A6_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10020B A1_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A2_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A3_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A4_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A5_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A6_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        A1_Cycle_am_10010.start();
+        A2_Cycle_am_10010.start();
+        A3_Cycle_am_10010.start();
+        A4_Cycle_am_10010.start();
+        A5_Cycle_am_10010.start();
+        A6_Cycle_am_10010.start();
+        A1_Cycle_am_10020.start();
+        A2_Cycle_am_10020.start();
+        A3_Cycle_am_10020.start();
+        A4_Cycle_am_10020.start();
+        A5_Cycle_am_10020.start();
+        A6_Cycle_am_10020.start();
+
+        try {
+            A1_Cycle_am_10010.join();
+            A2_Cycle_am_10010.join();
+            A3_Cycle_am_10010.join();
+            A4_Cycle_am_10010.join();
+            A5_Cycle_am_10010.join();
+            A6_Cycle_am_10010.join();
+            A1_Cycle_am_10020.join();
+            A2_Cycle_am_10020.join();
+            A3_Cycle_am_10020.join();
+            A4_Cycle_am_10020.join();
+            A5_Cycle_am_10020.join();
+            A6_Cycle_am_10020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_10010.check() && A2_Cycle_am_10010.check() && A3_Cycle_am_10010.check() && A4_Cycle_am_10010.check() && A5_Cycle_am_10010.check() && A6_Cycle_am_10010.check() && A1_Cycle_am_10020.check() && A2_Cycle_am_10020.check() && A3_Cycle_am_10020.check() && A4_Cycle_am_10020.check() && A5_Cycle_am_10020.check() && A6_Cycle_am_10020.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/Cycle_Bm_1_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/Cycle_Bm_1_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..edf653086ae8a46ab7a58f157a72c8ef0b12ea63
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/Cycle_Bm_1_00010.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00010 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00010.java
+ *- @ExecuteClass: Cycle_Bm_1_00010
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 246)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00010_A1 {
+        Cycle_B_1_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00010_A1() {
+            a1_0 = null;
+            a = 123;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00010 A1_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A2_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A3_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A4_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A5_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A6_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+
+        A1_Cycle_Bm_1_00010.start();
+        A2_Cycle_Bm_1_00010.start();
+        A3_Cycle_Bm_1_00010.start();
+        A4_Cycle_Bm_1_00010.start();
+        A5_Cycle_Bm_1_00010.start();
+        A6_Cycle_Bm_1_00010.start();
+
+        try {
+            A1_Cycle_Bm_1_00010.join();
+            A2_Cycle_Bm_1_00010.join();
+            A3_Cycle_Bm_1_00010.join();
+            A4_Cycle_Bm_1_00010.join();
+            A5_Cycle_Bm_1_00010.join();
+            A6_Cycle_Bm_1_00010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00010.check() && A2_Cycle_Bm_1_00010.check() && A3_Cycle_Bm_1_00010.check() && A4_Cycle_Bm_1_00010.check() && A5_Cycle_Bm_1_00010.check() && A6_Cycle_Bm_1_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/Cycle_Bm_1_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/Cycle_Bm_1_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..dae8a2a198987861dc1b6a40f141fd4aeaab0aeb
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/Cycle_Bm_1_00020.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00020 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00020.java
+ *- @ExecuteClass: Cycle_Bm_1_00020
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_Bm_1_00020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00020_A1 a1_0 = new Cycle_B_1_00020_A1();
+        a1_0.a2_0 = new Cycle_B_1_00020_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 6)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00020_A1 {
+        Cycle_B_1_00020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00020_A2 {
+        Cycle_B_1_00020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00020_A2() {
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00020 A1_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A2_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A3_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A4_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A5_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A6_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+
+        A1_Cycle_Bm_1_00020.start();
+        A2_Cycle_Bm_1_00020.start();
+        A3_Cycle_Bm_1_00020.start();
+        A4_Cycle_Bm_1_00020.start();
+        A5_Cycle_Bm_1_00020.start();
+        A6_Cycle_Bm_1_00020.start();
+
+        try {
+            A1_Cycle_Bm_1_00020.join();
+            A2_Cycle_Bm_1_00020.join();
+            A3_Cycle_Bm_1_00020.join();
+            A4_Cycle_Bm_1_00020.join();
+            A5_Cycle_Bm_1_00020.join();
+            A6_Cycle_Bm_1_00020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00020.check() && A2_Cycle_Bm_1_00020.check() && A3_Cycle_Bm_1_00020.check() && A4_Cycle_Bm_1_00020.check() && A5_Cycle_Bm_1_00020.check() && A6_Cycle_Bm_1_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/Cycle_Bm_1_00030.java b/test/testsuite/ouroboros/memory_management/Function/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/Cycle_Bm_1_00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba81b308df691963b54b8ac018c460150a6b66db
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/Cycle_Bm_1_00030.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00030 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00030.java
+ *- @ExecuteClass: Cycle_Bm_1_00030
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_Bm_1_00030 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00030_A1 a1_0 = new Cycle_B_1_00030_A1();
+        a1_0.a2_0 = new Cycle_B_1_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00030_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00030_A1 {
+        Cycle_B_1_00030_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00030_A2 {
+        Cycle_B_1_00030_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00030_A3 {
+        Cycle_B_1_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00030 A1_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A2_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A3_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A4_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A5_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A6_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+
+        A1_Cycle_Bm_1_00030.start();
+        A2_Cycle_Bm_1_00030.start();
+        A3_Cycle_Bm_1_00030.start();
+        A4_Cycle_Bm_1_00030.start();
+        A5_Cycle_Bm_1_00030.start();
+        A6_Cycle_Bm_1_00030.start();
+
+        try {
+            A1_Cycle_Bm_1_00030.join();
+            A2_Cycle_Bm_1_00030.join();
+            A3_Cycle_Bm_1_00030.join();
+            A4_Cycle_Bm_1_00030.join();
+            A5_Cycle_Bm_1_00030.join();
+            A6_Cycle_Bm_1_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00030.check() && A2_Cycle_Bm_1_00030.check() && A3_Cycle_Bm_1_00030.check() && A4_Cycle_Bm_1_00030.check() && A5_Cycle_Bm_1_00030.check() && A6_Cycle_Bm_1_00030.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/Cycle_Bm_1_00040.java b/test/testsuite/ouroboros/memory_management/Function/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/Cycle_Bm_1_00040.java
new file mode 100644
index 0000000000000000000000000000000000000000..96c20cc5af11ad9a26aecd605f57f09e199ad9ea
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/Cycle_Bm_1_00040.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00040 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00040.java
+ *- @ExecuteClass: Cycle_Bm_1_00040
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_Bm_1_00040 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00040_A1 a1_0 = new Cycle_B_1_00040_A1();
+        a1_0.a2_0 = new Cycle_B_1_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00040_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00040_A4();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00040_A1 {
+        Cycle_B_1_00040_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A2 {
+        Cycle_B_1_00040_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A3 {
+        Cycle_B_1_00040_A1 a1_0;
+        Cycle_B_1_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A4 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00040 A1_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A2_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A3_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A4_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A5_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A6_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+
+        A1_Cycle_Bm_1_00040.start();
+        A2_Cycle_Bm_1_00040.start();
+        A3_Cycle_Bm_1_00040.start();
+        A4_Cycle_Bm_1_00040.start();
+        A5_Cycle_Bm_1_00040.start();
+        A6_Cycle_Bm_1_00040.start();
+
+        try {
+            A1_Cycle_Bm_1_00040.join();
+            A2_Cycle_Bm_1_00040.join();
+            A3_Cycle_Bm_1_00040.join();
+            A4_Cycle_Bm_1_00040.join();
+            A5_Cycle_Bm_1_00040.join();
+            A6_Cycle_Bm_1_00040.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00040.check() && A2_Cycle_Bm_1_00040.check() && A3_Cycle_Bm_1_00040.check() && A4_Cycle_Bm_1_00040.check() && A5_Cycle_Bm_1_00040.check() && A6_Cycle_Bm_1_00040.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/Cycle_Bm_1_00050.java b/test/testsuite/ouroboros/memory_management/Function/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/Cycle_Bm_1_00050.java
new file mode 100644
index 0000000000000000000000000000000000000000..78e144be2d47cdad2cfafeebbfe001fde629093b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/Cycle_Bm_1_00050.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00050 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00050.java
+ *- @ExecuteClass: Cycle_Bm_1_00050
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_Bm_1_00050 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00050_A1 a1_0 = new Cycle_B_1_00050_A1();
+        a1_0.a2_0 = new Cycle_B_1_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00050_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00050_A4();
+        a1_0.a2_0.a5_0 = new Cycle_B_1_00050_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 34)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00050_A1 {
+        Cycle_B_1_00050_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A2 {
+        Cycle_B_1_00050_A3 a3_0;
+        Cycle_B_1_00050_A4 a4_0;
+        Cycle_B_1_00050_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A3 {
+        Cycle_B_1_00050_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A4 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+
+    class Cycle_B_1_00050_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A5() {
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00050 A1_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A2_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A3_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A4_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A5_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A6_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+
+        A1_Cycle_Bm_1_00050.start();
+        A2_Cycle_Bm_1_00050.start();
+        A3_Cycle_Bm_1_00050.start();
+        A4_Cycle_Bm_1_00050.start();
+        A5_Cycle_Bm_1_00050.start();
+        A6_Cycle_Bm_1_00050.start();
+
+        try {
+            A1_Cycle_Bm_1_00050.join();
+            A2_Cycle_Bm_1_00050.join();
+            A3_Cycle_Bm_1_00050.join();
+            A4_Cycle_Bm_1_00050.join();
+            A5_Cycle_Bm_1_00050.join();
+            A6_Cycle_Bm_1_00050.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00050.check() && A2_Cycle_Bm_1_00050.check() && A3_Cycle_Bm_1_00050.check() && A4_Cycle_Bm_1_00050.check() && A5_Cycle_Bm_1_00050.check() && A6_Cycle_Bm_1_00050.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/Cycle_Bm_1_00060.java b/test/testsuite/ouroboros/memory_management/Function/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/Cycle_Bm_1_00060.java
new file mode 100644
index 0000000000000000000000000000000000000000..d9d8a20788866d89765165ba4f493af6b68c107a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/Cycle_Bm_1_00060.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00060 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00060.java
+ *- @ExecuteClass: Cycle_Bm_1_00060
+ *- @ExecuteArgs:
+ */
+
+class ThreadRc_Cycle_Bm_1_00060 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00060_A1 a1_0 = new Cycle_B_1_00060_A1();
+        a1_0.a2_0 = new Cycle_B_1_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00060_A3();
+        Cycle_B_1_00060_A4 a4_0 = new Cycle_B_1_00060_A4();
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00060_A1 {
+        Cycle_B_1_00060_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A2 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A3 {
+        Cycle_B_1_00060_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A4 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00060 A1_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A2_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A3_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A4_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A5_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A6_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+
+        A1_Cycle_Bm_1_00060.start();
+        A2_Cycle_Bm_1_00060.start();
+        A3_Cycle_Bm_1_00060.start();
+        A4_Cycle_Bm_1_00060.start();
+        A5_Cycle_Bm_1_00060.start();
+        A6_Cycle_Bm_1_00060.start();
+
+        try {
+            A1_Cycle_Bm_1_00060.join();
+            A2_Cycle_Bm_1_00060.join();
+            A3_Cycle_Bm_1_00060.join();
+            A4_Cycle_Bm_1_00060.join();
+            A5_Cycle_Bm_1_00060.join();
+            A6_Cycle_Bm_1_00060.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00060.check() && A2_Cycle_Bm_1_00060.check() && A3_Cycle_Bm_1_00060.check() && A4_Cycle_Bm_1_00060.check() && A5_Cycle_Bm_1_00060.check() && A6_Cycle_Bm_1_00060.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/Cycle_Bm_1_00070.java b/test/testsuite/ouroboros/memory_management/Function/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/Cycle_Bm_1_00070.java
new file mode 100644
index 0000000000000000000000000000000000000000..342e9bc1f5f0c45e171179a1149a680ff5211d03
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/Cycle_Bm_1_00070.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00070 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00070.java
+ *- @ExecuteClass: Cycle_Bm_1_00070
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00070 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00070_A1 a1_0 = new Cycle_B_1_00070_A1();
+        a1_0.a2_0 = new Cycle_B_1_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00070_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00070_A4();
+
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00070_A1 {
+        Cycle_B_1_00070_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A2 {
+        Cycle_B_1_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A3 {
+        Cycle_B_1_00070_A1 a1_0;
+        Cycle_B_1_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00070 A1_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A2_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A3_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A4_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A5_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A6_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+
+        A1_Cycle_Bm_1_00070.start();
+        A2_Cycle_Bm_1_00070.start();
+        A3_Cycle_Bm_1_00070.start();
+        A4_Cycle_Bm_1_00070.start();
+        A5_Cycle_Bm_1_00070.start();
+        A6_Cycle_Bm_1_00070.start();
+
+        try {
+            A1_Cycle_Bm_1_00070.join();
+            A2_Cycle_Bm_1_00070.join();
+            A3_Cycle_Bm_1_00070.join();
+            A4_Cycle_Bm_1_00070.join();
+            A5_Cycle_Bm_1_00070.join();
+            A6_Cycle_Bm_1_00070.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00070.check() && A2_Cycle_Bm_1_00070.check() && A3_Cycle_Bm_1_00070.check() && A4_Cycle_Bm_1_00070.check() && A5_Cycle_Bm_1_00070.check() && A6_Cycle_Bm_1_00070.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/Cycle_Bm_1_00080.java b/test/testsuite/ouroboros/memory_management/Function/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/Cycle_Bm_1_00080.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8a9e50b7283f6945676968534a0357475f66134
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/Cycle_Bm_1_00080.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00080 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00080.java
+ *- @ExecuteClass: Cycle_Bm_1_00080
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00080 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00080_A1 a1_0 = new Cycle_B_1_00080_A1();
+        a1_0.a2_0 = new Cycle_B_1_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00080_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00080_A4();
+        a1_0.a2_0.a3_0.a5_0 = new Cycle_B_1_00080_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 56)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00080_A1 {
+        Cycle_B_1_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00080_A2 {
+        Cycle_B_1_00080_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00080_A3 {
+        Cycle_B_1_00080_A1 a1_0;
+        Cycle_B_1_00080_A4 a4_0;
+        Cycle_B_1_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            a4_0.add();
+            a5_0.add();
+            sum = a + a1_0.a + a4_0.sum + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00080_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+
+    class Cycle_B_1_00080_A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A5() {
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00080 A1_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A2_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A3_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A4_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A5_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A6_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+
+        A1_Cycle_Bm_1_00080.start();
+        A2_Cycle_Bm_1_00080.start();
+        A3_Cycle_Bm_1_00080.start();
+        A4_Cycle_Bm_1_00080.start();
+        A5_Cycle_Bm_1_00080.start();
+        A6_Cycle_Bm_1_00080.start();
+
+        try {
+            A1_Cycle_Bm_1_00080.join();
+            A2_Cycle_Bm_1_00080.join();
+            A3_Cycle_Bm_1_00080.join();
+            A4_Cycle_Bm_1_00080.join();
+            A5_Cycle_Bm_1_00080.join();
+            A6_Cycle_Bm_1_00080.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00080.check() && A2_Cycle_Bm_1_00080.check() && A3_Cycle_Bm_1_00080.check() && A4_Cycle_Bm_1_00080.check() && A5_Cycle_Bm_1_00080.check() && A6_Cycle_Bm_1_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/Cycle_Bm_1_00090.java b/test/testsuite/ouroboros/memory_management/Function/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/Cycle_Bm_1_00090.java
new file mode 100644
index 0000000000000000000000000000000000000000..c946024b5b541ba3b9ab28080f3f0d814cee174d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/Cycle_Bm_1_00090.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00090 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00090.java
+ *- @ExecuteClass: Cycle_Bm_1_00090
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00090 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00090_A1 a1_0 = new Cycle_B_1_00090_A1();
+        a1_0.a2_0 = new Cycle_B_1_00090_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00090_A3();
+        Cycle_B_1_00090_A4 a4_0 = new Cycle_B_1_00090_A4();
+        Cycle_B_1_00090_A5 a5_0 = new Cycle_B_1_00090_A5();
+        a4_0.a2_0 = a1_0.a2_0;
+        a5_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 25)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00090_A1 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A2 {
+        Cycle_B_1_00090_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A3 {
+        Cycle_B_1_00090_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A4 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A5 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00090 A1_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A2_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A3_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A4_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A5_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A6_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+
+        A1_Cycle_Bm_1_00090.start();
+        A2_Cycle_Bm_1_00090.start();
+        A3_Cycle_Bm_1_00090.start();
+        A4_Cycle_Bm_1_00090.start();
+        A5_Cycle_Bm_1_00090.start();
+        A6_Cycle_Bm_1_00090.start();
+
+        try {
+            A1_Cycle_Bm_1_00090.join();
+            A2_Cycle_Bm_1_00090.join();
+            A3_Cycle_Bm_1_00090.join();
+            A4_Cycle_Bm_1_00090.join();
+            A5_Cycle_Bm_1_00090.join();
+            A6_Cycle_Bm_1_00090.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00090.check() && A2_Cycle_Bm_1_00090.check() && A3_Cycle_Bm_1_00090.check() && A4_Cycle_Bm_1_00090.check() && A5_Cycle_Bm_1_00090.check() && A6_Cycle_Bm_1_00090.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/Cycle_Bm_1_00100.java b/test/testsuite/ouroboros/memory_management/Function/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/Cycle_Bm_1_00100.java
new file mode 100644
index 0000000000000000000000000000000000000000..279b968cc21ff6b5ab77063d344f28a88b61f070
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/Cycle_Bm_1_00100.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00100 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00100.java
+ *- @ExecuteClass: Cycle_Bm_1_00100
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00100 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00100_A1 a1_0 = new Cycle_B_1_00100_A1();
+        a1_0.a2_0 = new Cycle_B_1_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00100_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00100_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_1_00100_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00100_A1 {
+        Cycle_B_1_00100_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A2 {
+        Cycle_B_1_00100_A3 a3_0;
+        Cycle_B_1_00100_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A3 {
+        Cycle_B_1_00100_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A4 {
+
+        int a;
+        int sum;
+        Cycle_B_1_00100_A5 a5_0;
+
+        Cycle_B_1_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00100_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A5() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00100 A1_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A2_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A3_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A4_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A5_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A6_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+
+        A1_Cycle_Bm_1_00100.start();
+        A2_Cycle_Bm_1_00100.start();
+        A3_Cycle_Bm_1_00100.start();
+        A4_Cycle_Bm_1_00100.start();
+        A5_Cycle_Bm_1_00100.start();
+        A6_Cycle_Bm_1_00100.start();
+
+        try {
+            A1_Cycle_Bm_1_00100.join();
+            A2_Cycle_Bm_1_00100.join();
+            A3_Cycle_Bm_1_00100.join();
+            A4_Cycle_Bm_1_00100.join();
+            A5_Cycle_Bm_1_00100.join();
+            A6_Cycle_Bm_1_00100.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00100.check() && A2_Cycle_Bm_1_00100.check() && A3_Cycle_Bm_1_00100.check() && A4_Cycle_Bm_1_00100.check() && A5_Cycle_Bm_1_00100.check() && A6_Cycle_Bm_1_00100.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/Cycle_Bm_1_00110.java b/test/testsuite/ouroboros/memory_management/Function/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/Cycle_Bm_1_00110.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3b289b42a465061ee0d1907af455ff5fd9327ce
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/Cycle_Bm_1_00110.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00110 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00110.java
+ *- @ExecuteClass: Cycle_Bm_1_00110
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00110 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00110_A1 a1_0 = new Cycle_B_1_00110_A1();
+        a1_0.a2_0 = new Cycle_B_1_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00110_A3();
+        Cycle_B_1_00110_A5 a5_0 = new Cycle_B_1_00110_A5();
+        a5_0.a4_0 = new Cycle_B_1_00110_A4();
+        a5_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00110_A1 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A2 {
+        Cycle_B_1_00110_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A3 {
+        Cycle_B_1_00110_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A4 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A5 {
+        Cycle_B_1_00110_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00110 A1_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A2_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A3_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A4_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A5_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A6_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+
+        A1_Cycle_Bm_1_00110.start();
+        A2_Cycle_Bm_1_00110.start();
+        A3_Cycle_Bm_1_00110.start();
+        A4_Cycle_Bm_1_00110.start();
+        A5_Cycle_Bm_1_00110.start();
+        A6_Cycle_Bm_1_00110.start();
+
+        try {
+            A1_Cycle_Bm_1_00110.join();
+            A2_Cycle_Bm_1_00110.join();
+            A3_Cycle_Bm_1_00110.join();
+            A4_Cycle_Bm_1_00110.join();
+            A5_Cycle_Bm_1_00110.join();
+            A6_Cycle_Bm_1_00110.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00110.check() && A2_Cycle_Bm_1_00110.check() && A3_Cycle_Bm_1_00110.check() && A4_Cycle_Bm_1_00110.check() && A5_Cycle_Bm_1_00110.check() && A6_Cycle_Bm_1_00110.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/Cycle_Bm_1_00120.java b/test/testsuite/ouroboros/memory_management/Function/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/Cycle_Bm_1_00120.java
new file mode 100644
index 0000000000000000000000000000000000000000..63236063fc8f3c83cf44e8f4bba1177b3adb85e0
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/Cycle_Bm_1_00120.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00120 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00120.java
+ *- @ExecuteClass: Cycle_Bm_1_00120
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00120 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00120_A1 a1_0 = new Cycle_B_1_00120_A1();
+        a1_0.a2_0 = new Cycle_B_1_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00120_A3();
+        Cycle_B_1_00120_A5 a5_0 = new Cycle_B_1_00120_A5();
+        a5_0.a4_0 = new Cycle_B_1_00120_A4();
+        a5_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00120_A1 {
+        Cycle_B_1_00120_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A2 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A3 {
+        Cycle_B_1_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A4 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A5 {
+        Cycle_B_1_00120_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00120 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00120 A1_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A2_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A3_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A4_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A5_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A6_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+
+        A1_Cycle_Bm_1_00120.start();
+        A2_Cycle_Bm_1_00120.start();
+        A3_Cycle_Bm_1_00120.start();
+        A4_Cycle_Bm_1_00120.start();
+        A5_Cycle_Bm_1_00120.start();
+        A6_Cycle_Bm_1_00120.start();
+
+        try {
+            A1_Cycle_Bm_1_00120.join();
+            A2_Cycle_Bm_1_00120.join();
+            A3_Cycle_Bm_1_00120.join();
+            A4_Cycle_Bm_1_00120.join();
+            A5_Cycle_Bm_1_00120.join();
+            A6_Cycle_Bm_1_00120.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00120.check() && A2_Cycle_Bm_1_00120.check() && A3_Cycle_Bm_1_00120.check() && A4_Cycle_Bm_1_00120.check() && A5_Cycle_Bm_1_00120.check() && A6_Cycle_Bm_1_00120.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/Cycle_Bm_1_00130.java b/test/testsuite/ouroboros/memory_management/Function/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/Cycle_Bm_1_00130.java
new file mode 100644
index 0000000000000000000000000000000000000000..e22d8c0ff68bf0a1222fc8396914d070f696a4dd
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/Cycle_Bm_1_00130.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00130 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00130.java
+ *- @ExecuteClass: Cycle_Bm_1_00130
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00130 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00130_A1 a1_0 = new Cycle_B_1_00130_A1();
+        Cycle_B_1_00130_A2 a2_0 = new Cycle_B_1_00130_A2();
+        Cycle_B_1_00130_A3 a3_0 = new Cycle_B_1_00130_A3();
+        a1_0.a3_0 = a3_0;
+        a2_0.a3_0 = a3_0;
+        a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00130_A1 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A1() {
+            a3_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00130_A2 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00130_A3 {
+        Cycle_B_1_00130_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00130 A1_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A2_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A3_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A4_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A5_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A6_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+
+        A1_Cycle_Bm_1_00130.start();
+        A2_Cycle_Bm_1_00130.start();
+        A3_Cycle_Bm_1_00130.start();
+        A4_Cycle_Bm_1_00130.start();
+        A5_Cycle_Bm_1_00130.start();
+        A6_Cycle_Bm_1_00130.start();
+
+        try {
+            A1_Cycle_Bm_1_00130.join();
+            A2_Cycle_Bm_1_00130.join();
+            A3_Cycle_Bm_1_00130.join();
+            A4_Cycle_Bm_1_00130.join();
+            A5_Cycle_Bm_1_00130.join();
+            A6_Cycle_Bm_1_00130.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00130.check() && A2_Cycle_Bm_1_00130.check() && A3_Cycle_Bm_1_00130.check() && A4_Cycle_Bm_1_00130.check() && A5_Cycle_Bm_1_00130.check() && A6_Cycle_Bm_1_00130.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/Cycle_Bm_1_00140.java b/test/testsuite/ouroboros/memory_management/Function/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/Cycle_Bm_1_00140.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d1bcc02c1b01710b087dfc8c48908c97c5f06b6
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/Cycle_Bm_1_00140.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00140 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00140.java
+ *- @ExecuteClass: Cycle_Bm_1_00140
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00140 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00140_A1 a1_0 = new Cycle_B_1_00140_A1();
+        a1_0.a2_0 = new Cycle_B_1_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00140_A3();
+        Cycle_B_1_00140_A4 a4_0 = new Cycle_B_1_00140_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00140_A1 {
+        Cycle_B_1_00140_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A2 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A3 {
+        Cycle_B_1_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A4 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00140 A1_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A2_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A3_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A4_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A5_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A6_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+
+        A1_Cycle_Bm_1_00140.start();
+        A2_Cycle_Bm_1_00140.start();
+        A3_Cycle_Bm_1_00140.start();
+        A4_Cycle_Bm_1_00140.start();
+        A5_Cycle_Bm_1_00140.start();
+        A6_Cycle_Bm_1_00140.start();
+
+        try {
+            A1_Cycle_Bm_1_00140.join();
+            A2_Cycle_Bm_1_00140.join();
+            A3_Cycle_Bm_1_00140.join();
+            A4_Cycle_Bm_1_00140.join();
+            A5_Cycle_Bm_1_00140.join();
+            A6_Cycle_Bm_1_00140.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00140.check() && A2_Cycle_Bm_1_00140.check() && A3_Cycle_Bm_1_00140.check() && A4_Cycle_Bm_1_00140.check() && A5_Cycle_Bm_1_00140.check() && A6_Cycle_Bm_1_00140.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/Cycle_Bm_1_00150.java b/test/testsuite/ouroboros/memory_management/Function/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/Cycle_Bm_1_00150.java
new file mode 100644
index 0000000000000000000000000000000000000000..409e61c8188f5ec4372efc5f554803594fce8582
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/Cycle_Bm_1_00150.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00150 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00150.java
+ *- @ExecuteClass: Cycle_Bm_1_00150
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00150 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00150_A1 a1_0 = new Cycle_B_1_00150_A1();
+        a1_0.a2_0 = new Cycle_B_1_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00150_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_1_00150_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00150_A1 {
+        Cycle_B_1_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A2 {
+        Cycle_B_1_00150_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A3 {
+        Cycle_B_1_00150_A1 a1_0;
+        Cycle_B_1_00150_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A4 {
+
+        int a;
+        int sum;
+        Cycle_B_1_00150_A5 a5_0;
+
+        Cycle_B_1_00150_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00150_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A5() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00150 A1_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A2_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A3_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A4_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A5_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A6_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+
+        A1_Cycle_Bm_1_00150.start();
+        A2_Cycle_Bm_1_00150.start();
+        A3_Cycle_Bm_1_00150.start();
+        A4_Cycle_Bm_1_00150.start();
+        A5_Cycle_Bm_1_00150.start();
+        A6_Cycle_Bm_1_00150.start();
+
+        try {
+            A1_Cycle_Bm_1_00150.join();
+            A2_Cycle_Bm_1_00150.join();
+            A3_Cycle_Bm_1_00150.join();
+            A4_Cycle_Bm_1_00150.join();
+            A5_Cycle_Bm_1_00150.join();
+            A6_Cycle_Bm_1_00150.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00150.check() && A2_Cycle_Bm_1_00150.check() && A3_Cycle_Bm_1_00150.check() && A4_Cycle_Bm_1_00150.check() && A5_Cycle_Bm_1_00150.check() && A6_Cycle_Bm_1_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/Cycle_Bm_1_00160.java b/test/testsuite/ouroboros/memory_management/Function/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/Cycle_Bm_1_00160.java
new file mode 100644
index 0000000000000000000000000000000000000000..a82103ae889c13fa2f397d1646811e01e747f3e6
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/Cycle_Bm_1_00160.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00160 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00160.java
+ *- @ExecuteClass: Cycle_Bm_1_00160
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00160 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00160_A1 a1_0 = new Cycle_B_1_00160_A1();
+        a1_0.a2_0 = new Cycle_B_1_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00160_A3();
+        Cycle_B_1_00160_A4 a4_0 = new Cycle_B_1_00160_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 17)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00160_A1 {
+        Cycle_B_1_00160_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A2 {
+        Cycle_B_1_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A3 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A4 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00160 A1_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A2_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A3_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A4_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A5_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A6_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+
+        A1_Cycle_Bm_1_00160.start();
+        A2_Cycle_Bm_1_00160.start();
+        A3_Cycle_Bm_1_00160.start();
+        A4_Cycle_Bm_1_00160.start();
+        A5_Cycle_Bm_1_00160.start();
+        A6_Cycle_Bm_1_00160.start();
+
+        try {
+            A1_Cycle_Bm_1_00160.join();
+            A2_Cycle_Bm_1_00160.join();
+            A3_Cycle_Bm_1_00160.join();
+            A4_Cycle_Bm_1_00160.join();
+            A5_Cycle_Bm_1_00160.join();
+            A6_Cycle_Bm_1_00160.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00160.check() && A2_Cycle_Bm_1_00160.check() && A3_Cycle_Bm_1_00160.check() && A4_Cycle_Bm_1_00160.check() && A5_Cycle_Bm_1_00160.check() && A6_Cycle_Bm_1_00160.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/Cycle_Bm_1_00170.java b/test/testsuite/ouroboros/memory_management/Function/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/Cycle_Bm_1_00170.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7a5bf844634bf70dbd27baf208be5f421b00cc3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/Cycle_Bm_1_00170.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00170 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00170.java
+ *- @ExecuteClass: Cycle_Bm_1_00170
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00170 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00170_A1 a1_0 = new Cycle_B_1_00170_A1();
+        a1_0.a2_0 = new Cycle_B_1_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00170_A3();
+        Cycle_B_1_00170_A4 a4_0 = new Cycle_B_1_00170_A4();
+        Cycle_B_1_00170_A5 a5_0 = new Cycle_B_1_00170_A5();
+        a5_0.a4_0 = a4_0;
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 26)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00170_A1 {
+        Cycle_B_1_00170_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A2 {
+        Cycle_B_1_00170_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A3 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A4 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A5 {
+        Cycle_B_1_00170_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00170 A1_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A2_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A3_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A4_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A5_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A6_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+
+        A1_Cycle_Bm_1_00170.start();
+        A2_Cycle_Bm_1_00170.start();
+        A3_Cycle_Bm_1_00170.start();
+        A4_Cycle_Bm_1_00170.start();
+        A5_Cycle_Bm_1_00170.start();
+        A6_Cycle_Bm_1_00170.start();
+
+        try {
+            A1_Cycle_Bm_1_00170.join();
+            A2_Cycle_Bm_1_00170.join();
+            A3_Cycle_Bm_1_00170.join();
+            A4_Cycle_Bm_1_00170.join();
+            A5_Cycle_Bm_1_00170.join();
+            A6_Cycle_Bm_1_00170.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00170.check() && A2_Cycle_Bm_1_00170.check() && A3_Cycle_Bm_1_00170.check() && A4_Cycle_Bm_1_00170.check() && A5_Cycle_Bm_1_00170.check() && A6_Cycle_Bm_1_00170.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/Cycle_Bm_1_00180.java b/test/testsuite/ouroboros/memory_management/Function/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/Cycle_Bm_1_00180.java
new file mode 100644
index 0000000000000000000000000000000000000000..f040270d0d9de71ae58cad193ed96e04743b33ad
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/Cycle_Bm_1_00180.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00180 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00180.java
+ *- @ExecuteClass: Cycle_Bm_1_00180
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 23)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00180_A1 {
+        Cycle_B_1_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A2 {
+        Cycle_B_1_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A3 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A4 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A5 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00180 A1_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A2_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A3_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A4_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A5_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A6_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+
+        A1_Cycle_Bm_1_00180.start();
+        A2_Cycle_Bm_1_00180.start();
+        A3_Cycle_Bm_1_00180.start();
+        A4_Cycle_Bm_1_00180.start();
+        A5_Cycle_Bm_1_00180.start();
+        A6_Cycle_Bm_1_00180.start();
+
+        try {
+            A1_Cycle_Bm_1_00180.join();
+            A2_Cycle_Bm_1_00180.join();
+            A3_Cycle_Bm_1_00180.join();
+            A4_Cycle_Bm_1_00180.join();
+            A5_Cycle_Bm_1_00180.join();
+            A6_Cycle_Bm_1_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00180.check() && A2_Cycle_Bm_1_00180.check() && A3_Cycle_Bm_1_00180.check() && A4_Cycle_Bm_1_00180.check() && A5_Cycle_Bm_1_00180.check() && A6_Cycle_Bm_1_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/Cycle_Bm_1_00190.java b/test/testsuite/ouroboros/memory_management/Function/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/Cycle_Bm_1_00190.java
new file mode 100644
index 0000000000000000000000000000000000000000..953dae4c5b4ea0c1ffcd6e4ac32eec132a48d3d0
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/Cycle_Bm_1_00190.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00190 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00190.java
+ *- @ExecuteClass: Cycle_Bm_1_00190
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00190 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00190_A1 a1_0 = new Cycle_B_1_00190_A1();
+        a1_0.a2_0 = new Cycle_B_1_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00190_A3();
+        Cycle_B_1_00190_A4 a4_0 = new Cycle_B_1_00190_A4();
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00190_A1 {
+        Cycle_B_1_00190_A2 a2_0;
+        Cycle_B_1_00190_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A2 {
+        Cycle_B_1_00190_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A3 {
+        Cycle_B_1_00190_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00190 A1_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A2_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A3_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A4_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A5_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A6_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+
+        A1_Cycle_Bm_1_00190.start();
+        A2_Cycle_Bm_1_00190.start();
+        A3_Cycle_Bm_1_00190.start();
+        A4_Cycle_Bm_1_00190.start();
+        A5_Cycle_Bm_1_00190.start();
+        A6_Cycle_Bm_1_00190.start();
+
+        try {
+            A1_Cycle_Bm_1_00190.join();
+            A2_Cycle_Bm_1_00190.join();
+            A3_Cycle_Bm_1_00190.join();
+            A4_Cycle_Bm_1_00190.join();
+            A5_Cycle_Bm_1_00190.join();
+            A6_Cycle_Bm_1_00190.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00190.check() && A2_Cycle_Bm_1_00190.check() && A3_Cycle_Bm_1_00190.check() && A4_Cycle_Bm_1_00190.check() && A5_Cycle_Bm_1_00190.check() && A6_Cycle_Bm_1_00190.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/Cycle_Bm_1_00200.java b/test/testsuite/ouroboros/memory_management/Function/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/Cycle_Bm_1_00200.java
new file mode 100644
index 0000000000000000000000000000000000000000..94cab3da8cbe3f4c6675f4dfd6679c0843f4738d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/Cycle_Bm_1_00200.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00200 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00200.java
+ *- @ExecuteClass: Cycle_Bm_1_00200
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00200 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00200_A1 a1_0 = new Cycle_B_1_00200_A1();
+        a1_0.a2_0 = new Cycle_B_1_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00200_A3();
+        Cycle_B_1_00200_A4 a4_0 = new Cycle_B_1_00200_A4();
+        Cycle_B_1_00200_A5 a5_0 = new Cycle_B_1_00200_A5();
+        a1_0.a4_0 = a4_0;
+        a1_0.a5_0 = a5_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00200_A1 {
+        Cycle_B_1_00200_A2 a2_0;
+        Cycle_B_1_00200_A4 a4_0;
+        Cycle_B_1_00200_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A2 {
+        Cycle_B_1_00200_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A3 {
+        Cycle_B_1_00200_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A4() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+
+    class Cycle_B_1_00200_A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A5() {
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00200 A1_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A2_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A3_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A4_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A5_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A6_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+
+        A1_Cycle_Bm_1_00200.start();
+        A2_Cycle_Bm_1_00200.start();
+        A3_Cycle_Bm_1_00200.start();
+        A4_Cycle_Bm_1_00200.start();
+        A5_Cycle_Bm_1_00200.start();
+        A6_Cycle_Bm_1_00200.start();
+
+        try {
+            A1_Cycle_Bm_1_00200.join();
+            A2_Cycle_Bm_1_00200.join();
+            A3_Cycle_Bm_1_00200.join();
+            A4_Cycle_Bm_1_00200.join();
+            A5_Cycle_Bm_1_00200.join();
+            A6_Cycle_Bm_1_00200.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00200.check() && A2_Cycle_Bm_1_00200.check() && A3_Cycle_Bm_1_00200.check() && A4_Cycle_Bm_1_00200.check() && A5_Cycle_Bm_1_00200.check() && A6_Cycle_Bm_1_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/Cycle_Bm_1_00210.java b/test/testsuite/ouroboros/memory_management/Function/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/Cycle_Bm_1_00210.java
new file mode 100644
index 0000000000000000000000000000000000000000..d86b28b53b2d99aa9efef7519b3ec572f20e24dd
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/Cycle_Bm_1_00210.java
@@ -0,0 +1,2046 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:make Cycle_B_1_xx together to this Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00210.java
+ *- @ExecuteClass: Cycle_Bm_1_00210
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_00010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 246)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00010_A1 {
+        Cycle_B_1_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00010_A1() {
+            a1_0 = null;
+            a = 123;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00020_A1 a1_0 = new Cycle_B_1_00020_A1();
+        a1_0.a2_0 = new Cycle_B_1_00020_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 6)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00020_A1 {
+        Cycle_B_1_00020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00020_A2 {
+        Cycle_B_1_00020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00020_A2() {
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00030B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00030_A1 a1_0 = new Cycle_B_1_00030_A1();
+        a1_0.a2_0 = new Cycle_B_1_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00030_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00030_A1 {
+        Cycle_B_1_00030_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00030_A2 {
+        Cycle_B_1_00030_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00030_A3 {
+        Cycle_B_1_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00040B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00040_A1 a1_0 = new Cycle_B_1_00040_A1();
+        a1_0.a2_0 = new Cycle_B_1_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00040_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00040_A4();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00040_A1 {
+        Cycle_B_1_00040_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A2 {
+        Cycle_B_1_00040_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A3 {
+        Cycle_B_1_00040_A1 a1_0;
+        Cycle_B_1_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A4 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00050B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00050_A1 a1_0 = new Cycle_B_1_00050_A1();
+        a1_0.a2_0 = new Cycle_B_1_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00050_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00050_A4();
+        a1_0.a2_0.a5_0 = new Cycle_B_1_00050_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 34)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00050_A1 {
+        Cycle_B_1_00050_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A2 {
+        Cycle_B_1_00050_A3 a3_0;
+        Cycle_B_1_00050_A4 a4_0;
+        Cycle_B_1_00050_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A3 {
+        Cycle_B_1_00050_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A4 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+
+    class Cycle_B_1_00050_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A5() {
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00060B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00060_A1 a1_0 = new Cycle_B_1_00060_A1();
+        a1_0.a2_0 = new Cycle_B_1_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00060_A3();
+        Cycle_B_1_00060_A4 a4_0 = new Cycle_B_1_00060_A4();
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00060_A1 {
+        Cycle_B_1_00060_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A2 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A3 {
+        Cycle_B_1_00060_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A4 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00070B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00070_A1 a1_0 = new Cycle_B_1_00070_A1();
+        a1_0.a2_0 = new Cycle_B_1_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00070_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00070_A4();
+
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00070_A1 {
+        Cycle_B_1_00070_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A2 {
+        Cycle_B_1_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A3 {
+        Cycle_B_1_00070_A1 a1_0;
+        Cycle_B_1_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00080B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00080_A1 a1_0 = new Cycle_B_1_00080_A1();
+        a1_0.a2_0 = new Cycle_B_1_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00080_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00080_A4();
+        a1_0.a2_0.a3_0.a5_0 = new Cycle_B_1_00080_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 56)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00080_A1 {
+        Cycle_B_1_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00080_A2 {
+        Cycle_B_1_00080_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00080_A3 {
+        Cycle_B_1_00080_A1 a1_0;
+        Cycle_B_1_00080_A4 a4_0;
+        Cycle_B_1_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            a4_0.add();
+            a5_0.add();
+            sum = a + a1_0.a + a4_0.sum + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00080_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+
+    class Cycle_B_1_00080_A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A5() {
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00090B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00090_A1 a1_0 = new Cycle_B_1_00090_A1();
+        a1_0.a2_0 = new Cycle_B_1_00090_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00090_A3();
+        Cycle_B_1_00090_A4 a4_0 = new Cycle_B_1_00090_A4();
+        Cycle_B_1_00090_A5 a5_0 = new Cycle_B_1_00090_A5();
+        a4_0.a2_0 = a1_0.a2_0;
+        a5_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 25)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00090_A1 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A2 {
+        Cycle_B_1_00090_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A3 {
+        Cycle_B_1_00090_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A4 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A5 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00100B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00100_A1 a1_0 = new Cycle_B_1_00100_A1();
+        a1_0.a2_0 = new Cycle_B_1_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00100_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00100_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_1_00100_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00100_A1 {
+        Cycle_B_1_00100_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A2 {
+        Cycle_B_1_00100_A3 a3_0;
+        Cycle_B_1_00100_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A3 {
+        Cycle_B_1_00100_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A4 {
+
+        int a;
+        int sum;
+        Cycle_B_1_00100_A5 a5_0;
+
+        Cycle_B_1_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00100_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A5() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00110B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00110_A1 a1_0 = new Cycle_B_1_00110_A1();
+        a1_0.a2_0 = new Cycle_B_1_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00110_A3();
+        Cycle_B_1_00110_A5 a5_0 = new Cycle_B_1_00110_A5();
+        a5_0.a4_0 = new Cycle_B_1_00110_A4();
+        a5_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00110_A1 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A2 {
+        Cycle_B_1_00110_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A3 {
+        Cycle_B_1_00110_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A4 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A5 {
+        Cycle_B_1_00110_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00120B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00120_A1 a1_0 = new Cycle_B_1_00120_A1();
+        a1_0.a2_0 = new Cycle_B_1_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00120_A3();
+        Cycle_B_1_00120_A5 a5_0 = new Cycle_B_1_00120_A5();
+        a5_0.a4_0 = new Cycle_B_1_00120_A4();
+        a5_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00120_A1 {
+        Cycle_B_1_00120_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A2 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A3 {
+        Cycle_B_1_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A4 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A5 {
+        Cycle_B_1_00120_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00130B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00130_A1 a1_0 = new Cycle_B_1_00130_A1();
+        Cycle_B_1_00130_A2 a2_0 = new Cycle_B_1_00130_A2();
+        Cycle_B_1_00130_A3 a3_0 = new Cycle_B_1_00130_A3();
+        a1_0.a3_0 = a3_0;
+        a2_0.a3_0 = a3_0;
+        a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00130_A1 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A1() {
+            a3_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00130_A2 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00130_A3 {
+        Cycle_B_1_00130_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00140B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00140_A1 a1_0 = new Cycle_B_1_00140_A1();
+        a1_0.a2_0 = new Cycle_B_1_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00140_A3();
+        Cycle_B_1_00140_A4 a4_0 = new Cycle_B_1_00140_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00140_A1 {
+        Cycle_B_1_00140_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A2 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A3 {
+        Cycle_B_1_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A4 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00150B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00150_A1 a1_0 = new Cycle_B_1_00150_A1();
+        a1_0.a2_0 = new Cycle_B_1_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00150_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_1_00150_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00150_A1 {
+        Cycle_B_1_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A2 {
+        Cycle_B_1_00150_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A3 {
+        Cycle_B_1_00150_A1 a1_0;
+        Cycle_B_1_00150_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A4 {
+
+        int a;
+        int sum;
+        Cycle_B_1_00150_A5 a5_0;
+
+        Cycle_B_1_00150_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00150_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A5() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00160B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00160_A1 a1_0 = new Cycle_B_1_00160_A1();
+        a1_0.a2_0 = new Cycle_B_1_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00160_A3();
+        Cycle_B_1_00160_A4 a4_0 = new Cycle_B_1_00160_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 17)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00160_A1 {
+        Cycle_B_1_00160_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A2 {
+        Cycle_B_1_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A3 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A4 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00170B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00170_A1 a1_0 = new Cycle_B_1_00170_A1();
+        a1_0.a2_0 = new Cycle_B_1_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00170_A3();
+        Cycle_B_1_00170_A4 a4_0 = new Cycle_B_1_00170_A4();
+        Cycle_B_1_00170_A5 a5_0 = new Cycle_B_1_00170_A5();
+        a5_0.a4_0 = a4_0;
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 26)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00170_A1 {
+        Cycle_B_1_00170_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A2 {
+        Cycle_B_1_00170_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A3 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A4 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A5 {
+        Cycle_B_1_00170_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00180B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 23)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00180_A1 {
+        Cycle_B_1_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A2 {
+        Cycle_B_1_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A3 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A4 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A5 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00190B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00190_A1 a1_0 = new Cycle_B_1_00190_A1();
+        a1_0.a2_0 = new Cycle_B_1_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00190_A3();
+        Cycle_B_1_00190_A4 a4_0 = new Cycle_B_1_00190_A4();
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00190_A1 {
+        Cycle_B_1_00190_A2 a2_0;
+        Cycle_B_1_00190_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A2 {
+        Cycle_B_1_00190_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A3 {
+        Cycle_B_1_00190_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00200B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00200_A1 a1_0 = new Cycle_B_1_00200_A1();
+        a1_0.a2_0 = new Cycle_B_1_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00200_A3();
+        Cycle_B_1_00200_A4 a4_0 = new Cycle_B_1_00200_A4();
+        Cycle_B_1_00200_A5 a5_0 = new Cycle_B_1_00200_A5();
+        a1_0.a4_0 = a4_0;
+        a1_0.a5_0 = a5_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00200_A1 {
+        Cycle_B_1_00200_A2 a2_0;
+        Cycle_B_1_00200_A4 a4_0;
+        Cycle_B_1_00200_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A2 {
+        Cycle_B_1_00200_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A3 {
+        Cycle_B_1_00200_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A4() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+
+    class Cycle_B_1_00200_A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A5() {
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+
+public class Cycle_Bm_1_00210 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00010B A1_00010 = new ThreadRc_Cycle_Bm_1_00010B();
+        ThreadRc_Cycle_Bm_1_00010B A2_00010 = new ThreadRc_Cycle_Bm_1_00010B();
+        ThreadRc_Cycle_Bm_1_00020B A1_00020 = new ThreadRc_Cycle_Bm_1_00020B();
+        ThreadRc_Cycle_Bm_1_00020B A2_00020 = new ThreadRc_Cycle_Bm_1_00020B();
+        ThreadRc_Cycle_Bm_1_00030B A1_00030 = new ThreadRc_Cycle_Bm_1_00030B();
+        ThreadRc_Cycle_Bm_1_00030B A2_00030 = new ThreadRc_Cycle_Bm_1_00030B();
+        ThreadRc_Cycle_Bm_1_00040B A1_00040 = new ThreadRc_Cycle_Bm_1_00040B();
+        ThreadRc_Cycle_Bm_1_00040B A2_00040 = new ThreadRc_Cycle_Bm_1_00040B();
+        ThreadRc_Cycle_Bm_1_00050B A1_00050 = new ThreadRc_Cycle_Bm_1_00050B();
+        ThreadRc_Cycle_Bm_1_00050B A2_00050 = new ThreadRc_Cycle_Bm_1_00050B();
+        ThreadRc_Cycle_Bm_1_00060B A1_00060 = new ThreadRc_Cycle_Bm_1_00060B();
+        ThreadRc_Cycle_Bm_1_00060B A2_00060 = new ThreadRc_Cycle_Bm_1_00060B();
+        ThreadRc_Cycle_Bm_1_00070B A1_00070 = new ThreadRc_Cycle_Bm_1_00070B();
+        ThreadRc_Cycle_Bm_1_00070B A2_00070 = new ThreadRc_Cycle_Bm_1_00070B();
+        ThreadRc_Cycle_Bm_1_00080B A1_00080 = new ThreadRc_Cycle_Bm_1_00080B();
+        ThreadRc_Cycle_Bm_1_00080B A2_00080 = new ThreadRc_Cycle_Bm_1_00080B();
+        ThreadRc_Cycle_Bm_1_00090B A1_00090 = new ThreadRc_Cycle_Bm_1_00090B();
+        ThreadRc_Cycle_Bm_1_00090B A2_00090 = new ThreadRc_Cycle_Bm_1_00090B();
+        ThreadRc_Cycle_Bm_1_00100B A1_00100 = new ThreadRc_Cycle_Bm_1_00100B();
+        ThreadRc_Cycle_Bm_1_00100B A2_00100 = new ThreadRc_Cycle_Bm_1_00100B();
+        ThreadRc_Cycle_Bm_1_00110B A1_00110 = new ThreadRc_Cycle_Bm_1_00110B();
+        ThreadRc_Cycle_Bm_1_00110B A2_00110 = new ThreadRc_Cycle_Bm_1_00110B();
+        ThreadRc_Cycle_Bm_1_00120B A1_00120 = new ThreadRc_Cycle_Bm_1_00120B();
+        ThreadRc_Cycle_Bm_1_00120B A2_00120 = new ThreadRc_Cycle_Bm_1_00120B();
+        ThreadRc_Cycle_Bm_1_00130B A1_00130 = new ThreadRc_Cycle_Bm_1_00130B();
+        ThreadRc_Cycle_Bm_1_00130B A2_00130 = new ThreadRc_Cycle_Bm_1_00130B();
+        ThreadRc_Cycle_Bm_1_00140B A1_00140 = new ThreadRc_Cycle_Bm_1_00140B();
+        ThreadRc_Cycle_Bm_1_00140B A2_00140 = new ThreadRc_Cycle_Bm_1_00140B();
+        ThreadRc_Cycle_Bm_1_00150B A1_00150 = new ThreadRc_Cycle_Bm_1_00150B();
+        ThreadRc_Cycle_Bm_1_00150B A2_00150 = new ThreadRc_Cycle_Bm_1_00150B();
+        ThreadRc_Cycle_Bm_1_00160B A1_00160 = new ThreadRc_Cycle_Bm_1_00160B();
+        ThreadRc_Cycle_Bm_1_00160B A2_00160 = new ThreadRc_Cycle_Bm_1_00160B();
+        ThreadRc_Cycle_Bm_1_00170B A1_00170 = new ThreadRc_Cycle_Bm_1_00170B();
+        ThreadRc_Cycle_Bm_1_00170B A2_00170 = new ThreadRc_Cycle_Bm_1_00170B();
+        ThreadRc_Cycle_Bm_1_00180B A1_00180 = new ThreadRc_Cycle_Bm_1_00180B();
+        ThreadRc_Cycle_Bm_1_00180B A2_00180 = new ThreadRc_Cycle_Bm_1_00180B();
+        ThreadRc_Cycle_Bm_1_00190B A1_00190 = new ThreadRc_Cycle_Bm_1_00190B();
+        ThreadRc_Cycle_Bm_1_00190B A2_00190 = new ThreadRc_Cycle_Bm_1_00190B();
+        ThreadRc_Cycle_Bm_1_00200B A1_00200 = new ThreadRc_Cycle_Bm_1_00200B();
+        ThreadRc_Cycle_Bm_1_00200B A2_00200 = new ThreadRc_Cycle_Bm_1_00200B();
+        A1_00010.start();
+        A2_00010.start();
+        A1_00020.start();
+        A2_00020.start();
+        A1_00030.start();
+        A2_00030.start();
+        A1_00040.start();
+        A2_00040.start();
+        A1_00050.start();
+        A2_00050.start();
+        A1_00060.start();
+        A2_00060.start();
+        A1_00070.start();
+        A2_00070.start();
+        A1_00080.start();
+        A2_00080.start();
+        A1_00090.start();
+        A2_00090.start();
+        A1_00100.start();
+        A2_00100.start();
+        A1_00110.start();
+        A2_00110.start();
+        A1_00120.start();
+        A2_00120.start();
+        A1_00130.start();
+        A2_00130.start();
+        A1_00140.start();
+        A2_00140.start();
+        A1_00150.start();
+        A2_00150.start();
+        A1_00160.start();
+        A2_00160.start();
+        A1_00170.start();
+        A2_00170.start();
+        A1_00180.start();
+        A2_00180.start();
+        A1_00190.start();
+        A2_00190.start();
+        A1_00200.start();
+        A2_00200.start();
+        try {
+            A1_00010.join();
+            A2_00010.join();
+            A1_00020.join();
+            A2_00020.join();
+            A1_00030.join();
+            A2_00030.join();
+            A1_00040.join();
+            A2_00040.join();
+            A1_00050.join();
+            A2_00050.join();
+            A1_00060.join();
+            A2_00060.join();
+            A1_00070.join();
+            A2_00070.join();
+            A1_00080.join();
+            A2_00080.join();
+            A1_00090.join();
+            A2_00090.join();
+            A1_00100.join();
+            A2_00100.join();
+            A1_00110.join();
+            A2_00110.join();
+            A1_00120.join();
+            A2_00120.join();
+            A1_00130.join();
+            A2_00130.join();
+            A1_00140.join();
+            A2_00140.join();
+            A1_00150.join();
+            A2_00150.join();
+            A1_00160.join();
+            A2_00160.join();
+            A1_00170.join();
+            A2_00170.join();
+            A1_00180.join();
+            A2_00180.join();
+            A1_00190.join();
+            A2_00190.join();
+            A1_00200.join();
+            A2_00200.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00010.check() && A2_00010.check() && A1_00020.check() && A2_00020.check() && A1_00030.check() && A2_00030.check() && A1_00040.check() && A2_00040.check() && A1_00050.check() && A2_00050.check() && A1_00060.check() && A2_00060.check() && A1_00070.check() && A2_00070.check() && A1_00080.check() && A2_00080.check() && A1_00090.check() && A2_00090.check() && A1_00100.check() && A2_00100.check() && A1_00110.check() && A2_00110.check() && A1_00120.check() && A2_00120.check() && A1_00130.check() && A2_00130.check() && A1_00140.check() && A2_00140.check() && A1_00150.check() && A2_00150.check() && A1_00160.check() && A2_00160.check() && A1_00170.check() && A2_00170.check() && A1_00180.check() && A2_00180.check() && A1_00190.check() && A2_00190.check() && A1_00200.check() && A2_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/Cycle_Bm_1_10010.java b/test/testsuite/ouroboros/memory_management/Function/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/Cycle_Bm_1_10010.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a31a1ea660034a79771dc85936e366ec145b7cb
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/Cycle_Bm_1_10010.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_10010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_10010 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_10010.java
+ *- @ExecuteClass: Cycle_Bm_1_10010
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_10010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_10010_A1 a1_0 = new Cycle_B_1_10010_A1();
+        a1_0.a2_0 = new Cycle_B_1_10010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10010_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        Cycle_B_1_10010_2A1 a1_10 = new Cycle_B_1_10010_2A1();
+        a1_10.a2_0 = new Cycle_B_1_10010_2A2();
+        a1_10.a2_0.a3_0 = new Cycle_B_1_10010_2A3();
+        a1_10.a2_0.a3_0.a1_0 = a1_10;
+        a1_10.add();
+        a1_10.a2_0.add();
+        a1_10.a2_0.a3_0.add();
+        int nsum2 = (a1_10.sum + a1_10.a2_0.sum + a1_10.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        nsum += nsum2;
+
+        if (nsum == 24)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_10010_A1 {
+        Cycle_B_1_10010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_A2 {
+        Cycle_B_1_10010_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_A3 {
+        Cycle_B_1_10010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A1 {
+        Cycle_B_1_10010_2A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A2 {
+        Cycle_B_1_10010_2A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A3 {
+        Cycle_B_1_10010_2A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_10010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_10010 A1_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A2_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A3_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A4_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A5_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A6_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+
+        A1_Cycle_Bm_1_10010.start();
+        A2_Cycle_Bm_1_10010.start();
+        A3_Cycle_Bm_1_10010.start();
+        A4_Cycle_Bm_1_10010.start();
+        A5_Cycle_Bm_1_10010.start();
+        A6_Cycle_Bm_1_10010.start();
+
+        try {
+            A1_Cycle_Bm_1_10010.join();
+            A2_Cycle_Bm_1_10010.join();
+            A3_Cycle_Bm_1_10010.join();
+            A4_Cycle_Bm_1_10010.join();
+            A5_Cycle_Bm_1_10010.join();
+            A6_Cycle_Bm_1_10010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_10010.check() && A2_Cycle_Bm_1_10010.check() && A3_Cycle_Bm_1_10010.check() && A4_Cycle_Bm_1_10010.check() && A5_Cycle_Bm_1_10010.check() && A6_Cycle_Bm_1_10010.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/Cycle_Bm_1_10020.java b/test/testsuite/ouroboros/memory_management/Function/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/Cycle_Bm_1_10020.java
new file mode 100644
index 0000000000000000000000000000000000000000..99beca30a6a4a02c7a28f6ae757fec6e7c87bdca
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/Cycle_Bm_1_10020.java
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_10020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_10020 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_10020.java
+ *- @ExecuteClass: Cycle_Bm_1_10020
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_10020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_10020_A1 a1_0 = new Cycle_B_1_10020_A1();
+        a1_0.a2_0 = new Cycle_B_1_10020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10020_A3();
+        Cycle_B_1_10020_A4 a4_0 = new Cycle_B_1_10020_A4();
+        Cycle_B_1_10020_A5 a5_0 = new Cycle_B_1_10020_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        Cycle_B_1_10020_2A1 a1_20 = new Cycle_B_1_10020_2A1();
+        a1_20.a2_0 = new Cycle_B_1_10020_2A2();
+        a1_20.a2_0.a3_0 = new Cycle_B_1_10020_2A3();
+        Cycle_B_1_10020_2A4 a4_20 = new Cycle_B_1_10020_2A4();
+        Cycle_B_1_10020_2A5 a5_20 = new Cycle_B_1_10020_2A5();
+        a1_20.a4_0 = a4_20;
+        a1_20.a5_0 = a5_20;
+        a1_20.a2_0.a3_0.a1_0 = a1_20;
+        a1_20.add();
+        a1_20.a2_0.add();
+        a1_20.a2_0.a3_0.add();
+        a4_20.add();
+        a5_20.add();
+        int nsum1 = (a1_20.sum + a1_20.a2_0.sum + a1_20.a2_0.a3_0.sum + a4_20.sum + a5_20.sum);
+        nsum += nsum1;
+
+        if (nsum == 61)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_10020_A1 {
+        Cycle_B_1_10020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A2 {
+        Cycle_B_1_10020_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A3 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A4 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A5 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A1 {
+        Cycle_B_1_10020_2A2 a2_0;
+        Cycle_B_1_10020_2A4 a4_0;
+        Cycle_B_1_10020_2A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A2 {
+        Cycle_B_1_10020_2A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A3 {
+        Cycle_B_1_10020_2A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A4() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+
+    class Cycle_B_1_10020_2A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A5() {
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_10020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_10020 A1_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A2_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A3_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A4_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A5_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A6_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+
+        A1_Cycle_Bm_1_10020.start();
+        A2_Cycle_Bm_1_10020.start();
+        A3_Cycle_Bm_1_10020.start();
+        A4_Cycle_Bm_1_10020.start();
+        A5_Cycle_Bm_1_10020.start();
+        A6_Cycle_Bm_1_10020.start();
+
+        try {
+            A1_Cycle_Bm_1_10020.join();
+            A2_Cycle_Bm_1_10020.join();
+            A3_Cycle_Bm_1_10020.join();
+            A4_Cycle_Bm_1_10020.join();
+            A5_Cycle_Bm_1_10020.join();
+            A6_Cycle_Bm_1_10020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_10020.check() && A2_Cycle_Bm_1_10020.check() && A3_Cycle_Bm_1_10020.check() && A4_Cycle_Bm_1_10020.check() && A5_Cycle_Bm_1_10020.check() && A6_Cycle_Bm_1_10020.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/Cycle_Bm_1_10030.java b/test/testsuite/ouroboros/memory_management/Function/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/Cycle_Bm_1_10030.java
new file mode 100644
index 0000000000000000000000000000000000000000..313af618f3890b71d3392080a2aa2f6a0bb8fe07
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/Cycle_Bm_1_10030.java
@@ -0,0 +1,418 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_10030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_10030 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_10030.java
+ *- @ExecuteClass: Cycle_Bm_1_10030
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_1_10010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_10010_A1 a1_0 = new Cycle_B_1_10010_A1();
+        a1_0.a2_0 = new Cycle_B_1_10010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10010_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        Cycle_B_1_10010_2A1 a1_10 = new Cycle_B_1_10010_2A1();
+        a1_10.a2_0 = new Cycle_B_1_10010_2A2();
+        a1_10.a2_0.a3_0 = new Cycle_B_1_10010_2A3();
+        a1_10.a2_0.a3_0.a1_0 = a1_10;
+        a1_10.add();
+        a1_10.a2_0.add();
+        a1_10.a2_0.a3_0.add();
+        int nsum2 = (a1_10.sum + a1_10.a2_0.sum + a1_10.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        nsum += nsum2;
+
+        if (nsum == 24)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_10010_A1 {
+        Cycle_B_1_10010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_A2 {
+        Cycle_B_1_10010_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_A3 {
+        Cycle_B_1_10010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A1 {
+        Cycle_B_1_10010_2A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A2 {
+        Cycle_B_1_10010_2A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A3 {
+        Cycle_B_1_10010_2A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_10020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_10020_A1 a1_0 = new Cycle_B_1_10020_A1();
+        a1_0.a2_0 = new Cycle_B_1_10020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10020_A3();
+        Cycle_B_1_10020_A4 a4_0 = new Cycle_B_1_10020_A4();
+        Cycle_B_1_10020_A5 a5_0 = new Cycle_B_1_10020_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        Cycle_B_1_10020_2A1 a1_20 = new Cycle_B_1_10020_2A1();
+        a1_20.a2_0 = new Cycle_B_1_10020_2A2();
+        a1_20.a2_0.a3_0 = new Cycle_B_1_10020_2A3();
+        Cycle_B_1_10020_2A4 a4_20 = new Cycle_B_1_10020_2A4();
+        Cycle_B_1_10020_2A5 a5_20 = new Cycle_B_1_10020_2A5();
+        a1_20.a4_0 = a4_20;
+        a1_20.a5_0 = a5_20;
+        a1_20.a2_0.a3_0.a1_0 = a1_20;
+        a1_20.add();
+        a1_20.a2_0.add();
+        a1_20.a2_0.a3_0.add();
+        a4_20.add();
+        a5_20.add();
+        int nsum1 = (a1_20.sum + a1_20.a2_0.sum + a1_20.a2_0.a3_0.sum + a4_20.sum + a5_20.sum);
+        nsum += nsum1;
+
+        if (nsum == 61)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_10020_A1 {
+        Cycle_B_1_10020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A2 {
+        Cycle_B_1_10020_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A3 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A4 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A5 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A1 {
+        Cycle_B_1_10020_2A2 a2_0;
+        Cycle_B_1_10020_2A4 a4_0;
+        Cycle_B_1_10020_2A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A2 {
+        Cycle_B_1_10020_2A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A3 {
+        Cycle_B_1_10020_2A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A4() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+
+    class Cycle_B_1_10020_2A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A5() {
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+
+public class Cycle_Bm_1_10030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_10010B A1_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A2_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A3_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A4_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A5_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A6_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10020B A1_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A2_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A3_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A4_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A5_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A6_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        A1_Cycle_Bm_1_10010.start();
+        A2_Cycle_Bm_1_10010.start();
+        A3_Cycle_Bm_1_10010.start();
+        A4_Cycle_Bm_1_10010.start();
+        A5_Cycle_Bm_1_10010.start();
+        A6_Cycle_Bm_1_10010.start();
+        A1_Cycle_Bm_1_10020.start();
+        A2_Cycle_Bm_1_10020.start();
+        A3_Cycle_Bm_1_10020.start();
+        A4_Cycle_Bm_1_10020.start();
+        A5_Cycle_Bm_1_10020.start();
+        A6_Cycle_Bm_1_10020.start();
+
+        try {
+            A1_Cycle_Bm_1_10010.join();
+            A2_Cycle_Bm_1_10010.join();
+            A3_Cycle_Bm_1_10010.join();
+            A4_Cycle_Bm_1_10010.join();
+            A5_Cycle_Bm_1_10010.join();
+            A6_Cycle_Bm_1_10010.join();
+            A1_Cycle_Bm_1_10020.join();
+            A2_Cycle_Bm_1_10020.join();
+            A3_Cycle_Bm_1_10020.join();
+            A4_Cycle_Bm_1_10020.join();
+            A5_Cycle_Bm_1_10020.join();
+            A6_Cycle_Bm_1_10020.join();
+        } catch (InterruptedException e) {
+            e.getStackTrace();
+        }
+        if (A1_Cycle_Bm_1_10010.check() && A2_Cycle_Bm_1_10010.check() && A3_Cycle_Bm_1_10010.check() && A4_Cycle_Bm_1_10010.check() && A5_Cycle_Bm_1_10010.check() && A6_Cycle_Bm_1_10010.check() && A1_Cycle_Bm_1_10020.check() && A2_Cycle_Bm_1_10020.check() && A3_Cycle_Bm_1_10020.check() && A4_Cycle_Bm_1_10020.check() && A5_Cycle_Bm_1_10020.check() && A6_Cycle_Bm_1_10020.check())
+            System.out.println("ExpectResult");
+    }
+
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/Cycle_Bm_2_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/Cycle_Bm_2_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..6bb433c987414f19f497638675ff10ef961497b8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/Cycle_Bm_2_00010.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00010 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00010.java
+ *- @ExecuteClass: Cycle_Bm_2_00010
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00010_A1 a1_0 = new Cycle_B_2_00010_A1();
+        a1_0.a2_0 = new Cycle_B_2_00010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00010_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00010_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 18)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00010_A1 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A2 {
+        Cycle_B_2_00010_A3 a3_0;
+        Cycle_B_2_00010_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A3 {
+        Cycle_B_2_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A4 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00010 A1_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A2_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A3_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A4_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A5_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A6_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+
+        A1_Cycle_Bm_2_00010.start();
+        A2_Cycle_Bm_2_00010.start();
+        A3_Cycle_Bm_2_00010.start();
+        A4_Cycle_Bm_2_00010.start();
+        A5_Cycle_Bm_2_00010.start();
+        A6_Cycle_Bm_2_00010.start();
+
+        try {
+            A1_Cycle_Bm_2_00010.join();
+            A2_Cycle_Bm_2_00010.join();
+            A3_Cycle_Bm_2_00010.join();
+            A4_Cycle_Bm_2_00010.join();
+            A5_Cycle_Bm_2_00010.join();
+            A6_Cycle_Bm_2_00010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00010.check() && A2_Cycle_Bm_2_00010.check() && A3_Cycle_Bm_2_00010.check() && A4_Cycle_Bm_2_00010.check() && A5_Cycle_Bm_2_00010.check() && A6_Cycle_Bm_2_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/Cycle_Bm_2_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/Cycle_Bm_2_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2fe3691a235885cad581e369b1667bd1ffb2a38
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/Cycle_Bm_2_00020.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00020 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00020.java
+ *- @ExecuteClass: Cycle_Bm_2_00020
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00020_A1 a1_0 = new Cycle_B_2_00020_A1();
+        a1_0.a2_0 = new Cycle_B_2_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00020_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00020_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00020_A1 {
+        Cycle_B_2_00020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A2 {
+        Cycle_B_2_00020_A3 a3_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A3 {
+        Cycle_B_2_00020_A1 a1_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A4 {
+        Cycle_B_2_00020_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00020 A1_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A2_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A3_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A4_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A5_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A6_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+
+        A1_Cycle_Bm_2_00020.start();
+        A2_Cycle_Bm_2_00020.start();
+        A3_Cycle_Bm_2_00020.start();
+        A4_Cycle_Bm_2_00020.start();
+        A5_Cycle_Bm_2_00020.start();
+        A6_Cycle_Bm_2_00020.start();
+
+        try {
+            A1_Cycle_Bm_2_00020.join();
+            A2_Cycle_Bm_2_00020.join();
+            A3_Cycle_Bm_2_00020.join();
+            A4_Cycle_Bm_2_00020.join();
+            A5_Cycle_Bm_2_00020.join();
+            A6_Cycle_Bm_2_00020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00020.check() && A2_Cycle_Bm_2_00020.check() && A3_Cycle_Bm_2_00020.check() && A4_Cycle_Bm_2_00020.check() && A5_Cycle_Bm_2_00020.check() && A6_Cycle_Bm_2_00020.check())
+            System.out.println("ExpectResult");
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/Cycle_Bm_2_00030.java b/test/testsuite/ouroboros/memory_management/Function/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/Cycle_Bm_2_00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..ece163c493d60b9a6cf2821c70c41a28de5d38f7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/Cycle_Bm_2_00030.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00030 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00030.java
+ *- @ExecuteClass: Cycle_Bm_2_00030
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00030 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00030_A1 a1_0 = new Cycle_B_2_00030_A1();
+        a1_0.a2_0 = new Cycle_B_2_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00030_A3();
+        Cycle_B_2_00030_A4 a4_0 = new Cycle_B_2_00030_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00030_A1 {
+        Cycle_B_2_00030_A2 a2_0;
+        Cycle_B_2_00030_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A2 {
+        Cycle_B_2_00030_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A3 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A4 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00030 A1_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A2_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A3_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A4_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A5_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A6_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+
+        A1_Cycle_Bm_2_00030.start();
+        A2_Cycle_Bm_2_00030.start();
+        A3_Cycle_Bm_2_00030.start();
+        A4_Cycle_Bm_2_00030.start();
+        A5_Cycle_Bm_2_00030.start();
+        A6_Cycle_Bm_2_00030.start();
+
+        try {
+            A1_Cycle_Bm_2_00030.join();
+            A2_Cycle_Bm_2_00030.join();
+            A3_Cycle_Bm_2_00030.join();
+            A4_Cycle_Bm_2_00030.join();
+            A5_Cycle_Bm_2_00030.join();
+            A6_Cycle_Bm_2_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00030.check() && A2_Cycle_Bm_2_00030.check() && A3_Cycle_Bm_2_00030.check() && A4_Cycle_Bm_2_00030.check() && A5_Cycle_Bm_2_00030.check() && A6_Cycle_Bm_2_00030.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/Cycle_Bm_2_00040.java b/test/testsuite/ouroboros/memory_management/Function/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/Cycle_Bm_2_00040.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e03740f6020fb4c63731dfd38721dae830dc56e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/Cycle_Bm_2_00040.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00040 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00040.java
+ *- @ExecuteClass: Cycle_Bm_2_00040
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00040 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00040_A1 a1_0 = new Cycle_B_2_00040_A1();
+        a1_0.a2_0 = new Cycle_B_2_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00040_A3();
+        Cycle_B_2_00040_A4 a4_0 = new Cycle_B_2_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00040_A1 {
+        Cycle_B_2_00040_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A2 {
+        Cycle_B_2_00040_A3 a3_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A3 {
+        Cycle_B_2_00040_A1 a1_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A4 {
+        Cycle_B_2_00040_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00040 A1_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A2_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A3_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A4_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A5_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A6_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+
+        A1_Cycle_Bm_2_00040.start();
+        A2_Cycle_Bm_2_00040.start();
+        A3_Cycle_Bm_2_00040.start();
+        A4_Cycle_Bm_2_00040.start();
+        A5_Cycle_Bm_2_00040.start();
+        A6_Cycle_Bm_2_00040.start();
+
+        try {
+            A1_Cycle_Bm_2_00040.join();
+            A2_Cycle_Bm_2_00040.join();
+            A3_Cycle_Bm_2_00040.join();
+            A4_Cycle_Bm_2_00040.join();
+            A5_Cycle_Bm_2_00040.join();
+            A6_Cycle_Bm_2_00040.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00040.check() && A2_Cycle_Bm_2_00040.check() && A3_Cycle_Bm_2_00040.check() && A4_Cycle_Bm_2_00040.check() && A5_Cycle_Bm_2_00040.check() && A6_Cycle_Bm_2_00040.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/Cycle_Bm_2_00050.java b/test/testsuite/ouroboros/memory_management/Function/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/Cycle_Bm_2_00050.java
new file mode 100644
index 0000000000000000000000000000000000000000..686f7b289cd508b8080a5d53b86e13054ce406f3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/Cycle_Bm_2_00050.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00050 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00050.java
+ *- @ExecuteClass: Cycle_Bm_2_00050
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00050 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00050_A1 a1_0 = new Cycle_B_2_00050_A1();
+        a1_0.a2_0 = new Cycle_B_2_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00050_A3();
+        Cycle_B_2_00050_A4 a4_0 = new Cycle_B_2_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00050_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00050_A1 {
+        Cycle_B_2_00050_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A2 {
+        Cycle_B_2_00050_A3 a3_0;
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A3 {
+        Cycle_B_2_00050_A1 a1_0;
+        Cycle_B_2_00050_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A4 {
+        Cycle_B_2_00050_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A5 {
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00050 A1_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A2_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A3_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A4_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A5_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A6_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+
+        A1_Cycle_Bm_2_00050.start();
+        A2_Cycle_Bm_2_00050.start();
+        A3_Cycle_Bm_2_00050.start();
+        A4_Cycle_Bm_2_00050.start();
+        A5_Cycle_Bm_2_00050.start();
+        A6_Cycle_Bm_2_00050.start();
+
+        try {
+            A1_Cycle_Bm_2_00050.join();
+            A2_Cycle_Bm_2_00050.join();
+            A3_Cycle_Bm_2_00050.join();
+            A4_Cycle_Bm_2_00050.join();
+            A5_Cycle_Bm_2_00050.join();
+            A6_Cycle_Bm_2_00050.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00050.check() && A2_Cycle_Bm_2_00050.check() && A3_Cycle_Bm_2_00050.check() && A4_Cycle_Bm_2_00050.check() && A5_Cycle_Bm_2_00050.check() && A6_Cycle_Bm_2_00050.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/Cycle_Bm_2_00060.java b/test/testsuite/ouroboros/memory_management/Function/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/Cycle_Bm_2_00060.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f28f92ceaf33da5e5258eb80cc0c74c7bf1f41e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/Cycle_Bm_2_00060.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00060 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00060.java
+ *- @ExecuteClass: Cycle_Bm_2_00060
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00060 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00060_A1 a1_0 = new Cycle_B_2_00060_A1();
+        a1_0.a2_0 = new Cycle_B_2_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00060_A3();
+        Cycle_B_2_00060_A4 a4_0 = new Cycle_B_2_00060_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00060_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00060_A1 {
+        Cycle_B_2_00060_A2 a2_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A2 {
+        Cycle_B_2_00060_A3 a3_0;
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A3 {
+        Cycle_B_2_00060_A1 a1_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A4 {
+        Cycle_B_2_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A5 {
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00060 A1_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A2_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A3_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A4_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A5_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A6_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+
+        A1_Cycle_Bm_2_00060.start();
+        A2_Cycle_Bm_2_00060.start();
+        A3_Cycle_Bm_2_00060.start();
+        A4_Cycle_Bm_2_00060.start();
+        A5_Cycle_Bm_2_00060.start();
+        A6_Cycle_Bm_2_00060.start();
+
+        try {
+            A1_Cycle_Bm_2_00060.join();
+            A2_Cycle_Bm_2_00060.join();
+            A3_Cycle_Bm_2_00060.join();
+            A4_Cycle_Bm_2_00060.join();
+            A5_Cycle_Bm_2_00060.join();
+            A6_Cycle_Bm_2_00060.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00060.check() && A2_Cycle_Bm_2_00060.check() && A3_Cycle_Bm_2_00060.check() && A4_Cycle_Bm_2_00060.check() && A5_Cycle_Bm_2_00060.check() && A6_Cycle_Bm_2_00060.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/Cycle_Bm_2_00070.java b/test/testsuite/ouroboros/memory_management/Function/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/Cycle_Bm_2_00070.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a85cc8085beeda909ab23a7f0a336b58133440b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/Cycle_Bm_2_00070.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00070 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00070.java
+ *- @ExecuteClass: Cycle_Bm_2_00070
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00070 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00070_A1 a1_0 = new Cycle_B_2_00070_A1();
+        a1_0.a2_0 = new Cycle_B_2_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00070_A3();
+        Cycle_B_2_00070_A4 a4_0 = new Cycle_B_2_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00070_A5();
+        Cycle_B_2_00070_A6 a6_0 = new Cycle_B_2_00070_A6();
+        a6_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a6_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum + a6_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 37)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00070_A1 {
+        Cycle_B_2_00070_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A2 {
+        Cycle_B_2_00070_A3 a3_0;
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A3 {
+        Cycle_B_2_00070_A1 a1_0;
+        Cycle_B_2_00070_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A4 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A5 {
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A6 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A6() {
+            a3_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00070 A1_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A2_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A3_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A4_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A5_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A6_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+
+        A1_Cycle_Bm_2_00070.start();
+        A2_Cycle_Bm_2_00070.start();
+        A3_Cycle_Bm_2_00070.start();
+        A4_Cycle_Bm_2_00070.start();
+        A5_Cycle_Bm_2_00070.start();
+        A6_Cycle_Bm_2_00070.start();
+
+        try {
+            A1_Cycle_Bm_2_00070.join();
+            A2_Cycle_Bm_2_00070.join();
+            A3_Cycle_Bm_2_00070.join();
+            A4_Cycle_Bm_2_00070.join();
+            A5_Cycle_Bm_2_00070.join();
+            A6_Cycle_Bm_2_00070.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00070.check() && A2_Cycle_Bm_2_00070.check() && A3_Cycle_Bm_2_00070.check() && A4_Cycle_Bm_2_00070.check() && A5_Cycle_Bm_2_00070.check() && A6_Cycle_Bm_2_00070.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/Cycle_Bm_2_00080.java b/test/testsuite/ouroboros/memory_management/Function/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/Cycle_Bm_2_00080.java
new file mode 100644
index 0000000000000000000000000000000000000000..413b0a315e01de6abf3ff22b9d3e1bc893a59390
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/Cycle_Bm_2_00080.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00080 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00080.java
+ *- @ExecuteClass: Cycle_Bm_2_00080
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00080 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00080_A1 {
+        Cycle_B_2_00080_A2 a2_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A2 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A3 {
+        Cycle_B_2_00080_A1 a1_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A4 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A4() {
+            a3_0 = null;
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A5 {
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00080 A1_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A2_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A3_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A4_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A5_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A6_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+
+        A1_Cycle_Bm_2_00080.start();
+        A2_Cycle_Bm_2_00080.start();
+        A3_Cycle_Bm_2_00080.start();
+        A4_Cycle_Bm_2_00080.start();
+        A5_Cycle_Bm_2_00080.start();
+        A6_Cycle_Bm_2_00080.start();
+
+        try {
+            A1_Cycle_Bm_2_00080.join();
+            A2_Cycle_Bm_2_00080.join();
+            A3_Cycle_Bm_2_00080.join();
+            A4_Cycle_Bm_2_00080.join();
+            A5_Cycle_Bm_2_00080.join();
+            A6_Cycle_Bm_2_00080.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00080.check() && A2_Cycle_Bm_2_00080.check() && A3_Cycle_Bm_2_00080.check() && A4_Cycle_Bm_2_00080.check() && A5_Cycle_Bm_2_00080.check() && A6_Cycle_Bm_2_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/Cycle_Bm_2_00090.java b/test/testsuite/ouroboros/memory_management/Function/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/Cycle_Bm_2_00090.java
new file mode 100644
index 0000000000000000000000000000000000000000..26f640937a196f147306402f4227c86b8cdc0b68
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/Cycle_Bm_2_00090.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00090 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00090.java
+ *- @ExecuteClass: Cycle_Bm_2_00090
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00090 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00090_A1 a1_0 = new Cycle_B_2_00090_A1();
+        Cycle_B_2_00090_A3 a3_0 = new Cycle_B_2_00090_A3();
+        a1_0.a2_0 = new Cycle_B_2_00090_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a3_0.a2_0 = a1_0.a2_0;
+        a3_0.a2_0.a3_0 = a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 9)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00090_A1 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00090_A2 {
+        Cycle_B_2_00090_A1 a1_0;
+        Cycle_B_2_00090_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A2() {
+            a1_0 = null;
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00090_A3 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A3() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00090 A1_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A2_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A3_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A4_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A5_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A6_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+
+        A1_Cycle_Bm_2_00090.start();
+        A2_Cycle_Bm_2_00090.start();
+        A3_Cycle_Bm_2_00090.start();
+        A4_Cycle_Bm_2_00090.start();
+        A5_Cycle_Bm_2_00090.start();
+        A6_Cycle_Bm_2_00090.start();
+
+        try {
+            A1_Cycle_Bm_2_00090.join();
+            A2_Cycle_Bm_2_00090.join();
+            A3_Cycle_Bm_2_00090.join();
+            A4_Cycle_Bm_2_00090.join();
+            A5_Cycle_Bm_2_00090.join();
+            A6_Cycle_Bm_2_00090.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00090.check() && A2_Cycle_Bm_2_00090.check() && A3_Cycle_Bm_2_00090.check() && A4_Cycle_Bm_2_00090.check() && A5_Cycle_Bm_2_00090.check() && A6_Cycle_Bm_2_00090.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/Cycle_Bm_2_00100.java b/test/testsuite/ouroboros/memory_management/Function/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/Cycle_Bm_2_00100.java
new file mode 100644
index 0000000000000000000000000000000000000000..45cc9a3079ca35b8105a0e32cb385fc1644b707f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/Cycle_Bm_2_00100.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00100 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00100.java
+ *- @ExecuteClass: Cycle_Bm_2_00100
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00100 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00100_A1 a1_0 = new Cycle_B_2_00100_A1();
+        a1_0.a2_0 = new Cycle_B_2_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00100_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00100_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00100_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 29)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00100_A1 {
+        Cycle_B_2_00100_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A2 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A3 {
+        Cycle_B_2_00100_A1 a1_0;
+        Cycle_B_2_00100_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A4 {
+        Cycle_B_2_00100_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A5 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00100 A1_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A2_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A3_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A4_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A5_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A6_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+
+        A1_Cycle_Bm_2_00100.start();
+        A2_Cycle_Bm_2_00100.start();
+        A3_Cycle_Bm_2_00100.start();
+        A4_Cycle_Bm_2_00100.start();
+        A5_Cycle_Bm_2_00100.start();
+        A6_Cycle_Bm_2_00100.start();
+
+        try {
+            A1_Cycle_Bm_2_00100.join();
+            A2_Cycle_Bm_2_00100.join();
+            A3_Cycle_Bm_2_00100.join();
+            A4_Cycle_Bm_2_00100.join();
+            A5_Cycle_Bm_2_00100.join();
+            A6_Cycle_Bm_2_00100.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00100.check() && A2_Cycle_Bm_2_00100.check() && A3_Cycle_Bm_2_00100.check() && A4_Cycle_Bm_2_00100.check() && A5_Cycle_Bm_2_00100.check() && A6_Cycle_Bm_2_00100.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/Cycle_Bm_2_00110.java b/test/testsuite/ouroboros/memory_management/Function/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/Cycle_Bm_2_00110.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9f2a39382c3a128859db5dab4a08a342d34cecc
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/Cycle_Bm_2_00110.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00110 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00110.java
+ *- @ExecuteClass: Cycle_Bm_2_00110
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00110 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00110_A1 a1_0 = new Cycle_B_2_00110_A1();
+        a1_0.a2_0 = new Cycle_B_2_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00110_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00110_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_2_00110_A5();
+        a1_0.a2_0.a4_0.a5_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00110_A1 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A2 {
+        Cycle_B_2_00110_A3 a3_0;
+        Cycle_B_2_00110_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A3 {
+        Cycle_B_2_00110_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A4 {
+        Cycle_B_2_00110_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A5 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00110 A1_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A2_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A3_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A4_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A5_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A6_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+
+        A1_Cycle_Bm_2_00110.start();
+        A2_Cycle_Bm_2_00110.start();
+        A3_Cycle_Bm_2_00110.start();
+        A4_Cycle_Bm_2_00110.start();
+        A5_Cycle_Bm_2_00110.start();
+        A6_Cycle_Bm_2_00110.start();
+
+        try {
+            A1_Cycle_Bm_2_00110.join();
+            A2_Cycle_Bm_2_00110.join();
+            A3_Cycle_Bm_2_00110.join();
+            A4_Cycle_Bm_2_00110.join();
+            A5_Cycle_Bm_2_00110.join();
+            A6_Cycle_Bm_2_00110.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00110.check() && A2_Cycle_Bm_2_00110.check() && A3_Cycle_Bm_2_00110.check() && A4_Cycle_Bm_2_00110.check() && A5_Cycle_Bm_2_00110.check() && A6_Cycle_Bm_2_00110.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/Cycle_Bm_2_00120.java b/test/testsuite/ouroboros/memory_management/Function/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/Cycle_Bm_2_00120.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d0059311c15005625983595b0b200d6652af1a7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/Cycle_Bm_2_00120.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00120 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00120.java
+ *- @ExecuteClass: Cycle_Bm_2_00120
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00120 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00120_A1 a1_0 = new Cycle_B_2_00120_A1();
+        a1_0.a2_0 = new Cycle_B_2_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00120_A3();
+        a1_0.a4_0 = new Cycle_B_2_00120_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a4_0.a5_0 = new Cycle_B_2_00120_A5();
+        a1_0.a4_0.a5_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a4_0.add();
+        a1_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a4_0.sum + a1_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00120_A1 {
+        Cycle_B_2_00120_A2 a2_0;
+        Cycle_B_2_00120_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A2 {
+        Cycle_B_2_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A3 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A4 {
+        Cycle_B_2_00120_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A5 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00120 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00120 A1_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A2_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A3_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A4_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A5_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A6_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+
+        A1_Cycle_Bm_2_00120.start();
+        A2_Cycle_Bm_2_00120.start();
+        A3_Cycle_Bm_2_00120.start();
+        A4_Cycle_Bm_2_00120.start();
+        A5_Cycle_Bm_2_00120.start();
+        A6_Cycle_Bm_2_00120.start();
+
+        try {
+            A1_Cycle_Bm_2_00120.join();
+            A2_Cycle_Bm_2_00120.join();
+            A3_Cycle_Bm_2_00120.join();
+            A4_Cycle_Bm_2_00120.join();
+            A5_Cycle_Bm_2_00120.join();
+            A6_Cycle_Bm_2_00120.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00120.check() && A2_Cycle_Bm_2_00120.check() && A3_Cycle_Bm_2_00120.check() && A4_Cycle_Bm_2_00120.check() && A5_Cycle_Bm_2_00120.check() && A6_Cycle_Bm_2_00120.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/Cycle_Bm_2_00130.java b/test/testsuite/ouroboros/memory_management/Function/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/Cycle_Bm_2_00130.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea2a34088c1242d18b28c3ab1a7ba915556e802b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/Cycle_Bm_2_00130.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00130 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00130.java
+ *- @ExecuteClass: Cycle_Bm_2_00130
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00130 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00130_A1 a1_0 = new Cycle_B_2_00130_A1();
+        a1_0.a2_0 = new Cycle_B_2_00130_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00130_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00130_A4();
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        Cycle_B_2_00130_A5 a5_0 = new Cycle_B_2_00130_A5();
+        a1_0.a2_0.a3_0.a4_0.a6_0 = new Cycle_B_2_00130_A6();
+        a1_0.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_0;
+        a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a6_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a5_0.sum + a1_0.a2_0.a3_0.a4_0.a6_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 45)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00130_A1 {
+        Cycle_B_2_00130_A2 a2_0;
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A2 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A3 {
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A4 {
+        Cycle_B_2_00130_A1 a1_0;
+        Cycle_B_2_00130_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A5 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A6 {
+        Cycle_B_2_00130_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00130 A1_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A2_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A3_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A4_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A5_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A6_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+
+        A1_Cycle_Bm_2_00130.start();
+        A2_Cycle_Bm_2_00130.start();
+        A3_Cycle_Bm_2_00130.start();
+        A4_Cycle_Bm_2_00130.start();
+        A5_Cycle_Bm_2_00130.start();
+        A6_Cycle_Bm_2_00130.start();
+
+        try {
+            A1_Cycle_Bm_2_00130.join();
+            A2_Cycle_Bm_2_00130.join();
+            A3_Cycle_Bm_2_00130.join();
+            A4_Cycle_Bm_2_00130.join();
+            A5_Cycle_Bm_2_00130.join();
+            A6_Cycle_Bm_2_00130.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00130.check() && A2_Cycle_Bm_2_00130.check() && A3_Cycle_Bm_2_00130.check() && A4_Cycle_Bm_2_00130.check() && A5_Cycle_Bm_2_00130.check() && A6_Cycle_Bm_2_00130.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/Cycle_Bm_2_00140.java b/test/testsuite/ouroboros/memory_management/Function/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/Cycle_Bm_2_00140.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab958f0a21844b7c9618f9bef4066d05de65949c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/Cycle_Bm_2_00140.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00140 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00140.java
+ *- @ExecuteClass: Cycle_Bm_2_00140
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00140 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00140_A1 a1_0 = new Cycle_B_2_00140_A1();
+        a1_0.a2_0 = new Cycle_B_2_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00140_A3();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00140_A1 {
+        Cycle_B_2_00140_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00140_A2 {
+        Cycle_B_2_00140_A3 a3_0;
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A2() {
+            a3_0 = null;
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00140_A3 {
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00140 A1_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A2_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A3_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A4_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A5_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A6_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+
+        A1_Cycle_Bm_2_00140.start();
+        A2_Cycle_Bm_2_00140.start();
+        A3_Cycle_Bm_2_00140.start();
+        A4_Cycle_Bm_2_00140.start();
+        A5_Cycle_Bm_2_00140.start();
+        A6_Cycle_Bm_2_00140.start();
+
+        try {
+            A1_Cycle_Bm_2_00140.join();
+            A2_Cycle_Bm_2_00140.join();
+            A3_Cycle_Bm_2_00140.join();
+            A4_Cycle_Bm_2_00140.join();
+            A5_Cycle_Bm_2_00140.join();
+            A6_Cycle_Bm_2_00140.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00140.check() && A2_Cycle_Bm_2_00140.check() && A3_Cycle_Bm_2_00140.check() && A4_Cycle_Bm_2_00140.check() && A5_Cycle_Bm_2_00140.check() && A6_Cycle_Bm_2_00140.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/Cycle_Bm_2_00150.java b/test/testsuite/ouroboros/memory_management/Function/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/Cycle_Bm_2_00150.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f25a6ed36e517ea314ea508c8b5434a3ca4149d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/Cycle_Bm_2_00150.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00150 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00150.java
+ *- @ExecuteClass: Cycle_Bm_2_00150
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00150 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00150_A1 a1_0 = new Cycle_B_2_00150_A1();
+        a1_0.a2_0 = new Cycle_B_2_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 14)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00150_A1 {
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00150_A2 {
+        Cycle_B_2_00150_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00150_A3 {
+        Cycle_B_2_00150_A1 a1_0;
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00150 A1_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A2_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A3_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A4_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A5_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A6_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+
+        A1_Cycle_Bm_2_00150.start();
+        A2_Cycle_Bm_2_00150.start();
+        A3_Cycle_Bm_2_00150.start();
+        A4_Cycle_Bm_2_00150.start();
+        A5_Cycle_Bm_2_00150.start();
+        A6_Cycle_Bm_2_00150.start();
+
+        try {
+            A1_Cycle_Bm_2_00150.join();
+            A2_Cycle_Bm_2_00150.join();
+            A3_Cycle_Bm_2_00150.join();
+            A4_Cycle_Bm_2_00150.join();
+            A5_Cycle_Bm_2_00150.join();
+            A6_Cycle_Bm_2_00150.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00150.check() && A2_Cycle_Bm_2_00150.check() && A3_Cycle_Bm_2_00150.check() && A4_Cycle_Bm_2_00150.check() && A5_Cycle_Bm_2_00150.check() && A6_Cycle_Bm_2_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/Cycle_Bm_2_00160.java b/test/testsuite/ouroboros/memory_management/Function/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/Cycle_Bm_2_00160.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a3569a8611d6ac59c0e9308b8106def38fd6663
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/Cycle_Bm_2_00160.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00160 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00160.java
+ *- @ExecuteClass: Cycle_Bm_2_00160
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00160 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00160_A1 a1_0 = new Cycle_B_2_00160_A1();
+        a1_0.a2_0 = new Cycle_B_2_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00160_A3();
+        a1_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00160_A1 {
+        Cycle_B_2_00160_A2 a2_0;
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00160_A2 {
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00160_A3 {
+        Cycle_B_2_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00160 A1_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A2_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A3_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A4_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A5_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A6_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+
+        A1_Cycle_Bm_2_00160.start();
+        A2_Cycle_Bm_2_00160.start();
+        A3_Cycle_Bm_2_00160.start();
+        A4_Cycle_Bm_2_00160.start();
+        A5_Cycle_Bm_2_00160.start();
+        A6_Cycle_Bm_2_00160.start();
+
+        try {
+            A1_Cycle_Bm_2_00160.join();
+            A2_Cycle_Bm_2_00160.join();
+            A3_Cycle_Bm_2_00160.join();
+            A4_Cycle_Bm_2_00160.join();
+            A5_Cycle_Bm_2_00160.join();
+            A6_Cycle_Bm_2_00160.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00160.check() && A2_Cycle_Bm_2_00160.check() && A3_Cycle_Bm_2_00160.check() && A4_Cycle_Bm_2_00160.check() && A5_Cycle_Bm_2_00160.check() && A6_Cycle_Bm_2_00160.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/Cycle_Bm_2_00170.java b/test/testsuite/ouroboros/memory_management/Function/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/Cycle_Bm_2_00170.java
new file mode 100644
index 0000000000000000000000000000000000000000..787004e7f3fefd68217b8016d4364aa4b28a3248
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/Cycle_Bm_2_00170.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00170 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00170.java
+ *- @ExecuteClass: Cycle_Bm_2_00170
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00170 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00170_A1 a1_0 = new Cycle_B_2_00170_A1();
+        a1_0.a2_0 = new Cycle_B_2_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00170_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00170_A4();
+        a1_0.a2_0.a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00170_A1 {
+        Cycle_B_2_00170_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A2 {
+        Cycle_B_2_00170_A3 a3_0;
+        Cycle_B_2_00170_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A3 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A4 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00170 A1_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A2_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A3_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A4_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A5_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A6_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+
+        A1_Cycle_Bm_2_00170.start();
+        A2_Cycle_Bm_2_00170.start();
+        A3_Cycle_Bm_2_00170.start();
+        A4_Cycle_Bm_2_00170.start();
+        A5_Cycle_Bm_2_00170.start();
+        A6_Cycle_Bm_2_00170.start();
+
+        try {
+            A1_Cycle_Bm_2_00170.join();
+            A2_Cycle_Bm_2_00170.join();
+            A3_Cycle_Bm_2_00170.join();
+            A4_Cycle_Bm_2_00170.join();
+            A5_Cycle_Bm_2_00170.join();
+            A6_Cycle_Bm_2_00170.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00170.check() && A2_Cycle_Bm_2_00170.check() && A3_Cycle_Bm_2_00170.check() && A4_Cycle_Bm_2_00170.check() && A5_Cycle_Bm_2_00170.check() && A6_Cycle_Bm_2_00170.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/Cycle_Bm_2_00180.java b/test/testsuite/ouroboros/memory_management/Function/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/Cycle_Bm_2_00180.java
new file mode 100644
index 0000000000000000000000000000000000000000..690eb34102ecf3d133917d975733410187e62f85
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/Cycle_Bm_2_00180.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00180 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00180.java
+ *- @ExecuteClass: Cycle_Bm_2_00180
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00180_A1 a1_0 = new Cycle_B_2_00180_A1();
+        a1_0.a2_0 = new Cycle_B_2_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00180_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00180_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00180_A1 {
+        Cycle_B_2_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A2 {
+        Cycle_B_2_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A3 {
+        Cycle_B_2_00180_A1 a1_0;
+        Cycle_B_2_00180_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A4 {
+        Cycle_B_2_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00180 A1_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A2_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A3_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A4_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A5_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A6_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+
+        A1_Cycle_Bm_2_00180.start();
+        A2_Cycle_Bm_2_00180.start();
+        A3_Cycle_Bm_2_00180.start();
+        A4_Cycle_Bm_2_00180.start();
+        A5_Cycle_Bm_2_00180.start();
+        A6_Cycle_Bm_2_00180.start();
+
+        try {
+            A1_Cycle_Bm_2_00180.join();
+            A2_Cycle_Bm_2_00180.join();
+            A3_Cycle_Bm_2_00180.join();
+            A4_Cycle_Bm_2_00180.join();
+            A5_Cycle_Bm_2_00180.join();
+            A6_Cycle_Bm_2_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00180.check() && A2_Cycle_Bm_2_00180.check() && A3_Cycle_Bm_2_00180.check() && A4_Cycle_Bm_2_00180.check() && A5_Cycle_Bm_2_00180.check() && A6_Cycle_Bm_2_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/Cycle_Bm_2_00190.java b/test/testsuite/ouroboros/memory_management/Function/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/Cycle_Bm_2_00190.java
new file mode 100644
index 0000000000000000000000000000000000000000..62d38a639058936fcb29ce9e29fd1a34f6cea91c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/Cycle_Bm_2_00190.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00190 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00190.java
+ *- @ExecuteClass: Cycle_Bm_2_00190
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00190 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00190_A1 a1_0 = new Cycle_B_2_00190_A1();
+        a1_0.a2_0 = new Cycle_B_2_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00190_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00190_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00190_A1 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A2 {
+        Cycle_B_2_00190_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A3 {
+        Cycle_B_2_00190_A1 a1_0;
+        Cycle_B_2_00190_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A4 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00190 A1_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A2_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A3_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A4_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A5_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A6_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+
+        A1_Cycle_Bm_2_00190.start();
+        A2_Cycle_Bm_2_00190.start();
+        A3_Cycle_Bm_2_00190.start();
+        A4_Cycle_Bm_2_00190.start();
+        A5_Cycle_Bm_2_00190.start();
+        A6_Cycle_Bm_2_00190.start();
+
+        try {
+            A1_Cycle_Bm_2_00190.join();
+            A2_Cycle_Bm_2_00190.join();
+            A3_Cycle_Bm_2_00190.join();
+            A4_Cycle_Bm_2_00190.join();
+            A5_Cycle_Bm_2_00190.join();
+            A6_Cycle_Bm_2_00190.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00190.check() && A2_Cycle_Bm_2_00190.check() && A3_Cycle_Bm_2_00190.check() && A4_Cycle_Bm_2_00190.check() && A5_Cycle_Bm_2_00190.check() && A6_Cycle_Bm_2_00190.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/Cycle_Bm_2_00200.java b/test/testsuite/ouroboros/memory_management/Function/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/Cycle_Bm_2_00200.java
new file mode 100644
index 0000000000000000000000000000000000000000..f93b5246fdd60d1b6a0bebc685405f4fdd26a5a1
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/Cycle_Bm_2_00200.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00200 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00200.java
+ *- @ExecuteClass: Cycle_Bm_2_00200
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00200 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00200_A1 a1_0 = new Cycle_B_2_00200_A1();
+        a1_0.a2_0 = new Cycle_B_2_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00200_A3();
+        Cycle_B_2_00200_A4 a4_0 = new Cycle_B_2_00200_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00200_A1 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A2 {
+        Cycle_B_2_00200_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A3 {
+        Cycle_B_2_00200_A1 a1_0;
+        Cycle_B_2_00200_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A4 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00200 A1_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A2_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A3_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A4_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A5_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A6_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+
+        A1_Cycle_Bm_2_00200.start();
+        A2_Cycle_Bm_2_00200.start();
+        A3_Cycle_Bm_2_00200.start();
+        A4_Cycle_Bm_2_00200.start();
+        A5_Cycle_Bm_2_00200.start();
+        A6_Cycle_Bm_2_00200.start();
+
+        try {
+            A1_Cycle_Bm_2_00200.join();
+            A2_Cycle_Bm_2_00200.join();
+            A3_Cycle_Bm_2_00200.join();
+            A4_Cycle_Bm_2_00200.join();
+            A5_Cycle_Bm_2_00200.join();
+            A6_Cycle_Bm_2_00200.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00200.check() && A2_Cycle_Bm_2_00200.check() && A3_Cycle_Bm_2_00200.check() && A4_Cycle_Bm_2_00200.check() && A5_Cycle_Bm_2_00200.check() && A6_Cycle_Bm_2_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/Cycle_Bm_2_00210.java b/test/testsuite/ouroboros/memory_management/Function/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/Cycle_Bm_2_00210.java
new file mode 100644
index 0000000000000000000000000000000000000000..d28db74be03794470d92f18c3f0373cb6398d0f8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/Cycle_Bm_2_00210.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00210 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00210.java
+ *- @ExecuteClass: Cycle_Bm_2_00210
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00210 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00210_A1 a1_0 = new Cycle_B_2_00210_A1();
+        a1_0.a2_0 = new Cycle_B_2_00210_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00210_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00210_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00210_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00210_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0 = new Cycle_B_2_00210_A8();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0 = new Cycle_B_2_00210_A9();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00210_A7();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00210_A1 {
+        Cycle_B_2_00210_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A2 {
+        Cycle_B_2_00210_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A3 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A4 {
+        Cycle_B_2_00210_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A5 {
+        Cycle_B_2_00210_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A6 {
+        Cycle_B_2_00210_A1 a1_0;
+        Cycle_B_2_00210_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A6() {
+            a1_0 = null;
+            a8_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A8 {
+        Cycle_B_2_00210_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A9 {
+        Cycle_B_2_00210_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A7 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00210 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00210 A1_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A2_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A3_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A4_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A5_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A6_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+
+        A1_Cycle_Bm_2_00210.start();
+        A2_Cycle_Bm_2_00210.start();
+        A3_Cycle_Bm_2_00210.start();
+        A4_Cycle_Bm_2_00210.start();
+        A5_Cycle_Bm_2_00210.start();
+        A6_Cycle_Bm_2_00210.start();
+
+        try {
+            A1_Cycle_Bm_2_00210.join();
+            A2_Cycle_Bm_2_00210.join();
+            A3_Cycle_Bm_2_00210.join();
+            A4_Cycle_Bm_2_00210.join();
+            A5_Cycle_Bm_2_00210.join();
+            A6_Cycle_Bm_2_00210.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00210.check() && A2_Cycle_Bm_2_00210.check() && A3_Cycle_Bm_2_00210.check() && A4_Cycle_Bm_2_00210.check() && A5_Cycle_Bm_2_00210.check() && A6_Cycle_Bm_2_00210.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/Cycle_Bm_2_00220.java b/test/testsuite/ouroboros/memory_management/Function/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/Cycle_Bm_2_00220.java
new file mode 100644
index 0000000000000000000000000000000000000000..510cee920223760ac04a47d8f1ab227888645976
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/Cycle_Bm_2_00220.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00220.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00220 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00220.java
+ *- @ExecuteClass: Cycle_Bm_2_00220
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00220 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00220_A1 a1_0 = new Cycle_B_2_00220_A1();
+        a1_0.a2_0 = new Cycle_B_2_00220_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00220_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00220_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00220_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00220_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a8_0 = new Cycle_B_2_00220_A8();
+        a1_0.a8_0.a9_0 = new Cycle_B_2_00220_A9();
+        a1_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00220_A7();
+        a1_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a8_0.add();
+        a1_0.a8_0.a9_0.add();
+        a1_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a8_0.sum + a1_0.a8_0.a9_0.sum + a1_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00220_A1 {
+        Cycle_B_2_00220_A2 a2_0;
+        Cycle_B_2_00220_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A1() {
+            a2_0 = null;
+            a8_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A2 {
+        Cycle_B_2_00220_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A3 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A4 {
+        Cycle_B_2_00220_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A5 {
+        Cycle_B_2_00220_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A6 {
+        Cycle_B_2_00220_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A6() {
+            a1_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A8 {
+        Cycle_B_2_00220_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A9 {
+        Cycle_B_2_00220_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A7 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00220 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00220 A1_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A2_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A3_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A4_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A5_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A6_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+
+        A1_Cycle_Bm_2_00220.start();
+        A2_Cycle_Bm_2_00220.start();
+        A3_Cycle_Bm_2_00220.start();
+        A4_Cycle_Bm_2_00220.start();
+        A5_Cycle_Bm_2_00220.start();
+        A6_Cycle_Bm_2_00220.start();
+
+        try {
+            A1_Cycle_Bm_2_00220.join();
+            A2_Cycle_Bm_2_00220.join();
+            A3_Cycle_Bm_2_00220.join();
+            A4_Cycle_Bm_2_00220.join();
+            A5_Cycle_Bm_2_00220.join();
+            A6_Cycle_Bm_2_00220.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00220.check() && A2_Cycle_Bm_2_00220.check() && A3_Cycle_Bm_2_00220.check() && A4_Cycle_Bm_2_00220.check() && A5_Cycle_Bm_2_00220.check() && A6_Cycle_Bm_2_00220.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/Cycle_Bm_2_00230.java b/test/testsuite/ouroboros/memory_management/Function/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/Cycle_Bm_2_00230.java
new file mode 100644
index 0000000000000000000000000000000000000000..1578a5bbc7b2fda8c144f17011b7bd67d7f70a38
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/Cycle_Bm_2_00230.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00230.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00230 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00230.java
+ *- @ExecuteClass: Cycle_Bm_2_00230
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00230 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        //System.out.println(nsum);
+
+        if (nsum == 97)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00230_A1 {
+        Cycle_B_2_00230_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A2 {
+        Cycle_B_2_00230_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A3 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A4 {
+        Cycle_B_2_00230_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A5 {
+        Cycle_B_2_00230_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A6 {
+        Cycle_B_2_00230_A1 a1_0;
+        Cycle_B_2_00230_A10 a10_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A6() {
+            a1_0 = null;
+            a10_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A8 {
+        Cycle_B_2_00230_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A9 {
+        Cycle_B_2_00230_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A7 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A10 {
+        Cycle_B_2_00230_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A10() {
+            a8_0 = null;
+            a = 10;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00230 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00230 A1_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A2_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A3_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A4_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A5_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A6_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+
+        A1_Cycle_Bm_2_00230.start();
+        A2_Cycle_Bm_2_00230.start();
+        A3_Cycle_Bm_2_00230.start();
+        A4_Cycle_Bm_2_00230.start();
+        A5_Cycle_Bm_2_00230.start();
+        A6_Cycle_Bm_2_00230.start();
+
+        try {
+            A1_Cycle_Bm_2_00230.join();
+            A2_Cycle_Bm_2_00230.join();
+            A3_Cycle_Bm_2_00230.join();
+            A4_Cycle_Bm_2_00230.join();
+            A5_Cycle_Bm_2_00230.join();
+            A6_Cycle_Bm_2_00230.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00230.check() && A2_Cycle_Bm_2_00230.check() && A3_Cycle_Bm_2_00230.check() && A4_Cycle_Bm_2_00230.check() && A5_Cycle_Bm_2_00230.check() && A6_Cycle_Bm_2_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/Cycle_Bm_2_00240.java b/test/testsuite/ouroboros/memory_management/Function/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/Cycle_Bm_2_00240.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd816ef6a5ef989eb1898d90b79839c55643a601
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/Cycle_Bm_2_00240.java
@@ -0,0 +1,2763 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Make Cycle_B_2_00240 together to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00240.java
+ *- @ExecuteClass: Cycle_Bm_2_00240
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_00010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00010_A1 a1_0 = new Cycle_B_2_00010_A1();
+        a1_0.a2_0 = new Cycle_B_2_00010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00010_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00010_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 18)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00010_A1 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A2 {
+        Cycle_B_2_00010_A3 a3_0;
+        Cycle_B_2_00010_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A3 {
+        Cycle_B_2_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A4 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00020_A1 a1_0 = new Cycle_B_2_00020_A1();
+        a1_0.a2_0 = new Cycle_B_2_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00020_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00020_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00020_A1 {
+        Cycle_B_2_00020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A2 {
+        Cycle_B_2_00020_A3 a3_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A3 {
+        Cycle_B_2_00020_A1 a1_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A4 {
+        Cycle_B_2_00020_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00030B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00030_A1 a1_0 = new Cycle_B_2_00030_A1();
+        a1_0.a2_0 = new Cycle_B_2_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00030_A3();
+        Cycle_B_2_00030_A4 a4_0 = new Cycle_B_2_00030_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00030_A1 {
+        Cycle_B_2_00030_A2 a2_0;
+        Cycle_B_2_00030_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A2 {
+        Cycle_B_2_00030_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A3 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A4 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00040B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00040_A1 a1_0 = new Cycle_B_2_00040_A1();
+        a1_0.a2_0 = new Cycle_B_2_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00040_A3();
+        Cycle_B_2_00040_A4 a4_0 = new Cycle_B_2_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00040_A1 {
+        Cycle_B_2_00040_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A2 {
+        Cycle_B_2_00040_A3 a3_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A3 {
+        Cycle_B_2_00040_A1 a1_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A4 {
+        Cycle_B_2_00040_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00050B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00050_A1 a1_0 = new Cycle_B_2_00050_A1();
+        a1_0.a2_0 = new Cycle_B_2_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00050_A3();
+        Cycle_B_2_00050_A4 a4_0 = new Cycle_B_2_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00050_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00050_A1 {
+        Cycle_B_2_00050_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A2 {
+        Cycle_B_2_00050_A3 a3_0;
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A3 {
+        Cycle_B_2_00050_A1 a1_0;
+        Cycle_B_2_00050_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A4 {
+        Cycle_B_2_00050_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A5 {
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00060B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00060_A1 a1_0 = new Cycle_B_2_00060_A1();
+        a1_0.a2_0 = new Cycle_B_2_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00060_A3();
+        Cycle_B_2_00060_A4 a4_0 = new Cycle_B_2_00060_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00060_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00060_A1 {
+        Cycle_B_2_00060_A2 a2_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A2 {
+        Cycle_B_2_00060_A3 a3_0;
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A3 {
+        Cycle_B_2_00060_A1 a1_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A4 {
+        Cycle_B_2_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A5 {
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00070B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00070_A1 a1_0 = new Cycle_B_2_00070_A1();
+        a1_0.a2_0 = new Cycle_B_2_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00070_A3();
+        Cycle_B_2_00070_A4 a4_0 = new Cycle_B_2_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00070_A5();
+        Cycle_B_2_00070_A6 a6_0 = new Cycle_B_2_00070_A6();
+        a6_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a6_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum + a6_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 37)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00070_A1 {
+        Cycle_B_2_00070_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A2 {
+        Cycle_B_2_00070_A3 a3_0;
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A3 {
+        Cycle_B_2_00070_A1 a1_0;
+        Cycle_B_2_00070_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A4 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A5 {
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A6 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A6() {
+            a3_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00080B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00080_A1 {
+        Cycle_B_2_00080_A2 a2_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A2 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A3 {
+        Cycle_B_2_00080_A1 a1_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A4 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A4() {
+            a3_0 = null;
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A5 {
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00090B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00090_A1 a1_0 = new Cycle_B_2_00090_A1();
+        Cycle_B_2_00090_A3 a3_0 = new Cycle_B_2_00090_A3();
+        a1_0.a2_0 = new Cycle_B_2_00090_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a3_0.a2_0 = a1_0.a2_0;
+        a3_0.a2_0.a3_0 = a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 9)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00090_A1 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00090_A2 {
+        Cycle_B_2_00090_A1 a1_0;
+        Cycle_B_2_00090_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A2() {
+            a1_0 = null;
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00090_A3 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A3() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00100B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00100_A1 a1_0 = new Cycle_B_2_00100_A1();
+        a1_0.a2_0 = new Cycle_B_2_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00100_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00100_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00100_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 29)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00100_A1 {
+        Cycle_B_2_00100_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A2 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A3 {
+        Cycle_B_2_00100_A1 a1_0;
+        Cycle_B_2_00100_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A4 {
+        Cycle_B_2_00100_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A5 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00110B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00110_A1 a1_0 = new Cycle_B_2_00110_A1();
+        a1_0.a2_0 = new Cycle_B_2_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00110_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00110_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_2_00110_A5();
+        a1_0.a2_0.a4_0.a5_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00110_A1 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A2 {
+        Cycle_B_2_00110_A3 a3_0;
+        Cycle_B_2_00110_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A3 {
+        Cycle_B_2_00110_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A4 {
+        Cycle_B_2_00110_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A5 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00120B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00120_A1 a1_0 = new Cycle_B_2_00120_A1();
+        a1_0.a2_0 = new Cycle_B_2_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00120_A3();
+        a1_0.a4_0 = new Cycle_B_2_00120_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a4_0.a5_0 = new Cycle_B_2_00120_A5();
+        a1_0.a4_0.a5_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a4_0.add();
+        a1_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a4_0.sum + a1_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00120_A1 {
+        Cycle_B_2_00120_A2 a2_0;
+        Cycle_B_2_00120_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A2 {
+        Cycle_B_2_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A3 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A4 {
+        Cycle_B_2_00120_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A5 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00130B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00130_A1 a1_0 = new Cycle_B_2_00130_A1();
+        a1_0.a2_0 = new Cycle_B_2_00130_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00130_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00130_A4();
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        Cycle_B_2_00130_A5 a5_0 = new Cycle_B_2_00130_A5();
+        a1_0.a2_0.a3_0.a4_0.a6_0 = new Cycle_B_2_00130_A6();
+        a1_0.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_0;
+        a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a6_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a5_0.sum + a1_0.a2_0.a3_0.a4_0.a6_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 45)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00130_A1 {
+        Cycle_B_2_00130_A2 a2_0;
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A2 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A3 {
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A4 {
+        Cycle_B_2_00130_A1 a1_0;
+        Cycle_B_2_00130_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A5 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A6 {
+        Cycle_B_2_00130_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00140B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00140_A1 a1_0 = new Cycle_B_2_00140_A1();
+        a1_0.a2_0 = new Cycle_B_2_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00140_A3();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00140_A1 {
+        Cycle_B_2_00140_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00140_A2 {
+        Cycle_B_2_00140_A3 a3_0;
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A2() {
+            a3_0 = null;
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00140_A3 {
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00150B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00150_A1 a1_0 = new Cycle_B_2_00150_A1();
+        a1_0.a2_0 = new Cycle_B_2_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 14)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00150_A1 {
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00150_A2 {
+        Cycle_B_2_00150_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00150_A3 {
+        Cycle_B_2_00150_A1 a1_0;
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00160B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00160_A1 a1_0 = new Cycle_B_2_00160_A1();
+        a1_0.a2_0 = new Cycle_B_2_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00160_A3();
+        a1_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00160_A1 {
+        Cycle_B_2_00160_A2 a2_0;
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00160_A2 {
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00160_A3 {
+        Cycle_B_2_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+class ThreadRc_Cycle_Bm_2_00170B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00170_A1 a1_0 = new Cycle_B_2_00170_A1();
+        a1_0.a2_0 = new Cycle_B_2_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00170_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00170_A4();
+        a1_0.a2_0.a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00170_A1 {
+        Cycle_B_2_00170_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A2 {
+        Cycle_B_2_00170_A3 a3_0;
+        Cycle_B_2_00170_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A3 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A4 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00180B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00180_A1 a1_0 = new Cycle_B_2_00180_A1();
+        a1_0.a2_0 = new Cycle_B_2_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00180_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00180_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00180_A1 {
+        Cycle_B_2_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A2 {
+        Cycle_B_2_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A3 {
+        Cycle_B_2_00180_A1 a1_0;
+        Cycle_B_2_00180_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A4 {
+        Cycle_B_2_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00190B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00190_A1 a1_0 = new Cycle_B_2_00190_A1();
+        a1_0.a2_0 = new Cycle_B_2_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00190_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00190_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00190_A1 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A2 {
+        Cycle_B_2_00190_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A3 {
+        Cycle_B_2_00190_A1 a1_0;
+        Cycle_B_2_00190_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A4 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+class ThreadRc_Cycle_Bm_2_00200B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00200_A1 a1_0 = new Cycle_B_2_00200_A1();
+        a1_0.a2_0 = new Cycle_B_2_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00200_A3();
+        Cycle_B_2_00200_A4 a4_0 = new Cycle_B_2_00200_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00200_A1 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A2 {
+        Cycle_B_2_00200_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A3 {
+        Cycle_B_2_00200_A1 a1_0;
+        Cycle_B_2_00200_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A4 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+class ThreadRc_Cycle_Bm_2_00210B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00210_A1 a1_0 = new Cycle_B_2_00210_A1();
+        a1_0.a2_0 = new Cycle_B_2_00210_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00210_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00210_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00210_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00210_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0 = new Cycle_B_2_00210_A8();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0 = new Cycle_B_2_00210_A9();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00210_A7();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00210_A1 {
+        Cycle_B_2_00210_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A2 {
+        Cycle_B_2_00210_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A3 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A4 {
+        Cycle_B_2_00210_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A5 {
+        Cycle_B_2_00210_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A6 {
+        Cycle_B_2_00210_A1 a1_0;
+        Cycle_B_2_00210_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A6() {
+            a1_0 = null;
+            a8_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A8 {
+        Cycle_B_2_00210_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A9 {
+        Cycle_B_2_00210_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A7 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00220B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00220_A1 a1_0 = new Cycle_B_2_00220_A1();
+        a1_0.a2_0 = new Cycle_B_2_00220_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00220_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00220_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00220_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00220_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a8_0 = new Cycle_B_2_00220_A8();
+        a1_0.a8_0.a9_0 = new Cycle_B_2_00220_A9();
+        a1_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00220_A7();
+        a1_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a8_0.add();
+        a1_0.a8_0.a9_0.add();
+        a1_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a8_0.sum + a1_0.a8_0.a9_0.sum + a1_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00220_A1 {
+        Cycle_B_2_00220_A2 a2_0;
+        Cycle_B_2_00220_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A1() {
+            a2_0 = null;
+            a8_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A2 {
+        Cycle_B_2_00220_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A3 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A4 {
+        Cycle_B_2_00220_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A5 {
+        Cycle_B_2_00220_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A6 {
+        Cycle_B_2_00220_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A6() {
+            a1_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A8 {
+        Cycle_B_2_00220_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A9 {
+        Cycle_B_2_00220_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A7 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00230B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        //System.out.println(nsum);
+
+        if (nsum == 97)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00230_A1 {
+        Cycle_B_2_00230_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A2 {
+        Cycle_B_2_00230_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A3 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A4 {
+        Cycle_B_2_00230_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A5 {
+        Cycle_B_2_00230_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A6 {
+        Cycle_B_2_00230_A1 a1_0;
+        Cycle_B_2_00230_A10 a10_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A6() {
+            a1_0 = null;
+            a10_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A8 {
+        Cycle_B_2_00230_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A9 {
+        Cycle_B_2_00230_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A7 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A10 {
+        Cycle_B_2_00230_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A10() {
+            a8_0 = null;
+            a = 10;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+public class Cycle_Bm_2_00240 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00010B A1_00010 = new ThreadRc_Cycle_Bm_2_00010B();
+        ThreadRc_Cycle_Bm_2_00010B A2_00010 = new ThreadRc_Cycle_Bm_2_00010B();
+        ThreadRc_Cycle_Bm_2_00020B A1_00020 = new ThreadRc_Cycle_Bm_2_00020B();
+        ThreadRc_Cycle_Bm_2_00020B A2_00020 = new ThreadRc_Cycle_Bm_2_00020B();
+        ThreadRc_Cycle_Bm_2_00030B A1_00030 = new ThreadRc_Cycle_Bm_2_00030B();
+        ThreadRc_Cycle_Bm_2_00030B A2_00030 = new ThreadRc_Cycle_Bm_2_00030B();
+        ThreadRc_Cycle_Bm_2_00040B A1_00040 = new ThreadRc_Cycle_Bm_2_00040B();
+        ThreadRc_Cycle_Bm_2_00040B A2_00040 = new ThreadRc_Cycle_Bm_2_00040B();
+        ThreadRc_Cycle_Bm_2_00050B A1_00050 = new ThreadRc_Cycle_Bm_2_00050B();
+        ThreadRc_Cycle_Bm_2_00050B A2_00050 = new ThreadRc_Cycle_Bm_2_00050B();
+        ThreadRc_Cycle_Bm_2_00060B A1_00060 = new ThreadRc_Cycle_Bm_2_00060B();
+        ThreadRc_Cycle_Bm_2_00060B A2_00060 = new ThreadRc_Cycle_Bm_2_00060B();
+        ThreadRc_Cycle_Bm_2_00070B A1_00070 = new ThreadRc_Cycle_Bm_2_00070B();
+        ThreadRc_Cycle_Bm_2_00070B A2_00070 = new ThreadRc_Cycle_Bm_2_00070B();
+        ThreadRc_Cycle_Bm_2_00080B A1_00080 = new ThreadRc_Cycle_Bm_2_00080B();
+        ThreadRc_Cycle_Bm_2_00080B A2_00080 = new ThreadRc_Cycle_Bm_2_00080B();
+        ThreadRc_Cycle_Bm_2_00090B A1_00090 = new ThreadRc_Cycle_Bm_2_00090B();
+        ThreadRc_Cycle_Bm_2_00090B A2_00090 = new ThreadRc_Cycle_Bm_2_00090B();
+        ThreadRc_Cycle_Bm_2_00100B A1_00100 = new ThreadRc_Cycle_Bm_2_00100B();
+        ThreadRc_Cycle_Bm_2_00100B A2_00100 = new ThreadRc_Cycle_Bm_2_00100B();
+        ThreadRc_Cycle_Bm_2_00110B A1_00110 = new ThreadRc_Cycle_Bm_2_00110B();
+        ThreadRc_Cycle_Bm_2_00110B A2_00110 = new ThreadRc_Cycle_Bm_2_00110B();
+        ThreadRc_Cycle_Bm_2_00120B A1_00120 = new ThreadRc_Cycle_Bm_2_00120B();
+        ThreadRc_Cycle_Bm_2_00120B A2_00120 = new ThreadRc_Cycle_Bm_2_00120B();
+        ThreadRc_Cycle_Bm_2_00130B A1_00130 = new ThreadRc_Cycle_Bm_2_00130B();
+        ThreadRc_Cycle_Bm_2_00130B A2_00130 = new ThreadRc_Cycle_Bm_2_00130B();
+        ThreadRc_Cycle_Bm_2_00140B A1_00140 = new ThreadRc_Cycle_Bm_2_00140B();
+        ThreadRc_Cycle_Bm_2_00140B A2_00140 = new ThreadRc_Cycle_Bm_2_00140B();
+        ThreadRc_Cycle_Bm_2_00150B A1_00150 = new ThreadRc_Cycle_Bm_2_00150B();
+        ThreadRc_Cycle_Bm_2_00150B A2_00150 = new ThreadRc_Cycle_Bm_2_00150B();
+        ThreadRc_Cycle_Bm_2_00160B A1_00160 = new ThreadRc_Cycle_Bm_2_00160B();
+        ThreadRc_Cycle_Bm_2_00160B A2_00160 = new ThreadRc_Cycle_Bm_2_00160B();
+        ThreadRc_Cycle_Bm_2_00170B A1_00170 = new ThreadRc_Cycle_Bm_2_00170B();
+        ThreadRc_Cycle_Bm_2_00170B A2_00170 = new ThreadRc_Cycle_Bm_2_00170B();
+        ThreadRc_Cycle_Bm_2_00180B A1_00180 = new ThreadRc_Cycle_Bm_2_00180B();
+        ThreadRc_Cycle_Bm_2_00180B A2_00180 = new ThreadRc_Cycle_Bm_2_00180B();
+        ThreadRc_Cycle_Bm_2_00190B A1_00190 = new ThreadRc_Cycle_Bm_2_00190B();
+        ThreadRc_Cycle_Bm_2_00190B A2_00190 = new ThreadRc_Cycle_Bm_2_00190B();
+        ThreadRc_Cycle_Bm_2_00200B A1_00200 = new ThreadRc_Cycle_Bm_2_00200B();
+        ThreadRc_Cycle_Bm_2_00200B A2_00200 = new ThreadRc_Cycle_Bm_2_00200B();
+        ThreadRc_Cycle_Bm_2_00210B A1_00210 = new ThreadRc_Cycle_Bm_2_00210B();
+        ThreadRc_Cycle_Bm_2_00210B A2_00210 = new ThreadRc_Cycle_Bm_2_00210B();
+        ThreadRc_Cycle_Bm_2_00220B A1_00220 = new ThreadRc_Cycle_Bm_2_00220B();
+        ThreadRc_Cycle_Bm_2_00220B A2_00220 = new ThreadRc_Cycle_Bm_2_00220B();
+        ThreadRc_Cycle_Bm_2_00230B A1_00230 = new ThreadRc_Cycle_Bm_2_00230B();
+        ThreadRc_Cycle_Bm_2_00230B A2_00230 = new ThreadRc_Cycle_Bm_2_00230B();
+        A1_00010.start();
+        A2_00010.start();
+        A1_00020.start();
+        A2_00020.start();
+        A1_00030.start();
+        A2_00030.start();
+        A1_00040.start();
+        A2_00040.start();
+        A1_00050.start();
+        A2_00050.start();
+        A1_00060.start();
+        A2_00060.start();
+        A1_00070.start();
+        A2_00070.start();
+        A1_00080.start();
+        A2_00080.start();
+        A1_00090.start();
+        A2_00090.start();
+        A1_00100.start();
+        A2_00100.start();
+        A1_00110.start();
+        A2_00110.start();
+        A1_00120.start();
+        A2_00120.start();
+        A1_00130.start();
+        A2_00130.start();
+        A1_00140.start();
+        A2_00140.start();
+        A1_00150.start();
+        A2_00150.start();
+        A1_00160.start();
+        A2_00160.start();
+        A1_00170.start();
+        A2_00170.start();
+        A1_00180.start();
+        A2_00180.start();
+        A1_00190.start();
+        A2_00190.start();
+        A1_00200.start();
+        A2_00200.start();
+        A1_00210.start();
+        A2_00210.start();
+        A1_00220.start();
+        A2_00220.start();
+        A1_00230.start();
+        A2_00230.start();
+        try {
+            A1_00010.join();
+            A2_00010.join();
+            A1_00020.join();
+            A2_00020.join();
+            A1_00030.join();
+            A2_00030.join();
+            A1_00040.join();
+            A2_00040.join();
+            A1_00050.join();
+            A2_00050.join();
+            A1_00060.join();
+            A2_00060.join();
+            A1_00070.join();
+            A2_00070.join();
+            A1_00080.join();
+            A2_00080.join();
+            A1_00090.join();
+            A2_00090.join();
+            A1_00100.join();
+            A2_00100.join();
+            A1_00110.join();
+            A2_00110.join();
+            A1_00120.join();
+            A2_00120.join();
+            A1_00130.join();
+            A2_00130.join();
+            A1_00140.join();
+            A2_00140.join();
+            A1_00150.join();
+            A2_00150.join();
+            A1_00160.join();
+            A2_00160.join();
+            A1_00170.join();
+            A2_00170.join();
+            A1_00180.join();
+            A2_00180.join();
+            A1_00190.join();
+            A2_00190.join();
+            A1_00200.join();
+            A2_00200.join();
+            A1_00210.join();
+            A2_00210.join();
+            A1_00220.join();
+            A2_00220.join();
+            A1_00230.join();
+            A2_00230.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00010.check() && A2_00010.check() && A1_00020.check() && A2_00020.check() && A1_00030.check() && A2_00030.check() && A1_00040.check() && A2_00040.check() && A1_00050.check() && A2_00050.check() && A1_00060.check() && A2_00060.check() && A1_00070.check() && A2_00070.check() && A1_00080.check() && A2_00080.check() && A1_00090.check() && A2_00090.check() && A1_00100.check() && A2_00100.check() && A1_00110.check() && A2_00110.check() && A1_00120.check() && A2_00120.check() && A1_00130.check() && A2_00130.check() && A1_00140.check() && A2_00140.check() && A1_00150.check() && A2_00150.check() && A1_00160.check() && A2_00160.check() && A1_00170.check() && A2_00170.check() && A1_00180.check() && A2_00180.check() && A1_00190.check() && A2_00190.check() && A1_00200.check() && A2_00200.check() && A1_00210.check() && A2_00210.check() && A1_00220.check() && A2_00220.check() && A1_00230.check() && A2_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/Cycle_Bm_2_10240.java b/test/testsuite/ouroboros/memory_management/Function/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/Cycle_Bm_2_10240.java
new file mode 100644
index 0000000000000000000000000000000000000000..7666fd7acbcd3b47a3ebdcff48848cf733d95904
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/Cycle_Bm_2_10240.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_10240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Make Cycle_B_2_10240 together to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_10240.java
+ *- @ExecuteClass: Cycle_Bm_2_10240
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Cycle_Bm_2_10240 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00240_A1 a1_main = new Cycle_B_2_00240_A1("a1_main");
+        a1_main.a2_0 = new Cycle_B_2_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_B_2_00240_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_B_2_00240_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        Cycle_B_2_00240_B1 b1_0 = new Cycle_B_2_00240_B1();
+        b1_0.a3_0 = new Cycle_B_2_00240_A3("a3_b1");
+        b1_0.b2_0 = new Cycle_B_2_00240_B2();
+        b1_0.c2_0 = new Nocycle_B_2_00240_C2("c2_b1");
+        b1_0.b2_0.b1_0 = b1_0;
+        b1_0.add();
+        b1_0.b2_0.add();
+
+        int nsum = (b1_0.sum + b1_0.b2_0.sum);
+        // System.out.println(nsum);
+
+
+        Nocycle_B_2_00240_C1 c1_main = new Nocycle_B_2_00240_C1("c1_main");
+        c1_main.c2_0 = new Nocycle_B_2_00240_C2("c2_0");
+        c1_main.add();
+        c1_main.c2_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",c1_main.sum+c1_main.b1_0.sum);
+        int result2 = c1_main.sum + c1_main.c2_0.sum;
+        //System.out.println("RC-Testing_Result="+result2);
+
+        if (result == 1124 && nsum == 310 && result2 == 704)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00240_A1 {
+        Cycle_B_2_00240_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_B_2_00240_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_A2 {
+        Cycle_B_2_00240_A1 a1_0;
+        Cycle_B_2_00240_A3 a3_0;
+        Cycle_B_2_00240_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_B_2_00240_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_A3 {
+        Cycle_B_2_00240_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_B_2_00240_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_A4 {
+        Cycle_B_2_00240_A1 a1_0;
+        Cycle_B_2_00240_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_B_2_00240_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_B1 {
+        Cycle_B_2_00240_A3 a3_0;
+        Cycle_B_2_00240_B2 b2_0;
+        Nocycle_B_2_00240_C2 c2_0;
+
+
+        int a;
+        int sum;
+
+        Cycle_B_2_00240_B1() {
+            a3_0 = null;
+            b2_0 = null;
+            c2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_B2 {
+        Cycle_B_2_00240_B1 b1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00240_B2() {
+            b1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_B_2_00240_C1 {
+        Nocycle_B_2_00240_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_B_2_00240_C1(String strObjectName) {
+            c2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + c2_0.a;
+        }
+    }
+
+    class Nocycle_B_2_00240_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_B_2_00240_C2(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_10240 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_10240 A1_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A2_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A3_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A4_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A5_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A6_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+
+        A1_Cycle_Bm_2_10240.start();
+        A2_Cycle_Bm_2_10240.start();
+        A3_Cycle_Bm_2_10240.start();
+        A4_Cycle_Bm_2_10240.start();
+        A5_Cycle_Bm_2_10240.start();
+        A6_Cycle_Bm_2_10240.start();
+
+        try {
+            A1_Cycle_Bm_2_10240.join();
+            A2_Cycle_Bm_2_10240.join();
+            A3_Cycle_Bm_2_10240.join();
+            A4_Cycle_Bm_2_10240.join();
+            A5_Cycle_Bm_2_10240.join();
+            A6_Cycle_Bm_2_10240.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_10240.check() && A2_Cycle_Bm_2_10240.check() && A3_Cycle_Bm_2_10240.check() && A4_Cycle_Bm_2_10240.check() && A5_Cycle_Bm_2_10240.check() && A6_Cycle_Bm_2_10240.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/Nocycle_am_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/Nocycle_am_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..01646065ce4c31077fcc268f05850f6cdeb12210
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/Nocycle_am_00020.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00020 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00020.java
+ *- @ExecuteClass: Nocycle_am_00020
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00020_A1 a1_main = new Nocycle_a_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00020_B2("b2_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 1310)
+            checkout = true;
+        //System.out.println(checkout);
+
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00020_A1 {
+        Nocycle_a_00020_B1 b1_0;
+        Nocycle_a_00020_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00020 A1_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A2_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A3_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A4_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A5_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A6_00020 = new ThreadRc_00020();
+
+        A1_00020.start();
+        A2_00020.start();
+        A3_00020.start();
+        A4_00020.start();
+        A5_00020.start();
+        A6_00020.start();
+        try {
+            A1_00020.join();
+            A2_00020.join();
+            A3_00020.join();
+            A4_00020.join();
+            A5_00020.join();
+            A6_00020.join();
+        } catch (InterruptedException e) {
+        }
+
+        if (A1_00020.check() && A2_00020.check() && A3_00020.check() && A4_00020.check() && A5_00020.check() && A6_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/Nocycle_am_00030.java b/test/testsuite/ouroboros/memory_management/Function/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/Nocycle_am_00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..0df29a5815c47ae7829fcf44b1576618fe56207d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/Nocycle_am_00030.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00030 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00030.java
+ *- @ExecuteClass: Nocycle_am_00030
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00030 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00030_A1 a1_main = new Nocycle_a_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00030_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00030_B3("b3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 1919)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00030_A1 {
+        Nocycle_a_00030_B1 b1_0;
+        Nocycle_a_00030_B2 b2_0;
+        Nocycle_a_00030_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00030_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00030_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00030_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00030 A1_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A2_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A3_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A4_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A5_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A6_00030 = new ThreadRc_00030();
+
+        A1_00030.start();
+        A2_00030.start();
+        A3_00030.start();
+        A4_00030.start();
+        A5_00030.start();
+        A6_00030.start();
+        try {
+            A1_00030.join();
+            A2_00030.join();
+            A3_00030.join();
+            A4_00030.join();
+            A5_00030.join();
+            A6_00030.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00030.check() && A2_00030.check() && A3_00030.check() && A4_00030.check() && A5_00030.check() && A6_00030.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/Nocycle_am_00040.java b/test/testsuite/ouroboros/memory_management/Function/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/Nocycle_am_00040.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd31094d1a124a9ce4b14fde4b3b0eb49e60ca74
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/Nocycle_am_00040.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00040 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00040.java
+ *- @ExecuteClass: Nocycle_am_00040
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00040 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00040_A1 a1_main = new Nocycle_a_00040_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00040_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00040_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00040_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00040_B4("b4_0");
+        a1_main.b5_0 = new Nocycle_a_00040_B5("b5_0");
+        a1_main.b6_0 = new Nocycle_a_00040_B6("b6_0");
+        a1_main.b7_0 = new Nocycle_a_00040_B7("b7_0");
+        a1_main.b8_0 = new Nocycle_a_00040_B8("b8_0");
+        a1_main.b9_0 = new Nocycle_a_00040_B9("b9_0");
+        a1_main.b10_0 = new Nocycle_a_00040_B10("b10_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b5_0.add();
+        a1_main.b6_0.add();
+        a1_main.b7_0.add();
+        a1_main.b8_0.add();
+        a1_main.b9_0.add();
+        a1_main.b10_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b5_0.sum+a1_main.b6_0.sum+a1_main.b7_0.sum+a1_main.b8_0.sum+a1_main.b9_0.sum+a1_main.b10_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b5_0.sum + a1_main.b6_0.sum + a1_main.b7_0.sum + a1_main.b8_0.sum + a1_main.b9_0.sum + a1_main.b10_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 6266)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00040_A1 {
+        Nocycle_a_00040_B1 b1_0;
+        Nocycle_a_00040_B2 b2_0;
+        Nocycle_a_00040_B3 b3_0;
+        Nocycle_a_00040_B4 b4_0;
+        Nocycle_a_00040_B5 b5_0;
+        Nocycle_a_00040_B6 b6_0;
+        Nocycle_a_00040_B7 b7_0;
+        Nocycle_a_00040_B8 b8_0;
+        Nocycle_a_00040_B9 b9_0;
+        Nocycle_a_00040_B10 b10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            b5_0 = null;
+            b6_0 = null;
+            b7_0 = null;
+            b8_0 = null;
+            b9_0 = null;
+            b10_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + b5_0.a + b6_0.a + b7_0.a + b8_0.a + b9_0.a + b10_0.a;
+        }
+    }
+
+    class Nocycle_a_00040_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B5 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B5(String strObjectName) {
+            a = 205;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B6 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B6(String strObjectName) {
+            a = 206;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B7(String strObjectName) {
+            a = 207;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B8 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B8(String strObjectName) {
+            a = 208;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B9 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B9(String strObjectName) {
+            a = 209;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B10 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B10(String strObjectName) {
+            a = 210;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00040 A1_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A2_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A3_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A4_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A5_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A6_00040 = new ThreadRc_00040();
+
+        A1_00040.start();
+        A2_00040.start();
+        A3_00040.start();
+        A4_00040.start();
+        A5_00040.start();
+        A6_00040.start();
+        try {
+            A1_00040.join();
+            A2_00040.join();
+            A3_00040.join();
+            A4_00040.join();
+            A5_00040.join();
+            A6_00040.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00040.check() && A2_00040.check() && A3_00040.check() && A4_00040.check() && A5_00040.check() && A6_00040.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/Nocycle_am_00050.java b/test/testsuite/ouroboros/memory_management/Function/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/Nocycle_am_00050.java
new file mode 100644
index 0000000000000000000000000000000000000000..e550305e978eea5ec761ed5b1a4658cef8d825a2
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/Nocycle_am_00050.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00050 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00050.java
+ *- @ExecuteClass: Nocycle_am_00050
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00050 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00050_A1 a1_main = new Nocycle_a_00050_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00050_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00050_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_a_00050_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_a_00050_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_a_00050_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00050_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00050_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        a1_main.b1_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c2_0.sum+a1_main.b1_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum + a1_main.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 5048)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00050_A1 {
+        Nocycle_a_00050_B1 b1_0;
+        Nocycle_a_00050_B2 b2_0;
+        Nocycle_a_00050_B3 b3_0;
+        Nocycle_a_00050_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00050_B1 {
+        Nocycle_a_00050_C1 c1_0;
+        Nocycle_a_00050_C2 c2_0;
+        Nocycle_a_00050_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00050_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00050 A1_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A2_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A3_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A4_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A5_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A6_00050 = new ThreadRc_00050();
+
+        A1_00050.start();
+        A2_00050.start();
+        A3_00050.start();
+        A4_00050.start();
+        A5_00050.start();
+        A6_00050.start();
+        try {
+            A1_00050.join();
+            A2_00050.join();
+            A3_00050.join();
+            A4_00050.join();
+            A5_00050.join();
+            A6_00050.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00050.check() && A2_00050.check() && A3_00050.check() && A4_00050.check() && A5_00050.check() && A6_00050.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/Nocycle_am_00060.java b/test/testsuite/ouroboros/memory_management/Function/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/Nocycle_am_00060.java
new file mode 100644
index 0000000000000000000000000000000000000000..83a7c3adddcad8aa118a85275e19ae3b4b15be55
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/Nocycle_am_00060.java
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00060 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00060.java
+ *- @ExecuteClass: Nocycle_am_00060
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00060 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00060_A1 a1_main = new Nocycle_a_00060_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00060_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00060_B2("b2_0");
+        a1_main.b2_0.c1_0 = new Nocycle_a_00060_C1("c1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00060_C2("c2_0");
+        a1_main.b2_0.c3_0 = new Nocycle_a_00060_C3("c3_0");
+        a1_main.b3_0 = new Nocycle_a_00060_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00060_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c1_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b2_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c1_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b2_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c1_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b2_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 5047)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00060_A1 {
+        Nocycle_a_00060_B1 b1_0;
+        Nocycle_a_00060_B2 b2_0;
+        Nocycle_a_00060_B3 b3_0;
+        Nocycle_a_00060_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00060_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_B2 {
+        Nocycle_a_00060_C1 c1_0;
+        Nocycle_a_00060_C2 c2_0;
+        Nocycle_a_00060_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B2(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00060_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_00060 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00060 A1_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A2_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A3_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A4_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A5_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A6_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A7_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A8_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A9_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A10_00060 = new ThreadRc_00060();
+
+        A1_00060.start();
+        A2_00060.start();
+        A3_00060.start();
+        A4_00060.start();
+        A5_00060.start();
+        A6_00060.start();
+        A7_00060.start();
+        A8_00060.start();
+        A9_00060.start();
+        A10_00060.start();
+
+        try {
+            A1_00060.join();
+            A2_00060.join();
+            A3_00060.join();
+            A4_00060.join();
+            A5_00060.join();
+            A6_00060.join();
+            A7_00060.join();
+            A8_00060.join();
+            A9_00060.join();
+            A10_00060.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00060.check() && A2_00060.check() && A3_00060.check() && A4_00060.check() && A5_00060.check() && A6_00060.check() && A7_00060.check() && A8_00060.check() && A9_00060.check() && A10_00060.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/Nocycle_am_00070.java b/test/testsuite/ouroboros/memory_management/Function/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/Nocycle_am_00070.java
new file mode 100644
index 0000000000000000000000000000000000000000..631b98fc845618f581fe69b4c3f0ecdce73ee922
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/Nocycle_am_00070.java
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00070 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00070.java
+ *- @ExecuteClass: Nocycle_am_00070
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00070 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00070_A1 a1_main = new Nocycle_a_00070_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00070_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00070_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00070_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00070_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_00070_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_00070_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00070_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 5045)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00070_A1 {
+        Nocycle_a_00070_B1 b1_0;
+        Nocycle_a_00070_B2 b2_0;
+        Nocycle_a_00070_B3 b3_0;
+        Nocycle_a_00070_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00070_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B4 {
+        Nocycle_a_00070_C1 c1_0;
+        Nocycle_a_00070_C2 c2_0;
+        Nocycle_a_00070_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00070_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00070 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00070 A1_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A2_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A3_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A4_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A5_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A6_00070 = new ThreadRc_00070();
+
+        A1_00070.start();
+        A2_00070.start();
+        A3_00070.start();
+        A4_00070.start();
+        A5_00070.start();
+        A6_00070.start();
+
+        try {
+            A1_00070.join();
+            A2_00070.join();
+            A3_00070.join();
+            A4_00070.join();
+            A5_00070.join();
+            A6_00070.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00070.check() && A2_00070.check() && A3_00070.check() && A4_00070.check() && A5_00070.check() && A6_00070.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/Nocycle_am_00080.java b/test/testsuite/ouroboros/memory_management/Function/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/Nocycle_am_00080.java
new file mode 100644
index 0000000000000000000000000000000000000000..062194a08062da469948cd7a2f929a3e56bdf0b3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/Nocycle_am_00080.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00080 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00080.java
+ *- @ExecuteClass: Nocycle_am_00080
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00080 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00080_A1 a1_main = new Nocycle_a_00080_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00080_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00080_C1("c1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 1406)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00080_A1 {
+        Nocycle_a_00080_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00080_B1 {
+        Nocycle_a_00080_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00080_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_00080 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00080 A1_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A2_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A3_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A4_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A5_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A6_00080 = new ThreadRc_00080();
+
+        A1_00080.start();
+        A2_00080.start();
+        A3_00080.start();
+        A4_00080.start();
+        A5_00080.start();
+        A6_00080.start();
+        try {
+            A1_00080.join();
+            A2_00080.join();
+            A3_00080.join();
+            A4_00080.join();
+            A5_00080.join();
+            A6_00080.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00080.check() && A2_00080.check() && A3_00080.check() && A4_00080.check() && A5_00080.check() && A6_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/Nocycle_am_00090.java b/test/testsuite/ouroboros/memory_management/Function/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/Nocycle_am_00090.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd00468d3ff7b2ec55a959df4e50b0bb5f6651a5
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/Nocycle_am_00090.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00090 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00090.java
+ *- @ExecuteClass: Nocycle_am_00090
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00090 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00090_A1 a1_main = new Nocycle_a_00090_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00090_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00090_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00090_D1("d1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2308)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00090_A1 {
+        Nocycle_a_00090_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_B1 {
+        Nocycle_a_00090_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_C1 {
+        Nocycle_a_00090_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00090 A1_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A2_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A3_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A4_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A5_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A6_00090 = new ThreadRc_00090();
+
+        A1_00090.start();
+        A2_00090.start();
+        A3_00090.start();
+        A4_00090.start();
+        A5_00090.start();
+        A6_00090.start();
+
+        try {
+            A1_00090.join();
+            A2_00090.join();
+            A3_00090.join();
+            A4_00090.join();
+            A5_00090.join();
+            A6_00090.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00090.check() && A2_00090.check() && A3_00090.check() && A4_00090.check() && A5_00090.check() && A6_00090.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/Nocycle_am_00100.java b/test/testsuite/ouroboros/memory_management/Function/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/Nocycle_am_00100.java
new file mode 100644
index 0000000000000000000000000000000000000000..56536474eab9d7a7c66a4eaa554f724716d6de3d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/Nocycle_am_00100.java
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00100 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00100.java
+ *- @ExecuteClass: Nocycle_am_00100
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00100 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00100_A1 a1_main = new Nocycle_a_00100_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00100_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00100_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00100_D1("d1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_00100_E1("e1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_00100_F1("f1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_00100_G1("g1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_00100_H1("h1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_00100_I1("i1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_00100_J1("j1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+//         System.out.printf("a=%d\n",a1_main.sum);
+//         System.out.printf("b=%d\n",a1_main.b1_0.sum);
+//         System.out.printf("c=%d\n",a1_main.b1_0.c1_0.sum);
+//         System.out.printf("d=%d\n",a1_main.b1_0.c1_0.d1_0.sum);
+//         System.out.printf("e=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.sum);
+//         System.out.printf("f=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum);
+//         System.out.printf("g=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum);
+//         System.out.printf("h=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum);
+//         System.out.printf("i=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum);
+//         System.out.printf("j=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 11920)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00100_A1 {
+        Nocycle_a_00100_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_B1 {
+        Nocycle_a_00100_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_C1 {
+        Nocycle_a_00100_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_D1 {
+        Nocycle_a_00100_E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_E1 {
+        Nocycle_a_00100_F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_F1 {
+        Nocycle_a_00100_G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_G1 {
+        Nocycle_a_00100_H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_H1 {
+        Nocycle_a_00100_I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_I1 {
+        Nocycle_a_00100_J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_J1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00100 A1_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A2_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A3_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A4_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A5_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A6_00100 = new ThreadRc_00100();
+
+        A1_00100.start();
+        A2_00100.start();
+        A3_00100.start();
+        A4_00100.start();
+        A5_00100.start();
+        A6_00100.start();
+
+        try {
+            A1_00100.join();
+            A2_00100.join();
+            A3_00100.join();
+            A4_00100.join();
+            A5_00100.join();
+            A6_00100.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00100.check() && A2_00100.check() && A3_00100.check() && A4_00100.check() && A5_00100.check() && A6_00100.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/Nocycle_am_00110.java b/test/testsuite/ouroboros/memory_management/Function/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/Nocycle_am_00110.java
new file mode 100644
index 0000000000000000000000000000000000000000..919abd889e021266c048b4ecddc1304935a40ab0
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/Nocycle_am_00110.java
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00110 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00110.java
+ *- @ExecuteClass: Nocycle_am_00110
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00110 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00110_A1 a1_main = new Nocycle_a_00110_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00110_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00110_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00110_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00110_B4("b4_0");
+        a1_main.b1_0.d1_0 = new Nocycle_a_00110_D1("d1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00110_C2("c2_0");
+        a1_main.b3_0.c1_0 = new Nocycle_a_00110_C1("c1_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00110_C3("c3_0");
+        a1_main.b3_0.c1_0.d2_0 = new Nocycle_a_00110_D2("d2_0");
+        a1_main.b2_0.c2_0.d3_0 = new Nocycle_a_00110_D3("d3_0");
+        a1_main.b2_0.c2_0.d4_0 = new Nocycle_a_00110_D4("d4_0");
+        a1_main.d5_0 = new Nocycle_a_00110_D5("d5_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b3_0.c1_0.add();
+        a1_main.b4_0.c3_0.add();
+        a1_main.b1_0.d1_0.add();
+        a1_main.b3_0.c1_0.d2_0.add();
+        a1_main.b2_0.c2_0.d3_0.add();
+        a1_main.b2_0.c2_0.d4_0.add();
+        a1_main.d5_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b3_0.c1_0.sum+a1_main.b4_0.c3_0.sum+a1_main.b1_0.d1_0.sum+a1_main.b3_0.c1_0.d2_0.sum+a1_main.b2_0.c2_0.d3_0.sum+a1_main.b2_0.c2_0.d4_0.sum+a1_main.d5_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b3_0.c1_0.sum + a1_main.b4_0.c3_0.sum + a1_main.b1_0.d1_0.sum + a1_main.b3_0.c1_0.d2_0.sum + a1_main.b2_0.c2_0.d3_0.sum + a1_main.b2_0.c2_0.d4_0.sum + a1_main.d5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 9881)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00110_A1 {
+        Nocycle_a_00110_B1 b1_0;
+        Nocycle_a_00110_B2 b2_0;
+        Nocycle_a_00110_B3 b3_0;
+        Nocycle_a_00110_B4 b4_0;
+        Nocycle_a_00110_D5 d5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            d5_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + d5_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B1 {
+        Nocycle_a_00110_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B2 {
+        Nocycle_a_00110_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B2(String strObjectName) {
+            c2_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B3 {
+        Nocycle_a_00110_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B4 {
+        Nocycle_a_00110_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B4(String strObjectName) {
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C1 {
+        Nocycle_a_00110_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C1(String strObjectName) {
+            d2_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C2 {
+        Nocycle_a_00110_D3 d3_0;
+        Nocycle_a_00110_D4 d4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C2(String strObjectName) {
+            d3_0 = null;
+            d4_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d3_0.a + d4_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D4(String strObjectName) {
+            a = 404;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D5 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D5(String strObjectName) {
+            a = 405;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00110 A1_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A2_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A3_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A4_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A5_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A6_00110 = new ThreadRc_00110();
+
+        A1_00110.start();
+        A2_00110.start();
+        A3_00110.start();
+        A4_00110.start();
+        A5_00110.start();
+        A6_00110.start();
+
+        try {
+            A1_00110.join();
+            A2_00110.join();
+            A3_00110.join();
+            A4_00110.join();
+            A5_00110.join();
+            A6_00110.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00110.check() && A2_00110.check() && A3_00110.check() && A4_00110.check() && A5_00110.check() && A6_00110.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/Nocycle_am_00120.java b/test/testsuite/ouroboros/memory_management/Function/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/Nocycle_am_00120.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d4eb4da8c226fc1389e2d2d58a3e0e193bf3126
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/Nocycle_am_00120.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00120 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00120.java
+ *- @ExecuteClass: Nocycle_am_00120
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00120 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00120_A1 a1_main = new Nocycle_a_00120_A1("a1_main");
+        Nocycle_a_00120_A2 a2_main = new Nocycle_a_00120_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1007)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00120_A1 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00120_A2 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00120_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00120 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00120 A1_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A2_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A3_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A4_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A5_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A6_00120 = new ThreadRc_00120();
+
+        A1_00120.start();
+        A2_00120.start();
+        A3_00120.start();
+        A4_00120.start();
+        A5_00120.start();
+        A6_00120.start();
+
+        try {
+            A1_00120.join();
+            A2_00120.join();
+            A3_00120.join();
+            A4_00120.join();
+            A5_00120.join();
+            A6_00120.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00120.check() && A2_00120.check() && A3_00120.check() && A4_00120.check() && A5_00120.check() && A6_00120.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/Nocycle_am_00130.java b/test/testsuite/ouroboros/memory_management/Function/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/Nocycle_am_00130.java
new file mode 100644
index 0000000000000000000000000000000000000000..61ed7706dbab20119a976e02e0cd5181904fd750
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/Nocycle_am_00130.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00130 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00130.java
+ *- @ExecuteClass: Nocycle_am_00130
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00130 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00130_A1 a1_main = new Nocycle_a_00130_A1("a1_main");
+        Nocycle_a_00130_A2 a2_main = new Nocycle_a_00130_A2("a2_main");
+        Nocycle_a_00130_A3 a3_main = new Nocycle_a_00130_A3("a3_main");
+        Nocycle_a_00130_A4 a4_main = new Nocycle_a_00130_A4("a4_main");
+        Nocycle_a_00130_A5 a5_main = new Nocycle_a_00130_A5("a5_main");
+        Nocycle_a_00130_A6 a6_main = new Nocycle_a_00130_A6("a6_main");
+        Nocycle_a_00130_A7 a7_main = new Nocycle_a_00130_A7("a7_main");
+        Nocycle_a_00130_A8 a8_main = new Nocycle_a_00130_A8("a8_main");
+        Nocycle_a_00130_A9 a9_main = new Nocycle_a_00130_A9("a9_main");
+        Nocycle_a_00130_A10 a10_main = new Nocycle_a_00130_A10("a10_main");
+        a1_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a3_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a4_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a5_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a6_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a7_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a8_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a9_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a10_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        a3_main.b1_0.add();
+        a4_main.b1_0.add();
+        a5_main.b1_0.add();
+        a6_main.b1_0.add();
+        a7_main.b1_0.add();
+        a8_main.b1_0.add();
+        a9_main.b1_0.add();
+        a10_main.b1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a5_main.sum+a6_main.sum+a7_main.sum+a8_main.sum+a9_main.sum+a10_main.sum+a1_main.b1_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 3467)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00130_A1 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A2 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A3 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A3(String strObjectName) {
+            b1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A4 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A4(String strObjectName) {
+            b1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A5 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A5(String strObjectName) {
+            b1_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A6 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A6(String strObjectName) {
+            b1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A7 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A7(String strObjectName) {
+            b1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A8 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A8(String strObjectName) {
+            b1_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A9 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A9(String strObjectName) {
+            b1_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A10 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A10(String strObjectName) {
+            b1_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00130 A1_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A2_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A3_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A4_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A5_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A6_00130 = new ThreadRc_00130();
+
+        A1_00130.start();
+        A2_00130.start();
+        A3_00130.start();
+        A4_00130.start();
+        A5_00130.start();
+        A6_00130.start();
+
+        try {
+            A1_00130.join();
+            A2_00130.join();
+            A3_00130.join();
+            A4_00130.join();
+            A5_00130.join();
+            A6_00130.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00130.check() && A2_00130.check() && A3_00130.check() && A4_00130.check() && A5_00130.check() && A6_00130.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/Nocycle_am_00140.java b/test/testsuite/ouroboros/memory_management/Function/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/Nocycle_am_00140.java
new file mode 100644
index 0000000000000000000000000000000000000000..88f61365f19ed4f9f6815c7acb416f6967f25208
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/Nocycle_am_00140.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00140 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00140.java
+ *- @ExecuteClass: Nocycle_am_00140
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00140 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00140_A1 a1_main = new Nocycle_a_00140_A1("a1_main");
+        Nocycle_a_00140_A2 a2_main = new Nocycle_a_00140_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00140_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1613)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00140_A1 {
+        Nocycle_a_00140_B1 b1_0;
+        Nocycle_a_00140_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00140_A2 {
+        Nocycle_a_00140_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00140_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00140_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00140 A1_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A2_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A3_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A4_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A5_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A6_00140 = new ThreadRc_00140();
+
+        A1_00140.start();
+        A2_00140.start();
+        A3_00140.start();
+        A4_00140.start();
+        A5_00140.start();
+        A6_00140.start();
+
+        try {
+            A1_00140.join();
+            A2_00140.join();
+            A3_00140.join();
+            A4_00140.join();
+            A5_00140.join();
+            A6_00140.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00140.check() && A2_00140.check() && A3_00140.check() && A4_00140.check() && A5_00140.check() && A6_00140.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/Nocycle_am_00150.java b/test/testsuite/ouroboros/memory_management/Function/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/Nocycle_am_00150.java
new file mode 100644
index 0000000000000000000000000000000000000000..45e19dd99ead907f3946b8e29958165c28c7a286
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/Nocycle_am_00150.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00150 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00150.java
+ *- @ExecuteClass: Nocycle_am_00150
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00150 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00150_A1 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_A2 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00150_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00150 A1_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A2_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A3_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A4_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A5_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A6_00150 = new ThreadRc_00150();
+
+        A1_00150.start();
+        A2_00150.start();
+        A3_00150.start();
+        A4_00150.start();
+        A5_00150.start();
+        A6_00150.start();
+
+        try {
+            A1_00150.join();
+            A2_00150.join();
+            A3_00150.join();
+            A4_00150.join();
+            A5_00150.join();
+            A6_00150.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00150.check() && A2_00150.check() && A3_00150.check() && A4_00150.check() && A5_00150.check() && A6_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/Nocycle_am_00160.java b/test/testsuite/ouroboros/memory_management/Function/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/Nocycle_am_00160.java
new file mode 100644
index 0000000000000000000000000000000000000000..86e0b784f3a3d48bc88ce9cae02d39be52048ba8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/Nocycle_am_00160.java
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00160 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00160.java
+ *- @ExecuteClass: Nocycle_am_00160
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00160 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00160_A1 a1_main = new Nocycle_a_00160_A1("a1_main");
+        Nocycle_a_00160_A2 a2_main = new Nocycle_a_00160_A2("a2_main");
+        Nocycle_a_00160_A3 a3_main = new Nocycle_a_00160_A3("a3_main");
+        Nocycle_a_00160_A4 a4_main = new Nocycle_a_00160_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a3_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a4_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2828)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00160_A1 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A2 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A3 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A4 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00160_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00160 A1_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A2_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A3_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A4_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A5_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A6_00160 = new ThreadRc_00160();
+
+        A1_00160.start();
+        A2_00160.start();
+        A3_00160.start();
+        A4_00160.start();
+        A5_00160.start();
+        A6_00160.start();
+
+        try {
+            A1_00160.join();
+            A2_00160.join();
+            A3_00160.join();
+            A4_00160.join();
+            A5_00160.join();
+            A6_00160.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00160.check() && A2_00160.check() && A3_00160.check() && A4_00160.check() && A5_00160.check() && A6_00160.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/Nocycle_am_00170.java b/test/testsuite/ouroboros/memory_management/Function/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/Nocycle_am_00170.java
new file mode 100644
index 0000000000000000000000000000000000000000..161a893b0bfa3f822d034d1ed936349c0e08ae1d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/Nocycle_am_00170.java
@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00170 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00170.java
+ *- @ExecuteClass: Nocycle_am_00170
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00170 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00170_A1 a1_main = new Nocycle_a_00170_A1("a1_main");
+        Nocycle_a_00170_A2 a2_main = new Nocycle_a_00170_A2("a2_main");
+        Nocycle_a_00170_A3 a3_main = new Nocycle_a_00170_A3("a3_main");
+        Nocycle_a_00170_A4 a4_main = new Nocycle_a_00170_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a2_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a2_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a3_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a3_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a4_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a4_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a2_main.b3_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b3_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        a4_main.b3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 4046)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00170_A1 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A2 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A3 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A4 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00170_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00170_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00170 A1_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A2_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A3_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A4_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A5_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A6_00170 = new ThreadRc_00170();
+
+        A1_00170.start();
+        A2_00170.start();
+        A3_00170.start();
+        A4_00170.start();
+        A5_00170.start();
+        A6_00170.start();
+
+        try {
+            A1_00170.join();
+            A2_00170.join();
+            A3_00170.join();
+            A4_00170.join();
+            A5_00170.join();
+            A6_00170.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00170.check() && A2_00170.check() && A3_00170.check() && A4_00170.check() && A5_00170.check() && A6_00170.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/Nocycle_am_00180.java b/test/testsuite/ouroboros/memory_management/Function/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/Nocycle_am_00180.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8f661f9e1abdd0d520dcadccb048ba7dd1c692b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/Nocycle_am_00180.java
@@ -0,0 +1,402 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00180 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00180.java
+ *- @ExecuteClass: Nocycle_am_00180
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+//         System.out.printf("a1_main.sum=%d\n",a1_main.sum);
+//         System.out.printf("a2_main.sum=%d\n",a2_main.sum);
+//         System.out.printf("a3_main.sum=%d\n",a3_main.sum);
+//         System.out.printf("a4_main.sum=%d\n",a4_main.sum);
+//         System.out.printf("a1_main.b1_0.sum=%d\n",a1_main.b1_0.sum);
+//         System.out.printf("a2_main.b2_0.sum=%d\n",a2_main.b2_0.sum);
+//         System.out.printf("a4_main.b3_0.sum=%d\n",a4_main.b3_0.sum);
+//         System.out.printf("a2_main.b2_0.c1_0.sum=%d\n",a2_main.b2_0.c1_0.sum);
+//         System.out.printf("a3_main.c2_0.sum=%d\n",a3_main.c2_0.sum);
+//         System.out.printf("a1_main.d1_0.sum=%d\n",a1_main.d1_0.sum);
+//         System.out.printf("a3_main.c2_0.d2_0.sum=%d\n",a3_main.c2_0.d2_0.sum);
+//         System.out.printf("a3_main.c2_0.d3_0.sum=%d\n",a3_main.c2_0.d3_0.sum);
+
+
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a2_main.b2_0.sum+a4_main.b3_0.sum+a2_main.b2_0.c1_0.sum+a3_main.c2_0.sum+a1_main.d1_0.sum+a3_main.c2_0.d2_0.sum+a3_main.c2_0.d3_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 9260)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00180_A1 {
+        Nocycle_a_00180_B1 b1_0;
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A2 {
+        Nocycle_a_00180_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A3 {
+        Nocycle_a_00180_B2 b2_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A4 {
+        Nocycle_a_00180_B3 b3_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B1 {
+        Nocycle_a_00180_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B2 {
+        Nocycle_a_00180_C1 c1_0;
+        Nocycle_a_00180_D1 d1_0;
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B3 {
+        Nocycle_a_00180_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C1 {
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C2 {
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00180 A1_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A2_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A3_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A4_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A5_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A6_00180 = new ThreadRc_00180();
+
+        A1_00180.start();
+        A2_00180.start();
+        A3_00180.start();
+        A4_00180.start();
+        A5_00180.start();
+        A6_00180.start();
+
+        try {
+            A1_00180.join();
+            A2_00180.join();
+            A3_00180.join();
+            A4_00180.join();
+            A5_00180.join();
+            A6_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00180.check() && A2_00180.check() && A3_00180.check() && A4_00180.check() && A5_00180.check() && A6_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/Nocycle_am_00190.java b/test/testsuite/ouroboros/memory_management/Function/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/Nocycle_am_00190.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3606966057aab54ff79db7c821e1f2d3d6d3eab
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/Nocycle_am_00190.java
@@ -0,0 +1,3148 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:make Nocycle_a_xx together to this Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00190.java
+ *- @ExecuteClass: Nocycle_am_00190
+ *- @ExecuteArgs:
+ */
+class ThreadRc_00010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_am_00010_A1 a1_main = new Nocycle_am_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_am_00010_B1("b1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 704)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_am_00010_A1 {
+        Nocycle_am_00010_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_am_00010_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_am_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_am_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00020_A1 a1_main = new Nocycle_a_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00020_B2("b2_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1310)
+            checkout = true;
+        //System.out.println(checkout);
+
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00020_A1 {
+        Nocycle_a_00020_B1 b1_0;
+        Nocycle_a_00020_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00030B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00030_A1 a1_main = new Nocycle_a_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00030_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00030_B3("b3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1919)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00030_A1 {
+        Nocycle_a_00030_B1 b1_0;
+        Nocycle_a_00030_B2 b2_0;
+        Nocycle_a_00030_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00030_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00030_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00030_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00040B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00040_A1 a1_main = new Nocycle_a_00040_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00040_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00040_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00040_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00040_B4("b4_0");
+        a1_main.b5_0 = new Nocycle_a_00040_B5("b5_0");
+        a1_main.b6_0 = new Nocycle_a_00040_B6("b6_0");
+        a1_main.b7_0 = new Nocycle_a_00040_B7("b7_0");
+        a1_main.b8_0 = new Nocycle_a_00040_B8("b8_0");
+        a1_main.b9_0 = new Nocycle_a_00040_B9("b9_0");
+        a1_main.b10_0 = new Nocycle_a_00040_B10("b10_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b5_0.add();
+        a1_main.b6_0.add();
+        a1_main.b7_0.add();
+        a1_main.b8_0.add();
+        a1_main.b9_0.add();
+        a1_main.b10_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b5_0.sum+a1_main.b6_0.sum+a1_main.b7_0.sum+a1_main.b8_0.sum+a1_main.b9_0.sum+a1_main.b10_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b5_0.sum + a1_main.b6_0.sum + a1_main.b7_0.sum + a1_main.b8_0.sum + a1_main.b9_0.sum + a1_main.b10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 6266)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00040_A1 {
+        Nocycle_a_00040_B1 b1_0;
+        Nocycle_a_00040_B2 b2_0;
+        Nocycle_a_00040_B3 b3_0;
+        Nocycle_a_00040_B4 b4_0;
+        Nocycle_a_00040_B5 b5_0;
+        Nocycle_a_00040_B6 b6_0;
+        Nocycle_a_00040_B7 b7_0;
+        Nocycle_a_00040_B8 b8_0;
+        Nocycle_a_00040_B9 b9_0;
+        Nocycle_a_00040_B10 b10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            b5_0 = null;
+            b6_0 = null;
+            b7_0 = null;
+            b8_0 = null;
+            b9_0 = null;
+            b10_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + b5_0.a + b6_0.a + b7_0.a + b8_0.a + b9_0.a + b10_0.a;
+        }
+    }
+
+    class Nocycle_a_00040_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B5 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B5(String strObjectName) {
+            a = 205;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B6 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B6(String strObjectName) {
+            a = 206;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B7(String strObjectName) {
+            a = 207;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B8 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B8(String strObjectName) {
+            a = 208;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B9 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B9(String strObjectName) {
+            a = 209;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B10 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B10(String strObjectName) {
+            a = 210;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00050B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00050_A1 a1_main = new Nocycle_a_00050_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00050_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00050_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_a_00050_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_a_00050_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_a_00050_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00050_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00050_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        a1_main.b1_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c2_0.sum+a1_main.b1_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum + a1_main.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5048)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00050_A1 {
+        Nocycle_a_00050_B1 b1_0;
+        Nocycle_a_00050_B2 b2_0;
+        Nocycle_a_00050_B3 b3_0;
+        Nocycle_a_00050_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00050_B1 {
+        Nocycle_a_00050_C1 c1_0;
+        Nocycle_a_00050_C2 c2_0;
+        Nocycle_a_00050_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00050_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00060B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00060_A1 a1_main = new Nocycle_a_00060_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00060_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00060_B2("b2_0");
+        a1_main.b2_0.c1_0 = new Nocycle_a_00060_C1("c1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00060_C2("c2_0");
+        a1_main.b2_0.c3_0 = new Nocycle_a_00060_C3("c3_0");
+        a1_main.b3_0 = new Nocycle_a_00060_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00060_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c1_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b2_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c1_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b2_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c1_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b2_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5047)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00060_A1 {
+        Nocycle_a_00060_B1 b1_0;
+        Nocycle_a_00060_B2 b2_0;
+        Nocycle_a_00060_B3 b3_0;
+        Nocycle_a_00060_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00060_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_B2 {
+        Nocycle_a_00060_C1 c1_0;
+        Nocycle_a_00060_C2 c2_0;
+        Nocycle_a_00060_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B2(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00060_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00070B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00070_A1 a1_main = new Nocycle_a_00070_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00070_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00070_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00070_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00070_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_00070_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_00070_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00070_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 5045)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00070_A1 {
+        Nocycle_a_00070_B1 b1_0;
+        Nocycle_a_00070_B2 b2_0;
+        Nocycle_a_00070_B3 b3_0;
+        Nocycle_a_00070_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00070_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B4 {
+        Nocycle_a_00070_C1 c1_0;
+        Nocycle_a_00070_C2 c2_0;
+        Nocycle_a_00070_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00070_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00080B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00080_A1 a1_main = new Nocycle_a_00080_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00080_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00080_C1("c1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1406)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00080_A1 {
+        Nocycle_a_00080_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00080_B1 {
+        Nocycle_a_00080_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00080_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00090B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00090_A1 a1_main = new Nocycle_a_00090_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00090_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00090_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00090_D1("d1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2308)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00090_A1 {
+        Nocycle_a_00090_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_B1 {
+        Nocycle_a_00090_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_C1 {
+        Nocycle_a_00090_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00100B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00100_A1 a1_main = new Nocycle_a_00100_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00100_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00100_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00100_D1("d1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_00100_E1("e1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_00100_F1("f1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_00100_G1("g1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_00100_H1("h1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_00100_I1("i1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_00100_J1("j1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+//         System.out.printf("a=%d\n",a1_main.sum);
+//         System.out.printf("b=%d\n",a1_main.b1_0.sum);
+//         System.out.printf("c=%d\n",a1_main.b1_0.c1_0.sum);
+//         System.out.printf("d=%d\n",a1_main.b1_0.c1_0.d1_0.sum);
+//         System.out.printf("e=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.sum);
+//         System.out.printf("f=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum);
+//         System.out.printf("g=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum);
+//         System.out.printf("h=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum);
+//         System.out.printf("i=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum);
+//         System.out.printf("j=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 11920)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00100_A1 {
+        Nocycle_a_00100_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_B1 {
+        Nocycle_a_00100_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_C1 {
+        Nocycle_a_00100_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_D1 {
+        Nocycle_a_00100_E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_E1 {
+        Nocycle_a_00100_F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_F1 {
+        Nocycle_a_00100_G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_G1 {
+        Nocycle_a_00100_H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_H1 {
+        Nocycle_a_00100_I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_I1 {
+        Nocycle_a_00100_J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_J1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00110B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00110_A1 a1_main = new Nocycle_a_00110_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00110_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00110_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00110_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00110_B4("b4_0");
+        a1_main.b1_0.d1_0 = new Nocycle_a_00110_D1("d1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00110_C2("c2_0");
+        a1_main.b3_0.c1_0 = new Nocycle_a_00110_C1("c1_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00110_C3("c3_0");
+        a1_main.b3_0.c1_0.d2_0 = new Nocycle_a_00110_D2("d2_0");
+        a1_main.b2_0.c2_0.d3_0 = new Nocycle_a_00110_D3("d3_0");
+        a1_main.b2_0.c2_0.d4_0 = new Nocycle_a_00110_D4("d4_0");
+        a1_main.d5_0 = new Nocycle_a_00110_D5("d5_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b3_0.c1_0.add();
+        a1_main.b4_0.c3_0.add();
+        a1_main.b1_0.d1_0.add();
+        a1_main.b3_0.c1_0.d2_0.add();
+        a1_main.b2_0.c2_0.d3_0.add();
+        a1_main.b2_0.c2_0.d4_0.add();
+        a1_main.d5_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b3_0.c1_0.sum+a1_main.b4_0.c3_0.sum+a1_main.b1_0.d1_0.sum+a1_main.b3_0.c1_0.d2_0.sum+a1_main.b2_0.c2_0.d3_0.sum+a1_main.b2_0.c2_0.d4_0.sum+a1_main.d5_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b3_0.c1_0.sum + a1_main.b4_0.c3_0.sum + a1_main.b1_0.d1_0.sum + a1_main.b3_0.c1_0.d2_0.sum + a1_main.b2_0.c2_0.d3_0.sum + a1_main.b2_0.c2_0.d4_0.sum + a1_main.d5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 9881)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00110_A1 {
+        Nocycle_a_00110_B1 b1_0;
+        Nocycle_a_00110_B2 b2_0;
+        Nocycle_a_00110_B3 b3_0;
+        Nocycle_a_00110_B4 b4_0;
+        Nocycle_a_00110_D5 d5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            d5_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + d5_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B1 {
+        Nocycle_a_00110_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B2 {
+        Nocycle_a_00110_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B2(String strObjectName) {
+            c2_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B3 {
+        Nocycle_a_00110_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B4 {
+        Nocycle_a_00110_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B4(String strObjectName) {
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C1 {
+        Nocycle_a_00110_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C1(String strObjectName) {
+            d2_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C2 {
+        Nocycle_a_00110_D3 d3_0;
+        Nocycle_a_00110_D4 d4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C2(String strObjectName) {
+            d3_0 = null;
+            d4_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d3_0.a + d4_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D4(String strObjectName) {
+            a = 404;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D5 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D5(String strObjectName) {
+            a = 405;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00120B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00120_A1 a1_main = new Nocycle_a_00120_A1("a1_main");
+        Nocycle_a_00120_A2 a2_main = new Nocycle_a_00120_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1007)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00120_A1 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00120_A2 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00120_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00130B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00130_A1 a1_main = new Nocycle_a_00130_A1("a1_main");
+        Nocycle_a_00130_A2 a2_main = new Nocycle_a_00130_A2("a2_main");
+        Nocycle_a_00130_A3 a3_main = new Nocycle_a_00130_A3("a3_main");
+        Nocycle_a_00130_A4 a4_main = new Nocycle_a_00130_A4("a4_main");
+        Nocycle_a_00130_A5 a5_main = new Nocycle_a_00130_A5("a5_main");
+        Nocycle_a_00130_A6 a6_main = new Nocycle_a_00130_A6("a6_main");
+        Nocycle_a_00130_A7 a7_main = new Nocycle_a_00130_A7("a7_main");
+        Nocycle_a_00130_A8 a8_main = new Nocycle_a_00130_A8("a8_main");
+        Nocycle_a_00130_A9 a9_main = new Nocycle_a_00130_A9("a9_main");
+        Nocycle_a_00130_A10 a10_main = new Nocycle_a_00130_A10("a10_main");
+        a1_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a3_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a4_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a5_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a6_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a7_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a8_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a9_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a10_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        a3_main.b1_0.add();
+        a4_main.b1_0.add();
+        a5_main.b1_0.add();
+        a6_main.b1_0.add();
+        a7_main.b1_0.add();
+        a8_main.b1_0.add();
+        a9_main.b1_0.add();
+        a10_main.b1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a5_main.sum+a6_main.sum+a7_main.sum+a8_main.sum+a9_main.sum+a10_main.sum+a1_main.b1_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 3467)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00130_A1 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A2 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A3 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A3(String strObjectName) {
+            b1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A4 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A4(String strObjectName) {
+            b1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A5 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A5(String strObjectName) {
+            b1_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A6 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A6(String strObjectName) {
+            b1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A7 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A7(String strObjectName) {
+            b1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A8 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A8(String strObjectName) {
+            b1_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A9 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A9(String strObjectName) {
+            b1_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A10 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A10(String strObjectName) {
+            b1_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00140B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00140_A1 a1_main = new Nocycle_a_00140_A1("a1_main");
+        Nocycle_a_00140_A2 a2_main = new Nocycle_a_00140_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00140_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1613)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00140_A1 {
+        Nocycle_a_00140_B1 b1_0;
+        Nocycle_a_00140_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00140_A2 {
+        Nocycle_a_00140_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00140_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00140_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00150B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00150_A1 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_A2 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00150_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00160B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00160_A1 a1_main = new Nocycle_a_00160_A1("a1_main");
+        Nocycle_a_00160_A2 a2_main = new Nocycle_a_00160_A2("a2_main");
+        Nocycle_a_00160_A3 a3_main = new Nocycle_a_00160_A3("a3_main");
+        Nocycle_a_00160_A4 a4_main = new Nocycle_a_00160_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a3_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a4_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2828)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00160_A1 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A2 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A3 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A4 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00160_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00170B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00170_A1 a1_main = new Nocycle_a_00170_A1("a1_main");
+        Nocycle_a_00170_A2 a2_main = new Nocycle_a_00170_A2("a2_main");
+        Nocycle_a_00170_A3 a3_main = new Nocycle_a_00170_A3("a3_main");
+        Nocycle_a_00170_A4 a4_main = new Nocycle_a_00170_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a2_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a2_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a3_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a3_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a4_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a4_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a2_main.b3_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b3_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        a4_main.b3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 4046)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00170_A1 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A2 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A3 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A4 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00170_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00170_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+class ThreadRc_00180B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+//         System.out.printf("a1_main.sum=%d\n",a1_main.sum);
+//         System.out.printf("a2_main.sum=%d\n",a2_main.sum);
+//         System.out.printf("a3_main.sum=%d\n",a3_main.sum);
+//         System.out.printf("a4_main.sum=%d\n",a4_main.sum);
+//         System.out.printf("a1_main.b1_0.sum=%d\n",a1_main.b1_0.sum);
+//         System.out.printf("a2_main.b2_0.sum=%d\n",a2_main.b2_0.sum);
+//         System.out.printf("a4_main.b3_0.sum=%d\n",a4_main.b3_0.sum);
+//         System.out.printf("a2_main.b2_0.c1_0.sum=%d\n",a2_main.b2_0.c1_0.sum);
+//         System.out.printf("a3_main.c2_0.sum=%d\n",a3_main.c2_0.sum);
+//         System.out.printf("a1_main.d1_0.sum=%d\n",a1_main.d1_0.sum);
+//         System.out.printf("a3_main.c2_0.d2_0.sum=%d\n",a3_main.c2_0.d2_0.sum);
+//         System.out.printf("a3_main.c2_0.d3_0.sum=%d\n",a3_main.c2_0.d3_0.sum);
+
+
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a2_main.b2_0.sum+a4_main.b3_0.sum+a2_main.b2_0.c1_0.sum+a3_main.c2_0.sum+a1_main.d1_0.sum+a3_main.c2_0.d2_0.sum+a3_main.c2_0.d3_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 9260)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00180_A1 {
+        Nocycle_a_00180_B1 b1_0;
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A2 {
+        Nocycle_a_00180_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A3 {
+        Nocycle_a_00180_B2 b2_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A4 {
+        Nocycle_a_00180_B3 b3_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B1 {
+        Nocycle_a_00180_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B2 {
+        Nocycle_a_00180_C1 c1_0;
+        Nocycle_a_00180_D1 d1_0;
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B3 {
+        Nocycle_a_00180_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C1 {
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C2 {
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00010B A1_00010 = new ThreadRc_00010B();
+        ThreadRc_00010B A2_00010 = new ThreadRc_00010B();
+        ThreadRc_00020B A1_00020 = new ThreadRc_00020B();
+        ThreadRc_00020B A2_00020 = new ThreadRc_00020B();
+        ThreadRc_00030B A1_00030 = new ThreadRc_00030B();
+        ThreadRc_00030B A2_00030 = new ThreadRc_00030B();
+        ThreadRc_00040B A1_00040 = new ThreadRc_00040B();
+        ThreadRc_00040B A2_00040 = new ThreadRc_00040B();
+        ThreadRc_00050B A1_00050 = new ThreadRc_00050B();
+        ThreadRc_00050B A2_00050 = new ThreadRc_00050B();
+        ThreadRc_00060B A1_00060 = new ThreadRc_00060B();
+        ThreadRc_00060B A2_00060 = new ThreadRc_00060B();
+        ThreadRc_00070B A1_00070 = new ThreadRc_00070B();
+        ThreadRc_00070B A2_00070 = new ThreadRc_00070B();
+        ThreadRc_00080B A1_00080 = new ThreadRc_00080B();
+        ThreadRc_00080B A2_00080 = new ThreadRc_00080B();
+        ThreadRc_00090B A1_00090 = new ThreadRc_00090B();
+        ThreadRc_00090B A2_00090 = new ThreadRc_00090B();
+        ThreadRc_00100B A1_00100 = new ThreadRc_00100B();
+        ThreadRc_00100B A2_00100 = new ThreadRc_00100B();
+        ThreadRc_00110B A1_00110 = new ThreadRc_00110B();
+        ThreadRc_00110B A2_00110 = new ThreadRc_00110B();
+        ThreadRc_00120B A1_00120 = new ThreadRc_00120B();
+        ThreadRc_00120B A2_00120 = new ThreadRc_00120B();
+        ThreadRc_00130B A1_00130 = new ThreadRc_00130B();
+        ThreadRc_00130B A2_00130 = new ThreadRc_00130B();
+        ThreadRc_00140B A1_00140 = new ThreadRc_00140B();
+        ThreadRc_00140B A2_00140 = new ThreadRc_00140B();
+        ThreadRc_00150B A1_00150 = new ThreadRc_00150B();
+        ThreadRc_00150B A2_00150 = new ThreadRc_00150B();
+        ThreadRc_00160B A1_00160 = new ThreadRc_00160B();
+        ThreadRc_00160B A2_00160 = new ThreadRc_00160B();
+        ThreadRc_00170B A1_00170 = new ThreadRc_00170B();
+        ThreadRc_00170B A2_00170 = new ThreadRc_00170B();
+        ThreadRc_00180B A1_00180 = new ThreadRc_00180B();
+        ThreadRc_00180B A2_00180 = new ThreadRc_00180B();
+        A1_00010.start();
+        A2_00010.start();
+        A1_00020.start();
+        A2_00020.start();
+        A1_00030.start();
+        A2_00030.start();
+        A1_00040.start();
+        A2_00040.start();
+        A1_00050.start();
+        A2_00050.start();
+        A1_00060.start();
+        A2_00060.start();
+        A1_00070.start();
+        A2_00070.start();
+        A1_00080.start();
+        A2_00080.start();
+        A1_00090.start();
+        A2_00090.start();
+        A1_00100.start();
+        A2_00100.start();
+        A1_00110.start();
+        A2_00110.start();
+        A1_00120.start();
+        A2_00120.start();
+        A1_00130.start();
+        A2_00130.start();
+        A1_00140.start();
+        A2_00140.start();
+        A1_00150.start();
+        A2_00150.start();
+        A1_00160.start();
+        A2_00160.start();
+        A1_00170.start();
+        A2_00170.start();
+        A1_00180.start();
+        A2_00180.start();
+        try {
+            A1_00010.join();
+            A2_00010.join();
+            A1_00020.join();
+            A2_00020.join();
+            A1_00030.join();
+            A2_00030.join();
+            A1_00040.join();
+            A2_00040.join();
+            A1_00050.join();
+            A2_00050.join();
+            A1_00060.join();
+            A2_00060.join();
+            A1_00070.join();
+            A2_00070.join();
+            A1_00080.join();
+            A2_00080.join();
+            A1_00090.join();
+            A2_00090.join();
+            A1_00100.join();
+            A2_00100.join();
+            A1_00110.join();
+            A2_00110.join();
+            A1_00120.join();
+            A2_00120.join();
+            A1_00130.join();
+            A2_00130.join();
+            A1_00140.join();
+            A2_00140.join();
+            A1_00150.join();
+            A2_00150.join();
+            A1_00160.join();
+            A2_00160.join();
+            A1_00170.join();
+            A2_00170.join();
+            A1_00180.join();
+            A2_00180.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00010.check() && A2_00010.check() && A1_00020.check() && A2_00020.check() && A1_00030.check() && A2_00030.check() && A1_00040.check() && A2_00040.check() && A1_00050.check() && A2_00050.check() && A1_00060.check() && A2_00060.check() && A1_00070.check() && A2_00070.check() && A1_00080.check() && A2_00080.check() && A1_00090.check() && A2_00090.check() && A1_00100.check() && A2_00100.check() && A1_00110.check() && A2_00110.check() && A1_00120.check() && A2_00120.check() && A1_00130.check() && A2_00130.check() && A1_00140.check() && A2_00140.check() && A1_00150.check() && A2_00150.check() && A1_00160.check() && A2_00160.check() && A1_00170.check() && A2_00170.check() && A1_00180.check() && A2_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/Nocycle_am_2_00010.java b/test/testsuite/ouroboros/memory_management/Function/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/Nocycle_am_2_00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..5ce17d9b7844800ac03d775ec6375f3da5c3401c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/Nocycle_am_2_00010.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_2_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_2_00010 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_2_00010.java
+ *- @ExecuteClass: Nocycle_am_2_00010
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Nocycle_am_2_00010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_2_00010_A1 a1_main = new Nocycle_a_2_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00010_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00010_B3("b3_0");
+        Nocycle_a_2_00010_A2 a2_main = new Nocycle_a_2_00010_A2("a2_main");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.add();
+        //         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a2_main.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1939)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_2_00010_A1 {
+        Nocycle_a_2_00010_B1 b1_0;
+        Nocycle_a_2_00010_B2 b2_0;
+        Nocycle_a_2_00010_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_A2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_A2(String strObjectName) {
+            a = 10;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_2_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Nocycle_am_2_00010 A1_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A2_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A3_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A4_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A5_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A6_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+
+        A1_Nocycle_am_2_00010.start();
+        A2_Nocycle_am_2_00010.start();
+        A3_Nocycle_am_2_00010.start();
+        A4_Nocycle_am_2_00010.start();
+        A5_Nocycle_am_2_00010.start();
+        A6_Nocycle_am_2_00010.start();
+
+        try {
+            A1_Nocycle_am_2_00010.join();
+            A2_Nocycle_am_2_00010.join();
+            A3_Nocycle_am_2_00010.join();
+            A4_Nocycle_am_2_00010.join();
+            A5_Nocycle_am_2_00010.join();
+            A6_Nocycle_am_2_00010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Nocycle_am_2_00010.check() && A2_Nocycle_am_2_00010.check() && A3_Nocycle_am_2_00010.check() && A4_Nocycle_am_2_00010.check() && A5_Nocycle_am_2_00010.check() && A6_Nocycle_am_2_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/Nocycle_am_2_00020.java b/test/testsuite/ouroboros/memory_management/Function/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/Nocycle_am_2_00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa877d61eacb9e1862e6f18dabeba29a57e7e2ef
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/Nocycle_am_2_00020.java
@@ -0,0 +1,769 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_2_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_2_00020 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_2_00020.java
+ *- @ExecuteClass: Nocycle_am_2_00020
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Nocycle_am_2_00020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_2_00020_A1 a1_main = new Nocycle_a_2_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_2_00020_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_2_00020_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_2_00020_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_2_00020_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result1 = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result1);
+        Nocycle_a_2_00020_2A1 a1_main2 = new Nocycle_a_2_00020_2A1("a1_main2");
+        a1_main2.b1_0 = new Nocycle_a_2_00020_2B1("b1_0");
+        a1_main2.b1_0.c1_0 = new Nocycle_a_2_00020_2C1("c1_0");
+        a1_main2.b1_0.c1_0.d1_0 = new Nocycle_a_2_00020_2D1("d1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_2_00020_2E1("e1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_2_00020_2F1("f1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_2_00020_2G1("g1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_2_00020_2H1("h1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_2_00020_2I1("i1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_2_00020_2J1("j1_0");
+        a1_main2.add();
+        a1_main2.b1_0.add();
+        a1_main2.b1_0.c1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+
+        int result2 = a1_main2.sum + a1_main2.b1_0.sum + a1_main2.b1_0.c1_0.sum + a1_main2.b1_0.c1_0.d1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        Nocycle_a_2_00020_3A1 a1_main3 = new Nocycle_a_2_00020_3A1("a1_main3");
+        Nocycle_a_2_00020_3A2 a2_main = new Nocycle_a_2_00020_3A2("a2_main");
+        Nocycle_a_2_00020_3A3 a3_main = new Nocycle_a_2_00020_3A3("a3_main");
+        Nocycle_a_2_00020_3A4 a4_main = new Nocycle_a_2_00020_3A4("a4_main");
+        a1_main3.b1_0 = new Nocycle_a_2_00020_3B1("b1_0");
+        a1_main3.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a1_main3.b1_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_2_00020_3B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a1_main3.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main3.b1_0.add();
+        a1_main3.d1_0.add();
+        a1_main3.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result3 = a1_main3.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main3.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main3.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+
+        int result = result1 + result2 + result3;
+
+        if (result == 26225)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_2_00020_A1 {
+        Nocycle_a_2_00020_B1 b1_0;
+        Nocycle_a_2_00020_B2 b2_0;
+        Nocycle_a_2_00020_B3 b3_0;
+        Nocycle_a_2_00020_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B4 {
+        Nocycle_a_2_00020_C1 c1_0;
+        Nocycle_a_2_00020_C2 c2_0;
+        Nocycle_a_2_00020_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2A1 {
+        Nocycle_a_2_00020_2B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2B1 {
+        Nocycle_a_2_00020_2C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2C1 {
+        Nocycle_a_2_00020_2D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2D1 {
+        Nocycle_a_2_00020_2E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2E1 {
+        Nocycle_a_2_00020_2F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2F1 {
+        Nocycle_a_2_00020_2G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2G1 {
+        Nocycle_a_2_00020_2H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2H1 {
+        Nocycle_a_2_00020_2I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2I1 {
+        Nocycle_a_2_00020_2J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2J1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A1 {
+        Nocycle_a_2_00020_3B1 b1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A2 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A3 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A4 {
+        Nocycle_a_2_00020_3B3 b3_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B1 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B2 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B3 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3C1 {
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3C2 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_2_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Nocycle_am_2_00020 A1_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A2_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A3_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A4_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A5_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A6_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+
+        A1_Nocycle_am_2_00020.start();
+        A2_Nocycle_am_2_00020.start();
+        A3_Nocycle_am_2_00020.start();
+        A4_Nocycle_am_2_00020.start();
+        A5_Nocycle_am_2_00020.start();
+        A6_Nocycle_am_2_00020.start();
+
+        try {
+            A1_Nocycle_am_2_00020.join();
+            A2_Nocycle_am_2_00020.join();
+            A3_Nocycle_am_2_00020.join();
+            A4_Nocycle_am_2_00020.join();
+            A5_Nocycle_am_2_00020.join();
+            A6_Nocycle_am_2_00020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Nocycle_am_2_00020.check() && A2_Nocycle_am_2_00020.check() && A3_Nocycle_am_2_00020.check() && A4_Nocycle_am_2_00020.check() && A5_Nocycle_am_2_00020.check() && A6_Nocycle_am_2_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/Nocycle_am_2_00030.java b/test/testsuite/ouroboros/memory_management/Function/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/Nocycle_am_2_00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..0db7c329f77bcca7bb08fda568b36e5a9553e145
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/Nocycle_am_2_00030.java
@@ -0,0 +1,905 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_2_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_2_00030 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_2_00030.java
+ *- @ExecuteClass: Nocycle_am_2_00030
+ *- @ExecuteArgs:
+ */
+class ThreadRc_Nocycle_am_2_00010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_2_00010_A1 a1_main = new Nocycle_a_2_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00010_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00010_B3("b3_0");
+        Nocycle_a_2_00010_A2 a2_main = new Nocycle_a_2_00010_A2("a2_main");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.add();
+        //         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a2_main.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1939)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_2_00010_A1 {
+        Nocycle_a_2_00010_B1 b1_0;
+        Nocycle_a_2_00010_B2 b2_0;
+        Nocycle_a_2_00010_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_A2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_A2(String strObjectName) {
+            a = 10;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_Nocycle_am_2_00020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_2_00020_A1 a1_main = new Nocycle_a_2_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_2_00020_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_2_00020_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_2_00020_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_2_00020_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//         System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result1 = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result1);
+        Nocycle_a_2_00020_2A1 a1_main2 = new Nocycle_a_2_00020_2A1("a1_main2");
+        a1_main2.b1_0 = new Nocycle_a_2_00020_2B1("b1_0");
+        a1_main2.b1_0.c1_0 = new Nocycle_a_2_00020_2C1("c1_0");
+        a1_main2.b1_0.c1_0.d1_0 = new Nocycle_a_2_00020_2D1("d1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_2_00020_2E1("e1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_2_00020_2F1("f1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_2_00020_2G1("g1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_2_00020_2H1("h1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_2_00020_2I1("i1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_2_00020_2J1("j1_0");
+        a1_main2.add();
+        a1_main2.b1_0.add();
+        a1_main2.b1_0.c1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+
+        int result2 = a1_main2.sum + a1_main2.b1_0.sum + a1_main2.b1_0.c1_0.sum + a1_main2.b1_0.c1_0.d1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        Nocycle_a_2_00020_3A1 a1_main3 = new Nocycle_a_2_00020_3A1("a1_main3");
+        Nocycle_a_2_00020_3A2 a2_main = new Nocycle_a_2_00020_3A2("a2_main");
+        Nocycle_a_2_00020_3A3 a3_main = new Nocycle_a_2_00020_3A3("a3_main");
+        Nocycle_a_2_00020_3A4 a4_main = new Nocycle_a_2_00020_3A4("a4_main");
+        a1_main3.b1_0 = new Nocycle_a_2_00020_3B1("b1_0");
+        a1_main3.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a1_main3.b1_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_2_00020_3B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a1_main3.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main3.b1_0.add();
+        a1_main3.d1_0.add();
+        a1_main3.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result3 = a1_main3.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main3.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main3.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+
+        int result = result1 + result2 + result3;
+
+        if (result == 26225)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_2_00020_A1 {
+        Nocycle_a_2_00020_B1 b1_0;
+        Nocycle_a_2_00020_B2 b2_0;
+        Nocycle_a_2_00020_B3 b3_0;
+        Nocycle_a_2_00020_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B4 {
+        Nocycle_a_2_00020_C1 c1_0;
+        Nocycle_a_2_00020_C2 c2_0;
+        Nocycle_a_2_00020_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2A1 {
+        Nocycle_a_2_00020_2B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2B1 {
+        Nocycle_a_2_00020_2C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2C1 {
+        Nocycle_a_2_00020_2D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2D1 {
+        Nocycle_a_2_00020_2E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2E1 {
+        Nocycle_a_2_00020_2F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2F1 {
+        Nocycle_a_2_00020_2G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2G1 {
+        Nocycle_a_2_00020_2H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2H1 {
+        Nocycle_a_2_00020_2I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2I1 {
+        Nocycle_a_2_00020_2J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2J1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A1 {
+        Nocycle_a_2_00020_3B1 b1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A2 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A3 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A4 {
+        Nocycle_a_2_00020_3B3 b3_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B1 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B2 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B3 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3C1 {
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3C2 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_2_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Nocycle_am_2_00010B A1_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A2_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A3_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A4_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A5_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A6_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00020B A1_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A2_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A3_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A4_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A5_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A6_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+
+        A1_Nocycle_am_2_00010.start();
+        A2_Nocycle_am_2_00010.start();
+        A3_Nocycle_am_2_00010.start();
+        A4_Nocycle_am_2_00010.start();
+        A5_Nocycle_am_2_00010.start();
+        A6_Nocycle_am_2_00010.start();
+        A1_Nocycle_am_2_00020.start();
+        A2_Nocycle_am_2_00020.start();
+        A3_Nocycle_am_2_00020.start();
+        A4_Nocycle_am_2_00020.start();
+        A5_Nocycle_am_2_00020.start();
+        A6_Nocycle_am_2_00020.start();
+
+        try {
+            A1_Nocycle_am_2_00010.join();
+            A2_Nocycle_am_2_00010.join();
+            A3_Nocycle_am_2_00010.join();
+            A4_Nocycle_am_2_00010.join();
+            A5_Nocycle_am_2_00010.join();
+            A6_Nocycle_am_2_00010.join();
+            A1_Nocycle_am_2_00020.join();
+            A2_Nocycle_am_2_00020.join();
+            A3_Nocycle_am_2_00020.join();
+            A4_Nocycle_am_2_00020.join();
+            A5_Nocycle_am_2_00020.join();
+            A6_Nocycle_am_2_00020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Nocycle_am_2_00010.check() && A2_Nocycle_am_2_00010.check() && A3_Nocycle_am_2_00010.check() && A4_Nocycle_am_2_00010.check() && A5_Nocycle_am_2_00010.check() && A6_Nocycle_am_2_00010.check() && A1_Nocycle_am_2_00020.check() && A2_Nocycle_am_2_00020.check() && A3_Nocycle_am_2_00020.check() && A4_Nocycle_am_2_00020.check() && A5_Nocycle_am_2_00020.check() && A6_Nocycle_am_2_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0228-rc-function-RC_Thread02-RC_Thread_01/RC_Thread_01.java b/test/testsuite/ouroboros/memory_management/Function/RC0228-rc-function-RC_Thread02-RC_Thread_01/RC_Thread_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..bdcd3b7418f6f54d7b740c55960aa9fb44995f19
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0228-rc-function-RC_Thread02-RC_Thread_01/RC_Thread_01.java
@@ -0,0 +1,435 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_01.java
+ *- @ExecuteClass: RC_Thread_01
+ *- @ExecuteArgs:
+
+ *
+ */
+
+class RC_Thread_01_1 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_01_2 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_01_3 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_01_4 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_01_5 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_01 {
+    private volatile static RC_Thread_01_A1 a1_main = null;
+    private volatile static RC_Thread_01_A2 a2_main = null;
+    private volatile static RC_Thread_01_A3 a3_main = null;
+    private volatile static RC_Thread_01_A4 a4_main = null;
+
+    RC_Thread_01() {
+        try {
+            a1_main = new RC_Thread_01_A1("a1_main");
+            a2_main = new RC_Thread_01_A2("a2_main");
+            a3_main = new RC_Thread_01_A3("a3_main");
+            a4_main = new RC_Thread_01_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_01_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_01_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_01_D2("d2_0");
+
+            a2_main.b2_0 = new RC_Thread_01_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_01_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_01_D1("d1_0");
+
+            a3_main.b2_0 = new RC_Thread_01_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_01_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+
+            a3_main.c2_0 = new RC_Thread_01_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+
+            a4_main.b3_0 = new RC_Thread_01_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_01_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_01_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_01_1 t1 = new RC_Thread_01_1();
+        RC_Thread_01_2 t2 = new RC_Thread_01_2();
+        RC_Thread_01_3 t3 = new RC_Thread_01_3();
+        RC_Thread_01_4 t4 = new RC_Thread_01_4();
+        RC_Thread_01_5 t5 = new RC_Thread_01_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA2null() {
+        a2_main = null;
+    }
+
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_01_D2("new");
+            a3_main = new RC_Thread_01_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        a3_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    class RC_Thread_01_A1 {
+        volatile RC_Thread_01_B1 b1_0;
+        volatile RC_Thread_01_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_A2 {
+        volatile RC_Thread_01_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_A3 {
+        volatile RC_Thread_01_B2 b2_0;
+        volatile RC_Thread_01_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class RC_Thread_01_A4 {
+        volatile RC_Thread_01_B3 b3_0;
+        volatile RC_Thread_01_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_B1 {
+        volatile RC_Thread_01_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_B2 {
+        volatile RC_Thread_01_C1 c1_0;
+        volatile RC_Thread_01_D1 d1_0;
+        volatile RC_Thread_01_D2 d2_0;
+        volatile RC_Thread_01_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_B3 {
+        volatile RC_Thread_01_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_C1 {
+        volatile RC_Thread_01_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class RC_Thread_01_C2 {
+        volatile RC_Thread_01_D2 d2_0;
+        volatile RC_Thread_01_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_01_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_01_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0229-rc-function-RC_Thread02-RC_Thread_02/RC_Thread_02.java b/test/testsuite/ouroboros/memory_management/Function/RC0229-rc-function-RC_Thread02-RC_Thread_02/RC_Thread_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0aba5dac7ca1bf9e25ad6e6d3a788d98e15c812
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0229-rc-function-RC_Thread02-RC_Thread_02/RC_Thread_02.java
@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00050
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_02.java
+ *- @ExecuteClass: RC_Thread_02
+ *- @ExecuteArgs:
+
+ *
+ */
+class RC_Thread_02_1 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.addSum();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_02_2 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.ModifyB4();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_02_3 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.deleteA1();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_02_4 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.setA1(null);
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_02 {
+    private volatile static RC_Thread_02_A1 a1 = null;
+
+    RC_Thread_02(String str) {
+        try {
+            a1 = new RC_Thread_02_A1("a1");
+            a1.b1_0 = new RC_Thread_02_B1("b1_0");
+            a1.b1_0.c1_0 = new RC_Thread_02_C1("c1_0");
+            a1.b1_0.c2_0 = new RC_Thread_02_C2("c2_0");
+            a1.b1_0.c3_0 = new RC_Thread_02_C3("c3_0");
+            a1.b2_0 = new RC_Thread_02_B2("b2_0");
+            a1.b3_0 = new RC_Thread_02_B3("b3_0");
+            a1.b4_0 = new RC_Thread_02_B4("b4_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_02_1 t1 = new RC_Thread_02_1();
+        RC_Thread_02_2 t2 = new RC_Thread_02_2();
+        RC_Thread_02_3 t3 = new RC_Thread_02_3();
+        RC_Thread_02_4 t4 = new RC_Thread_02_4();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void deleteA1() {
+        a1 = null;
+    }
+
+    public void ModifyB4() {
+        try {
+            a1.b4_0 = new RC_Thread_02_B4("new_b4");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void addSum() {
+        try {
+            a1.add();
+            a1.b1_0.add();
+            a1.b2_0.add();
+            a1.b3_0.add();
+            a1.b4_0.add();
+            a1.b1_0.c1_0.add();
+            a1.b1_0.c2_0.add();
+            a1.b1_0.c3_0.add();
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA1(RC_Thread_02_A1 a1) {
+        this.a1 = a1;
+    }
+
+    class RC_Thread_02_A1 {
+        volatile RC_Thread_02_B1 b1_0;
+        volatile RC_Thread_02_B2 b2_0;
+        volatile RC_Thread_02_B3 b3_0;
+        volatile RC_Thread_02_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class RC_Thread_02_B1 {
+        volatile RC_Thread_02_C1 c1_0;
+        volatile RC_Thread_02_C2 c2_0;
+        volatile RC_Thread_02_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class RC_Thread_02_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+
+    class RC_Thread_02_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_02_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_02_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_02_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_02_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0230-rc-function-RC_Thread02-RC_Thread_03/RC_Thread_03.java b/test/testsuite/ouroboros/memory_management/Function/RC0230-rc-function-RC_Thread02-RC_Thread_03/RC_Thread_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..28acd4c2d3eb19b9dc1143ad2af2151b0f48fa62
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0230-rc-function-RC_Thread02-RC_Thread_03/RC_Thread_03.java
@@ -0,0 +1,437 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_03.java
+ *- @ExecuteClass: RC_Thread_03
+ *- @ExecuteArgs:
+
+ *
+ */
+
+class RC_Thread_03_1 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_03_2 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_03_3 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_03_4 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_03_5 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA4();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_03 {
+    private volatile static RC_Thread_03_A1 a1_main = null;
+    private volatile static RC_Thread_03_A2 a2_main = null;
+    private volatile static RC_Thread_03_A3 a3_main = null;
+    private volatile static RC_Thread_03_A4 a4_main = null;
+
+    RC_Thread_03() {
+        try {
+            a1_main = new RC_Thread_03_A1("a1_main");
+            a2_main = new RC_Thread_03_A2("a2_main");
+            a3_main = new RC_Thread_03_A3("a3_main");
+            a4_main = new RC_Thread_03_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_03_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_03_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_03_D2("d2_0");
+
+            a2_main.b2_0 = new RC_Thread_03_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_03_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_03_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_03_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_03_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_03_D1("d1_0");
+
+            a3_main.b2_0 = new RC_Thread_03_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_03_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_03_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_03_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_03_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_03_D3("d3_0");
+
+            a3_main.c2_0 = new RC_Thread_03_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_03_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_03_D3("d3_0");
+
+            a4_main.b3_0 = new RC_Thread_03_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_03_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_03_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_03_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_03_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_03_D3("d3_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_03_1 t1 = new RC_Thread_03_1();
+        RC_Thread_03_2 t2 = new RC_Thread_03_2();
+        RC_Thread_03_3 t3 = new RC_Thread_03_3();
+        RC_Thread_03_4 t4 = new RC_Thread_03_4();
+        RC_Thread_03_5 t5 = new RC_Thread_03_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA2null() {
+        a2_main = null;
+    }
+
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_03_D2("new");
+            a3_main = new RC_Thread_03_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        a3_main = null;
+    }
+
+    public void setA4() {
+        try {
+            a4_main = new RC_Thread_03_A4("a4_new");
+
+        } catch (NullPointerException e) {
+        }
+    }
+
+    class RC_Thread_03_A1 {
+        volatile RC_Thread_03_B1 b1_0;
+        volatile RC_Thread_03_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+
+    class RC_Thread_03_A2 {
+        volatile RC_Thread_03_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+
+    class RC_Thread_03_A3 {
+        volatile RC_Thread_03_B2 b2_0;
+        volatile RC_Thread_03_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class RC_Thread_03_A4 {
+        volatile RC_Thread_03_B3 b3_0;
+        volatile RC_Thread_03_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+
+    class RC_Thread_03_B1 {
+        volatile RC_Thread_03_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+
+    class RC_Thread_03_B2 {
+        volatile RC_Thread_03_C1 c1_0;
+        volatile RC_Thread_03_D1 d1_0;
+        volatile RC_Thread_03_D2 d2_0;
+        volatile RC_Thread_03_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_03_B3 {
+        volatile RC_Thread_03_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+
+    class RC_Thread_03_C1 {
+        volatile RC_Thread_03_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class RC_Thread_03_C2 {
+        volatile RC_Thread_03_D2 d2_0;
+        volatile RC_Thread_03_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_03_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_03_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_03_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_03_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0231-rc-function-RC_Thread02-RC_Thread_04/RC_Thread_04.java b/test/testsuite/ouroboros/memory_management/Function/RC0231-rc-function-RC_Thread02-RC_Thread_04/RC_Thread_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..980d837ed53f9950fdbf6ec8b92488f50d8f5ce5
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0231-rc-function-RC_Thread02-RC_Thread_04/RC_Thread_04.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_04.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_04.java
+ *- @ExecuteClass: RC_Thread_04
+ *- @ExecuteArgs:
+
+ *
+ */
+
+class RC_Thread_04_1 extends Thread {
+    public void run() {
+        RC_Thread_04 rcth01 = new RC_Thread_04();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_04_2 extends Thread {
+    public void run() {
+        RC_Thread_04 rcth01 = new RC_Thread_04();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_04_3 extends Thread {
+    public void run() {
+        RC_Thread_04 rcth01 = new RC_Thread_04();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_04 {
+    private volatile static RC_Thread_04_A1 a1_main = null;
+    private volatile static RC_Thread_04_A4 a4_main = null;
+    private volatile static RC_Thread_04_A5 a5_main = null;
+
+    RC_Thread_04() {
+        try {
+            RC_Thread_04_A1 a1 = new RC_Thread_04_A1();
+            a1.a2_0 = new RC_Thread_04_A2();
+            a1.a2_0.a3_0 = new RC_Thread_04_A3();
+            RC_Thread_04_A4 a4 = new RC_Thread_04_A4();
+            RC_Thread_04_A5 a5 = new RC_Thread_04_A5();
+            a4.a1_0 = a1;
+            a5.a1_0 = a1;
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1_main = a1;
+            a4_main = a4;
+            a5_main = a5;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        a1_main = new RC_Thread_04_A1();
+        a1_main.a2_0 = new RC_Thread_04_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_04_A3();
+        a4_main = new RC_Thread_04_A4();
+        a5_main = new RC_Thread_04_A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main = null;
+        a4_main = null;
+        a5_main = null;
+        Runtime.getRuntime().gc();//单独构造一次Cycle_B_1_00180环，通过gc学习到环模式
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_04_1 t1 = new RC_Thread_04_1();
+        RC_Thread_04_2 t2 = new RC_Thread_04_2();
+        RC_Thread_04_3 t3 = new RC_Thread_04_3();
+        t1.start();
+        t2.start();
+        t3.start();
+
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_04_A1 {
+        volatile RC_Thread_04_A2 a2_0;
+        int a;
+        int sum;
+
+        RC_Thread_04_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_04_A2 {
+        volatile RC_Thread_04_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_04_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_04_A3 {
+        volatile RC_Thread_04_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_04_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    static class RC_Thread_04_A4 {
+        volatile RC_Thread_04_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_04_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    static class RC_Thread_04_A5 {
+        volatile RC_Thread_04_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_04_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0232-rc-function-RC_Thread02-RC_Thread_05/RC_Thread_05.java b/test/testsuite/ouroboros/memory_management/Function/RC0232-rc-function-RC_Thread02-RC_Thread_05/RC_Thread_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e1d5306c0fab7c845c2f5b4db81267f8fe81b7b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0232-rc-function-RC_Thread02-RC_Thread_05/RC_Thread_05.java
@@ -0,0 +1,302 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_05.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_05.java
+ *- @ExecuteClass: RC_Thread_05
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_05_1 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_05_2 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_05_3 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_05_4 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA1();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_05_5 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_05_6 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA3_a(5);
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_05 {
+    private volatile static RC_Thread_05_A1 a1_main = null;
+    private volatile static RC_Thread_05_A4 a4_main = null;
+    private volatile static RC_Thread_05_A5 a5_main = null;
+
+    RC_Thread_05() {
+        try {
+            a1_main = new RC_Thread_05_A1();
+            a1_main.a2_0 = new RC_Thread_05_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_05_A3();
+            a4_main = new RC_Thread_05_A4();
+            a5_main = new RC_Thread_05_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        a1_main = new RC_Thread_05_A1();
+        a1_main.a2_0 = new RC_Thread_05_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_05_A3();
+        a4_main = new RC_Thread_05_A4();
+        a5_main = new RC_Thread_05_A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main = null;
+        a4_main = null;
+        a5_main = null;
+        Runtime.getRuntime().gc();//单独构造一次Cycle_B_1_00180环，通过gc学习到环模式
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_05_1 t1 = new RC_Thread_05_1();
+        RC_Thread_05_2 t2 = new RC_Thread_05_2();
+        RC_Thread_05_3 t3 = new RC_Thread_05_3();
+        RC_Thread_05_4 t4 = new RC_Thread_05_4();
+        RC_Thread_05_5 t5 = new RC_Thread_05_5();
+        RC_Thread_05_6 t6 = new RC_Thread_05_6();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        t6.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+            t6.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    public void setA1() {
+        try {
+            this.a1_main = new RC_Thread_05_A1();
+            a1_main.a2_0 = new RC_Thread_05_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_05_A3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    public void checkA3() {
+        try {
+            int a = a1_main.a2_0.a3_0.a;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    public void setA3_a(int a) {
+        try {
+            this.a1_main.a2_0.a3_0.a = a;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    static class RC_Thread_05_A1 {
+        volatile RC_Thread_05_A2 a2_0;
+        int a;
+        int sum;
+
+        RC_Thread_05_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_05_A2 {
+        volatile RC_Thread_05_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_05_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_05_A3 {
+        volatile RC_Thread_05_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_05_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    static class RC_Thread_05_A4 {
+        volatile RC_Thread_05_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_05_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    static class RC_Thread_05_A5 {
+        volatile RC_Thread_05_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_05_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0233-rc-function-RC_Thread02-RC_Thread_06/RC_Thread_06.java b/test/testsuite/ouroboros/memory_management/Function/RC0233-rc-function-RC_Thread02-RC_Thread_06/RC_Thread_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..0dadf5a30e4bc9bbcb1577b5b87a0b432e659605
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0233-rc-function-RC_Thread02-RC_Thread_06/RC_Thread_06.java
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_06.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_06.java
+ *- @ExecuteClass: RC_Thread_06
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_06_1 extends Thread {
+    public void run() {
+        RC_Thread_06 rcth01 = new RC_Thread_06();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_06_2 extends Thread {
+    public void run() {
+        RC_Thread_06 rcth01 = new RC_Thread_06();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_06_3 extends Thread {
+    public void run() {
+        RC_Thread_06 rcth01 = new RC_Thread_06();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+
+    }
+}
+
+public class RC_Thread_06 {
+    private volatile static RC_Thread_06_A1 a1_main = null;
+    private volatile static RC_Thread_06_A5 a5_main = null;
+
+    RC_Thread_06() {
+        try {
+            a1_main = new RC_Thread_06_A1();
+            a1_main.a2_0 = new RC_Thread_06_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_06_A3();
+            a1_main.a2_0.a3_0.a4_0 = new RC_Thread_06_A4();
+            a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+            a5_main = new RC_Thread_06_A5();
+            a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_06_A6();
+            a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+            a5_main.a3_0 = a1_main.a2_0.a3_0;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        Runtime.getRuntime().gc();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        a1_main = new RC_Thread_06_A1();
+        a1_main.a2_0 = new RC_Thread_06_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_06_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_06_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_06_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_06_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main = null;
+        a5_main = null;
+
+        a1_main = new RC_Thread_06_A1();
+        a1_main.a2_0 = new RC_Thread_06_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_06_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_06_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main = null;
+
+        a1_main = new RC_Thread_06_A1();
+        a1_main.a2_0 = new RC_Thread_06_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_06_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_06_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_06_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_06_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0 = null;
+        a1_main = null;
+        a5_main = null;     //总共三种环类型
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_06_1 t1 = new RC_Thread_06_1();
+        RC_Thread_06_2 t2 = new RC_Thread_06_2();
+        RC_Thread_06_3 t3 = new RC_Thread_06_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        try {
+            a1_main.a2_0.a3_0.a4_0 = null;
+            a5_main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_06_A1 {
+        volatile RC_Thread_06_A2 a2_0;
+        volatile RC_Thread_06_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_06_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_06_A2 {
+        volatile RC_Thread_06_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_06_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_06_A3 {
+        volatile RC_Thread_06_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_06_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+
+    static class RC_Thread_06_A4 {
+        volatile RC_Thread_06_A1 a1_0;
+        volatile RC_Thread_06_A6 a6_0;
+        int a;
+        int sum;
+
+        RC_Thread_06_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_06_A5 {
+        volatile RC_Thread_06_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_06_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_06_A6 {
+        volatile RC_Thread_06_A5 a5_0;
+        int a;
+        int sum;
+
+        RC_Thread_06_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0234-rc-function-RC_Thread02-RC_Thread_07/RC_Thread_07.java b/test/testsuite/ouroboros/memory_management/Function/RC0234-rc-function-RC_Thread02-RC_Thread_07/RC_Thread_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed9b7753a9e3d4c76b58c9d020c84587e1f88d3e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0234-rc-function-RC_Thread02-RC_Thread_07/RC_Thread_07.java
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_07.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_07.java
+ *- @ExecuteClass: RC_Thread_07
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_07_1 extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        try {
+            rcth01.ModifyA1();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_07_2 extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        try {
+            rcth01.checkA4();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_07_3 extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        try {
+            rcth01.setA5();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_07 {
+    private volatile static RC_Thread_07_A1 a1_main = null;
+    private volatile static RC_Thread_07_A5 a5_main = null;
+
+    RC_Thread_07() {
+        try {
+            RC_Thread_07_A1 a1_1 = new RC_Thread_07_A1();
+            a1_1.a2_0 = new RC_Thread_07_A2();
+            a1_1.a2_0.a3_0 = new RC_Thread_07_A3();
+            a1_1.a2_0.a3_0.a4_0 = new RC_Thread_07_A4();
+            a1_1.a2_0.a3_0.a4_0.a1_0 = a1_1;
+            RC_Thread_07_A5 a5_1 = new RC_Thread_07_A5();
+            a1_1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_07_A6();
+            a1_1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_1;
+            a5_1.a3_0 = a1_1.a2_0.a3_0;
+            a1_main = a1_1;
+            a5_main = a5_1;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        Runtime.getRuntime().gc();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        RC_Thread_07_A1 a1 = new RC_Thread_07_A1();
+        a1.a2_0 = new RC_Thread_07_A2();
+        a1.a2_0.a3_0 = new RC_Thread_07_A3();
+        a1.a2_0.a3_0.a4_0 = new RC_Thread_07_A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        RC_Thread_07_A5 a5 = new RC_Thread_07_A5();
+        a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_07_A6();
+        a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+        a5.a3_0 = a1.a2_0.a3_0;
+        a1 = null;
+        a5 = null;
+
+        a1 = new RC_Thread_07_A1();
+        a1.a2_0 = new RC_Thread_07_A2();
+        a1.a2_0.a3_0 = new RC_Thread_07_A3();
+        a1.a2_0.a3_0.a4_0 = new RC_Thread_07_A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        a1 = null;
+
+        a1 = new RC_Thread_07_A1();
+        a1.a2_0 = new RC_Thread_07_A2();
+        a1.a2_0.a3_0 = new RC_Thread_07_A3();
+        a1.a2_0.a3_0.a4_0 = new RC_Thread_07_A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        a5 = new RC_Thread_07_A5();
+        a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_07_A6();
+        a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+        a5.a3_0 = a1.a2_0.a3_0;
+        a1.a2_0.a3_0 = null;
+        a1 = null;
+        a5 = null;
+
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_07_1 t1 = new RC_Thread_07_1();
+        RC_Thread_07_2 t2 = new RC_Thread_07_2();
+        RC_Thread_07_3 t3 = new RC_Thread_07_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void ModifyA1() {
+        a1_main.a2_0.a3_0 = null;
+        a1_main = null;
+    }
+
+    public void checkA4() {
+        try {
+            int[] arr = new int[2];
+            arr[0] = a5_main.a3_0.a4_0.sum;
+            arr[1] = a5_main.a3_0.a4_0.a;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA5() {
+        RC_Thread_07_A5 a5 = new RC_Thread_07_A5();
+        a5 = this.a5_main;
+        a5_main = null;
+    }
+
+    static class RC_Thread_07_A1 {
+        volatile RC_Thread_07_A2 a2_0;
+        volatile RC_Thread_07_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_07_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_07_A2 {
+        volatile RC_Thread_07_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_07_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_07_A3 {
+        volatile RC_Thread_07_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_07_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+
+    static class RC_Thread_07_A4 {
+        volatile RC_Thread_07_A1 a1_0;
+        volatile RC_Thread_07_A6 a6_0;
+        int a;
+        int sum;
+
+        RC_Thread_07_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_07_A5 {
+        volatile RC_Thread_07_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_07_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_07_A6 {
+        volatile RC_Thread_07_A5 a5_0;
+        int a;
+        int sum;
+
+        RC_Thread_07_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0235-rc-function-RC_Thread02-RC_Thread_08/RC_Thread_08.java b/test/testsuite/ouroboros/memory_management/Function/RC0235-rc-function-RC_Thread02-RC_Thread_08/RC_Thread_08.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e7efb8c86398c5ba5293ff500c69c5d76c0498c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0235-rc-function-RC_Thread02-RC_Thread_08/RC_Thread_08.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_08.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_08.java
+ *- @ExecuteClass: RC_Thread_08
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_08_1 extends Thread {
+    public void run() {
+        RC_Thread_08 rcth01 = new RC_Thread_08();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_08_2 extends Thread {
+    public void run() {
+        RC_Thread_08 rcth01 = new RC_Thread_08();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_08_3 extends Thread {
+    public void run() {
+        RC_Thread_08 rcth01 = new RC_Thread_08();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_08 {
+    private volatile static RC_Thread_08_A1 a1_main = null;
+    private volatile static RC_Thread_08_A4 a4_main = null;
+    private volatile static RC_Thread_08_A6 a6_main = null;
+
+    RC_Thread_08() {
+        try {
+            RC_Thread_08_A1 a1 = new RC_Thread_08_A1("a1");
+            RC_Thread_08_A4 a4 = new RC_Thread_08_A4("a4");
+            RC_Thread_08_A6 a6 = new RC_Thread_08_A6("a6");
+            a1.a2_0 = new RC_Thread_08_A2("a2_0");
+            a1.a2_0.a3_0 = new RC_Thread_08_A3("a3_0");
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1.a2_0.a3_0.a5_0 = new RC_Thread_08_A5("a5_0");
+            a1.a2_0.a3_0.a5_0.a6_0 = a6;
+            a6.a1_0 = a1;
+            a6.a3_0 = a1.a2_0.a3_0;
+            a4.a5_0 = a1.a2_0.a3_0.a5_0;
+            a6.a4_0 = a4;
+            a1_main = a1;
+            a4_main = a4;
+            a6_main = a6;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+
+    }
+
+    private static void cycle_pattern_wrapper() {
+        RC_Thread_08_A1 a1 = new RC_Thread_08_A1("a1");
+        RC_Thread_08_A4 a4 = new RC_Thread_08_A4("a4");
+        RC_Thread_08_A6 a6 = new RC_Thread_08_A6("a6");
+        a1.a2_0 = new RC_Thread_08_A2("a2_0");
+        a1.a2_0.a3_0 = new RC_Thread_08_A3("a3_0");
+        a1.a2_0.a3_0.a1_0 = a1;
+        a1.a2_0.a3_0.a5_0 = new RC_Thread_08_A5("a5_0");
+        a1.a2_0.a3_0.a5_0.a6_0 = a6;
+        a6.a1_0 = a1;
+        a6.a3_0 = a1.a2_0.a3_0;
+        a4.a5_0 = a1.a2_0.a3_0.a5_0;
+        a6.a4_0 = a4;
+        a1 = null;
+        a4 = null;
+        a6 = null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_08_1 t_00010 = new RC_Thread_08_1();
+        RC_Thread_08_2 t_00020 = new RC_Thread_08_2();
+        RC_Thread_08_3 t_00030 = new RC_Thread_08_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RC_Thread_08_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RC_Thread_08_A3 a3 = new RC_Thread_08_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RC_Thread_08_A1 {
+        volatile RC_Thread_08_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RC_Thread_08_A2 {
+        volatile RC_Thread_08_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_08_A3 {
+        volatile RC_Thread_08_A1 a1_0;
+        volatile RC_Thread_08_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RC_Thread_08_A4 {
+        volatile RC_Thread_08_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RC_Thread_08_A5 {
+        volatile RC_Thread_08_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_08_A6 {
+        volatile RC_Thread_08_A1 a1_0;
+        volatile RC_Thread_08_A3 a3_0;
+        volatile RC_Thread_08_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0236-rc-function-RC_Thread02-RC_Thread_09/RC_Thread_09.java b/test/testsuite/ouroboros/memory_management/Function/RC0236-rc-function-RC_Thread02-RC_Thread_09/RC_Thread_09.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4c576ad1e01c967251b4bbcafb6fc9b134b9605
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0236-rc-function-RC_Thread02-RC_Thread_09/RC_Thread_09.java
@@ -0,0 +1,434 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_09
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_09.java
+ *- @ExecuteClass: RC_Thread_09
+ *- @ExecuteArgs:
+
+ *
+ */
+
+class RC_Thread_09_1 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_09_2 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_09_3 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_09_4 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_09_5 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_09 {
+    private static RC_Thread_09_A1 a1_main = null;
+    private static RC_Thread_09_A2 a2_main = null;
+    private static RC_Thread_09_A3 a3_main = null;
+    private static RC_Thread_09_A4 a4_main = null;
+
+    RC_Thread_09() {
+        try {
+            a1_main = new RC_Thread_09_A1("a1_main");
+            a2_main = new RC_Thread_09_A2("a2_main");
+            a3_main = new RC_Thread_09_A3("a3_main");
+            a4_main = new RC_Thread_09_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_09_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_09_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_09_D2("d2_0");
+
+            a2_main.b2_0 = new RC_Thread_09_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_09_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_09_D1("d1_0");
+
+            a3_main.b2_0 = new RC_Thread_09_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_09_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+
+            a3_main.c2_0 = new RC_Thread_09_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+
+            a4_main.b3_0 = new RC_Thread_09_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_09_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_09_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_09_1 t1 = new RC_Thread_09_1();
+        RC_Thread_09_2 t2 = new RC_Thread_09_2();
+        RC_Thread_09_3 t3 = new RC_Thread_09_3();
+        RC_Thread_09_4 t4 = new RC_Thread_09_4();
+        RC_Thread_09_5 t5 = new RC_Thread_09_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA2null() {
+        a2_main = null;
+    }
+
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_09_D2("new");
+            a3_main = new RC_Thread_09_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        a3_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    class RC_Thread_09_A1 {
+        RC_Thread_09_B1 b1_0;
+        RC_Thread_09_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_A2 {
+        RC_Thread_09_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_A3 {
+        RC_Thread_09_B2 b2_0;
+        RC_Thread_09_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class RC_Thread_09_A4 {
+        RC_Thread_09_B3 b3_0;
+        RC_Thread_09_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_B1 {
+        RC_Thread_09_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_B2 {
+        RC_Thread_09_C1 c1_0;
+        RC_Thread_09_D1 d1_0;
+        RC_Thread_09_D2 d2_0;
+        RC_Thread_09_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_B3 {
+        RC_Thread_09_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_C1 {
+        RC_Thread_09_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class RC_Thread_09_C2 {
+        RC_Thread_09_D2 d2_0;
+        RC_Thread_09_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_09_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_09_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0237-rc-function-RC_Thread02-RC_Thread_10/RC_Thread_10.java b/test/testsuite/ouroboros/memory_management/Function/RC0237-rc-function-RC_Thread02-RC_Thread_10/RC_Thread_10.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ad19d63b30ba5ef65b8847110deea05be37b5db
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0237-rc-function-RC_Thread02-RC_Thread_10/RC_Thread_10.java
@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_10
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00050
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_10.java
+ *- @ExecuteClass: RC_Thread_10
+ *- @ExecuteArgs:
+
+ *
+ */
+class RC_Thread_10_1 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.addSum();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_10_2 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.ModifyB4();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_10_3 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.deleteA1();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_10_4 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.setA1(null);
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_10 {
+    private static RC_Thread_10_A1 a1 = null;
+
+    RC_Thread_10(String str) {
+        try {
+            a1 = new RC_Thread_10_A1("a1");
+            a1.b1_0 = new RC_Thread_10_B1("b1_0");
+            a1.b1_0.c1_0 = new RC_Thread_10_C1("c1_0");
+            a1.b1_0.c2_0 = new RC_Thread_10_C2("c2_0");
+            a1.b1_0.c3_0 = new RC_Thread_10_C3("c3_0");
+            a1.b2_0 = new RC_Thread_10_B2("b2_0");
+            a1.b3_0 = new RC_Thread_10_B3("b3_0");
+            a1.b4_0 = new RC_Thread_10_B4("b4_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_10_1 t1 = new RC_Thread_10_1();
+        RC_Thread_10_2 t2 = new RC_Thread_10_2();
+        RC_Thread_10_3 t3 = new RC_Thread_10_3();
+        RC_Thread_10_4 t4 = new RC_Thread_10_4();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void deleteA1() {
+        a1 = null;
+    }
+
+    public void ModifyB4() {
+        try {
+            a1.b4_0 = new RC_Thread_10_B4("new_b4");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void addSum() {
+        try {
+            a1.add();
+            a1.b1_0.add();
+            a1.b2_0.add();
+            a1.b3_0.add();
+            a1.b4_0.add();
+            a1.b1_0.c1_0.add();
+            a1.b1_0.c2_0.add();
+            a1.b1_0.c3_0.add();
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA1(RC_Thread_10_A1 a1) {
+        this.a1 = a1;
+    }
+
+    class RC_Thread_10_A1 {
+        RC_Thread_10_B1 b1_0;
+        RC_Thread_10_B2 b2_0;
+        RC_Thread_10_B3 b3_0;
+        RC_Thread_10_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class RC_Thread_10_B1 {
+        RC_Thread_10_C1 c1_0;
+        RC_Thread_10_C2 c2_0;
+        RC_Thread_10_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class RC_Thread_10_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+
+    class RC_Thread_10_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_10_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_10_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_10_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_10_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0238-rc-function-RC_Thread02-RC_Thread_11/RC_Thread_11.java b/test/testsuite/ouroboros/memory_management/Function/RC0238-rc-function-RC_Thread02-RC_Thread_11/RC_Thread_11.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba6f8da8c35bac04da808edce48a53bd523b01c5
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0238-rc-function-RC_Thread02-RC_Thread_11/RC_Thread_11.java
@@ -0,0 +1,437 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_11
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_11.java
+ *- @ExecuteClass: RC_Thread_11
+ *- @ExecuteArgs:
+
+ *
+ */
+
+class RC_Thread_11_1 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_11_2 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_11_3 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_11_4 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_11_5 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA4();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_11 {
+    private static RC_Thread_11_A1 a1_main = null;
+    private static RC_Thread_11_A2 a2_main = null;
+    private static RC_Thread_11_A3 a3_main = null;
+    private static RC_Thread_11_A4 a4_main = null;
+
+    RC_Thread_11() {
+        try {
+            a1_main = new RC_Thread_11_A1("a1_main");
+            a2_main = new RC_Thread_11_A2("a2_main");
+            a3_main = new RC_Thread_11_A3("a3_main");
+            a4_main = new RC_Thread_11_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_11_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_11_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_11_D2("d2_0");
+
+            a2_main.b2_0 = new RC_Thread_11_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_11_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_11_D1("d1_0");
+
+            a3_main.b2_0 = new RC_Thread_11_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_11_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+
+            a3_main.c2_0 = new RC_Thread_11_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+
+            a4_main.b3_0 = new RC_Thread_11_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_11_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_11_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_11_1 t1 = new RC_Thread_11_1();
+        RC_Thread_11_2 t2 = new RC_Thread_11_2();
+        RC_Thread_11_3 t3 = new RC_Thread_11_3();
+        RC_Thread_11_4 t4 = new RC_Thread_11_4();
+        RC_Thread_11_5 t5 = new RC_Thread_11_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA2null() {
+        a2_main = null;
+    }
+
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_11_D2("new");
+            a3_main = new RC_Thread_11_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        a3_main = null;
+    }
+
+    public void setA4() {
+        try {
+            a4_main = new RC_Thread_11_A4("a4_new");
+
+        } catch (NullPointerException e) {
+        }
+    }
+
+    class RC_Thread_11_A1 {
+        RC_Thread_11_B1 b1_0;
+        RC_Thread_11_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_A2 {
+        RC_Thread_11_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_A3 {
+        RC_Thread_11_B2 b2_0;
+        RC_Thread_11_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class RC_Thread_11_A4 {
+        RC_Thread_11_B3 b3_0;
+        RC_Thread_11_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_B1 {
+        RC_Thread_11_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_B2 {
+        RC_Thread_11_C1 c1_0;
+        RC_Thread_11_D1 d1_0;
+        RC_Thread_11_D2 d2_0;
+        RC_Thread_11_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_B3 {
+        RC_Thread_11_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_C1 {
+        RC_Thread_11_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class RC_Thread_11_C2 {
+        RC_Thread_11_D2 d2_0;
+        RC_Thread_11_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_11_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_11_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0239-rc-function-RC_Thread02-RC_Thread_12/RC_Thread_12.java b/test/testsuite/ouroboros/memory_management/Function/RC0239-rc-function-RC_Thread02-RC_Thread_12/RC_Thread_12.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8a09a5a5b8a009423f97425b26b967e87d8d526
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0239-rc-function-RC_Thread02-RC_Thread_12/RC_Thread_12.java
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_12
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_12.java
+ *- @ExecuteClass: RC_Thread_12
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_12_1 extends Thread {
+    public void run() {
+        RC_Thread_12 rcth01 = new RC_Thread_12();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_12_2 extends Thread {
+    public void run() {
+        RC_Thread_12 rcth01 = new RC_Thread_12();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_12_3 extends Thread {
+    public void run() {
+        RC_Thread_12 rcth01 = new RC_Thread_12();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_12 {
+    private static RC_Thread_12_A1 a1_main = null;
+    private static RC_Thread_12_A4 a4_main = null;
+    private static RC_Thread_12_A5 a5_main = null;
+
+    RC_Thread_12() {
+        try {
+            a1_main = new RC_Thread_12_A1();
+            a1_main.a2_0 = new RC_Thread_12_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_12_A3();
+            a4_main = new RC_Thread_12_A4();
+            a5_main = new RC_Thread_12_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        a1_main = new RC_Thread_12_A1();
+        a1_main.a2_0 = new RC_Thread_12_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_12_A3();
+        a4_main = new RC_Thread_12_A4();
+        a5_main = new RC_Thread_12_A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main = null;
+        a4_main = null;
+        a5_main = null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_12_1 t1 = new RC_Thread_12_1();
+        RC_Thread_12_2 t2 = new RC_Thread_12_2();
+        RC_Thread_12_3 t3 = new RC_Thread_12_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_12_A1 {
+        RC_Thread_12_A2 a2_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_12_A2 {
+        RC_Thread_12_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_12_A3 {
+        RC_Thread_12_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    static class RC_Thread_12_A4 {
+        RC_Thread_12_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    static class RC_Thread_12_A5 {
+        RC_Thread_12_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0240-rc-function-RC_Thread02-RC_Thread_13/RC_Thread_13.java b/test/testsuite/ouroboros/memory_management/Function/RC0240-rc-function-RC_Thread02-RC_Thread_13/RC_Thread_13.java
new file mode 100644
index 0000000000000000000000000000000000000000..4959459b6e7f07eefea694fcb58bd5fce934acd8
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0240-rc-function-RC_Thread02-RC_Thread_13/RC_Thread_13.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_13
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_13.java
+ *- @ExecuteClass: RC_Thread_13
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_13_1 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_13_2 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_13_3 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_13_4 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA1();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_13_5 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_13_6 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA3_a(5);
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_13 {
+    private static RC_Thread_13_A1 a1_main = null;
+    private static RC_Thread_13_A4 a4_main = null;
+    private static RC_Thread_13_A5 a5_main = null;
+
+    RC_Thread_13() {
+        try {
+            a1_main = new RC_Thread_13_A1();
+            a1_main.a2_0 = new RC_Thread_13_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_13_A3();
+            a4_main = new RC_Thread_13_A4();
+            a5_main = new RC_Thread_13_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_13_1 t1 = new RC_Thread_13_1();
+        RC_Thread_13_2 t2 = new RC_Thread_13_2();
+        RC_Thread_13_3 t3 = new RC_Thread_13_3();
+        RC_Thread_13_4 t4 = new RC_Thread_13_4();
+        RC_Thread_13_5 t5 = new RC_Thread_13_5();
+        RC_Thread_13_6 t6 = new RC_Thread_13_6();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        t6.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+            t6.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    public void setA1() {
+        try {
+            this.a1_main = new RC_Thread_13_A1();
+            a1_main.a2_0 = new RC_Thread_13_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_13_A3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    public void checkA3() {
+        try {
+            int a = a1_main.a2_0.a3_0.a;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    public void setA3_a(int a) {
+        try {
+            this.a1_main.a2_0.a3_0.a = a;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    class RC_Thread_13_A1 {
+        RC_Thread_13_A2 a2_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    class RC_Thread_13_A2 {
+        RC_Thread_13_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    class RC_Thread_13_A3 {
+        RC_Thread_13_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class RC_Thread_13_A4 {
+        RC_Thread_13_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    class RC_Thread_13_A5 {
+        RC_Thread_13_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0241-rc-function-RC_Thread02-RC_Thread_14/RC_Thread_14.java b/test/testsuite/ouroboros/memory_management/Function/RC0241-rc-function-RC_Thread02-RC_Thread_14/RC_Thread_14.java
new file mode 100644
index 0000000000000000000000000000000000000000..32876e88a0b5b13226321b87f73afcf52a36d50e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0241-rc-function-RC_Thread02-RC_Thread_14/RC_Thread_14.java
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_14
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_14.java
+ *- @ExecuteClass: RC_Thread_14
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_14_1 extends Thread {
+    public void run() {
+        RC_Thread_14 rcth01 = new RC_Thread_14();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_14_2 extends Thread {
+    public void run() {
+        RC_Thread_14 rcth01 = new RC_Thread_14();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_14_3 extends Thread {
+    public void run() {
+        RC_Thread_14 rcth01 = new RC_Thread_14();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+
+    }
+}
+
+public class RC_Thread_14 {
+    private static RC_Thread_14_A1 a1_main = null;
+    private static RC_Thread_14_A5 a5_main = null;
+
+    RC_Thread_14() {
+        try {
+            a1_main = new RC_Thread_14_A1();
+            a1_main.a2_0 = new RC_Thread_14_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+            a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+            a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+            a5_main = new RC_Thread_14_A5();
+            a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_14_A6();
+            a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+            a5_main.a3_0 = a1_main.a2_0.a3_0;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        Runtime.getRuntime().gc();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        a1_main = new RC_Thread_14_A1();
+        a1_main.a2_0 = new RC_Thread_14_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_14_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_14_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main = null;
+        a5_main = null;
+
+        a1_main = new RC_Thread_14_A1();
+        a1_main.a2_0 = new RC_Thread_14_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main = null;
+
+        a1_main = new RC_Thread_14_A1();
+        a1_main.a2_0 = new RC_Thread_14_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_14_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_14_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0 = null;
+        a1_main = null;
+        a5_main = null;
+        //Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_14_1 t1 = new RC_Thread_14_1();
+        RC_Thread_14_2 t2 = new RC_Thread_14_2();
+        RC_Thread_14_3 t3 = new RC_Thread_14_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        try {
+            a1_main.a2_0.a3_0.a4_0 = null;
+            a5_main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_14_A1 {
+        RC_Thread_14_A2 a2_0;
+        RC_Thread_14_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_14_A2 {
+        RC_Thread_14_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_14_A3 {
+        RC_Thread_14_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+
+    static class RC_Thread_14_A4 {
+        RC_Thread_14_A1 a1_0;
+        RC_Thread_14_A6 a6_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_14_A5 {
+        RC_Thread_14_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_14_A6 {
+        RC_Thread_14_A5 a5_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0242-rc-function-RC_Thread02-RC_Thread_15/RC_Thread_15.java b/test/testsuite/ouroboros/memory_management/Function/RC0242-rc-function-RC_Thread02-RC_Thread_15/RC_Thread_15.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2f3da433694db349fe5a05b2535a1a452db126d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0242-rc-function-RC_Thread02-RC_Thread_15/RC_Thread_15.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_15
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_15.java
+ *- @ExecuteClass: RC_Thread_15
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_15_1 extends Thread {
+    public void run() {
+        RC_Thread_15 rcth01 = new RC_Thread_15();
+        try {
+            rcth01.ModifyA1();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_15_2 extends Thread {
+    public void run() {
+        RC_Thread_15 rcth01 = new RC_Thread_15();
+        try {
+            rcth01.checkA4();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_15_3 extends Thread {
+    public void run() {
+        RC_Thread_15 rcth01 = new RC_Thread_15();
+        try {
+            rcth01.setA5();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_15 {
+    private static RC_Thread_15_A1 a1_main = null;
+    private static RC_Thread_15_A5 a5_main = null;
+
+    RC_Thread_15() {
+        try {
+            RC_Thread_15_A1 a1 = new RC_Thread_15_A1();
+            a1.a2_0 = new RC_Thread_15_A2();
+            a1.a2_0.a3_0 = new RC_Thread_15_A3();
+            a1.a2_0.a3_0.a4_0 = new RC_Thread_15_A4();
+            a1.a2_0.a3_0.a4_0.a1_0 = a1;
+            RC_Thread_15_A5 a5 = new RC_Thread_15_A5();
+            a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_15_A6();
+            a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+            a5.a3_0 = a1.a2_0.a3_0;
+            a1_main = a1;
+            a5_main = a5;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        RC_Thread_15_A1 a1 = new RC_Thread_15_A1();
+        a1.a2_0 = new RC_Thread_15_A2();
+        a1.a2_0.a3_0 = new RC_Thread_15_A3();
+        a1.a2_0.a3_0.a4_0 = new RC_Thread_15_A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        RC_Thread_15_A5 a5 = new RC_Thread_15_A5();
+        a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_15_A6();
+        a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+        a5.a3_0 = a1.a2_0.a3_0;
+        a1 = null;
+        a5 = null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_15_1 t1 = new RC_Thread_15_1();
+        RC_Thread_15_2 t2 = new RC_Thread_15_2();
+        RC_Thread_15_3 t3 = new RC_Thread_15_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void ModifyA1() {
+        a1_main.a2_0.a3_0 = null;
+        a1_main = null;
+    }
+
+    public void checkA4() {
+        try {
+            int[] arr = new int[2];
+            arr[0] = a5_main.a3_0.a4_0.sum;
+            arr[1] = a5_main.a3_0.a4_0.a;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA5() {
+        RC_Thread_15_A5 a5 = new RC_Thread_15_A5();
+        a5 = this.a5_main;
+        a5_main = null;
+    }
+
+    static class RC_Thread_15_A1 {
+        RC_Thread_15_A2 a2_0;
+        RC_Thread_15_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_15_A2 {
+        RC_Thread_15_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_15_A3 {
+        RC_Thread_15_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+
+    static class RC_Thread_15_A4 {
+        RC_Thread_15_A1 a1_0;
+        RC_Thread_15_A6 a6_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_15_A5 {
+        RC_Thread_15_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_15_A6 {
+        RC_Thread_15_A5 a5_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0243-rc-function-RC_Thread02-RC_Thread_16/RC_Thread_16.java b/test/testsuite/ouroboros/memory_management/Function/RC0243-rc-function-RC_Thread02-RC_Thread_16/RC_Thread_16.java
new file mode 100644
index 0000000000000000000000000000000000000000..5184b08462fd36b0ce3c9ce7f0ae3e2d396ca197
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0243-rc-function-RC_Thread02-RC_Thread_16/RC_Thread_16.java
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_16
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_16.java
+ *- @ExecuteClass: RC_Thread_16
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_16_1 extends Thread {
+    public void run() {
+        RC_Thread_16 rcth01 = new RC_Thread_16();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_16_2 extends Thread {
+    public void run() {
+        RC_Thread_16 rcth01 = new RC_Thread_16();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_16_3 extends Thread {
+    public void run() {
+        RC_Thread_16 rcth01 = new RC_Thread_16();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_16 {
+    private static RC_Thread_16_A1 a1_main = null;
+    private static RC_Thread_16_A4 a4_main = null;
+    private static RC_Thread_16_A6 a6_main = null;
+
+    RC_Thread_16() {
+        try {
+            RC_Thread_16_A1 a1 = new RC_Thread_16_A1("a1");
+            RC_Thread_16_A4 a4 = new RC_Thread_16_A4("a4");
+            RC_Thread_16_A6 a6 = new RC_Thread_16_A6("a6");
+            a1.a2_0 = new RC_Thread_16_A2("a2_0");
+            a1.a2_0.a3_0 = new RC_Thread_16_A3("a3_0");
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1.a2_0.a3_0.a5_0 = new RC_Thread_16_A5("a5_0");
+            a1.a2_0.a3_0.a5_0.a6_0 = a6;
+            a6.a1_0 = a1;
+            a6.a3_0 = a1.a2_0.a3_0;
+            a4.a5_0 = a1.a2_0.a3_0.a5_0;
+            a6.a4_0 = a4;
+            a1_main = a1;
+            a4_main = a4;
+            a6_main = a6;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        RC_Thread_16_A1 a1 = new RC_Thread_16_A1("a1");
+        RC_Thread_16_A4 a4 = new RC_Thread_16_A4("a4");
+        RC_Thread_16_A6 a6 = new RC_Thread_16_A6("a6");
+        a1.a2_0 = new RC_Thread_16_A2("a2_0");
+        a1.a2_0.a3_0 = new RC_Thread_16_A3("a3_0");
+        a1.a2_0.a3_0.a1_0 = a1;
+        a1.a2_0.a3_0.a5_0 = new RC_Thread_16_A5("a5_0");
+        a1.a2_0.a3_0.a5_0.a6_0 = a6;
+        a6.a1_0 = a1;
+        a6.a3_0 = a1.a2_0.a3_0;
+        a4.a5_0 = a1.a2_0.a3_0.a5_0;
+        a6.a4_0 = a4;
+        a1 = null;
+        a4 = null;
+        a6 = null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_16_1 t_00010 = new RC_Thread_16_1();
+        RC_Thread_16_2 t_00020 = new RC_Thread_16_2();
+        RC_Thread_16_3 t_00030 = new RC_Thread_16_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RC_Thread_16_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RC_Thread_16_A3 a3 = new RC_Thread_16_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RC_Thread_16_A1 {
+        RC_Thread_16_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RC_Thread_16_A2 {
+        RC_Thread_16_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_16_A3 {
+        RC_Thread_16_A1 a1_0;
+        RC_Thread_16_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RC_Thread_16_A4 {
+        RC_Thread_16_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RC_Thread_16_A5 {
+        RC_Thread_16_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_16_A6 {
+        RC_Thread_16_A1 a1_0;
+        RC_Thread_16_A3 a3_0;
+        RC_Thread_16_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0244-rc-function-RC_Thread02-RC_Thread_17/RC_Thread_17.java b/test/testsuite/ouroboros/memory_management/Function/RC0244-rc-function-RC_Thread02-RC_Thread_17/RC_Thread_17.java
new file mode 100644
index 0000000000000000000000000000000000000000..6cee733592ba4c3286b7229de2ec45b85f0ba688
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0244-rc-function-RC_Thread02-RC_Thread_17/RC_Thread_17.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_17
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_17.java
+ *- @ExecuteClass: RC_Thread_17
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_17_1 extends Thread {
+    public void run() {
+        RC_Thread_17 rcth01 = new RC_Thread_17();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_17_2 extends Thread {
+    public void run() {
+        RC_Thread_17 rcth01 = new RC_Thread_17();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_17_3 extends Thread {
+    public void run() {
+        RC_Thread_17 rcth01 = new RC_Thread_17();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_17 {
+    private static RC_Thread_17_A1 a1_main = null;
+    private static RC_Thread_17_A4 a4_main = null;
+    private static RC_Thread_17_A5 a5_main = null;
+    private static RC_Thread_17_A2 a2 = null;
+
+    RC_Thread_17() {
+        try {
+            a1_main = new RC_Thread_17_A1();
+            a2 = new RC_Thread_17_A2();
+            a1_main.a2_0 = a2;
+            a1_main.a2_0.a3_0 = new RC_Thread_17_A3();
+            a4_main = new RC_Thread_17_A4();
+            a5_main = new RC_Thread_17_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        a1_main = new RC_Thread_17_A1();
+        a2 = new RC_Thread_17_A2();
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a3_0 = new RC_Thread_17_A3();
+        a4_main = new RC_Thread_17_A4();
+        a5_main = new RC_Thread_17_A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main = null;
+        a4_main = null;
+        a2 = null;
+        a5_main = null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_17_1 t1 = new RC_Thread_17_1();
+        RC_Thread_17_2 t2 = new RC_Thread_17_2();
+        RC_Thread_17_3 t3 = new RC_Thread_17_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_17_A1 {
+        RC_Thread_17_A2 a2_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_17_A2 {
+        RC_Thread_17_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_17_A3 {
+        RC_Thread_17_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    static class RC_Thread_17_A4 {
+        RC_Thread_17_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    static class RC_Thread_17_A5 {
+        RC_Thread_17_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0245-rc-function-RC_Thread02-RC_Thread_18/RC_Thread_18.java b/test/testsuite/ouroboros/memory_management/Function/RC0245-rc-function-RC_Thread02-RC_Thread_18/RC_Thread_18.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2b58011b9898735727f46007d708caa3e89293a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0245-rc-function-RC_Thread02-RC_Thread_18/RC_Thread_18.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_18.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_18.java
+ *- @ExecuteClass: RC_Thread_18
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_18_1 extends Thread {
+    public void run() {
+        RC_Thread_18 rcth01 = new RC_Thread_18();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_18_2 extends Thread {
+    public void run() {
+        RC_Thread_18 rcth01 = new RC_Thread_18();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_18_3 extends Thread {
+    public void run() {
+        RC_Thread_18 rcth01 = new RC_Thread_18();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_18 {
+    private volatile static RC_Thread_18_A1 a1_main = null;
+    private volatile static RC_Thread_18_A4 a4_main = null;
+    private volatile static RC_Thread_18_A6 a6_main = null;
+    private static RC_Thread_18_A2 a2 = null;
+
+    RC_Thread_18() {
+        try {
+            RC_Thread_18_A1 a1 = new RC_Thread_18_A1("a1");
+            RC_Thread_18_A4 a4 = new RC_Thread_18_A4("a4");
+            RC_Thread_18_A6 a6 = new RC_Thread_18_A6("a6");
+            a2 = new RC_Thread_18_A2("a2_0");
+            a1.a2_0 = a2;
+            a1.a2_0.a3_0 = new RC_Thread_18_A3("a3_0");
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1.a2_0.a3_0.a5_0 = new RC_Thread_18_A5("a5_0");
+            a1.a2_0.a3_0.a5_0.a6_0 = a6;
+            a6.a1_0 = a1;
+            a6.a3_0 = a1.a2_0.a3_0;
+            a4.a5_0 = a1.a2_0.a3_0.a5_0;
+            a6.a4_0 = a4;
+            a1_main = a1;
+            a4_main = a4;
+            a6_main = a6;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+
+    }
+
+    private static void cycle_pattern_wrapper() {
+        RC_Thread_18_A1 a1 = new RC_Thread_18_A1("a1");
+        RC_Thread_18_A4 a4 = new RC_Thread_18_A4("a4");
+        RC_Thread_18_A6 a6 = new RC_Thread_18_A6("a6");
+        a2 = new RC_Thread_18_A2("a2_0");
+        a1.a2_0 = a2;
+        a1.a2_0.a3_0 = new RC_Thread_18_A3("a3_0");
+        a1.a2_0.a3_0.a1_0 = a1;
+        a1.a2_0.a3_0.a5_0 = new RC_Thread_18_A5("a5_0");
+        a1.a2_0.a3_0.a5_0.a6_0 = a6;
+        a6.a1_0 = a1;
+        a6.a3_0 = a1.a2_0.a3_0;
+        a4.a5_0 = a1.a2_0.a3_0.a5_0;
+        a6.a4_0 = a4;
+        a1 = null;
+        a2 = null;
+        a4 = null;
+        a6 = null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_18_1 t_00010 = new RC_Thread_18_1();
+        RC_Thread_18_2 t_00020 = new RC_Thread_18_2();
+        RC_Thread_18_3 t_00030 = new RC_Thread_18_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RC_Thread_18_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RC_Thread_18_A3 a3 = new RC_Thread_18_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RC_Thread_18_A1 {
+        volatile RC_Thread_18_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RC_Thread_18_A2 {
+        volatile RC_Thread_18_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_18_A3 {
+        volatile RC_Thread_18_A1 a1_0;
+        volatile RC_Thread_18_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RC_Thread_18_A4 {
+        volatile RC_Thread_18_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RC_Thread_18_A5 {
+        volatile RC_Thread_18_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_18_A6 {
+        volatile RC_Thread_18_A1 a1_0;
+        volatile RC_Thread_18_A3 a3_0;
+        volatile RC_Thread_18_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0246-rc-function-RC_Thread02-RC_Thread_19/RC_Thread_19.java b/test/testsuite/ouroboros/memory_management/Function/RC0246-rc-function-RC_Thread02-RC_Thread_19/RC_Thread_19.java
new file mode 100644
index 0000000000000000000000000000000000000000..b292547ee529204ac0a7976720bf485d40a305bf
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0246-rc-function-RC_Thread02-RC_Thread_19/RC_Thread_19.java
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_19
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00050
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_19.java
+ *- @ExecuteClass: RC_Thread_19
+ *- @ExecuteArgs:
+
+ *
+ */
+class RC_Thread_19_1 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.addSum();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_19_2 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.ModifyB4();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_19_3 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.deleteA1();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_19_4 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.setA1(null);
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_19 {
+    private static RC_Thread_19_A1 a1 = null;
+    private volatile static RC_Thread_19_B4 b4;
+
+    RC_Thread_19(String str) {
+        try {
+            a1 = new RC_Thread_19_A1("a1");
+            a1.b1_0 = new RC_Thread_19_B1("b1_0");
+            a1.b1_0.c1_0 = new RC_Thread_19_C1("c1_0");
+            a1.b1_0.c2_0 = new RC_Thread_19_C2("c2_0");
+            a1.b1_0.c3_0 = new RC_Thread_19_C3("c3_0");
+            a1.b2_0 = new RC_Thread_19_B2("b2_0");
+            a1.b3_0 = new RC_Thread_19_B3("b3_0");
+            b4 = new RC_Thread_19_B4("b4_0");
+            a1.b4_0 = b4;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_19_1 t1 = new RC_Thread_19_1();
+        RC_Thread_19_2 t2 = new RC_Thread_19_2();
+        RC_Thread_19_3 t3 = new RC_Thread_19_3();
+        RC_Thread_19_4 t4 = new RC_Thread_19_4();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void deleteA1() {
+        a1 = null;
+    }
+
+    public void ModifyB4() {
+        try {
+            a1.b4_0 = new RC_Thread_19_B4("new_b4");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void addSum() {
+        try {
+            a1.add();
+            a1.b1_0.add();
+            a1.b2_0.add();
+            a1.b3_0.add();
+            a1.b4_0.add();
+            a1.b1_0.c1_0.add();
+            a1.b1_0.c2_0.add();
+            a1.b1_0.c3_0.add();
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA1(RC_Thread_19_A1 a1) {
+        this.a1 = a1;
+    }
+
+    class RC_Thread_19_A1 {
+        RC_Thread_19_B1 b1_0;
+        RC_Thread_19_B2 b2_0;
+        RC_Thread_19_B3 b3_0;
+        RC_Thread_19_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class RC_Thread_19_B1 {
+        RC_Thread_19_C1 c1_0;
+        RC_Thread_19_C2 c2_0;
+        RC_Thread_19_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class RC_Thread_19_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+
+    class RC_Thread_19_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_19_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_19_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_19_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_19_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0247-rc-function-RC_Thread02-RC_Thread_20/RC_Thread_20.java b/test/testsuite/ouroboros/memory_management/Function/RC0247-rc-function-RC_Thread02-RC_Thread_20/RC_Thread_20.java
new file mode 100644
index 0000000000000000000000000000000000000000..37610e5b42f9fda516b3957d6c6479d190197f86
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0247-rc-function-RC_Thread02-RC_Thread_20/RC_Thread_20.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_20
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_20.java
+ *- @ExecuteClass: RC_Thread_20
+ *- @ExecuteArgs:
+
+ *
+ */
+
+import java.lang.Runtime;
+
+class RC_Thread_20_1 extends Thread {
+    public void run() {
+        RC_Thread_20 rcth01 = new RC_Thread_20();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_20_2 extends Thread {
+    public void run() {
+        RC_Thread_20 rcth01 = new RC_Thread_20();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_20_3 extends Thread {
+    public void run() {
+        RC_Thread_20 rcth01 = new RC_Thread_20();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+
+    }
+}
+
+public class RC_Thread_20 {
+    private static RC_Thread_20_A1 a1_main = null;
+    private static RC_Thread_20_A5 a5_main = null;
+    private static RC_Thread_20_A4 a4;
+
+    RC_Thread_20() {
+        try {
+            RC_Thread_20_A1 a1 = new RC_Thread_20_A1();
+            a1.a2_0 = new RC_Thread_20_A2();
+            a1.a2_0.a3_0 = new RC_Thread_20_A3();
+            RC_Thread_20_A4 a4_temp = new RC_Thread_20_A4();
+            a1.a2_0.a3_0.a4_0 = a4_temp;
+            a1.a2_0.a3_0.a4_0.a1_0 = a1;
+            RC_Thread_20_A5 a5 = new RC_Thread_20_A5();
+            a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_20_A6();
+            a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+            a5.a3_0 = a1.a2_0.a3_0;
+            a1_main = a1;
+            a4 = a4_temp;
+            a5_main = a5;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        Runtime.getRuntime().gc();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper() {
+        a1_main = new RC_Thread_20_A1();
+        a1_main.a2_0 = new RC_Thread_20_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_20_A3();
+        a4 = new RC_Thread_20_A4();
+        a1_main.a2_0.a3_0.a4_0 = a4;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_20_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_20_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main = null;
+        a4 = null;
+        a5_main = null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_20_1 t1 = new RC_Thread_20_1();
+        RC_Thread_20_2 t2 = new RC_Thread_20_2();
+        RC_Thread_20_3 t3 = new RC_Thread_20_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        try {
+            a1_main.a2_0.a3_0.a4_0 = null;
+            a5_main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_20_A1 {
+        RC_Thread_20_A2 a2_0;
+        RC_Thread_20_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_20_A2 {
+        RC_Thread_20_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_20_A3 {
+        RC_Thread_20_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+
+    static class RC_Thread_20_A4 {
+        RC_Thread_20_A1 a1_0;
+        RC_Thread_20_A6 a6_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_20_A5 {
+        RC_Thread_20_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_20_A6 {
+        RC_Thread_20_A5 a5_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0248-rc-function-RC_Finalize_02/RC_Finalize_02.java b/test/testsuite/ouroboros/memory_management/Function/RC0248-rc-function-RC_Finalize_02/RC_Finalize_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..46d5eb230841253939b7a16142e2992ed5740621
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0248-rc-function-RC_Finalize_02/RC_Finalize_02.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_Finalize_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test Finalizer for RC .
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Finalize_02.java
+ *- @ExecuteClass: RC_Finalize_02
+ *- @ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class RC_Finalize_02 {
+
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        return 0;
+    }
+
+    public static void main(String argv[]) {
+
+        System.runFinalizersOnExit(true);
+        RC_Finalize_02 testClass = new RC_Finalize_02();
+    }
+} // end RC_Finalize_02
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/Alloc_11_15x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/Alloc_11_15x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..485b5ab598d9f7a3d9ff43877544af00dfedcd90
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/Alloc_11_15x8B.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_11_15x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 11*8B to 15*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_11_15x8B.java
+ *- @ExecuteClass: Alloc_11_15x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_11_15x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_11_8B = 11 * 8;
+    private final static int MAX_12_8B = 12 * 8;
+    private final static int MAX_13_8B = 13 * 8;
+    private final static int MAX_14_8B = 14 * 8;
+    private final static int MAX_15_8B = 15 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 2 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize11 = alloc_test(MAX_11_8B);
+        int countSize12 = alloc_test(MAX_12_8B);
+        int countSize13 = alloc_test(MAX_13_8B);
+        int countSize14 = alloc_test(MAX_14_8B);
+        int countSize15 = alloc_test(MAX_15_8B);
+        //System.out.println(countSize11);
+        //System.out.println(countSize12);
+        //System.out.println(countSize13);
+        //System.out.println(countSize14);
+        //System.out.println(countSize15);
+
+        if (countSize11 == 853 && countSize12 == 788 && countSize13 == 728 && countSize14 == 681 && countSize15 == 639)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0251-rc-function-ROSAlloc-Alloc_128x8B/Alloc_128x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0251-rc-function-ROSAlloc-Alloc_128x8B/Alloc_128x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..90ae56eb39b0623286d55133e87fc8cb25f8b615
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0251-rc-function-ROSAlloc-Alloc_128x8B/Alloc_128x8B.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_128x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 64*8B to 128*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_128x8B.java
+ *- @ExecuteClass: Alloc_128x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_128x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B = 128 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i = i + 3) {
+            for (int j = 0; j < (PAGE_SIZE * 256 / (i + OBJ_HEADSIZE) + 5); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum += store.size();
+            store = new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+
+        int result = alloc_test(MAX_128_8B);
+        //System.out.println(result);
+        if (result == 243561)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/Alloc_16_20x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/Alloc_16_20x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2621d02895e21677a302fa7c1a3a630a19ed5c0
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/Alloc_16_20x8B.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_16_20x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 16*8B to 20*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_16_20x8B.java
+ *- @ExecuteClass: Alloc_16_20x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_16_20x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_16_8B = 16 * 8;
+    private final static int MAX_17_8B = 17 * 8;
+    private final static int MAX_18_8B = 18 * 8;
+    private final static int MAX_19_8B = 19 * 8;
+    private final static int MAX_20_8B = 20 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 2 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize16 = alloc_test(MAX_16_8B);
+        int countSize17 = alloc_test(MAX_17_8B);
+        int countSize18 = alloc_test(MAX_18_8B);
+        int countSize19 = alloc_test(MAX_19_8B);
+        int countSize20 = alloc_test(MAX_20_8B);
+        //System.out.println(countSize16);
+        //System.out.println(countSize17);
+        //System.out.println(countSize18);
+        //System.out.println(countSize19);
+        //System.out.println(countSize20);
+
+        if (countSize16 == 604 && countSize17 == 572 && countSize18 == 542 && countSize19 == 517 && countSize20 == 495)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0253-rc-function-ROSAlloc-Alloc_192x8B/Alloc_192x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0253-rc-function-ROSAlloc-Alloc_192x8B/Alloc_192x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..e08ca838bfdba5feda6f9a3c67110fff47bb6eac
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0253-rc-function-ROSAlloc-Alloc_192x8B/Alloc_192x8B.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_192x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing big objects from 128*8B to 192*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_192x8B.java
+ *- @ExecuteClass: Alloc_192x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_192x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_192_8B = 192 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 + 1 - OBJ_HEADSIZE; i <= slot_type - OBJ_HEADSIZE; i = i + 6) {
+            for (int j = 0; j < (PAGE_SIZE * 2560 / (i + OBJ_HEADSIZE) + 5); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum += store.size();
+            store = new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_192_8B);
+        //System.out.println(result);
+        if (result == 714677)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/Alloc_21_25x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/Alloc_21_25x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..4248a2e56a2ebe91dc25a252c9e7af7efb5b8c8d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/Alloc_21_25x8B.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_21_25x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 21*8B to 25*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_21_25x8B.java
+ *- @ExecuteClass: Alloc_21_25x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_21_25x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_21_8B = 21 * 8;
+    private final static int MAX_22_8B = 22 * 8;
+    private final static int MAX_23_8B = 23 * 8;
+    private final static int MAX_24_8B = 24 * 8;
+    private final static int MAX_25_8B = 25 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 3 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize21 = alloc_test(MAX_21_8B);
+        int countSize22 = alloc_test(MAX_22_8B);
+        int countSize23 = alloc_test(MAX_23_8B);
+        int countSize24 = alloc_test(MAX_24_8B);
+        int countSize25 = alloc_test(MAX_25_8B);
+        //System.out.println(countSize21);
+        //System.out.println(countSize22);
+        //System.out.println(countSize23);
+        //System.out.println(countSize24);
+        //System.out.println(countSize25);
+
+        if (countSize21 == 674 && countSize22 == 646 && countSize23 == 621 && countSize24 == 599 && countSize25 == 577)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0255-rc-function-ROSAlloc-Alloc_256x8B/Alloc_256x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0255-rc-function-ROSAlloc-Alloc_256x8B/Alloc_256x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7ae2aafef3cc673852bb3c21cd52199a8d87e24
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0255-rc-function-ROSAlloc-Alloc_256x8B/Alloc_256x8B.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_256x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing big objects from 192*8B to 256*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_256x8B.java
+ *- @ExecuteClass: Alloc_256x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_256x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_256_8B = 256 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 + 1 - OBJ_HEADSIZE; i <= slot_type - OBJ_HEADSIZE; i = i + 256) {
+            for (int j = 0; j < (PAGE_SIZE * 5120 / (i + OBJ_HEADSIZE) + 5); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum += store.size();
+            store = new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_256_8B);
+        //System.out.println(result);
+        if (result == 62191)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/Alloc_26_30x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/Alloc_26_30x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..98ac62f0c6c24dafc6c5254ed5568f395b2c55f4
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/Alloc_26_30x8B.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_26_30x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 26*8B to 30*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_26_30x8B.java
+ *- @ExecuteClass: Alloc_26_30x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_26_30x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_26_8B = 26 * 8;
+    private final static int MAX_27_8B = 27 * 8;
+    private final static int MAX_28_8B = 28 * 8;
+    private final static int MAX_29_8B = 29 * 8;
+    private final static int MAX_30_8B = 30 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 3 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize26 = alloc_test(MAX_26_8B);
+        int countSize27 = alloc_test(MAX_27_8B);
+        int countSize28 = alloc_test(MAX_28_8B);
+        int countSize29 = alloc_test(MAX_29_8B);
+        int countSize30 = alloc_test(MAX_30_8B);
+        //System.out.println(countSize26);
+        //System.out.println(countSize27);
+        //System.out.println(countSize28);
+        //System.out.println(countSize29);
+        //System.out.println(countSize30);
+
+        if (countSize26 == 557 && countSize27 == 538 && countSize28 == 522 && countSize29 == 506 && countSize30 == 492)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/Alloc_3_10x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/Alloc_3_10x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..d25034fdd8bc5e0fc5fabb43f252ffdb8c46da16
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/Alloc_3_10x8B.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_3_10x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 3*8B to 10*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_3_10x8B.java
+ *- @ExecuteClass: Alloc_3_10x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_3_10x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_3_8B = 3 * 8;
+    private final static int MAX_4_8B = 4 * 8;
+    private final static int MAX_5_8B = 5 * 8;
+    private final static int MAX_6_8B = 6 * 8;
+    private final static int MAX_7_8B = 7 * 8;
+    private final static int MAX_8_8B = 8 * 8;
+    private final static int MAX_9_8B = 9 * 8;
+    private final static int MAX_10_8B = 10 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize3 = alloc_test(MAX_3_8B);
+        int countSize4 = alloc_test(MAX_4_8B);
+        int countSize5 = alloc_test(MAX_5_8B);
+        int countSize6 = alloc_test(MAX_6_8B);
+        int countSize7 = alloc_test(MAX_7_8B);
+        int countSize8 = alloc_test(MAX_8_8B);
+        int countSize9 = alloc_test(MAX_9_8B);
+        int countSize10 = alloc_test(MAX_10_8B);
+        if (countSize3 == 4488 && countSize4 == 1234 && countSize5 == 978 && countSize6 == 816 && countSize7 == 701 && countSize8 == 620 && countSize9 == 556 && countSize10 == 505)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/Alloc_31_35x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/Alloc_31_35x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..b41490859e04ae37563e5641e660b4b0606bbe91
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/Alloc_31_35x8B.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_31_35x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 31*8B to 35*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_31_35x8B.java
+ *- @ExecuteClass: Alloc_31_35x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_31_35x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_31_8B = 31 * 8;
+    private final static int MAX_32_8B = 32 * 8;
+    private final static int MAX_33_8B = 33 * 8;
+    private final static int MAX_34_8B = 34 * 8;
+    private final static int MAX_35_8B = 35 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 4 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize31 = alloc_test(MAX_31_8B);
+        int countSize32 = alloc_test(MAX_32_8B);
+        int countSize33 = alloc_test(MAX_33_8B);
+        int countSize34 = alloc_test(MAX_34_8B);
+        int countSize35 = alloc_test(MAX_35_8B);
+        //System.out.println(countSize31);
+        //System.out.println(countSize32);
+        //System.out.println(countSize33);
+        //System.out.println(countSize34);
+        //System.out.println(countSize35);
+
+        if (countSize31 == 612 && countSize32 == 596 && countSize33 == 580 && countSize34 == 564 && countSize35 == 550)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/Alloc_36_40x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/Alloc_36_40x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1f90c58fb20262647864d699218931000656600
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/Alloc_36_40x8B.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_36_40x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 36*8B to 40*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_36_40x8B.java
+ *- @ExecuteClass: Alloc_36_40x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_36_40x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_36_8B = 36 * 8;
+    private final static int MAX_37_8B = 37 * 8;
+    private final static int MAX_38_8B = 38 * 8;
+    private final static int MAX_39_8B = 39 * 8;
+    private final static int MAX_40_8B = 40 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 4 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize36 = alloc_test(MAX_36_8B);
+        int countSize37 = alloc_test(MAX_37_8B);
+        int countSize38 = alloc_test(MAX_38_8B);
+        int countSize39 = alloc_test(MAX_39_8B);
+        int countSize40 = alloc_test(MAX_40_8B);
+        //System.out.println(countSize36);
+        //System.out.println(countSize37);
+        //System.out.println(countSize38);
+        //System.out.println(countSize39);
+        //System.out.println(countSize40);
+
+        if (countSize36 == 537 && countSize37 == 524 && countSize38 == 512 && countSize39 == 501 && countSize40 == 491)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/Alloc_41_45x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/Alloc_41_45x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f0848979934200ff8eeaee1864e5d834cccf281
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/Alloc_41_45x8B.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_41_45x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 41*8B to 45*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_41_45x8B.java
+ *- @ExecuteClass: Alloc_41_45x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_41_45x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_41_8B = 41 * 8;
+    private final static int MAX_42_8B = 42 * 8;
+    private final static int MAX_43_8B = 43 * 8;
+    private final static int MAX_44_8B = 44 * 8;
+    private final static int MAX_45_8B = 45 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 5 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize41 = alloc_test(MAX_41_8B);
+        int countSize42 = alloc_test(MAX_42_8B);
+        int countSize43 = alloc_test(MAX_43_8B);
+        int countSize44 = alloc_test(MAX_44_8B);
+        int countSize45 = alloc_test(MAX_45_8B);
+        //System.out.println(countSize41);
+        //System.out.println(countSize42);
+        //System.out.println(countSize43);
+        //System.out.println(countSize44);
+        //System.out.println(countSize45);
+
+        if (countSize41 == 581 && countSize42 == 569 && countSize43 == 557 && countSize44 == 547 && countSize45 == 536)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/Alloc_46_50x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/Alloc_46_50x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad0ff703e1903b5e44a250973435aa40bc2edf5f
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/Alloc_46_50x8B.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_46_50x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 46*8B to 50*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_46_50x8B.java
+ *- @ExecuteClass: Alloc_46_50x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_46_50x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_46_8B = 46 * 8;
+    private final static int MAX_47_8B = 47 * 8;
+    private final static int MAX_48_8B = 48 * 8;
+    private final static int MAX_49_8B = 49 * 8;
+    private final static int MAX_50_8B = 50 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 5 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize46 = alloc_test(MAX_46_8B);
+        int countSize47 = alloc_test(MAX_47_8B);
+        int countSize48 = alloc_test(MAX_48_8B);
+        int countSize49 = alloc_test(MAX_49_8B);
+        int countSize50 = alloc_test(MAX_50_8B);
+        //System.out.println(countSize46);
+        //System.out.println(countSize47);
+        //System.out.println(countSize48);
+        //System.out.println(countSize49);
+        //System.out.println(countSize50);
+
+        if (countSize46 == 525 && countSize47 == 516 && countSize48 == 507 && countSize49 == 498 && countSize50 == 489)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/Alloc_51_55x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/Alloc_51_55x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..d784ca35cfe7b4d42dae71e9fa85753d97e2c7d3
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/Alloc_51_55x8B.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_51_55x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 51*8B to 55*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_51_55x8B.java
+ *- @ExecuteClass: Alloc_51_55x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_51_55x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_51_8B = 51 * 8;
+    private final static int MAX_52_8B = 52 * 8;
+    private final static int MAX_53_8B = 53 * 8;
+    private final static int MAX_54_8B = 54 * 8;
+    private final static int MAX_55_8B = 55 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 6 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize51 = alloc_test(MAX_51_8B);
+        int countSize52 = alloc_test(MAX_52_8B);
+        int countSize53 = alloc_test(MAX_53_8B);
+        int countSize54 = alloc_test(MAX_54_8B);
+        int countSize55 = alloc_test(MAX_55_8B);
+        //System.out.println(countSize51);
+        //System.out.println(countSize52);
+        //System.out.println(countSize53);
+        //System.out.println(countSize54);
+        //System.out.println(countSize55);
+
+        if (countSize51 == 562 && countSize52 == 553 && countSize53 == 543 && countSize54 == 535 && countSize55 == 526)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/Alloc_56_60x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/Alloc_56_60x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5ccd0f117bb26b44727876d3cc55ff7d05514df
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/Alloc_56_60x8B.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_56_60x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 56*8B to 60*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_56_60x8B.java
+ *- @ExecuteClass: Alloc_56_60x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_56_60x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_56_8B = 56 * 8;
+    private final static int MAX_57_8B = 57 * 8;
+    private final static int MAX_58_8B = 58 * 8;
+    private final static int MAX_59_8B = 59 * 8;
+    private final static int MAX_60_8B = 60 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 6 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize56 = alloc_test(MAX_56_8B);
+        int countSize57 = alloc_test(MAX_57_8B);
+        int countSize58 = alloc_test(MAX_58_8B);
+        int countSize59 = alloc_test(MAX_59_8B);
+        int countSize60 = alloc_test(MAX_60_8B);
+        //System.out.println(countSize56);
+        //System.out.println(countSize57);
+        //System.out.println(countSize58);
+        //System.out.println(countSize59);
+        //System.out.println(countSize60);
+
+        if (countSize56 == 518 && countSize57 == 511 && countSize58 == 503 && countSize59 == 496 && countSize60 == 488)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/Alloc_61_64x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/Alloc_61_64x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..83ba324f3943a2159b2f1524b20b2d6bbe3066af
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/Alloc_61_64x8B.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_61_64x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 61*8B to 64*8B(max)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_61_64x8B.java
+ *- @ExecuteClass: Alloc_61_64x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_61_64x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_61_8B = 61 * 8;
+    private final static int MAX_62_8B = 62 * 8;
+    private final static int MAX_63_8B = 63 * 8;
+    private final static int MAX_64_8B = 64 * 8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if (slot_type == 24) {
+            i = 1;
+        } else if (slot_type == 1024) {
+            i = 64 * 8 + 1 - OBJ_HEADSIZE;
+        } else {
+            i = slot_type - 2 * 8 + 1;
+        }
+
+        for (; i <= slot_type - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 7 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size = store.size();
+        store = new ArrayList<byte[]>();
+        return check_size;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize61 = alloc_test(MAX_61_8B);
+        int countSize62 = alloc_test(MAX_62_8B);
+        int countSize63 = alloc_test(MAX_63_8B);
+        int countSize64 = alloc_test(MAX_64_8B);
+        //System.out.println(countSize61);
+        //System.out.println(countSize62);
+        //System.out.println(countSize63);
+        //System.out.println(countSize64);
+
+        if (countSize61 == 549 && countSize62 == 542 && countSize63 == 535 && countSize64 == 528)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/Alloc_B256x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/Alloc_B256x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..2dca3bb00ef569963a5892a5aa06663ce2dec614
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/Alloc_B256x8B.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_B256x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing big objects more than 2KB
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_B256x8B.java
+ *- @ExecuteClass: Alloc_B256x8B
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+public class Alloc_B256x8B {
+    private final static int PAGE_SIZE = 4 * 1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_B256_8B = 2 * 1024 * 1024;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 * 1024 - OBJ_HEADSIZE; i <= slot_type - OBJ_HEADSIZE; i = i + 256) {
+            for (int j = 0; j < (PAGE_SIZE * 2560 / (i + OBJ_HEADSIZE) + 5); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum += store.size();
+            store = new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_B256_8B);
+        //System.out.println(result);
+        if (result == 46939)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/Alloc_Thread2_64x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/Alloc_Thread2_64x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..638638fb18251a65e84851dba8c76ff686500f84
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/Alloc_Thread2_64x8B.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_Thread2_64x8B
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 60*8B to 64*8B(max)
+ * -@Brief:functionTest
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_Thread2_64x8B.java
+ * -@ExecuteClass: Alloc_Thread2_64x8B
+ * -@ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+class Alloc_Thread2_64x8B_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_64_8B = 64 * 8;
+    private static boolean checkout = false;
+
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 480 - OBJ_HEADSIZE; i <= MAX_64_8B - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 128 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int checkSize = store.size();
+        if (checkSize == 35212) {
+            checkout = true;
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+public class Alloc_Thread2_64x8B {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Thread2_64x8B_01 test1 = new Alloc_Thread2_64x8B_01();
+        test1.start();
+        Alloc_Thread2_64x8B_01 test2 = new Alloc_Thread2_64x8B_01();
+        test2.start();
+        try {
+            test1.join();
+            test2.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/Alloc_Threadm_192x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/Alloc_Threadm_192x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..52c2b21698a9e1cba81ea35277d9d3d09fc18fca
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/Alloc_Threadm_192x8B.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_Threadm_192x8B
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing
+ *         objects from 128*8B to 192*8B(max) with 6 threads
+ * -@Brief:functionTest
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_Threadm_192x8B.java
+ * -@ExecuteClass: Alloc_Threadm_192x8B
+ * -@ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+class Alloc_Threadm_192x8B_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_192_8B = 192 * 8;
+    private static boolean checkout = false;
+
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        int checkSize = 0;
+        for (int i = 1024 - OBJ_HEADSIZE; i <= MAX_192_8B - OBJ_HEADSIZE; i = i + 100) {
+            for (int j = 0; j < (PAGE_SIZE * 512 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+                checkSize++;
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (checkSize == 10117) {
+            checkout = true;
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+public class Alloc_Threadm_192x8B {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_192x8B_01 test1 = new Alloc_Threadm_192x8B_01();
+        test1.start();
+        Alloc_Threadm_192x8B_01 test2 = new Alloc_Threadm_192x8B_01();
+        test2.start();
+        Alloc_Threadm_192x8B_01 test3 = new Alloc_Threadm_192x8B_01();
+        test3.start();
+        Alloc_Threadm_192x8B_01 test4 = new Alloc_Threadm_192x8B_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check() && test3.check() && test4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/Alloc_Threadm_256x8B_2.java b/test/testsuite/ouroboros/memory_management/Function/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/Alloc_Threadm_256x8B_2.java
new file mode 100644
index 0000000000000000000000000000000000000000..8726aaaaf65217e692b294e63c64b97b4a8705af
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/Alloc_Threadm_256x8B_2.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_Threadm_256x8B_2
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing
+ *         objects from 192*8B to 256*8B(max) with 6 threads and time sleep
+ * -@Brief:functionTest
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_Threadm_256x8B_2.java
+ * -@ExecuteClass: Alloc_Threadm_256x8B_2
+ * -@ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+class Alloc_Threadm_256x8B_2_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_256_8B = 256 * 8;
+    private static boolean checkOut = false;
+
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        int check_size = 0;
+        for (int i = 192 * 8 - OBJ_HEADSIZE; i <= MAX_256_8B - OBJ_HEADSIZE; i = i + 800) {
+            for (int j = 0; j < (PAGE_SIZE * 1024 / (i + OBJ_HEADSIZE) + 10); j++) {
+                if (j % 1000 == 0) {
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException e) {
+                        // do nothing
+                    }
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size++;
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (check_size == 2740) {
+            checkOut = true;
+        }
+    }
+
+    public boolean check() {
+        return checkOut;
+    }
+}
+
+public class Alloc_Threadm_256x8B_2 {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_256x8B_2_01 test1 = new Alloc_Threadm_256x8B_2_01();
+        test1.start();
+        Alloc_Threadm_256x8B_2_01 test2 = new Alloc_Threadm_256x8B_2_01();
+        test2.start();
+        Alloc_Threadm_256x8B_2_01 test3 = new Alloc_Threadm_256x8B_2_01();
+        test3.start();
+        Alloc_Threadm_256x8B_2_01 test4 = new Alloc_Threadm_256x8B_2_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check() && test3.check() && test4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/Alloc_Threadm_256x8B.java b/test/testsuite/ouroboros/memory_management/Function/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/Alloc_Threadm_256x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7dc5c2b1ea8c3c34325b88ff09144c19b7a241e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/Alloc_Threadm_256x8B.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:Alloc_Threadm_256x8B
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing
+ *         objects from 192*8B to 256*8B(max) with 6 threads
+ * -@Brief:functionTest
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_Threadm_256x8B.java
+ * -@ExecuteClass: Alloc_Threadm_256x8B
+ * -@ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+
+class Alloc_Threadm_256x8B_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_256_8B = 256 * 8;
+    private static boolean checkOut = false;
+
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        int checkSize = 0;
+        for (int i = 192 * 8 - OBJ_HEADSIZE; i <= MAX_256_8B - OBJ_HEADSIZE; i = i + 800) {
+            for (int j = 0; j < (PAGE_SIZE * 512 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+                checkSize++;
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (checkSize == 1375) {
+            checkOut = true;
+        }
+    }
+
+    public boolean check() {
+        return checkOut;
+    }
+
+}
+
+public class Alloc_Threadm_256x8B {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_256x8B_01 test1 = new Alloc_Threadm_256x8B_01();
+        test1.start();
+        Alloc_Threadm_256x8B_01 test2 = new Alloc_Threadm_256x8B_01();
+        test2.start();
+        Alloc_Threadm_256x8B_01 test3 = new Alloc_Threadm_256x8B_01();
+        test3.start();
+        Alloc_Threadm_256x8B_01 test4 = new Alloc_Threadm_256x8B_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check() && test3.check() && test4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0302-rc-function-Ref-PhantomRefTest/PhantomRefTest.java b/test/testsuite/ouroboros/memory_management/Function/RC0302-rc-function-Ref-PhantomRefTest/PhantomRefTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2781a5e4e19fc512b31d83121f7877ac3b26e474
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0302-rc-function-Ref-PhantomRefTest/PhantomRefTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/PhantomRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: PhantomRefTest basic testcase
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: PhantomRefTest.java
+ *- @ExecuteClass: PhantomRefTest
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.lang.ref.*;
+
+public class PhantomRefTest {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+
+    static void setPhantomReference() {
+        rp = new PhantomReference<Object>(new Object(), rq);
+        if (rp.get() != null) {
+            a++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        Reference r;
+        setPhantomReference();
+        Thread.sleep(2000);
+        while ((r = rq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                a++;
+            }
+        }
+
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0303-rc-function-Ref-SoftRefTest/SoftRefTest.java b/test/testsuite/ouroboros/memory_management/Function/RC0303-rc-function-Ref-SoftRefTest/SoftRefTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f6965a780502e27dce226c6ef8966e2976dd34c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0303-rc-function-Ref-SoftRefTest/SoftRefTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/SoftRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: SoftRefTest basic testcase
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SoftRefTest.java
+ *- @ExecuteClass: SoftRefTest
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.lang.ref.*;
+
+public class SoftRefTest {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            a++;
+        }
+    }
+
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 60; i++) {
+                SoftReference sr = new SoftReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        Reference r;
+        setSoftReference();
+        new Thread(new TriggerRP()).start();
+        Thread.sleep(3000);
+        if (rp.get() != null) {
+            a++;
+        }
+        while ((r = rq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.SoftReference")) {
+                a++;
+            }
+        }
+        if (a == 101) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0305-rc-function-SubsumeRC01/SubsumeRC01.java b/test/testsuite/ouroboros/memory_management/Function/RC0305-rc-function-SubsumeRC01/SubsumeRC01.java
new file mode 100644
index 0000000000000000000000000000000000000000..03175190a77f4810566061cbfdc26f66e91175bb
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0305-rc-function-SubsumeRC01/SubsumeRC01.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/SubsumeRC01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test subsumerc for RC, return a field directly
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SubsumeRC01.java
+ *- @ExecuteClass: SubsumeRC01
+ *- @ExecuteArgs:
+ *- @ExpectMplCode:
+ *-  callassigned &MRT_LoadRefField_NaiveRCFast (
+ *-    regread ref %2,
+ *-    iaddrof ref <* <$LSubsumeRC01_3B>> 4 (regread ref %2)) { regassign ptr %1}
+ *-  regassign ref %3 (regread ptr %1)
+ *-  dassign %Reg0_R71 0 (regread ref %3)
+ *-  intrinsiccall MPL_CLEANUP_LOCALREFVARS_SKIP (dread ref %Reg0_R71)
+ *-  return (regread ref %3)
+ */
+public class SubsumeRC01 {
+    private String str;
+
+    public String testfunc() {
+        return str;
+    }
+
+    public static void main(String[] args) {
+        SubsumeRC01 temp = new SubsumeRC01();
+        temp.testfunc();
+        System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0306-rc-function-SubsumeRC02/SubsumeRC02.java b/test/testsuite/ouroboros/memory_management/Function/RC0306-rc-function-SubsumeRC02/SubsumeRC02.java
new file mode 100644
index 0000000000000000000000000000000000000000..203718c05aa43e28223d7f1d42ce4f67a2815d3d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0306-rc-function-SubsumeRC02/SubsumeRC02.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/SubsumeRC02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test subsumerc for RC, assign a value returned by function call to a field
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SubsumeRC02.java
+ *- @ExecuteClass: SubsumeRC02
+ *- @ExecuteArgs:
+ *- @ExpectMplCode:
+ *- callassigned &Native_java_lang_StringFactory_newStringFromString__Ljava_lang_String_2 (iread ref <* <* <$Ljava_2Flang_2FString_3B>>> 0 (addrof ptr $_PTR_C_STR_7400650073007400)) { regassign ref %1}
+ *- call &CC_WriteRefFieldNoInc (
+ *-   regread ref %2,
+ *-   iaddrof ref <* <$LSubsumeRC02_3B>> 4 (regread ref %2),
+ *-   regread ref %1)
+ */
+public class SubsumeRC02 {
+    private String str;
+
+    public SubsumeRC02() {
+    }
+
+    public void testfunc() {
+        str = new String("test");
+        return;
+    }
+
+    public static void main(String[] args) {
+        SubsumeRC02 temp = new SubsumeRC02();
+        temp.testfunc();
+        System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0307-rc-function-SubsumeRC03/SubsumeRC03.java b/test/testsuite/ouroboros/memory_management/Function/RC0307-rc-function-SubsumeRC03/SubsumeRC03.java
new file mode 100644
index 0000000000000000000000000000000000000000..98ae92eb8562bd68952da3edaa9afcb04ed0ef97
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0307-rc-function-SubsumeRC03/SubsumeRC03.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/SubsumeRC03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test subsumerc for RC, assign another object's field to a field
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SubsumeRC03.java
+ *- @ExecuteClass: SubsumeRC03
+ *- @ExecuteArgs:
+ *- @ExpectMplCode:
+ *- callassigned &MRT_LoadRefField_NaiveRCFast (
+ *-   regread ref %2,
+ *-     iaddrof ref <* <$LSubsumeRC03_3B>> 4 (regread ref %2)) { regassign ref %1}
+ *- call &CC_WriteRefFieldNoInc (
+ *-   regread ref %3,
+ *-   iaddrof ref <* <$LSubsumeRC03_3B>> 4 (regread ref %3),
+ *-   regread ref %1)
+ */
+public class SubsumeRC03 {
+    private String str;
+
+    public SubsumeRC03() {
+    }
+
+    public void testfunc(SubsumeRC03 t) {
+        str = t.str;
+        return;
+    }
+
+    public static void main(String[] args) {
+        SubsumeRC03 temp0 = new SubsumeRC03();
+        SubsumeRC03 temp1 = new SubsumeRC03();
+        temp1.testfunc(temp0);
+        System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0308-rc-function-CondBasedRC01/CondBasedRC01.java b/test/testsuite/ouroboros/memory_management/Function/RC0308-rc-function-CondBasedRC01/CondBasedRC01.java
new file mode 100644
index 0000000000000000000000000000000000000000..029076b9b2c73e59b2a425cc735a6589b5a52dbc
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0308-rc-function-CondBasedRC01/CondBasedRC01.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/CondBasedRC01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test condbasedrc for RC, decref can be omitted if ref is null can be guaranteed
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CondBasedRC01.java
+ *- @ExecuteClass: CondBasedRC01
+ *- @ExecuteArgs:
+ */
+public class CondBasedRC01 {
+    private String str1;
+    public static String str2;
+
+    public CondBasedRC01() {
+    }
+
+    public String testfunc(String s) {
+        if (s == null) {
+            s = str1;
+        }
+        return s;
+    }
+
+    public String strfunc() {
+        return str1;
+    }
+
+    public String testfunc1() {
+        String t = strfunc();
+        if (t == null) {
+            t = str1;
+        }
+        return t;
+    }
+
+    public static void main(String[] args) {
+        CondBasedRC01 temp1 = new CondBasedRC01();
+        String s = new String("test");
+        str2 = temp1.testfunc(s);
+        str2 = temp1.testfunc1();
+        System.out.println("ExpectResult");
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0309-rc-function-Optimization-RC_newObjectIassign_01/RC_newObjectIassign_01.java b/test/testsuite/ouroboros/memory_management/Function/RC0309-rc-function-Optimization-RC_newObjectIassign_01/RC_newObjectIassign_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf5b0360bb5e0a0c5c6a8df63d68d4f3bd14cf5d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0309-rc-function-Optimization-RC_newObjectIassign_01/RC_newObjectIassign_01.java
@@ -0,0 +1,92 @@
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_newObjectIassign_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 针对RC优化new object assign 做场景测试：对象类中的某个域如果在类初始化时没有做赋值，则不会对它的incref(无集成场景)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_newObjectIassign_01.java
+ *- @ExecuteClass: RC_newObjectIassign_01
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class RC_newObjectIassign_01 {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    String[] strArray;
+    static String str1;
+    volatile String str2;
+
+    private RC_newObjectIassign_01() {
+        strArray = new String[10];
+        str1 = "MapleTest";
+        str2 = "FigoTest";
+    }
+
+    private RC_newObjectIassign_01(String str) {
+        str1 = str;
+        str2 = str;
+    }
+
+    private RC_newObjectIassign_01(String[] str) {
+        strArray = str;
+    }
+
+    public static void main(String[] args) {
+        for (int i = 1; i <= 100; i++) {
+            test_new_objct_assign();
+            if (check != 5) {
+                System.out.println("ErrorResult");
+                break;
+            } else {
+                check = 0;
+                str1 = null;
+            }
+
+        }
+        System.out.println("ExpectResult");
+    }
+
+    private static void test_new_objct_assign() {
+        String[] example = {"a", "b", "c"};
+        String[] arrayStr = {"a", "b", "c"};
+        RC_newObjectIassign_01 rctest = new RC_newObjectIassign_01(arrayStr);
+        if (Arrays.equals(rctest.strArray, example) && rctest.str1 == null && rctest.str2 == null)
+            check += 1;
+        rctest.str1 = "firstTimeTestStr1";
+        rctest.str2 = "firstTimeTestStr2";
+        if (Arrays.equals(rctest.strArray, example) && rctest.str1 == "firstTimeTestStr1" && rctest.str2 == "firstTimeTestStr2")
+            check += 1;
+
+        rctest = new RC_newObjectIassign_01("secondTimeTest");
+        if (Arrays.equals(rctest.strArray, null) && rctest.str1 == "secondTimeTest" && rctest.str2 == "secondTimeTest")
+            check += 1;
+        rctest.strArray = arrayStr;
+        if (Arrays.equals(rctest.strArray, example) && rctest.str1 == "secondTimeTest" && rctest.str2 == "secondTimeTest")
+            check += 1;
+
+        rctest = new RC_newObjectIassign_01();
+        if (rctest.strArray.length == 10 && rctest.str1 == "MapleTest" && rctest.str2 == "FigoTest")
+            check += 1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0310-rc-function-Optimization-RC_newObjectIassign_02/RC_newObjectIassign_02.java b/test/testsuite/ouroboros/memory_management/Function/RC0310-rc-function-Optimization-RC_newObjectIassign_02/RC_newObjectIassign_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..17c4ce7cc1d4353c6ddd9b34836aec58898b0ab9
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0310-rc-function-Optimization-RC_newObjectIassign_02/RC_newObjectIassign_02.java
@@ -0,0 +1,95 @@
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_newObjectIassign_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 针对RC优化new object assign 做场景测试：对象类中的某个域如果在类初始化时没有做赋值，则不会对它的incref(无集成场景)
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_newObjectIassign_02.java
+ *- @ExecuteClass: RC_newObjectIassign_02
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+class Base {
+    String[] strArray;
+    volatile String str2;
+}
+
+public class RC_newObjectIassign_02 extends Base {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    static String str1;
+
+    private RC_newObjectIassign_02() {
+        strArray = new String[10];
+        str1 = "MapleTest";
+        str2 = "FigoTest";
+    }
+
+    private RC_newObjectIassign_02(String str) {
+        str1 = str;
+        str2 = str;
+    }
+
+    private RC_newObjectIassign_02(String[] str) {
+        strArray = str;
+    }
+
+    public static void main(String[] args) {
+        for (int i = 1; i <= 100; i++) {
+            test_new_objct_assign();
+            if (check != 5) {
+                System.out.println("ErrorResult");
+                break;
+            } else {
+                check = 0;
+                str1 = null;
+            }
+
+        }
+        System.out.println("ExpectResult");
+    }
+
+    private static void test_new_objct_assign() {
+        String[] example = {"a", "b", "c"};
+        String[] arrayStr = {"a", "b", "c"};
+        RC_newObjectIassign_02 rctest = new RC_newObjectIassign_02(arrayStr);
+        if (Arrays.equals(rctest.strArray, example) && rctest.str1 == null && rctest.str2 == null)
+            check += 1;
+        rctest.str1 = "firstTimeTestStr1";
+        rctest.str2 = "firstTimeTestStr2";
+        if (Arrays.equals(rctest.strArray, example) && rctest.str1 == "firstTimeTestStr1" && rctest.str2 == "firstTimeTestStr2")
+            check += 1;
+
+        rctest = new RC_newObjectIassign_02("secondTimeTest");
+        if (Arrays.equals(rctest.strArray, null) && rctest.str1 == "secondTimeTest" && rctest.str2 == "secondTimeTest")
+            check += 1;
+        rctest.strArray = arrayStr;
+        if (Arrays.equals(rctest.strArray, example) && rctest.str1 == "secondTimeTest" && rctest.str2 == "secondTimeTest")
+            check += 1;
+
+        rctest = new RC_newObjectIassign_02();
+        if (rctest.strArray.length == 10 && rctest.str1 == "MapleTest" && rctest.str2 == "FigoTest")
+            check += 1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0311-rc-function-Optimization-RC_newObjectToField/RC_newObjectToField.java b/test/testsuite/ouroboros/memory_management/Function/RC0311-rc-function-Optimization-RC_newObjectToField/RC_newObjectToField.java
new file mode 100644
index 0000000000000000000000000000000000000000..0aa8e96fb675dbc8253e227c230edf3621e87b34
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0311-rc-function-Optimization-RC_newObjectToField/RC_newObjectToField.java
@@ -0,0 +1,92 @@
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_newObjectToField.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 对于像mR = new Obj（）的语句; 为了分配一个新对象并将其引用分配给一个field，我们正在生成一对冗余的RC Inc / Dec操作
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_newObjectToField.java
+ *- @ExecuteClass: RC_newObjectToField
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class RC_newObjectToField {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    volatile static String[] strArray;
+    static String str1;
+    volatile String str2;
+
+    private RC_newObjectToField() {
+        strArray = new String[10];
+        str1 = new String("str1") + "MapleTest";
+        str2 = "FigoTest";
+    }
+
+    private RC_newObjectToField(String str) {
+        str1 = new String("str1") + str;
+        str2 = new String("str2") + str;
+    }
+
+    private RC_newObjectToField(String[] str) {
+        Arrays.sort(str);
+        Arrays.toString(str);
+        new Object();
+        new String("Just Test");
+        Arrays.binarySearch(str, "d");
+        strArray = new String[10];
+        strArray = str;
+    }
+
+
+    public static void main(String[] args) {
+        for (int i = 1; i <= 100; i++) {
+            test_new_objct_assign();
+            if (check != 3) {
+                System.out.println("ErrorResult");
+                break;
+            } else {
+                check = 0;
+                str1 = null;
+            }
+
+        }
+        System.out.println("ExpectResult");
+    }
+
+    private static void test_new_objct_assign() {
+        String[] example = {"a", "b", "c"};
+        String[] arrayStr = {"c", "a", "b"};
+        RC_newObjectToField rctest = new RC_newObjectToField(arrayStr);
+        if (Arrays.equals(rctest.strArray, example) && rctest.str1 == null && rctest.str2 == null)
+            check += 1;
+
+        rctest = new RC_newObjectToField("secondTimeTest");
+        if (Arrays.equals(rctest.strArray, example) && rctest.str1.equals("str1secondTimeTest") && rctest.str2.equals("str2secondTimeTest"))
+            check += 1;
+
+        rctest = new RC_newObjectToField();
+        if (rctest.strArray.length == 10 && rctest.str1.equals("str1MapleTest") && rctest.str2 == "FigoTest")
+            check += 1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0312-rc-function-Optimization-RC_newObjectToField_02/RC_newObjectToField_02.java b/test/testsuite/ouroboros/memory_management/Function/RC0312-rc-function-Optimization-RC_newObjectToField_02/RC_newObjectToField_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..331b752f40cf7c25319d76f51e6924134a44eae7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0312-rc-function-Optimization-RC_newObjectToField_02/RC_newObjectToField_02.java
@@ -0,0 +1,97 @@
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_newObjectToField_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 对于像mR = new Obj（）的语句; 为了分配一个新对象并将其引用分配给一个field，我们正在生成一对冗余的RC Inc / Dec操作
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_newObjectToField_02.java
+ *- @ExecuteClass: RC_newObjectToField_02
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class RC_newObjectToField_02 {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    volatile static String[] strArray;
+    int[] intArray;
+    static String str1;
+    volatile String str2;
+
+    private RC_newObjectToField_02() throws ArithmeticException {
+        strArray = new String[10];
+        str1 = new String("str1") + "MapleTest";
+        str2 = "FigoTest";
+        intArray = new int[]{1 / 0};
+    }
+
+    private RC_newObjectToField_02(String str) throws StringIndexOutOfBoundsException {
+        str1 = (new String("str1") + str).substring(-1, -2);
+        str2 = new String("str2") + str;
+    }
+
+    private RC_newObjectToField_02(String[] str) throws ArrayIndexOutOfBoundsException {
+        Arrays.sort(str);
+        Arrays.toString(str);
+        new Object();
+        new String("Just Test");
+        Arrays.binarySearch(str, "d");
+        intArray = new int[10];
+        strArray = new String[1];
+        strArray[2] = new String("IndexOutBounds");
+    }
+
+    public static void main(String[] args) {
+        for (int i = 1; i <= 100; i++) {
+            test_new_objct_assign();
+            if (check != 3) {
+                System.out.println("ErrorResult");
+                break;
+            } else {
+                check = 0;
+                str1 = null;
+            }
+
+        }
+        System.out.println("ExpectResult");
+    }
+
+    private static void test_new_objct_assign() {
+        String[] arrayStr = {"c", "a", "b"};
+        try {
+            RC_newObjectToField_02 rctest = new RC_newObjectToField_02(arrayStr);
+        } catch (ArrayIndexOutOfBoundsException a) {
+            check += 1;
+        }
+        try {
+            RC_newObjectToField_02 rctest = new RC_newObjectToField_02("secondTimeTest");
+        } catch (StringIndexOutOfBoundsException s) {
+            check += 1;
+        }
+        try {
+            RC_newObjectToField_02 rctest = new RC_newObjectToField_02();
+        } catch (ArithmeticException a) {
+            check += 1;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0313-rc-function-Optimization-RC_staticInput/RC_staticInput.java b/test/testsuite/ouroboros/memory_management/Function/RC0313-rc-function-Optimization-RC_staticInput/RC_staticInput.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ffdd600e46ef0232db765dce52bbbf1b9628c95
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0313-rc-function-Optimization-RC_staticInput/RC_staticInput.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_staticInput.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_staticInput.java
+ *- @ExecuteClass: RC_staticInput
+ *- @ExecuteArgs:
+ */
+public class RC_staticInput {
+    static int[] test = {10, 20, 30, 40};
+
+    public static void main(String[] args) {
+        if (test.length == 4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+        test(4, test);
+        if (test.length == 4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+
+    public static void test(int first, int[] second) {
+        int[] xyz = {23, 24, 25, 26};
+        test = xyz;
+        if (second.length == 4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/memory_management/Function/RC0314-rc-function-Optimization-RC_staticInput_02/RC_staticInput_02.java b/test/testsuite/ouroboros/memory_management/Function/RC0314-rc-function-Optimization-RC_staticInput_02/RC_staticInput_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..7838cd4c7e156a544a43e3cc08cc28a54b28cb78
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/Function/RC0314-rc-function-Optimization-RC_staticInput_02/RC_staticInput_02.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:maple/runtime/rc/function/RC_staticInput_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Brief:functionTest
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_staticInput_02.java
+ *- @ExecuteClass: RC_staticInput_02
+ *- @ExecuteArgs:
+ */
+public class RC_staticInput_02 {
+    static int[] test = {10, 20, 30, 40};
+
+    public static void main(String[] args) {
+        if (test.length == 4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+        test(4, test);
+        if (test.length == 4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+
+    public static void test(int first, int[] second) {
+        int[] xyz = {23, 24, 25, 26};
+        modify(xyz);
+        if (second.length == 4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+
+    public static void modify(int[] temp) {
+        test = temp;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/memory_management/MemoryTest/RC0360-rc-Memory-leaktestsupplycase-01/BackupTracingAndRefPro.java b/test/testsuite/ouroboros/memory_management/MemoryTest/RC0360-rc-Memory-leaktestsupplycase-01/BackupTracingAndRefPro.java
new file mode 100644
index 0000000000000000000000000000000000000000..f86e2ace2e24acfcea9b7a3622953372db2e9357
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/MemoryTest/RC0360-rc-Memory-leaktestsupplycase-01/BackupTracingAndRefPro.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: maple/runtime/rc/function/BackupTracingAndRefPro.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Brief:functionTest
+ * -#step1: 创建弱引用，确认创建成功
+ * -#step2: 等待一个时间周期，确认引用和引用队列被释放
+ * -#step3: 调用Runtime.getRuntime().gc()进行垃圾回收，重复步骤1~2;
+ * -#step4: 创建类的引用，并对类的变量进行运算，确认运算结果正确。
+ * -#step5: 调用Runtime.getRuntime().gc()进行垃圾回收，重复步骤4;
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: BackupTracingAndRefPro.java
+ *- @ExecuteClass: BackupTracingAndRefPro
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class BackupTracingAndRefPro {
+    static int NUM = 2;
+
+    public static void main(String[] args) {
+        runRefPro();
+        Runtime.getRuntime().gc();
+        runRefPro();
+
+        runBackupTracing();
+        Runtime.getRuntime().gc();
+        runBackupTracing();
+        System.out.println("ExpectResult");
+    }
+
+    static void runRefPro() {
+        ThreadRefPro threadRefPro = new ThreadRefPro();
+        for (int i = 0; i < NUM; i++) {
+            threadRefPro.run();
+        }
+    }
+
+    static void runBackupTracing() {
+        ThreadBackupTracing threadBackupTracing = new ThreadBackupTracing();
+        for (int i = 0; i < NUM; i++) {
+            threadBackupTracing.run();
+        }
+    }
+}
+
+class ThreadBackupTracing implements Runnable {
+    int result = 0;
+
+    void versify() {
+        ReferenceOperation ref = new ReferenceOperation();
+        ref.referenceOperation = ref;
+        ref.add();
+        result = ref.sum;
+    }
+
+    @Override
+    public void run() {
+        versify();
+        if (result != 20) {
+            System.out.println("error result ==" + result);
+        }
+    }
+}
+
+class ReferenceOperation {
+    ReferenceOperation referenceOperation;
+    int num;
+    int sum;
+
+    ReferenceOperation() {
+        referenceOperation = null;
+        num = 10;
+        sum = 0;
+    }
+
+    void add() {
+        sum = num + referenceOperation.num;
+    }
+}
+
+class ThreadRefPro implements Runnable {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer obj = new StringBuffer("weak");
+
+    static void setWeakRef() {
+        obj = new StringBuffer("weak");
+        rp = new WeakReference<Object>(obj, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        obj = null;
+    }
+
+    @Override
+    public void run() {
+        Reference reference;
+        setWeakRef();
+
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (rp.get() != null) {
+            System.out.println("error in rp.get()");
+        }
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println("error in rq");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan ExpectResult\n
diff --git a/test/testsuite/ouroboros/memory_management/MemoryTest/RC0364-rc-Memory-leaktestsupplycase-05/RaceInLoadAndWriteWeakRef.java b/test/testsuite/ouroboros/memory_management/MemoryTest/RC0364-rc-Memory-leaktestsupplycase-05/RaceInLoadAndWriteWeakRef.java
new file mode 100644
index 0000000000000000000000000000000000000000..df716fb5ba0e5931fe03d14c8b26af16fc901003
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/MemoryTest/RC0364-rc-Memory-leaktestsupplycase-05/RaceInLoadAndWriteWeakRef.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: maple/runtime/rc/function/RaceInLoadAndWriteWeakRef.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Brief:functionTest
+ * -#step1: 创建一个WeakReference类的对象并赋值给rp，经判断rp.get()不为null，最后令stringBuffer等于null；
+ * -#step2: 以setWeakRef为参数，分别创建ThreadLoadWeakRef、ThreadWriteWeakRef类的实例对象threadLoadWeakRef和
+ *          threadWriteWeakRef；
+ * -#step3: 调用threadLoadWeakRef的run()方法，即将setWeakRef.rp的值赋值给rp_load；
+ * -#step4: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step5: 重复执行step3~step4一次；
+ * -#step6: 再次执行step3一次；
+ * -#step7: 调用threadWriteWeakRef的run()方法，即将rp_write的值赋值给setWeakRef.rp；
+ * -#step8: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step9: 重复执行step7一次；
+ * -#step10: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step11: 重复执行步骤1~9一次；
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: RaceInLoadAndWriteWeakRef.java
+ *- @ExecuteClass: RaceInLoadAndWriteWeakRef
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class RaceInLoadAndWriteWeakRef {
+    static int NUM = 100;
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        System.out.println("ExpectResult");
+    }
+
+    static void test() {
+        SetWeakRef setWeakRef = new SetWeakRef();
+        setWeakRef.setWeakRef();
+        ThreadLoadWeakRef threadLoadWeakRef = new ThreadLoadWeakRef(setWeakRef);
+        ThreadWriteWeakRef threadWriteWeakRef = new ThreadWriteWeakRef(setWeakRef);
+        for (int i = 0; i < NUM; i++) {
+            threadLoadWeakRef.run();
+            Runtime.getRuntime().gc();
+            threadLoadWeakRef.run();
+            Runtime.getRuntime().gc();
+            threadLoadWeakRef.run();
+
+            threadWriteWeakRef.run();
+            Runtime.getRuntime().gc();
+            threadWriteWeakRef.run();
+        }
+    }
+}
+
+class SetWeakRef {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer stringBuffer = new StringBuffer("Weak");
+
+    static void setWeakRef() {
+        stringBuffer = new StringBuffer("Weak");
+        rp = new WeakReference(stringBuffer, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        stringBuffer = null;
+    }
+}
+
+class ThreadLoadWeakRef implements Runnable {
+    SetWeakRef setWeakRef;
+
+    public ThreadLoadWeakRef(SetWeakRef setWeakRef) {
+        this.setWeakRef = setWeakRef;
+    }
+
+    static Reference rp_load;
+
+    @Override
+    public void run() {
+        rp_load = setWeakRef.rp;
+    }
+}
+
+class ThreadWriteWeakRef implements Runnable {
+    SetWeakRef setWeakRef;
+
+    public ThreadWriteWeakRef(SetWeakRef setWeakRef) {
+        this.setWeakRef = setWeakRef;
+    }
+
+    static WeakReference rp_write;
+
+    @Override
+    public void run() {
+        setWeakRef.rp = rp_write;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/memory_management/MemoryTest/RC0365-rc-Memory-leaktestsupplycase-06/WeakAndCleanerRef.java b/test/testsuite/ouroboros/memory_management/MemoryTest/RC0365-rc-Memory-leaktestsupplycase-06/WeakAndCleanerRef.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a3517631c5cba27394ed2532237c73d5891a309
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/MemoryTest/RC0365-rc-Memory-leaktestsupplycase-06/WeakAndCleanerRef.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: maple/runtime/rc/function/WeakAndCleanerRef.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Brief:functionTest
+ * -#step1: 创建一个ThreadCleaner类的实例对象threadCleaner，创建一个StringBuffer类的变量stringBuffer并赋值为test；
+ * -#step2: 以step1中的threadCleaner和stringBuffer为参数，调用Cleaner类的create()方法创建一个实例对象cleaner；
+ * -#step3: 以ReferenceQueue类的实例对象rq和stringBuffer为参数，创建一个WeakReference类的对象并赋值给rp；
+ * -#step4: 令stringBuffer等于null, 释放强引用；
+ * -#step5: 调用cleaner的clean()方法，进行对象的清除和资源的释放；
+ * -#step6: 让当前线程休眠2000ms；
+ * -#step7: 重复执行step3一次；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: WeakAndCleanerRef.java
+ *- @ExecuteClass: WeakAndCleanerRef
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class WeakAndCleanerRef {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer stringBuffer = new StringBuffer("test");
+
+    static void addWeakAndCleanerRef() {
+        rp = new WeakReference(stringBuffer, rq);
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        ThreadCleaner threadCleaner = new ThreadCleaner();
+        Cleaner cleaner = Cleaner.create(stringBuffer, threadCleaner);
+        addWeakAndCleanerRef();
+        stringBuffer = null;
+        cleaner.clean();
+        Thread.sleep(2000);
+        addWeakAndCleanerRef();
+        if (rp.get() == null) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+class ThreadCleaner implements Runnable {
+    @Override
+    public void run() {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/memory_management/MemoryTest/RC0410-rc-Memory-stressTestCase29/Memory_stressTestCase29.java b/test/testsuite/ouroboros/memory_management/MemoryTest/RC0410-rc-Memory-stressTestCase29/Memory_stressTestCase29.java
new file mode 100644
index 0000000000000000000000000000000000000000..36b9b2a3e26e32869b8f0cbae407454044950c6e
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/MemoryTest/RC0410-rc-Memory-stressTestCase29/Memory_stressTestCase29.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:rc/stress/Memory_stressTestCase29.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Brief:functionTest
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_stressTestCase29.java
+ *- @ExecuteClass: Memory_stressTestCase29
+ *- @ExecuteArgs:
+ */
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+
+import sun.misc.Cleaner;
+
+public class Memory_stressTestCase29 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM = INIT_DEFAULT_THREAD_NUM;
+    static List<List<AllocUnit>> mAllThread = new ArrayList<List<AllocUnit>>();
+
+    public static void main(String[] args) {
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        System.out.println("ExpectResult");
+    }
+
+    public static void testCase29() {
+        ArrayList<Thread> list = new ArrayList<>();
+        for (int i = 0; i < (DEFAULT_THREAD_NUM / 10); i++) {
+            list.add(new StopAbleThread(() -> {
+                ArrayList<Memory_stressTestCase29.AllocUnitwithVerifyCleaner> units = new ArrayList<>();
+                Random r = new Random();
+                for (int j = 0; j < 100; j++) {
+                    units.add(new Memory_stressTestCase29.AllocUnitwithVerifyCleaner(r.nextInt(512)));
+                }
+                trySleep(r.nextInt(500));
+                for (Memory_stressTestCase29.AllocUnitwithVerifyCleaner unit : units) {
+                    unit.CanbeFree();
+                }
+                units.clear();
+            }, "testCase29_alloc_" + (i + 1)));
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    public static class StopAbleThread extends Thread {
+        public static boolean mRuning = true;
+        static List<List<AllocUnit>> mAllThread = new ArrayList<List<AllocUnit>>();
+
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+
+
+        }
+    }
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static class AllocUnitwithVerifyCleaner extends AllocUnit {
+        static final int FLAG_INUSE = 0x112233;
+        static final int FLAG_CANBECLEAN = 0xddee;
+        static final int FLAG_CLEARED = 0xaabb;
+        public CleanerStatus status;
+
+        public AllocUnitwithVerifyCleaner(int arrayLength) {
+            super(arrayLength);
+            status = new CleanerStatus();
+            this.cleaner = Cleaner.create(this, new TestCleaner(status));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class CleanerStatus {
+            public int status;
+
+            CleanerStatus() {
+                status = FLAG_INUSE;
+            }
+        }
+
+        public void CanbeFree() {
+            if (this.status.status != FLAG_INUSE) {
+                throw new NullPointerException();
+            }
+            this.status.status = FLAG_CANBECLEAN;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public CleanerStatus status;
+
+            public TestCleaner(CleanerStatus status) {
+                this.status = status;
+            }
+
+            public void run() {
+                if (this.status.status != FLAG_CANBECLEAN) {
+                }
+                this.status.status = FLAG_CLEARED;
+            }
+        }
+
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/memory_management/RP/RC0348-rc-rp-simpleweakref_01/DeadReferenceTest.java b/test/testsuite/ouroboros/memory_management/RP/RC0348-rc-rp-simpleweakref_01/DeadReferenceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ef7c49b7cd064d5028b84952f612bba4637e64a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/RP/RC0348-rc-rp-simpleweakref_01/DeadReferenceTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RefProCase/RefProcessor/src/DeadReferenceTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor  testcase：处理对象为死对象的弱引用
+ *- @Brief:functionTest
+ * -#step1：创建一个ReferenceQueue类的实例对象rq，并已null和rq为参数创建一个WeakReference的实例对象weakRp；
+ * -#step2：新建一个ThreadRf线程，并开启此线程；
+ * -#step3：让当前线程休眠2000ms；
+ * -#step4：经判断得出weakRp.get()的返回值为null；
+ * -#step5：判断rq.poll()的返回值为reference，直至全部判断完成；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: DeadReferenceTest.java
+ *- @ExecuteClass: DeadReferenceTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.*;
+
+public class DeadReferenceTest {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    static Reference weakRp;
+    static ReferenceQueue rq = new ReferenceQueue();
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            deadReferenceTest();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void setWeakRef() {
+        weakRp = new WeakReference<Object>(null, rq);
+    }
+
+    static void deadReferenceTest() throws InterruptedException {
+        Reference reference;
+
+        setWeakRef();
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        if (weakRp.get() != null) {
+            judgeNum++;
+        }
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                judgeNum++;
+            }
+        }
+    }
+}
+
+class ThreadRf implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/RP/RC0349-rc-rp-simpleweakref_02/IsCleanerInDeadCycle.java b/test/testsuite/ouroboros/memory_management/RP/RC0349-rc-rp-simpleweakref_02/IsCleanerInDeadCycle.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5facf26325eeed0efe0e676429103fac28ccc3a
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/RP/RC0349-rc-rp-simpleweakref_02/IsCleanerInDeadCycle.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RefProCase/RefProcessor/src/IsCleanerInDeadCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor testcase: 处理对象为cleaner对象，且在一个不可达的环中
+ *- @Brief:functionTest
+ * -#step1：分别创建Cycle_BDec_00010_A1_Cleaner类的实例对象cycleBA1，InCycle类的实例对象cycleA；
+ * -#step2：调用System.gc()进行垃圾回收；
+ * -#step3：以cycleBA1为参数，执行cycleA的setCleanerCycle()方法，并记其返回值为result；
+ * -#step4：创建一个Cycle_BDec_00010_A2_Cleaner的实例对象cycleBA2，并令cycleBA1.cycleBA2和cycleBA1均为null；
+ * -#step5：经判断得知result为true，并令当前线程休眠2000ms，并判断得出cycleBA1.cleaner、cycleBA1.cycleBA2.cleaner、
+ *          cycleBA1、cycleBA1.cycleBA2至少有一个为null；
+ * -#step6：调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step7：重复步骤1~5；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: IsCleanerInDeadCycle.java
+ *- @ExecuteClass: IsCleanerInDeadCycle
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Cleaner;
+
+public class IsCleanerInDeadCycle {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerInDeadCycle();
+            Runtime.getRuntime().gc();
+            isCleanerInDeadCycle();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void isCleanerInDeadCycle() throws InterruptedException {
+        judgeNum = 0;
+        Cycle_BDec_00010_A1_Cleaner cycleBA1 = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cycleBA1);
+        cycleBA1.cycleBA2 = null;
+        cycleBA1 = null;
+        if (result == true) {
+            Thread.sleep(2000);
+            if (cycleBA1.cleaner == null || cycleBA1.cycleBA2.cleaner == null) {
+            } else {
+                judgeNum++;
+            }
+        } else {
+            judgeNum++;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    Cycle_BDec_00010_A2_Cleaner cycleBA2;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBA2, null);
+        cycleBA2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBA2.num;
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBA1Cleaner;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBA1Cleaner, null);
+        cycleBA1Cleaner = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBA1Cleaner.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleBDA 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleBDA) {
+        cycleBDA.add();
+        cycleBDA.cycleBA2.add();
+        int nSum = cycleBDA.sum + cycleBDA.cycleBA2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBDA1Cleaner 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner) {
+        cycleBDA1Cleaner.cycleBA2 = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBDA1Cleaner.cycleBA2.cycleBA1Cleaner = cycleBDA1Cleaner;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleBDA1Cleaner);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleBDA1Cleaner.cleaner == null && cycleBDA1Cleaner.cycleBA2.cleaner == null
+                && cycleBDA1Cleaner != null && cycleBDA1Cleaner.cycleBA2 != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/RP/RC0351-rc-rp-simpleweakref_04/IsCleanerNotInDeadCycleFreeRef.java b/test/testsuite/ouroboros/memory_management/RP/RC0351-rc-rp-simpleweakref_04/IsCleanerNotInDeadCycleFreeRef.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b710ca6fbd6207b83ec9c2a3ae4b12c87386c91
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/RP/RC0351-rc-rp-simpleweakref_04/IsCleanerNotInDeadCycleFreeRef.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RefProCase/RefProcessor/src/IsCleanerNotInDeadCycleFreeRef.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase：在一个对象是cleaner的环中释放reference
+ *- @Brief:functionTest
+ * -#step1: 分别创建Cycle_BDec_00010_A1_Cleaner类的实例对象cycleBDA1Cleaner，InCycle类的实例对象cycleA；
+ * -#step2: 调用System.gc()进行垃圾回收；
+ * -#step3: 以cycleBDA1Cleaner为参数，执行cycleA的setCleanerCycle()方法，并记其返回值为result；
+ * -#step4: 令cycleBDA1Cleaner.cycleBDA2Cleaner的值为null，经判断result为true，并让当前线程休眠2000ms；
+ * -#step5: 经判断，cycleBDA1Cleaner.cleaner为null、cycleBDA1Cleaner.cycleBDA2Cleaner.cleaner为null、cycleBDA1Cleaner
+ *          不为null这三个条件至少有一个为真；
+ * -#step6: 创建一个ReferenceQueue类的实例对象rq，并且通过cycleBDA1Cleaner.rq.poll()方法返回的cleaner对象等于null；
+ * -#step7: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step8: 重复步骤1~6；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: IsCleanerNotInDeadCycleFreeRef.java
+ *- @ExecuteClass: IsCleanerNotInDeadCycleFreeRef
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.*;
+
+public class IsCleanerNotInDeadCycleFreeRef {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleFreeRef();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleFreeRef();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void isCleanerNotInDeadCycleFreeRef() throws InterruptedException {
+        Cleaner cleaner;
+        Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cycleBDA1Cleaner);
+        cycleBDA1Cleaner.cycleBDA2Cleaner = null;
+        if (result == true) {
+            Thread.sleep(2000);
+            if ((cycleBDA1Cleaner.cleaner == null) || (cycleBDA1Cleaner.cycleBDA2Cleaner.cleaner == null)
+                    || (cycleBDA1Cleaner != null)) {
+                while ((cleaner = (Cleaner) cycleBDA1Cleaner.rq.poll()) != null) {
+                    if (!cleaner.getClass().toString().equals("class sun.misc.Cleaner")) {
+                        judgeNum++;
+                    }
+                }
+            } else {
+                judgeNum++;
+            }
+        } else {
+            judgeNum++;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBDA1;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBDA1, null);
+        cycleBDA1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBDA1.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleBD 传入的是带有Referent的类实例
+     * @return 传入的是带有Referent的类实例
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleBD) {
+        cycleBD.add();
+        cycleBD.cycleBDA2Cleaner.add();
+        int nSum = cycleBD.sum + cycleBD.cycleBDA2Cleaner.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleB
+     * @return
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleB) {
+        cycleB.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleB.cycleBDA2Cleaner.cycleBDA1 = cycleB;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleB);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleB.cleaner == null && cycleB.cycleBDA2Cleaner.cleaner == null && cycleB != null
+                && cycleB.cycleBDA2Cleaner != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/RP/RC0354-rc-rp-simpleweakref_07/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java b/test/testsuite/ouroboros/memory_management/RP/RC0354-rc-rp-simpleweakref_07/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8237e44931cecf430c2f6fe598efe1d45570987
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/RP/RC0354-rc-rp-simpleweakref_07/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RefProCase/RefProcessor/src/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase：在可达的环中构造cleaner对象，并不设置WCB。
+ *- @Brief:functionTest
+ * -#step1：创建两个带有Cleaner 对象的class，并相互声明了对方作为自己的Field。
+ * -#step2：创建第三个类InCycle，将上两个类连成一个可达的环。
+ * -#step3：创建InCycle的实例，调用方法一给第一个类对象关于第二个类的Field初始化对象，再将该对象关于第一个类Field赋值为第一个类，
+ *          从而形成一个带Cleaner的环。
+ * -#step4：方法一调用方法二执行前两个类对象的add方法进行Field的运算，相当于对对象进行了引用，判断运算结果是否正确。
+ * -#step5：调用System.gc()进行系统回收，重复步骤4，判断环正确且reference都没释放。
+ * -#step6：调用System.gc()进行系统回收，重复步骤3~5。
+ * -#step7：调用Runtime.getRuntime().gc()进行系统回收，重复步骤1~6。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source:IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
+ *- @ExecuteClass: IsCleanerNotInDeadCycleNotSetWCBFailAtomic
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.*;
+
+public class IsCleanerNotInDeadCycleNotSetWCBFailAtomic {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleNotSetWCBFailAtomic();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleNotSetWCBFailAtomic();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void isCleanerNotInDeadCycleNotSetWCBFailAtomic() throws InterruptedException {
+        Cycle_BDec_00010_A1_Cleaner cleanerClass1 = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        cycleA.setCleanerCycle(cleanerClass1);
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cleanerClass1);
+        if (result == false) {
+            judgeNum++;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cleanerClass2;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cleanerClass2, null);
+        cleanerClass2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cleanerClass2.num;
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1_Cleaner cleanerClass1;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cleanerClass1, null);
+        cleanerClass1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cleanerClass1.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cleaner 传入的是带有Referent的类实例
+     * @return 返回布尔值，判断运算的结果正确
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cleaner) {
+        cleaner.add();
+        cleaner.cleanerClass2.add();
+        int nSum = cleaner.sum + cleaner.cleanerClass2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cleaner 传入的是带有Referent的类实例
+     * @return 返回布尔值，判断reference没释放
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cleaner) {
+        cleaner.cleanerClass2 = new Cycle_BDec_00010_A2_Cleaner();
+        cleaner.cleanerClass2.cleanerClass1 = cleaner;
+        boolean ret;
+        ret = ModifyCleanerA1(cleaner);
+        System.gc();
+        ret = ModifyCleanerA1(cleaner);
+        // 环正确，且reference都没释放
+        if (ret == true && cleaner.cleaner == null && cleaner.cleanerClass2.cleaner == null && cleaner != null
+                && cleaner.cleanerClass2 != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/RP/RC0355-rc-rp-simpleweakref_08/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java b/test/testsuite/ouroboros/memory_management/RP/RC0355-rc-rp-simpleweakref_08/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
new file mode 100644
index 0000000000000000000000000000000000000000..0412fc39080da45e01499df2987eda692bacbb65
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/RP/RC0355-rc-rp-simpleweakref_08/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RefProCase/RefProcessor/src/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase: 在可达的环中，构造对象，不设置WCB
+ *- @Brief:functionTest
+ * -#step1：创建两个带有弱引用对象的class，弱引用申请后通过get方法判断非空，并相互声明对方类作为自己的Field。
+ * -#step2：创建第三个类InCycle，将上两个类连成一个可达的环。
+ * -#step3：创建InCycle的实例，调用方法一给第一个类对象关于第二个类的Field初始化对象，再将该对象关于第一个类Field赋值为第一个类，
+ *          从而形成一个环。
+ * -#step4：方法一调用方法二执行前两个类对象的add方法进行Field的运算，相当于对对象进行了引用，判断运算结果是否正确。
+ * -#step5：调用System.gc()进行系统回收，重复步骤3~4。
+ * -#step6：调用Runtime.getRuntime().gc()进行系统回收，重复步骤1~5。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source:NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
+ *- @ExecuteClass: NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.*;
+
+public class NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerNotInDeadCycleNotSetWCBFailAtomic();
+            Runtime.getRuntime().gc();
+            notIsCleanerNotInDeadCycleNotSetWCBFailAtomic();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void notIsCleanerNotInDeadCycleNotSetWCBFailAtomic() throws InterruptedException {
+        Cycle_BDec_00010_A1 cycleMember = new Cycle_BDec_00010_A1();
+        InCycle cycleA = new InCycle();
+        cycleA.setCycle(cycleMember);
+        System.gc();
+        boolean result = cycleA.setCycle(cycleMember);
+        if (result == false) {
+            judgeNum++;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1 {
+    Reference memberRef1;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2 partner2;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A1() {
+        obj = new StringBuffer("weak");
+        memberRef1 = new WeakReference<Object>(obj, rq);
+        if (memberRef1.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner2.num;
+    }
+}
+
+class Cycle_BDec_00010_A2 {
+    Reference memberRef2;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1 partner1;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A2() {
+        obj = new StringBuffer("weak");
+        memberRef2 = new WeakReference<Object>(obj, rq);
+        if (memberRef2.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner1.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyA1(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.add();
+        refInstance.partner2.add();
+        int nSum = refInstance.sum + refInstance.partner2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Referent的环
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCycle(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.partner2 = new Cycle_BDec_00010_A2();
+        refInstance.partner2.partner1 = refInstance;
+        boolean ret;
+        ret = ModifyA1(refInstance);
+        if (ret == true) {
+            return true;
+        } else {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ret != true");
+            return false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/RP/RC0452-rc-RP-FinalizerReferenceTest04/FinalizerReferenceTest04.java b/test/testsuite/ouroboros/memory_management/RP/RC0452-rc-RP-FinalizerReferenceTest04/FinalizerReferenceTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..8416d2397b57339207d7c57ca17e781964bd1324
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/RP/RC0452-rc-RP-FinalizerReferenceTest04/FinalizerReferenceTest04.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest04
+ *- @TestCaseName: FinalizerReferenceTest04
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:测试正常情况下，Cleaner+FinalizerReference指向的对象
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest04;
+ *  -#step2: 创建一个cleaner引用指向ReferenceTest04的实例。
+ *  -#step3: 触发用户GC，虚引用无法通过get获得，finalize方法被调用。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest04.java
+ *- @ExecuteClass: FinalizerReferenceTest04
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Cleaner;
+
+public class FinalizerReferenceTest04 {
+    static Cleaner cleaner;
+
+    public static void main(String[] args) {
+        Cleaner.create(new ReferenceTest04(10), null);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+    }
+}
+
+class ReferenceTest04 {
+    String[] stringArray;
+
+    public ReferenceTest04(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        for (int i = 0; i < this.stringArray.length; i++) {
+            stringArray[i] = null;
+        }
+        System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/RP/RC0456-rc-RP-FinalizerReferenceTest08/FinalizerReferenceTest08.java b/test/testsuite/ouroboros/memory_management/RP/RC0456-rc-RP-FinalizerReferenceTest08/FinalizerReferenceTest08.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1212549e73f40178fcb127c2eb6edb9aaf43e30
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/RP/RC0456-rc-RP-FinalizerReferenceTest08/FinalizerReferenceTest08.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest08
+ *- @TestCaseName: FinalizerReferenceTest08
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:测试正常情况下，Cleaner+FinalizerReference指向的对象内存回收正确。
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest08,
+ *  -#step2: 该实例的对象gc回收时，finalize方法会将其关联到一个虚引用上，判断无问题。
+ *  -#step3: 触发用户GC，虚引用无法通过get获得finalize方法不再被调用。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest08.java
+ *- @ExecuteClass: FinalizerReferenceTest08
+ *- @ExecuteArgs:
+ */
+
+import sun.misc.Cleaner;
+
+public class FinalizerReferenceTest08 {
+    static Cleaner cleaner;
+    static int check = 2;
+
+    public static void main(String[] args) {
+        new ReferenceTest08(10);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+    }
+}
+
+class ReferenceTest08 {
+    String[] stringArray;
+
+    public ReferenceTest08(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+        Cleaner.create(this, null);
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/SoftRef/RC0431-rc-SoftRef-SoftRefTest/SoftRefTest.java b/test/testsuite/ouroboros/memory_management/SoftRef/RC0431-rc-SoftRef-SoftRefTest/SoftRefTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d72094c1efb110b05f3f0d7546e46dd281b1420
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/SoftRef/RC0431-rc-SoftRef-SoftRefTest/SoftRefTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:SoftRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 测试SoftRefernece的基本内存管理方式：在正常情况下，SoftReference对象不会被回收掉
+ *- @Brief:functionTest
+ * -#step1：创建一个SoftReference对象，并将其放到ReferneceQueue中，该对象不应该被释放；
+ * -#step2：封装一个函数生成一下局部的SoftReference对象
+ * -#step3：再次确认该对象不应该被释放，且它所在的ReferenceQueue中没有即将回收的Reference对象
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SoftRefTest.java
+ *- @ExecuteClass: SoftRefTest
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+
+public class SoftRefTest {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+        new Thread(new TriggerRP()).start();
+
+        if (rp.get() == null) {
+            System.out.println("Error Result when second check ");
+            a++;
+        }
+        Reference r = rq.poll();
+        if (r != null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+
+    }
+
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 60; i++) {
+                SoftReference sr = new SoftReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/SoftRef/RC0432-rc-SoftRef-SoftRefTest02/SoftRefTest02.java b/test/testsuite/ouroboros/memory_management/SoftRef/RC0432-rc-SoftRef-SoftRefTest02/SoftRefTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..6896b57b47881b73f7685439504c58122c01ab36
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/SoftRef/RC0432-rc-SoftRef-SoftRefTest02/SoftRefTest02.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:SoftRefTest02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 正常情况下通过system.gc()强制gc时，SoftReference对象不会被回收掉
+ *- @Brief:functionTest
+ * -#step1：创建一个SoftReference对象，并将其放到ReferneceQueue中，该对象不应该被释放；
+ * -#step2：通过System.gc()进行强制GC
+ * -#step3：再次确认该对象不应该被释放，且它所在的ReferenceQueue中没有即将回收的Reference对象
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SoftRefTest02.java
+ *- @ExecuteClass: SoftRefTest02
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+
+public class SoftRefTest02 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+        for (int i = 0; i < 3; i++) {
+            System.gc();
+            if (rp.get() == null) {
+                System.out.println("Error Result when second check ");
+                a++;
+            }
+        }
+        Reference r = rq.poll();
+        if (r != null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/SoftRef/RC0435-rc-SoftRef-SoftRefTest05/SoftRefTest05.java b/test/testsuite/ouroboros/memory_management/SoftRef/RC0435-rc-SoftRef-SoftRefTest05/SoftRefTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c43e3c651278a03a013dbdba36675f4f27d27f0
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/SoftRef/RC0435-rc-SoftRef-SoftRefTest05/SoftRefTest05.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:SoftRefTest05.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 环上SoftReference对象在正常情况下不会被释放
+ *- @Brief:functionTest
+ * -#step1：创建一个对象环，由四个对象Class_A、Class_B、Class_C和Class_D组成。这四个对象都一个域，关联着一个SoftReference；
+ * -#step2：执行一次后，进行一遍gc，进行环的自学习；
+ * -#step3：再执行一次后，判断环关联的软对象不应该被释放。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SoftRefTest05.java
+ *- @ExecuteClass: SoftRefTest05
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+
+public class SoftRefTest05 {
+    static final int TEST_NUM = 1;
+    static int check_count = 0;
+    static int allSum;
+
+    public static void main(String[] args) {
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            Runtime.getRuntime().gc();
+            // resultLine = null;
+            test_01();
+
+            if (allSum == 20) {
+                check_count++;
+                System.out.println("sum is srong");
+            }
+
+            if (check_count == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println(" errorResult ----checkcount" + check_count);
+            }
+
+        }
+    }
+
+    private static void test_01() {
+        Cycle_A a1 = new Cycle_A();
+        a1.cyb = new Cycle_B();
+        a1.cyb.cyc = new Cycle_C();
+        a1.cyb.cyc.cyd = new Cycle_D();
+        a1.cyb.cyc.cyd.cya = a1;
+        allSum = a1.sum + a1.cyb.sum + a1.cyb.cyc.sum + a1.cyb.cyc.cyd.sum;
+        sleep(4000);
+        if ((a1.sr.get() == null) || (a1.cyb.sr.get() == null) || (a1.cyb.cyc.pr.get() == null) || (a1.cyb.cyc.cyd.str.get() == null)) {
+            check_count++;
+        }
+
+    }
+
+    private static void sleep(int sleepnum) {
+        try {
+            Thread.sleep(sleepnum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+
+}
+
+class Cycle_A {
+    static StringBuffer a = new StringBuffer("ref_processor_cycle_A");
+    Reference sr;
+    Cycle_B cyb;
+    int aNum;
+    int sum;
+
+    Cycle_A() {
+        a = new StringBuffer("ref_processor_cycle_A");
+        sr = new SoftReference(a);
+        if (sr.get() == null) {
+            assert false;
+        }
+        a = null;
+        cyb = null;
+        aNum = 1;
+    }
+
+    int joinStr() {
+        try {
+            sum = aNum + cyb.bNum;
+        } catch (Exception e) {
+
+        }
+        return sum;
+    }
+}
+
+class Cycle_B {
+    static StringBuffer b = new StringBuffer("ref_processor_cycle_B");
+    Reference sr;
+    Cycle_C cyc;
+    int bNum;
+    int sum;
+
+    Cycle_B() {
+        b = new StringBuffer("ref_processor_cycle_B");
+        sr = new SoftReference<>(b);
+        if (sr.get() == null) {
+            assert false;
+        }
+        b = null;
+        cyc = null;
+        bNum = 2;
+    }
+
+
+    int joinStr() {
+        try {
+            sum = bNum + cyc.cNum;
+        } catch (Exception e) {
+
+        }
+        return sum;
+    }
+
+
+}
+
+class Cycle_C {
+    Reference pr;
+    Cycle_D cyd;
+    StringBuffer c = new StringBuffer("ref_processor_cycle_C");
+    int sum;
+    int cNum;
+
+    Cycle_C() {
+        c = new StringBuffer("ref_processor_cycle_C");
+        pr = new SoftReference<>(c);
+        if (pr.get() == null) {
+            assert false;
+        }
+        c = null;
+        cyd = null;
+        cNum = 3;
+    }
+
+    int joinStr() {
+        try {
+            sum = cNum + cyd.dNum;
+        } catch (Exception e) {
+
+        }
+        return sum;
+    }
+}
+
+class Cycle_D {
+    Reference str;
+    Cycle_A cya;
+    StringBuffer d = new StringBuffer("ref_processor_cycle_D");
+    int dNum;
+    int sum;
+
+
+    Cycle_D() {
+        d = new StringBuffer("ref_processor_cycle_D");
+        str = new SoftReference<StringBuffer>(d);
+        d = null;
+        cya = null;
+        dNum = 4;
+
+    }
+
+
+    int joinStr() {
+        try {
+            int sum = dNum + cya.aNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0477-rc-StackScan-CB_01/CB_01.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0477-rc-StackScan-CB_01/CB_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..a14d8b4e4e1007e55dcc9c033e0a4bafa846538b
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0477-rc-StackScan-CB_01/CB_01.java
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CB01
+ *- @TestCaseName: CB_01
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考Nocycle_00180.java，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_01.java
+ *- @ExecuteClass: CB_01
+ *- @ExecuteArgs:
+ */
+
+import java.util.HashMap;
+
+class CB_Nolcycle_a_00180_A1 {
+    CB_Nolcycle_a_00180_B1 b1_0;
+    CB_Nolcycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_A2 {
+    CB_Nolcycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_A3 {
+    CB_Nolcycle_a_00180_B2 b2_0;
+    CB_Nolcycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class CB_Nolcycle_a_00180_A4 {
+    CB_Nolcycle_a_00180_B3 b3_0;
+    CB_Nolcycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_B1 {
+    CB_Nolcycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_B2 {
+    CB_Nolcycle_a_00180_C1 c1_0;
+    CB_Nolcycle_a_00180_D1 d1_0;
+    CB_Nolcycle_a_00180_D2 d2_0;
+    CB_Nolcycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_B3 {
+    CB_Nolcycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_C1 {
+    CB_Nolcycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class CB_Nolcycle_a_00180_C2 {
+    CB_Nolcycle_a_00180_D2 d2_0;
+    CB_Nolcycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CB_Nolcycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+//该树有12个节点
+class CB_Nolcycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CB_Nolcycle_a_00180 {
+    public CB_Nolcycle_a_00180() {
+        CB_Nolcycle_a_00180_A1 a1_main = new CB_Nolcycle_a_00180_A1("a1_main");
+        CB_Nolcycle_a_00180_A2 a2_main = new CB_Nolcycle_a_00180_A2("a2_main");
+        CB_Nolcycle_a_00180_A3 a3_main = new CB_Nolcycle_a_00180_A3("a3_main");
+        CB_Nolcycle_a_00180_A4 a4_main = new CB_Nolcycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new CB_Nolcycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new CB_Nolcycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new CB_Nolcycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+
+        a3_main.b2_0 = new CB_Nolcycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new CB_Nolcycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+
+        a3_main.c2_0 = new CB_Nolcycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+
+        a4_main.b3_0 = new CB_Nolcycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new CB_Nolcycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new CB_Nolcycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+    }
+}
+
+class CB_01_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_01_A2 a2_0;
+    CB_01_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_01_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        //System.out.println("A finalize");
+
+        CB_01.check = this;
+
+    }
+}
+
+class CB_01_A2 {
+    static CB_01_A1 a1_0;
+    volatile static HashMap test2;
+    CB_01_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_01_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_01_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_01_A3 {
+    static CB_Nolcycle_a_00180[] test1;
+    CB_01_A1 a1_0;
+    CB_01_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_01_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_01_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_01 {
+    public static CB_01_A1 check = null;
+    private static CB_01_A1 a1_main = null;
+
+    private CB_01() {
+        a1_main = new CB_01_A1("a1_main");
+        a1_main.a2_0 = new CB_01_A2("a2_0");
+        CB_01_A2.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_01_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_01(int times) {
+        CB_01_A1.test1 = new HashMap();
+        CB_01_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_01_A1.test1.put(i, new CB_Nolcycle_a_00180());
+            CB_01_A2.test2.put(i, new CB_Nolcycle_a_00180());
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_01 cb01 = new CB_01();
+        test_CB_01(10000);
+        check = a1_main;
+        try {
+            int result = CB_01.check.sum + CB_01.check.a2_0.sum + CB_01.check.a2_0.a3_0.sum + CB_01_A1.test1.size() + CB_01_A2.test2.size();
+            if (result == 20918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0478-rc-StackScan-CB_02/CB_02.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0478-rc-StackScan-CB_02/CB_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..a989fd27ba0d13fe425822c86c8415c0ecb4d0ee
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0478-rc-StackScan-CB_02/CB_02.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CB02
+ *- @TestCaseName: CB_02
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为String类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_02.java
+ *- @ExecuteClass: CB_02
+ *- @ExecuteArgs:
+ */
+
+import java.util.HashMap;
+
+class CB_02_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_02_A2 a2_0;
+    CB_02_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_02_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_02.check = this;
+    }
+}
+
+class CB_02_A2 {
+    volatile static HashMap test2;
+    CB_02_A1 a1_0;
+    CB_02_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_02_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_02_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_02_A3 {
+    CB_02_A1 a1_0;
+    CB_02_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_02_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_02_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_02 {
+    public volatile static CB_02_A1 check = null;
+    private static CB_02_A1 a1_main = null;
+
+    private CB_02() {
+        a1_main = new CB_02_A1("a1_main");
+        a1_main.a2_0 = new CB_02_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_02_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_02(int times) {
+        CB_02_A1.test1 = new HashMap();
+        CB_02_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_02_A1.test1.put(i, "Maple" + i);
+            CB_02_A2.test2.put(i, "Figo" + i);
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_02 cb01 = new CB_02();
+        test_CB_02(100000);
+        check = a1_main;
+        try {
+            int result = CB_02.check.sum + CB_02.check.a2_0.sum + CB_02.check.a2_0.a3_0.sum + CB_02_A1.test1.size() + CB_02_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0479-rc-StackScan-CB_03/CB_03.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0479-rc-StackScan-CB_03/CB_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..de885782778cda94085a464dec19428f2159921d
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0479-rc-StackScan-CB_03/CB_03.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CB03
+ *- @TestCaseName: CB_03
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为StringBuffer类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_03.java
+ *- @ExecuteClass: CB_03
+ *- @ExecuteArgs:
+ */
+
+import java.util.HashMap;
+
+class CB_03_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_03_A2 a2_0;
+    CB_03_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_03_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_03.check = this;
+    }
+}
+
+class CB_03_A2 {
+    CB_03_A1 a1_0;
+    CB_03_A3 a3_0;
+    volatile HashMap test2;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_03_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_03_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_03_A3 {
+    CB_03_A1 a1_0;
+    CB_03_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_03_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_03_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_03 {
+    public volatile static CB_03_A1 check = null;
+    private static CB_03_A1 a1_main = null;
+
+    private CB_03() {
+        a1_main = new CB_03_A1("a1_main");
+        a1_main.a2_0 = new CB_03_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_03_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_03(int times) {
+        CB_03_A1.test1 = new HashMap();
+        a1_main.a2_0.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_03_A1.test1.put(i, new StringBuffer("Maple test").append(i));
+            a1_main.a2_0.test2.put(i, new StringBuffer("Figo test").append(i));
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_03 cb01 = new CB_03();
+        test_CB_03(100000);
+        check = a1_main;
+        try {
+            int result = CB_03.check.sum + CB_03.check.a2_0.sum + CB_03.check.a2_0.a3_0.sum + CB_03_A1.test1.size() + check.a2_0.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0480-rc-StackScan-CB_04/CB_04.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0480-rc-StackScan-CB_04/CB_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..98cf02fbfd4c99529975fd07611b7974c3e4f51c
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0480-rc-StackScan-CB_04/CB_04.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CB04
+ *- @TestCaseName: CB_04
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为StringBuilder类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_04.java
+ *- @ExecuteClass: CB_04
+ *- @ExecuteArgs:
+ */
+
+import java.util.HashMap;
+
+class CB_04_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_04_A2 a2_0;
+    CB_04_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_04_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("A finalize");
+
+        CB_04.check = this;
+
+    }
+
+}
+
+class CB_04_A2 {
+    volatile static HashMap test2;
+    CB_04_A1 a1_0;
+    CB_04_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_04_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_04_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("B finalize");
+    }
+}
+
+class CB_04_A3 {
+    CB_04_A1 a1_0;
+    CB_04_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_04_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_04_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_04 {
+    public static CB_04_A1 a1_main = null;
+    public volatile static CB_04_A1 check = null;
+
+    public CB_04() {
+        a1_main = new CB_04_A1("a1_main");
+        a1_main.a2_0 = new CB_04_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_04_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    public static void test_CB_04(int times) {
+        CB_04_A1.test1 = new HashMap();
+        CB_04_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_04_A1.test1.put(i, new StringBuilder().append(i));
+            CB_04_A2.test2.put(i, new StringBuilder().append(times + i));
+        }
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        CB_04 cb01 = new CB_04();
+        test_CB_04(100000);
+        check = a1_main;
+        try {
+            int result = CB_04.check.sum + CB_04.check.a2_0.sum + CB_04.check.a2_0.a3_0.sum + CB_04_A1.test1.size() + CB_04_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0481-rc-StackScan-CB_05/CB_05.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0481-rc-StackScan-CB_05/CB_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..b26a495121eecc3e6f7b6919d124a3e2870ae201
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0481-rc-StackScan-CB_05/CB_05.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CB05
+ *- @TestCaseName: CB_05
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为SoftReference类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_05.java
+ *- @ExecuteClass: CB_05
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.SoftReference;
+import java.util.HashMap;
+
+class CB_05_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_05_A2 a2_0;
+    CB_05_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_05_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_05.check = this;
+
+    }
+}
+
+class CB_05_A2 {
+    volatile static HashMap test2;
+    CB_05_A1 a1_0;
+    CB_05_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_05_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_05_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_05_A3 {
+    CB_05_A1 a1_0;
+    CB_05_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_05_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_05_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_05 {
+    public volatile static CB_05_A1 check = null;
+    private static CB_05_A1 a1_main = null;
+
+    private CB_05() {
+        a1_main = new CB_05_A1("a1_main");
+        a1_main.a2_0 = new CB_05_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_05_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_05(int times) {
+        CB_05_A1.test1 = new HashMap();
+        CB_05_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_05_A1.test1.put(i, new SoftReference<>("maple" + i));
+            CB_05_A2.test2.put(i, new SoftReference<>("maple" + times + i));
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_05 cb01 = new CB_05();
+        test_CB_05(10000);
+        check = a1_main;
+        try {
+            int result = CB_05.check.sum + CB_05.check.a2_0.sum + CB_05.check.a2_0.a3_0.sum + CB_05_A1.test1.size() + CB_05_A2.test2.size();
+            if (result == 20918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0482-rc-StackScan-CB_06/CB_06.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0482-rc-StackScan-CB_06/CB_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..27871b13cbef33849ed2349f054b5d9330706f57
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0482-rc-StackScan-CB_06/CB_06.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CB06
+ *- @TestCaseName: CB_06
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为WeakReference类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_06.java
+ *- @ExecuteClass: CB_06
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+
+class CB_06_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_06_A2 a2_0;
+    CB_06_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_06_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_06.check = this;
+    }
+}
+
+class CB_06_A2 {
+    volatile static HashMap test2;
+    CB_06_A1 a1_0;
+    CB_06_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_06_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_06_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_06_A3 {
+    CB_06_A1 a1_0;
+    CB_06_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_06_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_06_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_06 {
+    public volatile static CB_06_A1 check = null;
+    static String str;
+    private static CB_06_A1 a1_main = null;
+
+    private CB_06() {
+        a1_main = new CB_06_A1("a1_main");
+        a1_main.a2_0 = new CB_06_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_06_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_06(int times) {
+        CB_06_A1.test1 = new HashMap();
+        CB_06_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_06_A1.test1.put(i, new WeakReference("Maple" + i));
+            CB_06_A2.test2.put(i, new WeakReference("Figo" + i));
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_06 cb01 = new CB_06();
+        test_CB_06(100000);
+        check = a1_main;
+        try {
+            int result = CB_06.check.sum + CB_06.check.a2_0.sum + CB_06.check.a2_0.a3_0.sum + CB_06_A1.test1.size() + CB_06_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0483-rc-StackScan-CB_07/CB_07.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0483-rc-StackScan-CB_07/CB_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1254058014686c2cd66a35d908d2ba61f147225
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0483-rc-StackScan-CB_07/CB_07.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CB07
+ *- @TestCaseName: CB_07
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为PhantomReference类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_07.java
+ *- @ExecuteClass: CB_07
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+import java.util.HashMap;
+
+class CB_07_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_07_A2 a2_0;
+    CB_07_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_07_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_07.check = this;
+    }
+}
+
+class CB_07_A2 {
+    volatile static HashMap test2;
+    CB_07_A1 a1_0;
+    CB_07_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_07_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_07_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_07_A3 {
+    CB_07_A1 a1_0;
+    CB_07_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_07_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_07_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_07 {
+    public volatile static CB_07_A1 check = null;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static String str;
+    private static CB_07_A1 a1_main = null;
+
+    private CB_07() {
+        a1_main = new CB_07_A1("a1_main");
+        a1_main.a2_0 = new CB_07_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_07_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_07(int times) {
+        CB_07_A1.test1 = new HashMap();
+        CB_07_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_07_A1.test1.put(i, new PhantomReference<>("maple" + i, rq));
+            CB_07_A2.test2.put(i, new PhantomReference<>("Figo" + times + i, rq));
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_07 cb01 = new CB_07();
+        test_CB_07(100000);
+        check = a1_main;
+        try {
+            int result = CB_07.check.sum + CB_07.check.a2_0.sum + CB_07.check.a2_0.a3_0.sum + CB_07_A1.test1.size() + CB_07_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0484-rc-StackScan-CB_08/CB_08.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0484-rc-StackScan-CB_08/CB_08.java
new file mode 100644
index 0000000000000000000000000000000000000000..f19b139d6a3182866d43f9ebd83123d5b979b1fd
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0484-rc-StackScan-CB_08/CB_08.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CB08
+ *- @TestCaseName: CB_08
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为OutOfMemoryError类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_08.java
+ *- @ExecuteClass: CB_08
+ *- @ExecuteArgs:
+ */
+
+import java.util.HashMap;
+
+class CB_08_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_08_A2 a2_0;
+    CB_08_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_08_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_08.check = this;
+    }
+
+}
+
+class CB_08_A2 {
+    volatile static HashMap test2;
+    CB_08_A1 a1_0;
+    CB_08_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_08_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_08_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_08_A3 {
+    CB_08_A1 a1_0;
+    CB_08_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_08_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_08_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_08 {
+    public volatile static CB_08_A1 check = null;
+    private static CB_08_A1 a1_main = null;
+    private volatile static OutOfMemoryError test1;
+    private static OutOfMemoryError test2;
+
+    private CB_08() {
+        a1_main = new CB_08_A1("a1_main");
+        a1_main.a2_0 = new CB_08_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_08_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_08(int times) {
+        CB_08_A1.test1 = new HashMap();
+        CB_08_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            test1 = new OutOfMemoryError();
+            CB_08_A1.test1.put(i, test1);
+            test2 = new OutOfMemoryError();
+            CB_08_A2.test2.put(i, test2);
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_08 cb01 = new CB_08();
+        test_CB_08(100000);
+        check = a1_main;
+        try {
+            int result = CB_08.check.sum + CB_08.check.a2_0.sum + CB_08.check.a2_0.a3_0.sum + CB_08_A1.test1.size() + CB_08_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0485-rc-StackScan-CB_09/CB_09.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0485-rc-StackScan-CB_09/CB_09.java
new file mode 100644
index 0000000000000000000000000000000000000000..67595adb0f0522d0c210edbf9497c74eaff470a7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0485-rc-StackScan-CB_09/CB_09.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CB09
+ *- @TestCaseName: CB_09
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为ClassLoader类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_09.java
+ *- @ExecuteClass: CB_09
+ *- @ExecuteArgs:
+ */
+
+import java.util.HashMap;
+
+class CB_09_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_09_A2 a2_0;
+    CB_09_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_09_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_09.check = this;
+    }
+}
+
+class CB_09_A2 {
+    volatile static HashMap test2;
+    CB_09_A1 a1_0;
+    CB_09_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_09_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_09_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_09_A3 {
+    CB_09_A1 a1_0;
+    CB_09_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_09_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_09_A1.a + a2_0.a;
+    }
+}
+
+public class CB_09 {
+    public static CB_09_A1 a1_main = null;
+    public volatile static CB_09_A1 check = null;
+    public volatile static ClassLoader test1;
+    public static ClassLoader test2;
+
+    public CB_09() {
+        a1_main = new CB_09_A1("a1_main");
+        a1_main.a2_0 = new CB_09_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_09_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    public static void test_CB_09(int times) {
+        CB_09_A1.test1 = new HashMap();
+        CB_09_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            test1 = CB_09_A1.class.getClassLoader();
+            CB_09_A1.test1.put(i, test1);
+            test2 = CB_09_A1.class.getClassLoader();
+            CB_09_A2.test2.put(i, test2);
+        }
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        CB_09 cb01 = new CB_09();
+        test_CB_09(100000);
+        check = a1_main;
+        try {
+            int result = CB_09.check.sum + CB_09.check.a2_0.sum + CB_09.check.a2_0.a3_0.sum;
+            if (result == 918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0488-rc-StackScan-CP_Thread_03/CP_Thread_03.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0488-rc-StackScan-CP_Thread_03/CP_Thread_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..a124beed152db745f188da974b7c2bc77cc39d90
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0488-rc-StackScan-CP_Thread_03/CP_Thread_03.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CP_Thread_03
+ *- @TestCaseName: CP_Thread_03
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考StringBuffer，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_03.java
+ *- @ExecuteClass: CP_Thread_03
+ *- @ExecuteArgs:
+ */
+
+class CP_Thread_03_A1 {
+    static StringBuffer[] test1;
+    static
+    int a;
+    CP_Thread_03_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_03_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_03_test extends Thread {
+    private static CP_Thread_03_A1 a1_main = null;
+    private volatile static CP_Thread_03_A1 a2 = null;
+    private volatile static StringBuffer test1;
+    private static StringBuffer test2;
+
+    private static void test_CP_Thread_03_A1(int times) {
+        CP_Thread_03_A1.test1 = new StringBuffer[times];
+        for (int i = 0; i < times; i++) {
+            test1 = new StringBuffer("maple" + i);
+            CP_Thread_03_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_03_A2(int times) {
+        CP_Thread_03_A1.test1 = new StringBuffer[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new StringBuffer("maple" + times + i);
+            CP_Thread_03_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_03_A1("a1_main");
+        a2 = new CP_Thread_03_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_03_A1(10000);
+        test_CP_Thread_03_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_03 {
+    private static CP_Thread_03_A1 a1_main = null;
+    private volatile static CP_Thread_03_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_03_test cptest1 = new CP_Thread_03_test();
+        cptest1.run();
+        CP_Thread_03_test cptest2 = new CP_Thread_03_test();
+        cptest2.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0489-rc-StackScan-CP_Thread_04/CP_Thread_04.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0489-rc-StackScan-CP_Thread_04/CP_Thread_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..3fd20ca3e0b266e59b198a6e9c532975cd937630
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0489-rc-StackScan-CP_Thread_04/CP_Thread_04.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CP_Thread_04
+ *- @TestCaseName: CP_Thread_04
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考StringBuffer，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_04.java
+ *- @ExecuteClass: CP_Thread_04
+ *- @ExecuteArgs:
+ */
+
+class CP_Thread_04_A1 {
+    static StringBuilder[] test1;
+    static
+    int a;
+    CP_Thread_04_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_04_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_04_test extends Thread {
+    private static CP_Thread_04_A1 a1_main = null;
+    private volatile static CP_Thread_04_A1 a2 = null;
+    private volatile static StringBuilder test1;
+    private static StringBuilder test2;
+
+    private static void test_CP_Thread_04_A1(int times) {
+        CP_Thread_04_A1.test1 = new StringBuilder[times];
+        for (int i = 0; i < times; i++) {
+            test1 = new StringBuilder("maple" + i);
+            CP_Thread_04_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_04_A2(int times) {
+        CP_Thread_04_A1.test1 = new StringBuilder[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new StringBuilder("maple" + times + i);
+            CP_Thread_04_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_04_A1("a1_main");
+        a2 = new CP_Thread_04_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_04_A1(10000);
+        test_CP_Thread_04_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_04 {
+    private static CP_Thread_04_A1 a1_main = null;
+    private static CP_Thread_04_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_04_test cptest1 = new CP_Thread_04_test();
+        cptest1.run();
+        CP_Thread_04_test cptest2 = new CP_Thread_04_test();
+        cptest2.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0490-rc-StackScan-CP_Thread_05/CP_Thread_05.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0490-rc-StackScan-CP_Thread_05/CP_Thread_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..72cfc0df2b671233b57a99b028bfd16898f529ab
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0490-rc-StackScan-CP_Thread_05/CP_Thread_05.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CP_Thread_05
+ *- @TestCaseName: CP_Thread_05
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考SoftReference，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_05.java
+ *- @ExecuteClass: CP_Thread_05
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.SoftReference;
+
+class CP_Thread_05_A1 {
+    static SoftReference[] test1;
+    static
+    int a;
+    CP_Thread_05_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_05_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_05_test extends Thread {
+    static String str;
+    private static CP_Thread_05_A1 a1_main = null;
+    private volatile static CP_Thread_05_A1 a2 = null;
+    private volatile static SoftReference test1;
+    private static SoftReference test2;
+
+    private static void test_CP_Thread_05_A1(int times) {
+        CP_Thread_05_A1.test1 = new SoftReference[times];
+        for (int i = 0; i < times; i++) {
+            str = "maple" + i;
+            test1 = new SoftReference<>(str);
+            CP_Thread_05_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_05_A2(int times) {
+        CP_Thread_05_A1.test1 = new SoftReference[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new SoftReference<>("maple" + times + i);
+            CP_Thread_05_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_05_A1("a1_main");
+        a2 = new CP_Thread_05_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_05_A1(10000);
+        test_CP_Thread_05_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_05 {
+    private static CP_Thread_05_A1 a1_main = null;
+    private static CP_Thread_05_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_05_test cptest1 = new CP_Thread_05_test();
+        cptest1.run();
+        CP_Thread_05_test cptest2 = new CP_Thread_05_test();
+        cptest2.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0491-rc-StackScan-CP_Thread_06/CP_Thread_06.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0491-rc-StackScan-CP_Thread_06/CP_Thread_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..f947942dbe773f3f3e391c299a5206d0ee5115aa
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0491-rc-StackScan-CP_Thread_06/CP_Thread_06.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CP_Thread_06
+ *- @TestCaseName: CP_Thread_06
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考WeakReference，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_06.java
+ *- @ExecuteClass: CP_Thread_06
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.WeakReference;
+
+class CP_Thread_06_A1 {
+    static WeakReference[] test1;
+    static
+    int a;
+    CP_Thread_06_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_06_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_06_test extends Thread {
+    static String str;
+    private static CP_Thread_06_A1 a1_main = null;
+    private volatile static CP_Thread_06_A1 a2 = null;
+    private volatile static WeakReference test1;
+    private static WeakReference test2;
+
+    private static void test_CP_Thread_06_A1(int times) {
+        CP_Thread_06_A1.test1 = new WeakReference[times];
+        for (int i = 0; i < times; i++) {
+            str = "maple" + i;
+            test1 = new WeakReference<>(str);
+            CP_Thread_06_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_06_A2(int times) {
+        CP_Thread_06_A1.test1 = new WeakReference[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new WeakReference<>("maple" + times + i);
+            CP_Thread_06_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_06_A1("a1_main");
+        a2 = new CP_Thread_06_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_06_A1(10000);
+        test_CP_Thread_06_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_06 {
+    private static CP_Thread_06_A1 a1_main = null;
+    private static CP_Thread_06_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_06_test cptest1 = new CP_Thread_06_test();
+        cptest1.run();
+        CP_Thread_06_test cptest2 = new CP_Thread_06_test();
+        cptest2.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0492-rc-StackScan-CP_Thread_07/CP_Thread_07.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0492-rc-StackScan-CP_Thread_07/CP_Thread_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..1eff290cca9aaa47ca8861d91ce925e6b8da3f72
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0492-rc-StackScan-CP_Thread_07/CP_Thread_07.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CP_Thread_07
+ *- @TestCaseName: CP_Thread_07
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考PhantomReference，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_07.java
+ *- @ExecuteClass: CP_Thread_07
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+
+class CP_Thread_07_A1 {
+    static PhantomReference[] test1;
+    static
+    int a;
+    CP_Thread_07_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_07_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_07_test extends Thread {
+    static ReferenceQueue rq = new ReferenceQueue();
+    static String str;
+    private static CP_Thread_07_A1 a1_main = null;
+    private volatile static CP_Thread_07_A1 a2 = null;
+
+    private static void test_CP_Thread_07_A1(int times) {
+        CP_Thread_07_A1.test1 = new PhantomReference[times];
+        for (int i = 0; i < times; i++) {
+            str = "maple" + i;
+            PhantomReference<String> temp = new PhantomReference<>(str, rq);
+            CP_Thread_07_A1.test1[i] = temp;
+        }
+    }
+
+    private static void test_CP_Thread_07_A2(int times) {
+        CP_Thread_07_A1.test1 = new PhantomReference[times];
+        for (int i = 0; i < times; i++) {
+            PhantomReference<String> temp = new PhantomReference<>(str + times + i, rq);
+            CP_Thread_07_A1.test1[i] = temp;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_07_A1("a1_main");
+        a2 = new CP_Thread_07_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_07_A1(10000);
+        test_CP_Thread_07_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_07 {
+    private static CP_Thread_07_A1 a1_main = null;
+    private static CP_Thread_07_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_07_test cptest1 = new CP_Thread_07_test();
+        cptest1.run();
+        CP_Thread_07_test cptest2 = new CP_Thread_07_test();
+        cptest2.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0493-rc-StackScan-CP_Thread_08/CP_Thread_08.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0493-rc-StackScan-CP_Thread_08/CP_Thread_08.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ed638739eb8825fd95a6c9abe6b40c9711dfd82
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0493-rc-StackScan-CP_Thread_08/CP_Thread_08.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CP_Thread_08
+ *- @TestCaseName: CP_Thread_08
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考OutOfMemoryError，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_08.java
+ *- @ExecuteClass: CP_Thread_08
+ *- @ExecuteArgs:
+ */
+
+class CP_Thread_08_A1 {
+    static OutOfMemoryError[] test1;
+    static
+    int a;
+    CP_Thread_08_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_08_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_08_test extends Thread {
+    private static CP_Thread_08_A1 a1_main = null;
+    private volatile static CP_Thread_08_A1 a2 = null;
+    private volatile static OutOfMemoryError test1;
+    private static OutOfMemoryError test2;
+
+    private static void test_CP_Thread_08_A1(int times) {
+        CP_Thread_08_A1.test1 = new OutOfMemoryError[times];
+        for (int i = 0; i < times; i++) {
+            test1 = new OutOfMemoryError();
+            CP_Thread_08_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_08_A2(int times) {
+        CP_Thread_08_A1.test1 = new OutOfMemoryError[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new OutOfMemoryError();
+            CP_Thread_08_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_08_A1("a1_main");
+        a2 = new CP_Thread_08_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_08_A1(10000);
+        test_CP_Thread_08_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_08 {
+    private static CP_Thread_08_A1 a1_main = null;
+    private volatile static CP_Thread_08_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_08_test cptest1 = new CP_Thread_08_test();
+        cptest1.run();
+        CP_Thread_08_test cptest2 = new CP_Thread_08_test();
+        cptest2.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/memory_management/StackScan/RC0494-rc-StackScan-CP_Thread_09/CP_Thread_09.java b/test/testsuite/ouroboros/memory_management/StackScan/RC0494-rc-StackScan-CP_Thread_09/CP_Thread_09.java
new file mode 100644
index 0000000000000000000000000000000000000000..d9e5b6e13627a16924d7997b90420b216c7bb4c7
--- /dev/null
+++ b/test/testsuite/ouroboros/memory_management/StackScan/RC0494-rc-StackScan-CP_Thread_09/CP_Thread_09.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MemoryManagement2.0_CP_Thread_09
+ *- @TestCaseName: CP_Thread_09
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考ClassLoader，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_09.java
+ *- @ExecuteClass: CP_Thread_09
+ *- @ExecuteArgs:
+ */
+
+class CP_Thread_09_A1 {
+    static ClassLoader[] test1;
+    static
+    int a;
+    CP_Thread_09_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_09_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_09_test extends Thread {
+    private static CP_Thread_09_A1 a1_main = null;
+    private volatile static CP_Thread_09_A1 a2 = null;
+    private volatile static ClassLoader test1;
+    private static ClassLoader test2;
+
+    private static void test_CP_Thread_09_A1(int times) {
+        CP_Thread_09_A1.test1 = new ClassLoader[times];
+        for (int i = 0; i < times; i++) {
+            test1 = CP_Thread_09_A1.class.getClassLoader();
+            CP_Thread_09_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_09_A2(int times) {
+        CP_Thread_09_A1.test1 = new ClassLoader[times];
+        for (int i = 0; i < times; i++) {
+            test2 = CP_Thread_09_A1.class.getClassLoader();
+            CP_Thread_09_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_09_A1("a1_main");
+        a2 = new CP_Thread_09_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_09_A1(10000);
+        test_CP_Thread_09_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_09 {
+    private static CP_Thread_09_A1 a1_main = null;
+    private volatile static CP_Thread_09_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_09_test cptest1 = new CP_Thread_09_test();
+        cptest1.run();
+        CP_Thread_09_test cptest2 = new CP_Thread_09_test();
+        cptest2.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/other_test/RT0001-rt-other-CharacterNativeUncover/CharacterNativeUncover.java b/test/testsuite/ouroboros/other_test/RT0001-rt-other-CharacterNativeUncover/CharacterNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..596d92b942a4f00404112facead7655f3f573236
--- /dev/null
+++ b/test/testsuite/ouroboros/other_test/RT0001-rt-other-CharacterNativeUncover/CharacterNativeUncover.java
@@ -0,0 +1,586 @@
+/**
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: natives/CharacterNativeUncover.java
+ * -@Title/Destination: Character Methods
+ * -@Brief:
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterNativeUncover.java
+ * -@ExecuteClass: CharacterNativeUncover
+ * -@ExecuteArgs:
+ */
+
+public class CharacterNativeUncover {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        int result = 2;
+        CharacterDemo1();
+        if (result == 2 && res == 53) {
+            res = 0;
+        }
+        System.out.println(res);
+    }
+
+
+    public static void CharacterDemo1() {
+        Character character = new Character('a');
+        test1(character);
+        test2(character);
+        test3(character);
+        test4(character);
+        test5(character);
+        test6(character);
+        test7(character);
+        test8(character);
+        test9(character);
+        test10(character);
+        test11(character);
+        test12(character);
+        test13(character);
+        test14(character);
+        test15(character);
+        test16(character);
+        test17(character);
+        test18(character);
+        test19(character);
+        test20(character);
+        test21(character);
+        test22(character);
+        test23(character);
+    }
+
+
+    /**
+     * static native boolean isLowerCaseImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test1(Character character) {
+        try {
+            boolean flag = Character.isLowerCase(97);//isLowerCaseImpl() called by isLowerCase();
+            // System.out.println(flag);
+            if (flag) {
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isUpperCaseImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test2(Character character) {
+        try {
+            boolean flag = Character.isUpperCase(65);//isUpperCaseImpl() called by isUpperCase();
+            //System.out.println(flag);
+            if (flag) {
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isTitleCaseImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test3(Character character) {
+        try {
+            boolean flag = Character.isTitleCase(0x01c8);//isTitleCaseImpl() called by isTitleCase();
+            //System.out.println(flag);
+            if (flag) {
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isDigitImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test4(Character character) {
+        try {
+            boolean flag = Character.isDigit(0x06f8);//isDigitImpl() called by isDigit();judge if it`s number;
+            //System.out.println(flag);
+            if (flag) {
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isDefinedImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test5(Character character) {
+        try {
+            boolean flag = Character.isDefined(0x012345);//isDefinedImpl()  called by isDefined();
+            //System.out.println(flag);
+            if (flag) {
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+    /**
+     * static native boolean isLetterImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test6(Character character) {
+        try {
+            boolean flag = Character.isLetter(0x0065);//isLetterImpl() called by isLetter();tell if it`s char type;
+            //System.out.println(flag);
+            if (flag) {
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isLetterOrDigitImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test7(Character character) {
+        try {
+            boolean flag = Character.isLetterOrDigit(0x0033);//isLetterOrDigitImpl() called by isLetterOrDigit();tell if it`s char type;
+            //System.out.println(flag);
+            if (flag) {
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isAlphabeticImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test8(Character character) {
+        try {
+            boolean flag = Character.isAlphabetic(0x0065);//isAlphabeticImpl() called by  isAlphabetic(); tell if it`s char type;
+            //System.out.println(flag);
+            if (flag) {
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isIdeographicImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test9(Character character) {
+        try {
+            boolean flag = Character.isIdeographic(0x0065);//isIdeographicImpl() called by isIdeographic();
+
+            if (!flag) {
+                //System.out.println(flag);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isUnicodeIdentifierStartImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test10(Character character) {
+        try {
+            boolean flag = Character.isUnicodeIdentifierStart(0x0065);//isUnicodeIdentifierStartImpl() called by isUnicodeIdentifierStart();
+
+            if (flag) {
+                //System.out.println(flag);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isUnicodeIdentifierPartImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test11(Character character) {
+        try {
+            boolean flag = Character.isUnicodeIdentifierPart(0x053e);//isUnicodeIdentifierPartImpl() called by isUnicodeIdentifierPart();
+
+            if (flag) {
+                //System.out.println(flag);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * ensure the char should be a ignoreable char in java  or unicode identifier
+     * static native boolean isIdentifierIgnorableImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test12(Character character) {
+        try {
+            boolean flag = Character.isIdentifierIgnorable(0x053e);//isIdentifierIgnorableImpl() called by isIdentifierIgnorable();
+
+            if (!flag) {
+                //System.out.println(flag);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native int toLowerCaseImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test13(Character character) {
+        try {
+            int num = Character.toLowerCase(0x053e);//toLowerCaseImpl() called by toLowerCase();
+
+            if (num == 1390) {
+                //System.out.println(num);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+    /**
+     * static native int toUpperCaseImpl(int codePoint)
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test14(Character character) {
+        try {
+            int num = Character.toUpperCase(0x053e);//toUpperCaseImpl() called by toUpperCase();
+
+            if (num == 1342) {
+                //System.out.println(num);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native int toTitleCaseImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test15(Character character) {
+        try {
+            int num = Character.toTitleCase(0x053e);//toTitleCaseImpl() called by toTitleCase();
+
+            if (num == 1342) {
+                //System.out.println(num);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+    /**
+     * native static int digitImpl(int codePoint, int radix);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test16(Character character) {
+        try {
+            int num = Character.digit(9, 2);//digitImpl() called by digit();
+
+            if (num == -1) {
+                //System.out.println(num);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * native static int getNumericValueImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test17(Character character) {
+        try {
+            int num = Character.getNumericValue(9);//getNumericValueImpl() called by getNumericValue();
+
+            if (num == -1) {
+                //System.out.println(num);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native boolean isSpaceCharImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test18(Character character) {
+        try {
+            boolean flag = Character.isSpaceChar(9);//isSpaceCharImpl()  called by isSpaceChar();
+
+            if (!flag) {
+                //System.out.println(flag);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * native static boolean isWhitespaceImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test19(Character character) {
+        try {
+            boolean flag = Character.isWhitespace(9);//isWhitespaceImpl() called by isWhitespace();
+
+            if (flag) {
+                //System.out.println(flag);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * static native int getTypeImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test20(Character character) {
+        try {
+            int num = Character.getType(9);//getTypeImpl() called by getType();
+
+            if (num == 15) {
+                //System.out.println(num);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+    /**
+     * native static byte getDirectionalityImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test21(Character character) {
+        try {
+            int num = Character.getDirectionality(9);//getDirectionalityImpl() called by getDirectionality();
+
+            if (num == 11) {
+                //System.out.println(num);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * native static boolean isMirroredImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test22(Character character) {
+        try {
+            boolean flag = Character.isMirrored(9);//isMirroredImpl() called by isMirrored();
+
+            if (!flag) {
+                //System.out.println(flag);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    /**
+     * private static native String getNameImpl(int codePoint);
+     *
+     * @param character
+     * @return
+     */
+    public static boolean test23(Character character) {
+        try {
+            String string = Character.getName(9);//getNameImpl() called by getName();
+
+            //if (string.equals("CHARACTER TABULATION")) {
+            if (string.equals("<control-0009>")) {
+                //System.out.println(string);
+                CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/other_test/RT0002-rt-other-ClassNativeUncover/ClassNativeUncover.java b/test/testsuite/ouroboros/other_test/RT0002-rt-other-ClassNativeUncover/ClassNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..3be4091b7e984641b94dcf07fa19a70015a8b70f
--- /dev/null
+++ b/test/testsuite/ouroboros/other_test/RT0002-rt-other-ClassNativeUncover/ClassNativeUncover.java
@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: natives/ClassNativeUncover.java
+ * -@Title/Destination: ClassNativeUncover Methods
+ * -@Brief:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ClassNativeUncover.java
+ * -@ExecuteClass: ClassNativeUncover
+ * -@ExecuteArgs:
+ */
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+
+public class ClassNativeUncover {
+    private static int res = 99;
+    public String name;
+
+    public ClassNativeUncover() {
+        super();
+
+    }
+
+    public ClassNativeUncover(String name) {
+        super();
+        this.name = name;
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        ClassDemo1();
+
+        if (result == 2 && res == 65) {
+            res = 0;
+        }
+        System.out.println(res);
+    }
+
+
+    public static void ClassDemo1() {
+        Class class1 = ClassNativeUncover.class;
+        test1(class1);
+        test2(class1);
+        test3(class1);
+        test4(class1);
+        test5(class1);
+        test6(class1);
+        test7(class1);
+        test8(class1);
+        test9(class1);
+        test10(class1);
+        test11(class1);
+        test12(class1);
+        test13(class1);
+        test14(class1);
+        test15(class1);
+        test16(class1);
+        test17(class1);
+    }
+
+    /**
+     * public native Class<?> getDeclaringClass();
+     *
+     * @param class1
+     */
+    public static void test1(Class class1) {
+        try {
+            boolean flag = class1.isMemberClass();//getDeclaringClass() called by isMemberClass();
+            if (!flag) {
+                //System.out.println(flag);
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            ClassNativeUncover.res = ClassNativeUncover.res - 2;
+        }
+    }
+
+
+    /**
+     * public native Class<?> getEnclosingClass();
+     *
+     * @param class1
+     */
+    public static void test2(Class class1) {
+        try {
+            String string = class1.getCanonicalName();//getEnclosingClass() called by getCanonicalName();
+            if (string.equals("ClassNativeUncover")) {
+                //System.out.println(string);
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * public native boolean isAnonymousClass();
+     *
+     * @param class1
+     */
+    public static void test3(Class class1) {
+        try {
+            boolean flag = class1.isAnonymousClass();
+            if (!flag) {
+                //System.out.println(flag);
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * private native Field getPublicFieldRecursive(String name);
+     *
+     * @param class1
+     */
+    public static void test4(Class class1) {
+        try {
+            Field field = class1.getField("name");//get the whole attributes which named "public" and inherited from parent class;getPublicFieldRecursive() called by getField();
+            if (field.toString().equals("public java.lang.String ClassNativeUncover.name")) {
+                //System.out.println(field.toString());
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    /**
+     * public native Field[] getDeclaredFields();
+     *
+     * @param class1
+     */
+    public static void test5(Class class1) {
+        try {
+            Field[] fields = class1.getDeclaredFields();//get all declarative attributes;
+            if (fields != null && fields.length > 0) {
+//                for(Field field:fields ) {
+//                System.out.println(field);
+//            }
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    /**
+     * public native Method[] MethodsUnchecked(boolean publicOnly);
+     *
+     * @param class1
+     */
+    public static void test6(Class class1) {
+        try {
+            Method[] methods = class1.getDeclaredMethods();//get declarative methods;getDeclaredMethodsUnchecked() called by getDeclaredMethods();
+            if (methods != null && methods.length > 0) {
+//                for(Method method:methods ) {
+//                System.out.println(method);
+//            }
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    /**
+     * private native Constructor<?>[] getDeclaredConstructorsInternal(boolean publicOnly);
+     *
+     * @param class1
+     */
+    public static void test7(Class class1) {
+        try {
+            Constructor[] constructors = class1.getConstructors();//get public constructions and inherited from parent class;getDeclaredConstructorsInternal()called bygetConstructors();
+            if (constructors != null && constructors.length > 0) {
+//                for(Constructor constructor:constructors ) {
+//                System.out.println(constructor);
+//            }
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * dcons
+     * private native Constructor<?>[] getDeclaredConstructorsInternal(boolean publicOnly);
+     *
+     * @param class1
+     */
+    public static void test8(Class class1) {
+        try {
+            Constructor[] constructors = class1.getDeclaredConstructors();//get all of declarative construcors;getDeclaredConstructorsInternal() called by getDeclaredConstructors;
+            if (constructors != null && constructors.length > 0) {
+//            for(Constructor constructor:constructors ) {
+//                System.out.println(constructor);
+//            }
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    /**
+     * public native Field getDeclaredField(String name) throws NoSuchFieldException;
+     *
+     * @param class1
+     */
+    public static void test9(Class class1) {
+        try {
+            Field field = class1.getDeclaredField("res");
+            if (field.toString().equals("private static int ClassNativeUncover.res")) {
+                //System.out.println(field);
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    /**
+     * private native Constructor<T> getDeclaredConstructorInternal(Class<?>[] args);
+     *
+     * @param class1
+     */
+    public static void test10(Class class1) {
+        try {
+            Constructor constructor = class1.getConstructor(new Class[]{String.class});//getDeclaredConstructorInternal() called by getConstructor;
+            if (constructor.toString().equals("public ClassNativeUncover(java.lang.String)")) {
+                //System.out.println(constructor);
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * private native Constructor<T> getDeclaredConstructorInternal(Class<?>[] args);
+     *
+     * @param class1
+     */
+    public static void test11(Class class1) {
+        try {
+            Constructor constructor = class1.getDeclaredConstructor(new Class[]{String.class});//getDeclaredConstructorInternal() called by getDeclaredConstructor();
+            if (constructor.toString().equals("public ClassNativeUncover(java.lang.String)")) {
+                //System.out.println(constructor);
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    /**
+     * private native String getInnerClassName();
+     *
+     * @param class1
+     */
+    public static void test12(Class class1) {
+        try {
+            String string = class1.getSimpleName();//getInnerClassName() called by getSimpleName();
+            if (string.equals("ClassNativeUncover")) {
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+                //System.out.println(string);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * private native String[] getSignatureAnnotation();
+     *
+     * @param class1
+     */
+    public static void test13(Class class1) {
+        try {
+            TypeVariable[] typeVariables = class1.getTypeParameters();//return a array length 0;getSignatureAnnotation() called by getTypeParameters();
+            if (typeVariables.getClass().toString().equals("class [Ljava.lang.reflect.TypeVariable;") && typeVariables.length == 0) {
+                //System.out.println(typeVariables.length);
+                //System.out.println(typeVariables.getClass().toString());
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * private native String[] getSignatureAnnotation();
+     *
+     * @param class1
+     */
+    public static void test14(Class class1) {
+        try {
+            Type type = class1.getGenericSuperclass();//getSignatureAnnotation()called by getGenericSuperclass;
+            if (type.toString().equals("class java.lang.Object")) {
+                //System.out.println(type);
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * private native String[] getSignatureAnnotation();
+     *
+     * @param class1
+     */
+    public static void test15(Class class1) {
+
+        Type[] type = class1.getGenericInterfaces();//getSignatureAnnotation() called by getGenericInterfaces;
+        if (type.length == 0 && type.getClass().toString().equals("class [Ljava.lang.Class;")) {
+            //System.out.println(type.length);
+            //System.out.println(type.getClass().toString());
+            ClassNativeUncover.res = ClassNativeUncover.res - 2;
+        }
+    }
+
+    /**
+     * private native Method getDeclaredMethodInternal(String name, Class<?>[] args);
+     *
+     * @param class1
+     */
+    public static void test16(Class class1) {
+        try {
+            Method method = class1.getMethod("ClassDemo1");//getDeclaredMethodInternal() called by getMethod()
+            if (method.toString().equals("public static void ClassNativeUncover.ClassDemo1()")) {
+                //System.out.println(method);
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void test17(Class class1) {
+        try {
+            Annotation[] a = class1.getAnnotations(); //getDeclaredAnnotations() called by getAnnotations()
+            if (a.length == 0 && a.getClass().toString().equals("class [Ljava.lang.annotation.Annotation;")) {
+                //System.out.println(a.length);
+                //System.out.println(a.getClass().toString());
+                ClassNativeUncover.res = ClassNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/other_test/RT0003-rt-other-ConstructorNativeUncover/ConstructorNativeUncover.java b/test/testsuite/ouroboros/other_test/RT0003-rt-other-ConstructorNativeUncover/ConstructorNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1a3f5d057413a151913c44a11ca4e131a78d3d4
--- /dev/null
+++ b/test/testsuite/ouroboros/other_test/RT0003-rt-other-ConstructorNativeUncover/ConstructorNativeUncover.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: reflect.natives/ConstructorNativeUncover.java
+ * -@Title/Destination: ConstructorNativeUncover Methods
+ * -@Brief:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ConstructorNativeUncover.java
+ * -@ExecuteClass: ConstructorNativeUncover
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+import java.util.Arrays;
+
+public class ConstructorNativeUncover {
+
+    private static int res = 99;
+
+    public ConstructorNativeUncover() {
+        super();
+        // TODO Auto-generated constructor stub
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        ConstructorDemo1();
+        if (result == 2 && res == 97) {
+            res = 0;
+        }
+        System.out.println(res);
+    }
+
+
+    public static void ConstructorDemo1() {
+        ConstructorNativeUncover constructorNativeUncover = new ConstructorNativeUncover();
+        test(constructorNativeUncover);
+    }
+
+
+    /**
+     * public native Class<?>[] getExceptionTypes();
+     * @param constructorNativeUncover
+     * @return
+     */
+    public static boolean test(ConstructorNativeUncover constructorNativeUncover) {
+        try {
+            Class class1 = constructorNativeUncover.getClass();
+            Constructor constructor = class1.getConstructor(new Class[] {});
+            Class[] classes = constructor.getExceptionTypes();
+            if (classes.length == 0 && classes.getClass().toString().equals("class [Ljava.lang.Class;")) {
+//                System.out.println(classes.getClass().toString());
+//                System.out.println(classes.length);
+                ConstructorNativeUncover.res = ConstructorNativeUncover.res - 2;
+            }
+        } catch(NoSuchMethodException e) {
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/other_test/RT0005-rt-other-MethodNativeUncover/MethodNativeUncover.java b/test/testsuite/ouroboros/other_test/RT0005-rt-other-MethodNativeUncover/MethodNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a348e5ce829531c144d761e347cf8a7f0f31db9
--- /dev/null
+++ b/test/testsuite/ouroboros/other_test/RT0005-rt-other-MethodNativeUncover/MethodNativeUncover.java
@@ -0,0 +1,104 @@
+
+
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: reflect.natives/MethodNativeUncover.java
+ * -@Title/Destination: MethodNativeUncover Methods
+ * -@Brief:
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodNativeUncover.java
+ * -@ExecuteClass: MethodNativeUncover
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+public class MethodNativeUncover {
+
+private static int res = 99;
+
+    public static void sayHello() {
+        String hello = "halo";
+    }
+
+
+    public static void main(String[] args) {
+        int result = 2;
+        MethodDemo1();
+        if (result == 2 && res == 95) {
+            res = 0;
+        }
+        System.out.println(res);
+    }
+
+
+    public static void MethodDemo1(){
+        MethodNativeUncover methodNativeUncover = new MethodNativeUncover();
+        test(methodNativeUncover);
+        test1(methodNativeUncover);
+
+    }
+
+    /**
+     * public native Class<?>[] getExceptionTypes();
+     * @param methodNativeUncover
+     */
+    public static void test(MethodNativeUncover methodNativeUncover) {
+        Class class1 = methodNativeUncover.getClass();
+        try {
+            Method method = class1.getMethod("sayHello");
+            Class[] newClass = method.getExceptionTypes();
+            if (newClass.length == 0 && newClass.getClass().toString().equals("class [Ljava.lang.Class;")) {
+            //System.out.println(newClass.length);
+            //System.out.println(newClass.getClass());
+            MethodNativeUncover.res = MethodNativeUncover.res - 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+
+    /**
+     * public native Object getDefaultValue();
+     * @param methodNativeUncover
+     */
+    public static void test1(MethodNativeUncover methodNativeUncover) {
+        Class class1 = methodNativeUncover.getClass();
+        try {
+            Method method = class1.getMethod("sayHello");
+            Object object = method.getDefaultValue();
+            if (object == null) {
+            //System.out.println(object);
+            MethodNativeUncover.res = MethodNativeUncover.res - 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/other_test/RT0006-rt-other-ThreadNativeUncover/ThreadNativeUncover.java b/test/testsuite/ouroboros/other_test/RT0006-rt-other-ThreadNativeUncover/ThreadNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..f13a19408b8fd155c48766da4d60cbd16efcba8d
--- /dev/null
+++ b/test/testsuite/ouroboros/other_test/RT0006-rt-other-ThreadNativeUncover/ThreadNativeUncover.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Ouroboros/rt_test/ThreadNativeUncover.java
+ * - @Title/Destination: ThreadNativeUncover Methods getState()
+ * - @Brief:
+ * - @Expect:expected.txt
+ * - @Priority: High
+ * - @Source: ThreadNativeUncover.java
+ * - @ExecuteClass: ThreadNativeUncover
+ * - @ExecuteArgs:
+ */
+
+import java.lang.Thread.State;
+
+public class ThreadNativeUncover {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        int result = 2;
+        ThreadDemo1();
+        if (result == 2 && res == 97) {
+            res = 0;
+        }
+        System.out.println(res);
+    }
+
+    public static void ThreadDemo1() {
+        Thread thread = new Thread();
+        test(thread);
+    }
+
+    /**
+     * private native int nativeGetStatus(boolean hasBeenStarted);
+     * @param thread
+     */
+    public static void test(Thread thread) {
+        try {
+            State state = thread.getState();//nativeGetStatus() called by getState();
+            if (state.toString().equals("NEW")) {
+                ThreadNativeUncover.res = ThreadNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/other_test/RT0007-rt-other-ThrowableNativeUncover/ThrowableNativeUncover.java b/test/testsuite/ouroboros/other_test/RT0007-rt-other-ThrowableNativeUncover/ThrowableNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6dc93f62150136109c1cedb0dccb12fdce08117
--- /dev/null
+++ b/test/testsuite/ouroboros/other_test/RT0007-rt-other-ThrowableNativeUncover/ThrowableNativeUncover.java
@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: natives/ThrowableNativeUncover.java
+ * -@Title/Destination: ThrowableNativeUncover Methods
+ * -@Brief:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ThrowableNativeUncover.java
+ * -@ExecuteClass: ThrowableNativeUncover
+ * -@ExecuteArgs:
+ */
+
+public class ThrowableNativeUncover {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        ThrowableDemo1();
+    }
+
+
+
+    public static void ThrowableDemo1() {
+        int result = 2;
+        Throwable throwable = new Throwable();
+        test(throwable);
+        test1(throwable);
+        if (result == 2 && res == 95) {
+            res = 0;
+        }
+        System.out.println(res);
+    }
+
+    /**
+     * private static native Object nativeFillInStackTrace();
+     * @param throwable
+     * @return
+     */
+    public static boolean test(Throwable throwable) {
+
+        try {
+            Throwable throwable2 = throwable.fillInStackTrace();//nativeFillInStackTrace() called by fillInStackTrace();
+            if (throwable2.toString().equals("java.lang.Throwable")) {
+                //System.out.println(throwable2.toString());
+                ThrowableNativeUncover.res = ThrowableNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+
+        }
+        return true;
+    }
+
+
+    /**
+     * private static native StackTraceElement[] nativeGetStackTrace(Object stackState);
+     * @param throwable
+     * @return
+     */
+    public static boolean test1(Throwable throwable) {
+        try {
+            StackTraceElement[] stackTraceElements = throwable.getStackTrace();//nativeGetStackTrace() called by getStackTrace();
+            if (stackTraceElements.length == 3 && stackTraceElements.getClass().toString().equals("class [Ljava.lang.StackTraceElement;")) {
+                //System.out.println(stackTraceElements.length);
+                //System.out.println(stackTraceElements.getClass().toString());
+                ThrowableNativeUncover.res = ThrowableNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return true;
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/other_test/issue-RT0630-rt-other-ArrayNativeUncover/ArrayNativeUncover.java b/test/testsuite/ouroboros/other_test/issue-RT0630-rt-other-ArrayNativeUncover/ArrayNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..766fa86eefe7e2bdad2b9a20effa7ea7b0c49e63
--- /dev/null
+++ b/test/testsuite/ouroboros/other_test/issue-RT0630-rt-other-ArrayNativeUncover/ArrayNativeUncover.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: reflect.natives/ArrayNativeUncover.java
+ * -@Title/Destination: ArrayNativeUncover Methods
+ * -@Brief:
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: ArrayNativeUncover.java
+ * -@ExecuteClass: ArrayNativeUncover
+ * -@ExecuteArgs:
+ */
+import java.lang.reflect.Array;
+
+public class ArrayNativeUncover {
+    private static int res = 99;
+
+    public static void main(String[] args) {
+        int result = 2;
+        ArrayDemo1();
+        if (result == 2 && ArrayNativeUncover.res == 97) {
+            result = 0;
+            System.out.println(result);
+        }
+    }
+
+    public static void ArrayDemo1() {
+        test1();
+    }
+
+
+    /**
+     * private static native Object createObjectArray(Class<?> componentType, int length) throws NegativeArraySizeException;
+     *
+     * @return
+     */
+    public static boolean test1() {
+        try {
+            Object object = Array.newInstance(String.class, 5);//createObjectArray() called by newInstance();
+            if (object.getClass().toString().equals("class [Ljava.lang.String;")) {
+                ArrayNativeUncover.res = ArrayNativeUncover.res - 2;
+                return true;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/AccessibleObjectExObjectequals.java b/test/testsuite/ouroboros/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/AccessibleObjectExObjectequals.java
new file mode 100644
index 0000000000000000000000000000000000000000..0285d98a6f71721b18e10efdcaf6f2c181b510c0
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/AccessibleObjectExObjectequals.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectExObjectequals.java
+ * -@TestCaseName: Exception in reflect/AccessibleObject:  boolean equals(Object obj)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create Class AccessibleClass1 Field with sampleField
+ * -#step2: Create Object1 Get the Field of the sampleField of AccessibleClass1 through the getDeclaredField method
+ * -#step3: Create Object2 Get the Field of sampleField of AccessibleClass1 by getDeclaredField method
+ * -#step4: Call equals to compare object 1 and object 2 and confirm that they are equal
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectExObjectequals.java
+ * -@ExecuteClass: AccessibleObjectExObjectequals
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.*;
+
+public class AccessibleObjectExObjectequals {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new AccessibleObjectExObjectequals().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = accessibleObjectExObjectequals1();
+        } catch (Exception e) {
+            AccessibleObjectExObjectequals.res = AccessibleObjectExObjectequals.res - 20;
+        }
+        if (result == 4 && AccessibleObjectExObjectequals.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+
+
+    private int accessibleObjectExObjectequals1() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // boolean equals(Object obj)
+        AccessibleObject sampleField2 = AccessibleClass1.class.getDeclaredField("sampleField");
+        AccessibleObject sampleField1 = AccessibleClass1.class.getDeclaredField("sampleField");
+        if (sampleField2.equals(sampleField1)) {
+            AccessibleObjectExObjectequals.res = AccessibleObjectExObjectequals.res - 10;
+        } else {
+            AccessibleObjectExObjectequals.res = AccessibleObjectExObjectequals.res - 1;
+        }
+        return result1;
+    }
+}
+
+@AccessibleAnnotation1(name = "SampleClass", value = "Sample Class Annotation")
+class AccessibleClass1 {
+    private String sampleField;
+
+    @AccessibleAnnotation1(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface AccessibleAnnotation1 {
+    String name();
+
+    String value();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/AccessibleObjectExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/AccessibleObjectExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb1ca90fa14112cbf0d62394dd8544aa5e138cfb
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/AccessibleObjectExObjecthashCode.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectExObjecthashCode.java
+ * -@TestCaseName: Exception in reflect/AccessibleObject: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create Class SampleClass Field with sampleField0, sampleField1
+ * -#step2: Create Object1 Get the Field of the sampleField0 of SampleClass through the getDeclaredField method
+ * -#step3: Create Object2 Get the Field of sampleField0 of SampleClass by getDeclaredField method
+ * -#step4: Create Object3 Get the Field of sampleField1 of SampleClass by getDeclaredField method
+ * -#step5: Call hashCode to compare, object1 and object2 confirm that they are equal, object2 and object3 confirm that
+ *          they are not equal
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectExObjecthashCode.java
+ * -@ExecuteClass: AccessibleObjectExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new AccessibleObjectExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = accessibleObjectExObjecthashCode1();
+        } catch (Exception e) {
+            AccessibleObjectExObjecthashCode.res = AccessibleObjectExObjecthashCode.res - 20;
+        }
+
+        if (result == 4 && AccessibleObjectExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int accessibleObjectExObjecthashCode1() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        AccessibleObject sampleField0 = SampleClass.class.getDeclaredField("sampleField0");
+        AccessibleObject sampleField1 = SampleClass.class.getDeclaredField("sampleField0");
+        AccessibleObject sampleField2 = SampleClass.class.getDeclaredField("sampleField1");
+        int px0 = sampleField0.hashCode();
+        int px1 = sampleField1.hashCode();
+        int px2 = sampleField2.hashCode();
+        if (px0 == px1 && px0 != px2) {
+            AccessibleObjectExObjecthashCode.res = AccessibleObjectExObjecthashCode.res - 10;
+        }
+        return result1;
+    }
+}
+
+
+@CustomAnnotation(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass {
+    private String sampleField0;
+
+    private String sampleField1;
+
+    @CustomAnnotation(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+
+    /**
+     * get sampleField0
+     * @return sampleField0
+     */
+    public String getSampleField() {
+        return sampleField0;
+    }
+
+    /**
+     * set sampleField0
+     * @param sampleField just for test
+     */
+    public void setSampleField(String sampleField) {
+        this.sampleField0 = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotation {
+    String name();
+
+    String value();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..e29513118adc8fd220d5c5a663958d865a9118b0
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect/AccessibleObject: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: AccessibleObjectExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private static AccessibleObject sampleField1 = null;
+
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.class.getDeclaredField("res");
+        System.out.println(new AccessibleObjectExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = accessibleObjectExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new AccessibleObjectExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int accessibleObjectExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            sampleField1.notifyAll();
+            AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private class AccessibleObjectExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                try {
+                    sampleField1.notifyAll();
+                    AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/AccessibleObjectExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/AccessibleObjectExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..986a67216cee66f374003505f36bea90dcb5fc4a
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/AccessibleObjectExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect/AccessibleObject:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: AccessibleObjectExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private static AccessibleObject sampleField1 = null;
+
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = AccessibleObjectExObjectnotifyIllegalMonitorStateException.class.getDeclaredField("res");
+        System.out.println(new AccessibleObjectExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = acessibleObjectExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new AccessibleObjectExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && AccessibleObjectExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int acessibleObjectExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            sampleField1.notify();
+            AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private class AccessibleObjectExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                try {
+                    sampleField1.notify();
+                    AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/AccessibleObjectExObjecttoString.java b/test/testsuite/ouroboros/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/AccessibleObjectExObjecttoString.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f4159a7763a2e0b4339581d6a6b195465df1bdc
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/AccessibleObjectExObjecttoString.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectExObjecttoString.java
+ * -@TestCaseName: Exception in reflect/AccessibleObject:  String toString()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Call getDeclaredField to get the res of AccessibleObjectExObjecttoString as the new object of
+ *          AccessibleObject sampleField1
+ * -#step2: Call toString () on sampleField1
+ * -#step3: Confirm that toString () returns correctly
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectExObjecttoString.java
+ * -@ExecuteClass: AccessibleObjectExObjecttoString
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectExObjecttoString {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new AccessibleObjectExObjecttoString().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = accessibleObjectExObjecttoString1();
+        } catch (Exception e) {
+            AccessibleObjectExObjecttoString.res = AccessibleObjectExObjecttoString.res - 20;
+        }
+        if (result == 4 && AccessibleObjectExObjecttoString.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int accessibleObjectExObjecttoString1() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+//         String toString()
+        AccessibleObject sampleField1 = AccessibleObjectExObjecttoString.class.getDeclaredField("res");
+        String px1 = sampleField1.toString();
+//         System.out.println(px1);
+        if (px1.equals("static int AccessibleObjectExObjecttoString.res")) {
+            AccessibleObjectExObjecttoString.res = AccessibleObjectExObjecttoString.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/AccessibleObjectExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/AccessibleObjectExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..e01f7b3a120f0cb26abb1fe0af557a6fd6e3d01d
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/AccessibleObjectExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect/AccessibleObject: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: AccessibleObjectExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static AccessibleObject sampleField1 = null;
+
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = AccessibleObjectExObjectwaitIllegalMonitorStateException.class.getDeclaredField("res");
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = accessibleObjectExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = accessibleObjectExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = accessibleObjectExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && AccessibleObjectExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int accessibleObjectExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            sampleField1.wait();
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int accessibleObjectExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            sampleField1.wait(millis);
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private static int accessibleObjectExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            sampleField1.wait(millis, nanos);
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/ArrayExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/ArrayExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..7472d42c9d149352482011cd4c41a28a57c06830
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/ArrayExObjecthashCode.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ArrayExObjecthashCode.java
+ * -@TestCaseName: Exception in reflect/Array: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Call Array.newInstance to create Object
+ * -#step2: Create Object 2 from the direct assignment of Object 1
+ * -#step3: Call Array.newInstance to create Object 3
+ * -#step4: Call hashCode () to compare the hashcode values of three objects. Object 1 and object 2 are equal, and
+ *          object 1 and object 3 are not equal.
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ArrayExObjecthashCode.java
+ * -@ExecuteClass: ArrayExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Array;
+
+public class ArrayExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = arrayExObjecthashCode1();
+        } catch (Exception e) {
+            ArrayExObjecthashCode.res = ArrayExObjecthashCode.res - 20;
+        }
+        if (result == 4 && ArrayExObjecthashCode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int arrayExObjecthashCode1() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        Object ary0 = Array.newInstance(int.class, 10);
+        Object ary1 = ary0;
+        Object ary2 = Array.newInstance(int.class, 11);
+        int px0 = ary0.hashCode();
+        int px1 = ary1.hashCode();
+        int px2 = ary2.hashCode();
+
+        if (px0 == px1 && px0 != px2) {
+            ArrayExObjecthashCode.res = ArrayExObjecthashCode.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/ArrayExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/ArrayExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..063f955d254999513a5e206ca9766953b68134ca
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/ArrayExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ArrayExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect/Array: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ArrayExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ArrayExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Array;
+
+public class ArrayExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private static Object ary1 = Array.newInstance(int.class, 10);
+
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = arrayExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ArrayExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ArrayExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int arrayExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            ary1.notifyAll();
+            ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ArrayExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        private int remainder;
+
+        private ArrayExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (ary1) {
+                try {
+                    ary1.notifyAll();
+                    ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/ArrayExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/ArrayExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4294ad04d585456c7173d060efd5fcebcf05b7c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/ArrayExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ArrayExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect/Array:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ArrayExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ArrayExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Array;
+
+public class ArrayExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private static Object ary1 = Array.newInstance(int.class, 10);
+
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = arrayExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ArrayExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ArrayExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int arrayExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            ary1.notify();
+            ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ArrayExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ArrayExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (ary1) {
+                try {
+                    ary1.notify();
+                    ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/ArrayExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/ArrayExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ae3dcd59c1a8adc7533cf72f975224835ccd577
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/ArrayExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ArrayExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect/Array: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ArrayExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ArrayExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Array;
+
+public class ArrayExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static Object ary1 = Array.newInstance(int.class, 10);
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = arrayExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = arrayExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = arrayExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ArrayExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int arrayExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            ary1.wait();
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int arrayExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            ary1.wait(millis);
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int arrayExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            ary1.wait(millis, nanos);
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/ArrayExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/ArrayExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3b6692e9d2384bcab786d5b153af799c2fb929f
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/ArrayExObjectwaitInterruptedException.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ArrayExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in reflect/Array: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ArrayExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ArrayExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Array;
+
+public class ArrayExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Object ary1 = Array.newInstance(int.class, 10);
+
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjectwaitInterruptedException().run());
+    }
+
+    private class ArrayExObjectwaitInterruptedException11 implements Runnable {
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait();
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ArrayExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait(millis);
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ArrayExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait(millis, nanos);
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     * @param slpNum wait time
+     */
+    public void sleep(int slpNum) {
+        try {
+            Thread.sleep(slpNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ArrayExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ArrayExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ArrayExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && ArrayExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0012-rt-parent-ArrayExObjectwait/ArrayExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0012-rt-parent-ArrayExObjectwait/ArrayExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc8a42783aafed6651537b62d020425f3d29cefd
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0012-rt-parent-ArrayExObjectwait/ArrayExObjectwait.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ArrayExObjectwait.java
+ * -@TestCaseName: Exception in reflect/Array: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ArrayExObjectwait.java
+ * -@ExecuteClass: ArrayExObjectwait
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Array;
+
+public class ArrayExObjectwait {
+    static int res = 99;
+    private static Object ary1 = Array.newInstance(int.class, 10);
+
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjectwait().run());
+    }
+
+    private class ArrayExObjectwait11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait();
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ArrayExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait(millis);
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ArrayExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait(millis, nanos);
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ArrayExObjectwait11());
+        Thread t2 = new Thread(new ArrayExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ArrayExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ArrayExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        sleep(1000);
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.start();
+        sleep(1000);
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && ArrayExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/CharacterExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/CharacterExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc5f28ad949930e37da51f20e74ddbf96c0e0613
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/CharacterExObjectgetClass.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterExObjectgetClass.java
+ * -@TestCaseName: Exception in Character:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Construct object char1 by new Character (char name)
+ * -#step2: Call getClass () on char1
+ * -#step3: Confirm that the returned object is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterExObjectgetClass.java
+ * -@ExecuteClass: CharacterExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterExObjectgetClass {
+    static int res = 99;
+
+
+    public static void main(String argv[]) {
+        System.out.println(new CharacterExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterExObjectgetClass1();
+        } catch (Exception e) {
+            CharacterExObjectgetClass.res = CharacterExObjectgetClass.res - 20;
+        }
+        if (result == 4 && CharacterExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int characterExObjectgetClass1() {
+        //  final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        char name = 'A';
+        Character char1 = new Character(name);
+
+        Class px1 = char1.getClass();
+
+        if (px1.toString().equals("class java.lang.Character")) {
+            CharacterExObjectgetClass.res = CharacterExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/CharacterExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/CharacterExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a80944450c7446be9fd0088b12bb44081ee9ce5
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/CharacterExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Character:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: CharacterExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.Character;
+
+public class CharacterExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private char name = 'A';
+    private Character rp = name;
+
+    public static void main(String argv[]) {
+        System.out.println(new CharacterExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new CharacterExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && CharacterExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int characterExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notify();
+            CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class CharacterExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/CharacterExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/CharacterExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f919a8da59f52c6ca5190fdd5c185896d885046
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/CharacterExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Character: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: CharacterExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = characterExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = characterExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = characterExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && CharacterExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int characterExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        char name = 'A';
+        Character rp = new Character(name);
+        try {
+            rp.wait();
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int characterExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        char name = 'A';
+        long millis = 123;
+        Character rp = new Character(name);
+        try {
+            rp.wait(millis);
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private static int characterExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        char name = 'A';
+        long millis = 123;
+        int nanos = 10;
+        Character rp = new Character(name);
+        try {
+            rp.wait(millis, nanos);
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/CharacterExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/CharacterExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..13ea9ed19ea48dbd81f7da6ed2b1760d39187211
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/CharacterExObjectwaitInterruptedException.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in Character: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterExObjectwaitInterruptedException.java
+ * -@ExecuteClass: CharacterExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterExObjectwaitInterruptedException {
+    static int res = 99;
+    static char name = 'A';
+    static Character sampleField1 = new Character(name);
+
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        System.out.println(new CharacterExObjectwaitInterruptedException().run());
+    }
+
+    private class CharacterExObjectwaitInterruptedException11 implements Runnable {
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait();
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class CharacterExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis);
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class CharacterExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis, nanos);
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     * @param slpNum wait time
+     */
+    public void sleep(int slpNum) {
+        try {
+            Thread.sleep(slpNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new CharacterExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new CharacterExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new CharacterExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && CharacterExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0017-rt-parent-CharacterExObjectwait/CharacterExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0017-rt-parent-CharacterExObjectwait/CharacterExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..65814b55f802bbde95252ec62641a31ed39c5671
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0017-rt-parent-CharacterExObjectwait/CharacterExObjectwait.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterExObjectwait.java
+ * -@TestCaseName: Exception in Charactor: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterExObjectwait.java
+ * -@ExecuteClass: CharacterExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterExObjectwait {
+    static int res = 99;
+    private char name = 'A';
+    private String actions = null;
+    private Character rp = new Character(name);
+    private Character rp2 = new Character(name);
+    private Character rp3 = new Character(name);
+
+    public static void main(String argv[]) {
+        System.out.println(new CharacterExObjectwait().run());
+    }
+
+    private class CharacterExObjectwait11 implements Runnable {
+        // final void wait()
+
+        private int remainder;
+
+        private CharacterExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                rp.notifyAll();
+                try {
+                    rp.wait();
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class CharacterExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+
+        private int remainder;
+        long millis = 10;
+
+        private CharacterExObjectwait12(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp2) {
+                rp2.notifyAll();
+                try {
+                    rp2.wait(millis);
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class CharacterExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+
+        private CharacterExObjectwait13(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp3) {
+                rp3.notifyAll();
+                try {
+                    rp3.wait(millis, nanos);
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new CharacterExObjectwait11(1));
+        Thread t2 = new Thread(new CharacterExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new CharacterExObjectwait12(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new CharacterExObjectwait13(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && CharacterExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/CharacterSubsetExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/CharacterSubsetExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..1fc43e5c8384a5a595c2810ff1d851a9ec818dc5
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/CharacterSubsetExObjectgetClass.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterSubsetExObjectgetClass.java
+ * -@TestCaseName: Exception in Character/Subset:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Construct MySubset s by new MySubset (char name)
+ * -#step2: Call getClass() on s
+ * -#step3: Confirm that the returned object is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterSubsetExObjectgetClass.java
+ * -@ExecuteClass: CharacterSubsetExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterSubsetExObjectgetClass {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterSubsetExObjectgetClass1();
+        } catch (Exception e) {
+            CharacterSubsetExObjectgetClass.res = CharacterSubsetExObjectgetClass.res - 20;
+        }
+        if (result == 4 && CharacterSubsetExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int characterSubsetExObjectgetClass1() {
+//      final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        MySubset subset = new MySubset("some subset");
+        Class px1 = subset.getClass();
+        if (px1.toString().equals("class MySubset")) {
+            CharacterSubsetExObjectgetClass.res = CharacterSubsetExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+
+class MySubset extends Character.Subset {
+    MySubset(String name) {
+        super(name);
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f1bbf3daad6bb8fb42b8d2547dc0d01bcd9f85e
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Character/Subset: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: CharacterSubsetExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterSubsetExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    MySubset1 mf2 = new MySubset1("some subset");
+
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterSubsetExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new CharacterSubsetExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int characterSubsetExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            mf2.notifyAll();
+            CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class CharacterSubsetExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notifyAll();
+                    CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+class MySubset1 extends Character.Subset {
+    MySubset1(String name) {
+        super(name);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/CharacterSubsetExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/CharacterSubsetExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..794ec32affe9c8f18474ae1865e0cbb859e7f4ce
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/CharacterSubsetExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterSubsetExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Character/Subset:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterSubsetExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: CharacterSubsetExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterSubsetExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    MySubset2 mf2 = new MySubset2("some subset");
+
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterSubsetExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new CharacterSubsetExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && CharacterSubsetExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int characterSubsetExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        // final void notify()
+        try {
+            mf2.notify();
+            CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class CharacterSubsetExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notify();
+                    CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+class MySubset2 extends Character.Subset {
+    MySubset2(String name) {
+        super(name);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/CharacterSubsetExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/CharacterSubsetExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c07168b4860202bd504dd4331a3097bbd3ca5d04
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/CharacterSubsetExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterSubsetExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in Character/Subset: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterSubsetExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: CharacterSubsetExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterSubsetExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    MySubset4 csb1 = new MySubset4("some subset");
+
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class CharacterSubsetExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait(millis);
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class CharacterSubsetExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait(millis, nanos);
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     * @param sleepNum wait time
+     */
+    public void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new CharacterSubsetExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new CharacterSubsetExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && CharacterSubsetExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
+
+class MySubset4 extends Character.Subset {
+    MySubset4(String name) {
+        super(name);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/CharacterSubsetExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/CharacterSubsetExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..9aca51e75f5f0e23bccf18750ee36367034ccf5a
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/CharacterSubsetExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterSubsetExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Character/Subset: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterSubsetExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: CharacterSubsetExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterSubsetExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static MySubset5 csb1 = new MySubset5("some subset");
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = characterSubsetExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = characterSubsetExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = characterSubsetExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && CharacterSubsetExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("CharacterSubsetExObjectwaitIllegalMonitorStateException.res: " + CharacterSubsetExObjectwaitIllegalMonitorStateException.res);
+        return result;
+    }
+
+    private static int characterSubsetExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor
+        // final void wait()
+        try {
+            csb1.wait();
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private static int characterSubsetExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            csb1.wait(millis);
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int characterSubsetExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            csb1.wait(millis, nanos);
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+
+class MySubset5 extends Character.Subset {
+    MySubset5(String name) {
+        super(name);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/CharacterSubsetExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/CharacterSubsetExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..01a801b8cf0f38eb8674659399185600200a1851
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/CharacterSubsetExObjectwaitInterruptedException.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterSubsetExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in Character/Subset: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterSubsetExObjectwaitInterruptedException.java
+ * -@ExecuteClass: CharacterSubsetExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterSubsetExObjectwaitInterruptedException {
+    static int res = 99;
+    private static MySubset6 csb1 = new MySubset6("some subset");
+
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectwaitInterruptedException().run());
+    }
+
+    private class CharacterSubsetExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait();
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class CharacterSubsetExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait(millis);
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class CharacterSubsetExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait(millis, nanos);
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     * @param sleepNum wait time
+     */
+    public void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new CharacterSubsetExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new CharacterSubsetExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new CharacterSubsetExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && CharacterSubsetExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+
+class MySubset6 extends Character.Subset {
+    MySubset6(String name) {
+        super(name);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0024-rt-parent-ClassExObjectHashcode/ClassExObjectHashcode.java b/test/testsuite/ouroboros/parent_test/RT0024-rt-parent-ClassExObjectHashcode/ClassExObjectHashcode.java
new file mode 100644
index 0000000000000000000000000000000000000000..87922a18a778ac63a89f8b7d6b843d2e11343d7a
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0024-rt-parent-ClassExObjectHashcode/ClassExObjectHashcode.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassExObjectHashcode.java
+ * -@TestCaseName: Exception in Class: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create Class ClassExObjectHashcode
+ * -#step2: Create Object1 from ClassExObjectHashcode.class.getClass().
+ * -#step3: Call hashCode of Object1, check no exception is thrown.
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassExObjectHashcode.java
+ * -@ExecuteClass: ClassExObjectHashcode
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ClassExObjectHashcode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classExObjectHashcode();
+        } catch (Exception e) {
+            ClassExObjectHashcode.res = ClassExObjectHashcode.res - 10;
+        }
+        if (result == 4 && ClassExObjectHashcode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int classExObjectHashcode() {
+        // int hashCode()
+        int result1 = 4; /*STATUS_FAILED*/
+        Class<?> cal = ClassExObjectHashcode.class.getClass();
+        try {
+            int hashcode = cal.hashCode();
+            ClassExObjectHashcode.res = ClassExObjectHashcode.res - 10;
+        } catch (IllegalArgumentException e1) {
+            ClassExObjectHashcode.res = ClassExObjectHashcode.res - 1;
+        }
+        return result1;
+    }
+}
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/ClassExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/ClassExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..0cde571574b4e0432a1bdec42f5a4769b8cbd4e5
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/ClassExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Class: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ClassExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private Class<?>[] rp = ClassExObjectnotifyAllIllegalMonitorStateException.class.getClasses();
+
+    public static void main(String argv[]) {
+        System.out.println(new ClassExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ClassExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ClassExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int classExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ClassExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        private int remainder;
+
+        private ClassExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/ClassExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/ClassExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ed53840476e9063f5526c7f07ee6d14abbd5c7f
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/ClassExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Class: final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ClassExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private Class<?>[] rp = ClassExObjectnotifyIllegalMonitorStateException.class.getClasses();
+
+    public static void main(String argv[]) {
+        System.out.println(new ClassExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ClassExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ClassExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int classExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notifyAll();
+            ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ClassExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ClassExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/ClassExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/ClassExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..e71551cefc40ad569d87d6555c5650358a661db3
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/ClassExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in Class: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: ClassExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private Class<?>[] clazz = ClassExObjectwaitIllegalArgumentException.class.getClasses();
+
+    public static void main(String argv[]) {
+        System.out.println(new ClassExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class ClassExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (clazz) {
+                clazz.notifyAll();
+                try {
+                    clazz.wait(millis);
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ClassExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (clazz) {
+                clazz.notifyAll();
+                try {
+                    clazz.wait(millis, nanos);
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ClassExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/ClassExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/ClassExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..54d94b607a73d3e3570b13ba8766eca0afd4d013
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/ClassExObjectwaitInterruptedException.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: runtime/Class/ClassExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in Class: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ClassExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Class<?>[] sampleField1 = null;
+
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = ClassExObjectwaitInterruptedException.class.getClasses();
+        System.out.println(new ClassExObjectwaitInterruptedException().run());
+    }
+
+    private class ClassExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait();
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ClassExObjectwaitInterruptedException12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis);
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ClassExObjectwaitInterruptedException13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis, nanos);
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ClassExObjectwaitInterruptedException11());
+        Thread t2 = new Thread(new ClassExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassExObjectwaitInterruptedException12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassExObjectwaitInterruptedException13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && ClassExObjectwaitInterruptedException.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0029-rt-parent-ClassExObjectwait/ClassExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0029-rt-parent-ClassExObjectwait/ClassExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..26bde3a82d3f5c3e216599b72acaeee12ab13f0a
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0029-rt-parent-ClassExObjectwait/ClassExObjectwait.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: runtime/Class/ClassExObjectwait.java
+ * -@TestCaseName: Exception in Class: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassExObjectwait.java
+ * -@ExecuteClass: ClassExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassExObjectwait {
+    static int res = 99;
+    private Class<?>[] cal = ClassExObjectwait.class.getClasses();
+    private Class<?>[] cal2 = ClassExObjectwait.class.getClasses();
+    private Class<?>[] cal3 = ClassExObjectwait.class.getClasses();
+
+    public static void main(String argv[]) {
+        System.out.println(new ClassExObjectwait().run());
+    }
+
+    private class ClassExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private ClassExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal) {
+                cal.notifyAll();
+                try {
+                    cal.wait();
+                    ClassExObjectwait.res = ClassExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ClassExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+
+        private int remainder;
+        long millis = 10;
+
+        private ClassExObjectwait12(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal2) {
+                cal2.notifyAll();
+                try {
+                    cal2.wait(millis);
+                    ClassExObjectwait.res = ClassExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ClassExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+
+        private ClassExObjectwait13(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal3) {
+                cal3.notifyAll();
+                try {
+                    cal3.wait(millis, nanos);
+                    ClassExObjectwait.res = ClassExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ClassExObjectwait11(1));
+        Thread t2 = new Thread(new ClassExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassExObjectwait12(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassExObjectwait13(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && ClassExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/ClassLoaderExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/ClassLoaderExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..e05c1b1d8f43aa2f8010968000e6a09881dc1776
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/ClassLoaderExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassLoaderExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in ClassLoader: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassLoaderExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ClassLoaderExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassLoaderExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private ClassLoader rp = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.class.getClassLoader();
+
+    public static void main(String argv[]) {
+        System.out.println(new ClassLoaderExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/ClassLoaderExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/ClassLoaderExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..d417bfa20f20dc5216d34cae8341d8b24dc5170a
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/ClassLoaderExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassLoaderExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in ClassLoader: final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassLoaderExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ClassLoaderExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassLoaderExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private ClassLoader rp = ClassLoaderExObjectnotifyIllegalMonitorStateException.class.getClassLoader();
+
+    public static void main(String argv[]) {
+        System.out.println(new ClassLoaderExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classLoaderExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ClassLoaderExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ClassLoaderExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int classLoaderExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notify();
+            ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private class ClassLoaderExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/ClassLoaderExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/ClassLoaderExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff1ec996be8cd4285921b74dfba1c8d8d86393e7
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/ClassLoaderExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassLoaderExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in ClassLoader: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassLoaderExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: ClassLoaderExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassLoaderExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private ClassLoader cl = ClassLoaderExObjectwaitIllegalArgumentException.class.getClassLoader();
+
+    public static void main(String argv[]) {
+        System.out.println(new ClassLoaderExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class ClassLoaderExObjectwaitIllegalArgumentException21 implements Runnable {
+        //        IllegalArgumentException - if the value of timeout is negative.
+        //         final void wait(long millis)
+        long millis = -1;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cl) {
+                cl.notifyAll();
+                try {
+                    cl.wait(millis);
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ClassLoaderExObjectwaitIllegalArgumentException31 implements Runnable {
+        //        IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //         final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cl) {
+                cl.notifyAll();
+                try {
+                    cl.wait(millis, nanos);
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassLoaderExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassLoaderExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ClassLoaderExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/ClassLoaderExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/ClassLoaderExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..0da7134774a21ba0950ae4866076d7aaa20dda03
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/ClassLoaderExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassLoaderExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in ClassLoader: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassLoaderExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ClassLoaderExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassLoaderExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static ClassLoader cl = ClassLoaderExObjectwaitIllegalMonitorStateException.class.getClassLoader();
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = classLoaderExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = classLoaderExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = classLoaderExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ClassLoaderExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int classLoaderExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            cl.wait();
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private static int classLoaderExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            cl.wait(millis);
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private static int classLoaderExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            cl.wait(millis, nanos);
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/ClassLoaderExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/ClassLoaderExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..58ce45ca2635aa7a6640710e1b924bd1bdbd9a5c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/ClassLoaderExObjectwaitInterruptedException.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassLoaderExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in ClassLoader: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassLoaderExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ClassLoaderExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassLoaderExObjectwaitInterruptedException {
+    static int res = 99;
+    private static ClassLoader sampleField1 = ClassLoaderExObjectwaitInterruptedException.class.getClassLoader();
+
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        System.out.println(new ClassLoaderExObjectwaitInterruptedException().run());
+    }
+
+    private class ClassLoaderExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait();
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ClassLoaderExObjectwaitInterruptedException12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis);
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ClassLoaderExObjectwaitInterruptedException13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis, nanos);
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ClassLoaderExObjectwaitInterruptedException11());
+        Thread t2 = new Thread(new ClassLoaderExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassLoaderExObjectwaitInterruptedException12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassLoaderExObjectwaitInterruptedException13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && ClassLoaderExObjectwaitInterruptedException.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/ClassLoaderExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/ClassLoaderExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..c6ca1746e7a9d2c6b5e34c85498e9f866c4fc232
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/ClassLoaderExObjectwait.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassLoaderExObjectwait.java
+ * -@TestCaseName: Exception in ClassLoader: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ClassLoaderExObjectwait.java
+ * -@ExecuteClass: ClassLoaderExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ClassLoaderExObjectwait {
+    static int res = 99;
+    private ClassLoader cal = ClassLoaderExObjectwait.class.getClassLoader();
+    private ClassLoader cal2 = ClassLoaderExObjectwait.class.getClassLoader();
+    private ClassLoader cal3 = ClassLoaderExObjectwait.class.getClassLoader();
+
+    public static void main(String argv[]) {
+        System.out.println(new ClassLoaderExObjectwait().run());
+    }
+
+    private class ClassLoaderExObjectwait11 implements Runnable {
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal) {
+                cal.notifyAll();
+                try {
+                    cal.wait();
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ClassLoaderExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal2) {
+                cal2.notifyAll();
+                try {
+                    cal2.wait(millis);
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ClassLoaderExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal3) {
+                cal3.notifyAll();
+                try {
+                    cal3.wait(millis, nanos);
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ClassLoaderExObjectwait11());
+        Thread t2 = new Thread(new ClassLoaderExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassLoaderExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassLoaderExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && ClassLoaderExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/ConstructorExAccessibleObjectisAccessible.java b/test/testsuite/ouroboros/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/ConstructorExAccessibleObjectisAccessible.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef421627f2d40788e0c9d45cb9acc3817a1cb5ba
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/ConstructorExAccessibleObjectisAccessible.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExAccessibleObjectisAccessible.java
+ * -@TestCaseName: Exception in reflect /Constructor:   boolean isAccessible()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class SampleClass6, which has a single String parameter constructor, and annotate the class with
+ *          CustomAnnotations
+ * -#step2: Call the run of the use case, and execute method1. In the method, get the constructor by calling getConstructor
+ * -#step3: Call isAccessible() on object 1 to confirm that the returned is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExAccessibleObjectisAccessible.java
+ * -@ExecuteClass: ConstructorExAccessibleObjectisAccessible
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+
+public class ConstructorExAccessibleObjectisAccessible {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExAccessibleObjectisAccessibleTest();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExAccessibleObjectisAccessible.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int constructorExAccessibleObjectisAccessibleTest() {
+        int result = 4;
+        try {
+            // boolean isAccessible()
+            AccessibleObject sampleconstructor = SampleClass6.class.getConstructor(String.class);
+            boolean value = sampleconstructor.isAccessible();
+            // System.out.println(a);
+            if (!value) {
+                ConstructorExAccessibleObjectisAccessible.res = ConstructorExAccessibleObjectisAccessible.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException | NullPointerException e) {
+            String eMsg = e.toString();
+        }
+        return result;
+    }
+}
+
+@CustomAnnotations6(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass6 {
+    private String sampleField;
+
+    @CustomAnnotations6(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass6(String str) {
+        this.sampleField = str;
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations6 {
+    String name();
+
+    String value();
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/ConstructorExAccessibleObjectsetAccessibleSecurityException.java b/test/testsuite/ouroboros/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/ConstructorExAccessibleObjectsetAccessibleSecurityException.java
new file mode 100644
index 0000000000000000000000000000000000000000..33a16e6e31d140ba85dbef47a219ac674e626e90
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/ConstructorExAccessibleObjectsetAccessibleSecurityException.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExAccessibleObjectsetAccessibleSecurityException.java
+ * -@TestCaseName: Exception in reflect /Constructor:  void setAccessible(boolean flag)/ static void setAccessible(AccessibleObject[] array, boolean flag)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class SampleClass8, which has a single String parameter constructor, and annotate the class
+ * -#step2: Call the run of the use case, and execute method1. In the method, get the constructor by calling getConstructor
+ * -#step3: Call setAccessible(boolean flag) on object 1 to confirm isAccessible() that the returned is correct
+ * -#step4: Call the run of the use case, and execute method2. In the method, get the constructor by calling getConstructors
+ * -#step5: Call setAccessible(boolean flag) on object2[0], confirm to isAccessible() that the returned is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExAccessibleObjectsetAccessibleSecurityException.java
+ * -@ExecuteClass: ConstructorExAccessibleObjectsetAccessibleSecurityException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+
+public class ConstructorExAccessibleObjectsetAccessibleSecurityException {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    static int run() {
+        int result = 2;
+        result = constructorExAccessibleObjectsetAccessibleSecurityExceptionTest();
+        constructorExAccessibleObjectsetAccessibleSecurityExceptionTest2();
+        if (result == 4 && ConstructorExAccessibleObjectsetAccessibleSecurityException.res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int constructorExAccessibleObjectsetAccessibleSecurityExceptionTest() {
+        int result1 = 4;
+
+        try {
+            // void setAccessible(boolean flag)
+            AccessibleObject sampleconstructor = SampleClass8.class.getConstructor(String.class);
+            sampleconstructor.setAccessible(true);
+            boolean value = sampleconstructor.isAccessible();
+            if (value) {
+                // System.out.println(b);
+                ConstructorExAccessibleObjectsetAccessibleSecurityException.res = ConstructorExAccessibleObjectsetAccessibleSecurityException.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            String eMsg = e.toString();
+        }
+        return result1;
+    }
+
+
+    private static void constructorExAccessibleObjectsetAccessibleSecurityExceptionTest2() {
+        try {
+            // static void setAccessible(AccessibleObject[] array, boolean flag)
+            AccessibleObject[] sampleconstructorlist = SampleClass8.class.getConstructors();
+            AccessibleObject.setAccessible(sampleconstructorlist, true);
+            boolean value = sampleconstructorlist[0].isAccessible();
+            if (value) {
+                ConstructorExAccessibleObjectsetAccessibleSecurityException.res = ConstructorExAccessibleObjectsetAccessibleSecurityException.res - 2;
+            }
+        } catch (SecurityException e) {
+            String eMsg = e.toString();
+        }
+    }
+}
+
+@CustomAnnotations8(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass8 {
+    private String sampleField;
+
+    @CustomAnnotations8(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass8(String str) {
+
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations8 {
+    String name();
+
+    String value();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/ConstructorExExecutablegetExceptionTypes.java b/test/testsuite/ouroboros/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/ConstructorExExecutablegetExceptionTypes.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe9ee302c980d3eb4309ce49f7f1c474ec8311c1
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/ConstructorExExecutablegetExceptionTypes.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExExecutablegetExceptionTypes.java
+ * -@TestCaseName: abstract Class[]<?> getExceptionTypes()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class SampleClass12, which has a single String parameter constructor, and annotate the class with
+ *          CustomAnnotations12
+ * -#step2: Call the run of the use case, and execute method 1. In the method, get the constructor by calling
+ *          getConstructor as object1
+ * -#step3: Call getExceptionTypes() on object1 to confirm that the returned are correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExExecutablegetExceptionTypes.java
+ * -@ExecuteClass: ConstructorExExecutablegetExceptionTypes
+ * -@ExecuteArgs:
+ */
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Executable;
+
+public class ConstructorExExecutablegetExceptionTypes {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExExecutablegetExceptionTypes1();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExExecutablegetExceptionTypes.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int constructorExExecutablegetExceptionTypes1() {
+        int result1 = 4;
+        try {
+            // abstract Class[]<?> getExceptionTypes()
+            Executable sampleExecutable = SampleClass12.class.getConstructor(String.class);
+            Class<?>[] vlClass = sampleExecutable.getExceptionTypes();
+            if (vlClass.length == 0 && vlClass.getClass().toString().equals("class [Ljava.lang.Class;")) {
+                ConstructorExExecutablegetExceptionTypes.res = ConstructorExExecutablegetExceptionTypes.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException e1) {
+            String eMsg = e1.toString();
+        }
+        return result1;
+    }
+}
+
+@CustomAnnotations12(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass12 {
+    private String sampleField;
+
+    @CustomAnnotations12(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass12(String str) {
+        this.sampleField = str;
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations12 {
+    String name();
+
+    String value();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/ConstructorExExecutablegetGenericParameterTypes.java b/test/testsuite/ouroboros/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/ConstructorExExecutablegetGenericParameterTypes.java
new file mode 100644
index 0000000000000000000000000000000000000000..e0de5b77c9d0f5390c12f046d02ef2dfbf24db59
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/ConstructorExExecutablegetGenericParameterTypes.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExExecutablegetGenericParameterTypes.java
+ * -@TestCaseName:  Type[] getGenericParameterTypes()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class SampleClass13, which has a single String parameter constructor, and annotate the class with
+ *          CustomAnnotations13
+ * -#step2: Call the run of the use case, and execute method 1. In the method, get the constructor by calling
+ *          getConstructor as object1
+ * -#step3: Call getParameterTypes() on object1 to confirm that the returned are correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExExecutablegetGenericParameterTypes.java
+ * -@ExecuteClass: ConstructorExExecutablegetGenericParameterTypes
+ * -@ExecuteArgs:
+ */
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Executable;
+
+public class ConstructorExExecutablegetGenericParameterTypes {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExExecutablegetGenericParameterTypes1();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExExecutablegetGenericParameterTypes.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int constructorExExecutablegetGenericParameterTypes1() {
+        int result1 = 4;
+        try {
+            // Type[] getGenericParameterTypes()
+            Executable sampleExecutable = SampleClass13.class.getConstructor(String.class);
+            Class<?>[] classes = sampleExecutable.getParameterTypes();
+            if (classes.length == 1 && classes.getClass().toString().equals("class [Ljava.lang.Class;")) {
+                ConstructorExExecutablegetGenericParameterTypes.res = ConstructorExExecutablegetGenericParameterTypes.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException e1) {
+            String eMsg = e1.toString();
+        }
+        return result1;
+    }
+}
+
+@CustomAnnotations13(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass13 {
+    private String sampleField;
+
+    @CustomAnnotations13(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass13(String str) {
+
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations13 {
+    String name();
+
+    String value();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/ConstructorExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/ConstructorExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..b46e70523777103a504fda4ea650ce1b4bdc0583
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/ConstructorExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect /Constructor: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ConstructorExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+
+
+public class ConstructorExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+
+    public static void main(String argv[]) throws NoSuchMethodException, SecurityException {
+        con = SampleClass14.class.getConstructor(String.class);
+        System.out.println(new ConstructorExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2;
+        try {
+            result = constructorExObjectnotifyAllIllegalMonitorStateExceptionTest1();
+        } catch (Exception e) {
+            ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ConstructorExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExObjectnotifyAllIllegalMonitorStateException.res == 57) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int constructorExObjectnotifyAllIllegalMonitorStateExceptionTest1() {
+        int result1 = 4;
+        try {
+            con.notifyAll();
+            ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 50;
+
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 2;
+        }
+        return result1;
+    }
+
+
+    private class ConstructorExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        private int remainder;
+
+        // final void notifyAll()
+        private ConstructorExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con) {
+                try {
+                    con.notifyAll();
+                    ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+
+}
+
+@CustomAnnotations14(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass14 {
+    private String sampleField;
+
+    @CustomAnnotations14(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass14(String str) {
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations14 {
+    String name();
+
+    String value();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/ConstructorExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/ConstructorExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..6853d3fc4b0e92c24c617126c80de52c19e3ce6f
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/ConstructorExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect /Constructor: final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ConstructorExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+
+public class ConstructorExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+
+    public static void main(String argv[]) throws NoSuchMethodException, SecurityException {
+        con = SampleClass15.class.getConstructor(String.class);
+        System.out.println(new ConstructorExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2;
+        try {
+            result = constructorExObjectnotifyIllegalMonitorStateExceptionTest1();
+        } catch (Exception e) {
+            ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ConstructorExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExObjectnotifyIllegalMonitorStateException.res == 57) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int constructorExObjectnotifyIllegalMonitorStateExceptionTest1() {
+        int result1 = 4;
+        try {
+            con.notify();
+            ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 50;
+
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 2;
+        }
+        return result1;
+    }
+
+    private class ConstructorExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        private int remainder;
+
+        // final void notify()
+        private ConstructorExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+    /**
+     * Thread run fun
+     */
+        public void run() {
+            synchronized (con) {
+                try {
+                    con.notify();
+                    ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+
+}
+
+@CustomAnnotations15(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass15 {
+    private String sampleField;
+
+    @CustomAnnotations15(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass15(String s) {
+
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations15 {
+    String name();
+
+    String value();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/ConstructorExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/ConstructorExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8004eb71a03966e85f0cb2bbc4cfc3106cbc0ba
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/ConstructorExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName:  final void wait(long millis, int nanos)/ final void wait(long millis)/ final void wait()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: ConstructorExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+
+public class ConstructorExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+
+    public static void main(String argv[]) throws SecurityException, NoSuchMethodException {
+        con = SampleClass16.class.getConstructor(String.class);
+        System.out.println(new ConstructorExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class ConstructorExObjectwaitIllegalArgumentException11 implements Runnable {
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait();
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ConstructorExObjectwaitIllegalArgumentException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait(millis);
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ConstructorExObjectwaitIllegalArgumentException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait(millis, nanos);
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ConstructorExObjectwaitIllegalArgumentException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ConstructorExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ConstructorExObjectwaitIllegalArgumentException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+
+        if (result == 2 && ConstructorExObjectwaitIllegalArgumentException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+
+@CustomAnnotations16(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass16 {
+    private String sampleField;
+
+    @CustomAnnotations16(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass16(String str) {
+
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations16 {
+    String name();
+
+    String value();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/ConstructorExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/ConstructorExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..bac19c20e96e4a13d66e749fc943ea202b771acf
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/ConstructorExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: final void wait(long millis, int nanos)/ final void wait(long millis)/ final void wait()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ConstructorExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+
+public class ConstructorExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+
+    public static void main(String argv[]) throws SecurityException, NoSuchMethodException {
+        con = SampleClass17.class.getConstructor(String.class);
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = constructorExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = constructorExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = constructorExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && ConstructorExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int constructorExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            con.wait();
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int constructorExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            con.wait(millis);
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int constructorExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            con.wait(millis, nanos);
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+}
+
+@CustomAnnotations17(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass17 {
+    private String sampleField;
+
+    @CustomAnnotations17(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass17(String str) {
+
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations17 {
+    String name();
+
+    String value();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/ConstructorExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/ConstructorExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..328b63611158d66e28bfd30b3a6dcce6275dd926
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/ConstructorExObjectwaitInterruptedException.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName:  final void wait(long millis, int nanos)/ final void wait(long millis)/ final void wait()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ConstructorExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+
+public class ConstructorExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+
+    public static void main(String argv[]) throws NoSuchMethodException, SecurityException {
+        con = SampleClass18.class.getConstructor(String.class);
+        System.out.println(new ConstructorExObjectwaitInterruptedException().run());
+    }
+
+    private class ConstructorExObjectwaitInterruptedException11 implements Runnable {
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait();
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ConstructorExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait(millis);
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ConstructorExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait(millis, nanos);
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ConstructorExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ConstructorExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ConstructorExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+
+        if (result == 2 && ConstructorExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+
+@CustomAnnotations18(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass18 {
+    private String sampleField;
+
+    @CustomAnnotations18(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass18(String str) {
+
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations18 {
+    String name();
+
+    String value();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0055-rt-parent-ConstructorExObjectwait/ConstructorExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0055-rt-parent-ConstructorExObjectwait/ConstructorExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..64433165d9680422dd98e6f7392c6375c396cb99
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0055-rt-parent-ConstructorExObjectwait/ConstructorExObjectwait.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorExObjectwait.java
+ * -@TestCaseName: Exception in reflect Method: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ConstructorExObjectwait.java
+ * -@ExecuteClass: ConstructorExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+public class ConstructorExObjectwait {
+    static int res = 99;
+    private Constructor<?>[] con1 = ConstructorExObjectwait.class.getConstructors();
+    private Constructor<?>[] con2 = ConstructorExObjectwait.class.getConstructors();
+    private Constructor<?>[] con3 = ConstructorExObjectwait.class.getConstructors();
+
+    public static void main(String argv[]) {
+        System.out.println(new ConstructorExObjectwait().run());
+    }
+
+    private class ConstructorExObjectwait11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con1) {
+                con1.notifyAll();
+                try {
+                    con1.wait();
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ConstructorExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con2) {
+                con2.notifyAll();
+                try {
+                    con2.wait(millis);
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private class ConstructorExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (con3) {
+                con3.notifyAll();
+                try {
+                    con3.wait(millis, nanos);
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ConstructorExObjectwait11());
+        Thread t2 = new Thread(new ConstructorExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ConstructorExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ConstructorExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+            t2.interrupt();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && ConstructorExObjectwait.res == 69) {
+            result = 0;
+        }
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/FieldExAccessibleObjectisAccessible.java b/test/testsuite/ouroboros/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/FieldExAccessibleObjectisAccessible.java
new file mode 100644
index 0000000000000000000000000000000000000000..c64c0bc51eeadfb6b433f464d9aa83995ca9d4cc
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/FieldExAccessibleObjectisAccessible.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldExAccessibleObjectisAccessible.java
+ * -@TestCaseName: Exception in reflect/Field:    boolean isAccessible()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class SampleClassField_h2, which has a field id, and annotate the class with CustomAnnotations_h2
+ * -#step2: Call the run of the use case, and execute method 1. In the method, get the filed "id" by calling
+ *          getDeclaredField as Object1
+ * -#step3: Call isAccessible() on object 1 to confirm that the returned are correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldExAccessibleObjectisAccessible.java
+ * -@ExecuteClass: FieldExAccessibleObjectisAccessible
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+
+public class FieldExAccessibleObjectisAccessible {
+    static int res = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(new FieldExAccessibleObjectisAccessible().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectisAccessible1();
+        } catch (Exception e) {
+            FieldExAccessibleObjectisAccessible.res = FieldExAccessibleObjectisAccessible.res - 20;
+        }
+
+        if (result == 4 && FieldExAccessibleObjectisAccessible.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int fieldExAccessibleObjectisAccessible1() throws NoSuchFieldException {
+        //  boolean isAccessible()
+        int result1 = 4;
+        Field f1 = SampleClassFieldH2.class.getDeclaredField("id");
+        try {
+            if (!f1.isAccessible()) {
+                FieldExAccessibleObjectisAccessible.res = FieldExAccessibleObjectisAccessible.res - 10;
+            } else {
+                FieldExAccessibleObjectisAccessible.res = FieldExAccessibleObjectisAccessible.res - 15;
+            }
+        } catch (Exception e) {
+            FieldExAccessibleObjectisAccessible.res = FieldExAccessibleObjectisAccessible.res - 15;
+        }
+
+        return result1;
+    }
+}
+
+class SampleClassFieldH2 {
+    @CustomAnnotationsH2(name = "id")
+    String id;
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface CustomAnnotationsH2 {
+    String name();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/FieldExAccessibleObjectsetAccessibleSecurityException.java b/test/testsuite/ouroboros/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/FieldExAccessibleObjectsetAccessibleSecurityException.java
new file mode 100644
index 0000000000000000000000000000000000000000..a16beb9b7d4f2a091bcf540a7f788126147ce420
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/FieldExAccessibleObjectsetAccessibleSecurityException.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldExAccessibleObjectsetAccessibleSecurityException.java
+ * -@TestCaseName: Exception in reflect/Field:      void setAccessible(boolean flag)  \  static void setAccessible(AccessibleObject[] array, boolean flag)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class SampleClassField_h4, which has a field id, and annotate the class with CustomAnnotations_h4
+ * -#step2: Call the run of the use case, and execute method 1. In the method, get the filed "id" by calling
+ *          getDeclaredField as Object1
+ * -#step3: Call setAccessible(boolean flag) on object 1, flag test true and false, confirm set success
+ * -#step4: Call the run of the use case, and execute method 1. In the method, get the filed "id" by calling
+ *          getDeclaredField as Object2
+ * -#step5: Call setAccessible(AccessibleObject[] array, boolean flag) on object 2, flag test true and false, confirm
+ *          set success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldExAccessibleObjectsetAccessibleSecurityException.java
+ * -@ExecuteClass: FieldExAccessibleObjectsetAccessibleSecurityException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
+public class FieldExAccessibleObjectsetAccessibleSecurityException {
+    static int res = 99;
+
+    public static void main(String[] args) {
+        System.out.println(new FieldExAccessibleObjectsetAccessibleSecurityException().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectsetAccessibleSecurityException1();
+        } catch (Exception e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 20;
+        }
+
+        try {
+            result = fieldExAccessibleObjectsetAccessibleSecurityException2();
+        } catch (Exception e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 20;
+        }
+
+        if (result == 4 && FieldExAccessibleObjectsetAccessibleSecurityException.res == 59) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int fieldExAccessibleObjectsetAccessibleSecurityException1() throws NoSuchFieldException {
+        //  void setAccessible(boolean flag)
+        int result1 = 4;
+        Field f1 = SampleClassFieldH4.class.getDeclaredField("id");
+        try {
+            f1.setAccessible(false);
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 10;
+        } catch (SecurityException e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 15;
+        }
+
+        try {
+            f1.setAccessible(true);
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 10;
+        } catch (SecurityException e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 15;
+        }
+
+        return result1;
+    }
+
+    private int fieldExAccessibleObjectsetAccessibleSecurityException2() throws NoSuchFieldException {
+        //  static void setAccessible(AccessibleObject[] array, boolean flag)
+        int result2 = 4;
+        Constructor[] test = AccessibleObject.class.getDeclaredConstructors();
+        try {
+            AccessibleObject.setAccessible(test, false);
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 10;
+        } catch (SecurityException e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 15;
+        }
+
+        try {
+            AccessibleObject.setAccessible(test, true);
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 10;
+        } catch (SecurityException e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 15;
+        }
+        return result2;
+    }
+}
+
+class SampleClassFieldH4 {
+    @CustomAnnotationsH4(name = "id")
+    String id;
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface CustomAnnotationsH4 {
+    String name();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0064-rt-parent-FieldExObjectgetClass/FieldExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0064-rt-parent-FieldExObjectgetClass/FieldExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..be972aabd94b8126b4ef8960aeed81380b8125c3
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0064-rt-parent-FieldExObjectgetClass/FieldExObjectgetClass.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID:FieldExObjectgetClass.java
+ * -@TestCaseName: Exception in reflect/Field:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create class FieldExObjectgetClass, call getDeclaredFields() of class of FieldExObjectgetClass as object1
+ * -#step2: Call getClass() on object1[0]
+ * -#step3: Confirm that the returned Class is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldExObjectgetClass.java
+ * -@ExecuteClass: FieldExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Field;
+
+public class FieldExObjectgetClass {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExObjectgetClass1();
+        } catch (Exception e) {
+            FieldExObjectgetClass.res = FieldExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && FieldExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int fieldExObjectgetClass1() {
+        //  final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        Field[] f1 = FieldExObjectgetClass.class.getDeclaredFields();
+
+        Class px1 = f1[0].getClass();
+
+        if (px1.toString().equals("class java.lang.reflect.Field")) {
+            FieldExObjectgetClass.res = FieldExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/FieldExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/FieldExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..711cd116f110ec99c6d68c034397b439d6145b13
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/FieldExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Field: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: FieldExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Field;
+
+public class FieldExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private Field[] rp = FieldExObjectnotifyAllIllegalMonitorStateException.class.getDeclaredFields();
+
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && FieldExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/FieldExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/FieldExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..14f3d2497730af8d724c7909d2ba2d852a305246
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/FieldExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Field: final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: FieldExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Field;
+
+public class FieldExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private Field[] rp = FieldExObjectnotifyIllegalMonitorStateException.class.getDeclaredFields();
+
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && FieldExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notify();
+            FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/FieldExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/FieldExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa4f3196b5911c3eff8908e9397d5bf1e2c83080
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/FieldExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in reflect/Field: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: FieldExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class FieldExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private Field[] fields = FieldExObjectwaitIllegalArgumentException.class.getDeclaredFields();
+
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class FieldExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait(millis);
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class FieldExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+
+        long millis = -2;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait(millis, nanos);
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new FieldExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new FieldExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && FieldExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/FieldExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/FieldExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..1154ea97af3ea6df6963621db47909e51f8778ba
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/FieldExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect/Field: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: FieldExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class FieldExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Field[] fields = FieldExObjectwaitIllegalMonitorStateException.class.getDeclaredFields();
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = fieldExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = fieldExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = fieldExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && FieldExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int fieldExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            fields[0].wait();
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int fieldExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            fields[0].wait(millis);
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private static int fieldExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            fields[0].wait(millis, nanos);
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/FieldExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/FieldExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b54dae222ae67940c9cda80ba255c52ebc1fa83
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/FieldExObjectwaitInterruptedException.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in reflect/Field: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldExObjectwaitInterruptedException.java
+ * -@ExecuteClass: FieldExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Field;
+
+public class FieldExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Field[] fields = FieldExObjectwaitInterruptedException.class.getDeclaredFields();
+
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        System.out.println(new FieldExObjectwaitInterruptedException().run());
+    }
+
+    private class FieldExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait();
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    private class FieldExObjectwaitInterruptedException12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait(millis);
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    private class FieldExObjectwaitInterruptedException13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait(millis, nanos);
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new FieldExObjectwaitInterruptedException11());
+        Thread t2 = new Thread(new FieldExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new FieldExObjectwaitInterruptedException12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new FieldExObjectwaitInterruptedException13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && FieldExObjectwaitInterruptedException.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0070-rt-parent-FieldExObjectwait/FieldExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0070-rt-parent-FieldExObjectwait/FieldExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..4add3adaf79299f681700ff5753f0e92413b1ee5
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0070-rt-parent-FieldExObjectwait/FieldExObjectwait.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Field/FieldExObjectwait.java
+ * -@TestCaseName: Exception in reflect Field: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: FieldExObjectwait.java
+ * -@ExecuteClass: FieldExObjectwait
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Field;
+
+public class FieldExObjectwait {
+    static int res = 99;
+    private Field[] cal = FieldExObjectwait.class.getDeclaredFields();
+    private Field[] cal2 = FieldExObjectwait.class.getDeclaredFields();
+    private Field[] cal3 = FieldExObjectwait.class.getDeclaredFields();
+
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectwait().run());
+    }
+
+    private class FieldExObjectwait11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal) {
+                cal.notifyAll();
+                try {
+                    cal.wait();
+                    FieldExObjectwait.res = FieldExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class FieldExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal2) {
+                cal2.notifyAll();
+                try {
+                    cal2.wait(millis);
+                    FieldExObjectwait.res = FieldExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private class FieldExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal3) {
+                cal3.notifyAll();
+                try {
+                    cal3.wait(millis, nanos);
+                    FieldExObjectwait.res = FieldExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new FieldExObjectwait11());
+        Thread t2 = new Thread(new FieldExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new FieldExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new FieldExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && FieldExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/MethodExAccessibleObjectisAccessible.java b/test/testsuite/ouroboros/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/MethodExAccessibleObjectisAccessible.java
new file mode 100644
index 0000000000000000000000000000000000000000..90e1069f537c8c3813f1119e010fc5b7d515fc76
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/MethodExAccessibleObjectisAccessible.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExAccessibleObjectisAccessible.java
+ * -@TestCaseName: Exception in reflect Method:public   boolean isAccessible()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class MethodClass11, which has sampleMethod method, and annotate the method
+ * -#step2: Call the run of the use case, and execute method 1. In the method, get the method of MethodClass11 by
+ *          calling getMethod as Object 1
+ * -#step3: Call isAccessible() on object 1 to confirm that the returned are correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExAccessibleObjectisAccessible.java
+ * -@ExecuteClass: MethodExAccessibleObjectisAccessible
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+
+public class MethodExAccessibleObjectisAccessible {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = methodExAccessibleObjectisAccessible1();
+        } catch (Exception e) {
+            MethodExAccessibleObjectisAccessible.res = MethodExAccessibleObjectisAccessible.res - 10;
+        }
+
+
+        if (result == 4 && MethodExAccessibleObjectisAccessible.res == 98) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int methodExAccessibleObjectisAccessible1() throws NoSuchMethodException, SecurityException, NoSuchFieldException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // boolean isAccessible()
+        Method sampleMethod = MethodClass11.class.getMethod("sampleMethod");
+
+        if (sampleMethod.isAccessible()) {
+            MethodExAccessibleObjectisAccessible.res = MethodExAccessibleObjectisAccessible.res - 10;
+        } else {
+            MethodExAccessibleObjectisAccessible.res = MethodExAccessibleObjectisAccessible.res - 1;
+        }
+
+        return result1;
+    }
+
+}
+
+@CustomAnnotationn(name = "SampleClass", value = "Sample Class Annotation")
+class MethodClass11 {
+    private String sampleField;
+
+    @CustomAnnotationn(name = "sampleMethod", value = "Sample Class Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@interface CustomAnnotationn {
+    String name();
+
+    String value();
+}
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/MethodExAccessibleObjectisAnnotationPresentNullPointerException.java b/test/testsuite/ouroboros/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/MethodExAccessibleObjectisAnnotationPresentNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7c3d5a07cf4a29923384bfcfc4faa80267fb46c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/MethodExAccessibleObjectisAnnotationPresentNullPointerException.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExAccessibleObjectisAnnotationPresentNullPointerException.java
+ * -@TestCaseName: Exception in reflect Method:public  boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class MethodClass8, which has sampleMethod method, and annotate the method
+ * -#step2: Call the run of the use case, and execute method 1. In the method, get the method of MethodClass8 by
+ *          calling getMethod as Object 1
+ * -#step3: Call isAnnotationPresent(Class<? extends Annotation> annotationClass) on object 1 to confirm that the returned are correct
+ * -#step4: execute method 2. In the method, get the method of SampleClass_h6 by calling getMethod as Object 2
+ * -#step5: Call isAnnotationPresent(null) on object 2 with null parameter, confirm to throw NullPointerException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExAccessibleObjectisAnnotationPresentNullPointerException.java
+ * -@ExecuteClass: MethodExAccessibleObjectisAnnotationPresentNullPointerException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+
+public class MethodExAccessibleObjectisAnnotationPresentNullPointerException {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = methodExAccessibleObjectisAnnotationPresentNullPointerException1();
+        } catch (Exception e) {
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 20;
+        }
+
+        try {
+            result = methodExAccessibleObjectisAnnotationPresentNullPointerException2();
+        } catch (Exception e) {
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 20;
+        }
+
+
+        if (result == 4 && MethodExAccessibleObjectisAnnotationPresentNullPointerException.res == 68) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int methodExAccessibleObjectisAnnotationPresentNullPointerException1() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - If the specified object is empty.
+        Method sampleMethod = MethodClass8.class.getMethod("sampleMethod");
+        try {
+            sampleMethod.isAnnotationPresent(null);
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 10;
+        } catch (NullPointerException e1) {
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 1;
+        }
+        return result1;
+    }
+
+    private static int methodExAccessibleObjectisAnnotationPresentNullPointerException2() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - If the specified object is empty.
+        // boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
+        Method sampleMethod = MethodClass8.class.getMethod("sampleMethod");
+        try {
+            sampleMethod.isAnnotationPresent(CustomAnnotationH100.class);
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 30;
+        } catch (NullPointerException e1) {
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 5;
+        }
+        return result1;
+    }
+
+}
+
+@CustomAnnotationH100(name = "SampleClass", value = "Sample Class Annotation")
+class MethodClass8 {
+    private String sampleField;
+
+    @CustomAnnotationH100(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotationH100 {
+    String name();
+
+    String value();
+}
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/MethodExAccessibleObjectSetAccessible.java b/test/testsuite/ouroboros/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/MethodExAccessibleObjectSetAccessible.java
new file mode 100644
index 0000000000000000000000000000000000000000..aff8d9427e1a16e2a3aa8e2367e11d3130e95553
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/MethodExAccessibleObjectSetAccessible.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExAccessibleObjectSetAccessible.java
+ * -@TestCaseName: Exception in reflect Method:   static void setAccessible(AccessibleObject[] array, boolean flag)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class MethodClass14, which has sampleMethod method, and annotate the method
+ * -#step2: Call the run of the use case, and execute method 1. In the method, get the method of MethodClass14 by
+ *          calling getMethod as Object 1
+ * -#step3: Call setAccessible(AccessibleObject[] array, boolean flag) on object 1 to confirm that the returned are correct
+ * -#step4: Call the run of the use case, and execute method 2. In the method, get the method of MethodClass14 by
+ *          calling getMethod as Object 2
+ * -#step5: Call setAccessible(boolean flag) on object 2 to confirm that the returned are correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExAccessibleObjectSetAccessible.java
+ * -@ExecuteClass: MethodExAccessibleObjectSetAccessible
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Method;
+
+
+public class MethodExAccessibleObjectSetAccessible {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExAccessibleObjectSetAccessible1();
+        } catch (Exception e) {
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 10;
+        }
+
+        try {
+            result = methodExAccessibleObjectSetAccessible2();
+        } catch (Exception e) {
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 10;
+        }
+
+
+        if (result == 4 && MethodExAccessibleObjectSetAccessible.res == 79) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int methodExAccessibleObjectSetAccessible1() throws NoSuchFieldException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // SecurityException - Exception safety
+        // static void setAccessible(AccessibleObject[] array, boolean flag)
+        Method[] sampleMethod = MethodClass14.class.getMethods();
+
+        try {
+            AccessibleObject.setAccessible(sampleMethod, false);
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 10;
+        } catch (SecurityException e1) {
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 1;
+        }
+        return result1;
+    }
+
+    private static int methodExAccessibleObjectSetAccessible2() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // SecurityException - Exception safety
+        //  void setAccessible(boolean flag)
+
+        Method sampleMethod = MethodClass14.class.getMethod("sampleMethod");
+        try {
+            sampleMethod.setAccessible(false);
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 10;
+        } catch (SecurityException e1) {
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 1;
+        }
+        return result1;
+    }
+}
+
+@CustomAnnotationwe(name = "SampleClass", value = "Sample Class Annotation")
+class MethodClass14 {
+    private String sampleField;
+
+    @CustomAnnotationwe(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@interface CustomAnnotationwe {
+    String name();
+
+    String value();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/MethodExExecutablegetAnnotationsByTypeNullPointerException.java b/test/testsuite/ouroboros/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/MethodExExecutablegetAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..db187e45deb7c302495d77269576f9f5c716d247
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/MethodExExecutablegetAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExExecutablegetAnnotationsByTypeNullPointerException.java
+ *- @TestCaseName: Exception in reflect/Method:<T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+ *- @TestCaseType: Function Test
+ *- @RequirementName: 补充重写类的父类方法
+ *- @Brief:
+ * -#step1: Create a class SampleClass_h1, which has sampleMethod method, and annotate the method
+ * -#step2: Call the run of the use case, and execute method 1. In the method, get the method of SampleClass_h1 by
+ *          calling getMethod as Object 1
+ * -#step3: Call getAnnotationsByType(Class<T> annotationClass) on object 1 to confirm that the returned are correct
+ * -#step4: execute method 2. In the method, get the method of SampleClass_h6 by calling getMethod as Object 2
+ * -#step5: Call getAnnotationsByType(null) on object 2 with null parameter, confirm to throw NullPointerException
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source: MethodExExecutablegetAnnotationsByTypeNullPointerException.java
+ *- @ExecuteClass: MethodExExecutablegetAnnotationsByTypeNullPointerException
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+public class MethodExExecutablegetAnnotationsByTypeNullPointerException {
+    static int res = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(new MethodExExecutablegetAnnotationsByTypeNullPointerException().run());
+    }
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = MethodExExecutablegetAnnotationsByTypeNullPointerException_1();
+        } catch (Exception e) {
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 20;
+        }
+
+        try {
+            result = MethodExExecutablegetAnnotationsByTypeNullPointerException_2();
+        } catch (Exception e) {
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 20;
+        }
+
+        if (result == 4 && MethodExExecutablegetAnnotationsByTypeNullPointerException.res == 74) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int MethodExExecutablegetAnnotationsByTypeNullPointerException_1() throws NoSuchMethodException {
+        //  <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4;
+        Method m1 = SampleClass_h1.class.getDeclaredMethod("sampleMethod");
+        try {
+            CustomAnnotations_h5[] tp = m1.getAnnotationsByType(CustomAnnotations_h5.class);
+            if (tp.getClass().toString().equals("class [LCustomAnnotations_h5;")) {
+                MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 10;
+            }
+        } catch (Exception e) {
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 15;
+        }
+
+        return result1;
+    }
+
+    private int MethodExExecutablegetAnnotationsByTypeNullPointerException_2() throws NoSuchMethodException {
+        //  NullPointerException - if the given annotation class is null
+        //  <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4;
+        Method m1 = SampleClass_h1.class.getDeclaredMethod("sampleMethod");
+        try {
+            CustomAnnotations_h5[] tp = m1.getAnnotationsByType(null);
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 10;
+        } catch (NullPointerException e) {
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 15;
+        }
+
+        return result1;
+    }
+}
+
+@CustomAnnotations_h5(name="SampleClass",  value = "Sample Class Annotation")
+class SampleClass_h1 {
+    private String sampleField;
+
+    @CustomAnnotations_h5(name="sampleMethod",  value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+
+    public String getSampleField() {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@interface CustomAnnotations_h5 {
+    String name();
+    String value();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/MethodExExecutablegetGenericParameterTypesExceptions.java b/test/testsuite/ouroboros/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/MethodExExecutablegetGenericParameterTypesExceptions.java
new file mode 100644
index 0000000000000000000000000000000000000000..8154ba68d890fde2f50b047b8a3f1d1236984bdc
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/MethodExExecutablegetGenericParameterTypesExceptions.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExExecutablegetGenericParameterTypesExceptions.java
+ * -@TestCaseName: Exception in reflect/Method:Type[] getGenericParameterTypes()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a class SampleClass_h3, which has getSampleField method, and annotate the method
+ * -#step2: Call the run of the use case, and execute method 1. In the method, get the method of SampleClass_h3 by
+ *          calling getMethod as Object 1
+ * -#step3: Call getGenericParameterTypes() on object 1 to confirm that the returned are correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExExecutablegetGenericParameterTypesExceptions.java
+ * -@ExecuteClass: MethodExExecutablegetGenericParameterTypesExceptions
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+
+
+public class MethodExExecutablegetGenericParameterTypesExceptions {
+    static int res = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(new MethodExExecutablegetGenericParameterTypesExceptions().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExExecutablegetGenericParameterTypesExceptions1();
+        } catch (Exception e) {
+            MethodExExecutablegetGenericParameterTypesExceptions.res = MethodExExecutablegetGenericParameterTypesExceptions.res - 20;
+        }
+
+        if (result == 4 && MethodExExecutablegetGenericParameterTypesExceptions.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int methodExExecutablegetGenericParameterTypesExceptions1() throws NoSuchMethodException {
+        //  Type[] getGenericParameterTypes()
+        int result1 = 4;
+        Method m1 = SampleClassH3.class.getDeclaredMethod("getSampleField");
+        try {
+            Type[] tp = m1.getGenericParameterTypes();
+
+            if (Arrays.toString(tp).equals("[]")) {
+                MethodExExecutablegetGenericParameterTypesExceptions.res = MethodExExecutablegetGenericParameterTypesExceptions.res - 10;
+            }
+        } catch (Exception e) {
+            MethodExExecutablegetGenericParameterTypesExceptions.res = MethodExExecutablegetGenericParameterTypesExceptions.res - 15;
+        }
+
+        return result1;
+    }
+}
+
+@CustomAnnotationsH8(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClassH3 {
+    private String sampleField;
+
+    public String getSampleField() throws ArrayIndexOutOfBoundsException {
+        return sampleField;
+    }
+
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+
+@interface CustomAnnotationsH8 {
+    String name();
+
+    String value();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/MethodExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/MethodExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5fe4f9fc9a1d545fdc98bcd19eb4b266ed5d69c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/MethodExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Method: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: MethodExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Method;
+
+public class MethodExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private Method[] rp = MethodExObjectnotifyAllIllegalMonitorStateException.class.getMethods();
+
+    public static void main(String argv[]) {
+        System.out.println(new MethodExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && MethodExObjectnotifyAllIllegalMonitorStateException.res == 68) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp[0].notifyAll();
+            MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp[0].notifyAll();
+                    MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/MethodExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/MethodExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..5479cac40e8a86a9d257fcf20282f5e5cc107c03
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/MethodExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Method:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: MethodExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Method;
+
+public class MethodExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private Method[] rp = MethodExObjectnotifyIllegalMonitorStateException.class.getMethods();
+
+    public static void main(String argv[]) {
+        System.out.println(new MethodExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && MethodExObjectnotifyIllegalMonitorStateException.res == 68) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp[0].notify();
+            MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+    /**
+     * Thread run fun
+     */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp[0].notify();
+                    MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/MethodExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/MethodExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d2c5e4d7e283ad0cc27e7c67e7a6b0f25d81b36
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/MethodExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in reflect/Method: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: MethodExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Method;
+
+public class MethodExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    static Method[] methods = MethodExObjectwaitIllegalArgumentException.class.getMethods();
+
+    public static void main(String argv[]) {
+        System.out.println(new MethodExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class MethodExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait(millis);
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class MethodExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+
+        long millis = -2;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait(millis, nanos);
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new MethodExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new MethodExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && MethodExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/MethodExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/MethodExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3b9e66d6d281789b1e91d54fc1b2b06d907067f
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/MethodExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect/Method: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: MethodExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Method;
+
+public class MethodExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static Method[] methods = MethodExObjectwaitIllegalMonitorStateException.class.getMethods();
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = methodExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = methodExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = methodExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && MethodExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int methodExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            methods[0].wait();
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int methodExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            methods[0].wait(millis);
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int methodExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            methods[0].wait(millis, nanos);
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/MethodExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/MethodExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..3817e44260b3406a4a9492293dba6794f08e358c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/MethodExObjectwaitInterruptedException.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in reflect/Field: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExObjectwaitInterruptedException.java
+ * -@ExecuteClass: MethodExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.Method;
+
+public class MethodExObjectwaitInterruptedException {
+    static int res = 99;
+    static Method[] methods = MethodExObjectwaitInterruptedException.class.getMethods();
+
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        System.out.println(new MethodExObjectwaitInterruptedException().run());
+    }
+
+    private class MethodExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait();
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    private class MethodExObjectwaitInterruptedException12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait(millis);
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    private class MethodExObjectwaitInterruptedException13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait(millis, nanos);
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new MethodExObjectwaitInterruptedException11());
+        Thread t2 = new Thread(new MethodExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new MethodExObjectwaitInterruptedException12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new MethodExObjectwaitInterruptedException13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && MethodExObjectwaitInterruptedException.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0087-rt-parent-MethodExObjectwait/MethodExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0087-rt-parent-MethodExObjectwait/MethodExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..8cf1156e853276cf3dd492b97b65aed1ca0ff371
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0087-rt-parent-MethodExObjectwait/MethodExObjectwait.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Method/MethodExObjectwait.java
+ * -@TestCaseName: Exception in reflect Method: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: MethodExObjectwait.java
+ * -@ExecuteClass: MethodExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+public class MethodExObjectwait {
+    static int res = 99;
+    private Method[] cal = MethodExObjectwait.class.getMethods();
+    private Method[] cal2 = MethodExObjectwait.class.getMethods();
+    private Method[] cal3 = MethodExObjectwait.class.getMethods();
+
+    public static void main(String argv[]) {
+        System.out.println(new MethodExObjectwait().run());
+    }
+
+    private class MethodExObjectwait11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal) {
+                cal.notifyAll();
+                try {
+                    cal.wait();
+                    MethodExObjectwait.res = MethodExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class MethodExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal2) {
+                cal2.notifyAll();
+                try {
+                    cal2.wait(millis);
+                    MethodExObjectwait.res = MethodExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class MethodExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cal3) {
+                cal3.notifyAll();
+                try {
+                    cal3.wait(millis, nanos);
+                    MethodExObjectwait.res = MethodExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new MethodExObjectwait11());
+        Thread t2 = new Thread(new MethodExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new MethodExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new MethodExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && MethodExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/ModifierExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/ModifierExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..1814291a3a19ec1d8f41fd38d11f3d62b5cf9ab6
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/ModifierExObjectgetClass.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ModifierExObjectgetClass.java
+ * -@TestCaseName: Exception in reflect Modifier:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create Object1 by new Modifier()
+ * -#step2: Call getClass() on Object1
+ * -#step3: Confirm that the returned Class is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ModifierExObjectgetClass.java
+ * -@ExecuteClass: ModifierExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class ModifierExObjectgetClass {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = modifierExObjectgetClass1();
+        } catch (Exception e) {
+            ModifierExObjectgetClass.res = ModifierExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && ModifierExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int modifierExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+
+        Modifier mf2 = new Modifier();
+        Class px1 = mf2.getClass();
+        if (px1.toString().equals("class java.lang.reflect.Modifier")) {
+            ModifierExObjectgetClass.res = ModifierExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/ModifierExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/ModifierExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..f9919b5e8b082a32b2bdd0937e351973b8e80828
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/ModifierExObjecthashCode.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ModifierExObjecthashCode.java
+ * -@TestCaseName: Exception in reflect Modifier: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create Object1 by new Modifier(), Object2 is given by Object1
+ * -#step2: Create Object3 by new Modifier().
+ * -#step3: Check hashCode of the Object1 and Object2 is equal, check hashCode of the Object1 and Object3 is not equal.
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ModifierExObjecthashCode.java
+ * -@ExecuteClass: ModifierExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class ModifierExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = modifierExObjecthashCode1();
+        } catch (Exception e) {
+            ModifierExObjecthashCode.res = ModifierExObjecthashCode.res - 20;
+        }
+
+
+        if (result == 4 && ModifierExObjecthashCode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int modifierExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+
+        Modifier mf0 = new Modifier();
+        Modifier mf1 = mf0;
+        Modifier mf2 = new Modifier();
+
+        int px0 = mf0.hashCode();
+        int px1 = mf1.hashCode();
+        int px2 = mf2.hashCode();
+
+        if (px0 == px1 && px0 != px2) {
+            ModifierExObjecthashCode.res = ModifierExObjecthashCode.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/ModifierExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/ModifierExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..ceb8b2ffaf654e72139851c9efd303e63680f098
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/ModifierExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ModifierExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Modifier:  final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ModifierExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ModifierExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class ModifierExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    Modifier mf2 = new Modifier();
+
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = modifierExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ModifierExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ModifierExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int modifierExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            mf2.notifyAll();
+            ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ModifierExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+
+        private ModifierExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notifyAll();
+                    ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/ModifierExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/ModifierExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..4976ebf0306f0a637b6648ca4b592fe56e8716c6
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/ModifierExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ModifierExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Modifier:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ModifierExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ModifierExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class ModifierExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    Modifier mf2 = new Modifier();
+
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = modifierExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ModifierExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ModifierExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int modifierExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            mf2.notify();
+            ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ModifierExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ModifierExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notify();
+                    ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/ModifierExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/ModifierExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..5268aa37bd85f13bf70abd5ce59760fbb8573e0a
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/ModifierExObjectwaitInterruptedException.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ModifierExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in reflect Modifier: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ModifierExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ModifierExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class ModifierExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Modifier mf2 = new Modifier();
+
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectwaitInterruptedException().run());
+    }
+
+    private class ModifierExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+
+        private int remainder;
+
+        private ModifierExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait();
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ModifierExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+
+        private ModifierExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ModifierExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+
+        private ModifierExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ModifierExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ModifierExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ModifierExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+
+        if (result == 2 && ModifierExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0093-rt-parent-ModifierExObjectwait/ModifierExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0093-rt-parent-ModifierExObjectwait/ModifierExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..370647c62b424701b8d24aaf7df4ca1fe3a24044
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0093-rt-parent-ModifierExObjectwait/ModifierExObjectwait.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ModifierExObjectwait.java
+ * -@TestCaseName: Exception in reflect Modifier: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ModifierExObjectwait.java
+ * -@ExecuteClass: ModifierExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class ModifierExObjectwait {
+    static int res = 99;
+    private Modifier mf2 = new Modifier();
+
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectwait().run());
+    }
+
+    private class ModifierExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private ModifierExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait();
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ModifierExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+
+        private ModifierExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notify();
+                try {
+                    mf2.wait(millis);
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ModifierExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+
+        private ModifierExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * join fun
+     *
+     * @param thread want join thread
+     */
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ModifierExObjectwait11(1));
+        Thread t2 = new Thread(new ModifierExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ModifierExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ModifierExObjectwait31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+        t2.interrupt();
+
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+
+        if (result == 2 && ModifierExObjectwait.res == 54) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/ParameterExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/ParameterExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..f48a3531d71004002340c3725eab31b124b2cf17
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/ParameterExObjectgetClass.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ParameterExObjectgetClass.java
+ * -@TestCaseName: Exception in reflect Parameter:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ParameterExObjectgetClass.java
+ * -@ExecuteClass: ParameterExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+public class ParameterExObjectgetClass {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ParameterExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterExObjectgetClass1();
+        } catch (Exception e) {
+            System.out.println(e);
+            ParameterExObjectgetClass.res = ParameterExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && ParameterExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int parameterExObjectgetClass1() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+        // System.out.println("-0-");
+        Method method = Parameter01a.class.getMethod("getName", new Class[]{String.class});
+        // System.out.println("-1-");
+        Parameter[] parameters = method.getParameters();
+        // System.out.println("-2-");
+        Class px1 = parameters[0].getClass();
+        // System.out.println(px1);
+        if (px1.toString().equals("class java.lang.reflect.Parameter")) {
+            ParameterExObjectgetClass.res = ParameterExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+
+}
+
+class Parameter01a {
+    String name = "default";
+
+    public String getName(String str1) {
+        return this.name;
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/ParameterExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/ParameterExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..0670b0685403448f2f9be0d8ec04168d0f6a3019
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/ParameterExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ParameterExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Parameter:  final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ParameterExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ParameterExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Parameter;
+import java.lang.reflect.Method;
+
+public class ParameterExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ParameterExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ParameterExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ParameterExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int parameterExObjectnotifyAllIllegalMonitorStateException1() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        Method method = Parameter03a.class.getMethod("getName", new Class[]{String.class});
+        Parameter[] parameters = method.getParameters();
+
+        try {
+            parameters[0].notifyAll();
+            ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ParameterExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        private int remainder;
+
+        private ParameterExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            Method me = null;
+            try {
+                me = Parameter03a.class.getMethod("getName", new Class[]{String.class});
+            } catch (NoSuchMethodException | SecurityException e) {
+                e.printStackTrace();
+            }
+            Parameter[] parameters = me.getParameters();
+            synchronized (parameters[0]) {
+                try {
+                    parameters[0].notifyAll();
+                    ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+class Parameter03a {
+    private String name = "default";
+
+    public String getName(String str1) {
+        return str1;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/ParameterExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/ParameterExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..a85419c66ccdf447d0aeb924c90019993ee2b52b
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/ParameterExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ParameterExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Parameter:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ParameterExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ParameterExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Parameter;
+import java.lang.reflect.Method;
+
+public class ParameterExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ParameterExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ParameterExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ParameterExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int parameterExObjectnotifyIllegalMonitorStateException1() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        Method method = Parameter02a.class.getMethod("getName", new Class[]{String.class});
+        Parameter[] parameters = method.getParameters();
+
+        try {
+            parameters[0].notify();
+            ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ParameterExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ParameterExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            Method me = null;
+            try {
+                me = Parameter02a.class.getMethod("getName", new Class[]{String.class});
+            } catch (NoSuchMethodException | SecurityException e) {
+                e.printStackTrace();
+            }
+            Parameter[] parameters = me.getParameters();
+            synchronized (parameters[0]) {
+                try {
+                    parameters[0].notify();
+                    ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+class Parameter02a {
+    private String name = "default";
+
+    public String getName(String str1) {
+        return str1;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0097-rt-parent-ParameterExObjectwait/ParameterExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0097-rt-parent-ParameterExObjectwait/ParameterExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..f72886d38f9ff796ba372e6c889ce1182fd92b04
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0097-rt-parent-ParameterExObjectwait/ParameterExObjectwait.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ParameterExObjectwait.java
+ *- @TestCaseName: Exception in reflect Parameter: final void wait(*)
+ *- @TestCaseType: Function Test
+ *- @RequirementName: 补充重写类的父类方法
+ *- @Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source: ParameterExObjectwait.java
+ *- @ExecuteClass: ParameterExObjectwait
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Parameter;
+
+public class ParameterExObjectwait {
+    static int res = 99;
+    private static Parameter[] param = null;
+
+    public static void main(String argv[]) {
+        try {
+            param = ParameterExObjectwait.class.getMethod("sleep", new Class[]{int.class}).getParameters();
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        System.out.println(new ParameterExObjectwait().run());
+    }
+
+    private class ParameterExObjectwait_11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private ParameterExObjectwait_11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        public void run() {
+            synchronized (param[0]) {
+                param[0].notifyAll();
+                try {
+                    param[0].wait();
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    //System.out.println("111");
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    //System.out.println("222");
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ParameterExObjectwait_21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+
+        private ParameterExObjectwait_21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        public void run() {
+            synchronized (param[0]) {
+                param[0].notify();
+                try {
+                    param[0].wait(millis);
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ParameterExObjectwait_31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+
+        private ParameterExObjectwait_31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        public void run() {
+            synchronized (param[0]) {
+                param[0].notifyAll();
+                try {
+                    param[0].wait(millis, nanos);
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        //check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ParameterExObjectwait_11(1));
+        Thread t2 = new Thread(new ParameterExObjectwait_11(2));
+        //final void wait(long millis)
+        Thread t3 = new Thread(new ParameterExObjectwait_21(3));
+        //final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ParameterExObjectwait_31(5));
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        t1.interrupt();
+        t2.interrupt();
+
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+
+
+        if (result == 2 && ParameterExObjectwait.res == 54) {
+            result = 0;
+        }
+
+//        System.out.println("result: " + result);
+//        System.out.println("ParameterExObjectwait.res: " + ParameterExObjectwait.res);
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/ProxyExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/ProxyExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c8dd78f766c64dbda02e1c67e1f7e5db9100d5b
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/ProxyExObjecthashCode.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ProxyExObjecthashCode.java
+ * -@TestCaseName: Exception in reflect Proxy: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create MyProxy1 extend by Proxy
+ * -#step2: Create Object1 by new MyProxy1, Object2 is given by Object2, Object3 by new MyProxy1.
+ * -#step3: Check hashCode of the Object1 and Object2 is equal, check hashCode of the Object1 and Object3 is not equal.
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ProxyExObjecthashCode.java
+ * -@ExecuteClass: ProxyExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+public class ProxyExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = proxyExObjecthashCode1();
+        } catch (Exception e) {
+            ProxyExObjecthashCode.res = ProxyExObjecthashCode.res - 20;
+        }
+
+        if (result == 4 && ProxyExObjecthashCode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int proxyExObjecthashCode1() {
+        //  int hashCode()
+        int result1 = 4; /*STATUS_FAILED*/
+        MyProxy1 px0 = new MyProxy1(new MyInvocationHandler());
+        MyProxy1 px1 = px0;
+        MyProxy1 px2 = new MyProxy1(new MyInvocationHandler());
+
+        try {
+            int int0 = px0.hashCode();
+            int int1 = px1.hashCode();
+            int int2 = px2.hashCode();
+
+            if (px0 == px1 && px0 != px2) {
+                ProxyExObjecthashCode.res = ProxyExObjecthashCode.res - 10;
+            }
+        } catch (IllegalMonitorStateException e) {
+            ProxyExObjecthashCode.res = ProxyExObjecthashCode.res - 1;
+        }
+
+        return result1;
+    }
+
+}
+
+
+class MyProxy1 extends Proxy {
+    MyProxy1(InvocationHandler h) {
+        super(h);
+    }
+
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+
+class MyInvocationHandler implements InvocationHandler {
+    /**
+     * invoke test
+     * @param proxy proxy test
+     * @param method method for test
+     * @param args object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+     */
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/ProxyExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/ProxyExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b31aa3695d6ceef6b680b0cc25d96a05336c0c7
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/ProxyExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ProxyExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Proxy: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ProxyExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ProxyExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+public class ProxyExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private MyProxy3 proxy = new MyProxy3(new MyInvocationHandler2());
+
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = proxyExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ProxyExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ProxyExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int proxyExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            proxy.notifyAll();
+            ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ProxyExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+
+        private ProxyExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                try {
+                    proxy.notifyAll();
+                    ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+class MyProxy3 extends Proxy {
+    MyProxy3(InvocationHandler h) {
+        super(h);
+    }
+
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+
+class MyInvocationHandler2 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+     */
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/ProxyExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/ProxyExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..d68388efdf3622b6f042532f238c77f0f67aab5d
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/ProxyExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ProxyExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Proxy:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ProxyExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ProxyExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+public class ProxyExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private MyProxy2 proxy = new MyProxy2(new MyInvocationHandler1());
+
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = proxyExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ProxyExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ProxyExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int proxyExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            proxy.notify();
+            ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ProxyExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ProxyExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                try {
+                    proxy.notify();
+                    ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+class MyProxy2 extends Proxy {
+    MyProxy2(InvocationHandler h) {
+        super(h);
+    }
+
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+
+class MyInvocationHandler1 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+     */
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/ProxyExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/ProxyExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e45c4b479efc6f525b7e8385eecb14234d9cd8e
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/ProxyExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ProxyExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in reflect Proxy: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ProxyExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: ProxyExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+public class ProxyExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private MyProxy5 proxy = new MyProxy5(new MyInvocationHandler5());
+
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class ProxyExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+
+        private ProxyExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis);
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ProxyExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+
+        private ProxyExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis, nanos);
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ProxyExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ProxyExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ProxyExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+
+class MyProxy5 extends Proxy {
+    MyProxy5(InvocationHandler h) {
+        super(h);
+    }
+
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+
+class MyInvocationHandler5 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+     */
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/ProxyExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/ProxyExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..185ea9b12e8bd5fb5fade0332afb377202af2e00
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/ProxyExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ProxyExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Proxy: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ProxyExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ProxyExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+public class ProxyExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = proxyExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = proxyExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = proxyExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && ProxyExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int proxyExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        MyProxy7 proxy = new MyProxy7(new MyInvocationHandler6());
+        try {
+            proxy.wait();
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int proxyExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        MyProxy7 proxy = new MyProxy7(new MyInvocationHandler6());
+        long millis = 123;
+        try {
+            proxy.wait(millis);
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int proxyExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        MyProxy7 proxy = new MyProxy7(new MyInvocationHandler6());
+        long millis = 123;
+        int nanos = 10;
+        try {
+            proxy.wait(millis, nanos);
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+}
+
+class MyProxy7 extends Proxy {
+    MyProxy7(InvocationHandler h) {
+        super(h);
+    }
+
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+
+class MyInvocationHandler6 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+     */
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/ProxyExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/ProxyExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..151066950af21a0147baad4a520b1705d0092730
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/ProxyExObjectwaitInterruptedException.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ProxyExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in reflect Proxy: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ProxyExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ProxyExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationHandler;
+
+public class ProxyExObjectwaitInterruptedException {
+    static int res = 99;
+    private MyProxy8 proxy = new MyProxy8(new MyInvocationHandler7());
+
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectwaitInterruptedException().run());
+    }
+
+    private class ProxyExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private ProxyExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait();
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ProxyExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+
+        private ProxyExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis);
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ProxyExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+
+        private ProxyExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis, nanos);
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ProxyExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ProxyExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ProxyExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+
+        if (result == 2 && ProxyExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+
+class MyProxy8 extends Proxy {
+    MyProxy8(InvocationHandler h) {
+        super(h);
+    }
+
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+
+class MyInvocationHandler7 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+     */
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0104-rt-parent-ProxyExObjectwait/ProxyExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0104-rt-parent-ProxyExObjectwait/ProxyExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba237012c9c8363b0b51efab65fb810623fba0cd
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0104-rt-parent-ProxyExObjectwait/ProxyExObjectwait.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ProxyExObjectwait.java
+ * -@TestCaseName: Exception in reflect Proxy: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ProxyExObjectwait.java
+ * -@ExecuteClass: ProxyExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+public class ProxyExObjectwait {
+    static int res = 99;
+    private MyProxy4 proxy = new MyProxy4(new MyInvocationHandler3());
+
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectwait().run());
+    }
+
+    private class ProxyExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private ProxyExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait();
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ProxyExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+
+        private ProxyExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis);
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ProxyExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+
+        private ProxyExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis, nanos);
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * join fun
+     *
+     * @param thread wait join thread
+     */
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ProxyExObjectwait11(1));
+        Thread t2 = new Thread(new ProxyExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ProxyExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ProxyExObjectwait31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        t2.interrupt();
+
+
+        if (result == 2 && ProxyExObjectwait.res == 54) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+
+class MyProxy4 extends Proxy {
+    MyProxy4(InvocationHandler h) {
+        super(h);
+    }
+
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+
+class MyInvocationHandler3 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+     */
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/ReflectPermissionExBasicPermissionimplies.java b/test/testsuite/ouroboros/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/ReflectPermissionExBasicPermissionimplies.java
new file mode 100644
index 0000000000000000000000000000000000000000..db9d25361bf3fd5fb488806922087224ca889ab8
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/ReflectPermissionExBasicPermissionimplies.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectPermissionExBasicPermissionimplies.java
+ * -@TestCaseName: Exception in reflect ReflectPermission: boolean implies(Permission p)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a ReflectPermission object
+ * -#step2: call method implies(Permission p) of new Object
+ * -#step3: Confirm that the return value is true
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectPermissionExBasicPermissionimplies.java
+ * -@ExecuteClass: ReflectPermissionExBasicPermissionimplies
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.ReflectPermission;
+
+public class ReflectPermissionExBasicPermissionimplies {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExBasicPermissionimplies1();
+        } catch (Exception e) {
+            ReflectPermissionExBasicPermissionimplies.res = ReflectPermissionExBasicPermissionimplies.res - 20;
+        }
+
+        if (result == 4 && ReflectPermissionExBasicPermissionimplies.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int reflectPermissionExBasicPermissionimplies1() {
+        //  boolean implies(Permission p)
+        int result1 = 4; /*STATUS_FAILED*/
+        String name = "name";
+        String actions = null;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        if (rp.implies(rp)) {
+            ReflectPermissionExBasicPermissionimplies.res = ReflectPermissionExBasicPermissionimplies.res - 10;
+        } else {
+            ReflectPermissionExBasicPermissionimplies.res = ReflectPermissionExBasicPermissionimplies.res - 5;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/ReflectPermissionExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/ReflectPermissionExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..17218f3df45d5fb0565c8395bebdce3aa3af3e13
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/ReflectPermissionExObjectgetClass.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectPermissionExObjectgetClass.java
+ * -@TestCaseName: Exception in reflect ReflectPermission:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a ReflectPermission object1
+ * -#step2: Call getClass() on Object1
+ * -#step3: Confirm that the returned Class is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectPermissionExObjectgetClass.java
+ * -@ExecuteClass: ReflectPermissionExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.ReflectPermission;
+
+public class ReflectPermissionExObjectgetClass {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExObjectgetClass1();
+        } catch (Exception e) {
+            ReflectPermissionExObjectgetClass.res = ReflectPermissionExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && ReflectPermissionExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int reflectPermissionExObjectgetClass1() throws ClassNotFoundException {
+        //  final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        String name = "name";
+        String actions = null;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            Class<? extends ReflectPermission> cls1 = rp.getClass();
+            if (cls1.toString().equals("class java.lang.reflect.ReflectPermission")) {
+                ReflectPermissionExObjectgetClass.res = ReflectPermissionExObjectgetClass.res - 10;
+            }
+        } catch (IllegalMonitorStateException e) {
+            ReflectPermissionExObjectgetClass.res = ReflectPermissionExObjectgetClass.res - 1;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..0cd40baa417234bc7e40e1aa848b7dd69bc8d1fd
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect ReflectPermission: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ReflectPermissionExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.ReflectPermission;
+
+public class ReflectPermissionExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private String name = "name";
+    private String actions = null;
+    private ReflectPermission rp = new ReflectPermission(name, actions);
+
+    public static void main(String argv[]) {
+        System.out.println(new ReflectPermissionExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ReflectPermissionExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int reflectPermissionExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ReflectPermissionExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        private int remainder;
+
+        private ReflectPermissionExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/ReflectPermissionExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/ReflectPermissionExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..11beaf8aca6efe184dde649cf744746d196ca598
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/ReflectPermissionExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectPermissionExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect ReflectPermission:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectPermissionExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ReflectPermissionExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.ReflectPermission;
+
+public class ReflectPermissionExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private String name = "name";
+    private String actions = null;
+    private ReflectPermission rp = new ReflectPermission(name, actions);
+
+    public static void main(String argv[]) {
+        System.out.println(new ReflectPermissionExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ReflectPermissionExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ReflectPermissionExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int reflectPermissionExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notify();
+            ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ReflectPermissionExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ReflectPermissionExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/ReflectPermissionExObjecttoString.java b/test/testsuite/ouroboros/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/ReflectPermissionExObjecttoString.java
new file mode 100644
index 0000000000000000000000000000000000000000..591c480e9e51186a24e80c6ff5c4608a7db5dab0
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/ReflectPermissionExObjecttoString.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectPermissionExObjecttoString.java
+ * -@TestCaseName: Exception in reflect ReflectPermission:  String toString()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a ReflectPermission object
+ * -#step2: call method toString() of new Object
+ * -#step3: Confirm that the return value is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectPermissionExObjecttoString.java
+ * -@ExecuteClass: ReflectPermissionExObjecttoString
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.ReflectPermission;
+
+public class ReflectPermissionExObjecttoString {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExObjecttoString1();
+        } catch (Exception e) {
+            ReflectPermissionExObjecttoString.res = ReflectPermissionExObjecttoString.res - 20;
+        }
+
+        if (result == 4 && ReflectPermissionExObjecttoString.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int reflectPermissionExObjecttoString1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // String toString()
+        String name = "name";
+        String actions = null;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            String str1 = rp.toString();
+
+            if (str1.contains("java.lang.reflect.ReflectPermission")) {
+                ReflectPermissionExObjecttoString.res = ReflectPermissionExObjecttoString.res - 10;
+            }
+        } catch (IllegalMonitorStateException e) {
+            ReflectPermissionExObjecttoString.res = ReflectPermissionExObjecttoString.res - 1;
+        }
+
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/ReflectPermissionExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/ReflectPermissionExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c35caa0440bc0136234d8c16fcd4c317e5f9728
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/ReflectPermissionExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectPermissionExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect ReflectPermission: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectPermissionExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ReflectPermissionExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.ReflectPermission;
+
+public class ReflectPermissionExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = reflectPermissionExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = reflectPermissionExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = reflectPermissionExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && ReflectPermissionExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int reflectPermissionExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        String name = "name";
+        String actions = null;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            rp.wait();
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int reflectPermissionExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        String name = "name";
+        String actions = null;
+        long millis = 123;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            rp.wait(millis);
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int reflectPermissionExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        String name = "name";
+        String actions = null;
+        long millis = 123;
+        int nanos = 10;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            rp.wait(millis, nanos);
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/ReflectPermissionExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/ReflectPermissionExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e1cc38bee64c9bf5559271900469c6266f3968c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/ReflectPermissionExObjectwaitInterruptedException.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectPermission/ReflectPermissionExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in reflect ReflectPermission: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectPermissionExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ReflectPermissionExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.ReflectPermission;
+
+public class ReflectPermissionExObjectwaitInterruptedException {
+    static int res = 99;
+    private static String name = "name";
+    private static String action = null;
+    private static ReflectPermission RP = new ReflectPermission(name, action);
+
+    public static void main(String argv[]) {
+        System.out.println(new ReflectPermissionExObjectwaitInterruptedException().run());
+    }
+
+    private class ReflectPermissionExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+
+        private int remainder;
+
+        private ReflectPermissionExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (RP) {
+                RP.notifyAll();
+                try {
+                    RP.wait();
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ReflectPermissionExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+
+        private ReflectPermissionExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (RP) {
+                RP.notifyAll();
+                try {
+                    RP.wait(millis);
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ReflectPermissionExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+
+        private ReflectPermissionExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (RP) {
+                RP.notifyAll();
+                try {
+                    RP.wait(millis, nanos);
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ReflectPermissionExObjectwaitInterruptedException.ReflectPermissionExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ReflectPermissionExObjectwaitInterruptedException.ReflectPermissionExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ReflectPermissionExObjectwaitInterruptedException.ReflectPermissionExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+
+        if (result == 2 && ReflectPermissionExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/ReflectPermissionExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/ReflectPermissionExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b48069ecb0bc4aa1e2d17aac43ebb9be1a87ee3
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/ReflectPermissionExObjectwait.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectPermissionExObjectwait.java
+ * -@TestCaseName: Exception in reflect ReflectPermission: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectPermissionExObjectwait.java
+ * -@ExecuteClass: ReflectPermissionExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.ReflectPermission;
+
+public class ReflectPermissionExObjectwait {
+    static int res = 99;
+    private String name = "name";
+    private String action = null;
+    private ReflectPermission RP = new ReflectPermission(name, action);
+    private ReflectPermission RP2 = new ReflectPermission(name, action);
+    private ReflectPermission RP3 = new ReflectPermission(name, action);
+
+    public static void main(String argv[]) {
+        System.out.println(new ReflectPermissionExObjectwait().run());
+    }
+
+    private class ReflectPermissionExObjectwait11 implements Runnable {
+        // final void wait()
+
+        private int remainder;
+
+        private ReflectPermissionExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (RP) {
+                RP.notifyAll();
+                try {
+                    RP.wait();
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ReflectPermissionExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+
+        private ReflectPermissionExObjectwait12(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (RP2) {
+                RP2.notifyAll();
+                try {
+                    RP2.wait(millis);
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    private class ReflectPermissionExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+
+        private ReflectPermissionExObjectwait13(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (RP3) {
+                RP3.notifyAll();
+                try {
+                    RP3.wait(millis, nanos);
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ReflectPermissionExObjectwait11(1));
+        Thread t2 = new Thread(new ReflectPermissionExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ReflectPermissionExObjectwait12(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ReflectPermissionExObjectwait13(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 2 && ReflectPermissionExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/ReflectPermissionExPermissioncheckGuard.java b/test/testsuite/ouroboros/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/ReflectPermissionExPermissioncheckGuard.java
new file mode 100644
index 0000000000000000000000000000000000000000..427599752667a8076773a1543f110ee8370a4b58
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/ReflectPermissionExPermissioncheckGuard.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectPermissionExPermissioncheckGuard.java
+ * -@TestCaseName: Exception in reflect ReflectPermission:  void checkGuard(Object object)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a ReflectPermission object
+ * -#step2: call method checkGuard(Object object) of new Object
+ * -#step3: Confirm that execute is correct, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectPermissionExPermissioncheckGuard.java
+ * -@ExecuteClass: ReflectPermissionExPermissioncheckGuard
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.ReflectPermission;
+
+public class ReflectPermissionExPermissioncheckGuard {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExPermissioncheckGuard1();
+        } catch (Exception e) {
+            ReflectPermissionExPermissioncheckGuard.res = ReflectPermissionExPermissioncheckGuard.res - 20;
+        }
+
+        if (result == 4 && ReflectPermissionExPermissioncheckGuard.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int reflectPermissionExPermissioncheckGuard1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // void checkGuard(Object object)
+        String name = "name";
+        String actions = null;
+        final Object obj = new Object();
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            rp.checkGuard(obj);
+            ReflectPermissionExPermissioncheckGuard.res = ReflectPermissionExPermissioncheckGuard.res - 10;
+        } catch (IllegalMonitorStateException e) {
+            ReflectPermissionExPermissioncheckGuard.res = ReflectPermissionExPermissioncheckGuard.res - 1;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/StringBufferExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/StringBufferExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d8ebe047759f2e2a6d9b67ec9bd6921e55e07fa
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/StringBufferExObjectgetClass.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferExObjectgetClass.java
+ * -@TestCaseName: Exception in String:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a StringBuffer object1
+ * -#step2: Call getClass() on Object1
+ * -#step3: Confirm that the returned Class is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBufferExObjectgetClass.java
+ * -@ExecuteClass: StringBufferExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Class;
+
+public class StringBufferExObjectgetClass {
+    static int res = 99;
+    private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+
+    public static void main(String argv[]) {
+        System.out.println(new StringBufferExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBufferExObjectgetClass1();
+        } catch (Exception e) {
+            StringBufferExObjectgetClass.res = StringBufferExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && StringBufferExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int stringBufferExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+
+        StringBuffer sb = null;
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuffer(stringArray[i]);
+        }
+        Class px1 = sb.getClass();
+        if (px1.toString().equals("class java.lang.StringBuffer")) {
+            StringBufferExObjectgetClass.res = StringBufferExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/StringBufferExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/StringBufferExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2b434287744cc62f7e5a7dab31b21a8d0bddc09
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/StringBufferExObjecthashCode.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferExObjecthashCode.java
+ * -@TestCaseName: Exception in StringBuffer: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create Object1 by new StringBuffer(String name)
+ * -#step2: Create Object2 is given by Object2, Object3 by new StringBuffer(String name)
+ * -#step3: Check hashCode of the Object1 and Object2 is equal, check hashCode of the Object1 and Object3 is not equal.
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBufferExObjecthashCode.java
+ * -@ExecuteClass: StringBufferExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuffer;
+
+public class StringBufferExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new StringBufferExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBufferExObjecthashCode1();
+        } catch (Exception e) {
+            StringBufferExObjecthashCode.res = StringBufferExObjecthashCode.res - 20;
+        }
+
+        if (result == 4 && StringBufferExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+
+
+    private int stringBufferExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        StringBuffer sb1 = new StringBuffer("aa");
+        StringBuffer sb2 = sb1;
+        StringBuffer sb3 = new StringBuffer("╬の〆");
+
+        if (sb1.hashCode() == sb2.hashCode() && sb1.hashCode() != sb3.hashCode()) {
+            StringBufferExObjecthashCode.res = StringBufferExObjecthashCode.res - 10;
+        } else {
+            StringBufferExObjecthashCode.res = StringBufferExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/StringBufferExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/StringBufferExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..7bb7251801f787cdb20fd01d991fc540f9de3d9b
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/StringBufferExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in StringBuffer:  final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBufferExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: StringBufferExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuffer;
+
+public class StringBufferExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer sb = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(new StringBufferExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBufferExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new StringBufferExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && StringBufferExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int stringBufferExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            sb.notifyAll();
+            StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class StringBufferExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notifyAll();
+                    StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/StringBufferExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/StringBufferExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..1569369c1d3440649f4794712263cc3325a5d95b
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/StringBufferExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in StringBuffer:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBufferExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: StringBufferExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuffer;
+
+public class StringBufferExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer sb = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(new StringBufferExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBufferExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new StringBufferExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && StringBufferExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int stringBufferExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            sb.notify();
+            StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class StringBufferExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notify();
+                    StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/StringBufferExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/StringBufferExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e7a1d7177a2559feed4fd1007e0b5686fba7618
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/StringBufferExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in StringBuffer: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBufferExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: StringBufferExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuffer;
+
+public class StringBufferExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer mf2 = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            mf2 = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(new StringBufferExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class StringBufferExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class StringBufferExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringBufferExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringBufferExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && StringBufferExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/StringBufferExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/StringBufferExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d9278feee1920eff9e08c016c859b2904d18041
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/StringBufferExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in StringBuffer: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBufferExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: StringBufferExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuffer;
+
+public class StringBufferExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer mf2 = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            mf2 = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = stringBufferExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = stringBufferExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = stringBufferExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && StringBufferExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int stringBufferExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            mf2.wait();
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int stringBufferExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int stringBufferExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0120-rt-parent-StringBufferExObjectwait/StringBufferExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0120-rt-parent-StringBufferExObjectwait/StringBufferExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..67d417f55fbbc752e27b27772cfc5f06170d739a
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0120-rt-parent-StringBufferExObjectwait/StringBufferExObjectwait.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferExObjectwait.java
+ * -@TestCaseName: Exception in StringBuffer: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBufferExObjectwait.java
+ * -@ExecuteClass: StringBufferExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuffer;
+
+public class StringBufferExObjectwait {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer sb = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(new StringBufferExObjectwait().run());
+    }
+
+    private class StringBufferExObjectwait11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait();
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    // System.out.println("111");
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    System.out.println("222");
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+
+    private class StringBufferExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                sb.notify();
+                try {
+                    sb.wait(millis);
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    private class StringBufferExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait(millis, nanos);
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * join fun
+     * @param thread wait join thread
+     */
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new StringBufferExObjectwait11());
+        Thread t2 = new Thread(new StringBufferExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringBufferExObjectwait21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringBufferExObjectwait31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+
+        if (result == 2 && StringBufferExObjectwait.res == 54) {
+            result = 0;
+        }
+
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/StringBuilderExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/StringBuilderExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..110b7ced74ac1c8b580723099290a1fe3e653805
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/StringBuilderExObjectgetClass.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderExObjectgetClass.java
+ * -@TestCaseName: Exception in StringBuilder:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a StringBuilder object1
+ * -#step2: Call getClass() on Object1
+ * -#step3: Confirm that the returned Class is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBuilderExObjectgetClass.java
+ * -@ExecuteClass: StringBuilderExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.String;
+
+public class StringBuilderExObjectgetClass {
+    static int res = 99;
+    private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+
+    public static void main(String argv[]) {
+        System.out.println(new StringBuilderExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBuilderExObjectgetClass1();
+        } catch (Exception e) {
+            StringBuilderExObjectgetClass.res = StringBuilderExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && StringBuilderExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int stringBuilderExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+
+        StringBuilder sb = null;
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuilder(stringArray[i]);
+        }
+        Class px1 = sb.getClass();
+
+        if (px1.toString().equals("class java.lang.StringBuilder")) {
+            StringBuilderExObjectgetClass.res = StringBuilderExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/StringBuilderExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/StringBuilderExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a10f39c364be817142dbdbba486a52c47a27319
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/StringBuilderExObjecthashCode.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderExObjecthashCode.java
+ * -@TestCaseName: Exception in StringBuilder:   int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create Object1 by new StringBuilder(String name)
+ * -#step2: Create Object2 is given by Object2, Object3 by new StringBuilder(String name)
+ * -#step3: Check hashCode of the Object1 and Object2 is equal, check hashCode of the Object1 and Object3 is not equal.
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBuilderExObjecthashCode.java
+ * -@ExecuteClass: StringBuilderExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuilder;
+
+public class StringBuilderExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new StringBuilderExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBuilderExObjecthashCode1();
+        } catch (Exception e) {
+            StringBuilderExObjecthashCode.res = StringBuilderExObjecthashCode.res - 20;
+        }
+
+        if (result == 4 && StringBuilderExObjecthashCode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int stringBuilderExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //   int hashCode()
+
+        StringBuilder sb1 = new StringBuilder("aa");
+        StringBuilder sb2 = sb1;
+        StringBuilder sb3 = new StringBuilder("╬の〆");
+
+        if (sb1.hashCode() == sb2.hashCode() && sb1.hashCode() != sb3.hashCode()) {
+            StringBuilderExObjecthashCode.res = StringBuilderExObjecthashCode.res - 10;
+        } else {
+            StringBuilderExObjecthashCode.res = StringBuilderExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/StringBuilderExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/StringBuilderExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..050900f84023cbfbe84a48e3a215782af8c8e87c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/StringBuilderExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in StringBuilder:  final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBuilderExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: StringBuilderExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuilder;
+
+public class StringBuilderExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder sb = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(new StringBuilderExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBuilderExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new StringBuilderExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && StringBuilderExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int stringBuilderExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            sb.notifyAll();
+            StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class StringBuilderExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+
+        private StringBuilderExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notifyAll();
+                    StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/StringBuilderExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/StringBuilderExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..22aa3801532f10cd133e31499993be68819e0bea
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/StringBuilderExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in StringBuilder:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBuilderExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: StringBuilderExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuilder;
+
+public class StringBuilderExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder sb = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(new StringBuilderExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBuilderExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new StringBuilderExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && StringBuilderExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int stringBuilderExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            sb.notify();
+            StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class StringBuilderExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private StringBuilderExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notify();
+                    StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/StringBuilderExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/StringBuilderExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..208b5ca80c9a01f1189ea3ec8f84d4bbb5616d70
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/StringBuilderExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in StringBuilder: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBuilderExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: StringBuilderExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuilder;
+
+public class StringBuilderExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder mf2 = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            mf2 = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(new StringBuilderExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class StringBuilderExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+
+        private StringBuilderExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class StringBuilderExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+
+        private StringBuilderExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringBuilderExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringBuilderExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && StringBuilderExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/StringBuilderExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/StringBuilderExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1acbf82beef4659d6efe66f8c6df18de4d351b2
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/StringBuilderExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in StringBuilder: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBuilderExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: StringBuilderExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuilder;
+
+public class StringBuilderExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder mf2 = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            mf2 = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = stringBuilderExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = stringBuilderExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = stringBuilderExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && StringBuilderExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int stringBuilderExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            mf2.wait();
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int stringBuilderExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int stringBuilderExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/StringBuilderExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/StringBuilderExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..b349fbf148d914175aa266a0d892ffa2490bbea2
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/StringBuilderExObjectwait.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderExObjectwait.java
+ * -@TestCaseName: Exception in StringBuilder: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringBuilderExObjectwait.java
+ * -@ExecuteClass: StringBuilderExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.StringBuilder;
+
+public class StringBuilderExObjectwait {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder sb = null;
+
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(new StringBuilderExObjectwait().run());
+    }
+
+    private class StringBuilderExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private StringBuilderExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait();
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    // System.out.println("111");
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    // System.out.println("222");
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+
+    private class StringBuilderExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+
+        private StringBuilderExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                sb.notify();
+                try {
+                    sb.wait(millis);
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    private class StringBuilderExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+
+        private StringBuilderExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait(millis, nanos);
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * join fun
+     * @param thread wait join thread
+     */
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new StringBuilderExObjectwait11(1));
+        Thread t2 = new Thread(new StringBuilderExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringBuilderExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringBuilderExObjectwait31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        t1.interrupt();
+
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+
+
+        if (result == 2 && StringBuilderExObjectwait.res == 54) {
+            result = 0;
+        }
+
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0128-rt-parent-StringExObjectgetClass/StringExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0128-rt-parent-StringExObjectgetClass/StringExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..3f8edcea6e025448bba438c05e49b4f51ba374f2
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0128-rt-parent-StringExObjectgetClass/StringExObjectgetClass.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringExObjectgetClass.java
+ * -@TestCaseName: Exception in String:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a String object1
+ * -#step2: Call getClass() on Object1
+ * -#step3: Confirm that the returned Class is correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringExObjectgetClass.java
+ * -@ExecuteClass: StringExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Class;
+
+public class StringExObjectgetClass {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringExObjectgetClass1();
+        } catch (Exception e) {
+            StringExObjectgetClass.res = StringExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && StringExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int stringExObjectgetClass1() {
+        //  final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        String tr2 = "this is a test";
+        Class<? extends String> cls1 = tr2.getClass();
+
+        if (cls1.toString().equals("class java.lang.String")) {
+            StringExObjectgetClass.res = StringExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/StringExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/StringExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1d252ec3ce82982d7ffe9049e42efb9f9218196
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/StringExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in String:  final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: StringExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class StringExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    String mf2 = "this is a test";
+
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new StringExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && StringExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int stringExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            mf2.notifyAll();
+            StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class StringExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notifyAll();
+                    StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/StringExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/StringExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..9bdb194825ff7e8fa150fe7f522f7c0cd9a4e81c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/StringExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in String:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: StringExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class StringExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    String mf2 = "this is a test";
+
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new StringExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && StringExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int stringExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            mf2.notify();
+            StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class StringExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notify();
+                    StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/StringExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/StringExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..d15dffa6a0b39407eb9ba523d4aef895d7741e60
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/StringExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in String: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: StringExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class StringExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private static String mf2 = "this is a test";
+
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class StringExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class StringExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && StringExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/StringExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/StringExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce5d18fdbd95c46a58f7415b44fb1cf90b8ef488
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/StringExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in String: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: StringExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class StringExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static String mf2 = "this is a test";
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = stringExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = stringExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = stringExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && StringExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int stringExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            mf2.wait();
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int stringExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private static int stringExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0133-rt-parent-StringExObjectwait/StringExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0133-rt-parent-StringExObjectwait/StringExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..215a9aaae40c4d93575ee6adbb70079d3063d95c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0133-rt-parent-StringExObjectwait/StringExObjectwait.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringExObjectwait.java
+ * -@TestCaseName: Exception in String: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringExObjectwait.java
+ * -@ExecuteClass: StringExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class StringExObjectwait {
+    static int res = 99;
+    private String mf2 = "this is a test";
+    static Thread t2;
+
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectwait().run());
+        t2.interrupt();
+    }
+
+    private class StringExObjectwait11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait();
+                    StringExObjectwait.res = StringExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwait.res = StringExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwait.res = StringExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+
+    private class StringExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notify();
+                try {
+                    mf2.wait(millis);
+                    StringExObjectwait.res = StringExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwait.res = StringExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwait.res = StringExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringExObjectwait.res = StringExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    private class StringExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    StringExObjectwait.res = StringExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwait.res = StringExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwait.res = StringExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringExObjectwait.res = StringExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * join fun
+     * @param thread wait join thread
+     */
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new StringExObjectwait11());
+        t2 = new Thread(new StringExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringExObjectwait21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringExObjectwait31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+
+        if (result == 2 && StringExObjectwait.res == 54) {
+            result = 0;
+        }
+
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/ThreadExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/ThreadExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..ace675a501bfa8ad3114f1c984f3821d3109b73a
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/ThreadExObjecthashCode.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadExObjecthashCode.java
+ * -@TestCaseName: Exception in Thread: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create Object1 by new Thread()
+ * -#step2: Create Object2 is given by Object2, Object3 by new Thread()
+ * -#step3: Check hashCode of the Object1 and Object2 is equal, check hashCode of the Object1 and Object3 is not equal.
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadExObjecthashCode.java
+ * -@ExecuteClass: ThreadExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadExObjecthashCode1();
+        } catch (Exception e) {
+            ThreadExObjecthashCode.res = ThreadExObjecthashCode.res - 20;
+        }
+        if (result == 4 && ThreadExObjecthashCode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int threadExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+
+        Thread thr1 = new Thread();
+        Thread thr2 = thr1;
+        Thread thr3 = new Thread();
+        thr1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        thr2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        thr3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+
+        if (thr1.hashCode() == thr2.hashCode() && thr1.hashCode() != thr3.hashCode()) {
+            ThreadExObjecthashCode.res = ThreadExObjecthashCode.res - 10;
+        } else {
+            ThreadExObjecthashCode.res = ThreadExObjecthashCode.res - 5;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/ThreadExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/ThreadExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a4de024e51e28c8afd7a85bcee5616b8fe9db66
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/ThreadExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Thread:  final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ThreadExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    Thread sb = new Thread();
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ThreadExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        sb.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ThreadExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int threadExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            sb.notifyAll();
+            ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private class ThreadExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+
+        private ThreadExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notifyAll();
+                    ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/ThreadExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/ThreadExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5474a68baeaa630bc700e288c550d63c0a45a1b
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/ThreadExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Thread:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notify() inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notify() in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ThreadExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    Thread sb = new Thread();
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ThreadExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        sb.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ThreadExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int threadExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            sb.notify();
+            ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ThreadExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ThreadExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notify();
+                    ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/ThreadExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/ThreadExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f65d26326a1826113585370602bbc41bf1f862a
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/ThreadExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in Thread: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: ThreadExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private Thread mf2 = new Thread();
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class ThreadExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+
+        private ThreadExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ThreadExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+
+        private ThreadExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadExObjectwaitIllegalArgumentException31(5));
+        mf2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ThreadExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/ThreadExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/ThreadExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a882cd955a8bee1cb91d1c063cbdd333ac06a8b
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/ThreadExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Thread: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ThreadExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static Thread mf2 = new Thread();
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        mf2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        // final void wait()
+        try {
+            result = threadExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = threadExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = threadExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && ThreadExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int threadExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            mf2.wait();
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int threadExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int threadExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0139-rt-parent-ThreadExObjectwait/ThreadExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0139-rt-parent-ThreadExObjectwait/ThreadExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..afb260b978b5fde7dcc20a754c5941c8c15a3e6f
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0139-rt-parent-ThreadExObjectwait/ThreadExObjectwait.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadExObjectwait.java
+ * -@TestCaseName: Exception in Thread: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, and call wait (), wait (millis), wait (millis, nanos)
+ *          in run respectively
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: execute the start () method of the private class 2.
+ * -#step4: execute the start () method of the private class 3.
+ * -#step5: execute the start () method of the private class 1.
+ * -#step6: Wait for 2 ~ 4 threads to finish running, confirm that wait ends successfully, no exception is thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadExObjectwait.java
+ * -@ExecuteClass: ThreadExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadExObjectwait {
+    static int res = 99;
+    Thread sb = new Thread();
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjectwait().run());
+    }
+
+    private class ThreadExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private ThreadExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait();
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ThreadExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+
+        private ThreadExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                sb.notify();
+                try {
+                    sb.wait(millis);
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ThreadExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+
+        private ThreadExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait(millis, nanos);
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void sbSetUncaught() {
+        sb.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThreadExObjectwait11(1));
+        Thread t2 = new Thread(new ThreadExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadExObjectwait31(5));
+        sbSetUncaught();
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+
+        if (result == 2 && ThreadExObjectwait.res == 54) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/ThreadGroupExObjectequals.java b/test/testsuite/ouroboros/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/ThreadGroupExObjectequals.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c75f9ccecdb95234fc8631f8274a2a9ed217afe
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/ThreadGroupExObjectequals.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupExObjectequals.java
+ * -@TestCaseName: Exception in ThreadGroup:  boolean equals(Object obj)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Created ThreadGroup Object1 by new ThreadGroup(String name)
+ * -#step2: Created ThreadGroup Object2 by new ThreadGroup(String name) the same as Object1
+ * -#step3: call equals(Object obj), and check the result is correctly.
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadGroupExObjectequals.java
+ * -@ExecuteClass: ThreadGroupExObjectequals
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadGroupExObjectequals {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectequals().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjectequals1();
+        } catch (Exception e) {
+            ThreadGroupExObjectequals.res = ThreadGroupExObjectequals.res - 20;
+        }
+
+
+        if (result == 4 && ThreadGroupExObjectequals.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int threadGroupExObjectequals1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // boolean equals(Object obj)
+        ThreadGroup gr1 = new ThreadGroup("Thread3251");
+        ThreadGroup gr2 = new ThreadGroup("Thread3252");
+        boolean ret = gr1.equals(gr2);
+        if (!ret) {
+            ThreadGroupExObjectequals.res = ThreadGroupExObjectequals.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/ThreadGroupExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/ThreadGroupExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..03cd1e85ca955b6593246cedd7fe839f65f9f41c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/ThreadGroupExObjectgetClass.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupExObjectgetClass.java
+ * -@TestCaseName: Exception in ThreadGroup:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test api getClass extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadGroupExObjectgetClass.java
+ * -@ExecuteClass: ThreadGroupExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadGroupExObjectgetClass {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjectgetClass1();
+        } catch (Exception e) {
+            ThreadGroupExObjectgetClass.res = ThreadGroupExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && ThreadGroupExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int threadGroupExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+        ThreadGroup gr1 = new ThreadGroup("Thread8023");
+        Class px1 = gr1.getClass();
+
+        if (px1.toString().equals("class java.lang.ThreadGroup")) {
+            ThreadGroupExObjectgetClass.res = ThreadGroupExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/ThreadGroupExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/ThreadGroupExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e8d4cbcf84fb0eb52b5444ec5e0433aca4a8440
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/ThreadGroupExObjecthashCode.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupExObjecthashCode.java
+ * -@TestCaseName: Exception in ThreadGroup: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test api hashCode extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadGroupExObjecthashCode.java
+ * -@ExecuteClass: ThreadGroupExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.ThreadGroup;
+
+public class ThreadGroupExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjecthashCode1();
+        } catch (Exception e) {
+            ThreadGroupExObjecthashCode.res = ThreadGroupExObjecthashCode.res - 20;
+        }
+
+        if (result == 4 && ThreadGroupExObjecthashCode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int threadGroupExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+
+        ThreadGroup gr1 = new ThreadGroup("Thread8023");
+        ThreadGroup gr2 = gr1;
+        ThreadGroup gr3 = new ThreadGroup("Thread1988");
+
+        if (gr1.hashCode() == gr2.hashCode() && gr1.hashCode() != gr3.hashCode()) {
+            ThreadGroupExObjecthashCode.res = ThreadGroupExObjecthashCode.res - 10;
+        } else {
+            ThreadGroupExObjecthashCode.res = ThreadGroupExObjecthashCode.res - 5;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/ThreadGroupExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/ThreadGroupExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8a47faa8580dab779e6ad9f6af80b83f4c4383b
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/ThreadGroupExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in ThreadGroup:  final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test api notifyAll extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadGroupExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ThreadGroupExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadGroupExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    ThreadGroup gr1 = new ThreadGroup("Thread8023");
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ThreadGroupExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int threadGroupExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            gr1.notifyAll();
+            ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ThreadGroupExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+
+        private ThreadGroupExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (gr1) {
+                try {
+                    gr1.notifyAll();
+                    ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/ThreadGroupExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/ThreadGroupExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..a4e98eaddbb25dee8ea1122bbe6ef3a7fd785ebd
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/ThreadGroupExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in ThreadGroup:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test api notify extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadGroupExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ThreadGroupExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadGroupExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private ThreadGroup gr1 = new ThreadGroup("Thread8023");
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ThreadGroupExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ThreadGroupExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int threadGroupExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            gr1.notify();
+            ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ThreadGroupExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ThreadGroupExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (gr1) {
+                try {
+                    gr1.notify();
+                    ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/ThreadGroupExObjecttoString.java b/test/testsuite/ouroboros/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/ThreadGroupExObjecttoString.java
new file mode 100644
index 0000000000000000000000000000000000000000..5162e18f8635f2ed13b5b1ae008026f2a8922dc0
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/ThreadGroupExObjecttoString.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupExObjecttoString.java
+ * -@TestCaseName: Exception in ThreadGroup:  String toString()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test api toString extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadGroupExObjecttoString.java
+ * -@ExecuteClass: ThreadGroupExObjecttoString
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadGroupExObjecttoString {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjecttoString().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjecttoString1();
+        } catch (Exception e) {
+            ThreadGroupExObjecttoString.res = ThreadGroupExObjecttoString.res - 20;
+        }
+
+
+        if (result == 4 && ThreadGroupExObjecttoString.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int threadGroupExObjecttoString1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // String toString()
+        ThreadGroup gr1 = new ThreadGroup("Thread8023");
+        String str1 = gr1.toString();
+
+        if (str1.equals("java.lang.ThreadGroup[name=Thread8023,maxpri=10]")) {
+            ThreadGroupExObjecttoString.res = ThreadGroupExObjecttoString.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/ThreadGroupExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/ThreadGroupExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd7ab98d0d2f02654d78d6d8339da8691f20b8b6
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/ThreadGroupExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in ThreadGroup: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Test api wait extends from Object
+ * -#step2:Give the value of timeout is negative or the value of nanos is not in the range 0-999999
+ * -#step3:Throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadGroupExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: ThreadGroupExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadGroupExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    ThreadGroup gr1 = new ThreadGroup("Thread8023");
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class ThreadGroupExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+
+        private ThreadGroupExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait(millis);
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ThreadGroupExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+
+        private ThreadGroupExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait(millis, nanos);
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadGroupExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadGroupExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ThreadGroupExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/ThreadGroupExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/ThreadGroupExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c195be41dd070be1535d180794ef2e4a958b7ab2
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/ThreadGroupExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in ThreadGroup: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare the current thread is not the owner of the object's monitor.
+ * -#step2:Test api wait extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadGroupExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ThreadGroupExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.ThreadGroup;
+
+public class ThreadGroupExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static ThreadGroup gr1 = new ThreadGroup("Thread8023");
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = threadGroupExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = threadGroupExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = threadGroupExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && ThreadGroupExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int threadGroupExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            gr1.wait();
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int threadGroupExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            gr1.wait(millis);
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int threadGroupExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            gr1.wait(millis, nanos);
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/ThreadGroupExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/ThreadGroupExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc61fea083c8d530b285e0e34e1a9731cf5fdad2
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/ThreadGroupExObjectwaitInterruptedException.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in ThreadGroup: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Test api wait extends from Object
+ * -#step2:Thread is interruptted when wait
+ * -#step3:Throw InterruptedException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadGroupExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ThreadGroupExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.ThreadGroup;
+
+public class ThreadGroupExObjectwaitInterruptedException {
+    static int res = 99;
+    private static ThreadGroup gr1 = new ThreadGroup("Thread8023");
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectwaitInterruptedException().run());
+    }
+
+    private class ThreadGroupExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+
+        private int remainder;
+
+        private ThreadGroupExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait();
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ThreadGroupExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+
+        private ThreadGroupExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait(millis);
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ThreadGroupExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+
+        private ThreadGroupExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait(millis, nanos);
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThreadGroupExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadGroupExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadGroupExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+
+        if (result == 2 && ThreadGroupExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/ThreadLocalExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/ThreadLocalExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..642647d0f0136bb288ae9d2039a2632b0d0067db
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/ThreadLocalExObjectgetClass.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadLocalExObjectgetClass.java
+ * -@TestCaseName: Exception in ThreadLocal:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test ThreadLocal api getClass extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadLocalExObjectgetClass.java
+ * -@ExecuteClass: ThreadLocalExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.ThreadLocal;
+
+public class ThreadLocalExObjectgetClass {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjectgetClass1();
+        } catch (Exception e) {
+            ThreadLocalExObjectgetClass.res = ThreadLocalExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && ThreadLocalExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int threadLocalExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+        ThreadLocal<Object> threadLocal1 = new ThreadLocal<Object>();
+        Class px1 = threadLocal1.getClass();
+
+        if (px1.toString().equals("class java.lang.ThreadLocal")) {
+            ThreadLocalExObjectgetClass.res = ThreadLocalExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/ThreadLocalExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/ThreadLocalExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc44825daca8afb3add64c0a1cb8c56aabf3998f
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/ThreadLocalExObjecthashCode.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadLocalExObjecthashCode.java
+ * -@TestCaseName: Exception in ThreadLocal: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test ThreadLocal api hashCode extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadLocalExObjecthashCode.java
+ * -@ExecuteClass: ThreadLocalExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.ThreadLocal;
+
+public class ThreadLocalExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjecthashCode1();
+        } catch (Exception e) {
+            ThreadLocalExObjecthashCode.res = ThreadLocalExObjecthashCode.res - 20;
+        }
+
+        if (result == 4 && ThreadLocalExObjecthashCode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int threadLocalExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+
+        ThreadLocal<Object> threadLocal1 = new ThreadLocal<Object>();
+        ThreadLocal<Object> threadLocal2 = threadLocal1;
+        ThreadLocal<Object> threadLocal3 = new ThreadLocal<Object>();
+
+        if (threadLocal1.hashCode() == threadLocal2.hashCode() && threadLocal1.hashCode() != threadLocal3.hashCode()) {
+            ThreadLocalExObjecthashCode.res = ThreadLocalExObjecthashCode.res - 10;
+        } else {
+            ThreadLocalExObjecthashCode.res = ThreadLocalExObjecthashCode.res - 5;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/ThreadLocalExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/ThreadLocalExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a1143f2edab5942fe0a984f3aecc20b9129b127
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/ThreadLocalExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadLocalExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in ThreadLocal: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test ThreadLocal api notifyAll extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadLocalExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ThreadLocalExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadLocalExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    ThreadLocal<Object> tl1 = new ThreadLocal<Object>();
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ThreadLocalExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int threadLocalExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            tl1.notifyAll();
+            ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ThreadLocalExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+
+        private ThreadLocalExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (tl1) {
+                try {
+                    tl1.notifyAll();
+                    ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/ThreadLocalExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/ThreadLocalExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..133e2ac888155bf1a50effa76c0899600d5d1c73
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/ThreadLocalExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadLocalExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in ThreadLocal:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test ThreadLocal api notify extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadLocalExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ThreadLocalExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.ThreadLocal;
+
+public class ThreadLocalExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private ThreadLocal<Object> tl1 = new ThreadLocal<Object>();
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ThreadLocalExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ThreadLocalExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int threadLocalExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            tl1.notify();
+            ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ThreadLocalExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ThreadLocalExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (tl1) {
+                try {
+                    tl1.notify();
+                    ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/ThreadLocalExObjecttoString.java b/test/testsuite/ouroboros/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/ThreadLocalExObjecttoString.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8ac258ff71d737267c72f11da39e3e0c9ae5334
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/ThreadLocalExObjecttoString.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadLocalExObjecttoString.java
+ * -@TestCaseName: Exception in ThreadLocal:  String toString()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test ThreadLocal api toString extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadLocalExObjecttoString.java
+ * -@ExecuteClass: ThreadLocalExObjecttoString
+ * -@ExecuteArgs:
+ */
+
+import java.lang.ThreadLocal;
+
+public class ThreadLocalExObjecttoString {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjecttoString().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjecttoString1();
+        } catch (Exception e) {
+            ThreadLocalExObjecttoString.res = ThreadLocalExObjecttoString.res - 20;
+        }
+
+        if (result == 4 && ThreadLocalExObjecttoString.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int threadLocalExObjecttoString1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // String toString()
+
+        ThreadLocal<Object> threadLocal1 = new ThreadLocal<Object>();
+        String str1 = threadLocal1.toString();
+        if (str1.contains("java.lang.ThreadLocal")) {
+            ThreadLocalExObjecttoString.res = ThreadLocalExObjecttoString.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/ThreadLocalExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/ThreadLocalExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9010e2f4b705b664ddd9bb458c31eeada049caf
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/ThreadLocalExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadLocalExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in ThreadLocal: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Test ThreadLocal api wait extends from Object
+ * -#step2:Give the value of timeout is negative or the value of nanos is not in the range 0-999999
+ * -#step3:Throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadLocalExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: ThreadLocalExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadLocalExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    ThreadLocal<Object> tl1 = new ThreadLocal<Object>();
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class ThreadLocalExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+
+        private ThreadLocalExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait(millis);
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ThreadLocalExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+
+        private ThreadLocalExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait(millis, nanos);
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadLocalExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadLocalExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ThreadLocalExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/ThreadLocalExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/ThreadLocalExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0bcc76599e021a04b44c224c51d7c9791e26249
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/ThreadLocalExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadLocalExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in ThreadLocal: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test ThreadLocal api wait extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadLocalExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ThreadLocalExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadLocalExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static ThreadLocal<Object> tl1 = new ThreadLocal<>();
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = threadLocalExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = threadLocalExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = threadLocalExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && ThreadLocalExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int threadLocalExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            tl1.wait();
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int threadLocalExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            tl1.wait(millis);
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int threadLocalExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            tl1.wait(millis, nanos);
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/ThreadLocalExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/ThreadLocalExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..7959da359029e9e85a8f836fee159eefb236a1b6
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/ThreadLocalExObjectwaitInterruptedException.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadLocalExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in ThreadLocal: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Test ThreadLocal api wait extends from Object
+ * -#step2:Thread is interruptted when wait
+ * -#step3:Throw InterruptedException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThreadLocalExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ThreadLocalExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThreadLocalExObjectwaitInterruptedException {
+    static int res = 99;
+    static ThreadLocal<Object> tl1 = new ThreadLocal<>();
+
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectwaitInterruptedException().run());
+    }
+
+    private class ThreadLocalExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private ThreadLocalExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait();
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ThreadLocalExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+
+        private ThreadLocalExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait(millis);
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ThreadLocalExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+
+        private ThreadLocalExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait(millis, nanos);
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThreadLocalExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadLocalExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadLocalExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+
+        if (result == 2 && ThreadLocalExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/ThrowableExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/ThrowableExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..84ecd05cc49284ad6775000fb525b4955257cb5c
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/ThrowableExObjecthashCode.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThrowableExObjecthashCode.java
+ * -@TestCaseName: Exception in Throwable: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test Throwable api hashCode extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThrowableExObjecthashCode.java
+ * -@ExecuteClass: ThrowableExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Throwable;
+
+public class ThrowableExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = throwableExObjecthashCode1();
+        } catch (Exception e) {
+            ThrowableExObjecthashCode.res = ThrowableExObjecthashCode.res - 20;
+        }
+
+        if (result == 4 && ThrowableExObjecthashCode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int throwableExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+
+        Throwable cause1 = new Throwable("detailed message of cause1");
+        Throwable cause2 = cause1;
+        Throwable cause3 = new Throwable("detailed message of cause3");
+
+        if (cause1.hashCode() == cause2.hashCode() && cause1.hashCode() != cause3.hashCode()) {
+            ThrowableExObjecthashCode.res = ThrowableExObjecthashCode.res - 10;
+        } else {
+            ThrowableExObjecthashCode.res = ThrowableExObjecthashCode.res - 5;
+        }
+
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/ThrowableExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/ThrowableExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6f07aa6f0e7ec7f00d535b9be9827276d4c7a88
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/ThrowableExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThrowableExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Throwable: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test Throwable api notifyAll extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThrowableExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: ThrowableExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThrowableExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private Throwable cause = new Throwable("detailed message of cause");
+
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = throwableExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ThrowableExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ThrowableExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int throwableExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        //  final void notifyAll()
+        try {
+            cause.notifyAll();
+            ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ThrowableExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+
+        private ThrowableExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                try {
+                    cause.notifyAll();
+                    ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/ThrowableExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/ThrowableExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e00d50f3ca0be6437c700567a3f4002ecd21685
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/ThrowableExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThrowableExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Throwable:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test Throwable api notify extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThrowableExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: ThrowableExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThrowableExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private Throwable cause = new Throwable("detailed message of cause");
+
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = throwableExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new ThrowableExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && ThrowableExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int throwableExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            cause.notify();
+            ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class ThrowableExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private ThrowableExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                try {
+                    cause.notify();
+                    ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/ThrowableExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/ThrowableExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..b314fb23687a4d02bf691f3bdcdfbb4eef3e73dc
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/ThrowableExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThrowableExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in Throwable: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Test Throwable api wait extends from Object
+ * -#step2:Give the value of timeout is negative or the value of nanos is not in the range 0-999999
+ * -#step3:Throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThrowableExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: ThrowableExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class ThrowableExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private Throwable cause = new Throwable("detailed message of cause");
+
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class ThrowableExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+
+        private ThrowableExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis);
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ThrowableExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+
+        private ThrowableExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis, nanos);
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThrowableExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThrowableExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ThrowableExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/ThrowableExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/ThrowableExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..f310f5d0d6fdef86e4a167ef47a2b826ce6cdbdd
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/ThrowableExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThrowableExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Throwable: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test Throwable api notifyAll extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThrowableExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ThrowableExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Throwable;
+
+public class ThrowableExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Throwable cause = new Throwable("detailed message of cause");
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = throwableExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = throwableExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = throwableExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && ThrowableExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int throwableExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            cause.wait();
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int throwableExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            cause.wait(millis);
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int throwableExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            cause.wait(millis, nanos);
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/ThrowableExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/ThrowableExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..9168375b535b6709c58f2a2f512fb405e7786983
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/ThrowableExObjectwaitInterruptedException.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThrowableExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in Throwable: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Test Throwable api wait extends from Object
+ * -#step2:Thread is interruptted when wait
+ * -#step3:Throw InterruptedException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThrowableExObjectwaitInterruptedException.java
+ * -@ExecuteClass: ThrowableExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Throwable;
+
+public class ThrowableExObjectwaitInterruptedException {
+    static int res = 99;
+    static Throwable cause = new Throwable("detailed message of cause");
+
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectwaitInterruptedException().run());
+    }
+
+    private class ThrowableExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private ThrowableExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait();
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ThrowableExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+
+        private ThrowableExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis);
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ThrowableExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+
+        private ThrowableExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis, nanos);
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThrowableExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThrowableExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThrowableExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+
+        if (result == 2 && ThrowableExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0163-rt-parent-ThrowableExObjectwait/ThrowableExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0163-rt-parent-ThrowableExObjectwait/ThrowableExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..c477878c301e71e72ba0f1f6d040f410fdc003ae
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0163-rt-parent-ThrowableExObjectwait/ThrowableExObjectwait.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThrowableExObjectwait.java
+ * -@TestCaseName: Exception in Throwable: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test Throwable api wait extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ThrowableExObjectwait.java
+ * -@ExecuteClass: ThrowableExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Throwable;
+
+public class ThrowableExObjectwait {
+    static int res = 99;
+    private Throwable cause = new Throwable("detailed message of cause");
+
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectwait().run());
+    }
+
+    private class ThrowableExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private ThrowableExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait();
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+
+    private class ThrowableExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+
+        private ThrowableExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                cause.notify();
+                try {
+                    cause.wait(millis);
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ThrowableExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+
+        private ThrowableExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis, nanos);
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * join fun
+     * @param thread wait join thread
+     */
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThrowableExObjectwait11(1));
+        Thread t2 = new Thread(new ThrowableExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThrowableExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThrowableExObjectwait31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+
+
+        if (result == 2 && ThrowableExObjectwait.res == 54) {
+            result = 0;
+        }
+
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/UnicodeBlockExObjectgetClass.java b/test/testsuite/ouroboros/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/UnicodeBlockExObjectgetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..071831fb1be0cebbce80628087fac26c4c3027e8
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/UnicodeBlockExObjectgetClass.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnicodeBlockExObjectgetClass.java
+ * -@TestCaseName: Exception in Character/UnicodeBlock:  final Class<?> getClass()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test UnicodeBlock api getClass extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnicodeBlockExObjectgetClass.java
+ * -@ExecuteClass: UnicodeBlockExObjectgetClass
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Character;
+
+public class UnicodeBlockExObjectgetClass {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new UnicodeBlockExObjectgetClass().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjectgetClass1();
+        } catch (Exception e) {
+            UnicodeBlockExObjectgetClass.res = UnicodeBlockExObjectgetClass.res - 20;
+        }
+
+        if (result == 4 && UnicodeBlockExObjectgetClass.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+
+    private int unicodeBlockExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // final Class<?> getClass()
+        Character.UnicodeBlock unB1 = null;
+        for (int cp = 0; cp <= 10; ++cp) {
+            unB1 = Character.UnicodeBlock.of(cp);
+        }
+
+        Class px1 = unB1.getClass();
+
+        if (px1.toString().equals("class java.lang.Character$UnicodeBlock")) {
+            UnicodeBlockExObjectgetClass.res = UnicodeBlockExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/UnicodeBlockExObjecthashCode.java b/test/testsuite/ouroboros/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/UnicodeBlockExObjecthashCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..41cb0e3e2013f416f2e61a0e86429c23410d8a55
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/UnicodeBlockExObjecthashCode.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnicodeBlockExObjecthashCode.java
+ * -@TestCaseName: Exception in Character/UnicodeBlock: int hashCode()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test UnicodeBlock api hashCode extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnicodeBlockExObjecthashCode.java
+ * -@ExecuteClass: UnicodeBlockExObjecthashCode
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Character;
+
+public class UnicodeBlockExObjecthashCode {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new UnicodeBlockExObjecthashCode().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjecthashCode1();
+        } catch (Exception e) {
+            UnicodeBlockExObjecthashCode.res = UnicodeBlockExObjecthashCode.res - 20;
+        }
+
+        if (result == 4 && UnicodeBlockExObjecthashCode.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int unicodeBlockExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        Character.UnicodeBlock unB1 = Character.UnicodeBlock.of(10);
+        Character.UnicodeBlock unB2 = Character.UnicodeBlock.of(10);
+        Character.UnicodeBlock unB3 = Character.UnicodeBlock.of('〆');
+
+        if (unB1.hashCode() == unB2.hashCode() && unB1.hashCode() != unB3.hashCode()) {
+            UnicodeBlockExObjecthashCode.res = UnicodeBlockExObjecthashCode.res - 10;
+        } else {
+            UnicodeBlockExObjecthashCode.res = UnicodeBlockExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c871f4b48654da42a41681b536223488aa3b068d
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Character/UnicodeBlock: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test UnicodeBlock api notifyAll extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: UnicodeBlockExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Character;
+
+public class UnicodeBlockExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private static Character.UnicodeBlock unb1 = null;
+
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(new UnicodeBlockExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new UnicodeBlockExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int unicodeBlockExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            unb1.notifyAll();
+            UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class UnicodeBlockExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+
+        private UnicodeBlockExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (unb1) {
+                try {
+                    unb1.notifyAll();
+                    UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/UnicodeBlockExObjectnotifyIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/UnicodeBlockExObjectnotifyIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..774bf59f96e11400a13668a157b30d0299f4bfc2
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/UnicodeBlockExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnicodeBlockExObjectnotifyIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Character/UnicodeBlock:  final void notify()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test UnicodeBlock api notifyAll extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnicodeBlockExObjectnotifyIllegalMonitorStateException.java
+ * -@ExecuteClass: UnicodeBlockExObjectnotifyIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Character;
+
+public class UnicodeBlockExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    static Character.UnicodeBlock unb1 = null;
+
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(new UnicodeBlockExObjectnotifyIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+
+        Thread t1 = new Thread(new UnicodeBlockExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (result == 4 && UnicodeBlockExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int unicodeBlockExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            unb1.notify();
+            UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private class UnicodeBlockExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+
+        private UnicodeBlockExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (unb1) {
+                try {
+                    unb1.notify();
+                    UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/UnicodeBlockExObjecttoString.java b/test/testsuite/ouroboros/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/UnicodeBlockExObjecttoString.java
new file mode 100644
index 0000000000000000000000000000000000000000..8a46451936b60ae94ae7d6e4d87f6ae88e3fb369
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/UnicodeBlockExObjecttoString.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnicodeBlockExObjecttoString.java
+ * -@TestCaseName: Exception in Character/UnicodeBlock: final String toString()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test UnicodeBlock api toString extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnicodeBlockExObjecttoString.java
+ * -@ExecuteClass: UnicodeBlockExObjecttoString
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Character;
+
+public class UnicodeBlockExObjecttoString {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(new UnicodeBlockExObjecttoString().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjecttoString1();
+        } catch (Exception e) {
+            UnicodeBlockExObjecttoString.res = UnicodeBlockExObjecttoString.res - 20;
+        }
+
+        if (result == 4 && UnicodeBlockExObjecttoString.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private int unicodeBlockExObjecttoString1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // final String toString()
+        Character.UnicodeBlock unB1 = null;
+        for (int cp = 0; cp <= 10; ++cp) {
+            unB1 = Character.UnicodeBlock.of(cp);
+        }
+
+        String px1 = unB1.toString();
+        if (px1.equals("BASIC_LATIN")) {
+            UnicodeBlockExObjecttoString.res = UnicodeBlockExObjecttoString.res - 10;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/UnicodeBlockExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/UnicodeBlockExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..dcdab80bb45551bca93dc501311b3b8a079752f0
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/UnicodeBlockExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnicodeBlockExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Character/UnicodeBlock: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Prepare current thread is not the owner of the object's monitor
+ * -#step2:Test UnicodeBlock api wait extends from Object
+ * -#step3:Throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnicodeBlockExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: UnicodeBlockExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Character;
+
+public class UnicodeBlockExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Character.UnicodeBlock unb1 = null;
+
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = unicodeBlockExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = unicodeBlockExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = unicodeBlockExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && UnicodeBlockExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int unicodeBlockExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            unb1.wait();
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int unicodeBlockExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            unb1.wait(millis);
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int unicodeBlockExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            unb1.wait(millis, nanos);
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/UnicodeBlockExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/UnicodeBlockExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4e450ced76f4efdd590a005c520015459c8e618
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/UnicodeBlockExObjectwaitInterruptedException.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnicodeBlockExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in Character/UnicodeBlock: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1:Test UnicodeBlock api wait extends from Object
+ * -#step2:Thread is interruptted when wait
+ * -#step3:Throw InterruptedException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnicodeBlockExObjectwaitInterruptedException.java
+ * -@ExecuteClass: UnicodeBlockExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Character;
+
+public class UnicodeBlockExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Character.UnicodeBlock unb1 = null;
+
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(new UnicodeBlockExObjectwaitInterruptedException().run());
+    }
+
+    private class UnicodeBlockExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+
+        private UnicodeBlockExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait();
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class UnicodeBlockExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+
+        private UnicodeBlockExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait(millis);
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class UnicodeBlockExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+
+        private UnicodeBlockExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait(millis, nanos);
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new UnicodeBlockExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new UnicodeBlockExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new UnicodeBlockExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+
+        if (result == 2 && UnicodeBlockExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/UnicodeBlockExObjectwait.java b/test/testsuite/ouroboros/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/UnicodeBlockExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..b7b6deab4ce7dd657cfc20337fa07ac1fb966c7e
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/UnicodeBlockExObjectwait.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnicodeBlockExObjectwait.java
+ * -@TestCaseName: Exception in Character/UnicodeBlock: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:Test UnicodeBlock api wait extends from Object
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnicodeBlockExObjectwait.java
+ * -@ExecuteClass: UnicodeBlockExObjectwait
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Character;
+
+public class UnicodeBlockExObjectwait {
+    static int res = 99;
+    private static Character.UnicodeBlock unb1 = null;
+
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(new UnicodeBlockExObjectwait().run());
+    }
+
+    private class UnicodeBlockExObjectwait11 implements Runnable {
+        // final void wait()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait();
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+
+    private class UnicodeBlockExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (unb1) {
+                unb1.notify();
+                try {
+                    unb1.wait(millis);
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    private class UnicodeBlockExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait(millis, nanos);
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+     */
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * join fun
+     * @param thread wait join thread
+     */
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     *
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new UnicodeBlockExObjectwait11());
+        Thread t2 = new Thread(new UnicodeBlockExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new UnicodeBlockExObjectwait21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new UnicodeBlockExObjectwait31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        sleep(1000);
+        t1.interrupt();
+
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+
+        if (result == 2 && UnicodeBlockExObjectwait.res == 54) {
+            result = 0;
+        }
+
+        t2.interrupt();
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/AccessibleObjectExObjectwaitInterruptedException.java b/test/testsuite/ouroboros/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/AccessibleObjectExObjectwaitInterruptedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..d1a621730eaa60d087b58bf5fb6ecd6d6a28c110
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/AccessibleObjectExObjectwaitInterruptedException.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AccessibleObjectExObjectwaitInterruptedException.java
+ * -@TestCaseName: Exception in reflect/AccessibleObject: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three private classes to implement Runnable, run sampleField1 as a synchronization lock, Call wait(),
+ *          wait (millis), wait (millis, nanos) respectively
+ * -#step2: Call the run of the use case, execute the start () method of the private class 1, and wait for 100
+ *          milliseconds to interrupt
+ * -#step3: Execute the start () method of private class 2 and wait for 100 milliseconds to interrupt
+ * -#step4: Execute the start () method of private class 3 and wait for 100 milliseconds to interrupt
+ * -#step5: Confirm whether all classes are successfully interrupted and InterruptedException is successfully caught
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: AccessibleObjectExObjectwaitInterruptedException.java
+ * -@ExecuteClass: AccessibleObjectExObjectwaitInterruptedException
+ * -@ExecuteArgs:
+ */
+
+
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectExObjectwaitInterruptedException {
+    static int res = 99;
+    private static AccessibleObject sampleField1 = null;
+
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = AccessibleObjectExObjectwaitInterruptedException.class.getDeclaredField("res");
+        System.out.println(new AccessibleObjectExObjectwaitInterruptedException().run());
+    }
+
+    private class AccessibleObjectExObjectwaitInterruptedException11 implements Runnable {
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait();
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+
+    private class AccessibleObjectExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis);
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class AccessibleObjectExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis, nanos);
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     * @param sleepNum wait time
+     */
+    public void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new AccessibleObjectExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new AccessibleObjectExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new AccessibleObjectExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+
+        if (result == 2 && AccessibleObjectExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/CharacterExObjectnotifyAllIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/CharacterExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..5754fd0bc003d1419f0dfe038f699955d168ba25
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/CharacterExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: CharacterExObjectnotifyAllIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in Character: final void notifyAll()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create a private class to implement Runnable, call notifyAll () inside run
+ * -#step2: Call the run of the use case, execute method 1, and call notifyAll () in the method
+ * -#step3: Execute the start () method of the private class and wait 100 milliseconds
+ * -#step4: Confirm method 1 throws an exception IllegalMonitorStateException, the class does not throw an exception
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: CharacterExObjectnotifyAllIllegalMonitorStateException.java
+ * -@ExecuteClass: CharacterExObjectnotifyAllIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.Thread;
+
+public class CharacterExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private char name = 'A';
+    private Character rp = new Character(name);
+
+    public static void main(String argv[]) {
+        System.out.println(new CharacterExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new CharacterExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && CharacterExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private int characterExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+
+    private class CharacterExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/ModifierExObjectwaitIllegalArgumentException.java b/test/testsuite/ouroboros/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/ModifierExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..df41951543dd4bcbf076bb84f7351906896528de
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/ModifierExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ModifierExObjectwaitIllegalArgumentException.java
+ * -@TestCaseName: Exception in reflect Modifier: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create 2 private classes to implement Runnable, and call wait (millis), wait (millis, nanos) respectively in run
+ * -#step2: Call the run of the use case and execute the start () method of the private class 1.
+ * -#step3: Execute the start () method of private class 2
+ * -#step4: Wait 1000 ms
+ * -#step5: Confirm that all classes throw IllegalArgumentException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ModifierExObjectwaitIllegalArgumentException.java
+ * -@ExecuteClass: ModifierExObjectwaitIllegalArgumentException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class ModifierExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    static Modifier mf2 = new Modifier();
+
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectwaitIllegalArgumentException().run());
+    }
+
+    private class ModifierExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+
+        private ModifierExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    private class ModifierExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+
+        private ModifierExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+
+        /**
+         * Thread run fun
+         */
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+
+    /**
+     * sleep fun
+     * @param slpNum wait time
+     */
+    public void sleep(int slpNum) {
+        try {
+            Thread.sleep(slpNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        //  final void wait(long millis)
+        Thread t3 = new Thread(new ModifierExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ModifierExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ModifierExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+
+        return result;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/ModifierExObjectwaitIllegalMonitorStateException.java b/test/testsuite/ouroboros/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/ModifierExObjectwaitIllegalMonitorStateException.java
new file mode 100644
index 0000000000000000000000000000000000000000..756e41f61b308fed910d45132e2d90f212f2b32e
--- /dev/null
+++ b/test/testsuite/ouroboros/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/ModifierExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ModifierExObjectwaitIllegalMonitorStateException.java
+ * -@TestCaseName: Exception in reflect Modifier: final void wait(*)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: 补充重写类的父类方法
+ * -@Brief:
+ * -#step1: Create three methods, which call wait (), wait (millis), wait (millis, nanos)
+ * -#step2: Call the run of the use case, and execute these three methods respectively
+ * -#step3: Confirm that all methods throw IllegalMonitorStateException
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ModifierExObjectwaitIllegalMonitorStateException.java
+ * -@ExecuteClass: ModifierExObjectwaitIllegalMonitorStateException
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class ModifierExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Modifier mf2 = new Modifier();
+
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+
+    /**
+     * main test fun
+     * @return status code
+     */
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = modifierExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = modifierExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = modifierExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+
+        if (result == 4 && ModifierExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+
+        return result;
+    }
+
+    private static int modifierExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        // final void wait()
+        try {
+            mf2.wait();
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int modifierExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+    private static int modifierExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+
+        return result1;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/rc_test/RC0001-rc-function-Cycle_a_00180/Cycle_a_00180.java b/test/testsuite/ouroboros/rc_test/RC0001-rc-function-Cycle_a_00180/Cycle_a_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..750f83675f568ac3c7034c5eaae75db42bb42c62
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0001-rc-function-Cycle_a_00180/Cycle_a_00180.java
@@ -0,0 +1,238 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00180 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00180.java
+ *- @ExecuteClass: Cycle_a_00180
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 A8;
+ * A2 depend A3 ; A3 depend A4; A4 depend A5 ; A5 depend A6; A6 depend A1 ;
+ * A8 depend A9 ; A9 depend A7; A7 depend A4
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+108)+(102+103)+(103+104)+(104+105)+(105+106)+(106+101)+(107+104)+(108+109)+(109+107)=1994
+ *
+ */
+
+class Cycle_a_00180_A1 {
+    Cycle_a_00180_A2 a2_0;
+    Cycle_a_00180_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A1(String strObjectName) {
+        a2_0 = null;
+        a8_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00180_A2 {
+    Cycle_a_00180_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00180_A3 {
+    Cycle_a_00180_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00180_A4 {
+    Cycle_a_00180_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00180_A5 {
+    Cycle_a_00180_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00180_A6 {
+    Cycle_a_00180_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A6(String strObjectName) {
+        a1_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00180_A7 {
+    Cycle_a_00180_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A7(String strObjectName) {
+        a4_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00180_A8 {
+    Cycle_a_00180_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A8(String strObjectName) {
+        a9_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+class Cycle_a_00180_A9 {
+    Cycle_a_00180_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00180_A9(String strObjectName) {
+        a7_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+public class Cycle_a_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00180_A1 a1_main = new Cycle_a_00180_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00180_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00180_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00180_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00180_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00180_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a8_0 = new Cycle_a_00180_A8("a8_0");
+        a1_main.a8_0.a9_0 = new Cycle_a_00180_A9("a9_0");
+        a1_main.a8_0.a9_0.a7_0 = new Cycle_a_00180_A7("a7_0");
+        a1_main.a8_0.a9_0.a7_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_main.a8_0.add();
+        a1_main.a8_0.a9_0.add();
+        a1_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_main.a8_0.sum + a1_main.a8_0.a9_0.sum + a1_main.a8_0.a9_0.a7_0.sum;
+        if (result == 1994)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0002-rc-function-Cycle_a_00190/Cycle_a_00190.java b/test/testsuite/ouroboros/rc_test/RC0002-rc-function-Cycle_a_00190/Cycle_a_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..4110040104b4aaeeeafd38ae958299061029e101
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0002-rc-function-Cycle_a_00190/Cycle_a_00190.java
@@ -0,0 +1,261 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00190 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00190.java
+ *- @ExecuteClass: Cycle_a_00190
+ *- @ExecuteArgs:
+ *- @Remark:
+ A1 depend A2;  A10 depend A8 ;
+ * A2 depend A3 ; A3 depend A4; A4 depend A5 ; A5 depend A6; A6 depend A1 A10 ;
+ * A8 depend A9 ; A9 depend A7; A7 depend A5
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+104)+(104+105)+(105+106)+(106+101+110)+(107+105)+(108+109)+(109+107)+(110+108)=2215
+ *
+ */
+
+class Cycle_a_00190_A1 {
+    Cycle_a_00190_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00190_A2 {
+    Cycle_a_00190_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00190_A3 {
+    Cycle_a_00190_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00190_A4 {
+    Cycle_a_00190_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00190_A5 {
+    Cycle_a_00190_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00190_A6 {
+    Cycle_a_00190_A1 a1_0;
+    Cycle_a_00190_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A6(String strObjectName) {
+        a1_0 = null;
+        a10_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a10_0.a;
+    }
+}
+
+class Cycle_a_00190_A7 {
+    Cycle_a_00190_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A7(String strObjectName) {
+        a5_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00190_A8 {
+    Cycle_a_00190_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A8(String strObjectName) {
+        a9_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+class Cycle_a_00190_A9 {
+    Cycle_a_00190_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A9(String strObjectName) {
+        a7_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00190_A10 {
+    Cycle_a_00190_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00190_A10(String strObjectName) {
+        a8_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+public class Cycle_a_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00190_A1 a1_main = new Cycle_a_00190_A1("a1_main");
+        Cycle_a_00190_A10 a10_main = new Cycle_a_00190_A10("a10_main");
+        a1_main.a2_0 = new Cycle_a_00190_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00190_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00190_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00190_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00190_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_main;
+
+        a10_main.a8_0 = new Cycle_a_00190_A8("a8_0");
+        a10_main.a8_0.a9_0 = new Cycle_a_00190_A9("a9_0");
+        a10_main.a8_0.a9_0.a7_0 = new Cycle_a_00190_A7("a7_0");
+        a10_main.a8_0.a9_0.a7_0.a5_0 = a1_main.a2_0.a3_0.a4_0.a5_0;
+
+        a1_main.add();
+        a10_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_main.a8_0.add();
+        a10_main.a8_0.a9_0.add();
+        a10_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a10_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_main.a8_0.sum + a10_main.a8_0.a9_0.sum + a10_main.a8_0.a9_0.a7_0.sum;
+        if (result == 2215)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0003-rc-function-Cycle_a_00200/Cycle_a_00200.java b/test/testsuite/ouroboros/rc_test/RC0003-rc-function-Cycle_a_00200/Cycle_a_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..32340c7b4d2ddb4f7f083735d29379cf5e795368
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0003-rc-function-Cycle_a_00200/Cycle_a_00200.java
@@ -0,0 +1,199 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00200 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00200.java
+ *- @ExecuteClass: Cycle_a_00200
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2;  A4 depend A3 ;
+ * A2 depend A3 A6 A7; A3 depend A1 A5; A5 depend A4; A6 depend A7 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+106+107)+(102+103)+(103+101+105)+(104+103)+(105+104)+(106+107)+(107+107)=1773
+ *
+ */
+
+class Cycle_a_00200_A1 {
+    Cycle_a_00200_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00200_A2 {
+    Cycle_a_00200_A3 a3_0;
+    Cycle_a_00200_A6 a6_0;
+    Cycle_a_00200_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A2(String strObjectName) {
+        a3_0 = null;
+        a6_0 = null;
+        a7_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a6_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00200_A3 {
+    Cycle_a_00200_A1 a1_0;
+    Cycle_a_00200_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_00200_A4 {
+    Cycle_a_00200_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00200_A5 {
+    Cycle_a_00200_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A5(String strObjectName) {
+        a4_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00200_A6 {
+    Cycle_a_00200_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00200_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00200_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Cycle_a_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00200_A1 a1_main = new Cycle_a_00200_A1("a1_main");
+        Cycle_a_00200_A4 a4_main = new Cycle_a_00200_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00200_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00200_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00200_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a6_0 = new Cycle_a_00200_A6("a6_0");
+        a1_main.a2_0.a6_0.a7_0 = new Cycle_a_00200_A7("a7_0");
+        a1_main.a2_0.a7_0 = a1_main.a2_0.a6_0.a7_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a6_0.add();
+        a1_main.a2_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a6_0.sum + a1_main.a2_0.a6_0.a7_0.sum;
+        if (result == 1773)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0004-rc-function-Cycle_a_00210/Cycle_a_00210.java b/test/testsuite/ouroboros/rc_test/RC0004-rc-function-Cycle_a_00210/Cycle_a_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..fce699bd27a7ca926bc416298bbc58819713e7aa
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0004-rc-function-Cycle_a_00210/Cycle_a_00210.java
@@ -0,0 +1,199 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00210 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00210.java
+ *- @ExecuteClass: Cycle_a_00210
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2;  A4 depend A3 ;
+ * A2 depend A3; A3 depend A1 A5 A6; A5 depend A4; A6 depend A7 ; A7 depend A3;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+105+106)+(104+103)+(105+104)+(106+107)+(107+103)=1662
+ *
+ */
+
+class Cycle_a_00210_A1 {
+    Cycle_a_00210_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00210_A2 {
+    Cycle_a_00210_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00210_A3 {
+    Cycle_a_00210_A1 a1_0;
+    Cycle_a_00210_A5 a5_0;
+    Cycle_a_00210_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a6_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00210_A4 {
+    Cycle_a_00210_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00210_A5 {
+    Cycle_a_00210_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A5(String strObjectName) {
+        a4_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+class Cycle_a_00210_A6 {
+    Cycle_a_00210_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00210_A7 {
+    Cycle_a_00210_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00210_A7(String strObjectName) {
+        a3_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00210 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00210_A1 a1_main = new Cycle_a_00210_A1("a1_main");
+        Cycle_a_00210_A4 a4_main = new Cycle_a_00210_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00210_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00210_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00210_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00210_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0 = new Cycle_a_00210_A7("a7_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        a1_main.a2_0.a3_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a6_0.sum + a1_main.a2_0.a3_0.a6_0.a7_0.sum;
+        if (result == 1662)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0005-rc-function-Cycle_a_00220/Cycle_a_00220.java b/test/testsuite/ouroboros/rc_test/RC0005-rc-function-Cycle_a_00220/Cycle_a_00220.java
new file mode 100755
index 0000000000000000000000000000000000000000..e68bc131f325495cee001d86a976c7fb5690554d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0005-rc-function-Cycle_a_00220/Cycle_a_00220.java
@@ -0,0 +1,201 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00220.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00220 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00220.java
+ *- @ExecuteClass: Cycle_a_00220
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2;  A5 depend A4 A7;
+ * A2 depend A3; A3 depend A1 A5; A4 depend A3 ; A6 depend A5 A7 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+105)+(104+103)+(105+104+107)+(106+105+107)+(107+107)=1772
+ *
+ */
+
+class Cycle_a_00220_A1 {
+    Cycle_a_00220_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00220_A2 {
+    Cycle_a_00220_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00220_A3 {
+    Cycle_a_00220_A1 a1_0;
+    Cycle_a_00220_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_00220_A4 {
+    Cycle_a_00220_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00220_A5 {
+    Cycle_a_00220_A4 a4_0;
+    Cycle_a_00220_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A5(String strObjectName) {
+        a4_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00220_A6 {
+    Cycle_a_00220_A5 a5_0;
+    Cycle_a_00220_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A6(String strObjectName) {
+        a5_0 = null;
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00220_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00220_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Cycle_a_00220 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00220_A1 a1_main = new Cycle_a_00220_A1("a1_main");
+        Cycle_a_00220_A4 a4_main = new Cycle_a_00220_A4("a4_main");
+        Cycle_a_00220_A6 a6_main = new Cycle_a_00220_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00220_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00220_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00220_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_00220_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        if (result == 1772)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0006-rc-function-Cycle_a_00230/Cycle_a_00230.java b/test/testsuite/ouroboros/rc_test/RC0006-rc-function-Cycle_a_00230/Cycle_a_00230.java
new file mode 100755
index 0000000000000000000000000000000000000000..22909252dd0f3d03d3d9df0c8cb960e5845739e6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0006-rc-function-Cycle_a_00230/Cycle_a_00230.java
@@ -0,0 +1,199 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00230.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00230 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00230.java
+ *- @ExecuteClass: Cycle_a_00230
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2;  A5 depend A3 A6 A7;
+ * A2 depend A3; A3 depend A1 A4; A4 depend A5 ; A6 depend A7 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+104)+(104+105)+(105+103+106+107)+(106+107)+(107+107)=1773
+ *
+ */
+
+class Cycle_a_00230_A1 {
+    Cycle_a_00230_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00230_A2 {
+    Cycle_a_00230_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00230_A3 {
+    Cycle_a_00230_A1 a1_0;
+    Cycle_a_00230_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00230_A4 {
+    Cycle_a_00230_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00230_A5 {
+    Cycle_a_00230_A3 a3_0;
+    Cycle_a_00230_A6 a6_0;
+    Cycle_a_00230_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A5(String strObjectName) {
+        a3_0 = null;
+        a6_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a6_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00230_A6 {
+    Cycle_a_00230_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00230_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00230_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Cycle_a_00230 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00230_A1 a1_main = new Cycle_a_00230_A1("a1_main");
+        Cycle_a_00230_A5 a5_main = new Cycle_a_00230_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00230_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00230_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00230_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a7_0 = new Cycle_a_00230_A7("a7_0");
+        a5_main.a6_0 = new Cycle_a_00230_A6("a6_0");
+        a5_main.a6_0.a7_0 = a5_main.a7_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a5_main.a7_0.add();
+        a5_main.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a5_main.a6_0.sum + a5_main.a7_0.sum;
+        if (result == 1773)
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0007-rc-function-Cycle_a_00240/Cycle_a_00240.java b/test/testsuite/ouroboros/rc_test/RC0007-rc-function-Cycle_a_00240/Cycle_a_00240.java
new file mode 100755
index 0000000000000000000000000000000000000000..9e07f9cb5eb02f8477ebe973702761fa242a40ce
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0007-rc-function-Cycle_a_00240/Cycle_a_00240.java
@@ -0,0 +1,200 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00240 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00240.java
+ *- @ExecuteClass: Cycle_a_00240
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 A6;  A5 depend A3;
+ * A2 depend A3; A3 depend A1 A4; A4 depend A5 ; A6 depend A7 ; A7 depend A1;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+106)+(102+103)+(103+101+104)+(104+105)+(105+103)+(106+107)+(107+101)=1660
+ *
+ */
+
+class Cycle_a_00240_A1 {
+    Cycle_a_00240_A2 a2_0;
+    Cycle_a_00240_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A1(String strObjectName) {
+        a2_0 = null;
+        a6_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00240_A2 {
+    Cycle_a_00240_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00240_A3 {
+    Cycle_a_00240_A1 a1_0;
+    Cycle_a_00240_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00240_A4 {
+    Cycle_a_00240_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00240_A5 {
+    Cycle_a_00240_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00240_A6 {
+    Cycle_a_00240_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+class Cycle_a_00240_A7 {
+    Cycle_a_00240_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00240_A7(String strObjectName) {
+        a1_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_a_00240 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00240_A1 a1_main = new Cycle_a_00240_A1("a1_main");
+        Cycle_a_00240_A5 a5_main = new Cycle_a_00240_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00240_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00240_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a6_0 = new Cycle_a_00240_A6("a6_0");
+        a1_main.a6_0.a7_0 = new Cycle_a_00240_A7("a7_0");
+        a1_main.a6_0.a7_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a6_0.add();
+        a1_main.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a6_0.sum + a1_main.a6_0.a7_0.sum;
+        if (result == 1660)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0008-rc-function-Cycle_a_00250/Cycle_a_00250.java b/test/testsuite/ouroboros/rc_test/RC0008-rc-function-Cycle_a_00250/Cycle_a_00250.java
new file mode 100755
index 0000000000000000000000000000000000000000..b6e5aa83fbdd0db907d1d1c9caaca4caaa6ba15c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0008-rc-function-Cycle_a_00250/Cycle_a_00250.java
@@ -0,0 +1,158 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00250.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00250 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00250.java
+ *- @ExecuteClass: Cycle_a_00250
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2;  A6 depend A3
+ * A2 depend A3; A3 depend A1 A2 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+101+103)+(103+101+105)+(105+106)+(106+103)=1238
+ *
+ */
+
+class Cycle_a_00250_A1 {
+    Cycle_a_00250_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00250_A2 {
+    Cycle_a_00250_A1 a1_0;
+    Cycle_a_00250_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00250_A3 {
+    Cycle_a_00250_A1 a1_0;
+    Cycle_a_00250_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00250_A5 {
+    Cycle_a_00250_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00250_A6 {
+    Cycle_a_00250_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00250_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00250 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00250_A1 a1_main = new Cycle_a_00250_A1("a1_main");
+        Cycle_a_00250_A6 a6_main = new Cycle_a_00250_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00250_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00250_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00250_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1238)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0009-rc-function-Cycle_a_00260/Cycle_a_00260.java b/test/testsuite/ouroboros/rc_test/RC0009-rc-function-Cycle_a_00260/Cycle_a_00260.java
new file mode 100755
index 0000000000000000000000000000000000000000..5b198c7f2f4687be03e21edc642d631569989136
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0009-rc-function-Cycle_a_00260/Cycle_a_00260.java
@@ -0,0 +1,159 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00260.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00260 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00260.java
+ *- @ExecuteClass: Cycle_a_00260
+ *- @ExecuteArgs:
+ *- @Remark:
+ ** A1 depend A2;  A6 depend A3
+ * A2 depend A3; A3 depend A1 A2 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+102+105)+(105+106)+(106+103)=1239
+ *
+ */
+
+class Cycle_a_00260_A1 {
+    Cycle_a_00260_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00260_A2 {
+    Cycle_a_00260_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00260_A3 {
+    Cycle_a_00260_A1 a1_0;
+    Cycle_a_00260_A2 a2_0;
+    Cycle_a_00260_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00260_A5 {
+    Cycle_a_00260_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00260_A6 {
+    Cycle_a_00260_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00260_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00260 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00260_A1 a1_main = new Cycle_a_00260_A1("a1_main");
+        Cycle_a_00260_A6 a6_main = new Cycle_a_00260_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00260_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00260_A3("a3_0");
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00260_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1239)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0010-rc-function-Cycle_a_00270/Cycle_a_00270.java b/test/testsuite/ouroboros/rc_test/RC0010-rc-function-Cycle_a_00270/Cycle_a_00270.java
new file mode 100755
index 0000000000000000000000000000000000000000..f998f6a4e4bb1ebe884fe38c57ef5715aefdd4fb
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0010-rc-function-Cycle_a_00270/Cycle_a_00270.java
@@ -0,0 +1,159 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00270.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00270 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00270.java
+ *- @ExecuteClass: Cycle_a_00270
+ *- @ExecuteArgs:
+ *- @Remark:
+ *  A1 depend A2 A3;  A6 depend A3
+ * A2 depend A3; A3 depend A1 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+103)+(102+103)+(103+101+105)+(105+106)+(106+103)=1240
+ *
+ */
+
+class Cycle_a_00270_A1 {
+    Cycle_a_00270_A2 a2_0;
+    Cycle_a_00270_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00270_A2 {
+    Cycle_a_00270_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00270_A3 {
+    Cycle_a_00270_A1 a1_0;
+    Cycle_a_00270_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00270_A5 {
+    Cycle_a_00270_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00270_A6 {
+    Cycle_a_00270_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00270_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00270 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00270_A1 a1_main = new Cycle_a_00270_A1("a1_main");
+        Cycle_a_00270_A6 a6_main = new Cycle_a_00270_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00270_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00270_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00270_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1240)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0011-rc-function-Cycle_a_00280/Cycle_a_00280.java b/test/testsuite/ouroboros/rc_test/RC0011-rc-function-Cycle_a_00280/Cycle_a_00280.java
new file mode 100755
index 0000000000000000000000000000000000000000..907efb29f0efcdc5e8bfcafc9159ead111fa0555
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0011-rc-function-Cycle_a_00280/Cycle_a_00280.java
@@ -0,0 +1,164 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00280.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00280 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00280.java
+ *- @ExecuteClass: Cycle_a_00280
+ *- @ExecuteArgs:
+ *- @Remark:
+ *  A1 depend A2 A3;  A6 depend A3
+ * A2 depend A1 A3; A3 depend A1 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+103)+(102+101+103)+(103+101+102+105)+(105+106)+(106+103)=1443
+ *
+ */
+
+class Cycle_a_00280_A1 {
+    Cycle_a_00280_A2 a2_0;
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00280_A2 {
+    Cycle_a_00280_A1 a1_0;
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00280_A3 {
+    Cycle_a_00280_A1 a1_0;
+    Cycle_a_00280_A2 a2_0;
+    Cycle_a_00280_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00280_A5 {
+    Cycle_a_00280_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00280_A6 {
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00280 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1443)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0012-rc-function-Cycle_a_00290/Cycle_a_00290.java b/test/testsuite/ouroboros/rc_test/RC0012-rc-function-Cycle_a_00290/Cycle_a_00290.java
new file mode 100755
index 0000000000000000000000000000000000000000..f1748ce158cf3b8f8d1ab27dc40f752bce2ade33
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0012-rc-function-Cycle_a_00290/Cycle_a_00290.java
@@ -0,0 +1,181 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00290.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00290 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00290.java
+ *- @ExecuteClass: Cycle_a_00290
+ *- @ExecuteArgs:
+ *- @Remark:
+ *  A1 depend A2;  A5 depend A3
+ * A2 depend A3; A3 depend A1 A4 A6; A4 depend A5 ;A6 depend A2;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+104+106)+(104+105)+(105+103)+(106+102)=1447
+ *
+ */
+
+class Cycle_a_00290_A1 {
+    Cycle_a_00290_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00290_A2 {
+    Cycle_a_00290_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00290_A3 {
+    Cycle_a_00290_A1 a1_0;
+    Cycle_a_00290_A4 a4_0;
+    Cycle_a_00290_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a6_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a6_0.a;
+    }
+}
+
+
+class Cycle_a_00290_A4 {
+    Cycle_a_00290_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00290_A5 {
+    Cycle_a_00290_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00290_A6 {
+    Cycle_a_00290_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00290_A6(String strObjectName) {
+        a2_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00290 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00290_A1 a1_main = new Cycle_a_00290_A1("a1_main");
+        Cycle_a_00290_A5 a5_main = new Cycle_a_00290_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00290_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00290_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00290_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00290_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a2_0 = a1_main.a2_0;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a6_0.sum;
+
+        if (result == 1447)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0013-rc-function-Cycle_a_00300/Cycle_a_00300.java b/test/testsuite/ouroboros/rc_test/RC0013-rc-function-Cycle_a_00300/Cycle_a_00300.java
new file mode 100755
index 0000000000000000000000000000000000000000..3d2f06c08611345182f82f1e7c7ab7317555e7b6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0013-rc-function-Cycle_a_00300/Cycle_a_00300.java
@@ -0,0 +1,181 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00300.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_a_00300 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00300.java
+ *- @ExecuteClass: Cycle_a_00300
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2;  A5 depend A3
+ * A2 depend A3; A3 depend A1 A4; A4 depend A5 A6 ;A6 depend A3 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+104)+(104+105+106)+(105+103)+(106+103)=1448
+ *
+ */
+
+class Cycle_a_00300_A1 {
+    Cycle_a_00300_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00300_A2 {
+    Cycle_a_00300_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00300_A3 {
+    Cycle_a_00300_A1 a1_0;
+    Cycle_a_00300_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00300_A4 {
+    Cycle_a_00300_A5 a5_0;
+    Cycle_a_00300_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A4(String strObjectName) {
+        a5_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00300_A5 {
+    Cycle_a_00300_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00300_A6 {
+    Cycle_a_00300_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00300_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00300 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00300_A1 a1_main = new Cycle_a_00300_A1("a1_main");
+        Cycle_a_00300_A5 a5_main = new Cycle_a_00300_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00300_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00300_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00300_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a6_0 = new Cycle_a_00300_A6("a6_0");
+        a5_main.a3_0.a4_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a5_0 = a5_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1448)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0014-rc-function-Cycle_a_00310/Cycle_a_00310.java b/test/testsuite/ouroboros/rc_test/RC0014-rc-function-Cycle_a_00310/Cycle_a_00310.java
new file mode 100755
index 0000000000000000000000000000000000000000..e898f3dc48d3bb4db08f4dac642a0ec5fe122d8e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0014-rc-function-Cycle_a_00310/Cycle_a_00310.java
@@ -0,0 +1,185 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00310.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00310 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00310.java
+ *- @ExecuteClass: Cycle_a_00310
+ *- @ExecuteArgs:
+ *- @Remark:
+ *  A1 depend A2 A4; A4 depend A6 ; A6 depend A1 A3
+ * A2 depend A3; A3 depend A1 A5; A5 depend A6 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+104)+(102+103)+(103+101+105)+(104+106)+(105+106)+(106+101+103)=1552
+ *
+ */
+
+class Cycle_a_00310_A1 {
+    Cycle_a_00310_A2 a2_0;
+    Cycle_a_00310_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A1(String strObjectName) {
+        a2_0 = null;
+        a4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00310_A2 {
+    Cycle_a_00310_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00310_A3 {
+    Cycle_a_00310_A1 a1_0;
+    Cycle_a_00310_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00310_A4 {
+    Cycle_a_00310_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A4(String strObjectName) {
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00310_A5 {
+    Cycle_a_00310_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00310_A6 {
+    Cycle_a_00310_A1 a1_0;
+    Cycle_a_00310_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00310_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00310 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00310_A1 a1_main = new Cycle_a_00310_A1("a1_main");
+        Cycle_a_00310_A4 a4_main = new Cycle_a_00310_A4("a4_main");
+        Cycle_a_00310_A6 a6_main = new Cycle_a_00310_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00310_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00310_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00310_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a4_0 = a4_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a4_main.a6_0 = a6_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+
+        if (result == 1552)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0015-rc-function-Cycle_a_00320/Cycle_a_00320.java b/test/testsuite/ouroboros/rc_test/RC0015-rc-function-Cycle_a_00320/Cycle_a_00320.java
new file mode 100755
index 0000000000000000000000000000000000000000..b663ffdd3db2cd25d60ca1893cd7b22aaf9c1b43
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0015-rc-function-Cycle_a_00320/Cycle_a_00320.java
@@ -0,0 +1,184 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00320.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00320 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00320.java
+ *- @ExecuteClass: Cycle_a_00320
+ *- @ExecuteArgs:
+ *- @Remark:
+ *  A1 depend A2 ; A4 depend A5 ; A6 depend A1 A3 A4; A6 depend A1 A3 A4;
+ * A2 depend A3; A3 depend A1 A5; A5 depend A6 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+105)+(104+105)+(105+106)+(106+101+103+104)=1551
+ *
+ */
+
+class Cycle_a_00320_A1 {
+    Cycle_a_00320_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00320_A2 {
+    Cycle_a_00320_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00320_A3 {
+    Cycle_a_00320_A1 a1_0;
+    Cycle_a_00320_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00320_A4 {
+    Cycle_a_00320_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00320_A5 {
+    Cycle_a_00320_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00320_A6 {
+    Cycle_a_00320_A1 a1_0;
+    Cycle_a_00320_A3 a3_0;
+    Cycle_a_00320_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00320_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+
+
+public class Cycle_a_00320 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00320_A1 a1_main = new Cycle_a_00320_A1("a1_main");
+        Cycle_a_00320_A4 a4_main = new Cycle_a_00320_A4("a4_main");
+        Cycle_a_00320_A6 a6_main = new Cycle_a_00320_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00320_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00320_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00320_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a6_main.a4_0 = a4_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+
+        if (result == 1551)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0016-rc-function-Cycle_a_00330/Cycle_a_00330.java b/test/testsuite/ouroboros/rc_test/RC0016-rc-function-Cycle_a_00330/Cycle_a_00330.java
new file mode 100755
index 0000000000000000000000000000000000000000..58d969498a6ae5e6b63582727d196c14f44a3230
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0016-rc-function-Cycle_a_00330/Cycle_a_00330.java
@@ -0,0 +1,233 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00330.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00330 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00330.java
+ *- @ExecuteClass: Cycle_a_00330
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5 A8; A5 depend A6 A8;
+ * A7 depend A3 ; A8 depend A7;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105)+(104+101)+(105+106+108)+(106+101+103)+(107+103)+(108+107)=2080
+ *
+ */
+
+class Cycle_a_00330_A1 {
+    Cycle_a_00330_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00330_A2 {
+    Cycle_a_00330_A3 a3_0;
+    Cycle_a_00330_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00330_A3 {
+    Cycle_a_00330_A1 a1_0;
+    Cycle_a_00330_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00330_A4 {
+    Cycle_a_00330_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00330_A5 {
+    Cycle_a_00330_A6 a6_0;
+    Cycle_a_00330_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00330_A6 {
+    Cycle_a_00330_A1 a1_0;
+    Cycle_a_00330_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00330_A7 {
+    Cycle_a_00330_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A7(String strObjectName) {
+        a3_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00330_A8 {
+    Cycle_a_00330_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00330_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+public class Cycle_a_00330 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00330_A1 a1_main = new Cycle_a_00330_A1("a1_main");
+        Cycle_a_00330_A4 a4_main = new Cycle_a_00330_A4("a4_main");
+        Cycle_a_00330_A6 a6_main = new Cycle_a_00330_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00330_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00330_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00330_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00330_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00330_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+
+        if (result == 2080)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0017-rc-function-Cycle_a_00340/Cycle_a_00340.java b/test/testsuite/ouroboros/rc_test/RC0017-rc-function-Cycle_a_00340/Cycle_a_00340.java
new file mode 100755
index 0000000000000000000000000000000000000000..b7d24276ad725e5c96d256d9f957bdd0ef591ba8
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0017-rc-function-Cycle_a_00340/Cycle_a_00340.java
@@ -0,0 +1,233 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00340.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00340 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00340.java
+ *- @ExecuteClass: Cycle_a_00340
+ *- @ExecuteArgs:
+ *- @Remark:
+ *  A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5 A8; A5 depend A6;
+ * A7 depend A2 ; A8 depend A7;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105+108)+(104+101)+(105+106)+(106+101+103)+(107+102)+(108+107)=2079
+ *
+ */
+
+class Cycle_a_00340_A1 {
+    Cycle_a_00340_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00340_A2 {
+    Cycle_a_00340_A3 a3_0;
+    Cycle_a_00340_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00340_A3 {
+    Cycle_a_00340_A1 a1_0;
+    Cycle_a_00340_A5 a5_0;
+    Cycle_a_00340_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a8_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a8_0.a;
+    }
+}
+
+
+class Cycle_a_00340_A4 {
+    Cycle_a_00340_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00340_A5 {
+    Cycle_a_00340_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00340_A6 {
+    Cycle_a_00340_A1 a1_0;
+    Cycle_a_00340_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00340_A7 {
+    Cycle_a_00340_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_00340_A8 {
+    Cycle_a_00340_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00340_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+public class Cycle_a_00340 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00340_A1 a1_main = new Cycle_a_00340_A1("a1_main");
+        Cycle_a_00340_A4 a4_main = new Cycle_a_00340_A4("a4_main");
+        Cycle_a_00340_A6 a6_main = new Cycle_a_00340_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00340_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00340_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00340_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a8_0 = new Cycle_a_00340_A8("a8_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0 = new Cycle_a_00340_A7("a7_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a8_0.add();
+        a1_main.a2_0.a3_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a8_0.a7_0.sum + a6_main.a3_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2079)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0018-rc-function-Cycle_a_00350/Cycle_a_00350.java b/test/testsuite/ouroboros/rc_test/RC0018-rc-function-Cycle_a_00350/Cycle_a_00350.java
new file mode 100644
index 0000000000000000000000000000000000000000..fad6665dd9bc7e55117c1cc133fb9b4806bee099
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0018-rc-function-Cycle_a_00350/Cycle_a_00350.java
@@ -0,0 +1,215 @@
+/*
+ * -@TestCaseID:maple/runtime/rc/function/Cycle_a_00350.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination: Cycle_a_00350 in RC测试-Cycle-01
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:ExpectResult\nExpectResult\n
+ * -@Priority: High
+ * -@Source: Cycle_a_00350.java
+ * -@ExecuteClass: Cycle_a_00350
+ * -@ExecuteArgs:
+ * -@Remark:
+ * A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5; A5 depend A6 A8;
+ * A7 depend A2 ; A8 depend A7;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105)+(104+101)+(105+106+108)+(106+101+103)+(107+102)+(108+107)=2079
+ */
+
+class Cycle_a_00350_A1 {
+    Cycle_a_00350_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00350_A2 {
+    Cycle_a_00350_A3 a3_0;
+    Cycle_a_00350_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00350_A3 {
+    Cycle_a_00350_A1 a1_0;
+    Cycle_a_00350_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_00350_A4 {
+    Cycle_a_00350_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00350_A5 {
+    Cycle_a_00350_A6 a6_0;
+    Cycle_a_00350_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00350_A6 {
+    Cycle_a_00350_A1 a1_0;
+    Cycle_a_00350_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00350_A7 {
+    Cycle_a_00350_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00350_A8 {
+    Cycle_a_00350_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00350_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+public class Cycle_a_00350 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00350_A1 a1_main = new Cycle_a_00350_A1("a1_main");
+        Cycle_a_00350_A4 a4_main = new Cycle_a_00350_A4("a4_main");
+        Cycle_a_00350_A6 a6_main = new Cycle_a_00350_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00350_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00350_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00350_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00350_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00350_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum
+            + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        if (result == 2079) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0019-rc-function-Cycle_a_00360/Cycle_a_00360.java b/test/testsuite/ouroboros/rc_test/RC0019-rc-function-Cycle_a_00360/Cycle_a_00360.java
new file mode 100755
index 0000000000000000000000000000000000000000..6e0ff655b42d8b71864a53d824e1c290d0b05039
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0019-rc-function-Cycle_a_00360/Cycle_a_00360.java
@@ -0,0 +1,260 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00360.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00360 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00360.java
+ *- @ExecuteClass: Cycle_a_00360
+ *- @ExecuteArgs:
+ *- @Remark:
+ *  A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5; A5 depend A6 A8 A9;
+ * A7 depend A2 ; A8 depend A7;
+ * A9 depend A2 ;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105)+(104+101)+(105+106+108+109)+(106+101+103)+(107+102)+(108+107)+(109+102)=2399
+ *
+ */
+
+class Cycle_a_00360_A1 {
+    Cycle_a_00360_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00360_A2 {
+    Cycle_a_00360_A3 a3_0;
+    Cycle_a_00360_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00360_A3 {
+    Cycle_a_00360_A1 a1_0;
+    Cycle_a_00360_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00360_A4 {
+    Cycle_a_00360_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00360_A5 {
+    Cycle_a_00360_A6 a6_0;
+    Cycle_a_00360_A8 a8_0;
+    Cycle_a_00360_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a9_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a + a9_0.a;
+    }
+}
+
+class Cycle_a_00360_A6 {
+    Cycle_a_00360_A1 a1_0;
+    Cycle_a_00360_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00360_A7 {
+    Cycle_a_00360_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_00360_A8 {
+    Cycle_a_00360_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_00360_A9 {
+    Cycle_a_00360_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00360_A9(String strObjectName) {
+        a2_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00360 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00360_A1 a1_main = new Cycle_a_00360_A1("a1_main");
+        Cycle_a_00360_A4 a4_main = new Cycle_a_00360_A4("a4_main");
+        Cycle_a_00360_A6 a6_main = new Cycle_a_00360_A6("a6_main");
+        Cycle_a_00360_A9 a9_main = new Cycle_a_00360_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00360_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00360_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00360_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00360_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00360_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0.a9_0 = a9_main;
+        a9_main.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2399)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0020-rc-function-Cycle_a_00370/Cycle_a_00370.java b/test/testsuite/ouroboros/rc_test/RC0020-rc-function-Cycle_a_00370/Cycle_a_00370.java
new file mode 100755
index 0000000000000000000000000000000000000000..696074b41a7110a7fe4fef2c54896301c28d9f97
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0020-rc-function-Cycle_a_00370/Cycle_a_00370.java
@@ -0,0 +1,280 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00370.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00370 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00370.java
+ *- @ExecuteClass: Cycle_a_00370
+ *- @ExecuteArgs:
+ *- @Remark:
+ *  A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5 A10; A5 depend A6 A8
+ * A7 depend A2 ; A8 depend A7;
+ * A8 depend A6 ; A10 depend A9;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109 A10.a=1001
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105+110)+(104+101)+(105+106+108)+(106+101+103)+(107+102)+(108+107)+(109+106)+(110+109)=2623
+ *
+ */
+
+class Cycle_a_00370_A1 {
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00370_A2 {
+    Cycle_a_00370_A3 a3_0;
+    Cycle_a_00370_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00370_A3 {
+    Cycle_a_00370_A1 a1_0;
+    Cycle_a_00370_A5 a5_0;
+    Cycle_a_00370_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a10_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a10_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A4 {
+    Cycle_a_00370_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00370_A5 {
+    Cycle_a_00370_A6 a6_0;
+    Cycle_a_00370_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00370_A6 {
+    Cycle_a_00370_A1 a1_0;
+    Cycle_a_00370_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A7 {
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A8 {
+    Cycle_a_00370_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A9 {
+    Cycle_a_00370_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A9(String strObjectName) {
+        a6_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00370_A10 {
+    Cycle_a_00370_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A10(String strObjectName) {
+        a9_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+public class Cycle_a_00370 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2623)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0021-rc-function-Cycle_a_00380/Cycle_a_00380.java b/test/testsuite/ouroboros/rc_test/RC0021-rc-function-Cycle_a_00380/Cycle_a_00380.java
new file mode 100755
index 0000000000000000000000000000000000000000..72860de7f63259c46419b43b76496716e6f36ae5
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0021-rc-function-Cycle_a_00380/Cycle_a_00380.java
@@ -0,0 +1,115 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00380.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00380 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00380.java
+ *- @ExecuteClass: Cycle_a_00380
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 A3; A2 depend A1 A3; A3 depend A1
+ * A1.a=101 A2.a=102 A3.a=103
+ * RC-Testing_Result=(101+102)+(102+101+103)+(103++101+102)=815
+ *
+ */
+
+class Cycle_a_00380_A1 {
+    Cycle_a_00380_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00380_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00380_A2 {
+    Cycle_a_00380_A1 a1_0;
+    Cycle_a_00380_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00380_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00380_A3 {
+    Cycle_a_00380_A1 a1_0;
+    Cycle_a_00380_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00380_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00380 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00380_A1 a1_main = new Cycle_a_00380_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00380_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00380_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 815)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0022-rc-function-Cycle_a_00390/Cycle_a_00390.java b/test/testsuite/ouroboros/rc_test/RC0022-rc-function-Cycle_a_00390/Cycle_a_00390.java
new file mode 100755
index 0000000000000000000000000000000000000000..3a17431bfc9d216be89056480845dbafbb5b67fe
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0022-rc-function-Cycle_a_00390/Cycle_a_00390.java
@@ -0,0 +1,118 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00390.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00390 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00390.java
+ *- @ExecuteClass: Cycle_a_00390
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 A3; A2 depend A1 A3; A3 depend A1 A2
+ * A1.a=101 A2.a=102 A3.a=103
+ * RC-Testing_Result=(101+102+103)+(102+101+103)+(103+101+102)=918
+ *
+ */
+
+class Cycle_a_00390_A1 {
+    Cycle_a_00390_A2 a2_0;
+    Cycle_a_00390_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00390_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00390_A2 {
+    Cycle_a_00390_A1 a1_0;
+    Cycle_a_00390_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00390_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00390_A3 {
+    Cycle_a_00390_A1 a1_0;
+    Cycle_a_00390_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00390_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00390 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00390_A1 a1_main = new Cycle_a_00390_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00390_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00390_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 918)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0023-rc-function-Cycle_a_00400/Cycle_a_00400.java b/test/testsuite/ouroboros/rc_test/RC0023-rc-function-Cycle_a_00400/Cycle_a_00400.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d8a5885ac1d74ae61d86901cb37aedfd3d12021
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0023-rc-function-Cycle_a_00400/Cycle_a_00400.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00400.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00400 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00400.java
+ *- @ExecuteClass: Cycle_a_00400
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 A4; A2 depend A3; A3 depend A1 ; A4 depend A3
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106 A7.a=107
+ * RC-Testing_Result=(101+102+104)+(102+103)+(103+101)+(104+103)=923
+ *
+ */
+
+class Cycle_a_00400_A1 {
+    Cycle_a_00400_A2 a2_0;
+    Cycle_a_00400_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00400_A1(String strObjectName) {
+        a2_0 = null;
+        a4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00400_A2 {
+    Cycle_a_00400_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00400_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00400_A3 {
+    Cycle_a_00400_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00400_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00400_A4 {
+    Cycle_a_00400_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00400_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class Cycle_a_00400 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00400_A1 a1_main = new Cycle_a_00400_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00400_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00400_A3("a3_0");
+        a1_main.a4_0 = new Cycle_a_00400_A4("a4_0");
+        a1_main.a4_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 923)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0024-rc-function-Cycle_a_00410/Cycle_a_00410.java b/test/testsuite/ouroboros/rc_test/RC0024-rc-function-Cycle_a_00410/Cycle_a_00410.java
new file mode 100755
index 0000000000000000000000000000000000000000..a0a4c2c8b3db9725b6edfe842bf2b97e2be848ef
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0024-rc-function-Cycle_a_00410/Cycle_a_00410.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00410.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00410 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00410.java
+ *- @ExecuteClass: Cycle_a_00410
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 ; A2 depend A3 A4; A3 depend A1 ; A4 depend A1
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106 A7.a=107
+ * RC-Testing_Result=(101+102)+(102++103+104)+(103+101)+(104+101)=921
+ *
+ */
+
+class Cycle_a_00410_A1 {
+    Cycle_a_00410_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00410_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00410_A2 {
+    Cycle_a_00410_A3 a3_0;
+    Cycle_a_00410_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00410_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00410_A3 {
+    Cycle_a_00410_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00410_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00410_A4 {
+    Cycle_a_00410_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00410_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_a_00410 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00410_A1 a1_main = new Cycle_a_00410_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00410_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00410_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00410_A4("a4_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 921)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0025-rc-function-Cycle_a_00420/Cycle_a_00420.java b/test/testsuite/ouroboros/rc_test/RC0025-rc-function-Cycle_a_00420/Cycle_a_00420.java
new file mode 100755
index 0000000000000000000000000000000000000000..976d0223c4a924eb79199ef39c06314f6a6de550
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0025-rc-function-Cycle_a_00420/Cycle_a_00420.java
@@ -0,0 +1,132 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00420.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00420 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00420.java
+ *- @ExecuteClass: Cycle_a_00420
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 A3 ; A2 depend A3 ; A3 depend A4 ; A4 depend A1
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106 A7.a=107
+ * RC-Testing_Result=(101+102+103)+(102+103)+(103+104)+(104+101)=923
+ *
+ */
+
+class Cycle_a_00420_A1 {
+    Cycle_a_00420_A2 a2_0;
+    Cycle_a_00420_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00420_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00420_A2 {
+    Cycle_a_00420_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00420_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00420_A3 {
+    Cycle_a_00420_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00420_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00420_A4 {
+    Cycle_a_00420_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00420_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_a_00420 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00420_A1 a1_main = new Cycle_a_00420_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00420_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00420_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00420_A4("a4_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum;
+        if (result == 923)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0026-rc-function-Cycle_a_00430/Cycle_a_00430.java b/test/testsuite/ouroboros/rc_test/RC0026-rc-function-Cycle_a_00430/Cycle_a_00430.java
new file mode 100755
index 0000000000000000000000000000000000000000..261dbd908db43a299f96064c44f028fb78088a40
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0026-rc-function-Cycle_a_00430/Cycle_a_00430.java
@@ -0,0 +1,140 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00430.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00430 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00430.java
+ *- @ExecuteClass: Cycle_a_00430
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2  ; A2 depend A1 A3 A4 ; A3 depend A1 ; A4 depend  A1 A2
+ * A1.a=101 A2.a=102 A3.a=103 ... A4.a=104
+ * RC-Testing_Result=(101+102)+(102+101+103+104)+(103+101)+(104+101+102)=1124
+ *
+ */
+
+class Cycle_a_00430_A1 {
+    Cycle_a_00430_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00430_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00430_A2 {
+    Cycle_a_00430_A1 a1_0;
+    Cycle_a_00430_A3 a3_0;
+    Cycle_a_00430_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00430_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00430_A3 {
+    Cycle_a_00430_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00430_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00430_A4 {
+    Cycle_a_00430_A1 a1_0;
+    Cycle_a_00430_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00430_A4(String strObjectName) {
+        a2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00430 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00430_A1 a1_main = new Cycle_a_00430_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00430_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00430_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00430_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1124)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0027-rc-function-Cycle_a_00440/Cycle_a_00440.java b/test/testsuite/ouroboros/rc_test/RC0027-rc-function-Cycle_a_00440/Cycle_a_00440.java
new file mode 100755
index 0000000000000000000000000000000000000000..ca7ad3238ead69bf5bcf086b88f45c99a907e4d3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0027-rc-function-Cycle_a_00440/Cycle_a_00440.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00440.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00440 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00440.java
+ *- @ExecuteClass: Cycle_a_00440
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2  ; A2 depend A1 A3 A4 ; A3 depend A1 ; A4 depend A2
+ * A1.a=101 A2.a=102 A3.a=103 ... A4.a=104
+ * RC-Testing_Result=(101+102)+(102+101+103+104)+(103+101)+(104+102)=1023
+ *
+ */
+
+class Cycle_a_00440_A1 {
+    Cycle_a_00440_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00440_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00440_A2 {
+    Cycle_a_00440_A1 a1_0;
+    Cycle_a_00440_A3 a3_0;
+    Cycle_a_00440_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00440_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00440_A3 {
+    Cycle_a_00440_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00440_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00440_A4 {
+    Cycle_a_00440_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00440_A4(String strObjectName) {
+        a2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00440 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00440_A1 a1_main = new Cycle_a_00440_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00440_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00440_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00440_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        if (result == 1023)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0028-rc-function-Cycle_a_00450/Cycle_a_00450.java b/test/testsuite/ouroboros/rc_test/RC0028-rc-function-Cycle_a_00450/Cycle_a_00450.java
new file mode 100755
index 0000000000000000000000000000000000000000..fceeb11c4cc035a5d51b0aa7b71e8c9cfb5afc5a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0028-rc-function-Cycle_a_00450/Cycle_a_00450.java
@@ -0,0 +1,180 @@
+
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00450.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00450 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00450.java
+ *- @ExecuteClass: Cycle_a_00450
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2  ; A2 depend A3 ; A3 depend A1 A5 ; A5 depend A6 A7
+ * A6 depend A3 ; A7 depend A2
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106 A7.a=107
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101+105)+(105+106+107)+(106+103)+(107+102)=1453
+ *
+ */
+
+class Cycle_a_00450_A1 {
+    Cycle_a_00450_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00450_A2 {
+    Cycle_a_00450_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00450_A3 {
+    Cycle_a_00450_A1 a1_0;
+    Cycle_a_00450_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00450_A5 {
+    Cycle_a_00450_A6 a6_0;
+    Cycle_a_00450_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A5(String strObjectName) {
+        a6_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_00450_A6 {
+    Cycle_a_00450_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00450_A7 {
+    Cycle_a_00450_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00450_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_00450 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00450_A1 a1_main = new Cycle_a_00450_A1("a1_main");
+        Cycle_a_00450_A6 a6_main = new Cycle_a_00450_A6("a6_main");
+        Cycle_a_00450_A7 a7_main = new Cycle_a_00450_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00450_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00450_A3("a3_0");
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00450_A5("a5_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = a7_main;
+        a7_main.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a6_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1453)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0029-rc-function-Cycle_a_00460/Cycle_a_00460.java b/test/testsuite/ouroboros/rc_test/RC0029-rc-function-Cycle_a_00460/Cycle_a_00460.java
new file mode 100755
index 0000000000000000000000000000000000000000..8404237a34f59ca9648995f477958f5c2befd47f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0029-rc-function-Cycle_a_00460/Cycle_a_00460.java
@@ -0,0 +1,185 @@
+
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00460.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00460 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00460.java
+ *- @ExecuteClass: Cycle_a_00460
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 A4 ; A2 depend A3 ; A3 depend A4 ; A4 depend A1 A6
+ * A5 depend A3 ; A6 depend A1 A5
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106
+ * RC-Testing_Result=(101+102+104)+(102+103)+(103+104)+(104+106+101)+(105+103)+(106+105+101)=1550
+ *
+ */
+
+class Cycle_a_00460_A1 {
+    Cycle_a_00460_A2 a2_0;
+    Cycle_a_00460_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A1(String strObjectName) {
+        a2_0 = null;
+        a4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00460_A2 {
+    Cycle_a_00460_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00460_A3 {
+    Cycle_a_00460_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00460_A4 {
+    Cycle_a_00460_A1 a1_0;
+    Cycle_a_00460_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00460_A5 {
+    Cycle_a_00460_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00460_A6 {
+    Cycle_a_00460_A1 a1_0;
+    Cycle_a_00460_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00460_A6(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+public class Cycle_a_00460 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00460_A1 a1_main = new Cycle_a_00460_A1("a1_main");
+        Cycle_a_00460_A5 a5_main = new Cycle_a_00460_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00460_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00460_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00460_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00460_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1550)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0030-rc-function-Cycle_a_00470/Cycle_a_00470.java b/test/testsuite/ouroboros/rc_test/RC0030-rc-function-Cycle_a_00470/Cycle_a_00470.java
new file mode 100755
index 0000000000000000000000000000000000000000..86e0b00b866e3c7e9446e5bb54a5bce02220716a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0030-rc-function-Cycle_a_00470/Cycle_a_00470.java
@@ -0,0 +1,180 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00470.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00470 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00470.java
+ *- @ExecuteClass: Cycle_a_00470
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 ; A2 depend A3 ; A3 depend A4 ; A4 depend A1 A6
+ * A5 depend A3 A1 ; A6 depend A5
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106
+ * RC-Testing_Result=(101+102)+(102+103)+(103+104)+(104+106+101)+(105+103+101)+(106+105)=1446
+ *
+ */
+
+class Cycle_a_00470_A1 {
+    Cycle_a_00470_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00470_A2 {
+    Cycle_a_00470_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00470_A3 {
+    Cycle_a_00470_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00470_A4 {
+    Cycle_a_00470_A1 a1_0;
+    Cycle_a_00470_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00470_A5 {
+    Cycle_a_00470_A1 a1_0;
+    Cycle_a_00470_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A5(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00470_A6 {
+    Cycle_a_00470_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00470_A6(String strObjectName) {
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+public class Cycle_a_00470 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00470_A1 a1_main = new Cycle_a_00470_A1("a1_main");
+        Cycle_a_00470_A5 a5_main = new Cycle_a_00470_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00470_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00470_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00470_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00470_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a1_0 = a1_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        if (result == 1446)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0031-rc-function-Cycle_a_00480/Cycle_a_00480.java b/test/testsuite/ouroboros/rc_test/RC0031-rc-function-Cycle_a_00480/Cycle_a_00480.java
new file mode 100755
index 0000000000000000000000000000000000000000..151713478f46bdaca084678dddfea956d75fd9b9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0031-rc-function-Cycle_a_00480/Cycle_a_00480.java
@@ -0,0 +1,184 @@
+
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00480.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00480 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00480.java
+ *- @ExecuteClass: Cycle_a_00480
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 ; A2 depend A3 ; A3 depend A4 ; A4 depend A1 A6
+ * A5 depend A3 ; A6 depend A1 A4 A5
+ * A1.a=101 A2.a=102 A3.a=103 ... A6.a=106
+ * RC-Testing_Result=(101+102)+(102+103)+(103+104)+(104+106+101)+(105+103)+(106+101+104+105)=1550
+ *
+ */
+
+class Cycle_a_00480_A1 {
+    Cycle_a_00480_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00480_A2 {
+    Cycle_a_00480_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00480_A3 {
+    Cycle_a_00480_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00480_A4 {
+    Cycle_a_00480_A1 a1_0;
+    Cycle_a_00480_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_a_00480_A5 {
+    Cycle_a_00480_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00480_A6 {
+    Cycle_a_00480_A1 a1_0;
+    Cycle_a_00480_A4 a4_0;
+    Cycle_a_00480_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00480_A6(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a5_0.a;
+    }
+}
+
+public class Cycle_a_00480 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00480_A1 a1_main = new Cycle_a_00480_A1("a1_main");
+        Cycle_a_00480_A5 a5_main = new Cycle_a_00480_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00480_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00480_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00480_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00480_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        a5_main.a3_0.add();
+        a5_main.a3_0.a4_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        if (result == 1550)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0032-rc-function-Cycle_a_00490/Cycle_a_00490.java b/test/testsuite/ouroboros/rc_test/RC0032-rc-function-Cycle_a_00490/Cycle_a_00490.java
new file mode 100755
index 0000000000000000000000000000000000000000..51359a004a7d0f5e97603cee0035593b1d8a14d5
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0032-rc-function-Cycle_a_00490/Cycle_a_00490.java
@@ -0,0 +1,254 @@
+
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00490.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00490 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00490.java
+ *- @ExecuteClass: Cycle_a_00490
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 ; A2 depend A3 ; A3 depend A1
+ * A4 depend A5 ; A5 depend A6 ; A6 depend A4
+ * A8 depend A7 A5 ; A7 depend A9 ; A9 depend A8
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101)+(104+105)+(105+106)+(106+104+103)+(107+109)+(108+107+105)+(109+108)=2098
+ *
+ */
+
+class Cycle_a_00490_A1 {
+    Cycle_a_00490_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00490_A2 {
+    Cycle_a_00490_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00490_A3 {
+    Cycle_a_00490_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00490_A4 {
+    Cycle_a_00490_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_a_00490_A5 {
+    Cycle_a_00490_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00490_A6 {
+    Cycle_a_00490_A3 a3_0;
+    Cycle_a_00490_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A6(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00490_A7 {
+    Cycle_a_00490_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A7(String strObjectName) {
+        a9_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_a_00490_A8 {
+    Cycle_a_00490_A5 a5_0;
+    Cycle_a_00490_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A8(String strObjectName) {
+        a5_0 = null;
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00490_A9 {
+    Cycle_a_00490_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00490_A9(String strObjectName) {
+        a8_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+
+public class Cycle_a_00490 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00490_A1 a1_main = new Cycle_a_00490_A1("a1_main");
+        Cycle_a_00490_A4 a4_main = new Cycle_a_00490_A4("a4_main");
+        Cycle_a_00490_A7 a7_main = new Cycle_a_00490_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00490_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a5_0 = new Cycle_a_00490_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00490_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+        a4_main.a5_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0.a6_0.a3_0.a1_0 = a1_main;
+        a7_main.a9_0 = new Cycle_a_00490_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00490_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0.a8_0.a5_0 = a4_main.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a6_0.a3_0.add();
+        a4_main.a5_0.a6_0.a3_0.a1_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        a7_main.a9_0.a8_0.a5_0.add();
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        if (result == 2098)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0033-rc-function-Cycle_a_00500/Cycle_a_00500.java b/test/testsuite/ouroboros/rc_test/RC0033-rc-function-Cycle_a_00500/Cycle_a_00500.java
new file mode 100755
index 0000000000000000000000000000000000000000..d82d1d489ff02f950c40196a1f2f5d2572906c62
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0033-rc-function-Cycle_a_00500/Cycle_a_00500.java
@@ -0,0 +1,257 @@
+
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_00500.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00500 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_00500.java
+ *- @ExecuteClass: Cycle_a_00500
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 ; A2 depend A3 ; A3 depend A1
+ * A4 depend A5 ; A5 depend A6 ; A6 depend A4 ; A4 depend A1
+ * A5 depend A8 ; A8 depend A7 ; A7 depend A9 ; A9 depend A8
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102)+(102+103)+(103+101)+(104+101+105)+(106+104)+(105+106+108)+(107+109)+(108+107)+(109+108)=2099
+ *
+ */
+
+class Cycle_a_00500_A1 {
+    Cycle_a_00500_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00500_A2 {
+    Cycle_a_00500_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_00500_A3 {
+    Cycle_a_00500_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_a_00500_A4 {
+    Cycle_a_00500_A1 a1_0;
+    Cycle_a_00500_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A4(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_00500_A5 {
+    Cycle_a_00500_A6 a6_0;
+    Cycle_a_00500_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00500_A6 {
+    Cycle_a_00500_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A6(String strObjectName) {
+        a4_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_a_00500_A7 {
+    Cycle_a_00500_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A7(String strObjectName) {
+        a9_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_a_00500_A8 {
+    Cycle_a_00500_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_00500_A9 {
+    Cycle_a_00500_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00500_A9(String strObjectName) {
+        a8_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+
+public class Cycle_a_00500 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00500_A1 a1_main = new Cycle_a_00500_A1("a1_main");
+        Cycle_a_00500_A4 a4_main = new Cycle_a_00500_A4("a4_main");
+        Cycle_a_00500_A7 a7_main = new Cycle_a_00500_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00500_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00500_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00500_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00500_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+
+        a4_main.a5_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a4_main.a5_0.a8_0.a7_0 = a7_main;
+
+        a7_main.a9_0 = new Cycle_a_00500_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a8_0.add();
+        a4_main.a5_0.a8_0.a7_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        if (result == 2099)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0034-rc-function-Cycle_a_10010/Cycle_a_10010.java b/test/testsuite/ouroboros/rc_test/RC0034-rc-function-Cycle_a_10010/Cycle_a_10010.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1397fd8b9ea3cd1cbae3e8f7477c7271f4db18e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0034-rc-function-Cycle_a_10010/Cycle_a_10010.java
@@ -0,0 +1,378 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_10010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_10010 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_10010.java
+ *- @ExecuteClass: Cycle_a_10010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_a_10010_A1 {
+    Cycle_a_10010_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_10010_A2 {
+    Cycle_a_10010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_10010_A3 {
+    Cycle_a_10010_A1 a1_0;
+    Cycle_a_10010_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+class Cycle_a_10010_A4 {
+    Cycle_a_10010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_a_10010_A5 {
+    Cycle_a_10010_A4 a4_0;
+    Cycle_a_10010_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A5(String strObjectName) {
+        a4_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_10010_A6 {
+    Cycle_a_10010_A5 a5_0;
+    Cycle_a_10010_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A6(String strObjectName) {
+        a5_0 = null;
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a5_0.a + a7_0.a;
+    }
+}
+
+class Cycle_a_10010_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Cycle_a_10010_2A1 {
+    Cycle_a_10010_2A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_10010_2A2 {
+    Cycle_a_10010_2A3 a3_0;
+    Cycle_a_10010_2A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_10010_2A3 {
+    Cycle_a_10010_2A1 a1_0;
+    Cycle_a_10010_2A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_10010_2A4 {
+    Cycle_a_10010_2A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_10010_2A5 {
+    Cycle_a_10010_2A6 a6_0;
+    Cycle_a_10010_2A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_10010_2A6 {
+    Cycle_a_10010_2A1 a1_0;
+    Cycle_a_10010_2A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_10010_2A7 {
+    Cycle_a_10010_2A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A7(String strObjectName) {
+        a3_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_10010_2A8 {
+    Cycle_a_10010_2A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10010_2A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+public class Cycle_a_10010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_10010_A1 a1_main = new Cycle_a_10010_A1("a1_main");
+        Cycle_a_10010_A4 a4_main = new Cycle_a_10010_A4("a4_main");
+        Cycle_a_10010_A6 a6_main = new Cycle_a_10010_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_10010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10010_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10010_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_10010_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        Cycle_a_10010_2A1 a1_2main = new Cycle_a_10010_2A1("a1_2main");
+        Cycle_a_10010_2A4 a4_2main = new Cycle_a_10010_2A4("a4_2main");
+        Cycle_a_10010_2A6 a6_2main = new Cycle_a_10010_2A6("a6_2main");
+        a1_2main.a2_0 = new Cycle_a_10010_2A2("a2_0");
+        a1_2main.a2_0.a3_0 = new Cycle_a_10010_2A3("a3_0");
+        a1_2main.a2_0.a4_0 = a4_2main;
+        a4_2main.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a5_0 = new Cycle_a_10010_2A5("a5_0");
+        a1_2main.a2_0.a3_0.a5_0.a6_0 = a6_2main;
+        a1_2main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10010_2A8("a8_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10010_2A7("a7_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_2main.a2_0.a3_0;
+        a6_2main.a1_0 = a1_2main;
+        a6_2main.a3_0 = a1_2main.a2_0.a3_0;
+        a1_2main.add();
+        a4_2main.add();
+        a6_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        a1_2main.a2_0.a3_0.a5_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result2 = a1_2main.sum + a4_2main.sum + a6_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum + a1_2main.a2_0.a3_0.a5_0.sum + a6_2main.a3_0.a5_0.a8_0.a7_0.sum + a6_2main.a3_0.a5_0.a8_0.sum;
+        result += result2;
+        if (result == 3852)
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0035-rc-function-Cycle_a_10020/Cycle_a_10020.java b/test/testsuite/ouroboros/rc_test/RC0035-rc-function-Cycle_a_10020/Cycle_a_10020.java
new file mode 100755
index 0000000000000000000000000000000000000000..2e94c9c104d7e5df3d83ede5e9b3a2c07ffa5e95
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0035-rc-function-Cycle_a_10020/Cycle_a_10020.java
@@ -0,0 +1,342 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_a_10020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_10020 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_a_10020.java
+ *- @ExecuteClass: Cycle_a_10020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_a_10020_A1 {
+    Cycle_a_10020_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_10020_A2 {
+    Cycle_a_10020_A3 a3_0;
+    Cycle_a_10020_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_10020_A3 {
+    Cycle_a_10020_A1 a1_0;
+    Cycle_a_10020_A5 a5_0;
+    Cycle_a_10020_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a10_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a10_0.a;
+    }
+}
+
+
+class Cycle_a_10020_A4 {
+    Cycle_a_10020_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_10020_A5 {
+    Cycle_a_10020_A6 a6_0;
+    Cycle_a_10020_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_10020_A6 {
+    Cycle_a_10020_A1 a1_0;
+    Cycle_a_10020_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_10020_A7 {
+    Cycle_a_10020_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_10020_A8 {
+    Cycle_a_10020_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_10020_A9 {
+    Cycle_a_10020_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A9(String strObjectName) {
+        a6_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_10020_A10 {
+    Cycle_a_10020_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_A10(String strObjectName) {
+        a9_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+class Cycle_a_10020_2A1 {
+    Cycle_a_10020_2A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_2A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_10020_2A2 {
+    Cycle_a_10020_2A1 a1_0;
+    Cycle_a_10020_2A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_2A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_10020_2A3 {
+    Cycle_a_10020_2A1 a1_0;
+    Cycle_a_10020_2A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_10020_2A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_a_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_10020_A1 a1_main = new Cycle_a_10020_A1("a1_main");
+        Cycle_a_10020_A4 a4_main = new Cycle_a_10020_A4("a4_main");
+        Cycle_a_10020_A6 a6_main = new Cycle_a_10020_A6("a6_main");
+        Cycle_a_10020_A9 a9_main = new Cycle_a_10020_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_10020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10020_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10020_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_10020_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10020_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10020_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10020_2A1 a1_2main = new Cycle_a_10020_2A1("a1_2main");
+        a1_2main.a2_0 = new Cycle_a_10020_2A2("a2_0");
+        a1_2main.a2_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0 = new Cycle_a_10020_2A3("a3_0");
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a2_0 = a1_2main.a2_0;
+        a1_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        int result2 = a1_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+        if (result == (2623 + 815))
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0036-rc-function-Cycle_B_1_00010/Cycle_B_1_00010.java b/test/testsuite/ouroboros/rc_test/RC0036-rc-function-Cycle_B_1_00010/Cycle_B_1_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..fae9a0823f311e3d1275bff27a19ef974f78f71b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0036-rc-function-Cycle_B_1_00010/Cycle_B_1_00010.java
@@ -0,0 +1,54 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00010 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00010.java
+ *- @ExecuteClass: Cycle_B_1_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00010_A1 {
+    Cycle_B_1_00010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00010_A1() {
+        a1_0 = null;
+        a = 123;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_1_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        if (nsum == 246)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0037-rc-function-Cycle_B_1_00020/Cycle_B_1_00020.java b/test/testsuite/ouroboros/rc_test/RC0037-rc-function-Cycle_B_1_00020/Cycle_B_1_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..44bfccd5c84d067c0d1d58da1059e10f157d49eb
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0037-rc-function-Cycle_B_1_00020/Cycle_B_1_00020.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00020 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00020.java
+ *- @ExecuteClass: Cycle_B_1_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00020_A1 {
+    Cycle_B_1_00020_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00020_A2 {
+    Cycle_B_1_00020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00020_A2() {
+        a1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_1_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00020_A1 a1_0 = new Cycle_B_1_00020_A1();
+        a1_0.a2_0 = new Cycle_B_1_00020_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+
+        if (nsum == 6)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0038-rc-function-Cycle_B_1_00030/Cycle_B_1_00030.java b/test/testsuite/ouroboros/rc_test/RC0038-rc-function-Cycle_B_1_00030/Cycle_B_1_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..07e53159c25a61afd16628fee0c9e21bf0c3d9a0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0038-rc-function-Cycle_B_1_00030/Cycle_B_1_00030.java
@@ -0,0 +1,93 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00030 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00030.java
+ *- @ExecuteClass: Cycle_B_1_00030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00030_A1 {
+    Cycle_B_1_00030_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00030_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00030_A2 {
+    Cycle_B_1_00030_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00030_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00030_A3 {
+    Cycle_B_1_00030_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00030_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_1_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00030_A1 a1_0 = new Cycle_B_1_00030_A1();
+        a1_0.a2_0 = new Cycle_B_1_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00030_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+
+        if (nsum == 12)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0039-rc-function-Cycle_B_1_00040/Cycle_B_1_00040.java b/test/testsuite/ouroboros/rc_test/RC0039-rc-function-Cycle_B_1_00040/Cycle_B_1_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..81d86d822919f48453bc16dcef52e512da9f6b57
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0039-rc-function-Cycle_B_1_00040/Cycle_B_1_00040.java
@@ -0,0 +1,114 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00040 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00040.java
+ *- @ExecuteClass: Cycle_B_1_00040
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00040_A1 {
+    Cycle_B_1_00040_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00040_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00040_A2 {
+    Cycle_B_1_00040_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00040_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00040_A3 {
+    Cycle_B_1_00040_A1 a1_0;
+    Cycle_B_1_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00040_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00040_A4 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00040_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+
+public class Cycle_B_1_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00040_A1 a1_0 = new Cycle_B_1_00040_A1();
+        a1_0.a2_0 = new Cycle_B_1_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00040_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00040_A4();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0040-rc-function-Cycle_B_1_00050/Cycle_B_1_00050.java b/test/testsuite/ouroboros/rc_test/RC0040-rc-function-Cycle_B_1_00050/Cycle_B_1_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..1fcfae005f649bfba3507e8194cba8f653c1120b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0040-rc-function-Cycle_B_1_00050/Cycle_B_1_00050.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00050 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00050.java
+ *- @ExecuteClass: Cycle_B_1_00050
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00050_A1 {
+    Cycle_B_1_00050_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00050_A2 {
+    Cycle_B_1_00050_A3 a3_0;
+    Cycle_B_1_00050_A4 a4_0;
+    Cycle_B_1_00050_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00050_A3 {
+    Cycle_B_1_00050_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00050_A4 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+
+class Cycle_B_1_00050_A5 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00050_A5() {
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 7;
+    }
+}
+
+public class Cycle_B_1_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00050_A1 a1_0 = new Cycle_B_1_00050_A1();
+        a1_0.a2_0 = new Cycle_B_1_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00050_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00050_A4();
+        a1_0.a2_0.a5_0 = new Cycle_B_1_00050_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 34)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0041-rc-function-Cycle_B_1_00060/Cycle_B_1_00060.java b/test/testsuite/ouroboros/rc_test/RC0041-rc-function-Cycle_B_1_00060/Cycle_B_1_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..d881ea6dab90a4750672a960ca23bddc39802692
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0041-rc-function-Cycle_B_1_00060/Cycle_B_1_00060.java
@@ -0,0 +1,113 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00060 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00060.java
+ *- @ExecuteClass: Cycle_B_1_00060
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00060_A1 {
+    Cycle_B_1_00060_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00060_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00060_A2 {
+    Cycle_B_1_00060_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00060_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00060_A3 {
+    Cycle_B_1_00060_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00060_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00060_A4 {
+    Cycle_B_1_00060_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00060_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_1_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00060_A1 a1_0 = new Cycle_B_1_00060_A1();
+        a1_0.a2_0 = new Cycle_B_1_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00060_A3();
+        Cycle_B_1_00060_A4 a4_0 = new Cycle_B_1_00060_A4();
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum;
+
+        if (nsum == 19)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0042-rc-function-Cycle_B_1_00070/Cycle_B_1_00070.java b/test/testsuite/ouroboros/rc_test/RC0042-rc-function-Cycle_B_1_00070/Cycle_B_1_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..5dc54c893a30b3483d5324b09626dd78bf17d014
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0042-rc-function-Cycle_B_1_00070/Cycle_B_1_00070.java
@@ -0,0 +1,113 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00070 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00070.java
+ *- @ExecuteClass: Cycle_B_1_00070
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00070_A1 {
+    Cycle_B_1_00070_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00070_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00070_A2 {
+    Cycle_B_1_00070_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00070_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00070_A3 {
+    Cycle_B_1_00070_A1 a1_0;
+    Cycle_B_1_00070_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00070_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00070_A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00070_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+public class Cycle_B_1_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00070_A1 a1_0 = new Cycle_B_1_00070_A1();
+        a1_0.a2_0 = new Cycle_B_1_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00070_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00070_A4();
+
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0043-rc-function-Cycle_B_1_00080/Cycle_B_1_00080.java b/test/testsuite/ouroboros/rc_test/RC0043-rc-function-Cycle_B_1_00080/Cycle_B_1_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..36289e4434c32af880edee128b15881ba2dbfb9d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0043-rc-function-Cycle_B_1_00080/Cycle_B_1_00080.java
@@ -0,0 +1,131 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00080 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00080.java
+ *- @ExecuteClass: Cycle_B_1_00080
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00080_A1 {
+    Cycle_B_1_00080_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00080_A2 {
+    Cycle_B_1_00080_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00080_A3 {
+    Cycle_B_1_00080_A1 a1_0;
+    Cycle_B_1_00080_A4 a4_0;
+    Cycle_B_1_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        a4_0.add();
+        a5_0.add();
+        sum = a + a1_0.a + a4_0.sum + a5_0.sum;
+    }
+}
+
+
+class Cycle_B_1_00080_A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+
+class Cycle_B_1_00080_A5 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00080_A5() {
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 7;
+    }
+}
+
+public class Cycle_B_1_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00080_A1 a1_0 = new Cycle_B_1_00080_A1();
+        a1_0.a2_0 = new Cycle_B_1_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00080_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00080_A4();
+        a1_0.a2_0.a3_0.a5_0 = new Cycle_B_1_00080_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 56)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0044-rc-function-Cycle_B_1_00090/Cycle_B_1_00090.java b/test/testsuite/ouroboros/rc_test/RC0044-rc-function-Cycle_B_1_00090/Cycle_B_1_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..ef01aea58118d6adda0d080a5c13b10c751b26a4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0044-rc-function-Cycle_B_1_00090/Cycle_B_1_00090.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00090 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00090.java
+ *- @ExecuteClass: Cycle_B_1_00090
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00090_A1 {
+    Cycle_B_1_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00090_A2 {
+    Cycle_B_1_00090_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00090_A3 {
+    Cycle_B_1_00090_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00090_A4 {
+    Cycle_B_1_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00090_A5 {
+    Cycle_B_1_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00090_A5() {
+        a2_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+public class Cycle_B_1_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00090_A1 a1_0 = new Cycle_B_1_00090_A1();
+        a1_0.a2_0 = new Cycle_B_1_00090_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00090_A3();
+        Cycle_B_1_00090_A4 a4_0 = new Cycle_B_1_00090_A4();
+        Cycle_B_1_00090_A5 a5_0 = new Cycle_B_1_00090_A5();
+        a4_0.a2_0 = a1_0.a2_0;
+        a5_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 25)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0045-rc-function-Cycle_B_1_00100/Cycle_B_1_00100.java b/test/testsuite/ouroboros/rc_test/RC0045-rc-function-Cycle_B_1_00100/Cycle_B_1_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..de8643116464d262b4dad33044a6cff2a692c639
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0045-rc-function-Cycle_B_1_00100/Cycle_B_1_00100.java
@@ -0,0 +1,135 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00100 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00100.java
+ *- @ExecuteClass: Cycle_B_1_00100
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00100_A1 {
+    Cycle_B_1_00100_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00100_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00100_A2 {
+    Cycle_B_1_00100_A3 a3_0;
+    Cycle_B_1_00100_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00100_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00100_A3 {
+    Cycle_B_1_00100_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00100_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00100_A4 {
+
+    int a;
+    int sum;
+    Cycle_B_1_00100_A5 a5_0;
+
+    Cycle_B_1_00100_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        a5_0.add();
+        sum = a + a5_0.sum;
+    }
+}
+
+class Cycle_B_1_00100_A5 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00100_A5() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+public class Cycle_B_1_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00100_A1 a1_0 = new Cycle_B_1_00100_A1();
+        a1_0.a2_0 = new Cycle_B_1_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00100_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00100_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_1_00100_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0046-rc-function-Cycle_B_1_00110/Cycle_B_1_00110.java b/test/testsuite/ouroboros/rc_test/RC0046-rc-function-Cycle_B_1_00110/Cycle_B_1_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..bb69b977be60919675a1b4794b66f0c57e94f1da
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0046-rc-function-Cycle_B_1_00110/Cycle_B_1_00110.java
@@ -0,0 +1,131 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00110 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00110.java
+ *- @ExecuteClass: Cycle_B_1_00110
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00110_A1 {
+    Cycle_B_1_00110_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00110_A2 {
+    Cycle_B_1_00110_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00110_A3 {
+    Cycle_B_1_00110_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00110_A4 {
+    Cycle_B_1_00110_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_B_1_00110_A5 {
+    Cycle_B_1_00110_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00110_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_1_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00110_A1 a1_0 = new Cycle_B_1_00110_A1();
+        a1_0.a2_0 = new Cycle_B_1_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00110_A3();
+        Cycle_B_1_00110_A5 a5_0 = new Cycle_B_1_00110_A5();
+        a5_0.a4_0 = new Cycle_B_1_00110_A4();
+        a5_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 27)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0047-rc-function-Cycle_B_1_00120/Cycle_B_1_00120.java b/test/testsuite/ouroboros/rc_test/RC0047-rc-function-Cycle_B_1_00120/Cycle_B_1_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..cfda63ff43db1eb7203e06b92c19489391be88ba
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0047-rc-function-Cycle_B_1_00120/Cycle_B_1_00120.java
@@ -0,0 +1,130 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00120 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00120.java
+ *- @ExecuteClass: Cycle_B_1_00120
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00120_A1 {
+    Cycle_B_1_00120_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00120_A2 {
+    Cycle_B_1_00120_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00120_A3 {
+    Cycle_B_1_00120_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00120_A4 {
+    Cycle_B_1_00120_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_B_1_00120_A5 {
+    Cycle_B_1_00120_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00120_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_1_00120 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00120_A1 a1_0 = new Cycle_B_1_00120_A1();
+        a1_0.a2_0 = new Cycle_B_1_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00120_A3();
+        Cycle_B_1_00120_A5 a5_0 = new Cycle_B_1_00120_A5();
+        a5_0.a4_0 = new Cycle_B_1_00120_A4();
+        a5_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0048-rc-function-Cycle_B_1_00130/Cycle_B_1_00130.java b/test/testsuite/ouroboros/rc_test/RC0048-rc-function-Cycle_B_1_00130/Cycle_B_1_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..d0a7ebb1cac72d5e8225cb2df76eaf98a0eb7e02
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0048-rc-function-Cycle_B_1_00130/Cycle_B_1_00130.java
@@ -0,0 +1,95 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00130 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00130.java
+ *- @ExecuteClass: Cycle_B_1_00130
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00130_A1 {
+    Cycle_B_1_00130_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00130_A1() {
+        a3_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00130_A2 {
+    Cycle_B_1_00130_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00130_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00130_A3 {
+    Cycle_B_1_00130_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00130_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_1_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00130_A1 a1_0 = new Cycle_B_1_00130_A1();
+        Cycle_B_1_00130_A2 a2_0 = new Cycle_B_1_00130_A2();
+        Cycle_B_1_00130_A3 a3_0 = new Cycle_B_1_00130_A3();
+        a1_0.a3_0 = a3_0;
+        a2_0.a3_0 = a3_0;
+        a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0049-rc-function-Cycle_B_1_00140/Cycle_B_1_00140.java b/test/testsuite/ouroboros/rc_test/RC0049-rc-function-Cycle_B_1_00140/Cycle_B_1_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..347b09c73c8c41d5945bc6381ca06eaa8eac37ad
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0049-rc-function-Cycle_B_1_00140/Cycle_B_1_00140.java
@@ -0,0 +1,113 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00140 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00140.java
+ *- @ExecuteClass: Cycle_B_1_00140
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00140_A1 {
+    Cycle_B_1_00140_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00140_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00140_A2 {
+    Cycle_B_1_00140_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00140_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00140_A3 {
+    Cycle_B_1_00140_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00140_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00140_A4 {
+    Cycle_B_1_00140_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00140_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_1_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00140_A1 a1_0 = new Cycle_B_1_00140_A1();
+        a1_0.a2_0 = new Cycle_B_1_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00140_A3();
+        Cycle_B_1_00140_A4 a4_0 = new Cycle_B_1_00140_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 12)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0050-rc-function-Cycle_B_1_00150/Cycle_B_1_00150.java b/test/testsuite/ouroboros/rc_test/RC0050-rc-function-Cycle_B_1_00150/Cycle_B_1_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..750e5d21b1df0ecf976974e26e78e1189a1ded15
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0050-rc-function-Cycle_B_1_00150/Cycle_B_1_00150.java
@@ -0,0 +1,135 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00150 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00150.java
+ *- @ExecuteClass: Cycle_B_1_00150
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00150_A1 {
+    Cycle_B_1_00150_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00150_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00150_A2 {
+    Cycle_B_1_00150_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00150_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00150_A3 {
+    Cycle_B_1_00150_A1 a1_0;
+    Cycle_B_1_00150_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00150_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00150_A4 {
+
+    int a;
+    int sum;
+    Cycle_B_1_00150_A5 a5_0;
+
+    Cycle_B_1_00150_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        a5_0.add();
+        sum = a + a5_0.sum;
+    }
+}
+
+class Cycle_B_1_00150_A5 {
+
+    int a;
+    int sum;
+
+    Cycle_B_1_00150_A5() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+public class Cycle_B_1_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00150_A1 a1_0 = new Cycle_B_1_00150_A1();
+        a1_0.a2_0 = new Cycle_B_1_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00150_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_1_00150_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0051-rc-function-Cycle_B_1_00160/Cycle_B_1_00160.java b/test/testsuite/ouroboros/rc_test/RC0051-rc-function-Cycle_B_1_00160/Cycle_B_1_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..b5e1731679d29951a4b79454c9d3aef1c97c5c65
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0051-rc-function-Cycle_B_1_00160/Cycle_B_1_00160.java
@@ -0,0 +1,113 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00160 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00160.java
+ *- @ExecuteClass: Cycle_B_1_00160
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00160_A1 {
+    Cycle_B_1_00160_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00160_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00160_A2 {
+    Cycle_B_1_00160_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00160_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00160_A3 {
+    Cycle_B_1_00160_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00160_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_00160_A4 {
+    Cycle_B_1_00160_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00160_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_1_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00160_A1 a1_0 = new Cycle_B_1_00160_A1();
+        a1_0.a2_0 = new Cycle_B_1_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00160_A3();
+        Cycle_B_1_00160_A4 a4_0 = new Cycle_B_1_00160_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 17)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0052-rc-function-Cycle_B_1_00170/Cycle_B_1_00170.java b/test/testsuite/ouroboros/rc_test/RC0052-rc-function-Cycle_B_1_00170/Cycle_B_1_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..d72ed54011e322d3399783c8415fe0496b7547d2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0052-rc-function-Cycle_B_1_00170/Cycle_B_1_00170.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00170 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00170.java
+ *- @ExecuteClass: Cycle_B_1_00170
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00170_A1 {
+    Cycle_B_1_00170_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00170_A2 {
+    Cycle_B_1_00170_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00170_A3 {
+    Cycle_B_1_00170_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_00170_A4 {
+    Cycle_B_1_00170_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00170_A5 {
+    Cycle_B_1_00170_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00170_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+public class Cycle_B_1_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00170_A1 a1_0 = new Cycle_B_1_00170_A1();
+        a1_0.a2_0 = new Cycle_B_1_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00170_A3();
+        Cycle_B_1_00170_A4 a4_0 = new Cycle_B_1_00170_A4();
+        Cycle_B_1_00170_A5 a5_0 = new Cycle_B_1_00170_A5();
+        a5_0.a4_0 = a4_0;
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 26)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0053-rc-function-Cycle_B_1_00180/Cycle_B_1_00180.java b/test/testsuite/ouroboros/rc_test/RC0053-rc-function-Cycle_B_1_00180/Cycle_B_1_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..35692480ba37de759b027a8017af269de1bf214b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0053-rc-function-Cycle_B_1_00180/Cycle_B_1_00180.java
@@ -0,0 +1,132 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00180 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00180.java
+ *- @ExecuteClass: Cycle_B_1_00180
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00180_A1 {
+    Cycle_B_1_00180_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A2 {
+    Cycle_B_1_00180_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A3 {
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_00180_A4 {
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A5 {
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_1_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 23)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0054-rc-function-Cycle_B_1_00190/Cycle_B_1_00190.java b/test/testsuite/ouroboros/rc_test/RC0054-rc-function-Cycle_B_1_00190/Cycle_B_1_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..19bc82492496a994e6a0c73a3ad576ffd9cff2f5
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0054-rc-function-Cycle_B_1_00190/Cycle_B_1_00190.java
@@ -0,0 +1,114 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00190 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00190.java
+ *- @ExecuteClass: Cycle_B_1_00190
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00190_A1 {
+    Cycle_B_1_00190_A2 a2_0;
+    Cycle_B_1_00190_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00190_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00190_A2 {
+    Cycle_B_1_00190_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00190_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00190_A3 {
+    Cycle_B_1_00190_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00190_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00190_A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00190_A4() {
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 5;
+    }
+}
+
+
+public class Cycle_B_1_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00190_A1 a1_0 = new Cycle_B_1_00190_A1();
+        a1_0.a2_0 = new Cycle_B_1_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00190_A3();
+        Cycle_B_1_00190_A4 a4_0 = new Cycle_B_1_00190_A4();
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0055-rc-function-Cycle_B_1_00200/Cycle_B_1_00200.java b/test/testsuite/ouroboros/rc_test/RC0055-rc-function-Cycle_B_1_00200/Cycle_B_1_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..0fa041a696f1ef5b6ccd12ca2518c367f4a6b71a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0055-rc-function-Cycle_B_1_00200/Cycle_B_1_00200.java
@@ -0,0 +1,134 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00200 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_00200.java
+ *- @ExecuteClass: Cycle_B_1_00200
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_00200_A1 {
+    Cycle_B_1_00200_A2 a2_0;
+    Cycle_B_1_00200_A4 a4_0;
+    Cycle_B_1_00200_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00200_A2 {
+    Cycle_B_1_00200_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00200_A3 {
+    Cycle_B_1_00200_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00200_A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A4() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+class Cycle_B_1_00200_A5 {
+    int a;
+    int sum;
+
+    Cycle_B_1_00200_A5() {
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 8;
+    }
+}
+
+
+public class Cycle_B_1_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00200_A1 a1_0 = new Cycle_B_1_00200_A1();
+        a1_0.a2_0 = new Cycle_B_1_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00200_A3();
+        Cycle_B_1_00200_A4 a4_0 = new Cycle_B_1_00200_A4();
+        Cycle_B_1_00200_A5 a5_0 = new Cycle_B_1_00200_A5();
+        a1_0.a4_0 = a4_0;
+        a1_0.a5_0 = a5_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 38)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0056-rc-function-Cycle_B_1_10010/Cycle_B_1_10010.java b/test/testsuite/ouroboros/rc_test/RC0056-rc-function-Cycle_B_1_10010/Cycle_B_1_10010.java
new file mode 100755
index 0000000000000000000000000000000000000000..0632f10e96ff767a991175d03424ba21fd553eda
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0056-rc-function-Cycle_B_1_10010/Cycle_B_1_10010.java
@@ -0,0 +1,153 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_10010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_10010 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_10010.java
+ *- @ExecuteClass: Cycle_B_1_10010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_10010_A1 {
+    Cycle_B_1_10010_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_10010_A2 {
+    Cycle_B_1_10010_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_10010_A3 {
+    Cycle_B_1_10010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_10010_2A1 {
+    Cycle_B_1_10010_2A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_2A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_10010_2A2 {
+    Cycle_B_1_10010_2A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_2A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_10010_2A3 {
+    Cycle_B_1_10010_2A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10010_2A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_1_10010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_10010_A1 a1_0 = new Cycle_B_1_10010_A1();
+        a1_0.a2_0 = new Cycle_B_1_10010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10010_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        Cycle_B_1_10010_2A1 a1_10 = new Cycle_B_1_10010_2A1();
+        a1_10.a2_0 = new Cycle_B_1_10010_2A2();
+        a1_10.a2_0.a3_0 = new Cycle_B_1_10010_2A3();
+        a1_10.a2_0.a3_0.a1_0 = a1_10;
+        a1_10.add();
+        a1_10.a2_0.add();
+        a1_10.a2_0.a3_0.add();
+        int nsum2 = (a1_10.sum + a1_10.a2_0.sum + a1_10.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        nsum += nsum2;
+        if (nsum == 24)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0057-rc-function-Cycle_B_1_10020/Cycle_B_1_10020.java b/test/testsuite/ouroboros/rc_test/RC0057-rc-function-Cycle_B_1_10020/Cycle_B_1_10020.java
new file mode 100755
index 0000000000000000000000000000000000000000..8396c01fb1b59d0dc630b1dfb4bba77fcc82db09
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0057-rc-function-Cycle_B_1_10020/Cycle_B_1_10020.java
@@ -0,0 +1,228 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_1_10020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_10020 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_1_10020.java
+ *- @ExecuteClass: Cycle_B_1_10020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_1_10020_A1 {
+    Cycle_B_1_10020_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_A2 {
+    Cycle_B_1_10020_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_A3 {
+    Cycle_B_1_10020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_10020_A4 {
+    Cycle_B_1_10020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_A5 {
+    Cycle_B_1_10020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_10020_2A1 {
+    Cycle_B_1_10020_2A2 a2_0;
+    Cycle_B_1_10020_2A4 a4_0;
+    Cycle_B_1_10020_2A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_2A2 {
+    Cycle_B_1_10020_2A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_10020_2A3 {
+    Cycle_B_1_10020_2A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_10020_2A4 {
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A4() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+class Cycle_B_1_10020_2A5 {
+    int a;
+    int sum;
+
+    Cycle_B_1_10020_2A5() {
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 8;
+    }
+}
+
+
+public class Cycle_B_1_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_10020_A1 a1_0 = new Cycle_B_1_10020_A1();
+        a1_0.a2_0 = new Cycle_B_1_10020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10020_A3();
+        Cycle_B_1_10020_A4 a4_0 = new Cycle_B_1_10020_A4();
+        Cycle_B_1_10020_A5 a5_0 = new Cycle_B_1_10020_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        Cycle_B_1_10020_2A1 a1_20 = new Cycle_B_1_10020_2A1();
+        a1_20.a2_0 = new Cycle_B_1_10020_2A2();
+        a1_20.a2_0.a3_0 = new Cycle_B_1_10020_2A3();
+        Cycle_B_1_10020_2A4 a4_20 = new Cycle_B_1_10020_2A4();
+        Cycle_B_1_10020_2A5 a5_20 = new Cycle_B_1_10020_2A5();
+        a1_20.a4_0 = a4_20;
+        a1_20.a5_0 = a5_20;
+        a1_20.a2_0.a3_0.a1_0 = a1_20;
+        a1_20.add();
+        a1_20.a2_0.add();
+        a1_20.a2_0.a3_0.add();
+        a4_20.add();
+        a5_20.add();
+        int nsum1 = (a1_20.sum + a1_20.a2_0.sum + a1_20.a2_0.a3_0.sum + a4_20.sum + a5_20.sum);
+        nsum += nsum1;
+        if (nsum == 61)
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0058-rc-function-Cycle_B_2_00010/Cycle_B_2_00010.java b/test/testsuite/ouroboros/rc_test/RC0058-rc-function-Cycle_B_2_00010/Cycle_B_2_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..662af34f1157fd2fc325aacb0d0c38f39c6e47e5
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0058-rc-function-Cycle_B_2_00010/Cycle_B_2_00010.java
@@ -0,0 +1,115 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00010 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00010.java
+ *- @ExecuteClass: Cycle_B_2_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00010_A1 {
+    Cycle_B_2_00010_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00010_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00010_A2 {
+    Cycle_B_2_00010_A3 a3_0;
+    Cycle_B_2_00010_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00010_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00010_A3 {
+    Cycle_B_2_00010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00010_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00010_A4 {
+    Cycle_B_2_00010_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00010_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+public class Cycle_B_2_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00010_A1 a1_0 = new Cycle_B_2_00010_A1();
+        a1_0.a2_0 = new Cycle_B_2_00010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00010_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00010_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 18)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0059-rc-function-Cycle_B_2_00020/Cycle_B_2_00020.java b/test/testsuite/ouroboros/rc_test/RC0059-rc-function-Cycle_B_2_00020/Cycle_B_2_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..df8dae07400d87336d6f63ed03de67a3b32e5025
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0059-rc-function-Cycle_B_2_00020/Cycle_B_2_00020.java
@@ -0,0 +1,117 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00020 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00020.java
+ *- @ExecuteClass: Cycle_B_2_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00020_A1 {
+    Cycle_B_2_00020_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00020_A2 {
+    Cycle_B_2_00020_A3 a3_0;
+    Cycle_B_2_00020_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00020_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00020_A3 {
+    Cycle_B_2_00020_A1 a1_0;
+    Cycle_B_2_00020_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00020_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00020_A4 {
+    Cycle_B_2_00020_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00020_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_2_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00020_A1 a1_0 = new Cycle_B_2_00020_A1();
+        a1_0.a2_0 = new Cycle_B_2_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00020_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00020_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0060-rc-function-Cycle_B_2_00030/Cycle_B_2_00030.java b/test/testsuite/ouroboros/rc_test/RC0060-rc-function-Cycle_B_2_00030/Cycle_B_2_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..80e33403a4f76330f3c52f08554d01e876035cf7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0060-rc-function-Cycle_B_2_00030/Cycle_B_2_00030.java
@@ -0,0 +1,117 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_2_00030 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00030.java
+ *- @ExecuteClass: Cycle_B_2_00030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00030_A1 {
+    Cycle_B_2_00030_A2 a2_0;
+    Cycle_B_2_00030_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00030_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00030_A2 {
+    Cycle_B_2_00030_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00030_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00030_A3 {
+    Cycle_B_2_00030_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00030_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00030_A4 {
+    Cycle_B_2_00030_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00030_A4() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00030_A1 a1_0 = new Cycle_B_2_00030_A1();
+        a1_0.a2_0 = new Cycle_B_2_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00030_A3();
+        Cycle_B_2_00030_A4 a4_0 = new Cycle_B_2_00030_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0061-rc-function-Cycle_B_2_00040/Cycle_B_2_00040.java b/test/testsuite/ouroboros/rc_test/RC0061-rc-function-Cycle_B_2_00040/Cycle_B_2_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..d30f8cd7cdf04d3de11edbd42212cc758ca12e54
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0061-rc-function-Cycle_B_2_00040/Cycle_B_2_00040.java
@@ -0,0 +1,118 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00040 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00040.java
+ *- @ExecuteClass: Cycle_B_2_00040
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00040_A1 {
+    Cycle_B_2_00040_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00040_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00040_A2 {
+    Cycle_B_2_00040_A3 a3_0;
+    Cycle_B_2_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00040_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00040_A3 {
+    Cycle_B_2_00040_A1 a1_0;
+    Cycle_B_2_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00040_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00040_A4 {
+    Cycle_B_2_00040_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00040_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_2_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00040_A1 a1_0 = new Cycle_B_2_00040_A1();
+        a1_0.a2_0 = new Cycle_B_2_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00040_A3();
+        Cycle_B_2_00040_A4 a4_0 = new Cycle_B_2_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0062-rc-function-Cycle_B_2_00050/Cycle_B_2_00050.java b/test/testsuite/ouroboros/rc_test/RC0062-rc-function-Cycle_B_2_00050/Cycle_B_2_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..c7619a2473f87d28e1cc4d2d21feeb9aefb62de3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0062-rc-function-Cycle_B_2_00050/Cycle_B_2_00050.java
@@ -0,0 +1,138 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00050 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00050.java
+ *- @ExecuteClass: Cycle_B_2_00050
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00050_A1 {
+    Cycle_B_2_00050_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00050_A2 {
+    Cycle_B_2_00050_A3 a3_0;
+    Cycle_B_2_00050_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00050_A3 {
+    Cycle_B_2_00050_A1 a1_0;
+    Cycle_B_2_00050_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00050_A4 {
+    Cycle_B_2_00050_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00050_A5 {
+    Cycle_B_2_00050_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00050_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_2_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00050_A1 a1_0 = new Cycle_B_2_00050_A1();
+        a1_0.a2_0 = new Cycle_B_2_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00050_A3();
+        Cycle_B_2_00050_A4 a4_0 = new Cycle_B_2_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00050_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0063-rc-function-Cycle_B_2_00060/Cycle_B_2_00060.java b/test/testsuite/ouroboros/rc_test/RC0063-rc-function-Cycle_B_2_00060/Cycle_B_2_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..3b478bda919ae9d4b09f63caff02c7c179111e48
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0063-rc-function-Cycle_B_2_00060/Cycle_B_2_00060.java
@@ -0,0 +1,141 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00060 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00060.java
+ *- @ExecuteClass: Cycle_B_2_00060
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00060_A1 {
+    Cycle_B_2_00060_A2 a2_0;
+    Cycle_B_2_00060_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A1() {
+        a2_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00060_A2 {
+    Cycle_B_2_00060_A3 a3_0;
+    Cycle_B_2_00060_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00060_A3 {
+    Cycle_B_2_00060_A1 a1_0;
+    Cycle_B_2_00060_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00060_A4 {
+    Cycle_B_2_00060_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00060_A5 {
+    Cycle_B_2_00060_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00060_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_2_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00060_A1 a1_0 = new Cycle_B_2_00060_A1();
+        a1_0.a2_0 = new Cycle_B_2_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00060_A3();
+        Cycle_B_2_00060_A4 a4_0 = new Cycle_B_2_00060_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00060_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0064-rc-function-Cycle_B_2_00070/Cycle_B_2_00070.java b/test/testsuite/ouroboros/rc_test/RC0064-rc-function-Cycle_B_2_00070/Cycle_B_2_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..b076620499b44892437c77e1f32d5793879c0c51
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0064-rc-function-Cycle_B_2_00070/Cycle_B_2_00070.java
@@ -0,0 +1,158 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00070 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00070.java
+ *- @ExecuteClass: Cycle_B_2_00070
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00070_A1 {
+    Cycle_B_2_00070_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A2 {
+    Cycle_B_2_00070_A3 a3_0;
+    Cycle_B_2_00070_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A3 {
+    Cycle_B_2_00070_A1 a1_0;
+    Cycle_B_2_00070_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A4 {
+    Cycle_B_2_00070_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A5 {
+    Cycle_B_2_00070_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00070_A6 {
+    Cycle_B_2_00070_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00070_A6() {
+        a3_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_2_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00070_A1 a1_0 = new Cycle_B_2_00070_A1();
+        a1_0.a2_0 = new Cycle_B_2_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00070_A3();
+        Cycle_B_2_00070_A4 a4_0 = new Cycle_B_2_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00070_A5();
+        Cycle_B_2_00070_A6 a6_0 = new Cycle_B_2_00070_A6();
+        a6_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a6_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum + a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 37)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0065-rc-function-Cycle_B_2_00080/Cycle_B_2_00080.java b/test/testsuite/ouroboros/rc_test/RC0065-rc-function-Cycle_B_2_00080/Cycle_B_2_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..95c33d52ddb07614b3312a57dbd1f9c8ee9d66b4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0065-rc-function-Cycle_B_2_00080/Cycle_B_2_00080.java
@@ -0,0 +1,144 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00080 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00080.java
+ *- @ExecuteClass: Cycle_B_2_00080
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00080_A1 {
+    Cycle_B_2_00080_A2 a2_0;
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A1() {
+        a2_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A2 {
+    Cycle_B_2_00080_A3 a3_0;
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A3 {
+    Cycle_B_2_00080_A1 a1_0;
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A4 {
+    Cycle_B_2_00080_A3 a3_0;
+    Cycle_B_2_00080_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A4() {
+        a3_0 = null;
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A5 {
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class Cycle_B_2_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0066-rc-function-Cycle_B_2_00090/Cycle_B_2_00090.java b/test/testsuite/ouroboros/rc_test/RC0066-rc-function-Cycle_B_2_00090/Cycle_B_2_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..4040d0cd4771db07f819f4806d7ee192d61d583b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0066-rc-function-Cycle_B_2_00090/Cycle_B_2_00090.java
@@ -0,0 +1,97 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00090 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00090.java
+ *- @ExecuteClass: Cycle_B_2_00090
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00090_A1 {
+    Cycle_B_2_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00090_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00090_A2 {
+    Cycle_B_2_00090_A1 a1_0;
+    Cycle_B_2_00090_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00090_A2() {
+        a1_0 = null;
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00090_A3 {
+    Cycle_B_2_00090_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00090_A3() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+public class Cycle_B_2_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00090_A1 a1_0 = new Cycle_B_2_00090_A1();
+        Cycle_B_2_00090_A3 a3_0 = new Cycle_B_2_00090_A3();
+        a1_0.a2_0 = new Cycle_B_2_00090_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a3_0.a2_0 = a1_0.a2_0;
+        a3_0.a2_0.a3_0 = a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 9)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0067-rc-function-Cycle_B_2_00100/Cycle_B_2_00100.java b/test/testsuite/ouroboros/rc_test/RC0067-rc-function-Cycle_B_2_00100/Cycle_B_2_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..ca11b4de538b46db96fd2d0d3bf1e115258a3c41
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0067-rc-function-Cycle_B_2_00100/Cycle_B_2_00100.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00100 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00100.java
+ *- @ExecuteClass: Cycle_B_2_00100
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00100_A1 {
+    Cycle_B_2_00100_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00100_A2 {
+    Cycle_B_2_00100_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00100_A3 {
+    Cycle_B_2_00100_A1 a1_0;
+    Cycle_B_2_00100_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00100_A4 {
+    Cycle_B_2_00100_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_B_2_00100_A5 {
+    Cycle_B_2_00100_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00100_A5() {
+        a3_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_B_2_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00100_A1 a1_0 = new Cycle_B_2_00100_A1();
+        a1_0.a2_0 = new Cycle_B_2_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00100_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00100_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00100_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 29)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0068-rc-function-Cycle_B_2_00110/Cycle_B_2_00110.java b/test/testsuite/ouroboros/rc_test/RC0068-rc-function-Cycle_B_2_00110/Cycle_B_2_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..30d06728d72147e970b4041607d88a32f013b981
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0068-rc-function-Cycle_B_2_00110/Cycle_B_2_00110.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_2_00110 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00110.java
+ *- @ExecuteClass: Cycle_B_2_00110
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00110_A1 {
+    Cycle_B_2_00110_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00110_A2 {
+    Cycle_B_2_00110_A3 a3_0;
+    Cycle_B_2_00110_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00110_A3 {
+    Cycle_B_2_00110_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00110_A4 {
+    Cycle_B_2_00110_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_B_2_00110_A5 {
+    Cycle_B_2_00110_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00110_A5() {
+        a2_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+public class Cycle_B_2_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00110_A1 a1_0 = new Cycle_B_2_00110_A1();
+        a1_0.a2_0 = new Cycle_B_2_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00110_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00110_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_2_00110_A5();
+        a1_0.a2_0.a4_0.a5_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0069-rc-function-Cycle_B_2_00120/Cycle_B_2_00120.java b/test/testsuite/ouroboros/rc_test/RC0069-rc-function-Cycle_B_2_00120/Cycle_B_2_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..9138cbcbccd3ba2eaca72fb3cf88b02c11ce0ec3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0069-rc-function-Cycle_B_2_00120/Cycle_B_2_00120.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00120 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00120.java
+ *- @ExecuteClass: Cycle_B_2_00120
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00120_A1 {
+    Cycle_B_2_00120_A2 a2_0;
+    Cycle_B_2_00120_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00120_A2 {
+    Cycle_B_2_00120_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00120_A3 {
+    Cycle_B_2_00120_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00120_A4 {
+    Cycle_B_2_00120_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+class Cycle_B_2_00120_A5 {
+    Cycle_B_2_00120_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00120_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class Cycle_B_2_00120 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00120_A1 a1_0 = new Cycle_B_2_00120_A1();
+        a1_0.a2_0 = new Cycle_B_2_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00120_A3();
+        a1_0.a4_0 = new Cycle_B_2_00120_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a4_0.a5_0 = new Cycle_B_2_00120_A5();
+        a1_0.a4_0.a5_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a4_0.add();
+        a1_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a4_0.sum + a1_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 27)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0070-rc-function-Cycle_B_2_00130/Cycle_B_2_00130.java b/test/testsuite/ouroboros/rc_test/RC0070-rc-function-Cycle_B_2_00130/Cycle_B_2_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..07051ccd0503c6189ea468a8039a2c952e2f3753
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0070-rc-function-Cycle_B_2_00130/Cycle_B_2_00130.java
@@ -0,0 +1,154 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00130 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00130.java
+ *- @ExecuteClass: Cycle_B_2_00130
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00130_A1 {
+    Cycle_B_2_00130_A2 a2_0;
+    Cycle_B_2_00130_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00130_A2 {
+    Cycle_B_2_00130_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00130_A3 {
+    Cycle_B_2_00130_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00130_A4 {
+    Cycle_B_2_00130_A1 a1_0;
+    Cycle_B_2_00130_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A4() {
+        a1_0 = null;
+        a6_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_B_2_00130_A5 {
+    Cycle_B_2_00130_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A5() {
+        a3_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_B_2_00130_A6 {
+    Cycle_B_2_00130_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00130_A6() {
+        a5_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+public class Cycle_B_2_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00130_A1 a1_0 = new Cycle_B_2_00130_A1();
+        a1_0.a2_0 = new Cycle_B_2_00130_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00130_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00130_A4();
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        Cycle_B_2_00130_A5 a5_0 = new Cycle_B_2_00130_A5();
+        a1_0.a2_0.a3_0.a4_0.a6_0 = new Cycle_B_2_00130_A6();
+        a1_0.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_0;
+        a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a6_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a5_0.sum + a1_0.a2_0.a3_0.a4_0.a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 45)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0071-rc-function-Cycle_B_2_00140/Cycle_B_2_00140.java b/test/testsuite/ouroboros/rc_test/RC0071-rc-function-Cycle_B_2_00140/Cycle_B_2_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..1dd15f138c6932bcba39091d09446fdc28386998
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0071-rc-function-Cycle_B_2_00140/Cycle_B_2_00140.java
@@ -0,0 +1,99 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00140 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00140.java
+ *- @ExecuteClass: Cycle_B_2_00140
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00140_A1 {
+    Cycle_B_2_00140_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00140_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00140_A2 {
+    Cycle_B_2_00140_A3 a3_0;
+    Cycle_B_2_00140_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00140_A2() {
+        a3_0 = null;
+        a1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00140_A3 {
+    Cycle_B_2_00140_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00140_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00140_A1 a1_0 = new Cycle_B_2_00140_A1();
+        a1_0.a2_0 = new Cycle_B_2_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00140_A3();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0072-rc-function-Cycle_B_2_00150/Cycle_B_2_00150.java b/test/testsuite/ouroboros/rc_test/RC0072-rc-function-Cycle_B_2_00150/Cycle_B_2_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..3c63e484606f012cbfc7678815373a526006b457
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0072-rc-function-Cycle_B_2_00150/Cycle_B_2_00150.java
@@ -0,0 +1,97 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00150 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00150.java
+ *- @ExecuteClass: Cycle_B_2_00150
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00150_A1 {
+    Cycle_B_2_00150_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00150_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00150_A2 {
+    Cycle_B_2_00150_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00150_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00150_A3 {
+    Cycle_B_2_00150_A1 a1_0;
+    Cycle_B_2_00150_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00150_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00150_A1 a1_0 = new Cycle_B_2_00150_A1();
+        a1_0.a2_0 = new Cycle_B_2_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 14)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0073-rc-function-Cycle_B_2_00160/Cycle_B_2_00160.java b/test/testsuite/ouroboros/rc_test/RC0073-rc-function-Cycle_B_2_00160/Cycle_B_2_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..9ed05fb99f50d1b9483d17266d483ef81f0446fe
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0073-rc-function-Cycle_B_2_00160/Cycle_B_2_00160.java
@@ -0,0 +1,97 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00160 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00160.java
+ *- @ExecuteClass: Cycle_B_2_00160
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00160_A1 {
+    Cycle_B_2_00160_A2 a2_0;
+    Cycle_B_2_00160_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00160_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00160_A2 {
+    Cycle_B_2_00160_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00160_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00160_A3 {
+    Cycle_B_2_00160_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00160_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00160_A1 a1_0 = new Cycle_B_2_00160_A1();
+        a1_0.a2_0 = new Cycle_B_2_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00160_A3();
+        a1_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0074-rc-function-Cycle_B_2_00170/Cycle_B_2_00170.java b/test/testsuite/ouroboros/rc_test/RC0074-rc-function-Cycle_B_2_00170/Cycle_B_2_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..3f99ef3cf4ba38ac5475317708df9edc0a37aefa
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0074-rc-function-Cycle_B_2_00170/Cycle_B_2_00170.java
@@ -0,0 +1,115 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00170 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00170.java
+ *- @ExecuteClass: Cycle_B_2_00170
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00170_A1 {
+    Cycle_B_2_00170_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00170_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00170_A2 {
+    Cycle_B_2_00170_A3 a3_0;
+    Cycle_B_2_00170_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00170_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00170_A3 {
+    Cycle_B_2_00170_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00170_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00170_A4 {
+    Cycle_B_2_00170_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00170_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00170_A1 a1_0 = new Cycle_B_2_00170_A1();
+        a1_0.a2_0 = new Cycle_B_2_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00170_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00170_A4();
+        a1_0.a2_0.a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0075-rc-function-Cycle_B_2_00180/Cycle_B_2_00180.java b/test/testsuite/ouroboros/rc_test/RC0075-rc-function-Cycle_B_2_00180/Cycle_B_2_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..aa91fed0ffb78933665c5cbc7a71dc19616ef429
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0075-rc-function-Cycle_B_2_00180/Cycle_B_2_00180.java
@@ -0,0 +1,116 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00180 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00180.java
+ *- @ExecuteClass: Cycle_B_2_00180
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00180_A1 {
+    Cycle_B_2_00180_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00180_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00180_A2 {
+    Cycle_B_2_00180_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00180_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00180_A3 {
+    Cycle_B_2_00180_A1 a1_0;
+    Cycle_B_2_00180_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00180_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00180_A4 {
+    Cycle_B_2_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00180_A4() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00180_A1 a1_0 = new Cycle_B_2_00180_A1();
+        a1_0.a2_0 = new Cycle_B_2_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00180_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00180_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            System.out.println("ExpectResult");
+    }
+
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0076-rc-function-Cycle_B_2_00190/Cycle_B_2_00190.java b/test/testsuite/ouroboros/rc_test/RC0076-rc-function-Cycle_B_2_00190/Cycle_B_2_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..d5e3f978ac06312dc182e3d57ee619677ad978cb
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0076-rc-function-Cycle_B_2_00190/Cycle_B_2_00190.java
@@ -0,0 +1,115 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00190 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00190.java
+ *- @ExecuteClass: Cycle_B_2_00190
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00190_A1 {
+    Cycle_B_2_00190_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00190_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00190_A2 {
+    Cycle_B_2_00190_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00190_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00190_A3 {
+    Cycle_B_2_00190_A1 a1_0;
+    Cycle_B_2_00190_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00190_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00190_A4 {
+    Cycle_B_2_00190_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00190_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00190_A1 a1_0 = new Cycle_B_2_00190_A1();
+        a1_0.a2_0 = new Cycle_B_2_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00190_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00190_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0077-rc-function-Cycle_B_2_00200/Cycle_B_2_00200.java b/test/testsuite/ouroboros/rc_test/RC0077-rc-function-Cycle_B_2_00200/Cycle_B_2_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..a3a21dde3248e3f554fe721df2c89e8157d5f7db
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0077-rc-function-Cycle_B_2_00200/Cycle_B_2_00200.java
@@ -0,0 +1,116 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00200 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00200.java
+ *- @ExecuteClass: Cycle_B_2_00200
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00200_A1 {
+    Cycle_B_2_00200_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00200_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00200_A2 {
+    Cycle_B_2_00200_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00200_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00200_A3 {
+    Cycle_B_2_00200_A1 a1_0;
+    Cycle_B_2_00200_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00200_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00200_A4 {
+    Cycle_B_2_00200_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00200_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00200_A1 a1_0 = new Cycle_B_2_00200_A1();
+        a1_0.a2_0 = new Cycle_B_2_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00200_A3();
+        Cycle_B_2_00200_A4 a4_0 = new Cycle_B_2_00200_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0078-rc-function-Cycle_B_2_00210/Cycle_B_2_00210.java b/test/testsuite/ouroboros/rc_test/RC0078-rc-function-Cycle_B_2_00210/Cycle_B_2_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..93c29345ca69add0f0e221167cd92cc31643a818
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0078-rc-function-Cycle_B_2_00210/Cycle_B_2_00210.java
@@ -0,0 +1,210 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00210 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00210.java
+ *- @ExecuteClass: Cycle_B_2_00210
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00210_A1 {
+    Cycle_B_2_00210_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A2 {
+    Cycle_B_2_00210_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A3 {
+    Cycle_B_2_00210_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A4 {
+    Cycle_B_2_00210_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A5 {
+    Cycle_B_2_00210_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A6 {
+    Cycle_B_2_00210_A1 a1_0;
+    Cycle_B_2_00210_A8 a8_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A6() {
+        a1_0 = null;
+        a8_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a8_0.a;
+    }
+}
+
+class Cycle_B_2_00210_A8 {
+    Cycle_B_2_00210_A9 a9_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A9 {
+    Cycle_B_2_00210_A7 a7_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_B_2_00210_A7 {
+    Cycle_B_2_00210_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00210_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00210 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00210_A1 a1_0 = new Cycle_B_2_00210_A1();
+        a1_0.a2_0 = new Cycle_B_2_00210_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00210_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00210_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00210_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00210_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0 = new Cycle_B_2_00210_A8();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0 = new Cycle_B_2_00210_A9();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00210_A7();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0079-rc-function-Cycle_B_2_00220/Cycle_B_2_00220.java b/test/testsuite/ouroboros/rc_test/RC0079-rc-function-Cycle_B_2_00220/Cycle_B_2_00220.java
new file mode 100755
index 0000000000000000000000000000000000000000..1b022333348d802d1dba6dacacdd72d08bd1fc13
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0079-rc-function-Cycle_B_2_00220/Cycle_B_2_00220.java
@@ -0,0 +1,210 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00220.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00220 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00220.java
+ *- @ExecuteClass: Cycle_B_2_00220
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00220_A1 {
+    Cycle_B_2_00220_A2 a2_0;
+    Cycle_B_2_00220_A8 a8_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A1() {
+        a2_0 = null;
+        a8_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a8_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A2 {
+    Cycle_B_2_00220_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A3 {
+    Cycle_B_2_00220_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A4 {
+    Cycle_B_2_00220_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A5 {
+    Cycle_B_2_00220_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A6 {
+    Cycle_B_2_00220_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A6() {
+        a1_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_2_00220_A8 {
+    Cycle_B_2_00220_A9 a9_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A9 {
+    Cycle_B_2_00220_A7 a7_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_B_2_00220_A7 {
+    Cycle_B_2_00220_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00220_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00220 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00220_A1 a1_0 = new Cycle_B_2_00220_A1();
+        a1_0.a2_0 = new Cycle_B_2_00220_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00220_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00220_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00220_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00220_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a8_0 = new Cycle_B_2_00220_A8();
+        a1_0.a8_0.a9_0 = new Cycle_B_2_00220_A9();
+        a1_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00220_A7();
+        a1_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a8_0.add();
+        a1_0.a8_0.a9_0.add();
+        a1_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a8_0.sum + a1_0.a8_0.a9_0.sum + a1_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0080-rc-function-Cycle_B_2_00230/Cycle_B_2_00230.java b/test/testsuite/ouroboros/rc_test/RC0080-rc-function-Cycle_B_2_00230/Cycle_B_2_00230.java
new file mode 100755
index 0000000000000000000000000000000000000000..26f1f0fedf654afa87b2284e319084e54c64a819
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0080-rc-function-Cycle_B_2_00230/Cycle_B_2_00230.java
@@ -0,0 +1,231 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00230.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00230 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00230.java
+ *- @ExecuteClass: Cycle_B_2_00230
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_B_2_00230_A1 {
+    Cycle_B_2_00230_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A2 {
+    Cycle_B_2_00230_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A3 {
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A4 {
+    Cycle_B_2_00230_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A5 {
+    Cycle_B_2_00230_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A6 {
+    Cycle_B_2_00230_A1 a1_0;
+    Cycle_B_2_00230_A10 a10_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A6() {
+        a1_0 = null;
+        a10_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a10_0.a;
+    }
+}
+
+class Cycle_B_2_00230_A8 {
+    Cycle_B_2_00230_A9 a9_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A9 {
+    Cycle_B_2_00230_A7 a7_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A7 {
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A10 {
+    Cycle_B_2_00230_A8 a8_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A10() {
+        a8_0 = null;
+        a = 10;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+
+public class Cycle_B_2_00230 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        //System.out.println(nsum);
+        if (nsum == 97)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0081-rc-function-Cycle_B_2_00240/Cycle_B_2_00240.java b/test/testsuite/ouroboros/rc_test/RC0081-rc-function-Cycle_B_2_00240/Cycle_B_2_00240.java
new file mode 100755
index 0000000000000000000000000000000000000000..cba12c2fcc4c4d424a9ebb86183325ca4fd283cc
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0081-rc-function-Cycle_B_2_00240/Cycle_B_2_00240.java
@@ -0,0 +1,225 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Cycle_B_2_00240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00240 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_B_2_00240.java
+ *- @ExecuteClass: Cycle_B_2_00240
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class Cycle_B_2_00240_A1 {
+    Cycle_B_2_00240_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_B_2_00240_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_B_2_00240_A2 {
+    Cycle_B_2_00240_A1 a1_0;
+    Cycle_B_2_00240_A3 a3_0;
+    Cycle_B_2_00240_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_B_2_00240_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_B_2_00240_A3 {
+    Cycle_B_2_00240_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_B_2_00240_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00240_A4 {
+    Cycle_B_2_00240_A1 a1_0;
+    Cycle_B_2_00240_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_B_2_00240_A4(String strObjectName) {
+        a2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+
+class Cycle_B_2_00240_B1 {
+    Cycle_B_2_00240_A3 a3_0;
+    Cycle_B_2_00240_B2 b2_0;
+    Nocycle_B_2_00240_C2 c2_0;
+
+
+    int a;
+    int sum;
+
+    Cycle_B_2_00240_B1() {
+        a3_0 = null;
+        b2_0 = null;
+        c2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a + b2_0.a + c2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00240_B2 {
+    Cycle_B_2_00240_B1 b1_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00240_B2() {
+        b1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_B_2_00240_C1 {
+    Nocycle_B_2_00240_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_B_2_00240_C1(String strObjectName) {
+        c2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+    void add() {
+        sum = a + c2_0.a;
+    }
+}
+
+class Nocycle_B_2_00240_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_B_2_00240_C2(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Cycle_B_2_00240 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00240_A1 a1_main = new Cycle_B_2_00240_A1("a1_main");
+        a1_main.a2_0 = new Cycle_B_2_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_B_2_00240_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_B_2_00240_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+
+        Cycle_B_2_00240_B1 b1_0 = new Cycle_B_2_00240_B1();
+        b1_0.a3_0 = new Cycle_B_2_00240_A3("a3_b1");
+        b1_0.b2_0 = new Cycle_B_2_00240_B2();
+        b1_0.c2_0 = new Nocycle_B_2_00240_C2("c2_b1");
+        b1_0.b2_0.b1_0 = b1_0;
+        b1_0.add();
+        b1_0.b2_0.add();
+        int nsum = (b1_0.sum + b1_0.b2_0.sum);
+        Nocycle_B_2_00240_C1 c1_main = new Nocycle_B_2_00240_C1("c1_main");
+        c1_main.c2_0 = new Nocycle_B_2_00240_C2("c2_0");
+        c1_main.add();
+        c1_main.c2_0.add();
+        int result2 = c1_main.sum + c1_main.c2_0.sum;
+        if (result == 1124 && nsum == 310 && result2 == 704)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0082-rc-function-Nocycle_a_00010/Nocycle_a_00010.java b/test/testsuite/ouroboros/rc_test/RC0082-rc-function-Nocycle_a_00010/Nocycle_a_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..74f4e12e983bf8d9b5a4b0a7de51240f56c76cfb
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0082-rc-function-Nocycle_a_00010/Nocycle_a_00010.java
@@ -0,0 +1,85 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00010 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00010.java
+ *- @ExecuteClass: Nocycle_a_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class Nocycle_a_00010_A1 {
+    Nocycle_a_00010_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00010_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);  
+//   }  
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00010_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00010_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);  
+//   }
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        Nocycle_a_00010_A1 a1_main = new Nocycle_a_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00010_B1("b1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 704)
+            System.out.println("ExpectResult");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0083-rc-function-Nocycle_a_00020/Nocycle_a_00020.java b/test/testsuite/ouroboros/rc_test/RC0083-rc-function-Nocycle_a_00020/Nocycle_a_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..025c924447c09f2382b8fa96fabfa68ac0c6507f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0083-rc-function-Nocycle_a_00020/Nocycle_a_00020.java
@@ -0,0 +1,98 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00020 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00020.java
+ *- @ExecuteClass: Nocycle_a_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00020_A1 {
+    Nocycle_a_00020_B1 b1_0;
+    Nocycle_a_00020_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00020_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00020_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00020_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00020_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00020_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00020_A1 a1_main = new Nocycle_a_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00020_B2("b2_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1310)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0084-rc-function-Nocycle_a_00030/Nocycle_a_00030.java b/test/testsuite/ouroboros/rc_test/RC0084-rc-function-Nocycle_a_00030/Nocycle_a_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..4672cd13772bb35ed810fd34a2f879e2a6cde189
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0084-rc-function-Nocycle_a_00030/Nocycle_a_00030.java
@@ -0,0 +1,118 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00030 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00030.java
+ *- @ExecuteClass: Nocycle_a_00030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00030_A1 {
+    Nocycle_a_00030_B1 b1_0;
+    Nocycle_a_00030_B2 b2_0;
+    Nocycle_a_00030_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00030_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+class Nocycle_a_00030_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00030_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00030_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00030_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00030_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00030_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00030_A1 a1_main = new Nocycle_a_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00030_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00030_B3("b3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        if (result == 1919)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0085-rc-function-Nocycle_a_00040/Nocycle_a_00040.java b/test/testsuite/ouroboros/rc_test/RC0085-rc-function-Nocycle_a_00040/Nocycle_a_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..89b865c942eabef7cecfba30a27e0851382f00e7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0085-rc-function-Nocycle_a_00040/Nocycle_a_00040.java
@@ -0,0 +1,265 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00040 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00040.java
+ *- @ExecuteClass: Nocycle_a_00040
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00040_A1 {
+    Nocycle_a_00040_B1 b1_0;
+    Nocycle_a_00040_B2 b2_0;
+    Nocycle_a_00040_B3 b3_0;
+    Nocycle_a_00040_B4 b4_0;
+    Nocycle_a_00040_B5 b5_0;
+    Nocycle_a_00040_B6 b6_0;
+    Nocycle_a_00040_B7 b7_0;
+    Nocycle_a_00040_B8 b8_0;
+    Nocycle_a_00040_B9 b9_0;
+    Nocycle_a_00040_B10 b10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        b5_0 = null;
+        b6_0 = null;
+        b7_0 = null;
+        b8_0 = null;
+        b9_0 = null;
+        b10_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + b5_0.a + b6_0.a + b7_0.a + b8_0.a + b9_0.a + b10_0.a;
+    }
+}
+
+class Nocycle_a_00040_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00040_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B5 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B5(String strObjectName) {
+        a = 205;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B6 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B6(String strObjectName) {
+        a = 206;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B7 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B7(String strObjectName) {
+        a = 207;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00040_B8 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B8(String strObjectName) {
+        a = 208;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B9 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B9(String strObjectName) {
+        a = 209;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00040_B10 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00040_B10(String strObjectName) {
+        a = 210;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00040_A1 a1_main = new Nocycle_a_00040_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00040_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00040_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00040_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00040_B4("b4_0");
+        a1_main.b5_0 = new Nocycle_a_00040_B5("b5_0");
+        a1_main.b6_0 = new Nocycle_a_00040_B6("b6_0");
+        a1_main.b7_0 = new Nocycle_a_00040_B7("b7_0");
+        a1_main.b8_0 = new Nocycle_a_00040_B8("b8_0");
+        a1_main.b9_0 = new Nocycle_a_00040_B9("b9_0");
+        a1_main.b10_0 = new Nocycle_a_00040_B10("b10_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b5_0.add();
+        a1_main.b6_0.add();
+        a1_main.b7_0.add();
+        a1_main.b8_0.add();
+        a1_main.b9_0.add();
+        a1_main.b10_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b5_0.sum + a1_main.b6_0.sum + a1_main.b7_0.sum + a1_main.b8_0.sum + a1_main.b9_0.sum + a1_main.b10_0.sum;
+        if (result == 6266)
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0086-rc-function-Nocycle_a_00050/Nocycle_a_00050.java b/test/testsuite/ouroboros/rc_test/RC0086-rc-function-Nocycle_a_00050/Nocycle_a_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..8f611d9a27190f9bcbe940aa7c7618f2a2a3f7c4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0086-rc-function-Nocycle_a_00050/Nocycle_a_00050.java
@@ -0,0 +1,205 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00050 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00050.java
+ *- @ExecuteClass: Nocycle_a_00050
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00050_A1 {
+    Nocycle_a_00050_B1 b1_0;
+    Nocycle_a_00050_B2 b2_0;
+    Nocycle_a_00050_B3 b3_0;
+    Nocycle_a_00050_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_a_00050_B1 {
+    Nocycle_a_00050_C1 c1_0;
+    Nocycle_a_00050_C2 c2_0;
+    Nocycle_a_00050_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+class Nocycle_a_00050_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00050_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00050_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00050_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00050_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00050_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00050_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00050_A1 a1_main = new Nocycle_a_00050_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00050_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00050_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_a_00050_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_a_00050_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_a_00050_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00050_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00050_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        a1_main.b1_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c2_0.sum+a1_main.b1_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum + a1_main.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5048)
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0087-rc-function-Nocycle_a_00060/Nocycle_a_00060.java b/test/testsuite/ouroboros/rc_test/RC0087-rc-function-Nocycle_a_00060/Nocycle_a_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..b253a7d2eef6674b6e5d2e5b4702a13cec7feb05
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0087-rc-function-Nocycle_a_00060/Nocycle_a_00060.java
@@ -0,0 +1,204 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00060 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00060.java
+ *- @ExecuteClass: Nocycle_a_00060
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00060_A1 {
+    Nocycle_a_00060_B1 b1_0;
+    Nocycle_a_00060_B2 b2_0;
+    Nocycle_a_00060_B3 b3_0;
+    Nocycle_a_00060_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_a_00060_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_B2 {
+    Nocycle_a_00060_C1 c1_0;
+    Nocycle_a_00060_C2 c2_0;
+    Nocycle_a_00060_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_B2(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+
+class Nocycle_a_00060_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00060_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00060_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00060_A1 a1_main = new Nocycle_a_00060_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00060_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00060_B2("b2_0");
+        a1_main.b2_0.c1_0 = new Nocycle_a_00060_C1("c1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00060_C2("c2_0");
+        a1_main.b2_0.c3_0 = new Nocycle_a_00060_C3("c3_0");
+        a1_main.b3_0 = new Nocycle_a_00060_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00060_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c1_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b2_0.c3_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c1_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b2_0.c3_0.sum;
+        if (result == 5047)
+            System.out.println("ExpectResult");
+
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0088-rc-function-Nocycle_a_00070/Nocycle_a_00070.java b/test/testsuite/ouroboros/rc_test/RC0088-rc-function-Nocycle_a_00070/Nocycle_a_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..c3d9aa10c1a2f7a3322de5a1fb88a5a078e54e58
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0088-rc-function-Nocycle_a_00070/Nocycle_a_00070.java
@@ -0,0 +1,210 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00070 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00070.java
+ *- @ExecuteClass: Nocycle_a_00070
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00070_A1 {
+    Nocycle_a_00070_B1 b1_0;
+    Nocycle_a_00070_B2 b2_0;
+    Nocycle_a_00070_B3 b3_0;
+    Nocycle_a_00070_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_a_00070_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00070_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00070_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00070_B4 {
+    Nocycle_a_00070_C1 c1_0;
+    Nocycle_a_00070_C2 c2_0;
+    Nocycle_a_00070_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_B4(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+
+class Nocycle_a_00070_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00070_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00070_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00070_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00070_A1 a1_main = new Nocycle_a_00070_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00070_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00070_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00070_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00070_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_00070_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_00070_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00070_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5045)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0089-rc-function-Nocycle_a_00080/Nocycle_a_00080.java b/test/testsuite/ouroboros/rc_test/RC0089-rc-function-Nocycle_a_00080/Nocycle_a_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..80f3863992c4a79c610d14d80836d812a3489cd0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0089-rc-function-Nocycle_a_00080/Nocycle_a_00080.java
@@ -0,0 +1,102 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00080 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00080.java
+ *- @ExecuteClass: Nocycle_a_00080
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00080_A1 {
+    Nocycle_a_00080_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00080_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00080_B1 {
+    Nocycle_a_00080_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00080_B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00080_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00080_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00080_A1 a1_main = new Nocycle_a_00080_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00080_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00080_C1("c1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1406)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0090-rc-function-Nocycle_a_00090/Nocycle_a_00090.java b/test/testsuite/ouroboros/rc_test/RC0090-rc-function-Nocycle_a_00090/Nocycle_a_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..99af0ab6c264a69a32e5d4e3ba6e91ee4bef1884
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0090-rc-function-Nocycle_a_00090/Nocycle_a_00090.java
@@ -0,0 +1,123 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00090 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00090.java
+ *- @ExecuteClass: Nocycle_a_00090
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00090_A1 {
+    Nocycle_a_00090_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00090_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00090_B1 {
+    Nocycle_a_00090_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00090_B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00090_C1 {
+    Nocycle_a_00090_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00090_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_00090_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00090_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00090_A1 a1_main = new Nocycle_a_00090_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00090_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00090_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00090_D1("d1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2308)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0091-rc-function-Nocycle_a_00100/Nocycle_a_00100.java b/test/testsuite/ouroboros/rc_test/RC0091-rc-function-Nocycle_a_00100/Nocycle_a_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..a39af0862e3e463e4e84aba00499401117009e74
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0091-rc-function-Nocycle_a_00100/Nocycle_a_00100.java
@@ -0,0 +1,250 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00100 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00100.java
+ *- @ExecuteClass: Nocycle_a_00100
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00100_A1 {
+    Nocycle_a_00100_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00100_B1 {
+    Nocycle_a_00100_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00100_C1 {
+    Nocycle_a_00100_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_00100_D1 {
+    Nocycle_a_00100_E1 e1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_D1(String strObjectName) {
+        e1_0 = null;
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + e1_0.a;
+    }
+}
+
+class Nocycle_a_00100_E1 {
+    Nocycle_a_00100_F1 f1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_E1(String strObjectName) {
+        f1_0 = null;
+        a = 501;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + f1_0.a;
+    }
+}
+
+
+class Nocycle_a_00100_F1 {
+    Nocycle_a_00100_G1 g1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_F1(String strObjectName) {
+        g1_0 = null;
+        a = 601;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + g1_0.a;
+    }
+}
+
+class Nocycle_a_00100_G1 {
+    Nocycle_a_00100_H1 h1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_G1(String strObjectName) {
+        h1_0 = null;
+        a = 701;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + h1_0.a;
+    }
+}
+
+
+class Nocycle_a_00100_H1 {
+    Nocycle_a_00100_I1 i1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_H1(String strObjectName) {
+        i1_0 = null;
+        a = 801;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + i1_0.a;
+    }
+}
+
+
+class Nocycle_a_00100_I1 {
+    Nocycle_a_00100_J1 j1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_I1(String strObjectName) {
+        j1_0 = null;
+        a = 901;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + j1_0.a;
+    }
+}
+
+class Nocycle_a_00100_J1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00100_J1(String strObjectName) {
+        a = 1001;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00100_A1 a1_main = new Nocycle_a_00100_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00100_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00100_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00100_D1("d1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_00100_E1("e1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_00100_F1("f1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_00100_G1("g1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_00100_H1("h1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_00100_I1("i1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_00100_J1("j1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        if (result == 11920)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0092-rc-function-Nocycle_a_00110/Nocycle_a_00110.java b/test/testsuite/ouroboros/rc_test/RC0092-rc-function-Nocycle_a_00110/Nocycle_a_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..4130eced92416753d1b5fb413ee6857e23aae753
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0092-rc-function-Nocycle_a_00110/Nocycle_a_00110.java
@@ -0,0 +1,311 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00110 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00110.java
+ *- @ExecuteClass: Nocycle_a_00110
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00110_A1 {
+    Nocycle_a_00110_B1 b1_0;
+    Nocycle_a_00110_B2 b2_0;
+    Nocycle_a_00110_B3 b3_0;
+    Nocycle_a_00110_B4 b4_0;
+    Nocycle_a_00110_D5 d5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        d5_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + d5_0.a;
+    }
+}
+
+class Nocycle_a_00110_B1 {
+    Nocycle_a_00110_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+
+class Nocycle_a_00110_B2 {
+    Nocycle_a_00110_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_B2(String strObjectName) {
+        c2_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c2_0.a;
+    }
+}
+
+
+class Nocycle_a_00110_B3 {
+    Nocycle_a_00110_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00110_B4 {
+    Nocycle_a_00110_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_B4(String strObjectName) {
+        c3_0 = null;
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c3_0.a;
+    }
+}
+
+
+class Nocycle_a_00110_C1 {
+    Nocycle_a_00110_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_C1(String strObjectName) {
+        d2_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+class Nocycle_a_00110_C2 {
+    Nocycle_a_00110_D3 d3_0;
+    Nocycle_a_00110_D4 d4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_C2(String strObjectName) {
+        d3_0 = null;
+        d4_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d3_0.a + d4_0.a;
+    }
+}
+
+class Nocycle_a_00110_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_00110_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00110_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00110_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00110_D4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D4(String strObjectName) {
+        a = 404;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00110_D5 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00110_D5(String strObjectName) {
+        a = 405;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00110_A1 a1_main = new Nocycle_a_00110_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00110_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00110_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00110_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00110_B4("b4_0");
+        a1_main.b1_0.d1_0 = new Nocycle_a_00110_D1("d1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00110_C2("c2_0");
+        a1_main.b3_0.c1_0 = new Nocycle_a_00110_C1("c1_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00110_C3("c3_0");
+        a1_main.b3_0.c1_0.d2_0 = new Nocycle_a_00110_D2("d2_0");
+        a1_main.b2_0.c2_0.d3_0 = new Nocycle_a_00110_D3("d3_0");
+        a1_main.b2_0.c2_0.d4_0 = new Nocycle_a_00110_D4("d4_0");
+        a1_main.d5_0 = new Nocycle_a_00110_D5("d5_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b3_0.c1_0.add();
+        a1_main.b4_0.c3_0.add();
+        a1_main.b1_0.d1_0.add();
+        a1_main.b3_0.c1_0.d2_0.add();
+        a1_main.b2_0.c2_0.d3_0.add();
+        a1_main.b2_0.c2_0.d4_0.add();
+        a1_main.d5_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b3_0.c1_0.sum + a1_main.b4_0.c3_0.sum + a1_main.b1_0.d1_0.sum + a1_main.b3_0.c1_0.d2_0.sum + a1_main.b2_0.c2_0.d3_0.sum + a1_main.b2_0.c2_0.d4_0.sum + a1_main.d5_0.sum;
+        if (result == 9881)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0093-rc-function-Nocycle_a_00120/Nocycle_a_00120.java b/test/testsuite/ouroboros/rc_test/RC0093-rc-function-Nocycle_a_00120/Nocycle_a_00120.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b2449a2fb06091e482d424f5b63f694dc5678ab
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0093-rc-function-Nocycle_a_00120/Nocycle_a_00120.java
@@ -0,0 +1,90 @@
+/*
+ * -@TestCaseID:maple/runtime/rc/function/Nocycle_a_00120.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination: Nocycle_a_00120 in RC测试-No-Cycle-00.vsd.
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Nocycle_a_00120.java
+ * -@ExecuteClass: Nocycle_a_00120
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+class Nocycle_a_00120_A1 {
+    Nocycle_a_00120_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00120_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00120_A2 {
+    Nocycle_a_00120_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00120_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00120_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00120_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00120 {
+
+    public static void main(String[] args) {
+        Nocycle_a_00120_A1 a1_main = new Nocycle_a_00120_A1("a1_main");
+        Nocycle_a_00120_A2 a2_main = new Nocycle_a_00120_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum;
+        if (result == 1007) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0094-rc-function-Nocycle_a_00130/Nocycle_a_00130.java b/test/testsuite/ouroboros/rc_test/RC0094-rc-function-Nocycle_a_00130/Nocycle_a_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..e207abfb3fbea08e2dc6aade4e03b3e640c8ef58
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0094-rc-function-Nocycle_a_00130/Nocycle_a_00130.java
@@ -0,0 +1,289 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00130 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00130.java
+ *- @ExecuteClass: Nocycle_a_00130
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00130_A1 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A2 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class Nocycle_a_00130_A3 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A3(String strObjectName) {
+        b1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A4 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A4(String strObjectName) {
+        b1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A5 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A5(String strObjectName) {
+        b1_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class Nocycle_a_00130_A6 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A6(String strObjectName) {
+        b1_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A7 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A7(String strObjectName) {
+        b1_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A8 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A8(String strObjectName) {
+        b1_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A9 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A9(String strObjectName) {
+        b1_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_00130_A10 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_A10(String strObjectName) {
+        b1_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class Nocycle_a_00130_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00130_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00130_A1 a1_main = new Nocycle_a_00130_A1("a1_main");
+        Nocycle_a_00130_A2 a2_main = new Nocycle_a_00130_A2("a2_main");
+        Nocycle_a_00130_A3 a3_main = new Nocycle_a_00130_A3("a3_main");
+        Nocycle_a_00130_A4 a4_main = new Nocycle_a_00130_A4("a4_main");
+        Nocycle_a_00130_A5 a5_main = new Nocycle_a_00130_A5("a5_main");
+        Nocycle_a_00130_A6 a6_main = new Nocycle_a_00130_A6("a6_main");
+        Nocycle_a_00130_A7 a7_main = new Nocycle_a_00130_A7("a7_main");
+        Nocycle_a_00130_A8 a8_main = new Nocycle_a_00130_A8("a8_main");
+        Nocycle_a_00130_A9 a9_main = new Nocycle_a_00130_A9("a9_main");
+        Nocycle_a_00130_A10 a10_main = new Nocycle_a_00130_A10("a10_main");
+        a1_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a3_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a4_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a5_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a6_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a7_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a8_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a9_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a10_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        a3_main.b1_0.add();
+        a4_main.b1_0.add();
+        a5_main.b1_0.add();
+        a6_main.b1_0.add();
+        a7_main.b1_0.add();
+        a8_main.b1_0.add();
+        a9_main.b1_0.add();
+        a10_main.b1_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + a1_main.b1_0.sum;
+
+        if (result == 3467)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0095-rc-function-Nocycle_a_00140/Nocycle_a_00140.java b/test/testsuite/ouroboros/rc_test/RC0095-rc-function-Nocycle_a_00140/Nocycle_a_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..738fc5119f0188f530ee9964eab46fc33cbd87ff
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0095-rc-function-Nocycle_a_00140/Nocycle_a_00140.java
@@ -0,0 +1,122 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00140 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00140.java
+ *- @ExecuteClass: Nocycle_a_00140
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00140_A1 {
+    Nocycle_a_00140_B1 b1_0;
+    Nocycle_a_00140_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00140_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00140_A2 {
+    Nocycle_a_00140_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00140_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class Nocycle_a_00140_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00140_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00140_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00140_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00140_A1 a1_main = new Nocycle_a_00140_A1("a1_main");
+        Nocycle_a_00140_A2 a2_main = new Nocycle_a_00140_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00140_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 1613)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0096-rc-function-Nocycle_a_00150/Nocycle_a_00150.java b/test/testsuite/ouroboros/rc_test/RC0096-rc-function-Nocycle_a_00150/Nocycle_a_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..4e8a23ccfb6a36c92c926f9e01adc91090e9ae34
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0096-rc-function-Nocycle_a_00150/Nocycle_a_00150.java
@@ -0,0 +1,125 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00150 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00150.java
+ *- @ExecuteClass: Nocycle_a_00150
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00150_A1 {
+    Nocycle_a_00150_B1 b1_0;
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00150_A2 {
+    Nocycle_a_00150_B1 b1_0;
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00150_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00150_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 1815)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0097-rc-function-Nocycle_a_00160/Nocycle_a_00160.java b/test/testsuite/ouroboros/rc_test/RC0097-rc-function-Nocycle_a_00160/Nocycle_a_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..42345f6be063680943ea269e26243da2b553f09c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0097-rc-function-Nocycle_a_00160/Nocycle_a_00160.java
@@ -0,0 +1,182 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00160 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00160.java
+ *- @ExecuteClass: Nocycle_a_00160
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00160_A1 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00160_A2 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00160_A3 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_A3(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00160_A4 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_A4(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00160_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00160_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00160_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00160_A1 a1_main = new Nocycle_a_00160_A1("a1_main");
+        Nocycle_a_00160_A2 a2_main = new Nocycle_a_00160_A2("a2_main");
+        Nocycle_a_00160_A3 a3_main = new Nocycle_a_00160_A3("a3_main");
+        Nocycle_a_00160_A4 a4_main = new Nocycle_a_00160_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a3_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a4_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+
+        if (result == 2828)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0098-rc-function-Nocycle_a_00170/Nocycle_a_00170.java b/test/testsuite/ouroboros/rc_test/RC0098-rc-function-Nocycle_a_00170/Nocycle_a_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..aac9a9046186d763398bed66cce0a83914aeed23
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0098-rc-function-Nocycle_a_00170/Nocycle_a_00170.java
@@ -0,0 +1,214 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00170 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00170.java
+ *- @ExecuteClass: Nocycle_a_00170
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00170_A1 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+class Nocycle_a_00170_A2 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+
+class Nocycle_a_00170_A3 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_A3(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+class Nocycle_a_00170_A4 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_A4(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+
+class Nocycle_a_00170_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00170_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00170_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00170_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00170_A1 a1_main = new Nocycle_a_00170_A1("a1_main");
+        Nocycle_a_00170_A2 a2_main = new Nocycle_a_00170_A2("a2_main");
+        Nocycle_a_00170_A3 a3_main = new Nocycle_a_00170_A3("a3_main");
+        Nocycle_a_00170_A4 a4_main = new Nocycle_a_00170_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a2_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a2_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a3_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a3_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a4_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a4_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a2_main.b3_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b3_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        a4_main.b3_0.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        if (result == 4046)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0099-rc-function-Nocycle_a_00180/Nocycle_a_00180.java b/test/testsuite/ouroboros/rc_test/RC0099-rc-function-Nocycle_a_00180/Nocycle_a_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..5316990c42ad1e9779b2c0283278519eeadf8468
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0099-rc-function-Nocycle_a_00180/Nocycle_a_00180.java
@@ -0,0 +1,347 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00180 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_00180.java
+ *- @ExecuteClass: Nocycle_a_00180
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_00180_A1 {
+    Nocycle_a_00180_B1 b1_0;
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_A2 {
+    Nocycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_A3 {
+    Nocycle_a_00180_B2 b2_0;
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_a_00180_A4 {
+    Nocycle_a_00180_B3 b3_0;
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_B1 {
+    Nocycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_B2 {
+    Nocycle_a_00180_C1 c1_0;
+    Nocycle_a_00180_D1 d1_0;
+    Nocycle_a_00180_D2 d2_0;
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_B3 {
+    Nocycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_C1 {
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_00180_C2 {
+    Nocycle_a_00180_D2 d2_0;
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_a_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        if (result == 9260)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0100-rc-function-Nocycle_a_2_00010/Nocycle_a_2_00010.java b/test/testsuite/ouroboros/rc_test/RC0100-rc-function-Nocycle_a_2_00010/Nocycle_a_2_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..dd19a8eb6bc8d65147d974914fa64e9e97c1d955
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0100-rc-function-Nocycle_a_2_00010/Nocycle_a_2_00010.java
@@ -0,0 +1,135 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_2_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_2_00010 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_2_00010.java
+ *- @ExecuteClass: Nocycle_a_2_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_2_00010_A1 {
+    Nocycle_a_2_00010_B1 b1_0;
+    Nocycle_a_2_00010_B2 b2_0;
+    Nocycle_a_2_00010_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+
+class Nocycle_a_2_00010_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00010_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00010_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00010_A2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00010_A2(String strObjectName) {
+        a = 10;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_2_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_2_00010_A1 a1_main = new Nocycle_a_2_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00010_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00010_B3("b3_0");
+        Nocycle_a_2_00010_A2 a2_main = new Nocycle_a_2_00010_A2("a2_main");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a2_main.sum;
+        if (result == 1939)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0101-rc-function-Nocycle_a_2_00020/Nocycle_a_2_00020.java b/test/testsuite/ouroboros/rc_test/RC0101-rc-function-Nocycle_a_2_00020/Nocycle_a_2_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..f9e19951f2fc13fcf6da057e3d991c79b3506432
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0101-rc-function-Nocycle_a_2_00020/Nocycle_a_2_00020.java
@@ -0,0 +1,725 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Nocycle_a_2_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_2_00020 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_a_2_00020.java
+ *- @ExecuteClass: Nocycle_a_2_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Nocycle_a_2_00020_A1 {
+    Nocycle_a_2_00020_B1 b1_0;
+    Nocycle_a_2_00020_B2 b2_0;
+    Nocycle_a_2_00020_B3 b3_0;
+    Nocycle_a_2_00020_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_2_00020_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_2_00020_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_a_2_00020_B4 {
+    Nocycle_a_2_00020_C1 c1_0;
+    Nocycle_a_2_00020_C2 c2_0;
+    Nocycle_a_2_00020_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_B4(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_2A1 {
+    Nocycle_a_2_00020_2B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2B1 {
+    Nocycle_a_2_00020_2C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_2C1 {
+    Nocycle_a_2_00020_2D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2D1 {
+    Nocycle_a_2_00020_2E1 e1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2D1(String strObjectName) {
+        e1_0 = null;
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + e1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2E1 {
+    Nocycle_a_2_00020_2F1 f1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2E1(String strObjectName) {
+        f1_0 = null;
+        a = 501;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + f1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_2F1 {
+    Nocycle_a_2_00020_2G1 g1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2F1(String strObjectName) {
+        g1_0 = null;
+        a = 601;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + g1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2G1 {
+    Nocycle_a_2_00020_2H1 h1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2G1(String strObjectName) {
+        h1_0 = null;
+        a = 701;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + h1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_2H1 {
+    Nocycle_a_2_00020_2I1 i1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2H1(String strObjectName) {
+        i1_0 = null;
+        a = 801;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + i1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_2I1 {
+    Nocycle_a_2_00020_2J1 j1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2I1(String strObjectName) {
+        j1_0 = null;
+        a = 901;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + j1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_2J1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_2J1(String strObjectName) {
+        a = 1001;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_3A1 {
+    Nocycle_a_2_00020_3B1 b1_0;
+    Nocycle_a_2_00020_3D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3A2 {
+    Nocycle_a_2_00020_3B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3A3 {
+    Nocycle_a_2_00020_3B2 b2_0;
+    Nocycle_a_2_00020_3C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_3A4 {
+    Nocycle_a_2_00020_3B3 b3_0;
+    Nocycle_a_2_00020_3C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3B1 {
+    Nocycle_a_2_00020_3D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3B2 {
+    Nocycle_a_2_00020_3C1 c1_0;
+    Nocycle_a_2_00020_3D1 d1_0;
+    Nocycle_a_2_00020_3D2 d2_0;
+    Nocycle_a_2_00020_3D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3B3 {
+    Nocycle_a_2_00020_3C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3C1 {
+    Nocycle_a_2_00020_3D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_a_2_00020_3C2 {
+    Nocycle_a_2_00020_3D2 d2_0;
+    Nocycle_a_2_00020_3D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_a_2_00020_3D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_3D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_2_00020_3D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_2_00020_3D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_a_2_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_2_00020_A1 a1_main = new Nocycle_a_2_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_2_00020_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_2_00020_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_2_00020_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_2_00020_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result1 = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result1);
+        Nocycle_a_2_00020_2A1 a1_main2 = new Nocycle_a_2_00020_2A1("a1_main2");
+        a1_main2.b1_0 = new Nocycle_a_2_00020_2B1("b1_0");
+        a1_main2.b1_0.c1_0 = new Nocycle_a_2_00020_2C1("c1_0");
+        a1_main2.b1_0.c1_0.d1_0 = new Nocycle_a_2_00020_2D1("d1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_2_00020_2E1("e1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_2_00020_2F1("f1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_2_00020_2G1("g1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_2_00020_2H1("h1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_2_00020_2I1("i1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_2_00020_2J1("j1_0");
+        a1_main2.add();
+        a1_main2.b1_0.add();
+        a1_main2.b1_0.c1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+
+        int result2 = a1_main2.sum + a1_main2.b1_0.sum + a1_main2.b1_0.c1_0.sum + a1_main2.b1_0.c1_0.d1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+        Nocycle_a_2_00020_3A1 a1_main3 = new Nocycle_a_2_00020_3A1("a1_main3");
+        Nocycle_a_2_00020_3A2 a2_main = new Nocycle_a_2_00020_3A2("a2_main");
+        Nocycle_a_2_00020_3A3 a3_main = new Nocycle_a_2_00020_3A3("a3_main");
+        Nocycle_a_2_00020_3A4 a4_main = new Nocycle_a_2_00020_3A4("a4_main");
+        a1_main3.b1_0 = new Nocycle_a_2_00020_3B1("b1_0");
+        a1_main3.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a1_main3.b1_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a3_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a4_main.b3_0 = new Nocycle_a_2_00020_3B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a1_main3.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main3.b1_0.add();
+        a1_main3.d1_0.add();
+        a1_main3.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result3 = a1_main3.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main3.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main3.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+
+        int result = result1 + result2 + result3;
+        if (result == 26225)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0102-rc-function-RC_basic/RC_basic.java b/test/testsuite/ouroboros/rc_test/RC0102-rc-function-RC_basic/RC_basic.java
new file mode 100755
index 0000000000000000000000000000000000000000..56eccbb2540bd5bc9605c9f41a5270f72bb1a813
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0102-rc-function-RC_basic/RC_basic.java
@@ -0,0 +1,111 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_basic.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test RC basic operation.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_basic.java
+ *- @ExecuteClass: RC_basic
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+public class RC_basic {
+    private Object obj;
+    private String[] str;
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        RC_basic rc = new RC_basic();
+        rc.obj = new Object();
+        rc.str = new String[10];
+        Test1();
+        Test2();
+        Test3();
+        Test4(rc);
+        Test5(rc);
+        Test6(rc);
+        Test7(rc);
+        Test8();
+        Test9();
+        Test10();
+    }
+
+    // simple new and recycle
+    static void Test1() {
+        RC_basic obj = new RC_basic();
+        consume(obj);
+    }
+
+    // new and return
+    static RC_basic Test2() {
+        RC_basic obj = new RC_basic();
+        return obj;
+    }
+
+    // new and consume and return
+    static Object Test3() {
+        RC_basic obj = new RC_basic();
+        consume(obj);
+        return obj;
+    }
+
+    // load and dec
+    static void Test4(RC_basic rc) {
+        Object obj = rc.obj;
+        consume(obj);
+    }
+
+    // load and dec
+    static void Test5(RC_basic rc) {
+        consume(rc.obj);
+    }
+
+    // load and return
+    static Object Test6(RC_basic rc) {
+        return rc.obj;
+    }
+
+    // load consume and return
+    static Object Test7(RC_basic rc) {
+        Object o = rc.str;
+        consume(o);
+        return o;
+    }
+
+
+    // call and consume
+    static void Test8() {
+        RC_basic obj = Test2();
+        consume(obj);
+    }
+
+    // call consume and return
+    static Object Test9() {
+        RC_basic obj = Test2();
+        consume(obj);
+        return obj;
+    }
+
+    // call and not consume
+    static void Test10() {
+        Test2();
+    }
+
+    public static void consume(Object obj) {
+        //System.out.println("do noting");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0103-rc-function-RC_eh_01/RC_eh_01.java b/test/testsuite/ouroboros/rc_test/RC0103-rc-function-RC_eh_01/RC_eh_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..b9dd294fcffb4d8b9673e30e9f84f9c2ebc192a7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0103-rc-function-RC_eh_01/RC_eh_01.java
@@ -0,0 +1,64 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_eh_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test eh for RC.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_eh_01.java
+ *- @ExecuteClass: RC_eh_01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.nio.charset.IllegalCharsetNameException;
+
+public class RC_eh_01 {
+    static int res = 0;
+
+    public static void main(String argv[]) {
+        run1();
+		System.out.println("ExpectResult");
+    }
+
+    public static void run1() {
+
+        try {
+            new RC_eh_01().run2();
+        } catch (IllegalArgumentException e) {
+            RC_eh_01.res = 1;
+            
+        }
+
+    }
+
+    public  void run2() {
+        Foo f1 = new Foo(1);
+        Foo f2 = new Foo(2);
+        run3();
+        int result=f1.i+f2.i;
+
+    }
+
+    public static void run3() {
+        try {
+            Integer.parseInt("123#456");
+        } catch (IllegalCharsetNameException e) {
+            RC_eh_01.res = 3;
+            
+        }
+    }
+
+    class Foo{
+        public int i;
+        public Foo(int i){
+            this.i=i;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0104-rc-function-RC_Finalize_01/RC_Finalize_01.java b/test/testsuite/ouroboros/rc_test/RC0104-rc-function-RC_Finalize_01/RC_Finalize_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..e310a4355258f7a5c94c37f9e100aa31693e6fd2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0104-rc-function-RC_Finalize_01/RC_Finalize_01.java
@@ -0,0 +1,77 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Finalize_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test Finalizer for RC .
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Finalize_01.java
+ *- @ExecuteClass: RC_Finalize_01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class C {
+    static A a;
+}
+
+class A {
+    B b;
+
+    public A(B b) {
+
+        this.b = b;
+
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("A finalize");
+
+        C.a = this;
+
+    }
+
+}
+
+
+class B {
+    int num1;
+    int num2;
+
+    public B(int num1, int num2) {
+        this.num1 = num1;
+        this.num2 = num2;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("B finalize");
+    }
+
+    public int sum() {
+        return num1 + num2;
+    }
+
+}
+
+public class RC_Finalize_01 {
+
+    public static void main(String[] args) throws Exception {
+        A a = new A(new B(12, 18));
+        a = null;
+        //System.gc();
+
+        Thread.sleep(5000);
+		System.out.println("ExpectResult");
+}
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0105-rc-function-RC_flow/RC_flow.java b/test/testsuite/ouroboros/rc_test/RC0105-rc-function-RC_flow/RC_flow.java
new file mode 100755
index 0000000000000000000000000000000000000000..0bae2a0a92dfb6dd0bc8c7a158085de941547329
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0105-rc-function-RC_flow/RC_flow.java
@@ -0,0 +1,71 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_flow.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test RC basic operation in For flow.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_flow.java
+ *- @ExecuteClass: RC_flow
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+public class RC_flow {
+    private Object obj;
+    private byte[] b;
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        TestFlow1(21);
+        TestFlow2(30);
+        TestFlow3(56);
+    }
+
+    static Object TestFlow1(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = new RC_flow();
+            }
+        }
+        return rc;
+    }
+
+    static Object TestFlow2(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = Test2();
+            }
+        }
+        return rc;
+    }
+
+    static void TestFlow3(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = Test2();
+            }
+        }
+
+    }
+
+    static RC_flow Test2() {
+        RC_flow obj = new RC_flow();
+        return obj;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0106-rc-function-RC_multest/RC_multest.java b/test/testsuite/ouroboros/rc_test/RC0106-rc-function-RC_multest/RC_multest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ffce9e2abda43acf61181a6390c431a6fdc2977c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0106-rc-function-RC_multest/RC_multest.java
@@ -0,0 +1,205 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_multest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test RC basic operation in For flow.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_multest.java
+ *- @ExecuteClass: RC_multest
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+public class RC_multest {
+    static Foo f;
+    private Object obj;
+    private byte[] b;
+
+    {
+        f = new Bar();
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        TestSimple();
+        TestParam();
+        TestFlow();
+        f = null;
+    }
+
+    static void TestSimple() {
+        RC_multest rc = new RC_multest();
+        rc.obj = new Object();
+        rc.b = new byte[10];
+        Test1();
+        Test2();
+        Test3();
+        Test4(rc);
+        Test5(rc);
+        Test6(rc);
+        Test7(rc);
+        Test8();
+        Test9();
+        Test10();
+    }
+
+    static void TestParam() {
+        RC_multest rc = new RC_multest();
+        rc.obj = new Object();
+        rc.b = new byte[10];
+        TestParam1(rc);
+        TestParam2(rc);
+        TestParam3(rc);
+    }
+
+    static void TestFlow() {
+        TestFlow1(21);
+        TestFlow2(30);
+    }
+
+    // simple new and recycle
+    static void Test1() {
+        RC_multest obj = new RC_multest();
+        consume(obj);
+    }
+
+    // new and return
+    static RC_multest Test2() {
+        RC_multest obj = new RC_multest();
+        return obj;
+    }
+
+    // new and consume and return
+    static Object Test3() {
+        RC_multest obj = new RC_multest();
+        consume(obj);
+        return obj;
+    }
+
+    // load and dec
+    static void Test4(RC_multest rc) {
+        Object obj = rc.obj;
+        consume(obj);
+    }
+
+    // load and dec
+    static void Test5(RC_multest rc) {
+        consume(rc.obj);
+    }
+
+    // load and return
+    static Object Test6(RC_multest rc) {
+        return rc.obj;
+    }
+
+    // load consume and return
+    static Object Test7(RC_multest rc) {
+        Object o = rc.b;
+        consume(o);
+        return o;
+    }
+
+    // call and consume
+    static void Test8() {
+        RC_multest obj = Test2();
+        consume(obj);
+    }
+
+    // call consume and return
+    static Object Test9() {
+        RC_multest obj = Test2();
+        consume(obj);
+        return obj;
+    }
+
+    // call and not consume
+    static void Test10() {
+        Test2();
+    }
+
+    // parameter related
+    // 1. parameter is returned
+    // 2. parameter is redefined
+    // 3. parameter is redefined conditionally
+    static Object TestParam1(RC_multest rc) {
+        consume(rc);
+        return rc;
+    }
+
+    static Object TestParam2(RC_multest rc) {
+        consume(rc);
+        rc = Test2();
+        return rc;
+    }
+
+    static Object TestParam3(RC_multest rc) {
+        consume(rc);
+        if (rc.b != null) {
+            rc = Test2();
+        }
+        return rc;
+    }
+
+    static Object TestParam4() {
+        RC_multest rc = new RC_multest();
+        consume_return(rc);
+        return rc;
+    }
+
+    // object field store
+
+    // local variable
+    // 1. local varaible is redefined in if/loop
+    static Object TestFlow1(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = new RC_multest();
+            }
+        }
+        return rc;
+    }
+
+    static Object TestFlow2(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = Test2();
+            }
+        }
+        return rc;
+    }
+
+    // class info
+    // exception
+    static Object consume_return(Object obj) {
+        return obj;
+    }
+
+    static void consume(Object obj) {
+        f.consume(obj);
+    }
+}
+
+class Foo {
+    void consume(Object obj) {
+    }
+}
+
+class Bar extends Foo {
+    void consume(Object obj) {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/Cycle_aDec_00010.java b/test/testsuite/ouroboros/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/Cycle_aDec_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..3ae6ad61055f85e20ffbb9ed52108eb2e1aeb4bd
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/Cycle_aDec_00010.java
@@ -0,0 +1,183 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/ Cycle_aDec_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:  Cycle_aDec_00010 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source:Cycle_aDec_00010.java
+ *- @ExecuteClass:Cycle_aDec_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+class Cycle_aDec_00010_A1 {
+    Cycle_aDec_00010_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_aDec_00010_A2 {
+    Cycle_aDec_00010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_aDec_00010_A3 {
+    Cycle_aDec_00010_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_aDec_00010_A4 {
+    Cycle_aDec_00010_A1 a1_0;
+    Cycle_aDec_00010_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_aDec_00010_A5 {
+    Cycle_aDec_00010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_aDec_00010_A6 {
+    Cycle_aDec_00010_A1 a1_0;
+    Cycle_aDec_00010_A4 a4_0;
+    Cycle_aDec_00010_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00010_A6(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a5_0.a;
+    }
+}
+
+
+public class Cycle_aDec_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		
+    }
+
+    private static void Modify(Cycle_aDec_00010_A1 a1_main) {
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_aDec_00010_A1 a1_main = new Cycle_aDec_00010_A1("a1_main");
+        Cycle_aDec_00010_A5 a5_main = new Cycle_aDec_00010_A5("a5_main");
+        a1_main.a2_0 = new Cycle_aDec_00010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_aDec_00010_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_aDec_00010_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_aDec_00010_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        Modify(a1_main);
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0 = null;
+        int result = a1_main.sum + a5_main.sum + a5_main.a3_0.sum + a5_main.a3_0.a4_0.sum + a5_main.a3_0.a4_0.a6_0.sum;
+        if (result == 1137)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/Cycle_aDec_00020.java b/test/testsuite/ouroboros/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/Cycle_aDec_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..209f7b23843776e8932e4a041dab75261237103a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/Cycle_aDec_00020.java
@@ -0,0 +1,184 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/ Cycle_aDec_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:  Cycle_aDec_00020 in RC测试-Cycle-01
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source:  Cycle_aDec_00020.java
+ *- @ExecuteClass:  Cycle_aDec_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+class Cycle_aDec_00020_A1 {
+    Cycle_aDec_00020_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Cycle_aDec_00020_A2 {
+    Cycle_aDec_00020_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_aDec_00020_A3 {
+    Cycle_aDec_00020_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_aDec_00020_A4 {
+    Cycle_aDec_00020_A1 a1_0;
+    Cycle_aDec_00020_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+
+class Cycle_aDec_00020_A5 {
+    Cycle_aDec_00020_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+class Cycle_aDec_00020_A6 {
+    Cycle_aDec_00020_A1 a1_0;
+    Cycle_aDec_00020_A4 a4_0;
+    Cycle_aDec_00020_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_aDec_00020_A6(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a5_0.a;
+    }
+}
+
+
+public class Cycle_aDec_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+
+    }
+
+    private static void Modify(Cycle_aDec_00020_A1 a1_main) {
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_aDec_00020_A1 a1_main = new Cycle_aDec_00020_A1("a1_main");
+        Cycle_aDec_00020_A5 a5_main = new Cycle_aDec_00020_A5("a5_main");
+        a1_main.a2_0 = new Cycle_aDec_00020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_aDec_00020_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_aDec_00020_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_aDec_00020_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        Modify(a1_main);
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0 = null;
+        a5_main = null;
+        a1_main.add();
+        int result = a1_main.sum;
+        if (result == 202)
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/Cycle_BDec_00010.java b/test/testsuite/ouroboros/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/Cycle_BDec_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..2000ad9e56a7f939cc7c296e92665d994558f198
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/Cycle_BDec_00010.java
@@ -0,0 +1,84 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00010 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00010.java
+ *- @ExecuteClass: Cycle_BDec_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_BDec_00010_A1 {
+    Cycle_BDec_00010_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00010_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00010_A2 {
+    Cycle_BDec_00010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00010_A2() {
+        a1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+public class Cycle_BDec_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static boolean ModifyA1(Cycle_BDec_00010_A1 a1_0) {
+        a1_0.add();
+        a1_0.a2_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 6)
+            return true;
+        else
+            return false;
+
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00010_A1 a1_0 = new Cycle_BDec_00010_A1();
+        a1_0.a2_0 = new Cycle_BDec_00010_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        boolean ret = ModifyA1(a1_0);
+        a1_0 = null;
+        if (ret == true && a1_0 == null)
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/Cycle_BDec_00020.java b/test/testsuite/ouroboros/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/Cycle_BDec_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..9b71285e0d229edf81e331aecc147ba391081ce7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/Cycle_BDec_00020.java
@@ -0,0 +1,138 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00020 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00020.java
+ *- @ExecuteClass: Cycle_BDec_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_BDec_00020_A1 {
+    Cycle_BDec_00020_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00020_A2 {
+    Cycle_BDec_00020_A3 a3_0;
+    Cycle_BDec_00020_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00020_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_BDec_00020_A3 {
+    Cycle_BDec_00020_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00020_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_BDec_00020_A4 {
+
+    int a;
+    int sum;
+    Cycle_BDec_00020_A5 a5_0;
+
+    Cycle_BDec_00020_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        a5_0.add();
+        sum = a + a5_0.sum;
+    }
+}
+
+class Cycle_BDec_00020_A5 {
+
+    int a;
+    int sum;
+
+    Cycle_BDec_00020_A5() {
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + 6;
+    }
+}
+
+
+public class Cycle_BDec_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void ModifyA1(Cycle_BDec_00020_A1 a1) {
+        a1.add();
+        a1.a2_0.add();
+        a1.a2_0.a3_0.add();
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00020_A1 a1_0 = new Cycle_BDec_00020_A1();
+        a1_0.a2_0 = new Cycle_BDec_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00020_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_BDec_00020_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_BDec_00020_A5();
+        ModifyA1(a1_0);
+        a1_0.a2_0.a4_0 = null;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int result = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum;
+        if (result == 12)
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/Cycle_BDec_00030.java b/test/testsuite/ouroboros/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/Cycle_BDec_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..6ced2c298d8991c1db12c9855810b3d3e345bd6f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/Cycle_BDec_00030.java
@@ -0,0 +1,122 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00030 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00030.java
+ *- @ExecuteClass: Cycle_BDec_00030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_BDec_00030_A1 {
+    Cycle_BDec_00030_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00030_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00030_A2 {
+    Cycle_BDec_00030_A3 a3_0;
+    Cycle_BDec_00030_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00030_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_BDec_00030_A3 {
+    Cycle_BDec_00030_A1 a1_0;
+    Cycle_BDec_00030_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00030_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_BDec_00030_A4 {
+    Cycle_BDec_00030_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00030_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_BDec_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void ModifyA1(Cycle_BDec_00030_A1 a1) {
+        a1 = null;
+        a1 = new Cycle_BDec_00030_A1();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00030_A1 a1_0 = new Cycle_BDec_00030_A1();
+        a1_0.a2_0 = new Cycle_BDec_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00030_A3();
+        Cycle_BDec_00030_A4 a4_0 = new Cycle_BDec_00030_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        ModifyA1(a1_0);
+        a1_0 = null;
+        a4_0.add();
+        a4_0.a3_0.add();
+        int nsum = (a4_0.a3_0.sum + a4_0.sum);
+        if (nsum == 14)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/Cycle_BDec_00040.java b/test/testsuite/ouroboros/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/Cycle_BDec_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..b4649f6cf1d08a224fa88fec08f8ff1a35719929
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/Cycle_BDec_00040.java
@@ -0,0 +1,120 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00040 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00040.java
+ *- @ExecuteClass: Cycle_BDec_00040
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_BDec_00040_A1 {
+    Cycle_BDec_00040_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00040_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00040_A2 {
+    Cycle_BDec_00040_A3 a3_0;
+    Cycle_BDec_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00040_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_BDec_00040_A3 {
+    Cycle_BDec_00040_A1 a1_0;
+    Cycle_BDec_00040_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00040_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_BDec_00040_A4 {
+    Cycle_BDec_00040_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00040_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_BDec_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void modifyA1(Cycle_BDec_00040_A1 a1) {
+        a1.add();
+        a1.a2_0.add();
+        a1.a2_0.a3_0.add();
+        a1.a2_0.a3_0.a4_0.add();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00040_A1 a1_0 = new Cycle_BDec_00040_A1();
+        a1_0.a2_0 = new Cycle_BDec_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00040_A3();
+        Cycle_BDec_00040_A4 a4_0 = new Cycle_BDec_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        modifyA1(a1_0);
+        a1_0 = null;
+        a4_0 = null;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/Cycle_BDec_00050.java b/test/testsuite/ouroboros/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/Cycle_BDec_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..3cec54ab066f558747df9f76d2ea07a9110567b3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/Cycle_BDec_00050.java
@@ -0,0 +1,126 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Cycle_BDec_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_BDec_00050 in RC测试-Cycle-00.vsd
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_BDec_00050.java
+ *- @ExecuteClass: Cycle_BDec_00050
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class Cycle_BDec_00050_A1 {
+    Cycle_BDec_00050_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00050_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_BDec_00050_A2 {
+    Cycle_BDec_00050_A3 a3_0;
+    Cycle_BDec_00050_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00050_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_BDec_00050_A3 {
+    Cycle_BDec_00050_A1 a1_0;
+    Cycle_BDec_00050_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00050_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_BDec_00050_A4 {
+    Cycle_BDec_00050_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_BDec_00050_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+public class Cycle_BDec_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		System.out.println("ExpectResult");
+        
+    }
+
+    private static void modifyA1(Cycle_BDec_00050_A1 a1) {
+        a1.add();
+        a1.a2_0.add();
+        a1.a2_0.a3_0.add();
+        a1.a2_0.a3_0.a4_0.add();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00050_A1 a1_0 = new Cycle_BDec_00050_A1();
+        a1_0.a2_0 = new Cycle_BDec_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00050_A3();
+        Cycle_BDec_00050_A4 a4_0 = new Cycle_BDec_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        modifyA1(a1_0);
+        //cancel inline by for flow
+        int sum=0;
+        for(int i=0;i<100;i++)
+            sum +=i;
+        a1_0.a2_0.a3_0.a1_0 = null;
+        a4_0.a3_0 = null;
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/Nocycle_aDec_00010.java b/test/testsuite/ouroboros/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/Nocycle_aDec_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..cfd58c8e988b08f24076a0448fc8f60932dbeac0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/Nocycle_aDec_00010.java
@@ -0,0 +1,216 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00010 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00010.java
+ *- @ExecuteClass: Nocycle_aDec_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+
+class Nocycle_aDec_00010_A1 {
+    Nocycle_aDec_00010_B1 b1_0;
+    Nocycle_aDec_00010_B2 b2_0;
+    Nocycle_aDec_00010_B3 b3_0;
+    Nocycle_aDec_00010_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_aDec_00010_B1 {
+    Nocycle_aDec_00010_C1 c1_0;
+    Nocycle_aDec_00010_C2 c2_0;
+    Nocycle_aDec_00010_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+class Nocycle_aDec_00010_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_aDec_00010_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00010_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00010_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00010_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00010_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00010_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_aDec_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00010_A1 a1_main = new Nocycle_aDec_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_aDec_00010_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_aDec_00010_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_aDec_00010_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_aDec_00010_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_aDec_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_aDec_00010_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_aDec_00010_B4("b4_0");
+        Nocycle_aDec_00010_A1 a1_copy = modifyA1(a1_main);
+        a1_main = null;
+        a1_copy.add();
+        a1_copy.b1_0.add();
+        a1_copy.b2_0.add();
+        a1_copy.b3_0.add();
+        a1_copy.b4_0.add();
+        a1_copy.b1_0.c1_0.add();
+        a1_copy.b1_0.c2_0.add();
+        a1_copy.b1_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_copy.sum+a1_copy.b1_0.sum+a1_copy.b2_0.sum+a1_copy.b3_0.sum+a1_copy.b4_0.sum+a1_copy.b1_0.c1_0.sum+a1_copy.b1_0.c2_0.sum+a1_copy.b1_0.c3_0.sum);
+
+        int result = a1_copy.sum + a1_copy.b1_0.sum + a1_copy.b2_0.sum + a1_copy.b3_0.sum + a1_copy.b4_0.sum + a1_copy.b1_0.c1_0.sum + a1_copy.b1_0.c2_0.sum + a1_copy.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5049)
+            System.out.println("ExpectResult");
+    }
+
+    public static Nocycle_aDec_00010_A1 modifyA1(Nocycle_aDec_00010_A1 a1) {
+        a1.a = 102;
+        return a1;
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/Nocycle_aDec_00020.java b/test/testsuite/ouroboros/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/Nocycle_aDec_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..9fc696e41a01461ebbb61f6d779927ca90fd9f74
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/Nocycle_aDec_00020.java
@@ -0,0 +1,209 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00020 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00020.java
+ *- @ExecuteClass: Nocycle_aDec_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class Nocycle_aDec_00020_A1 {
+    Nocycle_aDec_00020_B1 b1_0;
+    Nocycle_aDec_00020_B2 b2_0;
+    Nocycle_aDec_00020_B3 b3_0;
+    Nocycle_aDec_00020_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_aDec_00020_B1 {
+    Nocycle_aDec_00020_C1 c1_0;
+    Nocycle_aDec_00020_C2 c2_0;
+    Nocycle_aDec_00020_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+
+class Nocycle_aDec_00020_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+
+class Nocycle_aDec_00020_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+class Nocycle_aDec_00020_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+class Nocycle_aDec_00020_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00020_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00020_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00020_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_aDec_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00020_A1 a1_main = new Nocycle_aDec_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_aDec_00020_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_aDec_00020_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_aDec_00020_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_aDec_00020_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_aDec_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_aDec_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_aDec_00020_B4("b4_0");
+        modifyB1(a1_main.b1_0);
+        a1_main.b1_0 = null;
+        a1_main.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        int result = a1_main.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum;
+
+        if (result == 1928)
+            System.out.println("ExpectResult");
+    }
+
+    public static void modifyB1(Nocycle_aDec_00020_B1 b1) {
+        b1.a = 202;
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/Nocycle_aDec_00030.java b/test/testsuite/ouroboros/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/Nocycle_aDec_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..640f5c40b33d1666e24ce502d22bab09f0ec833c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/Nocycle_aDec_00030.java
@@ -0,0 +1,212 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00030 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00030.java
+ *- @ExecuteClass: Nocycle_aDec_00030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class Nocycle_aDec_00030_A1 {
+    Nocycle_aDec_00030_B1 b1_0;
+    Nocycle_aDec_00030_B2 b2_0;
+    Nocycle_aDec_00030_B3 b3_0;
+    Nocycle_aDec_00030_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+
+class Nocycle_aDec_00030_B1 {
+    Nocycle_aDec_00030_C1 c1_0;
+    Nocycle_aDec_00030_C2 c2_0;
+    Nocycle_aDec_00030_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_aDec_00030_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+
+class Nocycle_aDec_00030_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+class Nocycle_aDec_00030_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+
+    }
+}
+
+class Nocycle_aDec_00030_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00030_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00030_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00030_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class Nocycle_aDec_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00030_A1 a1_main = new Nocycle_aDec_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_aDec_00030_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_aDec_00030_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_aDec_00030_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_aDec_00030_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_aDec_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_aDec_00030_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_aDec_00030_B4("b4_0");
+        modifyC3(a1_main.b1_0.c3_0);
+        a1_main.b1_0.c3_0 = null;
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum;
+        if (result == 4139)
+            System.out.println("ExpectResult");
+    }
+
+    public static void modifyC3(Nocycle_aDec_00030_C3 c3) {
+        c3.a += 1;
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/Nocycle_aDec_00040.java b/test/testsuite/ouroboros/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/Nocycle_aDec_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..dbc76715410d6144adc025e2e2c30b4ea3dc66cc
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/Nocycle_aDec_00040.java
@@ -0,0 +1,354 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00040 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00040.java
+ *- @ExecuteClass: Nocycle_aDec_00040
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+
+class Nocycle_aDec_00040_A1 {
+    Nocycle_aDec_00040_B1 b1_0;
+    Nocycle_aDec_00040_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_A2 {
+    Nocycle_aDec_00040_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_A3 {
+    Nocycle_aDec_00040_B2 b2_0;
+    Nocycle_aDec_00040_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_aDec_00040_A4 {
+    Nocycle_aDec_00040_B3 b3_0;
+    Nocycle_aDec_00040_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_B1 {
+    Nocycle_aDec_00040_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_B2 {
+    Nocycle_aDec_00040_C1 c1_0;
+    Nocycle_aDec_00040_D1 d1_0;
+    Nocycle_aDec_00040_D2 d2_0;
+    Nocycle_aDec_00040_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_B3 {
+    Nocycle_aDec_00040_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_C1 {
+    Nocycle_aDec_00040_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_aDec_00040_C2 {
+    Nocycle_aDec_00040_D2 d2_0;
+    Nocycle_aDec_00040_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00040_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00040_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00040_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00040_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_aDec_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00040_A1 a1_main = new Nocycle_aDec_00040_A1("a1_main");
+        Nocycle_aDec_00040_A2 a2_main = new Nocycle_aDec_00040_A2("a2_main");
+        Nocycle_aDec_00040_A3 a3_main = new Nocycle_aDec_00040_A3("a3_main");
+        Nocycle_aDec_00040_A4 a4_main = new Nocycle_aDec_00040_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_aDec_00040_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_aDec_00040_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_aDec_00040_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_aDec_00040_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_aDec_00040_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = new Nocycle_aDec_00040_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_aDec_00040_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a2_main.b2_0.c1_0.d1_0;
+        a3_main.b2_0.d1_0 = a2_main.b2_0.d1_0;
+        a3_main.b2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a3_main.c2_0 = new Nocycle_aDec_00040_C2("c2_0");
+        a3_main.c2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.c2_0.d3_0 = new Nocycle_aDec_00040_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_aDec_00040_B3("b3_0");
+        a4_main.b3_0.c1_0 = a3_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a3_main.b2_0.c1_0.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a3_main.c2_0.d2_0;
+        a4_main.c2_0.d3_0 = a3_main.c2_0.d3_0;
+        modifyA1(a1_main);
+        a1_main = null;
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result = a2_main.sum + a3_main.sum + a4_main.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a4_main.b3_0.c1_0.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        if (result == 7954)
+            System.out.println("ExpectResult");
+    }
+
+    private static void modifyA1(Nocycle_aDec_00040_A1 a1) {
+        a1.a += 1;
+        a1.add();
+        a1.b1_0.add();
+        a1.d1_0.add();
+        a1.b1_0.d2_0.add();
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/Nocycle_aDec_00050.java b/test/testsuite/ouroboros/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/Nocycle_aDec_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..b2e8f5549d725dd778a20a7a9236df39b9998528
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/Nocycle_aDec_00050.java
@@ -0,0 +1,348 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00050 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00050.java
+ *- @ExecuteClass: Nocycle_aDec_00050
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class Nocycle_aDec_00050_A1 {
+    Nocycle_aDec_00050_B1 b1_0;
+    Nocycle_aDec_00050_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_A2 {
+    Nocycle_aDec_00050_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+class Nocycle_aDec_00050_A3 {
+    Nocycle_aDec_00050_B2 b2_0;
+    Nocycle_aDec_00050_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c2_0.a;
+    }
+}
+
+class Nocycle_aDec_00050_A4 {
+    Nocycle_aDec_00050_B3 b3_0;
+    Nocycle_aDec_00050_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_B1 {
+    Nocycle_aDec_00050_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_B2 {
+    Nocycle_aDec_00050_C1 c1_0;
+    Nocycle_aDec_00050_D1 d1_0;
+    Nocycle_aDec_00050_D2 d2_0;
+    Nocycle_aDec_00050_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_B3 {
+    Nocycle_aDec_00050_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_C1 {
+    Nocycle_aDec_00050_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_aDec_00050_C2 {
+    Nocycle_aDec_00050_D2 d2_0;
+    Nocycle_aDec_00050_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00050_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00050_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00050_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00050_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_aDec_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00050_A1 a1_main = new Nocycle_aDec_00050_A1("a1_main");
+        Nocycle_aDec_00050_A2 a2_main = new Nocycle_aDec_00050_A2("a2_main");
+        Nocycle_aDec_00050_A3 a3_main = new Nocycle_aDec_00050_A3("a3_main");
+        Nocycle_aDec_00050_A4 a4_main = new Nocycle_aDec_00050_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_aDec_00050_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_aDec_00050_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_aDec_00050_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_aDec_00050_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_aDec_00050_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = new Nocycle_aDec_00050_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_aDec_00050_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a2_main.b2_0.c1_0.d1_0;
+        a3_main.b2_0.d1_0 = a2_main.b2_0.d1_0;
+        a3_main.b2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a3_main.c2_0 = new Nocycle_aDec_00050_C2("c2_0");
+        a3_main.c2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.c2_0.d3_0 = new Nocycle_aDec_00050_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_aDec_00050_B3("b3_0");
+        a4_main.b3_0.c1_0 = a3_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a3_main.b2_0.c1_0.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a3_main.c2_0.d2_0;
+        a4_main.c2_0.d3_0 = a3_main.c2_0.d3_0;
+        modifyB2(a2_main.b2_0);
+        a2_main.b2_0 = null;
+        a3_main.b2_0 = null;
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a4_main.b3_0.sum + a4_main.b3_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+
+        if (result == 7249)
+            System.out.println("ExpectResult");
+    }
+
+    private static void modifyB2(Nocycle_aDec_00050_B2 b2) {
+        b2.a += 1;
+        b2.add();
+        b2.c1_0.add();
+        b2.d1_0.add();
+        b2.d2_0.add();
+        b2.d3_0.add();
+        b2.c1_0.d1_0.add();
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/Nocycle_aDec_00060.java b/test/testsuite/ouroboros/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/Nocycle_aDec_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..08e24d34c425e101a8ee15f3a11c4d2e6ca6592d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/Nocycle_aDec_00060.java
@@ -0,0 +1,360 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Dec/Nocycle_aDec_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_aDec_00060 in RC测试-No-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_aDec_00060.java
+ *- @ExecuteClass: Nocycle_aDec_00060
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+
+class Nocycle_aDec_00060_A1 {
+    Nocycle_aDec_00060_B1 b1_0;
+    Nocycle_aDec_00060_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_A2 {
+    Nocycle_aDec_00060_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_A3 {
+    Nocycle_aDec_00060_B2 b2_0;
+    Nocycle_aDec_00060_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class Nocycle_aDec_00060_A4 {
+    Nocycle_aDec_00060_B3 b3_0;
+    Nocycle_aDec_00060_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_B1 {
+    Nocycle_aDec_00060_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_B2 {
+    Nocycle_aDec_00060_C1 c1_0;
+    Nocycle_aDec_00060_D1 d1_0;
+    Nocycle_aDec_00060_D2 d2_0;
+    Nocycle_aDec_00060_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_B3 {
+    Nocycle_aDec_00060_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_C1 {
+    Nocycle_aDec_00060_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class Nocycle_aDec_00060_C2 {
+    Nocycle_aDec_00060_D2 d2_0;
+    Nocycle_aDec_00060_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class Nocycle_aDec_00060_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00060_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_aDec_00060_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_aDec_00060_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+
+public class Nocycle_aDec_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00060_A1 a1_main = new Nocycle_aDec_00060_A1("a1_main");
+        Nocycle_aDec_00060_A2 a2_main = new Nocycle_aDec_00060_A2("a2_main");
+        Nocycle_aDec_00060_A3 a3_main = new Nocycle_aDec_00060_A3("a3_main");
+        Nocycle_aDec_00060_A4 a4_main = new Nocycle_aDec_00060_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_aDec_00060_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_aDec_00060_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_aDec_00060_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_aDec_00060_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_aDec_00060_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = new Nocycle_aDec_00060_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_aDec_00060_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a2_main.b2_0.c1_0.d1_0;
+        a3_main.b2_0.d1_0 = a2_main.b2_0.d1_0;
+        a3_main.b2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+
+        a3_main.c2_0 = new Nocycle_aDec_00060_C2("c2_0");
+        a3_main.c2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.c2_0.d3_0 = new Nocycle_aDec_00060_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_aDec_00060_B3("b3_0");
+        a4_main.b3_0.c1_0 = a3_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a3_main.b2_0.c1_0.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a3_main.c2_0.d2_0;
+        a4_main.c2_0.d3_0 = a3_main.c2_0.d3_0;
+        ModifyA1(a1_main);
+        ModifyA2(a2_main);
+        ModifyA3(a3_main);
+        a4_main.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result = a4_main.sum + a4_main.b3_0.sum + a4_main.b3_0.c1_0.sum + a4_main.c2_0.sum + a4_main.b3_0.c1_0.d1_0.sum + a4_main.c2_0.d2_0.sum + a4_main.c2_0.d3_0.sum;
+
+        if (result == 5334)
+            System.out.println("ExpectResult");
+    }
+
+    private static void ModifyA1(Nocycle_aDec_00060_A1 a1) {
+        a1.a += 1;
+        a1.add();
+        a1.b1_0.add();
+        a1.d1_0.add();
+        a1.b1_0.d2_0.add();
+    }
+
+    private static void ModifyA2(Nocycle_aDec_00060_A2 a2) {
+        a2.a += 1;
+        a2.add();
+        a2.b2_0.add();
+        a2.b2_0.c1_0.add();
+        a2.b2_0.d1_0.add();
+        a2.b2_0.d2_0.add();
+        a2.b2_0.d3_0.add();
+        a2.b2_0.c1_0.d1_0.add();
+    }
+
+    private static void ModifyA3(Nocycle_aDec_00060_A3 a3) {
+        a3.a += 1;
+        a3.add();
+        a3.b2_0.add();
+        a3.b2_0.c1_0.add();
+        a3.b2_0.c1_0.d1_0.add();
+        a3.b2_0.d1_0.add();
+        a3.b2_0.d2_0.add();
+        a3.b2_0.d3_0.add();
+        a3.c2_0.add();
+        a3.c2_0.d2_0.add();
+        a3.c2_0.d3_0.add();
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/Cycle_am_00180.java b/test/testsuite/ouroboros/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/Cycle_am_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..535b166808fe1acbaf3fc3a8999018a13c9a9928
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/Cycle_am_00180.java
@@ -0,0 +1,276 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00180 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00180.java
+ *- @ExecuteClass: Cycle_am_00180
+ *- @ExecuteArgs:
+ *- @Remark:
+ * A1 depend A2 A8;
+ * A2 depend A3 ; A3 depend A4; A4 depend A5 ; A5 depend A6; A6 depend A1 ;
+ * A8 depend A9 ; A9 depend A7; A7 depend A4
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+108)+(102+103)+(103+104)+(104+105)+(105+106)+(106+101)+(107+104)+(108+109)+(109+107)=1994
+ *
+ */
+class ThreadRc_Cycle_am_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00180_A1 a1_main = new Cycle_a_00180_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00180_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00180_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00180_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00180_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00180_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a8_0 = new Cycle_a_00180_A8("a8_0");
+        a1_main.a8_0.a9_0 = new Cycle_a_00180_A9("a9_0");
+        a1_main.a8_0.a9_0.a7_0 = new Cycle_a_00180_A7("a7_0");
+        a1_main.a8_0.a9_0.a7_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_main.a8_0.add();
+        a1_main.a8_0.a9_0.add();
+        a1_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_main.a8_0.sum + a1_main.a8_0.a9_0.sum + a1_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1994)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00180_A1 {
+        Cycle_a_00180_A2 a2_0;
+        Cycle_a_00180_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A1(String strObjectName) {
+            a2_0 = null;
+            a8_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A2 {
+        Cycle_a_00180_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A3 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A4 {
+        Cycle_a_00180_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A5 {
+        Cycle_a_00180_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A6 {
+        Cycle_a_00180_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A6(String strObjectName) {
+            a1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A7 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A7(String strObjectName) {
+            a4_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A8 {
+        Cycle_a_00180_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A9 {
+        Cycle_a_00180_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00180 A1_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A2_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A3_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A4_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A5_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A6_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+
+        A1_Cycle_am_00180.start();
+        A2_Cycle_am_00180.start();
+        A3_Cycle_am_00180.start();
+        A4_Cycle_am_00180.start();
+        A5_Cycle_am_00180.start();
+        A6_Cycle_am_00180.start();
+
+        try {
+            A1_Cycle_am_00180.join();
+            A2_Cycle_am_00180.join();
+            A3_Cycle_am_00180.join();
+            A4_Cycle_am_00180.join();
+            A5_Cycle_am_00180.join();
+            A6_Cycle_am_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00180.check() && A2_Cycle_am_00180.check() && A3_Cycle_am_00180.check() && A4_Cycle_am_00180.check() && A5_Cycle_am_00180.check() && A6_Cycle_am_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/Cycle_am_00190.java b/test/testsuite/ouroboros/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/Cycle_am_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..3fcb66469b2dd11922d8c9d547ef07bfdaca8eb8
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/Cycle_am_00190.java
@@ -0,0 +1,293 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00190 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00190.java
+ *- @ExecuteClass: Cycle_am_00190
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_am_00190 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00190_A1 a1_main = new Cycle_a_00190_A1("a1_main");
+        Cycle_a_00190_A10 a10_main = new Cycle_a_00190_A10("a10_main");
+        a1_main.a2_0 = new Cycle_a_00190_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00190_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00190_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00190_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00190_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_main;
+
+        a10_main.a8_0 = new Cycle_a_00190_A8("a8_0");
+        a10_main.a8_0.a9_0 = new Cycle_a_00190_A9("a9_0");
+        a10_main.a8_0.a9_0.a7_0 = new Cycle_a_00190_A7("a7_0");
+        a10_main.a8_0.a9_0.a7_0.a5_0 = a1_main.a2_0.a3_0.a4_0.a5_0;
+
+        a1_main.add();
+        a10_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_main.a8_0.add();
+        a10_main.a8_0.a9_0.add();
+        a10_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a10_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_main.a8_0.sum + a10_main.a8_0.a9_0.sum + a10_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2215)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00190_A1 {
+        Cycle_a_00190_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A2 {
+        Cycle_a_00190_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A3 {
+        Cycle_a_00190_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A4 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A5 {
+        Cycle_a_00190_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A6 {
+        Cycle_a_00190_A1 a1_0;
+        Cycle_a_00190_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A6(String strObjectName) {
+            a1_0 = null;
+            a10_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A7 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A7(String strObjectName) {
+            a5_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A8 {
+        Cycle_a_00190_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A9 {
+        Cycle_a_00190_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A10 {
+        Cycle_a_00190_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A10(String strObjectName) {
+            a8_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00190 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00190 A1_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A2_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A3_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A4_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A5_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A6_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+
+        A1_Cycle_am_00190.start();
+        A2_Cycle_am_00190.start();
+        A3_Cycle_am_00190.start();
+        A4_Cycle_am_00190.start();
+        A5_Cycle_am_00190.start();
+        A6_Cycle_am_00190.start();
+
+        try {
+            A1_Cycle_am_00190.join();
+            A2_Cycle_am_00190.join();
+            A3_Cycle_am_00190.join();
+            A4_Cycle_am_00190.join();
+            A5_Cycle_am_00190.join();
+            A6_Cycle_am_00190.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00190.check() && A2_Cycle_am_00190.check() && A3_Cycle_am_00190.check() && A4_Cycle_am_00190.check() && A5_Cycle_am_00190.check() && A6_Cycle_am_00190.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/Cycle_am_00200.java b/test/testsuite/ouroboros/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/Cycle_am_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..94d0b4d3434e2c844628a181d45c03a01c764288
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/Cycle_am_00200.java
@@ -0,0 +1,231 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00200 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00200.java
+ *- @ExecuteClass: Cycle_am_00200
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_am_00200 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00200_A1 a1_main = new Cycle_a_00200_A1("a1_main");
+        Cycle_a_00200_A4 a4_main = new Cycle_a_00200_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00200_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00200_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00200_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a6_0 = new Cycle_a_00200_A6("a6_0");
+        a1_main.a2_0.a6_0.a7_0 = new Cycle_a_00200_A7("a7_0");
+        a1_main.a2_0.a7_0 = a1_main.a2_0.a6_0.a7_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a6_0.add();
+        a1_main.a2_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a6_0.sum + a1_main.a2_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00200_A1 {
+        Cycle_a_00200_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A2 {
+        Cycle_a_00200_A3 a3_0;
+        Cycle_a_00200_A6 a6_0;
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A2(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A3 {
+        Cycle_a_00200_A1 a1_0;
+        Cycle_a_00200_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A4 {
+        Cycle_a_00200_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A5 {
+        Cycle_a_00200_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A6 {
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Cycle_am_00200 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00200 A1_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A2_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A3_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A4_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A5_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A6_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+
+        A1_Cycle_am_00200.start();
+        A2_Cycle_am_00200.start();
+        A3_Cycle_am_00200.start();
+        A4_Cycle_am_00200.start();
+        A5_Cycle_am_00200.start();
+        A6_Cycle_am_00200.start();
+
+        try {
+            A1_Cycle_am_00200.join();
+            A2_Cycle_am_00200.join();
+            A3_Cycle_am_00200.join();
+            A4_Cycle_am_00200.join();
+            A5_Cycle_am_00200.join();
+            A6_Cycle_am_00200.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00200.check() && A2_Cycle_am_00200.check() && A3_Cycle_am_00200.check() && A4_Cycle_am_00200.check() && A5_Cycle_am_00200.check() && A6_Cycle_am_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/Cycle_am_00210.java b/test/testsuite/ouroboros/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/Cycle_am_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..165ec6c4f138f3beb2911588bdab173e6c0f6d40
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/Cycle_am_00210.java
@@ -0,0 +1,232 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00210 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00210.java
+ *- @ExecuteClass: Cycle_am_00210
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_am_00210 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00210_A1 a1_main = new Cycle_a_00210_A1("a1_main");
+        Cycle_a_00210_A4 a4_main = new Cycle_a_00210_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00210_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00210_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00210_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00210_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0 = new Cycle_a_00210_A7("a7_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        a1_main.a2_0.a3_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a6_0.sum + a1_main.a2_0.a3_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1662)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00210_A1 {
+        Cycle_a_00210_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A2 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A3 {
+        Cycle_a_00210_A1 a1_0;
+        Cycle_a_00210_A5 a5_0;
+        Cycle_a_00210_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A4 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A5 {
+        Cycle_a_00210_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A6 {
+        Cycle_a_00210_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A7 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00210 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00210 A1_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A2_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A3_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A4_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A5_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A6_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+
+        A1_Cycle_am_00210.start();
+        A2_Cycle_am_00210.start();
+        A3_Cycle_am_00210.start();
+        A4_Cycle_am_00210.start();
+        A5_Cycle_am_00210.start();
+        A6_Cycle_am_00210.start();
+
+        try {
+            A1_Cycle_am_00210.join();
+            A2_Cycle_am_00210.join();
+            A3_Cycle_am_00210.join();
+            A4_Cycle_am_00210.join();
+            A5_Cycle_am_00210.join();
+            A6_Cycle_am_00210.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00210.check() && A2_Cycle_am_00210.check() && A3_Cycle_am_00210.check() && A4_Cycle_am_00210.check() && A5_Cycle_am_00210.check() && A6_Cycle_am_00210.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/Cycle_am_00220.java b/test/testsuite/ouroboros/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/Cycle_am_00220.java
new file mode 100755
index 0000000000000000000000000000000000000000..2958d7784a0284b7fe15a651c4c4dcfc65b5b910
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/Cycle_am_00220.java
@@ -0,0 +1,233 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00220.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00220 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00220.java
+ *- @ExecuteClass: Cycle_am_00220
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00220 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00220_A1 a1_main = new Cycle_a_00220_A1("a1_main");
+        Cycle_a_00220_A4 a4_main = new Cycle_a_00220_A4("a4_main");
+        Cycle_a_00220_A6 a6_main = new Cycle_a_00220_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00220_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00220_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00220_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_00220_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1772)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00220_A1 {
+        Cycle_a_00220_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A2 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A3 {
+        Cycle_a_00220_A1 a1_0;
+        Cycle_a_00220_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A4 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A5 {
+        Cycle_a_00220_A4 a4_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A6 {
+        Cycle_a_00220_A5 a5_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Cycle_am_00220 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00220 A1_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A2_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A3_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A4_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A5_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A6_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+
+        A1_Cycle_am_00220.start();
+        A2_Cycle_am_00220.start();
+        A3_Cycle_am_00220.start();
+        A4_Cycle_am_00220.start();
+        A5_Cycle_am_00220.start();
+        A6_Cycle_am_00220.start();
+
+        try {
+            A1_Cycle_am_00220.join();
+            A2_Cycle_am_00220.join();
+            A3_Cycle_am_00220.join();
+            A4_Cycle_am_00220.join();
+            A5_Cycle_am_00220.join();
+            A6_Cycle_am_00220.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00220.check() && A2_Cycle_am_00220.check() && A3_Cycle_am_00220.check() && A4_Cycle_am_00220.check() && A5_Cycle_am_00220.check() && A6_Cycle_am_00220.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/Cycle_am_00230.java b/test/testsuite/ouroboros/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/Cycle_am_00230.java
new file mode 100755
index 0000000000000000000000000000000000000000..fd1d933ae10d75361aaaf3595401b0c455633356
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/Cycle_am_00230.java
@@ -0,0 +1,232 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00230.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00230 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00230.java
+ *- @ExecuteClass: Cycle_am_00230
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00230 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00230_A1 a1_main = new Cycle_a_00230_A1("a1_main");
+        Cycle_a_00230_A5 a5_main = new Cycle_a_00230_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00230_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00230_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00230_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a7_0 = new Cycle_a_00230_A7("a7_0");
+        a5_main.a6_0 = new Cycle_a_00230_A6("a6_0");
+        a5_main.a6_0.a7_0 = a5_main.a7_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a5_main.a7_0.add();
+        a5_main.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a5_main.a6_0.sum + a5_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00230_A1 {
+        Cycle_a_00230_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A2 {
+        Cycle_a_00230_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A3 {
+        Cycle_a_00230_A1 a1_0;
+        Cycle_a_00230_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A4 {
+        Cycle_a_00230_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A5 {
+        Cycle_a_00230_A3 a3_0;
+        Cycle_a_00230_A6 a6_0;
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A5(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A6 {
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Cycle_am_00230 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00230 A1_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A2_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A3_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A4_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A5_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A6_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+
+        A1_Cycle_am_00230.start();
+        A2_Cycle_am_00230.start();
+        A3_Cycle_am_00230.start();
+        A4_Cycle_am_00230.start();
+        A5_Cycle_am_00230.start();
+        A6_Cycle_am_00230.start();
+
+        try {
+            A1_Cycle_am_00230.join();
+            A2_Cycle_am_00230.join();
+            A3_Cycle_am_00230.join();
+            A4_Cycle_am_00230.join();
+            A5_Cycle_am_00230.join();
+            A6_Cycle_am_00230.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00230.check() && A2_Cycle_am_00230.check() && A3_Cycle_am_00230.check() && A4_Cycle_am_00230.check() && A5_Cycle_am_00230.check() && A6_Cycle_am_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/Cycle_am_00240.java b/test/testsuite/ouroboros/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/Cycle_am_00240.java
new file mode 100755
index 0000000000000000000000000000000000000000..c1d8ab26261e2c01b7c18b7f53c574750d69aba9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/Cycle_am_00240.java
@@ -0,0 +1,232 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00240 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00240.java
+ *- @ExecuteClass: Cycle_am_00240
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00240 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00240_A1 a1_main = new Cycle_a_00240_A1("a1_main");
+        Cycle_a_00240_A5 a5_main = new Cycle_a_00240_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00240_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00240_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a6_0 = new Cycle_a_00240_A6("a6_0");
+        a1_main.a6_0.a7_0 = new Cycle_a_00240_A7("a7_0");
+        a1_main.a6_0.a7_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a6_0.add();
+        a1_main.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a6_0.sum + a1_main.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1660)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00240_A1 {
+        Cycle_a_00240_A2 a2_0;
+        Cycle_a_00240_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A1(String strObjectName) {
+            a2_0 = null;
+            a6_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A2 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A3 {
+        Cycle_a_00240_A1 a1_0;
+        Cycle_a_00240_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A4 {
+        Cycle_a_00240_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A5 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A6 {
+        Cycle_a_00240_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A7 {
+        Cycle_a_00240_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A7(String strObjectName) {
+            a1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00240 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00240 A1_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A2_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A3_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A4_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A5_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A6_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+
+        A1_Cycle_am_00240.start();
+        A2_Cycle_am_00240.start();
+        A3_Cycle_am_00240.start();
+        A4_Cycle_am_00240.start();
+        A5_Cycle_am_00240.start();
+        A6_Cycle_am_00240.start();
+
+        try {
+            A1_Cycle_am_00240.join();
+            A2_Cycle_am_00240.join();
+            A3_Cycle_am_00240.join();
+            A4_Cycle_am_00240.join();
+            A5_Cycle_am_00240.join();
+            A6_Cycle_am_00240.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00240.check() && A2_Cycle_am_00240.check() && A3_Cycle_am_00240.check() && A4_Cycle_am_00240.check() && A5_Cycle_am_00240.check() && A6_Cycle_am_00240.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/Cycle_am_00250.java b/test/testsuite/ouroboros/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/Cycle_am_00250.java
new file mode 100755
index 0000000000000000000000000000000000000000..8792ba82ae684dfe7b3d7dfcc54289d515c8e959
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/Cycle_am_00250.java
@@ -0,0 +1,190 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00250.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00250 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00250.java
+ *- @ExecuteClass: Cycle_am_00250
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00250 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00250_A1 a1_main = new Cycle_a_00250_A1("a1_main");
+        Cycle_a_00250_A6 a6_main = new Cycle_a_00250_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00250_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00250_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00250_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1238)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00250_A1 {
+        Cycle_a_00250_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A2 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A3 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A5 {
+        Cycle_a_00250_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A6 {
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00250 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00250 A1_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A2_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A3_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A4_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A5_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A6_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+
+        A1_Cycle_am_00250.start();
+        A2_Cycle_am_00250.start();
+        A3_Cycle_am_00250.start();
+        A4_Cycle_am_00250.start();
+        A5_Cycle_am_00250.start();
+        A6_Cycle_am_00250.start();
+
+        try {
+            A1_Cycle_am_00250.join();
+            A2_Cycle_am_00250.join();
+            A3_Cycle_am_00250.join();
+            A4_Cycle_am_00250.join();
+            A5_Cycle_am_00250.join();
+            A6_Cycle_am_00250.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00250.check() && A2_Cycle_am_00250.check() && A3_Cycle_am_00250.check() && A4_Cycle_am_00250.check() && A5_Cycle_am_00250.check() && A6_Cycle_am_00250.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/Cycle_am_00260.java b/test/testsuite/ouroboros/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/Cycle_am_00260.java
new file mode 100755
index 0000000000000000000000000000000000000000..99423b3e5db10a3deab22ea00116ae58a66b5d5c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/Cycle_am_00260.java
@@ -0,0 +1,190 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00260.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00260 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00260.java
+ *- @ExecuteClass: Cycle_am_00260
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00260 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00260_A1 a1_main = new Cycle_a_00260_A1("a1_main");
+        Cycle_a_00260_A6 a6_main = new Cycle_a_00260_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00260_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00260_A3("a3_0");
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00260_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1239)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00260_A1 {
+        Cycle_a_00260_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A2 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A3 {
+        Cycle_a_00260_A1 a1_0;
+        Cycle_a_00260_A2 a2_0;
+        Cycle_a_00260_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A5 {
+        Cycle_a_00260_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A6 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00260 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00260 A1_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A2_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A3_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A4_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A5_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A6_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+
+        A1_Cycle_am_00260.start();
+        A2_Cycle_am_00260.start();
+        A3_Cycle_am_00260.start();
+        A4_Cycle_am_00260.start();
+        A5_Cycle_am_00260.start();
+        A6_Cycle_am_00260.start();
+
+        try {
+            A1_Cycle_am_00260.join();
+            A2_Cycle_am_00260.join();
+            A3_Cycle_am_00260.join();
+            A4_Cycle_am_00260.join();
+            A5_Cycle_am_00260.join();
+            A6_Cycle_am_00260.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00260.check() && A2_Cycle_am_00260.check() && A3_Cycle_am_00260.check() && A4_Cycle_am_00260.check() && A5_Cycle_am_00260.check() && A6_Cycle_am_00260.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/Cycle_am_00270.java b/test/testsuite/ouroboros/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/Cycle_am_00270.java
new file mode 100755
index 0000000000000000000000000000000000000000..848c513e6ac96a8b556d7f46ca1916b001f1949b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/Cycle_am_00270.java
@@ -0,0 +1,190 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00270.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00270 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00270.java
+ *- @ExecuteClass: Cycle_am_00270
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00270 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00270_A1 a1_main = new Cycle_a_00270_A1("a1_main");
+        Cycle_a_00270_A6 a6_main = new Cycle_a_00270_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00270_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00270_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00270_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1240)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00270_A1 {
+        Cycle_a_00270_A2 a2_0;
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A2 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A3 {
+        Cycle_a_00270_A1 a1_0;
+        Cycle_a_00270_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A5 {
+        Cycle_a_00270_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A6 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00270 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00270 A1_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A2_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A3_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A4_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A5_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A6_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+
+        A1_Cycle_am_00270.start();
+        A2_Cycle_am_00270.start();
+        A3_Cycle_am_00270.start();
+        A4_Cycle_am_00270.start();
+        A5_Cycle_am_00270.start();
+        A6_Cycle_am_00270.start();
+
+        try {
+            A1_Cycle_am_00270.join();
+            A2_Cycle_am_00270.join();
+            A3_Cycle_am_00270.join();
+            A4_Cycle_am_00270.join();
+            A5_Cycle_am_00270.join();
+            A6_Cycle_am_00270.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00270.check() && A2_Cycle_am_00270.check() && A3_Cycle_am_00270.check() && A4_Cycle_am_00270.check() && A5_Cycle_am_00270.check() && A6_Cycle_am_00270.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/Cycle_am_00280.java b/test/testsuite/ouroboros/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/Cycle_am_00280.java
new file mode 100755
index 0000000000000000000000000000000000000000..3349fcf787dc0414d12957d4353792531c6db2f2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/Cycle_am_00280.java
@@ -0,0 +1,196 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00280.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00280 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00280.java
+ *- @ExecuteClass: Cycle_am_00280
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00280 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1443)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00280_A1 {
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A2 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A3 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A5 {
+        Cycle_a_00280_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A6 {
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00280 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00280 A1_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A2_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A3_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A4_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A5_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A6_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+
+        A1_Cycle_am_00280.start();
+        A2_Cycle_am_00280.start();
+        A3_Cycle_am_00280.start();
+        A4_Cycle_am_00280.start();
+        A5_Cycle_am_00280.start();
+        A6_Cycle_am_00280.start();
+
+        try {
+            A1_Cycle_am_00280.join();
+            A2_Cycle_am_00280.join();
+            A3_Cycle_am_00280.join();
+            A4_Cycle_am_00280.join();
+            A5_Cycle_am_00280.join();
+            A6_Cycle_am_00280.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00280.check() && A2_Cycle_am_00280.check() && A3_Cycle_am_00280.check() && A4_Cycle_am_00280.check() && A5_Cycle_am_00280.check() && A6_Cycle_am_00280.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/Cycle_am_00290.java b/test/testsuite/ouroboros/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/Cycle_am_00290.java
new file mode 100755
index 0000000000000000000000000000000000000000..3b05d7020386f7dc457a77152a0d44f048a5594b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/Cycle_am_00290.java
@@ -0,0 +1,212 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00290.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00290 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00290.java
+ *- @ExecuteClass: Cycle_am_00290
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00290 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00290_A1 a1_main = new Cycle_a_00290_A1("a1_main");
+        Cycle_a_00290_A5 a5_main = new Cycle_a_00290_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00290_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00290_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00290_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00290_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a2_0 = a1_main.a2_0;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1447)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00290_A1 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A2 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A3 {
+        Cycle_a_00290_A1 a1_0;
+        Cycle_a_00290_A4 a4_0;
+        Cycle_a_00290_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A4 {
+        Cycle_a_00290_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A5 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A6 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A6(String strObjectName) {
+            a2_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00290 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00290 A1_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A2_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A3_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A4_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A5_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A6_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+
+        A1_Cycle_am_00290.start();
+        A2_Cycle_am_00290.start();
+        A3_Cycle_am_00290.start();
+        A4_Cycle_am_00290.start();
+        A5_Cycle_am_00290.start();
+        A6_Cycle_am_00290.start();
+
+        try {
+            A1_Cycle_am_00290.join();
+            A2_Cycle_am_00290.join();
+            A3_Cycle_am_00290.join();
+            A4_Cycle_am_00290.join();
+            A5_Cycle_am_00290.join();
+            A6_Cycle_am_00290.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00290.check() && A2_Cycle_am_00290.check() && A3_Cycle_am_00290.check() && A4_Cycle_am_00290.check() && A5_Cycle_am_00290.check() && A6_Cycle_am_00290.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/Cycle_am_00300.java b/test/testsuite/ouroboros/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/Cycle_am_00300.java
new file mode 100755
index 0000000000000000000000000000000000000000..002d2455a583b5de365dd8ff172f451863b2df30
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/Cycle_am_00300.java
@@ -0,0 +1,212 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00300.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00300 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00300.java
+ *- @ExecuteClass: Cycle_am_00300
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00300 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00300_A1 a1_main = new Cycle_a_00300_A1("a1_main");
+        Cycle_a_00300_A5 a5_main = new Cycle_a_00300_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00300_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00300_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00300_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a6_0 = new Cycle_a_00300_A6("a6_0");
+        a5_main.a3_0.a4_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a5_0 = a5_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1448)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00300_A1 {
+        Cycle_a_00300_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A2 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A3 {
+        Cycle_a_00300_A1 a1_0;
+        Cycle_a_00300_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A4 {
+        Cycle_a_00300_A5 a5_0;
+        Cycle_a_00300_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A4(String strObjectName) {
+            a5_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A5 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A6 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00300 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00300 A1_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A2_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A3_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A4_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A5_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A6_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+
+        A1_Cycle_am_00300.start();
+        A2_Cycle_am_00300.start();
+        A3_Cycle_am_00300.start();
+        A4_Cycle_am_00300.start();
+        A5_Cycle_am_00300.start();
+        A6_Cycle_am_00300.start();
+
+        try {
+            A1_Cycle_am_00300.join();
+            A2_Cycle_am_00300.join();
+            A3_Cycle_am_00300.join();
+            A4_Cycle_am_00300.join();
+            A5_Cycle_am_00300.join();
+            A6_Cycle_am_00300.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00300.check() && A2_Cycle_am_00300.check() && A3_Cycle_am_00300.check() && A4_Cycle_am_00300.check() && A5_Cycle_am_00300.check() && A6_Cycle_am_00300.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/Cycle_am_00310.java b/test/testsuite/ouroboros/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/Cycle_am_00310.java
new file mode 100755
index 0000000000000000000000000000000000000000..a03a6626c533a15bf198a298bf67f83c576ae4c7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/Cycle_am_00310.java
@@ -0,0 +1,216 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00310.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00310 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00310.java
+ *- @ExecuteClass: Cycle_am_00310
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00310 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00310_A1 a1_main = new Cycle_a_00310_A1("a1_main");
+        Cycle_a_00310_A4 a4_main = new Cycle_a_00310_A4("a4_main");
+        Cycle_a_00310_A6 a6_main = new Cycle_a_00310_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00310_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00310_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00310_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a4_0 = a4_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a4_main.a6_0 = a6_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1552)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00310_A1 {
+        Cycle_a_00310_A2 a2_0;
+        Cycle_a_00310_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A2 {
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A3 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A4 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A4(String strObjectName) {
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A5 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A6 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00310 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00310 A1_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A2_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A3_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A4_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A5_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A6_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+
+        A1_Cycle_am_00310.start();
+        A2_Cycle_am_00310.start();
+        A3_Cycle_am_00310.start();
+        A4_Cycle_am_00310.start();
+        A5_Cycle_am_00310.start();
+        A6_Cycle_am_00310.start();
+
+        try {
+            A1_Cycle_am_00310.join();
+            A2_Cycle_am_00310.join();
+            A3_Cycle_am_00310.join();
+            A4_Cycle_am_00310.join();
+            A5_Cycle_am_00310.join();
+            A6_Cycle_am_00310.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00310.check() && A2_Cycle_am_00310.check() && A3_Cycle_am_00310.check() && A4_Cycle_am_00310.check() && A5_Cycle_am_00310.check() && A6_Cycle_am_00310.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/Cycle_am_00320.java b/test/testsuite/ouroboros/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/Cycle_am_00320.java
new file mode 100755
index 0000000000000000000000000000000000000000..2a8484dbf13b950dde783090cb3922e3180a8e9b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/Cycle_am_00320.java
@@ -0,0 +1,215 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00320.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00320 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00320.java
+ *- @ExecuteClass: Cycle_am_00320
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00320 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00320_A1 a1_main = new Cycle_a_00320_A1("a1_main");
+        Cycle_a_00320_A4 a4_main = new Cycle_a_00320_A4("a4_main");
+        Cycle_a_00320_A6 a6_main = new Cycle_a_00320_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00320_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00320_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00320_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a6_main.a4_0 = a4_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1551)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00320_A1 {
+        Cycle_a_00320_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A2 {
+        Cycle_a_00320_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A3 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A4 {
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A5 {
+        Cycle_a_00320_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A6 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A3 a3_0;
+        Cycle_a_00320_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00320 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00320 A1_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A2_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A3_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A4_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A5_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A6_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+
+        A1_Cycle_am_00320.start();
+        A2_Cycle_am_00320.start();
+        A3_Cycle_am_00320.start();
+        A4_Cycle_am_00320.start();
+        A5_Cycle_am_00320.start();
+        A6_Cycle_am_00320.start();
+
+        try {
+            A1_Cycle_am_00320.join();
+            A2_Cycle_am_00320.join();
+            A3_Cycle_am_00320.join();
+            A4_Cycle_am_00320.join();
+            A5_Cycle_am_00320.join();
+            A6_Cycle_am_00320.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00320.check() && A2_Cycle_am_00320.check() && A3_Cycle_am_00320.check() && A4_Cycle_am_00320.check() && A5_Cycle_am_00320.check() && A6_Cycle_am_00320.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/Cycle_am_00330.java b/test/testsuite/ouroboros/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/Cycle_am_00330.java
new file mode 100755
index 0000000000000000000000000000000000000000..fa6b5c31ff24e196798bf1302ddece9583dcc843
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/Cycle_am_00330.java
@@ -0,0 +1,262 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00330.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00330 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00330.java
+ *- @ExecuteClass: Cycle_am_00330
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00330 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00330_A1 a1_main = new Cycle_a_00330_A1("a1_main");
+        Cycle_a_00330_A4 a4_main = new Cycle_a_00330_A4("a4_main");
+        Cycle_a_00330_A6 a6_main = new Cycle_a_00330_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00330_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00330_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00330_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00330_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00330_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2080)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00330_A1 {
+        Cycle_a_00330_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A2 {
+        Cycle_a_00330_A3 a3_0;
+        Cycle_a_00330_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A3 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A4 {
+        Cycle_a_00330_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A5 {
+        Cycle_a_00330_A6 a6_0;
+        Cycle_a_00330_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A6 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A7 {
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A8 {
+        Cycle_a_00330_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00330 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00330 A1_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A2_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A3_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A4_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A5_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A6_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+
+        A1_Cycle_am_00330.start();
+        A2_Cycle_am_00330.start();
+        A3_Cycle_am_00330.start();
+        A4_Cycle_am_00330.start();
+        A5_Cycle_am_00330.start();
+        A6_Cycle_am_00330.start();
+
+        try {
+            A1_Cycle_am_00330.join();
+            A2_Cycle_am_00330.join();
+            A3_Cycle_am_00330.join();
+            A4_Cycle_am_00330.join();
+            A5_Cycle_am_00330.join();
+            A6_Cycle_am_00330.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00330.check() && A2_Cycle_am_00330.check() && A3_Cycle_am_00330.check() && A4_Cycle_am_00330.check() && A5_Cycle_am_00330.check() && A6_Cycle_am_00330.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/Cycle_am_00340.java b/test/testsuite/ouroboros/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/Cycle_am_00340.java
new file mode 100755
index 0000000000000000000000000000000000000000..2dba0f8e36ad63a595fb78e3ff5c91e7d862d8f9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/Cycle_am_00340.java
@@ -0,0 +1,261 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00340.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00340 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00340.java
+ *- @ExecuteClass: Cycle_am_00340
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00340 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00340_A1 a1_main = new Cycle_a_00340_A1("a1_main");
+        Cycle_a_00340_A4 a4_main = new Cycle_a_00340_A4("a4_main");
+        Cycle_a_00340_A6 a6_main = new Cycle_a_00340_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00340_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00340_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00340_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a8_0 = new Cycle_a_00340_A8("a8_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0 = new Cycle_a_00340_A7("a7_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a8_0.add();
+        a1_main.a2_0.a3_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a8_0.a7_0.sum + a6_main.a3_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00340_A1 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A2 {
+        Cycle_a_00340_A3 a3_0;
+        Cycle_a_00340_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A3 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A5 a5_0;
+        Cycle_a_00340_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a8_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A4 {
+        Cycle_a_00340_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A5 {
+        Cycle_a_00340_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A6 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A7 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A8 {
+        Cycle_a_00340_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00340 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00340 A1_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A2_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A3_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A4_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A5_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A6_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+
+        A1_Cycle_am_00340.start();
+        A2_Cycle_am_00340.start();
+        A3_Cycle_am_00340.start();
+        A4_Cycle_am_00340.start();
+        A5_Cycle_am_00340.start();
+        A6_Cycle_am_00340.start();
+
+        try {
+            A1_Cycle_am_00340.join();
+            A2_Cycle_am_00340.join();
+            A3_Cycle_am_00340.join();
+            A4_Cycle_am_00340.join();
+            A5_Cycle_am_00340.join();
+            A6_Cycle_am_00340.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00340.check() && A2_Cycle_am_00340.check() && A3_Cycle_am_00340.check() && A4_Cycle_am_00340.check() && A5_Cycle_am_00340.check() && A6_Cycle_am_00340.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/Cycle_am_00350.java b/test/testsuite/ouroboros/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/Cycle_am_00350.java
new file mode 100755
index 0000000000000000000000000000000000000000..d510803f8613129b255d70ee8e177182eb325f79
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/Cycle_am_00350.java
@@ -0,0 +1,261 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00350.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00350 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00350.java
+ *- @ExecuteClass: Cycle_am_00350
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00350 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00350_A1 a1_main = new Cycle_a_00350_A1("a1_main");
+        Cycle_a_00350_A4 a4_main = new Cycle_a_00350_A4("a4_main");
+        Cycle_a_00350_A6 a6_main = new Cycle_a_00350_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00350_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00350_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00350_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00350_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00350_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00350_A1 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A2 {
+        Cycle_a_00350_A3 a3_0;
+        Cycle_a_00350_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A3 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A4 {
+        Cycle_a_00350_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A5 {
+        Cycle_a_00350_A6 a6_0;
+        Cycle_a_00350_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A6 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A7 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A8 {
+        Cycle_a_00350_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00350 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00350 A1_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A2_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A3_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A4_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A5_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A6_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+
+        A1_Cycle_am_00350.start();
+        A2_Cycle_am_00350.start();
+        A3_Cycle_am_00350.start();
+        A4_Cycle_am_00350.start();
+        A5_Cycle_am_00350.start();
+        A6_Cycle_am_00350.start();
+
+        try {
+            A1_Cycle_am_00350.join();
+            A2_Cycle_am_00350.join();
+            A3_Cycle_am_00350.join();
+            A4_Cycle_am_00350.join();
+            A5_Cycle_am_00350.join();
+            A6_Cycle_am_00350.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00350.check() && A2_Cycle_am_00350.check() && A3_Cycle_am_00350.check() && A4_Cycle_am_00350.check() && A5_Cycle_am_00350.check() && A6_Cycle_am_00350.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/Cycle_am_00360.java b/test/testsuite/ouroboros/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/Cycle_am_00360.java
new file mode 100755
index 0000000000000000000000000000000000000000..6ac1b124768f55beec3edbc48669a8d34b724ade
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/Cycle_am_00360.java
@@ -0,0 +1,286 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00360.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00360 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00360.java
+ *- @ExecuteClass: Cycle_am_00360
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00360 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00360_A1 a1_main = new Cycle_a_00360_A1("a1_main");
+        Cycle_a_00360_A4 a4_main = new Cycle_a_00360_A4("a4_main");
+        Cycle_a_00360_A6 a6_main = new Cycle_a_00360_A6("a6_main");
+        Cycle_a_00360_A9 a9_main = new Cycle_a_00360_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00360_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00360_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00360_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00360_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00360_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0.a9_0 = a9_main;
+        a9_main.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2399)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00360_A1 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A2 {
+        Cycle_a_00360_A3 a3_0;
+        Cycle_a_00360_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A3 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A4 {
+        Cycle_a_00360_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A5 {
+        Cycle_a_00360_A6 a6_0;
+        Cycle_a_00360_A8 a8_0;
+        Cycle_a_00360_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a9_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A6 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A7 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A8 {
+        Cycle_a_00360_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A9 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A9(String strObjectName) {
+            a2_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00360 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00360 A1_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A2_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A3_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A4_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A5_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A6_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+
+        A1_Cycle_am_00360.start();
+        A2_Cycle_am_00360.start();
+        A3_Cycle_am_00360.start();
+        A4_Cycle_am_00360.start();
+        A5_Cycle_am_00360.start();
+        A6_Cycle_am_00360.start();
+
+        try {
+            A1_Cycle_am_00360.join();
+            A2_Cycle_am_00360.join();
+            A3_Cycle_am_00360.join();
+            A4_Cycle_am_00360.join();
+            A5_Cycle_am_00360.join();
+            A6_Cycle_am_00360.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00360.check() && A2_Cycle_am_00360.check() && A3_Cycle_am_00360.check() && A4_Cycle_am_00360.check() && A5_Cycle_am_00360.check() && A6_Cycle_am_00360.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/Cycle_am_00370.java b/test/testsuite/ouroboros/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/Cycle_am_00370.java
new file mode 100755
index 0000000000000000000000000000000000000000..daa8d627058f82626919fc8a3966ffc7bff6982b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/Cycle_am_00370.java
@@ -0,0 +1,307 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00370.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00370 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00370.java
+ *- @ExecuteClass: Cycle_am_00370
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00370 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2623)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00370_A1 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A2 {
+        Cycle_a_00370_A3 a3_0;
+        Cycle_a_00370_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A3 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A5 a5_0;
+        Cycle_a_00370_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A4 {
+        Cycle_a_00370_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A5 {
+        Cycle_a_00370_A6 a6_0;
+        Cycle_a_00370_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A6 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A7 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A8 {
+        Cycle_a_00370_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A9 {
+        Cycle_a_00370_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A10 {
+        Cycle_a_00370_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00370 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00370 A1_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A2_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A3_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A4_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A5_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A6_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+
+        A1_Cycle_am_00370.start();
+        A2_Cycle_am_00370.start();
+        A3_Cycle_am_00370.start();
+        A4_Cycle_am_00370.start();
+        A5_Cycle_am_00370.start();
+        A6_Cycle_am_00370.start();
+
+        try {
+            A1_Cycle_am_00370.join();
+            A2_Cycle_am_00370.join();
+            A3_Cycle_am_00370.join();
+            A4_Cycle_am_00370.join();
+            A5_Cycle_am_00370.join();
+            A6_Cycle_am_00370.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00370.check() && A2_Cycle_am_00370.check() && A3_Cycle_am_00370.check() && A4_Cycle_am_00370.check() && A5_Cycle_am_00370.check() && A6_Cycle_am_00370.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/Cycle_am_00380.java b/test/testsuite/ouroboros/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/Cycle_am_00380.java
new file mode 100755
index 0000000000000000000000000000000000000000..a32bbcb5c7ec9c6787909ad317535e9a37a69f8e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/Cycle_am_00380.java
@@ -0,0 +1,149 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00380.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00380 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00380.java
+ *- @ExecuteClass: Cycle_am_00380
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+
+class ThreadRc_Cycle_am_00380 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00380_A1 a1_main = new Cycle_a_00380_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00380_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00380_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00380_A1 {
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00380_A2 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00380_A3 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00380 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00380 A1_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A2_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A3_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A4_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A5_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A6_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+
+        A1_Cycle_am_00380.start();
+        A2_Cycle_am_00380.start();
+        A3_Cycle_am_00380.start();
+        A4_Cycle_am_00380.start();
+        A5_Cycle_am_00380.start();
+        A6_Cycle_am_00380.start();
+
+        try {
+            A1_Cycle_am_00380.join();
+            A2_Cycle_am_00380.join();
+            A3_Cycle_am_00380.join();
+            A4_Cycle_am_00380.join();
+            A5_Cycle_am_00380.join();
+            A6_Cycle_am_00380.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00380.check() && A2_Cycle_am_00380.check() && A3_Cycle_am_00380.check() && A4_Cycle_am_00380.check() && A5_Cycle_am_00380.check() && A6_Cycle_am_00380.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/Cycle_am_00390.java b/test/testsuite/ouroboros/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/Cycle_am_00390.java
new file mode 100755
index 0000000000000000000000000000000000000000..7dcf27bca8e16806f14d63a8147a142a294325bb
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/Cycle_am_00390.java
@@ -0,0 +1,151 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00390.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00390 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00390.java
+ *- @ExecuteClass: Cycle_am_00390
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00390 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00390_A1 a1_main = new Cycle_a_00390_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00390_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00390_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 918)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00390_A1 {
+        Cycle_a_00390_A2 a2_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00390_A2 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00390_A3 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00390 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00390 A1_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A2_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A3_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A4_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A5_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A6_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+
+        A1_Cycle_am_00390.start();
+        A2_Cycle_am_00390.start();
+        A3_Cycle_am_00390.start();
+        A4_Cycle_am_00390.start();
+        A5_Cycle_am_00390.start();
+        A6_Cycle_am_00390.start();
+
+        try {
+            A1_Cycle_am_00390.join();
+            A2_Cycle_am_00390.join();
+            A3_Cycle_am_00390.join();
+            A4_Cycle_am_00390.join();
+            A5_Cycle_am_00390.join();
+            A6_Cycle_am_00390.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00390.check() && A2_Cycle_am_00390.check() && A3_Cycle_am_00390.check() && A4_Cycle_am_00390.check() && A5_Cycle_am_00390.check() && A6_Cycle_am_00390.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/Cycle_am_00400.java b/test/testsuite/ouroboros/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/Cycle_am_00400.java
new file mode 100755
index 0000000000000000000000000000000000000000..91ad0c701c5d031fa52a3a9714544a6e01184aaa
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/Cycle_am_00400.java
@@ -0,0 +1,165 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00400.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00400 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00400.java
+ *- @ExecuteClass: Cycle_am_00400
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00400 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00400_A1 a1_main = new Cycle_a_00400_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00400_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00400_A3("a3_0");
+        a1_main.a4_0 = new Cycle_a_00400_A4("a4_0");
+        a1_main.a4_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00400_A1 {
+        Cycle_a_00400_A2 a2_0;
+        Cycle_a_00400_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A2 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A3 {
+        Cycle_a_00400_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A4 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00400 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00400 A1_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A2_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A3_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A4_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A5_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A6_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+
+        A1_Cycle_am_00400.start();
+        A2_Cycle_am_00400.start();
+        A3_Cycle_am_00400.start();
+        A4_Cycle_am_00400.start();
+        A5_Cycle_am_00400.start();
+        A6_Cycle_am_00400.start();
+
+        try {
+            A1_Cycle_am_00400.join();
+            A2_Cycle_am_00400.join();
+            A3_Cycle_am_00400.join();
+            A4_Cycle_am_00400.join();
+            A5_Cycle_am_00400.join();
+            A6_Cycle_am_00400.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00400.check() && A2_Cycle_am_00400.check() && A3_Cycle_am_00400.check() && A4_Cycle_am_00400.check() && A5_Cycle_am_00400.check() && A6_Cycle_am_00400.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/Cycle_am_00410.java b/test/testsuite/ouroboros/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/Cycle_am_00410.java
new file mode 100755
index 0000000000000000000000000000000000000000..88b1b10a01aa33df669feca133ce3e5e16ac9b16
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/Cycle_am_00410.java
@@ -0,0 +1,165 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00410.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00410 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00410.java
+ *- @ExecuteClass: Cycle_am_00410
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00410 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00410_A1 a1_main = new Cycle_a_00410_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00410_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00410_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00410_A4("a4_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 921)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00410_A1 {
+        Cycle_a_00410_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A2 {
+        Cycle_a_00410_A3 a3_0;
+        Cycle_a_00410_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A3 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A4 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00410 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00410 A1_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A2_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A3_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A4_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A5_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A6_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+
+        A1_Cycle_am_00410.start();
+        A2_Cycle_am_00410.start();
+        A3_Cycle_am_00410.start();
+        A4_Cycle_am_00410.start();
+        A5_Cycle_am_00410.start();
+        A6_Cycle_am_00410.start();
+
+        try {
+            A1_Cycle_am_00410.join();
+            A2_Cycle_am_00410.join();
+            A3_Cycle_am_00410.join();
+            A4_Cycle_am_00410.join();
+            A5_Cycle_am_00410.join();
+            A6_Cycle_am_00410.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00410.check() && A2_Cycle_am_00410.check() && A3_Cycle_am_00410.check() && A4_Cycle_am_00410.check() && A5_Cycle_am_00410.check() && A6_Cycle_am_00410.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/Cycle_am_00420.java b/test/testsuite/ouroboros/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/Cycle_am_00420.java
new file mode 100755
index 0000000000000000000000000000000000000000..6e3be57542480b3b24fc6c1849e87ad407de7387
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/Cycle_am_00420.java
@@ -0,0 +1,166 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00420.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00420 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00420.java
+ *- @ExecuteClass: Cycle_am_00420
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00420 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00420_A1 a1_main = new Cycle_a_00420_A1("a1_main");
+//		 Cycle_a_00420_A4 a4_main = new Cycle_a_00420_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00420_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00420_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00420_A4("a4_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00420_A1 {
+        Cycle_a_00420_A2 a2_0;
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A2 {
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A3 {
+        Cycle_a_00420_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A4 {
+        Cycle_a_00420_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00420 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00420 A1_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A2_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A3_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A4_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A5_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A6_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+
+        A1_Cycle_am_00420.start();
+        A2_Cycle_am_00420.start();
+        A3_Cycle_am_00420.start();
+        A4_Cycle_am_00420.start();
+        A5_Cycle_am_00420.start();
+        A6_Cycle_am_00420.start();
+
+        try {
+            A1_Cycle_am_00420.join();
+            A2_Cycle_am_00420.join();
+            A3_Cycle_am_00420.join();
+            A4_Cycle_am_00420.join();
+            A5_Cycle_am_00420.join();
+            A6_Cycle_am_00420.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00420.check() && A2_Cycle_am_00420.check() && A3_Cycle_am_00420.check() && A4_Cycle_am_00420.check() && A5_Cycle_am_00420.check() && A6_Cycle_am_00420.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/Cycle_am_00430.java b/test/testsuite/ouroboros/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/Cycle_am_00430.java
new file mode 100755
index 0000000000000000000000000000000000000000..9274cd6ce24254fc700fd88111c7a6594f48d95b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/Cycle_am_00430.java
@@ -0,0 +1,172 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00430.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00430 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00430.java
+ *- @ExecuteClass: Cycle_am_00430
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00430 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00430_A1 a1_main = new Cycle_a_00430_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00430_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00430_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00430_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1124)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00430_A1 {
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A2 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A3 a3_0;
+        Cycle_a_00430_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A3 {
+        Cycle_a_00430_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A4 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00430 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00430 A1_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A2_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A3_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A4_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A5_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A6_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+
+        A1_Cycle_am_00430.start();
+        A2_Cycle_am_00430.start();
+        A3_Cycle_am_00430.start();
+        A4_Cycle_am_00430.start();
+        A5_Cycle_am_00430.start();
+        A6_Cycle_am_00430.start();
+
+        try {
+            A1_Cycle_am_00430.join();
+            A2_Cycle_am_00430.join();
+            A3_Cycle_am_00430.join();
+            A4_Cycle_am_00430.join();
+            A5_Cycle_am_00430.join();
+            A6_Cycle_am_00430.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00430.check() && A2_Cycle_am_00430.check() && A3_Cycle_am_00430.check() && A4_Cycle_am_00430.check() && A5_Cycle_am_00430.check() && A6_Cycle_am_00430.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/Cycle_am_00440.java b/test/testsuite/ouroboros/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/Cycle_am_00440.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1a917f27658f775c25b16c93b6b31beefec951e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/Cycle_am_00440.java
@@ -0,0 +1,170 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00440.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00440 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00440.java
+ *- @ExecuteClass: Cycle_am_00440
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00440 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00440_A1 a1_main = new Cycle_a_00440_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00440_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00440_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00440_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1023)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00440_A1 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A2 {
+        Cycle_a_00440_A1 a1_0;
+        Cycle_a_00440_A3 a3_0;
+        Cycle_a_00440_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A3 {
+        Cycle_a_00440_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A4 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00440 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00440 A1_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A2_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A3_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A4_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A5_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A6_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+
+        A1_Cycle_am_00440.start();
+        A2_Cycle_am_00440.start();
+        A3_Cycle_am_00440.start();
+        A4_Cycle_am_00440.start();
+        A5_Cycle_am_00440.start();
+        A6_Cycle_am_00440.start();
+
+        try {
+            A1_Cycle_am_00440.join();
+            A2_Cycle_am_00440.join();
+            A3_Cycle_am_00440.join();
+            A4_Cycle_am_00440.join();
+            A5_Cycle_am_00440.join();
+            A6_Cycle_am_00440.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00440.check() && A2_Cycle_am_00440.check() && A3_Cycle_am_00440.check() && A4_Cycle_am_00440.check() && A5_Cycle_am_00440.check() && A6_Cycle_am_00440.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/Cycle_am_00450.java b/test/testsuite/ouroboros/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/Cycle_am_00450.java
new file mode 100755
index 0000000000000000000000000000000000000000..3371ece46cf126caf9051856e593d405fbcb296a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/Cycle_am_00450.java
@@ -0,0 +1,213 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00450.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00450 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00450.java
+ *- @ExecuteClass: Cycle_am_00450
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00450 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00450_A1 a1_main = new Cycle_a_00450_A1("a1_main");
+        Cycle_a_00450_A6 a6_main = new Cycle_a_00450_A6("a6_main");
+        Cycle_a_00450_A7 a7_main = new Cycle_a_00450_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00450_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00450_A3("a3_0");
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00450_A5("a5_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = a7_main;
+        a7_main.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a6_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+
+        int result = a1_main.sum + a6_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1453)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00450_A1 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A2 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A3 {
+        Cycle_a_00450_A1 a1_0;
+        Cycle_a_00450_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A5 {
+        Cycle_a_00450_A6 a6_0;
+        Cycle_a_00450_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A5(String strObjectName) {
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A6 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A7 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00450 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00450 A1_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A2_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A3_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A4_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A5_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A6_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+
+        A1_Cycle_am_00450.start();
+        A2_Cycle_am_00450.start();
+        A3_Cycle_am_00450.start();
+        A4_Cycle_am_00450.start();
+        A5_Cycle_am_00450.start();
+        A6_Cycle_am_00450.start();
+
+        try {
+            A1_Cycle_am_00450.join();
+            A2_Cycle_am_00450.join();
+            A3_Cycle_am_00450.join();
+            A4_Cycle_am_00450.join();
+            A5_Cycle_am_00450.join();
+            A6_Cycle_am_00450.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00450.check() && A2_Cycle_am_00450.check() && A3_Cycle_am_00450.check() && A4_Cycle_am_00450.check() && A5_Cycle_am_00450.check() && A6_Cycle_am_00450.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/Cycle_am_00460.java b/test/testsuite/ouroboros/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/Cycle_am_00460.java
new file mode 100755
index 0000000000000000000000000000000000000000..db1ee2b145aab0fed34ce66444d41792aa7d8df7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/Cycle_am_00460.java
@@ -0,0 +1,216 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00460.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00460 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00460.java
+ *- @ExecuteClass: Cycle_am_00460
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+
+class ThreadRc_Cycle_am_00460 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00460_A1 a1_main = new Cycle_a_00460_A1("a1_main");
+        Cycle_a_00460_A5 a5_main = new Cycle_a_00460_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00460_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00460_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00460_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00460_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00460_A1 {
+        Cycle_a_00460_A2 a2_0;
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A2 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A3 {
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A4 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A5 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A6 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A6(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00460 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00460 A1_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A2_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A3_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A4_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A5_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A6_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+
+        A1_Cycle_am_00460.start();
+        A2_Cycle_am_00460.start();
+        A3_Cycle_am_00460.start();
+        A4_Cycle_am_00460.start();
+        A5_Cycle_am_00460.start();
+        A6_Cycle_am_00460.start();
+
+        try {
+            A1_Cycle_am_00460.join();
+            A2_Cycle_am_00460.join();
+            A3_Cycle_am_00460.join();
+            A4_Cycle_am_00460.join();
+            A5_Cycle_am_00460.join();
+            A6_Cycle_am_00460.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00460.check() && A2_Cycle_am_00460.check() && A3_Cycle_am_00460.check() && A4_Cycle_am_00460.check() && A5_Cycle_am_00460.check() && A6_Cycle_am_00460.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/Cycle_am_00470.java b/test/testsuite/ouroboros/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/Cycle_am_00470.java
new file mode 100755
index 0000000000000000000000000000000000000000..3168b2ffab92b2f2c268e7addea7e7535314c324
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/Cycle_am_00470.java
@@ -0,0 +1,212 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00470.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00470 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00470.java
+ *- @ExecuteClass: Cycle_am_00470
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00470 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00470_A1 a1_main = new Cycle_a_00470_A1("a1_main");
+        Cycle_a_00470_A5 a5_main = new Cycle_a_00470_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00470_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00470_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00470_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00470_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a1_0 = a1_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1446)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00470_A1 {
+        Cycle_a_00470_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A2 {
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A3 {
+        Cycle_a_00470_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A4 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A5 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A5(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A6 {
+        Cycle_a_00470_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A6(String strObjectName) {
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00470 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00470 A1_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A2_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A3_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A4_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A5_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A6_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+
+        A1_Cycle_am_00470.start();
+        A2_Cycle_am_00470.start();
+        A3_Cycle_am_00470.start();
+        A4_Cycle_am_00470.start();
+        A5_Cycle_am_00470.start();
+        A6_Cycle_am_00470.start();
+
+        try {
+            A1_Cycle_am_00470.join();
+            A2_Cycle_am_00470.join();
+            A3_Cycle_am_00470.join();
+            A4_Cycle_am_00470.join();
+            A5_Cycle_am_00470.join();
+            A6_Cycle_am_00470.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00470.check() && A2_Cycle_am_00470.check() && A3_Cycle_am_00470.check() && A4_Cycle_am_00470.check() && A5_Cycle_am_00470.check() && A6_Cycle_am_00470.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/Cycle_am_00480.java b/test/testsuite/ouroboros/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/Cycle_am_00480.java
new file mode 100755
index 0000000000000000000000000000000000000000..93360a611dda7fca3564b7690743955da29e02f2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/Cycle_am_00480.java
@@ -0,0 +1,235 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00480.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00480 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00480.java
+ *- @ExecuteClass: Cycle_am_00480
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00480 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00480_A1 a1_main = new Cycle_a_00480_A1("a1_main");
+        Cycle_a_00480_A5 a5_main = new Cycle_a_00480_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00480_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00480_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00480_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00480_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a5_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a1_0.add();
+
+        a5_main.a3_0.add();
+        a5_main.a3_0.a4_0.add();
+
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a5_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum);
+
+
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a5_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a1_main.a2_0.a3_0.a4_0.sum+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00480_A1 {
+        Cycle_a_00480_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A2 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A3 {
+        Cycle_a_00480_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A4 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A5 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A6 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A4 a4_0;
+        Cycle_a_00480_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A6(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a5_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00480 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00480 A1_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A2_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A3_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A4_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A5_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A6_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+
+        A1_Cycle_am_00480.start();
+        A2_Cycle_am_00480.start();
+        A3_Cycle_am_00480.start();
+        A4_Cycle_am_00480.start();
+        A5_Cycle_am_00480.start();
+        A6_Cycle_am_00480.start();
+
+        try {
+            A1_Cycle_am_00480.join();
+            A2_Cycle_am_00480.join();
+            A3_Cycle_am_00480.join();
+            A4_Cycle_am_00480.join();
+            A5_Cycle_am_00480.join();
+            A6_Cycle_am_00480.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00480.check() && A2_Cycle_am_00480.check() && A3_Cycle_am_00480.check() && A4_Cycle_am_00480.check() && A5_Cycle_am_00480.check() && A6_Cycle_am_00480.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/Cycle_am_00490.java b/test/testsuite/ouroboros/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/Cycle_am_00490.java
new file mode 100755
index 0000000000000000000000000000000000000000..2f892714ea669e10d1f6331974b95734b9f3d8c0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/Cycle_am_00490.java
@@ -0,0 +1,301 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00490.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00490 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00490.java
+ *- @ExecuteClass: Cycle_am_00490
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_am_00490 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00490_A1 a1_main = new Cycle_a_00490_A1("a1_main");
+        Cycle_a_00490_A4 a4_main = new Cycle_a_00490_A4("a4_main");
+        Cycle_a_00490_A7 a7_main = new Cycle_a_00490_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00490_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a5_0 = new Cycle_a_00490_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00490_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+//		 a4_main.a5_0.a6_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a4_main.a5_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0.a6_0.a3_0.a1_0 = a1_main;
+
+        a7_main.a9_0 = new Cycle_a_00490_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00490_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0.a8_0.a5_0 = a4_main.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a6_0.a3_0.add();
+        a4_main.a5_0.a6_0.a3_0.a1_0.add();
+
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        a7_main.a9_0.a8_0.a5_0.add();
+//
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a4_main.sum);
+//		 System.out.println("a7_main.sum:"+a7_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a4_main.a5_0.sum:"+a4_main.a5_0.sum);
+//		 System.out.println("a4_main.a5_0.a6_0.sum:"+a4_main.a5_0.a6_0.sum);
+//		 System.out.println("a7_main.a9_0.sum:"+a7_main.a9_0.sum);
+//		 System.out.println("a7_main.a9_0.a8_0.sum:"+a7_main.a9_0.a8_0.sum);
+
+
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a4_main.sum+a7_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a4_main.a5_0.sum+a4_main.a5_0.a6_0.sum+a7_main.a9_0.sum+a7_main.a9_0.a8_0.sum);
+
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2098)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00490_A1 {
+        Cycle_a_00490_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A2 {
+        Cycle_a_00490_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A3 {
+        Cycle_a_00490_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A4 {
+        Cycle_a_00490_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A5 {
+        Cycle_a_00490_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A6 {
+        Cycle_a_00490_A3 a3_0;
+        Cycle_a_00490_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A6(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A7 {
+        Cycle_a_00490_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A8 {
+        Cycle_a_00490_A5 a5_0;
+        Cycle_a_00490_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A8(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A9 {
+        Cycle_a_00490_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00490 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00490 A1_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A2_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A3_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A4_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A5_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A6_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+
+        A1_Cycle_am_00490.start();
+        A2_Cycle_am_00490.start();
+        A3_Cycle_am_00490.start();
+        A4_Cycle_am_00490.start();
+        A5_Cycle_am_00490.start();
+        A6_Cycle_am_00490.start();
+
+        try {
+            A1_Cycle_am_00490.join();
+            A2_Cycle_am_00490.join();
+            A3_Cycle_am_00490.join();
+            A4_Cycle_am_00490.join();
+            A5_Cycle_am_00490.join();
+            A6_Cycle_am_00490.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00490.check() && A2_Cycle_am_00490.check() && A3_Cycle_am_00490.check() && A4_Cycle_am_00490.check() && A5_Cycle_am_00490.check() && A6_Cycle_am_00490.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/Cycle_am_00500.java b/test/testsuite/ouroboros/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/Cycle_am_00500.java
new file mode 100755
index 0000000000000000000000000000000000000000..b1ec8360e940197329baff80a326364537fc7fc2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/Cycle_am_00500.java
@@ -0,0 +1,302 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00500.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_00500 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00500.java
+ *- @ExecuteClass: Cycle_am_00500
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_am_00500 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00500_A1 a1_main = new Cycle_a_00500_A1("a1_main");
+        Cycle_a_00500_A4 a4_main = new Cycle_a_00500_A4("a4_main");
+        Cycle_a_00500_A7 a7_main = new Cycle_a_00500_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00500_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00500_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00500_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00500_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+
+        a4_main.a5_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a4_main.a5_0.a8_0.a7_0 = a7_main;
+
+        a7_main.a9_0 = new Cycle_a_00500_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a8_0.add();
+        a4_main.a5_0.a8_0.a7_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+
+
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a4_main.sum);
+//		 System.out.println("a7_main.sum:"+a7_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a4_main.a5_0.sum:"+a4_main.a5_0.sum);
+//		 System.out.println("a4_main.a5_0.a6_0.sum:"+a4_main.a5_0.a6_0.sum);
+//		 System.out.println("a7_main.a9_0.sum:"+a7_main.a9_0.sum);
+//		 System.out.println("a7_main.a9_0.a8_0.sum:"+a7_main.a9_0.a8_0.sum);
+
+
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a4_main.sum+a7_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a4_main.a5_0.sum+a4_main.a5_0.a6_0.sum+a7_main.a9_0.sum+a7_main.a9_0.a8_0.sum);
+
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2099)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00500_A1 {
+        Cycle_a_00500_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A2 {
+        Cycle_a_00500_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A3 {
+        Cycle_a_00500_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A4 {
+        Cycle_a_00500_A1 a1_0;
+        Cycle_a_00500_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A4(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A5 {
+        Cycle_a_00500_A6 a6_0;
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A6 {
+        Cycle_a_00500_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A6(String strObjectName) {
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A7 {
+        Cycle_a_00500_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A8 {
+        Cycle_a_00500_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A9 {
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_00500 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00500 A1_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A2_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A3_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A4_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A5_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A6_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+
+        A1_Cycle_am_00500.start();
+        A2_Cycle_am_00500.start();
+        A3_Cycle_am_00500.start();
+        A4_Cycle_am_00500.start();
+        A5_Cycle_am_00500.start();
+        A6_Cycle_am_00500.start();
+
+        try {
+            A1_Cycle_am_00500.join();
+            A2_Cycle_am_00500.join();
+            A3_Cycle_am_00500.join();
+            A4_Cycle_am_00500.join();
+            A5_Cycle_am_00500.join();
+            A6_Cycle_am_00500.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00500.check() && A2_Cycle_am_00500.check() && A3_Cycle_am_00500.check() && A4_Cycle_am_00500.check() && A5_Cycle_am_00500.check() && A6_Cycle_am_00500.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/Cycle_am_00510.java b/test/testsuite/ouroboros/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/Cycle_am_00510.java
new file mode 100755
index 0000000000000000000000000000000000000000..9193c47346eeff3afc758651f314c0c78581d490
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/Cycle_am_00510.java
@@ -0,0 +1,5641 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_00510.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:make all Cycle_a_xx together to this Multi thread testcase for Performance Testing.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_00510.java
+ *- @ExecuteClass: Cycle_am_00510
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_am_00180B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00180_A1 a1_main = new Cycle_a_00180_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00180_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00180_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00180_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00180_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00180_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a8_0 = new Cycle_a_00180_A8("a8_0");
+        a1_main.a8_0.a9_0 = new Cycle_a_00180_A9("a9_0");
+        a1_main.a8_0.a9_0.a7_0 = new Cycle_a_00180_A7("a7_0");
+        a1_main.a8_0.a9_0.a7_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_main.a8_0.add();
+        a1_main.a8_0.a9_0.add();
+        a1_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_main.a8_0.sum + a1_main.a8_0.a9_0.sum + a1_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1994)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00180_A1 {
+        Cycle_a_00180_A2 a2_0;
+        Cycle_a_00180_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A1(String strObjectName) {
+            a2_0 = null;
+            a8_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A2 {
+        Cycle_a_00180_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A3 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A4 {
+        Cycle_a_00180_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A5 {
+        Cycle_a_00180_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A6 {
+        Cycle_a_00180_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A6(String strObjectName) {
+            a1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A7 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A7(String strObjectName) {
+            a4_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A8 {
+        Cycle_a_00180_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00180_A9 {
+        Cycle_a_00180_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00180_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00190B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00190_A1 a1_main = new Cycle_a_00190_A1("a1_main");
+        Cycle_a_00190_A10 a10_main = new Cycle_a_00190_A10("a10_main");
+        a1_main.a2_0 = new Cycle_a_00190_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00190_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00190_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00190_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00190_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_main;
+
+        a10_main.a8_0 = new Cycle_a_00190_A8("a8_0");
+        a10_main.a8_0.a9_0 = new Cycle_a_00190_A9("a9_0");
+        a10_main.a8_0.a9_0.a7_0 = new Cycle_a_00190_A7("a7_0");
+        a10_main.a8_0.a9_0.a7_0.a5_0 = a1_main.a2_0.a3_0.a4_0.a5_0;
+
+        a1_main.add();
+        a10_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_main.a8_0.add();
+        a10_main.a8_0.a9_0.add();
+        a10_main.a8_0.a9_0.a7_0.add();
+
+
+        int result = a1_main.sum + a10_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_main.a8_0.sum + a10_main.a8_0.a9_0.sum + a10_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2215)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00190_A1 {
+        Cycle_a_00190_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A2 {
+        Cycle_a_00190_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A3 {
+        Cycle_a_00190_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A4 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A5 {
+        Cycle_a_00190_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A6 {
+        Cycle_a_00190_A1 a1_0;
+        Cycle_a_00190_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A6(String strObjectName) {
+            a1_0 = null;
+            a10_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A7 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A7(String strObjectName) {
+            a5_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A8 {
+        Cycle_a_00190_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A9 {
+        Cycle_a_00190_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00190_A10 {
+        Cycle_a_00190_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00190_A10(String strObjectName) {
+            a8_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00200B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00200_A1 a1_main = new Cycle_a_00200_A1("a1_main");
+        Cycle_a_00200_A4 a4_main = new Cycle_a_00200_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00200_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00200_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00200_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a6_0 = new Cycle_a_00200_A6("a6_0");
+        a1_main.a2_0.a6_0.a7_0 = new Cycle_a_00200_A7("a7_0");
+        a1_main.a2_0.a7_0 = a1_main.a2_0.a6_0.a7_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a6_0.add();
+        a1_main.a2_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a6_0.sum + a1_main.a2_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00200_A1 {
+        Cycle_a_00200_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A2 {
+        Cycle_a_00200_A3 a3_0;
+        Cycle_a_00200_A6 a6_0;
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A2(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A3 {
+        Cycle_a_00200_A1 a1_0;
+        Cycle_a_00200_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A4 {
+        Cycle_a_00200_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A5 {
+        Cycle_a_00200_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A6 {
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00200_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00200_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00210B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00210_A1 a1_main = new Cycle_a_00210_A1("a1_main");
+        Cycle_a_00210_A4 a4_main = new Cycle_a_00210_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00210_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00210_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00210_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00210_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0 = new Cycle_a_00210_A7("a7_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        a1_main.a2_0.a3_0.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a6_0.sum + a1_main.a2_0.a3_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1662)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00210_A1 {
+        Cycle_a_00210_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A2 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A3 {
+        Cycle_a_00210_A1 a1_0;
+        Cycle_a_00210_A5 a5_0;
+        Cycle_a_00210_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A4 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A5 {
+        Cycle_a_00210_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A6 {
+        Cycle_a_00210_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00210_A7 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00210_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00220B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00220_A1 a1_main = new Cycle_a_00220_A1("a1_main");
+        Cycle_a_00220_A4 a4_main = new Cycle_a_00220_A4("a4_main");
+        Cycle_a_00220_A6 a6_main = new Cycle_a_00220_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00220_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00220_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00220_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_00220_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1772)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00220_A1 {
+        Cycle_a_00220_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A2 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A3 {
+        Cycle_a_00220_A1 a1_0;
+        Cycle_a_00220_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A4 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A5 {
+        Cycle_a_00220_A4 a4_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A6 {
+        Cycle_a_00220_A5 a5_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00220_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00220_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00230B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00230_A1 a1_main = new Cycle_a_00230_A1("a1_main");
+        Cycle_a_00230_A5 a5_main = new Cycle_a_00230_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00230_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00230_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00230_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a7_0 = new Cycle_a_00230_A7("a7_0");
+        a5_main.a6_0 = new Cycle_a_00230_A6("a6_0");
+        a5_main.a6_0.a7_0 = a5_main.a7_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a5_main.a7_0.add();
+        a5_main.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a5_main.a6_0.sum + a5_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00230_A1 {
+        Cycle_a_00230_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A2 {
+        Cycle_a_00230_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A3 {
+        Cycle_a_00230_A1 a1_0;
+        Cycle_a_00230_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A4 {
+        Cycle_a_00230_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A5 {
+        Cycle_a_00230_A3 a3_0;
+        Cycle_a_00230_A6 a6_0;
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A5(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A6 {
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00230_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00230_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00240B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00240_A1 a1_main = new Cycle_a_00240_A1("a1_main");
+        Cycle_a_00240_A5 a5_main = new Cycle_a_00240_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00240_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00240_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a6_0 = new Cycle_a_00240_A6("a6_0");
+        a1_main.a6_0.a7_0 = new Cycle_a_00240_A7("a7_0");
+        a1_main.a6_0.a7_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a6_0.add();
+        a1_main.a6_0.a7_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a6_0.sum + a1_main.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1660)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00240_A1 {
+        Cycle_a_00240_A2 a2_0;
+        Cycle_a_00240_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A1(String strObjectName) {
+            a2_0 = null;
+            a6_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A2 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A3 {
+        Cycle_a_00240_A1 a1_0;
+        Cycle_a_00240_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A4 {
+        Cycle_a_00240_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A5 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A6 {
+        Cycle_a_00240_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00240_A7 {
+        Cycle_a_00240_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00240_A7(String strObjectName) {
+            a1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00250B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00250_A1 a1_main = new Cycle_a_00250_A1("a1_main");
+        Cycle_a_00250_A6 a6_main = new Cycle_a_00250_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00250_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00250_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00250_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1238)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00250_A1 {
+        Cycle_a_00250_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A2 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A3 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A5 {
+        Cycle_a_00250_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00250_A6 {
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00250_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00260B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00260_A1 a1_main = new Cycle_a_00260_A1("a1_main");
+        Cycle_a_00260_A6 a6_main = new Cycle_a_00260_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00260_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00260_A3("a3_0");
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00260_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1239)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00260_A1 {
+        Cycle_a_00260_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A2 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A3 {
+        Cycle_a_00260_A1 a1_0;
+        Cycle_a_00260_A2 a2_0;
+        Cycle_a_00260_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A5 {
+        Cycle_a_00260_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00260_A6 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00260_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00270B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00270_A1 a1_main = new Cycle_a_00270_A1("a1_main");
+        Cycle_a_00270_A6 a6_main = new Cycle_a_00270_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00270_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00270_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00270_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1240)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00270_A1 {
+        Cycle_a_00270_A2 a2_0;
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A2 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A3 {
+        Cycle_a_00270_A1 a1_0;
+        Cycle_a_00270_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A5 {
+        Cycle_a_00270_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00270_A6 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00270_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00280B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1443)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00280_A1 {
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A2 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A3 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A5 {
+        Cycle_a_00280_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A6 {
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00290B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00290_A1 a1_main = new Cycle_a_00290_A1("a1_main");
+        Cycle_a_00290_A5 a5_main = new Cycle_a_00290_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00290_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00290_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00290_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00290_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a2_0 = a1_main.a2_0;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1447)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00290_A1 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A2 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A3 {
+        Cycle_a_00290_A1 a1_0;
+        Cycle_a_00290_A4 a4_0;
+        Cycle_a_00290_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A4 {
+        Cycle_a_00290_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A5 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00290_A6 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00290_A6(String strObjectName) {
+            a2_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00300B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00300_A1 a1_main = new Cycle_a_00300_A1("a1_main");
+        Cycle_a_00300_A5 a5_main = new Cycle_a_00300_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00300_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00300_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00300_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a6_0 = new Cycle_a_00300_A6("a6_0");
+        a5_main.a3_0.a4_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a5_0 = a5_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1448)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00300_A1 {
+        Cycle_a_00300_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A2 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A3 {
+        Cycle_a_00300_A1 a1_0;
+        Cycle_a_00300_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A4 {
+        Cycle_a_00300_A5 a5_0;
+        Cycle_a_00300_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A4(String strObjectName) {
+            a5_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A5 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00300_A6 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00300_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00310B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00310_A1 a1_main = new Cycle_a_00310_A1("a1_main");
+        Cycle_a_00310_A4 a4_main = new Cycle_a_00310_A4("a4_main");
+        Cycle_a_00310_A6 a6_main = new Cycle_a_00310_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00310_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00310_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00310_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a4_0 = a4_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a4_main.a6_0 = a6_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1552)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00310_A1 {
+        Cycle_a_00310_A2 a2_0;
+        Cycle_a_00310_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A2 {
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A3 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A4 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A4(String strObjectName) {
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A5 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00310_A6 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00310_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00320B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00320_A1 a1_main = new Cycle_a_00320_A1("a1_main");
+        Cycle_a_00320_A4 a4_main = new Cycle_a_00320_A4("a4_main");
+        Cycle_a_00320_A6 a6_main = new Cycle_a_00320_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00320_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00320_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00320_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a6_main.a4_0 = a4_main;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1551)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00320_A1 {
+        Cycle_a_00320_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A2 {
+        Cycle_a_00320_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A3 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A4 {
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A5 {
+        Cycle_a_00320_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00320_A6 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A3 a3_0;
+        Cycle_a_00320_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00320_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00330B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00330_A1 a1_main = new Cycle_a_00330_A1("a1_main");
+        Cycle_a_00330_A4 a4_main = new Cycle_a_00330_A4("a4_main");
+        Cycle_a_00330_A6 a6_main = new Cycle_a_00330_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00330_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00330_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00330_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00330_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00330_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2080)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00330_A1 {
+        Cycle_a_00330_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A2 {
+        Cycle_a_00330_A3 a3_0;
+        Cycle_a_00330_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A3 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A4 {
+        Cycle_a_00330_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A5 {
+        Cycle_a_00330_A6 a6_0;
+        Cycle_a_00330_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A6 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A7 {
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00330_A8 {
+        Cycle_a_00330_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00330_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00340B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00340_A1 a1_main = new Cycle_a_00340_A1("a1_main");
+        Cycle_a_00340_A4 a4_main = new Cycle_a_00340_A4("a4_main");
+        Cycle_a_00340_A6 a6_main = new Cycle_a_00340_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00340_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00340_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00340_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a8_0 = new Cycle_a_00340_A8("a8_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0 = new Cycle_a_00340_A7("a7_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a8_0.add();
+        a1_main.a2_0.a3_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a8_0.a7_0.sum + a6_main.a3_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00340_A1 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A2 {
+        Cycle_a_00340_A3 a3_0;
+        Cycle_a_00340_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A3 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A5 a5_0;
+        Cycle_a_00340_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a8_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A4 {
+        Cycle_a_00340_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A5 {
+        Cycle_a_00340_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A6 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A7 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00340_A8 {
+        Cycle_a_00340_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00340_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00350B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00350_A1 a1_main = new Cycle_a_00350_A1("a1_main");
+        Cycle_a_00350_A4 a4_main = new Cycle_a_00350_A4("a4_main");
+        Cycle_a_00350_A6 a6_main = new Cycle_a_00350_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00350_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00350_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00350_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00350_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00350_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00350_A1 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A2 {
+        Cycle_a_00350_A3 a3_0;
+        Cycle_a_00350_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A3 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A4 {
+        Cycle_a_00350_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A5 {
+        Cycle_a_00350_A6 a6_0;
+        Cycle_a_00350_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A6 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A7 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00350_A8 {
+        Cycle_a_00350_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00350_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00360B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00360_A1 a1_main = new Cycle_a_00360_A1("a1_main");
+        Cycle_a_00360_A4 a4_main = new Cycle_a_00360_A4("a4_main");
+        Cycle_a_00360_A6 a6_main = new Cycle_a_00360_A6("a6_main");
+        Cycle_a_00360_A9 a9_main = new Cycle_a_00360_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00360_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00360_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00360_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00360_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00360_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0.a9_0 = a9_main;
+        a9_main.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2399)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00360_A1 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A2 {
+        Cycle_a_00360_A3 a3_0;
+        Cycle_a_00360_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A3 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A4 {
+        Cycle_a_00360_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A5 {
+        Cycle_a_00360_A6 a6_0;
+        Cycle_a_00360_A8 a8_0;
+        Cycle_a_00360_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a9_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A6 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A7 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A8 {
+        Cycle_a_00360_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00360_A9 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00360_A9(String strObjectName) {
+            a2_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00370B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2623)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00370_A1 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A2 {
+        Cycle_a_00370_A3 a3_0;
+        Cycle_a_00370_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A3 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A5 a5_0;
+        Cycle_a_00370_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A4 {
+        Cycle_a_00370_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A5 {
+        Cycle_a_00370_A6 a6_0;
+        Cycle_a_00370_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A6 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A7 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A8 {
+        Cycle_a_00370_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A9 {
+        Cycle_a_00370_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A10 {
+        Cycle_a_00370_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00380B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00380_A1 a1_main = new Cycle_a_00380_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00380_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00380_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00380_A1 {
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00380_A2 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00380_A3 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00380_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00390B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00390_A1 a1_main = new Cycle_a_00390_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00390_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00390_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 918)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00390_A1 {
+        Cycle_a_00390_A2 a2_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00390_A2 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00390_A3 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00390_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00400B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00400_A1 a1_main = new Cycle_a_00400_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00400_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00400_A3("a3_0");
+        a1_main.a4_0 = new Cycle_a_00400_A4("a4_0");
+        a1_main.a4_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00400_A1 {
+        Cycle_a_00400_A2 a2_0;
+        Cycle_a_00400_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A2 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A3 {
+        Cycle_a_00400_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00400_A4 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00400_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00410B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00410_A1 a1_main = new Cycle_a_00410_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00410_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00410_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00410_A4("a4_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 921)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00410_A1 {
+        Cycle_a_00410_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A2 {
+        Cycle_a_00410_A3 a3_0;
+        Cycle_a_00410_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A3 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00410_A4 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00410_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00420B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00420_A1 a1_main = new Cycle_a_00420_A1("a1_main");
+//		 Cycle_a_00420_A4 a4_main = new Cycle_a_00420_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00420_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00420_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00420_A4("a4_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00420_A1 {
+        Cycle_a_00420_A2 a2_0;
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A2 {
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A3 {
+        Cycle_a_00420_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00420_A4 {
+        Cycle_a_00420_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00420_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00430B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00430_A1 a1_main = new Cycle_a_00430_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00430_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00430_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00430_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1124)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00430_A1 {
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A2 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A3 a3_0;
+        Cycle_a_00430_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A3 {
+        Cycle_a_00430_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00430_A4 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00430_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00440B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00440_A1 a1_main = new Cycle_a_00440_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00440_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00440_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00440_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1023)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00440_A1 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A2 {
+        Cycle_a_00440_A1 a1_0;
+        Cycle_a_00440_A3 a3_0;
+        Cycle_a_00440_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A3 {
+        Cycle_a_00440_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00440_A4 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00440_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00450B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00450_A1 a1_main = new Cycle_a_00450_A1("a1_main");
+        Cycle_a_00450_A6 a6_main = new Cycle_a_00450_A6("a6_main");
+        Cycle_a_00450_A7 a7_main = new Cycle_a_00450_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00450_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00450_A3("a3_0");
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00450_A5("a5_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = a7_main;
+        a7_main.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a6_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+
+        int result = a1_main.sum + a6_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1453)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00450_A1 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A2 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A3 {
+        Cycle_a_00450_A1 a1_0;
+        Cycle_a_00450_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A5 {
+        Cycle_a_00450_A6 a6_0;
+        Cycle_a_00450_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A5(String strObjectName) {
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A6 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00450_A7 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00450_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00460B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00460_A1 a1_main = new Cycle_a_00460_A1("a1_main");
+        Cycle_a_00460_A5 a5_main = new Cycle_a_00460_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00460_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00460_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00460_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00460_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00460_A1 {
+        Cycle_a_00460_A2 a2_0;
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A2 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A3 {
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A4 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A5 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00460_A6 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00460_A6(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00470B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00470_A1 a1_main = new Cycle_a_00470_A1("a1_main");
+        Cycle_a_00470_A5 a5_main = new Cycle_a_00470_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00470_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00470_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00470_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00470_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a1_0 = a1_main;
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1446)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00470_A1 {
+        Cycle_a_00470_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A2 {
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A3 {
+        Cycle_a_00470_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A4 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A5 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A5(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00470_A6 {
+        Cycle_a_00470_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00470_A6(String strObjectName) {
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00480B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00480_A1 a1_main = new Cycle_a_00480_A1("a1_main");
+        Cycle_a_00480_A5 a5_main = new Cycle_a_00480_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00480_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00480_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00480_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00480_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+
+
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a5_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a1_0.add();
+
+        a5_main.a3_0.add();
+        a5_main.a3_0.a4_0.add();
+
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a5_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum);
+
+
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a5_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a1_main.a2_0.a3_0.a4_0.sum+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00480_A1 {
+        Cycle_a_00480_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A2 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A3 {
+        Cycle_a_00480_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A4 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A5 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00480_A6 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A4 a4_0;
+        Cycle_a_00480_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00480_A6(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a5_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00490B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00490_A1 a1_main = new Cycle_a_00490_A1("a1_main");
+        Cycle_a_00490_A4 a4_main = new Cycle_a_00490_A4("a4_main");
+        Cycle_a_00490_A7 a7_main = new Cycle_a_00490_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00490_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a5_0 = new Cycle_a_00490_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00490_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+//		 a4_main.a5_0.a6_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a4_main.a5_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0.a6_0.a3_0.a1_0 = a1_main;
+
+        a7_main.a9_0 = new Cycle_a_00490_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00490_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0.a8_0.a5_0 = a4_main.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a6_0.a3_0.add();
+        a4_main.a5_0.a6_0.a3_0.a1_0.add();
+
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        a7_main.a9_0.a8_0.a5_0.add();
+//
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a4_main.sum);
+//		 System.out.println("a7_main.sum:"+a7_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a4_main.a5_0.sum:"+a4_main.a5_0.sum);
+//		 System.out.println("a4_main.a5_0.a6_0.sum:"+a4_main.a5_0.a6_0.sum);
+//		 System.out.println("a7_main.a9_0.sum:"+a7_main.a9_0.sum);
+//		 System.out.println("a7_main.a9_0.a8_0.sum:"+a7_main.a9_0.a8_0.sum);
+
+
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a4_main.sum+a7_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a4_main.a5_0.sum+a4_main.a5_0.a6_0.sum+a7_main.a9_0.sum+a7_main.a9_0.a8_0.sum);
+
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2098)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00490_A1 {
+        Cycle_a_00490_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A2 {
+        Cycle_a_00490_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A3 {
+        Cycle_a_00490_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A4 {
+        Cycle_a_00490_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A5 {
+        Cycle_a_00490_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A6 {
+        Cycle_a_00490_A3 a3_0;
+        Cycle_a_00490_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A6(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A7 {
+        Cycle_a_00490_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A8 {
+        Cycle_a_00490_A5 a5_0;
+        Cycle_a_00490_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A8(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00490_A9 {
+        Cycle_a_00490_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00490_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_00500B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00500_A1 a1_main = new Cycle_a_00500_A1("a1_main");
+        Cycle_a_00500_A4 a4_main = new Cycle_a_00500_A4("a4_main");
+        Cycle_a_00500_A7 a7_main = new Cycle_a_00500_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00500_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00500_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+
+        a4_main.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00500_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00500_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+
+        a4_main.a5_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a4_main.a5_0.a8_0.a7_0 = a7_main;
+
+        a7_main.a9_0 = new Cycle_a_00500_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a8_0.add();
+        a4_main.a5_0.a8_0.a7_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2099)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00500_A1 {
+        Cycle_a_00500_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A2 {
+        Cycle_a_00500_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A3 {
+        Cycle_a_00500_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A4 {
+        Cycle_a_00500_A1 a1_0;
+        Cycle_a_00500_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A4(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A5 {
+        Cycle_a_00500_A6 a6_0;
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A6 {
+        Cycle_a_00500_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A6(String strObjectName) {
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A7 {
+        Cycle_a_00500_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A8 {
+        Cycle_a_00500_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00500_A9 {
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00500_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+public class Cycle_am_00510 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00180B A1_Cycle_am_00180 = new ThreadRc_Cycle_am_00180B();
+        ThreadRc_Cycle_am_00180B A2_Cycle_am_00180 = new ThreadRc_Cycle_am_00180B();
+        ThreadRc_Cycle_am_00190B A1_Cycle_am_00190 = new ThreadRc_Cycle_am_00190B();
+        ThreadRc_Cycle_am_00190B A2_Cycle_am_00190 = new ThreadRc_Cycle_am_00190B();
+        ThreadRc_Cycle_am_00200B A1_Cycle_am_00200 = new ThreadRc_Cycle_am_00200B();
+        ThreadRc_Cycle_am_00200B A2_Cycle_am_00200 = new ThreadRc_Cycle_am_00200B();
+        ThreadRc_Cycle_am_00210B A1_Cycle_am_00210 = new ThreadRc_Cycle_am_00210B();
+        ThreadRc_Cycle_am_00210B A2_Cycle_am_00210 = new ThreadRc_Cycle_am_00210B();
+        ThreadRc_Cycle_am_00220B A1_Cycle_am_00220 = new ThreadRc_Cycle_am_00220B();
+        ThreadRc_Cycle_am_00220B A2_Cycle_am_00220 = new ThreadRc_Cycle_am_00220B();
+        ThreadRc_Cycle_am_00230B A1_Cycle_am_00230 = new ThreadRc_Cycle_am_00230B();
+        ThreadRc_Cycle_am_00230B A2_Cycle_am_00230 = new ThreadRc_Cycle_am_00230B();
+        ThreadRc_Cycle_am_00240B A1_Cycle_am_00240 = new ThreadRc_Cycle_am_00240B();
+        ThreadRc_Cycle_am_00240B A2_Cycle_am_00240 = new ThreadRc_Cycle_am_00240B();
+        ThreadRc_Cycle_am_00250B A1_Cycle_am_00250 = new ThreadRc_Cycle_am_00250B();
+        ThreadRc_Cycle_am_00250B A2_Cycle_am_00250 = new ThreadRc_Cycle_am_00250B();
+        ThreadRc_Cycle_am_00260B A1_Cycle_am_00260 = new ThreadRc_Cycle_am_00260B();
+        ThreadRc_Cycle_am_00260B A2_Cycle_am_00260 = new ThreadRc_Cycle_am_00260B();
+        ThreadRc_Cycle_am_00270B A1_Cycle_am_00270 = new ThreadRc_Cycle_am_00270B();
+        ThreadRc_Cycle_am_00270B A2_Cycle_am_00270 = new ThreadRc_Cycle_am_00270B();
+        ThreadRc_Cycle_am_00280B A1_Cycle_am_00280 = new ThreadRc_Cycle_am_00280B();
+        ThreadRc_Cycle_am_00280B A2_Cycle_am_00280 = new ThreadRc_Cycle_am_00280B();
+        ThreadRc_Cycle_am_00290B A1_Cycle_am_00290 = new ThreadRc_Cycle_am_00290B();
+        ThreadRc_Cycle_am_00290B A2_Cycle_am_00290 = new ThreadRc_Cycle_am_00290B();
+        ThreadRc_Cycle_am_00300B A1_Cycle_am_00300 = new ThreadRc_Cycle_am_00300B();
+        ThreadRc_Cycle_am_00300B A2_Cycle_am_00300 = new ThreadRc_Cycle_am_00300B();
+        ThreadRc_Cycle_am_00310B A1_Cycle_am_00310 = new ThreadRc_Cycle_am_00310B();
+        ThreadRc_Cycle_am_00310B A2_Cycle_am_00310 = new ThreadRc_Cycle_am_00310B();
+        ThreadRc_Cycle_am_00320B A1_Cycle_am_00320 = new ThreadRc_Cycle_am_00320B();
+        ThreadRc_Cycle_am_00320B A2_Cycle_am_00320 = new ThreadRc_Cycle_am_00320B();
+        ThreadRc_Cycle_am_00330B A1_Cycle_am_00330 = new ThreadRc_Cycle_am_00330B();
+        ThreadRc_Cycle_am_00330B A2_Cycle_am_00330 = new ThreadRc_Cycle_am_00330B();
+        ThreadRc_Cycle_am_00340B A1_Cycle_am_00340 = new ThreadRc_Cycle_am_00340B();
+        ThreadRc_Cycle_am_00340B A2_Cycle_am_00340 = new ThreadRc_Cycle_am_00340B();
+        ThreadRc_Cycle_am_00350B A1_Cycle_am_00350 = new ThreadRc_Cycle_am_00350B();
+        ThreadRc_Cycle_am_00350B A2_Cycle_am_00350 = new ThreadRc_Cycle_am_00350B();
+        ThreadRc_Cycle_am_00360B A1_Cycle_am_00360 = new ThreadRc_Cycle_am_00360B();
+        ThreadRc_Cycle_am_00360B A2_Cycle_am_00360 = new ThreadRc_Cycle_am_00360B();
+        ThreadRc_Cycle_am_00370B A1_Cycle_am_00370 = new ThreadRc_Cycle_am_00370B();
+        ThreadRc_Cycle_am_00370B A2_Cycle_am_00370 = new ThreadRc_Cycle_am_00370B();
+        ThreadRc_Cycle_am_00380B A1_Cycle_am_00380 = new ThreadRc_Cycle_am_00380B();
+        ThreadRc_Cycle_am_00380B A2_Cycle_am_00380 = new ThreadRc_Cycle_am_00380B();
+        ThreadRc_Cycle_am_00390B A1_Cycle_am_00390 = new ThreadRc_Cycle_am_00390B();
+        ThreadRc_Cycle_am_00390B A2_Cycle_am_00390 = new ThreadRc_Cycle_am_00390B();
+        ThreadRc_Cycle_am_00400B A1_Cycle_am_00400 = new ThreadRc_Cycle_am_00400B();
+        ThreadRc_Cycle_am_00400B A2_Cycle_am_00400 = new ThreadRc_Cycle_am_00400B();
+        ThreadRc_Cycle_am_00410B A1_Cycle_am_00410 = new ThreadRc_Cycle_am_00410B();
+        ThreadRc_Cycle_am_00410B A2_Cycle_am_00410 = new ThreadRc_Cycle_am_00410B();
+        ThreadRc_Cycle_am_00420B A1_Cycle_am_00420 = new ThreadRc_Cycle_am_00420B();
+        ThreadRc_Cycle_am_00420B A2_Cycle_am_00420 = new ThreadRc_Cycle_am_00420B();
+        ThreadRc_Cycle_am_00430B A1_Cycle_am_00430 = new ThreadRc_Cycle_am_00430B();
+        ThreadRc_Cycle_am_00430B A2_Cycle_am_00430 = new ThreadRc_Cycle_am_00430B();
+        ThreadRc_Cycle_am_00440B A1_Cycle_am_00440 = new ThreadRc_Cycle_am_00440B();
+        ThreadRc_Cycle_am_00440B A2_Cycle_am_00440 = new ThreadRc_Cycle_am_00440B();
+        ThreadRc_Cycle_am_00450B A1_Cycle_am_00450 = new ThreadRc_Cycle_am_00450B();
+        ThreadRc_Cycle_am_00450B A2_Cycle_am_00450 = new ThreadRc_Cycle_am_00450B();
+        ThreadRc_Cycle_am_00460B A1_Cycle_am_00460 = new ThreadRc_Cycle_am_00460B();
+        ThreadRc_Cycle_am_00460B A2_Cycle_am_00460 = new ThreadRc_Cycle_am_00460B();
+        ThreadRc_Cycle_am_00470B A1_Cycle_am_00470 = new ThreadRc_Cycle_am_00470B();
+        ThreadRc_Cycle_am_00470B A2_Cycle_am_00470 = new ThreadRc_Cycle_am_00470B();
+        ThreadRc_Cycle_am_00480B A1_Cycle_am_00480 = new ThreadRc_Cycle_am_00480B();
+        ThreadRc_Cycle_am_00480B A2_Cycle_am_00480 = new ThreadRc_Cycle_am_00480B();
+        ThreadRc_Cycle_am_00490B A1_Cycle_am_00490 = new ThreadRc_Cycle_am_00490B();
+        ThreadRc_Cycle_am_00490B A2_Cycle_am_00490 = new ThreadRc_Cycle_am_00490B();
+        ThreadRc_Cycle_am_00500B A1_Cycle_am_00500 = new ThreadRc_Cycle_am_00500B();
+        ThreadRc_Cycle_am_00500B A2_Cycle_am_00500 = new ThreadRc_Cycle_am_00500B();
+        A1_Cycle_am_00180.start();
+        A2_Cycle_am_00180.start();
+        A1_Cycle_am_00190.start();
+        A2_Cycle_am_00190.start();
+        A1_Cycle_am_00200.start();
+        A2_Cycle_am_00200.start();
+        A1_Cycle_am_00210.start();
+        A2_Cycle_am_00210.start();
+        A1_Cycle_am_00220.start();
+        A2_Cycle_am_00220.start();
+        A1_Cycle_am_00230.start();
+        A2_Cycle_am_00230.start();
+        A1_Cycle_am_00240.start();
+        A2_Cycle_am_00240.start();
+        A1_Cycle_am_00250.start();
+        A2_Cycle_am_00250.start();
+        A1_Cycle_am_00260.start();
+        A2_Cycle_am_00260.start();
+        A1_Cycle_am_00270.start();
+        A2_Cycle_am_00270.start();
+        A1_Cycle_am_00280.start();
+        A2_Cycle_am_00280.start();
+        A1_Cycle_am_00290.start();
+        A2_Cycle_am_00290.start();
+        A1_Cycle_am_00300.start();
+        A2_Cycle_am_00300.start();
+        A1_Cycle_am_00310.start();
+        A2_Cycle_am_00310.start();
+        A1_Cycle_am_00320.start();
+        A2_Cycle_am_00320.start();
+        A1_Cycle_am_00330.start();
+        A2_Cycle_am_00330.start();
+        A1_Cycle_am_00340.start();
+        A2_Cycle_am_00340.start();
+        A1_Cycle_am_00350.start();
+        A2_Cycle_am_00350.start();
+        A1_Cycle_am_00360.start();
+        A2_Cycle_am_00360.start();
+        A1_Cycle_am_00370.start();
+        A2_Cycle_am_00370.start();
+        A1_Cycle_am_00380.start();
+        A2_Cycle_am_00380.start();
+        A1_Cycle_am_00390.start();
+        A2_Cycle_am_00390.start();
+        A1_Cycle_am_00400.start();
+        A2_Cycle_am_00400.start();
+        A1_Cycle_am_00410.start();
+        A2_Cycle_am_00410.start();
+        A1_Cycle_am_00420.start();
+        A2_Cycle_am_00420.start();
+        A1_Cycle_am_00430.start();
+        A2_Cycle_am_00430.start();
+        A1_Cycle_am_00440.start();
+        A2_Cycle_am_00440.start();
+        A1_Cycle_am_00450.start();
+        A2_Cycle_am_00450.start();
+        A1_Cycle_am_00460.start();
+        A2_Cycle_am_00460.start();
+        A1_Cycle_am_00470.start();
+        A2_Cycle_am_00470.start();
+        A1_Cycle_am_00480.start();
+        A2_Cycle_am_00480.start();
+        A1_Cycle_am_00490.start();
+        A2_Cycle_am_00490.start();
+        A1_Cycle_am_00500.start();
+        A2_Cycle_am_00500.start();
+        try {
+            A1_Cycle_am_00180.join();
+            A2_Cycle_am_00180.join();
+            A1_Cycle_am_00190.join();
+            A2_Cycle_am_00190.join();
+            A1_Cycle_am_00200.join();
+            A2_Cycle_am_00200.join();
+            A1_Cycle_am_00210.join();
+            A2_Cycle_am_00210.join();
+            A1_Cycle_am_00220.join();
+            A2_Cycle_am_00220.join();
+            A1_Cycle_am_00230.join();
+            A2_Cycle_am_00230.join();
+            A1_Cycle_am_00240.join();
+            A2_Cycle_am_00240.join();
+            A1_Cycle_am_00250.join();
+            A2_Cycle_am_00250.join();
+            A1_Cycle_am_00260.join();
+            A2_Cycle_am_00260.join();
+            A1_Cycle_am_00270.join();
+            A2_Cycle_am_00270.join();
+            A1_Cycle_am_00280.join();
+            A2_Cycle_am_00280.join();
+            A1_Cycle_am_00290.join();
+            A2_Cycle_am_00290.join();
+            A1_Cycle_am_00300.join();
+            A2_Cycle_am_00300.join();
+            A1_Cycle_am_00310.join();
+            A2_Cycle_am_00310.join();
+            A1_Cycle_am_00320.join();
+            A2_Cycle_am_00320.join();
+            A1_Cycle_am_00330.join();
+            A2_Cycle_am_00330.join();
+            A1_Cycle_am_00340.join();
+            A2_Cycle_am_00340.join();
+            A1_Cycle_am_00350.join();
+            A2_Cycle_am_00350.join();
+            A1_Cycle_am_00360.join();
+            A2_Cycle_am_00360.join();
+            A1_Cycle_am_00370.join();
+            A2_Cycle_am_00370.join();
+            A1_Cycle_am_00380.join();
+            A2_Cycle_am_00380.join();
+            A1_Cycle_am_00390.join();
+            A2_Cycle_am_00390.join();
+            A1_Cycle_am_00400.join();
+            A2_Cycle_am_00400.join();
+            A1_Cycle_am_00410.join();
+            A2_Cycle_am_00410.join();
+            A1_Cycle_am_00420.join();
+            A2_Cycle_am_00420.join();
+            A1_Cycle_am_00430.join();
+            A2_Cycle_am_00430.join();
+            A1_Cycle_am_00440.join();
+            A2_Cycle_am_00440.join();
+            A1_Cycle_am_00450.join();
+            A2_Cycle_am_00450.join();
+            A1_Cycle_am_00460.join();
+            A2_Cycle_am_00460.join();
+            A1_Cycle_am_00470.join();
+            A2_Cycle_am_00470.join();
+            A1_Cycle_am_00480.join();
+            A2_Cycle_am_00480.join();
+            A1_Cycle_am_00490.join();
+            A2_Cycle_am_00490.join();
+            A1_Cycle_am_00500.join();
+            A2_Cycle_am_00500.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00180.check() && A2_Cycle_am_00180.check() && A1_Cycle_am_00190.check() && A2_Cycle_am_00190.check() && A1_Cycle_am_00200.check() && A2_Cycle_am_00200.check() && A1_Cycle_am_00210.check() && A2_Cycle_am_00210.check() && A1_Cycle_am_00220.check() && A2_Cycle_am_00220.check() && A1_Cycle_am_00230.check() && A2_Cycle_am_00230.check() && A1_Cycle_am_00240.check() && A2_Cycle_am_00240.check() && A1_Cycle_am_00250.check() && A2_Cycle_am_00250.check() && A1_Cycle_am_00260.check() && A2_Cycle_am_00260.check() && A1_Cycle_am_00270.check() && A2_Cycle_am_00270.check() && A1_Cycle_am_00280.check() && A2_Cycle_am_00280.check() && A1_Cycle_am_00290.check() && A2_Cycle_am_00290.check() && A1_Cycle_am_00300.check() && A2_Cycle_am_00300.check() && A1_Cycle_am_00310.check() && A2_Cycle_am_00310.check() && A1_Cycle_am_00320.check() && A2_Cycle_am_00320.check() && A1_Cycle_am_00330.check() && A2_Cycle_am_00330.check() && A1_Cycle_am_00340.check() && A2_Cycle_am_00340.check() && A1_Cycle_am_00350.check() && A2_Cycle_am_00350.check() && A1_Cycle_am_00360.check() && A2_Cycle_am_00360.check() && A1_Cycle_am_00370.check() && A2_Cycle_am_00370.check() && A1_Cycle_am_00380.check() && A2_Cycle_am_00380.check() && A1_Cycle_am_00390.check() && A2_Cycle_am_00390.check() && A1_Cycle_am_00400.check() && A2_Cycle_am_00400.check() && A1_Cycle_am_00410.check() && A2_Cycle_am_00410.check() && A1_Cycle_am_00420.check() && A2_Cycle_am_00420.check() && A1_Cycle_am_00430.check() && A2_Cycle_am_00430.check() && A1_Cycle_am_00440.check() && A2_Cycle_am_00440.check() && A1_Cycle_am_00450.check() && A2_Cycle_am_00450.check() && A1_Cycle_am_00460.check() && A2_Cycle_am_00460.check() && A1_Cycle_am_00470.check() && A2_Cycle_am_00470.check() && A1_Cycle_am_00480.check() && A2_Cycle_am_00480.check() && A1_Cycle_am_00490.check() && A2_Cycle_am_00490.check() && A1_Cycle_am_00500.check() && A2_Cycle_am_00500.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/Cycle_am_10010.java b/test/testsuite/ouroboros/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/Cycle_am_10010.java
new file mode 100755
index 0000000000000000000000000000000000000000..af1e8df3cd457c5befa2e047335f7ec1e708d62d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/Cycle_am_10010.java
@@ -0,0 +1,422 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_10010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_10010 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_10010.java
+ *- @ExecuteClass: Cycle_am_10010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_am_10010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_10010_A1 a1_main = new Cycle_a_10010_A1("a1_main");
+        Cycle_a_10010_A4 a4_main = new Cycle_a_10010_A4("a4_main");
+        Cycle_a_10010_A6 a6_main = new Cycle_a_10010_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_10010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10010_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10010_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_10010_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        Cycle_a_10010_2A1 a1_2main = new Cycle_a_10010_2A1("a1_2main");
+        Cycle_a_10010_2A4 a4_2main = new Cycle_a_10010_2A4("a4_2main");
+        Cycle_a_10010_2A6 a6_2main = new Cycle_a_10010_2A6("a6_2main");
+        a1_2main.a2_0 = new Cycle_a_10010_2A2("a2_0");
+        a1_2main.a2_0.a3_0 = new Cycle_a_10010_2A3("a3_0");
+        a1_2main.a2_0.a4_0 = a4_2main;
+        a4_2main.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a5_0 = new Cycle_a_10010_2A5("a5_0");
+        a1_2main.a2_0.a3_0.a5_0.a6_0 = a6_2main;
+        a1_2main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10010_2A8("a8_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10010_2A7("a7_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_2main.a2_0.a3_0;
+        a6_2main.a1_0 = a1_2main;
+        a6_2main.a3_0 = a1_2main.a2_0.a3_0;
+
+
+        a1_2main.add();
+        a4_2main.add();
+        a6_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        a1_2main.a2_0.a3_0.a5_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result2 = a1_2main.sum + a4_2main.sum + a6_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum + a1_2main.a2_0.a3_0.a5_0.sum + a6_2main.a3_0.a5_0.a8_0.a7_0.sum + a6_2main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+
+        if (result == 3852)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_10010_A1 {
+        Cycle_a_10010_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A2 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A3 {
+        Cycle_a_10010_A1 a1_0;
+        Cycle_a_10010_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A4 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A5 {
+        Cycle_a_10010_A4 a4_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A6 {
+        Cycle_a_10010_A5 a5_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Cycle_a_10010_2A1 {
+        Cycle_a_10010_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A2 {
+        Cycle_a_10010_2A3 a3_0;
+        Cycle_a_10010_2A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A3 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A4 {
+        Cycle_a_10010_2A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A5 {
+        Cycle_a_10010_2A6 a6_0;
+        Cycle_a_10010_2A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A6 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A7 {
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A8 {
+        Cycle_a_10010_2A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_10010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_10010 A1_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A2_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A3_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A4_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A5_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A6_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+
+        A1_Cycle_am_10010.start();
+        A2_Cycle_am_10010.start();
+        A3_Cycle_am_10010.start();
+        A4_Cycle_am_10010.start();
+        A5_Cycle_am_10010.start();
+        A6_Cycle_am_10010.start();
+
+        try {
+            A1_Cycle_am_10010.join();
+            A2_Cycle_am_10010.join();
+            A3_Cycle_am_10010.join();
+            A4_Cycle_am_10010.join();
+            A5_Cycle_am_10010.join();
+            A6_Cycle_am_10010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_10010.check() && A2_Cycle_am_10010.check() && A3_Cycle_am_10010.check() && A4_Cycle_am_10010.check() && A5_Cycle_am_10010.check() && A6_Cycle_am_10010.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/Cycle_am_10020.java b/test/testsuite/ouroboros/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/Cycle_am_10020.java
new file mode 100755
index 0000000000000000000000000000000000000000..6baf25d47074fcdbe12c03bb446410f5933072e8
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/Cycle_am_10020.java
@@ -0,0 +1,382 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_10020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_10020 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_10020.java
+ *- @ExecuteClass: Cycle_am_10020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_am_10020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_10020_A1 a1_main = new Cycle_a_10020_A1("a1_main");
+        Cycle_a_10020_A4 a4_main = new Cycle_a_10020_A4("a4_main");
+        Cycle_a_10020_A6 a6_main = new Cycle_a_10020_A6("a6_main");
+        Cycle_a_10020_A9 a9_main = new Cycle_a_10020_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_10020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10020_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10020_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_10020_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10020_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10020_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10020_2A1 a1_2main = new Cycle_a_10020_2A1("a1_2main");
+        a1_2main.a2_0 = new Cycle_a_10020_2A2("a2_0");
+        a1_2main.a2_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0 = new Cycle_a_10020_2A3("a3_0");
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a2_0 = a1_2main.a2_0;
+
+
+        a1_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+
+        int result2 = a1_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+
+        if (result == 3438)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_10020_A1 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A2 {
+        Cycle_a_10020_A3 a3_0;
+        Cycle_a_10020_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A3 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A5 a5_0;
+        Cycle_a_10020_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A4 {
+        Cycle_a_10020_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A5 {
+        Cycle_a_10020_A6 a6_0;
+        Cycle_a_10020_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A6 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A7 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A8 {
+        Cycle_a_10020_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A9 {
+        Cycle_a_10020_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A10 {
+        Cycle_a_10020_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A1 {
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A2 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A3 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_am_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_10020 A1_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A2_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A3_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A4_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A5_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A6_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+
+        A1_Cycle_am_10020.start();
+        A2_Cycle_am_10020.start();
+        A3_Cycle_am_10020.start();
+        A4_Cycle_am_10020.start();
+        A5_Cycle_am_10020.start();
+        A6_Cycle_am_10020.start();
+
+        try {
+            A1_Cycle_am_10020.join();
+            A2_Cycle_am_10020.join();
+            A3_Cycle_am_10020.join();
+            A4_Cycle_am_10020.join();
+            A5_Cycle_am_10020.join();
+            A6_Cycle_am_10020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_10020.check() && A2_Cycle_am_10020.check() && A3_Cycle_am_10020.check() && A4_Cycle_am_10020.check() && A5_Cycle_am_10020.check() && A6_Cycle_am_10020.check())
+           System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/Cycle_am_10030.java b/test/testsuite/ouroboros/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/Cycle_am_10030.java
new file mode 100755
index 0000000000000000000000000000000000000000..e153de1fe5d7a3da52070c96272beadaaf54cf4f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/Cycle_am_10030.java
@@ -0,0 +1,763 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_am_10030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_a_10030 in RC测试-Cycle-01 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_am_10030.java
+ *- @ExecuteClass: Cycle_am_10030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_am_10020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_10020_A1 a1_main = new Cycle_a_10020_A1("a1_main");
+        Cycle_a_10020_A4 a4_main = new Cycle_a_10020_A4("a4_main");
+        Cycle_a_10020_A6 a6_main = new Cycle_a_10020_A6("a6_main");
+        Cycle_a_10020_A9 a9_main = new Cycle_a_10020_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_10020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10020_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10020_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_10020_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10020_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10020_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10020_2A1 a1_2main = new Cycle_a_10020_2A1("a1_2main");
+        a1_2main.a2_0 = new Cycle_a_10020_2A2("a2_0");
+        a1_2main.a2_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0 = new Cycle_a_10020_2A3("a3_0");
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a2_0 = a1_2main.a2_0;
+
+
+        a1_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+
+        int result2 = a1_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+
+        if (result == 3438)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_10020_A1 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A2 {
+        Cycle_a_10020_A3 a3_0;
+        Cycle_a_10020_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A3 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A5 a5_0;
+        Cycle_a_10020_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A4 {
+        Cycle_a_10020_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A5 {
+        Cycle_a_10020_A6 a6_0;
+        Cycle_a_10020_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A6 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A7 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A8 {
+        Cycle_a_10020_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A9 {
+        Cycle_a_10020_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_10020_A10 {
+        Cycle_a_10020_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A1 {
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A2 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10020_2A3 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10020_2A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_am_10010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_10010_A1 a1_main = new Cycle_a_10010_A1("a1_main");
+        Cycle_a_10010_A4 a4_main = new Cycle_a_10010_A4("a4_main");
+        Cycle_a_10010_A6 a6_main = new Cycle_a_10010_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_10010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10010_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10010_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_10010_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        Cycle_a_10010_2A1 a1_2main = new Cycle_a_10010_2A1("a1_2main");
+        Cycle_a_10010_2A4 a4_2main = new Cycle_a_10010_2A4("a4_2main");
+        Cycle_a_10010_2A6 a6_2main = new Cycle_a_10010_2A6("a6_2main");
+        a1_2main.a2_0 = new Cycle_a_10010_2A2("a2_0");
+        a1_2main.a2_0.a3_0 = new Cycle_a_10010_2A3("a3_0");
+        a1_2main.a2_0.a4_0 = a4_2main;
+        a4_2main.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a5_0 = new Cycle_a_10010_2A5("a5_0");
+        a1_2main.a2_0.a3_0.a5_0.a6_0 = a6_2main;
+        a1_2main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10010_2A8("a8_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10010_2A7("a7_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_2main.a2_0.a3_0;
+        a6_2main.a1_0 = a1_2main;
+        a6_2main.a3_0 = a1_2main.a2_0.a3_0;
+
+
+        a1_2main.add();
+        a4_2main.add();
+        a6_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        a1_2main.a2_0.a3_0.a5_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result2 = a1_2main.sum + a4_2main.sum + a6_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum + a1_2main.a2_0.a3_0.a5_0.sum + a6_2main.a3_0.a5_0.a8_0.a7_0.sum + a6_2main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+
+        if (result == 3852)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_10010_A1 {
+        Cycle_a_10010_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A2 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A3 {
+        Cycle_a_10010_A1 a1_0;
+        Cycle_a_10010_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A4 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A5 {
+        Cycle_a_10010_A4 a4_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A6 {
+        Cycle_a_10010_A5 a5_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_10010_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Cycle_a_10010_2A1 {
+        Cycle_a_10010_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A2 {
+        Cycle_a_10010_2A3 a3_0;
+        Cycle_a_10010_2A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A3 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A4 {
+        Cycle_a_10010_2A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A5 {
+        Cycle_a_10010_2A6 a6_0;
+        Cycle_a_10010_2A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A6 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A7 {
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_10010_2A8 {
+        Cycle_a_10010_2A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_10010_2A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+
+public class Cycle_am_10030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_10010B A1_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A2_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A3_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A4_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A5_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A6_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10020B A1_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A2_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A3_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A4_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A5_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A6_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        A1_Cycle_am_10010.start();
+        A2_Cycle_am_10010.start();
+        A3_Cycle_am_10010.start();
+        A4_Cycle_am_10010.start();
+        A5_Cycle_am_10010.start();
+        A6_Cycle_am_10010.start();
+        A1_Cycle_am_10020.start();
+        A2_Cycle_am_10020.start();
+        A3_Cycle_am_10020.start();
+        A4_Cycle_am_10020.start();
+        A5_Cycle_am_10020.start();
+        A6_Cycle_am_10020.start();
+
+        try {
+            A1_Cycle_am_10010.join();
+            A2_Cycle_am_10010.join();
+            A3_Cycle_am_10010.join();
+            A4_Cycle_am_10010.join();
+            A5_Cycle_am_10010.join();
+            A6_Cycle_am_10010.join();
+            A1_Cycle_am_10020.join();
+            A2_Cycle_am_10020.join();
+            A3_Cycle_am_10020.join();
+            A4_Cycle_am_10020.join();
+            A5_Cycle_am_10020.join();
+            A6_Cycle_am_10020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_10010.check() && A2_Cycle_am_10010.check() && A3_Cycle_am_10010.check() && A4_Cycle_am_10010.check() && A5_Cycle_am_10010.check() && A6_Cycle_am_10010.check() && A1_Cycle_am_10020.check() && A2_Cycle_am_10020.check() && A3_Cycle_am_10020.check() && A4_Cycle_am_10020.check() && A5_Cycle_am_10020.check() && A6_Cycle_am_10020.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/Cycle_Bm_1_00010.java b/test/testsuite/ouroboros/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/Cycle_Bm_1_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..4cecc4a65662669f2438154aa466a5f0a449709c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/Cycle_Bm_1_00010.java
@@ -0,0 +1,94 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00010 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00010.java
+ *- @ExecuteClass: Cycle_Bm_1_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 246)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00010_A1 {
+        Cycle_B_1_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00010_A1() {
+            a1_0 = null;
+            a = 123;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00010 A1_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A2_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A3_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A4_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A5_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A6_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+
+        A1_Cycle_Bm_1_00010.start();
+        A2_Cycle_Bm_1_00010.start();
+        A3_Cycle_Bm_1_00010.start();
+        A4_Cycle_Bm_1_00010.start();
+        A5_Cycle_Bm_1_00010.start();
+        A6_Cycle_Bm_1_00010.start();
+
+        try {
+            A1_Cycle_Bm_1_00010.join();
+            A2_Cycle_Bm_1_00010.join();
+            A3_Cycle_Bm_1_00010.join();
+            A4_Cycle_Bm_1_00010.join();
+            A5_Cycle_Bm_1_00010.join();
+            A6_Cycle_Bm_1_00010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00010.check() && A2_Cycle_Bm_1_00010.check() && A3_Cycle_Bm_1_00010.check() && A4_Cycle_Bm_1_00010.check() && A5_Cycle_Bm_1_00010.check() && A6_Cycle_Bm_1_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/Cycle_Bm_1_00020.java b/test/testsuite/ouroboros/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/Cycle_Bm_1_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..df785164e663cbe8e185a1f1c4fdcf6449995649
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/Cycle_Bm_1_00020.java
@@ -0,0 +1,114 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00020 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00020.java
+ *- @ExecuteClass: Cycle_Bm_1_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_Bm_1_00020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00020_A1 a1_0 = new Cycle_B_1_00020_A1();
+        a1_0.a2_0 = new Cycle_B_1_00020_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 6)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00020_A1 {
+        Cycle_B_1_00020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00020_A2 {
+        Cycle_B_1_00020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00020_A2() {
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00020 A1_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A2_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A3_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A4_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A5_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A6_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+
+        A1_Cycle_Bm_1_00020.start();
+        A2_Cycle_Bm_1_00020.start();
+        A3_Cycle_Bm_1_00020.start();
+        A4_Cycle_Bm_1_00020.start();
+        A5_Cycle_Bm_1_00020.start();
+        A6_Cycle_Bm_1_00020.start();
+
+        try {
+            A1_Cycle_Bm_1_00020.join();
+            A2_Cycle_Bm_1_00020.join();
+            A3_Cycle_Bm_1_00020.join();
+            A4_Cycle_Bm_1_00020.join();
+            A5_Cycle_Bm_1_00020.join();
+            A6_Cycle_Bm_1_00020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00020.check() && A2_Cycle_Bm_1_00020.check() && A3_Cycle_Bm_1_00020.check() && A4_Cycle_Bm_1_00020.check() && A5_Cycle_Bm_1_00020.check() && A6_Cycle_Bm_1_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/Cycle_Bm_1_00030.java b/test/testsuite/ouroboros/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/Cycle_Bm_1_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..ee4ab991e7826b89f3da0883d8ae252e765d4cde
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/Cycle_Bm_1_00030.java
@@ -0,0 +1,131 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00030 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00030.java
+ *- @ExecuteClass: Cycle_Bm_1_00030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_Bm_1_00030 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00030_A1 a1_0 = new Cycle_B_1_00030_A1();
+        a1_0.a2_0 = new Cycle_B_1_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00030_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00030_A1 {
+        Cycle_B_1_00030_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00030_A2 {
+        Cycle_B_1_00030_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00030_A3 {
+        Cycle_B_1_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00030 A1_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A2_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A3_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A4_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A5_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A6_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+
+        A1_Cycle_Bm_1_00030.start();
+        A2_Cycle_Bm_1_00030.start();
+        A3_Cycle_Bm_1_00030.start();
+        A4_Cycle_Bm_1_00030.start();
+        A5_Cycle_Bm_1_00030.start();
+        A6_Cycle_Bm_1_00030.start();
+
+        try {
+            A1_Cycle_Bm_1_00030.join();
+            A2_Cycle_Bm_1_00030.join();
+            A3_Cycle_Bm_1_00030.join();
+            A4_Cycle_Bm_1_00030.join();
+            A5_Cycle_Bm_1_00030.join();
+            A6_Cycle_Bm_1_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00030.check() && A2_Cycle_Bm_1_00030.check() && A3_Cycle_Bm_1_00030.check() && A4_Cycle_Bm_1_00030.check() && A5_Cycle_Bm_1_00030.check() && A6_Cycle_Bm_1_00030.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/Cycle_Bm_1_00040.java b/test/testsuite/ouroboros/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/Cycle_Bm_1_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..dd5272d460f35f88dec2bac43586ff14d2f71d08
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/Cycle_Bm_1_00040.java
@@ -0,0 +1,151 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00040 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00040.java
+ *- @ExecuteClass: Cycle_Bm_1_00040
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_Bm_1_00040 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00040_A1 a1_0 = new Cycle_B_1_00040_A1();
+        a1_0.a2_0 = new Cycle_B_1_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00040_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00040_A4();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00040_A1 {
+        Cycle_B_1_00040_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A2 {
+        Cycle_B_1_00040_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A3 {
+        Cycle_B_1_00040_A1 a1_0;
+        Cycle_B_1_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A4 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00040 A1_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A2_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A3_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A4_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A5_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A6_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+
+        A1_Cycle_Bm_1_00040.start();
+        A2_Cycle_Bm_1_00040.start();
+        A3_Cycle_Bm_1_00040.start();
+        A4_Cycle_Bm_1_00040.start();
+        A5_Cycle_Bm_1_00040.start();
+        A6_Cycle_Bm_1_00040.start();
+
+        try {
+            A1_Cycle_Bm_1_00040.join();
+            A2_Cycle_Bm_1_00040.join();
+            A3_Cycle_Bm_1_00040.join();
+            A4_Cycle_Bm_1_00040.join();
+            A5_Cycle_Bm_1_00040.join();
+            A6_Cycle_Bm_1_00040.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00040.check() && A2_Cycle_Bm_1_00040.check() && A3_Cycle_Bm_1_00040.check() && A4_Cycle_Bm_1_00040.check() && A5_Cycle_Bm_1_00040.check() && A6_Cycle_Bm_1_00040.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/Cycle_Bm_1_00050.java b/test/testsuite/ouroboros/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/Cycle_Bm_1_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..ffe63e5f1a0013c9e32e3eec39c9b35e1cdc81b0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/Cycle_Bm_1_00050.java
@@ -0,0 +1,169 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00050 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00050.java
+ *- @ExecuteClass: Cycle_Bm_1_00050
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_Bm_1_00050 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00050_A1 a1_0 = new Cycle_B_1_00050_A1();
+        a1_0.a2_0 = new Cycle_B_1_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00050_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00050_A4();
+        a1_0.a2_0.a5_0 = new Cycle_B_1_00050_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 34)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00050_A1 {
+        Cycle_B_1_00050_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A2 {
+        Cycle_B_1_00050_A3 a3_0;
+        Cycle_B_1_00050_A4 a4_0;
+        Cycle_B_1_00050_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A3 {
+        Cycle_B_1_00050_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A4 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+
+    class Cycle_B_1_00050_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A5() {
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00050 A1_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A2_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A3_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A4_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A5_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A6_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+
+        A1_Cycle_Bm_1_00050.start();
+        A2_Cycle_Bm_1_00050.start();
+        A3_Cycle_Bm_1_00050.start();
+        A4_Cycle_Bm_1_00050.start();
+        A5_Cycle_Bm_1_00050.start();
+        A6_Cycle_Bm_1_00050.start();
+
+        try {
+            A1_Cycle_Bm_1_00050.join();
+            A2_Cycle_Bm_1_00050.join();
+            A3_Cycle_Bm_1_00050.join();
+            A4_Cycle_Bm_1_00050.join();
+            A5_Cycle_Bm_1_00050.join();
+            A6_Cycle_Bm_1_00050.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00050.check() && A2_Cycle_Bm_1_00050.check() && A3_Cycle_Bm_1_00050.check() && A4_Cycle_Bm_1_00050.check() && A5_Cycle_Bm_1_00050.check() && A6_Cycle_Bm_1_00050.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/Cycle_Bm_1_00060.java b/test/testsuite/ouroboros/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/Cycle_Bm_1_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..36c05fc066b98aa28f9135b4d84e95769b9db750
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/Cycle_Bm_1_00060.java
@@ -0,0 +1,150 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00060 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00060.java
+ *- @ExecuteClass: Cycle_Bm_1_00060
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class ThreadRc_Cycle_Bm_1_00060 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00060_A1 a1_0 = new Cycle_B_1_00060_A1();
+        a1_0.a2_0 = new Cycle_B_1_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00060_A3();
+        Cycle_B_1_00060_A4 a4_0 = new Cycle_B_1_00060_A4();
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00060_A1 {
+        Cycle_B_1_00060_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A2 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A3 {
+        Cycle_B_1_00060_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A4 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00060 A1_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A2_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A3_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A4_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A5_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A6_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+
+        A1_Cycle_Bm_1_00060.start();
+        A2_Cycle_Bm_1_00060.start();
+        A3_Cycle_Bm_1_00060.start();
+        A4_Cycle_Bm_1_00060.start();
+        A5_Cycle_Bm_1_00060.start();
+        A6_Cycle_Bm_1_00060.start();
+
+        try {
+            A1_Cycle_Bm_1_00060.join();
+            A2_Cycle_Bm_1_00060.join();
+            A3_Cycle_Bm_1_00060.join();
+            A4_Cycle_Bm_1_00060.join();
+            A5_Cycle_Bm_1_00060.join();
+            A6_Cycle_Bm_1_00060.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00060.check() && A2_Cycle_Bm_1_00060.check() && A3_Cycle_Bm_1_00060.check() && A4_Cycle_Bm_1_00060.check() && A5_Cycle_Bm_1_00060.check() && A6_Cycle_Bm_1_00060.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/Cycle_Bm_1_00070.java b/test/testsuite/ouroboros/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/Cycle_Bm_1_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..d4de881663ba681792d888b84c93b69e58a57941
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/Cycle_Bm_1_00070.java
@@ -0,0 +1,149 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00070 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00070.java
+ *- @ExecuteClass: Cycle_Bm_1_00070
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00070 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00070_A1 a1_0 = new Cycle_B_1_00070_A1();
+        a1_0.a2_0 = new Cycle_B_1_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00070_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00070_A4();
+
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00070_A1 {
+        Cycle_B_1_00070_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A2 {
+        Cycle_B_1_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A3 {
+        Cycle_B_1_00070_A1 a1_0;
+        Cycle_B_1_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00070 A1_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A2_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A3_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A4_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A5_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A6_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+
+        A1_Cycle_Bm_1_00070.start();
+        A2_Cycle_Bm_1_00070.start();
+        A3_Cycle_Bm_1_00070.start();
+        A4_Cycle_Bm_1_00070.start();
+        A5_Cycle_Bm_1_00070.start();
+        A6_Cycle_Bm_1_00070.start();
+
+        try {
+            A1_Cycle_Bm_1_00070.join();
+            A2_Cycle_Bm_1_00070.join();
+            A3_Cycle_Bm_1_00070.join();
+            A4_Cycle_Bm_1_00070.join();
+            A5_Cycle_Bm_1_00070.join();
+            A6_Cycle_Bm_1_00070.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00070.check() && A2_Cycle_Bm_1_00070.check() && A3_Cycle_Bm_1_00070.check() && A4_Cycle_Bm_1_00070.check() && A5_Cycle_Bm_1_00070.check() && A6_Cycle_Bm_1_00070.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/Cycle_Bm_1_00080.java b/test/testsuite/ouroboros/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/Cycle_Bm_1_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..0354e463f14c6daa8d7e865a7b2a84af7eda0989
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/Cycle_Bm_1_00080.java
@@ -0,0 +1,166 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00080 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00080.java
+ *- @ExecuteClass: Cycle_Bm_1_00080
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00080 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00080_A1 a1_0 = new Cycle_B_1_00080_A1();
+        a1_0.a2_0 = new Cycle_B_1_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00080_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00080_A4();
+        a1_0.a2_0.a3_0.a5_0 = new Cycle_B_1_00080_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 56)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00080_A1 {
+        Cycle_B_1_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00080_A2 {
+        Cycle_B_1_00080_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00080_A3 {
+        Cycle_B_1_00080_A1 a1_0;
+        Cycle_B_1_00080_A4 a4_0;
+        Cycle_B_1_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            a4_0.add();
+            a5_0.add();
+            sum = a + a1_0.a + a4_0.sum + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00080_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+
+    class Cycle_B_1_00080_A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A5() {
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00080 A1_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A2_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A3_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A4_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A5_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A6_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+
+        A1_Cycle_Bm_1_00080.start();
+        A2_Cycle_Bm_1_00080.start();
+        A3_Cycle_Bm_1_00080.start();
+        A4_Cycle_Bm_1_00080.start();
+        A5_Cycle_Bm_1_00080.start();
+        A6_Cycle_Bm_1_00080.start();
+
+        try {
+            A1_Cycle_Bm_1_00080.join();
+            A2_Cycle_Bm_1_00080.join();
+            A3_Cycle_Bm_1_00080.join();
+            A4_Cycle_Bm_1_00080.join();
+            A5_Cycle_Bm_1_00080.join();
+            A6_Cycle_Bm_1_00080.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00080.check() && A2_Cycle_Bm_1_00080.check() && A3_Cycle_Bm_1_00080.check() && A4_Cycle_Bm_1_00080.check() && A5_Cycle_Bm_1_00080.check() && A6_Cycle_Bm_1_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/Cycle_Bm_1_00090.java b/test/testsuite/ouroboros/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/Cycle_Bm_1_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..7a60bf51b1322df897d3ce95942b04f9544be18a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/Cycle_Bm_1_00090.java
@@ -0,0 +1,168 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00090 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00090.java
+ *- @ExecuteClass: Cycle_Bm_1_00090
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00090 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00090_A1 a1_0 = new Cycle_B_1_00090_A1();
+        a1_0.a2_0 = new Cycle_B_1_00090_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00090_A3();
+        Cycle_B_1_00090_A4 a4_0 = new Cycle_B_1_00090_A4();
+        Cycle_B_1_00090_A5 a5_0 = new Cycle_B_1_00090_A5();
+        a4_0.a2_0 = a1_0.a2_0;
+        a5_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 25)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00090_A1 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A2 {
+        Cycle_B_1_00090_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A3 {
+        Cycle_B_1_00090_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A4 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A5 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00090 A1_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A2_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A3_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A4_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A5_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A6_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+
+        A1_Cycle_Bm_1_00090.start();
+        A2_Cycle_Bm_1_00090.start();
+        A3_Cycle_Bm_1_00090.start();
+        A4_Cycle_Bm_1_00090.start();
+        A5_Cycle_Bm_1_00090.start();
+        A6_Cycle_Bm_1_00090.start();
+
+        try {
+            A1_Cycle_Bm_1_00090.join();
+            A2_Cycle_Bm_1_00090.join();
+            A3_Cycle_Bm_1_00090.join();
+            A4_Cycle_Bm_1_00090.join();
+            A5_Cycle_Bm_1_00090.join();
+            A6_Cycle_Bm_1_00090.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00090.check() && A2_Cycle_Bm_1_00090.check() && A3_Cycle_Bm_1_00090.check() && A4_Cycle_Bm_1_00090.check() && A5_Cycle_Bm_1_00090.check() && A6_Cycle_Bm_1_00090.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/Cycle_Bm_1_00100.java b/test/testsuite/ouroboros/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/Cycle_Bm_1_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..717547a963360fa90a1616ce3973cbfbab2ec960
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/Cycle_Bm_1_00100.java
@@ -0,0 +1,170 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00100 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00100.java
+ *- @ExecuteClass: Cycle_Bm_1_00100
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00100 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00100_A1 a1_0 = new Cycle_B_1_00100_A1();
+        a1_0.a2_0 = new Cycle_B_1_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00100_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00100_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_1_00100_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00100_A1 {
+        Cycle_B_1_00100_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A2 {
+        Cycle_B_1_00100_A3 a3_0;
+        Cycle_B_1_00100_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A3 {
+        Cycle_B_1_00100_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A4 {
+
+        int a;
+        int sum;
+        Cycle_B_1_00100_A5 a5_0;
+
+        Cycle_B_1_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00100_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A5() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00100 A1_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A2_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A3_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A4_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A5_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A6_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+
+        A1_Cycle_Bm_1_00100.start();
+        A2_Cycle_Bm_1_00100.start();
+        A3_Cycle_Bm_1_00100.start();
+        A4_Cycle_Bm_1_00100.start();
+        A5_Cycle_Bm_1_00100.start();
+        A6_Cycle_Bm_1_00100.start();
+
+        try {
+            A1_Cycle_Bm_1_00100.join();
+            A2_Cycle_Bm_1_00100.join();
+            A3_Cycle_Bm_1_00100.join();
+            A4_Cycle_Bm_1_00100.join();
+            A5_Cycle_Bm_1_00100.join();
+            A6_Cycle_Bm_1_00100.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00100.check() && A2_Cycle_Bm_1_00100.check() && A3_Cycle_Bm_1_00100.check() && A4_Cycle_Bm_1_00100.check() && A5_Cycle_Bm_1_00100.check() && A6_Cycle_Bm_1_00100.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/Cycle_Bm_1_00110.java b/test/testsuite/ouroboros/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/Cycle_Bm_1_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..580380ee2f0e9bcb8742146f784af294bfa0b125
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/Cycle_Bm_1_00110.java
@@ -0,0 +1,167 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00110 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00110.java
+ *- @ExecuteClass: Cycle_Bm_1_00110
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00110 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00110_A1 a1_0 = new Cycle_B_1_00110_A1();
+        a1_0.a2_0 = new Cycle_B_1_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00110_A3();
+        Cycle_B_1_00110_A5 a5_0 = new Cycle_B_1_00110_A5();
+        a5_0.a4_0 = new Cycle_B_1_00110_A4();
+        a5_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00110_A1 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A2 {
+        Cycle_B_1_00110_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A3 {
+        Cycle_B_1_00110_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A4 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A5 {
+        Cycle_B_1_00110_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00110 A1_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A2_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A3_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A4_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A5_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A6_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+
+        A1_Cycle_Bm_1_00110.start();
+        A2_Cycle_Bm_1_00110.start();
+        A3_Cycle_Bm_1_00110.start();
+        A4_Cycle_Bm_1_00110.start();
+        A5_Cycle_Bm_1_00110.start();
+        A6_Cycle_Bm_1_00110.start();
+
+        try {
+            A1_Cycle_Bm_1_00110.join();
+            A2_Cycle_Bm_1_00110.join();
+            A3_Cycle_Bm_1_00110.join();
+            A4_Cycle_Bm_1_00110.join();
+            A5_Cycle_Bm_1_00110.join();
+            A6_Cycle_Bm_1_00110.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00110.check() && A2_Cycle_Bm_1_00110.check() && A3_Cycle_Bm_1_00110.check() && A4_Cycle_Bm_1_00110.check() && A5_Cycle_Bm_1_00110.check() && A6_Cycle_Bm_1_00110.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/Cycle_Bm_1_00120.java b/test/testsuite/ouroboros/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/Cycle_Bm_1_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..c90ca8c3ce7418b47484c614224af4c0f60a169f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/Cycle_Bm_1_00120.java
@@ -0,0 +1,167 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00120 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00120.java
+ *- @ExecuteClass: Cycle_Bm_1_00120
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00120 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00120_A1 a1_0 = new Cycle_B_1_00120_A1();
+        a1_0.a2_0 = new Cycle_B_1_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00120_A3();
+        Cycle_B_1_00120_A5 a5_0 = new Cycle_B_1_00120_A5();
+        a5_0.a4_0 = new Cycle_B_1_00120_A4();
+        a5_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00120_A1 {
+        Cycle_B_1_00120_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A2 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A3 {
+        Cycle_B_1_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A4 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A5 {
+        Cycle_B_1_00120_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00120 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00120 A1_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A2_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A3_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A4_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A5_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A6_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+
+        A1_Cycle_Bm_1_00120.start();
+        A2_Cycle_Bm_1_00120.start();
+        A3_Cycle_Bm_1_00120.start();
+        A4_Cycle_Bm_1_00120.start();
+        A5_Cycle_Bm_1_00120.start();
+        A6_Cycle_Bm_1_00120.start();
+
+        try {
+            A1_Cycle_Bm_1_00120.join();
+            A2_Cycle_Bm_1_00120.join();
+            A3_Cycle_Bm_1_00120.join();
+            A4_Cycle_Bm_1_00120.join();
+            A5_Cycle_Bm_1_00120.join();
+            A6_Cycle_Bm_1_00120.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00120.check() && A2_Cycle_Bm_1_00120.check() && A3_Cycle_Bm_1_00120.check() && A4_Cycle_Bm_1_00120.check() && A5_Cycle_Bm_1_00120.check() && A6_Cycle_Bm_1_00120.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/Cycle_Bm_1_00130.java b/test/testsuite/ouroboros/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/Cycle_Bm_1_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..370d828f53e19f33434ff75f1996d6299470cd9a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/Cycle_Bm_1_00130.java
@@ -0,0 +1,132 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00130 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00130.java
+ *- @ExecuteClass: Cycle_Bm_1_00130
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00130 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00130_A1 a1_0 = new Cycle_B_1_00130_A1();
+        Cycle_B_1_00130_A2 a2_0 = new Cycle_B_1_00130_A2();
+        Cycle_B_1_00130_A3 a3_0 = new Cycle_B_1_00130_A3();
+        a1_0.a3_0 = a3_0;
+        a2_0.a3_0 = a3_0;
+        a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00130_A1 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A1() {
+            a3_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00130_A2 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00130_A3 {
+        Cycle_B_1_00130_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00130 A1_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A2_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A3_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A4_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A5_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A6_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+
+        A1_Cycle_Bm_1_00130.start();
+        A2_Cycle_Bm_1_00130.start();
+        A3_Cycle_Bm_1_00130.start();
+        A4_Cycle_Bm_1_00130.start();
+        A5_Cycle_Bm_1_00130.start();
+        A6_Cycle_Bm_1_00130.start();
+
+        try {
+            A1_Cycle_Bm_1_00130.join();
+            A2_Cycle_Bm_1_00130.join();
+            A3_Cycle_Bm_1_00130.join();
+            A4_Cycle_Bm_1_00130.join();
+            A5_Cycle_Bm_1_00130.join();
+            A6_Cycle_Bm_1_00130.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00130.check() && A2_Cycle_Bm_1_00130.check() && A3_Cycle_Bm_1_00130.check() && A4_Cycle_Bm_1_00130.check() && A5_Cycle_Bm_1_00130.check() && A6_Cycle_Bm_1_00130.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/Cycle_Bm_1_00140.java b/test/testsuite/ouroboros/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/Cycle_Bm_1_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..b89529a8973488ab89a188c12493d11c229dee15
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/Cycle_Bm_1_00140.java
@@ -0,0 +1,149 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00140 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00140.java
+ *- @ExecuteClass: Cycle_Bm_1_00140
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00140 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00140_A1 a1_0 = new Cycle_B_1_00140_A1();
+        a1_0.a2_0 = new Cycle_B_1_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00140_A3();
+        Cycle_B_1_00140_A4 a4_0 = new Cycle_B_1_00140_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00140_A1 {
+        Cycle_B_1_00140_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A2 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A3 {
+        Cycle_B_1_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A4 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00140 A1_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A2_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A3_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A4_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A5_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A6_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+
+        A1_Cycle_Bm_1_00140.start();
+        A2_Cycle_Bm_1_00140.start();
+        A3_Cycle_Bm_1_00140.start();
+        A4_Cycle_Bm_1_00140.start();
+        A5_Cycle_Bm_1_00140.start();
+        A6_Cycle_Bm_1_00140.start();
+
+        try {
+            A1_Cycle_Bm_1_00140.join();
+            A2_Cycle_Bm_1_00140.join();
+            A3_Cycle_Bm_1_00140.join();
+            A4_Cycle_Bm_1_00140.join();
+            A5_Cycle_Bm_1_00140.join();
+            A6_Cycle_Bm_1_00140.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00140.check() && A2_Cycle_Bm_1_00140.check() && A3_Cycle_Bm_1_00140.check() && A4_Cycle_Bm_1_00140.check() && A5_Cycle_Bm_1_00140.check() && A6_Cycle_Bm_1_00140.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/Cycle_Bm_1_00150.java b/test/testsuite/ouroboros/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/Cycle_Bm_1_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..9374b807288d0537104708feb03169ad571e5755
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/Cycle_Bm_1_00150.java
@@ -0,0 +1,170 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00150 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00150.java
+ *- @ExecuteClass: Cycle_Bm_1_00150
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00150 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00150_A1 a1_0 = new Cycle_B_1_00150_A1();
+        a1_0.a2_0 = new Cycle_B_1_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00150_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_1_00150_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00150_A1 {
+        Cycle_B_1_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A2 {
+        Cycle_B_1_00150_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A3 {
+        Cycle_B_1_00150_A1 a1_0;
+        Cycle_B_1_00150_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A4 {
+
+        int a;
+        int sum;
+        Cycle_B_1_00150_A5 a5_0;
+
+        Cycle_B_1_00150_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00150_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A5() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00150 A1_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A2_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A3_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A4_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A5_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A6_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+
+        A1_Cycle_Bm_1_00150.start();
+        A2_Cycle_Bm_1_00150.start();
+        A3_Cycle_Bm_1_00150.start();
+        A4_Cycle_Bm_1_00150.start();
+        A5_Cycle_Bm_1_00150.start();
+        A6_Cycle_Bm_1_00150.start();
+
+        try {
+            A1_Cycle_Bm_1_00150.join();
+            A2_Cycle_Bm_1_00150.join();
+            A3_Cycle_Bm_1_00150.join();
+            A4_Cycle_Bm_1_00150.join();
+            A5_Cycle_Bm_1_00150.join();
+            A6_Cycle_Bm_1_00150.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00150.check() && A2_Cycle_Bm_1_00150.check() && A3_Cycle_Bm_1_00150.check() && A4_Cycle_Bm_1_00150.check() && A5_Cycle_Bm_1_00150.check() && A6_Cycle_Bm_1_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/Cycle_Bm_1_00160.java b/test/testsuite/ouroboros/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/Cycle_Bm_1_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..78acd8cec07ac758cfad6202e127024de8ac345b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/Cycle_Bm_1_00160.java
@@ -0,0 +1,149 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00160 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00160.java
+ *- @ExecuteClass: Cycle_Bm_1_00160
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00160 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00160_A1 a1_0 = new Cycle_B_1_00160_A1();
+        a1_0.a2_0 = new Cycle_B_1_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00160_A3();
+        Cycle_B_1_00160_A4 a4_0 = new Cycle_B_1_00160_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 17)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00160_A1 {
+        Cycle_B_1_00160_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A2 {
+        Cycle_B_1_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A3 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A4 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00160 A1_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A2_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A3_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A4_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A5_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A6_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+
+        A1_Cycle_Bm_1_00160.start();
+        A2_Cycle_Bm_1_00160.start();
+        A3_Cycle_Bm_1_00160.start();
+        A4_Cycle_Bm_1_00160.start();
+        A5_Cycle_Bm_1_00160.start();
+        A6_Cycle_Bm_1_00160.start();
+
+        try {
+            A1_Cycle_Bm_1_00160.join();
+            A2_Cycle_Bm_1_00160.join();
+            A3_Cycle_Bm_1_00160.join();
+            A4_Cycle_Bm_1_00160.join();
+            A5_Cycle_Bm_1_00160.join();
+            A6_Cycle_Bm_1_00160.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00160.check() && A2_Cycle_Bm_1_00160.check() && A3_Cycle_Bm_1_00160.check() && A4_Cycle_Bm_1_00160.check() && A5_Cycle_Bm_1_00160.check() && A6_Cycle_Bm_1_00160.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/Cycle_Bm_1_00170.java b/test/testsuite/ouroboros/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/Cycle_Bm_1_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f17ff2312f85aa771aac98658520ef197da8c11
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/Cycle_Bm_1_00170.java
@@ -0,0 +1,168 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00170 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00170.java
+ *- @ExecuteClass: Cycle_Bm_1_00170
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00170 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00170_A1 a1_0 = new Cycle_B_1_00170_A1();
+        a1_0.a2_0 = new Cycle_B_1_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00170_A3();
+        Cycle_B_1_00170_A4 a4_0 = new Cycle_B_1_00170_A4();
+        Cycle_B_1_00170_A5 a5_0 = new Cycle_B_1_00170_A5();
+        a5_0.a4_0 = a4_0;
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 26)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00170_A1 {
+        Cycle_B_1_00170_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A2 {
+        Cycle_B_1_00170_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A3 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A4 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A5 {
+        Cycle_B_1_00170_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00170 A1_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A2_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A3_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A4_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A5_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A6_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+
+        A1_Cycle_Bm_1_00170.start();
+        A2_Cycle_Bm_1_00170.start();
+        A3_Cycle_Bm_1_00170.start();
+        A4_Cycle_Bm_1_00170.start();
+        A5_Cycle_Bm_1_00170.start();
+        A6_Cycle_Bm_1_00170.start();
+
+        try {
+            A1_Cycle_Bm_1_00170.join();
+            A2_Cycle_Bm_1_00170.join();
+            A3_Cycle_Bm_1_00170.join();
+            A4_Cycle_Bm_1_00170.join();
+            A5_Cycle_Bm_1_00170.join();
+            A6_Cycle_Bm_1_00170.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00170.check() && A2_Cycle_Bm_1_00170.check() && A3_Cycle_Bm_1_00170.check() && A4_Cycle_Bm_1_00170.check() && A5_Cycle_Bm_1_00170.check() && A6_Cycle_Bm_1_00170.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/Cycle_Bm_1_00180.java b/test/testsuite/ouroboros/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/Cycle_Bm_1_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..c4ce5054b33389e47e779c5cbbc26a545ae68825
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/Cycle_Bm_1_00180.java
@@ -0,0 +1,168 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00180 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00180.java
+ *- @ExecuteClass: Cycle_Bm_1_00180
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 23)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00180_A1 {
+        Cycle_B_1_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A2 {
+        Cycle_B_1_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A3 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A4 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A5 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00180 A1_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A2_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A3_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A4_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A5_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A6_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+
+        A1_Cycle_Bm_1_00180.start();
+        A2_Cycle_Bm_1_00180.start();
+        A3_Cycle_Bm_1_00180.start();
+        A4_Cycle_Bm_1_00180.start();
+        A5_Cycle_Bm_1_00180.start();
+        A6_Cycle_Bm_1_00180.start();
+
+        try {
+            A1_Cycle_Bm_1_00180.join();
+            A2_Cycle_Bm_1_00180.join();
+            A3_Cycle_Bm_1_00180.join();
+            A4_Cycle_Bm_1_00180.join();
+            A5_Cycle_Bm_1_00180.join();
+            A6_Cycle_Bm_1_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00180.check() && A2_Cycle_Bm_1_00180.check() && A3_Cycle_Bm_1_00180.check() && A4_Cycle_Bm_1_00180.check() && A5_Cycle_Bm_1_00180.check() && A6_Cycle_Bm_1_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/Cycle_Bm_1_00190.java b/test/testsuite/ouroboros/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/Cycle_Bm_1_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..242d57de0e421e9197254bc06d0b37ffa8784d67
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/Cycle_Bm_1_00190.java
@@ -0,0 +1,149 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00190 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00190.java
+ *- @ExecuteClass: Cycle_Bm_1_00190
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00190 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00190_A1 a1_0 = new Cycle_B_1_00190_A1();
+        a1_0.a2_0 = new Cycle_B_1_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00190_A3();
+        Cycle_B_1_00190_A4 a4_0 = new Cycle_B_1_00190_A4();
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00190_A1 {
+        Cycle_B_1_00190_A2 a2_0;
+        Cycle_B_1_00190_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A2 {
+        Cycle_B_1_00190_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A3 {
+        Cycle_B_1_00190_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00190 A1_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A2_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A3_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A4_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A5_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A6_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+
+        A1_Cycle_Bm_1_00190.start();
+        A2_Cycle_Bm_1_00190.start();
+        A3_Cycle_Bm_1_00190.start();
+        A4_Cycle_Bm_1_00190.start();
+        A5_Cycle_Bm_1_00190.start();
+        A6_Cycle_Bm_1_00190.start();
+
+        try {
+            A1_Cycle_Bm_1_00190.join();
+            A2_Cycle_Bm_1_00190.join();
+            A3_Cycle_Bm_1_00190.join();
+            A4_Cycle_Bm_1_00190.join();
+            A5_Cycle_Bm_1_00190.join();
+            A6_Cycle_Bm_1_00190.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00190.check() && A2_Cycle_Bm_1_00190.check() && A3_Cycle_Bm_1_00190.check() && A4_Cycle_Bm_1_00190.check() && A5_Cycle_Bm_1_00190.check() && A6_Cycle_Bm_1_00190.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/Cycle_Bm_1_00200.java b/test/testsuite/ouroboros/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/Cycle_Bm_1_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..4eb9d32139143aa3e53b805e78c08623e3370e8c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/Cycle_Bm_1_00200.java
@@ -0,0 +1,168 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_00200 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00200.java
+ *- @ExecuteClass: Cycle_Bm_1_00200
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00200 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00200_A1 a1_0 = new Cycle_B_1_00200_A1();
+        a1_0.a2_0 = new Cycle_B_1_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00200_A3();
+        Cycle_B_1_00200_A4 a4_0 = new Cycle_B_1_00200_A4();
+        Cycle_B_1_00200_A5 a5_0 = new Cycle_B_1_00200_A5();
+        a1_0.a4_0 = a4_0;
+        a1_0.a5_0 = a5_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00200_A1 {
+        Cycle_B_1_00200_A2 a2_0;
+        Cycle_B_1_00200_A4 a4_0;
+        Cycle_B_1_00200_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A2 {
+        Cycle_B_1_00200_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A3 {
+        Cycle_B_1_00200_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A4() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+
+    class Cycle_B_1_00200_A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A5() {
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00200 A1_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A2_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A3_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A4_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A5_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A6_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+
+        A1_Cycle_Bm_1_00200.start();
+        A2_Cycle_Bm_1_00200.start();
+        A3_Cycle_Bm_1_00200.start();
+        A4_Cycle_Bm_1_00200.start();
+        A5_Cycle_Bm_1_00200.start();
+        A6_Cycle_Bm_1_00200.start();
+
+        try {
+            A1_Cycle_Bm_1_00200.join();
+            A2_Cycle_Bm_1_00200.join();
+            A3_Cycle_Bm_1_00200.join();
+            A4_Cycle_Bm_1_00200.join();
+            A5_Cycle_Bm_1_00200.join();
+            A6_Cycle_Bm_1_00200.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00200.check() && A2_Cycle_Bm_1_00200.check() && A3_Cycle_Bm_1_00200.check() && A4_Cycle_Bm_1_00200.check() && A5_Cycle_Bm_1_00200.check() && A6_Cycle_Bm_1_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/Cycle_Bm_1_00210.java b/test/testsuite/ouroboros/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/Cycle_Bm_1_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..59cda020000b7ae1f201c452a3c0fb443483f6c2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/Cycle_Bm_1_00210.java
@@ -0,0 +1,2037 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:make Cycle_B_1_xx together to this Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_00210.java
+ *- @ExecuteClass: Cycle_Bm_1_00210
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_00010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 246)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00010_A1 {
+        Cycle_B_1_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00010_A1() {
+            a1_0 = null;
+            a = 123;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00020_A1 a1_0 = new Cycle_B_1_00020_A1();
+        a1_0.a2_0 = new Cycle_B_1_00020_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 6)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00020_A1 {
+        Cycle_B_1_00020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00020_A2 {
+        Cycle_B_1_00020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00020_A2() {
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00030B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00030_A1 a1_0 = new Cycle_B_1_00030_A1();
+        a1_0.a2_0 = new Cycle_B_1_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00030_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00030_A1 {
+        Cycle_B_1_00030_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00030_A2 {
+        Cycle_B_1_00030_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00030_A3 {
+        Cycle_B_1_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00040B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00040_A1 a1_0 = new Cycle_B_1_00040_A1();
+        a1_0.a2_0 = new Cycle_B_1_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00040_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00040_A4();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00040_A1 {
+        Cycle_B_1_00040_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A2 {
+        Cycle_B_1_00040_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A3 {
+        Cycle_B_1_00040_A1 a1_0;
+        Cycle_B_1_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00040_A4 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00040_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00050B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00050_A1 a1_0 = new Cycle_B_1_00050_A1();
+        a1_0.a2_0 = new Cycle_B_1_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00050_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00050_A4();
+        a1_0.a2_0.a5_0 = new Cycle_B_1_00050_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 34)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00050_A1 {
+        Cycle_B_1_00050_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A2 {
+        Cycle_B_1_00050_A3 a3_0;
+        Cycle_B_1_00050_A4 a4_0;
+        Cycle_B_1_00050_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A3 {
+        Cycle_B_1_00050_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00050_A4 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+
+    class Cycle_B_1_00050_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00050_A5() {
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00060B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00060_A1 a1_0 = new Cycle_B_1_00060_A1();
+        a1_0.a2_0 = new Cycle_B_1_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00060_A3();
+        Cycle_B_1_00060_A4 a4_0 = new Cycle_B_1_00060_A4();
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00060_A1 {
+        Cycle_B_1_00060_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A2 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A3 {
+        Cycle_B_1_00060_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00060_A4 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00070B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00070_A1 a1_0 = new Cycle_B_1_00070_A1();
+        a1_0.a2_0 = new Cycle_B_1_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00070_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00070_A4();
+
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00070_A1 {
+        Cycle_B_1_00070_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A2 {
+        Cycle_B_1_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A3 {
+        Cycle_B_1_00070_A1 a1_0;
+        Cycle_B_1_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00070_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00070_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00080B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00080_A1 a1_0 = new Cycle_B_1_00080_A1();
+        a1_0.a2_0 = new Cycle_B_1_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00080_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00080_A4();
+        a1_0.a2_0.a3_0.a5_0 = new Cycle_B_1_00080_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 56)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00080_A1 {
+        Cycle_B_1_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00080_A2 {
+        Cycle_B_1_00080_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00080_A3 {
+        Cycle_B_1_00080_A1 a1_0;
+        Cycle_B_1_00080_A4 a4_0;
+        Cycle_B_1_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            a4_0.add();
+            a5_0.add();
+            sum = a + a1_0.a + a4_0.sum + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00080_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+
+    class Cycle_B_1_00080_A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00080_A5() {
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00090B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00090_A1 a1_0 = new Cycle_B_1_00090_A1();
+        a1_0.a2_0 = new Cycle_B_1_00090_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00090_A3();
+        Cycle_B_1_00090_A4 a4_0 = new Cycle_B_1_00090_A4();
+        Cycle_B_1_00090_A5 a5_0 = new Cycle_B_1_00090_A5();
+        a4_0.a2_0 = a1_0.a2_0;
+        a5_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 25)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00090_A1 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A2 {
+        Cycle_B_1_00090_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A3 {
+        Cycle_B_1_00090_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A4 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00090_A5 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00090_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00100B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00100_A1 a1_0 = new Cycle_B_1_00100_A1();
+        a1_0.a2_0 = new Cycle_B_1_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00100_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00100_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_1_00100_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00100_A1 {
+        Cycle_B_1_00100_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A2 {
+        Cycle_B_1_00100_A3 a3_0;
+        Cycle_B_1_00100_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A3 {
+        Cycle_B_1_00100_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00100_A4 {
+
+        int a;
+        int sum;
+        Cycle_B_1_00100_A5 a5_0;
+
+        Cycle_B_1_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00100_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00100_A5() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00110B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00110_A1 a1_0 = new Cycle_B_1_00110_A1();
+        a1_0.a2_0 = new Cycle_B_1_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00110_A3();
+        Cycle_B_1_00110_A5 a5_0 = new Cycle_B_1_00110_A5();
+        a5_0.a4_0 = new Cycle_B_1_00110_A4();
+        a5_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00110_A1 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A2 {
+        Cycle_B_1_00110_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A3 {
+        Cycle_B_1_00110_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A4 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00110_A5 {
+        Cycle_B_1_00110_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00110_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00120B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00120_A1 a1_0 = new Cycle_B_1_00120_A1();
+        a1_0.a2_0 = new Cycle_B_1_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00120_A3();
+        Cycle_B_1_00120_A5 a5_0 = new Cycle_B_1_00120_A5();
+        a5_0.a4_0 = new Cycle_B_1_00120_A4();
+        a5_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00120_A1 {
+        Cycle_B_1_00120_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A2 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A3 {
+        Cycle_B_1_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A4 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00120_A5 {
+        Cycle_B_1_00120_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00120_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00130B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00130_A1 a1_0 = new Cycle_B_1_00130_A1();
+        Cycle_B_1_00130_A2 a2_0 = new Cycle_B_1_00130_A2();
+        Cycle_B_1_00130_A3 a3_0 = new Cycle_B_1_00130_A3();
+        a1_0.a3_0 = a3_0;
+        a2_0.a3_0 = a3_0;
+        a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00130_A1 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A1() {
+            a3_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00130_A2 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00130_A3 {
+        Cycle_B_1_00130_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00130_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00140B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00140_A1 a1_0 = new Cycle_B_1_00140_A1();
+        a1_0.a2_0 = new Cycle_B_1_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00140_A3();
+        Cycle_B_1_00140_A4 a4_0 = new Cycle_B_1_00140_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00140_A1 {
+        Cycle_B_1_00140_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A2 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A3 {
+        Cycle_B_1_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00140_A4 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00140_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00150B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00150_A1 a1_0 = new Cycle_B_1_00150_A1();
+        a1_0.a2_0 = new Cycle_B_1_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00150_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_1_00150_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum;
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00150_A1 {
+        Cycle_B_1_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A2 {
+        Cycle_B_1_00150_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A3 {
+        Cycle_B_1_00150_A1 a1_0;
+        Cycle_B_1_00150_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00150_A4 {
+
+        int a;
+        int sum;
+        Cycle_B_1_00150_A5 a5_0;
+
+        Cycle_B_1_00150_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+
+    class Cycle_B_1_00150_A5 {
+
+        int a;
+        int sum;
+
+        Cycle_B_1_00150_A5() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00160B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00160_A1 a1_0 = new Cycle_B_1_00160_A1();
+        a1_0.a2_0 = new Cycle_B_1_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00160_A3();
+        Cycle_B_1_00160_A4 a4_0 = new Cycle_B_1_00160_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 17)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00160_A1 {
+        Cycle_B_1_00160_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A2 {
+        Cycle_B_1_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A3 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00160_A4 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00160_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00170B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00170_A1 a1_0 = new Cycle_B_1_00170_A1();
+        a1_0.a2_0 = new Cycle_B_1_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00170_A3();
+        Cycle_B_1_00170_A4 a4_0 = new Cycle_B_1_00170_A4();
+        Cycle_B_1_00170_A5 a5_0 = new Cycle_B_1_00170_A5();
+        a5_0.a4_0 = a4_0;
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 26)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00170_A1 {
+        Cycle_B_1_00170_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A2 {
+        Cycle_B_1_00170_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A3 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A4 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00170_A5 {
+        Cycle_B_1_00170_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00170_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00180B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 23)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00180_A1 {
+        Cycle_B_1_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A2 {
+        Cycle_B_1_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A3 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A4 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A5 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00190B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00190_A1 a1_0 = new Cycle_B_1_00190_A1();
+        a1_0.a2_0 = new Cycle_B_1_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00190_A3();
+        Cycle_B_1_00190_A4 a4_0 = new Cycle_B_1_00190_A4();
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00190_A1 {
+        Cycle_B_1_00190_A2 a2_0;
+        Cycle_B_1_00190_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A2 {
+        Cycle_B_1_00190_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A3 {
+        Cycle_B_1_00190_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00190_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00190_A4() {
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_00200B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00200_A1 a1_0 = new Cycle_B_1_00200_A1();
+        a1_0.a2_0 = new Cycle_B_1_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00200_A3();
+        Cycle_B_1_00200_A4 a4_0 = new Cycle_B_1_00200_A4();
+        Cycle_B_1_00200_A5 a5_0 = new Cycle_B_1_00200_A5();
+        a1_0.a4_0 = a4_0;
+        a1_0.a5_0 = a5_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00200_A1 {
+        Cycle_B_1_00200_A2 a2_0;
+        Cycle_B_1_00200_A4 a4_0;
+        Cycle_B_1_00200_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A2 {
+        Cycle_B_1_00200_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A3 {
+        Cycle_B_1_00200_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00200_A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A4() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+
+    class Cycle_B_1_00200_A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_00200_A5() {
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+
+public class Cycle_Bm_1_00210 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00010B A1_00010 = new ThreadRc_Cycle_Bm_1_00010B();
+        ThreadRc_Cycle_Bm_1_00010B A2_00010 = new ThreadRc_Cycle_Bm_1_00010B();
+        ThreadRc_Cycle_Bm_1_00020B A1_00020 = new ThreadRc_Cycle_Bm_1_00020B();
+        ThreadRc_Cycle_Bm_1_00020B A2_00020 = new ThreadRc_Cycle_Bm_1_00020B();
+        ThreadRc_Cycle_Bm_1_00030B A1_00030 = new ThreadRc_Cycle_Bm_1_00030B();
+        ThreadRc_Cycle_Bm_1_00030B A2_00030 = new ThreadRc_Cycle_Bm_1_00030B();
+        ThreadRc_Cycle_Bm_1_00040B A1_00040 = new ThreadRc_Cycle_Bm_1_00040B();
+        ThreadRc_Cycle_Bm_1_00040B A2_00040 = new ThreadRc_Cycle_Bm_1_00040B();
+        ThreadRc_Cycle_Bm_1_00050B A1_00050 = new ThreadRc_Cycle_Bm_1_00050B();
+        ThreadRc_Cycle_Bm_1_00050B A2_00050 = new ThreadRc_Cycle_Bm_1_00050B();
+        ThreadRc_Cycle_Bm_1_00060B A1_00060 = new ThreadRc_Cycle_Bm_1_00060B();
+        ThreadRc_Cycle_Bm_1_00060B A2_00060 = new ThreadRc_Cycle_Bm_1_00060B();
+        ThreadRc_Cycle_Bm_1_00070B A1_00070 = new ThreadRc_Cycle_Bm_1_00070B();
+        ThreadRc_Cycle_Bm_1_00070B A2_00070 = new ThreadRc_Cycle_Bm_1_00070B();
+        ThreadRc_Cycle_Bm_1_00080B A1_00080 = new ThreadRc_Cycle_Bm_1_00080B();
+        ThreadRc_Cycle_Bm_1_00080B A2_00080 = new ThreadRc_Cycle_Bm_1_00080B();
+        ThreadRc_Cycle_Bm_1_00090B A1_00090 = new ThreadRc_Cycle_Bm_1_00090B();
+        ThreadRc_Cycle_Bm_1_00090B A2_00090 = new ThreadRc_Cycle_Bm_1_00090B();
+        ThreadRc_Cycle_Bm_1_00100B A1_00100 = new ThreadRc_Cycle_Bm_1_00100B();
+        ThreadRc_Cycle_Bm_1_00100B A2_00100 = new ThreadRc_Cycle_Bm_1_00100B();
+        ThreadRc_Cycle_Bm_1_00110B A1_00110 = new ThreadRc_Cycle_Bm_1_00110B();
+        ThreadRc_Cycle_Bm_1_00110B A2_00110 = new ThreadRc_Cycle_Bm_1_00110B();
+        ThreadRc_Cycle_Bm_1_00120B A1_00120 = new ThreadRc_Cycle_Bm_1_00120B();
+        ThreadRc_Cycle_Bm_1_00120B A2_00120 = new ThreadRc_Cycle_Bm_1_00120B();
+        ThreadRc_Cycle_Bm_1_00130B A1_00130 = new ThreadRc_Cycle_Bm_1_00130B();
+        ThreadRc_Cycle_Bm_1_00130B A2_00130 = new ThreadRc_Cycle_Bm_1_00130B();
+        ThreadRc_Cycle_Bm_1_00140B A1_00140 = new ThreadRc_Cycle_Bm_1_00140B();
+        ThreadRc_Cycle_Bm_1_00140B A2_00140 = new ThreadRc_Cycle_Bm_1_00140B();
+        ThreadRc_Cycle_Bm_1_00150B A1_00150 = new ThreadRc_Cycle_Bm_1_00150B();
+        ThreadRc_Cycle_Bm_1_00150B A2_00150 = new ThreadRc_Cycle_Bm_1_00150B();
+        ThreadRc_Cycle_Bm_1_00160B A1_00160 = new ThreadRc_Cycle_Bm_1_00160B();
+        ThreadRc_Cycle_Bm_1_00160B A2_00160 = new ThreadRc_Cycle_Bm_1_00160B();
+        ThreadRc_Cycle_Bm_1_00170B A1_00170 = new ThreadRc_Cycle_Bm_1_00170B();
+        ThreadRc_Cycle_Bm_1_00170B A2_00170 = new ThreadRc_Cycle_Bm_1_00170B();
+        ThreadRc_Cycle_Bm_1_00180B A1_00180 = new ThreadRc_Cycle_Bm_1_00180B();
+        ThreadRc_Cycle_Bm_1_00180B A2_00180 = new ThreadRc_Cycle_Bm_1_00180B();
+        ThreadRc_Cycle_Bm_1_00190B A1_00190 = new ThreadRc_Cycle_Bm_1_00190B();
+        ThreadRc_Cycle_Bm_1_00190B A2_00190 = new ThreadRc_Cycle_Bm_1_00190B();
+        ThreadRc_Cycle_Bm_1_00200B A1_00200 = new ThreadRc_Cycle_Bm_1_00200B();
+        ThreadRc_Cycle_Bm_1_00200B A2_00200 = new ThreadRc_Cycle_Bm_1_00200B();
+        A1_00010.start();
+        A2_00010.start();
+        A1_00020.start();
+        A2_00020.start();
+        A1_00030.start();
+        A2_00030.start();
+        A1_00040.start();
+        A2_00040.start();
+        A1_00050.start();
+        A2_00050.start();
+        A1_00060.start();
+        A2_00060.start();
+        A1_00070.start();
+        A2_00070.start();
+        A1_00080.start();
+        A2_00080.start();
+        A1_00090.start();
+        A2_00090.start();
+        A1_00100.start();
+        A2_00100.start();
+        A1_00110.start();
+        A2_00110.start();
+        A1_00120.start();
+        A2_00120.start();
+        A1_00130.start();
+        A2_00130.start();
+        A1_00140.start();
+        A2_00140.start();
+        A1_00150.start();
+        A2_00150.start();
+        A1_00160.start();
+        A2_00160.start();
+        A1_00170.start();
+        A2_00170.start();
+        A1_00180.start();
+        A2_00180.start();
+        A1_00190.start();
+        A2_00190.start();
+        A1_00200.start();
+        A2_00200.start();
+        try {
+            A1_00010.join();
+            A2_00010.join();
+            A1_00020.join();
+            A2_00020.join();
+            A1_00030.join();
+            A2_00030.join();
+            A1_00040.join();
+            A2_00040.join();
+            A1_00050.join();
+            A2_00050.join();
+            A1_00060.join();
+            A2_00060.join();
+            A1_00070.join();
+            A2_00070.join();
+            A1_00080.join();
+            A2_00080.join();
+            A1_00090.join();
+            A2_00090.join();
+            A1_00100.join();
+            A2_00100.join();
+            A1_00110.join();
+            A2_00110.join();
+            A1_00120.join();
+            A2_00120.join();
+            A1_00130.join();
+            A2_00130.join();
+            A1_00140.join();
+            A2_00140.join();
+            A1_00150.join();
+            A2_00150.join();
+            A1_00160.join();
+            A2_00160.join();
+            A1_00170.join();
+            A2_00170.join();
+            A1_00180.join();
+            A2_00180.join();
+            A1_00190.join();
+            A2_00190.join();
+            A1_00200.join();
+            A2_00200.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00010.check() && A2_00010.check() && A1_00020.check() && A2_00020.check() && A1_00030.check() && A2_00030.check() && A1_00040.check() && A2_00040.check() && A1_00050.check() && A2_00050.check() && A1_00060.check() && A2_00060.check() && A1_00070.check() && A2_00070.check() && A1_00080.check() && A2_00080.check() && A1_00090.check() && A2_00090.check() && A1_00100.check() && A2_00100.check() && A1_00110.check() && A2_00110.check() && A1_00120.check() && A2_00120.check() && A1_00130.check() && A2_00130.check() && A1_00140.check() && A2_00140.check() && A1_00150.check() && A2_00150.check() && A1_00160.check() && A2_00160.check() && A1_00170.check() && A2_00170.check() && A1_00180.check() && A2_00180.check() && A1_00190.check() && A2_00190.check() && A1_00200.check() && A2_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/Cycle_Bm_1_10010.java b/test/testsuite/ouroboros/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/Cycle_Bm_1_10010.java
new file mode 100755
index 0000000000000000000000000000000000000000..016e69d3f59f2e877cd688a740133b914f9d6b19
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/Cycle_Bm_1_10010.java
@@ -0,0 +1,187 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_10010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_10010 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_10010.java
+ *- @ExecuteClass: Cycle_Bm_1_10010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_10010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_10010_A1 a1_0 = new Cycle_B_1_10010_A1();
+        a1_0.a2_0 = new Cycle_B_1_10010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10010_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        Cycle_B_1_10010_2A1 a1_10 = new Cycle_B_1_10010_2A1();
+        a1_10.a2_0 = new Cycle_B_1_10010_2A2();
+        a1_10.a2_0.a3_0 = new Cycle_B_1_10010_2A3();
+        a1_10.a2_0.a3_0.a1_0 = a1_10;
+        a1_10.add();
+        a1_10.a2_0.add();
+        a1_10.a2_0.a3_0.add();
+        int nsum2 = (a1_10.sum + a1_10.a2_0.sum + a1_10.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        nsum += nsum2;
+
+        if (nsum == 24)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_10010_A1 {
+        Cycle_B_1_10010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_A2 {
+        Cycle_B_1_10010_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_A3 {
+        Cycle_B_1_10010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A1 {
+        Cycle_B_1_10010_2A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A2 {
+        Cycle_B_1_10010_2A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A3 {
+        Cycle_B_1_10010_2A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_10010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_10010 A1_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A2_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A3_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A4_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A5_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A6_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+
+        A1_Cycle_Bm_1_10010.start();
+        A2_Cycle_Bm_1_10010.start();
+        A3_Cycle_Bm_1_10010.start();
+        A4_Cycle_Bm_1_10010.start();
+        A5_Cycle_Bm_1_10010.start();
+        A6_Cycle_Bm_1_10010.start();
+
+        try {
+            A1_Cycle_Bm_1_10010.join();
+            A2_Cycle_Bm_1_10010.join();
+            A3_Cycle_Bm_1_10010.join();
+            A4_Cycle_Bm_1_10010.join();
+            A5_Cycle_Bm_1_10010.join();
+            A6_Cycle_Bm_1_10010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_10010.check() && A2_Cycle_Bm_1_10010.check() && A3_Cycle_Bm_1_10010.check() && A4_Cycle_Bm_1_10010.check() && A5_Cycle_Bm_1_10010.check() && A6_Cycle_Bm_1_10010.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/Cycle_Bm_1_10020.java b/test/testsuite/ouroboros/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/Cycle_Bm_1_10020.java
new file mode 100755
index 0000000000000000000000000000000000000000..b671deb3939d2e306e122d02b6c13f6ac27c9363
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/Cycle_Bm_1_10020.java
@@ -0,0 +1,262 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_10020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_10020 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_10020.java
+ *- @ExecuteClass: Cycle_Bm_1_10020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_10020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_10020_A1 a1_0 = new Cycle_B_1_10020_A1();
+        a1_0.a2_0 = new Cycle_B_1_10020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10020_A3();
+        Cycle_B_1_10020_A4 a4_0 = new Cycle_B_1_10020_A4();
+        Cycle_B_1_10020_A5 a5_0 = new Cycle_B_1_10020_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        Cycle_B_1_10020_2A1 a1_20 = new Cycle_B_1_10020_2A1();
+        a1_20.a2_0 = new Cycle_B_1_10020_2A2();
+        a1_20.a2_0.a3_0 = new Cycle_B_1_10020_2A3();
+        Cycle_B_1_10020_2A4 a4_20 = new Cycle_B_1_10020_2A4();
+        Cycle_B_1_10020_2A5 a5_20 = new Cycle_B_1_10020_2A5();
+        a1_20.a4_0 = a4_20;
+        a1_20.a5_0 = a5_20;
+        a1_20.a2_0.a3_0.a1_0 = a1_20;
+        a1_20.add();
+        a1_20.a2_0.add();
+        a1_20.a2_0.a3_0.add();
+        a4_20.add();
+        a5_20.add();
+        int nsum1 = (a1_20.sum + a1_20.a2_0.sum + a1_20.a2_0.a3_0.sum + a4_20.sum + a5_20.sum);
+        nsum += nsum1;
+
+        if (nsum == 61)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_10020_A1 {
+        Cycle_B_1_10020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A2 {
+        Cycle_B_1_10020_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A3 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A4 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A5 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A1 {
+        Cycle_B_1_10020_2A2 a2_0;
+        Cycle_B_1_10020_2A4 a4_0;
+        Cycle_B_1_10020_2A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A2 {
+        Cycle_B_1_10020_2A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A3 {
+        Cycle_B_1_10020_2A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A4() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+
+    class Cycle_B_1_10020_2A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A5() {
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+
+
+public class Cycle_Bm_1_10020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_10020 A1_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A2_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A3_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A4_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A5_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A6_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+
+        A1_Cycle_Bm_1_10020.start();
+        A2_Cycle_Bm_1_10020.start();
+        A3_Cycle_Bm_1_10020.start();
+        A4_Cycle_Bm_1_10020.start();
+        A5_Cycle_Bm_1_10020.start();
+        A6_Cycle_Bm_1_10020.start();
+
+        try {
+            A1_Cycle_Bm_1_10020.join();
+            A2_Cycle_Bm_1_10020.join();
+            A3_Cycle_Bm_1_10020.join();
+            A4_Cycle_Bm_1_10020.join();
+            A5_Cycle_Bm_1_10020.join();
+            A6_Cycle_Bm_1_10020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_10020.check() && A2_Cycle_Bm_1_10020.check() && A3_Cycle_Bm_1_10020.check() && A4_Cycle_Bm_1_10020.check() && A5_Cycle_Bm_1_10020.check() && A6_Cycle_Bm_1_10020.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/Cycle_Bm_1_10030.java b/test/testsuite/ouroboros/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/Cycle_Bm_1_10030.java
new file mode 100755
index 0000000000000000000000000000000000000000..3b8e832e39b617614f108ee7b863b7d8e2c0d450
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/Cycle_Bm_1_10030.java
@@ -0,0 +1,409 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_1_10030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_1_10030 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_1_10030.java
+ *- @ExecuteClass: Cycle_Bm_1_10030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_1_10010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_10010_A1 a1_0 = new Cycle_B_1_10010_A1();
+        a1_0.a2_0 = new Cycle_B_1_10010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10010_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        Cycle_B_1_10010_2A1 a1_10 = new Cycle_B_1_10010_2A1();
+        a1_10.a2_0 = new Cycle_B_1_10010_2A2();
+        a1_10.a2_0.a3_0 = new Cycle_B_1_10010_2A3();
+        a1_10.a2_0.a3_0.a1_0 = a1_10;
+        a1_10.add();
+        a1_10.a2_0.add();
+        a1_10.a2_0.a3_0.add();
+        int nsum2 = (a1_10.sum + a1_10.a2_0.sum + a1_10.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        nsum += nsum2;
+
+        if (nsum == 24)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_10010_A1 {
+        Cycle_B_1_10010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_A2 {
+        Cycle_B_1_10010_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_A3 {
+        Cycle_B_1_10010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A1 {
+        Cycle_B_1_10010_2A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A2 {
+        Cycle_B_1_10010_2A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10010_2A3 {
+        Cycle_B_1_10010_2A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10010_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_1_10020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_10020_A1 a1_0 = new Cycle_B_1_10020_A1();
+        a1_0.a2_0 = new Cycle_B_1_10020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10020_A3();
+        Cycle_B_1_10020_A4 a4_0 = new Cycle_B_1_10020_A4();
+        Cycle_B_1_10020_A5 a5_0 = new Cycle_B_1_10020_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        Cycle_B_1_10020_2A1 a1_20 = new Cycle_B_1_10020_2A1();
+        a1_20.a2_0 = new Cycle_B_1_10020_2A2();
+        a1_20.a2_0.a3_0 = new Cycle_B_1_10020_2A3();
+        Cycle_B_1_10020_2A4 a4_20 = new Cycle_B_1_10020_2A4();
+        Cycle_B_1_10020_2A5 a5_20 = new Cycle_B_1_10020_2A5();
+        a1_20.a4_0 = a4_20;
+        a1_20.a5_0 = a5_20;
+        a1_20.a2_0.a3_0.a1_0 = a1_20;
+        a1_20.add();
+        a1_20.a2_0.add();
+        a1_20.a2_0.a3_0.add();
+        a4_20.add();
+        a5_20.add();
+        int nsum1 = (a1_20.sum + a1_20.a2_0.sum + a1_20.a2_0.a3_0.sum + a4_20.sum + a5_20.sum);
+        nsum += nsum1;
+
+        if (nsum == 61)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_10020_A1 {
+        Cycle_B_1_10020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A2 {
+        Cycle_B_1_10020_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A3 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A4 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_A5 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A1 {
+        Cycle_B_1_10020_2A2 a2_0;
+        Cycle_B_1_10020_2A4 a4_0;
+        Cycle_B_1_10020_2A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A2 {
+        Cycle_B_1_10020_2A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A3 {
+        Cycle_B_1_10020_2A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_10020_2A4 {
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A4() {
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 6;
+        }
+    }
+
+    class Cycle_B_1_10020_2A5 {
+        int a;
+        int sum;
+
+        Cycle_B_1_10020_2A5() {
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+
+public class Cycle_Bm_1_10030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_10010B A1_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A2_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A3_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A4_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A5_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A6_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10020B A1_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A2_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A3_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A4_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A5_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A6_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        A1_Cycle_Bm_1_10010.start();
+        A2_Cycle_Bm_1_10010.start();
+        A3_Cycle_Bm_1_10010.start();
+        A4_Cycle_Bm_1_10010.start();
+        A5_Cycle_Bm_1_10010.start();
+        A6_Cycle_Bm_1_10010.start();
+        A1_Cycle_Bm_1_10020.start();
+        A2_Cycle_Bm_1_10020.start();
+        A3_Cycle_Bm_1_10020.start();
+        A4_Cycle_Bm_1_10020.start();
+        A5_Cycle_Bm_1_10020.start();
+        A6_Cycle_Bm_1_10020.start();
+
+        try {
+            A1_Cycle_Bm_1_10010.join();
+            A2_Cycle_Bm_1_10010.join();
+            A3_Cycle_Bm_1_10010.join();
+            A4_Cycle_Bm_1_10010.join();
+            A5_Cycle_Bm_1_10010.join();
+            A6_Cycle_Bm_1_10010.join();
+            A1_Cycle_Bm_1_10020.join();
+            A2_Cycle_Bm_1_10020.join();
+            A3_Cycle_Bm_1_10020.join();
+            A4_Cycle_Bm_1_10020.join();
+            A5_Cycle_Bm_1_10020.join();
+            A6_Cycle_Bm_1_10020.join();
+        } catch (InterruptedException e) {
+            e.getStackTrace();
+        }
+        if (A1_Cycle_Bm_1_10010.check() && A2_Cycle_Bm_1_10010.check() && A3_Cycle_Bm_1_10010.check() && A4_Cycle_Bm_1_10010.check() && A5_Cycle_Bm_1_10010.check() && A6_Cycle_Bm_1_10010.check() && A1_Cycle_Bm_1_10020.check() && A2_Cycle_Bm_1_10020.check() && A3_Cycle_Bm_1_10020.check() && A4_Cycle_Bm_1_10020.check() && A5_Cycle_Bm_1_10020.check() && A6_Cycle_Bm_1_10020.check())
+            System.out.println("ExpectResult");
+    }
+
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/Cycle_Bm_2_00010.java b/test/testsuite/ouroboros/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/Cycle_Bm_2_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..b44309d11a8044f1013c54adedb5b5c2096ef82b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/Cycle_Bm_2_00010.java
@@ -0,0 +1,151 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00010 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00010.java
+ *- @ExecuteClass: Cycle_Bm_2_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00010_A1 a1_0 = new Cycle_B_2_00010_A1();
+        a1_0.a2_0 = new Cycle_B_2_00010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00010_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00010_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 18)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00010_A1 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A2 {
+        Cycle_B_2_00010_A3 a3_0;
+        Cycle_B_2_00010_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A3 {
+        Cycle_B_2_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A4 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00010 A1_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A2_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A3_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A4_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A5_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A6_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+
+        A1_Cycle_Bm_2_00010.start();
+        A2_Cycle_Bm_2_00010.start();
+        A3_Cycle_Bm_2_00010.start();
+        A4_Cycle_Bm_2_00010.start();
+        A5_Cycle_Bm_2_00010.start();
+        A6_Cycle_Bm_2_00010.start();
+
+        try {
+            A1_Cycle_Bm_2_00010.join();
+            A2_Cycle_Bm_2_00010.join();
+            A3_Cycle_Bm_2_00010.join();
+            A4_Cycle_Bm_2_00010.join();
+            A5_Cycle_Bm_2_00010.join();
+            A6_Cycle_Bm_2_00010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00010.check() && A2_Cycle_Bm_2_00010.check() && A3_Cycle_Bm_2_00010.check() && A4_Cycle_Bm_2_00010.check() && A5_Cycle_Bm_2_00010.check() && A6_Cycle_Bm_2_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/Cycle_Bm_2_00020.java b/test/testsuite/ouroboros/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/Cycle_Bm_2_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..7f5f7e9f0cc68540282c8574a3ae540af72107f0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/Cycle_Bm_2_00020.java
@@ -0,0 +1,154 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00020 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00020.java
+ *- @ExecuteClass: Cycle_Bm_2_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00020_A1 a1_0 = new Cycle_B_2_00020_A1();
+        a1_0.a2_0 = new Cycle_B_2_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00020_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00020_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00020_A1 {
+        Cycle_B_2_00020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A2 {
+        Cycle_B_2_00020_A3 a3_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A3 {
+        Cycle_B_2_00020_A1 a1_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A4 {
+        Cycle_B_2_00020_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00020 A1_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A2_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A3_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A4_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A5_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A6_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+
+        A1_Cycle_Bm_2_00020.start();
+        A2_Cycle_Bm_2_00020.start();
+        A3_Cycle_Bm_2_00020.start();
+        A4_Cycle_Bm_2_00020.start();
+        A5_Cycle_Bm_2_00020.start();
+        A6_Cycle_Bm_2_00020.start();
+
+        try {
+            A1_Cycle_Bm_2_00020.join();
+            A2_Cycle_Bm_2_00020.join();
+            A3_Cycle_Bm_2_00020.join();
+            A4_Cycle_Bm_2_00020.join();
+            A5_Cycle_Bm_2_00020.join();
+            A6_Cycle_Bm_2_00020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00020.check() && A2_Cycle_Bm_2_00020.check() && A3_Cycle_Bm_2_00020.check() && A4_Cycle_Bm_2_00020.check() && A5_Cycle_Bm_2_00020.check() && A6_Cycle_Bm_2_00020.check())
+            System.out.println("ExpectResult");
+
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/Cycle_Bm_2_00030.java b/test/testsuite/ouroboros/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/Cycle_Bm_2_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..a07f5dfbf9560a8ec4e012bb709b63e0c38ae67a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/Cycle_Bm_2_00030.java
@@ -0,0 +1,152 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00030 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00030.java
+ *- @ExecuteClass: Cycle_Bm_2_00030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00030 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00030_A1 a1_0 = new Cycle_B_2_00030_A1();
+        a1_0.a2_0 = new Cycle_B_2_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00030_A3();
+        Cycle_B_2_00030_A4 a4_0 = new Cycle_B_2_00030_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00030_A1 {
+        Cycle_B_2_00030_A2 a2_0;
+        Cycle_B_2_00030_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A2 {
+        Cycle_B_2_00030_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A3 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A4 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00030 A1_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A2_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A3_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A4_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A5_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A6_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+
+        A1_Cycle_Bm_2_00030.start();
+        A2_Cycle_Bm_2_00030.start();
+        A3_Cycle_Bm_2_00030.start();
+        A4_Cycle_Bm_2_00030.start();
+        A5_Cycle_Bm_2_00030.start();
+        A6_Cycle_Bm_2_00030.start();
+
+        try {
+            A1_Cycle_Bm_2_00030.join();
+            A2_Cycle_Bm_2_00030.join();
+            A3_Cycle_Bm_2_00030.join();
+            A4_Cycle_Bm_2_00030.join();
+            A5_Cycle_Bm_2_00030.join();
+            A6_Cycle_Bm_2_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00030.check() && A2_Cycle_Bm_2_00030.check() && A3_Cycle_Bm_2_00030.check() && A4_Cycle_Bm_2_00030.check() && A5_Cycle_Bm_2_00030.check() && A6_Cycle_Bm_2_00030.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/Cycle_Bm_2_00040.java b/test/testsuite/ouroboros/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/Cycle_Bm_2_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..10257f1419b2abad0f922904b8a36d5e9c9d9a5c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/Cycle_Bm_2_00040.java
@@ -0,0 +1,154 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00040 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00040.java
+ *- @ExecuteClass: Cycle_Bm_2_00040
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00040 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00040_A1 a1_0 = new Cycle_B_2_00040_A1();
+        a1_0.a2_0 = new Cycle_B_2_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00040_A3();
+        Cycle_B_2_00040_A4 a4_0 = new Cycle_B_2_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00040_A1 {
+        Cycle_B_2_00040_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A2 {
+        Cycle_B_2_00040_A3 a3_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A3 {
+        Cycle_B_2_00040_A1 a1_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A4 {
+        Cycle_B_2_00040_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00040 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00040 A1_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A2_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A3_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A4_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A5_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A6_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+
+        A1_Cycle_Bm_2_00040.start();
+        A2_Cycle_Bm_2_00040.start();
+        A3_Cycle_Bm_2_00040.start();
+        A4_Cycle_Bm_2_00040.start();
+        A5_Cycle_Bm_2_00040.start();
+        A6_Cycle_Bm_2_00040.start();
+
+        try {
+            A1_Cycle_Bm_2_00040.join();
+            A2_Cycle_Bm_2_00040.join();
+            A3_Cycle_Bm_2_00040.join();
+            A4_Cycle_Bm_2_00040.join();
+            A5_Cycle_Bm_2_00040.join();
+            A6_Cycle_Bm_2_00040.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00040.check() && A2_Cycle_Bm_2_00040.check() && A3_Cycle_Bm_2_00040.check() && A4_Cycle_Bm_2_00040.check() && A5_Cycle_Bm_2_00040.check() && A6_Cycle_Bm_2_00040.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/Cycle_Bm_2_00050.java b/test/testsuite/ouroboros/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/Cycle_Bm_2_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..bf01ae8277417c362d1ddc66cec7a6b11e4ba954
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/Cycle_Bm_2_00050.java
@@ -0,0 +1,173 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00050 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00050.java
+ *- @ExecuteClass: Cycle_Bm_2_00050
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00050 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00050_A1 a1_0 = new Cycle_B_2_00050_A1();
+        a1_0.a2_0 = new Cycle_B_2_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00050_A3();
+        Cycle_B_2_00050_A4 a4_0 = new Cycle_B_2_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00050_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00050_A1 {
+        Cycle_B_2_00050_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A2 {
+        Cycle_B_2_00050_A3 a3_0;
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A3 {
+        Cycle_B_2_00050_A1 a1_0;
+        Cycle_B_2_00050_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A4 {
+        Cycle_B_2_00050_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A5 {
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00050 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00050 A1_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A2_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A3_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A4_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A5_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A6_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+
+        A1_Cycle_Bm_2_00050.start();
+        A2_Cycle_Bm_2_00050.start();
+        A3_Cycle_Bm_2_00050.start();
+        A4_Cycle_Bm_2_00050.start();
+        A5_Cycle_Bm_2_00050.start();
+        A6_Cycle_Bm_2_00050.start();
+
+        try {
+            A1_Cycle_Bm_2_00050.join();
+            A2_Cycle_Bm_2_00050.join();
+            A3_Cycle_Bm_2_00050.join();
+            A4_Cycle_Bm_2_00050.join();
+            A5_Cycle_Bm_2_00050.join();
+            A6_Cycle_Bm_2_00050.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00050.check() && A2_Cycle_Bm_2_00050.check() && A3_Cycle_Bm_2_00050.check() && A4_Cycle_Bm_2_00050.check() && A5_Cycle_Bm_2_00050.check() && A6_Cycle_Bm_2_00050.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/Cycle_Bm_2_00060.java b/test/testsuite/ouroboros/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/Cycle_Bm_2_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..f20bb2d1c25aa457ed13cbfa1d3d9348752a5c53
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/Cycle_Bm_2_00060.java
@@ -0,0 +1,176 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00060 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00060.java
+ *- @ExecuteClass: Cycle_Bm_2_00060
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00060 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00060_A1 a1_0 = new Cycle_B_2_00060_A1();
+        a1_0.a2_0 = new Cycle_B_2_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00060_A3();
+        Cycle_B_2_00060_A4 a4_0 = new Cycle_B_2_00060_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00060_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00060_A1 {
+        Cycle_B_2_00060_A2 a2_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A2 {
+        Cycle_B_2_00060_A3 a3_0;
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A3 {
+        Cycle_B_2_00060_A1 a1_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A4 {
+        Cycle_B_2_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A5 {
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00060 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00060 A1_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A2_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A3_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A4_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A5_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A6_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+
+        A1_Cycle_Bm_2_00060.start();
+        A2_Cycle_Bm_2_00060.start();
+        A3_Cycle_Bm_2_00060.start();
+        A4_Cycle_Bm_2_00060.start();
+        A5_Cycle_Bm_2_00060.start();
+        A6_Cycle_Bm_2_00060.start();
+
+        try {
+            A1_Cycle_Bm_2_00060.join();
+            A2_Cycle_Bm_2_00060.join();
+            A3_Cycle_Bm_2_00060.join();
+            A4_Cycle_Bm_2_00060.join();
+            A5_Cycle_Bm_2_00060.join();
+            A6_Cycle_Bm_2_00060.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00060.check() && A2_Cycle_Bm_2_00060.check() && A3_Cycle_Bm_2_00060.check() && A4_Cycle_Bm_2_00060.check() && A5_Cycle_Bm_2_00060.check() && A6_Cycle_Bm_2_00060.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/Cycle_Bm_2_00070.java b/test/testsuite/ouroboros/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/Cycle_Bm_2_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..09d057a04c6d0a57b5d23f291011965b82bacecd
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/Cycle_Bm_2_00070.java
@@ -0,0 +1,192 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00070 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00070.java
+ *- @ExecuteClass: Cycle_Bm_2_00070
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00070 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00070_A1 a1_0 = new Cycle_B_2_00070_A1();
+        a1_0.a2_0 = new Cycle_B_2_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00070_A3();
+        Cycle_B_2_00070_A4 a4_0 = new Cycle_B_2_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00070_A5();
+        Cycle_B_2_00070_A6 a6_0 = new Cycle_B_2_00070_A6();
+        a6_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a6_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum + a6_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 37)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00070_A1 {
+        Cycle_B_2_00070_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A2 {
+        Cycle_B_2_00070_A3 a3_0;
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A3 {
+        Cycle_B_2_00070_A1 a1_0;
+        Cycle_B_2_00070_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A4 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A5 {
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A6 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A6() {
+            a3_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00070 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00070 A1_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A2_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A3_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A4_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A5_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A6_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+
+        A1_Cycle_Bm_2_00070.start();
+        A2_Cycle_Bm_2_00070.start();
+        A3_Cycle_Bm_2_00070.start();
+        A4_Cycle_Bm_2_00070.start();
+        A5_Cycle_Bm_2_00070.start();
+        A6_Cycle_Bm_2_00070.start();
+
+        try {
+            A1_Cycle_Bm_2_00070.join();
+            A2_Cycle_Bm_2_00070.join();
+            A3_Cycle_Bm_2_00070.join();
+            A4_Cycle_Bm_2_00070.join();
+            A5_Cycle_Bm_2_00070.join();
+            A6_Cycle_Bm_2_00070.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00070.check() && A2_Cycle_Bm_2_00070.check() && A3_Cycle_Bm_2_00070.check() && A4_Cycle_Bm_2_00070.check() && A5_Cycle_Bm_2_00070.check() && A6_Cycle_Bm_2_00070.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/Cycle_Bm_2_00080.java b/test/testsuite/ouroboros/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/Cycle_Bm_2_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..019476184b445719b63bc2eac9ff3f7d59ca0fe4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/Cycle_Bm_2_00080.java
@@ -0,0 +1,180 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00080 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00080.java
+ *- @ExecuteClass: Cycle_Bm_2_00080
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00080 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00080_A1 {
+        Cycle_B_2_00080_A2 a2_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A2 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A3 {
+        Cycle_B_2_00080_A1 a1_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A4 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A4() {
+            a3_0 = null;
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A5 {
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00080 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00080 A1_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A2_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A3_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A4_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A5_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A6_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+
+        A1_Cycle_Bm_2_00080.start();
+        A2_Cycle_Bm_2_00080.start();
+        A3_Cycle_Bm_2_00080.start();
+        A4_Cycle_Bm_2_00080.start();
+        A5_Cycle_Bm_2_00080.start();
+        A6_Cycle_Bm_2_00080.start();
+
+        try {
+            A1_Cycle_Bm_2_00080.join();
+            A2_Cycle_Bm_2_00080.join();
+            A3_Cycle_Bm_2_00080.join();
+            A4_Cycle_Bm_2_00080.join();
+            A5_Cycle_Bm_2_00080.join();
+            A6_Cycle_Bm_2_00080.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00080.check() && A2_Cycle_Bm_2_00080.check() && A3_Cycle_Bm_2_00080.check() && A4_Cycle_Bm_2_00080.check() && A5_Cycle_Bm_2_00080.check() && A6_Cycle_Bm_2_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/Cycle_Bm_2_00090.java b/test/testsuite/ouroboros/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/Cycle_Bm_2_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..e9c33b055345859b2c9349104b7b4131ff63f468
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/Cycle_Bm_2_00090.java
@@ -0,0 +1,134 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00090 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00090.java
+ *- @ExecuteClass: Cycle_Bm_2_00090
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00090 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00090_A1 a1_0 = new Cycle_B_2_00090_A1();
+        Cycle_B_2_00090_A3 a3_0 = new Cycle_B_2_00090_A3();
+        a1_0.a2_0 = new Cycle_B_2_00090_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a3_0.a2_0 = a1_0.a2_0;
+        a3_0.a2_0.a3_0 = a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 9)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00090_A1 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00090_A2 {
+        Cycle_B_2_00090_A1 a1_0;
+        Cycle_B_2_00090_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A2() {
+            a1_0 = null;
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00090_A3 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A3() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00090 A1_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A2_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A3_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A4_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A5_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A6_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+
+        A1_Cycle_Bm_2_00090.start();
+        A2_Cycle_Bm_2_00090.start();
+        A3_Cycle_Bm_2_00090.start();
+        A4_Cycle_Bm_2_00090.start();
+        A5_Cycle_Bm_2_00090.start();
+        A6_Cycle_Bm_2_00090.start();
+
+        try {
+            A1_Cycle_Bm_2_00090.join();
+            A2_Cycle_Bm_2_00090.join();
+            A3_Cycle_Bm_2_00090.join();
+            A4_Cycle_Bm_2_00090.join();
+            A5_Cycle_Bm_2_00090.join();
+            A6_Cycle_Bm_2_00090.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00090.check() && A2_Cycle_Bm_2_00090.check() && A3_Cycle_Bm_2_00090.check() && A4_Cycle_Bm_2_00090.check() && A5_Cycle_Bm_2_00090.check() && A6_Cycle_Bm_2_00090.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/Cycle_Bm_2_00100.java b/test/testsuite/ouroboros/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/Cycle_Bm_2_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..93e5dec9c97144a9e40a626807c2e3cd45c1c55e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/Cycle_Bm_2_00100.java
@@ -0,0 +1,169 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00100 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00100.java
+ *- @ExecuteClass: Cycle_Bm_2_00100
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00100 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00100_A1 a1_0 = new Cycle_B_2_00100_A1();
+        a1_0.a2_0 = new Cycle_B_2_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00100_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00100_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00100_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 29)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00100_A1 {
+        Cycle_B_2_00100_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A2 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A3 {
+        Cycle_B_2_00100_A1 a1_0;
+        Cycle_B_2_00100_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A4 {
+        Cycle_B_2_00100_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A5 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00100 A1_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A2_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A3_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A4_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A5_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A6_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+
+        A1_Cycle_Bm_2_00100.start();
+        A2_Cycle_Bm_2_00100.start();
+        A3_Cycle_Bm_2_00100.start();
+        A4_Cycle_Bm_2_00100.start();
+        A5_Cycle_Bm_2_00100.start();
+        A6_Cycle_Bm_2_00100.start();
+
+        try {
+            A1_Cycle_Bm_2_00100.join();
+            A2_Cycle_Bm_2_00100.join();
+            A3_Cycle_Bm_2_00100.join();
+            A4_Cycle_Bm_2_00100.join();
+            A5_Cycle_Bm_2_00100.join();
+            A6_Cycle_Bm_2_00100.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00100.check() && A2_Cycle_Bm_2_00100.check() && A3_Cycle_Bm_2_00100.check() && A4_Cycle_Bm_2_00100.check() && A5_Cycle_Bm_2_00100.check() && A6_Cycle_Bm_2_00100.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/Cycle_Bm_2_00110.java b/test/testsuite/ouroboros/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/Cycle_Bm_2_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..215289c66a59fb3348a6a6db912fa335970341a7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/Cycle_Bm_2_00110.java
@@ -0,0 +1,169 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00110 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00110.java
+ *- @ExecuteClass: Cycle_Bm_2_00110
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00110 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00110_A1 a1_0 = new Cycle_B_2_00110_A1();
+        a1_0.a2_0 = new Cycle_B_2_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00110_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00110_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_2_00110_A5();
+        a1_0.a2_0.a4_0.a5_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00110_A1 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A2 {
+        Cycle_B_2_00110_A3 a3_0;
+        Cycle_B_2_00110_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A3 {
+        Cycle_B_2_00110_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A4 {
+        Cycle_B_2_00110_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A5 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00110 A1_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A2_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A3_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A4_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A5_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A6_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+
+        A1_Cycle_Bm_2_00110.start();
+        A2_Cycle_Bm_2_00110.start();
+        A3_Cycle_Bm_2_00110.start();
+        A4_Cycle_Bm_2_00110.start();
+        A5_Cycle_Bm_2_00110.start();
+        A6_Cycle_Bm_2_00110.start();
+
+        try {
+            A1_Cycle_Bm_2_00110.join();
+            A2_Cycle_Bm_2_00110.join();
+            A3_Cycle_Bm_2_00110.join();
+            A4_Cycle_Bm_2_00110.join();
+            A5_Cycle_Bm_2_00110.join();
+            A6_Cycle_Bm_2_00110.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00110.check() && A2_Cycle_Bm_2_00110.check() && A3_Cycle_Bm_2_00110.check() && A4_Cycle_Bm_2_00110.check() && A5_Cycle_Bm_2_00110.check() && A6_Cycle_Bm_2_00110.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/Cycle_Bm_2_00120.java b/test/testsuite/ouroboros/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/Cycle_Bm_2_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..79d961e4bb44ffe53e5313a0e498b7070118c271
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/Cycle_Bm_2_00120.java
@@ -0,0 +1,169 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00120 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00120.java
+ *- @ExecuteClass: Cycle_Bm_2_00120
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00120 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00120_A1 a1_0 = new Cycle_B_2_00120_A1();
+        a1_0.a2_0 = new Cycle_B_2_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00120_A3();
+        a1_0.a4_0 = new Cycle_B_2_00120_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a4_0.a5_0 = new Cycle_B_2_00120_A5();
+        a1_0.a4_0.a5_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a4_0.add();
+        a1_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a4_0.sum + a1_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00120_A1 {
+        Cycle_B_2_00120_A2 a2_0;
+        Cycle_B_2_00120_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A2 {
+        Cycle_B_2_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A3 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A4 {
+        Cycle_B_2_00120_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A5 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00120 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00120 A1_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A2_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A3_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A4_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A5_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A6_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+
+        A1_Cycle_Bm_2_00120.start();
+        A2_Cycle_Bm_2_00120.start();
+        A3_Cycle_Bm_2_00120.start();
+        A4_Cycle_Bm_2_00120.start();
+        A5_Cycle_Bm_2_00120.start();
+        A6_Cycle_Bm_2_00120.start();
+
+        try {
+            A1_Cycle_Bm_2_00120.join();
+            A2_Cycle_Bm_2_00120.join();
+            A3_Cycle_Bm_2_00120.join();
+            A4_Cycle_Bm_2_00120.join();
+            A5_Cycle_Bm_2_00120.join();
+            A6_Cycle_Bm_2_00120.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00120.check() && A2_Cycle_Bm_2_00120.check() && A3_Cycle_Bm_2_00120.check() && A4_Cycle_Bm_2_00120.check() && A5_Cycle_Bm_2_00120.check() && A6_Cycle_Bm_2_00120.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/Cycle_Bm_2_00130.java b/test/testsuite/ouroboros/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/Cycle_Bm_2_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..847abe60fe0dfc734cd610929d2f49b6c07f69c7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/Cycle_Bm_2_00130.java
@@ -0,0 +1,190 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00130 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00130.java
+ *- @ExecuteClass: Cycle_Bm_2_00130
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00130 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00130_A1 a1_0 = new Cycle_B_2_00130_A1();
+        a1_0.a2_0 = new Cycle_B_2_00130_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00130_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00130_A4();
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        Cycle_B_2_00130_A5 a5_0 = new Cycle_B_2_00130_A5();
+        a1_0.a2_0.a3_0.a4_0.a6_0 = new Cycle_B_2_00130_A6();
+        a1_0.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_0;
+        a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a6_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a5_0.sum + a1_0.a2_0.a3_0.a4_0.a6_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 45)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00130_A1 {
+        Cycle_B_2_00130_A2 a2_0;
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A2 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A3 {
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A4 {
+        Cycle_B_2_00130_A1 a1_0;
+        Cycle_B_2_00130_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A5 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A6 {
+        Cycle_B_2_00130_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00130 A1_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A2_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A3_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A4_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A5_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A6_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+
+        A1_Cycle_Bm_2_00130.start();
+        A2_Cycle_Bm_2_00130.start();
+        A3_Cycle_Bm_2_00130.start();
+        A4_Cycle_Bm_2_00130.start();
+        A5_Cycle_Bm_2_00130.start();
+        A6_Cycle_Bm_2_00130.start();
+
+        try {
+            A1_Cycle_Bm_2_00130.join();
+            A2_Cycle_Bm_2_00130.join();
+            A3_Cycle_Bm_2_00130.join();
+            A4_Cycle_Bm_2_00130.join();
+            A5_Cycle_Bm_2_00130.join();
+            A6_Cycle_Bm_2_00130.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00130.check() && A2_Cycle_Bm_2_00130.check() && A3_Cycle_Bm_2_00130.check() && A4_Cycle_Bm_2_00130.check() && A5_Cycle_Bm_2_00130.check() && A6_Cycle_Bm_2_00130.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/Cycle_Bm_2_00140.java b/test/testsuite/ouroboros/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/Cycle_Bm_2_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..801863d406a60d8d3786435494ea7069dc6babc3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/Cycle_Bm_2_00140.java
@@ -0,0 +1,135 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00140 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00140.java
+ *- @ExecuteClass: Cycle_Bm_2_00140
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00140 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00140_A1 a1_0 = new Cycle_B_2_00140_A1();
+        a1_0.a2_0 = new Cycle_B_2_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00140_A3();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00140_A1 {
+        Cycle_B_2_00140_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00140_A2 {
+        Cycle_B_2_00140_A3 a3_0;
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A2() {
+            a3_0 = null;
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00140_A3 {
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00140 A1_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A2_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A3_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A4_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A5_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A6_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+
+        A1_Cycle_Bm_2_00140.start();
+        A2_Cycle_Bm_2_00140.start();
+        A3_Cycle_Bm_2_00140.start();
+        A4_Cycle_Bm_2_00140.start();
+        A5_Cycle_Bm_2_00140.start();
+        A6_Cycle_Bm_2_00140.start();
+
+        try {
+            A1_Cycle_Bm_2_00140.join();
+            A2_Cycle_Bm_2_00140.join();
+            A3_Cycle_Bm_2_00140.join();
+            A4_Cycle_Bm_2_00140.join();
+            A5_Cycle_Bm_2_00140.join();
+            A6_Cycle_Bm_2_00140.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00140.check() && A2_Cycle_Bm_2_00140.check() && A3_Cycle_Bm_2_00140.check() && A4_Cycle_Bm_2_00140.check() && A5_Cycle_Bm_2_00140.check() && A6_Cycle_Bm_2_00140.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/Cycle_Bm_2_00150.java b/test/testsuite/ouroboros/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/Cycle_Bm_2_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..4b2a09bb8cbe86581a1620abf8adde7ee8ff4309
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/Cycle_Bm_2_00150.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00150 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00150.java
+ *- @ExecuteClass: Cycle_Bm_2_00150
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00150 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00150_A1 a1_0 = new Cycle_B_2_00150_A1();
+        a1_0.a2_0 = new Cycle_B_2_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 14)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00150_A1 {
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00150_A2 {
+        Cycle_B_2_00150_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00150_A3 {
+        Cycle_B_2_00150_A1 a1_0;
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00150 A1_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A2_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A3_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A4_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A5_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A6_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+
+        A1_Cycle_Bm_2_00150.start();
+        A2_Cycle_Bm_2_00150.start();
+        A3_Cycle_Bm_2_00150.start();
+        A4_Cycle_Bm_2_00150.start();
+        A5_Cycle_Bm_2_00150.start();
+        A6_Cycle_Bm_2_00150.start();
+
+        try {
+            A1_Cycle_Bm_2_00150.join();
+            A2_Cycle_Bm_2_00150.join();
+            A3_Cycle_Bm_2_00150.join();
+            A4_Cycle_Bm_2_00150.join();
+            A5_Cycle_Bm_2_00150.join();
+            A6_Cycle_Bm_2_00150.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00150.check() && A2_Cycle_Bm_2_00150.check() && A3_Cycle_Bm_2_00150.check() && A4_Cycle_Bm_2_00150.check() && A5_Cycle_Bm_2_00150.check() && A6_Cycle_Bm_2_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/Cycle_Bm_2_00160.java b/test/testsuite/ouroboros/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/Cycle_Bm_2_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1b11b88733d202937d7f5782f651778e6602f16
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/Cycle_Bm_2_00160.java
@@ -0,0 +1,133 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00160 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00160.java
+ *- @ExecuteClass: Cycle_Bm_2_00160
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00160 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00160_A1 a1_0 = new Cycle_B_2_00160_A1();
+        a1_0.a2_0 = new Cycle_B_2_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00160_A3();
+        a1_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00160_A1 {
+        Cycle_B_2_00160_A2 a2_0;
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00160_A2 {
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00160_A3 {
+        Cycle_B_2_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00160 A1_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A2_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A3_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A4_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A5_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A6_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+
+        A1_Cycle_Bm_2_00160.start();
+        A2_Cycle_Bm_2_00160.start();
+        A3_Cycle_Bm_2_00160.start();
+        A4_Cycle_Bm_2_00160.start();
+        A5_Cycle_Bm_2_00160.start();
+        A6_Cycle_Bm_2_00160.start();
+
+        try {
+            A1_Cycle_Bm_2_00160.join();
+            A2_Cycle_Bm_2_00160.join();
+            A3_Cycle_Bm_2_00160.join();
+            A4_Cycle_Bm_2_00160.join();
+            A5_Cycle_Bm_2_00160.join();
+            A6_Cycle_Bm_2_00160.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00160.check() && A2_Cycle_Bm_2_00160.check() && A3_Cycle_Bm_2_00160.check() && A4_Cycle_Bm_2_00160.check() && A5_Cycle_Bm_2_00160.check() && A6_Cycle_Bm_2_00160.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/Cycle_Bm_2_00170.java b/test/testsuite/ouroboros/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/Cycle_Bm_2_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..787e75ac07597b7755a0331fb4ffa815175cfc97
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/Cycle_Bm_2_00170.java
@@ -0,0 +1,150 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00170 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00170.java
+ *- @ExecuteClass: Cycle_Bm_2_00170
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00170 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00170_A1 a1_0 = new Cycle_B_2_00170_A1();
+        a1_0.a2_0 = new Cycle_B_2_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00170_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00170_A4();
+        a1_0.a2_0.a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00170_A1 {
+        Cycle_B_2_00170_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A2 {
+        Cycle_B_2_00170_A3 a3_0;
+        Cycle_B_2_00170_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A3 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A4 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00170 A1_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A2_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A3_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A4_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A5_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A6_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+
+        A1_Cycle_Bm_2_00170.start();
+        A2_Cycle_Bm_2_00170.start();
+        A3_Cycle_Bm_2_00170.start();
+        A4_Cycle_Bm_2_00170.start();
+        A5_Cycle_Bm_2_00170.start();
+        A6_Cycle_Bm_2_00170.start();
+
+        try {
+            A1_Cycle_Bm_2_00170.join();
+            A2_Cycle_Bm_2_00170.join();
+            A3_Cycle_Bm_2_00170.join();
+            A4_Cycle_Bm_2_00170.join();
+            A5_Cycle_Bm_2_00170.join();
+            A6_Cycle_Bm_2_00170.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00170.check() && A2_Cycle_Bm_2_00170.check() && A3_Cycle_Bm_2_00170.check() && A4_Cycle_Bm_2_00170.check() && A5_Cycle_Bm_2_00170.check() && A6_Cycle_Bm_2_00170.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/Cycle_Bm_2_00180.java b/test/testsuite/ouroboros/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/Cycle_Bm_2_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..947df82aa9a50f0efd50ad4c96c39a40991f7685
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/Cycle_Bm_2_00180.java
@@ -0,0 +1,150 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00180 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00180.java
+ *- @ExecuteClass: Cycle_Bm_2_00180
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00180_A1 a1_0 = new Cycle_B_2_00180_A1();
+        a1_0.a2_0 = new Cycle_B_2_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00180_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00180_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00180_A1 {
+        Cycle_B_2_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A2 {
+        Cycle_B_2_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A3 {
+        Cycle_B_2_00180_A1 a1_0;
+        Cycle_B_2_00180_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A4 {
+        Cycle_B_2_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00180 A1_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A2_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A3_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A4_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A5_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A6_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+
+        A1_Cycle_Bm_2_00180.start();
+        A2_Cycle_Bm_2_00180.start();
+        A3_Cycle_Bm_2_00180.start();
+        A4_Cycle_Bm_2_00180.start();
+        A5_Cycle_Bm_2_00180.start();
+        A6_Cycle_Bm_2_00180.start();
+
+        try {
+            A1_Cycle_Bm_2_00180.join();
+            A2_Cycle_Bm_2_00180.join();
+            A3_Cycle_Bm_2_00180.join();
+            A4_Cycle_Bm_2_00180.join();
+            A5_Cycle_Bm_2_00180.join();
+            A6_Cycle_Bm_2_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00180.check() && A2_Cycle_Bm_2_00180.check() && A3_Cycle_Bm_2_00180.check() && A4_Cycle_Bm_2_00180.check() && A5_Cycle_Bm_2_00180.check() && A6_Cycle_Bm_2_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/Cycle_Bm_2_00190.java b/test/testsuite/ouroboros/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/Cycle_Bm_2_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..19c1362aff41cad486d228a49808577fb68e2309
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/Cycle_Bm_2_00190.java
@@ -0,0 +1,150 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00190 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00190.java
+ *- @ExecuteClass: Cycle_Bm_2_00190
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00190 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00190_A1 a1_0 = new Cycle_B_2_00190_A1();
+        a1_0.a2_0 = new Cycle_B_2_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00190_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00190_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00190_A1 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A2 {
+        Cycle_B_2_00190_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A3 {
+        Cycle_B_2_00190_A1 a1_0;
+        Cycle_B_2_00190_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A4 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00190 A1_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A2_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A3_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A4_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A5_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A6_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+
+        A1_Cycle_Bm_2_00190.start();
+        A2_Cycle_Bm_2_00190.start();
+        A3_Cycle_Bm_2_00190.start();
+        A4_Cycle_Bm_2_00190.start();
+        A5_Cycle_Bm_2_00190.start();
+        A6_Cycle_Bm_2_00190.start();
+
+        try {
+            A1_Cycle_Bm_2_00190.join();
+            A2_Cycle_Bm_2_00190.join();
+            A3_Cycle_Bm_2_00190.join();
+            A4_Cycle_Bm_2_00190.join();
+            A5_Cycle_Bm_2_00190.join();
+            A6_Cycle_Bm_2_00190.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00190.check() && A2_Cycle_Bm_2_00190.check() && A3_Cycle_Bm_2_00190.check() && A4_Cycle_Bm_2_00190.check() && A5_Cycle_Bm_2_00190.check() && A6_Cycle_Bm_2_00190.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/Cycle_Bm_2_00200.java b/test/testsuite/ouroboros/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/Cycle_Bm_2_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..f020d80dc0430aa72409c0fc2dee2d2b2444d2ca
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/Cycle_Bm_2_00200.java
@@ -0,0 +1,151 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00200.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00200 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00200.java
+ *- @ExecuteClass: Cycle_Bm_2_00200
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00200 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00200_A1 a1_0 = new Cycle_B_2_00200_A1();
+        a1_0.a2_0 = new Cycle_B_2_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00200_A3();
+        Cycle_B_2_00200_A4 a4_0 = new Cycle_B_2_00200_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00200_A1 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A2 {
+        Cycle_B_2_00200_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A3 {
+        Cycle_B_2_00200_A1 a1_0;
+        Cycle_B_2_00200_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A4 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00200 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00200 A1_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A2_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A3_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A4_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A5_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A6_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+
+        A1_Cycle_Bm_2_00200.start();
+        A2_Cycle_Bm_2_00200.start();
+        A3_Cycle_Bm_2_00200.start();
+        A4_Cycle_Bm_2_00200.start();
+        A5_Cycle_Bm_2_00200.start();
+        A6_Cycle_Bm_2_00200.start();
+
+        try {
+            A1_Cycle_Bm_2_00200.join();
+            A2_Cycle_Bm_2_00200.join();
+            A3_Cycle_Bm_2_00200.join();
+            A4_Cycle_Bm_2_00200.join();
+            A5_Cycle_Bm_2_00200.join();
+            A6_Cycle_Bm_2_00200.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00200.check() && A2_Cycle_Bm_2_00200.check() && A3_Cycle_Bm_2_00200.check() && A4_Cycle_Bm_2_00200.check() && A5_Cycle_Bm_2_00200.check() && A6_Cycle_Bm_2_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/Cycle_Bm_2_00210.java b/test/testsuite/ouroboros/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/Cycle_Bm_2_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..e1ca30dc329413626180cfc8060809abc3217c75
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/Cycle_Bm_2_00210.java
@@ -0,0 +1,241 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00210.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00210 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00210.java
+ *- @ExecuteClass: Cycle_Bm_2_00210
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00210 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00210_A1 a1_0 = new Cycle_B_2_00210_A1();
+        a1_0.a2_0 = new Cycle_B_2_00210_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00210_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00210_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00210_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00210_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0 = new Cycle_B_2_00210_A8();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0 = new Cycle_B_2_00210_A9();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00210_A7();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00210_A1 {
+        Cycle_B_2_00210_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A2 {
+        Cycle_B_2_00210_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A3 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A4 {
+        Cycle_B_2_00210_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A5 {
+        Cycle_B_2_00210_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A6 {
+        Cycle_B_2_00210_A1 a1_0;
+        Cycle_B_2_00210_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A6() {
+            a1_0 = null;
+            a8_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A8 {
+        Cycle_B_2_00210_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A9 {
+        Cycle_B_2_00210_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A7 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00210 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00210 A1_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A2_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A3_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A4_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A5_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A6_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+
+        A1_Cycle_Bm_2_00210.start();
+        A2_Cycle_Bm_2_00210.start();
+        A3_Cycle_Bm_2_00210.start();
+        A4_Cycle_Bm_2_00210.start();
+        A5_Cycle_Bm_2_00210.start();
+        A6_Cycle_Bm_2_00210.start();
+
+        try {
+            A1_Cycle_Bm_2_00210.join();
+            A2_Cycle_Bm_2_00210.join();
+            A3_Cycle_Bm_2_00210.join();
+            A4_Cycle_Bm_2_00210.join();
+            A5_Cycle_Bm_2_00210.join();
+            A6_Cycle_Bm_2_00210.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00210.check() && A2_Cycle_Bm_2_00210.check() && A3_Cycle_Bm_2_00210.check() && A4_Cycle_Bm_2_00210.check() && A5_Cycle_Bm_2_00210.check() && A6_Cycle_Bm_2_00210.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/Cycle_Bm_2_00220.java b/test/testsuite/ouroboros/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/Cycle_Bm_2_00220.java
new file mode 100755
index 0000000000000000000000000000000000000000..0023efe41cf7eaabb20974895f7c3712106de0ac
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/Cycle_Bm_2_00220.java
@@ -0,0 +1,241 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00220.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00220 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00220.java
+ *- @ExecuteClass: Cycle_Bm_2_00220
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00220 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00220_A1 a1_0 = new Cycle_B_2_00220_A1();
+        a1_0.a2_0 = new Cycle_B_2_00220_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00220_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00220_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00220_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00220_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a8_0 = new Cycle_B_2_00220_A8();
+        a1_0.a8_0.a9_0 = new Cycle_B_2_00220_A9();
+        a1_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00220_A7();
+        a1_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a8_0.add();
+        a1_0.a8_0.a9_0.add();
+        a1_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a8_0.sum + a1_0.a8_0.a9_0.sum + a1_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00220_A1 {
+        Cycle_B_2_00220_A2 a2_0;
+        Cycle_B_2_00220_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A1() {
+            a2_0 = null;
+            a8_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A2 {
+        Cycle_B_2_00220_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A3 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A4 {
+        Cycle_B_2_00220_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A5 {
+        Cycle_B_2_00220_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A6 {
+        Cycle_B_2_00220_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A6() {
+            a1_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A8 {
+        Cycle_B_2_00220_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A9 {
+        Cycle_B_2_00220_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A7 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00220 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00220 A1_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A2_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A3_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A4_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A5_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A6_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+
+        A1_Cycle_Bm_2_00220.start();
+        A2_Cycle_Bm_2_00220.start();
+        A3_Cycle_Bm_2_00220.start();
+        A4_Cycle_Bm_2_00220.start();
+        A5_Cycle_Bm_2_00220.start();
+        A6_Cycle_Bm_2_00220.start();
+
+        try {
+            A1_Cycle_Bm_2_00220.join();
+            A2_Cycle_Bm_2_00220.join();
+            A3_Cycle_Bm_2_00220.join();
+            A4_Cycle_Bm_2_00220.join();
+            A5_Cycle_Bm_2_00220.join();
+            A6_Cycle_Bm_2_00220.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00220.check() && A2_Cycle_Bm_2_00220.check() && A3_Cycle_Bm_2_00220.check() && A4_Cycle_Bm_2_00220.check() && A5_Cycle_Bm_2_00220.check() && A6_Cycle_Bm_2_00220.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/Cycle_Bm_2_00230.java b/test/testsuite/ouroboros/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/Cycle_Bm_2_00230.java
new file mode 100755
index 0000000000000000000000000000000000000000..48e5897565c65c555eb504dccb730baf2e681576
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/Cycle_Bm_2_00230.java
@@ -0,0 +1,261 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00230.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Cycle_B_2_00230 in RC测试-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00230.java
+ *- @ExecuteClass: Cycle_Bm_2_00230
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00230 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        //System.out.println(nsum);
+
+        if (nsum == 97)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00230_A1 {
+        Cycle_B_2_00230_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A2 {
+        Cycle_B_2_00230_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A3 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A4 {
+        Cycle_B_2_00230_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A5 {
+        Cycle_B_2_00230_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A6 {
+        Cycle_B_2_00230_A1 a1_0;
+        Cycle_B_2_00230_A10 a10_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A6() {
+            a1_0 = null;
+            a10_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A8 {
+        Cycle_B_2_00230_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A9 {
+        Cycle_B_2_00230_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A7 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A10 {
+        Cycle_B_2_00230_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A10() {
+            a8_0 = null;
+            a = 10;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_00230 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00230 A1_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A2_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A3_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A4_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A5_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A6_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+
+        A1_Cycle_Bm_2_00230.start();
+        A2_Cycle_Bm_2_00230.start();
+        A3_Cycle_Bm_2_00230.start();
+        A4_Cycle_Bm_2_00230.start();
+        A5_Cycle_Bm_2_00230.start();
+        A6_Cycle_Bm_2_00230.start();
+
+        try {
+            A1_Cycle_Bm_2_00230.join();
+            A2_Cycle_Bm_2_00230.join();
+            A3_Cycle_Bm_2_00230.join();
+            A4_Cycle_Bm_2_00230.join();
+            A5_Cycle_Bm_2_00230.join();
+            A6_Cycle_Bm_2_00230.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00230.check() && A2_Cycle_Bm_2_00230.check() && A3_Cycle_Bm_2_00230.check() && A4_Cycle_Bm_2_00230.check() && A5_Cycle_Bm_2_00230.check() && A6_Cycle_Bm_2_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/Cycle_Bm_2_00240.java b/test/testsuite/ouroboros/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/Cycle_Bm_2_00240.java
new file mode 100755
index 0000000000000000000000000000000000000000..fc59f25614f5c83d8d5b3dcc497e86b20254269e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/Cycle_Bm_2_00240.java
@@ -0,0 +1,2754 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_00240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Make Cycle_B_2_00240 together to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_00240.java
+ *- @ExecuteClass: Cycle_Bm_2_00240
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_00010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00010_A1 a1_0 = new Cycle_B_2_00010_A1();
+        a1_0.a2_0 = new Cycle_B_2_00010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00010_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00010_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 18)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00010_A1 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A2 {
+        Cycle_B_2_00010_A3 a3_0;
+        Cycle_B_2_00010_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A3 {
+        Cycle_B_2_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00010_A4 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00010_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00020_A1 a1_0 = new Cycle_B_2_00020_A1();
+        a1_0.a2_0 = new Cycle_B_2_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00020_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00020_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00020_A1 {
+        Cycle_B_2_00020_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A2 {
+        Cycle_B_2_00020_A3 a3_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A3 {
+        Cycle_B_2_00020_A1 a1_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00020_A4 {
+        Cycle_B_2_00020_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00020_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00030B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00030_A1 a1_0 = new Cycle_B_2_00030_A1();
+        a1_0.a2_0 = new Cycle_B_2_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00030_A3();
+        Cycle_B_2_00030_A4 a4_0 = new Cycle_B_2_00030_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00030_A1 {
+        Cycle_B_2_00030_A2 a2_0;
+        Cycle_B_2_00030_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A2 {
+        Cycle_B_2_00030_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A3 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00030_A4 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00030_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00040B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00040_A1 a1_0 = new Cycle_B_2_00040_A1();
+        a1_0.a2_0 = new Cycle_B_2_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00040_A3();
+        Cycle_B_2_00040_A4 a4_0 = new Cycle_B_2_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00040_A1 {
+        Cycle_B_2_00040_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A2 {
+        Cycle_B_2_00040_A3 a3_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A3 {
+        Cycle_B_2_00040_A1 a1_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00040_A4 {
+        Cycle_B_2_00040_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00040_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00050B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00050_A1 a1_0 = new Cycle_B_2_00050_A1();
+        a1_0.a2_0 = new Cycle_B_2_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00050_A3();
+        Cycle_B_2_00050_A4 a4_0 = new Cycle_B_2_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00050_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00050_A1 {
+        Cycle_B_2_00050_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A2 {
+        Cycle_B_2_00050_A3 a3_0;
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A3 {
+        Cycle_B_2_00050_A1 a1_0;
+        Cycle_B_2_00050_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A4 {
+        Cycle_B_2_00050_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00050_A5 {
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00050_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00060B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00060_A1 a1_0 = new Cycle_B_2_00060_A1();
+        a1_0.a2_0 = new Cycle_B_2_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00060_A3();
+        Cycle_B_2_00060_A4 a4_0 = new Cycle_B_2_00060_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00060_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00060_A1 {
+        Cycle_B_2_00060_A2 a2_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A2 {
+        Cycle_B_2_00060_A3 a3_0;
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A3 {
+        Cycle_B_2_00060_A1 a1_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A4 {
+        Cycle_B_2_00060_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00060_A5 {
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00060_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00070B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00070_A1 a1_0 = new Cycle_B_2_00070_A1();
+        a1_0.a2_0 = new Cycle_B_2_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00070_A3();
+        Cycle_B_2_00070_A4 a4_0 = new Cycle_B_2_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00070_A5();
+        Cycle_B_2_00070_A6 a6_0 = new Cycle_B_2_00070_A6();
+        a6_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a6_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum + a6_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 37)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00070_A1 {
+        Cycle_B_2_00070_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A2 {
+        Cycle_B_2_00070_A3 a3_0;
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A3 {
+        Cycle_B_2_00070_A1 a1_0;
+        Cycle_B_2_00070_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A4 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A5 {
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00070_A6 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00070_A6() {
+            a3_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00080B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00080_A1 {
+        Cycle_B_2_00080_A2 a2_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A2 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A3 {
+        Cycle_B_2_00080_A1 a1_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A4 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A4() {
+            a3_0 = null;
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A5 {
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00090B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00090_A1 a1_0 = new Cycle_B_2_00090_A1();
+        Cycle_B_2_00090_A3 a3_0 = new Cycle_B_2_00090_A3();
+        a1_0.a2_0 = new Cycle_B_2_00090_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a3_0.a2_0 = a1_0.a2_0;
+        a3_0.a2_0.a3_0 = a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 9)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00090_A1 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00090_A2 {
+        Cycle_B_2_00090_A1 a1_0;
+        Cycle_B_2_00090_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A2() {
+            a1_0 = null;
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00090_A3 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00090_A3() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00100B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00100_A1 a1_0 = new Cycle_B_2_00100_A1();
+        a1_0.a2_0 = new Cycle_B_2_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00100_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00100_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00100_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 29)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00100_A1 {
+        Cycle_B_2_00100_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A2 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A3 {
+        Cycle_B_2_00100_A1 a1_0;
+        Cycle_B_2_00100_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A4 {
+        Cycle_B_2_00100_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00100_A5 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00100_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00110B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00110_A1 a1_0 = new Cycle_B_2_00110_A1();
+        a1_0.a2_0 = new Cycle_B_2_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00110_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00110_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_2_00110_A5();
+        a1_0.a2_0.a4_0.a5_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00110_A1 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A2 {
+        Cycle_B_2_00110_A3 a3_0;
+        Cycle_B_2_00110_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A3 {
+        Cycle_B_2_00110_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A4 {
+        Cycle_B_2_00110_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00110_A5 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00110_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00120B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00120_A1 a1_0 = new Cycle_B_2_00120_A1();
+        a1_0.a2_0 = new Cycle_B_2_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00120_A3();
+        a1_0.a4_0 = new Cycle_B_2_00120_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a4_0.a5_0 = new Cycle_B_2_00120_A5();
+        a1_0.a4_0.a5_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a4_0.add();
+        a1_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a4_0.sum + a1_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00120_A1 {
+        Cycle_B_2_00120_A2 a2_0;
+        Cycle_B_2_00120_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A2 {
+        Cycle_B_2_00120_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A3 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A4 {
+        Cycle_B_2_00120_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00120_A5 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00120_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00130B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00130_A1 a1_0 = new Cycle_B_2_00130_A1();
+        a1_0.a2_0 = new Cycle_B_2_00130_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00130_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00130_A4();
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        Cycle_B_2_00130_A5 a5_0 = new Cycle_B_2_00130_A5();
+        a1_0.a2_0.a3_0.a4_0.a6_0 = new Cycle_B_2_00130_A6();
+        a1_0.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_0;
+        a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a6_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a5_0.sum + a1_0.a2_0.a3_0.a4_0.a6_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 45)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00130_A1 {
+        Cycle_B_2_00130_A2 a2_0;
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A2 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A3 {
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A4 {
+        Cycle_B_2_00130_A1 a1_0;
+        Cycle_B_2_00130_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A5 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00130_A6 {
+        Cycle_B_2_00130_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00130_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00140B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00140_A1 a1_0 = new Cycle_B_2_00140_A1();
+        a1_0.a2_0 = new Cycle_B_2_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00140_A3();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00140_A1 {
+        Cycle_B_2_00140_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00140_A2 {
+        Cycle_B_2_00140_A3 a3_0;
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A2() {
+            a3_0 = null;
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00140_A3 {
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00150B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00150_A1 a1_0 = new Cycle_B_2_00150_A1();
+        a1_0.a2_0 = new Cycle_B_2_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 14)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00150_A1 {
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00150_A2 {
+        Cycle_B_2_00150_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00150_A3 {
+        Cycle_B_2_00150_A1 a1_0;
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00150_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00160B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00160_A1 a1_0 = new Cycle_B_2_00160_A1();
+        a1_0.a2_0 = new Cycle_B_2_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00160_A3();
+        a1_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00160_A1 {
+        Cycle_B_2_00160_A2 a2_0;
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00160_A2 {
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00160_A3 {
+        Cycle_B_2_00160_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+class ThreadRc_Cycle_Bm_2_00170B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00170_A1 a1_0 = new Cycle_B_2_00170_A1();
+        a1_0.a2_0 = new Cycle_B_2_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00170_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00170_A4();
+        a1_0.a2_0.a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00170_A1 {
+        Cycle_B_2_00170_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A2 {
+        Cycle_B_2_00170_A3 a3_0;
+        Cycle_B_2_00170_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A3 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00170_A4 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00180B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00180_A1 a1_0 = new Cycle_B_2_00180_A1();
+        a1_0.a2_0 = new Cycle_B_2_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00180_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00180_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00180_A1 {
+        Cycle_B_2_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A2 {
+        Cycle_B_2_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A3 {
+        Cycle_B_2_00180_A1 a1_0;
+        Cycle_B_2_00180_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00180_A4 {
+        Cycle_B_2_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00180_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00190B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00190_A1 a1_0 = new Cycle_B_2_00190_A1();
+        a1_0.a2_0 = new Cycle_B_2_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00190_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00190_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00190_A1 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A2 {
+        Cycle_B_2_00190_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A3 {
+        Cycle_B_2_00190_A1 a1_0;
+        Cycle_B_2_00190_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00190_A4 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00190_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+class ThreadRc_Cycle_Bm_2_00200B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00200_A1 a1_0 = new Cycle_B_2_00200_A1();
+        a1_0.a2_0 = new Cycle_B_2_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00200_A3();
+        Cycle_B_2_00200_A4 a4_0 = new Cycle_B_2_00200_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00200_A1 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A2 {
+        Cycle_B_2_00200_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A3 {
+        Cycle_B_2_00200_A1 a1_0;
+        Cycle_B_2_00200_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00200_A4 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00200_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+
+
+class ThreadRc_Cycle_Bm_2_00210B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00210_A1 a1_0 = new Cycle_B_2_00210_A1();
+        a1_0.a2_0 = new Cycle_B_2_00210_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00210_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00210_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00210_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00210_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0 = new Cycle_B_2_00210_A8();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0 = new Cycle_B_2_00210_A9();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00210_A7();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00210_A1 {
+        Cycle_B_2_00210_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A2 {
+        Cycle_B_2_00210_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A3 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A4 {
+        Cycle_B_2_00210_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A5 {
+        Cycle_B_2_00210_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A6 {
+        Cycle_B_2_00210_A1 a1_0;
+        Cycle_B_2_00210_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A6() {
+            a1_0 = null;
+            a8_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A8 {
+        Cycle_B_2_00210_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A9 {
+        Cycle_B_2_00210_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00210_A7 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00210_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00220B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00220_A1 a1_0 = new Cycle_B_2_00220_A1();
+        a1_0.a2_0 = new Cycle_B_2_00220_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00220_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00220_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00220_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00220_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a8_0 = new Cycle_B_2_00220_A8();
+        a1_0.a8_0.a9_0 = new Cycle_B_2_00220_A9();
+        a1_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00220_A7();
+        a1_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a8_0.add();
+        a1_0.a8_0.a9_0.add();
+        a1_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a8_0.sum + a1_0.a8_0.a9_0.sum + a1_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00220_A1 {
+        Cycle_B_2_00220_A2 a2_0;
+        Cycle_B_2_00220_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A1() {
+            a2_0 = null;
+            a8_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A2 {
+        Cycle_B_2_00220_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A3 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A4 {
+        Cycle_B_2_00220_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A5 {
+        Cycle_B_2_00220_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A6 {
+        Cycle_B_2_00220_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A6() {
+            a1_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A8 {
+        Cycle_B_2_00220_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A9 {
+        Cycle_B_2_00220_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00220_A7 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00220_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+class ThreadRc_Cycle_Bm_2_00230B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        //System.out.println(nsum);
+
+        if (nsum == 97)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00230_A1 {
+        Cycle_B_2_00230_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A2 {
+        Cycle_B_2_00230_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A3 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A4 {
+        Cycle_B_2_00230_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A5 {
+        Cycle_B_2_00230_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A6 {
+        Cycle_B_2_00230_A1 a1_0;
+        Cycle_B_2_00230_A10 a10_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A6() {
+            a1_0 = null;
+            a10_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A8 {
+        Cycle_B_2_00230_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A9 {
+        Cycle_B_2_00230_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A7 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A10 {
+        Cycle_B_2_00230_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A10() {
+            a8_0 = null;
+            a = 10;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+public class Cycle_Bm_2_00240 {
+
+    public static void main(String[] args) {
+    rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00010B A1_00010 = new ThreadRc_Cycle_Bm_2_00010B();
+        ThreadRc_Cycle_Bm_2_00010B A2_00010 = new ThreadRc_Cycle_Bm_2_00010B();
+        ThreadRc_Cycle_Bm_2_00020B A1_00020 = new ThreadRc_Cycle_Bm_2_00020B();
+        ThreadRc_Cycle_Bm_2_00020B A2_00020 = new ThreadRc_Cycle_Bm_2_00020B();
+        ThreadRc_Cycle_Bm_2_00030B A1_00030 = new ThreadRc_Cycle_Bm_2_00030B();
+        ThreadRc_Cycle_Bm_2_00030B A2_00030 = new ThreadRc_Cycle_Bm_2_00030B();
+        ThreadRc_Cycle_Bm_2_00040B A1_00040 = new ThreadRc_Cycle_Bm_2_00040B();
+        ThreadRc_Cycle_Bm_2_00040B A2_00040 = new ThreadRc_Cycle_Bm_2_00040B();
+        ThreadRc_Cycle_Bm_2_00050B A1_00050 = new ThreadRc_Cycle_Bm_2_00050B();
+        ThreadRc_Cycle_Bm_2_00050B A2_00050 = new ThreadRc_Cycle_Bm_2_00050B();
+        ThreadRc_Cycle_Bm_2_00060B A1_00060 = new ThreadRc_Cycle_Bm_2_00060B();
+        ThreadRc_Cycle_Bm_2_00060B A2_00060 = new ThreadRc_Cycle_Bm_2_00060B();
+        ThreadRc_Cycle_Bm_2_00070B A1_00070 = new ThreadRc_Cycle_Bm_2_00070B();
+        ThreadRc_Cycle_Bm_2_00070B A2_00070 = new ThreadRc_Cycle_Bm_2_00070B();
+        ThreadRc_Cycle_Bm_2_00080B A1_00080 = new ThreadRc_Cycle_Bm_2_00080B();
+        ThreadRc_Cycle_Bm_2_00080B A2_00080 = new ThreadRc_Cycle_Bm_2_00080B();
+        ThreadRc_Cycle_Bm_2_00090B A1_00090 = new ThreadRc_Cycle_Bm_2_00090B();
+        ThreadRc_Cycle_Bm_2_00090B A2_00090 = new ThreadRc_Cycle_Bm_2_00090B();
+        ThreadRc_Cycle_Bm_2_00100B A1_00100 = new ThreadRc_Cycle_Bm_2_00100B();
+        ThreadRc_Cycle_Bm_2_00100B A2_00100 = new ThreadRc_Cycle_Bm_2_00100B();
+        ThreadRc_Cycle_Bm_2_00110B A1_00110 = new ThreadRc_Cycle_Bm_2_00110B();
+        ThreadRc_Cycle_Bm_2_00110B A2_00110 = new ThreadRc_Cycle_Bm_2_00110B();
+        ThreadRc_Cycle_Bm_2_00120B A1_00120 = new ThreadRc_Cycle_Bm_2_00120B();
+        ThreadRc_Cycle_Bm_2_00120B A2_00120 = new ThreadRc_Cycle_Bm_2_00120B();
+        ThreadRc_Cycle_Bm_2_00130B A1_00130 = new ThreadRc_Cycle_Bm_2_00130B();
+        ThreadRc_Cycle_Bm_2_00130B A2_00130 = new ThreadRc_Cycle_Bm_2_00130B();
+        ThreadRc_Cycle_Bm_2_00140B A1_00140 = new ThreadRc_Cycle_Bm_2_00140B();
+        ThreadRc_Cycle_Bm_2_00140B A2_00140 = new ThreadRc_Cycle_Bm_2_00140B();
+        ThreadRc_Cycle_Bm_2_00150B A1_00150 = new ThreadRc_Cycle_Bm_2_00150B();
+        ThreadRc_Cycle_Bm_2_00150B A2_00150 = new ThreadRc_Cycle_Bm_2_00150B();
+        ThreadRc_Cycle_Bm_2_00160B A1_00160 = new ThreadRc_Cycle_Bm_2_00160B();
+        ThreadRc_Cycle_Bm_2_00160B A2_00160 = new ThreadRc_Cycle_Bm_2_00160B();
+        ThreadRc_Cycle_Bm_2_00170B A1_00170 = new ThreadRc_Cycle_Bm_2_00170B();
+        ThreadRc_Cycle_Bm_2_00170B A2_00170 = new ThreadRc_Cycle_Bm_2_00170B();
+        ThreadRc_Cycle_Bm_2_00180B A1_00180 = new ThreadRc_Cycle_Bm_2_00180B();
+        ThreadRc_Cycle_Bm_2_00180B A2_00180 = new ThreadRc_Cycle_Bm_2_00180B();
+        ThreadRc_Cycle_Bm_2_00190B A1_00190 = new ThreadRc_Cycle_Bm_2_00190B();
+        ThreadRc_Cycle_Bm_2_00190B A2_00190 = new ThreadRc_Cycle_Bm_2_00190B();
+        ThreadRc_Cycle_Bm_2_00200B A1_00200 = new ThreadRc_Cycle_Bm_2_00200B();
+        ThreadRc_Cycle_Bm_2_00200B A2_00200 = new ThreadRc_Cycle_Bm_2_00200B();
+        ThreadRc_Cycle_Bm_2_00210B A1_00210 = new ThreadRc_Cycle_Bm_2_00210B();
+        ThreadRc_Cycle_Bm_2_00210B A2_00210 = new ThreadRc_Cycle_Bm_2_00210B();
+        ThreadRc_Cycle_Bm_2_00220B A1_00220 = new ThreadRc_Cycle_Bm_2_00220B();
+        ThreadRc_Cycle_Bm_2_00220B A2_00220 = new ThreadRc_Cycle_Bm_2_00220B();
+        ThreadRc_Cycle_Bm_2_00230B A1_00230 = new ThreadRc_Cycle_Bm_2_00230B();
+        ThreadRc_Cycle_Bm_2_00230B A2_00230 = new ThreadRc_Cycle_Bm_2_00230B();
+        A1_00010.start();
+        A2_00010.start();
+        A1_00020.start();
+        A2_00020.start();
+        A1_00030.start();
+        A2_00030.start();
+        A1_00040.start();
+        A2_00040.start();
+        A1_00050.start();
+        A2_00050.start();
+        A1_00060.start();
+        A2_00060.start();
+        A1_00070.start();
+        A2_00070.start();
+        A1_00080.start();
+        A2_00080.start();
+        A1_00090.start();
+        A2_00090.start();
+        A1_00100.start();
+        A2_00100.start();
+        A1_00110.start();
+        A2_00110.start();
+        A1_00120.start();
+        A2_00120.start();
+        A1_00130.start();
+        A2_00130.start();
+        A1_00140.start();
+        A2_00140.start();
+        A1_00150.start();
+        A2_00150.start();
+        A1_00160.start();
+        A2_00160.start();
+        A1_00170.start();
+        A2_00170.start();
+        A1_00180.start();
+        A2_00180.start();
+        A1_00190.start();
+        A2_00190.start();
+        A1_00200.start();
+        A2_00200.start();
+        A1_00210.start();
+        A2_00210.start();
+        A1_00220.start();
+        A2_00220.start();
+        A1_00230.start();
+        A2_00230.start();
+        try {
+            A1_00010.join();
+            A2_00010.join();
+            A1_00020.join();
+            A2_00020.join();
+            A1_00030.join();
+            A2_00030.join();
+            A1_00040.join();
+            A2_00040.join();
+            A1_00050.join();
+            A2_00050.join();
+            A1_00060.join();
+            A2_00060.join();
+            A1_00070.join();
+            A2_00070.join();
+            A1_00080.join();
+            A2_00080.join();
+            A1_00090.join();
+            A2_00090.join();
+            A1_00100.join();
+            A2_00100.join();
+            A1_00110.join();
+            A2_00110.join();
+            A1_00120.join();
+            A2_00120.join();
+            A1_00130.join();
+            A2_00130.join();
+            A1_00140.join();
+            A2_00140.join();
+            A1_00150.join();
+            A2_00150.join();
+            A1_00160.join();
+            A2_00160.join();
+            A1_00170.join();
+            A2_00170.join();
+            A1_00180.join();
+            A2_00180.join();
+            A1_00190.join();
+            A2_00190.join();
+            A1_00200.join();
+            A2_00200.join();
+            A1_00210.join();
+            A2_00210.join();
+            A1_00220.join();
+            A2_00220.join();
+            A1_00230.join();
+            A2_00230.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00010.check() && A2_00010.check() && A1_00020.check() && A2_00020.check() && A1_00030.check() && A2_00030.check() && A1_00040.check() && A2_00040.check() && A1_00050.check() && A2_00050.check() && A1_00060.check() && A2_00060.check() && A1_00070.check() && A2_00070.check() && A1_00080.check() && A2_00080.check() && A1_00090.check() && A2_00090.check() && A1_00100.check() && A2_00100.check() && A1_00110.check() && A2_00110.check() && A1_00120.check() && A2_00120.check() && A1_00130.check() && A2_00130.check() && A1_00140.check() && A2_00140.check() && A1_00150.check() && A2_00150.check() && A1_00160.check() && A2_00160.check() && A1_00170.check() && A2_00170.check() && A1_00180.check() && A2_00180.check() && A1_00190.check() && A2_00190.check() && A1_00200.check() && A2_00200.check() && A1_00210.check() && A2_00210.check() && A1_00220.check() && A2_00220.check() && A1_00230.check() && A2_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/Cycle_Bm_2_10240.java b/test/testsuite/ouroboros/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/Cycle_Bm_2_10240.java
new file mode 100755
index 0000000000000000000000000000000000000000..3e372c16b4f38767cf9ef9eccaf2c864ff0088cc
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/Cycle_Bm_2_10240.java
@@ -0,0 +1,275 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Cycle_Bm_2_10240.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Make Cycle_B_2_10240 together to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Cycle_Bm_2_10240.java
+ *- @ExecuteClass: Cycle_Bm_2_10240
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Cycle_Bm_2_10240 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00240_A1 a1_main = new Cycle_B_2_00240_A1("a1_main");
+        a1_main.a2_0 = new Cycle_B_2_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_B_2_00240_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_B_2_00240_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+
+
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        Cycle_B_2_00240_B1 b1_0 = new Cycle_B_2_00240_B1();
+        b1_0.a3_0 = new Cycle_B_2_00240_A3("a3_b1");
+        b1_0.b2_0 = new Cycle_B_2_00240_B2();
+        b1_0.c2_0 = new Nocycle_B_2_00240_C2("c2_b1");
+        b1_0.b2_0.b1_0 = b1_0;
+        b1_0.add();
+        b1_0.b2_0.add();
+
+        int nsum = (b1_0.sum + b1_0.b2_0.sum);
+        // System.out.println(nsum);
+
+
+        Nocycle_B_2_00240_C1 c1_main = new Nocycle_B_2_00240_C1("c1_main");
+        c1_main.c2_0 = new Nocycle_B_2_00240_C2("c2_0");
+        c1_main.add();
+        c1_main.c2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",c1_main.sum+c1_main.b1_0.sum);
+        int result2 = c1_main.sum + c1_main.c2_0.sum;
+        //System.out.println("RC-Testing_Result="+result2);
+
+        if (result == 1124 && nsum == 310 && result2 == 704)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00240_A1 {
+        Cycle_B_2_00240_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_B_2_00240_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_A2 {
+        Cycle_B_2_00240_A1 a1_0;
+        Cycle_B_2_00240_A3 a3_0;
+        Cycle_B_2_00240_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_B_2_00240_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_A3 {
+        Cycle_B_2_00240_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_B_2_00240_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_A4 {
+        Cycle_B_2_00240_A1 a1_0;
+        Cycle_B_2_00240_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_B_2_00240_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_B1 {
+        Cycle_B_2_00240_A3 a3_0;
+        Cycle_B_2_00240_B2 b2_0;
+        Nocycle_B_2_00240_C2 c2_0;
+
+
+        int a;
+        int sum;
+
+        Cycle_B_2_00240_B1() {
+            a3_0 = null;
+            b2_0 = null;
+            c2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00240_B2 {
+        Cycle_B_2_00240_B1 b1_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00240_B2() {
+            b1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_B_2_00240_C1 {
+        Nocycle_B_2_00240_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_B_2_00240_C1(String strObjectName) {
+            c2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + c2_0.a;
+        }
+    }
+
+    class Nocycle_B_2_00240_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_B_2_00240_C2(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Cycle_Bm_2_10240 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_10240 A1_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A2_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A3_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A4_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A5_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A6_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+
+        A1_Cycle_Bm_2_10240.start();
+        A2_Cycle_Bm_2_10240.start();
+        A3_Cycle_Bm_2_10240.start();
+        A4_Cycle_Bm_2_10240.start();
+        A5_Cycle_Bm_2_10240.start();
+        A6_Cycle_Bm_2_10240.start();
+
+        try {
+            A1_Cycle_Bm_2_10240.join();
+            A2_Cycle_Bm_2_10240.join();
+            A3_Cycle_Bm_2_10240.join();
+            A4_Cycle_Bm_2_10240.join();
+            A5_Cycle_Bm_2_10240.join();
+            A6_Cycle_Bm_2_10240.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_10240.check() && A2_Cycle_Bm_2_10240.check() && A3_Cycle_Bm_2_10240.check() && A4_Cycle_Bm_2_10240.check() && A5_Cycle_Bm_2_10240.check() && A6_Cycle_Bm_2_10240.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/Nocycle_am_00010.java b/test/testsuite/ouroboros/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/Nocycle_am_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..c112ca54380f20d96805924a35a672b645052733
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/Nocycle_am_00010.java
@@ -0,0 +1,119 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00010 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00010.java
+ *- @ExecuteClass: Nocycle_am_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_am_00010_A1 a1_main = new Nocycle_am_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_am_00010_B1("b1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum;
+        // System.out.println("RC-Testing_Result_Thread="+result);
+        if (result == 704)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_am_00010_A1 {
+        Nocycle_am_00010_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_am_00010_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_am_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_am_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00010 t_00010 = new ThreadRc_00010();
+        t_00010.start();
+        ThreadRc_00010 t_00020 = new ThreadRc_00010();
+        t_00020.start();
+        ThreadRc_00010 t_00030 = new ThreadRc_00010();
+        t_00030.start();
+        ThreadRc_00010 t_00040 = new ThreadRc_00010();
+        t_00040.start();
+        ThreadRc_00010 t_00050 = new ThreadRc_00010();
+        t_00050.start();
+        ThreadRc_00010 t_00060 = new ThreadRc_00010();
+        t_00060.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+            t_00040.join();
+            t_00050.join();
+            t_00060.join();
+        } catch (InterruptedException e) {
+        }
+
+        if (t_00010.check() == true && t_00060.check() == true && t_00020.check() == true && t_00030.check() == true && t_00040.check() == true && t_00050.check() == true)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/Nocycle_am_00020.java b/test/testsuite/ouroboros/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/Nocycle_am_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..2ac170247f25659acbdf503a7132541d44b4b51e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/Nocycle_am_00020.java
@@ -0,0 +1,136 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00020 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00020.java
+ *- @ExecuteClass: Nocycle_am_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00020_A1 a1_main = new Nocycle_a_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00020_B2("b2_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 1310)
+            checkout = true;
+        //System.out.println(checkout);
+
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00020_A1 {
+        Nocycle_a_00020_B1 b1_0;
+        Nocycle_a_00020_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00020 A1_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A2_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A3_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A4_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A5_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A6_00020 = new ThreadRc_00020();
+
+        A1_00020.start();
+        A2_00020.start();
+        A3_00020.start();
+        A4_00020.start();
+        A5_00020.start();
+        A6_00020.start();
+        try {
+            A1_00020.join();
+            A2_00020.join();
+            A3_00020.join();
+            A4_00020.join();
+            A5_00020.join();
+            A6_00020.join();
+        } catch (InterruptedException e) {
+        }
+
+        if (A1_00020.check() && A2_00020.check() && A3_00020.check() && A4_00020.check() && A5_00020.check() && A6_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/Nocycle_am_00030.java b/test/testsuite/ouroboros/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/Nocycle_am_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..f63e22451e10af7e7d4ffd26df9180d5a4938f12
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/Nocycle_am_00030.java
@@ -0,0 +1,155 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00030 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00030.java
+ *- @ExecuteClass: Nocycle_am_00030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00030 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00030_A1 a1_main = new Nocycle_a_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00030_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00030_B3("b3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 1919)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00030_A1 {
+        Nocycle_a_00030_B1 b1_0;
+        Nocycle_a_00030_B2 b2_0;
+        Nocycle_a_00030_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00030_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00030_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00030_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00030 A1_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A2_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A3_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A4_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A5_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A6_00030 = new ThreadRc_00030();
+
+        A1_00030.start();
+        A2_00030.start();
+        A3_00030.start();
+        A4_00030.start();
+        A5_00030.start();
+        A6_00030.start();
+        try {
+            A1_00030.join();
+            A2_00030.join();
+            A3_00030.join();
+            A4_00030.join();
+            A5_00030.join();
+            A6_00030.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00030.check() && A2_00030.check() && A3_00030.check() && A4_00030.check() && A5_00030.check() && A6_00030.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/Nocycle_am_00040.java b/test/testsuite/ouroboros/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/Nocycle_am_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..df192dd13eb87049dcb074d0d1684acf15d5b49b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/Nocycle_am_00040.java
@@ -0,0 +1,301 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00040.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00040 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00040.java
+ *- @ExecuteClass: Nocycle_am_00040
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00040 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00040_A1 a1_main = new Nocycle_a_00040_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00040_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00040_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00040_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00040_B4("b4_0");
+        a1_main.b5_0 = new Nocycle_a_00040_B5("b5_0");
+        a1_main.b6_0 = new Nocycle_a_00040_B6("b6_0");
+        a1_main.b7_0 = new Nocycle_a_00040_B7("b7_0");
+        a1_main.b8_0 = new Nocycle_a_00040_B8("b8_0");
+        a1_main.b9_0 = new Nocycle_a_00040_B9("b9_0");
+        a1_main.b10_0 = new Nocycle_a_00040_B10("b10_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b5_0.add();
+        a1_main.b6_0.add();
+        a1_main.b7_0.add();
+        a1_main.b8_0.add();
+        a1_main.b9_0.add();
+        a1_main.b10_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b5_0.sum+a1_main.b6_0.sum+a1_main.b7_0.sum+a1_main.b8_0.sum+a1_main.b9_0.sum+a1_main.b10_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b5_0.sum + a1_main.b6_0.sum + a1_main.b7_0.sum + a1_main.b8_0.sum + a1_main.b9_0.sum + a1_main.b10_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 6266)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00040_A1 {
+        Nocycle_a_00040_B1 b1_0;
+        Nocycle_a_00040_B2 b2_0;
+        Nocycle_a_00040_B3 b3_0;
+        Nocycle_a_00040_B4 b4_0;
+        Nocycle_a_00040_B5 b5_0;
+        Nocycle_a_00040_B6 b6_0;
+        Nocycle_a_00040_B7 b7_0;
+        Nocycle_a_00040_B8 b8_0;
+        Nocycle_a_00040_B9 b9_0;
+        Nocycle_a_00040_B10 b10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            b5_0 = null;
+            b6_0 = null;
+            b7_0 = null;
+            b8_0 = null;
+            b9_0 = null;
+            b10_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + b5_0.a + b6_0.a + b7_0.a + b8_0.a + b9_0.a + b10_0.a;
+        }
+    }
+
+    class Nocycle_a_00040_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B5 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B5(String strObjectName) {
+            a = 205;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B6 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B6(String strObjectName) {
+            a = 206;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B7(String strObjectName) {
+            a = 207;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B8 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B8(String strObjectName) {
+            a = 208;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B9 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B9(String strObjectName) {
+            a = 209;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B10 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B10(String strObjectName) {
+            a = 210;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00040 A1_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A2_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A3_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A4_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A5_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A6_00040 = new ThreadRc_00040();
+
+        A1_00040.start();
+        A2_00040.start();
+        A3_00040.start();
+        A4_00040.start();
+        A5_00040.start();
+        A6_00040.start();
+        try {
+            A1_00040.join();
+            A2_00040.join();
+            A3_00040.join();
+            A4_00040.join();
+            A5_00040.join();
+            A6_00040.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00040.check() && A2_00040.check() && A3_00040.check() && A4_00040.check() && A5_00040.check() && A6_00040.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/Nocycle_am_00050.java b/test/testsuite/ouroboros/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/Nocycle_am_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..596c36dfa12a55f64d6e29ab7cf133651fb961ae
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/Nocycle_am_00050.java
@@ -0,0 +1,239 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00050.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00050 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00050.java
+ *- @ExecuteClass: Nocycle_am_00050
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00050 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00050_A1 a1_main = new Nocycle_a_00050_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00050_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00050_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_a_00050_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_a_00050_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_a_00050_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00050_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00050_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        a1_main.b1_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c2_0.sum+a1_main.b1_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum + a1_main.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 5048)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00050_A1 {
+        Nocycle_a_00050_B1 b1_0;
+        Nocycle_a_00050_B2 b2_0;
+        Nocycle_a_00050_B3 b3_0;
+        Nocycle_a_00050_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00050_B1 {
+        Nocycle_a_00050_C1 c1_0;
+        Nocycle_a_00050_C2 c2_0;
+        Nocycle_a_00050_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00050_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00050 A1_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A2_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A3_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A4_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A5_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A6_00050 = new ThreadRc_00050();
+
+        A1_00050.start();
+        A2_00050.start();
+        A3_00050.start();
+        A4_00050.start();
+        A5_00050.start();
+        A6_00050.start();
+        try {
+            A1_00050.join();
+            A2_00050.join();
+            A3_00050.join();
+            A4_00050.join();
+            A5_00050.join();
+            A6_00050.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00050.check() && A2_00050.check() && A3_00050.check() && A4_00050.check() && A5_00050.check() && A6_00050.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/Nocycle_am_00060.java b/test/testsuite/ouroboros/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/Nocycle_am_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..dde5dea8cf604a879f47d3805c338d5926ac56e6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/Nocycle_am_00060.java
@@ -0,0 +1,251 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00060.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00060 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00060.java
+ *- @ExecuteClass: Nocycle_am_00060
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00060 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00060_A1 a1_main = new Nocycle_a_00060_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00060_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00060_B2("b2_0");
+        a1_main.b2_0.c1_0 = new Nocycle_a_00060_C1("c1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00060_C2("c2_0");
+        a1_main.b2_0.c3_0 = new Nocycle_a_00060_C3("c3_0");
+        a1_main.b3_0 = new Nocycle_a_00060_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00060_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c1_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b2_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c1_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b2_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c1_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b2_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 5047)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00060_A1 {
+        Nocycle_a_00060_B1 b1_0;
+        Nocycle_a_00060_B2 b2_0;
+        Nocycle_a_00060_B3 b3_0;
+        Nocycle_a_00060_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00060_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_B2 {
+        Nocycle_a_00060_C1 c1_0;
+        Nocycle_a_00060_C2 c2_0;
+        Nocycle_a_00060_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B2(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00060_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_00060 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00060 A1_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A2_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A3_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A4_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A5_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A6_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A7_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A8_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A9_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A10_00060 = new ThreadRc_00060();
+
+        A1_00060.start();
+        A2_00060.start();
+        A3_00060.start();
+        A4_00060.start();
+        A5_00060.start();
+        A6_00060.start();
+        A7_00060.start();
+        A8_00060.start();
+        A9_00060.start();
+        A10_00060.start();
+
+        try {
+            A1_00060.join();
+            A2_00060.join();
+            A3_00060.join();
+            A4_00060.join();
+            A5_00060.join();
+            A6_00060.join();
+            A7_00060.join();
+            A8_00060.join();
+            A9_00060.join();
+            A10_00060.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00060.check() && A2_00060.check() && A3_00060.check() && A4_00060.check() && A5_00060.check() && A6_00060.check() && A7_00060.check() && A8_00060.check() && A9_00060.check() && A10_00060.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/Nocycle_am_00070.java b/test/testsuite/ouroboros/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/Nocycle_am_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..3039db54fabe54a5a7f320ac8d70dbebb12bdce0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/Nocycle_am_00070.java
@@ -0,0 +1,242 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00070.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00070 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00070.java
+ *- @ExecuteClass: Nocycle_am_00070
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00070 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00070_A1 a1_main = new Nocycle_a_00070_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00070_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00070_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00070_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00070_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_00070_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_00070_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00070_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 5045)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00070_A1 {
+        Nocycle_a_00070_B1 b1_0;
+        Nocycle_a_00070_B2 b2_0;
+        Nocycle_a_00070_B3 b3_0;
+        Nocycle_a_00070_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00070_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B4 {
+        Nocycle_a_00070_C1 c1_0;
+        Nocycle_a_00070_C2 c2_0;
+        Nocycle_a_00070_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00070_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00070 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00070 A1_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A2_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A3_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A4_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A5_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A6_00070 = new ThreadRc_00070();
+
+        A1_00070.start();
+        A2_00070.start();
+        A3_00070.start();
+        A4_00070.start();
+        A5_00070.start();
+        A6_00070.start();
+
+        try {
+            A1_00070.join();
+            A2_00070.join();
+            A3_00070.join();
+            A4_00070.join();
+            A5_00070.join();
+            A6_00070.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00070.check() && A2_00070.check() && A3_00070.check() && A4_00070.check() && A5_00070.check() && A6_00070.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/Nocycle_am_00080.java b/test/testsuite/ouroboros/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/Nocycle_am_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..c3985ba1b25b89b441403bf40ed74f3ed098d30e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/Nocycle_am_00080.java
@@ -0,0 +1,134 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00080.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00080 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00080.java
+ *- @ExecuteClass: Nocycle_am_00080
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00080 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00080_A1 a1_main = new Nocycle_a_00080_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00080_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00080_C1("c1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 1406)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00080_A1 {
+        Nocycle_a_00080_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00080_B1 {
+        Nocycle_a_00080_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00080_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_00080 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00080 A1_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A2_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A3_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A4_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A5_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A6_00080 = new ThreadRc_00080();
+
+        A1_00080.start();
+        A2_00080.start();
+        A3_00080.start();
+        A4_00080.start();
+        A5_00080.start();
+        A6_00080.start();
+        try {
+            A1_00080.join();
+            A2_00080.join();
+            A3_00080.join();
+            A4_00080.join();
+            A5_00080.join();
+            A6_00080.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00080.check() && A2_00080.check() && A3_00080.check() && A4_00080.check() && A5_00080.check() && A6_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/Nocycle_am_00090.java b/test/testsuite/ouroboros/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/Nocycle_am_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..929fe262f0657ccc288f6b9f39c2c0d91185500e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/Nocycle_am_00090.java
@@ -0,0 +1,159 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00090.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00090 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00090.java
+ *- @ExecuteClass: Nocycle_am_00090
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00090 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00090_A1 a1_main = new Nocycle_a_00090_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00090_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00090_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00090_D1("d1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2308)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00090_A1 {
+        Nocycle_a_00090_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_B1 {
+        Nocycle_a_00090_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_C1 {
+        Nocycle_a_00090_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00090 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00090 A1_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A2_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A3_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A4_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A5_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A6_00090 = new ThreadRc_00090();
+
+        A1_00090.start();
+        A2_00090.start();
+        A3_00090.start();
+        A4_00090.start();
+        A5_00090.start();
+        A6_00090.start();
+
+        try {
+            A1_00090.join();
+            A2_00090.join();
+            A3_00090.join();
+            A4_00090.join();
+            A5_00090.join();
+            A6_00090.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00090.check() && A2_00090.check() && A3_00090.check() && A4_00090.check() && A5_00090.check() && A6_00090.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/Nocycle_am_00100.java b/test/testsuite/ouroboros/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/Nocycle_am_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..f8d76880e1c89d978064c921e326dc75775f2bc2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/Nocycle_am_00100.java
@@ -0,0 +1,296 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00100.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00100 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00100.java
+ *- @ExecuteClass: Nocycle_am_00100
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00100 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00100_A1 a1_main = new Nocycle_a_00100_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00100_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00100_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00100_D1("d1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_00100_E1("e1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_00100_F1("f1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_00100_G1("g1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_00100_H1("h1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_00100_I1("i1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_00100_J1("j1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+//		 System.out.printf("a=%d\n",a1_main.sum);
+//		 System.out.printf("b=%d\n",a1_main.b1_0.sum);
+//		 System.out.printf("c=%d\n",a1_main.b1_0.c1_0.sum);
+//		 System.out.printf("d=%d\n",a1_main.b1_0.c1_0.d1_0.sum);
+//		 System.out.printf("e=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.sum);
+//		 System.out.printf("f=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum);
+//		 System.out.printf("g=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum);
+//		 System.out.printf("h=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum);
+//		 System.out.printf("i=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum);
+//		 System.out.printf("j=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 11920)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00100_A1 {
+        Nocycle_a_00100_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_B1 {
+        Nocycle_a_00100_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_C1 {
+        Nocycle_a_00100_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_D1 {
+        Nocycle_a_00100_E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_E1 {
+        Nocycle_a_00100_F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_F1 {
+        Nocycle_a_00100_G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_G1 {
+        Nocycle_a_00100_H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_H1 {
+        Nocycle_a_00100_I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_I1 {
+        Nocycle_a_00100_J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_J1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00100 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00100 A1_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A2_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A3_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A4_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A5_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A6_00100 = new ThreadRc_00100();
+
+        A1_00100.start();
+        A2_00100.start();
+        A3_00100.start();
+        A4_00100.start();
+        A5_00100.start();
+        A6_00100.start();
+
+        try {
+            A1_00100.join();
+            A2_00100.join();
+            A3_00100.join();
+            A4_00100.join();
+            A5_00100.join();
+            A6_00100.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00100.check() && A2_00100.check() && A3_00100.check() && A4_00100.check() && A5_00100.check() && A6_00100.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/Nocycle_am_00110.java b/test/testsuite/ouroboros/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/Nocycle_am_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..3c45f26a3dff6631ed4cb7b30c5ebf0101069c6b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/Nocycle_am_00110.java
@@ -0,0 +1,346 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00110.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00110 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00110.java
+ *- @ExecuteClass: Nocycle_am_00110
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00110 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00110_A1 a1_main = new Nocycle_a_00110_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00110_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00110_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00110_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00110_B4("b4_0");
+        a1_main.b1_0.d1_0 = new Nocycle_a_00110_D1("d1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00110_C2("c2_0");
+        a1_main.b3_0.c1_0 = new Nocycle_a_00110_C1("c1_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00110_C3("c3_0");
+        a1_main.b3_0.c1_0.d2_0 = new Nocycle_a_00110_D2("d2_0");
+        a1_main.b2_0.c2_0.d3_0 = new Nocycle_a_00110_D3("d3_0");
+        a1_main.b2_0.c2_0.d4_0 = new Nocycle_a_00110_D4("d4_0");
+        a1_main.d5_0 = new Nocycle_a_00110_D5("d5_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b3_0.c1_0.add();
+        a1_main.b4_0.c3_0.add();
+        a1_main.b1_0.d1_0.add();
+        a1_main.b3_0.c1_0.d2_0.add();
+        a1_main.b2_0.c2_0.d3_0.add();
+        a1_main.b2_0.c2_0.d4_0.add();
+        a1_main.d5_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b3_0.c1_0.sum+a1_main.b4_0.c3_0.sum+a1_main.b1_0.d1_0.sum+a1_main.b3_0.c1_0.d2_0.sum+a1_main.b2_0.c2_0.d3_0.sum+a1_main.b2_0.c2_0.d4_0.sum+a1_main.d5_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b3_0.c1_0.sum + a1_main.b4_0.c3_0.sum + a1_main.b1_0.d1_0.sum + a1_main.b3_0.c1_0.d2_0.sum + a1_main.b2_0.c2_0.d3_0.sum + a1_main.b2_0.c2_0.d4_0.sum + a1_main.d5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 9881)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00110_A1 {
+        Nocycle_a_00110_B1 b1_0;
+        Nocycle_a_00110_B2 b2_0;
+        Nocycle_a_00110_B3 b3_0;
+        Nocycle_a_00110_B4 b4_0;
+        Nocycle_a_00110_D5 d5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            d5_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + d5_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B1 {
+        Nocycle_a_00110_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B2 {
+        Nocycle_a_00110_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B2(String strObjectName) {
+            c2_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B3 {
+        Nocycle_a_00110_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B4 {
+        Nocycle_a_00110_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B4(String strObjectName) {
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C1 {
+        Nocycle_a_00110_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C1(String strObjectName) {
+            d2_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C2 {
+        Nocycle_a_00110_D3 d3_0;
+        Nocycle_a_00110_D4 d4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C2(String strObjectName) {
+            d3_0 = null;
+            d4_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d3_0.a + d4_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D4(String strObjectName) {
+            a = 404;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D5 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D5(String strObjectName) {
+            a = 405;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00110 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00110 A1_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A2_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A3_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A4_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A5_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A6_00110 = new ThreadRc_00110();
+
+        A1_00110.start();
+        A2_00110.start();
+        A3_00110.start();
+        A4_00110.start();
+        A5_00110.start();
+        A6_00110.start();
+
+        try {
+            A1_00110.join();
+            A2_00110.join();
+            A3_00110.join();
+            A4_00110.join();
+            A5_00110.join();
+            A6_00110.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00110.check() && A2_00110.check() && A3_00110.check() && A4_00110.check() && A5_00110.check() && A6_00110.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/Nocycle_am_00120.java b/test/testsuite/ouroboros/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/Nocycle_am_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..3d1fef01d04af97cfacbcd84cfea5fe3ee72f82f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/Nocycle_am_00120.java
@@ -0,0 +1,139 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00120.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00120 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00120.java
+ *- @ExecuteClass: Nocycle_am_00120
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00120 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00120_A1 a1_main = new Nocycle_a_00120_A1("a1_main");
+        Nocycle_a_00120_A2 a2_main = new Nocycle_a_00120_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1007)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00120_A1 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00120_A2 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00120_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00120 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00120 A1_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A2_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A3_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A4_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A5_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A6_00120 = new ThreadRc_00120();
+
+        A1_00120.start();
+        A2_00120.start();
+        A3_00120.start();
+        A4_00120.start();
+        A5_00120.start();
+        A6_00120.start();
+
+        try {
+            A1_00120.join();
+            A2_00120.join();
+            A3_00120.join();
+            A4_00120.join();
+            A5_00120.join();
+            A6_00120.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00120.check() && A2_00120.check() && A3_00120.check() && A4_00120.check() && A5_00120.check() && A6_00120.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/Nocycle_am_00130.java b/test/testsuite/ouroboros/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/Nocycle_am_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..4bf330e31c8c1a68455c96a96e0ae6ad1b8d1962
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/Nocycle_am_00130.java
@@ -0,0 +1,323 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00130.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00130 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00130.java
+ *- @ExecuteClass: Nocycle_am_00130
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00130 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00130_A1 a1_main = new Nocycle_a_00130_A1("a1_main");
+        Nocycle_a_00130_A2 a2_main = new Nocycle_a_00130_A2("a2_main");
+        Nocycle_a_00130_A3 a3_main = new Nocycle_a_00130_A3("a3_main");
+        Nocycle_a_00130_A4 a4_main = new Nocycle_a_00130_A4("a4_main");
+        Nocycle_a_00130_A5 a5_main = new Nocycle_a_00130_A5("a5_main");
+        Nocycle_a_00130_A6 a6_main = new Nocycle_a_00130_A6("a6_main");
+        Nocycle_a_00130_A7 a7_main = new Nocycle_a_00130_A7("a7_main");
+        Nocycle_a_00130_A8 a8_main = new Nocycle_a_00130_A8("a8_main");
+        Nocycle_a_00130_A9 a9_main = new Nocycle_a_00130_A9("a9_main");
+        Nocycle_a_00130_A10 a10_main = new Nocycle_a_00130_A10("a10_main");
+        a1_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a3_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a4_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a5_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a6_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a7_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a8_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a9_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a10_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        a3_main.b1_0.add();
+        a4_main.b1_0.add();
+        a5_main.b1_0.add();
+        a6_main.b1_0.add();
+        a7_main.b1_0.add();
+        a8_main.b1_0.add();
+        a9_main.b1_0.add();
+        a10_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a5_main.sum+a6_main.sum+a7_main.sum+a8_main.sum+a9_main.sum+a10_main.sum+a1_main.b1_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 3467)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00130_A1 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A2 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A3 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A3(String strObjectName) {
+            b1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A4 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A4(String strObjectName) {
+            b1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A5 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A5(String strObjectName) {
+            b1_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A6 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A6(String strObjectName) {
+            b1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A7 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A7(String strObjectName) {
+            b1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A8 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A8(String strObjectName) {
+            b1_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A9 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A9(String strObjectName) {
+            b1_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A10 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A10(String strObjectName) {
+            b1_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00130 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00130 A1_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A2_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A3_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A4_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A5_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A6_00130 = new ThreadRc_00130();
+
+        A1_00130.start();
+        A2_00130.start();
+        A3_00130.start();
+        A4_00130.start();
+        A5_00130.start();
+        A6_00130.start();
+
+        try {
+            A1_00130.join();
+            A2_00130.join();
+            A3_00130.join();
+            A4_00130.join();
+            A5_00130.join();
+            A6_00130.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00130.check() && A2_00130.check() && A3_00130.check() && A4_00130.check() && A5_00130.check() && A6_00130.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/Nocycle_am_00140.java b/test/testsuite/ouroboros/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/Nocycle_am_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..7761c926ca13d1399d8cd7e6fe9b64fc320355d0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/Nocycle_am_00140.java
@@ -0,0 +1,161 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00140.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00140 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00140.java
+ *- @ExecuteClass: Nocycle_am_00140
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00140 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00140_A1 a1_main = new Nocycle_a_00140_A1("a1_main");
+        Nocycle_a_00140_A2 a2_main = new Nocycle_a_00140_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00140_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1613)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00140_A1 {
+        Nocycle_a_00140_B1 b1_0;
+        Nocycle_a_00140_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00140_A2 {
+        Nocycle_a_00140_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00140_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00140_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00140 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00140 A1_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A2_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A3_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A4_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A5_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A6_00140 = new ThreadRc_00140();
+
+        A1_00140.start();
+        A2_00140.start();
+        A3_00140.start();
+        A4_00140.start();
+        A5_00140.start();
+        A6_00140.start();
+
+        try {
+            A1_00140.join();
+            A2_00140.join();
+            A3_00140.join();
+            A4_00140.join();
+            A5_00140.join();
+            A6_00140.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00140.check() && A2_00140.check() && A3_00140.check() && A4_00140.check() && A5_00140.check() && A6_00140.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/Nocycle_am_00150.java b/test/testsuite/ouroboros/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/Nocycle_am_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..4aaebaf7a214b08f9b56a2e6cb336b5c5200aa7e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/Nocycle_am_00150.java
@@ -0,0 +1,165 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00150.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00150 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00150.java
+ *- @ExecuteClass: Nocycle_am_00150
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00150 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00150_A1 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_A2 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00150_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00150 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00150 A1_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A2_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A3_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A4_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A5_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A6_00150 = new ThreadRc_00150();
+
+        A1_00150.start();
+        A2_00150.start();
+        A3_00150.start();
+        A4_00150.start();
+        A5_00150.start();
+        A6_00150.start();
+
+        try {
+            A1_00150.join();
+            A2_00150.join();
+            A3_00150.join();
+            A4_00150.join();
+            A5_00150.join();
+            A6_00150.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00150.check() && A2_00150.check() && A3_00150.check() && A4_00150.check() && A5_00150.check() && A6_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/Nocycle_am_00160.java b/test/testsuite/ouroboros/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/Nocycle_am_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d7547ded47533ceebe7526294b9553d8dac88e3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/Nocycle_am_00160.java
@@ -0,0 +1,219 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00160.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00160 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00160.java
+ *- @ExecuteClass: Nocycle_am_00160
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00160 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00160_A1 a1_main = new Nocycle_a_00160_A1("a1_main");
+        Nocycle_a_00160_A2 a2_main = new Nocycle_a_00160_A2("a2_main");
+        Nocycle_a_00160_A3 a3_main = new Nocycle_a_00160_A3("a3_main");
+        Nocycle_a_00160_A4 a4_main = new Nocycle_a_00160_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a3_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a4_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2828)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00160_A1 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A2 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A3 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A4 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00160_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00160 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00160 A1_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A2_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A3_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A4_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A5_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A6_00160 = new ThreadRc_00160();
+
+        A1_00160.start();
+        A2_00160.start();
+        A3_00160.start();
+        A4_00160.start();
+        A5_00160.start();
+        A6_00160.start();
+
+        try {
+            A1_00160.join();
+            A2_00160.join();
+            A3_00160.join();
+            A4_00160.join();
+            A5_00160.join();
+            A6_00160.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00160.check() && A2_00160.check() && A3_00160.check() && A4_00160.check() && A5_00160.check() && A6_00160.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/Nocycle_am_00170.java b/test/testsuite/ouroboros/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/Nocycle_am_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..6db69e30d05ae6dd853763ae49c6dcd62d67d61a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/Nocycle_am_00170.java
@@ -0,0 +1,253 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00170.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00170 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00170.java
+ *- @ExecuteClass: Nocycle_am_00170
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00170 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00170_A1 a1_main = new Nocycle_a_00170_A1("a1_main");
+        Nocycle_a_00170_A2 a2_main = new Nocycle_a_00170_A2("a2_main");
+        Nocycle_a_00170_A3 a3_main = new Nocycle_a_00170_A3("a3_main");
+        Nocycle_a_00170_A4 a4_main = new Nocycle_a_00170_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a2_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a2_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a3_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a3_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a4_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a4_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a2_main.b3_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b3_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        a4_main.b3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 4046)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00170_A1 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A2 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A3 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A4 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00170_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00170_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00170 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00170 A1_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A2_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A3_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A4_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A5_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A6_00170 = new ThreadRc_00170();
+
+        A1_00170.start();
+        A2_00170.start();
+        A3_00170.start();
+        A4_00170.start();
+        A5_00170.start();
+        A6_00170.start();
+
+        try {
+            A1_00170.join();
+            A2_00170.join();
+            A3_00170.join();
+            A4_00170.join();
+            A5_00170.join();
+            A6_00170.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00170.check() && A2_00170.check() && A3_00170.check() && A4_00170.check() && A5_00170.check() && A6_00170.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/Nocycle_am_00180.java b/test/testsuite/ouroboros/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/Nocycle_am_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..f4c36c61dbfd1c4168e4fea28a7903d16e73cf85
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/Nocycle_am_00180.java
@@ -0,0 +1,393 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00180.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_00180 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00180.java
+ *- @ExecuteClass: Nocycle_am_00180
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+//		 System.out.printf("a1_main.sum=%d\n",a1_main.sum);
+//		 System.out.printf("a2_main.sum=%d\n",a2_main.sum);
+//		 System.out.printf("a3_main.sum=%d\n",a3_main.sum);
+//		 System.out.printf("a4_main.sum=%d\n",a4_main.sum);
+//		 System.out.printf("a1_main.b1_0.sum=%d\n",a1_main.b1_0.sum);
+//		 System.out.printf("a2_main.b2_0.sum=%d\n",a2_main.b2_0.sum);
+//		 System.out.printf("a4_main.b3_0.sum=%d\n",a4_main.b3_0.sum);
+//		 System.out.printf("a2_main.b2_0.c1_0.sum=%d\n",a2_main.b2_0.c1_0.sum);
+//		 System.out.printf("a3_main.c2_0.sum=%d\n",a3_main.c2_0.sum);
+//		 System.out.printf("a1_main.d1_0.sum=%d\n",a1_main.d1_0.sum);
+//		 System.out.printf("a3_main.c2_0.d2_0.sum=%d\n",a3_main.c2_0.d2_0.sum);
+//		 System.out.printf("a3_main.c2_0.d3_0.sum=%d\n",a3_main.c2_0.d3_0.sum);
+
+
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a2_main.b2_0.sum+a4_main.b3_0.sum+a2_main.b2_0.c1_0.sum+a3_main.c2_0.sum+a1_main.d1_0.sum+a3_main.c2_0.d2_0.sum+a3_main.c2_0.d3_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 9260)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00180_A1 {
+        Nocycle_a_00180_B1 b1_0;
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A2 {
+        Nocycle_a_00180_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A3 {
+        Nocycle_a_00180_B2 b2_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A4 {
+        Nocycle_a_00180_B3 b3_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B1 {
+        Nocycle_a_00180_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B2 {
+        Nocycle_a_00180_C1 c1_0;
+        Nocycle_a_00180_D1 d1_0;
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B3 {
+        Nocycle_a_00180_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C1 {
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C2 {
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_00180 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00180 A1_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A2_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A3_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A4_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A5_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A6_00180 = new ThreadRc_00180();
+
+        A1_00180.start();
+        A2_00180.start();
+        A3_00180.start();
+        A4_00180.start();
+        A5_00180.start();
+        A6_00180.start();
+
+        try {
+            A1_00180.join();
+            A2_00180.join();
+            A3_00180.join();
+            A4_00180.join();
+            A5_00180.join();
+            A6_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00180.check() && A2_00180.check() && A3_00180.check() && A4_00180.check() && A5_00180.check() && A6_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/Nocycle_am_00190.java b/test/testsuite/ouroboros/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/Nocycle_am_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..b861aaa51d903b72e203245ab08aebbc782f58e6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/Nocycle_am_00190.java
@@ -0,0 +1,3139 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_00190.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:make Nocycle_a_xx together to this Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_00190.java
+ *- @ExecuteClass: Nocycle_am_00190
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_00010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_am_00010_A1 a1_main = new Nocycle_am_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_am_00010_B1("b1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 704)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_am_00010_A1 {
+        Nocycle_am_00010_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_am_00010_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_am_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_am_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00020_A1 a1_main = new Nocycle_a_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00020_B2("b2_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1310)
+            checkout = true;
+        //System.out.println(checkout);
+
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00020_A1 {
+        Nocycle_a_00020_B1 b1_0;
+        Nocycle_a_00020_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00030B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00030_A1 a1_main = new Nocycle_a_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00030_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00030_B3("b3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1919)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00030_A1 {
+        Nocycle_a_00030_B1 b1_0;
+        Nocycle_a_00030_B2 b2_0;
+        Nocycle_a_00030_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00030_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00030_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00030_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00030_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00040B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00040_A1 a1_main = new Nocycle_a_00040_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00040_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00040_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00040_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00040_B4("b4_0");
+        a1_main.b5_0 = new Nocycle_a_00040_B5("b5_0");
+        a1_main.b6_0 = new Nocycle_a_00040_B6("b6_0");
+        a1_main.b7_0 = new Nocycle_a_00040_B7("b7_0");
+        a1_main.b8_0 = new Nocycle_a_00040_B8("b8_0");
+        a1_main.b9_0 = new Nocycle_a_00040_B9("b9_0");
+        a1_main.b10_0 = new Nocycle_a_00040_B10("b10_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b5_0.add();
+        a1_main.b6_0.add();
+        a1_main.b7_0.add();
+        a1_main.b8_0.add();
+        a1_main.b9_0.add();
+        a1_main.b10_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b5_0.sum+a1_main.b6_0.sum+a1_main.b7_0.sum+a1_main.b8_0.sum+a1_main.b9_0.sum+a1_main.b10_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b5_0.sum + a1_main.b6_0.sum + a1_main.b7_0.sum + a1_main.b8_0.sum + a1_main.b9_0.sum + a1_main.b10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 6266)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00040_A1 {
+        Nocycle_a_00040_B1 b1_0;
+        Nocycle_a_00040_B2 b2_0;
+        Nocycle_a_00040_B3 b3_0;
+        Nocycle_a_00040_B4 b4_0;
+        Nocycle_a_00040_B5 b5_0;
+        Nocycle_a_00040_B6 b6_0;
+        Nocycle_a_00040_B7 b7_0;
+        Nocycle_a_00040_B8 b8_0;
+        Nocycle_a_00040_B9 b9_0;
+        Nocycle_a_00040_B10 b10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            b5_0 = null;
+            b6_0 = null;
+            b7_0 = null;
+            b8_0 = null;
+            b9_0 = null;
+            b10_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + b5_0.a + b6_0.a + b7_0.a + b8_0.a + b9_0.a + b10_0.a;
+        }
+    }
+
+    class Nocycle_a_00040_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B5 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B5(String strObjectName) {
+            a = 205;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B6 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B6(String strObjectName) {
+            a = 206;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B7 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B7(String strObjectName) {
+            a = 207;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B8 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B8(String strObjectName) {
+            a = 208;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B9 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B9(String strObjectName) {
+            a = 209;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00040_B10 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00040_B10(String strObjectName) {
+            a = 210;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00050B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00050_A1 a1_main = new Nocycle_a_00050_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00050_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00050_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_a_00050_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_a_00050_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_a_00050_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00050_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00050_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        a1_main.b1_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c2_0.sum+a1_main.b1_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum + a1_main.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5048)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00050_A1 {
+        Nocycle_a_00050_B1 b1_0;
+        Nocycle_a_00050_B2 b2_0;
+        Nocycle_a_00050_B3 b3_0;
+        Nocycle_a_00050_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00050_B1 {
+        Nocycle_a_00050_C1 c1_0;
+        Nocycle_a_00050_C2 c2_0;
+        Nocycle_a_00050_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00050_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00050_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00050_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00060B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00060_A1 a1_main = new Nocycle_a_00060_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00060_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00060_B2("b2_0");
+        a1_main.b2_0.c1_0 = new Nocycle_a_00060_C1("c1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00060_C2("c2_0");
+        a1_main.b2_0.c3_0 = new Nocycle_a_00060_C3("c3_0");
+        a1_main.b3_0 = new Nocycle_a_00060_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00060_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c1_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b2_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c1_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b2_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c1_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b2_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5047)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00060_A1 {
+        Nocycle_a_00060_B1 b1_0;
+        Nocycle_a_00060_B2 b2_0;
+        Nocycle_a_00060_B3 b3_0;
+        Nocycle_a_00060_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00060_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_B2 {
+        Nocycle_a_00060_C1 c1_0;
+        Nocycle_a_00060_C2 c2_0;
+        Nocycle_a_00060_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B2(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00060_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00060_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00060_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00070B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00070_A1 a1_main = new Nocycle_a_00070_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00070_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00070_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00070_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00070_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_00070_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_00070_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00070_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 5045)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00070_A1 {
+        Nocycle_a_00070_B1 b1_0;
+        Nocycle_a_00070_B2 b2_0;
+        Nocycle_a_00070_B3 b3_0;
+        Nocycle_a_00070_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_00070_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_B4 {
+        Nocycle_a_00070_C1 c1_0;
+        Nocycle_a_00070_C2 c2_0;
+        Nocycle_a_00070_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00070_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00070_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00070_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00080B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00080_A1 a1_main = new Nocycle_a_00080_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00080_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00080_C1("c1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1406)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00080_A1 {
+        Nocycle_a_00080_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00080_B1 {
+        Nocycle_a_00080_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00080_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00080_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00090B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00090_A1 a1_main = new Nocycle_a_00090_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00090_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00090_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00090_D1("d1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2308)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00090_A1 {
+        Nocycle_a_00090_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_B1 {
+        Nocycle_a_00090_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_C1 {
+        Nocycle_a_00090_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00090_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00090_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00100B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00100_A1 a1_main = new Nocycle_a_00100_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00100_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00100_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00100_D1("d1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_00100_E1("e1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_00100_F1("f1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_00100_G1("g1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_00100_H1("h1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_00100_I1("i1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_00100_J1("j1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+//		 System.out.printf("a=%d\n",a1_main.sum);
+//		 System.out.printf("b=%d\n",a1_main.b1_0.sum);
+//		 System.out.printf("c=%d\n",a1_main.b1_0.c1_0.sum);
+//		 System.out.printf("d=%d\n",a1_main.b1_0.c1_0.d1_0.sum);
+//		 System.out.printf("e=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.sum);
+//		 System.out.printf("f=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum);
+//		 System.out.printf("g=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum);
+//		 System.out.printf("h=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum);
+//		 System.out.printf("i=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum);
+//		 System.out.printf("j=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 11920)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00100_A1 {
+        Nocycle_a_00100_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_B1 {
+        Nocycle_a_00100_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_C1 {
+        Nocycle_a_00100_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_D1 {
+        Nocycle_a_00100_E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_E1 {
+        Nocycle_a_00100_F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_F1 {
+        Nocycle_a_00100_G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_G1 {
+        Nocycle_a_00100_H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_H1 {
+        Nocycle_a_00100_I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_I1 {
+        Nocycle_a_00100_J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+
+    class Nocycle_a_00100_J1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00100_J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00110B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00110_A1 a1_main = new Nocycle_a_00110_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00110_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00110_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00110_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00110_B4("b4_0");
+        a1_main.b1_0.d1_0 = new Nocycle_a_00110_D1("d1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00110_C2("c2_0");
+        a1_main.b3_0.c1_0 = new Nocycle_a_00110_C1("c1_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00110_C3("c3_0");
+        a1_main.b3_0.c1_0.d2_0 = new Nocycle_a_00110_D2("d2_0");
+        a1_main.b2_0.c2_0.d3_0 = new Nocycle_a_00110_D3("d3_0");
+        a1_main.b2_0.c2_0.d4_0 = new Nocycle_a_00110_D4("d4_0");
+        a1_main.d5_0 = new Nocycle_a_00110_D5("d5_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b3_0.c1_0.add();
+        a1_main.b4_0.c3_0.add();
+        a1_main.b1_0.d1_0.add();
+        a1_main.b3_0.c1_0.d2_0.add();
+        a1_main.b2_0.c2_0.d3_0.add();
+        a1_main.b2_0.c2_0.d4_0.add();
+        a1_main.d5_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b3_0.c1_0.sum+a1_main.b4_0.c3_0.sum+a1_main.b1_0.d1_0.sum+a1_main.b3_0.c1_0.d2_0.sum+a1_main.b2_0.c2_0.d3_0.sum+a1_main.b2_0.c2_0.d4_0.sum+a1_main.d5_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b3_0.c1_0.sum + a1_main.b4_0.c3_0.sum + a1_main.b1_0.d1_0.sum + a1_main.b3_0.c1_0.d2_0.sum + a1_main.b2_0.c2_0.d3_0.sum + a1_main.b2_0.c2_0.d4_0.sum + a1_main.d5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 9881)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00110_A1 {
+        Nocycle_a_00110_B1 b1_0;
+        Nocycle_a_00110_B2 b2_0;
+        Nocycle_a_00110_B3 b3_0;
+        Nocycle_a_00110_B4 b4_0;
+        Nocycle_a_00110_D5 d5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            d5_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + d5_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B1 {
+        Nocycle_a_00110_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B2 {
+        Nocycle_a_00110_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B2(String strObjectName) {
+            c2_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B3 {
+        Nocycle_a_00110_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_B4 {
+        Nocycle_a_00110_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_B4(String strObjectName) {
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C1 {
+        Nocycle_a_00110_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C1(String strObjectName) {
+            d2_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C2 {
+        Nocycle_a_00110_D3 d3_0;
+        Nocycle_a_00110_D4 d4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C2(String strObjectName) {
+            d3_0 = null;
+            d4_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d3_0.a + d4_0.a;
+        }
+    }
+
+    class Nocycle_a_00110_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D4(String strObjectName) {
+            a = 404;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00110_D5 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00110_D5(String strObjectName) {
+            a = 405;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00120B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00120_A1 a1_main = new Nocycle_a_00120_A1("a1_main");
+        Nocycle_a_00120_A2 a2_main = new Nocycle_a_00120_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1007)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00120_A1 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00120_A2 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00120_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00120_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00130B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00130_A1 a1_main = new Nocycle_a_00130_A1("a1_main");
+        Nocycle_a_00130_A2 a2_main = new Nocycle_a_00130_A2("a2_main");
+        Nocycle_a_00130_A3 a3_main = new Nocycle_a_00130_A3("a3_main");
+        Nocycle_a_00130_A4 a4_main = new Nocycle_a_00130_A4("a4_main");
+        Nocycle_a_00130_A5 a5_main = new Nocycle_a_00130_A5("a5_main");
+        Nocycle_a_00130_A6 a6_main = new Nocycle_a_00130_A6("a6_main");
+        Nocycle_a_00130_A7 a7_main = new Nocycle_a_00130_A7("a7_main");
+        Nocycle_a_00130_A8 a8_main = new Nocycle_a_00130_A8("a8_main");
+        Nocycle_a_00130_A9 a9_main = new Nocycle_a_00130_A9("a9_main");
+        Nocycle_a_00130_A10 a10_main = new Nocycle_a_00130_A10("a10_main");
+        a1_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a3_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a4_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a5_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a6_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a7_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a8_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a9_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a10_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        a3_main.b1_0.add();
+        a4_main.b1_0.add();
+        a5_main.b1_0.add();
+        a6_main.b1_0.add();
+        a7_main.b1_0.add();
+        a8_main.b1_0.add();
+        a9_main.b1_0.add();
+        a10_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a5_main.sum+a6_main.sum+a7_main.sum+a8_main.sum+a9_main.sum+a10_main.sum+a1_main.b1_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 3467)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00130_A1 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A2 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A3 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A3(String strObjectName) {
+            b1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A4 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A4(String strObjectName) {
+            b1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A5 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A5(String strObjectName) {
+            b1_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A6 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A6(String strObjectName) {
+            b1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A7 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A7(String strObjectName) {
+            b1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A8 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A8(String strObjectName) {
+            b1_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A9 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A9(String strObjectName) {
+            b1_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_A10 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_A10(String strObjectName) {
+            b1_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00130_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00130_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00140B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00140_A1 a1_main = new Nocycle_a_00140_A1("a1_main");
+        Nocycle_a_00140_A2 a2_main = new Nocycle_a_00140_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00140_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1613)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00140_A1 {
+        Nocycle_a_00140_B1 b1_0;
+        Nocycle_a_00140_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00140_A2 {
+        Nocycle_a_00140_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_00140_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00140_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00140_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00150B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00150_A1 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_A2 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00150_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00160B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00160_A1 a1_main = new Nocycle_a_00160_A1("a1_main");
+        Nocycle_a_00160_A2 a2_main = new Nocycle_a_00160_A2("a2_main");
+        Nocycle_a_00160_A3 a3_main = new Nocycle_a_00160_A3("a3_main");
+        Nocycle_a_00160_A4 a4_main = new Nocycle_a_00160_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a3_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a4_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 2828)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00160_A1 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A2 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A3 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_A4 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00160_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00160_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00160_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_00170B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00170_A1 a1_main = new Nocycle_a_00170_A1("a1_main");
+        Nocycle_a_00170_A2 a2_main = new Nocycle_a_00170_A2("a2_main");
+        Nocycle_a_00170_A3 a3_main = new Nocycle_a_00170_A3("a3_main");
+        Nocycle_a_00170_A4 a4_main = new Nocycle_a_00170_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a2_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a2_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a3_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a3_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a4_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a4_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a2_main.b3_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b3_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        a4_main.b3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 4046)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00170_A1 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A2 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A3 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_A4 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_00170_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00170_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00170_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00170_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+class ThreadRc_00180B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+//		 System.out.printf("a1_main.sum=%d\n",a1_main.sum);
+//		 System.out.printf("a2_main.sum=%d\n",a2_main.sum);
+//		 System.out.printf("a3_main.sum=%d\n",a3_main.sum);
+//		 System.out.printf("a4_main.sum=%d\n",a4_main.sum);
+//		 System.out.printf("a1_main.b1_0.sum=%d\n",a1_main.b1_0.sum);
+//		 System.out.printf("a2_main.b2_0.sum=%d\n",a2_main.b2_0.sum);
+//		 System.out.printf("a4_main.b3_0.sum=%d\n",a4_main.b3_0.sum);
+//		 System.out.printf("a2_main.b2_0.c1_0.sum=%d\n",a2_main.b2_0.c1_0.sum);
+//		 System.out.printf("a3_main.c2_0.sum=%d\n",a3_main.c2_0.sum);
+//		 System.out.printf("a1_main.d1_0.sum=%d\n",a1_main.d1_0.sum);
+//		 System.out.printf("a3_main.c2_0.d2_0.sum=%d\n",a3_main.c2_0.d2_0.sum);
+//		 System.out.printf("a3_main.c2_0.d3_0.sum=%d\n",a3_main.c2_0.d3_0.sum);
+
+
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a2_main.b2_0.sum+a4_main.b3_0.sum+a2_main.b2_0.c1_0.sum+a3_main.c2_0.sum+a1_main.d1_0.sum+a3_main.c2_0.d2_0.sum+a3_main.c2_0.d3_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 9260)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00180_A1 {
+        Nocycle_a_00180_B1 b1_0;
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A2 {
+        Nocycle_a_00180_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A3 {
+        Nocycle_a_00180_B2 b2_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_A4 {
+        Nocycle_a_00180_B3 b3_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B1 {
+        Nocycle_a_00180_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B2 {
+        Nocycle_a_00180_C1 c1_0;
+        Nocycle_a_00180_D1 d1_0;
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_B3 {
+        Nocycle_a_00180_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C1 {
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_C2 {
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_00180_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00180_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00180_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_00190 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00010B A1_00010 = new ThreadRc_00010B();
+        ThreadRc_00010B A2_00010 = new ThreadRc_00010B();
+        ThreadRc_00020B A1_00020 = new ThreadRc_00020B();
+        ThreadRc_00020B A2_00020 = new ThreadRc_00020B();
+        ThreadRc_00030B A1_00030 = new ThreadRc_00030B();
+        ThreadRc_00030B A2_00030 = new ThreadRc_00030B();
+        ThreadRc_00040B A1_00040 = new ThreadRc_00040B();
+        ThreadRc_00040B A2_00040 = new ThreadRc_00040B();
+        ThreadRc_00050B A1_00050 = new ThreadRc_00050B();
+        ThreadRc_00050B A2_00050 = new ThreadRc_00050B();
+        ThreadRc_00060B A1_00060 = new ThreadRc_00060B();
+        ThreadRc_00060B A2_00060 = new ThreadRc_00060B();
+        ThreadRc_00070B A1_00070 = new ThreadRc_00070B();
+        ThreadRc_00070B A2_00070 = new ThreadRc_00070B();
+        ThreadRc_00080B A1_00080 = new ThreadRc_00080B();
+        ThreadRc_00080B A2_00080 = new ThreadRc_00080B();
+        ThreadRc_00090B A1_00090 = new ThreadRc_00090B();
+        ThreadRc_00090B A2_00090 = new ThreadRc_00090B();
+        ThreadRc_00100B A1_00100 = new ThreadRc_00100B();
+        ThreadRc_00100B A2_00100 = new ThreadRc_00100B();
+        ThreadRc_00110B A1_00110 = new ThreadRc_00110B();
+        ThreadRc_00110B A2_00110 = new ThreadRc_00110B();
+        ThreadRc_00120B A1_00120 = new ThreadRc_00120B();
+        ThreadRc_00120B A2_00120 = new ThreadRc_00120B();
+        ThreadRc_00130B A1_00130 = new ThreadRc_00130B();
+        ThreadRc_00130B A2_00130 = new ThreadRc_00130B();
+        ThreadRc_00140B A1_00140 = new ThreadRc_00140B();
+        ThreadRc_00140B A2_00140 = new ThreadRc_00140B();
+        ThreadRc_00150B A1_00150 = new ThreadRc_00150B();
+        ThreadRc_00150B A2_00150 = new ThreadRc_00150B();
+        ThreadRc_00160B A1_00160 = new ThreadRc_00160B();
+        ThreadRc_00160B A2_00160 = new ThreadRc_00160B();
+        ThreadRc_00170B A1_00170 = new ThreadRc_00170B();
+        ThreadRc_00170B A2_00170 = new ThreadRc_00170B();
+        ThreadRc_00180B A1_00180 = new ThreadRc_00180B();
+        ThreadRc_00180B A2_00180 = new ThreadRc_00180B();
+        A1_00010.start();
+        A2_00010.start();
+        A1_00020.start();
+        A2_00020.start();
+        A1_00030.start();
+        A2_00030.start();
+        A1_00040.start();
+        A2_00040.start();
+        A1_00050.start();
+        A2_00050.start();
+        A1_00060.start();
+        A2_00060.start();
+        A1_00070.start();
+        A2_00070.start();
+        A1_00080.start();
+        A2_00080.start();
+        A1_00090.start();
+        A2_00090.start();
+        A1_00100.start();
+        A2_00100.start();
+        A1_00110.start();
+        A2_00110.start();
+        A1_00120.start();
+        A2_00120.start();
+        A1_00130.start();
+        A2_00130.start();
+        A1_00140.start();
+        A2_00140.start();
+        A1_00150.start();
+        A2_00150.start();
+        A1_00160.start();
+        A2_00160.start();
+        A1_00170.start();
+        A2_00170.start();
+        A1_00180.start();
+        A2_00180.start();
+        try {
+            A1_00010.join();
+            A2_00010.join();
+            A1_00020.join();
+            A2_00020.join();
+            A1_00030.join();
+            A2_00030.join();
+            A1_00040.join();
+            A2_00040.join();
+            A1_00050.join();
+            A2_00050.join();
+            A1_00060.join();
+            A2_00060.join();
+            A1_00070.join();
+            A2_00070.join();
+            A1_00080.join();
+            A2_00080.join();
+            A1_00090.join();
+            A2_00090.join();
+            A1_00100.join();
+            A2_00100.join();
+            A1_00110.join();
+            A2_00110.join();
+            A1_00120.join();
+            A2_00120.join();
+            A1_00130.join();
+            A2_00130.join();
+            A1_00140.join();
+            A2_00140.join();
+            A1_00150.join();
+            A2_00150.join();
+            A1_00160.join();
+            A2_00160.join();
+            A1_00170.join();
+            A2_00170.join();
+            A1_00180.join();
+            A2_00180.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00010.check() && A2_00010.check() && A1_00020.check() && A2_00020.check() && A1_00030.check() && A2_00030.check() && A1_00040.check() && A2_00040.check() && A1_00050.check() && A2_00050.check() && A1_00060.check() && A2_00060.check() && A1_00070.check() && A2_00070.check() && A1_00080.check() && A2_00080.check() && A1_00090.check() && A2_00090.check() && A1_00100.check() && A2_00100.check() && A1_00110.check() && A2_00110.check() && A1_00120.check() && A2_00120.check() && A1_00130.check() && A2_00130.check() && A1_00140.check() && A2_00140.check() && A1_00150.check() && A2_00150.check() && A1_00160.check() && A2_00160.check() && A1_00170.check() && A2_00170.check() && A1_00180.check() && A2_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/Nocycle_am_2_00010.java b/test/testsuite/ouroboros/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/Nocycle_am_2_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..af35cb660462adf97810967b6eeedf31bfc8bd53
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/Nocycle_am_2_00010.java
@@ -0,0 +1,177 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_2_00010.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_2_00010 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_2_00010.java
+ *- @ExecuteClass: Nocycle_am_2_00010
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Nocycle_am_2_00010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_2_00010_A1 a1_main = new Nocycle_a_2_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00010_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00010_B3("b3_0");
+        Nocycle_a_2_00010_A2 a2_main = new Nocycle_a_2_00010_A2("a2_main");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.add();
+        //		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a2_main.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1939)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_2_00010_A1 {
+        Nocycle_a_2_00010_B1 b1_0;
+        Nocycle_a_2_00010_B2 b2_0;
+        Nocycle_a_2_00010_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_A2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_A2(String strObjectName) {
+            a = 10;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_2_00010 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Nocycle_am_2_00010 A1_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A2_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A3_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A4_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A5_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A6_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+
+        A1_Nocycle_am_2_00010.start();
+        A2_Nocycle_am_2_00010.start();
+        A3_Nocycle_am_2_00010.start();
+        A4_Nocycle_am_2_00010.start();
+        A5_Nocycle_am_2_00010.start();
+        A6_Nocycle_am_2_00010.start();
+
+        try {
+            A1_Nocycle_am_2_00010.join();
+            A2_Nocycle_am_2_00010.join();
+            A3_Nocycle_am_2_00010.join();
+            A4_Nocycle_am_2_00010.join();
+            A5_Nocycle_am_2_00010.join();
+            A6_Nocycle_am_2_00010.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Nocycle_am_2_00010.check() && A2_Nocycle_am_2_00010.check() && A3_Nocycle_am_2_00010.check() && A4_Nocycle_am_2_00010.check() && A5_Nocycle_am_2_00010.check() && A6_Nocycle_am_2_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/Nocycle_am_2_00020.java b/test/testsuite/ouroboros/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/Nocycle_am_2_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..290adfac9a150342a63bb6afc8f9c32862872776
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/Nocycle_am_2_00020.java
@@ -0,0 +1,760 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_2_00020.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_2_00020 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_2_00020.java
+ *- @ExecuteClass: Nocycle_am_2_00020
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Nocycle_am_2_00020 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_2_00020_A1 a1_main = new Nocycle_a_2_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_2_00020_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_2_00020_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_2_00020_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_2_00020_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result1 = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result1);
+        Nocycle_a_2_00020_2A1 a1_main2 = new Nocycle_a_2_00020_2A1("a1_main2");
+        a1_main2.b1_0 = new Nocycle_a_2_00020_2B1("b1_0");
+        a1_main2.b1_0.c1_0 = new Nocycle_a_2_00020_2C1("c1_0");
+        a1_main2.b1_0.c1_0.d1_0 = new Nocycle_a_2_00020_2D1("d1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_2_00020_2E1("e1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_2_00020_2F1("f1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_2_00020_2G1("g1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_2_00020_2H1("h1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_2_00020_2I1("i1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_2_00020_2J1("j1_0");
+        a1_main2.add();
+        a1_main2.b1_0.add();
+        a1_main2.b1_0.c1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+
+        int result2 = a1_main2.sum + a1_main2.b1_0.sum + a1_main2.b1_0.c1_0.sum + a1_main2.b1_0.c1_0.d1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        Nocycle_a_2_00020_3A1 a1_main3 = new Nocycle_a_2_00020_3A1("a1_main3");
+        Nocycle_a_2_00020_3A2 a2_main = new Nocycle_a_2_00020_3A2("a2_main");
+        Nocycle_a_2_00020_3A3 a3_main = new Nocycle_a_2_00020_3A3("a3_main");
+        Nocycle_a_2_00020_3A4 a4_main = new Nocycle_a_2_00020_3A4("a4_main");
+        a1_main3.b1_0 = new Nocycle_a_2_00020_3B1("b1_0");
+        a1_main3.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a1_main3.b1_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_2_00020_3B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a1_main3.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main3.b1_0.add();
+        a1_main3.d1_0.add();
+        a1_main3.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result3 = a1_main3.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main3.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main3.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+
+        int result = result1 + result2 + result3;
+
+        if (result == 26225)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_2_00020_A1 {
+        Nocycle_a_2_00020_B1 b1_0;
+        Nocycle_a_2_00020_B2 b2_0;
+        Nocycle_a_2_00020_B3 b3_0;
+        Nocycle_a_2_00020_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B4 {
+        Nocycle_a_2_00020_C1 c1_0;
+        Nocycle_a_2_00020_C2 c2_0;
+        Nocycle_a_2_00020_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2A1 {
+        Nocycle_a_2_00020_2B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2B1 {
+        Nocycle_a_2_00020_2C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2C1 {
+        Nocycle_a_2_00020_2D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2D1 {
+        Nocycle_a_2_00020_2E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2E1 {
+        Nocycle_a_2_00020_2F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2F1 {
+        Nocycle_a_2_00020_2G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2G1 {
+        Nocycle_a_2_00020_2H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2H1 {
+        Nocycle_a_2_00020_2I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2I1 {
+        Nocycle_a_2_00020_2J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2J1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A1 {
+        Nocycle_a_2_00020_3B1 b1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A2 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A3 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A4 {
+        Nocycle_a_2_00020_3B3 b3_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B1 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B2 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B3 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3C1 {
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3C2 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class Nocycle_am_2_00020 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Nocycle_am_2_00020 A1_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A2_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A3_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A4_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A5_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A6_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+
+        A1_Nocycle_am_2_00020.start();
+        A2_Nocycle_am_2_00020.start();
+        A3_Nocycle_am_2_00020.start();
+        A4_Nocycle_am_2_00020.start();
+        A5_Nocycle_am_2_00020.start();
+        A6_Nocycle_am_2_00020.start();
+
+        try {
+            A1_Nocycle_am_2_00020.join();
+            A2_Nocycle_am_2_00020.join();
+            A3_Nocycle_am_2_00020.join();
+            A4_Nocycle_am_2_00020.join();
+            A5_Nocycle_am_2_00020.join();
+            A6_Nocycle_am_2_00020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Nocycle_am_2_00020.check() && A2_Nocycle_am_2_00020.check() && A3_Nocycle_am_2_00020.check() && A4_Nocycle_am_2_00020.check() && A5_Nocycle_am_2_00020.check() && A6_Nocycle_am_2_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/Nocycle_am_2_00030.java b/test/testsuite/ouroboros/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/Nocycle_am_2_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..206ae6b06a0d9db1ac4f2b15dfb9aacdeec5516a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/Nocycle_am_2_00030.java
@@ -0,0 +1,896 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/Nocycle_am_2_00030.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change Nocycle_a_2_00030 in RC测试-No-Cycle-00.vsd to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: Nocycle_am_2_00030.java
+ *- @ExecuteClass: Nocycle_am_2_00030
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+class ThreadRc_Nocycle_am_2_00010B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_2_00010_A1 a1_main = new Nocycle_a_2_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00010_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00010_B3("b3_0");
+        Nocycle_a_2_00010_A2 a2_main = new Nocycle_a_2_00010_A2("a2_main");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.add();
+        //		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a2_main.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1939)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_2_00010_A1 {
+        Nocycle_a_2_00010_B1 b1_0;
+        Nocycle_a_2_00010_B2 b2_0;
+        Nocycle_a_2_00010_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00010_A2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00010_A2(String strObjectName) {
+            a = 10;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+class ThreadRc_Nocycle_am_2_00020B extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_2_00020_A1 a1_main = new Nocycle_a_2_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_2_00020_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_2_00020_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_2_00020_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_2_00020_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+
+        int result1 = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result1);
+        Nocycle_a_2_00020_2A1 a1_main2 = new Nocycle_a_2_00020_2A1("a1_main2");
+        a1_main2.b1_0 = new Nocycle_a_2_00020_2B1("b1_0");
+        a1_main2.b1_0.c1_0 = new Nocycle_a_2_00020_2C1("c1_0");
+        a1_main2.b1_0.c1_0.d1_0 = new Nocycle_a_2_00020_2D1("d1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_2_00020_2E1("e1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_2_00020_2F1("f1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_2_00020_2G1("g1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_2_00020_2H1("h1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_2_00020_2I1("i1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_2_00020_2J1("j1_0");
+        a1_main2.add();
+        a1_main2.b1_0.add();
+        a1_main2.b1_0.c1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+
+        int result2 = a1_main2.sum + a1_main2.b1_0.sum + a1_main2.b1_0.c1_0.sum + a1_main2.b1_0.c1_0.d1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+
+        Nocycle_a_2_00020_3A1 a1_main3 = new Nocycle_a_2_00020_3A1("a1_main3");
+        Nocycle_a_2_00020_3A2 a2_main = new Nocycle_a_2_00020_3A2("a2_main");
+        Nocycle_a_2_00020_3A3 a3_main = new Nocycle_a_2_00020_3A3("a3_main");
+        Nocycle_a_2_00020_3A4 a4_main = new Nocycle_a_2_00020_3A4("a4_main");
+        a1_main3.b1_0 = new Nocycle_a_2_00020_3B1("b1_0");
+        a1_main3.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a1_main3.b1_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+
+        a2_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+
+        a3_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a3_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a4_main.b3_0 = new Nocycle_a_2_00020_3B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+
+        a1_main3.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main3.b1_0.add();
+        a1_main3.d1_0.add();
+        a1_main3.b1_0.d2_0.add();
+
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+
+
+        int result3 = a1_main3.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main3.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main3.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+
+        int result = result1 + result2 + result3;
+
+        if (result == 26225)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_2_00020_A1 {
+        Nocycle_a_2_00020_B1 b1_0;
+        Nocycle_a_2_00020_B2 b2_0;
+        Nocycle_a_2_00020_B3 b3_0;
+        Nocycle_a_2_00020_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_B4 {
+        Nocycle_a_2_00020_C1 c1_0;
+        Nocycle_a_2_00020_C2 c2_0;
+        Nocycle_a_2_00020_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2A1 {
+        Nocycle_a_2_00020_2B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2B1 {
+        Nocycle_a_2_00020_2C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2C1 {
+        Nocycle_a_2_00020_2D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2D1 {
+        Nocycle_a_2_00020_2E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2E1 {
+        Nocycle_a_2_00020_2F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2F1 {
+        Nocycle_a_2_00020_2G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2G1 {
+        Nocycle_a_2_00020_2H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2H1 {
+        Nocycle_a_2_00020_2I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2I1 {
+        Nocycle_a_2_00020_2J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_2J1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_2J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A1 {
+        Nocycle_a_2_00020_3B1 b1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A2 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A3 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3A4 {
+        Nocycle_a_2_00020_3B3 b3_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B1 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B2 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3B3 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3C1 {
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3C2 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_2_00020_3D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_2_00020_3D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+public class Nocycle_am_2_00030 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Nocycle_am_2_00010B A1_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A2_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A3_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A4_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A5_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A6_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00020B A1_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A2_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A3_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A4_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A5_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A6_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+
+        A1_Nocycle_am_2_00010.start();
+        A2_Nocycle_am_2_00010.start();
+        A3_Nocycle_am_2_00010.start();
+        A4_Nocycle_am_2_00010.start();
+        A5_Nocycle_am_2_00010.start();
+        A6_Nocycle_am_2_00010.start();
+        A1_Nocycle_am_2_00020.start();
+        A2_Nocycle_am_2_00020.start();
+        A3_Nocycle_am_2_00020.start();
+        A4_Nocycle_am_2_00020.start();
+        A5_Nocycle_am_2_00020.start();
+        A6_Nocycle_am_2_00020.start();
+
+        try {
+            A1_Nocycle_am_2_00010.join();
+            A2_Nocycle_am_2_00010.join();
+            A3_Nocycle_am_2_00010.join();
+            A4_Nocycle_am_2_00010.join();
+            A5_Nocycle_am_2_00010.join();
+            A6_Nocycle_am_2_00010.join();
+            A1_Nocycle_am_2_00020.join();
+            A2_Nocycle_am_2_00020.join();
+            A3_Nocycle_am_2_00020.join();
+            A4_Nocycle_am_2_00020.join();
+            A5_Nocycle_am_2_00020.join();
+            A6_Nocycle_am_2_00020.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Nocycle_am_2_00010.check() && A2_Nocycle_am_2_00010.check() && A3_Nocycle_am_2_00010.check() && A4_Nocycle_am_2_00010.check() && A5_Nocycle_am_2_00010.check() && A6_Nocycle_am_2_00010.check() && A1_Nocycle_am_2_00020.check() && A2_Nocycle_am_2_00020.check() && A3_Nocycle_am_2_00020.check() && A4_Nocycle_am_2_00020.check() && A5_Nocycle_am_2_00020.check() && A6_Nocycle_am_2_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/RC_Thread_01.java b/test/testsuite/ouroboros/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/RC_Thread_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..6ea43ef3ac8fa537ccfc2165a1f28b716abfe750
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/RC_Thread_01.java
@@ -0,0 +1,426 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00180
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_01.java
+ *- @ExecuteClass: RC_Thread_01
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+
+class RC_Thread_01_1 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_01_2 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_01_3 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_01_4 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_01_5 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_01 {
+    private volatile static RC_Thread_01_A1 a1_main = null;
+    private volatile static RC_Thread_01_A2 a2_main = null;
+    private volatile static RC_Thread_01_A3 a3_main = null;
+    private volatile static RC_Thread_01_A4 a4_main = null;
+
+    RC_Thread_01() {
+        try {
+            a1_main = new RC_Thread_01_A1("a1_main");
+            a2_main = new RC_Thread_01_A2("a2_main");
+            a3_main = new RC_Thread_01_A3("a3_main");
+            a4_main = new RC_Thread_01_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_01_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_01_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_01_D2("d2_0");
+
+            a2_main.b2_0 = new RC_Thread_01_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_01_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_01_D1("d1_0");
+
+            a3_main.b2_0 = new RC_Thread_01_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_01_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+
+            a3_main.c2_0 = new RC_Thread_01_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+
+            a4_main.b3_0 = new RC_Thread_01_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_01_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_01_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		System.out.println("ExpectResult");
+        
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_01_1 t1=new RC_Thread_01_1();
+        RC_Thread_01_2 t2=new RC_Thread_01_2();
+        RC_Thread_01_3 t3=new RC_Thread_01_3();
+        RC_Thread_01_4 t4=new RC_Thread_01_4();
+        RC_Thread_01_5 t5=new RC_Thread_01_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+        } catch (InterruptedException e) {}
+
+    }
+
+
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA2null() {
+        a2_main = null;
+    }
+
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_01_D2("new");
+            a3_main = new RC_Thread_01_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        a3_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    class RC_Thread_01_A1 {
+        volatile RC_Thread_01_B1 b1_0;
+        volatile RC_Thread_01_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_A2 {
+        volatile RC_Thread_01_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_A3 {
+        volatile RC_Thread_01_B2 b2_0;
+        volatile RC_Thread_01_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class RC_Thread_01_A4 {
+        volatile RC_Thread_01_B3 b3_0;
+        volatile RC_Thread_01_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_B1 {
+        volatile RC_Thread_01_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_B2 {
+        volatile RC_Thread_01_C1 c1_0;
+        volatile RC_Thread_01_D1 d1_0;
+        volatile RC_Thread_01_D2 d2_0;
+        volatile RC_Thread_01_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_B3 {
+        volatile RC_Thread_01_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_C1 {
+        volatile RC_Thread_01_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class RC_Thread_01_C2 {
+        volatile RC_Thread_01_D2 d2_0;
+        volatile RC_Thread_01_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_01_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_01_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_01_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_01_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/RC_Thread_02.java b/test/testsuite/ouroboros/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/RC_Thread_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..689ff89ba09029caa2a9ae2528a006d5f3885659
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/RC_Thread_02.java
@@ -0,0 +1,293 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00050
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_02.java
+ *- @ExecuteClass: RC_Thread_02
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+class RC_Thread_02_1 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.addSum();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_02_2 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.ModifyB4();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_02_3 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.deleteA1();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_02_4 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.setA1(null);
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_02 {
+    private volatile static RC_Thread_02_A1 a1 = null;
+
+    RC_Thread_02(String str) {
+        try {
+            a1 = new RC_Thread_02_A1("a1");
+            a1.b1_0 = new RC_Thread_02_B1("b1_0");
+            a1.b1_0.c1_0 = new RC_Thread_02_C1("c1_0");
+            a1.b1_0.c2_0 = new RC_Thread_02_C2("c2_0");
+            a1.b1_0.c3_0 = new RC_Thread_02_C3("c3_0");
+            a1.b2_0 = new RC_Thread_02_B2("b2_0");
+            a1.b3_0 = new RC_Thread_02_B3("b3_0");
+            a1.b4_0 = new RC_Thread_02_B4("b4_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_02_1 t1=new RC_Thread_02_1();
+        RC_Thread_02_2 t2=new RC_Thread_02_2();
+        RC_Thread_02_3 t3=new RC_Thread_02_3();
+        RC_Thread_02_4 t4=new RC_Thread_02_4();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        try{
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+
+        }catch(InterruptedException e){}
+    }
+
+    public void deleteA1() {
+        a1 = null;
+    }
+
+    public void ModifyB4() {
+        try{
+        a1.b4_0 = new RC_Thread_02_B4("new_b4");
+        }catch(NullPointerException e){
+
+        }
+    }
+
+    public void addSum() {
+        try {
+            a1.add();
+            a1.b1_0.add();
+            a1.b2_0.add();
+            a1.b3_0.add();
+            a1.b4_0.add();
+            a1.b1_0.c1_0.add();
+            a1.b1_0.c2_0.add();
+            a1.b1_0.c3_0.add();
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA1(RC_Thread_02_A1 a1) {
+        this.a1 = a1;
+    }
+
+    class RC_Thread_02_A1 {
+        volatile RC_Thread_02_B1 b1_0;
+        volatile RC_Thread_02_B2 b2_0;
+        volatile RC_Thread_02_B3 b3_0;
+        volatile RC_Thread_02_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class RC_Thread_02_B1 {
+        volatile RC_Thread_02_C1 c1_0;
+        volatile RC_Thread_02_C2 c2_0;
+        volatile RC_Thread_02_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class RC_Thread_02_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+
+    class RC_Thread_02_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_02_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_02_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_02_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_02_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_02_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/RC_Thread_03.java b/test/testsuite/ouroboros/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/RC_Thread_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..845f088246d918c7960e7dada235a527768df010
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/RC_Thread_03.java
@@ -0,0 +1,370 @@
+/*
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_03.java
+ * -@TestCaseName:RC_Thread_03
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00180
+ * -@Condition: no
+ * -#c1
+ * -@Brief:Multi Thread reads or writes static para. It is modified from Nocycle_a_00180. At the same time，another thread is GC.
+ * -#step1
+ * -@Expect:ExpectResult\nExpectResult\n
+ * -@Priority: High
+ * -@Source: RC_Thread_03.java
+ * -@ExecuteClass: RC_Thread_03
+ * -@ExecuteArgs:
+ * -@Remark:
+ *
+ */
+
+class RcThread0301 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0302 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0303 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0304 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0305 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA4();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread03GC extends Thread {
+    public void run() {
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 50);
+        if (start == 50) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+public class RC_Thread_03 {
+    private static volatile RcThread03A1 a1_main = null;
+    private static volatile RcThread03A2 a2_main = null;
+    private static volatile RcThread03A3 a3_main = null;
+    private static volatile RcThread03A4 a4_main = null;
+
+    RC_Thread_03() {
+        try {
+            a1_main = new RcThread03A1("a1_main");
+            a2_main = new RcThread03A2("a2_main");
+            a3_main = new RcThread03A3("a3_main");
+            a4_main = new RcThread03A4("a4_main");
+            a1_main.b1_0 = new RcThread03B1("b1_0");
+            a1_main.d1_0 = new RcThread03D1("d1_0");
+            a1_main.b1_0.d2_0 = new RcThread03D2("d2_0");
+            a2_main.b2_0 = new RcThread03B2("b2_0");
+            a2_main.b2_0.c1_0 = new RcThread03C1("c1_0");
+            a2_main.b2_0.d1_0 = new RcThread03D1("d1_0");
+            a2_main.b2_0.d2_0 = new RcThread03D2("d2_0");
+            a2_main.b2_0.d3_0 = new RcThread03D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RcThread03D1("d1_0");
+            a3_main.b2_0 = new RcThread03B2("b2_0");
+            a3_main.b2_0.c1_0 = new RcThread03C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RcThread03D1("d1_0");
+            a3_main.b2_0.d1_0 = new RcThread03D1("d1_0");
+            a3_main.b2_0.d2_0 = new RcThread03D2("d2_0");
+            a3_main.b2_0.d3_0 = new RcThread03D3("d3_0");
+            a3_main.c2_0 = new RcThread03C2("c2_0");
+            a3_main.c2_0.d2_0 = new RcThread03D2("d2_0");
+            a3_main.c2_0.d3_0 = new RcThread03D3("d3_0");
+            a4_main.b3_0 = new RcThread03B3("b3_0");
+            a4_main.b3_0.c1_0 = new RcThread03C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RcThread03D1("d1_0");
+            a4_main.c2_0 = new RcThread03C2("c2_0");
+            a4_main.c2_0.d2_0 = new RcThread03D2("d2_0");
+            a4_main.c2_0.d3_0 = new RcThread03D3("d3_0");
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    public static void main(String[] args) {
+        RcThread03GC gc = new RcThread03GC();
+        gc.run();
+        for(int start = 0; start < 10; start++) {
+            rcTestcaseMainWrapper();
+        }
+        System.out.println("ExpectResult");
+
+    }
+
+    private static void rcTestcaseMainWrapper() {
+        RcThread0301 t1 = new RcThread0301();
+        RcThread0302 t2 = new RcThread0302();
+        RcThread0303 t3 = new RcThread0303();
+        RcThread0304 t4 = new RcThread0304();
+        RcThread0305 t5 = new RcThread0305();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+
+        }catch(InterruptedException e){
+            // do nothing
+        }
+    }
+
+    void setA1null() {
+        a1_main = null;
+    }
+
+    void setA2null() {
+        a2_main = null;
+    }
+
+    void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RcThread03D2("new");
+            a3_main = new RcThread03A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    void setA3null() {
+        a3_main = null;
+    }
+
+    void setA4() {
+        try {
+            a4_main = new RcThread03A4("a4_new");
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    class RcThread03A1 {
+        volatile RcThread03B1 b1_0;
+        volatile RcThread03D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03A2 {
+        volatile RcThread03B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03A3 {
+        volatile RcThread03B2 b2_0;
+        volatile RcThread03C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03A4 {
+        volatile RcThread03B3 b3_0;
+        volatile RcThread03C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03B1 {
+        volatile RcThread03D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+
+    }
+
+    class RcThread03B2 {
+        volatile RcThread03C1 c1_0;
+        volatile RcThread03D1 d1_0;
+        volatile RcThread03D2 d2_0;
+        volatile RcThread03D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03B3 {
+        volatile RcThread03C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03C1 {
+        volatile RcThread03D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03C2 {
+        volatile RcThread03D2 d2_0;
+        volatile RcThread03D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+
+    class RcThread03D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RcThread03D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/RC_Thread_04.java b/test/testsuite/ouroboros/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/RC_Thread_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e22d10b27df53dff665f17f677a01ee260fef9a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/RC_Thread_04.java
@@ -0,0 +1,205 @@
+/*
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_04.java
+ * -@TestCaseName:RC_Thread_04.java
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination:Multi Thread reads or writes static para.It is modified from Cycle_B_1_00180.At the same time，another thread is GC.
+ * -@Condition: no
+ * -#c1
+ * -@Brief:Multi Thread reads or writes static para.It is modified from Cycle_B_1_00180.At the same time，another thread is GC.
+ * -#step1
+ * -@Expect:ExpectResult\nExpectResult\n
+ * -@Priority: High
+ * -@Source: RC_Thread_04.java
+ * -@ExecuteClass: RC_Thread_04
+ * -@ExecuteArgs:
+ * -@Remark:
+ *
+ */
+
+class RcThread0401 extends Thread {
+    public void run() {
+        RC_Thread_04 rcth01 = new RC_Thread_04();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0402 extends Thread {
+    public void run() {
+        RC_Thread_04 rcth01 = new RC_Thread_04();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0403 extends Thread {
+    public void run() {
+        RC_Thread_04 rcth01 = new RC_Thread_04();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread04GC extends Thread {
+    public void run() {
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 50);
+        if (start == 50) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+public class RC_Thread_04 {
+    private static volatile RcThread04A1 a1_main = null;
+    private static volatile  RcThread04A4 a4_main = null;
+    private static volatile  RcThread04A5 a5_main = null;
+
+    RC_Thread_04() {
+        try {
+            RcThread04A1 a1 = new RcThread04A1();
+            a1.a2_0 = new RcThread04A2();
+            a1.a2_0.a3_0 = new RcThread04A3();
+            RcThread04A4 a4 = new RcThread04A4();
+            RcThread04A5 a5 = new RcThread04A5();
+            a4.a1_0 = a1;
+            a5.a1_0 = a1;
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1_main = a1;
+            a4_main = a4;
+            a5_main = a5;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    public static void main(String[] args) {
+        cyclePatternWrapper();
+        RcThread04GC gc = new RcThread04GC();
+        gc.start();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void cyclePatternWrapper() {
+        a1_main = new RcThread04A1();
+        a1_main.a2_0 = new RcThread04A2();
+        a1_main.a2_0.a3_0 = new RcThread04A3();
+        a4_main = new RcThread04A4();
+        a5_main = new RcThread04A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main = null;
+        a4_main = null;
+        a5_main = null;
+        Runtime.getRuntime().gc(); // 单独构造一次Cycle_B_1_00180环，通过gc学习到环模式
+    }
+
+    private static void rcTestcaseMainWrapper() {
+        RcThread0401 t1 = new RcThread0401();
+        RcThread0402 t2 = new RcThread0402();
+        RcThread0403 t3 = new RcThread0403();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+
+        }catch(InterruptedException e){
+            // do nothing
+        }
+    }
+
+    void setA1null() {
+        a1_main = null;
+    }
+
+    void setA4null() {
+        a4_main = null;
+    }
+
+    void setA5null() {
+        a5_main = null;
+    }
+
+    static class RcThread04A1 {
+        volatile RcThread04A2 a2_0;
+        int a;
+        int sum;
+
+        RcThread04A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+    }
+
+    static class RcThread04A2 {
+        volatile RcThread04A3 a3_0;
+        int a;
+        int sum;
+
+        RcThread04A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+    }
+
+    static class RcThread04A3 {
+        volatile RcThread04A1 a1_0;
+        int a;
+        int sum;
+
+        RcThread04A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+    }
+
+    static class RcThread04A4 {
+        volatile RcThread04A1 a1_0;
+        int a;
+        int sum;
+
+        RcThread04A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+    }
+
+    static class RcThread04A5 {
+        volatile RcThread04A1 a1_0;
+        int a;
+        int sum;
+
+        RcThread04A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/RC_Thread_05.java b/test/testsuite/ouroboros/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/RC_Thread_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..3fb2aa5773024fce8703fad9bf90c9777587feed
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/RC_Thread_05.java
@@ -0,0 +1,267 @@
+/*
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_05.java
+ * -@TestCaseName:RC_Thread_05
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination:Multi Thread reads or writes static para.It is modified from Cycle_B_1_00180.At the same time,another thread is doing GC.
+ * -@Condition: no
+ * -#c1
+ * -@Brief:Multi Thread reads or writes static para.It is modified from Cycle_B_1_00180.At the same time,another thread is doing GC.
+ * -#step1
+ * -@Expect:ExpectResult\nExpectResult\n
+ * -@Priority: High
+ * -@Source: RC_Thread_05.java
+ * -@ExecuteClass: RC_Thread_05
+ * -@ExecuteArgs:
+ * -@Remark:
+ *
+ */
+
+class RcThread0501 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0502 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0503 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0504 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA1();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0505 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0506 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA3_a(5);
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread05GC extends Thread {
+    public void run() {
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 50);
+        if (start == 50) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+public class RC_Thread_05 {
+    private static volatile RcThread05A1 a1Main = null;
+    private static volatile RcThread05A4 a4Main = null;
+    private static volatile RcThread05A5 a5Main = null;
+
+    RC_Thread_05() {
+        try {
+            a1Main = new RcThread05A1();
+            a1Main.a2_0 = new RcThread05A2();
+            a1Main.a2_0.a3_0 = new RcThread05A3();
+            a4Main = new RcThread05A4();
+            a5Main = new RcThread05A5();
+            a4Main.a1_0 = a1Main;
+            a5Main.a1_0 = a1Main;
+            a1Main.a2_0.a3_0.a1_0 = a1Main;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    public static void main(String[] args) {
+        cyclePatternWrapper();
+        RcThread05GC gc = new RcThread05GC();
+        gc.run();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void cyclePatternWrapper() {
+        a1Main = new RcThread05A1();
+        a1Main.a2_0 = new RcThread05A2();
+        a1Main.a2_0.a3_0 = new RcThread05A3();
+        a4Main = new RcThread05A4();
+        a5Main = new RcThread05A5();
+        a4Main.a1_0 = a1Main;
+        a5Main.a1_0 = a1Main;
+        a1Main.a2_0.a3_0.a1_0 = a1Main;
+        a1Main = null;
+        a4Main = null;
+        a5Main = null;
+        Runtime.getRuntime().gc();    // 单独构造一次Cycle_B_1_00180环，通过gc学习到环模式
+    }
+
+    private static void rcTestcaseMainWrapper() {
+        RcThread0501 t1 = new RcThread0501();
+        RcThread0502 t2 = new RcThread0502();
+        RcThread0503 t3 = new RcThread0503();
+        RcThread0504 t4 = new RcThread0504();
+        RcThread0505 t5 = new RcThread0505();
+        RcThread0506 t6 = new RcThread0506();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        t6.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+            t6.join();
+        }catch(InterruptedException e){
+            // do nothing
+        }
+    }
+
+    void setA1null() {
+        a1Main = null;
+    }
+
+    void setA4null() {
+        a4Main = null;
+    }
+
+    void setA5null() {
+        a5Main = null;
+    }
+
+    void setA1() {
+        try {
+            this.a1Main = new RcThread05A1();
+            a1Main.a2_0 = new RcThread05A2();
+            a1Main.a2_0.a3_0 = new RcThread05A3();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    void checkA3() {
+        try {
+            int a = a1Main.a2_0.a3_0.a;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    void setA3_a(int a) {
+        try {
+            this.a1Main.a2_0.a3_0.a = a;
+        } catch (NullPointerException e) { }
+    }
+
+    static class RcThread05A1 {
+        volatile RcThread05A2 a2_0;
+        int a;
+        int sum;
+
+        RcThread05A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+    }
+
+    static class RcThread05A2 {
+        volatile RcThread05A3 a3_0;
+        int a;
+        int sum;
+
+        RcThread05A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+    }
+
+    static class RcThread05A3 {
+        volatile RcThread05A1 a1_0;
+        int a;
+        int sum;
+
+        RcThread05A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+    }
+
+    static class RcThread05A4 {
+        volatile RcThread05A1 a1_0;
+        int a;
+        int sum;
+
+        RcThread05A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+    }
+
+    static class RcThread05A5 {
+        volatile RcThread05A1 a1_0;
+        int a;
+        int sum;
+
+        RcThread05A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/RC_Thread_06.java b/test/testsuite/ouroboros/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/RC_Thread_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2667526680d50fd7a35a409530e00f74f3a8683
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/RC_Thread_06.java
@@ -0,0 +1,242 @@
+/*
+ * -@TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_06.java
+ * -@TestCaseName:RC_Thread_06
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination:Multi Thread reads or writes static para.It is modified from Cycle_B_2_00130. At the same time,another thread is doing GC.
+ * -@Condition: no
+ * -#c1
+ * -@Brief:Multi Thread reads or writes static para.It is modified from Cycle_B_2_00130. At the same time,another thread is doing GC.
+ * -#step1
+ * -@Expect:ExpectResult\nExpectResult\n
+ * -@Priority: High
+ * -@Source: RC_Thread_06.java
+ * -@ExecuteClass: RC_Thread_06
+ * -@ExecuteArgs:
+ * -@Remark:
+ *
+ */
+
+class RcThread0601 extends Thread {
+    public void run() {
+        RC_Thread_06 rcth01 = new RC_Thread_06();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0602 extends Thread {
+    public void run() {
+        RC_Thread_06 rcth01 = new RC_Thread_06();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0603 extends Thread {
+    public void run() {
+        RC_Thread_06 rcth01 = new RC_Thread_06();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread06GC extends Thread {
+    public void run() {
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 50);
+        if (start == 50) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+public class RC_Thread_06 {
+    private static volatile RcThread06A1 a1Main = null;
+    private static volatile RcThread06A5 a5Main = null;
+
+    RC_Thread_06() {
+        try {
+            a1Main = new RcThread06A1();
+            a1Main.a2_0 = new RcThread06A2();
+            a1Main.a2_0.a3_0 = new RcThread06A3();
+            a1Main.a2_0.a3_0.a4_0 = new RcThread06A4();
+            a1Main.a2_0.a3_0.a4_0.a1_0 = a1Main;
+            a5Main = new RcThread06A5();
+            a1Main.a2_0.a3_0.a4_0.a6_0 = new RcThread06A6();
+            a1Main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5Main;
+            a5Main.a3_0 = a1Main.a2_0.a3_0;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    public static void main(String[] args) {
+        cyclePatternWrapper();
+        Runtime.getRuntime().gc();
+        RcThread06GC gc = new RcThread06GC();
+        gc.run();
+        int start = 0;
+        for (;start < 20; start++) {
+            rcTestcaseMainWrapper();
+        }
+        if (start == 20) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    private static void cyclePatternWrapper() {
+        a1Main = new RcThread06A1();
+        a1Main.a2_0 = new RcThread06A2();
+        a1Main.a2_0.a3_0 = new RcThread06A3();
+        a1Main.a2_0.a3_0.a4_0 = new RcThread06A4();
+        a1Main.a2_0.a3_0.a4_0.a1_0 = a1Main;
+        a5Main = new RcThread06A5();
+        a1Main.a2_0.a3_0.a4_0.a6_0 = new RcThread06A6();
+        a1Main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5Main;
+        a5Main.a3_0 = a1Main.a2_0.a3_0;
+        a1Main = null;
+        a5Main = null;
+
+        a1Main = new RcThread06A1();
+        a1Main.a2_0 = new RcThread06A2();
+        a1Main.a2_0.a3_0 = new RcThread06A3();
+        a1Main.a2_0.a3_0.a4_0 = new RcThread06A4();
+        a1Main.a2_0.a3_0.a4_0.a1_0 = a1Main;
+        a1Main = null;
+
+        a1Main = new RcThread06A1();
+        a1Main.a2_0 = new RcThread06A2();
+        a1Main.a2_0.a3_0 = new RcThread06A3();
+        a1Main.a2_0.a3_0.a4_0 = new RcThread06A4();
+        a1Main.a2_0.a3_0.a4_0.a1_0 = a1Main;
+        a5Main = new RcThread06A5();
+        a1Main.a2_0.a3_0.a4_0.a6_0 = new RcThread06A6();
+        a1Main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5Main;
+        a5Main.a3_0 = a1Main.a2_0.a3_0;
+        a1Main.a2_0.a3_0 = null;
+        a1Main = null;
+        a5Main = null;     //总共三种环类型
+    }
+
+    private static void rcTestcaseMainWrapper() {
+        RcThread0601 t1 = new RcThread0601();
+        RcThread0602 t2 = new RcThread0602();
+        RcThread0603 t3 = new RcThread0603();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e){
+            // do nothing
+        }
+    }
+
+    void setA1null() {
+        a1Main = null;
+    }
+
+    void setA4null() {
+        try {
+            a1Main.a2_0.a3_0.a4_0 = null;
+            a5Main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) { }
+    }
+
+    void setA5null() {
+        a5Main = null;
+    }
+
+    static class RcThread06A1 {
+        volatile RcThread06A2 a2_0;
+        volatile RcThread06A4 a4_0;
+        int a;
+        int sum;
+
+        RcThread06A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+    }
+
+    static class RcThread06A2 {
+        volatile RcThread06A3 a3_0;
+        int a;
+        int sum;
+
+        RcThread06A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+    }
+
+    static class RcThread06A3 {
+        volatile RcThread06A4 a4_0;
+        int a;
+        int sum;
+
+        RcThread06A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+    }
+
+    static class RcThread06A4 {
+        volatile RcThread06A1 a1_0;
+        volatile RcThread06A6 a6_0;
+        int a;
+        int sum;
+
+        RcThread06A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+    }
+
+    static class RcThread06A5 {
+        volatile RcThread06A3 a3_0;
+        int a;
+        int sum;
+
+        RcThread06A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+    }
+
+    static class RcThread06A6 {
+        volatile RcThread06A5 a5_0;
+        int a;
+        int sum;
+
+        RcThread06A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/RC_Thread_07.java b/test/testsuite/ouroboros/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/RC_Thread_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..31542d8473fd699a719697f10e62282f74f609b5
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/RC_Thread_07.java
@@ -0,0 +1,270 @@
+/*
+ * -@TestCaseID:RC_Thread_07.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ * -@Condition: no
+ * -#c1
+ * -@Brief:Multi Thread reads or writes static para. it is modified from Cycle_B_2_00130.At the same time，another thread is doing GC.
+ * -#step1
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: RC_Thread_07.java
+ * -@ExecuteClass: RC_Thread_07
+ * -@ExecuteArgs:
+ * -@Remark:
+ *
+ */
+
+class RcThread0701 extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        try {
+            rcth01.modifyA1();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0702 extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        try {
+            rcth01.checkA4();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread0703 extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        try {
+            rcth01.setA5();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+
+class RcThread07GC extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 20);
+    }
+}
+
+public class RC_Thread_07 {
+    private static volatile RcThread07A1 a1_main = null;
+    private static volatile RcThread07A5 a5_main = null;
+
+    RC_Thread_07() {
+        try {
+            RcThread07A1 a1_1 = new RcThread07A1();
+            a1_1.a2_0 = new RcThread07A2();
+            a1_1.a2_0.a3_0 = new RcThread07A3();
+            a1_1.a2_0.a3_0.a4_0 = new RcThread07A4();
+            a1_1.a2_0.a3_0.a4_0.a1_0 = a1_1;
+            RcThread07A5 a5_1 = new RcThread07A5();
+            a1_1.a2_0.a3_0.a4_0.a6_0 = new RcThread07A6();
+            a1_1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_1;
+            a5_1.a3_0 = a1_1.a2_0.a3_0;
+            a1_main = a1_1;
+            a5_main = a5_1;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    public static void main(String[] args) {
+        cyclePatternWrapper();
+        Runtime.getRuntime().gc();
+        cyclePatternWrapper();
+        Runtime.getRuntime().gc();
+        RcThread07GC gc = new RcThread07GC();
+        gc.start();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void cyclePatternWrapper() {
+        RcThread07A1 a1 = new RcThread07A1();
+        a1.a2_0 = new RcThread07A2();
+        a1.a2_0.a3_0 = new RcThread07A3();
+        a1.a2_0.a3_0.a4_0 = new RcThread07A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        RcThread07A5 a5 = new RcThread07A5();
+        a1.a2_0.a3_0.a4_0.a6_0 = new RcThread07A6();
+        a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+        a5.a3_0 = a1.a2_0.a3_0;
+        a1 = null;
+        a5 = null;
+
+        a1 = new RcThread07A1();
+        a1.a2_0 = new RcThread07A2();
+        a1.a2_0.a3_0 = new RcThread07A3();
+        a1.a2_0.a3_0.a4_0 = new RcThread07A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        a1 = null;
+
+        a1 = new RcThread07A1();
+        a1.a2_0 = new RcThread07A2();
+        a1.a2_0.a3_0 = new RcThread07A3();
+        a1.a2_0.a3_0.a4_0 = new RcThread07A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        a5 = new RcThread07A5();
+        a1.a2_0.a3_0.a4_0.a6_0 = new RcThread07A6();
+        a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+        a5.a3_0 = a1.a2_0.a3_0;
+        a1.a2_0.a3_0 = null;
+        a1 = null;
+        a5 = null;
+    }
+
+    private static void rcTestcaseMainWrapper() {
+        RcThread0701 t1 = new RcThread0701();
+        RcThread0702 t2 = new RcThread0702();
+        RcThread0703 t3 = new RcThread0703();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e){
+            // do nothing
+        }
+    }
+
+    void modifyA1() {
+        a1_main.a2_0.a3_0 = null;
+        a1_main = null;
+    }
+
+    void checkA4() {
+        try {
+            int[] arr = new int[2];
+            arr[0] = a5_main.a3_0.a4_0.sum;
+            arr[1] = a5_main.a3_0.a4_0.a;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+
+    void setA5() {
+        RcThread07A5 a5 = new RcThread07A5();
+        a5 = this.a5_main;
+        a5_main = null;
+    }
+
+    static class RcThread07A1 {
+        volatile RcThread07A2 a2_0;
+        volatile RcThread07A4 a4_0;
+        int a;
+        int sum;
+
+        RcThread07A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RcThread07A2 {
+        volatile RcThread07A3 a3_0;
+        int a;
+        int sum;
+
+        RcThread07A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RcThread07A3 {
+        volatile RcThread07A4 a4_0;
+        int a;
+        int sum;
+
+        RcThread07A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    static class RcThread07A4 {
+        volatile RcThread07A1 a1_0;
+        volatile RcThread07A6 a6_0;
+        int a;
+        int sum;
+
+        RcThread07A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RcThread07A5 {
+        volatile RcThread07A3 a3_0;
+        int a;
+        int sum;
+
+        RcThread07A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RcThread07A6 {
+        volatile RcThread07A5 a5_0;
+        int a;
+        int sum;
+
+        RcThread07A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/RC_Thread_08.java b/test/testsuite/ouroboros/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/RC_Thread_08.java
new file mode 100755
index 0000000000000000000000000000000000000000..c2a63d07aeea90145b176f2bb93e5795155eaf9f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/RC_Thread_08.java
@@ -0,0 +1,284 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_08.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_08.java
+ *- @ExecuteClass: RC_Thread_08
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+import java.lang.Runtime;
+class RC_Thread_08_1 extends Thread {
+    public void run() {
+        RC_Thread_08 rcth01 = new RC_Thread_08();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_08_2 extends Thread {
+    public void run() {
+        RC_Thread_08 rcth01 = new RC_Thread_08();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_08_3 extends Thread {
+    public void run() {
+        RC_Thread_08 rcth01 = new RC_Thread_08();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_08 {
+    private volatile static RC_Thread_08_A1 a1_main = null;
+    private volatile static RC_Thread_08_A4 a4_main = null;
+    private volatile static RC_Thread_08_A6 a6_main = null;
+
+    RC_Thread_08() {
+        try {
+            RC_Thread_08_A1 a1 = new RC_Thread_08_A1("a1");
+            RC_Thread_08_A4 a4 = new RC_Thread_08_A4("a4");
+            RC_Thread_08_A6 a6 = new RC_Thread_08_A6("a6");
+            a1.a2_0 = new RC_Thread_08_A2("a2_0");
+            a1.a2_0.a3_0 = new RC_Thread_08_A3("a3_0");
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1.a2_0.a3_0.a5_0 = new RC_Thread_08_A5("a5_0");
+            a1.a2_0.a3_0.a5_0.a6_0 = a6;
+            a6.a1_0 = a1;
+            a6.a3_0 = a1.a2_0.a3_0;
+            a4.a5_0 = a1.a2_0.a3_0.a5_0;
+            a6.a4_0 = a4;
+            a1_main = a1;
+            a4_main = a4;
+            a6_main = a6;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+		
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+		System.out.println("ExpectResult");
+        
+    }
+
+    private static void cycle_pattern_wrapper(){
+        RC_Thread_08_A1 a1 = new RC_Thread_08_A1("a1");
+        RC_Thread_08_A4 a4 = new RC_Thread_08_A4("a4");
+        RC_Thread_08_A6 a6 = new RC_Thread_08_A6("a6");
+        a1.a2_0 = new RC_Thread_08_A2("a2_0");
+        a1.a2_0.a3_0 = new RC_Thread_08_A3("a3_0");
+        a1.a2_0.a3_0.a1_0 = a1;
+        a1.a2_0.a3_0.a5_0 = new RC_Thread_08_A5("a5_0");
+        a1.a2_0.a3_0.a5_0.a6_0 = a6;
+        a6.a1_0 = a1;
+        a6.a3_0 = a1.a2_0.a3_0;
+        a4.a5_0 = a1.a2_0.a3_0.a5_0;
+        a6.a4_0 = a4;
+        a1=null;
+        a4=null;
+        a6=null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_08_1 t_00010= new RC_Thread_08_1();
+        RC_Thread_08_2 t_00020= new RC_Thread_08_2();
+        RC_Thread_08_3 t_00030= new RC_Thread_08_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {}
+
+        }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RC_Thread_08_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RC_Thread_08_A3 a3 = new RC_Thread_08_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RC_Thread_08_A1 {
+        volatile RC_Thread_08_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RC_Thread_08_A2 {
+        volatile RC_Thread_08_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_08_A3 {
+        volatile RC_Thread_08_A1 a1_0;
+        volatile RC_Thread_08_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RC_Thread_08_A4 {
+        volatile RC_Thread_08_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RC_Thread_08_A5 {
+        volatile RC_Thread_08_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_08_A6 {
+        volatile RC_Thread_08_A1 a1_0;
+        volatile RC_Thread_08_A3 a3_0;
+        volatile RC_Thread_08_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_08_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/RC_Thread_09.java b/test/testsuite/ouroboros/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/RC_Thread_09.java
new file mode 100755
index 0000000000000000000000000000000000000000..9a55a8808fea7394cc97e4356856fc1d0664145b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/RC_Thread_09.java
@@ -0,0 +1,425 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_09
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00180
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_09.java
+ *- @ExecuteClass: RC_Thread_09
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+
+class RC_Thread_09_1 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_09_2 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_09_3 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_09_4 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_09_5 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_09 {
+    private static RC_Thread_09_A1 a1_main = null;
+    private static RC_Thread_09_A2 a2_main = null;
+    private static RC_Thread_09_A3 a3_main = null;
+    private static RC_Thread_09_A4 a4_main = null;
+
+    RC_Thread_09() {
+        try {
+            a1_main = new RC_Thread_09_A1("a1_main");
+            a2_main = new RC_Thread_09_A2("a2_main");
+            a3_main = new RC_Thread_09_A3("a3_main");
+            a4_main = new RC_Thread_09_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_09_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_09_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_09_D2("d2_0");
+
+            a2_main.b2_0 = new RC_Thread_09_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_09_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_09_D1("d1_0");
+
+            a3_main.b2_0 = new RC_Thread_09_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_09_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+
+            a3_main.c2_0 = new RC_Thread_09_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+
+            a4_main.b3_0 = new RC_Thread_09_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_09_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_09_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_09_1 t1 = new RC_Thread_09_1();
+        RC_Thread_09_2 t2 = new RC_Thread_09_2();
+        RC_Thread_09_3 t3 = new RC_Thread_09_3();
+        RC_Thread_09_4 t4 = new RC_Thread_09_4();
+        RC_Thread_09_5 t5 = new RC_Thread_09_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA2null() {
+        a2_main = null;
+    }
+
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_09_D2("new");
+            a3_main = new RC_Thread_09_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        a3_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    class RC_Thread_09_A1 {
+        RC_Thread_09_B1 b1_0;
+        RC_Thread_09_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_A2 {
+        RC_Thread_09_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_A3 {
+        RC_Thread_09_B2 b2_0;
+        RC_Thread_09_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class RC_Thread_09_A4 {
+        RC_Thread_09_B3 b3_0;
+        RC_Thread_09_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_B1 {
+        RC_Thread_09_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_B2 {
+        RC_Thread_09_C1 c1_0;
+        RC_Thread_09_D1 d1_0;
+        RC_Thread_09_D2 d2_0;
+        RC_Thread_09_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_B3 {
+        RC_Thread_09_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_C1 {
+        RC_Thread_09_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class RC_Thread_09_C2 {
+        RC_Thread_09_D2 d2_0;
+        RC_Thread_09_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_09_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_09_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_09_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_09_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/RC_Thread_10.java b/test/testsuite/ouroboros/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/RC_Thread_10.java
new file mode 100755
index 0000000000000000000000000000000000000000..fce1873180e2dbb6feb5e7b8033d4270acfe53db
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/RC_Thread_10.java
@@ -0,0 +1,294 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_10
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00050
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_10.java
+ *- @ExecuteClass: RC_Thread_10
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+class RC_Thread_10_1 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.addSum();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_10_2 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.ModifyB4();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_10_3 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.deleteA1();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_10_4 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.setA1(null);
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_10 {
+    private static RC_Thread_10_A1 a1 = null;
+
+    RC_Thread_10(String str) {
+        try {
+            a1 = new RC_Thread_10_A1("a1");
+            a1.b1_0 = new RC_Thread_10_B1("b1_0");
+            a1.b1_0.c1_0 = new RC_Thread_10_C1("c1_0");
+            a1.b1_0.c2_0 = new RC_Thread_10_C2("c2_0");
+            a1.b1_0.c3_0 = new RC_Thread_10_C3("c3_0");
+            a1.b2_0 = new RC_Thread_10_B2("b2_0");
+            a1.b3_0 = new RC_Thread_10_B3("b3_0");
+            a1.b4_0 = new RC_Thread_10_B4("b4_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_10_1 t1 = new RC_Thread_10_1();
+        RC_Thread_10_2 t2 = new RC_Thread_10_2();
+        RC_Thread_10_3 t3 = new RC_Thread_10_3();
+        RC_Thread_10_4 t4 = new RC_Thread_10_4();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void deleteA1() {
+        a1 = null;
+    }
+
+    public void ModifyB4() {
+        try {
+            a1.b4_0 = new RC_Thread_10_B4("new_b4");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void addSum() {
+        try {
+            a1.add();
+            a1.b1_0.add();
+            a1.b2_0.add();
+            a1.b3_0.add();
+            a1.b4_0.add();
+            a1.b1_0.c1_0.add();
+            a1.b1_0.c2_0.add();
+            a1.b1_0.c3_0.add();
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA1(RC_Thread_10_A1 a1) {
+        this.a1 = a1;
+    }
+
+    class RC_Thread_10_A1 {
+        RC_Thread_10_B1 b1_0;
+        RC_Thread_10_B2 b2_0;
+        RC_Thread_10_B3 b3_0;
+        RC_Thread_10_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class RC_Thread_10_B1 {
+        RC_Thread_10_C1 c1_0;
+        RC_Thread_10_C2 c2_0;
+        RC_Thread_10_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class RC_Thread_10_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+
+    class RC_Thread_10_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_10_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_10_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_10_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_10_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_10_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/RC_Thread_11.java b/test/testsuite/ouroboros/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/RC_Thread_11.java
new file mode 100755
index 0000000000000000000000000000000000000000..77902fd128dd337be9e18de442aa81ac8b1126a3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/RC_Thread_11.java
@@ -0,0 +1,428 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_11
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00180
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_11.java
+ *- @ExecuteClass: RC_Thread_11
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+
+class RC_Thread_11_1 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_11_2 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_11_3 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_11_4 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_11_5 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA4();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_11 {
+    private static RC_Thread_11_A1 a1_main = null;
+    private static RC_Thread_11_A2 a2_main = null;
+    private static RC_Thread_11_A3 a3_main = null;
+    private static RC_Thread_11_A4 a4_main = null;
+
+    RC_Thread_11() {
+        try {
+            a1_main = new RC_Thread_11_A1("a1_main");
+            a2_main = new RC_Thread_11_A2("a2_main");
+            a3_main = new RC_Thread_11_A3("a3_main");
+            a4_main = new RC_Thread_11_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_11_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_11_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_11_D2("d2_0");
+
+            a2_main.b2_0 = new RC_Thread_11_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_11_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_11_D1("d1_0");
+
+            a3_main.b2_0 = new RC_Thread_11_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_11_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+
+            a3_main.c2_0 = new RC_Thread_11_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+
+            a4_main.b3_0 = new RC_Thread_11_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_11_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_11_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_11_1 t1 = new RC_Thread_11_1();
+        RC_Thread_11_2 t2 = new RC_Thread_11_2();
+        RC_Thread_11_3 t3 = new RC_Thread_11_3();
+        RC_Thread_11_4 t4 = new RC_Thread_11_4();
+        RC_Thread_11_5 t5 = new RC_Thread_11_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA2null() {
+        a2_main = null;
+    }
+
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_11_D2("new");
+            a3_main = new RC_Thread_11_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        a3_main = null;
+    }
+
+    public void setA4() {
+        try {
+            a4_main = new RC_Thread_11_A4("a4_new");
+
+        } catch (NullPointerException e) {
+        }
+    }
+
+    class RC_Thread_11_A1 {
+        RC_Thread_11_B1 b1_0;
+        RC_Thread_11_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_A2 {
+        RC_Thread_11_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_A3 {
+        RC_Thread_11_B2 b2_0;
+        RC_Thread_11_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+
+    class RC_Thread_11_A4 {
+        RC_Thread_11_B3 b3_0;
+        RC_Thread_11_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_B1 {
+        RC_Thread_11_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_B2 {
+        RC_Thread_11_C1 c1_0;
+        RC_Thread_11_D1 d1_0;
+        RC_Thread_11_D2 d2_0;
+        RC_Thread_11_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_B3 {
+        RC_Thread_11_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_C1 {
+        RC_Thread_11_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+
+    class RC_Thread_11_C2 {
+        RC_Thread_11_D2 d2_0;
+        RC_Thread_11_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+
+
+    class RC_Thread_11_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_11_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_11_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_11_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/RC_Thread_12.java b/test/testsuite/ouroboros/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/RC_Thread_12.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1ecec150d89c5945500a40143fd43caff353f58
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/RC_Thread_12.java
@@ -0,0 +1,218 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_12
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_12.java
+ *- @ExecuteClass: RC_Thread_12
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+import java.lang.Runtime;
+class RC_Thread_12_1 extends Thread {
+    public void run() {
+        RC_Thread_12 rcth01 = new RC_Thread_12();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_12_2 extends Thread {
+    public void run() {
+        RC_Thread_12 rcth01 = new RC_Thread_12();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_12_3 extends Thread {
+    public void run() {
+        RC_Thread_12 rcth01 = new RC_Thread_12();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_12 {
+    private static RC_Thread_12_A1 a1_main = null;
+    private static RC_Thread_12_A4 a4_main = null;
+    private static RC_Thread_12_A5 a5_main = null;
+
+    RC_Thread_12() {
+        try {
+            a1_main = new RC_Thread_12_A1();
+            a1_main.a2_0 = new RC_Thread_12_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_12_A3();
+            a4_main = new RC_Thread_12_A4();
+            a5_main = new RC_Thread_12_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper(){
+        a1_main = new RC_Thread_12_A1();
+        a1_main.a2_0 = new RC_Thread_12_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_12_A3();
+        a4_main = new RC_Thread_12_A4();
+        a5_main = new RC_Thread_12_A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main=null;
+        a4_main=null;
+        a5_main=null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_12_1 t1 = new RC_Thread_12_1();
+        RC_Thread_12_2 t2 = new RC_Thread_12_2();
+        RC_Thread_12_3 t3 = new RC_Thread_12_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_12_A1 {
+        RC_Thread_12_A2 a2_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_12_A2 {
+        RC_Thread_12_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_12_A3 {
+        RC_Thread_12_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    static class RC_Thread_12_A4 {
+        RC_Thread_12_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    static class RC_Thread_12_A5 {
+        RC_Thread_12_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_12_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/RC_Thread_13.java b/test/testsuite/ouroboros/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/RC_Thread_13.java
new file mode 100755
index 0000000000000000000000000000000000000000..d50060cbfd68f7b5c72326a03de71b257619e614
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/RC_Thread_13.java
@@ -0,0 +1,273 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_13
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_13.java
+ *- @ExecuteClass: RC_Thread_13
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+import java.lang.Runtime;
+class RC_Thread_13_1 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_13_2 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_13_3 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_13_4 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA1();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_13_5 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_13_6 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA3_a(5);
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_13 {
+    private static RC_Thread_13_A1 a1_main = null;
+    private static RC_Thread_13_A4 a4_main = null;
+    private static RC_Thread_13_A5 a5_main = null;
+
+    RC_Thread_13() {
+        try {
+            a1_main = new RC_Thread_13_A1();
+            a1_main.a2_0 = new RC_Thread_13_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_13_A3();
+            a4_main = new RC_Thread_13_A4();
+            a5_main = new RC_Thread_13_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_13_1 t1 = new RC_Thread_13_1();
+        RC_Thread_13_2 t2 = new RC_Thread_13_2();
+        RC_Thread_13_3 t3 = new RC_Thread_13_3();
+        RC_Thread_13_4 t4 = new RC_Thread_13_4();
+        RC_Thread_13_5 t5 = new RC_Thread_13_5();
+        RC_Thread_13_6 t6 = new RC_Thread_13_6();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        t6.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+            t6.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    public void setA1() {
+        try {
+            this.a1_main = new RC_Thread_13_A1();
+            a1_main.a2_0 = new RC_Thread_13_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_13_A3();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    public void checkA3() {
+        try {
+            int a = a1_main.a2_0.a3_0.a;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    public void setA3_a(int a) {
+        try {
+            this.a1_main.a2_0.a3_0.a = a;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    class RC_Thread_13_A1 {
+        RC_Thread_13_A2 a2_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    class RC_Thread_13_A2 {
+        RC_Thread_13_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    class RC_Thread_13_A3 {
+        RC_Thread_13_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class RC_Thread_13_A4 {
+        RC_Thread_13_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    class RC_Thread_13_A5 {
+        RC_Thread_13_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_13_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/RC_Thread_14.java b/test/testsuite/ouroboros/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/RC_Thread_14.java
new file mode 100755
index 0000000000000000000000000000000000000000..6c1373649f8e11ba3ad4a6217e87410d9fc87dc7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/RC_Thread_14.java
@@ -0,0 +1,261 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_14
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_14.java
+ *- @ExecuteClass: RC_Thread_14
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+import java.lang.Runtime;
+class RC_Thread_14_1 extends Thread {
+    public void run() {
+        RC_Thread_14 rcth01 = new RC_Thread_14();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_14_2 extends Thread {
+    public void run() {
+        RC_Thread_14 rcth01 = new RC_Thread_14();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_14_3 extends Thread {
+    public void run() {
+        RC_Thread_14 rcth01 = new RC_Thread_14();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+
+    }
+}
+
+public class RC_Thread_14 {
+    private static RC_Thread_14_A1 a1_main = null;
+    private static RC_Thread_14_A5 a5_main = null;
+
+    RC_Thread_14() {
+        try {
+            a1_main = new RC_Thread_14_A1();
+            a1_main.a2_0 = new RC_Thread_14_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+            a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+            a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+            a5_main = new RC_Thread_14_A5();
+            a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_14_A6();
+            a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+            a5_main.a3_0 = a1_main.a2_0.a3_0;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        Runtime.getRuntime().gc();
+        
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper(){
+        a1_main = new RC_Thread_14_A1();
+        a1_main.a2_0 = new RC_Thread_14_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_14_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_14_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main=null;
+        a5_main=null;
+
+        a1_main = new RC_Thread_14_A1();
+        a1_main.a2_0 = new RC_Thread_14_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main=null;
+
+        a1_main = new RC_Thread_14_A1();
+        a1_main.a2_0 = new RC_Thread_14_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_14_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_14_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0=null;
+        a1_main=null;
+        a5_main=null;
+        //Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_14_1 t1 = new RC_Thread_14_1();
+        RC_Thread_14_2 t2 = new RC_Thread_14_2();
+        RC_Thread_14_3 t3 = new RC_Thread_14_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        try {
+            a1_main.a2_0.a3_0.a4_0 = null;
+            a5_main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_14_A1 {
+        RC_Thread_14_A2 a2_0;
+        RC_Thread_14_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_14_A2 {
+        RC_Thread_14_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_14_A3 {
+        RC_Thread_14_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+
+    static class RC_Thread_14_A4 {
+        RC_Thread_14_A1 a1_0;
+        RC_Thread_14_A6 a6_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_14_A5 {
+        RC_Thread_14_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_14_A6 {
+        RC_Thread_14_A5 a5_0;
+        int a;
+        int sum;
+
+        RC_Thread_14_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/RC_Thread_15.java b/test/testsuite/ouroboros/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/RC_Thread_15.java
new file mode 100755
index 0000000000000000000000000000000000000000..7a0e0101702e2b45668f311ad9ed2b5f29736029
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/RC_Thread_15.java
@@ -0,0 +1,248 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_15
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_15.java
+ *- @ExecuteClass: RC_Thread_15
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+import java.lang.Runtime;
+class RC_Thread_15_1 extends Thread {
+    public void run() {
+        RC_Thread_15 rcth01 = new RC_Thread_15();
+        try {
+            rcth01.ModifyA1();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_15_2 extends Thread {
+    public void run() {
+        RC_Thread_15 rcth01 = new RC_Thread_15();
+        try {
+            rcth01.checkA4();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_15_3 extends Thread {
+    public void run() {
+        RC_Thread_15 rcth01 = new RC_Thread_15();
+        try {
+            rcth01.setA5();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_15 {
+    private static RC_Thread_15_A1 a1_main = null;
+    private static RC_Thread_15_A5 a5_main = null;
+
+    RC_Thread_15() {
+        try {
+            RC_Thread_15_A1 a1 = new RC_Thread_15_A1();
+            a1.a2_0 = new RC_Thread_15_A2();
+            a1.a2_0.a3_0 = new RC_Thread_15_A3();
+            a1.a2_0.a3_0.a4_0 = new RC_Thread_15_A4();
+            a1.a2_0.a3_0.a4_0.a1_0 = a1;
+            RC_Thread_15_A5 a5 = new RC_Thread_15_A5();
+            a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_15_A6();
+            a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+            a5.a3_0 = a1.a2_0.a3_0;
+            a1_main = a1;
+            a5_main = a5;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper(){
+        RC_Thread_15_A1 a1 = new RC_Thread_15_A1();
+        a1.a2_0 = new RC_Thread_15_A2();
+        a1.a2_0.a3_0 = new RC_Thread_15_A3();
+        a1.a2_0.a3_0.a4_0 = new RC_Thread_15_A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        RC_Thread_15_A5 a5 = new RC_Thread_15_A5();
+        a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_15_A6();
+        a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+        a5.a3_0 = a1.a2_0.a3_0;
+        a1=null;
+        a5=null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_15_1 t1 = new RC_Thread_15_1();
+        RC_Thread_15_2 t2 = new RC_Thread_15_2();
+        RC_Thread_15_3 t3 = new RC_Thread_15_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void ModifyA1() {
+        a1_main.a2_0.a3_0 = null;
+        a1_main = null;
+    }
+
+    public void checkA4() {
+        try {
+            int[] arr = new int[2];
+            arr[0] = a5_main.a3_0.a4_0.sum;
+            arr[1] = a5_main.a3_0.a4_0.a;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA5() {
+        RC_Thread_15_A5 a5 = new RC_Thread_15_A5();
+        a5 = this.a5_main;
+        a5_main = null;
+    }
+
+    static class RC_Thread_15_A1 {
+        RC_Thread_15_A2 a2_0;
+        RC_Thread_15_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_15_A2 {
+        RC_Thread_15_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_15_A3 {
+        RC_Thread_15_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+
+    static class RC_Thread_15_A4 {
+        RC_Thread_15_A1 a1_0;
+        RC_Thread_15_A6 a6_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_15_A5 {
+        RC_Thread_15_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_15_A6 {
+        RC_Thread_15_A5 a5_0;
+        int a;
+        int sum;
+
+        RC_Thread_15_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/RC_Thread_16.java b/test/testsuite/ouroboros/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/RC_Thread_16.java
new file mode 100755
index 0000000000000000000000000000000000000000..b5d3d9c65c7bea0dca01c9a112ee1eb7e02b1f59
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/RC_Thread_16.java
@@ -0,0 +1,284 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_16
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_16.java
+ *- @ExecuteClass: RC_Thread_16
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+import java.lang.Runtime;
+class RC_Thread_16_1 extends Thread {
+    public void run() {
+        RC_Thread_16 rcth01 = new RC_Thread_16();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_16_2 extends Thread {
+    public void run() {
+        RC_Thread_16 rcth01 = new RC_Thread_16();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_16_3 extends Thread {
+    public void run() {
+        RC_Thread_16 rcth01 = new RC_Thread_16();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_16 {
+    private static RC_Thread_16_A1 a1_main = null;
+    private static RC_Thread_16_A4 a4_main = null;
+    private static RC_Thread_16_A6 a6_main = null;
+
+    RC_Thread_16() {
+        try {
+            RC_Thread_16_A1 a1 = new RC_Thread_16_A1("a1");
+            RC_Thread_16_A4 a4 = new RC_Thread_16_A4("a4");
+            RC_Thread_16_A6 a6 = new RC_Thread_16_A6("a6");
+            a1.a2_0 = new RC_Thread_16_A2("a2_0");
+            a1.a2_0.a3_0 = new RC_Thread_16_A3("a3_0");
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1.a2_0.a3_0.a5_0 = new RC_Thread_16_A5("a5_0");
+            a1.a2_0.a3_0.a5_0.a6_0 = a6;
+            a6.a1_0 = a1;
+            a6.a3_0 = a1.a2_0.a3_0;
+            a4.a5_0 = a1.a2_0.a3_0.a5_0;
+            a6.a4_0 = a4;
+            a1_main = a1;
+            a4_main = a4;
+            a6_main = a6;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+		System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper(){
+        RC_Thread_16_A1 a1 = new RC_Thread_16_A1("a1");
+        RC_Thread_16_A4 a4 = new RC_Thread_16_A4("a4");
+        RC_Thread_16_A6 a6 = new RC_Thread_16_A6("a6");
+        a1.a2_0 = new RC_Thread_16_A2("a2_0");
+        a1.a2_0.a3_0 = new RC_Thread_16_A3("a3_0");
+        a1.a2_0.a3_0.a1_0 = a1;
+        a1.a2_0.a3_0.a5_0 = new RC_Thread_16_A5("a5_0");
+        a1.a2_0.a3_0.a5_0.a6_0 = a6;
+        a6.a1_0 = a1;
+        a6.a3_0 = a1.a2_0.a3_0;
+        a4.a5_0 = a1.a2_0.a3_0.a5_0;
+        a6.a4_0 = a4;
+        a1=null;
+        a4=null;
+        a6=null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_16_1 t_00010 = new RC_Thread_16_1();
+        RC_Thread_16_2 t_00020 = new RC_Thread_16_2();
+        RC_Thread_16_3 t_00030 = new RC_Thread_16_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {
+        }
+
+    }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RC_Thread_16_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RC_Thread_16_A3 a3 = new RC_Thread_16_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RC_Thread_16_A1 {
+        RC_Thread_16_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RC_Thread_16_A2 {
+        RC_Thread_16_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_16_A3 {
+        RC_Thread_16_A1 a1_0;
+        RC_Thread_16_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RC_Thread_16_A4 {
+        RC_Thread_16_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RC_Thread_16_A5 {
+        RC_Thread_16_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_16_A6 {
+        RC_Thread_16_A1 a1_0;
+        RC_Thread_16_A3 a3_0;
+        RC_Thread_16_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_16_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/RC_Thread_17.java b/test/testsuite/ouroboros/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/RC_Thread_17.java
new file mode 100755
index 0000000000000000000000000000000000000000..a806041145ffc1c989c3fcafdce64af42d03d4dc
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/RC_Thread_17.java
@@ -0,0 +1,222 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_17
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_17.java
+ *- @ExecuteClass: RC_Thread_17
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+import java.lang.Runtime;
+class RC_Thread_17_1 extends Thread {
+    public void run() {
+        RC_Thread_17 rcth01 = new RC_Thread_17();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_17_2 extends Thread {
+    public void run() {
+        RC_Thread_17 rcth01 = new RC_Thread_17();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_17_3 extends Thread {
+    public void run() {
+        RC_Thread_17 rcth01 = new RC_Thread_17();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_17 {
+    private static RC_Thread_17_A1 a1_main = null;
+    private static RC_Thread_17_A4 a4_main = null;
+    private static RC_Thread_17_A5 a5_main = null;
+    private static RC_Thread_17_A2 a2=null;
+
+    RC_Thread_17() {
+        try {
+            a1_main = new RC_Thread_17_A1();
+            a2 = new RC_Thread_17_A2();
+            a1_main.a2_0=a2;
+            a1_main.a2_0.a3_0 = new RC_Thread_17_A3();
+            a4_main = new RC_Thread_17_A4();
+            a5_main = new RC_Thread_17_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper(){
+        a1_main = new RC_Thread_17_A1();
+        a2 = new RC_Thread_17_A2();
+        a1_main.a2_0=a2;
+        a1_main.a2_0.a3_0 = new RC_Thread_17_A3();
+        a4_main = new RC_Thread_17_A4();
+        a5_main = new RC_Thread_17_A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main=null;
+        a4_main=null;
+        a2=null;
+        a5_main=null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_17_1 t1 = new RC_Thread_17_1();
+        RC_Thread_17_2 t2 = new RC_Thread_17_2();
+        RC_Thread_17_3 t3 = new RC_Thread_17_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_17_A1 {
+        RC_Thread_17_A2 a2_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_17_A2 {
+        RC_Thread_17_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_17_A3 {
+        RC_Thread_17_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    static class RC_Thread_17_A4 {
+        RC_Thread_17_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    static class RC_Thread_17_A5 {
+        RC_Thread_17_A1 a1_0;
+        int a;
+        int sum;
+
+        RC_Thread_17_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/RC_Thread_18.java b/test/testsuite/ouroboros/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/RC_Thread_18.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e00594fd55633284ca18acd248a950392f71feb
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/RC_Thread_18.java
@@ -0,0 +1,287 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_18.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_18.java
+ *- @ExecuteClass: RC_Thread_18
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+import java.lang.Runtime;
+class RC_Thread_18_1 extends Thread {
+    public void run() {
+        RC_Thread_18 rcth01 = new RC_Thread_18();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_18_2 extends Thread {
+    public void run() {
+        RC_Thread_18 rcth01 = new RC_Thread_18();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_18_3 extends Thread {
+    public void run() {
+        RC_Thread_18 rcth01 = new RC_Thread_18();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RC_Thread_18 {
+    private volatile static RC_Thread_18_A1 a1_main = null;
+    private volatile static RC_Thread_18_A4 a4_main = null;
+    private volatile static RC_Thread_18_A6 a6_main = null;
+    private static RC_Thread_18_A2 a2=null;
+    RC_Thread_18() {
+        try {
+            RC_Thread_18_A1 a1 = new RC_Thread_18_A1("a1");
+            RC_Thread_18_A4 a4 = new RC_Thread_18_A4("a4");
+            RC_Thread_18_A6 a6 = new RC_Thread_18_A6("a6");
+            a2 = new RC_Thread_18_A2("a2_0");
+            a1.a2_0=a2;
+            a1.a2_0.a3_0 = new RC_Thread_18_A3("a3_0");
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1.a2_0.a3_0.a5_0 = new RC_Thread_18_A5("a5_0");
+            a1.a2_0.a3_0.a5_0.a6_0 = a6;
+            a6.a1_0 = a1;
+            a6.a3_0 = a1.a2_0.a3_0;
+            a4.a5_0 = a1.a2_0.a3_0.a5_0;
+            a6.a4_0 = a4;
+            a1_main = a1;
+            a4_main = a4;
+            a6_main = a6;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+			
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+
+    }
+
+    private static void cycle_pattern_wrapper(){
+        RC_Thread_18_A1 a1 = new RC_Thread_18_A1("a1");
+        RC_Thread_18_A4 a4 = new RC_Thread_18_A4("a4");
+        RC_Thread_18_A6 a6 = new RC_Thread_18_A6("a6");
+        a2 = new RC_Thread_18_A2("a2_0");
+        a1.a2_0=a2;
+        a1.a2_0.a3_0 = new RC_Thread_18_A3("a3_0");
+        a1.a2_0.a3_0.a1_0 = a1;
+        a1.a2_0.a3_0.a5_0 = new RC_Thread_18_A5("a5_0");
+        a1.a2_0.a3_0.a5_0.a6_0 = a6;
+        a6.a1_0 = a1;
+        a6.a3_0 = a1.a2_0.a3_0;
+        a4.a5_0 = a1.a2_0.a3_0.a5_0;
+        a6.a4_0 = a4;
+        a1=null;
+        a2=null;
+        a4=null;
+        a6=null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_18_1 t_00010= new RC_Thread_18_1();
+        RC_Thread_18_2 t_00020= new RC_Thread_18_2();
+        RC_Thread_18_3 t_00030= new RC_Thread_18_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {}
+
+    }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RC_Thread_18_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RC_Thread_18_A3 a3 = new RC_Thread_18_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RC_Thread_18_A1 {
+        volatile RC_Thread_18_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RC_Thread_18_A2 {
+        volatile RC_Thread_18_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_18_A3 {
+        volatile RC_Thread_18_A1 a1_0;
+        volatile RC_Thread_18_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RC_Thread_18_A4 {
+        volatile RC_Thread_18_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RC_Thread_18_A5 {
+        volatile RC_Thread_18_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_18_A6 {
+        volatile RC_Thread_18_A1 a1_0;
+        volatile RC_Thread_18_A3 a3_0;
+        volatile RC_Thread_18_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_18_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/RC_Thread_19.java b/test/testsuite/ouroboros/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/RC_Thread_19.java
new file mode 100755
index 0000000000000000000000000000000000000000..2722e66ef5f7724183e67134f46cbd31ee82b8bc
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/RC_Thread_19.java
@@ -0,0 +1,296 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_19
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Nocycle_a_00050
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_19.java
+ *- @ExecuteClass: RC_Thread_19
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+class RC_Thread_19_1 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.addSum();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_19_2 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.ModifyB4();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RC_Thread_19_3 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.deleteA1();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+class RC_Thread_19_4 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.setA1(null);
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+
+public class RC_Thread_19 {
+    private static RC_Thread_19_A1 a1 = null;
+    private volatile  static RC_Thread_19_B4 b4;
+
+    RC_Thread_19(String str) {
+        try {
+            a1 = new RC_Thread_19_A1("a1");
+            a1.b1_0 = new RC_Thread_19_B1("b1_0");
+            a1.b1_0.c1_0 = new RC_Thread_19_C1("c1_0");
+            a1.b1_0.c2_0 = new RC_Thread_19_C2("c2_0");
+            a1.b1_0.c3_0 = new RC_Thread_19_C3("c3_0");
+            a1.b2_0 = new RC_Thread_19_B2("b2_0");
+            a1.b3_0 = new RC_Thread_19_B3("b3_0");
+            b4=new RC_Thread_19_B4("b4_0");
+            a1.b4_0 =b4;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_19_1 t1 = new RC_Thread_19_1();
+        RC_Thread_19_2 t2 = new RC_Thread_19_2();
+        RC_Thread_19_3 t3 = new RC_Thread_19_3();
+        RC_Thread_19_4 t4 = new RC_Thread_19_4();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void deleteA1() {
+        a1 = null;
+    }
+
+    public void ModifyB4() {
+        try {
+            a1.b4_0 = new RC_Thread_19_B4("new_b4");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void addSum() {
+        try {
+            a1.add();
+            a1.b1_0.add();
+            a1.b2_0.add();
+            a1.b3_0.add();
+            a1.b4_0.add();
+            a1.b1_0.c1_0.add();
+            a1.b1_0.c2_0.add();
+            a1.b1_0.c3_0.add();
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA1(RC_Thread_19_A1 a1) {
+        this.a1 = a1;
+    }
+
+    class RC_Thread_19_A1 {
+        RC_Thread_19_B1 b1_0;
+        RC_Thread_19_B2 b2_0;
+        RC_Thread_19_B3 b3_0;
+        RC_Thread_19_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+
+    class RC_Thread_19_B1 {
+        RC_Thread_19_C1 c1_0;
+        RC_Thread_19_C2 c2_0;
+        RC_Thread_19_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+
+    class RC_Thread_19_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+
+    class RC_Thread_19_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_19_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_19_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_19_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class RC_Thread_19_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        RC_Thread_19_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/RC_Thread_20.java b/test/testsuite/ouroboros/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/RC_Thread_20.java
new file mode 100755
index 0000000000000000000000000000000000000000..c65663e0d8abbea8c621899d1592407f376422c9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/RC_Thread_20.java
@@ -0,0 +1,248 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RC_Thread_20
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_2_00130
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Thread_20.java
+ *- @ExecuteClass: RC_Thread_20
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+import java.lang.Runtime;
+class RC_Thread_20_1 extends Thread {
+    public void run() {
+        RC_Thread_20 rcth01 = new RC_Thread_20();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_20_2 extends Thread {
+    public void run() {
+        RC_Thread_20 rcth01 = new RC_Thread_20();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class RC_Thread_20_3 extends Thread {
+    public void run() {
+        RC_Thread_20 rcth01 = new RC_Thread_20();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+
+    }
+}
+
+public class RC_Thread_20 {
+    private static RC_Thread_20_A1 a1_main = null;
+    private static RC_Thread_20_A5 a5_main = null;
+    private static RC_Thread_20_A4 a4;
+
+    RC_Thread_20() {
+        try {
+            RC_Thread_20_A1 a1 = new RC_Thread_20_A1();
+            a1.a2_0 = new RC_Thread_20_A2();
+            a1.a2_0.a3_0 = new RC_Thread_20_A3();
+            RC_Thread_20_A4 a4_temp=new RC_Thread_20_A4();
+            a1.a2_0.a3_0.a4_0 = a4_temp;
+            a1.a2_0.a3_0.a4_0.a1_0 = a1;
+            RC_Thread_20_A5 a5 = new RC_Thread_20_A5();
+            a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_20_A6();
+            a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+            a5.a3_0 = a1.a2_0.a3_0;
+            a1_main=a1;
+	        a4=a4_temp;
+	        a5_main=a5;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        Runtime.getRuntime().gc();
+		
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void cycle_pattern_wrapper(){
+        a1_main = new RC_Thread_20_A1();
+        a1_main.a2_0 = new RC_Thread_20_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_20_A3();
+        a4=new RC_Thread_20_A4();
+        a1_main.a2_0.a3_0.a4_0 = a4;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_20_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_20_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main=null;
+        a4=null;
+        a5_main=null;
+        Runtime.getRuntime().gc();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_20_1 t1 = new RC_Thread_20_1();
+        RC_Thread_20_2 t2 = new RC_Thread_20_2();
+        RC_Thread_20_3 t3 = new RC_Thread_20_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        try {
+            a1_main.a2_0.a3_0.a4_0 = null;
+            a5_main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RC_Thread_20_A1 {
+        RC_Thread_20_A2 a2_0;
+        RC_Thread_20_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RC_Thread_20_A2 {
+        RC_Thread_20_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RC_Thread_20_A3 {
+        RC_Thread_20_A4 a4_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+
+    static class RC_Thread_20_A4 {
+        RC_Thread_20_A1 a1_0;
+        RC_Thread_20_A6 a6_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+
+    static class RC_Thread_20_A5 {
+        RC_Thread_20_A3 a3_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RC_Thread_20_A6 {
+        RC_Thread_20_A5 a5_0;
+        int a;
+        int sum;
+
+        RC_Thread_20_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0248-rc-function-RC_Finalize_02/RC_Finalize_02.java b/test/testsuite/ouroboros/rc_test/RC0248-rc-function-RC_Finalize_02/RC_Finalize_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..34821eba22c31f7adcaeea279470abc3e716913b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0248-rc-function-RC_Finalize_02/RC_Finalize_02.java
@@ -0,0 +1,37 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Finalize_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test Finalizer for RC .
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Finalize_02.java
+ *- @ExecuteClass: RC_Finalize_02
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.io.PrintStream;
+
+public class RC_Finalize_02 {
+
+    public void finalize() { 
+	System.out.println("ExpectResult");
+    }
+
+    public static int run(String argv[], PrintStream out) {
+	return 0;
+    }
+
+    public static void main(String argv[]) {
+
+	System.runFinalizersOnExit(true);
+	RC_Finalize_02 testClass = new RC_Finalize_02();
+    }
+} // end RC_Finalize_02
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0249-rc-function-RC_Finalize_03/RC_Finalize_03.java b/test/testsuite/ouroboros/rc_test/RC0249-rc-function-RC_Finalize_03/RC_Finalize_03.java
new file mode 100755
index 0000000000000000000000000000000000000000..5de249135c63f76eb202725459d0badb8784e8f4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0249-rc-function-RC_Finalize_03/RC_Finalize_03.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Finalize_03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test Finalizer for RC .
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Finalize_03.java
+ *- @ExecuteClass: RC_Finalize_03
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.io.PrintStream;
+class RC_Finalize_031 {
+    public void finalize() {
+        RC_Finalize_03.fo_finalized = true;
+        RC_Finalize_03.dummy = 1 / RC_Finalize_03.zero;
+        RC_Finalize_03.fo_exception_occerred = false;
+    }
+}
+public class RC_Finalize_03 {
+
+    public static boolean fo_finalized;
+    public static boolean fo_exception_occerred;
+    public static final long TIMEOUT = 50000;
+    public static final int zero = 0;
+    public static int dummy;
+
+    public static int run(String argv[], PrintStream out) {
+
+        fo_finalized = false;
+        fo_exception_occerred = true;
+
+        RC_Finalize_031 cl1 = new RC_Finalize_031();
+        cl1 = null;
+        long startTime = System.currentTimeMillis();
+        while (System.currentTimeMillis() - startTime < TIMEOUT){
+            Runtime.getRuntime().gc();
+            Runtime.getRuntime().runFinalization();
+            if (!fo_finalized) {
+                try {
+                    Thread.sleep(500);
+                } catch (InterruptedException e) {
+                    //out.println("InterruptedException: " + e);
+                    return 2;
+                } catch(Throwable e) {
+                    //out.println("Throwable: " + e);
+                    return 2;
+                }
+            } else {
+                break;
+            }
+        }
+        if (!fo_finalized) {
+            //out.println("Ok, RC_Finalize_031 was not finalized during " + TIMEOUT/1000 + "sec");
+            return 0;
+        }
+
+        if (fo_exception_occerred) {
+            return 0;
+        } else {
+            //out.println("Failed: expected exception is not thrown");
+        }
+
+        return 2;
+    }
+
+    public static void main(String argv[]) {
+        if(run(argv, System.out)==0)
+			System.out.println("ExpectResult");
+
+    }
+} // end RC_Finalize_03
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/Alloc_11_15x8B.java b/test/testsuite/ouroboros/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/Alloc_11_15x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..6fb8e99ee181be24c25489a5923da7dcdc479e87
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/Alloc_11_15x8B.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID:Alloc_11_15x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 11*8B to 15*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_11_15x8B.java
+ *- @ExecuteClass: Alloc_11_15x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_11_15x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_11_8B=11*8;
+    private final static int MAX_12_8B=12*8;
+    private final static int MAX_13_8B=13*8;
+    private final static int MAX_14_8B=14*8;
+    private final static int MAX_15_8B=15*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*2/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize11 = alloc_test(MAX_11_8B);
+        int countSize12 = alloc_test(MAX_12_8B);
+        int countSize13 = alloc_test(MAX_13_8B);
+        int countSize14 = alloc_test(MAX_14_8B);
+        int countSize15 = alloc_test(MAX_15_8B);
+        //System.out.println(countSize11);
+        //System.out.println(countSize12);
+        //System.out.println(countSize13);
+        //System.out.println(countSize14);
+        //System.out.println(countSize15);
+
+        if (countSize11 == 853 && countSize12 == 788 && countSize13 == 728 && countSize14 == 681 && countSize15 == 639)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/Alloc_128x8B.java b/test/testsuite/ouroboros/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/Alloc_128x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..f068c310bc3c5cc83e7f78481f08570bfc294a52
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/Alloc_128x8B.java
@@ -0,0 +1,63 @@
+/*
+ *- @TestCaseID:Alloc_128x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 64*8B to 128*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_128x8B.java
+ *- @ExecuteClass: Alloc_128x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_128x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        int sum=0;
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i=i+3)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+5);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum +=store.size();
+            store=new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+
+        int result = alloc_test(MAX_128_8B);
+        //System.out.println(result);
+        if ( result == 243561)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/Alloc_16_20x8B.java b/test/testsuite/ouroboros/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/Alloc_16_20x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..3d1f959699fd3da891a8f3ce07f0d66c10babab2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/Alloc_16_20x8B.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID:Alloc_16_20x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 16*8B to 20*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_16_20x8B.java
+ *- @ExecuteClass: Alloc_16_20x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_16_20x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_16_8B=16*8;
+    private final static int MAX_17_8B=17*8;
+    private final static int MAX_18_8B=18*8;
+    private final static int MAX_19_8B=19*8;
+    private final static int MAX_20_8B=20*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*2/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize16 = alloc_test(MAX_16_8B);
+        int countSize17 = alloc_test(MAX_17_8B);
+        int countSize18 = alloc_test(MAX_18_8B);
+        int countSize19 = alloc_test(MAX_19_8B);
+        int countSize20 = alloc_test(MAX_20_8B);
+        //System.out.println(countSize16);
+        //System.out.println(countSize17);
+        //System.out.println(countSize18);
+        //System.out.println(countSize19);
+        //System.out.println(countSize20);
+
+        if (countSize16 == 604 && countSize17 == 572 && countSize18 == 542 && countSize19 == 517 && countSize20 == 495)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/Alloc_192x8B.java b/test/testsuite/ouroboros/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/Alloc_192x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..e4718a2f0d9a3b3845a44299754671f32c4aa3e1
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/Alloc_192x8B.java
@@ -0,0 +1,53 @@
+/*
+ * -@TestCaseID:Alloc_192x8B
+ * -@TestCaseName:Alloc_192x8B
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing big objects from 128*8B to 192*8B(max)
+ * -@Condition: no
+ * -#c1
+ * -@Brief:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing big objects from 128*8B to 192*8B(max)
+ * -#step1
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_192x8B.java
+ * -@ExecuteClass: Alloc_192x8B
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_192x8B {
+    private  static final int PAGE_SIZE = 4*1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_192_8B = 192*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type) {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 + 1 - OBJ_HEADSIZE; i <= slot_type - OBJ_HEADSIZE; i = i + 6) {
+            for (int j = 0; j < (PAGE_SIZE * 1280 / (i + OBJ_HEADSIZE) + 5); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum += store.size();
+            store = new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_192_8B);
+        if ( result == 357534) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/Alloc_21_25x8B.java b/test/testsuite/ouroboros/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/Alloc_21_25x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..bad5eec217c57ca817ff4c7b40e298265e41e09c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/Alloc_21_25x8B.java
@@ -0,0 +1,75 @@
+/*
+ *- @TestCaseID:Alloc_21_25x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 21*8B to 25*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_21_25x8B.java
+ *- @ExecuteClass: Alloc_21_25x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_21_25x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_21_8B=21*8;
+    private final static int MAX_22_8B=22*8;
+    private final static int MAX_23_8B=23*8;
+    private final static int MAX_24_8B=24*8;
+    private final static int MAX_25_8B=25*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*3/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize21 = alloc_test(MAX_21_8B);
+        int countSize22 = alloc_test(MAX_22_8B);
+        int countSize23 = alloc_test(MAX_23_8B);
+        int countSize24 = alloc_test(MAX_24_8B);
+        int countSize25 = alloc_test(MAX_25_8B);
+        //System.out.println(countSize21);
+        //System.out.println(countSize22);
+        //System.out.println(countSize23);
+        //System.out.println(countSize24);
+        //System.out.println(countSize25);
+
+        if (countSize21 == 674 && countSize22 == 646 && countSize23 == 621 && countSize24 == 599 && countSize25 == 577)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/Alloc_256x8B.java b/test/testsuite/ouroboros/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/Alloc_256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..d66b7b4ed14fabbe14c45b53423c4fcb6f82f57f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/Alloc_256x8B.java
@@ -0,0 +1,54 @@
+/*
+ *- @TestCaseID:Alloc_256x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing big objects from 192*8B to 256*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_256x8B.java
+ *- @ExecuteClass: Alloc_256x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_256x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_256_8B=256*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        int sum=0;
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+
+        for(int i=1024+1-OBJ_HEADSIZE;i<=slot_type-OBJ_HEADSIZE;i=i+256)
+        {
+            for(int j=0;j<(PAGE_SIZE*5120/(i+OBJ_HEADSIZE)+5);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum +=store.size();
+            store=new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_256_8B);
+        //System.out.println(result);
+        if ( result == 62191)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/Alloc_26_30x8B.java b/test/testsuite/ouroboros/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/Alloc_26_30x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..d074edf1dd07d4a3f0d2c477453c23b0a0a0017f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/Alloc_26_30x8B.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID:Alloc_26_30x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 26*8B to 30*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_26_30x8B.java
+ *- @ExecuteClass: Alloc_26_30x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_26_30x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_26_8B=26*8;
+    private final static int MAX_27_8B=27*8;
+    private final static int MAX_28_8B=28*8;
+    private final static int MAX_29_8B=29*8;
+    private final static int MAX_30_8B=30*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*3/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize26 = alloc_test(MAX_26_8B);
+        int countSize27 = alloc_test(MAX_27_8B);
+        int countSize28 = alloc_test(MAX_28_8B);
+        int countSize29 = alloc_test(MAX_29_8B);
+        int countSize30 = alloc_test(MAX_30_8B);
+        //System.out.println(countSize26);
+        //System.out.println(countSize27);
+        //System.out.println(countSize28);
+        //System.out.println(countSize29);
+        //System.out.println(countSize30);
+
+        if (countSize26 == 557 && countSize27 == 538 && countSize28 == 522 && countSize29 == 506 && countSize30 == 492)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/Alloc_3_10x8B.java b/test/testsuite/ouroboros/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/Alloc_3_10x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..3e045976f7cd3959851105a920c9dc8c51aaba89
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/Alloc_3_10x8B.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID:Alloc_3_10x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 3*8B to 10*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_3_10x8B.java
+ *- @ExecuteClass: Alloc_3_10x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_3_10x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_3_8B=3*8;
+    private final static int MAX_4_8B=4*8;
+    private final static int MAX_5_8B=5*8;
+    private final static int MAX_6_8B=6*8;
+    private final static int MAX_7_8B=7*8;
+    private final static int MAX_8_8B=8*8;
+    private final static int MAX_9_8B=9*8;
+    private final static int MAX_10_8B=10*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+            else if(slot_type==1024){
+                i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args){
+        store=new ArrayList<byte[]>();
+        int countSize3 = alloc_test(MAX_3_8B);
+        int countSize4 = alloc_test(MAX_4_8B);
+        int countSize5 = alloc_test(MAX_5_8B);
+        int countSize6 = alloc_test(MAX_6_8B);
+        int countSize7 = alloc_test(MAX_7_8B);
+        int countSize8 = alloc_test(MAX_8_8B);
+        int countSize9 = alloc_test(MAX_9_8B);
+        int countSize10 = alloc_test(MAX_10_8B);
+        if(countSize3==4488 && countSize4==1234 && countSize5==978 && countSize6==816 && countSize7==701 && countSize8==620 &&countSize9==556 && countSize10==505 )
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/Alloc_31_35x8B.java b/test/testsuite/ouroboros/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/Alloc_31_35x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..cdedd0b2448b2162639d47b54b73d39ba5eb6965
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/Alloc_31_35x8B.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID:Alloc_31_35x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 31*8B to 35*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_31_35x8B.java
+ *- @ExecuteClass: Alloc_31_35x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_31_35x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_31_8B=31*8;
+    private final static int MAX_32_8B=32*8;
+    private final static int MAX_33_8B=33*8;
+    private final static int MAX_34_8B=34*8;
+    private final static int MAX_35_8B=35*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*4/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize31 = alloc_test(MAX_31_8B);
+        int countSize32 = alloc_test(MAX_32_8B);
+        int countSize33 = alloc_test(MAX_33_8B);
+        int countSize34 = alloc_test(MAX_34_8B);
+        int countSize35 = alloc_test(MAX_35_8B);
+        //System.out.println(countSize31);
+        //System.out.println(countSize32);
+        //System.out.println(countSize33);
+        //System.out.println(countSize34);
+        //System.out.println(countSize35);
+
+        if (countSize31 == 612 && countSize32 == 596 && countSize33 == 580 && countSize34 == 564 && countSize35 == 550)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/Alloc_36_40x8B.java b/test/testsuite/ouroboros/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/Alloc_36_40x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..327225d5f3b2a2446b3c1c8ce903a3218ebf0aa8
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/Alloc_36_40x8B.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID:Alloc_36_40x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 36*8B to 40*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_36_40x8B.java
+ *- @ExecuteClass: Alloc_36_40x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_36_40x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_36_8B=36*8;
+    private final static int MAX_37_8B=37*8;
+    private final static int MAX_38_8B=38*8;
+    private final static int MAX_39_8B=39*8;
+    private final static int MAX_40_8B=40*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*4/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize36 = alloc_test(MAX_36_8B);
+        int countSize37 = alloc_test(MAX_37_8B);
+        int countSize38 = alloc_test(MAX_38_8B);
+        int countSize39 = alloc_test(MAX_39_8B);
+        int countSize40 = alloc_test(MAX_40_8B);
+        //System.out.println(countSize36);
+        //System.out.println(countSize37);
+        //System.out.println(countSize38);
+        //System.out.println(countSize39);
+        //System.out.println(countSize40);
+
+        if (countSize36 == 537 && countSize37 == 524 && countSize38 == 512 && countSize39 == 501 && countSize40 == 491)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/Alloc_41_45x8B.java b/test/testsuite/ouroboros/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/Alloc_41_45x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..9896eca9a7e3df029ecde445b164130b3a7525c2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/Alloc_41_45x8B.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID:Alloc_41_45x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 41*8B to 45*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_41_45x8B.java
+ *- @ExecuteClass: Alloc_41_45x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_41_45x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_41_8B=41*8;
+    private final static int MAX_42_8B=42*8;
+    private final static int MAX_43_8B=43*8;
+    private final static int MAX_44_8B=44*8;
+    private final static int MAX_45_8B=45*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*5/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize41 = alloc_test(MAX_41_8B);
+        int countSize42 = alloc_test(MAX_42_8B);
+        int countSize43 = alloc_test(MAX_43_8B);
+        int countSize44 = alloc_test(MAX_44_8B);
+        int countSize45 = alloc_test(MAX_45_8B);
+        //System.out.println(countSize41);
+        //System.out.println(countSize42);
+        //System.out.println(countSize43);
+        //System.out.println(countSize44);
+        //System.out.println(countSize45);
+
+        if (countSize41 == 581 && countSize42 == 569 && countSize43 == 557 && countSize44 == 547 && countSize45 == 536)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/Alloc_46_50x8B.java b/test/testsuite/ouroboros/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/Alloc_46_50x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..706d06dc2b4b41f49d0dd7066d0083865082c064
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/Alloc_46_50x8B.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID:Alloc_46_50x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 46*8B to 50*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_46_50x8B.java
+ *- @ExecuteClass: Alloc_46_50x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_46_50x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_46_8B=46*8;
+    private final static int MAX_47_8B=47*8;
+    private final static int MAX_48_8B=48*8;
+    private final static int MAX_49_8B=49*8;
+    private final static int MAX_50_8B=50*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*5/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize46 = alloc_test(MAX_46_8B);
+        int countSize47 = alloc_test(MAX_47_8B);
+        int countSize48 = alloc_test(MAX_48_8B);
+        int countSize49 = alloc_test(MAX_49_8B);
+        int countSize50 = alloc_test(MAX_50_8B);
+        //System.out.println(countSize46);
+        //System.out.println(countSize47);
+        //System.out.println(countSize48);
+        //System.out.println(countSize49);
+        //System.out.println(countSize50);
+
+        if (countSize46 == 525 && countSize47 == 516 && countSize48 == 507 && countSize49 == 498 && countSize50 == 489)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/Alloc_51_55x8B.java b/test/testsuite/ouroboros/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/Alloc_51_55x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..82d190c17d0f53d1e5cc502b1d86e8c177dd264a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/Alloc_51_55x8B.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID:Alloc_51_55x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 51*8B to 55*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_51_55x8B.java
+ *- @ExecuteClass: Alloc_51_55x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_51_55x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_51_8B=51*8;
+    private final static int MAX_52_8B=52*8;
+    private final static int MAX_53_8B=53*8;
+    private final static int MAX_54_8B=54*8;
+    private final static int MAX_55_8B=55*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*6/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize51 = alloc_test(MAX_51_8B);
+        int countSize52 = alloc_test(MAX_52_8B);
+        int countSize53 = alloc_test(MAX_53_8B);
+        int countSize54 = alloc_test(MAX_54_8B);
+        int countSize55 = alloc_test(MAX_55_8B);
+        //System.out.println(countSize51);
+        //System.out.println(countSize52);
+        //System.out.println(countSize53);
+        //System.out.println(countSize54);
+        //System.out.println(countSize55);
+
+        if (countSize51 == 562 && countSize52 == 553 && countSize53 == 543 && countSize54 == 535 && countSize55 == 526)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/Alloc_56_60x8B.java b/test/testsuite/ouroboros/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/Alloc_56_60x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..c34807038beb863369eb67b5d91ecfcc55168f71
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/Alloc_56_60x8B.java
@@ -0,0 +1,74 @@
+/*
+ *- @TestCaseID:Alloc_56_60x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 56*8B to 60*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_56_60x8B.java
+ *- @ExecuteClass: Alloc_56_60x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_56_60x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_56_8B=56*8;
+    private final static int MAX_57_8B=57*8;
+    private final static int MAX_58_8B=58*8;
+    private final static int MAX_59_8B=59*8;
+    private final static int MAX_60_8B=60*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*6/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize56 = alloc_test(MAX_56_8B);
+        int countSize57 = alloc_test(MAX_57_8B);
+        int countSize58 = alloc_test(MAX_58_8B);
+        int countSize59 = alloc_test(MAX_59_8B);
+        int countSize60 = alloc_test(MAX_60_8B);
+        //System.out.println(countSize56);
+        //System.out.println(countSize57);
+        //System.out.println(countSize58);
+        //System.out.println(countSize59);
+        //System.out.println(countSize60);
+
+        if (countSize56 == 518 && countSize57 == 511 && countSize58 == 503 && countSize59 == 496 && countSize60 == 488)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/Alloc_61_64x8B.java b/test/testsuite/ouroboros/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/Alloc_61_64x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..6af5da77203784b86aa73dad7bcfe71d2b5bfb2a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/Alloc_61_64x8B.java
@@ -0,0 +1,71 @@
+/*
+ *- @TestCaseID:Alloc_61_64x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 61*8B to 64*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_61_64x8B.java
+ *- @ExecuteClass: Alloc_61_64x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_61_64x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_61_8B=61*8;
+    private final static int MAX_62_8B=62*8;
+    private final static int MAX_63_8B=63*8;
+    private final static int MAX_64_8B=64*8;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*7/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize61 = alloc_test(MAX_61_8B);
+        int countSize62 = alloc_test(MAX_62_8B);
+        int countSize63 = alloc_test(MAX_63_8B);
+        int countSize64 = alloc_test(MAX_64_8B);
+        //System.out.println(countSize61);
+        //System.out.println(countSize62);
+        //System.out.println(countSize63);
+        //System.out.println(countSize64);
+
+        if (countSize61 == 549 && countSize62 == 542 && countSize63 == 535 && countSize64 == 528 )
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/Alloc_B256x8B.java b/test/testsuite/ouroboros/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/Alloc_B256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..fec791fa3f41fe4b73f7e58b56f1c3e33f6c8120
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/Alloc_B256x8B.java
@@ -0,0 +1,53 @@
+/*
+ *- @TestCaseID:Alloc_B256x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing big objects more than 2KB
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_B256x8B.java
+ *- @ExecuteClass: Alloc_B256x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+public class Alloc_B256x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_B256_8B=2*1024*1024;
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test(int slot_type){
+        int sum=0;
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+
+        for(int i=1024*1024-OBJ_HEADSIZE;i<=slot_type-OBJ_HEADSIZE;i=i+256)
+        {
+            for(int j=0;j<(PAGE_SIZE*2560/(i+OBJ_HEADSIZE)+5);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum +=store.size();
+            store=new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_B256_8B);
+        //System.out.println(result);
+        if ( result == 46939)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/Alloc_Thread_128x8B.java b/test/testsuite/ouroboros/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/Alloc_Thread_128x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..bb99bdaed409573887dc2371dd47ed03dff7a359
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/Alloc_Thread_128x8B.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID:Alloc_Thread_128x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 64*8B to 128*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_128x8B.java
+ *- @ExecuteClass: Alloc_Thread_128x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_128x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 348510)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_128x8B {
+    public static void main(String[] args){
+        Alloc_Thread_128x8B_01 test1=new Alloc_Thread_128x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/Alloc_Thread_18x8B.java b/test/testsuite/ouroboros/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/Alloc_Thread_18x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..d03dad0b45cee5832a65f6b542826a8ddb3a1fd9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/Alloc_Thread_18x8B.java
@@ -0,0 +1,65 @@
+/*
+ *- @TestCaseID:Alloc_Thread_18x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 8B to 18*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_18x8B.java
+ *- @ExecuteClass: Alloc_Thread_18x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_18x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_18_8B=18*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=1;i<=MAX_18_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*64/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 743858)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_18x8B {
+    public static void main(String[] args){
+        Alloc_Thread_18x8B_01 test1=new Alloc_Thread_18x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/Alloc_Thread_192x8B.java b/test/testsuite/ouroboros/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/Alloc_Thread_192x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..89e75274855a22d8dae43a106108ed7501dc4478
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/Alloc_Thread_192x8B.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID:Alloc_Thread_192x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 128*8B to 192*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_192x8B.java
+ *- @ExecuteClass: Alloc_Thread_192x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_192x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_192_8B=192*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024-OBJ_HEADSIZE;i<=MAX_192_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 201256)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_192x8B {
+    public static void main(String[] args){
+        Alloc_Thread_192x8B_01 test1=new Alloc_Thread_192x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/Alloc_Thread2_128x8B_2.java b/test/testsuite/ouroboros/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/Alloc_Thread2_128x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..68dfb1e7950312258beab0cc6bccf518daf46a52
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/Alloc_Thread2_128x8B_2.java
@@ -0,0 +1,77 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_128x8B_2
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 64*8B to 128*8B with time sleep
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_128x8B_2.java
+ *- @ExecuteClass: Alloc_Thread2_128x8B_2
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_128x8B_2_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        try{Thread.sleep(100);}catch(InterruptedException e){}
+        byte[] temp;
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                if(j%10000==0)
+                {
+                    try{Thread.sleep(100);}catch(InterruptedException e){}
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 348510)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_128x8B_2 {
+    public static void main(String[] args){
+        Runtime.getRuntime().gc();
+        Alloc_Thread2_128x8B_2_01 test1=new Alloc_Thread2_128x8B_2_01();
+        test1.start();
+        Alloc_Thread2_128x8B_2_01 test2=new Alloc_Thread2_128x8B_2_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/Alloc_Thread2_128x8B.java b/test/testsuite/ouroboros/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/Alloc_Thread2_128x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..254ae2b07badf60efe1b1ace8c1aee30353c5b0b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/Alloc_Thread2_128x8B.java
@@ -0,0 +1,72 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_128x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This testcase is mainly for testing objects from 64*8B to 128*8B(max) with 2 threads.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_128x8B.java
+ *- @ExecuteClass: Alloc_Thread2_128x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_128x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 348510)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_128x8B {
+    public static void main(String[] args){
+        Runtime.getRuntime().gc();
+        Alloc_Thread2_128x8B_01 test1=new Alloc_Thread2_128x8B_01();
+        test1.start();
+        Alloc_Thread2_128x8B_01 test2=new Alloc_Thread2_128x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/Alloc_Thread2_18x8B.java b/test/testsuite/ouroboros/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/Alloc_Thread2_18x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..fcc9a69fceb607d36703293a74572fc17bde7658
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/Alloc_Thread2_18x8B.java
@@ -0,0 +1,69 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_18x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 8B to 18*8B(max) with 2 threads.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_18x8B.java
+ *- @ExecuteClass: Alloc_Thread2_18x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_18x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_18_8B=18*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=1;i<=MAX_18_8B-OBJ_HEADSIZE;i+=10)
+        {
+            for(int j=0;j<(PAGE_SIZE*64/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 89848)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_18x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_18x8B_01 test1=new Alloc_Thread2_18x8B_01();
+        test1.start();
+        Alloc_Thread2_18x8B_01 test2=new Alloc_Thread2_18x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check() == true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/Alloc_Thread2_192x8B_2.java b/test/testsuite/ouroboros/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/Alloc_Thread2_192x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..0361c984a136be9a3fbfda3e1df280e22a2e8b3b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/Alloc_Thread2_192x8B_2.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_192x8B_2
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 128*8B to 192*8B(max) with time sleep
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_192x8B_2.java
+ *- @ExecuteClass: Alloc_Thread2_192x8B_2
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_192x8B_2_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_192_8B=192*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        try{Thread.sleep(100);}catch(InterruptedException e){}
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024-OBJ_HEADSIZE;i<=MAX_192_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                if(j%10000==0)
+                {
+                    try{Thread.sleep(100);}catch(InterruptedException e){}
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 201256)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_192x8B_2 {
+    public static void main(String[] args){
+        Alloc_Thread2_192x8B_2_01 test1=new Alloc_Thread2_192x8B_2_01();
+        test1.start();
+        Alloc_Thread2_192x8B_2_01 test2=new Alloc_Thread2_192x8B_2_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true &&test2.check()==true )
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/Alloc_Thread2_192x8B.java b/test/testsuite/ouroboros/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/Alloc_Thread2_192x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..d23f9ba29843c80d8945b30acb887e63e3bf5aff
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/Alloc_Thread2_192x8B.java
@@ -0,0 +1,71 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_192x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 128*8B to 192*8B(max) with 2 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_192x8B.java
+ *- @ExecuteClass: Alloc_Thread2_192x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_192x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_192_8B=192*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024-OBJ_HEADSIZE;i<=MAX_192_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 201256)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_192x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_192x8B_01 test1=new Alloc_Thread2_192x8B_01();
+        test1.start();
+        Alloc_Thread2_192x8B_01 test2=new Alloc_Thread2_192x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true &&test2.check()==true )
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2/Alloc_Thread2_256x8B_2.java b/test/testsuite/ouroboros/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2/Alloc_Thread2_256x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..d4eca5ee9640ae73f7083c28e97f2d3304aed14b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2/Alloc_Thread2_256x8B_2.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_256x8B_2
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 192*8B to 256*8B(max) with time sleep
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_256x8B_2.java
+ *- @ExecuteClass: Alloc_Thread2_256x8B_2
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_256x8B_2_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_256_8B=256*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        try{Thread.sleep(100);}catch(InterruptedException e){}
+        byte[] temp;
+        int check_size=0;
+        for(int i=192*8-OBJ_HEADSIZE;i<=MAX_256_8B-OBJ_HEADSIZE;i=i+60)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                if(j%10000==0)
+                {
+                    try{Thread.sleep(100);}catch(InterruptedException e){}
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 214274)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_256x8B_2 {
+    public static void main(String[] args){
+        Alloc_Thread2_256x8B_2_01 test1=new Alloc_Thread2_256x8B_2_01();
+        test1.start();
+        Alloc_Thread2_256x8B_2_01 test2=new Alloc_Thread2_256x8B_2_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/Alloc_Thread2_256x8B.java b/test/testsuite/ouroboros/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/Alloc_Thread2_256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..b4b8914a58f8227c228ad4ae382c2b969d7dfd55
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/Alloc_Thread2_256x8B.java
@@ -0,0 +1,71 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_256x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 192*8B to 256*8B(max) with 2 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_256x8B.java
+ *- @ExecuteClass: Alloc_Thread2_256x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_256_8B=256*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=192*8-OBJ_HEADSIZE;i<=MAX_256_8B-OBJ_HEADSIZE;i=i+60)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 214274)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_256x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_256x8B_01 test1=new Alloc_Thread2_256x8B_01();
+        test1.start();
+        Alloc_Thread2_256x8B_01 test2=new Alloc_Thread2_256x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/Alloc_Thread2_30x8B.java b/test/testsuite/ouroboros/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/Alloc_Thread2_30x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..eeb443fcd545ff380d7363a9cf0142980470ac2d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/Alloc_Thread2_30x8B.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_30x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 18*8B to 30*8B(max) with 2 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_30x8B.java
+ *- @ExecuteClass: Alloc_Thread2_30x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_30x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_30_8B=30*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=144-OBJ_HEADSIZE;i<=MAX_30_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*128/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 271654)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_30x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_30x8B_01 test1=new Alloc_Thread2_30x8B_01();
+        test1.start();
+        Alloc_Thread2_30x8B_01 test2=new Alloc_Thread2_30x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&& test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/Alloc_Thread2_40x8B.java b/test/testsuite/ouroboros/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/Alloc_Thread2_40x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..9cafb04d5482766f3ec186d6277abbcea25b729a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/Alloc_Thread2_40x8B.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_40x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 30*8B to 40*8B(max) with 2 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_40x8B.java
+ *- @ExecuteClass: Alloc_Thread2_40x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_40x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_40_8B=40*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=240-OBJ_HEADSIZE;i<=MAX_40_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*128/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 153513)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_40x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_40x8B_01 test1=new Alloc_Thread2_40x8B_01();
+        test1.start();
+        Alloc_Thread2_40x8B_01 test2=new Alloc_Thread2_40x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/Alloc_Thread2_50x8B.java b/test/testsuite/ouroboros/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/Alloc_Thread2_50x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..44ba769b4dad22b8bdde6240faf6a90aaf20c874
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/Alloc_Thread2_50x8B.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_50x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 40*8B to 50*8B(max) with 2 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_50x8B.java
+ *- @ExecuteClass: Alloc_Thread2_50x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_50x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_50_8B=50*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=320-OBJ_HEADSIZE;i<=MAX_50_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 237701)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_50x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_50x8B_01 test1=new Alloc_Thread2_50x8B_01();
+        test1.start();
+        Alloc_Thread2_50x8B_01 test2=new Alloc_Thread2_50x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/Alloc_Thread_256x8B.java b/test/testsuite/ouroboros/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/Alloc_Thread_256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..727ca43c23f43f7e686314fdb5ffa62ee932d68c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/Alloc_Thread_256x8B.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID:Alloc_Thread_256x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 192*8B to 256*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_256x8B.java
+ *- @ExecuteClass: Alloc_Thread_256x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_256_8B=256*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=192*8-OBJ_HEADSIZE;i<=MAX_256_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+       //System.out.println(check_size);
+        if(check_size == 142271)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_256x8B {
+    public static void main(String[] args){
+        Alloc_Thread_256x8B_01 test1=new Alloc_Thread_256x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/Alloc_Thread2_60x8B.java b/test/testsuite/ouroboros/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/Alloc_Thread2_60x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..8b414bf20c66305108dffcfb39b4afec04cf484b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/Alloc_Thread2_60x8B.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_60x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 50*8B to 60*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_60x8B.java
+ *- @ExecuteClass: Alloc_Thread2_60x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_60x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_60_8B=60*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=400-OBJ_HEADSIZE;i<=MAX_60_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 194350)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_60x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_60x8B_01 test1=new Alloc_Thread2_60x8B_01();
+        test1.start();
+        Alloc_Thread2_60x8B_01 test2=new Alloc_Thread2_60x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/Alloc_Thread2_64x8B.java b/test/testsuite/ouroboros/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/Alloc_Thread2_64x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..404c08d4363ed22aee051217303bbb2522812e0a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/Alloc_Thread2_64x8B.java
@@ -0,0 +1,69 @@
+/*
+ * -@TestCaseID:Alloc_Thread2_64x8B
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 60*8B to 64*8B(max)
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_Thread2_64x8B.java
+ * -@ExecuteClass: Alloc_Thread2_64x8B
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+import java.util.ArrayList;
+
+class Alloc_Thread2_64x8B_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_64_8B = 64 * 8;
+    private static boolean checkout = false;
+
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 480 - OBJ_HEADSIZE; i <= MAX_64_8B - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 128 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int checkSize = store.size();
+        if (checkSize == 35212) {
+            checkout = true;
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+public class Alloc_Thread2_64x8B {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Thread2_64x8B_01 test1 = new Alloc_Thread2_64x8B_01();
+        test1.start();
+        Alloc_Thread2_64x8B_01 test2 = new Alloc_Thread2_64x8B_01();
+        test2.start();
+        try {
+            test1.join();
+            test2.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/Alloc_Thread2_B256x8B.java b/test/testsuite/ouroboros/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/Alloc_Thread2_B256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..5a97bade3522f571219a664a4cabf52e227f710d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/Alloc_Thread2_B256x8B.java
@@ -0,0 +1,75 @@
+/*
+ *- @TestCaseID:Alloc_Thread2_B256x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 1MB to 2MB(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread2_B256x8B.java
+ *- @ExecuteClass: Alloc_Thread2_B256x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread2_B256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_B256_8B=2*1024*1024;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024*1024-OBJ_HEADSIZE;i<=MAX_B256_8B-OBJ_HEADSIZE;i=i+1024)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 38167)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread2_B256x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_B256x8B_01 test1=new Alloc_Thread2_B256x8B_01();
+        test1.start();
+        try{ test1.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Thread2_B256x8B_01 test2=new Alloc_Thread2_B256x8B_01();
+        test2.start();
+        try{ test2.sleep(1000);} catch(InterruptedException e){}
+        try{
+            test1.sleep(1000);
+            test2.sleep(1000);
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/Alloc_Thread_30x8B.java b/test/testsuite/ouroboros/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/Alloc_Thread_30x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..280bb2c6fafcb9375a4ecbbaa84c494eef394b16
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/Alloc_Thread_30x8B.java
@@ -0,0 +1,65 @@
+/*
+ *- @TestCaseID:Alloc_Thread_30x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 18*8B to 30*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_30x8B.java
+ *- @ExecuteClass: Alloc_Thread_30x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_30x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_30_8B=30*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=144-OBJ_HEADSIZE;i<=MAX_30_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*128/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 271654)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_30x8B {
+    public static void main(String[] args){
+        Alloc_Thread_30x8B_01 test1=new Alloc_Thread_30x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/Alloc_Thread_40x8B.java b/test/testsuite/ouroboros/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/Alloc_Thread_40x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..0efcb32ee8c2339a6327cdc004fd0dc6bc073a38
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/Alloc_Thread_40x8B.java
@@ -0,0 +1,65 @@
+/*
+ *- @TestCaseID:Alloc_Thread_40x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 30*8B to 40*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_40x8B.java
+ *- @ExecuteClass: Alloc_Thread_40x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_40x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_40_8B=40*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=240-OBJ_HEADSIZE;i<=MAX_40_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*128/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 153513)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_40x8B {
+    public static void main(String[] args){
+        Alloc_Thread_40x8B_01 test1=new Alloc_Thread_40x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/Alloc_Thread_50x8B.java b/test/testsuite/ouroboros/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/Alloc_Thread_50x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..8db8a13f17105fc953905c150f8e2fc9ad556961
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/Alloc_Thread_50x8B.java
@@ -0,0 +1,65 @@
+/*
+ *- @TestCaseID:Alloc_Thread_50x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 40*8B to 50*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_50x8B.java
+ *- @ExecuteClass: Alloc_Thread_50x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_50x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_50_8B=50*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=320-OBJ_HEADSIZE;i<=MAX_50_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 237701)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_50x8B {
+    public static void main(String[] args){
+        Alloc_Thread_50x8B_01 test1=new Alloc_Thread_50x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/Alloc_Thread_60x8B.java b/test/testsuite/ouroboros/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/Alloc_Thread_60x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..721f41235d779e857bcb135f8e5078093962fdff
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/Alloc_Thread_60x8B.java
@@ -0,0 +1,65 @@
+/*
+ *- @TestCaseID:Alloc_Thread_60x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 50*8B to 60*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_60x8B.java
+ *- @ExecuteClass: Alloc_Thread_60x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_60x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_60_8B=60*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=400-OBJ_HEADSIZE;i<=MAX_60_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 194350)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_60x8B {
+    public static void main(String[] args){
+        Alloc_Thread_60x8B_01 test1=new Alloc_Thread_60x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/Alloc_Thread_64x8B.java b/test/testsuite/ouroboros/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/Alloc_Thread_64x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..86ce9206fba6fa5351f442ddeb97236abb386977
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/Alloc_Thread_64x8B.java
@@ -0,0 +1,65 @@
+/*
+ *- @TestCaseID:Alloc_Thread_64x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 60*8B to 64*8B(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_64x8B.java
+ *- @ExecuteClass: Alloc_Thread_64x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_64x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_64_8B=64*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=480-OBJ_HEADSIZE;i<=MAX_64_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*512/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 139895)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_64x8B {
+    public static void main(String[] args){
+        Alloc_Thread_64x8B_01 test1=new Alloc_Thread_64x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/Alloc_Thread_B256x8B.java b/test/testsuite/ouroboros/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/Alloc_Thread_B256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..1ab3442164af8b5e0a599717b1a2fe37c8afaaa8
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/Alloc_Thread_B256x8B.java
@@ -0,0 +1,68 @@
+/*
+ *- @TestCaseID:Alloc_Thread_B256x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 1MB to 2MB(max)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Thread_B256x8B.java
+ *- @ExecuteClass: Alloc_Thread_B256x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Thread_B256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_B256_8B=2*1024*1024;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024*1024-OBJ_HEADSIZE;i<=MAX_B256_8B-OBJ_HEADSIZE;i=i+1024)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 38167)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Thread_B256x8B {
+    public static void main(String[] args){
+        Alloc_Thread_B256x8B_01 test1=new Alloc_Thread_B256x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/Alloc_Threadm_128x8B_2.java b/test/testsuite/ouroboros/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/Alloc_Threadm_128x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..fa535923327c6489296c3ed4df1a6bba67a94724
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/Alloc_Threadm_128x8B_2.java
@@ -0,0 +1,88 @@
+/*
+ *- @TestCaseID:Alloc_Threadm_128x8B_2
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 64*8B to 128*8B(max) with 6 threads and time sleep
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Threadm_128x8B_2.java
+ *- @ExecuteClass: Alloc_Threadm_128x8B_2
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Threadm_128x8B_2_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        try{Thread.sleep(100);}catch(InterruptedException e){}
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+10)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                if(j%1000==0)
+                {
+                    try{Thread.sleep(100);}catch(InterruptedException e){}
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 28253)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Threadm_128x8B_2 {
+    public static void main(String[] args){
+        Alloc_Threadm_128x8B_2_01 test1=new Alloc_Threadm_128x8B_2_01();
+        test1.start();
+        Alloc_Threadm_128x8B_2_01 test2=new Alloc_Threadm_128x8B_2_01();
+        test2.start();
+        Alloc_Threadm_128x8B_2_01 test3=new Alloc_Threadm_128x8B_2_01();
+        test3.start();
+        Alloc_Threadm_128x8B_2_01 test4=new Alloc_Threadm_128x8B_2_01();
+        test4.start();
+        Alloc_Threadm_128x8B_2_01 test5=new Alloc_Threadm_128x8B_2_01();
+        test5.start();
+        Alloc_Threadm_128x8B_2_01 test6=new Alloc_Threadm_128x8B_2_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/Alloc_Threadm_128x8B.java b/test/testsuite/ouroboros/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/Alloc_Threadm_128x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..e9cb7539f3d74f9af26711eef9b51671a978294b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/Alloc_Threadm_128x8B.java
@@ -0,0 +1,83 @@
+/*
+ *- @TestCaseID:Alloc_Threadm_128x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 40*8B to 50*8B(max) with 6 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Threadm_128x8B.java
+ *- @ExecuteClass: Alloc_Threadm_128x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Threadm_128x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+10)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 28253)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Threadm_128x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_128x8B_01 test1=new Alloc_Threadm_128x8B_01();
+        test1.start();
+        Alloc_Threadm_128x8B_01 test2=new Alloc_Threadm_128x8B_01();
+        test2.start();
+        Alloc_Threadm_128x8B_01 test3=new Alloc_Threadm_128x8B_01();
+        test3.start();
+        Alloc_Threadm_128x8B_01 test4=new Alloc_Threadm_128x8B_01();
+        test4.start();
+        Alloc_Threadm_128x8B_01 test5=new Alloc_Threadm_128x8B_01();
+        test5.start();
+        Alloc_Threadm_128x8B_01 test6=new Alloc_Threadm_128x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/Alloc_Threadm_18x8B.java b/test/testsuite/ouroboros/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/Alloc_Threadm_18x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..9f6a5136123f160be18acde251791f6b4869d768
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/Alloc_Threadm_18x8B.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID:Alloc_Threadm_18x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 8B to 18*8B(max) with 6 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Threadm_18x8B.java
+ *- @ExecuteClass: Alloc_Threadm_18x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Threadm_18x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_18_8B=18*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=1;i<=MAX_18_8B-OBJ_HEADSIZE;i=i+20)
+        {
+            for(int j=0;j<(PAGE_SIZE*64/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 54765)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Threadm_18x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_18x8B_01 test1=new Alloc_Threadm_18x8B_01();
+        test1.start();
+        Alloc_Threadm_18x8B_01 test2=new Alloc_Threadm_18x8B_01();
+        test2.start();
+        Alloc_Threadm_18x8B_01 test3=new Alloc_Threadm_18x8B_01();
+        test3.start();
+        Alloc_Threadm_18x8B_01 test4=new Alloc_Threadm_18x8B_01();
+        test4.start();
+        Alloc_Threadm_18x8B_01 test5=new Alloc_Threadm_18x8B_01();
+        test5.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check() == true &&test3.check()==true && test4.check() == true&& test5.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/Alloc_Threadm_192x8B_2.java b/test/testsuite/ouroboros/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/Alloc_Threadm_192x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..5068b8d6788618145caae72ddbd59a8d0e0c76a0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/Alloc_Threadm_192x8B_2.java
@@ -0,0 +1,89 @@
+/*
+ * -@TestCaseID:Alloc_Threadm_192x8B_2
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing
+ *         objects from 128*8B to 192*8B(max) with 6 threads and time sleep
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_Threadm_192x8B_2.java
+ * -@ExecuteClass: Alloc_Threadm_192x8B_2
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+import java.util.ArrayList;
+
+class Alloc_Threadm_192x8B_2_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_192_8B = 192 * 8;
+    private static boolean checkout = false;
+
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        int checkSize = 0;
+        for (int i = 1024 - OBJ_HEADSIZE; i <= MAX_192_8B - OBJ_HEADSIZE; i = i + 100) {
+            for (int j = 0; j < (PAGE_SIZE * 512 / (i + OBJ_HEADSIZE) + 10); j++) {
+                if (j % 1000 == 0) {
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException e) {
+                        // do nothing
+                    }
+                }
+                temp = new byte[i];
+                store.add(temp);
+                checkSize += store.size();
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (checkSize == 10117) {
+            checkout = true;
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+public class Alloc_Threadm_192x8B_2 {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_192x8B_2_01 test1 = new Alloc_Threadm_192x8B_2_01();
+        test1.start();
+        Alloc_Threadm_192x8B_2_01 test2 = new Alloc_Threadm_192x8B_2_01();
+        test2.start();
+        Alloc_Threadm_192x8B_2_01 test3 = new Alloc_Threadm_192x8B_2_01();
+        test3.start();
+        Alloc_Threadm_192x8B_2_01 test4 = new Alloc_Threadm_192x8B_2_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() == true && test2.check() == true && test3.check() == true && test4.check() == true) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/Alloc_Threadm_192x8B.java b/test/testsuite/ouroboros/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/Alloc_Threadm_192x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..d688d1b2103193ae9decf646a11e011c9e62578e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/Alloc_Threadm_192x8B.java
@@ -0,0 +1,77 @@
+/*
+ * -@TestCaseID:Alloc_Threadm_192x8B
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing
+ *         objects from 128*8B to 192*8B(max) with 6 threads
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_Threadm_192x8B.java
+ * -@ExecuteClass: Alloc_Threadm_192x8B
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+import java.util.ArrayList;
+
+class Alloc_Threadm_192x8B_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_192_8B = 192 * 8;
+    private static boolean checkout = false;
+
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        int checkSize = 0;
+        for (int i = 1024 - OBJ_HEADSIZE; i <= MAX_192_8B - OBJ_HEADSIZE; i = i + 100) {
+            for (int j = 0; j < (PAGE_SIZE * 512 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+                checkSize++;
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (checkSize == 10117) {
+            checkout = true;
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+public class Alloc_Threadm_192x8B {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_192x8B_01 test1 = new Alloc_Threadm_192x8B_01();
+        test1.start();
+        Alloc_Threadm_192x8B_01 test2 = new Alloc_Threadm_192x8B_01();
+        test2.start();
+        Alloc_Threadm_192x8B_01 test3 = new Alloc_Threadm_192x8B_01();
+        test3.start();
+        Alloc_Threadm_192x8B_01 test4 = new Alloc_Threadm_192x8B_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check() && test3.check() && test4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/Alloc_Threadm_256x8B_2.java b/test/testsuite/ouroboros/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/Alloc_Threadm_256x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a3bf5dd64e56106ef19bd79ce8728944c117019b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/Alloc_Threadm_256x8B_2.java
@@ -0,0 +1,90 @@
+/*
+ * -@TestCaseID:Alloc_Threadm_256x8B_2
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing
+ *         objects from 192*8B to 256*8B(max) with 6 threads and time sleep
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_Threadm_256x8B_2.java
+ * -@ExecuteClass: Alloc_Threadm_256x8B_2
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+import java.util.ArrayList;
+
+class Alloc_Threadm_256x8B_2_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_256_8B = 256 * 8;
+    private static boolean checkOut = false;
+
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        int check_size = 0;
+        for (int i = 192 * 8 - OBJ_HEADSIZE; i <= MAX_256_8B - OBJ_HEADSIZE; i = i + 800) {
+            for (int j = 0; j < (PAGE_SIZE * 1024 / (i + OBJ_HEADSIZE) + 10); j++) {
+                if (j % 1000 == 0) {
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException e) {
+                        // do nothing
+                    }
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size++;
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (check_size == 2740) {
+            checkOut = true;
+        }
+    }
+
+    public boolean check() {
+        return checkOut;
+    }
+}
+
+public class Alloc_Threadm_256x8B_2 {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_256x8B_2_01 test1 = new Alloc_Threadm_256x8B_2_01();
+        test1.start();
+        Alloc_Threadm_256x8B_2_01 test2 = new Alloc_Threadm_256x8B_2_01();
+        test2.start();
+        Alloc_Threadm_256x8B_2_01 test3 = new Alloc_Threadm_256x8B_2_01();
+        test3.start();
+        Alloc_Threadm_256x8B_2_01 test4 = new Alloc_Threadm_256x8B_2_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check() && test3.check() && test4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/Alloc_Threadm_256x8B.java b/test/testsuite/ouroboros/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/Alloc_Threadm_256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..2491bc5faa286e10f57c7a172290ad9c4ce3252e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/Alloc_Threadm_256x8B.java
@@ -0,0 +1,78 @@
+/*
+ * -@TestCaseID:Alloc_Threadm_256x8B
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing
+ *         objects from 192*8B to 256*8B(max) with 6 threads
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: Alloc_Threadm_256x8B.java
+ * -@ExecuteClass: Alloc_Threadm_256x8B
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+import java.util.ArrayList;
+
+class Alloc_Threadm_256x8B_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_256_8B = 256 * 8;
+    private static boolean checkOut = false;
+
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        int checkSize = 0;
+        for (int i = 192 * 8 - OBJ_HEADSIZE; i <= MAX_256_8B - OBJ_HEADSIZE; i = i + 800) {
+            for (int j = 0; j < (PAGE_SIZE * 512 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+                checkSize++;
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (checkSize == 1375) {
+            checkOut = true;
+        }
+    }
+
+    public boolean check() {
+        return checkOut;
+    }
+
+}
+
+public class Alloc_Threadm_256x8B {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_256x8B_01 test1 = new Alloc_Threadm_256x8B_01();
+        test1.start();
+        Alloc_Threadm_256x8B_01 test2 = new Alloc_Threadm_256x8B_01();
+        test2.start();
+        Alloc_Threadm_256x8B_01 test3 = new Alloc_Threadm_256x8B_01();
+        test3.start();
+        Alloc_Threadm_256x8B_01 test4 = new Alloc_Threadm_256x8B_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check() && test3.check() && test4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/Alloc_Threadm_30x8B.java b/test/testsuite/ouroboros/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/Alloc_Threadm_30x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..50755344a13efa779ef8b01545f6ffad00403567
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/Alloc_Threadm_30x8B.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID:Alloc_Threadm_30x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 18*8B to 30*8B(max) with 6 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Threadm_30x8B.java
+ *- @ExecuteClass: Alloc_Threadm_30x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Threadm_30x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_30_8B=30*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=144-OBJ_HEADSIZE;i<=MAX_30_8B-OBJ_HEADSIZE;i=i+5)
+        {
+            for(int j=0;j<(PAGE_SIZE*64/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 28217)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Threadm_30x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_30x8B_01 test1=new Alloc_Threadm_30x8B_01();
+        test1.start();
+        Alloc_Threadm_30x8B_01 test2=new Alloc_Threadm_30x8B_01();
+        test2.start();
+        Alloc_Threadm_30x8B_01 test3=new Alloc_Threadm_30x8B_01();
+        test3.start();
+        Alloc_Threadm_30x8B_01 test4=new Alloc_Threadm_30x8B_01();
+        test4.start();
+        Alloc_Threadm_30x8B_01 test5=new Alloc_Threadm_30x8B_01();
+        test5.start();
+        Alloc_Threadm_30x8B_01 test6=new Alloc_Threadm_30x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&& test2.check()==true&&test3.check()==true&& test4.check()==true&&test5.check()==true&& test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/Alloc_Threadm_40x8B.java b/test/testsuite/ouroboros/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/Alloc_Threadm_40x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..07115079be20e9d5c2884f3464c453f629f8b766
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/Alloc_Threadm_40x8B.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID:Alloc_Threadm_40x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 30*8B to 40*8B(max) with 6 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Threadm_40x8B.java
+ *- @ExecuteClass: Alloc_Threadm_40x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Threadm_40x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_40_8B=40*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=240-OBJ_HEADSIZE;i<=MAX_40_8B-OBJ_HEADSIZE;i+=4)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 29915)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Threadm_40x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_40x8B_01 test1=new Alloc_Threadm_40x8B_01();
+        test1.start();
+        Alloc_Threadm_40x8B_01 test2=new Alloc_Threadm_40x8B_01();
+        test2.start();
+        Alloc_Threadm_40x8B_01 test3=new Alloc_Threadm_40x8B_01();
+        test3.start();
+        Alloc_Threadm_40x8B_01 test4=new Alloc_Threadm_40x8B_01();
+        test4.start();
+        Alloc_Threadm_40x8B_01 test5=new Alloc_Threadm_40x8B_01();
+        test5.start();
+        Alloc_Threadm_40x8B_01 test6=new Alloc_Threadm_40x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/Alloc_Threadm_50x8B.java b/test/testsuite/ouroboros/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/Alloc_Threadm_50x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..d4a4a35d78cd925e4c1ec6b4e1179392b20e5bef
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/Alloc_Threadm_50x8B.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID:Alloc_Threadm_50x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 40*8B to 50*8B(max) with 6 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Threadm_50x8B.java
+ *- @ExecuteClass: Alloc_Threadm_50x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Threadm_50x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_50_8B=50*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=320-OBJ_HEADSIZE;i<=MAX_50_8B-OBJ_HEADSIZE;i=i+5)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 18816)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Threadm_50x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_50x8B_01 test1=new Alloc_Threadm_50x8B_01();
+        test1.start();
+        Alloc_Threadm_50x8B_01 test2=new Alloc_Threadm_50x8B_01();
+        test2.start();
+        Alloc_Threadm_50x8B_01 test3=new Alloc_Threadm_50x8B_01();
+        test3.start();
+        Alloc_Threadm_50x8B_01 test4=new Alloc_Threadm_50x8B_01();
+        test4.start();
+        Alloc_Threadm_50x8B_01 test5=new Alloc_Threadm_50x8B_01();
+        test5.start();
+        Alloc_Threadm_50x8B_01 test6=new Alloc_Threadm_50x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/Alloc_Threadm_60x8B.java b/test/testsuite/ouroboros/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/Alloc_Threadm_60x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..2be42c88d7f17e70f689a85c21e26f1c888c5189
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/Alloc_Threadm_60x8B.java
@@ -0,0 +1,81 @@
+/*
+ *- @TestCaseID:Alloc_Threadm_60x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 50*8B to 60*8B(max) with 6 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Threadm_60x8B.java
+ *- @ExecuteClass: Alloc_Threadm_60x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Threadm_60x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_60_8B=60*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=400-OBJ_HEADSIZE;i<=MAX_60_8B-OBJ_HEADSIZE;i+=3)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 24509)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Threadm_60x8B {
+    public static void main(String[] args){
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_60x8B_01 test1=new Alloc_Threadm_60x8B_01();
+        test1.start();
+        Alloc_Threadm_60x8B_01 test2=new Alloc_Threadm_60x8B_01();
+        test2.start();
+        Alloc_Threadm_60x8B_01 test3=new Alloc_Threadm_60x8B_01();
+        test3.start();
+        Alloc_Threadm_60x8B_01 test4=new Alloc_Threadm_60x8B_01();
+        test4.start();
+        Alloc_Threadm_60x8B_01 test5=new Alloc_Threadm_60x8B_01();
+        test5.start();
+        Alloc_Threadm_60x8B_01 test6=new Alloc_Threadm_60x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/Alloc_Threadm_64x8B.java b/test/testsuite/ouroboros/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/Alloc_Threadm_64x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..36463a8236185cebc1bf04ce68d4cb168afe873e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/Alloc_Threadm_64x8B.java
@@ -0,0 +1,80 @@
+/*
+ *- @TestCaseID:Alloc_Threadm_64x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 60*8B to 64*8B(max) with 6 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Threadm_64x8B.java
+ *- @ExecuteClass: Alloc_Threadm_64x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Threadm_64x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_64_8B=64*8;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=480-OBJ_HEADSIZE;i<=MAX_64_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 26487)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Threadm_64x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_64x8B_01 test1=new Alloc_Threadm_64x8B_01();
+        test1.start();
+        Alloc_Threadm_64x8B_01 test2=new Alloc_Threadm_64x8B_01();
+        test2.start();
+        Alloc_Threadm_64x8B_01 test3=new Alloc_Threadm_64x8B_01();
+        test3.start();
+        Alloc_Threadm_64x8B_01 test4=new Alloc_Threadm_64x8B_01();
+        test4.start();
+        Alloc_Threadm_64x8B_01 test5=new Alloc_Threadm_64x8B_01();
+        test5.start();
+        Alloc_Threadm_64x8B_01 test6=new Alloc_Threadm_64x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/Alloc_Threadm_B256x8B.java b/test/testsuite/ouroboros/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/Alloc_Threadm_B256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..37ad975e91d82c021262a12714db80a9ea9b315f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/Alloc_Threadm_B256x8B.java
@@ -0,0 +1,88 @@
+/*
+ *- @TestCaseID:Alloc_Threadm_B256x8B
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title:ROS Allocator is in charge of applying and releasing objects.This mulit thread testcase is mainly for testing objects from 1MB to 2MB(max) with 6 threads
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Alloc_Threadm_B256x8B.java
+ *- @ExecuteClass: Alloc_Threadm_B256x8B
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.ArrayList;
+
+class Alloc_Threadm_B256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_B256_8B=2*1024*1024;
+    private static boolean checkout=false;
+
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024*1024-OBJ_HEADSIZE;i<=MAX_B256_8B-OBJ_HEADSIZE;i=i+15120)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+
+        //System.out.println(check_size);
+        if(check_size == 2612)
+            checkout=true;
+
+    }
+    public boolean check() {
+        return checkout;
+    }
+
+}
+
+public class Alloc_Threadm_B256x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_B256x8B_01 test1=new Alloc_Threadm_B256x8B_01();
+        test1.start();
+        try{ test1.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test2=new Alloc_Threadm_B256x8B_01();
+        test2.start();
+        try{ test2.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test3=new Alloc_Threadm_B256x8B_01();
+        test3.start();
+        try{ test3.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test4=new Alloc_Threadm_B256x8B_01();
+        test4.start();
+        try{ test4.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test5=new Alloc_Threadm_B256x8B_01();
+        test5.start();
+        try{ test5.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test6=new Alloc_Threadm_B256x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0302-rc-function-Ref-PhantomRefTest/PhantomRefTest.java b/test/testsuite/ouroboros/rc_test/RC0302-rc-function-Ref-PhantomRefTest/PhantomRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1d30441bd369e7dd58a34116e96b72e8348a7da
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0302-rc-function-Ref-PhantomRefTest/PhantomRefTest.java
@@ -0,0 +1,49 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/PhantomRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: PhantomRefTest basic testcase
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: PhantomRefTest.java
+ *- @ExecuteClass: PhantomRefTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+import java.lang.ref.*;
+
+public class PhantomRefTest {
+  static Reference rp;
+  static ReferenceQueue rq = new ReferenceQueue();
+  static int a = 100;
+
+  static void setPhantomReference() {
+    rp = new PhantomReference<Object>(new Object(), rq);
+    if (rp.get() != null) {
+      a++;
+    }
+  }
+
+  public static void main(String [] args) throws Exception {
+    Reference r;
+    setPhantomReference();
+    Thread.sleep(2000);
+    while ((r = rq.poll())!=null) {
+      if (!r.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+        a++;
+      }
+    }
+
+    if (a == 100) {
+      System.out.println("ExpectResult");
+    }
+  }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0303-rc-function-Ref-SoftRefTest/SoftRefTest.java b/test/testsuite/ouroboros/rc_test/RC0303-rc-function-Ref-SoftRefTest/SoftRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..f0369cac6573fe2c03dc68491805f448f9ea1184
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0303-rc-function-Ref-SoftRefTest/SoftRefTest.java
@@ -0,0 +1,63 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/SoftRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: SoftRefTest basic testcase
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SoftRefTest.java
+ *- @ExecuteClass: SoftRefTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+import java.lang.ref.*;
+
+public class SoftRefTest {
+  static Reference rp;
+  static ReferenceQueue rq = new ReferenceQueue();
+  static int a = 100;
+
+  static void setSoftReference() {
+    rp = new SoftReference<Object>(new Object(), rq);
+    if (rp.get() == null) {
+      a++;
+    }
+  }
+
+  static class TriggerRP implements Runnable {
+    public void run() {
+      for (int i = 0; i < 60; i++) {
+        SoftReference sr = new SoftReference(new Object());
+        try {
+          Thread.sleep(50);
+        } catch (Exception e) {}
+      }
+    }
+  }
+
+  public static void main(String [] args) throws Exception {
+    Reference r;
+    setSoftReference();
+    new Thread(new TriggerRP()).start();
+    Thread.sleep(3000);
+    if (rp.get() != null) {
+      a++;
+    }
+    while ((r = rq.poll())!=null) {
+      if(!r.getClass().toString().equals("class java.lang.ref.SoftReference")) {
+        a++;
+      }
+    }
+    if (a == 101) {
+      System.out.println("ExpectResult");
+    }
+  }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0304-rc-function-Ref-WeakRefTest/WeakRefTest.java b/test/testsuite/ouroboros/rc_test/RC0304-rc-function-Ref-WeakRefTest/WeakRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..44dab169d01cd5c3640133f984898f9f0325fe8b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0304-rc-function-Ref-WeakRefTest/WeakRefTest.java
@@ -0,0 +1,63 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/WeakRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: WeakRefTest basic testcase
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: WeakRefTest.java
+ *- @ExecuteClass: WeakRefTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+import java.lang.ref.*;
+
+public class WeakRefTest {
+  static Reference rp;
+  static ReferenceQueue rq = new ReferenceQueue();
+  static int a = 100;
+
+  static void setWeakReference() {
+    rp = new WeakReference<Object>(new Object(), rq);
+    if (rp.get() == null) {
+      a++;
+    }
+  }
+
+  static class TriggerRP implements Runnable {
+    public void run() {
+      for (int i = 0; i < 60; i++) {
+        WeakReference wr = new WeakReference(new Object());
+        try {
+          Thread.sleep(50);
+        } catch (Exception e) {}
+      }
+    }
+  }
+
+  public static void main(String [] args) throws Exception {
+    Reference r;
+    setWeakReference();
+    new Thread(new TriggerRP()).start();
+    Thread.sleep(3000);
+    if (rp.get() != null) {
+      a++;
+    }
+    while ((r = rq.poll())!=null) {
+      if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+        a++;
+      }
+    }
+
+    if (a == 100) {
+      System.out.println("ExpectResult");
+    }
+  }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/RC_newObjectIassign_01.java b/test/testsuite/ouroboros/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/RC_newObjectIassign_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..1293a22ea0b6b63fe104d5e8959bf3d3f8ce0b03
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/RC_newObjectIassign_01.java
@@ -0,0 +1,78 @@
+
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_newObjectIassign_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 针对RC优化new object assign 做场景测试：对象类中的某个域如果在类初始化时没有做赋值，则不会对它的incref(无集成场景)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_newObjectIassign_01.java
+ *- @ExecuteClass: RC_newObjectIassign_01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.Arrays;
+
+public class RC_newObjectIassign_01 {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    String[] strArray;
+    static String str1;
+    volatile String str2;
+    private RC_newObjectIassign_01(){
+        strArray=new String[10];
+        str1="MapleTest";
+        str2="FigoTest";
+    }
+    private RC_newObjectIassign_01(String str){
+        str1=str;
+        str2=str;
+    }
+    private RC_newObjectIassign_01(String[] str){
+        strArray=str;
+    }
+
+    public static void main(String[] args){
+        for(int i =1; i<=100 ; i++){
+            test_new_objct_assign();
+            if(check != 5){
+                System.out.println("ErrorResult");
+                break;
+            }else{
+                check=0;
+                str1=null;
+            }
+
+        }
+        System.out.println("ExpectResult");
+    }
+    private static void test_new_objct_assign(){
+        String[] example = {"a","b","c"};
+        String[] arrayStr = {"a","b","c"};
+        RC_newObjectIassign_01 rctest=new RC_newObjectIassign_01(arrayStr);
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 ==null && rctest.str2== null)
+            check +=1;
+        rctest.str1="firstTimeTestStr1";
+        rctest.str2="firstTimeTestStr2";
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 =="firstTimeTestStr1" && rctest.str2== "firstTimeTestStr2")
+            check +=1;
+
+        rctest = new RC_newObjectIassign_01("secondTimeTest");
+        if(Arrays.equals(rctest.strArray,null) && rctest.str1 =="secondTimeTest" && rctest.str2== "secondTimeTest")
+            check +=1;
+        rctest.strArray = arrayStr;
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 =="secondTimeTest" && rctest.str2== "secondTimeTest")
+            check +=1;
+
+        rctest=new RC_newObjectIassign_01();
+        if(rctest.strArray.length == 10 && rctest.str1 =="MapleTest" && rctest.str2== "FigoTest")
+            check +=1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/RC_newObjectIassign_02.java b/test/testsuite/ouroboros/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/RC_newObjectIassign_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..70a7950855b621e3637fccf27da0a43e50983223
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/RC_newObjectIassign_02.java
@@ -0,0 +1,81 @@
+
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_newObjectIassign_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 针对RC优化new object assign 做场景测试：对象类中的某个域如果在类初始化时没有做赋值，则不会对它的incref(无集成场景)
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_newObjectIassign_02.java
+ *- @ExecuteClass: RC_newObjectIassign_02
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.Arrays;
+class Base{
+    String[] strArray;
+    volatile String str2;
+}
+
+public class RC_newObjectIassign_02 extends Base{
+    final static String STR = "MapleTest";
+    static int check = 0;
+    static String str1;
+
+    private RC_newObjectIassign_02(){
+        strArray=new String[10];
+        str1="MapleTest";
+        str2="FigoTest";
+    }
+    private RC_newObjectIassign_02(String str){
+        str1=str;
+        str2=str;
+    }
+    private RC_newObjectIassign_02(String[] str){
+        strArray=str;
+    }
+
+    public static void main(String[] args){
+        for(int i =1; i<=100 ; i++){
+            test_new_objct_assign();
+            if(check != 5){
+                System.out.println("ErrorResult");
+                break;
+            }else{
+                check=0;
+                str1=null;
+            }
+
+        }
+        System.out.println("ExpectResult");
+    }
+    private static void test_new_objct_assign(){
+        String[] example = {"a","b","c"};
+        String[] arrayStr = {"a","b","c"};
+        RC_newObjectIassign_02 rctest=new RC_newObjectIassign_02(arrayStr);
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 ==null && rctest.str2== null)
+            check +=1;
+        rctest.str1="firstTimeTestStr1";
+        rctest.str2="firstTimeTestStr2";
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 =="firstTimeTestStr1" && rctest.str2== "firstTimeTestStr2")
+            check +=1;
+
+        rctest = new RC_newObjectIassign_02("secondTimeTest");
+        if(Arrays.equals(rctest.strArray,null) && rctest.str1 =="secondTimeTest" && rctest.str2== "secondTimeTest")
+            check +=1;
+        rctest.strArray = arrayStr;
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 =="secondTimeTest" && rctest.str2== "secondTimeTest")
+            check +=1;
+
+        rctest=new RC_newObjectIassign_02();
+        if(rctest.strArray.length == 10 && rctest.str1 =="MapleTest" && rctest.str2== "FigoTest")
+            check +=1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/RC_newObjectToField.java b/test/testsuite/ouroboros/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/RC_newObjectToField.java
new file mode 100755
index 0000000000000000000000000000000000000000..8affe8d5a13b7ccc60678a792d96ad5ba2911a3b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/RC_newObjectToField.java
@@ -0,0 +1,78 @@
+
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_newObjectToField.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 对于像mR = new Obj（）的语句; 为了分配一个新对象并将其引用分配给一个field，我们正在生成一对冗余的RC Inc / Dec操作
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_newObjectToField.java
+ *- @ExecuteClass: RC_newObjectToField
+ *- @ExecuteArgs:
+ *- @Remark:http://rnd-gitlab-ca.huawei.com/Maple/mapleall/issues/1780
+ */
+import java.util.Arrays;
+
+public class RC_newObjectToField {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    volatile static String[] strArray;
+    static String str1;
+    volatile String str2;
+    private RC_newObjectToField(){
+        strArray=new String[10];
+        str1=new String("str1")+"MapleTest";
+        str2="FigoTest";
+    }
+    private RC_newObjectToField(String str){
+        str1=new String("str1")+str;
+        str2=new String("str2")+str;
+    }
+    private RC_newObjectToField(String[] str){
+        Arrays.sort(str);
+        Arrays.toString(str);
+        new Object();
+        new String("Just Test");
+        Arrays.binarySearch(str,"d");
+        strArray=new String[10];
+        strArray=str;
+    }
+
+
+    public static void main(String[] args){
+        for(int i =1; i<=100 ; i++){
+            test_new_objct_assign();
+            if(check != 3){
+                System.out.println("ErrorResult");
+                break;
+            }else{
+                check=0;
+                str1=null;
+            }
+
+        }
+        System.out.println("ExpectResult");
+    }
+    private static void test_new_objct_assign(){
+        String[] example = {"a","b","c"};
+        String[] arrayStr = {"c","a","b"};
+        RC_newObjectToField rctest=new RC_newObjectToField(arrayStr);
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 ==null && rctest.str2== null)
+            check +=1;
+
+        rctest = new RC_newObjectToField("secondTimeTest");
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1.equals("str1secondTimeTest") && rctest.str2.equals( "str2secondTimeTest"))
+            check +=1;
+
+        rctest=new RC_newObjectToField();
+        if(rctest.strArray.length == 10 && rctest.str1.equals("str1MapleTest") && rctest.str2== "FigoTest")
+            check +=1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/RC_newObjectToField_02.java b/test/testsuite/ouroboros/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/RC_newObjectToField_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..4506c34051d50b782aaeabcf48660cd3de0ac4a0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/RC_newObjectToField_02.java
@@ -0,0 +1,83 @@
+
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_newObjectToField_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 对于像mR = new Obj（）的语句; 为了分配一个新对象并将其引用分配给一个field，我们正在生成一对冗余的RC Inc / Dec操作
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_newObjectToField_02.java
+ *- @ExecuteClass: RC_newObjectToField_02
+ *- @ExecuteArgs:
+ *- @Remark:http://rnd-gitlab-ca.huawei.com/Maple/mapleall/issues/1780
+ */
+import java.util.Arrays;
+
+public class RC_newObjectToField_02 {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    volatile static String[] strArray;
+    int[] intArray;
+    static String str1;
+    volatile String str2;
+    private RC_newObjectToField_02() throws ArithmeticException{
+        strArray=new String[10];
+        str1=new String("str1")+"MapleTest";
+        str2="FigoTest";
+        intArray = new int[]{1/0};
+    }
+    private RC_newObjectToField_02(String str) throws StringIndexOutOfBoundsException{
+        str1=(new String("str1")+str).substring(-1,-2);
+        str2=new String("str2")+str;
+    }
+    private RC_newObjectToField_02(String[] str) throws ArrayIndexOutOfBoundsException{
+        Arrays.sort(str);
+        Arrays.toString(str);
+        new Object();
+        new String("Just Test");
+        Arrays.binarySearch(str,"d");
+        intArray=new int[10];
+        strArray=new String[1];
+        strArray[2]=new String("IndexOutBounds");
+    }
+
+    public static void main(String[] args){
+        for(int i =1; i<=100 ; i++){
+            test_new_objct_assign();
+            if(check != 3){
+                System.out.println("ErrorResult");
+                break;
+            }else{
+                check=0;
+                str1=null;
+            }
+
+        }
+        System.out.println("ExpectResult");
+    }
+    private static void test_new_objct_assign(){
+        String[] arrayStr = {"c","a","b"};
+        try{
+        RC_newObjectToField_02 rctest=new RC_newObjectToField_02(arrayStr);
+        }catch(ArrayIndexOutOfBoundsException a) {
+            check += 1;
+        }
+        try{
+        RC_newObjectToField_02 rctest = new RC_newObjectToField_02("secondTimeTest");}
+        catch(StringIndexOutOfBoundsException s){
+            check +=1;
+        }
+        try{
+            RC_newObjectToField_02 rctest=new RC_newObjectToField_02();}
+        catch(ArithmeticException a){
+            check +=1;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0313-rc-function-Optimization-RC_staticInput/RC_staticInput.java b/test/testsuite/ouroboros/rc_test/RC0313-rc-function-Optimization-RC_staticInput/RC_staticInput.java
new file mode 100755
index 0000000000000000000000000000000000000000..a23a0dc285690d69487bd62986102be609d9503d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0313-rc-function-Optimization-RC_staticInput/RC_staticInput.java
@@ -0,0 +1,41 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_staticInput.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_staticInput.java
+ *- @ExecuteClass: RC_staticInput
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+public class RC_staticInput {
+    static int []test= {10,20,30,40};
+
+    public static void main(String [] args) {
+        if(test.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+        test(4,test);
+        if(test.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+    public static void test(int first, int[] second) {
+        int [] xyz = {23,24,25,26};
+        test = xyz;
+        if(second.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/RC_staticInput_02.java b/test/testsuite/ouroboros/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/RC_staticInput_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c7a72178fbecd80cc0b211bcdef64581f656cfd
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/RC_staticInput_02.java
@@ -0,0 +1,44 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_staticInput_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_staticInput_02.java
+ *- @ExecuteClass: RC_staticInput_02
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+public class RC_staticInput_02 {
+    static int []test= {10,20,30,40};
+
+    public static void main(String [] args) {
+        if(test.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+        test(4,test);
+        if(test.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+    public static void test(int first, int[] second) {
+        int [] xyz = {23,24,25,26};
+        modify(xyz);
+        if(second.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+    public static void modify(int[] temp){
+        test=temp;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0315-rc-Memory-normalTestCase1/Memory_normalTestCase1.java b/test/testsuite/ouroboros/rc_test/RC0315-rc-Memory-normalTestCase1/Memory_normalTestCase1.java
new file mode 100755
index 0000000000000000000000000000000000000000..12eadfba4428bdcd7c5f9734aa35ec9fb7bbb0da
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0315-rc-Memory-normalTestCase1/Memory_normalTestCase1.java
@@ -0,0 +1,645 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase1.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:默认启动80个线程，对62个runslot去申请释放它们所管理的区间大小的内存块,所申请的内存块不会立刻释放。
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase1.java
+ *- @ExecuteClass: Memory_normalTestCase1
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase1 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int ALLOC_4K = 4 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase1() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int slot = 0;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase1_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        System.out.println("ExpectResult");
+    }
+
+    public static void main(String[] args) {
+        testCase1();
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0316-rc-Memory-normalTestCase2/Memory_normalTestCase2.java b/test/testsuite/ouroboros/rc_test/RC0316-rc-Memory-normalTestCase2/Memory_normalTestCase2.java
new file mode 100755
index 0000000000000000000000000000000000000000..6bb585fe3b0b963a166e82e86def1b917c5cf0b4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0316-rc-Memory-normalTestCase2/Memory_normalTestCase2.java
@@ -0,0 +1,652 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:默认启动80个线程，对62个runslot去申请释放它们所管理的区间大小的内存块，一起释放。同时在起一个线程去申请同样大小的内存块去一半一半地释放。这样会造成大量的释放
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase2.java
+ *- @ExecuteClass: Memory_normalTestCase2
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase2 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase2() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int slot = 0;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            slot = i % MAX_SLOT_NUM;
+            Runnable remain = new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_HALF_RAMDOM, true, 1);
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, true, 1, DEFAULT_REPEAT_TIMES, remain), "testCase2_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        
+    }
+
+    public static void main(String[] args) {
+
+        testCase2();
+        Runtime.getRuntime().gc();
+        testCase2();
+        System.out.println("ExpectResult");
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+   
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0317-rc-Memory-normalTestCase3/Memory_normalTestCase3.java b/test/testsuite/ouroboros/rc_test/RC0317-rc-Memory-normalTestCase3/Memory_normalTestCase3.java
new file mode 100755
index 0000000000000000000000000000000000000000..c1d40a5442c25b7fd19b41ff07001657d4414bd4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0317-rc-Memory-normalTestCase3/Memory_normalTestCase3.java
@@ -0,0 +1,633 @@
+/*
+ * -@TestCaseID:rc/stress/Memory_normalTestCase3.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination:默认启动80个线程，对62个runslot去申请释放它们所管理的区间大小的内存块，不会立刻释放。同时在起一个线程去申请同样大小的内存块去一半一半地释放。
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:
+ * -@Priority: High
+ * -@Source: Memory_normalTestCase3.java
+ * -@ExecuteClass: Memory_normalTestCase3
+ * -@ExecuteArgs:
+ * -@Remark:
+ * -@Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.Random;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.HashSet;
+
+public class Memory_normalTestCase3 {
+    private static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int MAX_SLOT_NUM = 62;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    private static boolean running = true;
+    private static List<List<AllocUnit>> allThreadReference = new ArrayList<List<AllocUnit>>();
+    private static boolean rest = false;
+    private static int restTime = 5000;
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    private static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Thread interrupted during trySleep", e);
+        }
+    }
+
+    private static boolean tryRest() {
+        if (rest) {
+            trySleep(restTime);
+            return true;
+        }
+        return false;
+    }
+
+    private static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    private static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException("Thread interrupted while joining", e);
+            }
+        }
+    }
+
+    public static void wrapper() {
+        resetTestEnvirment(allThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int slot = 0;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            slot = i % MAX_SLOT_NUM;
+            Runnable remain = new MemAlloc(ALLOC_2K, slot, allThreadReference, i, MemAlloc.SAVE_HALF_RAMDOM, true, 1);
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, allThreadReference, i, MemAlloc.SAVE_HALF, false,
+                1, DEFAULT_REPEAT_TIMES, remain), "testCase3_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(allThreadReference);
+    }
+
+    public static void main(String[] args) {
+        wrapper();
+        Runtime.getRuntime().gc();
+        wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    public static class AllocUnit {
+        public byte[] unit;
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public abstract static class MemAllocMethod {
+        protected long mAllocSize;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        private final Cleaner cleaner;
+
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+//        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+//                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        private int mRepeatTimes = 1;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes,
+            Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree,
+            MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!running) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    continue;
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0318-rc-Memory-normalTestCase4/Memory_normalTestCase4.java b/test/testsuite/ouroboros/rc_test/RC0318-rc-Memory-normalTestCase4/Memory_normalTestCase4.java
new file mode 100755
index 0000000000000000000000000000000000000000..578a94383ee7862f4883b4ee7fec6bcb67336b03
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0318-rc-Memory-normalTestCase4/Memory_normalTestCase4.java
@@ -0,0 +1,652 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase4.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:默认启动80个线程，对62个runslot去申请释放它们所管理的区间大小的内存块，不会立刻释放。同时在起一个线程去申请同样大小的内存块去一半一半地释放。
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase4.java
+ *- @ExecuteClass: Memory_normalTestCase4
+ *- @ExecuteArgs:
+ *- @Remark:
+ * - @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase4 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase4() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int slot = 0;
+        for (int i = 0; i < MAX_SLOT_NUM; i++) {
+            slot = i % MAX_SLOT_NUM;
+            Runnable remain = new MemAlloc(ALLOC_2K, slot, mAllThreadReference, i, MemAlloc.SAVE_HALF_RAMDOM, true, 1);
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_HALF_RAMDOM, false, 1, DEFAULT_REPEAT_TIMES, remain), "testCase4_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase4();
+        Runtime.getRuntime().gc();
+        testCase4();
+        System.out.println("ExpectResult");
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0319-rc-Memory-normalTestCase5/Memory_normalTestCase5.java b/test/testsuite/ouroboros/rc_test/RC0319-rc-Memory-normalTestCase5/Memory_normalTestCase5.java
new file mode 100755
index 0000000000000000000000000000000000000000..d3dfa93775c568597873283e3dc0f40e575d92b5
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0319-rc-Memory-normalTestCase5/Memory_normalTestCase5.java
@@ -0,0 +1,643 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase5.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase5.java
+ *- @ExecuteClass: Memory_normalTestCase5
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase5 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if(s ==null)
+                    return;
+                if(s.isAlive()){
+                    synchronized (list){
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase5() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int average = ALLOC_4K / DEFAULT_THREAD_NUM;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_4K + Math.max(getSlotSize(slot), average), slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase5_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args){
+        testCase5();
+        Runtime.getRuntime().gc();
+        testCase5();
+        System.out.println("ExpectResult");
+    }
+
+
+
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit{
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit{
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable{
+            public byte unit[];
+            public TestCleaner(byte unit[]){
+                this.unit = unit;
+            }
+            public void run(){
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit{
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit{
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable{
+            public byte[] unit;
+            public TestCleaner(byte[] unit){
+                this.unit = unit;
+            }
+
+            public void run(){
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit{
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable{
+            public byte[] unit;
+            public TestCleaner(byte[] unit){
+                this.unit = unit;
+            }
+
+            public void run(){
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive{
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit{
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable{
+            public byte[] unit;
+            public TestCleaner(byte[] unit){
+                this.unit = unit;
+            }
+
+            public void run(){
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM){
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit{
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable{
+            public byte[] unit;
+            public TestCleaner(byte[] unit){
+                this.unit = unit;
+            }
+
+            public void run(){
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx+1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER){
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if(curNum < 3){
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if(curNum < 4){
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if(curNum < 5){
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if(curNum < 6){
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if(curNum < 7){
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if(curNum < 8){
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if(curNum < 2){
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if(curNum < 3){
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if(ret != null){
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0320-rc-Memory-normalTestCase6/Memory_normalTestCase6.java b/test/testsuite/ouroboros/rc_test/RC0320-rc-Memory-normalTestCase6/Memory_normalTestCase6.java
new file mode 100755
index 0000000000000000000000000000000000000000..4ea2a605e846c69c2c1f1d04506d4336b90aa95b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0320-rc-Memory-normalTestCase6/Memory_normalTestCase6.java
@@ -0,0 +1,661 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase6.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase6.java
+ *- @ExecuteClass: Memory_normalTestCase6
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase6 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase6() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        t = new Thread(new MemAlloc(ALLOC_4K, (int) (Math.random() * MAX_SLOT_NUM), mAllThreadReference, 0, 1, false, 1, DEFAULT_THREAD_NUM), "testCase6_" + (1));
+        list.add(t);
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        list.clear();
+        for (int i = 1; i < DEFAULT_THREAD_NUM + 1; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_8K - getSlotSize(slot), slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase6_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase6();
+        Runtime.getRuntime().gc();
+        testCase6();
+        System.out.println("ExpectResult");
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0321-rc-Memory-normalTestCase6_1/Memory_normalTestCase6_1.java b/test/testsuite/ouroboros/rc_test/RC0321-rc-Memory-normalTestCase6_1/Memory_normalTestCase6_1.java
new file mode 100755
index 0000000000000000000000000000000000000000..e65c456043449e361f5c65714cc1319a989acd61
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0321-rc-Memory-normalTestCase6_1/Memory_normalTestCase6_1.java
@@ -0,0 +1,660 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase6_1.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase6_1.java
+ *- @ExecuteClass: Memory_normalTestCase6_1
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase6_1 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase6_1() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        t = new Thread(new MemAlloc(ALLOC_4K, (int) (Math.random() * MAX_SLOT_NUM), mAllThreadReference, 0, 1, false, 1, DEFAULT_THREAD_NUM), "testCase6_1_" + (1));
+        list.add(t);
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        list.clear();
+        for (int i = 1; i < DEFAULT_THREAD_NUM + 1; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_8K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase6_1_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase6_1();
+        Runtime.getRuntime().gc();
+        testCase6_1();
+        System.out.println("ExpectResult");
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0322-rc-Memory-normalTestCase7/Memory_normalTestCase7.java b/test/testsuite/ouroboros/rc_test/RC0322-rc-Memory-normalTestCase7/Memory_normalTestCase7.java
new file mode 100755
index 0000000000000000000000000000000000000000..635be913b5acae62cfc6fb1c89017fd70ee4c708
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0322-rc-Memory-normalTestCase7/Memory_normalTestCase7.java
@@ -0,0 +1,656 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase7.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase7.java
+ *- @ExecuteClass: Memory_normalTestCase7
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+//import java.lang.ref.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase7 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase7() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_8K + getSlotSize(slot), slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase7_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase7();
+        Runtime.getRuntime().gc();
+        testCase7();
+        System.out.println("ExpectResult");
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0323-rc-Memory-normalTestCase8/Memory_normalTestCase8.java b/test/testsuite/ouroboros/rc_test/RC0323-rc-Memory-normalTestCase8/Memory_normalTestCase8.java
new file mode 100755
index 0000000000000000000000000000000000000000..69712645cad3f02319278b11da0926aaf7ec2d15
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0323-rc-Memory-normalTestCase8/Memory_normalTestCase8.java
@@ -0,0 +1,652 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase8.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase8.java
+ *- @ExecuteClass: Memory_normalTestCase8
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase8 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase8() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_8K + ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase8_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase8();
+        Runtime.getRuntime().gc();
+        testCase8();
+        System.out.println("ExpectResult");
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0324-rc-Memory-normalTestCase9/Memory_normalTestCase9.java b/test/testsuite/ouroboros/rc_test/RC0324-rc-Memory-normalTestCase9/Memory_normalTestCase9.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f1c215941ac8cb1b5be223f736c4eb67c22b3d3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0324-rc-Memory-normalTestCase9/Memory_normalTestCase9.java
@@ -0,0 +1,625 @@
+/*
+ * -@TestCaseID:rc/stress/Memory_normalTestCase9.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination:
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:
+ * -@Priority: High
+ * -@Source: Memory_normalTestCase9.java
+ * -@ExecuteClass: Memory_normalTestCase9
+ * -@ExecuteArgs:
+ * -@Remark:
+ * -@Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.*;
+
+public class Memory_normalTestCase9 {
+    static final int MAX_SLOT_NUM = 62;
+    private static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    private static final int ALLOC_12K = 12 * 1024;
+    static boolean running = true;
+    static List<List<AllocUnit>> allThreadReference = new ArrayList<List<AllocUnit>>();
+    private static boolean rest = false;
+    private static int restTime = 5000;
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    private static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Thread interrupted during trySleep", e);
+        }
+    }
+
+    private static boolean tryRest() {
+        if (rest) {
+            trySleep(restTime);
+            return true;
+        }
+        return false;
+    }
+
+    private static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    private static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException("Thread interrupted while joining", e);
+            }
+        }
+    }
+
+    private static void testCase9() {
+        resetTestEnvirment(allThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_12K, slot, allThreadReference, i, MemAlloc.SAVE_ALL,
+                false, 1), "testCase9_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(allThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase9();
+        Runtime.getRuntime().gc();
+        testCase9();
+        System.out.println("ExpectResult");
+    }
+
+    public static class AllocUnit {
+        public byte[] unit;
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        private final Cleaner cleaner;
+
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+            = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+            = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        private int mRepeatTimes = 1;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes,
+            Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree,
+            MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime,
+                repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime,
+                repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!running) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    continue;
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0325-rc-Memory-normalTestCase10/Memory_normalTestCase10.java b/test/testsuite/ouroboros/rc_test/RC0325-rc-Memory-normalTestCase10/Memory_normalTestCase10.java
new file mode 100755
index 0000000000000000000000000000000000000000..1d6a660533030b7ae8f0be2482a73a13044f83a1
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0325-rc-Memory-normalTestCase10/Memory_normalTestCase10.java
@@ -0,0 +1,651 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase10.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase10.java
+ *- @ExecuteClass: Memory_normalTestCase10
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase10 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase10() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_16K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase10_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase10();
+        Runtime.getRuntime().gc();
+        testCase10();
+        System.out.println("ExpectResult");
+
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0326-rc-Memory-normalTestCase11/Memory_normalTestCase11.java b/test/testsuite/ouroboros/rc_test/RC0326-rc-Memory-normalTestCase11/Memory_normalTestCase11.java
new file mode 100755
index 0000000000000000000000000000000000000000..d96d4ee4dda5c8230a37c504755ee2108dd9c6e4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0326-rc-Memory-normalTestCase11/Memory_normalTestCase11.java
@@ -0,0 +1,687 @@
+/*
+ * -@TestCaseID:rc/stress/Memory_normalTestCase11.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination:
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1
+ * -@Expect:
+ * -@Priority: High
+ * -@Source: Memory_normalTestCase11.java
+ * -@ExecuteClass: Memory_normalTestCase11
+ * -@ExecuteArgs:
+ * -@Remark:
+ * -@Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase11 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    private static final int MAX_SLOT_NUM = 62;
+    private static boolean rest = false;
+    private static int restTime = 5000;
+    private static boolean running = true;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static List<List<AllocUnit>> allThreadReference = new ArrayList<List<AllocUnit>>();
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    private static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Thread interrupted during trySleep", e);
+        }
+    }
+
+    private static boolean tryRest() {
+        if (rest) {
+            trySleep(restTime);
+            return true;
+        }
+        return false;
+    }
+
+    private static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    private static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException("Thread interrupted while joining", e);
+            }
+        }
+    }
+
+    private static void testCase11() {
+        resetTestEnvirment(allThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, allThreadReference, i, MemAlloc.SAVE_ALL,
+                false, 1), "testCase11_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+
+        list.clear();
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            t = new Thread(new FreeReference(allThreadReference, i, false), "testCase11_free_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(allThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase11();
+        Runtime.getRuntime().gc();
+        testCase11();
+        System.out.println("ExpectResult");
+    }
+
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!running) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+
+    public static class AllocUnit {
+        public byte []unit;
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public abstract static class MemAllocMethod {
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte []unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            private TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+            = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+            = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        public static final int PAGE_SIZE = 4016;
+        public static final int PAGE_HEADSIZE = 80;
+        public static final int OBJ_MAX_SIZE = 1008;
+        public static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        private int mRepeatTimes = 1;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes,
+            Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes,
+            Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes,Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime,
+                repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!running) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    continue;
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0327-rc-Memory-normalTestCase12/Memory_normalTestCase12.java b/test/testsuite/ouroboros/rc_test/RC0327-rc-Memory-normalTestCase12/Memory_normalTestCase12.java
new file mode 100755
index 0000000000000000000000000000000000000000..f49cdea8ea3323adad8a4e2e496c605a5db74506
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0327-rc-Memory-normalTestCase12/Memory_normalTestCase12.java
@@ -0,0 +1,727 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase12.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase12.java
+ *- @ExecuteClass: Memory_normalTestCase12
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase12 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase11() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase11_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+
+        list.clear();
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            t = new Thread(new FreeReference(mAllThreadReference, i, false), "testCase11_free_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+
+    public static void testCase12() {
+        for (int i = 0; i < 3; i++) {
+            testCase11();
+        }
+    }
+
+    public static void main(String[] args) {
+        testCase12();
+        Runtime.getRuntime().gc();
+        testCase12();
+        System.out.println("ExpectResult");
+    }
+
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0330-rc-Memory-normalTestCase15/Memory_normalTestCase15.java b/test/testsuite/ouroboros/rc_test/RC0330-rc-Memory-normalTestCase15/Memory_normalTestCase15.java
new file mode 100755
index 0000000000000000000000000000000000000000..fc3f232d30c96c8ec57b45aaf0bc330c9bcb5bff
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0330-rc-Memory-normalTestCase15/Memory_normalTestCase15.java
@@ -0,0 +1,1015 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase15.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase15.java
+ *- @ExecuteClass: Memory_normalTestCase15
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase15 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase15() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_8K * 11, ENUM_RANGE.ENUM_RANGE_BOTH, 11, 0, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(ALLOC_8K * 11, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase15_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+
+        list.clear();
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            t = new Thread(new FreeReference(mAllThreadReference, i, false), "testCase15_free_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase15();
+        Runtime.getRuntime().gc();
+        testCase15();
+        System.out.println("ExpectResult");
+    }
+
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+
+            return null;
+        }
+
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0331-rc-Memory-normalTestCase16/Memory_normalTestCase16.java b/test/testsuite/ouroboros/rc_test/RC0331-rc-Memory-normalTestCase16/Memory_normalTestCase16.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e1bfebf3c056a1cc374f1dcf7ae417c64622087
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0331-rc-Memory-normalTestCase16/Memory_normalTestCase16.java
@@ -0,0 +1,1014 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase16.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase16.java
+ *- @ExecuteClass: Memory_normalTestCase16
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase16 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase16() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_8K * 11, ENUM_RANGE.ENUM_RANGE_BOTH, 11, 80, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(ALLOC_8K * 11, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase16_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+
+        list.clear();
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            t = new Thread(new FreeReference(mAllThreadReference, i, false), "testCase16_free_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+
+    public static void main(String[] args) {
+        testCase16();
+        Runtime.getRuntime().gc();
+        testCase16();
+        System.out.println("ExpectResult");
+    }
+
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+
+            return null;
+        }
+
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0332-rc-Memory-normalTestCase17/Memory_normalTestCase17.java b/test/testsuite/ouroboros/rc_test/RC0332-rc-Memory-normalTestCase17/Memory_normalTestCase17.java
new file mode 100755
index 0000000000000000000000000000000000000000..f8abd57e2c00ba614693e0dcd9daeb2185c54afb
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0332-rc-Memory-normalTestCase17/Memory_normalTestCase17.java
@@ -0,0 +1,1004 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase17.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase17.java
+ *- @ExecuteClass: Memory_normalTestCase17
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase17 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase17() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < 2 * DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_4K * 6, ENUM_RANGE.ENUM_RANGE_ALL, 6, 0, false);
+            t = new Thread(new MemAlloc(ALLOC_4K * 6, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase17_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void main(String[] args) {
+        testCase17();
+        System.out.println("ExpectResult");
+    }
+
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+
+            return null;
+        }
+
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0333-rc-Memory-normalTestCase18/Memory_normalTestCase18.java b/test/testsuite/ouroboros/rc_test/RC0333-rc-Memory-normalTestCase18/Memory_normalTestCase18.java
new file mode 100755
index 0000000000000000000000000000000000000000..ba651be5c82a2b6732f0b13a7c54f7cb15409b5c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0333-rc-Memory-normalTestCase18/Memory_normalTestCase18.java
@@ -0,0 +1,1005 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase18.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase18.java
+ *- @ExecuteClass: Memory_normalTestCase18
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase18 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase18() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < 2 * DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_4K * 6, ENUM_RANGE.ENUM_RANGE_ALL, 6, 0, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(ALLOC_4K * 6, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, true, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase18_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void main(String[] args) {
+        testCase18();
+        Runtime.getRuntime().gc();
+        testCase18();
+        System.out.println("ExpectResult");
+    }
+
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+
+            return null;
+        }
+
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0334-rc-Memory-normalTestCase19/Memory_normalTestCase19.java b/test/testsuite/ouroboros/rc_test/RC0334-rc-Memory-normalTestCase19/Memory_normalTestCase19.java
new file mode 100755
index 0000000000000000000000000000000000000000..0881dce48b71e1c9b76ea3cf95ebb415f71f95ef
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0334-rc-Memory-normalTestCase19/Memory_normalTestCase19.java
@@ -0,0 +1,1004 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase19.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase19.java
+ *- @ExecuteClass: Memory_normalTestCase19
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase19 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase19() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < 2 * DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_8K * 6, ENUM_RANGE.ENUM_RANGE_ALL, 6, 80, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(ALLOC_8K * 6, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase19_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void main(String[] args) {
+        testCase19();
+        System.out.println("ExpectResult");
+    }
+
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+
+            return null;
+        }
+
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0335-rc-Memory-normalTestCase22/Memory_normalTestCase22.java b/test/testsuite/ouroboros/rc_test/RC0335-rc-Memory-normalTestCase22/Memory_normalTestCase22.java
new file mode 100755
index 0000000000000000000000000000000000000000..dc0fcc8b723a9acf6e48b89d39b520330e0aac10
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0335-rc-Memory-normalTestCase22/Memory_normalTestCase22.java
@@ -0,0 +1,1014 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase22.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase22.java
+ *- @ExecuteClass: Memory_normalTestCase22
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase22 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    private static final int DEFAULT_THREAD_NUM_HALF = DEFAULT_THREAD_NUM / 2;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase22() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = new Random().nextInt(MAX_SLOT_NUM);
+            int size = new Random().nextInt(ALLOC_12K) + ALLOC_4K;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(size, ENUM_RANGE.ENUM_RANGE_ALL, 6, (int) Math.random() * 100, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(size, slot, mAllThreadReference, i % DEFAULT_THREAD_NUM_HALF, MemAlloc.SAVE_ALL, true, 1000, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase22_alloc_" + (i + 1));
+            list.add(t);
+        }
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = new Random().nextInt(MAX_SLOT_NUM);
+            int size = new Random().nextInt(ALLOC_12K) + ALLOC_4K;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(size, ENUM_RANGE.ENUM_RANGE_ALL, 6, (int) Math.random() * 100, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(size, slot, mAllThreadReference, i % DEFAULT_THREAD_NUM_HALF, MemAlloc.SAVE_ALL, true, 1000, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase22_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void main(String[] args) {
+        testCase22();
+        Runtime.getRuntime().gc();
+        testCase22();
+        System.out.println("ExpectResult");
+    }
+
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+
+            return null;
+        }
+
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0336-rc-Memory-normalTestCase23/Memory_normalTestCase23.java b/test/testsuite/ouroboros/rc_test/RC0336-rc-Memory-normalTestCase23/Memory_normalTestCase23.java
new file mode 100755
index 0000000000000000000000000000000000000000..d114c8b86d7a6fa322d80ce20a2796af33c6fce9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0336-rc-Memory-normalTestCase23/Memory_normalTestCase23.java
@@ -0,0 +1,1066 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase23.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase23.java
+ *- @ExecuteClass: Memory_normalTestCase23
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase23 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    private static final int DEFAULT_THREAD_NUM_HALF = DEFAULT_THREAD_NUM / 2;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void testCase23() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = new Random().nextInt(MAX_SLOT_NUM);
+            int size = new Random().nextInt(ALLOC_12K) + ALLOC_4K;
+            MemAllocMethod allocMethod = new ContinueRandomAllocMethod(size, ENUM_RANGE.ENUM_RANGE_ALL, 6, (int) Math.random() * 100, Math.random() > 0.5d, 100, 400, 0, false);
+            t = new Thread(new MemAlloc(size, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, true, 1000, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase23_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void main(String[] args) {
+        testCase23();
+        Runtime.getRuntime().gc();
+        testCase23();
+        System.out.println("ExpectResult");
+    }
+
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+
+            return null;
+        }
+
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+
+    public static class ContinueRandomAllocMethod extends MemAllocMethod {
+        private long mSleep;
+        private long mTotalTimes;
+        private long mTimes = 0;
+        private boolean mFreeImmediately;
+
+        public ContinueRandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random, long sleep, long totalTimes, int times, boolean freeImmediately) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+            mSleep = sleep;
+            mTotalTimes = totalTimes;
+            mTimes = times;
+            mFreeImmediately = freeImmediately;
+        }
+
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = null;
+            List<AllocUnit> tmp = null;
+            if (mTotalTimes == 0 && mTimes == 0) {
+                ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+                return ret;
+            }
+            long elipseTime = 0;
+            boolean find = false;
+            ret = new ArrayList<AllocUnit>();
+
+            while (elipseTime < mTotalTimes) {
+                long now = System.currentTimeMillis();
+                tmp = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+                if (!mFreeImmediately && tmp != null) {
+                    ret.addAll(tmp);
+                } else {
+                    tmp = null;
+                }
+                find = true;
+                trySleep(mSleep);
+                elipseTime += System.currentTimeMillis() - now;
+            }
+            if (!find) {
+                int time = 0;
+                while (time < mTotalTimes) {
+                    tmp = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+                    if (!mFreeImmediately && tmp != null) {
+                        ret.addAll(tmp);
+                    } else {
+                        tmp = null;
+                    }
+                    time++;
+                    trySleep(mSleep);
+                }
+            }
+            return ret;
+        }
+    }
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+
+            return new AllocUnit(alloc_size);
+        }
+
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0337-rc-Memory-normalTestCase27/Memory_normalTestCase27.java b/test/testsuite/ouroboros/rc_test/RC0337-rc-Memory-normalTestCase27/Memory_normalTestCase27.java
new file mode 100755
index 0000000000000000000000000000000000000000..f4c6dd69fb0634619e01fa7a072343dce962a695
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0337-rc-Memory-normalTestCase27/Memory_normalTestCase27.java
@@ -0,0 +1,124 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase27.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase27.java
+ *- @ExecuteClass: Memory_normalTestCase27
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.*;
+
+public class Memory_normalTestCase27 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    private static final int DEFAULT_STRESS_THREAD_NUM = 60;
+    private static final int DEFAULT_STRESS_THREAD_NUM_HALF = DEFAULT_STRESS_THREAD_NUM / 2;
+    private static ArrayList<Thread> mThreadList = new ArrayList<Thread>();
+
+    public static void testCase27() {
+        RCWeakProxyTest.RCWeakProxyTestEntry();
+    }
+
+    public static void main(String[] args) {
+        testCase27();
+        System.out.println("ExpectResult");
+    }
+}
+
+class RCWeakProxyTest {
+    static class A {
+        Object o;
+    }
+
+    static class ThreadRunning extends Thread {
+        HashMap map;
+        Hashtable table;
+
+        ThreadRunning(HashMap m, Hashtable t) {
+            super("testCase_RCWeakProxy");
+            map = m;
+            table = t;
+        }
+
+        int foo() {
+            return map.values().size();
+        }
+
+        public void run() {
+            for (int i = 0; i < 500; i++) {
+                /*
+                 * Collection c = map.values(); if (c == null) {
+                 * System.out.println("error"); return; } int x = c.size();
+                 */
+                int x = foo();
+                if (x == 100) {
+                } else {
+                    A a = new A();
+                    a = new A();
+                }
+
+                /*
+                 * int y = table.values().size(); if (y == 100) {
+                 * System.out.println("bla"); }
+                 */
+            }
+        }
+    }
+
+    public static void RCWeakProxyTestEntry() {
+        HashMap map = new HashMap();
+        map.put("key1", "value1");
+        Hashtable table = new Hashtable();
+        table.put("key1", "value1");
+        int num_thread = 2;
+        ThreadRunning t[] = new ThreadRunning[num_thread];
+        for (int i = 0; i < num_thread; i++) {
+            t[i] = new ThreadRunning(map, table);
+            t[i].start();
+        }
+
+        try {
+            for (int i = 0; i < num_thread; i++) {
+                t[i].join();
+            }
+        } catch (Exception e) {
+        }
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0338-rc-Memory-normalTestCase28/Memory_normalTestCase28.java b/test/testsuite/ouroboros/rc_test/RC0338-rc-Memory-normalTestCase28/Memory_normalTestCase28.java
new file mode 100755
index 0000000000000000000000000000000000000000..a046684473d67c3078486bfffc41cd682ccac24e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0338-rc-Memory-normalTestCase28/Memory_normalTestCase28.java
@@ -0,0 +1,172 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_normalTestCase28.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_normalTestCase28.java
+ *- @ExecuteClass: Memory_normalTestCase28
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class Memory_normalTestCase28 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    public static final int LOCAL_MIN_IDX = 0;
+    private static final int DEFAULT_STRESS_THREAD_NUM = 60;
+    private static final String MODULE_NAME_MEMT = "MemAllocTest";
+    static List<List<AllocUnit>> mAllStressThreadReference = new ArrayList<List<AllocUnit>>();
+    private static ArrayList<Thread> mThreadList = new ArrayList<Thread>();
+
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        testCase28();
+        Runtime.getRuntime().gc();
+        testCase28();
+        Runtime.getRuntime().gc();
+        testCase28();
+        Runtime.getRuntime().gc();
+        testCase28();
+        Runtime.getRuntime().gc();
+        testCase28();
+        System.out.println("ExpectResult");
+    }
+
+    public static void testCase28() {
+
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        resetTestEnvirment(mAllStressThreadReference);
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM / 8; i++) {
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    for (int j = 0; j < 50; j++) {
+                        NativeTestFunc nativeTestFunc = new NativeTestFunc();
+                        nativeTestFunc.testNativeWeakDelete(nativeTestFunc);
+                        System.runFinalization();
+                    }
+                }
+            }, MODULE_NAME_MEMT + "_testCase28_weak_" + i);
+            list.add(t);
+        }
+
+        for (int i = 0; i < DEFAULT_THREAD_NUM / 8; i++) {
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    for (int j = 0; j < 50; j++) {
+                        NativeTestFunc nativeTestFunc = new NativeTestFunc();
+                        nativeTestFunc.testNativeGlobalDelete(nativeTestFunc);
+                        System.runFinalization();
+                    }
+                }
+            }, MODULE_NAME_MEMT + "_testCase28_global_" + i);
+            list.add(t);
+        }
+
+        mThreadList.addAll(list);
+        startAllThread(list);
+        waitAllThreadFinish(list);
+
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+}
+
+class NativeTestFunc {
+    static {
+       // System.loadLibrary("StressTestNative");
+    }
+
+    public native void testNativeAttach();
+
+    public native void testNativeWeakDelete(Object input);
+
+    public native void testNativeGlobalDelete(Object input);
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0339-rc-rp-cycle_all_weak/Ref_Processor_Cycle_All_Weak_Ref.java b/test/testsuite/ouroboros/rc_test/RC0339-rc-rp-cycle_all_weak/Ref_Processor_Cycle_All_Weak_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..32c89aac3091a1f637df8aa63a37904ff2c7dd37
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0339-rc-rp-cycle_all_weak/Ref_Processor_Cycle_All_Weak_Ref.java
@@ -0,0 +1,186 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/Ref_Processor_Cycle_All_Weak_Ref.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Reference Processor: 1.Circular references, all of which are weak references
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 分别创建Cycle_A、Cycle_B、Cycle_C、Cycle_D 四个类的对象，均含有弱引用，并且这四个对象互为循环引用；
+ * -#step2: 分别取出step1中四个对象的sum属性的值，计算它们的和并赋值给allSum；
+ * -#step3: 让当前线程休眠2000ms；
+ * -#step4: 确认四个类的对象的引用均已经释放；
+ * -#step5: 将step1中Cycle_A的实例对象cycleA赋值为null；
+ * -#step6: 让当前线程休眠2000ms；
+ * -#step7: 经判断得出step1中的四个实例对象均为null；
+ * -#step8: 调用Runtime.getRuntime().gc()进行垃圾回收，重复步骤2~8；
+ * -#step9: 分别判断allSum和checkCount的值，并确定step1中四个互为循环引用的对象为弱引用；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ref_Processor_Cycle_All_Weak_Ref.java
+ *- @ExecuteClass: Ref_Processor_Cycle_All_Weak_Ref
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class Ref_Processor_Cycle_All_Weak_Ref {
+    static int checkCount = 0;
+    static final int TEST_NUM = 1;
+    static int allSum;
+
+    public static void main(String[] args) {
+        checkCount = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            Runtime.getRuntime().gc();
+            test_01();
+
+            if (allSum == 20) {
+                checkCount++;
+                System.out.println("sum is wrong");
+            }
+
+            if (checkCount == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println("errorResult ---- checkCount: " + checkCount);
+            }
+        }
+    }
+
+    private static void test_01() {
+        Cycle_A cycleA = new Cycle_A();
+        cycleA.cyb = new Cycle_B();
+        cycleA.cyb.cyc = new Cycle_C();
+        cycleA.cyb.cyc.cyd = new Cycle_D();
+        cycleA.cyb.cyc.cyd.cya = cycleA;
+        allSum = cycleA.sum + cycleA.cyb.sum + cycleA.cyb.cyc.sum + cycleA.cyb.cyc.cyd.sum;
+        sleep(2000);
+        if ((cycleA.wr.get() != null) || (cycleA.cyb.sr.get() != null) || (cycleA.cyb.cyc.pr.get() != null)
+                || (cycleA.cyb.cyc.cyd.str.get() != null)) {
+            checkCount++;
+        }
+        cycleA = null;
+        sleep(2000);
+        if (cycleA != null && cycleA.cyb != null && cycleA.cyb.cyc != null && cycleA.cyb.cyc.cyd != null
+                && cycleA.cyb.cyc.cyd.cya != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " [test_01]a1 has not free");
+        }
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+
+class Cycle_A {
+    Reference wr;
+    Cycle_B cyb;
+    int aNum;
+    int sum;
+    static StringBuffer stringBufferA = new StringBuffer("ref_processor_cycle_A");
+
+    Cycle_A() {
+        stringBufferA = new StringBuffer("ref_processor_cycle_A");
+        wr = new WeakReference<>(stringBufferA);
+        if (wr.get() == null) {
+            assert false;
+        }
+        stringBufferA = null;
+        cyb = null;
+        aNum = 1;
+    }
+
+    int joinStr() {
+        try {
+            sum = aNum + cyb.bNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+class Cycle_B {
+    Reference sr;
+    Cycle_C cyc;
+    int bNum;
+    int sum;
+    static StringBuffer stringBufferB = new StringBuffer("ref_processor_cycle_B");
+
+    Cycle_B() {
+        stringBufferB = new StringBuffer("ref_processor_cycle_B");
+        sr = new WeakReference<>(stringBufferB);
+        if (sr.get() == null) {
+            assert false;
+        }
+        stringBufferB = null;
+        cyc = null;
+        bNum = 2;
+    }
+
+    int joinStr() {
+        try {
+            sum = bNum + cyc.cNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+class Cycle_C {
+    Reference pr;
+    Cycle_D cyd;
+    StringBuffer stringBufferC = new StringBuffer("ref_processor_cycle_C");
+    int sum;
+    int cNum;
+
+    Cycle_C() {
+        stringBufferC = new StringBuffer("ref_processor_cycle_C");
+        pr = new WeakReference<>(stringBufferC);
+        if (pr.get() == null) {
+            assert false;
+        }
+        stringBufferC = null;
+        cyd = null;
+        cNum = 3;
+    }
+
+    int joinStr() {
+        try {
+            sum = cNum + cyd.dNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+class Cycle_D {
+    Reference str;
+    Cycle_A cya;
+    StringBuffer stringBufferD = new StringBuffer("ref_processor_cycle_D");
+    int dNum;
+    int sum;
+
+    Cycle_D() {
+        stringBufferD = new StringBuffer("ref_processor_cycle_D");
+        str = new WeakReference<StringBuffer>(stringBufferD);
+        stringBufferD = null;
+        cya = null;
+        dNum = 4;
+    }
+
+    int joinStr() {
+        try {
+            int sum = dNum + cya.aNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0340-rc-rp-cycle_weak_strong/Ref_Processor_Cycle_Weak_Strong_Ref.java b/test/testsuite/ouroboros/rc_test/RC0340-rc-rp-cycle_weak_strong/Ref_Processor_Cycle_Weak_Strong_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..cfba5550729c35733c9f40eb2bffe9b00cc3ed3b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0340-rc-rp-cycle_weak_strong/Ref_Processor_Cycle_Weak_Strong_Ref.java
@@ -0,0 +1,183 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/Ref_Processor_Cycle_Weak_Strong_Ref.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Reference Processor: 1.Circular reference, has strong and weak references
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 分别创建Cycle_A、Cycle_B、Cycle_C、Cycle_D 四个类的对象，含有强弱引用，并且这四个对象互为循环引用；
+ * -#step2: 分别取出step1中四个对象的sum属性的值，计算它们的和并赋值给allSum；
+ * -#step3: 让当前线程休眠2000ms；
+ * -#step4: 确认四个类的对象的引用均已经释放；
+ * -#step5: 将step1中Cycle_A的实例对象cycleA赋值为null；
+ * -#step6: 让当前线程休眠2000ms；
+ * -#step7: 经判断得出step1中的四个实例对象均为null；
+ * -#step8: 调用Runtime.getRuntime().gc()进行垃圾回收，重复步骤2~8；
+ * -#step9: 分别判断allSum和checkCount的值，并确定step1中四个互为循环引用的对象既有强引用，又有弱引用；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ref_Processor_Cycle_Weak_Strong_Ref.java
+ *- @ExecuteClass: Ref_Processor_Cycle_Weak_Strong_Ref
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class Ref_Processor_Cycle_Weak_Strong_Ref {
+    static int checkCount = 0;
+    static final int TEST_NUM = 1;
+    static int allSum;
+
+    public static void main(String[] args) {
+        checkCount = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            Runtime.getRuntime().gc();
+            test_01();
+
+            if (allSum == 20) {
+                checkCount++;
+                System.out.println("sum is wrong");
+            }
+
+            if (checkCount == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println("errorResult ---- checkCount: " + checkCount);
+            }
+        }
+    }
+
+    private static void test_01() {
+        Cycle_A cycleA = new Cycle_A();
+        cycleA.cyb = new Cycle_B();
+        cycleA.cyb.cyc = new Cycle_C();
+        cycleA.cyb.cyc.cyd = new Cycle_D();
+        cycleA.cyb.cyc.cyd.cya = cycleA;
+        allSum = cycleA.sum + cycleA.cyb.sum + cycleA.cyb.cyc.sum + cycleA.cyb.cyc.cyd.sum;
+        sleep(2000);
+        if ((cycleA.wr.get() != null) || (cycleA.cyb.sr.get() != null) || (cycleA.cyb.cyc.pr.get() != null)
+                || (cycleA.cyb.cyc.cyd.string == null)) {
+            checkCount++;
+        }
+        cycleA = null;
+        sleep(2000);
+        if (cycleA != null && cycleA.cyb != null && cycleA.cyb.cyc != null && cycleA.cyb.cyc.cyd != null
+                && cycleA.cyb.cyc.cyd.cya != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " [test_01]a1 has not free");
+        }
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+
+class Cycle_A {
+    Reference wr;
+    Cycle_B cyb;
+    int aNum;
+    int sum;
+    static StringBuffer stringBufferA = new StringBuffer("ref_processor_cycle_A");
+
+    Cycle_A() {
+        stringBufferA = new StringBuffer("ref_processor_cycle_A");
+        wr = new WeakReference<>(stringBufferA);
+        if (wr.get() == null) {
+            assert false;
+        }
+        stringBufferA = null;
+        cyb = null;
+        aNum = 1;
+    }
+
+    int joinStr() {
+        try {
+            sum = aNum + cyb.bNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+class Cycle_B {
+    Reference sr;
+    Cycle_C cyc;
+    int bNum;
+    int sum;
+    static StringBuffer stringBufferB = new StringBuffer("ref_processor_cycle_B");
+
+    Cycle_B() {
+        stringBufferB = new StringBuffer("ref_processor_cycle_B");
+        sr = new WeakReference<>(stringBufferB);
+        if (sr.get() == null) {
+            assert false;
+        }
+        stringBufferB = null;
+        cyc = null;
+        bNum = 2;
+    }
+
+    int joinStr() {
+        try {
+            sum = bNum + cyc.cNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+class Cycle_C {
+    Reference pr;
+    Cycle_D cyd;
+    StringBuffer stringBufferC = new StringBuffer("ref_processor_cycle_C");
+    int sum;
+    int cNum;
+
+    Cycle_C() {
+        stringBufferC = new StringBuffer("ref_processor_cycle_C");
+        pr = new WeakReference<>(stringBufferC);
+        if (pr.get() == null) {
+            assert false;
+        }
+        stringBufferC = null;
+        cyd = null;
+        cNum = 3;
+    }
+
+    int joinStr() {
+        try {
+            sum = cNum + cyd.dNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+class Cycle_D {
+    String string;
+    Cycle_A cya;
+    int dNum;
+    int sum;
+
+    Cycle_D() {
+        string = new String("ref_processor_cycle_D");
+        cya = null;
+        dNum = 4;
+    }
+
+    int joinStr() {
+        try {
+            int sum = dNum + cya.aNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0341-rc-rp-mutator/Ref_Processor_Mutator_Ref.java b/test/testsuite/ouroboros/rc_test/RC0341-rc-rp-mutator/Ref_Processor_Mutator_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..f388259769067bb6a200668c0258e490a4d7d93e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0341-rc-rp-mutator/Ref_Processor_Mutator_Ref.java
@@ -0,0 +1,138 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/Ref_Processor_Mutator_Ref.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Reference Processor and Mutator threads are called simultaneously (test work queue)
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建三个ReferenceQueue类的对象，并令其分别等于wrq、srq、prq；声明三个StringBuffer类型的变量stringBuffer1、
+ *          stringBuffer2、stringBuffer3并分别赋值为weak、soft、phantom；
+ * -#step2: 以stringBuffer1、wrq为参数，创建一个WeakReference类的对象wr；同理，以stringBuffer2、srq为参数，创建一个
+ *          WeakReference类的对象sr；以stringBuffer3、prq为参数，创建一个PhantomReference类的对象pr；
+ * -#step3: 通过wr.get()、sr.get()、pr.get()方法分别获取各自的referent对象，经判断获取到的referent对象均不为null；
+ * -#step4: 令变量stringBuffer1、stringBuffer2、stringBuffer3等于null；
+ * -#step5: 让当前线程休眠2000ms；
+ * -#step6: 经判断通过wr.get()方法获取的referent对象为null；同理，通过sr.get()方法获取的referent对象为null；
+ * -#step7: wrq、srq、prq引用队列判断它们均为null；
+ * -#step8: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step9: 重复步骤1~8三次；
+ * -#step10: 重复步骤1~7；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ref_Processor_Mutator_Ref.java
+ *- @ExecuteClass: Ref_Processor_Mutator_Ref
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class Ref_Processor_Mutator_Ref {
+    static int check_count = 0;
+    static final int TEST_NUM = 1;
+    static Reference wr, sr, pr;
+    static ReferenceQueue wrq, srq, prq;
+    static StringBuffer stringBuffer1 = new StringBuffer("weak");
+    static StringBuffer stringBuffer2 = new StringBuffer("soft");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+
+        if (check_count == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error,check_count: " + check_count);
+        }
+    }
+
+    private static void test() {
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            sleep(2000);
+            if (wr.get() != null) {
+                check_count++;
+            }
+            if (sr.get() != null) {
+                check_count++;
+            }
+        }
+
+        Reference wrqPoll, srqPoll, prqPoll;
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                check_count++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                        "wrq.poll()");
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                check_count++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                        "srq.poll()");
+            }
+        }
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                check_count++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                        "prq.poll()");
+            }
+        }
+    }
+
+    public static void test_01() {
+        wrq = new ReferenceQueue();
+        srq = new ReferenceQueue();
+        prq = new ReferenceQueue();
+        stringBuffer1 = new StringBuffer("weak");
+        stringBuffer2 = new StringBuffer("soft");
+        stringBuffer3 = new StringBuffer("phantom");
+        wr = new WeakReference<StringBuffer>(stringBuffer1, wrq);
+        if (wr.get() == null) {
+            check_count++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ----------------------" +
+                    "check_count: " + check_count);
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in wr");
+        }
+
+        sr = new WeakReference<StringBuffer>(stringBuffer2, srq);
+        if (sr.get() == null) {
+            check_count++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ----------------------" +
+                    "check_count: " + check_count);
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in sr");
+        }
+
+        pr = new PhantomReference<StringBuffer>(stringBuffer3, prq);
+        if (pr.get() != null) {
+            check_count++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ----------------------" +
+                    "check_count: " + check_count);
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in pr");
+        }
+        stringBuffer1 = null;
+        stringBuffer2 = null;
+        stringBuffer3 = null;
+    }
+
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0342-rc-rp-weak_ref_boundary/Ref_Processor_Weak_Ref_Boundary.java b/test/testsuite/ouroboros/rc_test/RC0342-rc-rp-weak_ref_boundary/Ref_Processor_Weak_Ref_Boundary.java
new file mode 100755
index 0000000000000000000000000000000000000000..a6db428a0f37701a93c670a2df593b21e27ce471
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0342-rc-rp-weak_ref_boundary/Ref_Processor_Weak_Ref_Boundary.java
@@ -0,0 +1,200 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/Ref_Processor_Weak_Ref_Boundary.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Reference Processor: 1.14 mix weak references
+ *                                           2.15 mix weak references
+ *                                           3.16 mix weak references
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 声明一个ReferenceQueue类的实例对象srq，以stringBuffer1和srq为参数，创建一个WeakReference类的实例对象并赋值给sr，
+ *          判断sr.get()的返回值不为null；
+ * -#step2: 重复step1四次后，令stringBuffer1等于null；
+ * -#step3: 让当前线程休眠2000ms，经判断sr不为null；
+ * -#step4: 判断得出sr.get()的返回值为null；
+ * -#step5: 重复步骤4四次后，经判断srq.poll()的返回值不为null，并且其是WeakReference类的一个实例对象；
+ * -#step6: 创建一个StringBuffer类型的变量stringBuffer2，并赋初值为weak，同时声明一个ReferenceQueue类的实例对象wrq，以
+ *          stringBuffer2和wrq为参数，创建一个WeakReference类的实例对象并赋值给wr，经判断wr.get()的返回值不为null；
+ * -#step7: 重复step6三次后，令stringBuffer2等于null；让当前线程休眠2000ms，经判断wr不为null；
+ * -#step8: 判断得出wr.get()的返回值不为null，否则将check_count的值加1，并打印相关信息；
+ * -#step9: 重复步骤8三次后，经判断wrq.poll()的返回值不为null，并且其是WeakReference类的一个实例对象；
+ * -#step10: 创建一个StringBuffer类型的变量stringBuffer3，并赋初值为phantom，同时声明一个ReferenceQueue类的实例对象prq，
+ *           以stringBuffer3和prq为参数，创建一个WeakReference类的实例对象并赋值给pr，经判断pr.get()的返回值不为null；
+ * -#step11: 重复step10四次后，令stringBuffer3等于null；
+ * -#step12: 经判断prq.poll()的返回值不为null，并且其是WeakReference类的一个实例对象；
+ * -#step13: 重复步骤1~12，但是在执行步骤7的时候，由原来的重复步骤step6三次变为四次；同样，在执行步骤9的时候，由原来的
+ *           重复步骤8三次变为四次；
+ * -#step14: 重复步骤1~12，但是在执行步骤7的时候，由原来的重复步骤step6三次变为五次；同样，在执行步骤9的时候，由原来的
+ *           重复步骤8三次变为五次；
+ * -#step15: 让当前线程休眠1000ms；
+ * -#step16: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step17: 重复步骤1~16两次；
+ * -#step18: 重复步骤1~15一次；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ref_Processor_Weak_Ref_Boundary.java
+ *- @ExecuteClass: Ref_Processor_Weak_Ref_Boundary
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class Ref_Processor_Weak_Ref_Boundary {
+    static int checkCount = 0;
+    static final int TEST_NUM = 1;
+
+    static WeakReference wr[] = new WeakReference[14];
+    static WeakReference sr[] = new WeakReference[14];
+    static PhantomReference pr[] = new PhantomReference[14];
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+
+        //Result judgment
+        if (checkCount == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("errorResult,checkNum: " + checkCount);
+        }
+    }
+
+    private static void test() {
+        //test01: 14 mix weak references
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+        }
+        sleep(1000);
+    }
+
+    public static void setSoftRef(int times) {
+        stringBuffer1 = new StringBuffer("soft");
+        for (int i = 0; i < times; i++) {
+            sr[i] = new WeakReference<Object>(stringBuffer1, srq);
+            if (sr[i].get() == null) {
+                System.out.println(" ---------------error in sr of test01");
+                checkCount++;
+            }
+        }
+        stringBuffer1 = null;
+    }
+
+    public static void setWeakRef(int times) {
+        stringBuffer2 = new StringBuffer("Weak");
+        for (int i = 0; i < times; i++) {
+            wr[i] = new WeakReference<Object>(stringBuffer2, wrq);
+            if (wr[i].get() == null) {
+                System.out.println(" ---------------error in wr of test01");
+                checkCount++;
+            }
+        }
+        stringBuffer2 = null;
+    }
+
+    public static void setPhantomRef(int times) {
+        stringBuffer3 = new StringBuffer("phantom");
+        for (int i = 0; i < times; i++) {
+            pr[i] = new PhantomReference<Object>(stringBuffer3, prq);
+            if (pr[i].get() != null) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ---------------" +
+                        "error in pr of test01");
+                checkCount++;
+            }
+        }
+        stringBuffer3 = null;
+    }
+
+    public static void test_01() {
+        /* 14 mix weak references */
+        setSoftRef(5);
+        checkSoftRq("soft", 5);
+        setWeakRef(4);
+        checkWeakRq("weak", 4);
+        setPhantomRef(5);
+        checkPhantomRq("phantom");
+
+        setSoftRef(5);
+        checkSoftRq("soft", 5);
+        setWeakRef(5);
+        checkWeakRq("weak", 5);
+        setPhantomRef(5);
+        checkPhantomRq("phantom");
+
+        setSoftRef(5);
+        checkSoftRq("soft", 5);
+        setWeakRef(6);
+        checkWeakRq("weak", 6);
+        setPhantomRef(5);
+        checkPhantomRq("phantom");
+    }
+
+    public static void checkSoftRq(String funName, int times) {
+        Reference srqPoll;
+        sleep(2000);
+        if (sr != null) {
+            for (int i = 0; i < times; i++) {
+                if (sr[i].get() != null) {
+                    checkCount++;
+                    System.out.println(" ErrorResult in sr      " + funName);
+                }
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in srq.poll()");
+            }
+        }
+    }
+
+    public static void checkWeakRq(String funName, int times) {
+        Reference wrqPoll;
+        sleep(2000);
+        for (int i = 0; i < times; i++) {
+            if (wr[i].get() != null) {
+                checkCount++;
+                System.out.println(" ErrorResult in wr       " + funName + "times:" + i);
+            }
+        }
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in wrq.poll()");
+            }
+        }
+    }
+
+    public static void checkPhantomRq(String funName) {
+        Reference prqPoll;
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in prq.poll()");
+            }
+        }
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0343-rc-rp-wcb_test_ref/Ref_Processor_Wcb_Test_Ref.java b/test/testsuite/ouroboros/rc_test/RC0343-rc-rp-wcb_test_ref/Ref_Processor_Wcb_Test_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..2bf1ee8e5ce13f75653d203bd989f518f76d4da7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0343-rc-rp-wcb_test_ref/Ref_Processor_Wcb_Test_Ref.java
@@ -0,0 +1,136 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/ref_processor_strong_and_weak_ref.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Reference Processor WCB test: 1.if WCB == 0, return object value
+ *                                                    2.if WCB == 1, return null
+ *                                                    3.check change WCB 1 to 0
+ *                                                    4.check change WCB 0 to 1
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建WeakReference类型的引用变量sr，wr和pr，经判断它们均不为null，令变量stringBuffer1、stringBuffer2、
+ *          stringBuffer3等于null；
+ * -#step2: 让当前线程休眠1000ms；
+ * -#step3: 让当前线程休眠2000ms；
+ * -#step4: 经判断sr.get()的返回值不为null，则令checkCount的值加1；同理，wr.get()的返回值也不为null，令checkCount的值
+ *          加1；pr.get()的返回值也不为null，令checkCount的值加1；
+ * -#step5: 分别令wrq.poll()、srq.poll()、prq.poll()的返回值为wrqPoll、srqPoll、prqPoll，经判断它们均不为null，并且都是
+ *          WeakReference类的一个实例对象；
+ * -#step6: 重复步骤1~5；
+ * -#step7: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step8: 重复步骤1~6；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ref_Processor_Wcb_Test_Ref.java
+ *- @ExecuteClass: Ref_Processor_Wcb_Test_Ref
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class Ref_Processor_Wcb_Test_Ref {
+    static int checkCount = 0;
+    static final int TEST_NUM = 1;
+    static Reference wr, sr, pr;
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+
+        if (checkCount == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("errorResult ---- checkcount: " + checkCount);
+        }
+    }
+
+    private static void test() {
+        // test: if WCB == 0, return object value
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            sleep(1000);
+        }
+        // test: if WCB == 1, return null
+        checkRet("test step 2");
+        // test: check change WCB 1 to 0
+    }
+
+    private static void test_01() {
+        /*if WCB == 0, return object value except PhantomReference*/
+        stringBuffer1 = new StringBuffer("soft");
+        stringBuffer2 = new StringBuffer("weak");
+        stringBuffer3 = new StringBuffer("phantom");
+
+        wr = new WeakReference<Object>(stringBuffer2, wrq);
+        if (wr.get() == null) {
+            checkCount++;
+        }
+
+        sr = new WeakReference<Object>(stringBuffer1, srq);
+        if (sr.get() == null) {
+            checkCount++;
+        }
+
+        pr = new PhantomReference<Object>(stringBuffer3, prq);
+        if (pr.get() != null) {
+            checkCount++;
+        }
+        stringBuffer2 = null;
+        stringBuffer1 = null;
+        stringBuffer3 = null;
+    }
+
+    private static void checkRet(String funName) {
+        sleep(2000);
+        Reference wrqPoll, srqPoll, prqPoll;
+        if (sr.get() != null) {
+            checkCount++;
+        }
+        if (wr.get() != null) {
+            checkCount++;
+        }
+        if (pr.get() != null) {
+            checkCount++;
+        }
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in wrq.poll()");
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in srq.poll()");
+            }
+        }
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in prq.poll()");
+            }
+        }
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0344-rc-rp-test_aged_ref/Ref_Processor_Aged_Ref.java b/test/testsuite/ouroboros/rc_test/RC0344-rc-rp-test_aged_ref/Ref_Processor_Aged_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..7f3fe2dd8b838384619c845d121f00a3c945d54b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0344-rc-rp-test_aged_ref/Ref_Processor_Aged_Ref.java
@@ -0,0 +1,161 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/Ref_Processor_Aged_Ref.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Reference Processor: 1. Threshold for Ref object == age - 1
+ *                                           2. Threshold for Ref object == age
+ *                                           3. Threshold for Ref object == age + 1
+ *                                           4. Has entered the Aged Ref queue, the number of processing == X-1
+ *                                           5. Has entered the Aged Ref queue, the number of processing == X
+ *                                           6. Has entered the Aged Ref queue, the number of processing == X+1
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建软引用，弱引用，虚引用，并判断创建后引用不为空。
+ * -#step2: 等待一个时间，引用应该被回收为空，引用队列也为空。
+ * -#step3: 将步骤1,2的操作分别重复age-1、age、age+1。
+ * -#step4: 此时会到达age的引用队列，重复步骤1~3。
+ * -#step5: 调用Runtime.getRuntime().gc()进行资源回收。
+ * -#step6: 重复步骤1~4。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ref_Processor_Aged_Ref.java
+ *- @ExecuteClass: Ref_Processor_Aged_Ref
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class Ref_Processor_Aged_Ref {
+    static int check_count = 0;
+    static final int TEST_NUM = 1;
+    static final int AGED_NUM = 3;
+    static WeakReference sr[] = new WeakReference[AGED_NUM + 1];
+    static WeakReference wr[] = new WeakReference[AGED_NUM + 1];
+    static PhantomReference pr[] = new PhantomReference[AGED_NUM + 1];
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("WeakReference");
+    static StringBuffer obj2 = new StringBuffer("WeakReference");
+    static StringBuffer obj3 = new StringBuffer("PhantomReference");
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+
+        if (check_count == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check_count : " + check_count);
+        }
+    }
+
+    public static void test() {
+        for (int i = 0; i < TEST_NUM; i++) {
+            // Threshold for Ref object == age - 1
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM - 1);
+            checkRef(AGED_NUM - 1);
+            // Threshold for Ref object == age
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM);
+            checkRef(AGED_NUM);
+            // Threshold for Ref object == age + 1
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM + 1);
+            checkRef(AGED_NUM + 1);
+            // Has entered the Aged Ref queue
+            // The number of processing == X-1
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM - 1);
+            checkRef(AGED_NUM - 1);
+            //the number of processing == X
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM);
+            checkRef(AGED_NUM);
+            //the number of processing == X+1
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM + 1);
+            checkRef(AGED_NUM + 1);
+        }
+    }
+
+    public static void setRef(int repeat_time) {
+        /*Threshold for Ref object == age - 1*/
+        for (int i = 0; i < repeat_time; i++) {
+            sr[i] = new WeakReference<StringBuffer>(obj1, srq);
+            if (sr[i].get() == null) {
+                check_count++;
+                System.out.println("sr in setRef    " + i + "repeat_time:" + repeat_time);
+            }
+            wr[i] = new WeakReference<StringBuffer>(obj2, wrq);
+            if (wr[i].get() == null) {
+                check_count++;
+                System.out.println("wr in setRef     " + i + "repeat_time:" + repeat_time);
+            }
+            pr[i] = new PhantomReference<StringBuffer>(obj3, prq);
+            if (pr[i].get() != null) {
+                check_count++;
+                System.out.println("pr in setRef");
+            }
+        }
+        obj1 = null;
+        obj2 = null;
+        obj3 = null;
+    }
+
+    public static void checkRef(int repeat_time) {
+        sleep(2000);
+        for (int i = 0; i < repeat_time; i++) {
+            if (sr[i].get() != null) {
+                check_count++;
+            }
+            if (wr[i].get() != null) {
+                check_count++;
+            }
+            Reference wrqPoll, srqPoll, prqPoll;
+            while ((wrqPoll = wrq.poll()) != null) {
+                if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in wrq.poll()");
+                }
+            }
+            while ((srqPoll = srq.poll()) != null) {
+                if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in srq.poll()");
+                }
+            }
+            while ((prqPoll = prq.poll()) != null) {
+                if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in prq.poll()");
+                }
+            }
+        }
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(" sleep was Interrupted");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0345-rc-rp-single_or_more/Ref_Processor_Single_Or_More_Weak_Ref.java b/test/testsuite/ouroboros/rc_test/RC0345-rc-rp-single_or_more/Ref_Processor_Single_Or_More_Weak_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c27870788e185f7f8792c585c83c922b32edadf
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0345-rc-rp-single_or_more/Ref_Processor_Single_Or_More_Weak_Ref.java
@@ -0,0 +1,199 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/Ref_Processor_Single_Or_More_Weak_Ref.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Reference Processor: single weak/soft phantom reference.
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建弱引用，并判断创建后引用不为空, 等待一个时间，引用应该被回收为空，引用队列也为空。
+ * -#step2: 创建软引用，并判断创建后引用不为空, 等待一个时间，引用应该被回收为空，引用队列也为空。
+ * -#step3: 创建虚引用，并判断创建后引用不为空, 等待一个时间，引用应该被回收为空，引用队列也为空。
+ * -#step4: 同时创建弱引用、软引用、虚引用，并判断创建后引用不为空, 等待一个时间，引用应该被回收为空，引用队列也为空。
+ * -#step5: 调用Runtime.getRuntime().gc()进行资源回收。
+ * -#step6: 重复步骤1~4。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ref_Processor_Single_Or_More_Weak_Ref.java
+ *- @ExecuteClass: Ref_Processor_Single_Or_More_Weak_Ref
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class Ref_Processor_Single_Or_More_Weak_Ref {
+    static int check_count = 0;
+    static final int TEST_NUM = 1;
+    static Reference wr, sr, pr;
+    static ReferenceQueue wrq, srq, prq;
+
+    static StringBuffer obj_1 = new StringBuffer("hello");
+    static StringBuffer obj_2 = new StringBuffer("kitty");
+    static StringBuffer obj_3 = new StringBuffer("mikey");
+    static StringBuffer obj4 = new StringBuffer("WeakReference");
+    static StringBuffer obj5 = new StringBuffer("WeakReference");
+    static StringBuffer obj6 = new StringBuffer("PhantomReference");
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        if (check_count == 0)
+            System.out.println("ExpectResult");
+        else {
+            System.out.println("ErrorResult, check_count:" + check_count);
+        }
+    }
+
+    private static void test() {
+        Reference wrqPoll, srqPoll, prqPoll;
+        for (int i = 0; i < TEST_NUM; i++) {
+            weakRef();
+            sleep(2000);
+            if (wr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in weakRef step1");
+            }
+            while ((wrqPoll = wrq.poll()) != null) {
+                if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in wrq.poll() step2");
+                }
+            }
+        }
+        // check WeakReference
+        for (int i = 0; i < TEST_NUM; i++) {
+            softRef();
+            sleep(2000);
+
+            if (sr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in softRef step2");
+            }
+            while ((srqPoll = srq.poll()) != null) {
+                if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in srq.poll()");
+                }
+            }
+        }
+        // check PhantomReference
+        for (int i = 0; i < TEST_NUM; i++) {
+            phantomRef();
+            sleep(2000);
+            while ((prqPoll = prq.poll()) != null) {
+                if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in prq.poll()");
+                }
+            }
+        }
+        // more than one reference
+        for (int i = 0; i < TEST_NUM; i++) {
+            mixRef();
+            sleep(2000);
+            if (wr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in mixRef step2:weakRef");
+            }
+            if (sr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in mixRef step2:softRef");
+            }
+            if (pr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in mixRef step2:phantomRef");
+            }
+
+            while ((wrqPoll = wrq.poll()) != null) {
+                if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in wrq.poll()");
+                }
+            }
+            while ((srqPoll = srq.poll()) != null) {
+                if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in srq.poll()");
+                }
+            }
+            while ((prqPoll = prq.poll()) != null) {
+                if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in prq.poll()");
+                }
+            }
+        }
+    }
+
+    private static void weakRef() {
+        wrq = new ReferenceQueue();
+        obj_1 = new StringBuffer("hello");
+        wr = new WeakReference<StringBuffer>(obj_1, wrq);
+        if (wr.get() == null) {
+            check_count++;
+            System.out.println(" ErrorResult in weakRef step1");
+        }
+        obj_1 = null;
+    }
+
+    private static void softRef() {
+        srq = new ReferenceQueue();
+        obj_2 = new StringBuffer("kitty");
+        sr = new WeakReference<StringBuffer>(obj_2, srq);
+        if (sr.get() == null) {
+            check_count++;
+            System.out.println(" ErrorResult in softRef step1");
+        }
+        obj_2 = null;
+    }
+
+    private static void phantomRef() {
+        obj_3 = new StringBuffer("mikey");
+        prq = new ReferenceQueue();
+        pr = new PhantomReference<StringBuffer>(obj_3, prq);
+        if (pr.get() != null) {
+            check_count++;
+            System.out.println(" ErrorResult in phantomRef step1");
+        }
+        obj_3 = null;
+    }
+
+    private static void mixRef() {
+        wrq = new ReferenceQueue();
+        srq = new ReferenceQueue();
+        prq = new ReferenceQueue();
+        obj4 = new StringBuffer("WeakReference");
+        obj5 = new StringBuffer("WeakReference");
+        obj6 = new StringBuffer("PhantomReference");
+        wr = new WeakReference<StringBuffer>(obj4, wrq);
+        if (wr.get() == null) {
+            check_count++;
+            System.out.println(" ErrorResult of wr in mixRef step1");
+        }
+        sr = new WeakReference<StringBuffer>(obj5, srq);
+        if (sr.get() == null) {
+            check_count++;
+            System.out.println(" ErrorResult of sr in mixRef step2");
+        }
+        pr = new PhantomReference<StringBuffer>(obj6, prq);
+        if (pr.get() != null) {
+            check_count++;
+            System.out.println(" ErrorResult of pr in mixRef step3");
+        }
+        obj4 = null;
+        obj5 = null;
+        obj6 = null;
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(" sleep was Interrupted");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+
diff --git a/test/testsuite/ouroboros/rc_test/RC0346-rc-rp-strong_and_weak/Ref_Processor_Strong_And_Weak_Ref.java b/test/testsuite/ouroboros/rc_test/RC0346-rc-rp-strong_and_weak/Ref_Processor_Strong_And_Weak_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..90776ca5903f6624f17fcf8014a12166a0577381
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0346-rc-rp-strong_and_weak/Ref_Processor_Strong_And_Weak_Ref.java
@@ -0,0 +1,131 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/Ref_Processor_Strong_And_Weak_Ref.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Reference Processor: strong and weak reference, first free strong, next free weak
+ *
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建弱引用，软引用，虚引用，判断这些引用不为空。
+ * -#step2: 将弱引用，软引用，虚引用的引用的对象置为NULL，释放强引用。
+ * -#step3: 等待一个时间周期，检查引用，软引用，虚引用及对应引用队列被释放。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ref_Processor_Strong_And_Weak_Ref.java
+ *- @ExecuteClass: Ref_Processor_Strong_And_Weak_Ref
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class Ref_Processor_Strong_And_Weak_Ref {
+    static int check_count = 0;
+    static final int TEST_NUM = 1;
+    static String rf = new String("test");
+    static Reference wr, sr, pr;
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("weak");
+    static StringBuffer obj2 = new StringBuffer("soft");
+    static StringBuffer obj3 = new StringBuffer("phantom");
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+
+        if (check_count == 0){
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult check_count : " + check_count);
+        }
+    }
+
+    private static void test() {
+        // strong and weak reference, first free strong, next free weak
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+        }
+        checkRq("test_01_02");
+    }
+
+    private static void test_01() {
+        /* strong and weak reference, first free strong, next free weak */
+        obj1 = new StringBuffer("weak");
+        obj2 = new StringBuffer("soft");
+        obj3 = new StringBuffer("phantom");
+        wr = new WeakReference<Object>(obj1, wrq);
+        if (wr.get() == null) {
+            check_count++;
+            System.out.println("error in test01---------------wr");
+        }
+
+        sr = new WeakReference<Object>(obj2, srq);
+        if (sr.get() == null) {
+            check_count++;
+            System.out.println("error in test01----------------sr");
+        }
+
+        pr = new PhantomReference<Object>(obj3, prq);
+        if (pr.get() != null) {
+            check_count++;
+            System.out.println("error in test01----------------pr");
+        }
+
+        obj1 = null;
+        obj2 = null;
+        obj3 = null;
+        if (rf == null) {
+            check_count++;
+            System.out.println("error in test01-----------rf");
+        }
+    }
+
+    private static void checkRq(String funName) {
+        Reference wrqPoll, srqPoll, prqPoll;
+        sleep(2000);
+        if (wr.get() != null) {
+            System.out.println("error in checkRq---------------wr");
+            check_count++;
+        }
+        if (sr.get() != null) {
+            System.out.println("error in checkRq--------------sr");
+            check_count++;
+        }
+        if (rf == null || (!rf.equals("test"))) {
+            System.out.println("error in checkRq---------------rf");
+            check_count++;
+        }
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                check_count++;
+                System.out.println("ErrorResult in wrq.poll()");
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                check_count++;
+                System.out.println("ErrorResult in srq.poll()");
+            }
+        }
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                check_count++;
+                System.out.println("ErrorResult in prq.poll()");
+            }
+        }
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println("sleep was Interrupted");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0347-rc-rp-simulthread/SimulThreadInRef.java b/test/testsuite/ouroboros/rc_test/RC0347-rc-rp-simulthread/SimulThreadInRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..22080011738529e488b341d3acfc3c0885c627f3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0347-rc-rp-simulthread/SimulThreadInRef.java
@@ -0,0 +1,254 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/SimulThreadInRef.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefTest basic testcase.
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建线程来设置软引用，等待一个时间周期，确认软引用被释放，软引用队列为空。
+ * -#step2: 调用Runtime.getRuntime().gc()，重复步骤1;
+ * -#step3: 创建线程来设置弱引用，等待一个时间周期，确认弱引用被释放，弱引用队列为空。
+ * -#step4: 调用Runtime.getRuntime().gc()，重复步骤3;
+ * -#step5: 创建线程来设置虚引用，等待一个时间周期，确认虚引用被释放，虚引用队列为空。
+ * -#step6: 调用Runtime.getRuntime().gc()，重复步骤5;
+ * -#step7: 创建线程来设置其他引用，调用Runtime.getRuntime().gc()。
+ * -#step8: 调用Runtime.getRuntime().gc()，重复步骤1~7。
+ *- @Expect: ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: SimulThreadInRef.java
+ *- @ExecuteClass: SimulThreadInRef
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class SimulThreadInRef {
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+    }
+
+    static void test() {
+        int soft, weak, phantom;
+        soft = testExecuteSoft();
+        Runtime.getRuntime().gc();
+        soft = testExecuteSoft();
+
+        weak = testExecuteWeak();
+        Runtime.getRuntime().gc();
+        weak = testExecuteWeak();
+
+        phantom = testExecutePhantom();
+        Runtime.getRuntime().gc();
+        phantom = testExecutePhantom();
+
+        testExecuteOther();
+        Runtime.getRuntime().gc();
+    
+        if ((soft == 0) && (weak == 0) && (phantom == 0)) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    static int testExecuteSoft() {
+        MultiRef multiRef = new MultiRef();
+        ThreadTestSoftRef threadTestSoftRef = new ThreadTestSoftRef(multiRef);
+        int N = 1;
+        for (int i = 0; i < N; i++) {
+            threadTestSoftRef.run();
+        }
+        return threadTestSoftRef.count1;
+    }
+
+    static int testExecuteWeak() {
+        MultiRef multiRef = new MultiRef();
+        ThreadTestWeakRef threadTestWeakRef = new ThreadTestWeakRef(multiRef);
+        int N = 1;
+        for (int i = 0; i < N; i++) {
+            threadTestWeakRef.run();
+        }
+        return threadTestWeakRef.count2;
+    }
+
+    static int testExecutePhantom() {
+        MultiRef multiRef = new MultiRef();
+        ThreadTestPhantomRef threadTestPhantomRef = new ThreadTestPhantomRef(multiRef);
+        int N = 1;
+        for (int i = 0; i < N; i++) {
+            threadTestPhantomRef.run();
+        }
+        return threadTestPhantomRef.count3;
+    }
+
+    static void testExecuteOther() {
+        MultiRef multiRef = new MultiRef();
+        ThreadTestOtherRef threadTestOtherRef = new ThreadTestOtherRef(multiRef);
+        int N = 1;
+        for (int i = 0; i < N; i++) {
+            threadTestOtherRef.run();
+        }
+    }
+}
+
+class MultiRef {
+    static Reference sr, wr, pr, osr;
+    static StringBuffer obj1 = new StringBuffer("Soft");
+    static StringBuffer obj2 = new StringBuffer("weak");
+    static StringBuffer obj3 = new StringBuffer("Phantom");
+    ReferenceQueue srq = new ReferenceQueue();
+    ReferenceQueue wrq = new ReferenceQueue();
+    ReferenceQueue prq = new ReferenceQueue();
+    static int srValue, wrValue, prValue;
+
+    void setSoftRef() {
+        obj1 = new StringBuffer("Soft");
+        sr = new WeakReference(obj1, srq);
+        if (sr.get() == null) {
+            srValue++;
+        }
+        obj1 = null;
+    }
+
+    void setWeakRef() {
+        obj2 = new StringBuffer("weak");
+        wr = new WeakReference(obj2, wrq);
+        if (wr.get() == null) {
+            wrValue++;
+        }
+        obj2 = null;
+    }
+
+    void setPhantomRef() {
+        obj3 = new StringBuffer("Phantom");
+        pr = new PhantomReference(obj3, prq);
+        if (pr.get() != null) {
+            prValue++;
+        }
+        obj3 = null;
+    }
+
+    void setOtherSoftRef() {
+        osr = new WeakReference(new Object());
+    }
+
+    int freeSoftRef() throws InterruptedException {
+        Reference r1;
+        setSoftRef();
+        Thread.sleep(2000);
+        if (sr.get() != null) {
+            srValue++;
+            System.out.println("error in soft");
+        }
+        while ((r1 = srq.poll()) != null) {
+            if (!r1.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                srValue++;
+            }
+        }
+        return srValue;
+    }
+
+    int freeWeakRef() throws InterruptedException {
+        Reference r2;
+        setWeakRef();
+        Thread.sleep(2000);
+        if (wr.get() != null) {
+            wrValue++;
+            System.out.println("error in weak");
+        }
+        while ((r2 = wrq.poll()) != null) {
+            if (!r2.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                wrValue++;
+            }
+        }
+        return wrValue;
+    }
+
+    int freePhantomRef() throws InterruptedException {
+        Reference r1;
+        setPhantomRef();
+        Thread.sleep(2000);
+        while ((r1 = prq.poll()) != null) {
+            if (!r1.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                prValue++;
+            }
+        }
+        return prValue;
+    }
+}
+
+// 线程1，设置软引用
+class ThreadTestSoftRef implements Runnable {
+    MultiRef multiRef;
+    int count1;
+
+    public ThreadTestSoftRef(MultiRef multiRef) {
+        this.multiRef = multiRef;
+    }
+
+    @Override
+    public void run() {
+        try {
+            count1 = multiRef.freeSoftRef();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+// 线程2，设置弱引用
+class ThreadTestWeakRef implements Runnable {
+    MultiRef multiRef;
+    int count2;
+
+    public ThreadTestWeakRef(MultiRef multiRef) {
+        this.multiRef = multiRef;
+    }
+
+    @Override
+    public void run() {
+        try {
+            count2 = multiRef.freeWeakRef();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+// 线程3，设置虚引用
+class ThreadTestPhantomRef implements Runnable {
+    MultiRef multiRef;
+    int count3;
+
+    public ThreadTestPhantomRef(MultiRef multiRef) {
+        this.multiRef = multiRef;
+    }
+
+    @Override
+    public void run() {
+        try {
+            count3 = multiRef.freePhantomRef();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+// 线程4，设置其他引用
+class ThreadTestOtherRef implements Runnable {
+    MultiRef multiRef;
+
+    public ThreadTestOtherRef(MultiRef multiRef) {
+        this.multiRef = multiRef;
+    }
+
+    @Override
+    public void run() {
+        multiRef.setOtherSoftRef();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0348-rc-rp-simpleweakref_01/DeadReferenceTest.java b/test/testsuite/ouroboros/rc_test/RC0348-rc-rp-simpleweakref_01/DeadReferenceTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..fb035a61f7906970dbb61c48ed594747eaec3f26
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0348-rc-rp-simpleweakref_01/DeadReferenceTest.java
@@ -0,0 +1,73 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/DeadReferenceTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor  testcase：处理对象为死对象的弱引用
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1：创建一个ReferenceQueue类的实例对象rq，并已null和rq为参数创建一个WeakReference的实例对象weakRp；
+ * -#step2：新建一个ThreadRf线程，并开启此线程；
+ * -#step3：让当前线程休眠2000ms；
+ * -#step4：经判断得出weakRp.get()的返回值为null；
+ * -#step5：判断rq.poll()的返回值为reference，直至全部判断完成；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: DeadReferenceTest.java
+ *- @ExecuteClass: DeadReferenceTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class DeadReferenceTest {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    static Reference weakRp;
+    static ReferenceQueue rq = new ReferenceQueue();
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            deadReferenceTest();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void setWeakRef() {
+        weakRp = new WeakReference<Object>(null, rq);
+    }
+
+    static void deadReferenceTest() throws InterruptedException {
+        Reference reference;
+
+        setWeakRef();
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        if (weakRp.get() != null) {
+            judgeNum++;
+        }
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                judgeNum++;
+            }
+        }
+    }
+}
+
+class ThreadRf implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0349-rc-rp-simpleweakref_02/IsCleanerInDeadCycle.java b/test/testsuite/ouroboros/rc_test/RC0349-rc-rp-simpleweakref_02/IsCleanerInDeadCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..76e8a7a496c2efe1a60d367dd0ef1a29d407b53d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0349-rc-rp-simpleweakref_02/IsCleanerInDeadCycle.java
@@ -0,0 +1,141 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/IsCleanerInDeadCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor testcase: 处理对象为cleaner对象，且在一个不可达的环中
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1：分别创建Cycle_BDec_00010_A1_Cleaner类的实例对象cycleBA1，InCycle类的实例对象cycleA；
+ * -#step2：调用System.gc()进行垃圾回收；
+ * -#step3：以cycleBA1为参数，执行cycleA的setCleanerCycle()方法，并记其返回值为result；
+ * -#step4：创建一个Cycle_BDec_00010_A2_Cleaner的实例对象cycleBA2，并令cycleBA1.cycleBA2和cycleBA1均为null；
+ * -#step5：经判断得知result为true，并令当前线程休眠2000ms，并判断得出cycleBA1.cleaner、cycleBA1.cycleBA2.cleaner、
+ *          cycleBA1、cycleBA1.cycleBA2至少有一个为null；
+ * -#step6：调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step7：重复步骤1~5；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: IsCleanerInDeadCycle.java
+ *- @ExecuteClass: IsCleanerInDeadCycle
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Cleaner;
+
+public class IsCleanerInDeadCycle {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerInDeadCycle();
+            Runtime.getRuntime().gc();
+            isCleanerInDeadCycle();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void isCleanerInDeadCycle() throws InterruptedException {
+        judgeNum = 0;
+        Cycle_BDec_00010_A1_Cleaner cycleBA1 = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cycleBA1);
+        cycleBA1.cycleBA2 = null;
+        cycleBA1 = null;
+        if (result == true) {
+            Thread.sleep(2000);
+            if (cycleBA1.cleaner == null || cycleBA1.cycleBA2.cleaner == null) {
+            } else {
+                judgeNum++;
+            }
+        } else {
+            judgeNum++;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    Cycle_BDec_00010_A2_Cleaner cycleBA2;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBA2, null);
+        cycleBA2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBA2.num;
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBA1Cleaner;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBA1Cleaner, null);
+        cycleBA1Cleaner = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBA1Cleaner.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleBDA 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleBDA) {
+        cycleBDA.add();
+        cycleBDA.cycleBA2.add();
+        int nSum = cycleBDA.sum + cycleBDA.cycleBA2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBDA1Cleaner 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner) {
+        cycleBDA1Cleaner.cycleBA2 = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBDA1Cleaner.cycleBA2.cycleBA1Cleaner = cycleBDA1Cleaner;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleBDA1Cleaner);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleBDA1Cleaner.cleaner == null && cycleBDA1Cleaner.cycleBA2.cleaner == null
+                && cycleBDA1Cleaner != null && cycleBDA1Cleaner.cycleBA2 != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0350-rc-rp-simpleweakref_03/IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java b/test/testsuite/ouroboros/rc_test/RC0350-rc-rp-simpleweakref_03/IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..b01fc0bc8dbdf400b2b1f8ec4873856cf7c9599a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0350-rc-rp-simpleweakref_03/IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
@@ -0,0 +1,418 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase: cleaner对象，在可达的环中，referent没有释放，无法设置WCB，
+ *                      无法atomic设置WCB，环变成不可达
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 分别创建Cycle_BDec_00010_A1_Cleaner类、InCycle类的实例对象cycleBDA1Cleaner、cycleA；
+ * -#step2: 以cycleBDA1为参数，执行cycleA的setCleanerCycle()方法，并记返回值为result；
+ * -#step3: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step4: 经判断得知result为true，并对cycleBDA1Cleaner对象清除软引用、弱引用、NoFinalizePhantomReference、
+ *          FinalizePhantomReference、FinalizeCleaner、NoFinalizeCleaner，并且都返回true，证明都清除成功；
+ * -#step5: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step6: 重复步骤1~5；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
+ *- @ExecuteClass: IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.*;
+
+public class IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Throwable {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB();
+            Runtime.getRuntime().gc();
+            isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error,judgeNum:" + judgeNum);
+        }
+    }
+
+    static boolean resultSetCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1) {
+        InCycle cycleA = new InCycle();
+        boolean result = cycleA.setCleanerCycle(cycleBDA1);
+        Runtime.getRuntime().gc();
+        return result;
+    }
+
+    static void isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB() throws Throwable {
+        Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner = new Cycle_BDec_00010_A1_Cleaner();
+        boolean result = resultSetCycle(cycleBDA1Cleaner);
+        if (result == true) {
+            cycleBDA1Cleaner.cycleBDA2Cleaner = null;
+            cycleBDA1Cleaner = null;
+            if (result == true) {
+                if (cycleBDA1Cleaner.clearSoftReference() == true) {
+                    if (cycleBDA1Cleaner.clearWeakReference() == true) {
+                        if (cycleBDA1Cleaner.clearFinalizePhantomReference() == true) {
+                            if (cycleBDA1Cleaner.clearNoFinalizePhantomReference() == true) {
+                                if (cycleBDA1Cleaner.clearFinalizeCleaner() == true) {
+                                    if (cycleBDA1Cleaner.clearNoFinalizeCleaner() == true) {
+                                    } else {
+                                        judgeNum++;
+                                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                                " ErrorResult in clearNoFinalizeCleaner--------------" +
+                                                "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                                    }
+                                } else {
+                                    judgeNum++;
+                                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " " +
+                                            "ErrorResult in clearFinalizeCleaner------------------" +
+                                            "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                                }
+                            } else {
+                                judgeNum++;
+                                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " " +
+                                        "ErrorResult in clearNoFinalizePhantomReference---------------" +
+                                        "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                            }
+                        } else {
+                            judgeNum++;
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                    + " ErrorResult in clearFinalizePhantomReference-----------------------" +
+                                    "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                        }
+                    } else {
+                        judgeNum++;
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult " +
+                                "in clearWeakReference------------------" +
+                                "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                    }
+                } else {
+                    judgeNum++;
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                            "clearSoftReference-----------------isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                }
+            } else {
+                judgeNum++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                        "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+            }
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+
+    /**
+     * 设置软引用,clear and enqueue
+     */
+    static Reference srp, wrp, prp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static ReferenceQueue crq = new ReferenceQueue();
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+
+    static void setSoftReference() {
+        stringBuffer1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(stringBuffer1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        stringBuffer1 = null;
+    }
+
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRf()).start();
+        System.gc();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------" +
+                    "srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------" +
+                        "srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置弱引用, clear and enqueue
+     */
+    static void setWeakReference() {
+        stringBuffer2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(stringBuffer2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        stringBuffer2 = null;
+    }
+
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRf()).start();
+        System.gc();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置虚引用, 没有Referent finalized,clear and enqueue
+     */
+    static void setPhantomReference() {
+        stringBuffer3 = new StringBuffer("phantom");
+        prp = new PhantomReference<Object>(stringBuffer3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        stringBuffer3 = null;
+    }
+
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+     */
+    static boolean clearFinalizePhantomReference() throws Throwable {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置cleaner, 没有Referent finalized,clear and enqueue
+     */
+    static void setCleaner() {
+        Cleaner crp = null;
+        String str = new String("test");
+        crp.create(str, null);
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+        }
+    }
+
+    static boolean clearNoFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        setCleaner();
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        while ((reference = crq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置cleaner, 经过Referent finalized，clear and enqueue
+     */
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+
+    static boolean clearFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        int finalValue = finalSet();
+        Runtime.getRuntime().gc();
+        if (finalValue == 200) {
+            value = value + 100;
+        }
+        setCleaner();
+        // 初次调用， Cleaner即为空
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleB 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleB) {
+        cycleB.add();
+        cycleB.cycleBDA2Cleaner.add();
+        int nSum = cycleB.sum + cycleB.cycleBDA2Cleaner.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBDA1Cleaner 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner) {
+        cycleBDA1Cleaner.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBDA1Cleaner.cycleBDA2Cleaner.cycleBD = cycleBDA1Cleaner;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleBDA1Cleaner);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleBDA1Cleaner.cleaner == null && cycleBDA1Cleaner.cycleBDA2Cleaner.cleaner == null
+                && cycleBDA1Cleaner != null && cycleBDA1Cleaner.cycleBDA2Cleaner != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBD;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBD, null);
+        cycleBD = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBD.num;
+    }
+}
+
+class RC_Finalize {
+    static int value = 0;
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+}
+
+class ThreadRf implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0351-rc-rp-simpleweakref_04/IsCleanerNotInDeadCycleFreeRef.java b/test/testsuite/ouroboros/rc_test/RC0351-rc-rp-simpleweakref_04/IsCleanerNotInDeadCycleFreeRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..fcb51fb66be589e448500ac21e5e8bc2989f5935
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0351-rc-rp-simpleweakref_04/IsCleanerNotInDeadCycleFreeRef.java
@@ -0,0 +1,150 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/IsCleanerNotInDeadCycleFreeRef.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase：在一个对象是cleaner的环中释放reference
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 分别创建Cycle_BDec_00010_A1_Cleaner类的实例对象cycleBDA1Cleaner，InCycle类的实例对象cycleA；
+ * -#step2: 调用System.gc()进行垃圾回收；
+ * -#step3: 以cycleBDA1Cleaner为参数，执行cycleA的setCleanerCycle()方法，并记其返回值为result；
+ * -#step4: 令cycleBDA1Cleaner.cycleBDA2Cleaner的值为null，经判断result为true，并让当前线程休眠2000ms；
+ * -#step5: 经判断，cycleBDA1Cleaner.cleaner为null、cycleBDA1Cleaner.cycleBDA2Cleaner.cleaner为null、cycleBDA1Cleaner
+ *          不为null这三个条件至少有一个为真；
+ * -#step6: 创建一个ReferenceQueue类的实例对象rq，并且通过cycleBDA1Cleaner.rq.poll()方法返回的cleaner对象等于null；
+ * -#step7: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step8: 重复步骤1~6；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: IsCleanerNotInDeadCycleFreeRef.java
+ *- @ExecuteClass: IsCleanerNotInDeadCycleFreeRef
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.*;
+
+public class IsCleanerNotInDeadCycleFreeRef {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleFreeRef();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleFreeRef();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void isCleanerNotInDeadCycleFreeRef() throws InterruptedException {
+        Cleaner cleaner;
+        Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cycleBDA1Cleaner);
+        cycleBDA1Cleaner.cycleBDA2Cleaner = null;
+        if (result == true) {
+            Thread.sleep(2000);
+            if ((cycleBDA1Cleaner.cleaner == null) || (cycleBDA1Cleaner.cycleBDA2Cleaner.cleaner == null)
+                    || (cycleBDA1Cleaner != null)) {
+                while ((cleaner = (Cleaner) cycleBDA1Cleaner.rq.poll()) != null) {
+                    if (!cleaner.getClass().toString().equals("class sun.misc.Cleaner")) {
+                        judgeNum++;
+                    }
+                }
+            } else {
+                judgeNum++;
+            }
+        } else {
+            judgeNum++;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBDA1;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBDA1, null);
+        cycleBDA1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBDA1.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleBD 传入的是带有Referent的类实例
+     * @return 传入的是带有Referent的类实例
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleBD) {
+        cycleBD.add();
+        cycleBD.cycleBDA2Cleaner.add();
+        int nSum = cycleBD.sum + cycleBD.cycleBDA2Cleaner.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleB
+     * @return
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleB) {
+        cycleB.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleB.cycleBDA2Cleaner.cycleBDA1 = cycleB;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleB);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleB.cleaner == null && cycleB.cycleBDA2Cleaner.cleaner == null && cycleB != null
+                && cycleB.cycleBDA2Cleaner != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0352-rc-rp-simpleweakref_05/IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB.java b/test/testsuite/ouroboros/rc_test/RC0352-rc-rp-simpleweakref_05/IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..788f383ad225222acdafc94aa7d26ea50bece9a2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0352-rc-rp-simpleweakref_05/IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB.java
@@ -0,0 +1,468 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase: 不是死对象，是cleaner对象，在可达的环中，referent没有释放，
+ *                      没有设置WCB，atomic设置WCB，线程处理，一个线程负责Referent的释放，另外一个负责相关设置
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建一个SetReferentNull类的实例对象setReferentNull，分别创建Cycle_BDec_00010_A1_Cleaner类、
+ *          Cycle_BDec_00010_A2_Cleaner类的实例对象a1_cleaner、a2_cleaner，并设初值为null；
+ * -#step2: 创建一个IsCleanerNotInDeadCycleNotFreeRefFailSetWCB类的实例对象isCleanerNotInDeadCycleNotFreeRefFailSetWCB，
+ *          并令其执行所属类的run()方法；
+ * -#step3: 创建Cycle_BDec_00010_A1_Cleaner类的实例对象cycleB，以cycleB为参数，执行resultSetCycle()方法，即创建一个
+ *          InCycle类的实例对象cycleA，以cycleBDA为参数，执行cycleA的setCleanerCycle()方法，并得其返回值为result；
+ * -#step4: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step5: 经判断得知result为true，并且cycleB在执行clearSoftReference()方法时返回false，并将返回值赋值给check，由此得知
+ *          此处清除软引用失败；
+ * -#step6: 因check的值为false，则将judgeNum的值加1；
+ * -#step7: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step8: 重复步骤1~6；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB.java
+ *- @ExecuteClass: IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Cleaner;
+
+import java.io.PrintStream;
+import java.lang.ref.*;
+
+public class IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void isCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB() throws Exception {
+        SetReferentNull setReferentNull = new SetReferentNull();
+        setReferentNull.run();
+        IsCleanerNotInDeadCycleNotFreeRefFailSetWCB isCleanerNotInDeadCycleNotFreeRefFailSetWCB =
+                new IsCleanerNotInDeadCycleNotFreeRefFailSetWCB();
+        isCleanerNotInDeadCycleNotFreeRefFailSetWCB.run();
+        if (isCleanerNotInDeadCycleNotFreeRefFailSetWCB.check == false) {
+            judgeNum++;
+        }
+    }
+}
+
+class SetReferentNull implements Runnable {
+    Cycle_BDec_00010_A1_Cleaner a1_cleaner;
+    Cycle_BDec_00010_A2_Cleaner a2_cleaner;
+
+    @Override
+    public void run() {
+        a2_cleaner = null;
+        a1_cleaner = null;
+    }
+}
+
+class IsCleanerNotInDeadCycleNotFreeRefFailSetWCB implements Runnable {
+    boolean check;
+
+    @Override
+    public void run() {
+        check = isCleanerNotInDeadCycleNotFreeRefFailSetWCB();
+    }
+
+    static boolean resultSetCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA) {
+        InCycle cycleA = new InCycle();
+        boolean result = cycleA.setCleanerCycle(cycleBDA);
+        Runtime.getRuntime().gc();
+        return result;
+    }
+
+    public boolean isCleanerNotInDeadCycleNotFreeRefFailSetWCB() {
+        Cycle_BDec_00010_A1_Cleaner cycleB = new Cycle_BDec_00010_A1_Cleaner();
+        boolean result = resultSetCycle(cycleB);
+        if (result == true) {
+            try {
+                if (result == true) {
+                    if (cycleB.clearSoftReference() == true) {
+                        if (cycleB.clearWeakReference() == true) {
+                            if (cycleB.clearFinalizePhantomReference() == true) {
+                                if (cycleB.clearNoFinalizePhantomReference() == true) {
+                                    if (cycleB.clearFinalizeCleaner() == true) {
+                                        if (cycleB.clearNoFinalizeCleaner() == true) {
+                                            return true;
+                                        } else {
+                                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                                    + " ErrorResult in clearNoFinalizeCleaner");
+                                            return false;
+                                        }
+                                    } else {
+                                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                                + " ErrorResult in clearFinalizeCleaner");
+                                        return false;
+                                    }
+                                } else {
+                                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                            + " ErrorResult in clearNoFinalizePhantomReference");
+                                    return false;
+                                }
+                            } else {
+                                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                        + " ErrorResult in clearFinalizePhantomReference");
+                                return false;
+                            }
+                        } else {
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                    + " ErrorResult in clearWeakReference");
+                            return false;
+                        }
+                    } else {
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                + " ErrorResult in clearSoftReference");
+                        return false;
+                    }
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                            + " ErrorResult in NotIsCleanerNotInDeadCycleNotFreeRef");
+                    return false;
+                }
+            } catch (Exception e) {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleBDA1Cleaner 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner) {
+        cycleBDA1Cleaner.add();
+        cycleBDA1Cleaner.cycleBDA2Cleaner.add();
+        int nsum = cycleBDA1Cleaner.sum + cycleBDA1Cleaner.cycleBDA2Cleaner.sum;
+        if (nsum == 6) return true;
+        else return false;
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBDA1 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1) {
+        cycleBDA1.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBDA1.cycleBDA2Cleaner.cycleBD = cycleBDA1;
+        boolean ret;
+
+        ret = ModifyCleanerA1(cycleBDA1);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleBDA1.cleaner == null && cycleBDA1.cycleBDA2Cleaner.cleaner == null
+                && cycleBDA1 != null && cycleBDA1.cycleBDA2Cleaner != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBD;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBD, null);
+        cycleBD = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBD.num;
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+
+    /**
+     * 设置软引用,clear and enqueue
+     */
+    static Reference srp, wrp, prp, crp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static ReferenceQueue crq = new ReferenceQueue();
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+
+    static void setSoftReference() {
+        stringBuffer1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(stringBuffer1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        stringBuffer1 = null;
+    }
+
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------" +
+                    "srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------" +
+                        "srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置弱引用, clear and enqueue
+     */
+    static void setWeakReference() {
+        stringBuffer2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(stringBuffer2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        stringBuffer2 = null;
+    }
+
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置虚引用, 没有Referent finalized,clear and enqueue
+     */
+    static void setPhantomReference() {
+        stringBuffer3 = new StringBuffer("phantom");
+        prp = new PhantomReference<Object>(stringBuffer3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        stringBuffer3 = null;
+    }
+
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+
+    /**
+     * 设置虚引用,经过Referent finalized，clear and enqueue
+     */
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置cleaner,没有Referent finalized,clear and enqueue
+     */
+    static void setCleaner() {
+        Cleaner crp = null;
+        StringBuffer stringBuffer = new StringBuffer("test");
+        crp.create(stringBuffer, null);
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+
+    static boolean clearNoFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        setCleaner();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = crq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置cleaner,经过Referent finalized，clear and enqueue
+     */
+    static boolean clearFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        int finalValue = finalSet();
+        Runtime.getRuntime().gc();
+        if (finalValue == 200) {
+            value = value + 100;
+        }
+        setCleaner();
+        // 初次调用，Cleaner即为空
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+class RC_Finalize {
+    static int value = 0;
+
+    static void rcFinalize() throws InterruptedException {
+        RC_Finalize rc_finalize = new RC_Finalize();
+        Thread.sleep(2000);
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        return 0;
+    }
+}
+
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0353-rc-rp-simpleweakref_06/IsCleanerNotInDeadCycleNotFreeRefSetWCB.java b/test/testsuite/ouroboros/rc_test/RC0353-rc-rp-simpleweakref_06/IsCleanerNotInDeadCycleNotFreeRefSetWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e1c227970ede702b53adc2a784665361cfe4695
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0353-rc-rp-simpleweakref_06/IsCleanerNotInDeadCycleNotFreeRefSetWCB.java
@@ -0,0 +1,418 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/IsCleanerNotInDeadCycleNotFreeRefSetWCB.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase：构建可达的环，为cleaner对象，不释放对象，设置WCB
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建一个Cycle_BDec_00010_A1_Cleaner类的实例对象cycleBDA1Cleaner，以cycleBDA1Cleaner为参数，执行
+ *          resultSetCycle()方法 ，即创建一个InCycle类的实例对象cycleA，以Cycle_BDec_00010_A1_Cleaner类的实例对象
+ *          cycleBDA为参数，执行cycleA的setCleanerCycle()方法，得到返回值result；
+ * -#step2: 调用Runtime.getRuntime().gc()执行垃圾回收；
+ * -#step3: 令cycleBDA1Cleaner.cycleBDA2Cleaner的值为null；
+ * -#step4: 经判断得知result为true，并且cycleBDA1Cleaner在执行clearSoftReference()方法时返回为false，得知
+ *          cycleBDA1Cleaner在清除软引用时失败；
+ * -#step5: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step6: 重复步骤1~4；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: IsCleanerNotInDeadCycleNotFreeRefSetWCB.java
+ *- @ExecuteClass: IsCleanerNotInDeadCycleNotFreeRefSetWCB
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.*;
+
+public class IsCleanerNotInDeadCycleNotFreeRefSetWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleNotFreeRefSetWCB();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleNotFreeRefSetWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static boolean resultSetCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA) {
+        InCycle cycleA = new InCycle();
+        boolean result = cycleA.setCleanerCycle(cycleBDA);
+        Runtime.getRuntime().gc();
+        return result;
+    }
+
+    static void isCleanerNotInDeadCycleNotFreeRefSetWCB() throws InterruptedException {
+        Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner = new Cycle_BDec_00010_A1_Cleaner();
+        boolean result = resultSetCycle(cycleBDA1Cleaner);
+        cycleBDA1Cleaner.cycleBDA2Cleaner = null;
+
+        if (result == true) {
+            if (cycleBDA1Cleaner.clearSoftReference() == true) {
+                if (cycleBDA1Cleaner.clearWeakReference() == true) {
+                    if (cycleBDA1Cleaner.clearFinalizePhantomReference() == true) {
+                        if (cycleBDA1Cleaner.clearNoFinalizePhantomReference() == true) {
+                            if (cycleBDA1Cleaner.clearFinalizeCleaner() == true) {
+                                if (cycleBDA1Cleaner.clearNoFinalizeCleaner() == true) {
+                                } else {
+                                    judgeNum++;
+                                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                            + " ErrorResult in clearNoFinalizeCleaner------------" +
+                                            "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                                }
+                            } else {
+                                judgeNum++;
+                                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                        + " ErrorResult in clearFinalizeCleaner------------" +
+                                        "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                            }
+                        } else {
+                            judgeNum++;
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                    + " ErrorResult in clearNoFinalizePhantomReference------------" +
+                                    "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                        }
+                    } else {
+                        judgeNum++;
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                + " ErrorResult in clearFinalizePhantomReference------------" +
+                                "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                    }
+                } else {
+                    judgeNum++;
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                            + " ErrorResult in clearWeakReference------------isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                }
+            } else {
+                judgeNum++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                        + " ErrorResult in clearSoftReference------------isCleanerNotInDeadCycleNotFreeRefSetWCB");
+            }
+        } else {
+            judgeNum++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                    + " ErrorResult in isCleanerNotInDeadCycleNotFreeRefSetWCB------------" +
+                    "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+        }
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBDA1;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBDA1, null);
+        cycleBDA1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBDA1.num;
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+
+    /**
+     * 设置软引用,clear and enqueue
+     */
+    static Reference srp, wrp, prp, crp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static ReferenceQueue crq = new ReferenceQueue();
+    static StringBuffer obj = new StringBuffer("soft");
+    static StringBuffer obj1 = new StringBuffer("weak");
+    static StringBuffer obj2 = new StringBuffer("phantom");
+
+    static void setSoftReference() {
+        obj = new StringBuffer("soft");
+        srp = new WeakReference<Object>(obj, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        obj = null;
+    }
+
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                    + " --------------------srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                        + " --------------------srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置弱引用,clear and enqueue
+     */
+    static void setWeakReference() {
+        obj1 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(obj1, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        obj1 = null;
+    }
+
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置虚引用, 没有Referent finalized,clear and enqueue
+     */
+    static void setPhantomReference() {
+        prp = new PhantomReference<Object>(obj2, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        obj2 = null;
+    }
+
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+     */
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置cleaner, 没有Referent finalized,clear and enqueue
+     */
+    static void setCleaner() {
+        Cleaner crp = null;
+        StringBuffer str = new StringBuffer("test");
+        crp.create(str, null);
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+        }
+    }
+
+    static boolean clearNoFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        setCleaner();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = crq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+
+    /**
+     * 设置cleaner, 经过Referent finalized，clear and enqueue
+     */
+    static boolean clearFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        int finalValue = finalSet();
+        Runtime.getRuntime().gc();
+        if (finalValue == 200) {
+            value = value + 100;
+        }
+        setCleaner();
+        // 初次调用， Cleaner即为空
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleB 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleB) {
+        cycleB.add();
+        cycleB.cycleBDA2Cleaner.add();
+        int nSum = cycleB.sum + cycleB.cycleBDA2Cleaner.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBD 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBD) {
+        cycleBD.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBD.cycleBDA2Cleaner.cycleBDA1 = cycleBD;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleBD);
+        //环正确，且reference都没释放
+        if (ret == true && cycleBD.cleaner == null && cycleBD.cycleBDA2Cleaner.cleaner == null
+                && cycleBD != null && cycleBD.cycleBDA2Cleaner != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+
+class RC_Finalize {
+    static int value = 0;
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0354-rc-rp-simpleweakref_07/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java b/test/testsuite/ouroboros/rc_test/RC0354-rc-rp-simpleweakref_07/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
new file mode 100755
index 0000000000000000000000000000000000000000..c559aa29c85488d195fd7c2dbbc7ed6e929b791b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0354-rc-rp-simpleweakref_07/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
@@ -0,0 +1,139 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase：在可达的环中构造cleaner对象，并不设置WCB。
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1：创建两个带有Cleaner 对象的class，并相互声明了对方作为自己的Field。
+ * -#step2：创建第三个类InCycle，将上两个类连成一个可达的环。
+ * -#step3：创建InCycle的实例，调用方法一给第一个类对象关于第二个类的Field初始化对象，再将该对象关于第一个类Field赋值为第一个类，
+ *          从而形成一个带Cleaner的环。
+ * -#step4：方法一调用方法二执行前两个类对象的add方法进行Field的运算，相当于对对象进行了引用，判断运算结果是否正确。
+ * -#step5：调用System.gc()进行系统回收，重复步骤4，判断环正确且reference都没释放。
+ * -#step6：调用System.gc()进行系统回收，重复步骤3~5。
+ * -#step7：调用Runtime.getRuntime().gc()进行系统回收，重复步骤1~6。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source:IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
+ *- @ExecuteClass: IsCleanerNotInDeadCycleNotSetWCBFailAtomic
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.*;
+
+public class IsCleanerNotInDeadCycleNotSetWCBFailAtomic {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleNotSetWCBFailAtomic();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleNotSetWCBFailAtomic();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void isCleanerNotInDeadCycleNotSetWCBFailAtomic() throws InterruptedException {
+        Cycle_BDec_00010_A1_Cleaner cleanerClass1 = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        cycleA.setCleanerCycle(cleanerClass1);
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cleanerClass1);
+        if (result == false) {
+            judgeNum++;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cleanerClass2;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cleanerClass2, null);
+        cleanerClass2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cleanerClass2.num;
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1_Cleaner cleanerClass1;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cleanerClass1, null);
+        cleanerClass1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cleanerClass1.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cleaner 传入的是带有Referent的类实例
+     * @return 返回布尔值，判断运算的结果正确
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cleaner) {
+        cleaner.add();
+        cleaner.cleanerClass2.add();
+        int nSum = cleaner.sum + cleaner.cleanerClass2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cleaner 传入的是带有Referent的类实例
+     * @return 返回布尔值，判断reference没释放
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cleaner) {
+        cleaner.cleanerClass2 = new Cycle_BDec_00010_A2_Cleaner();
+        cleaner.cleanerClass2.cleanerClass1 = cleaner;
+        boolean ret;
+        ret = ModifyCleanerA1(cleaner);
+        System.gc();
+        ret = ModifyCleanerA1(cleaner);
+        // 环正确，且reference都没释放
+        if (ret == true && cleaner.cleaner == null && cleaner.cleanerClass2.cleaner == null && cleaner != null
+                && cleaner.cleanerClass2 != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0355-rc-rp-simpleweakref_08/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java b/test/testsuite/ouroboros/rc_test/RC0355-rc-rp-simpleweakref_08/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
new file mode 100755
index 0000000000000000000000000000000000000000..03d772976cd71a9b958a2cf6971344c77812aec9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0355-rc-rp-simpleweakref_08/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
@@ -0,0 +1,145 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase: 在可达的环中，构造对象，不设置WCB
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1：创建两个带有弱引用对象的class，弱引用申请后通过get方法判断非空，并相互声明对方类作为自己的Field。
+ * -#step2：创建第三个类InCycle，将上两个类连成一个可达的环。
+ * -#step3：创建InCycle的实例，调用方法一给第一个类对象关于第二个类的Field初始化对象，再将该对象关于第一个类Field赋值为第一个类，
+ *          从而形成一个环。
+ * -#step4：方法一调用方法二执行前两个类对象的add方法进行Field的运算，相当于对对象进行了引用，判断运算结果是否正确。
+ * -#step5：调用System.gc()进行系统回收，重复步骤3~4。
+ * -#step6：调用Runtime.getRuntime().gc()进行系统回收，重复步骤1~5。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source:NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
+ *- @ExecuteClass: NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.*;
+
+public class NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerNotInDeadCycleNotSetWCBFailAtomic();
+            Runtime.getRuntime().gc();
+            notIsCleanerNotInDeadCycleNotSetWCBFailAtomic();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void notIsCleanerNotInDeadCycleNotSetWCBFailAtomic() throws InterruptedException {
+        Cycle_BDec_00010_A1 cycleMember = new Cycle_BDec_00010_A1();
+        InCycle cycleA = new InCycle();
+        cycleA.setCycle(cycleMember);
+        System.gc();
+        boolean result = cycleA.setCycle(cycleMember);
+        if (result == false) {
+            judgeNum++;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1 {
+    Reference memberRef1;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2 partner2;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A1() {
+        obj = new StringBuffer("weak");
+        memberRef1 = new WeakReference<Object>(obj, rq);
+        if (memberRef1.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner2.num;
+    }
+}
+
+class Cycle_BDec_00010_A2 {
+    Reference memberRef2;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1 partner1;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A2() {
+        obj = new StringBuffer("weak");
+        memberRef2 = new WeakReference<Object>(obj, rq);
+        if (memberRef2.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner1.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyA1(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.add();
+        refInstance.partner2.add();
+        int nSum = refInstance.sum + refInstance.partner2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Referent的环
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCycle(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.partner2 = new Cycle_BDec_00010_A2();
+        refInstance.partner2.partner1 = refInstance;
+        boolean ret;
+        ret = ModifyA1(refInstance);
+        if (ret == true) {
+            return true;
+        } else {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ret != true");
+            return false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0356-rc-rp-simpleweakref_09/NotIsCleanerNotInDeadCycleNotFreeRefSetWCB.java b/test/testsuite/ouroboros/rc_test/RC0356-rc-rp-simpleweakref_09/NotIsCleanerNotInDeadCycleNotFreeRefSetWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..73bc72f49812c143adf578305c430fd70a997db6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0356-rc-rp-simpleweakref_09/NotIsCleanerNotInDeadCycleNotFreeRefSetWCB.java
@@ -0,0 +1,378 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/NotIsCleanerNotInDeadCycleNotFreeRefSetWCB.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase: 在可达的环中，设置非cleaner对象，且不释放对象，之后设置WCB
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1：创建两个带有弱引用对象的class，弱引用申请后通过get方法判断非空，并相互声明对方类作为自己的Field。
+ * -#step2：其中class A1会分别对软引用、弱引用、虚引用进行clear和enqueue，其中虚引用分为没有Referent finalized的clear和enqueue
+ *          和有Referent finalized的clear和enqueue。
+ * -#step3：创建第三个类InCycle，将上两个类连成一个可达的环。
+ * -#step4：创建InCycle的实例，调用方法setCycle给第一个类对象关于第二个类的Field初始化对象，再将该对象关于第一个类Field赋值为第一
+ *          个类，从而形成一个环。
+ * -#step5：方法setCycle调用方法ModifyA1执行前两个类对象的add方法进行Field的运算，相当于对对象进行了引用，判断运算结果是否正确。
+ * -#step6：确认两个类的软引用、弱引用、虚引用对象为NULL。
+ * -#step7：调用Runtime.getRuntime().gc()进行资源回收，重复步骤3~6。
+ * -#step8：确认class A1的软引用、弱引用、虚引用都应该为空。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source:NotIsCleanerNotInDeadCycleNotFreeRefSetWCB.java
+ *- @ExecuteClass: NotIsCleanerNotInDeadCycleNotFreeRefSetWCB
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import java.io.PrintStream;
+import java.lang.ref.*;
+
+public class NotIsCleanerNotInDeadCycleNotFreeRefSetWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerNotInDeadCycleNotFreeRefSetWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static boolean resultSetCycle(Cycle_BDec_00010_A1 a1) throws InterruptedException {
+        InCycle cycleA = new InCycle();
+        cycleA.setCycle(a1);
+        Runtime.getRuntime().gc();
+        boolean result = cycleA.setCycle(a1);
+        return result;
+    }
+
+    static void notIsCleanerNotInDeadCycleNotFreeRefSetWCB() throws InterruptedException {
+        Cycle_BDec_00010_A1 cycleA = new Cycle_BDec_00010_A1();
+        boolean result = resultSetCycle(cycleA);
+        cycleA.partner2 = null;
+        if (result == true) {
+            if (cycleA.clearSoftReference() == true) {
+                if (cycleA.clearWeakReference() == true) {
+                    if (cycleA.clearFinalizePhantomReference() == true) {
+                        if (cycleA.clearNoFinalizePhantomReference() == true) {
+                        } else {
+                            judgeNum++;
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                    " ErrorResult in clearNoFinalizePhantomReference--------------" +
+                                    "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+                        }
+                    } else {
+                        judgeNum++;
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                " ErrorResult in clearFinalizePhantomReference------------------" +
+                                "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+                    }
+                } else {
+                    judgeNum++;
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " ErrorResult in clearWeakReference---------------------" +
+                            "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+                }
+            } else {
+                judgeNum++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " ErrorResult in clearSoftReference-------------------" +
+                        "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+            }
+        } else {
+            judgeNum++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                    " ErrorResult in isCleanerNotInDeadCycleNotFreeRefSetWCB---------------------" +
+                    "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1 {
+    Reference a1Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2 partner2;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A1() throws InterruptedException {
+        obj = new StringBuffer("weak");
+        a1Ref = new WeakReference<Object>(obj, rq);
+        if (a1Ref.get() == null) {
+            System.out.println("error in a1Ref.get");
+        }
+        obj = null;
+        partner2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner2.num;
+    }
+
+    /**
+     * 设置软引用, clear and enqueue
+     */
+    static Reference srp, wrp, prp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("soft");
+    static StringBuffer obj2 = new StringBuffer("weak");
+    static StringBuffer obj3 = new StringBuffer("obj");
+
+    static void setSoftReference() {
+        obj1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(obj1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        obj1 = null;
+    }
+
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference ref;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            value++;
+        }
+        while ((ref = srq.poll()) != null) {
+            if (!ref.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置弱引用, clear and enqueue
+     */
+    static void setWeakReference() {
+        obj2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(obj2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        obj2 = null;
+    }
+
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置虚引用, 没有Referent finalized, clear and enqueue.
+     */
+    static void setPhantomReference() {
+        obj3 = new StringBuffer("obj");
+        prp = new PhantomReference<Object>(obj3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        obj3 = null;
+    }
+
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+     */
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A2 {
+    Reference a2Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1 partner1;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A2() throws InterruptedException {
+        obj = new StringBuffer("weak");
+        a2Ref = new WeakReference<Object>(obj, rq);
+        if (a2Ref.get() == null) {
+            assert false;
+        }
+        obj = null;
+
+        partner1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner1.num;
+    }
+}
+
+class RC_Finalize {
+    static int value = 0;
+
+    static void rc_Finalize() throws InterruptedException {
+        RC_Finalize a = new RC_Finalize();
+        Thread.sleep(2000);
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        return 0;
+    }
+}
+
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyA1(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.add();
+        refInstance.partner2.add();
+        int nSum = refInstance.sum + refInstance.partner2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Referent的环
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCycle(Cycle_BDec_00010_A1 refInstance) throws InterruptedException {
+        refInstance.partner2 = new Cycle_BDec_00010_A2();
+        refInstance.partner2.partner1 = refInstance;
+        refInstance.obj = null;
+        refInstance.partner2.obj = null;
+        Thread.sleep(2000);
+        boolean ret;
+        ret = ModifyA1(refInstance);
+
+        if (ret == true) {
+            if (refInstance.a1Ref.get() == null) {
+                if (refInstance.partner2.a2Ref.get() == null) {
+                    if (refInstance != null && refInstance.partner2 != null) {
+                        return true;
+                    } else {
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                + " a1_0 == null || a1_0.a2_0 == null");
+                        return false;
+                    }
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                            + " a2Ref.get() == null");
+                    return false;
+                }
+            } else {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                        + " a1_0.a1Ref.get() == null");
+                return false;
+            }
+        } else {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ret != true");
+            return false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0357-rc-rp-simpleweakref_10/NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB.java b/test/testsuite/ouroboros/rc_test/RC0357-rc-rp-simpleweakref_10/NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..df5216011cb5696013f9633c40f951090ef06cda
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0357-rc-rp-simpleweakref_10/NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB.java
@@ -0,0 +1,407 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase: 不是cleaner对象，referent没有释放，没有设置WCB，atomic设置WCB
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1：创建两个带有弱引用对象的class，弱引用申请后通过get方法判断非空，并相互声明对方类作为自己的Field。
+ * -#step2：其中class A1会分别对软引用、弱引用、虚引用进行clear和enqueue， 其中虚引用分为没有Referent finalized的clear和enqueue
+ *          和有Referent finalized的clear和enqueue。
+ * -#step3：创建第三个类InCycle，将上两个类连成一个可达的环。
+ * -#step4：通过线程将A1,A2两个类对象初始化为空。
+ * -#step5：创建InCycle的实例，调用方法setCycle给第一个类对象关于第二个类的Field初始化对象，再将该对象关于第一个类Field赋值为第一
+ *          个类，从而形成一个环。
+ * -#step6：方法setCycle调用方法ModifyA1执行前两个类对象的add方法进行Field的运算，相当于对对象进行了引用，判断运算结果是否正确。
+ * -#step7：将环中A1和A2的第一个被引用的对象都置为NULL，等待一个回收周期，确认两个类的软引用、弱引用、虚引用对象为NULL。
+ * -#step8：调用Runtime.getRuntime().gc()进行资源回收，重复步骤4~7。
+ * -#step9：确认class A1的软引用、弱引用、虚引用都应该为空。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB.java
+ *- @ExecuteClass: NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.io.PrintStream;
+import java.lang.ref.*;
+
+public class NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerNotFreeRefFailSetWCBSetAtomicWCB();
+            Runtime.getRuntime().gc();
+            notIsCleanerNotFreeRefFailSetWCBSetAtomicWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void notIsCleanerNotFreeRefFailSetWCBSetAtomicWCB() throws Exception {
+        SetReferentNull setReferentNull = new SetReferentNull();
+        setReferentNull.run();
+        NotIsCleanerNotInDeadCycleNotFreeRef notIsCleanerNotInDeadCycleNotFreeRef = new
+                NotIsCleanerNotInDeadCycleNotFreeRef();
+        notIsCleanerNotInDeadCycleNotFreeRef.run();
+        if (notIsCleanerNotInDeadCycleNotFreeRef.check == false) {
+            judgeNum++;
+        }
+    }
+}
+
+class SetReferentNull implements Runnable {
+    Cycle_BDec_00010_A1 cycle1;
+    Cycle_BDec_00010_A2 cycle2;
+
+    @Override
+    public void run() {
+        cycle2 = null;
+        cycle1 = null;
+    }
+}
+
+class NotIsCleanerNotInDeadCycleNotFreeRef implements Runnable {
+    boolean check;
+
+    @Override
+    public void run() {
+        try {
+            check = notIsCleanerNotInDeadCycleNotFreeRef();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    static boolean resultSetCycle(Cycle_BDec_00010_A1 cycle1) throws InterruptedException {
+        InCycle cycleA = new InCycle();
+        cycleA.setCycle(cycle1);
+        Runtime.getRuntime().gc();
+        boolean result = cycleA.setCycle(cycle1);
+        return result;
+    }
+
+    boolean notIsCleanerNotInDeadCycleNotFreeRef() throws InterruptedException {
+        Cycle_BDec_00010_A1 a1 = new Cycle_BDec_00010_A1();
+        boolean result = resultSetCycle(a1);
+        try {
+            if (result == true) {
+                if (a1.clearSoftReference() == true) {
+                    if (a1.clearWeakReference() == true) {
+                        if (a1.clearFinalizePhantomReference() == true) {
+                            if (a1.clearNoFinalizePhantomReference() == true) {
+                                return true;
+                            } else {
+                                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                        " ErrorResult in clearNoFinalizePhantomReference");
+                                return false;
+                            }
+                        } else {
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                    " ErrorResult in clearFinalizePhantomReference");
+                            return false;
+                        }
+                    } else {
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                " ErrorResult in clearWeakReference");
+                        return false;
+                    }
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " ErrorResult in clearSoftReference");
+                    return false;
+                }
+            } else {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " ErrorResult in NotIsCleanerNotInDeadCycleNotFreeRef");
+                return false;
+            }
+        } catch (Exception e) {
+            return false;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A2 {
+    Reference a2Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1 partner1;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A2() {
+        a2Ref = new WeakReference<Object>(obj, rq);
+        if (a2Ref.get() == null) {
+            assert false;
+        }
+        partner1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner1.num;
+    }
+}
+
+class Cycle_BDec_00010_A1 {
+    Reference a1Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2 partner2;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A1() {
+        a1Ref = new WeakReference<Object>(obj, rq);
+        if (a1Ref.get() == null) {
+            assert false;
+        }
+        partner2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner2.num;
+    }
+
+    /**
+     * 设置软引用, clear and enqueue
+     */
+    static Reference srp, wrp, prp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("soft");
+    static StringBuffer obj2 = new StringBuffer("weak");
+    static StringBuffer obj3 = new StringBuffer("phantom");
+
+    static void setSoftReference() {
+        obj1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(obj1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        obj1 = null;
+    }
+
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                    " --------------------srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " --------------------srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置弱引用,clear and enqueue
+     */
+    static void setWeakReference() {
+        obj2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(obj2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        obj2 = null;
+    }
+
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        //释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置虚引用,没有Referent finalized,clear and enqueue
+     */
+    static void setPhantomReference() {
+        obj3 = new StringBuffer("phantom");
+        prp = new PhantomReference<Object>(obj3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        obj3 = null;
+    }
+
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+     */
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyA1(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.add();
+        refInstance.partner2.add();
+        int nSum = refInstance.sum + refInstance.partner2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Referent的环
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCycle(Cycle_BDec_00010_A1 refInstance) throws InterruptedException {
+        refInstance.partner2 = new Cycle_BDec_00010_A2();
+        refInstance.partner2.partner1 = refInstance;
+        boolean ret;
+        ret = ModifyA1(refInstance);
+        refInstance.obj = null;
+        refInstance.partner2.obj = null;
+        Thread.sleep(2000);
+        if (ret == true) {
+            if (refInstance.a1Ref.get() == null && refInstance.partner2.a2Ref.get() == null) {
+                if (refInstance != null && refInstance.partner2 != null) {
+                    return true;
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " a1_0==null||a1_0.a2_0==nulll");
+                    return false;
+                }
+            } else {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " a1_0.a1Ref.get() != null");
+                return false;
+            }
+        } else {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ret != true");
+            return false;
+        }
+    }
+}
+
+class RC_Finalize {
+    static int value = 0;
+
+    static void rc_Finalize() throws InterruptedException {
+        RC_Finalize a = new RC_Finalize();
+        Thread.sleep(2000);
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        return 0;
+    }
+}
+
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0358-rc-rp-simpleweakref_11/NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java b/test/testsuite/ouroboros/rc_test/RC0358-rc-rp-simpleweakref_11/NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..93d74a78e91f2c4f1f20ff2204f2d1377bd62426
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0358-rc-rp-simpleweakref_11/NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
@@ -0,0 +1,376 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor basic testcase: 在不可达的环中，不是cleaner对象，不释放对象，不设置WCB
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1：创建两个带有弱引用对象的class，弱引用申请后通过get方法判断非空，并相互声明对方类作为自己的Field。
+ * -#step2：其中class A1会分别对软引用、弱引用、虚引用进行clear和enqueue， 其中虚引用分为没有Referent finalized的clear和enqueue
+ *          和有Referent finalized的clear和enqueue。
+ * -#step3：创建第三个类InCycle，将上两个类连成一个可达的环。
+ * -#step4：通过线程将A1,A2两个类对象初始化为空。
+ * -#step5：创建InCycle的实例，调用方法setCycle给第一个类对象关于第二个类的Field初始化对象，判断对象的引用不为空，再将该对象关于
+ *          第一个类Field赋值为第一个类，从而形成一个环。
+ * -#step6：方法setCycle调用方法ModifyA1执行前两个类对象的add方法进行Field的运算，相当于对对象进行了引用，判断运算结果是否正确。
+ * -#step7：等待一个回收周期，确认两个类的软引用、弱引用、虚引用对象为NULL。
+ * -#step8：调用Runtime.getRuntime().gc()进行资源回收，重复步骤4~7。
+ * -#step9：确认class A1的软引用、弱引用、虚引用都应该为空。
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source:NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
+ *- @ExecuteClass: NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.io.PrintStream;
+import java.lang.ref.*;
+
+public class NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB();
+            Runtime.getRuntime().gc();
+            notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static boolean resultSetCycle(Cycle_BDec_00010_A1 cycle1) throws InterruptedException {
+        InCycle cycleA = new InCycle();
+        cycleA.setCycle(cycle1);
+        Runtime.getRuntime().gc();
+        boolean result = cycleA.setCycle(cycle1);
+        return result;
+    }
+
+    static void notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB() throws InterruptedException {
+        Cycle_BDec_00010_A1 cycle1 = new Cycle_BDec_00010_A1();
+        boolean result = resultSetCycle(cycle1);
+        if (result == true) {
+            cycle1.partner2 = null;
+            cycle1 = null;
+            if (cycle1.clearSoftReference() == true) {
+                if (cycle1.clearWeakReference() == true) {
+                    if (cycle1.clearFinalizePhantomReference() == true) {
+                        if (cycle1.clearNoFinalizePhantomReference() == true) {
+                        } else {
+                            judgeNum++;
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                    " ErrorResult in clearNoFinalizePhantomReference--------------" +
+                                    "notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                        }
+                    } else {
+                        judgeNum++;
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                " ErrorResult in clearFinalizePhantomReference-------------" +
+                                "notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                    }
+                } else {
+                    judgeNum++;
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " ErrorResult in clearWeakReference");
+                }
+            } else {
+                judgeNum++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " ErrorResult in clearSoftReference");
+            }
+        } else {
+            judgeNum++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                    " ErrorResult in isCleanerNotInDeadCycleNotFreeRefSetWCB");
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1 {
+    Reference a1Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2 partner2;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A1() {
+        obj = new StringBuffer("weak");
+        a1Ref = new WeakReference<Object>(obj, rq);
+        if (a1Ref.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner2.num;
+    }
+
+    /**
+     * 设置软引用,clear and enqueue
+     */
+    static Reference srp, wrp, prp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("soft");
+    static StringBuffer obj2 = new StringBuffer("weak");
+    static StringBuffer obj3 = new StringBuffer("phantom");
+
+    static void setSoftReference() {
+        obj1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(obj1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        obj1 = null;
+    }
+
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        //释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                    " --------------------srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " --------------------srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置弱引用,clear and enqueue
+     */
+    static void setWeakReference() {
+        obj2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(obj2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        obj2 = null;
+    }
+
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置虚引用, 没有Referent finalized, clear and enqueue
+     */
+    static void setPhantomReference() {
+        obj3 = new StringBuffer("phantom");
+        prp = new PhantomReference<Object>(obj3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        obj3 = null;
+    }
+
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+     */
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A2 {
+    Reference a2Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1 partner1;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+
+    Cycle_BDec_00010_A2() {
+        obj = new StringBuffer("weak");
+        a2Ref = new WeakReference<Object>(obj, rq);
+        if (a2Ref.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + partner1.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true: 正确；false：错误
+     */
+    public static boolean ModifyA1(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.add();
+        refInstance.partner2.add();
+        int nSum = refInstance.sum + refInstance.partner2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Referent的环
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true: 正确；false：错误
+     */
+    public static boolean setCycle(Cycle_BDec_00010_A1 refInstance) throws InterruptedException {
+        refInstance.partner2 = new Cycle_BDec_00010_A2();
+        if (refInstance.partner2.a2Ref.get() == null) {
+            return false;
+        }
+        refInstance.partner2.partner1 = refInstance;
+        boolean ret;
+        ret = ModifyA1(refInstance);
+        if (ret == true) {
+            Thread.sleep(2000);
+            if (refInstance.a1Ref.get() == null) {
+                if (refInstance != null && refInstance.partner2 != null) {
+                    return true;
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " a1_0==null||a1_0.a2_0==nulll");
+                    return false;
+                }
+            } else {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " a1_0.a1Ref.get() != null");
+                return false;
+            }
+        } else {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ret != true");
+            return false;
+        }
+    }
+}
+
+class RC_Finalize {
+    static int value = 0;
+
+    static void rc_Finalize() throws InterruptedException {
+        RC_Finalize rc = new RC_Finalize();
+        Thread.sleep(2000);
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        return 0;
+    }
+}
+
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+
diff --git a/test/testsuite/ouroboros/rc_test/RC0359-rc-rp-simpleweakref_12/NotIsCleanerFreeRef.java b/test/testsuite/ouroboros/rc_test/RC0359-rc-rp-simpleweakref_12/NotIsCleanerFreeRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..20e5eca7e5216dd637e67e99f8b5983da203203e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0359-rc-rp-simpleweakref_12/NotIsCleanerFreeRef.java
@@ -0,0 +1,81 @@
+/*
+ *- @TestCaseID: RefProCase/RefProcessor/src/NotIsCleanerFreeRef.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: RefProcessor testcase: 不是cleaner对象，并且释放对象
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 构造一个弱引用, 确认引用不为空。
+ * -#step2: 等待一个周期，确认弱引用被释放
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: NotIsCleanerFreeRef.java
+ *- @ExecuteClass: NotIsCleanerFreeRef
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class NotIsCleanerFreeRef {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer obj = new StringBuffer("soft");
+
+    static void setSoftRef() {
+        obj = new StringBuffer("soft");
+        rp = new WeakReference<Object>(obj, rq);
+        if (rp.get() == null) {
+            judgeNum++;
+        }
+        obj = null;
+    }
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerFreeRef();
+            Runtime.getRuntime().gc();
+            notIsCleanerFreeRef();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void notIsCleanerFreeRef() throws InterruptedException {
+        Reference ref;
+        setSoftRef();
+
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        if (rp.get() != null) {
+            judgeNum++;
+        }
+        while ((ref = rq.poll()) != null) {
+            if (!ref.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                judgeNum++;
+            }
+        }
+    }
+}
+
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0360-rc-Memory-leaktestsupplycase-01/BackupTracingAndRefPro.java b/test/testsuite/ouroboros/rc_test/RC0360-rc-Memory-leaktestsupplycase-01/BackupTracingAndRefPro.java
new file mode 100755
index 0000000000000000000000000000000000000000..a8ac58a6b15d6c82740de5f79f23ad5aa7d8dac4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0360-rc-Memory-leaktestsupplycase-01/BackupTracingAndRefPro.java
@@ -0,0 +1,124 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/BackupTracingAndRefPro.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建弱引用，确认创建成功
+ * -#step2: 等待一个时间周期，确认引用和引用队列被释放
+ * -#step3: 调用Runtime.getRuntime().gc()进行垃圾回收，重复步骤1~2;
+ * -#step4: 创建类的引用，并对类的变量进行运算，确认运算结果正确。
+ * -#step5: 调用Runtime.getRuntime().gc()进行垃圾回收，重复步骤4;
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: BackupTracingAndRefPro.java
+ *- @ExecuteClass: BackupTracingAndRefPro
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class BackupTracingAndRefPro {
+    static int NUM = 2;
+
+    public static void main(String[] args) {
+        runRefPro();
+        Runtime.getRuntime().gc();
+        runRefPro();
+
+        runBackupTracing();
+        Runtime.getRuntime().gc();
+        runBackupTracing();
+        System.out.println("ExpectResult");
+    }
+
+    static void runRefPro() {
+        ThreadRefPro threadRefPro = new ThreadRefPro();
+        for (int i = 0; i < NUM; i++) {
+            threadRefPro.run();
+        }
+    }
+
+    static void runBackupTracing() {
+        ThreadBackupTracing threadBackupTracing = new ThreadBackupTracing();
+        for (int i = 0; i < NUM; i++) {
+            threadBackupTracing.run();
+        }
+    }
+}
+
+class ThreadBackupTracing implements Runnable {
+    int result = 0;
+
+    void versify() {
+        ReferenceOperation ref = new ReferenceOperation();
+        ref.referenceOperation = ref;
+        ref.add();
+        result = ref.sum;
+    }
+
+    @Override
+    public void run() {
+        versify();
+        if (result != 20) {
+            System.out.println("error result ==" + result);
+        }
+    }
+}
+
+class ReferenceOperation {
+    ReferenceOperation referenceOperation;
+    int num;
+    int sum;
+
+    ReferenceOperation() {
+        referenceOperation = null;
+        num = 10;
+        sum = 0;
+    }
+
+    void add() {
+        sum = num + referenceOperation.num;
+    }
+}
+
+class ThreadRefPro implements Runnable {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer obj = new StringBuffer("weak");
+
+    static void setWeakRef() {
+        obj = new StringBuffer("weak");
+        rp = new WeakReference<Object>(obj, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        obj = null;
+    }
+
+    @Override
+    public void run() {
+        Reference reference;
+        setWeakRef();
+
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (rp.get() != null) {
+            System.out.println("error in rp.get()");
+        }
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println("error in rq");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0361-rc-Memory-leaktestsupplycase-02/FinalizerRef.java b/test/testsuite/ouroboros/rc_test/RC0361-rc-Memory-leaktestsupplycase-02/FinalizerRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1256cab9ade76777f2a244d4cb842b9461e52d2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0361-rc-Memory-leaktestsupplycase-02/FinalizerRef.java
@@ -0,0 +1,131 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/FinalizerRef.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建弱引用，确认创建成功，释放强引用。
+ * -#step2: 创建5个线程调用finalize。
+ * -#step3: 调用Runtime.getRuntime().gc()进行垃圾回收。
+ * -#step4: 重复步骤1~2。
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: FinalizerRef.java
+ *- @ExecuteClass: FinalizerRef
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class FinalizerRef {
+    static int NUM = 1;
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        System.out.println("ExpectResult");
+    }
+
+    public static void test() {
+        SetWeakRef setWeakRef = new SetWeakRef();
+        setWeakRef.setWeakRef();
+        ThreadWeakRef_01 threadWeakRef_01 = new ThreadWeakRef_01();
+        ThreadWeakRef_02 threadWeakRef_02 = new ThreadWeakRef_02();
+        ThreadWeakRef_03 threadWeakRef_03 = new ThreadWeakRef_03();
+        ThreadWeakRef_04 threadWeakRef_04 = new ThreadWeakRef_04();
+        ThreadWeakRef_05 threadWeakRef_05 = new ThreadWeakRef_05();
+        for (int i = 0; i < NUM; i++) {
+            threadWeakRef_01.run();
+            threadWeakRef_02.run();
+            threadWeakRef_03.run();
+            threadWeakRef_04.run();
+            threadWeakRef_05.run();
+        }
+    }
+}
+
+class SetWeakRef {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer obj = new StringBuffer("weak");
+
+    static void setWeakRef() {
+        obj = new StringBuffer("weak");
+        rp = new WeakReference(obj, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        obj = null;
+    }
+}
+
+class ThreadWeakRef_01 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_01 threadWeakRef_01 = new ThreadWeakRef_01();
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class ThreadWeakRef_02 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_02 threadWeakRef_02 = new ThreadWeakRef_02();
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class ThreadWeakRef_03 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_03 threadWeakRef_03 = new ThreadWeakRef_03();
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class ThreadWeakRef_04 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_04 threadWeakRef_04 = new ThreadWeakRef_04();
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class ThreadWeakRef_05 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_05 threadWeakRef_05 = new ThreadWeakRef_05();
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0362-rc-Memory-leaktestsupplycase-03/FinalizerTest.java b/test/testsuite/ouroboros/rc_test/RC0362-rc-Memory-leaktestsupplycase-03/FinalizerTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..c105a9484943ff387a8593b2831e3b9e6c7ac80d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0362-rc-Memory-leaktestsupplycase-03/FinalizerTest.java
@@ -0,0 +1,87 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/FinalizerTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *                      等finalizer队列中所有对象执行finalize()方法，确认所有finalize资源顺利释放
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建一个FinalizerTest类的实例对象finalizerTest，对其调用newFinalizeObject()方法，即先创建一个WeakReference类的对
+ *          象并赋值给rp[i]（此处i < finalizeNum = 10），经判断得知rp[i].get()的返回值不为null，最后令stringBuffer等于null；
+ * -#step2: 重复步骤1九次；
+ * -#step3: 令静态的全局变量finalizerTest等于null；
+ * -#step4: 使当前线程休眠2000ms；
+ * -#step5: 调用System.gc()进行垃圾回收；
+ * -#step6: 调用System.runFinalization()方法，即强制调用失去引用的对象的finalize()方法进行资源的释放；
+ * -#step7: 经判断得出rp[i].get()（此处i < finalizeNum = 10）的返回值均为null，证实对象已经完全释放；
+ * -#step8: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step9: 重复步骤1~7；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerTest.java
+ *- @ExecuteClass: FinalizerTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class FinalizerTest extends Object {
+    static int finalizeNum = 10;
+    static Reference rp[] = new Reference[finalizeNum];
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int checkNum = 0;
+    static StringBuffer stringBuffer;
+    static FinalizerTest finalizerTest = null;
+
+    static void newFinalizeObject() throws InterruptedException {
+        stringBuffer = new StringBuffer("weak");
+        for (int i = 0; i < finalizeNum; i++) {
+            rp[i] = new WeakReference<Object>(stringBuffer, rq);
+            if (rp[i].get() == null) {
+                checkNum--;
+            }
+        }
+        stringBuffer = null;
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+        checkNum++;
+    }
+
+    static void newFinalizeTest() throws InterruptedException {
+        for (int i = 0; i < finalizeNum; i++) {
+            FinalizerTest finalizerTest = new FinalizerTest();
+            finalizerTest.newFinalizeObject();
+        }
+        finalizerTest = null;
+    }
+
+    static void finalizeTest() throws InterruptedException {
+        newFinalizeTest();
+        Thread.sleep(2000);
+        System.gc();
+        System.runFinalization();
+        for (int i = 0; i < finalizeNum; i++) {
+            if (rp[i].get() != null) {
+                checkNum--;
+            }
+        }
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        finalizeTest();
+        Runtime.getRuntime().gc();
+        finalizeTest();
+
+        if (checkNum == (finalizeNum * 2)) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("checkNum = " + checkNum);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0363-rc-Memory-leaktestsupplycase-04/FrequentGCAndFinalize.java b/test/testsuite/ouroboros/rc_test/RC0363-rc-Memory-leaktestsupplycase-04/FrequentGCAndFinalize.java
new file mode 100755
index 0000000000000000000000000000000000000000..c92833b7e228c1c149612a818ff52dab56e53163
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0363-rc-Memory-leaktestsupplycase-04/FrequentGCAndFinalize.java
@@ -0,0 +1,83 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/FrequentGCAndFinalize.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建一个WeakReference类的对象rp，经判断rp.get()的返回值不为null；
+ * -#step2: 令stringBuffer等于null；
+ * -#step3: 创建一个ThreadFinalize类的实例对象threadFinalize，对于i < num = 10成立时，对其调用run()方法，即调用
+ *          System.runFinalization()方法，对失去引用的对象调用finalize()方法进行资源的释放；
+ * -#step4: 创建一个ThreadGC类的实例对象threadGC，对于i < num = 10成立时，对其调用run()方法，即调用
+ *          Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step5: 重复step3；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: FrequentGCAndFinalize.java
+ *- @ExecuteClass: FrequentGCAndFinalize
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class FrequentGCAndFinalize {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int num = 10;
+    static StringBuffer stringBuffer = new StringBuffer("weak");
+
+    static void setWeakRef() {
+        stringBuffer = new StringBuffer("weak");
+        rp = new WeakReference<Object>(stringBuffer, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        stringBuffer = null;
+    }
+
+    static void executeThreadGC() {
+        ThreadGC threadGC = new ThreadGC();
+        for (int i = 0; i < num; i++) {
+            threadGC.run();
+        }
+    }
+
+    static void executeThreadFinalize() {
+        ThreadFinalize threadFinalize = new ThreadFinalize();
+        for (int i = 0; i < num; i++) {
+            threadFinalize.run();
+        }
+    }
+
+    public static void main(String[] args) {
+        setWeakRef();
+        executeThreadFinalize();
+        executeThreadGC();
+        executeThreadFinalize();
+        System.out.println("ExpectResult");
+    }
+}
+
+class ThreadGC implements Runnable {
+    @Override
+    public void run() {
+        Runtime.getRuntime().gc();
+    }
+}
+
+class ThreadFinalize implements Runnable {
+    @Override
+    public void run() {
+        ThreadFinalize threadFinalize = new ThreadFinalize();
+        System.runFinalization();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0364-rc-Memory-leaktestsupplycase-05/RaceInLoadAndWriteWeakRef.java b/test/testsuite/ouroboros/rc_test/RC0364-rc-Memory-leaktestsupplycase-05/RaceInLoadAndWriteWeakRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..eb47fcd003adc491e62982a871826004dadcab61
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0364-rc-Memory-leaktestsupplycase-05/RaceInLoadAndWriteWeakRef.java
@@ -0,0 +1,106 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/RaceInLoadAndWriteWeakRef.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建一个WeakReference类的对象并赋值给rp，经判断rp.get()不为null，最后令stringBuffer等于null；
+ * -#step2: 以setWeakRef为参数，分别创建ThreadLoadWeakRef、ThreadWriteWeakRef类的实例对象threadLoadWeakRef和
+ *          threadWriteWeakRef；
+ * -#step3: 调用threadLoadWeakRef的run()方法，即将setWeakRef.rp的值赋值给rp_load；
+ * -#step4: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step5: 重复执行step3~step4一次；
+ * -#step6: 再次执行step3一次；
+ * -#step7: 调用threadWriteWeakRef的run()方法，即将rp_write的值赋值给setWeakRef.rp；
+ * -#step8: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step9: 重复执行step7一次；
+ * -#step10: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step11: 重复执行步骤1~9一次；
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: RaceInLoadAndWriteWeakRef.java
+ *- @ExecuteClass: RaceInLoadAndWriteWeakRef
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class RaceInLoadAndWriteWeakRef {
+    static int NUM = 100;
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        System.out.println("ExpectResult");
+    }
+
+    static void test(){
+        SetWeakRef setWeakRef = new SetWeakRef();
+        setWeakRef.setWeakRef();
+        ThreadLoadWeakRef threadLoadWeakRef = new ThreadLoadWeakRef(setWeakRef);
+        ThreadWriteWeakRef threadWriteWeakRef = new ThreadWriteWeakRef(setWeakRef);
+        for (int i = 0; i < NUM; i++) {
+            threadLoadWeakRef.run();
+            Runtime.getRuntime().gc();
+            threadLoadWeakRef.run();
+            Runtime.getRuntime().gc();
+            threadLoadWeakRef.run();
+
+            threadWriteWeakRef.run();
+            Runtime.getRuntime().gc();
+            threadWriteWeakRef.run();
+        }
+    }
+}
+
+class SetWeakRef {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer stringBuffer = new StringBuffer("Weak");
+
+    static void setWeakRef() {
+        stringBuffer = new StringBuffer("Weak");
+        rp = new WeakReference(stringBuffer, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        stringBuffer = null;
+    }
+}
+
+class ThreadLoadWeakRef implements Runnable {
+    SetWeakRef setWeakRef;
+
+    public ThreadLoadWeakRef(SetWeakRef setWeakRef) {
+        this.setWeakRef = setWeakRef;
+    }
+
+    static Reference rp_load;
+
+    @Override
+    public void run() {
+        rp_load = setWeakRef.rp;
+    }
+}
+
+class ThreadWriteWeakRef implements Runnable {
+    SetWeakRef setWeakRef;
+
+    public ThreadWriteWeakRef(SetWeakRef setWeakRef) {
+        this.setWeakRef = setWeakRef;
+    }
+
+    static WeakReference rp_write;
+
+    @Override
+    public void run() {
+        setWeakRef.rp = rp_write;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+
diff --git a/test/testsuite/ouroboros/rc_test/RC0365-rc-Memory-leaktestsupplycase-06/WeakAndCleanerRef.java b/test/testsuite/ouroboros/rc_test/RC0365-rc-Memory-leaktestsupplycase-06/WeakAndCleanerRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..8931453e69680d39699ef9fb9ec03411087cd269
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0365-rc-Memory-leaktestsupplycase-06/WeakAndCleanerRef.java
@@ -0,0 +1,57 @@
+/*
+ *- @TestCaseID: maple/runtime/rc/function/WeakAndCleanerRef.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Condition: no
+ *- @Brief:functionTest
+ * -#step1: 创建一个ThreadCleaner类的实例对象threadCleaner，创建一个StringBuffer类的变量stringBuffer并赋值为test；
+ * -#step2: 以step1中的threadCleaner和stringBuffer为参数，调用Cleaner类的create()方法创建一个实例对象cleaner；
+ * -#step3: 以ReferenceQueue类的实例对象rq和stringBuffer为参数，创建一个WeakReference类的对象并赋值给rp；
+ * -#step4: 令stringBuffer等于null, 释放强引用；
+ * -#step5: 调用cleaner的clean()方法，进行对象的清除和资源的释放；
+ * -#step6: 让当前线程休眠2000ms；
+ * -#step7: 重复执行step3一次；
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: WeakAndCleanerRef.java
+ *- @ExecuteClass: WeakAndCleanerRef
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class WeakAndCleanerRef {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer stringBuffer = new StringBuffer("test");
+
+    static void addWeakAndCleanerRef() {
+        rp = new WeakReference(stringBuffer, rq);
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        ThreadCleaner threadCleaner = new ThreadCleaner();
+        Cleaner cleaner = Cleaner.create(stringBuffer, threadCleaner);
+        addWeakAndCleanerRef();
+        stringBuffer = null;
+        cleaner.clean();
+        Thread.sleep(2000);
+        addWeakAndCleanerRef();
+        if (rp.get() == null) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+class ThreadCleaner implements Runnable {
+    @Override
+    public void run() {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/RC_Array_01.java b/test/testsuite/ouroboros/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/RC_Array_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..181cdf013b04264884471e137c4791ea9c0ef074
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/RC_Array_01.java
@@ -0,0 +1,434 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D int array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_01.java
+ *- @ExecuteClass: RC_Array_01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_001{
+    //Parent interface
+    volatile int[] base1;
+    int[][] base2;
+    int[][] base21;
+    int[][][] base3;
+}
+
+public class RC_Array_01 extends Base_001{
+    static int check_count = 0;
+    static int[] arr1 = {10,20,30,40};
+    static int[][] arr2 = {{10,20,30,40},{40,50},{60}};
+    static int[][] arr21 = {{40,50,60,30},{70,80},{90}};
+    static int[][][] arr3 = {arr2,arr21};
+
+    private RC_Array_01(){
+        base1 = new int[]{10,20,30,40};
+        base2 = new int[][]{{10,20,30,40},{40,50},{60}};
+        base21 = new int[][]{{40,50,60,30},{70,80},{90}};
+        base3 = new int[][][]{{{10,20,30,40},{40,50},{60}},{{40,50,60,30},{70,80},{90}}};
+    }
+
+    private RC_Array_01(int[] intar){
+        base1 = intar;
+    }
+
+    private RC_Array_01(int[][] intarr){
+        base2 = intarr;
+    }
+
+    private RC_Array_01(int[][][] intarrr){
+        base3 = intarrr;
+    }
+
+    private RC_Array_01(int[] intar, int[][] intarr, int[][][] intarrr){
+        base1 = intar;
+        base2 = intarr;
+        base3 = intarrr;
+    }
+
+    public static void main(String [] args) {
+        final int[] TEST1 = {10,20,30,40};
+        final int[][] TEST2 = {TEST1,{40,50},{60}};
+        final int[][] TEST21 = {{40,50,60,30},{70,80},{90}};
+        final int[][][] TEST3 = {TEST2,TEST21};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2 && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_01_test01 function return value to the parameter third and judged.
+        //RC_Array_01_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_01 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_01_test02();
+
+        //Get an array object by returning a function call
+        int[] getarr1 = RC_Array_get01();
+        int[][] getarr2 = RC_Array_get02();
+        int[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        Boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, int[] second, int[][] third, int[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        int [] xyz = {23,24,25,26};
+        int[][] xyz2 = {{23,24,25,26},{23,24},{23}};
+        int[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, int[] second, int[][] third, int[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        int [] xyz = {23,24,25,26};
+        int[][] xyz2 = {{23,24,25,26},{23,24},{23}};
+        int[][][] xyz3 = {xyz2,xyz2};
+        second = (int[]) change(second,xyz);
+        third = (int[][])change(third,xyz2);
+        four = (int[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(int[][] third) {
+        //The test03 interface is called, and the RC_Array_01_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_01_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static int[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static int[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static int[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static int[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        int [] value1 = {23,24,25,26};
+        RC_Array_01 rctest=new RC_Array_01(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new int[] {88,10,02,11};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static int[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        int[][] value2 = {{23,24,25,26},{23,24},{23}};
+        RC_Array_01 rctest=new RC_Array_01(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new int[][] {{88,10,02,11},{10,92},{16}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static int[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        int[][][] value3 = {{{10,20,30,40},{40,50},{60}},{{40,50,60,30},{70,80},{90}}};
+        RC_Array_01 rctest=new RC_Array_01(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new int[][][]{{{88,10,02,11},{10,92},{12}},{{88,10,02,11},{10,92},{16}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static int[][] RC_Array_01_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to the newly created
+        // object field, and judge the result
+        int [] value1 = {23,24,25,26};
+        int[][] value2 = {{23,24,25,26},{23,24},{23}};
+        int[][][] value3 = {value2,value2};
+        RC_Array_01 rctest=new RC_Array_01(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new int[] {88,10,02,11};
+        rctest.base2 = new int[][] {{88,10,02,11},{10,92},{16}};
+        rctest.base21 = new int[][] {{88,10,02,11},{10,92},{12}};
+        rctest.base3 = new int[][][]{{{88,10,02,11},{10,92},{12}},{{88,10,02,11},{10,92},{16}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_01_test01");
+        return rctest.base21;
+    }
+
+    private static int[] RC_Array_final01()
+    {
+        final int [] VALUE1 = {23,24,25,26};
+        return VALUE1;
+    }
+    private static int[][] RC_Array_final02()
+    {
+        final int[][] VALUE2 = {{23,24,25,26},{23,24},{23}};
+        return VALUE2;
+    }
+    private static int[][][] RC_Array_final03()
+    {
+        final int[][][] VALUE3 = {{{10,20,30,40},{40,50},{60}},{{40,50,60,30},{70,80},{90}}};
+        return VALUE3;
+    }
+    private static int[][] RC_Array_01_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_01 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final int [] VALUE1 = RC_Array_final01();
+        final int[][] VALUE2 = RC_Array_final02();
+        final int[][][] VALUE3 = RC_Array_final03();
+        RC_Array_01 rctest=new RC_Array_01();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_01_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_01_test02_2");
+        return VALUE2;
+    }
+
+    private static Boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        int [] value1 = RC_Array_final01();
+        int[][] value2 = RC_Array_final02();
+        int[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getInt(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 23;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setInt(value1,5,10);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getInt(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getInt(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //NumberFormatException
+        try{
+            Integer i = new Integer(10);
+            Array.setInt(value1,0,i.decode("abc"));
+        }catch (NumberFormatException e)
+        {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_01 rc1 = new RC_Array_01();
+        try{
+            Base_001 bs1 = new Base_001();
+            rc1 = (RC_Array_01)bs1;
+            rc1.base1[0] = 123;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 123)
+                check++;
+        }
+
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getInt(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getInt(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getInt(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        if (check == 19)
+            return true;
+        else
+            return false;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/RC_Array_02.java b/test/testsuite/ouroboros/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/RC_Array_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..db65f4b0964d7f337934f470c4ead05cd2f66631
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/RC_Array_02.java
@@ -0,0 +1,447 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D String array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static、literial
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_02.java
+ *- @ExecuteClass: RC_Array_02
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.regex.PatternSyntaxException;
+
+class Base_002{
+    //Parent interface
+    volatile String[] base1;
+    String[][] base2;
+    String[][] base21;
+    String[][][] base3;
+}
+
+public class RC_Array_02 extends Base_002{
+    static int check_count = 0;
+    static String[] arr1 = {"10","20","30","40"};
+    static String[][] arr2 = {{"10","20","30","40"},{"40","50"},{"60"}};
+    static String[][] arr21 = {{"40","50","60","30"},{"70","80"},{"90"}};
+    static String[][][] arr3 = {arr2,arr21};
+    //literial type data
+    static String literial_v = "abc";
+    static String[] arstr1 = {literial_v,literial_v,literial_v,literial_v};
+    static String[][] arstr2 = {{"abc","abc","abc","abc"},{"abc","abc"},{literial_v}};
+    static String[][][] arstr3 = {arstr2,arstr2};
+
+    private RC_Array_02(){
+        base1 = new String[]{"10","20","30","40"};
+        base2 = new String[][]{{"10","20","30","40"},{"40","50"},{"60"}};
+        base21 = new String[][]{{"40","50","60","30"},{"70","80"},{"90"}};
+        base3 = new String[][][]{{{"10","20","30","40"},{"40","50"},{"60"}},{{"40","50","60","30"},{"70","80"},{"90"}}};
+    }
+
+    private RC_Array_02(String[] Stringar){
+        base1 = Stringar;
+    }
+
+    private RC_Array_02(String[][] Stringarr){
+        base2 = Stringarr;
+    }
+
+    private RC_Array_02(String[][][] Stringarrr){
+        base3 = Stringarrr;
+    }
+
+    private RC_Array_02(String[] Stringar, String[][] Stringarr, String[][][] Stringarrr){
+        base1 = Stringar;
+        base2 = Stringarr;
+        base3 = Stringarrr;
+    }
+
+    public static void main(String [] args) {
+        final String[] TEST1 = {"10","20","30","40"};
+        final String[][] TEST2 = {TEST1,{"40","50"},{"60"}};
+        final String[][] TEST21 = {{"40","50","60","30"},{"70","80"},{"90"}};
+        final String[][][] TEST3 = {TEST2,TEST21};
+        //literial type data
+        final String literial_v = "abc";
+        final String[] arstrr1 = {literial_v,literial_v,literial_v,literial_v};
+        final String[][] arstrr2 = {{"abc","abc","abc","abc"},{"abc","abc"},{literial_v}};
+        final String[][][] arstrr3 = {arstrr2,arstrr2};
+
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2
+                && arstrr1.length == 4 && arstrr2.length == 3 && arstrr3.length == 2
+                && arstr1.length == 4 && arstr2.length == 3 && arstr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult String step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        test01(4,arstr1,arstr2,arstr3);
+        test01(4,arstrr1,arstrr2,arstrr3);
+
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2
+                && arstrr1.length == 4 && arstrr2.length == 3 && arstrr3.length == 2
+                && arstr1.length == 4 && arstr2.length == 3 && arstr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        test02(4,arstr1,arstr2,arstr3);
+        test02(4,arstrr1,arstrr2,arstrr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2
+                && arstrr1.length == 4 && arstrr2.length == 3 && arstrr3.length == 2
+                && arstr1.length == 4 && arstr2.length == 3 && arstr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_02_test01 function return value to the parameter third and judged.
+        //RC_Array_02_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_02() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_02_test02();
+
+        //Get an array object by returning a function call
+        String[] getarr1 = RC_Array_get01();
+        String[][] getarr2 = RC_Array_get02();
+        String[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        Boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 28)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, String[] second, String[][] third, String[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        String [] xyz = {"23","24","25","26"};
+        String[][] xyz2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        String[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, String[] second, String[][] third, String[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        String [] xyz = {"23","24","25","26"};
+        String[][] xyz2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        String[][][] xyz3 = {xyz2,xyz2};
+        second = (String[]) change(second,xyz);
+        third = (String[][])change(third,xyz2);
+        four = (String[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(String[][] third) {
+        //The test03 interface is called, and the RC_Array_02_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_02_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static String[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static String[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static String[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static String[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        String [] value1 = {"23","24","25","26"};
+        RC_Array_02 rctest=new RC_Array_02(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new String[] {"88","10","02","11"};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static String[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        String[][] value2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        RC_Array_02 rctest=new RC_Array_02(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new String[][] {{"88","10","02","11"},{"10","92"},{"16"}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static String[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        String[][][] value3 = {{{"10","20","30","40"},{"40","50"},{"60"}},{{"40","50","60","30"},{"70","80"},{"90"}}};
+        RC_Array_02 rctest=new RC_Array_02(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new String[][][]{{{"88","10","02","11"},{"10","92"},{"12"}},{{"88","10","02","11"},{"10","92"},{"16"}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static String[][] RC_Array_02_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_02, and assign a value to the newly created
+        // object field, and judge the result
+        String [] value1 = {"23","24","25","26"};
+        String[][] value2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        String[][][] value3 = {value2,value2};
+        RC_Array_02 rctest=new RC_Array_02(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new String[] {"88","10","02","11"};
+        rctest.base2 = new String[][] {{"88","10","02","11"},{"10","92"},{"16"}};
+        rctest.base21 = new String[][] {{"88","10","02","11"},{"10","92"},{"12"}};
+        rctest.base3 = new String[][][]{{{"88","10","02","11"},{"10","92"},{"12"}},{{"88","10","02","11"},{"10","92"},{"16"}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_02_test01");
+        return rctest.base21;
+    }
+
+    private static String[] RC_Array_final01()
+    {
+        final String [] VALUE1 = {"23","24","25","26"};
+        return VALUE1;
+    }
+    private static String[][] RC_Array_final02()
+    {
+        final String[][] VALUE2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        return VALUE2;
+    }
+    private static String[][][] RC_Array_final03()
+    {
+        final String[][][] VALUE3 = {{{"10","20","30","40"},{"40","50"},{"60"}},{{"40","50","60","30"},{"70","80"},{"90"}}};
+        return VALUE3;
+    }
+    private static String[][] RC_Array_02_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_02 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final String [] VALUE1 = RC_Array_final01();
+        final String[][] VALUE2 = RC_Array_final02();
+        final String[][][] VALUE3 = RC_Array_final03();
+        RC_Array_02 rctest=new RC_Array_02();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_02_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_02_test02_2");
+        return VALUE2;
+    }
+
+    private static Boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        String [] value1 = RC_Array_final01();
+        String[][] value2 = RC_Array_final02();
+        String[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.get(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = "error";
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.set(value1,5,"10");
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+
+        //IndexOutOfBoundsException
+        try {
+            char[] ch1 = {'h','x','c','t'};
+            Array.set(RC_Array_final03()[0][0],0,String.valueOf(ch1, 5, 2));
+        }catch (IndexOutOfBoundsException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_02 rc1 = new RC_Array_02();
+        try{
+            Base_002 bs1 = new Base_002();
+            rc1 = (RC_Array_02)bs1;
+            rc1.base1[0] = "kitty";
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != "kitty")
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.get(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.get(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.get(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 17)
+            return true;
+        else
+            return false;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/RC_Array_03.java b/test/testsuite/ouroboros/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/RC_Array_03.java
new file mode 100755
index 0000000000000000000000000000000000000000..1b58056b5e307c43fec7df282807ca1047d8dd29
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/RC_Array_03.java
@@ -0,0 +1,428 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D Char array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_03.java
+ *- @ExecuteClass: RC_Array_03
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_003{
+    //Parent interface
+    volatile char[] base1;
+    char[][] base2;
+    char[][] base21;
+    char[][][] base3;
+}
+
+public class RC_Array_03 extends Base_003{
+    static int check_count = 0;
+    static char[] arr1 = {'a','b','c','d'};
+    static char[][] arr2 = {{'a','b','c','d'},{'e','f'},{'g'}};
+    static char[][] arr21 = {{'h','i','j','k'},{'l','m'},{'n'}};
+    static char[][][] arr3 = {arr2,arr21};
+
+    private RC_Array_03(){
+        base1 = new char[]{'a','b','c','d'};
+        base2 = new char[][]{{'a','b','c','d'},{'e','f'},{'g'}};
+        base21 = new char[][]{{'h','i','j','k'},{'l','m'},{'n'}};
+        base3 = new char[][][]{{{'a','b','c','d'},{'e','f'},{'g'}},{{'h','i','j','k'},{'l','m'},{'n'}}};
+    }
+
+    private RC_Array_03(char[] charar){
+        base1 = charar;
+    }
+
+    private RC_Array_03(char[][] chararr){
+        base2 = chararr;
+    }
+
+    private RC_Array_03(char[][][] chararrr){
+        base3 = chararrr;
+    }
+
+    private RC_Array_03(char[] charar, char[][] chararr, char[][][] chararrr){
+        base1 = charar;
+        base2 = chararr;
+        base3 = chararrr;
+    }
+
+    public static void main(String[] args) {
+        final char[] TEST1 = {'1','2','3','4'};
+        final char[][] TEST2 = {TEST1,{'4','5'},{'6'}};
+        final char[][] TEST21 = {{'4','5','6','3'},{'7','8'},{'9'}};
+        final char[][][] TEST3 = {TEST2,TEST21};
+
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult char step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_03_test01 function return value to the parameter third and judged.
+        //RC_Array_03_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_03() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_03_test02();
+
+        //Get an array object by returning a function call
+        char[] getarr1 = RC_Array_get01();
+        char[][] getarr2 = RC_Array_get02();
+        char[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        Boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, char[] second, char[][] third, char[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        char [] xyz = {'h','x','w','g'};
+        char[][] xyz2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        char[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, char[] second, char[][] third, char[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        char [] xyz = {'h','x','w','g'};
+        char[][] xyz2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        char[][][] xyz3 = {xyz2,xyz2};
+        second = (char[]) change(second,xyz);
+        third = (char[][])change(third,xyz2);
+        four = (char[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(char[][] third) {
+        //The test03 interface is called, and the RC_Array_03_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_03_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static char[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static char[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static char[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static char[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        char [] value1 = {'h','x','w','g'};
+        RC_Array_03 rctest=new RC_Array_03(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new char[] {'8','0','2','3'};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static char[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        char[][] value2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        RC_Array_03 rctest=new RC_Array_03(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new char[][] {{'8','0','2','3'},{'w','g'},{'q'}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static char[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        char[][][] value3 = {{{'1','2','3','4'},{'4','5'},{'6'}},{{'4','5','6','3'},{'7','8'},{'9'}}};
+        RC_Array_03 rctest=new RC_Array_03(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new char[][][]{{{'w','a','n','g'},{'s','u'},{'n'}},{{'w','a','n','g'},{'w','g'},{'q'}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static char[][] RC_Array_03_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_03, and assign a value to the newly created
+        // object field, and judge the result
+        char [] value1 = {'h','x','w','g'};
+        char[][] value2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        char[][][] value3 = {value2,value2};
+        RC_Array_03 rctest=new RC_Array_03(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new char[] {'w','a','n','g'};
+        rctest.base2 = new char[][] {{'w','a','n','g'},{'w','g'},{'q'}};
+        rctest.base21 = new char[][] {{'w','a','n','g'},{'s','u'},{'n'}};
+        rctest.base3 = new char[][][]{{{'w','a','n','g'},{'s','u'},{'n'}},{{'w','a','n','g'},{'w','g'},{'q'}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_03_test01");
+        return rctest.base21;
+    }
+
+    private static char[] RC_Array_final01()
+    {
+        final char [] VALUE1 = {'h','x','w','g'};
+        return VALUE1;
+    }
+    private static char[][] RC_Array_final02()
+    {
+        final char[][] VALUE2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        return VALUE2;
+    }
+    private static char[][][] RC_Array_final03()
+    {
+        final char[][][] VALUE3 = {{{'1','2','3','4'},{'4','5'},{'6'}},{{'4','5','6','3'},{'7','8'},{'9'}}};
+        return VALUE3;
+    }
+    private static char[][] RC_Array_03_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_03 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final char [] VALUE1 = RC_Array_final01();
+        final char[][] VALUE2 = RC_Array_final02();
+        final char[][][] VALUE3 = RC_Array_final03();
+        RC_Array_03 rctest=new RC_Array_03();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_03_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_03_test02_2");
+        return VALUE2;
+    }
+
+    private static Boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        char[] value1 = RC_Array_final01();
+        char[][] value2 = RC_Array_final02();
+        char[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getChar(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 'e';
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setChar(value1,5,'1');
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getChar(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getChar(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_03 rc1 = new RC_Array_03();
+        try{
+            Base_003 bs1 = new Base_003();
+            rc1 = (RC_Array_03)bs1;
+            rc1.base1[0] = 'p';
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 'p')
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getChar(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getChar(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getChar(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/RC_Array_04.java b/test/testsuite/ouroboros/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/RC_Array_04.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d12e42221c4501aec33a1fddcbbc856c2131d6f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/RC_Array_04.java
@@ -0,0 +1,428 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_04.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D boolean array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_04.java
+ *- @ExecuteClass: RC_Array_04
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_004{
+    //Parent interface
+    volatile boolean[] base1;
+    boolean[][] base2;
+    boolean[][] base21;
+    boolean[][][] base3;
+}
+
+public class RC_Array_04 extends Base_004{
+    static int check_count = 0;
+    static boolean[] arr1 = {true,false,false,true};
+    static boolean[][] arr2 = {{true,false,false,true},{false,false},{true,true}};
+    static boolean[][] arr21 = {{false,true,false,true},{true,false},{false,true}};
+    static boolean[][][] arr3 = {arr2,arr21};
+
+    private RC_Array_04(){
+        base1 = new boolean[]{true,true,true,true};
+        base2 = new boolean[][]{{true,true,true,true},{false,false},{true,true}};
+        base21 = new boolean[][]{{false,true,true,true},{false,true},{true,true}};
+        base3 = new boolean[][][]{{{true,true,true,true},{false,false},{true,true}},{{false,true,true,true},{false,true},{true,true}}};
+    }
+
+    private RC_Array_04(boolean[] booleanar){
+        base1 = booleanar;
+    }
+
+    private RC_Array_04(boolean[][] booleanarr){
+        base2 = booleanarr;
+    }
+
+    private RC_Array_04(boolean[][][] booleanarrr){
+        base3 = booleanarrr;
+    }
+
+    private RC_Array_04(boolean[] booleanar, boolean[][] booleanarr, boolean[][][] booleanarrr){
+        base1 = booleanar;
+        base2 = booleanarr;
+        base3 = booleanarrr;
+    }
+
+    public static void main(String[] args) {
+        final boolean[] TEST1 = {true,true,true,true};
+        final boolean[][] TEST2 = {TEST1,{false,false},{true,true}};
+        final boolean[][] TEST21 = {{false,true,true,true},{false,true},{true,true}};
+        final boolean[][][] TEST3 = {TEST2,TEST21};
+
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult boolean step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_04_test01 function return value to the parameter third and judged.
+        //RC_Array_04_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_04() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_04_test02();
+
+        //Get an array object by returning a function call
+        boolean[] getarr1 = RC_Array_get01();
+        boolean[][] getarr2 = RC_Array_get02();
+        boolean[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, boolean[] second, boolean[][] third, boolean[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        boolean [] xyz = {false,true,false,true};
+        boolean[][] xyz2 = {{true,true,true,true},{false,false},{true}};
+        boolean[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, boolean[] second, boolean[][] third, boolean[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        boolean [] xyz = {false,true,false,true};
+        boolean[][] xyz2 = {{true,true,true,true},{false,false},{true}};
+        boolean[][][] xyz3 = {xyz2,xyz2};
+        second = (boolean[]) change(second,xyz);
+        third = (boolean[][])change(third,xyz2);
+        four = (boolean[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(boolean[][] third) {
+        //The test03 interface is called, and the RC_Array_04_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_04_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static boolean[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static boolean[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static boolean[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static boolean[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        boolean [] value1 = {false,false,false,false};
+        RC_Array_04 rctest=new RC_Array_04(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new boolean[] {true,true,true,true};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static boolean[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        boolean[][] value2 = {{true,true,true,true},{false,false},{true}};
+        RC_Array_04 rctest=new RC_Array_04(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new boolean[][] {{false,false,false,false},{false,false},{true}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static boolean[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        boolean[][][] value3 = {{{true,true,true,true},{false,false},{true}},{{false,false,false,false},{false,false},{true}}};
+        RC_Array_04 rctest=new RC_Array_04(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new boolean[][][]{{{false,false,false,false},{false,false},{true}},{{true,true,true,true},{false,false},{true}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static boolean[][] RC_Array_04_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_04, and assign a value to the newly created
+        // object field, and judge the result
+        boolean [] value1 = {true,true,true,true};
+        boolean[][] value2 = {{true,true,true,true},{false,false},{true}};
+        boolean[][][] value3 = {value2,value2};
+        RC_Array_04 rctest=new RC_Array_04(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new boolean[] {false,false,false,false};
+        rctest.base2 = new boolean[][] {{false,false,false,false},{false,false},{true}};
+        rctest.base21 = new boolean[][] {{false,true,true,false},{false,false},{true}};
+        rctest.base3 = new boolean[][][]{{{false,false,false,false},{false,false},{true}},{{false,true,true,false},{false,false},{true}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_04_test01");
+        return rctest.base21;
+    }
+
+    private static boolean[] RC_Array_final01()
+    {
+        final boolean[] VALUE1 = {true,true,true,true};
+        return VALUE1;
+    }
+    private static boolean[][] RC_Array_final02()
+    {
+        final boolean[][] VALUE2 = {{false,false,false,false},{false,false},{true}};
+        return VALUE2;
+    }
+    private static boolean[][][] RC_Array_final03()
+    {
+        final boolean[][][] VALUE3 = {{{false,true,true,false},{false,false},{true}},{{false,false,false,false},{false,false},{true}}};
+        return VALUE3;
+    }
+    private static boolean[][] RC_Array_04_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_04 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final boolean[] VALUE1 = RC_Array_final01();
+        final boolean[][] VALUE2 = RC_Array_final02();
+        final boolean[][][] VALUE3 = RC_Array_final03();
+        RC_Array_04 rctest=new RC_Array_04();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_04_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_04_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        boolean[] value1 = RC_Array_final01();
+        boolean[][] value2 = RC_Array_final02();
+        boolean[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getBoolean(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = false;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setBoolean(value1,5,true);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getBoolean(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_04 rc1 = new RC_Array_04();
+        try{
+            Base_004 bs1 = new Base_004();
+            rc1 = (RC_Array_04)bs1;
+            rc1.base1[0] = false;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != false)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getBoolean(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/RC_Array_05.java b/test/testsuite/ouroboros/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/RC_Array_05.java
new file mode 100755
index 0000000000000000000000000000000000000000..c1d7f2e1118530f714498522e77f3767fe978ab6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/RC_Array_05.java
@@ -0,0 +1,428 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_05.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D byte array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_05.java
+ *- @ExecuteClass: RC_Array_05
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_005{
+    //Parent interface
+    volatile byte[] base1;
+    byte[][] base2;
+    byte[][] base21;
+    byte[][][] base3;
+}
+
+public class RC_Array_05 extends Base_005{
+    static int check_count = 0;
+    static byte[] arr1 = {1,2,3,4};
+    static byte[][] arr2 = {{1,2,3,4},{5,6},{7,8}};
+    static byte[][] arr21 = {{4,5,6,7},{8,9},{10,11}};
+    static byte[][][] arr3 = {arr2,arr21};
+
+    private RC_Array_05(){
+        base1 = new byte[]{1,2,3,4};
+        base2 = new byte[][]{{1,2,3,4},{5,6},{7,8}};
+        base21 = new byte[][]{{4,5,6,7},{8,9},{10,11}};
+        base3 = new byte[][][]{{{1,2,3,4},{5,6},{7,8}},{{4,5,6,7},{8,9},{10,11}}};
+    }
+
+    private RC_Array_05(byte[] bytear){
+        base1 = bytear;
+    }
+
+    private RC_Array_05(byte[][] bytearr){
+        base2 = bytearr;
+    }
+
+    private RC_Array_05(byte[][][] bytearrr){
+        base3 = bytearrr;
+    }
+
+    private RC_Array_05(byte[] bytear, byte[][] bytearr, byte[][][] bytearrr){
+        base1 = bytear;
+        base2 = bytearr;
+        base3 = bytearrr;
+    }
+
+    public static void main(String[] args) {
+        final byte[] TEST1 = {1,2,3,4};
+        final byte[][] TEST2 = {TEST1,{5,6},{7,8}};
+        final byte[][] TEST21 = {{4,5,6,7},{8,9},{10,11}};
+        final byte[][][] TEST3 = {TEST2,TEST21};
+
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult byte step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_05_test01 function return value to the parameter third and judged.
+        //RC_Array_05_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_05() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_05_test02();
+
+        //Get an array object by returning a function call
+        byte[] getarr1 = RC_Array_get01();
+        byte[][] getarr2 = RC_Array_get02();
+        byte[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, byte[] second, byte[][] third, byte[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        byte [] xyz = {8,8,1,0};
+        byte[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        byte[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, byte[] second, byte[][] third, byte[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        byte [] xyz = {8,8,1,0};
+        byte[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        byte[][][] xyz3 = {xyz2,xyz2};
+        second = (byte[]) change(second,xyz);
+        third = (byte[][])change(third,xyz2);
+        four = (byte[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(byte[][] third) {
+        //The test03 interface is called, and the RC_Array_05_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_05_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static byte[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static byte[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static byte[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static byte[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        byte [] value1 = {9,2,8,8};
+        RC_Array_05 rctest=new RC_Array_05(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new byte[] {1,2,3,4};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static byte[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        byte[][] value2 = {{1,2,3,4},{1,1},{0}};
+        RC_Array_05 rctest=new RC_Array_05(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new byte[][] {{9,2,8,8},{1,1},{0}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static byte[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        byte[][][] value3 = {{{1,2,3,4},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        RC_Array_05 rctest=new RC_Array_05(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new byte[][][]{{{9,2,8,8},{1,1},{0}},{{1,2,3,4},{1,1},{0}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static byte[][] RC_Array_05_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_05, and assign a value to the newly created
+        // object field, and judge the result
+        byte [] value1 = {1,2,3,4};
+        byte[][] value2 = {{1,2,3,4},{1,1},{0}};
+        byte[][][] value3 = {value2,value2};
+        RC_Array_05 rctest=new RC_Array_05(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new byte[] {9,2,8,8};
+        rctest.base2 = new byte[][] {{9,2,8,8},{1,1},{0}};
+        rctest.base21 = new byte[][] {{6,6,6,5},{1,1},{0}};
+        rctest.base3 = new byte[][][]{{{9,2,8,8},{1,1},{0}},{{6,6,6,5},{1,1},{0}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_05_test01");
+        return rctest.base21;
+    }
+
+    private static byte[] RC_Array_final01()
+    {
+        final byte[] VALUE1 = {1,2,3,4};
+        return VALUE1;
+    }
+    private static byte[][] RC_Array_final02()
+    {
+        final byte[][] VALUE2 = {{9,2,8,8},{1,1},{0}};
+        return VALUE2;
+    }
+    private static byte[][][] RC_Array_final03()
+    {
+        final byte[][][] VALUE3 = {{{6,6,6,5},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        return VALUE3;
+    }
+    private static byte[][] RC_Array_05_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_05 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final byte[] VALUE1 = RC_Array_final01();
+        final byte[][] VALUE2 = RC_Array_final02();
+        final byte[][][] VALUE3 = RC_Array_final03();
+        RC_Array_05 rctest=new RC_Array_05();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_05_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_05_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        byte[] value1 = RC_Array_final01();
+        byte[][] value2 = RC_Array_final02();
+        byte[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getByte(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 'h';
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setByte(value1,5,(byte)0x19);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getByte(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getByte(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_05 rc1 = new RC_Array_05();
+        try{
+            Base_005 bs1 = new Base_005();
+            rc1 = (RC_Array_05)bs1;
+            rc1.base1[0] = 8;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getByte(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getByte(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getByte(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/RC_Array_06.java b/test/testsuite/ouroboros/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/RC_Array_06.java
new file mode 100755
index 0000000000000000000000000000000000000000..58006985eab70ffcf166757be26087440c9dc18c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/RC_Array_06.java
@@ -0,0 +1,428 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_06.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D short array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_06.java
+ *- @ExecuteClass: RC_Array_06
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_006{
+    //Parent interface
+    volatile short[] base1;
+    short[][] base2;
+    short[][] base21;
+    short[][][] base3;
+}
+
+public class RC_Array_06 extends Base_006{
+    static int check_count = 0;
+    static short[] arr1 = {1,2,3,4};
+    static short[][] arr2 = {{1,2,3,4},{5,6},{7,8}};
+    static short[][] arr21 = {{4,5,6,7},{8,9},{10,11}};
+    static short[][][] arr3 = {arr2,arr21};
+
+    private RC_Array_06(){
+        base1 = new short[]{1,2,3,4};
+        base2 = new short[][]{{1,2,3,4},{5,6},{7,8}};
+        base21 = new short[][]{{4,5,6,7},{8,9},{10,11}};
+        base3 = new short[][][]{{{1,2,3,4},{5,6},{7,8}},{{4,5,6,7},{8,9},{10,11}}};
+    }
+
+    private RC_Array_06(short[] shortar){
+        base1 = shortar;
+    }
+
+    private RC_Array_06(short[][] shortarr){
+        base2 = shortarr;
+    }
+
+    private RC_Array_06(short[][][] shortarrr){
+        base3 = shortarrr;
+    }
+
+    private RC_Array_06(short[] shortar, short[][] shortarr, short[][][] shortarrr){
+        base1 = shortar;
+        base2 = shortarr;
+        base3 = shortarrr;
+    }
+
+    public static void main(String[] args) {
+        final short[] TEST1 = {1,2,3,4};
+        final short[][] TEST2 = {TEST1,{5,6},{7,8}};
+        final short[][] TEST21 = {{4,5,6,7},{8,9},{10,11}};
+        final short[][][] TEST3 = {TEST2,TEST21};
+
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult short step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_06_test01 function return value to the parameter third and judged.
+        //RC_Array_06_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_06() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_06_test02();
+
+        //Get an array object by returning a function call
+        short[] getarr1 = RC_Array_get01();
+        short[][] getarr2 = RC_Array_get02();
+        short[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, short[] second, short[][] third, short[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        short [] xyz = {8,8,1,0};
+        short[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        short[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, short[] second, short[][] third, short[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        short [] xyz = {8,8,1,0};
+        short[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        short[][][] xyz3 = {xyz2,xyz2};
+        second = (short[]) change(second,xyz);
+        third = (short[][])change(third,xyz2);
+        four = (short[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(short[][] third) {
+        //The test03 interface is called, and the RC_Array_06_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_06_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static short[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static short[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static short[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static short[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        short [] value1 = {9,2,8,8};
+        RC_Array_06 rctest=new RC_Array_06(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new short[] {1,2,3,4};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static short[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        short[][] value2 = {{1,2,3,4},{1,1},{0}};
+        RC_Array_06 rctest=new RC_Array_06(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new short[][] {{9,2,8,8},{1,1},{0}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static short[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        short[][][] value3 = {{{1,2,3,4},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        RC_Array_06 rctest=new RC_Array_06(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new short[][][]{{{9,2,8,8},{1,1},{0}},{{1,2,3,4},{1,1},{0}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static short[][] RC_Array_06_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_06, and assign a value to the newly created
+        // object field, and judge the result
+        short [] value1 = {1,2,3,4};
+        short[][] value2 = {{1,2,3,4},{1,1},{0}};
+        short[][][] value3 = {value2,value2};
+        RC_Array_06 rctest=new RC_Array_06(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new short[] {9,2,8,8};
+        rctest.base2 = new short[][] {{9,2,8,8},{1,1},{0}};
+        rctest.base21 = new short[][] {{6,6,6,5},{1,1},{0}};
+        rctest.base3 = new short[][][]{{{9,2,8,8},{1,1},{0}},{{6,6,6,5},{1,1},{0}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_06_test01");
+        return rctest.base21;
+    }
+
+    private static short[] RC_Array_final01()
+    {
+        final short[] VALUE1 = {1,2,3,4};
+        return VALUE1;
+    }
+    private static short[][] RC_Array_final02()
+    {
+        final short[][] VALUE2 = {{9,2,8,8},{1,1},{0}};
+        return VALUE2;
+    }
+    private static short[][][] RC_Array_final03()
+    {
+        final short[][][] VALUE3 = {{{6,6,6,5},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        return VALUE3;
+    }
+    private static short[][] RC_Array_06_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_06() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final short[] VALUE1 = RC_Array_final01();
+        final short[][] VALUE2 = RC_Array_final02();
+        final short[][][] VALUE3 = RC_Array_final03();
+        RC_Array_06 rctest=new RC_Array_06();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_06_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_06_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        short[] value1 = RC_Array_final01();
+        short[][] value2 = RC_Array_final02();
+        short[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getShort(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 88;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setShort(value1,5,(short)12);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getShort(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getShort(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_06 rc1 = new RC_Array_06();
+        try{
+            Base_006 bs1 = new Base_006();
+            rc1 = (RC_Array_06)bs1;
+            rc1.base1[0] = 8;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getShort(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getShort(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getShort(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/RC_Array_07.java b/test/testsuite/ouroboros/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/RC_Array_07.java
new file mode 100755
index 0000000000000000000000000000000000000000..badc7fa9c24e3260120a8bae49b865a0a384bb03
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/RC_Array_07.java
@@ -0,0 +1,431 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_07.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D long array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_07.java
+ *- @ExecuteClass: RC_Array_07
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_007{
+    //Parent interface
+    volatile long[] base1;
+    long[][] base2;
+    long[][] base21;
+    long[][][] base3;
+}
+
+public class RC_Array_07 extends Base_007{
+    static int check_count = 0;
+    static long[] arr1 = {1,2,3,4};
+    static long[][] arr2 = {{1,2,3,4},{5,6},{7,8}};
+    static long[][] arr21 = {{4,5,6,7},{8,9},{10,11}};
+    static long[][][] arr3 = {arr2,arr21};
+
+    private RC_Array_07(){
+        base1 = new long[]{1,2,3,4};
+        base2 = new long[][]{{1,2,3,4},{5,6},{7,8}};
+        base21 = new long[][]{{4,5,6,7},{8,9},{10,11}};
+        base3 = new long[][][]{{{1,2,3,4},{5,6},{7,8}},{{4,5,6,7},{8,9},{10,11}}};
+    }
+
+    private RC_Array_07(long[] longar){
+        base1 = longar;
+    }
+
+    private RC_Array_07(long[][] longarr){
+        base2 = longarr;
+    }
+
+    private RC_Array_07(long[][][] longarrr){
+        base3 = longarrr;
+    }
+
+    private RC_Array_07(long[] longar, long[][] longarr, long[][][] longarrr){
+        base1 = longar;
+        base2 = longarr;
+        base3 = longarrr;
+    }
+
+    public static void main(String[] args) {
+        final long[] TEST1 = {1,2,3,4};
+        final long[][] TEST2 = {TEST1,{5,6},{7,8}};
+        final long[][] TEST21 = {{4,5,6,7},{8,9},{10,11}};
+        final long[][][] TEST3 = {TEST2,TEST21};
+
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult long step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_07_test01 function return value to the parameter third and judged.
+        //RC_Array_07_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_07() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_07_test02();
+
+        //Get an array object by returning a function call
+        long[] getarr1 = RC_Array_get01();
+        long[][] getarr2 = RC_Array_get02();
+        long[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, long[] second, long[][] third, long[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        long [] xyz = {8,8,1,0};
+        long[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        long[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, long[] second, long[][] third, long[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        long [] xyz = {8,8,1,0};
+        long[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        long[][][] xyz3 = {xyz2,xyz2};
+        second = (long[]) change(second,xyz);
+        third = (long[][])change(third,xyz2);
+        four = (long[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(long[][] third) {
+        //The test03 interface is called, and the RC_Array_07_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_07_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static long[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static long[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static long[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static long[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        long [] value1 = {9,2,8,8};
+        RC_Array_07 rctest=new RC_Array_07(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new long[] {1,2,3,4};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static long[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        long[][] value2 = {{1,2,3,4},{1,1},{0}};
+        RC_Array_07 rctest=new RC_Array_07(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new long[][] {{9,2,8,8},{1,1},{0}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static long[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        long[][][] value3 = {{{1,2,3,4},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        RC_Array_07 rctest=new RC_Array_07(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new long[][][]{{{9,2,8,8},{1,1},{0}},{{1,2,3,4},{1,1},{0}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static long[][] RC_Array_07_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_07, and assign a value to the newly created
+        // object field, and judge the result
+        long [] value1 = {1,2,3,4};
+        long[][] value2 = {{1,2,3,4},{1,1},{0}};
+        long[][][] value3 = {value2,value2};
+        RC_Array_07 rctest=new RC_Array_07(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new long[] {9,2,8,8};
+        rctest.base2 = new long[][] {{9,2,8,8},{1,1},{0}};
+        rctest.base21 = new long[][] {{6,6,6,5},{1,1},{0}};
+        rctest.base3 = new long[][][]{{{9,2,8,8},{1,1},{0}},{{6,6,6,5},{1,1},{0}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_07_test01");
+        return rctest.base21;
+    }
+
+    private static long[] RC_Array_final01()
+    {
+        final long[] VALUE1 = {1,2,3,4};
+        return VALUE1;
+    }
+    private static long[][] RC_Array_final02()
+    {
+        final long[][] VALUE2 = {{9,2,8,8},{1,1},{0}};
+        return VALUE2;
+    }
+    private static long[][][] RC_Array_final03()
+    {
+        final long[][][] VALUE3 = {{{6,6,6,5},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        return VALUE3;
+    }
+    private static long[][] RC_Array_07_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_07() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final long[] VALUE1 = RC_Array_final01();
+        final long[][] VALUE2 = RC_Array_final02();
+        final long[][][] VALUE3 = RC_Array_final03();
+        RC_Array_07 rctest=new RC_Array_07();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_07_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_07_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        long[] value1 = RC_Array_final01();
+        long[][] value2 = RC_Array_final02();
+        long[][][] value3 = RC_Array_final03();
+
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getLong(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 92;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setLong(value1,5,(long)12);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getLong(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getLong(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_07 rc1 = new RC_Array_07();
+        try{
+            Base_007 bs1 = new Base_007();
+            rc1 = (RC_Array_07)bs1;
+            rc1.base1[0] = 8;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getLong(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getLong(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getLong(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/RC_Array_08.java b/test/testsuite/ouroboros/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/RC_Array_08.java
new file mode 100755
index 0000000000000000000000000000000000000000..0c9a823a47592930ea094db87fbfb66ff7178bbc
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/RC_Array_08.java
@@ -0,0 +1,431 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_08.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D float array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_08.java
+ *- @ExecuteClass: RC_Array_08
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_008{
+    //Parent interface
+    volatile float[] base1;
+    float[][] base2;
+    float[][] base21;
+    float[][][] base3;
+}
+
+public class RC_Array_08 extends Base_008{
+    static int check_count = 0;
+    static float[] arr1 = {1.1f,2.2f,3.3f,4.4f};
+    static float[][] arr2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+    static float[][] arr21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+    static float[][][] arr3 = {arr2,arr21};
+
+    private RC_Array_08(){
+        base1 = new float[]{1.1f,2.2f,3.3f,4.4f};
+        base2 = new float[][]{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+        base21 = new float[][]{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+        base3 = new float[][][]{{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}}};
+    }
+
+    private RC_Array_08(float[] floatar){
+        base1 = floatar;
+    }
+
+    private RC_Array_08(float[][] floatarr){
+        base2 = floatarr;
+    }
+
+    private RC_Array_08(float[][][] floatarrr){
+        base3 = floatarrr;
+    }
+
+    private RC_Array_08(float[] floatar, float[][] floatarr, float[][][] floatarrr){
+        base1 = floatar;
+        base2 = floatarr;
+        base3 = floatarrr;
+    }
+
+    public static void main(String[] args) {
+        final float[] TEST1 = {1.1f,2.2f,3.3f,4.4f};
+        final float[][] TEST2 = {TEST1,{5.5f,6.6f},{7.7f,8.8f}};
+        final float[][] TEST21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+        final float[][][] TEST3 = {TEST2,TEST21};
+
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult float step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_08_test01 function return value to the parameter third and judged.
+        //RC_Array_08_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_08() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_08_test02();
+
+        //Get an array object by returning a function call
+        float[] getarr1 = RC_Array_get01();
+        float[][] getarr2 = RC_Array_get02();
+        float[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, float[] second, float[][] third, float[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        float [] xyz = {8.5f,8.3f,1.2f,0.5f};
+        float[][] xyz2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        float[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, float[] second, float[][] third, float[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        float [] xyz = {8.5f,8.3f,1.2f,0.5f};
+        float[][] xyz2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        float[][][] xyz3 = {xyz2,xyz2};
+        second = (float[]) change(second,xyz);
+        third = (float[][])change(third,xyz2);
+        four = (float[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(float[][] third) {
+        //The test03 interface is called, and the RC_Array_08_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_08_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static float[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static float[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static float[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static float[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        float [] value1 = {9.2f,2.2f,8.8f,8.8f};
+        RC_Array_08 rctest=new RC_Array_08(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new float[] {1.1f,2.2f,3.3f,4.4f};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static float[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        float[][] value2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        RC_Array_08 rctest=new RC_Array_08(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new float[][] {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static float[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        float[][][] value3 = {{{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}},{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}}};
+        RC_Array_08 rctest=new RC_Array_08(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new float[][][]{{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}},{{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static float[][] RC_Array_08_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_08, and assign a value to the newly created
+        // object field, and judge the result
+        float [] value1 = {1.1f,2.2f,3.3f,4.4f};
+        float[][] value2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        float[][][] value3 = {value2,value2};
+        RC_Array_08 rctest=new RC_Array_08(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new float[] {9.2f,2.2f,8.8f,8.8f};
+        rctest.base2 = new float[][] {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        rctest.base21 = new float[][] {{6,6,6,5},{1.3f,1.1f},{0.5f}};
+        rctest.base3 = new float[][][]{{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}},{{6,6,6,5},{1.3f,1.1f},{0.5f}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_08_test01");
+        return rctest.base21;
+    }
+
+    private static float[] RC_Array_final01()
+    {
+        final float[] VALUE1 = {1.1f,2.2f,3.3f,4.4f};
+        return VALUE1;
+    }
+    private static float[][] RC_Array_final02()
+    {
+        final float[][] VALUE2 = {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        return VALUE2;
+    }
+    private static float[][][] RC_Array_final03()
+    {
+        final float[][][] VALUE3 = {{{6.4f,6.1f,6.3f,5.5f},{1.3f,1.1f},{0.5f}},{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}}};
+        return VALUE3;
+    }
+    private static float[][] RC_Array_08_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_08() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final float[] VALUE1 = RC_Array_final01();
+        final float[][] VALUE2 = RC_Array_final02();
+        final float[][][] VALUE3 = RC_Array_final03();
+        RC_Array_08 rctest=new RC_Array_08();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_08_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_08_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        float[] value1 = RC_Array_final01();
+        float[][] value2 = RC_Array_final02();
+        float[][][] value3 = RC_Array_final03();
+
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getFloat(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 88.10f;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setFloat(value1,5,12.5f);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getFloat(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_08 rc1 = new RC_Array_08();
+        try{
+            Base_008 bs1 = new Base_008();
+            rc1 = (RC_Array_08)bs1;
+            rc1.base1[0] = 8.9f;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8.9f)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getFloat(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/RC_Array_09.java b/test/testsuite/ouroboros/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/RC_Array_09.java
new file mode 100755
index 0000000000000000000000000000000000000000..e0eaf1962ac6370a87c51e2ba766035ba7fbb94d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/RC_Array_09.java
@@ -0,0 +1,417 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_09.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Scenario testing for RC optimization: testing various scenes of 1D, 2D, 3D double array objects，including：
+ *                   1.Parameter modification / parameter has not been modified
+ *                   2.final、static
+ *                   3.As a constructor fun
+ *                   4.Function call
+ *                   5.Object Passing
+ *                   6.return constant; variable; function call
+ *                   7.Inherited as a parent class; child class inherits the parent class; interface call;
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_09.java
+ *- @ExecuteClass: RC_Array_09
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+class Base_009{
+    //Parent interface
+    volatile double[] base1;
+    double[][] base2;
+    double[][] base21;
+    double[][][] base3;
+}
+
+public class RC_Array_09 extends Base_009{
+    static int check_count = 0;
+    static double[] arr1 = {1.1f,2.2f,3.3f,4.4f};
+    static double[][] arr2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+    static double[][] arr21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+    static double[][][] arr3 = {arr2,arr21};
+
+    private RC_Array_09(){
+        base1 = new double[]{1.1f,2.2f,3.3f,4.4f};
+        base2 = new double[][]{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+        base21 = new double[][]{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+        base3 = new double[][][]{{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}}};
+    }
+
+    private RC_Array_09(double[] doublear){
+        base1 = doublear;
+    }
+
+    private RC_Array_09(double[][] doublearr){
+        base2 = doublearr;
+    }
+
+    private RC_Array_09(double[][][] doublearrr){
+        base3 = doublearrr;
+    }
+
+    private RC_Array_09(double[] doublear, double[][] doublearr, double[][][] doublearrr){
+        base1 = doublear;
+        base2 = doublearr;
+        base3 = doublearrr;
+    }
+
+    public static void main(String[] args) {
+        final double[] TEST1 = {1.1f,2.2f,3.3f,4.4f};
+        final double[][] TEST2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+        final double[][] TEST21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+        final double[][][] TEST3 = {TEST2,TEST21};
+
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult double step1");
+
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+
+        //The test03 interface call, call the RC_Array_09_test01 function return value to the parameter third and judged.
+        //RC_Array_09_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_09() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_09_test02();
+
+        //Get an array object by returning a function call
+        double[] getarr1 = RC_Array_get01();
+        double[][] getarr2 = RC_Array_get02();
+        double[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+
+    }
+
+    private static void test01(int first, double[] second, double[][] third, double[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        double [] xyz = {8.5f,8.3f,1.2f,0.5f};
+        double[][] xyz2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        double[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+
+    private static void test02(int first, double[] second, double[][] third, double[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        double [] xyz = {8.5f,8.3f,1.2f,0.5f};
+        double[][] xyz2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        double[][][] xyz3 = {xyz2,xyz2};
+        second = (double[]) change(second,xyz);
+        third = (double[][])change(third,xyz2);
+        four = (double[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03(double[][] third) {
+        //The test03 interface is called, and the RC_Array_09_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_09_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static double[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+
+    private static double[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+
+    private static double[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+
+    private static double[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        double [] value1 = {9.2f,2.2f,8.8f,8.8f};
+        RC_Array_09 rctest=new RC_Array_09(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new double[] {1.1f,2.2f,3.3f,4.4f};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+
+    private static double[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        double[][] value2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        RC_Array_09 rctest=new RC_Array_09(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new double[][] {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+
+    private static double[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        double[][][] value3 = {{{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}},{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}}};
+        RC_Array_09 rctest=new RC_Array_09(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new double[][][]{{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}},{{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+
+    private static double[][] RC_Array_09_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_09, and assign a value to the newly created
+        // object field, and judge the result
+        double [] value1 = {1.1f,2.2f,3.3f,4.4f};
+        double[][] value2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        double[][][] value3 = {value2,value2};
+        RC_Array_09 rctest=new RC_Array_09(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new double[] {9.2f,2.2f,8.8f,8.8f};
+        rctest.base2 = new double[][] {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        rctest.base21 = new double[][] {{6,6,6,5},{1.3f,1.1f},{0.5f}};
+        rctest.base3 = new double[][][]{{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}},{{6,6,6,5},{1.3f,1.1f},{0.5f}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_09_test01");
+        return rctest.base21;
+    }
+
+    private static double[] RC_Array_final01()
+    {
+        final double[] VALUE1 = {1.1f,2.2f,3.3f,4.4f};
+        return VALUE1;
+    }
+    private static double[][] RC_Array_final02()
+    {
+        final double[][] VALUE2 = {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        return VALUE2;
+    }
+    private static double[][][] RC_Array_final03()
+    {
+        final double[][][] VALUE3 = {{{6.4f,6.1f,6.3f,5.5f},{1.3f,1.1f},{0.5f}},{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}}};
+        return VALUE3;
+    }
+    private static double[][] RC_Array_09_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_09() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final double[] VALUE1 = RC_Array_final01();
+        final double[][] VALUE2 = RC_Array_final02();
+        final double[][][] VALUE3 = RC_Array_final03();
+        RC_Array_09 rctest=new RC_Array_09();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_09_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_09_test02_2");
+        return VALUE2;
+    }
+
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        double[] value1 = RC_Array_final01();
+        double[][] value2 = RC_Array_final02();
+        double[][][] value3 = RC_Array_final03();
+
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getDouble(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 10.16f;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setDouble(value1,5,12.5f);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getDouble(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_09 rc1 = new RC_Array_09();
+        try{
+            Base_009 bs1 = new Base_009();
+            rc1 = (RC_Array_09)bs1;
+            rc1.base1[0] = 8.9f;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8.9f)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getDouble(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+
+        //System.out.println(check);
+        if (check == 15)
+            return true;
+        else
+            return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/RC_Array_10.java b/test/testsuite/ouroboros/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/RC_Array_10.java
new file mode 100755
index 0000000000000000000000000000000000000000..1bd974a32f2c39b7d1e85efc8d022d920ed47ea7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/RC_Array_10.java
@@ -0,0 +1,404 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_10.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario test for RC optimization: test array copy object various scenarios, including:
+ *                   1.One, two, three-dimensional array type cyclic assignment
+ *                   2.One, two, three-dimensional array type System.arraycopy () assignment
+ *                   3.One, two, three-dimensional array type Arrays.copyOf() assignment
+ *                   4.One, two, three-dimensional array type Arrays.copyOfRange() assignment
+ *                   5.One, two, three-dimensional array type clone() assignment
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_10.java
+ *- @ExecuteClass: RC_Array_10
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.util.Arrays;
+
+public class RC_Array_10 {
+    static int check_count = 0;
+    //Nine definitions:int、string、char、boolean、byte、short、long、float、double
+    static int[] intr1 = {10,20,30,40};
+    static int[][] intr2 = {{10,20,30,40},{40,50},{60}};
+    static int[][] intr21 = {{40,50,60,30},{70,80},{90}};
+    static int[][][] intr3 = {{{10,20,30,40},{40,50},{60}},{{40,50,60,30},{70,80},{90}}};
+    static String[] strr1 = {"hello","test","for","array"};
+    static String[][] strr2 = {{"hello","test","for","array"},{"2018","11"},{"26"}};
+    static String[][] strr21 = {{"huawei","test","for","array"},{"2018","11"},{"26"}};
+    static String[][][] strr3 = {{{"hello","test","for","array"},{"2018","11"},{"26"}},{{"huawei","test","for","array"},{"2018","11"},{"26"}}};
+    static char[] charr1 = {'a','b','c','d'};
+    static char[][] charr2 = {{'a','b','c','d'},{'e','f'},{'g'}};
+    static char[][] charr21 = {{'h','i','j','k'},{'l','m'},{'n'}};
+    static char[][][] charr3 = {{{'a','b','c','d'},{'e','f'},{'g'}},{{'h','i','j','k'},{'l','m'},{'n'}}};
+    static boolean[] boolr1 = {true,false,false,true};
+    static boolean[][] boolr2 = {{true,false,false,true},{false,false},{true}};
+    static boolean[][] boolr21 = {{false,true,false,true},{true,false},{false}};
+    static boolean[][][] boolr3 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{false}}};
+    static byte[] byter1 = {1,2,3,4};
+    static byte[][] byter2 = {{1,2,3,4},{5,6},{7}};
+    static byte[][] byter21 = {{4,5,6,7},{8,9},{10}};
+    static byte[][][] byter3 = {{{1,2,3,4},{5,6},{7}},{{4,5,6,7},{8,9},{10}}};
+    static short[] shortr1 = {1,2,3,4};
+    static short[][] shortr2 = {{1,2,3,4},{5,6},{7}};
+    static short[][] shortr21 = {{4,5,6,7},{8,9},{10}};
+    static short[][][] shortr3 = {{{1,2,3,4},{5,6},{7}},{{4,5,6,7},{8,9},{10}}};
+    static long[] longr1 = {1,2,3,4};
+    static long[][] longr2 = {{1,2,3,4},{5,6},{7}};
+    static long[][] longr21 = {{4,5,6,7},{8,9},{10}};
+    static long[][][] longr3 = {{{1,2,3,4},{5,6},{7}},{{4,5,6,7},{8,9},{10}}};
+    static float[] floatr1 = {1.1f,2.2f,3.3f,4.4f};
+    static float[][] floatr2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}};
+    static float[][] floatr21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}};
+    static float[][][] floatr3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}}};
+    static double[] doubler1 = {1.1f,2.2f,3.3f,4.4f};
+    static double[][] doubler2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}};
+    static double[][] doubler21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}};
+    static double[][][] doubler3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}}};
+
+    public static void main(String [] args) {
+        //Initialization check
+        check("initialization");
+
+        //Copy scene1：One, two, three-dimensional array type cyclic assignment
+        test01();
+        check("test01");
+
+        //Copy scene2：One, two, three-dimensional array type System.arraycopy () assignment
+        test02();
+        check("test02");
+
+        //Copy scene3：One, two, three-dimensional array type Arrays.copyOf() assignment
+        test03();
+        check("test03");
+
+        //Copy scene4：One, two, three-dimensional array type Arrays.copyOfRange() assignment
+        test04();
+        check("test04");
+
+        //Copy scene5：One, two, three-dimensional array type clone() assignment
+        test05();
+        check("test05");
+
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 11)
+            System.out.println("ExpectResult");
+    }
+
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled*/
+        if(intr1.length == 4 && intr2.length == 3 && intr21.length == 3 && intr3.length == 2
+                && strr1.length == 4 && strr2.length == 3 && strr21.length == 3 && strr3.length == 2
+                && charr1.length == 4 && charr2.length == 3 && charr21.length == 3 && charr3.length == 2
+                && boolr1.length == 4 && boolr2.length == 3 && boolr21.length == 3 && boolr3.length == 2
+                && byter1.length == 4 && byter2.length == 3 && byter21.length == 3 && byter3.length == 2
+                && shortr1.length == 4 && shortr2.length == 3 && shortr21.length == 3 && shortr3.length == 2
+                && longr1.length == 4 && longr2.length == 3 && longr21.length == 3 && longr3.length == 2
+                && floatr1.length == 4 && floatr2.length == 3 && floatr21.length == 3 && floatr3.length == 2
+                && doubler1.length == 4 && doubler2.length == 3 && doubler21.length == 3 && doubler3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+
+    private static void test01() {
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        int [] tmp_int1 = new int[4];
+        int [][] tmp_int2 = new int [3][4];
+        int [][][] tmp_int3 = new int [2][3][4];
+        String [] tmp_String1 = new String[4];
+        String [][] tmp_String2 = new String [3][4];
+        String [][][] tmp_String3 = new String [2][3][4];
+        char [] tmp_char1 = new char[4];
+        char [][] tmp_char2 = new char [3][4];
+        char [][][] tmp_char3 = new char [2][3][4];
+        boolean [] tmp_boolean1 = new boolean[4];
+        boolean [][] tmp_boolean2 = new boolean [3][4];
+        boolean [][][] tmp_boolean3 = new boolean [2][3][4];
+        byte [] tmp_byte1 = new byte[4];
+        byte [][] tmp_byte2 = new byte [3][4];
+        byte [][][] tmp_byte3 = new byte [2][3][4];
+        short [] tmp_short1 = new short[4];
+        short [][] tmp_short2 = new short [3][4];
+        short [][][] tmp_short3 = new short [2][3][4];
+        long [] tmp_long1 = new long[4];
+        long [][] tmp_long2 = new long [3][4];
+        long [][][] tmp_long3 = new long [2][3][4];
+        float [] tmp_float1 = new float[4];
+        float [][] tmp_float2 = new float [3][4];
+        float [][][] tmp_float3 = new float [2][3][4];
+        double [] tmp_double1 = new double[4];
+        double [][] tmp_double2 = new double [3][4];
+        double [][][] tmp_double3 = new double [2][3][4];
+        //1D array
+        for (int i = 0; i < intr1.length; i++) {
+            tmp_int1[i] = intr1[i];
+            tmp_String1[i] = strr1[i];
+            tmp_char1[i] = charr1[i];
+            tmp_boolean1[i] = boolr1[i];
+            tmp_byte1[i] = byter1[i];
+            tmp_short1[i] = shortr1[i];
+            tmp_long1[i] = longr1[i];
+            tmp_float1[i] = floatr1[i];
+            tmp_double1[i] = doubler1[i];
+        }
+        //2D array
+        for (int i = 0; i < intr2.length; i++)
+            for(int j = 0; j < intr2[i].length; j++)
+            {
+                tmp_int2[i][j] = intr2[i][j];
+                tmp_String2[i][j] = strr2[i][j];
+                tmp_char2[i][j] = charr2[i][j];
+                tmp_boolean2[i][j] = boolr2[i][j];
+                tmp_byte2[i][j] = byter2[i][j];
+                tmp_short2[i][j] = shortr2[i][j];
+                tmp_long2[i][j] = longr2[i][j];
+                tmp_float2[i][j] = floatr2[i][j];
+                tmp_double2[i][j] = doubler2[i][j];
+            }
+        //3D array
+        for (int i = 0; i < intr3.length; i++)
+            for(int j = 0; j < intr3[i].length; j++)
+                for(int k = 0; k < intr3[i][j].length; k++)
+                {
+                    tmp_int3[i][j][k] = intr3[i][j][k];
+                    tmp_String3[i][j][k] = strr3[i][j][k];
+                    tmp_char3[i][j][k] = charr3[i][j][k];
+                    tmp_boolean3[i][j][k] = boolr3[i][j][k];
+                    tmp_byte3[i][j][k] = byter3[i][j][k];
+                    tmp_short3[i][j][k] = shortr3[i][j][k];
+                    tmp_long3[i][j][k] = longr3[i][j][k];
+                    tmp_float3[i][j][k] = floatr3[i][j][k];
+                    tmp_double3[i][j][k] = doubler3[i][j][k];
+                }
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static void test02() {
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        int [] tmp_int1 = new int[4];
+        int [][] tmp_int2 = new int [3][4];
+        int [][][] tmp_int3 = new int [2][3][4];
+        String [] tmp_String1 = new String[4];
+        String [][] tmp_String2 = new String [3][4];
+        String [][][] tmp_String3 = new String [2][3][4];
+        char [] tmp_char1 = new char[4];
+        char [][] tmp_char2 = new char [3][4];
+        char [][][] tmp_char3 = new char [2][3][4];
+        boolean [] tmp_boolean1 = new boolean[4];
+        boolean [][] tmp_boolean2 = new boolean [3][4];
+        boolean [][][] tmp_boolean3 = new boolean [2][3][4];
+        byte [] tmp_byte1 = new byte[4];
+        byte [][] tmp_byte2 = new byte [3][4];
+        byte [][][] tmp_byte3 = new byte [2][3][4];
+        short [] tmp_short1 = new short[4];
+        short [][] tmp_short2 = new short [3][4];
+        short [][][] tmp_short3 = new short [2][3][4];
+        long [] tmp_long1 = new long[4];
+        long [][] tmp_long2 = new long [3][4];
+        long [][][] tmp_long3 = new long [2][3][4];
+        float [] tmp_float1 = new float[4];
+        float [][] tmp_float2 = new float [3][4];
+        float [][][] tmp_float3 = new float [2][3][4];
+        double [] tmp_double1 = new double[4];
+        double [][] tmp_double2 = new double [3][4];
+        double [][][] tmp_double3 = new double [2][3][4];
+        System.arraycopy(intr1,0,tmp_int1,0,intr1.length);
+        System.arraycopy(intr2,0,tmp_int2,0,intr2.length);
+        System.arraycopy(intr3,0,tmp_int3,0,intr3.length);
+        System.arraycopy(strr1,0,tmp_String1,0,strr1.length);
+        System.arraycopy(strr2,0,tmp_String2,0,strr2.length);
+        System.arraycopy(strr3,0,tmp_String3,0,strr3.length);
+        System.arraycopy(charr1,0,tmp_char1,0,charr1.length);
+        System.arraycopy(charr2,0,tmp_char2,0,charr2.length);
+        System.arraycopy(charr3,0,tmp_char3,0,charr3.length);
+        System.arraycopy(boolr1,0,tmp_boolean1,0,boolr1.length);
+        System.arraycopy(boolr2,0,tmp_boolean2,0,boolr2.length);
+        System.arraycopy(boolr3,0,tmp_boolean3,0,boolr3.length);
+        System.arraycopy(byter1,0,tmp_byte1,0,byter1.length);
+        System.arraycopy(byter2,0,tmp_byte2,0,byter2.length);
+        System.arraycopy(byter3,0,tmp_byte3,0,byter3.length);
+        System.arraycopy(shortr1,0,tmp_short1,0,shortr1.length);
+        System.arraycopy(shortr2,0,tmp_short2,0,shortr2.length);
+        System.arraycopy(shortr3,0,tmp_short3,0,shortr3.length);
+        System.arraycopy(longr1,0,tmp_long1,0,longr1.length);
+        System.arraycopy(longr2,0,tmp_long2,0,longr2.length);
+        System.arraycopy(longr3,0,tmp_long3,0,longr3.length);
+        System.arraycopy(floatr1,0,tmp_float1,0,floatr1.length);
+        System.arraycopy(floatr2,0,tmp_float2,0,floatr2.length);
+        System.arraycopy(floatr3,0,tmp_float3,0,floatr3.length);
+        System.arraycopy(doubler1,0,tmp_double1,0,doubler1.length);
+        System.arraycopy(doubler2,0,tmp_double2,0,doubler2.length);
+        System.arraycopy(doubler3,0,tmp_double3,0,doubler3.length);
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private static void test03()
+    {
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        int [] tmp_int1 = Arrays.copyOf(intr1,intr1.length);
+        int [][] tmp_int2 = Arrays.copyOf(intr2,intr2.length);
+        int [][][] tmp_int3 = Arrays.copyOf(intr3,intr3.length);
+        String [] tmp_String1 = Arrays.copyOf(strr1,strr1.length);
+        String [][] tmp_String2 = Arrays.copyOf(strr2,strr2.length);
+        String [][][] tmp_String3 = Arrays.copyOf(strr3,strr3.length);
+        char [] tmp_char1 = Arrays.copyOf(charr1,charr1.length);
+        char [][] tmp_char2 = Arrays.copyOf(charr2,charr2.length);
+        char [][][] tmp_char3 = Arrays.copyOf(charr3,charr3.length);
+        boolean [] tmp_boolean1 = Arrays.copyOf(boolr1,boolr1.length);
+        boolean [][] tmp_boolean2 = Arrays.copyOf(boolr2,boolr2.length);
+        boolean [][][] tmp_boolean3 = Arrays.copyOf(boolr3,boolr3.length);
+        byte [] tmp_byte1 = Arrays.copyOf(byter1,byter1.length);
+        byte [][] tmp_byte2 = Arrays.copyOf(byter2,byter2.length);
+        byte [][][] tmp_byte3 = Arrays.copyOf(byter3,byter3.length);
+        short [] tmp_short1 = Arrays.copyOf(shortr1,shortr1.length);
+        short [][] tmp_short2 = Arrays.copyOf(shortr2,shortr2.length);
+        short [][][] tmp_short3 = Arrays.copyOf(shortr3,shortr3.length);
+        long [] tmp_long1 = Arrays.copyOf(longr1,longr1.length);
+        long [][] tmp_long2 = Arrays.copyOf(longr2,longr2.length);
+        long [][][] tmp_long3 = Arrays.copyOf(longr3,longr3.length);
+        float [] tmp_float1 = Arrays.copyOf(floatr1,floatr1.length);
+        float [][] tmp_float2 = Arrays.copyOf(floatr2,floatr2.length);
+        float [][][] tmp_float3 = Arrays.copyOf(floatr3,floatr3.length);
+        double [] tmp_double1 = Arrays.copyOf(doubler1,doubler1.length);
+        double [][] tmp_double2 = Arrays.copyOf(doubler2,doubler2.length);
+        double [][][] tmp_double3 = Arrays.copyOf(doubler3,doubler3.length);
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+
+    private static void test04()
+    {
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        int [] tmp_int1 = Arrays.copyOfRange(intr1,0,intr1.length);
+        int [][] tmp_int2 = Arrays.copyOfRange(intr2,0,intr2.length);
+        int [][][] tmp_int3 = Arrays.copyOfRange(intr3,0,intr3.length);
+        String [] tmp_String1 = Arrays.copyOfRange(strr1,0,strr1.length);
+        String [][] tmp_String2 = Arrays.copyOfRange(strr2,0,strr2.length);
+        String [][][] tmp_String3 = Arrays.copyOfRange(strr3,0,strr3.length);
+        char [] tmp_char1 = Arrays.copyOfRange(charr1,0,charr1.length);
+        char [][] tmp_char2 = Arrays.copyOfRange(charr2,0,charr2.length);
+        char [][][] tmp_char3 = Arrays.copyOfRange(charr3,0,charr3.length);
+        boolean [] tmp_boolean1 = Arrays.copyOfRange(boolr1,0,boolr1.length);
+        boolean [][] tmp_boolean2 = Arrays.copyOfRange(boolr2,0,boolr2.length);
+        boolean [][][] tmp_boolean3 = Arrays.copyOfRange(boolr3,0,boolr3.length);
+        byte [] tmp_byte1 = Arrays.copyOfRange(byter1,0,byter1.length);
+        byte [][] tmp_byte2 = Arrays.copyOfRange(byter2,0,byter2.length);
+        byte [][][] tmp_byte3 = Arrays.copyOfRange(byter3,0,byter3.length);
+        short [] tmp_short1 = Arrays.copyOfRange(shortr1,0,shortr1.length);
+        short [][] tmp_short2 = Arrays.copyOfRange(shortr2,0,shortr2.length);
+        short [][][] tmp_short3 = Arrays.copyOfRange(shortr3,0,shortr3.length);
+        long [] tmp_long1 = Arrays.copyOfRange(longr1,0,longr1.length);
+        long [][] tmp_long2 = Arrays.copyOfRange(longr2,0,longr2.length);
+        long [][][] tmp_long3 = Arrays.copyOfRange(longr3,0,longr3.length);
+        float [] tmp_float1 = Arrays.copyOfRange(floatr1,0,floatr1.length);
+        float [][] tmp_float2 = Arrays.copyOfRange(floatr2,0,floatr2.length);
+        float [][][] tmp_float3 = Arrays.copyOfRange(floatr3,0,floatr3.length);
+        double [] tmp_double1 = Arrays.copyOfRange(doubler1,0,doubler1.length);
+        double [][] tmp_double2 = Arrays.copyOfRange(doubler2,0,doubler2.length);
+        double [][][] tmp_double3 = Arrays.copyOfRange(doubler3,0,doubler3.length);
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test04");
+    }
+
+    private static void test05()
+    {
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        int [] tmp_int1 = intr1.clone();
+        int [][] tmp_int2 = intr2.clone();
+        int [][][] tmp_int3 = intr3.clone();
+        String [] tmp_String1 = strr1.clone();
+        String [][] tmp_String2 = strr2.clone();
+        String [][][] tmp_String3 = strr3.clone();
+        char [] tmp_char1 = charr1.clone();
+        char [][] tmp_char2 = charr2.clone();
+        char [][][] tmp_char3 = charr3.clone();
+        boolean [] tmp_boolean1 = boolr1.clone();
+        boolean [][] tmp_boolean2 = boolr2.clone();
+        boolean [][][] tmp_boolean3 = boolr3.clone();
+        byte [] tmp_byte1 = byter1.clone();
+        byte [][] tmp_byte2 = byter2.clone();
+        byte [][][] tmp_byte3 = byter3.clone();
+        short [] tmp_short1 = shortr1.clone();
+        short [][] tmp_short2 = shortr2.clone();
+        short [][][] tmp_short3 = shortr3.clone();
+        long [] tmp_long1 = longr1.clone();
+        long [][] tmp_long2 = longr2.clone();
+        long [][][] tmp_long3 = longr3.clone();
+        float [] tmp_float1 = floatr1.clone();
+        float [][] tmp_float2 = floatr2.clone();
+        float [][][] tmp_float3 = floatr3.clone();
+        double [] tmp_double1 = doubler1.clone();
+        double [][] tmp_double2 = doubler2.clone();
+        double [][][] tmp_double3 = doubler3.clone();
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test05");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/RC_Array_11.java b/test/testsuite/ouroboros/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/RC_Array_11.java
new file mode 100755
index 0000000000000000000000000000000000000000..c3d021a637deb56b8a156699f2d8f00f2e6d0f6b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/RC_Array_11.java
@@ -0,0 +1,380 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_11.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Scenario test for RC optimization: Test String array multi-threaded various scenarios, including:
+ *                   1.Five copy scenarios: loop assignment, System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange(), clone()
+ *                   2.Parameter modification / parameter has not been modified
+ *                   3.final、static
+ *                   4.As a constructor fun
+ *                   5.Function call
+ *                   6.Object Passing param
+ *                   7.return constant; variable; function call
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_11.java
+ *- @ExecuteClass: RC_Array_11
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.io.PrintStream;
+
+public class RC_Array_11 {
+    static int check_count = 0;
+    Thread sb = new Thread();
+    String[] str_base1;
+    String[][] str_base2;
+    String[][][] str_base3;
+    static String[] strr1 = {"'h''e''l''l''o'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"};
+    static String[][] strr2 = {{"'h''e''l''l''o'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''6'"}};
+    static String[][][] strr3 = {{{"'h''e''l''l''o'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''6'"}},
+            {{"'h''u''a''w''e''i'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''6'"}}};
+
+    private static synchronized void intCheckCount() {
+        check_count++;
+    }
+
+    /*The calling function returns a constant value as the assignment of the constant of this function.*/
+    private String[] RC_Array_final01()
+    {
+        final String [] VALUE1 = {"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"};
+        return VALUE1;
+    }
+    private String[][] RC_Array_final02()
+    {
+        final String[][] VALUE2 = {{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"},{"'2''7'"}};
+        return VALUE2;
+    }
+    private String[][][] RC_Array_final03()
+    {
+        final String[][][] VALUE3 = {{{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"}, {"'2''7'"}},
+                {{"'h''u''a''w''e''i'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''7'"}}};
+        return VALUE3;
+    }
+
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled.*/
+        if(strr1.length == 4 && strr2.length == 3 && strr3.length == 2)
+            intCheckCount();
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+
+    public String  run(String argv[],PrintStream out) throws InterruptedException {
+        String result = "Error"; /*STATUS_FAILED*/
+        //Initialization check
+        check("initialization");
+        //Scene test
+        Thread t1 = new Thread(new test01());
+        Thread t2 = new Thread(new test02());
+        Thread t3 = new Thread(new test03());
+        Thread t4 = new Thread(new test04());
+        Thread t5 = new Thread(new test05());
+        Thread t6 = new Thread(new test06());
+        Thread t7 = new Thread(new test07());
+        Thread t8 = new Thread(new test08());
+        Thread t9 = new Thread(new test09());
+        //Copy scene multithreading
+        t1.start();t2.start();t3.start();t4.start();t5.start();
+        t1.join();t2.join();t3.join();t4.join();t5.join();
+        //Other scene
+        t6.start();t7.start();t8.start();
+        t6.join();t7.join();t8.join();
+        //Exception scene
+        t9.start();
+        t9.join();
+
+        check("End");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 14)
+            result = "ExpectResult";
+        return result;
+    }
+
+    public static void main(String argv[]) {
+        try {
+            System.out.println(new RC_Array_11().run(argv, System.out));
+        }catch (Exception e)
+        {
+            System.out.println(e);
+        }
+    }
+
+    private class test01 implements Runnable{
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        private void method01() {
+            String [] tmp_String1 = new String[4];
+            String [][] tmp_String2 = new String [3][4];
+            String [][][] tmp_String3 = new String [2][3][4];
+            //1D array
+            for (int i = 0; i < strr1.length; i++) {
+                tmp_String1[i] = strr1[i];
+            }
+            //2D array
+            for (int i = 0; i < strr2.length; i++)
+                for(int j = 0; j < strr2[i].length; j++)
+                {
+                    tmp_String2[i][j] = strr2[i][j];
+                }
+            //3D array
+            for (int i = 0; i < strr3.length; i++)
+                for(int j = 0; j < strr3[i].length; j++)
+                    for(int k = 0; k < strr3[i][j].length; k++)
+                    {
+                        tmp_String3[i][j][k] = strr3[i][j][k];
+                    }
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                    intCheckCount();
+            else
+                System.out.println("ErrorResult in test01");
+        }
+        public void run()
+        {
+            method01();
+        }
+    }
+
+    private class test02 implements Runnable{
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        private void method02() {
+            String [] tmp_String1 = new String[4];
+            String [][] tmp_String2 = new String [3][4];
+            String [][][] tmp_String3 = new String [2][3][4];
+            System.arraycopy(strr1,0,tmp_String1,0,strr1.length);
+            System.arraycopy(strr2,0,tmp_String2,0,strr2.length);
+            System.arraycopy(strr3,0,tmp_String3,0,strr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test02");
+        }
+        public void run()
+        {
+            method02();
+        }
+    }
+
+    private class test03 implements Runnable{
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        private void method03()
+        {
+            String [] tmp_String1 = Arrays.copyOf(strr1,strr1.length);
+            String [][] tmp_String2 = Arrays.copyOf(strr2,strr2.length);
+            String [][][] tmp_String3 = Arrays.copyOf(strr3,strr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test03");
+        }
+        public void run()
+        {
+            method03();
+        }
+    }
+
+    private class test04 implements Runnable{
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        private void method04()
+        {
+            String [] tmp_String1 = Arrays.copyOfRange(strr1,0,strr1.length);
+            String [][] tmp_String2 = Arrays.copyOfRange(strr2,0,strr2.length);
+            String [][][] tmp_String3 = Arrays.copyOfRange(strr3,0,strr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test04");
+        }
+        public void run()
+        {
+            method04();
+        }
+    }
+
+    private class test05 implements Runnable{
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        private void method05()
+        {
+            String [] tmp_String1 = strr1.clone();
+            String [][] tmp_String2 = strr2.clone();
+            String [][][] tmp_String3 = strr3.clone();
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test05");
+        }
+        public void run()
+        {
+            method05();
+        }
+    }
+
+    private class test06 implements Runnable{
+        /*test06Interface call, internal initialization array, do not modify parameter values, only judge*/
+        private void method06(String[] arr_str1, String[][] arr_str2, String[][][] arr_str3)
+        {
+            String[] tmp_String1 = {"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"};
+            String[][] tmp_String2 = {{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"},{"'2''7'"}};
+            String[][][] tmp_String3 = {{{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"}, {"'2''7'"}},
+                    {{"'h''u''a''w''e''i'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''7'"}}};
+            //Check the values defined in the function
+            if(tmp_String1[3] == "'h''a''l''l''y'" && tmp_String2[2][0] == "'2''7'" && tmp_String3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step1");
+            //Check unmodified parameter values
+            if(arr_str1[3]== "'a''r''r''a''y'" && arr_str2[2][0] == "'2''6'" && arr_str3[1][2][0] == "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step2");
+        }
+        public void run()
+        {
+            method06(strr1, strr2, strr3);
+        }
+    }
+
+    private class test07 implements Runnable{
+        /*test07 Interface call, call function change to modify the parameter value and judge*/
+        private Object change(Object temp1, Object temp2){
+            temp1 = temp2;
+            return temp1;
+        }
+
+        private void method07(String[] arr_str1, String[][] arr_str2, String[][][] arr_str3) {
+            String[] strr1 = {"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"};
+            String[][] strr2 = {{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"},{"'2''7'"}};
+            String[][][] strr3 = {{{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"}, {"'2''7'"}},
+                    {{"'h''u''a''w''e''i'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''7'"}}};
+            arr_str1 = (String[]) change(arr_str1,strr1);
+            arr_str2 = (String[][])change(arr_str2,strr2);
+            arr_str3 = (String[][][]) change(arr_str3,strr3);
+            //Check the values defined in the function
+            if(strr1[3] == "'h''a''l''l''y'" && strr2[2][0] == "'2''7'" && strr3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step1");
+            //Check the modified parameter values
+            if(arr_str1[3]== "'h''a''l''l''y'" && arr_str2[2][0] == "'2''7'" && arr_str3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step2");
+        }
+        public void run()
+        {
+            method07(strr1,strr2,strr3);
+        }
+    }
+
+    private class test08 implements Runnable{
+        /*Call the no-argument constructor, initialize the variables of the parent class, and assign values to the
+        fields of the newly created object, and judge the result*/
+        private void method08() {
+            final String [] VALUE1 = RC_Array_final01();
+            final String[][] VALUE2 = RC_Array_final02();
+            final String[][][] VALUE3 = RC_Array_final03();
+            RC_Array_11 rctest = new RC_Array_11();
+            rctest.str_base1 = VALUE1;
+            rctest.str_base2 = VALUE2;
+            rctest.str_base3 = VALUE3;
+            //Check the values defined in the function
+            if(VALUE1[3] == "'h''a''l''l''y'" && VALUE2[2][0] == "'2''7'" && VALUE3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step1");
+            //Check the modified parameter values
+            if(rctest.str_base1[3]== "'h''a''l''l''y'" && rctest.str_base2[2][0] == "'2''7'" && rctest.str_base3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step2");
+
+        }
+        public void run()
+        {
+            method08();
+        }
+    }
+
+    private  class test09 implements Runnable{
+        /*Exception test*/
+        private synchronized void method09(){
+            int check = 0;
+            String [] value1 = RC_Array_final01();
+            String[][] value2 = RC_Array_final02();
+            String[][][] value3 = RC_Array_final03();
+            //Is the value judged after the assignment?
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+
+            //ArrayIndexOutOfBoundsException
+            try {
+                value1[5] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value2[5][0] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value3[3][3][0] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            //Whether the judgment value is normal after the abnormality
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+
+            //NullPointerException
+            value1 = null;
+            value2 = null;
+            value3 = null;
+            try {
+                Array.get(value1, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.get(value2, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.get(value3, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+
+            //System.out.println(check);
+            if (check == 8)
+                intCheckCount();
+            else
+                System.out.println("End: ErrorResult in test09");
+        }
+        public void run()
+        {
+            method09();
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/RC_Array_12.java b/test/testsuite/ouroboros/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/RC_Array_12.java
new file mode 100755
index 0000000000000000000000000000000000000000..ce9c78429204ea4acabb19c851317f1cd4f3870a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/RC_Array_12.java
@@ -0,0 +1,381 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_12.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Scenario test for RC optimization: Test Object array multi-threaded various scenarios, including:
+ *                   1.Five copy scenarios: loop assignment, System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange(), clone()
+ *                   2.Parameter modification / parameter has not been modified
+ *                   3.final、static
+ *                   4.As a constructor fun
+ *                   5.Function call
+ *                   6.Object Passing param
+ *                   7.return constant; variable; function call
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_12.java
+ *- @ExecuteClass: RC_Array_12
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.io.PrintStream;
+
+public class RC_Array_12 {
+    static int check_count = 0;
+    Thread sb = new Thread();
+    Object[] obj_base1;
+    Object[][] obj_base2;
+    Object[][][] obj_base3;
+    static Object[] objr1 = {'a','b','c','d'};
+    static Object[][] objr2 = {{'a','b','c','d'},{'e','f'},{'g'}};
+    static Object[][][] objr3 = {{{'a','b','c','d'},{'e','f'},{'g'}},{{'h','i','j','k'},{'l','m'},{'n'}}};
+
+    private static synchronized void incCheckCount() {
+      check_count++;
+    }
+
+    /*The calling function returns a constant value as the assignment of the constant of this function.*/
+    private Object[] RC_Array_final04()
+    {
+        final Object [] VALUE4 = {'b','s','d','g'};
+        return VALUE4;
+    }
+    private Object[][] RC_Array_final05()
+    {
+        final Object[][] VALUE5 = {{'b','s','d','g'},{'e','f'},{'s'}};
+        return VALUE5;
+    }
+    private Object[][][] RC_Array_final06()
+    {
+        final Object[][][] VALUE6 = {{{'b','s','d','g'},{'e','f'},{'s'}},{{'h','i','j','k'},{'l','m'},{'a'}}};
+        return VALUE6;
+    }
+
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled.*/
+        if(objr1.length == 4 && objr2.length == 3 && objr3.length == 2)
+            incCheckCount();
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+
+    public String  run(String argv[],PrintStream out) throws InterruptedException {
+        String result = "Error"; /*STATUS_FAILED*/
+        //Initialization check
+        check("initialization");
+        //Scene test
+        Thread t1 = new Thread(new test01());
+        Thread t2 = new Thread(new test02());
+        Thread t3 = new Thread(new test03());
+        Thread t4 = new Thread(new test04());
+        Thread t5 = new Thread(new test05());
+        Thread t6 = new Thread(new test06());
+        Thread t7 = new Thread(new test07());
+        Thread t8 = new Thread(new test08());
+        Thread t9 = new Thread(new test09());
+        //Copy scene multithreading
+        t1.start();t2.start();t3.start();t4.start();t5.start();
+        t1.join();t2.join();t3.join();t4.join();t5.join();
+        //Other scene
+        t6.start();t7.start();t8.start();
+        t6.join();t7.join();t8.join();
+        //Exception scene
+        t9.start();
+        t9.join();
+
+        check("End");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 14)
+            result = "ExpectResult";
+        return result;
+    }
+
+    public static void main(String argv[]) {
+        try {
+            System.out.println(new RC_Array_12().run(argv, System.out));
+        }catch (Exception e)
+        {
+            System.out.println(e);
+        }
+    }
+
+    private class test01 implements Runnable{
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        private void method01() {
+            Object [] tmp_obj1 = new Object[4];
+            Object [][] tmp_obj2 = new Object [3][4];
+            Object [][][] tmp_obj3 = new Object [2][3][4];
+            //1D array
+            for (int i = 0; i < objr1.length; i++) {
+                tmp_obj1[i] = objr1[i];
+            }
+            //2D array
+            for (int i = 0; i < objr2.length; i++)
+                for(int j = 0; j < objr2[i].length; j++)
+                {
+                    tmp_obj2[i][j] = objr2[i][j];
+                }
+            //3D array
+            for (int i = 0; i < objr3.length; i++)
+                for(int j = 0; j < objr3[i].length; j++)
+                    for(int k = 0; k < objr3[i][j].length; k++)
+                    {
+                        tmp_obj3[i][j][k] = objr3[i][j][k];
+                    }
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test01");
+        }
+
+        public void run()
+        {
+            method01();
+        }
+    }
+
+    private class test02 implements Runnable{
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        private void method02() {
+            Object [] tmp_obj1 = new Object[4];
+            Object [][] tmp_obj2 = new Object [3][4];
+            Object [][][] tmp_obj3 = new Object [2][3][4];
+            System.arraycopy(objr1,0,tmp_obj1,0,objr1.length);
+            System.arraycopy(objr2,0,tmp_obj2,0,objr2.length);
+            System.arraycopy(objr3,0,tmp_obj3,0,objr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test02");
+        }
+
+        public void run()
+        {
+            method02();
+        }
+    }
+
+    private class test03 implements Runnable{
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        private void method03()
+        {
+            Object [] tmp_obj1 = Arrays.copyOf(objr1,objr1.length);
+            Object [][] tmp_obj2 = Arrays.copyOf(objr2,objr2.length);
+            Object [][][] tmp_obj3 = Arrays.copyOf(objr3,objr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test03");
+        }
+        public void run()
+        {
+            method03();
+        }
+    }
+
+    private class test04 implements Runnable{
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        private void method04()
+        {
+            Object [] tmp_obj1 = Arrays.copyOfRange(objr1,0,objr1.length);
+            Object [][] tmp_obj2 = Arrays.copyOfRange(objr2,0,objr2.length);
+            Object [][][] tmp_obj3 = Arrays.copyOfRange(objr3,0,objr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test04");
+        }
+
+        public void run()
+        {
+            method04();
+        }
+    }
+
+    private class test05 implements Runnable{
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        private void method05()
+        {
+            Object [] tmp_obj1 = objr1.clone();
+            Object [][] tmp_obj2 = objr2.clone();
+            Object [][][] tmp_obj3 = objr3.clone();
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test05");
+        }
+        public void run()
+        {
+            method05();
+        }
+    }
+
+    private class test06 implements Runnable{
+        /*test06Interface call, internal initialization array, do not modify parameter values, only judge*/
+        private void method06(Object[] arr_obj1, Object[][] arr_obj2, Object[][][] arr_obj3)
+        {
+            Object[] tmp_obj1 = {'b','s','d','g'};
+            Object[][] tmp_obj2 = {{'b','s','d','g'},{'e','f'},{'s'}};
+            Object[][][] tmp_obj3 = {{{'b','s','d','g'},{'e','f'},{'s'}},{{'h','i','j','k'},{'l','m'},{'a'}}};
+            //Check the values defined in the function
+            if(tmp_obj1[3] == (Object)'g' && tmp_obj2[2][0] == (Object)'s' && tmp_obj3[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step1");
+            //Check unmodified parameter values
+            if(arr_obj1[3] == (Object)'d' && arr_obj2[2][0] == (Object)'g'  && arr_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step2");
+        }
+        public void run()
+        {
+            method06(objr1,objr2,objr3);
+        }
+    }
+
+    private class test07 implements Runnable{
+        /*test07 Interface call, call function change to modify the parameter value and judge*/
+        private Object change(Object temp1, Object temp2){
+            temp1 = temp2;
+            return temp1;
+        }
+
+        private void method07(Object[] arr_obj1, Object[][] arr_obj2, Object[][][] arr_obj3) {
+            Object[] objr1 = {'b','s','d','g'};
+            Object[][] objr2 = {{'b','s','d','g'},{'e','f'},{'s'}};
+            Object[][][] objr3 = {{{'b','s','d','g'},{'e','f'},{'s'}},{{'h','i','j','k'},{'l','m'},{'a'}}};
+            arr_obj1 = (Object[]) change(arr_obj1,objr1);
+            arr_obj2 = (Object[][])change(arr_obj2,objr2);
+            arr_obj3 = (Object[][][]) change(arr_obj3,objr3);
+            //Check the values defined in the function
+            if(objr1[3] == (Object)'g' && objr2[2][0] == (Object)'s' && objr3[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step1");
+            //Check the modified parameter values
+            if(arr_obj1[3] == (Object)'g' && arr_obj2[2][0] == (Object)'s'  && arr_obj3[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step2");
+        }
+        public void run()
+        {
+            method07(objr1,objr2,objr3);
+        }
+    }
+
+    private class test08 implements Runnable{
+        /*Call the no-argument constructor, initialize the variables of the parent class, and assign values to the
+        fields of the newly created object, and judge the result*/
+        private void method08() {
+            final Object [] VALUE4 = RC_Array_final04();
+            final Object[][] VALUE5 = RC_Array_final05();
+            final Object[][][] VALUE6 = RC_Array_final06();
+            RC_Array_12 rctest = new RC_Array_12();
+            rctest.obj_base1 = VALUE4;
+            rctest.obj_base2 = VALUE5;
+            rctest.obj_base3 = VALUE6;
+            //Check the values defined in the function
+            if(VALUE4[3] == (Object)'g' && VALUE5[2][0] == (Object)'s' && VALUE6[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step1");
+            //Check the modified parameter values
+            if(rctest.obj_base1[3] == (Object)'g' && rctest.obj_base2[2][0] == (Object)'s'  && rctest.obj_base3[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step2");
+
+        }
+        public void run()
+        {
+            method08();
+        }
+    }
+
+    private class test09 implements Runnable{
+        /*Exception test*/
+        private void method09(){
+            int check = 0;
+            Object [] value1 = RC_Array_final04();
+            Object[][] value2 = RC_Array_final05();
+            Object[][][] value3 = RC_Array_final06();
+            //Is the value judged after the assignment?
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+
+            //ArrayIndexOutOfBoundsException
+            try {
+                value1[5] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value2[5][0] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value3[3][3][0] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            //Whether the judgment value is normal after the abnormality
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+
+            //NullPointerException
+            value1 = null;
+            value2 = null;
+            value3 = null;
+            try {
+                Array.get(value1, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.get(value2, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.get(value3, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+
+            //System.out.println(check);
+            if (check == 8)
+                incCheckCount();
+            else
+                System.out.println("End: ErrorResult in test09");
+        }
+
+        public void run()
+        {
+            method09();
+        }
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/RC_Array_13.java b/test/testsuite/ouroboros/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/RC_Array_13.java
new file mode 100755
index 0000000000000000000000000000000000000000..834b7ee3a9a516776f4bba0fcf19728088bb90e2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/RC_Array_13.java
@@ -0,0 +1,387 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_13.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Scenario test for RC optimization: Test boolean array multi-threaded various scenarios, including:
+ *                   1.Five copy scenarios: loop assignment, System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange(), clone()
+ *                   2.Parameter modification / parameter has not been modified
+ *                   3.final、static
+ *                   4.As a constructor fun
+ *                   5.Function call
+ *                   6.Object Passing param
+ *                   7.return constant; variable; function call
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_13.java
+ *- @ExecuteClass: RC_Array_13
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.io.PrintStream;
+
+public class RC_Array_13 {
+    static int check_count = 0;
+    Thread sb = new Thread();
+    boolean[] bool_base1;
+    boolean[][] bool_base2;
+    boolean[][][] bool_base3;
+    static boolean[] boolr1 = {true,false,false,true};
+    static boolean[][] boolr2 = {{true,false,false,true},{false,false},{true}};
+    static boolean[][][] boolr3 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{false}}};
+
+    private static synchronized void incCheckCount() {
+      check_count++;
+    }
+
+    /*The calling function returns a constant value as the assignment of the constant of this function.*/
+    private boolean[] RC_Array_final07()
+    {
+        final boolean [] VALUE7 = {true,false,false,false};
+        return VALUE7;
+    }
+    private boolean[][] RC_Array_final08()
+    {
+        final boolean[][] VALUE8 = {{true,false,false,true},{false,false},{false}};
+        return VALUE8;
+    }
+    private boolean[][][] RC_Array_final09()
+    {
+        final boolean[][][] VALUE9 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{true}}};
+        return VALUE9;
+    }
+
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled.*/
+        if(boolr1.length == 4 && boolr2.length == 3 && boolr3.length == 2)
+            incCheckCount();
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+
+    public String  run(String argv[],PrintStream out) throws InterruptedException {
+        String result = "Error"; /*STATUS_FAILED*/
+        //Initialization check
+        check("initialization");
+        //Scene test
+        Thread t1 = new Thread(new test01());
+        Thread t2 = new Thread(new test02());
+        Thread t3 = new Thread(new test03());
+        Thread t4 = new Thread(new test04());
+        Thread t5 = new Thread(new test05());
+        Thread t6 = new Thread(new test06());
+        Thread t7 = new Thread(new test07());
+        Thread t8 = new Thread(new test08());
+        Thread t9 = new Thread(new test09());
+        //Copy scene multithreading
+        t1.start();t2.start();t3.start();t4.start();t5.start();
+        t1.join();t2.join();t3.join();t4.join();t5.join();
+        //Other scene
+        t6.start();t7.start();t8.start();
+        t6.join();t7.join();t8.join();
+        //Exception scene
+        t9.start();
+        t9.join();
+
+        check("End");
+        //Result judgment
+        if(check_count == 14)
+            result = "ExpectResult";
+        return result;
+    }
+
+    public static void main(String argv[]) {
+        try {
+            System.out.println(new RC_Array_13().run(argv, System.out));
+        }catch (Exception e)
+        {
+            System.out.println(e);
+        }
+    }
+
+    private class test01 implements Runnable{
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        private void method01() {
+            boolean [] tmp_boolean1 = new boolean[4];
+            boolean [][] tmp_boolean2 = new boolean [3][4];
+            boolean [][][] tmp_boolean3 = new boolean [2][3][4];
+            //1D array
+            for (int i = 0; i < boolr1.length; i++) {
+                tmp_boolean1[i] = boolr1[i];
+            }
+            //2D array
+            for (int i = 0; i < boolr2.length; i++)
+                for(int j = 0; j < boolr2[i].length; j++)
+                {
+                    tmp_boolean2[i][j] = boolr2[i][j];
+                }
+            //3D array
+            for (int i = 0; i < boolr3.length; i++)
+                for(int j = 0; j < boolr3[i].length; j++)
+                    for(int k = 0; k < boolr3[i][j].length; k++)
+                    {
+                        tmp_boolean3[i][j][k] = boolr3[i][j][k];
+                    }
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false) {
+                    incCheckCount();
+            }
+            else
+                System.out.println("ErrorResult in test01");
+        }
+        public void run()
+        {
+            method01();
+        }
+    }
+
+    private class test02 implements Runnable{
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        private void method02() {
+            boolean [] tmp_boolean1 = new boolean[4];
+            boolean [][] tmp_boolean2 = new boolean [3][4];
+            boolean [][][] tmp_boolean3 = new boolean [2][3][4];
+            System.arraycopy(boolr1,0,tmp_boolean1,0,boolr1.length);
+            System.arraycopy(boolr2,0,tmp_boolean2,0,boolr2.length);
+            System.arraycopy(boolr3,0,tmp_boolean3,0,boolr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test02");
+        }
+        public void run()
+        {
+            method02();
+        }
+    }
+
+    private class test03 implements Runnable{
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        private void method03()
+        {
+            boolean [] tmp_boolean1 = Arrays.copyOf(boolr1,boolr1.length);
+            boolean [][] tmp_boolean2 = Arrays.copyOf(boolr2,boolr2.length);
+            boolean [][][] tmp_boolean3 = Arrays.copyOf(boolr3,boolr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test03");
+        }
+        public void run()
+        {
+            method03();
+        }
+    }
+
+    private class test04 implements Runnable{
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        private void method04()
+        {
+            boolean [] tmp_boolean1 = Arrays.copyOfRange(boolr1,0,boolr1.length);
+            boolean [][] tmp_boolean2 = Arrays.copyOfRange(boolr2,0,boolr2.length);
+            boolean [][][] tmp_boolean3 = Arrays.copyOfRange(boolr3,0,boolr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test04");
+        }
+        public void run()
+        {
+            method04();
+        }
+    }
+
+    private class test05 implements Runnable{
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        private void method05()
+        {
+            boolean [] tmp_boolean1 = boolr1.clone();
+            boolean [][] tmp_boolean2 = boolr2.clone();
+            boolean [][][] tmp_boolean3 = boolr3.clone();
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test05");
+        }
+        public void run()
+        {
+            method05();
+        }
+    }
+
+    private class test06 implements Runnable{
+        /*test06Interface call, internal initialization array, do not modify parameter values, only judge*/
+        private void method06(boolean[] arr_bool1, boolean[][] arr_bool2, boolean[][][] arr_bool3)
+        {
+            boolean[] tmp_boolean1 = {true,false,false,false};
+            boolean[][] tmp_boolean2 = {{true,false,false,true},{false,false},{false}};
+            boolean[][][] tmp_boolean3 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{true}}};
+            //Check the values defined in the function
+            if(tmp_boolean1[3] == false && tmp_boolean2[2][0] == false && tmp_boolean3[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step1");
+            //Check unmodified parameter values
+            if(arr_bool1[3] == true && arr_bool2[2][0] == true && arr_bool3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step2");
+        }
+        public void run()
+        {
+            method06(boolr1, boolr2, boolr3);
+        }
+    }
+
+    private class test07 implements Runnable{
+        /*test07 Interface call, call function change to modify the parameter value and judge*/
+        private Object change(Object temp1, Object temp2){
+            temp1 = temp2;
+            return temp1;
+        }
+
+        private void method07(boolean[] arr_bool1, boolean[][] arr_bool2,boolean[][][] arr_bool3) {
+            boolean[] boolr1 = {true,false,false,false};
+            boolean[][] boolr2 = {{true,false,false,true},{false,false},{false}};
+            boolean[][][] boolr3 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{true}}};
+            arr_bool1 = (boolean[]) change(arr_bool1,boolr1);
+            arr_bool2 = (boolean[][])change(arr_bool2,boolr2);
+            arr_bool3 = (boolean[][][]) change(arr_bool3,boolr3);
+            //Check the values defined in the function
+            if(boolr1[3] == false && boolr2[2][0] == false && boolr3[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step1");
+            //Check the modified parameter values
+            if(arr_bool1[3] == false && arr_bool2[2][0] == false && arr_bool3[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step2");
+        }
+        public void run()
+        {
+            method07(boolr1,boolr2,boolr3);
+        }
+    }
+
+    private class test08 implements Runnable{
+        /*Call the no-argument constructor, initialize the variables of the parent class, and assign values to the
+        fields of the newly created object, and judge the result*/
+        private void method08() {
+            final boolean [] VALUE7 = RC_Array_final07();
+            final boolean[][] VALUE8 = RC_Array_final08();
+            final boolean[][][] VALUE9 = RC_Array_final09();
+            RC_Array_13 rctest = new RC_Array_13();
+            rctest.bool_base1 = VALUE7;
+            rctest.bool_base2 = VALUE8;
+            rctest.bool_base3 = VALUE9;
+            //Check the values defined in the function
+            if(VALUE7[3] == false && VALUE8[2][0] == false && VALUE9[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step1");
+            //Check the modified parameter values
+            if(rctest.bool_base1[3] == false && rctest.bool_base2[2][0] == false && rctest.bool_base3[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step2");
+
+        }
+        public void run()
+        {
+            method08();
+        }
+    }
+
+    private  class test09 implements Runnable{
+        /*Exception test*/
+        private synchronized void method09(){
+            int check = 0;
+            boolean [] value1 = RC_Array_final07();
+            boolean[][] value2 = RC_Array_final08();
+            boolean[][][] value3 = RC_Array_final09();
+            //Is the value judged after the assignment?
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+
+            //ArrayIndexOutOfBoundsException
+            try {
+                value1[5] = true;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value2[5][0] = true;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value3[3][3][0] = true;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            //IllegalArgumentException
+            try {
+                Array.getBoolean(value2,1);
+            }catch (IllegalArgumentException e){
+                check++;
+            }
+            try {
+                Array.getBoolean(value3,1);
+            }catch (IllegalArgumentException e){
+                check++;
+            }
+            //Whether the judgment value is normal after the abnormality
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+
+            //NullPointerException
+            value1 = null;
+            value2 = null;
+            value3 = null;
+            try {
+                Array.getBoolean(value1, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.getBoolean(value2, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.getBoolean(value3, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+
+            //System.out.println(check);
+            if (check == 10)
+                incCheckCount();
+            else
+                System.out.println("End: ErrorResult in test09");
+        }
+        public void run()
+        {
+            method09();
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/RC_Array_14.java b/test/testsuite/ouroboros/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/RC_Array_14.java
new file mode 100755
index 0000000000000000000000000000000000000000..7bbf3a55f52f3d64fdd463915b384bc8aa4ad222
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/RC_Array_14.java
@@ -0,0 +1,387 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/optimization/RC_Array_14.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Scenario test for RC optimization: Test double array multi-threaded various scenarios, including:
+ *                   1.Five copy scenarios: loop assignment, System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange(), clone()
+ *                   2.Parameter modification / parameter has not been modified
+ *                   3.final、static
+ *                   4.As a constructor fun
+ *                   5.Function call
+ *                   6.Object Passing param
+ *                   7.return constant; variable; function call
+ *                   8.Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RC_Array_14.java
+ *- @ExecuteClass: RC_Array_14
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.io.PrintStream;
+
+public class RC_Array_14 {
+    static int check_count = 0;
+    Thread sb = new Thread();
+    double[] double_base1;
+    double[][] double_base2;
+    double[][][] double_base3;
+    static double[] doubler1 = {1.1f,2.2f,3.3f,4.4f};
+    static double[][] doubler2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}};
+    static double[][][] doubler3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}}};
+
+    private static synchronized void incCheckCount() {
+      check_count++;
+    }
+
+    /*The calling function returns a constant value as the assignment of the constant of this function.*/
+    private double[] RC_Array_final10()
+    {
+        final double [] VALUE7 = {1.1f,2.2f,3.3f,4.8f};
+        return VALUE7;
+    }
+    private double[][] RC_Array_final11()
+    {
+        final double[][] VALUE8 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{2.7f}};
+        return VALUE8;
+    }
+    private double[][][] RC_Array_final12()
+    {
+        final double[][][] VALUE9 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.9f}}};
+        return VALUE9;
+    }
+
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled.*/
+        if(doubler1.length == 4 && doubler2.length == 3 && doubler3.length == 2)
+            incCheckCount();
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+
+    public String  run(String argv[],PrintStream out) throws InterruptedException {
+        String result = "Error"; /*STATUS_FAILED*/
+        //Initialization check
+        check("initialization");
+        //Scene test
+        Thread t1 = new Thread(new test01());
+        Thread t2 = new Thread(new test02());
+        Thread t3 = new Thread(new test03());
+        Thread t4 = new Thread(new test04());
+        Thread t5 = new Thread(new test05());
+        Thread t6 = new Thread(new test06());
+        Thread t7 = new Thread(new test07());
+        Thread t8 = new Thread(new test08());
+        Thread t9 = new Thread(new test09());
+        //Copy scene multithreading
+        t1.start();t2.start();t3.start();t4.start();t5.start();
+        t1.join();t2.join();t3.join();t4.join();t5.join();
+        //Other scene
+        t6.start();t7.start();t8.start();
+        t6.join();t7.join();t8.join();
+        //Exception scene
+        t9.start();
+        t9.join();
+
+        check("End");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 14)
+            result = "ExpectResult";
+        return result;
+    }
+
+    public static void main(String argv[]) {
+        try {
+            System.out.println(new RC_Array_14().run(argv, System.out));
+        }catch (Exception e)
+        {
+            System.out.println(e);
+        }
+    }
+
+    private class test01 implements Runnable{
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        private void method01() {
+            double [] tmp_double1 = new double[4];
+            double [][] tmp_double2 = new double [3][4];
+            double [][][] tmp_double3 = new double [2][3][4];
+            //1D array
+            for (int i = 0; i < doubler1.length; i++) {
+                tmp_double1[i] = doubler1[i];
+            }
+            //2D array
+            for (int i = 0; i < doubler2.length; i++)
+                for(int j = 0; j < doubler2[i].length; j++)
+                {
+                    tmp_double2[i][j] = doubler2[i][j];
+                }
+            //3D array
+            for (int i = 0; i < doubler3.length; i++)
+                for(int j = 0; j < doubler3[i].length; j++)
+                    for(int k = 0; k < doubler3[i][j].length; k++)
+                    {
+                        tmp_double3[i][j][k] = doubler3[i][j][k];
+                    }
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                    incCheckCount();
+            else
+                System.out.println("ErrorResult in test01");
+        }
+        public void run()
+        {
+            method01();
+        }
+    }
+
+    private class test02 implements Runnable{
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        private void method02() {
+            double [] tmp_double1 = new double[4];
+            double [][] tmp_double2 = new double [3][4];
+            double [][][] tmp_double3 = new double [2][3][4];
+            System.arraycopy(doubler1,0,tmp_double1,0,doubler1.length);
+            System.arraycopy(doubler2,0,tmp_double2,0,doubler2.length);
+            System.arraycopy(doubler3,0,tmp_double3,0,doubler3.length);
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test02");
+        }
+        public void run()
+        {
+            method02();
+        }
+    }
+
+    private class test03 implements Runnable{
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        private void method03()
+        {
+            double [] tmp_double1 = Arrays.copyOf(doubler1,doubler1.length);
+            double [][] tmp_double2 = Arrays.copyOf(doubler2,doubler2.length);
+            double [][][] tmp_double3 = Arrays.copyOf(doubler3,doubler3.length);
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test03");
+        }
+        public void run()
+        {
+            method03();
+        }
+    }
+
+    private class test04 implements Runnable{
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        private void method04()
+        {
+            double [] tmp_double1 = Arrays.copyOfRange(doubler1,0,doubler1.length);
+            double [][] tmp_double2 = Arrays.copyOfRange(doubler2,0,doubler2.length);
+            double [][][] tmp_double3 = Arrays.copyOfRange(doubler3,0,doubler3.length);
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test04");
+        }
+        public void run()
+        {
+            method04();
+        }
+    }
+
+    private class test05 implements Runnable{
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        private void method05()
+        {
+            double [] tmp_double1 = doubler1.clone();
+            double [][] tmp_double2 = doubler2.clone();
+            double [][][] tmp_double3 = doubler3.clone();
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test05");
+        }
+        public void run()
+        {
+            method05();
+        }
+    }
+
+    private class test06 implements Runnable{
+        /*test06Interface call, internal initialization array, do not modify parameter values, only judge*/
+        private void method06(double[] arr_dou1, double[][] arr_dou2, double[][][] arr_dou3)
+        {
+            double[] tmp_double1 = {1.1f,2.2f,3.3f,4.8f};
+            double[][] tmp_double2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{2.7f}};
+            double[][][] tmp_double3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.9f}}};
+            //Check the values defined in the function
+            if(tmp_double1[3] == 4.8f && tmp_double2[2][0] == 2.7f && tmp_double3[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step1");
+            //Check unmodified parameter values
+            if(arr_dou1[3] == 4.4f && arr_dou2[2][0] == 7.7f && arr_dou3[1][2][0] == 10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step2");
+        }
+        public void run()
+        {
+            method06(doubler1, doubler2, doubler3);
+        }
+    }
+
+    private class test07 implements Runnable{
+        /*test07 Interface call, call function change to modify the parameter value and judge*/
+        private Object change(Object temp1, Object temp2){
+            temp1 = temp2;
+            return temp1;
+        }
+
+        private void method07(double[] arr_dou1, double[][] arr_dou2, double[][][] arr_dou3) {
+            double[] doubler1 = {1.1f,2.2f,3.3f,4.8f};
+            double[][] doubler2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{2.7f}};
+            double[][][] doubler3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.9f}}};
+            arr_dou1 = (double[]) change(arr_dou1,doubler1);
+            arr_dou2 = (double[][])change(arr_dou2,doubler2);
+            arr_dou3 = (double[][][]) change(arr_dou3,doubler3);
+            //Check the values defined in the function
+            if(doubler1[3] == 4.8f && doubler2[2][0] == 2.7f && doubler3[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step1");
+            //Check the modified parameter values
+            if(arr_dou1[3] == 4.8f && arr_dou2[2][0] == 2.7f && arr_dou3[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step2");
+        }
+        public void run()
+        {
+            method07(doubler1,doubler2,doubler3);
+        }
+    }
+
+    private class test08 implements Runnable{
+        /*Call the no-argument constructor, initialize the variables of the parent class, and assign values to the
+        fields of the newly created object, and judge the result*/
+        private void method08() {
+            final double [] VALUE10 = RC_Array_final10();
+            final double[][] VALUE11 = RC_Array_final11();
+            final double[][][] VALUE12 = RC_Array_final12();
+            RC_Array_14 rctest = new RC_Array_14();
+            rctest.double_base1 = VALUE10;
+            rctest.double_base2 = VALUE11;
+            rctest.double_base3 = VALUE12;
+            //Check the values defined in the function
+            if(VALUE10[3] == 4.8f && VALUE11[2][0] == 2.7f && VALUE12[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step1");
+            //Check the modified parameter values
+            if(rctest.double_base1[3] == 4.8f && rctest.double_base2[2][0] == 2.7f && rctest.double_base3[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step2");
+
+        }
+        public void run()
+        {
+            method08();
+        }
+    }
+
+    private  class test09 implements Runnable{
+        /*Exception test*/
+        private synchronized void method09(){
+            int check = 0;
+            double [] value1 = RC_Array_final10();
+            double[][] value2 = RC_Array_final11();
+            double[][][] value3 = RC_Array_final12();
+            //Is the value judged after the assignment?
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+
+            //ArrayIndexOutOfBoundsException
+            try {
+                value1[5] = 4.8f;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value2[5][0] = 4.8f;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value3[3][3][0] = 4.8f;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            //IllegalArgumentException
+            try {
+                Array.getDouble(value2,1);
+            }catch (IllegalArgumentException e){
+                check++;
+            }
+            try {
+                Array.getDouble(value3,1);
+            }catch (IllegalArgumentException e){
+                check++;
+            }
+            //Whether the judgment value is normal after the abnormality
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+
+            //NullPointerException
+            value1 = null;
+            value2 = null;
+            value3 = null;
+            try {
+                Array.getDouble(value1, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.getDouble(value2, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.getDouble(value3, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+
+            //System.out.println(check);
+            if (check == 10)
+                incCheckCount();
+            else
+                System.out.println("End: ErrorResult in test09");
+        }
+        public void run()
+        {
+            method09();
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0380-rc-Annotation-RCWeakRefTest/RCWeakRefTest.java b/test/testsuite/ouroboros/rc_test/RC0380-rc-Annotation-RCWeakRefTest/RCWeakRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..9f306f2b64b289a9c875c0d087f8188eea777aa6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0380-rc-Annotation-RCWeakRefTest/RCWeakRefTest.java
@@ -0,0 +1,58 @@
+/*
+ *- @TestCaseID:rc/unownedRef/RCWeakRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Test the basic function of @Weak
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCWeakRefTest.java
+ *- @ExecuteClass: RCWeakRefTest
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Weak;
+
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+
+class Test_A {
+    @Weak
+    Test_B bb;
+    Test_B bb2;
+
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");
+        }
+        bb2.run();
+    }
+
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+    }
+}
+
+public class RCWeakRefTest {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0381-rc-Annotation-RCWeakRefTest2/RCWeakRefTest2.java b/test/testsuite/ouroboros/rc_test/RC0381-rc-Annotation-RCWeakRefTest2/RCWeakRefTest2.java
new file mode 100755
index 0000000000000000000000000000000000000000..ec2b9f7d20ebd7acabfe4e53d8d6a91cbafcd309
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0381-rc-Annotation-RCWeakRefTest2/RCWeakRefTest2.java
@@ -0,0 +1,96 @@
+/*
+ *- @TestCaseID:rc/unownedRef/RCWeakRefTest2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Test the basic function of the @Weak
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCWeakRefTest2.java
+ *- @ExecuteClass: RCWeakRefTest2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Field;
+import com.huawei.ark.annotation.Weak;
+
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+
+class Test_A {
+    @Weak
+    Test_B bb;
+    @Weak
+    volatile Test_B bv;
+
+    public void test() {
+        foo();
+        new Thread(new TriggerRef()).start();
+
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");  //expect to be null
+        }
+        try {
+            bv.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");  //expect to be null
+        }
+    }
+
+    private void foo() {
+        //bb = new Test_B();
+        try {
+            Field m = Test_A.class.getDeclaredField("bb");
+            Test_B b1 = new Test_B();
+            m.set(this, b1);
+            Field m1 = Test_A.class.getDeclaredField("bv");
+            m1.set(this, b1);
+
+            Test_B temp1 = (Test_B) m.get(this);
+            if (temp1 != b1) {
+                System.out.println("error 1");
+            }
+            Test_B temp2 = (Test_B) m1.get(this);
+            if (temp2 != b1) {
+                System.out.println("error 1");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+
+    class TriggerRef implements Runnable {
+        public void run() {
+            for (int i = 0; i < 100; i++) {
+                WeakReference ref = new WeakReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+
+public class RCWeakRefTest2 {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0383-rc-Annotation-RCWeakRefTest4/RCWeakRefTest4.java b/test/testsuite/ouroboros/rc_test/RC0383-rc-Annotation-RCWeakRefTest4/RCWeakRefTest4.java
new file mode 100755
index 0000000000000000000000000000000000000000..e70bc987d2734a012f15fca760677a94d9d2b9f9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0383-rc-Annotation-RCWeakRefTest4/RCWeakRefTest4.java
@@ -0,0 +1,54 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RCWeakRefTest4.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_1_00010 for @Weak Test
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCWeakRefTest4.java
+ *- @ExecuteClass: RCWeakRefTest4
+ *- @ExecuteArgs:
+ *- @Remark: Owner Zhang Wenlong 00292413
+ */
+
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_B_1_00010_A1 {
+    @Weak
+    Cycle_B_1_00010_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00010_A1() {
+        a1_0 = null;
+        a = 123;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class RCWeakRefTest4 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        if (nsum == 246)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest/RCWeakRefThreadTest.java b/test/testsuite/ouroboros/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest/RCWeakRefThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..2b8d497c732878a8458d4df0b82b06a241c39716
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest/RCWeakRefThreadTest.java
@@ -0,0 +1,88 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/RCWeakRefThreadTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCWeakRefTest4 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCWeakRefThreadTest.java
+ *- @ExecuteClass: RCWeakRefThreadTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_Bm_1_00010 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        if (nsum == 246)
+            checkout = true;
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00010_A1 {
+        @Weak
+        Cycle_B_1_00010_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00010_A1() {
+            a1_0 = null;
+            a = 123;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a1_0.a + this.a;
+        }
+    }
+}
+
+public class RCWeakRefThreadTest {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00010 A1_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A2_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A3_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A4_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A5_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A6_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        A1_Cycle_Bm_1_00010.start();
+        A2_Cycle_Bm_1_00010.start();
+        A3_Cycle_Bm_1_00010.start();
+        A4_Cycle_Bm_1_00010.start();
+        A5_Cycle_Bm_1_00010.start();
+        A6_Cycle_Bm_1_00010.start();
+        try {
+            A1_Cycle_Bm_1_00010.join();
+            A2_Cycle_Bm_1_00010.join();
+            A3_Cycle_Bm_1_00010.join();
+            A4_Cycle_Bm_1_00010.join();
+            A5_Cycle_Bm_1_00010.join();
+            A6_Cycle_Bm_1_00010.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (A1_Cycle_Bm_1_00010.check() && A2_Cycle_Bm_1_00010.check() && A3_Cycle_Bm_1_00010.check() && A4_Cycle_Bm_1_00010.check() && A5_Cycle_Bm_1_00010.check() && A6_Cycle_Bm_1_00010.check()) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0385-rc-Annotation-RCUnownedRefTest/RCUnownedRefTest.java b/test/testsuite/ouroboros/rc_test/RC0385-rc-Annotation-RCUnownedRefTest/RCUnownedRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..fd4d70c8fd49da87dc69d7aa16ff5abbee4eeb1b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0385-rc-Annotation-RCUnownedRefTest/RCUnownedRefTest.java
@@ -0,0 +1,71 @@
+/*
+ *- @TestCaseID:rc/unownedRef/RCUnownedRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Test the basic function with cycle of the @Unowned
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefTest.java
+ *- @ExecuteClass: RCUnownedRefTest
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wennlong 00292413
+ */
+
+import java.lang.reflect.Field;
+import com.huawei.ark.annotation.Unowned;
+
+class Test_B {
+    @Unowned
+    Test_A aa;
+
+    // add volatile will crash
+    // static Test_A a1;
+
+    protected void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+
+class Test_A {
+    Test_B bb;
+
+    public void test() {
+        setReferences();
+        System.runFinalization();
+    }
+
+    private void setReferences() {
+        Test_A ta = new Test_A();
+        ta.bb = new Test_B();
+        //ta.bb.aa = ta;
+
+        try {
+            Field m = Test_B.class.getDeclaredField("aa");
+            m.set(ta.bb, ta);
+            Test_A a_temp = (Test_A) m.get(ta.bb);
+            if (a_temp != ta) {
+                System.out.println("error");
+            }
+            //Field m1 = Test_B.class.getDeclaredField("a1");
+            //m1.set(null, ta);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+}
+
+
+public class RCUnownedRefTest {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2/RCUnownedRefTest2.java b/test/testsuite/ouroboros/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2/RCUnownedRefTest2.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e336830a47d66783c115b0cc8d4217075198dd
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2/RCUnownedRefTest2.java
@@ -0,0 +1,57 @@
+/*
+ *- @TestCaseID:rc/unownedRef/RCUnownedRefTest2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Test the basic function of @Unowned
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefTest2.java
+ *- @ExecuteClass: RCUnownedRefTest2
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+class Test_B {
+    @Unowned
+    Test_B bself;
+
+    protected void run() {
+        System.out.println("ExpectResult");
+    }
+}
+
+class Test_A {
+
+    Test_B bb;
+
+    Test_B bb2;
+
+    public void test() {
+        foo();
+        bb.bself.run();
+        bb2.bself.run();
+    }
+
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+        bb.bself = bb;
+        bb2.bself = bb;
+    }
+}
+
+public class RCUnownedRefTest2 {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle/RCUnownedRefUnCycle.java b/test/testsuite/ouroboros/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle/RCUnownedRefUnCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..0dc1db6a41531af64b28d9cf308562c722c713c9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle/RCUnownedRefUnCycle.java
@@ -0,0 +1,125 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RCUnownedRefUnCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Nocycle_a_00150 for @Unowned function Test
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefUnCycle.java
+ *- @ExecuteClass: RCUnownedRefUnCycle
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+class Nocycle_a_00150_A1 {
+    Nocycle_a_00150_B1 b1_0;
+    @Unowned
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+class Nocycle_a_00150_A2 {
+    @Unowned
+    Nocycle_a_00150_B1 b1_0;
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+
+
+class Nocycle_a_00150_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class Nocycle_a_00150_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    Nocycle_a_00150_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+public class RCUnownedRefUnCycle {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.b2_0 = a2_main.b2_0;
+        a2_main.b1_0 = a1_main.b1_0;
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 1815)
+            System.out.println("ExpectResult");
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread/RCUnownedRefUncycleThread.java b/test/testsuite/ouroboros/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread/RCUnownedRefUncycleThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..853b595bd33683a41e64dbe560b695984101fdf0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread/RCUnownedRefUncycleThread.java
@@ -0,0 +1,165 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/RCUnownedRefUncycleThread.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCUnownedRefUncycle to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefUncycleThread.java
+ *- @ExecuteClass: RCUnownedRefUncycleThread
+ *- @ExecuteArgs:
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+class ThreadRc_00150 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = a1_main.b1_0;
+        a1_main.b2_0 = a2_main.b2_0;
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Nocycle_a_00150_A1 {
+        Nocycle_a_00150_B1 b1_0;
+        @Unowned
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_A2 {
+        @Unowned
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+
+    class Nocycle_a_00150_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+
+    class Nocycle_a_00150_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+
+        Nocycle_a_00150_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+
+
+public class RCUnownedRefUncycleThread {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00150 A1_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A2_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A3_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A4_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A5_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A6_00150 = new ThreadRc_00150();
+
+        A1_00150.start();
+        A2_00150.start();
+        A3_00150.start();
+        A4_00150.start();
+        A5_00150.start();
+        A6_00150.start();
+
+        try {
+            A1_00150.join();
+            A2_00150.join();
+            A3_00150.join();
+            A4_00150.join();
+            A5_00150.join();
+            A6_00150.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_00150.check() && A2_00150.check() && A3_00150.check() && A4_00150.check() && A5_00150.check() && A6_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0392-rc-Annotation-RCAnnotationThread02/RCAnnotationThread02.java b/test/testsuite/ouroboros/rc_test/RC0392-rc-Annotation-RCAnnotationThread02/RCAnnotationThread02.java
new file mode 100755
index 0000000000000000000000000000000000000000..19f6a7dec4e79a20af1f4eef9a05d9a0d7fd6d10
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0392-rc-Annotation-RCAnnotationThread02/RCAnnotationThread02.java
@@ -0,0 +1,204 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RCAnnotationThread02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_B_1_00180
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationThread02.java
+ *- @ExecuteClass: RCAnnotationThread02
+ *- @ExecuteArgs:
+ *- @Remark:
+
+ *
+ */
+
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+
+class RCAnnotationThread02_1 extends Thread {
+    public void run() {
+        RCAnnotationThread02 rcth01 = new RCAnnotationThread02();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread02_2 extends Thread {
+    public void run() {
+        RCAnnotationThread02 rcth01 = new RCAnnotationThread02();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread02_3 extends Thread {
+    public void run() {
+        RCAnnotationThread02 rcth01 = new RCAnnotationThread02();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RCAnnotationThread02 {
+    private volatile  static RCAnnotationThread02_A1 a1_main = null;
+    private volatile  static  RCAnnotationThread02_A4 a4_main = null;
+    private volatile  static  RCAnnotationThread02_A5 a5_main = null;
+
+    RCAnnotationThread02() {
+        synchronized (this) {
+            try {
+                RCAnnotationThread02_A1 a1 = new RCAnnotationThread02_A1();
+                a1.a2_0 = new RCAnnotationThread02_A2();
+                a1.a2_0.a3_0 = new RCAnnotationThread02_A3();
+                RCAnnotationThread02_A4 a4 = new RCAnnotationThread02_A4();
+                RCAnnotationThread02_A5 a5 = new RCAnnotationThread02_A5();
+                a4.a1_0 = a1;
+                a5.a1_0 = a1;
+                a1.a2_0.a3_0.a1_0 = a1;
+                a1_main = a1;
+                a4_main = a4;
+                a5_main = a5;
+            } catch (NullPointerException e) {
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread02_1 t1=new RCAnnotationThread02_1();
+        RCAnnotationThread02_2 t2=new RCAnnotationThread02_2();
+        RCAnnotationThread02_3 t3=new RCAnnotationThread02_3();
+        t1.start();
+        t2.start();
+        t3.start();
+
+        try{
+            t1.join();
+            t2.join();
+            t3.join();
+
+        }catch(InterruptedException e){}
+    }
+
+    public void setA1null() {
+        a1_main = null;
+    }
+
+    public void setA4null() {
+        a4_main = null;
+    }
+
+    public void setA5null() {
+        a5_main = null;
+    }
+
+    static class RCAnnotationThread02_A1 {
+        volatile RCAnnotationThread02_A2 a2_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread02_A2 {
+        volatile RCAnnotationThread02_A3 a3_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread02_A3 {
+        @Weak
+        volatile RCAnnotationThread02_A1 a1_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    static class RCAnnotationThread02_A4 {
+        @Unowned
+        volatile RCAnnotationThread02_A1 a1_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread02_A5 {
+        @Unowned
+        volatile RCAnnotationThread02_A1 a1_0;
+        int a;
+        int sum;
+
+        RCAnnotationThread02_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0394-rc-Annotation-RCAnnotationThread04/RCAnnotationThread04.java b/test/testsuite/ouroboros/rc_test/RC0394-rc-Annotation-RCAnnotationThread04/RCAnnotationThread04.java
new file mode 100755
index 0000000000000000000000000000000000000000..372bb2034b86c276da71379bc5aa0ae593c7e14b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0394-rc-Annotation-RCAnnotationThread04/RCAnnotationThread04.java
@@ -0,0 +1,263 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RCAnnotationThread04.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationThread04.java
+ *- @ExecuteClass: RCAnnotationThread04
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ *
+ */
+ 
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+class RCAnnotationThread04_1 extends Thread {
+    public void run() {
+        RCAnnotationThread04 rcth01 = new RCAnnotationThread04();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread04_2 extends Thread {
+    public void run() {
+        RCAnnotationThread04 rcth01 = new RCAnnotationThread04();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread04_3 extends Thread {
+    public void run() {
+        RCAnnotationThread04 rcth01 = new RCAnnotationThread04();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RCAnnotationThread04 {
+    private volatile static RCAnnotationThread04_A1 a1_main = null;
+    private volatile static RCAnnotationThread04_A4 a4_main = null;
+    private volatile static RCAnnotationThread04_A6 a6_main = null;
+
+    RCAnnotationThread04() {
+        synchronized (this) {
+            try {
+                RCAnnotationThread04_A1 a1 = new RCAnnotationThread04_A1("a1");
+                RCAnnotationThread04_A4 a4 = new RCAnnotationThread04_A4("a4");
+                RCAnnotationThread04_A6 a6 = new RCAnnotationThread04_A6("a6");
+                a1.a2_0 = new RCAnnotationThread04_A2("a2_0");
+                a1.a2_0.a3_0 = new RCAnnotationThread04_A3("a3_0");
+                a1.a2_0.a3_0.a1_0 = a1;
+                a1.a2_0.a3_0.a5_0 = new RCAnnotationThread04_A5("a5_0");
+                a1.a2_0.a3_0.a5_0.a6_0 = a6;
+                a6.a1_0 = a1;
+                a6.a3_0 = a1.a2_0.a3_0;
+                a4.a5_0 = a1.a2_0.a3_0.a5_0;
+                a6.a4_0 = a4;
+                a1_main = a1;
+                a4_main = a4;
+                a6_main = a6;
+            } catch (NullPointerException e) {
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread04_1 t_00010= new RCAnnotationThread04_1();
+        RCAnnotationThread04_2 t_00020= new RCAnnotationThread04_2();
+        RCAnnotationThread04_3 t_00030= new RCAnnotationThread04_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {}
+
+    }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RCAnnotationThread04_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RCAnnotationThread04_A3 a3 = new RCAnnotationThread04_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RCAnnotationThread04_A1 {
+        volatile RCAnnotationThread04_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RCAnnotationThread04_A2 {
+        volatile RCAnnotationThread04_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RCAnnotationThread04_A3 {
+        @Weak
+        volatile RCAnnotationThread04_A1 a1_0;
+        volatile RCAnnotationThread04_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread04_A4 {
+        volatile RCAnnotationThread04_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RCAnnotationThread04_A5 {
+        @Unowned
+        volatile RCAnnotationThread04_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RCAnnotationThread04_A6 {
+        @Unowned
+        volatile RCAnnotationThread04_A1 a1_0;
+        @Unowned
+        volatile RCAnnotationThread04_A3 a3_0;
+        @Unowned
+        volatile RCAnnotationThread04_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread04_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0395-rc-Annotation-RCAnnotationThread05/RCAnnotationThread05.java b/test/testsuite/ouroboros/rc_test/RC0395-rc-Annotation-RCAnnotationThread05/RCAnnotationThread05.java
new file mode 100755
index 0000000000000000000000000000000000000000..0b70035f4fe841f41f2b150c03b53d858195c067
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0395-rc-Annotation-RCAnnotationThread05/RCAnnotationThread05.java
@@ -0,0 +1,267 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread02/RCAnnotationThread05.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Multi Thread reads or writes static para.mofidfy from Cycle_a_00320
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationThread05.java
+ *- @ExecuteClass: RCAnnotationThread05
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ *
+ */
+ 
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+
+class RCAnnotationThread05_1 extends Thread {
+    public void run() {
+        RCAnnotationThread05 rcth01 = new RCAnnotationThread05();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread05_2 extends Thread {
+    public void run() {
+        RCAnnotationThread05 rcth01 = new RCAnnotationThread05();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+
+        }
+    }
+}
+
+class RCAnnotationThread05_3 extends Thread {
+    public void run() {
+        RCAnnotationThread05 rcth01 = new RCAnnotationThread05();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+}
+
+public class RCAnnotationThread05 {
+    private volatile static RCAnnotationThread05_A1 a1_main = null;
+    private volatile static RCAnnotationThread05_A4 a4_main = null;
+    private volatile static RCAnnotationThread05_A6 a6_main = null;
+    private static RCAnnotationThread05_A2 a2=null;
+    RCAnnotationThread05() {
+        synchronized (this) {
+            try {
+                RCAnnotationThread05_A1 a1 = new RCAnnotationThread05_A1("a1");
+                RCAnnotationThread05_A4 a4 = new RCAnnotationThread05_A4("a4");
+                RCAnnotationThread05_A6 a6 = new RCAnnotationThread05_A6("a6");
+                a2 = new RCAnnotationThread05_A2("a2_0");
+                a1.a2_0 = a2;
+                a1.a2_0.a3_0 = new RCAnnotationThread05_A3("a3_0");
+                a1.a2_0.a3_0.a1_0 = a1;
+                a1.a2_0.a3_0.a5_0 = new RCAnnotationThread05_A5("a5_0");
+                a1.a2_0.a3_0.a5_0.a6_0 = a6;
+                a6.a1_0 = a1;
+                a6.a3_0 = a1.a2_0.a3_0;
+                a4.a5_0 = a1.a2_0.a3_0.a5_0;
+                a6.a4_0 = a4;
+                a1_main = a1;
+                a4_main = a4;
+                a6_main = a6;
+            } catch (NullPointerException e) {
+
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread05_1 t_00010= new RCAnnotationThread05_1();
+        RCAnnotationThread05_2 t_00020= new RCAnnotationThread05_2();
+        RCAnnotationThread05_3 t_00030= new RCAnnotationThread05_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+
+        } catch (InterruptedException e) {}
+
+    }
+
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RCAnnotationThread05_A3("new-a3");
+        } catch (NullPointerException e) {
+
+        }
+    }
+
+    public void setA3null() {
+        RCAnnotationThread05_A3 a3 = new RCAnnotationThread05_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+
+        }
+
+    }
+
+    static class RCAnnotationThread05_A1 {
+        volatile RCAnnotationThread05_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    static class RCAnnotationThread05_A2 {
+        volatile RCAnnotationThread05_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    static class RCAnnotationThread05_A3 {
+        @Weak
+        volatile RCAnnotationThread05_A1 a1_0;
+        volatile RCAnnotationThread05_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+
+
+    static class RCAnnotationThread05_A4 {
+        @Unowned
+        volatile RCAnnotationThread05_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    static class RCAnnotationThread05_A5 {
+        @Unowned
+        volatile RCAnnotationThread05_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    static class RCAnnotationThread05_A6 {
+        @Unowned
+        volatile RCAnnotationThread05_A1 a1_0;
+        @Unowned
+        volatile RCAnnotationThread05_A3 a3_0;
+        @Unowned
+        volatile RCAnnotationThread05_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        RCAnnotationThread05_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle/RCAnnotationOneCycle.java b/test/testsuite/ouroboros/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle/RCAnnotationOneCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..68acca5b8ce747d7e94e9b1ddc8ce81883c796b6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle/RCAnnotationOneCycle.java
@@ -0,0 +1,136 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RCAnnotationOneCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Cycle_B_1_00180 for @Weak and @Unowned Test
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationOneCycle.java
+ *- @ExecuteClass: RCAnnotationOneCycle
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_B_1_00180_A1 {
+    Cycle_B_1_00180_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A2 {
+    Cycle_B_1_00180_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A3 {
+    @Weak
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_B_1_00180_A4 {
+    @Unowned
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_1_00180_A5 {
+    @Unowned
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+
+    Cycle_B_1_00180_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+public class RCAnnotationOneCycle {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 23)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread/RCAnnotationOneCycleThread.java b/test/testsuite/ouroboros/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread/RCAnnotationOneCycleThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..de2b084c29b2194ee4124406e728b436cd0ffb62
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread/RCAnnotationOneCycleThread.java
@@ -0,0 +1,172 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationOneCycleThread.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationOneCycle to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationOneCycleThread.java
+ *- @ExecuteClass: RCAnnotationOneCycleThread
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_Bm_1_00180 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 23)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_1_00180_A1 {
+        Cycle_B_1_00180_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A2 {
+        Cycle_B_1_00180_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A3 {
+        @Weak
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A4 {
+        @Unowned
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_1_00180_A5 {
+        @Unowned
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+
+        Cycle_B_1_00180_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationOneCycleThread {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00180 A1_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A2_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A3_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A4_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A5_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A6_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+
+        A1_Cycle_Bm_1_00180.start();
+        A2_Cycle_Bm_1_00180.start();
+        A3_Cycle_Bm_1_00180.start();
+        A4_Cycle_Bm_1_00180.start();
+        A5_Cycle_Bm_1_00180.start();
+        A6_Cycle_Bm_1_00180.start();
+
+        try {
+            A1_Cycle_Bm_1_00180.join();
+            A2_Cycle_Bm_1_00180.join();
+            A3_Cycle_Bm_1_00180.join();
+            A4_Cycle_Bm_1_00180.join();
+            A5_Cycle_Bm_1_00180.join();
+            A6_Cycle_Bm_1_00180.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00180.check() && A2_Cycle_Bm_1_00180.check() && A3_Cycle_Bm_1_00180.check() && A4_Cycle_Bm_1_00180.check() && A5_Cycle_Bm_1_00180.check() && A6_Cycle_Bm_1_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle/RCAnnotationTwoCycle.java b/test/testsuite/ouroboros/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle/RCAnnotationTwoCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..7d38583189748cd0148f9e29e10f8f397d5a27b0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle/RCAnnotationTwoCycle.java
@@ -0,0 +1,150 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RCAnnotationTwoCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00080 for @Weak and @Unowned Test.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationTwoCycle.java
+ *- @ExecuteClass: RCAnnotationTwoCycle
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_B_2_00080_A1 {
+    Cycle_B_2_00080_A2 a2_0;
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A1() {
+        a2_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A2 {
+    Cycle_B_2_00080_A3 a3_0;
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A3 {
+    @Weak
+    Cycle_B_2_00080_A1 a1_0;
+    @Unowned
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A4 {
+    @Unowned
+    Cycle_B_2_00080_A3 a3_0;
+    @Unowned
+    Cycle_B_2_00080_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A4() {
+        a3_0 = null;
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00080_A5 {
+    @Unowned
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00080_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+public class RCAnnotationTwoCycle {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a1_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a1_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2/RCAnnotationTwoCycle2.java b/test/testsuite/ouroboros/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2/RCAnnotationTwoCycle2.java
new file mode 100755
index 0000000000000000000000000000000000000000..6a6fc52e4f2755d49e98079580b99085209f522c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2/RCAnnotationTwoCycle2.java
@@ -0,0 +1,235 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RCAnnotationTwoCycle2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_B_2_00230 in RC测试-Cycle-00.vsd.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationTwoCycle2.java
+ *- @ExecuteClass: RCAnnotationTwoCycle2
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_B_2_00230_A1 {
+    Cycle_B_2_00230_A2 a2_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A2 {
+    Cycle_B_2_00230_A3 a3_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A3 {
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A4 {
+    Cycle_B_2_00230_A5 a5_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A5 {
+    Cycle_B_2_00230_A6 a6_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A6 {
+    @Weak
+    Cycle_B_2_00230_A1 a1_0;
+    @Unowned
+    Cycle_B_2_00230_A10 a10_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A6() {
+        a1_0 = null;
+        a10_0 = null;
+        a = 6;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a1_0.a + a10_0.a;
+    }
+}
+
+class Cycle_B_2_00230_A8 {
+    Cycle_B_2_00230_A9 a9_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A9 {
+    Cycle_B_2_00230_A7 a7_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A7 {
+    @Unowned
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+
+
+class Cycle_B_2_00230_A10 {
+    Cycle_B_2_00230_A8 a8_0;
+    int a;
+    int sum;
+
+    Cycle_B_2_00230_A10() {
+        a8_0 = null;
+        a = 10;
+        sum = 0;
+    }
+
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+
+
+public class RCAnnotationTwoCycle2 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        //System.out.println(nsum);
+        if (nsum == 97)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/RCAnnotationTwoCycleThread.java b/test/testsuite/ouroboros/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/RCAnnotationTwoCycleThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..eb60ec352141815fefa75311abe799b23f4d79f3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/RCAnnotationTwoCycleThread.java
@@ -0,0 +1,186 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationTwoCycleThread.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationTwoCycle to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationTwoCycleThread.java
+ *- @ExecuteClass: RCAnnotationTwoCycleThread
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_Bm_2_00080 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a1_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a1_0.a5_0.sum);
+        //System.out.println(nsum);
+
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00080_A1 {
+        Cycle_B_2_00080_A2 a2_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A2 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A3 {
+        @Weak
+        Cycle_B_2_00080_A1 a1_0;
+        @Unowned
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A4 {
+        @Unowned
+        Cycle_B_2_00080_A3 a3_0;
+        @Unowned
+        Cycle_B_2_00080_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A4() {
+            a3_0 = null;
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00080_A5 {
+        @Unowned
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00080_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationTwoCycleThread {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00080 A1_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A2_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A3_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A4_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A5_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A6_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+
+        A1_Cycle_Bm_2_00080.start();
+        A2_Cycle_Bm_2_00080.start();
+        A3_Cycle_Bm_2_00080.start();
+        A4_Cycle_Bm_2_00080.start();
+        A5_Cycle_Bm_2_00080.start();
+        A6_Cycle_Bm_2_00080.start();
+
+        try {
+            A1_Cycle_Bm_2_00080.join();
+            A2_Cycle_Bm_2_00080.join();
+            A3_Cycle_Bm_2_00080.join();
+            A4_Cycle_Bm_2_00080.join();
+            A5_Cycle_Bm_2_00080.join();
+            A6_Cycle_Bm_2_00080.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00080.check() && A2_Cycle_Bm_2_00080.check() && A3_Cycle_Bm_2_00080.check() && A4_Cycle_Bm_2_00080.check() && A5_Cycle_Bm_2_00080.check() && A6_Cycle_Bm_2_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/RCAnnotationTwoCycleThread2.java b/test/testsuite/ouroboros/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/RCAnnotationTwoCycleThread2.java
new file mode 100755
index 0000000000000000000000000000000000000000..759a5f31029924d90c16182588bf67843c7f59b7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/RCAnnotationTwoCycleThread2.java
@@ -0,0 +1,262 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationTwoCycleThread2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationTwoCycle2  to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationTwoCycleThread2.java
+ *- @ExecuteClass: RCAnnotationTwoCycleThread2
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_Bm_2_00230 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+
+        if (nsum == 97)
+            checkout = true;
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_B_2_00230_A1 {
+        Cycle_B_2_00230_A2 a2_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A2 {
+        Cycle_B_2_00230_A3 a3_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A3 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A4 {
+        Cycle_B_2_00230_A5 a5_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A5 {
+        Cycle_B_2_00230_A6 a6_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A6 {
+        @Weak
+        Cycle_B_2_00230_A1 a1_0;
+        @Unowned
+        Cycle_B_2_00230_A10 a10_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A6() {
+            a1_0 = null;
+            a10_0 = null;
+            a = 6;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A8 {
+        Cycle_B_2_00230_A9 a9_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A9 {
+        Cycle_B_2_00230_A7 a7_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A7 {
+        @Unowned
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+
+    class Cycle_B_2_00230_A10 {
+        Cycle_B_2_00230_A8 a8_0;
+        int a;
+        int sum;
+
+        Cycle_B_2_00230_A10() {
+            a8_0 = null;
+            a = 10;
+            sum = 0;
+        }
+
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationTwoCycleThread2 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00230 A1_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A2_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A3_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A4_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A5_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A6_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+
+        A1_Cycle_Bm_2_00230.start();
+        A2_Cycle_Bm_2_00230.start();
+        A3_Cycle_Bm_2_00230.start();
+        A4_Cycle_Bm_2_00230.start();
+        A5_Cycle_Bm_2_00230.start();
+        A6_Cycle_Bm_2_00230.start();
+
+        try {
+            A1_Cycle_Bm_2_00230.join();
+            A2_Cycle_Bm_2_00230.join();
+            A3_Cycle_Bm_2_00230.join();
+            A4_Cycle_Bm_2_00230.join();
+            A5_Cycle_Bm_2_00230.join();
+            A6_Cycle_Bm_2_00230.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00230.check() && A2_Cycle_Bm_2_00230.check() && A3_Cycle_Bm_2_00230.check() && A4_Cycle_Bm_2_00230.check() && A5_Cycle_Bm_2_00230.check() && A6_Cycle_Bm_2_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle/RCAnnotationMultiCycle.java b/test/testsuite/ouroboros/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle/RCAnnotationMultiCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..293930ae896541ca52dac00f1ec9eb775cb33cf6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle/RCAnnotationMultiCycle.java
@@ -0,0 +1,170 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RCAnnotationMultiCycle.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00280 for @Weak and @Unowned Test
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationMultiCycle.java
+ *- @ExecuteClass: RCAnnotationMultiCycle
+ *- @ExecuteArgs:
+ *- @Remark: Owner Zhang Wenlong 00292413
+ *  A1 depend A2 A3;  A6 depend A3
+ * A2 depend A1 A3; A3 depend A1 A5; A5 depend A6;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109
+ * RC-Testing_Result=(101+102+103)+(102+101+103)+(103+101+102+105)+(105+106)+(106+103)=1443
+ *
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_a_00280_A1 {
+    Cycle_a_00280_A2 a2_0;
+    @Unowned
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00280_A2 {
+    @Weak
+    Cycle_a_00280_A1 a1_0;
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+class Cycle_a_00280_A3 {
+    @Weak
+    Cycle_a_00280_A1 a1_0;
+    @Weak
+    Cycle_a_00280_A2 a2_0;
+    Cycle_a_00280_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a2_0.a + a5_0.a;
+    }
+}
+
+
+class Cycle_a_00280_A5 {
+    @Unowned
+    Cycle_a_00280_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00280_A6 {
+    @Unowned
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00280_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+
+
+public class RCAnnotationMultiCycle {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1443)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2/RCAnnotationMultiCycle2.java b/test/testsuite/ouroboros/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2/RCAnnotationMultiCycle2.java
new file mode 100755
index 0000000000000000000000000000000000000000..15e95ab76571cd045e579df29f101f85b583ced6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2/RCAnnotationMultiCycle2.java
@@ -0,0 +1,289 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RCAnnotationMultiCycle2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: Cycle_a_00370 for @Weak and @Unowned Test
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationMultiCycle2.java
+ *- @ExecuteClass: RCAnnotationMultiCycle2
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ *  A1 depend A2 ; A4 depend A1 ; A6 depend A1 A3;
+ * A2 depend A3 A4; A3 depend A1 A5 A10; A5 depend A6 A8
+ * A7 depend A2 ; A8 depend A7;
+ * A8 depend A6 ; A10 depend A9;
+ * A1.a=101 A2.a=102 A3.a=103 ... A9.a=109 A10.a=1001
+ * RC-Testing_Result=(101+102)+(102+103+104)+(103+101+105+110)+(104+101)+(105+106+108)+(106+101+103)+(107+102)+(108+107)+(109+106)+(110+109)=2623
+ *
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class Cycle_a_00370_A1 {
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+class Cycle_a_00370_A2 {
+    Cycle_a_00370_A3 a3_0;
+    @Unowned
+    Cycle_a_00370_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+
+class Cycle_a_00370_A3 {
+    @Weak
+    Cycle_a_00370_A1 a1_0;
+    Cycle_a_00370_A5 a5_0;
+    Cycle_a_00370_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a10_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a10_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A4 {
+    @Unowned
+    Cycle_a_00370_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+
+class Cycle_a_00370_A5 {
+    @Unowned
+    Cycle_a_00370_A6 a6_0;
+    Cycle_a_00370_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+
+class Cycle_a_00370_A6 {
+    @Unowned
+    Cycle_a_00370_A1 a1_0;
+    @Unowned
+    Cycle_a_00370_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A7 {
+    @Unowned
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A8 {
+    Cycle_a_00370_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+
+
+class Cycle_a_00370_A9 {
+    @Unowned
+    Cycle_a_00370_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A9(String strObjectName) {
+        a6_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+
+class Cycle_a_00370_A10 {
+    @Unowned
+    Cycle_a_00370_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    Cycle_a_00370_A10(String strObjectName) {
+        a9_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+
+public class RCAnnotationMultiCycle2 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum +a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.sum + a1_main.a2_0.a3_0.a10_0.sum;
+       
+        if (result == 2623)
+            System.out.println("ExpectResult");
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/RCAnnotationMultiCycleThread.java b/test/testsuite/ouroboros/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/RCAnnotationMultiCycleThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..5b99c9cbe033ab615fa7f444bb901f0cb74433d6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/RCAnnotationMultiCycleThread.java
@@ -0,0 +1,202 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationMultiCycleThread.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationMultiCycle to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationMultiCycleThread.java
+ *- @ExecuteClass: RCAnnotationMultiCycleThread
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_am_00280 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+
+        if (result == 1443)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00280_A1 {
+        Cycle_a_00280_A2 a2_0;
+        @Unowned
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A2 {
+        @Weak
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A3 {
+        @Weak
+        Cycle_a_00280_A1 a1_0;
+        @Weak
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A5 {
+        @Unowned
+        Cycle_a_00280_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00280_A6 {
+        @Unowned
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00280_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationMultiCycleThread {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00280 A1_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A2_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A3_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A4_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A5_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A6_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+
+        A1_Cycle_am_00280.start();
+        A2_Cycle_am_00280.start();
+        A3_Cycle_am_00280.start();
+        A4_Cycle_am_00280.start();
+        A5_Cycle_am_00280.start();
+        A6_Cycle_am_00280.start();
+
+        try {
+            A1_Cycle_am_00280.join();
+            A2_Cycle_am_00280.join();
+            A3_Cycle_am_00280.join();
+            A4_Cycle_am_00280.join();
+            A5_Cycle_am_00280.join();
+            A6_Cycle_am_00280.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00280.check() && A2_Cycle_am_00280.check() && A3_Cycle_am_00280.check() && A4_Cycle_am_00280.check() && A5_Cycle_am_00280.check() && A6_Cycle_am_00280.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/RCAnnotationMultiCycleThread2.java b/test/testsuite/ouroboros/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/RCAnnotationMultiCycleThread2.java
new file mode 100755
index 0000000000000000000000000000000000000000..ca56b9f113bff3c659211a5e1dbf0cbc75e7d172
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/RCAnnotationMultiCycleThread2.java
@@ -0,0 +1,315 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/RCAnnotationMultiCycleThread2.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change RCAnnotationMultiCycle2 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect: ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCAnnotationMultiCycleThread2.java
+ *- @ExecuteClass: RCAnnotationMultiCycleThread2
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ */
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+
+class ThreadRc_Cycle_am_00370 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+
+
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.sum + a1_main.a2_0.a3_0.a10_0.sum;
+
+        if (result == 2623)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    class Cycle_a_00370_A1 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A2 {
+        Cycle_a_00370_A3 a3_0;
+        @Unowned
+        Cycle_a_00370_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A3 {
+        @Weak
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A5 a5_0;
+        Cycle_a_00370_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A4 {
+        @Unowned
+        Cycle_a_00370_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A5 {
+        @Unowned
+        Cycle_a_00370_A6 a6_0;
+        Cycle_a_00370_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A6 {
+        @Unowned
+        Cycle_a_00370_A1 a1_0;
+        @Unowned
+        Cycle_a_00370_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A7 {
+        @Unowned
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A8 {
+        Cycle_a_00370_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A9 {
+        @Unowned
+        Cycle_a_00370_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+
+    class Cycle_a_00370_A10 {
+        @Unowned
+        Cycle_a_00370_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+
+        Cycle_a_00370_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+}
+
+
+public class RCAnnotationMultiCycleThread2 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00370 A1_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A2_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A3_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A4_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A5_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A6_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+
+        A1_Cycle_am_00370.start();
+        A2_Cycle_am_00370.start();
+        A3_Cycle_am_00370.start();
+        A4_Cycle_am_00370.start();
+        A5_Cycle_am_00370.start();
+        A6_Cycle_am_00370.start();
+
+        try {
+            A1_Cycle_am_00370.join();
+            A2_Cycle_am_00370.join();
+            A3_Cycle_am_00370.join();
+            A4_Cycle_am_00370.join();
+            A5_Cycle_am_00370.join();
+            A6_Cycle_am_00370.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00370.check() && A2_Cycle_am_00370.check() && A3_Cycle_am_00370.check() && A4_Cycle_am_00370.check() && A5_Cycle_am_00370.check() && A6_Cycle_am_00370.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0406-rc-DTS-stringIntern/stringIntern.java b/test/testsuite/ouroboros/rc_test/RC0406-rc-DTS-stringIntern/stringIntern.java
new file mode 100755
index 0000000000000000000000000000000000000000..69774a8005151199378d807fa141c15efed56704
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0406-rc-DTS-stringIntern/stringIntern.java
@@ -0,0 +1,101 @@
+/*
+ *- @TestCaseID:String_intern.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:test Intern() API of String
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: stringIntern.java
+ *- @ExecuteClass: stringIntern
+ *- @ExecuteArgs:
+
+ *
+ */
+public class stringIntern {
+    private static int check = 0;
+
+    public static void main(String[] args) {
+        String s1 = new String("aaa");
+        String s2 = "aaa";
+        if (s1 != s2) {
+            check++;    //=1
+        }
+
+        s1 = new String("bbb").intern();
+        s2 = "bbb";
+        if (s1 == s2) {
+            check++;    //=2
+        }
+
+        s1 = "ccc";
+        s2 = "ccc";
+        if (s1 == s2) {
+            check++;    //=3
+        }
+
+        s1 = new String("ddd").intern();
+        s2 = new String("ddd").intern();
+        if (s1 == s2) {
+            check++;    //=4
+        }
+
+        s1 = "ab" + "cd";
+        s2 = "abcd";
+        if (s1 == s2) {
+            check++;    //=5
+        }
+
+        String temp = "hh";
+        s1 = "a" + temp;
+        s2 = "ahh";
+        if (s1 != s2) {
+            check++;    //=6
+        }
+
+        temp = "hh".intern();
+        s1 = "a" + temp;
+        s2 = "ahh";
+        if (s1 != s2) {
+            check++;    //=7
+        }
+
+        temp = "hh".intern();
+        s1 = ("a" + temp).intern();
+        s2 = "ahh";
+        if (s1 == s2) {
+            check++;    //=8
+        }
+
+        s1 = new String("1");
+        s1.intern();
+        s2 = "1";
+        if (s1 != s2) {
+            check++;    //=9
+        }
+
+        String s3 = new String("1") + new String("1");
+        s3.intern();
+        String s4 = "11";
+        if (s1 != s2) {
+            check++;    //=10
+        }
+
+        s3 = new String("2") + new String("2");
+        s4 = "22";
+        s3.intern();
+        if (s1 != s2) {
+            check++;    //=11
+        }
+        if (check == 11) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0407-rc-DTS-stackAllocField/stackAllocField.java b/test/testsuite/ouroboros/rc_test/RC0407-rc-DTS-stackAllocField/stackAllocField.java
new file mode 100755
index 0000000000000000000000000000000000000000..b1eda3660f1d5acaae4e72e9618b74f46c25f381
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0407-rc-DTS-stackAllocField/stackAllocField.java
@@ -0,0 +1,59 @@
+/*
+ *- @TestCaseID:stackAllocField.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:test Intern() API of String
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: stackAllocField.java
+ *- @ExecuteClass: stackAllocField
+ *- @ExecuteArgs:
+
+ *
+ */
+public class stackAllocField {
+    private static A a1 = new A();
+    private static A a2 = new A();
+    private static A a3 = new A();
+    private static A a4 = new A();
+
+    public static void main(String[] args) {
+        wrapper(a1, a2, a3, a4);
+    }
+
+    public static void wrapper(A tempa1, A tempa2, A tempa3, A tempa4) {
+        A testa1 = new A();
+        testa1.a = tempa1;
+        A testa2 = new A();
+        testa2.a = tempa2;
+        A testa3 = new A();
+        testa3.a = tempa3;
+        A testa4 = new A();
+        testa4.a = tempa4;
+        tempa1 = null;
+        tempa2 = null;
+        tempa3 = null;
+        tempa4 = null;
+        a1 = null;
+        a2 = null;
+        a3 = null;
+        a4 = null;
+        for (int i = 0; i <= 50; i++) {
+            Runtime.getRuntime().gc();
+        }
+        if (testa1.a != null && testa2.a != null && testa3.a != null && testa4.a != null) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    private static class A {
+        A a;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0408-rc-DTS-OOMtest/OOMtest.java b/test/testsuite/ouroboros/rc_test/RC0408-rc-DTS-OOMtest/OOMtest.java
new file mode 100755
index 0000000000000000000000000000000000000000..e3227aa90dc0a52965a5b014bb769ced47212a19
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0408-rc-DTS-OOMtest/OOMtest.java
@@ -0,0 +1,51 @@
+/*
+ *- @TestCaseID:OOMtest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: OOMtest.java
+ *- @ExecuteClass: OOMtest
+ *- @ExecuteArgs:
+ *
+ */
+
+import java.util.ArrayList;
+
+public class OOMtest {
+    private static ArrayList<byte[]> store;
+
+    private static int alloc_test() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 * 1024 * 10; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        try {
+            int result = alloc_test();
+        } catch (OutOfMemoryError o) {
+            System.out.println("ExpectResult");
+        }
+        if (store == null) {
+            System.out.println("Error");
+        } else {
+			System.out.println("ExpectResult");
+		}
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0409-rc-DTS-Ex_eight_arguments/Ex_eight_arguments.java b/test/testsuite/ouroboros/rc_test/RC0409-rc-DTS-Ex_eight_arguments/Ex_eight_arguments.java
new file mode 100755
index 0000000000000000000000000000000000000000..43520c2ef0afdbb52c57e8c633cdd9504eba9d81
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0409-rc-DTS-Ex_eight_arguments/Ex_eight_arguments.java
@@ -0,0 +1,266 @@
+/*
+ *- @TestCaseID:Ex_eight_arguments_static.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: more than 8 arguments method test, include static ,no static, has return value, no return, throw
+ *                      Exception,not throw Exception
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: Ex_eight_arguments.java
+ *- @ExecuteClass: Ex_eight_arguments
+ *- @ExecuteArgs:
+ *- @Remark:Owner Zhang Wenlong 00292413
+ */
+
+import java.lang.reflect.Array;
+
+public class Ex_eight_arguments {
+    static int check_count = 0;
+
+    public static void main(String[] args) {
+        int first = 1988;
+        byte second = 2;
+        char third = 'g';
+        long four = 19881110;
+        float five = 601.5f;
+        double six = 60.15f;
+        String seven = "huawei";
+        boolean eight = true;
+        Object nine = new String("CC is a cat");
+        int[] ten = {2012, 2020, 2019, 2040, 3301};
+        Ex_eight_arguments Test = new Ex_eight_arguments();
+
+        //test static method no return no exception
+        test01(first, second, third, four, five, six, seven, eight, nine, ten);
+
+        //test no static method no return no exception
+        Test.test02(first, second, third, four, five, six, seven, eight, nine, ten);
+
+        //test no static method return value no exception
+        first = Test.test03(first, second, third, four, five, six, seven, eight, nine, ten);
+
+        //test no static method no return throws exception
+        try {
+            Test.test04(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test04 not catch Exception");
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check_count++;
+        }
+
+        //test static method return value no exception
+        seven = test05(first, second, third, four, five, six, seven, eight, nine, ten);
+
+        //test static method no return value throws exception
+        try {
+            test06(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test06 not catch Exception");
+        } catch (IllegalArgumentException e) {
+            check_count++;
+        }
+
+        //test no static method return value throws exception
+        try {
+            boolean result7 = Test.test07(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test07 not catch Exception");
+        } catch (ArithmeticException e) {
+            check_count++;
+        }
+
+        //test static method return value throws exception
+        try {
+            int[] result8 = test08(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test08 not catch Exception");
+        } catch (NegativeArraySizeException e) {
+            check_count++;
+        }
+
+        //Result judgment
+        if (check_count == 12)
+            System.out.println("ExpectResult");
+        //System.out.println(check_count);
+    }
+
+    private static void test01(int first, byte second, char third, long four, float five, double six, String seven,
+                               boolean eight, Object nine, int[] ten) {
+        /*test static method no return no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1989 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+
+    private static String test05(int first, byte second, char third, long four, float five, double six, String seven,
+                                 Boolean eight, Object nine, int[] ten) {
+        /*test static method return value no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test05");
+        return new String("test05 is End");
+    }
+
+    private static void test06(int first, byte second, char third, long four, float five, double six, String seven,
+                               Boolean eight, Object nine, int[] ten) throws IllegalArgumentException {
+        /*test static method no return value throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        int[][] test_ten = {ten, ten, ten, ten, ten, ten};
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test06");
+        Array.getInt(test_ten, 5);
+    }
+
+    private static int[] test08(int first, byte second, char third, long four, float five, double six, String seven,
+                                Boolean eight, Object nine, int[] ten) throws NegativeArraySizeException {
+        /*test static method return value throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        int[][] test_ten = {ten, ten, ten, ten, ten, ten};
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test08");
+        int[] chck = new int[-1];
+        return chck;
+    }
+
+    private void test02(int first, byte second, char third, long four, float five, double six, String seven,
+                        Boolean eight, Object nine, int[] ten) {
+        /*test no static method no return no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1989 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+
+    private int test03(int first, byte second, char third, long four, float five, double six, String seven,
+                       Boolean eight, Object nine, int[] ten) {
+        /*test no static method return value no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1989 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+        return first;
+    }
+
+    private void test04(int first, byte second, char third, long four, float five, double six, String seven,
+                        Boolean eight, Object nine, int[] ten) throws ArrayIndexOutOfBoundsException {
+        /*test no static method no return throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test04");
+        ten[5] = 1988;
+    }
+
+    private boolean test07(int first, byte second, char third, long four, float five, double six, String seven,
+                           Boolean eight, Object nine, int[] ten) throws ArithmeticException {
+        /*test no static method return value throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        int[][] test_ten = {ten, ten, ten, ten, ten, ten};
+
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test07");
+
+        first = first / 0;
+        return true;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0410-rc-Memory-stressTestCase29/Memory_stressTestCase29.java b/test/testsuite/ouroboros/rc_test/RC0410-rc-Memory-stressTestCase29/Memory_stressTestCase29.java
new file mode 100755
index 0000000000000000000000000000000000000000..7923b03af4dbf48240a2099060a369b3a830f454
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0410-rc-Memory-stressTestCase29/Memory_stressTestCase29.java
@@ -0,0 +1,171 @@
+/*
+ *- @TestCaseID:rc/stress/Memory_stressTestCase29.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:
+ *- @Priority: High
+ *- @Source: Memory_stressTestCase29.java
+ *- @ExecuteClass: Memory_stressTestCase29
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:从压力测试case中拆解 liuweiqing l00481345
+ */
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+
+import sun.misc.Cleaner;
+
+public class Memory_stressTestCase29 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM = INIT_DEFAULT_THREAD_NUM;
+    static List<List<AllocUnit>> mAllThread = new ArrayList<List<AllocUnit>>();
+
+    public static void main(String[] args) {
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        System.out.println("ExpectResult");
+    }
+
+    public static void testCase29() {
+        ArrayList<Thread> list = new ArrayList<>();
+        for (int i = 0; i < (DEFAULT_THREAD_NUM / 10); i++) {
+            list.add(new StopAbleThread(() -> {
+                ArrayList<Memory_stressTestCase29.AllocUnitwithVerifyCleaner> units = new ArrayList<>();
+                Random r = new Random();
+                for (int j = 0; j < 100; j++) {
+                    units.add(new Memory_stressTestCase29.AllocUnitwithVerifyCleaner(r.nextInt(512)));
+                }
+                trySleep(r.nextInt(500));
+                for (Memory_stressTestCase29.AllocUnitwithVerifyCleaner unit : units) {
+                    unit.CanbeFree();
+                }
+                units.clear();
+            }, "testCase29_alloc_" + (i + 1)));
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    public static class StopAbleThread extends Thread {
+        public static boolean mRuning = true;
+        static List<List<AllocUnit>> mAllThread = new ArrayList<List<AllocUnit>>();
+
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+
+
+        }
+    }
+
+    public static class AllocUnit {
+        public byte unit[];
+
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+
+    public static class AllocUnitwithVerifyCleaner extends AllocUnit {
+        static final int FLAG_INUSE = 0x112233;
+        static final int FLAG_CANBECLEAN = 0xddee;
+        static final int FLAG_CLEARED = 0xaabb;
+        public CleanerStatus status;
+
+        public AllocUnitwithVerifyCleaner(int arrayLength) {
+            super(arrayLength);
+            status = new CleanerStatus();
+            this.cleaner = Cleaner.create(this, new TestCleaner(status));
+        }
+
+        private final Cleaner cleaner;
+
+        private static class CleanerStatus {
+            public int status;
+
+            CleanerStatus() {
+                status = FLAG_INUSE;
+            }
+        }
+
+        public void CanbeFree() {
+            if (this.status.status != FLAG_INUSE) {
+                throw new NullPointerException();
+            }
+            this.status.status = FLAG_CANBECLEAN;
+        }
+
+        private static class TestCleaner implements Runnable {
+            public CleanerStatus status;
+
+            public TestCleaner(CleanerStatus status) {
+                this.status = status;
+            }
+
+            public void run() {
+                if (this.status.status != FLAG_CANBECLEAN) {
+                }
+                this.status.status = FLAG_CLEARED;
+            }
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3/RCUnownedRefTest3.java b/test/testsuite/ouroboros/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3/RCUnownedRefTest3.java
new file mode 100755
index 0000000000000000000000000000000000000000..27f70360e0f1847bf672c9e07ea0b086d5ac36ad
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3/RCUnownedRefTest3.java
@@ -0,0 +1,76 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/RCUnownedTest3
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:在匿名类和lambda中使用@Unowned，没有环泄露
+ *- @Condition:no
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 在匿名类和lambda中使用@Unowned，没有环泄露
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefTest3.java
+ *- @ExecuteClass: RCUnownedRefTest3
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+import com.huawei.ark.annotation.Unowned;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class RCUnownedRefTest3 {
+    public static void main(String[] args) {
+        UnownedAnnoymous unownedAnnoymous = new UnownedAnnoymous();
+        unownedAnnoymous.anonymousCapture("test");
+        UnownedLambda unownedLambda = new UnownedLambda();
+        List<String> list = new LinkedList<>();
+        list.add("test");
+        unownedLambda.lambdaCapture(list, "test");
+        if (unownedAnnoymous.checkAnnoy == true && unownedLambda.checkLambda == true) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+class UnownedLambda {
+    String name;
+    static boolean checkLambda = false;
+    
+    void lambdaCapture(List<String> list, String suffix) {
+        final @Unowned String capSuffix = suffix;
+        final @Unowned UnownedLambda self = this;
+        list.forEach((str) -> {
+            if ((self.name + str + capSuffix).equals("nulltesttest")) {
+                checkLambda = true;
+            }
+        });
+    }
+}
+
+class UnownedAnnoymous {
+    String name;
+    static boolean checkAnnoy = false;
+
+    void anonymousCapture(String suffix) {
+        final @Unowned String capSuffix = suffix;
+        Runnable r = new Runnable() {
+            @Override
+            public void run() {
+                if ((name + capSuffix).equals("nulltest")) {
+                    checkAnnoy = true;
+                }
+            }
+        };
+        r.run();
+    }
+}
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3/RCUnownedRefThreadTest3.java b/test/testsuite/ouroboros/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3/RCUnownedRefThreadTest3.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1bf5406fe7d5dd6f37dc62c7a217a0bbeb37143
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3/RCUnownedRefThreadTest3.java
@@ -0,0 +1,141 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/RCUnownedRefThreadTest3.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change CaseRC0417 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedRefThreadTest3.java
+ *- @ExecuteClass: RCUnownedRefThreadTest3
+ *- @ExecuteArgs:
+ *- @Remark:Owner liuweiqing 00481345
+ */
+
+import com.huawei.ark.annotation.Unowned;
+
+import java.util.LinkedList;
+import java.util.List;
+
+class RCUnownedRefTest3 extends Thread {
+    private boolean checkout;
+
+    public void run() {
+        UnownedAnnoymous unownedAnnoymous = new UnownedAnnoymous();
+        unownedAnnoymous.anonymousCapture("test");
+        UnownedLambda unownedLambda = new UnownedLambda();
+        List<String> list = new LinkedList<>();
+        list.add("test");
+        unownedLambda.lambdaCapture(list, "test");
+        
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        if (unownedAnnoymous.checkAnnoy == true && unownedLambda.checkLambda == true) {
+            checkout = true;
+        } else {
+            System.out.println("unownedAnnoymous.checkAnnoy:" + unownedAnnoymous.checkAnnoy);
+            System.out.println("unownedLambda.checkLambda:" + unownedLambda.checkLambda);
+            System.out.println("555555555555555");
+            checkout = false;
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+class UnownedLambda {
+    String name;
+    static boolean checkLambda;
+
+    void lambdaCapture(List<String> list, String suffix) {
+        checkLambda = false;
+        final String capSuffix = suffix;
+        final UnownedLambda self = this;
+        list.forEach((str) -> {
+            if ((self.name + str + capSuffix).equals("nulltesttest")) {
+                checkLambda = true;
+            } else {
+                System.out.println("self.name + str + capSuffix:" + self.name + "  " + str + "  " + capSuffix);
+            }
+        });
+    }
+}
+
+class UnownedAnnoymous {
+    String name;
+    static boolean checkAnnoy;
+
+    void anonymousCapture(String suffix) {
+        checkAnnoy = false;
+        final @Unowned String capSuffix = suffix;
+        Runnable r = new Runnable() {
+            @Override
+            public void run() {
+                if ((name + capSuffix).equals("nulltest")) {
+                    checkAnnoy = true;
+                } else {
+                    System.out.println("name + capSuffix:" + name + "   " + capSuffix);
+                }
+            }
+        };
+        r.run();
+    }
+}
+
+public class RCUnownedRefThreadTest3 {
+
+    public static void main (String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCUnownedRefTest3 rcTest1 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest2 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest3 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest4 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest5 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest6 = new RCUnownedRefTest3();
+
+        rcTest1.start();
+        rcTest2.start();
+        rcTest3.start();
+        rcTest4.start();
+        rcTest5.start();
+        rcTest6.start();
+
+        try {
+            rcTest1.join();
+            rcTest2.join();
+            rcTest3.join();
+            rcTest4.join();
+            rcTest5.join();
+            rcTest6.join();
+
+        } catch (InterruptedException e) {
+        }
+        Thread.sleep(2000);
+        if (rcTest1.check() && rcTest2.check() && rcTest3.check() && rcTest4.check() && rcTest5.check() && rcTest6.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcTest1.check():" + rcTest1.check());
+            System.out.println("rcTest2.check():" + rcTest2.check());
+            System.out.println("rcTest3.check():" + rcTest3.check());
+            System.out.println("rcTest4.check():" + rcTest4.check());
+            System.out.println("rcTest5.check():" + rcTest5.check());
+            System.out.println("rcTest6.check():" + rcTest6.check());
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest/RCUnownedLocalTest.java b/test/testsuite/ouroboros/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest/RCUnownedLocalTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..c1e9e3e4b0b82694fd125de1bdeb314bcb893035
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest/RCUnownedLocalTest.java
@@ -0,0 +1,56 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/RCUnownedLocalTest
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:方法中添加@UnownedLocal,没有环泄露
+ *- @Condition:no
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 方法中添加@UnownedLocal,没有环泄露
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedLocalTest.java
+ *- @ExecuteClass: RCUnownedLocalTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import com.huawei.ark.annotation.UnownedLocal;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class RCUnownedLocalTest {
+    static Integer a = new Integer(1);
+    static Object[] arr = new Object[]{1, 2, 3};
+
+    @UnownedLocal
+    static int method(Integer a, Object[] arr) {
+        int check = 0;
+        Integer c = a + a;
+        if (c == 2) {
+            check++;
+        } else {
+            check--;
+        }
+        for (Object array : arr) {
+            //System.out.println(array);
+            check++;
+        }
+        return check;
+    }
+
+    public static void main(String[] args) {
+        int result = method(a, arr);
+        if (result == 4) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest/RCUnownedLocalThreadTest.java b/test/testsuite/ouroboros/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest/RCUnownedLocalThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..c07b8569d6e6aae16307f842eee09ba3dd04b3c2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest/RCUnownedLocalThreadTest.java
@@ -0,0 +1,97 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/RC_Thread01/RCUnownedLocalThreadTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Change CaseRC0419 to Multi thread testcase.
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedLocalThreadTest.java
+ *- @ExecuteClass: RCUnownedLocalThreadTest
+ *- @ExecuteArgs:
+ *- @Remark:Owner liuweiqing 00481345
+ */
+
+import com.huawei.ark.annotation.*;
+
+import java.util.LinkedList;
+import java.util.List;
+
+class RCUnownedLocalTest extends Thread {
+    private boolean checkout;
+    
+    Integer a = new Integer(1);
+    Object[] arr = new Object[]{1, 2, 3};
+
+    @UnownedLocal
+    int method(Integer a, Object[] arr) {
+        int check = 0;
+        Integer c = a + a;
+        if (c == 2) {
+            check++;
+        } else {
+            check--;
+        }
+        for (Object array : arr) {
+            //System.out.println(array);
+            check++;
+        }
+        return check;
+    }
+
+    public void run() {
+        int result = method(a, arr);
+        if (result == 4) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println("result:" + result);
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+public class RCUnownedLocalThreadTest {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        RCUnownedLocalTest rcTest1 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest2 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest3 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest4 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest5 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest6 = new RCUnownedLocalTest();
+
+        rcTest1.start();
+        rcTest2.start();
+        rcTest3.start();
+        rcTest4.start();
+        rcTest5.start();
+        rcTest6.start();
+
+        try {
+            rcTest1.join();
+            rcTest2.join();
+            rcTest3.join();
+            rcTest4.join();
+            rcTest5.join();
+            rcTest6.join();
+
+        } catch (InterruptedException e) {
+        }
+        if (rcTest1.check() && rcTest2.check() && rcTest3.check() && rcTest4.check() && rcTest5.check() && rcTest6.check())
+            System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest/RCUnownedOuterTest.java b/test/testsuite/ouroboros/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest/RCUnownedOuterTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..99da9b7a1a74133114933a7f9d3305ac888b66df
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest/RCUnownedOuterTest.java
@@ -0,0 +1,90 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/RCUnownedOuterTest
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:在内部类和内部匿名类添加@UnownedOuter,没有环泄露
+ *- @Condition:no
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 在内部匿名类和内部类添加@UnownedOuter,没有环泄露
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCUnownedOuterTest.java
+ *- @ExecuteClass: RCUnownedOuterTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import com.huawei.ark.annotation.UnownedOuter;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class RCUnownedOuterTest {
+
+
+    public static void main(String[] args) {
+        UnownedAnnoymous unownedAnnoymous = new UnownedAnnoymous();
+        unownedAnnoymous.anonymousCapture();
+
+        UnownedInner unownedInner = new UnownedInner();
+        unownedInner.method();
+        UnownedInner.InnerClass innerClass = unownedInner.new InnerClass();
+        innerClass.myName();
+        if (unownedAnnoymous.checkAnnoy == 1 && unownedInner.checkInner == 1) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("unownedAnnoymous.checkAnnoy:" + unownedAnnoymous.checkAnnoy);
+            System.out.println("unownedInner.checkInner:" + unownedInner.checkInner);
+        }
+    }
+
+}
+
+class UnownedInner {
+    String name = "test";
+    int checkInner = 0;
+    InnerClass innerClass;
+
+    void method() {
+        innerClass = new InnerClass();
+    }
+
+    @UnownedOuter
+    class InnerClass {
+        void myName() {
+            checkInner = 0;
+            String myname;
+            myname = name + name;
+            if (myname.equals("testtest")) {
+                checkInner++;
+            }
+        }
+    }
+}
+
+class UnownedAnnoymous {
+    String name = "test";
+    static int checkAnnoy;
+
+    void anonymousCapture() {
+        Runnable r = new Runnable() {
+            @UnownedOuter
+            @Override
+            public void run() {
+                checkAnnoy = 0;
+                String myName = name + name;
+                if (myName.equals("testtest")) {
+                    checkAnnoy++;
+                }
+            }
+        };
+        r.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0431-rc-SoftRef-SoftRefTest/SoftRefTest.java b/test/testsuite/ouroboros/rc_test/RC0431-rc-SoftRef-SoftRefTest/SoftRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b13585a892427162dc47aea5d518446a7d71d8a4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0431-rc-SoftRef-SoftRefTest/SoftRefTest.java
@@ -0,0 +1,73 @@
+/*
+ *- @TestCaseID:SoftRefTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 测试SoftRefernece的基本内存管理方式：在正常情况下，SoftReference对象不会被回收掉
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：创建一个SoftReference对象，并将其放到ReferneceQueue中，该对象不应该被释放；
+ * -#step2：封装一个函数生成一下局部的SoftReference对象
+ * -#step3：再次确认该对象不应该被释放，且它所在的ReferenceQueue中没有即将回收的Reference对象
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SoftRefTest.java
+ *- @ExecuteClass: SoftRefTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+
+public class SoftRefTest {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+        new Thread(new TriggerRP()).start();
+
+        if (rp.get() == null) {
+            System.out.println("Error Result when second check ");
+            a++;
+        }
+        Reference r = rq.poll();
+        if (r != null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+
+    }
+
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 60; i++) {
+                SoftReference sr = new SoftReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0432-rc-SoftRef-SoftRefTest02/SoftRefTest02.java b/test/testsuite/ouroboros/rc_test/RC0432-rc-SoftRef-SoftRefTest02/SoftRefTest02.java
new file mode 100755
index 0000000000000000000000000000000000000000..21029623d5eebc789e3149c84737f5b2fbeddccb
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0432-rc-SoftRef-SoftRefTest02/SoftRefTest02.java
@@ -0,0 +1,63 @@
+/*
+ *- @TestCaseID:SoftRefTest02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 正常情况下通过system.gc()强制gc时，SoftReference对象不会被回收掉
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：创建一个SoftReference对象，并将其放到ReferneceQueue中，该对象不应该被释放；
+ * -#step2：通过System.gc()进行强制GC
+ * -#step3：再次确认该对象不应该被释放，且它所在的ReferenceQueue中没有即将回收的Reference对象
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SoftRefTest02.java
+ *- @ExecuteClass: SoftRefTest02
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+
+public class SoftRefTest02 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+        for (int i = 0; i < 3; i++) {
+            System.gc();
+            if (rp.get() == null) {
+                System.out.println("Error Result when second check ");
+                a++;
+            }
+        }
+        Reference r = rq.poll();
+        if (r != null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0433-rc-SoftRef-SoftRefTest03/SoftRefTest03.java b/test/testsuite/ouroboros/rc_test/RC0433-rc-SoftRef-SoftRefTest03/SoftRefTest03.java
new file mode 100755
index 0000000000000000000000000000000000000000..de62d89730090b2af071dd42731204d59c4676ec
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0433-rc-SoftRef-SoftRefTest03/SoftRefTest03.java
@@ -0,0 +1,67 @@
+/*
+ *- @TestCaseID:SoftRefTest03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 内存充足的正常情况下通过Runtime.getRuntime().gc()强制gc时，SoftReference对象不会被回收掉
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：创建一个SoftReference对象，并将其放到ReferneceQueue中，该对象不应该被释放；
+ * -#step2：通过Runtime.getRuntime().gc()进行强制GC
+ * -#step3：再次确认该对象不应该被释放，且它所在的ReferenceQueue中没有即将回收的Reference对象
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SoftRefTest03.java
+ *- @ExecuteClass: SoftRefTest03
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+
+public class SoftRefTest03 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+
+        for (int i = 0; i < 3; i++) {
+            Runtime.getRuntime().gc();
+            Runtime.getRuntime().runFinalization();
+            if (rp.get() == null) {
+                System.out.println("Error Result when second check ");
+                a++;
+                break;    //rp指向的对象不应该被释放，如果出现释放，则打印、a++;然后break跳出循环
+            }
+        }
+
+        Reference r = rq.poll();    //ReferenceQueue里不应该有对象，poll返回值应该是空指针
+        if (r != null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0435-rc-SoftRef-SoftRefTest05/SoftRefTest05.java b/test/testsuite/ouroboros/rc_test/RC0435-rc-SoftRef-SoftRefTest05/SoftRefTest05.java
new file mode 100755
index 0000000000000000000000000000000000000000..ab6cc4c568c3e4d6ca1e1145ba31023f396dc8bb
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0435-rc-SoftRef-SoftRefTest05/SoftRefTest05.java
@@ -0,0 +1,189 @@
+/*
+ *- @TestCaseID:SoftRefTest05.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 环上SoftReference对象在正常情况下不会被释放
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：创建一个对象环，由四个对象Class_A、Class_B、Class_C和Class_D组成。这四个对象都一个域，关联着一个SoftReference；
+ * -#step2：执行一次后，进行一遍gc，进行环的自学习；
+ * -#step3：再执行一次后，判断环关联的软对象不应该被释放。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SoftRefTest05.java
+ *- @ExecuteClass: SoftRefTest05
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+
+public class SoftRefTest05 {
+    static final int TEST_NUM = 1;
+    static int check_count = 0;
+    static int allSum;
+
+    public static void main(String[] args) {
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            Runtime.getRuntime().gc();
+            // resultLine = null;
+            test_01();
+
+            if (allSum == 20) {
+                check_count++;
+                System.out.println("sum is srong");
+            }
+
+            if (check_count == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println(" errorResult ----checkcount" + check_count);
+            }
+
+        }
+    }
+
+    private static void test_01() {
+        Cycle_A a1 = new Cycle_A();
+        a1.cyb = new Cycle_B();
+        a1.cyb.cyc = new Cycle_C();
+        a1.cyb.cyc.cyd = new Cycle_D();
+        a1.cyb.cyc.cyd.cya = a1;
+        allSum = a1.sum + a1.cyb.sum + a1.cyb.cyc.sum + a1.cyb.cyc.cyd.sum;
+        sleep(4000);
+        if ((a1.sr.get() == null) || (a1.cyb.sr.get() == null) || (a1.cyb.cyc.pr.get() == null) || (a1.cyb.cyc.cyd.str.get() == null)) {
+            check_count++;
+        }
+
+    }
+
+    private static void sleep(int sleepnum) {
+        try {
+            Thread.sleep(sleepnum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+
+}
+
+class Cycle_A {
+    static StringBuffer a = new StringBuffer("ref_processor_cycle_A");
+    Reference sr;
+    Cycle_B cyb;
+    int aNum;
+    int sum;
+
+    Cycle_A() {
+        a = new StringBuffer("ref_processor_cycle_A");
+        sr = new SoftReference(a);
+        if (sr.get() == null) {
+            assert false;
+        }
+        a = null;
+        cyb = null;
+        aNum = 1;
+    }
+
+    int joinStr() {
+        try {
+            sum = aNum + cyb.bNum;
+        } catch (Exception e) {
+
+        }
+        return sum;
+    }
+}
+
+class Cycle_B {
+    static StringBuffer b = new StringBuffer("ref_processor_cycle_B");
+    Reference sr;
+    Cycle_C cyc;
+    int bNum;
+    int sum;
+
+    Cycle_B() {
+        b = new StringBuffer("ref_processor_cycle_B");
+        sr = new SoftReference<>(b);
+        if (sr.get() == null) {
+            assert false;
+        }
+        b = null;
+        cyc = null;
+        bNum = 2;
+    }
+
+
+    int joinStr() {
+        try {
+            sum = bNum + cyc.cNum;
+        } catch (Exception e) {
+
+        }
+        return sum;
+    }
+
+
+}
+
+class Cycle_C {
+    Reference pr;
+    Cycle_D cyd;
+    StringBuffer c = new StringBuffer("ref_processor_cycle_C");
+    int sum;
+    int cNum;
+
+    Cycle_C() {
+        c = new StringBuffer("ref_processor_cycle_C");
+        pr = new SoftReference<>(c);
+        if (pr.get() == null) {
+            assert false;
+        }
+        c = null;
+        cyd = null;
+        cNum = 3;
+    }
+
+    int joinStr() {
+        try {
+            sum = cNum + cyd.dNum;
+        } catch (Exception e) {
+
+        }
+        return sum;
+    }
+}
+
+class Cycle_D {
+    Reference str;
+    Cycle_A cya;
+    StringBuffer d = new StringBuffer("ref_processor_cycle_D");
+    int dNum;
+    int sum;
+
+
+    Cycle_D() {
+        d = new StringBuffer("ref_processor_cycle_D");
+        str = new SoftReference<StringBuffer>(d);
+        d = null;
+        cya = null;
+        dNum = 4;
+
+    }
+
+
+    int joinStr() {
+        try {
+            int sum = dNum + cya.aNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/RCHeaderTest04.java b/test/testsuite/ouroboros/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/RCHeaderTest04.java
new file mode 100755
index 0000000000000000000000000000000000000000..4e16bacf16693cf050867f4da7de96115cd3d656
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/RCHeaderTest04.java
@@ -0,0 +1,71 @@
+/*
+ *- @TestCaseID:RCHeaderTest04.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 软指针指向的对象声明周期未结束时，同时有cleaner referent和Weak Annotation referent引用的资源和对象是不会释放的
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：在方法体内为一个具有缓存语义的软引用rcht.sr加上一个Cleaner和一个Weak Annotation指向它；
+ * -#step2：该软引用生命周期结束后，应该会立刻释放该对象占用的内存（Cleaner和Weak Annotation对象没有缓存语义）
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCHeaderTest04.java
+ *- @ExecuteClass: RCHeaderTest04
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import sun.misc.Cleaner;
+
+import java.lang.ref.SoftReference;
+
+import com.huawei.ark.annotation.Weak;
+
+class RCRunner04 implements Runnable {
+    public void run() {
+        RCHeaderTest04.iArray = null;
+    }
+}
+
+
+public class RCHeaderTest04 {
+    static int[] iArray;
+    @Weak
+    static int[] wr_annotation = null;
+    static Cleaner c = null;
+    static SoftReference<int[]> sr = null;
+
+    public RCHeaderTest04() {
+        iArray = new int[4];
+        int[] temp = {1, 2, 3, 4};
+        wr_annotation = temp;
+        sr = new SoftReference<>(temp);
+    }
+
+    //方法退出后，实例变量sr声明周期结束，触发对SoftReference的处理，它指向的数组占用空间被释放。
+    static void foo() {
+        RCHeaderTest04 rcht = new RCHeaderTest04();
+        c = Cleaner.create(rcht.sr, new RCRunner04());
+        if (c == null && wr_annotation.length != 4) {
+            System.out.println("Cleaner create failly");
+        }
+    }
+
+    public static void main(String[] args) {
+        foo();
+        Runtime.getRuntime().runFinalization();
+        if (c != null && wr_annotation != null && sr.get() != null) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/PlacementRCTest01.java b/test/testsuite/ouroboros/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/PlacementRCTest01.java
new file mode 100755
index 0000000000000000000000000000000000000000..1bc8b46e0d7c860aed7ff225b2d3873c05bb7ba4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/PlacementRCTest01.java
@@ -0,0 +1,173 @@
+/*
+ *- @TestCaseID:PlacementRCTest01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:检测在循环语句（for, while, do-while）控制流中，生命周期结束的对象，应该会被立即回收
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest通过重写finalize（）方法对回收的及时性做检测
+ * -#step1:函数1测试场景：对象初始化在for循环外，只在for循环内部使用；
+ * -#step2:函数2测试场景：对象初始化和使用都在for循环内；
+ * -#step3:函数3测试场景：对象初始化在do-while循环内，循环之后，仍有使用；
+ * -#step4:函数4测试场景：对象初始化在for循环外，只在for循环内部部分分支（通过if判断）使用；
+ * -#step5:函数5测试场景：对象初始化在while循环外，while循环后仍然存活；在while循环内有局部对象的初始化和使用
+ * -#step6:判断依据：End字符串和Method的位置关系
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: PlacementRCTest01.java
+ *- @ExecuteClass: PlacementRCTest01
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ *
+ */
+class B {
+    static A a;
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class A {
+    public int count = 0;
+    public String className = "A";
+
+    public A(String name) {
+        this.className = name;
+    }
+
+    public void changeName(String name) {
+        this.className = name;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        synchronized (PlacementRCTest01.lock) {
+            if (this.count % 25 == 0) {
+                PlacementRCTest01.result += ("End");
+            }
+        }
+        B.a = this;
+    }
+
+}
+
+public class PlacementRCTest01 {
+    public volatile static String result = new String();
+    public static String lock = "";
+    private static volatile int count = 0;
+    private static A infiniteLoop = null;
+    private A defInsideUseOutside = null;
+
+    public static void onlyUseInsideLoop() {
+        A a1 = new A("a1");
+        for (count = 0; count < 100; count++) {
+            a1.changeName("a" + count);
+	    a1.count = count;
+            if (count == 99)
+                a1.toString();
+        }
+        Runtime.getRuntime().runFinalization();
+		//try{ Thread.sleep(5000); } catch( Exception e ){ }
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method1";
+        }
+    }
+
+    public static void defAndUseInsideLoop() {
+        for (count = 0; count < 100; count++) {
+            A a2 = new A("a2_i" + count);
+	    a2.count = count;
+            a2.changeName("null");
+            for (int j = 0; j < 5; j++) {
+                a2 = new A("a2_i" + count + "_j" + j);
+            }
+            if (count == 99) {
+                a2.toString();
+            }
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method2";
+        }
+    }
+	
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        do {
+            this.defInsideUseOutside = new A("a2_i" + count);
+	    this.defInsideUseOutside.count = count;
+            for (int j = 0; j < 2; j++)
+                this.defInsideUseOutside = new A("a2_i" + count + "_j" + j);
+            if (count == 99)
+                this.defInsideUseOutside.toString();
+            count++;
+        } while (this.defInsideUseOutside.count < 100 && count < 100);
+        this.defInsideUseOutside.changeName("finish");
+        this.defInsideUseOutside = null;
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method3";
+        }
+    }
+
+    public static void defInBranchInsideLoop() {
+        A a4 = new A("a4");
+        for (count = 0; count < 100; count++) {
+            a4.changeName("a" + count);
+	    a4.count = count;
+            if (count % 2 == 0) {
+                a4 = new A("a4_" + count);
+            }
+            a4.toString();
+        }
+        a4.changeName("End");
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method4";
+        }
+    }
+
+    public static void infiniteLoop() {
+        infiniteLoop = new A("infinite loop");
+        count = 0;
+        while (count < 100) {
+            A a5 = new A("a2_i" + count);
+            a5.changeName("null");
+	    a5.count = count;
+            infiniteLoop.changeName("infinite loop" + count);
+            for (int j = 0; j < 2; j++) {
+                a5 = new A("a2_i" + count + "_j" + j);
+            }
+            if (count == 99) {
+                a5.toString();
+            }
+            count++;
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method5";
+        }
+    }
+
+    public static void main(String[] args) {
+        onlyUseInsideLoop();	
+        defAndUseInsideLoop();
+        new PlacementRCTest01().defInsideAndUseOutsideLoop();
+        defInBranchInsideLoop();
+        infiniteLoop();
+        //System.out.println(result);
+        if(result.contains("Method1") && result.contains("Method2") && result.contains("Method3") && result.contains("Method4") && result.contains("Method5") && result.contains("End") && infiniteLoop.className.equals("infinite loop99"))
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02/PlacementRCTest02.java b/test/testsuite/ouroboros/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02/PlacementRCTest02.java
new file mode 100755
index 0000000000000000000000000000000000000000..e3d1441fbb0deaa2a5928cf06591382f0550dde0
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02/PlacementRCTest02.java
@@ -0,0 +1,147 @@
+/*
+ *- @TestCaseID:PlacementRCTest02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:检测在判断语句（if-then, if-then-else, switch）控制流中，生命周期结束的对象，应该会被立即回收
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1:函数1判断仅有if语句，在if语句中进行对象使用和重新复制，使之前引用的局部对象声明周期结束。
+ * -#step2:函数2在if语句中进行对象使用和重新复制，使之前引用的局部对象声明周期结束；在else分支仅做使用，不重新复制。
+ * -#step3:函数3在switch控制流中测试，每个case中对对象都有不同的处理，查看是否会立刻释放。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: PlacementRCTest02.java
+ *- @ExecuteClass: PlacementRCTest02
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ *
+ */
+
+class PlacementRC_A2 {
+    public int count = 0;
+    public String className = "A";
+
+    public PlacementRC_A2(String name) {
+        this.className = name;
+    }
+
+    public void changeName(String name) {
+        this.className = name;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        synchronized (PlacementRCTest02.lock) {
+            if (this.count % 25 == 0) {
+                PlacementRCTest02.result += ("End" + count);
+            }
+        }
+    }
+
+}
+
+public class PlacementRCTest02 {
+    public static String result = new String();
+    public static String lock = "";
+    private volatile static int count = 0;
+    private PlacementRC_A2 defInsideUseOutside = null;
+
+    public static void onlyUseInsideLoop() {
+        PlacementRC_A2 a1 = new PlacementRC_A2("a1");
+        for (count = 0; count < 100; count++) {
+            a1.changeName("a" + count);
+            a1.count = count;
+            if (count % 11 == 0) {
+                a1.changeName("a" + 100);
+                a1 = new PlacementRC_A2("a10");
+                a1.toString();
+            }
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest02.lock) {
+            result += "Method1";
+        }
+    }
+
+    public static void defAndUseInsideLoop() {
+        for (count = 0; count < 100; count++) {
+            PlacementRC_A2 a2 = new PlacementRC_A2("a2_i" + count);
+            a2.changeName("null");
+            a2.count = count;
+            for (int j = 0; j < 2; j++)
+                a2 = new PlacementRC_A2("a2_i" + count + "_j" + j);
+            if (count % 11 == 0) {
+                a2.changeName("a" + 100);
+                a2 = new PlacementRC_A2("a10");
+                a2.toString();
+            } else {
+                a2.toString();
+
+            }
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest02.lock) {
+            result += "Method2";
+        }
+    }
+
+    public static void main(String[] args) {
+        onlyUseInsideLoop();
+        defAndUseInsideLoop();
+        new PlacementRCTest02().defInsideAndUseOutsideLoop();
+        //System.out.println(result);
+        if(result.contains("Method1") && result.contains("Method2") && result.contains("Method3") && result.contains("End"))
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error Result");
+
+    }
+
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        do {
+            int choice = count % 4;
+            this.defInsideUseOutside = new PlacementRC_A2("a2_i" + count);
+            switch (choice) {
+                case 1:
+                    for (int j = 0; j < 2; j++) {
+                        this.defInsideUseOutside = new PlacementRC_A2("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    if (count == 99)
+                        this.defInsideUseOutside.toString();
+                    break;
+                case 2:
+                    for (int j = 0; j < 2; j++) {
+                        this.defInsideUseOutside.changeName("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    break;
+                case 3:
+                    for (int j = 0; j < 2; j++) {
+                        this.defInsideUseOutside = new PlacementRC_A2("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    if (this.defInsideUseOutside.className.equals("a2_i95_j4"))
+                        System.out.println(this.defInsideUseOutside.className);
+                    break;
+                default:
+                    this.defInsideUseOutside = new PlacementRC_A2("a2_i" + count);
+                    this.defInsideUseOutside.count = count;
+            }
+            count++;
+        } while (this.defInsideUseOutside.count < 100 && count < 100);
+        this.defInsideUseOutside.changeName("finish");
+        this.defInsideUseOutside = null;
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest02.lock) {
+            result += "Method3";
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04/PlacementRCTest04.java b/test/testsuite/ouroboros/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04/PlacementRCTest04.java
new file mode 100755
index 0000000000000000000000000000000000000000..f6ced0eb8afa4660c1c011834ffb94bde4d5615c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04/PlacementRCTest04.java
@@ -0,0 +1,232 @@
+/*
+ * -@TestCaseID:PlacementRCTest04.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination:检测在多层try-catch的语句中，生命周期结束的局部对象，应该会被立即回收
+ * 检测在eh中，生命周期结束的对象，应该会被立即回收
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1：run（）方法就是多层try-catch嵌套，里面有一些局部对象，声明周期到了之后会被立即释放
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: PlacementRCTest04.java
+ * -@ExecuteClass: PlacementRCTest04
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+import java.util.IllegalFormatException;
+
+class PlacementRC_A4 {
+    public int count = 0;
+    public String className = "A";
+
+    public PlacementRC_A4(String name) {
+        this.className = name;
+    }
+
+    public void changeName(String name) {
+        this.className = name;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        synchronized (PlacementRCTest04.lock) {
+            PlacementRCTest04.result += "End";
+        }
+    }
+}
+
+public class PlacementRCTest04 {
+    public static String result = "";
+    public static String lock = "";
+    static int res = 99;
+
+    public static void main(String[] argv) {
+        run1();
+        Runtime.getRuntime().runFinalization();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (result.contains("run1") && result.contains("run4") && result.contains("run5") && result.contains("run3")
+                && result.contains("run2") && result.contains("End")) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    private static int run1() {
+        int result = 2;
+        PlacementRC_A4 place = new PlacementRC_A4("run4");
+        try {
+            place.className = "run1";
+            synchronized (PlacementRCTest04.lock) {
+                PlacementRCTest04.result += "run1";
+            }
+            result = run2();
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+
+        if (res == 96) {
+            result = 0;
+            res--;
+        }
+        return result;
+    }
+
+    private static int run2() {
+        int result = 2;
+        try {
+            PlacementRC_A4 place = new PlacementRC_A4("run4");
+            result = run3();
+            place.changeName("run2");
+            synchronized (PlacementRCTest04.lock) {
+                PlacementRCTest04.result += "run2";
+            }
+        } catch (ClassCastException e) {
+            res -= 2;
+        }
+
+        if (res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int run3() {
+        int result = 3;
+        try {
+            result = run4();
+            PlacementRC_A4 place = new PlacementRC_A4("run4");
+            synchronized (PlacementRCTest04.lock) {
+                place.className = "run3";
+            }
+            PlacementRCTest04.result += place.className;
+        } catch (IllegalStateException e) {
+            res -= 3;
+        }
+
+        if (res == 94) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int run4() {
+        int result = 4;
+        try {
+            PlacementRC_A4 place = new PlacementRC_A4("run4");
+            place.className = "run4";
+            synchronized (PlacementRCTest04.lock) {
+                PlacementRCTest04.result += "run4";
+            }
+            result = run5();
+        } catch (IllegalFormatException e) {
+            res -= 4;
+        }
+
+        if (res == 93) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int run5() {
+        int result = 5;
+        try {
+            result = ExcpCover03330();
+        } catch (Exception e) {
+            res -= 5;
+        }
+        PlacementRC_A4 place = new PlacementRC_A4("   ");
+        if (res == 92) {
+            result = 0;
+        }
+        place.className = "run5";
+        synchronized (PlacementRCTest04.lock) {
+            PlacementRCTest04.result += "run5";
+        }
+        return result;
+    }
+
+    private static int ExcpCover03330() {
+        int result1 = 4;
+        PlacementRC_A4 place4 = new PlacementRC_A4("123#456");
+        try {
+            Integer.parseInt(place4.className);
+        } catch (IndexOutOfBoundsException e) {
+            res -= 10;
+        } catch (IllegalArgumentException e) {
+            res--;
+        } finally {
+            res--;
+            try {
+                place4 = new PlacementRC_A4("123#4567");
+                res += 100;
+                try {
+                    place4 = new PlacementRC_A4("123#4568");
+                    PlacementRC_A4 place09 = new PlacementRC_A4("123#4561");
+                    res += 100;
+                    place09.count = res;
+                    try {
+                        place4 = new PlacementRC_A4("123#4569");
+                        PlacementRC_A4 place9 = new PlacementRC_A4("123#4561");
+                        res += 100;
+                        place9.count = res;
+                        try {
+                            place4 = new PlacementRC_A4("123#4560");
+                            PlacementRC_A4 place18 = new PlacementRC_A4("123#4561");
+                            res += 100;
+                            place18.count = res;
+                            place9.count = place18.count;
+                            try {
+                                place4 = new PlacementRC_A4("123#4561");
+                                PlacementRC_A4 place19 = new PlacementRC_A4("123#4561");
+                                res += 100;
+                                place19.count = res;
+                                place9.count = place19.count;
+                                System.out.println(place4.className.substring(-5));
+                            } catch (ClassCastException e) {
+                                place9.className = "catch info 1";
+                                res -= 10;
+                            } finally {
+                                res -= 100;
+                            }
+                        } catch (ClassCastException e1) {
+                            place4.className = "catch info 2";
+                            res -= 10;
+                        } finally {
+                            res -= 100;
+                        }
+                    } catch (IllegalStateException e2) {
+                        place09.className = "catch info 3";
+                        res -= 10;
+                    } finally {
+                        res -= 100;
+                    }
+                } catch (ClassCastException e3) {
+                    place4.className = "catch info 4";
+                    res -= 10;
+                } finally {
+                    res -= 100;
+                }
+            } catch (IllegalArgumentException e4) {
+                place4.className = "catch info 5";
+                res -= 10;
+            } finally {
+                res -= 100;
+            }
+        }
+        res -= 10;
+        place4.count = result1;
+        return place4.count;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/FinalizerReferenceTest01.java b/test/testsuite/ouroboros/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/FinalizerReferenceTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c7c10b2acd1e96f7921712bfa25a6e1c4fe8d96
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/FinalizerReferenceTest01.java
@@ -0,0 +1,83 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest01
+ *- @TestCaseName: FinalizerReferenceTest01
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，软引用+FinalizerReference指向的对象内存回收正确。
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest01;
+ *  -#step2: 创建一个软引用指向ReferenceTest01的实例，判断无问题。
+ *  -#step3: oom触发GC，软引用无法通过get获得，finalize方法被调用。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest01.java
+ *- @ExecuteClass: FinalizerReferenceTest01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+
+public class FinalizerReferenceTest01 {
+    static int check = 3;
+
+    public static void main(String[] args) {
+        SoftReference<ReferenceTest01> softReference = new SoftReference<>(new ReferenceTest01(10));
+        ReferenceTest01 rt01 = softReference.get();
+        if (rt01.stringArray.length == 10 && rt01.stringArray[9].equals("test9")) {
+            check--;
+        }
+        rt01 = null;
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+        }
+        Runtime.getRuntime().runFinalization();
+        if (softReference.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    private static int oomTest() {
+        int sum = 0;
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+}
+
+class ReferenceTest01 {
+    String[] stringArray;
+
+    public ReferenceTest01(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        for (int i = 0; i < this.stringArray.length; i++) {
+            stringArray[i] = null;
+        }
+        System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/FinalizerReferenceTest02.java b/test/testsuite/ouroboros/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/FinalizerReferenceTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..237df66f9f7b329c5781ee8c3d6c12bd405feede
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/FinalizerReferenceTest02.java
@@ -0,0 +1,65 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest02
+ *- @TestCaseName: FinalizerReferenceTest02
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，弱引用+FinalizerReference指向的对象
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest02;
+ *  -#step2: 创建一个弱引用引用指向ReferenceTest02的实例，判断无问题。
+ *  -#step3: 触发用户GC，弱引用无法通过get获得，finalize方法被调用。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest02.java
+ *- @ExecuteClass: FinalizerReferenceTest02
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+
+public class FinalizerReferenceTest02 {
+    static int check = 2;
+
+    public static void main(String[] args) {
+        WeakReference<ReferenceTest02> weakReference = new WeakReference<>(new ReferenceTest02(10));
+        ReferenceTest02 rt02 = weakReference.get();
+        if (rt02.stringArray.length == 10 && rt02.stringArray[9].equals("test9")) {
+            check--;
+        }
+        rt02 = null;
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        if (weakReference.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+
+class ReferenceTest02 {
+    String[] stringArray;
+
+    public ReferenceTest02(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        for (int i = 0; i < this.stringArray.length; i++) {
+            stringArray[i] = null;
+        }
+        System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/FinalizerReferenceTest03.java b/test/testsuite/ouroboros/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/FinalizerReferenceTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..6af77f9ef2657a734cf36323c78afc59b42790e2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/FinalizerReferenceTest03.java
@@ -0,0 +1,61 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest03
+ *- @TestCaseName: FinalizerReferenceTest03
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，虚引用+FinalizerReference指向的对象
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest03;
+ *  -#step2: 创建一个虚引用引用指向ReferenceTest03的实例，判断无问题。
+ *  -#step3: 触发用户GC，虚引用无法通过get获得，finalize方法被调用。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest03.java
+ *- @ExecuteClass: FinalizerReferenceTest03
+ *- @ExecuteArgs:
+ */
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+
+public class FinalizerReferenceTest03 {
+    static int check = 1;
+
+    public static void main(String[] args) {
+        ReferenceQueue referenceQueue = new ReferenceQueue();
+        PhantomReference<ReferenceTest03> pr = new PhantomReference<>(new ReferenceTest03(10), referenceQueue);
+        if (pr.get() == null) {
+            check--;
+        }
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+
+class ReferenceTest03 {
+    String[] stringArray;
+
+    public ReferenceTest03(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        for (int i = 0; i < this.stringArray.length; i++) {
+            stringArray[i] = null;
+        }
+        System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/FinalizerReferenceTest04.java b/test/testsuite/ouroboros/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/FinalizerReferenceTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..96875430e34031c1f6c4aaf4e41e46cc744e4ab6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/FinalizerReferenceTest04.java
@@ -0,0 +1,52 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest04
+ *- @TestCaseName: FinalizerReferenceTest04
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，Cleaner+FinalizerReference指向的对象
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest04;
+ *  -#step2: 创建一个cleaner引用指向ReferenceTest04的实例。
+ *  -#step3: 触发用户GC，虚引用无法通过get获得，finalize方法被调用。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest04.java
+ *- @ExecuteClass: FinalizerReferenceTest04
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Cleaner;
+
+public class FinalizerReferenceTest04 {
+    static Cleaner cleaner;
+
+    public static void main(String[] args) {
+        Cleaner.create(new ReferenceTest04(10), null);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+    }
+}
+
+class ReferenceTest04 {
+    String[] stringArray;
+
+    public ReferenceTest04(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        for (int i = 0; i < this.stringArray.length; i++) {
+            stringArray[i] = null;
+        }
+        System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/FinalizerReferenceTest05.java b/test/testsuite/ouroboros/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/FinalizerReferenceTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..dab5df13f798d495955347666870303afbbba7a8
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/FinalizerReferenceTest05.java
@@ -0,0 +1,85 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest05
+ *- @TestCaseName: FinalizerReferenceTest05
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，软引用+FinalizerReference指向的对象内存回收正确。
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest05,
+ *  -#step2: 该实例的对象gc回收时，finalize方法会将其关联到一个软引用上，判断无问题。
+ *  -#step3: oom触发GC，软引用无法通过get获得finalize方法不再被调用。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest05.java
+ *- @ExecuteClass: FinalizerReferenceTest05
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+
+public class FinalizerReferenceTest05 {
+    static SoftReference<ReferenceTest05> sr05;
+    static int check = 3;
+
+    public static void main(String[] args) {
+        new ReferenceTest05(10);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        ReferenceTest05 rt05 = sr05.get();
+        if (rt05.stringArray.length == 10 && rt05.stringArray[9].equals("test9")) {
+            check--;
+        }
+        rt05 = null;
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+        }
+        Runtime.getRuntime().runFinalization();
+        if (sr05.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    private static int oomTest() {
+        int sum = 0;
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+}
+
+class ReferenceTest05 {
+    String[] stringArray;
+
+    public ReferenceTest05(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+        FinalizerReferenceTest05.sr05 = new SoftReference(this);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/FinalizerReferenceTest06.java b/test/testsuite/ouroboros/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/FinalizerReferenceTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..f81e20f3931df789b62a083b4cf8fd69397e1be8
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/FinalizerReferenceTest06.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest06
+ *- @TestCaseName: FinalizerReferenceTest06
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，弱引用+FinalizerReference指向的对象内存回收正确。
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest06,
+ *  -#step2: 该实例的对象gc回收时，finalize方法会将其关联到一个弱引用上，判断无问题。
+ *  -#step3: 触发用户GC，弱引用无法通过get获得finalize方法不再被调用。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest06.java
+ *- @ExecuteClass: FinalizerReferenceTest06
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+
+public class FinalizerReferenceTest06 {
+    static WeakReference<ReferenceTest06> sr06;
+    static int check = 2;
+
+    public static void main(String[] args) {
+        new ReferenceTest06(10);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        if (sr06.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+
+class ReferenceTest06 {
+    String[] stringArray;
+
+    public ReferenceTest06(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+        FinalizerReferenceTest06.sr06 = new WeakReference<>(this);
+        ReferenceTest06 rt06 = FinalizerReferenceTest06.sr06.get();
+        if (rt06.stringArray.length == 10 && rt06.stringArray[9].equals("test9")) {
+            FinalizerReferenceTest06.check--;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/FinalizerReferenceTest07.java b/test/testsuite/ouroboros/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/FinalizerReferenceTest07.java
new file mode 100755
index 0000000000000000000000000000000000000000..a226dcaddaaa8eac56af415d2117a43dfcd834dc
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/FinalizerReferenceTest07.java
@@ -0,0 +1,72 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest07
+ *- @TestCaseName: FinalizerReferenceTest07
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Conditon:
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，虚引用+FinalizerReference指向的对象内存回收正确。
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest07,
+ *  -#step2: 该实例的对象gc回收时，finalize方法会将其关联到一个虚引用上，判断无问题。
+ *  -#step3: 触发用户GC，虚引用无法通过get获得finalize方法不再被调用。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest07.java
+ *- @ExecuteClass: FinalizerReferenceTest07
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+
+public class FinalizerReferenceTest07 {
+    static ReferenceQueue referenceQueue = new ReferenceQueue();
+    static PhantomReference<ReferenceTest07> sr07;
+    static int check = 2;
+
+    public static void main(String[] args) {
+        new ReferenceTest07(10);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        if (sr07.get() == null) {
+            check--;
+        }
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (referenceQueue.poll() != null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+
+class ReferenceTest07 {
+    String[] stringArray;
+
+    public ReferenceTest07(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+        FinalizerReferenceTest07.sr07 = new PhantomReference<>(this, FinalizerReferenceTest07.referenceQueue);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/FinalizerReferenceTest08.java b/test/testsuite/ouroboros/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/FinalizerReferenceTest08.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c5139d90c1c84e7e96ef286e2141ad33f5acd7b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/FinalizerReferenceTest08.java
@@ -0,0 +1,54 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_FinalizerReferenceTest08
+ *- @TestCaseName: FinalizerReferenceTest08
+ *- @TestCaseType: Function Testing for FinalizerReference Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，Cleaner+FinalizerReference指向的对象内存回收正确。
+ *  -#step1: 创建带有重构finalize方法的类ReferenceTest08,
+ *  -#step2: 该实例的对象gc回收时，finalize方法会将其关联到一个虚引用上，判断无问题。
+ *  -#step3: 触发用户GC，虚引用无法通过get获得finalize方法不再被调用。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: FinalizerReferenceTest08.java
+ *- @ExecuteClass: FinalizerReferenceTest08
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Cleaner;
+
+public class FinalizerReferenceTest08 {
+    static Cleaner cleaner;
+    static int check = 2;
+
+    public static void main(String[] args) {
+        new ReferenceTest08(10);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+    }
+}
+
+class ReferenceTest08 {
+    String[] stringArray;
+
+    public ReferenceTest08(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+        Cleaner.create(this, null);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0457-rc-GC-TriggerGCTest01/TriggerGCTest01.java b/test/testsuite/ouroboros/rc_test/RC0457-rc-GC-TriggerGCTest01/TriggerGCTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ca2bb1eb8696fbfe76e7f623d5fe9c8910c7688
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0457-rc-GC-TriggerGCTest01/TriggerGCTest01.java
@@ -0,0 +1,62 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_TriggerGCTest01
+ *- @TestCaseName: TriggerGCTest01
+ *- @TestCaseType: Function Testing for TriggerGC Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，用户通过System.gc()进行内存回收时处理正确。
+ *  -#step1: 创建一个弱引用，判断该引用可以通过get（）正常获得object;
+ *  -#step2: 在一个线程中创建一个60个无RP关联的弱引用，再次判断步骤一里创建的弱引用仍然可以通过get()方法获得对象。
+ *  -#step3: 用户调用System.gc()触发GC，判断该引用被回收到的RP中。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: TriggerGCTest01.java
+ *- @ExecuteClass: TriggerGCTest01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class TriggerGCTest01 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+
+    static void setWeakReference() {
+        rp = new WeakReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            a++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        Reference r;
+        setWeakReference();
+        new Thread(new TriggerRP()).start();
+        Runtime.getRuntime().gc();
+        Thread.sleep(1000);
+        if (rp.get() != null) {
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 60; i++) {
+                WeakReference wr = new WeakReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
diff --git a/test/testsuite/ouroboros/rc_test/RC0458-rc-GC-TriggerGCTest02/TriggerGCTest02.java b/test/testsuite/ouroboros/rc_test/RC0458-rc-GC-TriggerGCTest02/TriggerGCTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..111cdb97c9fb63da0124da3b170d38d01f0f834c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0458-rc-GC-TriggerGCTest02/TriggerGCTest02.java
@@ -0,0 +1,62 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_TriggerGCTest02
+ *- @TestCaseName: TriggerGCTest02
+ *- @TestCaseType: Function Testing for TriggerGC Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，用户通过Runtime.getRuntime().gc()进行内存回收时处理正确。
+ *  -#step1: 创建一个弱引用，判断该引用可以通过get（）正常获得object;
+ *  -#step2: 在一个线程中创建一个60个无RP关联的弱引用，再次判断步骤一里创建的弱引用仍然可以通过get()方法获得对象。
+ *  -#step3: 用户调用Runtime.getRuntime().gc()触发GC，判断该引用被回收到的RP中。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: TriggerGCTest02.java
+ *- @ExecuteClass: TriggerGCTest02
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class TriggerGCTest02 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+
+    static void setWeakReference() {
+        rp = new WeakReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            a++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        Reference r;
+        setWeakReference();
+        new Thread(new TriggerRP()).start();
+        Runtime.getRuntime().gc();
+        if (rp.get() != null) {
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 60; i++) {
+                WeakReference wr = new WeakReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0459-rc-GC-TriggerGCTest03/TriggerGCTest03.java b/test/testsuite/ouroboros/rc_test/RC0459-rc-GC-TriggerGCTest03/TriggerGCTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..caa1fc0e1f1cf3ce17d62eccbcdd5c9f99cd89cf
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0459-rc-GC-TriggerGCTest03/TriggerGCTest03.java
@@ -0,0 +1,73 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_TriggerGCTest03
+ *- @TestCaseName: TriggerGCTest03
+ *- @TestCaseType: Function Testing for TriggerGC Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，OOM时会触发GC进行内存回收。
+ *  -#step1: 创建一个软引用，判断该引用可以通过get（）正常获得object;
+ *  -#step2: 用户调用oomTest()触发GC，判断该引用被回收。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: TriggerGCTest03.java
+ *- @ExecuteClass: TriggerGCTest03
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+
+public class TriggerGCTest03 {
+    static int check = 3;
+
+    public static void main(String[] args) {
+        SoftReference<Reference03> softReference = new SoftReference<>(new Reference03(100000));
+        Reference03 rt01 = softReference.get();
+        if (rt01.stringArray.length == 100000 && rt01.stringArray[9].equals("test9")) {
+            check--;
+        }
+        rt01 = null;
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+            Runtime.getRuntime().runFinalization();
+            if (softReference.get() == null) {
+                check--;
+            }
+            if (check == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println("ErrorResult");
+            }
+        }
+    }
+
+    private static int oomTest() {
+        int sum = 0;
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1034 * 1034; i <= 1034 * 1034 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+}
+
+class Reference03 {
+    String[] stringArray;
+
+    public Reference03(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0463-rc-GC-TriggerGCTest07/TriggerGCTest07.java b/test/testsuite/ouroboros/rc_test/RC0463-rc-GC-TriggerGCTest07/TriggerGCTest07.java
new file mode 100644
index 0000000000000000000000000000000000000000..da3c0c603eedb51d11e55117588323956fda3611
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0463-rc-GC-TriggerGCTest07/TriggerGCTest07.java
@@ -0,0 +1,52 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_TriggerGCTest07
+ *- @TestCaseName: TriggerGCTest07
+ *- @TestCaseType: Function Testing for TriggerGC Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:当前初始阈值是100MB，会隐式触发GC。
+ *  -#step1:创建一个弱引用，检查它可以通过get()方法获得关联的引用对象。
+ *  -#step2:通过1个for循环，分配内存到100M。
+ *  -#step3:验证GC被隐式触发，步骤1中创建的弱引用被回收掉了。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: TriggerGCTest07.java
+ *- @ExecuteClass: TriggerGCTest07
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+
+public class TriggerGCTest07 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int INIT_MEMORY = 100; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+
+    public static void main(String[] args) throws Exception {
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        for (int i = 0; i < INIT_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(3000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0464-rc-GC-TriggerGCTest08/TriggerGCTest08.java b/test/testsuite/ouroboros/rc_test/RC0464-rc-GC-TriggerGCTest08/TriggerGCTest08.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ed76cdbaaace1f26ac4cff95d334553c1b8185e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0464-rc-GC-TriggerGCTest08/TriggerGCTest08.java
@@ -0,0 +1,59 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_TriggerGCTest08
+ *- @TestCaseName: TriggerGCTest08
+ *- @TestCaseType: Function Testing for TriggerGC Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:当前初始阈值是100MB，每次已分配内存超过阈值时会将阈值乘以1.5的系数并设为新的阈值。
+ *  -#step1: 通过1个for循环，分配内存到100M。
+ *  -#step2:创建一个弱引用，检查它可以通过get()方法获得关联的引用对象。
+ *  -#step3:再次将内存分配到100*1.5=150M
+ *  -#step4:验证GC被隐式触发，步骤1中创建的弱引用被回收掉了。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: TriggerGCTest08.java
+ *- @ExecuteClass: TriggerGCTest08
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+
+public class TriggerGCTest08 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int INIT_MEMORY = 100; // MB
+    private final static int SEC_MEMORY = 150; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < INIT_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(2000);
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        for (int i = INIT_MEMORY; i < SEC_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(3000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0465-rc-GC-TriggerGCTest09/TriggerGCTest09.java b/test/testsuite/ouroboros/rc_test/RC0465-rc-GC-TriggerGCTest09/TriggerGCTest09.java
new file mode 100644
index 0000000000000000000000000000000000000000..148b75ce119686caf1fcc52e29031401d55766d2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0465-rc-GC-TriggerGCTest09/TriggerGCTest09.java
@@ -0,0 +1,59 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_TriggerGCTest09
+ *- @TestCaseName: TriggerGCTest09
+ *- @TestCaseType: Function Testing for TriggerGC Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:当前初始阈值是100MB，每次已分配内存超过阈值时会将阈值乘以1.5的系数并设为新的阈值。
+ *  -#step1: 通过1个for循环，分配内存到150M。
+ *  -#step2:创建一个弱引用，检查它可以通过get()方法获得关联的引用对象。
+ *  -#step3:再次将内存分配到150*1.5=225M
+ *  -#step4:验证GC被隐式触发，步骤1中创建的弱引用被回收掉了。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: TriggerGCTest09.java
+ *- @ExecuteClass: TriggerGCTest09
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+
+public class TriggerGCTest09 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int SEC_MEMORY = 150; // MB
+    private final static int TRI_MEMORY = 225; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < SEC_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(2000);
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        for (int i = SEC_MEMORY; i < TRI_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(3000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0466-rc-GC-TriggerGCTest10/TriggerGCTest10.java b/test/testsuite/ouroboros/rc_test/RC0466-rc-GC-TriggerGCTest10/TriggerGCTest10.java
new file mode 100644
index 0000000000000000000000000000000000000000..50ed8e98090d93f3398069fbc3c7e885651d6448
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0466-rc-GC-TriggerGCTest10/TriggerGCTest10.java
@@ -0,0 +1,63 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_TriggerGCTest10
+ *- @TestCaseName: TriggerGCTest10
+ *- @TestCaseType: Function Testing for TriggerGC Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:当前初始阈值是100MB，每次已分配内存超过阈值时会将阈值乘以1.5的系数并设为新的阈值。
+ *  -#step1: 通过1个for循环，分配内存到225M。
+ *  -#step2:创建一个弱引用，检查它可以通过get()方法获得关联的引用对象。
+ *  -#step3:再次将内存分配到350M,因为可能会OOM，加了一个try-catch
+ *  -#step4:验证GC被隐式触发，步骤1中创建的弱引用被回收掉了。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: TriggerGCTest10.java
+ *- @ExecuteClass: TriggerGCTest10
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+
+public class TriggerGCTest10 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int TRI_MEMORY = 225; // MB
+    private final static int FOU_MEMORY = 350; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < TRI_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(2000);
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        try {
+            for (int i = TRI_MEMORY; i < FOU_MEMORY; i++) {
+                byte[] temp = new byte[1024 * 1024];
+                store.add(temp);
+            }
+        } catch (OutOfMemoryError e) {
+            // do nothing
+        }
+        Thread.sleep(1000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/ArrayCloneTest.java b/test/testsuite/ouroboros/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/ArrayCloneTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9cee681c3e18496c656717ccc6a2ba6f63ec80f4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/ArrayCloneTest.java
@@ -0,0 +1,38 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_ArrayCloneTest
+ *- @TestCaseName: ArrayCloneTest
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:clone()函数专项测试：验证数组的clone()方法的基本功能正常。
+ *  -#step1:测试正常数组拷贝
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: ArrayCloneTest.java
+ *- @ExecuteClass: ArrayCloneTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+public class ArrayCloneTest {
+    public static void main(String[] args) {
+        if (functionTest01()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    private static boolean functionTest01() {
+        String[] test1 = {"test1","test2","test3","test4","test5","test6","test7","test8","test9","test10"};
+        String[] test2 = test1.clone();
+        if (test2 != test1  && test2.length == 10 && test2[0].equals("test1") && test2[9].equals("test10")) {
+            return true;
+        }
+        return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/ArrayCloneTest02.java b/test/testsuite/ouroboros/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/ArrayCloneTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..9566cb288feabc801991bd7a51a30c66244e5496
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/ArrayCloneTest02.java
@@ -0,0 +1,52 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_ArrayCloneTest02
+ *- @TestCaseName: ArrayCloneTest02
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:clone()函数专项测试：验证数组的clone()方法的基本功能正常。
+ *  -#step1:测试数组拷贝时报CloneNotSupportedException异常
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: ArrayCloneTest02.java
+ *- @ExecuteClass: ArrayCloneTest02
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+public class ArrayCloneTest02 {
+    private Integer id;
+
+    public ArrayCloneTest02(Integer id) {
+        this.id = id;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    @Override
+    public String toString() {
+        return "CloneTest{" +
+                "id=" + id +
+                '}';
+    }
+
+    public static void main(String[] args) {
+        try {
+            ArrayCloneTest02 cloneTest = new ArrayCloneTest02(1);
+            ArrayCloneTest02 cloneTest1 = (ArrayCloneTest02) cloneTest.clone();
+            System.out.println("ErrorResult");
+        } catch (CloneNotSupportedException e) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/ArrayCopyTest.java b/test/testsuite/ouroboros/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/ArrayCopyTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b58ac82695238506ea5e4b9325b07bb1f9362d03
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/ArrayCopyTest.java
@@ -0,0 +1,78 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_ArrayCopyTest
+ *- @TestCaseName: ArrayCopyTest
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:ArrayCopy函数专项测试：验证ArrayCopy方法的基本功能正常。
+ *  -#step1:测试正常数组拷贝
+ *  -#step2:测试拷贝过程中出现ArrayStoreException异常
+ *  -#step3:测试拷贝过程中出现ArrayIndexOutOfBoundsException异常
+ *  -#step4:测试拷贝过程中出现NullPointerException异常
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: ArrayCopyTest.java
+ *- @ExecuteClass: ArrayCopyTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+public class ArrayCopyTest {
+    public static void main(String[] args) {
+        if (functionTest01() && functionTest02() && functionTest03() && functionTest04()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    private static boolean functionTest01() {
+        String[] test1 = {"test1","test2","test3","test4","test5","test6","test7","test8","test9","test10"};
+        String[] test2 = new String[10];
+        System.arraycopy(test1,0,test2,0,10);
+        if (test2[0].equals("test1") && test2[9].equals("test10")) {
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean functionTest02() {
+        try {
+            String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+            int[] test2 = new int[10];
+            System.arraycopy(test1, 0, test2, 0, 10);
+
+        } catch (ArrayStoreException e) {
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean functionTest03() {
+        try {
+            String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+            String[] test2 = new String[9];
+            System.arraycopy(test1, 0, test2, 0, 10);
+
+        } catch (ArrayIndexOutOfBoundsException e) {
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean functionTest04() {
+        try {
+            String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+            String[] test2 = null;
+            System.arraycopy(test1, 0, test2, 0, 10);
+
+        } catch (NullPointerException e) {
+            return true;
+        }
+        return false;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0477-rc-StackScan-CB_01/CB_01.java b/test/testsuite/ouroboros/rc_test/RC0477-rc-StackScan-CB_01/CB_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..b33abc90f88a4fe62e27f4c8b2247ccd35cf9d91
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0477-rc-StackScan-CB_01/CB_01.java
@@ -0,0 +1,431 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB01
+ *- @TestCaseName: CB_01
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: Cycle is Cycle_a_0038.java;Nocycle is Nocycle_00180.java
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考Nocycle_00180.java，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_01.java
+ *- @ExecuteClass: CB_01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.util.HashMap;
+
+class CB_Nolcycle_a_00180_A1 {
+    CB_Nolcycle_a_00180_B1 b1_0;
+    CB_Nolcycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_A2 {
+    CB_Nolcycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_A3 {
+    CB_Nolcycle_a_00180_B2 b2_0;
+    CB_Nolcycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class CB_Nolcycle_a_00180_A4 {
+    CB_Nolcycle_a_00180_B3 b3_0;
+    CB_Nolcycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_B1 {
+    CB_Nolcycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_B2 {
+    CB_Nolcycle_a_00180_C1 c1_0;
+    CB_Nolcycle_a_00180_D1 d1_0;
+    CB_Nolcycle_a_00180_D2 d2_0;
+    CB_Nolcycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_B3 {
+    CB_Nolcycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_C1 {
+    CB_Nolcycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class CB_Nolcycle_a_00180_C2 {
+    CB_Nolcycle_a_00180_D2 d2_0;
+    CB_Nolcycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+
+class CB_Nolcycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CB_Nolcycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+//该树有12个节点
+class CB_Nolcycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nolcycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CB_Nolcycle_a_00180 {
+    public CB_Nolcycle_a_00180() {
+        CB_Nolcycle_a_00180_A1 a1_main = new CB_Nolcycle_a_00180_A1("a1_main");
+        CB_Nolcycle_a_00180_A2 a2_main = new CB_Nolcycle_a_00180_A2("a2_main");
+        CB_Nolcycle_a_00180_A3 a3_main = new CB_Nolcycle_a_00180_A3("a3_main");
+        CB_Nolcycle_a_00180_A4 a4_main = new CB_Nolcycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new CB_Nolcycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+
+        a2_main.b2_0 = new CB_Nolcycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new CB_Nolcycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+
+        a3_main.b2_0 = new CB_Nolcycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new CB_Nolcycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+
+        a3_main.c2_0 = new CB_Nolcycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+
+        a4_main.b3_0 = new CB_Nolcycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new CB_Nolcycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new CB_Nolcycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+    }
+}
+
+class CB_01_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_01_A2 a2_0;
+    CB_01_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_01_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        //System.out.println("A finalize");
+
+        CB_01.check = this;
+
+    }
+}
+
+class CB_01_A2 {
+    static CB_01_A1 a1_0;
+    volatile static HashMap test2;
+    CB_01_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_01_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_01_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_01_A3 {
+    static CB_Nolcycle_a_00180[] test1;
+    CB_01_A1 a1_0;
+    CB_01_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_01_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_01_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_01 {
+    public static CB_01_A1 check = null;
+    private static CB_01_A1 a1_main = null;
+
+    private CB_01() {
+        a1_main = new CB_01_A1("a1_main");
+        a1_main.a2_0 = new CB_01_A2("a2_0");
+        CB_01_A2.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_01_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_01(int times) {
+        CB_01_A1.test1 = new HashMap();
+        CB_01_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_01_A1.test1.put(i, new CB_Nolcycle_a_00180());
+            CB_01_A2.test2.put(i, new CB_Nolcycle_a_00180());
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_01 cb01 = new CB_01();
+        test_CB_01(10000);
+        check = a1_main;
+        try {
+            int result = CB_01.check.sum + CB_01.check.a2_0.sum + CB_01.check.a2_0.a3_0.sum + CB_01_A1.test1.size() + CB_01_A2.test2.size();
+            if (result == 20918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0478-rc-StackScan-CB_02/CB_02.java b/test/testsuite/ouroboros/rc_test/RC0478-rc-StackScan-CB_02/CB_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3b87a7ac1d381476c6b2af43df602ef8ddffb32
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0478-rc-StackScan-CB_02/CB_02.java
@@ -0,0 +1,147 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB02
+ *- @TestCaseName: CB_02
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: Cycle is Cycle_a_0038.java;Node is String
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为String类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_02.java
+ *- @ExecuteClass: CB_02
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.util.HashMap;
+
+class CB_02_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_02_A2 a2_0;
+    CB_02_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_02_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_02.check = this;
+    }
+}
+
+class CB_02_A2 {
+    volatile static HashMap test2;
+    CB_02_A1 a1_0;
+    CB_02_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_02_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_02_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_02_A3 {
+    CB_02_A1 a1_0;
+    CB_02_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_02_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_02_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_02 {
+    public volatile static CB_02_A1 check = null;
+    private static CB_02_A1 a1_main = null;
+
+    private CB_02() {
+        a1_main = new CB_02_A1("a1_main");
+        a1_main.a2_0 = new CB_02_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_02_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_02(int times) {
+        CB_02_A1.test1 = new HashMap();
+        CB_02_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_02_A1.test1.put(i, "Maple" + i);
+            CB_02_A2.test2.put(i, "Figo" + i);
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_02 cb01 = new CB_02();
+        test_CB_02(100000);
+        check = a1_main;
+        try {
+            int result = CB_02.check.sum + CB_02.check.a2_0.sum + CB_02.check.a2_0.a3_0.sum + CB_02_A1.test1.size() + CB_02_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0479-rc-StackScan-CB_03/CB_03.java b/test/testsuite/ouroboros/rc_test/RC0479-rc-StackScan-CB_03/CB_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..df2b8069f3c9f49b1bcd0d10ce8437bc2dc0e938
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0479-rc-StackScan-CB_03/CB_03.java
@@ -0,0 +1,142 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB03
+ *- @TestCaseName: CB_03
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: Cycle is Cycle_a_0038.java;Node is StringBuffer
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为StringBuffer类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_03.java
+ *- @ExecuteClass: CB_03
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.util.HashMap;
+
+class CB_03_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_03_A2 a2_0;
+    CB_03_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_03_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_03.check = this;
+    }
+}
+
+class CB_03_A2 {
+    CB_03_A1 a1_0;
+    CB_03_A3 a3_0;
+    volatile HashMap test2;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_03_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_03_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_03_A3 {
+    CB_03_A1 a1_0;
+    CB_03_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_03_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_03_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_03 {
+    public volatile static CB_03_A1 check = null;
+    private static CB_03_A1 a1_main = null;
+
+    private CB_03() {
+        a1_main = new CB_03_A1("a1_main");
+        a1_main.a2_0 = new CB_03_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_03_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_03(int times) {
+        CB_03_A1.test1 = new HashMap();
+        a1_main.a2_0.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_03_A1.test1.put(i, new StringBuffer("Maple test").append(i));
+            a1_main.a2_0.test2.put(i, new StringBuffer("Figo test").append(i));
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_03 cb01 = new CB_03();
+        test_CB_03(100000);
+        check = a1_main;
+        try {
+            int result = CB_03.check.sum + CB_03.check.a2_0.sum + CB_03.check.a2_0.a3_0.sum + CB_03_A1.test1.size() + check.a2_0.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0480-rc-StackScan-CB_04/CB_04.java b/test/testsuite/ouroboros/rc_test/RC0480-rc-StackScan-CB_04/CB_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..081645ceb03a82d48d99a289a7fe598da4294cf2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0480-rc-StackScan-CB_04/CB_04.java
@@ -0,0 +1,152 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB04
+ *- @TestCaseName: CB_04
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: Cycle is Cycle_a_0038.java;Node is StringBuilder
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为StringBuilder类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_04.java
+ *- @ExecuteClass: CB_04
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.util.HashMap;
+
+class CB_04_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_04_A2 a2_0;
+    CB_04_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_04_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("A finalize");
+
+        CB_04.check = this;
+
+    }
+
+}
+
+class CB_04_A2 {
+    volatile static HashMap test2;
+    CB_04_A1 a1_0;
+    CB_04_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_04_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_04_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("B finalize");
+    }
+}
+
+class CB_04_A3 {
+    CB_04_A1 a1_0;
+    CB_04_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_04_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + CB_04_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_04 {
+    public static CB_04_A1 a1_main = null;
+    public volatile static CB_04_A1 check = null;
+
+    public CB_04() {
+        a1_main = new CB_04_A1("a1_main");
+        a1_main.a2_0 = new CB_04_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_04_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    public static void test_CB_04(int times) {
+        CB_04_A1.test1 = new HashMap();
+        CB_04_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_04_A1.test1.put(i, new StringBuilder().append(i));
+            CB_04_A2.test2.put(i, new StringBuilder().append(times + i));
+        }
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        CB_04 cb01 = new CB_04();
+        test_CB_04(100000);
+        check = a1_main;
+        try {
+            int result = CB_04.check.sum + CB_04.check.a2_0.sum + CB_04.check.a2_0.a3_0.sum + CB_04_A1.test1.size() + CB_04_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0481-rc-StackScan-CB_05/CB_05.java b/test/testsuite/ouroboros/rc_test/RC0481-rc-StackScan-CB_05/CB_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..a930d242cdc712af39598f487dcf287a4d81af09
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0481-rc-StackScan-CB_05/CB_05.java
@@ -0,0 +1,145 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB05
+ *- @TestCaseName: CB_05
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: Cycle is Cycle_a_0038.java;Node is SoftReference
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为SoftReference类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_05.java
+ *- @ExecuteClass: CB_05
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.SoftReference;
+import java.util.HashMap;
+
+class CB_05_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_05_A2 a2_0;
+    CB_05_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_05_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_05.check = this;
+
+    }
+}
+
+class CB_05_A2 {
+    volatile static HashMap test2;
+    CB_05_A1 a1_0;
+    CB_05_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_05_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_05_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_05_A3 {
+    CB_05_A1 a1_0;
+    CB_05_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_05_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_05_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_05 {
+    public volatile static CB_05_A1 check = null;
+    private static CB_05_A1 a1_main = null;
+
+    private CB_05() {
+        a1_main = new CB_05_A1("a1_main");
+        a1_main.a2_0 = new CB_05_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_05_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_05(int times) {
+        CB_05_A1.test1 = new HashMap();
+        CB_05_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_05_A1.test1.put(i, new SoftReference<>("maple" + i));
+            CB_05_A2.test2.put(i, new SoftReference<>("maple" + times + i));
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_05 cb01 = new CB_05();
+        test_CB_05(10000);
+        check = a1_main;
+        try {
+            int result = CB_05.check.sum + CB_05.check.a2_0.sum + CB_05.check.a2_0.a3_0.sum + CB_05_A1.test1.size() + CB_05_A2.test2.size();
+            if (result == 20918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0482-rc-StackScan-CB_06/CB_06.java b/test/testsuite/ouroboros/rc_test/RC0482-rc-StackScan-CB_06/CB_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1002faf03dfcde1014fe6e13d95e2142ed1d439
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0482-rc-StackScan-CB_06/CB_06.java
@@ -0,0 +1,145 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB06
+ *- @TestCaseName: CB_06
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: Cycle is Cycle_a_0038.java;Node is WeakReference
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为WeakReference类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_06.java
+ *- @ExecuteClass: CB_06
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+
+class CB_06_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_06_A2 a2_0;
+    CB_06_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_06_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_06.check = this;
+    }
+}
+
+class CB_06_A2 {
+    volatile static HashMap test2;
+    CB_06_A1 a1_0;
+    CB_06_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_06_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_06_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_06_A3 {
+    CB_06_A1 a1_0;
+    CB_06_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_06_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_06_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_06 {
+    public volatile static CB_06_A1 check = null;
+    static String str;
+    private static CB_06_A1 a1_main = null;
+
+    private CB_06() {
+        a1_main = new CB_06_A1("a1_main");
+        a1_main.a2_0 = new CB_06_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_06_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_06(int times) {
+        CB_06_A1.test1 = new HashMap();
+        CB_06_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_06_A1.test1.put(i, new WeakReference("Maple" + i));
+            CB_06_A2.test2.put(i, new WeakReference("Figo" + i));
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_06 cb01 = new CB_06();
+        test_CB_06(100000);
+        check = a1_main;
+        try {
+            int result = CB_06.check.sum + CB_06.check.a2_0.sum + CB_06.check.a2_0.a3_0.sum + CB_06_A1.test1.size() + CB_06_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0483-rc-StackScan-CB_07/CB_07.java b/test/testsuite/ouroboros/rc_test/RC0483-rc-StackScan-CB_07/CB_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..480b550a222f65364c72a3a67b9d6f0013d98a3a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0483-rc-StackScan-CB_07/CB_07.java
@@ -0,0 +1,147 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB07
+ *- @TestCaseName: CB_07
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: Cycle is Cycle_a_0038.java;Node is PhantomReference
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为PhantomReference类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_07.java
+ *- @ExecuteClass: CB_07
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+import java.util.HashMap;
+
+class CB_07_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_07_A2 a2_0;
+    CB_07_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_07_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_07.check = this;
+    }
+}
+
+class CB_07_A2 {
+    volatile static HashMap test2;
+    CB_07_A1 a1_0;
+    CB_07_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_07_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_07_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_07_A3 {
+    CB_07_A1 a1_0;
+    CB_07_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_07_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_07_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_07 {
+    public volatile static CB_07_A1 check = null;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static String str;
+    private static CB_07_A1 a1_main = null;
+
+    private CB_07() {
+        a1_main = new CB_07_A1("a1_main");
+        a1_main.a2_0 = new CB_07_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_07_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_07(int times) {
+        CB_07_A1.test1 = new HashMap();
+        CB_07_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_07_A1.test1.put(i, new PhantomReference<>("maple" + i, rq));
+            CB_07_A2.test2.put(i, new PhantomReference<>("Figo" + times + i, rq));
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_07 cb01 = new CB_07();
+        test_CB_07(100000);
+        check = a1_main;
+        try {
+            int result = CB_07.check.sum + CB_07.check.a2_0.sum + CB_07.check.a2_0.a3_0.sum + CB_07_A1.test1.size() + CB_07_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0484-rc-StackScan-CB_08/CB_08.java b/test/testsuite/ouroboros/rc_test/RC0484-rc-StackScan-CB_08/CB_08.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b907d5f6df71ccddb431e4fa1bb1e10b0fc42fe
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0484-rc-StackScan-CB_08/CB_08.java
@@ -0,0 +1,148 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB08
+ *- @TestCaseName: CB_08
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: Cycle is Cycle_a_0038.java;Node is OutOfMemoryError
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为OutOfMemoryError类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_08.java
+ *- @ExecuteClass: CB_08
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.util.HashMap;
+
+class CB_08_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_08_A2 a2_0;
+    CB_08_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_08_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_08.check = this;
+    }
+
+}
+
+class CB_08_A2 {
+    volatile static HashMap test2;
+    CB_08_A1 a1_0;
+    CB_08_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_08_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_08_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_08_A3 {
+    CB_08_A1 a1_0;
+    CB_08_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_08_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_08_A1.a + a2_0.a;
+    }
+}
+
+
+public class CB_08 {
+    public volatile static CB_08_A1 check = null;
+    private static CB_08_A1 a1_main = null;
+    private volatile static OutOfMemoryError test1;
+    private static OutOfMemoryError test2;
+
+    private CB_08() {
+        a1_main = new CB_08_A1("a1_main");
+        a1_main.a2_0 = new CB_08_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_08_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    private static void test_CB_08(int times) {
+        CB_08_A1.test1 = new HashMap();
+        CB_08_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            test1 = new OutOfMemoryError();
+            CB_08_A1.test1.put(i, test1);
+            test2 = new OutOfMemoryError();
+            CB_08_A2.test2.put(i, test2);
+        }
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        CB_08 cb01 = new CB_08();
+        test_CB_08(100000);
+        check = a1_main;
+        try {
+            int result = CB_08.check.sum + CB_08.check.a2_0.sum + CB_08.check.a2_0.a3_0.sum + CB_08_A1.test1.size() + CB_08_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0485-rc-StackScan-CB_09/CB_09.java b/test/testsuite/ouroboros/rc_test/RC0485-rc-StackScan-CB_09/CB_09.java
new file mode 100644
index 0000000000000000000000000000000000000000..a810103d05b5dc6ca890e8ed371a8ac7b95d1e1c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0485-rc-StackScan-CB_09/CB_09.java
@@ -0,0 +1,146 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB09
+ *- @TestCaseName: CB_09
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: Cycle is Cycle_a_0038.java;Node is ClassLoader
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式为ClassLoader类型，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_09.java
+ *- @ExecuteClass: CB_09
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.util.HashMap;
+
+class CB_09_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_09_A2 a2_0;
+    CB_09_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_09_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_09.check = this;
+    }
+}
+
+class CB_09_A2 {
+    volatile static HashMap test2;
+    CB_09_A1 a1_0;
+    CB_09_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_09_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_09_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_09_A3 {
+    CB_09_A1 a1_0;
+    CB_09_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_09_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_09_A1.a + a2_0.a;
+    }
+}
+
+public class CB_09 {
+    public static CB_09_A1 a1_main = null;
+    public volatile static CB_09_A1 check = null;
+    public volatile static ClassLoader test1;
+    public static ClassLoader test2;
+
+    public CB_09() {
+        a1_main = new CB_09_A1("a1_main");
+        a1_main.a2_0 = new CB_09_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_09_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+
+    public static void test_CB_09(int times) {
+        CB_09_A1.test1 = new HashMap();
+        CB_09_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            test1 = CB_09_A1.class.getClassLoader();
+            CB_09_A1.test1.put(i, test1);
+            test2 = CB_09_A1.class.getClassLoader();
+            CB_09_A2.test2.put(i, test2);
+        }
+    }
+
+    public static void rc_testcase_main_wrapper() {
+        CB_09 cb01 = new CB_09();
+        test_CB_09(100000);
+        check = a1_main;
+        try {
+            int result = CB_09.check.sum + CB_09.check.a2_0.sum + CB_09.check.a2_0.a3_0.sum;
+            if (result == 918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0486-rc-StackScan-CB_Thread_01/CB_Thread_01.java b/test/testsuite/ouroboros/rc_test/RC0486-rc-StackScan-CB_Thread_01/CB_Thread_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d73061f7476adcb94fb24194b941dc6f4f0003b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0486-rc-StackScan-CB_Thread_01/CB_Thread_01.java
@@ -0,0 +1,419 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB_Thread_01
+ *- @TestCaseName: CB_Thread_01
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: MultiThreadMode:Cycle is Cycle_a_0038.java;Nocycle is Nocycle_00180.java
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考Nocycle_00180.java，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_Thread_01.java
+ *- @ExecuteClass: CB_Thread_01
+ *- @ExecuteArgs:
+ */
+
+import java.util.HashMap;
+
+class CB_Nocycle_a_00180_A1 {
+    CB_Nocycle_a_00180_B1 b1_0;
+    CB_Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+
+class CB_Nocycle_a_00180_A2 {
+    CB_Nocycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+
+class CB_Nocycle_a_00180_A3 {
+    CB_Nocycle_a_00180_B2 b2_0;
+    CB_Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+
+class CB_Nocycle_a_00180_A4 {
+    CB_Nocycle_a_00180_B3 b3_0;
+    CB_Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+
+class CB_Nocycle_a_00180_B1 {
+    CB_Nocycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+
+class CB_Nocycle_a_00180_B2 {
+    CB_Nocycle_a_00180_C1 c1_0;
+    CB_Nocycle_a_00180_D1 d1_0;
+    CB_Nocycle_a_00180_D2 d2_0;
+    CB_Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+
+class CB_Nocycle_a_00180_B3 {
+    CB_Nocycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+
+class CB_Nocycle_a_00180_C1 {
+    CB_Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+
+class CB_Nocycle_a_00180_C2 {
+    CB_Nocycle_a_00180_D2 d2_0;
+    CB_Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+
+class CB_Nocycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CB_Nocycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+// 该树有12个节点
+class CB_Nocycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Nocycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+        // System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CB_Nocycle_a_00180 {
+    public CB_Nocycle_a_00180() {
+        CB_Nocycle_a_00180_A1 a1_main = new CB_Nocycle_a_00180_A1("a1_main");
+        CB_Nocycle_a_00180_A2 a2_main = new CB_Nocycle_a_00180_A2("a2_main");
+        CB_Nocycle_a_00180_A3 a3_main = new CB_Nocycle_a_00180_A3("a3_main");
+        CB_Nocycle_a_00180_A4 a4_main = new CB_Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new CB_Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0 = new CB_Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new CB_Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new CB_Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0 = new CB_Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new CB_Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new CB_Nocycle_a_00180_D3("d3_0");
+        a3_main.c2_0 = new CB_Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new CB_Nocycle_a_00180_D3("d3_0");
+
+        a4_main.b3_0 = new CB_Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new CB_Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new CB_Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new CB_Nocycle_a_00180_D3("d3_0");
+    }
+}
+
+class CB_Thread_01_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_Thread_01_A2 a2_0;
+    CB_Thread_01_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_Thread_01_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+        // System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        // System.out.println("A finalize");
+
+        CB_Thread_01.check = this;
+    }
+}
+
+class CB_Thread_01_A2 {
+    volatile static HashMap test2;
+    CB_Thread_01_A1 a1_0;
+    CB_Thread_01_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Thread_01_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_Thread_01_A1.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("B finalize");
+    }
+}
+
+class CB_Thread_01_A3 {
+    static CB_Nocycle_a_00180[] test1;
+    CB_Thread_01_A1 a1_0;
+    CB_Thread_01_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Thread_01_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_Thread_01_A1.a + a2_0.a;
+    }
+}
+
+class CB_Thread_01_test extends Thread {
+    private static CB_Thread_01_A1 a1_main = null;
+
+    private static void test_CB_Thread_01(int times) {
+        CB_Thread_01_A1.test1 = new HashMap();
+        CB_Thread_01_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_Thread_01_A1.test1.put(i, new CB_Nocycle_a_00180());
+            CB_Thread_01_A2.test2.put(i, new CB_Nocycle_a_00180());
+        }
+    }
+
+    public void run() {
+        a1_main = new CB_Thread_01_A1("a1_main");
+        a1_main.a2_0 = new CB_Thread_01_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_Thread_01_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        test_CB_Thread_01(10000);
+        a1_main = null;
+        CB_Thread_01.check = null;
+    }
+}
+
+public class CB_Thread_01 {
+    public static CB_Thread_01_A1 check = null;
+    private static CB_Thread_01_A1 a1_main = null;
+    private static CB_Thread_01_test cbtest1;
+    private volatile static CB_Thread_01_test cbtest2;
+
+    public static void main(String[] args) {
+        a1_main = new CB_Thread_01_A1("a1_main");
+        a1_main.a2_0 = new CB_Thread_01_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_Thread_01_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main = null;
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+
+        try {
+            int result = CB_Thread_01.check.sum + CB_Thread_01.check.a2_0.sum + CB_Thread_01.check.a2_0.a3_0.sum;
+            if (result == 918) {
+                System.out.println("ExpectResult");
+            }
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0487-rc-StackScan-CB_Thread_02/CB_Thread_02.java b/test/testsuite/ouroboros/rc_test/RC0487-rc-StackScan-CB_Thread_02/CB_Thread_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..78cb667088b077d4f719e1f14754e504ff155355
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0487-rc-StackScan-CB_Thread_02/CB_Thread_02.java
@@ -0,0 +1,152 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CB_Thread_02
+ *- @TestCaseName: CB_Thread_02
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: MultiThreadMode:Cycle is Cycle_a_0038.java;Nocycle is String
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考String，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CB_Thread_02.java
+ *- @ExecuteClass: CB_Thread_02
+ *- @ExecuteArgs:
+ */
+
+import java.util.HashMap;
+
+class CB_Thread_02_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_Thread_02_A2 a2_0;
+    CB_Thread_02_A3 a3_0;
+    int sum;
+    String strObjectName;
+
+    CB_Thread_02_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_Thread_02_test.check = this;
+    }
+}
+
+class CB_Thread_02_A2 {
+    volatile static HashMap test2;
+    CB_Thread_02_A1 a1_0;
+    CB_Thread_02_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Thread_02_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_Thread_02_A1.a + a3_0.a;
+    }
+
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+
+class CB_Thread_02_A3 {
+    CB_Thread_02_A1 a1_0;
+    CB_Thread_02_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    CB_Thread_02_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + CB_Thread_02_A1.a + a2_0.a;
+    }
+}
+
+class CB_Thread_02_test extends Thread {
+    public volatile static CB_Thread_02_A1 check = null;
+    private static CB_Thread_02_A1 a1_main = null;
+
+    private static void test_CB_Thread_02(int times) {
+        CB_Thread_02_A1.test1 = new HashMap();
+        CB_Thread_02_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_Thread_02_A1.test1.put(i, "Maple" + i);
+            CB_Thread_02_A2.test2.put(i, "Figo" + i);
+        }
+    }
+
+    public void run() {
+        a1_main = new CB_Thread_02_A1("a1_main");
+        a1_main.a2_0 = new CB_Thread_02_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_Thread_02_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        test_CB_Thread_02(10000);
+        a1_main = null;
+        CB_Thread_02_test.check = null;
+    }
+}
+
+public class CB_Thread_02 {
+    private static CB_Thread_02_A1 a1_main = null;
+
+    public static void main(String[] args) {
+        a1_main = new CB_Thread_02_A1("a1_main");
+        a1_main.a2_0 = new CB_Thread_02_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_Thread_02_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main = null;
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+
+        try {
+            int result = CB_Thread_02_test.check.sum + CB_Thread_02_test.check.a2_0.sum +
+                    CB_Thread_02_test.check.a2_0.a3_0.sum;
+            if (result == 918) {
+                System.out.println("ExpectResult");
+            }
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0488-rc-StackScan-CP_Thread_03/CP_Thread_03.java b/test/testsuite/ouroboros/rc_test/RC0488-rc-StackScan-CP_Thread_03/CP_Thread_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..469e61a13de0c534e53e07e07448d4f303b7f0ee
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0488-rc-StackScan-CP_Thread_03/CP_Thread_03.java
@@ -0,0 +1,90 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CP_Thread_03
+ *- @TestCaseName: CP_Thread_03
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: MultiThreadMode:Cycle is Cycle_a_0038.java;Nocycle is StringBuffer
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考StringBuffer，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_03.java
+ *- @ExecuteClass: CP_Thread_03
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class CP_Thread_03_A1 {
+    static StringBuffer[] test1;
+    static
+    int a;
+    CP_Thread_03_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_03_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_03_test extends Thread {
+    private static CP_Thread_03_A1 a1_main = null;
+    private volatile static CP_Thread_03_A1 a2 = null;
+    private volatile static StringBuffer test1;
+    private static StringBuffer test2;
+
+    private static void test_CP_Thread_03_A1(int times) {
+        CP_Thread_03_A1.test1 = new StringBuffer[times];
+        for (int i = 0; i < times; i++) {
+            test1 = new StringBuffer("maple" + i);
+            CP_Thread_03_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_03_A2(int times) {
+        CP_Thread_03_A1.test1 = new StringBuffer[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new StringBuffer("maple" + times + i);
+            CP_Thread_03_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_03_A1("a1_main");
+        a2 = new CP_Thread_03_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_03_A1(10000);
+        test_CP_Thread_03_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_03 {
+    private static CP_Thread_03_A1 a1_main = null;
+    private volatile static CP_Thread_03_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_03_test cptest1 = new CP_Thread_03_test();
+        cptest1.run();
+        CP_Thread_03_test cptest2 = new CP_Thread_03_test();
+        cptest2.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0489-rc-StackScan-CP_Thread_04/CP_Thread_04.java b/test/testsuite/ouroboros/rc_test/RC0489-rc-StackScan-CP_Thread_04/CP_Thread_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab0641378c70d150ed3241151501370d379920ce
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0489-rc-StackScan-CP_Thread_04/CP_Thread_04.java
@@ -0,0 +1,90 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CP_Thread_04
+ *- @TestCaseName: CP_Thread_04
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: MultiThreadMode:Cycle is Cycle_a_0038.java;Nocycle is StringBuffer
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考StringBuffer，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_04.java
+ *- @ExecuteClass: CP_Thread_04
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class CP_Thread_04_A1 {
+    static StringBuilder[] test1;
+    static
+    int a;
+    CP_Thread_04_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_04_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_04_test extends Thread {
+    private static CP_Thread_04_A1 a1_main = null;
+    private volatile static CP_Thread_04_A1 a2 = null;
+    private volatile static StringBuilder test1;
+    private static StringBuilder test2;
+
+    private static void test_CP_Thread_04_A1(int times) {
+        CP_Thread_04_A1.test1 = new StringBuilder[times];
+        for (int i = 0; i < times; i++) {
+            test1 = new StringBuilder("maple" + i);
+            CP_Thread_04_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_04_A2(int times) {
+        CP_Thread_04_A1.test1 = new StringBuilder[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new StringBuilder("maple" + times + i);
+            CP_Thread_04_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_04_A1("a1_main");
+        a2 = new CP_Thread_04_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_04_A1(10000);
+        test_CP_Thread_04_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_04 {
+    private static CP_Thread_04_A1 a1_main = null;
+    private static CP_Thread_04_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_04_test cptest1 = new CP_Thread_04_test();
+        cptest1.run();
+        CP_Thread_04_test cptest2 = new CP_Thread_04_test();
+        cptest2.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0490-rc-StackScan-CP_Thread_05/CP_Thread_05.java b/test/testsuite/ouroboros/rc_test/RC0490-rc-StackScan-CP_Thread_05/CP_Thread_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..56b4943169116bcd89e94a987d98391c99b12645
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0490-rc-StackScan-CP_Thread_05/CP_Thread_05.java
@@ -0,0 +1,96 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CP_Thread_05
+ *- @TestCaseName: CP_Thread_05
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: MultiThreadMode:Cycle is Cycle_a_0038.java;Nocycle is SoftReference
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考SoftReference，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_05.java
+ *- @ExecuteClass: CP_Thread_05
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.SoftReference;
+
+class CP_Thread_05_A1 {
+    static SoftReference[] test1;
+    static
+    int a;
+    CP_Thread_05_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_05_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_05_test extends Thread {
+    static String str;
+    private static CP_Thread_05_A1 a1_main = null;
+    private volatile static CP_Thread_05_A1 a2 = null;
+    private volatile static SoftReference test1;
+    private static SoftReference test2;
+
+    private static void test_CP_Thread_05_A1(int times) {
+        CP_Thread_05_A1.test1 = new SoftReference[times];
+        for (int i = 0; i < times; i++) {
+            str = "maple" + i;
+            test1 = new SoftReference<>(str);
+            CP_Thread_05_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_05_A2(int times) {
+        CP_Thread_05_A1.test1 = new SoftReference[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new SoftReference<>("maple" + times + i);
+            CP_Thread_05_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_05_A1("a1_main");
+        a2 = new CP_Thread_05_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_05_A1(10000);
+        test_CP_Thread_05_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_05 {
+    private static CP_Thread_05_A1 a1_main = null;
+    private static CP_Thread_05_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_05_test cptest1 = new CP_Thread_05_test();
+        cptest1.run();
+        CP_Thread_05_test cptest2 = new CP_Thread_05_test();
+        cptest2.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0491-rc-StackScan-CP_Thread_06/CP_Thread_06.java b/test/testsuite/ouroboros/rc_test/RC0491-rc-StackScan-CP_Thread_06/CP_Thread_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae66336159e9d0050cf26bf2bb0997f0d87af159
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0491-rc-StackScan-CP_Thread_06/CP_Thread_06.java
@@ -0,0 +1,96 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CP_Thread_06
+ *- @TestCaseName: CP_Thread_06
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: MultiThreadMode:Cycle is Cycle_a_0038.java;Nocycle is WeakReference
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考WeakReference，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_06.java
+ *- @ExecuteClass: CP_Thread_06
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+
+class CP_Thread_06_A1 {
+    static WeakReference[] test1;
+    static
+    int a;
+    CP_Thread_06_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_06_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_06_test extends Thread {
+    static String str;
+    private static CP_Thread_06_A1 a1_main = null;
+    private volatile static CP_Thread_06_A1 a2 = null;
+    private volatile static WeakReference test1;
+    private static WeakReference test2;
+
+    private static void test_CP_Thread_06_A1(int times) {
+        CP_Thread_06_A1.test1 = new WeakReference[times];
+        for (int i = 0; i < times; i++) {
+            str = "maple" + i;
+            test1 = new WeakReference<>(str);
+            CP_Thread_06_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_06_A2(int times) {
+        CP_Thread_06_A1.test1 = new WeakReference[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new WeakReference<>("maple" + times + i);
+            CP_Thread_06_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_06_A1("a1_main");
+        a2 = new CP_Thread_06_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_06_A1(10000);
+        test_CP_Thread_06_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_06 {
+    private static CP_Thread_06_A1 a1_main = null;
+    private static CP_Thread_06_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_06_test cptest1 = new CP_Thread_06_test();
+        cptest1.run();
+        CP_Thread_06_test cptest2 = new CP_Thread_06_test();
+        cptest2.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0492-rc-StackScan-CP_Thread_07/CP_Thread_07.java b/test/testsuite/ouroboros/rc_test/RC0492-rc-StackScan-CP_Thread_07/CP_Thread_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..534a1e6d2cf44023162c747fa664aa6451afabc6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0492-rc-StackScan-CP_Thread_07/CP_Thread_07.java
@@ -0,0 +1,96 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CP_Thread_07
+ *- @TestCaseName: CP_Thread_07
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: MultiThreadMode:Cycle is Cycle_a_0038.java;Nocycle is PhantomReference
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考PhantomReference，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_07.java
+ *- @ExecuteClass: CP_Thread_07
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+
+class CP_Thread_07_A1 {
+    static PhantomReference[] test1;
+    static
+    int a;
+    CP_Thread_07_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_07_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_07_test extends Thread {
+    static ReferenceQueue rq = new ReferenceQueue();
+    static String str;
+    private static CP_Thread_07_A1 a1_main = null;
+    private volatile static CP_Thread_07_A1 a2 = null;
+
+    private static void test_CP_Thread_07_A1(int times) {
+        CP_Thread_07_A1.test1 = new PhantomReference[times];
+        for (int i = 0; i < times; i++) {
+            str = "maple" + i;
+            PhantomReference<String> temp = new PhantomReference<>(str, rq);
+            CP_Thread_07_A1.test1[i] = temp;
+        }
+    }
+
+    private static void test_CP_Thread_07_A2(int times) {
+        CP_Thread_07_A1.test1 = new PhantomReference[times];
+        for (int i = 0; i < times; i++) {
+            PhantomReference<String> temp = new PhantomReference<>(str + times + i, rq);
+            CP_Thread_07_A1.test1[i] = temp;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_07_A1("a1_main");
+        a2 = new CP_Thread_07_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_07_A1(10000);
+        test_CP_Thread_07_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_07 {
+    private static CP_Thread_07_A1 a1_main = null;
+    private static CP_Thread_07_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_07_test cptest1 = new CP_Thread_07_test();
+        cptest1.run();
+        CP_Thread_07_test cptest2 = new CP_Thread_07_test();
+        cptest2.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0493-rc-StackScan-CP_Thread_08/CP_Thread_08.java b/test/testsuite/ouroboros/rc_test/RC0493-rc-StackScan-CP_Thread_08/CP_Thread_08.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d33717c36969758c9383003815e9cf2d820042e
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0493-rc-StackScan-CP_Thread_08/CP_Thread_08.java
@@ -0,0 +1,93 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CP_Thread_08
+ *- @TestCaseName: CP_Thread_08
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: MultiThreadMode:Cycle is Cycle_a_0038.java;Nocycle is OutOfMemoryError
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考OutOfMemoryError，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_08.java
+ *- @ExecuteClass: CP_Thread_08
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class CP_Thread_08_A1 {
+    static OutOfMemoryError[] test1;
+    static
+    int a;
+    CP_Thread_08_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_08_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_08_test extends Thread {
+    private static CP_Thread_08_A1 a1_main = null;
+    private volatile static CP_Thread_08_A1 a2 = null;
+    private volatile static OutOfMemoryError test1;
+    private static OutOfMemoryError test2;
+
+    private static void test_CP_Thread_08_A1(int times) {
+        CP_Thread_08_A1.test1 = new OutOfMemoryError[times];
+        for (int i = 0; i < times; i++) {
+            test1 = new OutOfMemoryError();
+            CP_Thread_08_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_08_A2(int times) {
+        CP_Thread_08_A1.test1 = new OutOfMemoryError[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new OutOfMemoryError();
+            CP_Thread_08_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_08_A1("a1_main");
+        a2 = new CP_Thread_08_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_08_A1(10000);
+        test_CP_Thread_08_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_08 {
+    private static CP_Thread_08_A1 a1_main = null;
+    private volatile static CP_Thread_08_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_08_test cptest1 = new CP_Thread_08_test();
+        cptest1.run();
+        CP_Thread_08_test cptest2 = new CP_Thread_08_test();
+        cptest2.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0494-rc-StackScan-CP_Thread_09/CP_Thread_09.java b/test/testsuite/ouroboros/rc_test/RC0494-rc-StackScan-CP_Thread_09/CP_Thread_09.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc0ae8294fc353b0e9dc45e0dee3bb0dc28adf98
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0494-rc-StackScan-CP_Thread_09/CP_Thread_09.java
@@ -0,0 +1,92 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_CP_Thread_09
+ *- @TestCaseName: CP_Thread_09
+ *- @TestCaseType: Function Testing for placementRCTest
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: MultiThreadMode:Cycle is Cycle_a_0038.java;Nocycle is ClassLoader
+ *- @Brief:一组有环的对象，他们的field指向一个hashMap，里面装满了对象
+ *  -#step1: 创建一个环，环的类型参考了Cycle_a_0038.java;
+ *  -#step2: 两个域test1和test2,里面装满了对象，对象格式参考ClassLoader，这样就构造了一个大对象。
+ *  -#step3: 验证结果正确，再用GCverify验证无内存泄漏。
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: CP_Thread_09.java
+ *- @ExecuteClass: CP_Thread_09
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+class CP_Thread_09_A1 {
+    static ClassLoader[] test1;
+    static
+    int a;
+    CP_Thread_09_A1 a2_0;
+    int sum;
+    String strObjectName;
+
+    CP_Thread_09_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+
+class CP_Thread_09_test extends Thread {
+    private static CP_Thread_09_A1 a1_main = null;
+    private volatile static CP_Thread_09_A1 a2 = null;
+    private volatile static ClassLoader test1;
+    private static ClassLoader test2;
+
+    private static void test_CP_Thread_09_A1(int times) {
+        CP_Thread_09_A1.test1 = new ClassLoader[times];
+        for (int i = 0; i < times; i++) {
+            test1 = CP_Thread_09_A1.class.getClassLoader();
+            CP_Thread_09_A1.test1[i] = test1;
+        }
+    }
+
+    private static void test_CP_Thread_09_A2(int times) {
+        CP_Thread_09_A1.test1 = new ClassLoader[times];
+        for (int i = 0; i < times; i++) {
+            test2 = CP_Thread_09_A1.class.getClassLoader();
+            CP_Thread_09_A1.test1[i] = test2;
+        }
+    }
+
+    public void run() {
+        a1_main = new CP_Thread_09_A1("a1_main");
+        a2 = new CP_Thread_09_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_09_A1(10000);
+        test_CP_Thread_09_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+
+public class CP_Thread_09 {
+    private static CP_Thread_09_A1 a1_main = null;
+    private volatile static CP_Thread_09_A1 a2 = null;
+
+    public static void main(String[] args) {
+        CP_Thread_09_test cptest1 = new CP_Thread_09_test();
+        cptest1.run();
+        CP_Thread_09_test cptest2 = new CP_Thread_09_test();
+        cptest2.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/FrequentSystemGC_01.java b/test/testsuite/ouroboros/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/FrequentSystemGC_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c2b6bf617bb78f45e051f765b57eaee271e3c53
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/FrequentSystemGC_01.java
@@ -0,0 +1,81 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_FrequentSystemGC_01
+ *- @TestCaseName: FrequentSystemGC_01
+ *- @TestCaseType: Function Testing for frequently system.gc() by user
+ *- @RequirementName: GC队列
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:多线程同时显式触发system.gc。
+ *  -#step1:创建100个线程
+ *  -#step2:每个线程先sleep不同的时间，依次为1ms,2ms,3ms...
+ *  -#step3:sleep完后分配一个weak, 接着显式触发gc()
+ *  -#step4:每个线程在显式调用Runtime.getRuntime().gc()后，其weak都已经被释放
+ *- @Expect:expected.txt
+ *- @Priority: High
+ *- @Source: FrequentSystemGC_01.java
+ *- @ExecuteClass: FrequentSystemGC_01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+
+class MyThread extends Thread {
+    public void run(){
+        try {
+            Thread.sleep(index * FrequentSystemGC_01.THREAD_SLEEP_UNIT);
+        } catch (Exception e) {
+            // System.out.println("Exception from thread sleep: " + index);
+            // do nothing, just continue test...
+        }
+
+        WeakReference weak = new WeakReference<Object>(new Object());
+        if (weak.get() == null) {
+            return;
+        }
+        Runtime.getRuntime().gc();
+        if (weak.get() != null) {
+            System.out.println("MyThread" + index + " check fail");
+            FrequentSystemGC_01.totalResult = false;
+        }
+   }
+
+   public MyThread(int i) {
+       index = i;
+   }
+
+   private int index;
+}
+
+public class FrequentSystemGC_01 {
+    public static final int THREAD_COUNT = 50;
+    public static boolean totalResult = true;
+    public static final long THREAD_SLEEP_UNIT = 1;
+    public static ArrayList<Thread> threads = new ArrayList<>();
+    public static void main(String[] args) {
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            Thread t = new MyThread(i);
+            threads.add(t);
+            t.start();
+        }
+
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            try {
+                threads.get(i).join();
+            } catch (Exception e) {
+                System.out.println("Exception from join thread: " + i + " need re-test!");
+                return;
+            }
+        }
+        if (FrequentSystemGC_01.totalResult == true) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, weak is not freed after system.gc() in some thread!");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/StartupInvoke_01.java b/test/testsuite/ouroboros/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/StartupInvoke_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..26f060081e6ef98e10d23701a30acb041e944573
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/StartupInvoke_01.java
@@ -0,0 +1,52 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_StartupInvoke_01
+ *- @TestCaseName: StartupInvoke_01
+ *- @TestCaseType: Function Testing for async TriggerGC at startup
+ *- @RequirementName: GC队列实现
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:当前初始阈值是100MB，会隐式触发GC。
+ *  -#step1:创建一个弱引用，检查它可以通过get()方法获得关联的引用对象。
+ *  -#step2:通过1个for循环，分配内存到100M。
+ *  -#step3:验证GC被隐式触发，步骤1中创建的弱引用被回收掉了。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: StartupInvoke_01.java
+ *- @ExecuteClass: StartupInvoke_01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+
+public class StartupInvoke_01 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int INIT_MEMORY = 100; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+
+    public static void main(String[] args) throws Exception {
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        for (int i = 0; i < INIT_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(3000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0507-JTreg-CheckLoops/CheckLoops.java b/test/testsuite/ouroboros/rc_test/RC0507-JTreg-CheckLoops/CheckLoops.java
new file mode 100755
index 0000000000000000000000000000000000000000..57a7c1de463f4a59089649f475dd54b8851fb0bf
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0507-JTreg-CheckLoops/CheckLoops.java
@@ -0,0 +1,1071 @@
+/*
+ * -@TestCaseID: CheckLoops
+ * -@TestCaseName: CheckLoops
+ * -@TestCaseType: Function Testing from JTreg
+ * -@RequirementID: None
+ * -@RequirementName: some testcases will be moved to FigtoTest when enable JTreg.
+ * -@Condition:no
+ *  -#c1: 测试环境正常
+ * -@Brief:将该用例从JTreg中摘出来，放到CI和组件daily测试中测试。该用例在JTreg连跑中会挂掉
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: CheckLoops.java
+ * -@ExecuteClass: CheckLoops
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+public class CheckLoops {
+    private static int sResult;
+
+    //
+    // Various sequence variables used in bound checks.
+    //
+
+    // CHECK-START: void Main.bubble(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.bubble(int[]) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    private static void bubble(int[] a) {
+        for (int i = a.length; --i >= 0; ) {
+            for (int j = 0; j < i; j++) {
+                if (a[j] > a[j + 1]) {
+                    int tmp = a[j];
+                    a[j] = a[j + 1];
+                    a[j + 1] = tmp;
+                }
+            }
+        }
+    }
+
+    // CHECK-START: int Main.periodicIdiom(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.periodicIdiom(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int periodicIdiom(int tc) {
+        int[] x = {1, 3};
+        // Loop with periodic sequence (0, 1).
+        int k = 0;
+        int result = 0;
+        for (int i = 0; i < tc; i++) {
+            result += x[k];
+            k = 1 - k;
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.periodicSequence2(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.periodicSequence2(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int periodicSequence2(int tc) {
+        int[] x = {1, 3};
+        // Loop with periodic sequence (0, 1).
+        int k = 0;
+        int l = 1;
+        int result = 0;
+        for (int i = 0; i < tc; i++) {
+            result += x[k];
+            int t = l;
+            l = k;
+            k = t;
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.periodicSequence4(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    // CHECK-DAG: BoundsCheck
+    // CHECK-DAG: BoundsCheck
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.periodicSequence4(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int periodicSequence4(int tc) {
+        int[] x = {1, 3, 5, 7};
+        // Loop with periodic sequence (0, 1, 2, 3).
+        int k = 0;
+        int l = 1;
+        int m = 2;
+        int n = 3;
+        int result = 0;
+        for (int i = 0; i < tc; i++) {
+            result += x[k] + x[l] + x[m] + x[n]; // all used at once
+            int t = n;
+            n = k;
+            k = l;
+            l = m;
+            m = t;
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.justRightUp1() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightUp1() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightUp1() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MAX_VALUE - 10, k = 0; i < Integer.MAX_VALUE; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.justRightUp2() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightUp2() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightUp2() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MAX_VALUE - 10; i < Integer.MAX_VALUE; i++) {
+            result += x[i - Integer.MAX_VALUE + 10];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.justRightUp3() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightUp3() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightUp3() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MAX_VALUE - 10, k = 0; i <= Integer.MAX_VALUE - 1; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.justOOBUp() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justOOBUp() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justOOBUp() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static int justOOBUp() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        // Infinite loop!
+        for (int i = Integer.MAX_VALUE - 9, k = 0; i <= Integer.MAX_VALUE; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.justRightDown1() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightDown1() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightDown1() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MIN_VALUE + 10, k = 0; i > Integer.MIN_VALUE; i--) {
+            result += x[k++];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.justRightDown2() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightDown2() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightDown2() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MIN_VALUE + 10; i > Integer.MIN_VALUE; i--) {
+            result += x[Integer.MAX_VALUE + i];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.justRightDown3() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightDown3() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightDown3() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MIN_VALUE + 10, k = 0; i >= Integer.MIN_VALUE + 1; i--) {
+            result += x[k++];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.justOOBDown() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justOOBDown() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justOOBDown() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static int justOOBDown() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        // Infinite loop!
+        for (int i = Integer.MIN_VALUE + 9, k = 0; i >= Integer.MIN_VALUE; i--) {
+            result += x[k++];
+        }
+        return result;
+    }
+
+    // CHECK-START: void Main.lowerOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.lowerOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.lowerOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void lowerOOB(int[] x) {
+        // OOB!
+        for (int i = -1; i < x.length; i++) {
+            sResult += x[i];
+        }
+    }
+
+    // CHECK-START: void Main.upperOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.upperOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.upperOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void upperOOB(int[] x) {
+        // OOB!
+        for (int i = 0; i <= x.length; i++) {
+            sResult += x[i];
+        }
+    }
+
+    // CHECK-START: void Main.doWhileUpOOB() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.doWhileUpOOB() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.doWhileUpOOB() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void doWhileUpOOB() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int i = 0;
+        // OOB!
+        do {
+            sResult += x[i++];
+        } while (i <= x.length);
+    }
+
+    // CHECK-START: void Main.doWhileDownOOB() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.doWhileDownOOB() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.doWhileDownOOB() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void doWhileDownOOB() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int i = x.length - 1;
+        // OOB!
+        do {
+            sResult += x[i--];
+        } while (-1 <= i);
+    }
+
+    // CHECK-START: void Main.hiddenOOB1(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenOOB1(int) BCE (after)
+    // CHECK-DAG: Deoptimize
+    //
+    // CHECK-START: void Main.hiddenOOB1(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    private static void hiddenOOB1(int lo) {
+        int[] a = {1};
+        for (int i = lo; i <= 10; i++) {
+            // Dangerous loop where careless static range analysis would yield strict upper bound
+            // on index j of 5. When, for instance, lo and thus i = -2147483648, the upper bound
+            // becomes really positive due to arithmetic wrap-around, causing OOB.
+            // Dynamic BCE is feasible though, since it checks the range.
+            for (int j = 4; j < i - 5; j++) {
+                sResult += a[j - 4];
+            }
+        }
+    }
+
+    // CHECK-START: void Main.hiddenOOB2(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenOOB2(int) BCE (after)
+    // CHECK-DAG: Deoptimize
+    //
+    // CHECK-START: void Main.hiddenOOB2(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    private static void hiddenOOB2(int hi) {
+        int[] a = {1};
+        for (int i = 0; i < hi; i++) {
+            // Dangerous loop where careless static range analysis would yield strict lower bound
+            // on index j of 5. When, for instance, hi and thus i = 2147483647, the upper bound
+            // becomes really negative due to arithmetic wrap-around, causing OOB.
+            // Dynamic BCE is feasible though, since it checks the range.
+            for (int j = 6; j > i + 5; j--) {
+                sResult += a[j - 6];
+            }
+        }
+    }
+
+    // CHECK-START: void Main.hiddenInfiniteOOB() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenInfiniteOOB() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenInfiniteOOB() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void hiddenInfiniteOOB() {
+        int[] a = {11};
+        for (int i = -1; i <= 0; i++) {
+            // Dangerous loop where careless static range analysis would yield a safe upper bound
+            // of -3. In reality, due to arithmetic wrap-around (when i = -1, j <= 2147483647;
+            // whereas when i = 0, j <= -3), this is an infinite loop that goes OOB.
+            for (int j = -3; j <= 2147483646 * i - 3; j++) {
+                sResult += a[j + 3];
+            }
+        }
+    }
+
+    // CHECK-START: void Main.hiddenFiniteOOB() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenFiniteOOB() BCE (after)
+    // CHECK-DAG: Deoptimize
+    //
+    // CHECK-START: void Main.hiddenFiniteOOB() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    private static void hiddenFiniteOOB() {
+        int[] a = {111};
+        for (int i = -1; i <= 0; i++) {
+            // Dangerous loop similar as above where the loop is now finite, but the
+            // loop still goes out of bounds for i = -1 due to the large upper bound.
+            // Dynamic BCE is feasible though, since it checks the range.
+            for (int j = -4; j < 2147483646 * i - 3; j++) {
+                sResult += a[j + 4];
+            }
+        }
+    }
+
+    // CHECK-START: void Main.inductionOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.inductionOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.inductionOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void inductionOOB(int[] a) {
+        // Careless range analysis would remove the bounds check.
+        // However, the narrower induction b wraps around arithmetically
+        // before it reaches the end of arrays longer than 127.
+        byte b = 0;
+        for (int i = 0; i < a.length; i++) {
+            a[b++] = i;
+        }
+    }
+
+    // CHECK-START: void Main.controlOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.controlOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.controlOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void controlOOB(int[] a) {
+        // As above, but now the loop control also wraps around.
+        for (byte i = 0; i < a.length; i++) {
+            a[i] = -i;
+        }
+    }
+
+    // CHECK-START: void Main.conversionOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.conversionOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.conversionOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void conversionOOB(int[] a) {
+        // As above, but with wrap around caused by an explicit conversion.
+        for (int i = 0; i < a.length; ) {
+            a[i] = i;
+            i = (byte) (i + 1);
+        }
+    }
+
+    // CHECK-START: int[] Main.add() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int[] Main.add() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int[] add() {
+        int[] a = new int[10];
+        for (int i = 0; i <= 3; i++) {
+            for (int j = 0; j <= 6; j++) {
+                a[i + j] += 1;
+            }
+        }
+        return a;
+    }
+
+    // CHECK-START: int[] Main.multiply1() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int[] Main.multiply1() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int[] multiply1() {
+        int[] a = new int[10];
+        try {
+            for (int i = 0; i <= 3; i++) {
+                for (int j = 0; j <= 3; j++) {
+                    // Range [0,9]: safe.
+                    a[i * j] += 1;
+                }
+            }
+        } catch (Exception e) {
+            a[0] += 1000;
+        }
+        return a;
+    }
+
+    // CHECK-START: int[] Main.multiply2() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int[] Main.multiply2() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int[] Main.multiply2() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static int[] multiply2() {
+        int[] a = new int[10];
+        try {
+            for (int i = -3; i <= 3; i++) {
+                for (int j = -3; j <= 3; j++) {
+                    // Range [-9,9]: unsafe.
+                    a[i * j] += 1;
+                }
+            }
+        } catch (Exception e) {
+            a[0] += 1000;
+        }
+        return a;
+    }
+
+    // CHECK-START: int Main.linearDynamicBCE1(int[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.linearDynamicBCE1(int[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.linearDynamicBCE1(int[], int, int) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int linearDynamicBCE1(int[] x, int lo, int hi) {
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            sResult += x[i];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.linearDynamicBCE2(int[], int, int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.linearDynamicBCE2(int[], int, int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.linearDynamicBCE2(int[], int, int, int) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int linearDynamicBCE2(int[] x, int lo, int hi, int offset) {
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            sResult += x[offset + i];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.wrapAroundDynamicBCE(int[]) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.wrapAroundDynamicBCE(int[]) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.wrapAroundDynamicBCE(int[]) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int wrapAroundDynamicBCE(int[] x) {
+        int w = 9;
+        int result = 0;
+        for (int i = 0; i < 10; i++) {
+            result += x[w];
+            w = i;
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.periodicDynamicBCE(int[]) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.periodicDynamicBCE(int[]) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.periodicDynamicBCE(int[]) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int periodicDynamicBCE(int[] x) {
+        int k = 0;
+        int result = 0;
+        for (int i = 0; i < 10; i++) {
+            result += x[k];
+            k = 1 - k;
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.dynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.dynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int dynamicBCEPossiblyInfiniteLoop(int[] x, int lo, int hi) {
+        // This loop could be infinite for hi = max int. Since i is also used
+        // as subscript, however, dynamic bce can proceed.
+        int result = 0;
+        for (int i = lo; i <= hi; i++) {
+            result += x[i];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.noDynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.noDynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.noDynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (after)
+    // CHECK-NOT: Deoptimize
+    static int noDynamicBCEPossiblyInfiniteLoop(int[] x, int lo, int hi) {
+        // As above, but now the index is not used as subscript,
+        // and dynamic bce is not applied.
+        int result = 0;
+        for (int k = 0, i = lo; i <= hi; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.noDynamicBCEMixedInductionTypes(int[], long, long) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.noDynamicBCEMixedInductionTypes(int[], long, long) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.noDynamicBCEMixedInductionTypes(int[], long, long) BCE (after)
+    // CHECK-NOT: Deoptimize
+    static int noDynamicBCEMixedInductionTypes(int[] x, long lo, long hi) {
+        int result = 0;
+        // Mix of int and long induction.
+        int k = 0;
+        for (long i = lo; i < hi; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.dynamicBCEConstantRange(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck loop:<<InnerLoop:B\d+>>
+    // CHECK-DAG: ArrayGet    loop:<<InnerLoop>>
+    // CHECK-DAG: If          loop:<<InnerLoop>>
+    // CHECK-DAG: If          loop:<<OuterLoop:B\d+>>
+    // CHECK-EVAL: "<<InnerLoop>>" != "<<OuterLoop>>"
+    //
+    // CHECK-START: int Main.dynamicBCEConstantRange(int[]) BCE (after)
+    // CHECK-DAG: ArrayGet   loop:<<InnerLoop:B\d+>>
+    // CHECK-DAG: Deoptimize loop:<<OuterLoop:B\d+>>
+    // CHECK-EVAL: "<<InnerLoop>>" != "<<OuterLoop>>"
+    //
+    // CHECK-START: int Main.dynamicBCEConstantRange(int[]) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    //
+    //  No additional top tests were introduced.
+    // CHECK-START: int Main.dynamicBCEConstantRange(int[]) BCE (after)
+    // CHECK-DAG: If
+    // CHECK-DAG: If
+    // CHECK-NOT: If
+    static int dynamicBCEConstantRange(int[] x) {
+        int result = 0;
+        for (int i = 2; i <= 6; i++) {
+            // Range analysis sees that innermost loop is finite and always taken.
+            for (int j = i - 2; j <= i + 2; j++) {
+                result += x[j];
+            }
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.dynamicBCEAndConstantIndices(int[], int[][], int, int) BCE (before)
+    // CHECK-DAG: {{l\d+}} ArrayGet loop:<<Loop:B\d+>>
+    // CHECK-DAG: {{l\d+}} ArrayGet loop:<<Loop>>
+    // CHECK-DAG: {{l\d+}} ArrayGet loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndices(int[], int[][], int, int) BCE (after)
+    //  Order matters:
+    // CHECK:              Deoptimize loop:<<Loop:B\d+>>
+    //  CHECK-NOT:          Goto       loop:<<Loop>>
+    // CHECK-DAG: {{l\d+}} ArrayGet   loop:<<Loop>>
+    // CHECK-DAG: {{l\d+}} ArrayGet   loop:<<Loop>>
+    // CHECK-DAG: {{l\d+}} ArrayGet   loop:<<Loop>>
+    // CHECK:              Goto       loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndices(int[], int[][], int, int) BCE (after)
+    // CHECK-DAG: Deoptimize loop:none
+    static int dynamicBCEAndConstantIndices(int[] x, int[][] a, int lo, int hi) {
+        // Deliberately test array length on a before the loop so that only bounds checks
+        // on constant subscripts remain, making them a viable candidate for hoisting.
+        if (a.length == 0) {
+            return -1;
+        }
+        // Loop that allows BCE on x[i].
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            result += x[i];
+            if ((i % 10) != 0) {
+                // None of the subscripts inside a conditional are removed by dynamic bce,
+                // making them a candidate for deoptimization based on constant indices.
+                // Compiler should ensure the array loads are not subsequently hoisted
+                // "above" the deoptimization "barrier" on the bounds.
+                a[0][i] = 1;
+                a[1][i] = 2;
+                a[99][i] = 3;
+            }
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.dynamicBCEAndConstantIndicesAllPrimTypes(int[], boolean[], byte[], char[], short[], int[], long[], float[], double[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    //  For brevity, just test occurrence of at least one of each in the loop:
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndicesAllPrimTypes(int[], boolean[], byte[], char[], short[], int[], long[], float[], double[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-NOT: ArrayGet    loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndicesAllPrimTypes(int[], boolean[], byte[], char[], short[], int[], long[], float[], double[], int, int) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndicesAllPrimTypes(int[], boolean[], byte[], char[], short[], int[], long[], float[], double[], int, int) BCE (after)
+    // CHECK-DAG: Deoptimize  loop:none
+    private static int dynamicBCEAndConstantIndicesAllPrimTypes(int[] q, boolean[] r, byte[] s, char[] t, short[] u, int[] v, long[] w, float[] x, double[] y, int lo, int hi) {
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            // All constant index array references can be hoisted out of the loop during BCE on q[i].
+            result += q[i] + (r[0] ? 1 : 0) + (int) s[0] + (int) t[0] + (int) u[0] + v[0] + (int) w[0] + (int) x[0] + (int) y[0];
+        }
+        return result;
+    }
+
+    // CHECK-START: int Main.dynamicBCEAndConstantIndexRefType(int[], java.lang.Integer[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndexRefType(int[], java.lang.Integer[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndexRefType(int[], java.lang.Integer[], int, int) BCE (after)
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int dynamicBCEAndConstantIndexRefType(int[] q, Integer[] z, int lo, int hi) {
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            // Similar to above, but now implicit call to intValue() may prevent hoisting
+            // z[0] itself during BCE on q[i]. Therefore, we just check BCE on q[i].
+            result += q[i] + z[0];
+        }
+        return result;
+    }
+
+    //
+    // Verifier.
+    //
+
+    public static void main(String[] args) {
+        // Set to run expensive tests for correctness too.
+        boolean heavy = false;
+
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+        int[] a200 = new int[200];
+
+        // Sorting.
+        int[] sort = {5, 4, 1, 9, 10, 2, 7, 6, 3, 8};
+        bubble(sort);
+        for (int i = 0; i < 10; i++) {
+            expectEquals(sort[i], x[i]);
+        }
+
+        // Periodic adds (1, 3), one at the time.
+        expectEquals(0, periodicIdiom(-1));
+        for (int tc = 0; tc < 32; tc++) {
+            int expected = (tc >> 1) << 2;
+            if ((tc & 1) != 0)
+                expected += 1;
+            expectEquals(expected, periodicIdiom(tc));
+        }
+
+        // Periodic adds (1, 3), one at the time.
+        expectEquals(0, periodicSequence2(-1));
+        for (int tc = 0; tc < 32; tc++) {
+            int expected = (tc >> 1) << 2;
+            if ((tc & 1) != 0)
+                expected += 1;
+            expectEquals(expected, periodicSequence2(tc));
+        }
+
+        // Periodic adds (1, 3, 5, 7), all at once.
+        expectEquals(0, periodicSequence4(-1));
+        for (int tc = 0; tc < 32; tc++) {
+            expectEquals(tc * 16, periodicSequence4(tc));
+        }
+
+        // Large bounds.
+        expectEquals(55, justRightUp1());
+        expectEquals(55, justRightUp2());
+        expectEquals(55, justRightUp3());
+        expectEquals(55, justRightDown1());
+        expectEquals(55, justRightDown2());
+        expectEquals(55, justRightDown3());
+        sResult = 0;
+        try {
+            justOOBUp();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult = 1;
+        }
+        expectEquals(1, sResult);
+        sResult = 0;
+        try {
+            justOOBDown();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult = 1;
+        }
+        expectEquals(1, sResult);
+
+        // Lower bound goes OOB.
+        sResult = 0;
+        try {
+            lowerOOB(x);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+
+        // Upper bound goes OOB.
+        sResult = 0;
+        try {
+            upperOOB(x);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1055, sResult);
+
+        // Do while up goes OOB.
+        sResult = 0;
+        try {
+            doWhileUpOOB();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1055, sResult);
+
+        // Do while down goes OOB.
+        sResult = 0;
+        try {
+            doWhileDownOOB();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1055, sResult);
+
+        // Hidden OOB.
+        sResult = 0;
+        try {
+            hiddenOOB1(10); // no OOB
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1, sResult);
+        sResult = 0;
+        try {
+            hiddenOOB1(-2147483648); // OOB
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1001, sResult);
+        sResult = 0;
+        try {
+            hiddenOOB2(1); // no OOB
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1, sResult);
+        if (heavy) {
+            sResult = 0;
+            try {
+                hiddenOOB2(2147483647); // OOB
+            } catch (ArrayIndexOutOfBoundsException e) {
+                sResult += 1000;
+            }
+            expectEquals(1002, sResult);
+        }
+        sResult = 0;
+        try {
+            hiddenInfiniteOOB();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1011, sResult);
+        sResult = 0;
+        try {
+            hiddenFiniteOOB();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1111, sResult);
+        sResult = 0;
+        try {
+            inductionOOB(a200);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        for (int i = 0; i < 200; i++) {
+            expectEquals(i < 128 ? i : 0, a200[i]);
+        }
+        sResult = 0;
+        try {
+            controlOOB(a200);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        for (int i = 0; i < 200; i++) {
+            expectEquals(i < 128 ? -i : 0, a200[i]);
+        }
+        sResult = 0;
+        try {
+            conversionOOB(a200);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        for (int i = 0; i < 200; i++) {
+            expectEquals(i < 128 ? i : 0, a200[i]);
+        }
+
+        // Addition.
+        {
+            int[] e1 = {1, 2, 3, 4, 4, 4, 4, 3, 2, 1};
+            int[] a1 = add();
+            for (int i = 0; i < 10; i++) {
+                expectEquals(a1[i], e1[i]);
+            }
+        }
+
+        // Multiplication.
+        {
+            int[] e1 = {7, 1, 2, 2, 1, 0, 2, 0, 0, 1};
+            int[] a1 = multiply1();
+            for (int i = 0; i < 10; i++) {
+                expectEquals(a1[i], e1[i]);
+            }
+            int[] e2 = {1001, 0, 0, 1, 0, 0, 1, 0, 0, 1};
+            int[] a2 = multiply2();
+            for (int i = 0; i < 10; i++) {
+                expectEquals(a2[i], e2[i]);
+            }
+        }
+
+        // Dynamic BCE.
+        sResult = 0;
+        try {
+            linearDynamicBCE1(x, -1, x.length);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        sResult = 0;
+        linearDynamicBCE1(x, 0, x.length);
+        expectEquals(55, sResult);
+        sResult = 0;
+        try {
+            linearDynamicBCE1(x, 0, x.length + 1);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1055, sResult);
+
+        // Dynamic BCE with offset.
+        sResult = 0;
+        try {
+            linearDynamicBCE2(x, 0, x.length, -1);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        sResult = 0;
+        linearDynamicBCE2(x, 0, x.length, 0);
+        expectEquals(55, sResult);
+        sResult = 0;
+        try {
+            linearDynamicBCE2(x, 0, x.length, 1);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1054, sResult);
+
+        // Dynamic BCE candidates.
+        expectEquals(55, wrapAroundDynamicBCE(x));
+        expectEquals(15, periodicDynamicBCE(x));
+        expectEquals(55, dynamicBCEPossiblyInfiniteLoop(x, 0, 9));
+        expectEquals(55, noDynamicBCEPossiblyInfiniteLoop(x, 0, 9));
+        expectEquals(55, noDynamicBCEMixedInductionTypes(x, 0, 10));
+        expectEquals(125, dynamicBCEConstantRange(x));
+
+        // Dynamic BCE combined with constant indices.
+        int[][] a;
+        a = new int[0][0];
+        expectEquals(-1, dynamicBCEAndConstantIndices(x, a, 0, 10));
+        a = new int[100][10];
+        expectEquals(55, dynamicBCEAndConstantIndices(x, a, 0, 10));
+        for (int i = 0; i < 10; i++) {
+            expectEquals((i % 10) != 0 ? 1 : 0, a[0][i]);
+            expectEquals((i % 10) != 0 ? 2 : 0, a[1][i]);
+            expectEquals((i % 10) != 0 ? 3 : 0, a[99][i]);
+        }
+        a = new int[2][10];
+        sResult = 0;
+        try {
+            expectEquals(55, dynamicBCEAndConstantIndices(x, a, 0, 10));
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult = 1;
+        }
+        expectEquals(1, sResult);
+        expectEquals(a[0][1], 1);
+        expectEquals(a[1][1], 2);
+
+        // Dynamic BCE combined with constant indices of all types.
+        boolean[] x1 = {true};
+        byte[] x2 = {2};
+        char[] x3 = {3};
+        short[] x4 = {4};
+        int[] x5 = {5};
+        long[] x6 = {6};
+        float[] x7 = {7};
+        double[] x8 = {8};
+        expectEquals(415, dynamicBCEAndConstantIndicesAllPrimTypes(x, x1, x2, x3, x4, x5, x6, x7, x8, 0, 10));
+        Integer[] x9 = {9};
+        expectEquals(145, dynamicBCEAndConstantIndexRefType(x, x9, 0, 10));
+
+        System.out.println("ExpectResult");
+    }
+
+    private static void expectEquals(int expected, int result) {
+        if (expected != result) {
+            throw new Error("Expected: " + expected + ", found: " + result);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0508-JTreg-ConstCharAppend/ConstCharAppend.java b/test/testsuite/ouroboros/rc_test/RC0508-JTreg-ConstCharAppend/ConstCharAppend.java
new file mode 100755
index 0000000000000000000000000000000000000000..4cd569695f468d20d65030d445f7e052ad7191a4
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0508-JTreg-ConstCharAppend/ConstCharAppend.java
@@ -0,0 +1,29 @@
+/*
+ * -@TestCaseID: ConstCharAppend
+ * -@TestCaseName: ConstCharAppend
+ * -@TestCaseType: Function Testing from JTreg
+ * -@RequirementID: None
+ * -@RequirementName: some testcases will be moved to FigtoTest when enable JTreg.
+ * -@Condition:no
+ *  -#c1: 测试环境正常
+ * -@Brief:将该用例从JTreg中摘出来，放到CI和组件daily测试中测试。该用例在JTreg连跑中会挂掉
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: ConstCharAppend.java
+ * -@ExecuteClass: ConstCharAppend
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+public class ConstCharAppend {
+    public static void main(String[] args) {
+        if (!("" + 'a' + 'b').equals("ab")) {
+            System.out.println("append of chars is wrong: 4103959");
+        } else {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0509-JTreg-RelaxedArrays/RelaxedArrays.java b/test/testsuite/ouroboros/rc_test/RC0509-JTreg-RelaxedArrays/RelaxedArrays.java
new file mode 100755
index 0000000000000000000000000000000000000000..b7f5841d433d6e0e68a5fdd37371a3e13c730e06
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0509-JTreg-RelaxedArrays/RelaxedArrays.java
@@ -0,0 +1,40 @@
+/*
+ * -@TestCaseID: RelaxedArrays
+ * -@TestCaseName: RelaxedArrays
+ * -@TestCaseType: Function Testing from JTreg
+ * -@RequirementID: None
+ * -@RequirementName: some testcases will be moved to FigtoTest when enable JTreg.
+ * -@Condition:no
+ *  -#c1: 测试环境正常
+ * -@Brief:将该用例从JTreg中摘出来，放到CI和组件daily测试中测试。该用例在JTreg连跑中会挂掉
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: RelaxedArrays.java
+ * -@ExecuteClass: RelaxedArrays
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RelaxedArrays {
+    static <T> T select(T... tl) {
+        return tl.length == 0 ? null : tl[tl.length - 1];
+    }
+
+    public static void main(String[] args) {
+        List<String>[] a = new StringList[20];
+        if (select("A", "B", "C") != "C") {
+            System.out.println("error");
+        } else {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static class StringList extends ArrayList<String> {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0510-JTreg-T4711694/T4711694.java b/test/testsuite/ouroboros/rc_test/RC0510-JTreg-T4711694/T4711694.java
new file mode 100755
index 0000000000000000000000000000000000000000..714cee482ca3cb08cfe82a37005ec7a5f3856771
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0510-JTreg-T4711694/T4711694.java
@@ -0,0 +1,47 @@
+/*
+ * -@TestCaseID: T4711694
+ * -@TestCaseName: T4711694
+ * -@TestCaseType: Function Testing from JTreg
+ * -@RequirementID: None
+ * -@RequirementName: some testcases will be moved to FigtoTest when enable JTreg.
+ * -@Condition:no
+ *  -#c1: 测试环境正常
+ * -@Brief:将该用例从JTreg中摘出来，放到CI和组件daily测试中测试。该用例在JTreg连跑中会挂掉
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: T4711694.java
+ * -@ExecuteClass: T4711694
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+public class T4711694 {
+    public static void main(String[] args) {
+        D.main(args);
+        System.out.println("ExpectResult");
+    }
+
+    interface A<T> {
+        void f(T u);
+    }
+
+    static class B {
+        public void f(Integer i) {
+        }
+    }
+
+    static abstract class C<T> extends B implements A<T> {
+        public void g(T t) {
+            f(t);
+        }
+    }
+
+    static class D extends C<Integer> {
+        public static void main(String[] args) {
+            new D().g(new Integer(3));
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0511-JTreg-T7040104/T7040104.java b/test/testsuite/ouroboros/rc_test/RC0511-JTreg-T7040104/T7040104.java
new file mode 100755
index 0000000000000000000000000000000000000000..7b94ef3a3800438e4f3aaf6dca6ae96d76f3f063
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0511-JTreg-T7040104/T7040104.java
@@ -0,0 +1,62 @@
+/*
+ * -@TestCaseID: T7040104
+ * -@TestCaseName: T7040104
+ * -@TestCaseType: Function Testing from JTreg
+ * -@RequirementID: None
+ * -@RequirementName: some testcases will be moved to FigtoTest when enable JTreg.
+ * -@Condition:no
+ *  -#c1: 测试环境正常
+ * -@Brief:将该用例从JTreg中摘出来，放到CI和组件daily测试中测试。该用例在JTreg连跑中会挂掉
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: T7040104.java
+ * -@ExecuteClass: T7040104
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+public class T7040104 {
+    int npeCount = 0;
+
+    public static void main(String[] args) {
+        T7040104 t = new T7040104();
+        t.test1();
+        t.test2();
+        t.test3();
+        if (t.npeCount != 3) {
+            System.out.println("error");
+        } else {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    void test1() {
+        Object[] a;
+        try {
+            Object o = (a = null)[0];
+        } catch (NullPointerException npe) {
+            npeCount++;
+        }
+    }
+
+    void test2() {
+        Object[][] a;
+        try {
+            Object o = (a = null)[0][0];
+        } catch (NullPointerException npe) {
+            npeCount++;
+        }
+    }
+
+    void test3() {
+        Object[][][] a;
+        try {
+            Object o = (a = null)[0][0][0];
+        } catch (NullPointerException npe) {
+            npeCount++;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0512-JTreg-WrongNew/WrongNew.java b/test/testsuite/ouroboros/rc_test/RC0512-JTreg-WrongNew/WrongNew.java
new file mode 100755
index 0000000000000000000000000000000000000000..dd47f1d01bff40544b2ecccfd2b75363b7e91300
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0512-JTreg-WrongNew/WrongNew.java
@@ -0,0 +1,40 @@
+/*
+ * -@TestCaseID: WrongNew
+ * -@TestCaseName: WrongNew
+ * -@TestCaseType: Function Testing from JTreg
+ * -@RequirementID: None
+ * -@RequirementName: some testcases will be moved to FigtoTest when enable JTreg.
+ * -@Condition:no
+ *  -#c1: 测试环境正常
+ * -@Brief:将该用例从JTreg中摘出来，放到CI和组件daily测试中测试。该用例在JTreg连跑中会概率性挂掉
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: WrongNew.java
+ * -@ExecuteClass: WrongNew
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+class WrongNewList<T> {
+}
+
+class WrongNewArrayList<T> extends WrongNewList<T> {
+}
+
+public class WrongNew {
+    public static void main(String[] ps) {
+        WrongNewList<String> list = getList();
+        if (list != null) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public static WrongNewList<String> getList() {
+        return new WrongNewArrayList();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0513-JTreg-T6481655/T6481655.java b/test/testsuite/ouroboros/rc_test/RC0513-JTreg-T6481655/T6481655.java
new file mode 100755
index 0000000000000000000000000000000000000000..948320706dbdd831119d692b63166b4b7f691296
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0513-JTreg-T6481655/T6481655.java
@@ -0,0 +1,32 @@
+/*
+ * -@TestCaseID: T6481655
+ * -@TestCaseName: T6481655
+ * -@TestCaseType: Function Testing from JTreg
+ * -@RequirementID: None
+ * -@RequirementName: some testcases will be moved to FigtoTest when enable JTreg.
+ * -@Condition:no
+ *  -#c1: 测试环境正常
+ * -@Brief:将该用例从JTreg中摘出来，放到CI和组件daily测试中测试。该用例在JTreg连跑中会概率性挂掉
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: T6481655.java
+ * -@ExecuteClass: T6481655
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+public class T6481655 {
+
+    public static <T> T getT(T t) {
+        return t;
+    }
+
+    public static void main(String... s) {
+        if (T6481655.getT("").equals("") && (T6481655.getT("")).getClass().isInstance("java.lang.String")) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0514-JTreg-SingleLocalTest/SingleLocalTest.java b/test/testsuite/ouroboros/rc_test/RC0514-JTreg-SingleLocalTest/SingleLocalTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..f75e5c5c066e795f56079662965d929d84b1c819
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0514-JTreg-SingleLocalTest/SingleLocalTest.java
@@ -0,0 +1,45 @@
+/*
+ * -@TestCaseID: SingleLocalTest
+ * -@TestCaseName: SingleLocalTest
+ * -@TestCaseType: Function Testing from JTreg
+ * -@RequirementID: None
+ * -@RequirementName: some testcases will be moved to FigtoTest when enable JTreg.
+ * -@Condition:no
+ *  -#c1: 测试环境正常
+ * -@Brief:将该用例从JTreg中摘出来，放到CI和组件daily测试中测试。该用例在JTreg连跑中会概率性挂掉
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: SingleLocalTest.java
+ * -@ExecuteClass: SingleLocalTest
+ * -@ExecuteArgs:
+ * -@Remark:
+ */
+
+public class SingleLocalTest {
+    static F f;
+
+    public static void main(String[] args) {
+        StringBuffer sb = new StringBuffer();
+        class Local1 {
+            public Local1() {
+                f = () -> new Local1();
+                sb.append("1");
+            }
+        }
+        new Local1();
+        f.f();
+        String s = sb.toString();
+        if (!s.equals("11")) {
+            System.out.println("Expected '11' got '" + s + "'");
+        } else {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    interface F {
+        void f();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0515-GC-FrequentGCTest01/FrequentGCTest01.java b/test/testsuite/ouroboros/rc_test/RC0515-GC-FrequentGCTest01/FrequentGCTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..2527e342052199d1b01bafb417077f8fc96ff3b3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0515-GC-FrequentGCTest01/FrequentGCTest01.java
@@ -0,0 +1,54 @@
+/*
+ *- @TestCaseID: GC-TaskQueue-FrequentGCTest01
+ *- @TestCaseName: GC-TaskQueue-FrequentGCTest01
+ *- @TestCaseType: FunctionTest
+ *- @RequirementName: 添加GC队列及Runtime.GC正确性保证
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief: 验证频繁调用Runtime.getRuntime.gc()，GC队列仍然能保证GC的正确性。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: FrequentGCTest01.java
+ *- @ExecuteClass: FrequentGCTest01
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:
+ */
+
+
+import java.lang.ref.WeakReference;
+
+public class FrequentGCTest01 {
+    static int a = 100;
+
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < 100; i++) {
+            WeakReference rp = new WeakReference<Object>(new Object());
+            if (rp.get() == null) {
+                a++;
+            }
+            new Thread(new TriggerRP()).start();
+            Runtime.getRuntime().gc();
+            Thread.sleep(100);
+            if (rp.get() != null) {
+                a++;
+            }
+            if (a != 100) {
+                System.out.println("ErrorResult");
+                return;
+            }
+        }
+        System.out.println("ExpectResult");
+    }
+
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+                WeakReference wr = new WeakReference(new Object());
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/RC0516-GC-FrequentGCTest02/FrequentGCTest02.java b/test/testsuite/ouroboros/rc_test/RC0516-GC-FrequentGCTest02/FrequentGCTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fd2faec4037bb0aef53947e1b1961fd77523eec
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/RC0516-GC-FrequentGCTest02/FrequentGCTest02.java
@@ -0,0 +1,44 @@
+/*
+ *- @TestCaseID: GC-TaskQueue-FrequentGCTest02
+ *- @TestCaseName: GC-TaskQueue-FrequentGCTest02
+ *- @TestCaseType: FunctionTest
+ *- @RequirementName: 添加GC队列及Runtime.GC正确性保证
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief: art/maple的system.gc()里会限制频繁调用Runtime.getRuntime.gc().验证在程序初期内存充足的情况下，system.gc()不会实际执行垃圾回收操作。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: FrequentGCTest02.java
+ *- @ExecuteClass: FrequentGCTest02
+ *- @ExecuteArgs:
+ *- @Remark:该用例不能测试RC,只能测试GCOnly。原因是RC会直接将WeakReference清理掉。
+ *- @Author:
+ */
+
+
+import java.lang.ref.WeakReference;
+
+public class FrequentGCTest02 {
+    static int a = 100;
+
+    public static void main(String[] args) {
+        for (int i = 0; i < 100; i++) {
+            WeakReference rp = new WeakReference<Object>(new Object());
+            if (rp.get() == null) {
+                a++;
+            }
+            System.gc();
+            if (rp.get() == null) {
+                a++;
+            }
+            if (a != 100) {
+                System.out.println("ErrorResult");
+                return;
+            }
+        }
+        System.out.println("ExpectResult");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0305-rc-function-SubsumeRC01/SubsumeRC01.java b/test/testsuite/ouroboros/rc_test/common_test/RC0305-rc-function-SubsumeRC01/SubsumeRC01.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb32d91735861106eb71fc49512e6ddea33d1ca8
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0305-rc-function-SubsumeRC01/SubsumeRC01.java
@@ -0,0 +1,41 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/SubsumeRC01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test subsumerc for RC, return a field directly
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SubsumeRC01.java
+ *- @ExecuteClass: SubsumeRC01
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @ExpectMplCode:
+ *-  callassigned &MRT_LoadRefField_NaiveRCFast (
+ *-    regread ref %2,
+ *-    iaddrof ref <* <$LSubsumeRC01_3B>> 4 (regread ref %2)) { regassign ptr %1}
+ *-  regassign ref %3 (regread ptr %1)
+ *-  dassign %Reg0_R71 0 (regread ref %3)
+ *-  intrinsiccall MPL_CLEANUP_LOCALREFVARS_SKIP (dread ref %Reg0_R71)
+ *-  return (regread ref %3)
+ */
+public class SubsumeRC01 {
+    private String str;
+
+    public String testfunc() {
+        return str;
+    }
+
+    public static void main(String[] args){
+        SubsumeRC01 temp = new SubsumeRC01();
+        temp.testfunc();
+        System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0306-rc-function-SubsumeRC02/SubsumeRC02.java b/test/testsuite/ouroboros/rc_test/common_test/RC0306-rc-function-SubsumeRC02/SubsumeRC02.java
new file mode 100755
index 0000000000000000000000000000000000000000..453b73c93c80b7fd760d7d58f8604c112bfb299b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0306-rc-function-SubsumeRC02/SubsumeRC02.java
@@ -0,0 +1,43 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/SubsumeRC02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test subsumerc for RC, assign a value returned by function call to a field
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SubsumeRC02.java
+ *- @ExecuteClass: SubsumeRC02
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @ExpectMplCode:
+ *- callassigned &Native_java_lang_StringFactory_newStringFromString__Ljava_lang_String_2 (iread ref <* <* <$Ljava_2Flang_2FString_3B>>> 0 (addrof ptr $_PTR_C_STR_7400650073007400)) { regassign ref %1}
+ *- call &CC_WriteRefFieldNoInc (
+ *-   regread ref %2,
+ *-   iaddrof ref <* <$LSubsumeRC02_3B>> 4 (regread ref %2),
+ *-   regread ref %1)
+ */
+public class SubsumeRC02 {
+    private String str;
+
+    public SubsumeRC02() {
+    }
+
+    public void testfunc() {
+        str = new String("test");
+        return ;
+    }
+
+    public static void main(String[] args){
+        SubsumeRC02 temp = new SubsumeRC02();
+        temp.testfunc();
+        System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0307-rc-function-SubsumeRC03/SubsumeRC03.java b/test/testsuite/ouroboros/rc_test/common_test/RC0307-rc-function-SubsumeRC03/SubsumeRC03.java
new file mode 100755
index 0000000000000000000000000000000000000000..bf3bfe36443184959a02411cfdbb81bc2374ff48
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0307-rc-function-SubsumeRC03/SubsumeRC03.java
@@ -0,0 +1,46 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/SubsumeRC03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test subsumerc for RC, assign another object's field to a field
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: SubsumeRC03.java
+ *- @ExecuteClass: SubsumeRC03
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @ExpectMplCode:
+ *- callassigned &MRT_LoadRefField_NaiveRCFast (
+ *-   regread ref %2,
+ *-     iaddrof ref <* <$LSubsumeRC03_3B>> 4 (regread ref %2)) { regassign ref %1}
+ *- call &CC_WriteRefFieldNoInc (
+ *-   regread ref %3,
+ *-   iaddrof ref <* <$LSubsumeRC03_3B>> 4 (regread ref %3),
+ *-   regread ref %1)
+ */
+public class SubsumeRC03 {
+    private String str;
+
+    public SubsumeRC03() {
+    }
+
+    public void testfunc(SubsumeRC03 t) {
+        str = t.str;
+        return ;
+    }
+
+    public static void main(String[] args){
+        SubsumeRC03 temp0 = new SubsumeRC03();
+        SubsumeRC03 temp1 = new SubsumeRC03();
+        temp1.testfunc(temp0);
+        System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0308-rc-function-CondBasedRC01/CondBasedRC01.java b/test/testsuite/ouroboros/rc_test/common_test/RC0308-rc-function-CondBasedRC01/CondBasedRC01.java
new file mode 100755
index 0000000000000000000000000000000000000000..e2aac95169dcd1c60cfaefff3b6fb888e4883922
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0308-rc-function-CondBasedRC01/CondBasedRC01.java
@@ -0,0 +1,54 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/function/CondBasedRC01.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: test condbasedrc for RC, decref can be omitted if ref is null can be guaranteed
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: CondBasedRC01.java
+ *- @ExecuteClass: CondBasedRC01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+public class CondBasedRC01 {
+    private String str1;
+    public static String str2;
+
+    public CondBasedRC01() {
+    }
+
+    public String testfunc(String s) {
+        if (s == null) {
+            s = str1;
+        }
+        return s;
+    }
+
+    public String strfunc() {
+        return str1;
+    }
+
+    public String testfunc1() {
+        String t = strfunc();
+        if (t == null) {
+            t = str1;
+        }
+        return t;
+    }
+
+    public static void main(String[] args){
+        CondBasedRC01 temp1 = new CondBasedRC01();
+        String s = new String("test");
+        str2 = temp1.testfunc(s);
+        str2 = temp1.testfunc1();
+        System.out.println("ExpectResult");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/RCMixTest.java b/test/testsuite/ouroboros/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/RCMixTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..22ab652eb13a18ecb001d0f72aad81dfba336649
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/RCMixTest.java
@@ -0,0 +1,111 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest6
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:Weak 或Unowned和Permanent一起用在一个对象的case，验证是否能够正常被释放
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * Weak 或Unowned和Permanent一起用在一个对象的case，验证是否能够正常被释放
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCMixTest.java
+ *- @ExecuteClass: RCMixTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import com.huawei.ark.annotation.*;
+
+import java.lang.reflect.Field;
+
+
+public class RCMixTest {
+
+
+    public static void main(String[] args) {
+
+        new Test_A_Weak().test();
+        new Test_A_Unowned().test();
+        Runtime.getRuntime().gc();
+    }
+}
+
+class Test_A_Weak {
+    @Weak
+    Test_B_Weak bb;
+    Test_B_Weak bb2;
+
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("NullPointerException");
+        }
+        bb2.run();
+    }
+
+    private void foo() {
+        bb = new @Permanent Test_B_Weak();
+        bb2 = new Test_B_Weak();
+    }
+}
+
+class Test_B_Weak {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+
+
+class Test_B_Unowned {
+    @Unowned
+    Test_A_Unowned aa ;
+
+    // add volatile will crash
+    // static Test_A a1;
+
+    protected void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+
+class Test_A_Unowned {
+    Test_B_Unowned bb;
+
+    public void test() {
+        setReferences();
+        System.runFinalization();
+    }
+
+    private void setReferences() {
+        @Unowned
+        Test_A_Unowned ta;
+        ta = new @Permanent Test_A_Unowned();
+        ta.bb = new Test_B_Unowned();
+        //ta.bb.aa = ta;
+
+        try {
+            Field m = Test_B_Unowned.class.getDeclaredField("aa");
+            m.set(ta.bb, ta);
+            Test_A_Unowned a_temp = (Test_A_Unowned) m.get(ta.bb);
+            if (a_temp != ta) {
+                System.out.println("error");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/RCMixThreadTest.java b/test/testsuite/ouroboros/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/RCMixThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..338de8f0c7f44e2e462c68bde6f721acbca5d646
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/RCMixThreadTest.java
@@ -0,0 +1,99 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCMixThreadTest
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:多线程下调用Weak 或Unowned和Permanent一起用在一个对象的case，验证是否能够正常被释放
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 多线程下调用Weak 或Unowned和Permanent一起用在一个对象的case，验证是否能够正常被释放
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCMixThreadTest.java
+ *- @ExecuteClass: RCMixThreadTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.*;
+
+
+public class RCMixThreadTest {
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+    }
+
+    public static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCMixTest_Weak rcMixTest_weak = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak2 = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak3 = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak4 = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak5 = new RCMixTest_Weak();
+
+        rcMixTest_weak.start();
+        rcMixTest_weak2.start();
+        rcMixTest_weak3.start();
+        rcMixTest_weak4.start();
+        rcMixTest_weak5.start();
+
+        rcMixTest_weak.join();
+        rcMixTest_weak2.join();
+        rcMixTest_weak3.join();
+        rcMixTest_weak4.join();
+        rcMixTest_weak5.join();
+    }
+}
+
+
+class RCMixTest_Weak extends Thread {
+
+    public void run() {
+        new Test_A_Weak().test();
+    }
+}
+
+
+
+class Test_A_Weak {
+    @Weak
+    Test_B_Weak bb;
+    Test_B_Weak bb2;
+
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("NullPointerException");
+        }
+        bb2.run();
+    }
+
+    private void foo() {
+        bb = new @Permanent Test_B_Weak();
+        bb2 = new Test_B_Weak();
+    }
+}
+
+class Test_B_Weak {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/SoftRefTest04.java b/test/testsuite/ouroboros/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/SoftRefTest04.java
new file mode 100755
index 0000000000000000000000000000000000000000..4561c5164012525cd46a04b8c760e78fb340b711
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/SoftRefTest04.java
@@ -0,0 +1,78 @@
+/*
+ * -@TestCaseID:SoftRefTest04.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination: 通过OOM 触发gc时，SoftReference对象会被回收掉
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1：创建一个SoftReference对象，并将其放到ReferneceQueue中，该对象不应该被释放；
+ * -#step2：通过制造OOM进行GC
+ * -#step3：再次确认该对象应该被释放，且它所在的ReferenceQueue中有这个即将回收的Reference对象
+ * -@Expect:ExpectResult\n
+ * -@Priority: High
+ * -@Source: SoftRefTest04.java
+ * -@ExecuteClass: SoftRefTest04
+ * -@ExecuteArgs:
+ * -@Remark:
+ *
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+
+public class SoftRefTest04 {
+    private static Reference rp;
+    private static ReferenceQueue rq = new ReferenceQueue();
+    private static int a = 100;
+    private static ArrayList<byte[]> store;
+
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+
+    private static int oomTest() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+        try {
+            int Result = oomTest();
+        } catch (OutOfMemoryError o) {
+            // do nothing
+        }
+        if (rp.get() != null) {
+            System.out.println("Error Result when second check ");
+            a++;
+        }
+        Thread.sleep(500);
+        Reference r = rq.poll();
+        if (r == null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/SoftRefTest06.java b/test/testsuite/ouroboros/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/SoftRefTest06.java
new file mode 100755
index 0000000000000000000000000000000000000000..ec0c4b7260174f254258dcb730ca7f6c640e42a2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/SoftRefTest06.java
@@ -0,0 +1,81 @@
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+
+/*
+ * -@TestCaseID:SoftRefTest06.java
+ * -@TestCaseName:MyselfClassName
+ * -@RequirementName:[运行时需求]支持自动内存管理
+ * -@Title/Destination: SoftReference指向的对象在回收的时候，会触发自己的finalize方法。
+ * -@Condition: no
+ * -#c1
+ * -@Brief:functionTest
+ * -#step1：SoftReference指向一个软引用，该对象声明周期结束后，会立刻被回收；
+ * -#step2：执行一次后，进行一遍gc，进行环的自学习；
+ * -#step3：再执行一次后，判断环关联的软对象不应该被释放。
+ * -@Expect:ExpectResult1\nExpectResult2\n
+ * -@Priority: High
+ * -@Source: SoftRefTest06.java
+ * -@ExecuteClass: SoftRefTest06
+ * -@ExecuteArgs:
+ * -@Remark:
+ *
+ */
+
+public class SoftRefTest06 {
+    private static Reference rp;
+    private static ReferenceQueue rq = new ReferenceQueue();
+    private static ArrayList<byte[]> store;
+    private static int count = 1;
+
+    // 生命周期结束的软指针指向的对象，应该被释放，放到它的ReferenceQueue里
+    public static void objectDeadNormally() {
+        Reference sr = new SoftReference<SoftRefTest06>(new SoftRefTest06(), rq);
+        if (sr.get() == null) {
+            System.out.println("ErrorResult");
+        }
+        // sr will die now.
+    }
+
+    private static int oomTest() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+
+    private static void setSoftRef() {
+        // oom出发，回收软引用对象使用的内存
+        rp = new SoftReference<SoftRefTest06>(new SoftRefTest06(), rq);
+    }
+
+    public static void main(String[] args) {
+        objectDeadNormally();
+        Runtime.getRuntime().runFinalization();
+        setSoftRef();
+        try {
+            int oom = oomTest();
+        } catch (OutOfMemoryError ofm) {
+            // do nothing
+        }
+        if (rp.get() != null) {
+            System.out.println("Error Result when second check ");
+        }
+        Runtime.getRuntime().runFinalization();
+    }
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult" + count);
+        count++;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult1\nExpectResult2\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/RCHeaderTest.java b/test/testsuite/ouroboros/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/RCHeaderTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..d629ac0c62bba147ca0d830b9337d3122a5be553
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/RCHeaderTest.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID:RCHeaderTest.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 可以在不触发RP的情况下，及时回收cleaner referent引用的资源和对象
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：在方法体内为一个强引用加上一个Cleaner指向它；
+ * -#step2：强引用声明周期结束后，可以在不触发RP的情况下，应该会被立刻释放该对象占用的内存（Cleaner没有缓存语义）
+ *- @Expect:ExpectResult\nExpectResultEnd\n
+ *- @Priority: High
+ *- @Source: RCHeaderTest.java
+ *- @ExecuteClass: RCHeaderTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import sun.misc.Cleaner;
+
+class RCRunner implements Runnable {
+    public void run() {
+        RCHeaderTest.iArray = null;
+    }
+}
+
+class Resource {
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+
+
+public class RCHeaderTest {
+    static int[] iArray;
+    static Cleaner c = null;
+    Resource res;
+
+    public RCHeaderTest() {
+        iArray = new int[4];
+        res = new Resource();
+    }
+
+    static void foo() {
+        RCHeaderTest rcht = new RCHeaderTest();
+        c = Cleaner.create(rcht, new RCRunner());
+        if (c == null) {
+            System.out.println("Cleaner create failly");
+        }
+    }
+
+    public static void main(String[] args) {
+        foo();
+        Runtime.getRuntime().runFinalization();
+        System.out.println("ExpectResultEnd");    //ReleaseEnd
+
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResultEnd\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/RCHeaderTest02.java b/test/testsuite/ouroboros/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/RCHeaderTest02.java
new file mode 100755
index 0000000000000000000000000000000000000000..d81849e841b3ecf62d4ad6ee71b7f577429f9c31
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/RCHeaderTest02.java
@@ -0,0 +1,87 @@
+/*
+ *- @TestCaseID:RCHeaderTest02.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 软指针指向的对象生命周期结束后，仍及时回收cleaner referent引用的资源和对象
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：在方法体内为一个具有缓存语义的软引用rcht.sr加上一个Cleaner指向它；
+ * -#step2：该软引用生命周期结束后，应该会立刻释放该对象占用的内存（Cleaner没有缓存语义）
+ *- @Expect:ExpectResult\nExpectResultEnd\n
+ *- @Priority: High
+ *- @Source: RCHeaderTest02.java
+ *- @ExecuteClass: RCHeaderTest02
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import sun.misc.Cleaner;
+import java.util.ArrayList;
+import java.lang.ref.SoftReference;
+
+class RCRunner02 implements Runnable {
+    public void run() {
+        RCHeaderTest02.iArray = null;
+    }
+}
+
+class Resource02 {
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+
+
+public class RCHeaderTest02 {
+	private static ArrayList<byte[]> store;
+    static int[] iArray;
+    static Cleaner c = null;
+    Resource02 res02 = null;
+
+    public RCHeaderTest02() {
+        iArray = new int[4];
+        res02 = new Resource02();
+
+    }
+
+    //方法退出后，sr_rcht02声明周期结束，触发对SoftReference的处理，它指向的对象占用空间被释放。
+    static void foo() {
+        SoftReference<RCHeaderTest02> sr_rcht02 = new SoftReference<>(new RCHeaderTest02());
+        c = Cleaner.create(sr_rcht02, new RCRunner02());
+        if (sr_rcht02.get() == null || c == null) {
+            System.out.println("SoftReference error or Cleaner create failly");
+        }
+    }
+	
+    private static int oomTest() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        foo();
+        try {
+            int oom = oomTest();
+        } catch (OutOfMemoryError ofm) {}
+        Runtime.getRuntime().runFinalization();
+        System.out.println("ExpectResultEnd");    //ReleaseEnd
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResultEnd\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/RCHeaderTest03.java b/test/testsuite/ouroboros/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/RCHeaderTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..20ba4e87ffce7e5c2de1a01c8e368e0d7def2e34
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/RCHeaderTest03.java
@@ -0,0 +1,94 @@
+/*
+ *- @TestCaseID:RCHeaderTest03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 软指针指向的对象声明周期结束后，cleaner referent和Weak Annotation referent引用的资源和对象是会释放的
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：在方法体内为一个具有缓存语义的软引用rcht.sr加上一个Cleaner和一个Weak Annotation指向它；
+ * -#step2：该软引用生命回收后，应该会立刻释放该对象占用的内存（Cleaner和Weak Annotation对象没有缓存语义）
+ *- @Expect:oom occured\nSR release\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCHeaderTest03.java
+ *- @ExecuteClass: RCHeaderTest03
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import sun.misc.Cleaner;
+import java.util.ArrayList;
+import java.lang.ref.SoftReference;
+
+import com.huawei.ark.annotation.Weak;
+
+class RCRunner03 implements Runnable {
+    public void run() {
+        RCHeaderTest03.iArray = null;
+    }
+}
+
+
+public class RCHeaderTest03 {
+    static String[] iArray;
+    private static ArrayList<byte[]> store;
+    String @Weak [] wr_annotation = null;
+    Cleaner c = null;
+    SoftReference<String[]> sr = null;
+
+    public RCHeaderTest03() {
+        iArray = new String[4];
+        String[] temp = {"1", "2", "3", "4"};
+        wr_annotation = temp;
+        sr = new SoftReference<>(temp);
+    }
+
+    //方法退出后，实例变量sr声明周期结束，触发对SoftReference的处理，它指向的数组占用空间被释放。
+    void foo() {
+        c = Cleaner.create(wr_annotation, new RCRunner03());
+        if (c == null || wr_annotation.length != 4) {
+            System.out.println("Cleaner create failly");
+        }
+    }
+
+    private static int oomTest() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        RCHeaderTest03 rcht = new RCHeaderTest03();
+        rcht.foo();
+        try {
+            int oom = oomTest();
+        } catch (OutOfMemoryError ofm) {
+            System.out.println("oom occured");
+        }
+        Runtime.getRuntime().gc();
+        if (rcht.sr.get() == null ) {
+            System.out.println("SR release");
+        }
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (rcht.wr_annotation == null) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full oom occured\nSR release\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/RCHeaderTest06.java b/test/testsuite/ouroboros/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/RCHeaderTest06.java
new file mode 100755
index 0000000000000000000000000000000000000000..f0db267cf08a0438fe7a1ebfc5f580549296aac5
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/RCHeaderTest06.java
@@ -0,0 +1,69 @@
+/*
+ *- @TestCaseID:RCHeaderTest06.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 可以在不触发RP的情况下，及时回收Weak Annoatation referent和Cleaner 共同引用的资源和Finalize对象
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：在方法体内为一个强引用加上一个Weak Annoatation referent指向它；
+ * -#step2：强引用声明周期结束后，可以在不触发RP的情况下，应该会被立刻释放该对象占用的内存（Weak Annoatation referent没有缓存语义）
+ *- @Expect:ExpectResult\nExpectResultEnd\n
+ *- @Priority: High
+ *- @Source: RCHeaderTest06.java
+ *- @ExecuteClass: RCHeaderTest06
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import sun.misc.Cleaner;
+
+import com.huawei.ark.annotation.Weak;
+class RCRunner06 implements Runnable {
+    public void run() {
+        RCHeaderTest06.iArray = null;
+    }
+}
+
+class Resource06 {
+
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+
+
+public class RCHeaderTest06 {
+    static int[] iArray;
+    static Cleaner cleaner = null;
+    @Weak
+    Resource06 c = null;
+
+    public RCHeaderTest06() {
+        iArray = new int[4];
+        c = new Resource06();
+    }
+
+    static void foo() {
+        RCHeaderTest06 rcht = new RCHeaderTest06();
+        RCHeaderTest06.cleaner = Cleaner.create(rcht.c, new RCRunner06());
+        if (cleaner == null) {
+            System.out.println("Weak Annotation Object shouldn't be null");
+        }
+    }
+
+    public static void main(String[] args) {
+        foo();
+        Runtime.getRuntime().runFinalization();
+        System.out.println("ExpectResultEnd");
+
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResultEnd\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/RCHeaderTest07.java b/test/testsuite/ouroboros/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/RCHeaderTest07.java
new file mode 100755
index 0000000000000000000000000000000000000000..bd9e6292f3761a61c2a9b8eaf9161717be5e541a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/RCHeaderTest07.java
@@ -0,0 +1,66 @@
+/*
+ *- @TestCaseID:RCHeaderTest07.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination: 可以在不触发RP的情况下，及时回收cleaner referent引用的资源和Finalize对象
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1：在方法体内为一个强引用的finalize对象域加上一个Cleaner指向它；
+ * -#step2：强引用声明周期结束后，可以在不触发RP的情况下，应该会被立刻释放该对象占用的内存（Cleaner没有缓存语义）
+ *- @Expect:ExpectResult\nExpectResultEnd\n
+ *- @Priority: High
+ *- @Source: RCHeaderTest07.java
+ *- @ExecuteClass: RCHeaderTest07
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ */
+
+import sun.misc.Cleaner;
+class RCRunner07 implements Runnable {
+    public void run() {
+        RCHeaderTest07.iArray = null;
+    }
+}
+
+class Resource07 {
+
+
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+
+
+public class RCHeaderTest07 {
+    static int[] iArray;
+    static Cleaner c = null;
+    Resource07 res;
+
+    public RCHeaderTest07() {
+        iArray = new int[4];
+        res = new Resource07();
+    }
+
+    static void foo() {
+        RCHeaderTest07 rcht = new RCHeaderTest07();
+        c = Cleaner.create(rcht.res, new RCRunner07());
+        if (c == null) {
+            System.out.println("Cleaner create failly");
+        }
+    }
+
+    public static void main(String[] args) {
+        foo();
+        Runtime.getRuntime().runFinalization();
+        System.out.println("ExpectResultEnd");
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResultEnd\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/PlacementRCTest03.java b/test/testsuite/ouroboros/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/PlacementRCTest03.java
new file mode 100755
index 0000000000000000000000000000000000000000..7b1fc2a93ef102ee8987c2fcbcea07aa61375b23
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/PlacementRCTest03.java
@@ -0,0 +1,176 @@
+/*
+ *- @TestCaseID:PlacementRCTest03.java
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:检测在跳转语句（break, continue, return）控制流中，生命周期结束的对象，应该会被立即回收
+ *- @Condition: no
+ * -#c1
+ *- @Brief:functionTest
+ * -#step1:函数1做在continue ； continue tag的跳转for循环里，检查局部变量的及时回收情况
+ * -#step2:函数2做在return的跳转for循环里，检查局部变量的及时回收情况
+ * -#step3:函数3做在break的跳转do-while循环里，检查局部变量的及时回收情况
+ *- @Expect:a10\na2_i91_j4\nExpect Result\n
+ *- @Priority: High
+ *- @Source: PlacementRCTest03.java
+ *- @ExecuteClass: PlacementRCTest03
+ *- @ExecuteArgs:
+ *- @Remark:
+ *
+ *
+ */
+
+
+class PlacementRC_A3 {
+    public int count = 0;
+    public String className = "temp";
+
+    public PlacementRC_A3(String name) {
+        this.className = name;
+    }
+
+    public void changeName(String name) {
+        this.className = name;
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        synchronized (PlacementRCTest03.lock) {
+            if (this.count % 25 == 0) {
+                PlacementRCTest03.result += ("End" + count);
+            }
+        }
+    }    
+
+}
+
+public class PlacementRCTest03 {
+    public static String result = new String();
+    public static String lock = "";
+    private volatile static int count = 0;
+    private PlacementRC_A3 defInsideUseOutside = null;
+
+    //def outside, only use inside loop
+    public static void onlyUseInsideLoop() {
+        PlacementRC_A3 a1 = new PlacementRC_A3("a1");
+        continueTag:
+        for (count = 0; count < 100; count++) {
+            a1.changeName("a" + count);
+            a1.count = count;
+            if (count % 95 == 0) {
+                count = 100;
+                continue continueTag;
+            }
+            if (count % 4 == 0) {
+                if (count % 8 == 0)
+                    continue;
+                a1.changeName("a" + 100);
+                a1 = new PlacementRC_A3("a10");
+                a1.toString();
+            }
+            if (count >= 95)
+                System.out.println("Wrong Result");
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest03.lock) {
+            result += "Method1";
+        }
+    }
+
+    public static PlacementRC_A3 defAndUseInsideLoop() {
+        for (count = 0; count < 100; count++) {
+            PlacementRC_A3 a2 = new PlacementRC_A3("a2_i" + count);
+            a2.count = count;
+            a2.changeName("null");
+            for (int j = 0; j < 2; j++)
+                a2 = new PlacementRC_A3("a2_i" + count + "_j" + j);
+            if (count % 4 == 0) {
+                a2.changeName("a" + 100);
+                a2 = new PlacementRC_A3("a10");
+                if (count == 96) {
+                    Runtime.getRuntime().runFinalization();
+                    synchronized (PlacementRCTest03.lock) {
+                        result += "Method2";
+                    }
+                    return a2;
+                }
+                a2.toString();
+            } else {
+                a2.toString();
+
+            }
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest03.lock) {
+            result += "Method2";
+        }
+        return new PlacementRC_A3("wrong");
+    }
+
+    public static void main(String[] args) {
+        onlyUseInsideLoop();
+        System.out.println(defAndUseInsideLoop().className);
+        new PlacementRCTest03().defInsideAndUseOutsideLoop();
+        //System.out.println(result);
+        if(result.contains("Method1") && result.contains("Method2") && result.contains("Method3") && result.contains("End"))
+            System.out.println("Expect Result");
+        else
+            System.out.println("Error Result");
+
+    }
+
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        breakTag:
+        do {
+            int choice = count % 4;
+            this.defInsideUseOutside = new PlacementRC_A3("a2_i" + count);
+            switch (choice) {
+                case 1:
+                    for (int j = 0; j < 5; j++) {
+                        this.defInsideUseOutside = new PlacementRC_A3("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    if (count == 99)
+                        this.defInsideUseOutside.toString();
+                    break;
+                case 2:
+                    for (int j = 0; j < 2; j++) {
+                        this.defInsideUseOutside.changeName("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    break;
+                case 3:
+                    for (int j = 0; j < 5; j++) {
+                        this.defInsideUseOutside = new PlacementRC_A3("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    if (this.defInsideUseOutside.className.equals("a2_i91_j4")) {
+                        System.out.println(this.defInsideUseOutside.className);
+                        break breakTag;
+                    }
+                    if (this.defInsideUseOutside.className.equals("a2_i99_j4")) {
+                        System.out.println(this.defInsideUseOutside.className);
+                        break breakTag;
+                    }
+
+                    break;
+                default:
+                    this.defInsideUseOutside = new PlacementRC_A3("a2_i" + count);
+                    this.defInsideUseOutside.count = count;
+            }
+            count++;
+        } while (this.defInsideUseOutside.count < 100 && count < 100);
+        this.defInsideUseOutside.changeName("finish");
+        this.defInsideUseOutside = null;
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest03.lock) {
+            result += "Method3";
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full a10\na2_i91_j4\nExpect Result\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/UnsafeTest01.java b/test/testsuite/ouroboros/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/UnsafeTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..8166eb533058c647062307822fd95cfa4f744afd
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/UnsafeTest01.java
@@ -0,0 +1,82 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_UnsafeTest01
+ *- @TestCaseName: UnsafeTest01
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:unsafe.compareAndSwapObject()函数专项测试：验证compareAndSwapObject()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest01.java
+ *- @ExecuteClass:UnsafeTest01
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest01 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecompareAndSwapObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest01.res = UnsafeTest01.res - 10;
+        }
+        if (result == 3 && UnsafeTest01.res == 97){
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafecompareAndSwapObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Field param;
+        Object obj;
+        long offset;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new Billie5();
+            param = Billie5.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            unsafe.compareAndSwapObject(obj, offset, "Me", "billie5");
+            result = unsafe.getObject(obj, offset);
+            if(result.equals("billie5")){
+                UnsafeTest01.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie5{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/UnsafeTest02.java b/test/testsuite/ouroboros/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/UnsafeTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..a093f1a2c855467933acf37ecb20d69e19eca28b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/UnsafeTest02.java
@@ -0,0 +1,85 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_UnsafeTest02
+ *- @TestCaseName: UnsafeTest02
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:unsafe.getObjectVolatile()函数专项测试：验证getObjectVolatile()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest02.java
+ *- @ExecuteClass:UnsafeTest02
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest02 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest02.res -= 2;
+        }
+
+        if (result == 3 && UnsafeTest02.res == 97){
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetObjectVolatileTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie10.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie10();
+            result = unsafe.getObjectVolatile(obj, offset);
+            if(result.equals("eilish")){
+                UnsafeTest02.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie10{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/UnsafeTest03.java b/test/testsuite/ouroboros/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/UnsafeTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..3f49ea7787a57fb372cbd09305ffec263eb026ff
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/UnsafeTest03.java
@@ -0,0 +1,85 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_UnsafeTest03
+ *- @TestCaseName: UnsafeTest03
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:unsafe.getObject()函数专项测试：验证getObject()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest03.java
+ *- @ExecuteClass:UnsafeTest03
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest03 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest03.res -= 2;
+        }
+        if (result == 3 && UnsafeTest03.res == 97){
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie18.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie18();
+            result = unsafe.getObject(obj, offset);
+            if(result.equals("Me")){
+                UnsafeTest03.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie18{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/UnsafeTest04.java b/test/testsuite/ouroboros/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/UnsafeTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e5d35a44eebceee149c181d53c6cd7bbfbe9e06
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/UnsafeTest04.java
@@ -0,0 +1,86 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_UnsafeTest04
+ *- @TestCaseName: UnsafeTest04
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:unsafe.putObject()函数专项测试：验证putObject()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest04.java
+ *- @ExecuteClass:UnsafeTest04
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest04 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest04.res -= 2;
+        }
+        if (result == 3 && UnsafeTest04.res == 97){
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie19.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie19();
+            result = unsafe.getObject(obj, offset);
+            unsafe.putObject(obj, offset, "she");
+            result = unsafe.getObject(obj,offset);
+            if(result.equals("she")){
+                UnsafeTest04.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie19{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/UnsafeTest05.java b/test/testsuite/ouroboros/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/UnsafeTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..e77f56ad633ae3167ade34f367827238ef40e75a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/UnsafeTest05.java
@@ -0,0 +1,86 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_UnsafeTest05
+ *- @TestCaseName: UnsafeTest05
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:unsafe.putObjectVolatile()函数专项测试：验证putObjectVolatile()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest05.java
+ *- @ExecuteClass:UnsafeTest05
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest05 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest05.res -= 2;
+        }
+        if (result == 3 && UnsafeTest05.res == 97){
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputObjectVolatileTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie11.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie11();
+            result = unsafe.getObjectVolatile(obj, offset);
+            unsafe.putObjectVolatile(obj, offset, "Eilish");
+            result = unsafe.getObjectVolatile(obj, offset);
+            if(result.equals("Eilish")){
+                UnsafeTest05.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie11{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/UnsafeTest06.java b/test/testsuite/ouroboros/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/UnsafeTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..09e9d8021e1b74b092083ce305c94058f66060dc
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/UnsafeTest06.java
@@ -0,0 +1,86 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_UnsafeTest06
+ *- @TestCaseName: UnsafeTest06
+ *- @TestCaseType: Function Testing for MemoryBindingMethod Test
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:unsafe.putOrderedObject()函数专项测试：验证putOrderedObject()方法的基本功能正常。
+ *  -#step1:
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source:UnsafeTest06.java
+ *- @ExecuteClass:UnsafeTest06
+ *- @ExecuteArgs:
+ *- @Remark:
+ */
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeTest06 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputOrderedObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest06.res -= 2;
+        }
+        if (result == 3 && UnsafeTest06.res == 97){
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputOrderedObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie20.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie20();
+            result = unsafe.getObject(obj, offset);
+            unsafe.putOrderedObject(obj, offset, "she");
+            result = unsafe.getObject(obj,offset);
+            if(result.equals("she")){
+                UnsafeTest06.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie20{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/RCPermanentTest.java b/test/testsuite/ouroboros/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/RCPermanentTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..9b3b3508cad5c1e791f60b8331faab0c0f9131e2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/RCPermanentTest.java
@@ -0,0 +1,209 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:添加/没有Permanent annotation的数组，验证是否经过RC策略以及是否为堆内存
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 添加/没有Permanent annotation的普通数组,验证是否经过RC策略以及是否为堆内存
+ * 添加/没有Permanent annotation的Interger数组,验证是否经过RC策略以及是否为堆内存
+ * 添加/没有Permanent annotation的arraylist数组,验证是否经过RC策略以及是否为堆内存
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentTest.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentTest
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.Permanent;
+
+import java.lang.ref.WeakReference;
+
+public class RCPermanentTest {
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1(Object obj) {
+        obj = new int @Permanent [8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+
+    /*
+    验证new int [8]
+     */
+    static void method2(Object obj) {
+        obj = new int[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int [8];in method2");
+        }
+    }
+
+    /*
+    验证new @Permanent int[8]
+    */
+    static void method3(Object obj) {
+        obj = new @Permanent int[1];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent int[8];in method3");
+        }
+    }
+
+    /*
+    验证new Integer @Permanent [10]
+    */
+    static void method4(Object obj) {
+        Integer[] arr = new Integer @Permanent [10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer @Permanent [10];in method4");
+        }
+    }
+
+    /*
+   验证new @Permanent Integer  [10]
+   */
+    static void method5(Object obj) {
+        Integer[] arr = new @Permanent Integer[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent Integer [10];in method5");
+        }
+    }
+
+    /*
+    验证new Integer[10];
+    */
+    static void method6(Object obj) {
+        obj = new Integer[10];
+        boolean result1 = checkRC(obj);
+
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer[10];in method6");
+        }
+    }
+
+    /*
+    验证new @Permanent ArrayList[]{};
+    */
+    static void method7(Object obj) {
+        obj = new @Permanent ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent ArrayList[]{};in method7");
+        }
+    }
+
+    /*
+    验证new ArrayList @Permanent []{};
+    */
+    static void method8(Object obj) {
+        obj = new ArrayList @Permanent []{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList @Permanent []{};in method8");
+        }
+    }
+
+    /*
+    验证new ArrayList []{};
+    */
+    static void method9(Object obj) {
+        obj = new ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList []{}; method9");
+        }
+    }
+
+
+    static ArrayList<Object> noleak = new ArrayList<>();
+    
+    public static int NUM = 5;
+    public static void main(String[] args) {
+        for(int i=0;i<NUM;i++){
+            Object obj = null;
+            method1(obj);
+            method2(obj);
+            method3(obj);
+            method4(obj);
+            method5(obj);
+            method6(obj);
+            method7(obj);
+            method8(obj);
+            method9(obj);
+        }
+
+        if (checkNum == 9*NUM) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..843e811b3906f43a053c944a1e4104c05f1f6965
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/jniTestHelper.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/RCPermanentTest2.java b/test/testsuite/ouroboros/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/RCPermanentTest2.java
new file mode 100755
index 0000000000000000000000000000000000000000..9e317f4f6e43ff723a48ba08002776c28c3b6706
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/RCPermanentTest2.java
@@ -0,0 +1,213 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest2
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:添加/没有Permanent annotation的field，验证是否经过RC策略以及是否为堆内存
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 添加/没有Permanent annotation的常量,验证是否经过RC策略以及是否为堆内存
+ * 添加/没有Permanent annotation的局部变量,验证是否经过RC策略以及是否为堆内存
+ * 添加/没有Permanent annotation的static field,验证是否经过RC策略以及是否为堆内存
+ * 添加/没有Permanent annotation的static volatile field,验证是否经过RC策略以及是否为堆内存
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentTest2.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentTest2 
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.Permanent;
+
+import java.lang.ref.WeakReference;
+
+public class RCPermanentTest2 {
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    public static Integer INT = new @Permanent Integer(100);
+    public static Integer INT2 = new Integer(100);
+    static String STRING = new @Permanent String("test");
+    static Long LONG = new @Permanent Long(522222);
+    static Long LONG2 = null;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    /*
+    验证public final static Integer INT = new @Permanent Integer(100);
+    */
+    static void method1() {
+        boolean result = checkRC(INT);
+        boolean heapResult = isHeapObject(INT);
+
+        if ((result == false) && (heapResult == false)) {
+            checkNum++;
+        } else {
+            System.out.println("error in method1");
+            System.out.println("result:" + result + "    isHeap:" + heapResult);
+            System.out.println(String.valueOf(result));
+            System.out.println(String.valueOf(heapResult));
+        }
+    }
+
+    /*
+    验证public final static Integer INT2 = new Integer(100);
+    */
+    static void method2() {
+        boolean result = checkRC(INT2);
+        if (result == true && isHeapObject(INT2) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method2");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(INT2));
+        }
+    }
+
+    /*
+    验证static String STRING = new @Permanent String("test");
+    */
+    static void method3() {
+       // static String STRING = new @Permanent String("test");
+        boolean result = checkRC(STRING);
+        if (result == true && isHeapObject(STRING) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method3");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(STRING));
+        }
+    }
+
+    /*
+    验证static Long LONG2 = new  Long("test4");
+    */
+    static void method4() {
+        LONG2 = new Long(2222222);
+        boolean result = checkRC(LONG2);
+        if (result == true && isHeapObject(LONG2) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method4");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(LONG2));
+        }
+    }
+
+    /*
+    验证String obj = new @Permanent Long("test5");
+    */
+    static void method5() {
+        //String obj = new @Permanent String("test5");
+        Double obj = new @Permanent Double(3333.3);
+        boolean result = checkRC(obj);
+        if (result == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in method5");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+
+    /*
+    验证String obj = new String("test6");
+    */
+    static void method6() {
+        Double obj = new Double(3333.3);
+        boolean result = checkRC(obj);
+        if (result == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method6");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+
+    /*
+    验证obj =  new @Permanent Integer("test");
+    */
+    static volatile Integer obj = null;
+
+    static void method7() {
+        obj = new @Permanent Integer(123);
+        boolean result = checkRC(obj);
+        if (result == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in  method7");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+
+    /*
+    验证obj =  new @Permanent Integer("test");
+    */
+    static void method8() {
+        obj = new Integer(123);
+        boolean result = checkRC(obj);
+        if (result == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method8");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证static Long LONG = new @Permanent Long(522222);
+    */
+    static void method9() {
+        boolean result = checkRC(LONG);
+        if (result == false && isHeapObject(LONG) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in method3");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(LONG));
+        }
+    }
+
+
+    public static void main(String[] args) {
+        method1();
+        method2();
+        method3();
+        method4();
+        method5();
+        method6();
+        method7();
+        method8();
+        method9();
+
+        if (checkNum == 9) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7fd2b8ad8b97f1aafd1b2df3b55212eb79c77f5a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/jniTestHelper.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest2_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest2_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/RCPermanentTest3.java b/test/testsuite/ouroboros/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/RCPermanentTest3.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c4c418c501fdced58b38adec635c9d3eda7fdf7
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/RCPermanentTest3.java
@@ -0,0 +1,107 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest3
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:添加/没有Permanent annotation的arraylist，验证是否经过RC策略以及是否为堆内存
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 添加/没有Permanent annotation的arraylist,验证是否经过RC策略以及是否为堆内存
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentTest3.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentTest3
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.Permanent;
+
+import java.lang.ref.WeakReference;
+
+public class RCPermanentTest3 {
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1() {
+        ArrayList list = null;
+        list = new @Permanent ArrayList<>();
+        boolean result1 = checkRC(list);
+        boolean result2 = isHeapObject(list);
+        if (String.valueOf(result1).equals("false") && String.valueOf(result2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method1");
+            System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+
+    static void method2() {
+        ArrayList list = null;
+        list = new ArrayList<Object>();
+                list.add("test");
+        boolean result1 = checkRC(list);
+        boolean result2 = isHeapObject(list);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method2");
+            System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+
+
+    public static void main(String[] args) {
+
+        method1();
+        Runtime.getRuntime().gc();
+        method1();
+
+        method2();
+        Runtime.getRuntime().gc();
+        method2();
+
+        if (checkNum == 4) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6e2013f9c903aba014bfe63c14304cf4827b25fd
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/jniTestHelper.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest3_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest3_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/RCPermanentTest4.java b/test/testsuite/ouroboros/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/RCPermanentTest4.java
new file mode 100755
index 0000000000000000000000000000000000000000..98bc446f72fd6238df769c58612abe31088c7b9b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/RCPermanentTest4.java
@@ -0,0 +1,135 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest4
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:对环中的一个对象添加Permanent annotation，验证是否经过RC策略以及是否为堆内存
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 对环中的一个对象添加Permanent annotation,验证是否经过RC策略以及是否为堆内存
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentTest4.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentTest4
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.Permanent;
+
+import java.lang.ref.WeakReference;
+
+public class RCPermanentTest4 {
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    /*
+      验证环场景
+       */
+    static void method1() {
+        Cycle_A a = new Cycle_A();
+        a.b = null;
+        a.b = new @Permanent Cycle_B();
+        a.b.a = a;
+        int result = a.add() + a.b.add();
+        if (result == 16) {
+            checkNum++;
+        } else {
+            System.out.println("result:" + result);
+        }
+        boolean resultA1 = checkRC(a);
+        boolean resultA2 = isHeapObject(a);
+        boolean resultB1 = checkRC(a.b);
+        boolean resultB2 = isHeapObject(a.b);
+        if (String.valueOf(resultA1).equals("true") && String.valueOf(resultA2).equals("true") && String.valueOf(resultB1).equals("false") && String.valueOf(resultB2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error");
+            System.out.println("CycleA_checkRC:" + resultA1);
+            System.out.println("CycleA_isHeap:" + resultA2);
+            System.out.println("CycleB_checkRC:" + resultB1);
+            System.out.println("CycleB_isHeap:" + resultB2);
+            //System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+
+    }
+
+
+    public static void main(String[] args) {
+
+        method1();
+
+
+        if (checkNum == 2) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+
+
+class Cycle_A {
+    Cycle_B b;
+    static int sum;
+    static int a;
+
+    Cycle_A() {
+        a = 3;
+    }
+
+    int add() {
+        sum = a + b.b;
+        return sum;
+    }
+
+}
+
+class Cycle_B {
+    Cycle_A a;
+    static int sum;
+    static int b;
+
+    Cycle_B() {
+        b = 5;
+
+    }
+
+    int add() {
+        sum = a.a + b;
+        return sum;
+    }
+
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..036f28224664943235d5f19e837824d62eb4c722
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/jniTestHelper.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest4_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest4_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/RCPermanentTest5.java b/test/testsuite/ouroboros/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/RCPermanentTest5.java
new file mode 100755
index 0000000000000000000000000000000000000000..090ab670b716ceda3ec2aa59b42208d653c3c839
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/RCPermanentTest5.java
@@ -0,0 +1,136 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest5
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:添加/没有Permanent annotation的Reference和有finalize方法的对象，验证是否经过RC策略以及是否为堆内存
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 添加/没有Permanent annotation的soft/weak/phantom Reference,验证是否经过RC策略以及是否为堆内存
+ * 添加/没有Permanent annotation的有finalize方法的对象,验证是否经过RC策略以及是否为堆内存
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentTest5.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentTest5
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.Permanent;
+import sun.misc.Cleaner;
+
+import java.lang.ref.*;
+
+import static java.lang.Thread.sleep;
+
+
+class FinalizableObject {
+    // static int value;
+
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+
+public class RCPermanentTest5 {
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    static Object owner;
+    static int checkSum;
+    static Object referent = new Object();
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+
+    static void methodRef1(Object obj) {
+        obj = new @Permanent WeakReference(referent);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+
+    static void methodRef2(Object obj) {
+        obj = new @Permanent SoftReference(referent);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+
+    static void methodRef3(Object obj) {
+        ReferenceQueue rq = new ReferenceQueue();
+        obj = new @Permanent PhantomReference(referent, rq);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+
+    static void methodFinal(Object obj) throws InterruptedException {
+        obj = new @Permanent FinalizableObject();
+        sleep(3000);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+
+
+    public static void main(String[] args) throws InterruptedException {
+        Object obj = null;
+        methodRef1(obj);
+        methodRef2(obj);
+        methodRef3(obj);
+        methodFinal(obj);
+
+        if (checkSum == 4) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkSum);
+        }
+
+    }
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..05ef52c6c16b38fe40cb3f4839f2bcc6fc9f09f3
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/jniTestHelper.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest5_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest5_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/RCPermanentThread.java b/test/testsuite/ouroboros/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/RCPermanentThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..c2fe1602b84ee85414bfcb39c9609f0df07276f9
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/RCPermanentThread.java
@@ -0,0 +1,743 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentThread
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:多线程下调用PermanentTest的case，验证是否经过RC策略以及是否为堆内存
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 多线程下调用PermanentTest的case,包括caseRC0411,RC0412,RC0413,RC0414,RC0415,验证是否经过RC策略以及是否为堆内存
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentThread.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentThread
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.Permanent;
+import sun.misc.Cleaner;
+
+import java.lang.ref.*;
+
+public class RCPermanentThread {
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCPermanentTest rcPermanentTest = new RCPermanentTest();
+        RCPermanentTest2 rcPermanentTest2 = new RCPermanentTest2();
+        RCPermanentTest3 rcPermanentTest3 = new RCPermanentTest3();
+        RCPermanentTest4 rcPermanentTest4 = new RCPermanentTest4();
+        RCPermanentTest5 rcPermanentTest5 = new RCPermanentTest5();
+
+        rcPermanentTest.start();
+        rcPermanentTest2.start();
+        rcPermanentTest3.start();
+        rcPermanentTest4.start();
+        rcPermanentTest5.start();
+
+        rcPermanentTest.join();
+        rcPermanentTest2.join();
+        rcPermanentTest3.join();
+        rcPermanentTest4.join();
+        rcPermanentTest5.join();
+
+        if (rcPermanentTest.check() && rcPermanentTest2.check() && rcPermanentTest3.check() && rcPermanentTest4.check() && rcPermanentTest5.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + rcPermanentTest.check());
+            System.out.println("rcPermanentTest2.check() :" + rcPermanentTest2.check());
+            System.out.println("rcPermanentTest3.check() :" + rcPermanentTest3.check());
+            System.out.println("rcPermanentTest4.check() :" + rcPermanentTest4.check());
+            System.out.println("rcPermanentTest5.check() :" + rcPermanentTest5.check());
+        }
+    }
+}
+
+
+class RCPermanentTest extends Thread {
+    public boolean checkout;
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+
+    /*
+    验证new int [8]
+     */
+    static void method2(Object obj) {
+        obj = new int[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int [8];in method2");
+        }
+    }
+
+    /*
+    验证new @Permanent int[8]
+    */
+    static void method3(Object obj) {
+        obj = new @Permanent int[1];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent int[8];in method3");
+        }
+    }
+
+    /*
+    验证new Integer @Permanent [10]
+    */
+    static void method4(Object obj) {
+        Integer[] arr = new Integer@Permanent[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer @Permanent [10];in method4");
+        }
+    }
+
+    /*
+   验证new @Permanent Integer  [10]
+   */
+    static void method5(Object obj) {
+        Integer[] arr = new @Permanent Integer[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent Integer [10];in method5");
+        }
+    }
+
+    /*
+    验证new Integer[10];
+    */
+    static void method6(Object obj) {
+        obj = new Integer[10];
+        boolean result1 = checkRC(obj);
+
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer[10];in method6");
+        }
+    }
+
+    /*
+    验证new @Permanent ArrayList[]{};
+    */
+    static void method7(Object obj) {
+        obj = new @Permanent ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent ArrayList[]{};in method7");
+        }
+    }
+
+    /*
+    验证new ArrayList @Permanent []{};
+    */
+    static void method8(Object obj) {
+        obj = new ArrayList@Permanent[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList @Permanent []{};in method8");
+        }
+    }
+
+    /*
+    验证new ArrayList []{};
+    */
+    static void method9(Object obj) {
+        obj = new ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList []{}; method9");
+        }
+    }
+
+
+    static ArrayList<Object> noleak = new ArrayList<>();
+
+    public void run(
+        ) {
+        Object obj = null;
+        method1(obj);
+        method2(obj);
+        method3(obj);
+        method4(obj);
+        method5(obj);
+        method6(obj);
+        method7(obj);
+        method8(obj);
+        method9(obj);
+  
+        if (checkNum == 9) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkNum);
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+class RCPermanentTest2 extends Thread {
+    public boolean checkout;
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    public static Integer INT = new @Permanent Integer(100);
+    public static Integer INT2 = new Integer(100);
+    static String STRING = new @Permanent String("test");
+    static Long LONG = new @Permanent Long(23534);
+    static Long LONG2 = null;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    /*
+    验证public final static Integer INT = new @Permanent Integer(100);
+    */
+    static void method1() {
+        boolean result = checkRC(INT);
+        boolean heapResult = isHeapObject(INT);
+
+        if ((result == false) && (heapResult == false)) {
+            checkNum++;
+        } else {
+            System.out.println("error in method1");
+            System.out.println("result:" + result + "    isHeap:" + heapResult);
+            System.out.println(String.valueOf(result));
+            System.out.println(String.valueOf(heapResult));
+        }
+    }
+
+    /*
+    验证public final static Integer INT2 = new Integer(100);
+    */
+    static void method2() {
+        boolean result = checkRC(INT2);
+        if (result == true && isHeapObject(INT2) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method2");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(INT2));
+        }
+    }
+
+    /*
+    验证static String STRING = new @Permanent String("test");
+    */
+    static void method3() {
+        // STRING = new @Permanent (454555);
+        boolean result = checkRC(STRING);
+        if (result == true && isHeapObject(STRING) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method3");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(STRING));
+        }
+    }
+
+    /*
+    验证static Long LONG2 = new  Long("test4");
+    */
+    static void method4() {
+        LONG2 = new Long(2222222);
+        boolean result = checkRC(LONG2);
+        if (result == true && isHeapObject(LONG2) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method4");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(LONG2));
+        }
+    }
+
+    /*
+    验证String obj = new @Permanent Long("test5");
+    */
+    static void method5() {
+        //String obj = new @Permanent String("test5");
+        Double obj = new @Permanent Double(3333.3);
+        boolean result = checkRC(obj);
+        if (result == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in method5");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+
+    /*
+    验证String obj = new String("test6");
+    */
+    static void method6() {
+        Double obj = new Double(3333.3);
+        boolean result = checkRC(obj);
+        if (result == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method6");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+
+    /*
+    验证obj =  new @Permanent Integer("test");
+    */
+    static volatile Integer obj = null;
+
+    static void method7() {
+        obj = new @Permanent Integer(123);
+        boolean result = checkRC(obj);
+        if (result == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in  method7");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+
+    /*
+    验证obj =  new @Permanent Integer("test");
+    */
+    static void method8() {
+        obj = new Integer(123);
+        boolean result = checkRC(obj);
+        if (result == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method8");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+
+    /*
+    验证static long LONG = new @Permanent long(23534);
+    */
+    static void method9() {
+        boolean result = checkRC(LONG);
+        if (result == false && isHeapObject(LONG) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in method9");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(LONG));
+        }
+    }
+
+
+    public void run() {
+        method1();
+        method2();
+        method3();
+        method4();
+        method5();
+        method6();
+        method7();
+        method8();
+        method9();
+        //System.out.println(checkNum);
+        if (checkNum == 9) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkNum);
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+class RCPermanentTest3 extends Thread {
+    public boolean checkout;
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1() {
+        ArrayList list = null;
+        list = new @Permanent ArrayList<>();
+        boolean result1 = checkRC(list);
+        boolean result2 = isHeapObject(list);
+        if (String.valueOf(result1).equals("false") && String.valueOf(result2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method1");
+            System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+
+    static void method2() {
+        ArrayList list = null;
+        list = new ArrayList<Object>();
+        list.add("test");
+        boolean result1 = checkRC(list);
+        boolean result2 = isHeapObject(list);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method2");
+            System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+
+
+    public void run() {
+
+        method1();
+        Runtime.getRuntime().gc();
+        method1();
+
+        method2();
+        Runtime.getRuntime().gc();
+        method2();
+        
+        if (checkNum == 4) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkNum);
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+class RCPermanentTest4 extends Thread {
+    public boolean checkout;
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    /*
+      验证环场景
+       */
+    static void method1() {
+        Cycle_A a = new Cycle_A();
+        a.b = null;
+        a.b = new @Permanent Cycle_B();
+        a.b.a = a;
+        int result = a.add() + a.b.add();
+        if (result == 16) {
+            checkNum++;
+        } else {
+            System.out.println("result:" + result);
+        }
+        boolean resultA1 = checkRC(a);
+        boolean resultA2 = isHeapObject(a);
+        boolean resultB1 = checkRC(a.b);
+        boolean resultB2 = isHeapObject(a.b);
+        if (String.valueOf(resultA1).equals("true") && String.valueOf(resultA2).equals("true") && String.valueOf(resultB1).equals("false") && String.valueOf(resultB2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error");
+            System.out.println("CycleA_checkRC:" + resultA1);
+            System.out.println("CycleA_isHeap:" + resultA2);
+            System.out.println("CycleB_checkRC:" + resultB1);
+            System.out.println("CycleB_isHeap:" + resultB2);
+            //System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+
+    }
+
+    public void run() {
+
+        method1();
+       
+        if (checkNum == 2) {
+            checkout = true;
+        } else {
+            System.out.println(checkNum);
+            checkout = false;
+
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+
+class Cycle_A {
+    Cycle_B b;
+    static int sum;
+    static int a;
+
+    Cycle_A() {
+        a = 3;
+    }
+
+    int add() {
+        sum = a + b.b;
+        return sum;
+    }
+
+}
+
+class Cycle_B {
+    Cycle_A a;
+    static int sum;
+    static int b;
+
+    Cycle_B() {
+        b = 5;
+
+    }
+
+    int add() {
+        sum = a.a + b;
+        return sum;
+    }
+
+}
+
+
+class RCPermanentTest5 extends Thread {
+    public boolean checkout;
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    static Object owner;
+    static Object referent = new Object();
+    static int checkSum;
+
+    public void run() {
+        Object obj = null;
+        methodRef1(obj);
+        methodRef2(obj);
+        methodRef3(obj);
+        methodFinal(obj);
+        
+        if (checkSum == 4) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkSum);
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+
+    static void methodRef1(Object obj) {
+        obj = new @Permanent WeakReference(referent);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+
+    static void methodRef2(Object obj) {
+        obj = new @Permanent SoftReference(referent);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+
+    static void methodRef3(Object obj) {
+        ReferenceQueue rq = new ReferenceQueue();
+        obj = new @Permanent PhantomReference(referent, rq);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+
+    static void methodFinal(Object obj) {
+        obj = new @Permanent FinalizableObject();
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+
+
+}
+
+class FinalizableObject {
+    // static int value;
+
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c3dd79c74a48a56118894192c963efd6fc0b1c61
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/jniTestHelper.cpp
@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentThread_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentThread_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest2_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest2_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest3_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest3_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest4_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest4_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest5_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest5_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/RCPermanentTest6.java b/test/testsuite/ouroboros/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/RCPermanentTest6.java
new file mode 100755
index 0000000000000000000000000000000000000000..d2f1c1a0baca21c7a59e91f4fe9db8037be5618f
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/RCPermanentTest6.java
@@ -0,0 +1,124 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest6
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:@Permanent &@Unowned 在同个case中使用。添加Permanent annotation的数组，验证是否经过RC策略以及是否为堆内存；添加Unowned annotation，确认被正常释放
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 添加Permanent annotation的普通数组,验证是否经过RC策略以及是否为堆内存
+ * 添加Unowned annotation，确认被正常释放
+ *- @Expect:ExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentTest6.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentTest6
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.*;
+
+import java.lang.ref.WeakReference;
+
+public class RCPermanentTest6 {
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+
+
+    public static void main(String[] args) {
+        Object obj = null;
+        method1(obj);
+        new Test_A().test();
+        if (checkNum == 1) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+
+class Test_B {
+    @Unowned
+    Test_A aa;
+
+    // add volatile will crash
+    // static Test_A a1;
+
+    protected void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+
+class Test_A {
+    Test_B bb;
+
+    public void test() {
+        setReferences();
+        System.runFinalization();
+    }
+
+    private void setReferences() {
+        Test_A ta = new Test_A();
+        ta.bb = new Test_B();
+        //ta.bb.aa = ta;
+
+        try {
+            Field m = Test_B.class.getDeclaredField("aa");
+            m.set(ta.bb, ta);
+            Test_A a_temp = (Test_A) m.get(ta.bb);
+            if (a_temp != ta) {
+                System.out.println("error");
+            }
+            //Field m1 = Test_B.class.getDeclaredField("a1");
+            //m1.set(null, ta);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c7c9aaccdebb4aeb5e51ebb76f8ab46a5265581a
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/jniTestHelper.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest6_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest6_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/RCPermanentThread2.java b/test/testsuite/ouroboros/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/RCPermanentThread2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a3fc951f8fbca61aa2a6031d7da1419ede266200
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/RCPermanentThread2.java
@@ -0,0 +1,329 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentThread2
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:多线程下调用：@Permanent &@Unowned 在同个case中使用。添加Permanent annotation的数组，验证是否经过RC策略以及是否为堆内存；添加Unowned annotation，确认被正常释放
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 多线程下调用：@Permanent &@Unowned 在同个case中使用。添加Permanent annotation的数组，验证是否经过RC策略以及是否为堆内存；添加Unowned annotation，确认被正常释放
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentThread2.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentThread2
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.*;
+
+
+public class RCPermanentThread2 {
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+        rc_testcase_main_wrapper2();
+    }
+
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCPermanentTest rcPermanentTest = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest2 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest3 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest4 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest5 = new RCPermanentTest();
+
+        rcPermanentTest.start();
+        rcPermanentTest.join();
+        
+        rcPermanentTest2.start();
+        rcPermanentTest2.join();
+
+        rcPermanentTest3.start();
+        rcPermanentTest3.join();
+
+        rcPermanentTest4.start();
+        rcPermanentTest4.join();
+
+        rcPermanentTest5.start();
+        rcPermanentTest5.join();
+
+        // rcPermanentTest.join();
+        // rcPermanentTest2.join();
+        // rcPermanentTest3.join();
+        // rcPermanentTest4.join();
+        // rcPermanentTest5.join();
+
+        if (rcPermanentTest.check() && rcPermanentTest2.check() && rcPermanentTest3.check() && rcPermanentTest4.check() && rcPermanentTest5.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + rcPermanentTest.check());
+            System.out.println("rcPermanentTest2.check() :" + rcPermanentTest2.check());
+            System.out.println("rcPermanentTest3.check() :" + rcPermanentTest3.check());
+            System.out.println("rcPermanentTest4.check() :" + rcPermanentTest4.check());
+            System.out.println("rcPermanentTest5.check() :" + rcPermanentTest5.check());
+
+        }
+    }
+
+    private static void rc_testcase_main_wrapper2() throws InterruptedException {
+        RCUnownedTest rcUnownedTest = new RCUnownedTest();
+        RCUnownedTest rcUnownedTest2 = new RCUnownedTest();
+        RCUnownedTest rcUnownedTest3 = new RCUnownedTest();
+        RCUnownedTest rcUnownedTest4 = new RCUnownedTest();
+        RCUnownedTest rcUnownedTest5 = new RCUnownedTest();
+
+        rcUnownedTest.start();
+        rcUnownedTest2.start();
+        rcUnownedTest3.start();
+        rcUnownedTest4.start();
+        rcUnownedTest5.start();
+
+        rcUnownedTest.join();
+        rcUnownedTest2.join();
+        rcUnownedTest3.join();
+        rcUnownedTest4.join();
+        rcUnownedTest5.join();
+    }
+}
+
+
+class RCPermanentTest extends Thread {
+    public boolean checkout;
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+
+    /*
+    验证new int [8]
+     */
+    static void method2(Object obj) {
+        obj = new int[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int [8];in method2");
+        }
+    }
+
+    /*
+    验证new @Permanent int[8]
+    */
+    static void method3(Object obj) {
+        obj = new @Permanent int[1];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent int[8];in method3");
+        }
+    }
+
+    /*
+    验证new Integer @Permanent [10]
+    */
+    static void method4(Object obj) {
+        Integer[] arr = new Integer@Permanent[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer @Permanent [10];in method4");
+        }
+    }
+
+    /*
+   验证new @Permanent Integer  [10]
+   */
+    static void method5(Object obj) {
+        Integer[] arr = new @Permanent Integer[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent Integer [10];in method5");
+        }
+    }
+
+    /*
+    验证new Integer[10];
+    */
+    static void method6(Object obj) {
+        obj = new Integer[10];
+        boolean result1 = checkRC(obj);
+
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer[10];in method6");
+            System.out.println("checkRC(obj):" + result1 + "        isHeapObject(obj):" + isHeapObject(obj));
+        }
+    }
+
+    /*
+    验证new @Permanent ArrayList[]{};
+    */
+    static void method7(Object obj) {
+        obj = new @Permanent ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent ArrayList[]{};in method7");
+        }
+    }
+
+    /*
+    验证new ArrayList @Permanent []{};
+    */
+    static void method8(Object obj) {
+        obj = new ArrayList@Permanent[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList @Permanent []{};in method8");
+        }
+    }
+
+    /*
+    验证new ArrayList []{};
+    */
+    static void method9(Object obj) {
+        obj = new ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList []{}; method9");
+        }
+    }
+
+
+    static ArrayList<Object> noleak = new ArrayList<>();
+
+    public void run(
+    ) {
+        checkNum = 0;
+        Object obj = null;
+        method1(obj);
+        method2(obj);
+        method3(obj);
+        method4(obj);
+        method5(obj);
+        method6(obj);
+        method7(obj);
+        method8(obj);
+        method9(obj);
+        // System.out.println(checkNum);
+        if (checkNum == 9) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println("checkout== false,checkNum:"+checkNum);
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+class RCUnownedTest extends Thread {
+    public void run() {
+        new Test_A().test();
+
+    }
+}
+
+class Test_A {
+    Test_B bb;
+
+    public void test() {
+        setReferences();
+        System.runFinalization();
+    }
+
+    private void setReferences() {
+        Test_A ta = new Test_A();
+        ta.bb = new Test_B();
+        //ta.bb.aa = ta;
+
+        try {
+            Field m = Test_B.class.getDeclaredField("aa");
+            m.set(ta.bb, ta);
+            Test_A a_temp = (Test_A) m.get(ta.bb);
+            if (a_temp != ta) {
+                System.out.println("error");
+            }
+            //Field m1 = Test_B.class.getDeclaredField("a1");
+            //m1.set(null, ta);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+}
+
+class Test_B {
+    @Unowned
+    Test_A aa;
+
+    // add volatile will crash
+    // static Test_A a1;
+
+    protected void finalize() {
+        System.out.println("ExpectResult");
+    }
+
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..31811eb73638c3784e8db250533d3bce19a8aa6c
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/jniTestHelper.cpp
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentThread2_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentThread2_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/RCPermanentTest7.java b/test/testsuite/ouroboros/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/RCPermanentTest7.java
new file mode 100755
index 0000000000000000000000000000000000000000..49d79c9902166a09c79af42c7be523b6f2325bf6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/RCPermanentTest7.java
@@ -0,0 +1,112 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest7
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:@Permanent &@Weak在同个case中使用。添加Permanent annotation的数组，验证是否经过RC策略以及是否为堆内存；添加Weak annotation，确认被正常释放
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 添加Permanent annotation的普通数组,验证是否经过RC策略以及是否为堆内存
+ * 添加Weak annotation，确认被正常释放
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentTest7.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentTest7
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import com.huawei.ark.annotation.*;
+
+
+public class RCPermanentTest7 {
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+
+
+    public static void main(String[] args) {
+        Object obj = null;
+        method1(obj);
+        new Test_A().test();
+        if (checkNum == 1) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+
+class Test_A {
+    @Weak
+    Test_B bb;
+    Test_B bb2;
+
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");
+        }
+        bb2.run();
+    }
+
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+    }
+}
+
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..24c07934365baf4609c0545da7560102d6c89fd5
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/jniTestHelper.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest7_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest7_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/RCPermanentThread3.java b/test/testsuite/ouroboros/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/RCPermanentThread3.java
new file mode 100755
index 0000000000000000000000000000000000000000..20770d454eda387cb514e324ca22fc9d58fe291d
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/RCPermanentThread3.java
@@ -0,0 +1,319 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentThread3
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:多线程下调用：@Permanent &@Weak在同个case中使用。添加Permanent annotation的数组，验证是否经过RC策略以及是否为堆内存；添加Weak annotation，确认被正常释放
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 多线程下调用：@Permanent &@Weak在同个case中使用。添加Permanent annotation的数组，验证是否经过RC策略以及是否为堆内存；添加Weak annotation，确认被正常释放
+ *- @Expect:ExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentThread3.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentThread3
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.*;
+
+
+public class RCPermanentThread3 {
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+        rc_testcase_main_wrapper2();
+    }
+
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCPermanentTest rcPermanentTest = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest2 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest3 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest4 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest5 = new RCPermanentTest();
+
+        rcPermanentTest.start();
+        rcPermanentTest.join();
+        
+        rcPermanentTest2.start();
+        rcPermanentTest2.join();
+
+        rcPermanentTest3.start();
+        rcPermanentTest3.join();
+
+        rcPermanentTest4.start();
+        rcPermanentTest4.join();
+
+        rcPermanentTest5.start();
+        rcPermanentTest5.join();
+
+        // rcPermanentTest.join();
+        // rcPermanentTest2.join();
+        // rcPermanentTest3.join();
+        // rcPermanentTest4.join();
+        // rcPermanentTest5.join();
+
+        if (rcPermanentTest.check() && rcPermanentTest2.check() && rcPermanentTest3.check() && rcPermanentTest4.check() && rcPermanentTest5.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + rcPermanentTest.check());
+            System.out.println("rcPermanentTest2.check() :" + rcPermanentTest2.check());
+            System.out.println("rcPermanentTest3.check() :" + rcPermanentTest3.check());
+            System.out.println("rcPermanentTest4.check() :" + rcPermanentTest4.check());
+            System.out.println("rcPermanentTest5.check() :" + rcPermanentTest5.check());
+
+        }
+    }
+
+    private static void rc_testcase_main_wrapper2() throws InterruptedException {
+        RCWeakTest rcWeakTest = new RCWeakTest();
+        RCWeakTest rcWeakTest2 = new RCWeakTest();
+        RCWeakTest rcWeakTest3 = new RCWeakTest();
+        RCWeakTest rcWeakTest4 = new RCWeakTest();
+        RCWeakTest rcWeakTest5 = new RCWeakTest();
+
+        rcWeakTest.start();
+        rcWeakTest2.start();
+        rcWeakTest3.start();
+        rcWeakTest4.start();
+        rcWeakTest5.start();
+
+        rcWeakTest.join();
+        rcWeakTest2.join();
+        rcWeakTest3.join();
+        rcWeakTest4.join();
+        rcWeakTest5.join();
+    }
+}
+
+
+class RCPermanentTest extends Thread {
+    public boolean checkout;
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+
+    /*
+    验证new int [8]
+     */
+    static void method2(Object obj) {
+        obj = new int[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int [8];in method2");
+        }
+    }
+
+    /*
+    验证new @Permanent int[8]
+    */
+    static void method3(Object obj) {
+        obj = new @Permanent int[1];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent int[8];in method3");
+        }
+    }
+
+    /*
+    验证new Integer @Permanent [10]
+    */
+    static void method4(Object obj) {
+        Integer[] arr = new Integer@Permanent[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer @Permanent [10];in method4");
+        }
+    }
+
+    /*
+   验证new @Permanent Integer  [10]
+   */
+    static void method5(Object obj) {
+        Integer[] arr = new @Permanent Integer[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent Integer [10];in method5");
+        }
+    }
+
+    /*
+    验证new Integer[10];
+    */
+    static void method6(Object obj) {
+        obj = new Integer[10];
+        boolean result1 = checkRC(obj);
+
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer[10];in method6");
+            System.out.println("checkRC(obj):" + result1 + "        isHeapObject(obj):" + isHeapObject(obj));
+        }
+    }
+
+    /*
+    验证new @Permanent ArrayList[]{};
+    */
+    static void method7(Object obj) {
+        obj = new @Permanent ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent ArrayList[]{};in method7");
+        }
+    }
+
+    /*
+    验证new ArrayList @Permanent []{};
+    */
+    static void method8(Object obj) {
+        obj = new ArrayList@Permanent[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList @Permanent []{};in method8");
+        }
+    }
+
+    /*
+    验证new ArrayList []{};
+    */
+    static void method9(Object obj) {
+        obj = new ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList []{}; method9");
+        }
+    }
+
+
+    static ArrayList<Object> noleak = new ArrayList<>();
+
+    public void run(
+    ) {
+        checkNum = 0;
+        Object obj = null;
+        method1(obj);
+        method2(obj);
+        method3(obj);
+        method4(obj);
+        method5(obj);
+        method6(obj);
+        method7(obj);
+        method8(obj);
+        method9(obj);
+        // System.out.println(checkNum);
+        if (checkNum == 9) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println("checkout== false,checkNum:"+checkNum);
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+class RCWeakTest extends Thread {
+    public void run() {
+        new Test_A().test();
+    }
+}
+
+class Test_A {
+    @Weak
+    Test_B bb;
+    Test_B bb2;
+
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");
+        }
+        bb2.run();
+    }
+
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+    }
+}
+
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\nExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2cfe702b8b682caaef6b63e0d752c019ef8f98db
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/jniTestHelper.cpp
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentThread3_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentThread3_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/RCPermanentTest8.java b/test/testsuite/ouroboros/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/RCPermanentTest8.java
new file mode 100755
index 0000000000000000000000000000000000000000..91b9ef99a6f36445d99713698b4c00ee054b6213
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/RCPermanentTest8.java
@@ -0,0 +1,87 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest8
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:在try/catch中添加Permanent annotation的字段，验证是否经过RC策略以及是否为堆内存
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 在try/catch中使用注解，验证是否经过RC策略以及是否为堆内存
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentTest8.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentTest8
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.Permanent;
+
+import java.lang.ref.WeakReference;
+
+public class RCPermanentTest8 {
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1(Object obj) {
+        try {
+            obj = new int@Permanent[8];
+            boolean result1 = checkRC(obj);
+            if (result1 == false && isHeapObject(obj) == false) {
+                checkNum++;
+            } else {
+                System.out.println("error in new int @Permanent [8];in method1");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    public static void main(String[] args) {
+
+        Object obj = null;
+        method1(obj);
+
+        if (checkNum == 1) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b56c4a1840d0e5e1541f7abf5c161dad77721031
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/jniTestHelper.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest8_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest8_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/RCPermanentThread4.java b/test/testsuite/ouroboros/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/RCPermanentThread4.java
new file mode 100755
index 0000000000000000000000000000000000000000..376eb1608bdc52378653643c3c6d84bc0e715398
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/RCPermanentThread4.java
@@ -0,0 +1,213 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentThread4
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:多线程下调用RC0429,以及在synchronized代码块中使用@Permanent，验证是否经过RC策略以及是否为堆内存
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 多线程下调用PermanentTest的caseRC0429,以及在synchronized代码块中使用@Permanent，验证是否经过RC策略以及是否为堆内存
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentThread4.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentThread4
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import com.huawei.ark.annotation.Permanent;
+
+
+public class RCPermanentThread4 {
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCPermanentTest rcPermanentTest = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest2 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest3 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest4 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest5 = new RCPermanentTest();
+
+        rcPermanentTest.start();
+        rcPermanentTest.join();
+
+        rcPermanentTest2.start();
+        rcPermanentTest2.join();
+
+        rcPermanentTest3.start();
+        rcPermanentTest3.join();
+
+        rcPermanentTest4.start();
+        rcPermanentTest4.join();
+
+        rcPermanentTest5.start();
+        rcPermanentTest5.join();
+
+        if (rcPermanentTest.check() && rcPermanentTest2.check() && rcPermanentTest3.check() && rcPermanentTest4.check() && rcPermanentTest5.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + rcPermanentTest.check());
+            System.out.println("rcPermanentTest2.check() :" + rcPermanentTest2.check());
+            System.out.println("rcPermanentTest3.check() :" + rcPermanentTest3.check());
+            System.out.println("rcPermanentTest4.check() :" + rcPermanentTest4.check());
+            System.out.println("rcPermanentTest5.check() :" + rcPermanentTest5.check());
+        }
+    }
+
+    private static void rc_testcase_main_wrapper2() throws InterruptedException {
+        SyncTest syncTest = new SyncTest();
+        SyncTest syncTest1 = new SyncTest();
+        SyncTest syncTest2 = new SyncTest();
+        SyncTest syncTest3 = new SyncTest();
+        SyncTest syncTest4 = new SyncTest();
+
+        syncTest.start();
+        syncTest.join();
+
+        syncTest1.start();
+        syncTest1.join();
+
+        syncTest2.start();
+        syncTest2.join();
+
+        syncTest3.start();
+        syncTest3.join();
+
+        syncTest4.start();
+        syncTest4.join();
+
+        if (syncTest.check() && syncTest1.check() && syncTest2.check() && syncTest3.check() && syncTest4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + syncTest.check());
+            System.out.println("rcPermanentTest2.check() :" + syncTest1.check());
+            System.out.println("rcPermanentTest3.check() :" + syncTest2.check());
+            System.out.println("rcPermanentTest4.check() :" + syncTest3.check());
+            System.out.println("rcPermanentTest5.check() :" + syncTest4.check());
+        }
+    }
+}
+
+
+class RCPermanentTest extends Thread {
+    public boolean checkout;
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证new int @Permanent [8]
+     */
+    static void method1(Object obj) {
+        try {
+            obj = new int@Permanent[8];
+            boolean result1 = checkRC(obj);
+            if (result1 == false && isHeapObject(obj) == false) {
+                checkNum++;
+            } else {
+                System.out.println("error in new int @Permanent [8];in method1");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    public void run() {
+        checkNum = 0;
+        Object obj = null;
+        method1(obj);
+        if (checkNum == 1) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkNum);
+        }
+    }
+
+    public boolean check() {
+        return checkout;
+    }
+}
+
+
+class SyncTest extends Thread {
+    public boolean checkout;
+
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    public void run() {
+        synchronized (this) {
+            Object obj = null;
+            obj = new int@Permanent[8];
+            boolean result1 = checkRC(obj);
+            if (result1 == false && isHeapObject(obj) == false) {
+                checkout = true;
+            } else {
+                checkout = false;
+                System.out.println("error in new int @Permanent [8];in method1");
+            }
+        }
+    }
+
+
+    public boolean check() {
+        return checkout;
+    }
+
+}
+// DEPENDENCE: jniTestHelper.cpp
+// EXEC:%maple  %f jniTestHelper.cpp %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e0fe46b017c93caa103afea3aa0e8e652d3cdac2
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/jniTestHelper.cpp
@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/RCPermanentLimit2.java b/test/testsuite/ouroboros/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/RCPermanentLimit2.java
new file mode 100755
index 0000000000000000000000000000000000000000..ad11c091a379c75d6f7a00d7d4b5902abd161db6
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/RCPermanentLimit2.java
@@ -0,0 +1,128 @@
+/*
+ *- @TestCaseID:maple/runtime/rc/annotation/Permanent/RCPermanentTest8
+ *- @TestCaseName:MyselfClassName
+ *- @RequirementName:[运行时需求]支持自动内存管理
+ *- @Title/Destination:添加Permanent annotation的对象，验证申请内存大于64k的情况是否正常，验证是否经过RC策略以及是否为堆内存
+ *- @Condition:
+ * -#c1:
+ *- @Brief:functionTest
+ * -#step1:
+ * 使用注解的对象申请内存大于64K，验证是否经过RC策略以及是否为堆内存
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: RCPermanentLimit2.java jniTestHelper.cpp
+ *- @ExecuteClass: RCPermanentLimit2
+ *- @ExecuteArgs:
+ *- @Remark:
+ *- @Author:liuweiqing l00481345
+ */
+
+import java.util.ArrayList;
+
+import com.huawei.ark.annotation.Permanent;
+
+
+public class RCPermanentLimit2 {
+    public static native boolean isHeapObject(Object obj);
+
+    public static native int refCount(Object obj);
+
+    public static int checkNum = 0;
+
+    static Object owner;
+
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+
+    /*
+    验证加了注解Permanent，申请的内存为64K+1byte的情况
+     */
+    static void method1(Object obj) {
+        try {
+            obj = new @Permanent ArrayList<Byte>();
+
+            for (int i = 0; i < 64 * 1024+1; i++) {
+                byte tmp = 2;
+                ((ArrayList) obj).add(tmp);
+            }
+//            int check_size = ((ArrayList) obj).size();
+//            System.out.println(check_size);
+            boolean result1 = checkRC(obj);
+            boolean result2 =isHeapObject(obj);
+            if (result1 == false && result2 == true) {
+                checkNum++;
+            } else {
+                System.out.println("result1:" + result1);
+                System.out.println("isHeapObject:" + result2);
+                System.out.println("error in new int test1;in method1");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /*
+    验证加了注解Permanent，申请的内存为128K的情况
+     */
+    static void method2(Object obj) {
+        try {
+            obj = new @Permanent ArrayList<Byte>();
+
+            for (int i = 0; i < 128 * 1024; i++) {
+                byte tmp = 2;
+                ((ArrayList) obj).add(tmp);
+            }
+//            int check_size = ((ArrayList) obj).size();
+//            System.out.println(check_size);
+            boolean result1 = checkRC(obj);
+            boolean result2 =isHeapObject(obj);
+            if (result1 == false && result2 == true) {
+                checkNum++;
+            } else {
+                System.out.println("result1:" + result1);
+                System.out.println("isHeapObject:" + result2);
+                System.out.println("error in new int test1;in method1");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) {
+
+        Object obj = null;
+        method1(obj);
+        Runtime.getRuntime().gc();
+        method1(obj);
+
+        method2(obj);
+        Runtime.getRuntime().gc();
+        method2(obj);
+        
+        if (checkNum == 4) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
diff --git a/test/testsuite/ouroboros/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/jniTestHelper.cpp b/test/testsuite/ouroboros/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..38b8ea6b916ecde5e414c577864746291199560b
--- /dev/null
+++ b/test/testsuite/ouroboros/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/jniTestHelper.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentLimit2_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentLimit2_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+} /* extern "C" */
diff --git a/test/testsuite/ouroboros/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/ReflectingGetConstructor1.java b/test/testsuite/ouroboros/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/ReflectingGetConstructor1.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bfb30be0c6ef1b87e1052475652101d9865f83b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/ReflectingGetConstructor1.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectingGetConstructor1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectingGetConstructor1.java
+ *- @Title/Destination: Getting public constructors of different arguments from reflection by calling
+ *                      Class.getConstructor()
+ *- @Brief:no:
+ * -#step1: 通过Class.forName获得GetConstructor1类的一个实例对象getConstructor1；
+ * -#step2: 分别调用GetConstructor1类的三个构造方法，从而实现从反射中获取不同参数的公共构造函数constructor1、constructor2、
+ *          constructor3；
+ * -#step3: 判断三个构造方法获取成功；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectingGetConstructor1.java
+ *- @ExecuteClass: ReflectingGetConstructor1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetConstructor1 {
+    public GetConstructor1() {
+    }
+
+    public GetConstructor1(String name) {
+    }
+
+    public GetConstructor1(String name, int number) {
+    }
+
+    GetConstructor1(int number) {
+    }
+}
+
+public class ReflectingGetConstructor1 {
+    public static void main(String[] args) {
+        try {
+            Class getConstructor1 = Class.forName("GetConstructor1");
+            Constructor constructor1 = getConstructor1.getConstructor(String.class);
+            Constructor constructor2 = getConstructor1.getConstructor();
+            Constructor constructor3 = getConstructor1.getConstructor(String.class, int.class);
+            if (constructor1.toString().equals("public GetConstructor1(java.lang.String)")
+                    && constructor2.toString().equals("public GetConstructor1()")
+                    && constructor3.toString().equals("public GetConstructor1(java.lang.String,int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/ReflectingGetConstructor2.java b/test/testsuite/ouroboros/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/ReflectingGetConstructor2.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3097f86b1b0be449cbc5dead16162f86e19329d
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/ReflectingGetConstructor2.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectingGetConstructor2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectingGetConstructor2.java
+ *- @Title/Destination: When the specified constructor could not be found by reflection, NoSuchMethodException is thrown
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获得GetConstructor2类的一个实例对象getConstructor21；
+ * -#step2: 以int.class为参数，尝试通过getConstructor()方法获取GetConstructor2类的构造函数并记为constructor1；
+ * -#step3: 通过Class.forName()方法获得GetConstructor2类的一个实例对象getConstructor22；
+ * -#step4: 以String.class, char.class, int.class为参数，尝试通过getConstructor()方法获取GetConstructor2类的构造函数并记
+ *          为constructor2；
+ * -#step5: 确定step2和step4中的构造函数constructor1、constructor2获取失败，并且会抛出NoSuchMethodException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectingGetConstructor2.java
+ *- @ExecuteClass: ReflectingGetConstructor2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetConstructor2 {
+    public GetConstructor2() {
+    }
+
+    public GetConstructor2(String name) {
+    }
+
+    public GetConstructor2(String name, int number) {
+    }
+
+    GetConstructor2(int number) {
+    }
+}
+
+public class ReflectingGetConstructor2 {
+    public static void main(String[] args) {
+        try {
+            Class getConstructor21 = Class.forName("GetConstructor2");
+            Constructor constructor1 = getConstructor21.getConstructor(int.class);
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e) {
+            try {
+                Class getConstructor22 = Class.forName("GetConstructor2");
+                Constructor constructor2 = getConstructor22.getConstructor(String.class, char.class, int.class);
+                System.out.println(2);
+            } catch (ClassNotFoundException ee) {
+                System.err.println(ee);
+                System.out.println(2);
+            } catch (NoSuchMethodException ee) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/ReflectingGetConstructors.java b/test/testsuite/ouroboros/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/ReflectingGetConstructors.java
new file mode 100644
index 0000000000000000000000000000000000000000..75bfb8d48714b7b7f105ffa251a6b89986ed9742
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/ReflectingGetConstructors.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectingGetConstructors
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectingGetConstructors.java
+ *- @Title/Destination: Call Class.GetConstructors() to get all the public constructors in a class by reflection
+ *- @Brief:no:
+ * -#step1: 通过反射的方法获得GetConstructors_a类的一个实例对象getConstructors_a；
+ * -#step2: 通过调用getConstructors_a的getConstructors()方法，获取到它的所有公共构造函数并记为constructors；
+ * -#step3: 确定step2中成功获取到getConstructors_a对象的所有公共构造函数constructors，并且其长度等于3，并且对于
+ *          constructors[i].toString()（此处i < constructors.length = 3）不包含字符串"GetConstructors_a(int)"；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectingGetConstructors.java
+ *- @ExecuteClass: ReflectingGetConstructors
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetConstructors {
+    public GetConstructors() {
+    }
+
+    public GetConstructors(String name) {
+    }
+
+    public GetConstructors(String name, int number) {
+    }
+
+    GetConstructors(int number) {
+    }
+
+    GetConstructors(double id) {
+    }
+
+    public GetConstructors(double id, String name) {
+    }
+}
+
+class GetConstructors_a extends GetConstructors {
+    public GetConstructors_a() {
+    }
+
+    public GetConstructors_a(String name) {
+    }
+
+    public GetConstructors_a(String name, int number) {
+    }
+
+    GetConstructors_a(int number) {
+    }
+}
+
+public class ReflectingGetConstructors {
+    public static void main(String[] args) {
+        try {
+            Class getConstructors_a = Class.forName("GetConstructors_a");
+            Constructor<?>[] constructors = getConstructors_a.getConstructors();
+            if (constructors.length == 3) {
+                for (int i = 0; i < constructors.length; i++) {
+                    if (constructors[i].toString().indexOf("GetConstructors_a(int)") != -1) {
+                        System.out.println(2);
+                    }
+                }
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (ArrayIndexOutOfBoundsException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java b/test/testsuite/ouroboros/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java
new file mode 100644
index 0000000000000000000000000000000000000000..a7448aac2bb27813160940b05992aea07c30e785
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectingGetDeclaredConstructor1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectingGetDeclaredConstructor1.java
+ *- @Title/Destination: Call Class.getDeclaredConstructor() to get the local constructor of a class by reflection
+ *- @Brief:no:
+ * -#step1: 通过反射的方法获得GetDeclaredConstructor1类的一个实例对象getDeclaredConstructor1；
+ * -#step2: 通过step1中获得的getDeclaredConstructor1分别调用GetDeclaredConstructor1类的三个构造方法，从而实现从反射中获
+ *          取不同参数的本地构造函数constructor1、constructor2、constructor3；
+ * -#step3: step2中所获取到的三个公共构造函数constructor1、constructor2、constructor3分别对应于
+ *          GetDeclaredConstructor1类的三个构造函数，表明本地构造函数获取成功；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectingGetDeclaredConstructor1.java
+ *- @ExecuteClass: ReflectingGetDeclaredConstructor1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetDeclaredConstructor1 {
+    public GetDeclaredConstructor1() {
+    }
+
+    private GetDeclaredConstructor1(String name) {
+    }
+
+    protected GetDeclaredConstructor1(String name, int number) {
+    }
+
+    GetDeclaredConstructor1(int number) {
+    }
+}
+
+public class ReflectingGetDeclaredConstructor1 {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructor1 = Class.forName("GetDeclaredConstructor1");
+            Constructor constructor1 = getDeclaredConstructor1.getDeclaredConstructor(String.class);
+            Constructor constructor2 = getDeclaredConstructor1.getDeclaredConstructor();
+            Constructor constructor3 = getDeclaredConstructor1.getDeclaredConstructor(String.class, int.class);
+            Constructor constructor4 = getDeclaredConstructor1.getDeclaredConstructor(int.class);
+            if (constructor1.toString().equals("private GetDeclaredConstructor1(java.lang.String)")
+                    && constructor2.toString().equals("public GetDeclaredConstructor1()")
+                    && constructor3.toString().equals("protected GetDeclaredConstructor1(java.lang.String,int)")
+                    && constructor4.toString().equals("GetDeclaredConstructor1(int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java b/test/testsuite/ouroboros/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e46284e864bd8895714537f09715193307eb425
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectingGetDeclaredConstructor2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectingGetDeclaredConstructor2.java
+ *- @Title/Destination: When the specified local constructor for the class can not be retrieved by reflection using
+ *                      Class.getDeclaredConstructors(), NoSuchMethodException will be thrown
+ *- @Brief:no:
+ * -#step1: 通过反射的方法获得GetDeclaredConstructor2类的一个实例对象getDeclaredConstructor2；
+ * -#step2: 尝试通过step1中的getDeclaredConstructor2对象调用GetDeclaredConstructor2类的不存在的本地构造函数；
+ * -#step3: step2中获取getDeclaredConstructor2对象的不存在的本地构造函数不成功，会抛出NoSuchMethodException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectingGetDeclaredConstructor2.java
+ *- @ExecuteClass: ReflectingGetDeclaredConstructor2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetDeclaredConstructor2 {
+    public GetDeclaredConstructor2() {
+    }
+
+    private GetDeclaredConstructor2(String name) {
+    }
+
+    protected GetDeclaredConstructor2(String name, int number) {
+    }
+
+    GetDeclaredConstructor2(int number) {
+    }
+}
+
+public class ReflectingGetDeclaredConstructor2 {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructor2 = Class.forName("GetDeclaredConstructor2");
+            Constructor constructor = getDeclaredConstructor2.getDeclaredConstructor(String.class, char.class, int.class);
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java b/test/testsuite/ouroboros/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java
new file mode 100644
index 0000000000000000000000000000000000000000..564f87988c2d3a4d306ab24b33caf774ed746926
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectingGetDeclaredConstructors
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectingGetDeclaredConstructors.java
+ *- @Title/Destination: Call Class.getDeclaredConstructors() to get all the local constructors of a class by reflection
+ *- @Brief:no:
+ * -#step1: 通过反射的方法获得GetDeclaredConstructors类的一个实例对象getDeclaredConstructors；
+ * -#step2: 通过调用getDeclaredConstructors的GetDeclaredConstructors()方法，获取到它的所有本地构造函数并记为constructors；
+ * -#step3: 确定step2中获取getDeclaredConstructors对象的所有本地构造函数constructors成功，并且其长度为4；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectingGetDeclaredConstructors.java
+ *- @ExecuteClass: ReflectingGetDeclaredConstructors
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+
+class GetDeclaredConstructors {
+    public GetDeclaredConstructors() {
+    }
+
+    private GetDeclaredConstructors(String name) {
+    }
+
+    protected GetDeclaredConstructors(String name, int number) {
+    }
+
+    GetDeclaredConstructors(int number) {
+    }
+}
+
+public class ReflectingGetDeclaredConstructors {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructors = Class.forName("GetDeclaredConstructors");
+            Constructor<?>[] constructors = getDeclaredConstructors.getDeclaredConstructors();
+            if (constructors.length == 4) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/ReflectionAsSubclass1.java b/test/testsuite/ouroboros/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/ReflectionAsSubclass1.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2ca556de299ac15ebbd904842c38ec5e02b0a4d
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/ReflectionAsSubclass1.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionAsSubclass1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionAsSubclass1.java
+ *- @Title/Destination: child class calls Class.asSubclass() on father class/interface. Get the instance of the subclass
+ *                      that casts the class to the target class by reflection gets the target
+ *- @Brief:no:
+ * -#step1: 通过反射获取A_1类的运行时类，并对其返回值以A.class为参数调用asSubclass()方法，获得a_2；同理，通过反射获取
+ *          A_2类的运行时类，并对其返回值以A.class为参数调用asSubclass()方法，获得a_1；
+ * -#step2: 经判断得知a_2.newInstance()是A的一个实例，a_1.newInstance()也是A的一个实例；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionAsSubclass1.java
+ *- @ExecuteClass: ReflectionAsSubclass1
+ *- @ExecuteArgs:
+ */
+
+interface A {
+}
+
+class A_1 implements A {
+}
+
+class A_2 extends A_1 {
+}
+
+public class ReflectionAsSubclass1 {
+    public static void main(String[] args) {
+        try {
+            Class a_2 = Class.forName("A_1").asSubclass(A.class);
+            Class a_1 = Class.forName("A_2").asSubclass(A.class);
+            if (a_2.newInstance() instanceof A) {
+                if (a_1.newInstance() instanceof A) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(e1);
+        } catch (InstantiationException e2) {
+            System.out.println(e2);
+        } catch (IllegalAccessException e3) {
+            System.out.println(e3);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/ReflectionAsSubclass2.java b/test/testsuite/ouroboros/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/ReflectionAsSubclass2.java
new file mode 100644
index 0000000000000000000000000000000000000000..97c72364e1194c7e50e970c143cb9cfdd53197c1
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/ReflectionAsSubclass2.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionAsSubclass2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionAsSubclass2.java
+ *- @Title/Destination: To cast a subclass of another class by reflection get a class
+ *- @Brief:no:
+ * -#step1: 通过Class.forName("B_1")，再对其返回值调用asSubclass()方法可以获得B类的子类B_1类；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionAsSubclass2.java
+ *- @ExecuteClass: ReflectionAsSubclass2
+ *- @ExecuteArgs:
+ */
+
+class B {
+}
+
+class B_1 extends B {
+}
+
+public class ReflectionAsSubclass2 {
+    public static void main(String[] args) {
+        try {
+            Class.forName("B_1").asSubclass(B.class);
+        } catch (ClassCastException e) {
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/ReflectionAsSubclass3.java b/test/testsuite/ouroboros/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/ReflectionAsSubclass3.java
new file mode 100644
index 0000000000000000000000000000000000000000..c224fd0568c1b8945370d54efe91858427c017fb
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/ReflectionAsSubclass3.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionAsSubclass3
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionAsSubclass3.java
+ *- @Title/Destination: class A calls Class.asSubclass on class B, if A is not a subclass of B, throws ClassCastException
+ *- @Brief:no:
+ * -#step1: 通过反射C_1类，并对其返回值以D.class为参数调用asSubclass()方法；
+ * -#step2: 同理，通过反射C_2类，并对其返回值以D.class为参数调用asSubclass()方法；
+ * -#step3: 通过反射D_1类，并对其返回值以C.class为参数调用asSubclass()方法；
+ * -#step4: step1、step2、step3中方法均调用失败，即无法获取到对应类的子类，会抛出ClassCastException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionAsSubclass3.java
+ *- @ExecuteClass: ReflectionAsSubclass3
+ *- @ExecuteArgs:
+ */
+
+interface C {
+}
+
+class C_1 implements C {
+}
+
+class C_2 extends C_1 {
+}
+
+class D {
+}
+
+class D_1 extends D {
+}
+
+public class ReflectionAsSubclass3 {
+    public static void main(String[] args) {
+        try {
+            Class.forName("C_1").asSubclass(D.class);
+        } catch (ClassCastException e1) {
+            try {
+                Class.forName("C_2").asSubclass(D.class);
+            } catch (ClassCastException e2) {
+                try {
+                    Class.forName("D_1").asSubclass(C.class);
+                } catch (ClassCastException e3) {
+                    System.out.println(0);
+                } catch (ClassNotFoundException e4) {
+                    System.out.println(2);
+                }
+            } catch (ClassNotFoundException e5) {
+                System.out.println(2);
+            }
+        } catch (ClassNotFoundException e6) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0010-rt-reflection-Reflectioncast1/ReflectionCast1.java b/test/testsuite/ouroboros/reflection_test/RT0010-rt-reflection-Reflectioncast1/ReflectionCast1.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2f2c47bcb05e972cc1aff18aa10886548fad63b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0010-rt-reflection-Reflectioncast1/ReflectionCast1.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionCast1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionCast1.java
+ *- @Title/Destination: Casts an object to the class or interface represented by this Class object
+ *- @Brief:no:
+ * -#step1: 创建一个Cast1_a类的实例对象cast1_a，创建一个Cast1类的实例对象cast1；
+ * -#step2: 将step1中的Cast1类的实例对象cast1强制转换为Cast1_a类型；
+ * -#step3: 经转换后的cast1对象和Cast1_a类是同一类型；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionCast1.java
+ *- @ExecuteClass: ReflectionCast1
+ *- @ExecuteArgs:
+ */
+
+class Cast1 {
+}
+
+class Cast1_a extends Cast1 {
+}
+
+public class ReflectionCast1 {
+    public static void main(String[] args) {
+        Cast1_a cast1_a = new Cast1_a();
+        Cast1 cast1 = new Cast1();
+        cast1 = Cast1.class.cast(cast1_a);
+        if (cast1.getClass().toString().equals("class Cast1_a")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0011-rt-reflection-Reflectioncast2/ReflectionCast2.java b/test/testsuite/ouroboros/reflection_test/RT0011-rt-reflection-Reflectioncast2/ReflectionCast2.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1708d8334801229e7f87da0042edb3852159caa
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0011-rt-reflection-Reflectioncast2/ReflectionCast2.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionCast2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionCast2.java
+ *- @Title/Destination: An exception is reported when the parent object cannot be cast to the class represented by this
+ *                      class object
+ *- @Brief:no:
+ * -#step1: 创建一个Cast2类的实例对象cast2,创建一个Cast2类的子类Cast2_a类的实例对象cast2_a；
+ * -#step2: 将Cast2_a类的对象cast2_a强制转换为父类Cast2类型；
+ * -#step3: step2中的转换不能转换成功，会发生ClassCastException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionCast2.java
+ *- @ExecuteClass: ReflectionCast2
+ *- @ExecuteArgs:
+ */
+
+class Cast2 {
+}
+
+class Cast2_a extends Cast2 {
+}
+
+public class ReflectionCast2 {
+    public static void main(String[] args) {
+        Cast2_a cast2_a = new Cast2_a();
+        Cast2 cast2 = new Cast2();
+        try {
+            cast2_a = Cast2_a.class.cast(cast2);
+        } catch (ClassCastException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0012-rt-reflection-Reflectioncast3/ReflectionCast3.java b/test/testsuite/ouroboros/reflection_test/RT0012-rt-reflection-Reflectioncast3/ReflectionCast3.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c6e8cd7b0cfea5717485aaf49501ec14a2c85ea
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0012-rt-reflection-Reflectioncast3/ReflectionCast3.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionCast3
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionCast3.java
+ *- @Title/Destination: An exception is reported when a relationship-free object cannot be cast to a class represented
+ *                      by this class object
+ *- @Brief:no:
+ * -#step1: 创建一个Cast3_a类的实例对象cast3_a，创建一个Cast3类的实例对象cast3；
+ * -#step2: 将Cast3_a类的对象cast3_a强制转换为Cast3类型；
+ * -#step3: step2中的转换不能转换成功，会发生ClassCastException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionCast3.java
+ *- @ExecuteClass: ReflectionCast3
+ *- @ExecuteArgs:
+ */
+
+class Cast3 {
+}
+
+class Cast3_a {
+}
+
+public class ReflectionCast3 {
+    public static void main(String[] args) {
+        Cast3_a cast3_a = new Cast3_a();
+        Cast3 cast3 = new Cast3();
+        try {
+            cast3_a = Cast3_a.class.cast(cast3);
+        } catch (ClassCastException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0013-rt-reflection-Reflectioncast4/ReflectionCast4.java b/test/testsuite/ouroboros/reflection_test/RT0013-rt-reflection-Reflectioncast4/ReflectionCast4.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b4e43f494692b8893895002a1fe3a09687b7631
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0013-rt-reflection-Reflectioncast4/ReflectionCast4.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionCast4
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionCast4.java
+ *- @Title/Destination: Object cast to NULL
+ *- @Brief:no:
+ * -#step1: 创建一个Cast4类的实例对象cast4，创建一个Object类的变量object，并赋初值为null；
+ * -#step2: 将Cast4类的实例对象cast4强制转换为null；
+ * -#step3: step2中成功将cast4对象转换为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionCast4.java
+ *- @ExecuteClass: ReflectionCast4
+ *- @ExecuteArgs:
+ */
+
+class Cast4 {
+}
+
+public class ReflectionCast4 {
+    public static void main(String[] args) {
+        Object object = null;
+        Cast4 cast4 = new Cast4();
+        cast4 = Cast4.class.cast(object);
+        if (cast4 == null) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java b/test/testsuite/ouroboros/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab993922ddcdc477cc30482ac57d1d83712cb711
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionDesiredAssertionStatus
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionDesiredAssertionStatus.java
+ *- @Title/Destination: When a class's assertionStatus is not set, desiredAssertionStatus() return false
+ *- @Brief:no:
+ * -#step1: 创建一个ReflectionDesiredAssertionStatus类的实例对象reflectionDesiredAssertionStatus；
+ * -#step2: 通过reflectionDesiredAssertionStatus的getClass()方法获取其所属的类型并记为clazz；
+ * -#step3: 调用clazz的desiredAssertionStatus()方法得到的返回值为false；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionDesiredAssertionStatus.java
+ *- @ExecuteClass: ReflectionDesiredAssertionStatus
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionDesiredAssertionStatus {
+    public static void main(String[] args) {
+        ReflectionDesiredAssertionStatus reflectionDesiredAssertionStatus = new ReflectionDesiredAssertionStatus();
+        Class clazz = reflectionDesiredAssertionStatus.getClass();
+        if (!clazz.desiredAssertionStatus()) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0015-rt-reflection-ReflectionforName1/ReflectionForName1.java b/test/testsuite/ouroboros/reflection_test/RT0015-rt-reflection-ReflectionforName1/ReflectionForName1.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5699a985426c411228aacdff4fd0cc63a5c0156
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0015-rt-reflection-ReflectionforName1/ReflectionForName1.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionForName1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionForName1.java
+ *- @Title/Destination: Use Class.forName() To find a class by class name
+ *- @Brief:no:
+ * -#step1: 通过Class.forName的方法获取ForName1类的类型clazz；
+ * -#step2: 确定step1中的clazz与ForName1类是同一类型；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionForName1.java
+ *- @ExecuteClass: ReflectionForName1
+ *- @ExecuteArgs:
+ */
+
+class ForName1 {
+}
+
+public class ReflectionForName1 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        Class clazz = Class.forName("ForName1");
+        if (clazz.toString().equals("class ForName1")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0016-rt-reflection-ReflectionforName4/ReflectionForName4.java b/test/testsuite/ouroboros/reflection_test/RT0016-rt-reflection-ReflectionforName4/ReflectionForName4.java
new file mode 100644
index 0000000000000000000000000000000000000000..67366b3995c936457be11f02171f42c699007ede
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0016-rt-reflection-ReflectionforName4/ReflectionForName4.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionForName4
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionForName4.java
+ *- @Title/Destination: An exception is reported when a class is not found with reflection through a class name
+ *- @Brief:no:
+ * -#step1: 以“for*”、true、ForName4_a.class.getClassLoader()为参数，通过Class.forName()获取相关类的运行时类时会
+ *          抛出ClassNotFoundException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionForName4.java
+ *- @ExecuteClass: ReflectionForName4
+ *- @ExecuteArgs:
+ */
+
+class ForName4 {
+    static {
+    }
+}
+
+class ForName4_a {
+    static {
+    }
+}
+
+public class ReflectionForName4 extends Thread {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("for*", true, ForName4_a.class.getClassLoader());
+        } catch (ClassNotFoundException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0017-rt-reflection-ReflectionforName5/ReflectionForName5.java b/test/testsuite/ouroboros/reflection_test/RT0017-rt-reflection-ReflectionforName5/ReflectionForName5.java
new file mode 100644
index 0000000000000000000000000000000000000000..d83ab87af313af1da5472aed1c71349c7dbb1b99
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0017-rt-reflection-ReflectionforName5/ReflectionForName5.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionForName5
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionForName5.java
+ *- @Title/Destination: Use Class.forName() to get a multilevel inherited class by reflection
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取ForName5类的类型clazz，且clazz和ForName5类是同一类型；
+ * -#step2: 通过Class.forName()方法获取ForName55类的类型clazz2，且clazz2和ForName55类是同一类型；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionForName5.java
+ *- @ExecuteClass: ReflectionForName5
+ *- @ExecuteArgs:
+ */
+
+interface ForName55_c {
+}
+
+class ForName55_b implements ForName55_c {
+}
+
+class ForName55_a extends ForName55_b {
+}
+
+class ForName55 extends ForName55_a {
+}
+
+class ForName5_e {
+}
+
+class ForName5_d extends ForName5_e {
+}
+
+class ForName5_c extends ForName5_d {
+}
+
+class ForName5_b extends ForName5_c {
+}
+
+class ForName5_a extends ForName5_b {
+}
+
+class ForName5 extends ForName5_a {
+}
+
+public class ReflectionForName5 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        Class clazz = Class.forName("ForName5");
+        if (clazz.toString().equals("class ForName5")) {
+            Class clazz2 = Class.forName("ForName55");
+            if (clazz2.toString().equals("class ForName55")) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java b/test/testsuite/ouroboros/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java
new file mode 100644
index 0000000000000000000000000000000000000000..7208dd20f7b3153376995a4e1d74f632fbc420d1
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetAnnotation3
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetAnnotation3.java
+ *- @Title/Destination: Call Class.getAnnotation in functions of target class to get annotation by reflection, if the
+ *                      function does not have the expected annotation, throws exception.
+ *- @Brief:no:
+ *  -#step1: 定义含注解的内部类GetAnnotation3_a。
+ *  -#step2：通过调用getField()从内部类GetAnnotation3_a中获取成员。
+ *  -#step3：调用getAnnotation(Class<T> annotationClass)获取GetAnnotation3_a的注解并抛出NullPointerException。
+ *  -#step4：定义不含注解的类GetAnnotation3_b，通过getAnnotation()方法获取成员方法，并抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetAnnotation3.java
+ *- @ExecuteClass: ReflectionGetAnnotation3
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz3 {
+    int i() default 0;
+    String t() default "";
+}
+
+class GetAnnotation3_a {
+    @Zzz3(i = 333, t = "getAnnotation")
+    public void qqq() {
+    };
+
+    public void rrr() {
+    };
+}
+
+class GetAnnotation3_b {
+    public void www() {
+    };
+}
+
+public class ReflectionGetAnnotation3 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation3_a");
+            Method zhu1 = zqp1.getMethod("qqq");
+            Method zhu2 = zqp1.getMethod("rrr");
+            zhu1.getAnnotation(Zzz3.class).t();
+            zhu2.getAnnotation(Zzz3.class).i();
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+
+            try {
+                Class zqp2 = Class.forName("GetAnnotation3_b");
+                Method zhu3 = zqp2.getMethod("www");
+                zhu3.getAnnotation(Zzz3.class).i();
+                System.out.println(2);
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                System.out.println(2);
+            } catch (NoSuchMethodException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+            }
+        }
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java b/test/testsuite/ouroboros/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java
new file mode 100644
index 0000000000000000000000000000000000000000..27945cb2971ef96c6483061a23be77a4fb14be6c
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetAnnotation4
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetAnnotation4.java
+ *- @Title/Destination: Call Class.getAnnotation in functions of target class to get annotation by reflection, if the
+ *                      function does not have the expected annotation, throws exception.
+ *- @Brief:no:
+ *  -#step1: 定义含注解的内部类GetAnnotation4_a。
+ *  -#step2：通过调用getMethod()从内部类GetAnnotation4_a中获取成员方法。
+ *  -#step3：调用getAnnotation(Class<T> annotationClass)获取GetAnnotation4_a成员方法的注解并抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetAnnotation4.java
+ *- @ExecuteClass: ReflectionGetAnnotation4
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz4 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@interface Zzz4_a {
+    int ii() default 0;
+
+    String tt() default "";
+}
+
+class GetAnnotation4_a {
+    @Zzz4(i = 333, t = "getAnnotation")
+    public void qqq() {
+    };
+
+    @Zzz4_a(ii = 555, tt = "test")
+    public void rrr() {
+    };
+}
+
+public class ReflectionGetAnnotation4 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation4_a");
+            Method zhu1 = zqp1.getMethod("qqq");
+            Method zhu2 = zqp1.getMethod("rrr");
+            if (zhu1.getAnnotation(Zzz4_a.class) == null && zhu2.getAnnotation(Zzz4.class) == null) {
+                zhu1.getAnnotation(Zzz4_a.class).ii();
+                System.out.println(2);
+            }
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java b/test/testsuite/ouroboros/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java
new file mode 100644
index 0000000000000000000000000000000000000000..9bf1e32411e6c93528823305e2da86fe7d8ab73c
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetAnnotationsByType2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetAnnotationsByType2.java
+ *- @Title/Destination: Retrieving an empty annotation of a field in a target class by reflection reports an exception.
+ *                      Class.GetAnnotationsByType(null) throws NullPointerException.
+ *- @Brief:no:
+ *  -#step1: 创建含注解的类GetAnnotationsByType2_a，不含注解的类GetAnnotationsByType2_b。
+ *  -#step2: 通过forName()获取GetAnnotationsByType2_a的类名对象，通过getField()获取GetAnnotationsByType2_a内对应名称的成员。
+ *  -#step3: 调用getAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的数组并抛出NullPointerException。
+ *  -#step4：通过forName()获取GetAnnotationsByType2_b的类名对象，通过getField()获取GetAnnotationsByType2_b内对应名称的成员。
+ *  -#step5：调用getAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的数组并抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetAnnotationsByType2.java
+ *- @ExecuteClass: ReflectionGetAnnotationsByType2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz2 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+class GetAnnotationsByType2_a {
+    @Zzzz2(i = 333, t = "GetAnnotationsByType")
+    public int i_a;
+    public String t_a;
+}
+
+class GetAnnotationsByType2_b {
+    public int i_b;
+    public String t_b;
+}
+
+public class ReflectionGetAnnotationsByType2 {
+
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType2_a");
+            Field zhu1 = zqp1.getField("t_a");
+            Annotation[] j = zhu1.getAnnotationsByType(null);
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+
+            try {
+                Class zqp2 = Class.forName("GetAnnotationsByType2_b");
+                Field zhu2 = zqp2.getField("i_b");
+                Annotation[] k = zhu2.getAnnotationsByType(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                System.out.println(2);
+            } catch (NoSuchFieldException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java b/test/testsuite/ouroboros/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java
new file mode 100644
index 0000000000000000000000000000000000000000..21ef48d59731c8b4bc5aaf312fb8fd4f7e439aa9
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetCanonicalName
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetCanonicalName.java
+ *- @Title/Destination: Class.getCanonicalName() returns class name by reflection.
+ *- @Brief:no:
+ * -#step1: Define an empty class.
+ * -#step2: Get Class instance by calling ForName(String className)
+ * -#step3: Test getCanonicalName() returns class name correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetCanonicalName.java
+ *- @ExecuteClass: ReflectionGetCanonicalName
+ *- @ExecuteArgs:
+ */
+
+class GetCanonicalNameTest {
+}
+
+public class ReflectionGetCanonicalName {
+
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+
+        try {
+            Class zqp = Class.forName("GetCanonicalNameTest");
+            if (zqp.getCanonicalName().equals("GetCanonicalNameTest")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/ReflectionGetComponentType.java b/test/testsuite/ouroboros/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/ReflectionGetComponentType.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd06d0052acd8c1b901b06d71f67c714615e0461
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/ReflectionGetComponentType.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetComponentType
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetComponentType.java
+ *- @Title/Destination: Class.getComponentType() returns the Class representing the component type of an array. If
+ *                      this class does not represent an array class ,then this method returns null.
+ *- @Brief:no:
+ * -#step1: Test Class.getComponentType() when char,string[] and int[] call it.
+ * -#step2: Check Class.getComponentType() returns right component type when an array calls it.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetComponentType.java
+ *- @ExecuteClass: ReflectionGetComponentType
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionGetComponentType {
+
+    public static void main(String[] args) {
+        if (char.class.getComponentType() == null && String[].class.getComponentType().toString().
+                equals("class java.lang.String") && int[].class.getComponentType().toString().equals("int")) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java b/test/testsuite/ouroboros/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2960951302401d1f0680a50fabaa45bd2d90666
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredAnnotations1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredAnnotations1.java
+ *- @Title/Destination: Class.GetDeclaredAnnotations() retrieve all annotations from the target class by reflection,
+ *                      and result an array of annotations.
+ *- @Brief:no:
+ * -#step1: Define two annotations.
+ * -#step2: Use classloader to load class.R
+ * -#step3: Return an array of annotations by calling GetDeclaredAnnotations().
+ * -#step4: Check that Class.GetDeclaredAnnotations() retrieves all annotations.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredAnnotations1.java
+ *- @ExecuteClass: ReflectionGetDeclaredAnnotations1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd1 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd1_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Ddd1(i = 333, t = "test1")
+class GetDeclaredAnnotations1 {
+    public int i;
+    public String t;
+}
+
+@Ddd1_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotations1_a extends GetDeclaredAnnotations1 {
+    public int i_a;
+    public String t_a;
+}
+
+public class ReflectionGetDeclaredAnnotations1 {
+
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotations1_a");
+            if (zqp1.getDeclaredAnnotations().length == 1) {
+                Annotation[] j = zqp1.getDeclaredAnnotations();
+                if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                    result = 0;
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java
new file mode 100644
index 0000000000000000000000000000000000000000..fabe60f027f2c48051dc2e2d2855d9ecd8406cdf
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredAnnotations2.java
+ *- @Title/Destination: Class.GetDeclaredAnnotations() does not result annotations that inherited from parent class.
+ *- @Brief:no:
+ * -#step1: Define two annotation.
+ * -#step2：Use classloader to load class.
+ * -#step3：Return an array of annotations by calling GetDeclaredAnnotations().
+ * -#step4: Check that Class.GetDeclaredAnnotations() retrieves all annotations but annotations those inherited from
+ *          parent class.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredAnnotations2.java
+ *- @ExecuteClass: ReflectionGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd2 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd2_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Ddd2(i = 333, t = "test1")
+class GetDeclaredAnnotations2 {
+    public int i;
+    public String t;
+}
+
+@Ddd2_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotations2_a extends GetDeclaredAnnotations2 {
+    public int i_a;
+    public String t_a;
+}
+
+class GetDeclaredAnnotations2_b extends GetDeclaredAnnotations2_a {
+}
+
+public class ReflectionGetDeclaredAnnotations2 {
+
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotations2_b");
+            if (zqp1.getDeclaredAnnotations().length == 0) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java b/test/testsuite/ouroboros/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..999d99b70875e60c4a03895adfab61bb4a5a78d8
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredAnnotationsByTypeNullPointerException
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
+ *- @Title/Destination: Class.GetDeclaredAnnotationsByType(null) throws NullPointerException.
+ *- @Brief:no:
+ * -#step1: Define two annotation.
+ * -#step2: Use classloader to load class.
+ * -#step3: Test Class.GetDeclaredAnnotationsByType() with null parameter.
+ * -#step4: Check that NullPointerException was threw.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
+ *- @ExecuteClass: ReflectionGetDeclaredAnnotationsByTypeNullPointerException
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd2 {
+    int i() default 0;
+
+    String t() default "";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd2_a {
+    int i_a() default 2;
+
+    String t_a() default "";
+}
+
+@Dddd2(i = 333, t = "test1")
+class GetDeclaredAnnotationsByType2 {
+    public int i;
+    public String t;
+}
+
+@Dddd2_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotationsByType2_a extends GetDeclaredAnnotationsByType2 {
+    public int i_a;
+    public String t_a;
+}
+
+class GetDeclaredAnnotationsByType2_b extends GetDeclaredAnnotationsByType2_a {
+}
+
+public class ReflectionGetDeclaredAnnotationsByTypeNullPointerException {
+
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotationsByType2_b");
+            Annotation[] j = zqp1.getDeclaredAnnotationsByType(null);
+            result = 0;
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java b/test/testsuite/ouroboros/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java
new file mode 100644
index 0000000000000000000000000000000000000000..9690dc4ddb757f067ea4a4f9fec1cd4c47ae03ba
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredClasses
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredClasses.java
+ *- @Title/Destination: Class.getDeclaredClasses() result an array of class objects that represent all declared members
+ *                      of this class,includes public, protected, default (package) access, and private classes and
+ *                      interfaces,excludes inherited classes and interfaces
+ *- @Brief:no:
+ * -#step1: Create a class include inner class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Return an array of class objects by calling Class.getDeclaredClasses().
+ * -#step4: Check that the array of class objects exclude inherited classes and interfaces.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredClasses.java
+ *- @ExecuteClass: ReflectionGetDeclaredClasses
+ *- @ExecuteArgs:
+ */
+
+class ReflectiongetDeclaredClasses_a {
+    public class getDeclaredClasses_a1 {
+    }
+
+    private class getDeclaredClasses_a2 {
+    }
+
+    protected class getDeclaredClasses_a3 {
+    }
+}
+
+public class ReflectionGetDeclaredClasses extends ReflectiongetDeclaredClasses_a {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("ReflectionGetDeclaredClasses");
+            Class<?>[] j = zqp.getDeclaredClasses();
+            if (j.length == 3) {
+                for (int i = 0; i < j.length; i++) {
+                    if (j[i].getName().indexOf("getDeclaredClasses_a") != -1) {
+                        result = -1;
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+
+    public class getDeclaredClassestest1 {
+    }
+
+    private class getDeclaredClassestest2 {
+    }
+
+    protected class getDeclaredClassestest3 {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java b/test/testsuite/ouroboros/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java
new file mode 100644
index 0000000000000000000000000000000000000000..25551bd3192626642f50dd57e487908107ddd401
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredField1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredField1.java
+ *- @Title/Destination: Class.GetDeclaredField() Returns a Field object that reflects the specified declared field of
+ *                      the class or interface represented by this Class object.
+ *- @Brief:no:
+ * -#step1: Create a test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Check that return field objects are correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredField1.java
+ *- @ExecuteClass: ReflectionGetDeclaredField1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetDeclaredField1 {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+
+public class ReflectionGetDeclaredField1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("GetDeclaredField1");
+            Field zhu1 = zqp.getDeclaredField("i");
+            Field zhu2 = zqp.getDeclaredField("s");
+            Field zhu3 = zqp.getDeclaredField("d");
+            Field zhu4 = zqp.getDeclaredField("f");
+            if (zhu1.getName().equals("i") && zhu2.getName().equals("s") && zhu3.getName().equals("d") &&
+                    zhu4.getName().equals("f")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            result = -1;
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java b/test/testsuite/ouroboros/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..42859a055c71538740d4476c3b33b947758df863
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredFieldNullPointerException.
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredFieldNullPointerException.java
+ *- @Title/Destination: Class.GetDeclaredField(null) throws NullPointerException.
+ *- @Brief:no:
+ * -#step1: Create two test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Test Class.GetDeclaredField() with null parameter.
+ * -#step4: Check that NullPointerException was threw.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredFieldNullPointerException.java
+ *- @ExecuteClass: ReflectionGetDeclaredFieldNullPointerException
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetDeclaredField2_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+
+class GetDeclaredField2 extends GetDeclaredField2_a {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+
+public class ReflectionGetDeclaredFieldNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("GetDeclaredField2");
+            Field zhu1 = zqp.getDeclaredField("i_a");
+            result = -1;
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        } catch (NoSuchFieldException e3) {
+            try {
+                Class zqp = Class.forName("GetDeclaredField2");
+                Field zhu1 = zqp.getDeclaredField(null);
+                result = -1;
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                result = -1;
+            } catch (NoSuchFieldException e5) {
+                System.err.println(e5);
+                result = -1;
+            } catch (NullPointerException e6) {
+                result = 0;
+            }
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java b/test/testsuite/ouroboros/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f5355749ae54c7574476d0b559258590e4ec54a
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredFields1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredFields1.java
+ *- @Title/Destination: Class.GetDeclaredFields() returns an array of Field objects reflecting all the fields declared
+ *                      by the class or interface represented by this Class object. This includes public, protected,
+ *                      default (package) access, and private fields, but excludes inherited fields.
+ *- @Brief:no:
+ * -#step1: Create test classes and interface.
+ * -#step2: Use classloader to load class.
+ * -#step3: Check that return Field objects array correctly by calling GetDeclaredFields().
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredFields1.java
+ *- @ExecuteClass: ReflectionGetDeclaredFields1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetDeclaredFields1_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+
+class GetDeclaredFields1 extends GetDeclaredFields1_a {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+
+interface GetDeclaredFields1_b {
+    public int i_b = 2;
+    String s_b = "ccc";
+}
+
+public class ReflectionGetDeclaredFields1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("GetDeclaredFields1");
+            Class zqp2 = Class.forName("GetDeclaredFields1_b");
+            Field[] j = zqp1.getDeclaredFields();
+            Field[] k = zqp2.getDeclaredFields();
+            if (j.length == 4 && k.length == 2) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java b/test/testsuite/ouroboros/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java
new file mode 100644
index 0000000000000000000000000000000000000000..3973eafa7286383d463e2d174228a7471494deb7
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredFields
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredFields.java
+ *- @Title/Destination: Class.getDeclaredFields() returns an array of Field objects reflecting all the fields declared
+ *                      by the class or interface represented by this Class object. This includes public, protected,
+ *                      default (package) access, and private fields, but excludes inherited fields.
+ *- @Brief:no:
+ * -#step1: Create test classes and enum.
+ * -#step2: Use classloader to load class.
+ * -#step3: Check that return Field objects array  which exclude inherited fields which  by calling GetDeclaredFields().
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredFields.java
+ *- @ExecuteClass: ReflectionGetDeclaredFields
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetDeclaredFields_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+
+class GetDeclaredFields extends GetDeclaredFields_a {
+}
+
+enum GetDeclaredFields_b {
+    i_b, s_b, f_b
+}
+
+public class ReflectionGetDeclaredFields {
+    public static void main(String[] args) {
+        int result = 0;
+        try {
+            Class zqp1 = Class.forName("GetDeclaredFields");
+            Class zqp2 = Class.forName("GetDeclaredFields_b");
+            Field[] j = zqp1.getDeclaredFields();
+            Field[] k = zqp2.getDeclaredFields();
+            if (j.length == 0 && k.length == 4) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java b/test/testsuite/ouroboros/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java
new file mode 100644
index 0000000000000000000000000000000000000000..19e2314577fe71830286286969b5dbd6a461b029
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredMethod1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredMethod1.java
+ *- @Title/Destination: Class.getDeclaredMethod() Returns a Method object that reflects the specified declared method
+ *                      of the class or interface represented by this Class object.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获得GetDeclaredMethod1类的运行时类clazz；
+ * -#step2: 分别以（"empty1", int.class）、"getDd"、"empty1"、"empty2"、"getZero"和（"getZero", String.class）为参数，通过
+ *          clazz的getDeclaredMethod()方法，获取Method类的不同的方法对象method1、method2、method3、method4、method5、method6；
+ * -#step3: 确定step2中的方法对象method1、method2、method3、method4、method5、method6获取成功，并且分别是
+ *          GetDeclaredMethod1类的指定的声明方法。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredMethod1.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethod1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetDeclaredMethod1 {
+    public void empty1() {
+    }
+
+    void empty2() {
+    }
+
+    int getZero() {
+        return 0;
+    }
+
+    private String getDd() {
+        return "dd";
+    }
+
+    public void empty1(int number) {
+    }
+
+    int getZero(String name) {
+        return 2;
+    }
+}
+
+public class ReflectionGetDeclaredMethod1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethod1");
+            Method method1 = clazz.getDeclaredMethod("empty1", int.class);
+            Method method2 = clazz.getDeclaredMethod("getDd");
+            Method method3 = clazz.getDeclaredMethod("empty1");
+            Method method4 = clazz.getDeclaredMethod("empty2");
+            Method method5 = clazz.getDeclaredMethod("getZero");
+            Method method6 = clazz.getDeclaredMethod("getZero", String.class);
+            if (method1.toString().equals("public void GetDeclaredMethod1.empty1(int)")
+                    && method2.toString().equals("private java.lang.String GetDeclaredMethod1.getDd()")
+                    && method3.toString().equals("public void GetDeclaredMethod1.empty1()")
+                    && method4.toString().equals("void GetDeclaredMethod1.empty2()")
+                    && method5.toString().equals("int GetDeclaredMethod1.getZero()")
+                    && method6.toString().equals("int GetDeclaredMethod1.getZero(java.lang.String)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java b/test/testsuite/ouroboros/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3f60e8907f8ca92be10ef214eea8c6424bbd382
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredMethod2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredMethod2.java
+ *- @Title/Destination: Class.getDeclaredMethod() throws NoSuchMethodException when expected method not found in class;
+ *                      Class.getDeclaredMethod(null) throws NullPointerException.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaredMethod2类的运行时类clazz1；
+ * -#step2: 以empty1为参数，尝试通过getDeclaredMethod()方法尝试获取clazz1的方法对象并记为method1；
+ * -#step3: 通过Class.forName()方法获取GetDeclaredMethod2类的运行时类clazz2；
+ * -#step4: 以null为参数，尝试通过getDeclaredMethod()方法尝试获取clazz2的方法对象并记为method2；
+ * -#step5: method1和method2获取失败，并且会抛出NullPointerException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredMethod2.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethod2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetDeclaredMethod2_a {
+    public void empty1() {
+    }
+
+    public void empty2() {
+    }
+}
+
+class GetDeclaredMethod2 extends GetDeclaredMethod2_a {
+    public void void1() {
+    }
+
+    void void2() {
+    }
+
+    int getZero() {
+        return 0;
+    }
+
+    private String getDd() {
+        return "dd";
+    }
+
+    public void setNumber(int number) {
+    }
+
+    int setName(String name) {
+        return 2;
+    }
+}
+
+public class ReflectionGetDeclaredMethod2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetDeclaredMethod2");
+            Method method1 = clazz1.getDeclaredMethod("empty1");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            try {
+                Class clazz2 = Class.forName("GetDeclaredMethod2");
+                Method method2 = clazz2.getDeclaredMethod(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchMethodException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java b/test/testsuite/ouroboros/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java
new file mode 100644
index 0000000000000000000000000000000000000000..18232e51683fd543944caf527a06489800a293d0
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredMethod3
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredMethod3.java
+ *- @Title/Destination: Class.getDeclaredMethod() can return abstract methods of target class
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaredMethod3类的运行时类clazz；
+ * -#step2: 以aa为参数，通过getDeclaredMethod()方法获取clazz的方法对象method1；同理，以bb为参数，通过getMethod()方法获取
+ *          clazz的方法对象method2；
+ * -#step3: 确定method1和method2获取成功，并且是GetDeclaredMethod3类的指定的运行方法；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredMethod3.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethod3
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+abstract class GetDeclaredMethod3 {
+    abstract void empty1();
+    abstract public int empty2();
+}
+
+public class ReflectionGetDeclaredMethod3 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethod3");
+            Method method1 = clazz.getDeclaredMethod("empty1");
+            Method method2 = clazz.getMethod("empty2");
+            if (method1.toString().equals("abstract void GetDeclaredMethod3.empty1()")
+                    && method2.toString().equals("public abstract int GetDeclaredMethod3.empty2()")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java b/test/testsuite/ouroboros/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java
new file mode 100644
index 0000000000000000000000000000000000000000..d9cd00138dcd5cab372918eab252199e40370614
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredMethods1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredMethods1.java
+ *- @Title/Destination: Class.GetDeclaredMethods returns an array containing Method objects reflecting all the declared
+ *                      methods of the class or interface represented by this Class object, including public, protected,
+ *                      default (package) access, and private methods. If class has multiple declared methods with the
+ *                      same name and parameter types but different return types, each method will be returned.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaredMethods1类的运行时类clazz1；
+ * -#step2: 通过Class.forName()方法获取GetDeclaredMethods1_b类的运行时类clazz2；
+ * -#step3: 通过getDeclaredMethods()方法，分别获取clazz1、clazz2的所有的方法对象，返回值分别为methods1和methods2；
+ * -#step4: 确定step3中methods1和methods2都成功获取，即成功获取到clazz1、clazz2的所有的方法对象，并且methods1、methods2
+ *          的长度分别为6和2。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredMethods1.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethods1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetDeclaredMethods1_a {
+    public void empty1() {
+    }
+
+    public void empty2() {
+    }
+}
+
+class GetDeclaredMethods1 extends GetDeclaredMethods1_a {
+    public void void1() {
+    }
+
+    void void2() {
+    }
+
+    int getZero() {
+        return 0;
+    }
+
+    private String getDd() {
+        return "dd";
+    }
+
+    public void setNumber(int number) {
+    }
+
+    int setName(String name) {
+        return 2;
+    }
+}
+
+interface GetDeclaredMethods1_b {
+    public default void test1() {
+    }
+
+    default void test2() {
+    }
+}
+
+public class ReflectionGetDeclaredMethods1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetDeclaredMethods1");
+            Class clazz2 = Class.forName("GetDeclaredMethods1_b");
+            Method[] methods1 = clazz1.getDeclaredMethods();
+            Method[] methods2 = clazz2.getDeclaredMethods();
+            if (methods1.length == 6 && methods2.length == 2) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java b/test/testsuite/ouroboros/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ed29aef4deefe209ce1855531faa679d6f26ac3
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaredMethods2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaredMethods2.java
+ *- @Title/Destination: Class.getDeclaredMethods() does not return inherited methods.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaredMethods2类的运行时类clazz；
+ * -#step2: 通过getDeclaredMethods()方法获取clazz的所有的方法对象，返回值为一个数组，并记为method；
+ * -#step3: 确定method的长度为0，即返回的数组为空，证明通过getDeclaredMethods()方法不返回继承的方法。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaredMethods2.java
+ *- @ExecuteClass: ReflectionGetDeclaredMethods2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetDeclaredMethods2_a {
+    public void empty1() {
+    }
+
+    public void empty2() {
+    }
+}
+
+class GetDeclaredMethods2 extends GetDeclaredMethods2_a {
+}
+
+public class ReflectionGetDeclaredMethods2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethods2");
+            Method[] method = clazz.getDeclaredMethods();
+            if (method.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java b/test/testsuite/ouroboros/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..6500874292c8ab932d1d572492a981f64528ef9d
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetDeclaringClass
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetDeclaringClass.java
+ *- @Title/Destination: If the class or interface represented by this Class object is a member of another class,
+ *                      Class.GetDeclaringClass() returns the Class object representing the class in which it was
+ *                      declared. This method returns null if this class or interface is not a member of any other class.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetDeclaringClass类的运行时类clazz；
+ * -#step2: 通过getDeclaredFields()方法获取clazz的所有的成员，返回值为一个数组记为fields；
+ * -#step3: 通过getDeclaredConstructors()方法获取clazz的所有的构造方法，返回值为一个数组记为constructors；
+ * -#step4: 对于num < fields.length，fields[i].getDeclaringClass().getName()的返回值与GetDeclaringClass类是同一类型，同时
+ *          对于str < constructors.length，constructors[s].getDeclaringClass().getName()的返回值与GetDeclaringClass类是同
+ *          一类型；
+ * -#step5: 在step4的基础上，通过Class.forName()方法获取GetDeclaringClass_a类的运行时类clazz2，并且通过
+ *          clazz2.getDeclaringClass()的返回值均为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetDeclaringClass.java
+ *- @ExecuteClass: ReflectionGetDeclaringClass
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
+class GetDeclaringClass {
+    public int num;
+    String str;
+    float fNum;
+
+    public GetDeclaringClass() {
+    }
+
+    GetDeclaringClass(int number) {
+    }
+
+    GetDeclaringClass(String name) {
+    }
+
+    GetDeclaringClass(int number, String name) {
+    }
+}
+
+class GetDeclaringClass_a {
+}
+
+public class ReflectionGetDeclaringClass {
+    public static void main(String[] args) {
+        try {
+            int num = 0;
+            Class clazz = Class.forName("GetDeclaringClass");
+            Field[] fields = clazz.getDeclaredFields();
+            Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+            for (int i = 0; i < fields.length; i++) {
+                if (fields[i].getDeclaringClass().getName().equals("GetDeclaringClass")) {
+                    for (int j = 0; j < constructors.length; j++) {
+                        if (constructors[j].getDeclaringClass().getName().equals("GetDeclaringClass")) {
+                            Class clazz2 = Class.forName("GetDeclaringClass_a");
+                            if (clazz2.getDeclaringClass() == null) {
+                                num++;
+                            }
+                        }
+                    }
+                }
+            }
+            if (num == 12) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java b/test/testsuite/ouroboros/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java
new file mode 100644
index 0000000000000000000000000000000000000000..3da8250fac9ee01b41fc4f1e7b27e5225457583b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetEnumConstants
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetEnumConstants.java
+ *- @Title/Destination: Returns an array of the values of the enumeration classes that are represented in the order
+ *                      declared by this class object.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法分别获取Weekday类、GetEnumConstants类的运行时类clazz1、clazz2；
+ * -#step2: 分别通过clazz1.getEnumConstants()和clazz2.getEnumConstants()获取枚举类的数组并记为objects1、objects2；
+ * -#step3: 确定step2中成功获取到枚举类数组objects1、objects2，并且objects1数组的长度为7，objects2数组为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetEnumConstants.java
+ *- @ExecuteClass: ReflectionGetEnumConstants
+ *- @ExecuteArgs:
+ */
+
+enum Weekday {
+    MONDAY {
+        Object test1() {
+            class classA {
+            }
+
+            return new classA();
+        }
+    },
+    TUESDAY {
+        Object test2() {
+            class classB {
+            }
+
+            return new classB();
+        }
+    },
+    WEDNESDAY {
+        Object test3() {
+            class classC {
+            }
+
+            return new classC();
+        }
+    },
+    THURSDAY {
+        Object test4() {
+            class classD {
+            }
+
+            return new classD();
+        }
+    },
+    FRIDAY {
+        Object test5() {
+            class classE {
+            }
+
+            return new classE();
+        }
+    },
+    SATURDAY {
+        Object test6() {
+            class classF {
+            }
+
+            return new classF();
+        }
+    },
+    SUNDAY {
+        Object test7() {
+            class classG {
+            }
+
+            return new classG();
+        }
+    }
+}
+
+class GetEnumConstants {
+}
+
+public class ReflectionGetEnumConstants {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("Weekday");
+            Class clazz2 = Class.forName("GetEnumConstants");
+            Object[] objects1 = clazz1.getEnumConstants();
+            Object[] objects2 = clazz2.getEnumConstants();
+            if (objects1.length == 7) {
+                if (objects2 == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0048-rt-reflection-ReflectiongetField1/ReflectionGetField1.java b/test/testsuite/ouroboros/reflection_test/RT0048-rt-reflection-ReflectiongetField1/ReflectionGetField1.java
new file mode 100644
index 0000000000000000000000000000000000000000..925d6af22c9481ad62e7f6ae14cb742ca76219c2
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0048-rt-reflection-ReflectiongetField1/ReflectionGetField1.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetField1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetField1.java
+ *- @Title/Destination: Class.getField() returns a Field object that reflects the specified public member field,
+ *                      including the inherited public fields.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetField1类的运行时类clazz；
+ * -#step2: 分别以num、str为参数，通过getField()方法分别获取GetField1类、GetField1_a类的公共字段并记为field1、field2；
+ * -#step3: 确定step2中成功获取到两个字段field1、field2，并且field1等于i，field2等于str。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetField1.java
+ *- @ExecuteClass: ReflectionGetField1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetField1_a {
+    int num2 = 5;
+    public String str = "bbb";
+}
+
+class GetField1 extends GetField1_a {
+    public int num = 1;
+    String string = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+
+public class ReflectionGetField1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetField1");
+            Field field1 = clazz.getField("num");
+            Field field2 = clazz.getField("str");
+            if (field1.getName().equals("num") && field2.getName().equals("str")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0049-rt-reflection-ReflectiongetField2/ReflectionGetField2.java b/test/testsuite/ouroboros/reflection_test/RT0049-rt-reflection-ReflectiongetField2/ReflectionGetField2.java
new file mode 100644
index 0000000000000000000000000000000000000000..6bd5556f948834e8ebc840ce415142776a5e6643
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0049-rt-reflection-ReflectiongetField2/ReflectionGetField2.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetField2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetField2.java
+ *- @Title/Destination: If expected Field not found, throws NoSuchFieldException; Class.getField(null) throws
+ *                      NullPointerException.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetField2类的运行时类clazz1；
+ * -#step2: 以s为参数，通过getField()方法尝试获取GetField2类的default类型的字段并记为field1；
+ * -#step3: 通过Class.forName()方法获取GetField2类的运行时类clazz2；
+ * -#step4: 以null为参数，通过getField()方法尝试获取GetField2类的字段并记为field2；
+ * -#step5: 确定step2和step4中field1、field2获取失败，并且会抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetField2.java
+ *- @ExecuteClass: ReflectionGetField2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetField2_a {
+    int num = 5;
+    public String str = "bbb";
+}
+
+class GetField2 extends GetField2_a {
+    public int num = 1;
+    String str2 = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+
+public class ReflectionGetField2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetField2");
+            Field field1 = clazz1.getField("str2");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            try {
+                Class clazz2 = Class.forName("GetField2");
+                Field field2 = clazz2.getField(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchFieldException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0050-rt-reflection-ReflectiongetFields/ReflectionGetFields.java b/test/testsuite/ouroboros/reflection_test/RT0050-rt-reflection-ReflectiongetFields/ReflectionGetFields.java
new file mode 100644
index 0000000000000000000000000000000000000000..2cbe8ec3a02dac17d2eb8253e5b39becd6501a34
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0050-rt-reflection-ReflectiongetFields/ReflectionGetFields.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetFields
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetFields.java
+ *- @Title/Destination: Class.GetFields() returns an array containing Field objects reflecting all the accessible public
+ *                      fields of the class or interface represented by this Class object. Including inherited public
+ *                      fields.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法分别获取GetFields类、GetFields_b类、GetFields_c类的运行时类clazz1、clazz2、clazz3；
+ * -#step2: 通过getFields()方法分别获取clazz1、clazz2、clazz3的所有可访问的公共字段并记为fields1、fields2、fields3；
+ * -#step3: 确定step2中fields1、fields2、fields3获取成功，并且fields1和fields2的长度为2，fields的长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetFields.java
+ *- @ExecuteClass: ReflectionGetFields
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class GetFields_a {
+    public int num = 5;
+    String str = "bbb";
+}
+
+class GetFields extends GetFields_a {
+    public int num = 1;
+    String str = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+
+interface GetFields_b {
+    public int num = 2;
+    String str = "ccc";
+}
+
+class GetFields_c {
+}
+
+public class ReflectionGetFields {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetFields");
+            Class clazz2 = Class.forName("GetFields_b");
+            Class clazz3 = Class.forName("GetFields_c");
+            Field[] fields1 = clazz1.getFields();
+            Field[] fields2 = clazz2.getFields();
+            Field[] fields3 = clazz3.getFields();
+            if (fields1.length == 2 && fields2.length == 2 && fields3.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/ReflectionGetMethod1.java b/test/testsuite/ouroboros/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/ReflectionGetMethod1.java
new file mode 100644
index 0000000000000000000000000000000000000000..90cc766c887ed19906a7fb7a181897f66078a125
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/ReflectionGetMethod1.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetMethod1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetMethod1.java
+ *- @Title/Destination: Class.getMethod Returns a Method object that reflects the specified public member method of the
+ *                      class or interface represented by this Class object. Include inherited public methods.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetMethod1类的运行时类clazz；
+ * -#step2: 分别以empty、（empty，int.class）、（setName，String.class）、getStr为参数，获取clazz的指定的公共成员方法并记为
+ *          method1、method2、method3、method4；
+ * -#step3: 确定step2中成功获取到method1、method2、method3、method4，并且正好是GetMethod1类的指定的公共成员方法；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetMethod1.java
+ *- @ExecuteClass: ReflectionGetMethod1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetMethod1_a {
+    public int setName(String name) {
+        return 10;
+    }
+
+    public String getStr() {
+        return "getDda";
+    }
+}
+
+class GetMethod1 extends GetMethod1_a {
+    public void empty() {
+    }
+
+    void emptyB() {
+    }
+
+    int getNum() {
+        return 0;
+    }
+
+    private String getDd() {
+        return "getDd";
+    }
+
+    public void empty(int number) {
+    }
+
+    int getNum(String name) {
+        return 2;
+    }
+}
+
+public class ReflectionGetMethod1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetMethod1");
+            Method method1 = clazz.getMethod("empty");
+            Method method2 = clazz.getMethod("empty", int.class);
+            Method method3 = clazz.getMethod("setName", String.class);
+            Method method4 = clazz.getMethod("getStr");
+            if (method1.toString().equals("public void GetMethod1.empty()")
+                    && method2.toString().equals("public void GetMethod1.empty(int)")
+                    && method3.toString().equals("public int GetMethod1_a.setName(java.lang.String)")
+                    && method4.toString().equals("public java.lang.String GetMethod1_a.getStr()")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/ReflectionGetMethod2.java b/test/testsuite/ouroboros/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/ReflectionGetMethod2.java
new file mode 100644
index 0000000000000000000000000000000000000000..85712cf4bf2f0ed07c621f28d24c5c9cebe30492
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/ReflectionGetMethod2.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetMethod2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetMethod2.java
+ *- @Title/Destination: If expected method is not found, getMethod throws NoSuchMethodException; Class.getMethod(NULL)
+ *                      throws NullPointerException.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetMethod2类的运行时类clazz1；
+ * -#step2: 以empty为参数，通过getMethod()方法获取clazz1的公共成员方法并记为method1；
+ * -#step3: 通过Class.forName()方法获取GetMethod2类的运行时类clazz2；
+ * -#step4: 以null为参数，通过getMethod()方法获取clazz2的公共成员方法并记为method2；
+ * -#step5: 确定step2和step4中的method1、method2获取失败，并且会抛出NullPointerException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetMethod2.java
+ *- @ExecuteClass: ReflectionGetMethod2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class GetMethod2_a {
+    public int getName(String name) {
+        return 10;
+    }
+
+    public String getString() {
+        return "dda";
+    }
+}
+
+class GetMethod2 extends GetMethod2_a {
+    public void getVoid() {
+    }
+
+    void empty() {
+    }
+
+    int getZero() {
+        return 0;
+    }
+
+    private String getStr() {
+        return "dd";
+    }
+
+    public void setNum(int number) {
+    }
+
+    int getSecondNum(String name) {
+        return 2;
+    }
+}
+
+public class ReflectionGetMethod2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetMethod2");
+            Method method1 = clazz1.getMethod("empty");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            // NoSuchMethodException is thrown when method not exist.
+            try {
+                Class clazz2 = Class.forName("GetMethod2");
+                Method method2 = clazz2.getMethod(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchMethodException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                // Expected result: NullPointerException is thrown when method is null.
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/ReflectionGetSigners.java b/test/testsuite/ouroboros/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/ReflectionGetSigners.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b7416a77b0debc520685c7b18f8c58c29274a1a
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/ReflectionGetSigners.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetSigners
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetSigners.java
+ *- @Title/Destination: Gets the signers of this class.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetSigners类的运行时类clazz；
+ * -#step2: 通过getSigners()方法获取clazz的所有的标签并记为objects；
+ * -#step3: 确定step2中成功获取到objects，并且objects等于null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetSigners.java
+ *- @ExecuteClass: ReflectionGetSigners
+ *- @ExecuteArgs:
+ */
+
+class GetSigners {
+}
+
+public class ReflectionGetSigners {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetSigners");
+            Object[] objects = clazz.getSigners();
+            if (objects == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/ReflectionGetSimpleName.java b/test/testsuite/ouroboros/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/ReflectionGetSimpleName.java
new file mode 100644
index 0000000000000000000000000000000000000000..63951dc781044bbd03620554e143a5c945d5d617
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/ReflectionGetSimpleName.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionGetSimpleName
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionGetSimpleName.java
+ *- @Title/Destination: Returns the simple name of the underlying class as given in the source code.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取GetSimpleName类的运行时类clazz；
+ * -#step2: 通过getSimpleName()方法获取clazz的类名并记为string；
+ * -#step3: 确定step2中成功获取到string并且其类型与GetSimpleName类是同一类型；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionGetSimpleName.java
+ *- @ExecuteClass: ReflectionGetSimpleName
+ *- @ExecuteArgs:
+ */
+
+class GetSimpleName {
+}
+
+public class ReflectionGetSimpleName {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetSimpleName");
+            String string = clazz.getSimpleName();
+            if (string.equals("GetSimpleName")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0056-rt-reflection-ReflectionisArray/ReflectionIsArray.java b/test/testsuite/ouroboros/reflection_test/RT0056-rt-reflection-ReflectionisArray/ReflectionIsArray.java
new file mode 100644
index 0000000000000000000000000000000000000000..e95b2b415f38577867ba02173ffe7129c36dc0e8
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0056-rt-reflection-ReflectionisArray/ReflectionIsArray.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionIsArray
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionIsArray.java
+ *- @Title/Destination: Determines if this Class object represents an array class.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取IsArray类的运行时类clazz；
+ * -#step2: 通过getDeclaredFields()方法获取clazz的所有的声明的字段并记为fields；
+ * -#step3: 通过fields.getClass()获取当前的运行时类并记为clazz1；
+ * -#step4: 确定step1和step3成功获取clazz和clazz1，并且clazz1是一个数组，而clazz不是一个数组。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionIsArray.java
+ *- @ExecuteClass: ReflectionIsArray
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class IsArray {
+    public int num;
+    String str;
+    float fNum;
+}
+
+public class ReflectionIsArray {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("IsArray");
+            Field[] fields = clazz.getDeclaredFields();
+            Class clazz1 = fields.getClass();
+            if (clazz1.isArray()) {
+                if (!clazz.isArray()) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java b/test/testsuite/ouroboros/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java
new file mode 100644
index 0000000000000000000000000000000000000000..5894e2302685dc24533e8e2f93c1a577e5966d92
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionIsAssignableFrom1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionIsAssignableFrom1.java
+ *- @Title/Destination: Class.isAssignableFrom(cls) return true when Class is superclass of cls.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法分别获取AssignableFrom1类、AssignableFrom1_a类、AssignableFromTest1类和
+ *          AssignableFromTest1_a类的运行时类并记为clazz1、clazz2、clazz3、clazz4；
+ * -#step2: 调用isAssignableFrom确定step1中成功获取到clazz1、clazz2、clazz3、clazz4并且clazz1是clazz2的父类，而clazz2不是
+ *          clazz1的父类；同理，clazz3是clazz4的父类，clazz4不是clazz3的父类；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionIsAssignableFrom1.java
+ *- @ExecuteClass: ReflectionIsAssignableFrom1
+ *- @ExecuteArgs:
+ */
+
+class AssignableFrom1 {
+}
+
+class AssignableFrom1_a extends AssignableFrom1 {
+}
+
+interface AssignableFromTest1 {
+}
+
+interface AssignableFromTest1_a extends AssignableFromTest1 {
+}
+
+public class ReflectionIsAssignableFrom1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("AssignableFrom1");
+            Class clazz2 = Class.forName("AssignableFrom1_a");
+            Class clazz3 = Class.forName("AssignableFromTest1");
+            Class clazz4 = Class.forName("AssignableFromTest1_a");
+            if (clazz1.isAssignableFrom(clazz2) && !clazz2.isAssignableFrom(clazz1) && clazz3.isAssignableFrom(clazz4)
+                    && !clazz4.isAssignableFrom(clazz3)) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java b/test/testsuite/ouroboros/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..a714605cb4941433c772a90263b040dd467d1267
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionIsAssignableFromNullPointerException
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionIsAssignableFromNullPointerException.java
+ *- @Title/Destination: Class.isAssignableFrom(null) throws NullPointerException.
+ *- @Brief:no:
+ * -#step1: Use classloader load class.
+ * -#step2: Test Class.isAssignableFrom() whit null param.
+ * -#step3: Check that NullPointerException occurs when Class.isAssignableFrom()'s is null.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionIsAssignableFromNullPointerException.java
+ *- @ExecuteClass: ReflectionIsAssignableFromNullPointerException
+ *- @ExecuteArgs:
+ */
+
+class AssignableFromNullPointerException {
+}
+
+public class ReflectionIsAssignableFromNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("AssignableFromNullPointerException");
+            zqp1.isAssignableFrom(null);
+            result = -1;
+        } catch (ClassNotFoundException e1) {
+            result = -1;
+        } catch (NullPointerException e2) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/ReflectionIsLocalClass.java b/test/testsuite/ouroboros/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/ReflectionIsLocalClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8d11ca029c1e4532706fc715137b23129540538
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/ReflectionIsLocalClass.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionIsLocalClass
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionIsLocalClass.java
+ *- @Title/Destination: isLocalClass() returns true if and only if the underlying class is a local class(defined in the
+ *                      body of a method)
+ *- @Brief:no:
+ * -#step1: Define a class in method and two class out of the method.
+ * -#step2: Get Class object of the class.
+ * -#step3: Test isLocalClass() with different the Class object of the class.
+ * -#step4: Check that isLocalClass() identifies local class correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionIsLocalClass.java
+ *- @ExecuteClass: ReflectionIsLocalClass
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionIsLocalClass {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        class isLocalClass {
+        }
+        try {
+            Class zqp1 = isLocalClass.class;
+            Class zqp2 = Class.forName("ReflectionIsLocalClass");
+            Class zqp3 = IsLocalClass_a.class;
+            Class zqp4 = IsLocalClass_b.class;
+            Class zqp5 = (new isLocalClass() {
+            }).getClass();
+            if (!zqp2.isLocalClass()) {
+                if (!zqp3.isLocalClass()) {
+                    if (!zqp4.isLocalClass()) {
+                        if (!zqp5.isLocalClass()) {
+                            if (zqp1.isLocalClass()) {
+                                result = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = 2;
+        }
+        System.out.println(result);
+    }
+
+    class IsLocalClass_a {
+    }
+
+    static class IsLocalClass_b {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/ReflectionIsMemberClass.java b/test/testsuite/ouroboros/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/ReflectionIsMemberClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e52df232a61880636befe01cecfd280485f29d8
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/ReflectionIsMemberClass.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionIsMemberClass
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionIsMemberClass.java
+ *- @Title/Destination: Class.IsMemberClass() returns true if and only if the underlying class is a member
+ *                      class(class inside another class, but not inside a method).
+ *- @Brief:no:
+ * -#step1: Define a class in method and two inner class but not inside the method.
+ * -#step2: Get Class object of the class.
+ * -#step3: Test isMemberClass() with different the Class object of the class.
+ * -#step4: Check that isMemberClass() identifies member class correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionIsMemberClass.java
+ *- @ExecuteClass: ReflectionIsMemberClass
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionIsMemberClass {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        class IsMemberClass_a {
+        }
+        try {
+            Class zqp1 = IsMemberClass.class;
+            Class zqp2 = Class.forName("ReflectionIsMemberClass");
+            Class zqp3 = IsMemberClass_a.class;
+            Class zqp4 = IsMemberClass_b.class;
+            Class zqp5 = (new IsMemberClass_b() {
+            }).getClass();
+            if (!zqp2.isMemberClass()) {
+                if (!zqp3.isMemberClass()) {
+                    if (zqp4.isMemberClass()) {
+                        if (!zqp5.isMemberClass()) {
+                            if (zqp1.isMemberClass()) {
+                                result = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+
+    class IsMemberClass {
+    }
+
+    static class IsMemberClass_b {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/ReflectionIsPrimitive.java b/test/testsuite/ouroboros/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/ReflectionIsPrimitive.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a969bc989d80841dfc52c7ad0a8187b2b904be6
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/ReflectionIsPrimitive.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionIsPrimitive
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionIsPrimitive.java
+ *- @Title/Destination: Determines if the specified Class object represents a primitive type.
+ *- @Brief:no:
+ * -#step1: Get nine Class Pre-defined object and a normal Class object of class.
+ * -#step2: Test isPrimitive() with the 10 primitive type object.
+ * -#step3: Check that isPrimitive() identifies primitive type of the object correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionIsPrimitive.java
+ *- @ExecuteClass: ReflectionIsPrimitive
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionIsPrimitive {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+
+        Class zqp1 = ReflectionIsPrimitive.class;
+        Class zqp2 = int.class;
+        Class zqp3 = boolean.class;
+        Class zqp4 = byte.class;
+        Class zqp5 = char.class;
+        Class zqp6 = short.class;
+        Class zqp7 = long.class;
+        Class zqp8 = float.class;
+        Class zqp9 = double.class;
+        Class zqp10 = void.class;
+        if (!zqp1.isPrimitive() && zqp2.isPrimitive() && zqp3.isPrimitive() && zqp4.isPrimitive() && zqp5.isPrimitive()
+                && zqp6.isPrimitive() && zqp7.isPrimitive() && zqp8.isPrimitive() && zqp9.isPrimitive() &&
+                zqp10.isPrimitive()) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/ReflectionIsSynthetic.java b/test/testsuite/ouroboros/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/ReflectionIsSynthetic.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4e547c1accc07bc55e2ff9a2f41c2b3ab1da8fd
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/ReflectionIsSynthetic.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionIsSynthetic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionIsSynthetic.java
+ *- @Title/Destination: Returns true if this class is a synthetic class
+ *- @Brief:no:
+ * -#step1: Define a test class IsSynthetic.
+ * -#step2: Test isSynthetic() with three different type object.
+ * -#step3: Check that isSynthetic() identifies synthetic class correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionIsSynthetic.java
+ *- @ExecuteClass: ReflectionIsSynthetic
+ *- @ExecuteArgs:
+ */
+
+public class ReflectionIsSynthetic {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        new IsSynthetic();
+        try {
+            Class zqp1 = IsSynthetic.class;
+            Class zqp2 = int.class;
+            Class zqp3 = Class.forName("ReflectionIsSynthetic$1");
+            if (!zqp2.isSynthetic()) {
+                if (!zqp1.isSynthetic()) {
+                    if (zqp3.isSynthetic()) {
+                        result = 0;
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+
+    private static class IsSynthetic {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/ReflectionNewInstance1.java b/test/testsuite/ouroboros/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/ReflectionNewInstance1.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2b059ddb5e1cc11397088b905c00f332714fb86
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/ReflectionNewInstance1.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionNewInstance1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionNewInstance1.java
+ *- @Title/Destination: Instantiating a class by reflection:class.newInstance() creates a new instance of the class
+ *                      represented by this Class object. The class is instantiated as if by a new expression with an
+ *                      empty argument list.
+ *- @Brief:no:
+ * -#step1: Use classloader load class.
+ * -#step2: Instantiating the class by class.newInstance().
+ * -#step3: Check that the object is  instance of class NewInstance1
+ * -#step4: Try to catch exceptions those occurs possibly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionNewInstance1.java
+ *- @ExecuteClass: ReflectionNewInstance1
+ *- @ExecuteArgs:
+ */
+
+class NewInstance1 {
+}
+
+public class ReflectionNewInstance1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("NewInstance1");
+            Object zhu = zqp.newInstance();
+            if (zhu.toString().indexOf("NewInstance1@") != -1) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java b/test/testsuite/ouroboros/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
new file mode 100644
index 0000000000000000000000000000000000000000..eeb119cb146f6e59a4cd7e6b9e1694ed9a71034b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionNewInstanceInstantiationExceptionIllegalAccessException
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
+ *- @Title/Destination: call newInstance() on an interface object throws InstantiationException; if the class's
+ *                      constructor is not accessible, throws IllegalAccessException.
+ *- @Brief:no:
+ * -#step1: Create a test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Instantiating the class by class.newInstance().
+ * -#step4: It will throw InstantiationException because we used class which dose not exit.
+ * -#step5: Then check that IllegalAccessException was threw when class constructor is not accessible.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
+ *- @ExecuteClass: ReflectionNewInstanceInstantiationExceptionIllegalAccessException
+ *- @ExecuteArgs:
+ */
+
+interface NewInstance2 {
+}
+
+class NewInstance2_a {
+    private NewInstance2_a() {
+    }
+}
+
+public class ReflectionNewInstanceInstantiationExceptionIllegalAccessException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp1 = Class.forName("NewInstance2");
+            Object zhu1 = zqp1.newInstance();
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (InstantiationException e1) {
+
+            try {
+                Class zqp2 = Class.forName("NewInstance2_a");
+                Object zhu2 = zqp2.newInstance();
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                result = -1;
+            } catch (InstantiationException e4) {
+                System.err.println(e4);
+                result = -1;
+            } catch (IllegalAccessException e5) {
+                result = 0;
+            }
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/ReflectionToGenericString.java b/test/testsuite/ouroboros/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/ReflectionToGenericString.java
new file mode 100644
index 0000000000000000000000000000000000000000..a438e13e54565fa16afda2ef118db887703c7c25
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/ReflectionToGenericString.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionToGenericString
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionToGenericString.java
+ *- @Title/Destination: getGenericString() returns a string description of this class, including information about
+ *                      modifiers and type parameters.
+ *- @Brief:no:
+ * -#step1: Create a abstract test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Test getGenericString() with Class object of the test class.
+ * -#step4: Check that getGenericString() returns a string description of class information correctly.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionToGenericString.java
+ *- @ExecuteClass: ReflectionToGenericString
+ *- @ExecuteArgs:
+ */
+
+@interface Eee {
+}
+
+@Eee
+abstract class ToGenericString<t> {
+}
+
+public class ReflectionToGenericString {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("ToGenericString");
+            String zhu = zqp.toGenericString();
+            if (zhu.equals("abstract class ToGenericString<t>")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0066-rt-reflection-ReflectiontoString/ReflectionToString.java b/test/testsuite/ouroboros/reflection_test/RT0066-rt-reflection-ReflectiontoString/ReflectionToString.java
new file mode 100644
index 0000000000000000000000000000000000000000..0553710e9a445e828a73cca1d5d9d0fc0a1efab5
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0066-rt-reflection-ReflectiontoString/ReflectionToString.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionToString
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionToString.java
+ *- @Title/Destination: To obtain a class for string output by reflection.
+ *- @Brief:no:
+ * -#step1: Create a test class.
+ * -#step2: Use classloader to load class.
+ * -#step3: Test toString() by reflection.
+ * -#step4: Check that reflection result is correct.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionToString.java
+ *- @ExecuteClass: ReflectionToString
+ *- @ExecuteArgs:
+ */
+
+@interface Fff {
+}
+
+@Fff
+abstract class ToString_$<t> {
+}
+
+public class ReflectionToString {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success */
+        try {
+            Class zqp = Class.forName("ToString_$");
+            String zhu = zqp.toString();
+            if (zhu.equals("class ToString_$")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java b/test/testsuite/ouroboros/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java
new file mode 100644
index 0000000000000000000000000000000000000000..091522de7bdad0240372f009fd06cc24acffd2d3
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTConstructorGetAnnotation2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTConstructorGetAnnotation2.java
+ *- @Title/Destination: When try to get annotation of target class's constructor by reflection and the annotation does
+ *                      not exist, Constructor.getAnnotation() throws NullPointerException.
+ *- @Brief:no
+ * -#step1: 定义类1有含注解的构造方法，类2有无注解的构造方法。
+ * -#step2：通过Class.forName获取类1的class。
+ * -#step3：通过getDeclaredConstructor(Class...<?> parameterTypes)获取构造方法1，通过getConstructor()获取无参构造方法2、
+ * -#step4：构造方法1，2调用getAnnotation(Class<T> annotationClass)，annotationClass为不匹配的注解类型，判断返回的注解为空。
+ * -#step5：通过Class.forName获取类2的class。
+ * -#step6：通过getDeclaredConstructor(Class...<?> parameterTypes)获取构造方法3。
+ * -#step7：构造方法3调用getAnnotation(Class<T> annotationClass)，annotationClass为注解类型，判断返回的注解为空。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTConstructorGetAnnotation2.java
+ *- @ExecuteClass: RTConstructorGetAnnotation2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ConstructorGetAnnotation2 {
+    @IF2(i = 333, t = "ConstructorGetAnnotation")
+    public ConstructorGetAnnotation2() {
+    }
+
+    @IF2_a(c = 666, d = "Constructor")
+    ConstructorGetAnnotation2(int number) {
+    }
+}
+
+class ConstructorGetAnnotation2_a {
+    ConstructorGetAnnotation2_a(String name, int number) {
+    }
+}
+
+public class RTConstructorGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetAnnotation2");
+            Constructor instance1 = cls.getDeclaredConstructor(int.class);
+            Constructor instance2 = cls.getConstructor();
+            if (instance1.getAnnotation(IF2.class) == null && instance2.getAnnotation(IF2_a.class) == null) {
+                instance1.getAnnotation(IF2.class).toString();
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(1);
+            return;
+        } catch (NullPointerException e3) {
+            try {
+                Class cls = Class.forName("ConstructorGetAnnotation2_a");
+                Constructor instance3 = cls.getDeclaredConstructor(String.class, int.class);
+                if (instance3.getAnnotation(IF2.class) == null && instance3.getAnnotation(IF2_a.class) == null) {
+                    instance3.getAnnotation(IF2.class).toString();
+                }
+                System.out.println(1);
+                return;
+            } catch (ClassNotFoundException e4) {
+                System.out.println(2);
+                return;
+            } catch (NoSuchMethodException e5) {
+                System.out.println(3);
+                return;
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+                return;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java
new file mode 100644
index 0000000000000000000000000000000000000000..380c6e411600e3927aee19a8c8d0c8831c6c7c4e
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTConstructorGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTConstructorGetDeclaredAnnotations2.java
+ *- @Title/Destination: Constructor.getDeclaredAnnotations() does not return annotations inherited from parent class.
+ *- @Brief:no:
+ * -#step1: 定义两个类，有父子关系，父类含有注解的构造方法，子类的构造方法没有注解。
+ * -#step2：调用getConstructor(Class...<?> parameterTypes)从子类中获取构造方法1。
+ * -#step3：调用getDeclaredAnnotations()获取注解数组，判断数组长度为0。
+ * -#step4：调用getConstructor(Class...<?> parameterTypes)从子类中获取构造方法2。
+ * -#step5：调用getDeclaredAnnotations()获取注解数组，判断数组长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTConstructorGetDeclaredAnnotations2.java
+ *- @ExecuteClass: RTConstructorGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+
+class ConstructorGetDeclaredAnnotations2 {
+    public ConstructorGetDeclaredAnnotations2() {
+    }
+
+    @IF2(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations2(String name) {
+    }
+
+    @IF2(i = 333, t = "test1")
+    ConstructorGetDeclaredAnnotations2(int number) {
+    }
+}
+
+class ConstructorGetDeclaredAnnotations2_a extends ConstructorGetDeclaredAnnotations2 {
+    public ConstructorGetDeclaredAnnotations2_a(String name) {
+    }
+
+    ConstructorGetDeclaredAnnotations2_a(int number) {
+    }
+}
+
+public class RTConstructorGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetDeclaredAnnotations2_a");
+            Constructor instance1 = cls.getConstructor(String.class);
+            Constructor instance2 = cls.getDeclaredConstructor(int.class);
+            if (instance1.getDeclaredAnnotations().length == 0 && instance2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        } catch (NullPointerException e2) {
+            System.out.println(4);
+            return;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0074-rt-reflection-RTFieldget1/RTFieldGet1.java b/test/testsuite/ouroboros/reflection_test/RT0074-rt-reflection-RTFieldget1/RTFieldGet1.java
new file mode 100644
index 0000000000000000000000000000000000000000..db04b00cce5629c5d1ba09da4d1f331da9242fd7
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0074-rt-reflection-RTFieldget1/RTFieldGet1.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldGet1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldGet1.java
+ *- @Title/Destination: Field.get() returns the value of the field represented by this field on the target object.
+ *- @Brief:no:
+ * -#step1: 创建类FieldGet1_a和它的子类FieldGet1。
+ * -#step2：通过forName()方法加载FieldGet1并调用newInstance()生成实例对象。
+ * -#step3：通过getField()方法获取实例对象中的成员变量，并确认值正确。
+ * -#step4：通过forName()方法加载FieldGet1_a并生成实例对象,通过getField()方法获取对应的成员变量并核对值正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldGet1.java
+ *- @ExecuteClass: RTFieldGet1
+ *- @ExecuteArgs:
+ */
+
+class FieldGet1_a {
+    public static String str = "aaa";
+    public int num = 2;
+    public int num1 = 5;
+    public static boolean aBoolean = false;
+}
+
+class FieldGet1 extends FieldGet1_a {
+    public static String str = "bbb";
+    public int number = 1;
+    public int test = super.num1 + 1;
+    public static boolean bBoolean = true;
+    public char aChar = '国';
+}
+
+public class RTFieldGet1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet1");
+            Object obj = cls.newInstance();
+            Object q1 = cls.getField("str").get(obj);
+            Object q2 = cls.getField("number").get(obj);
+            Object q3 = cls.getField("test").get(obj);
+            Object q4 = cls.getField("bBoolean").get(obj);
+            Object q5 = cls.getField("aChar").get(obj);
+            Object q6 = cls.getField("num").get(obj);
+            Object q7 = cls.getField("aBoolean").get(null);
+            if (q1.toString().equals("bbb") && (int) q2 == 1 && (int) q3 == 6 && (boolean) q4 && q5.toString().
+                    equals("国") && (int) q6 == 2) {
+                Class cls1 = Class.forName("FieldGet1_a");
+                Object instance1 = cls1.newInstance();
+                Object q8 = cls1.getField("str").get(instance1);
+                if (q8.toString().equals("aaa")) {
+                    if (!(boolean) q7) {
+                        System.out.println(0);
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0075-rt-reflection-RTFieldget2/RTFieldGet2.java b/test/testsuite/ouroboros/reflection_test/RT0075-rt-reflection-RTFieldget2/RTFieldGet2.java
new file mode 100644
index 0000000000000000000000000000000000000000..b71e3817d226a46fa7e1adb7e0c98a69a8fe2230
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0075-rt-reflection-RTFieldget2/RTFieldGet2.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldGet2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldGet2.java
+ *- @Title/Destination: Field.get throws IllegalAccessException when the Field is inaccessible; throws
+ *                      IllegalArgumentException when the object is not an instance of the class; Field.get(null) throws
+ *                      NullPointerException.
+ *- @Brief:no:
+ * -#step1: 创建类FieldGet2_a，FieldGet2_a的子类FieldGet2且含有私有成员变量，定义FieldGet2_b。
+ * -#step2：通过forName()方法加载FieldGet2并调用newInstance()生成实例对象。
+ * -#step3：通过getDeclaredField()方法获取FieldGet2中的私有变量，确认会抛出IllegalAccessException。
+ * -#step4：加载FieldGet2实例对象，通过getDeclaredField()方法获取public变量域，构造FieldGet2_b实例，并取对应变量域值。
+ * -#step5：确认会抛出IllegalArgumentException异常，通过getDeclaredField()方法获取FieldGet2的public变量域。
+ * -#step6：调用get(Object obj)方法，obj为NULL，确认NullPointerException抛出。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldGet2.java
+ *- @ExecuteClass: RTFieldGet2
+ *- @ExecuteArgs:
+ */
+
+class FieldGet2_a {
+    public int num;
+}
+
+class FieldGet2 extends FieldGet2_a {
+    private int number = 1;
+    public boolean aBoolean = true;
+    public int number1 = 8;
+}
+
+class FieldGet2_b {
+    public int number1 = 18;
+}
+
+public class RTFieldGet2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet2");
+            Object obj = cls.newInstance();
+            Object q1 = cls.getDeclaredField("number").get(obj);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            try {
+                Class cls = Class.forName("FieldGet2");
+                Class cls1 = Class.forName("FieldGet2_b");
+                Object instance1 = cls1.newInstance();
+                Object q2 = cls.getDeclaredField("number1").get(instance1);
+            } catch (ClassNotFoundException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (InstantiationException e6) {
+                System.err.println(e6);
+                System.out.println(2);
+            } catch (NoSuchFieldException e7) {
+                System.err.println(e7);
+                System.out.println(2);
+            } catch (IllegalAccessException e8) {
+                System.err.println(e8);
+                System.out.println(2);
+            } catch (IllegalArgumentException e9) {
+                try {
+                    Class cls = Class.forName("FieldGet2");
+                    Object q3 = cls.getDeclaredField("aBoolean").get(null);
+                } catch (ClassNotFoundException e10) {
+                    System.err.println(e10);
+                    System.out.println(2);
+                } catch (NoSuchFieldException e11) {
+                    System.err.println(e11);
+                    System.out.println(2);
+                } catch (IllegalAccessException e12) {
+                    System.err.println(e12);
+                    System.out.println(2);
+                } catch (NullPointerException e13) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0076-rt-reflection-RTFieldget3/RTFieldGet3.java b/test/testsuite/ouroboros/reflection_test/RT0076-rt-reflection-RTFieldget3/RTFieldGet3.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fb7dc72451f50f2c6737fb7d7c193e01316324b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0076-rt-reflection-RTFieldget3/RTFieldGet3.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldGet3
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldGet3.java
+ *- @Title/Destination: If the filed is not given a value, the default value is returned by reflection。
+ *- @Brief:no:
+ * -#step1: 定义类FieldGet3_a，定义FieldGet3_a的子类FieldGet3。
+ * -#step2: 通过调用forName()方法加载类FieldGet3，调用newInstance()生产实例对象。
+ * -#step3: 通过调用getField()获取对应名称的未初始化的成员变量。
+ * -#step4: 调用get(Object obj)方法作出判断，确认String类型为null,int类型为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldGet3.java
+ *- @ExecuteClass: RTFieldGet3
+ *- @ExecuteArgs:
+ */
+
+class FieldGet3_a {
+    public int num;
+}
+
+class FieldGet3 extends FieldGet3_a {
+    public static String str;
+}
+
+public class RTFieldGet3 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet3");
+            Object obj = cls.newInstance();
+            Object obj1 = cls.getField("str").get(obj);
+            Object obj2 = cls.getField("num").get(obj);
+            if (obj1 == null && (int) obj2 == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/RTFieldGetAnnotation1.java b/test/testsuite/ouroboros/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/RTFieldGetAnnotation1.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a0523b2f3b5c4ebb2490d30be108b2eab11e613
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/RTFieldGetAnnotation1.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldGetAnnotation1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldGetAnnotation1.java
+ *- @Title/Destination: Field.GetAnnotation() returns null when the expected annotation is not present.
+ *- @Brief:no:
+ * -#step1: 定义含注解类FieldGetAnnotation1。
+ * -#step2: 通过调用forName()方法加载类FieldGetAnnotation1。
+ * -#step3: 通过调用getField()获取对应名称的成员变量。
+ * -#step4: 调用getAnnotation(Class<T> annotationClass)，annotationClass为不匹配的类型，确认返回null。
+ * -#step5: 调用返回空注解类型进行.number()的调用，确认抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldGetAnnotation1.java
+ *- @ExecuteClass: RTFieldGetAnnotation1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface4 {
+    int num() default 0;
+    String str() default "";
+}
+
+@interface interface4_a {
+    int number() default 0;
+    String string() default "";
+}
+
+class FieldGetAnnotation1 {
+    @interface4(num = 333, str = "GetAnnotation")
+    public int num1;
+    @interface4_a(number = 555, string = "test")
+    public String str1;
+}
+
+public class RTFieldGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls1 = Class.forName("FieldGetAnnotation1");
+            Field instance1 = cls1.getField("num1");
+            Field instance2 = cls1.getField("str1");
+            if (instance1.getAnnotation(interface4_a.class) == null && instance2.getAnnotation(interface4.class) == null) {
+                instance1.getAnnotation(interface4_a.class).number();
+            }
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java
new file mode 100644
index 0000000000000000000000000000000000000000..36e021f5ffa3fbf8f38e2058e241e575a7bd8dbe
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldGetDeclaredAnnotations2.java
+ *- @Title/Destination: Field.GetDeclaredAnnotations() ignores inherited annotations.
+ *- @Brief:no:
+ * -#step1: 定义含注解类FieldGetDeclaredAnnotations2，定义含注解的类FieldGetDeclaredAnnotations2的子类
+ *          FieldGetDeclaredAnnotations2_a。
+ * -#step2: 通过调用forName()方法加载类FieldGetDeclaredAnnotations2_a。
+ * -#step3: 通过调用 getField()获取对应名称的成员变量。
+ * -#step4: 通过调用getAnnotation(Class<T> annotationClass)获取注解，调用equals()方法进行判断获取正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldGetDeclaredAnnotations2.java
+ *- @ExecuteClass: RTFieldGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface2 {
+    int num() default 0;
+    String str() default "";
+}
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+
+class FieldGetDeclaredAnnotations2 {
+    @interface2(num = 333, str = "test1")
+    public int num;
+    @interface2(num = 333, str = "test1")
+    public String str;
+}
+
+class FieldGetDeclaredAnnotations2_a extends FieldGetDeclaredAnnotations2 {
+    @interface2_a(i_a = 666, t_a = "right1")
+    public int num;
+    public String str;
+}
+
+public class RTFieldGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaredAnnotations2_a");
+            Field instance1 = cls.getField("str");
+            Field instance2 = cls.getDeclaredField("str");
+            if (instance1.getDeclaredAnnotations().length == 0 && instance2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java b/test/testsuite/ouroboros/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..78ee9b8dae3a60c9d4459c8e132084ff9d57a05d
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldGetDeclaringClass
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldGetDeclaringClass.java
+ *- @Title/Destination: Field.GetDeclaringClass() returns the class object of the class declaring the field represented
+ *                      by this Field object.
+ *- @Brief:no:
+ * -#step1: 定义类FieldGetDeclaringClass。
+ * -#step2: 通过调用forName()方法加载类FieldGetDeclaringClass。
+ * -#step3: 通过调用 getField()、getDeclaredField()获取对应名称的成员变量。
+ * -#step4: 通过调用FieldGetDeclaringClass()获取类对象，调用equals()方法进行判断获取正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldGetDeclaringClass.java
+ *- @ExecuteClass: RTFieldGetDeclaringClass
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldGetDeclaringClass {
+    public int num;
+    char aChar;
+}
+
+public class RTFieldGetDeclaringClass {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaringClass");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("aChar");
+            Class<?> j = instance1.getDeclaringClass();
+            Class<?> k = instance2.getDeclaringClass();
+            if (j.getName().equals("FieldGetDeclaringClass") && k.getName().equals("FieldGetDeclaringClass")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/RTFieldGetModifiers.java b/test/testsuite/ouroboros/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/RTFieldGetModifiers.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a625affe82bab50f64038ecd5a7bac264ce9749
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/RTFieldGetModifiers.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldGetModifiers
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldGetModifiers.java
+ *- @Title/Destination: Field.GetModifiers() Returns the Java language modifiers for the field represented by this Field
+ *                      object, as an integer.
+ *- @Brief:no:
+ * -#step1: 定义含受保护的今天成员变量的类FieldGetModifiers。
+ * -#step2: 通过调用forName()方法加载类FieldGetModifiers。
+ * -#step3: 通过调用getField()、getDeclaredField()获取对应名称的成员变量。
+ * -#step4: 通过调用getModifiers()获取对应字段的Java语言修饰符,调用equals()方法进行判断描述正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldGetModifiers.java
+ *- @ExecuteClass: RTFieldGetModifiers
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldGetModifiers {
+    public static int num;
+    final String str = "aaa";
+    private String string = "ccc";
+    protected static int number;
+}
+
+public class RTFieldGetModifiers {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetModifiers");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("str");
+            Field instance3 = cls.getDeclaredField("string");
+            Field field = cls.getDeclaredField("number");
+            if (instance1.getModifiers() == 9 && instance2.getModifiers() == 16 && instance3.getModifiers() == 2
+                    && field.getModifiers()
+                    == 12) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0082-rt-reflection-RTFieldgetName/RTFieldGetName.java b/test/testsuite/ouroboros/reflection_test/RT0082-rt-reflection-RTFieldgetName/RTFieldGetName.java
new file mode 100644
index 0000000000000000000000000000000000000000..200388ff60c6706d00c9bfc0b34b43bfa027115d
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0082-rt-reflection-RTFieldgetName/RTFieldGetName.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldGetName
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldGetName.java
+ *- @Title/Destination: Field.GetName() Returns the name of the field represented by this Field object.
+ *- @Brief:no:
+ * -#step1: 定义类FieldGetName。
+ * -#step2: 通过调用forName()方法加载类FieldGetModifiers。
+ * -#step3: 通过调用getField()、getDeclaredField()获取对应名称的成员变量。
+ * -#step4: 通过调用getName()方法获取对应字段，调用equals()方法进行判断字段值正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldGetName.java
+ *- @ExecuteClass: RTFieldGetName
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldGetName {
+    public static int num;
+    final String str = "aaa";
+}
+
+public class RTFieldGetName {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetName");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("str");
+            if (instance1.getName().equals("num") && instance2.getName().equals("str")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0083-rt-reflection-RTFieldgetType/RTFieldGetType.java b/test/testsuite/ouroboros/reflection_test/RT0083-rt-reflection-RTFieldgetType/RTFieldGetType.java
new file mode 100644
index 0000000000000000000000000000000000000000..18a6b4ed0b17c194c96ff160af10ef67e86efb79
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0083-rt-reflection-RTFieldgetType/RTFieldGetType.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldGetType
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldGetType.java
+ *- @Title/Destination: Field.GetType() Returns a Class object that identifies the declared type for the field
+ *                      represented by this Field object.
+ *- @Brief:no:
+ * -#step1: 定义类FieldGetType。
+ * -#step2: 调用forName()方法加载类FieldGetType。
+ * -#step3: 调用getField()、getDeclaredField()方法获取对应的成员变量。
+ * -#step4: 调用getType().getName()获取相应的类型,调用equals()方法与相应的类型比较，判断通过字段值正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldGetType.java
+ *- @ExecuteClass: RTFieldGetType
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldGetType {
+    public static short sNum;
+    final char aChar = '什';
+    private float fNum;
+}
+
+public class RTFieldGetType {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetType");
+            Field instance1 = cls.getField("sNum");
+            Field instance2 = cls.getDeclaredField("aChar");
+            Field instance3 = cls.getDeclaredField("fNum");
+            if (instance1.getType().getName().equals("short") && instance2.getType().getName().equals("char")
+                    && instance3.getType().getName().equals("float")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0084-rt-reflection-RTFieldset1/RTFieldSet1.java b/test/testsuite/ouroboros/reflection_test/RT0084-rt-reflection-RTFieldset1/RTFieldSet1.java
new file mode 100644
index 0000000000000000000000000000000000000000..16d4f576854615c007ce0bf2ddaaf97c3111fffd
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0084-rt-reflection-RTFieldset1/RTFieldSet1.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldSet1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldSet1.java
+ *- @Title/Destination: Field.set() sets the field on the specified object argument to the new value.
+ *- @Brief:no:
+ * -#step1: 定义类FieldSet1_a，定义类FieldSet1_a的子类FieldSet1。
+ * -#step2: 通过调用forName()方法加载类FieldSet1，调用newInstance()方法生成实例对象。
+ * -#step3: 通过调用getField()获取对应名称的成员变量，调用set()方法设置变量的值。
+ * -#step4: 通过调用get()方法获取对应字段的值并作比较，确认字段值正确。
+ * -#step5: 通过调用forName()方法加载类FieldSet1_a，调用newInstance()方法生成实例对象。
+ * -#step6: 通过调用getDeclaredField()获取对应名称的成员变量，调用set()方法设置变量的值。
+ * -#step7: 通过调用get()方法获取对应字段的值并作比较，确认字段值正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldSet1.java
+ *- @ExecuteClass: RTFieldSet1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldSet1_a {
+    public static String str = "aaa";
+    public int num2 = 2;
+    public int number = 5;
+    public static int num1;
+}
+
+class FieldSet1 extends FieldSet1_a {
+    public static String str = "bbb";
+    public int num = 1;
+    public int test = super.number + 1;
+    public static boolean aBoolean = true;
+    public char aChar;
+}
+
+public class RTFieldSet1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet1");
+            Object obj = cls.newInstance();
+            Field f1 = cls.getField("str");
+            Field f2 = cls.getField("num");
+            Field f3 = cls.getField("aBoolean");
+            Field f4 = cls.getField("aChar");
+            Field f5 = cls.getField("num1");
+            Field f6 = cls.getField("num2");
+            Field f7 = cls.getField("number");
+            f1.set(obj, "ccc");
+            f2.set(obj, 10);
+            f3.set(obj, false);
+            f4.set(obj, '国');
+            f5.set(obj, 20);
+            f6.set(obj, 30);
+            f7.set(obj, 40);
+            if (f1.get(obj).toString().equals("ccc") && (int) f2.get(obj) == 10 && !(boolean) f3.get(obj) && (int)
+                    f6.get(obj) == 30) {
+                if (f4.get(obj).toString().equals("国") && (int) f5.get(obj) == 20) {
+                    if ((int) cls.getField("test").get(obj) == 6) {
+                        Class cls1 = Class.forName("FieldSet1_a");
+                        Object instance1 = cls1.newInstance();
+                        Object p = cls1.getDeclaredField("str").get(instance1);
+                        if (p.toString().equals("aaa")) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0085-rt-reflection-RTFieldset2/RTFieldSet2.java b/test/testsuite/ouroboros/reflection_test/RT0085-rt-reflection-RTFieldset2/RTFieldSet2.java
new file mode 100644
index 0000000000000000000000000000000000000000..bbad654582cfab1f561f7e0b87a6afee0b6d873e
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0085-rt-reflection-RTFieldset2/RTFieldSet2.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldSet2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldSet2.java
+ *- @Title/Destination: If this Field object is inaccessible or final, throws IllegalAccessException; if the field
+ *                      doesn't exist in the class object, throws IllegalArgumentException; trying to set a non-static
+ *                      field on a null object throws NullPointerException.
+ *- @Brief:no:
+ * -#step1: 定义类FieldSet2_a的子类FieldSet2，含有私有变量。
+ * -#step2: 通过调用forName()方法加载类FieldSet2，调用newInstance()方法生成实例对象，通过调用 getField()获取对应名称的
+ *          成员变量，通过set()方法设值，抛出IllegalAccessException。
+ * -#step3: 定义类FieldSet2_a，通过调用forName()方法加载类FieldSet2和FieldSet2_b，调用newInstance()方法生成实例对象，
+ *          通过调用 getField()获取对应名称的成员变量，通过set()方法设值，抛出IllegalArgumentException。
+ * -#step4: 通过调用forName()方法加载类FieldSet2，调用getDeclaredField()方法获取对应名称的成员变量，通过set()方法设值，
+ *          抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldSet2.java
+ *- @ExecuteClass: RTFieldSet2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldSet2_a {
+    public static String str = "aaa";
+    public int num;
+}
+
+class FieldSet2 extends FieldSet2_a {
+    public static String str;
+    private int num = 1;
+    public boolean aBoolean = true;
+    public int num1 = 8;
+}
+
+class FieldSet2_b {
+    public int num = 18;
+}
+
+public class RTFieldSet2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet2");
+            Object obj = cls.newInstance();
+            Field field = cls.getDeclaredField("num");
+            field.set(obj, 10);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            try {
+                Class cls = Class.forName("FieldSet2");
+                Class cls1 = Class.forName("FieldSet2_b");
+                Object instance1 = cls1.newInstance();
+                Field f1 = cls.getDeclaredField("aBoolean");
+                f1.set(instance1, 10);
+            } catch (ClassNotFoundException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (InstantiationException e6) {
+                System.err.println(e6);
+                System.out.println(2);
+            } catch (NoSuchFieldException e7) {
+                System.err.println(e7);
+                System.out.println(2);
+            } catch (IllegalAccessException e8) {
+                System.err.println(e8);
+                System.out.println(2);
+            } catch (IllegalArgumentException e9) {
+                try {
+                    Class cls = Class.forName("FieldSet2");
+                    Field f2 = cls.getDeclaredField("aBoolean");
+                    f2.set(null, false);
+                } catch (ClassNotFoundException e10) {
+                    System.err.println(e10);
+                    System.out.println(2);
+                } catch (NoSuchFieldException e11) {
+                    System.err.println(e11);
+                    System.out.println(2);
+                } catch (IllegalAccessException e12) {
+                    System.err.println(e12);
+                    System.out.println(2);
+                } catch (NullPointerException e13) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0086-rt-reflection-RTFieldset3/RTFieldSet3.java b/test/testsuite/ouroboros/reflection_test/RT0086-rt-reflection-RTFieldset3/RTFieldSet3.java
new file mode 100644
index 0000000000000000000000000000000000000000..941cad32a40eb726e53b282ee28d5660e465c1c0
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0086-rt-reflection-RTFieldset3/RTFieldSet3.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldSet3
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldSet3.java
+ *- @Title/Destination: Setting on a final field throws IllegalAccessException.
+ *- @Brief:no:
+ * -#step1: 定义类FieldSet3_a，包含final修饰的变量。定义类FieldSet3_a的子类FieldSet3，包含final修饰的变量。
+ * -#step2: 通过调用forName()方法加载类FieldSet3，调用newInstance()方法生成实例对象。
+ * -#step3: 通过调用 getField()获取对应名称的成员变量，调用set()方法设置变量的值，抛出IllegalAccessException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldSet3.java
+ *- @ExecuteClass: RTFieldSet3
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldSet3_a {
+    public final static String str = "aaa";
+    public int num = 2;
+}
+
+class FieldSet3 extends FieldSet3_a {
+    public final int num = 1;
+}
+
+public class RTFieldSet3 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet3");
+            Object obj = cls.newInstance();
+            Field q1 = cls.getField("str");
+            Field q2 = cls.getField("num");
+            q1.set(obj, "bbb");
+            q2.set(obj, 10);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0087-rt-reflection-RTFieldset4/RTFieldSet4.java b/test/testsuite/ouroboros/reflection_test/RT0087-rt-reflection-RTFieldset4/RTFieldSet4.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb23dd2113d6cf314ba2bd8836f076827bf77645
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0087-rt-reflection-RTFieldset4/RTFieldSet4.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldSet4
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldSet4.java
+ *- @Title/Destination: To set a value with no corresponding object on a static field by reflection.
+ *- @Brief:no:
+ * -#step1: 定义含私有变量的类FieldSet4。
+ * -#step2: 通过调用forName()方法加载类FieldSet4，调用newInstance()方法生成实例对象。
+ * -#step3: 通过调用getDeclaredField()获取对应名称的成员变量，调用set()方法设置变量的值。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldSet4.java
+ *- @ExecuteClass: RTFieldSet4
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+class FieldSet4 {
+    public static String str;
+    private int num = 1;
+    public boolean aBoolean = true;
+    public int num1 = 8;
+}
+
+public class RTFieldSet4 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet4");
+            Object obj = cls.newInstance();
+            Field field = cls.getDeclaredField("str");
+            field.set(null, "aaa");
+            System.out.println(0);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0089-rt-reflection-RTFieldtoString/RTFieldToString.java b/test/testsuite/ouroboros/reflection_test/RT0089-rt-reflection-RTFieldtoString/RTFieldToString.java
new file mode 100644
index 0000000000000000000000000000000000000000..df8b4f1623eb106e4a5fdcb4f471cd4cd8cb039b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0089-rt-reflection-RTFieldtoString/RTFieldToString.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTFieldToString
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTFieldToString.java
+ *- @Title/Destination: Field.ToString() returns a string describing this Field.
+ *- @Brief:no:
+ * -#step1: 定义含私有变量的类FieldToGenericString<E, F>。
+ * -#step2: 通过调用forName()方法加载类FieldToGenericString，调用getField()、getDeclaredField()分别获取相应的成员。
+ * -#step3: 通过调用toString()()返回对象的string，确认字符串描述正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTFieldToString.java
+ *- @ExecuteClass: RTFieldToString
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+class FieldToString<E, F> {
+    public List<F> list1;
+    private List<E> list2;
+}
+
+public class RTFieldToString {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldToString");
+            Field instance1 = cls.getField("list1");
+            Field instance2 = cls.getDeclaredField("list2");
+            String q1 = instance1.toString();
+            String q2 = instance2.toString();
+            if (q1.equals("public java.util.List FieldToString.list1")
+                    && q2.equals("private java.util.List FieldToString.list2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java b/test/testsuite/ouroboros/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d233384e7ff491b294738d09ec658e6df0487f8
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTMethodGetAnnotation2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTMethodGetAnnotation2.java
+ *- @Title/Destination: Annotations are not acting at the runtime stage, and the annotation to obtain the target class
+ *                      method by reflection is null
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodGetAnnotation2类的运行时类clazz；
+ * -#step2: 以test3、int.class为参数，通过getDeclaredMethod()方法获取clazz的声明方法并记为method1；
+ * -#step3: 以test1为参数，通过getMethod()方法获取clazz的方法对象method2；
+ * -#step4: 以IF2_a.class为参数，通过getAnnotation()方法分别获取method1、method2的注解，其返回值均为null；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTMethodGetAnnotation2.java
+ *- @ExecuteClass: RTMethodGetAnnotation2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.CLASS)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.SOURCE)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class MethodGetAnnotation2 {
+    @IF2(i = 333, t = "MethodGetAnnotation")
+    public void test1() {
+    }
+
+    @IF2_a(c = 666, d = "Method")
+    void test3(int number) {
+    }
+}
+
+public class RTMethodGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetAnnotation2");
+            Method method1 = clazz.getDeclaredMethod("test3", int.class);
+            Method method2 = clazz.getMethod("test1");
+            if (method1.getAnnotation(IF2_a.class) == null && method2.getAnnotation(IF2.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java
new file mode 100644
index 0000000000000000000000000000000000000000..00c43b9dec2e4a51866f00b7bd0a3cd836a738a4
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTMethodGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTMethodGetDeclaredAnnotations2.java
+ *- @Title/Destination: When the target class method has the same name as its parent class method, it is obtained by
+ *                      reflection as the annotation of the method in the target class, not the method of its parent
+ *                      class
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodGetDeclaredAnnotations2_a类的运行时类clazz；
+ * -#step2: 以ii、String.class为参数，通过getMethod()方法获取clazz的方法对象并记为method1；
+ * -#step3: 以tt为参数，通过getDeclaredMethod()方法获取clazz的声明方法并记为method2；
+ * -#step4: 经判断得知method1.getDeclaredAnnotations()和method2.getDeclaredAnnotations()的返回值的长度均为0；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTMethodGetDeclaredAnnotations2.java
+ *- @ExecuteClass: RTMethodGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+
+class MethodGetDeclaredAnnotations2 {
+    @IFw2(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+
+    @IFw2_a(i_a = 666, t_a = "right1")
+    void tt(int number) {
+    }
+}
+
+class MethodGetDeclaredAnnotations2_a extends MethodGetDeclaredAnnotations2 {
+    public static void ii(String name) {
+    }
+
+    void tt() {
+    }
+}
+
+public class RTMethodGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetDeclaredAnnotations2_a");
+            Method method1 = clazz.getMethod("ii", String.class);
+            Method method2 = clazz.getDeclaredMethod("tt");
+            if (method1.getDeclaredAnnotations().length == 0 && method2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/RTMethodGetParameterCount.java b/test/testsuite/ouroboros/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/RTMethodGetParameterCount.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d892b02f8798badeae47df1640a73053a2a25f4
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/RTMethodGetParameterCount.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTMethodGetParameterCount
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTMethodGetParameterCount.java
+ *- @Title/Destination: Method.GetParameterCount() Returns the number of formal parameters (whether explicitly declared
+ *                      or implicitly declared or neither) for the executable represented by this object.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法获取MethodGetParameterCount2类的运行时类clazz；
+ * -#step2: 以test1为参数，通过getDeclaredMethod()方法获取clazz的声明方法并记为method1；
+ * -#step3: 通过getMethods()方法获取clazz的所有的方法对象并记为methods；
+ * -#step4: 经判断得知method.getParameterCount()的返回值为0，即method的参数个数为0；而methods[0].getParameterCount()的返
+ *          回值为9，即methods[0]的所有的参数个数为9；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTMethodGetParameterCount.java
+ *- @ExecuteClass: RTMethodGetParameterCount
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+class MethodGetParameterCount2 {
+    void test1() {
+    }
+
+    public void test2(String name, int number, char c, short s, float f, double d, long l, boolean b, byte bb) {
+    }
+}
+
+public class RTMethodGetParameterCount {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetParameterCount2");
+            Method method = clazz.getDeclaredMethod("test1");
+            Method[] methods = clazz.getMethods();
+            if (method.getParameterCount() == 0) {
+                if (methods[0].getParameterCount() == 9) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0097-rt-reflection-RTMethonisDefault/RTMethodIsDefault.java b/test/testsuite/ouroboros/reflection_test/RT0097-rt-reflection-RTMethonisDefault/RTMethodIsDefault.java
new file mode 100644
index 0000000000000000000000000000000000000000..e37e027b35791a5b582831b291f7ed3cdbd1ef0b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0097-rt-reflection-RTMethonisDefault/RTMethodIsDefault.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTMethodIsDefault
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTMethodIsDefault.java
+ *- @Title/Destination: Verify through reflection whether the default method in the interface.
+ *- @Brief:no:
+ * -#step1: 通过Class.forName()方法分别获取MethodIsDefault_A类、MethodIsDefault类的运行时类clazz1、clazz2；
+ * -#step2: 以run为参数，通过getMethod()方法分别获取clazz1、clazz2的方法对象并记为method1、method2；
+ * -#step3: 以ss、int.class为参数，通过getDeclaredMethod()方法获取clazz2的声明方法并记为method3；
+ * -#step4: 经isDefault()判断得知method1是默认的；
+ * -#step5: 经isDefault()判断得知method2、method3不是默认的；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTMethodIsDefault.java
+ *- @ExecuteClass: RTMethodIsDefault
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+interface MethodIsDefault_A {
+    default public void run() {
+        String i;
+    }
+}
+
+class MethodIsDefault implements MethodIsDefault_A {
+    public void run() {
+        String i = "abc";
+    }
+
+    void ss(int number) {
+    }
+}
+
+public class RTMethodIsDefault {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("MethodIsDefault_A");
+            Class clazz2 = Class.forName("MethodIsDefault");
+            Method method1 = clazz1.getMethod("run");
+            Method method2 = clazz2.getMethod("run");
+            Method method3 = clazz2.getDeclaredMethod("ss", int.class);
+            if (method1.isDefault()) {
+                if (!method2.isDefault() && !method3.isDefault()) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e) {
+            System.err.println(e);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/RTModifierParameterModifiers.java b/test/testsuite/ouroboros/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/RTModifierParameterModifiers.java
new file mode 100644
index 0000000000000000000000000000000000000000..0fb5f710a294c6b14f0b40033e2abbbd3ed9e25f
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/RTModifierParameterModifiers.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTModifierParameterModifiers
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTModifierParameterModifiers.java
+ *- @Title/Destination: Verify that the integer value of the parameter modifier for the modifier class is 16.
+ *                      Modifier.parameterModifiers() return an int value OR-ing together the source language modifiers
+ *                      that can be applied to a parameter.
+ *- @Brief:no:
+ * -#step1: 经判断得知Modifier.parameterModifiers()的返回值为16，即修饰符类的参数修饰符的整数值为16；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTModifierParameterModifiers.java
+ *- @ExecuteClass: RTModifierParameterModifiers
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Modifier;
+
+public class RTModifierParameterModifiers {
+    public static void main(String[] args) {
+        if (Modifier.parameterModifiers() == 16) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/RTParameterGetAnnotation2.java b/test/testsuite/ouroboros/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/RTParameterGetAnnotation2.java
new file mode 100644
index 0000000000000000000000000000000000000000..68fd28fe9e7d02c9cf0cbc5cb06eb2a5691259c6
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/RTParameterGetAnnotation2.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTParameterGetAnnotation2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTParameterGetAnnotation2.java
+ *- @Title/Destination: If expected annotation not exist, getAnnotation() return null; if the given annotation class is
+ *                      null, getAnnotation() throws NullPointerException;
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法，和有注解的方法。
+ * -#step2：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)获取注解，参数annotationClass类型与实际注解类型不匹配，确认返回为空。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)获取注解，参数annotationClass类型与实际注解类型不匹配，确认返回为空。
+ * -#step4：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)并且继续调用注解的方法，参数annotationClass类型与实际注解类型不匹配，
+ *          确认抛出NullPointerException异常。
+ * -#step5：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotation(Class<T> annotationClass)获取注解，参数annotationClass为null，确认抛出NullPointerException异常。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTParameterGetAnnotation2.java
+ *- @ExecuteClass: RTParameterGetAnnotation2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetAnnotation2 {
+    ParameterGetAnnotation2(@IF2(i = 222, t = "Parameter") int number) {
+    }
+
+    public void test1(@IF2_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+
+public class RTParameterGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotation2");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getAnnotation(IF2_a.class) == null && p2[0].getAnnotation(IF2.class) == null) {
+                p1[0].getAnnotation(IF2_a.class).c();
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        } catch (NullPointerException e2) {
+            try {
+                Class cls1 = Class.forName("ParameterGetAnnotation2");
+                Method method2 = cls1.getMethod("test1", int.class);
+                Parameter[] p3 = method2.getParameters();
+                p3[0].getAnnotation(null);
+                System.out.println(3);
+                return;
+            } catch (ClassNotFoundException e3) {
+                System.out.println(4);
+                return;
+            } catch (NoSuchMethodException e4) {
+                System.out.println(5);
+                return;
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(6);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java b/test/testsuite/ouroboros/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e7d1b19f6209e721e6648b622017ddedacb93ec
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTParameterGetAnnotationsByType2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTParameterGetAnnotationsByType2.java
+ *- @Title/Destination:Parameter.getAnnotationsByType() return an array of length zero if no expected annotation found;
+ *                     getAnnotationsByType(null) throws NullPointerException.
+ *- @Brief:no:
+ * -#step1: 自定义一个类，含有注解的构造方法，和不含注解的方法。
+ * -#step2：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为非对应的注解类型，对注解数组q1
+ *          调用q1[0].toString(), 检查会有ArrayIndexOutOfBoundsException抛出。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为非对应的注解类型，对注解数组q2
+ *          调用q2[0].toString(), 检查会有ArrayIndexOutOfBoundsException抛出。
+ * -#step4：通过调用getDeclaredConstructor获取自定义类的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getAnnotationsByType(Class<T> annotationClass)获取注解数组，annotationClass为null，检查会有
+ *          NullPointerException抛出。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTParameterGetAnnotationsByType2.java
+ *- @ExecuteClass: RTParameterGetAnnotationsByType2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF8 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF8_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetAnnotationsByType2 {
+    ParameterGetAnnotationsByType2(@IF8(i = 222, t = "Parameter") int number) {
+    }
+
+    public void test1(@IF8_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+
+public class RTParameterGetAnnotationsByType2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotationsByType2");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            Annotation[] q1 = p1[0].getAnnotationsByType(IF8_a.class);
+            Annotation[] q2 = p2[0].getAnnotationsByType(IF8.class);
+            q1[0].toString();
+            q2[0].toString();
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        } catch (ArrayIndexOutOfBoundsException e2) {
+            try {
+                Class cls1 = Class.forName("ParameterGetAnnotationsByType2");
+                Constructor cons1 = cls1.getDeclaredConstructor(int.class);
+                Parameter[] p3 = cons1.getParameters();
+                Annotation[] q3 = p3[0].getAnnotationsByType(null);
+                System.out.println(3);
+                return;
+            } catch (ClassNotFoundException e3) {
+                System.out.println(4);
+                return;
+            } catch (NoSuchMethodException e4) {
+                System.out.println(5);
+                return;
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(6);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java b/test/testsuite/ouroboros/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java
new file mode 100644
index 0000000000000000000000000000000000000000..6bc4b32db33a43f8b49d22d9e9027b78cbaaf8ac
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTParameterGetDeclaredAnnotations2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTParameterGetDeclaredAnnotations2.java
+ *- @Title/Destination: Parameter.getDeclaredAnnotations() returns annotations that are directly present on this element.
+ *                      This method ignores inherited annotations. If there are no annotations directly present on this
+ *                      element, the return value is an array of length 0.
+ *- @Brief:no:
+ * -#step1：创建一个类1，含有注解和无注解的构造方法和有注解方法。创建一个子类2继承类1，含有注解和无注解的构造方法和有注
+ *          解方法。创建子类3继承类2，重写构造方法和方法，均为无注解。
+ * -#step2：通过调用getDeclaredConstructor获取自定义类3的构造方法，通过调用getParameters()获取参数数组，调用
+ *          getDeclaredAnnotations()获取注解数组，检查数组长度为0。
+ * -#step3：通过调用getMethod获取自定义类的方法，通过调用getParameters()获取参数数组，调用getDeclaredAnnotations()获取注
+ *          解数组，检查数组长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTParameterGetDeclaredAnnotations2.java
+ *- @ExecuteClass: RTParameterGetDeclaredAnnotations2
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF4 {
+    int i() default 0;
+    String t() default "";
+}
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF4_a {
+    int c() default 0;
+    String d() default "";
+}
+
+class ParameterGetDeclaredAnnotations2 {
+    ParameterGetDeclaredAnnotations2() {
+    }
+
+    ParameterGetDeclaredAnnotations2(@IF4(i = 222, t = "Parameter") int number) {
+    }
+
+    public void test1(@IF4(i = 222, t = "Parameter") String name) {
+    }
+}
+
+class ParameterGetDeclaredAnnotations2_a extends ParameterGetDeclaredAnnotations2 {
+    ParameterGetDeclaredAnnotations2_a() {
+    }
+
+    ParameterGetDeclaredAnnotations2_a(@IF4_a(c = 666, d = "Happy new year") int number) {
+    }
+
+    public void test1(@IF4_a(c = 666, d = "Happy new year") String name) {
+    }
+}
+
+class ParameterGetDeclaredAnnotations2_b extends ParameterGetDeclaredAnnotations2_a {
+    ParameterGetDeclaredAnnotations2_b(int number) {
+    }
+
+    public void test1(String name) {
+    }
+}
+
+public class RTParameterGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotations2_b");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getDeclaredAnnotations().length == 0 && p2[0].getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/RTProxyGetProxyClass1.java b/test/testsuite/ouroboros/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/RTProxyGetProxyClass1.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1726d8b7bbca47af2812275a945a66825dedac4
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/RTProxyGetProxyClass1.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: RTProxyGetProxyClass1
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:RTProxyGetProxyClass1.java
+ *- @Title/Destination: Verify that there are more than 30 methods in the class that perform the proxy, and you can
+ *                     construct the proxy function normally.
+ *- @Brief:no:
+ * -#step1: 构造接口1有30个default方法，接口2继承接口1，接口3有1个方法。
+ * -#step2：创建参数1loader为接口1的类加载器，参数2interfaces为class数组，成员为接口1的class,接口2的class。
+ * -#step3：调用Proxy的静态方法getProxyClass(ClassLoader loader, Class<?>... interfaces)。
+ * -#step4：确认无异常抛出。
+ * -#step5：创建参数1loader为接口1的类加载器，参数2interfaces为class数组，成员为接口1的class,接口3的class。
+ * -#step6：调用Proxy的静态方法getProxyClass(ClassLoader loader, Class<?>... interfaces)。
+ * -#step7：确认无异常抛出。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RTProxyGetProxyClass1.java
+ *- @ExecuteClass: RTProxyGetProxyClass1
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Proxy;
+
+interface ProxyGetProxyClass1_1 {
+    default void test1() {
+    }
+
+    default void test2() {
+    }
+
+    default void test3() {
+    }
+
+    default void test4() {
+    }
+
+    default void test5() {
+    }
+
+    default void test6() {
+    }
+
+    default void test7() {
+    }
+
+    default void test8() {
+    }
+
+    default void test9() {
+    }
+
+    default void test10() {
+    }
+
+    default void test11() {
+    }
+
+    default void test12() {
+    }
+
+    default void test13() {
+    }
+
+    default void test14() {
+    }
+
+    default void test15() {
+    }
+
+    default void test16() {
+    }
+
+    default void test17() {
+    }
+
+    default void test18() {
+    }
+
+    default void test19() {
+    }
+
+    default void test20() {
+    }
+
+    default void test21() {
+    }
+
+    default void test22() {
+    }
+
+    default void test23() {
+    }
+
+    default void test24() {
+    }
+
+    default void test25() {
+    }
+
+    default void test26() {
+    }
+
+    default void test27() {
+    }
+
+    default void test28() {
+    }
+
+    default void test29() {
+    }
+
+    default void test30() {
+    }
+}
+
+interface ProxyGetProxyClass1_2 extends ProxyGetProxyClass1_1 {
+    default void test30() {
+    }
+}
+
+interface ProxyGetProxyClass1_3 {
+    default void test31() {
+    }
+}
+
+public class RTProxyGetProxyClass1 {
+    public static void main(String[] args) {
+        try {
+            Proxy.getProxyClass(ProxyGetProxyClass1_1.class.getClassLoader(), new Class[]{ProxyGetProxyClass1_1.class,
+                    ProxyGetProxyClass1_2.class});
+            Proxy.getProxyClass(ProxyGetProxyClass1_1.class.getClassLoader(), new Class[]{ProxyGetProxyClass1_1.class,
+                    ProxyGetProxyClass1_3.class});
+        } catch (IllegalArgumentException e) {
+            System.err.println(e);
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java b/test/testsuite/ouroboros/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c7b6a93f3b26995fd9c98a6abfe1dcb7f2ce6c7
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassGetDeclaredAnnotationNPE
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassGetDeclaredAnnotationNPE.java
+ *- @Title/Destination: Class.getDeclaredAnnotation(null) throws NullPointerException
+ *- @Brief:no:
+ *  -#step1: 定义内部类MyClass, 获取class MyClass。
+ *  -#step2：调用getDeclaredAnnotation(Class<A> annotationClass), annotationClass为Deprecated.class。
+ *  -#step3：确认无异常抛出。
+ *  -#step4：调用getDeclaredAnnotation(Class<A> annotationClass), annotationClass为null。
+ *  -#step5：确认抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassGetDeclaredAnnotationNPE.java
+ *- @ExecuteClass: ClassGetDeclaredAnnotationNPE
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.Annotation;
+
+public class ClassGetDeclaredAnnotationNPE {
+    public static void main(String argv[]) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = ClassGetDeclaredAnnotationNPE_1();
+        } catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetDeclaredAnnotationNPE_1() {
+        try {
+            Annotation a = MyClass.class.getDeclaredAnnotation(Deprecated.class);
+            a = MyClass.class.getDeclaredAnnotation(null);
+        } catch (NullPointerException e) {
+            return 0;
+        }
+        return 4;
+    }
+
+    @Deprecated
+    class MyClass extends MySuperClass {
+    }
+
+    @MyAnnotation
+    class MySuperClass {
+    }
+
+    @interface MyAnnotation {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java b/test/testsuite/ouroboros/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java
new file mode 100644
index 0000000000000000000000000000000000000000..a314b7bea76054b3f7452aa93fa70c170d6a38b9
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassIsAssignableFromNPE
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassIsAssignableFromNPE.java
+ *- @Title/Destination: Test isAssignableFrom( null ) throws NullPointerException of class.
+ *- @Brief:no:
+ *  -#step1: 定义一个int数组intArray，获取intArray的class。
+ *  -#step2：调用isAssignableFrom(Class<?> cls), cls为null。
+ *  -#step3：确认抛出NullPointerException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassIsAssignableFromNPE.java
+ *- @ExecuteClass: ClassIsAssignableFromNPE
+ *- @ExecuteArgs:
+ */
+
+public class ClassIsAssignableFromNPE {
+    public static void main(String argv[]) {
+        int result = 2; /* STATUS_FAILED */
+        try {
+            result = ClassIsAssignableFromNPE_1();
+        } catch (Exception e) {
+            System.out.println(e);
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassIsAssignableFromNPE_1() {
+        int result1 = 4; /* STATUS_FAILED */
+        int intArray[] = {1, 2, 3, 4, 5};
+        Class cl = null;
+        try {
+            intArray.getClass().isAssignableFrom(cl);
+        } catch (SecurityException e) {
+            return 1;
+        } catch (NullPointerException e) {
+            return 0;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java b/test/testsuite/ouroboros/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java
new file mode 100644
index 0000000000000000000000000000000000000000..d159bacd0083b3493880c4f191fa900b55dbabc5
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassGetAnnotationsByType
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassGetAnnotationsByType.java
+ * - @Title/Destination: Class have no Annotation and method have annotation, Class.getAnnotationsByType() return an
+ *                       array of length 0.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest0。
+ *  -#step2：获取class MyTargetTest0。
+ *  -#step3：调用getAnnotationsByType(Class<T> annotationClass)获取类型为MyTarget的注解数组。
+ *  -#step4：确认获取的注解数组个数大于0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: ClassGetAnnotationsByType.java
+ * - @ExecuteClass: ClassGetAnnotationsByType
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ClassGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetAnnotationsByType1() {
+        Class<MyTargetTest0> m;
+        try {
+            m = MyTargetTest0.class;
+            MyTarget[] Target = m.getAnnotationsByType(MyTarget.class);
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest0 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest0(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/ClassGetEnumConstants.java b/test/testsuite/ouroboros/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/ClassGetEnumConstants.java
new file mode 100644
index 0000000000000000000000000000000000000000..08eee426102ecacfe34d8bc69f1640eb5a3e41e5
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/ClassGetEnumConstants.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassGetEnumConstants
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassGetEnumConstants.java
+ * - @Title/Destination: Class getEnumConstants() return null when there is no enum in the class。
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest3。
+ *  -#step2：获取class MyTargetTest3。
+ *  -#step3：调用getEnumConstants()获取枚举类的元素。
+ *  -#step4：确认返回为空。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: ClassGetEnumConstants.java
+ * - @ExecuteClass: ClassGetEnumConstants
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ClassGetEnumConstants {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetEnumConstants1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetEnumConstants1() {
+        Class<MyTargetTest3> m;
+        try {
+            m = MyTargetTest3.class;
+            MyTargetTest3[] target = m.getEnumConstants();
+            if (target == null) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest3 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest3(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/ClassGetTypeParameters.java b/test/testsuite/ouroboros/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/ClassGetTypeParameters.java
new file mode 100644
index 0000000000000000000000000000000000000000..5070f8cf33d23b9881716aeb2c95d4be4e8bb910
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/ClassGetTypeParameters.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassGetTypeParameters
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassGetTypeParameters.java
+ * - @Title/Destination: Class.getTypeParameters() return an array of TypeVariable objects that represent the type
+ *                       variables declared by the generic declaration represented by this GenericDeclaration object,
+ *                       in declaration order.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest5。
+ *  -#step2：获取class MyTargetTest5。
+ *  -#step3：调用getTypeParameters()获取TypeVariable对象的一个数组。
+ *  -#step4：确认返回的数组的长度为0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: ClassGetTypeParameters.java
+ * - @ExecuteClass: ClassGetTypeParameters
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.TypeVariable;
+
+public class ClassGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassGetTypeParameters1() {
+        Class<MyTargetTest5> m;
+        try {
+            m = MyTargetTest5.class;
+            TypeVariable<Class<MyTargetTest5>>[] target = m.getTypeParameters();
+            if (target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest5 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest5(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0118-rt-reflection-ClassToGenericString/ClassToGenericString.java b/test/testsuite/ouroboros/reflection_test/RT0118-rt-reflection-ClassToGenericString/ClassToGenericString.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e2c56cd47d9893fee680aba2d8ba040519c0008
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0118-rt-reflection-ClassToGenericString/ClassToGenericString.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassToGenericString
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassToGenericString.java
+ * - @Title/Destination: Class.toGenericString() returns a string describing this Class, including information about
+ *                       modifiers and type parameters.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest5。
+ *  -#step2：获取class MyTargetTest5。
+ *  -#step3：调用toGenericString()获取描述此class的字符串。
+ *  -#step4：确认返回的描述正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: ClassToGenericString.java
+ * - @ExecuteClass: ClassToGenericString
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class ClassToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+
+        try {
+            result = ClassToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ClassToGenericString1() {
+        Class<MyTargetTest6> m;
+        try {
+            m = MyTargetTest6.class;
+            String str = m.toGenericString();
+            if ("class ClassToGenericString$MyTargetTest6".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest6 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest6(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java b/test/testsuite/ouroboros/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java
new file mode 100644
index 0000000000000000000000000000000000000000..06177357633ab5d33c042e93ef1e65b87e1a79f0
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorGetExceptionTypes.java
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ConstructorGetExceptionTypes.java
+ * - @Title/Destination: Constructor.getExceptionTypes() returns an array of length 0 if the executable declares no
+ *                       exceptions in its throws clause.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest02。
+ *  -#step2：通过调用getConstructor(Class[])从内部类MyTargetTest02中获取对应的构造方法。
+ *  -#step3：调用getExceptionTypes()获取抛出的异常类型的Class对象的数组。
+ *  -#step4：确认返回的数组长度是0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: ConstructorGetExceptionTypes.java
+ * - @ExecuteClass: ConstructorGetExceptionTypes
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+
+public class ConstructorGetExceptionTypes {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetExceptionTypes1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ConstructorGetExceptionTypes1() {
+        Constructor<MyTargetTest02> m;
+        try {
+            m = MyTargetTest02.class.getConstructor(new Class[]{ConstructorGetExceptionTypes.class, String.class});
+            Class<?>[] Target = m.getExceptionTypes();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest02 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest02(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java b/test/testsuite/ouroboros/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java
new file mode 100644
index 0000000000000000000000000000000000000000..f41f202d3b63346976c141fb6678ce219e860402
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorGetTypeParameters.java
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ConstructorGetTypeParameters.java
+ * - @Title/Destination: Constructor.getTypeParameters() returns an array of length 0 if the underlying generic
+ *                       declaration declares no type variables.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest03。
+ *  -#step2：通过调用getConstructor(Class[])从内部类MyTargetTest03中获取对应的构造方法。
+ *  -#step3：调用getTypeParameters()获取TypeVariable对象的数组。
+ *  -#step4：确认返回的数组长度是0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: ConstructorGetTypeParameters.java
+ * - @ExecuteClass: ConstructorGetTypeParameters
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.TypeVariable;
+
+public class ConstructorGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ConstructorGetTypeParameters1() {
+        Constructor<MyTargetTest03> m;
+        try {
+            m = MyTargetTest03.class.getConstructor(new Class[]{ConstructorGetTypeParameters.class, String.class});
+            TypeVariable<Constructor<MyTargetTest03>>[] Target = m.getTypeParameters();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest03 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest03(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/ConstructorToGenericString.java b/test/testsuite/ouroboros/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/ConstructorToGenericString.java
new file mode 100644
index 0000000000000000000000000000000000000000..7905d14e70746f9cbaa5e9fab202f07d9d25972b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/ConstructorToGenericString.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorToGenericString.java
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ConstructorToGenericString.java
+ * - @Title/Destination: Constructor.toGenericString() returns a string describing this Constructor, including type
+ *                       parameters.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest04。
+ *  -#step2：通过调用getConstructor(Class[])从内部类MyTargetTest04中获取对应的构造方法。
+ *  -#step3：调用toGenericString()获取描述此Field的字符串。
+ *  -#step4：确认返回的描述正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: ConstructorToGenericString.java
+ * - @ExecuteClass: ConstructorToGenericString
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+
+public class ConstructorToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int ConstructorToGenericString1() {
+        Constructor<MyTargetTest04> m;
+        try {
+            m = MyTargetTest04.class.getConstructor(new Class[]{ConstructorToGenericString.class, String.class});
+            String str = m.toGenericString();
+            if ("public ConstructorToGenericString$MyTargetTest04(ConstructorToGenericString,java.lang.String)"
+                    .equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest04 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest04(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0128-rt-reflection-FieldToGenericString/FieldToGenericString.java b/test/testsuite/ouroboros/reflection_test/RT0128-rt-reflection-FieldToGenericString/FieldToGenericString.java
new file mode 100644
index 0000000000000000000000000000000000000000..f298e81a07fdd4725e7ba69d9b925743770828d1
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0128-rt-reflection-FieldToGenericString/FieldToGenericString.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldToGenericString
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:FieldToGenericString.java
+ * - @Title/Destination: Field.toGenericString() returns a string describing this Field, including its generic type.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest10。
+ *  -#step2：通过调用getField()从内部类MyTargetTest10中获取home。
+ *  -#step3：调用toGenericString()获取描述此Field的字符串。
+ *  -#step4：确认返回的描述正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: FieldToGenericString.java
+ * - @ExecuteClass: FieldToGenericString
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+
+public class FieldToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int FieldToGenericString1() {
+        Field m;
+        try {
+            m = MyTargetTest10.class.getField("home");
+            String str = m.toGenericString();
+            if ("public java.lang.String FieldToGenericString$MyTargetTest10.home".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest10 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest10(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/MethodGetDefaultValue.java b/test/testsuite/ouroboros/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/MethodGetDefaultValue.java
new file mode 100644
index 0000000000000000000000000000000000000000..52147a561b59680b4c2a00d947480a718048cbba
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/MethodGetDefaultValue.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodGetDefaultValue
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:MethodGetDefaultValue.java
+ * - @Title/Destination: Method.getDefaultValue returns the default value for the annotation member represented by this
+ *                       Method instance. Returns null if no default is associated with the member。
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest13。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest13中获取MyTargetTest_1。
+ *  -#step3：调用getDefaultValue()获取注解成员的默认值。
+ *  -#step4：确认获取为null，无异常抛出。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: MethodGetDefaultValue.java
+ * - @ExecuteClass: MethodGetDefaultValue
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+public class MethodGetDefaultValue {
+    public static void main(String[] argv) {
+        int result = 2/* STATUS_FAILED */;
+        try {
+            result = MethodGetDefaultValueTypeNotPresent_1();
+        } catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodGetDefaultValueTypeNotPresent_1() {
+        try {
+            Method m = MyTargetTest13.class.getMethod("MyTargetTest_1");
+            Object a = m.getDefaultValue();
+        } catch (TypeNotPresentException e) {
+            return 3;
+        } catch (NoSuchMethodException e) {
+            return 4;
+        }
+        return 0;
+    }
+
+    @Target(ElementType.TYPE)
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        Class style() default String.class;
+    }
+
+    @MyTarget()
+    class MyTargetTest13 {
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/MethodGetParameterCount.java b/test/testsuite/ouroboros/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/MethodGetParameterCount.java
new file mode 100644
index 0000000000000000000000000000000000000000..48fb43227dbf78e3e302fcf74a747ed527715036
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/MethodGetParameterCount.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodGetParameterCount
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:MethodGetParameterCount.java
+ * - @Title/Destination: Method.getParameterCount() returns the number of formal parameters.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest14。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest14中获取MyTargetTest_1。
+ *  -#step3：调用getParameterCount()获取参数个数。
+ *  -#step4：确认返回的参数个数是0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: MethodGetParameterCount.java
+ * - @ExecuteClass: MethodGetParameterCount
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+public class MethodGetParameterCount {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+
+        try {
+            result = MethodGetParameterCount1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodGetParameterCount1() {
+        Method m;
+        try {
+            m = MyTargetTest14.class.getMethod("MyTargetTest_1");
+            int num = m.getParameterCount();
+            if (num == 0) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest14 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest14(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/MethodGetTypeParameters.java b/test/testsuite/ouroboros/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/MethodGetTypeParameters.java
new file mode 100644
index 0000000000000000000000000000000000000000..79927d5ad819d41572a22b34692c81227f712787
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/MethodGetTypeParameters.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodGetTypeParameters
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:MethodGetTypeParameters.java
+ * - @Title/Destination: Method.getTypeParameters() returns an array of TypeVariable objects.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest15。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest15中获取MyTargetTest_1。
+ *  -#step3：调用getTypeParameters()获取TypeVariable对象的数组。
+ *  -#step4：确认返回的数组长度是0。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: MethodGetTypeParameters.java
+ * - @ExecuteClass: MethodGetTypeParameters
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.TypeVariable;
+
+public class MethodGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodGetTypeParameters1() {
+        Method m;
+        try {
+            m = MyTargetTest15.class.getMethod("MyTargetTest_1");
+            TypeVariable<Method>[] Target = m.getTypeParameters();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest15 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest15(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0134-rt-reflection-MethodIsDefault/MethodIsDefault.java b/test/testsuite/ouroboros/reflection_test/RT0134-rt-reflection-MethodIsDefault/MethodIsDefault.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae03d59e5a57168551feda28ca388a8d3f7023fa
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0134-rt-reflection-MethodIsDefault/MethodIsDefault.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodIsDefault
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:MethodIsDefault.java
+ * - @Title/Destination: Method.isDefault() Returns true if this method is a default method。
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest16。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest16中获取MyTargetTest_1。
+ *  -#step3：调用isDefault()判断是否是default method。
+ *  -#step4：确认返回false。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: MethodIsDefault.java
+ * - @ExecuteClass: MethodIsDefault
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+public class MethodIsDefault {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodIsDefault1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodIsDefault1() {
+        Method m;
+        try {
+            m = MyTargetTest16.class.getMethod("MyTargetTest_1");
+            boolean flag = m.isDefault();
+            if (!flag) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest16 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest16(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0135-rt-reflection-MethodToGenericString/MethodToGenericString.java b/test/testsuite/ouroboros/reflection_test/RT0135-rt-reflection-MethodToGenericString/MethodToGenericString.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6bb1c2d754c85e4135abd5aa9ebcaed25dbf42d
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0135-rt-reflection-MethodToGenericString/MethodToGenericString.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodToGenericString
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:MethodToGenericString.java
+ * - @Title/Destination: Method.toGenericString() Returns a string describing this Method, including type parameters.
+ * - @Brief:no:
+ *  -#step1: 定义含注解的内部类MyTargetTest15。
+ *  -#step2：通过调用getMethod()从内部类MyTargetTest15中获取MyTargetTest_1。
+ *  -#step3：调用toGenericString()获取描述此Method的字符串。
+ *  -#step4：确认返回的描述正确。
+ * - @Expect: 0\n
+ * - @Priority: High
+ * - @Source: MethodToGenericString.java
+ * - @ExecuteClass: MethodToGenericString
+ * - @ExecuteArgs:
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+public class MethodToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+
+    public static int MethodToGenericString1() {
+        Method m;
+        try {
+            m = MyTargetTest17.class.getMethod("MyTargetTest_1");
+            String str = m.toGenericString();
+            if ("public void MethodToGenericString$MyTargetTest17.MyTargetTest_1()".equals(str)) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+
+    class MyTargetTest17 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest17(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java b/test/testsuite/ouroboros/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0401214e32cf48bbead0f5ed967930f1eaf6137
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ *- @TestCaseID: ReflectionAnnotationGetClass
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionAnnotationGetClass.java
+ *- @Brief:no:
+ * -#step1: Define an Annotation A0 and define Class Two has one annotation A0.
+ * -#step2: Get class by forName("Two"), call getAnnotations() of the get class.
+ * -#step3: Check the Class of get annotation is "class $Proxy0".
+ * -#step4: Get class by forName("java.lang.annotation.Documented"), call getAnnotations() of the get class.
+ * -#step5: Check the three Class of get annotation is "class $Proxy1", "class $Proxy2", "class $Proxy3".
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionAnnotationGetClass.java
+ *- @ExecuteClass: ReflectionAnnotationGetClass
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.util.Arrays;
+
+public class ReflectionAnnotationGetClass {
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            // Check point 1 : only 1 annotation in user-defined Class Two.
+            Annotation[] annotations1 = Class.forName("Two").getAnnotations();
+            if (annotations1.length == 1) {
+                if (annotations1[0].getClass().toString().startsWith("class $Proxy")) {
+                    result--;
+                }
+            }
+
+            // Check point 2 : 3 annotations in Class java.lang.annotation.Documented.
+            Annotation[] annotations2 = Class.forName("java.lang.annotation.Documented").getAnnotations();
+            String[] annoClazz = new String[annotations2.length];
+            for (int i = 0; i < annoClazz.length; i++) {
+                annoClazz[i] = annotations2[i].getClass().toString();
+            }
+            Arrays.sort(annoClazz);
+            if (annotations2.length == 3) {
+                if (annoClazz[0].startsWith("class $Proxy") && annoClazz[1]
+                        .startsWith("class $Proxy")
+                        && annoClazz[2].startsWith("class $Proxy")) {
+                    result--;
+                }
+            }
+        } catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+}
+
+@A0
+class Two {
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface A0 {
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/ClassInitClassNewInstance.java b/test/testsuite/ouroboros/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/ClassInitClassNewInstance.java
new file mode 100644
index 0000000000000000000000000000000000000000..33cb762bb639112e6d3c7d4a27b920d9396c6e0e
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/ClassInitClassNewInstance.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitClassNewInstance
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitClassNewInstance.java
+ *- @Title/Destination: When call Class.newInstance, class is initialized; when call other methods of Class, class is
+ *                      not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) to get the class One.
+ * -#step2: Call methods of Class except newInstance() and forName(), class One is not initialized.
+ * -#step3: call method newInstance(), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitClassNewInstance.java
+ *- @ExecuteClass: ClassInitClassNewInstance
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+
+public class ClassInitClassNewInstance {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+
+            /* Check point 1: no class initialization when calling following methods of Class
+             * not test clazz.cast(Object obj) because it success only when obj is an instance of One or Two,
+             * and need to call new One(), which result in Class initialization. */
+            clazz.asSubclass(clazz);
+            clazz.desiredAssertionStatus();
+            clazz.getAnnotation(A.class);
+            clazz.getAnnotations();
+            clazz.getAnnotationsByType(A.class);
+            clazz.getCanonicalName();
+            clazz.getClasses();
+            clazz.getClassLoader();
+            clazz.getComponentType();
+            clazz.getConstructor(String.class);
+            clazz.getConstructors();
+            clazz.getDeclaredAnnotation(A.class);
+            clazz.getDeclaredAnnotations();
+            clazz.getDeclaredAnnotationsByType(A.class);
+            clazz.getDeclaredClasses();
+            clazz.getDeclaredConstructor(String.class);
+            clazz.getDeclaredConstructors();
+            clazz.getDeclaredField("what");
+            clazz.getDeclaredFields();
+            clazz.getDeclaredMethod("testOne", String.class);
+            clazz.getDeclaredMethods();
+            clazz.getDeclaringClass();
+            clazz.getEnclosingClass();
+            clazz.getEnclosingConstructor();
+            clazz.getEnclosingMethod();
+            clazz.getEnumConstants();
+            clazz.getField("hi");
+            clazz.getFields();
+            clazz.getGenericInterfaces();
+            clazz.getGenericSuperclass();
+            clazz.getInterfaces();
+            clazz.getMethod("testOne", String.class);
+            clazz.getMethods();
+            clazz.getModifiers();
+            clazz.getName();
+            clazz.getPackage();
+            clazz.getProtectionDomain();
+            clazz.getSigners();
+            clazz.getSimpleName();
+            clazz.getSuperclass();
+            clazz.getTypeName();
+            clazz.getTypeParameters();
+            clazz.isAnnotation();
+            clazz.isAnnotationPresent(A.class);
+            clazz.isAnonymousClass();
+            clazz.isArray();
+            clazz.isAssignableFrom(clazz);
+            clazz.isEnum();
+            clazz.isInstance(new Object());
+            clazz.isInterface();
+            clazz.isLocalClass();
+            clazz.isMemberClass();
+            clazz.isPrimitive();
+            clazz.isSynthetic();
+            clazz.toString();
+            clazz.toGenericString();
+            clazz.getResource("hi");
+            clazz.getResourceAsStream("hi");
+
+            // Check point 2: when call newInstance, start class initialization
+            if (result.toString().compareTo("") == 0) {
+                clazz.newInstance();
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitClassNewInstance.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitClassNewInstance.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitClassNewInstance.result.append("One");
+    }
+
+    String what = "lala";
+    public String hi = "";
+    One() {
+    }
+
+    public One(String s) {
+        what = s;
+        System.out.println(s);
+    }
+
+    public int testOne(String a) {
+        System.out.println(a);
+        return 0;
+    }
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitClassNewInstance.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitClassNewInstance.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java b/test/testsuite/ouroboros/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ecf36cb3ff67f6d59abe4db90da0811c43b5cc0
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitConstructorNewInstance
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitConstructorNewInstance.java
+ *- @Title/Destination: When call Constructor.newInstance, class is initialized; when call other methods of Constructor,
+ *                      class is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getConstructor to get Constructor of
+ *          class One.
+ * -#step2: Call methods of Class except newInstance(), class One is not initialized.
+ * -#step3: call method newInstance(), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitConstructorNewInstance.java
+ *- @ExecuteClass: ClassInitConstructorNewInstance
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+
+public class ClassInitConstructorNewInstance {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Constructor constructor = clazz.getConstructor(String.class);
+            //check point 1: calling following methods, class not initialized
+            constructor.equals(constructor);
+            constructor.getAnnotation(A.class);
+            constructor.getDeclaredAnnotations();
+            constructor.getDeclaringClass();
+            constructor.getExceptionTypes();
+            constructor.getGenericExceptionTypes();
+            constructor.getGenericParameterTypes();
+            constructor.getModifiers();
+            constructor.getName();
+            constructor.getParameterAnnotations();
+            constructor.getParameterCount();
+            constructor.getParameterTypes();
+            constructor.hashCode();
+            constructor.isSynthetic();
+            constructor.isVarArgs();
+            constructor.toString();
+            constructor.toGenericString();
+
+            //check point 2: after call newInstance(), class initialized
+            if (result.toString().compareTo("") == 0) {
+                constructor.newInstance("newInstance");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitConstructorNewInstance.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitConstructorNewInstance.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitConstructorNewInstance.result.append("One");
+    }
+
+    String what = "lala";
+
+    One() {
+    }
+
+    public One(String s) {
+        what = s;
+    }
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitConstructorNewInstance.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitConstructorNewInstance.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java b/test/testsuite/ouroboros/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8aa335c0186d0d7996535c06bb694cd43aa3614
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetBooleanStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetBooleanStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getBoolean(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getBoolean(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetBooleanStatic.java
+ *- @ExecuteClass: ClassInitFieldGetBooleanStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetBooleanStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.getBoolean(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetBooleanStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("One");
+    }
+
+    public static boolean hiBoolean = false;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetBooleanStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java b/test/testsuite/ouroboros/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..cdb29c99bf73571277419829a50974840c2fed5f
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetByteStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetByteStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getByte(), class One is initialized
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getByte(null), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetByteStatic.java
+ *- @ExecuteClass: ClassInitFieldGetByteStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetByteStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.getByte(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetByteStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetByteStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetByteStatic.result.append("One");
+    }
+
+    public static byte hiByte = (byte) 0;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetByteStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetByteStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java b/test/testsuite/ouroboros/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..dad3cf02792e64ed7f008cb9a2fb335ea88b32f3
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetCharStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetCharStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getChar(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getChar(null), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetCharStatic.java
+ *- @ExecuteClass: ClassInitFieldGetCharStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetCharStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.getChar(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetCharStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetCharStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetCharStatic.result.append("One");
+    }
+
+    public static char hiChar = (char) 45;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetCharStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetCharStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java b/test/testsuite/ouroboros/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f32164557269368e44d44a55054a85eacb05a94
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetDoubleStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetDoubleStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getDouble(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getDouble(null), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetDoubleStatic.java
+ *- @ExecuteClass: ClassInitFieldGetDoubleStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetDoubleStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.getDouble(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetDoubleStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("One");
+    }
+
+    public static double hiDouble = 4.5;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetDoubleStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java b/test/testsuite/ouroboros/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c32d3de920a3f2e2cf9018638e7bc5d7215e22c
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetFloatStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetFloatStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getFloat(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getFloat(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetFloatStatic.java
+ *- @ExecuteClass: ClassInitFieldGetFloatStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetFloatStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.getFloat(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetFloatStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("One");
+    }
+    public static float hiFloat = 0.25f;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetFloatStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java b/test/testsuite/ouroboros/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..879f1980faca227278b1c7956b11b800532b652c
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetIntStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetIntStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getInt(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getInt(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetIntStatic.java
+ *- @ExecuteClass: ClassInitFieldGetIntStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetIntStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.getInt(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetIntStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetIntStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetIntStatic.result.append("One");
+    }
+    public static int hiInt = 0;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetIntStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetIntStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java b/test/testsuite/ouroboros/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..42b29b1b1def6ae1e2db3db9df544616075813d7
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetLongStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetLongStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getLong(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.getLong(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetLongStatic.java
+ *- @ExecuteClass: ClassInitFieldGetLongStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetLongStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.getLong(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetLongStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetLongStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetLongStatic.result.append("One");
+    }
+
+    public static long hiLong = 4859l;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetLongStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetLongStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java b/test/testsuite/ouroboros/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..17149980179e85fe1130042d0cceb50e977425ac
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetShortStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetShortStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.getShort(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class.
+ * -#step2: Call method f.getShort(null), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetShortStatic.java
+ *- @ExecuteClass: ClassInitFieldGetShortStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetShortStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.getShort(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetShortStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetShortStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetShortStatic.result.append("One");
+    }
+
+    public static short hiShort = 48;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetShortStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetShortStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/ClassInitFieldGetStatic.java b/test/testsuite/ouroboros/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/ClassInitFieldGetStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..20a7c4c95f1f0eb8d2efdd1ae729304ffec01537
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/ClassInitFieldGetStatic.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.get(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class.
+ * -#step2: Call method f.get(null), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetStatic.java
+ *- @ExecuteClass: ClassInitFieldGetStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        String fValue = "";
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                fValue = (String)f.get(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0 && fValue.compareTo("hi") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldGetStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldGetStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetStatic.result.append("One");
+    }
+
+    public static String hi = "hi";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldGetStatic.result.append("Two");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java b/test/testsuite/ouroboros/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java
new file mode 100644
index 0000000000000000000000000000000000000000..4285f3b7ee5e4722ac444e848afab2cc64e205b3
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldOtherMethod
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldOtherMethod.java
+ *- @Title/Destination: When f is a static field of class One and call method except setXX/getXX, class is not
+ *                      initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class.
+ * -#step2: Call method of Field except setXX/getXX, class One is not initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldOtherMethod.java
+ *- @ExecuteClass: ClassInitFieldOtherMethod
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldOtherMethod {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+
+            f.equals(f);
+            f.getAnnotation(B.class);
+            f.getAnnotationsByType(B.class);
+            f.getDeclaredAnnotations();
+            f.getDeclaringClass();
+            f.getGenericType();
+            f.getModifiers();
+            f.getName();
+            f.getType();
+            f.hashCode();
+            f.isEnumConstant();
+            f.isSynthetic();
+            f.toGenericString();
+            f.toString();
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldOtherMethod.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldOtherMethod.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldOtherMethod.result.append("One");
+    }
+
+    @B("hello")
+    public static String hi = "value";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldOtherMethod.result.append("|InterfaceA|").toString();
+}
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@interface B {
+    String value() default "hi";
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldOtherMethod.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java b/test/testsuite/ouroboros/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..b23f35fa291833bc9eeee6ab2978fb14fe5ba2c1
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetBooleanStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetBooleanStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setBoolean(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setBoolean(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetBooleanStatic.java
+ *- @ExecuteClass: ClassInitFieldSetBooleanStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetBooleanStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.setBoolean(null, false);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetBooleanStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("One");
+    }
+
+    String what = "lala";
+    public static boolean hiBoolean = false;
+    One() {
+    }
+
+    public One(String s) {
+        what = s;
+        System.out.println(s);
+    }
+
+    public int testOne(String a) {
+        System.out.println(a);
+        return 0;
+    }
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetBooleanStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java b/test/testsuite/ouroboros/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..4078e36fb6f0ed4db3383575f4f5d8b301b14b1b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetByteStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetByteStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setByte(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setByte(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetByteStatic.java
+ *- @ExecuteClass: ClassInitFieldSetByteStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetByteStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.setByte(null, (byte) 1);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetByteStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetByteStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetByteStatic.result.append("One");
+    }
+
+    public static byte hiByte = (byte) 0;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetByteStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetByteStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java b/test/testsuite/ouroboros/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..50e39f7f5437f775d7dc935ee627b4f0cd967005
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetCharStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetCharStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setChar(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setChar(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetCharStatic.java
+ *- @ExecuteClass: ClassInitFieldSetCharStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetCharStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.setChar(null, (char) 1);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetCharStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetCharStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetCharStatic.result.append("One");
+    }
+
+    public static char hiChar = (char) 45;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetCharStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetCharStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java b/test/testsuite/ouroboros/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..6fee1c2803ebbeb705514af3994f31044162e1ed
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetDoubleStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetDoubleStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setDouble(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setDouble(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetDoubleStatic.java
+ *- @ExecuteClass: ClassInitFieldSetDoubleStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetDoubleStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.setDouble(null, 0.2589);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetDoubleStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("One");
+    }
+
+    public static double hiDouble = 4.5;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetDoubleStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java b/test/testsuite/ouroboros/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..a5d40ac789e39c19953e76fd83c630fa91918d65
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetFloatStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetFloatStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setFloat(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setFloat(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetFloatStatic.java
+ *- @ExecuteClass: ClassInitFieldSetFloatStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetFloatStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.setFloat(null, 0.2589f);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetFloatStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("One");
+    }
+
+    public static float hiFloat = 0.25f;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetFloatStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java b/test/testsuite/ouroboros/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..96d6a6da4b74c315697409ab99717425a1e4f238
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetIntStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetIntStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setInt(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setInt(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetIntStatic.java
+ *- @ExecuteClass: ClassInitFieldSetIntStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetIntStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.setInt(null, 25);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetIntStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetIntStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetIntStatic.result.append("One");
+    }
+
+    public static int hiInt = 0;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetIntStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetIntStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java b/test/testsuite/ouroboros/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..fbe06f9892915d84456b748b3b4f99b4088c95ce
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetLongStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetLongStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setLong(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setLong(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetLongStatic.java
+ *- @ExecuteClass: ClassInitFieldSetLongStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetLongStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.setLong(null, 25l);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetLongStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetLongStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetLongStatic.result.append("One");
+    }
+
+    public static long hiLong = 4859l;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetLongStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetLongStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java b/test/testsuite/ouroboros/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..452454d594e969eff339def180b2b66c6a651e08
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetShortStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetShortStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.setShort(), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One.
+ * -#step2: Call method f.setShort(null, newValue), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetShortStatic.java
+ *- @ExecuteClass: ClassInitFieldSetShortStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetShortStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.setShort(null, (short) 25);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetShortStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetShortStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetShortStatic.result.append("One");
+    }
+
+    public static short hiShort = 48;
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetShortStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetShortStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/ClassInitFieldSetStatic.java b/test/testsuite/ouroboros/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/ClassInitFieldSetStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..e97bc11512b615891ff6f00ed3f1ad3d1ccc8e35
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/ClassInitFieldSetStatic.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetStatic.java
+ *- @Title/Destination: When f is a static field of class One and call f.set(), class One is initialized
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getField to get a static field f of class
+ *          One
+ * -#step2: Call method f.set(null, newValue), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetStatic.java
+ *- @ExecuteClass: ClassInitFieldSetStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.set(null, "what");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitFieldSetStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitFieldSetStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetStatic.result.append("One");
+    }
+
+    public static String hi = "hi";
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitFieldSetStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java b/test/testsuite/ouroboros/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java
new file mode 100644
index 0000000000000000000000000000000000000000..02ca173673f35a7a8d97146579ad532cea673463
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitMethodInvokeStatic
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitMethodInvokeStatic.java
+ *- @Title/Destination: When m is a static method of class One and call m.invoke(null, args), class One is initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("One" , false, One.class.getClassLoader()) and clazz.getDeclaredMethod to get a static method
+ *          m of class One.
+ * -#step2: Call methods of Method except invoke(), class One is not initialized.
+ * -#step3: Call method invoke(), class One is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitMethodInvokeStatic.java
+ *- @ExecuteClass: ClassInitMethodInvokeStatic
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+
+public class ClassInitMethodInvokeStatic {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Method m = clazz.getDeclaredMethod("testOne", String.class);
+            // Check point 1: calling following methods, class not initialized.
+            m.equals(m);
+            m.getAnnotation(A.class);
+            m.getDeclaredAnnotations();
+            m.getDeclaringClass();
+            m.getDefaultValue();
+            m.getExceptionTypes();
+            m.getGenericExceptionTypes();
+            m.getGenericParameterTypes();
+            m.getGenericReturnType();
+            m.getModifiers();
+            m.getName();
+            m.getParameterAnnotations();
+            m.getParameterCount();
+            m.getParameterTypes();
+            m.getReturnType();
+            m.getTypeParameters();
+            m.hashCode();
+            m.isBridge();
+            m.isDefault();
+            m.isSynthetic();
+            m.isVarArgs();
+            m.toString();
+            m.toGenericString();
+
+            // Check point 2: after newInstance, class initialized.
+            if (result.toString().compareTo("") == 0) {
+                m.invoke(null, "hi");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+@A
+class Super {
+    static {
+        ClassInitMethodInvokeStatic.result.append("Super");
+    }
+}
+
+interface InterfaceSuper {
+    String a = ClassInitMethodInvokeStatic.result.append("|InterfaceSuper|").toString();
+}
+
+@A(i = 1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitMethodInvokeStatic.result.append("One");
+    }
+
+    public static int testOne(String a) {
+        return 0;
+    }
+}
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitMethodInvokeStatic.result.append("|InterfaceA|").toString();
+}
+
+class Two extends One {
+    static {
+        ClassInitMethodInvokeStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java b/test/testsuite/ouroboros/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ff97d59d333a0791ef74a1e29c5319f877abc7f
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetBooleanInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetBooleanInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getBoolean(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getBoolean(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetBooleanInterface.java
+ *- @ExecuteClass: ClassInitFieldGetBooleanInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetBooleanInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.getBoolean(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldGetBooleanInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldGetBooleanInterface.result.append("One").toString();
+    boolean hiBoolean = false;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldGetBooleanInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetBooleanInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java b/test/testsuite/ouroboros/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b2f853c6cc0a7ce4881293ea5f65092e18ad971
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetByteInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetByteInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getByte(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getByte(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetByteInterface.java
+ *- @ExecuteClass: ClassInitFieldGetByteInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetByteInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.getByte(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldGetByteInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldGetByteInterface.result.append("One").toString();
+    byte hiByte = (byte) 1;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldGetByteInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetByteInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java b/test/testsuite/ouroboros/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..52e50ddf6d98043dbe47d7d03e37a06e2da715ba
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetCharInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetCharInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getChar(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getChar(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetCharInterface.java
+ *- @ExecuteClass: ClassInitFieldGetCharInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetCharInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.getChar(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldGetCharInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldGetCharInterface.result.append("One").toString();
+    char hiChar = (char) 45;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldGetCharInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetCharInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java b/test/testsuite/ouroboros/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..645164dc14aad22ba030de6c9866f764c4394b97
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetDoubleInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetDoubleInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getDouble(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getDouble(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetDoubleInterface.java
+ *- @ExecuteClass: ClassInitFieldGetDoubleInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetDoubleInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.getDouble(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldGetDoubleInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldGetDoubleInterface.result.append("One").toString();
+    double hiDouble = 0.1532;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldGetDoubleInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetDoubleInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java b/test/testsuite/ouroboros/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..474e0656699ac58368b53464f7d302f7b0da80ac
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetFloatInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetFloatInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getFloat(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getFloat(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetFloatInterface.java
+ *- @ExecuteClass: ClassInitFieldGetFloatInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetFloatInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.getFloat(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldGetFloatInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldGetFloatInterface.result.append("One").toString();
+    float hiFloat = 0.25f;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldGetFloatInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetFloatInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/ClassInitFieldGetInterface.java b/test/testsuite/ouroboros/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/ClassInitFieldGetInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..8186af1692a3ce77533dc6643ce1f0c6175a90f3
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/ClassInitFieldGetInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.get(), OneInterface is initialized, it's
+ *                      parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.get(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetInterface.java
+ *- @ExecuteClass: ClassInitFieldGetInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.get(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldGetInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldGetInterface.result.append("One").toString();
+    String hi = "hiField";
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldGetInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java b/test/testsuite/ouroboros/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..421716fa2b5dd5d0175bc094ffb23349fbd748c3
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetIntInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetIntInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getInt(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getInt(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetIntInterface.java
+ *- @ExecuteClass: ClassInitFieldGetIntInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetIntInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.getInt(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldGetIntInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldGetIntInterface.result.append("One").toString();
+    int hiInt = 125;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldGetIntInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetIntInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java b/test/testsuite/ouroboros/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..201e13e7b7fc1298a9bb18cdcc7fbbc2a158cb78
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetLongInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetLongInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getLong(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getLong(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetLongInterface.java
+ *- @ExecuteClass: ClassInitFieldGetLongInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetLongInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.getLong(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldGetLongInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldGetLongInterface.result.append("One").toString();
+    long hiLong = 4859l;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldGetLongInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetLongInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java b/test/testsuite/ouroboros/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..9945da1be14db5149f1514cb52504e2f02ea45e7
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldGetShortInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldGetShortInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.getShort(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.getShort(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldGetShortInterface.java
+ *- @ExecuteClass: ClassInitFieldGetShortInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldGetShortInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.getShort(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldGetShortInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldGetShortInterface.result.append("One").toString();
+    short hiShort = 14;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldGetShortInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldGetShortInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java b/test/testsuite/ouroboros/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..b652be0b2ef4080b69e0ecfd159bf47a1a376670
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldOtherMethodInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldOtherMethodInterface.java
+ *- @Title/Destination: When f is a field of of interface OneInterface and call method except setXX/getXX, class is not
+ *                      initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method of Field except setXX/getXX, class One is not initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldOtherMethodInterface.java
+ *- @ExecuteClass: ClassInitFieldOtherMethodInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldOtherMethodInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+
+            f.equals(f);
+            f.getAnnotation(A.class);
+            f.getAnnotationsByType(A.class);
+            f.getDeclaredAnnotations();
+            f.getDeclaringClass();
+            f.getGenericType();
+            f.getModifiers();
+            f.getName();
+            f.getType();
+            f.hashCode();
+            f.isEnumConstant();
+            f.isSynthetic();
+            f.toGenericString();
+            f.toString();
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldOtherMethodInterface.result.append("Super").toString();
+}
+
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldOtherMethodInterface.result.append("One").toString();
+    @A
+    short hi = 14;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldOtherMethodInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldOtherMethodInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java b/test/testsuite/ouroboros/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1aa1f485747cdeab6727727c551d08a01e9f4e5
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetBooleanInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetBooleanInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setBoolean(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setBoolean(null, true), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetBooleanInterface.java
+ *- @ExecuteClass: ClassInitFieldSetBooleanInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetBooleanInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.setBoolean(null, true);
+            }
+        } catch (IllegalAccessException e) {
+            result.append("IllegalAccessException");
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldSetBooleanInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldSetBooleanInterface.result.append("One").toString();
+    boolean hiBoolean = false;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldSetBooleanInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetBooleanInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java b/test/testsuite/ouroboros/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4be3645a1b0fc388ef1044b2c682572f8d7427d
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetByteInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetByteInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setByte(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setByte(null, (byte)0), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetByteInterface.java
+ *- @ExecuteClass: ClassInitFieldSetByteInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetByteInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.setByte(null, (byte) 0);
+            }
+        } catch (IllegalAccessException e) {
+            result.append("IllegalAccessException");
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldSetByteInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldSetByteInterface.result.append("One").toString();
+    byte hiByte = (byte) 1;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldSetByteInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetByteInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java b/test/testsuite/ouroboros/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..fce527c853a77c036882a4f89941758a79d96bfa
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetFloatInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetFloatInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setFloat(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setFloat(null, 0.654f), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetFloatInterface.java
+ *- @ExecuteClass: ClassInitFieldSetFloatInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetFloatInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.setFloat(null, 0.654f);
+            }
+        } catch (IllegalAccessException e) {
+            result.append("IllegalAccessException");
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldSetFloatInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldSetFloatInterface.result.append("One").toString();
+    float hiFloat = 0.25f;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldSetFloatInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetFloatInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/ClassInitFieldSetInterface.java b/test/testsuite/ouroboros/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/ClassInitFieldSetInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..744d79cf4bf06bc8b466548f91744814105df884
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/ClassInitFieldSetInterface.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.set(), OneInterface is initialized, it's
+ *                      parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.set(null, newValue), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetInterface.java
+ *- @ExecuteClass: ClassInitFieldSetInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.set(null, "newString");
+            }
+        } catch (IllegalAccessException e) {
+            result.append("IllegalAccessException");
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldSetInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldSetInterface.result.append("One").toString();
+    String hi = "hiField";
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldSetInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java b/test/testsuite/ouroboros/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f509b2333f1cc74a2e116992c5b9937942f86c2
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetIntInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetIntInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setInt(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setInt(null, 98), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetIntInterface.java
+ *- @ExecuteClass: ClassInitFieldSetIntInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetIntInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.setInt(null, 98);
+            }
+        } catch (IllegalAccessException e) {
+            result.append("IllegalAccessException");
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldSetIntInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldSetIntInterface.result.append("One").toString();
+    int hiInt = 125;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldSetIntInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetIntInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java b/test/testsuite/ouroboros/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..54df08b163dd4ffb4b64ae6b83b97d3fda4fe748
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetLongInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetLongInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setLong(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setLong(null, 7456l), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetLongInterface.java
+ *- @ExecuteClass: ClassInitFieldSetLongInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetLongInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.setLong(null, 7456l);
+            }
+        } catch (IllegalAccessException e) {
+            result.append("IllegalAccessException");
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldSetLongInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldSetLongInterface.result.append("One").toString();
+    long hiLong = 4859l;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldSetLongInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetLongInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java b/test/testsuite/ouroboros/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf81e8d805a9e912f4d1fa7cd04840ef87132b6d
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetShortInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetShortInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setShort(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setShort(null, 124), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetShortInterface.java
+ *- @ExecuteClass: ClassInitFieldSetShortInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetShortInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.setShort(null, (short) 124);
+            }
+        } catch (IllegalAccessException e) {
+            result.append("IllegalAccessException");
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldSetShortInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldSetShortInterface.result.append("One").toString();
+    short hiShort = 14;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldSetShortInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetShortInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java b/test/testsuite/ouroboros/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8533a7113187ea5ca3d9060c17aca51f5284c14
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitMethodInvokeInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitMethodInvokeInterface.java
+ *- @Title/Destination: When m is a static method of interface OneInterface and call m.invoke(), OneInterface is
+ *                      initialized, it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getDeclaredMethod to get
+ *          a static method m of OneInterface.
+ * -#step2: Call methods of Method except invoke(), class One is not initialized.
+ * -#step3: Call method invoke(), class One is initialized
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitMethodInvokeInterface.java
+ *- @ExecuteClass: ClassInitMethodInvokeInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Method;
+
+public class ClassInitMethodInvokeInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Method m = clazz.getDeclaredMethod("runInterface", String.class);
+            //check point 1: calling following methods, class not initialized
+            m.equals(m);
+            m.getAnnotation(A.class);
+            m.getDeclaredAnnotations();
+            m.getDeclaringClass();
+            m.getDefaultValue();
+            m.getExceptionTypes();
+            m.getGenericExceptionTypes();
+            m.getGenericParameterTypes();
+            m.getGenericReturnType();
+            m.getModifiers();
+            m.getName();
+            m.getParameterAnnotations();
+            m.getParameterCount();
+            m.getParameterTypes();
+            m.getReturnType();
+            m.getTypeParameters();
+            m.hashCode();
+            m.isBridge();
+            m.isDefault();
+            m.isSynthetic();
+            m.isVarArgs();
+            m.toString();
+            m.toGenericString();
+
+            //check point 2: after newInstance, class initialized
+            if (result.toString().compareTo("") == 0) {
+                m.invoke(null, "hi");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneRunInterface") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitMethodInvokeInterface.result.append("Super").toString();
+}
+
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitMethodInvokeInterface.result.append("One").toString();
+    @A
+    static void runInterface(String a) {
+        ClassInitMethodInvokeInterface.result.append("RunInterface");
+    }
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitMethodInvokeInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitMethodInvokeInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0184-rt-reflection-MethodTest/MethodTest.java b/test/testsuite/ouroboros/reflection_test/RT0184-rt-reflection-MethodTest/MethodTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..08d3d2d78ae7956209bddb1eb63c5cf01814cb27
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0184-rt-reflection-MethodTest/MethodTest.java
@@ -0,0 +1,449 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodTest.java
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:MethodTest.java
+ *- @Title/Destination: for the same method, different Method object is return when call following API twice: Class.getMethods(), Class.getEnclosingMethod(), Class.getDeclaredMethods(), Class.getMethod(String name, Class<?>... parameterTypes), Class.getDeclaredMethod(String name, Class<?>... parameterTypes). tests method with different return return type, parameter type, modifier, annotation and declaring class
+ *- @Brief:no: see steps of separate test cases
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source: MethodTest.java
+ *- @ExecuteClass: MethodTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+public class MethodTest {
+    /**
+     * Verify that for the same method, different Method object is return when call following API twice:
+     * - Class.getMethods(),
+     * - Class.getEnclosingMethod(),
+     * - Class.getDeclaredMethods(),
+     * - Class.getMethod(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredMethod(String name, Class<?>... parameterTypes),
+     * if any Method failed the check, will print error message including testcase and method name;
+     * after all check is pass, casePassed will be increased;
+     */
+    private static void classAllMethodTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getMethods()
+        Method[] methods1 = clazz.getMethods();
+        Method[] methods2 = clazz.getMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 2. Class.getMethod(String name)
+            Method m1 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed");
+            }
+        }
+
+        // checkpoint 3. Class.getDeclaredMethods()
+        methods1 = clazz.getDeclaredMethods();
+        methods2 = clazz.getDeclaredMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 4. Class.getDeclaredMethod(String name)
+            Method m1 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for declared method");
+            }
+        }
+
+        // checkpoint 5. Class.getEnclosingMethod()
+        if (clazz.getEnclosingMethod() != null) {
+            Method m1 = clazz.getEnclosingMethod();
+            Method m2 = clazz.getEnclosingMethod();
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for Enclosing method");
+            }
+        }
+
+        casesPassed++;
+    }
+
+    private static void checkMethods(Method[] methods1, Method[] methods2) {
+        for (Method m1: methods1) {
+            for (Method m2: methods2) {
+                // only when modifers and class and name is same, two Method object is for same method
+                if(m1.toString().equals(m2.toString())) {
+                    if (singleMethodCheck(m1, m2) != 3) {
+                        System.out.println(m1.getName()+" failed in checkMethods");
+                    }
+                }
+            }
+        }
+    }
+
+    private static int singleMethodCheck(Method m1, Method m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    static int casesPassed = 0;
+
+    public static void main(String [] args) {
+        method01();
+        method02();
+        method03();
+        method04();
+        method05();
+        method06();
+        method07();
+        method08();
+        method09();
+        method10();
+        method11();
+        System.out.println(casesPassed - 11);
+    }
+
+    /**
+     *- @TestCaseID: method01
+     *- @Title/Destination: for same method in pre-defined class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. all test in classAllMethodTest() passed for pre-defined class java.lang.Thread
+     */
+    private static void method01() {
+        try {
+            classAllMethodTest(Class.forName("java.lang.Thread"), "method01");
+        } catch (Exception e) {
+            System.out.println("Case method01 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method02
+     *- @Title/Destination: for same method in user-defined class with different return_type/parameter_type/modifier/annotation, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. classAllMethodTest() passed for methods with different return type and parameter type
+     * -#step2. classAllMethodTest() passed for methods with different access modifier: public, private, protected
+     * -#step3. classAllMethodTest() passed for methods with different modifier: transient, final, volatile, static
+     * -#step4. classAllMethodTest() passed for methods with annotation
+     */
+    private static void method02() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod02"), "method02");
+        } catch (Exception e) {
+            System.out.println("Case method02 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method03
+     *- @Title/Destination: check all test in classAllMethodTest passed for methods in interface
+     *- @Brief:no:
+     * -step1. check all test in classAllMethodTest passed for methods in interface
+     */
+    private static void method03() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod03"), "method03");
+        } catch (Exception e) {
+            System.out.println("Case method03 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method04
+     *- @Title/Destination: for same method in abstract class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in abstract class
+     */
+    private static void method04() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod04"), "method04");
+        } catch (Exception e) {
+            System.out.println("Case method04 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method05
+     *- @Title/Destination: for same method in anonymous class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. get the class instance of anonymous class
+     * -#step2. check all test in classAllMethodTest passed for methods in anonymous class
+     */
+    private static void method05() {
+        try {
+            // step 1
+            Class clazz = Class.forName("MethodTest");
+            MethodTest mainClass = new MethodTest();
+            Field method = clazz.getDeclaredField("testMethod05");
+
+            classAllMethodTest(method.get(mainClass).getClass(), "method05");
+        } catch (Exception e) {
+            System.out.println("Case method05 failed with exception" + e);
+        }
+    }
+
+    private Runnable testMethod05 = new Runnable() {
+        private final synchronized int intRunnable() {
+            return 1;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    /**
+     *- @TestCaseID: method06
+     *- @Title/Destination: for same method in local class(class in a function), certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in local class
+     */
+    private static void method06() {
+        class TestMethod06 {
+            private final int intLocalMethod() {
+                return 9;
+            }
+            public synchronized String stringLocal() {
+                return "a fake behind the fear";
+            }
+        }
+        try {
+            classAllMethodTest(Class.forName("MethodTest$1TestMethod06"), "method06");
+        } catch (Exception e) {
+            System.out.println("Case method06 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method07
+     *- @Title/Destination: for same method in inner class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in inner class
+     */
+    private static void method07() {
+        try {
+            classAllMethodTest(Class.forName("MethodTest$TestMethod07"), "method07");
+        } catch (Exception e) {
+            System.out.println("Case method07 failed with exception" + e);
+        }
+    }
+
+    class TestMethod07 {
+        private char charInnerMethod(int a, double... b) {
+            return 'l';
+        }
+        final public double doubleInnerMethod() {
+            return 1988.0416;
+        }
+    }
+
+    /**
+     *- @TestCaseID: method08
+     *- @Title/Destination: for same method in enum class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in enum class
+     */
+    private static void method08() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod08"), "method08");
+        } catch (Exception e) {
+            System.out.println("Case method08 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method09
+     *- @Title/Destination: for same method in parent class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in parent class
+     */
+    private static void method09() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod09"), "method09");
+        } catch (Exception e) {
+            System.out.println("Case method09 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method10
+     *- @Title/Destination: for same method in child class with implemented interface, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in child class with implemented interface
+     */
+    private static void method10() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod10"), "method10");
+        } catch (Exception e) {
+            System.out.println("Case method10 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method11
+     *- @Title/Destination: for same method in interface implemented by another class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in interface implemented by another class
+     */
+    private static void method11() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod11"), "method11");
+        } catch (Exception e) {
+            System.out.println("Case method11 failed with exception" + e);
+        }
+    }
+}
+
+class TestMethod02 {
+    // step1
+    void voidMethod() {}
+    boolean booleanMethod() {
+        return true;
+    }
+    byte byteMethod() {
+        return (byte)1;
+    }
+    short shortMethod() {
+        return (short)2;
+    }
+    int intMethod() {
+        return 3;
+    }
+    long longMethod() {
+        return 4l;
+    }
+    char charMethod() {
+        return 'a';
+    }
+    float floatMethod() {
+        return 0.9f;
+    }
+    double doubleMethod() {
+        return 0.416;
+    }
+    String stringMethod() {
+        return "The queerest of the queer";
+    }
+    Runnable[] rArrayMethod() {
+        return null;
+    }
+    boolean[][][][][][][] booleanArray7Method() {
+        return new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    }
+    String[][][] stringArray3Method() {
+        return new String[][][] {{{"the strangest of the strange"}}};
+    }
+
+    int parameterMethod(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                        boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                        String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+        return 1;
+    }
+
+    // step2
+    public int publicIntMethod(boolean a) {
+        return 88;
+    }
+    protected double protectedDoubleMethod(byte a) {
+        return 99;
+    }
+    private String privateStringMethod(String a) {
+        return "the coldest of the cool";
+    }
+
+    // step3
+    strictfp double[][] transientDoubleArrayMethod(float[][] a) {
+        return new double[][] {{1988, 4.16}};
+    }
+    final int finalIntMethod() {
+        return 9876;
+    }
+    synchronized String volatileStringMethod() {
+        return "the lamest of the lame";
+    }
+    static Character staticCharacterMethod(Thread.State a) {
+        return 'd';
+    }
+
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotationMethod() {
+        return new String[][] {{"the numbest of the dumb"}};
+    }
+}
+
+interface TestMethod03 {
+    String stringInterfaceMethod(int[] a);
+    char[][][] charArrayInterfaceMethod(double... a);
+}
+
+abstract class TestMethod04 {
+    public static final synchronized String[] stringsAbstractArrayMethod() {
+        return new String[] {"i hate to see you here", "you choke behind a smile"};
+    }
+    abstract Runnable runnableAbstractMethod();
+}
+
+enum TestMethod08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnumMethod() {
+        return (short)6;
+    }
+    public final String stringEnumMethod(int... a) {
+        return "Dry Martini";
+    }
+}
+
+class TestMethod09 {
+    public int int09Method() {
+        return 1;
+    }
+    protected boolean boolean09Method() {
+        return false;
+    }
+    char[] chars09Method() {
+        return new char[] {'a', 'b', 'c'};
+    }
+    private String string09Method() {
+        return "I'm only happy when it rains";
+    }
+}
+
+class TestMethod10 extends TestMethod09 implements TestMethod11 {
+    public boolean boolean09Method() {
+        return true;
+    }
+    public double double10Method() {
+        return 0.416;
+    }
+    public char[] chars09Method() {
+        return new char[] {'a'};
+    }
+    public String string09Method() {
+        return "SHALALALA";
+    }
+}
+
+interface TestMethod11 {
+    int int09Method();
+    boolean boolean09Method();
+    char[] chars09Method();
+    String string09Method();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0186-rt-reflection-ConstructorTest/ConstructorTest.java b/test/testsuite/ouroboros/reflection_test/RT0186-rt-reflection-ConstructorTest/ConstructorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d3499a794f631906e590cde88bc06f1c9643048
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0186-rt-reflection-ConstructorTest/ConstructorTest.java
@@ -0,0 +1,379 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ConstructorTest.java
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ConstructorTest.java
+ *- @Title/Destination: for the same constructor, different Constructor object is return when call following API twice: Class.getConstructors(), Class.getEnclosingConstructor(), Class.getDeclaredConstructors(), Class.getConstructor(String name, Class<?>... parameterTypes), Class.getDeclaredConstructor(String name, Class<?>... parameterTypes)
+ *- @Brief:no: see steps of separate test cases
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source: ConstructorTest.java
+ *- @ExecuteClass: ConstructorTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Constructor;
+
+public class ConstructorTest {
+    /**
+     * Verify that for the same constructor, different Constructor object is return when call following API twice:
+     * - Class.getConstructors(),
+     * - Class.getEnclosingConstructor(),
+     * - Class.getDeclaredConstructors(),
+     * - Class.getConstructor(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredConstructor(String name, Class<?>... parameterTypes),
+     * if any Constructor failed the check, will print error message including testcase and constructor name;
+     * after all check is pass, casePassed will be increased;
+     */
+    private static void classAllConstructorTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getConstructors()
+        Constructor[] constructors1 = clazz.getConstructors();
+        Constructor[] constructors2 = clazz.getConstructors();
+        checkConstructors(constructors1, constructors2);
+        for (Constructor c : constructors1) {
+            // checkpoint 2. Class.getConstructor(String name)
+            Constructor c1 = clazz.getConstructor(c.getParameterTypes());
+            Constructor c2 = clazz.getConstructor(c.getParameterTypes());
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed");
+            }
+        }
+
+        // checkpoint 3. Class.getDeclaredConstructors()
+        constructors1 = clazz.getDeclaredConstructors();
+        constructors2 = clazz.getDeclaredConstructors();
+        checkConstructors(constructors1, constructors2);
+        for (Constructor c : constructors1) {
+            // checkpoint 4. Class.getDeclaredConstructor(String name)
+            Constructor c1 = clazz.getDeclaredConstructor(c.getParameterTypes());
+            Constructor c2 = clazz.getDeclaredConstructor(c.getParameterTypes());
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed for declared constructor");
+            }
+        }
+
+        // checkpoint 5. Class.getEnclosingConstructor()
+        if (clazz.getEnclosingConstructor() != null) {
+            Constructor c1 = clazz.getEnclosingConstructor();
+            Constructor c2 = clazz.getEnclosingConstructor();
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed for Enclosing constructor");
+            }
+        }
+
+        casesPassed++;
+    }
+
+    private static void checkConstructors(Constructor[] constructors1, Constructor[] constructors2) {
+        for (Constructor c1 : constructors1) {
+            for (Constructor c2 : constructors2) {
+                // only when modifers and class and name is same, two Constructor object is for same constructor
+                if (c1.toString().equals(c2.toString())) {
+                    if (singleConstructorCheck(c1, c2) != 3) {
+                        System.out.println(c1.getName() + " failed in checkConstructors");
+                    }
+                }
+            }
+        }
+    }
+
+    private static int singleConstructorCheck(Constructor c1, Constructor c2) {
+        int passCnt = 0;
+        passCnt += c1 == c2 ? 0 : 1;
+        passCnt += c1.equals(c2) ? 1 : 0;
+        passCnt += c1.hashCode() == c2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    static int casesPassed = 0;
+
+    public static void main(String[] args) {
+        constructor01();
+        constructor02();
+        constructor03();
+        constructor04();
+        constructor05();
+        constructor06();
+        constructor07();
+        constructor08();
+        constructor09();
+        constructor10();
+        constructor11();
+        System.out.println(casesPassed - 11);
+    }
+
+    /**
+     *- @TestCaseID: constructor01
+     *- @Title/Destination: for same constructor in pre-defined class, certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. all test in classAllConstructorTest() passed for pre-defined class java.lang.Thread
+     */
+    private static void constructor01() {
+        try {
+            classAllConstructorTest(Class.forName("java.lang.Thread"), "constructor01");
+        } catch (Exception e) {
+            System.out.println("Case constructor01 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor02
+     *- @Title/Destination: for same constructor in user-defined class with different parameter_type/modifier/annotation, certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. classAllConstructorTest() passed for constructors with different parameter type
+     * -#step2. classAllConstructorTest() passed for constructors with different access modifier: public, private, protected
+     * -#step3. classAllConstructorTest() passed for constructors with annotation
+     */
+    private static void constructor02() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor02"), "constructor02");
+        } catch (Exception e) {
+            System.out.println("Case constructor02 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor03
+     *- @Title/Destination: check all test in classAllConstructorTest passed for constructors in class with modifier strictfp
+     *- @Brief:no:
+     * -step1. check all test in classAllConstructorTest passed for constructors in class with modifier strictfp
+     */
+    private static void constructor03() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor03"), "constructor03");
+        } catch (Exception e) {
+            System.out.println("Case constructor03 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor04
+     *- @Title/Destination: for same constructor in abstract class, certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in abstract class
+     */
+    private static void constructor04() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor04"), "constructor04");
+        } catch (Exception e) {
+            System.out.println("Case constructor04 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor05
+     *- @Title/Destination: for same constructor in anonymous class, certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. get the class instance of anonymous class by getting constructor value of otter class instance
+     * -#step2. check all test in classAllConstructorTest passed for constructors in anonymous class
+     */
+    private static void constructor05() {
+        try {
+            Class clazz = Class.forName("ConstructorTest");
+            ConstructorTest mainClass = new ConstructorTest();
+            Field constructor = clazz.getDeclaredField("testConstructor05");
+
+            classAllConstructorTest(constructor.get(mainClass).getClass(), "constructor05");
+        } catch (Exception e) {
+            System.out.println("Case constructor05 failed with exception" + e);
+        }
+    }
+
+    private Runnable testConstructor05 = new Runnable() {
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    /**
+     *- @TestCaseID: constructor06
+     *- @Title/Destination: for same constructor in local class(class in a function), certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in local class
+     */
+    private static void constructor06() {
+        class TestConstructor06 {
+            private TestConstructor06(int a) {
+            }
+            public TestConstructor06(String[][][] a) {
+            }
+        }
+        try {
+            classAllConstructorTest(Class.forName("ConstructorTest$1TestConstructor06"), "constructor06");
+        } catch (Exception e) {
+            System.out.println("Case constructor06 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor07
+     *- @Title/Destination: for same constructor in inner class, certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in inner class
+     */
+    private static void constructor07() {
+        try {
+            classAllConstructorTest(Class.forName("ConstructorTest$TestConstructor07"), "constructor07");
+        } catch (Exception e) {
+            System.out.println("Case constructor07 failed with exception" + e);
+        }
+    }
+
+    class TestConstructor07 {
+        private TestConstructor07(int a, double... b) {
+        }
+        public TestConstructor07() {
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor08
+     *- @Title/Destination: for same constructor in user-defined class, certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in
+     */
+    private static void constructor08() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor08"), "constructor08");
+        } catch (Exception e) {
+            System.out.println("Case constructor08 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor09
+     *- @Title/Destination: for same constructor in father class, certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in father class
+     */
+    private static void constructor09() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor09"), "constructor09");
+        } catch (Exception e) {
+            System.out.println("Case constructor09 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor10
+     *- @Title/Destination: for same constructor in class extends another class and implements interface, certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in class extends another class and implements interface
+     */
+    private static void constructor10() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor10"), "constructor10");
+        } catch (Exception e) {
+            System.out.println("Case constructor10 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: constructor11
+     *- @Title/Destination: for same constructor in interface implemented by another class, certain APIs return different Constructor object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllConstructorTest passed for constructors in interface implemented by another class
+     */
+    private static void constructor11() {
+        try {
+            Class clazz = (new TestConstructor11()).c.getClass();
+            classAllConstructorTest(clazz, "constructor11");
+        } catch (Exception e) {
+            System.out.println("Case constructor11 failed with exception" + e);
+        }
+    }
+}
+
+class TestConstructor02 {
+    // step1
+    TestConstructor02() {
+    }
+
+    TestConstructor02(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                      boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                      String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+    }
+
+    // step2
+    public TestConstructor02(int a) {}
+    TestConstructor02(byte a) {}
+    protected TestConstructor02(String a) {}
+    private TestConstructor02(Runnable[] a) {}
+
+    // step3
+    @Deprecated
+    TestConstructor02(int... a) {}
+}
+
+strictfp class TestConstructor03 {
+    public TestConstructor03(float... a) {
+    }
+    TestConstructor03(float a, double b) {
+    }
+}
+
+abstract class TestConstructor04 {
+    public TestConstructor04() {
+    }
+
+    TestConstructor04(int a) {
+    }
+}
+
+enum TestConstructor08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    TestConstructor08() {
+    }
+
+    TestConstructor08(String a) {
+    }
+}
+
+class TestConstructor09 {
+    public TestConstructor09() {
+    }
+    TestConstructor09(int... a) {
+    }
+    protected TestConstructor09(double[] a) {
+    }
+    private TestConstructor09(int a) {
+    }
+}
+
+class TestConstructor10 extends TestConstructor09 {
+    public TestConstructor10() {
+    }
+    TestConstructor10(int... a) {
+    }
+    protected TestConstructor10(double[] a) {
+    }
+    private TestConstructor10(int a) {
+    }
+}
+
+class TestConstructor11 {
+    public Object c;
+    public TestConstructor11( ) {
+        class ClassA {
+        }
+        c = new ClassA();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java b/test/testsuite/ouroboros/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..32c5a17566f49bafc8425fa260518bec2e3f15cb
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodHandleReflectCombineTest.java
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:MethodHandleReflectCombineTest.java
+ *- @Title/Destination: Test Field/Method/Constructor object return by MethodHandles.reflectAs(Class<T> expected, MethodHandle target) is heap object
+ *- @Brief:no:
+ * -#step1. testData including methodHandles for virtual method, static method, private method, constructor with primitive parameter and array parameter, field with primitive type, array type, static field;
+ * -#step2. for methodHandles in testData, call reflectAs(Member.class, methodhandle) twice, the Field/Constructor/Method returned is two object
+ * -#step3. for private constructor, try to setAccessible(true) for it first and then get method handle for it and check reflectAs return a new Constructor object
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source: MethodHandleReflectCombineTest.java
+ *- @ExecuteClass: MethodHandleReflectCombineTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+
+import static java.lang.invoke.MethodHandles.lookup;
+import static java.lang.invoke.MethodHandles.reflectAs;
+import static java.lang.invoke.MethodType.methodType;
+
+public class MethodHandleReflectCombineTest {
+    static int passCnt = 0;
+
+    private static <T extends Member> int singleMethodCheck(T m1, T m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    public static void main(String[] args) {
+        try {
+            System.out.println(run());
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static int run() throws Throwable {
+        Object[][] testData = new Object[][]{
+            {Member.class, lookup().findVirtual(String.class, "concat", methodType(String.class, String.class))},
+            {Member.class, lookup().findStatic(String.class, "copyValueOf", methodType(String.class, char[].class))},
+            {Member.class, RATest.LOOKUP().findSpecial(RATest.class, "mhVar", methodType(int.class, Object[].class), RATest.class)},
+            {Constructor.class, lookup().findConstructor(RATest.class, methodType(void.class, int.class))},
+            {Constructor.class, lookup().findConstructor(RATest.class, methodType(void.class, double[].class))},
+            {Field.class, lookup().findStaticGetter(RATest.class, "svi", int.class)},
+            {Field.class, lookup().findStaticSetter(RATest.class, "svi", int.class)},
+            {Field.class, RATest.LOOKUP().findGetter(RATest.class, "vd", double.class)},
+            {Field.class, lookup().findGetter(RATest.class, "vs", String[].class)},
+            {Field.class, lookup().findSetter(RATest.class, "vs", String[].class)}
+        };
+
+        for (int i = 0; i < testData.length; i++) {
+            passCnt += singleMethodCheck(reflectAs((Class) testData[i][0], (MethodHandle) testData[i][1]), reflectAs((Class) testData[i][0], (MethodHandle) testData[i][1])) == 3 ? 1 : 0;
+        }
+
+        Constructor privC = Class.forName("RATest").getDeclaredConstructor();
+        privC.setAccessible(true);
+        MethodHandle raCon = lookup().unreflectConstructor(privC);
+        passCnt += singleMethodCheck(privC, reflectAs(Constructor.class, raCon)) == 3 ? 1 : 0;
+
+        return passCnt - 11;
+    }
+}
+
+class RATest {
+    public static MethodHandles.Lookup LOOKUP() {
+        return lookup();
+    }
+
+    static public double count = 0;
+    protected static int svi = 333;
+    private double vd = 136;
+    String[] vs = {"hi"};
+
+    RATest(int i) {
+        count = i;
+    }
+
+    public RATest(double[] i) {
+        count = i.length;
+    }
+
+    private RATest() {
+        count = -1;
+    }
+
+    private int mhVar(Object... a) {
+        return a.length;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0189-rt-reflection-FieldTest/FieldTest.java b/test/testsuite/ouroboros/reflection_test/RT0189-rt-reflection-FieldTest/FieldTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b6de83e6400a4e49c3dec57facb1370776270f8
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0189-rt-reflection-FieldTest/FieldTest.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldTest.java
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:FieldTest.java
+ *- @Title/Destination: for the same field, different Field object is return when call following API twice: Class.getFields(), Class.getDeclaredFields(), Class.getField(String name), Class.getDeclareedField(String name). tests field with different data type, modifier, annotation and declaring class
+ *- @Brief:no: see steps of separate test cases
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source: FieldTest.java
+ *- @ExecuteClass: FieldTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class FieldTest {
+    /**
+     * Verify that for the same field, different Field object is return when call following API twice:
+     * - Class.getFields()
+     * - Class.getDeclaredFields()
+     * - Class.getField(String name)
+     * - Class.getDeclareedField(String name)
+     * if any Field failed the check, will print error message including testcase and field name;
+     * after all check is pass, casePassed will be increased;
+     */
+    private static void classAllFieldTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getFields()
+        Field[] fields1 = clazz.getFields();
+        Field[] fields2 = clazz.getFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 2. Class.getDeclaredFields()
+            Field f1 = clazz.getField(f.getName());
+            Field f2 = clazz.getField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed");
+            }
+        }
+
+        // checkpoint 3. Class.getField(String name)
+        fields1 = clazz.getDeclaredFields();
+        fields2 = clazz.getDeclaredFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 4. Class.getDeclareedField(String name)
+            Field f1 = clazz.getDeclaredField(f.getName());
+            Field f2 = clazz.getDeclaredField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed for declared fields");
+            }
+        }
+        casesPassed++;
+    }
+
+    private static void checkFields(Field[] fields1, Field[] fields2) {
+        for (Field f1: fields1) {
+            for (Field f2: fields2) {
+                // only when modifers and class and name is same, two Field object is for same field
+                if(f1.toGenericString().equals(f2.toGenericString())) {
+                    if (singleFieldCheck(f1, f2) != 3) {
+                        System.out.println(f1.getName()+" failed in checkFields");
+                    }
+                }
+            }
+        }
+    }
+
+    private static int singleFieldCheck(Field f1, Field f2) {
+        int passCnt = 0;
+        passCnt += f1 == f2 ? 0 : 1;
+        passCnt += f1.equals(f2) ? 1 : 0;
+        passCnt += f1.hashCode() == f2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    static int casesPassed = 0;
+
+    public static void main(String [] args) {
+        field01();
+        field02();
+        field03();
+        field04();
+        field05();
+        field06();
+        field07();
+        field08();
+        field09();
+        field10();
+        field11();
+        field12();
+        System.out.println(casesPassed - 12);
+    }
+
+    /**
+     *- @TestCaseID: field01
+     *- @Title/Destination: for same field in pre-defined class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. all test in classAllFieldTest() passed for pre-defined class java.lang.Thread
+     */
+    private static void field01() {
+        try {
+            classAllFieldTest(Class.forName("java.lang.Thread"), "field01");
+        } catch (Exception e) {
+            System.out.println("Case field01 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field02
+     *- @Title/Destination: for same field in user-defined class with different type/modifier/annotation, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. classAllFieldTest() passed for fields with different type
+     * -#step2. classAllFieldTest() passed for fields with different access modifier: public, private, protected
+     * -#step3. classAllFieldTest() passed for fields with different modifier: transient, final, volatile, static
+     * -#step4. classAllFieldTest() passed for fields with annotation
+     */
+    private static void field02() {
+        try {
+            classAllFieldTest(Class.forName("TestField02"), "field02");
+        } catch (Exception e) {
+            System.out.println("Case field02 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field03
+     *- @Title/Destination: for same field in strictfp class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -step1. all test in classAllFieldTest() passed for class with modifier strictfp
+     */
+    private static void field03() {
+        try {
+            classAllFieldTest(Class.forName("TestField03"), "field03");
+        } catch (Exception e) {
+            System.out.println("Case field03 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field04
+     *- @Title/Destination: for same field in interface, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -step1. check all test in classAllFieldTest passed for fields in interface
+     */
+    private static void field04() {
+        try {
+            classAllFieldTest(Class.forName("TestField04"), "field04");
+        } catch (Exception e) {
+            System.out.println("Case field04 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field05
+     *- @Title/Destination: for same field in abstract class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in abstract class
+     */
+    private static void field05() {
+        try {
+            classAllFieldTest(Class.forName("TestField05"), "field05");
+        } catch (Exception e) {
+            System.out.println("Case field05 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field06
+     *- @Title/Destination: for same field in anonymous class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. get the class instance of an anonymous class
+     * -#step2. check all test in classAllFieldTest passed for fields in anonymous class
+     */
+    private static void field06() {
+        try {
+            // step 1
+            Class clazz = Class.forName("FieldTest");
+            FieldTest mainClass = new FieldTest();
+            Field field = clazz.getDeclaredField("testField06");
+
+            classAllFieldTest(field.get(mainClass).getClass(), "field06");
+        } catch (Exception e) {
+            System.out.println("Case field06 failed with exception" + e);
+        }
+    }
+
+    private Runnable testField06 = new Runnable() {
+        int intAnonymous = 10;
+        public double doubleAnonymous = 1988.416;
+
+        @Override
+        public void run() {
+            for (int i = 0; i < intAnonymous; i++) {
+                intAnonymous += i;
+            }
+        }
+    };
+
+    /**
+     *- @TestCaseID: field07
+     *- @Title/Destination: for same field in local class(class in a function), certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in local class
+     */
+    private static void field07() {
+        class TestField07 {
+            private final transient int intLocal = 9;
+            public volatile String stringLocal = "a fake behind the fear";
+        }
+        try {
+            classAllFieldTest(Class.forName("FieldTest$1TestField07"), "field07");
+        } catch (Exception e) {
+            System.out.println("Case field07 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field08
+     *- @Title/Destination: for same field in inner class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in inner class
+     */
+    private static void field08() {
+        try {
+            classAllFieldTest(Class.forName("FieldTest$TestField08"), "field08");
+        } catch (Exception e) {
+            System.out.println("Case field08 failed with exception" + e);
+        }
+    }
+
+    class TestField08 {
+        volatile private char charInner = 'l';
+        public final static transient double doubleInner = 0.88;
+    }
+
+    /**
+     *- @TestCaseID: field09
+     *- @Title/Destination: for same field in user-defined enum class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in enum class
+     */
+    private static void field09() {
+        try {
+            classAllFieldTest(Class.forName("TestField09"), "field09");
+        } catch (Exception e) {
+            System.out.println("Case field09 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field10
+     *- @Title/Destination: for same field in parent class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in parent class
+     */
+    private static void field10() {
+        try {
+            classAllFieldTest(Class.forName("TestField10"), "field10");
+        } catch (Exception e) {
+            System.out.println("Case field10 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field11
+     *- @Title/Destination: for same field in child class with implemented interface, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in child class with implemented interface
+     */
+    private static void field11() {
+        try {
+            classAllFieldTest(Class.forName("TestField11"), "field11");
+        } catch (Exception e) {
+            System.out.println("Case field11 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field12
+     *- @Title/Destination: for same field in interface implemented by another class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in interface implemented by another class
+     */
+    private static void field12() {
+        try {
+            classAllFieldTest(Class.forName("TestField12"), "field12");
+        } catch (Exception e) {
+            System.out.println("Case field12 failed with exception" + e);
+        }
+    }
+}
+
+class TestField02 {
+    // step1
+    boolean booleanField = true;
+    byte byteField = (byte)2;
+    short shortField = (short)4;
+    int intField = 6;
+    long longField = 8;
+    char charField = 10;
+    float floatField = 0.4f;
+    double doubleField = 0.8;
+
+    String stringField = "The queerest of the queer";
+    Runnable r = null;
+
+    boolean[][][][][][][] booleanArray7 = new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    String[][][] stringArray3 = new String[][][] {{{"the strangest of the strange"}}};
+
+    // step2
+    public int publicInt = 88;
+    protected double protectedDouble = 99;
+    private String privateString = "the coldest of the cool";
+
+    // step3
+    transient double[][] transientDoubleArray = new double[][] {{1988, 4.16}};
+    final int finalInt = 9876;
+    volatile String volatileString = "the lamest of the lame";
+    static Character staticCharacter = 'd';
+
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotation = new String[][] {{"the numbest of the dumb"}};
+}
+
+strictfp class TestField03 {
+    float floatField = 4.16f;
+    public double doubleField = 19.88;
+}
+
+interface TestField04 {
+    String stringInterface = "i know what's good for you";
+    char[] charInterface = new char[] {'l', 'e', 't'};
+}
+
+abstract class TestField05 {
+    String[] stringsAbstractArray = {"i hate to see you here", "you choke behind a smile"};
+    Runnable[] runnableAbstractArray = {new Runnable() {
+            @Override
+            public void run() {
+            }
+        }
+    };
+}
+
+enum TestField09 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnum = (short)6;
+    public final String stringEnum = "Dry Martini";
+}
+
+class TestField10 {
+    public int int10;
+    protected boolean boolean10;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    private String string10 = "I'm only happy when it rains";
+}
+
+class TestField11 extends TestField10 implements TestField12 {
+    boolean boolean10 = true;
+    public double double11 = 0.416;
+
+}
+
+interface TestField12 {
+    int int10 = 9;
+    boolean boolean10 = false;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    String string10 = "I'm only happy when it rains";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoA.java b/test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoA.java
new file mode 100644
index 0000000000000000000000000000000000000000..576170aa682a3b99b1907ae752270508d5ad64d5
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoA.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoB.java b/test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoB.java
new file mode 100644
index 0000000000000000000000000000000000000000..56cf1cfc5d74989d6b7c186af90e6635cf957e64
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoB.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java b/test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..625acf431ae0895799c54ca9c6fbcd994804c745
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:AnnotationTypeParameterSetTest.java
+ *- @TestCaseName: AnnotationTypeParameterSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE_PARAMETER)
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE_PARAMETER) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Source: AnnotationTypeParameterSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationTypeParameterSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationTypeParameterSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+
+        System.out.println(Test.class.getAnnotations().length);
+//      TypeVeriable.getAnnotation not supported in ART
+/*      AnnoA anno = Test.class.getTypeParameters()[0].getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));*/
+    }
+}
+
+class Test<@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) T> {
+
+}
+
+
+// DEPENDENCE: AnnoB.java AnnoA.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoA.java b/test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoA.java
new file mode 100644
index 0000000000000000000000000000000000000000..d760f6a086b56f7ea5462d99437fe5a859d168a3
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoA.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoB.java b/test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoB.java
new file mode 100644
index 0000000000000000000000000000000000000000..56cf1cfc5d74989d6b7c186af90e6635cf957e64
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoB.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java b/test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2abba7f2ddd30ee7fff648106beab50c71d6cbeb
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_Annotation_invoke_AnnotationSetTest
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:AnnotationTypeUseSetTest.java
+ *- @TestCaseName: AnnotationTypeUseSetTest
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation with @Target(ElementType.TYPE_USE)
+ *- @Brief:no:
+ * -#step1. User-defined Annotation with @Target(ElementType.TYPE_USE) has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Source: AnnotationTypeUseSetTest.java AnnoA.java AnnoB.java
+ *- @ExecuteClass: AnnotationTypeUseSetTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.Arrays;
+
+public class AnnotationTypeUseSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        System.out.println(Test.class.getAnnotations().length);
+/*        AnnoA anno = Test.class.getTypeParameters()[0].getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));*/
+    }
+}
+
+class Test<@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) T> {
+
+}
+
+
+// DEPENDENCE: AnnoB.java AnnoA.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoA.java b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoA.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6b86e4374cea37c546ff6553250a3c1bdf84979
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoA.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA() default Integer.MAX_VALUE;
+
+    double doubleA() default Double.MIN_VALUE;
+
+    String stringA() default "";
+
+    AnnoB annoBA();
+
+    ENUMA enumA() default ENUMA.A;
+}
diff --git a/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoB.java b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoB.java
new file mode 100644
index 0000000000000000000000000000000000000000..56cf1cfc5d74989d6b7c186af90e6635cf957e64
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoB.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoC.java b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoC.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a7d6dde6c2325f96ff0b65dd16e6b22dc9d4ba4
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoC.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoC {
+    int[] intA() default Integer.MAX_VALUE;
+
+    double[] doubleA() default Double.MIN_VALUE;
+
+    String[] stringA() default "";
+
+    AnnoB[] annoBA() default @AnnoB;
+
+    ENUMA[] enumA() default ENUMA.A;
+}
diff --git a/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoD.java b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoD.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc32ac9473634853144a0f473d14c7e01a6bfed5
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoD.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoD {
+    int intA() default Integer.MAX_VALUE;
+
+    double doubleA() default Double.MIN_VALUE;
+
+    String stringA() default "";
+
+    AnnoB annoBA();
+
+    ENUMA enumA() default ENUMA.A;
+}
diff --git a/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnotationMultiThread.java b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnotationMultiThread.java
new file mode 100644
index 0000000000000000000000000000000000000000..a87fd8c0b65626548c92b6bdaa4634434052af6f
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnotationMultiThread.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_MethodHandle_invoke_AnnotationMultiThread
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:AnnotationMultiThread.java
+ *- @TestCaseName: AnnotationMultiThread
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: annotation
+ *- @Title/Destination: positive test for User-defined Annotation, verify when multiple thread try to use annotations, working fine
+ *- @Brief:no:
+ * -#step1. User-defined Annotation has field with primitive type, String, ENUM, annotation, class and their array
+ * -#step2. verify able to set and get value under multithread
+ *- @Expect:0\n
+ *- @Priority: Level 1
+ *- @Source: AnnotationMultiThread.java AnnoA.java AnnoB.java AnnoC.java AnnoD.java ENUMA.java
+ *- @ExecuteClass: AnnotationMultiThread
+ *- @ExecuteArgs:
+ */
+
+import java.lang.annotation.Annotation;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class AnnotationMultiThread {
+    static AtomicInteger passCnt = new AtomicInteger();
+    public static void main(String[] args) throws ClassNotFoundException {
+        ThreadGroup threadGroup = new ThreadGroup("myGroup");
+
+        String[][] expectedGF = new String[][]{
+                {"@AnnoA", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+                {"@AnnoB(intB=999)"},
+                {"@AnnoC", "annoBA=[@AnnoB(intB=999)]", "intA=[2147483647]", "enumA=[A]", "stringA=[]", "doubleA=[4.9E-324]"}
+        };
+
+        String[][] expectedF = new String[][]{
+                {"@AnnoA", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+                {"@AnnoB(intB=999)"},
+                {"@AnnoC", "annoBA=[@AnnoB(intB=999)]", "intA=[2147483647]", "enumA=[A]", "stringA=[]", "doubleA=[4.9E-324]"},
+                {"@AnnoD", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+        };
+
+        new AnnotationGetter("GrandFather", expectedGF, expectedGF, threadGroup, "threadGF").start();
+        new AnnotationGetter("Father", expectedF, expectedF, threadGroup, "threadF").start();
+        new AnnotationGetter("Interface", expectedF, expectedF, threadGroup, "threadI").start();
+        new AnnotationGetter("Son", expectedF, new String[][]{}, threadGroup, "threadS").start();
+        new AnnotationGetter("Son2", expectedF, new String[][]{}, threadGroup, "threadS2").start();
+        new AnnotationGetter("GrandFather", expectedGF, expectedGF, threadGroup, "threadGF").start();
+        new AnnotationGetter("Father", expectedF, expectedF, threadGroup, "threadF").start();
+        new AnnotationGetter("Interface", expectedF, expectedF, threadGroup, "threadI").start();
+        new AnnotationGetter("Son", expectedF, new String[][]{}, threadGroup, "threadI").start();
+        new AnnotationGetter("Son2", expectedF, new String[][]{}, threadGroup, "threadI").start();
+
+        int i = 0;
+        while (threadGroup.activeCount() > 0) {
+            i++;
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                System.out.println(e);
+            }
+            if (i > 1000) {
+                break;
+            }
+        }
+
+        System.out.println(passCnt.get() - 200);
+    }
+
+
+    public static boolean checkAllAnnotations(Annotation[] annotations, String[][] expected) {
+        String[] actual = new String[annotations.length];
+
+        for (int i = 0; i < annotations.length; i++) {
+            actual[i] = annotations[i].toString();
+        }
+        Arrays.sort(actual);
+        if (actual.length != expected.length) {
+            return false;
+        }
+//        System.out.println(Arrays.toString(actual));
+        for (int i = 0; i < annotations.length; i++) {
+            if (expected[i].length == 1) {
+                if (actual[i].compareTo(expected[i][0]) != 0) {
+                    System.out.println(actual[i]);
+                    System.out.println(expected[i][0]);
+                    return false;
+                }
+            } else {
+                for (int j = 0; j < expected[i].length; j++) {
+                    if (!actual[i].contains(expected[i][j])) {
+                        System.out.println(actual[i]);
+                        System.out.println(expected[i][j]);
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+}
+
+class AnnotationGetter extends Thread {
+    String name;
+    String[][] expected;
+    String[][] expectedD;
+
+    AnnotationGetter(String nameI, String[][] expectedI, String[][] expectedDI, ThreadGroup threadGroup, String thread_name) {
+        super(threadGroup, thread_name);
+        name = nameI;
+        expected = expectedI;
+        expectedD = expectedDI;
+    }
+
+    @Override
+    public void run() {
+        try {
+            for (int i = 0; i < 10; i++) {
+                if (AnnotationMultiThread.checkAllAnnotations(Class.forName(this.name).getAnnotations(), this.expected)) {
+                    AnnotationMultiThread.passCnt.incrementAndGet();
+                }
+                if (AnnotationMultiThread.checkAllAnnotations(Class.forName(this.name).getDeclaredAnnotations(), this.expectedD)) {
+                    AnnotationMultiThread.passCnt.incrementAndGet();
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+}
+
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+class GrandFather {
+    public void method1(int a, double b, Object... objects) {
+    }
+}
+
+@SuppressWarnings("all")
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+@AnnoD(annoBA = @AnnoB)
+class Father extends GrandFather implements Interface {
+    @Override
+    public void method1(int a, double b, Object... objects) {
+    }
+
+    @Deprecated
+    public void method2() {
+    }
+}
+
+class Son extends Father {
+    @Override
+    @Deprecated
+    public void method2() {
+    }
+}
+
+class Son2 extends Father {
+    @Override
+    @Deprecated
+    public void method2() {
+    }
+}
+
+@SuppressWarnings("all")
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+@AnnoD(annoBA = @AnnoB)
+interface Interface {
+
+}
+
+// DEPENDENCE: AnnoB.java AnnoC.java AnnoA.java ENUMA.java AnnoD.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java AnnoC.java AnnoD.java ENUMA.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/ENUMA.java b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/ENUMA.java
new file mode 100644
index 0000000000000000000000000000000000000000..2dd9b6b8f2c920cd8311d59abaa811fec0180be1
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/ENUMA.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+public enum ENUMA {
+    A,
+    B,
+    C
+}
diff --git a/test/testsuite/ouroboros/reflection_test/RT0208-rt-reflection-MetadataCheck/FieldTest.java b/test/testsuite/ouroboros/reflection_test/RT0208-rt-reflection-MetadataCheck/FieldTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..73157de8818a7cc0090ecbea0296d8258301a92b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0208-rt-reflection-MetadataCheck/FieldTest.java
@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: FieldTest.java
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:FieldTest.java
+ *- @Title/Destination: for the same field, different Field object is return when call following API twice: Class.getFields(), Class.getDeclaredFields(), Class.getField(String name), Class.getDeclareedField(String name). tests field with different data type, modifier, annotation and declaring class
+ *- @Brief:no: see steps of separate test cases
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source: FieldTest.java
+ *- @ExecuteClass: FieldTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class FieldTest {
+    /**
+     * Verify that for the same field, different Field object is return when call following API twice:
+     * - Class.getFields()
+     * - Class.getDeclaredFields()
+     * - Class.getField(String name)
+     * - Class.getDeclareedField(String name)
+     * if any Field failed the check, will print error message including testcase and field name;
+     * after all check is pass, casePassed will be increased;
+     */
+    private static void classAllFieldTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getFields()
+        Field[] fields1 = clazz.getFields();
+        Field[] fields2 = clazz.getFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 2. Class.getDeclaredFields()
+            Field f1 = clazz.getField(f.getName());
+            Field f2 = clazz.getField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed");
+            }
+        }
+
+        // checkpoint 3. Class.getField(String name)
+        fields1 = clazz.getDeclaredFields();
+        fields2 = clazz.getDeclaredFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 4. Class.getDeclareedField(String name)
+            Field f1 = clazz.getDeclaredField(f.getName());
+            Field f2 = clazz.getDeclaredField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed for declared fields");
+            }
+        }
+        casesPassed++;
+    }
+
+    private static void checkFields(Field[] fields1, Field[] fields2) {
+        for (Field f1: fields1) {
+            for (Field f2: fields2) {
+                // only when modifers and class and name is same, two Field object is for same field
+                if(f1.toGenericString().equals(f2.toGenericString())) {
+                    if (singleFieldCheck(f1, f2) != 3) {
+                        System.out.println(f1.getName()+" failed in checkFields");
+                    }
+                }
+            }
+        }
+    }
+
+    private static int singleFieldCheck(Field f1, Field f2) {
+        int passCnt = 0;
+        passCnt += f1 == f2 ? 0 : 1;
+        passCnt += f1.equals(f2) ? 1 : 0;
+        passCnt += f1.hashCode() == f2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    static int casesPassed = 0;
+
+    public static void main(String [] args) {
+        field01();
+        field02();
+        field03();
+        field04();
+        field05();
+        field06();
+        field07();
+        field08();
+        field09();
+        field10();
+        field11();
+        field12();
+        System.out.println(casesPassed - 12);
+    }
+
+    /**
+     *- @TestCaseID: field01
+     *- @Title/Destination: for same field in pre-defined class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. all test in classAllFieldTest() passed for pre-defined class java.lang.Thread
+     */
+    private static void field01() {
+        try {
+            classAllFieldTest(Class.forName("java.lang.Thread"), "field01");
+        } catch (Exception e) {
+            System.out.println("Case field01 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field02
+     *- @Title/Destination: for same field in user-defined class with different type/modifier/annotation, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. classAllFieldTest() passed for fields with different type
+     * -#step2. classAllFieldTest() passed for fields with different access modifier: public, private, protected
+     * -#step3. classAllFieldTest() passed for fields with different modifier: transient, final, volatile, static
+     * -#step4. classAllFieldTest() passed for fields with annotation
+     */
+    private static void field02() {
+        try {
+            classAllFieldTest(Class.forName("TestField02"), "field02");
+        } catch (Exception e) {
+            System.out.println("Case field02 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field03
+     *- @Title/Destination: for same field in strictfp class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -step1. all test in classAllFieldTest() passed for class with modifier strictfp
+     */
+    private static void field03() {
+        try {
+            classAllFieldTest(Class.forName("TestField03"), "field03");
+        } catch (Exception e) {
+            System.out.println("Case field03 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field04
+     *- @Title/Destination: for same field in interface, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -step1. check all test in classAllFieldTest passed for fields in interface
+     */
+    private static void field04() {
+        try {
+            classAllFieldTest(Class.forName("TestField04"), "field04");
+        } catch (Exception e) {
+            System.out.println("Case field04 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field05
+     *- @Title/Destination: for same field in abstract class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in abstract class
+     */
+    private static void field05() {
+        try {
+            classAllFieldTest(Class.forName("TestField05"), "field05");
+        } catch (Exception e) {
+            System.out.println("Case field05 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field06
+     *- @Title/Destination: for same field in anonymous class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. get the class instance of an anonymous class
+     * -#step2. check all test in classAllFieldTest passed for fields in anonymous class
+     */
+    private static void field06() {
+        try {
+            // step 1
+            Class clazz = Class.forName("FieldTest");
+            FieldTest mainClass = new FieldTest();
+            Field field = clazz.getDeclaredField("testField06");
+
+            classAllFieldTest(field.get(mainClass).getClass(), "field06");
+        } catch (Exception e) {
+            System.out.println("Case field06 failed with exception" + e);
+        }
+    }
+
+    private Runnable testField06 = new Runnable() {
+        int intAnonymous = 10;
+        public double doubleAnonymous = 1988.416;
+
+        @Override
+        public void run() {
+            for (int i = 0; i < intAnonymous; i++) {
+                intAnonymous += i;
+            }
+        }
+    };
+
+    /**
+     *- @TestCaseID: field07
+     *- @Title/Destination: for same field in local class(class in a function), certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in local class
+     */
+    private static void field07() {
+        class TestField07 {
+            private final transient int intLocal = 9;
+            public volatile String stringLocal = "a fake behind the fear";
+        }
+        try {
+            classAllFieldTest(Class.forName("FieldTest$1TestField07"), "field07");
+        } catch (Exception e) {
+            System.out.println("Case field07 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field08
+     *- @Title/Destination: for same field in inner class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in inner class
+     */
+    private static void field08() {
+        try {
+            classAllFieldTest(Class.forName("FieldTest$TestField08"), "field08");
+        } catch (Exception e) {
+            System.out.println("Case field08 failed with exception" + e);
+        }
+    }
+
+    class TestField08 {
+        volatile private char charInner = 'l';
+        public final static transient double doubleInner = 0.88;
+    }
+
+    /**
+     *- @TestCaseID: field09
+     *- @Title/Destination: for same field in user-defined enum class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in enum class
+     */
+    private static void field09() {
+        try {
+            classAllFieldTest(Class.forName("TestField09"), "field09");
+        } catch (Exception e) {
+            System.out.println("Case field09 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field10
+     *- @Title/Destination: for same field in parent class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in parent class
+     */
+    private static void field10() {
+        try {
+            classAllFieldTest(Class.forName("TestField10"), "field10");
+        } catch (Exception e) {
+            System.out.println("Case field10 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field11
+     *- @Title/Destination: for same field in child class with implemented interface, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in child class with implemented interface
+     */
+    private static void field11() {
+        try {
+            classAllFieldTest(Class.forName("TestField11"), "field11");
+        } catch (Exception e) {
+            System.out.println("Case field11 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: field12
+     *- @Title/Destination: for same field in interface implemented by another class, certain APIs return different Field object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllFieldTest passed for fields in interface implemented by another class
+     */
+    private static void field12() {
+        try {
+            classAllFieldTest(Class.forName("TestField12"), "field12");
+        } catch (Exception e) {
+            System.out.println("Case field12 failed with exception" + e);
+        }
+    }
+}
+
+class TestField02 {
+    // step1
+    boolean booleanField = true;
+    byte byteField = (byte)2;
+    short shortField = (short)4;
+    int intField = 6;
+    long longField = 8;
+    char charField = 10;
+    float floatField = 0.4f;
+    double doubleField = 0.8;
+
+    String stringField = "The queerest of the queer";
+    Runnable r = null;
+
+    boolean[][][][][][][] booleanArray7 = new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    String[][][] stringArray3 = new String[][][] {{{"the strangest of the strange"}}};
+
+    // step2
+    public int publicInt = 88;
+    protected double protectedDouble = 99;
+    private String privateString = "the coldest of the cool";
+
+    // step3
+    transient double[][] transientDoubleArray = new double[][] {{1988, 4.16}};
+    final int finalInt = 9876;
+    volatile String volatileString = "the lamest of the lame";
+    static Character staticCharacter = 'd';
+
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotation = new String[][] {{"the numbest of the dumb"}};
+}
+
+strictfp class TestField03 {
+    float floatField = 4.16f;
+    public double doubleField = 19.88;
+}
+
+interface TestField04 {
+    String stringInterface = "i know what's good for you";
+    char[] charInterface = new char[] {'l', 'e', 't'};
+}
+
+abstract class TestField05 {
+    String[] stringsAbstractArray = {"i hate to see you here", "you choke behind a smile"};
+    Runnable[] runnableAbstractArray = {new Runnable() {
+            @Override
+            public void run() {
+            }
+        }
+    };
+}
+
+enum TestField09 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnum = (short)6;
+    public final String stringEnum = "Dry Martini";
+}
+
+class TestField10 {
+    public int int10;
+    protected boolean boolean10;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    private String string10 = "I'm only happy when it rains";
+}
+
+class TestField11 extends TestField10 implements TestField12 {
+    boolean boolean10 = true;
+    public double double11 = 0.416;
+
+}
+
+interface TestField12 {
+    int int10 = 9;
+    boolean boolean10 = false;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    String string10 = "I'm only happy when it rains";
+}
+// DEPENDENCE: MethodTest.java
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/reflection_test/RT0208-rt-reflection-MetadataCheck/MethodTest.java b/test/testsuite/ouroboros/reflection_test/RT0208-rt-reflection-MetadataCheck/MethodTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d70cc06cc59a2d2089e37a075d9114e807ee2320
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/RT0208-rt-reflection-MetadataCheck/MethodTest.java
@@ -0,0 +1,450 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MethodTest.java
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:MethodTest.java
+ *- @Title/Destination: for the same method, different Method object is return when call following API twice: Class.getMethods(), Class.getEnclosingMethod(), Class.getDeclaredMethods(), Class.getMethod(String name, Class<?>... parameterTypes), Class.getDeclaredMethod(String name, Class<?>... parameterTypes). tests method with different return return type, parameter type, modifier, annotation and declaring class
+ *- @Brief:no: see steps of separate test cases
+ *- @Expect:0\n
+ *- @Priority: High
+ *- @Source: MethodTest.java
+ *- @ExecuteClass: MethodTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+public class MethodTest {
+    /**
+     * Verify that for the same method, different Method object is return when call following API twice:
+     * - Class.getMethods(),
+     * - Class.getEnclosingMethod(),
+     * - Class.getDeclaredMethods(),
+     * - Class.getMethod(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredMethod(String name, Class<?>... parameterTypes),
+     * if any Method failed the check, will print error message including testcase and method name;
+     * after all check is pass, casePassed will be increased;
+     */
+    private static void classAllMethodTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getMethods()
+        Method[] methods1 = clazz.getMethods();
+        Method[] methods2 = clazz.getMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 2. Class.getMethod(String name)
+            Method m1 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed");
+            }
+        }
+
+        // checkpoint 3. Class.getDeclaredMethods()
+        methods1 = clazz.getDeclaredMethods();
+        methods2 = clazz.getDeclaredMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 4. Class.getDeclaredMethod(String name)
+            Method m1 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for declared method");
+            }
+        }
+
+        // checkpoint 5. Class.getEnclosingMethod()
+        if (clazz.getEnclosingMethod() != null) {
+            Method m1 = clazz.getEnclosingMethod();
+            Method m2 = clazz.getEnclosingMethod();
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for Enclosing method");
+            }
+        }
+
+        casesPassed++;
+    }
+
+    private static void checkMethods(Method[] methods1, Method[] methods2) {
+        for (Method m1: methods1) {
+            for (Method m2: methods2) {
+                // only when modifers and class and name is same, two Method object is for same method
+                if(m1.toString().equals(m2.toString())) {
+                    if (singleMethodCheck(m1, m2) != 3) {
+                        System.out.println(m1.getName()+" failed in checkMethods");
+                    }
+                }
+            }
+        }
+    }
+
+    private static int singleMethodCheck(Method m1, Method m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+
+    static int casesPassed = 0;
+
+    public static void main(String [] args) {
+        method01();
+        method02();
+        method03();
+        method04();
+        method05();
+        method06();
+        method07();
+        method08();
+        method09();
+        method10();
+        method11();
+        System.out.println(casesPassed - 11);
+    }
+
+    /**
+     *- @TestCaseID: method01
+     *- @Title/Destination: for same method in pre-defined class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. all test in classAllMethodTest() passed for pre-defined class java.lang.Thread
+     */
+    private static void method01() {
+        try {
+            classAllMethodTest(Class.forName("java.lang.Thread"), "method01");
+        } catch (Exception e) {
+            System.out.println("Case method01 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method02
+     *- @Title/Destination: for same method in user-defined class with different return_type/parameter_type/modifier/annotation, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. classAllMethodTest() passed for methods with different return type and parameter type
+     * -#step2. classAllMethodTest() passed for methods with different access modifier: public, private, protected
+     * -#step3. classAllMethodTest() passed for methods with different modifier: transient, final, volatile, static
+     * -#step4. classAllMethodTest() passed for methods with annotation
+     */
+    private static void method02() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod02"), "method02");
+        } catch (Exception e) {
+            System.out.println("Case method02 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method03
+     *- @Title/Destination: check all test in classAllMethodTest passed for methods in interface
+     *- @Brief:no:
+     * -step1. check all test in classAllMethodTest passed for methods in interface
+     */
+    private static void method03() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod03"), "method03");
+        } catch (Exception e) {
+            System.out.println("Case method03 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method04
+     *- @Title/Destination: for same method in abstract class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in abstract class
+     */
+    private static void method04() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod04"), "method04");
+        } catch (Exception e) {
+            System.out.println("Case method04 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method05
+     *- @Title/Destination: for same method in anonymous class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. get the class instance of anonymous class
+     * -#step2. check all test in classAllMethodTest passed for methods in anonymous class
+     */
+    private static void method05() {
+        try {
+            // step 1
+            Class clazz = Class.forName("MethodTest");
+            MethodTest mainClass = new MethodTest();
+            Field method = clazz.getDeclaredField("testMethod05");
+
+            classAllMethodTest(method.get(mainClass).getClass(), "method05");
+        } catch (Exception e) {
+            System.out.println("Case method05 failed with exception" + e);
+        }
+    }
+
+    private Runnable testMethod05 = new Runnable() {
+        private final synchronized int intRunnable() {
+            return 1;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    /**
+     *- @TestCaseID: method06
+     *- @Title/Destination: for same method in local class(class in a function), certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in local class
+     */
+    private static void method06() {
+        class TestMethod06 {
+            private final int intLocalMethod() {
+                return 9;
+            }
+            public synchronized String stringLocal() {
+                return "a fake behind the fear";
+            }
+        }
+        try {
+            classAllMethodTest(Class.forName("MethodTest$1TestMethod06"), "method06");
+        } catch (Exception e) {
+            System.out.println("Case method06 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method07
+     *- @Title/Destination: for same method in inner class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in inner class
+     */
+    private static void method07() {
+        try {
+            classAllMethodTest(Class.forName("MethodTest$TestMethod07"), "method07");
+        } catch (Exception e) {
+            System.out.println("Case method07 failed with exception" + e);
+        }
+    }
+
+    class TestMethod07 {
+        private char charInnerMethod(int a, double... b) {
+            return 'l';
+        }
+        final public double doubleInnerMethod() {
+            return 1988.0416;
+        }
+    }
+
+    /**
+     *- @TestCaseID: method08
+     *- @Title/Destination: for same method in enum class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in enum class
+     */
+    private static void method08() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod08"), "method08");
+        } catch (Exception e) {
+            System.out.println("Case method08 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method09
+     *- @Title/Destination: for same method in parent class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in parent class
+     */
+    private static void method09() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod09"), "method09");
+        } catch (Exception e) {
+            System.out.println("Case method09 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method10
+     *- @Title/Destination: for same method in child class with implemented interface, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in child class with implemented interface
+     */
+    private static void method10() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod10"), "method10");
+        } catch (Exception e) {
+            System.out.println("Case method10 failed with exception" + e);
+        }
+    }
+
+    /**
+     *- @TestCaseID: method11
+     *- @Title/Destination: for same method in interface implemented by another class, certain APIs return different Method object when called twice
+     *- @Brief:no:
+     * -#step1. check all test in classAllMethodTest passed for methods in interface implemented by another class
+     */
+    private static void method11() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod11"), "method11");
+        } catch (Exception e) {
+            System.out.println("Case method11 failed with exception" + e);
+        }
+    }
+}
+
+class TestMethod02 {
+    // step1
+    void voidMethod() {}
+    boolean booleanMethod() {
+        return true;
+    }
+    byte byteMethod() {
+        return (byte)1;
+    }
+    short shortMethod() {
+        return (short)2;
+    }
+    int intMethod() {
+        return 3;
+    }
+    long longMethod() {
+        return 4l;
+    }
+    char charMethod() {
+        return 'a';
+    }
+    float floatMethod() {
+        return 0.9f;
+    }
+    double doubleMethod() {
+        return 0.416;
+    }
+    String stringMethod() {
+        return "The queerest of the queer";
+    }
+    Runnable[] rArrayMethod() {
+        return null;
+    }
+    boolean[][][][][][][] booleanArray7Method() {
+        return new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    }
+    String[][][] stringArray3Method() {
+        return new String[][][] {{{"the strangest of the strange"}}};
+    }
+
+    int parameterMethod(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                        boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                        String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+        return 1;
+    }
+
+    // step2
+    public int publicIntMethod(boolean a) {
+        return 88;
+    }
+    protected double protectedDoubleMethod(byte a) {
+        return 99;
+    }
+    private String privateStringMethod(String a) {
+        return "the coldest of the cool";
+    }
+
+    // step3
+    strictfp double[][] transientDoubleArrayMethod(float[][] a) {
+        return new double[][] {{1988, 4.16}};
+    }
+    final int finalIntMethod() {
+        return 9876;
+    }
+    synchronized String volatileStringMethod() {
+        return "the lamest of the lame";
+    }
+    static Character staticCharacterMethod(Thread.State a) {
+        return 'd';
+    }
+
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotationMethod() {
+        return new String[][] {{"the numbest of the dumb"}};
+    }
+}
+
+interface TestMethod03 {
+    String stringInterfaceMethod(int[] a);
+    char[][][] charArrayInterfaceMethod(double... a);
+}
+
+abstract class TestMethod04 {
+    public static final synchronized String[] stringsAbstractArrayMethod() {
+        return new String[] {"i hate to see you here", "you choke behind a smile"};
+    }
+    abstract Runnable runnableAbstractMethod();
+}
+
+enum TestMethod08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnumMethod() {
+        return (short)6;
+    }
+    public final String stringEnumMethod(int... a) {
+        return "Dry Martini";
+    }
+}
+
+class TestMethod09 {
+    public int int09Method() {
+        return 1;
+    }
+    protected boolean boolean09Method() {
+        return false;
+    }
+    char[] chars09Method() {
+        return new char[] {'a', 'b', 'c'};
+    }
+    private String string09Method() {
+        return "I'm only happy when it rains";
+    }
+}
+
+class TestMethod10 extends TestMethod09 implements TestMethod11 {
+    public boolean boolean09Method() {
+        return true;
+    }
+    public double double10Method() {
+        return 0.416;
+    }
+    public char[] chars09Method() {
+        return new char[] {'a'};
+    }
+    public String string09Method() {
+        return "SHALALALA";
+    }
+}
+
+interface TestMethod11 {
+    int int09Method();
+    boolean boolean09Method();
+    char[] chars09Method();
+    String string09Method();
+}
+
+// DEPENDENCE: FieldTest.java
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/ReflectionForName2.java b/test/testsuite/ouroboros/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/ReflectionForName2.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f15ecace673cfe3f363f3f9a096cf557a04849b
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/ReflectionForName2.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectionForName2
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ReflectionForName2.java
+ *- @Title/Destination: Use Class.forName to get class, Static initialization blocks for target classes are executed
+ *                      when initialized set to True.
+ *- @Brief:no:
+ * -#step1: 定义一个类1，含有静态块，初始化会新建文件1。
+ * -#step2：判断文件1是否存在，如果存在删除该文件。
+ * -#step3：调用static Class<?> forName(String name, boolean initialize, ClassLoader loader)获取类1，initialize为true。
+ * -#step4：检查类的静态块被初始化，产生新的文件1。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ReflectionForName2.java
+ *- @ExecuteClass: ReflectionForName2
+ *- @ExecuteArgs:
+ */
+
+import java.io.File;
+import java.io.IOException;
+
+class ForName2 {
+    static {
+        File cls2 = new File("/data/local/tmp/ReflectionForName2.txt");
+        try {
+            cls2.createNewFile();
+        } catch (IOException e) {
+            System.err.println(e);
+        }
+    }
+}
+
+public class ReflectionForName2 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        File cls1 = new File("/data/local/tmp/ReflectionForName2.txt");
+        if (cls1.exists()) {
+            cls1.delete();
+        }
+        Class cls = Class.forName("ForName2", true, ForName2.class.getClassLoader());
+        if (cls1.exists()) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/ClassInitFieldSetCharInterface.java b/test/testsuite/ouroboros/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/ClassInitFieldSetCharInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..54c892d5dc3f6c32a7d29d1ee73b912653f0a3c4
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/ClassInitFieldSetCharInterface.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetCharInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetCharInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setChar(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setChar(null, (char)46), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetCharInterface.java
+ *- @ExecuteClass: ClassInitFieldSetCharInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetCharInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.setChar(null, (char) 46);
+            }
+        } catch (IllegalAccessException e) {
+            result.append("IllegalAccessException");
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldSetCharInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldSetCharInterface.result.append("One").toString();
+    char hiChar = (char) 45;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldSetCharInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetCharInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/ClassInitFieldSetDoubleInterface.java b/test/testsuite/ouroboros/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/ClassInitFieldSetDoubleInterface.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bb8c19626b324aeb5f3324f65fd55d8e5728b6d
--- /dev/null
+++ b/test/testsuite/ouroboros/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/ClassInitFieldSetDoubleInterface.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ClassInitFieldSetDoubleInterface
+ *- @RequirementName: Java Reflection
+ *- @TestCaseName:ClassInitFieldSetDoubleInterface.java
+ *- @Title/Destination: When f is a field of interface OneInterface and call f.setDouble(), OneInterface is initialized,
+ *                      it's parent interface is not initialized.
+ *- @Brief:no:
+ * -#step1: Class.forName("OneInterface", false, OneInterface.class.getClassLoader()) and clazz.getField to get field f
+ *          of OneInterface.
+ * -#step2: Call method f.setDouble(null), OneInterface is initialized.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ClassInitFieldSetDoubleInterface.java
+ *- @ExecuteClass: ClassInitFieldSetDoubleInterface
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ClassInitFieldSetDoubleInterface {
+    static StringBuffer result = new StringBuffer("");
+
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.setDouble(null, 0.265874);
+            }
+        } catch (IllegalAccessException e) {
+            result.append("IllegalAccessException");
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+            return;
+        } else {
+            System.out.println(2);
+            return;
+        }
+    }
+}
+
+interface SuperInterface {
+    String aSuper = ClassInitFieldSetDoubleInterface.result.append("Super").toString();
+}
+
+@A
+interface OneInterface extends SuperInterface {
+    String aOne = ClassInitFieldSetDoubleInterface.result.append("One").toString();
+    double hiDouble = 0.1532;
+}
+
+interface TwoInterface extends OneInterface {
+    String aTwo = ClassInitFieldSetDoubleInterface.result.append("Two").toString();
+}
+
+@interface A {
+    String aA = ClassInitFieldSetDoubleInterface.result.append("Annotation").toString();
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0001-rt-String-StmtTest01/StmtTest01.java b/test/testsuite/ouroboros/stmtpre_test/RT0001-rt-String-StmtTest01/StmtTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a4f241028dbe53654e6132c65a1545cdf6a2cdf
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0001-rt-String-StmtTest01/StmtTest01.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest01
+ *- @TestCaseName: StmtTest01
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief:在同一个函数统一分支中出现的字符串常量冗余时，只需要为该字符串常量调用一次runtime的MCC_GetOrInsertLiteral函数。
+ *  -#step1: 创建一个函数，在该函数中反复调用一个特定的字符串常量做相关操作;
+ *  -#step2: 在main行数用if-else创造两个互斥分支。
+ *  -#step3: 校验中间文件SmtmTest01.VtableImpl.mpl中 callassigned &MCC_GetOrInsertLiteral出现的次数：3次。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest01.java
+ *- @ExecuteClass: StmtTest01
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest01 {
+    public static void main(String[] args) {
+        if (test()) {
+            System.out.println("ExpectResult");  // 1
+        } else {
+            String string = "ExpectResult" + "ExpectResult"; // 2
+            System.out.println(string);
+        }
+    }
+
+    // 基础的测试
+    private static boolean test() {
+        String string = "A"; // 3
+        for (int ii = 0; ii < 100; ii++) {
+            string += "A";
+        }
+        return string.length() == 101;  //true;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0002-rt-String-StmtTest02/StmtTest02.java b/test/testsuite/ouroboros/stmtpre_test/RT0002-rt-String-StmtTest02/StmtTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..abfc1a51db96035fa9b458ce062ee11f7602d7ef
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0002-rt-String-StmtTest02/StmtTest02.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest02
+ *- @TestCaseName: StmtTest02
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief:在同一个函数同一个分支中出现的字符串常量冗余，只需要为该字符串常量调用一次runtime的MCC_GetOrInsertLiteral函数。涉及到另外函数调用时，不会做该优化
+ *  -#step1: 创建一个函数，在该函数中反复调用一个特定的字符串常量做相关操作;再起另一个函数调用该函数，在这个函数中也有该常量字符串的操作。
+ *  -#step2: 在main行数用if-else创造两个互斥分支。
+ *  -#step3: 校验中间文件SmtmTest02.VtableImpl.mpl中callassigned &MCC_GetOrInsertLiteral出现的次数：4次。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest02.java
+ *- @ExecuteClass: StmtTest02
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest02 {
+    public static void main(String[] args) {
+        if (test1()) {
+            System.out.println("ExpectResult"); // 1
+        } else {
+            System.out.println("ExpectResult " + "ExpectResult"); // 2
+        }
+    }
+
+    // 基础的测试
+    private static boolean test() {
+        String string = "A"; // 3
+        for (int ii = 0; ii < 100; ii++) {
+            string += "A";
+        }
+        return string.length() == 101;  //true;
+    }
+
+    // 有函数调用,确认
+    private static boolean test1() {
+        String str1 = "A" + "A"; // 4
+        String str2 = "A" + "A";
+        if (test() == true) {
+            str2 = str1;
+        }
+        return str1 == str1; //true
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0003-rt-String-StmtTest03/StmtTest03.java b/test/testsuite/ouroboros/stmtpre_test/RT0003-rt-String-StmtTest03/StmtTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..a158c5c473b42fbbd19a435b1395fcbc3153a678
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0003-rt-String-StmtTest03/StmtTest03.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest03
+ *- @TestCaseName: StmtTest03
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief:涉及接口实现的场景下，在同一个函数同一分支中出现的字符串常量，只需要为该字符串常量调用一次runtime的MCC_GetOrInsertLiteral函数。
+ *  -#step1: 创建一个实现接口的类，在该类中实现接口中的函数test()，在该函数中反复调用一个特定的字符串常量做相关操作;
+ *  -#step2: 在main行数用if-else创造两个互斥分支。
+ *  -#step3: 校验中间文件SmtmTest03.VtableImpl.s中callassigned &MCC_GetOrInsertLiteral出现的次数：3次。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest03.java
+ *- @ExecuteClass: StmtTest03
+ *- @ExecuteArgs:
+ */
+
+interface Interface {
+    boolean test();
+}
+
+public class StmtTest03 implements Interface {
+    public static void main(String[] args) {
+        if (new StmtTest03().test()) {
+            System.out.println("ExpectResult");  // 1
+        } else {
+            System.out.println("ExpectResult " + "ExpectResult"); // 2
+        }
+    }
+
+    // 实现接口
+    public boolean test() {
+        String str1 = "A" + "A"; // 3
+        String str2 = "A" + "A";
+        return str1 == str2;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0004-rt-String-StmtTest04/StmtTest04.java b/test/testsuite/ouroboros/stmtpre_test/RT0004-rt-String-StmtTest04/StmtTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bafa8a16e84e375eec7a47f9270a1750275ca6d
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0004-rt-String-StmtTest04/StmtTest04.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest04
+ *- @TestCaseName: StmtTest04
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief:在继承的场景下，在同一个函数中出现的字符串常量，只需要调用runtime的MCC_GetOrInsertLiteral函数只会为该字符串常量调用一次。
+ *  -#step1: 创建一个有父类的类，在该类中父类中的函数test1()，在该函数中调用一个特定的字符串常量做相关操作;
+ *  -#step2: 在main行数用if-else创造两个互斥分支。
+ *  -#step3: 校验中间文件SmtmTest04.VtableImpl.s中callassigned &MCC_GetOrInsertLiteral出现的次数：4次。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest04.java
+ *- @ExecuteClass: StmtTest04
+ *- @ExecuteArgs:
+ */
+
+class Father {
+    public String name;
+
+    public boolean test1() {
+        String str1 = "A" + "A"; // 1
+        String str2 = "A" + "A";
+        return str1 == str2; // false;
+    }
+}
+
+public class StmtTest04 extends Father {
+    public String name;
+
+    public static void main(String[] args) {
+        Father father = new StmtTest04();
+        father.name = "ExpectResult"; // 2
+        if (father.test1()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ExpectResult" + " " + "ExpectResult"); // 4
+        }
+    }
+
+    // 集成父类
+    @Override
+    public boolean test1() {
+        String str1 = "A" + "A"; // 3
+        String str2 = "A" + "A";
+        return str1.equals(str2); // true;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0005-rt-String-StmtTest05/StmtTest05.java b/test/testsuite/ouroboros/stmtpre_test/RT0005-rt-String-StmtTest05/StmtTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..edc40cd8c042128c9293c8cdefda2d3f6125386d
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0005-rt-String-StmtTest05/StmtTest05.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest05
+ *- @TestCaseName: StmtTest05
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief:在同一个函数中，有Switch-多case分支时，在同一个数据流中出现的冗余字符串常量，只需要为该字符串常量调用一次runtime的MCC_GetOrInsertLiteral函数。
+ *  -#step1: 在main行数用switch - case创造两个互斥分支。
+ *  -#step2: 校验中间文件StmtTest05.VtableImpl.mpl中 callassigned &MCC_GetOrInsertLiteral出现的次数：6次。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest05.java
+ *- @ExecuteClass: StmtTest05
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest05 {
+    public static void main(String[] args) {
+        String test = "TestStringForStmt"; // 1
+        switch (test) {
+            case "TestStringForStmt33": // 6
+                test = "TestStringForStmt01"; // 2
+                break;
+            case "TestStringForStmt55":  // 3
+                test += "TestStringForStmt01"; // 4
+                break;
+            default:
+                test = "TestStringForStmt";
+                break;
+        }
+
+        String output = "ExpectResult"; // 5
+        if (test == "TestStringForStmt") {
+            System.out.println(output);
+        } else {
+            System.out.print("ExpectResult");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0006-rt-String-StmtTest06/StmtTest06.java b/test/testsuite/ouroboros/stmtpre_test/RT0006-rt-String-StmtTest06/StmtTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f8e36a0a258099ac5ce6240f92d90db1003da75
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0006-rt-String-StmtTest06/StmtTest06.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest06
+ *- @TestCaseName: StmtTest06
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief:在同一个函数中，有try-多catch分支时，在同一个数据流中出现的冗余字符串常量，只需要为该字符串常量调用一次runtime的MCC_GetOrInsertLiteral函数。
+ *  -#step1: 在main行数用stry-多catch创造两个互斥分支
+ *  -#step2: 校验中间文件StmtTest06.VtableImpl.mpl中 callassigned &MCC_GetOrInsertLiteral出现的次数：3次。
+ *- @Expect:123#\n
+ *- @Priority: High
+ *- @Source: StmtTest06.java
+ *- @ExecuteClass: StmtTest06
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest06 {
+    public static void main(String[] argv) {
+        int result = 2;
+        boolean check;
+        String str = "123#";  // 1
+        try {
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            str = "123#456";  // 2
+            result--;
+        } catch (NullPointerException e) {
+            str = "123456";  // 3
+            result = 2;
+        } catch (OutOfMemoryError e) {
+            str += "123#456";  // 被外提
+            result = 2;
+        } finally {
+            check = str == "123#456";
+            result--;
+        }
+        if (check == true && result == 0) {
+            System.out.println("123#");
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 123#\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0007-rt-String-StmtTest07/StmtTest07.java b/test/testsuite/ouroboros/stmtpre_test/RT0007-rt-String-StmtTest07/StmtTest07.java
new file mode 100644
index 0000000000000000000000000000000000000000..f90b9eb742bee91ee0d9145cf9498be35af56dae
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0007-rt-String-StmtTest07/StmtTest07.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest07
+ *- @TestCaseName: StmtTest07
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief: 在同一个函数统一分支(try{For循环嵌套}catch{})中出现的字符串常量冗余时，只需要为该字符串常量调用一次runtime的MCC_GetOrInsertLiteral函数。
+ *  -#step1: 在test()函数用for多层嵌套、try-多catch创造for嵌套和互斥分支，并冗余使用字符串常量
+ *  -#step2: 校验中间文件SmtmTest07.VtableImpl.mpl中 callassigned &MCC_GetOrInsertLiteral出现的次数：4次。
+ *- @Expect:AA\nExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest07.java
+ *- @ExecuteClass: StmtTest07
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest07 {
+    public static void main(String[] args) {
+        if (test()) {
+            System.out.println("ExpectResult");  // 1
+        } else {
+            String string = "ExpectResult" + "ExpectResult"; // 2
+            System.out.println(string);
+        }
+    }
+
+    // 基础的测试for循环嵌套
+    private static boolean test() {
+        String string = "AA"; // 3
+        for (int ii = 0; ii < 10; ii++) {
+            string = "AA";
+            for (int jj = 0; jj < 10; jj++) {
+                for (int kk = 0; kk < 2; kk++) {
+                    string += "AA";
+                }
+            }
+        }
+        try {
+            string = "AA";
+            for (int jj = 0; jj < 10; jj++) {
+                for (int ii = 0; ii < getInt(); ii++) {
+                    string += "123";  // 4
+                }
+            }
+        } catch (ArithmeticException a) {
+            System.out.println(string);
+        }
+        return string.length() == 2;  //true;
+    }
+
+    private static int getInt() {
+        return 1 / 0;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full AA\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0008-rt-String-StmtTest08/StmtTest08.java b/test/testsuite/ouroboros/stmtpre_test/RT0008-rt-String-StmtTest08/StmtTest08.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b4855a99f87052c4f8aff438f2bd271c53bb8fa
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0008-rt-String-StmtTest08/StmtTest08.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest08
+ *- @TestCaseName: StmtTest08
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief: 在同一个函数统一分支if-else多分支中出现的字符串常量冗余时，同一数据流里的冗余字符串常量只需要为该字符串常量才会调用一次runtime的MCC_GetOrInsertLiteral函数。
+ *  -#step1: 在test1()函数有多层if-else分支，并冗余使用字符串常量
+ *  -#step2: 校验中间文件StmtTest08.VtableImpl.mpl中callassigned &MCC_GetOrInsertLiteral出现的次数：7次。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest08.java
+ *- @ExecuteClass: StmtTest08
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest08 {
+    public static void main(String[] args) {
+        if (test1() == false) {
+            System.out.println("ExpectResult"); // 1
+        } else {
+            System.out.println("ExpectResult " + "ExpectResult"); // 2
+        }
+    }
+
+    // 基础的测试
+    private static boolean test() {
+        String string = "A"; // 3
+        for (int ii = 0; ii < 100; ii++) {
+            string += "A";
+        }
+        return string.length() == 101;  //true;
+    }
+
+    // 有函数调用,确认
+    private static boolean test1() {
+        String str1 = "AA"; // 4
+        String str2;
+        if (test() == true) {
+            str2 = str1;
+            if (str2 == "AA") {
+                str2 = str2.substring(0, 1);
+            } else {
+                str1 = "AAA"; // 5
+            }
+        } else {
+            str2 = "A"; // 6
+            if (str2.equals("AA")) {
+                str2 = str2.substring(0, 1);
+            } else {
+                str1 = "AAA"; // 7
+            }
+        }
+        return str2 == str1; //true
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0009-rt-String-StmtTest09/StmtTest09.java b/test/testsuite/ouroboros/stmtpre_test/RT0009-rt-String-StmtTest09/StmtTest09.java
new file mode 100644
index 0000000000000000000000000000000000000000..95f1f293d915a7df7b8de5a79428d74cb26380c4
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0009-rt-String-StmtTest09/StmtTest09.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest09
+ *- @TestCaseName: StmtTest09
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief: 在同一个函数同一个分支(多层switch嵌套)中出现的字符串常量冗余，只需要为该字符串常量调用一次runtime的MCC_GetOrInsertLiteral函数。涉及到函数调用时，不会做该优化
+ *  -#step1: 在main方法中函数有switch-多case分支，并冗余使用字符串常量
+ *  -#step2: 校验中间文件StmtTest09.VtableImpl.mpl中callassigned &MCC_GetOrInsertLiteral出现的次数：8次。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest09.java
+ *- @ExecuteClass: StmtTest09
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest09 {
+    public static void main(String[] args) {
+        String test = "TestStringForStmt"; // 1
+        switch (test) {
+            case "TestStringForStmt33": // 2
+                test = "TestStringForStmt01"; // 3
+                break;
+            case "TestStringForStmt55":  // 4
+                test += "TestStringForStmt01"; // 其他优化导致"TestStringForStmt01"的地址调用外提到22行，所以与33行合用。
+                break;
+            default:
+                switch (test) {
+                    case "TestStringForStmt34": // 5
+                        test = "TestStringForStmt01"; // 其他优化导致"TestStringForStmt01"的地址调用外提到22行，所以与33行合用
+                        break;
+                    case "TestStringForStmt35":  // 6
+                        test += "TestStringForStmt01"; // 7
+                        break;
+                    default:
+                        test = "TestStringForStmt";
+                        break;
+                }
+        }
+        String output = "ExpectResult"; // 8、
+        if (test == "TestStringForStmt") {
+            System.out.println(output);
+        } else {
+            System.out.print("ExpectResult");
+        }
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0010-rt-String-StmtTest10/StmtTest10.java b/test/testsuite/ouroboros/stmtpre_test/RT0010-rt-String-StmtTest10/StmtTest10.java
new file mode 100644
index 0000000000000000000000000000000000000000..05f9f94d315d4643b7d2d6edf57fde27c88256ba
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0010-rt-String-StmtTest10/StmtTest10.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest10
+ *- @TestCaseName: StmtTest10
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief: 在同一个函数同一个分支(多层try-多cathc嵌套)中出现的字符串常量冗余，只需要为该字符串常量调用一次runtime的MCC_GetOrInsertLiteral函数。涉及到函数调用时，不会做该优化
+ *  -#step1: 在main方法中函数有两层try-多catch分支，并冗余使用字符串常量
+ *  -#step2: 校验中间文件StmtTest10.VtableImpl.mpl中 callassigned &MCC_GetOrInsertLiteral出现的次数：4次。
+ *           注："123#456"的函数调用会外提，因此在实际的中间代码里出现的次数是4次。
+ *- @Expect:123#\n
+ *- @Priority: High
+ *- @Source: StmtTest10.java
+ *- @ExecuteClass: StmtTest10
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest10 {
+    public static void main(String[] argv) {
+        int result = 2;
+        boolean check;
+        String str = "123#";  // 1
+        try {
+            str = "123456"; // 2
+            try {
+                Integer.parseInt(str);
+            } catch (NumberFormatException e) {
+                str = "123#456";  // 3
+                result--;
+            } catch (NullPointerException e) {
+                str = "123456#"; // 4
+                result = 2;
+            } catch (OutOfMemoryError e) {
+                str += "123#456";  // 与32行被其他优化了
+                result = 2;
+            } finally {
+                str = "123#456";
+            }
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            str = "123#456";
+            result--;
+        } catch (NullPointerException e) {
+            str = "123456";
+            result = 2;
+        } catch (OutOfMemoryError e) {
+            str += "123#456";
+            result = 2;
+        } finally {
+            check = str == "123#456";
+            result--;
+        }
+        if (check == true && result == 0) {
+            System.out.println("123#");
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 123#\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0011-rt-String-StmtTest11/StmtTest11.java b/test/testsuite/ouroboros/stmtpre_test/RT0011-rt-String-StmtTest11/StmtTest11.java
new file mode 100644
index 0000000000000000000000000000000000000000..96eba402a3707536597c3a50766cb2705b0092e8
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0011-rt-String-StmtTest11/StmtTest11.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest11
+ *- @TestCaseName: StmtTest11
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief: 在同一个函数同一数据流分支(For/If-else/try-catch/switch-case)中出现的字符串常量冗余时，只需要为该字符串常量调用一次runtime的MCC_GetOrInsertLiteral函数。
+ *  -#step1: 在main方法中函数有try-catch/switch-case/if-else嵌套使用，并冗余使用字符串常量
+ *  -#step2: 校验中间文件StmtTest11.VtableImpl.mpl中 callassigned &MCC_GetOrInsertLiteral出现的次数：6次。
+ *- @Expect:AB\nExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest11.java
+ *- @ExecuteClass: StmtTest11
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest11 {
+    public static void main(String[] args) {
+        if (test()) {
+            System.out.println("ExpectResult");  // 1
+        } else {
+            String string = "ExpectResultExpectResult"; // 2
+            System.out.println(string);
+        }
+    }
+
+    // 基础的测试for循环嵌套
+    private static boolean test() {
+        String string = "AA"; // 3
+        try {
+            string = "AB"; // 4
+            if (string.length() == 2) {
+                for (int jj = 0; jj < 10; jj++) {
+                    for (int ii = 0; ii < getInt(); ii++) {
+                        string += "123";  // 5,被外提
+                    }
+                }
+            } else {
+                switch (string) {
+                    case "A": // 6
+                        string = "123"; //被外提
+                        break;
+                    case "AA":
+                        string = "A";
+                        break;
+                    default:
+                        break;
+                }
+            }
+        } catch (ArithmeticException a) {
+            System.out.println(string);
+        }
+        return string.length() == 2;  //true;
+    }
+
+    private static int getInt() {
+        return 1 / 0;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full AB\nExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0013-rt-String-StmtTest13/StmtTest13.java b/test/testsuite/ouroboros/stmtpre_test/RT0013-rt-String-StmtTest13/StmtTest13.java
new file mode 100644
index 0000000000000000000000000000000000000000..f3000defcd7d17b30b56a1fe03d525109ae00691
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0013-rt-String-StmtTest13/StmtTest13.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest13
+ *- @TestCaseName: StmtTest13
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief: 字符串常量在字符串常量池中，引用变量拼接和new出来的在堆上，不会做该优化，实例变量上的字符串常量不参与常量。
+ *  -#step1: 校验中间文件StmtTest13.VtableImpl.mpl中 callassigned &MCC_GetOrInsertLiteral出现的次数：3次。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: StmtTest13.java
+ *- @ExecuteClass: StmtTest13
+ *- @ExecuteArgs:
+ */
+
+public class StmtTest13 {
+    private String outOfMethod = "AB"; //3
+
+    public static void main(String[] args) {
+        String string = "AB"; // 1
+        for (int ii = 0; ii < 10; ii++) {
+            string += "A" + "B";
+        }
+        if (string.length() == 22) {
+            string = "AB"; //此处在堆上分配内存，不会用第22行的伪寄存器地址
+        } else {
+            char[] chars = {'A', 'B'};
+            string = chars.toString();
+        }
+        if (string.equals(new StmtTest13().outOfMethod)) {
+            System.out.println("ExpectResult");  // 2
+        } else {
+            System.out.print("ExpectResult");  //优化外提，这边不会再取一次。
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/stmtpre_test/RT0014-rt-String-StmtTest14/StmtTest14.java b/test/testsuite/ouroboros/stmtpre_test/RT0014-rt-String-StmtTest14/StmtTest14.java
new file mode 100644
index 0000000000000000000000000000000000000000..71bcbed87e0d4fc3723be7754a035975e2a703de
--- /dev/null
+++ b/test/testsuite/ouroboros/stmtpre_test/RT0014-rt-String-StmtTest14/StmtTest14.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_StmtTest13
+ *- @TestCaseName: StmtTest13
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Store PRE和Stmt PRE使能(store PRE 收益十分有限，先挂起)
+ *- @Brief: 字符串常量在各种情况下出现冗余时，都应该用优化后的同一个伪寄存器地址。
+ *  -#step1: 校验中间文件StmtTest14.VtableImpl.mpl中 callassigned &MCC_GetOrInsertLiteral出现的次数：1次。
+ *- @Expect:AB\n
+ *- @Priority: High
+ *- @Source: StmtTest14.java
+ *- @ExecuteClass: StmtTest14
+ *- @ExecuteArgs:
+ */
+
+import java.nio.charset.StandardCharsets;
+
+public class StmtTest14 {
+    public static void main(String[] args) {
+        String string = "AB"; // 1
+        for (int ii = 0; ii < 10; ii++) {
+            string += "A" + "B"; // +号拼接场景
+        }
+        if (string.length() == 22) {
+            string = "AB"; // 作为入参
+        } else {
+            char[] chars = "AB".toCharArray(); // 作为函数调用主体
+            string = chars.toString();
+        }
+        byte[] bs = string.getBytes();
+        string = new String(bs, StandardCharsets.US_ASCII);
+        System.out.println(string);
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full AB\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0001-rt-string-ReflectString/ReflectString.java b/test/testsuite/ouroboros/string_test/RT0001-rt-string-ReflectString/ReflectString.java
new file mode 100644
index 0000000000000000000000000000000000000000..00eea34c2febed812eec96bb4085f8d4e7d89c94
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0001-rt-string-ReflectString/ReflectString.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ReflectString.java
+ * -@TestCaseName: String.class.newInstance
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1:create String instance by Reflect
+ * -#step1:check the instance corret
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: ReflectString.java
+ * -@ExecuteClass: ReflectString
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ReflectString {
+    static int res = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+
+        try {
+            ReflectString_1();
+        } catch (Exception e) {
+            res -= 10;
+        }
+        if (result == 2 && res == 95) {
+            result = 0;
+        }
+        return result;
+
+    }
+
+    public static void ReflectString_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        Object test1 = null;
+        try {
+            test1 = String.class.newInstance();
+            res -= 4;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+        }
+//        System.out.println("test1:"+ test1);
+
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0002-rt-String-BufferConstructorsTest/StringBufferConstructorsTest.java b/test/testsuite/ouroboros/string_test/RT0002-rt-String-BufferConstructorsTest/StringBufferConstructorsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d91ec7007d6dd681797531bb751363a799e280cc
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0002-rt-String-BufferConstructorsTest/StringBufferConstructorsTest.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferConstructorsTest.java
+ * -@TestCaseName: Test String Buffer Constructors StringBuffer(String str)/StringBuffer()/StringBuffer(int capacity)
+ *                     /StringBuffer(CharSequence seq).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#case1
+ * -#step1: Create a String instance By new and not new.
+ * -#step2: Test Constructor StringBuffer(String str).
+ * -#step3: Check new StringBuffer instance is new correctly.
+ * -#step4: Change Parameter str Traversing String mix with Letter and special symbols and Number、empty String、null to
+ *          repeat step2~3.
+ * -#case2
+ * -#step1: Test new StringBuffer() and check the capacity() of instance is correctly.
+ * -#step2: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step1.
+ * -#case3
+ * -#step1: Create capacity > 0 or capacity = 0, test new StringBuffer(int capacity), check the capacity() of instance
+ *          is correctly.
+ * -#case4
+ * -#step1: Create seq Contains numbers, letters, special symbols, test StringBuffer(CharSequence seq), check new
+ *          instance is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferConstructorsTest.java
+ * -@ExecuteClass: StringBufferConstructorsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferConstructorsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferConstructorsTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferConstructorsTest_1() {
+        String str1_1 = new String("abc123abc");
+        String str1_2 = new String(" @!.&%()*");
+        String str1_3 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                        "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "abc123ABC";
+        String str2_2 = " @!.&%()*";
+        String str2_3 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZX" +
+                        "CVBNM0x96";
+        String str2_4 = "";
+
+        test1_1(str1_1);
+        test1_1(str1_2);
+        test1_1(str1_3);
+        test1_1(str1_4);
+        test1_1(str1_5);
+        test1_1(str2_1);
+        test1_1(str2_2);
+        test1_1(str2_3);
+        test1_1(str2_4);
+
+        StringBuffer strBuffer1_1 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=" +
+                                    "!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+
+        test1_2(strBuffer1_1);
+        test1_2(strBuffer1_2);
+        test1_2(strBuffer1_3);
+        test1_2(strBuffer1_4);
+        test1_2(strBuffer1_5);
+
+        test1_3();
+        test1_4();
+        test1_5();
+    }
+
+    private static void test1_1(String str) {
+        System.out.println(new StringBuffer(str));
+    }
+
+    private static void test1_2(StringBuffer strBuffer) {
+        System.out.println(strBuffer.toString());
+    }
+
+    // Test new StringBuffer().
+    private static void test1_3() {
+        StringBuffer strBuffer1_6 = new StringBuffer();
+        System.out.println(strBuffer1_6.capacity());
+    }
+
+    // Test new StringBuffer(int capacity).
+    private static void test1_4() {
+        int capacity = 20;
+        StringBuffer strBuffer1_6 = new StringBuffer(capacity);
+        System.out.println(strBuffer1_6.capacity());
+        int capacityMin = 0;
+        strBuffer1_6 = new StringBuffer(capacityMin);
+        System.out.println(strBuffer1_6.capacity());
+    }
+
+    // Test new StringBuffer(CharSequence seq).
+    private static void test1_5() {
+        CharSequence chs1_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTY" +
+                "UIOPZXCVBNM0x96";
+        StringBuffer strBuffer1_7 = new StringBuffer(chs1_1);
+        test1_2(strBuffer1_7);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123abc\n @!.&%()*\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n\nabc123ABC\n @!.&%()*\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\nabc123abc\n @!.&%()*\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n\n16\n20\n0\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/StringBufferAppendAndAppendCodePointTest.java b/test/testsuite/ouroboros/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/StringBufferAppendAndAppendCodePointTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fecba4ffd2c06eb7c8e4167e484421074ad49edd
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/StringBufferAppendAndAppendCodePointTest.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferAppendAndAppendCodePointTest.java
+ * -@TestCaseName: Test method append(boolean b)/append(char c)/append(char[] str)/append(CharSequence s)/
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      append(CharSequence s, int start, int end)/append(double d)/append(float f)/append(int i)/
+ *                      append(long lng)/append(Object obj)/append(String str)/append(StringBuffer sb)/
+ *                      appendCodePoint(int codePoint) of StringBuffer.
+ * -@Brief:
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameter str is a String instance, test method append(String str).
+ * -#step3: Create parameter b is true or false, test method append(boolean b).
+ * -#step4: Create parameter c is a letter, test method append(char c).
+ * -#step5: Create parameter data.length > 0, data.element is a char, test method append(char[] data).
+ * -#step6: Create parameter s is a CharSequence, test method append(CharSequence s).
+ * -#step7: Create parameters: s is a CharSequence, 0 =< start < end, end <= s.length, start and end coverage boundary
+ *          value. test method append(CharSequence s, int start, int end).
+ * -#step8: Create parameter d > 0 or d = 0, test method append(double d).
+ * -#step9: Create parameter f > 0 or f = 0, test method append(float f).
+ * -#step10: Create parameter i > 0 or i = 0, test method append(int i).
+ * -#step11: Create parameter lng > 0 or lng = 0, test method append(long lng).
+ * -#step12: Create parameter obj is a Object, test method append(Object obj).
+ * -#step13: Create parameter sb is a StringBuffer, test method append(StringBuffer sb).
+ * -#step14: Create parameter codePoint is unicode num, test method appendCodePoint(int codePoint).
+ * -#step15: Check the append result is correctly and the Src StringBuffer is correctly.
+ * -#step16: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~15.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferAppendAndAppendCodePointTest.java
+ * -@ExecuteClass: StringBufferAppendAndAppendCodePointTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferAppendAndAppendCodePointTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferAppendAndAppendCodePointTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferAppendAndAppendCodePointTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                                    "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+        test1(strBuffer1_5);
+    }
+
+    private static void test1(StringBuffer strBuffer) {
+        char c = 'C';
+        char[] data = {'A', 'B', 'C'};
+        CharSequence chs1_1 = "xyz";
+        double d = 8888.8888;
+        double dMin = 0;
+        float f = 99999999;
+        float fMin = 0;
+        int i = 77777777;
+        int iMin = 0;
+        long lng = 66666666;
+        long lngMin = 0;
+        Object obj = new String("object");
+        String str = "string";
+        StringBuffer sb = new StringBuffer("stringbuffer");
+        int codePoint = 74; // unicode 74 is J
+
+        System.out.println(strBuffer.append("-").append(true).append("-").append(false).append("-").append(c)
+                .append("-").append(data).append("-").append(chs1_1).append("-").append(chs1_1, 1, 2).append("-")
+                .append(chs1_1, 0, 3).append("-").append(chs1_1, 3, 3).append("-").append(chs1_1, 0, 0).append("-")
+                .append(d).append("-").append(dMin).append("-").append(f).append("-").append(fMin).append("-").append(i)
+                .append("-").append(iMin).append("-").append(lng).append("-").append(lngMin).append("-").append(obj)
+                .append("-").append(str).append("-").append(sb).append("-").appendCodePoint(codePoint));
+        System.out.println(strBuffer.subSequence(2, 8));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J\nertyui\n @!.&%()*-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J\n!.&%()\nabc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J\nc123ab\n-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J\nrue-fa\n-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J\nrue-fa\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0004-rt-String-BufferInsertTest/StringBufferInsertTest.java b/test/testsuite/ouroboros/string_test/RT0004-rt-String-BufferInsertTest/StringBufferInsertTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..251a10d8d705b6cc4e2fda0cfdc767e28e19a263
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0004-rt-String-BufferInsertTest/StringBufferInsertTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferInsertTest.java
+ * -@TestCaseName: Test Method insert(Various parameters) of StringBuffer include insert(int offset, boolean b)/
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      insert(int offset, char c)/insert(int offset, char[] str)/insert(int dstOffset, CharSequence s)/
+ *                      insert(int dstOffset, CharSequence s, int start, int end)/insert(int offset, double d)/insert
+ *                      (int offset, float f)/insert(int offset, int i)/insert(int offset, long l)/insert(int offset,
+ *                      Object obj)/insert(int offset, String str).
+ * -@Brief:
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: 0 =< offset < instance.length, offset test boundary value, str is a String, test method
+ *          insert(int offset, String str).
+ * -#step3: Create parameters: 0 =< offset < instance.length, offset test boundary value, b is true/false, test method
+ *          insert(int offset, boolean b).
+ * -#step4: Create parameters: 0 =< offset < instance.length, offset test boundary value, c is a char, test method
+ *          insert(int offset, char c).
+ * -#step5: Create parameters: 0 =< offset < instance.length, offset test boundary value, create a char[] data, test
+ *          method insert(int offset, char[] data).
+ * -#step6: Create parameters: 0 =< offset < instance.length, offset test boundary value, s is a CharSequence, test
+ *          method insert(int offset, CharSequence s).
+ * -#step7: Create parameters: 0 =< offset < instance.length, s is a CharSequence, 0 =< start < end, end <= s.length,
+ *          offset/start/end test boundary value, test method insert(int offset, CharSequence s, int start, int end).
+ * -#step8: Create parameters: 0 =< offset < instance.length, offset test boundary value, d > 0 or d = 0, test method
+ *          insert(int offset, double d).
+ * -#step9: Create parameters: 0 =< offset < instance.length, offset test boundary value, f > 0 or f = 0, test method
+ *          insert(int offset, float f).
+ * -#step10: Create parameters: 0 =< offset < instance.length, offset test boundary value, i > 0 or i = 0, test method
+ *           insert(int offset, int i).
+ * -#step11: Create parameters: 0 =< offset < instance.length, offset test boundary value, l > 0 or l = 0, test method
+ *           insert(int offset, long l).
+ * -#step12: Create parameters: 0 =< offset < instance.length, offset test boundary value, obj is a Object, test method
+ *           insert(int offset, Object obj).
+ * -#step13: Check the insert result is correctly and the Src instance is correctly.
+ * -#step14: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~13.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferInsertTest.java
+ * -@ExecuteClass: StringBufferInsertTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferInsertTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferInsertTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferInsertTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+        test1(strBuffer1_5);
+    }
+
+    private static void test1(StringBuffer strBuffer) {
+        boolean b = true;
+        char c = 'C';
+        char[] data = {'A', 'B', 'C'};
+        CharSequence chs1_1 = "xyz";
+        double d = 8888.8888;
+        double dMin = 0;
+        float f = 99999999;
+        float fMin = 0;
+        int i = 77777777;
+        int iMin = 0;
+        long lng = 66666666;
+        long lngMin = 0;
+        Object obj = new String("object");
+        String str = "-";
+
+        System.out.println(strBuffer.insert(0, str).insert(0, b).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), b).insert(0, str).insert(0, false).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), false).insert(0, str).insert(0, c).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), c).insert(0, str).insert(0, data).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), data).insert(0, str).insert(0, chs1_1).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), chs1_1).insert(0, str).insert(0, chs1_1, 1, 2)
+                .insert(strBuffer.length(), str).insert(strBuffer.length(), chs1_1, 1, 2).insert(0, str)
+                .insert(0, chs1_1, 0, 3).insert(strBuffer.length(), str).insert(strBuffer.length(), chs1_1, 0, 3)
+                .insert(0, str).insert(0, chs1_1, 3, 3).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), chs1_1, 3, 3).insert(0, str).insert(0, chs1_1, 0, 0)
+                .insert(strBuffer.length(), str).insert(strBuffer.length(), chs1_1, 0, 0).insert(0, str).insert(0, d)
+                .insert(strBuffer.length(), str).insert(strBuffer.length(), d).insert(0, str).insert(0, dMin)
+                .insert(0, str).insert(0, f).insert(strBuffer.length(), str).insert(strBuffer.length(), f)
+                .insert(0, str).insert(0, fMin).insert(0, str).insert(0, i).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), i).insert(0, str).insert(0, iMin).insert(0, str).insert(0, lng)
+                .insert(strBuffer.length(), str).insert(strBuffer.length(), lng).insert(0, str)
+                .insert(0, lngMin).insert(0, str).insert(0, obj).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), obj));
+        System.out.println(strBuffer.subSequence(2, 8));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\nobject-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true- @!.&%()*-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\nobject-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true-abc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\nobject-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true--true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\nobject-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true--true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/StringBufferDeleteAndDeleteCharAtTest.java b/test/testsuite/ouroboros/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/StringBufferDeleteAndDeleteCharAtTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..561191e92f677adb04480dd5a38d157243c7ba73
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/StringBufferDeleteAndDeleteCharAtTest.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferDeleteAndDeleteCharAtTest.java
+ * -@TestCaseName: Test Method StringBuffer delete(int start, int end) and StringBuffer deleteCharAt(int index) of
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      StringBuffer.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: 0 =< start =< end, end =< instance.length, start and end coverage boundary value.
+ * -#step3: Test Method delete(int start, int end) and check result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case2
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: 0 =< index < instance.length, index coverage boundary value.
+ * -#step3: Test Method deleteCharAt(int index) and check result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferDeleteAndDeleteCharAtTest.java
+ * -@ExecuteClass: StringBufferDeleteAndDeleteCharAtTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferDeleteAndDeleteCharAtTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferDeleteAndDeleteCharAtTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferDeleteAndDeleteCharAtTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+
+        StringBuffer strBuffer2_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer2_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer2_3 = new StringBuffer("abc123abc");
+
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+
+        test2(strBuffer2_1);
+        test2(strBuffer2_2);
+        test2(strBuffer2_3);
+    }
+
+    // Test method delete(int start, int end).
+    private static void test1(StringBuffer strBuffer) {
+        // Test 0 < start < end, end < strBuffer.length().
+        System.out.println(strBuffer.delete(3, 5));
+        // Test start = 0.
+        System.out.println(strBuffer.delete(0, 1));
+        // Test end = 0.
+        System.out.println(strBuffer.delete(0, 0));
+        // Test start=strBuffer.length().
+        System.out.println(strBuffer.delete(strBuffer.length(), strBuffer.length()));
+        // Test end=strBuffer.length().
+        System.out.println(strBuffer.delete(2, strBuffer.length()));
+    }
+
+    // Test method deleteCharAt(int index).
+    private static void test2(StringBuffer strBuffer) {
+        // Test 0 < index < strBuffer.length().
+        System.out.println(strBuffer.deleteCharAt(1));
+        // Test index = 0.
+        System.out.println(strBuffer.deleteCharAt(0));
+        // Test index = strBuffer.length() - 1.
+        System.out.println(strBuffer.deleteCharAt(strBuffer.length() - 1));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nwe\n @!%()*\n@!%()*\n@!%()*\n@!%()*\n@!\nabc3abc\nbc3abc\nbc3abc\nbc3abc\nbc\nqertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x9\n !.&%()*\n!.&%()*\n!.&%()\nac123abc\nc123abc\nc123ab\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0006-rt-String-BufferCodePointExceptionTest/StringBufferCodePointExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0006-rt-String-BufferCodePointExceptionTest/StringBufferCodePointExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5daa0f13e9110c4d822f36250b08e2a94f05cae8
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0006-rt-String-BufferCodePointExceptionTest/StringBufferCodePointExceptionTest.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferCodePointExceptionTest.java
+ * -@TestCaseName: Test method codePointAt(int index)/codePointBefore(int index)/codePointCount(int beginIndex, int
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      endIndex)/offsetByCodePoints(int index, int codePointOffset) of StringBuffer, test
+ *                      StringIndexOutOfBoundsException throw in codePointAt and codePointBefore, test
+ *                      IndexOutOfBoundsException throw in codePointCount and offsetByCodePoints.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: index range from 0 to instance.length.
+ * -#step3: Test method codePointAt(int index). Check result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case2
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: index range from 0 to instance.length.
+ * -#step3: Test method codePointBefore(int index). Check result is correctly, StringIndexOutOfBoundsException is thrown
+ *          when index = 0.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case3
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: beginIndex range from 0 to instance.length - 2, endIndex = beginIndex + 3.
+ * -#step3: Test method codePointCount(int beginIndex, int endIndex),Check result is correctly.IndexOutOfBoundsException
+ *          is thrown when endIndex > instance.length - 1.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case4
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: index range from 0 to instance.length - 2, codePointOffset = index + 3.
+ * -#step3: Test method int offsetByCodePoints(int index, int codePointOffset),Check result is correctly,
+ *          StringIndexOutOfBoundsException is thrown when index + codePointOffset > instance.length.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferCodePointExceptionTest.java
+ * -@ExecuteClass: StringBufferCodePointExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferCodePointExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferCodePointExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferCodePointExceptionTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-" +
+                "=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+
+        test3(strBuffer1_1);
+        test3(strBuffer1_2);
+        test3(strBuffer1_3);
+
+        test4(strBuffer1_1);
+        test4(strBuffer1_2);
+        test4(strBuffer1_3);
+    }
+
+    // Test method codePointAt(int index).
+    private static void test1(StringBuffer strBuffer) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = strBuffer.codePointAt(i);
+                System.out.println("i=" + i + " " + "codePointAt=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointAt(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(strBuffer.charAt(i) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+
+    // Test method codePointBefore(int index).
+    private static void test2(StringBuffer strBuffer) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = strBuffer.codePointBefore(i);
+                System.out.println("i=" + i + " " + "codePointBefore=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointBefore(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(strBuffer.charAt(i - 1) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+
+    // Test method codePointCount(int beginIndex, int endIndex).
+    private static void test3(StringBuffer strBuffer) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = strBuffer.codePointCount(i, i + 3);
+                System.out.println("i=" + i + " " + "codePointCount=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("codePointCount(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(strBuffer.charAt(i) + "~" + strBuffer.charAt(i + 3) +
+                            " codePointCount is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+
+    // Test method int offsetByCodePoints(int index, int codePointOffset).
+    private static void test4(StringBuffer strBuffer) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = strBuffer.offsetByCodePoints(i, i + 3);
+                System.out.println("i=" + i + " " + "offsetByCodePoints=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("offsetByCodePoints(): " + i + "+3  out of length");
+            } finally {
+                try {
+                    System.out.println(strBuffer.charAt(i) + " offsetByCodePoints +3 is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full i=0 codePointAt=113\nq Unicode is:113\ni=1 codePointAt=119\nw Unicode is:119\ni=2 codePointAt=101\ne Unicode is:101\ni=3 codePointAt=114\nr Unicode is:114\ni=4 codePointAt=116\nt Unicode is:116\ni=5 codePointAt=121\ny Unicode is:121\ni=0 codePointAt=32\n  Unicode is:32\ni=1 codePointAt=64\n@ Unicode is:64\ni=2 codePointAt=33\n! Unicode is:33\ni=3 codePointAt=46\n. Unicode is:46\ni=4 codePointAt=38\n& Unicode is:38\ni=5 codePointAt=37\n% Unicode is:37\ni=0 codePointAt=97\na Unicode is:97\ni=1 codePointAt=98\nb Unicode is:98\ni=2 codePointAt=99\nc Unicode is:99\ni=3 codePointAt=49\n1 Unicode is:49\ni=4 codePointAt=50\n2 Unicode is:50\ni=5 codePointAt=51\n3 Unicode is:51\ncodePointBefore(): 0out of length\n0 out of length\ni=1 codePointBefore=113\nq Unicode is:113\ni=2 codePointBefore=119\nw Unicode is:119\ni=3 codePointBefore=101\ne Unicode is:101\ni=4 codePointBefore=114\nr Unicode is:114\ni=5 codePointBefore=116\nt Unicode is:116\ncodePointBefore(): 0out of length\n0 out of length\ni=1 codePointBefore=32\n  Unicode is:32\ni=2 codePointBefore=64\n@ Unicode is:64\ni=3 codePointBefore=33\n! Unicode is:33\ni=4 codePointBefore=46\n. Unicode is:46\ni=5 codePointBefore=38\n& Unicode is:38\ncodePointBefore(): 0out of length\n0 out of length\ni=1 codePointBefore=97\na Unicode is:97\ni=2 codePointBefore=98\nb Unicode is:98\ni=3 codePointBefore=99\nc Unicode is:99\ni=4 codePointBefore=49\n1 Unicode is:49\ni=5 codePointBefore=50\n2 Unicode is:50\ni=0 codePointCount=3\nq~r codePointCount is :3\ni=1 codePointCount=3\nw~t codePointCount is :3\ni=2 codePointCount=3\ne~y codePointCount is :3\ni=3 codePointCount=3\nr~u codePointCount is :3\ni=0 codePointCount=3\n ~. codePointCount is :3\ni=1 codePointCount=3\n@~& codePointCount is :3\ni=2 codePointCount=3\n!~% codePointCount is :3\ni=3 codePointCount=3\n3 out of length\ni=0 codePointCount=3\na~1 codePointCount is :3\ni=1 codePointCount=3\nb~2 codePointCount is :3\ni=2 codePointCount=3\nc~3 codePointCount is :3\ni=3 codePointCount=3\n3 out of length\ni=0 offsetByCodePoints=3\nq offsetByCodePoints +3 is :3\ni=1 offsetByCodePoints=5\nw offsetByCodePoints +3 is :5\ni=2 offsetByCodePoints=7\ne offsetByCodePoints +3 is :7\ni=3 offsetByCodePoints=9\nr offsetByCodePoints +3 is :9\ni=0 offsetByCodePoints=3\n  offsetByCodePoints +3 is :3\ni=1 offsetByCodePoints=5\n@ offsetByCodePoints +3 is :5\noffsetByCodePoints(): 2+3  out of length\n! offsetByCodePoints +3 is :5\noffsetByCodePoints(): 3+3  out of length\n. offsetByCodePoints +3 is :5\ni=0 offsetByCodePoints=3\na offsetByCodePoints +3 is :3\ni=1 offsetByCodePoints=5\nb offsetByCodePoints +3 is :5\noffsetByCodePoints(): 2+3  out of length\nc offsetByCodePoints +3 is :5\noffsetByCodePoints(): 3+3  out of length\n1 offsetByCodePoints +3 is :5\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/StringBufferCapacityAndEnsureCapacityTest.java b/test/testsuite/ouroboros/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/StringBufferCapacityAndEnsureCapacityTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..582e3ee295068b148365799452a04e4a4c064e6c
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/StringBufferCapacityAndEnsureCapacityTest.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferCapacityAndEnsureCapacityTest.java
+ * -@TestCaseName: Test Method capacity()/ensureCapacity(int minimumCapacity) of StringBuffer.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Test method int capacity(), check the result capacity and the length of instance is correctly.
+ * -#step3: Create str(str.length > 0), Invoke Append(String str), test method capacity(), check the result capacity and
+ *          the length of instance is correctly.
+ * -#step4: Create minimumCapacity > old capacity(), Test method ensureCapacity(int minimumCapacity), test
+ *          method capacity(), check the result capacity and the length of instance is correctly.
+ * -#step5: Create newLength > StringBuffer.length, Invoke setLength(int newLength), test method capacity(), check
+ *          the result capacity and the length of instance is correctly.
+ * -#step6: Invoke trimToSize(), test method capacity(), check the result capacity and the length of instance is
+ *          correctly.
+ * -#step7: Create minimumCapacity = 0 or minimumCapacity < 0 or 0 < minimumCapacity < old capacity(), Test method
+ *          ensureCapacity(int minimumCapacity), test method capacity(), check the result capacity and the length of
+ *          instance is correctly.
+ * -#step8: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~7.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferCapacityAndEnsureCapacityTest.java
+ * -@ExecuteClass: StringBufferCapacityAndEnsureCapacityTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferCapacityAndEnsureCapacityTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferCapacityAndEnsureCapacityTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferCapacityAndEnsureCapacityTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=" +
+                "!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+        test1(strBuffer1_5);
+    }
+
+    private static void test1(StringBuffer strBuffer) {
+        System.out.println("1-capacity: " + strBuffer.capacity());
+        System.out.println("1-lent: " + strBuffer.length());
+
+        strBuffer = strBuffer.append("01234567890123456789");
+        System.out.println("2-capacity: " + strBuffer.capacity());
+        System.out.println("2-lent: " + strBuffer.length());
+
+        strBuffer.ensureCapacity(80);
+        System.out.println("3-capacity: " + strBuffer.capacity());
+        System.out.println("3-lent: " + strBuffer.length());
+
+        strBuffer.setLength(100);
+        System.out.println("4-capacity: " + strBuffer.capacity());
+        System.out.println("4-lent: " + strBuffer.length());
+
+        strBuffer.trimToSize();
+        System.out.println("5-capacity: " + strBuffer.capacity());
+        System.out.println("5-lent: " + strBuffer.length());
+
+        // Test minimumCapacity < 0.
+        strBuffer.ensureCapacity(-2);
+        System.out.println("6-capacity: " + strBuffer.capacity());
+        System.out.println("6-lent: " + strBuffer.length());
+
+        // Test minimumCapacity = 0.
+        strBuffer.ensureCapacity(0);
+        System.out.println("7-capacity: " + strBuffer.capacity());
+        System.out.println("7-lent: " + strBuffer.length());
+
+        // Test minimumCapacity > 0.
+        strBuffer.ensureCapacity(2);
+        System.out.println("8-capacity: " + strBuffer.capacity());
+        System.out.println("8-lent: " + strBuffer.length());
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 1-capacity: 115\n1-lent: 99\n2-capacity: 232\n2-lent: 119\n3-capacity: 232\n3-lent: 119\n4-capacity: 232\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n1-capacity: 25\n1-lent: 9\n2-capacity: 52\n2-lent: 29\n3-capacity: 106\n3-lent: 29\n4-capacity: 106\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n1-capacity: 22\n1-lent: 6\n2-capacity: 46\n2-lent: 26\n3-capacity: 94\n3-lent: 26\n4-capacity: 190\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n1-capacity: 16\n1-lent: 0\n2-capacity: 34\n2-lent: 20\n3-capacity: 80\n3-lent: 20\n4-capacity: 162\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n1-capacity: 16\n1-lent: 0\n2-capacity: 34\n2-lent: 20\n3-capacity: 80\n3-lent: 20\n4-capacity: 162\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/StringBufferCharAtAndSetCharAtExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/StringBufferCharAtAndSetCharAtExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e21ad1262e16fb436aa6a37fd09c9e93b12bb56b
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/StringBufferCharAtAndSetCharAtExceptionTest.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferCharAtAndSetCharAtExceptionTest.java
+ * -@TestCaseName: Test Method charAt(int index)/setCharAt(int index, char ch) of StringBuffer and
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      StringIndexOutOfBoundsException occured in charAt/setCharAt.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: index range from -1  to exceed instance.length.
+ * -#step3: Test method char charAt(int index) and StringIndexOutOfBoundsException is thrown.
+ * -#step4: Check the result char is correctly when index is range from 0 to (instance.length -1),
+ *          StringIndexOutOfBoundsException is thrown when index < 0 or index > (instance.length -1).
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/"" to repeat step2~4.
+ * -#case2
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: index range from -1  to exceed instance.length. ch is a Letter char.
+ * -#step3: Test Method void setCharAt(int index, char ch) and StringIndexOutOfBoundsException is thrown.
+ * -#step4: Check the instance after setCharAt is replaced correctly when index is range from 0 to (instance.length -1),
+ *          or StringIndexOutOfBoundsException is thrown when index < 0 or index > (instance.length -1).
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/"" to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferCharAtAndSetCharAtExceptionTest.java
+ * -@ExecuteClass: StringBufferCharAtAndSetCharAtExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferCharAtAndSetCharAtExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferCharAtAndSetCharAtExceptionTest_1();
+            StringBufferCharAtAndSetCharAtExceptionTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferCharAtAndSetCharAtExceptionTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=" +
+                "!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+    }
+
+    public static void StringBufferCharAtAndSetCharAtExceptionTest_2() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+        test2(strBuffer1_4);
+    }
+
+    // Test method char charAt(int index).
+    private static void test1(StringBuffer strBuffer) {
+        int charAt = 0;
+        for (int i = -1; i < 8; i++) {
+            try {
+                charAt = strBuffer.charAt(i);
+                System.out.println("i=" + i + "  " + "charAt=" + charAt);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("index: " + i + "  String index out of range");
+            }
+        }
+    }
+
+    // Test Method void setCharAt(int index, char ch).
+    private static void test2(StringBuffer strBuffer) {
+        char ch = 'A';
+        for (int i = -1; i < 8; i++) {
+            try {
+                strBuffer.setCharAt(i, ch);
+                System.out.println("i=" + i + "  " + "setcharAt=" + strBuffer);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("index: " + i + "  String index out of range");
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full index: -1  String index out of range\ni=0  charAt=113\ni=1  charAt=119\ni=2  charAt=101\ni=3  charAt=114\ni=4  charAt=116\ni=5  charAt=121\ni=6  charAt=117\ni=7  charAt=105\nindex: -1  String index out of range\ni=0  charAt=32\ni=1  charAt=64\ni=2  charAt=33\ni=3  charAt=46\ni=4  charAt=38\ni=5  charAt=37\ni=6  charAt=40\ni=7  charAt=41\nindex: -1  String index out of range\ni=0  charAt=97\ni=1  charAt=98\ni=2  charAt=99\ni=3  charAt=49\ni=4  charAt=50\ni=5  charAt=51\nindex: 6  String index out of range\nindex: 7  String index out of range\nindex: -1  String index out of range\nindex: 0  String index out of range\nindex: 1  String index out of range\nindex: 2  String index out of range\nindex: 3  String index out of range\nindex: 4  String index out of range\nindex: 5  String index out of range\nindex: 6  String index out of range\nindex: 7  String index out of range\nindex: -1  String index out of range\ni=0  setcharAt=Awertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=1  setcharAt=AAertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=2  setcharAt=AAArtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=3  setcharAt=AAAAtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=4  setcharAt=AAAAAyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=5  setcharAt=AAAAAAuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=6  setcharAt=AAAAAAAiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=7  setcharAt=AAAAAAAAop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nindex: -1  String index out of range\ni=0  setcharAt=A@!.&%()*\ni=1  setcharAt=AA!.&%()*\ni=2  setcharAt=AAA.&%()*\ni=3  setcharAt=AAAA&%()*\ni=4  setcharAt=AAAAA%()*\ni=5  setcharAt=AAAAAA()*\ni=6  setcharAt=AAAAAAA)*\ni=7  setcharAt=AAAAAAAA*\nindex: -1  String index out of range\ni=0  setcharAt=Abc123\ni=1  setcharAt=AAc123\ni=2  setcharAt=AAA123\ni=3  setcharAt=AAAA23\ni=4  setcharAt=AAAAA3\ni=5  setcharAt=AAAAAA\nindex: 6  String index out of range\nindex: 7  String index out of range\nindex: -1  String index out of range\nindex: 0  String index out of range\nindex: 1  String index out of range\nindex: 2  String index out of range\nindex: 3  String index out of range\nindex: 4  String index out of range\nindex: 5  String index out of range\nindex: 6  String index out of range\nindex: 7  String index out of range\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0009-rt-String-BufferGetCharsTest/StringBufferGetCharsTest.java b/test/testsuite/ouroboros/string_test/RT0009-rt-String-BufferGetCharsTest/StringBufferGetCharsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..98266639ba32061be05e7ac3956c5d515f35a642
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0009-rt-String-BufferGetCharsTest/StringBufferGetCharsTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferGetCharsTest.java
+ * -@TestCaseName: Test Method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) of StringBuffer.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create parameters: srcBegin  =< srcEnd < instance.length,, dstBegin < dst(char[]).length, srcBegin/srcEnd
+ *          /dstBegin coverage boundary value.
+ * -#step3: Test Method void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin).
+ * -#step4: Check some chars of dst(char[]) is replaced correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferGetCharsTest.java
+ * -@ExecuteClass: StringBufferGetCharsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferGetCharsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferGetCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferGetCharsTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+    }
+
+    private static void test1(StringBuffer strBuffer) {
+        // Test srcBegin  < srcEnd < instance.length, dstBegin < dst(char[]).length.
+        char[] dst = {'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(2, 5, dst, 2);
+        System.out.println(dst);
+
+        // Test srcBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(0, 3, dst, 2);
+        System.out.println(dst);
+
+        // Test srcEnd = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(0, 0, dst, 2);
+        System.out.println(dst);
+
+        // Test dstBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(2, 5, dst, 0);
+        System.out.println(dst);
+
+        // Test srcBegin = srcEnd.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(2, 2, dst, 0);
+        System.out.println(dst);
+
+        // Test srcBegin = strBuffer.length() - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        int index = strBuffer.length() - 1;
+        strBuffer.getChars(index, index, dst, 0);
+        System.out.println(dst);
+
+        // Test srcEnd = strBuffer.length() - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(index - 2, index, dst, 0);
+        System.out.println(dst);
+
+        // Test dstBegin = dst.length - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(0, 1, dst, dst.length - 1);
+        System.out.println(dst);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ABertF\nABqweF\nABCDEF\nertDEF\nABCDEF\nABCDEF\nx9CDEF\nABCDEq\nAB!.&F\nAB @!F\nABCDEF\n!.&DEF\nABCDEF\nABCDEF\n()CDEF\nABCDE \nABc12F\nABabcF\nABCDEF\nc12DEF\nABCDEF\nABCDEF\n12CDEF\nABCDEa\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/StringBufferIndexOfAndLastIndexOfTest.java b/test/testsuite/ouroboros/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/StringBufferIndexOfAndLastIndexOfTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd113e30a17ac33a59c64aeae18b9e581942cf11
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/StringBufferIndexOfAndLastIndexOfTest.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferIndexOfAndLastIndexOfTest.java
+ * -@TestCaseName: Test Method int indexOf(String str)/int indexOf(String str, int fromIndex)/int lastIndexOf(
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      String str)/int lastIndexOf(String str, int fromIndex) of StringBuffer.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters: str is String with letter or empty String.
+ * -#step3: Test method indexOf(String str), check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~3.
+ * -#case2
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters: str is String with letter, instance.length > fromIndex >= 0, fromIndex coverage boundary
+ *          value.
+ * -#step3: Test method indexOf(String str, int fromIndex), check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~3.
+ * -#case3
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters: str is String with letter or empty String.
+ * -#step3: Test method lastIndexOf(String str), check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~3.
+ * -#case4
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters: str is String with letter, instance.length > fromIndex >= 0, fromIndex coverage boundary
+ *          value.
+ * -#step3: Test method lastIndexOf(String str, int fromIndex), check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferIndexOfAndLastIndexOfTest.java
+ * -@ExecuteClass: StringBufferIndexOfAndLastIndexOfTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferIndexOfAndLastIndexOfTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferIndexOfAndLastIndexOfTest_1();
+            StringBufferIndexOfAndLastIndexOfTest_2();
+            StringBufferIndexOfAndLastIndexOfTest_3();
+            StringBufferIndexOfAndLastIndexOfTest_4();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferIndexOfAndLastIndexOfTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+        test1(strBuffer1_5);
+    }
+
+    public static void StringBufferIndexOfAndLastIndexOfTest_2() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+        test2(strBuffer1_4);
+        test2(strBuffer1_5);
+    }
+
+    public static void StringBufferIndexOfAndLastIndexOfTest_3() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+
+        test3(strBuffer1_1);
+        test3(strBuffer1_2);
+        test3(strBuffer1_3);
+        test3(strBuffer1_4);
+        test3(strBuffer1_5);
+    }
+
+
+    public static void StringBufferIndexOfAndLastIndexOfTest_4() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+
+        test4(strBuffer1_1);
+        test4(strBuffer1_2);
+        test4(strBuffer1_3);
+        test4(strBuffer1_4);
+        test4(strBuffer1_5);
+    }
+
+    // Test method indexOf(String str).
+    private static void test1(StringBuffer strBuffer) {
+        System.out.println(strBuffer.indexOf("b"));
+        // Test empty String.
+        System.out.println(strBuffer.indexOf(""));
+    }
+
+    // Test method indexOf(String str, int fromIndex).
+    private static void test2(StringBuffer strBuffer) {
+        System.out.println(strBuffer.indexOf("b", 2));
+        // Test fromIndex = 0.
+        System.out.println(strBuffer.indexOf("b", 0));
+        // Test fromIndex = strBuffer.length() - 1.
+        System.out.println(strBuffer.indexOf("6", strBuffer.length() - 1));
+    }
+
+    // Test method lastIndexOf(String str).
+    private static void test3(StringBuffer strBuffer) {
+        System.out.println(strBuffer.lastIndexOf("b"));
+        // Test empty String.
+        System.out.println(strBuffer.lastIndexOf(""));
+    }
+
+    // Test method lastIndexOf(String str, int fromIndex).
+    private static void test4(StringBuffer strBuffer) {
+        System.out.println(strBuffer.lastIndexOf("b", 1));
+        // Test fromIndex = 0.
+        System.out.println(strBuffer.lastIndexOf("b", 0));
+        // Test fromIndex = strBuffer.length() - 1.
+        System.out.println(strBuffer.lastIndexOf("6", strBuffer.length() - 1));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 33\n0\n-1\n0\n1\n0\n-1\n0\n-1\n0\n33\n33\n98\n-1\n-1\n-1\n7\n1\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n33\n99\n-1\n9\n7\n9\n-1\n0\n-1\n0\n-1\n-1\n98\n-1\n-1\n-1\n1\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/StringBufferReplaceAndReverseTest.java b/test/testsuite/ouroboros/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/StringBufferReplaceAndReverseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2693a59b340271ff303a3795bdbebfaf009257ed
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/StringBufferReplaceAndReverseTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferReplaceAndReverseTest.java
+ * -@TestCaseName: Test Method StringBuffer replace(int start, int end, String str)/StringBuffer reverse() of
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      StringBuffer.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters: start < end < instance.length, start/end coverage boundary value. str is String with some
+  *         letters.
+ * -#step3: Test method replace(int start, int end, String str), check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case2
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Test method reverse(), check return result is correctly.
+ * -#step3: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferReplaceAndReverseTest.java
+ * -@ExecuteClass: StringBufferReplaceAndReverseTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferReplaceAndReverseTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferReplaceAndReverseTest_1();
+            StringBufferReplaceAndReverseTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferReplaceAndReverseTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+    }
+
+    public static void StringBufferReplaceAndReverseTest_2() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+        test2(strBuffer1_4);
+        test2(strBuffer1_5);
+    }
+
+    // Test method replace(int start, int end, String str).
+    private static void test1(StringBuffer strBuffer) {
+        System.out.println(strBuffer.replace(2, 6, "xyz"));
+        // end = 0
+        System.out.println(strBuffer.replace(0, 0, "xyz"));
+        // start = 0 & end = strBuffer.length()
+        System.out.println(strBuffer.replace(0, strBuffer.length(), "xyz"));
+        // start = strBuffer.length() & end = strBuffer.length()
+        System.out.println(strBuffer.replace(strBuffer.length(), strBuffer.length(), "xyz"));
+    }
+
+    // Test method reverse().
+    private static void test2(StringBuffer strBuffer) {
+        strBuffer.reverse();
+        System.out.println(strBuffer);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwxyzuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nxyzqwxyzuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nxyz\nxyzxyz\n @xyz\nxyz @xyz\nxyz\nxyzxyz\nabxyzabc\nxyzabxyzabc\nxyz\nxyzxyz\n69x0MNBVCXZPOIUYTREWQLKJHGFDSA +_)(*&^%$#@!=-0987654321`~?/><.,mnbvcxz"\':;lkjhgfdsa|\\][}{poiuytrewq\n%&.!@ \ncba321cba\n\n\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/StringBufferSubstringAndToStringTest.java b/test/testsuite/ouroboros/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/StringBufferSubstringAndToStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..69d444b8f130d499efc99478b79b7d07379f9bc2
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/StringBufferSubstringAndToStringTest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferSubstringAndToStringTest.java
+ * -@TestCaseName: Test Method:String substring(int start)/String substring(int start, int end)/String toString()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+  *                     of StringBuffer.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters: start < instance.length, start < end < instance.length, start and end coverage boundary
+ *          value.
+ * -#step3: Test method substring(int start, int end).
+ * -#step4: Check the return result of substring is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -#case2
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters: 0 =< start < instance.length, start coverage boundary value.
+ * -#step3: Test method substring(int start).
+ * -#step4: Check the return result of substring is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -#case3
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Test method toString().
+ * -#step3: Check the return result of toString is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2-3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBufferSubstringAndToStringTest.java
+ * -@ExecuteClass: StringBufferSubstringAndToStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferSubstringAndToStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBufferSubstringAndToStringTest_1();
+            StringBufferSubstringAndToStringTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBufferSubstringAndToStringTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+    }
+
+    public static void StringBufferSubstringAndToStringTest_2() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+
+        test3(strBuffer1_1);
+        test3(strBuffer1_2);
+        test3(strBuffer1_3);
+        test3(strBuffer1_4);
+        test3(strBuffer1_5);
+    }
+
+    // Test method substring(int start, int end).
+    private static void test1(StringBuffer strBuffer) {
+        System.out.println(strBuffer.substring(2, 7));
+        // Test start = 0 & end = strBuffer.length().
+        System.out.println(strBuffer.substring(0, strBuffer.length()));
+        // Test start = strBuffer.length().
+        System.out.println(strBuffer.substring(strBuffer.length(), strBuffer.length()));
+        // Test end = 0.
+        System.out.println(strBuffer.substring(0, 0));
+    }
+
+    // Test method substring(int start).
+    private static void test2(StringBuffer strBuffer) {
+        System.out.println(strBuffer.substring(3));
+        // Test start = 0.
+        System.out.println(strBuffer.substring(0));
+        // Test start = strBuffer.length().
+        System.out.println(strBuffer.substring(strBuffer.length()));
+    }
+
+    // Test method toString().
+    private static void test3(StringBuffer strBuffer) {
+        System.out.println(strBuffer.toString());
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ertyu\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n\n!.&%(\n @!.&%()*\n\n\nc123a\nabc123abc\n\n\nrtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n.&%()*\n @!.&%()*\n\n123abc\nabc123abc\n\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\nabc123abc\n\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0013-rt-String-BuilderConstructorsTest/StringBuilderConstructorsTest.java b/test/testsuite/ouroboros/string_test/RT0013-rt-String-BuilderConstructorsTest/StringBuilderConstructorsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b75483e3256b64f8e03797848ec0d449b6db09e5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0013-rt-String-BuilderConstructorsTest/StringBuilderConstructorsTest.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderConstructorsTest.java
+ * -@TestCaseName: Test StringBuilder Constructors StringBuilder()/StringBuilder(CharSequence seq)/StringBuilder
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      (int capacity)/StringBuilder(String str).
+ * -@Brief:
+ * -#case1
+ * -#step1: Create a String instance By new String(String str) and not new.
+ * -#step2: Test Constructor StringBuilder(String instance).
+ * -#step3: Check new StringBuilder instance is new correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~3.
+ * -#case2
+ * -#step1: Test new StringBuilder() and check the capacity() of instance is correctly.
+ * -#step2: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step1.
+ * -#case3
+ * -#step1: Create capacity > 0 or capacity = 0, test new StringBuilder(int capacity), check the capacity() of instance
+ *          is correctly.
+ * -#case4
+ * -#step1: Create seq Contains numbers, letters, special symbols, test StringBuilder(CharSequence seq), check new
+ *          instance is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderConstructorsTest.java
+ * -@ExecuteClass: StringBuilderConstructorsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderConstructorsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderConstructorsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderConstructorsTest_1() {
+        String str1_1 = new String("abc123abc");
+        String str1_2 = new String(" @!.&%()*");
+        String str1_3 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "abc123ABC";
+        String str2_2 = " @!.&%()*";
+        String str2_3 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZX" +
+                "CVBNM0x96";
+        String str2_4 = "";
+
+        test1_1(str1_1);
+        test1_1(str1_2);
+        test1_1(str1_3);
+        test1_1(str1_4);
+        test1_1(str1_5);
+        test1_1(str2_1);
+        test1_1(str2_2);
+        test1_1(str2_3);
+        test1_1(str2_4);
+
+        StringBuilder strBuilder1_1 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=" +
+                "!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test1_2(strBuilder1_1);
+        test1_2(strBuilder1_2);
+        test1_2(strBuilder1_3);
+        test1_2(strBuilder1_4);
+        test1_2(strBuilder1_5);
+
+        // Test new StringBuilder()
+        test1_3();
+
+        // Test new StringBuilder(int capacity)
+        test1_4();
+
+        // Test new StringBuilder(CharSequence seq)
+        test1_5();
+    }
+
+    private static void test1_1(String str) {
+        System.out.println(new StringBuilder(str));
+    }
+
+    private static void test1_2(StringBuilder strBuilder) {
+        System.out.println(strBuilder.toString());
+    }
+
+    private static void test1_3() {
+        StringBuilder strBuilder1_6 = new StringBuilder();
+        System.out.println(strBuilder1_6.capacity());
+    }
+
+    private static void test1_4() {
+        int capacity = 20;
+        StringBuilder strBuilder1_6 = new StringBuilder(capacity);
+        System.out.println(strBuilder1_6.capacity());
+
+        int capacityMin = 0;
+        strBuilder1_6 = new StringBuilder(capacityMin);
+        System.out.println(strBuilder1_6.capacity());
+    }
+
+    private static void test1_5() {
+        CharSequence chs1_1 = "xyz";
+        StringBuilder strBuilder1_7 = new StringBuilder(chs1_1);
+        test1_2(strBuilder1_7);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123abc\n @!.&%()*\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n\nabc123ABC\n @!.&%()*\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\nabc123abc\n @!.&%\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n\n16\n20\n0\nxyz\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/StringBuilderAppendAndAppendCodePointTest.java b/test/testsuite/ouroboros/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/StringBuilderAppendAndAppendCodePointTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d499beb07fe001b82f240e1864303bc5e7ed5c27
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/StringBuilderAppendAndAppendCodePointTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderAppendAndAppendCodePointTest.java
+ * -@TestCaseName: Test method append(boolean b)/append(char c)/append(char[] str)/append(char[] str, int offset,
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      int len)/append(CharSequence s)/append(CharSequence s, int start, int end)/append(double d)/
+ *                      append(float f)/append(int i)/append(long lng)/append(Object obj)/append(String str)/
+ *                      append(StringBuilder sb)/appendCodePoint(int codePoint) of StringBuilder
+ * -@Brief:
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameter str is a String instance, test method append(String str).
+ * -#step3: Create parameter b is true or false, test method append(boolean b).
+ * -#step4: Create parameter c is a letter, test method append(char c).
+ * -#step5: Create parameter data.length > 0, data.element is a char, test method append(char[] data).
+ * -#step6: Create parameter s is a CharSequence, test method append(CharSequence s).
+ * -#step7: Create parameters: s is a CharSequence, 0 =< start < end, end <= s.length, start and end coverage boundary
+ *          value. test method append(CharSequence s, int start, int end).
+ * -#step8: Create parameter d > 0 or d = 0, test method append(double d).
+ * -#step9: Create parameter f > 0 or f = 0, test method append(float f).
+ * -#step10: Create parameter i > 0 or i = 0, test method append(int i).
+ * -#step11: Create parameter lng > 0 or lng = 0, test method append(long lng).
+ * -#step12: Create parameter obj is a Object, test method append(Object obj).
+ * -#step13: Create parameter sb is a StringBuffer, test method append(StringBuilder sb).
+ * -#step14: Create parameter codePoint is unicode num, test method appendCodePoint(int codePoint).
+ * -#step15: Check the append result is correctly and the Src StringBuilder is correctly.
+ * -#step16: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~15.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderAppendAndAppendCodePointTest.java
+ * -@ExecuteClass: StringBuilderAppendAndAppendCodePointTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderAppendAndAppendCodePointTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderAppendAndAppendCodePointTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderAppendAndAppendCodePointTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_2 = new StringBuilder("      ");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+        test1(strBuilder1_5);
+    }
+
+    private static void test1(StringBuilder strBuilder) {
+        char c = 'C';
+        char[] data = {'A', 'B', 'C'};
+        CharSequence chs1_1 = "xyz";
+        Object obj = new String("object");
+        String str = "string";
+        double d = 8888.8888;
+        double dMin = 0;
+        float f = 99999999;
+        float fMin = 0;
+        int i = 77777777;
+        int iMin = 0;
+        long lng = 66666666;
+        long lngMin = 0;
+        StringBuilder sb = new StringBuilder("StringBuilder");
+        int codePoint = 74; // unicode 74 is J
+
+        System.out.println(strBuilder.append("-").append(true).append("-").append(false).append("-").append(c)
+                .append("-").append(data).append("-").append(chs1_1).append("-").append(chs1_1, 1, 2).append("-")
+                .append(chs1_1, 0, 3).append("-").append(chs1_1, 3, 3).append("-").append(chs1_1, 0, 0).append("-")
+                .append(d).append("-").append(dMin).append("-").append(f).append("-").append(fMin).append("-").append(i)
+                .append("-").append(iMin).append("-").append(lng).append("-").append(lngMin).append("-").append(obj)
+                .append("-").append(str).append("-").append(sb).append("-").appendCodePoint(codePoint));
+
+        System.out.println(strBuilder.subSequence(2, 8));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J\nc123ab\n      -true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J\n    -t\nabc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J\nc123ab\n-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J\nrue-fa\n-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J\nrue-fa\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0015-rt-String-BuilderInsertTest/StringBuilderInsertTest.java b/test/testsuite/ouroboros/string_test/RT0015-rt-String-BuilderInsertTest/StringBuilderInsertTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d8d6cf81324c63b01ba0c141a2b402240fff90d
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0015-rt-String-BuilderInsertTest/StringBuilderInsertTest.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderInsertTest.java
+ * -@TestCaseName: Test Method insert(Various parameters) of StringBuilder include insert(int offset, boolean b)/
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      insert(int offset, char c)/insert(int offset, char[] str)/insert(int index, char[] str,
+ *                      int offset, int len)insert(int dstOffset, CharSequence s)/insert(int dstOffset, CharSequence s,
+ *                      int start, int end)/insert(int offset, double d)/insert(int offset, float f)/insert(int offset,
+ *                      int i)/insert(int offset, long l)/insert(int offset,Object obj)/insert(int offset, String str).
+ * -@Brief:
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameters: 0 =< offset < instance.length, offset test boundary value, str is a String, test method
+ *          insert(int offset, String str).
+ * -#step3: Create parameters: 0 =< offset < instance.length, offset test boundary value, b is true/false, test method
+ *          insert(int offset, boolean b).
+ * -#step4: Create parameters: 0 =< offset < instance.length, offset test boundary value, c is a char, test method
+ *          insert(int offset, char c).
+ * -#step5: Create parameters: 0 =< offset < instance.length, offset test boundary value, create a char[] data, test
+ *          method insert(int offset, char[] data).
+ * -#step6: Create parameters: 0 =< offset < instance.length, offset test boundary value, s is a CharSequence, test
+ *          method insert(int offset, CharSequence s).
+ * -#step7: Create parameters: 0 =< offset < instance.length, s is a CharSequence, 0 =< start < end, end <= s.length,
+ *          offset/start/end test boundary value, test method insert(int offset, CharSequence s, int start, int end).
+ * -#step8: Create parameters: 0 =< offset < instance.length, offset test boundary value, d > 0 or d = 0, test method
+ *          insert(int offset, double d).
+ * -#step9: Create parameters: 0 =< offset < instance.length, offset test boundary value, f > 0 or f = 0, test method
+ *          insert(int offset, float f).
+ * -#step10: Create parameters: 0 =< offset < instance.length, offset test boundary value, i > 0 or i = 0, test method
+ *           insert(int offset, int i).
+ * -#step11: Create parameters: 0 =< offset < instance.length, offset test boundary value, l > 0 or l = 0, test method
+ *           insert(int offset, long l).
+ * -#step12: Create parameters: 0 =< offset < instance.length, offset test boundary value, obj is a Object, test method
+ *           insert(int offset, Object obj).
+ * -#step13: Check the insert result is correctly and the Src instance is correctly.
+ * -#step14: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~13.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderInsertTest.java
+ * -@ExecuteClass: StringBuilderInsertTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderInsertTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderInsertTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderInsertTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+        test1(strBuilder1_5);
+    }
+
+    private static void test1(StringBuilder strBuilder) {
+        char c = 'C';
+        char[] data = {'A', 'B', 'C'};
+        CharSequence chs1_1 = "xyz";
+        double d = 8888.8888;
+        double dMin = 0;
+        float f = 99999999;
+        float fMin = 0;
+        int i = 77777777;
+        int iMin = 0;
+        long lng = 66666666;
+        long lngMin = 0;
+        Object obj = new String("object");
+        String str = "-";
+
+        System.out.println(strBuilder.insert(0, str).insert(1, true).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), true).insert(0, str).insert(0, false).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), false).insert(0, str).insert(0, c).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), c).insert(0, str).insert(0, data).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), data).insert(0, str).insert(0, chs1_1).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), chs1_1).insert(0, str).insert(0, chs1_1, 1, 2)
+                .insert(strBuilder.length(), str).insert(strBuilder.length(), chs1_1, 1, 2).insert(0, str)
+                .insert(0, chs1_1, 0, 3).insert(strBuilder.length(), str).insert(strBuilder.length(), chs1_1, 0, 3)
+                .insert(0, str).insert(0, chs1_1, 3, 3).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), chs1_1, 3, 3).insert(0, str).insert(0, chs1_1, 0, 0)
+                .insert(strBuilder.length(), str).insert(strBuilder.length(), chs1_1, 0, 0).insert(0, str).insert(0, d)
+                .insert(strBuilder.length(), str).insert(strBuilder.length(), d).insert(0, str).insert(0, dMin)
+                .insert(0, str).insert(0, f).insert(strBuilder.length(), str).insert(strBuilder.length(), f)
+                .insert(0, str).insert(0, fMin).insert(0, str).insert(0, i).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), i).insert(0, str).insert(0, iMin).insert(0, str).insert(0, lng)
+                .insert(strBuilder.length(), str).insert(strBuilder.length(), lng).insert(0, str).insert(0, lngMin)
+                .insert(0, str).insert(0, obj).insert(strBuilder.length(), str).insert(strBuilder.length(), obj));
+        System.out.println(strBuilder.subSequence(2, 8));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--trueqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\nobject-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--true @!.&%()*-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\nobject-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--trueabc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\nobject-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--true-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\nobject-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--true-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object\nject-0\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/StringBuilderDeleteAndDeleteCharAtTest.java b/test/testsuite/ouroboros/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/StringBuilderDeleteAndDeleteCharAtTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1e29fb1c89ad2af142086d963bda339e66013cc
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/StringBuilderDeleteAndDeleteCharAtTest.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderDeleteAndDeleteCharAtTest.java
+ * -@TestCaseName: Test Method delete(int start, int end) and deleteCharAt(int index) of StringBuilder.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameters: 0 =< start =< end, end =< instance.length, start and end coverage boundary value.
+ * -#step3: Test Method delete(int start, int end) and check result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case2
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameters: 0 =< index < instance.length, index coverage boundary value.
+ * -#step3: Test Method deleteCharAt(int index) and check result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderDeleteAndDeleteCharAtTest.java
+ * -@ExecuteClass: StringBuilderDeleteAndDeleteCharAtTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderDeleteAndDeleteCharAtTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderDeleteAndDeleteCharAtTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderDeleteAndDeleteCharAtTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+
+        StringBuilder strBuilder2_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder2_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder2_3 = new StringBuilder("abc123abc");
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+
+        test2(strBuilder2_1);
+        test2(strBuilder2_2);
+        test2(strBuilder2_3);
+    }
+
+    // Test method delete(int start, int end).
+    private static void test1(StringBuilder strBuilder) {
+        // Test 0 < start < end, end < strBuffer.length().
+        System.out.println(strBuilder.delete(3, 5));
+        // Test start = 0.
+        System.out.println(strBuilder.delete(0, 1));
+        // Test end = 0.
+        System.out.println(strBuilder.delete(0, 0));
+        // Test start=strBuffer.length().
+        System.out.println(strBuilder.delete(strBuilder.length(), strBuilder.length()));
+        // Test end=strBuffer.length().
+        System.out.println(strBuilder.delete(2, strBuilder.length()));
+    }
+
+    // Test method deleteCharAt(int index).
+    private static void test2(StringBuilder strBuilder) {
+        // Test 0 < index < strBuffer.length().
+        System.out.println(strBuilder.deleteCharAt(1));
+        // Test index = 0.
+        System.out.println(strBuilder.deleteCharAt(0));
+        // Test index = strBuffer.length()-1.
+        System.out.println(strBuilder.deleteCharAt(strBuilder.length() - 1));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nwe\n @!%()*\n@!%()*\n@!%()*\n@!%()*\n@!\nabc3abc\nbc3abc\nbc3abc\nbc3abc\nbc\nqertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x9\n !.&%()*\n!.&%()*\n!.&%()\nac123abc\nc123abc\nc123ab\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/StringBuilderCodePointExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/StringBuilderCodePointExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..090004d863bc160fa07ef9712bfe243c2299fb6a
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/StringBuilderCodePointExceptionTest.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderCodePointExceptionTest.java
+ * -@TestCaseName: Test method codePointAt(int index)/codePointBefore(int index)/codePointCount(int beginIndex, int
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      endIndex)/offsetByCodePoints(int index, int codePointOffset) of StringBuilder, test
+ *                      StringIndexOutOfBoundsException throw in codePointAt and codePointBefore, test
+ *                      IndexOutOfBoundsException throw in codePointCount and offsetByCodePoints.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameters: index range from 0 to instance.length.
+ * -#step3: Test method codePointAt(int index). Check result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case2
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameters: index range from 0 to instance.length.
+ * -#step3: Test method codePointBefore(int index). Check result is correctly, StringIndexOutOfBoundsException is thrown
+ *          when index = 0.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case3
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameters: beginIndex range from 0 to instance.length - 2, endIndex = beginIndex + 3.
+ * -#step3: Test method codePointCount(int beginIndex, int endIndex),Check result is correctly.IndexOutOfBoundsException
+ *          is thrown when endIndex > instance.length - 1.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case4
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameters: index range from 0 to instance.length - 2, codePointOffset = index + 3.
+ * -#step3: Test method int offsetByCodePoints(int index, int codePointOffset),Check result is correctly,
+ *          StringIndexOutOfBoundsException is thrown when index + codePointOffset > instance.length.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderCodePointExceptionTest.java
+ * -@ExecuteClass: StringBuilderCodePointExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderCodePointExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderCodePointExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderCodePointExceptionTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`123456789" +
+                "0-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+
+        test3(strBuilder1_1);
+        test3(strBuilder1_2);
+        test3(strBuilder1_3);
+
+        test4(strBuilder1_1);
+        test4(strBuilder1_2);
+        test4(strBuilder1_3);
+    }
+
+    // Test method codePointAt(int index).
+    private static void test1(StringBuilder strBuilder) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = strBuilder.codePointAt(i);
+                System.out.println("i=" + i + " " + "codePointAt=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointAt(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(strBuilder.charAt(i) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+
+    // Test method codePointBefore(int index).
+    private static void test2(StringBuilder strBuilder) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = strBuilder.codePointBefore(i);
+                System.out.println("i=" + i + " " + "codePointBefore=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointBefore(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(strBuilder.charAt(i - 1) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+
+    // Test method codePointCount(int beginIndex, int endIndex).
+    private static void test3(StringBuilder strBuilder) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = strBuilder.codePointCount(i, i + 3);
+                System.out.println("i=" + i + " " + "codePointCount=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("codePointCount(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(strBuilder.charAt(i) + "~" + strBuilder.charAt(i + 3)
+                            + " codePointCount is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+
+    // Test method int offsetByCodePoints(int index, int codePointOffset).
+    private static void test4(StringBuilder strBuilder) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = strBuilder.offsetByCodePoints(i, i + 3);
+                System.out.println("i=" + i + " " + "offsetByCodePoints=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("offsetByCodePoints(): " + i + "+3  out of length");
+            } finally {
+                try {
+                    System.out.println(strBuilder.charAt(i) + " offsetByCodePoints +3 is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full i=0 codePointAt=113\nq Unicode is:113\ni=1 codePointAt=119\nw Unicode is:119\ni=2 codePointAt=101\ne Unicode is:101\ni=3 codePointAt=114\nr Unicode is:114\ni=4 codePointAt=116\nt Unicode is:116\ni=5 codePointAt=121\ny Unicode is:121\ni=0 codePointAt=32\n  Unicode is:32\ni=1 codePointAt=64\n@ Unicode is:64\ni=2 codePointAt=33\n! Unicode is:33\ni=3 codePointAt=46\n. Unicode is:46\ni=4 codePointAt=38\n& Unicode is:38\ni=5 codePointAt=37\n% Unicode is:37\ni=0 codePointAt=97\na Unicode is:97\ni=1 codePointAt=98\nb Unicode is:98\ni=2 codePointAt=99\nc Unicode is:99\ni=3 codePointAt=49\n1 Unicode is:49\ni=4 codePointAt=50\n2 Unicode is:50\ni=5 codePointAt=51\n3 Unicode is:51\ncodePointBefore(): 0out of length\n0 out of length\ni=1 codePointBefore=113\nq Unicode is:113\ni=2 codePointBefore=119\nw Unicode is:119\ni=3 codePointBefore=101\ne Unicode is:101\ni=4 codePointBefore=114\nr Unicode is:114\ni=5 codePointBefore=116\nt Unicode is:116\ncodePointBefore(): 0out of length\n0 out of length\ni=1 codePointBefore=32\n  Unicode is:32\ni=2 codePointBefore=64\n@ Unicode is:64\ni=3 codePointBefore=33\n! Unicode is:33\ni=4 codePointBefore=46\n. Unicode is:46\ni=5 codePointBefore=38\n& Unicode is:38\ncodePointBefore(): 0out of length\n0 out of length\ni=1 codePointBefore=97\na Unicode is:97\ni=2 codePointBefore=98\nb Unicode is:98\ni=3 codePointBefore=99\nc Unicode is:99\ni=4 codePointBefore=49\n1 Unicode is:49\ni=5 codePointBefore=50\n2 Unicode is:50\ni=0 codePointCount=3\nq~r codePointCount is :3\ni=1 codePointCount=3\nw~t codePointCount is :3\ni=2 codePointCount=3\ne~y codePointCount is :3\ni=3 codePointCount=3\nr~u codePointCount is :3\ni=0 codePointCount=3\n ~. codePointCount is :3\ni=1 codePointCount=3\n@~& codePointCount is :3\ni=2 codePointCount=3\n!~% codePointCount is :3\ni=3 codePointCount=3\n3 out of length\ni=0 codePointCount=3\na~1 codePointCount is :3\ni=1 codePointCount=3\nb~2 codePointCount is :3\ni=2 codePointCount=3\nc~3 codePointCount is :3\ni=3 codePointCount=3\n3 out of length\ni=0 offsetByCodePoints=3\nq offsetByCodePoints +3 is :3\ni=1 offsetByCodePoints=5\nw offsetByCodePoints +3 is :5\ni=2 offsetByCodePoints=7\ne offsetByCodePoints +3 is :7\ni=3 offsetByCodePoints=9\nr offsetByCodePoints +3 is :9\ni=0 offsetByCodePoints=3\n  offsetByCodePoints +3 is :3\ni=1 offsetByCodePoints=5\n@ offsetByCodePoints +3 is :5\noffsetByCodePoints(): 2+3  out of length\n! offsetByCodePoints +3 is :5\noffsetByCodePoints(): 3+3  out of length\n. offsetByCodePoints +3 is :5\ni=0 offsetByCodePoints=3\na offsetByCodePoints +3 is :3\ni=1 offsetByCodePoints=5\nb offsetByCodePoints +3 is :5\noffsetByCodePoints(): 2+3  out of length\nc offsetByCodePoints +3 is :5\noffsetByCodePoints(): 3+3  out of length\n1 offsetByCodePoints +3 is :5\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/StringBuilderCapacityAndEnsureCapacityTest.java b/test/testsuite/ouroboros/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/StringBuilderCapacityAndEnsureCapacityTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9bb6772d96c040342ef3947a01e9be6b45a4a7d3
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/StringBuilderCapacityAndEnsureCapacityTest.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderCapacityAndEnsureCapacityTest.java
+ * -@TestCaseName: Test Method capacity()/ensureCapacity(int minimumCapacity) of StringBuilder.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Test method int capacity(),check the result capacity and the length of instance is correctly.
+ * -#step3: Create str(str.length > 0), Invoke Append(String str),test method capacity(), check the result
+ *          capacity and the length of instance is correctly.
+ * -#step4: Create minimumCapacity > old capacity(), Test method ensureCapacity(int minimumCapacity), test
+ *          method capacity(), check the result capacity and the length of instance is correctly.
+ * -#step5: Create newLength > StringBuffer.length, Invoke setLength(int newLength), test method capacity(), check
+ *          the result capacity and the length of instance is correctly.
+ * -#step6: Invoke trimToSize(), test method capacity(), check the result capacity and the length of instance is
+ *          correctly.
+ * -#step7: Create minimumCapacity = 0 or minimumCapacity < 0 or 0 < minimumCapacity < old capacity(), Test method
+ *          ensureCapacity(int minimumCapacity), test method capacity(), check the result capacity and the length of
+ *          instance is correctly.
+ * -#step8: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~7.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderCapacityAndEnsureCapacityTest.java
+ * -@ExecuteClass: StringBuilderCapacityAndEnsureCapacityTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderCapacityAndEnsureCapacityTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderCapacityAndEnsureCapacityTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderCapacityAndEnsureCapacityTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+        test1(strBuilder1_5);
+    }
+
+    private static void test1(StringBuilder strBuilder) {
+        System.out.println("1-capacity: " + strBuilder.capacity());
+        System.out.println("1-lent: " + strBuilder.length());
+
+        strBuilder = strBuilder.append("01234567890123456789");
+        System.out.println("2-capacity: " + strBuilder.capacity());
+        System.out.println("2-lent: " + strBuilder.length());
+
+        strBuilder.ensureCapacity(80);
+        System.out.println("3-capacity: " + strBuilder.capacity());
+        System.out.println("3-lent: " + strBuilder.length());
+
+        strBuilder.setLength(100);
+        System.out.println("4-capacity: " + strBuilder.capacity());
+        System.out.println("4-lent: " + strBuilder.length());
+
+        strBuilder.trimToSize();
+        System.out.println("5-capacity: " + strBuilder.capacity());
+        System.out.println("5-lent: " + strBuilder.length());
+
+        strBuilder.ensureCapacity(-2);
+        System.out.println("6-capacity: " + strBuilder.capacity());
+        System.out.println("6-lent: " + strBuilder.length());
+
+        strBuilder.ensureCapacity(0);
+        System.out.println("7-capacity: " + strBuilder.capacity());
+        System.out.println("7-lent: " + strBuilder.length());
+
+        strBuilder.ensureCapacity(2);
+        System.out.println("8-capacity: " + strBuilder.capacity());
+        System.out.println("8-lent: " + strBuilder.length());
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 1-capacity: 115\n1-lent: 99\n2-capacity: 232\n2-lent: 119\n3-capacity: 232\n3-lent: 119\n4-capacity: 232\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n1-capacity: 25\n1-lent: 9\n2-capacity: 52\n2-lent: 29\n3-capacity: 106\n3-lent: 29\n4-capacity: 106\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n1-capacity: 22\n1-lent: 6\n2-capacity: 46\n2-lent: 26\n3-capacity: 94\n3-lent: 26\n4-capacity: 190\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n1-capacity: 16\n1-lent: 0\n2-capacity: 34\n2-lent: 20\n3-capacity: 80\n3-lent: 20\n4-capacity: 162\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n1-capacity: 16\n1-lent: 0\n2-capacity: 34\n2-lent: 20\n3-capacity: 80\n3-lent: 20\n4-capacity: 162\n4-lent: 100\n5-capacity: 100\n5-lent: 100\n6-capacity: 100\n6-lent: 100\n7-capacity: 100\n7-lent: 100\n8-capacity: 100\n8-lent: 100\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/StringBuilderCharAtAndSetCharAtExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/StringBuilderCharAtAndSetCharAtExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef8b937fba7d8bbe244911e1580b7051485ebda5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/StringBuilderCharAtAndSetCharAtExceptionTest.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderCharAtAndSetCharAtExceptionTest.java
+ * -@TestCaseName: Test Method charAt(int index)/setCharAt(int index, char ch) of StringBuilder and
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      StringIndexOutOfBoundsException occured in charAt/setCharAt.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameters: index range from -1  to exceed instance.length.
+ * -#step3: Test method char charAt(int index) and StringIndexOutOfBoundsException is thrown.
+ * -#step4: Check the result char is correctly when index is range from 0 to (instance.length -1),
+ *          StringIndexOutOfBoundsException is thrown when index < 0 or index > (instance.length -1).
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/"" to repeat step2~4.
+ * -#case2
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create parameters: index range from -1  to exceed instance.length. ch is a Letter char.
+ * -#step3: Test Method void setCharAt(int index, char ch) and StringIndexOutOfBoundsException is thrown.
+ * -#step4: Check the instance after setCharAt is replaced correctly when index is range from 0 to (instance.length -1),
+ *          or StringIndexOutOfBoundsException is thrown when index < 0 or index > (instance.length -1).
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/"" to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderCharAtAndSetCharAtExceptionTest.java
+ * -@ExecuteClass: StringBuilderCharAtAndSetCharAtExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderCharAtAndSetCharAtExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderCharAtAndSetCharAtExceptionTest_1();
+            StringBuilderCharAtAndSetCharAtExceptionTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderCharAtAndSetCharAtExceptionTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+    }
+
+    public static void StringBuilderCharAtAndSetCharAtExceptionTest_2() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+        test2(strBuilder1_4);
+    }
+
+    // Test method char charAt(int index).
+    private static void test1(StringBuilder strBuilder) {
+        int charAt = 0;
+        for (int i = -1; i < 8; i++) {
+            try {
+                charAt = strBuilder.charAt(i);
+                System.out.println("i=" + i + "  " + "charAt=" + charAt);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("index: " + i + "  String index out of range");
+            }
+        }
+    }
+
+    // Test Method void setCharAt(int index, char ch).
+    private static void test2(StringBuilder strBuilder) {
+        char ch = 'A';
+        for (int i = -1; i < 8; i++) {
+            try {
+                strBuilder.setCharAt(i, ch);
+                System.out.println("i=" + i + "  " + "setcharAt=" + strBuilder);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("index: " + i + "  String index out of range");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full index: -1  String index out of range\ni=0  charAt=113\ni=1  charAt=119\ni=2  charAt=101\ni=3  charAt=114\ni=4  charAt=116\ni=5  charAt=121\ni=6  charAt=117\ni=7  charAt=105\nindex: -1  String index out of range\ni=0  charAt=32\ni=1  charAt=64\ni=2  charAt=33\ni=3  charAt=46\ni=4  charAt=38\ni=5  charAt=37\ni=6  charAt=40\ni=7  charAt=41\nindex: -1  String index out of range\ni=0  charAt=97\ni=1  charAt=98\ni=2  charAt=99\ni=3  charAt=49\ni=4  charAt=50\ni=5  charAt=51\nindex: 6  String index out of range\nindex: 7  String index out of range\nindex: -1  String index out of range\nindex: 0  String index out of range\nindex: 1  String index out of range\nindex: 2  String index out of range\nindex: 3  String index out of range\nindex: 4  String index out of range\nindex: 5  String index out of range\nindex: 6  String index out of range\nindex: 7  String index out of range\nindex: -1  String index out of range\ni=0  setcharAt=Awertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=1  setcharAt=AAertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=2  setcharAt=AAArtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=3  setcharAt=AAAAtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=4  setcharAt=AAAAAyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=5  setcharAt=AAAAAAuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=6  setcharAt=AAAAAAAiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ni=7  setcharAt=AAAAAAAAop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nindex: -1  String index out of range\ni=0  setcharAt=A@!.&%()*\ni=1  setcharAt=AA!.&%()*\ni=2  setcharAt=AAA.&%()*\ni=3  setcharAt=AAAA&%()*\ni=4  setcharAt=AAAAA%()*\ni=5  setcharAt=AAAAAA()*\ni=6  setcharAt=AAAAAAA)*\ni=7  setcharAt=AAAAAAAA*\nindex: -1  String index out of range\ni=0  setcharAt=Abc123\ni=1  setcharAt=AAc123\ni=2  setcharAt=AAA123\ni=3  setcharAt=AAAA23\ni=4  setcharAt=AAAAA3\ni=5  setcharAt=AAAAAA\nindex: 6  String index out of range\nindex: 7  String index out of range\nindex: -1  String index out of range\nindex: 0  String index out of range\nindex: 1  String index out of range\nindex: 2  String index out of range\nindex: 3  String index out of range\nindex: 4  String index out of range\nindex: 5  String index out of range\nindex: 6  String index out of range\nindex: 7  String index out of range\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0020-rt-String-BuilderGetCharsTest/StringBuilderGetCharsTest.java b/test/testsuite/ouroboros/string_test/RT0020-rt-String-BuilderGetCharsTest/StringBuilderGetCharsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fdaf14e056f32e35fdd1fcbd8cc40ebadddf36cb
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0020-rt-String-BuilderGetCharsTest/StringBuilderGetCharsTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderGetCharsTest.java
+ * -@TestCaseName: Test Method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) of StringBuilder.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create StringBuilder instance by new StringBuilder(String stringLine).
+ * -#step2: Create parameters: instance.length  > srcEnd > srcBegin,dstBegin < dst(char[]).length, srcBegin/srcEnd
+ *          /dstBegin coverage boundary value.
+ * -#step3: Test Method void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin).
+ * -#step4: Check some chars of dst(char[]) is replaced correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderGetCharsTest.java
+ * -@ExecuteClass: StringBuilderGetCharsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderGetCharsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderGetCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderGetCharsTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+    }
+
+    private static void test1(StringBuilder strBuilder) {
+        // Test srcBegin  < srcEnd < instance.length, dstBegin < dst(char[]).length.
+        char[] dst = {'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(2, 5, dst, 2);
+        System.out.println(dst);
+
+        // Test srcBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(0, 3, dst, 2);
+        System.out.println(dst);
+
+        // Test srcEnd = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(0, 0, dst, 2);
+        System.out.println(dst);
+
+        // Test dstBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(2, 5, dst, 0);
+        System.out.println(dst);
+
+        // Test strBuilder = srcEnd.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(2, 2, dst, 0);
+        System.out.println(dst);
+
+        // Test srcBegin = strBuffer.length() - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        int index = strBuilder.length() - 1;
+        strBuilder.getChars(index, index, dst, 0);
+        System.out.println(dst);
+
+        // Test srcEnd = strBuffer.length() - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(index - 2, index, dst, 0);
+        System.out.println(dst);
+
+        // Test dstBegin = dst.length-1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(0, 1, dst, dst.length - 1);
+        System.out.println(dst);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ABertF\nABqweF\nABCDEF\nertDEF\nABCDEF\nABCDEF\nx9CDEF\nABCDEq\nAB!.&F\nAB @!F\nABCDEF\n!.&DEF\nABCDEF\nABCDEF\n()CDEF\nABCDE \nABc12F\nABabcF\nABCDEF\nc12DEF\nABCDEF\nABCDEF\n12CDEF\nABCDEa\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/StringBuilderIndexOfAndLastIndexOfTest.java b/test/testsuite/ouroboros/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/StringBuilderIndexOfAndLastIndexOfTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b028e2879c5f4aa218c2984b56e1e1a5b75454a
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/StringBuilderIndexOfAndLastIndexOfTest.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderIndexOfAndLastIndexOfTest.java
+ * -@TestCaseName: Test Method int indexOf(String str)/int indexOf(String str, int fromIndex)/int lastIndexOf(
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      String str)/int lastIndexOf(String str, int fromIndex) of StringBuilder.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameters: str is String with letter or empty String.
+ * -#step3: Test method indexOf(String str),check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~3.
+ * -#case2
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameters: str is String with letter, instance.length > fromIndex >= 0, fromIndex coverage boundary
+ *          value.
+ * -#step3: Test method indexOf(String str, int fromIndex),check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~3.
+ * -#case3
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameters: str is String with letter or empty String.
+ * -#step3: Test method lastIndexOf(String str),check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~3.
+ * -#case4
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameters: str is String with letter, instance.length > fromIndex >= 0, fromIndex coverage boundary
+ *          value.
+ * -#step3: Test method lastIndexOf(String str, int fromIndex),check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderIndexOfAndLastIndexOfTest.java
+ * -@ExecuteClass: StringBuilderIndexOfAndLastIndexOfTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderIndexOfAndLastIndexOfTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderIndexOfAndLastIndexOfTest_1();
+            StringBuilderIndexOfAndLastIndexOfTest_2();
+            StringBuilderIndexOfAndLastIndexOfTest_3();
+            StringBuilderIndexOfAndLastIndexOfTest_4();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderIndexOfAndLastIndexOfTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+        test1(strBuilder1_5);
+    }
+
+    public static void StringBuilderIndexOfAndLastIndexOfTest_2() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+        test2(strBuilder1_4);
+        test2(strBuilder1_5);
+    }
+
+    public static void StringBuilderIndexOfAndLastIndexOfTest_3() {
+
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test3(strBuilder1_1);
+        test3(strBuilder1_2);
+        test3(strBuilder1_3);
+        test3(strBuilder1_4);
+        test3(strBuilder1_5);
+    }
+
+    public static void StringBuilderIndexOfAndLastIndexOfTest_4() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test4(strBuilder1_1);
+        test4(strBuilder1_2);
+        test4(strBuilder1_3);
+        test4(strBuilder1_4);
+        test4(strBuilder1_5);
+    }
+
+    // Test method indexOf(String str).
+    private static void test1(StringBuilder strBuilder) {
+        System.out.println(strBuilder.indexOf("b"));
+        // Test empty String.
+        System.out.println(strBuilder.indexOf(""));
+    }
+
+    // Test method indexOf(String str, int fromIndex).
+    private static void test2(StringBuilder strBuilder) {
+        System.out.println(strBuilder.indexOf("b", 2));
+        // Test fromIndex = 0.
+        System.out.println(strBuilder.indexOf("b", 0));
+        // Test fromIndex = strBuilder.length() - 1.
+        System.out.println(strBuilder.indexOf("6", strBuilder.length() - 1));
+    }
+
+    // Test method lastIndexOf(String str).
+    private static void test3(StringBuilder strBuilder) {
+        System.out.println(strBuilder.lastIndexOf("b"));
+        // Test empty String.
+        System.out.println(strBuilder.lastIndexOf(""));
+    }
+
+    // Test method lastIndexOf(String str, int fromIndex).
+    private static void test4(StringBuilder strBuilder) {
+        System.out.println(strBuilder.lastIndexOf("b", 1));
+        // Test fromIndex = 0.
+        System.out.println(strBuilder.lastIndexOf("b", 0));
+        // Test fromIndex = strBuilder.length() - 1.
+        System.out.println(strBuilder.lastIndexOf("6", strBuilder.length() - 1));
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 33\n0\n-1\n0\n1\n0\n-1\n0\n-1\n0\n33\n33\n98\n-1\n-1\n-1\n7\n1\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n33\n99\n-1\n9\n7\n9\n-1\n0\n-1\n0\n-1\n-1\n98\n-1\n-1\n-1\n1\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/StringBuilderReplaceAndReverseTest.java b/test/testsuite/ouroboros/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/StringBuilderReplaceAndReverseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5705c1064a6bcc3787740a8396d16b578697389a
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/StringBuilderReplaceAndReverseTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderReplaceAndReverseTest.java
+ * -@TestCaseName: Test Method StringBuffer replace(int start, int end, String str)/StringBuffer reverse() of
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      StringBuilder.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameters: start < end < instance.length, start/end coverage boundary value. str is String with some
+  *         letters.
+ * -#step3: Test method replace(int start, int end, String str), check return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -#case2
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Test method reverse(), check return result is correctly.
+ * -#step3: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderReplaceAndReverseTest.java
+ * -@ExecuteClass: StringBuilderReplaceAndReverseTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderReplaceAndReverseTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderReplaceAndReverseTest_1();
+            StringBuilderReplaceAndReverseTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderReplaceAndReverseTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+    }
+
+    public static void StringBuilderReplaceAndReverseTest_2() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+        test2(strBuilder1_4);
+        test2(strBuilder1_5);
+    }
+
+    // Test method replace(int start, int end, String str).
+    private static void test1(StringBuilder strBuilder) {
+        System.out.println(strBuilder.replace(2, 6, "xyz"));
+        // end = 0
+        System.out.println(strBuilder.replace(0, 0, "xyz"));
+        // start = 0 & end = strBuffer.length()
+        System.out.println(strBuilder.replace(0, strBuilder.length(), "xyz"));
+        // start = strBuffer.length() & end = strBuffer.length()
+        System.out.println(strBuilder.replace(strBuilder.length(), strBuilder.length(), "xyz"));
+    }
+
+    // Test method reverse().
+    private static void test2(StringBuilder strBuilder) {
+        strBuilder.reverse();
+        System.out.println(strBuilder);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwxyzuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nxyzqwxyzuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nxyz\nxyzxyz\n @xyz\nxyz @xyz\nxyz\nxyzxyz\nabxyzabc\nxyzabxyzabc\nxyz\nxyzxyz\n69x0MNBVCXZPOIUYTREWQLKJHGFDSA +_)(*&^%$#@!=-0987654321`~?/><.,mnbvcxz"\':;lkjhgfdsa|\\][}{poiuytrewq\n%&.!@ \ncba321cba\n\n\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/StringBuilderSubstringAndToStringTest.java b/test/testsuite/ouroboros/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/StringBuilderSubstringAndToStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c286e65f925a78853b47080bee937df9ae73181
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/StringBuilderSubstringAndToStringTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderSubstringAndToStringTest.java
+ * -@TestCaseName: Test Method:String substring(int start)/String substring(int start, int end)/String toString()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+  *                     of StringBuilder.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameters: start < instance.length, start < end < instance.length, start and end coverage boundary
+ *          value.
+ * -#step3: Test method substring(int start, int end).
+ * -#step4: Check the return result of substring is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -#case2
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameters: 0 =< start < instance.length, start coverage boundary value.
+ * -#step3: Test method substring(int start).
+ * -#step4: Check the return result of substring is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -#case3
+ * -#step1: Create StringBuilder instance by new StringBuilder(String stringLine).
+ * -#step2: Test method toString().
+ * -#step3: Check the return result of toString is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2-3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringBuilderSubstringAndToStringTest.java
+ * -@ExecuteClass: StringBuilderSubstringAndToStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderSubstringAndToStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringBuilderSubstringAndToStringTest_1();
+            StringBuilderSubstringAndToStringTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringBuilderSubstringAndToStringTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+    }
+
+    public static void StringBuilderSubstringAndToStringTest_2() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+
+        test3(strBuilder1_1);
+        test3(strBuilder1_2);
+        test3(strBuilder1_3);
+        test3(strBuilder1_4);
+        test3(strBuilder1_5);
+    }
+
+    // Test method substring(int start, int end).
+    private static void test1(StringBuilder strBuilder) {
+        System.out.println(strBuilder.substring(2, 7));
+        // Test start = 0 & end = strBuffer.length().
+        System.out.println(strBuilder.substring(0, strBuilder.length()));
+        // Test start = strBuffer.length().
+        System.out.println(strBuilder.substring(strBuilder.length(), strBuilder.length()));
+        // Test end = 0.
+        System.out.println(strBuilder.substring(0, 0));
+    }
+
+    // Test method substring(int start).
+    private static void test2(StringBuilder strBuilder) {
+        System.out.println(strBuilder.substring(3));
+        // Test start = 0.
+        System.out.println(strBuilder.substring(0));
+        // Test start = strBuffer.length().
+        System.out.println(strBuilder.substring(strBuilder.length()));
+    }
+
+    // Test method toString().
+    private static void test3(StringBuilder strBuilder) {
+        System.out.println(strBuilder.toString());
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ertyu\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n\n!.&%(\n @!.&%()*\n\n\nc123a\nabc123abc\n\n\nrtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n.&%()*\n @!.&%()*\n\n123abc\nabc123abc\n\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\nabc123abc\n\n\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c244632df4be5aaa8299858b1a85b6633a3a92de
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsBytesIntIntIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test IndexOutOfBoundsException in String constructor:public String(byte[] bytes, int offset,
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+  *                     int length).
+ * -@Brief:
+ * -#step1: Create Parameters: byte[] str1_1,str1_1.length > 0, element is byte in normal.
+ * -#step2: Create offset < 0, 0 < length < str1_1.length, Test Constructors new String(byte[] bytes, int offset,
+ *          int length), check IndexOutOfBoundsException is thrown.
+ * -#step3: Create 0 < offset < str1_1.length, length < 0, Test Constructors new String(byte[] bytes, int offset,
+ *          int length), check IndexOutOfBoundsException is thrown.
+ * -#step4: Create 0 < offset < str1_1.length, length > str1_1.length, Test Constructors new String(byte[] bytes,
+ *          int offset, int length), check IndexOutOfBoundsException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsBytesIntIntIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringConsBytesIntIntIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsBytesIntIntIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            result = StringConsBytesIntIntIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 96) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringConsBytesIntIntIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success */
+        // IndexOutOfBoundsException - If the offset and length arguments index characters outside the bounds of the
+        // bytes array
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, -1, 3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 3, -1);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 3, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/StringConsCharArrayIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/StringConsCharArrayIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c5bb2ffea1c08f04e48f62f35fd9f999801db04
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/StringConsCharArrayIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsCharArrayIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test String constructor: String(char[] value, int offset, int count) throw
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      IndexOutOfBoundsException.
+ * -@Brief:
+ * -#step1: Create Parameters: char[] str1_1,str1_1.length > 0, element is letter or number.
+ * -#step2: Create offset < 0, 0 < length < str1_1.length, Test Constructors new String(char[] value, int offset,
+ *          int count), check IndexOutOfBoundsException is thrown.
+ * -#step3: Create 0 =< offset < str1_1.length, length > str1_1.length, Test Constructors new String(char[] value,
+ *          int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsCharArrayIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringConsCharArrayIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsCharArrayIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            result = StringConsCharArrayIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringConsCharArrayIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success */
+        // IndexOutOfBoundsException - If the offset and length arguments index characters outside the bounds of the
+        // bytes array
+        char[] str1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        try {
+            String str1 = new String(str1_1, -1, 3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        try {
+            String str2 = new String(str1_1, 0, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/StringConsIntArrayExceptionsTest.java b/test/testsuite/ouroboros/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/StringConsIntArrayExceptionsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b106177cff95afb0945151f1fc24526bf07a219
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/StringConsIntArrayExceptionsTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsIntArrayExceptionsTest.java
+ * -@TestCaseName: Test IndexOutOfBoundsException/IllegalArgumentException in String constructor: String(int[]
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      codePoints, int offset, int count).
+ * -@Brief:
+ * -#step1: Create Parameters: int[] str1_1,str1_1.length > 0, element is number.
+ * -#step2: Create offset < 0, count = str1_1.length, Test Constructors new String(int[] codePoints, int offset,
+ *          int count), check IndexOutOfBoundsException is thrown.
+ * -#step3: Create 0 =< offset < str1_1.length, count > str1_1.length, Test Constructors new String(int[] codePoints,
+ *          int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -#step4: Create Parameters: int[] str1_2,str1_2.length > 0, element is Unicode code point include invalid num.
+ * -#step5: Create offset = 0, count = str1_2.length, Test Constructors new String(int[] codePoints, int offset,
+ *          int count), check IllegalArgumentException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsIntArrayExceptionsTest.java
+ * -@ExecuteClass: StringConsIntArrayExceptionsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsIntArrayExceptionsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            result = StringConsIntArrayExceptionsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 96) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringConsIntArrayExceptionsTest_1() {
+        int result1 = 2; /* STATUS_Success */
+        // IndexOutOfBoundsException - If the offset and count arguments index characters outside the bounds of the
+        // codePoints array
+        int[] str1_1 = new int[]{97, 98, 99, 49, 50, 51};
+        try {
+            String str1 = new String(str1_1, -1, str1_1.length);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 0, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        //IllegalArgumentException - If any invalid Unicode code point is found in codePoints
+        int[] str1_2 = new int[]{0xFFFFFFF, 0x62, 0x63, 0x31, 0x32, 0x33};
+        try {
+            String str2 = new String(str1_2, 0, str1_2.length);
+            processResult -= 10;
+        } catch (IllegalArgumentException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..581c81c5851c382e4fd09286836f2a6c59ab0f88
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test IndexOutOfBoundsException/IllegalArgumentException in String constructor: String(byte[]
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      ascii, int hibyte, int offset, int count).
+ * -@Brief:
+ * -#step1: Create Parameters: byte[] str1_1,str1_1.length > 0, element is byte in normal.
+ * -#step2: Create hibyte >= 0, offset < 0, 0 < count < str1_1.length, Test Constructors new String(byte[] bytes, int
+ *          hibyte, int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -#step3: Create hibyte >= 0, str1_1.length > offset >= 0, count > str1_1.length, Test Constructors new String(byte[]
+ *          bytes, int hibyte, int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            result = StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success */
+        // IndexOutOfBoundsException - If the offset and count arguments index characters outside the bounds of the
+        // codePoints array
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, 0, -1, 2);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 0, 0, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/StringConsBytesIntIntCharsetExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/StringConsBytesIntIntCharsetExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..43c316016742a9cec7f95c2b8b789adf1b250dd7
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/StringConsBytesIntIntCharsetExceptionTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsBytesIntIntCharsetExceptionTest.java
+ * -@TestCaseName: Test IndexOutOfBoundsException in String constructor: String(byte[] bytes, int offset, int
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      length, Charset charset).
+ * -@Brief:
+ * -#step1: Create Parameters: byte[] str1_1,str1_1.length > 0, element is byte in normal.
+ * -#step2: Create offset < 0, 0 < length < str1_1.length, Charset is a Unicode charset, Test Constructors new String(
+ *          byte[] bytes, int offset, int length, Charset charset), check IndexOutOfBoundsException is thrown.
+ * -#step3: Create str1_1.length > offset >= 0, length < 0, Charset is a Unicode Charset, Test Constructors new String(
+ *          byte[] bytes, int offset, int length, Charset charset), check IndexOutOfBoundsException is thrown.
+ * -#step4: Create str1_1.length > offset >= 0, length > str1_1.length, Charset is a Unicode Charset, Test Constructors
+ *          new String(byte[] bytes, int offset, int length, Charset charset), check IndexOutOfBoundsException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsBytesIntIntCharsetExceptionTest.java
+ * -@ExecuteClass: StringConsBytesIntIntCharsetExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.nio.charset.Charset;
+
+public class StringConsBytesIntIntCharsetExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            result = StringConsBytesIntIntCharsetExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 96) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringConsBytesIntIntCharsetExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success */
+        // IndexOutOfBoundsException - If the offset and length arguments index characters outside the bounds of the
+        // bytes array
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, -1, 3, Charset.forName("ASCII"));
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 3, -1, Charset.forName("ASCII"));
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 3, 10, Charset.forName("ASCII"));
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/StringCharAtIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/StringCharAtIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fe9e835f5fc9e8428e90039ac32da2f975537fa
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/StringCharAtIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCharAtIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test IndexOutOfBoundsException in String Method: public char charAt(int index).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: str1.length > 0, index < 0, Test method charAt(int index), check IndexOutOfBoundsException
+ *          is thrown.
+ * -#step3: Create Parameters: str1.length = 0, index > 0, Test method charAt(int index), check IndexOutOfBoundsException
+ *          is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCharAtIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringCharAtIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCharAtIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            result = StringCharAtIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringCharAtIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success */
+        // IndexOutOfBoundsException - if the index argument is negative or not less than the length of this string.
+        String str1_1 = new String("abc123");
+        String str1_4 = new String("");
+        try {
+            char ch = str1_1.charAt(-2);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            char ch = str1_4.charAt(2);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/StringCodePointAtStringIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/StringCodePointAtStringIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c64bedcbb688dbd519ac60339d3fad200614653
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/StringCodePointAtStringIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCodePointAtStringIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test StringIndexOutOfBoundsException in String Method: public int codePointAt(int index).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: index range from -1 to instance.length + 1.
+ * -#step3: Check the result int is correctly when index is range from 0 to (instance.length -1),
+ *          StringIndexOutOfBoundsException is thrown when index < 0 or index > (instance.length -1).
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2-3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCodePointAtStringIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringCodePointAtStringIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCodePointAtStringIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCodePointAtStringIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCodePointAtStringIndexOutOfBoundsExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = -1; i < 7; i++) {
+            try {
+                codePoint = str.codePointAt(i);
+                System.out.println("i=" + i + " " + "codePointAt=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointAt(): " + i + " StringIndexOutOfBounds");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " StringIndexOutOfBounds");
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full codePointAt(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointAt=113\nq Unicode is:113\ni=1 codePointAt=119\nw Unicode is:119\ni=2 codePointAt=101\ne Unicode is:101\ni=3 codePointAt=114\nr Unicode is:114\ni=4 codePointAt=116\nt Unicode is:116\ni=5 codePointAt=121\ny Unicode is:121\ni=6 codePointAt=117\nu Unicode is:117\ncodePointAt(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointAt=32\n  Unicode is:32\ni=1 codePointAt=64\n@ Unicode is:64\ni=2 codePointAt=33\n! Unicode is:33\ni=3 codePointAt=46\n. Unicode is:46\ni=4 codePointAt=38\n& Unicode is:38\ni=5 codePointAt=37\n% Unicode is:37\ncodePointAt(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\ncodePointAt(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointAt=97\na Unicode is:97\ni=1 codePointAt=98\nb Unicode is:98\ni=2 codePointAt=99\nc Unicode is:99\ni=3 codePointAt=49\n1 Unicode is:49\ni=4 codePointAt=50\n2 Unicode is:50\ni=5 codePointAt=51\n3 Unicode is:51\ncodePointAt(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\ncodePointAt(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointAt(): 0 StringIndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\ncodePointAt(): 1 StringIndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\ncodePointAt(): 2 StringIndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\ncodePointAt(): 3 StringIndexOutOfBounds\ncharAt(): 3 StringIndexOutOfBounds\ncodePointAt(): 4 StringIndexOutOfBounds\ncharAt(): 4 StringIndexOutOfBounds\ncodePointAt(): 5 StringIndexOutOfBounds\ncharAt(): 5 StringIndexOutOfBounds\ncodePointAt(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\ncodePointAt(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointAt(): 0 StringIndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\ncodePointAt(): 1 StringIndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\ncodePointAt(): 2 StringIndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\ncodePointAt(): 3 StringIndexOutOfBounds\ncharAt(): 3 StringIndexOutOfBounds\ncodePointAt(): 4 StringIndexOutOfBounds\ncharAt(): 4 StringIndexOutOfBounds\ncodePointAt(): 5 StringIndexOutOfBounds\ncharAt(): 5 StringIndexOutOfBounds\ncodePointAt(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\ncodePointAt(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointAt=113\nq Unicode is:113\ni=1 codePointAt=119\nw Unicode is:119\ni=2 codePointAt=101\ne Unicode is:101\ni=3 codePointAt=114\nr Unicode is:114\ni=4 codePointAt=116\nt Unicode is:116\ni=5 codePointAt=121\ny Unicode is:121\ni=6 codePointAt=117\nu Unicode is:117\ncodePointAt(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointAt=32\n  Unicode is:32\ni=1 codePointAt=64\n@ Unicode is:64\ni=2 codePointAt=33\n! Unicode is:33\ni=3 codePointAt=46\n. Unicode is:46\ni=4 codePointAt=38\n& Unicode is:38\ni=5 codePointAt=37\n% Unicode is:37\ncodePointAt(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\ncodePointAt(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointAt=97\na Unicode is:97\ni=1 codePointAt=98\nb Unicode is:98\ni=2 codePointAt=99\nc Unicode is:99\ni=3 codePointAt=49\n1 Unicode is:49\ni=4 codePointAt=50\n2 Unicode is:50\ni=5 codePointAt=51\n3 Unicode is:51\ncodePointAt(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\ncodePointAt(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointAt(): 0 StringIndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\ncodePointAt(): 1 StringIndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\ncodePointAt(): 2 StringIndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\ncodePointAt(): 3 StringIndexOutOfBounds\ncharAt(): 3 StringIndexOutOfBounds\ncodePointAt(): 4 StringIndexOutOfBounds\ncharAt(): 4 StringIndexOutOfBounds\ncodePointAt(): 5 StringIndexOutOfBounds\ncharAt(): 5 StringIndexOutOfBounds\ncodePointAt(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/StringCodePointBeforeExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/StringCodePointBeforeExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9915b78a35dd40582d166d1ee908b43e53133e03
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/StringCodePointBeforeExceptionTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCodePointBeforeExceptionTest.java
+ * -@TestCaseName: Test StringIndexOutOfBoundsException in String Method: int codePointBefore(int index).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: index range from -1 to instance.length + 1.
+ * -#step3: Check the result int is correctly when index is range from 0 to (instance.length -1),
+ *          StringIndexOutOfBoundsException is thrown when index < 0 or index > (instance.length -1).
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2-3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCodePointBeforeExceptionTest.java
+ * -@ExecuteClass: StringCodePointBeforeExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCodePointBeforeExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCodePointBeforeExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCodePointBeforeExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = -1; i < 7; i++) {
+            try {
+                codePoint = str.codePointBefore(i);
+                System.out.println("i=" + i + " " + "codePointBefore=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointBefore(): " + i + " StringIndexOutOfBounds");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " codePointBefore is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " StringIndexOutOfBounds");
+                }
+            }
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full codePointBefore(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointBefore(): 0 StringIndexOutOfBounds\nq codePointBefore is:0\ni=1 codePointBefore=113\nw codePointBefore is:113\ni=2 codePointBefore=119\ne codePointBefore is:119\ni=3 codePointBefore=101\nr codePointBefore is:101\ni=4 codePointBefore=114\nt codePointBefore is:114\ni=5 codePointBefore=116\ny codePointBefore is:116\ni=6 codePointBefore=121\nu codePointBefore is:121\ncodePointBefore(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointBefore(): 0 StringIndexOutOfBounds\n  codePointBefore is:0\ni=1 codePointBefore=32\n@ codePointBefore is:32\ni=2 codePointBefore=64\n! codePointBefore is:64\ni=3 codePointBefore=33\n. codePointBefore is:33\ni=4 codePointBefore=46\n& codePointBefore is:46\ni=5 codePointBefore=38\n% codePointBefore is:38\ni=6 codePointBefore=37\ncharAt(): 6 StringIndexOutOfBounds\ncodePointBefore(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointBefore(): 0 StringIndexOutOfBounds\na codePointBefore is:0\ni=1 codePointBefore=97\nb codePointBefore is:97\ni=2 codePointBefore=98\nc codePointBefore is:98\ni=3 codePointBefore=99\n1 codePointBefore is:99\ni=4 codePointBefore=49\n2 codePointBefore is:49\ni=5 codePointBefore=50\n3 codePointBefore is:50\ni=6 codePointBefore=51\ncharAt(): 6 StringIndexOutOfBounds\ncodePointBefore(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointBefore(): 0 StringIndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\ncodePointBefore(): 1 StringIndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\ncodePointBefore(): 2 StringIndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\ncodePointBefore(): 3 StringIndexOutOfBounds\ncharAt(): 3 StringIndexOutOfBounds\ncodePointBefore(): 4 StringIndexOutOfBounds\ncharAt(): 4 StringIndexOutOfBounds\ncodePointBefore(): 5 StringIndexOutOfBounds\ncharAt(): 5 StringIndexOutOfBounds\ncodePointBefore(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\ncodePointBefore(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointBefore(): 0 StringIndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\ncodePointBefore(): 1 StringIndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\ncodePointBefore(): 2 StringIndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\ncodePointBefore(): 3 StringIndexOutOfBounds\ncharAt(): 3 StringIndexOutOfBounds\ncodePointBefore(): 4 StringIndexOutOfBounds\ncharAt(): 4 StringIndexOutOfBounds\ncodePointBefore(): 5 StringIndexOutOfBounds\ncharAt(): 5 StringIndexOutOfBounds\ncodePointBefore(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\ncodePointBefore(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointBefore(): 0 StringIndexOutOfBounds\nq codePointBefore is:0\ni=1 codePointBefore=113\nw codePointBefore is:113\ni=2 codePointBefore=119\ne codePointBefore is:119\ni=3 codePointBefore=101\nr codePointBefore is:101\ni=4 codePointBefore=114\nt codePointBefore is:114\ni=5 codePointBefore=116\ny codePointBefore is:116\ni=6 codePointBefore=121\nu codePointBefore is:121\ncodePointBefore(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointBefore(): 0 StringIndexOutOfBounds\n  codePointBefore is:0\ni=1 codePointBefore=32\n@ codePointBefore is:32\ni=2 codePointBefore=64\n! codePointBefore is:64\ni=3 codePointBefore=33\n. codePointBefore is:33\ni=4 codePointBefore=46\n& codePointBefore is:46\ni=5 codePointBefore=38\n% codePointBefore is:38\ni=6 codePointBefore=37\ncharAt(): 6 StringIndexOutOfBounds\ncodePointBefore(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointBefore(): 0 StringIndexOutOfBounds\na codePointBefore is:0\ni=1 codePointBefore=97\nb codePointBefore is:97\ni=2 codePointBefore=98\nc codePointBefore is:98\ni=3 codePointBefore=99\n1 codePointBefore is:99\ni=4 codePointBefore=49\n2 codePointBefore is:49\ni=5 codePointBefore=50\n3 codePointBefore is:50\ni=6 codePointBefore=51\ncharAt(): 6 StringIndexOutOfBounds\ncodePointBefore(): -1 StringIndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointBefore(): 0 StringIndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\ncodePointBefore(): 1 StringIndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\ncodePointBefore(): 2 StringIndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\ncodePointBefore(): 3 StringIndexOutOfBounds\ncharAt(): 3 StringIndexOutOfBounds\ncodePointBefore(): 4 StringIndexOutOfBounds\ncharAt(): 4 StringIndexOutOfBounds\ncodePointBefore(): 5 StringIndexOutOfBounds\ncharAt(): 5 StringIndexOutOfBounds\ncodePointBefore(): 6 StringIndexOutOfBounds\ncharAt(): 6 StringIndexOutOfBounds\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/StringCodePointCountIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/StringCodePointCountIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2cfab95de8065cff8d625dd55df51d44978fc83c
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/StringCodePointCountIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCodePointCountIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test IndexOutOfBoundsException in int codePointCount(int beginIndex, int endIndex) of String.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: beginIndex range from -1 to instance.length - 2, endIndex = beginIndex + 3.
+ * -#step3: Test Method codePointCount(int beginIndex, int endIndex), Check result is correctly.
+ *          IndexOutOfBoundsException is thrown when beginIndex < 0 or endIndex > instance.length - 1.
+ * -#step4: Create Parameters index = beginIndex, Test Method charAt(int index), Check String instance is correctly.
+ *          StringIndexOutOfBoundsException is thrown when index < 0 or index >= instance.length.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCodePointCountIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringCodePointCountIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCodePointCountIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCodePointCountIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCodePointCountIndexOutOfBoundsExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = -1; i < 5; i++) {
+            try {
+                codePoint = str.codePointCount(i, i + 3);
+                System.out.println("i=" + i + " " + "codePointCount=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("codePointCount(): " + i + " IndexOutOfBounds");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " codePointCount is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " StringIndexOutOfBounds");
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full codePointCount(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointCount=3\nq codePointCount is :3\ni=1 codePointCount=3\nw codePointCount is :3\ni=2 codePointCount=3\ne codePointCount is :3\ni=3 codePointCount=3\nr codePointCount is :3\ni=4 codePointCount=3\nt codePointCount is :3\ncodePointCount(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointCount=3\n  codePointCount is :3\ni=1 codePointCount=3\n@ codePointCount is :3\ni=2 codePointCount=3\n! codePointCount is :3\ni=3 codePointCount=3\n. codePointCount is :3\ncodePointCount(): 4 IndexOutOfBounds\n& codePointCount is :3\ncodePointCount(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointCount=3\na codePointCount is :3\ni=1 codePointCount=3\nb codePointCount is :3\ni=2 codePointCount=3\nc codePointCount is :3\ni=3 codePointCount=3\n1 codePointCount is :3\ncodePointCount(): 4 IndexOutOfBounds\n2 codePointCount is :3\ncodePointCount(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointCount(): 0 IndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\ncodePointCount(): 1 IndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\ncodePointCount(): 2 IndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\ncodePointCount(): 3 IndexOutOfBounds\ncharAt(): 3 StringIndexOutOfBounds\ncodePointCount(): 4 IndexOutOfBounds\ncharAt(): 4 StringIndexOutOfBounds\ncodePointCount(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointCount(): 0 IndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\ncodePointCount(): 1 IndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\ncodePointCount(): 2 IndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\ncodePointCount(): 3 IndexOutOfBounds\ncharAt(): 3 StringIndexOutOfBounds\ncodePointCount(): 4 IndexOutOfBounds\ncharAt(): 4 StringIndexOutOfBounds\ncodePointCount(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointCount=3\nq codePointCount is :3\ni=1 codePointCount=3\nw codePointCount is :3\ni=2 codePointCount=3\ne codePointCount is :3\ni=3 codePointCount=3\nr codePointCount is :3\ni=4 codePointCount=3\nt codePointCount is :3\ncodePointCount(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointCount=3\n  codePointCount is :3\ni=1 codePointCount=3\n@ codePointCount is :3\ni=2 codePointCount=3\n! codePointCount is :3\ni=3 codePointCount=3\n. codePointCount is :3\ncodePointCount(): 4 IndexOutOfBounds\n& codePointCount is :3\ncodePointCount(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 codePointCount=3\na codePointCount is :3\ni=1 codePointCount=3\nb codePointCount is :3\ni=2 codePointCount=3\nc codePointCount is :3\ni=3 codePointCount=3\n1 codePointCount is :3\ncodePointCount(): 4 IndexOutOfBounds\n2 codePointCount is :3\ncodePointCount(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ncodePointCount(): 0 IndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\ncodePointCount(): 1 IndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\ncodePointCount(): 2 IndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\ncodePointCount(): 3 IndexOutOfBounds\ncharAt(): 3 StringIndexOutOfBounds\ncodePointCount(): 4 IndexOutOfBounds\ncharAt(): 4 StringIndexOutOfBounds\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/StringOffsetByCodePointsIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/StringOffsetByCodePointsIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..04a869fb6e07ac32ca4566ad35c6ab111bf45c6b
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/StringOffsetByCodePointsIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringOffsetByCodePointsIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test IndexOutOfBoundsException in String Method: int offsetByCodePoints(int index,
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      int codePointOffset).
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: index range from -1 to instance.length - 4, codePointOffset = index + 3.
+ * -#step3: Test Method offsetByCodePoints(int index, int codePointOffset), Check result is correctly.
+ *          IndexOutOfBoundsException is thrown when beginIndex < 0 or index + codePointOffset  > instance.length.
+ * -#step4: Create Parameters index = beginIndex, Test Method charAt(int index), Check String instance is correctly.
+ *          StringIndexOutOfBoundsException is thrown when index < 0 or index >= instance.length.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringOffsetByCodePointsIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringOffsetByCodePointsIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringOffsetByCodePointsIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringOffsetByCodePointsIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringOffsetByCodePointsIndexOutOfBoundsExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = -1; i < 3; i++) {
+            try {
+                codePoint = str.offsetByCodePoints(i, i + 3);
+                System.out.println("i=" + i + " " + "offsetByCodePoints=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("offsetByCodePoints(): " + i + " IndexOutOfBounds");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " offsetByCodePoints is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " StringIndexOutOfBounds");
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full offsetByCodePoints(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 offsetByCodePoints=3\nq offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\nw offsetByCodePoints is :5\ni=2 offsetByCodePoints=7\ne offsetByCodePoints is :7\noffsetByCodePoints(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 offsetByCodePoints=3\n  offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\n@ offsetByCodePoints is :5\noffsetByCodePoints(): 2 IndexOutOfBounds\n! offsetByCodePoints is :5\noffsetByCodePoints(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 offsetByCodePoints=3\na offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\nb offsetByCodePoints is :5\noffsetByCodePoints(): 2 IndexOutOfBounds\nc offsetByCodePoints is :5\noffsetByCodePoints(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\noffsetByCodePoints(): 0 IndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\noffsetByCodePoints(): 1 IndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\noffsetByCodePoints(): 2 IndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\noffsetByCodePoints(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\noffsetByCodePoints(): 0 IndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\noffsetByCodePoints(): 1 IndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\noffsetByCodePoints(): 2 IndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\noffsetByCodePoints(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 offsetByCodePoints=3\nq offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\nw offsetByCodePoints is :5\ni=2 offsetByCodePoints=7\ne offsetByCodePoints is :7\noffsetByCodePoints(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 offsetByCodePoints=3\n  offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\n@ offsetByCodePoints is :5\noffsetByCodePoints(): 2 IndexOutOfBounds\n! offsetByCodePoints is :5\noffsetByCodePoints(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\ni=0 offsetByCodePoints=3\na offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\nb offsetByCodePoints is :5\noffsetByCodePoints(): 2 IndexOutOfBounds\nc offsetByCodePoints is :5\noffsetByCodePoints(): -1 IndexOutOfBounds\ncharAt(): -1 StringIndexOutOfBounds\noffsetByCodePoints(): 0 IndexOutOfBounds\ncharAt(): 0 StringIndexOutOfBounds\noffsetByCodePoints(): 1 IndexOutOfBounds\ncharAt(): 1 StringIndexOutOfBounds\noffsetByCodePoints(): 2 IndexOutOfBounds\ncharAt(): 2 StringIndexOutOfBounds\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0034-rt-String-GetCharsExceptionsTest/StringGetCharsExceptionsTest.java b/test/testsuite/ouroboros/string_test/RT0034-rt-String-GetCharsExceptionsTest/StringGetCharsExceptionsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..02ca1d1a9cdecd2e5fb31aaf4c3abc081a5fdcbf
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0034-rt-String-GetCharsExceptionsTest/StringGetCharsExceptionsTest.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGetCharsExceptionsTest.java
+ * -@TestCaseName: Test Exception in String Method: void getChars(int srcBegin, int srcEnd, char[] dst,
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      int dstBegin).
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: dst is null, 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin > 0.
+ * -#step3: Test method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin), check NullPointerException is
+ *          thrown, check dst is not replaced.
+ * -#step4: Create Parameters: dst.length > 0, data.element is letter, srcBegin < 0, 0 < srcEnd < instance.length,
+ *          0 < dstBegin < dst.length.
+ * -#step5: Test method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin), check
+ *          StringIndexOutOfBoundsException is thrown, check dst is not replaced.
+ * -#step6: Create Parameters: dst.length > 0, data.element is letter, 0 < srcBegin < srcEnd, srcEnd < instance.length,
+ *          0 < dstBegin < dst.length, dstBegin + srcEnd - srcBegin > dst.length.
+ * -#step7: Test method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin), check
+ *          ArrayIndexOutOfBoundsException is thrown, check dst is not replaced.
+ * -#step8: Create Parameters: dst.length > 0, data.element is letter, srcBegin > srcEnd, 0 < srcEnd < instance.length,
+ *          0 < dstBegin < dst.length.
+ * -#step9: Test method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin), check
+ *          StringIndexOutOfBoundsException is thrown, check dst is not replaced.
+ * -#step10: Create Parameters: dst.length > 0, data.element is letter, 0 < srcBegin < srcEnd, srcEnd < instance.length,
+ *           dstBegin < 0.
+ * -#step11: Test method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin), check
+ *           StringIndexOutOfBoundsException is thrown, check dst is not replaced.
+ * -#step12: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~11.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringGetCharsExceptionsTest.java
+ * -@ExecuteClass: StringGetCharsExceptionsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringGetCharsExceptionsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringGetCharsExceptionsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringGetCharsExceptionsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        char dst1_1[] = null;
+        try {
+            str.getChars(2, 5, dst1_1, 2);
+        } catch (NullPointerException e1) {
+            System.out.println("EXCEPTION 1_1");
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_2");
+        } finally {
+            try {
+                System.out.println(dst1_1);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 1_3");
+            }
+        }
+
+        char dst1_2[] = {'A', 'B', 'C', 'D', 'E'};
+        try {
+            str.getChars(-1, 5, dst1_2, 2);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 2_1");
+        } finally {
+            try {
+                System.out.println(dst1_2);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 2_2");
+            }
+        }
+
+        char dst1_3[] = {'A', 'B', 'C', 'D', 'E'};
+        try {
+            str.getChars(2, 6, dst1_3, 2);
+        } catch (ArrayIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 3_1");
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 3_2");
+        } finally {
+            try {
+                System.out.println(dst1_3);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 3_3");
+            }
+        }
+
+        char dst1_4[] = {'A', 'B', 'C', 'D', 'E'};
+        try {
+            str.getChars(4, 3, dst1_4, 2);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 4_1");
+        } finally {
+            try {
+                System.out.println(dst1_4);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 4_2");
+            }
+        }
+
+        char dst1_5[] = {'A', 'B', 'C', 'D', 'E'};
+        try {
+            str.getChars(4, 3, dst1_5, -1);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 5_1");
+        } finally {
+            try {
+                System.out.println(dst1_5);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 5_2");
+            }
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full EXCEPTION 1_1\nEXCEPTION 1_3\nEXCEPTION 2_1\nABCDE\nEXCEPTION 3_1\nABCDE\nEXCEPTION 4_1\nABCDE\nEXCEPTION 5_1\nABCDE\nEXCEPTION 1_1\nEXCEPTION 1_3\nEXCEPTION 2_1\nABCDE\nEXCEPTION 3_1\nABCDE\nEXCEPTION 4_1\nABCDE\nEXCEPTION 5_1\nABCDE\nEXCEPTION 1_1\nEXCEPTION 1_3\nEXCEPTION 2_1\nABCDE\nEXCEPTION 3_1\nABCDE\nEXCEPTION 4_1\nABCDE\nEXCEPTION 5_1\nABCDE\nEXCEPTION 1_1\nEXCEPTION 1_3\nEXCEPTION 2_1\nABCDE\nEXCEPTION 3_2\nABCDE\nEXCEPTION 4_1\nABCDE\nEXCEPTION 5_1\nABCDE\nEXCEPTION 1_1\nEXCEPTION 1_3\nEXCEPTION 2_1\nABCDE\nEXCEPTION 3_2\nABCDE\nEXCEPTION 4_1\nABCDE\nEXCEPTION 5_1\nABCDE\nEXCEPTION 1_1\nEXCEPTION 1_3\nEXCEPTION 2_1\nABCDE\nEXCEPTION 3_1\nABCDE\nEXCEPTION 4_1\nABCDE\nEXCEPTION 5_1\nABCDE\nEXCEPTION 1_1\nEXCEPTION 1_3\nEXCEPTION 2_1\nABCDE\nEXCEPTION 3_1\nABCDE\nEXCEPTION 4_1\nABCDE\nEXCEPTION 5_1\nABCDE\nEXCEPTION 1_1\nEXCEPTION 1_3\nEXCEPTION 2_1\nABCDE\nEXCEPTION 3_1\nABCDE\nEXCEPTION 4_1\nABCDE\nEXCEPTION 5_1\nABCDE\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0035-rt-String-GetBytesExceptionTest/StringGetBytesExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0035-rt-String-GetBytesExceptionTest/StringGetBytesExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf58ca3643ace609d9ea0e7179836f7ab38a34dd
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0035-rt-String-GetBytesExceptionTest/StringGetBytesExceptionTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGetBytesExceptionTest.java
+ * -@TestCaseName: Test Exception in String Method: getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: dst is null, 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin > 0.
+ * -#step3: Test method getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin), check NullPointerException is
+ *          thrown, check dst is not replaced.
+ * -#step4: Create Parameters: dst.length > 0, data.element is normal byte, srcBegin < 0, 0 < srcEnd < instance.length,
+ *          0 < dstBegin < dst.length.
+ * -#step5: Test method getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin), check
+ *          StringIndexOutOfBoundsException is thrown, check dst is not replaced.
+ * -#step6: Create Parameters: dst.length > 0, data.element is normal byte, 0 < srcBegin < srcEnd, srcEnd <
+ *          instance.length, 0 < dstBegin < dst.length, dstBegin + srcEnd - srcBegin > dst.length.
+ * -#step7: Test method getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin), check
+ *          ArrayIndexOutOfBoundsException is thrown, check dst is not replaced.
+ * -#step8: Create Parameters: dst.length > 0, data.element is normal byte, srcBegin > srcEnd, 0 < srcEnd
+ *          < instance.length, 0 < dstBegin < dst.length.
+ * -#step9: Test method getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin), check
+ *          StringIndexOutOfBoundsException is thrown, check dst is not replaced.
+ * -#step10: Create Parameters: dst.length > 0, data.element is normal byte, 0 < srcBegin < srcEnd, srcEnd <
+ *           instance.length, dstBegin < 0.
+ * -#step11: Test method getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin), check
+ *           StringIndexOutOfBoundsException is thrown, check dst is not replaced.
+ * -#step12: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~11.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringGetBytesExceptionTest.java
+ * -@ExecuteClass: StringGetBytesExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringGetBytesExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringGetBytesExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringGetBytesExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        byte[] dst1_1 = null;
+        try {
+            str.getBytes(2, 5, dst1_1, 2);
+            String str_new = new String(dst1_1);
+        } catch (NullPointerException e1) {
+            System.out.println("EXCEPTION 1_1");
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_2");
+        }
+
+        byte[] dst1_2 = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        try {
+            str.getBytes(-1, 5, dst1_2, 2);
+            String str_new = new String(dst1_2);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 2_1");
+        }
+
+        // if (srcEnd > length()) ...throw new StringIndexOutOfBoundsException(this, srcEnd);
+        byte[] dst1_3 = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        try {
+            str.getBytes(2, 6, dst1_3, 2);
+            String str_new = new String(dst1_3);
+        } catch (ArrayIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 3_1");
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 3_2");
+        }
+
+        byte[] dst1_4 = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        try {
+            str.getBytes(4, 3, dst1_4, 2);
+            String str_new = new String(dst1_4);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 4_1");
+        }
+
+        byte[] dst1_5 = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        try {
+            str.getBytes(4, 3, dst1_5, -1);
+            String str_new = new String(dst1_5);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 5_1");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full EXCEPTION 1_1\nEXCEPTION 2_1\nEXCEPTION 4_1\nEXCEPTION 5_1\nEXCEPTION 1_1\nEXCEPTION 2_1\nEXCEPTION 4_1\nEXCEPTION 5_1\nEXCEPTION 1_1\nEXCEPTION 2_1\nEXCEPTION 4_1\nEXCEPTION 5_1\nEXCEPTION 1_2\nEXCEPTION 2_1\nEXCEPTION 3_2\nEXCEPTION 4_1\nEXCEPTION 5_1\nEXCEPTION 1_2\nEXCEPTION 2_1\nEXCEPTION 3_2\nEXCEPTION 4_1\nEXCEPTION 5_1\nEXCEPTION 1_1\nEXCEPTION 2_1\nEXCEPTION 4_1\nEXCEPTION 5_1\nEXCEPTION 1_1\nEXCEPTION 2_1\nEXCEPTION 4_1\nEXCEPTION 5_1\nEXCEPTION 1_1\nEXCEPTION 2_1\nEXCEPTION 4_1\nEXCEPTION 5_1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/StringSubstringStringIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/StringSubstringStringIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b4854ce4af62f92031034632ee820dc7b475f3d2
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/StringSubstringStringIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringSubstringStringIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test StringIndexOutOfBoundsException in String Method: String substring(int beginIndex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: beginIndex range from -1 to max (max > instance.length).
+ * -#step3: Test method substring(int beginIndex), Check result is correctly. StringIndexOutOfBoundsException is thrown
+ *          when beginIndex < 0 or beginIndex > instance.length.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringSubstringStringIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringSubstringStringIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringSubstringStringIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringSubstringStringIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringSubstringStringIndexOutOfBoundsExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        for (int i = -1; i < 8; i++) {
+            try {
+                System.out.println("beginIndex= " + i);
+                String dst1_1 = str.substring(i);
+                System.out.println(dst1_1);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("StringIndexOutOfBounds 1_1");
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full beginIndex= -1\nStringIndexOutOfBounds 1_1\nbeginIndex= 0\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 1\nwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 2\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 3\nrtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 4\ntyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 5\nyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 6\nuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 7\niop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= -1\nStringIndexOutOfBounds 1_1\nbeginIndex= 0\n @!.&%\nbeginIndex= 1\n@!.&%\nbeginIndex= 2\n!.&%\nbeginIndex= 3\n.&%\nbeginIndex= 4\n&%\nbeginIndex= 5\n%\nbeginIndex= 6\n\nbeginIndex= 7\nStringIndexOutOfBounds 1_1\nbeginIndex= -1\nStringIndexOutOfBounds 1_1\nbeginIndex= 0\nabc123\nbeginIndex= 1\nbc123\nbeginIndex= 2\nc123\nbeginIndex= 3\n123\nbeginIndex= 4\n23\nbeginIndex= 5\n3\nbeginIndex= 6\n\nbeginIndex= 7\nStringIndexOutOfBounds 1_1\nbeginIndex= -1\nStringIndexOutOfBounds 1_1\nbeginIndex= 0\n\nbeginIndex= 1\nStringIndexOutOfBounds 1_1\nbeginIndex= 2\nStringIndexOutOfBounds 1_1\nbeginIndex= 3\nStringIndexOutOfBounds 1_1\nbeginIndex= 4\nStringIndexOutOfBounds 1_1\nbeginIndex= 5\nStringIndexOutOfBounds 1_1\nbeginIndex= 6\nStringIndexOutOfBounds 1_1\nbeginIndex= 7\nStringIndexOutOfBounds 1_1\nbeginIndex= -1\nStringIndexOutOfBounds 1_1\nbeginIndex= 0\n\nbeginIndex= 1\nStringIndexOutOfBounds 1_1\nbeginIndex= 2\nStringIndexOutOfBounds 1_1\nbeginIndex= 3\nStringIndexOutOfBounds 1_1\nbeginIndex= 4\nStringIndexOutOfBounds 1_1\nbeginIndex= 5\nStringIndexOutOfBounds 1_1\nbeginIndex= 6\nStringIndexOutOfBounds 1_1\nbeginIndex= 7\nStringIndexOutOfBounds 1_1\nbeginIndex= -1\nStringIndexOutOfBounds 1_1\nbeginIndex= 0\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 1\nwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 2\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 3\nrtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 4\ntyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 5\nyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 6\nuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= 7\niop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nbeginIndex= -1\nStringIndexOutOfBounds 1_1\nbeginIndex= 0\n @!.&%\nbeginIndex= 1\n@!.&%\nbeginIndex= 2\n!.&%\nbeginIndex= 3\n.&%\nbeginIndex= 4\n&%\nbeginIndex= 5\n%\nbeginIndex= 6\n\nbeginIndex= 7\nStringIndexOutOfBounds 1_1\nbeginIndex= -1\nStringIndexOutOfBounds 1_1\nbeginIndex= 0\nabc123\nbeginIndex= 1\nbc123\nbeginIndex= 2\nc123\nbeginIndex= 3\n123\nbeginIndex= 4\n23\nbeginIndex= 5\n3\nbeginIndex= 6\n\nbeginIndex= 7\nStringIndexOutOfBounds 1_1\nbeginIndex= -1\nStringIndexOutOfBounds 1_1\nbeginIndex= 0\n\nbeginIndex= 1\nStringIndexOutOfBounds 1_1\nbeginIndex= 2\nStringIndexOutOfBounds 1_1\nbeginIndex= 3\nStringIndexOutOfBounds 1_1\nbeginIndex= 4\nStringIndexOutOfBounds 1_1\nbeginIndex= 5\nStringIndexOutOfBounds 1_1\nbeginIndex= 6\nStringIndexOutOfBounds 1_1\nbeginIndex= 7\nStringIndexOutOfBounds 1_1\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/StringSubstringIntIntExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/StringSubstringIntIntExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f3a6e6616aa1c9999b0fe910993d2dbbd6309ddd
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/StringSubstringIntIntExceptionTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringSubstringIntIntExceptionTest.java
+ * -@TestCaseName: Test StringIndexOutOfBoundsException in String Method: String substring(int beginIndex,
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      int endIndex).
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: beginIndex > 0, beginIndex < endIndex < instance.length.
+ * -#step3: Test Method substring(int beginIndex,int endIndex), check the result correctly, throws
+ *          StringIndexOutOfBoundsException when beginIndex < 0 or beginIndex > instance.length or
+ *          endIndex > instance.length.
+ * -#step4: Create Parameters: beginIndex < 0, 0 < endIndex < instance.length.
+ * -#step5: Test Method substring(int beginIndex,int endIndex), check StringIndexOutOfBoundsException is thrown.
+ * -#step6: Create Parameters: beginIndex > endIndex > 0.
+ * -#step7: Test Method substring(int beginIndex,int endIndex), check StringIndexOutOfBoundsException is thrown.
+ * -#step6: Create Parameters: beginIndex > 0, instance.length < endIndex.
+ * -#step7: Test Method substring(int beginIndex,int endIndex), check StringIndexOutOfBoundsException is thrown.
+ * -#step8: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~7.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringSubstringIntIntExceptionTest.java
+ * -@ExecuteClass: StringSubstringIntIntExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringSubstringIntIntExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringSubstringIntIntExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringSubstringIntIntExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%()*");
+        String str1_3 = new String("abc123abc");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZ" +
+                "XCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        try {
+            System.out.println(str.substring(2, 6));
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_1");
+        }
+
+        try {
+            System.out.println(str.substring(-1, 6));
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_2");
+        }
+
+        try {
+            System.out.println(str.substring(2, 1));
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_3");
+        }
+
+        try {
+            System.out.println(str.substring(2, 9));
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_4");
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full erty\nEXCEPTION 1_2\nEXCEPTION 1_3\nertyuio\n!.&%\nEXCEPTION 1_2\nEXCEPTION 1_3\n!.&%()*\nc123\nEXCEPTION 1_2\nEXCEPTION 1_3\nc123abc\nerty\nEXCEPTION 1_2\nEXCEPTION 1_3\nertyuio\n!.&%\nEXCEPTION 1_2\nEXCEPTION 1_3\nEXCEPTION 1_4\nc123\nEXCEPTION 1_2\nEXCEPTION 1_3\nc123ABC\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/StringSubSequenceIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/StringSubSequenceIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..33f6a108a4b80493a473cc1538b1a63863330340
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/StringSubSequenceIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringSubSequenceIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test IndexOutOfBoundsException in String Method: CharSequence subSequence(int beginIndex,
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      int endIndex).
+ * -@Brief:
+ * -#step1: Create String instance by new String(String str1) and not new.
+ * -#step2: Create Parameters: beginIndex < 0, 0 < endIndex < instance.length.
+ * -#step3: Test Method subSequence(int beginIndex, int endIndex), check IndexOutOfBoundsException is thrown
+ *          StringIndexOutOfBoundsException.
+ * -#step4: Create Parameters: 0 < beginIndex < instance.length, endIndex < 0.
+ * -#step5: Test Method subSequence(int beginIndex,int endIndex), check IndexOutOfBoundsException is thrown.
+ * -#step6: Create Parameters: beginIndex > endIndex > 0.
+ * -#step7: Test Method subSequence(int beginIndex,int endIndex), check IndexOutOfBoundsException is thrown.
+ * -#step6: Create Parameters: beginIndex > 0, instance.length < endIndex.
+ * -#step7: Test Method subSequence(int beginIndex,int endIndex), check IndexOutOfBoundsException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringSubSequenceIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringSubSequenceIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringSubSequenceIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = StringSubSequenceIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringSubSequenceIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //IndexOutOfBoundsException - if the index argument is negative or not less than the length of this string.
+        String str1_1 = new String("abc123");
+
+        try {
+            str1_1.subSequence(-2, 6);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            str1_1.subSequence(2, -6);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            str1_1.subSequence(2, 1);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            str1_1.subSequence(2, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/StringReplaceNullPointerExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/StringReplaceNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e845fc0feaaf508a8c9d6d910a1b1a18bf9345c5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/StringReplaceNullPointerExceptionTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringReplaceNullPointerExceptionTest.java
+ * -@TestCaseName: Test NullPointerException in String Method:String replace(CharSequence target,
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      CharSequence replacement).
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: target = null, replacement is a special symbols.
+ * -#step3: Test method replace(CharSequence target, CharSequence replacement), NullPointerException is thrown.
+ * -#step4: Create Parameters: target is a letter, replacement = null.
+ * -#step5: Test method replace(CharSequence target, CharSequence replacement), NullPointerException is thrown.
+ * -#step6: Create Parameters: target is a letter, replacement is a letter.
+ * -#step7: Test method replace(CharSequence target, CharSequence replacement), the result is replaced correctly.
+ * -#step8: Change instance as One or more kinds of letters, numbers, special symbols/""/null to repeat step2~7.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringReplaceNullPointerExceptionTest.java
+ * -@ExecuteClass: StringReplaceNullPointerExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringReplaceNullPointerExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringReplaceNullPointerExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringReplaceNullPointerExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        String str2_5 = null;
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        test(str2_5);
+    }
+
+    private static void test(String str) {
+        String target = null;
+        try {
+            System.out.println(str.replace(target, "@"));
+        } catch (NullPointerException e1) {
+            System.out.println("EXCEPTION 1_1");
+        }
+
+        String replacement = null;
+        try {
+            System.out.println(str.replace("a", replacement));
+        } catch (NullPointerException e2) {
+            System.out.println("EXCEPTION 1_2");
+        }
+
+        try {
+            System.out.println(str.replace("a", "@"));
+        } catch (NullPointerException e2) {
+            System.out.println("EXCEPTION 1_3");
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full EXCEPTION 1_1\nEXCEPTION 1_2\nqwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nEXCEPTION 1_1\nEXCEPTION 1_2\n @!.&%\nEXCEPTION 1_1\nEXCEPTION 1_2\n@bc123@bc\nEXCEPTION 1_1\nEXCEPTION 1_2\n\nEXCEPTION 1_1\nEXCEPTION 1_2\n\nEXCEPTION 1_1\nEXCEPTION 1_2\nqwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nEXCEPTION 1_1\nEXCEPTION 1_2\n @!.&%\nEXCEPTION 1_1\nEXCEPTION 1_2\n@bc123ABC\nEXCEPTION 1_1\nEXCEPTION 1_2\n\nEXCEPTION 1_1\nEXCEPTION 1_2\nEXCEPTION 1_3\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/StringValueOfAndCopyValueOfExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/StringValueOfAndCopyValueOfExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..080ad350be2a70969fc50782acdf323384531adb
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/StringValueOfAndCopyValueOfExceptionTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfAndCopyValueOfExceptionTest.java
+ * -@TestCaseName: Test Exception in String Static Method: String valueOf(char[] data, int offset, int count)/String
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      copyValueOf(char[] data, int offset, int count).
+ * -@Brief:
+ * -#step1: Create char[] instance initialization by some letters.
+ * -#step2: Create Parameters: offset < 0, 0 < count < instance.length.
+ * -#step3: Test method valueOf(char[] data, int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -#step4: Create Parameters: 0 =< offset < instance.length, count < 0.
+ * -#step5: Test method valueOf(char[] data, int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -#step6: Create Parameters: 0 =< offset < instance.length, count > instance.length.
+ * -#step7: Test method valueOf(char[] data, int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -#step8: Create Parameters: offset < 0, 0 < count < instance.length.
+ * -#step9: Test method copyValueOf(char[] data, int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -#step10: Create Parameters: 0 =< offset < instance.length, count < 0.
+ * -#step11: Test method copyValueOf(char[] data, int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -#step12: Create Parameters: 0 =< offset < instance.length, count > instance.length.
+ * -#step13: Test method copyValueOf(char[] data, int offset, int count), check IndexOutOfBoundsException is thrown.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfAndCopyValueOfExceptionTest.java
+ * -@ExecuteClass: StringValueOfAndCopyValueOfExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfAndCopyValueOfExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            result = StringValueOfAndCopyValueOfExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 93) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringValueOfAndCopyValueOfExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success */
+
+        char[] ch1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        /* IndexOutOfBoundsException - if offset is negative, or count is negative, or offset+count is larger than
+           data.length */
+        try {
+            String.valueOf(ch1_1, -1, 3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.valueOf(ch1_1, 1, -3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.valueOf(ch1_1, 1, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.copyValueOf(ch1_1, -1, 3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.copyValueOf(ch1_1, 1, -3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.copyValueOf(ch1_1, 1, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0041-rt-String-GetClassTest/StringGetClassTest.java b/test/testsuite/ouroboros/string_test/RT0041-rt-String-GetClassTest/StringGetClassTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..849b54d8f46a9613b0873de7fef2a773b115e965
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0041-rt-String-GetClassTest/StringGetClassTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGetClassTest.java
+ * -@TestCaseName: Test Method Class<?> getClass() of String.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method of getClass(), check the result the correctly.
+ * -#step3: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringGetClassTest.java
+ * -@ExecuteClass: StringGetClassTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringGetClassTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringGetClassTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringGetClassTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.getClass());
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full class java.lang.String\nclass java.lang.String\nclass java.lang.String\nclass java.lang.String\nclass java.lang.String\nclass java.lang.String\nclass java.lang.String\nclass java.lang.String\nclass java.lang.String\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/StringEqualsAndEqualsIgnoreCaseAndLengthTest.java b/test/testsuite/ouroboros/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/StringEqualsAndEqualsIgnoreCaseAndLengthTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4125c19f479906dbd44360ab880da9e1c5501429
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/StringEqualsAndEqualsIgnoreCaseAndLengthTest.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringEqualsAndEqualsIgnoreCaseAndLengthTest.java
+ * -@TestCaseName: Test method boolean equals(Object anObject)/boolean equalsIgnoreCase(String anotherString)/
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      int length() of String.
+ * -@Brief:
+ * -#case1
+ * -#step1: Create two same String instance consists of special symbols.
+ * -#step2: Test method equals(Object anObject), check get result true.
+ * -#step3: Test method length() of one String, check get result correctly.
+ * -#case2
+ * -#step1: Create two same String instance consists of letters, numbers ,special symbols.
+ * -#step2: Test method equals(Object anObject), check get result true.
+ * -#step3: Test method length() of one String, check get result correctly.
+ * -#case3
+ * -#step1: Create two different String instance consists of letters, numbers ,special symbols, the diff is Uppercase
+ *          and lowercase letters.
+ * -#step2: Test method equals(Object anObject), check get result false.
+ * -#step3: Test method equalsIgnoreCase(String anotherString), check get result true.
+ * -#case4
+ * -#step1: Create two different String instance, one consists of letters, space, one consists of space.
+ * -#step2: Test method equals(Object anObject), check get result false.
+ * -#step3: Test method length() of one String, check get result correctly.
+ * -#case5
+ * -#step1: Create two different String instance, one consists of letters, one consists of space.
+ * -#step2: Test method equals(Object anObject), check get result false.
+ * -#case6
+ * -#step1: Create two different String instance, one consists of lowercase letters, one consists of Uppercase letters.
+ * -#step2: Test method equals(Object anObject), check get result false.
+ * -#step3: Test method equalsIgnoreCase(String anotherString), check get result true.
+ * -#case7
+ * -#step1: Create two different String instance, one consists of letters, space, one has One more space than another.
+ * -#step2: Test method equals(Object anObject), check get result false.
+ * -#case8
+ * -#step1: Create two different String instance, one is $, one is ￥.
+ * -#step2: Test method equals(Object anObject), check get result false.
+ * -#step3: Test method length() of "$", check get result correctly.
+ * -#step4: Test method length() of "￥", check get result correctly.
+ * -#case9
+ * -#step1: Create two different String instance, one consists of letters and \n, one consists of letters and \t.
+ * -#step2: Test method equals(Object anObject), check get result false.
+ * -#step3: Test method length() of of one String, check get result correctly.
+ * -#case10
+ * -#step1: Create two String instance consists of letters and numbers and special symbols.
+ * -#step2: Test method equals(Object anObject), two instance compare to Corresponding constant, check get result true.
+ * -#case11
+ * -#step1: Create two same long String instance consists of letters and numbers and special symbols.
+ * -#step2: Test method equals(Object anObject), check get result true.
+ * -#step3: Test method length() of of one String, check get result correctly.
+ * -#case12
+ * -#step1: Create two different long String instance consists of letters and numbers and special symbols.
+ * -#step2: Test method equals(Object anObject), check get result false.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringEqualsAndEqualsIgnoreCaseAndLengthTest.java
+ * -@ExecuteClass: StringEqualsAndEqualsIgnoreCaseAndLengthTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringEqualsAndEqualsIgnoreCaseAndLengthTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 3; /* STATUS_Failed */
+
+        result = StringEqualsAndEqualsIgnoreCaseAndLengthTest_1();
+        if (result == 2 && processResult == 87) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringEqualsAndEqualsIgnoreCaseAndLengthTest_1() {
+        test1();
+        test2();
+        test3();
+        test4();
+        test5();
+        test6();
+        test7();
+        test8();
+        test9();
+        test10();
+        test11();
+        test12();
+        return 2;
+    }
+
+    public static int test_equals(String str1, String str2) {
+        if (str1.equals(str2)) {
+            return 1; // right result
+        }
+        return 30; // wrong result
+    }
+
+    public static int test_not_equals(String str1, String str2) {
+        if (!str1.equals(str2)) {
+            return 1; // right result
+        }
+        return 30; // wrong result
+    }
+
+    public static int test_equalsIgnoreCase(String str1, String str2) {
+        if (str1.equalsIgnoreCase(str2)) {
+            return 1; // right result
+        }
+        return 30; // wrong result
+    }
+
+    public static int test_length(String str1, int a) {
+        if (str1.length() == a) {
+            return 1; // right result
+        }
+        return 30; // wrong result
+    }
+
+    private static void test1() {
+        String str1_1 = "{";
+        String str1_2 = "{";
+        if (test_equals(str1_1, str1_2) == 1 && test_length(str1_1, 1) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test2() {
+        String str2_1 = "{12ab";
+        String str2_2 = "{12ab";
+        if (test_equals(str2_1, str2_2) == 1 && test_length(str2_1, 5) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test3() {
+        String str2_1 = "{12ab";
+        String str2_3 = "{12AB";
+
+        if (test_equalsIgnoreCase(str2_1, str2_3) == 1 && test_not_equals(str2_1, str2_3) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test4() {
+        String str3_1 = " abc ";
+        String str3_3 = " ";
+
+        if (test_not_equals(str3_1, str3_3) == 1 && test_length(str3_1, 5) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test5() {
+        String str3_2 = "null";
+        String str3_3 = " ";
+
+        if (test_not_equals(str3_2, str3_3) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test6() {
+        String str3_2 = "null";
+        String str3_4 = "NULL";
+
+        if (test_not_equals(str3_2, str3_4) == 1 && test_equalsIgnoreCase(str3_2, str3_4) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test7() {
+        String str3_1 = " abc ";
+        String str3_5 = " abc";
+
+        if (test_not_equals(str3_1, str3_5) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test8() {
+        String str4_1 = "$";
+        String str4_2 = "￥";
+
+        if (test_not_equals(str4_1, str4_2) == 1 && test_length(str4_1, 1) == 1 && test_length(str4_2, 1) == 1)
+        {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test9() {
+        String str5_1 = "abc\n";
+        String str5_2 = "abc\t";
+
+        if (test_not_equals(str5_1, str5_2) == 1 && test_length(str5_1, 4) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test10() {
+        String str6_1 = "‘OR‘1’=’1";
+        String str6_2 = "<‘script’>alter(“Test,Bom~~~”)<‘/script’>";
+
+        if (test_equals(str6_1, "‘OR‘1’=’1") == 1 && test_equals(str6_2, "<‘script’>alter(“Test,Bom~~~”)" +
+                "<‘/script’>") == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test11() {
+        String str7_1 = "``_+-=asdfadfqwerqwz!@##$%&#*^%^&(&*^()*&^*)^&%^~@#%@#$%^sdfgrw5646843131324fshst{}|[]]:,\\," +
+                "dkd d/.';,;'mmm:\"<>?;',./";
+        String str7_2 = "``_+-=asdfadfqwerqwz!@##$%&#*^%^&(&*^()*&^*)^&%^~@#%@#$%^sdfgrw5646843131324fshst{}|[]]:,\\," +
+                "dkd d/.';,;'mmm:\"<>?;',./";
+
+        if (test_equals(str7_1, str7_2) == 1 && test_length(str7_1, 116) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+
+    private static void test12() {
+        String str7_1 = "``_+-=asdfadfqwerqwz!@##$%&#*^%^&(&*^()*&^*)^&%^~@#%@#$%^sdfgrw5646843131324fshst{}|[]]:,\\," +
+                "dkd d/.';,;'mmm:\"<>?;',./";
+        String str7_3 = "``_+-=asdfadfqwerqwz!@##$%&#*^%^&(&*^()*&^*)^&%^~@#%@#$%^sdfgrw5646843131324fshst{}|[]]:,\\," +
+                "dkd d/.';,;'mmm:\"<>?;',./123";
+
+        if (test_not_equals(str7_1, str7_3) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0043-rt-String-NoParamConstructorTest/StringNoParamConstructorTest.java b/test/testsuite/ouroboros/string_test/RT0043-rt-String-NoParamConstructorTest/StringNoParamConstructorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e719e2255637320a94efde174cb1bcc5662f455
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0043-rt-String-NoParamConstructorTest/StringNoParamConstructorTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringNoParamConstructorTest.java
+ * -@TestCaseName: Test String Constructor: public String().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Test Constructor String().
+ * -#step2: Check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringNoParamConstructorTest.java
+ * -@ExecuteClass: StringNoParamConstructorTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringNoParamConstructorTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringNoParamConstructorTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringNoParamConstructorTest_1() {
+        String str1 = new String();
+        System.out.println(str1);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full \n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0044-rt-String-ConsStringTest/StringConsStringTest.java b/test/testsuite/ouroboros/string_test/RT0044-rt-String-ConsStringTest/StringConsStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b2f171c52f15ea6a5488c0fe82e754a77953999
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0044-rt-String-ConsStringTest/StringConsStringTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsStringTest.java
+ * -@TestCaseName: Test String constructor: String(String original).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: original as One or more kinds of letters, numbers, special symbols.
+ * -#step2: Test constructor String(String original).
+ * -#step3: Check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsStringTest.java
+ * -@ExecuteClass: StringConsStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsStringTest_1() {
+        String str1_1 = new String("abc123");
+        String str1 = new String(str1_1);
+        System.out.println(str1);
+
+        String str1_2 = new String(" @!.&%");
+        String str2 = new String(str1_2);
+        System.out.println(str2);
+
+        String str1_3 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str3 = new String(str1_3);
+        System.out.println(str3);
+
+        String str1_4 = new String("");
+        String str4 = new String(str1_4);
+        System.out.println(str4);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123\n @!.&%\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0045-rt-String-ConsCharTest/StringConsCharTest.java b/test/testsuite/ouroboros/string_test/RT0045-rt-String-ConsCharTest/StringConsCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ef5c55f9739404fc9c023c4363d1c621491d221
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0045-rt-String-ConsCharTest/StringConsCharTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsCharTest.java
+ * -@TestCaseName: Test String constructor: String(char[] value).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: value.length > 0, value.element is letter and number.
+ * -#step2: Test constructor String(char[] value).
+ * -#step3: Check the return String is correctly.
+ * -#step4: Create Parameters: value.length = 0.
+ * -#step5: Test constructor String(char[] value).
+ * -#step6: Check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsCharTest.java
+ * -@ExecuteClass: StringConsCharTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsCharTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsCharTest_1() {
+        char[] value1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        String str1 = new String(value1_1);
+        System.out.println(str1);
+
+        char[] value1_2 = {};
+        String str2 = new String(value1_2);
+        System.out.println(str2);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123\n\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0046-rt-String-ConsCharIntIntTest/StringConsCharIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0046-rt-String-ConsCharIntIntTest/StringConsCharIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..37dbfeaa0da1252ca52d7e212dccc427747db897
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0046-rt-String-ConsCharIntIntTest/StringConsCharIntIntTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsCharIntIntTest.java
+ * -@TestCaseName: Test String constructor: String(char[] value, int offset, int count).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: value.length > 0, value.element is letter and number.
+ * -#step2: Create Parameters: offset = 0, 0 < count < value.length.
+ * -#step3: Test Constructor String(char[] value, int offset, int count), check the return String is correctly.
+ * -#step4: Create Parameters: offset = 0, count = 0.
+ * -#step5: Test Constructor String(char[] value, int offset, int count), check the return String is correctly.
+ * -#step6: Create Parameters: offset = 0, count = value.length.
+ * -#step7: Test Constructor String(char[] value, int offset, int count), check the return String is correctly.
+ * -#step8: Create Parameters: offset = value.length -1, count = 1.
+ * -#step9: Test Constructor String(char[] value, int offset, int count), check the return String is correctly.
+ * -#step10: Create Parameters: offset = value.length -1, count = 0.
+ * -#step11: Test Constructor String(char[] value, int offset, int count), check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsCharIntIntTest.java
+ * -@ExecuteClass: StringConsCharIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsCharIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsCharIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsCharIntIntTest_1() {
+        char[] value1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        String str1 = new String(value1_1, 0, 3);
+        String str1_1 = new String(value1_1, 0, 0);
+        String str1_2 = new String(value1_1, 0, 6);
+        String str1_3 = new String(value1_1, 5, 1);
+        String str1_4 = new String(value1_1, 5, 0);
+        System.out.println(str1);
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        System.out.println(str1_4);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc\n\nabc123\n3\n\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0047-rt-String-ConsIntsIntIntTest/StringConsIntsIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0047-rt-String-ConsIntsIntIntTest/StringConsIntsIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd40cc936560ca708f1638ceb1f5328b6fa3a750
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0047-rt-String-ConsIntsIntIntTest/StringConsIntsIntIntTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsIntsIntIntTest.java
+ * -@TestCaseName: Test String constructor: String(int[] codePoints, int offset, int count).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: codePoints.length > 0, value.element is Decimal number.
+ * -#step2: Create Parameters: offset = 0, count = codePoints.length.
+ * -#step3: Test method String(int[] codePoints, int offset, int count), check the return String is correctly.
+ * -#step4: Create Parameters: offset = codePoints.length - 1, count = 1.
+ * -#step5: Test method String(int[] codePoints, int offset, int count), check the return String is correctly.
+ * -#step6: Create Parameters: offset = codePoints.length - 1, count = 0.
+ * -#step7: Test method String(int[] codePoints, int offset, int count), check the return String is correctly.
+ * -#step8: Create Parameters: codePoints.length > 0, value.element is Hexadecimal number.
+ * -#step9: Create Parameters: offset = 0, count = codePoints.length.
+ * -#step10: Test method String(int[] codePoints, int offset, int count), check the return String is correctly.
+ * -#step11: Create Parameters: offset = codePoints.length - 1, count = 1.
+ * -#step12: Test method String(int[] codePoints, int offset, int count), check the return String is correctly.
+ * -#step13: Create Parameters: offset = codePoints.length - 1, count = 0.
+ * -#step14: Test method String(int[] codePoints, int offset, int count), check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsIntsIntIntTest.java
+ * -@ExecuteClass: StringConsIntsIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsIntsIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsIntsIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsIntsIntIntTest_1() {
+        int[] charIntArray1_1 = new int[]{97, 98, 99, 49, 50, 51};
+        String str1_1 = new String(charIntArray1_1, 0, charIntArray1_1.length);
+        String str1_2 = new String(charIntArray1_1, charIntArray1_1.length - 1, 1);
+        String str1_3 = new String(charIntArray1_1, charIntArray1_1.length - 1, 0);
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+
+        int[] charIntArray2_1 = new int[]{0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        String str2_1 = new String(charIntArray2_1, 0, charIntArray2_1.length);
+        String str2_2 = new String(charIntArray2_1, charIntArray2_1.length - 1, 1);
+        String str2_3 = new String(charIntArray2_1, charIntArray2_1.length - 1, 0);
+        System.out.println(str2_1);
+        System.out.println(str2_2);
+        System.out.println(str2_3);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123\n3\n\nabc123\n3\n\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0048-rt-String-ConsBytesIntTest/StringConsBytesIntTest.java b/test/testsuite/ouroboros/string_test/RT0048-rt-String-ConsBytesIntTest/StringConsBytesIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a876d9415152fbc6b635f8474acc2aaabc077297
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0048-rt-String-ConsBytesIntTest/StringConsBytesIntTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsBytesIntTest.java
+ * -@TestCaseName: Test String constructor: String(byte[] ascii, int hibyte).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: ascii.length > 0, ascii.element is ascii number.
+ * -#step2: Create Parameters: hibyte = 0, Test constructor String(byte[] ascii, int hibyte).
+ * -#step3: Test constructor String(byte[] ascii).
+ * -#step4: Check the two constructor result is same or not.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsBytesIntTest.java
+ * -@ExecuteClass: StringConsBytesIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsBytesIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsBytesIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsBytesIntTest_1() {
+        byte[] ascii1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1 = new String(ascii1_1, 0);
+        String str0 = new String(ascii1_1);
+        System.out.println(str0);
+        System.out.println(str1);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123\nabc123\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/StringConsBytesIntIntStringTest.java b/test/testsuite/ouroboros/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/StringConsBytesIntIntStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b79b7d3b88dcd57c0328e33a81e978b9c8f5a518
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/StringConsBytesIntIntStringTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsBytesIntIntStringTest.java
+ * -@TestCaseName: Test String constructor: String(byte[] bytes, int offset, int length, String charsetName).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: bytes.length > 0, bytes.element is byte number.
+ * -#step2: Create Parameters: offset = 0, 0 < length < bytes.length, charsetName is Charset name.
+ * -#step3: Test String(byte[] bytes, int offset, int length, String charsetName), Check the return String is correctly.
+ * -#step4: Create Parameters: offset = 0, length = bytes.length, charsetName is Charset name.
+ * -#step5: Test String(byte[] bytes, int offset, int length, String charsetName), Check the return String is correctly.
+ * -#step6: Create Parameters: offset = 0, length = 0, charsetName is Charset name.
+ * -#step7: Test String(byte[] bytes, int offset, int length, String charsetName), Check the return String is correctly.
+ * -#step8: Create Parameters: offset = bytes.length - 1, length = 1, charsetName is Charset name.
+ * -#step9: Test String(byte[] bytes, int offset, int length, String charsetName), Check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsBytesIntIntStringTest.java
+ * -@ExecuteClass: StringConsBytesIntIntStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+
+
+public class StringConsBytesIntIntStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsBytesIntIntStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsBytesIntIntStringTest_1() throws UnsupportedEncodingException {
+        byte[] str1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1_1 = new String(str1, 0, 3, "ASCII");
+        String str1_2 = new String(str1, 0, 6, "ASCII");
+        String str1_3 = new String(str1, 0, 0, "ASCII");
+        String str1_4 = new String(str1, 5, 1, "ASCII");
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        System.out.println(str1_4);
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc\nabc123\n\n3\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/StringCosBytesIntIntCharsetTest.java b/test/testsuite/ouroboros/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/StringCosBytesIntIntCharsetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e996a859ebb7977d3c1abaaef1545b0123c60ff
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/StringCosBytesIntIntCharsetTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCosBytesIntIntCharsetTest.java
+ * -@TestCaseName: String constructor: String(byte[] bytes, int offset, int length, Charset charset).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: bytes.length > 0, bytes.element is byte number.
+ * -#step2: Create Parameters: 0 =< offset < bytes.length, 0 =< length < bytes.length, charset like ASCII.charset.
+ * -#step3: Test String(byte[] bytes, int offset, int length, Charset charset), check the return String is correctly.
+ * -#step4: Create Parameters: offset = 0, length = bytes.length, charset like ASCII.charset.
+ * -#step5: Test String(byte[] bytes, int offset, int length, Charset charset), Check the return String is correctly.
+ * -#step6: Create Parameters: offset = 0, length = 0, charset like ASCII.charset.
+ * -#step7: Test String(byte[] bytes, int offset, int length, Charset charset), Check the return String is correctly.
+ * -#step8: Create Parameters: offset = bytes.length - 1, length = 1, charset like ASCII.charset.
+ * -#step9: Test String(byte[] bytes, int offset, int length, Charset charset), Check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCosBytesIntIntCharsetTest.java
+ * -@ExecuteClass: StringCosBytesIntIntCharsetTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+public class StringCosBytesIntIntCharsetTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCosBytesIntIntCharsetTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCosBytesIntIntCharsetTest_1() throws UnsupportedEncodingException {
+        byte[] str1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1_1 = new String(str1, 3, 3, Charset.forName("ASCII"));
+        String str1_2 = new String(str1, 0, 6, Charset.forName("ASCII"));
+        String str1_3 = new String(str1, 0, 0, Charset.forName("ASCII"));
+        String str1_4 = new String(str1, 5, 1, Charset.forName("ASCII"));
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        System.out.println(str1_4);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 123\nabc123\n\n3\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0051-rt-String-ConsBytesStringTest/StringConsBytesStringTest.java b/test/testsuite/ouroboros/string_test/RT0051-rt-String-ConsBytesStringTest/StringConsBytesStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5bb35a3b1674f8c2033aee97639e32b4387c065b
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0051-rt-String-ConsBytesStringTest/StringConsBytesStringTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsBytesStringTest.java
+ * -@TestCaseName: Test String constructor: String(byte[] bytes, String charsetName).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: bytes.length > 0, bytes.element is byte number, charsetName is a Charset name.
+ * -#step2: Test constructor String(byte[] bytes, String charsetName).
+ * -#step3: Check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsBytesStringTest.java
+ * -@ExecuteClass: StringConsBytesStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+
+
+public class StringConsBytesStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsBytesStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsBytesStringTest_1() throws UnsupportedEncodingException {
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1 = new String(str1_1, "ASCII");
+        System.out.println(str1);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0052-rt-String-ConsBytesCharsetTest/StringConsBytesCharsetTest.java b/test/testsuite/ouroboros/string_test/RT0052-rt-String-ConsBytesCharsetTest/StringConsBytesCharsetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..572bdbcb70c778f177a05d69beca98b0f8ed2027
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0052-rt-String-ConsBytesCharsetTest/StringConsBytesCharsetTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsBytesCharsetTest.java
+ * -@TestCaseName: Test String constructor: String(byte[] bytes, Charset charset).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: bytes.length > 0, bytes.element is byte number. charset like ASCII.charset.
+ * -#step2: Test constructor: String(byte[] bytes, Charset charset).
+ * -#step3: Check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsBytesCharsetTest.java
+ * -@ExecuteClass: StringConsBytesCharsetTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.nio.charset.Charset;
+
+
+public class StringConsBytesCharsetTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsBytesCharsetTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsBytesCharsetTest_1() {
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1 = new String(str1_1, Charset.forName("ASCII"));
+        System.out.println(str1);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0053-rt-String-ConsBytesIntIntTest/StringConsBytesIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0053-rt-String-ConsBytesIntIntTest/StringConsBytesIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..777a5aabe225e656dac33391dbbf4f11b028ede1
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0053-rt-String-ConsBytesIntIntTest/StringConsBytesIntIntTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsBytesIntIntTest.java
+ * -@TestCaseName: String constructor: String(byte[] bytes, int offset, int length).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: bytes.length > 0, bytes.element is byte number
+ * -#step2: Create Parameters: 0 =< offset < bytes.length, 0 =< length < bytes.length - offset.
+ * -#step3: Test constructor String(byte[] bytes, int offset, int length), check the return String is correctly.
+ * -#step4: Create Parameters: offset = 0, length = bytes.length.
+ * -#step5: Test constructor String(byte[] bytes, int offset, int length), check the return String is correctly.
+ * -#step6: Create Parameters: offset = 0, length = 0.
+ * -#step7: Test constructor String(byte[] bytes, int offset, int length), check the return String is correctly.
+ * -#step8: Create Parameters: offset = bytes.length - 1, length = 1.
+ * -#step9: Test constructor String(byte[] bytes, int offset, int length), check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsBytesIntIntTest.java
+ * -@ExecuteClass: StringConsBytesIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsBytesIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsBytesIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsBytesIntIntTest_1() {
+        byte[] str1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1_1 = new String(str1, 3, 3);
+        String str1_2 = new String(str1, 0, 6);
+        String str1_3 = new String(str1, 0, 0);
+        String str1_4 = new String(str1, 5, 1);
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        System.out.println(str1_4);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 123\nabc123\n\n3\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0054-rt-String-ConsBytesTest/StringConsBytesTest.java b/test/testsuite/ouroboros/string_test/RT0054-rt-String-ConsBytesTest/StringConsBytesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9efa16abdb03a521ae9fdc21bc22cfdf6c8d9d69
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0054-rt-String-ConsBytesTest/StringConsBytesTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsBytesTest.java
+ * -@TestCaseName: Test String constructor: String(byte bytes[]).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: bytes.length > 0, bytes.element is Hexadecimal number.
+ * -#step2: Test constructor String(byte bytes[]).
+ * -#step3: Check the return String is correctly.
+ * -#step4: Create Parameters: bytes.length > 0, bytes.element is Decimal number.
+ * -#step5: Test constructor String(byte bytes[]).
+ * -#step6: Check the return String is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsBytesTest.java
+ * -@ExecuteClass: StringConsBytesTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsBytesTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsBytesTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsBytesTest_1() {
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1 = new String(str1_1);
+        byte[] str1_2 = new byte[]{97, 98, 99, 49, 50, 51};
+        String str1_3 = new String(str1_2);
+
+        System.out.println(str1);
+        System.out.println(str1_3);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123\nabc123\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0055-rt-String-ConsStringBufferTest/StringConsStringBufferTest.java b/test/testsuite/ouroboros/string_test/RT0055-rt-String-ConsStringBufferTest/StringConsStringBufferTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ddb3e79d934097fadde399ad8d296b859867ca33
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0055-rt-String-ConsStringBufferTest/StringConsStringBufferTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsStringBufferTest.java
+ * -@TestCaseName: Test String constructor: String(StringBuffer buffer).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String1 by "String" + "String" + "String".
+ * -#step2: Create String2 by str2_1 + str2_2 + str2_3.
+ * -#step3: Create Parameters: buffer by new StringBuffer(String buffer).append(String str).
+ * -#step4: Test constructor String(StringBuffer buffer).
+ * -#step5: check return result is correctly as same as String1 and String2.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsStringBufferTest.java
+ * -@ExecuteClass: StringConsStringBufferTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsStringBufferTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsStringBufferTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsStringBufferTest_1() {
+        String str1 = "These " + "are " + "abcdefghijklmnopqrstuvwxyz";
+        String str2_1 = "These ";
+        String str2_2 = "are ";
+        String str2_3 = "abcdefghijklmnopqrstuvwxyz";
+        String str2 = str2_1 + str2_2 + str2_3;
+        StringBuffer str_b_1 = new StringBuffer("These ").append("are ").append("abcdefghijklmnopqrstuvwxyz");
+        String str3 = new String(str_b_1);
+        System.out.println(str1);
+        System.out.println(str2);
+        System.out.println(str3);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full These are abcdefghijklmnopqrstuvwxyz\nThese are abcdefghijklmnopqrstuvwxyz\nThese are abcdefghijklmnopqrstuvwxyz\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0056-rt-String-ConsStringBuilderTest/StringConsStringBuilderTest.java b/test/testsuite/ouroboros/string_test/RT0056-rt-String-ConsStringBuilderTest/StringConsStringBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9177300f4fb250bfe8011f74f2b6287c8cb8c5b0
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0056-rt-String-ConsStringBuilderTest/StringConsStringBuilderTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConsStringBuilderTest.java
+ * -@TestCaseName: Test String constructor: String(StringBuilder builder).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String1 by "String" + "String" + "String".
+ * -#step2: Create String2 by str2_1 + str2_2 + str2_3.
+ * -#step3: Create Parameters: builder by constructor new StringBuilder(String builder).
+ * -#step4: Test constructor String(StringBuilder builder).
+ * -#step5: check return result is correctly as same as String1 and String2.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConsStringBuilderTest.java
+ * -@ExecuteClass: StringConsStringBuilderTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConsStringBuilderTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConsStringBuilderTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConsStringBuilderTest_1() {
+        String str1 = "These " + "are " + "abcdefghijklmnopqrstuvwxyz";
+        String str2_1 = "These ";
+        String str2_2 = "are ";
+        String str2_3 = "abcdefghijklmnopqrstuvwxyz";
+        String str2 = str2_1 + str2_2 + str2_3;
+        StringBuilder str_b_1 = new StringBuilder("These ").append("are ").append("abcdefghijklmnopqrstuvwxyz");
+        String str3 = new String(str_b_1);
+        System.out.println(str1);
+        System.out.println(str2);
+        System.out.println(str3);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full These are abcdefghijklmnopqrstuvwxyz\nThese are abcdefghijklmnopqrstuvwxyz\nThese are abcdefghijklmnopqrstuvwxyz\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0057-rt-String-LengthTest/StringLengthTest.java b/test/testsuite/ouroboros/string_test/RT0057-rt-String-LengthTest/StringLengthTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1890dc0989f3083301e31148bbb8d3bc1dcc308f
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0057-rt-String-LengthTest/StringLengthTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringLengthTest.java
+ * -@TestCaseName: Test String Method: int length().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method length(), check the return length is correctly.
+ * -#step3: judge String stance is null/empty/"" or not.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringLengthTest.java
+ * -@ExecuteClass: StringLengthTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringLengthTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringLengthTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringLengthTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        int strLength = str1_1.length();
+        System.out.println(strLength);
+        test(str1_1);
+
+        System.out.println(str1_2.length());
+        test(str1_2);
+
+        System.out.println(str1_3.length());
+        test(str1_3);
+
+        System.out.println(str1_4.length());
+        test(str1_4);
+
+        System.out.println(str1_5.length());
+        test(str1_5);
+
+        System.out.println(str2_1.length());
+        test(str2_1);
+
+        System.out.println(str2_2.length());
+        test(str2_2);
+
+        System.out.println(str2_3.length());
+        test(str2_3);
+
+        System.out.println(str2_4.length());
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        if (str == null) {
+            System.out.println(str + " is:null");
+        }
+        if (str.isEmpty()) {
+            System.out.println(str + " is:isEmpty");
+        }
+        if (str.equals("")) {
+            System.out.println(str + " is:\"\"");
+        }
+        System.out.println("*****");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 99\n*****\n6\n*****\n6\n*****\n0\n is:isEmpty\n is:""\n*****\n0\n is:isEmpty\n is:""\n*****\n99\n*****\n6\n*****\n6\n*****\n0\n is:isEmpty\n is:""\n*****\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0058-rt-String-IsEmptyTest/StringIsEmptyTest.java b/test/testsuite/ouroboros/string_test/RT0058-rt-String-IsEmptyTest/StringIsEmptyTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..29968de96b4d4c273f977daff10fb33cf5bc3e60
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0058-rt-String-IsEmptyTest/StringIsEmptyTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringIsEmptyTest.java
+ * -@TestCaseName: Test String Method: boolean isEmpty().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method isEmpty(), check the return value is correctly.
+ * -#step3: judge String stance is null/empty/"" or not.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringIsEmptyTest.java
+ * -@ExecuteClass: StringIsEmptyTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringIsEmptyTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringIsEmptyTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringIsEmptyTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        System.out.println(str1_1.isEmpty());
+        test(str1_1);
+
+        System.out.println(str1_2.isEmpty());
+        test(str1_2);
+
+        System.out.println(str1_3.isEmpty());
+        test(str1_3);
+
+        System.out.println(str1_4.isEmpty());
+        test(str1_4);
+
+        System.out.println(str1_5.isEmpty());
+        test(str1_5);
+
+        System.out.println(str2_1.isEmpty());
+        test(str2_1);
+
+        System.out.println(str2_2.isEmpty());
+        test(str2_2);
+
+        System.out.println(str2_3.isEmpty());
+        test(str2_3);
+
+        System.out.println(str2_4.isEmpty());
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        if (str == null) {
+            System.out.println(str + " is:null");
+        }
+        if (str.isEmpty()) {
+            System.out.println(str + " is:isEmpty");
+        }
+        if (str.equals("")) {
+            System.out.println(str + " is:\"\"");
+        }
+        System.out.println("*****");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full false\n*****\nfalse\n*****\nfalse\n*****\ntrue\n is:isEmpty\n is:""\n*****\ntrue\n is:isEmpty\n is:""\n*****\nfalse\n*****\nfalse\n*****\nfalse\n*****\ntrue\n is:isEmpty\n is:""\n*****\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0059-rt-String-CharAtTest/StringCharAtTest.java b/test/testsuite/ouroboros/string_test/RT0059-rt-String-CharAtTest/StringCharAtTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f05dce8ff7b8503199ac02f8a626635716c9fbf
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0059-rt-String-CharAtTest/StringCharAtTest.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCharAtTest.java
+ * -@TestCaseName: String Method: char charAt(int index).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: instance.length > index >= 0, index cover boundary value.
+ * -#step3: Test method charAt(int index), check the return length is correctly.
+ * -#step4: judge String stance is null/empty/"" or not.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCharAtTest.java
+ * -@ExecuteClass: StringCharAtTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCharAtTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCharAtTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCharAtTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test1(str1_1);
+        test(str1_1);
+
+        test1(str1_2);
+        test(str1_2);
+
+        test1(str1_3);
+        test(str1_3);
+
+        test(str1_4);
+        test(str1_5);
+
+        test1(str2_1);
+        test(str2_1);
+
+        test1(str2_2);
+        test(str2_2);
+
+        test1(str2_3);
+        test(str2_3);
+
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        if (str == null) {
+            System.out.println(str + " is:null");
+        }
+        if (str.isEmpty()) {
+            System.out.println(str + " is:isEmpty");
+        }
+        if (str.equals("")) {
+            System.out.println(str + " is:\"\"");
+        }
+        System.out.println("*****");
+    }
+
+    private static void test1(String str) {
+        char ch = str.charAt(0);
+        System.out.println(ch);
+        System.out.println(str.charAt(str.length() - 1));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full q\n6\n*****\n \n%\n*****\na\n3\n*****\n is:isEmpty\n is:""\n*****\n is:isEmpty\n is:""\n*****\nq\n6\n*****\n \n%\n*****\na\n3\n*****\n is:isEmpty\n is:""\n*****\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0060-rt-String-CodePointAtTest/StringCodePointAtTest.java b/test/testsuite/ouroboros/string_test/RT0060-rt-String-CodePointAtTest/StringCodePointAtTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..17fe194ad8d67e90e79811d9d53a341a7d0650f3
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0060-rt-String-CodePointAtTest/StringCodePointAtTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCodePointAtTest.java
+ * -@TestCaseName: Test String Method: int codePointAt(int index).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: index range from 0 to instance.length - 1.
+ * -#step3: Test method codePointAt(int index), check the return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCodePointAtTest.java
+ * -@ExecuteClass: StringCodePointAtTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCodePointAtTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCodePointAtTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCodePointAtTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = str.codePointAt(i);
+                System.out.println("i=" + i + " " + "codePointAt=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointAt(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full i=0 codePointAt=113\nq Unicode is:113\ni=1 codePointAt=119\nw Unicode is:119\ni=2 codePointAt=101\ne Unicode is:101\ni=3 codePointAt=114\nr Unicode is:114\ni=4 codePointAt=116\nt Unicode is:116\ni=5 codePointAt=121\ny Unicode is:121\ni=0 codePointAt=32\n  Unicode is:32\ni=1 codePointAt=64\n@ Unicode is:64\ni=2 codePointAt=33\n! Unicode is:33\ni=3 codePointAt=46\n. Unicode is:46\ni=4 codePointAt=38\n& Unicode is:38\ni=5 codePointAt=37\n% Unicode is:37\ni=0 codePointAt=97\na Unicode is:97\ni=1 codePointAt=98\nb Unicode is:98\ni=2 codePointAt=99\nc Unicode is:99\ni=3 codePointAt=49\n1 Unicode is:49\ni=4 codePointAt=50\n2 Unicode is:50\ni=5 codePointAt=51\n3 Unicode is:51\ni=0 codePointAt=113\nq Unicode is:113\ni=1 codePointAt=119\nw Unicode is:119\ni=2 codePointAt=101\ne Unicode is:101\ni=3 codePointAt=114\nr Unicode is:114\ni=4 codePointAt=116\nt Unicode is:116\ni=5 codePointAt=121\ny Unicode is:121\ni=0 codePointAt=32\n  Unicode is:32\ni=1 codePointAt=64\n@ Unicode is:64\ni=2 codePointAt=33\n! Unicode is:33\ni=3 codePointAt=46\n. Unicode is:46\ni=4 codePointAt=38\n& Unicode is:38\ni=5 codePointAt=37\n% Unicode is:37\ni=0 codePointAt=97\na Unicode is:97\ni=1 codePointAt=98\nb Unicode is:98\ni=2 codePointAt=99\nc Unicode is:99\ni=3 codePointAt=49\n1 Unicode is:49\ni=4 codePointAt=50\n2 Unicode is:50\ni=5 codePointAt=51\n3 Unicode is:51\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0061-rt-String-CodePointBeforeTest/StringCodePointBeforeTest.java b/test/testsuite/ouroboros/string_test/RT0061-rt-String-CodePointBeforeTest/StringCodePointBeforeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6bf007fd36d8af403a4e61efb158b79b824d0915
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0061-rt-String-CodePointBeforeTest/StringCodePointBeforeTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCodePointBeforeTest.java
+ * -@TestCaseName: Test String Method: int codePointBefore(int index).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: index range from 0 to instance.length - 1.
+ * -#step3: Test method codePointBefore(int index), check the return result is correctly.
+ * -#step4: check the String instance is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCodePointBeforeTest.java
+ * -@ExecuteClass: StringCodePointBeforeTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCodePointBeforeTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCodePointBeforeTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCodePointBeforeTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = 1; i < 6; i++) {
+            try {
+                codePoint = str.codePointBefore(i);
+                System.out.println("i=" + i + " " + "codePointBefore=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointBefore(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " codePointBefore is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full i=1 codePointBefore=113\nw codePointBefore is:113\ni=2 codePointBefore=119\ne codePointBefore is:119\ni=3 codePointBefore=101\nr codePointBefore is:101\ni=4 codePointBefore=114\nt codePointBefore is:114\ni=5 codePointBefore=116\ny codePointBefore is:116\ni=1 codePointBefore=32\n@ codePointBefore is:32\ni=2 codePointBefore=64\n! codePointBefore is:64\ni=3 codePointBefore=33\n. codePointBefore is:33\ni=4 codePointBefore=46\n& codePointBefore is:46\ni=5 codePointBefore=38\n% codePointBefore is:38\ni=1 codePointBefore=97\nb codePointBefore is:97\ni=2 codePointBefore=98\nc codePointBefore is:98\ni=3 codePointBefore=99\n1 codePointBefore is:99\ni=4 codePointBefore=49\n2 codePointBefore is:49\ni=5 codePointBefore=50\n3 codePointBefore is:50\ni=1 codePointBefore=113\nw codePointBefore is:113\ni=2 codePointBefore=119\ne codePointBefore is:119\ni=3 codePointBefore=101\nr codePointBefore is:101\ni=4 codePointBefore=114\nt codePointBefore is:114\ni=5 codePointBefore=116\ny codePointBefore is:116\ni=1 codePointBefore=32\n@ codePointBefore is:32\ni=2 codePointBefore=64\n! codePointBefore is:64\ni=3 codePointBefore=33\n. codePointBefore is:33\ni=4 codePointBefore=46\n& codePointBefore is:46\ni=5 codePointBefore=38\n% codePointBefore is:38\ni=1 codePointBefore=97\nb codePointBefore is:97\ni=2 codePointBefore=98\nc codePointBefore is:98\ni=3 codePointBefore=99\n1 codePointBefore is:99\ni=4 codePointBefore=49\n2 codePointBefore is:49\ni=5 codePointBefore=50\n3 codePointBefore is:50\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0062-rt-String-CodePointCountTest/StringCodePointCountTest.java b/test/testsuite/ouroboros/string_test/RT0062-rt-String-CodePointCountTest/StringCodePointCountTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a734c2e3819982d9aff388daea0f49afde292f2
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0062-rt-String-CodePointCountTest/StringCodePointCountTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCodePointCountTest.java
+ * -@TestCaseName: Test String Method: int codePointCount(int beginIndex, int endIndex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: beginIndex range from 0 to instance.length - 3, endIndex = beginIndex + 3.
+ * -#step3: Test method codePointCount(int beginIndex, int endIndex), check the return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCodePointCountTest.java
+ * -@ExecuteClass: StringCodePointCountTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCodePointCountTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCodePointCountTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCodePointCountTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = str.codePointCount(i, i + 3);
+                System.out.println("i=" + i + " " + "codePointCount=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("codePointCount(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " codePointCount is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full i=0 codePointCount=3\nq codePointCount is :3\ni=1 codePointCount=3\nw codePointCount is :3\ni=2 codePointCount=3\ne codePointCount is :3\ni=3 codePointCount=3\nr codePointCount is :3\ni=0 codePointCount=3\n  codePointCount is :3\ni=1 codePointCount=3\n@ codePointCount is :3\ni=2 codePointCount=3\n! codePointCount is :3\ni=3 codePointCount=3\n. codePointCount is :3\ni=0 codePointCount=3\na codePointCount is :3\ni=1 codePointCount=3\nb codePointCount is :3\ni=2 codePointCount=3\nc codePointCount is :3\ni=3 codePointCount=3\n1 codePointCount is :3\ni=0 codePointCount=3\nq codePointCount is :3\ni=1 codePointCount=3\nw codePointCount is :3\ni=2 codePointCount=3\ne codePointCount is :3\ni=3 codePointCount=3\nr codePointCount is :3\ni=0 codePointCount=3\n  codePointCount is :3\ni=1 codePointCount=3\n@ codePointCount is :3\ni=2 codePointCount=3\n! codePointCount is :3\ni=3 codePointCount=3\n. codePointCount is :3\ni=0 codePointCount=3\na codePointCount is :3\ni=1 codePointCount=3\nb codePointCount is :3\ni=2 codePointCount=3\nc codePointCount is :3\ni=3 codePointCount=3\n1 codePointCount is :3\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0063-rt-String-OffsetByCodePointsTest/StringOffsetByCodePointsTest.java b/test/testsuite/ouroboros/string_test/RT0063-rt-String-OffsetByCodePointsTest/StringOffsetByCodePointsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d9a7e4216c75c79c311f1165768794ad492936ab
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0063-rt-String-OffsetByCodePointsTest/StringOffsetByCodePointsTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringOffsetByCodePointsTest.java
+ * -@TestCaseName: Test String Method: int offsetByCodePoints(int index, int codePointOffset).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: index range from 0 to instance.length - 5, codePointOffset = index + 3.
+ * -#step3: Test method offsetByCodePoints(int index, int codePointOffset), check the return result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringOffsetByCodePointsTest.java
+ * -@ExecuteClass: StringOffsetByCodePointsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringOffsetByCodePointsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringOffsetByCodePointsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringOffsetByCodePointsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = 0; i < 2; i++) {
+            try {
+                codePoint = str.offsetByCodePoints(i, i + 3);
+                System.out.println("i=" + i + " " + "offsetByCodePoints=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("offsetByCodePoints(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " offsetByCodePoints is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full i=0 offsetByCodePoints=3\nq offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\nw offsetByCodePoints is :5\ni=0 offsetByCodePoints=3\n  offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\n@ offsetByCodePoints is :5\ni=0 offsetByCodePoints=3\na offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\nb offsetByCodePoints is :5\ni=0 offsetByCodePoints=3\nq offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\nw offsetByCodePoints is :5\ni=0 offsetByCodePoints=3\n  offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\n@ offsetByCodePoints is :5\ni=0 offsetByCodePoints=3\na offsetByCodePoints is :3\ni=1 offsetByCodePoints=5\nb offsetByCodePoints is :5\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0064-rt-String-GetCharsTest/StringGetCharsTest.java b/test/testsuite/ouroboros/string_test/RT0064-rt-String-GetCharsTest/StringGetCharsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..374f8c4e07a767acb7ecce6955a59ff11e9c3653
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0064-rt-String-GetCharsTest/StringGetCharsTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGetCharsTest.java
+ * -@TestCaseName: Test String Method: void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: dst.length > 0, dst.element some letters. 0 =< srcBegin < srcEnd,
+ *          srcEnd < instance.length. 0 =< dstBegin < dst.length -1, srcBegin/srcEnd/dstBegin cover boundary value.
+ * -#step3: Test method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin).
+ * -#step4: check the dst is replaced correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringGetCharsTest.java
+ * -@ExecuteClass: StringGetCharsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringGetCharsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringGetCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringGetCharsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        // 0 < srcBegin < srcEnd, srcEnd < instance.length. 0 =< dstBegin < dst.length -1.
+        char[] dst = {'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(2, 5, dst, 2);
+        System.out.println(dst);
+
+        // srcBegin = 0, srcEnd < instance.length. 0 =< dstBegin < dst.length -1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(0, 3, dst, 2);
+        System.out.println(dst);
+
+        // srcBegin = instance.length, srcEnd = instance.length, 0 =< dstBegin < dst.length -1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(str.length(), str.length(), dst, 2);
+        System.out.println(dst);
+
+        // srcBegin = 0, srcEnd = 0, 0 =< dstBegin < dst.length -1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(0, 0, dst, 2);
+        System.out.println(dst);
+
+        // 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(2, 3, dst, 0);
+        System.out.println(dst);
+
+        // 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin = dst.length -1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(2, 3, dst, 5);
+        System.out.println(dst);
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ABertF\nABqweF\nABCDEF\nABCDEF\neBCDEF\nABCDEe\nAB!.&F\nAB @!F\nABCDEF\nABCDEF\n!BCDEF\nABCDE!\nABc12F\nABabcF\nABCDEF\nABCDEF\ncBCDEF\nABCDEc\nABertF\nABqweF\nABCDEF\nABCDEF\neBCDEF\nABCDEe\nAB!.&F\nAB @!F\nABCDEF\nABCDEF\n!BCDEF\nABCDE!\nABc12F\nABabcF\nABCDEF\nABCDEF\ncBCDEF\nABCDEc\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/StringGetBytesIntIntBytesIntTest.java b/test/testsuite/ouroboros/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/StringGetBytesIntIntBytesIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e8714a04a744268c5d677102e269c5a7a70ebb6
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/StringGetBytesIntIntBytesIntTest.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGetBytesIntIntBytesIntTest.java
+ * -@TestCaseName: Test String Method: void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: dst.length > 0, dst.element is Hex number. 0 =< srcBegin < srcEnd, srcEnd <
+ *          instance.length. 0 =< dstBegin < dst.length -1. srcBegin/srcEnd/dstBegin cover boundary value.
+ * -#step3: Test method getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin).
+ * -#step4: check the dst is replaced correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringGetBytesIntIntBytesIntTest.java
+ * -@ExecuteClass: StringGetBytesIntIntBytesIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringGetBytesIntIntBytesIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringGetBytesIntIntBytesIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringGetBytesIntIntBytesIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        // Test 0 < srcBegin < srcEnd, srcEnd < instance.length. 0 =< dstBegin < dst.length -1.
+        byte[] dst = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(2, 5, dst, 2);
+        String str_new = new String(dst);
+        System.out.println(str_new);
+
+        // Test srcBegin = 0, srcEnd < instance.length. 0 =< dstBegin < dst.length -1.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(0, 3, dst, 2);
+        str_new = new String(dst);
+        System.out.println(str_new);
+
+        // Test srcBegin = instance.length, srcEnd = instance.length, 0 =< dstBegin < dst.length -1.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(str.length(), str.length(), dst, 2);
+        str_new = new String(dst);
+        System.out.println(str_new);
+
+        // Test srcBegin = 0, srcEnd = 0, 0 =< dstBegin < dst.length -1.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(0, 0, dst, 2);
+        str_new = new String(dst);
+        System.out.println(str_new);
+
+        // Test 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin = 0.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(2, 3, dst, 0);
+        str_new = new String(dst);
+        System.out.println(str_new);
+
+        // Test 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin = dst.length -1.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(2, 3, dst, 5);
+        str_new = new String(dst);
+        System.out.println(str_new);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ABertF\nABqweF\nABCDEF\nABCDEF\neBCDEF\nABCDEe\nAB!.&F\nAB @!F\nABCDEF\nABCDEF\n!BCDEF\nABCDE!\nABc12F\nABabcF\nABCDEF\nABCDEF\ncBCDEF\nABCDEc\nABertF\nABqweF\nABCDEF\nABCDEF\neBCDEF\nABCDEe\nAB!.&F\nAB @!F\nABCDEF\nABCDEF\n!BCDEF\nABCDE!\nABc12F\nABabcF\nABCDEF\nABCDEF\ncBCDEF\nABCDEc\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0066-rt-String-GetBytesStringTest/StringGetBytesStringTest.java b/test/testsuite/ouroboros/string_test/RT0066-rt-String-GetBytesStringTest/StringGetBytesStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..462f948a9be3cb1347b60892710587e7599b1aa2
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0066-rt-String-GetBytesStringTest/StringGetBytesStringTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGetBytesStringTest.java
+ * -@TestCaseName: Test String Method: byte[] getBytes(String charsetName).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: charsetName is Charset Name String.
+ * -#step3: Test method getBytes(String charsetName).
+ * -#step4: Check the return byte[] is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringGetBytesStringTest.java
+ * -@ExecuteClass: StringGetBytesStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+
+public class StringGetBytesStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringGetBytesStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringGetBytesStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        try {
+            byte[] test1_1 = str.getBytes("UTF-8");
+            for (int i = 0; i < test1_1.length; i++) {
+                System.out.println(test1_1[i]);
+            }
+        } catch (UnsupportedEncodingException e) {
+            System.out.println("Unsupported character set");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 113\n119\n101\n114\n116\n121\n117\n105\n111\n112\n123\n125\n91\n93\n92\n124\n97\n115\n100\n102\n103\n104\n106\n107\n108\n59\n58\n39\n34\n122\n120\n99\n118\n98\n110\n109\n44\n46\n60\n62\n47\n63\n126\n96\n49\n50\n51\n52\n53\n54\n55\n56\n57\n48\n45\n61\n33\n64\n35\n36\n37\n94\n38\n42\n40\n41\n95\n43\n32\n65\n83\n68\n70\n71\n72\n74\n75\n76\n81\n87\n69\n82\n84\n89\n85\n73\n79\n80\n90\n88\n67\n86\n66\n78\n77\n48\n120\n57\n54\n32\n64\n33\n46\n38\n37\n97\n98\n99\n49\n50\n51\n113\n119\n101\n114\n116\n121\n117\n105\n111\n112\n123\n125\n91\n93\n92\n124\n97\n115\n100\n102\n103\n104\n106\n107\n108\n59\n58\n39\n34\n122\n120\n99\n118\n98\n110\n109\n44\n46\n60\n62\n47\n63\n126\n96\n49\n50\n51\n52\n53\n54\n55\n56\n57\n48\n45\n61\n33\n64\n35\n36\n37\n94\n38\n42\n40\n41\n95\n43\n32\n65\n83\n68\n70\n71\n72\n74\n75\n76\n81\n87\n69\n82\n84\n89\n85\n73\n79\n80\n90\n88\n67\n86\n66\n78\n77\n48\n120\n57\n54\n32\n64\n33\n46\n38\n37\n97\n98\n99\n49\n50\n51\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0067-rt-String-GetBytesCharsetTest/StringGetBytesCharsetTest.java b/test/testsuite/ouroboros/string_test/RT0067-rt-String-GetBytesCharsetTest/StringGetBytesCharsetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2314f100e7874cf98bbc5265f7658affcea548df
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0067-rt-String-GetBytesCharsetTest/StringGetBytesCharsetTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGetBytesCharsetTest.java
+ * -@TestCaseName: Test String method: public byte[] getBytes(Charset charset).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: charset is Charset in normal.
+ * -#step3: Test method getBytes(Charset charset).
+ * -#step4: Check the return byte[] is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringGetBytesCharsetTest.java
+ * -@ExecuteClass: StringGetBytesCharsetTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+public class StringGetBytesCharsetTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringGetBytesCharsetTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringGetBytesCharsetTest_1() throws UnsupportedEncodingException {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) throws UnsupportedEncodingException {
+        Charset charset = Charset.defaultCharset();
+        byte[] test1 = str.getBytes(charset);
+        for (int i = 0; i < test1.length; i++) {
+            System.out.println(test1[i]);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 113\n119\n101\n114\n116\n121\n117\n105\n111\n112\n123\n125\n91\n93\n92\n124\n97\n115\n100\n102\n103\n104\n106\n107\n108\n59\n58\n39\n34\n122\n120\n99\n118\n98\n110\n109\n44\n46\n60\n62\n47\n63\n126\n96\n49\n50\n51\n52\n53\n54\n55\n56\n57\n48\n45\n61\n33\n64\n35\n36\n37\n94\n38\n42\n40\n41\n95\n43\n32\n65\n83\n68\n70\n71\n72\n74\n75\n76\n81\n87\n69\n82\n84\n89\n85\n73\n79\n80\n90\n88\n67\n86\n66\n78\n77\n48\n120\n57\n54\n32\n64\n33\n46\n38\n37\n97\n98\n99\n49\n50\n51\n113\n119\n101\n114\n116\n121\n117\n105\n111\n112\n123\n125\n91\n93\n92\n124\n97\n115\n100\n102\n103\n104\n106\n107\n108\n59\n58\n39\n34\n122\n120\n99\n118\n98\n110\n109\n44\n46\n60\n62\n47\n63\n126\n96\n49\n50\n51\n52\n53\n54\n55\n56\n57\n48\n45\n61\n33\n64\n35\n36\n37\n94\n38\n42\n40\n41\n95\n43\n32\n65\n83\n68\n70\n71\n72\n74\n75\n76\n81\n87\n69\n82\n84\n89\n85\n73\n79\n80\n90\n88\n67\n86\n66\n78\n77\n48\n120\n57\n54\n32\n64\n33\n46\n38\n37\n97\n98\n99\n49\n50\n51\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0068-rt-String-GetBytesTest/StringGetBytesTest.java b/test/testsuite/ouroboros/string_test/RT0068-rt-String-GetBytesTest/StringGetBytesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e486dad452044002b2c9355e0d14298f8a1d9fa5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0068-rt-String-GetBytesTest/StringGetBytesTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGetBytesTest.java
+ * -@TestCaseName: Test String Method: byte[] getBytes().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method getBytes().
+ * -#step3: Check the return byte[] is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringGetBytesTest.java
+ * -@ExecuteClass: StringGetBytesTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringGetBytesTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringGetBytesTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringGetBytesTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        byte[] test1_1 = str.getBytes();
+        for (int i = 0; i < test1_1.length; i++) {
+            System.out.println(test1_1[i]);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 113\n119\n101\n114\n116\n121\n117\n105\n111\n112\n123\n125\n91\n93\n92\n124\n97\n115\n100\n102\n103\n104\n106\n107\n108\n59\n58\n39\n34\n122\n120\n99\n118\n98\n110\n109\n44\n46\n60\n62\n47\n63\n126\n96\n49\n50\n51\n52\n53\n54\n55\n56\n57\n48\n45\n61\n33\n64\n35\n36\n37\n94\n38\n42\n40\n41\n95\n43\n32\n65\n83\n68\n70\n71\n72\n74\n75\n76\n81\n87\n69\n82\n84\n89\n85\n73\n79\n80\n90\n88\n67\n86\n66\n78\n77\n48\n120\n57\n54\n32\n64\n33\n46\n38\n37\n97\n98\n99\n49\n50\n51\n113\n119\n101\n114\n116\n121\n117\n105\n111\n112\n123\n125\n91\n93\n92\n124\n97\n115\n100\n102\n103\n104\n106\n107\n108\n59\n58\n39\n34\n122\n120\n99\n118\n98\n110\n109\n44\n46\n60\n62\n47\n63\n126\n96\n49\n50\n51\n52\n53\n54\n55\n56\n57\n48\n45\n61\n33\n64\n35\n36\n37\n94\n38\n42\n40\n41\n95\n43\n32\n65\n83\n68\n70\n71\n72\n74\n75\n76\n81\n87\n69\n82\n84\n89\n85\n73\n79\n80\n90\n88\n67\n86\n66\n78\n77\n48\n120\n57\n54\n32\n64\n33\n46\n38\n37\n97\n98\n99\n49\n50\n51\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0069-rt-String-EqualsTest/StringEqualsTest.java b/test/testsuite/ouroboros/string_test/RT0069-rt-String-EqualsTest/StringEqualsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c14c446ee303665022100b2948ecc8d57c1f5f0b
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0069-rt-String-EqualsTest/StringEqualsTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringEqualsTest.java
+ * -@TestCaseName: Test String Method: boolean equals(Object anObject).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance, Create anObject as a String instance.
+ * -#step2: Test method equals(Object anObject).
+ * -#step3: Change instance/anObject as one or more kinds of letters, numbers, special symbols/""/NoParam to repeat
+ *          step2.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringEqualsTest.java
+ * -@ExecuteClass: StringEqualsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringEqualsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringEqualsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringEqualsTest_1() {
+        String str1_1 = new String("abc123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str1_6 = new String("ABc123");
+
+        String str2_1 = "abc123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        String str2_5 = null;
+
+        System.out.println(str1_1 + " equals " + str1_2 + " : " + str1_1.equals(str1_2));
+        System.out.println(str1_1 + " equals " + str1_3 + " : " + str1_1.equals(str1_3));
+        System.out.println(str1_1 + " equals " + str1_4 + " : " + str1_1.equals(str1_4));
+        System.out.println(str1_1 + " equals " + str1_5 + " : " + str1_1.equals(str1_5));
+        System.out.println(str1_1 + " equals " + str1_6 + " : " + str1_1.equals(str1_6));
+        System.out.println(str1_2 + " equals " + str2_2 + " : " + str1_2.equals(str2_2));
+        System.out.println(str2_1 + " equals " + str2_2 + " : " + str2_1.equals(str2_2));
+        System.out.println(str2_1 + " equals " + str2_3 + " : " + str2_1.equals(str2_3));
+        System.out.println(str2_1 + " equals " + str2_4 + " : " + str2_1.equals(str2_4));
+        System.out.println(str2_1 + " equals " + str2_5 + " : " + str2_1.equals(str2_5));
+        System.out.println(str1_1 + " equals " + str2_1 + " : " + str1_1.equals(str2_1));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123 equals ****** : false\nabc123 equals abc123 : true\nabc123 equals  : false\nabc123 equals  : false\nabc123 equals ABc123 : false\n****** equals ****** : true\nabc123 equals ****** : false\nabc123 equals abc123 : true\nabc123 equals  : false\nabc123 equals null : false\nabc123 equals abc123 : true\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0070-rt-String-ContentEqualsTest/StringContentEqualsTest.java b/test/testsuite/ouroboros/string_test/RT0070-rt-String-ContentEqualsTest/StringContentEqualsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..83eb7487118f5635783ce3461ab99cc96cf910b5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0070-rt-String-ContentEqualsTest/StringContentEqualsTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringContentEqualsTest.java
+ * -@TestCaseName: Test String Method: boolean contentEquals(StringBuffer sb).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: sb is created by new StringBuffer(String str).
+ * -#step3: Test method contentEquals(StringBuffer sb).
+ * -#step4: Check the boolean result is correctly.
+ * -#step5: Change str as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringContentEqualsTest.java
+ * -@ExecuteClass: StringContentEqualsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringContentEqualsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringContentEqualsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringContentEqualsTest_1() {
+        String str1_1 = new String("abc123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("ABc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "abc123";
+        String str2_2 = "******";
+        String str2_3 = "ABc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String test = "abc123";
+        StringBuffer test1_1 = new StringBuffer(str);
+        boolean result = test.contentEquals(test1_1);
+        System.out.println(result);
+    }
+}
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full true\nfalse\nfalse\nfalse\nfalse\ntrue\nfalse\nfalse\nfalse\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/StringContentEqualsCharSequenceTest.java b/test/testsuite/ouroboros/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/StringContentEqualsCharSequenceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c881a60a94f382bd5a7b067a615834c9a9251bd
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/StringContentEqualsCharSequenceTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringContentEqualsCharSequenceTest.java
+ * -@TestCaseName: Test String Method: boolean contentEquals(CharSequence cs).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: cs is initialized by String str.
+ * -#step3: Test method contentEquals(CharSequence cs).
+ * -#step4: Check the boolean result is correctly.
+ * -#step5: Change cs as String 0f One or more kinds of letters, numbers, special symbols or as "" or as NoParam to
+ *          repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringContentEqualsCharSequenceTest.java
+ * -@ExecuteClass: StringContentEqualsCharSequenceTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringContentEqualsCharSequenceTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringContentEqualsCharSequenceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringContentEqualsCharSequenceTest_1() {
+        String str1_1 = new String("ABC123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "ABC123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String test = "abc123";
+        CharSequence test1_1 = str;
+        boolean result = test.contentEquals(test1_1);
+        System.out.println(result);
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full false\nfalse\ntrue\nfalse\nfalse\nfalse\nfalse\ntrue\nfalse\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/StringEqualsIgnoreCaseTest.java b/test/testsuite/ouroboros/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/StringEqualsIgnoreCaseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d13ac3a3bda189d751ee047623f9e478d09e1fa
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/StringEqualsIgnoreCaseTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringEqualsIgnoreCaseTest.java
+ * -@TestCaseName: Test String Method: boolean equalsIgnoreCase(String anotherString).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance and anotherString instance.
+ * -#step2: Test method test.equalsIgnoreCase(anotherString).
+ * -#step3: Check the boolean result is correctly.
+ * -#step4: Change anotherString as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringEqualsIgnoreCaseTest.java
+ * -@ExecuteClass: StringEqualsIgnoreCaseTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringEqualsIgnoreCaseTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringEqualsIgnoreCaseTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringEqualsIgnoreCaseTest_1() {
+        String str1_1 = new String("ABC123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "ABC123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String test = "ABC123";
+        boolean result = test.equalsIgnoreCase(str);
+        System.out.println(result);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full true\nfalse\ntrue\nfalse\nfalse\ntrue\nfalse\ntrue\nfalse\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0073-rt-String-CompareToTest/StringCompareToTest.java b/test/testsuite/ouroboros/string_test/RT0073-rt-String-CompareToTest/StringCompareToTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa347f769dec84f806c3bd19614af966440222ae
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0073-rt-String-CompareToTest/StringCompareToTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCompareToTest.java
+ * -@TestCaseName: Test String Method compareTo(String anotherString).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance and anotherString instance.
+ * -#step2: Test method compareTo(String anotherString).
+ * -#step3: Check the int result is correctly.
+ * -#step4: Change anotherString as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCompareToTest.java
+ * -@ExecuteClass: StringCompareToTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCompareToTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCompareToTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCompareToTest_1() {
+        String str1_1 = new String("ABC123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "ABC123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String test = "ABC123";
+        int result = test.compareTo(str);
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n23\n-32\n6\n6\n0\n23\n-32\n6\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/StringCompareToIgnoreCaseTest.java b/test/testsuite/ouroboros/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/StringCompareToIgnoreCaseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3d9c897ab3636ccb90d64f492914f35530296c5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/StringCompareToIgnoreCaseTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCompareToIgnoreCaseTest.java
+ * -@TestCaseName: Test String Method: int compareToIgnoreCase(String str).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance, parameter anotherString instance.
+ * -#step2: Test method test.compareTo(anotherString).
+ * -#step3: Check the int result is correctly.
+ * -#step4: Change anotherString as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCompareToIgnoreCaseTest.java
+ * -@ExecuteClass: StringCompareToIgnoreCaseTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCompareToIgnoreCaseTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCompareToIgnoreCaseTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCompareToIgnoreCaseTest_1() {
+        String str1_1 = new String("ABC123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "ABC123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String test = "ABC123";
+        int result = test.compareToIgnoreCase(str);
+        System.out.println(result);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n55\n0\n6\n6\n0\n55\n0\n6\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/StringRegionMatchesIntStringIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/StringRegionMatchesIntStringIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9183c6c1f3267efdd3e52cad8c62c3ef777763f
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/StringRegionMatchesIntStringIntIntTest.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringRegionMatchesIntStringIntIntTest.java
+ * -@TestCaseName: Test String Method: boolean regionMatches(int toffset, String other, int ooffset, int len).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: 0 =< toffset < instance.length, 0 =< ooffset < other.length, 0 =< len <
+ *          Min value of other.length - ooffset -1 and instance.length - toffset - 1, toffset/ooffset/len cover
+ *          Boundary value.
+ * -#step3: Test method instance.regionMatches(int toffset, String other, int ooffset, int len).
+ * -#step4: Check the boolean result is correctly.
+ * -#step5: Change instance & String as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat
+ *          step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringRegionMatchesIntStringIntIntTest.java
+ * -@ExecuteClass: StringRegionMatchesIntStringIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringRegionMatchesIntStringIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringRegionMatchesIntStringIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringRegionMatchesIntStringIntIntTest_1() {
+        String str1_1 = new String("abc123_SAME");
+        String str1_2 = new String("      _same");
+        String str1_3 = new String("abc123_same");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "abc123_SAME";
+        String str2_2 = "      _same";
+        String str2_3 = "abc123_same";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String test = "same";
+        // Test 0 =< toffset < instance.length, 0 =< ooffset < other.length,
+        // 0 =< len < 0 =< len < Min value of other.length - ooffset -1 and instance.length - toffset - 1
+        System.out.println(str.regionMatches(7, test, 0, 4));
+        System.out.println(str.regionMatches(7, test, 0, 5));
+        System.out.println(str.regionMatches(8, test, 1, 3));
+        // Test toffset < 0.
+        System.out.println(str.regionMatches(-2, test, 0, 2));
+        // Test toffset = 0.
+        System.out.println(str.regionMatches(0, test, 1, 1));
+        // Test toffset < instance.length - 1.
+        System.out.println(str.regionMatches(10, test, 1, 1));
+        // Test ooffset = other.length - 1.
+        System.out.println(str.regionMatches(10, test, 3, 1));
+        // Test len = 0.
+        System.out.println(str.regionMatches(7, test, 0, 0));
+        // Test len = str.length().
+        System.out.println(str.regionMatches(7, test, 0, str.length()));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full false\nfalse\nfalse\nfalse\ntrue\nfalse\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\nfalse\nfalse\ntrue\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\ntrue\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\ntrue\nfalse\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\nfalse\nfalse\ntrue\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\ntrue\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/StringRegionMatchesBooleanIntStringIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/StringRegionMatchesBooleanIntStringIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf86c7c16919e0587c3a4399b89bd5ae72127ae1
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/StringRegionMatchesBooleanIntStringIntIntTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringRegionMatchesBooleanIntStringIntIntTest.java
+ * -@TestCaseName: Test String Method: boolean regionMatches(boolean ignoreCase, int toffset, String other, int
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      ooffset, int len).
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: ignoreCase = true, 0 =< toffset < instance.length, 0 =< ooffset < other.length, 0 =< len
+ *          < Min value of other.length - ooffset and instance.length - toffset.
+ * -#step3: Test method instance.regionMatches(int toffset, String other, int ooffset, int len), check the boolean
+ *          result is correctly.
+ * -#step4: Create parameters: ignoreCase = false, 0 =< toffset < instance.length, 0 =< ooffset < other.length, 0 =< len
+ *          < Min value of other.length - ooffset and instance.length - toffset.
+ * -#step5: Test method instance.regionMatches(int toffset, String other, int ooffset, int len), check the boolean
+ *          result is correctly.
+ * -#step6: Create parameters: ignoreCase/toffset/ooffset/len cover boundary value.
+ * -#step7: Test method instance.regionMatches(int toffset, String other, int ooffset, int len), check the boolean
+ *          result is correctly.
+ * -#step8: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~7.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringRegionMatchesBooleanIntStringIntIntTest.java
+ * -@ExecuteClass: StringRegionMatchesBooleanIntStringIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringRegionMatchesBooleanIntStringIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringRegionMatchesBooleanIntStringIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringRegionMatchesBooleanIntStringIntIntTest_1() {
+        String str1_1 = new String("abc123_SAME");
+        String str1_2 = new String("      _same");
+        String str1_3 = new String("abc123_same");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "abc123_SAME";
+        String str2_2 = "      _same";
+        String str2_3 = "abc123_same";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String test = "SAME";
+        // Test ooffset = 0, len = Min value of other.length - ooffset and instance.length - toffset.
+        System.out.println(str.regionMatches(true, 7, test, 0, 4));
+        System.out.println(str.regionMatches(false, 7, test, 0, 4));
+
+        // Test toffset = 0.
+        System.out.println(str.regionMatches(true, 0, test, 1, 1));
+        System.out.println(str.regionMatches(false, 0, test, 1, 1));
+
+        // Test toffset = str.length() - 1, ooffset = test.length() - 1.
+        System.out.println(str.regionMatches(true, str.length() - 1, test, 3, 1));
+        System.out.println(str.regionMatches(false, str.length() - 1, test, 3, 1));
+
+        // Test len = 0.
+        System.out.println(str.regionMatches(true, 7, test, 0, 0));
+        System.out.println(str.regionMatches(false, 7, test, 0, 0));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full true\ntrue\ntrue\nfalse\ntrue\ntrue\ntrue\ntrue\ntrue\nfalse\nfalse\nfalse\ntrue\nfalse\ntrue\ntrue\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\ntrue\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\ntrue\ntrue\ntrue\nfalse\ntrue\ntrue\ntrue\ntrue\ntrue\nfalse\nfalse\nfalse\ntrue\nfalse\ntrue\ntrue\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\ntrue\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0077-rt-String-StartsWithStringIntTest/StringStartsWithStringIntTest.java b/test/testsuite/ouroboros/string_test/RT0077-rt-String-StartsWithStringIntTest/StringStartsWithStringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..06eb339f37c58282632db65e0ab62207a579cb82
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0077-rt-String-StartsWithStringIntTest/StringStartsWithStringIntTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringStartsWithStringIntTest.java
+ * -@TestCaseName: Test String Method: boolean startsWith(String prefix, int toffset).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: prefix is some letters/numbers, 0 =< toffset < instance.length, toffset cover boundary
+ *          value.
+ * -#step3: Test method startsWith(String prefix, int toffset).
+ * -#step4: Check the boolean result is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringStartsWithStringIntTest.java
+ * -@ExecuteClass: StringStartsWithStringIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringStartsWithStringIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringStartsWithStringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringStartsWithStringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.startsWith("123", 3));
+        // Test toffset = 0.
+        System.out.println(str.startsWith("abc", 0));
+        // Test toffset = str.length() - 1.
+        System.out.println(str.startsWith("%", str.length() - 1));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full false\nfalse\nfalse\nfalse\nfalse\ntrue\ntrue\ntrue\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\ntrue\ntrue\ntrue\nfalse\nfalse\nfalse\nfalse\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0078-rt-String-StartsWithStringTest/StringStartsWithStringTest.java b/test/testsuite/ouroboros/string_test/RT0078-rt-String-StartsWithStringTest/StringStartsWithStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2471d15dd4e2f828c14bee9295fa64b22fde6beb
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0078-rt-String-StartsWithStringTest/StringStartsWithStringTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringStartsWithStringTest.java
+ * -@TestCaseName: Test String Method: boolean startsWith(String prefix).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: prefix is some letters/numbers or "".
+ * -#step3: Test method startsWith(String prefix).
+ * -#step4: Check the boolean result is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringStartsWithStringTest.java
+ * -@ExecuteClass: StringStartsWithStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringStartsWithStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringStartsWithStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringStartsWithStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.startsWith("ab"));
+        System.out.println(str.startsWith(""));
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full false\ntrue\nfalse\ntrue\ntrue\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\ntrue\ntrue\nfalse\ntrue\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0079-rt-String-EndsWithTest/StringEndsWithTest.java b/test/testsuite/ouroboros/string_test/RT0079-rt-String-EndsWithTest/StringEndsWithTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2d5e37dd97f4fa47d62c5afe19ffbd8fedf1a44
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0079-rt-String-EndsWithTest/StringEndsWithTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringEndsWithTest.java
+ * -@TestCaseName: Test String Method: boolean endsWith(String suffix).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: suffix is some letters/numbers or "".
+ * -#step3: Test method endsWith(String suffix).
+ * -#step4: Check the boolean result is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringEndsWithTest.java
+ * -@ExecuteClass: StringEndsWithTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringEndsWithTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringEndsWithTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringEndsWithTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.endsWith("bc"));
+        System.out.println(str.endsWith(""));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full false\ntrue\nfalse\ntrue\ntrue\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0080-rt-String-HashCodeTest/StringHashCodeTest.java b/test/testsuite/ouroboros/string_test/RT0080-rt-String-HashCodeTest/StringHashCodeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb94cdd85c9e74333ed8b77ad0614ad658928041
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0080-rt-String-HashCodeTest/StringHashCodeTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringHashCodeTest.java
+ * -@TestCaseName: Test String Method: int hashCode().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method hashCode().
+ * -#step3: Check the int result is correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringHashCodeTest.java
+ * -@ExecuteClass: StringHashCodeTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringHashCodeTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringHashCodeTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringHashCodeTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.hashCode());
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full -736345066\n976266700\n-1113531438\n0\n0\n-736345066\n976266700\n-1113563214\n0\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0081-rt-String-IndexOfIntTest/StringIndexOfIntTest.java b/test/testsuite/ouroboros/string_test/RT0081-rt-String-IndexOfIntTest/StringIndexOfIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd79303b5ba6bd21c26f701d87d097b6a3c53e53
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0081-rt-String-IndexOfIntTest/StringIndexOfIntTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringIndexOfIntTest.java
+ * -@TestCaseName: Test String Method: int indexOf(int ch).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: ch is ascii numbers.
+ * -#step3: Test method indexOf(int ch).
+ * -#step4: Check the int result is correctly.
+ * -#step5: replace instance or string which consists of one or more of the following:letters, numbers , "",
+ *          special symbols and null, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringIndexOfIntTest.java
+ * -@ExecuteClass: StringIndexOfIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringIndexOfIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringIndexOfIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringIndexOfIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUI" +
+                "OPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.indexOf(98));
+    }
+}
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 33\n-1\n1\n-1\n-1\n33\n-1\n1\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0082-rt-String-IndexOfIntIntTest/StringIndexOfIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0082-rt-String-IndexOfIntIntTest/StringIndexOfIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..373c439dfd55a3528c46bf79bfd863bcd2ab0220
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0082-rt-String-IndexOfIntIntTest/StringIndexOfIntIntTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringIndexOfIntIntTest.java
+ * -@TestCaseName: Test String Method: int indexOf(int ch, int fromIndex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: ch is ascii numbers, 0 =< fromIndex = < instance.length.
+ * -#step3: Test method indexOf(int ch, int fromIndex).
+ * -#step4: Check the int result is correctly.
+ * -#step5: Replace instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringIndexOfIntIntTest.java
+ * -@ExecuteClass: StringIndexOfIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringIndexOfIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringIndexOfIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringIndexOfIntIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZX" +
+                "CVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        // Test 0 < fromIndex < str.length().
+        System.out.println(str.indexOf(98, 2));
+        // Test fromIndex = 0.
+        System.out.println(str.indexOf(98, 0));
+        // Test fromIndex = str.length().
+        System.out.println(str.indexOf(98, str.length()));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 33\n33\n-1\n-1\n-1\n-1\n7\n1\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n33\n33\n-1\n-1\n-1\n-1\n-1\n1\n-1\n-1\n-1\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0083-rt-String-LastIndexOfIntTest/StringLastIndexOfIntTest.java b/test/testsuite/ouroboros/string_test/RT0083-rt-String-LastIndexOfIntTest/StringLastIndexOfIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f3f157d15896a6fe3efd4d017fbc943d5520d82e
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0083-rt-String-LastIndexOfIntTest/StringLastIndexOfIntTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringLastIndexOfIntTest.java
+ * -@TestCaseName: Test String Method: int lastIndexOf(int ch).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: ch is ascii numbers.
+ * -#step3: Test method lastIndexOf(int ch).
+ * -#step4: Check the int result is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringLastIndexOfIntTest.java
+ * -@ExecuteClass: StringLastIndexOfIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringLastIndexOfIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringLastIndexOfIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringLastIndexOfIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+" +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZ" +
+                "XCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.lastIndexOf(98));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 33\n-1\n7\n-1\n-1\n33\n-1\n1\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0084-rt-String-LastIndexOfIntIntTest/StringLastIndexOfIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0084-rt-String-LastIndexOfIntIntTest/StringLastIndexOfIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e4e57fd020a2fef362f919e36c35d9731000bdc
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0084-rt-String-LastIndexOfIntIntTest/StringLastIndexOfIntIntTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringLastIndexOfIntIntTest.java
+ * -@TestCaseName: Test String Method: int lastIndexOf(int ch, int fromIndex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: ch is ascii numbers, 0 =< fromIndex =< instance.length.
+ * -#step3: Test method lastIndexOf(int ch, int fromIndex).
+ * -#step4: Check the int result is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringLastIndexOfIntIntTest.java
+ * -@ExecuteClass: StringLastIndexOfIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringLastIndexOfIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringLastIndexOfIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringLastIndexOfIntIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASD" +
+                "FGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        // Test fromIndex = 0.
+        System.out.println(str.lastIndexOf(49, 0));
+        // Test 0 < fromIndex < str.length().
+        System.out.println(str.lastIndexOf(49, 3));
+        // Test fromIndex = str.length().
+        System.out.println(str.lastIndexOf(49, str.length()));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full -1\n-1\n44\n-1\n-1\n-1\n-1\n3\n3\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n44\n-1\n-1\n-1\n-1\n3\n3\n-1\n-1\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0085-rt-String-IndexOfStringTest/StringIndexOfStringTest.java b/test/testsuite/ouroboros/string_test/RT0085-rt-String-IndexOfStringTest/StringIndexOfStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ad5839290c78b4984223e6c9f6f628b8f04bbad
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0085-rt-String-IndexOfStringTest/StringIndexOfStringTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringIndexOfStringTest.java
+ * -@TestCaseName: Test String Method: int indexOf(String str).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: str1 is a letter.
+ * -#step3: Test method indexOf(String str).
+ * -#step4: Check the int result is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringIndexOfStringTest.java
+ * -@ExecuteClass: StringIndexOfStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringIndexOfStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringIndexOfStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringIndexOfStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.indexOf("c"));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 31\n-1\n2\n-1\n-1\n31\n-1\n2\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0086-rt-String-IndexOfStringIntTest/StringIndexOfStringIntTest.java b/test/testsuite/ouroboros/string_test/RT0086-rt-String-IndexOfStringIntTest/StringIndexOfStringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..77737a8b9e16dba5e04b051c15e1dbc72793721e
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0086-rt-String-IndexOfStringIntTest/StringIndexOfStringIntTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringIndexOfStringIntTest.java
+ * -@TestCaseName: Test String Method: int indexOf(String str, int fromIndex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: str is a letter, 0 =< fromIndex = < instance.length.
+ * -#step3: Test method indexOf(String str, int fromIndex).
+ * -#step4: Check the int result is correctly.
+ * -#step5: Replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringIndexOfStringIntTest.java
+ * -@ExecuteClass: StringIndexOfStringIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringIndexOfStringIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringIndexOfStringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringIndexOfStringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        // Test fromIndex = 0.
+        System.out.println(str.indexOf("c", 0));
+        // Test 0 < fromIndex < str.length().
+        System.out.println(str.indexOf("c", 4));
+        // Test fromIndex = str.length().
+        System.out.println(str.indexOf("c", str.length()));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 31\n31\n-1\n-1\n-1\n-1\n2\n8\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n31\n31\n-1\n-1\n-1\n-1\n2\n-1\n-1\n-1\n-1\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0087-rt-String-LastIndexOfStringTest/StringLastIndexOfStringTest.java b/test/testsuite/ouroboros/string_test/RT0087-rt-String-LastIndexOfStringTest/StringLastIndexOfStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ecbd8dd83622228cca6e6424a715ad87422af636
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0087-rt-String-LastIndexOfStringTest/StringLastIndexOfStringTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringLastIndexOfStringTest.java
+ * -@TestCaseName: Test String Method: int lastIndexOf(String str).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: str1 is a letter.
+ * -#step3: Test method lastIndexOf(String str).
+ * -#step4: Check the int result is correctly.
+ * -#step5: Replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect:expected.txt
+ * -@Priority: High
+ * -@Source: StringLastIndexOfStringTest.java
+ * -@ExecuteClass: StringLastIndexOfStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringLastIndexOfStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringLastIndexOfStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringLastIndexOfStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZX" +
+                "CVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.lastIndexOf("c"));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 31\n-1\n8\n-1\n-1\n31\n-1\n2\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0088-rt-String-LastIndexOfStringIntTest/StringLastIndexOfStringIntTest.java b/test/testsuite/ouroboros/string_test/RT0088-rt-String-LastIndexOfStringIntTest/StringLastIndexOfStringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c414ae41dbe7131497d28275ff352617e251857
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0088-rt-String-LastIndexOfStringIntTest/StringLastIndexOfStringIntTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringLastIndexOfStringIntTest.java
+ * -@TestCaseName: Test String Method: int lastIndexOf(String str, int fromIndex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: str is a letter, 0 =< fromIndex =< instance.length.
+ * -#step3: Test method lastIndexOf(String str, int fromIndex).
+ * -#step4: Check the int result is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringLastIndexOfStringIntTest.java
+ * -@ExecuteClass: StringLastIndexOfStringIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringLastIndexOfStringIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringLastIndexOfStringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringLastIndexOfStringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASD" +
+                "FGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZX" +
+                "CVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        // Test fromIndex = 0.
+        System.out.println(str.lastIndexOf("c", 0));
+        // Test 0 < fromIndex < str.length().
+        System.out.println(str.lastIndexOf("c", 2));
+        // Test fromIndex = str.length().
+        System.out.println(str.lastIndexOf("c", str.length()));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full -1\n-1\n31\n-1\n-1\n-1\n-1\n2\n8\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n31\n-1\n-1\n-1\n-1\n2\n2\n-1\n-1\n-1\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0089-rt-String-SubstringIntTest/StringSubstringIntTest.java b/test/testsuite/ouroboros/string_test/RT0089-rt-String-SubstringIntTest/StringSubstringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b65cb79dc2e642e408d6a7e01f49069642540db2
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0089-rt-String-SubstringIntTest/StringSubstringIntTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringSubstringIntTest.java
+ * -@TestCaseName: Test String Method: String substring(int beginIndex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: 0 =< beginIndex =< instance.length.
+ * -#step3: Test method substring(int beginIndex).
+ * -#step4: Check the String result is correctly.
+ * -#step5: Replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringSubstringIntTest.java
+ * -@ExecuteClass: StringSubstringIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringSubstringIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringSubstringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringSubstringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTY" +
+                "UIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        // Test beginIndex = 0.
+        System.out.println(str.substring(0));
+        // Test 0 < beginIndex < str.length().
+        System.out.println(str.substring(4));
+        // Test beginIndex = str.length().
+        System.out.println(str.substring(str.length()));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ntyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n @!.&%\n&%\n\nabc123abc\n23abc\n\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ntyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n @!.&%\n&%\n\nabc123ABC\n23ABC\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0090-rt-String-SubstringIntIntTest/StringSubstringIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0090-rt-String-SubstringIntIntTest/StringSubstringIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a03a3f6014a063f9cdbeb9a015ffde129847287
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0090-rt-String-SubstringIntIntTest/StringSubstringIntIntTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringSubstringIntIntTest.java
+ * -@TestCaseName: String Method: String substring(int beginIndex, int endIndex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: 0 =< beginIndex < endIndex =< instance.length.
+ * -#step3: Test method substring(int beginIndex, int endIndex).
+ * -#step4: Check the String result is correctly.
+ * -#step5: Replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringSubstringIntIntTest.java
+ * -@ExecuteClass: StringSubstringIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringSubstringIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringSubstringIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringSubstringIntIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXC" +
+                "VBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        // Test 0 < beginIndex < endIndex < str.length().
+        System.out.println(str.substring(2, 5));
+        // Test beginIndex = 0.
+        System.out.println(str.substring(0, str.length() - 1));
+        // Test endIndex = 0.
+        System.out.println(str.substring(0, 0));
+        // Test beginIndex = str.length() - 1.
+        System.out.println(str.substring(str.length() - 1, str.length() - 1));
+        // Test endIndex = str.length.
+        System.out.println(str.substring(2, str.length() - 1));
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ert\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x9\n\n\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x9\n!.&\n @!.&\n\n\n!.&\nc12\nabc123ab\n\n\nc123ab\nert\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x9\n\n\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x9\n!.&\n @!.&\n\n\n!.&\nc12\nabc123AB\n\n\nc123AB\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0091-rt-String-SubSequenceIntIntTest/StringSubSequenceIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0091-rt-String-SubSequenceIntIntTest/StringSubSequenceIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..71267312b4695ea2b1260a59ef6ab06104bf2e6f
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0091-rt-String-SubSequenceIntIntTest/StringSubSequenceIntIntTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringSubSequenceIntIntTest.java
+ * -@TestCaseName: Test String Method: CharSequence subSequence(int beginIndex, int endIndex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: 0 =< beginIndex < endIndex =< instance.length.Also,endIndex could be 0.
+ * -#step3: Test method subSequence(int beginIndex, int endIndex).
+ * -#step4: Check the CharSequence result is correctly.
+ * -#step5: replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringSubSequenceIntIntTest.java
+ * -@ExecuteClass: StringSubSequenceIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringSubSequenceIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringSubSequenceIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringSubSequenceIntIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZ" +
+                "XCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+
+    private static void test(String str) {
+        // Test 0 < beginIndex < endIndex < str.length().
+        System.out.println(str.subSequence(2, 6));
+        // Test beginIndex = 0.
+        System.out.println(str.subSequence(0, str.length()));
+        // Test enfIndex = 0.
+        System.out.println(str.subSequence(0, 0));
+        // Test beginIndex = str.length().
+        System.out.println(str.subSequence(str.length(), str.length()));
+        // Test endIndex = str.length().
+        System.out.println(str.subSequence(2, str.length()));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full erty\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n!.&%\n @!.&%\n\n\n!.&%\nc123\nabc123abc\n\n\nc123abc\nerty\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n\n\nertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n!.&%\n @!.&%\n\n\n!.&%\nc123\nabc123ABC\n\n\nc123ABC\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0092-rt-String-ConcatTest/StringConcatTest.java b/test/testsuite/ouroboros/string_test/RT0092-rt-String-ConcatTest/StringConcatTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e5cc31f4fd0587c62f66a1cb27674c536656a96
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0092-rt-String-ConcatTest/StringConcatTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConcatTest.java
+ * -@TestCaseName: Test String Method: String concat(String str).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: test1_1 and test1_2 are some letters.
+ * -#step3: Test method test1_1.concat(instance).concat(test1_2).
+ * -#step4: Check the String result is correctly.
+ * -#step5: replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConcatTest.java
+ * -@ExecuteClass: StringConcatTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConcatTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringConcatTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringConcatTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String test1_1 = "<begin>";
+        String test1_2 = "<end>";
+        System.out.println(test1_1.concat(str).concat(test1_2));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full <begin>qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96<end>\n<begin> @!.&%<end>\n<begin>abc123abc<end>\n<begin><end>\n<begin><end>\n<begin>qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96<end>\n<begin> @!.&%<end>\n<begin>abc123ABC<end>\n<begin><end>\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0093-rt-String-ReplaceCharCharTest/StringReplaceCharCharTest.java b/test/testsuite/ouroboros/string_test/RT0093-rt-String-ReplaceCharCharTest/StringReplaceCharCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6878f737be52fd6031371f3c4c7c5939b3bc44ee
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0093-rt-String-ReplaceCharCharTest/StringReplaceCharCharTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringReplaceCharCharTest.java
+ * -@TestCaseName: Test String Method: String replace(char oldChar, char newChar).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: oldChar and newChar is a char of letter or number or special symbols.
+ * -#step3: Test method replace(char oldChar, char newChar).
+ * -#step4: Check the String result is correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringReplaceCharCharTest.java
+ * -@ExecuteClass: StringReplaceCharCharTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringReplaceCharCharTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringReplaceCharCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringReplaceCharCharTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.replace("a", "@").replace("1", "!"));
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`!234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n@bc!23@bc\n\n\nqwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`!234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n@bc!23ABC\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0094-rt-String-ContainsTest/StringContainsTest.java b/test/testsuite/ouroboros/string_test/RT0094-rt-String-ContainsTest/StringContainsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d4608ca38753b677a5caf4e95c81db8612f553e
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0094-rt-String-ContainsTest/StringContainsTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringContainsTest.java
+ * -@TestCaseName: Test String Method: boolean contains(CharSequence s).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: s is some letters/numbers.
+ * -#step3: Test method contains(CharSequence s).
+ * -#step4: Check the boolean result is correctly.
+ * -#step5: replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringContainsTest.java
+ * -@ExecuteClass: StringContainsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringContainsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringContainsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringContainsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.contains("c123A"));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full false\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\ntrue\nfalse\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/StringReplaceCharSequenceCharSequenceTest.java b/test/testsuite/ouroboros/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/StringReplaceCharSequenceCharSequenceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b99e81b9f61c0c8e505a31aef0652756060cec2f
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/StringReplaceCharSequenceCharSequenceTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringReplaceCharSequenceCharSequenceTest.java
+ * -@TestCaseName: Test String Method: String replace(CharSequence target, CharSequence replacement).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: target and replacement is a CharSequence mix with letter/number/special symbols.
+ * -#step3: Test method replace(CharSequence target, CharSequence replacement).
+ * -#step4: Check the String result is correctly.
+ * -#step5: replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringReplaceCharSequenceCharSequenceTest.java
+ * -@ExecuteClass: StringReplaceCharSequenceCharSequenceTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringReplaceCharSequenceCharSequenceTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringReplaceCharSequenceCharSequenceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringReplaceCharSequenceCharSequenceTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYU" +
+                "IOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.replace("a", "@"));
+        System.out.println(str.replace("c123A", "@"));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n @!.&%\n@bc123@bc\nabc123abc\n\n\n\n\nqwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n @!.&%\n@bc123ABC\nab@BC\n\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0096-rt-String-SplitStringIntTest/StringSplitStringIntTest.java b/test/testsuite/ouroboros/string_test/RT0096-rt-String-SplitStringIntTest/StringSplitStringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e4ee0116702130f70ff2bef510298e4302245f5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0096-rt-String-SplitStringIntTest/StringSplitStringIntTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringSplitStringIntTest.java
+ * -@TestCaseName: Test String Method: String[] split(String regex, int limit).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: regex is a String mix with letter/number/special symbols, 0 = < limit =< instance.length.
+ * -#step3: Test method split(String regex, int limit).
+ * -#step4: Check the String[] result is correctly.
+ * -#step5: replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringSplitStringIntTest.java
+ * -@ExecuteClass: StringSplitStringIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringSplitStringIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringSplitStringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringSplitStringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String[] result;
+        // Test 0  < limit < instance.length.
+        result = str.split("a", 3);
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+
+        // Test limit = instance.length.
+        result = str.split("a", str.length());
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+
+        // Test limit = 0.
+        result = str.split("a", 0);
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+
+        // Test regex is a special symbols.
+        result = str.split("\\.", 2);
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|\nsdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|\nsdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|\nsdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,\n<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n @!.&%\n @!.&%\n @!\n&%\n\nbc.123.\nbc\n\nbc.123.\nbc\n\nbc.123.\nbc\nabc\n123.abc\n\n\n\n\n\n\n\n\nqwertyuiop{}[]\|\nsdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|\nsdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|\nsdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,\n<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n @!.&%\n @!.&%\n @!\n&%\n\nbc.123.ABC\n\nbc.123.ABC\n\nbc.123.ABC\nabc\n123.ABC\n\n\n\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0097-rt-String-SplitStringTest/StringSplitStringTest.java b/test/testsuite/ouroboros/string_test/RT0097-rt-String-SplitStringTest/StringSplitStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff831202a077acf25c259e3d6963c28fd74da6b4
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0097-rt-String-SplitStringTest/StringSplitStringTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringSplitStringTest.java
+ * -@TestCaseName: Test String Method: String[] split(String regex).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create parameters: regex a String mix with letter/number/special symbols.
+ * -#step3: Test method split(String regex).
+ * -#step4: Check the String[] result is correctly.
+ * -#step5: replace instance or string which consists of one or more of the following: letters, numbers and special
+ *          symbols, then to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringSplitStringTest.java
+ * -@ExecuteClass: StringSplitStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringSplitStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringSplitStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringSplitStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String[] result;
+        result = str.split("a");
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+
+        result = str.split("\\.");
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|\nsdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,\n<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n @!\n&%\n\nbc.123.\nbc\nabc\n123\nabc\n\n\n\n\nqwertyuiop{}[]\|\nsdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,\n<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n @!\n&%\n\nbc.123.ABC\nabc\n123\nABC\n\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/StringJoinCharSequenceCharSequenceTest.java b/test/testsuite/ouroboros/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/StringJoinCharSequenceCharSequenceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..17e8d0a74bb7ed5737f71bf3e6239928904a3f5b
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/StringJoinCharSequenceCharSequenceTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringJoinCharSequenceCharSequenceTest.java
+ * -@TestCaseName: Test static String Method: join(CharSequence delimiter, CharSequence... elements).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: Create CharSequence delimiter, Create elements consist of String instance.
+ * -#step3: Test method join(CharSequence delimiter, CharSequence... elements).
+ * -#step4: Check the result get correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringJoinCharSequenceCharSequenceTest.java
+ * -@ExecuteClass: StringJoinCharSequenceCharSequenceTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringJoinCharSequenceCharSequenceTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringJoinCharSequenceCharSequenceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringJoinCharSequenceCharSequenceTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String[] test = new String[]{str, str, str};
+        System.out.println(String.join("-", test));
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%- @!.&%- @!.&%\nabc123abc-abc123abc-abc123abc\n--\n--\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%- @!.&%- @!.&%\nabc123ABC-abc123ABC-abc123ABC\n--\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/StringJoinCharSequenceIterableTest.java b/test/testsuite/ouroboros/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/StringJoinCharSequenceIterableTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d58d477c6caef62db6a31a1cd7533a960737cda5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/StringJoinCharSequenceIterableTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringJoinCharSequenceIterableTest.java
+ * -@TestCaseName: Test String Method: public static String join(CharSequence delimiter, Iterable<? extends
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      CharSequence> elements).
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: Create CharSequence delimiter, Create elements as a List consist of String instance.
+ * -#step3: Test method  join(CharSequence delimiter, Iterable<? extends CharSequence> elements).
+ * -#step4: Check the result get correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringJoinCharSequenceIterableTest.java
+ * -@ExecuteClass: StringJoinCharSequenceIterableTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+public class StringJoinCharSequenceIterableTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringJoinCharSequenceIterableTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringJoinCharSequenceIterableTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        List<String> test1_1 = new LinkedList<>();
+        test1_1.add(str);
+        test1_1.add(str);
+        test1_1.add(str);
+        System.out.println(String.join("-", test1_1));
+
+        Set<String> test1_2 = new LinkedHashSet<>();
+        test1_2.add(str);
+        test1_2.add(str);
+        test1_2.add(str);
+        System.out.println(String.join("~", test1_2));
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%- @!.&%- @!.&%\n @!.&%\nabc123abc-abc123abc-abc123abc\nabc123abc\n--\n\n--\n\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%- @!.&%- @!.&%\n @!.&%\nabc123ABC-abc123ABC-abc123ABC\nabc123ABC\n--\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/StringToLowerCaseLocaleTest.java b/test/testsuite/ouroboros/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/StringToLowerCaseLocaleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..08470666bc412bc5d503fbc875b151385b9d0499
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/StringToLowerCaseLocaleTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringToLowerCaseLocaleTest.java
+ * -@TestCaseName: Test String Method: public String toLowerCase(Locale locale).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: Create locale random choose three country.
+ * -#step3: Test method toLowerCase(Locale locale).
+ * -#step4: Check the result get correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringToLowerCaseLocaleTest.java
+ * -@ExecuteClass: StringToLowerCaseLocaleTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.util.Locale;
+
+
+public class StringToLowerCaseLocaleTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringToLowerCaseLocaleTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringToLowerCaseLocaleTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc.~!@#$%^&*()_+;'/.?");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.toLowerCase(Locale.CHINESE));
+        System.out.println(str.toLowerCase(Locale.ENGLISH));
+        System.out.println(str.toLowerCase(Locale.FRENCH));
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96\n @!.&%\n @!.&%\n @!.&%\nabc.123.abc.~!@#$%^&*()_+;'/.?\nabc.123.abc.~!@#$%^&*()_+;'/.?\nabc.123.abc.~!@#$%^&*()_+;'/.?\n\n\n\n\n\n\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96\n @!.&%\n @!.&%\n @!.&%\nabc.123.abc\nabc.123.abc\nabc.123.abc\n\n\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0101-rt-String-ToLowerCaseTest/StringToLowerCaseTest.java b/test/testsuite/ouroboros/string_test/RT0101-rt-String-ToLowerCaseTest/StringToLowerCaseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4901cf88f94972ecb754d0af2f1960a45b91bf3c
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0101-rt-String-ToLowerCaseTest/StringToLowerCaseTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringToLowerCaseTest.java
+ * -@TestCaseName: Test String Method: public String toLowerCase().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method toLowerCase().
+ * -#step3: Check the result get correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringToLowerCaseTest.java
+ * -@ExecuteClass: StringToLowerCaseTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringToLowerCaseTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringToLowerCaseTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringToLowerCaseTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc.~!@#$%^&*()_+;'/.?");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.toLowerCase());
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96\n @!.&%\nabc.123.abc.~!@#$%^&*()_+;'/.?\n\n\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96\n @!.&%\nabc.123.abc\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/StringToUpperCaseLocaleTest.java b/test/testsuite/ouroboros/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/StringToUpperCaseLocaleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..14d8e4abc0e456bc7935cbfa8c8f16be6236d243
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/StringToUpperCaseLocaleTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringToUpperCaseLocaleTest.java
+ * -@TestCaseName: Test String Method: public String toUpperCase(Locale locale).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Create Parameters: Create locale random choose three country.
+ * -#step3: Test method toUpperCase(Locale locale).
+ * -#step4: Check the result get correctly.
+ * -#step5: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringToUpperCaseLocaleTest.java
+ * -@ExecuteClass: StringToUpperCaseLocaleTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+import java.util.Locale;
+
+public class StringToUpperCaseLocaleTest {
+    private static int processResult = 99;
+
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringToUpperCaseLocaleTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringToUpperCaseLocaleTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc.~!@#$%^&*()_+;'/.?");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.toUpperCase(Locale.CHINESE));
+        System.out.println(str.toUpperCase(Locale.ENGLISH));
+        System.out.println(str.toUpperCase(Locale.FRENCH));
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full QWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96\nQWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96\nQWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96\n @!.&%\n @!.&%\n @!.&%\nABC.123.ABC.~!@#$%^&*()_+;'/.?\nABC.123.ABC.~!@#$%^&*()_+;'/.?\nABC.123.ABC.~!@#$%^&*()_+;'/.?\n\n\n\n\n\n\nQWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96\nQWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96\nQWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96\n @!.&%\n @!.&%\n @!.&%\nABC.123.ABC\nABC.123.ABC\nABC.123.ABC\n\n\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0103-rt-String-ToUpperCaseTest/StringToUpperCaseTest.java b/test/testsuite/ouroboros/string_test/RT0103-rt-String-ToUpperCaseTest/StringToUpperCaseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4bbc61612f1aac11d526387adccf2fc38b961a4
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0103-rt-String-ToUpperCaseTest/StringToUpperCaseTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringToUpperCaseTest.java
+ * -@TestCaseName: Test String Method: public String toUpperCase().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method toUpperCase().
+ * -#step3: Check the result get correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringToUpperCaseTest.java
+ * -@ExecuteClass: StringToUpperCaseTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringToUpperCaseTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringToUpperCaseTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringToUpperCaseTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc.~!@#$%^&*()_+;'/.?");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str.toUpperCase());
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full QWERTYUIOP{}[]\\|ASDFGHJKL;:\'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96\n @!.&%\nABC.123.ABC.~!@#$%^&*()_+;\'/.?\n\n\nQWERTYUIOP{}[]\\|ASDFGHJKL;:\'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96\n @!.&%\nABC.123.ABC\n\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0104-rt-String-TrimTest/StringTrimTest.java b/test/testsuite/ouroboros/string_test/RT0104-rt-String-TrimTest/StringTrimTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..822c510acd26b63118b7fbe916c6380279e28967
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0104-rt-String-TrimTest/StringTrimTest.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringTrimTest.java
+ * -@TestCaseName: Test String Method: public String trim().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method trim().
+ * -#step3: Check the result get correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols(include\t、\n、\f、\b、\r、\、\\、
+ *          \" )/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringTrimTest.java
+ * -@ExecuteClass: StringTrimTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringTrimTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringTrimTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringTrimTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String(" abc.123.abc ");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = " abc.123.ABC ";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+
+        char data3_1[] = {'\t', 'a', 'b', 'c', '\t'};
+        String str3_1 = new String(data3_1);
+        test(str3_1);
+
+        char data3_2[] = {'\n', 'A', 'B', 'C', '\n'};
+        String str3_2 = new String(data3_2);
+        test(str3_2);
+
+        char data3_3[] = {'\f', 'a', 'b', 'c', '\f'};
+        String str3_3 = new String(data3_3);
+        test(str3_3);
+
+
+        char data3_4[] = {'\b', 'A', 'B', 'C', '\b'};
+        String str3_4 = new String(data3_4);
+        test(str3_4);
+
+        char data3_5[] = {'\r', 'a', 'b', 'c', '\r'};
+        String str3_5 = new String(data3_5);
+        test(str3_5);
+
+        char data3_6[] = {'\'', 'A', 'B', 'C', '\''};
+        String str3_6 = new String(data3_6);
+        test(str3_6);
+
+        char data3_7[] = {'\\', 'a', 'b', 'c', '\\'};
+        String str3_7 = new String(data3_7);
+        test(str3_7);
+
+
+        char data3_8[] = {'\"', 'A', 'B', 'C', '\"'};
+        String str3_8 = new String(data3_8);
+        test(str3_8);
+    }
+
+    private static void test(String str) {
+        System.out.println(str);
+        System.out.println(str.trim());
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n@!.&%\n abc.123.abc \nabc.123.abc\n\n\n\n\nqwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n@!.&%\n abc.123.ABC \nabc.123.ABC\n\n\n\tabc\t\nabc\n\nABC\n\nABC\n\x0cabc\x0c\nabc\n\x08ABC\x08\nABC\n\rabc\r\nabc\n\'ABC\'\n\'ABC\'\n\\abc\\\n\\abc\\\n"ABC"\n"ABC"\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0105-rt-String-ToStringTest/StringToStringTest.java b/test/testsuite/ouroboros/string_test/RT0105-rt-String-ToStringTest/StringToStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..093d4ce94425f21af1d28391d7a6a24908821a1e
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0105-rt-String-ToStringTest/StringToStringTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringToStringTest.java
+ * -@TestCaseName: Test String Method: public String toString().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method toString().
+ * -#step3: Check the result get correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -#step5: Create String instance by char[].
+ * -#step6: Test method toString(), check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringToStringTest.java
+ * -@ExecuteClass: StringToStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringToStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringToStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringToStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+
+        //new String() input : byte[], char[], StringBuffer, StringBuilder, String, int[](ASCII)
+        //byte[] char[] must USE new String
+        char data3_1[] = {0x61, 0x62, 0x63};
+        String str3_1 = new String(data3_1);
+        System.out.println(str3_1);
+        System.out.println(str3_1.toString());
+    }
+
+    private static void test(String str) {
+        System.out.println(str.toString());
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\nabc123abc\n\n\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\nabc123ABC\n\nabc\nabc\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0106-rt-String-ToCharArrayTest/StringToCharArrayTest.java b/test/testsuite/ouroboros/string_test/RT0106-rt-String-ToCharArrayTest/StringToCharArrayTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..221c7a134c28b452ebd6094ad6ffd8ff9ed09b00
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0106-rt-String-ToCharArrayTest/StringToCharArrayTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringToCharArrayTest.java
+ * -@TestCaseName: Test String Method: public char[] toCharArray().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance.
+ * -#step2: Test method toString().
+ * -#step3: Check the result get correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringToCharArrayTest.java
+ * -@ExecuteClass: StringToCharArrayTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringToCharArrayTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringToCharArrayTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringToCharArrayTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc\n123\nabc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        System.out.println(str);
+        char[] ch1 = str.toCharArray();
+        System.out.println("ch1 length: " + ch1.length);
+        System.out.println(ch1);
+        System.out.println(new String(ch1));
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nch1 length: 99\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\nch1 length: 6\n @!.&%\n @!.&%\nabc\n123\nabc\nch1 length: 11\nabc\n123\nabc\nabc\n123\nabc\n\nch1 length: 0\n\n\n\nch1 length: 0\n\n\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nch1 length: 99\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\nch1 length: 6\n @!.&%\n @!.&%\nabc123ABC\nch1 length: 9\nabc123ABC\nabc123ABC\n\nch1 length: 0\n\n\n0\n
diff --git a/test/testsuite/ouroboros/string_test/RT0107-rt-String-FormatStringObjectTest/StringFormatStringObjectTest.java b/test/testsuite/ouroboros/string_test/RT0107-rt-String-FormatStringObjectTest/StringFormatStringObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..515d7290bf32437ce2c30897db987433610841e9
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0107-rt-String-FormatStringObjectTest/StringFormatStringObjectTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringFormatStringObjectTest.java
+ * -@TestCaseName: Test String Method: public static String format(String format, Object... args).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *
+ * -@Brief:
+ * -#step1: Create String instance as parameter args.
+ * -#step2: Create Parameters: format is a format string as %s.
+ * -#step3: Test method format(String format, Object... args).
+ * -#step4: Check the result get correctly.
+ * -#step5: Change instance as one or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -#step6: Create Parameters: format is a format string as %c %n, args is 'A'.
+ * -#step7: Test method format(String format, Object... args), check the result get correctly.
+ * -#step8: Create Parameters: format is a format string as %b %n, args Is an expression whose result is true/false.
+ * -#step9: Test method format(String format, Object... args), check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringFormatStringObjectTest.java
+ * -@ExecuteClass: StringFormatStringObjectTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringFormatStringObjectTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringFormatStringObjectTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringFormatStringObjectTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+
+        String str3_1 = null;
+        str3_1 = String.format("%c %n", 'A');
+        System.out.println(str3_1);
+        str3_1 = String.format("%b %n", 3 > 7);
+        System.out.println(str3_1);
+        str3_1 = String.format("%b %n", 3 < 7);
+        System.out.println(str3_1);
+    }
+
+    private static void test(String str) {
+        String test1 = null;
+        test1 = String.format("%s", str);
+        System.out.println(test1);
+        test1 = String.format("%s %s %s", str, str, str);
+        System.out.println(test1);    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96 qwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96 qwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n @!.&%  @!.&%  @!.&%\nabc123abc\nabc123abc abc123abc abc123abc\n\n  \n\n  \nqwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96 qwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96 qwertyuiop{}[]\\|asdfghjkl;:\'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\n @!.&%  @!.&%  @!.&%\nabc123ABC\nabc123ABC abc123ABC abc123ABC\n\n  \nA \n\nfalse \n\ntrue \n\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0108-rt-String-ValueOfObjectTest/StringValueOfObjectTest.java b/test/testsuite/ouroboros/string_test/RT0108-rt-String-ValueOfObjectTest/StringValueOfObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b19b0fe9a4de04462f17a82bdf105bfec9f769d5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0108-rt-String-ValueOfObjectTest/StringValueOfObjectTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfObjectTest.java
+ * -@TestCaseName: Test String Method: public static String valueOf(Object obj).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance as parameter obj.
+ * -#step2: Test method valueOf(Object obj).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change instance as one or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfObjectTest.java
+ * -@ExecuteClass: StringValueOfObjectTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfObjectTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringValueOfObjectTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringValueOfObjectTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        String str2_5 = null;
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        test(str2_5);
+    }
+
+    private static void test(Object obj) {
+        System.out.println(String.valueOf(obj));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\nabc123abc\n\n\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\n @!.&%\nabc123ABC\n\nnull\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0109-rt-String-ValueOfCharsTest/StringValueOfCharsTest.java b/test/testsuite/ouroboros/string_test/RT0109-rt-String-ValueOfCharsTest/StringValueOfCharsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b72e38f11fe955ad9dffe3af99adaa0a0cabc78
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0109-rt-String-ValueOfCharsTest/StringValueOfCharsTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfCharsTest.java
+ * -@TestCaseName: Test String Method: public static String valueOf(char[] data).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create char[] instance as parameter data.
+ * -#step2: Test method valueOf(char[] data).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change data as the char array member type traversal letter, number Contains decimal、 hexadecimal、unix,
+ *          empty to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfCharsTest.java
+ * -@ExecuteClass: StringValueOfCharsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfCharsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringValueOfCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringValueOfCharsTest_1() {
+        char[] ch1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        char[] ch1_2 = {0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        char[] ch1_3 = {'\u0061', '\u0062', '\u0063', '\u0031', '\u0032', '\u0033'};
+        char[] ch1_4 = {0x0061, 0x0062, 0x0063, 0x0031, 0x0032, 0x0033};
+        char[] ch1_5 = {};
+
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+        test(ch1_5);
+    }
+
+    private static void test(char[] ch1_1) {
+        System.out.println(String.valueOf(ch1_1));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123\nabc123\nabc123\nabc123\n\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0110-rt-String-ValueOfCharIntIntTest/StringValueOfCharIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0110-rt-String-ValueOfCharIntIntTest/StringValueOfCharIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..54b47cbcd0c37a98d262508212203efdcc552389
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0110-rt-String-ValueOfCharIntIntTest/StringValueOfCharIntIntTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfCharIntIntTest.java
+ * -@TestCaseName: Test String Method: public static String valueOf(char[] data, int offset, int count).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create char[] instance as parameter data.
+ * -#step2: Create other parameters: 0 =< offset < data.length, 0 =< count <= data.length, offset/count cover boundary
+ *          value.
+ * -#step3: Test method valueOf(char[] data, int offset, int count).
+ * -#step4: Check the result get correctly.
+ * -#step5: Change data as the char array member type traversal letter, number Contains decimal、 hexadecimal、unix,
+ *          empty to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfCharIntIntTest.java
+ * -@ExecuteClass: StringValueOfCharIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfCharIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringValueOfCharIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringValueOfCharIntIntTest_1() {
+        char ch1_1[] = {'a', 'b', 'c', '1', '2', '3'};
+        char ch1_2[] = {0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        char ch1_3[] = {'\u0061', '\u0062', '\u0063', '\u0031', '\u0032', '\u0033'};
+        char ch1_4[] = {0x0061, 0x0062, 0x0063, 0x0031, 0x0032, 0x0033};
+
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+    }
+
+    private static void test(char[] ch1_1) {
+        System.out.println(String.valueOf(ch1_1, 1, 3));
+        // Test offset = 0.
+        System.out.println(String.valueOf(ch1_1, 0, 3));
+        // Test count = 0.
+        System.out.println(String.valueOf(ch1_1, 1, 0));
+        // Test count = ch1_1.length.
+        System.out.println(String.valueOf(ch1_1, 0, ch1_1.length));
+        // Test offset = ch1_1.length - 1.
+        System.out.println(String.valueOf(ch1_1, ch1_1.length - 1, 1));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full bc1\nabc\n\nabc123\n3\nbc1\nabc\n\nabc123\n3\nbc1\nabc\n\nabc123\n3\nbc1\nabc\n\nabc123\n3\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/StringCopyValueOfCharIntIntTest.java b/test/testsuite/ouroboros/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/StringCopyValueOfCharIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..576a321e0561c148c53a3013106022a46b2b022a
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/StringCopyValueOfCharIntIntTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCopyValueOfCharIntIntTest.java
+ * -@TestCaseName: Test String Method: public static String copyValueOf(char[] data, int offset, int count).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create char[] instance as parameter data.
+ * -#step2: Create other parameters: 0 =< offset < data.length, 0 =< count <= data.length, offset/count cover boundary
+ *          value.
+ * -#step3: Test method copyValueOf(char[] data, int offset, int count).
+ * -#step4: Check the result get correctly.
+ * -#step5: Change data as the char array member type traversal letter, number Contains decimal、 hexadecimal、unix,
+ *          empty to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCopyValueOfCharIntIntTest.java
+ * -@ExecuteClass: StringCopyValueOfCharIntIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCopyValueOfCharIntIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringCopyValueOfCharIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCopyValueOfCharIntIntTest_1() {
+        char ch1_1[] = {'a', 'b', 'c', '1', '2', '3'};
+        char ch1_2[] = {0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        char ch1_3[] = {'\u0061', '\u0062', '\u0063', '\u0031', '\u0032', '\u0033'};
+        char ch1_4[] = {0x0061, 0x0062, 0x0063, 0x0031, 0x0032, 0x0033};
+
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+    }
+
+    private static void test(char[] ch1_1) {
+        System.out.println(String.copyValueOf(ch1_1, 1, 3));
+        // Test offset = 0.
+        System.out.println(String.copyValueOf(ch1_1, 0, 3));
+        // Test count = 0.
+        System.out.println(String.copyValueOf(ch1_1, 1, 0));
+        // Test count = ch1_1.length.
+        System.out.println(String.copyValueOf(ch1_1, 0, ch1_1.length));
+        // Test offset = ch1_1.length - 1.
+        System.out.println(String.copyValueOf(ch1_1, ch1_1.length - 1, 1));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full bc1\nabc\n\nabc123\n3\nbc1\nabc\n\nabc123\n3\nbc1\nabc\n\nabc123\n3\nbc1\nabc\n\nabc123\n3\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0112-rt-String-CopyValueOfCharTest/StringCopyValueOfCharTest.java b/test/testsuite/ouroboros/string_test/RT0112-rt-String-CopyValueOfCharTest/StringCopyValueOfCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a1e83655c3e2f13ea2db3fbd065c230ad7644fd
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0112-rt-String-CopyValueOfCharTest/StringCopyValueOfCharTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCopyValueOfCharTest.java
+ * -@TestCaseName: Test String Method: public static String copyValueOf(char[] data).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create char[] instance as parameter data.
+ * -#step2: Test method copyValueOf(char[] data).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change data as the char array member type traversal letter, number Contains decimal、 hexadecimal、unix,
+ *          empty to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCopyValueOfCharTest.java
+ * -@ExecuteClass: StringCopyValueOfCharTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCopyValueOfCharTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringCopyValueOfCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCopyValueOfCharTest_1() {
+        char ch1_1[] = {'a', 'b', 'c', '1', '2', '3'};
+        char ch1_2[] = {0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        char ch1_3[] = {'\u0061', '\u0062', '\u0063', '\u0031', '\u0032', '\u0033'};
+        char ch1_4[] = {0x0061, 0x0062, 0x0063, 0x0031, 0x0032, 0x0033};
+
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+    }
+
+    private static void test(char[] ch) {
+        System.out.println(String.copyValueOf(ch));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc123\nabc123\nabc123\nabc123\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0113-rt-String-ValueOfBooleanTest/StringValueOfBooleanTest.java b/test/testsuite/ouroboros/string_test/RT0113-rt-String-ValueOfBooleanTest/StringValueOfBooleanTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa1ea4d11b9e92f6a710b37bcabcc76322cbc525
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0113-rt-String-ValueOfBooleanTest/StringValueOfBooleanTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfBooleanTest.java
+ * -@TestCaseName: Test String Method: public static String valueOf(boolean b).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create boolean instance as parameter b.
+ * -#step2: Test method valueOf(boolean b).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change b as the boolean instance traversal true/false expression to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfBooleanTest.java
+ * -@ExecuteClass: StringValueOfBooleanTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfBooleanTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringValueOfBooleanTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringValueOfBooleanTest_1() {
+        boolean bo1_1 = 3 > 7;
+        boolean bo1_2 = 9 > 7;
+
+        test(bo1_1);
+        test(bo1_2);
+    }
+
+    private static void test(boolean bo) {
+        System.out.println(String.valueOf(bo));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full false\ntrue\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0114-rt-String-ValueOfCharTest/StringValueOfCharTest.java b/test/testsuite/ouroboros/string_test/RT0114-rt-String-ValueOfCharTest/StringValueOfCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fdf64d3a0d06a316f8774f93ad66ebaea99b41cf
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0114-rt-String-ValueOfCharTest/StringValueOfCharTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfCharTest.java
+ * -@TestCaseName: Test String Method: public static String valueOf(char c).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create char instance as parameter c.
+ * -#step2: Test method valueOf(char c).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change c as char instance traversal letter, number Contains decimal、 hexadecimal、unix to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfCharTest.java
+ * -@ExecuteClass: StringValueOfCharTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfCharTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringValueOfCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringValueOfCharTest_1() {
+        char ch1_1 = 'a';
+        char ch1_2 = 0x61;
+        char ch1_3 = '\u0061';
+        char ch1_4 = 0x0061;
+
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+    }
+
+    private static void test(char ch) {
+        System.out.println(String.valueOf(ch));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full a\na\na\na\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0115-rt-String-ValueOfIntTest/StringValueOfIntTest.java b/test/testsuite/ouroboros/string_test/RT0115-rt-String-ValueOfIntTest/StringValueOfIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..054b5b0e5dd8d58c8f156af9b6465c0d297ed4ac
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0115-rt-String-ValueOfIntTest/StringValueOfIntTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfIntTest.java
+ * -@TestCaseName: Test String Method: public static String valueOf(int i).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create int instance as parameter i.
+ * -#step2: Test method valueOf(int i).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change i as int instance traversal number to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfIntTest.java
+ * -@ExecuteClass: StringValueOfIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringValueOfIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringValueOfIntTest_1() {
+        int in1_1 = 0;
+        int in1_2 = 12;
+
+        test(in1_1);
+        test(in1_2);
+    }
+
+    private static void test(int in) {
+        String test = String.valueOf(in);
+        System.out.println(test);
+        System.out.println(test + 13);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n013\n12\n1213\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0116-rt-String-ValueOfLongTest/StringValueOfLongTest.java b/test/testsuite/ouroboros/string_test/RT0116-rt-String-ValueOfLongTest/StringValueOfLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..202dd1843169ff9afe810b257e3fac5baff9dfd1
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0116-rt-String-ValueOfLongTest/StringValueOfLongTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfLongTest.java
+ * -@TestCaseName: Test String Method: public static String valueOf(long l).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create long instance as parameter l.
+ * -#step2: Test method valueOf(long l).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change l as long instance traversal long number to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfLongTest.java
+ * -@ExecuteClass: StringValueOfLongTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfLongTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringValueOfLongTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringValueOfLongTest_1() {
+        long long1_1 = 0;
+        long long1_2 = 1234567890;
+
+        test(long1_1);
+        test(long1_2);
+    }
+
+    private static void test(long lo) {
+        String test = String.valueOf(lo);
+        System.out.println(test);
+        System.out.println(test + 13);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n013\n1234567890\n123456789013\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0117-rt-String-ValueOfFloatTest/StringValueOfFloatTest.java b/test/testsuite/ouroboros/string_test/RT0117-rt-String-ValueOfFloatTest/StringValueOfFloatTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc7b4af65faba1bd96a1b1e33f52897b2c1e7ffb
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0117-rt-String-ValueOfFloatTest/StringValueOfFloatTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfFloatTest.java
+ * -@TestCaseName: Test String Method: public static String valueOf(float f).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create long instance as parameter f.
+ * -#step2: Test method valueOf(float f).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change f as float instance traversal float number to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfFloatTest.java
+ * -@ExecuteClass: StringValueOfFloatTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfFloatTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringValueOfFloatTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringValueOfFloatTest_1() {
+        float fl1_1 = 0;
+        float fl1_2 = (float) 13.0;
+
+        test(fl1_1);
+        test(fl1_2);
+    }
+
+    private static void test(float fl) {
+        String test = String.valueOf(fl);
+        System.out.println(test);
+        System.out.println(test + 13);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0.0\n0.013\n13.0\n13.013\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0118-rt-String-ValueOfDoubleTest/StringValueOfDoubleTest.java b/test/testsuite/ouroboros/string_test/RT0118-rt-String-ValueOfDoubleTest/StringValueOfDoubleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ca8342b513ab0b07855fb2cfe0770396f22a563
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0118-rt-String-ValueOfDoubleTest/StringValueOfDoubleTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringValueOfDoubleTest.java
+ * -@TestCaseName: Test String Method: public static String valueOf(double d).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create double instance as parameter d.
+ * -#step2: Test method valueOf(double d).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change d as double instance traversal double number to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringValueOfDoubleTest.java
+ * -@ExecuteClass: StringValueOfDoubleTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringValueOfDoubleTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringValueOfDoubleTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringValueOfDoubleTest_1() {
+        double d1_1 = 0;
+        double d1_2 = 1.23;
+
+        test(d1_1);
+        test(d1_2);
+    }
+
+    private static void test(double d) {
+        String test = String.valueOf(d);
+        System.out.println(test);
+        System.out.println(test + 13);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0.0\n0.013\n1.23\n1.2313\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0119-rt-String-InternTest/StringInternTest.java b/test/testsuite/ouroboros/string_test/RT0119-rt-String-InternTest/StringInternTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ebdb3a56e01a7089a2aa7f77340a47248b170132
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0119-rt-String-InternTest/StringInternTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringInternTest.java
+ * -@TestCaseName: Test String Method: public String intern().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance as some letters.
+ * -#step2: Test method intern().
+ * -#step3: Check the result get correctly by compare with Various forms of strings.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringInternTest.java
+ * -@ExecuteClass: StringInternTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+
+public class StringInternTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            result = result-StringInternTest_1(); // 2-1=1
+        } catch (Exception e) {
+            System.out.println(e);
+            StringInternTest.processResult = StringInternTest.processResult - 10;
+        }
+
+        if (result == 1 && StringInternTest.processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+
+    public static  int StringInternTest_1() {
+        int result1 = 4; /* STATUS_FAILED */
+        String str1 = "a";
+        String str2 = "b";
+        String str3 = "ab";
+        String str4 = str1 + str2;
+        String str5 = new String("ab");
+        String str6 = "a" + "b";
+        String str7 = "a" + str2;
+        String str8 = new String("ab");
+        if (str5.intern() == str3 && str5.intern() != str4 && str5.intern() == str6 && str5.intern() != str7
+                && str5.intern() == str8.intern()) {
+            StringInternTest.processResult = StringInternTest.processResult - 1;
+            return 1;
+        }
+        StringInternTest.processResult = StringInternTest.processResult - 10;
+        return result1;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0120-rt-String-VoluationTest/StringVoluationTest.java b/test/testsuite/ouroboros/string_test/RT0120-rt-String-VoluationTest/StringVoluationTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f93712ba5f0505e5d3ef766caea1a74a51ab7dcd
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0120-rt-String-VoluationTest/StringVoluationTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringVoluationTest.java
+ * -@TestCaseName: Test String create type by direct voluation.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String by = "String".
+ * -#step1: Check create string is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringVoluationTest.java
+ * -@ExecuteClass: StringVoluationTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringVoluationTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringVoluationTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringVoluationTest_1() {
+        String str1 = "abc";
+        System.out.println(str1);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0121-rt-String-VoluationCharsTest/StringVoluationCharsTest.java b/test/testsuite/ouroboros/string_test/RT0121-rt-String-VoluationCharsTest/StringVoluationCharsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..41224a196275be11546bd4de17024bf4267b4939
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0121-rt-String-VoluationCharsTest/StringVoluationCharsTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringVoluationCharsTest.java
+ * -@TestCaseName: Test String create type by new String(char[] value).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameter: the element of value is some letter.
+ * -#step2: Test constructor String(char[] value).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change the element of value is ascii num to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringVoluationCharsTest.java
+ * -@ExecuteClass: StringVoluationCharsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringVoluationCharsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringVoluationCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringVoluationCharsTest_1() {
+        char[] data2 = {'a', 'b', 'c'};
+        String str2 = new String(data2);
+        char[] data3 = {0x61, 0x62, 0x63};
+        String str3 = new String(data3);
+        String str4 = new String("abc");
+
+        System.out.println(str2);
+        System.out.println(str3);
+        System.out.println(str4);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full abc\nabc\nabc\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0122-rt-String-SpliceStringTest/StringSpliceStringTest.java b/test/testsuite/ouroboros/string_test/RT0122-rt-String-SpliceStringTest/StringSpliceStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..331b2559ea72e801a18cc8f0e6fa04bada6fc33f
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0122-rt-String-SpliceStringTest/StringSpliceStringTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringSpliceStringTest.java
+ * -@TestCaseName: Create String by one string + another string.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance str.
+ * -#step2: Test Create String by str + str, str + another string.
+ * -#step3: Check get the result correctly.
+ * -#step4: Change instance as One or more kinds of letters, numbers, special symbols/""/NoParam/null to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringSpliceStringTest.java
+ * -@ExecuteClass: StringSpliceStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringSpliceStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringSpliceStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringSpliceStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        String str2_5 = null;
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        test(str2_5);
+    }
+
+    private static void test(String str) {
+        String test1_1 = "test" + str;
+        String test1_2 = str + str;
+        System.out.println(test1_1);
+        System.out.println(test1_2);
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full testqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ntest @!.&%\n @!.&% @!.&%\ntestabc123\nabc123abc123\ntest\n\ntest\n\ntestqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\nqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96\ntest @!.&%\n @!.&% @!.&%\ntestabc123\nabc123abc123\ntest\n\ntestnull\nnullnull\n0\n
+
diff --git a/test/testsuite/ouroboros/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/StringCompareByDoubleEqualSignTest.java b/test/testsuite/ouroboros/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/StringCompareByDoubleEqualSignTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f134796ef30f60aba0c27f035e6d24b96e92d48
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/StringCompareByDoubleEqualSignTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCompareByDoubleEqualSignTest.java
+ * -@TestCaseName: User == compare strings.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance str1, str2.
+ * -#step2: Compare two strings with expression ==.
+ * -#step4: Check the result get correctly.
+ * -#step5: Change instance str2 as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCompareByDoubleEqualSignTest.java
+ * -@ExecuteClass: StringCompareByDoubleEqualSignTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCompareByDoubleEqualSignTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringCompareByDoubleEqualSignTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCompareByDoubleEqualSignTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        String str2_5 = null;
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        test(str2_5);
+    }
+
+    private static void test(String str) {
+        String test1_1 = "abc123ABC";
+        if (test1_1 == str) {
+            System.out.println("str == abc123abc");
+        } else {
+            System.out.println("str1 !");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full str1 !\nstr1 !\nstr1 !\nstr1 !\nstr1 !\nstr1 !\nstr1 !\nstr == abc123abc\nstr1 !\nstr1 !\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0124-rt-String-CompareByEqualsTest/StringCompareByEqualsTest.java b/test/testsuite/ouroboros/string_test/RT0124-rt-String-CompareByEqualsTest/StringCompareByEqualsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..73757c0f31361a9a2929e3c303fa8de5759bf499
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0124-rt-String-CompareByEqualsTest/StringCompareByEqualsTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCompareByEqualsTest.java
+ * -@TestCaseName: User equals(Object anObject) compare strings.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance str1, str2.
+ * -#step2: Compare two strings by method equals(Object str1).
+ * -#step4: Check the result get correctly.
+ * -#step5: Change instance str2 as One or more kinds of letters, numbers, special symbols/""/NoParam to repeat step2~4.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCompareByEqualsTest.java
+ * -@ExecuteClass: StringCompareByEqualsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCompareByEqualsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringCompareByEqualsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCompareByEqualsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+
+    private static void test(String str) {
+        String test1_1 = "abc123abc";
+        if (str.equals(test1_1)) {
+            System.out.println("str == abc123abc");
+        } else {
+            System.out.println("str1 !");
+        }
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full str1 !\nstr1 !\nstr == abc123abc\nstr1 !\nstr1 !\nstr1 !\nstr1 !\nstr1 !\nstr1 !\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0125-rt-String-ConvertToByteTest/StringConvertToByteTest.java b/test/testsuite/ouroboros/string_test/RT0125-rt-String-ConvertToByteTest/StringConvertToByteTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5ad99cef877d1480fc3f3292abc0def68035d605
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0125-rt-String-ConvertToByteTest/StringConvertToByteTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConvertToByteTest.java
+ * -@TestCaseName: Change String type to byte, test method of Byte: static byte parseByte(String s, int radix).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameter s, assign values to String's s1, s2.
+ * -#step2: Create Parameter radix, assign values to int r1, r2, their values represent octal and hexadecimal.
+ * -#step3: Test method parseByte(String s, int radix).
+ * -#step4: Check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConvertToByteTest.java
+ * -@ExecuteClass: StringConvertToByteTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConvertToByteTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringConvertToByteTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Test public static byte parseByte(String s).
+    public static void StringConvertToByteTest_1() {
+        // Create 2 byte primitives bt1, bt2.
+        byte b_1, b_2;
+        // Create and assign values to String's s1, s2.
+        String s1 = "123";
+        String s2 = "-1a";
+        // Create and assign values to int r1, r2.
+        int r1 = 8;  // Represents octal.
+        int r2 = 16; // Represents hexadecimal.
+        b_1 = Byte.parseByte(s1, r1);
+        b_2 = Byte.parseByte(s2, r2);
+        String str1_1 = s1 + " convert(8) to Byte:" + b_1;
+        String str1_2 = s2 + " convert(16) to Byte:" + b_2;
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 123 convert(8) to Byte:83\n-1a convert(16) to Byte:-26\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0126-rt-String-ConvertToShortTest/StringConvertToShortTest.java b/test/testsuite/ouroboros/string_test/RT0126-rt-String-ConvertToShortTest/StringConvertToShortTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f13c573525205137801a15311b8ba240d72b9888
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0126-rt-String-ConvertToShortTest/StringConvertToShortTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConvertToShortTest.java
+ * -@TestCaseName: Change String type to short, test method of Short: public static short parseShort(String s).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameter s, assign values to String's s.
+ * -#step2: Test method parseShort(String s).
+ * -#step3: Check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConvertToShortTest.java
+ * -@ExecuteClass: StringConvertToShortTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConvertToShortTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringConvertToShortTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Test public static short parseShort(String s).
+    public static void StringConvertToShortTest_1() {
+        String str1 = "04320";
+        short s_1 = Short.parseShort(str1);
+        System.out.println(s_1);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 4320\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0127-rt-String-ConvertToIntTest/StringConvertToIntTest.java b/test/testsuite/ouroboros/string_test/RT0127-rt-String-ConvertToIntTest/StringConvertToIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..215b73a10d1bfd4ce030e715f098d91588faf2f9
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0127-rt-String-ConvertToIntTest/StringConvertToIntTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConvertToIntTest.java
+ * -@TestCaseName: Change String type to int, test method of Integer: static int parseInt(String s), static int
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      parseInt(String s, int radix).
+ * -@Brief:
+ * -#case1
+ * -#step1: Create Parameter s, assign values to String's s.
+ * -#step2: Test method parseInt(String s).
+ * -#step3: Check the result get correctly.
+ * -#case2
+ * -#step1: Create Parameter s, assign values to String's s, radix is 8 represents octal.
+ * -#step2: Test method parseInt(String s, int radix).
+ * -#step3: Check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConvertToIntTest.java
+ * -@ExecuteClass: StringConvertToIntTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConvertToIntTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringConvertToIntTest_1();
+            StringConvertToIntTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Test static int parseInt(String s).
+    public static void StringConvertToIntTest_1() {
+        int i_1 = Integer.parseInt("1234");
+        System.out.println("convert(10) to int: " + i_1);
+    }
+
+    // Test static int parseInt(String s, int radix).
+    public static void StringConvertToIntTest_2() {
+        int i_2 = Integer.parseInt("1234", 8);
+        System.out.println("convert(8) to int: " + i_2);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full convert(10) to int: 1234\nconvert(8) to int: 668\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0128-rt-String-ConvertToLongTest/StringConvertToLongTest.java b/test/testsuite/ouroboros/string_test/RT0128-rt-String-ConvertToLongTest/StringConvertToLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..67f5b6e0b5a10e0790c981f1a9996ebc458af9b1
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0128-rt-String-ConvertToLongTest/StringConvertToLongTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConvertToLongTest.java
+ * -@TestCaseName: Change String type to long, test method of Long: static long parseLong(String s),
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      static long parseLong(String s, int radix).
+ * -@Brief:
+ * -#step1: Create Parameter s, assign values to String's s, radix is 10 represents Decimal.
+ * -#step2: Test method parseInt(String s, int radix).
+ * -#step3: Check the result get correctly.
+ * -#step4: Change s as 0, -0, Positive number, negative number, binary number, letters, change radix correspond cover
+ *          10, 16, 2, 27 to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConvertToLongTest.java
+ * -@ExecuteClass: StringConvertToLongTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConvertToLongTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringConvertToLongTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Test public static long parseLong(String s, int radix).
+    public static void StringConvertToLongTest_1() {
+        long l_1 = Long.parseLong("1234", 10);
+        // Test parses the string with specified radix
+        System.out.println(l_1);
+        long l_a = Long.parseLong("0", 10);
+        System.out.println(l_a);
+        long l_b = Long.parseLong("111", 10);
+        System.out.println(l_b);
+        long l_c = Long.parseLong("-0", 10);
+        System.out.println(l_c);
+        long l_d = Long.parseLong("-BB", 16);
+        System.out.println(l_d);
+        long l_e = Long.parseLong("1010110", 2);
+        System.out.println(l_e);
+        long l_f = Long.parseLong("2147483647", 10);
+        System.out.println(l_f);
+        long l_g = Long.parseLong("-2147483648", 10);
+        System.out.println(l_g);
+        long l_h = Long.parseLong("ADMIN", 27);
+        System.out.println(l_h);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 1234\n0\n111\n0\n-187\n86\n2147483647\n-2147483648\n5586836\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0129-rt-String-ConvertToFloatTest/StringConvertToFloatTest.java b/test/testsuite/ouroboros/string_test/RT0129-rt-String-ConvertToFloatTest/StringConvertToFloatTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e5e20c0828718a91b2220bf1c7bd2fec81b2bfd
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0129-rt-String-ConvertToFloatTest/StringConvertToFloatTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConvertToFloatTest.java
+ * -@TestCaseName: Change String type to float, test method of Float: public static float parseFloat(String s).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameter s, assign values to String's s.
+ * -#step2: Test method parseFloat(String s).
+ * -#step3: Check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConvertToFloatTest.java
+ * -@ExecuteClass: StringConvertToFloatTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConvertToFloatTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringConvertToFloatTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Test public static float parseFloat(String s).
+    public static void StringConvertToFloatTest_1() {
+        float f_1 = Float.parseFloat("12.34");
+        System.out.println(f_1);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 12.34\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0130-rt-String-ConvertToDoubleTest/StringConvertToDoubleTest.java b/test/testsuite/ouroboros/string_test/RT0130-rt-String-ConvertToDoubleTest/StringConvertToDoubleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..aaa5b3f97540118d3f67192d081aff1555f20a6f
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0130-rt-String-ConvertToDoubleTest/StringConvertToDoubleTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringConvertToDoubleTest.java
+ * -@TestCaseName: Change String type to double, test method of Double: public static double parseDouble(String s).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameter s, assign values to String's s.
+ * -#step2: Test method parseDouble(String s).
+ * -#step3: Check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringConvertToDoubleTest.java
+ * -@ExecuteClass: StringConvertToDoubleTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringConvertToDoubleTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            StringConvertToDoubleTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Test public static double parseDouble(String s).
+    public static void StringConvertToDoubleTest_1() {
+        double d_1 = Double.parseDouble("1.124");
+        System.out.println(d_1);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 1.124\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0131-rt-String-LongToBinaryStringTest/LongToBinaryStringTest.java b/test/testsuite/ouroboros/string_test/RT0131-rt-String-LongToBinaryStringTest/LongToBinaryStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bfd4c8ca6c68f81437688e44d11a429d6c787060
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0131-rt-String-LongToBinaryStringTest/LongToBinaryStringTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: LongToBinaryStringTest.java
+ * -@TestCaseName: Test method of Long: static String toBinaryString(long i).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create long instance, value cover 0, normal number, bigger number.
+ * -#step2: Test method toBinaryString(long i).
+ * -#step3: Check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: LongToBinaryStringTest.java
+ * -@ExecuteClass: LongToBinaryStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class LongToBinaryStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            LongToBinaryStringTest_1();
+            LongToBinaryStringTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Long.toBinaryString(long l)
+    public static void LongToBinaryStringTest_1() {
+        long l_a = 0L;
+        long l_b = 111L;
+        long l_c = 2147483647L;
+
+        test(l_a);
+        test(l_b);
+        test(l_c);
+    }
+
+    public static void LongToBinaryStringTest_2() {
+        Integer i_a = 0;
+        Integer i_b = 111;
+        Integer i_c = 2147483647;
+
+        test2(i_a);
+        test2(i_b);
+        test2(i_c);
+    }
+
+    private static void test(Long lo) {
+        System.out.println(Long.toBinaryString(lo));
+    }
+
+    private static void test2(Integer i) {
+        System.out.println(Integer.toBinaryString(i));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n1101111\n1111111111111111111111111111111\n0\n1101111\n1111111111111111111111111111111\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0132-rt-String-LongToOctalStringTest/LongToOctalStringTest.java b/test/testsuite/ouroboros/string_test/RT0132-rt-String-LongToOctalStringTest/LongToOctalStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bbcaeda3ba80755a4060de36cb965558dbc841b7
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0132-rt-String-LongToOctalStringTest/LongToOctalStringTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: LongToOctalStringTest.java
+ * -@TestCaseName: Test method of Long: static String toOctalString(long i).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create long instance, value cover 0, normal number, bigger number.
+ * -#step2: Test method toOctalString(long i).
+ * -#step3: Check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: LongToOctalStringTest.java
+ * -@ExecuteClass: LongToOctalStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class LongToOctalStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            LongToOctalStringTest_1();
+            LongToOctalStringTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Long.toOctalString(long l)
+    public static void LongToOctalStringTest_1() {
+        long l_a = 0L;
+        long l_b = 111L;
+        long l_c = 2147483647L;
+
+        test(l_a);
+        test(l_b);
+        test(l_c);
+    }
+
+    public static void LongToOctalStringTest_2() {
+        Integer i_a = 0;
+        Integer i_b = 111;
+        Integer i_c = 2147483647;
+
+        test2(i_a);
+        test2(i_b);
+        test2(i_c);
+    }
+
+    private static void test(Long lo) {
+        System.out.println(Long.toOctalString(lo));
+    }
+
+    private static void test2(Integer i) {
+        System.out.println(Integer.toOctalString(i));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n157\n17777777777\n0\n157\n17777777777\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0133-rt-String-BasicToStringTest/BasicToStringTest.java b/test/testsuite/ouroboros/string_test/RT0133-rt-String-BasicToStringTest/BasicToStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..373d6298bc848b9248713c1c368df5dcd72f3219
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0133-rt-String-BasicToStringTest/BasicToStringTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: BasicToStringTest.java
+ * -@TestCaseName:Test method of Long: static String toString(long i), test method of Integer: static String
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                     toString(int i), test method of Float: static String toString(float f), test method of Double:
+ *                     static String toString(double d).
+ * -@Brief:
+ * -#case1
+ * -#step1: Create long instance, value cover 0, normal number, bigger number.
+ * -#step2: Test method toString(long i).
+ * -#step3: Check the result get correctly.
+ * -#case2
+ * -#step1: Create Integer instance, value cover 0, normal number, bigger number.
+ * -#step2: Test method toString(int i).
+ * -#step3: Check the result get correctly.
+ * -#case3
+ * -#step1: Create float instance, value cover 0, normal number, bigger number.
+ * -#step2: Test method toString(float f).
+ * -#step3: Check the result get correctly.
+ * -#case4
+ * -#step1: Create double instance, value cover 0, normal number, bigger number.
+ * -#step2: Test method toString(double d).
+ * -#step3: Check the result get correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: BasicToStringTest.java
+ * -@ExecuteClass: BasicToStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class BasicToStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            BasicToStringTest_1();
+            BasicToStringTest_2();
+            BasicToStringTest_3();
+            BasicToStringTest_4();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Long.toString(long l, int p)
+    public static void BasicToStringTest_1() {
+        long l_a = 0;
+        long l_b = 111;
+        long l_c = 2147483647;
+
+        test1(l_a);
+        test1(l_b);
+        test1(l_c);
+    }
+
+    public static void BasicToStringTest_2() {
+        Integer i_a = 0;
+        Integer i_b = 111;
+        Integer i_c = 2147483647;
+
+        test2(i_a);
+        test2(i_b);
+        test2(i_c);
+    }
+
+    public static void BasicToStringTest_3() {
+        float f_a = 0f;
+        float f_b = 11.1f;
+        float f_c = 2147483.647f;
+
+        test3(f_a);
+        test3(f_b);
+        test3(f_c);
+    }
+
+    public static void BasicToStringTest_4() {
+        double d_a = 0;
+        double d_b = 1.11d;
+        double d_c = 21474836.47;
+
+        test4(d_a);
+        test4(d_b);
+        test4(d_c);
+    }
+
+    private static void test1(Long lo) {
+        System.out.println(Long.toString(lo));
+    }
+
+    private static void test2(Integer i) {
+        System.out.println(Integer.toString(i));
+    }
+
+    private static void test3(float f) {
+        System.out.println(Float.toString(f));
+    }
+
+    private static void test4(double f) {
+        System.out.println(Double.toString(f));
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n111\n2147483647\n0\n111\n2147483647\n0.0\n11.1\n2147483.8\n0.0\n1.11\n2.147483647E7\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0134-rt-String-NullToStringTest/NullToStringTest.java b/test/testsuite/ouroboros/string_test/RT0134-rt-String-NullToStringTest/NullToStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe8b0448506d52bc1af56c8f775017af8fb78c8e
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0134-rt-String-NullToStringTest/NullToStringTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NullToStringTest.java
+ * -@TestCaseName: Test null to String.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#case1
+ * -#step1: Create int instance, cover 0, normal, null value.
+ * -#step2: Create String by "<" + int instance + ">", check the string create correctly.
+ * -#case2
+ * -#step1: Create String instance, cover "", normal, null value.
+ * -#step2: Create String by "<" + String instance + ">", check the string create correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: NullToStringTest.java
+ * -@ExecuteClass: NullToStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class NullToStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            NullToStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void NullToStringTest_1() {
+        int i1_1 = 0;
+        test1(i1_1);
+        int i1_2 = 123;
+        test1(i1_2);
+        Integer i1_3 = (Integer) null;
+        test3(i1_3);
+
+        String str1_1 = "";
+        test2(str1_1);
+        String str1_2 = "abc";
+        test2(str1_2);
+        String str1_3 = null;
+        test2(str1_3);
+
+        System.out.println((String) null);
+        System.out.println("<" + (String) null + ">");
+    }
+
+    private static void test1(int i) {
+        String str1 = "<" + i + ">";
+        System.out.println("str1 : " + str1);
+    }
+
+    private static void test2(String str) {
+        String str2 = "<" + str + ">";
+        System.out.println("str2 : " + str2);
+    }
+
+    private static void test3(final Integer i) {
+        String str1 = "<" + i + ">";
+        System.out.println("str1 : " + str1);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full str1 : <0>\nstr1 : <123>\nstr1 : <null>\nstr2 : <>\nstr2 : <abc>\nstr2 : <null>\nnull\n<null>\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0135-rt-String-AsciiToStringTest/AsciiToStringTest.java b/test/testsuite/ouroboros/string_test/RT0135-rt-String-AsciiToStringTest/AsciiToStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8589da1b76bb3c51aaba39bb6f12e46a3903224f
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0135-rt-String-AsciiToStringTest/AsciiToStringTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: AsciiToStringTest.java
+ * -@TestCaseName: Test ascii to string By test constructor of String: String(char[] value).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create char[] instance, the element is decimal number.
+ * -#step2: Test constructor of String: String(char[] value).
+ * -#step3: Check the string create correctly.
+ * -#step1: Create char[] instance, the element is hexadecimal number.
+ * -#step2: Test constructor of String: String(char[] value).
+ * -#step3: Check the string create correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: AsciiToStringTest.java
+ * -@ExecuteClass: AsciiToStringTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class AsciiToStringTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+        try {
+            AsciiToStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void AsciiToStringTest_1() {
+        String str1_1 = "a b^c~AB";
+        //10
+        char[] data1_2 = {97, 32, 98, 94, 99, 126, 65, 66};
+        String str1_2 = new String(data1_2);
+        //16
+        char[] data1_3 = {0x61, 0x20, 0x62, 0x5E, 0x63, 0x7E, 0x41, 0x42};
+        String str1_3 = new String(data1_3);
+
+        test1(str1_1);
+        test1(str1_2);
+        test1(str1_3);
+    }
+
+    private static void test1(String str) {
+        System.out.println(str);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full a b^c~AB\na b^c~AB\na b^c~AB\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0136-rt-String-ToHexStringCharTest/StringToHexStringCharTest.java b/test/testsuite/ouroboros/string_test/RT0136-rt-String-ToHexStringCharTest/StringToHexStringCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..3fc1bc023eadfdb6898382aab159813deca18879
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0136-rt-String-ToHexStringCharTest/StringToHexStringCharTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringToHexStringCharTest.java
+ * -@TestCaseName: Test method toHesString(char ch).
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create Parameters: Parameters should be Char type.
+ * -#step2: Test method toHesString(char ch).
+ * -#step3: Check the return String is correct.
+ * -#step4: Replace instance or string which consists of one or more of the following: letters, numbers Contains decimal
+ *          and hexadecimal, special symbols, Chinese characters, unicode, then to repeat step2~3.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringToHexStringCharTest.java
+ * -@ExecuteClass: StringToHexStringCharTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringToHexStringCharTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringToHexStringCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringToHexStringCharTest_1() {
+        // 0x00~0x7F.
+        String str1_1 = "a b^c~AB";
+        //10
+        char data1_2[] = {97, 32, 98, 94, 99, 126, 65, 66};
+        String str1_2 = new String(data1_2);
+        //16
+        char data1_3[] = {0x61, 0x20, 0x62, 0x5E, 0x63, 0x7E, 0x41, 0x42};
+        String str1_3 = new        String(data1_3);
+        String str2_1 = "中国";
+        // Test unicode
+        char data2_2[] = {'\u4E2D', '\u56FD'};
+        String str2_2 = new String(data2_2);
+        String str3_1 = "中国abc";
+        //unicode
+        char data3_2[] = {'\u4E2D', '\u56FD', 97, 98, 99};
+        String str3_2 = new String(data3_2);
+
+        test1(str1_1);
+        test1(str1_2);
+        test1(str1_3);
+
+        test1(str2_1);
+        test1(str2_2);
+        test1(str3_1);
+        test1(str3_2);
+    }
+
+    private static void test1(String str) {
+        for (int i = 0; i < str.length(); i++) {
+            char ch = str.charAt(i);
+            System.out.println(Integer.toHexString(ch));
+        }
+    }
+}
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 61\n20\n62\n5e\n63\n7e\n41\n42\n61\n20\n62\n5e\n63\n7e\n41\n42\n61\n20\n62\n5e\n63\n7e\n41\n42\n4e2d\n56fd\n4e2d\n56fd\n4e2d\n56fd\n61\n62\n63\n4e2d\n56fd\n61\n62\n63\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/StringAsVariableAndFieldAndParamTest.java b/test/testsuite/ouroboros/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/StringAsVariableAndFieldAndParamTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ffe3139b238719fac1b2d405d10673323f1a80f1
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/StringAsVariableAndFieldAndParamTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringAsVariableAndFieldAndParamTest.java
+ * -@TestCaseName: User Scene: class use String.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create a null String.
+ * -#step2: Check the string is create correctly.
+ * -#step3: Create a string as the domain value of the class.
+ * -#step4: Check the string is create correctly.
+ * -#step5: Create a string as input param of function.
+ * -#step6: Check the return value of function is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringAsVariableAndFieldAndParamTest.java
+ * -@ExecuteClass: StringAsVariableAndFieldAndParamTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringAsVariableAndFieldAndParamTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringAsVariableAndFieldAndParamTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringAsVariableAndFieldAndParamTest_1() {
+        String str = null;
+        System.out.println(str);
+        System.out.println(StringAsVariableAndFieldAndParamTest_1.str1_1);
+
+        str = "abc";
+        System.out.println(StringAsVariableAndFieldAndParamTest_1.test(str));
+    }
+}
+
+class StringAsVariableAndFieldAndParamTest_1 {
+    static String str1_1 = "abc1_1";
+    protected static String test(String str) {
+        String result = str + str;
+        System.out.println(result);
+        return result;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full null\nabc1_1\nabcabc\nabcabc\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0138-rt-String-VariableOfInterfaceTest/StringVariableOfInterfaceTest.java b/test/testsuite/ouroboros/string_test/RT0138-rt-String-VariableOfInterfaceTest/StringVariableOfInterfaceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b7c7165f95251904512d4e704f78969e8e5d02a5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0138-rt-String-VariableOfInterfaceTest/StringVariableOfInterfaceTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringVariableOfInterfaceTest.java
+ * -@TestCaseName: User Scene: interface use String as Filed and function param.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create a null String.
+ * -#step2: Check that null string is created correctly.
+ * -#step3: Create a string as the Filed of the interface.
+ * -#step4: Check that string created correctly.
+ * -#step5: Create a string as the param of function.
+ * -#step6: Check that string created correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringVariableOfInterfaceTest.java
+ * -@ExecuteClass: StringVariableOfInterfaceTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringVariableOfInterfaceTest implements StringVariableOfInterfaceTest_1 {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringVariableOfInterfaceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    static String test(String str) {
+        String result = str + str;
+        System.out.println(result);
+        return result;
+    }
+
+    public static void StringVariableOfInterfaceTest_1() {
+        String str = null;
+        System.out.println(str);
+        System.out.println(StringVariableOfInterfaceTest_1.str1_1);
+
+        str = "abc";
+        System.out.println(StringVariableOfInterfaceTest.test(str));
+    }
+}
+
+interface StringVariableOfInterfaceTest_1 {
+    static String str1_1 = "abc1_1";
+    static void test(String str) {
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full null\nabc1_1\nabcabc\nabcabc\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0139-rt-String-CreateStringArrayTest/StringCreateStringArrayTest.java b/test/testsuite/ouroboros/string_test/RT0139-rt-String-CreateStringArrayTest/StringCreateStringArrayTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e57169a674694222b4aab8ce2f75bcd8bcc621df
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0139-rt-String-CreateStringArrayTest/StringCreateStringArrayTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringCreateStringArrayTest.java
+ * -@TestCaseName: Create String Array and Test String Array as param of function.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String array.
+ * -#step2: Check that String array is created correctly.
+ * -#step3: Create a string[] as param of function.
+ * -#step4: Check the return value of function is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringCreateStringArrayTest.java
+ * -@ExecuteClass: StringCreateStringArrayTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringCreateStringArrayTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringCreateStringArrayTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringCreateStringArrayTest_1() {
+        String[] strArray = {"a", "b", "c", "1", "2", "3"};
+        System.out.println(strArray[1]);
+        System.out.println(test(strArray)[1]);
+    }
+
+    private static String[] test(String[] str) {
+        for (int i = 0; i < str.length; i++) {
+            System.out.println(str[i]);
+        }
+
+        str[1] = "B";
+        return str;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full b\na\nb\nc\n1\n2\n3\nB\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0140-rt-String-GenericTest/StringGenericTest.java b/test/testsuite/ouroboros/string_test/RT0140-rt-String-GenericTest/StringGenericTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8e840a66733028a43e1ce6297a6d8674874487e
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0140-rt-String-GenericTest/StringGenericTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGenericTest.java
+ * -@TestCaseName: User Scene: <T>
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create ArrayList instance.
+ * -#step2: Add letters or numbers to the ArrayList.
+ * -#step3: Check the object belong to class java.util.ArrayList.
+ * -#step4: Check if return value is the second param of the template function.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringGenericTest.java
+ * -@ExecuteClass: StringGenericTest
+ * -@ExecuteArgs:
+ */
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.io.PrintStream;
+
+public class StringGenericTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) throws IllegalAccessException, IllegalArgumentException,
+            InvocationTargetException, NoSuchMethodException, SecurityException {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success */
+
+        try {
+            StringGenericTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringGenericTest_1() throws IllegalAccessException, IllegalArgumentException,
+            InvocationTargetException, NoSuchMethodException, SecurityException {
+        ArrayList<String> arrayList1 = new ArrayList<String>();
+        arrayList1.add("abc");
+
+        ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
+        arrayList2.add(123);
+
+        System.out.println(arrayList1.getClass() == arrayList2.getClass());
+
+        String str = StringGenericTest.<String>add("1", "2");
+        System.out.println(str);
+    }
+
+    public static <T> T add(T x, T y) {
+        return y;
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full true\n2\n0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0141-rt-String-MultiThreadsTest/StringMultiThreadsTest.java b/test/testsuite/ouroboros/string_test/RT0141-rt-String-MultiThreadsTest/StringMultiThreadsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..94079783f0f81dd5d17d2cc36c7c753941017e50
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0141-rt-String-MultiThreadsTest/StringMultiThreadsTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringMultiThreadsTest.java
+ * -@TestCaseName: User Scene:multi-thread
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Inherit class Thread and override the run().
+ * -#step2: Create ThreadGroup instance.
+ * -#step3: Name threads with string value.
+ * -#step4: Start all threads, check all threads run correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringMultiThreadsTest.java
+ * -@ExecuteClass: StringMultiThreadsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringMultiThreadsTest extends Thread {
+    static int retu = 1;
+    static int threadCount = 10;
+    static int stringCount = 10;
+    static int count = 0;
+
+    public StringMultiThreadsTest(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public void run() {
+        String[] str = new String[stringCount];
+        for (int i = 0; i < stringCount; i++) {
+            str[i] = "ABC";
+            count++;
+
+            if (str[i] != "ABC") {
+                retu++;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println(test(args, System.out));
+    }
+
+    public static int test(String[] args, PrintStream out) {
+        ThreadGroup thg = new ThreadGroup("threadg");
+        String[] th = new String[threadCount];
+        for (int i = 0; i < threadCount; i++) {
+            th[i] = "thread" + i;
+            new StringMultiThreadsTest(thg, th[i]).start();
+        }
+
+        try {
+            sleep(200);
+        } catch (InterruptedException e) {
+        }
+
+        if (retu == 1) {
+            return 0;
+        }
+        return 2;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/StringJoinNullPointerExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/StringJoinNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1b802023a61d126f6b4a50291729d43de08a52ad
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/StringJoinNullPointerExceptionTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringJoinNullPointerExceptionTest.java
+ * -@TestCaseName: Test NullPointerException throw in String Method: static String join(CharSequence delimiter,
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      CharSequence... elements).
+ * -@Brief:
+ * -#step1: Create Parameters: delimiter is a null CharSequence, elements is a String array, element is null.
+ * -#step2: Test method join(CharSequence delimiter, CharSequence... elements).
+ * -#step3: NullPointerException is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: StringJoinNullPointerExceptionTest.java
+ * -@ExecuteClass: StringJoinNullPointerExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringJoinNullPointerExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success */
+        try {
+            StringJoinNullPointerExceptionTest_1(null);
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static void StringJoinNullPointerExceptionTest_1(String str) {
+        try {
+            String[] test = new String[]{str, str, str};
+            System.out.println(String.join(null, test));
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0143-rt-String-NullPointExceptionTest/StringNullPointExceptionTest.java b/test/testsuite/ouroboros/string_test/RT0143-rt-String-NullPointExceptionTest/StringNullPointExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e838c938bd95da4158cafe61b5e6ad9d2a1f929c
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0143-rt-String-NullPointExceptionTest/StringNullPointExceptionTest.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringNullPointExceptionTest.java
+ * -@TestCaseName: Test String Method: Test NullPointException throw in String Method: public char charAt (int
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      index), public char[] toCharArray (), public String substring (int beginIndex), public int
+ *                      compareTo (String anotherString), public String intern (), public String replace (CharSequence
+ *                      target, CharSequence replacement), public String concat (String str).
+ * -@Brief:
+ * -#case1
+ * -#step1: Create String instance, parameter index < 0.
+ * -#step2: Test method charAt (int index), check StringIndexOutOfBoundsException is thrown.
+ * -#case2
+ * -#step1: Create null String instance, parameter index >= 0.
+ * -#step2: Test method charAt (int index), check NullPointerException is thrown.
+ * -#case3
+ * -#step1: Create null String instance.
+ * -#step2: Test method toCharArray(), check NullPointerException is thrown.
+ * -#case4
+ * -#step1: Create null String instance, parameter beginIndex >= 0.
+ * -#step2: Test method substring (int beginIndex), check NullPointerException is thrown.
+ * -#case5
+ * -#step1: Create null String instance, parameter anotherString as string instance.
+ * -#step2: Test method compareTo (String anotherString), check NullPointerException is thrown.
+ * -#case6
+ * -#step1: Create null String instance.
+ * -#step2: Test method intern (), check NullPointerException is thrown.
+ * -#case7
+ * -#step1: Create null String instance, parameter target/replacement as CharSequence instance.
+ * -#step2: Test method replace (CharSequence target, CharSequence replacement), check NullPointerException is thrown.
+ * -#case8
+ * -#step1: Create null String instance, parameter str as String instance.
+ * -#step2: Test method concat (String str), check NullPointerException is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: StringNullPointExceptionTest.java
+ * -@ExecuteClass: StringNullPointExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringNullPointExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success */
+        try {
+            StringNullPointExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 83) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringNullPointExceptionTest_1() {
+        String str2_1 = "abc123";
+        String str2_5 = null;
+
+        test0(str2_1);
+        test1(str2_5);
+        test2(str2_5);
+        test3(str2_5);
+        test4(str2_5);
+        test5(str2_5);
+        test6(str2_5);
+        test7(str2_5);
+    }
+
+    private static void test0(String str) {
+        try {
+            char t0 = str.charAt(-2);
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 2;
+        }
+    }
+
+    private static void test1(String str) {
+        try {
+            char t1 = str.charAt(0);
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+
+    private static void test2(String str) {
+        char[] t2 = null;
+        try {
+            t2 = str.toCharArray();
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+
+    private static void test3(String str) {
+        String t3 = null;
+        try {
+            t3 = str.substring(1);
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+
+    private static void test4(String str) {
+        try {
+            int t4 = str.compareTo("aaa");
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+
+    private static void test5(String str) {
+        try {
+            String t5 = str.intern();
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+
+    private static void test6(String str) {
+        try {
+            String t6 = str.replace("a", "b");
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+
+    private static void test7(String str) {
+        try {
+            String t7 = str.concat("aaa");
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0144-rt-String-BufferExceptionsTest/StringBufferExceptionsTest.java b/test/testsuite/ouroboros/string_test/RT0144-rt-String-BufferExceptionsTest/StringBufferExceptionsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0be11267310f58ccab79a4b1988fd620ab6c1675
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0144-rt-String-BufferExceptionsTest/StringBufferExceptionsTest.java
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBufferExceptionsTest.java
+ * -@TestCaseName: Test Exception in StringBuffer: test IndexOutOfBoundsException is thrown in public void
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin), test
+ *                      StringIndexOutOfBoundsException is thrown in public StringBuffer replace(int start, int end,
+ *                      String str), test StringIndexOutOfBoundsException is thrown in public String
+ *                      substring(int start, int end), test StringIndexOutOfBoundsException is thrown in public String
+ *                      substring(int start).
+ * -@Brief:
+ * -case1
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters：cover srcBegin/srcEnd < 0, srcBegin/srcEnd > instance.length, srcBegin > srcEnd, dstBegin
+ *          < 0, dstBegin > dst.length, dst.length - dstBegin < srcEnd - srcBegin 8 scenes.
+ * -#step3: Test method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin), check IndexOutOfBoundsException is
+ *          thrown.
+ * -case2
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters：cover start/end < 0, start > instance.length, start > end 4 scenes.
+ * -#step3: Test method replace(int start, int end, String str), check StringIndexOutOfBoundsException is thrown.
+ * -case3
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters：cover start/end < 0, start/end > instance.length, start > end 5 scenes.
+ * -#step3: Test method substring(int start, int end), check StringIndexOutOfBoundsException is thrown.
+ * -case4
+ * -#step1: Create StringBuffer instance.
+ * -#step2: Create Parameters：cover start < 0, start > instance.length 2 scenes.
+ * -#step3: Test method substring(int start), check StringIndexOutOfBoundsException is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: StringBufferExceptionsTest.java
+ * -@ExecuteClass: StringBufferExceptionsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBufferExceptionsTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success */
+
+        try {
+            result = StringBufferGetCharsIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBufferReplaceStringIndexOutOfBoundsException_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBufferSubstringStringIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBufferSubstringStringIndexOutOfBoundsException_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 2 && processResult == 80) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringBufferGetCharsIndexOutOfBoundsException_1() {
+        int result1 = 3; /*STATUS_FAILED*/
+
+        // IndexOutOfBoundsException- If either off or len is negative, or if off + len is greater than b.length.
+        // Test public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin).
+        StringBuffer buff = new StringBuffer("java programming");
+        char[] chArr = new char[]{'t', 'u', 't', 'o', 'r', 'i', 'a', 'l', 's'};
+
+        // Test dstBegin > dst.length.
+        try {
+            buff.getChars(5, 10, chArr, 30);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test dstBegin < 0.
+        try {
+            buff.getChars(5, 10, chArr, -2);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test dst.length - dstBegin < srcEnd - srcBegin.
+        try {
+            buff.getChars(5, 10, chArr, 7);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcBegin < 0.
+        try {
+            buff.getChars(-2, 10, chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcBegin > buff.length.
+        try {
+            buff.getChars(buff.length(), 10, chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcEnd < 0.
+        try {
+            buff.getChars(5, -2, chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcEnd < srcBegin.
+        try {
+            buff.getChars(5, 2, chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcEnd > buff.length.
+        try {
+            buff.getChars(5, buff.length(), chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    public static int StringBufferReplaceStringIndexOutOfBoundsException_2() {
+        int result1 = 3; /*STATUS_FAILED*/
+
+        // StringIndexOutOfBoundsException- Access parameter range of index.
+        // Test public StringBuffer replace(int start, int end, String str).
+        StringBuffer buff1 = new StringBuffer("HelloWorld");
+
+        // Test start > buff1.length.
+        try {
+            buff1.replace(20, 6, "QQQ");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start < 0.
+        try {
+            buff1.replace(-2, 6, "QQQ");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start > end.
+        try {
+            buff1.replace(7, 6, "QQQ");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test end < 0.
+        try {
+            buff1.replace(7, -2, "QQQ");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    public static int StringBufferSubstringStringIndexOutOfBoundsException_1() {
+        int result1 = 3; /*STATUS_FAILED*/
+
+        // StringIndexOutOfBoundsException- Intercept character string specifying scope, exceed the range error.
+        // Test public String substring(int start, int end).
+        StringBuffer buff2 = new StringBuffer("HelloWorld");
+
+        // Test end > buff2.length.
+        try {
+            String str = buff2.substring(9, 11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test end < 0.
+        try {
+            String str = buff2.substring(9, 11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start > buff2.length.
+        try {
+            String str = buff2.substring(11, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start > end.
+        try {
+            String str = buff2.substring(8, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start < 0.
+        try {
+            String str = buff2.substring(-2, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    public static int StringBufferSubstringStringIndexOutOfBoundsException_2() {
+        int result1 = 3; /*STATUS_FAILED*/
+
+        // StringIndexOutOfBoundsException- Intercept character string specifying scope, exceed the range error.
+        // Test public String substring(int start).
+        StringBuffer buff3 = new StringBuffer("HelloWorld");
+
+        // Test start > buff3.length.
+        try {
+            String str = buff3.substring(15);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start < 0.
+        try {
+            String str = buff3.substring(-2);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            result1 = 2;
+            processResult--;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0145-rt-String-BuilderExceptionsTest/StringBuilderExceptionsTest.java b/test/testsuite/ouroboros/string_test/RT0145-rt-String-BuilderExceptionsTest/StringBuilderExceptionsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..502f887cd7f2b54d1b00e62b8ccafe148415148d
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0145-rt-String-BuilderExceptionsTest/StringBuilderExceptionsTest.java
@@ -0,0 +1,485 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringBuilderExceptionsTest.java
+ * -@TestCaseName: Test Exception in StringBuilder: test StringIndexOutOfBoundsException is thrown in String
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ *                      substring(int start, int end), test StringIndexOutOfBoundsException is thrown in String
+ *                      substring(int start), test IndexOutOfBoundsException is thrown in int codePointAt(int index),
+ *                      test IndexOutOfBoundsException is thrown in int codePointBefore(int index), test
+ *                      IndexOutOfBoundsException is thrown in int codePointCount(int beginIndex, int endIndex), test
+ *                      StringIndexOutOfBoundsException is thrown in StringBuilder
+ *                      replace(int start, int end, String str), test IndexOutOfBoundsException in void getChars(int
+ *                      srcBegin, int srcEnd, char[] dst, int dstBegin), test IndexOutOfBoundsException in int
+ *                      offsetByCodePoints(int index, int codePointOffset).
+ * -@Brief:
+ * -case1
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameters：cover start/end < 0, start/end > instance.length, start > end 5 scenes.
+ * -#step3: Test method substring(int start, int end), check StringIndexOutOfBoundsException is thrown.
+ * -case2
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameter: cover start < 0, start > instance.length 2 scenes.
+ * -#step3: Test method substring(int start), check StringIndexOutOfBoundsException is thrown.
+ * -case3
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameter: cover index < 0, index >= instance.length 2 scenes.
+ * -#step3: Test method codePointAt(int index), check IndexOutOfBoundsException is thrown.
+ * -case4
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameter: cover index < 0, index >= instance.length 2 scenes.
+ * -#step3: Test method codePointBefore(int index), check IndexOutOfBoundsException is thrown.
+ * -case5
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameter: cover beginIndex/endIndex < 0, beginIndex/endIndex > instance.length, beginIndex >
+ *          endIndex 5 scenes.
+ * -#step3: Test method codePointCount(int beginIndex, int endIndex), check IndexOutOfBoundsException is thrown.
+ * -case6
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameter: cover start/end < 0, start/end > instance.length, start > end 5 scenes.
+ * -#step3: Test method replace(int start, int end, String str),check that if StringIndexOutOfBoundsException is thrown.
+ * -case7
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameter: cover srcBegin/srcEnd < 0, srcBegin/srcEnd > instance.length, srcBegin > srcEnd, dstBegin
+ *          < 0, dstBegin > dst.length, dst.length - dstBegin < srcEnd - srcBegin 8 scenes.
+ * -#step3: Test method getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin), check IndexOutOfBoundsException is
+ *          thrown.
+ * -case8
+ * -#step1: Create StringBuilder instance.
+ * -#step2: Create Parameter: cover index < 0, index > instance.length, codePointOffset > stringBuilder.length - index
+ *          3 scenes.
+ * -#step3: Test method offsetByCodePoints(int index, int codePointOffset), check IndexOutOfBoundsException is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: StringBuilderExceptionsTest.java
+ * -@ExecuteClass: StringBuilderExceptionsTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringBuilderExceptionsTest {
+    private static int processResult = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+
+        try {
+            result = StringBuilderSubstringStringIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderSubstringStringIndexOutOfBoundsException_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderCodePointAtIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderCodePointBeforeIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderCodePointCountIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderReplaceStringIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderGetCharsIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderOffsetByCodePointsIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+
+        if (result == 4 && processResult == 67) {
+            result = 0;
+        }
+        return result;
+    }
+
+    // Test StringIndexOutOfBoundsException in String substring(int start, int end).
+    public static int StringBuilderSubstringStringIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED */
+        StringBuilder str = new StringBuilder("java is boring");
+
+        // Test end > str.length().
+        try {
+            String test1 = str.substring(8, 20);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test end < 0.
+        try {
+            String test1 = str.substring(8, -2);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test end < start.
+        try {
+            String test1 = str.substring(8, 6);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start > str.length().
+        try {
+            String test1 = str.substring(20, 6);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start < 0.
+        try {
+            String test1 = str.substring(-2, 6);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    // Test StringIndexOutOfBoundsException in String substring(int start).
+    public static int StringBuilderSubstringStringIndexOutOfBoundsException_2() {
+        int result1 = 4; /* STATUS_FAILED */
+        StringBuilder str = new StringBuilder("java is boring");
+
+        // Test start > str.length.
+        try {
+            String test1 = str.substring(20);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start < 0.
+        try {
+            String test1 = str.substring(-2);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    // Test IndexOutOfBoundsException in int codePointAt(int index).
+    public static int StringBuilderCodePointAtIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED */
+        StringBuilder buff = new StringBuilder("programming");
+
+        // Test index >= stringBuilder.length.
+        try {
+            int str = buff.codePointAt(11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test index < 0.
+        try {
+            int str = buff.codePointAt(-1);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    // Test IndexOutOfBoundsException in int codePointBefore(int index).
+    public static int StringBuilderCodePointBeforeIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED */
+        StringBuilder buff = new StringBuilder("HelloWorld");
+
+        // Test index > stringBuilder.length.
+        try {
+            int str = buff.codePointBefore(11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test index < 0.
+        try {
+            int str = buff.codePointBefore(-3);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    // Test IndexOutOfBoundsException in int codePointCount(int beginIndex, int endIndex).
+    public static int StringBuilderCodePointCountIndexOutOfBoundsException_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        StringBuilder buff = new StringBuilder("HelloWorld");
+
+        // Test endIndex > stringBuilder.length.
+        try {
+            int str = buff.codePointCount(5, 11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test endIndex < beginIndex.
+        try {
+            int str = buff.codePointCount(5, 4);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test endIndex < 0.
+        try {
+            int str = buff.codePointCount(5, -2);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test beginIndex < 0.
+        try {
+            int str = buff.codePointCount(-1, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test beginIndex > stringBuilder.length.
+        try {
+            int str = buff.codePointCount(11, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    // Test StringIndexOutOfBoundsException in StringBuilder replace(int start, int end, String str).
+    public static int StringBuilderReplaceStringIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED */
+        StringBuilder str = new StringBuilder("Java Util Package");
+
+        // Test end > stringBuilder.length.
+        try {
+            StringBuilder test1 = str.replace(18, 20, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test end < start.
+        try {
+            StringBuilder test1 = str.replace(18, 16, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test end < 0.
+        try {
+            StringBuilder test1 = str.replace(18, -2, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start < 0.
+        try {
+            StringBuilder test1 = str.replace(-2, 16, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test start > stringBuilder.length.
+        try {
+            StringBuilder test1 = str.replace(20, 16, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    // Test IndexOutOfBoundsException in void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin).
+    public static int StringBuilderGetCharsIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED */
+        StringBuilder str = new StringBuilder("java programming");
+        char[] cArr = new char[]{'t', 'u', 't', 'o', 'r', 'i', 'a', 'l', 's'};
+
+        // Test cArr.length - dstBegin < srcEnd - srcBegin
+        try {
+            str.getChars(5, 9, cArr, 6);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test dstBegin > cArr.length.
+        try {
+            str.getChars(0, 9, cArr, 10);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test dstBegin < 0.
+        try {
+            str.getChars(0, 9, cArr, -2);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcEnd < 0.
+        try {
+            str.getChars(0, -2, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcBegin < 0.
+        try {
+            str.getChars(-2, 5, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcBegin > srcEnd.
+        try {
+            str.getChars(5, 2, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcBegin > stringBuilder.length.
+        try {
+            str.getChars(20, 2, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test srcEnd > stringBuilder.length.
+        try {
+            str.getChars(2, 20, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+
+    // Test IndexOutOfBoundsException in int offsetByCodePoints(int index, int codePointOffset).
+    public static int StringBuilderOffsetByCodePointsIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED */
+        StringBuilder str = new StringBuilder("abcdefg");
+
+        // Test codePointOffset > stringBuilder.length - index.
+        try {
+            int result = str.offsetByCodePoints(1, 7);
+            System.out.println(str);
+            System.out.println(result);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test index < 0.
+        try {
+            int result = str.offsetByCodePoints(-1, 3);
+            System.out.println(str);
+            System.out.println(result);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+
+        // Test index > stringBuilder.length.
+        try {
+            int result = str.offsetByCodePoints(8, 0);
+            System.out.println(str);
+            System.out.println(result);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0146-rt-String-ClassNewInstanceTest/StringClassNewInstanceTest.java b/test/testsuite/ouroboros/string_test/RT0146-rt-String-ClassNewInstanceTest/StringClassNewInstanceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb2f72e8c2eb917ae00f16a6d8b9eda469439ee0
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0146-rt-String-ClassNewInstanceTest/StringClassNewInstanceTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringClassNewInstanceTest.java
+ * -@TestCaseName: Calling String's no-argument constructor by reflection String.class.newInstance().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Test String.class.newInstance().
+ * -#step2: Check newInstance() is correctly, and no Exception is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: StringClassNewInstanceTest.java
+ * -@ExecuteClass: StringClassNewInstanceTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringClassNewInstanceTest  {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success */
+
+        try {
+            StringClassNewInstanceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringClassNewInstanceTest_1() {
+        Object test1 = null;
+        try {
+            test1 = String.class.newInstance();
+            processResult--;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0147-rt-String-PoolEnlargeTest/StringPoolEnlargeTest.java b/test/testsuite/ouroboros/string_test/RT0147-rt-String-PoolEnlargeTest/StringPoolEnlargeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..725a709385386360607c2e324e6e349ea30de86b
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0147-rt-String-PoolEnlargeTest/StringPoolEnlargeTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringPoolEnlargeTest.java
+ * -@TestCaseName: Test mapleStringPool large and large by public String intern().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create String instance by Integer.toHexString(int index), index cover 0 to 47000.
+ * -#step2: Test method intern(), check get result correctly.
+ * -#step3: Change String instance create by Integer.toHexString(int index), index cover 0 to 470000, repeat step 2.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: StringPoolEnlargeTest.java
+ * -@ExecuteClass: StringPoolEnlargeTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringPoolEnlargeTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success */
+        try {
+            result = result - StringPoolEnlargeTest_1(47000);
+            result = result - StringPoolEnlargeTest_1(470000);
+        } catch (Exception e) {
+            System.out.println(e);
+            StringPoolEnlargeTest.processResult = StringPoolEnlargeTest.processResult - 10;
+        }
+
+        if (result == 0 && StringPoolEnlargeTest.processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringPoolEnlargeTest_1(int len) {
+        int length = len; // 47 mapleStringPool/process, 1000 key-value/mapleStringPool
+        try {
+            String[] s;
+            s = new String[length];
+            for (int i = 0; i < length; i++) {
+                s[i] = Integer.toHexString(i);
+                if (s[i].intern() == Integer.toHexString(func1(len-1)).intern()) {
+                    StringPoolEnlargeTest.processResult = StringPoolEnlargeTest.processResult - 2;
+                    return 1;
+                }
+            }
+        } catch (OutOfMemoryError e) {
+            return 114;
+        }
+        StringPoolEnlargeTest.processResult = StringPoolEnlargeTest.processResult - 10;
+        return 102;
+    }
+
+    public static int func1(int i) {
+        return i;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0148-rt-String-XByteTest/StringXByteTest.java b/test/testsuite/ouroboros/string_test/RT0148-rt-String-XByteTest/StringXByteTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..68569de264bcc7615e652e5f30bd645b48d75089
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0148-rt-String-XByteTest/StringXByteTest.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringXByteTest.java
+ * -@TestCaseName: Test String(byte[] bytes), bytes cover 1、2、3、4 byte.
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Create string value and get the random string byte by string value.
+ * -#step2: Get byte array by random string cover with 1、2、3、4 byte.
+ * -#step3: Test constructor String(byte[] bytes), check the byte array change to string is correctly.
+ * -@Expect: expected.txt
+ * -@Priority: High
+ * -@Source: StringXByteTest.java
+ * -@ExecuteClass: StringXByteTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.io.*;
+import java.util.Random;
+
+public class StringXByteTest {
+    static int seed = 20;
+    static Random random = new Random(seed);
+
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    public static int run(String[] args, PrintStream out) {
+        int result = 2;
+
+        try {
+            result = StringXByteTest1();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        if (result == 1 ) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static int StringXByteTest1() {
+        String string_byte1 = getByteString(1);
+        String string_byte2 = getByteString(2);
+        String string_byte3 = getByteString(3);
+        String string_byte4 = getByteString(4);
+
+        byte[] by = new byte[]{(byte) 0x59,(byte) 0xCF,(byte) 0xB9,(byte) 0xE2,(byte) 0xA2,(byte) 0xA4,
+                (byte) 0xF3,(byte) 0x90,(byte) 0xA2,(byte) 0x85};
+
+        if ((string_byte1+string_byte2+string_byte3+string_byte4).equals(new String(by))) {
+            return 1;
+        }
+        return 3;
+    }
+
+    public static String getByteString(int lengthIn) {
+        String strCd = "CD";
+        String str0f = "0123456789ABCDEF";
+        String str8b = "89AB";
+        String str07 = "01234567";
+        String hexString = "0123456789ABCDEF";
+        StringBuffer byte5= new StringBuffer();
+
+        if (lengthIn == 1) {
+            // 1Byte: 0-7|0-F
+            byte5.append(str07.charAt( random.nextInt(8))); // 0-7
+            byte5.append(str0f.charAt( random.nextInt(16))); // 0-F
+        }else if (lengthIn == 2) {
+            // 2Byte: C-D|0-F   8-B|0-F
+            byte5.append(strCd.charAt(random.nextInt(2)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+        }else if (lengthIn == 3) {
+            // 3Byte: E|0-F  8-B|0-F 8-B|0-F
+            byte5.append("E");
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+        }else if (lengthIn == 4) {
+            // 4Byte: F|0-7 8-B|0-F 8-B|0-F 8-B|0-F
+            byte5.append("F");
+            byte5.append(str07.charAt(random.nextInt(8)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+        }
+
+        ByteArrayOutputStream scb=new ByteArrayOutputStream(byte5.length()/2);
+        for(int i=0;i<byte5.length();i+=2) {
+            scb.write((hexString.indexOf(byte5.charAt(i)) << 4 | hexString.indexOf(byte5.charAt(i + 1))));
+        }
+
+        return new String(scb.toByteArray());
+    }
+
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0149-rt-String-ClassNewInstance2Test/StringClassNewInstance2Test.java b/test/testsuite/ouroboros/string_test/RT0149-rt-String-ClassNewInstance2Test/StringClassNewInstance2Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..f75fdcf8dcd73f85ae5874ab65dec14afe591272
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0149-rt-String-ClassNewInstance2Test/StringClassNewInstance2Test.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringClassNewInstance2Test.java
+ * -@TestCaseName: Calling String's no-argument constructor by reflection String.class.newInstance().
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Test String.class.newInstance().
+ * -#step2: Check newInstance() is correctly, and no Exception is thrown.
+ * -@Expect: 0\n
+ * -@Priority: High
+ * -@Source: StringClassNewInstance2Test.java
+ * -@ExecuteClass: StringClassNewInstance2Test
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class StringClassNewInstance2Test {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success */
+
+        try {
+            StringClassNewInstance2Test_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+
+    public static void StringClassNewInstance2Test_1() {
+        Object test1 = null;
+        try {
+            test1 = String.class.newInstance();
+            processResult -= 4;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/RT0150-rt-String-Emoji/StringEmojiTest.java b/test/testsuite/ouroboros/string_test/RT0150-rt-String-Emoji/StringEmojiTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..71c6f9bc1d657ebd7cde52109978338533e7376a
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/RT0150-rt-String-Emoji/StringEmojiTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringEmojiTest.java
+ * -@TestCaseName: test Emoji because this use D8 zone;
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Prepare input Emoji
+ * -#step2: check unicode of Emoji corret
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringEmojiTest.java
+ * -@ExecuteClass: StringEmojiTest
+ * -@ExecuteArgs:
+ */
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+import java.sql.SQLOutput;
+import java.util.Arrays;
+
+public class StringEmojiTest {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2 /* STATUS_FAILED */;
+        try {
+            if (StringEmojiTest()) {
+                result =1;
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 1 && processResult == 99) {
+            result =0;
+        }
+        return result;
+    }
+
+    public static boolean StringEmojiTest() throws UnsupportedEncodingException {
+        // 以下用byte[]构造string 😘
+        byte[] emoji_FacewithTearsofJoy = {(byte) 0xD8, (byte) 0x3D, (byte) 0xDE, (byte) 0x02}; // U+1F602
+        byte[] emoji = {(byte) 0xD8, (byte) 0x3D, (byte) 0xDE, (byte) 0x18};
+        String emojis = "\uD83D\uDE18";
+//        System.out.println(new String(emoji, Charset.forName("unicode")));
+        /* 以上处理用例输出，用例输出是"😘"
+         * 得到unicode [-2 -1 -40 61 -34 24]
+         * 得到UTF-16  [-2 -1 -40 61 -34 24]
+         * 得到UTF-8   [-16 -97 -104 -104]
+         * 得到ISO-8859-1 [63] 已经出错了
+         * 得到ASCII   [63] 已经出错了
+         */
+        byte[] ab_10 = "\uD83D\uDE18".getBytes("unicode");
+//        for (int i = 0; i <ab_10.length ; i++) {
+//            System.out.print(ab_10[i]+" ");
+//        }
+//        System.out.println();
+
+        return Arrays.equals(emojis.getBytes("unicode"), ab_10);
+
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/StringGetBytesUnsupportedEncodingExceptionTest.java b/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/StringGetBytesUnsupportedEncodingExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f098bfdc7f3777ba4ccc6059164888f7a3e1cef5
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/StringGetBytesUnsupportedEncodingExceptionTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringGetBytesUnsupportedEncodingExceptionTest.java
+ * -@TestCaseName: Test UnsupportedEncodingException occured in getBytes(String charsetName)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Give an invalid CharsetName as args
+ * -#step2: Invoke Method of getBytes
+ * -#step3: Check UnsupportedEncodingException be thrown by Method(getBytes)
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringGetBytesUnsupportedEncodingExceptionTest.java
+ * -@ExecuteClass: StringGetBytesUnsupportedEncodingExceptionTest
+ * -@ExecuteArgs:
+ */
+
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+
+public class StringGetBytesUnsupportedEncodingExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 3; /*STATUS_FAILED*/
+        try {
+            result = StringGetBytesUnsupportedEncodingExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 98) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+
+    public static int StringGetBytesUnsupportedEncodingExceptionTest_1() {
+        int result1 = 3; /*STATUS_FAILED*/
+        String str1_1 = new String("abc123");
+//        String str1_2 = new String("      ");
+//        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+
+        String str2_1 = "abc123";
+//        String str2_2 = "      ";
+//        String str2_3 = "abc123";
+        String str2_4 = "";
+//        String str2_5 = null;
+        try {
+            byte[] test1_1 = str1_1.getBytes("asc");
+            processResult -= 10;
+        } catch (UnsupportedEncodingException e1) {
+            processResult--;
+        }
+        return 2;
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/StringStringIndexOutOfBoundsExceptionTest.java b/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/StringStringIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1b846ea592cff6d414d84bbfc044dc645f36079
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/StringStringIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringStringIndexOutOfBoundsExceptionTest.java
+ * -@TestCaseName: Test UnsupportedEncodingException/StringIndexOutOfBoundsException occured in constructor of String(byte bytes[], int offset, int length, String charsetName)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Give an invalid charset name for String constructor
+ * -#step2: new instance use the String constructor
+ * -#step3: Check UnsupportedEncodingException be thrown
+ * -#step4: Give a negative number as offset for String constructor,then repeat step2,check StringIndexOutOfBoundsException be thrown
+ * -#step4: Give a number larger than length for String constructor,then repeat step2,check StringIndexOutOfBoundsException be thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringStringIndexOutOfBoundsExceptionTest.java
+ * -@ExecuteClass: StringStringIndexOutOfBoundsExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+
+public class StringStringIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = StringStringIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 96) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+
+    public static int StringStringIndexOutOfBoundsExceptionTest_1() throws UnsupportedEncodingException {
+        int result = 4; /*STATUS_FAILED*/
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, 0, 3, "ASC");
+            processResult -= 10;
+        } catch (UnsupportedEncodingException e1) {
+            processResult--;
+        }
+        try {
+            String str2 = new String(str1_1, -1, 3, "ASCII");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult -= 1;
+        }
+        try {
+            String str3 = new String(str1_1, 0, 8, "ASCII");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result;
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/StringUnsupportedEncodingExceptionTest.java b/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/StringUnsupportedEncodingExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..947f75c823e648ffd9e21e8d2a6af0d6130907a1
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/StringUnsupportedEncodingExceptionTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringUnsupportedEncodingExceptionTest.java
+ * -@TestCaseName: Test UnsupportedEncodingException occured in String(byte bytes[], String charsetName)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Give an invalid charset name for String constructor
+ * -#step2: new instance use the String constructor
+ * -#step3: Check UnsupportedEncodingException be thrown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringUnsupportedEncodingExceptionTest.java
+ * -@ExecuteClass: StringUnsupportedEncodingExceptionTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+
+public class StringUnsupportedEncodingExceptionTest {
+    private static int processResult = 99;
+
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = StringUnsupportedEncodingExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+
+    public static int StringUnsupportedEncodingExceptionTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //UnsupportedEncodingException - If the named charset is not supported
+        //
+        // byte[] str1_1 = new byte[]{(byte)0x61, (byte)0x62, (byte)0x63, (byte)0x31, (byte)0x32, (byte)0x33};
+        //char[] str1_1 = {'a','b','c','1','2','3'};
+        //int[] str1_2 = new int[]{0x61,0x62,0x63,0x31,0x32,0x33};
+        //int[] str1_1 = new int[]{97,98,99,49,50,51};
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, "ASC");
+            processResult -= 10;
+        } catch (UnsupportedEncodingException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/StringUserCaseLiteralsISO88591Test.java b/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/StringUserCaseLiteralsISO88591Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..82001b3c5dc6f794458ac6d51b3cb8df6ef8d204
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/StringUserCaseLiteralsISO88591Test.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringUserCaseLiteralsISO88591Test.java
+ * -@TestCaseName: Literals is ISO-8859-1,new String instance correctly
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: Prepare a String which literals is ISO-8859-1
+ * -#step2: Get Its Bytes
+ * -#step3: New String instance with Bytes and ISO-8859-1 charset
+ * -#step4: Check the String is correct
+ * -@Expect:expected.txt
+ * -@Priority: High
+ * -@Source: StringUserCaseLiteralsISO88591Test.java
+ * -@ExecuteClass: StringUserCaseLiteralsISO88591Test
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+public class StringUserCaseLiteralsISO88591Test {
+    private static int processResult = 99;
+
+    public static void main(String[] argv) {
+        run(argv, System.out);
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            StringUserCaseLiteralsISO88591Test_1();
+        } catch (Exception e) {
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 1 && processResult == 99) {
+            result =0;
+        }
+        return result;
+    }
+
+    public static void StringUserCaseLiteralsISO88591Test_1() throws UnsupportedEncodingException {
+        String testCaseID = "StringUserCaseLiteralsISO88591Test_1";
+        System.out.println("========================" + testCaseID);
+        //0x00~0x7F
+        String str1_1 = "a b^c~AB";
+        //10
+        char data1_2[] = {97, 32, 98, 94, 99, 126, 65, 66};
+        String str1_2 = new String(data1_2);
+        //16
+//        char data1_3[] = {0x61,0x20, 0x62, 0x5E, 0x63, 0x7E,0x00, 0x41, 0x42, 0x43,0x7F};
+        char data1_3[] = {0x61, 0x20, 0x62, 0x5E, 0x63, 0x7E, 0x41, 0x42};
+        String str1_3 = new String(data1_3);
+
+//        //0x80~0xFF
+        String str2_1 = "jag ls dig";
+//        //16 ISO-8859-1 0x80undefinit ,
+        char data2_3[] = {0x80, 0xC5, 0xFF, 0xD7, 0xF7};
+        String str2_3 = new String(data2_3);
+
+        byte[] data2_4 = {(byte) 0x80, (byte) 0xC5, (byte) 0xFF, (byte) 0xD7, (byte) 0xF7};
+        String str2_4 = new String(data2_4, Charset.forName("iso-8859-1"));
+
+        byte[] testb = str2_1.getBytes("ISO-8859-1");
+        String tests = new String(testb, "ISO-8859-1");
+        test1(tests);
+
+    }
+
+    private static void test1(String str) {
+        System.out.println(str);
+//        for (int i=0;i< str.length() ; i++) {
+//            char ch = str.charAt(i);
+////            System.out.print("char: " + ch + " unicode: ");
+//            System.out.println(Integer.toHexString(ch));
+//
+//        }
+    }
+
+}
+
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ========================StringUserCaseLiteralsISO88591Test_1\njag ls dig\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/string_test/issue-RT0818-rt-String-StringOOMTest/StringOOMTest.java b/test/testsuite/ouroboros/string_test/issue-RT0818-rt-String-StringOOMTest/StringOOMTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..db5689f92778b313d2c2eb653d9cfdc0fbca6d77
--- /dev/null
+++ b/test/testsuite/ouroboros/string_test/issue-RT0818-rt-String-StringOOMTest/StringOOMTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StringOOMTest.java
+ * -@TestCaseName:  Test occur OOM when new string
+ * -@TestCaseType: Function Test
+ * -@RequirementName: Java字符串实现
+ * -@Brief:
+ * -#step1: New instance of String untill no Space
+ * -#step2: Check OOM be thown
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: StringOOMTest.java
+ * -@ExecuteClass: StringOOMTest
+ * -@ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+
+public class StringOOMTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+
+    public static int run(String argv[], PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = result-StringOOMTest_1();
+//            result = result-StringOOMTest_2(); time out
+        } catch (Exception e) {
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(StringOOMTest.res);
+        if (result == 1 && processResult == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    public static  int StringOOMTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        int length=1024*1024*5120;// 1024*1024*1B=1M,*512=512M,set as 1024*1024*5120
+        try {
+            String[] s;
+            s = new String[ length ];
+            s [0] = "a" ;//if no this,y = new int[] will be optimizated and deleted.
+//            System.out.println("s: "+ Arrays.toString(s));
+        } catch (OutOfMemoryError e) {
+            processResult = processResult - 2;
+            return 1;
+        }
+        processResult = processResult - 10;
+        return 40;
+    }
+    public static  int StringOOMTest_2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        int loop = 2147483647; // set as 2147483647
+//        String[] s= new String[loop];
+        String s=null;
+        while(loop >0 ) {
+            loop--;
+            try {
+                s = new String(Integer.toBinaryString(loop));
+            } catch (OutOfMemoryError e) {
+                processResult = processResult - 2;
+                return 1;
+            }
+        }
+        System.out.println("s: "+ s);
+        processResult = processResult - 10;
+        return 40;
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/LiverangeSubsumeRCTest01.java b/test/testsuite/ouroboros/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/LiverangeSubsumeRCTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..9864981d7fdba529b66349eb9e3fe799ed9d21d0
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/LiverangeSubsumeRCTest01.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest01
+ *- @TestCaseName: LiverangeSubsumeRCTest01
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ *  -#step1: 创建一个1个数组，先后用array1指针和array2指针指向了它;
+ *  -#step2: 数组越界式的用一下这俩数组指针，第27行代码可以看出，array1指针存活状态包含了array2，所以array2的incref和decref都应该被优化掉。
+ *  -#step3: str1 和str2同时指向一个字符串，str1指针存活状态包含了str2，所以str2的incref和decref都应该被优化掉。
+ *  校验中间文件LiverangeSubsumeRCTest01.VtableImpl.mpl中无IncRef
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest01.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest01
+ *- @ExecuteArgs:
+ */
+
+public class LiverangeSubsumeRCTest01 {
+    public static void main(String[] args) {
+        int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int[] array2 = array1;
+        String str1 = "ExpectResult";
+        String str2 = str1;
+        try {
+            if (array2[10] == array1[10]) {
+                System.out.print(str2); // 错误输出
+            }
+        } catch (Exception e) {
+            System.out.println(str1);
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/LiverangeSubsumeRCTest02.java b/test/testsuite/ouroboros/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/LiverangeSubsumeRCTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..639690047c54c563e52545bebd5433a33b2cbeb8
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/LiverangeSubsumeRCTest02.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest02
+ *- @TestCaseName: LiverangeSubsumeRCTest02
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的不在某个生存区间内的存活状态时，不能去掉这个区间内的此对象的RC操作
+ *  -#step1: 创建一个1个数组，先后用array1指针和array2指针指向了它;
+ *  -#step2: 数组越界式的用一下这俩数组指针，第29行代码可以看出，array1指针存活状态和array2相同，array2的incref和decref都能被优化掉。
+ *  -#step3: str1 和str2同时指向一个字符串，str1指针存活状态不能包含str2，所以str2的incref和decref都不能被优化掉。
+ *  校验中间文件LiverangeSubsumeRCTest01.VtableImpl.mpl无IncRef
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest02.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest02
+ *- @ExecuteArgs:
+ */
+public class LiverangeSubsumeRCTest02 {
+    public static void main(String[] args) {
+        int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int[] array2 = array1;
+        String str1 = "ExpectResult";
+        String str2 = str1; //被优化掉了
+        try {
+            if (array1[10] == array2[10]) {
+                System.out.print(str1); // 错误输出
+            }
+        } catch (Exception e) {
+            System.out.println(str2);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/LiverangeSubsumeRCTest03.java b/test/testsuite/ouroboros/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/LiverangeSubsumeRCTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..d9bde750ed3200034e70fa3add06e6647d157739
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/LiverangeSubsumeRCTest03.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest03
+ *- @TestCaseName: LiverangeSubsumeRCTest03
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ *  -#step1: 创建一个1个数组，先后用array1、array2、array3指针指向了它;
+ *  -#step2: str1、str2和str3同时指向一个字符串，step1和step2里他们的生命周期都是按照这个流程来的：
+ *  incref(array1)
+ *  array2 = array1   incref优化掉
+ *  array3 = array2  incref优化掉
+ *  decref(array2)   优化掉
+ *  decref(array3)   优化掉
+ *  decref(array1)
+ *  -#step3:
+ *  校验中间文件LiverangeSubsumeRCTest01.VtableImpl.mpl中无IncRef
+ *- @Expect:falsefalseExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest03.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest03
+ *- @ExecuteArgs:
+ */
+
+public class LiverangeSubsumeRCTest03 {
+    public static void main(String[] args) {
+        int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int[] array2 = array1;
+        int[] array3 = array2;
+        String str1 = "ExpectResult";
+        String str2 = str1;
+        String str3 = str2;
+        boolean check = String.valueOf(array2[0]).equals(str2); // false
+        System.out.print(check);
+        check = String.valueOf(array3[1]) == str3;
+        System.out.print(check); // false
+        if (array1.length == 10) {
+            System.out.println(str1);
+        } else {
+            System.out.print(str1); // 错误输出，无换行符
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full falsefalseExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/LiverangeSubsumeRCTest04.java b/test/testsuite/ouroboros/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/LiverangeSubsumeRCTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..a21ae5960e11818184d20e6367829d7e67496505
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/LiverangeSubsumeRCTest04.java
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest04
+ *- @TestCaseName: LiverangeSubsumeRCTest04
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ *  -#step1: 构造是个类对象A1、A2、A3···A10，他们同时有实例变量同时指向一块内存地址b1;
+ *  -#step2: b1的生命周期包含了这十个成员变量(A1···A10)的生命周期。代码51行--66行不再出现实例变量
+ *  -#step3: A1到A10的十个实例变量的incref和decRef都应该被优化掉都应该被优化掉。
+ *  校验中间文件LiverangeSubsumeRCTest04.VtableImpl.mpl无IncRef。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest04.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest04
+ *- @ExecuteArgs:
+ */
+
+public class LiverangeSubsumeRCTest04 {
+
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+
+    private static void rc_testcase_main_wrapper() {
+        LiverangeSubsumeRCTest04_A1 a1_main = new LiverangeSubsumeRCTest04_A1("a1_main");
+        LiverangeSubsumeRCTest04_A2 a2_main = new LiverangeSubsumeRCTest04_A2("a2_main");
+        LiverangeSubsumeRCTest04_A3 a3_main = new LiverangeSubsumeRCTest04_A3("a3_main");
+        LiverangeSubsumeRCTest04_A4 a4_main = new LiverangeSubsumeRCTest04_A4("a4_main");
+        LiverangeSubsumeRCTest04_A5 a5_main = new LiverangeSubsumeRCTest04_A5("a5_main");
+        LiverangeSubsumeRCTest04_A6 a6_main = new LiverangeSubsumeRCTest04_A6("a6_main");
+        LiverangeSubsumeRCTest04_A7 a7_main = new LiverangeSubsumeRCTest04_A7("a7_main");
+        LiverangeSubsumeRCTest04_A8 a8_main = new LiverangeSubsumeRCTest04_A8("a8_main");
+        LiverangeSubsumeRCTest04_A9 a9_main = new LiverangeSubsumeRCTest04_A9("a9_main");
+        LiverangeSubsumeRCTest04_A10 a10_main = new LiverangeSubsumeRCTest04_A10("a10_main");
+        LiverangeSubsumeRCTest04_B1 b1 = new LiverangeSubsumeRCTest04_B1("b1_0");
+        a1_main.b1_0 = b1;
+        a2_main.b1_0 = b1;
+        a3_main.b1_0 = b1;
+        a4_main.b1_0 = b1;
+        a5_main.b1_0 = b1;
+        a6_main.b1_0 = b1;
+        a7_main.b1_0 = b1;
+        a8_main.b1_0 = b1;
+        a9_main.b1_0 = b1;
+        a10_main.b1_0 = b1;
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        b1.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + b1.sum;
+        if (result == 3467)
+            System.out.println("ExpectResult");
+    }
+}
+
+class LiverangeSubsumeRCTest04_A1 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class LiverangeSubsumeRCTest04_A2 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class LiverangeSubsumeRCTest04_A3 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A3(String strObjectName) {
+        b1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class LiverangeSubsumeRCTest04_A4 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A4(String strObjectName) {
+        b1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class LiverangeSubsumeRCTest04_A5 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A5(String strObjectName) {
+        b1_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class LiverangeSubsumeRCTest04_A6 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A6(String strObjectName) {
+        b1_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class LiverangeSubsumeRCTest04_A7 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A7(String strObjectName) {
+        b1_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class LiverangeSubsumeRCTest04_A8 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A8(String strObjectName) {
+        b1_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class LiverangeSubsumeRCTest04_A9 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A9(String strObjectName) {
+        b1_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class LiverangeSubsumeRCTest04_A10 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_A10(String strObjectName) {
+        b1_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+
+class LiverangeSubsumeRCTest04_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest04_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/LiverangeSubsumeRCTest05.java b/test/testsuite/ouroboros/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/LiverangeSubsumeRCTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..110caaef0d643e84095b232988411e4f534446a6
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/LiverangeSubsumeRCTest05.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest05
+ *- @TestCaseName: LiverangeSubsumeRCTest05
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ *  -#step1: 构造是个同一个类对象的引用指针test1,test2,test3和test4，他们同时有实例变量同时指向一块内存地址b1;
+ *  -#step2: b1的生命周期包含了这test1.b1_0,test2.b1_0和test3.b1_0的生命周期,没有包含test4.b1_0的生命周期。
+ *  -#step3: test1.b1_0,test2.b1_0和test3.b1_0的incref和decRef都应该被优化掉都应该被优化掉；test4.b1_0的incref和decRef被保留。
+ *  校验中间文件LiverangeSubsumeRCTest05.VtableImpl.mpl中无IncRef。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest05.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest05
+ *- @ExecuteArgs:
+ */
+
+public class LiverangeSubsumeRCTest05 {
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest05_Node test1 = new LiverangeSubsumeRCTest05_Node("test1");
+        LiverangeSubsumeRCTest05_Node test2 = new LiverangeSubsumeRCTest05_Node("test2");
+        LiverangeSubsumeRCTest05_Node test3 = new LiverangeSubsumeRCTest05_Node("test3");
+        LiverangeSubsumeRCTest05_Node test4 = new LiverangeSubsumeRCTest05_Node("test4");
+        LiverangeSubsumeRCTest05_B1 b1 = new LiverangeSubsumeRCTest05_B1("b1");
+        test1.b1_0 = b1;
+        test2.b1_0 = b1;
+        test3.b1_0 = b1;
+        test4.b1_0 = b1;
+        test1.b1_0.add();
+        test2.b1_0.add();
+        test3.b1_0.add();
+        test4.b1_0.add();
+        b1.add();
+        int result = test1.sum + test2.sum + test3.sum + test4.sum + test4.b1_0.sum;
+        if (result == 402) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+class LiverangeSubsumeRCTest05_Node {
+    LiverangeSubsumeRCTest05_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest05_Node(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class LiverangeSubsumeRCTest05_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest05_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/LiverangeSubsumeRCTest06.java b/test/testsuite/ouroboros/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/LiverangeSubsumeRCTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..41821779e617acf6362ddacd5fe6366d1262770d
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/LiverangeSubsumeRCTest06.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest06
+ *- @TestCaseName: LiverangeSubsumeRCTest06
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ *  -#step1: 构造是个同一个类对象的引用指针test1,test2,test3和test4，他们同时指向一块内存地址，并且他们的实例变量b1_0同时指向一块内存地址b1;
+ *  -#step2: test1的生命周期包含了test2,test3 和test4,所以test2,test3和test4的incref和dec ref都应该被优化掉。
+ *  -#step3: b1指针的生命周期包含了四个b1_0的生命周期，四个b1_0的incref，decref应该被优化掉
+ *  校验中间文件LiverangeSubsumeRCTest06.VtableImpl.mpl无IncRef
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest06.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest06
+ *- @ExecuteArgs:
+ */
+
+public class LiverangeSubsumeRCTest06 {
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest06_Node test1 = new LiverangeSubsumeRCTest06_Node("test1");
+        LiverangeSubsumeRCTest06_Node test2 = test1;
+        LiverangeSubsumeRCTest06_Node test3 = test1;
+        LiverangeSubsumeRCTest06_Node test4 = test1;
+        LiverangeSubsumeRCTest06_B1 b1 = new LiverangeSubsumeRCTest06_B1("b1");
+        test2.b1_0 = b1;
+        test2.b1_0.add();
+        test3.b1_0 = b1;
+        test3.b1_0.add();
+        test4.b1_0 = b1;
+        test4.b1_0.add();
+        test1.b1_0 = b1;
+        test1.b1_0.add();
+        int result = test1.sum + b1.sum;
+        if (result == 402) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+class LiverangeSubsumeRCTest06_Node {
+    LiverangeSubsumeRCTest06_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest06_Node(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+
+class LiverangeSubsumeRCTest06_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest06_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//        System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+
+    void add() {
+        sum = a + a;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/LiverangeSubsumeRCTest07.java b/test/testsuite/ouroboros/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/LiverangeSubsumeRCTest07.java
new file mode 100644
index 0000000000000000000000000000000000000000..151eb8145b751f2929bdcd7619de717324c7c6b2
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/LiverangeSubsumeRCTest07.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest07
+ *- @TestCaseName: LiverangeSubsumeRCTest07
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作:自成环的场景应该会被优化
+ *  -#step1: test07与test07./，而且test07.next的生命周期被test07包含，所以 test07.next的incref和dec ref都应该被优化掉。
+ *  -#step2: 这样RC的自成环问题会被优化掉，该种场景仅通过RC就可以做到内存回收
+ *  校验中间文件LiverangeSubsumeRCTest07.VtableImpl.mpl中无IncRef。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest07.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest07
+ *- @ExecuteArgs:
+ */
+public class LiverangeSubsumeRCTest07 {
+    LiverangeSubsumeRCTest07 next;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest07(String strObjectName) {
+        next = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest07 test07 = new LiverangeSubsumeRCTest07("test1");
+        test07.next = test07; // 使用intrinsiccall MCCWriteNoDec（）代替
+        test07.next.add();
+        test07.add();
+        if (test07.sum == 202) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println(test07.sum);
+        }
+    }
+
+    void add() {
+        sum = a + next.a;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/LiverangeSubsumeRCTest08.java b/test/testsuite/ouroboros/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/LiverangeSubsumeRCTest08.java
new file mode 100644
index 0000000000000000000000000000000000000000..16efd2b8f36cc7062cb15b7c2490a237a17a14d0
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/LiverangeSubsumeRCTest08.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest08
+ *- @TestCaseName: LiverangeSubsumeRCTest08
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作:两个对象成环的场景应该会被优化
+ *  -#step1: test1与test1.next是两个不同的对象，占用不同的内存空间，而且test08.next.next的生命周期被test1包含，所以 test08.next的incref和dec ref都应该被优化掉。
+ *  -#step2: 这样RC的自成环问题会被优化掉，该种场景仅通过RC就可以做到内存回收
+ *  校验中间文件LiverangeSubsumeRCTest08.VtableImpl.mpl中无IncRef。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest08.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest08
+ *- @ExecuteArgs:
+ */
+public class LiverangeSubsumeRCTest08 {
+    LiverangeSubsumeRCTest08 next;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest08(String strObjectName) {
+        next = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest08 test1 = new LiverangeSubsumeRCTest08("test1");
+        test1.next = new LiverangeSubsumeRCTest08("test2");
+        test1.next.next = test1;
+        test1.next.add();
+        test1.next.next.add();
+        test1.add();
+        if (test1.sum == 202) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println(test1.sum);
+        }
+    }
+
+    void add() {
+        sum = a + next.a;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/LiverangeSubsumeRCTest09.java b/test/testsuite/ouroboros/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/LiverangeSubsumeRCTest09.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5fdf2c4699071f319f371b3405c18141dc9d9e8
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/LiverangeSubsumeRCTest09.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest09
+ *- @TestCaseName: LiverangeSubsumeRCTest09
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作:n(n>=3)个对象成环的场景应该会被优化
+ *  -#step1: test9与它后面的next是总共5个不同的对象，并且自成环，而且并且后面的所有next的生命周期被test9包含，所以所有的.next的incref和dec ref都应该被优化掉。
+ *  -#step2: 这样RC的自成环问题也会被优化掉，该种场景仅通过RC就可以做到内存回收
+ *  校验中间文件LiverangeSubsumeRCTest09.VtableImpl.mpl中无IncRef
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest09.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest09
+ *- @ExecuteArgs:
+ */
+public class LiverangeSubsumeRCTest09 {
+    LiverangeSubsumeRCTest09 next;
+    int a;
+    int sum;
+    String strObjectName;
+
+    LiverangeSubsumeRCTest09(String strObjectName) {
+        next = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest09 test9 = new LiverangeSubsumeRCTest09("test9");
+        test9.next = new LiverangeSubsumeRCTest09("test2");
+        test9.next.next = new LiverangeSubsumeRCTest09("test3");
+        test9.next.next.next = new LiverangeSubsumeRCTest09("test4");
+        test9.next.next.next.next = new LiverangeSubsumeRCTest09("test5");
+        test9.next.next.next.next = test9;
+        test9.next.next.next.next.add();
+        test9.add();
+        if (test9.sum == 202) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println(test9.next.sum);
+        }
+    }
+
+    void add() {
+        sum = a + next.a;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/LiverangeSubsumeRCTest10.java b/test/testsuite/ouroboros/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/LiverangeSubsumeRCTest10.java
new file mode 100644
index 0000000000000000000000000000000000000000..04346e4a36405694b8e597b1f27216c1b146881a
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/LiverangeSubsumeRCTest10.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest10
+ *- @TestCaseName: LiverangeSubsumeRCTest10
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:检测在循环语句（for, while, do-while）控制流中,当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ * -#step1:函数1测试场景：周期大的对象a1初始化在for循环外，只在for循环内部使用生命周期小的a2；a2的incref和decRef都应该被优化掉
+ * -#step2:函数2测试场景：周期大的对象a1和生命周期小的对象a2对象初始化和使用都在for循环内，因为a1的生命周期完全覆盖了a2的生命周期，a2的incref和decRef都应该被优化掉；
+ * -#step3:函数3测试场景：对象初始化在do-while循环内，循环之后，仍有使用；a2的生命周期因为被完全覆盖，所以它的incref和decRef都应该被优化掉；
+ *  校验中间文件LiverangeSubsumeRCTest10.VtableImpl.mpl中无IncRef。
+ *- @Expect:a1_1a1_1a1_1a1_1a1_1a1_1a1_1a1_1a1_1a1_1100ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest10.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest10
+ *- @ExecuteArgs:
+ */
+class A {
+    public int count = 0;
+    public String className = "A";
+
+    public A(String name) {
+        this.className = name;
+    }
+
+    public void changeName(String name) {
+        this.className = name;
+    }
+}
+
+public class LiverangeSubsumeRCTest10 {
+    private static volatile int count = 0;
+    private static A infiniteLoop = null;
+    private A defInsideUseOutside = null;
+
+    public static boolean onlyUseInsideLoop() {
+        A a1 = new A("a1");
+        for (count = 0; count < 100; count++) {
+            A a2 = a1;
+            a2.changeName("a" + count);
+            a2.count = count;
+            if (count == 99)
+                a2.toString();
+        }
+        return a1.className.equals("a99");
+    }
+
+    public static void defAndUseInsideLoop() {
+        for (count = 0; count < 10; count++) {
+            A a1 = new A("a1_" + count);
+            a1.changeName("a1");
+            A a2 = a1;
+            for (int j = 0; j < 2; j++) {
+                a2.changeName("a1_" + j);
+            }
+            System.out.print(a1.className);
+        }
+    }
+
+    public static void main(String[] args) {
+        defAndUseInsideLoop();
+        new LiverangeSubsumeRCTest10().defInsideAndUseOutsideLoop();
+        if (onlyUseInsideLoop()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        do {
+            this.defInsideUseOutside = new A("a1_i" + count);
+            A a2 = this.defInsideUseOutside;
+            a2.count = count;
+            for (int j = 0; j < 2; j++)
+                a2 = new A("a2_i" + count + "_j" + j);
+            if (count == 99)
+                a2.toString();
+            count++;
+        } while (this.defInsideUseOutside.count < 100 && count < 100);
+        System.out.print(count);
+    }
+
+
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full a1_1a1_1a1_1a1_1a1_1a1_1a1_1a1_1a1_1a1_1100ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/LiverangeSubsumeRCTest11.java b/test/testsuite/ouroboros/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/LiverangeSubsumeRCTest11.java
new file mode 100644
index 0000000000000000000000000000000000000000..3bd08f85ff852225b4a9a7fd293b9529804e8eb2
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/LiverangeSubsumeRCTest11.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest11
+ *- @TestCaseName: LiverangeSubsumeRCTest11
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:检测在循环语句（if-then, if-then-else, switch）控制流中,当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ * -#step1:函数1测试场景：周期大的对象a1初始化在for循环外，只在for循环内部使用生命周期小的a2；a1的最后调用放到for循环外的if语句里，a2的incRef和decRef会被优化掉。
+ * -#step2:函数2测试场景：a2 = a1，q且在for循环内使用，在if逻辑体，a2的incref和decRef不会被优化掉，在else逻辑体内，a2的incRef和decRef会被优化掉。
+ * -#step3:函数3测试场景：a2 =a1,在不同的switch--多case里，case1：a1包含了a2,会有优化；case2：没有包含住，不做优化；case3：无代码；case4： a2 = a1;
+ *  校验中间文件LiverangeSubsumeRCTest11.VtableImpl.mpl无IncRef。
+ *- @Expect:a100\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest11.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest11
+ *- @ExecuteArgs:
+ */
+
+class A2 {
+    public int count = 0;
+    public String className = "A";
+
+    public A2(String name) {
+        this.className = name;
+    }
+
+    public void changeName(String name) {
+        this.className = name;
+    }
+}
+
+public class LiverangeSubsumeRCTest11 {
+    private volatile static int count = 0;
+
+    public static void onlyUseInsideLoop() {
+        A2 a1 = new A2("a1");
+        for (count = 0; count < 100; count++) {
+            A2 a2 = new A2("a2");
+            a2.changeName("a" + count);
+            a2.count = count;
+        }
+        if (count % 10 == 0) {
+            a1.changeName("a" + 100);
+            System.out.println(a1.className);
+        }
+    }
+
+    public static void defAndUseInsideLoop() {
+        for (count = 0; count < 10; count++) {
+            A2 a1 = new A2("a1");
+            a1.count = count;
+            A2 a2 = a1;
+            a2.changeName("null");
+            if (count % 2 == 0) {
+                a2.changeName("a" + 100);
+                a2 = new A2("a10");
+                a2.toString();
+            } else {
+                a1.changeName("a" + 100);
+                a1.toString();
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        onlyUseInsideLoop();
+        defAndUseInsideLoop();
+        new LiverangeSubsumeRCTest11().defInsideAndUseOutsideLoop();
+    }
+
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        do {
+            int choice = count % 4;
+            A2 a1 = new A2("a2_i" + count);
+            A2 a2 = a1;
+            switch (choice) {
+                case 1:
+                    a1.changeName("case 1");
+                    break;
+                case 2:
+                    a2.changeName("case 2");
+                    break;
+                case 3:
+                    break;
+                default:
+                    a1 = a2;
+            }
+            count++;
+        } while (count < 10);
+
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full a100\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/LiverangeSubsumeRCTest12.java b/test/testsuite/ouroboros/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/LiverangeSubsumeRCTest12.java
new file mode 100644
index 0000000000000000000000000000000000000000..197bff0507a4ee115508b485505b3863c6751b10
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/LiverangeSubsumeRCTest12.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest12
+ *- @TestCaseName: LiverangeSubsumeRCTest12
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:检测在跳转语句（break, continue, return）控制流中,当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ * -#step1:函数1做在continue ； continue tag的跳转for循环里，在if -else里，a1的生命周期都包含住了a3，所以a3会被优化掉
+ * -#step2:函数2测试场景：a3 = a2，且在for循环内使用，在if逻辑体，a2的incref和decRef会被优化掉，在else逻辑体内，a2的incRef和decRef不会被优化掉。
+ *  校验中间文件LiverangeSubsumeRCTest12.VtableImpl.mpl中有1个IncRef。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest12.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest12
+ *- @ExecuteArgs:
+ */
+
+class A3 {
+    public int count = 0;
+    public String className = "temp";
+
+    public A3(String name) {
+        this.className = name;
+    }
+
+    public void changeName(String name) {
+        this.className = name;
+    }
+}
+
+public class LiverangeSubsumeRCTest12 {
+    private volatile static int count = 0;
+    private A3 defInsideUseOutside = null;
+
+    //def outside, only use inside loop
+    public static void onlyUseInsideLoop() {
+        A3 a1 = new A3("a1");
+        continueTag:
+        for (count = 0; count < 10; count++) {
+            A3 a3 = a1;
+            a1.changeName("a" + count);
+            a3.count = count;
+            if (count % 8 == 0) {
+                a1.changeName("Right"); // a3没有incRef和decRef
+                continue continueTag;
+            } else {
+                a1.className = "a1_" + count; // a3没有incRef和decRef
+                continue;
+            }
+        }
+    }
+
+    public static A3 defAndUseInsideLoop() {
+        for (count = 0; count < 10; count++) {
+            A3 a2 = new A3("a2_i" + count);
+            A3 a3 = a2; //因为else分支，这边会有一个incRef
+            a2.count = count;
+            a3.changeName("null");
+            if (count % 4 == 0 && count > 0) {
+                a2.changeName("Optimization");
+                return a2;
+            } else if (count == 3) {
+                a3.changeName("NoOptimization");
+                return a3;
+            }
+        }
+        return new A3("Error");
+    }
+
+    public static void main(String[] args) {
+        onlyUseInsideLoop();
+        if (defAndUseInsideLoop().className.equals("NoOptimization")) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/LiverangeSubsumeRCTest13.java b/test/testsuite/ouroboros/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/LiverangeSubsumeRCTest13.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ce9b34f6eb561749341d7e10c80c0f1698347ec
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/LiverangeSubsumeRCTest13.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest13
+ *- @TestCaseName: LiverangeSubsumeRCTest13
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:检测在跳转语句（try---多catch）控制流中,当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ * -#step1:str2 = str;空指针的catch包含不住，不做优化外；另外两个catch都应该做incRef和decRef的优化。
+ *  校验中间文件LiverangeSubsumeRCTest13.VtableImpl.mpl中无IncRef。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest13.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest13
+ *- @ExecuteArgs:
+ */
+
+public class LiverangeSubsumeRCTest13 {
+    public static void main(String[] argv) {
+        int result = 2;
+        boolean check;
+        String str = "123#";
+        String str2 = str;
+        try {
+            str.notifyAll();
+            str = str2;
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            str = "123#456";  // 2
+            result--;
+        } catch (NullPointerException e) {
+            str2 = "123456";  // 3
+            result = 2;
+        } catch (IllegalMonitorStateException e) {
+            str2 = str;
+            result = 0;
+        }
+        if (result == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/LiverangeSubsumeRCTest14.java b/test/testsuite/ouroboros/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/LiverangeSubsumeRCTest14.java
new file mode 100644
index 0000000000000000000000000000000000000000..11964f6d7512ea56204e9c4e2944949759821e48
--- /dev/null
+++ b/test/testsuite/ouroboros/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/LiverangeSubsumeRCTest14.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Maple_CompilerOptimization_LiverangeSubsumeRCTest14
+ *- @TestCaseName: LiverangeSubsumeRCTest14
+ *- @TestCaseType: Function Testing
+ *- @RequirementName: Liverange subsumeRC优化
+ *- @Brief:当确定一个对象的在某个生存区间内的存活状态时，去掉这个区间内的此对象的RC操作
+ *  -#step1: str2 = str1;这俩指向同一个字符串地址。
+ *  -#step2: 在try里有str1 = str2; 仍然是str1的生命周期包含住了str2；所以str2的incref和decRef都会被优化掉
+ *  校验中间文件LiverangeSubsumeRCTest14.VtableImpl.mpl中无IncRef。
+ *- @Expect:ExpectResultExpectResult\n
+ *- @Priority: High
+ *- @Source: LiverangeSubsumeRCTest14.java
+ *- @ExecuteClass: LiverangeSubsumeRCTest14
+ *- @ExecuteArgs:
+ */
+
+public class LiverangeSubsumeRCTest14 {
+    public static void main(String[] args) {
+        String str1 = "ExpectResult";
+        String str2 = str1;
+        try {
+            String temp = str2.substring(0, 3);
+            temp = str1.toLowerCase();
+            str1 = str2;
+            temp = temp.equals("ExpectResult") ? temp : str1;
+            temp.notifyAll();
+            str1.notifyAll();
+        } catch (Exception e) {
+            System.out.print(str1);
+        } finally {
+            System.out.println(str1);
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ExpectResultExpectResult\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/test.cfg b/test/testsuite/ouroboros/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..88926b3bb71dce6d306954665a98c5466cce4f6b
--- /dev/null
+++ b/test/testsuite/ouroboros/test.cfg
@@ -0,0 +1,14 @@
+[suffix]
+java = //
+
+[internal-var]
+maple = python3 ${MAPLE_ROOT}/test/testsuite/maple.py
+
+run = python3 ${MAPLE_ROOT}/test/testsuite/run.py
+
+build_option = --dex2mpl="-mplt ${MAPLE_BUILD_OUTPUT}/libjava-core/libcore-all.mplt -litprofile=${MAPLE_ROOT}/src/mrt/codetricks/profile.pv/meta.list" --maple="-O2" --ld=" -L${MAPLE_BUILD_OUTPUT}/ops/host-x86_64-O2" --cxx="-I${MAPLE_BUILD_OUTPUT}/ops/libnativehelper/include_jni"
+
+run_option =
+
+[description]
+title = Maple Ouroboros Test
diff --git a/test/testsuite/ouroboros/testlist b/test/testsuite/ouroboros/testlist
new file mode 100644
index 0000000000000000000000000000000000000000..6a8ba1a931b69dea64736ffb7e886b3ffee27be1
--- /dev/null
+++ b/test/testsuite/ouroboros/testlist
@@ -0,0 +1,119 @@
+[ALL-TEST-CASE]
+    arrayboundary_test
+    clinit_test
+    eh_test
+    fuzzapi_test
+    other_test
+    parent_test
+    rc_test
+    reflection_test
+    stmtpre_test
+    string_test
+    subsumeRC_test
+    thread_test
+    unsafe_test
+    memory_management
+
+[EXCLUDE-TEST-CASE]
+    memory_management/Annotation/RC0380-rc-Annotation-RCWeakRefTest
+    memory_management/Annotation/RC0381-rc-Annotation-RCWeakRefTest2
+    reflection_test/issue-0000-rt-Reflection-ReflectionforName2
+    memory_management/MemoryTest/RC0410-rc-Memory-stressTestCase29
+    thread_test/RT0180-rt-thread-MonitorTestCase8
+    rc_test/RC0249-rc-function-RC_Finalize_03
+    rc_test/RC0380-rc-Annotation-RCWeakRefTest
+    rc_test/RC0381-rc-Annotation-RCWeakRefTest2
+    rc_test/RC0383-rc-Annotation-RCWeakRefTest4
+    rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest
+    rc_test/RC0385-rc-Annotation-RCUnownedRefTest
+    rc_test/RC0386-rc-Annotation-RCUnownedRefTest2
+    rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle
+    rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread
+    rc_test/RC0392-rc-Annotation-RCAnnotationThread02
+    rc_test/RC0394-rc-Annotation-RCAnnotationThread04
+    rc_test/RC0395-rc-Annotation-RCAnnotationThread05
+    rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle
+    rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread
+    rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle
+    rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2
+    rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread
+    rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2
+    rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle
+    rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2
+    rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread
+    rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2
+    rc_test/RC0417-rc-Annotation-RCUnownedRefTest3
+    rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3
+    rc_test/RC0419-rc-Annotation-RCUnownedLocalTest
+    rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest
+    rc_test/RC0421-rc-Annotation-RCUnownedOuterTest
+    rc_test/RC0433-rc-SoftRef-SoftRefTest03
+    rc_test/RC0440-rc-RCHeader-RCHeaderTest04
+    rc_test/RC0443-rc-PlacementRC-PlacementRCTest01
+    rc_test/RC0449-rc-RP-FinalizerReferenceTest01
+    rc_test/RC0450-rc-RP-FinalizerReferenceTest02
+    rc_test/RC0451-rc-RP-FinalizerReferenceTest03
+    rc_test/RC0453-rc-RP-FinalizerReferenceTest05
+    rc_test/RC0454-rc-RP-FinalizerReferenceTest06
+    rc_test/RC0455-rc-RP-FinalizerReferenceTest07
+    rc_test/RC0456-rc-RP-FinalizerReferenceTest08
+    rc_test/RC0458-rc-GC-TriggerGCTest02
+    rc_test/RC0459-rc-GC-TriggerGCTest03
+    rc_test/RC0463-rc-GC-TriggerGCTest07
+    rc_test/RC0464-rc-GC-TriggerGCTest08
+    rc_test/RC0465-rc-GC-TriggerGCTest09
+    rc_test/RC0466-rc-GC-TriggerGCTest10
+    rc_test/RC0486-rc-StackScan-CB_Thread_01
+    rc_test/RC0487-rc-StackScan-CB_Thread_02
+    rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01
+    rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01
+    rc_test/RC0515-GC-FrequentGCTest01
+    rc_test/common_test/RC0427-rc-Annotation-RCMixTest
+    rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest
+    rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04
+    rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06
+    rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest
+    rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02
+    rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03
+    rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06
+    rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07
+    rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03
+    rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest
+    rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2
+    rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3
+    rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4
+    rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5
+    rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread
+    rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6
+    rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2
+    rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7
+    rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3
+    rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8
+    rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4
+    rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2
+    memory_management/Annotation/RC0383-rc-Annotation-RCWeakRefTest4
+    memory_management/Annotation/RC0384-rc-Annotation-RCWeakRefThreadTest
+    memory_management/Annotation/RC0386-rc-Annotation-RCUnownedRefTest2
+    memory_management/Annotation/RC0387-rc-Annotation-RCUnownedRefUnCycle
+    memory_management/Annotation/RC0389-rc-Annotation-RCUnownedRefUncycleThread
+    memory_management/Annotation/RC0391-rc-Annotation-RCAnnotationThread01
+    memory_management/Annotation/RC0392-rc-Annotation-RCAnnotationThread02
+    memory_management/Annotation/RC0393-rc-Annotation-RCAnnotationThread03
+    memory_management/Annotation/RC0394-rc-Annotation-RCAnnotationThread04
+    memory_management/Annotation/RC0395-rc-Annotation-RCAnnotationThread05
+    memory_management/Annotation/RC0396-rc-Annotation-RCAnnotationOneCycle
+    memory_management/Annotation/RC0397-rc-Annotation-RCAnnotationOneCycleThread
+    memory_management/Annotation/RC0398-rc-Annotation-RCAnnotationTwoCycle
+    memory_management/Annotation/RC0399-rc-Annotation-RCAnnotationTwoCycle2
+    memory_management/Annotation/RC0400-rc-Annotation-RCAnnotationTwoCycleThread
+    memory_management/Annotation/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2
+    memory_management/Annotation/RC0402-rc-Annotation-RCAnnotationMultiCycle
+    memory_management/Annotation/RC0403-rc-Annotation-RCAnnotationMultiCycle2
+    memory_management/Annotation/RC0404-rc-Annotation-RCAnnotationMultiCycleThread
+    memory_management/Annotation/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2
+    memory_management/Annotation/RC0419-rc-Annotation-RCUnownedLocalTest
+    memory_management/Annotation/RC0420-rc-Annotation-RCUnownedLocalThreadTest
+    memory_management/Annotation/RC0421-rc-Annotation-RCUnownedOuterTest
+    memory_management/Annotation/RC0428-rc-Annotation-RCMixThreadTest
+    memory_management/Annotation/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02
+    memory_management/Annotation/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2
diff --git a/test/testsuite/ouroboros/thread_test/RT0001-rt-thread-ThreadactiveCount/ThreadActiveCount.java b/test/testsuite/ouroboros/thread_test/RT0001-rt-thread-ThreadactiveCount/ThreadActiveCount.java
new file mode 100644
index 0000000000000000000000000000000000000000..86ea42510ed3d7fbb6da2590de077a112b0ca408
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0001-rt-thread-ThreadactiveCount/ThreadActiveCount.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadActiveCount
+ *- @TestCaseName: Thread_ThreadActiveCount.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread.activeCount() returns an estimate of the number of active threads in the current thread's
+  *                     thread group and its subgroups.
+ *- @Brief: see below
+ * -#step1: 以god为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 以threadGroup、"banana" + i（i < 10）为参数，新建一个ThreadActiveCount线程，并调用start()方法启动该线程；
+ * -#step3: 让当前线程休眠500ms；
+ * -#step4: 因ThreadActiveCount类继承自Thread类，导致静态int型变量p的值经内部多次调用run()方法后变为10；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadActiveCount.java
+ *- @ExecuteClass: ThreadActiveCount
+ *- @ExecuteArgs:
+ */
+
+public class ThreadActiveCount extends Thread {
+    static int num;
+    static Object ob = "aa";
+
+    public ThreadActiveCount(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public static void main(String[] args) {
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        for (int i = 0; i < 10; i++) {
+            (new ThreadActiveCount(threadGroup, "banana" + i)).start();
+        }
+        try {
+            sleep(500);
+        } catch (InterruptedException e1) {
+            e1.printStackTrace();
+        }
+        if (num == 10) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+
+    public void run() {
+        synchronized (ob) {
+            num = activeCount();
+            try {
+                ob.wait(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0002-rt-thread-ThreadcheckAccess/ThreadCheckAccess.java b/test/testsuite/ouroboros/thread_test/RT0002-rt-thread-ThreadcheckAccess/ThreadCheckAccess.java
new file mode 100644
index 0000000000000000000000000000000000000000..f897f30aa986d7ecc99b4ff5daa5b9d1e9b6bc94
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0002-rt-thread-ThreadcheckAccess/ThreadCheckAccess.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadCheckAccess
+ *- @TestCaseName: Thread_ThreadCheckAccess.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread.checkAccess() returns if the current running thread has permission to modify this thread.
+ *- @Brief: see below
+ * -#step1: 创建一个Thread的实例对象threadCheckAccess；
+ * -#step2: 调用threadCheckAccess的checkAccess()方法，发现程序完整运行并未抛出任何异常；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadCheckAccess.java
+ *- @ExecuteClass: ThreadCheckAccess
+ *- @ExecuteArgs:
+ */
+
+public class ThreadCheckAccess extends Thread {
+    public static void main(String[] args) {
+        ThreadCheckAccess threadCheckAccess = new ThreadCheckAccess();
+        try {
+            threadCheckAccess.checkAccess();
+        } catch (Exception e) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0003-rt-thread-Threadclone/ThreadClone.java b/test/testsuite/ouroboros/thread_test/RT0003-rt-thread-Threadclone/ThreadClone.java
new file mode 100644
index 0000000000000000000000000000000000000000..ede4338537da84b190d00bc2bf742e58c18d4566
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0003-rt-thread-Threadclone/ThreadClone.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadClone
+ *- @TestCaseName: Thread_ThreadClone.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Using clones in threads throws CloneNotSupportedException
+ *- @Brief: see below
+ * -#step1: 创建一个Thread类的实例对象threadClone；
+ * -#step2: 调用threadClone的clone()方法会抛出CloneNotSupportedException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadClone.java
+ *- @ExecuteClass: ThreadClone
+ *- @ExecuteArgs:
+ */
+
+public class ThreadClone extends Thread {
+    public static void main(String[] args) {
+        ThreadClone threadClone = new ThreadClone();
+        try {
+            threadClone.clone();
+            System.out.println(2);
+        } catch (CloneNotSupportedException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0004-rt-thread-ThreadConstructors1/ThreadConstructors1.java b/test/testsuite/ouroboros/thread_test/RT0004-rt-thread-ThreadConstructors1/ThreadConstructors1.java
new file mode 100644
index 0000000000000000000000000000000000000000..a39495749fe0c9fa3a256df4da511f6c9599021d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0004-rt-thread-ThreadConstructors1/ThreadConstructors1.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors1
+ *- @TestCaseName: Thread_ThreadConstructors1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Constructors Thread(): create a new Thread with no parameter
+ *- @Brief: see below
+ * -#step1: 创建一个Thread类的实例对象threadConstructors1；
+ * -#step2: 调用threadConstructors1的toString()的返回值与字符串"Thread[Thread-0,5,main]"相同，表明创建一个没有参数的新
+ *          线程成功；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors1.java
+ *- @ExecuteClass: ThreadConstructors1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors1 extends Thread {
+    public ThreadConstructors1() {
+    }
+
+    public static void main(String[] args) {
+        ThreadConstructors1 threadConstructors1 = new ThreadConstructors1();
+        if (threadConstructors1.toString().equals("Thread[Thread-0,5,main]")) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0005-rt-thread-ThreadConstructors10/ThreadConstructors10.java b/test/testsuite/ouroboros/thread_test/RT0005-rt-thread-ThreadConstructors10/ThreadConstructors10.java
new file mode 100644
index 0000000000000000000000000000000000000000..e91717ec55c3b94a360904df66a51e13cad4aa4c
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0005-rt-thread-ThreadConstructors10/ThreadConstructors10.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors10
+ *- @TestCaseName: Thread_ThreadConstructors10.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verifying that the Run method is not overridden in the thread object invokes the Run method in
+ *                      the target object.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadConstructors10_a类的实例对象threadConstructors10_a；
+ * -#step2: 以threadConstructors10_a为参数，创建一个ThreadConstructors10类的实例对象threadConstructors10；
+ * -#step3: 调用threadConstructors10的start()方法启动该线程；
+ * -#step4: 调用threadConstructors10的join()方法；
+ * -#step5: 经判断得知ThreadConstructors10_a类的int类型的静态变量t的值经其内部调用run()方法后由0变为1；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors10.java
+ *- @ExecuteClass: ThreadConstructors10
+ *- @ExecuteArgs:
+ */
+
+class ThreadConstructors10_a implements Runnable {
+    static int t = 0;
+
+    public void run() {
+        t++;
+    }
+}
+
+public class ThreadConstructors10 extends Thread {
+    public ThreadConstructors10(Runnable target) {
+        super(target);
+    }
+
+    public static void main(String[] args) {
+        ThreadConstructors10_a threadConstructors10_a = new ThreadConstructors10_a();
+        ThreadConstructors10 threadConstructors10 = new ThreadConstructors10(threadConstructors10_a);
+        threadConstructors10.start();
+        try {
+            threadConstructors10.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (ThreadConstructors10_a.t == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0006-rt-thread-ThreadConstructors2/ThreadConstructors2.java b/test/testsuite/ouroboros/thread_test/RT0006-rt-thread-ThreadConstructors2/ThreadConstructors2.java
new file mode 100644
index 0000000000000000000000000000000000000000..829650569c1aeefe519912fe006739323ba44d2a
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0006-rt-thread-ThreadConstructors2/ThreadConstructors2.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors2
+ *- @TestCaseName: Thread_ThreadConstructors2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Constructors Thread(Runnable target), use super() in subclass of Thread, both run() in target
+ *                      and subclass will be executed
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadConstructors2_a类的实例对象threadConstructors2_a；
+ * -#step2: 以threadConstructors2_a为参数，创建一个ThreadConstructors2类的实例对象threadConstructors2，并且
+ *          ThreadConstructors2类的run()中含有super.run()；
+ * -#step3: 调用threadConstructors2的start()方法启动该线程；
+ * -#step4: 调用threadConstructors2的join()方法；
+ * -#step5: 经判断得知ThreadConstructors2类和ThreadConstructors2_a类的int类型的静态变量i和t经调用各自类的内部的run()方法
+ *          后均由0变为1；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors2.java
+ *- @ExecuteClass: ThreadConstructors2
+ *- @ExecuteArgs:
+ */
+
+class ThreadConstructors2_a implements Runnable {
+    static int t = 0;
+
+    public void run() {
+        t++;
+    }
+}
+
+public class ThreadConstructors2 extends Thread {
+    static int i = 0;
+
+    public ThreadConstructors2(Runnable target) {
+        super(target);
+    }
+
+    public static void main(String[] args) {
+        ThreadConstructors2_a threadConstructors2_a = new ThreadConstructors2_a();
+        ThreadConstructors2 threadConstructors2 = new ThreadConstructors2(threadConstructors2_a);
+        threadConstructors2.start();
+        try {
+            threadConstructors2.join();
+        } catch (InterruptedException e) {
+        }
+        if (i == 1) {
+            if (ThreadConstructors2_a.t == 1) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0007-rt-thread-ThreadConstructors3/ThreadConstructors3.java b/test/testsuite/ouroboros/thread_test/RT0007-rt-thread-ThreadConstructors3/ThreadConstructors3.java
new file mode 100644
index 0000000000000000000000000000000000000000..207d78e85cbb97403ddfc74a6f3128f22fb68ddf
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0007-rt-thread-ThreadConstructors3/ThreadConstructors3.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors3
+ *- @TestCaseName: Thread_ThreadConstructors3.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Constructors Thread(Runnable target) don't use super() in subclass of Thread, only run() in
+ *                      subclass will be executed.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadConstructors3_a类的实例对象threadConstructors3_a；
+ * -#step2: 以threadConstructors3_a为参数，创建一个ThreadConstructors3类的实例对象threadConstructors3,并且
+ *          ThreadConstructors3类的run()中不含有super.run()；
+ * -#step3: 调用threadConstructors3的start()方法启动该线程；
+ * -#step4: 调用threadConstructors3的join()方法；
+ * -#step5: 经判断得知ThreadConstructors3类的int类型的静态变量i经调用其内部的run()方法后由0变为1，而
+ *          ThreadConstructors3_a类的int类型的静态变量t始终为0；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors3.java
+ *- @ExecuteClass: ThreadConstructors3
+ *- @ExecuteArgs:
+ */
+
+class ThreadConstructors3_a implements Runnable {
+    static int t = 0;
+
+    public void run() {
+        t++;
+    }
+}
+
+public class ThreadConstructors3 extends Thread {
+    static int i = 0;
+
+    public ThreadConstructors3(Runnable target) {
+        super(target);
+    }
+
+    public static void main(String[] args) {
+        ThreadConstructors3_a threadConstructors3_a = new ThreadConstructors3_a();
+        ThreadConstructors3 threadConstructors3 = new ThreadConstructors3(threadConstructors3_a);
+        threadConstructors3.start();
+        try {
+            threadConstructors3.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1) {
+            if (ThreadConstructors3_a.t == 0) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0008-rt-thread-ThreadConstructors4/ThreadConstructors4.java b/test/testsuite/ouroboros/thread_test/RT0008-rt-thread-ThreadConstructors4/ThreadConstructors4.java
new file mode 100644
index 0000000000000000000000000000000000000000..d5e142f26bcfd3be3be86e0631b330a53c4c167d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0008-rt-thread-ThreadConstructors4/ThreadConstructors4.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors4
+ *- @TestCaseName: Thread_ThreadConstructors4.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Constructors Thread(ThreadGroup group, Runnable target), use super() in subclass of Thread,
+ *                      both run() in target and subclass will be executed
+ *- @Brief: see below
+ * -#step1: 以god为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 创建一个ThreadConstructors4_a类的实例对象threadConstructors4_a；
+ * -#step3: 以threadGroup、threadConstructors4_a为参数，创建一个ThreadConstructors4类的实例对象threadConstructors4，并且
+ *          ThreadConstructors4类的run()中含有super.run()；
+ * -#step4: 令threadConstructors4.getThreadGroup().toString()的返回值为message；
+ * -#step5: 调用threadConstructors4的start()方法启动该线程；
+ * -#step6: 调用threadConstructors4的join()方法；
+ * -#step7: 经判断得知ThreadConstructors4类和ThreadConstructors4_a类的int类型的静态变量经调用各自类内部的run()方法后均由
+ *          0变为1，且message的信息与字符串"java.lang.ThreadGroup[name=god,maxpri=10]"相同；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors4.java
+ *- @ExecuteClass: ThreadConstructors4
+ *- @ExecuteArgs:
+ */
+
+class ThreadConstructors4_a implements Runnable {
+    static int t = 0;
+
+    public void run() {
+        t++;
+    }
+}
+
+public class ThreadConstructors4 extends Thread {
+    static int i = 0;
+
+    public ThreadConstructors4(ThreadGroup group, Runnable target) {
+        super(group, target);
+    }
+
+    public static void main(String[] args) {
+        String message;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadConstructors4_a threadConstructors4_a = new ThreadConstructors4_a();
+        ThreadConstructors4 threadConstructors4 = new ThreadConstructors4(threadGroup, threadConstructors4_a);
+        message = threadConstructors4.getThreadGroup().toString();
+        threadConstructors4.start();
+        try {
+            threadConstructors4.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (i == 1) {
+            if (ThreadConstructors4_a.t == 1) {
+                if (message.equals("java.lang.ThreadGroup[name=god,maxpri=10]")) {
+                    System.out.println(0);
+                    return;
+                }
+            }
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0009-rt-thread-ThreadConstructors5/ThreadConstructors5.java b/test/testsuite/ouroboros/thread_test/RT0009-rt-thread-ThreadConstructors5/ThreadConstructors5.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e1e298338990c5e01337ad2e662e222b596dcaf
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0009-rt-thread-ThreadConstructors5/ThreadConstructors5.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors5
+ *- @TestCaseName: Thread_ThreadConstructors5.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Constructors Thread(String name), Thread.getName() return the name set in constructors.
+ *- @Brief: see below
+ * -#step1: 以good为参数，创建一个ThreadConstructors5类的实例对象threadConstructors5；
+ * -#step2: 调用threadConstructors5的getName()方法，得知其返回值与字符串"good"相同；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadConstructors5.java
+ *- @ExecuteClass: ThreadConstructors5
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors5 extends Thread {
+    public ThreadConstructors5(String name) {
+        super(name);
+    }
+
+    public static void main(String[] args) {
+        ThreadConstructors5 threadConstructors5 = new ThreadConstructors5("good");
+        if (threadConstructors5.getName().equals("good")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0010-rt-thread-ThreadConstructors6/ThreadConstructors6.java b/test/testsuite/ouroboros/thread_test/RT0010-rt-thread-ThreadConstructors6/ThreadConstructors6.java
new file mode 100644
index 0000000000000000000000000000000000000000..1bdd139689f3a5571cd7292c1307fa6fd683050d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0010-rt-thread-ThreadConstructors6/ThreadConstructors6.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors6
+ *- @TestCaseName: Thread_ThreadConstructors6.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Constructors Thread(ThreadGroup group, String name).
+ *- @Brief: see below
+ * -#step1: 以god为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 以threadGroup、good为参数，创建一个ThreadConstructors6类的实例对象threadConstructors6；
+ * -#step3: 经判断得知threadConstructors6.toString()的返回值与字符串"Thread[good,5,god]"相同；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors6.java
+ *- @ExecuteClass: ThreadConstructors6
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors6 extends Thread {
+    public ThreadConstructors6(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public static void main(String[] args) {
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadConstructors6 threadConstructors6 = new ThreadConstructors6(threadGroup, "good");
+        if (threadConstructors6.toString().equals("Thread[good,5,god]")) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0011-rt-thread-ThreadConstructors7/ThreadConstructors7.java b/test/testsuite/ouroboros/thread_test/RT0011-rt-thread-ThreadConstructors7/ThreadConstructors7.java
new file mode 100644
index 0000000000000000000000000000000000000000..9258934d969adf50474ef6993b80c850c7e15a3a
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0011-rt-thread-ThreadConstructors7/ThreadConstructors7.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors7
+ *- @TestCaseName: Thread_ThreadConstructors7.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Constructors Thread(Runnable target, String name), use super() in subclass of Thread, both run()
+  *                     in target and subclass will be executed.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadConstructors7_a类的实例对象threadConstructors7_a；
+ * -#step2: 以threadConstructors7_a、good为参数，创建一个ThreadConstructors7类的实例对象threadConstructors7，并且
+ *          ThreadConstructors7类的run()方法中含有super.run()；
+ * -#step3: 调用threadConstructors7的start()方法启动该线程；
+ * -#step4: 调用threadConstructors7的join()方法；
+ * -#step5: 经判断得知ThreadConstructors7类和ThreadConstructors7_a类的int类型的静态变量i和t经调用各自内部的run()方法后均
+ *          为1，并且threadConstructors7.getName()的返回值与字符串"good"相同；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors7.java
+ *- @ExecuteClass: ThreadConstructors7
+ *- @ExecuteArgs:
+ */
+
+class ThreadConstructors7_a implements Runnable {
+    static int t = 0;
+
+    public void run() {
+        t++;
+    }
+}
+
+public class ThreadConstructors7 extends Thread {
+    static int i = 0;
+
+    public ThreadConstructors7(Runnable target, String name) {
+        super(target, name);
+    }
+
+    public static void main(String[] args) {
+        ThreadConstructors7_a threadConstructors7_a = new ThreadConstructors7_a();
+        ThreadConstructors7 threadConstructors7 = new ThreadConstructors7(threadConstructors7_a, "good");
+        threadConstructors7.start();
+        try {
+            threadConstructors7.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1) {
+            if (ThreadConstructors7_a.t == 1) {
+                if (threadConstructors7.getName().equals("good")) {
+                    System.out.println(0);
+                    return;
+                }
+            }
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/thread_test/RT0012-rt-thread-ThreadConstructors8/ThreadConstructors8.java b/test/testsuite/ouroboros/thread_test/RT0012-rt-thread-ThreadConstructors8/ThreadConstructors8.java
new file mode 100644
index 0000000000000000000000000000000000000000..205d92622b09898087bb371d8a6e7bee48ded360
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0012-rt-thread-ThreadConstructors8/ThreadConstructors8.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors8
+ *- @TestCaseName: Thread_ThreadConstructors8.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Constructors Thread(ThreadGroup group, Runnable target, String name), use super() in subclass of
+  *                     Thread, both run() in target and subclass will be executed
+ *- @Brief: see below
+ * -#step1: 以god为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 创建一个ThreadConstructors8_a类的实例对象threadConstructors8_a；
+ * -#step3: 以threadGroup、threadConstructors8_a、good为参数，创建一个ThreadConstructors8类的实例对象
+ *          threadConstructors8，并且ThreadConstructors8类的run()方法中含有super.run()；
+ * -#step4: 令threadConstructors8.getThreadGroup().toString()的返回值为message；
+ * -#step5: 调用threadConstructors8的start()方法启动该线程；
+ * -#step6: 调用threadConstructors8的join()方法；
+ * -#step7: 经判断得知ThreadConstructors8类和ThreadConstructors8_a类的int类型的静态变量i和t经调用各自内部的run()方法后均
+ *          由0变为1，并且message的信息与字符串"java.lang.ThreadGroup[name=god,maxpri=10]"相同，另外
+ *          threadConstructors8.getName()的返回值与字符串"good"相同；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors8.java
+ *- @ExecuteClass: ThreadConstructors8
+ *- @ExecuteArgs:
+ */
+
+class ThreadConstructors8_a implements Runnable {
+    static int t = 0;
+
+    public void run() {
+        t++;
+    }
+}
+
+public class ThreadConstructors8 extends Thread {
+    static int i = 0;
+
+    public ThreadConstructors8(ThreadGroup group, Runnable target, String name) {
+        super(group, target, name);
+    }
+
+    public static void main(String[] args) {
+        String message;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadConstructors8_a threadConstructors8_a = new ThreadConstructors8_a();
+        ThreadConstructors8 threadConstructors8 = new ThreadConstructors8(threadGroup, threadConstructors8_a,
+                "good");
+        message = threadConstructors8.getThreadGroup().toString();
+        threadConstructors8.start();
+        try {
+            threadConstructors8.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1 && ThreadConstructors8_a.t == 1) {
+            if (message.equals("java.lang.ThreadGroup[name=god,maxpri=10]")) {
+                if (threadConstructors8.getName().equals("good")) {
+                    System.out.println(0);
+                    return;
+                }
+            }
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0013-rt-thread-ThreadConstructors9/ThreadConstructors9.java b/test/testsuite/ouroboros/thread_test/RT0013-rt-thread-ThreadConstructors9/ThreadConstructors9.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae43ac41824b1ad900cbe0c039e525e1d5345989
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0013-rt-thread-ThreadConstructors9/ThreadConstructors9.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors9
+ *- @TestCaseName: Thread_ThreadConstructors9.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Constructors Thread(ThreadGroup group, Runnable target, String name, long stackSize),use super()
+  *                     in subclass of Thread, both run() in target and subclass will be executed
+ *- @Brief: see below
+ * -#step1: 以god为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 创建一个ThreadConstructors9_a类的实例对象threadConstructors9_a；
+ * -#step3: 以threadGroup、threadConstructors9_a、good为参数，创建一个ThreadConstructors9类的实例对象
+ *          threadConstructors9，并且ThreadConstructors9类的run()方法中含有super.run()；
+ * -#step4: 令threadConstructors9.getThreadGroup().toString()的返回值为message；
+ * -#step5: 调用threadConstructors9的start()方法启动该线程；
+ * -#step6: 调用threadConstructors9的join()方法；
+ * -#step7: 经判断得知ThreadConstructors9类和ThreadConstructors9_a类的int类型的静态变量i和t经调用各自内部的run()方法后均
+ *          由0变为1，并且k = stackSize= 1073741824, message的信息与字符串"java.lang.ThreadGroup[name=god,maxpri=10]"相
+ *          同，另外threadConstructors9.getName()的返回值与字符串"good"相同；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors9.java
+ *- @ExecuteClass: ThreadConstructors9
+ *- @ExecuteArgs:
+ */
+
+class ThreadConstructors9_a implements Runnable {
+    static int t = 0;
+
+    public void run() {
+        t++;
+    }
+}
+
+public class ThreadConstructors9 extends Thread {
+    static int i = 0;
+    static long k;
+
+    public ThreadConstructors9(ThreadGroup group, Runnable target, String name, long stackSize) {
+        super(group, target, name, stackSize);
+        k = stackSize;
+    }
+
+    public static void main(String[] args) {
+        String message;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadConstructors9_a threadConstructors9_a = new ThreadConstructors9_a();
+        ThreadConstructors9 threadConstructors9 = new ThreadConstructors9(threadGroup, threadConstructors9_a,
+                "good", 1 << 30);
+        message = threadConstructors9.getThreadGroup().toString();
+        threadConstructors9.start();
+        try {
+            threadConstructors9.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1 && k == 1073741824 && ThreadConstructors9_a.t == 1) {
+            if (message.equals("java.lang.ThreadGroup[name=god,maxpri=10]")) {
+                if (threadConstructors9.getName().equals("good")) {
+                    System.out.println(0);
+                    return;
+                }
+            }
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0014-rt-thread-ThreadcurrentThread/ThreadCurrentThread.java b/test/testsuite/ouroboros/thread_test/RT0014-rt-thread-ThreadcurrentThread/ThreadCurrentThread.java
new file mode 100644
index 0000000000000000000000000000000000000000..235cd3fdd2b244b5a32fc886e85827eb517f4b8f
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0014-rt-thread-ThreadcurrentThread/ThreadCurrentThread.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadcurrentThread
+ *- @TestCaseName: Thread_ThreadCurrentThread.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: currentThread() Returns a reference to the currently executing thread object.
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadCurrentThread类的实例对象并分别命名为threadCurrentThread1、threadCurrentThread2；
+ * -#step2: 给threadCurrentThread1起一个线程名为good，并调用其start()方法启动该线程，给threadCurrentThread2起一个线程名
+ *          为bad，并调用其start()方法启动该线程；
+ * -#step3: 分别调用threadCurrentThread1、threadCurrentThread2的join()方法；
+ * -#step4: 经判断得知currentThread().getName()的返回值与字符串"main"相同，并且ThreadCurrentThread类因继承自Thread类，其
+ *          内部调用了两次run()方法后使得int类型的静态变量nameMatch由0变为2；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadCurrentThread.java
+ *- @ExecuteClass: ThreadCurrentThread
+ *- @ExecuteArgs:
+ */
+
+public class ThreadCurrentThread extends Thread {
+    static int nameMatch = 0;
+    Object a = new Object();
+
+    public static void main(String[] args) {
+        ThreadCurrentThread threadCurrentThread1 = new ThreadCurrentThread();
+        ThreadCurrentThread threadCurrentThread2 = new ThreadCurrentThread();
+        threadCurrentThread1.setName("good");
+        threadCurrentThread2.setName("bad");
+        threadCurrentThread1.start();
+        threadCurrentThread2.start();
+        try {
+            threadCurrentThread1.join();
+            threadCurrentThread2.join();
+        } catch (Exception e) {
+            System.out.println("Join is interrupted");
+        }
+        if (currentThread().getName().equals("good")) {
+            System.out.println(2);
+        }
+        if (currentThread().getName().equals("bad")) {
+            System.out.println(3);
+        }
+        if (currentThread().getName().equals("main")) {
+            if (nameMatch == 2) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+    }
+
+    public synchronized void run() {
+        if (currentThread().getName() == getName()) {
+            synchronized (a) {
+                nameMatch++;
+            }
+        }
+        try {
+            wait(500);
+        } catch (InterruptedException e1) {
+            System.out.println("Wait is interrupted");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/ThreadDMCountStackFrames1.java b/test/testsuite/ouroboros/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/ThreadDMCountStackFrames1.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc462d8b64b624250a15def08c8aacd9a3959bf0
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/ThreadDMCountStackFrames1.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadDMCountStackFrames1
+ *- @TestCaseName: Thread_ThreadDMCountStackFrames1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Get the count of stack frames of a suspended thread by calling method countStackFrames(), the
+ *                      count should be >= 0.
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Override method run() and call suspend() in it.
+ * -#step3: Start the thread.
+ * -#step4: Get the count of stack frames of a suspended thread by calling method countStackFrames()
+ * -#step5: Check the count of stack frames of a suspended thread Greater than or equal to 0.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadDMCountStackFrames1.java
+ *- @ExecuteClass: ThreadDMCountStackFrames1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadDMCountStackFrames1 extends Thread{
+    static int eCnt = 0;
+
+    public static void main(String[] args) {
+        ThreadDMCountStackFrames1 thread_obj = new ThreadDMCountStackFrames1();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+
+        if (thread_obj.countStackFrames() >= 0 && eCnt == 1) {
+            System.out.println(0);
+            return;
+        }
+
+        thread_obj.stop();
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (this) {
+            try {
+                this.suspend();
+            } catch (UnsupportedOperationException e2) {
+                eCnt ++;
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/ThreadDMCountStackFrames2.java b/test/testsuite/ouroboros/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/ThreadDMCountStackFrames2.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ee5cf24d8bd1c2711bd0414612531c79ef3761b
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/ThreadDMCountStackFrames2.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadDMCountStackFrames2
+ *- @TestCaseName: Thread_ThreadDMCountStackFrames2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Get the stack frame with no pending thread to report IllegalThreadStateException.
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Override method run() without suspend().
+ * -#step3: Start the thread.
+ * -#step4: Check that IllegalThreadStateException occurs when calling method countStackFrames().
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadDMCountStackFrames2.java
+ *- @ExecuteClass: ThreadDMCountStackFrames2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadDMCountStackFrames2 extends Thread {
+    public static void main(String[] args) {
+        ThreadDMCountStackFrames2 thread_obj = new ThreadDMCountStackFrames2();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.countStackFrames();
+        } catch (IllegalThreadStateException e3) {
+            System.out.println(2);
+            return;
+        }
+
+        System.out.println(0);
+    }
+
+    public void run() {
+        synchronized (this) {
+            try {
+                sleep(100);
+            } catch (InterruptedException e2) {
+                System.err.println(e2);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0017-rt-thread-ThreadDMdestroy/ThreadDMDestroy.java b/test/testsuite/ouroboros/thread_test/RT0017-rt-thread-ThreadDMdestroy/ThreadDMDestroy.java
new file mode 100644
index 0000000000000000000000000000000000000000..970cabf78c1ba5b3b67a3b7731fdf0010f8d526f
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0017-rt-thread-ThreadDMdestroy/ThreadDMDestroy.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadDMDestroy
+ *- @TestCaseName: Thread_ThreadDMDestroy.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Destroy() is Deprecated and throws UnsupportedOperationException in
+ *                      Android(throws NoSuchMethodError in JDK).
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Override method run().
+ * -#step3: Start the thread.
+ * -#step4: Check that UnsupportedOperationException occurs when calling method Destroy().
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadDMDestroy.java
+ *- @ExecuteClass: ThreadDMDestroy
+ *- @ExecuteArgs:
+ */
+
+public class ThreadDMDestroy extends Thread {
+    public static void main(String[] args) {
+        ThreadDMDestroy thread_obj = new ThreadDMDestroy();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.destroy();
+        } catch (UnsupportedOperationException e2) {
+            System.out.println(0);
+            return;
+        } catch (NoSuchMethodError e3) {
+            System.out.println(1);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (this) {
+            try {
+                sleep(100);
+            } catch (InterruptedException e4) {
+                System.err.println(e4);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0018-rt-thread-ThreadDMresume/ThreadDMResume.java b/test/testsuite/ouroboros/thread_test/RT0018-rt-thread-ThreadDMresume/ThreadDMResume.java
new file mode 100644
index 0000000000000000000000000000000000000000..904ee4ecea9766148c6d5819c1a9db77d331711c
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0018-rt-thread-ThreadDMresume/ThreadDMResume.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadDMResume
+ *- @TestCaseName: Thread_ThreadDMResume.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Use of deprecated method resume() throws UnsupportedOperationException in Android.
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Override method run().
+ * -#step3: Start the thread.
+ * -#step4: Check that UnsupportedOperationException occurs when calling method resume().
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadDMResume.java
+ *- @ExecuteClass: ThreadDMResume
+ *- @ExecuteArgs:
+ */
+
+public class ThreadDMResume extends Thread {
+    static int i = 0;
+
+    public static void main(String[] args) {
+        ThreadDMResume thread_obj = new ThreadDMResume();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.resume();
+        } catch (UnsupportedOperationException e2) {
+            System.out.println(0);
+            return;
+        }
+
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (this) {
+            i++;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0019-rt-thread-ThreadDMstop/ThreadDMStop.java b/test/testsuite/ouroboros/thread_test/RT0019-rt-thread-ThreadDMstop/ThreadDMStop.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2460178a080d42844f0722e75a88a51e98f7f89
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0019-rt-thread-ThreadDMstop/ThreadDMStop.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadDMStop
+ *- @TestCaseName: Thread_ThreadDMStop.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Stop() is Deprecated and throws UnsupportedOperationException in Android. Other threads
+ *                      interrupt Target thread behavior.
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Override method run().
+ * -#step3: Start the thread.
+ * -#step4: Check that UnsupportedOperationException occurs when calling method stop().
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadDMStop.java
+ *- @ExecuteClass: ThreadDMStop
+ *- @ExecuteArgs:
+ */
+
+public class ThreadDMStop extends Thread {
+    static int i = 0;
+
+    public static void main(String[] args) {
+        long j;
+        long k;
+        ThreadDMStop thread_obj = new ThreadDMStop();
+        thread_obj.start();
+        j = System.currentTimeMillis();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.stop();
+        } catch (UnsupportedOperationException e2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (this) {
+            try {
+                wait(100);
+                i++;
+            } catch (InterruptedException e3) {
+                System.err.println(e3);
+            }
+        }
+        synchronized (this) {
+            for (int a = 0; a < 3; a++) {
+                try {
+                    sleep(1000);
+                    i++;
+                } catch (InterruptedException e4) {
+                    System.err.println(e4);
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0020-rt-thread-ThreadDMstopTh/ThreadDMStopThrowable.java b/test/testsuite/ouroboros/thread_test/RT0020-rt-thread-ThreadDMstopTh/ThreadDMStopThrowable.java
new file mode 100644
index 0000000000000000000000000000000000000000..afe4022b11f8072ec7ad9ddde205285dd28fd8a9
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0020-rt-thread-ThreadDMstopTh/ThreadDMStopThrowable.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadDMStopThrowable
+ *- @TestCaseName: Thread_ThreadDMStopThrowable.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Stop(Throwable) is Deprecated and throws UnsupportedOperationException in Android.
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Override method run().
+ * -#step3: Start the thread.
+ * -#step4: Check that UnsupportedOperationException occurs when calling method stop(Throwable).
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadDMStopThrowable.java
+ *- @ExecuteClass: ThreadDMStopThrowable
+ *- @ExecuteArgs:
+ */
+
+public class ThreadDMStopThrowable extends Thread {
+    public static void main(String[] args) {
+        Throwable aaa = null;
+        ThreadDMStopThrowable thread_obj = new ThreadDMStopThrowable();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.stop(aaa);
+        } catch (UnsupportedOperationException e2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (this) {
+            try {
+                sleep(100);
+            } catch (InterruptedException e4) {
+                System.err.println(e4);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0021-rt-thread-ThreadDMsuspend/ThreadDMSuspend.java b/test/testsuite/ouroboros/thread_test/RT0021-rt-thread-ThreadDMsuspend/ThreadDMSuspend.java
new file mode 100644
index 0000000000000000000000000000000000000000..d677665ca2224b93b51ae290c255fcc68e2db2d7
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0021-rt-thread-ThreadDMsuspend/ThreadDMSuspend.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadDMSuspend
+ *- @TestCaseName: Thread_ThreadDMSuspend.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: suspend() is Deprecated and throws UnsupportedOperationException in Android.
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Override method run().
+ * -#step3: Start the thread.
+ * -#step4: Check that UnsupportedOperationException occurs when calling method suspend().
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadDMSuspend.java
+ *- @ExecuteClass: ThreadDMSuspend
+ *- @ExecuteArgs:
+ */
+
+public class ThreadDMSuspend extends Thread {
+    static int i = 0; /* STATUS_Success */
+
+    public static void main(String[] args) {
+        ThreadDMSuspend thread_obj = new ThreadDMSuspend();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e2) {
+            System.err.println(e2);
+        }
+        try {
+            thread_obj.suspend();
+            thread_obj.stop();
+        } catch (UnsupportedOperationException e3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (this) {
+            try {
+                sleep(100);
+            } catch (InterruptedException e1) {
+                System.err.println(e1);
+            }
+            i++;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0022-rt-thread-Threadenumerate/ThreadEnumerate.java b/test/testsuite/ouroboros/thread_test/RT0022-rt-thread-Threadenumerate/ThreadEnumerate.java
new file mode 100644
index 0000000000000000000000000000000000000000..8bab55b6b8df5e3276fb46a0616c7a16bd35183b
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0022-rt-thread-Threadenumerate/ThreadEnumerate.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadEnumerate
+ *- @TestCaseName: Thread_ThreadEnumerate.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: enumerate(Thread[] tarray) Copies into the specified array every active thread in the current
+ *                      thread's thread group and its subgroups.
+ *- @Brief: see below
+ * -#step1: 定义线程类继承Thread类，包含静态线程组变量，并构造含参的构造方法。
+ * -#step2：定义线程安全的run()方法。
+ * -#step3：调用ThreadGroup()并实例化对象，启动线程并将线程添加到指定线程组。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadEnumerate.java
+ *- @ExecuteClass: ThreadEnumerate
+ *- @ExecuteArgs:
+ */
+
+public class ThreadEnumerate extends Thread {
+    static Thread[] p;
+    static int w, q;
+    static Object ob = "aa";
+
+    public ThreadEnumerate(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public static void main(String[] args) {
+        ThreadGroup cls1 = new ThreadGroup("god");
+        for (int i = 0; i < 10; i++) {
+            (new ThreadEnumerate(cls1, "banana" + i)).start();
+        }
+        try {
+            sleep(500);
+        } catch (InterruptedException e1) {
+        }
+        if (w == 10) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (ob) {
+            q = activeCount();
+            p = new Thread[q + 1];
+            w = enumerate(p);
+            try {
+                ob.wait(1000);
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0023-rt-thread-Threadextends1/ThreadExtends1.java b/test/testsuite/ouroboros/thread_test/RT0023-rt-thread-Threadextends1/ThreadExtends1.java
new file mode 100644
index 0000000000000000000000000000000000000000..91d80be80deaf966446937a3b3cc25a271ed4a7e
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0023-rt-thread-Threadextends1/ThreadExtends1.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadExtends1
+ *- @TestCaseName: Thread_ThreadExtends1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Repeat start a thread. IllegalThreadStateException is thrown if the thread was already started.
+ *- @Brief: see below
+ * -#step1: 定义含私有变量的类ThreadExtends1，继承于Thread类。
+ * -#step2: 创建线程安全的run()方法。
+ * -#step3: 利用new得到ThreadExtends1的对象，启动一个对象线程，抛出IllegalThreadStateException。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadExtends1.java
+ *- @ExecuteClass: ThreadExtends1
+ *- @ExecuteArgs:
+ */
+
+class ThreadExtends1 extends Thread {
+    private int ticket = 10;
+
+    public static void main(String[] args) {
+        ThreadExtends1 cls1 = new ThreadExtends1();
+        ThreadExtends1 cls2 = new ThreadExtends1();
+        ThreadExtends1 cls3 = new ThreadExtends1();
+        try {
+            cls1.start();
+            cls1.start();
+            cls1.start();
+        } catch (IllegalThreadStateException e) {
+            System.out.println(0);
+        }
+    }
+
+    public synchronized void run() {
+        for (int i = 0; i < 20; i++) {
+            if (this.ticket > 0) {
+                this.ticket--;
+            } else {
+                break;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0024-rt-thread-Threadextends2/ThreadExtends2.java b/test/testsuite/ouroboros/thread_test/RT0024-rt-thread-Threadextends2/ThreadExtends2.java
new file mode 100644
index 0000000000000000000000000000000000000000..0ce79eb833aaa3b23db13ed93d005bd6ff1c4dfc
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0024-rt-thread-Threadextends2/ThreadExtends2.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadExtends2
+ *- @TestCaseName: Thread_ThreadExtends2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Start different threads after inheritance
+ *- @Brief: see below
+ * -#step1: 定义含私有变量的类ThreadExtends1，继承于Thread类。
+ * -#step2: 创建线程安全的run()方法。
+ * -#step3: 利用new得到ThreadExtends1的对象，启动每一个对象线程。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadExtends2.java
+ *- @ExecuteClass: ThreadExtends2
+ *- @ExecuteArgs:
+ */
+
+class ThreadExtends2 extends Thread {
+    private int ticket = 10;
+
+    public static void main(String[] args) {
+        ThreadExtends2 cls1 = new ThreadExtends2();
+        ThreadExtends2 cls2 = new ThreadExtends2();
+        ThreadExtends2 cls3 = new ThreadExtends2();
+        try {
+            cls1.start();
+            cls2.start();
+            cls3.start();
+        } catch (Exception e) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+
+    public synchronized void run() {
+        for (int i = 0; i < 20; i++) {
+            if (this.ticket > 0) {
+                this.ticket--;
+            } else {
+                break;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/ThreadGetDefaultUncaughtExceptionHandler1.java b/test/testsuite/ouroboros/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/ThreadGetDefaultUncaughtExceptionHandler1.java
new file mode 100644
index 0000000000000000000000000000000000000000..367e808549df8719ae9fd1e84f35fa927ec71d78
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/ThreadGetDefaultUncaughtExceptionHandler1.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetDefaultUncaughtExceptionHandler1
+ *- @TestCaseName: Thread_ThreadGetDefaultUncaughtExceptionHandler1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Use setDefaultUncaughtExceptionHandler to set the default exception handling subroutine, call
+ *                      getDefaultExceptionHandler() can get the handler.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadGetDefaultUncaughtExceptionHandler1，含run()方法。
+ * -#step2: New一个ThreadGetDefaultUncaughtExceptionHandler1的对象，使用setDefaultUncaughtExceptionHandler()设置默认的
+ *           异常处理程序。
+ * -#step3：启动线程对象，可以获取处理程序，确认结果正确。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadGetDefaultUncaughtExceptionHandler1.java
+ *- @ExecuteClass: ThreadGetDefaultUncaughtExceptionHandler1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetDefaultUncaughtExceptionHandler1 extends Thread{
+    static String p;
+    public void run() {
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+        ThreadGetDefaultUncaughtExceptionHandler1 cls=new ThreadGetDefaultUncaughtExceptionHandler1();
+        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        cls.start();
+        try {
+            cls.join();
+        } catch (InterruptedException e1) {
+        }
+        p=Thread.getDefaultUncaughtExceptionHandler().toString();
+        if (p.indexOf("ThreadGetDefaultUncaughtExceptionHandle") !=-1) {
+            if (p.toString().indexOf("$") !=-1) {
+                if (p.toString().indexOf("@") !=-1) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/ThreadGetDefaultUncaughtExceptionHandler2.java b/test/testsuite/ouroboros/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/ThreadGetDefaultUncaughtExceptionHandler2.java
new file mode 100644
index 0000000000000000000000000000000000000000..3936270b3685430820f48d88865c9eca63c3b727
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/ThreadGetDefaultUncaughtExceptionHandler2.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetDefaultUncaughtExceptionHandler2
+ *- @TestCaseName: Thread_ThreadGetDefaultUncaughtExceptionHandler2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Failed to get default exception handler after setting non-default exception capture subroutine
+ *                      (setUncaughtExceptionHandler)
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadGetDefaultUncaughtExceptionHandler1，含run()方法。
+ * -#step2: New一个ThreadGetDefaultUncaughtExceptionHandler1的对象，使用setDefaultUncaughtExceptionHandler()设置默认的
+ *           异常处理程序。
+ * -#step3: 启动线程对象，不可以获取处理程序，NullPointerException抛出。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadGetDefaultUncaughtExceptionHandler2.java
+ *- @ExecuteClass: ThreadGetDefaultUncaughtExceptionHandler2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetDefaultUncaughtExceptionHandler2 extends Thread{
+    public void run() {
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+        ThreadGetDefaultUncaughtExceptionHandler2 cls=new ThreadGetDefaultUncaughtExceptionHandler2();
+        cls.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        cls.start();
+        try {
+            cls.join();
+        } catch (InterruptedException e1) {
+        }
+        try {
+            Thread.getDefaultUncaughtExceptionHandler().toString();
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0027-rt-thread-ThreadgetId/ThreadGetId.java b/test/testsuite/ouroboros/thread_test/RT0027-rt-thread-ThreadgetId/ThreadGetId.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c0aac645a4cd4baebe5fd2ec2a36a0a79d9f82f
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0027-rt-thread-ThreadgetId/ThreadGetId.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetId
+ *- @TestCaseName: Thread_ThreadGetId.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: GetId() Returns the identifier of this Thread as a positive long number.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadGetId类的实例对象threadGetId，且ThreadGetId类继承自Thread类；
+ * -#step2: 调用threadGetId的start()方法启动该线程；
+ * -#step3: 通过threadGetId的getId()方法获取到其id，并赋值给Long类型的变量i；
+ * -#step4: 确定变量i是Long类型的一个实例；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadGetId.java
+ *- @ExecuteClass: ThreadGetId
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetId extends Thread {
+    public static void main(String[] args) {
+        Long i;
+        ThreadGetId threadGetId = new ThreadGetId();
+        threadGetId.start();
+        i = threadGetId.getId();
+        if (i instanceof Long) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0028-rt-thread-ThreadgetName/ThreadGetName.java b/test/testsuite/ouroboros/thread_test/RT0028-rt-thread-ThreadgetName/ThreadGetName.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc88fd0f85afe09be4784df4c7383b3e7ab2f12a
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0028-rt-thread-ThreadgetName/ThreadGetName.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetName
+ *- @TestCaseName: Thread_ThreadGetName.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Get Thread Name.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadGetName类的实例对象threadGetName，且继承自Thread类；
+ * -#step2: 调用threadGetName的start()方法启动该线程；
+ * -#step3: 通过threadGetName的getName()方法返回的线程名与字符串"Thread-0"相同；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadGetName.java
+ *- @ExecuteClass: ThreadGetName
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetName extends Thread {
+    public static void main(String[] args) {
+        ThreadGetName threadGetName = new ThreadGetName();
+        threadGetName.start();
+        if (threadGetName.getName().equals("Thread-0")) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0029-rt-thread-ThreadgetPriority/ThreadGetPriority.java b/test/testsuite/ouroboros/thread_test/RT0029-rt-thread-ThreadgetPriority/ThreadGetPriority.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f4080404007668a4730b8baf212dd842ce37e5e
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0029-rt-thread-ThreadgetPriority/ThreadGetPriority.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetPriority
+ *- @TestCaseName: Thread_ThreadGetPriority.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Get Thread Default Priority
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadGetPriority类的实例对象threadGetPriority，且ThreadGetId类继承自Thread类；
+ * -#step2: 调用threadGetPriority的start()方法启动该线程；
+ * -#step3: 经判断得知通过threadGetPriority的getPriority()方法的返回值等于5；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadGetPriority.java
+ *- @ExecuteClass: ThreadGetPriority
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetPriority extends Thread {
+    public static void main(String[] args) {
+        ThreadGetPriority threadGetPriority = new ThreadGetPriority();
+        threadGetPriority.start();
+        if (threadGetPriority.getPriority() == 5) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/ThreadGetThreadGroup1.java b/test/testsuite/ouroboros/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/ThreadGetThreadGroup1.java
new file mode 100644
index 0000000000000000000000000000000000000000..d840bbf447c030f0116546a4f8884d194a99f682
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/ThreadGetThreadGroup1.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetThreadGroup1
+ *- @TestCaseName: Thread_ThreadGetThreadGroup1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Get thread groups for threads
+ *- @Brief: see below
+ * -#step1: 以god为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 通过threadGroup的setMaxPriority()方法设置其属性为7；
+ * -#step3: 以threadGroup、banana为参数，创建一个ThreadGetThreadGroup1类的实例对象threadGetThreadGroup1，且
+ *          ThreadGetThreadGroup1类继承自Thread类；
+ * -#step4: 通过threadGetThreadGroup1的getThreadGroup()方法的返回值记为string；
+ * -#step5: 经判断得知string与字符串"java.lang.ThreadGroup[name=god,maxpri=7]"相同；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadGetThreadGroup1.java
+ *- @ExecuteClass: ThreadGetThreadGroup1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetThreadGroup1 extends Thread {
+    public ThreadGetThreadGroup1(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public static void main(String[] args) {
+        String string;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        threadGroup.setMaxPriority(7);
+        ThreadGetThreadGroup1 threadGetThreadGroup1 = new ThreadGetThreadGroup1(threadGroup, "banana");
+        string = threadGetThreadGroup1.getThreadGroup().toString();
+        if (string.equals("java.lang.ThreadGroup[name=god,maxpri=7]")) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/ThreadGetThreadGroup2.java b/test/testsuite/ouroboros/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/ThreadGetThreadGroup2.java
new file mode 100644
index 0000000000000000000000000000000000000000..e807d599466a5c65789a50be9a17f65addad72c5
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/ThreadGetThreadGroup2.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetThreadGroup2
+ *- @TestCaseName: Thread_ThreadGetThreadGroup2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: getThreadGroup() returns null if this thread has died (been stopped).
+ *- @Brief: see below
+ * -#step1: 以god为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 通过threadGroup的setMaxPriority()方法设置其属性为7；
+ * -#step3: 以threadGroup、banana为参数，创建一个ThreadGetThreadGroup2类的实例对象threadGetThreadGroup2，且
+ *          ThreadGetThreadGroup2类继承自Thread类；
+ * -#step4: 调用threadGetThreadGroup2的start()方法启动该线程；
+ * -#step5: 调用threadGetThreadGroup2的join()方法；
+ * -#step6: 尝试将threadGetThreadGroup2的getThreadGroup()方法的返回值赋值给string；
+ * -#step7: 经判断得知step6将会抛出NullPointerException；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadGetThreadGroup2.java
+ *- @ExecuteClass: ThreadGetThreadGroup2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetThreadGroup2 extends Thread {
+    public ThreadGetThreadGroup2(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public static void main(String[] args) {
+        String string;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        threadGroup.setMaxPriority(7);
+        ThreadGetThreadGroup2 threadGetThreadGroup2 = new ThreadGetThreadGroup2(threadGroup, "banana");
+        threadGetThreadGroup2.start();
+        try {
+            threadGetThreadGroup2.join();
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        try {
+            string = threadGetThreadGroup2.getThreadGroup().toString();
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/ThreadGetUncaughtExceptionHandler1.java b/test/testsuite/ouroboros/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/ThreadGetUncaughtExceptionHandler1.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa49d2082c632e9230acf3ba0e05c2f60f9235ec
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/ThreadGetUncaughtExceptionHandler1.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetUncaughtExceptionHandler1
+ *- @TestCaseName: Thread_ThreadGetUncaughtExceptionHandler1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Call setUncaughtExceptionHandler to for a child thread, can use getUncaughtExceptionHandler to
+ *                      get exception handler program in main thread
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadGetUncaughtExceptionHandler1类的实例对象threadGetUncaughtExceptionHandler1，且
+ *          ThreadGetUncaughtExceptionHandler1类继承自Thread类；
+ * -#step2: 通过threadGetUncaughtExceptionHandler1的setUncaughtExceptionHandler()方法设置其相关属性；
+ * -#step3: 通过threadGetUncaughtExceptionHandler1的start()方法启动该线程；
+ * -#step4: 让当前线程休眠10ms；
+ * -#step5: 将threadGetUncaughtExceptionHandler1的getUncaughtExceptionHandler()方法的返回值赋值给string；
+ * -#step6: 经判断得知string包含字符串"ThreadGetUncaughtExceptionHandler1"、"$"和"@"；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadGetUncaughtExceptionHandler1.java
+ *- @ExecuteClass: ThreadGetUncaughtExceptionHandler1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetUncaughtExceptionHandler1 extends Thread{
+    static String string;
+
+    public void run() {
+        try {
+            sleep(50);
+        } catch (InterruptedException e2) {
+            System.out.println("Sleep is interrupted");
+        }
+        System.out.println(3/0);
+    }
+
+    public static void main(String[] args) {
+        ThreadGetUncaughtExceptionHandler1 threadGetUncaughtExceptionHandler1 = new
+                ThreadGetUncaughtExceptionHandler1();
+        threadGetUncaughtExceptionHandler1.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        threadGetUncaughtExceptionHandler1.start();
+        try {
+            sleep(10);
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+        string = threadGetUncaughtExceptionHandler1.getUncaughtExceptionHandler().toString();
+        if (string.indexOf("ThreadGetUncaughtExceptionHandler1") != -1) {
+            if (string.toString().indexOf("$") != -1) {
+                if (string.toString().indexOf("@") != -1) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/ThreadGetUncaughtExceptionHandler2.java b/test/testsuite/ouroboros/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/ThreadGetUncaughtExceptionHandler2.java
new file mode 100644
index 0000000000000000000000000000000000000000..c23aba7e60ef0485792e059b5fa6a77ab3025239
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/ThreadGetUncaughtExceptionHandler2.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetUncaughtExceptionHandler2
+ *- @TestCaseName: Thread_ThreadGetUncaughtExceptionHandler2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: When a thread does not have an uncaught exception explicitly, the thread's ThreadGroup is
+ *                      returned when call getUncaughtExceptionHandler.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadGetUncaughtExceptionHandler2类的实例对象threadGetUncaughtExceptionHandler2，且
+ *          ThreadGetUncaughtExceptionHandler2类继承自Thread类；
+ * -#step2: 通过Thread类的setUncaughtExceptionHandler()方法设置其相关属性；
+ * -#step3: 通过threadGetUncaughtExceptionHandler2的start()方法启动该线程；
+ * -#step4: 将threadGetUncaughtExceptionHandler2的getUncaughtExceptionHandler()方法的返回值赋值给string；
+ * -#step5: 经判断得知string中含有字符串"java.lang.ThreadGroup"；
+ *- @Expect: expected.txt
+ * -#step1xt
+ *- @Priority: High
+ *- @Source: ThreadGetUncaughtExceptionHandler2.java
+ *- @ExecuteClass: ThreadGetUncaughtExceptionHandler2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetUncaughtExceptionHandler2 extends Thread{
+    static String string;
+
+    public void run() {
+        System.out.println(3/0);
+    }
+
+    public static void main(String[] args) {
+        ThreadGetUncaughtExceptionHandler2 threadGetUncaughtExceptionHandler2 = new
+                ThreadGetUncaughtExceptionHandler2();
+        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        threadGetUncaughtExceptionHandler2.start();
+        string = threadGetUncaughtExceptionHandler2.getUncaughtExceptionHandler().toString();
+        if (string.indexOf("java.lang.ThreadGroup") != -1) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/ThreadGetUncaughtExceptionHandler3.java b/test/testsuite/ouroboros/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/ThreadGetUncaughtExceptionHandler3.java
new file mode 100644
index 0000000000000000000000000000000000000000..dcb8d8772e13ebd842b58d53f9628908aad12f05
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/ThreadGetUncaughtExceptionHandler3.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetUncaughtExceptionHandler3
+ *- @TestCaseName: Thread_ThreadGetUncaughtExceptionHandler3.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Cannot get exception in main thread after child thread ends(in Android, it does not return null).
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadGetUncaughtExceptionHandler3类的实例对象threadGetUncaughtExceptionHandler3，且
+ *          ThreadGetUncaughtExceptionHandler3类继承自Thread类；
+ * -#step2: 通过threadGetUncaughtExceptionHandler3的setUncaughtExceptionHandler()方法设置其相关属性；
+ * -#step3: 通过threadGetUncaughtExceptionHandler3的start()方法启动该线程；
+ * -#step4: 调用threadGetUncaughtExceptionHandler3的join()方法；
+ * -#step5: 将threadGetUncaughtExceptionHandler3的getUncaughtExceptionHandler()方法的返回值赋值给string；
+ * -#step6: 经判断得知string中含有字符串"ThreadGetUncaughtExceptionHandler3"、"$"和"@"；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadGetUncaughtExceptionHandler3.java
+ *- @ExecuteClass: ThreadGetUncaughtExceptionHandler3
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetUncaughtExceptionHandler3 extends Thread{
+    static String string;
+
+    public void run() {
+        System.out.println(3/0);
+    }
+
+    public static void main(String[] args) {
+        ThreadGetUncaughtExceptionHandler3 threadGetUncaughtExceptionHandler3 = new
+                ThreadGetUncaughtExceptionHandler3();
+        threadGetUncaughtExceptionHandler3.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        threadGetUncaughtExceptionHandler3.start();
+        try {
+            threadGetUncaughtExceptionHandler3.join();
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        try {
+            string = threadGetUncaughtExceptionHandler3.getUncaughtExceptionHandler().toString();
+            if (string.indexOf("ThreadGetUncaughtExceptionHandler3") != -1) {
+                if (string.toString().indexOf("$") != -1) {
+                    if (string.toString().indexOf("@") != -1) {
+                        System.out.println(0);
+                        return;
+                    }
+                }
+            }
+        } catch (NullPointerException e2) {
+            System.out.println(2);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0035-rt-thread-ThreadholdsLock1/ThreadHoldsLock1.java b/test/testsuite/ouroboros/thread_test/RT0035-rt-thread-ThreadholdsLock1/ThreadHoldsLock1.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3be3634b44f38ae477ce814d3a77bb155c1bf5e
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0035-rt-thread-ThreadholdsLock1/ThreadHoldsLock1.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadHoldsLock1
+ *- @TestCaseName: Thread_ThreadHoldsLock1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread.holdsLock(Object) returns true if and only if the current thread holds the monitor lock
+ *                      on the specified object. before and after the wait, holdsLock return true.
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadHoldsLock1类的实例对象threadHoldsLock1、threadHoldsLock2；
+ * -#step2: 调用threadHoldsLock1的start()方法启动该线程；
+ * -#step3: 让该线程休眠200ms；
+ * -#step4: 调用threadHoldsLock2的start()方法启动该线程；
+ * -#step5: 经判断得知，在经过ThreadHoldsLock1类内部的run()方法执行后int类型的静态变量都由0变为1；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadHoldsLock1.java
+ *- @ExecuteClass: ThreadHoldsLock1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadHoldsLock1 extends Thread {
+    static Object object = "aa";
+    static int i = 0;
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadHoldsLock1 threadHoldsLock1 = new ThreadHoldsLock1();
+        ThreadHoldsLock1 threadHoldsLock2 = new ThreadHoldsLock1();
+        threadHoldsLock1.start();
+        try {
+            sleep(200);
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+        threadHoldsLock2.start();
+        if (i == 1 && t == 1) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+
+    public void run() {
+        synchronized (object) {
+            try {
+                if (holdsLock(object)) {
+                    t = 1;
+                }
+                object.wait(100);
+            } catch (InterruptedException e1) {
+                System.out.println("Wait is interrupted");
+            }
+            if (holdsLock(object)) {
+                i = 1;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0036-rt-thread-ThreadholdsLock2/ThreadHoldsLock2.java b/test/testsuite/ouroboros/thread_test/RT0036-rt-thread-ThreadholdsLock2/ThreadHoldsLock2.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d6d029c4829a9c406d92b3e67dc8feeed5ef456
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0036-rt-thread-ThreadholdsLock2/ThreadHoldsLock2.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadHoldsLock2
+ *- @TestCaseName: Thread_ThreadHoldsLock2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: only one of the threads holdsLock on the Object if they synchronized on the same object.
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadHoldsLock2类的实例对象threadHoldsLock21、threadHoldsLock22；
+ * -#step2: 调用threadHoldsLock21的start()方法启动该线程；
+ * -#step3: 让该线程休眠200ms；
+ * -#step4: 调用threadHoldsLock22的start()方法启动该线程；
+ * -#step5: 经判断得知，在经过ThreadHoldsLock2类内部的run()方法执行后holdsLock(object)的返回值为false；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadHoldsLock2.java
+ *- @ExecuteClass: ThreadHoldsLock2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadHoldsLock2 extends Thread {
+    static Object object = "aa";
+
+    public static void main(String[] args) {
+        ThreadHoldsLock2 threadHoldsLock21 = new ThreadHoldsLock2();
+        ThreadHoldsLock2 threadHoldsLock22 = new ThreadHoldsLock2();
+        threadHoldsLock21.start();
+        try {
+            sleep(200);
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+        threadHoldsLock22.start();
+        if ((holdsLock(object))) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+
+    public void run() {
+        synchronized (object) {
+            try {
+                object.wait(100);
+            } catch (InterruptedException e1) {
+                System.out.println("Wait is interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0037-rt-thread-ThreadholdsLock3/ThreadHoldsLock3.java b/test/testsuite/ouroboros/thread_test/RT0037-rt-thread-ThreadholdsLock3/ThreadHoldsLock3.java
new file mode 100644
index 0000000000000000000000000000000000000000..978423f8f6832db4892f8b56473f77c38fcc23a4
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0037-rt-thread-ThreadholdsLock3/ThreadHoldsLock3.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadHoldsLock3
+ *- @TestCaseName: Thread_ThreadHoldsLock3.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: holdsLock(ob1) throws NullPointerException when object is null.
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadHoldsLock3类的实例对象threadHoldsLock31、threadHoldsLock32；
+ * -#step2: 调用threadHoldsLock31的start()方法启动该线程；
+ * -#step3: 让该线程休眠200ms；
+ * -#step4: 调用threadHoldsLock32的start()方法启动该线程；
+ * -#step5: 以object1=null为参数，尝试执行holdsLock()方法；
+ * -#step6: 确定step5中会抛出NullPointerException；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadHoldsLock3.java
+ *- @ExecuteClass: ThreadHoldsLock3
+ *- @ExecuteArgs:
+ */
+
+public class ThreadHoldsLock3 extends Thread {
+    static Object object = "aa";
+    static Object object1 = null;
+
+    public static void main(String[] args) {
+        ThreadHoldsLock3 threadHoldsLock31 = new ThreadHoldsLock3();
+        ThreadHoldsLock3 threadHoldsLock32 = new ThreadHoldsLock3();
+        threadHoldsLock31.start();
+        try {
+            sleep(200);
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+        threadHoldsLock32.start();
+        try {
+            holdsLock(object1);
+            System.out.println(2);
+        } catch (NullPointerException e) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (object) {
+            try {
+                object.wait(100);
+            } catch (InterruptedException e1) {
+                System.out.println("Wait is interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0038-rt-thread-ThreadisAlive1/ThreadIsAlive1.java b/test/testsuite/ouroboros/thread_test/RT0038-rt-thread-ThreadisAlive1/ThreadIsAlive1.java
new file mode 100644
index 0000000000000000000000000000000000000000..3cc017044ca9e484e2fe6c12bd5cbdf57ba6c80f
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0038-rt-thread-ThreadisAlive1/ThreadIsAlive1.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadIsAlive1
+ *- @TestCaseName: Thread_ThreadIsAlive1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: isAlive() return false when a thread haven't been started yet
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadIsAlive1类的实例对象threadIsAlive1，并且ThreadIsAlive1类继承自Thread类；
+ * -#step2: 经判断得知调用threadIsAlive1的isAlive()方法其返回值为false；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadIsAlive1.java
+ *- @ExecuteClass: ThreadIsAlive1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadIsAlive1 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsAlive1 threadIsAlive1 = new ThreadIsAlive1();
+        if (threadIsAlive1.isAlive()) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0039-rt-thread-ThreadisAlive2/ThreadIsAlive2.java b/test/testsuite/ouroboros/thread_test/RT0039-rt-thread-ThreadisAlive2/ThreadIsAlive2.java
new file mode 100644
index 0000000000000000000000000000000000000000..071e42af954616dcad52b2ead621bd8c211285d8
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0039-rt-thread-ThreadisAlive2/ThreadIsAlive2.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadIsAlive2
+ *- @TestCaseName: Thread_ThreadIsAlive2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: isAlive() return false when a thread is running
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadIsAlive2类的实例对象threadIsAlive2，并且ThreadIsAlive2类继承自Thread类；
+ * -#step2: 调用threadIsAlive2的start()方法启动该线程；
+ * -#step3: 经判断得知调用threadIsAlive2的isAlive()方法其返回值为true；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadIsAlive2.java
+ *- @ExecuteClass: ThreadIsAlive2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadIsAlive2 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsAlive2 threadIsAlive2 = new ThreadIsAlive2();
+        threadIsAlive2.start();
+        if (!threadIsAlive2.isAlive()) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+
+    public void run() {
+        try {
+            sleep(50);
+        } catch (InterruptedException e) {
+            System.out.println("Sleep is interrupted");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0040-rt-thread-ThreadisAlive3/ThreadIsAlive3.java b/test/testsuite/ouroboros/thread_test/RT0040-rt-thread-ThreadisAlive3/ThreadIsAlive3.java
new file mode 100644
index 0000000000000000000000000000000000000000..265be5596c6cbacf3f4af6a9bbe3cdb98849eac5
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0040-rt-thread-ThreadisAlive3/ThreadIsAlive3.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadIsAlive3
+ *- @TestCaseName: Thread_ThreadIsAlive3.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test isAlive() return false when a thread died.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadIsAlive3类的实例对象threadIsAlive3，并且ThreadIsAlive3类继承自Thread类；
+ * -#step2: 调用threadIsAlive3的start()方法启动该线程；
+ * -#step3: 调用threadIsAlive3的join()方法；
+ * -#step4: 经判断得知调用threadIsAlive3的isAlive()方法其返回值为false；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadIsAlive3.java
+ *- @ExecuteClass: ThreadIsAlive3
+ *- @ExecuteArgs:
+ */
+
+public class ThreadIsAlive3 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsAlive3 threadIsAlive3 = new ThreadIsAlive3();
+        threadIsAlive3.start();
+        try {
+            threadIsAlive3.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadIsAlive3.isAlive()) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0041-rt-thread-ThreadisDaemon1/ThreadIsDaemon1.java b/test/testsuite/ouroboros/thread_test/RT0041-rt-thread-ThreadisDaemon1/ThreadIsDaemon1.java
new file mode 100644
index 0000000000000000000000000000000000000000..c6e7cf36f84d735a31494b6bff74d4b5ebbd43d9
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0041-rt-thread-ThreadisDaemon1/ThreadIsDaemon1.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadIsDaemon1
+ *- @TestCaseName: Thread_ThreadIsDaemon1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: To set a child thread as a daemon thread
+ *- @Brief: see below
+ * -#step1: 创建ThreadIsDaemon1类的实例对象threadIsDaemon1，并且ThreadIsDaemon1类继承自Thread类；
+ * -#step2: 通过threadIsDaemon1的setDaemon()方法设置其属性为true；
+ * -#step3: 调用threadIsDaemon1的start()方法启动该线程；
+ * -#step4: 经判断得知调用threadIsDaemon1的isDaemon()方法其返回值为true；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadIsDaemon1.java
+ *- @ExecuteClass: ThreadIsDaemon1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadIsDaemon1 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsDaemon1 threadIsDaemon1 = new ThreadIsDaemon1();
+        threadIsDaemon1.setDaemon(true);
+        threadIsDaemon1.start();
+        if (threadIsDaemon1.isDaemon()) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0042-rt-thread-ThreadisDaemon2/ThreadIsDaemon2.java b/test/testsuite/ouroboros/thread_test/RT0042-rt-thread-ThreadisDaemon2/ThreadIsDaemon2.java
new file mode 100644
index 0000000000000000000000000000000000000000..75caedaa67140c5ca864ad466b59e70e7affee5d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0042-rt-thread-ThreadisDaemon2/ThreadIsDaemon2.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadIsDaemon2
+ *- @TestCaseName: Thread_ThreadIsDaemon2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Setting child threads to daemon threads has no effect on the main thread.
+ *- @Brief: see below
+ * -#step1: 创建ThreadIsDaemon2类的实例对象threadIsDaemon2，并且ThreadIsDaemon2类继承自Thread类；
+ * -#step2: 通过threadIsDaemon2的setDaemon()方法设置其属性为true；
+ * -#step3: 调用threadIsDaemon2的start()方法启动该线程；
+ * -#step4: 经判断得知调用currentThread()的isDaemon()方法其返回值为false；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadIsDaemon2.java
+ *- @ExecuteClass: ThreadIsDaemon2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadIsDaemon2 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsDaemon2 threadIsDaemon2 = new ThreadIsDaemon2();
+        threadIsDaemon2.setDaemon(true);
+        threadIsDaemon2.start();
+        if (currentThread().isDaemon()) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0043-rt-thread-ThreadRunnable/ThreadRunnable.java b/test/testsuite/ouroboros/thread_test/RT0043-rt-thread-ThreadRunnable/ThreadRunnable.java
new file mode 100644
index 0000000000000000000000000000000000000000..3bb7408201849f3e40bb9226f01f6149d6d139ca
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0043-rt-thread-ThreadRunnable/ThreadRunnable.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadRunnable
+ *- @TestCaseName: Thread_ThreadRunnable.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Validation creates a thread by implementing the Runnable interface.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadRunnable类的实例对象threadRunnable，并且ThreadRunnable类实现了Runnable接口；
+ * -#step2: 以threadRunnable为参数，通过new Thread()方法创建一个新线程，并调用start()方法启动该线程；
+ * -#step3: 重复step2两次；
+ * -#step4: 经判断得知step2和step3以及ThreadRunnable类在执行其内部的run()方法后均未抛出异常；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadRunnable.java
+ *- @ExecuteClass: ThreadRunnable
+ *- @ExecuteArgs:
+ */
+
+public class ThreadRunnable implements Runnable {
+    private int ticket = 10;
+
+    public static void main(String[] args) {
+        ThreadRunnable threadRunnable = new ThreadRunnable();
+        try {
+            new Thread(threadRunnable).start();
+            new Thread(threadRunnable).start();
+            new Thread(threadRunnable).start();
+        } catch (Exception e) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+
+    public synchronized void run() {
+        for (int i = 0; i < 20; i++) {
+            if (this.ticket > 0) {
+                this.ticket--;
+            } else {
+                break;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0044-rt-thread-ThreadsetDaemon1/ThreadSetDaemon1.java b/test/testsuite/ouroboros/thread_test/RT0044-rt-thread-ThreadsetDaemon1/ThreadSetDaemon1.java
new file mode 100644
index 0000000000000000000000000000000000000000..4859fbe682a8384ce83e9f8d6a8df60a4c0fa0f7
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0044-rt-thread-ThreadsetDaemon1/ThreadSetDaemon1.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetDaemon1
+ *- @TestCaseName: Thread_ThreadSetDaemon1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verify that the main thread end daemon ends directly when the daemon exists.
+ *- @Brief: see below
+ * -#step1: 创建ThreadSetDaemon1类的实例对象threadSetDaemon1，并且ThreadSetDaemon1类继承自Thread类；
+ * -#step2: 通过threadSetDaemon1的setDaemon()方法设置其属性为true；
+ * -#step3: 调用threadSetDaemon1的start()方法启动该线程；
+ * -#step4: 让当前线程休眠100ms；
+ * -#step5: 令int类型的全局静态变量t的值加1；
+ * -#step6: 确定step4、step5以及ThreadSetDaemon1类在执行其内部的run()后均未抛出异常；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadSetDaemon1.java
+ *- @ExecuteClass: ThreadSetDaemon1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetDaemon1 extends Thread {
+    static int i = 0;
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadSetDaemon1 threadSetDaemon1 = new ThreadSetDaemon1();
+        threadSetDaemon1.setDaemon(true);
+        threadSetDaemon1.start();
+        try {
+            sleep(100);
+            t++;
+        } catch (InterruptedException e2) {
+            System.out.println("Sleep is interrupted");
+        }
+        System.out.println(0);
+    }
+
+    public void run() {
+        try {
+            sleep(1000);
+            i++;
+            System.out.println(2);
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0045-rt-thread-ThreadsetDaemon2/ThreadSetDaemon2.java b/test/testsuite/ouroboros/thread_test/RT0045-rt-thread-ThreadsetDaemon2/ThreadSetDaemon2.java
new file mode 100644
index 0000000000000000000000000000000000000000..e67162bccb04523d9edc0ded047929f58f8cee78
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0045-rt-thread-ThreadsetDaemon2/ThreadSetDaemon2.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetDaemon2
+ *- @TestCaseName: Thread_ThreadSetDaemon2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: If this thread is alive, thread.setDaemon() throws IllegalThreadStateException.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadSetDaemon2类的实例对象threadSetDaemon2，并且ThreadSetDaemon2类继承自Thread类；
+ * -#step2: 调用threadSetDaemon2的start()方法启动该线程；
+ * -#step3: 尝试通过threadSetDaemon2的setDaemon()方法为其设置属性为true；
+ * -#step4: 确定step3中会抛出IllegalThreadStateException；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetDaemon2.java
+ *- @ExecuteClass: ThreadSetDaemon2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetDaemon2 extends Thread {
+    public static void main(String[] args) {
+        ThreadSetDaemon2 threadSetDaemon2 = new ThreadSetDaemon2();
+        threadSetDaemon2.start();
+        try {
+            threadSetDaemon2.setDaemon(true);
+            System.out.println(2);
+        } catch (IllegalThreadStateException e2) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        for (int i = 0; i < 5; i++) {
+            try {
+                sleep(200);
+            } catch (InterruptedException e1) {
+                System.out.println("Sleep is interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0046-rt-thread-ThreadsetDaemon3/ThreadSetDaemon3.java b/test/testsuite/ouroboros/thread_test/RT0046-rt-thread-ThreadsetDaemon3/ThreadSetDaemon3.java
new file mode 100644
index 0000000000000000000000000000000000000000..79aff4e2288b08c7ed3d01e1ebc65287c2b2aa8c
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0046-rt-thread-ThreadsetDaemon3/ThreadSetDaemon3.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetDaemon3
+ *- @TestCaseName: Thread_ThreadSetDaemon3.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verify that the main thread end daemon does not end directly when some other non-daemon thread
+ *                      still running
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadSetDaemon3类的实例对象threadSetDaemon31、threadSetDaemon32，并且ThreadSetDaemon3类继承自
+ *          Thread类；
+ * -#step2: 通过threadSetDaemon31的setDaemon()方法为其设置属性为true；
+ * -#step3: 通过threadSetDaemon31的start()方法启动该线程；
+ * -#step4: 让当前线程休眠50ms；
+ * -#step5: 将int类型的全局静态变量t的值加1；
+ * -#step6: 通过threadSetDaemon32的start()方法启动该线程；
+ * -#step7: 让当前线程休眠50ms；
+ * -#step8: 将int类型的全局静态变量t的值加1；
+ * -#step9: 确定以上步骤以及ThreadSetDaemon3类在执行其内部的run()后均未抛出异常；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadSetDaemon3.java
+ *- @ExecuteClass: ThreadSetDaemon3
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetDaemon3 extends Thread {
+    static int i = 0;
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadSetDaemon3 threadSetDaemon31 = new ThreadSetDaemon3();
+        ThreadSetDaemon3 threadSetDaemon32 = new ThreadSetDaemon3();
+        threadSetDaemon31.setDaemon(true);
+        threadSetDaemon31.start();
+        try {
+            sleep(50);
+            t++;
+        } catch (InterruptedException e3) {
+            System.out.println("Sleep is interrupted");
+        }
+        threadSetDaemon32.start();
+        try {
+            sleep(50);
+            t++;
+        } catch (InterruptedException e2) {
+            System.out.println("Sleep is interrupted");
+        }
+        System.out.println(0);
+    }
+
+    public void run() {
+        try {
+            sleep(300);
+            i++;
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/ThreadSetDefaultUncaughtExceptionHandler.java b/test/testsuite/ouroboros/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/ThreadSetDefaultUncaughtExceptionHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..b4e95193a4e3526ee3e46720d69d1f1a140e29d0
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/ThreadSetDefaultUncaughtExceptionHandler.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetDefaultUncaughtExceptionHandler
+ *- @TestCaseName: Thread_ThreadSetDefaultUncaughtExceptionHandler.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: SetDefaultUncaughtExceptionHandler set the exception handler for Thread class, all thread will
+ *                     have the same exception handler
+ *- @Brief: see below
+ * -#step1: Override method run() include a uncaught error.
+ * -#step2: Create two ThreadSetDefaultUncaughtExceptionHandler instance.
+ * -#step3: Start the threads.
+ * -#step4: Check that two times java.lang.ArithmeticException were handled by
+ *          Thread.setDefaultUncaughtExceptionHandler,rather than catch.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetDefaultUncaughtExceptionHandler.java
+ *- @ExecuteClass: ThreadSetDefaultUncaughtExceptionHandler
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetDefaultUncaughtExceptionHandler extends Thread{
+    static int i=0;
+    static String p;
+    public void run() {
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+
+        ThreadSetDefaultUncaughtExceptionHandler thread_obj1 = new ThreadSetDefaultUncaughtExceptionHandler();
+        ThreadSetDefaultUncaughtExceptionHandler thread_obj2 = new ThreadSetDefaultUncaughtExceptionHandler();
+        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+                p = e.toString();
+                if (p.indexOf("java.lang.ArithmeticException") != -1) {
+                    i++;
+                }
+            }
+        });
+        thread_obj1.start();
+        thread_obj2.start();
+        try {
+        thread_obj1.join();
+        thread_obj2.join();
+        } catch (InterruptedException e1) {
+        }
+        if (i == 2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0048-rt-thread-ThreadsetName1/ThreadSetName1.java b/test/testsuite/ouroboros/thread_test/RT0048-rt-thread-ThreadsetName1/ThreadSetName1.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec05b18ac9414a870c428ec8bdfae8f54210324c
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0048-rt-thread-ThreadsetName1/ThreadSetName1.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetName1
+ *- @TestCaseName: Thread_ThreadSetName1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Set Thread name
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Start the thread.
+ * -#step3: Set a name for thread.
+ * -#step4: Check that name of thread is right.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetName1.java
+ *- @ExecuteClass: ThreadSetName1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetName1 extends Thread {
+    public static void main(String[] args) {
+        ThreadSetName1 thread_obj = new ThreadSetName1();
+        thread_obj.start();
+        thread_obj.setName("我abc123!?*{$");
+        if (thread_obj.getName().equals("我abc123!?*{$")) {
+            System.out.println(0);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0049-rt-thread-ThreadsetName2/ThreadSetName2.java b/test/testsuite/ouroboros/thread_test/RT0049-rt-thread-ThreadsetName2/ThreadSetName2.java
new file mode 100644
index 0000000000000000000000000000000000000000..e951c0759ee409dcf26d89e219f802f586e1b5e1
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0049-rt-thread-ThreadsetName2/ThreadSetName2.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetName2
+ *- @TestCaseName: Thread_ThreadSetName2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread.setName(NULL) throws NullPointerException
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Start the thread.
+ * -#step3: Set a null name for thread.
+ * -#step4: Check that throw NullPointerException when setName(String str)'s param is null.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetName2.java
+ *- @ExecuteClass: ThreadSetName2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetName2 extends Thread {
+    public static void main(String[] args) {
+        String string = null;
+        ThreadSetName2 threa_obj = new ThreadSetName2();
+        try {
+            threa_obj.setName(string);
+            System.out.println(2);
+        } catch (NullPointerException e) {
+            System.out.println(0);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0050-rt-thread-ThreadsetPriority1/ThreadSetPriority1.java b/test/testsuite/ouroboros/thread_test/RT0050-rt-thread-ThreadsetPriority1/ThreadSetPriority1.java
new file mode 100644
index 0000000000000000000000000000000000000000..3bc272dbd0bd80054457f94ea3f9b98d9186cf86
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0050-rt-thread-ThreadsetPriority1/ThreadSetPriority1.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetPriority1
+ *- @TestCaseName: Thread_ThreadSetPriority1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Repeatedly set thread priority
+ *- @Brief: see below
+ * -#step1: Create four thread instance.
+ * -#step2: Set priority for four thread.
+ * -#step3: Start the threads.
+ * -#step4: Check that priority of instances was set correctly.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetPriority1.java
+ *- @ExecuteClass: ThreadSetPriority1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetPriority1 extends Thread {
+    public static void main(String[] args) {
+        ThreadSetPriority1 thread_obj1 = new ThreadSetPriority1();
+        ThreadSetPriority1 thread_obj2 = new ThreadSetPriority1();
+        ThreadSetPriority1 thread_obj3 = new ThreadSetPriority1();
+        ThreadSetPriority1 thread_obj4 = new ThreadSetPriority1();
+        thread_obj1.setPriority(6);
+        thread_obj4.setPriority(MIN_PRIORITY);
+        thread_obj2.setPriority(MAX_PRIORITY);
+        thread_obj3.setPriority(3);
+        thread_obj1.setPriority(2);
+        thread_obj2.setPriority(MIN_PRIORITY);
+        thread_obj3.setPriority(NORM_PRIORITY);
+        thread_obj4.setPriority(7);
+        thread_obj1.start();
+        thread_obj2.start();
+        thread_obj3.start();
+        thread_obj4.start();
+        if (thread_obj1.getPriority() != 2) {
+            System.out.println(2);
+        }
+        if (thread_obj2.getPriority() != 1) {
+            System.out.println(2);
+        }
+        if (thread_obj3.getPriority() != 5) {
+            System.out.println(2);
+        }
+        if (thread_obj4.getPriority() != 7) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0051-rt-thread-ThreadsetPriority2/ThreadSetPriority2.java b/test/testsuite/ouroboros/thread_test/RT0051-rt-thread-ThreadsetPriority2/ThreadSetPriority2.java
new file mode 100644
index 0000000000000000000000000000000000000000..c39f16dbe8a94dee1dc566fb5bb92c33cf0be13f
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0051-rt-thread-ThreadsetPriority2/ThreadSetPriority2.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetPriority2
+ *- @TestCaseName: Thread_ThreadSetPriority2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Child thread inherits the priority of the main thread
+ *- @Brief: see below
+ * -#step1: Define a test class that inherited from thread class and override run().
+ * -#step2: Set current thread's priority.
+ * -#step3: Create two thread instance and start them.
+ * -#step4: Check that all priority of child thread was same.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetPriority2.java
+ *- @ExecuteClass: ThreadSetPriority2
+ *- @ExecuteArgs:
+ */
+
+class ThreadSetPriority_a extends Thread {
+    public synchronized void run() {
+        for (int i = 0; i < 10; i++) {
+        }
+    }
+}
+
+public class ThreadSetPriority2 extends ThreadSetPriority_a {
+    public static void main(String[] args) {
+        currentThread().setPriority(2);
+        ThreadSetPriority2 thread_obj1 = new ThreadSetPriority2();
+        ThreadSetPriority2 thread_obj2 = new ThreadSetPriority2();
+        thread_obj1.start();
+        thread_obj2.start();
+        if (thread_obj1.getPriority() != 2) {
+            System.out.println(2);
+            return ;
+        }
+        if (thread_obj2.getPriority() != 2) {
+            System.out.println(2);
+            return ;
+        }
+        System.out.println(0);
+        return;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0052-rt-thread-ThreadsetPriority3/ThreadsSetPriority3.java b/test/testsuite/ouroboros/thread_test/RT0052-rt-thread-ThreadsetPriority3/ThreadsSetPriority3.java
new file mode 100644
index 0000000000000000000000000000000000000000..414436a7f5d9755ef019f76bbc02a2abbeb64b39
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0052-rt-thread-ThreadsetPriority3/ThreadsSetPriority3.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadsSetPriority3
+ *- @TestCaseName: Thread_ThreadsSetPriority3.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: SetPriority() throws IllegalArgumentException If the priority is not in the range MIN_PRIORITY
+ *                      to MAX_PRIORITY
+ *- @Brief: see below
+ * -#step1: Create four thread instance.
+ * -#step2: Set priority of thread.
+ * -#step3: Check that throw the IllegalArgumentException when priority out of range.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadsSetPriority3.java
+ *- @ExecuteClass: ThreadsSetPriority3
+ *- @ExecuteArgs:
+ */
+
+public class ThreadsSetPriority3 extends Thread {
+    public static void main(String[] args) {
+        ThreadsSetPriority3 thread_obj1 = new ThreadsSetPriority3();
+        ThreadsSetPriority3 thread_obj2 = new ThreadsSetPriority3();
+        ThreadsSetPriority3 thread_obj3 = new ThreadsSetPriority3();
+        ThreadsSetPriority3 thread_obj4 = new ThreadsSetPriority3();
+        try {
+            thread_obj1.setPriority(11);
+            System.out.println(2);
+        } catch (IllegalArgumentException e1) {
+            try {
+                thread_obj2.setPriority(0);
+                System.out.println(2);
+            } catch (IllegalArgumentException e2) {
+                try {
+                    thread_obj3.setPriority(MAX_PRIORITY + 1);
+                    System.out.println(2);
+                } catch (IllegalArgumentException e3) {
+                    try {
+                        thread_obj4.setPriority(MIN_PRIORITY - 1);
+                        System.out.println(2);
+                    } catch (IllegalArgumentException e4) {
+                        System.out.println(0);
+                    }
+                }
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0053-rt-thread-ThreadsetPriority4/ThreadSetPriority4.java b/test/testsuite/ouroboros/thread_test/RT0053-rt-thread-ThreadsetPriority4/ThreadSetPriority4.java
new file mode 100644
index 0000000000000000000000000000000000000000..22e594b4a2f560bdbe73b3e8a32b01ae44da4707
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0053-rt-thread-ThreadsetPriority4/ThreadSetPriority4.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetPriority4
+ *- @TestCaseName: Thread_ThreadSetPriority4.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: SetPriority() after the thread dies will not change the priority successfully.
+ *- @Brief: see below
+ * -#step1: Create three thread instance.
+ * -#step2: Start the threads.
+ * -#step3: Run all threads until them die.
+ * -#step4: Check that priority was not changed when the thread was died.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetPriority4.java
+ *- @ExecuteClass: ThreadSetPriority4
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetPriority4 extends Thread {
+    public static void main(String[] args) {
+        ThreadSetPriority4 thread_obj1 = new ThreadSetPriority4();
+        ThreadSetPriority4 thread_obj2 = new ThreadSetPriority4();
+        ThreadSetPriority4 thread_obj3 = new ThreadSetPriority4();
+        thread_obj1.start();
+        thread_obj2.start();
+        thread_obj3.start();
+        try {
+            thread_obj1.join();
+            thread_obj2.join();
+            thread_obj3.join();
+        } catch (InterruptedException e) {
+        }
+        thread_obj1.setPriority(7);
+        thread_obj2.setPriority(MAX_PRIORITY);
+        thread_obj3.setPriority(MIN_PRIORITY + 1);
+        if (thread_obj1.getPriority() != 5) {
+            System.out.println(2);
+        }
+        if (thread_obj2.getPriority() != 5) {
+            System.out.println(2);
+        }
+        if (thread_obj3.getPriority() != 5) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0054-rt-thread-ThreadsetPriority5/ThreadSetPriority5.java b/test/testsuite/ouroboros/thread_test/RT0054-rt-thread-ThreadsetPriority5/ThreadSetPriority5.java
new file mode 100644
index 0000000000000000000000000000000000000000..a742786870bbb85e898a66d9230b1468596bb4c6
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0054-rt-thread-ThreadsetPriority5/ThreadSetPriority5.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetPriority5
+ *- @TestCaseName: Thread_ThreadSetPriority5.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: SetPriority(NULL) throws NullPointerException
+ *- @Brief: see below
+ * -#step1: Create thread instance.
+ * -#step2: Test SetPriority(NULL) when its param is null.
+ * -#step3: Check that NullPointerException was threw.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetPriority5.java
+ *- @ExecuteClass: ThreadSetPriority5
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetPriority5 extends Thread {
+    public static void main(String[] args) {
+        Integer i = null;
+        ThreadSetPriority5 thread_obj1 = new ThreadSetPriority5();
+        try {
+            thread_obj1.setPriority(i);
+            System.out.println(2);
+        } catch (IllegalArgumentException e) {
+            System.out.println(2);
+        } catch (NullPointerException e) {
+            System.out.println(0);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0055-rt-thread-ThreadsetPriority6/ThreadSetPriority6.java b/test/testsuite/ouroboros/thread_test/RT0055-rt-thread-ThreadsetPriority6/ThreadSetPriority6.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c6c87d7e63d21e95e6bc0123ea9b1bbf2ce5267
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0055-rt-thread-ThreadsetPriority6/ThreadSetPriority6.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetPriority6
+ *- @TestCaseName: Thread_ThreadSetPriority6.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: SetMaxPriority() does not change the priority of threads in the Thread Group
+ *- @Brief: see below
+ * -#step1: Create a new ThreadGroup instance.
+ * -#step2: Assign the new thread to thread group.
+ * -#step3: Set priority to thread group.
+ * -#step4: Check that the priority of threads in the Thread Group was not change by calling SetMaxPriority().
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetPriority6.java
+ *- @ExecuteClass: ThreadSetPriority6
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetPriority6 extends Thread {
+    public ThreadSetPriority6(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public static void main(String[] args) {
+        ThreadGroup cls1 = new ThreadGroup("god");
+        ThreadSetPriority6 cls2 = new ThreadSetPriority6(cls1, "good");
+        cls1.setMaxPriority(3);
+        if (cls1.getMaxPriority() == 3 && cls2.getPriority() == 5) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0056-rt-thread-ThreadsetPriority7/ThreadSetPriority7.java b/test/testsuite/ouroboros/thread_test/RT0056-rt-thread-ThreadsetPriority7/ThreadSetPriority7.java
new file mode 100644
index 0000000000000000000000000000000000000000..d019bf3f325c5fe9e4babf371aa51bd551bb972b
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0056-rt-thread-ThreadsetPriority7/ThreadSetPriority7.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetPriority7
+ *- @TestCaseName: Thread_ThreadSetPriority7.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: SetPriority() with value exceeds ThreadGroup's MaxPriority will not success,and does not throws
+ *                      exception.
+ *- @Brief: see below
+ * -#step1: Create a new ThreadGroup instance.
+ * -#step2: Assign the new thread to thread group.
+ * -#step3: Set thread and thread group priority.
+ * -#step4: Check that thread's priority will not greater than thread-group's.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetPriority7.java
+ *- @ExecuteClass: ThreadSetPriority7
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetPriority7 extends Thread {
+    public ThreadSetPriority7(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public static void main(String[] args) {
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadSetPriority7 threadSetPriority7 = new ThreadSetPriority7(threadGroup, "good");
+        threadGroup.setMaxPriority(3);
+        threadSetPriority7.setPriority(8);
+        if (threadGroup.getMaxPriority() == 3 && threadSetPriority7.getPriority() == 3) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/ThreadSetUncaughtExceptionHandler.java b/test/testsuite/ouroboros/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/ThreadSetUncaughtExceptionHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab5d5c1e540b09ccca387b38e67ff46095e5a62a
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/ThreadSetUncaughtExceptionHandler.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetUncaughtExceptionHandler
+ *- @TestCaseName: Thread_ThreadSetUncaughtExceptionHandler.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: SetUncaughtExceptionHandler set he exception handler for a child thread.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadSetDefaultUncaughtExceptionHandler1，含run()方法设置3/0的异常。
+ * -#step2: 通过new得到两个ThreadGetDefaultUncaughtExceptionHandler1的对象，分别使用setDefaultUncaughtExceptionHandler()
+ *          设置默认的异常处理程序。
+ * -#step3: 启动线程对象，等待线程结束，确认异常处理程序被调用。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadSetUncaughtExceptionHandler.java
+ *- @ExecuteClass: ThreadSetUncaughtExceptionHandler
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetUncaughtExceptionHandler extends Thread {
+    static int i = 0;
+    static String p;
+
+    public void run() {
+        System.out.println(3/0);
+    }
+
+    public static void main(String[] args) {
+        ThreadSetUncaughtExceptionHandler cls = new ThreadSetUncaughtExceptionHandler();
+        ThreadSetUncaughtExceptionHandler cls2 = new ThreadSetUncaughtExceptionHandler();
+        cls.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+                p = e.toString();
+                if (p.indexOf("java.lang.ArithmeticException") != -1) {
+                    i++;
+                }
+            }
+        });
+        cls2.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        cls.start();
+        cls2.start();
+        try {
+            cls.join();
+            cls2.join();
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1) {
+            System.out.println(0);
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/ThreadStateInterrupt1.java b/test/testsuite/ouroboros/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/ThreadStateInterrupt1.java
new file mode 100644
index 0000000000000000000000000000000000000000..e443ad965a54eca24179345f0a4705db1887b255
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/ThreadStateInterrupt1.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateInterrupt1
+ *- @TestCaseName: Thread_ThreadStateInterrupt1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Interrupt a thread blocked in an invocation of the wait(), wait(long), or wait(long, int)
+ *                      methods of the Object class, then its interrupt status will be cleared and it will receive an
+ *                      InterruptedException.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadStateInterrupt1。
+ * -#step2: 定义线程安全的run()方法，中断调用wait()的线程时会捕获通过InterruptedException异常。
+ * -#step3: 通过new关键字得到Thread类的线程对象。
+ * -#step4：启动线程对象，等待50毫秒后中断线程，抛出InterruptedException，线程后续操作未被执行。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateInterrupt1.java
+ *- @ExecuteClass: ThreadStateInterrupt1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateInterrupt1 extends Thread {
+    static int i = 0;
+    static boolean j;
+
+    public static void main(String[] args) {
+        ThreadStateInterrupt1 cls = new ThreadStateInterrupt1();
+        cls.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e2) {
+            System.err.println(e2);
+        }
+        cls.interrupt();
+        try {
+            sleep(50);
+        } catch (InterruptedException e3) {
+            System.err.println(e3);
+        }
+        if (j && i == 0) {
+            System.out.println(0);
+        }
+    }
+
+    public synchronized void run() {
+        try {
+            while (!Thread.currentThread().isInterrupted()) {
+                wait();
+                i++;
+            }
+        } catch (InterruptedException e1) {
+            Thread.currentThread().interrupt();
+            j = Thread.currentThread().isInterrupted();
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/ThreadStateInterrupt2.java b/test/testsuite/ouroboros/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/ThreadStateInterrupt2.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed82f44939fa8a4b05d2f751b8ef3a1a667f01cb
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/ThreadStateInterrupt2.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateInterrupt2
+ *- @TestCaseName: Thread_ThreadStateInterrupt2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Threads that are not interrupted keep waiting till time up.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadStateInterrupt2。
+ * -#step2: 定义线程安全的run()方法，线程未中断直到等待时间结束。
+ * -#step3: 通过new关键字得到ThreadStateInterrupt2类的线程对象。
+ * -#step4：启动线程对象，调用sleep()方法，线程未中断直到等待时间结束。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateInterrupt2.java
+ *- @ExecuteClass: ThreadStateInterrupt2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateInterrupt2 extends Thread {
+    static int i = 0;
+    static boolean j = false;
+
+    public static void main(String[] args) {
+        ThreadStateInterrupt2 cls = new ThreadStateInterrupt2();
+        cls.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e2) {
+            System.err.println(e2);
+        }
+        if (!j && !cls.isInterrupted() && i == 0) {
+            System.out.println(0);
+        }
+    }
+
+    public synchronized void run() {
+        try {
+            while (!Thread.currentThread().isInterrupted()) {
+                wait(2000);
+                break;
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            j = Thread.currentThread().isInterrupted();
+            i++;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0060-rt-thread-ThreadStatejoin1/ThreadStateJoin1.java b/test/testsuite/ouroboros/thread_test/RT0060-rt-thread-ThreadStatejoin1/ThreadStateJoin1.java
new file mode 100644
index 0000000000000000000000000000000000000000..d71dfd69e5531e07643d98b5ebd41d6e046cec56
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0060-rt-thread-ThreadStatejoin1/ThreadStateJoin1.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin1
+ *- @TestCaseName: Thread_ThreadStateJoin1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Wait for target thread to end.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadStateJoin1。
+ * -#step2: 通过new关键字得到ThreadStateInterrupt2类的线程对象。
+ * -#step3：启动线程对象，调用join()方法确认该线程的状态为TERMINATED。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateJoin1.java
+ *- @ExecuteClass: ThreadStateJoin1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin1 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateJoin1 cls = new ThreadStateJoin1();
+        cls.start();
+        try {
+            cls.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (cls.getState().toString().equals("TERMINATED")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0061-rt-thread-ThreadStatejoin11/ThreadStateJoin11.java b/test/testsuite/ouroboros/thread_test/RT0061-rt-thread-ThreadStatejoin11/ThreadStateJoin11.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b43efca071bd4160ae984e87df9a1819037635c
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0061-rt-thread-ThreadStatejoin11/ThreadStateJoin11.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin11
+ *- @TestCaseName: Thread_ThreadStateJoin11.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verify the accuracy of join time.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadStateJoin11。
+ * -#step2: 定义run()方法，指定synchronized的对象，指定休眠时间。
+ * -#step2: 通过new关键字得到ThreadStateJoin11类的线程对象。
+ * -#step3：启动线程对象，获取启动时的当前时间。调用join()方法，获取线程结束时的当前时间。计算花费时间在970~1030毫秒之间。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin11.java
+ *- @ExecuteClass: ThreadStateJoin11
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin11 extends Thread {
+    static Object ob = "aa";
+
+    public static void main(String[] args) {
+        long startTime;
+        long endTime;
+        ThreadStateJoin11 cls = new ThreadStateJoin11();
+        cls.start();
+        startTime = System.currentTimeMillis();
+        try {
+            cls.join(1000);
+        } catch (InterruptedException ex) {
+            System.out.println("Join is interrupted");
+        }
+        endTime = System.currentTimeMillis();
+        if (endTime - startTime > 970 && endTime - startTime < 1030) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (ob) {
+            try {
+                sleep(2000);
+            } catch (InterruptedException e) {
+                System.out.println("Sleep is interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0062-rt-thread-ThreadStatejoin12/ThreadStateJoin12.java b/test/testsuite/ouroboros/thread_test/RT0062-rt-thread-ThreadStatejoin12/ThreadStateJoin12.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d26dfd161b6ea04d5a3bc05402aee71d94dd093
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0062-rt-thread-ThreadStatejoin12/ThreadStateJoin12.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin12
+ *- @TestCaseName: Thread_ThreadStateJoin12.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verify the accuracy of the wait time after the join gets the object lock.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadStateJoin12。
+ * -#step2: 定义run()方法，指定synchronized的对象，指定休眠时间。
+ * -#step2: 通过new关键字得到ThreadStateJoin12类的线程对象。
+ * -#step3：启动线程对象，获取启动时的当前时间。调用join()方法，获取线程结束时的当前时间。计算花费时间在590~1010毫秒之间。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateJoin12.java
+ *- @ExecuteClass: ThreadStateJoin12
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin12 extends Thread {
+    public static void main(String[] args) {
+        long startTime;
+        long endTime;
+        ThreadStateJoin12 cls = new ThreadStateJoin12();
+        cls.start();
+        startTime = System.currentTimeMillis();
+        try {
+            cls.join(600);
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        endTime = System.currentTimeMillis();
+        if (endTime - startTime > 590 && endTime - startTime < 1010) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0063-rt-thread-ThreadStatejoin13/ThreadStateJoin13.java b/test/testsuite/ouroboros/thread_test/RT0063-rt-thread-ThreadStatejoin13/ThreadStateJoin13.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e0f74e16d8244c8a3c2542647b8d2f467e20bb0
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0063-rt-thread-ThreadStatejoin13/ThreadStateJoin13.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin13
+ *- @TestCaseName: Thread_ThreadStateJoin13.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Validation join(0) equals infinite wait.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadStateJoin13。
+ * -#step2: 定义run()方法，循环三次，指定synchronized的对象，指定休眠时间，t自增1。
+ * -#step3: 通过new关键字得到ThreadStateJoin13类的线程对象。
+ * -#step4：启动线程对象，调用join()方法，等待线程运行结束。获取线程的状态为TERMINATED。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin13.java
+ *- @ExecuteClass: ThreadStateJoin13
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin13 extends Thread {
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateJoin13 cls = new ThreadStateJoin13();
+        cls.start();
+        try {
+            cls.join(0);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (cls.getState().toString().equals("TERMINATED") && t == 4) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0064-rt-thread-ThreadStatejoin14/ThreadStateJoin14.java b/test/testsuite/ouroboros/thread_test/RT0064-rt-thread-ThreadStatejoin14/ThreadStateJoin14.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7194f65997072af17564f7a0d5ee0e1007527d9
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0064-rt-thread-ThreadStatejoin14/ThreadStateJoin14.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin14
+ *- @TestCaseName: Thread_ThreadStateJoin14.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verify waiting for negative seconds throws IllegalArgumentException.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadStateJoin14。
+ * -#step2: 定义run()方法，循环三次，指定synchronized的对象，指定休眠时间。
+ * -#step2: 通过new关键字得到ThreadStateJoin14类的线程对象。
+ * -#step3：启动线程对象。调用join()方法，指定否定秒为负值。确认抛出IllegalArgumentException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin14.java
+ *- @ExecuteClass: ThreadStateJoin14
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin14 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateJoin14 cls = new ThreadStateJoin14();
+        cls.start();
+        try {
+            cls.join(-10);
+        } catch (InterruptedException e1) {
+            System.out.println(2);
+        } catch (IllegalArgumentException e2) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0065-rt-thread-ThreadStatejoin15/ThreadStateJoin15.java b/test/testsuite/ouroboros/thread_test/RT0065-rt-thread-ThreadStatejoin15/ThreadStateJoin15.java
new file mode 100644
index 0000000000000000000000000000000000000000..04a8692686d4aecbea9ad92e1f2022f4410c949d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0065-rt-thread-ThreadStatejoin15/ThreadStateJoin15.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin15
+ *- @TestCaseName: Thread_ThreadStateJoin15.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Validation waits for negative milliseconds  throws IllegalArgumentException.
+ *- @Brief: see below
+ * -#step1: 定义继承Thread类的线程类ThreadStateJoin15。
+ * -#step2: 定义run()方法，循环三次，指定synchronized的对象，指定休眠时间。
+ * -#step2: 通过new关键字得到ThreadStateJoin15类的线程对象。
+ * -#step3：启动线程对象。调用join()方法，构造参数nanos为负值，millis为1000。确认会抛出IllegalArgumentException。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateJoin15.java
+ *- @ExecuteClass: ThreadStateJoin15
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin15 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateJoin15 cls = new ThreadStateJoin15();
+        cls.start();
+        try {
+            cls.join(1000, -10);
+        } catch (InterruptedException e1) {
+            System.out.println(2);
+        } catch (IllegalArgumentException e2) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0066-rt-thread-ThreadStatejoin2/ThreadStateJoin2.java b/test/testsuite/ouroboros/thread_test/RT0066-rt-thread-ThreadStatejoin2/ThreadStateJoin2.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd9508f72a4e1874bd1a135a47b03cca037cd442
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0066-rt-thread-ThreadStatejoin2/ThreadStateJoin2.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin2
+ *- @TestCaseName: Thread_ThreadStateJoin2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Wait time unit is seconds target thread ends.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateJoin2类的实例对象threadStateJoin2，并且ThreadStateJoin2类继承自Thread类；
+ * -#step2: 调用threadStateJoin2的start()方法启动该线程；
+ * -#step3: 调用threadStateJoin2的join()方法，参数为1000；
+ * -#step4: run方法循环三次，每次令int类型的全局静态变量t的值加1；
+ * -#step5: 经判断得知threadStateJoin2.getState().toString()的返回值与字符串"TERMINATED"相同，并且ThreadStateJoin2类在其
+ *          内部的run()方法执行完之后t的值变为4；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin2.java
+ *- @ExecuteClass: ThreadStateJoin2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin2 extends Thread {
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateJoin2 threadStateJoin2 = new ThreadStateJoin2();
+        threadStateJoin2.start();
+        try {
+            threadStateJoin2.join(1000);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin2.getState().toString().equals("TERMINATED") && t == 4) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0067-rt-thread-ThreadStatejoin3/ThreadStateJoin3.java b/test/testsuite/ouroboros/thread_test/RT0067-rt-thread-ThreadStatejoin3/ThreadStateJoin3.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6a42ff8c49b2026775278c449222fe123978bd4
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0067-rt-thread-ThreadStatejoin3/ThreadStateJoin3.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin3
+ *- @TestCaseName: Thread_ThreadStateJoin3.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Wait time unit is millisecond target thread ends.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateJoin3类的实例对象threadStateJoin3，并且ThreadStateJoin3类继承自Thread类；
+ * -#step2: 调用threadStateJoin3的start()方法启动该线程；
+ * -#step3: 调用threadStateJoin3的join()方法，参数1为1000、参数2为300；
+ * -#step4: run方法循环三次，每次令int类型的全局静态变量t的值加1；
+ * -#step5: 经判断得知threadStateJoin3.getState().toString()的返回值与字符串"TERMINATED"相同，并且ThreadStateJoin3类在其
+ *          内部的run()方法执行完之后t的值变为4；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin3.java
+ *- @ExecuteClass: ThreadStateJoin3
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin3 extends Thread {
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateJoin3 threadStateJoin3 = new ThreadStateJoin3();
+        threadStateJoin3.start();
+        try {
+            threadStateJoin3.join(1000, 300);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin3.getState().toString().equals("TERMINATED") && t == 4) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0068-rt-thread-ThreadStatejoin4/ThreadStateJoin4.java b/test/testsuite/ouroboros/thread_test/RT0068-rt-thread-ThreadStatejoin4/ThreadStateJoin4.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5ffd73fc047b3b88dc122d982547b8a097b1641
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0068-rt-thread-ThreadStatejoin4/ThreadStateJoin4.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin4
+ *- @TestCaseName: Thread_ThreadStateJoin4.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Wait time unit seconds and target thread is not finished after wait.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateJoin4类的实例对象threadStateJoin4，并且ThreadStateJoin4类继承自Thread类；
+ * -#step2: 调用threadStateJoin4的start()方法启动该线程；
+ * -#step3: 调用threadStateJoin4的join()方法，参数为500；
+ * -#step4: run方法循环5次，每次令int类型的全局静态变量t的值加1；
+ * -#step5: 经判断得知threadStateJoin4.getState().toString()的返回值与字符串"TIMED_WAITING"相同，并且ThreadStateJoin4类
+ *          在其内部的run()方法执行完之后t的值变为3；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin4.java
+ *- @ExecuteClass: ThreadStateJoin4
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin4 extends Thread {
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateJoin4 threadStateJoin4 = new ThreadStateJoin4();
+        threadStateJoin4.start();
+        try {
+            threadStateJoin4.join(500);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin4.getState().toString().equals("TIMED_WAITING") && t == 3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    wait(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0069-rt-thread-ThreadStatejoin5/ThreadStateJoin5.java b/test/testsuite/ouroboros/thread_test/RT0069-rt-thread-ThreadStatejoin5/ThreadStateJoin5.java
new file mode 100644
index 0000000000000000000000000000000000000000..6054501e5e6b7e13d8303d207881e5eb793984aa
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0069-rt-thread-ThreadStatejoin5/ThreadStateJoin5.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin5
+ *- @TestCaseName: Thread_ThreadStateJoin5.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Wait time unit is millisecond target thread is not finished after wait.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateJoin5类的实例对象threadStateJoin5，并且ThreadStateJoin5类继承自Thread类；
+ * -#step2: 调用threadStateJoin5的start()方法启动该线程；
+ * -#step3: 调用threadStateJoin5的join()方法，参数为500、300；
+ * -#step4: run方法循环5次，每次令int类型的全局静态变量t的值加1；
+ * -#step5: 经判断得知threadStateJoin5.getState().toString()的返回值与字符串"TIMED_WAITING"相同，并且ThreadStateJoin5类
+ *          在其内部的run()方法执行完之后t的值变为3；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin5.java
+ *- @ExecuteClass: ThreadStateJoin5
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin5 extends Thread {
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateJoin5 threadStateJoin5 = new ThreadStateJoin5();
+        threadStateJoin5.start();
+        try {
+            threadStateJoin5.join(500, 300);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin5.getState().toString().equals("TIMED_WAITING") && t == 3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    wait(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0070-rt-thread-ThreadStatejoin6/ThreadStateJoin6.java b/test/testsuite/ouroboros/thread_test/RT0070-rt-thread-ThreadStatejoin6/ThreadStateJoin6.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e9ce59ef8f57459a2b6932afa0a3f05249fcd1e
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0070-rt-thread-ThreadStatejoin6/ThreadStateJoin6.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin6
+ *- @TestCaseName: Thread_ThreadStateJoin6.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Wait time unit seconds target thread does not end.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateJoin6类的实例对象threadStateJoin6，并且ThreadStateJoin6类继承自Thread类；
+ * -#step2: 调用threadStateJoin6的start()方法启动该线程；
+ * -#step3: 调用threadStateJoin6的join()方法，参数为500；
+ * -#step4: run方法循环5次，每次int类型的全局静态变量t的值加1，然后wait，然后再加1；
+ * -#step5: 经判断得知threadStateJoin6.getState().toString()的返回值与字符串"TIMED_WAITING"相同，并且ThreadStateJoin6类
+ *          在其内部的run()方法执行完之后t的值变为2；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin6.java
+ *- @ExecuteClass: ThreadStateJoin6
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin6 extends Thread {
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateJoin6 threadStateJoin6 = new ThreadStateJoin6();
+        threadStateJoin6.start();
+        try {
+            threadStateJoin6.join(500);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin6.getState().toString().equals("TIMED_WAITING") && t == 2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    t++;
+                    wait(1000);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0071-rt-thread-ThreadStatejoin7/ThreadStateJoin7.java b/test/testsuite/ouroboros/thread_test/RT0071-rt-thread-ThreadStatejoin7/ThreadStateJoin7.java
new file mode 100644
index 0000000000000000000000000000000000000000..08717e882fa694abeef1443da0fae7c6c6176819
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0071-rt-thread-ThreadStatejoin7/ThreadStateJoin7.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin7
+ *- @TestCaseName: Thread_ThreadStateJoin7.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Wait time unit is millisecond target thread does not end.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateJoin7类的实例对象threadStateJoin7，并且ThreadStateJoin7类继承自Thread类；
+ * -#step2: 调用threadStateJoin7的start()方法启动该线程；
+ * -#step3: 调用threadStateJoin7的join()方法，参数为500、300；
+ * -#step4: run方法循环5次，每次令int类型的全局静态变量t的值加1，然后wait，然后再加1；
+ * -#step5: 经判断得知threadStateJoin7.getState().toString()的返回值与字符串"TIMED_WAITING"相同，并且ThreadStateJoin7类
+ *          在其内部的run()方法执行完之后t的值变为2；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin7.java
+ *- @ExecuteClass: ThreadStateJoin7
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin7 extends Thread {
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateJoin7 threadStateJoin7 = new ThreadStateJoin7();
+        threadStateJoin7.start();
+        try {
+            threadStateJoin7.join(500, 300);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin7.getState().toString().equals("TIMED_WAITING") && t == 2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    t++;
+                    wait(1000);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0072-rt-thread-ThreadStatejoin8/ThreadStateJoin8.java b/test/testsuite/ouroboros/thread_test/RT0072-rt-thread-ThreadStatejoin8/ThreadStateJoin8.java
new file mode 100644
index 0000000000000000000000000000000000000000..a41b536e40e6b40b3c8197d78dc0578898852538
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0072-rt-thread-ThreadStatejoin8/ThreadStateJoin8.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin8
+ *- @TestCaseName: Thread_ThreadStateJoin8.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Wait time unit seconds target thread is still sleeping.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateJoin8类的实例对象threadStateJoin8，并且ThreadStateJoin8类继承自Thread类；
+ * -#step2: 调用threadStateJoin8的start()方法启动该线程；
+ * -#step3: 调用threadStateJoin8的join()方法，参数为1000；
+ * -#step4: run方法循环5次，每次sleep后int类型的全局静态变量t的值加1；
+ * -#step5: 经判断得知threadStateJoin8.getState().toString()的返回值与字符串"TIMED_WAITING"相同，并且ThreadStateJoin8类
+ *          在其内部的run()方法执行完之后t的值变为3；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateJoin8.java
+ *- @ExecuteClass: ThreadStateJoin8
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin8 extends Thread {
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateJoin8 threadStateJoin8 = new ThreadStateJoin8();
+        threadStateJoin8.start();
+        try {
+            threadStateJoin8.join(1000);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin8.getState().toString().equals("TIMED_WAITING") && t == 3) {
+            System.out.println(0);
+            return;
+        }
+    }
+
+    public void run() {
+        for (int i = 1; i <= 5; i++) {
+            try {
+                sleep(400);
+                t++;
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0073-rt-thread-ThreadStatejoin9/ThreadStateJoin9.java b/test/testsuite/ouroboros/thread_test/RT0073-rt-thread-ThreadStatejoin9/ThreadStateJoin9.java
new file mode 100644
index 0000000000000000000000000000000000000000..d24d5d42753efa219817b025149ce6a604c523de
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0073-rt-thread-ThreadStatejoin9/ThreadStateJoin9.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateJoin9
+ *- @TestCaseName: Thread_ThreadStateJoin9.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Wait time unit is millisecond target thread is still sleeping.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateJoin9类的实例对象threadStateJoin9，并且ThreadStateJoin9类继承自Thread类；
+ * -#step2: 调用threadStateJoin9的start()方法启动该线程；
+ * -#step3: 调用threadStateJoin9的join()方法，参数为500,300；
+ * -#step4: run方法循环5次，每次sleep后int类型的全局静态变量t的值加1；
+ * -#step5: 经判断得知threadStateJoin9.getState().toString()的返回值与字符串"TIMED_WAITING"相同，并且ThreadStateJoin9类
+ *          在其内部的run()方法执行完之后t的值变为3；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateJoin9.java
+ *- @ExecuteClass: ThreadStateJoin9
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateJoin9 extends Thread {
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateJoin9 threadStateJoin9 = new ThreadStateJoin9();
+        threadStateJoin9.start();
+        try {
+            threadStateJoin9.join(500, 300);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin9.getState().toString().equals("TIMED_WAITING") && t == 3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        for (int i = 1; i <= 5; i++) {
+            try {
+                sleep(200);
+                t++;
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0074-rt-thread-ThreadStatenotify1/ThreadStateNotify1.java b/test/testsuite/ouroboros/thread_test/RT0074-rt-thread-ThreadStatenotify1/ThreadStateNotify1.java
new file mode 100644
index 0000000000000000000000000000000000000000..77d68354c6ce6aef791fdf3992b772e9dd6d20e1
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0074-rt-thread-ThreadStatenotify1/ThreadStateNotify1.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateNotify1
+ *- @TestCaseName: Thread_ThreadStateNotify1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: notify() wakes up a single thread that is waiting on this object's monitor. If any threads are
+ *                      waiting on this object, one of them is chosen randomly to be awakened.
+ *- @Brief: see below
+ * -#step1: 创建一个Object的对象并赋值给变量lock；
+ * -#step2: 以lock为参数，创建两个ThreadA类的实例对象threadA、threadA2，并且ThreadA类继承自Thread类；
+ * -#step3: 以lock为参数，创建SynNotifyMethodThreadA类的实例对象synNotifyMethodThreadA，并且SynNotifyMethodThreadA类继承
+ *          自Thread类；
+ * -#step4: 分别调用threadA、threadA2、synNotifyMethodThreadA的start()方法启动这三个线程；
+ * -#step5: 让当前线程休眠1000ms；
+ * -#step6: 确定在执行完ThreadA类和SynNotifyMethodThreadA类的内部的run()方法后，线程threadA、threadA2的状态有且仅有一个
+ *          与枚举类型Thread.State.TIMED_WAITING相同，并且Service1类中定义的int类型的静态变量i和t都由0变为1；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateNotify1.java
+ *- @ExecuteClass: ThreadStateNotify1
+ *- @ExecuteArgs:
+ */
+
+class Service1 {
+    static int i = 0;
+    static int t = 0;
+
+    public void testMethod(Object lock) {
+        try {
+            synchronized (lock) {
+                lock.wait(3000);
+                i++;
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void syncNotifyMethod(Object lock) {
+        try {
+            Thread.sleep(100);
+            synchronized (lock) {
+                lock.notify();
+                t++;
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class ThreadA extends Thread {
+    private Object lock;
+
+    public ThreadA(Object lock) {
+        this.lock = lock;
+    }
+
+    public void run() {
+        Service1 service = new Service1();
+        service.testMethod(lock);
+    }
+}
+
+class SynNotifyMethodThreadA extends Thread {
+    private Object lock;
+
+    public SynNotifyMethodThreadA(Object lock) {
+        this.lock = lock;
+    }
+
+    public void run() {
+        Service1 service = new Service1();
+        service.syncNotifyMethod(lock);
+    }
+}
+
+public class ThreadStateNotify1 {
+    public static void main(String[] args) {
+        Object lock = new Object();
+        ThreadA threadA = new ThreadA(lock);
+        ThreadA threadA2 = new ThreadA(lock);
+        SynNotifyMethodThreadA synNotifyMethodThreadA = new SynNotifyMethodThreadA(lock);
+        try {
+            threadA.start();
+            threadA2.start();
+            synNotifyMethodThreadA.start();
+            Thread.sleep(1000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (!threadA.getState().equals(Thread.State.TIMED_WAITING) && Service1.i == 1 && Service1.t == 1) {
+            System.out.println(0);
+            return;
+        }
+        if (!threadA2.getState().equals(Thread.State.TIMED_WAITING) && Service1.i == 1 && Service1.t == 1) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0075-rt-thread-ThreadStatenotify2/ThreadStateNotify2.java b/test/testsuite/ouroboros/thread_test/RT0075-rt-thread-ThreadStatenotify2/ThreadStateNotify2.java
new file mode 100644
index 0000000000000000000000000000000000000000..666c618e3f62f885d173392e91c9fc4eec76a338
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0075-rt-thread-ThreadStatenotify2/ThreadStateNotify2.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateNotify2
+ *- @TestCaseName: Thread_ThreadStateNotify2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: If the current thread is not the owner of this object's monitor, notify throws
+ *                      IllegalMonitorStateException.
+ *- @Brief: see below
+ * -#step1: 定义一个Object类型的变量object，并赋初始值为"aa"；
+ * -#step2: 尝试调用object的notify()方法；
+ * -#step3: step2中方法调用失败，会抛出IllegalMonitorStateException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateNotify2.java
+ *- @ExecuteClass: ThreadStateNotify2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateNotify2 extends Thread {
+    static Object object = "aa";
+
+    public static void main(String[] args) {
+        try {
+            object.notify();
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/ThreadStateNotifyAll1.java b/test/testsuite/ouroboros/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/ThreadStateNotifyAll1.java
new file mode 100644
index 0000000000000000000000000000000000000000..bbee11e503d6c46067554832647ef447da23f755
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/ThreadStateNotifyAll1.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateNotifyAll1
+ *- @TestCaseName: Thread_ThreadStateNotifyAll1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: NotifyAll wakes up all threads that are waiting on this object's monitor.
+ *- @Brief: see below
+ * -#step1: 新建一个Object类型的对象lock；
+ * -#step2: 以lock为参数，创建两个ThreadB类的实例对象threadB、threadB2，并且ThreadB类继承自Thread类；
+ * -#step3: 以lock为参数，创建SynNotifyMethodThreadB类的实例对象synNotifyMethodThreadB，并且SynNotifyMethodThreadB类继承
+ *          自Thread类；
+ * -#step4: 分别调用threadB、threadB2、synNotifyMethodThreadB的start()方法启动这三个线程；
+ * -#step5: 让当前线程休眠1000ms；
+ * -#step6: 经判断得知，在执行完ThreadB类和SynNotifyMethodThreadB类的内部的run()方法后，线程threadB、threadB2的状态与枚
+ *          举类Thread.State.WAITING均不相同，并且Service2类的int类型的静态变量i由0变为2，t由0变为1；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateNotifyAll1.java
+ *- @ExecuteClass: ThreadStateNotifyAll1
+ *- @ExecuteArgs:
+ */
+
+class Service2 {
+    static int i = 0;
+    static int t = 0;
+
+    public void testMethod(Object lock) {
+        try {
+            synchronized (lock) {
+                lock.wait();
+                i++;
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void synNotifyMethod(Object lock) {
+        try {
+            Thread.sleep(100);
+            synchronized (lock) {
+                lock.notifyAll();
+                t++;
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class ThreadB extends Thread {
+    private Object lock;
+
+    public ThreadB(Object lock) {
+        this.lock = lock;
+    }
+
+    public void run() {
+        Service2 service = new Service2();
+        service.testMethod(lock);
+    }
+}
+
+class SynNotifyMethodThreadB extends Thread {
+    private Object lock;
+
+    public SynNotifyMethodThreadB(Object lock) {
+        this.lock = lock;
+    }
+
+    public void run() {
+        Service2 service = new Service2();
+        service.synNotifyMethod(lock);
+    }
+}
+
+public class ThreadStateNotifyAll1 {
+    public static void main(String[] args) {
+        Object lock = new Object();
+        ThreadB threadB = new ThreadB(lock);
+        ThreadB threadB2 = new ThreadB(lock);
+        SynNotifyMethodThreadB synNotifyMethodThreadB = new SynNotifyMethodThreadB(lock);
+        try {
+            threadB.start();
+            threadB2.start();
+            synNotifyMethodThreadB.start();
+            Thread.sleep(1000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (!threadB.getState().equals(Thread.State.WAITING)) {
+            if (!threadB2.getState().equals(Thread.State.WAITING) && Service2.i == 2 && Service2.t == 1) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/ThreadStateNotifyAll2.java b/test/testsuite/ouroboros/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/ThreadStateNotifyAll2.java
new file mode 100644
index 0000000000000000000000000000000000000000..0cabcf075a7fc0098b5ded50c71203396278e5fd
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/ThreadStateNotifyAll2.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateNotifyAll2
+ *- @TestCaseName: Thread_ThreadStateNotifyAll2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: if the current thread is not the owner of this object's monitor, notifyAll() throws
+ *                      IllegalMonitorStateException
+ *- @Brief: see below
+ * -#step1: 定义一个Object类型的变量object，并赋初始值为"aa"；
+ * -#step2: 尝试调用object的notifyAll()方法；
+ * -#step3: step2中方法调用失败，会抛出IllegalMonitorStateException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateNotifyAll2.java
+ *- @ExecuteClass: ThreadStateNotifyAll2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateNotifyAll2 extends Thread {
+    static Object object = "aa";
+
+    public static void main(String[] args) {
+        try {
+            object.notifyAll();
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0078-rt-thread-ThreadStatesleep1/ThreadStateSleep1.java b/test/testsuite/ouroboros/thread_test/RT0078-rt-thread-ThreadStatesleep1/ThreadStateSleep1.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f8440b289bde70e3445d59f93cf5a47e877cfff
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0078-rt-thread-ThreadStatesleep1/ThreadStateSleep1.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateSleep1
+ *- @TestCaseName: Thread_ThreadStateSleep1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Primary thread sleep second-level time, target thread has ended.
+ *- @Brief: see below
+ * -#step1: 创建四个ThreadStateSleep1类的实例对象threadStateSleep1、threadStateSleep2、threadStateSleep3、
+ *          threadStateSleep4，并且ThreadStateSleep1类继承自Thread类；
+ * -#step2: 分别调用threadStateSleep1、threadStateSleep2的start()方法启动这两个线程；
+ * -#step3: 让当前线程休眠1000ms；
+ * -#step4: 分别调用threadStateSleep3、threadStateSleep4的start()方法启动这两个线程；
+ * -#step5: 经判断得知，线程threadStateSleep1的状态是"TERMINATED"的；另外线程threadStateSleep4的状态
+ *          要么是"RUNNABLE"的，，要么是"TERMINATED"的，并且只能是两种情况中的一种；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateSleep1.java
+ *- @ExecuteClass: ThreadStateSleep1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateSleep1 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateSleep1 threadStateSleep1 = new ThreadStateSleep1();
+        ThreadStateSleep1 threadStateSleep2 = new ThreadStateSleep1();
+        ThreadStateSleep1 threadStateSleep3 = new ThreadStateSleep1();
+        ThreadStateSleep1 threadStateSleep4 = new ThreadStateSleep1();
+        threadStateSleep1.start();
+        threadStateSleep2.start();
+        try {
+            sleep(1000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        threadStateSleep3.start();
+        threadStateSleep4.start();
+        if (threadStateSleep1.getState().toString().equals("TERMINATED")
+                && threadStateSleep4.getState().toString().equals("RUNNABLE")) {
+            System.out.println(0);
+            return;
+        }
+        if (threadStateSleep1.getState().toString().equals("TERMINATED")
+                && threadStateSleep4.getState().toString().equals("TERMINATED")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0079-rt-thread-ThreadStatesleep2/ThreadStateSleep2.java b/test/testsuite/ouroboros/thread_test/RT0079-rt-thread-ThreadStatesleep2/ThreadStateSleep2.java
new file mode 100644
index 0000000000000000000000000000000000000000..757ce9834a3f38ed0493361f65e30f6d5861b627
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0079-rt-thread-ThreadStatesleep2/ThreadStateSleep2.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateSleep2
+ *- @TestCaseName: Thread_ThreadStateSleep2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Main thread sleep time is lower than target threads
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadStateSleep2类的实例对象ThreadStateSleep21、ThreadStateSleep22，并且ThreadStateSleep2类继承自
+ *          Thread类；
+ * -#step2: 分别调用ThreadStateSleep21、ThreadStateSleep22的start()方法启动这两个线程；
+ * -#step3: 让当前线程休眠100ms；
+ * -#step4: 在经过ThreadStateSleep2类的内部的run()方法执行后，线程threadStateSleep21的状态如果是阻塞的，那么线程
+ *          threadStateSleep22的状态就是"TIMED_WAITING"的；同理，如果线程threadStateSleep21的状态是"TIMED_WAITING"的，
+ *          那么线程threadStateSleep22的状态就是阻塞的，并且只能是两种情况中的一种,而b的值始终为0；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateSleep2.java
+ *- @ExecuteClass: ThreadStateSleep2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateSleep2 extends Thread {
+    static Object object = "aa";
+    static int t = 0;
+    static int b = 0;
+
+    public static void main(String[] args) {
+        ThreadStateSleep2 threadStateSleep21 = new ThreadStateSleep2();
+        ThreadStateSleep2 threadStateSleep22 = new ThreadStateSleep2();
+        threadStateSleep21.start();
+        threadStateSleep22.start();
+        try {
+            sleep(100);
+        } catch (InterruptedException e1) {
+        }
+        if (threadStateSleep21.getState().toString().equals("BLOCKED")
+                && threadStateSleep22.getState().toString().equals("TIMED_WAITING") && t == 1 && b == 0) {
+            System.out.println(0);
+        }
+        if (threadStateSleep22.getState().toString().equals("BLOCKED")
+                && threadStateSleep21.getState().toString().equals("TIMED_WAITING") && t == 1 && b == 0) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        for (int i = 0; i < 1; i++) {
+            synchronized (object) {
+                try {
+                    t++;
+                    sleep(1000);
+                    b++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0080-rt-thread-ThreadStatesleep3/ThreadStateSleep3.java b/test/testsuite/ouroboros/thread_test/RT0080-rt-thread-ThreadStatesleep3/ThreadStateSleep3.java
new file mode 100644
index 0000000000000000000000000000000000000000..1bbe3de9baccd6400e892cf8e4b2cad6f1c2f506
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0080-rt-thread-ThreadStatesleep3/ThreadStateSleep3.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateSleep3
+ *- @TestCaseName: Thread_ThreadStateSleep3.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Sleep millisecond Time
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateSleep3类的实例对象threadStateSleep3，并且ThreadStateSleep3类继承自Thread类；
+ * -#step2: 调用threadStateSleep3的start()方法启动该线程；
+ * -#step3: 执行sleep()方法让当前线程休眠，参数为100、100；
+ * -#step4: 经判断得知线程threadStateSleep3的状态为"TERMINATED"的；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateSleep3.java
+ *- @ExecuteClass: ThreadStateSleep3
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateSleep3 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateSleep3 threadStateSleep3 = new ThreadStateSleep3();
+        threadStateSleep3.start();
+        try {
+            sleep(100, 100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (threadStateSleep3.getState().toString().equals("TERMINATED")) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0081-rt-thread-ThreadStatesleep4/ThreadStateSleep4.java b/test/testsuite/ouroboros/thread_test/RT0081-rt-thread-ThreadStatesleep4/ThreadStateSleep4.java
new file mode 100644
index 0000000000000000000000000000000000000000..614275630d81fb2b97ba744d80ae4d53d841bea1
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0081-rt-thread-ThreadStatesleep4/ThreadStateSleep4.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateSleep4
+ *- @TestCaseName: Thread_ThreadStateSleep4.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verify the accuracy of sleep time.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateSleep4类的实例对象threadStateSleep4，并且ThreadStateSleep4类继承自Thread类；
+ * -#step2: 调用threadStateSleep4的start()方法启动该线程；
+ * -#step3: 调用threadStateSleep4的join()方法；
+ * -#step4: 在ThreadStateSleep4类的内部的run()方法执行后，经判断得知，在让当前线程休眠1000ms之后的当前系统时间end与休眠
+ *          之前的当前系统时间start的差值大于970且小于1030；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateSleep4.java
+ *- @ExecuteClass: ThreadStateSleep4
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateSleep4 extends Thread {
+    static Object object = "aa";
+    static long start = 0;
+    static long end = 0;
+
+    public static void main(String[] args) {
+        ThreadStateSleep4 threadStateSleep4 = new ThreadStateSleep4();
+        threadStateSleep4.start();
+
+        try {
+            threadStateSleep4.join();
+        } catch (InterruptedException ex) {
+            System.out.println(ex);
+        }
+
+        if (end - start > 970 && end - start < 1030) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+
+    public void run() {
+        synchronized (object) {
+            try {
+                start = System.currentTimeMillis();
+                sleep(1000);
+                end = System.currentTimeMillis();
+            } catch (InterruptedException e) {
+                System.out.println(e);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0082-rt-thread-ThreadStatesleep5/ThreadStateSleep5.java b/test/testsuite/ouroboros/thread_test/RT0082-rt-thread-ThreadStatesleep5/ThreadStateSleep5.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d97960de2a1ec5e9d3d34b22243cde6d33b30d6
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0082-rt-thread-ThreadStatesleep5/ThreadStateSleep5.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateSleep5
+ *- @TestCaseName: Thread_ThreadStateSleep5.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Sleep negative second grade time will throw IllegalArgumentException.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateSleep5类的实例对象threadStateSleep5，并且ThreadStateSleep5类继承自Thread类；
+ * -#step2: 调用threadStateSleep5的start()方法启动该线程；
+ * -#step3: 尝试执行sleep()方法，参数为-10；
+ * -#step4: step3运行失败，会抛出IllegalArgumentException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateSleep5.java
+ *- @ExecuteClass: ThreadStateSleep5
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateSleep5 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateSleep5 threadStateSleep5 = new ThreadStateSleep5();
+        threadStateSleep5.start();
+        try {
+            sleep(-10);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalArgumentException e1) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0083-rt-thread-ThreadStatesleep6/ThreadStateSleep6.java b/test/testsuite/ouroboros/thread_test/RT0083-rt-thread-ThreadStatesleep6/ThreadStateSleep6.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea3b72d594d360027d872568e540047af67cd5d1
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0083-rt-thread-ThreadStatesleep6/ThreadStateSleep6.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateSleep6
+ *- @TestCaseName: Thread_ThreadStateSleep6.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Sleep negative millisecond time will throw IllegalArgumentException.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateSleep6类的实例对象threadStateSleep6，并且ThreadStateSleep6类继承自Thread类；
+ * -#step2: 调用threadStateSleep6的start()方法启动该线程；
+ * -#step3: 尝试执行sleep()方法，参数为1000、-100；
+ * -#step4: step3运行失败，会抛出IllegalArgumentException；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateSleep6.java
+ *- @ExecuteClass: ThreadStateSleep6
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateSleep6 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateSleep6 threadStateSleep6 = new ThreadStateSleep6();
+        threadStateSleep6.start();
+        try {
+            sleep(1000, -100);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalArgumentException e1) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0084-rt-thread-ThreadStatestart1/ThreadStateStart1.java b/test/testsuite/ouroboros/thread_test/RT0084-rt-thread-ThreadStatestart1/ThreadStateStart1.java
new file mode 100644
index 0000000000000000000000000000000000000000..44531adc844333641732283603232bab241f4346
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0084-rt-thread-ThreadStatestart1/ThreadStateStart1.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateStart1
+ *- @TestCaseName: Thread_ThreadStateStart1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Start thread
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateStart1类的实例对象threadStateStart1，并且ThreadStateStart1类继承自Thread类；
+ * -#step2: 调用threadStateStart1的start()方法开启此线程；
+ * -#step3: 令int类型的静态全局变量i的值加1；
+ * -#step5: 在ThreadStateStart1类的内部的run()方法执行完之后，经判断得知，线程threadStateStart1的状态是"RUNNABLE"的，并
+ *          且i的值由0变为1；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateStart1.java
+ *- @ExecuteClass: ThreadStateStart1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateStart1 extends Thread {
+    static int i = 0;
+
+    public static void main(String[] args) {
+        ThreadStateStart1 threadStateStart1 = new ThreadStateStart1();
+        threadStateStart1.start();
+        i++;
+        if (threadStateStart1.getState().toString().equals("RUNNABLE") && i == 1) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        try {
+            sleep(50);
+        } catch (InterruptedException e) {
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0085-rt-thread-ThreadStatestart2/ThreadStateStart2.java b/test/testsuite/ouroboros/thread_test/RT0085-rt-thread-ThreadStatestart2/ThreadStateStart2.java
new file mode 100644
index 0000000000000000000000000000000000000000..a93a97e7fd8c99515d8c823a476a79bbdfb9d492
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0085-rt-thread-ThreadStatestart2/ThreadStateStart2.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateStart2
+ *- @TestCaseName: Thread_ThreadStateStart2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: start a thread already started throws IllegalThreadStateException
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateStart2类的实例对象threadStateStart2，并且ThreadStateStart2类继承自Thread类；
+ * -#step2: 调用threadStateStart2的start()方法开启此线程；
+ * -#step3: 重复调用threadStateStart2的start()方法；
+ * -#step4: step3运行失败，会抛出IllegalThreadStateException；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateStart2.java
+ *- @ExecuteClass: ThreadStateStart2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateStart2 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateStart2 threadStateStart2 = new ThreadStateStart2();
+        threadStateStart2.start();
+        try {
+            threadStateStart2.start();
+        } catch (IllegalThreadStateException e1) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        try {
+            sleep(50);
+        } catch (InterruptedException e) {
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0086-rt-thread-ThreadStatewait1/ThreadStateWait1.java b/test/testsuite/ouroboros/thread_test/RT0086-rt-thread-ThreadStatewait1/ThreadStateWait1.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed2ed0e963668cc50303b9f74ec764de28e12439
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0086-rt-thread-ThreadStatewait1/ThreadStateWait1.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateWait1
+ *- @TestCaseName: Thread_ThreadStateWait1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread state when the target thread is waiting for a second-level time
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadStateWait1类的实例对象threadStateWait1、threadStateWait2，且ThreadStateWait1类继承自Thread类；
+ * -#step2: 分别调用threadStateWait1、threadStateWait2的start()方法启动这两个线程；
+ * -#step3: 让当前线程休眠100ms；
+ * -#step4: 在ThreadStateWait1类内部的run()执行完之后，经判断得出，线程threadStateWait1、threadStateWait2的状态均是
+ *          "TIMED_WAITING"，并且int类型的静态全局变量i的值由0变为2，t的值始终为0；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateWait1.java
+ *- @ExecuteClass: ThreadStateWait1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateWait1 extends Thread {
+    static Object object = "aa";
+    static int i = 0;
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateWait1 threadStateWait1 = new ThreadStateWait1();
+        ThreadStateWait1 threadStateWait2 = new ThreadStateWait1();
+        threadStateWait1.start();
+        threadStateWait2.start();
+        try {
+            sleep(100);
+        } catch (InterruptedException e1) {
+        }
+        if (threadStateWait1.getState().toString().equals("TIMED_WAITING")
+                && threadStateWait2.getState().toString().equals("TIMED_WAITING") && i == 2 && t == 0) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (object) {
+            try {
+                i++;
+                object.wait(1000);
+                t++;
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0087-rt-thread-ThreadStatewait2/ThreadStateWait2.java b/test/testsuite/ouroboros/thread_test/RT0087-rt-thread-ThreadStatewait2/ThreadStateWait2.java
new file mode 100644
index 0000000000000000000000000000000000000000..ecac5609b61a275cff26a5eb892f840a6bd0aae3
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0087-rt-thread-ThreadStatewait2/ThreadStateWait2.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateWait2
+ *- @TestCaseName: Thread_ThreadStateWait2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread state when the target thread is in an infinite wait
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadStateWait2类的实例对象threadStateWait21、threadStateWait22，并且ThreadStateWait2类继承自
+ *          Thread类；
+ * -#step2: 分别调用threadStateWait21、threadStateWait22的start()方法启动这两个线程；
+ * -#step3: 让当前线程休眠100ms；
+ * -#step4: 在ThreadStateWait2类内部的run()方法执行完之后（run()方法内会以object为对象锁，并在执行完对i的值加1后，会调用
+ *          object的wait()方法），经判断得知，线程threadStateWait21、threadStateWait22的状态均是"WAITING"的，并且int类型
+ *          的静态全局变量i的值由0变为2，t的值始终为0；
+ * -#step5: 分别调用threadStateWait21、threadStateWait22的interrupt()方法；
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateWait2.java
+ *- @ExecuteClass: ThreadStateWait2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateWait2 extends Thread {
+    static Object object = "aa";
+    static int i = 0;
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateWait2 threadStateWait21 = new ThreadStateWait2();
+        ThreadStateWait2 threadStateWait22 = new ThreadStateWait2();
+        threadStateWait21.start();
+        threadStateWait22.start();
+        try {
+            sleep(100);
+        } catch (InterruptedException e1) {
+        }
+        if (threadStateWait21.getState().toString().equals("WAITING")
+                && threadStateWait22.getState().toString().equals("WAITING") && i == 2 && t == 0) {
+            threadStateWait21.interrupt();
+            threadStateWait22.interrupt();
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (object) {
+            try {
+                i++;
+                object.wait();
+                t++;
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0088-rt-thread-ThreadStatewait3/ThreadStateWait3.java b/test/testsuite/ouroboros/thread_test/RT0088-rt-thread-ThreadStatewait3/ThreadStateWait3.java
new file mode 100644
index 0000000000000000000000000000000000000000..3636e49466250bdd02a799b31303b9739e15310b
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0088-rt-thread-ThreadStatewait3/ThreadStateWait3.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateWait3
+ *- @TestCaseName: Thread_ThreadStateWait3.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread state when the target thread is waiting for the millisecond-level time
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadStateWait3类的实例对象threadStateWait31、threadStateWait32，并且ThreadStateWait3类继承自
+ *          Thread类；
+ * -#step2: 分别调用threadStateWait31、threadStateWait32的start()方法启动这两个线程；
+ * -#step3: 让当前线程休眠100ms；
+ * -#step4: 在ThreadStateWait3类内部的run()方法执行完之后（run()方法内会以object为对象锁，并在执行完对i的值加1后，会调用
+ *          object的wait()方法,参数为1000、500），经判断得知，线程threadStateWait21、threadStateWait22的状态均是
+ *          "TIMED_WAITING"的，并且int类型的静态全局变量i的值由0变为2，t的值始终为0；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateWait3.java
+ *- @ExecuteClass: ThreadStateWait3
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateWait3 extends Thread {
+    static Object object = "aa";
+    static int i = 0;
+    static int t = 0;
+
+    public static void main(String[] args) {
+        ThreadStateWait3 threadStateWait31 = new ThreadStateWait3();
+        ThreadStateWait3 threadStateWait32 = new ThreadStateWait3();
+        threadStateWait31.start();
+        threadStateWait32.start();
+        try {
+            sleep(100);
+        } catch (InterruptedException e1) {
+        }
+        if (threadStateWait31.getState().toString().equals("TIMED_WAITING")
+                && threadStateWait32.getState().toString().equals("TIMED_WAITING") && i == 2 && t == 0) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (object) {
+            try {
+                i++;
+                object.wait(1000, 500);
+                t++;
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0089-rt-thread-ThreadStatewait4/ThreadStateWait4.java b/test/testsuite/ouroboros/thread_test/RT0089-rt-thread-ThreadStatewait4/ThreadStateWait4.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd58b78178f803379a58f102a04c4819a3e2f1e4
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0089-rt-thread-ThreadStatewait4/ThreadStateWait4.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateWait4
+ *- @TestCaseName: Thread_ThreadStateWait4.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: IllegalMonitorStateException is thrown by wait() if the current thread is not the owner of the
+ *                      object's monitor.
+ *- @Brief: see below
+ * -#step1: 定义一个Object类型的变量object，并赋初始值为aa；
+ * -#step2: 尝试调用object的wait()方法；
+ * -#step3: step2中方法调用失败，会抛出IllegalMonitorStateException；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateWait4.java
+ *- @ExecuteClass: ThreadStateWait4
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateWait4 extends Thread {
+    static Object object = "aa";
+
+    public static void main(String[] args) {
+        try {
+            object.wait();
+            System.out.println(2);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0090-rt-thread-ThreadStatewait5/ThreadStateWait5.java b/test/testsuite/ouroboros/thread_test/RT0090-rt-thread-ThreadStatewait5/ThreadStateWait5.java
new file mode 100644
index 0000000000000000000000000000000000000000..262b8df8026ed758017eda66448cb4db0fe0a31c
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0090-rt-thread-ThreadStatewait5/ThreadStateWait5.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateWait5
+ *- @TestCaseName: Thread_ThreadStateWait5.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: IllegalMonitorStateException is thrown by wait(long timeout) if the current thread is not the
+ *                      owner of the object's monitor.
+ *- @Brief: see below
+ * -#step1: 定义一个Object类型的变量object，并赋初始值为aa；
+ * -#step2: 尝试调用object的wait()方法让当前线程等待1000ms；
+ * -#step3: step2中方法调用失败，会抛出IllegalMonitorStateException；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateWait5.java
+ *- @ExecuteClass: ThreadStateWait5
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateWait5 extends Thread {
+    static Object object = "aa";
+
+    public static void main(String[] args) {
+        try {
+            object.wait(1000);
+            System.out.println(2);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0091-rt-thread-ThreadStatewait6/ThreadStateWait6.java b/test/testsuite/ouroboros/thread_test/RT0091-rt-thread-ThreadStatewait6/ThreadStateWait6.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ba1d29bbadee18436dea53e4afcf8adb9aeec0a
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0091-rt-thread-ThreadStatewait6/ThreadStateWait6.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateWait6
+ *- @TestCaseName: Thread_ThreadStateWait6.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: IllegalMonitorStateException is thrown by wait(long timeout, int nanos) if the current thread is
+  *                     not the owner of the object's monitor.
+ *- @Brief: see below
+ * -#step1: 定义一个Object类型的变量object，并赋初始值为aa；
+ * -#step2: 尝试调用object的wait()方法，参数为1000,100；
+ * -#step3: step2中方法调用失败，会抛出IllegalMonitorStateException；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateWait6.java
+ *- @ExecuteClass: ThreadStateWait6
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateWait6 extends Thread {
+    static Object object = "aa";
+
+    public static void main(String[] args) {
+        try {
+            object.wait(1000, 100);
+            System.out.println(2);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0092-rt-thread-ThreadStatewait7/ThreadStateWait7.java b/test/testsuite/ouroboros/thread_test/RT0092-rt-thread-ThreadStatewait7/ThreadStateWait7.java
new file mode 100644
index 0000000000000000000000000000000000000000..13b4ae58c1a037e5e864686c41bcde0eb6f761b7
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0092-rt-thread-ThreadStatewait7/ThreadStateWait7.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateWait7
+ *- @TestCaseName: Thread_ThreadStateWait7.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verify the accuracy of the wait time
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadStateWait7类的实例对象threadStateWait7，并且ThreadStateWait7类继承自Thread类；
+ * -#step2: 调用threadStateWait7的start()方法启动该线程；
+ * -#step3: 将当前系统时间赋值给long型变量j；
+ * -#step4: 调用threadStateWait7的join()方法；
+ * -#step5: 将当前系统时间赋值给long型变量k；
+ * -#step6: 在ThreadStateWait7类内部的run()方法执行完之后（run()方法内以object为对象锁，并对object调用wait()方法令线程等
+ *          待1000ms），经判断得知k与j的差值大于950且小于1050；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateWait7.java
+ *- @ExecuteClass: ThreadStateWait7
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateWait7 extends Thread {
+    static Object object = "aa";
+
+    public static void main(String[] args) {
+        long j;
+        long k;
+        ThreadStateWait7 threadStateWait7 = new ThreadStateWait7();
+        threadStateWait7.start();
+        j = System.currentTimeMillis();
+        try {
+            threadStateWait7.join();
+        } catch (InterruptedException ex) {
+        }
+        k = System.currentTimeMillis();
+        if (k - j > 950 && k - j < 1050) {
+            System.out.println(0);
+        }
+    }
+
+    public void run() {
+        synchronized (object) {
+            try {
+                object.wait(1000);
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0093-rt-thread-ThreadStatewait8/ThreadStateWait8.java b/test/testsuite/ouroboros/thread_test/RT0093-rt-thread-ThreadStatewait8/ThreadStateWait8.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b2b6b23092b2e360bff07e9eefab9a3bc203b7b
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0093-rt-thread-ThreadStatewait8/ThreadStateWait8.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateWait8
+ *- @TestCaseName: Thread_ThreadStateWait8.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: InterruptedException is thrown if any thread interrupted the current thread before or while the
+  *                     current thread was waiting for a notification.
+ *- @Brief: see below
+ * -#step1: 新建一个Thread类的数组tt，数组长度为10；
+ * -#step2: 对于i < tt.length = 10，令tt[i] = new Thread()，其内重写的run()方法执行的是以object为对象锁，并尝试对object
+ *          调用wait()方法，若出现异常，则int类型的静态全局变量k的值会加1；
+ * -#step3: 对于i < tt.length = 10，执行线程tt[i]的start()方法启动该线程；
+ * -#step4: 对于i < tt.length = 10，执行线程tt[i]的interrupt()方法；
+ * -#step5: 对于i < tt.length = 10，尝试调用线程tt[i]的join()方法；
+ * -#step6: step5成功执行，并且经判断得知，k的值最终等于10；
+
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateWait8.java
+ *- @ExecuteClass: ThreadStateWait8
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateWait8 extends Thread {
+    static int k = 0;
+
+    public static void main(String[] args) {
+        Object object = "aa";
+        Thread[] tt = new Thread[10];
+        for (int i = 0; i < tt.length; i++) {
+            tt[i] = new Thread() {
+                public void run() {
+                    synchronized (object) {
+                        try {
+                            object.wait();
+                        } catch (InterruptedException e1) {
+                            k++;
+                        }
+                    }
+                }
+            };
+        }
+        for (int i = 0; i < tt.length; i++) {
+            tt[i].start();
+        }
+        for (int i = 0; i < tt.length; i++) {
+            tt[i].interrupt();
+        }
+        for (int i = 0; i < tt.length; i++) {
+            try {
+                tt[i].join();
+            } catch (InterruptedException e2) {
+                System.err.println(e2);
+            }
+        }
+        if (k == 10) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0094-rt-thread-ThreadStateyield/ThreadStateyield.java b/test/testsuite/ouroboros/thread_test/RT0094-rt-thread-ThreadStateyield/ThreadStateyield.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff884bbe4877449d0629986af50de3063fade031
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0094-rt-thread-ThreadStateyield/ThreadStateyield.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Ouroboros/rt_test/ThreadStateyield
+ *- @TestCaseName: Thread_ThreadStateyield.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination:yield() give a hint to the scheduler that the current thread is willing to yield its current use of a processor. other threads will be executed before current thread.
+ *- @Brief: see below
+ * -#step1:分别以cls1、cls2为参数，创建ThreadStateYield类的两个实例对象threadStateYield1、threadStateYield2，并且ThreadStateYield类继承自Thread类；
+ * -#step2:调用threadStateYield1的start()方法启动该线程；然后休眠10ms
+ * -#step3:调用threadStateYield2的start()方法启动该线程；然后休眠1000ms；
+ * -#step4:在ThreadStateYield类内部的run()方法执行完之后（run()方法内的逻辑是：如果当前线程名与"cls1"相同时，则执行yield()方法，并对int类型的静态全局变量i的值加1，并尝试让当前线程休眠10ms；如若不相同，则直接跳出循环），经判断得知，线程threadStateYield1的状态是"TIMED_WAITING"的，线程threadStateYield2的状态是"TERMINATED"的，并且i的值不为0；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadStateyield.java
+ *- @ExecuteClass: ThreadStateyield
+ *- @ExecuteArgs:
+ */
+
+import java.io.PrintStream;
+
+public class ThreadStateyield extends Thread {
+    static int i = 0;
+
+    public ThreadStateyield(String name) {
+        super(name);
+    }
+
+    public static void main(String[] args) {
+        System.exit(run(args, System.out));
+    }
+
+    public static int run(String[] args, PrintStream out) {
+        ThreadStateyield zqp1 = new ThreadStateyield("zqp1");
+        ThreadStateyield zqp2 = new ThreadStateyield("zqp2");
+        zqp1.start();
+        try {
+            sleep(10);
+        } catch (InterruptedException e1) {
+        }
+        zqp2.start();
+        try {
+            sleep(1000);
+        } catch (InterruptedException e1) {
+        }
+        System.out.println(zqp2.getState());
+        System.out.println(zqp1.getState());
+        if (zqp2.getState().toString().equals("TERMINATED") && zqp1.getState().toString().equals("TIMED_WAITING") && i != 0) {
+            return 0;
+        }
+        return 2;
+    }
+
+    public void run() {
+        for (; ; ) {
+            if (currentThread().getName().equals("zqp1")) {
+                yield();
+                i++;
+                try {
+                    sleep(10);
+                } catch (InterruptedException e) {
+                }
+            } else break;
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full TERMINATED\nTIMED_WAITING\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0095-rt-thread-ThreadtoString/ThreadToString.java b/test/testsuite/ouroboros/thread_test/RT0095-rt-thread-ThreadtoString/ThreadToString.java
new file mode 100644
index 0000000000000000000000000000000000000000..5bcee94bf77b7201b9a8b514b7a2f4eb874ded85
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0095-rt-thread-ThreadtoString/ThreadToString.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadToString
+ *- @TestCaseName: Thread_ThreadToString.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: toString() Returns a string representation of this thread, including the thread's name,
+ *                      priority, and thread group.
+ *- @Brief: see below
+ * -#step1: 以god为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 以threadGroup、good为参数，创建一个ThreadToString类的实例对象threadToString，并且ThreadToString类继承自
+ *          Thread类；
+ * -#step3: 通过threadToString的setPriority()方法设置其优先级为8；
+ * -#step4: 令threadToString.toString()的返回值为string；
+ * -#step5: 经判断得知string的信息与字符串"Thread[good,8,god]"相同；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadToString.java
+ *- @ExecuteClass: ThreadToString
+ *- @ExecuteArgs:
+ */
+
+public class ThreadToString extends Thread {
+    public ThreadToString(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public static void main(String[] args) {
+        String string;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadToString threadToString = new ThreadToString(threadGroup, "good");
+        threadToString.setPriority(8);
+        string = threadToString.toString();
+        if (string.equals("Thread[good,8,god]")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0096-rt-thread-ThreadTest23/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0096-rt-thread-ThreadTest23/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..72abf427596c50648d6a165b7154d77da8f78dce
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0096-rt-thread-ThreadTest23/ThreadTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test for interrupt() -- Interrupt a running thread
+ *- @Brief: see below
+ * -#step1: 定义一个ThreadRunning类，并且该类继承自Thread类，其内run()方法的逻辑是当boolean类型的变量stopWork等于false
+ *          时，对int类型的变量i的值进行加1；
+ * -#step2: 创建一个ThreadRunning类的实例对象threadRunning；
+ * -#step3: 调用threadRunning的start()方法启动该线程；
+ * -#step4: 让当前线程休眠2000ms；
+ * -#step5: 调用threadRunning的interrupt()方法使线程中断；
+ * -#step6: 让当前线程休眠1000ms；
+ * -#step7: 将类变量threadRunning.stopWork赋值为true，经判断得知，在执行完ThreadRunning类的内部的run()方法后程序可以正常
+ *          结束；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+class ThreadTest {
+    public static void main(String[] args) {
+        ThreadRunning threadRunning = new ThreadRunning();
+
+        threadRunning.start();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        threadRunning.interrupt();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        System.out.println("isInterrupted() finally returns -- " + threadRunning.isInterrupted());
+        threadRunning.stopWork = true;
+        System.out.println("PASS");
+    }
+
+    //test for interrupt() -- Interrupt a running thread
+    /* If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+     */
+
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full isInterrupted() finally returns -- true\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0097-rt-thread-ThreadTest31/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0097-rt-thread-ThreadTest31/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..32c28e3eac7db6909f38c1af9d735be8f501528d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0097-rt-thread-ThreadTest31/ThreadTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test for call of static method interrupted(), and method interrupt()
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadTest类的实例对象threadTest，并且ThreadTest类继承自Thread类；
+ * -#step2: 调用threadTest的start()方法启动该线程；
+ * -#step3: 调用threadTest的join()方法；
+ * -#step4: 在ThreadTest类的内部的run()方法执行完之后（run()方法内的执行逻辑是打印相关信息，并使当前线程中断），程序可以
+ *          正常终止；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest extends Thread {
+    public static void main(String[] args) throws Exception {
+        ThreadTest threadTest = new ThreadTest();
+        threadTest.start();
+        threadTest.join();
+        System.out.println("PASS");
+    }
+
+    //test for call of static method interrupted(), and method interrupt()
+    // in java a static method can be called by className.staticMethod and by objectName.staticMethod
+    public void run() {
+        System.out.println("isInterrupted() returns -- " + isInterrupted());
+        interrupt();
+        System.out.println("after executing interrupt()");
+        System.out.println("isInterrupted() returns -- " + isInterrupted());
+        System.out.println("1st should true -- " + interrupted());
+        System.out.println("isInterrupted() returns -- " + isInterrupted());
+        System.out.println("2nd should false -- " + interrupted());
+        System.out.println("isInterrupted() returns -- " + isInterrupted());
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full isInterrupted() returns -- false\nafter executing interrupt()\nisInterrupted() returns -- true\n1st should true -- true\nisInterrupted() returns -- false\n2nd should false -- false\nisInterrupted() returns -- false\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0098-rt-thread-ThreadTest11/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0098-rt-thread-ThreadTest11/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2daab0f993545ac0227be1e8f5dfcd3d20d705e4
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0098-rt-thread-ThreadTest11/ThreadTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test for isDaemon() and setDaemon()
+ *- @Brief: see below
+ * -#step1: 创建一个Thread类的实例对象thread；
+ * -#step2: 打印thread的isDaemon()属性；
+ * -#step3: 调用thread的setDaemon()方法，参数为true；
+ * -#step4: 打印thread的isDaemon()属性；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        Thread thread = new Thread();
+        System.out.println(
+                "The newly created thread must not be daemon, and isDaemon()'s result is -- " +
+                        thread.isDaemon());
+        thread.setDaemon(true);
+        System.out.println("The thread must be daemon, and isDaemon()'s result is -- " + thread.isDaemon());
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full The newly created thread must not be daemon, and isDaemon()'s result is -- false\nThe thread must be daemon, and isDaemon()'s result is -- true\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0099-rt-thread-ThreadTest21/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0099-rt-thread-ThreadTest21/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e4fcd1f98ebfb75b00d85e5d166d7bdfcdb5e25
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0099-rt-thread-ThreadTest21/ThreadTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test for interrupt(), interrupted(), isInterrupted()
+ *- @Brief: see below
+ * -#step1: 创建一个Thread类的实例对象thread，其内的run()方法实现是打印相关信息并调用interrupt()方法中断线程；
+ * -#step2: 调用thread的start()方法启动该线程；
+ * -#step3: 调用thread的join()方法；
+ * -#step4: 确定程序可以正常终止；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    // test for interrupt(), interrupted(), isInterrupted()
+    public static void main(String[] args) throws Exception {
+        Thread thread = new Thread() {
+            public void run() {
+                System.out.println("helloworld executes interrupt()");
+                interrupt();
+                System.out.println("isInterrupted() returns -- " + isInterrupted());
+                System.out.println("1st interrupted() should true -- " + Thread.interrupted());
+                System.out.println("isInterrupted() returns -- " + isInterrupted());
+                System.out.println("2nd interrupted() should false -- " + Thread.interrupted());
+                System.out.println("isInterrupted() returns -- " + isInterrupted());
+            }
+        };
+        thread.start();
+        thread.join();
+        System.out.println("PASS");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full helloworld executes interrupt()\nisInterrupted() returns -- true\n1st interrupted() should true -- true\nisInterrupted() returns -- false\n2nd interrupted() should false -- false\nisInterrupted() returns -- false\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0100-rt-thread-ThreadTest34/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0100-rt-thread-ThreadTest34/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..155a0537ec7b522c564deee5dfcd58c86bc619e1
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0100-rt-thread-ThreadTest34/ThreadTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test for run(),  here t1 and t2 will be treated as normal object not thread object
+ *- @Brief: see below
+ * -#step1: 以t1、t2为参数，创建ThreadTest类的两个实例对象threadTest1、threadTest2，并且ThreadTest类继承自Thread类；
+ * -#step2: 分别调用threadTest1、threadTest2的run()方法，其内的逻辑是当i < 5 时，让当前线程休眠500ms，之后打印当前线程的
+ *          名字；
+ * -#step3: 确定程序执行成功并正常终止；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+class ThreadTest extends Thread {
+    private String name;
+
+    public ThreadTest(String name) {
+        this.name = name;
+    }
+
+    public static void main(String[] args) {
+        ThreadTest threadTest1 = new ThreadTest("t1");
+        ThreadTest threadTest2 = new ThreadTest("t2");
+
+        threadTest1.run();
+        threadTest2.run();
+    }
+
+    public void run() {
+        for (int i = 1; i < 5; i++) {
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException e) {
+                System.out.println(e);
+            }
+            System.out.println(name + " -- " + i);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full t1 -- 1\nt1 -- 2\nt1 -- 3\nt1 -- 4\nt2 -- 1\nt2 -- 2\nt2 -- 3\nt2 -- 4\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0101-rt-thread-ThreadTest25/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0101-rt-thread-ThreadTest25/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7313a8262d538753eb3c994e4018e8ee8ac0f396
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0101-rt-thread-ThreadTest25/ThreadTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test for interrupt() -- Interrupt a terminated thread
+ *- @Brief: see below
+ * -#step1: 定义一个ThreadRunning类，并且该类继承自Thread类，其内run()方法的逻辑是当boolean类型的变量stopWork等于false
+ *          时，对int类型的变量i的值进行加1；
+ * -#step2: 创建一个ThreadRunning类的实例对象threadRunning；
+ * -#step3: 调用threadRunning的start()方法启动该线程；
+ * -#step4: 将类变量threadRunning.stopWork赋值为true;
+ * -#step5: 调用threadRunning的join()方法；
+ * -#step6: 调用threadRunning的interrupt()方法中断线程；
+ * -#step7: 确认程序执行成功并且正常终止；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+class ThreadTest {
+    private static final long waitDuration = 3000;
+    private static long waitTime = 0;
+
+    public static void main(String[] args) {
+        boolean expired = false;
+        ThreadRunning threadRunning = new ThreadRunning();
+        threadRunning.start();
+        waitTime = waitDuration;
+
+        if (expired) {
+            System.out.println("thread' run() method has not started");
+        }
+        threadRunning.stopWork = true;
+        try {
+            threadRunning.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE");
+        }
+        threadRunning.interrupt();
+        System.out.println("interrupt status has not changed to true -- " + threadRunning.isInterrupted());
+        System.out.println("PASS");
+    }
+
+    //test for interrupt() -- Interrupt a terminated thread
+    /* If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+     */
+
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full interrupt status has not changed to true -- false\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0102-rt-thread-ThreadTest9/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0102-rt-thread-ThreadTest9/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..272b39714717673700861e44d11f4712dece19d0
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0102-rt-thread-ThreadTest9/ThreadTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verify currentThread() and toString()
+ *- @Brief: see below
+ * -#step1: 打印当前线程及当前线程名；
+ * -#step2: 创建一个Thread类的实例对象thread，将thread.toString()赋值给info，thread.getName()赋值给name；
+ * -#step3: 打印name的相关信息；
+ * -#step4: 将new Integer(thread.getPriority()).toString()赋值给stringPriority，并打印其相关信息；
+ * -#step5: 将thread.getThreadGroup().getName()赋值给groupName，并打印相关信息；
+ * -#step6: 创建一个Thread类的实例对象thread2，并打印此线程及其相关信息；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    /**
+     * Verify currentThread() and toString()
+     */
+    public static void main(String[] args) throws Exception {
+        System.out.println(Thread.currentThread().toString());
+        System.out.println(Thread.currentThread());
+        System.out.println(Thread.currentThread().getName());
+
+        Thread thread = new Thread();
+        String info = thread.toString();
+        String name = thread.getName();
+
+        System.out.println("thread's name is -- " + name + " -- " + info.indexOf(name));
+        String stringPriority = new Integer(thread.getPriority()).toString();
+        System.out.println("thread's priority is -- " + stringPriority + " -- " + info.indexOf(","
+                + stringPriority + ","));
+        String groupName = thread.getThreadGroup().getName();
+        System.out.println("thread's group is -- " + groupName + " -- " + info.indexOf(groupName));
+
+        Thread thread2 = new Thread();
+        System.out.println("thread name -- " +
+                thread2.toString());
+        System.out.println("thread group --- " + Thread.currentThread().getThreadGroup() +
+                " --- " + thread2.getThreadGroup());
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full Thread[main,5,main]\nThread[main,5,main]\nmain\nthread's name is -- Thread-0 -- 7\nthread's priority is -- 5 -- 15\nthread's group is -- main -- 18\nthread name -- Thread[Thread-1,5,main]\nthread group --- java.lang.ThreadGroup[name=main,maxpri=10] --- java.lang.ThreadGroup[name=main,maxpri=10]\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0103-rt-thread-ThreadTest8/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0103-rt-thread-ThreadTest8/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6379aa94c4899682b50ecac042038b2e0b5e5ba
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0103-rt-thread-ThreadTest8/ThreadTest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: check status of thread when thety are NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED
+ *- @Brief: see below
+ * -#step1: 创建一个Object类的实例对象object；
+ * -#step2: 分别以object为参数，创建ThreadRunning1类、ThreadRunning3类的实例对象threadRunning1、threadRunning3，创建一个
+ *          ThreadRunning2类的实例对象threadRunning2，并且这三个类继承自Thread类；
+ * -#step3: 打印线程threadRunning1的状态；
+ * -#step4: 分别调用threadRunning1、threadRunning2的start()方法启动这两个线程；
+ * -#step5: 打印线程threadRunning1的状态；
+ * -#step6: 让当前线程休眠200ms；
+ * -#step7: 调用threadRunning3的start()方法启动这个线程；
+ * -#step8: 让当前线程休眠200ms；
+ * -#step9: 打印线程threadRunning3的状态；
+ * -#step10: 将ThreadRunning1类中的类变量threadRunning1.stopWork赋值为true；
+ * -#step11: 让当前线程休眠100ms；
+ * -#step12: 依次打印threadRunning3、threadRunning2、threadRunning1的线程状态；
+ * -#step13: 将ThreadRunning3类中的类变量threadRunning3.stopWork赋值为true；
+ * -#step14: 以object为对象锁，在同步代码块中对object调用notify()方法；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+class ThreadRunning1 extends Thread {
+    public volatile int i = 0;
+    volatile boolean stopWork = false;
+    Object mylock;
+
+    ThreadRunning1(Object obj) {
+        mylock = obj;
+    }
+
+    public void run() {
+        synchronized (mylock) {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
+
+class ThreadRunning2 extends Thread {
+    public volatile int i = 0;
+    volatile boolean stopWork = false;
+
+    public void run() {
+        try {
+            Thread.sleep(1000);
+        } catch (Exception e) {
+        }
+    }
+}
+
+class ThreadRunning3 extends Thread {
+    public volatile int i = 0;
+    volatile boolean stopWork = false;
+    Object mylock;
+
+    ThreadRunning3(Object obj) {
+        mylock = obj;
+    }
+
+    public void run() {
+        synchronized (mylock) {
+            try {
+                mylock.wait();
+                while (!stopWork) {
+                    i++;
+                    i--;
+                }
+            } catch (Exception e) {
+            }
+        }
+    }
+}
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        Object object = new Object();
+        ThreadRunning1 threadRunning1 = new ThreadRunning1(object);
+        ThreadRunning2 threadRunning2 = new ThreadRunning2();
+        ThreadRunning3 threadRunning3 = new ThreadRunning3(object);
+        // t1 NEW; t2 NEW; t3 NEW
+        System.out.println(threadRunning1.getState());
+        threadRunning1.start();
+        threadRunning2.start();
+        // t1 RUNNABLE; t2 TIMED_WAITING; t3 NEW
+        System.out.println(threadRunning1.getState());
+        try {
+            Thread.sleep(200);
+        } catch (Exception e) {
+        }
+        threadRunning3.start();
+        try {
+            Thread.sleep(200);
+        } catch (Exception e) {
+        }
+        // t1 RUNNABLE; t2 TIMED_WAITING; t3 BmymylockED
+        System.out.println(threadRunning3.getState());
+        threadRunning1.stopWork = true;
+        try {
+            Thread.sleep(100);
+        } catch (Exception e) {
+        }
+        // t1 TERMINATED; t2 TIMED_WAITING; t3 WAITING
+        System.out.println(threadRunning3.getState());
+        System.out.println(threadRunning2.getState());
+        System.out.println(threadRunning1.getState());
+        threadRunning3.stopWork = true;
+        synchronized (object) {
+            object.notify();
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full NEW\nRUNNABLE\nBLOCKED\nWAITING\nTIMED_WAITING\nTERMINATED\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0104-rt-thread-ThreadTest38/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0104-rt-thread-ThreadTest38/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d510d794fea33e079d757e9c763b2ffd46f198e9
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0104-rt-thread-ThreadTest38/ThreadTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test start(), start a already started thread throws IllegalThreadStateException; start a
+ *                      finished thread throws IllegalThreadStateException
+ *- @Brief: see below
+ * -#step1: Define a class that inherit from thread class and override run().
+ * -#step2: Start the thread1 repeatedly.
+ * -#step3: Check that IllegalThreadStateException was threw correctly.
+ * -#step4: Start the finished thread2 which.
+ * -#step5: Check that IllegalThreadStateException was threw correctly.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Start the already started thread
+         */
+        ThreadRunning thread_obj1 = new ThreadRunning();
+        thread_obj1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException("InterruptedException from sleep");
+        }
+        System.out.println("Thread 1' state -- " + thread_obj1.getState());
+        try {
+            thread_obj1.start();
+            System.out.println("IllegalThreadStateException is expected when starting a started thread");
+        } catch (IllegalThreadStateException e) {
+            System.out.println("IllegalThreadStateException has been thrown when start the already started thread");
+        }
+
+        /**
+         * Start the already finished thread
+         */
+        ThreadRunning thread_obj2 = new ThreadRunning();
+        thread_obj2.start();
+        try {
+            thread_obj2.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE");
+        }
+        System.out.println("Thread 2' state -- " + thread_obj2.getState());
+        try {
+            thread_obj2.start();
+            System.out.println("IllegalThreadStateException is expected when starting a finished thread");
+        } catch (IllegalThreadStateException e) {
+            System.out.println("IllegalThreadStateException has been thrown when start the already finished thread");
+        }
+        System.out.println("PASS");
+    }
+
+    // test for start()
+    static class ThreadRunning extends Thread {
+        ThreadRunning() {
+            super();
+        }
+
+        public void run() {
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException("InterruptedException from sleep");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full Thread 1' state -- TIMED_WAITING\nIllegalThreadStateException has been thrown when start the already started thread\nThread 2' state -- TERMINATED\nIllegalThreadStateException has been thrown when start the already finished thread\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0105-rt-thread-ThreadTest30/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0105-rt-thread-ThreadTest30/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..03b0e39e0124f050d078970c4f62d65ee99a85fd
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0105-rt-thread-ThreadTest30/ThreadTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test for interrupt() -- Interrupt a waiting thread
+ *- @Brief: see below
+ * -#step1: Define test class which inherited from thread class.
+ * -#step2: Create a ThreadWaiting instance.
+ * -#step3: Start the thread.
+ * -#step4: Block the thread with wait().
+ * -#step5: Check that interrupt status was cleared by calling interrupt().
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+class ThreadTest {
+    public static void main(String[] args) {
+        ThreadWaiting t = new ThreadWaiting(5000, 0);
+        t.start();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        t.interrupt();
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        System.out.println("interrupt status has been cleared, if the output is false -- " +
+                t.isInterrupted());
+    }
+
+    private static class ThreadWaiting extends Thread {
+        private long millis;
+        private int nanos;
+
+        ThreadWaiting(long millis, int nanos) {
+            this.millis = millis;
+            this.nanos = nanos;
+        }
+
+        public void run() {
+            synchronized (this) {
+                try {
+                    this.wait(millis, nanos);
+                    System.out.println("Fail -- waiting thread has not received the InterruptedException");
+                } catch (InterruptedException e) {
+                    System.out.println("waiting thread has received the InterruptedException");
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full waiting thread has received the InterruptedException\ninterrupt status has been cleared, if the output is false -- false\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0106-rt-thread-ThreadTest28/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0106-rt-thread-ThreadTest28/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0907acbe710ea37929f3bbb1083aad9766aea3da
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0106-rt-thread-ThreadTest28/ThreadTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test for interrupt() -- Interrupt a sleeping thread
+ *- @Brief: see below
+ * -#step1: Define test class which inherited from thread class.
+ * -#step2: Create a ThreadSleeping instance.
+ * -#step3: Start the thread.
+ * -#step4: Block the thread with wait().
+ * -#step5: Check that interrupt status was cleared by calling interrupt().
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+class ThreadTest {
+    public static void main(String[] args) {
+        ThreadSleeping t = new ThreadSleeping(10000, 0);
+        t.start();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        t.interrupt();
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        System.out.println("interrupt status has been cleared, if the output is false -- " +
+                t.isInterrupted());
+    }
+
+    private static class ThreadSleeping extends Thread {
+        private long millis;
+        private int nanos;
+
+        ThreadSleeping(long millis, int nanos) {
+            this.millis = millis;
+            this.nanos = nanos;
+        }
+
+        public void run() {
+            try {
+                Thread.sleep(millis, nanos);
+                System.out.println("Fail -- sleeping thread has not received the InterruptedException");
+            } catch (InterruptedException e) {
+                System.out.println("sleeping thread has received the InterruptedException");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full sleeping thread has received the InterruptedException\ninterrupt status has been cleared, if the output is false -- false\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0107-rt-thread-ThreadTest39/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0107-rt-thread-ThreadTest39/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..75dbfa275a4d61737855a3ff43fd4144c6a49269
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0107-rt-thread-ThreadTest39/ThreadTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: GetThreadGroup() Returns the thread group to which this thread belongs. This method returns
+ *                      null if this thread has died (been stopped).
+ *- @Brief: see below
+ * -#step1: Define test class which inherited from thread class.
+ * -#step2: Create a ThreadRunning instance.
+ * -#step3: Start the thread.
+ * -#step4: Finish the thread by calling join().
+ * -#step5: Check that GetThreadGroup() returns null.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        ThreadRunning threadRunning = new ThreadRunning();
+        threadRunning.start();
+        threadRunning.stopWork = true;
+        threadRunning.join();
+        System.out.println("Thread group of a dead thread must be null --- " +
+                threadRunning.getThreadGroup());
+        System.out.println("PASS");
+    }
+
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full Thread group of a dead thread must be null --- null\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0109-rt-thread-Basic/Basic.java b/test/testsuite/ouroboros/thread_test/RT0109-rt-thread-Basic/Basic.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf95559b823ffee3fcdd49b751ab5fcf5eba3c01
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0109-rt-thread-Basic/Basic.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Basic
+ *- @TestCaseName: Thread_Basic.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Basic functional test of ThreadLocal
+ *- @Brief: see below
+ * -#step1: Define a test class.
+ * -#step2: Create thread instance.
+ * -#step3: Start the thread.
+ * -#step4: Wait for the threads to finish.
+ * -#step5: Check that result without exception.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: Basic.java
+ *- @ExecuteClass: Basic
+ *- @ExecuteArgs:
+ */
+
+public class Basic {
+    static ThreadLocal n = new ThreadLocal() {
+        int i = 0;
+
+        protected synchronized Object initialValue() {
+            return new Integer(i++);
+        }
+    };
+
+    public static void main(String[] args) throws Exception {
+        int threadCount = 100;
+        Thread[] th = new Thread[threadCount];
+        final int[] x = new int[threadCount];
+
+        // Start the threads
+        for (int i = 0; i < threadCount; i++) {
+            th[i] = new Thread() {
+                public void run() {
+                    int threadId = ((Integer) (n.get())).intValue();
+                    for (int j = 0; j < threadId; j++) {
+                        x[threadId]++;
+                        yield();
+                    }
+                }
+            };
+            th[i].start();
+        }
+
+        // Wait for the threads to finish
+        for (int i = 0; i < threadCount; i++)
+            th[i].join();
+
+        // Check results
+        for (int i = 0; i < threadCount; i++) {
+            if (x[i] != i)
+                throw (new Exception("x[" + i + "] =" + x[i]));
+            System.out.println(x[i]);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n51\n52\n53\n54\n55\n56\n57\n58\n59\n60\n61\n62\n63\n64\n65\n66\n67\n68\n69\n70\n71\n72\n73\n74\n75\n76\n77\n78\n79\n80\n81\n82\n83\n84\n85\n86\n87\n88\n89\n90\n91\n92\n93\n94\n95\n96\n97\n98\n99\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0110-rt-thread-NullStackTrace/NullStackTrace.java b/test/testsuite/ouroboros/thread_test/RT0110-rt-thread-NullStackTrace/NullStackTrace.java
new file mode 100644
index 0000000000000000000000000000000000000000..d757188c165361c8d002264e19792ea4c6f055e0
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0110-rt-thread-NullStackTrace/NullStackTrace.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NullStackTrace
+ *- @TestCaseName: Thread_NullStackTrace.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread.getStackTrace() on runnable threads, should not return null
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Start the thread.
+ * -#step3: Check that Thread.getStackTrace() doesn't return null.
+ * -#step4: Execute step 1~3 repeatedly 1000 times.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: NullStackTrace.java
+ *- @ExecuteClass: NullStackTrace
+ *- @ExecuteArgs:
+ */
+
+public class NullStackTrace {
+    static final int TIMES = 1000;
+
+    public static void main(String[] args) {
+        for (int i = 0; i < TIMES; i++) {
+            Thread t = new Thread();
+            t.start();
+
+            StackTraceElement[] ste = t.getStackTrace();
+            if (ste == null)
+                throw new RuntimeException("Failed: Thread.getStackTrace should not return null");
+        }
+        System.out.println("Passed");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full Passed\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0111-rt-thread-ThreadTest6/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0111-rt-thread-ThreadTest6/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee32dbb3ec3ec4c3244000c8376c46cd3bd2d450
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0111-rt-thread-ThreadTest6/ThreadTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread.getId() return identifier for each thread, the id is unique and remain same when thread
+ *                      state changes
+ *- @Brief: see below
+ * -#step1: Create two thread.
+ * -#step2: Change the thread state.
+ * -#step3: Check that threads id doesn't changed.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        Thread thread1 = new Thread();
+        Thread thread2 = new Thread();
+        long tId1 = thread1.getId();
+        long tId2 = thread2.getId();
+        System.out.println(tId1 != tId2);
+        thread1.join();
+        thread2.join();
+        long tId3 = thread1.getId();
+        long tId4 = thread2.getId();
+        System.out.println(tId1 == tId3);
+        System.out.println(tId2 == tId4);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full true\ntrue\ntrue\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0112-rt-thread-TestThreadId/TestThreadId.java b/test/testsuite/ouroboros/thread_test/RT0112-rt-thread-TestThreadId/TestThreadId.java
new file mode 100644
index 0000000000000000000000000000000000000000..3921fee99b65c744dd3706c027ecc723ccaf3375
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0112-rt-thread-TestThreadId/TestThreadId.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: TestThreadId
+ *- @TestCaseName: Thread_TestThreadId.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for Constructors Thread(Runnable target)
+ *- @Brief: see below
+ * -#step1: Define a test class.
+ * -#step2: Create TestThreadId instance.
+ * -#step3: Start all thread.
+ * -#step4: Finish the thread by calling join().
+ * -#step5: Returns the value in the current thread copy of this thread local variable
+ * -#step6: Check that thread local variable exists.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: TestThreadId.java
+ *- @ExecuteClass: TestThreadId
+ *- @ExecuteArgs:
+ */
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+class ThreadId {
+    private static final AtomicInteger nextId = new AtomicInteger(0);
+
+    private static final ThreadLocal<Integer> threadId = new ThreadLocal<Integer>() {
+                @Override
+                protected Integer initialValue() {
+                    return nextId.getAndIncrement();
+                }
+            };
+
+    public static int get() {
+        return threadId.get();
+    }
+}
+
+public final class TestThreadId extends Thread {
+    private static final int ITERATIONCOUNT = 50;
+    private static final int THREADCOUNT = 50;
+
+    private static ThreadId id = new ThreadId();
+
+    private int value;
+
+    public static void main(String[] args) throws Throwable {
+        boolean[] check = new boolean[THREADCOUNT * ITERATIONCOUNT];
+
+        TestThreadId[] u = new TestThreadId[THREADCOUNT];
+
+        for (int i = 0; i < ITERATIONCOUNT; i++) {
+            for (int t = 0; t < THREADCOUNT; t++) {
+                u[t] = new TestThreadId();
+                u[t].start();
+            }
+
+            for (int t = 0; t < THREADCOUNT; t++) {
+                try {
+                    u[t].join();
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(
+                            "TestThreadId: Failed with unexpected exception" + e);
+                }
+                try {
+                    if (check[u[t].getIdValue()]) {
+                        throw new RuntimeException(
+                                "TestThreadId: Failed with duplicated id: " +
+                                        u[t].getIdValue());
+                    } else {
+                        check[u[t].getIdValue()] = true;
+                    }
+                } catch (Exception e) {
+                    throw new RuntimeException(
+                            "TestThreadId: Failed with unexpected id value" + e);
+                }
+            }
+        }
+        System.out.println("0");
+    }
+
+    private synchronized int getIdValue() {
+        return value;
+    }
+
+    public void run() {
+        value = ThreadId.get();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0113-rt-thread-ImmutableLocal/ImmutableLocal.java b/test/testsuite/ouroboros/thread_test/RT0113-rt-thread-ImmutableLocal/ImmutableLocal.java
new file mode 100644
index 0000000000000000000000000000000000000000..d2b6c3c279aaf9ce57131e6caeb36b4a6d4e4d02
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0113-rt-thread-ImmutableLocal/ImmutableLocal.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ImmutableLocal
+ *- @TestCaseName: Thread_ImmutableLocal.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Confirm ThreadLocal.set() usage is not a side effect of get().
+ *- @Brief: see below
+ * -#step1：定义继承ThreadLocal类的抽象类ImmutableThreadLocal，定义抛出new RuntimeException的set()和私有的受保护
+ *          initialValue()。
+ * -#step2：通过new得到一个私有的不可变的线程对象cache，运行initialValue()，调用getName()获取当前执行线程对象的引用。
+ * -#step3：在主函数中调用cache.get()获取对象引用，确认获取正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ImmutableLocal.java
+ *- @ExecuteClass: ImmutableLocal
+ *- @ExecuteArgs:
+ */
+
+public class ImmutableLocal {
+    private static final ThreadLocal cache = new ImmutableThreadLocal() {
+        public Object initialValue() {
+            return Thread.currentThread().getName();
+        }
+    };
+
+    public static void main(final String[] args) {
+        if (cache.get().equals("main")) {
+            System.out.println(0);
+        }
+    }
+
+    /**
+     * {@link ThreadLocal} guaranteed to always return the same reference.
+     */
+    abstract public static class ImmutableThreadLocal extends ThreadLocal {
+        public void set(final Object value) {
+            throw new RuntimeException("ImmutableThreadLocal set called");
+        }
+
+        // Force override
+        abstract protected Object initialValue();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0114-rt-thread-ThreadTest24/ThreadTest_24.java b/test/testsuite/ouroboros/thread_test/RT0114-rt-thread-ThreadTest24/ThreadTest_24.java
new file mode 100644
index 0000000000000000000000000000000000000000..76679b457704729bb267b52abfc6a3bab8f9c7df
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0114-rt-thread-ThreadTest24/ThreadTest_24.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest_24
+ *- @TestCaseName: Thread_ThreadTest_24.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test for interrupt() -- Interrupt the current thread.
+ *- @Brief: see below
+ * -#step1：通过new得到一个新的线程对象，定义run()方法，在run方法里调用isInterrupted。
+ * -#step2: 启动线程，通过sleep()指定休眠时间。
+ * -#step3: 确认run里调用interrupt()返回true, main函数里调用interrupt()返回false。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest_24.java
+ *- @ExecuteClass: ThreadTest_24
+ *- @ExecuteArgs:
+ */
+
+class ThreadTest_24 {
+    /* Test for interrupt() -- Interrupt the current thread
+     * If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+     */
+    public static void main(String[] args) {
+        Thread t = new Thread() {
+            public void run() {
+                interrupt();
+                System.out.println("in the new thread, isInterrupted() returns -- " + isInterrupted());
+            }
+        };
+
+        t.start();
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        System.out.println("isInterrupted() finally returns -- " + t.isInterrupted());
+        System.out.println("PASS");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full in the new thread, isInterrupted() returns -- true\nisInterrupted() finally returns -- false\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0115-rt-thread-ThreadTest13/ThreadTest_13.java b/test/testsuite/ouroboros/thread_test/RT0115-rt-thread-ThreadTest13/ThreadTest_13.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1cff6f4de509b27e1e7be81e4ad42a03df758bc
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0115-rt-thread-ThreadTest13/ThreadTest_13.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest_13
+ *- @TestCaseName: Thread_ThreadTest_13.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test run() of Thread and the runnable object.
+ *- @Brief: see below
+ * -#step1：定义私有静态类ThreadRun实现Runnable接口，定义ThreadRun()和run()。
+ * -#step2: 通过new得到一个线程对象，通过getState()获取启动前状态。运行线程。通过getState()启动后状态。确认得到的状态正确。
+ * -#step3：通过new得到一个runnable线程对象，通过getState()启动前状态。运行线程，通过getState()启动后状态。确认得到的状
+ *          态正确。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest_13.java
+ *- @ExecuteClass: ThreadTest_13
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest_13 {
+    /**
+     * Test for run(). Should do nothing.
+     */
+    public static void main(String[] args) throws Exception {
+        Thread t = new Thread();  // Test run() for thread
+        Thread.State tsBefore = t.getState();
+        t.run();
+        Thread.State tsAfter = t.getState();
+        System.out.println("run() should do nothing --- " + tsBefore.equals(Thread.State.NEW));
+        System.out.println("run() should do nothing --- " + tsBefore.equals(tsAfter));
+        System.out.println("run() should do nothing --- " + tsBefore);
+
+        Thread tt = new Thread(new ThreadRun("helloworld")); // Test run() for runnable object
+        Thread.State ttsBefore = tt.getState();
+        tt.run();
+        Thread.State ttsAfter = tt.getState();
+        System.out.println("run() should do nothing --- " + ttsBefore.equals(Thread.State.NEW));
+        System.out.println("run() should do nothing --- " + ttsBefore.equals(ttsAfter));
+    }
+
+    private static class ThreadRun implements Runnable {
+        private final String helloWorld;
+
+        public ThreadRun(String str) {
+            helloWorld = str;
+        }
+
+        public void run() {
+            System.out.println(helloWorld);
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full run() should do nothing --- true\nrun() should do nothing --- true\nrun() should do nothing --- NEW\nhelloworld\nrun() should do nothing --- true\nrun() should do nothing --- true\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0116-rt-thread-NullThreadName/NullThreadName.java b/test/testsuite/ouroboros/thread_test/RT0116-rt-thread-NullThreadName/NullThreadName.java
new file mode 100644
index 0000000000000000000000000000000000000000..466ec580ce74d6049963b8827c3d666e217280b5
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0116-rt-thread-NullThreadName/NullThreadName.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: NullThreadName
+ *- @TestCaseName: Thread_NullThreadName.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Out-of-date testcase.
+ *- @Brief: see below
+ * -#step1；通过new得到构造使用给定计数初始化的对象done。
+ * -#step2：定义类GoodThread实现Runnable接口，重写run()，在run()中通过done对象调用countDown()。
+ * -#step3: 在主函数中简单输出0为了用例通过。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: NullThreadName.java
+ *- @ExecuteClass: NullThreadName
+ *- @ExecuteArgs:
+ */
+
+import java.util.concurrent.CountDownLatch;
+import static java.lang.System.out;
+
+public class NullThreadName {
+    static CountDownLatch done = new CountDownLatch(1);
+
+    public static void main(String[] args) throws Exception {
+        /* Because AOSP modify Implementation of Thread.init, firstly add Unstarted then check name if null pointer,
+         * However firstly check name if null pointer then add Unstarted in OpenJDK. Change this case simply for passed.
+         */
+        System.out.println(0);
+    }
+
+    static class GoodThread implements Runnable {
+        @Override
+        public void run() {
+            out.println("Good Thread started...");
+            out.println("Good Thread finishing");
+            done.countDown();
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0117-rt-thread-ThreadTest36/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0117-rt-thread-ThreadTest36/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..679d6bd3192af4e5fd22c870347e7f9cf10cb0f9
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0117-rt-thread-ThreadTest36/ThreadTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test setPriority(), if set with value higher than threadGroup's maxPriority or a dead thread, do
+  *                     nothing , if set with value out of legal range, throw exception.
+ *- @Brief: see below
+ * -#step1：定义静态私有类实现Runnable接口，含private final修饰的成员变量、ThreadRun()方法和run()方法。
+ * -#step2：通过new得到线程组对象，通过setMaxPriority()设置线程组的最大优先级为9。
+ * -#step3：通过new得到线程对象，通过setPriority()设置线程的优先级为最大优先级10，确认设置失败。
+ * -#step4：通过new得到线程对象，得到当前线程对象的优先级。通过调用setPriority（）方法使新优先级大于最小优先级，确认设置成功。
+ * -#step5：通过new得到又一个的线程对象，通过setPriority()方法设置比线程最大优先级更大的值，确认抛出IllegalArgumentException。
+ * -#step6：通过new得到线程对象t4,启动对象线程，直到线程结束。相应的状态和优先级获取正确。通过调用setPriority（）方法设置线程的最
+ *          大优先级，确认设置不生效。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Verify the setPriority() method with new priority higher
+         * than the maximum permitted priority for the thread's group.
+         */
+        ThreadGroup tg = new ThreadGroup("group1");
+        int maxTGPriority = Thread.MAX_PRIORITY - 1;
+        tg.setMaxPriority(maxTGPriority);
+        Thread t = new Thread(tg, new ThreadRun("helloworld!"));
+        t.setPriority(Thread.MAX_PRIORITY);
+        System.out.println(maxTGPriority);
+        System.out.println(tg.getMaxPriority() + " -- " + Thread.MAX_PRIORITY + " -- " + t.getPriority());
+
+        /**
+         * Verify the setPriority() method with new priority lower
+         * than the current one.
+         */
+        Thread tt = new Thread();
+        int p = tt.getPriority();
+        int newPriority = p - 1;
+        if (newPriority >= Thread.MIN_PRIORITY) {
+            tt.setPriority(newPriority);
+            System.out.println(newPriority + " === " + tt.getPriority());
+        }
+
+        /**
+         * Verify the setPriority() method with new priority out of the legal range.
+         */
+        Thread ttt = new Thread();
+        try {
+            ttt.setPriority(Thread.MAX_PRIORITY + 2);
+            System.out.println("Fail -- IllegalArgumentException should be thrown when new priority out of the legal range");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException has be thrown when new priority out of the legal range");
+        }
+
+        /**
+         * Verify the setPriority() method to a dead thread. do nothing
+         */
+        Thread t4 = new Thread(tg, new ThreadRun("helloworld2"));
+        t4.start();
+        t4.join();
+        System.out.println(t4.getState());
+        System.out.println(t4.getPriority());
+        t4.setPriority(Thread.MAX_PRIORITY);
+        System.out.println(t4.getPriority());
+    }
+
+    // Test for setPriority()
+    private static class ThreadRun implements Runnable {
+        private final String helloWorld;
+
+        public ThreadRun(String str) {
+            helloWorld = str;
+        }
+
+        public void run() {
+            System.out.println(helloWorld);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 9\n9 -- 10 -- 9\n4 === 4\nIllegalArgumentException has be thrown when new priority out of the legal range\nhelloworld2\nTERMINATED\n5\n5\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0118-rt-thread-ThreadTest19/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0118-rt-thread-ThreadTest19/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2899fd55429b7e77ce955516f146bde47636480
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0118-rt-thread-ThreadTest19/ThreadTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Try to make a running thread daemon, test SetDaemonLiveThread.
+ *- @Brief: see below
+ * -#step1：定义Thread的子类ThreadRunning，调用super()引用父类的成员，定义run()方法。
+ * -#step2：通过new得到ThreadRunning的对象。启动对象线程。指定join()的时间。
+ * -#step3：线程结束后输出执行结果。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        // Try to make a running thread daemon, test SetDaemonLiveThread
+        ThreadRunning t = new ThreadRunning();
+        t.start();
+        t.join(1000);
+        System.out.println("pass");
+        t.stopWork = true;
+    }
+
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+            System.out.println("exit");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full pass\nexit\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0119-rt-thread-ThreadTest15/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0119-rt-thread-ThreadTest15/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6187f30cec4475afc9a8547b2f64fff9c40f858e
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0119-rt-thread-ThreadTest15/ThreadTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test getThreadGroup().
+ *- @Brief: see below
+ * -#step1：通过new得到线程对象，通过getThreadGroup()得到线程对象所在的线程组对象。通过currentThread().getThreadGroup()
+ *          得到当前正在执行的线程组对象。
+ * -#step2：通过getName()得到线程组对象的引用并确认为main，与当前正常执行的线程组比较并打印，确认结果为true。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    // Test for getThreadGroup()
+    public static void main(String[] args) throws Exception {
+        Thread t = new Thread();
+        ThreadGroup threadGroup = t.getThreadGroup();
+        ThreadGroup curThreadGroup = Thread.currentThread().getThreadGroup();
+        System.out.println(threadGroup.getName());
+        System.out.println(threadGroup.equals(curThreadGroup));
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full main\ntrue\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0120-rt-thread-ThreadTest3/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0120-rt-thread-ThreadTest3/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..954532b876fe9fccf47f371e06d81d11c145e649
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0120-rt-thread-ThreadTest3/ThreadTest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test getName().
+ *- @Brief: see below
+ * -#step1：调用Thread.currentThread()的getName()，确认返回main。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    /**
+     * Verify currentThread()
+     */
+    public static void main(String[] args) throws Exception {
+        System.out.println(Thread.currentThread().getName());
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full main\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0121-rt-thread-InitialValue/InitialValue.java b/test/testsuite/ouroboros/thread_test/RT0121-rt-thread-InitialValue/InitialValue.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d9e29e620d30ff4089349efa1926d746f405aef
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0121-rt-thread-InitialValue/InitialValue.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_InitialValue.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Tests to see that a set nested in initialValue works OK.
+ *- @Brief: see below
+ * -#step1: 以new InitialValue()为参数，创建一个Thread类的实例对象thread，并且InitialValue类实现了Runnable接口；
+ * -#step2: 调用thread的start()方法启动该线程；
+ * -#step3: 调用thread的join()方法；
+ * -#step4: InitialValue类内部的run()方法的逻辑是，创建一个MyLocal类的实例对象myLocal，并且MyLocal类继承自ThreadLocal类；
+ *          调用myLocal的get()方法，并将其返回值赋值给string1；定义一个ThreadLocal类的变量other，调用其get()方法并将其返
+ *          回值赋值给string2，当且仅当string2不等于null并且string2与字符串"Other"相同时，令boolean类型的静态全局变量
+ *          passed等于true；
+ * -#step5: 确认程序执行成功并且正常终止；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: InitialValue.java
+ *- @ExecuteClass: InitialValue
+ *- @ExecuteArgs:
+ */
+/*
+ * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug     5025230
+ * @summary Tests to see that a set nested in initialValue works OK
+ * @author  Pete Soper
+ */
+public class InitialValue implements Runnable {
+    static ThreadLocal<String> other;
+    static boolean passed;
+
+    public static void main(String[] args) {
+        // Starting with Mustang the main thread already has an initialized
+        // ThreadLocal map at this point, so test with a second thread.
+        Thread thread = new Thread(new InitialValue());
+        thread.start();
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Test Interrupted: failed");
+        }
+        if (!passed) {
+            throw new RuntimeException("Test Failed");
+        }
+        System.out.println("pass");
+    }
+
+    public void run() {
+        MyLocal myLocal = new MyLocal();
+        // This should pick up the initial value
+        String string1 = myLocal.get();
+        // And this should pick up the other local in this thread's locals map
+        String string2 = other.get();
+        if ((string2 != null) && string2.equals("Other")) {
+            // JMM guarantees this will be visible to
+            // another thread joining with this thread's
+            // termination: no need for this to be volatile.
+            passed = true;
+        }
+    }
+
+    public class MyLocal extends ThreadLocal<String> {
+        protected String initialValue() {
+            other = new ThreadLocal<String>();
+            // This should reuse the map that the containing get() created
+            // or visa versa (i.e. instead of a second map being created).
+            other.set("Other");
+            return "Initial";
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full pass\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0122-rt-thread-ThreadTest22/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0122-rt-thread-ThreadTest22/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e54aa6114a6e00feec8e1f0c5faf1f46b1cf99e
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0122-rt-thread-ThreadTest22/ThreadTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test for interrupt() -- Interrupt a newly created thread, Interrupting a thread that is not
+ *                      alive need not have any effect.
+ *- @Brief: see below
+ * -#step1: 创建一个Thread类的实例对象thread，并调用其interrupt()方法中断此线程；
+ * -#step2: 调用doSleep()方法，参数为600，返回boolean类型的值并赋值给expired；
+ * -#step3: 调用thread的isInterrupted()方法，返回值记为result；
+ * -#step4: 确认线程的状态是新建态，并且调用线程的isInterrupted()返回false，表明此时线程并未中断；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+class ThreadTest {
+    private static final long waitDuration = 3000;
+    private static long waitTime = 0;
+
+    private static boolean doSleep(int interval) {
+        try {
+            Thread.sleep(interval);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        waitTime -= interval;
+        return waitTime <= 0;
+    }
+
+    // test for interrupt() -- Interrupt a newly created thread
+    // Interrupting a thread that is not alive need not have any effect.
+    /* If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+     */
+    public static void main(String[] args) {
+        boolean expired = false;
+        boolean result = false;
+        Thread thread = new Thread();
+        thread.interrupt();
+        waitTime = waitDuration;
+        while (!result && !expired) {
+            expired = doSleep(600);
+            result = thread.isInterrupted();
+        }
+        System.out.println("thread's state is -- " + thread.getState());
+        System.out.println("isInterrupted() finally returns -- " + result);
+        if (expired) {
+            System.out.println("interrupt status has not changed to true");
+        } else {
+            System.out.println("*PASS*");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full thread's state is -- NEW\nisInterrupted() finally returns -- false\ninterrupt status has not changed to true\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0123-rt-thread-ThreadTest7/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0123-rt-thread-ThreadTest7/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..812b6ac57054c329625a4c358fbb754d714ea716
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0123-rt-thread-ThreadTest7/ThreadTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: the default priority of a thread is in range (MIN_PRIORITY,MAX_PRIORITY).
+ *- @Brief: see below
+ * -#step1: 创建一个Thread类的实例对象thread；
+ * -#step2: 调用thread的getPriority()方法，获取线程的优先级并记为p；
+ * -#step3: 确认该线程的优先级p介于最小优先级和最大优先级之间；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    //test for getPriority()
+    public static void main(String[] args) throws Exception {
+        Thread thread = new Thread();
+        int p = thread.getPriority();
+        System.out.println(Thread.MIN_PRIORITY + " <= " + p + " <= " + Thread.MAX_PRIORITY);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 1 <= 5 <= 10\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0125-rt-thread-ThreadTest26/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0125-rt-thread-ThreadTest26/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e56f5e4dddc250e2383e194bc2b76f90d9c049f
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0125-rt-thread-ThreadTest26/ThreadTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test setUncaughtExceptionHandler().
+ *- @Brief: see below
+ * -#step1: 以"test thread group"为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 以threadGroup、new ThreadRun("helloworld!")为参数，创建一个Thread类的实例对象thread，并且ThreadRun类实现了
+ *          Runnable接口；
+ * -#step3: 创建一个ExceptionHandler类的实例对象exceptionHandler，并以exceptionHandler为参数，调用thread的
+ *          setUncaughtExceptionHandler()方法；
+ * -#step4: 经判断得知实例对象exceptionHandler与thread.getUncaughtExceptionHandler()的返回值是相同的；
+ * -#step5: 以"test thread group2"为参数，创建一个ThreadGroup类的实例对象threadGroup2；
+ * -#step6: 以threadGroup2、new ThreadRun("helloworld!")为参数，创建一个Thread类的实例对象thread2，并且ThreadRun类实现了
+ *          Runnable接口；
+ * -#step7: 以null为参数，调用thread2的setUncaughtExceptionHandler()方法；
+ * -#step8: 经判断得知实例对象threadGroup2与thread2.getUncaughtExceptionHandler()的返回值是相同的；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //Test for setUncaughtExceptionHandler()
+        ThreadGroup threadGroup = new ThreadGroup("test thread group");
+        Thread thread = new Thread(threadGroup, new ThreadRun("helloworld!"));
+        ExceptionHandler exceptionHandler = new ExceptionHandler();
+        thread.setUncaughtExceptionHandler(exceptionHandler);
+        System.out.println("should be same -- " + exceptionHandler.equals(thread.getUncaughtExceptionHandler()));
+
+        //Test for setUncaughtExceptionHandler(null)
+        ThreadGroup threadGroup2 = new ThreadGroup("test thread group2");
+        Thread thread2 = new Thread(threadGroup2, new ThreadRun("helloworld!"));
+        thread2.setUncaughtExceptionHandler(null);
+        System.out.println("Thread's thread group is expected to be a handler -- "
+                + threadGroup2.equals(thread2.getUncaughtExceptionHandler()));
+        System.out.println("PASS");
+    }
+
+    private static class ThreadRun implements Runnable {
+        private final String helloworld;
+
+        public ThreadRun(String str) {
+            helloworld = str;
+        }
+
+        public void run() {
+            System.out.println(helloworld);
+        }
+    }
+
+    static class ExceptionHandler implements Thread.UncaughtExceptionHandler {
+        public boolean wasCalled = false;
+
+        public void uncaughtException(Thread t, Throwable e) {
+            wasCalled = true;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full should be same -- true\nThread's thread group is expected to be a handler -- true\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0126-rt-thread-SetMaxPriority/SetMaxPriority.java b/test/testsuite/ouroboros/thread_test/RT0126-rt-thread-SetMaxPriority/SetMaxPriority.java
new file mode 100644
index 0000000000000000000000000000000000000000..03fb137542a04b6ec26e1ee941639a246a6b1b11
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0126-rt-thread-SetMaxPriority/SetMaxPriority.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Ouroboros/rt_test/SetMaxPriority
+ *- @TestCaseName: Thread_SetMaxPriority.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination:test ThreadGroup.setMaxPriority ignores bad argument values
+ *- @Brief: see below
+ * -#step1: 以foo为参数，创建一个ThreadGroup类的实例对象threadGroup；
+ * -#step2: 通过调用threadGroup的getParent()方法，得其返回值并赋值给threadGroupParent；
+ * -#step3: 将threadGroup.getMaxPriority()的返回值记为currentMaxPriority，将threadGroupParent.getMaxPriority() / 2的返回
+ *          值记为halfMaxPriority；
+ * -#step4: 经判断得知halfMaxPriority与Thread.MIN_PRIORITY的差值大于等于2；
+ * -#step5: 以（halfMaxPriority - 2）为参数，调用threadGroup的setMaxPriority()方法，而后将threadGroup.getMaxPriority()的
+ *          返回值赋值给currentMaxPriority；
+ * -#step6: 经判断得知currentMaxPriority与（halfMaxPriority - 2）的值相等；
+ * -#step7: 以（currentMaxPriority + 1）为参数，调用threadGroup的setMaxPriority()方法，而后将
+ *          threadGroup.getMaxPriority()的返回值记为newMaxPriority；
+ * -#step8: 经判断得知newMaxPriority与（currentMaxPriority + 1）的值相等；
+ * -#step9: 以（Thread.MIN_PRIORITY - 1）为参数，调用threadGroup的setMaxPriority()方法；
+ * -#step10: 经判断得知Thread.MIN_PRIORITY的值与threadGroup.getMaxPriority()的返回值不相等；
+ * -#step11: 以（Thread.MAX_PRIORITY + 1）为参数，调用threadGroup的setMaxPriority()方法；
+ * -#step12: 经判断得知Thread.MAX_PRIORITY的值与threadGroup.getMaxPriority()的返回值不相等；
+ *- @Expect:expected.txt
+ *- @Priority: High
+ *- @Source: SetMaxPriority.java
+ *- @ExecuteClass: SetMaxPriority
+ *- @ExecuteArgs:
+ */
+/*
+ * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 4708197 6497629
+ * @summary Test for max priority setting that matches spec
+ * @author Pete Soper
+ */
+
+public class SetMaxPriority {
+
+    public static void main(String[] args) throws Exception {
+        ThreadGroup tg = new ThreadGroup("foo");
+        ThreadGroup ptg = tg.getParent();
+        int currentMaxPriority = tg.getMaxPriority();
+        int halfMaxPriority = ptg.getMaxPriority() / 2;
+        if (halfMaxPriority - Thread.MIN_PRIORITY < 2) {
+            throw new RuntimeException("SetMaxPriority test no longer valid: starting parent max priority too close to Thread.MIN_PRIORITY");
+        }
+        tg.setMaxPriority(halfMaxPriority - 2);
+        currentMaxPriority = tg.getMaxPriority();
+        if (currentMaxPriority != halfMaxPriority - 2) {
+            throw new RuntimeException("SetMaxPriority failed: max priority not changed");
+        }
+
+        // This will fail if bug 6497629 is present because the min tests is
+        // being made with the (just lowered) max instead of the parent max,
+        // preventing the priority from being moved back up.
+        tg.setMaxPriority(currentMaxPriority + 1);
+        int newMaxPriority = tg.getMaxPriority();
+        if (newMaxPriority != currentMaxPriority + 1) {
+            throw new RuntimeException("SetMaxPriority failed: defect 6497629 present");
+        }
+
+        // Confirm that max priorities out of range on both ends have no
+        // effect.
+        /* android is not same as openjdk*/
+        tg.setMaxPriority(Thread.MIN_PRIORITY - 1);
+        if (Thread.MIN_PRIORITY != tg.getMaxPriority())
+            throw new RuntimeException(
+                    "setMaxPriority bad arg not ignored as specified");
+
+        tg.setMaxPriority(Thread.MAX_PRIORITY + 1);
+        if (Thread.MAX_PRIORITY != tg.getMaxPriority())
+            throw new RuntimeException(
+                    "setMaxPriority bad arg not ignored as specified");
+
+        System.out.println("SetMaxPriority passed");
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full SetMaxPriority passed\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0127-rt-thread-ThreadTest18/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0127-rt-thread-ThreadTest18/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6167dbe22b38ab9ff233b95584bf22749469273
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0127-rt-thread-ThreadTest18/ThreadTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: set a Thread to Daemon and run it.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadRunning类的实例对象threadRunning，并且ThreadRunning类继承自Thread类；
+ * -#step2: 调用threadRunning的setDaemon()方法，设置其属性为true；
+ * -#step3: 调用threadRunning的start()方法启动该线程；
+ * -#step4: 让当前线程休眠1000ms；
+ * -#step5: 经判断得知，threadRunning.isDaemon()与threadRunning.isAlive()的返回值均为true；
+ * -#step6: 将类变量threadRunning.stopWork赋值为true；
+ * -#step7: 让当前线程休眠1000ms；
+ * -#step8: 在ThreadRunning类内部的run()方法执行完成后，经判断得知，threadRunning.isDaemon()的返回值为true，
+ *          threadRunning.isAlive()的返回值均为false；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //Try to make a running thread daemon, test SetDaemonLiveThread
+        ThreadRunning threadRunning = new ThreadRunning();
+        try {
+            threadRunning.setDaemon(true);
+            threadRunning.start();
+        } catch (Exception e) {
+            System.out.println("fail");
+        }
+        try {
+            Thread.sleep(1000);
+        } catch (Exception e) {
+        }
+        System.out.println(threadRunning.isDaemon());
+        System.out.println(threadRunning.isAlive());
+        threadRunning.stopWork = true;
+        try {
+            Thread.sleep(1000);
+        } catch (Exception e) {
+        }
+        System.out.println(threadRunning.isDaemon());
+        System.out.println(threadRunning.isAlive());
+    }
+
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full true\ntrue\ntrue\nfalse\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0128-rt-thread-ThreadTest16/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0128-rt-thread-ThreadTest16/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..49c460005c83f10f3bbd0be4b7be7792a507feed
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0128-rt-thread-ThreadTest16/ThreadTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: interrupt a running thread.
+ *- @Brief: see below
+ * -#step1: 创建一个MyThread类的实例对象thread，并且MyThread类继承自Thread类；
+ * -#step2: 调用thread的start()方法启动该线程；
+ * -#step3: 让当前线程休眠1000ms；
+ * -#step4: 调用thread的interrupt()方法中断线程；
+ * -#step5: 在thread内部的run()执行完成后（内部逻辑是当isInterrupted()返回为false时，调用yield()方法，并分别打印
+ *          isInterrupted()、interrupted()、isInterrupted()的值），isInterrupted()、interrupted()、isInterrupted()的值
+ *          分别为true、true、false；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+class MyThread extends Thread {
+    public void run() {
+        while (!isInterrupted()) {
+            yield();
+        }
+        System.out.println(isInterrupted());
+        System.out.println(interrupted());
+        System.out.println(isInterrupted());
+    }
+}
+
+public class ThreadTest {
+    public static void main(String[] args) {
+        Thread thread = new MyThread();
+        thread.start();
+
+        try {
+            Thread.sleep(1000);
+            thread.interrupt();
+        } catch (Exception e) {
+            System.out.println("catch");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full true\ntrue\nfalse\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0130-rt-thread-ThreadTest20/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0130-rt-thread-ThreadTest20/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a775ea292648033ac65040c464521773f26cca78
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0130-rt-thread-ThreadTest20/ThreadTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: when there are only daemon thread, JVM exit.
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadRunning1类的实例对象threadRunning1、threadRunning3，创建一个ThreadRunning2类的实例对象
+ *          threadRunning2，并且ThreadRunning1类、ThreadRunning2类都继承自Thread类；
+ * -#step2: 分别调用threadRunning1、threadRunning3的setDaemon()方法，设置其属性为true；
+ * -#step3: 分别调用threadRunning1、threadRunning2、threadRunning3的start()方法启动这三个线程；
+ * -#step4: 让当前线程休眠1000ms；
+ * -#step5: 将类变量threadRunning2.stopWork赋值为true；
+ * -#step6: 经判断可知，程序最终只打印了ThreadRunning2；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //Try to make a running thread daemon, test SetDaemonLiveThread
+
+        ThreadRunning1 threadRunning1 = new ThreadRunning1();
+        ThreadRunning2 threadRunning2 = new ThreadRunning2();
+        ThreadRunning1 threadRunning3 = new ThreadRunning1();
+        threadRunning1.setDaemon(true);
+        threadRunning3.setDaemon(true);
+        threadRunning1.start();
+        threadRunning2.start();
+        threadRunning3.start();
+        try {
+            Thread.sleep(1000);
+        } catch (Exception e) {
+        }
+        threadRunning2.stopWork = true;
+    }
+
+    static class ThreadRunning1 extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning1() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+            }
+            System.out.println("ThreadRunning1");
+        }
+    }
+
+    static class ThreadRunning2 extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning2() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+            System.out.println("ThreadRunning2");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full ThreadRunning2\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0131-rt-thread-ThreadTest14/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0131-rt-thread-ThreadTest14/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e5f0bec60d20dfe7250f5db5d02ef099360cc8d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0131-rt-thread-ThreadTest14/ThreadTest.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test join(long millis) and join(long millis, int nanos) with valid and invalid value. when value
+  *                     out of range, throws IllegalArgumentException.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadRunning类的实例对象threadRunning，并且ThreadRunning类继承自Thread类；
+ * -#step2: 调用threadRunning的start()方法启动该线程；
+ * -#step3: 尝试以-1为参数，调用threadRunning的join()方法；
+ * -#step4: step3中会抛出IllegalArgumentException，此时将类变量threadRunning.stopWork赋值为true；
+ * -#step5: 创建一个ThreadRunning类的实例对象threadRunning2，并且ThreadRunning类继承自Thread类；
+ * -#step6: 调用threadRunning2的start()方法启动该线程；
+ * -#step7: 以1000为参数，调用threadRunning2的join()方法；
+ * -#step8: 程序执行成功并打印相关信息，此时将类变量threadRunning2.stopWork赋值为true；
+ * -#step9: 创建一个ThreadRunning类的实例对象threadRunning3，并且ThreadRunning类继承自Thread类；
+ * -#step10: 调用threadRunning3的start()方法启动该线程；
+ * -#step11: 尝试以1000、1123456为参数，调用threadRunning3的join()方法；
+ * -#step12: step11中会抛出IllegalArgumentException，此时将类变量threadRunning3.stopWork赋值为true；
+ * -#step13: 创建一个ThreadRunning类的实例对象threadRunning4，并且ThreadRunning类继承自Thread类；
+ * -#step14: 调用threadRunning4的start()方法启动该线程；
+ * -#step15: 尝试以-2、123456为参数，调用threadRunning4的join()方法；
+ * -#step16: step15中会抛出IllegalArgumentException，此时将类变量threadRunning4.stopWork赋值为true；
+ * -#step17: 创建一个ThreadRunning类的实例对象threadRunning5，并且ThreadRunning类继承自Thread类；
+ * -#step18: 调用threadRunning5的start()方法启动该线程；
+ * -#step19: 以1000、123456为参数，调用threadRunning5的join()方法；
+ * -#step20: 程序执行成功并打印相关信息，此时将类变量threadRunning5.stopWork赋值为true；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //for  join(long millis)
+        ThreadRunning threadRunning = new ThreadRunning();
+        threadRunning.start();
+        try {
+            threadRunning.join(-1);
+            System.out.println("join(millis) OK");
+            threadRunning.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning.stopWork = true;
+            System.out.println("in join(millis), millis is negative");
+        }
+
+        ThreadRunning threadRunning2 = new ThreadRunning();
+        threadRunning2.start();
+        try {
+            threadRunning2.join(1000);
+            System.out.println("join(millis) OK");
+            threadRunning2.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning2.stopWork = true;
+            System.out.println("in join(millis), millis is negative");
+        }
+
+        //for join(long millis, int nanos)
+        ThreadRunning threadRunning3 = new ThreadRunning();
+        threadRunning3.start();
+        try {
+            threadRunning3.join(1000, 1123456);
+            System.out.println("join(millis, nanos) OK");
+            threadRunning3.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning3.stopWork = true;
+            System.out.println("in join(millis, nanos), nanosecond out of range");
+        }
+
+        ThreadRunning threadRunning4 = new ThreadRunning();
+        threadRunning4.start();
+        try {
+            threadRunning4.join(-2, 123456);
+            System.out.println("join(millis, nanos) OK");
+            threadRunning4.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning4.stopWork = true;
+            System.out.println("in join(millis, nanos), millis is negative");
+        }
+
+        ThreadRunning threadRunning5 = new ThreadRunning();
+        threadRunning5.start();
+        try {
+            threadRunning5.join(1000, 123456);
+            System.out.println("join(millis, nanos) OK");
+            threadRunning5.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning5.stopWork = true;
+            System.out.println("in join(millis, nanos), millis is negative or nanosecond out of range");
+        }
+        System.out.println("PASS");
+    }
+
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full in join(millis), millis is negative\njoin(millis) OK\nin join(millis, nanos), nanosecond out of range\nin join(millis, nanos), millis is negative\njoin(millis, nanos) OK\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0132-rt-thread-ThreadTest17/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0132-rt-thread-ThreadTest17/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7959ab9658f45c9d318c34fc7439b0e2d986e1ac
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0132-rt-thread-ThreadTest17/ThreadTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: use volatile to control when a thread should stop running.
+ *- @Brief: see below
+ * -#step1: 创建一个ThreadRunning类的实例对象threadRunning，且ThreadRunning类继承自Thread类；
+ * -#step2: 调用threadRunning的start()方法启动该线程；
+ * -#step3: 调用threadRunning的isAlive()方法得其返回值为true，得知线程threadRunning是活跃着的；
+ * -#step4: 将类变量threadRunning.stopWork赋值为true；
+ * -#step5: 调用threadRunning的join()方法；
+ * -#step6: 调用threadRunning的isAlive()方法得其返回值为false，得知线程threadRunning已经不活跃；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //Try to make a running thread daemon, test SetDaemonLiveThread
+
+        ThreadRunning threadRunning = new ThreadRunning();
+        threadRunning.start();
+        System.out.println(threadRunning.isAlive());
+        threadRunning.stopWork = true;
+        threadRunning.join();
+        System.out.println(threadRunning.isAlive());
+    }
+
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full true\nfalse\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0133-rt-thread-ThreadTest33/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0133-rt-thread-ThreadTest33/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..96785f6bb4b443daffac63cc6fbbfc423d1fd8a4
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0133-rt-thread-ThreadTest33/ThreadTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: test yield() in thread. finally all thread finished running.
+ *- @Brief: see below
+ * -#step1: 创建两个ThreadYielding类的实例对象threadYielding1、threadYielding2，并且ThreadYielding类继承自Thread类；
+ * -#step2: 分别调用threadYielding1、threadYielding2的start()方法启动这两个线程；
+ * -#step3: 分别调用threadYielding1、threadYielding2的join()方法；
+ * -#step4: 将类变量ThreadYielding.dim的值赋值给threadNum；
+ * -#step5: 经判断得知，threadYielding1.count、threadYielding2.count的值与（threadNum / 2）的值相等；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Test for void yield()
+         */
+        ThreadYielding threadYielding1 = new ThreadYielding();
+        ThreadYielding threadYielding2 = new ThreadYielding();
+        threadYielding1.start();
+        threadYielding2.start();
+        try {
+            threadYielding1.join();
+            threadYielding2.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE");
+        }
+        int threadNum = ThreadYielding.dim;
+
+        // We suppose that threads t1 and t2 alternate with each other.
+        // The might be a case when some another thread (not t2) runs
+        // while t1 is yelding. In this case the 'list' might start with 1s
+        // and end with 2s and look like threads does not alternate.
+        // We cannot treat this as failure nevertheless.
+        // We just make sure that both threads have finished successfully.
+        System.out.println("threads have finished successfully --- " +
+                (threadYielding1.count == threadNum / 2) + " --- " + (threadYielding2.count == threadNum / 2));
+        System.out.println("PASS");
+    }
+
+    private static class ThreadYielding extends Thread {
+        public static final int dim = 200;
+        public int count = 0;
+
+        public synchronized void incCount() {
+            count++;
+        }
+
+        public void run() {
+            for (int i = 0; i < dim / 2; i++) {
+                incCount();
+                Thread.yield();
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full threads have finished successfully --- true --- true\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0134-rt-thread-ThreadTest27/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0134-rt-thread-ThreadTest27/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..40cc5414b9e9128de0ae3dbc2c9ebdd0d48db01d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0134-rt-thread-ThreadTest27/ThreadTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test set/get DefaultUncaughtExceptionHandler() and set/get DefaultUncaughtExceptionHandler
+ *                      (null).
+ *- @Brief: see below
+ * -#step1: 创建一个ExceptionHandler类的实例对象exceptionHandler，并且ExceptionHandler类实现了
+ *          Thread.UncaughtExceptionHandler接口；
+ * -#step2: 以exceptionHandler为参数，调用Thread的setDefaultUncaughtExceptionHandler()方法；
+ * -#step3: 经判断得知，exceptionHandler与Thread.getDefaultUncaughtExceptionHandler()的返回值相同；
+ * -#step4: 以null为参数，调用Thread的setDefaultUncaughtExceptionHandler()方法；
+ * -#step5: 经判断得知，Thread.getDefaultUncaughtExceptionHandler()的返回值为null；
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Test set/get DefaultUncaughtExceptionHandler()
+         */
+        ExceptionHandler exceptionHandler = new ExceptionHandler();
+        Thread.setDefaultUncaughtExceptionHandler(exceptionHandler);
+        System.out.println("The default handler has been set, should print true -- " +
+                exceptionHandler.equals(Thread.getDefaultUncaughtExceptionHandler()));
+
+
+        /**
+         * Test set/get DefaultUncaughtExceptionHandler(null)
+         */
+        Thread.setDefaultUncaughtExceptionHandler(null);
+        System.out.println("Default handler should be null, and the test is -- " +
+                Thread.getDefaultUncaughtExceptionHandler());
+        System.out.println("PASS");
+    }
+
+    static class ExceptionHandler implements Thread.UncaughtExceptionHandler {
+        public boolean wasCalled = false;
+
+        public void uncaughtException(Thread t, Throwable e) {
+            wasCalled = true;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full The default handler has been set, should print true -- true\nDefault handler should be null, and the test is -- null\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0135-rt-thread-StartOOMTest/StartOOMTest.java b/test/testsuite/ouroboros/thread_test/RT0135-rt-thread-StartOOMTest/StartOOMTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5512d9289de42a4879ab5337433293c3224e7909
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0135-rt-thread-StartOOMTest/StartOOMTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: StartOOMTest
+ *- @TestCaseName: Thread_StartOOMTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: OutOfMemoryError is thrown when there are too many thread created.
+ *- @Brief: see below
+ * -#step1: 定义类SleepRunnable实现Runnable接口，定义run()方法，通过sleep()指定休眠时间。
+ * -#step2: 通过new得到类SleepRunnable的对象、线程组对象、线程列表对象以及一个为null的failedThread。
+ * -#step3: 在for()循环中，new得到100个设置了参数的Thread类对象，当跑到第100个是，throw OutOfMemoryError。
+ * -#step4: Thread类对象循环调用interrupt()。启动failedThread线程对象，调用interrupt()。Thread类对象循环调用join()，
+ *          failedThread对象赋值为最后一个新增的Thread类对象。
+ * -#step5: 对前100个线程调用interrupt()进行中断，当活跃线程数大于50时，调用Thread.yield()。
+ * -#step6: 等待所有线程运行结束，确认激活的线程组对象数量为0。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: StartOOMTest.java
+ *- @ExecuteClass: StartOOMTest
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class StartOOMTest {
+    public static void main(String[] args) throws Throwable {
+        Runnable r = new SleepRunnable();
+        ThreadGroup tg = new ThreadGroup("buggy");
+        List<Thread> threads = new ArrayList<Thread>();
+        Thread failedThread = null;
+        int i = 0;
+        for (i = 0; i < 101; i++) {
+            Thread t = new Thread(tg, r);
+            try {
+                if (i == 100) {
+                    throw new OutOfMemoryError("throw OutOfMemoryError");
+                }
+                t.start();
+                threads.add(t);
+            } catch (Throwable x) {
+                failedThread = t;
+                System.out.println(x);
+                System.out.println(i);
+                break;
+            }
+        }
+
+        int j = 0;
+        for (Thread t : threads) {
+            t.interrupt();
+        }
+
+        while (tg.activeCount() > i / 2) {
+            Thread.yield();
+        }
+        failedThread.start();
+        failedThread.interrupt();
+
+        for (Thread t : threads) {
+            t.join();
+        }
+        failedThread.join();
+
+        try {
+            Thread.sleep(1000);
+        } catch (Throwable ignore) {
+            System.out.println("Sleep is interrupted");
+        }
+
+        int activeCount = tg.activeCount();
+        System.out.println("activeCount = " + activeCount);
+
+        if (activeCount > 0) {
+            throw new RuntimeException("Failed: there  should be no active Threads in the group");
+        }
+    }
+
+    static class SleepRunnable implements Runnable {
+        public void run() {
+            try {
+                Thread.sleep(60 * 1000);
+            } catch (Throwable t) {
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full java.lang.OutOfMemoryError: throw OutOfMemoryError\n100\nactiveCount = 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0136-rt-thread-ThreadTest29/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0136-rt-thread-ThreadTest29/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..99931ecf3c3c4ce8ff5a61fffda6e52bc0d40f31
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0136-rt-thread-ThreadTest29/ThreadTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test for interrupt() -- Interrupt a joining thread.
+ *- @Brief: see below
+ * -#step1: 定义私有静态类ThreadJoining继承于Thread，创建ThreadJoining的构造方法。定义run()。
+ * -#step2: 通过new得到ThreadJoining的对象，启动线程对象，通过sleep()指定线程休眠时间。
+ * -#step3: 中断线程，等待3秒，确认抛出InterruptedException，调用isInterrupted()返回false。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+class ThreadTest {
+    public static void main(String[] args) {
+        ThreadJoining t = new ThreadJoining(10000, 0);
+        t.start();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        t.interrupt();
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        System.out.println("interrupt status has been cleared, if the output is false -- " + t.isInterrupted());
+    }
+
+    /* Test for interrupt() -- Interrupt a joining thread
+     * If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+     */
+    private static class ThreadJoining extends Thread {
+        private long millis;
+        private int nanos;
+
+        ThreadJoining(long millis, int nanos) {
+            this.millis = millis;
+            this.nanos = nanos;
+        }
+
+        public void run() {
+            try {
+                this.join(millis, nanos);
+                System.out.println("Fail -- joining thread has not received the InterruptedException");
+            } catch (InterruptedException e) {
+                System.out.println("joining thread has received the InterruptedException");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full joining thread has received the InterruptedException\ninterrupt status has been cleared, if the output is false -- false\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0137-rt-thread-ThreadTest12/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0137-rt-thread-ThreadTest12/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..17b8acf8890703c88a4def3677d9180a641e2bd5
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0137-rt-thread-ThreadTest12/ThreadTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test for setDaemon() and isDaemon(); child thread inherits from parent thread if it is daemon
+ *                      or not.
+ *- @Brief: see below
+ * -#step1: 定义私有静态类ThreadRunningAnotherThread，继承于类Thread。定义构造方法，调用super()。定义run(),定义了Thread
+ *          对象，currentThread对象，isDaemon对象。
+ * -#step2: 通过new得到ThreadRunningAnotherThread的对象，设置对象的守护进程状态为true。启动线程对象，暂停线程。等待线程结束，
+ *          调用childIsDaemon(),确认返回true。
+ * -#step3: 通过new得到ThreadRunningAnotherThread的对象，设置对象的守护进程状态为false。启动线程对象，暂停线程。等待线程结束，
+ *          调用childIsDaemon(),确认返回false。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Verify that a thread created by a daemon thread is daemon
+         */
+        ThreadRunningAnotherThread t = new ThreadRunningAnotherThread();
+        t.setDaemon(true);
+        t.start();
+        t.stop = true;
+        try {
+            t.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE --");
+        }
+        System.out.println("the child thread of a daemon thread is daemon --- " +
+                t.childIsDaemon);
+        /**
+         * Verify that a thread created by a non-daemon thread is not daemon
+         */
+        ThreadRunningAnotherThread tt = new ThreadRunningAnotherThread();
+        tt.setDaemon(false);
+        tt.start();
+        tt.stop = true;
+        try {
+            tt.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE --");
+        }
+        System.out.println("the child thread of a non-daemon thread is non-daemon --- " +
+                tt.childIsDaemon);
+    }
+
+    // Test for setDaemon() and isDaemon()
+    private static class ThreadRunningAnotherThread extends Thread {
+        int field = 0;
+        volatile boolean stop = false;
+        boolean childIsDaemon = false;
+        Thread curThread = null;
+
+        public ThreadRunningAnotherThread() {
+            super();
+        }
+
+        public void run() {
+            Thread child = new Thread();
+            curThread = Thread.currentThread();
+            childIsDaemon = child.isDaemon();
+            while (!stop) {
+                field++;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full the child thread of a daemon thread is daemon --- true\nthe child thread of a non-daemon thread is non-daemon --- false\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0138-rt-thread-ThreadTest32/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0138-rt-thread-ThreadTest32/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d8e8d5cf25602acfa6871af8ad26593f54271f0d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0138-rt-thread-ThreadTest32/ThreadTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Create a thread with Thread(ThreadGroup, Runnable, String, long), stack size is Long.MAX_VALUE.
+ *- @Brief: see below
+ * -#step1: 定义类Square实现Runnable接口，定义run()方法，通过sleep()指定线程休眠时间。
+ * -#step2: 创建Square对象。
+ * -#step3: 调用Thread(ThreadGroup, Runnable, String, long)创建Thread对象，启动线程对象。确认正常启动，run方法被调用，无异常
+ *          抛出。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    /**
+     * Thread(ThreadGroup, Runnable, String, long) stack size is Long.MAX_VALUE.
+     */
+    public static void main(String[] args) throws Exception {
+        // Does not work in maple, no exception occurs, run() is not executed.
+        boolean expired = false;
+        ThreadGroup tg = new ThreadGroup("newGroup");
+        String name = "t1";
+        Square s = new Square();
+        System.out.println(Long.MAX_VALUE);
+        try {
+            Thread t = new Thread(tg, s, name, Long.MAX_VALUE);
+            System.out.println("Creation_OK");
+            t.start();
+        } catch (OutOfMemoryError er) {
+            System.out.println("OutOfMemoryError");
+        }
+        System.out.println("PASS");
+    }
+
+    static class Square implements Runnable {
+        public void run() {
+            System.out.println("Enter_OK");
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException e) {
+                System.out.println("unexpected InterruptedException while sleeping");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 9223372036854775807\nCreation_OK\nOutOfMemoryError\nPASS\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0139-rt-thread-ThreadTest4/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0139-rt-thread-ThreadTest4/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a88fc3f1be3e98b32d352411885879ea34bb06e
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0139-rt-thread-ThreadTest4/ThreadTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test for static int enumerate(Thread[] tarray) .
+ *- @Brief: see below
+ * -#step1: 定义类ThreadRunning继承于Thread。定义构造方法，调用super()。定义run()。
+ * -#step2: 通过new得到类ThreadRunning的多个线程对象并启动，调用enumerate(Thread[] tarray)复制线程列表。
+ * -#step3: 遍历线程，暂停线程。返回线程总数为7。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    // Enumerate() does not work in maple.
+    public static void main(String[] args) throws Exception {
+        ThreadRunning t1 = new ThreadRunning();
+        t1.start();
+        ThreadRunning t2 = new ThreadRunning();
+        t2.start();
+        ThreadRunning t11 = new ThreadRunning();
+        t11.start();
+        ThreadRunning t12 = new ThreadRunning();
+        t12.start();
+        ThreadRunning t121 = new ThreadRunning();
+        t121.start();
+        ThreadRunning t122 = new ThreadRunning();
+        t122.start();
+        // Estimate dimension as 6 created threads.
+        // Plus 10 for some other threads.
+        int estimateLength = 16;
+        Thread[] list;
+        int count;
+        while (true) {
+            list = new Thread[estimateLength];
+            count = Thread.enumerate(list);
+            if (count == estimateLength) {
+                estimateLength *= 2;
+            } else {
+                //System.out.println(count);
+                break;
+            }
+        }
+        t1.stopWork = true;
+        t2.stopWork = true;
+        t11.stopWork = true;
+        t12.stopWork = true;
+        t121.stopWork = true;
+        t122.stopWork = true;
+        System.out.println("thread count : " + count);
+    }
+
+    // Test for enumerate()
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+
+        ThreadRunning() {
+            super();
+        }
+
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full thread count : 7\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0140-rt-thread-MainThreadTest/MainThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0140-rt-thread-MainThreadTest/MainThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c250eee9b15a59f76c9964a9de023655f823a06c
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0140-rt-thread-MainThreadTest/MainThreadTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MainThreadTest
+ *- @TestCaseName: Thread_MainThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test to see if the main thread is in its thread group.
+ *- @Brief: see below
+ * -#step1: 通过Thread.currentThread().getThreadGroup()获取当前线程组对象。
+ * -#step2: 调用activeCount()获取当前活跃的线程数目n。
+ * -#step3: 创建一个n大小的线程组ts，调用enumerate(Thread[] tarray)复制当前的线程组到ts。
+ * -#step4: 遍历线程组。main线程确认在遍历的线程组中。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: MainThreadTest.java
+ *- @ExecuteClass: MainThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class MainThreadTest {
+    public static void main(String[] args) {
+        ThreadGroup tg = Thread.currentThread().getThreadGroup();
+        int n = tg.activeCount();
+        Thread[] ts = new Thread[n];
+        int m = tg.enumerate(ts);
+        for (int i = 0; i < ts.length; i++) {
+            if (Thread.currentThread() == ts[i]) {
+                System.out.println(0);
+                return;
+            }
+        }
+        throw new RuntimeException("Current thread is not in its own thread group!");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0141-rt-thread-ThreadTest35/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0141-rt-thread-ThreadTest35/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fcf22c4fe3758100adc51f079643bf048edfa905
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0141-rt-thread-ThreadTest35/ThreadTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Verify the setName(null) method, and throw NullPointerException.
+ *- @Brief: see below
+ * -#step1: 通过new得到Thread的线程对象，通过setName()设置线程名称。输出线程设置的名称。
+ * -#step2: 通过new得到Thread的线程对象，通过setName()设置一个空的名称。抛出NullPointerException。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    // Test for setName()
+    public static void main(String[] args) throws Exception {
+        Thread thread = new Thread();
+        String newName = "maple_thread";
+        thread.setName(newName);
+        System.out.println("set the new name -- " + newName + " ---- " + thread.getName());
+
+        /**
+         * Verify the setName(null) method, and throw NullPointerException
+         */
+        Thread t = new Thread();
+        try {
+            t.setName(null);
+        } catch (NullPointerException e) {
+            System.out.println("setName() should not accept null names");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full set the new name -- maple_thread ---- maple_thread\nsetName() should not accept null names\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0142-rt-thread-ThreadTest5/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0142-rt-thread-ThreadTest5/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f9c5b65175ffef483a0124d2c887d8b6f482ae30
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0142-rt-thread-ThreadTest5/ThreadTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test set/get DefaultUncaughtExceptionHandler and set/get DefaultUncaughtExceptionHandler(null).
+ *- @Brief: see below
+ * -#step1: 定义类ExceptionHandler实现Thread.UncaughtExceptionHandler，定义带参的构造方法。
+ * -#step2: 通过new得到的类ExceptionHandler对象eh，通过setDefaultUncaughtExceptionHandler()设置类ExceptionHandler对象的处
+ *          理程序。通过getDefaultUncaughtExceptionHandler()确认设置成功。
+ * -#step3: 通过setDefaultUncaughtExceptionHandler()设置参数为null的处理程序。通过getDefaultUncaughtExceptionHandler()
+ *          得到Thread.UncaughtExceptionHandler的对象。确认该对象为为null。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        // Test set/get DefaultUncaughtExceptionHandler
+        ExceptionHandler eh = new ExceptionHandler();
+        Thread.setDefaultUncaughtExceptionHandler(eh);
+        Thread.UncaughtExceptionHandler ret1 = Thread.getDefaultUncaughtExceptionHandler();
+
+        //Test set/get DefaultUncaughtExceptionHandler(null)
+        Thread.setDefaultUncaughtExceptionHandler(null);
+        Thread.UncaughtExceptionHandler ret2 = Thread.getDefaultUncaughtExceptionHandler();
+        if (ret1 == eh && ret2 == null)
+            System.out.println(0);
+    }
+
+    static class ExceptionHandler implements Thread.UncaughtExceptionHandler {
+        public boolean wasCalled = false;
+
+        public void uncaughtException(Thread t, Throwable e) {
+            wasCalled = true;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0143-rt-thread-Daemon/Daemon.java b/test/testsuite/ouroboros/thread_test/RT0143-rt-thread-Daemon/Daemon.java
new file mode 100644
index 0000000000000000000000000000000000000000..bbb3a008d7df9bdb9bea500d42ddc2a69091d07a
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0143-rt-thread-Daemon/Daemon.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Daemon
+ *- @TestCaseName: Thread_Daemon.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test for premature destruction of daemon threadgroups
+ *- @Brief: see below
+ * -#step1: Create a thread group.
+ * -#step2: Assign the new thread to thread group
+ * -#step3: Create a new thread group,its parent thread group is tg.
+ * -#step4: Change this thread group(tg) to a last backgrounder Thread Group
+ * -#step5: Destroy the thread group by calling destroy()
+ * -#step6: Check that child thread group was stop correctly.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: Daemon.java
+ *- @ExecuteClass: Daemon
+ *- @ExecuteArgs:
+ */
+
+public class Daemon {
+    public static void main(String[] args) throws Exception {
+        ThreadGroup tg = new ThreadGroup("madbot-threads");
+        Thread myThread = new MadThread(tg, "mad");
+        ThreadGroup aGroup = new ThreadGroup(tg, "ness");
+        tg.setDaemon(true);
+        if (tg.activeCount() != 0)
+            throw new RuntimeException("activeCount");
+        aGroup.destroy();
+        if (tg.isDestroyed())
+            throw new RuntimeException("destroy");
+        try {
+            Thread anotherThread = new MadThread(aGroup, "bot");
+            throw new RuntimeException("illegal");
+        } catch (IllegalThreadStateException itse) {
+            // Correct result
+        }
+        System.out.println("Passed");
+    }
+}
+
+class MadThread extends Thread {
+    String name;
+
+    MadThread(ThreadGroup tg, String name) {
+        super(tg, name);
+        this.name = name;
+    }
+
+    public void run() {
+        System.out.println("me run " + name);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full Passed\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0144-rt-thread-ThreadTest10/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0144-rt-thread-ThreadTest10/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e17145823d5d6ed2e883fa582e54254e2bdbcbc
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0144-rt-thread-ThreadTest10/ThreadTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test sleep with out interrupt
+ *- @Brief: see below
+ * -#step1: Sleep current thread by calling Thread.sleep().
+ * -#step2: Check that current thread was slept.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        System.out.println("Test sleep(long millis) OK --");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full Test sleep(long millis) OK --\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0145-rt-thread-MemoryLeak/MemoryLeak.java b/test/testsuite/ouroboros/thread_test/RT0145-rt-thread-MemoryLeak/MemoryLeak.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a6347b020cbf205fd1cf2dcc51f10c115c39a32
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0145-rt-thread-MemoryLeak/MemoryLeak.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MemoryLeak
+ *- @TestCaseName: Thread_MemoryLeak.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test to see that memory leak no longer exists.
+ *- @Brief: see below
+ * -#step1: Create ThreadLocal instance.
+ * -#step2: Set the value of the thread local variable for the current thread
+ * -#step2: Check that memory leak no longer exists.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: MemoryLeak.java
+ *- @ExecuteClass: MemoryLeak
+ *- @ExecuteArgs:
+ */
+
+public class MemoryLeak {
+    public static void main(String[] args) {
+
+        for (int i = 0; i < 1000; i++) {
+            ThreadLocal t = new ThreadLocal();
+            t.set(new Object());
+            t.set(null);
+        }
+        System.out.println("Passed");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full Passed\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0146-rt-thread-ThreadId/ThreadId.java b/test/testsuite/ouroboros/thread_test/RT0146-rt-thread-ThreadId/ThreadId.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a7351f78d51eb6ca0ddf7c1201325cadb3e8f07
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0146-rt-thread-ThreadId/ThreadId.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadId
+ *- @TestCaseName: Thread_ThreadId.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Use ThreadLocal to generate unique id for thread
+ *- @Brief: see below
+ * -#step1: Define a test class that to generate unique id for thread.
+ * -#step2: Atomic integer containing the next thread ID to be assigned.
+ * -#step3: Override initialValue().
+ * -#step4: Check that the current thread's unique ID is correctly.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadId.java
+ *- @ExecuteClass: ThreadId
+ *- @ExecuteArgs:
+ */
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class ThreadId {
+    private static final AtomicInteger nextId = new AtomicInteger(0);
+
+    private static final ThreadLocal<Integer> threadId =
+            new ThreadLocal<Integer>() {
+                @Override
+                protected Integer initialValue() {
+                    return nextId.getAndIncrement();
+                }
+            };
+
+    public static int get() {
+        return threadId.get();
+    }
+
+    public static void main(String[] args) {
+        System.out.println(get());
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0147-rt-thread-ThreadTest1/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0147-rt-thread-ThreadTest1/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..69f0e9e04bd8e753db375be51e4037e7a70bd5f6
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0147-rt-thread-ThreadTest1/ThreadTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Interrupt a sleeping thread
+ *- @Brief: see below
+ * -#step1: Define a test class inherited from thread.
+ * -#step2: Create a thread instance.
+ * -#step3: Sleep the current thread.
+ * -#step4: Interrupt the sleeping thread.
+ * -#step5: Check that the sleeping thread was Interrupted.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+
+class MyThread extends Thread {
+    public void run() {
+        try {
+            while (!isInterrupted()) {
+                Thread.sleep(10000);
+            }
+        } catch (Exception e) {
+            System.out.println("isInterrupted");
+        }
+    }
+}
+
+public class ThreadTest {
+    public static void main(String[] args) {
+        Thread t1 = new MyThread();
+        t1.start();
+
+        try {
+            Thread.sleep(1000);
+            t1.interrupt();
+        } catch (Exception e) {
+            System.out.println("catch");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full isInterrupted\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0148-rt-thread-ThreadTest37/ThreadTest.java b/test/testsuite/ouroboros/thread_test/RT0148-rt-thread-ThreadTest37/ThreadTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4826c5e560d00f384a143a030d2afd12aa9948fe
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0148-rt-thread-ThreadTest37/ThreadTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadTest
+ *- @TestCaseName: Thread_ThreadTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test for void sleep(long millis) and sleep(long millis, int nanos) with both valid and
+ *                      invalid value
+ *- @Brief: see below
+ * case1:
+ * -#step1: Test void sleep(long millis) with legal or illegal param.
+ * -#step2: Check that IllegalArgumentException was threw when param is illegal.
+ * case2:
+ * -#step1: Test sleep(long millis, int nanos) with legal or illegal param.
+ * -#step2: Check that IllegalArgumentException was threw when param is illegal.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadTest.java
+ *- @ExecuteClass: ThreadTest
+ *- @ExecuteArgs:
+ */
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        long millis = 2000;
+
+        try {
+            Thread.sleep(millis);
+            System.out.println("sleep(long millis) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis) as: millis < 0");
+        }
+
+        try {
+            Thread.sleep(-2);
+            System.out.println("sleep(long millis) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis) as: millis < 0");
+        }
+
+        int nanos = 123456;
+
+        try {
+            Thread.sleep(millis, nanos);
+            System.out.println("sleep(long millis, int nanos) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis, int nanos) as: millis < 0 or nanos < 0 or nanos > 999999");
+        }
+
+        try {
+            Thread.sleep(millis, -1);
+            System.out.println("sleep(long millis, int nanos) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis, int nanos) as: nanos < 0");
+        }
+
+        try {
+            Thread.sleep(millis, 1123456);
+            System.out.println("sleep(long millis, int nanos) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis, int nanos) as: nanos > 999999");
+        }
+
+        try {
+            Thread.sleep(-3, nanos);
+            System.out.println("sleep(long millis, int nanos) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis, int nanos) as: millis < 0");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full sleep(long millis) OK\nIllegalArgumentException for sleep(long millis) as: millis < 0\nsleep(long millis, int nanos) OK\nIllegalArgumentException for sleep(long millis, int nanos) as: nanos < 0\nIllegalArgumentException for sleep(long millis, int nanos) as: nanos > 999999\nIllegalArgumentException for sleep(long millis, int nanos) as: millis < 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0149-rt-thread-ThreadConstructors13/ThreadConstructors13.java b/test/testsuite/ouroboros/thread_test/RT0149-rt-thread-ThreadConstructors13/ThreadConstructors13.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f494fdd07267bb6c5c52500ff3d21696894281b
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0149-rt-thread-ThreadConstructors13/ThreadConstructors13.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors13
+ *- @TestCaseName: Thread_ThreadConstructors13.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for Constructors Thread(String name)
+ *- @Brief: see below
+ * -#step1: Create thread instances.
+ * -#step2: Test Constructors Thread(String name) with null and "" params.
+ * -#step3: Check that Thread(String name) threw NullPointerException when param was null,and when param is "",it will
+ *          be  normal.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadConstructors13.java
+ *- @ExecuteClass: ThreadConstructors13
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors13 extends Thread {
+    static int i = 0;
+    private static int ecount = 0;
+
+    public ThreadConstructors13(String name) {
+        super(name);
+    }
+
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors13 test_illegal1 = new ThreadConstructors13(null);
+        } catch (NullPointerException e) {
+            ecount++;
+        }
+        ThreadConstructors13 test_illegal2 = new ThreadConstructors13("");
+        ThreadConstructors13 test_illegal3 = new ThreadConstructors13("");
+
+        test_illegal2.start();
+        try {
+            test_illegal2.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+
+        test_illegal3.start();
+        try {
+            test_illegal3.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+
+        if (i == 2) {
+            if (ecount == 1) {
+                System.out.println("0");
+                return;
+            }
+        }
+        System.out.println("2");
+        return;
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0150-rt-thread-ThreadConstructors14/ThreadConstructors14.java b/test/testsuite/ouroboros/thread_test/RT0150-rt-thread-ThreadConstructors14/ThreadConstructors14.java
new file mode 100644
index 0000000000000000000000000000000000000000..38f78bca546092ed03db25e7a379393c79ec25b1
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0150-rt-thread-ThreadConstructors14/ThreadConstructors14.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors14
+ *- @TestCaseName: Thread_ThreadConstructors14.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for Constructors Thread(ThreadGroup group, Runnable target)
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Start the thread.
+ * -#step3: Test Thread(ThreadGroup group, Runnable target) with null params.
+ * -#step4: Check that no wrong or exception when Thread(ThreadGroup group, Runnable target)'s params are null.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadConstructors14.java
+ *- @ExecuteClass: ThreadConstructors14
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors14 extends Thread {
+    static int i = 0;
+
+    public ThreadConstructors14(ThreadGroup group, Runnable target) {
+        super(group, target);
+    }
+
+    public static void main(String[] args) {
+
+        ThreadConstructors14 test_illegal1 = new ThreadConstructors14(null, null);
+
+        test_illegal1.start();
+        try {
+            test_illegal1.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+
+        if (i == 1) {
+            System.out.println("0");
+            return;
+        }
+        System.out.println("2");
+        return;
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0151-rt-thread-ThreadConstructors15/ThreadConstructors15.java b/test/testsuite/ouroboros/thread_test/RT0151-rt-thread-ThreadConstructors15/ThreadConstructors15.java
new file mode 100644
index 0000000000000000000000000000000000000000..639c10814469eece083a7c11a5c925c47002c525
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0151-rt-thread-ThreadConstructors15/ThreadConstructors15.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors15
+ *- @TestCaseName: Thread_ThreadConstructors15.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for Constructors Thread(ThreadGroup group, Runnable target, String name)
+ *- @Brief: see below
+ * -#step1: Create a thread instance.
+ * -#step2: Test Thread(ThreadGroup group, Runnable target, String name) with different params.
+ * -#step3: Check that NullPointerException was threw when the params are null.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadConstructors15.java
+ *- @ExecuteClass: ThreadConstructors15
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors15 extends Thread {
+    static int i = 0;
+    static int ecount = 0;
+
+    public ThreadConstructors15(ThreadGroup group, Runnable target, String name) {
+        super(group, target, name);
+    }
+
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors15 test_illegal1 = new ThreadConstructors15(null, null, null);
+        } catch (NullPointerException e) {
+            //System.out.println("NullPointerException");
+            ecount++;
+        }
+        ThreadConstructors15 test_illegal2 = new ThreadConstructors15(null, null, "");
+        ThreadConstructors15 test_illegal3 = new ThreadConstructors15(null, null, "");
+
+        test_illegal2.start();
+        try {
+            test_illegal2.join();
+        } catch (InterruptedException e) {
+            //System.out.println("NullPointerException");
+        }
+
+        test_illegal3.start();
+        try {
+            test_illegal3.join();
+        } catch (InterruptedException e) {
+            //System.out.println("NullPointerException");
+        }
+
+        if (i == 2) {
+            if (ecount == 1) {
+                System.out.println("0");
+                return;
+            }
+        }
+        System.out.println("2");
+        return;
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0152-rt-thread-ThreadConstructors16/ThreadConstructors16.java b/test/testsuite/ouroboros/thread_test/RT0152-rt-thread-ThreadConstructors16/ThreadConstructors16.java
new file mode 100644
index 0000000000000000000000000000000000000000..77aa9d6aaecf5746449b7e51ff04091f0f629286
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0152-rt-thread-ThreadConstructors16/ThreadConstructors16.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors16
+ *- @TestCaseName: Thread_ThreadConstructors16.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for Thread(ThreadGroup group, Runnable target, String name, long stackSize)
+ *- @Brief: see below
+ * -#step1: Create thread instance.
+ * -#step2: Test Thread(ThreadGroup group, Runnable target, String name, long stackSize) with different params.
+ * -#step3: Check that whatever stackSize is any value,there is no exception threw.
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadConstructors16.java
+ *- @ExecuteClass: ThreadConstructors16
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors16 extends Thread {
+    static int i = 0;
+    static int ecount = 0;
+
+    public ThreadConstructors16(ThreadGroup group, Runnable target, String name, long stackSize) {
+        super(group, target, name, stackSize);
+    }
+
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors16 test_illegal1 = new ThreadConstructors16(null, null, null, 0);
+        } catch (NullPointerException e) {
+            //System.out.println("NullPointerException");
+            ecount++;
+        }
+
+        try {
+            ThreadConstructors16 test_illegal2 = new ThreadConstructors16(null, null, "", Long.MAX_VALUE);
+        } catch (OutOfMemoryError ee) {
+            System.out.println("OutOfMemoryError");
+            ecount += 2;
+        }
+
+        ThreadConstructors16[] test_illegal = new ThreadConstructors16[3];
+
+        test_illegal[0] = new ThreadConstructors16(null, null, "", 100); //Long.MIN_VALUE);
+        test_illegal[1] = new ThreadConstructors16(null, null, "", new Integer("-1"));
+        test_illegal[2] = new ThreadConstructors16(null, null, "", new Short("00356"));
+
+        for (ThreadConstructors16 thread : test_illegal) {
+            thread.start();
+            try {
+                thread.join();
+            } catch (InterruptedException e) {
+               // System.out.println("InterruptedException");
+            }
+        }
+
+        if (i == 3) {
+            if (ecount == 1) {
+                System.out.println("0");
+                return;
+            }
+        }
+        System.out.println("2");
+        return;
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0153-rt-thread-ThreadConstructors17/ThreadConstructors17.java b/test/testsuite/ouroboros/thread_test/RT0153-rt-thread-ThreadConstructors17/ThreadConstructors17.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f16ef09ca2ab9aaccc7ac8943be830fe58da904
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0153-rt-thread-ThreadConstructors17/ThreadConstructors17.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors17
+ *- @TestCaseName: Thread_ThreadConstructors17.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for Constructors Thread(ThreadGroup group, String name)
+ *- @Brief: see below
+ * -#step1: Create thread instance.
+ * -#step2: Test Constructors Thread(ThreadGroup group, String name) with different params.
+ * -#step3: Check that NullPointerException was threw when name param was null;
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: ThreadConstructors17.java
+ *- @ExecuteClass: ThreadConstructors17
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors17 extends Thread {
+    static int i = 0;
+    static int ecount = 0;
+
+    public ThreadConstructors17(ThreadGroup group, String name) {
+        super(group, name);
+    }
+
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors17 test_illegal1 = new ThreadConstructors17(null, null);
+        } catch (NullPointerException e) {
+            //System.out.println("NullPointerException");
+            ecount++;
+        }
+
+        ThreadConstructors17 test_illegal2 = new ThreadConstructors17(null, "");
+        ThreadConstructors17 test_illegal3 = new ThreadConstructors17(null, new String());
+
+        test_illegal2.start();
+        try {
+            test_illegal2.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+
+        test_illegal3.start();
+        try {
+            test_illegal3.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+
+        if (i == 2) {
+            if (ecount == 1) {
+                System.out.println("0");
+                return;
+            }
+        }
+        System.out.println("2");
+        return;
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/ThreadCountStackFramesTest.java b/test/testsuite/ouroboros/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/ThreadCountStackFramesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f8bb5a463b0509561f7bafe3a1ed1ca5bd8205e
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/ThreadCountStackFramesTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadCountStackFramesTest
+ *- @TestCaseName: Thread_ThreadCountStackFramesTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Check if countStackFrames throws IllegalThreadStateException when thread not suspended.
+ *- @Brief: see below
+ * -#step1: 创建Thread对象实例。
+ * -#step2：调用start()启动对象实例。
+ * -#step3：调用countStackFrames()确认无异常抛出。
+ * -#step4：调用getStackTrace()，获取返回的长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadCountStackFramesTest.java
+ *- @ExecuteClass: ThreadCountStackFramesTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadCountStackFramesTest extends Thread {
+    static int cnt = 0;
+    static Object ob = "aa";
+
+    public static void main(String[] args) {
+        ThreadCountStackFramesTest thCountStackFramesTest = new ThreadCountStackFramesTest();
+        thCountStackFramesTest.start();
+
+        try {
+            cnt = thCountStackFramesTest.countStackFrames();
+        } catch (IllegalThreadStateException e) {
+            System.out.println(2);
+            return;
+        }
+
+        int j = thCountStackFramesTest.getStackTrace().length;
+        if (j == cnt) {
+            System.out.println(0);
+            return;
+        }
+
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (ob) {
+            try {
+                ob.wait(1000);
+            } catch (InterruptedException e) {
+                System.out.println("Wait is interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0155-rt-thread-ThreadEHdestroy/ThreadDestroyUnsupportedOperationExceptionTest.java b/test/testsuite/ouroboros/thread_test/RT0155-rt-thread-ThreadEHdestroy/ThreadDestroyUnsupportedOperationExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..56bad545c6bb1c2b75c4d3cfaef3cbc3964857a3
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0155-rt-thread-ThreadEHdestroy/ThreadDestroyUnsupportedOperationExceptionTest.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadDestroyUnsupportedOperationExceptionTest
+ *- @TestCaseName: Thread_ThreadDestroyUnsupportedOperationExceptionTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Check if destroy() throws UnsupportedOperationException.
+ *- @Brief: see below
+ * -#step1: 创建Thread对象实例。
+ * -#step2：调用start()启动对象实例。
+ * -#step3: 调用destroy()方法。
+ * -#step4：确认抛出UnsupportedOperationException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadDestroyUnsupportedOperationExceptionTest.java
+ *- @ExecuteClass: ThreadDestroyUnsupportedOperationExceptionTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadDestroyUnsupportedOperationExceptionTest extends Thread {
+    public static void main(String[] args) {
+        ThreadDestroyUnsupportedOperationExceptionTest thread = new ThreadDestroyUnsupportedOperationExceptionTest();
+        thread.start();
+
+        try {
+            thread.destroy();
+        } catch (UnsupportedOperationException e) {
+            System.out.println(0);
+            return;
+        } catch (Throwable ee) {
+            System.out.println(1);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0156-rt-thread-Threadenumerate2/Threadenumerate2.java b/test/testsuite/ouroboros/thread_test/RT0156-rt-thread-Threadenumerate2/Threadenumerate2.java
new file mode 100644
index 0000000000000000000000000000000000000000..041ad89f3dd448cd350ea9952f3f1dbbf9ce9aec
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0156-rt-thread-Threadenumerate2/Threadenumerate2.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: Threadenumerate2
+ *- @TestCaseName: Thread_Threadenumerate2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for static int enumerate(Thread[] tarray).
+ *- @Brief: see below
+ * -#step1: 创建Thread对象实例。
+ * -#step2：调用start()启动对象实例。
+ * -#step3: 构造参数tarray为null,调用enumerate(Thread[] tarray)。
+ * -#step4：确认NullPointerException抛出。
+ * -#step5: 构造参数tarray为new Thread[0],调用enumerate(Thread[] tarray)。
+ * -#step6：确认返回为0。
+ *- @Expect: expected.txt
+ *- @Priority: High
+ *- @Source: Threadenumerate2.java
+ *- @ExecuteClass: Threadenumerate2
+ *- @ExecuteArgs:
+ */
+
+public class Threadenumerate2 extends Thread {
+    static int num = 0;
+    static int eCount = 0;
+
+    public static void main(String[] args) {
+        Threadenumerate2 te = new Threadenumerate2();
+        te.start();
+
+        try {
+            enumerate(null);
+        } catch (NullPointerException e) {
+            eCount++;
+        }
+
+        num = enumerate(new Thread[0]);
+        if (num == 0 && eCount == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0158-rt-thread-ThreadgetStackTrace/ThreadgetStackTrace.java b/test/testsuite/ouroboros/thread_test/RT0158-rt-thread-ThreadgetStackTrace/ThreadgetStackTrace.java
new file mode 100644
index 0000000000000000000000000000000000000000..52f4c6caefd86d4f8299ad418b04c57dae1da546
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0158-rt-thread-ThreadgetStackTrace/ThreadgetStackTrace.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetStackTraceTest
+ *- @TestCaseName: Thread_ThreadgetStackTrace.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test getStackTrace().
+ *- @Brief: see below
+ * -#step1: 调用Thread.currentThread()获取Thread 实例。
+ * -#step2：调用getStackTrace()获取对应的StackTraceElement数组。
+ * -#step3：确认获取的StackTraceElement数组成员内容正确。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadgetStackTrace.java
+ *- @ExecuteClass: ThreadgetStackTrace
+ *- @ExecuteArgs:
+ */
+
+
+import java.io.PrintStream;
+
+public class ThreadgetStackTrace extends Thread {
+
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    public static int run(String[] args, PrintStream out) {
+        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+
+        int l = stackTraceElements.length;
+        if (stackTraceElements[l - 1].toString().contains("main") && stackTraceElements[l - 2].toString().contains("run") && stackTraceElements[l - 3].toString().contains("getStackTrace")) {
+            return 0;
+        }
+
+        return 2;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/ThreadGroupAllowThreadSuspensionTest.java b/test/testsuite/ouroboros/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/ThreadGroupAllowThreadSuspensionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..943d0d763849f402b8565067a1601c10b1cb55fe
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/ThreadGroupAllowThreadSuspensionTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupAllowThreadSuspensionTest
+ *- @TestCaseName: Thread_ThreadGroupAllowThreadSuspensionTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test ThreadGroup.allowSuspension(), it changes the value of vmAllowSuspension.
+ *- @Brief: see below
+ * -#step1: 通过new ThreadGroup(String name)构造新的实例。
+ * -#step2：调用allowThreadSuspension(boolean b)，参数b为true。
+ * -#step3：通过反射getDeclaredField获取私有域vmAllowSuspension判断值不为true。
+ * -#step4：调用allowThreadSuspension(boolean b)，参数b为false。
+ * -#step5：通过反射getDeclaredField获取私有域vmAllowSuspension判断值不为false。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadGroupAllowThreadSuspensionTest.java
+ *- @ExecuteClass: ThreadGroupAllowThreadSuspensionTest
+ *- @ExecuteArgs:
+ */
+
+import java.lang.reflect.Field;
+
+public class ThreadGroupAllowThreadSuspensionTest {
+    public static void main(String[] args) {
+        ThreadGroup tg = new ThreadGroup("group");
+        tg.allowThreadSuspension(true);
+        try {
+            if (getValue(tg, "vmAllowSuspension").toString() != "true") {
+                System.out.println(2);
+                return;
+            }
+        } catch (Throwable e) {
+            System.out.println(2);
+            return;
+        }
+
+        tg.allowThreadSuspension(false);
+        try {
+            if (getValue(tg, "vmAllowSuspension").toString() != "false") {
+                System.out.println(2);
+                return;
+            }
+        } catch (Throwable e) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+
+    // Use reflect to get the value of private field of ThreadGroup
+    public static Object getValue(Object instance, String fieldName) throws IllegalAccessException, NoSuchFieldException {
+        Field field = getField(instance.getClass(), fieldName);
+        field.setAccessible(true);
+        return field.get(instance);
+    }
+
+    public static Field getField(Class thisClass, String fieldName) throws NoSuchFieldException {
+        if (fieldName == null) {
+            throw new NoSuchFieldException("Error field !");
+        }
+        Field field = thisClass.getDeclaredField(fieldName);
+        return field;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/ThreadGroupEHdestroy.java b/test/testsuite/ouroboros/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/ThreadGroupEHdestroy.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e4620e0eacd4603d0c672ef093b37d8d51654a9
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/ThreadGroupEHdestroy.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGroupEHdestroy
+ *- @TestCaseName: Thread_ThreadGroupEHdestroy.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Check if destroy throws IllegalThreadStateException.
+ *- @Brief: see below
+ * -#step1: 通过new ThreadGroup(String name)构造新的实例tg。
+ * -#step2: 通过Thread(ThreadGroup group, String name)分配新的thread对象。
+ * -#step3：调用start()启动线程。
+ * -#step4：对ThreadGroup对象tg调用destroy()，预计会抛出IllegalThreadStateException。
+ * -#step5：调用join()等待线程运行结束。
+ * -#step6：对ThreadGroup对象tg调用destroy()，预计会抛出IllegalThreadStateException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadGroupEHdestroy.java
+ *- @ExecuteClass: ThreadGroupEHdestroy
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGroupEHdestroy {
+    static int cnt = 0;
+
+    public static void main(String[] args) {
+        ThreadGroup tg = new ThreadGroup("hi");
+        Thread t = new Thread(tg, "hello");
+        t.start();
+        // Destroy a thread group which is not empty, throws IllegalThreadStateException
+        try {
+            tg.destroy();
+        } catch (IllegalThreadStateException e) {
+            cnt++;
+        }
+        try {
+            t.join();
+        } catch (InterruptedException ee) {
+            System.out.println("Join is interrupted");
+        }
+
+        tg.destroy();
+        // Destroy a thread group which is already destroyed, throws IllegalThreadStateException
+        try {
+            tg.destroy();
+        } catch (IllegalThreadStateException e) {
+            cnt += 2;
+        }
+
+        if (cnt == 3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0161-rt-thread-ThreadholdsLock4/ThreadholdsLock4.java b/test/testsuite/ouroboros/thread_test/RT0161-rt-thread-ThreadholdsLock4/ThreadholdsLock4.java
new file mode 100644
index 0000000000000000000000000000000000000000..fba27449cb0b80cb47402a5ed81851e23668b375
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0161-rt-thread-ThreadholdsLock4/ThreadholdsLock4.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadholdsLock4
+ *- @TestCaseName: Thread_ThreadholdsLock4.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for boolean holdsLock(Object obj).
+ *- @Brief: see below
+ * -#step1: 构造Thread实例。
+ * -#step2：调用holdsLock(Object obj), 参数obj为null。
+ * -#step3：确认抛出NullPointerException。
+ * -#step4: 重复两次调用holdsLock(Object obj), 参数obj为"", 预期每次结果都返回false。
+ * -#step5: 调用holdsLock(Object obj), 参数obj为new Object(), 预期结果返回false。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadholdsLock4.java
+ *- @ExecuteClass: ThreadholdsLock4
+ *- @ExecuteArgs:
+ */
+
+public class ThreadholdsLock4 extends Thread {
+    static int eCount = 0;
+    static int sCount = 0;
+
+    public static void main(String[] args) {
+        ThreadholdsLock4 tl = new ThreadholdsLock4();
+        try {
+            holdsLock(null);
+        } catch (NullPointerException e) {
+            eCount++;
+        }
+
+        if (!holdsLock("")) {
+            if (!holdsLock("")) {
+                if (!holdsLock(new Object())) {
+                    sCount++;
+                }
+            }
+        }
+
+        if (sCount == 1 && eCount == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/ThreadLocalEHwithInitial.java b/test/testsuite/ouroboros/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/ThreadLocalEHwithInitial.java
new file mode 100644
index 0000000000000000000000000000000000000000..3cc50bbfe6bd936d30f9951ff8ba5d1cc628bbd8
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/ThreadLocalEHwithInitial.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadLocalEHwithInitial
+ *- @TestCaseName: Thread_ThreadLocalEHwithInitial.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Check if ThreadLocal.withInitial(Supplier<? extends S> supplier) throws NullPointerException.
+ *- @Brief: see below
+ * -#step1: 创建参数supplier为null。
+ * -#step2：调用withInitial(Supplier<? extends S> supplier)。
+ * -#step3：确认会抛出NullPointerException异常。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadLocalEHwithInitial.java
+ *- @ExecuteClass: ThreadLocalEHwithInitial
+ *- @ExecuteArgs:
+ */
+
+public class ThreadLocalEHwithInitial {
+    public static void main(String[] args) {
+        try {
+            ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(null);
+        } catch (NullPointerException e) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/ThreadsetContextClassLoader1.java b/test/testsuite/ouroboros/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/ThreadsetContextClassLoader1.java
new file mode 100644
index 0000000000000000000000000000000000000000..ede5777517587b8836afb8f520c29a978bcb25ed
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/ThreadsetContextClassLoader1.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadsetContextClassLoader1
+ *- @TestCaseName: Thread_ThreadsetContextClassLoader1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for setContextClassLoader(ClassLoader cl).
+ *- @Brief: see below
+ * -#step1: 创建Thread实例。
+ * -#step2：调用setContextClassLoader(ClassLoader cl)，参数cl为null。
+ * -#step3：调用start()启动线程，等待线程结束。
+ * -#step4：确认线程的run函数被正常调用。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadsetContextClassLoader1.java
+ *- @ExecuteClass: ThreadsetContextClassLoader1
+ *- @ExecuteArgs:
+ */
+
+public class ThreadsetContextClassLoader1 extends Thread {
+    static int i = 0;
+
+    public static void main(String[] args) {
+        ThreadsetContextClassLoader1 t = new ThreadsetContextClassLoader1();
+        t.setContextClassLoader(null);
+
+        t.start();
+        try {
+            t.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+
+        if (i == 1 && t.getContextClassLoader() == null) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/ThreadSetDefaultUncaughtExceptionHandlerTest.java b/test/testsuite/ouroboros/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/ThreadSetDefaultUncaughtExceptionHandlerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d05c516a2057aa6b96276bc87f3f1491d5e3f56
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/ThreadSetDefaultUncaughtExceptionHandlerTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetDefaultUncaughtExceptionHandlerTest
+ *- @TestCaseName: Thread_ThreadSetDefaultUncaughtExceptionHandlerTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test negative input for setDefaultUncaughtExceptionHandler().
+ *- @Brief: see below
+ * -#step1: 创建Thread对象实例。
+ * -#step2：构造参数eh为实例的getUncaughtExceptionHandler()，调用
+ *          setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)。
+ * -#step3：调用getDefaultUncaughtExceptionHandler()确认返回不为null。
+ * -#step4：构造参数eh为实例的null，调用setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)。
+ * -#step3：调用getDefaultUncaughtExceptionHandler()确认返回为null。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadSetDefaultUncaughtExceptionHandlerTest.java
+ *- @ExecuteClass: ThreadSetDefaultUncaughtExceptionHandlerTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetDefaultUncaughtExceptionHandlerTest extends Thread {
+    public static void main(String[] args) {
+        ThreadSetDefaultUncaughtExceptionHandlerTest setEH = new ThreadSetDefaultUncaughtExceptionHandlerTest();
+        Thread.setDefaultUncaughtExceptionHandler(setEH.getUncaughtExceptionHandler());
+        if (getDefaultUncaughtExceptionHandler() == null) {
+            System.out.println(1);
+            return;
+        }
+
+        Thread.setDefaultUncaughtExceptionHandler(null);
+        if (getDefaultUncaughtExceptionHandler() == null) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/ThreadSetUncaughtExceptionHandlerTest.java b/test/testsuite/ouroboros/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/ThreadSetUncaughtExceptionHandlerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..62422e32402ddf73a9877172b9159f8fd0fbfcbf
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/ThreadSetUncaughtExceptionHandlerTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetUncaughtExceptionHandlerTest
+ *- @TestCaseName: Thread_ThreadSetUncaughtExceptionHandlerTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination:test negative input for setUncaughtExceptionHandler()
+ *- @Brief: see below
+ * -#step1: 创建Thread对象实例。
+ * -#step2: 实例调用getUncaughtExceptionHandler()确认返回不为null。
+ * -#step3：构造参数eh为实例的null，调用setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)。
+ * -#step4: 启动线程，实例调用getUncaughtExceptionHandler()确认返回不为null。
+ * -#step5：等待线程结束，实例调用getUncaughtExceptionHandler()确认返回不为null，run函数被成功调用。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadSetUncaughtExceptionHandlerTest.java
+ *- @ExecuteClass: ThreadSetUncaughtExceptionHandlerTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetUncaughtExceptionHandlerTest extends Thread {
+    static int i = 0;
+
+    public static void main(String[] args) {
+        ThreadSetUncaughtExceptionHandlerTest setEH = new ThreadSetUncaughtExceptionHandlerTest();
+        if (setEH.getUncaughtExceptionHandler() == null) {
+            System.out.println(1);
+            return;
+        }
+        setEH.setUncaughtExceptionHandler(null);
+        setEH.start();
+        if (setEH.getUncaughtExceptionHandler() == null) {
+            System.out.println(2);
+            return;
+        }
+        try {
+            setEH.join();
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+
+        if (i == 1 && setEH.getUncaughtExceptionHandler() != null) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(3);
+    }
+
+    public void run() {
+        i++;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0166-rt-thread-ThreadStatejoin16/ThreadStatejoin16.java b/test/testsuite/ouroboros/thread_test/RT0166-rt-thread-ThreadStatejoin16/ThreadStatejoin16.java
new file mode 100644
index 0000000000000000000000000000000000000000..c990f6a05a70b41dce5942e5372ebb533e5131a5
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0166-rt-thread-ThreadStatejoin16/ThreadStatejoin16.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStatejoin16
+ *- @TestCaseName: Thread_ThreadStatejoin16.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for join(long millis)
+ *- @Brief: see below
+ * -#step1: 调用Thread()来构造对象实例。
+ * -#step2：调用start()启动线程。
+ * -#step3：构造参数millis为负数，调用join(long millis)等待线程结束，确认抛出IllegalArgumentException异常。
+ * -#step4：构造参数millis为0，调用join(long millis)等待线程结束，确认线程能正常运行。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStatejoin16.java
+ *- @ExecuteClass: ThreadStatejoin16
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStatejoin16 extends Thread {
+    static int i = 0;
+    static int eCount = 0;
+
+    public static void main(String[] args) {
+        ThreadStatejoin16 tj = new ThreadStatejoin16();
+        tj.start();
+
+        try {
+            tj.join(-2);
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        } catch (IllegalArgumentException ee) {
+            eCount++;
+        }
+
+        try {
+            tj.join(0);
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        } catch (IllegalArgumentException ee) {
+            eCount = eCount + 2;
+        }
+
+        if (i == 1 && eCount == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0167-rt-thread-ThreadStatejoin17/ThreadStatejoin17.java b/test/testsuite/ouroboros/thread_test/RT0167-rt-thread-ThreadStatejoin17/ThreadStatejoin17.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd03bf9168af57f5e4601898624683fae8babeb9
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0167-rt-thread-ThreadStatejoin17/ThreadStatejoin17.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStatejoin17
+ *- @TestCaseName: Thread_ThreadStatejoin17.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for join(long millis, int nanos).
+ *- @Brief: see below
+ * -#step1: 调用Thread()来构造对象实例。
+ * -#step2：调用start()启动线程。
+ * -#step3：构造参数millis为负数，nanos为正整数，调用join(long millis, int nanos)等待线程结束，确认抛出
+ *          IllegalArgumentException异常。
+ * -#step4：构造参数millis为正整数，nanos为负数，调用join(long millis, int nanos)等待线程结束，确认抛出
+ *          IllegalArgumentException异常。
+ * -#step5：构造参数millis为0，nanos为0，调用join(long millis, int nanos)等待线程结束，确认线程能正常运行。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStatejoin17.java
+ *- @ExecuteClass: ThreadStatejoin17
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStatejoin17 extends Thread {
+    static int i = 0;
+    static int eCount = 0;
+
+    public static void main(String[] args) {
+        ThreadStatejoin17 tj = new ThreadStatejoin17();
+        tj.start();
+
+        long[] invalidMillis = new long[]{-2l, 2l};
+        int[] invalidNanos = new int[]{2, -2};
+
+        for (int j = 0; j < invalidMillis.length; j++) {
+            try {
+                tj.join(invalidMillis[j], invalidNanos[j]);
+            } catch (InterruptedException e) {
+                System.out.println(e);
+            } catch (IllegalArgumentException ee) {
+                eCount++;
+            }
+        }
+
+        try {
+            tj.join(0, 0);
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        } catch (IllegalArgumentException ee) {
+            eCount = eCount + 10;
+        }
+
+        if (i == 1 && eCount == invalidMillis.length) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0168-rt-thread-ThreadStatesleep7/ThreadStatesleep7.java b/test/testsuite/ouroboros/thread_test/RT0168-rt-thread-ThreadStatesleep7/ThreadStatesleep7.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c7b9addca5cb37ec2acd751fe1c949b5a2d3f29
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0168-rt-thread-ThreadStatesleep7/ThreadStatesleep7.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStatesleep7
+ *- @TestCaseName: Thread_ThreadStatesleep7.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Sleep 0 millisecond time or 0 nanos, no exception threw.
+ *- @Brief: see below
+ * -#step1: 调用Thread()来构造对象实例。
+ * -#step2：调用start()启动线程。
+ * -#step3：构造参数millis为0，调用sleep(long millis)，确认线程能正常运行,无异常抛出。
+ * -#step4：构造参数millis为0，nanos为0，调用sleep(long millis, int nanos)，确认确认线程能正常运行,无异常抛出。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStatesleep7.java
+ *- @ExecuteClass: ThreadStatesleep7
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStatesleep7 extends Thread {
+    public static void main(String[] args) {
+        ThreadStatesleep7 cls = new ThreadStatesleep7();
+        cls.start();
+        try {
+            sleep(0);
+            sleep(0, 0);
+        } catch (InterruptedException e) {
+            System.out.println("sleep is interrupted");
+        } catch (IllegalArgumentException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0169-rt-thread-ThreadStatewait9/ThreadStatewait9.java b/test/testsuite/ouroboros/thread_test/RT0169-rt-thread-ThreadStatewait9/ThreadStatewait9.java
new file mode 100644
index 0000000000000000000000000000000000000000..511e53137d7a78a8c53683facd415e8413eebf04
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0169-rt-thread-ThreadStatewait9/ThreadStatewait9.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStatewait9
+ *- @TestCaseName: Thread_ThreadStatewait9.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Invalid input for Object.wait(long timeout).
+ *- @Brief: see below
+ * -#step1: 调用Thread()来构造对象实例。
+ * -#step2：调用start()启动线程。
+ * -#step3: 构造参数timeout为负数，调用wait(long timeout)，确认会抛出IllegalArgumentException异常。
+ * -#step4：等待线程结束。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStatewait9.java
+ *- @ExecuteClass: ThreadStatewait9
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStatewait9 extends Thread {
+    static Object ob = "aa";
+    static int i = 0;
+
+    public static void main(String[] args) {
+        ThreadStatewait9 threadWait = new ThreadStatewait9();
+        threadWait.start();
+        try {
+            threadWait.join();
+        } catch (InterruptedException ee) {
+            System.out.println(2);
+            return;
+        }
+
+        if (i == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (ob) {
+            try {
+                ob.wait(-1000);
+            } catch (IllegalArgumentException ee) {
+                i++;
+            } catch (InterruptedException e) {
+                System.out.println("Wait is interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0170-rt-thread-ThreadStatewait10/ThreadStatewait10.java b/test/testsuite/ouroboros/thread_test/RT0170-rt-thread-ThreadStatewait10/ThreadStatewait10.java
new file mode 100644
index 0000000000000000000000000000000000000000..dbdf584b22af0e3c05f97f2ccf89b766691f31ba
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0170-rt-thread-ThreadStatewait10/ThreadStatewait10.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStatewait10
+ *- @TestCaseName: Thread_ThreadStatewait10.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Invalid input for Object.wait(long timeout, int nanos).
+ *- @Brief: see below
+ * -#step1: 调用Thread()来构造对象实例。
+ * -#step2：调用start()启动线程。
+ * -#step3: 构造参数timeout为正整数，参数nanos为负数，调用wait(long timeout, int nanos)，确认会抛出
+ *          IllegalArgumentException.
+ * -#step4：等待线程结束。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStatewait10.java
+ *- @ExecuteClass: ThreadStatewait10
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStatewait10 extends Thread {
+    static Object ob = "aa";
+    static int i = 0;
+
+    public static void main(String[] args) {
+        ThreadStatewait10 threadWait = new ThreadStatewait10();
+        threadWait.start();
+        try {
+            threadWait.join();
+        } catch (InterruptedException ee) {
+            System.out.println(2);
+            return;
+        }
+
+        if (i == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        synchronized (ob) {
+            try {
+                ob.wait(100, -1000);
+            } catch (IllegalArgumentException ee) {
+                i++;
+            } catch (InterruptedException e) {
+                System.out.println("Wait is interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0171-rt-thread-ThreadStatewait11/ThreadStatewait11.java b/test/testsuite/ouroboros/thread_test/RT0171-rt-thread-ThreadStatewait11/ThreadStatewait11.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5f3da2e795c9331b8f37a0cab809b214dafa211
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0171-rt-thread-ThreadStatewait11/ThreadStatewait11.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStatewait11
+ *- @TestCaseName: Thread_ThreadStatewait11.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Invalid input for Object.wait(long timeout).
+ *- @Brief: see below
+ * -#step1: 调用ThreadStatewait11()来构造对象实例。
+ * -#step2：调用start()启动线程。
+ * -#step3: 构造参数timeout为0，调用wait(long timeout)，确认会抛出IllegalMonitorStateException.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStatewait11.java
+ *- @ExecuteClass: ThreadStatewait11
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStatewait11 extends Thread {
+    public static void main(String[] args) {
+        ThreadStatewait11 threadWait = new ThreadStatewait11();
+        threadWait.start();
+        try {
+            threadWait.wait(0);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+            return;
+        } catch (IllegalMonitorStateException e1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0172-rt-thread-ThreadStatewait12/ThreadStatewait12.java b/test/testsuite/ouroboros/thread_test/RT0172-rt-thread-ThreadStatewait12/ThreadStatewait12.java
new file mode 100644
index 0000000000000000000000000000000000000000..1797d892f99879b32bf556b9acdf386627f71702
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0172-rt-thread-ThreadStatewait12/ThreadStatewait12.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStatewait12
+ *- @TestCaseName: Thread_ThreadStatewait12.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Invalid input for Object.wait(long timeout, int nanos).
+ *- @Brief: see below
+ * -#step1: 调用ThreadStatewait12()来构造对象实例。
+ * -#step2：调用start()启动线程。
+ * -#step3: 构造参数timeout为0，nanos为0，调用wait(long timeout, int nanos)，确认会抛出IllegalMonitorStateException.
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStatewait12.java
+ *- @ExecuteClass: ThreadStatewait12
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStatewait12 extends Thread {
+    public static void main(String[] args) {
+        ThreadStatewait12 threadWait = new ThreadStatewait12();
+        threadWait.start();
+        try {
+            threadWait.wait(0, 0);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+            return;
+        } catch (IllegalMonitorStateException e1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0173-rt-thread-ThreadConstructors11/ThreadConstructors11.java b/test/testsuite/ouroboros/thread_test/RT0173-rt-thread-ThreadConstructors11/ThreadConstructors11.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef56a57aeb59288a095b6813099dd0c6cccb68f1
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0173-rt-thread-ThreadConstructors11/ThreadConstructors11.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors11
+ *- @TestCaseName: Thread_ThreadConstructors11.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for Constructors Thread(Runnable target).
+ *- @Brief: see below
+ * -#step1: 构造参数target为null，调用Thread(Runnable target)来构造对象实例。
+ * -#step2：调用start()启动线程。
+ * -#step3：等待线程结束，确认线程能正常运行。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors11.java
+ *- @ExecuteClass: ThreadConstructors11
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors11 extends Thread {
+    static int i = 0;
+
+    public ThreadConstructors11(Runnable target) {
+        super(target);
+    }
+
+    public static void main(String[] args) {
+        ThreadConstructors11 test_illegal1 = new ThreadConstructors11(null);
+
+        test_illegal1.start();
+        try {
+            test_illegal1.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+
+        if (i == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0174-rt-thread-ThreadConstructors12/ThreadConstructors12.java b/test/testsuite/ouroboros/thread_test/RT0174-rt-thread-ThreadConstructors12/ThreadConstructors12.java
new file mode 100644
index 0000000000000000000000000000000000000000..fcda3de1a4fc736028b6c62dc238d783c2b9c1c6
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0174-rt-thread-ThreadConstructors12/ThreadConstructors12.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadConstructors12
+ *- @TestCaseName: Thread_ThreadConstructors12.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for Constructors Thread(Runnable target, String name).
+ *- @Brief: see below
+ * -#step1: 构造参数target为null，name为null,调用Thread(Runnable target, String name)来构造对象实例。
+ * -#step2: 确认会抛出NullPointerException异常。
+ * -#step3：构造参数target为null，name为"",调用Thread(Runnable target, String name)来构造对象实例test_illegal2。
+ * -#step4: 构造参数target为null，name为new String(),调用Thread(Runnable target, String name)来构造对象实例
+ *          test_illegal3.
+ * -#step2：调用start()启动线程test_illegal2,test_illegal3。
+ * -#step3：等待线程结束，确认两个线程都能正常运行。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadConstructors12.java
+ *- @ExecuteClass: ThreadConstructors12
+ *- @ExecuteArgs:
+ */
+
+public class ThreadConstructors12 extends Thread {
+    static int i = 0;
+    static int eCount = 0;
+
+    public ThreadConstructors12(Runnable target, String name) {
+        super(target, name);
+    }
+
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors12 test_illegal1 = new ThreadConstructors12(null, null);
+        } catch (NullPointerException e) {
+            eCount++;
+        }
+
+        ThreadConstructors12 test_illegal2 = new ThreadConstructors12(null, "");
+        ThreadConstructors12 test_illegal3 = new ThreadConstructors12(null, new String());
+
+        test_illegal2.start();
+        try {
+            test_illegal2.join();
+        } catch (InterruptedException e) {
+            System.out.println("test_illegal2 join is interrupted");
+        }
+
+        test_illegal3.start();
+        try {
+            test_illegal3.join();
+        } catch (InterruptedException e) {
+            System.out.println("test_illegal3 join is interrupted");
+        }
+
+        if (i == 2 && eCount == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0175-rt-thread-MonitorTestCase1/MonitorTestCase1.java b/test/testsuite/ouroboros/thread_test/RT0175-rt-thread-MonitorTestCase1/MonitorTestCase1.java
new file mode 100644
index 0000000000000000000000000000000000000000..c465b75546410370846c8633dac3eae121023487
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0175-rt-thread-MonitorTestCase1/MonitorTestCase1.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MonitorTestCase1.java
+ *- @TestCaseName: Thread_MonitorTestCase1.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Added according to stress cases SyscompTestCase/Maple_harness/tools/testapp_MemStressTest/src
+ *                      /com/huawei/stress.
+ *- @Brief: see below
+ * -#step1: 创建一个static的类StopAbleThread继承Thread，类的构造方法使用了父函数的构造方法。
+ * -#step2: 分配INIT_DEFAULT_THREAD_NUM / 2个对象来自于new StopAbleThread类，同时启动监控线程。
+ * -#step3: 调用start()启动所有的对象线程。
+ * -#step4: 调用join()等待线程运行结束。
+ * -#step5: 调用Runtime.getRuntime().gc()回收资源。
+ * -#step6: 重复步骤1~4。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: MonitorTestCase1.java
+ *- @ExecuteClass: MonitorTestCase1
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class MonitorTestCase1 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_SLEEP_TIME_DEFAULT = 1;
+    private static final String MODULE_NAME_MONITOR = "M";
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static List<Thread> mAllThread = new ArrayList<>();
+
+    public static void main(String[] args) {
+        testCase1();
+        Runtime.getRuntime().gc();
+        testCase1();
+        System.out.println(0);
+    }
+
+    public static void testCase1() {
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread thread;
+        Object lockObject = new Object();
+        for (int i = 0; i < DEFAULT_THREAD_NUM_HALF; i++) {
+            thread = new StopAbleThread(new MonitorTest(lockObject, THREAD_SLEEP_TIME_DEFAULT, THREAD_REPEATS_DEFAULT),
+                    MODULE_NAME_MONITOR + "_testCase1_" + i);
+            list.add(thread);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    static class MonitorTest implements Runnable {
+        Object lockObject;
+        int sleepTime;
+        int repeats;
+
+        public MonitorTest(Object lockObject, int sleepTime, int repeatTimes) {
+            this.lockObject = lockObject;
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+        }
+
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                synchronized (lockObject) {
+                    lockObject.toString();
+                    tryRest();
+                    trySleep(sleepTime);
+                    if (!mRunning) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0176-rt-thread-MonitorTestCase2/MonitorTestCase2.java b/test/testsuite/ouroboros/thread_test/RT0176-rt-thread-MonitorTestCase2/MonitorTestCase2.java
new file mode 100644
index 0000000000000000000000000000000000000000..4fac32dc0b05106d6406d4f434db7e22c0f3f308
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0176-rt-thread-MonitorTestCase2/MonitorTestCase2.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MonitorTestCase2.java
+ *- @TestCaseName: Thread_MonitorTestCase2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Added according to stress cases SyscompTestCase/Maple_harness/tools/testapp_MemStressTest/src
+ *                      /com/huawei/stress.
+ *- @Brief: see below
+ * -#step1: 创建一个static的类StopAbleThread继承Thread，类的构造方法使用了父函数的构造方法。
+ * -#step2: 分配INIT_DEFAULT_THREAD_NUM / 2个对象来自于new StopAbleThread类，同时启动监控线程,监控进程解锁后等待sleepTime时间。
+ * -#step3: 调用start()启动所有的对象线程。
+ * -#step4: 调用join()等待线程运行结束。
+ * -#step5: 调用Runtime.getRuntime().gc()回收资源。
+ * -#step6: 重复步骤1~4。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: MonitorTestCase2.java
+ *- @ExecuteClass: MonitorTestCase2
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class MonitorTestCase2 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_SLEEP_TIME_DEFAULT = 1;
+    private static final String MODULE_NAME_MONITOR = "M";
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static List<Thread> mAllThread = new ArrayList<>();
+
+    public static void main(String[] args) {
+        testCase2();
+        Runtime.getRuntime().gc();
+        testCase2();
+        System.out.println("0");
+    }
+
+    public static void testCase2() {
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread t;
+        Object lockObject = new Object();
+        for (int i = 0; i < DEFAULT_THREAD_NUM_HALF; i++) {
+            t = new StopAbleThread(new MonitorTestWait(lockObject, THREAD_SLEEP_TIME_DEFAULT, THREAD_REPEATS_DEFAULT),
+                    MODULE_NAME_MONITOR + "_testCase2_" + i);
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    static class MonitorTest implements Runnable {
+        Object lockObject;
+        int sleepTime;
+        int repeats;
+
+        public MonitorTest(Object lockObject, int sleepTime) {
+            this(lockObject, sleepTime, THREAD_REPEATS_INFINITE);
+        }
+
+        public MonitorTest(Object lockObject, int sleepTime, int repeatTimes) {
+            this.lockObject = lockObject;
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+        }
+
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                synchronized (lockObject) {
+                    lockObject.toString();
+                    tryRest();
+                    trySleep(sleepTime);
+                    if (!mRunning) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    static class MonitorTestWait extends MonitorTest {
+        public MonitorTestWait(Object lockObject, int sleepTime, int repeatTimes) {
+            super(lockObject, sleepTime, repeatTimes);
+        }
+
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                if (!mRunning) {
+                    break;
+                }
+                synchronized (lockObject) {
+                    lockObject.toString();
+                    tryRest();
+                    try {
+                        lockObject.wait(sleepTime);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0177-rt-thread-MonitorTestCase4/MonitorTestCase4.java b/test/testsuite/ouroboros/thread_test/RT0177-rt-thread-MonitorTestCase4/MonitorTestCase4.java
new file mode 100644
index 0000000000000000000000000000000000000000..521a7adff4648579c7dc9021a439e214dc1cb1df
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0177-rt-thread-MonitorTestCase4/MonitorTestCase4.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MonitorTestCase4.java
+ *- @TestCaseName: Thread_MonitorTestCase4.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Added according to stress cases SyscompTestCase/Maple_harness/tools/testapp_MemStressTest/src
+ *                      /com/huawei/stress.
+ *- @Brief: see below
+ * -#step1: 创建一个static的类StopAbleThread继承Thread，类的构造方法使用了父函数的构造方法。
+ * -#step2: 分配INIT_DEFAULT_THREAD_NUM / 2个对象来自于new StopAbleThread类，同时启动mTestVolatileRun线程。
+ * -#step3: 调用start()启动所有的对象线程。
+ * -#step4: 调用join()等待线程运行结束。
+ * -#step5: 调用Runtime.getRuntime().gc()回收资源。
+ * -#step6: 重复步骤1~4。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: MonitorTestCase4.java
+ *- @ExecuteClass: MonitorTestCase4
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class MonitorTestCase4 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_SLEEP_TIME_DEFAULT = 1;
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+
+    private static final String MODULE_NAME_MONITOR = "M";
+    static List<Thread> mAllThread = new ArrayList<>();
+
+    public static void main(String[] args) {
+        testCase4();
+        Runtime.getRuntime().gc();
+        testCase4();
+        System.out.println("0");
+    }
+
+    public static void testCase4() {
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread t1;
+        for (int i = 0; i < DEFAULT_THREAD_NUM_HALF; i++) {
+            t1 = new StopAbleThread(new CommonRun(mTestVolatileRun, THREAD_SLEEP_TIME_DEFAULT, THREAD_REPEATS_DEFAULT),
+                    MODULE_NAME_MONITOR + "_testCase4_" + i);
+            list.add(t1);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static Runnable mTestVolatileRun = new Runnable() {
+        @Override
+        public void run() {
+            for (int i = 0; i < 100; i++) {
+                tryRest();
+                Object testa = GetTestVolatile();
+                // Visit meta
+                if (testa instanceof Object) {
+                    continue;
+                }
+            }
+        }
+    };
+
+    public static volatile Object testVolatile = null;
+
+    private static Object GetTestVolatileImpl() {
+        if (testVolatile == null) {
+            testVolatile = new testVolatileClass();
+        }
+        return testVolatile;
+    }
+
+    static class testVolatileClass {
+        int a;
+    }
+
+    private static Object GetTestVolatile() {
+        return GetTestVolatileImpl();
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    static class CommonRun implements Runnable {
+        int sleepTime;
+        int repeats;
+        Runnable cbFun;
+
+        public CommonRun(Runnable cb, int sleepTime, int repeatTimes) {
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+            cbFun = cb;
+        }
+
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                tryRest();
+                if (cbFun != null) {
+                    cbFun.run();
+                }
+                trySleep(sleepTime);
+                if (!mRunning) {
+                    break;
+                }
+            }
+        }
+    }
+
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0178-rt-thread-MonitorTestCase5/MonitorTestCase5.java b/test/testsuite/ouroboros/thread_test/RT0178-rt-thread-MonitorTestCase5/MonitorTestCase5.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3a3fa3a35329fed2e7e3b818242b971ab627e8d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0178-rt-thread-MonitorTestCase5/MonitorTestCase5.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MonitorTestCase5.java
+ *- @TestCaseName: Thread_MonitorTestCase5.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Added according to stress cases SyscompTestCase/Maple_harness/tools/testapp_MemStressTest/src
+ *                      /com/huawei/stress.
+ *- @Brief: see below
+ * -#step1: 创建一个static的类StopAbleThread继承Thread，类的构造方法使用了父函数的构造方法。
+ * -#step2: 分配INIT_DEFAULT_THREAD_NUM / 2个对象来自于new StopAbleThread类，同时启动mTestVolatileRun线程。
+ * -#step3: 调用start()启动所有的对象线程。
+ * -#step4: 调用join()等待线程运行结束。
+ * -#step5: 调用Runtime.getRuntime().gc()回收资源。
+ * -#step6: 重复步骤1~4。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: MonitorTestCase5.java
+ *- @ExecuteClass: MonitorTestCase5
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class MonitorTestCase5 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_SLEEP_TIME_DEFAULT = 1;
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static final String MODULE_NAME_MONITOR = "M";
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static List<Thread> mAllThread = new ArrayList<>();
+
+    public static void main(String[] args) {
+        testCase5();
+        Runtime.getRuntime().gc();
+        testCase5();
+        System.out.println("0");
+    }
+
+    public static void testCase5() {
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread t1;
+        for (int i = 0; i < DEFAULT_THREAD_NUM_HALF; i++) {
+            t1 = new StopAbleThread(new CommonRun(mTestVolatileRun, THREAD_SLEEP_TIME_DEFAULT, THREAD_REPEATS_DEFAULT),
+                    MODULE_NAME_MONITOR + "_testCase5_" + i);
+            list.add(t1);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static Runnable mTestVolatileRun = new Runnable() {
+        @Override
+        public void run() {
+            for (int i = 0; i < 100; i++) {
+                tryRest();
+                Object testa = GetTestVolatile();
+
+                if (testa instanceof Object) {
+                    continue;
+                }
+            }
+        }
+    };
+
+    public static volatile Object testVolatile = null;
+
+    private static Object GetTestVolatileImpl() {
+        if (testVolatile == null) {
+            testVolatile = new testVolatileClass();
+        }
+        return testVolatile;
+    }
+
+    static class testVolatileClass {
+        // test class
+    }
+
+    private static Object GetTestVolatile() {
+        return GetTestVolatileImpl();
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    static class CommonRun implements Runnable {
+        int sleepTime;
+        int repeats;
+        Runnable cbFun;
+
+        public CommonRun(Runnable cb, int sleepTime, int repeatTimes) {
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+            cbFun = cb;
+        }
+
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                tryRest();
+                if (cbFun != null) {
+                    cbFun.run();
+                }
+                trySleep(sleepTime);
+                if (!mRunning) {
+                    break;
+                }
+            }
+        }
+    }
+
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0179-rt-thread-MonitorTestCase6/MonitorTestCase6.java b/test/testsuite/ouroboros/thread_test/RT0179-rt-thread-MonitorTestCase6/MonitorTestCase6.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3c9ccfd69a699263491f5cb6116db899a8f1f80
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0179-rt-thread-MonitorTestCase6/MonitorTestCase6.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MonitorTestCase6.java
+ *- @TestCaseName: Thread_MonitorTestCase6.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Added according to stress cases SyscompTestCase/Maple_harness/tools/testapp_MemStressTest/src
+ *                      /com/huawei/stress.
+ *- @Brief: see below
+ * -#step1: 创建一个static的类StopAbleThread继承Thread，类的构造方法使用了父函数的构造方法。
+ * -#step2: 分配INIT_DEFAULT_THREAD_NUM个对象来自于new StopAbleThread类，同时启动SyncThread监控线程,该线程带同步锁。
+ * -#step3: 调用Runtime.getRuntime().gc()回收资源。
+ * -#step4: 重复步骤1~2。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: MonitorTestCase6.java
+ *- @ExecuteClass: MonitorTestCase6
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+import java.util.Random;
+
+public class MonitorTestCase6 {
+    private static boolean quit = false;
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM = INIT_DEFAULT_THREAD_NUM;
+    private static final String MODULE_NAME_MONITOR = "M";
+    private static int monitorLengthForCase6 = DEFAULT_THREAD_NUM / 5;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+
+    public static void main(String[] args) {
+        testCase6();
+        Runtime.getRuntime().gc();
+        testCase6();
+        System.out.println("0");
+    }
+
+    public static void testCase6() {
+        quit = false;
+        ArrayList<monitorTestUnit> mList = createTestObject();
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread t;
+
+        for (int i = 0; i < (DEFAULT_THREAD_NUM / 10); i++) {
+            t = new StopAbleThread(new SyncThread(mList), MODULE_NAME_MONITOR + "_testCase6_A" + i);
+            list.add(t);
+        }
+    }
+
+    public static class SyncThread implements Runnable {
+        private Random intRandom;
+        private ArrayList<monitorTestUnit> mList;
+
+        public SyncThread(ArrayList<monitorTestUnit> list) {
+            this.intRandom = new Random();
+            this.mList = list;
+        }
+
+        @Override
+        public void run() {
+            monitorTestUnit monitor;
+            int start;
+            int sleepTime;
+            for (int j = 0; j < 2000; j++) {
+                start = this.intRandom.nextInt(monitorLengthForCase6);
+                for (int k = 0; k < monitorLengthForCase6; k++) {
+                    monitor = mList.get((k + start) % monitorLengthForCase6);
+                    synchronized (monitor) {
+                        tryRest();
+                        monitor.testCount++;
+                        sleepTime = this.intRandom.nextInt(4) + 1;
+                        trySleep(sleepTime * 3);
+                    }
+                }
+
+                if (quit) {
+                    break;
+                }
+            }
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    public static ArrayList<monitorTestUnit> createTestObject() {
+        ArrayList<monitorTestUnit> mList = new ArrayList<>();
+        for (int i = 0; i < monitorLengthForCase6; i++) {
+            mList.add(new monitorTestUnit());
+        }
+        return mList;
+    }
+
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+
+    static class monitorTestUnit {
+        int testCount;
+        boolean isWait;
+
+        monitorTestUnit() {
+            testCount = 0;
+            isWait = false;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0180-rt-thread-MonitorTestCase8/MonitorTestCase8.java b/test/testsuite/ouroboros/thread_test/RT0180-rt-thread-MonitorTestCase8/MonitorTestCase8.java
new file mode 100644
index 0000000000000000000000000000000000000000..f67046abd064aa19867f54927284cd9a0f4d0cd2
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0180-rt-thread-MonitorTestCase8/MonitorTestCase8.java
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: MonitorTestCase8.java
+ *- @TestCaseName: Thread_MonitorTestCase8.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Added according to stress cases SyscompTestCase/Maple_harness/tools/testapp_MemStressTest/src
+ *                      /com/huawei/stress.
+ *- @Brief: see below
+ * -#step1: 创建一个static的类StopAbleThread继承Thread，类的构造方法使用了父函数的构造方法。
+ * -#step2: 分配DEFAULT_THREAD_NUM_HALF / 2个对象来自于new StopAbleThread类，同时在new的参数1里定义new CommonRun监控线程。
+ * -#step3: 调用start()启动所有的对象线程。
+ * -#step4: 调用join()等待线程运行结束。
+ * -#step5: 调用Runtime.getRuntime().gc()回收资源。
+ * -#step6: 重复步骤1~4。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: MonitorTestCase8.java
+ *- @ExecuteClass: MonitorTestCase8
+ *- @ExecuteArgs:
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class MonitorTestCase8 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 10;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 500;
+    static List<Thread> mAllThread = new ArrayList<>();
+
+    public static void main(String[] args) {
+        testCase8();
+        Runtime.getRuntime().gc();
+        testCase8();
+        System.out.println("0");
+    }
+
+    public static void testCase8() {
+        List<Thread> list = new ArrayList<>();
+        List<String> stringList = new ArrayList<>();
+        for (int i = 0; i < (DEFAULT_THREAD_NUM_HALF / 2); i++) {
+            int index = i;
+            stringList.add("");
+            list.add(new StopAbleThread(new CommonRun(() -> {
+                ArrayList<String> strings = new ArrayList<>(100);
+                for (int j = 0; j < 100; j++) {
+                    strings.add(StringMethod.getStringRandom());
+                }
+                for (String str : strings) {
+                    stringList.set(index, stringList.get(index) + str);
+                }
+            }, 100, THREAD_REPEATS_DEFAULT), "testCase8_" + (i + 1)));
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+
+    static class CommonRun implements Runnable {
+        int sleepTime;
+        int repeats;
+        Runnable cbFun;
+
+        public CommonRun(Runnable cb, int sleepTime, int repeatTimes) {
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+            cbFun = cb;
+        }
+
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                tryRest();
+                if (cbFun != null) {
+                    cbFun.run();
+                }
+                trySleep(sleepTime);
+                if (!mRunning) {
+                    break;
+                }
+            }
+        }
+    }
+
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+
+    private enum StringMethod {
+        METHOD0("DirectString") {
+            @Override
+            public String apply() {
+                return "DirectString";
+            }
+        },
+        METHOD1("ReferenceString") {
+            @Override
+            public String apply() {
+                return this.name;
+            }
+        },
+        METHOD2("FinalString") {
+            @Override
+            public String apply() {
+                return FINAL_STRING;
+            }
+        },
+        METHOD3("ConcatString") {
+            @Override
+            public String apply() {
+                return "Concat".concat("String");
+            }
+        },
+        METHOD4("StringAddition") {
+            @Override
+            public String apply() {
+                return "String" + "Addition" + 1;
+            }
+        },
+        METHOD5("CopyValueOf") {
+            @Override
+            public String apply() {
+                char[] tmp = {'C', 'o', 'p', 'y', 'V', 'a', 'l', 'u', 'e', 'O', 'f'};
+                return String.copyValueOf(tmp);
+            }
+        },
+        METHOD6("Intern") {
+            @Override
+            public String apply() {
+                return mRandom.toString().intern();
+            }
+        },
+        METHOD7("Integer") {
+            @Override
+            public String apply() {
+                return Integer.toString(mRandom.nextInt());
+            }
+        },
+        METHOD8("Float") {
+            @Override
+            public String apply() {
+                return Float.toString(mRandom.nextFloat());
+            }
+        },
+        METHOD9("Double") {
+            @Override
+            public String apply() {
+                return Double.toString(mRandom.nextDouble());
+            }
+        },
+        METHOD10("Boolean") {
+            @Override
+            public String apply() {
+                return Boolean.toString(mRandom.nextBoolean());
+            }
+        },
+        METHOD11("ReplaceChar") {
+            @Override
+            public String apply() {
+                return mRandom.toString().replace('R', 'r');
+            }
+        },
+        METHOD12("ReplaceString") {
+            @Override
+            public String apply() {
+                return mRandom.toString().replace("Ran", "RED");
+            }
+        },
+        METHOD13("Split") {
+            @Override
+            public String apply() {
+                return mRandom.toString().split("@")[0];
+            }
+        },
+        METHOD14("SubString") {
+            @Override
+            public String apply() {
+                return mRandom.toString().substring(3, 5);
+            }
+        },
+        METHOD15("ToLowerCase") {
+            @Override
+            public String apply() {
+                return mRandom.toString().toLowerCase();
+            }
+        },
+        METHOD16("ToUpperCase") {
+            @Override
+            public String apply() {
+                return mRandom.toString().toUpperCase();
+            }
+        },
+        METHOD17("StringBuffer") {
+            @Override
+            public String apply() {
+                return new StringBuffer("String").append("Buffer").append(1).toString();
+            }
+        },
+        METHOD18("StringBuilder") {
+            @Override
+            public String apply() {
+                return new StringBuilder(20).append(mRandom).toString();
+            }
+        },
+        METHOD19("subSequence") {
+            @Override
+            public String apply() {
+                return mRandom.toString().subSequence(1, 3).toString();
+            }
+        };
+
+        public final String name;
+        private static final String FINAL_STRING = "FinalString";
+        private static final Random mRandom = new Random();
+
+        StringMethod(String name) {
+            this.name = name;
+        }
+
+        public String apply() {
+            return name;
+        }
+
+        public static String getString(int id) {
+            if ((id < 0) || (id >= StringMethod.values().length)) {
+                return "";
+            } else {
+                return StringMethod.values()[id].apply();
+            }
+        }
+
+        public static String getStringRandom() {
+            return getString(mRandom.nextInt(StringMethod.values().length));
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0181-rt-thread-ThreadCountStackFrames/ThreadCountStackFrames.java b/test/testsuite/ouroboros/thread_test/RT0181-rt-thread-ThreadCountStackFrames/ThreadCountStackFrames.java
new file mode 100644
index 0000000000000000000000000000000000000000..f56a82fb95e6e3b9f99fc02d2377c7bf8fda34f4
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0181-rt-thread-ThreadCountStackFrames/ThreadCountStackFrames.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadCountStackFrames
+ *- @TestCaseName: Thread_ThreadCountStackFrames.java
+ *- @RequirementName: Java Thread
+ *- @Brief: see below
+ * -#step1: 创建一个线程。
+ * -#step2：在线程启动前检查，调用countStackFrames()确认返回0，调用getStackTrace()确认返回的长度为0。
+ * -#step3：启动线程，等待线程结束。
+ * -#step4：确认线程已经结束，调用countStackFrames()确认返回0，调用getStackTrace()确认返回的长度为0。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadCountStackFrames.java
+ *- @ExecuteClass: ThreadCountStackFrames
+ *- @ExecuteArgs:
+ */
+
+public class ThreadCountStackFrames {
+    static int threadFinish = 0;
+
+    public static void main(String[] args) {
+        int result = 2;
+        Thread thread = new Thread("ThreadCountStackFrames") {
+            public void run() {
+                try {
+                    sleep(1000);
+                } catch (Exception e) {
+                    System.out.println(e);
+                }
+                ThreadCountStackFrames.threadFinish++;
+            }
+        };
+        // Before the thread started.
+        if (thread.countStackFrames() == 0 && thread.getStackTrace().length == 0) {
+            result--;
+        }
+
+        thread.start();
+        try {
+            thread.join();
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        // After a thread finished.
+        if (thread.countStackFrames() == 0 && thread.getStackTrace().length == 0
+                && ThreadCountStackFrames.threadFinish == 1) {
+            result--;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/test/testsuite/ouroboros/thread_test/RT0182-rt-thread-ThreadDMdestory2/ThreadDMdestory2.java b/test/testsuite/ouroboros/thread_test/RT0182-rt-thread-ThreadDMdestory2/ThreadDMdestory2.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ceb0becb21ef9fb30218c16d87ddb7422ae7162
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0182-rt-thread-ThreadDMdestory2/ThreadDMdestory2.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadDMDestroy2
+ *- @TestCaseName: Thread_ThreadDMdestory2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread api: destroy(), added from JCK test case ${MAPLE_ROOT}/clinic/jck/JCK-runtime-8b/tests/
+ *                      api/java_lang/Thread/index.html#destroy destroy001, destroy002, destroy003.
+ *- @Brief: see below
+ * -#step1: 直接调用new Thread().destroy()，确认会抛出UnsupportedOperationException。
+ * -#step2：创建一个线程thread，调用start()启动，调用join()等待线程结束，调用destroy()，确认会抛出
+ *          UnsupportedOperationException。
+ * -#step3：创建一个线程st，调用start()启动，线程会执行sleep操作，调用destroy()，确认会抛出UnsupportedOperationException。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadDMdestory2.java
+ *- @ExecuteClass: ThreadDMdestory2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadDMdestory2 {
+
+    public static void main(String[] args) {
+        System.out.println(run());
+    }
+
+    private static int run() {
+        int exceptionCount = 0;
+
+        // destroy001: test destroy() when the thread is not started
+        try {
+            new Thread().destroy();
+            return 1;
+        } catch (UnsupportedOperationException ok) {
+            exceptionCount++;
+        }
+
+        // destroy002: test destroy() when the thread is finished
+        Thread thread = new Thread();
+        thread.start();
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        }
+
+        try {
+            thread.destroy();
+            return 2;
+        } catch (UnsupportedOperationException ok) {
+            exceptionCount++;
+        }
+
+        // destroy003: test destroy() when a thread is sleeping
+        SleepingThread st = new SleepingThread();
+        st.start();
+
+        while (! st.started) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                // ignore any attempt to interrupt
+                System.out.println(e);
+            }
+        }
+
+        try {
+            st.destroy();
+            return 3;
+        } catch (UnsupportedOperationException ok) {
+            exceptionCount++;
+        }
+        st.checked=true;
+
+        if (exceptionCount == 3) {
+            return 0;
+        }else{
+            return 4;
+        }
+    }
+}
+
+class SleepingThread extends Thread {
+    public volatile boolean started = false;
+    public volatile boolean checked = false;
+
+    public void run() {
+        started = true;
+        while (! checked) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                // ignore any attempt to interrupt
+                System.out.println(e);
+            }
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/ThreadGetContextClassLoader.java b/test/testsuite/ouroboros/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/ThreadGetContextClassLoader.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fda31abb186121c002a342fa3d6faab2b91b06d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/ThreadGetContextClassLoader.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadGetContextClassLoader.java
+ *- @TestCaseName: Thread_ThreadGetContextClassLoader.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Thread api: getContextClassLoader(), added from JCK test case ${MAPLE_ROOT}/clinic/jck/
+ *                      JCK-runtime-8b/tests/api/java_lang/Thread/index.html#getContextClassLoader(), Thread4404.
+ *- @Brief: see below
+ * -#step1: 创建线程，调用getContextClassLoader()确认为父线程的ClassLoader上下文。
+ * -#step2：启动线程，等待线程结束。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadGetContextClassLoader.java
+ *- @ExecuteClass: ThreadGetContextClassLoader
+ *- @ExecuteArgs:
+ */
+
+public class ThreadGetContextClassLoader {
+    public static void main(String[] args) {
+        Thread thr = new Thread();
+        try {
+            // If not set, the default is the ClassLoader context of the parent Thread.
+            if (thr.getContextClassLoader() != Thread.currentThread().getContextClassLoader()) {
+                System.out.println(2);
+            }
+        } finally {
+            thr.start();
+            try {
+                thr.join();
+            } catch (InterruptedException e) {
+                System.out.println("Join is interrupted");
+            }
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/RT0184-rt-Thread-GenerifyStackTraces2/GenerifyStackTraces.java b/test/testsuite/ouroboros/thread_test/RT0184-rt-Thread-GenerifyStackTraces2/GenerifyStackTraces.java
new file mode 100644
index 0000000000000000000000000000000000000000..01b0a31bd16724f747cd35ba03f76282e74224e2
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0184-rt-Thread-GenerifyStackTraces2/GenerifyStackTraces.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: getStackTrace_RecursiveCall
+ *- @TestCaseName: GenerifyStackTraces.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Generified basic unit test of Thread.getStackTraces()
+ *- @Brief: see below
+ * -#step1： 定义ThreadOne类，该类继承Thread类，定义run函数，会调用wait()方法依次调用A,B,C,Done方法，最后获取当前线程的栈信
+ *           息，并检查。
+ * -#step2： 定义DumpThread类，该类继承Thread类，定义run函数，等待ThreadOne阻塞获取栈信息，通知ThreadOne继续。
+ * -#step3： New对象ThreadOne，通过start()方法启动run()。
+ * -#step4： New对象DumpThread，通过start()方法启动run()。
+ * -#step5： 等待ThreadOne对象运行结束。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: GenerifyStackTraces.java
+ *- @ExecuteClass: GenerifyStackTraces
+ *- @ExecuteArgs:
+ */
+
+import java.util.Map;
+
+public class GenerifyStackTraces {
+    private static Object go = new Object();
+    private static String[] methodNames = {"run", "A", "B", "C", "Done"};
+    private static int DONE_DEPTH = 5;
+    private static boolean testFailed = false;
+    private static Thread one;
+    private static boolean trace = false;
+
+    public static void main(String[] args) throws Exception {
+        if (args.length > 0 && args[0].equals("trace")) {
+            trace = true;
+        }
+
+        one = new ThreadOne();
+        one.start();
+
+        DumpThread dt = new DumpThread();
+        dt.start();
+
+        try {
+            one.join();
+        } finally {
+            dt.shutdown();
+        }
+
+        if (testFailed) {
+            throw new RuntimeException("Test Failed.");
+        }
+        System.out.println(0);
+    }
+
+    static class DumpThread extends Thread {
+        private volatile boolean finished = false;
+
+        public void run() {
+            int depth = 2;
+            while (!finished) {
+                // At each iterator, wait until ThreadOne blocks to wait for thread dump.
+                // Then dump stack trace and notify ThreadOne to continue.
+                try {
+                    sleep(2000);
+                    dumpStacks(depth);
+                    depth++;
+                    finishDump();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    testFailed = true;
+                }
+            }
+        }
+
+        public void shutdown() throws InterruptedException {
+            finished = true;
+            this.join();
+        }
+    }
+
+    static class ThreadOne extends Thread {
+        public void run() {
+            System.out.println( );
+            A();
+        }
+
+        private void A() {
+            waitForDump();
+            B();
+        }
+
+        private void B() {
+            waitForDump();
+            C();
+        }
+
+        private void C() {
+            waitForDump();
+            Done();
+        }
+
+        private void Done() {
+            waitForDump();
+
+            // Get stack trace of current thread
+            StackTraceElement[] stack = getStackTrace();
+            try {
+                checkStack(this, stack, DONE_DEPTH);
+            } catch (Exception e) {
+                e.printStackTrace();
+                testFailed = true;
+            }
+        }
+    }
+
+    static private void waitForDump() {
+        synchronized(go) {
+            try {
+               go.wait();
+            } catch (Exception e) {
+               throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+
+    static private void finishDump() {
+        synchronized(go) {
+            try {
+               go.notifyAll();
+            } catch (Exception e) {
+               throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+
+    public static void dumpStacks(int depth) throws Exception {
+        // Get stack trace of another thread
+        StackTraceElement[] stack = one.getStackTrace();
+        checkStack(one, stack, depth);
+
+        // Get stack traces of all Threads
+        for (Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
+            Thread t = entry.getKey();
+            stack = entry.getValue();
+            if (t == null || stack == null) {
+                throw new RuntimeException("Null thread or stacktrace returned");
+            }
+            if (t == one) {
+                checkStack(t, stack, depth);
+            }
+        }
+    }
+
+    private static void checkStack(Thread t, StackTraceElement[] stack, int depth) throws Exception {
+        if (trace) {
+            printStack(t, stack);
+        }
+        int frame = stack.length - 1;
+        for (int i = 0; i < depth && frame >= 0; i++) {
+            if (! stack[frame].getMethodName().equals(methodNames[i])) {
+                throw new RuntimeException("Expected " + methodNames[i] + " in frame " + frame + " but got " +
+                                           stack[frame].getMethodName());
+            }
+            frame--;
+        }
+    }
+
+    private static void printStack(Thread t, StackTraceElement[] stack) {
+        System.out.println(t + " stack: (length = " + stack.length + ")");
+        if (t != null) {
+            for (int j = 0; j < stack.length; j++) {
+                System.out.println(stack[j]);
+            }
+            System.out.println();
+        }
+    }
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan 0\n
diff --git a/test/testsuite/ouroboros/thread_test/RT0185-rt-Thread-GenerifyAllStackTraces/GenerifyAllStackTraces.java b/test/testsuite/ouroboros/thread_test/RT0185-rt-Thread-GenerifyAllStackTraces/GenerifyAllStackTraces.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6a28746e0e338e98edc68a23cabf01e80188be5
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0185-rt-Thread-GenerifyAllStackTraces/GenerifyAllStackTraces.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: GenerifyAllStackTraces
+ *- @TestCaseName: GenerifyAllStackTraces.java
+ *- @RequirementName: Unwind
+ *- @Title/Destination: Generified basic unit test of Thread.getAllStackTraces()
+ *- @Brief: see below
+ * -#step1： 创造两个线程组，每个线程都有相同同步锁，解锁后等待10ms，
+ * -#step2： 定义ThreadOne和ThreadTwo类，该类均继承Thread类，分别定义run函数，会调用wait()方法依次调用A,B,C方法，最后获取当前线程的栈信
+ *           息，并检查。
+ * -#step3： 定义DumpThread类，该类继承Thread类，定义run函数，等待ThreadOne和ThreadTwo阻塞获取栈信息，通知ThreadOne继续。
+ * -#step4： 等待线程组中的ThreadOne和ThreadTwo对象运行结束。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: GenerifyAllStackTraces.java
+ *- @ExecuteClass: GenerifyAllStackTraces
+ *- @ExecuteArgs:
+ */
+
+
+import java.util.Map;
+
+public class GenerifyAllStackTraces {
+    private static Object go = new Object();
+    private static String[] methodNames = {"run", "A", "B", "C", "Done"};
+    private static int DONE_DEPTH = 5;
+    private static boolean testFailed = false;
+    private static Thread one;
+    private static Thread two;
+    private static boolean trace = false;
+
+    public static void main(String[] args) throws Exception {
+        if (args.length > 0 && args[0].equals("trace")) {
+            trace = true;
+        }
+
+        one = new ThreadOne();
+        two = new ThreadTwo();
+        one.start();
+        two.start();
+
+        DumpThread dt = new DumpThread();
+        dt.start();
+
+        try {
+            one.join();
+            two.join();
+        } finally {
+            dt.shutdown();
+        }
+
+        if (testFailed) {
+            throw new RuntimeException("Test Failed.");
+        }
+        System.out.println(0);
+    }
+
+    static class DumpThread extends Thread {
+        private volatile boolean finished = false;
+
+        @Override
+        public void run() {
+            int depth = 2;
+            while (!finished) {
+                // At each iterator, wait until ThreadOne blocks to wait for thread dump.
+                // Then dump stack trace and notify ThreadOne to continue.
+                try {
+                    sleep(2000);
+                    dumpStacks(depth);
+                    depth++;
+                    finishDump();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    testFailed = true;
+                }
+            }
+        }
+
+        public void shutdown() throws InterruptedException {
+            finished = true;
+            join();
+        }
+    }
+
+    static class ThreadOne extends Thread {
+        @Override
+        public void run() {
+            System.out.println();
+            A();
+        }
+
+        private void A() {
+            waitForDump();
+            B();
+        }
+
+        private void B() {
+            waitForDump();
+            C();
+        }
+
+        private void C() {
+            waitForDump();
+            Done();
+        }
+
+        private void Done() {
+            waitForDump();
+
+            // Get stack trace of current thread
+
+            StackTraceElement[] stack = getStackTrace();
+            try {
+                checkStack(this, stack, DONE_DEPTH);
+            } catch (Exception e) {
+                e.printStackTrace();
+                testFailed = true;
+            }
+        }
+    }
+
+    static class ThreadTwo extends Thread {
+        @Override
+        public void run() {
+            System.out.println();
+            A();
+        }
+
+        private void A() {
+            waitForDump();
+            B();
+        }
+
+        private void B() {
+            waitForDump();
+            C();
+        }
+
+        private void C() {
+            waitForDump();
+            Done();
+        }
+
+        private void Done() {
+            waitForDump();
+
+            // Get stack trace of current thread
+            StackTraceElement[] stack = getStackTrace();
+            try {
+                checkStack(this, stack, DONE_DEPTH);
+            } catch (Exception e) {
+                e.printStackTrace();
+                testFailed = true;
+            }
+        }
+    }
+
+    static private void waitForDump() {
+        synchronized (go) {
+            try {
+                go.wait();
+            } catch (Exception e) {
+                throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+
+    static private void finishDump() {
+        synchronized (go) {
+            try {
+                go.notifyAll();
+            } catch (Exception e) {
+                throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+
+    public static void dumpStacks(int depth) throws Exception {
+        // Get stack trace of another thread
+        StackTraceElement[] stack = one.getStackTrace();
+        StackTraceElement[] stacks = two.getStackTrace();
+        checkStack(one, stack, depth);
+        checkStack(two, stacks, depth);
+
+        // Get stack traces of all Threads
+        for (Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
+            Thread t = entry.getKey();
+            stack = entry.getValue();
+            if (t == null || stack == null) {
+                throw new RuntimeException("Null thread or stacktrace returned");
+            }
+            if (t == one) {
+                checkStack(t, stack, depth);
+            }
+            if (t == two) {
+                checkStack(t, stacks, depth);
+            }
+        }
+    }
+
+    private static void checkStack(Thread t, StackTraceElement[] stack, int depth) throws Exception {
+        if (trace) {
+            printStack(t, stack);
+        }
+        int frame = stack.length - 1;
+        for (int i = 0; i < depth && frame >= 0; i++) {
+            if (!stack[frame].getMethodName().equals(methodNames[i])) {
+                throw new RuntimeException("Expected " + methodNames[i] + " in frame " + frame + " but got " +
+                        stack[frame].getMethodName());
+            }
+            frame--;
+        }
+    }
+
+    private static void printStack(Thread t, StackTraceElement[] stack) {
+        System.out.println(t + " stack: (length = " + stack.length + ")");
+        if (t != null) {
+            for (int j = 0; j < stack.length; j++) {
+                System.out.println(stack[j]);
+            }
+            System.out.println();
+        }
+    }
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan 0\n
diff --git a/test/testsuite/ouroboros/thread_test/RT0186-rt-Thread-getAllStackTraces-RecursiveCall/RecursiveCall.java b/test/testsuite/ouroboros/thread_test/RT0186-rt-Thread-getAllStackTraces-RecursiveCall/RecursiveCall.java
new file mode 100644
index 0000000000000000000000000000000000000000..1937d41329fd1f38ef5b4f45e56bffe2884b8e9f
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0186-rt-Thread-getAllStackTraces-RecursiveCall/RecursiveCall.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: getAllStackTrace_RecursiveCall
+ *- @TestCaseName: RecursiveCall.java
+ *- @RequirementName: Unwind
+ *- @Title/Destination: Generified basic unit test of Thread.getAllStackTraces()
+ *- @Brief: see below
+ * -#step1： 创造一个线程组，长度为1000，每个线程都有相同同步锁，解锁后等待10ms，
+ * -#step2： ThreadOne类，该类均继承Thread类，分别定义run函数，会调用wait()方法依次调用A,B,C方法，并行执行线程组。
+ * -#step3： 等待所有线程正常结束
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: RecursiveCall.java
+ *- @ExecuteClass: RecursiveCall
+ *- @ExecuteArgs:
+ */
+
+
+import java.util.Map;
+
+public class RecursiveCall  extends Thread{
+    private static String[] methodNames = {"run", "A", "B", "C", "Done"};
+    private static Object obj = new Object();
+    private static Thread[] tt = new Thread[1000];
+
+    public static void main(String[] args) throws InterruptedException{
+
+        for (int i = 0; i < tt.length; i++) {
+            tt[i] = new ThreadOne();
+        }
+        for (int i = 0; i < tt.length; i++) {
+            tt[i].start();
+        }
+
+        for (int i = 0; i < tt.length; i++) {
+            try {
+                tt[i].join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+
+        }
+        System.out.println(0);
+    }
+
+
+    static class ThreadOne extends Thread {
+        @Override
+        public void run() {
+            System.out.println( );
+            A();
+        }
+
+        private void A() {
+            waitForDump();
+            B();
+        }
+
+        private void B() {
+            waitForDump();
+            C();
+        }
+
+        private void C() {
+            waitForDump();
+            Done();
+        }
+
+        private void Done() {
+            waitForDump();
+        }
+    }
+
+    static private void waitForDump() {
+        synchronized (obj) {
+            try {
+                obj.wait(10);
+            } catch (InterruptedException e) {
+                System.out.println("wait is interrupted");
+            }
+        }
+    }
+
+
+}
+
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan 0\n
diff --git a/test/testsuite/ouroboros/thread_test/RT0188-rt-Thread-getAllStackTraces-NullStackTrace/NullStackTrace.java b/test/testsuite/ouroboros/thread_test/RT0188-rt-Thread-getAllStackTraces-NullStackTrace/NullStackTrace.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fdf52e18d78e910fe4806751e28fe872510038d
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/RT0188-rt-Thread-getAllStackTraces-NullStackTrace/NullStackTrace.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: getAllStackTrace_NullStackTrace
+ *- @TestCaseName: NullStackTrace.java
+ *- @RequirementName: getAllStackTrace
+ *- @Title/Destination: Thread.getAllStackTrace() on runnable threads, should not return null
+ *- @Brief: see below
+ * -#step1: 创建一个线程实例
+ * -#step2: 启动线程
+ * -#step3: 用Thread.getAllStackTrace() 打印线程，不能返回为空
+ * -#step4: 重复1-3步骤1000次.
+ *- @Expect: Passed
+ *- @Priority: High
+ *- @Source: NullStackTrace.java
+ *- @ExecuteClass: NullStackTrace
+ *- @ExecuteArgs:
+ */
+import java.util.Map;
+
+public class NullStackTrace extends Thread{
+    static final int TIMES = 1000;
+
+    public static void main(String[] args) {
+        for (int i = 0; i < TIMES; i++) {
+            Thread t = new Thread();
+            t.start();
+
+            Map m = getAllStackTraces();
+            String stFinish = m.keySet().toString();
+            if (stFinish == null)
+                throw new RuntimeException("Failed: Thread.getAllStackTrace should not return null");
+        }
+        System.out.println("Passed");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full Passed\n
diff --git a/test/testsuite/ouroboros/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/ThreadOutOfMemoryTest.java b/test/testsuite/ouroboros/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/ThreadOutOfMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2805d97551ec53494d389ad8193dcb24de835a53
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/ThreadOutOfMemoryTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadOutOfMemoryTest
+ *- @TestCaseName: Thread_ThreadOutOfMemoryTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Check if thread creation reaches memory line will throw OutOfMemory.
+ *- @Brief: see below
+ * -#step1: 调用new Thread来创建线程，线程里会创建一个超大整数。
+ * -#step2：使用循环反复启动该线程。
+ * -#step3：检查线程是否会抛OutOfMemoryError异常并退出。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadOutOfMemoryTest.java
+ *- @ExecuteClass: ThreadOutOfMemoryTest
+ *- @ExecuteArgs:
+ */
+import java.io.PrintStream;
+
+public class ThreadOutOfMemoryTest {
+    private static Object s = new Object();
+    private static int count = 0;
+    private static int i = 0;
+
+    public static void main(String[] args) {
+        System.exit(run(args, System.out));
+        System.out.println(2);
+    }
+
+    public static int run(String[] args, PrintStream out) {
+        for (; ; ) {
+            new Thread(new Runnable() {
+                public void run() {
+                    synchronized (s) {
+                        try {
+                            int[] y;
+                            y = new int[50000 * 1000];
+                            y[0]++;
+                        } catch (OutOfMemoryError e2) {
+                            i++;
+                            System.err.println(e2);
+                        }
+                        count += 1;
+//                        System.out.println("New thread #" + count);
+                    }
+                    for (; ; ) {
+                        try {
+                            Thread.sleep(1000);
+                        } catch (InterruptedException e1) {
+                            System.err.println(e1);
+                        } catch (OutOfMemoryError e3) {
+                            i++;
+                            System.err.println(e3);
+                        }
+                    }
+                }
+            }).start();
+            if (i != 0) {
+//                System.out.println(i);
+                break;
+            }
+        }
+        System.out.println(0);
+        return 0;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/issue-RT0392-rt-Thread-Threadperformance1/ThreadPerformance1Test.java b/test/testsuite/ouroboros/thread_test/issue-RT0392-rt-Thread-Threadperformance1/ThreadPerformance1Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c914b9e2af864ab27f3af3b8084309af86cf29e
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/issue-RT0392-rt-Thread-Threadperformance1/ThreadPerformance1Test.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadPerformance1Test
+ *- @TestCaseName: Thread_ThreadPerformance1Test.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Gets the average time to perform 20 group reentrant locks/unlock 100 times of monitor.
+ *- @Brief: see below
+ * -#step1: 创建个100长度的线程组，线程里有6个同步锁，第5和6个解锁后各等待10毫秒，调用notifyAll()进行解锁。
+ * -#step2：打点开始时间startTime,并发启动线程组的线程进行解锁和关锁的操作。
+ * -#step3：调用join()等待所有线程结束，打点结束时间endTime，endTime - startTime算出每次运行时间。
+ * -#step4：重复步骤1~3 20次，计算每次的平均时间。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadPerformance1Test.java
+ *- @ExecuteClass: ThreadPerformance1Test
+ *- @ExecuteArgs:
+ */
+
+class LockCls {}
+
+public class ThreadPerformance1Test extends  Thread{
+    public static void main(String[] args) {
+        LockCls lock = new LockCls();
+        long startTime;
+        long endTime;
+        long[] ThreadPerformance1Test = new long[20];
+        long sum = 0;
+        long ave;
+        Object obj = "aa";
+        Thread[] tt = new Thread[100];
+        for (int ii = 0; ii < ThreadPerformance1Test.length; ii++) {
+            for (int i = 0; i < tt.length; i++) {
+                tt[i] = new Thread(new Runnable() {
+                    public void run() {
+                        synchronized (lock) {
+                            synchronized (lock) {
+                                synchronized (obj) {
+                                    synchronized (this) {
+                                        synchronized (obj) {
+                                            synchronized (this) {
+                                                try {
+                                                    this.wait(10);
+                                                } catch (InterruptedException e1) {
+                                                    System.err.println(e1);
+                                                }
+                                            }
+                                            try {
+                                                obj.wait(10);
+                                            } catch (InterruptedException e2) {
+                                                System.err.println(e2);
+                                            }
+                                        }
+                                        this.notifyAll();
+                                    }
+                                    obj.notify();
+                                }
+                                try {
+                                    lock.wait(10);
+                                } catch (InterruptedException e3) {
+                                    System.err.println(e3);
+                                }
+                            }
+                            lock.notifyAll();
+                        }
+                    }
+                });
+            }
+            startTime = System.currentTimeMillis();
+            for (int i = 0; i < tt.length; i++) {
+                tt[i].start();
+            }
+            for (int i = 0; i < tt.length; i++) {
+                try {
+                    tt[i].join();
+                } catch (InterruptedException e) {
+                    System.err.println(e);
+                }
+            }
+            endTime = System.currentTimeMillis();
+            //System.out.println(startTime);
+            //System.out.println(endTime);
+            //System.out.println(endTime - startTime);
+            ThreadPerformance1Test[ii] = endTime - startTime;
+        }
+        for(int ii = 0; ii < ThreadPerformance1Test.length; ii++) {
+            sum += ThreadPerformance1Test[ii];
+        }
+        ave = sum / ThreadPerformance1Test.length;
+        //System.out.println("ave=" + ave + "ms");
+        System.out.println(0);
+        return;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/ThreadStateNewTest.java b/test/testsuite/ouroboros/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/ThreadStateNewTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a5c2809163b73e9effd08d2d3e9f7a1bea208b3
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/ThreadStateNewTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadStateNewTest
+ *- @TestCaseName: Thread_ThreadStateNewTest.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Test getState() return NEW when the thread have not start.
+ *- @Brief: see below
+ * -#step1: 用用例的类来new一个对象。
+ * -#step2: 用对象调用getState()方法。
+ * -#step3：确认返回NEW。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadStateNewTest.java
+ *- @ExecuteClass: ThreadStateNewTest
+ *- @ExecuteArgs:
+ */
+
+public class ThreadStateNewTest extends Thread {
+    public static void main(String[] args) {
+        ThreadStateNewTest cls = new ThreadStateNewTest();
+        if (cls.getState().toString().equals("NEW")) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/GenerifyStackTraces.java b/test/testsuite/ouroboros/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/GenerifyStackTraces.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b90a44125235fd92fa48ebd369bf2defb1c03d6
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/GenerifyStackTraces.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: GenerifyStackTraces
+ *- @TestCaseName: Thread_GenerifyStackTraces.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Generified basic unit test of Thread.getAllStackTraces()
+ *- @Brief: see below
+ * -#step1： 定义ThreadOne类，该类继承Thread类，定义run函数，会调用wait()方法依次调用A,B,C方法，最后获取当前线程的栈信
+ *           息，并检查。
+ * -#step2： 定义DumpThread类，该类继承Thread类，定义run函数，等待ThreadOne阻塞获取栈信息，通知ThreadOne继续。
+ * -#step3： New对象ThreadOne，通过start()方法启动run()。
+ * -#step4： New对象DumpThread，通过start()方法启动run()。
+ * -#step5： 等待ThreadOne对象运行结束。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: GenerifyStackTraces.java
+ *- @ExecuteClass: GenerifyStackTraces
+ *- @ExecuteArgs:
+ */
+
+import java.util.*;
+
+public class GenerifyStackTraces {
+    private static Object go = new Object();
+    private static String[] methodNames = {"run", "A", "B", "C", "Done"};
+    private static int DONE_DEPTH = 5;
+    private static boolean testFailed = false;
+    private static Thread one;
+    private static boolean trace = false;
+
+    public static void main(String[] args) throws Exception {
+        if (args.length > 0 && args[0].equals("trace")) {
+            trace = true;
+        }
+
+        one = new ThreadOne();
+        one.start();
+
+        DumpThread dt = new DumpThread();
+        dt.start();
+
+        try {
+            one.join();
+        } finally {
+            dt.shutdown();
+        }
+
+        if (testFailed) {
+            throw new RuntimeException("Test Failed.");
+        }
+        System.out.println(0);
+    }
+
+    static class DumpThread extends Thread {
+        private volatile boolean finished = false;
+
+        public void run() {
+            int depth = 2;
+            while (!finished) {
+                // At each iterator, wait until ThreadOne blocks to wait for thread dump.
+                // Then dump stack trace and notify ThreadOne to continue.
+                try {
+                    sleep(2000);
+                    dumpStacks(depth);
+                    depth++;
+                    finishDump();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    testFailed = true;
+                }
+            }
+        }
+
+        public void shutdown() throws InterruptedException {
+            finished = true;
+            this.join();
+        }
+    }
+
+    static class ThreadOne extends Thread {
+        public void run() {
+            A();
+        }
+
+        private void A() {
+            waitForDump();
+            B();
+        }
+
+        private void B() {
+            waitForDump();
+            C();
+        }
+
+        private void C() {
+            waitForDump();
+            Done();
+        }
+
+        private void Done() {
+            waitForDump();
+
+            // Get stack trace of current thread
+            StackTraceElement[] stack = getStackTrace();
+            try {
+                checkStack(this, stack, DONE_DEPTH);
+            } catch (Exception e) {
+                e.printStackTrace();
+                testFailed = true;
+            }
+        }
+    }
+
+    static private void waitForDump() {
+        synchronized(go) {
+            try {
+               go.wait();
+            } catch (Exception e) {
+               throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+
+    static private void finishDump() {
+        synchronized(go) {
+            try {
+               go.notifyAll();
+            } catch (Exception e) {
+               throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+
+    public static void dumpStacks(int depth) throws Exception {
+        // Get stack trace of another thread
+        StackTraceElement[] stack = one.getStackTrace();
+        checkStack(one, stack, depth);
+
+        // Get stack traces of all Threads
+        for (Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
+            Thread t = entry.getKey();
+            stack = entry.getValue();
+            if (t == null || stack == null) {
+                throw new RuntimeException("Null thread or stacktrace returned");
+            }
+            if (t == one) {
+                checkStack(t, stack, depth);
+            }
+        }
+    }
+
+    private static void checkStack(Thread t, StackTraceElement[] stack, int depth) throws Exception {
+        if (trace) {
+            printStack(t, stack);
+        }
+        int frame = stack.length - 1;
+        for (int i = 0; i < depth && frame >= 0; i++) {
+            if (! stack[frame].getMethodName().equals(methodNames[i])) {
+                throw new RuntimeException("Expected " + methodNames[i] + " in frame " + frame + " but got " +
+                                           stack[frame].getMethodName());
+            }
+            frame--;
+        }
+    }
+
+    private static void printStack(Thread t, StackTraceElement[] stack) {
+        System.out.println(t + " stack: (length = " + stack.length + ")");
+        if (t != null) {
+            for (int j = 0; j < stack.length; j++) {
+                System.out.println(stack[j]);
+            }
+            System.out.println();
+        }
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/JGFSyncBench.java b/test/testsuite/ouroboros/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/JGFSyncBench.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c361bdb73027619490c3a2318a359ba5d27c7e6
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/JGFSyncBench.java
@@ -0,0 +1,399 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: JGFSyncBench
+ *- @TestCaseName: Thread_JGFSyncBench.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Get the time of thread sync.
+ *- @Brief: see below
+ * -#step1: 调用JGFInstrumentor.printHeader对header进行设置。
+ * -#step2: 声明类JGFSyncBench实现自定义接口JGFSection1。
+ * -#step3：创建nThreads+1个Runnable数组和Thread数组,线程里有synchronized同步锁。
+ * -#step4: 打点开始时间，启动线程组线程，等待线程结束，打点结束时间,存储运行时间。
+ * -#step5：重复步骤1~4 100000次。
+ * -#step6：重复步骤1~5。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: JGFSyncBench.java
+ *- @ExecuteClass: JGFSyncBench
+ *- @ExecuteArgs:
+ */
+
+import java.util.Hashtable;
+
+public class JGFSyncBench implements JGFSection1 {
+    public static int nThreads;
+    private static final int INITSIZE = 1000;
+    private static final int MAXSIZE = 100000;
+    private static final double TARGETTIME = 10.0;
+
+    public JGFSyncBench(int nThreads) {
+        this.nThreads = nThreads;
+    }
+
+    public void JGFRun() {
+        int i,size;
+        double time;
+        int counter = 0;
+        int shared_cont = 0;
+
+        size=INITSIZE;
+        time = 0.0;
+
+        Runnable thoObjects[] = new Runnable[nThreads + 1];
+        Thread th[] = new Thread[nThreads + 1];
+        CounterClass conTm = new CounterClass(shared_cont);
+        CounterClass conTo = new CounterClass(shared_cont);
+        JGFInstrumentor.addTimer("Section1:Sync:Method", "synchronisations");
+
+        while (size < MAXSIZE) {
+            JGFInstrumentor.resetTimer("Section1:Sync:Method");
+            JGFInstrumentor.startTimer("Section1:Sync:Method");
+
+            for(i = 1; i < nThreads + 1; i++) {
+                thoObjects[i] = new SyncMethodRunner(i,conTm,size);
+                th[i] = new Thread(thoObjects[i]);
+                th[i].start();
+            }
+
+            thoObjects[0] = new SyncMethodRunner(0, conTm, size);
+            thoObjects[0].run();
+
+            for(i = 1; i < nThreads + 1; i++) {
+                try {
+                    th[i].join();
+                } catch (InterruptedException e) {
+                    System.out.println("Join is interrupted");
+                }
+            }
+
+            JGFInstrumentor.stopTimer("Section1:Sync:Method");
+            time = JGFInstrumentor.readTimer("Section1:Sync:Method");
+            JGFInstrumentor.addOpsToTimer("Section1:Sync:Method", (double) size);
+            size *= 2;
+        }
+
+        JGFInstrumentor.printPerTimer("Section1:Sync:Method");
+
+        size = INITSIZE;
+        time = 0.0;
+        JGFInstrumentor.addTimer("Section1:Sync:Object", "synchronisations");
+
+        while (size < MAXSIZE) {
+            JGFInstrumentor.resetTimer("Section1:Sync:Object");
+            JGFInstrumentor.startTimer("Section1:Sync:Object");
+
+            for(i = 1; i < nThreads + 1; i++) {
+                thoObjects[i] = new SyncObjectRunner(i, conTo, size);
+                th[i] = new Thread(thoObjects[i]);
+                th[i].start();
+            }
+
+            thoObjects[0] = new SyncObjectRunner(i, conTo, size);
+            thoObjects[0].run();
+
+            for(i = 1; i < nThreads + 1; i++) {
+                try {
+                    th[i].join();
+                } catch (InterruptedException e) {
+                    System.out.println("Join is interrupted");
+                }
+            }
+
+            JGFInstrumentor.stopTimer("Section1:Sync:Object");
+            time = JGFInstrumentor.readTimer("Section1:Sync:Object");
+            JGFInstrumentor.addOpsToTimer("Section1:Sync:Object",(double) size);
+            size *= 2;
+        }
+        JGFInstrumentor.printPerTimer("Section1:Sync:Object");
+    }
+
+    public static void main(String[] argv) {
+        nThreads = 4;
+        JGFInstrumentor.printHeader(1, 0, nThreads);
+        JGFSyncBench sb = new JGFSyncBench(nThreads);
+        sb.JGFRun();
+        System.out.println(0);
+    }
+}
+
+class CounterClass {
+    int shared_cont;
+
+    public CounterClass(int shared_cont) {
+        this.shared_cont = shared_cont;
+    }
+
+    public synchronized void update() {
+        shared_cont++;
+    }
+}
+
+class SyncMethodRunner implements Runnable {
+    int id;
+    int size;
+    CounterClass cont;
+
+    public SyncMethodRunner(int id, CounterClass cont ,int size) {
+        this.id = id;
+        this.cont = cont;
+        this.size = size;
+    }
+
+    public void run() {
+        for(int i = 0; i < size; i++) {
+            cont.update();
+        }
+    }
+}
+
+class SyncObjectRunner implements Runnable {
+    int id;
+    int size;
+    CounterClass cont;
+
+    public SyncObjectRunner(int id, CounterClass cont, int size) {
+        this.id = id;
+        this.cont = cont;
+        this.size = size;
+    }
+
+    public void run() {
+        for(int i = 0; i < size; i++) {
+            synchronized(cont) {
+                cont.shared_cont++;
+            }
+        }
+    }
+}
+
+class JGFInstrumentor{
+    private static Hashtable timers;
+    private static Hashtable data;
+
+    static {
+        timers = new Hashtable();
+        data = new Hashtable();
+    }
+
+    public static synchronized void addTimer (String name) {
+        if (!timers.containsKey(name)) {
+            timers.put(name, new JGFTimer(name));
+        }
+    }
+
+    public static synchronized void addTimer (String name, String opname) {
+        if (!timers.containsKey(name)) {
+            timers.put(name, new JGFTimer(name,opname));
+        }
+    }
+
+    public static synchronized void addTimer (String name, String opname, int size) {
+        if (!timers.containsKey(name)) {
+            timers.put(name, new JGFTimer(name,opname,size));
+        }
+    }
+
+    public static synchronized void startTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).start();
+        }
+    }
+
+    public static synchronized void stopTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).stop();
+        }
+    }
+
+    public static synchronized void addOpsToTimer(String name, double count) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).addOps(count);
+        }
+    }
+
+    public static synchronized void addTimeToTimer(String name, double added_time) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).addTime(added_time);
+        }
+    }
+
+    public static synchronized double readTimer(String name) {
+        double time;
+        if (timers.containsKey(name)) {
+            time = ((JGFTimer) timers.get(name)).time;
+        } else {
+            time = 0.0;
+        }
+        return time;
+    }
+
+    public static synchronized void resetTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).reset();
+        }
+    }
+
+    public static synchronized void printTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).print();
+        }
+    }
+
+    public static synchronized void printPerTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).printPer();
+        }
+    }
+
+    public static synchronized void storeData(String name, Object obj) {
+        data.put(name,obj);
+    }
+
+    public static synchronized void retrieveData(String name, Object obj) {
+        obj = data.get(name);
+    }
+
+    public static synchronized void printHeader(int section, int size,int nThreads) {
+        String header;
+        String base;
+        header = "";
+        base = "Java Grande Forum Thread Benchmark Suite - Version 1.0 - Section ";
+
+        switch (section) {
+            case 1:
+                header = base + "1";
+                break;
+            case 2:
+                switch (size) {
+                    case 0:
+                        header = base + "2 - Size A";
+                        break;
+                    case 1:
+                        header = base + "2 - Size B";
+                        break;
+                    case 2:
+                        header = base + "2 - Size C";
+                        break;
+                }
+                break;
+            case 3:
+                switch (size) {
+                    case 0:
+                        header = base + "3 - Size A";
+                        break;
+                    case 1:
+                        header = base + "3 - Size B";
+                        break;
+                }
+                break;
+        }
+    }
+}
+
+interface JGFSection1 {
+    public final int INITSIZE = 10000;
+    public final int MAXSIZE = 1000000000;
+    public final double TARGETTIME = 1.0;
+    public void JGFRun();
+}
+
+class JGFTimer {
+    public String name;
+    public String opName;
+    public double time;
+    public double opCount;
+    public long calls;
+    public int size = -1;
+    private long start_time;
+    private boolean on;
+
+    public JGFTimer(String name, String opName) {
+        this.name = name;
+        this.opName = opName;
+        reset();
+    }
+
+    public JGFTimer(String name, String opName, int size) {
+        this.name = name;
+        this.opName = opName;
+        this.size = size;
+        reset();
+    }
+
+    public JGFTimer(String name) {
+        this(name,"");
+    }
+
+    public void start() {
+        if (on) {
+            on = true;
+        }
+        start_time = System.currentTimeMillis();
+    }
+
+    public void stop() {
+        time += (double) (System.currentTimeMillis()-start_time) / 1000.;
+        if (!on) {
+            calls++;
+        }
+        on = false;
+    }
+
+    public void addOps(double count) {
+        opCount += count;
+    }
+
+    public void addTime(double added_time) {
+        time += added_time;
+    }
+
+    public void reset() {
+        time = 0.0;
+        calls = 0;
+        opCount = 0;
+        on = false;
+    }
+
+    public double per() {
+        return opCount / time;
+    }
+
+    public void print() {
+        if (!opName.equals("")) {
+            switch(size) {
+                case 0:
+                    break;
+                case 1:
+                    break;
+                case 2:
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    public void printPer() {
+        String name;
+        name = this.name;
+
+        // pad name to 40 characters
+        while ( name.length() < 40 ) {
+            name = name + " ";
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/ThreadSetContextClassLoader2.java b/test/testsuite/ouroboros/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/ThreadSetContextClassLoader2.java
new file mode 100644
index 0000000000000000000000000000000000000000..814797544ba083b5b6c2b8c05fc4b8f2869629f9
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/ThreadSetContextClassLoader2.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetContextClassLoader2
+ *- @TestCaseName: Thread_ThreadSetContextClassLoader2.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Use setContextClassLoader(ClassLoader cl) to change the class loader of Thread.
+ *- @Brief: see below
+ * -#step1: 创建本用例类的对象，通过getContextClassLoader()获取对应的类加载器。
+ * -#step2：调用setContextClassLoader(ClassLoader cl)来设置类的ClassLoader。
+ * -#step3：调用start()启动对应的实例对象，等待线程运行结束。
+ * -#step4：确认对应的加载器成功运行。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadSetContextClassLoader2.java
+ *- @ExecuteClass: ThreadSetContextClassLoader2
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetContextClassLoader2 extends Thread {
+    static int i;
+
+    public static void main(String[] args) {
+        ThreadSetContextClassLoader2 threadSetContextClassLoader2 = new ThreadSetContextClassLoader2();
+        ClassLoader cl = threadSetContextClassLoader2.getContextClassLoader();
+        threadSetContextClassLoader2.setContextClassLoader(cl.getParent());
+
+        threadSetContextClassLoader2.start();
+        try {
+            threadSetContextClassLoader2.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+
+        if (i == 1) {
+            if (threadSetContextClassLoader2.getContextClassLoader() != cl) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+    }
+
+    public void run() {
+        i++;
+        super.run();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/ThreadSetName3Test.java b/test/testsuite/ouroboros/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/ThreadSetName3Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd2041b2051860d19ba62ef99ac6b7328c65c124
--- /dev/null
+++ b/test/testsuite/ouroboros/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/ThreadSetName3Test.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: ThreadSetName3Test
+ *- @TestCaseName: Thread_ThreadSetName3Test.java
+ *- @RequirementName: Java Thread
+ *- @Title/Destination: Negative input for setName(String name).
+ *- @Brief: see below
+ * -#step1: 创建两个线程分别为testName1，testName2。
+ * -#step2：调用start()启动两个线程。
+ * -#step3：创建参数name为空字符串，两个线程分别都调用setName(String name)。
+ * -#step4：通过getName()检查设置成功。
+ *- @Expect: 0\n
+ *- @Priority: High
+ *- @Source: ThreadSetName3Test.java
+ *- @ExecuteClass: ThreadSetName3Test
+ *- @ExecuteArgs:
+ */
+
+public class ThreadSetName3Test extends Thread {
+    public static void main(String[] args) {
+        ThreadSetName3Test testName1 = new ThreadSetName3Test();
+        ThreadSetName3Test testName2 = new ThreadSetName3Test();
+        testName1.start();
+        testName1.setName("");
+        testName2.start();
+        testName2.setName("");
+
+        if (testName1.getName().equals("")) {
+            if (testName1.getName().equals("")) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/UnsafegetIntVolatileTest.java b/test/testsuite/ouroboros/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/UnsafegetIntVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..91277d302cca880a1705c6d920ade40c736dcb77
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/UnsafegetIntVolatileTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetIntVolatileTest
+ * -@TestCaseName: Unsafe api: getIntvolatile()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:getobjectFieldOffset
+ * -#step2:Unsafe.getIntVolatile of step1
+ * -#step3:get result as step1 set
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetIntVolatileTest.java
+ * -@ExecuteClass: UnsafegetIntVolatileTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.TreeSet;
+
+public class UnsafegetIntVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetIntVolatileTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetIntVolatileTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetIntVolatileTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+
+    private static int UnsafegetIntVolatileTest_1()  {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie6.class.getDeclaredField("age");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie6();
+            result = unsafe.getIntVolatile(obj, offset);
+            if (result == 18) {
+                UnsafegetIntVolatileTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie6 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/UnsafeallocateMemoryTest.java b/test/testsuite/ouroboros/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/UnsafeallocateMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ece087d0dfa4e07c8d31c847b91b0d4d4ce311e9
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/UnsafeallocateMemoryTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeallocateMemoryTest
+ * -@TestCaseName: Unsafe api: allocateMemoary()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:invoke Unsafe.allocateMemory to get Memory success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeallocateMemoryTest.java
+ * -@ExecuteClass: UnsafeallocateMemoryTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeallocateMemoryTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeallocateMemoryTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeallocateMemoryTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeallocateMemoryTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeallocateMemoryTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            UnsafeallocateMemoryTest.res -= 2;
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/UnsafearrayBaseOffsetTest.java b/test/testsuite/ouroboros/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/UnsafearrayBaseOffsetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4cdf4083239bde119429af70e2a7dd73524c0c22
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/UnsafearrayBaseOffsetTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafearrayBaseOffsetTest
+ * -@TestCaseName: Unsafe api: arrayBaseOffset()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare array
+ * -#step2:get offset of array
+ * -#step3:check return value by getInt,compare step1
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafearrayBaseOffsetTest.java
+ * -@ExecuteClass: UnsafearrayBaseOffsetTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafearrayBaseOffsetTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafearrayFieldOffsetTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafearrayBaseOffsetTest.res = UnsafearrayBaseOffsetTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafearrayBaseOffsetTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafearrayFieldOffsetTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Object obj;
+        long offset;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            obj = new int[]{101, 2, 3};
+            offset = unsafe.arrayBaseOffset(obj.getClass());
+            int result = unsafe.getInt(obj, offset);
+            if (result == 101) {
+                UnsafearrayBaseOffsetTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/UnsafearrayIndexScaleTest.java b/test/testsuite/ouroboros/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/UnsafearrayIndexScaleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..964d9403571535d3c4b944a879fbd4565d37e1f3
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/UnsafearrayIndexScaleTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafearrayBaseOffsetTest
+ * -@TestCaseName: Unsafe api: arrayBaseOffset()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare arrys[N]
+ * -#step2:use arrayBaseOffset+index*arrayIndexScale to visit arrays
+ * -#step3:get corrt value
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafearrayIndexScaleTest.java
+ * -@ExecuteClass: UnsafearrayIndexScaleTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafearrayIndexScaleTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafearrayIndexSacleTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafearrayIndexScaleTest.res = UnsafearrayIndexScaleTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafearrayIndexScaleTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafearrayIndexSacleTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Object obj;
+        long scale;
+        long offset;
+        long result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new long[]{9, 8, 7, 6};
+            scale =  unsafe.arrayIndexScale(obj.getClass());
+            offset = unsafe.arrayBaseOffset(obj.getClass());
+            result = unsafe.getLong(obj, offset + 2*scale);
+            if (result == 7) {
+                UnsafearrayIndexScaleTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/UnsafecompareAndSwapIntTest.java b/test/testsuite/ouroboros/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/UnsafecompareAndSwapIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f15d372fba0e01923a51190ec7254bcc7a7cc61
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/UnsafecompareAndSwapIntTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafecompareAndSwapIntTest
+ * -@TestCaseName: Unsafe api: compareAndSwapInt()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare Field height = 8(int type)
+ * -#step2:invoke Unsafe.compareAndSwapInt to swap value of step1
+ * -#step3:swap success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafecompareAndSwapIntTest.java
+ * -@ExecuteClass: UnsafecompareAndSwapIntTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafecompareAndSwapIntTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecompareAndSwapIntTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafecompareAndSwapIntTest.res = UnsafecompareAndSwapIntTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafecompareAndSwapIntTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafecompareAndSwapIntTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Field param;
+        Object obj;
+        long scale;
+        long offset;
+        int result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new Billie3();
+            param = Billie3.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            unsafe.compareAndSwapInt(obj, offset, 8, 10);
+            result = unsafe.getInt(obj, offset);
+            if (result == 10) {
+                UnsafecompareAndSwapIntTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie3 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/UnsafecompareAndSwapLongTest.java b/test/testsuite/ouroboros/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/UnsafecompareAndSwapLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..52ae1086b0b778aaf0736e916345bbeb2f13a1eb
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/UnsafecompareAndSwapLongTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafecompareAndSwapLongTest
+ * -@TestCaseName: Unsafe api: compareAndSwapLong()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare Field weight = 100L(long type)
+ * -#step2:invoke Unsafe.compareAndSwapLong to swap value of step1
+ * -#step3:swap success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafecompareAndSwapLongTest.java
+ * -@ExecuteClass: UnsafecompareAndSwapLongTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafecompareAndSwapLongTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecompareAndSwapLongTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafecompareAndSwapLongTest.res = UnsafecompareAndSwapLongTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafecompareAndSwapLongTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafecompareAndSwapLongTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Field param;
+        Object obj;
+        long offset;
+        long result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new Billie4();
+            param = Billie4.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            unsafe.compareAndSwapLong(obj, offset, 100L, 200L);
+            result = unsafe.getLong(obj, offset);
+            if (result == 200L) {
+                UnsafecompareAndSwapLongTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie4 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/UnsafecompareAndSwapObjectTest.java b/test/testsuite/ouroboros/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/UnsafecompareAndSwapObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b48f7a516c029d75b546e5862a6c68aebd0dcf1
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/UnsafecompareAndSwapObjectTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafecompareAndSwapObjectTest
+ * -@TestCaseName: Unsafe api: compareAndSwapObject()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare Field owner = "Me"(Object)
+ * -#step2:invoke Unsafe.compareAndSwapObject to swap value of step1
+ * -#step3:swap success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafecompareAndSwapObjectTest.java
+ * -@ExecuteClass: UnsafecompareAndSwapObjectTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafecompareAndSwapObjectTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecompareAndSwapObjectTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafecompareAndSwapObjectTest.res = UnsafecompareAndSwapObjectTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafecompareAndSwapObjectTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafecompareAndSwapObjectTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Field param;
+        Object obj;
+        long offset;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new Billie5();
+            param = Billie5.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            unsafe.compareAndSwapObject(obj, offset, "Me", "billie5");
+            result = unsafe.getObject(obj, offset);
+            if (result.equals("billie5")) {
+                UnsafecompareAndSwapObjectTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie5 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/UnsafecopyMemoryTest.java b/test/testsuite/ouroboros/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/UnsafecopyMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b83aa73a65360bf85376e46e464ed12f7b110a6
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/UnsafecopyMemoryTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafecopyMemoryTest
+ * -@TestCaseName: Unsafe api:  copyMemory(long srcAddr, long dstAddr, long bytes)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:allocateMemory to put value
+ * -#step2:copyMemory from step1
+ * -#step3:get value from step2,should be same as step1 put
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafecopyMemoryTest.java
+ * -@ExecuteClass: UnsafecopyMemoryTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+public class UnsafecopyMemoryTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecopyMemoryTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafecopyMemoryTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafecopyMemoryTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafecopyMemoryTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address1;
+        long address2;
+        byte result;
+        Method m;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address1 = unsafe.allocateMemory(5);
+            byte b = 101;
+            unsafe.putByte(address1, b);
+            address2 = unsafe.allocateMemory(5);
+            unsafe.copyMemory(address1, address2, 5);
+//            System.out.println(Arrays.toString(bytes));
+            result = unsafe.getByte(address2);
+//            System.out.println(result);
+            if (result == 101) {
+                UnsafecopyMemoryTest.res -= 2;
+            }
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/UnsafefreeMemoryTest.java b/test/testsuite/ouroboros/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/UnsafefreeMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5af372ccdd28a985b9fd9ead6c9a0728cc413eb9
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/UnsafefreeMemoryTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeallocateMemoryTest
+ * -@TestCaseName: Unsafe api: allocateMemoary()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:Unsafe.freeMemory sucess
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafefreeMemoryTest.java
+ * -@ExecuteClass: UnsafefreeMemoryTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafefreeMemoryTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafefreeMemoryTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafefreeMemoryTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafefreeMemoryTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafefreeMemoryTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            unsafe.freeMemory(address);
+            UnsafefreeMemoryTest.res -= 2;
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/UnsafegetAndAddIntTest.java b/test/testsuite/ouroboros/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/UnsafegetAndAddIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ad1d01c575006700ab503dd9d709aa7727d9551
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/UnsafegetAndAddIntTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetAndAddIntTest
+ * -@TestCaseName: Unsafe api: getAndAddInt()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare Field height = 8(int type)
+ * -#step2:invoke Unsafe.getAndAddInt to add one value
+ * -#step3:check the Field,add success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetAndAddIntTest.java
+ * -@ExecuteClass: UnsafegetAndAddIntTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetAndAddIntTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndAddIntTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetAndAddIntTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetAndAddIntTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetAndAddIntTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        int result2;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie35.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie35();
+            result = unsafe.getAndAddInt(obj, offset, 20);
+//            System.out.println(result);
+            result2 = unsafe.getInt(obj, offset);
+//            System.out.println(result2);
+            if (result == 8 && result2 == 28) {
+                UnsafegetAndAddIntTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie35 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/UnsafegetAndAddLongTest.java b/test/testsuite/ouroboros/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/UnsafegetAndAddLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..20415097335c81b9748ef5c04fafec6546b8dd95
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/UnsafegetAndAddLongTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetAndAddIntTest
+ * -@TestCaseName: Unsafe api: getAndAddInt()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare Field weight = 100L(long type)
+ * -#step2:invoke Unsafe.getAndAddLong to add one value
+ * -#step3:check the Field,add success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetAndAddLongTest.java
+ * -@ExecuteClass: UnsafegetAndAddLongTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetAndAddLongTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndAddLongTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetAndAddLongTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetAndAddLongTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetAndAddLongTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        long result;
+        long result2;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie37.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie37();
+            result = unsafe.getAndAddLong(obj, offset, 1L);
+//            System.out.println(result);
+            result2 = unsafe.getLong(obj, offset);
+//            System.out.println(result2);
+            if (result == 100 && result2 == 101) {
+                UnsafegetAndAddLongTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie37 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/UnsafegetAndSetIntTest.java b/test/testsuite/ouroboros/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/UnsafegetAndSetIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8265666675fd695cb9ece1335f8ca4e62e91dc17
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/UnsafegetAndSetIntTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetAndSetIntTest
+ * -@TestCaseName: Unsafe api: getAndSetInt()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare Field height = 8(int type)
+ * -#step2:invoke Unsafe.getAndSetInt to set another value
+ * -#step3:check the Field,modify success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetAndSetIntTest.java
+ * -@ExecuteClass: UnsafegetAndSetIntTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafegetAndSetIntTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndSetIntTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetAndSetIntTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetAndSetIntTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetAndSetIntTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        int result2;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie36.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie36();
+            result = unsafe.getAndSetInt(obj, offset, 20);
+//            System.out.println(result);
+            result2 = unsafe.getInt(obj, offset);
+//            System.out.println(result2);
+            if (result == 8 && result2 == 20) {
+                UnsafegetAndSetIntTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie36 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/UnsafegetAndSetLongTest.java b/test/testsuite/ouroboros/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/UnsafegetAndSetLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f902b7a5779b6d0f0f00c9d5ca318d4712a485bf
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/UnsafegetAndSetLongTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetAndSetLongTest
+ * -@TestCaseName: Unsafe api: getAndSetLong()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare Field weight = 100L(Long type)
+ * -#step2:invoke Unsafe.getAndSetLong to set another value
+ * -#step3:check the Field,modify success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetAndSetLongTest.java
+ * -@ExecuteClass: UnsafegetAndSetLongTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafegetAndSetLongTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndSetLongTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetAndSetLongTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetAndSetLongTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetAndSetLongTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        long result;
+        long result2;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie38.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie38();
+            result = unsafe.getAndSetLong(obj, offset, 99L);
+//            System.out.println(result);
+            result2 = unsafe.getInt(obj, offset);
+//            System.out.println(result2);
+            if (result == 100 && result2 == 99) {
+                UnsafegetAndSetLongTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie38 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/UnsafegetAndSetObjectTest.java b/test/testsuite/ouroboros/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/UnsafegetAndSetObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..553b87e03b5e0bb844e55953b2464ec8b0416c32
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/UnsafegetAndSetObjectTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetAndSetObjectTest
+ * -@TestCaseName: Unsafe api: getAndSetObject()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare Field private String owner = "Me"(Object type)
+ * -#step2:invoke Unsafe.getAndSetObject to add another value
+ * -#step3:check the Field,modify success
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetAndSetObjectTest.java
+ * -@ExecuteClass: UnsafegetAndSetObjectTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafegetAndSetObjectTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndSetObjectTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetAndSetObjectTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetAndSetObjectTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetAndSetObjectTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        Object result2;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie39.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie39();
+            result = unsafe.getAndSetObject(obj, offset, "she");
+//            System.out.println(result);
+            result2 = unsafe.getObject(obj, offset);
+//            System.out.println(result2);
+            if (result.equals("Me") && result2.equals("she")) {
+                UnsafegetAndSetObjectTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie39 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/UnsafegetBooleanTest.java b/test/testsuite/ouroboros/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/UnsafegetBooleanTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..61a1e6afe469769e00a88477febff81c94032cfa
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/UnsafegetBooleanTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetBooleanTest
+ * -@TestCaseName: Unsafe api: getBoolean()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Boolean
+ * -#step2:invoke Unsafe.getBoolean to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetBooleanTest.java
+ * -@ExecuteClass: UnsafegetBooleanTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetBooleanTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetBooleanTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetBooleanTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetBooleanTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetBooleanTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        boolean result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie21.class.getDeclaredField("gender");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie21();
+            result = unsafe.getBoolean(obj, offset);
+            if (!result) {
+                UnsafegetBooleanTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie21 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/UnsafegetCharByAddressTest.java b/test/testsuite/ouroboros/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/UnsafegetCharByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..792aa83ddcacbd245d1827879c86f6d11bb7b146
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/UnsafegetCharByAddressTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetCharByAddressTest
+ * -@TestCaseName: Unsafe api: getChar(address)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:allocateMemory for one Field of Char
+ * -#step2:set value of Field from step1
+ * -#step3:invoke Unsafe.getChar(address) to visit this Field
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetCharByAddressTest.java
+ * -@ExecuteClass: UnsafegetCharByAddressTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafegetCharByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetCharByAddressTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetCharByAddressTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetCharByAddressTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetCharByAddressTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        char result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(2);
+//            System.out.println(address);
+            char c = 'a';
+            unsafe.putChar(address, c);
+            result = unsafe.getChar(address);
+//            System.out.println(result);
+            if (result == c) {
+                UnsafegetCharByAddressTest.res -= 2;
+            }
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/UnsafegetCharTest.java b/test/testsuite/ouroboros/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/UnsafegetCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..3bbce8a7a3192ba3c027b8a85966456d8e0cd5e1
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/UnsafegetCharTest.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetCharTest
+ * -@TestCaseName: Unsafe api: getChar()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Char
+ * -#step2:invoke Unsafe.getChar to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetCharTest.java
+ * -@ExecuteClass: UnsafegetCharTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetCharTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetCharTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetCharTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetCharTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetCharTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        char result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie25.class.getDeclaredField("favorite");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie25();
+            result = unsafe.getChar(obj, offset);
+            if (result == '7') {
+                UnsafegetCharTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie25 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/UnsafegetDoubleByAddressTest.java b/test/testsuite/ouroboros/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/UnsafegetDoubleByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..111e030e41927f7571d8c8dad28fb158e189e5b8
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/UnsafegetDoubleByAddressTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetDoubleByAddressTest
+ * -@TestCaseName: Unsafe api:  getDouble(address)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:allocateMemory for one Field of Double
+ * -#step2:set value of Field from step1
+ * -#step3:invoke Unsafe.getDouble(address) to visit this Field
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetDoubleByAddressTest.java
+ * -@ExecuteClass: UnsafegetDoubleByAddressTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafegetDoubleByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetDoubleByAddressTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetDoubleByAddressTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetDoubleByAddressTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetDoubleByAddressTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        double result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(2);
+//            System.out.println(address);
+            double d = 111;
+            unsafe.putDouble(address, d);
+            result = unsafe.getDouble(address);
+//            System.out.println(result);
+            if (result == d) {
+                UnsafegetDoubleByAddressTest.res -= 2;
+            }
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/UnsafegetDoubleTest.java b/test/testsuite/ouroboros/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/UnsafegetDoubleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd29428ce72b0af6b0da976f0141b07a9e82c17a
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/UnsafegetDoubleTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetDoubleTest
+ * -@TestCaseName: Unsafe api: getDouble()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Double
+ * -#step2:invoke Unsafe.getDouble to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetDoubleTest.java
+ * -@ExecuteClass: UnsafegetDoubleTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetDoubleTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetDoubleTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetDoubleTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetDoubleTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetDoubleTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        double result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie29.class.getDeclaredField("grade");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie29();
+            result = unsafe.getDouble(obj, offset);
+            if (result == 99.99) {
+                UnsafegetDoubleTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie29 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/UnsafegetFloatByAddressTest.java b/test/testsuite/ouroboros/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/UnsafegetFloatByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..04458c9ec88bb12adc58026792d6b226a56b9ff0
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/UnsafegetFloatByAddressTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetFloatByAddressTest
+ * -@TestCaseName: Unsafe api:  getFloat(Address)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:allocateMemory for one Field of Float
+ * -#step2:set value of Field from step1
+ * -#step3:invoke Unsafe.getFloat(address) to visit this Field
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetFloatByAddressTest.java
+ * -@ExecuteClass: UnsafegetFloatByAddressTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafegetFloatByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetFloatByAddressTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetFloatByAddressTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetFloatByAddressTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetFloatByAddressTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        float result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(2);
+//            System.out.println(address);
+            float f = 111f;
+            unsafe.putFloat(address, f);
+            result = unsafe.getFloat(address);
+//            System.out.println(result);
+            if (result == f) {
+                UnsafegetFloatByAddressTest.res -= 2;
+            }
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/UnsafegetFloatTest.java b/test/testsuite/ouroboros/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/UnsafegetFloatTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..75e17f02030b5f5b24069246cf8fe9993c7aa715
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/UnsafegetFloatTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetFloatTest
+ * -@TestCaseName: Unsafe api: getFloat()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Float
+ * -#step2:invoke Unsafe.getFloat to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetFloatTest.java
+ * -@ExecuteClass: UnsafegetFloatTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetFloatTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetFloatTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetFloatTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetFloatTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetFloatTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Float result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie31.class.getDeclaredField("aFloat");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie31();
+            result = unsafe.getFloat(obj, offset);
+            if (result == 66.66f) {
+                UnsafegetFloatTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie31 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/UnsafegetIntByAddressTest.java b/test/testsuite/ouroboros/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/UnsafegetIntByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..675d69c45138de2569b9a4dbee02e2e55331858b
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/UnsafegetIntByAddressTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetIntByAddressTest
+ * -@TestCaseName: Unsafe api:  getInt(address)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:allocateMemory for one Int of Char
+ * -#step2:set value of Field from step1
+ * -#step3:invoke Unsafe.getInt(address) to visit this Field
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetIntByAddressTest.java
+ * -@ExecuteClass: UnsafegetIntByAddressTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafegetIntByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetIntByAddressTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetIntByAddressTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetIntByAddressTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetIntByAddressTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        int result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(2);
+//            System.out.println(address);
+            int i = 111;
+            unsafe.putInt(address, i);
+            result = unsafe.getInt(address);
+//            System.out.println(result);
+            if (result == i) {
+                UnsafegetIntByAddressTest.res -= 2;
+            }
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/UnsafegetIntTest.java b/test/testsuite/ouroboros/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/UnsafegetIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a6882c0ff937ce096c9e082ffd24be2bc2866cd1
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/UnsafegetIntTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetIntTest
+ * -@TestCaseName: Unsafe api: getInt()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Int
+ * -#step2:invoke Unsafe.getInt to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetIntTest.java
+ * -@ExecuteClass: UnsafegetIntTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetIntTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetIntTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetIntTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetIntTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetIntTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie12.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie12();
+            result = unsafe.getInt(obj, offset);
+            if (result == 8) {
+                UnsafegetIntTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie12 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/UnsafegetLongTest.java b/test/testsuite/ouroboros/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/UnsafegetLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f2739505379a37543c4f507c0e204b013174988
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/UnsafegetLongTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetLongTest
+ * -@TestCaseName: Unsafe api: getLong()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Long
+ * -#step2:invoke Unsafe.getLong to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetLongTest.java
+ * -@ExecuteClass: UnsafegetLongTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetLongTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetLongTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetLongTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetLongTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetLongTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Long result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie15.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie15();
+            result = unsafe.getLong(obj, offset);
+            if (result == 100L) {
+                UnsafegetLongTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie15 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/UnsafegetLongVolatileTest.java b/test/testsuite/ouroboros/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/UnsafegetLongVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..55981b04b682184f7a882dbdad3c80af1bc216a8
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/UnsafegetLongVolatileTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetLongVolatileTest
+ * -@TestCaseName: Unsafe api: getLongvolatile()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Volatile&Long
+ * -#step2:invoke Unsafe.getLong to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetLongVolatileTest.java
+ * -@ExecuteClass: UnsafegetLongVolatileTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetLongVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetLongVolatileTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetLongVolatileTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetLongVolatileTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetLongVolatileTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Long result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie8.class.getDeclaredField("birth");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie8();
+            result = unsafe.getLongVolatile(obj, offset);
+            if (result == 20010214L) {
+                UnsafegetLongVolatileTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie8 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/UnsafegetObjectTest.java b/test/testsuite/ouroboros/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/UnsafegetObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..39baf9e047ddedcab022e008f721d8f5f0fed255
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/UnsafegetObjectTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetObjectTest
+ * -@TestCaseName: Unsafe api: getObject()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Object
+ * -#step2:invoke Unsafe.getObject to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetObjectTest.java
+ * -@ExecuteClass: UnsafegetObjectTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetObjectTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetObjectTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetObjectTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetObjectTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie18.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie18();
+            result = unsafe.getObject(obj, offset);
+            if (result.equals("Me")) {
+                UnsafegetObjectTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie18 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/UnsafegetObjectVolatileTest.java b/test/testsuite/ouroboros/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/UnsafegetObjectVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..45c2ff1e38a952fdf103614b50ee853821604f1d
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/UnsafegetObjectVolatileTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetObjectVolatileTest
+ * -@TestCaseName: Unsafe api: getObjectvolatile()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Volatile&Object
+ * -#step2:invoke Unsafe.getObject to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetObjectVolatileTest.java
+ * -@ExecuteClass: UnsafegetObjectVolatileTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetObjectVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectVolatileTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetObjectVolatileTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetObjectVolatileTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetObjectVolatileTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie10.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie10();
+            result = unsafe.getObjectVolatile(obj, offset);
+            if (result.equals("eilish")) {
+                UnsafegetObjectVolatileTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie10 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/UnsafegetShortByAddressTest.java b/test/testsuite/ouroboros/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/UnsafegetShortByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c80c7f7372c3e6ec616411e6122a432b22f4dd87
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/UnsafegetShortByAddressTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetShortByAddressTest
+ * -@TestCaseName: Unsafe api: getShort(address)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:allocateMemory for one Field of Short
+ * -#step2:set value of Field from step1
+ * -#step3:invoke Unsafe.getShort(address) to visit this Field
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetShortByAddressTest.java
+ * -@ExecuteClass: UnsafegetShortByAddressTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafegetShortByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetShortByAddressTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetShortByAddressTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetShortByAddressTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetShortByAddressTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        short result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(2);
+//            System.out.println(address);
+            short s = 1;
+            unsafe.putShort(address, s);
+            result = unsafe.getShort(address);
+//            System.out.println(result);
+            if (result == s) {
+                UnsafegetShortByAddressTest.res -= 2;
+            }
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/UnsafegetShortTest.java b/test/testsuite/ouroboros/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/UnsafegetShortTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e51275c476beee81990af19d8df72b7ebb05b46e
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/UnsafegetShortTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetShortTest
+ * -@TestCaseName: Unsafe api: getShort()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Short
+ * -#step2:invoke Unsafe.getShort to visit this Field
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetShortTest.java
+ * -@ExecuteClass: UnsafegetShortTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetShortTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetShortTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetShortTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetShortTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetShortTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        short result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie27.class.getDeclaredField("date");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie27();
+            result = unsafe.getShort(obj, offset);
+            if (result == 6) {
+                UnsafegetShortTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie27 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/UnsafeobjectFieldOffeset.java b/test/testsuite/ouroboros/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/UnsafeobjectFieldOffeset.java
new file mode 100644
index 0000000000000000000000000000000000000000..b06ae37a496dbc7153b84f74bfc06d4d472ce76d
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/UnsafeobjectFieldOffeset.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeobjectFieldOffeset
+ * -@TestCaseName: Unsafe api: objectFieldOffset()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:Prepare Object
+ * -#step2:get offset by Unsafe.objectFieldOffset()
+ * -#step3:check return value from step2,compare step1
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeobjectFieldOffeset.java
+ * -@ExecuteClass: UnsafeobjectFieldOffeset
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeobjectFieldOffeset {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeobjectFieldOffsetTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeobjectFieldOffeset.res = UnsafeobjectFieldOffeset.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafeobjectFieldOffeset.res);
+        if (result == 3 && UnsafeobjectFieldOffeset.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeobjectFieldOffsetTest_1() {
+        Unsafe unsafe;
+        Object obj = new Billie();
+        Field field;
+        Field param1;
+        String result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            param1 = obj.getClass().getDeclaredField("owner");
+            long offset = unsafe.objectFieldOffset(param1);
+//            System.out.println(offset);
+//            System.out.println(unsafe.getObject(obj, offset));
+            result = (String)unsafe.getObject(obj, offset);
+//            System.out.println(result);
+            if (result.equals("Me")) {
+                UnsafeobjectFieldOffeset.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+
+}
+
+class Billie {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/UnsafeputBooleanTest.java b/test/testsuite/ouroboros/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/UnsafeputBooleanTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f4b2a1b08deb1864f05e0ececcce26b8e3415ce
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/UnsafeputBooleanTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputBooleanTest
+ * -@TestCaseName: Unsafe api: putBoolean()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Boolean
+ * -#step2:invoke Unsafe.getBoolean to visit this Field
+ * -#step3:set value of step2 by Unsafe.putBoolean
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputBooleanTest.java
+ * -@ExecuteClass: UnsafeputBooleanTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafeputBooleanTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputBooleanTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputBooleanTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputBooleanTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputBooleanTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        boolean result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie22.class.getDeclaredField("gender");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie22();
+            result = unsafe.getBoolean(obj, offset);
+            unsafe.putBoolean(obj, offset, true);
+            result = unsafe.getBoolean(obj, offset);
+            if (result) {
+                UnsafeputBooleanTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie22 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/UnsafeputByteByAddressTest.java b/test/testsuite/ouroboros/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/UnsafeputByteByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..98e9f99a38b7209f35f38b28efc1ea62c7486790
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/UnsafeputByteByAddressTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputByteByAddressTest
+ * -@TestCaseName: Unsafe api: putByte(Address)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:allocateMemory for one Field of Byte
+ * -#step2:set value of step2 by Unsafe.putByte
+ * -#step3:check value after step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputByteByAddressTest.java
+ * -@ExecuteClass: UnsafeputByteByAddressTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeputByteByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputByteByAddressTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputByteByAddressTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputByteByAddressTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputByteByAddressTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        byte result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            byte b = 127;
+            unsafe.putByte(address, b);
+            result = unsafe.getByte(address);
+//            System.out.println(result);
+            if (result == b) {
+                UnsafeputByteByAddressTest.res -= 2;
+            }
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/UnsafeputByteTest.java b/test/testsuite/ouroboros/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/UnsafeputByteTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c407199ec3d514a5fd67b73a44b7f856391a2c8
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/UnsafeputByteTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputByteTest
+ * -@TestCaseName: Unsafe api: putByten()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Byte
+ * -#step2:invoke Unsafe.getByte to visit this Field
+ * -#step3:set value of step2 by Unsafe.putByte
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputByteTest.java
+ * -@ExecuteClass: UnsafeputByteTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafeputByteTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputByteTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputByteTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputByteTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputByteTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        byte result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie24.class.getDeclaredField("length");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie24();
+            result = unsafe.getByte(obj, offset);
+            byte b = 12;
+            unsafe.putByte(obj, offset, b);
+            result = unsafe.getByte(obj, offset);
+            if (result == 12) {
+                UnsafeputByteTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie24 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/UnsafeputCharTest.java b/test/testsuite/ouroboros/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/UnsafeputCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a219ba24811ac6a6751cb8db77f254ef3b270c91
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/UnsafeputCharTest.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputCharTest
+ * -@TestCaseName: Unsafe api: putChar()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Char
+ * -#step2:invoke Unsafe.getChar to visit this Field
+ * -#step3:set value of step2 by Unsafe.putChar
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputCharTest.java
+ * -@ExecuteClass: UnsafeputCharTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafeputCharTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputCharTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputCharTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputCharTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputCharTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        char result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie26.class.getDeclaredField("favorite");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie26();
+            result = unsafe.getChar(obj, offset);
+            unsafe.putChar(obj, offset, 's');
+            result = unsafe.getChar(obj, offset);
+            if (result == 's') {
+                UnsafeputCharTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie26 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/UnsafeputDoubleTest.java b/test/testsuite/ouroboros/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/UnsafeputDoubleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a60dcc1cfddab769032d5a0e0a65e3cf37e41588
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/UnsafeputDoubleTest.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputDoubleTest
+ * -@TestCaseName: Unsafe api: putDouble()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Double
+ * -#step2:invoke Unsafe.getDouble to visit this Field
+ * -#step3:set value of step2 by Unsafe.putDouble
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputDoubleTest.java
+ * -@ExecuteClass: UnsafeputDoubleTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafeputDoubleTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputDoubleTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputDoubleTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputDoubleTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputDoubleTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        double result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie30.class.getDeclaredField("grade");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie30();
+            result = unsafe.getDouble(obj, offset);
+            double d = 11.11;
+            unsafe.putDouble(obj, offset, d);
+            result = unsafe.getDouble(obj, offset);
+            if (result == d) {
+                UnsafeputDoubleTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie30 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/UnsafeputFloatTest.java b/test/testsuite/ouroboros/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/UnsafeputFloatTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ab5cebd8999336f8474ecdfbd294c2de448c6f9
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/UnsafeputFloatTest.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputFloatTest
+ * -@TestCaseName: Unsafe api: putFloat()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Float
+ * -#step2:invoke Unsafe.getFloat to visit this Field
+ * -#step3:set value of step2 by Unsafe.putFloat
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputFloatTest.java
+ * -@ExecuteClass: UnsafeputFloatTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafeputFloatTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputFloatTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputFloatTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputFloatTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputFloatTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Float result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie32.class.getDeclaredField("aFloat");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie32();
+            result = unsafe.getFloat(obj, offset);
+            unsafe.putFloat(obj, offset, 11.11f);
+            result = unsafe.getFloat(obj, offset);
+            if (result == 11.11f) {
+                UnsafeputFloatTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie32 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/UnsafeputIntTest.java b/test/testsuite/ouroboros/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/UnsafeputIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2019ccdcd8ab05b25f51f5b0b8389abe01f27a78
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/UnsafeputIntTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputIntTest
+ * -@TestCaseName: Unsafe api: putInt()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Int
+ * -#step2:invoke Unsafe.getInt to visit this Field
+ * -#step3:set value of step2 by Unsafe.putInt
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputIntTest.java
+ * -@ExecuteClass: UnsafeputIntTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeputIntTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputIntTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputIntTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputIntTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputIntTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie13.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie13();
+            result = unsafe.getInt(obj, offset);
+            unsafe.putInt(obj, offset, 10);
+            result = unsafe.getInt(obj,offset);
+            if (result == 10) {
+                UnsafeputIntTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie13 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/UnsafeputIntVolatileTest.java b/test/testsuite/ouroboros/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/UnsafeputIntVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e886a0f66f1280181dc4760b4f3047eb3fd82f8
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/UnsafeputIntVolatileTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputIntVolatileTest
+ * -@TestCaseName: Unsafe api: putIntvolatile()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Volatile Int
+ * -#step2:invoke Unsafe.getIntVolatile to visit this Field
+ * -#step3:set value of step2 by Unsafe.putIntVolatile
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputIntVolatileTest.java
+ * -@ExecuteClass: UnsafeputIntVolatileTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.TreeSet;
+
+public class UnsafeputIntVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputIntVolatileTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputIntVolatileTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputIntVolatileTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+
+    private static int UnsafeputIntVolatileTest_1()  {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie7.class.getDeclaredField("age");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie7();
+            result = unsafe.getIntVolatile(obj, offset);
+            unsafe.putIntVolatile(obj, offset, 20);
+            result = unsafe.getIntVolatile(obj, offset);
+            if (result == 20) {
+                UnsafeputIntVolatileTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie7 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/UnsafeputLongTest.java b/test/testsuite/ouroboros/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/UnsafeputLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d2e418eb3f8914743da8cf1f6a0da02b06f1ed5
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/UnsafeputLongTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputLongTest
+ * -@TestCaseName: Unsafe api: putLong()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:allocateMemory for one Field of Long
+ * -#step2:set value of step2 by Unsafe.putLong
+ * -#step3:check value after step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputLongTest.java
+ * -@ExecuteClass: UnsafeputLongTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeputLongTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputLongTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputLongTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputLongTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputLongTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        long result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie16.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie16();
+            result = unsafe.getLong(obj, offset);
+            unsafe.putLong(obj, offset, 200L);
+            result = unsafe.getLong(obj,offset);
+            if (result == 200L) {
+                UnsafeputLongTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie16 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/UnsafeputLongVolatileTest.java b/test/testsuite/ouroboros/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/UnsafeputLongVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf073b72b4206e8a326ca08218ff050e4d8dadbc
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/UnsafeputLongVolatileTest.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputLongVolatileTest
+ * -@TestCaseName: Unsafe api: putLongvolatile()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Long
+ * -#step2:invoke Unsafe.getVolatileLong to visit this Field
+ * -#step3:set value of step2 by Unsafe.putVolatileLong
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputLongVolatileTest.java
+ * -@ExecuteClass: UnsafeputLongVolatileTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafeputLongVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputLongVolatileTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputLongVolatileTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputLongVolatileTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputLongVolatileTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Long result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie9.class.getDeclaredField("birth");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie9();
+            result = unsafe.getLongVolatile(obj, offset);
+            unsafe.putLongVolatile(obj, offset, 20020214L);
+            result = unsafe.getLongVolatile(obj, offset);
+            if (result == 20020214L) {
+                UnsafeputLongVolatileTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie9 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/UnsafeputObjectTest.java b/test/testsuite/ouroboros/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/UnsafeputObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f13906b7b248efb16935a251690f695e269c7d7
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/UnsafeputObjectTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputObjectTest
+ * -@TestCaseName: Unsafe api: putObject()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Object
+ * -#step2:invoke Unsafe.getObject to visit this Field
+ * -#step3:set value of step2 by Unsafe.putObject
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputObjectTest.java
+ * -@ExecuteClass: UnsafeputObjectTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeputObjectTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputObjectTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputObjectTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputObjectTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie19.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie19();
+            result = unsafe.getObject(obj, offset);
+            unsafe.putObject(obj, offset, "she");
+            result = unsafe.getObject(obj,offset);
+            if (result.equals("she")) {
+                UnsafeputObjectTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie19 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/UnsafeputObjectVolatileTest.java b/test/testsuite/ouroboros/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/UnsafeputObjectVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c8228e64b8928d80d39a827132dd398cb42ed09
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/UnsafeputObjectVolatileTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputObjectVolatileTest
+ * -@TestCaseName: Unsafe api: putLongvolatile()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Object
+ * -#step2:invoke Unsafe.getVolatileObject to visit this Field
+ * -#step3:set value of step2 by Unsafe.putVolatileObject
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputObjectVolatileTest.java
+ * -@ExecuteClass: UnsafeputObjectVolatileTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeputObjectVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectVolatileTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputObjectVolatileTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputObjectVolatileTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputObjectVolatileTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie11.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie11();
+            result = unsafe.getObjectVolatile(obj, offset);
+            unsafe.putObjectVolatile(obj, offset, "Eilish");
+            result = unsafe.getObjectVolatile(obj, offset);
+            if (result.equals("Eilish")) {
+                UnsafeputObjectVolatileTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie11 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/UnsafeputOrderedIntTest.java b/test/testsuite/ouroboros/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/UnsafeputOrderedIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..583cfa935ccf2f1a84a7fe2d20915fd22c5a4cca
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/UnsafeputOrderedIntTest.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputOrderedIntTest
+ * -@TestCaseName: Unsafe api: putOrderedInt()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Int
+ * -#step2:invoke Unsafe.getInt to visit this Field
+ * -#step3:set value of step2 by Unsafe.putOrderedInt
+ * -#step4:check value of step3 immediately,the value may not be changed as step3
+ * -#step5:check value of step3 after seconds,the value should be changed as step3
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputOrderedIntTest.java
+ * -@ExecuteClass: UnsafeputOrderedIntTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeputOrderedIntTest {
+    private static int res = 99;
+    private static Object obj = new Object();
+    private static Long offset =0l;
+    private static int flag =0;
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) throws InterruptedException {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputOrderedIntTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputOrderedIntTest.res -= 2;
+        }
+//        System.out.println(flag);
+        if (flag==0) {
+//            System.out.println("It is true");
+        }
+        Thread.sleep(4000);
+//        System.out.println(flag);
+//        System.out.println("result:" +result);
+//        System.out.println("res: "+ res);
+        if (result == 3 && UnsafeputOrderedIntTest.flag == 10) {
+            result = 0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputOrderedIntTest_1() {
+        int result = 3;
+        Field field;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            Unsafe unsafe = (Unsafe)field.get(null);
+            Thread boyThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    Field param = null;
+                    try {
+                        param = Billie14.class.getDeclaredField("height");
+                    } catch (NoSuchFieldException e) {
+                        e.printStackTrace();
+                    }
+                    offset = unsafe.objectFieldOffset(param);
+                    obj = new Billie14();
+                    unsafe.putOrderedInt(obj, offset, 10);
+                }
+            });
+
+            Thread girlThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    int result;
+                    flag = unsafe.getInt(obj,offset);
+//                    System.out.println("======================="+flag);
+                    try {
+                        Thread.sleep(3000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    flag = unsafe.getInt(obj,offset);
+//                    System.out.println("======================="+flag);
+                }
+            });
+            boyThread.start();
+            girlThread.start();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 40;
+        }
+        return result;
+    }
+}
+
+class Billie14 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/UnsafeputOrderedLongTest.java b/test/testsuite/ouroboros/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/UnsafeputOrderedLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..51baa00bf6897995bb58c1b2479ce299ed781e76
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/UnsafeputOrderedLongTest.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputLongTest
+ * -@TestCaseName: Unsafe api: putLong()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Long
+ * -#step2:invoke Unsafe.getLong to visit this Field
+ * -#step3:set value of step2 by Unsafe.putOrderedLong
+ * -#step4:check value of step3 immediately,the value may not be changed as step3
+ * -#step5:check value of step3 after seconds,the value should be changed as step3
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputOrderedLongTest.java
+ * -@ExecuteClass: UnsafeputOrderedLongTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeputOrderedLongTest {
+    private static int res = 99;
+    private static Object obj = new Object();
+    private static Long offset =0l;
+    private static long flag =0l;
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) throws InterruptedException {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputOrderedLongTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputOrderedLongTest.res -= 2;
+        }
+//        System.out.println(flag);
+        if (flag==0) {
+//            System.out.println("It is true");
+        }
+        Thread.sleep(4000);
+//        System.out.println(flag);
+//        System.out.println("result:" +result);
+//        System.out.println("res: "+ res);
+        if (result == 3 && UnsafeputOrderedLongTest.flag == 200L) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputOrderedLongTest_1() {
+        int result =3;
+        Field field;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            Unsafe unsafe = (Unsafe)field.get(null);
+            Thread boyThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    Field param = null;
+                    try {
+                        param = Billie17.class.getDeclaredField("weight");
+                    } catch (NoSuchFieldException e) {
+                        e.printStackTrace();
+                    }
+                    offset = unsafe.objectFieldOffset(param);
+                    obj = new Billie17();
+                    unsafe.putOrderedLong(obj, offset, 200L);
+                }
+            });
+
+            Thread girlThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    int result;
+                    flag = unsafe.getLong(obj,offset);
+//                    System.out.println("======================="+flag);
+                    try {
+                        Thread.sleep(3000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    flag = unsafe.getLong(obj,offset);
+//                    System.out.println("======================="+flag);
+                }
+            });
+            boyThread.start();
+            girlThread.start();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 40;
+        }
+        return 3;
+    }
+}
+
+class Billie17 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/UnsafeputOrderedObjectTest.java b/test/testsuite/ouroboros/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/UnsafeputOrderedObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..24b9720829e64966a6566b2b91c48b3d50bb8b3a
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/UnsafeputOrderedObjectTest.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputOrderedObjectTest
+ * -@TestCaseName: Unsafe api: putOrderedObject()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Object
+ * -#step2:invoke Unsafe.getObject to visit this Field
+ * -#step3:set value of step2 by Unsafe.putOrderedObject
+ * -#step4:check value of step3 immediately,the value may not be changed as step3
+ * -#step5:check value of step3 after seconds,the value should be changed as step3
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputOrderedObjectTest.java
+ * -@ExecuteClass: UnsafeputOrderedObjectTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeputOrderedObjectTest {
+    private static int res = 99;
+    private static Object obj = new Object();
+    private static Long offset =0l;
+    private static Object flag = new Object();
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) throws InterruptedException {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputOrderedObjectTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputOrderedObjectTest.res -= 2;
+        }
+//        System.out.println(flag.toString());
+        if (flag.equals("")) {
+//            System.out.println("It is true");
+        }
+        Thread.sleep(4000);
+//        System.out.println(flag.toString());
+//        System.out.println("result:" +result);
+//        System.out.println("res: "+ res);
+        if (result == 3 && UnsafeputOrderedObjectTest.flag.equals("Yours")) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeputOrderedObjectTest_1() {
+        int result =3;
+        Field field;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            Unsafe unsafe = (Unsafe)field.get(null);
+            Thread boyThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    Field param = null;
+                    try {
+                        param = Billie20.class.getDeclaredField("owner");
+                    } catch (NoSuchFieldException e) {
+                        e.printStackTrace();
+                    }
+                    offset = unsafe.objectFieldOffset(param);
+                    obj = new Billie20();
+                    unsafe.putOrderedObject(obj, offset, "Yours");
+                }
+            });
+
+            Thread girlThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    int result;
+                    flag = unsafe.getObject(obj,offset);
+//                    System.out.println("======================="+flag);
+                    try {
+                        Thread.sleep(3000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    flag = unsafe.getObject(obj,offset);
+//                    System.out.println("======================="+flag);
+                }
+            });
+            boyThread.start();
+            girlThread.start();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 40;
+        }
+        return 3;
+    }
+}
+
+class Billie20 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/UnsafeputShortTest.java b/test/testsuite/ouroboros/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/UnsafeputShortTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b41ae22c21fe1331f19535d0fb63409af531ff85
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/UnsafeputShortTest.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeputShortTest
+ * -@TestCaseName: Unsafe api: putShort()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get Field of Short
+ * -#step2:invoke Unsafe.getShort to visit this Field
+ * -#step3:set value of step2 by Unsafe.putShort
+ * -#step4:check value of step3 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeputShortTest.java
+ * -@ExecuteClass: UnsafeputShortTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafeputShortTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetShortTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeputShortTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafeputShortTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetShortTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        short result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie28.class.getDeclaredField("date");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie28();
+            result = unsafe.getShort(obj, offset);
+            short s = 10;
+            unsafe.putShort(obj, offset, s);
+            result = unsafe.getShort(obj, offset);
+            if (result == 10) {
+                UnsafeputShortTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie28 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/UnsafesetMemoryTest.java b/test/testsuite/ouroboros/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/UnsafesetMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..81ba493147d06abf81fecd4cd53c63979d756b70
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/UnsafesetMemoryTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafesetMemoryTest
+ * -@TestCaseName: Unsafe api: setMemory()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:allocateMemory for one Field
+ * -#step2:set value at step1 by Unsafe.setMemory
+ * -#step3:check value after ste2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafesetMemoryTest.java
+ * -@ExecuteClass: UnsafesetMemoryTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafesetMemoryTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafesetMemoryTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafesetMemoryTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafesetMemoryTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafesetMemoryTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        byte result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            byte b = 127;
+            unsafe.setMemory(address, 4L, b);
+            result = unsafe.getByte(address);
+//            System.out.println(result);
+            if (result == b) {
+                UnsafesetMemoryTest.res -= 2;
+            }
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/UnsafegetByteTest.java b/test/testsuite/ouroboros/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/UnsafegetByteTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..67aac7ab8df2a24c09550759450260e9e9cb2ed3
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/UnsafegetByteTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetByteTest
+ * -@TestCaseName: Test Unsafe api: getByte()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare one Class and get this FieldOffset
+ * -#step2:invoke Unsafe.getByte to get value from FieldOffset
+ * -#step3:check value of step2 correct
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetByteTest.java
+ * -@ExecuteClass: UnsafegetByteTest
+ * -@ExecuteArgs:
+ */
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class UnsafegetByteTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetByteTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetByteTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetByteTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetByteTest_1() {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        byte result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie23.class.getDeclaredField("length");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie23();
+            result = unsafe.getByte(obj, offset);
+            if (result == 7) {
+                UnsafegetByteTest.res -= 2;
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+class Billie23 {
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/UnsafegetLongByAddressTest.java b/test/testsuite/ouroboros/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/UnsafegetLongByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..da27f4202eca37be4be68a860f3434a587f0ba3e
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/UnsafegetLongByAddressTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafegetShortByAddressTest
+ * -@TestCaseName: Unsafe api:  getLong(long)
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:prepare address from unsafe.allocateMemory,and put long number
+ * -#step2:invoke unsafe.getLong(address)
+ * -#step3:check return from step2 as step1
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafegetLongByAddressTest.java
+ * -@ExecuteClass: UnsafegetLongByAddressTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafegetLongByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetLongByAddressTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafegetLongByAddressTest.res -= 2;
+        }
+
+        if (result == 3 && UnsafegetLongByAddressTest.res == 97) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafegetLongByAddressTest_1() {
+        Unsafe unsafe;
+        Field field;
+        long address;
+        long result;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(2);
+//            System.out.println(address);
+            long l = 111L;
+            unsafe.putLong(address, l);
+            result = unsafe.getLong(address);
+//            System.out.println(result);
+            if (result == l) {
+                UnsafegetLongByAddressTest.res -= 2;
+            }
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return 40;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/ouroboros/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/UnsafeunparkTest.java b/test/testsuite/ouroboros/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/UnsafeunparkTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..934d2445e19345689fb171133a679d2358365800
--- /dev/null
+++ b/test/testsuite/ouroboros/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/UnsafeunparkTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * -@TestCaseID: UnsafeunparkTest
+ * -@TestCaseName: Unsafe api: unpark()
+ * -@TestCaseType: Function Test
+ * -@RequirementName: VMRuntime_registerNativeAllocation接口实现
+ * -@Brief:
+ * -#step1:threa1 park
+ * -#step2:thread2 to unpark thread1
+ * -#step3:thread1 go on excute
+ * -@Expect:0\n
+ * -@Priority: High
+ * -@Source: UnsafeunparkTest.java
+ * -@ExecuteClass: UnsafeunparkTest
+ * -@ExecuteArgs:
+ */
+
+import sun.misc.Unsafe;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+
+public class UnsafeunparkTest {
+    private static int res = 99;
+    private static int flag = 0;
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println(run(args, System.out));
+    }
+
+    private static int run(String[] args, PrintStream out) throws InterruptedException {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeunparkTest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            UnsafeunparkTest.res -= 2;
+        }
+        Thread.sleep(4000);
+//        System.out.println("===================="+flag);
+        if (result == 3 && UnsafeunparkTest.flag == 1214210) {
+            result =0;
+        }
+        return result;
+    }
+
+    private static int UnsafeunparkTest_1() {
+        int result = 3;
+        Field field;
+        try {
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            Unsafe unsafe = (Unsafe)field.get(null);
+            Thread boyThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+//                    System.out.println("boy: 我要吃鸡");
+                    flag += (flag+1)*10;
+//                    System.out.println(flag);
+                    unsafe.park(false,0);
+//                    System.out.println("boy: park1");
+                    flag += (flag+3)*1000;
+//                    System.out.println(flag);
+//                    unsafe.park(false,0); // 第二次会阻塞住，因为只有一个permit
+//                    System.out.println("boy: park2");
+//                    System.out.println("boy: 不会再执行了");
+                }
+            });
+
+            Thread girlThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        Thread.sleep(3000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+//                    System.out.println("girl: OK");
+                    flag += (flag+2)*100;
+//                    System.out.println(flag);
+                    unsafe.unpark(boyThread); // unpark两次，但是permit不会叠加
+                    unsafe.unpark(boyThread);
+                }
+            });
+
+            boyThread.start();
+            girlThread.start();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 40;
+        }
+        return result;
+    }
+
+}
+
+
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
\ No newline at end of file
diff --git a/test/testsuite/run.py b/test/testsuite/run.py
new file mode 100644
index 0000000000000000000000000000000000000000..4923b7ad9a7b2a827a319b548fd27393f21d69c9
--- /dev/null
+++ b/test/testsuite/run.py
@@ -0,0 +1,189 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import argparse
+import logging
+import os
+import shlex
+import subprocess
+import sys
+import time
+from collections import OrderedDict
+from textwrap import indent
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+from maple_test.utils import ENCODING, complete_path, add_run_path
+
+EXIT_CODE = 0
+
+
+class MapleRunError(Exception):
+    pass
+
+
+def run(cmd, work_dir, timeout):
+    process_command = subprocess.Popen(
+        cmd,
+        shell=True,
+        cwd=str(work_dir),
+        env=add_run_path(str(work_dir)),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        close_fds=True,
+    )
+    try:
+        com_out, com_err = process_command.communicate(timeout=timeout)
+    except subprocess.CalledProcessError as err:
+        raise err
+    else:
+        return_code = process_command.returncode
+        com_out = com_out.decode(ENCODING, errors="ignore")
+        com_err = com_err.decode(ENCODING, errors="ignore")
+        return return_code, com_out, com_err
+    finally:
+        process_command.terminate()
+
+
+def construct_qemu_cmd(execute_cmd, execute_option):
+    maple_root = os.environ.get("MAPLE_ROOT")
+    if maple_root is None:
+        logging.error("Not found system environment : MAPLE_ROOT")
+        sys.exit(1)
+    execute_option["execute_files"] = ":".join(
+        [str(file) for file in execute_option["execute_files"]]
+    )
+    maple_out_path = os.environ.get("MAPLE_BUILD_OUTPUT")
+    LIBZ_SO = maple_out_path + "/ops/third_party"
+    RUNTIME_SO = maple_out_path + "/ops/host-x86_64-" + execute_option["mrt_type"]
+    APP_SO = os.getcwd()
+    MPLSH = maple_out_path + "/ops/mplsh"
+    QEMU = maple_root + "/tools/bin/qemu-aarch64"
+    execute_cmd["run_case"] = (
+        "{QEMU} "
+        "-L /usr/aarch64-linux-gnu -E LD_LIBRARY_PATH={LIBZ_SO}:{RUNTIME_SO}:{APP_SO} "
+        "{MPLSH} -Xbootclasspath:libcore-all.so -cp {execute_files} "
+        "{execute_class} {execute_args}".format(
+            QEMU=QEMU, LIBZ_SO=LIBZ_SO, RUNTIME_SO=RUNTIME_SO, APP_SO=APP_SO,
+            MPLSH=MPLSH, **execute_option
+        )
+    )
+
+
+def parse_cli():
+    parser = argparse.ArgumentParser(prog="run")
+    parser.add_argument(
+        "--run_type",
+        default="aarch64",
+        choices=["aarch64"],
+        help="run type",
+    )
+
+    parser.add_argument(
+        "execute_file", metavar="<file1>[:file2:file3...]", help="execute file, ",
+    )
+    parser.add_argument("execute_class", help="execute class")
+    parser.add_argument("--execute_args", dest="execute_args", default="", help="execute args")
+    parser.add_argument(
+        "--timeout", help="run test case timeout", type=float, default=None
+    )
+    parser.add_argument(
+        "--mrt_type",
+        dest="mrt_type",
+        default="O2",
+        choices=["O0", "O2"],
+        help="Add mrt type to the extra option",
+    )
+
+    connection_options = parser.add_argument_group("Script options")
+    connection_options.add_argument(
+        "--verbose", action="store_true", dest="verbose", help="enable verbose output",
+    )
+
+    opts = parser.parse_args()
+    return opts
+
+
+def main():
+    opts = parse_cli()
+    run_type = opts.run_type
+
+    parser = shlex.shlex(opts.execute_file)
+    parser.whitespace = ":"
+    parser.whitespace_split = True
+    source_files = [complete_path(file) for file in parser]
+
+    execute_class = opts.execute_class
+    execute_args = opts.execute_args
+    mrt_type = opts.mrt_type
+    timeout = opts.timeout
+
+    execute_option = {
+        "execute_files": source_files,
+        "execute_class": execute_class,
+        "execute_args": execute_args,
+        "mrt_type": mrt_type,
+        "timeout": timeout,
+    }
+
+    logging.basicConfig(
+        format="\t%(asctime)s %(message)s",
+        datefmt="%H:%M:%S",
+        level=logging.DEBUG if opts.verbose else logging.INFO,
+        stream=sys.stderr,
+    )
+
+    execute_cmd = OrderedDict()
+    execute_cmd["run_case"] = None
+
+    if run_type == "aarch64":
+        construct_qemu_cmd(execute_cmd, execute_option)
+    else:
+        logging.error("Not support run type: {}".format(run_type))
+    run_case(execute_cmd, ".", timeout)
+
+
+def run_case(execute_cmd, work_dir, timeout):
+    for stage, cmd in execute_cmd.items():
+        run_cmd(stage, cmd, work_dir, timeout)
+
+
+def run_cmd(stage, cmd, work_dir, timeout):
+    return_code, com_out, com_err = run(cmd, work_dir, timeout)
+    logging.debug("execute command: %s", cmd)
+    logging.debug("execute return code: %d", return_code)
+    logging.debug("execute out: \n%s", indent(com_out, "\t", lambda line: True))
+    logging.debug("execute error: \n%s", indent(com_err, "\t", lambda line: True))
+    global EXIT_CODE
+    EXIT_CODE = return_code
+    print(com_out, end="")
+    print(com_err, file=sys.stderr, end="")
+    if return_code != 0:
+        logging.error("execute command: %s", cmd)
+        logging.error("execute return code: %d", return_code)
+        logging.error("execute out: \n%s", indent(com_out, "\t", lambda line: True))
+        logging.error(
+            "execute error: \n%s", indent(com_err, "\t", lambda line: True)
+        )
+        reason = "Maple run stage: {} failed at command: {}, reason: {}".format(
+            "run_case".upper(), cmd, com_err
+        )
+        raise MapleRunError(reason)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except MapleRunError as e:
+        sys.exit(EXIT_CODE)
diff --git a/testsuite/Readme_zh.md b/testsuite/Readme_zh.md
new file mode 100644
index 0000000000000000000000000000000000000000..e01c0d35b886792c20b5a10da69a329b30b2c441
--- /dev/null
+++ b/testsuite/Readme_zh.md
@@ -0,0 +1,193 @@
+# Maple 测试框架
+
+## 目录结构
+
+```shell
+testsuite
+├── README_zh.md    测试框架中文说明文档
+├── driver    测试框架代码
+│   ├── config    测试套集合配置
+|   |   └── testall.conf    testall target 测试套集合配置
+│   ├── src    测试框架源码 
+|   |   ├── api    常用测试命令封装
+|   |   |   ├── shell_operator.py    shell命令封装父类
+|   |   |   ├── shell.py    一般shell封装
+|   |   |   ├── maple.py    maple 可执行二进制封装
+|   |   |   ├── dex2mpl.py    dex2mpl 可执行二进制封装
+|   |   |   ├── ...  (可根据需求自行添加)
+|   |   |   └── ... 
+|   |   ├── basic_tools    测试框架常用的业务无关的函数库
+|   |   |   ├── file.py    文件函数库
+|   |   |   ├── string_list.py    字符串列表函数库
+|   |   |   └── string.py    字符串函数库
+|   |   ├── case.py    测试用例封装类
+|   |   ├── driver.py    测试框架入口
+|   |   ├── env_var.py    测试环境变量处理
+|   |   ├── mode    测试用例的测试流程模式封装
+|   |   |   ├── O0.py    测试用例使用编译器O0选项对应的编译和运行测试流程模式封装
+|   |   |   ├── O2.py    测试用例使用编译器O2选项对应的编译和运行测试流程模式封装
+|   |   |   ├── ...  (可根据需求自行添加)
+|   |   |   └── ...
+|   |   ├── mode_table.py    测试套集合配置解析类
+|   |   ├── shell_executor.py    单独一条shell命令执行封装
+|   |   ├── target    测试套封装
+|   |   ├── case.py    测试用例封装
+|   |   ├── task.py    测试用例执行任务封装
+|   |   └── test_cfg.py    测试用例封装类      ​
+│   └── script    测试框架接口命令脚本
+├── irbuild_test    irbuild测试套
+├── java_test    java测试套
+├── irbuil_test    irbuild测试套
+└── c_test    c测试套
+
+```
+
+## 运行要求
+
+- python版本>=3.5.2
+
+## 运行说明
+
+必须先设置环境变量：source build/envsetup.sh arm release
+
+### 批量运行
+
+在MAPLE_ROOT下，即代码根目录下，执行如：
+
+    make testall  批量跑testsuite/driver/config/testall.conf指定的所有测试套
+
+
+    make testall MODE=O2    批量跑testsuite/driver/config/testall.conf指定的所有测试套中支持O2流程模式的部分
+
+
+    make java_test/app_test    批量跑测试套java_test/app_test，这里测试套名称可以是相对testsuite的相对路径
+
+
+    make java_test/app_test MODE=O02     批量跑测试套java_test/app_test中支持O2流程模式的部分
+
+
+
+支持自定义测试套，在testsuite/driver/config下，写测试套配置文件，文件名必须以test开头，便于和编译target区分，语法见后文[测试套配置]，之后可以在MAPLE_ROOT下，执行如：
+
+    make [target_name] [MODE=mod]     
+
+
+
+### 调试模式运行
+
+比如要调试java_test/app_test/APP0001-app-Application-Application-helloworld，则切换路径到这个case下面，执行：
+
+    mm MODE=O2
+
+执行的流程模式自选，如不清楚这个case支持具体哪些测试模式，可以输入一个错误的模式名称，如mm MODE=xx，这样会提示支持的模式都有哪些。
+
+执行的命令行会打印出来，可以复制后直接在当前路径下粘贴执行，便于调试。
+
+清理调试运行生成的文件，执行：
+
+    mm clean
+
+
+## 测试套配置
+
+### 按测试套集合配置文件
+
+
+
+测试套集合配置文件在testsuite/driver/config目录，里面可以添加多个测试套集合配置文件，每个配置文件包含流程模式集合，指定测试套能运行的流程模式集合，ban列表，配置文件语法如下：
+
+
+#### 流程模式集合 [MODE_SET]
+
+    mode_set_name: mode1, mode2    将mode1 mode2两个流程模式封装为mode_set_name
+
+如 java_common_mode_set: O0，O2，即将方舟编译器O0，O2模式封装到常用测试模式流程集合java_common_mode_set中，后续如有新模式可继续添加
+
+
+
+
+#### 指定测试套能运行的流程模式集合 [DEFAULT_TEST_SUITE]
+
+    java_test/app_test: java_common_mode_set    testsuite下java_test/app_test路径下的case都能跑java_common_mode_set中的模式流程，等价于：java_test/app_test: O0, O2
+
+
+支持流程模式集合和流程模式同时使用，如：
+
+    java_test/app_test: java_common_mode_set， special_mode_set
+
+
+支持路径配置覆盖，如：
+
+    java_test/app_test/APP0001-app-Application-Application-helloworld: O3, O4     即这个case只能跑O3，O4，而不是跑java_test/app_test指定的流程模式集合
+
+
+
+
+#### ban列表 [BAN_TEST_SUITE]
+
+基于指定测试套默认的能运行的流程模式集合[DEFAULT_TEST_SUITE]中，将不能运行的模式注释掉的ban列表，如果cmp在PATH中，如：
+	
+	java_test/app_test/APP0001-app-Application-Application-helloworld: O0     这一行声明这个case O0模式不跑，那么这个case将跑除了O0之外的测试套中指定的流程模式集合[DEFAULT_TEST_SUITE]
+
+同样的测试套可以多次出现在ban列表中，ban列表中测试套注释掉的模式为多行的并集。
+	
+
+说明：
+
+1.测试套路径全部是相对testsuite的真实存在的路径，且必须是文件夹
+
+2.流程模式必须是在testsuite/driver/mode中存在的已配置的流程模式
+
+3.配置文件中，支持#注释和空行
+
+
+## 流程模式配置
+
+流程模式配置文件在路径 testsuite/driver/src/mode 下，每一个流程模式配置文件里有且只有一个dict，dict 的变量名即为这个流程模式的名字，且一定与改流程模式配置文件的名字保持一致，否则无法正确加载，该文件需符合python3语法。
+
+流程模式的dict封装结构如下：
+
+    mode_name = {
+        phase_name1 : [
+		    api1，
+			api2，
+			...
+		]，
+		phase_name2 : [
+		    api1，
+			api2，
+			...
+		]，
+		...
+	}
+
+其中，dict的key值为要封装的一个阶段流程的名称，如 clean compile run等，而对应的value为由若干个api组成的流程描述。
+
+常用的api，建议封装在testsuite/driver/src/api 下面，每个api尽可能抽象并与业务解耦，这样才能最大程度复用，可变内容在实例化时用入参传入，在api解析时拼装成一条完整的shell命令
+
+不常用的api，提供最原始的Shell api封装,可以直接写shell命令
+
+
+## 用例配置
+
+用例所在文件夹命名规范为^[A-Z]{1,9}[0-9]{3,10}-[a-zA-Z0-9_.]，1到9个大写字母加3到10位数字组成用例文件夹开头，后面用“-”链接若干由大小写字母，数字，'_' , '.'组成的字符串
+
+用例所在文件夹下有test.cfg，即用例对应的配置文件，配置文件语法为：
+    
+	phase_name1()
+	phase_name2(var1=1,var2="test")
+	...
+
+调用封装描述case测试的主干流程，phase_name 要存在于 上文流程模式配置文件里dict封装中的key中，()里为case相关的入参，格式为
+
+    var_name=var_value
+
+多个入参用','相连，无入参时()不可缺省
+
+另 主类名传参时，如
+    
+    compile(APP=HelloWorld)
+
+可简写为
+
+    compile(HelloWorld)
diff --git a/testsuite/c_test/ast_test/AST0001-HelloWorld/HelloWorld.c b/testsuite/c_test/ast_test/AST0001-HelloWorld/HelloWorld.c
new file mode 100644
index 0000000000000000000000000000000000000000..1755ef20bb8edd20b0510aa99644f25041835c78
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0001-HelloWorld/HelloWorld.c
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  printf("Hello world!");
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0001-HelloWorld/expected.txt b/testsuite/c_test/ast_test/AST0001-HelloWorld/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6769dd60bdf536a83c9353272157893043e9f7d0
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0001-HelloWorld/expected.txt
@@ -0,0 +1 @@
+Hello world!
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0001-HelloWorld/test.cfg b/testsuite/c_test/ast_test/AST0001-HelloWorld/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0001-HelloWorld/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/c_test/ast_test/AST0002-IntPrint/IntPrint.c b/testsuite/c_test/ast_test/AST0002-IntPrint/IntPrint.c
new file mode 100644
index 0000000000000000000000000000000000000000..ff457cd6fcebbe4d8dfff1f52f271ec998b7dc72
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0002-IntPrint/IntPrint.c
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int a = 2;
+  int b = 3;
+  printf("%d%d", a, b);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0002-IntPrint/expected.txt b/testsuite/c_test/ast_test/AST0002-IntPrint/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b39356075901abfb43d27aef2ae5b76b6aee19c4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0002-IntPrint/expected.txt
@@ -0,0 +1 @@
+23
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0002-IntPrint/test.cfg b/testsuite/c_test/ast_test/AST0002-IntPrint/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ea17173ba73fd653a0ec9fb995ba4f61e53aed61
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0002-IntPrint/test.cfg
@@ -0,0 +1,2 @@
+compile(IntPrint)
+run(IntPrint)
diff --git a/testsuite/c_test/ast_test/AST0003-CallExpr/CallExpr.c b/testsuite/c_test/ast_test/AST0003-CallExpr/CallExpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..c4c51ca0e3bcf741a7bc539968ca4c5e57b17c73
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0003-CallExpr/CallExpr.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int GetValue(int a) {
+  return a;
+}
+int AddTwo(int a, int b){                     // multi param
+  return GetValue(a) + GetValue(b);
+}
+void AssignArr(int a[], int len){             // array param
+  for (int i = 0; i < len; i++){
+    a[i] = i * 2;
+  }
+}
+void PrintArr(int a[], int len){
+  int i = 0;
+  while (i < len){
+    printf("%d", a[i]);
+    i++;
+  }
+  printf("\n");
+}
+int CulSum(int a){                            // recursive call
+  if (a == 1){
+    return 1;
+  }
+  else{
+    return a + CulSum(a - 1);
+  }
+}
+
+int main() {
+  int b = 23;
+  int c = GetValue(b);
+  printf("%d", c);
+
+  // add more complex cases
+  printf("b + c = %d\n", AddTwo(b, c));
+  int arr[5];
+  int len = sizeof(arr)/sizeof(int);
+  AssignArr(arr, len);
+  // PrintArr(arr, len);                      // @fail case, output wrong
+  printf("%d", CulSum(10));
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0003-CallExpr/expected.txt b/testsuite/c_test/ast_test/AST0003-CallExpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0a4b798364543ea925ac8533dc2a503c62437613
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0003-CallExpr/expected.txt
@@ -0,0 +1,2 @@
+23b + c = 46
+55
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0003-CallExpr/test.cfg b/testsuite/c_test/ast_test/AST0003-CallExpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..29fec885ffb6aaee31cfa43f8e397d1897ef3e6f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0003-CallExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(CallExpr)
+run(CallExpr)
diff --git a/testsuite/c_test/ast_test/AST0004-SameVarName/SameVarName.c b/testsuite/c_test/ast_test/AST0004-SameVarName/SameVarName.c
new file mode 100644
index 0000000000000000000000000000000000000000..cf988433154777c7e87224a6f2e9a926a39e7cf0
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0004-SameVarName/SameVarName.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int a = 1;
+int b = 2;
+
+int main() {
+  int a = 3;
+  printf("%d%d", b, a);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0004-SameVarName/expected.txt b/testsuite/c_test/ast_test/AST0004-SameVarName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b39356075901abfb43d27aef2ae5b76b6aee19c4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0004-SameVarName/expected.txt
@@ -0,0 +1 @@
+23
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0004-SameVarName/test.cfg b/testsuite/c_test/ast_test/AST0004-SameVarName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..629c39abe69473dc430812ec656bb7d7a65ea3f8
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0004-SameVarName/test.cfg
@@ -0,0 +1,2 @@
+compile(SameVarName)
+run(SameVarName)
diff --git a/testsuite/c_test/ast_test/AST0005-UnaryOperatorExpr/UnaryOperatorExpr.c b/testsuite/c_test/ast_test/AST0005-UnaryOperatorExpr/UnaryOperatorExpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..f7a3f0fb43634aa68872d45fb991621f0f0417dd
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0005-UnaryOperatorExpr/UnaryOperatorExpr.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int a = 1;
+
+int main() {
+  int b = 10;
+  printf("%d", a++);
+  printf("%d", ++a);
+  printf("%d", a--);
+  printf("%d", --a);
+  printf("%d", b++);
+  printf("%d", ++b);
+  printf("%d", b--);
+  printf("%d", --b);
+  printf("\n");
+  double c = 1.0;
+  printf("%f", c++);
+  printf("%f", ++c);
+  printf("%f", c--);
+  printf("%f", --c);
+  printf("\n");
+  short d = 2;
+  printf("%d", d++);
+  printf("%d", ++d);
+  printf("%d", d--);
+  printf("%d", --d);
+  printf("\n");
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0005-UnaryOperatorExpr/expected.txt b/testsuite/c_test/ast_test/AST0005-UnaryOperatorExpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..df573c936fac09fda19cc11353233119f1bf096b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0005-UnaryOperatorExpr/expected.txt
@@ -0,0 +1,3 @@
+133110121210
+1.0000003.0000003.0000001.000000
+2442
diff --git a/testsuite/c_test/ast_test/AST0005-UnaryOperatorExpr/test.cfg b/testsuite/c_test/ast_test/AST0005-UnaryOperatorExpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c4007d7b267b23c1402ded1b778bbad5b83df819
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0005-UnaryOperatorExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(UnaryOperatorExpr)
+run(UnaryOperatorExpr)
diff --git a/testsuite/c_test/ast_test/AST0006-ArraySubscriptExpr/ArraySubscriptExpr.c b/testsuite/c_test/ast_test/AST0006-ArraySubscriptExpr/ArraySubscriptExpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..824ef3825cae69731ffec2c6f193b8af8bae8482
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0006-ArraySubscriptExpr/ArraySubscriptExpr.c
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int a[3] = {1, 2, 3};
+  double f[3] = {1.0, 2.1, 3.14};
+  int b[10];
+  b[2] = 10;
+  b[3] = 100;
+
+  char c[5];
+  c[3] = 'a';
+  c[4] = 'b';
+
+  printf("%d", b[2]);
+  printf("%d", b[3]);
+  printf("%c", c[3]);
+  printf("%c\n", c[4]);
+  printf("%d%d%d", a[0], a[1], a[2]);
+  int a_ = a[0] + a[1] + a[2];
+  printf("%d", a_);
+  printf("%lf%lf%lf", f[0], f[1], f[2]);
+  // fail cases
+  // double f[3] = {1, 2.1, 3.14};
+  // printf("%d%d%d", a[0], a[1], a[1+1]);
+  // printf("%d%d%d", a[0] + a[1] + a[2]);
+  // double f_ = f[0] + f[1] + f[2];
+  // printf("\n%d%d%d",*(a), *(a+1), *(a+2));
+  // printf("%d%d%d",*&a[0], *&a[1+1], *&a[2]);
+  // printf("\n%f%f%f",*&f[0], *&f[1+1], *&f[2]);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0006-ArraySubscriptExpr/expected.txt b/testsuite/c_test/ast_test/AST0006-ArraySubscriptExpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eaaf8c10a2bcf6c72dad4828233fefc1f9ca8dfb
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0006-ArraySubscriptExpr/expected.txt
@@ -0,0 +1,2 @@
+10100ab
+12361.0000002.1000003.140000
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0006-ArraySubscriptExpr/test.cfg b/testsuite/c_test/ast_test/AST0006-ArraySubscriptExpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f6d40f9a32473c57132a9b6b2931b92537d93448
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0006-ArraySubscriptExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(ArraySubscriptExpr)
+run(ArraySubscriptExpr)
diff --git a/testsuite/c_test/ast_test/AST0007-ConditionalOperator/ConditionalOperator.c b/testsuite/c_test/ast_test/AST0007-ConditionalOperator/ConditionalOperator.c
new file mode 100644
index 0000000000000000000000000000000000000000..03b1c009e6667585743187e3dd3d32f63904529f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0007-ConditionalOperator/ConditionalOperator.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int a = 9;
+  int b = (a < 10) ? 1 : 2;
+  printf("%d %d\n", a, b); // 9 1
+  // nested false expr
+  b = (a < 9) ? 1 : a++;
+  printf("%d %d\n", a, b); // 10 9
+  // multilevel conditional expr
+  (a < 10) ? (a = 1) : (b < 9) ? 1 : (a = 2, a++);
+  printf("%d %d\n", a, b); // 3 9
+  // noncomparative conditional expr
+  double c = 0.0;
+  b = c++ ? 1 : a++;
+  printf("%d %d %f\n", a, b, c); // 4 3 1.000000
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0007-ConditionalOperator/expected.txt b/testsuite/c_test/ast_test/AST0007-ConditionalOperator/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..55a04753cf0dffc92584e3fd72119647ec7dc967
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0007-ConditionalOperator/expected.txt
@@ -0,0 +1,4 @@
+9 1
+10 9
+3 9
+4 3 1.000000
diff --git a/testsuite/c_test/ast_test/AST0007-ConditionalOperator/test.cfg b/testsuite/c_test/ast_test/AST0007-ConditionalOperator/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..49fd2710e36633ff6c3db2ce22bbbbcf9604921a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0007-ConditionalOperator/test.cfg
@@ -0,0 +1,2 @@
+compile(ConditionalOperator)
+run(ConditionalOperator)
diff --git a/testsuite/c_test/ast_test/AST0008-InitListExpr-Array/InitListExpr-Array.c b/testsuite/c_test/ast_test/AST0008-InitListExpr-Array/InitListExpr-Array.c
new file mode 100644
index 0000000000000000000000000000000000000000..71b373a3a32bfde465ecb1d3ce8fd691dd2341a7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0008-InitListExpr-Array/InitListExpr-Array.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int arr1[10] = {1 ,2, 3};
+  double arr2[10] = {1.5, 2.5 ,8.5};
+  char arr3[10] = {'a', 'b'};
+  char arr4[2][3] = {'a', 'b','c','d','e'};
+  char arr5[2][2][2] = {{'a', 'b','c','d'},{{'b','c'},{'d','e'}}};
+  printf("%d\n", arr1[2]);
+  printf("%f\n", arr2[2]);
+  printf("%c\n", arr3[0]);
+  printf("%c\n", arr4[1][1]);
+  arr4[1][1] = 'z';
+  char c = arr4[1][1];
+  printf("%c\n", arr4[1][1]);
+  printf("%c\n",c);
+  printf("%c\n", arr5[0][1][1]);
+  arr5[0][1][1] = 'w';
+  char c1 = arr5[0][1][1];
+  printf("%c\n",c1);
+  printf("%c\n", arr5[0][1][1]);
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0008-InitListExpr-Array/expected.txt b/testsuite/c_test/ast_test/AST0008-InitListExpr-Array/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..62ffe507a2eb1d354ecea6235f9efe29b486a165
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0008-InitListExpr-Array/expected.txt
@@ -0,0 +1,9 @@
+3
+8.500000
+a
+e
+z
+z
+d
+w
+w
diff --git a/testsuite/c_test/ast_test/AST0008-InitListExpr-Array/test.cfg b/testsuite/c_test/ast_test/AST0008-InitListExpr-Array/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f223da63cef2f2767b259958d19d816571f0baeb
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0008-InitListExpr-Array/test.cfg
@@ -0,0 +1,2 @@
+compile(InitListExpr-Array)
+run(InitListExpr-Array)
diff --git a/testsuite/c_test/ast_test/AST0009-BinaryOperatorExpr/BinaryOperatorExpr.c b/testsuite/c_test/ast_test/AST0009-BinaryOperatorExpr/BinaryOperatorExpr.c
new file mode 100755
index 0000000000000000000000000000000000000000..02bf197ef0ddade61dc6a31f541111766e184a4f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0009-BinaryOperatorExpr/BinaryOperatorExpr.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int a = 1;
+struct Person{
+  int age;
+  char c_name;
+};
+
+int main() {
+  int b = 10;
+  int a = 2;
+  printf("%d + %d=%d\n", a, b, a + b);
+  printf("%d - %d=%d\n", a, b, a - b);
+  printf("%d * %d=%d\n", a, b, a * b);
+  printf("%d / %d=%d\n", a, b, a / b);
+  printf("%d %% %d=%d\n", a, b, a % b);
+  printf("%d << %d=%d\n", a, b, a << b);
+  printf("%d >> %d=%d\n", a, b, a >> b);
+  printf("%d > %d=%d\n", a, b, a > b);
+  printf("%d < %d=%d\n", a, b, a < b);
+  printf("%d <= %d=%d\n", a, b, a <= b);
+  printf("%d >= %d=%d\n", a, b, a >= b);
+  printf("%d == %d=%d\n", a, b, a == b);
+  printf("%d != %d=%d\n", a, b, a != b);
+  printf("%d & %d=%d\n", a, b, a & b);
+  printf("%d ^ %d=%d\n", a, b, a ^ b);
+  printf("%d | %d=%d\n", a, b, a | b);
+  printf("%d && %d=%d\n", a, b, a && b);
+  printf("%d || %d=%d\n", a, b, a || b);
+  printf("%d , %d=%d\n", a, b, (a, b));
+
+  // add more complex cases
+  long int l_int = -2147483647;
+  char c = 'a';
+  unsigned int u_int = 65535;
+  unsigned char u_char = 128;
+  float flt = 123.456789f;                                                                     // @fail if no 'f' at end
+  double db = 1.23456789;
+  // long double ldb = 12.3456789123456;                                                                      //@fail case
+  double ldb = 12.3456789123456;
+  short int s_int = 0xa5;
+  int res = c + a;
+  printf("+:%ld%ud%.2f%f\n",(l_int + c), (u_int + u_char), (flt + db), (ldb + s_int));
+  printf("-:%ld%ud%.2f%f\n",(l_int - c), (u_int - u_char), (flt - db), (ldb - s_int));
+  printf("*:%ld%ud%.2f%f\n",(l_int * c), (u_int * u_char), (flt * db), (ldb * s_int));
+  printf("/:%ld%ud%.2f%f\n",(l_int / c), (u_int / u_char), (flt / db), (ldb / s_int));
+  // printf("%%:%ld%ud%d%d\n",(l_int % c), (u_int % u_char), ((int)flt % (int)db), ((int)ldb / (int)s_int)); //@fail case
+  // printf("&:%ld%ud%d%d\n",(l_int & c), (u_int & u_char), ((int)flt & (int)db), (int)ldb & (int)s_int);    //@fail case
+  // printf("&:%ld%ud%d%d\n",(l_int | c), (u_int | u_char), ((int)flt | (int)db), (int)ldb | (int)s_int);    //@fail case
+  // printf("&:%ld%ud%d%d\n",(l_int ^ c), (u_int ^ u_char), ((int)flt ^ (int)db), (int)ldb ^ (int)s_int);    //@fail case
+
+  struct Person p;
+  struct Person *ptr = &p;
+  p.age = 10;
+  p.c_name = 'p';
+  printf("%d%d", ptr->age + 10, ptr->c_name + 10);
+  printf("%d%d", p.age + 10, p.c_name + 10);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0009-BinaryOperatorExpr/expected.txt b/testsuite/c_test/ast_test/AST0009-BinaryOperatorExpr/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..437d8426a923f273c4777e1b890849c980cd0cd4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0009-BinaryOperatorExpr/expected.txt
@@ -0,0 +1,24 @@
+2 + 10=12
+2 - 10=-8
+2 * 10=20
+2 / 10=0
+2 % 10=2
+2 << 10=2048
+2 >> 10=0
+2 > 10=0
+2 < 10=1
+2 <= 10=1
+2 >= 10=0
+2 == 10=0
+2 != 10=1
+2 & 10=2
+2 ^ 10=8
+2 | 10=10
+2 && 10=1
+2 || 10=1
+2 , 10=10
++:-214748355065663d124.69177.345679
+-:-214748374465407d122.22-152.654321
+*:-2083059137598388480d152.422037.037021
+/:-22139006511d100.000.074822
+2012220122
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0009-BinaryOperatorExpr/test.cfg b/testsuite/c_test/ast_test/AST0009-BinaryOperatorExpr/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c29ba6a85edb455a719c3e731af44b268d05d60f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0009-BinaryOperatorExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(BinaryOperatorExpr)
+run(BinaryOperatorExpr)
diff --git a/testsuite/c_test/ast_test/AST0010-BinaryOperatorStmt/BinaryOperatorStmt.c b/testsuite/c_test/ast_test/AST0010-BinaryOperatorStmt/BinaryOperatorStmt.c
new file mode 100755
index 0000000000000000000000000000000000000000..4d961c9b2881e46bef3c55d24c53febbb92c24a9
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0010-BinaryOperatorStmt/BinaryOperatorStmt.c
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int a = 1;
+
+int main() {
+  int b = 10;
+  int a = 2;
+  a + b;
+  a - b;
+  a * b;
+  a / b;
+  a % b;
+  a << b;
+  a >> b;
+  a > b;
+  a < b;
+  a <= b;
+  a >= b;
+  a == b;
+  a != b;
+  a & b;
+  a ^ b;
+  a | b;
+  a && b;
+  a || b;
+  printf("ok\n");
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0010-BinaryOperatorStmt/expected.txt b/testsuite/c_test/ast_test/AST0010-BinaryOperatorStmt/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..9766475a4185a151dc9d56d614ffb9aaea3bfd42
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0010-BinaryOperatorStmt/expected.txt
@@ -0,0 +1 @@
+ok
diff --git a/testsuite/c_test/ast_test/AST0010-BinaryOperatorStmt/test.cfg b/testsuite/c_test/ast_test/AST0010-BinaryOperatorStmt/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..df9da84bd6b82190a8b25aab64574cd357150a6b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0010-BinaryOperatorStmt/test.cfg
@@ -0,0 +1,2 @@
+compile(BinaryOperatorStmt)
+run(BinaryOperatorStmt)
diff --git a/testsuite/c_test/ast_test/AST00101-VariablyModifiedType/VariablyModifiedType.c b/testsuite/c_test/ast_test/AST00101-VariablyModifiedType/VariablyModifiedType.c
new file mode 100644
index 0000000000000000000000000000000000000000..40289fb831c0979ca4fd5142a87fbaaa39877b7f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST00101-VariablyModifiedType/VariablyModifiedType.c
@@ -0,0 +1,36 @@
+#include <stdio.h>
+
+
+int main() {
+  int n1=5, n2=6, n3=7;
+  int (*A)[n1][n2] = malloc(sizeof(int[n1][n2]));
+  int (*B)[n2][n3] = malloc(sizeof(int[n2][n3]));
+  int (*C)[n1][n3] = malloc(sizeof(int[n1][n3]));
+  for (size_t i1 = 0; i1 < n1; i1++) {
+    for (size_t i2 = 0; i2 < n2; i2++) {
+      (*A)[i1][i2] = 1;
+    }
+  }
+  for (size_t i2 = 0; i2 < n2; i2++) {
+    for (size_t i3 = 0; i3 < n3; i3++) {
+       (*B)[i2][i3] = 2;
+    }
+  }  
+  for (size_t i1 = 0; i1 < n1; i1++) {
+    for (size_t i3 = 0; i3 < n3; i3++) {
+      (*C)[i1][i3] = 0.0;
+      for (size_t i2 = 0; i2 < n2; i2++) {
+	(*C)[i1][i3] += (*A)[i1][i2] * (*B)[i2][i3];
+      }
+    }
+  }
+  for (size_t i1 = 0; i1 < n1; i1++) {
+    for (size_t i3 = 0; i3 < n3; i3++) {
+      if ((*C)[i1][i3] != 12) {
+	abort();
+      }
+    }
+  }
+  free(A); free(B); free(C);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST00101-VariablyModifiedType/expected.txt b/testsuite/c_test/ast_test/AST00101-VariablyModifiedType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST00101-VariablyModifiedType/test.cfg b/testsuite/c_test/ast_test/AST00101-VariablyModifiedType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3438e91f5c2b3acc660a7de49b2561c277b3d0d
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST00101-VariablyModifiedType/test.cfg
@@ -0,0 +1,2 @@
+compile(VariablyModifiedType)
+run(VariablyModifiedType)
diff --git a/testsuite/c_test/ast_test/AST00102-VLASavedStack/VLASavedStack.c b/testsuite/c_test/ast_test/AST00102-VLASavedStack/VLASavedStack.c
new file mode 100644
index 0000000000000000000000000000000000000000..6905b7a67d1bb6684c2008b50c2a1b5f66672350
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST00102-VLASavedStack/VLASavedStack.c
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/VLASavedStack.c"
+#include <stdio.h>
+
+int main() {
+	return 0;
+}
+
+int foo (int n) { // scope 0
+  printf("0");
+  { // scope 1
+		printf("1");
+    int vla[n];
+		if (n > 0) {  // scope 2
+			int vla1[n];
+			printf("2");
+			if (n > 5) { // scope 3
+				// CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+        // CHECK-NEXT: intrinsiccall C_stack_restore
+				// CHECK-NEXT: intrinsiccall C_stack_restore
+        goto i_am_here_2;
+			}
+		}
+    printf("failed;");
+		if (n < 0) { // scope 4
+	  	i_am_here_1:
+		  printf("4");
+		}
+	}
+	// CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+	// CHECK-NOT: intrinsiccall C_stack_restore
+  goto i_am_here_2;
+  printf("failed;");
+  i_am_here_2:
+  printf("5");
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST00102-VLASavedStack/expected.txt b/testsuite/c_test/ast_test/AST00102-VLASavedStack/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST00102-VLASavedStack/test.cfg b/testsuite/c_test/ast_test/AST00102-VLASavedStack/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ee11821898651b6a29b847a9ca9ce827a5fc6901
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST00102-VLASavedStack/test.cfg
@@ -0,0 +1,3 @@
+compile(VLASavedStack)
+run(VLASavedStack)
+cat VLASavedStack.mpl | ${OUT_ROOT}/tools/bin/FileCheck VLASavedStack.c
diff --git a/testsuite/c_test/ast_test/AST0011-MemberExpr/MemberExpr.c b/testsuite/c_test/ast_test/AST0011-MemberExpr/MemberExpr.c
new file mode 100755
index 0000000000000000000000000000000000000000..e8c17969573e167b5683195de00b0005fd84dbd1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0011-MemberExpr/MemberExpr.c
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+struct A {
+ int a;
+ int b;
+};
+struct B {
+  struct A a;
+  struct A *pa;
+  int d;
+  char c;
+  double f[1];
+};
+
+int main() {
+  struct A a;
+  struct A *pa = &a;
+  a.a = 1;
+  a.b = 2;
+  printf("%d,", a.a);
+  printf("%d,", a.b);
+  printf("%d,", pa->a);
+  printf("%d\n", pa->b);
+
+  // add more cases
+  struct B b;
+  struct B *pb = &b;
+  b.pa = &a;
+  b.a.a = 11;
+  b.a.b = 22;
+  b.d = -32766;
+  b.c = 'b';
+  printf("%c", pb->c);
+  printf("%d", b.d);
+  b.f[0] = 1.1;
+  printf("%d\n", pb->a.a + pb->a.b + pb->d);
+  b.pa = &b.a;
+  printf("%d%d", b.pa->a, b.pa->b);
+  printf("%d", b.a.a + b.a.b + b.d);
+
+  struct C {
+    struct B b;
+    struct B *pb;
+  } c;
+  c.pb = &c.b;
+  struct C *pc = &c;
+  c.b = b;
+  pc->b = b;
+  c.b.pa = &a;
+  c.b.a.a = 11;
+  c.b.a.b = 22;
+  c.b.d = -32766;
+  c.b.c = 'b';
+  // c.b.f[0] = 1.11;                     // fail case
+  c.b.pa = &c.b.a;
+  printf("%c%c%c%c", c.b.c, pc->b.c, c.pb->c, pc->pb->c);
+  printf("%d%d%d%d", c.b.pa->a, c.b.a.a, c.pb->a.a, c.pb->pa->a);
+  printf("%d%d%d%d", pc->b.pa->a, pc->b.a.a, pc->pb->a.a, pc->pb->pa->a);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0011-MemberExpr/expected.txt b/testsuite/c_test/ast_test/AST0011-MemberExpr/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..16b8d24d1e0f6163e982555c084d09d73c2f34b9
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0011-MemberExpr/expected.txt
@@ -0,0 +1,3 @@
+1,2,1,2
+b-32766-32733
+1122-32733bbbb1111111111111111
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0011-MemberExpr/test.cfg b/testsuite/c_test/ast_test/AST0011-MemberExpr/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..39cd626a055407acb7393667ad8894fd0446a7c9
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0011-MemberExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(MemberExpr)
+run(MemberExpr)
diff --git a/testsuite/c_test/ast_test/AST0012-AssignExpr/AssignExpr.c b/testsuite/c_test/ast_test/AST0012-AssignExpr/AssignExpr.c
new file mode 100755
index 0000000000000000000000000000000000000000..db9c32123f5c4ecfb955a49d9d9dbc16386e1d76
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0012-AssignExpr/AssignExpr.c
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+struct A {
+ int a;
+ int b;
+};
+
+int main() {
+  int a = 0;
+  int b = 1;
+  int c = 2;
+  int *pb = &b;
+  int *pc = &c;
+  struct A sa;
+  struct A sb;
+  struct A *psb = &sb;
+  sa.a = 0;
+  sa.b = 0;
+  sb.a = 0;
+  sb.b = 0;
+  printf("%d,", a);
+  a = 1;
+  printf("%d,", a);
+  printf("%d,", *pb);
+  pb = pc;
+  printf("%d,", *pc);
+  *pc = 4;
+  printf("%d,", *pc);
+  printf("%d,", sa.a);
+  printf("%d,", sa.b);
+  sa.a = 1;
+  sa.b = 2;
+  printf("%d,", sa.a);
+  printf("%d,", sa.b);
+  printf("%d,", psb->a);
+  printf("%d,", psb->b);
+  psb->a = 3;
+  psb->b = 4;
+  printf("%d,", psb->a);
+  printf("%d,", psb->b);
+
+  int arr[] = {1,2,3,4,5};
+  int *parr = arr;
+  printf("%d,", *(arr + 1));
+  printf("%d,", *(1 + arr));
+  printf("%d\n", *(1 + arr - 2 + 1));
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0012-AssignExpr/expected.txt b/testsuite/c_test/ast_test/AST0012-AssignExpr/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..5bd06043f44ca78d742f3c0c28475a921203c3a1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0012-AssignExpr/expected.txt
@@ -0,0 +1 @@
+0,1,1,2,4,0,0,1,2,0,0,3,4,2,2,1
diff --git a/testsuite/c_test/ast_test/AST0012-AssignExpr/test.cfg b/testsuite/c_test/ast_test/AST0012-AssignExpr/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d694a0c30fa4026f7d033782a6cb009e2fcd7569
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0012-AssignExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(AssignExpr)
+run(AssignExpr)
diff --git a/testsuite/c_test/ast_test/AST0013-IfStmt/IfStmt.c b/testsuite/c_test/ast_test/AST0013-IfStmt/IfStmt.c
new file mode 100755
index 0000000000000000000000000000000000000000..d842b98281b9d1bca8bbdad0f0076765e12b788f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0013-IfStmt/IfStmt.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+int main() {
+  int a = 1;
+  int b = 0;
+  if (a) {
+    printf("1,");
+  }
+  if (b) {
+    printf("failed");
+  }
+  if (a) {
+    printf("1,");
+  } else {
+    printf("failed");
+  }
+  if (b) {
+    printf("failed");
+  } else {
+    printf("1\n");
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0013-IfStmt/expected.txt b/testsuite/c_test/ast_test/AST0013-IfStmt/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..5b8274e039ab99fdbbc827ab684a1380855e16d4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0013-IfStmt/expected.txt
@@ -0,0 +1 @@
+1,1,1
diff --git a/testsuite/c_test/ast_test/AST0013-IfStmt/test.cfg b/testsuite/c_test/ast_test/AST0013-IfStmt/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2fa01453e7427c4794bb46bbe0eeeefa891d50f7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0013-IfStmt/test.cfg
@@ -0,0 +1,2 @@
+compile(IfStmt)
+run(IfStmt)
diff --git a/testsuite/c_test/ast_test/AST0014-ForStmt/ForStmt.c b/testsuite/c_test/ast_test/AST0014-ForStmt/ForStmt.c
new file mode 100755
index 0000000000000000000000000000000000000000..59a44f500034edf139fc6915649492f599d65152
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0014-ForStmt/ForStmt.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+int main() {
+  for (int i = 0; i < 5; i++) {
+    printf("%d,", i);
+  }
+  int a = 0;
+  for (; a < 5; a++) {
+    printf("%d,", a);
+  }
+  int b = 0;
+  for (;; b++) {
+    printf("%d,", b);
+    if (b >= 5) {
+      break;
+    }
+  }
+  int c = 10;
+  for (;;) {
+    printf("%d,", c);
+    c = c - 1;
+    if (c <= 5) {
+      break;
+    }
+  }
+  for (int i = 0; i < 5; i++) {
+    if (i == 2) {
+      continue;
+    }
+    printf("%d,", i);
+  }
+  printf("0\n");
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0014-ForStmt/expected.txt b/testsuite/c_test/ast_test/AST0014-ForStmt/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..242b3354ac73ded78b394edc41668ca7e7bc84cb
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0014-ForStmt/expected.txt
@@ -0,0 +1 @@
+0,1,2,3,4,0,1,2,3,4,0,1,2,3,4,5,10,9,8,7,6,0,1,3,4,0
diff --git a/testsuite/c_test/ast_test/AST0014-ForStmt/test.cfg b/testsuite/c_test/ast_test/AST0014-ForStmt/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e9a0016e895176c830a32234b10398bfcd0d7dcb
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0014-ForStmt/test.cfg
@@ -0,0 +1,2 @@
+compile(ForStmt)
+run(ForStmt)
diff --git a/testsuite/c_test/ast_test/AST0015-DoStmt/DoStmt.c b/testsuite/c_test/ast_test/AST0015-DoStmt/DoStmt.c
new file mode 100755
index 0000000000000000000000000000000000000000..890e821898ebf084dfb0f4ccf4b99b97a34cc151
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0015-DoStmt/DoStmt.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+int main() {
+  int i = 0;
+  do {
+    printf("%d,", i);
+    if (i == 3) {
+      continue;
+    }
+  } while (++i < 5);
+  i = 0;
+  do {
+    printf("%d,", i);
+    if (i == 3) {
+      break;
+    }
+  } while (++i < 5);
+  i = 0;
+  do {
+    i = i + 1;
+    printf("%d,", i);
+    if (i == 3) {
+      break;
+    }
+  } while (i < 5);
+  i = 0;
+  do {
+    i = i + 1;
+    printf("%d,", i);
+    if (i == 3) {
+      continue;
+    }
+  } while (i < 5);
+  printf("0\n");
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0015-DoStmt/expected.txt b/testsuite/c_test/ast_test/AST0015-DoStmt/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..f56a9ced10771aa246ddb23236deb20e09b3f88f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0015-DoStmt/expected.txt
@@ -0,0 +1 @@
+0,1,2,3,4,0,1,2,3,1,2,3,1,2,3,4,5,0
diff --git a/testsuite/c_test/ast_test/AST0015-DoStmt/test.cfg b/testsuite/c_test/ast_test/AST0015-DoStmt/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2f2d8857790d27e89cc11c9f37b61dfb9cae27b5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0015-DoStmt/test.cfg
@@ -0,0 +1,2 @@
+compile(DoStmt)
+run(DoStmt)
diff --git a/testsuite/c_test/ast_test/AST0016-WhileStmt/WhileStmt.c b/testsuite/c_test/ast_test/AST0016-WhileStmt/WhileStmt.c
new file mode 100755
index 0000000000000000000000000000000000000000..e9f6094f97efb3973942d3aed19ad41d9ab29574
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0016-WhileStmt/WhileStmt.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+int main() {
+  int i = 0;
+  while (++i < 5) {
+    if (i == 3) {
+      continue;
+    }
+    printf("%d,", i);
+  }
+  i = 0;
+  while (++i < 5) {
+    if (i == 3) {
+      break;
+    }
+    printf("%d,", i);
+  }
+  i = 1;
+  while (i) {
+    i = i + 1;
+    printf("%d,", i);
+    if (i > 3) {
+      i = 0;
+    }
+  }
+  int a = 0;
+  while (1) {
+    if (a >= 5) {
+      break;
+    }
+    printf("%d,", a);
+    a = a + 1;
+  }
+  printf("0\n");
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0016-WhileStmt/expected.txt b/testsuite/c_test/ast_test/AST0016-WhileStmt/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..bc2ea163a0dd73f7d605c2d636a9201c9805d785
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0016-WhileStmt/expected.txt
@@ -0,0 +1 @@
+1,2,4,1,2,2,3,4,0,1,2,3,4,0
diff --git a/testsuite/c_test/ast_test/AST0016-WhileStmt/test.cfg b/testsuite/c_test/ast_test/AST0016-WhileStmt/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..adb8afc63ce6721a3350e0163018714042ff5fcd
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0016-WhileStmt/test.cfg
@@ -0,0 +1,2 @@
+compile(WhileStmt)
+run(WhileStmt)
diff --git a/testsuite/c_test/ast_test/AST0017-InitListExpr-Struct/InitListExpr-Struct.c b/testsuite/c_test/ast_test/AST0017-InitListExpr-Struct/InitListExpr-Struct.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d536dada862a33e391a4ec96bd066016f631749
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0017-InitListExpr-Struct/InitListExpr-Struct.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stddef.h>
+
+struct Str2 {
+  short c;
+  int e;
+};
+
+struct Str1 {
+  int a;
+  double b;
+  char ch[2];
+  struct Str2 d;
+};
+
+int main() {
+  // printf("%c", myStr1.ch[0]) not support temporarily
+  struct Str1 myStr1 = {1, 1.5, {'a', 'b'}, {2, 3}};
+  printf("%d:%f:%hd:%d\n", myStr1.a, myStr1.b, myStr1.d.c, myStr1.d.e);
+
+  struct Str2 myStr2 = {4, 5};
+  struct Str1 myStr3 = {1, 1.5, {'a', 'b'}, .d = myStr2};
+  printf("%d:%f:%hd:%d\n", myStr3.a, myStr3.b, myStr3.d.c, myStr3.d.e);
+
+  struct Str1 myStr4 = {1, 1.5, {'a', 'b'}, .d = myStr2, .d.c = 6, .d.e = 7};
+  printf("%d:%f:%hd:%d\n", myStr4.a, myStr4.b, myStr4.d.c, myStr4.d.e);
+
+  struct Str1 myStr5 = {1, 1.5, {'a', 'b'}, .d = myStr2, .d.c = 8};
+  printf("%d:%f:%hd:%d\n", myStr5.a, myStr5.b, myStr5.d.c, myStr5.d.e);
+
+  struct Str2 myStr6 = (struct Str2){9, 10};
+  printf("%hd:%d\n", myStr6.c, myStr6.e);
+
+  size_t lenA = offsetof(struct Str1, a);
+  printf("%ld\n", lenA);
+
+  size_t lenB = offsetof(struct Str1, b);
+  printf("%ld\n", lenB);
+
+  size_t lenCh = offsetof(struct Str1, ch);
+  printf("%ld\n", lenCh);
+
+  size_t lenD = offsetof(struct Str1, d);
+  printf("%ld\n", lenD);
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0017-InitListExpr-Struct/expected.txt b/testsuite/c_test/ast_test/AST0017-InitListExpr-Struct/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..04c3a5eda968d43d59f9f4cdbcc1d350af36b313
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0017-InitListExpr-Struct/expected.txt
@@ -0,0 +1,9 @@
+1:1.500000:2:3
+1:1.500000:4:5
+1:1.500000:6:7
+1:1.500000:8:0
+9:10
+0
+8
+16
+20
diff --git a/testsuite/c_test/ast_test/AST0017-InitListExpr-Struct/test.cfg b/testsuite/c_test/ast_test/AST0017-InitListExpr-Struct/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..95f57ccfcb12aea6e1ddd050cb92797366d9578c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0017-InitListExpr-Struct/test.cfg
@@ -0,0 +1,2 @@
+compile(InitListExpr-Struct)
+run(InitListExpr-Struct)
diff --git a/testsuite/c_test/ast_test/AST0018-ConstantExprInEnum/ConstantExprInEnum.c b/testsuite/c_test/ast_test/AST0018-ConstantExprInEnum/ConstantExprInEnum.c
new file mode 100644
index 0000000000000000000000000000000000000000..44d53f872715d650314da7a95276f42c8c694bc7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0018-ConstantExprInEnum/ConstantExprInEnum.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+enum G {
+  g0 = 1,
+  g1 = sizeof(int),
+  g2,
+};
+
+int main() {
+  enum L {
+	l0 = 2,
+	l1,
+	l2 = sizeof(float)
+  };
+
+  printf("g0 = %d, g1 = %d, g2 = %d\nl0 = %d, l1 = %d, l2 = %d\n", g0, g1, g2, l0, l1, l2);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0018-ConstantExprInEnum/expected.txt b/testsuite/c_test/ast_test/AST0018-ConstantExprInEnum/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2890d91145f9376925dff2cea6e1bcf6e27a93e8
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0018-ConstantExprInEnum/expected.txt
@@ -0,0 +1,2 @@
+g0 = 1, g1 = 4, g2 = 5
+l0 = 2, l1 = 3, l2 = 4
diff --git a/testsuite/c_test/ast_test/AST0018-ConstantExprInEnum/test.cfg b/testsuite/c_test/ast_test/AST0018-ConstantExprInEnum/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..323ed2417d45d9b6d5b7eaf6fdcd2e2c4d8bb7d9
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0018-ConstantExprInEnum/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstantExprInEnum)
+run(ConstantExprInEnum)
diff --git a/testsuite/c_test/ast_test/AST0020-CStyleCastExpr/CStyleCastExpr.c b/testsuite/c_test/ast_test/AST0020-CStyleCastExpr/CStyleCastExpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f3c74a632ad0bf23c831c2b47eabeeb83cdae73
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0020-CStyleCastExpr/CStyleCastExpr.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+struct book {
+    int a;
+    int b;
+};
+int main() {
+  double a = 2.2;
+  int b = (int)a;
+  int c = 3;
+  double d = (double)c;
+  struct book m;
+  m.a = 1;
+  m.b = 2;
+  struct book n = (struct book)m;
+  void *vPtr = (void*)&b;
+  int *sPtr = (int*)vPtr;
+  int arr[2];
+  arr[0] = 7;
+  arr[1] = 8;
+  int *pArr = (int*)arr;
+  printf("%d, %f, %d, %d, %d, %d\n", b, d, n.a, n.b, *sPtr, *pArr);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0020-CStyleCastExpr/expected.txt b/testsuite/c_test/ast_test/AST0020-CStyleCastExpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cdac60069de455c628d801fd98a76d76c6176770
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0020-CStyleCastExpr/expected.txt
@@ -0,0 +1 @@
+2, 3.000000, 1, 2, 2, 7
diff --git a/testsuite/c_test/ast_test/AST0020-CStyleCastExpr/test.cfg b/testsuite/c_test/ast_test/AST0020-CStyleCastExpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7ebea2c38e32ba479c6995a386cc67ae8084705d
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0020-CStyleCastExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(CStyleCastExpr)
+run(CStyleCastExpr)
diff --git a/testsuite/c_test/ast_test/AST0021-SwitchCaseDefault/SwitchCaseDefault.c b/testsuite/c_test/ast_test/AST0021-SwitchCaseDefault/SwitchCaseDefault.c
new file mode 100644
index 0000000000000000000000000000000000000000..2046b8b799be90b4661df708fef8f8c5e0745e1f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0021-SwitchCaseDefault/SwitchCaseDefault.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+int main() {
+  int a = 5;
+  switch (a) {
+    case 0:{
+      a = 1;
+      break;
+    }
+    default: {
+      switch (a) {
+        case 2:
+          a = 3;
+        case 3:
+          a = 10;
+        case 5:
+          a = 20;
+      }
+      break;
+    }
+  }
+  printf("%d\n", a);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0021-SwitchCaseDefault/expected.txt b/testsuite/c_test/ast_test/AST0021-SwitchCaseDefault/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..209e3ef4b6247ce746048d5711befda46206d235
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0021-SwitchCaseDefault/expected.txt
@@ -0,0 +1 @@
+20
diff --git a/testsuite/c_test/ast_test/AST0021-SwitchCaseDefault/test.cfg b/testsuite/c_test/ast_test/AST0021-SwitchCaseDefault/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..03ad4c0b60d7b53a3bd67fda59f018c33cd7f107
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0021-SwitchCaseDefault/test.cfg
@@ -0,0 +1,2 @@
+compile(SwitchCaseDefault)
+run(SwitchCaseDefault)
diff --git a/testsuite/c_test/ast_test/AST0022-StructDReadField/StructDReadField.c b/testsuite/c_test/ast_test/AST0022-StructDReadField/StructDReadField.c
new file mode 100644
index 0000000000000000000000000000000000000000..82c0bebb10fe91d28d8668978657709f07817c6b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0022-StructDReadField/StructDReadField.c
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+struct Person1 {
+  char name;
+  int age;
+};
+
+struct Person2 {
+  int age;
+  char name;
+};
+
+int main() {
+  struct Person1 p1;
+  struct Person2 p2;
+  p1.name = 'a';
+  p1.age = 100;
+  p2.name = 'a';
+  p2.age = 100;
+  printf("%d%d\n", p1.age, p1.name);
+  printf("%d%c\n", p1.age, p1.name);
+  printf("%d%d\n", p2.age, p2.name);
+  printf("%d%c\n", p2.age, p2.name);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0022-StructDReadField/expected.txt b/testsuite/c_test/ast_test/AST0022-StructDReadField/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..882b71ced20d92cf55b89b653c87ddbc0fbbfb56
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0022-StructDReadField/expected.txt
@@ -0,0 +1,4 @@
+10097
+100a
+10097
+100a
diff --git a/testsuite/c_test/ast_test/AST0022-StructDReadField/test.cfg b/testsuite/c_test/ast_test/AST0022-StructDReadField/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c7712213ac346a4969f18fc8e3cee29bcb2c0215
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0022-StructDReadField/test.cfg
@@ -0,0 +1,2 @@
+compile(StructDReadField)
+run(StructDReadField)
diff --git a/testsuite/c_test/ast_test/AST0023-StructIReadField/StructIReadField.c b/testsuite/c_test/ast_test/AST0023-StructIReadField/StructIReadField.c
new file mode 100644
index 0000000000000000000000000000000000000000..716522bc6d57d44870a9631c5c9ad9681a765ff9
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0023-StructIReadField/StructIReadField.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+struct Person1 {
+  char name;
+  int age;
+};
+
+struct Person2 {
+  int age;
+  char name;
+};
+
+int main() {
+  struct Person1 p1;
+  struct Person2 p2;
+  p1.name = 'a';
+  p1.age = 100;
+  p2.name = 'a';
+  p2.age = 100;
+  struct Person1 *p1Ptr = &p1;
+  struct Person2 *p2Ptr = &p2;
+  printf("%d%d\n", p1Ptr->age, p1Ptr->name);
+  printf("%d%c\n", p1Ptr->age, p1Ptr->name);
+  printf("%d%d\n", p2Ptr->age, p2Ptr->name);
+  printf("%d%c\n", p2Ptr->age, p2Ptr->name);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0023-StructIReadField/expected.txt b/testsuite/c_test/ast_test/AST0023-StructIReadField/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..882b71ced20d92cf55b89b653c87ddbc0fbbfb56
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0023-StructIReadField/expected.txt
@@ -0,0 +1,4 @@
+10097
+100a
+10097
+100a
diff --git a/testsuite/c_test/ast_test/AST0023-StructIReadField/test.cfg b/testsuite/c_test/ast_test/AST0023-StructIReadField/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..436884978a34de16b00e574a0843af5feca3b2bf
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0023-StructIReadField/test.cfg
@@ -0,0 +1,2 @@
+compile(StructIReadField)
+run(StructIReadField)
diff --git a/testsuite/c_test/ast_test/AST0024-CompoundAssignOperator/CompoundAssignOperator.c b/testsuite/c_test/ast_test/AST0024-CompoundAssignOperator/CompoundAssignOperator.c
new file mode 100644
index 0000000000000000000000000000000000000000..15797023d35b3d4de2b37a42be53ee901e01cc9e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0024-CompoundAssignOperator/CompoundAssignOperator.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+int g_a = 10;
+int g_b = 20;
+
+int main()
+{
+  int a = 15;
+  int b = 35;
+
+  b += a;           // +=
+  g_b += g_a;
+  a += g_a;
+  printf("%d%d%d\n", b, g_b, a);
+  b -= a;           // -=
+  g_b -= g_a;
+  a -= g_a;
+  printf("%d%d%d\n", b, g_b, a);
+  b *= a;           // *=
+  g_b *= g_a;
+  a *= g_a;
+  printf("%d%d%d\n", b, g_b, a);
+  b /= a;           // /=
+  g_b /= g_a;
+  a /= g_a;
+  printf("%d%d%d\n", b, g_b, a);
+  b %= a;           // %=
+  g_b %= g_a;
+  a %= g_a;
+  printf("%d%d%d\n", b, g_b, a);
+
+  // TODO: need more nested example
+  b += g_a;
+  g_b %= a;
+  printf("%d%d\n", b, g_b);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0024-CompoundAssignOperator/expected.txt b/testsuite/c_test/ast_test/AST0024-CompoundAssignOperator/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9f934385024e4540c5e11dbf90f224ae104eea72
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0024-CompoundAssignOperator/expected.txt
@@ -0,0 +1,6 @@
+503025
+252015
+375200150
+22015
+205
+120
diff --git a/testsuite/c_test/ast_test/AST0024-CompoundAssignOperator/test.cfg b/testsuite/c_test/ast_test/AST0024-CompoundAssignOperator/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4544188f9061b0c933e03ac189dfb281c1bef851
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0024-CompoundAssignOperator/test.cfg
@@ -0,0 +1,2 @@
+compile(CompoundAssignOperator)
+run(CompoundAssignOperator)
diff --git a/testsuite/c_test/ast_test/AST0024-ConstantExprInBitField/ConstantExprInBitField.c b/testsuite/c_test/ast_test/AST0024-ConstantExprInBitField/ConstantExprInBitField.c
new file mode 100644
index 0000000000000000000000000000000000000000..41ebbdc093087e82933a2104540d25222a3e5da5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0024-ConstantExprInBitField/ConstantExprInBitField.c
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+struct A {
+  int i:2;
+  unsigned int j:2;
+};
+
+int main() {
+  struct A a;
+  a.i = 0x1;
+  printf("%d\n", a.i);
+
+  a.i = 0x2;
+  printf("%d\n", a.i);
+
+  a.i = 0x3;
+  printf("%d\n", a.i);
+
+  a.i = 0x5;
+  printf("%d\n", a.i);
+
+  a.i = 0x7;
+  printf("%d\n", a.i);
+
+  a.j = 0x1;
+  printf("%u\n", a.j);
+
+  a.j = 0x2;
+  printf("%u\n", a.j);
+
+  a.j = 0x3;
+  printf("%u\n", a.j);
+
+  a.j = 0x5;
+  printf("%u\n", a.j);
+
+  a.j = 0x7;
+  printf("%u\n", a.j);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0024-ConstantExprInBitField/expected.txt b/testsuite/c_test/ast_test/AST0024-ConstantExprInBitField/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7e9528a92f7e6962acb2dc6a62f9fea88c9b8e9e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0024-ConstantExprInBitField/expected.txt
@@ -0,0 +1,10 @@
+1
+-2
+-1
+1
+-1
+1
+2
+3
+1
+3
diff --git a/testsuite/c_test/ast_test/AST0024-ConstantExprInBitField/test.cfg b/testsuite/c_test/ast_test/AST0024-ConstantExprInBitField/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d862c9d35ae1854a4ba6d5ec3adb8ceafd7451b8
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0024-ConstantExprInBitField/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstantExprInBitField)
+run(ConstantExprInBitField)
diff --git a/testsuite/c_test/ast_test/AST0025-BinaryConditionalOperator/BinaryConditionalOperator.c b/testsuite/c_test/ast_test/AST0025-BinaryConditionalOperator/BinaryConditionalOperator.c
new file mode 100644
index 0000000000000000000000000000000000000000..b45b53397f889e5e5af38fa77815162dc0f68fdb
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0025-BinaryConditionalOperator/BinaryConditionalOperator.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int a = 0;
+  // comparative conditioan: a < 10, get true val = (a < 10) = 1
+  int b = (a < 10) ?: 1;
+  printf("%d %d\n", a, b); // 0 1
+  // noncomparative condition: a = 0, get false val
+  b = a ?: 2;
+  printf("%d %d\n", a, b); // 0 2
+
+  b = a++ ?: 2;
+  printf("%d %d\n", a, b); // 1 2
+  // noncomparative conditioan: a = 10, get true val = 10
+  a = 10;
+  b = a++ ?: 2;
+  printf("%d %d\n", a, b); // 11 10
+  // comparative conditioan: a < 9, get false val
+  b = (a < 9) ?: a++;
+  printf("%d %d\n", a, b); // 12 11
+  // multilevel conditional expr
+  b = (a < 10) ?: (b < 9) ?: (a = 2, a++);
+  printf("%d %d\n", a, b); // 3 2
+
+
+  // double type noncomparative condition, get false val
+  double c = 0.0;
+  double d = c++ ?: 2.0;
+  printf("%f %f\n", c, d); // 1.000000 2.000000
+  // double type noncomparative condition, get true val
+  c = 5.0;
+  d = c ?: 2.0;
+  printf("%f %f\n", c, d); // 5.000000 5.000000
+  // double type comparative condition, get true val
+  d = (c < 10.0) ?: 2.0;
+  printf("%f %f\n", c, d); // 5.000000 1.000000
+  // double type comparative condition, get false val
+  d = (c < 1.0) ?: 2.0;
+  printf("%f %f\n", c, d); // 5.000000 2.000000
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0025-BinaryConditionalOperator/expected.txt b/testsuite/c_test/ast_test/AST0025-BinaryConditionalOperator/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d24b8de30f60dee5b74a81e0fdd80bbb20a31bc5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0025-BinaryConditionalOperator/expected.txt
@@ -0,0 +1,10 @@
+0 1
+0 2
+1 2
+11 10
+12 11
+3 2
+1.000000 2.000000
+5.000000 5.000000
+5.000000 1.000000
+5.000000 2.000000
diff --git a/testsuite/c_test/ast_test/AST0025-BinaryConditionalOperator/test.cfg b/testsuite/c_test/ast_test/AST0025-BinaryConditionalOperator/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1332f34af0108941c62e0288f05bc07efa997875
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0025-BinaryConditionalOperator/test.cfg
@@ -0,0 +1,2 @@
+compile(BinaryConditionalOperator)
+run(BinaryConditionalOperator)
diff --git a/testsuite/c_test/ast_test/AST0025-FloatingLiteral/FloatingLiteral.c b/testsuite/c_test/ast_test/AST0025-FloatingLiteral/FloatingLiteral.c
new file mode 100644
index 0000000000000000000000000000000000000000..b5d3058b3f9fa72467a8922422936107d0853229
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0025-FloatingLiteral/FloatingLiteral.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+
+  // floating literal
+  printf("%.1f\n", 12345.678901);
+  printf("%2.3f\n", 12345.678901);
+  printf("%6.7f\n", 12345.678901);
+
+  printf("%.1f\n", 105.861233e2);
+  printf("%5.3f\n", 105.861233e2);
+  printf("%5.8f\n", 105.861233e2);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0025-FloatingLiteral/expected.txt b/testsuite/c_test/ast_test/AST0025-FloatingLiteral/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9d22ef0591320bf1130ef0ae201a9ee38215dc9f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0025-FloatingLiteral/expected.txt
@@ -0,0 +1,6 @@
+12345.7
+12345.679
+12345.6789010
+10586.1
+10586.123
+10586.12330000
diff --git a/testsuite/c_test/ast_test/AST0025-FloatingLiteral/test.cfg b/testsuite/c_test/ast_test/AST0025-FloatingLiteral/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..da412c1b2ce9946debc1188e028ac50d85a92ef3
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0025-FloatingLiteral/test.cfg
@@ -0,0 +1,2 @@
+compile(FloatingLiteral)
+run(FloatingLiteral)
diff --git a/testsuite/c_test/ast_test/AST0026-CharacterLiteral/CharacterLiteral.c b/testsuite/c_test/ast_test/AST0026-CharacterLiteral/CharacterLiteral.c
new file mode 100644
index 0000000000000000000000000000000000000000..20337621044095a015905083add57ef43a0b3c0f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0026-CharacterLiteral/CharacterLiteral.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+char g_a = 'a';
+int main() {
+
+  for (int c = 33; c <127; c++){  // ASCII 33->"!",...126->"~"
+    printf("%c\n",c);
+  }
+
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0026-CharacterLiteral/expected.txt b/testsuite/c_test/ast_test/AST0026-CharacterLiteral/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e17df2ad76a1679ec4c6473e27ac0ad07e65b8d3
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0026-CharacterLiteral/expected.txt
@@ -0,0 +1,94 @@
+!
+"
+#
+$
+%
+&
+'
+(
+)
+*
++
+,
+-
+.
+/
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+:
+;
+<
+=
+>
+?
+@
+A
+B
+C
+D
+E
+F
+G
+H
+I
+J
+K
+L
+M
+N
+O
+P
+Q
+R
+S
+T
+U
+V
+W
+X
+Y
+Z
+[
+\
+]
+^
+_
+`
+a
+b
+c
+d
+e
+f
+g
+h
+i
+j
+k
+l
+m
+n
+o
+p
+q
+r
+s
+t
+u
+v
+w
+x
+y
+z
+{
+|
+}
+~
diff --git a/testsuite/c_test/ast_test/AST0026-CharacterLiteral/test.cfg b/testsuite/c_test/ast_test/AST0026-CharacterLiteral/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9bd9c835921510eda8da02c36da5d183002da99b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0026-CharacterLiteral/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterLiteral)
+run(CharacterLiteral)
diff --git a/testsuite/c_test/ast_test/AST0026-Sizeof/Sizeof.c b/testsuite/c_test/ast_test/AST0026-Sizeof/Sizeof.c
new file mode 100644
index 0000000000000000000000000000000000000000..6b628a7984ce392f8690e3905835766c00dde9e5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0026-Sizeof/Sizeof.c
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  printf("%d,",sizeof(int));
+  printf("%d,",sizeof(long));
+  int a;
+  printf("%d,",sizeof(a));
+  struct A {
+    int a;
+    double b;
+  };
+  struct A aa;
+  printf("%d,",sizeof(struct A));
+  printf("%d\n",sizeof(aa));
+
+    // complex cases
+  long int l_int = -2147483647;
+  char c = 'a';
+  unsigned int u_int = 65535;
+  unsigned char u_char = 128;
+  float flt = 123.456789f;
+  double db = 1.23456789;
+  // long double ldb = 12.3456789123456;                //@fail case
+  double ldb = 12.3456789123456;
+  short int s_int = 0xa5;
+  int res = c + a;
+  char *p;
+  printf("%lu%lu%lu%lu", sizeof(l_int), sizeof(c), sizeof(u_int), sizeof(u_char));
+  printf("%lu%lu%lu%lu\n", sizeof(flt), sizeof(db), sizeof(s_int), sizeof(res));
+  struct B {
+    struct A a;
+  } B;
+  union u{
+    char c;
+    double d;
+  } u;
+  int arr[5];
+  double arr2[10];
+  printf("%lu%lu%lu%lu", sizeof(struct B), sizeof(p), sizeof(arr), sizeof(arr2));
+  printf("%lu%lu%lu%lu%lu%lu", sizeof(8), sizeof(8.8), sizeof("arr"), sizeof(u), sizeof(u.c), sizeof(u.d));
+  printf("\n%lu%lu%lu", sizeof(aa), sizeof(aa.a), sizeof(aa.b));
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0026-Sizeof/expected.txt b/testsuite/c_test/ast_test/AST0026-Sizeof/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8109eefd46894b7c2084cd28bec2bd723c9c0c15
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0026-Sizeof/expected.txt
@@ -0,0 +1,4 @@
+4,8,4,16,16
+81414824
+1682080484818
+1648
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0026-Sizeof/test.cfg b/testsuite/c_test/ast_test/AST0026-Sizeof/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..504528957cc8e154e66d86ca0df2bffa16375d16
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0026-Sizeof/test.cfg
@@ -0,0 +1,2 @@
+compile(Sizeof)
+run(Sizeof)
diff --git a/testsuite/c_test/ast_test/AST0027-GotoLabel/GotoLabel.c b/testsuite/c_test/ast_test/AST0027-GotoLabel/GotoLabel.c
new file mode 100644
index 0000000000000000000000000000000000000000..c9d74be0acee88da68c77cb45626a94adf5c3fca
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0027-GotoLabel/GotoLabel.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  printf("1");
+  goto i_am_here_1;
+  printf("failed;");
+  i_am_here_1:
+  printf("1");
+  goto i_am_here_2;
+  printf("failed;");
+  i_am_here_2:
+  printf("1");
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0027-GotoLabel/expected.txt b/testsuite/c_test/ast_test/AST0027-GotoLabel/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9d07aa0df55c353e18eea6f1b401946b5dad7bce
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0027-GotoLabel/expected.txt
@@ -0,0 +1 @@
+111
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0027-GotoLabel/test.cfg b/testsuite/c_test/ast_test/AST0027-GotoLabel/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ccbdb2dca17f6807f8643029aadcb823627ff827
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0027-GotoLabel/test.cfg
@@ -0,0 +1,2 @@
+compile(GotoLabel)
+run(GotoLabel)
diff --git a/testsuite/c_test/ast_test/AST0027-ICallassigned/ICallassigned.c b/testsuite/c_test/ast_test/AST0027-ICallassigned/ICallassigned.c
new file mode 100644
index 0000000000000000000000000000000000000000..31650e1f81cbcac1d710f6252bda48ac8bd83842
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0027-ICallassigned/ICallassigned.c
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+char *fpchar(void) {
+  return "yes_its_possible1";
+}
+
+char *(*fpfpchar(void))(void) {
+  return (fpchar);
+}
+
+char *(*(*fpfpfpchar(void))(void))(void) {
+  return (fpfpchar);
+}
+
+void fpvoid(void) {
+  printf("yes_its_possible2");
+}
+
+void (*fpfpvoid(void))(void) {
+  return (fpvoid);
+}
+
+void (*(*fpfpfpvoid(void))(void))(void) {
+  return (fpfpvoid);
+}
+
+void testv() {
+  printf("yes_its_possible3");
+}
+
+int testi() {
+  return 4;
+}
+
+int main() {
+  char *tmp = (((fpfpfpchar())())());
+  printf("%s", tmp);
+  (((fpfpfpvoid())())());
+  testv();
+  int a = testi();
+  printf("yes_its_possible%d", a);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0027-ICallassigned/expected.txt b/testsuite/c_test/ast_test/AST0027-ICallassigned/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..84fc5513754671a674c743a9d8099737af8f42fa
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0027-ICallassigned/expected.txt
@@ -0,0 +1 @@
+yes_its_possible1yes_its_possible2yes_its_possible3yes_its_possible4
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0027-ICallassigned/test.cfg b/testsuite/c_test/ast_test/AST0027-ICallassigned/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cadca6cf01935480d6bee333064bb57c23ff8fa7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0027-ICallassigned/test.cfg
@@ -0,0 +1,2 @@
+compile(ICallassigned)
+run(ICallassigned)
diff --git a/testsuite/c_test/ast_test/AST0028-ImplicitCvt/ImplicitCvt.c b/testsuite/c_test/ast_test/AST0028-ImplicitCvt/ImplicitCvt.c
new file mode 100644
index 0000000000000000000000000000000000000000..bbe91ca14ee4f1e67c69330b38f622d29f1b2846
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0028-ImplicitCvt/ImplicitCvt.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+long a = 65538;
+int b = 23;
+
+int main() {
+  if (ULONG_MAX >= 2147483647) {
+    printf("true");
+  }
+  long c = 655351111;
+  int d = 23;
+  if (c > d) {
+    printf("true");
+  }
+  if (a > b) {
+    printf("true");
+  }
+  float e = 2.2f;
+  double f = 2.3;
+  if (f > e) {
+    printf("true");
+  }
+  int i = e;
+  int j = f;
+  int h = 0;
+  h = e;
+  printf("%f", e);
+  printf("%f", f);
+  printf("%ld", a);
+  printf("%d", i);
+  printf("%d", j);
+  printf("%d", h);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0028-ImplicitCvt/expected.txt b/testsuite/c_test/ast_test/AST0028-ImplicitCvt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1f8f545a7d678531fa51e3f658a827bb264594ea
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0028-ImplicitCvt/expected.txt
@@ -0,0 +1 @@
+truetruetruetrue2.2000002.30000065538222
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0028-ImplicitCvt/test.cfg b/testsuite/c_test/ast_test/AST0028-ImplicitCvt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..886d9fd997af6936a5e461e9416e939febdf974f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0028-ImplicitCvt/test.cfg
@@ -0,0 +1,2 @@
+compile(ImplicitCvt)
+run(ImplicitCvt)
diff --git a/testsuite/c_test/ast_test/AST0028-PtrBinary/PtrBinary.c b/testsuite/c_test/ast_test/AST0028-PtrBinary/PtrBinary.c
new file mode 100644
index 0000000000000000000000000000000000000000..9c315d2c4130f67343b962253115e37f88132d8f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0028-PtrBinary/PtrBinary.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int a = 1;
+  int b = 2;
+  int c = 3;
+  int *pa = &a;
+  int *pb = &b;
+  int *pc = &c;
+  printf("%d,", *pa);
+  printf("%d,", *(pa+1));
+  printf("%d,", *(pa+2));
+  printf("%ld\n", (pc - pa));
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0028-PtrBinary/expected.txt b/testsuite/c_test/ast_test/AST0028-PtrBinary/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65f986cd2192bb117a24cbb74707db042918fdd3
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0028-PtrBinary/expected.txt
@@ -0,0 +1 @@
+1,2,3,2
diff --git a/testsuite/c_test/ast_test/AST0028-PtrBinary/test.cfg b/testsuite/c_test/ast_test/AST0028-PtrBinary/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..da489c17959ef4aebe2c7e0a745a45897a72a56a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0028-PtrBinary/test.cfg
@@ -0,0 +1,2 @@
+compile(PtrBinary)
+run(PtrBinary)
diff --git a/testsuite/c_test/ast_test/AST0031-SameNameTypeDeclInDifferentScope/SameNameTypeDeclInDifferentScope.c b/testsuite/c_test/ast_test/AST0031-SameNameTypeDeclInDifferentScope/SameNameTypeDeclInDifferentScope.c
new file mode 100644
index 0000000000000000000000000000000000000000..cdd0ae332fb17d274c1af5e37659a2747a456a9e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0031-SameNameTypeDeclInDifferentScope/SameNameTypeDeclInDifferentScope.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  struct A { int a; } aa;
+  aa.a = 111;
+  {
+    struct A { double d; } dd;
+    dd.d = 3.14;
+    printf("dd.d = %f\n", dd.d);
+    {
+      struct A { char c; } cc;
+      cc.c = 'a';
+      printf("cc.c = %c\n", cc.c);
+    }
+  }
+
+  printf("aa.a = %d\n", aa.a);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0031-SameNameTypeDeclInDifferentScope/expected.txt b/testsuite/c_test/ast_test/AST0031-SameNameTypeDeclInDifferentScope/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7a47b67b07539bd882cb98f38a5c8973e7fa2dbb
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0031-SameNameTypeDeclInDifferentScope/expected.txt
@@ -0,0 +1,3 @@
+dd.d = 3.140000
+cc.c = a
+aa.a = 111
diff --git a/testsuite/c_test/ast_test/AST0031-SameNameTypeDeclInDifferentScope/test.cfg b/testsuite/c_test/ast_test/AST0031-SameNameTypeDeclInDifferentScope/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4d6828b50ed3470713c8828b0dacf0c578810a1e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0031-SameNameTypeDeclInDifferentScope/test.cfg
@@ -0,0 +1,2 @@
+compile(SameNameTypeDeclInDifferentScope)
+run(SameNameTypeDeclInDifferentScope)
diff --git a/testsuite/c_test/ast_test/AST0032-SameNameVarIndifferentScope/SameNameVarIndifferentScope.c b/testsuite/c_test/ast_test/AST0032-SameNameVarIndifferentScope/SameNameVarIndifferentScope.c
new file mode 100644
index 0000000000000000000000000000000000000000..c82534f588dada181195142f7c7a019ebabd5372
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0032-SameNameVarIndifferentScope/SameNameVarIndifferentScope.c
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+enum {
+  e = 0
+};
+extern int aa;
+int aa;
+int main() {
+  aa = 123;
+  int x = 1;
+  printf("e = %d\n", e);
+  enum E {
+    e = 11
+  };
+  {
+    printf("e = %d\n", e);
+    enum EE {
+      e = 22
+    };
+    printf("x = %d\n", x);
+    int x = 2;
+    {
+      printf("e = %d\n", e);
+      printf("x = %d\n", x);
+      int x = 3;
+      enum EEE {
+        e = 33
+      };
+      printf("e = %d\n", e);
+      printf("x = %d\n", x);
+    }
+    printf("x = %d\n", x);
+  }
+  printf("e = %d\n", e);
+  printf("x = %d\n", x);
+  printf("aa = %d\n", aa);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0032-SameNameVarIndifferentScope/expected.txt b/testsuite/c_test/ast_test/AST0032-SameNameVarIndifferentScope/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f18d783234d67f3924c17095a4b466bc68ed8139
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0032-SameNameVarIndifferentScope/expected.txt
@@ -0,0 +1,11 @@
+e = 0
+e = 11
+x = 1
+e = 22
+x = 2
+e = 33
+x = 3
+x = 2
+e = 11
+x = 1
+aa = 123
diff --git a/testsuite/c_test/ast_test/AST0032-SameNameVarIndifferentScope/test.cfg b/testsuite/c_test/ast_test/AST0032-SameNameVarIndifferentScope/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4298f1b2e7ed9d2af84f6f444f86ce00854c1c99
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0032-SameNameVarIndifferentScope/test.cfg
@@ -0,0 +1,2 @@
+compile(SameNameVarIndifferentScope)
+run(SameNameVarIndifferentScope)
diff --git a/testsuite/c_test/ast_test/AST0033-StmtExpr/StmtExpr.c b/testsuite/c_test/ast_test/AST0033-StmtExpr/StmtExpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..56a804ceea9abfecc07a25a00a3608df0ee8ab2e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0033-StmtExpr/StmtExpr.c
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+ 
+int main() {
+  ({int a = 1; a = 2; a;});
+  int x = ({int a = 11; a = 22; a;});
+  printf("x = %d\n", x);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0033-StmtExpr/expected.txt b/testsuite/c_test/ast_test/AST0033-StmtExpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bb516a779476dca94bf71f7b25366412e16e5e76
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0033-StmtExpr/expected.txt
@@ -0,0 +1 @@
+x = 22
diff --git a/testsuite/c_test/ast_test/AST0033-StmtExpr/test.cfg b/testsuite/c_test/ast_test/AST0033-StmtExpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..831ed5c5c24b5896ec266cba029cfb92b0d4729c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0033-StmtExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtExpr)
+run(StmtExpr)
diff --git a/testsuite/c_test/ast_test/AST0034-ArrayInStruct/ArrayInStruct.c b/testsuite/c_test/ast_test/AST0034-ArrayInStruct/ArrayInStruct.c
new file mode 100644
index 0000000000000000000000000000000000000000..60952333c358c367641fd3252cd4c7b6fe4a4faa
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0034-ArrayInStruct/ArrayInStruct.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+struct C {
+ char f;
+};
+struct B {
+ char c;
+ char d;
+ struct C inc;
+};
+struct A {
+  int a;
+  int b;
+  char inArr[2][2];
+  double inArr1[2][2];
+  struct B inb;
+};
+
+int main() {
+  struct A sa = {1, 2, {'a', 'b','c'},{2.5, 6.8,8.5,45.2},{'d','f',{'g'}}};
+  char c1 = sa.inArr[0][1];
+  char c2 = sa.inArr[1][0];
+  double c11 = sa.inArr1[0][1];
+  double c21 = sa.inArr1[1][0];
+  double c22 = sa.inArr1[1][1];
+  sa.inArr1[1][1] = 22.2;
+  double c23 = sa.inArr1[1][1];
+  printf("%c\n",c1);
+  printf("%c\n",c2);
+  printf("%f\n",c11);
+  printf("%f\n",c21);
+  printf("%f\n",c22);
+  printf("%f\n",sa.inArr1[1][1]);
+  printf("%f\n",c23);
+  printf("%c\n",sa.inb.inc.f);
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0034-ArrayInStruct/expected.txt b/testsuite/c_test/ast_test/AST0034-ArrayInStruct/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d36a6db149a01e2ba5d259499f721216f8b11f53
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0034-ArrayInStruct/expected.txt
@@ -0,0 +1,8 @@
+b
+c
+6.800000
+8.500000
+45.200000
+22.200000
+22.200000
+g
diff --git a/testsuite/c_test/ast_test/AST0034-ArrayInStruct/test.cfg b/testsuite/c_test/ast_test/AST0034-ArrayInStruct/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a7c0055ec306047ebc44ef50fb50436d97bf090c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0034-ArrayInStruct/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayInStruct)
+run(ArrayInStruct)
diff --git a/testsuite/c_test/ast_test/AST0035-ImplicitValueInitExpr/ImplicitValueInitExpr.c b/testsuite/c_test/ast_test/AST0035-ImplicitValueInitExpr/ImplicitValueInitExpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..e801e1b7eafbff51df4ca6d398463e3d0ac7e75c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0035-ImplicitValueInitExpr/ImplicitValueInitExpr.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stddef.h>
+
+struct Str2 {
+  short c;
+  int e;
+};
+
+struct Str1 {
+  int a;
+  double b;
+  int arr[2];
+  struct Str2 d;
+};
+
+int main() {
+  struct Str1 myStr1 = {1};
+  printf("%d:%f:%d:%d:%hd:%d\n", myStr1.a, myStr1.b, myStr1.arr[0], myStr1.arr[1], myStr1.d.c, myStr1.d.e);
+
+  struct Str2 myStr2 = {4};
+  struct Str1 myStr3 = {1, .d = myStr2};
+  printf("%d:%f:%d:%d:%hd:%d\n", myStr3.a, myStr3.b, myStr3.arr[0], myStr3.arr[1], myStr3.d.c, myStr3.d.e);
+
+  myStr2.e = 3;
+  struct Str1 myStr4 = {1, 1.5, .d = myStr2, .d.c = 5 };
+  printf("%d:%f:%d:%d:%hd:%d\n", myStr4.a, myStr4.b, myStr4.arr[0], myStr4.arr[1], myStr4.d.c, myStr4.d.e);
+
+  struct Str1 myStr5 = {1, .arr = {6, 7}, .d.c = 8};
+  printf("%d:%f:%d:%d:%hd:%d\n", myStr5.a, myStr5.b, myStr5.arr[0], myStr5.arr[1], myStr5.d.c, myStr5.d.e);
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0035-ImplicitValueInitExpr/expected.txt b/testsuite/c_test/ast_test/AST0035-ImplicitValueInitExpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fbc6574557acacf90b02f11ec3928699539cbeb9
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0035-ImplicitValueInitExpr/expected.txt
@@ -0,0 +1,4 @@
+1:0.000000:0:0:0:0
+1:0.000000:0:0:4:0
+1:1.500000:0:0:5:0
+1:0.000000:6:7:8:0
diff --git a/testsuite/c_test/ast_test/AST0035-ImplicitValueInitExpr/test.cfg b/testsuite/c_test/ast_test/AST0035-ImplicitValueInitExpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fa3e98c9fd2357e6c79d0c27f5f41340e8babb78
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0035-ImplicitValueInitExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(ImplicitValueInitExpr)
+run(ImplicitValueInitExpr)
diff --git a/testsuite/c_test/ast_test/AST0036-Complex/Complex.c b/testsuite/c_test/ast_test/AST0036-Complex/Complex.c
new file mode 100644
index 0000000000000000000000000000000000000000..23635b7ec4446d3b22b2010d9c68bf5beb954fa6
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0036-Complex/Complex.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <complex.h>
+
+int main() {
+  float complex a = 1 + I;
+  printf("%f + i%f\n", __real a , __imag a);
+  float complex b = 1 + I;
+  printf("%f + i%f\n", __real b , __imag b);
+  float complex c = a + b;
+  printf("%f + i%f\n", __real c , __imag c);
+  complex double d = a - b;
+  printf("%f + i%f\n", __real d , __imag d);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0036-Complex/expected.txt b/testsuite/c_test/ast_test/AST0036-Complex/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0244aca82c5cdddcfa2e097b3da467b8b074a0e7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0036-Complex/expected.txt
@@ -0,0 +1,4 @@
+1.000000 + i1.000000
+1.000000 + i1.000000
+2.000000 + i2.000000
+0.000000 + i0.000000
diff --git a/testsuite/c_test/ast_test/AST0036-Complex/test.cfg b/testsuite/c_test/ast_test/AST0036-Complex/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2904001c8d6773da86b0ceae6608d1271f39792c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0036-Complex/test.cfg
@@ -0,0 +1,2 @@
+compile(Complex)
+run(Complex)
diff --git a/testsuite/c_test/ast_test/AST0036-TypeDef/TypeDef.c b/testsuite/c_test/ast_test/AST0036-TypeDef/TypeDef.c
new file mode 100644
index 0000000000000000000000000000000000000000..48455e62d803caf93b83e56deefb8a96eb224c28
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0036-TypeDef/TypeDef.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+typedef int MyInt;
+typedef struct A { int i; } StructA;
+int main() {
+  typedef float MyFloat;
+  StructA a;
+  a.i = 22;
+  typedef struct A { double d; } StructA;
+  StructA a0;
+  a0.d = 1.414;
+  MyInt i = 11;
+  MyFloat f = 3.14;
+  printf("i = %d\n", i);
+  printf("f = %f\n", f);
+  printf("a.i = %d\n", a.i);
+  printf("a0.d = %f\n", a0.d);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0036-TypeDef/expected.txt b/testsuite/c_test/ast_test/AST0036-TypeDef/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..43a1c844d5a42e5576f71b1cb2f2560499d4b717
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0036-TypeDef/expected.txt
@@ -0,0 +1,4 @@
+i = 11
+f = 3.140000
+a.i = 22
+a0.d = 1.414000
diff --git a/testsuite/c_test/ast_test/AST0036-TypeDef/test.cfg b/testsuite/c_test/ast_test/AST0036-TypeDef/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2a2651ab049e83556727def5ec604868e932df6b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0036-TypeDef/test.cfg
@@ -0,0 +1,2 @@
+compile(TypeDef)
+run(TypeDef)
diff --git a/testsuite/c_test/ast_test/AST0037-VAArgExpr/VAArgExpr.c b/testsuite/c_test/ast_test/AST0037-VAArgExpr/VAArgExpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..233e51797d6eca0bf020ab32d78e23c692dbf78e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0037-VAArgExpr/VAArgExpr.c
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdarg.h>
+
+typedef struct demo1 {
+  int a;
+  short b;
+} demo1;
+
+typedef struct demo2 {
+  float a;
+  float b;
+  float c;
+} demo2;  // HFA 
+
+typedef struct demo3 {
+  double a;
+  double b;
+  double c;
+} demo3;  // copyed mem
+
+typedef struct demo4 {
+  float a;
+  float arr[3];
+} demo4;  // HFA nested array
+
+void func(int a, ...) { // reg
+  va_list vl;
+  printf("a: %d\n",a);
+  va_start(vl, a);
+  double b = va_arg(vl, double);
+  printf("b: %lf\n", b);
+  long c = va_arg(vl, long);
+  printf("c: %ld\n", c);
+  char *d = va_arg(vl, char *);
+  printf("d: %s\n", d);
+  demo1 e = va_arg(vl, demo1);
+  printf("e.a: %d\n", e.a);
+  printf("e.b: %d\n", e.b);
+  demo2 f = va_arg(vl, demo2);
+  printf("f.a: %lf\n", f.a);
+  printf("f.b: %lf\n", f.b);
+  printf("f.c: %lf\n", f.c);
+  demo3 g = va_arg(vl, demo3);
+  printf("g.a: %lf\n", g.a);
+  printf("g.b: %lf\n", g.b);
+  printf("g.c: %lf\n", g.c);
+  demo4 h = va_arg(vl, demo4);
+  printf("g.a: %lf\n", h.a);
+  printf("g.a: %lf\n", h.arr[2]);
+  va_end(vl);
+}
+
+void func1(int a, ...) { // stack
+  va_list vl1;
+  printf("a: %d\n",a);
+  va_start(vl1, a);
+ 
+  for (int i = 1; i <= 8; i++) {
+    int ii = va_arg(vl1, int);
+    printf("ii%d: %d\n", i, ii);
+  }
+
+  for (int i = 1; i <= 8; i++) {
+    double dd = va_arg(vl1, double);
+    printf("dd%d: %lf\n", i, dd);
+  }
+
+  double b = va_arg(vl1, double);
+  printf("b: %lf\n", b);
+  long c = va_arg(vl1, long);
+  printf("c: %ld\n", c);
+  char *d = va_arg(vl1, char *);
+  printf("d: %s\n", d);
+  demo1 e = va_arg(vl1, demo1);
+  printf("e.a: %d\n", e.a);
+  printf("e.b: %d\n", e.b);
+  demo2 f = va_arg(vl1, demo2);
+  printf("f.a: %lf\n", f.a);
+  printf("f.b: %lf\n", f.b);
+  printf("f.c: %lf\n", f.c);
+  demo3 g = va_arg(vl1, demo3);
+  printf("g.a: %lf\n", g.a);
+  printf("g.b: %lf\n", g.b);
+  printf("g.c: %lf\n", g.c);
+  demo4 h = va_arg(vl1, demo4);
+  printf("g.a: %lf\n", h.a);
+  printf("g.a: %lf\n", h.arr[2]);
+  va_end(vl1);
+}
+
+int main() {
+  int a = 20;       // int 
+  double b = 30.0;  // double
+  long c = 123L;
+  char *d = "abc";  // ptr
+  demo1 e;          // struct
+  e.a = 100;
+  e.b = 101;
+  demo2 f;
+  f.a = 1.1f;
+  f.b = 1.2f;
+  f.c = 1.3f;
+  demo3 g;
+  g.a = 3.14;
+  g.b = 1.234;
+  g.c = 1.0;
+  demo4 h;
+  h.a = 2.22;
+  h.arr[2] = 3.33;
+  func(a, b, c, d, e, f, g, h);
+  func1(a, 1, 2, 3, 4, 5, 6, 7 ,8, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 ,7.7, 8.8, b, c, d, e, f, g, h);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0037-VAArgExpr/expected.txt b/testsuite/c_test/ast_test/AST0037-VAArgExpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..41bf5fe6b913c266871d6f9b376ff23fa60337e1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0037-VAArgExpr/expected.txt
@@ -0,0 +1,44 @@
+a: 20
+b: 30.000000
+c: 123
+d: abc
+e.a: 100
+e.b: 101
+f.a: 1.100000
+f.b: 1.200000
+f.c: 1.300000
+g.a: 3.140000
+g.b: 1.234000
+g.c: 1.000000
+g.a: 2.220000
+g.a: 3.330000
+a: 20
+ii1: 1
+ii2: 2
+ii3: 3
+ii4: 4
+ii5: 5
+ii6: 6
+ii7: 7
+ii8: 8
+dd1: 1.100000
+dd2: 2.200000
+dd3: 3.300000
+dd4: 4.400000
+dd5: 5.500000
+dd6: 6.600000
+dd7: 7.700000
+dd8: 8.800000
+b: 30.000000
+c: 123
+d: abc
+e.a: 100
+e.b: 101
+f.a: 1.100000
+f.b: 1.200000
+f.c: 1.300000
+g.a: 3.140000
+g.b: 1.234000
+g.c: 1.000000
+g.a: 2.220000
+g.a: 3.330000
diff --git a/testsuite/c_test/ast_test/AST0037-VAArgExpr/test.cfg b/testsuite/c_test/ast_test/AST0037-VAArgExpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8e9359c55543c8ca3f1f73acfe3ecb270f12a4c6
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0037-VAArgExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(VAArgExpr)
+run(VAArgExpr)
diff --git a/testsuite/c_test/ast_test/AST0038-GlobalAggInit/GlobalAggInit.c b/testsuite/c_test/ast_test/AST0038-GlobalAggInit/GlobalAggInit.c
new file mode 100644
index 0000000000000000000000000000000000000000..47bfcc292d96e830c6fd62bfddabb4197e8e5421
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0038-GlobalAggInit/GlobalAggInit.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+struct A {
+  int i[2];
+  float f;
+};
+const int cInt = 111;
+enum {
+  e0,
+  e1
+};
+union U {
+  char c;
+  int i;
+  short s;
+  float f;
+};
+
+union U u = { .f=10.1 };
+
+struct A Aarray[2] = { { { e0, e1 }, 11.1f },
+                       { { sizeof(int), 4 }, 22.2f }
+                     };
+struct A a = { { 5, e1 }, 33.3f };
+int i[3] = { 3 + 1, 2, 1};
+
+struct CC {
+  int i;
+  struct A *a;
+};
+
+struct CC c = { .a = (struct A[1]){{{1,2}, 1.123}}};
+//
+struct D {
+  int y;
+  double z;
+  int i;
+  int j;
+  struct E {
+    int i;
+    int j;
+    struct F {
+      int y;
+    } f;
+  } e;
+} d;
+struct F *pf = &d.e.f;
+
+enum X {
+  ONE,
+  TWO,
+  THREE,
+  FOUR,
+  FIVE
+};
+
+struct G {
+  int a;
+  int b;
+  union {
+    int c;
+    enum X *x;
+  } d;
+  double f;
+};
+struct G gg = {
+  .b = 2,
+  .d.x = ((const enum X[]) {FIVE, ONE, THREE}),
+  .f = 3.14,
+};
+
+struct G gg1 = {.d.x = (const enum X[]) {FIVE, ONE, THREE}};
+
+int main() {
+  printf("a.i[0] = %d\na.i[1] = %d\n", a.i[0], a.i[1]);
+  printf("i[0] = %d\ni[1] = %d\ni[2] = %d\n", i[0], i[1], i[2]);
+  printf("u.f = %f\n", u.f);
+  pf->y = 2;
+  printf("d.e.f.y=%d, pf=%d\n", d.e.f.y, pf->y);
+  printf("c.a->i[1]=%d, c.a->f=%f\n", c.a->i[1], c.a->f);
+  
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0038-GlobalAggInit/expected.txt b/testsuite/c_test/ast_test/AST0038-GlobalAggInit/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5489fc34502aa2b98e6957eee88e5aebe14c1a7f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0038-GlobalAggInit/expected.txt
@@ -0,0 +1,8 @@
+a.i[0] = 5
+a.i[1] = 1
+i[0] = 4
+i[1] = 2
+i[2] = 1
+u.f = 10.100000
+d.e.f.y=2, pf=2
+c.a->i[1]=2, c.a->f=1.123000
diff --git a/testsuite/c_test/ast_test/AST0038-GlobalAggInit/test.cfg b/testsuite/c_test/ast_test/AST0038-GlobalAggInit/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bf57935704a0728f64881f94e5961ba43d6a5446
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0038-GlobalAggInit/test.cfg
@@ -0,0 +1,2 @@
+compile(GlobalAggInit)
+run(GlobalAggInit)
diff --git a/testsuite/c_test/ast_test/AST0038-GlobalVar/GlobalVar.c b/testsuite/c_test/ast_test/AST0038-GlobalVar/GlobalVar.c
new file mode 100644
index 0000000000000000000000000000000000000000..a80d98cce0beb375f5400ff4f35e095b4994681f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0038-GlobalVar/GlobalVar.c
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+// double c = 3.14159;                                                              // fail case
+// long double d = 1.11111;                                                         // fail case
+// float arr3[] = {1.0, -1.0, 0 , 0};                                               // fail case
+// float arr4[] = {1.0f, -1.0, 0 , 0};                                              // fail case
+// float arr4[] = {1.0f, -1.0f};                                                    // fail case, wrong value
+// struct A A = {10, 10.1, 10.2, 'a'};                                              // fail case
+int a = 1;
+float b = 1.1;
+struct A {
+  int Aa;
+  float Ab;
+  double Ac;
+  char Ad;
+} A;                                                                                // A = {10, 10.1, 10.2, 'a'} fail
+
+struct A *pA = &A;
+int arr[] = {1, 2, 3};
+float arr2[3] = {0.0};
+float arr3[] = {1.0, -1.0};
+char arr4[] = {'a','c'};
+float f = (1.17549435e-38f <= 1.1) ? 1.1 : 9.9;
+struct B{
+  int Barr[2];
+  float Barr2[2];
+  double Barr3[2];
+  char Barr4[2];
+} B;
+struct B *pB = &B;
+int lenA = sizeof(A) + 1;
+enum DAY{
+  MON=1, TUE, WED, THU, FRI, SAT, SUN
+} day = WED;
+union data{
+    int n;
+    char ch;
+    double f;
+} data;
+// const struct C {                                                                 // fail case
+//   int a;
+//   char c;
+//   double d;
+// } C = {1, 'a', 2.222};
+int main() {
+  A.Aa = 10;
+  A.Ab = 10.1;
+  A.Ac = 10.2;
+  A.Ad = 'a';
+  B.Barr[0] = 20;
+  B.Barr[1] = 22;
+  B.Barr2[0] = 20.1;
+  B.Barr2[1] = 22.1;
+  B.Barr3[0] = 20.131;
+  B.Barr3[1] = 22.131;
+  B.Barr4[0] = 'b';
+  B.Barr4[1] = 'c';
+  data.n = 4;
+  data.ch ='s';
+  data.f = 1.234;
+  printf("%d\n", a);
+  printf("%f\n", b);
+  printf("%f\n", A.Ac);
+  printf("%d%d%d\n", arr[0], arr[1], arr[2]);
+  printf("%f%f%f\n", arr2[0], arr2[1], arr2[2]);
+  printf("%f%f\n", arr3[0], arr3[1]);
+  printf("%c%c\n", arr4[0], arr4[1]);
+  printf("%f\n", f);
+  printf("%d%d%d\n", *arr, *(arr + 1), *(arr + 2));
+  printf("%f%f%f\n", *arr2, *(arr2 + 1), *(arr2 + 2));
+  printf("%f%f\n", *arr3, *(arr2 + 1));
+  printf("%c%c\n", *arr4, *(arr4 + 1));
+  printf("%d%d%d", lenA, sizeof(pA), sizeof(pB));
+  printf("%d%d\n", day, sizeof(day));
+  printf("%d%c%f\n",data.n, data.ch, data.f);
+  // printf("%c%c%c", A.Ad, B.Barr4[0], B.Barr4[1]);                                  // fail case
+  // printf("%d\n", A.Aa);                                                            // fail case, wrong value
+  // printf("%f\n", A.Ab);                                                            // fail case, wrong value
+  // printf("%d%f%f\n", pA->Aa, pA->Ab, pA->Ac);                                      // fail case
+  // printf("%d%d\n", pB->Barr[0], pB->Barr[1]);                                      // fail case
+  // printf("%f%f%f%f\n", pB->Barr2[0], pB->Barr2[1], pB->Barr3[0], pB->Barr3[1]);    // fail case
+  // printf("%f%f\n", arr4[0], arr4[1]);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0038-GlobalVar/expected.txt b/testsuite/c_test/ast_test/AST0038-GlobalVar/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9113a848ff89212bfeed36c14a3f21b064a27aaf
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0038-GlobalVar/expected.txt
@@ -0,0 +1,14 @@
+1
+1.100000
+10.200000
+123
+0.0000000.0000000.000000
+1.000000-1.000000
+ac
+1.100000
+123
+0.0000000.0000000.000000
+1.0000000.000000
+ac
+258834
+-927712936X1.234000
diff --git a/testsuite/c_test/ast_test/AST0038-GlobalVar/test.cfg b/testsuite/c_test/ast_test/AST0038-GlobalVar/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..96ad7ecf4e04a03412b8b3881c6552866f97bff0
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0038-GlobalVar/test.cfg
@@ -0,0 +1,2 @@
+compile(GlobalVar)
+run(GlobalVar)
diff --git a/testsuite/c_test/ast_test/AST0039-StructInArray/StructInArray.c b/testsuite/c_test/ast_test/AST0039-StructInArray/StructInArray.c
new file mode 100644
index 0000000000000000000000000000000000000000..7d7c54ec72764b95308ab4478bcb6ba0df12572e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0039-StructInArray/StructInArray.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+struct A {
+  int a;
+  int b;
+};
+
+struct B {
+  int c;
+  int d;
+  struct A singleA;
+  int inB[2];
+};
+
+struct C {
+    char i[20];
+    char j[2][20];
+    unsigned int k;
+};
+
+typedef struct D {
+    char a[20];
+    char b[4][20];
+    unsigned int c;
+    char d[1][20];
+    struct C info;
+} dd;
+
+dd g_d[5] = {
+    {"abc", {"abcd"}, 1, {"abc"}, {"12", {"34"}, 1}},  // b[4][20] and d[1][20] filled by an element
+		{"def", {"efgh", "igkl"}, 2, {"abc"}, {"56", {"78", "910"}, 2}},
+    {"", {""}, 3, {""}, {"",{""}, 3}},
+};
+
+
+int main() {
+  struct B s1;
+  s1.inB[1] = 15;
+  printf("%d\n", s1.inB[1]);
+
+  struct A saa[4] = {{1,2},{3,4},{5,6},{7,8}};
+  printf("%d\n",saa[0].a);
+  printf("%d\n",saa[1].b);
+  saa[0].a = 10;
+  printf("%d\n",saa[0].a);
+  saa[1].b = 20;
+  saa[0].a = 30;
+  printf("%d\n",saa[0].a);
+  printf("%d\n",saa[1].b);
+  printf("%d\n",saa[2].a);
+  printf("%d\n",saa[2].b);
+  printf("%d\n",saa[3].a);
+  printf("%d\n",saa[3].b);
+
+  printf("g_d[0].a=%s, g_d[1].a=%s, g_d[2].a=%s\n",g_d[0].a, g_d[1].a, g_d[2].a);
+  printf("g_d[0].b[0]=%s, g_d[1].b[0]=%s, g_d[2].b[0]=%s\n",g_d[0].b[0], g_d[1].b[0], g_d[2].b[0]);
+  printf("g_d[0].b[1]=%s, g_d[1].b[1]=%s,  g_d[2].b[1]=%s\n",g_d[0].b[1], g_d[1].b[1], g_d[2].b[1]);
+  printf("g_d[0].c=%d, g_d[1].c=%d, g_dd[2].c=%d\n",g_d[0].c, g_d[1].c, g_d[2].c);
+  printf("g_d[0].d[0]=%s, g_d[1].d[0]=%s, g_d[2].d[0]=%s\n",g_d[0].d[0], g_d[1].d[0], g_d[2].d[0]);
+  printf("g_d[0].info.j[0]=%s, g_d[1].info.j[0]=%s, g_d[2].info.j[0]=%s\n",g_d[0].info.j[0], g_d[1].info.j[0], g_d[2].info.j[0]);
+  printf("g_d[0].info.j[1]=%s, g_d[1].info.j[1]=%s, g_d[2].info.j[1]=%s\n", g_d[0].info.j[1], g_d[1].info.j[1], g_d[2].info.j[1]);
+
+  dd d[5] = {
+    {"abc", {"abcd"}, 1, {"abc"}, {"12", {"34"}, 1}},  // b[4][20] and d[1][20] filled by an element
+    {"def", {"efgh", "igkl"}, 2, {"abc"}, {"56", {"78", "910"}, 2}},
+    {"", {""}, 3, {""}, {"",{""}, 3}},
+  };
+
+  printf("d[0].a=%s, d[1].a=%s, d[2].a=%s\n",d[0].a, d[1].a, d[2].a);
+  printf("d[0].b[0]=%s, d[1].b[0]=%s, d[2].b[0]=%s\n",d[0].b[0], d[1].b[0], d[2].b[0]);
+  printf("d[0].b[1]=%s, d[1].b[1]=%s, d[2].b[1]=%s\n",d[0].b[1], d[1].b[1], d[2].b[1]);
+  printf("d[0].c=%d, d[1].c=%d, d[2].c=%d\n",d[0].c, d[1].c, d[2].c);
+  printf("d[0].d[0]=%s, d[1].d[0]=%s, d[2].d[0]=%s\n",d[0].d[0], d[1].d[0], d[2].d[0]);
+  printf("d[0].info.j[0]=%s, d[1].info.j[0]=%s, d[2].info.j[0]=%s\n",d[0].info.j[0], d[1].info.j[0], d[2].info.j[0]);
+  printf("d[0].info.j[1]=%s, d[1].info.j[1]=%s, d[2].info.j[1]=%s\n", d[0].info.j[1], d[1].info.j[1], d[2].info.j[1]);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0039-StructInArray/expected.txt b/testsuite/c_test/ast_test/AST0039-StructInArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..203e746d2ac4784d9928358a08e9ba67a7e1c243
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0039-StructInArray/expected.txt
@@ -0,0 +1,24 @@
+15
+1
+4
+10
+30
+20
+5
+6
+7
+8
+g_d[0].a=abc, g_d[1].a=def, g_d[2].a=
+g_d[0].b[0]=abcd, g_d[1].b[0]=efgh, g_d[2].b[0]=
+g_d[0].b[1]=, g_d[1].b[1]=igkl,  g_d[2].b[1]=
+g_d[0].c=1, g_d[1].c=2, g_dd[2].c=3
+g_d[0].d[0]=abc, g_d[1].d[0]=abc, g_d[2].d[0]=
+g_d[0].info.j[0]=34, g_d[1].info.j[0]=78, g_d[2].info.j[0]=
+g_d[0].info.j[1]=, g_d[1].info.j[1]=910, g_d[2].info.j[1]=
+d[0].a=abc, d[1].a=def, d[2].a=
+d[0].b[0]=abcd, d[1].b[0]=efgh, d[2].b[0]=
+d[0].b[1]=, d[1].b[1]=igkl, d[2].b[1]=
+d[0].c=1, d[1].c=2, d[2].c=3
+d[0].d[0]=abc, d[1].d[0]=abc, d[2].d[0]=
+d[0].info.j[0]=34, d[1].info.j[0]=78, d[2].info.j[0]=
+d[0].info.j[1]=, d[1].info.j[1]=910, d[2].info.j[1]=
diff --git a/testsuite/c_test/ast_test/AST0039-StructInArray/test.cfg b/testsuite/c_test/ast_test/AST0039-StructInArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..33c07861938f8b2ad00491539ce5578b7c8bfe95
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0039-StructInArray/test.cfg
@@ -0,0 +1,2 @@
+compile(StructInArray)
+run(StructInArray)
diff --git a/testsuite/c_test/ast_test/AST0040-LocalAggInitialization/LocalAggInitialization.c b/testsuite/c_test/ast_test/AST0040-LocalAggInitialization/LocalAggInitialization.c
new file mode 100644
index 0000000000000000000000000000000000000000..051bf80593e7a488c1e10c9febe5be8d0675da05
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0040-LocalAggInitialization/LocalAggInitialization.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+struct S {
+  float f;
+  int i[3];
+};
+union U {
+  char ch;
+  int i;
+  char c[4];
+};
+union U g = {};
+struct SU {
+  int i;
+  union U u;
+};
+int main() {
+  struct S s0 = {};
+  struct S s = { 3.14f, { 3, 4, 5, } };
+  printf("%f, %d, %d, %d\n", s.f, s.i[0], s.i[1], s.i[2]);
+  union U u = {{0}};
+  union U u0 = {};
+  union U u1 = { 2 };
+  union U u2 = { 'a', 2 };
+  printf("%d %d %d %d %c %d\n", u.i, u0.i, u1.c[2], u1.i, u2.ch, u2.c[1]);
+
+  struct SU su = { 22, { 33 }};
+  printf("%d\n", su.u.i);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0040-LocalAggInitialization/expected.txt b/testsuite/c_test/ast_test/AST0040-LocalAggInitialization/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e33c5c8bb2110e8a00fc3a4f83c0cd82914c1029
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0040-LocalAggInitialization/expected.txt
@@ -0,0 +1,3 @@
+3.140000, 3, 4, 5
+0 0 0 2 a 0
+33
diff --git a/testsuite/c_test/ast_test/AST0040-LocalAggInitialization/test.cfg b/testsuite/c_test/ast_test/AST0040-LocalAggInitialization/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..55e9414b14b97d6da3720f655abe3abf2be9f777
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0040-LocalAggInitialization/test.cfg
@@ -0,0 +1,2 @@
+compile(LocalAggInitialization)
+run(LocalAggInitialization)
diff --git a/testsuite/c_test/ast_test/AST0041-AddrOfLabel/AddrOfLabel.c b/testsuite/c_test/ast_test/AST0041-AddrOfLabel/AddrOfLabel.c
new file mode 100644
index 0000000000000000000000000000000000000000..eaac69b6e0a25dba7c9ecda8cead6312af0bfb07
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0041-AddrOfLabel/AddrOfLabel.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+int main() {
+  void *plb = 0;
+  int visited = 0;
+lb:
+  printf("%d\n", 111);
+  plb = &&lb;
+  if (visited == 0) {
+    visited = 1;
+    goto *plb;
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0041-AddrOfLabel/expected.txt b/testsuite/c_test/ast_test/AST0041-AddrOfLabel/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2bbe845f4ef76194eda16eaad3b846e7ba014516
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0041-AddrOfLabel/expected.txt
@@ -0,0 +1,2 @@
+111
+111
diff --git a/testsuite/c_test/ast_test/AST0041-AddrOfLabel/test.cfg b/testsuite/c_test/ast_test/AST0041-AddrOfLabel/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc83ff8fa61442e19cc8fe0c943d828c9677fcbd
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0041-AddrOfLabel/test.cfg
@@ -0,0 +1,2 @@
+compile(AddrOfLabel)
+run(AddrOfLabel)
diff --git a/testsuite/c_test/ast_test/AST0042-NEON-Vst1/Vst1.c b/testsuite/c_test/ast_test/AST0042-NEON-Vst1/Vst1.c
new file mode 100644
index 0000000000000000000000000000000000000000..961e32c59cc65fcca261f69c23d8363736804d54
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0042-NEON-Vst1/Vst1.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+int main() {
+  unsigned char a[16] = {'a','a','b','b','c','c','d','d',
+                         'a','a','b','b','c','c','d','d'};
+  unsigned char b[16];
+  uint8x16_t A;
+
+  A = vld1q_u8(a);
+  vst1q_u8(b, A);
+  for (int i = 0; i < 16; i++) {
+    printf("%c ", b[i]);
+  }
+  printf("\n");
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0042-NEON-Vst1/expected.txt b/testsuite/c_test/ast_test/AST0042-NEON-Vst1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c1679d66370ac868748e7783422c83a61048b88a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0042-NEON-Vst1/expected.txt
@@ -0,0 +1 @@
+a a b b c c d d a a b b c c d d 
diff --git a/testsuite/c_test/ast_test/AST0042-NEON-Vst1/test.cfg b/testsuite/c_test/ast_test/AST0042-NEON-Vst1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..77f45eb3d38f57c7b7a9644e693eecb3b14ddd1b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0042-NEON-Vst1/test.cfg
@@ -0,0 +1,2 @@
+compile(Vst1)
+run(Vst1)
diff --git a/testsuite/c_test/ast_test/AST0043-NEON-Vld1qU8/Vld1qU8.c b/testsuite/c_test/ast_test/AST0043-NEON-Vld1qU8/Vld1qU8.c
new file mode 100644
index 0000000000000000000000000000000000000000..7d42b877400d1c3c92bf8a1b50b78e27a547febe
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0043-NEON-Vld1qU8/Vld1qU8.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint8x16(uint8x16_t *a, int n) {
+  uint8_t *p = (uint8_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%c ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint8_t data[16] = {'a','a','b','b','c','c','d','d',
+                      'a','a','b','b','c','c','d','d'};
+  uint8x16_t A;   //copy data to matrix A
+  A = vld1q_u8(data);
+  print_uint8x16(&A, 16);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0043-NEON-Vld1qU8/expected.txt b/testsuite/c_test/ast_test/AST0043-NEON-Vld1qU8/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c1679d66370ac868748e7783422c83a61048b88a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0043-NEON-Vld1qU8/expected.txt
@@ -0,0 +1 @@
+a a b b c c d d a a b b c c d d 
diff --git a/testsuite/c_test/ast_test/AST0043-NEON-Vld1qU8/test.cfg b/testsuite/c_test/ast_test/AST0043-NEON-Vld1qU8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ca87a29b602d39c114dd057354ea2a7a06049dcb
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0043-NEON-Vld1qU8/test.cfg
@@ -0,0 +1,2 @@
+compile(Vld1qU8)
+run(Vld1qU8)
diff --git a/testsuite/c_test/ast_test/AST0044-NEON-VdupqnS32/VdupqnS32.c b/testsuite/c_test/ast_test/AST0044-NEON-VdupqnS32/VdupqnS32.c
new file mode 100644
index 0000000000000000000000000000000000000000..8f7cf17f2352047acd1f9739b3504c7c3ccddd15
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0044-NEON-VdupqnS32/VdupqnS32.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_int32x4(int32x4_t *a, int n) {
+  int32_t *p = (int32_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  int32_t data = 2;
+  int32x4_t A;
+  A = vdupq_n_s32(data);
+  print_int32x4(&A, 4);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0044-NEON-VdupqnS32/expected.txt b/testsuite/c_test/ast_test/AST0044-NEON-VdupqnS32/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..22a32f49208dacad233b17e33774ce94f73a34c0
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0044-NEON-VdupqnS32/expected.txt
@@ -0,0 +1 @@
+2 2 2 2 
diff --git a/testsuite/c_test/ast_test/AST0044-NEON-VdupqnS32/test.cfg b/testsuite/c_test/ast_test/AST0044-NEON-VdupqnS32/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..40c74c33074edcb12b168b3f975b6e1f51358282
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0044-NEON-VdupqnS32/test.cfg
@@ -0,0 +1,2 @@
+compile(VdupqnS32)
+run(VdupqnS32)
diff --git a/testsuite/c_test/ast_test/AST0045-NEON-VdupqnU8/VdupqnU8.c b/testsuite/c_test/ast_test/AST0045-NEON-VdupqnU8/VdupqnU8.c
new file mode 100644
index 0000000000000000000000000000000000000000..fefc31050e98a0440805de7f07a58b5bf728a6ae
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0045-NEON-VdupqnU8/VdupqnU8.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint8x16(uint8x16_t *a, int n) {
+  uint8_t *p = (uint8_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%c ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint8_t data = 'a';
+  uint8x16_t A;
+  A = vdupq_n_u8(data);
+  print_uint8x16(&A, 16);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0045-NEON-VdupqnU8/expected.txt b/testsuite/c_test/ast_test/AST0045-NEON-VdupqnU8/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..538a1a83ea1bdd5db98a44a2f1927e9983bc6489
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0045-NEON-VdupqnU8/expected.txt
@@ -0,0 +1 @@
+a a a a a a a a a a a a a a a a 
diff --git a/testsuite/c_test/ast_test/AST0045-NEON-VdupqnU8/test.cfg b/testsuite/c_test/ast_test/AST0045-NEON-VdupqnU8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a128506b0e6d7aa140965c0a3ff25ede1a47a9d7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0045-NEON-VdupqnU8/test.cfg
@@ -0,0 +1,2 @@
+compile(VdupqnU8)
+run(VdupqnU8)
diff --git a/testsuite/c_test/ast_test/AST0046-NEON-VextqU8/VextqU8.c b/testsuite/c_test/ast_test/AST0046-NEON-VextqU8/VextqU8.c
new file mode 100644
index 0000000000000000000000000000000000000000..0a559902914af4666ab6fb84a1022bd40aa9b709
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0046-NEON-VextqU8/VextqU8.c
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint8x16(uint8x16_t *a, int n) {
+  uint8_t *p = (uint8_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%c ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint8_t a[16] = {'a','a','b','b','c','c','d','d',
+                  'a','a','b','b','c','c','d','d'};
+  uint8_t b[6] = {'e','f','g','h','j','k'};
+  uint8x16_t A, B, C;
+
+  A = vld1q_u8(a);
+  B = vld1q_u8(b);
+  C = vextq_u8(A, B, 3);  
+  print_uint8x16(&C,16);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0046-NEON-VextqU8/expected.txt b/testsuite/c_test/ast_test/AST0046-NEON-VextqU8/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cc9bb5ba4062f16ebb1f9646f18c2e3860bea129
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0046-NEON-VextqU8/expected.txt
@@ -0,0 +1 @@
+b c c d d a a b b c c d d e f g 
diff --git a/testsuite/c_test/ast_test/AST0046-NEON-VextqU8/test.cfg b/testsuite/c_test/ast_test/AST0046-NEON-VextqU8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..73be0b742944f87e5ce696fcd474545a72cba10f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0046-NEON-VextqU8/test.cfg
@@ -0,0 +1,2 @@
+compile(VextqU8)
+run(VextqU8)
diff --git a/testsuite/c_test/ast_test/AST0047-NEON-VgetU64/VgetU64.c b/testsuite/c_test/ast_test/AST0047-NEON-VgetU64/VgetU64.c
new file mode 100644
index 0000000000000000000000000000000000000000..817ab2a4a486848c9f789f09c319b01921e03ed3
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0047-NEON-VgetU64/VgetU64.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint64x1(uint64x1_t *a, int n) {
+  uint64_t *p = (uint64_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  // uint64_t data[2] = {2,3};
+  uint64x2_t A = {2,3};
+  uint64x1_t B, C;
+  // A = vld1q_u64(data);
+  B = vget_high_u64(A);
+  C = vget_low_u64(A);
+  print_uint64x1(&B,1);
+  print_uint64x1(&C,1);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0047-NEON-VgetU64/expected.txt b/testsuite/c_test/ast_test/AST0047-NEON-VgetU64/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c058554e8c0eccd4832839de74fdfad7ab34e6a4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0047-NEON-VgetU64/expected.txt
@@ -0,0 +1,2 @@
+3 
+2 
diff --git a/testsuite/c_test/ast_test/AST0047-NEON-VgetU64/test.cfg b/testsuite/c_test/ast_test/AST0047-NEON-VgetU64/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5e58e75a9ec9f70d1c02ad4022f425f8a8395f14
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0047-NEON-VgetU64/test.cfg
@@ -0,0 +1,2 @@
+compile(VgetU64)
+run(VgetU64)
diff --git a/testsuite/c_test/ast_test/AST0048-NEON-Vreinterpreq/Vreinterpreq.c b/testsuite/c_test/ast_test/AST0048-NEON-Vreinterpreq/Vreinterpreq.c
new file mode 100644
index 0000000000000000000000000000000000000000..0f5b7b49484686f157c8629e8eff229c47237154
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0048-NEON-Vreinterpreq/Vreinterpreq.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint64x2(uint64x2_t *a, int n) {
+  uint64_t *p = (uint64_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint8_t data[16] = {2,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0};
+  uint8x16_t A;
+  uint64x2_t B;
+  A = vld1q_u8(data);
+  B = vreinterpretq_u64_u8(A);
+  print_uint64x2(&B,2);
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0048-NEON-Vreinterpreq/expected.txt b/testsuite/c_test/ast_test/AST0048-NEON-Vreinterpreq/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8f25926dc82744ae196419e246e101b57a3b7053
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0048-NEON-Vreinterpreq/expected.txt
@@ -0,0 +1 @@
+2 1 
diff --git a/testsuite/c_test/ast_test/AST0048-NEON-Vreinterpreq/test.cfg b/testsuite/c_test/ast_test/AST0048-NEON-Vreinterpreq/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1faee89cb6e7fcb6540f72b534e35648cbcdff19
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0048-NEON-Vreinterpreq/test.cfg
@@ -0,0 +1,2 @@
+compile(Vreinterpreq)
+run(Vreinterpreq)
diff --git a/testsuite/c_test/ast_test/AST0049-NEON-VgetLane/VgetLane.c b/testsuite/c_test/ast_test/AST0049-NEON-VgetLane/VgetLane.c
new file mode 100644
index 0000000000000000000000000000000000000000..fba12bf355e66d022a5a112853c5d6b734417a00
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0049-NEON-VgetLane/VgetLane.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+int main() {
+  uint32x2_t A = {1,2};
+  uint32x4_t B = {2,3,4,5};
+  uint32_t a, b;
+
+  a = vget_lane_u32(A, 0);     //v2u32
+  b = vgetq_lane_u32(B, 2);    //v4u32
+  printf("%d ", a);
+  printf("%d ", b);
+  printf("\n");
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0049-NEON-VgetLane/expected.txt b/testsuite/c_test/ast_test/AST0049-NEON-VgetLane/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e6c8843164658b82241755cd0580c14dbcb0c722
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0049-NEON-VgetLane/expected.txt
@@ -0,0 +1 @@
+1 4 
diff --git a/testsuite/c_test/ast_test/AST0049-NEON-VgetLane/test.cfg b/testsuite/c_test/ast_test/AST0049-NEON-VgetLane/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f79f9ad9ea1f9b3d23721e4b339f5a15194f758f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0049-NEON-VgetLane/test.cfg
@@ -0,0 +1,2 @@
+compile(VgetLane)
+run(VgetLane)
diff --git a/testsuite/c_test/ast_test/AST0050-NEON-Vpaddlq/Vpaddlq.c b/testsuite/c_test/ast_test/AST0050-NEON-Vpaddlq/Vpaddlq.c
new file mode 100644
index 0000000000000000000000000000000000000000..c789db070e824ce549a29f6a8fc2fdb4b665cfd1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0050-NEON-Vpaddlq/Vpaddlq.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint32x4(uint32x4_t *a, int n) {
+  uint32_t *p = (uint32_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+
+int main() {
+  uint16_t data[8] = {2,3,4,5,6,7,8,9};
+  uint16x8_t A;
+  uint32x4_t B;
+
+  A = vld1q_u16(data);
+  B = vpaddlq_u16(A);  //add pairs of adjacent unsigned integer values
+  print_uint32x4(&B, 4);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0050-NEON-Vpaddlq/expected.txt b/testsuite/c_test/ast_test/AST0050-NEON-Vpaddlq/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e60066a57788c177f8e31a67824ca5d1a8a3384b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0050-NEON-Vpaddlq/expected.txt
@@ -0,0 +1 @@
+5 9 13 17 
diff --git a/testsuite/c_test/ast_test/AST0050-NEON-Vpaddlq/test.cfg b/testsuite/c_test/ast_test/AST0050-NEON-Vpaddlq/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c1dca1cebc8286074c9e637fe270a4e16fcda708
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0050-NEON-Vpaddlq/test.cfg
@@ -0,0 +1,2 @@
+compile(Vpaddlq)
+run(Vpaddlq)
diff --git a/testsuite/c_test/ast_test/AST0051-NEON-VsetqLane/VsetqLane.c b/testsuite/c_test/ast_test/AST0051-NEON-VsetqLane/VsetqLane.c
new file mode 100644
index 0000000000000000000000000000000000000000..1b980b349e61cfaf93ea54cd12a92ab4b02590ee
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0051-NEON-VsetqLane/VsetqLane.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+int main() {
+  uint32_t data[4] = {2,3,4,5};
+  uint32x4_t A, B;
+  uint32_t lane;
+
+  A = vld1q_u32(data);
+  B = vsetq_lane_u32(8, A, 0);
+  lane = vgetq_lane_u32(B, 0);
+  printf("%d ", lane);
+  printf("\n");
+
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0051-NEON-VsetqLane/expected.txt b/testsuite/c_test/ast_test/AST0051-NEON-VsetqLane/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cebfa009bacd1e9b12b4638c61441e6d2f13540a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0051-NEON-VsetqLane/expected.txt
@@ -0,0 +1 @@
+8 
diff --git a/testsuite/c_test/ast_test/AST0051-NEON-VsetqLane/test.cfg b/testsuite/c_test/ast_test/AST0051-NEON-VsetqLane/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..824f5cbd8ac3bcb727aed5a506396b0190a3b2cf
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0051-NEON-VsetqLane/test.cfg
@@ -0,0 +1,2 @@
+compile(VsetqLane)
+run(VsetqLane)
diff --git a/testsuite/c_test/ast_test/AST0052-NEON-Vrev32q/Vrev32q.c b/testsuite/c_test/ast_test/AST0052-NEON-Vrev32q/Vrev32q.c
new file mode 100644
index 0000000000000000000000000000000000000000..6d4c27a1d80c9395cda956d39447f7be094dc263
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0052-NEON-Vrev32q/Vrev32q.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint8x16(uint8x16_t *a, int n) {
+  uint8_t *p = (uint8_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%c ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint8_t data[8] = {'a','a','b','b','c','c','d','d'};
+  uint8x16_t A, B;
+
+  A = vld1q_u8(data);
+  B = vrev32q_u8(A);
+  print_uint8x16(&B, 8);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0052-NEON-Vrev32q/expected.txt b/testsuite/c_test/ast_test/AST0052-NEON-Vrev32q/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..16c694078240283251fca94a2883a1bc67112b2f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0052-NEON-Vrev32q/expected.txt
@@ -0,0 +1 @@
+b b a a d d c c 
diff --git a/testsuite/c_test/ast_test/AST0052-NEON-Vrev32q/test.cfg b/testsuite/c_test/ast_test/AST0052-NEON-Vrev32q/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d1c64d0a9ea0b0355ebd2f97d87f873b741058cf
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0052-NEON-Vrev32q/test.cfg
@@ -0,0 +1,2 @@
+compile(Vrev32q)
+run(Vrev32q)
diff --git a/testsuite/c_test/ast_test/AST0053-NEON-Vaddq/Vaddq.c b/testsuite/c_test/ast_test/AST0053-NEON-Vaddq/Vaddq.c
new file mode 100644
index 0000000000000000000000000000000000000000..ee974aa376f8a55d73d991bba397f61bc2817261
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0053-NEON-Vaddq/Vaddq.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+int main() {
+  uint16x8_t A = {1,2,3,4,5,6,7,8};
+  uint16_t a;
+
+  a = vaddvq_u16(A);
+  printf("%d", a);
+  printf("\n");
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0053-NEON-Vaddq/expected.txt b/testsuite/c_test/ast_test/AST0053-NEON-Vaddq/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7facc89938bbc5635e3d36ffa56b4c85e9b07db8
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0053-NEON-Vaddq/expected.txt
@@ -0,0 +1 @@
+36
diff --git a/testsuite/c_test/ast_test/AST0053-NEON-Vaddq/test.cfg b/testsuite/c_test/ast_test/AST0053-NEON-Vaddq/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3f74a9871c2b7244b737b1cec610dd1912ccf128
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0053-NEON-Vaddq/test.cfg
@@ -0,0 +1,2 @@
+compile(Vaddq)
+run(Vaddq)
diff --git a/testsuite/c_test/ast_test/AST0054-NEON-Veorq/Veorq.c b/testsuite/c_test/ast_test/AST0054-NEON-Veorq/Veorq.c
new file mode 100644
index 0000000000000000000000000000000000000000..267ab3320e6da7d4e58e6967482cb342810740a5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0054-NEON-Veorq/Veorq.c
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint32x4(uint32x4_t *a, int n) {
+  uint32_t *p = (uint32_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint32_t a[4] = {1,2,3,4};
+  uint32_t b[4] = {5,6,7,8};
+  uint32x4_t A, B, C;
+
+  A = vld1q_u32(a);
+  B = vld1q_u32(b);
+  C = veorq_u32(A, B);
+  print_uint32x4(&C, 4);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0054-NEON-Veorq/expected.txt b/testsuite/c_test/ast_test/AST0054-NEON-Veorq/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f57967ea8dda2b5012ff8996b2e611ccc7d547cf
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0054-NEON-Veorq/expected.txt
@@ -0,0 +1 @@
+4 4 4 12 
diff --git a/testsuite/c_test/ast_test/AST0054-NEON-Veorq/test.cfg b/testsuite/c_test/ast_test/AST0054-NEON-Veorq/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..24c2ded2db9c02a1fd1535a6fb9c23aedd605475
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0054-NEON-Veorq/test.cfg
@@ -0,0 +1,2 @@
+compile(Veorq)
+run(Veorq)
diff --git a/testsuite/c_test/ast_test/AST0055-NEON-Vmlal/Vmlal.c b/testsuite/c_test/ast_test/AST0055-NEON-Vmlal/Vmlal.c
new file mode 100644
index 0000000000000000000000000000000000000000..27cba3489523bca33502a97d5149095782344937
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0055-NEON-Vmlal/Vmlal.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uin64x2(uint64x2_t *a, int n) {
+  uint64_t *p = (uint64_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint32x2_t A = {1,2}, B = {3,4};
+  uint64x2_t C = {5,6};
+  uint64x2_t D;
+
+  D = vmlal_u32(C, A, B);
+  print_uin64x2(&D, 2);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0055-NEON-Vmlal/expected.txt b/testsuite/c_test/ast_test/AST0055-NEON-Vmlal/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..780f6211e2ca3095a9c6593a2538eabd3112fed9
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0055-NEON-Vmlal/expected.txt
@@ -0,0 +1 @@
+8 14 
diff --git a/testsuite/c_test/ast_test/AST0055-NEON-Vmlal/test.cfg b/testsuite/c_test/ast_test/AST0055-NEON-Vmlal/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5416485745ba5c6dab20b979e50fab340f66f69f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0055-NEON-Vmlal/test.cfg
@@ -0,0 +1,2 @@
+compile(Vmlal)
+run(Vmlal)
diff --git a/testsuite/c_test/ast_test/AST0056-NEON-Vmovn/Vmovn.c b/testsuite/c_test/ast_test/AST0056-NEON-Vmovn/Vmovn.c
new file mode 100644
index 0000000000000000000000000000000000000000..c54a4f54f8d15a7111a1605e36f8a34ea8143145
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0056-NEON-Vmovn/Vmovn.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uin32x2(uint32x2_t *a, int n) {
+  uint32_t *p = (uint32_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint64x2_t A = {4294967297,4294967298};
+  uint32x2_t B;
+
+  B = vmovn_u64(A);
+  print_uin32x2(&B, 2);
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0056-NEON-Vmovn/expected.txt b/testsuite/c_test/ast_test/AST0056-NEON-Vmovn/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a40ee1166fb96522a3f3eb0732687b98248b3e21
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0056-NEON-Vmovn/expected.txt
@@ -0,0 +1 @@
+1 2 
diff --git a/testsuite/c_test/ast_test/AST0056-NEON-Vmovn/test.cfg b/testsuite/c_test/ast_test/AST0056-NEON-Vmovn/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..89cfa94a0a80e7f4b39e3eb9f9d404d649ec9558
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0056-NEON-Vmovn/test.cfg
@@ -0,0 +1,2 @@
+compile(Vmovn)
+run(Vmovn)
diff --git a/testsuite/c_test/ast_test/AST0058-NEON-Vzip/Vzip.c b/testsuite/c_test/ast_test/AST0058-NEON-Vzip/Vzip.c
new file mode 100644
index 0000000000000000000000000000000000000000..2808cc2235fdf17ae21c0d17e51cee5dff516ab4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0058-NEON-Vzip/Vzip.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uin32x2x2(uint32x2x2_t *a, int n) {
+  uint32_t *p = (uint32_t *)a;
+  int i;
+  for (i = 0; i < n/2; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+  for (i = n/2; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+}
+
+int main() {
+  uint32x2_t A = {1,2}, B = {3,4};
+  uint32x2x2_t C;
+
+  C = vzip_u32(A, B);       //interleaves the pairs
+
+  print_uin32x2x2(&C, 4);
+  printf("\n");
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0058-NEON-Vzip/expected.txt b/testsuite/c_test/ast_test/AST0058-NEON-Vzip/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..104aa068a708d715330bb7f07480a04b4edc8d56
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0058-NEON-Vzip/expected.txt
@@ -0,0 +1,2 @@
+1 3 
+2 4 
diff --git a/testsuite/c_test/ast_test/AST0058-NEON-Vzip/test.cfg b/testsuite/c_test/ast_test/AST0058-NEON-Vzip/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e8f5a785280b39d59f0b88981f76f35143d32ebc
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0058-NEON-Vzip/test.cfg
@@ -0,0 +1,2 @@
+compile(Vzip)
+run(Vzip)
diff --git a/testsuite/c_test/ast_test/AST0059-NEON-Vmull/Vmull.c b/testsuite/c_test/ast_test/AST0059-NEON-Vmull/Vmull.c
new file mode 100644
index 0000000000000000000000000000000000000000..699e2fd44c065c27207b76e6752dc1b132de9ac1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0059-NEON-Vmull/Vmull.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint64x2(uint64x2_t *a, int n) {
+  uint64_t *p = (uint64_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+
+}
+
+void print_uint32x2(uint32x2_t *a, int n) {
+  uint32_t *p = (uint32_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint32x2_t A = {3,9}, B = {10,2};
+  uint64x2_t C;
+
+  C = vmull_u32(A, B);      //multiply
+  print_uint32x2(&A, 2);
+  print_uint32x2(&B, 2);
+  print_uint64x2(&C, 2);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0059-NEON-Vmull/expected.txt b/testsuite/c_test/ast_test/AST0059-NEON-Vmull/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ef7995aabbcee0d1c298710a812d69262481d76
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0059-NEON-Vmull/expected.txt
@@ -0,0 +1,3 @@
+3 9 
+10 2 
+30 18 
diff --git a/testsuite/c_test/ast_test/AST0059-NEON-Vmull/test.cfg b/testsuite/c_test/ast_test/AST0059-NEON-Vmull/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a195279978f742d554b232352ae1c8df11ad197a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0059-NEON-Vmull/test.cfg
@@ -0,0 +1,2 @@
+compile(Vmull)
+run(Vmull)
diff --git a/testsuite/c_test/ast_test/AST0060-NEON-Vshlq/Vshlq.c b/testsuite/c_test/ast_test/AST0060-NEON-Vshlq/Vshlq.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d3b4580f62ba9e5c25f25b63ec0a3f7738e9769
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0060-NEON-Vshlq/Vshlq.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint64x2(uint64x2_t *a, int n) {
+  uint64_t *p = (uint64_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint64x2_t A = {5,10};
+  uint64x2_t B;
+
+  B = vshlq_n_u64(A, 2);   //left shift 2 bits
+  print_uint64x2(&B, 2);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0060-NEON-Vshlq/expected.txt b/testsuite/c_test/ast_test/AST0060-NEON-Vshlq/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d91dc7f7077e101bec833ea4f836db90982f8f77
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0060-NEON-Vshlq/expected.txt
@@ -0,0 +1 @@
+20 40 
diff --git a/testsuite/c_test/ast_test/AST0060-NEON-Vshlq/test.cfg b/testsuite/c_test/ast_test/AST0060-NEON-Vshlq/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f1db455b64dcae0c3d53c731aed8cae548216e3e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0060-NEON-Vshlq/test.cfg
@@ -0,0 +1,2 @@
+compile(Vshlq)
+run(Vshlq)
diff --git a/testsuite/c_test/ast_test/AST0062-NEON-Vshrq/Vshrq.c b/testsuite/c_test/ast_test/AST0062-NEON-Vshrq/Vshrq.c
new file mode 100644
index 0000000000000000000000000000000000000000..b485a77681459a344461af6d40d10ae5bbd3516c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0062-NEON-Vshrq/Vshrq.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint64x2(uint64x2_t *a, int n) {
+  uint64_t *p = (uint64_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint64x2_t A = {17179869191,17179869187};
+  uint64x2_t B;
+
+  B = vshrq_n_u64(A, 1);
+  print_uint64x2(&B, 2);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0062-NEON-Vshrq/expected.txt b/testsuite/c_test/ast_test/AST0062-NEON-Vshrq/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9f20e0bab932868462e4c3b97b5327b8de1826c3
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0062-NEON-Vshrq/expected.txt
@@ -0,0 +1 @@
+3 1 
diff --git a/testsuite/c_test/ast_test/AST0062-NEON-Vshrq/test.cfg b/testsuite/c_test/ast_test/AST0062-NEON-Vshrq/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68c8a35f140563b94f957e9a5b7f9191f58e52dc
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0062-NEON-Vshrq/test.cfg
@@ -0,0 +1,2 @@
+compile(Vshrq)
+run(Vshrq)
diff --git a/testsuite/c_test/ast_test/AST0063-NEON-Vceqq/Vceqq.c b/testsuite/c_test/ast_test/AST0063-NEON-Vceqq/Vceqq.c
new file mode 100644
index 0000000000000000000000000000000000000000..0deaa6d731b81f683f897298e4220523cde471f7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0063-NEON-Vceqq/Vceqq.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint16x8(uint16x8_t *a, int n) {
+  uint16_t *p = (uint16_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint16x8_t A = {1,2,3,4,5,6,7,8},
+             B = {1,2,4,3,5,6,8,7};
+  uint16x8_t C;
+
+  C = vceqq_u16(A, B);
+  print_uint16x8(&C, 8);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0063-NEON-Vceqq/expected.txt b/testsuite/c_test/ast_test/AST0063-NEON-Vceqq/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..430a3dfbe877224a8fbbdbee5a984fabeea7fc87
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0063-NEON-Vceqq/expected.txt
@@ -0,0 +1 @@
+65535 65535 0 0 65535 65535 0 0 
diff --git a/testsuite/c_test/ast_test/AST0063-NEON-Vceqq/test.cfg b/testsuite/c_test/ast_test/AST0063-NEON-Vceqq/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b3cc7e5e1f9fdbbf8e6cba840377feb76818923d
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0063-NEON-Vceqq/test.cfg
@@ -0,0 +1,2 @@
+compile(Vceqq)
+run(Vceqq)
diff --git a/testsuite/c_test/ast_test/AST0064-NEON-Vandq/Vandq.c b/testsuite/c_test/ast_test/AST0064-NEON-Vandq/Vandq.c
new file mode 100644
index 0000000000000000000000000000000000000000..d5c7e982ed1a8ca40b66a6e7e1756cf17a736407
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0064-NEON-Vandq/Vandq.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint16x8(uint16x8_t *a, int n) {
+  uint16_t *p = (uint16_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint16x8_t A = {1,2,3,4,5,6,7,8},
+             B = {10,20,30,40,50,60,70,80};
+  uint16x8_t C;
+
+  C = vandq_u16(A, B);
+  print_uint16x8(&C, 8);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0064-NEON-Vandq/expected.txt b/testsuite/c_test/ast_test/AST0064-NEON-Vandq/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3e80785f8c8235526c709a6b5e56aa29096dbec5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0064-NEON-Vandq/expected.txt
@@ -0,0 +1 @@
+0 0 2 0 0 4 6 0 
diff --git a/testsuite/c_test/ast_test/AST0064-NEON-Vandq/test.cfg b/testsuite/c_test/ast_test/AST0064-NEON-Vandq/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d4243dbcde5efc85286fbdeacfed6d7f1389384a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0064-NEON-Vandq/test.cfg
@@ -0,0 +1,2 @@
+compile(Vandq)
+run(Vandq)
diff --git a/testsuite/c_test/ast_test/AST0065-NEON-Vcgt/Vcgt.c b/testsuite/c_test/ast_test/AST0065-NEON-Vcgt/Vcgt.c
new file mode 100644
index 0000000000000000000000000000000000000000..db011f1ae3144053ba7452952288c6902bce602c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0065-NEON-Vcgt/Vcgt.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint16x4(uint16x4_t *a, int n) {
+  uint16_t *p = (uint16_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+
+}
+
+int main() {
+  int16x4_t A = {1,2,3,4}, B = {1,2,4,3};
+  uint16x4_t C;
+
+  C = vcgt_s16(A, B);
+  print_uint16x4(&C, 4);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0065-NEON-Vcgt/expected.txt b/testsuite/c_test/ast_test/AST0065-NEON-Vcgt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9ac7f4293e531a0eb9b68528832a0038b0e0c1a7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0065-NEON-Vcgt/expected.txt
@@ -0,0 +1 @@
+0 0 0 65535 
diff --git a/testsuite/c_test/ast_test/AST0065-NEON-Vcgt/test.cfg b/testsuite/c_test/ast_test/AST0065-NEON-Vcgt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0f09c6f2c3695f9a30890677e55405c203effc03
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0065-NEON-Vcgt/test.cfg
@@ -0,0 +1,2 @@
+compile(Vcgt)
+run(Vcgt)
diff --git a/testsuite/c_test/ast_test/AST0066-NEON-Vcge/Vcge.c b/testsuite/c_test/ast_test/AST0066-NEON-Vcge/Vcge.c
new file mode 100644
index 0000000000000000000000000000000000000000..3d1db504ebfd445aaf207dbe1993044e5fa71f60
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0066-NEON-Vcge/Vcge.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint16x4(uint16x4_t *a, int n) {
+  uint16_t *p = (uint16_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+
+}
+
+int main() {
+  int16x4_t A = {1,2,3,4}, B = {1,2,4,3};
+  uint16x4_t C;
+
+  C = vcge_s16(A, B);
+  print_uint16x4(&C, 4);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0066-NEON-Vcge/expected.txt b/testsuite/c_test/ast_test/AST0066-NEON-Vcge/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b39bc415cf2d89c6cbf6fb0f7c698f911ed7b0bc
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0066-NEON-Vcge/expected.txt
@@ -0,0 +1 @@
+65535 65535 0 65535 
diff --git a/testsuite/c_test/ast_test/AST0066-NEON-Vcge/test.cfg b/testsuite/c_test/ast_test/AST0066-NEON-Vcge/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..392c8ee37f207192c51bb433a26902e284306f66
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0066-NEON-Vcge/test.cfg
@@ -0,0 +1,2 @@
+compile(Vcge)
+run(Vcge)
diff --git a/testsuite/c_test/ast_test/AST0067-NEON-Vcle/Vcle.c b/testsuite/c_test/ast_test/AST0067-NEON-Vcle/Vcle.c
new file mode 100644
index 0000000000000000000000000000000000000000..c68f149ead15398af0f5cd74a83e31538eb13bf1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0067-NEON-Vcle/Vcle.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint16x4(uint16x4_t *a, int n) {
+  uint16_t *p = (uint16_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+
+}
+
+int main() {
+  int16x4_t A = {1,2,3,4}, B = {1,2,4,3};
+  uint16x4_t C;
+
+  C = vcle_s16(A, B);
+  print_uint16x4(&C, 4);
+
+  return 0;
+}
+
+
diff --git a/testsuite/c_test/ast_test/AST0067-NEON-Vcle/expected.txt b/testsuite/c_test/ast_test/AST0067-NEON-Vcle/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..71e8b7a39a52b881c2f7fb8cb677f98c71d3c7a4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0067-NEON-Vcle/expected.txt
@@ -0,0 +1 @@
+65535 65535 65535 0 
diff --git a/testsuite/c_test/ast_test/AST0067-NEON-Vcle/test.cfg b/testsuite/c_test/ast_test/AST0067-NEON-Vcle/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b6e1307b13ff5a939eea1993cc0de4e61c869c4f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0067-NEON-Vcle/test.cfg
@@ -0,0 +1,2 @@
+compile(Vcle)
+run(Vcle)
diff --git a/testsuite/c_test/ast_test/AST0068-NEON-Vsub/Vsub.c b/testsuite/c_test/ast_test/AST0068-NEON-Vsub/Vsub.c
new file mode 100644
index 0000000000000000000000000000000000000000..a4281a96b215a46519071b00129d422a6c79eed1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0068-NEON-Vsub/Vsub.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_int16x4(int16x4_t *a, int n) {
+  int16_t *p = (int16_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+
+}
+
+int main() {
+  int16x4_t A = {1,2,3,4}, B = {1,2,4,3};
+  int16x4_t C;
+
+  C = vsub_s16(A, B);
+  print_int16x4(&C, 4);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0068-NEON-Vsub/expected.txt b/testsuite/c_test/ast_test/AST0068-NEON-Vsub/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f1a524d2fd99ded010c6b550fc3a7cb44b761f25
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0068-NEON-Vsub/expected.txt
@@ -0,0 +1 @@
+0 0 -1 1 
diff --git a/testsuite/c_test/ast_test/AST0068-NEON-Vsub/test.cfg b/testsuite/c_test/ast_test/AST0068-NEON-Vsub/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f7674f26b06aa372a878f0f72a375db25f406cf2
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0068-NEON-Vsub/test.cfg
@@ -0,0 +1,2 @@
+compile(Vsub)
+run(Vsub)
diff --git a/testsuite/c_test/ast_test/AST0069-NEON-Vshrn_n/Vshrn_n.c b/testsuite/c_test/ast_test/AST0069-NEON-Vshrn_n/Vshrn_n.c
new file mode 100644
index 0000000000000000000000000000000000000000..51803abaa09ae34a13d12e7477232d915bf93d61
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0069-NEON-Vshrn_n/Vshrn_n.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+void print_uint32x2(uint32x2_t *a, int n) {
+  uint32_t *p = (uint32_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  uint64x2_t A = {10, 20};
+  uint32x2_t B;
+
+  B = vshrn_n_u64(A, 1);
+  print_uint32x2(&B, 2);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0069-NEON-Vshrn_n/expected.txt b/testsuite/c_test/ast_test/AST0069-NEON-Vshrn_n/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bd670060cd4bfef814320135b5dfe02b0177ee03
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0069-NEON-Vshrn_n/expected.txt
@@ -0,0 +1 @@
+5 10 
diff --git a/testsuite/c_test/ast_test/AST0069-NEON-Vshrn_n/test.cfg b/testsuite/c_test/ast_test/AST0069-NEON-Vshrn_n/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9e3a8e5651234f4567fcde345fa4e7e4bdc721b8
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0069-NEON-Vshrn_n/test.cfg
@@ -0,0 +1,2 @@
+compile(Vshrn_n)
+run(Vshrn_n)
diff --git a/testsuite/c_test/ast_test/AST0070-builtin_rotateXXX/builtin_rotateXXX.c b/testsuite/c_test/ast_test/AST0070-builtin_rotateXXX/builtin_rotateXXX.c
new file mode 100644
index 0000000000000000000000000000000000000000..ff63585e3c5720602833e9f13c692db8b24d819c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0070-builtin_rotateXXX/builtin_rotateXXX.c
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <math.h>
+#include <stdint.h>
+
+int ConvertBinaryToDecimal(long long n) {
+  int dec = 0, i = 0, rem;
+  while (n != 0) {
+    rem = n % 10;
+    n /= 10;
+    dec += rem * pow(2, i);
+    ++i;
+  }
+  return dec;
+}
+
+int main() {
+  unsigned int x = ConvertBinaryToDecimal(10000110);
+  unsigned int z = __builtin_rotateleft8(x, 11);
+  printf("%u\n", z);  // 52: 0011 0100
+  x = ConvertBinaryToDecimal(1000001101000010);
+  z = __builtin_rotateleft16(x, 23);
+  printf("%u\n", z);  // 41281: 1010 0001 0100 0001
+  x = ConvertBinaryToDecimal(1000001101000010);
+  z = __builtin_rotateleft32(x, 23);
+  printf("%u\n", z);  // 2701131841: 1010 0001 0000 0000 0000 0000 0100 0001
+  uint64_t w = __builtin_rotateleft64(3, 63);
+  printf("%llu\n", w);  // 9223372036854775809: 1000000000000000000000000000000000000000000000000000000000000001
+  printf("\n");
+
+  x = ConvertBinaryToDecimal(10000110);
+  z = __builtin_rotateright8(x, 11);
+  printf("%u\n", z);  // 208: 1101 0000
+  x = ConvertBinaryToDecimal(1000001101000010);
+  z = __builtin_rotateright16(x, 23);
+  printf("%u\n", z);  // 34054: 1000 0101 000 00110
+  x = ConvertBinaryToDecimal(1000001101000010);
+  z = __builtin_rotateright32(x, 23);
+  printf("%u\n", z);  // 17204224: 0000 0001 0000 0110 1000 0100 0000 0000
+  w = __builtin_rotateright64(3, 1);
+  printf("%llu\n", w);  // 9223372036854775809: 1000000000000000000000000000000000000000000000000000000000000001
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0070-builtin_rotateXXX/expected.txt b/testsuite/c_test/ast_test/AST0070-builtin_rotateXXX/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aa8c2766becdd3617039c9cfdf7711d736f1776a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0070-builtin_rotateXXX/expected.txt
@@ -0,0 +1,9 @@
+52
+41281
+2701131841
+9223372036854775809
+
+208
+34054
+17204224
+9223372036854775809
diff --git a/testsuite/c_test/ast_test/AST0070-builtin_rotateXXX/test.cfg b/testsuite/c_test/ast_test/AST0070-builtin_rotateXXX/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bece7ab3a14a73758e347ec51d6361225d622520
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0070-builtin_rotateXXX/test.cfg
@@ -0,0 +1,2 @@
+compile(builtin_rotateXXX)
+run(builtin_rotateXXX)
diff --git a/testsuite/c_test/ast_test/AST0072-InvalidInitializer/InvalidInitializer.c b/testsuite/c_test/ast_test/AST0072-InvalidInitializer/InvalidInitializer.c
new file mode 100644
index 0000000000000000000000000000000000000000..0284bae906b8e5f8413b1a46c2a55b73c6b2e176
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0072-InvalidInitializer/InvalidInitializer.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+typedef struct {
+    char *auth_pwfile;
+    int x;
+} auth_config_rec;
+
+void *Ptr = &((auth_config_rec*)0)->x;
+
+int main() {
+  printf("InvalidInitializer");
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0072-InvalidInitializer/expected.txt b/testsuite/c_test/ast_test/AST0072-InvalidInitializer/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bd9f94ccaf2af0d82288a60ac7e592d0cb4144bb
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0072-InvalidInitializer/expected.txt
@@ -0,0 +1 @@
+InvalidInitializer
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0072-InvalidInitializer/test.cfg b/testsuite/c_test/ast_test/AST0072-InvalidInitializer/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d4fb9390a09bb2402067a3b6fa57276f456232b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0072-InvalidInitializer/test.cfg
@@ -0,0 +1,2 @@
+compile(InvalidInitializer)
+run(InvalidInitializer)
diff --git a/testsuite/c_test/ast_test/AST0073-RorOptimize/RorOptimize.c b/testsuite/c_test/ast_test/AST0073-RorOptimize/RorOptimize.c
new file mode 100644
index 0000000000000000000000000000000000000000..b57edd50dc726ddae9845f09d3d9feb2b55e0da1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0073-RorOptimize/RorOptimize.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef unsigned long u64;
+typedef unsigned int u32;
+typedef unsigned short u16;
+
+// u64
+u64 __attribute__((noinline)) rot1(u64 a, u64 b) {
+  return (a >> (b&63)) | (a << (64 - (b&63)));
+}
+
+u64 __attribute__((noinline)) rot2(u64 a, u64 b) {
+  return (a << (64 - (b&63))) | (a >> (b&63));
+}
+
+// u32
+u32 __attribute__((noinline)) rot3(u32 a, u32 b) {
+  return (a >> (b&31)) | (a << (32 - (b&31)));
+}
+
+u32 __attribute__((noinline)) rot4(u32 a, u32 b) {
+  return (a << (32 - (b&31))) | (a >> (b&31));
+}
+
+// u16
+u16 __attribute__((noinline)) rot5(u16 a, u16 b) {
+  return (a >> (b&15)) | (a << (16 - (b&15)));
+}
+
+u16 __attribute__((noinline)) rot6(u16 a, u16 b) {
+  return (a << (16 - (b&15))) | (a >> (b&15));
+}
+
+int main() {
+  u64 a = 9; // 1001
+  u64 b = rot1(a, 1);
+  u64 c = rot2(a, 2);
+  u32 d = rot3(a, 3);
+  u32 e = rot4(a, 4);
+  u16 f = rot5(a, 5);
+  u16 g = rot6(a, 6);
+  printf("%lu, %lu, %u, %u, %u, %u\n", b, c, d, e, f, g);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0073-RorOptimize/expected.txt b/testsuite/c_test/ast_test/AST0073-RorOptimize/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..748c315c99c5763cb40fe446cad9ff1295b22414
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0073-RorOptimize/expected.txt
@@ -0,0 +1 @@
+9223372036854775812, 4611686018427387906, 536870913, 2415919104, 18432, 9216
diff --git a/testsuite/c_test/ast_test/AST0073-RorOptimize/test.cfg b/testsuite/c_test/ast_test/AST0073-RorOptimize/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50dea888322d510db70f081007282b585bd7a5e5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0073-RorOptimize/test.cfg
@@ -0,0 +1,2 @@
+compile(RorOptimize)
+run(RorOptimize)
diff --git a/testsuite/c_test/ast_test/AST0075-AddrShiftOperate/AddrShiftOperate.c b/testsuite/c_test/ast_test/AST0075-AddrShiftOperate/AddrShiftOperate.c
new file mode 100644
index 0000000000000000000000000000000000000000..43653fb267cd0044f00ffc85c60d1e0badd9967c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0075-AddrShiftOperate/AddrShiftOperate.c
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stddef.h>
+
+int a[6] = {12345, 1, 2, 3, 4, 5};
+
+int main() {
+  int *b = &a[2];
+  // CHECK: iread i32 <* i32> 0 (add ptr (dread ptr %b{{.*}}, constval i64 8))
+  printf("%d\n", *(b + 2));
+  // CHECK: iread i32 <* i32> 0 (add ptr (constval i64 8, dread ptr %b{{.*}}))
+  printf("%d\n", *(2 + b));
+  // CHECK: iread i32 <* i32> 0 (add ptr (dread ptr %b{{.*}}, constval i64 -8))
+  printf("%d\n", *(b + (-2)));
+  int i = 2;
+  // CHECK:      iread i32 <* i32> 0 (add ptr (
+  // CHECK-NEXT:   dread ptr %b{{.*}},
+  // CHECK-NEXT:   mul i64 (
+  // CHECK-NEXT:     cvt i64 i32 (dread i32 %i{{.*}}),
+  // CHECK-NEXT:     constval i64 4)))
+  printf("%d\n", *(b + i));
+  // CHECK:      iread i32 <* i32> 0 (sub ptr (
+  // CHECK-NEXT:   dread ptr %b{{.*}},
+  // CHECK-NEXT:   mul i64 (
+  // CHECK-NEXT:     cvt i64 i32 (dread i32 %i{{.*}}),
+  // CHECK-NEXT:     constval i64 4)))
+  printf("%d\n", *(b - i));
+  unsigned int j = 2;
+  // CHECK:      iread i32 <* i32> 0 (add ptr (
+  // CHECK-NEXT:   dread ptr %b{{.*}},
+  // CHECK-NEXT:   mul ptr (
+  // CHECK-NEXT:     cvt ptr u32 (dread u32 %j{{.*}}),
+  // CHECK-NEXT:     constval ptr 4)))
+  printf("%d\n", *(b + j));
+  // CHECK:      iread i32 <* i32> 0 (sub ptr (
+  // CHECK-NEXT:   dread ptr %b{{.*}},
+  // CHECK-NEXT:   mul ptr (
+  // CHECK-NEXT:     cvt ptr u32 (dread u32 %j{{.*}}),
+  // CHECK-NEXT:     constval ptr 4)))
+  printf("%d\n", *(b - j));
+  int k = -2;
+  // CHECK:      iread i32 <* i32> 0 (add ptr (
+  // CHECK-NEXT:   dread ptr %b{{.*}},
+  // CHECK-NEXT:   mul i64 (
+  // CHECK-NEXT:     cvt i64 i32 (dread i32 %k{{.*}}),
+  // CHECK-NEXT:     constval i64 4)))
+  printf("%d\n", *(b + k));
+  // CHECK:      iread i32 <* i32> 0 (sub ptr (
+  // CHECK-NEXT:   dread ptr %b{{.*}},
+  // CHECK-NEXT:   mul i64 (
+  // CHECK-NEXT:     cvt i64 i32 (dread i32 %k{{.*}}),
+  // CHECK-NEXT:     constval i64 4)))
+  printf("%d\n", *(b - k));
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0075-AddrShiftOperate/expected.txt b/testsuite/c_test/ast_test/AST0075-AddrShiftOperate/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b323fbb66e4650e17baefdfee6dabbf35424c50f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0075-AddrShiftOperate/expected.txt
@@ -0,0 +1,9 @@
+4
+4
+12345
+4
+12345
+4
+12345
+12345
+4
diff --git a/testsuite/c_test/ast_test/AST0075-AddrShiftOperate/test.cfg b/testsuite/c_test/ast_test/AST0075-AddrShiftOperate/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c2e632942089495cfa52aae38bc9bb43041c49b6
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0075-AddrShiftOperate/test.cfg
@@ -0,0 +1,3 @@
+compile(AddrShiftOperate)
+run(AddrShiftOperate)
+cat AddrShiftOperate.mpl | ${OUT_ROOT}/tools/bin/FileCheck AddrShiftOperate.c
diff --git a/testsuite/c_test/ast_test/AST0076-ShortCircuit/ShortCircuit.c b/testsuite/c_test/ast_test/AST0076-ShortCircuit/ShortCircuit.c
new file mode 100644
index 0000000000000000000000000000000000000000..b6ce0407089734dea432b40082fe845bbe70fa44
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0076-ShortCircuit/ShortCircuit.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+int func1() {
+  return 1;
+}
+
+int main() {
+  int a, b, c;
+  // CHECK:       if (cior i32 (
+  // CHECK-NEXT:    ne u1 i32 (dread i32 %a_21_3, constval i32 0),
+  // CHECK-NEXT:    ne u1 i32 (dread i32 %b_21_3, constval i32 0))) {
+  // CHECK-NEXT:  }
+  if (a || b) {
+  }
+  // CHECK:       dassign %shortCircuit_[[# IDX:]] 0 (cior i32 (
+  // CHECK-NEXT:        ne u1 i32 (dread i32 %a_21_3, constval i32 0),
+  // CHECK-NEXT:        ne u1 i32 (dread i32 %b_21_3, constval i32 0)))
+  // CHECK-NEXT:    brtrue @shortCircuit_label_[[# IDX:]] (dread i32 %shortCircuit_[[# IDX:]])
+  // CHECK-NEXT:    callassigned &func1 () { dassign %retVar_[[# IDX:]] 0 }
+  // CHECK-NEXT:    dassign %shortCircuit_[[# IDX:]] 0 (ne u1 i32 (dread i32 %retVar_[[# IDX:]], constval i32 0))
+  // CHECK-NEXT:  @shortCircuit_label_[[# IDX:]]   if (ne u1 i32 (dread i32 %shortCircuit_[[# IDX:]], constval i32 0)) {
+  // CHECK-NEXT:  }
+  if (a || b || func1()) {
+  }
+  // CHECK:       callassigned &func1 () { dassign %retVar_[[# IDX:]] 0 }
+  // CHECK-NEXT:  if (cior i32 (
+  // CHECK-NEXT:    cior i32 (
+  // CHECK-NEXT:      ne u1 i32 (dread i32 %retVar_[[# IDX:]], constval i32 0),
+  // CHECK-NEXT:      ne u1 i32 (dread i32 %a_21_3, constval i32 0)),
+  // CHECK-NEXT:    ne u1 i32 (dread i32 %b_21_3, constval i32 0))) {
+  // CHECK-NEXT:  }
+  if (func1() || a || b) {
+  }
+  // CHECK:        dassign %shortCircuit_[[# IDX:]] 0 (ne u1 i32 (dread i32 %c_21_3, constval i32 0))
+  // CHECK-NEXT:   brtrue @shortCircuit_label_[[# IDX:]] (dread i32 %shortCircuit_[[# IDX:]])
+  // CHECK-NEXT:   callassigned &func1 () { dassign %retVar_[[# IDX:]] 0 }
+  // CHECK-NEXT:   dassign %shortCircuit_[[# IDX:]] 0 (ne u1 i32 (dread i32 %retVar_[[# IDX:]], constval i32 0))
+  // CHECK-NEXT: @shortCircuit_label_[[# IDX:]]   if (cior i32 (
+  // CHECK-NEXT:    cior i32 (
+  // CHECK-NEXT:      ne u1 i32 (dread i32 %shortCircuit_[[# IDX:]], constval i32 0),
+  // CHECK-NEXT:      ne u1 i32 (dread i32 %a_21_3, constval i32 0)),
+  // CHECK-NEXT:    ne u1 i32 (dread i32 %b_21_3, constval i32 0))) {
+  // CHECK-NEXT:  }
+  if (c || func1() || a || b) {
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0076-ShortCircuit/expected.txt b/testsuite/c_test/ast_test/AST0076-ShortCircuit/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0076-ShortCircuit/test.cfg b/testsuite/c_test/ast_test/AST0076-ShortCircuit/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35dbee2f1b194da98ae7f84f4f6c9dd724822d6d
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0076-ShortCircuit/test.cfg
@@ -0,0 +1,3 @@
+compile(ShortCircuit)
+run(ShortCircuit)
+#cat ShortCircuit.mpl | ${OUT_ROOT}/tools/bin/FileCheck ShortCircuit.c
diff --git a/testsuite/c_test/ast_test/AST0077-InlineOptimize/InlineOptimize.c b/testsuite/c_test/ast_test/AST0077-InlineOptimize/InlineOptimize.c
new file mode 100644
index 0000000000000000000000000000000000000000..c8c5d6d851b3ce3cd24ab1c4686cd078f974cacd
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0077-InlineOptimize/InlineOptimize.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+typedef void (*func)();
+
+// CHECK:     type $TypeC_MNO[[# IDX:]] <struct {
+// CHECK-NEXT:  @c i32 align(4),
+// CHECK-NEXT:  @b <$TypeB_MNO[[# IDX:]]> align(4)}>
+// CHECK-NEXT:type $TypeB_MNO[[# IDX:]] <struct {
+// CHECK-NEXT:  @b i32 align(4),
+// CHECK-NEXT:  @a <$TypeA_MNO[[# IDX:]]> align(4)}>
+// CHECK-NEXT:type $TypeA_MNO[[# IDX:]] <struct {
+// CHECK-NEXT:  @a i32 align(4)}>
+// CHECK: func &func5 public used noinline () void
+struct TypeA {
+  int a;
+};
+
+struct TypeB {
+  int b;
+  struct TypeA a;
+};
+
+struct TypeC {
+  int c;
+  struct TypeB b;
+};
+
+// CHECK: var $a_MNO[[# IDX:]] fstatic i32 static used = 1
+static int a = 1;
+// CHECK-NOT: func &func1_MNO[[# IDX:]] public static used () void
+static void func1() {
+  a++;
+}
+
+// CHECK-NOT: func &func2_MNO[[# IDX:]] public static used () void
+static void func2() {
+  a++;
+}
+
+__attribute__((noinline))
+void func5() {
+}
+
+// CHECK: func &func3_MNO[[# IDX:]] public static used () void
+static void func3() {
+  a++;
+  func f = func5;
+  f();
+}
+// CHECK: func &func4 public () void
+void func4() {
+  func3();
+  struct TypeC c = {1};
+}
+
+// CHECK-NOT: func &main public noinline () i32
+__attribute__((noinline))
+int main() {
+  char *str = "123";
+  func1();
+  func2();
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0077-InlineOptimize/expected.txt b/testsuite/c_test/ast_test/AST0077-InlineOptimize/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0077-InlineOptimize/test.cfg b/testsuite/c_test/ast_test/AST0077-InlineOptimize/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f7e82198013ad4a9913883b4641d17601c9d1428
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0077-InlineOptimize/test.cfg
@@ -0,0 +1,4 @@
+ASTO2:
+compile(InlineOptimize)
+run(InlineOptimize)
+cat InlineOptimize.mplt_inline | ${OUT_ROOT}/tools/bin/FileCheck InlineOptimize.c
diff --git a/testsuite/c_test/ast_test/AST0079-StructArray/StructArray.c b/testsuite/c_test/ast_test/AST0079-StructArray/StructArray.c
new file mode 100644
index 0000000000000000000000000000000000000000..e9019b947d84ff319ccabcf4a5efb832c2c2ec1f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0079-StructArray/StructArray.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+struct inter {
+  int a;
+  int b;
+};
+
+typedef struct foo bar;
+struct foo {
+  int x;
+  int y;
+  int z[10];
+  struct inter w;
+};
+
+int main() {
+  bar a[10] = {0};
+  printf("%d\n", a[0].z[0]);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0079-StructArray/expected.txt b/testsuite/c_test/ast_test/AST0079-StructArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0079-StructArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/c_test/ast_test/AST0079-StructArray/test.cfg b/testsuite/c_test/ast_test/AST0079-StructArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..79fb090471b21d6d8a842809ce42f0888ccb7701
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0079-StructArray/test.cfg
@@ -0,0 +1,2 @@
+compile(StructArray)
+run(StructArray)
diff --git a/testsuite/c_test/ast_test/AST0080-WcharInit/WcharInit.c b/testsuite/c_test/ast_test/AST0080-WcharInit/WcharInit.c
new file mode 100644
index 0000000000000000000000000000000000000000..e99fbb1229bda6ea01b13634537e4ecfd7c0e65e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0080-WcharInit/WcharInit.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <uchar.h>
+#include <stddef.h>
+#include <string.h>
+
+int strcmp_ctowc( char a[], wchar_t b[] ) {
+  int c = 0;
+
+  while( a[c] == b[c] ){
+      if( a[c] == '\0' || b[c] == '\0' ){
+          break;
+      }
+      c++;
+  }
+
+  if( a[c] == '\0' && b[c] == '\0' ){
+      return 0;
+  } else {
+      return -1;
+  }
+}
+
+int main() {
+  char     a [] =   "abcd";
+  char     b [] = u8"abcd";
+  wchar_t  c [] =  L"abcd";
+
+  if( strcmp_ctowc(  a, c ) != 0 ) {
+    abort();
+  }
+}
diff --git a/testsuite/c_test/ast_test/AST0080-WcharInit/expected.txt b/testsuite/c_test/ast_test/AST0080-WcharInit/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0080-WcharInit/test.cfg b/testsuite/c_test/ast_test/AST0080-WcharInit/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..106feb84cdb6f18d23996d56473f24fe41178733
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0080-WcharInit/test.cfg
@@ -0,0 +1,2 @@
+compile(WcharInit)
+run(WcharInit)
diff --git a/testsuite/c_test/ast_test/AST0081-Constructor/Constructor.c b/testsuite/c_test/ast_test/AST0081-Constructor/Constructor.c
new file mode 100644
index 0000000000000000000000000000000000000000..e7fc16ce123dcd5b4971072c5648ead50463fd14
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0081-Constructor/Constructor.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdint.h>
+
+
+void __attribute__((constructor(103))) z_1() {
+  printf("constructor(103)\n");
+}
+
+void __attribute__((constructor(102))) z_2() {
+  printf("constructor(102)\n");
+}
+
+void __attribute__((constructor())) z_3() {
+  printf("constructor\n");
+}
+
+void __attribute__((destructor(102))) z_4() {
+  printf("destructor(102)\n");
+}
+
+void __attribute__((constructor(105))) __attribute__((destructor(105))) z_5() {
+  printf("constructor/destructor(105)\n");
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0081-Constructor/expected.txt b/testsuite/c_test/ast_test/AST0081-Constructor/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6666aa7dd09a86291a0e8ecf8e6dee8c686ffaab
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0081-Constructor/expected.txt
@@ -0,0 +1,4 @@
+constructor(102)
+constructor(103)
+constructor/destructor(105)
+constructor
diff --git a/testsuite/c_test/ast_test/AST0081-Constructor/test.cfg b/testsuite/c_test/ast_test/AST0081-Constructor/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..82fbac52340e57764f62a0c66e5ed76a34f1506f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0081-Constructor/test.cfg
@@ -0,0 +1,2 @@
+compile(Constructor)
+run(Constructor)
diff --git a/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/expected.txt b/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/incomplete_array.c b/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/incomplete_array.c
new file mode 100644
index 0000000000000000000000000000000000000000..566600a71d739c8f112d4201de7ae3a6238bdd13
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/incomplete_array.c
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdint.h>
+#include "incomplete_array.h"
+
+typedef enum {
+  kFirst,
+  kSecond,
+  kThird,
+  kFourth
+}foo;
+
+int bar[kFourth];  // CHECK: var $bar <[3] i32> used
+
+int main() {
+  bar[1] = 1;
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/incomplete_array.h b/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/incomplete_array.h
new file mode 100644
index 0000000000000000000000000000000000000000..88afc1890ababa8f278d858fa83649ab43047f71
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/incomplete_array.h
@@ -0,0 +1 @@
+extern int bar[];
diff --git a/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/test.cfg b/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0b276cce5687d36b8e778ff37c8d53824da275b2
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0082-DuplicateDeclarations/test.cfg
@@ -0,0 +1,3 @@
+compile(incomplete_array)
+run(incomplete_array)
+cat incomplete_array.mpl | ${OUT_ROOT}/tools/bin/FileCheck incomplete_array.c
diff --git a/testsuite/c_test/ast_test/AST0083-MultiFuncDecl/MultiFuncDecl.c b/testsuite/c_test/ast_test/AST0083-MultiFuncDecl/MultiFuncDecl.c
new file mode 100644
index 0000000000000000000000000000000000000000..9ef13e33d00a95544ae98a169335b387d36d485c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0083-MultiFuncDecl/MultiFuncDecl.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// CHECK: [[# FILENUM:]] "{{.*}}/MultiFuncDecl.c"
+static void test();
+
+void foo() {
+  test();
+} 
+
+// CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+// CHECK-NEXT: func &test{{.*}} static
+void test() {
+  printf("test\n");
+}
+
+int main() {
+  foo();
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0083-MultiFuncDecl/expected.txt b/testsuite/c_test/ast_test/AST0083-MultiFuncDecl/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9daeafb9864cf43055ae93beb0afd6c7d144bfa4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0083-MultiFuncDecl/expected.txt
@@ -0,0 +1 @@
+test
diff --git a/testsuite/c_test/ast_test/AST0083-MultiFuncDecl/test.cfg b/testsuite/c_test/ast_test/AST0083-MultiFuncDecl/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..10262efb1baf3274d0b238f106c19883b461e917
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0083-MultiFuncDecl/test.cfg
@@ -0,0 +1,3 @@
+compile(MultiFuncDecl)
+run(MultiFuncDecl)
+cat MultiFuncDecl.mpl | ${OUT_ROOT}/tools/bin/FileCheck MultiFuncDecl.c
diff --git a/testsuite/c_test/ast_test/AST0084-PackedAttr/PackedAttr.c b/testsuite/c_test/ast_test/AST0084-PackedAttr/PackedAttr.c
new file mode 100644
index 0000000000000000000000000000000000000000..5b0dd2678e7ca789dd6ba6f9342f4f68c8ffafe5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0084-PackedAttr/PackedAttr.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+ #include <stdio.h>
+
+// CHECK: [[# FILENUM:]] "{{.*}}/PackedAttr.c"
+// CHECK: type {{.*}} <struct pack(2)
+#pragma pack(push, 2)
+typedef struct {
+  char c1;
+  int i;
+  char c2;
+} FOO1;
+#pragma pack(pop)
+// CHECK: type {{.*}} <struct pack(4)
+#pragma pack(push, 1)
+#pragma pack(push, 4)
+typedef struct {
+  char c1;
+  int i;
+  char c2;
+} FOO2;
+#pragma pack(pop)
+#pragma pack(pop)
+// CHECK: type {{.*}} <struct pack(1)
+typedef struct {
+  char c1;
+  int i;
+  char c2;
+}__attribute__ ((packed)) FOO3;
+// CHECK: type $foo1{{.*}} <struct pack(1)
+struct foo1 {
+  char c1;
+  int i;
+  char c2;
+} __attribute__ ((packed));
+// CHECK: type $foo2{{.*}} <struct pack(1)
+#pragma pack(push, 2)
+struct foo2 {
+  char c1;
+  int i;
+  char c2;
+} __attribute__ ((packed));
+#pragma pack(pop)
+struct foo3 {
+  char c1;
+  // CHECK: i {{.*}} pack(1)
+  int i  __attribute__ ((packed));
+  char c2;
+};
+// CHECK: type $foo4{{.*}} <struct pack(2)
+#pragma pack(push, 2)
+struct foo4 {
+  char c1;
+  // CHECK: i {{.*}} pack(1)
+  int i  __attribute__ ((packed));
+  char c2;
+};
+#pragma pack(pop)
+// CHECK: type $foo5{{.*}} <struct pack(1)
+struct foo5 {
+  char c1;
+  // CHECK: i {{.*}} pack(1)
+  int i  __attribute__ ((packed));
+  char c2;
+} __attribute__ ((packed));
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0084-PackedAttr/expected.txt b/testsuite/c_test/ast_test/AST0084-PackedAttr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0084-PackedAttr/test.cfg b/testsuite/c_test/ast_test/AST0084-PackedAttr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..14852c18379d08c9dcc09a3b18bbe43e8cca6489
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0084-PackedAttr/test.cfg
@@ -0,0 +1,3 @@
+compile(PackedAttr)
+run(PackedAttr)
+cat PackedAttr.mpl | ${OUT_ROOT}/tools/bin/FileCheck PackedAttr.c
diff --git a/testsuite/c_test/ast_test/AST0085-IncompleteStruct/IncompleteStruct.c b/testsuite/c_test/ast_test/AST0085-IncompleteStruct/IncompleteStruct.c
new file mode 100644
index 0000000000000000000000000000000000000000..dbfdfeeffbc71179e222f65b78075c03afe1a35d
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0085-IncompleteStruct/IncompleteStruct.c
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+// CHECK: [[# FILENUM:]] "{{.*}}/IncompleteStruct.c"
+// CHECK: type $FOO1{{.*}} <structincomplete
+struct FOO1;
+void test1(struct FOO1 foo);
+
+// CHECK: type $FOO2{{.*}} <struct {
+// CHECK-NOT: type $FOO2{{.*}} <structincomplete
+struct FOO2;
+void test2(struct FOO2 foo);
+struct FOO2{};
+
+// CHECK: type $FOO3{{.*}} <struct {
+// CHECK-NOT: type $FOO3{{.*}} <structincomplete
+struct FOO3;
+struct FOO3{};
+void test3(struct FOO3 foo);
+
+// CHECK: type $FOO4{{.*}} <structincomplete
+struct FOO4;
+typedef struct FOO4 foo4;
+void test5(foo4 foo);
+
+// CHECK: type $FOO6{{.*}} <struct {
+// CHECK-NOT: type $FOO6{{.*}} <structincomplete
+// CHECK: type $FOO8{{.*}} <struct {
+// CHECK-NOT: type $FOO8{{.*}} <structincomplete
+// CHECK: type $FOO7{{.*}} <structincomplete
+// CHECK: type $FOO5{{.*}} <structincomplete
+struct FOO5;
+extern struct FOO5 foo5;
+struct FOO6{};
+struct FOO6 foo6;
+
+typedef struct FOO8 {
+  struct FOO7 *p;
+  int b;
+} foo8;
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0085-IncompleteStruct/expected.txt b/testsuite/c_test/ast_test/AST0085-IncompleteStruct/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0085-IncompleteStruct/test.cfg b/testsuite/c_test/ast_test/AST0085-IncompleteStruct/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..33fbc8b2298dfc5411f790f241740d1063320c9e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0085-IncompleteStruct/test.cfg
@@ -0,0 +1,3 @@
+compile(IncompleteStruct)
+run(IncompleteStruct)
+cat IncompleteStruct.mpl | ${OUT_ROOT}/tools/bin/FileCheck IncompleteStruct.c
diff --git a/testsuite/c_test/ast_test/AST0086-LocalLabel/LocalLabel.c b/testsuite/c_test/ast_test/AST0086-LocalLabel/LocalLabel.c
new file mode 100644
index 0000000000000000000000000000000000000000..a581547f0f3eb5e4e0fd2f4d228b2f5b62e1e192
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0086-LocalLabel/LocalLabel.c
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#define IS_STR_EMPTY(str)	        \
+do {	                                \
+  __label__ empty, not_empty, exit;     \
+  if (strlen(str))			\
+    goto not_empty;		        \
+  else					\
+    goto empty;				\
+				        \
+  not_empty:				\
+    printf("string = %s\n", str);	\
+    goto exit;				\
+  empty:			        \
+    printf("string is empty\n");        \
+  exit: ;                               \
+} while(0);				\
+
+int main()
+{
+  char string[20] = {'\0'};
+  IS_STR_EMPTY(string);
+  strcpy(string, "test");
+  IS_STR_EMPTY(string);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0086-LocalLabel/expected.txt b/testsuite/c_test/ast_test/AST0086-LocalLabel/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0e90b5cfd40159a1c6dddece1a7da89cd5902f88
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0086-LocalLabel/expected.txt
@@ -0,0 +1,2 @@
+string is empty
+string = test
diff --git a/testsuite/c_test/ast_test/AST0086-LocalLabel/test.cfg b/testsuite/c_test/ast_test/AST0086-LocalLabel/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d687924d334051f9135000c1e0bcd4e7979463a8
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0086-LocalLabel/test.cfg
@@ -0,0 +1,2 @@
+compile(LocalLabel)
+run(LocalLabel)
diff --git a/testsuite/c_test/ast_test/AST0087-Typeof/Typeof.c b/testsuite/c_test/ast_test/AST0087-Typeof/Typeof.c
new file mode 100644
index 0000000000000000000000000000000000000000..4488f268e069c0fd44a1cee55499b42e60d775ce
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0087-Typeof/Typeof.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#define FINDMAX(m, x, n)\
+{\
+  typeof(n) _n = n;           /* _n is local copy of the number of elements*/\
+  if (_n > 0) {               /* in case the array is empty */\
+    int _i;\
+    typeof((x)[0]) * _x = x;  /* _x is local copy of pointer to the elements */\
+    typeof(m) _m = _x[0];     /* _m is maximum value found */\
+    for (_i=1; _i<_n; _i++)   /* Iterate through all elements */\
+      if (_x[_i] > _m)\
+        _m = _x[_i];\
+    (m) = _m;                 /* returns the result */\
+  }\
+}
+
+int main()
+{
+  int i[] = {69891, 71660, 71451, 71434, 72317}, im;
+  float f[] = {69891., 71660., 71451., 71434., 72317.}, fm;
+  double d[] = {69891., 71660., 71451., 71434., 72317.}, dm, * dp = d;
+  int n = 5;
+  FINDMAX(im, i, n--);
+  FINDMAX(fm, f, n--);
+  FINDMAX(dm, dp+=2, n--);
+  printf("%d %f %f\n", im, fm, dm);
+}
diff --git a/testsuite/c_test/ast_test/AST0087-Typeof/expected.txt b/testsuite/c_test/ast_test/AST0087-Typeof/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..de6f4472f40f9a016e331e74e514c817b583ba25
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0087-Typeof/expected.txt
@@ -0,0 +1 @@
+72317 71660.000000 72317.000000
diff --git a/testsuite/c_test/ast_test/AST0087-Typeof/test.cfg b/testsuite/c_test/ast_test/AST0087-Typeof/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b0aee7baad64a264417d249b430370a4e9aa35a0
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0087-Typeof/test.cfg
@@ -0,0 +1,2 @@
+compile(Typeof)
+run(Typeof)
diff --git a/testsuite/c_test/ast_test/AST0088-CompoundLiteralExpr/HelloWorld.c b/testsuite/c_test/ast_test/AST0088-CompoundLiteralExpr/HelloWorld.c
new file mode 100644
index 0000000000000000000000000000000000000000..a7aba001d09bcd5349e452099e575440ded6ab05
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0088-CompoundLiteralExpr/HelloWorld.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int *g_ptr = (int [4]) { 4, 8, 16, 32 };
+double *g_ptr1 = (double [4]) { 1.1, 1.2, 1.3, 1.4 };
+int *g_ptr2 = ((((int [4]) { 4, 8, 16, 32 })));
+int arr[] = {1,2,3,4};
+int *g_ptr3 = arr;
+int *g_ptr4 = &((arr));
+double *g_ptr5 = &((double [4]) { 1.1, 1.2, 1.3, 1.4 });
+
+
+int *g_a = &(int){6};
+int main() {
+  int *ptr = (int [4]) { 4, 8, 16, 32 };
+  printf("%d %d %f\n", g_ptr[1], ptr[2], g_ptr1[1]);
+
+  int *a = &(int){7};
+  float *b = &(float){1.1};
+  printf("%d %d %f\n", *g_a, *a, *b);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0088-CompoundLiteralExpr/expected.txt b/testsuite/c_test/ast_test/AST0088-CompoundLiteralExpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b1915c951c0165f901fdbcffa723afef77ef8287
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0088-CompoundLiteralExpr/expected.txt
@@ -0,0 +1,2 @@
+8 16 1.200000
+6 7 1.100000
diff --git a/testsuite/c_test/ast_test/AST0088-CompoundLiteralExpr/test.cfg b/testsuite/c_test/ast_test/AST0088-CompoundLiteralExpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0088-CompoundLiteralExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/c_test/ast_test/AST0089-GlobalAsmOut/asm.c b/testsuite/c_test/ast_test/AST0089-GlobalAsmOut/asm.c
new file mode 100644
index 0000000000000000000000000000000000000000..770a80e232b619986fd24eabf3eb07f278218195
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0089-GlobalAsmOut/asm.c
@@ -0,0 +1,31 @@
+#include <stdio.h>
+
+int destVar = -1;
+void test01() {
+  int srcVar = 4;
+  asm volatile ("mov %w0, %w1"
+                : "=r"(destVar)
+                : "r"(srcVar));
+  printf("destVar = %d\n", destVar);
+}
+
+typedef struct {
+  int a;
+  int b;
+} Foo;
+Foo destFoo = {-1,-1};
+
+void test02() {
+  int srcVar = 3;
+  asm volatile ("mov %w0, %w1"
+                : "=r"(destFoo.b)
+                : "r"(srcVar));
+  printf("destFoo.a = %d\n", destFoo.a);
+  printf("destFoo.b = %d\n", destFoo.b);
+}
+
+int main() {
+  test01();
+  test02();
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0089-GlobalAsmOut/expected.txt b/testsuite/c_test/ast_test/AST0089-GlobalAsmOut/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8c18f5197c8f01cacb3a48642ce27ed86bac47f2
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0089-GlobalAsmOut/expected.txt
@@ -0,0 +1,3 @@
+destVar = 4
+destFoo.a = -1
+destFoo.b = 3
diff --git a/testsuite/c_test/ast_test/AST0089-GlobalAsmOut/test.cfg b/testsuite/c_test/ast_test/AST0089-GlobalAsmOut/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0958817be27b81192c30be8332d99ddcb7e28b59
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0089-GlobalAsmOut/test.cfg
@@ -0,0 +1,2 @@
+compile(asm)
+run(asm)
diff --git a/testsuite/c_test/ast_test/AST0090-StringInitList_clang_fixed/HelloWorld.c b/testsuite/c_test/ast_test/AST0090-StringInitList_clang_fixed/HelloWorld.c
new file mode 100644
index 0000000000000000000000000000000000000000..e339ca028e84fbc8b9b95a78f9c618842fb4f613
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0090-StringInitList_clang_fixed/HelloWorld.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+char *g_ptr = (char[]) { "hello\n" };
+int main() {
+  printf("%s\n", g_ptr);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0090-StringInitList_clang_fixed/expected.txt b/testsuite/c_test/ast_test/AST0090-StringInitList_clang_fixed/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9a80a2252780ab97f40ce8292f17fb1447fcb634
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0090-StringInitList_clang_fixed/expected.txt
@@ -0,0 +1,2 @@
+hello
+
diff --git a/testsuite/c_test/ast_test/AST0090-StringInitList_clang_fixed/test.cfg b/testsuite/c_test/ast_test/AST0090-StringInitList_clang_fixed/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0090-StringInitList_clang_fixed/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/c_test/ast_test/AST0091-KRstyle/HelloWorld.c b/testsuite/c_test/ast_test/AST0091-KRstyle/HelloWorld.c
new file mode 100644
index 0000000000000000000000000000000000000000..b2d7bfc3e3bb99655e8cb2a0743014b1aabb707d
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0091-KRstyle/HelloWorld.c
@@ -0,0 +1,13 @@
+#include <limits.h>
+int fx (x)
+     short x;
+{
+  return x;
+}
+
+main ()
+{ int res = fx(INT_MAX);
+  printf("%d\n", res);
+}
+
+
diff --git a/testsuite/c_test/ast_test/AST0091-KRstyle/expected.txt b/testsuite/c_test/ast_test/AST0091-KRstyle/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3a2e3f4984a0ee55900f8c7894844c563d2c2744
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0091-KRstyle/expected.txt
@@ -0,0 +1 @@
+-1
diff --git a/testsuite/c_test/ast_test/AST0091-KRstyle/test.cfg b/testsuite/c_test/ast_test/AST0091-KRstyle/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0091-KRstyle/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/c_test/ast_test/AST0091-StructInitWithZero/StructInitWithZero.c b/testsuite/c_test/ast_test/AST0091-StructInitWithZero/StructInitWithZero.c
new file mode 100644
index 0000000000000000000000000000000000000000..6aa07e804f4f07b92b5eeee9bc82f90f46c2fecf
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0091-StructInitWithZero/StructInitWithZero.c
@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <limits.h>
+
+struct subFoo {
+  int a;
+  short b;
+  double c;
+};
+
+union uTest {
+  char a;
+  long b;
+  float c;
+};
+
+struct FooA {
+  int a;
+  long long b;
+  char c[4];
+  struct subFoo f;
+};
+
+struct FooB {
+  int a;
+  char *p;
+  struct subFoo f;
+  union uTest u;
+};
+
+struct FooC {
+  int a:31;
+  int b:15;
+  int c;
+};
+
+int main() {
+  char str[] = {'h', 'i'};
+  struct subFoo subfoo = {INT_MAX,0,-3.141592};
+  union uTest utest = {0};
+
+  struct FooA a1 = {1,0,{'a', 'b', 'c','d'},.f=subfoo};
+  struct FooA a2 = {0,0,{'a', 'b', 'c'},{0}};
+  struct FooA a3 = {1,0,{0},.f=subfoo};
+  struct FooA a4 = {1,1};
+  struct FooA a5 = {1,0};
+
+  struct FooB b1 = {1,str,{0},{.b=-1}};
+  struct FooB b2 = {1,NULL,{0},{.a='a'}};
+  struct FooB b2_2 = {INT_MAX,str,subfoo,{.a='a'}};
+  struct FooB b3 = {1,NULL,.f=subfoo,{0}};
+  struct FooB b4 = {1,str,{0},{0}};
+  struct FooB b5 = {1};
+
+  struct FooC c1 = {0};
+  struct FooC c2 = {0,1,1};
+  struct FooC c3 = {1,0,1};
+
+  printf("subfoo={%d,%hd,%f}\n", subfoo.a, subfoo.b, subfoo.c);
+  printf("utest={%ld}\n", utest.b);
+
+  printf("a1={%d,%lld,{%c,%c,%c,%c},{%d,%hd,%f}\n",a1.a, a1.b, a1.c[0], a1.c[1], a1.c[2], a1.c[3],a1.f.a,a1.f.b,a1.f.c);
+  printf("a2={%d,%lld,{%c,%c,%c,%c},{%d,%hd,%f}\n",a2.a, a2.b, a2.c[0], a2.c[1], a2.c[2], a2.c[3],a2.f.a,a2.f.b,a2.f.c);
+  printf("a3={%d,%lld,{%c,%c,%c,%c},{%d,%hd,%f}\n",a3.a, a3.b, a3.c[0], a3.c[1], a3.c[2], a3.c[3],a3.f.a,a3.f.b,a3.f.c);
+  printf("a4={%d,%lld,{%c,%c,%c,%c},{%d,%hd,%f}\n",a4.a, a4.b, a4.c[0], a4.c[1], a4.c[2], a4.c[3],a4.f.a,a4.f.b,a4.f.c);
+
+  printf("b1={%d,{%c,%c},{%d,%hd,%f},{%ld}}\n", b1.a, b1.p[0], b1.p[1], b1.f.a, b1.f.b, b1.f.c, b1.u.b);
+  printf("b2={%d,%d,{%d,%hd,%f},{%c}}\n", b2.a, b2.p, b2.f.a, b2.f.b, b2.f.c, b2.u.a);
+  printf("b2_2={%d,{%c,%c},{%d,%hd,%f},{%c}}\n", b2_2.a, b2_2.p[0], b1.p[1], b2_2.f.a, b2_2.f.b, b2_2.f.c, b2_2.u.a);
+  printf("b3={%d,%d,{%d,%hd,%f},{%ld}}\n", b3.a, b3.p, b3.f.a, b3.f.b, b3.f.c, b3.u.b);
+  printf("b4={%d,{%c,%c},{%d,%hd,%f},{%ld}}\n", b4.a, b4.p[0], b4.p[1], b4.f.a, b4.f.b, b4.f.c, b4.u.b);
+  printf("b5={%d,%d,{%d,%hd,%f},{%ld}}\n", b5.a, b5.p, b5.f.a, b5.f.b, b5.f.c, b5.u.b);
+
+  printf("c1={%d,%d,%d}\n",c1.a, c1.b, c1.c);
+  printf("c2={%d,%d,%d}\n",c2.a, c2.b, c2.c);
+  printf("c3={%d,%d,%d}\n",c3.a, c3.b, c3.c);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0091-StructInitWithZero/expected.txt b/testsuite/c_test/ast_test/AST0091-StructInitWithZero/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..30b742da3de1f3844f23984b1c123544597fe8b8
Binary files /dev/null and b/testsuite/c_test/ast_test/AST0091-StructInitWithZero/expected.txt differ
diff --git a/testsuite/c_test/ast_test/AST0091-StructInitWithZero/test.cfg b/testsuite/c_test/ast_test/AST0091-StructInitWithZero/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..820483ff569a1baf7e948c666dd5a0f10198a0d0
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0091-StructInitWithZero/test.cfg
@@ -0,0 +1,2 @@
+compile(StructInitWithZero)
+run(StructInitWithZero)
diff --git a/testsuite/c_test/ast_test/AST0092-UnionInitWithZero/UnionInitWithZero.c b/testsuite/c_test/ast_test/AST0092-UnionInitWithZero/UnionInitWithZero.c
new file mode 100644
index 0000000000000000000000000000000000000000..2519b5483a67e41c9ca4e21c8c334f03ec2b2854
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0092-UnionInitWithZero/UnionInitWithZero.c
@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <limits.h>
+
+struct subFoo {
+  int a;
+  short b;
+  double c;
+};
+
+union uTestA {
+  char a;
+  long b;
+  float c;
+  char str[20];
+};
+
+union uTestB {
+  int a;
+};
+
+union uTestC {
+  int a;
+  struct subFoo f;
+  union uTestA uA;
+  union uTestB uB;
+};
+
+int main() {
+  union uTestA ua = {.b=0};
+  union uTestC uc1 = {.a=0};
+  union uTestC uc2 = {.a=INT_MAX};
+  union uTestC uc3 = {.f={INT_MAX, 0, 3.14}};
+  union uTestC uc4 = {.uB={.a=INT_MAX}};
+  union uTestC uc5 = {.uA={.str={'h','i'}}};
+  union uTestC uc6 = {.f={0}};
+  union uTestC uc7={.f={INT_MAX, 0, 0}};
+
+  printf("ua={%ld}\n", ua.b);
+  printf("uc1={%d}\n", uc1.a);
+  printf("uc2={%d}\n", uc2.a);
+  printf("uc3={{%d,%hd,%f}}\n", uc3.f.a, uc3.f.b,uc3.f.c);
+  printf("uc4={{%d}}\n", uc4.uB.a);
+  printf("uc5={{%c,%c,%c,%c,...}}\n", uc5.uA.str[0], uc5.uA.str[1],uc5.uA.str[2], uc5.uA.str[3]);
+  printf("uc6={{%d,%hd,%f}}\n", uc6.f.a, uc6.f.b,uc6.f.c);
+  printf("uc7={{%d,%hd,%f}}\n", uc7.f.a, uc7.f.b,uc7.f.c);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0092-UnionInitWithZero/expected.txt b/testsuite/c_test/ast_test/AST0092-UnionInitWithZero/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5404167e7d664155b814abaa4d758b5b653a9ddc
Binary files /dev/null and b/testsuite/c_test/ast_test/AST0092-UnionInitWithZero/expected.txt differ
diff --git a/testsuite/c_test/ast_test/AST0092-UnionInitWithZero/test.cfg b/testsuite/c_test/ast_test/AST0092-UnionInitWithZero/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a7901f1a401fa5845f6341683a0dab30cf3fc8c7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0092-UnionInitWithZero/test.cfg
@@ -0,0 +1,2 @@
+compile(UnionInitWithZero)
+run(UnionInitWithZero)
diff --git a/testsuite/c_test/ast_test/AST0093-NestedWithEmptyStruct/NestedWithEmptyStruct.c b/testsuite/c_test/ast_test/AST0093-NestedWithEmptyStruct/NestedWithEmptyStruct.c
new file mode 100644
index 0000000000000000000000000000000000000000..2b3f6fcd883dcb258ee26321cca57a93aceec01f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0093-NestedWithEmptyStruct/NestedWithEmptyStruct.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+struct empty { };
+struct something {
+  int spacer;
+  struct empty foo;
+  int bar;
+};
+struct something X = {
+  foo: { },
+  bar: 1,
+};
+int main() {
+  printf("%d\n", sizeof X);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0093-NestedWithEmptyStruct/expected.txt b/testsuite/c_test/ast_test/AST0093-NestedWithEmptyStruct/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..45a4fb75db864000d01701c0f7a51864bd4daabf
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0093-NestedWithEmptyStruct/expected.txt
@@ -0,0 +1 @@
+8
diff --git a/testsuite/c_test/ast_test/AST0093-NestedWithEmptyStruct/test.cfg b/testsuite/c_test/ast_test/AST0093-NestedWithEmptyStruct/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..36ef46e24d828bec644536a08e5084995e586326
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0093-NestedWithEmptyStruct/test.cfg
@@ -0,0 +1,2 @@
+compile(NestedWithEmptyStruct)
+run(NestedWithEmptyStruct)
diff --git a/testsuite/c_test/ast_test/AST0094-StructInitWithCastExpr/StructInitWithCastExpr.c b/testsuite/c_test/ast_test/AST0094-StructInitWithCastExpr/StructInitWithCastExpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..e6fdd05c992be5e1afcaa181ab88b614b364d866
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0094-StructInitWithCastExpr/StructInitWithCastExpr.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+struct T { int i; };
+struct S { struct T t; };
+static struct S s = (struct S){ .t = { 42 } };
+struct T t = (struct T){.i = 22};
+int main() {
+  printf("s.t.i=%d\n", s.t.i);
+  printf("t.i=%d\n", t.i);
+}
diff --git a/testsuite/c_test/ast_test/AST0094-StructInitWithCastExpr/expected.txt b/testsuite/c_test/ast_test/AST0094-StructInitWithCastExpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e864b9d5674379c38739b7398b1ad0953889e8f6
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0094-StructInitWithCastExpr/expected.txt
@@ -0,0 +1,2 @@
+s.t.i=42
+t.i=22
diff --git a/testsuite/c_test/ast_test/AST0094-StructInitWithCastExpr/test.cfg b/testsuite/c_test/ast_test/AST0094-StructInitWithCastExpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fd2d8a1fbae9420d39537bfda36dc2e2828b9dda
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0094-StructInitWithCastExpr/test.cfg
@@ -0,0 +1,2 @@
+compile(StructInitWithCastExpr)
+run(StructInitWithCastExpr)
diff --git a/testsuite/c_test/ast_test/AST0095-AddrOfLabel_SpecialCases/AddrOfLabel.c b/testsuite/c_test/ast_test/AST0095-AddrOfLabel_SpecialCases/AddrOfLabel.c
new file mode 100644
index 0000000000000000000000000000000000000000..83ebd1cec08b6ddc2d0cd8a6cd0e6cefe6d83f5b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0095-AddrOfLabel_SpecialCases/AddrOfLabel.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+// CHECK: [[# FILENUM:]] "{{.*}}/AddrOfLabel.c"
+void bar (void *) {}
+int main() {
+  // CHECK: @__hereA@{{.*}}
+  // CHECK: call &bar (addroflabel ptr @__hereA@{{.*}})
+  bar(({__hereA:&&__hereA;}));
+  // CHECK: @__hereB@{{.*}}
+  // CHECK: @__subhereB@{{.*}}
+  // CHECK: call &bar (addroflabel ptr @__subhereB@{{.*}})
+  bar (({__hereB:__subhereB:&&__subhereB;}));
+  // CHECK: @__hereC@{{.*}}
+  // CHECK: @__subhereC@{{.*}}
+  // CHECK: @__fooC@{{.*}}
+  // call &bar (addroflabel ptr @__fooC@{{.*}})
+  bar (({__hereC:__subhereC:&&__subhereC;__fooC:&&__fooC;}));
+  // CHECK: @__hereD@{{.*}}
+  // CHECK: @__fooD@{{.*}}
+  // call &bar (addroflabel ptr @__fooD@{{.*}})
+  bar (({__hereD:&&__hereD;({__fooD:&&__fooD;});}));
+  // CHECK: eval (addroflabel ptr @ff{{.*}})
+  &&ff;
+  printf("it should not be skipped\n");
+  ff:
+  goto end;
+  printf("it should be skipped\n");
+  end:;
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0095-AddrOfLabel_SpecialCases/expected.txt b/testsuite/c_test/ast_test/AST0095-AddrOfLabel_SpecialCases/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..de8eca47bd9447f27e72a0fe8837eb9cd4897ad5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0095-AddrOfLabel_SpecialCases/expected.txt
@@ -0,0 +1 @@
+it should not be skipped
diff --git a/testsuite/c_test/ast_test/AST0095-AddrOfLabel_SpecialCases/test.cfg b/testsuite/c_test/ast_test/AST0095-AddrOfLabel_SpecialCases/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f5fd09e393979ae327bcb54df98d15dfba2e1c0c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0095-AddrOfLabel_SpecialCases/test.cfg
@@ -0,0 +1,3 @@
+compile(AddrOfLabel)
+run(AddrOfLabel)
+cat AddrOfLabel.mpl | ${OUT_ROOT}/tools/bin/FileCheck AddrOfLabel.c
diff --git a/testsuite/c_test/ast_test/AST0096-AsmOutWithPtrType/asm.c b/testsuite/c_test/ast_test/AST0096-AsmOutWithPtrType/asm.c
new file mode 100644
index 0000000000000000000000000000000000000000..e3c3f33955e1857082dca8b0fe68009cfce24a67
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0096-AsmOutWithPtrType/asm.c
@@ -0,0 +1,44 @@
+// CHECK: [[# FILENUM:]] "{{.*}}/asm.c"
+struct subA {
+  int b;
+};
+struct A {
+  long a;
+  struct subA f;
+};
+
+static inline void foo1(struct A *x)
+{
+ // CHECK: var %asm_out_{{.*}} i64
+ // CHECK: {{.*}} dassign %asm_out_{{.*}} 0
+ // CHECK: iassign <* <$A{{.*}}>> 1 (dread ptr %x, dread i64 %asm_out_{{.*}})
+  __asm__ __volatile__("" : "+m"(x->a) : "r"(x) : "memory", "cc");
+}
+
+static inline void foo2(struct A *x)
+{
+ // CHECK: var %asm_out_{{.*}} <$subA{{.*}}>
+ // CHECK: {{.*}} dassign %asm_out_{{.*}} 0
+ // CHECK: iassign <* <$A{{.*}}>> 2 (dread ptr %x, dread agg %asm_out_{{.*}})
+  __asm__ __volatile__("" : "+m"(x->f) : "r"(x) : "memory", "cc");
+}
+
+static inline void foo3(struct A *x)
+{
+ // CHECK: var %asm_out_{{.*}} i64
+ // CHECK: {{.*}} dassign %asm_out_{{.*}} 0
+ // CHECK: iassign <* <$A{{.*}}>> 1 (dread ptr %x, dread i64 %asm_out_{{.*}})
+  __asm__ __volatile__("" : "+r"(x->a) : "r"(x) : "memory", "cc");
+}
+
+static inline void foo4(struct A *x)
+{
+ // CHECK: var %asm_out_{{.*}} <$subA{{.*}}>
+ // CHECK: {{.*}} dassign %asm_out_{{.*}} 0
+ // CHECK: iassign <* <$A{{.*}}>> 2 (dread ptr %x, dread agg %asm_out_{{.*}})
+  __asm__ __volatile__("" : "+r"(x->f) : "r"(x) : "memory", "cc");
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0096-AsmOutWithPtrType/expected.txt b/testsuite/c_test/ast_test/AST0096-AsmOutWithPtrType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0096-AsmOutWithPtrType/test.cfg b/testsuite/c_test/ast_test/AST0096-AsmOutWithPtrType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..840dc737506f05b81f960448718f406a4cc7be15
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0096-AsmOutWithPtrType/test.cfg
@@ -0,0 +1,3 @@
+compile(asm)
+run(asm)
+cat asm.mpl | ${OUT_ROOT}/tools/bin/FileCheck asm.c
diff --git a/testsuite/c_test/ast_test/AST0096-UnfoldableConst/HelloWorld.c b/testsuite/c_test/ast_test/AST0096-UnfoldableConst/HelloWorld.c
new file mode 100644
index 0000000000000000000000000000000000000000..e6874c1c21d3e71fccbd74112ee0cc1ad6834b11
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0096-UnfoldableConst/HelloWorld.c
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+void f()
+{
+  void *p = &&a;
+  1 ? 1 : ({ a : 1; });
+  goto *p;
+}
+
+void f1(int x)
+{
+  1 ? 1 : ({  x; });
+}
+
+void f2 (int x) {
+ int y;
+ void *p = &&a;
+ y =  0 && ({ a : 1; });
+ goto *p;
+}
+
+int main() {
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0096-UnfoldableConst/expected.txt b/testsuite/c_test/ast_test/AST0096-UnfoldableConst/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0096-UnfoldableConst/test.cfg b/testsuite/c_test/ast_test/AST0096-UnfoldableConst/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0096-UnfoldableConst/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/c_test/ast_test/AST0097-StructInitWithStringLiteral/StructInitWithStringLiteral.c b/testsuite/c_test/ast_test/AST0097-StructInitWithStringLiteral/StructInitWithStringLiteral.c
new file mode 100644
index 0000000000000000000000000000000000000000..e6fd99e465a9b1d6d888c6ce32c03943b9259378
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0097-StructInitWithStringLiteral/StructInitWithStringLiteral.c
@@ -0,0 +1,41 @@
+struct subFoo {
+  int d;
+  char c[3][8];
+  char c2[13];
+};
+
+struct A {
+  int a;
+  char c[11];
+  int b;
+  char *p;
+  struct subFoo f;
+};
+
+int main() {
+  char *p1 = "j\0\0\0\0\0\0\0\0\0";
+  char *p2_1 = "apple\0\0";
+  char *p2_2 = "orange\0";
+  char *p2_3 = "bananas";
+  char *p3 = "k";
+  char *p4 = "hello\0\0\0\0\0\0\0";
+  struct A a = {1,"j",2, "k",{3,{"apple","orange","bananas"},"hello"}};
+  printf("a.a=%d\n", a.a);
+  if (__builtin_memcmp (a.c, p1, 11) == 0) {
+    printf("a.c ok\n");
+  }
+  printf("a.b=%d\n", a.b);
+  if (__builtin_memcmp (a.p, p3, 2) == 0) {
+    printf("a.p ok\n");
+  }
+  printf("a.f.d=%d\n", a.f.d);
+  if (__builtin_memcmp (a.f.c[0], p2_1, 8) == 0 &&
+      __builtin_memcmp (a.f.c[1], p2_2, 8) == 0 &&
+      __builtin_memcmp (a.f.c[2], p2_3, 8) == 0) {
+    printf("a.f.c ok\n");
+  }
+  if (__builtin_memcmp (a.f.c2, p4, 13) == 0) {
+    printf("a.f.c2 ok\n");
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0097-StructInitWithStringLiteral/expected.txt b/testsuite/c_test/ast_test/AST0097-StructInitWithStringLiteral/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4589f6436dd11352661eeb2c898f324ab410a130
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0097-StructInitWithStringLiteral/expected.txt
@@ -0,0 +1,7 @@
+a.a=1
+a.c ok
+a.b=2
+a.p ok
+a.f.d=3
+a.f.c ok
+a.f.c2 ok
diff --git a/testsuite/c_test/ast_test/AST0097-StructInitWithStringLiteral/test.cfg b/testsuite/c_test/ast_test/AST0097-StructInitWithStringLiteral/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..db43aac63612610f696cb6fe18bf5dabdab46f40
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0097-StructInitWithStringLiteral/test.cfg
@@ -0,0 +1,2 @@
+compile(StructInitWithStringLiteral)
+run(StructInitWithStringLiteral)
diff --git a/testsuite/c_test/ast_test/AST0098-CharArrayInitWithStringLiteral/CharArrayInit.c b/testsuite/c_test/ast_test/AST0098-CharArrayInitWithStringLiteral/CharArrayInit.c
new file mode 100644
index 0000000000000000000000000000000000000000..32c34e0845c3c1b247e2d59fe888f1a66041681f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0098-CharArrayInitWithStringLiteral/CharArrayInit.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+
+int main() {
+  char c1[10] = {"apple"};
+  char c2[10] = "apple";
+  char c3[3][10] = {{"apple"},{"banana"},{"redorange"}};
+  char c4[3][10] = {"apple", "banana", "redorange"};
+  char *p1 = "apple\0\0\0\0";
+  char *p2 = "banana\0\0\0";
+  char *p3 = "redorange";
+  if (__builtin_memcmp (c1, p1, 10) == 0 &&
+      __builtin_memcmp (c2, p1, 10) == 0 &&
+      __builtin_memcmp (c3[0], p1, 10) == 0 &&
+      __builtin_memcmp (c3[1], p2, 10) == 0 &&
+      __builtin_memcmp (c3[2], p3, 10) == 0 &&
+      __builtin_memcmp (c4[0], p1, 10) == 0 &&
+      __builtin_memcmp (c4[1], p2, 10) == 0 &&
+      __builtin_memcmp (c4[2], p3, 10) == 0) {
+    printf("test ok\n");
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0098-CharArrayInitWithStringLiteral/expected.txt b/testsuite/c_test/ast_test/AST0098-CharArrayInitWithStringLiteral/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eaf8b26a3b4f2dadaab597f35eb2d58678806390
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0098-CharArrayInitWithStringLiteral/expected.txt
@@ -0,0 +1 @@
+test ok
diff --git a/testsuite/c_test/ast_test/AST0098-CharArrayInitWithStringLiteral/test.cfg b/testsuite/c_test/ast_test/AST0098-CharArrayInitWithStringLiteral/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..be2af06bdac737f0a8f5eb85e40f5fec2a3b21b5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0098-CharArrayInitWithStringLiteral/test.cfg
@@ -0,0 +1,2 @@
+compile(CharArrayInit)
+run(CharArrayInit)
diff --git a/testsuite/c_test/ast_test/AST0098-UnionCast/HelloWorld.c b/testsuite/c_test/ast_test/AST0098-UnionCast/HelloWorld.c
new file mode 100644
index 0000000000000000000000000000000000000000..630b6bf552d6a8d3d0637eece92a1bfd082b6370
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0098-UnionCast/HelloWorld.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+struct tree_string
+{
+  char str[1];
+};
+
+union tree_node
+{
+  struct tree_string string;
+};
+
+char *Foo (char *str)
+{
+  char *str1 = ((union {const char * _q; char * _nq;}) str)._nq;
+  return str1;
+}
+
+char *Foo1 (union tree_node * num_string)
+{
+  char *str = ((union {const char * _q; char * _nq;})
+               ((const char *)(({ __typeof (num_string) const __t
+                                     = num_string;  __t; })
+                               ->string.str)))._nq;
+  return str;
+}
+
+int main() {
+  char *i = Foo("123");
+  union tree_node node = {'4'};
+  char *j = Foo1(&node);
+  printf("%c,%c\n", i[2], j[0]);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0098-UnionCast/expected.txt b/testsuite/c_test/ast_test/AST0098-UnionCast/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f87ec89c3d80adac91e86db1094409326fbc547d
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0098-UnionCast/expected.txt
@@ -0,0 +1 @@
+3,4
diff --git a/testsuite/c_test/ast_test/AST0098-UnionCast/test.cfg b/testsuite/c_test/ast_test/AST0098-UnionCast/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0098-UnionCast/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/c_test/ast_test/AST0099-CompoundLiteralExprAsLValue/compoundliteral.c b/testsuite/c_test/ast_test/AST0099-CompoundLiteralExprAsLValue/compoundliteral.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f19c3690c0169342258602d31a5cb3f221598cb
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0099-CompoundLiteralExprAsLValue/compoundliteral.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+
+struct S {
+  float a;
+};
+
+union U {
+  int a;
+};
+
+void Foo1(int a) {
+  printf("a=%d\n", a);
+}
+
+void Foo2(struct S f) {
+  printf("f.a=%f\n", f.a);
+}
+
+void Foo3(union U u) {
+  printf("u.a=%d\n", u.a);
+}
+
+int main() {
+  Foo1((int){7} = 407);
+  Foo2((struct S) {3} = (struct S){222});
+  Foo3((union U) {123} = (union U){321});
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0099-CompoundLiteralExprAsLValue/expected.txt b/testsuite/c_test/ast_test/AST0099-CompoundLiteralExprAsLValue/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3c188c5a13b86b9455e4321ec9a28809ebc713db
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0099-CompoundLiteralExprAsLValue/expected.txt
@@ -0,0 +1,3 @@
+a=407
+f.a=222.000000
+u.a=321
diff --git a/testsuite/c_test/ast_test/AST0099-CompoundLiteralExprAsLValue/test.cfg b/testsuite/c_test/ast_test/AST0099-CompoundLiteralExprAsLValue/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9333ef17b3e377e9036083e7aa6c44d0c5ea70f3
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0099-CompoundLiteralExprAsLValue/test.cfg
@@ -0,0 +1,2 @@
+compile(compoundliteral)
+run(compoundliteral)
diff --git a/testsuite/c_test/ast_test/AST0100-BinaryOperatorStmtInExprStmt/expected.txt b/testsuite/c_test/ast_test/AST0100-BinaryOperatorStmtInExprStmt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b261da18d51a39dc2cf0d156791e9c0b35dd83f4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0100-BinaryOperatorStmtInExprStmt/expected.txt
@@ -0,0 +1,2 @@
+1
+0
diff --git a/testsuite/c_test/ast_test/AST0100-BinaryOperatorStmtInExprStmt/exprstmt.c b/testsuite/c_test/ast_test/AST0100-BinaryOperatorStmtInExprStmt/exprstmt.c
new file mode 100644
index 0000000000000000000000000000000000000000..76258802f2dfe38723851bfed8ed285b03cd4d99
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0100-BinaryOperatorStmtInExprStmt/exprstmt.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+
+#define test(_si1, _si2)                      \
+  ({                                          \
+    int si1 = (_si1);                         \
+    int si2 = (_si2);                         \
+    (((si1) > (0)) && ((si2) > (0))) ? 1 : 0; \
+  })
+
+void func_1(int a, int b) {
+  if (test(a,b)) {
+    printf("%d\n", 1);
+  } else {
+    printf("%d\n", 0);
+  }
+}
+
+int main() {
+  func_1(1,1);
+  func_1(1,-1);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0100-BinaryOperatorStmtInExprStmt/test.cfg b/testsuite/c_test/ast_test/AST0100-BinaryOperatorStmtInExprStmt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9e39ff4197025305e3dcbd3242e87a5fc04bc856
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0100-BinaryOperatorStmtInExprStmt/test.cfg
@@ -0,0 +1,2 @@
+compile(exprstmt)
+run(exprstmt)
diff --git a/testsuite/c_test/ast_test/AST0101-ReturnUnionInRegs/expected.txt b/testsuite/c_test/ast_test/AST0101-ReturnUnionInRegs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0101-ReturnUnionInRegs/test.c b/testsuite/c_test/ast_test/AST0101-ReturnUnionInRegs/test.c
new file mode 100644
index 0000000000000000000000000000000000000000..875bba1b6495f9cd166739cd1f820aa1f703a22c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0101-ReturnUnionInRegs/test.c
@@ -0,0 +1,29 @@
+typedef union {
+    double el1[2];
+    double el2;
+} test_union1_t;
+
+typedef union {
+    double el1[2];
+    char el2;
+} test_union2_t;
+
+test_union1_t g_union1;
+test_union2_t g_union2;
+
+test_union1_t func1(void) {
+    // CHECK: ldr     d0
+    // CHECK: ldr     d1
+    return g_union1;
+}
+
+test_union2_t func2(void) {
+    // CHECK: ldr     x0
+    // CHECK: ldr     x1
+    return g_union2;
+}
+
+int main(void) {
+    test_union1_t loc1 = func1();
+    test_union2_t loc2 = func2();
+}
diff --git a/testsuite/c_test/ast_test/AST0101-ReturnUnionInRegs/test.cfg b/testsuite/c_test/ast_test/AST0101-ReturnUnionInRegs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f926ca21e0f54de39d1b78d2cd09861044f80ca1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0101-ReturnUnionInRegs/test.cfg
@@ -0,0 +1,8 @@
+ASTO2:
+compile(test)
+run(test)
+cat test.s | ${OUT_ROOT}/tools/bin/FileCheck test.c
+ASTO0:
+compile(test)
+run(test)
+cat test.s | ${OUT_ROOT}/tools/bin/FileCheck test.c
\ No newline at end of file
diff --git a/testsuite/c_test/ast_test/AST0101-staticDebug/StaticDebug.c b/testsuite/c_test/ast_test/AST0101-staticDebug/StaticDebug.c
new file mode 100644
index 0000000000000000000000000000000000000000..67e1fa61efcafbf0d9c1c16157fe8653ba22341b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0101-staticDebug/StaticDebug.c
@@ -0,0 +1,31 @@
+static int filelocal = 2; /* In Data section */
+static int filelocal_bss; /* In BSS section */
+
+static const int filelocal_ro = 202;  /* In Read-Only Data section */
+
+void foo ()
+{
+
+  void bar ();
+
+  static int funclocal = 3; /* In Data section */
+  static int funclocal_bss; /* In BSS section */
+  static const int funclocal_ro = 203;  /* RO Data */
+  static const int funclocal_ro_bss;  /* RO Data */
+
+  funclocal_bss = 103;
+  bar ();
+}
+
+void bar ()
+{
+  static int funclocal = 4; /* In data section */
+  static int funclocal_bss; /* In BSS section */
+  funclocal_bss = 104;
+}
+
+
+int main() {
+  foo ();
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0101-staticDebug/expected.txt b/testsuite/c_test/ast_test/AST0101-staticDebug/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0101-staticDebug/test.cfg b/testsuite/c_test/ast_test/AST0101-staticDebug/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1df1081409e3b9e67cab502ca34ac935235b4cf3
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0101-staticDebug/test.cfg
@@ -0,0 +1,2 @@
+compile(StaticDebug)
+run(StaticDebug)
diff --git a/testsuite/c_test/ast_test/AST0102-clobbered-registers/ClobberedRegisters.c b/testsuite/c_test/ast_test/AST0102-clobbered-registers/ClobberedRegisters.c
new file mode 100644
index 0000000000000000000000000000000000000000..b5c7b65dadb9e0b7e10365e31d7bc63dfe18d772
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0102-clobbered-registers/ClobberedRegisters.c
@@ -0,0 +1,22 @@
+unsigned  __attribute__((noinline))
+start_sequence (unsigned * x, unsigned * y)
+{
+  return (unsigned )0xdeadbeef;
+};
+
+unsigned __attribute__((noinline))
+gen_movsd (unsigned * operand0, unsigned * operand1)
+{
+  return start_sequence(operand0, operand1);
+}
+
+int main()
+{
+  unsigned x, y;
+
+  x = 13;
+  y = 14;
+  (int)gen_movsd (&x, &y);
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0102-clobbered-registers/expected.txt b/testsuite/c_test/ast_test/AST0102-clobbered-registers/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0102-clobbered-registers/test.cfg b/testsuite/c_test/ast_test/AST0102-clobbered-registers/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8371f98ba09728f30230322af1dfa402d6e12311
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0102-clobbered-registers/test.cfg
@@ -0,0 +1,2 @@
+compile(ClobberedRegisters)
+run(ClobberedRegisters)
diff --git a/testsuite/c_test/ast_test/AST0103-BuiltInExpectOptimize/builtinexpect.c b/testsuite/c_test/ast_test/AST0103-BuiltInExpectOptimize/builtinexpect.c
new file mode 100644
index 0000000000000000000000000000000000000000..647660c7a8cb161cd8ef6b696a7e720c5a83d142
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0103-BuiltInExpectOptimize/builtinexpect.c
@@ -0,0 +1,237 @@
+#ifndef likely
+#define likely(x) __builtin_expect((x), 1)
+#endif
+
+#ifndef unlikely
+#define unlikely(x) __builtin_expect((x), 0)
+#endif
+
+// CHECK: [[# FILENUM:]] "{{.*}}/builtinexpect.c"
+
+// each pair of following functions have equivalent __builtin_expect intrinsicop in mpl
+void and_un(int a, int b) {
+  // CHECK: func &and_un
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: return ()
+  if (unlikely(a != 0) && unlikely(b != 0)) {}
+}
+void un_and(int a, int b) {
+  // CHECK: func &un_and
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: return ()
+  if (unlikely(a != 0 && b != 0)) {}
+}
+
+
+void or_un(int a, int b) {
+  // CHECK: func &or_un
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: return ()
+  if (unlikely(a != 0) || unlikely(b != 0)) {}
+}
+void un_or(int a, int b) {
+  // CHECK: func &un_or
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: return ()
+  if (unlikely(a != 0 || b != 0)) {}
+}
+
+
+void and_likely(int a, int b) {
+  // CHECK: func &and_likely
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK:return ()
+  if (likely(a != 0) && likely(b != 0)) {}
+}
+void likely_and(int a, int b) {
+  // CHECK: func &likely_and
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: return ()
+  if (likely(a != 0 && b != 0)) {}
+}
+
+
+void or_likely(int a, int b) {
+  // CHECK: func &or_likely
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: return ()
+  if (likely(a != 0) || likely(b != 0)) {}
+}
+void likely_or(int a, int b) {
+  // CHECK: func &likely_or
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK return ()
+  if (likely(a != 0 || b != 0)) {}
+}
+
+
+void and_or_likely(int a, int b, int c) {
+  // CHECK: func &and_or_likely
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: return ()
+  if (likely(a!= 0) && (likely(b != 0) || likely(c!=0))) {}
+}
+void likely_and_or(int a, int b , int c) {
+  // CHECK: func &likely_and_or
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: return ()
+  if (likely(a!= 0 && (b != 0 || c != 0))) {}
+}
+
+
+void or_and_likely(int a, int b, int c) {
+  // CHECK: func &or_and_likely
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: return ()
+  if (likely(a!= 0) || (likely(b != 0) && likely(c!=0))) {}
+}
+void likely_or_and(int a, int b , int c) {
+  // CHECK: func &likely_or_and
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK:return ()
+  if (likely(a!= 0 || (b != 0 && c != 0))) {}
+}
+
+
+void un_and_likely_and(int a, int b, int c) {
+  // CHECK: func &un_and_likely_and
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // return ()
+  if(unlikely(a != 0) && likely(b != 0 && c != 0)) {}
+}
+void un_and_and_likely(int a, int b, int c) {
+  // CHECK: func &un_and_and_likely
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // return ()
+  if(unlikely(a != 0) && likely(b != 0) && likely(c != 0)) {}
+}
+
+
+void un_and_likely_or(int a, int b, int c) {
+  // CHECK: func &un_and_likely_or
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // return ()
+  if(unlikely(a != 0) && likely(b != 0 || c != 0)) {}
+}
+void un_and_or_likely(int a, int b, int c) {
+  // CHECK: func &un_and_or_likely
+  // CHECK: brfalse @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // return ()
+  if(unlikely(a != 0) && (likely(b != 0) || likely(c != 0))) {}
+}
+
+
+void un_or_liklely_or(int a, int b, int c) {
+  // CHECK: func &un_or_liklely_or
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // return ()
+  if(unlikely(a != 0) || likely(b != 0 || c != 0)) {}
+}
+void un_or_or_likely(int a, int b, int c) {
+  // CHECK: func &un_or_or_likely
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // return ()
+  if(unlikely(a != 0) || likely(b != 0) || likely(c != 0)) {}
+}
+
+
+void un_or_likely_and(int a, int b, int c) {
+  // CHECK: func &un_or_likely_and
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: false @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: false @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // return ()
+  if(unlikely(a != 0) || likely(b != 0 && c != 0)) {}
+}
+void un_or_and_likely(int a, int b, int c) {
+  // CHECK: func &un_or_and_likely
+  // CHECK: brtrue @shortCircuit_{{.*}}
+  // CHECK-NEXT: intrinsicop i64 C___builtin_expect
+  // CHECK: false @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // CHECK: false @shortCircuit_{{.*}}
+  // CHECK-NEXT:intrinsicop i64 C___builtin_expect
+  // return ()
+  if(unlikely(a != 0) || (likely(b != 0) && likely(c != 0))) {}
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0103-BuiltInExpectOptimize/expected.txt b/testsuite/c_test/ast_test/AST0103-BuiltInExpectOptimize/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0103-BuiltInExpectOptimize/test.cfg b/testsuite/c_test/ast_test/AST0103-BuiltInExpectOptimize/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..74a80ad96b4f2c29389bd7ba3c22e122a3698698
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0103-BuiltInExpectOptimize/test.cfg
@@ -0,0 +1,3 @@
+compile(builtinexpect)
+run(builtinexpect)
+cat builtinexpect.mpl | ${OUT_ROOT}/tools/bin/FileCheck builtinexpect.c
diff --git a/testsuite/c_test/ast_test/AST0103-volatile/Volatile.c b/testsuite/c_test/ast_test/AST0103-volatile/Volatile.c
new file mode 100644
index 0000000000000000000000000000000000000000..8185b8a515dab62664368913b1f1936a27ada5a7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0103-volatile/Volatile.c
@@ -0,0 +1,25 @@
+void marker1 (void)
+{
+}
+
+
+int main() {
+  /* volatile variables */
+  volatile char vox = 'X';
+  volatile unsigned char victuals = 13;
+  volatile short vixen = 200;
+  volatile unsigned short vitriol = 300;
+  volatile long vellum = 1000;
+  volatile unsigned long valve = 2000;
+  volatile float vacuity = 3.0;
+  volatile double vertigo = 10.3;
+
+  /* const volatile vars */
+  const volatile char           victor = 'Y';
+  const volatile unsigned char  vicar = 11;
+
+
+  marker1();
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0103-volatile/expected.txt b/testsuite/c_test/ast_test/AST0103-volatile/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0103-volatile/test.cfg b/testsuite/c_test/ast_test/AST0103-volatile/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0a9c572b18c59a09d7b2b6fd300ec427cb9753f6
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0103-volatile/test.cfg
@@ -0,0 +1,2 @@
+compile(Volatile)
+run(Volatile)
diff --git a/testsuite/c_test/ast_test/AST0104-FunctionPointer/expected.txt b/testsuite/c_test/ast_test/AST0104-FunctionPointer/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e4744dbd4f0c7202230ce40f8ac068b39b30cc50
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0104-FunctionPointer/expected.txt
@@ -0,0 +1,3 @@
+This is roundup
+This is roundup
+This is roundup
diff --git a/testsuite/c_test/ast_test/AST0104-FunctionPointer/funcpointer.c b/testsuite/c_test/ast_test/AST0104-FunctionPointer/funcpointer.c
new file mode 100644
index 0000000000000000000000000000000000000000..edc12f3a946e61408f085b256c36af3d85631dc0
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0104-FunctionPointer/funcpointer.c
@@ -0,0 +1,22 @@
+#include<stdio.h>
+
+int roundup() {
+    printf("This is roundup\n");
+    return 0;
+}
+
+int main() {
+  int  (*proundup)()  = roundup;
+  if (proundup != roundup) {
+    printf("proundup=%x  roundup=%x\n", proundup, roundup);
+    return 1;
+  }
+  if (&*proundup != roundup) {
+    printf("&*proundup=%x  roundup=%x\n",&*proundup, roundup);
+    return 1;
+  }
+  (*proundup)();
+  (proundup)();
+  roundup();
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0104-FunctionPointer/test.cfg b/testsuite/c_test/ast_test/AST0104-FunctionPointer/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c1ffe59633f3b532d24028bba23b997659506a38
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0104-FunctionPointer/test.cfg
@@ -0,0 +1,2 @@
+compile(funcpointer)
+run(funcpointer)
diff --git a/testsuite/c_test/ast_test/AST0104-location/Location.c b/testsuite/c_test/ast_test/AST0104-location/Location.c
new file mode 100644
index 0000000000000000000000000000000000000000..d77c6eb2910ed744aee4bfcea70a8c3c893790c5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0104-location/Location.c
@@ -0,0 +1,16 @@
+int multi_line_if_conditional (int a, int b, int c) {
+  if (a  /* set breakpoint 3 here */
+      && b
+      && c)
+    return 0;
+  else
+    return 1;
+}
+
+int main() {
+  int a = 2;
+  int b = 3;
+  int c = 4;
+
+  return multi_line_if_conditional(a, b, c);
+}
diff --git a/testsuite/c_test/ast_test/AST0104-location/expected.txt b/testsuite/c_test/ast_test/AST0104-location/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0104-location/test.cfg b/testsuite/c_test/ast_test/AST0104-location/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..02848ee2e37b977a1c123056c8d0007f8c6f268b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0104-location/test.cfg
@@ -0,0 +1,2 @@
+compile(Location)
+run(Location)
diff --git a/testsuite/c_test/ast_test/AST0105-atomic/atomic.c b/testsuite/c_test/ast_test/AST0105-atomic/atomic.c
new file mode 100644
index 0000000000000000000000000000000000000000..84ddbf473d021c1c28e3144a166bc5a22e7e7189
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0105-atomic/atomic.c
@@ -0,0 +1,12 @@
+enum OrderEnum {
+  MEMORY_ORDER_RELEAXED = __ATOMIC_RELAXED,
+};
+int main() {
+  int a = 100;
+  int b = 89;
+  int *prev = &a;
+  int *next = &b;
+  enum OrderEnum order = MEMORY_ORDER_RELEAXED;
+  __atomic_store_n(&prev, (next), order);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0105-atomic/expected.txt b/testsuite/c_test/ast_test/AST0105-atomic/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0105-atomic/test.cfg b/testsuite/c_test/ast_test/AST0105-atomic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9832106017dc1cb1368fc1adde3d12c34ad1fd88
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0105-atomic/test.cfg
@@ -0,0 +1,2 @@
+compile(atomic)
+run(atomic)
diff --git a/testsuite/c_test/ast_test/AST0106-SameStructName/SameStructName.c b/testsuite/c_test/ast_test/AST0106-SameStructName/SameStructName.c
new file mode 100644
index 0000000000000000000000000000000000000000..79d01ec4cb7fe1d76aef79934f50cd40867b4949
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0106-SameStructName/SameStructName.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+struct Agg {
+  int i;
+  int j;
+} gAgg;
+
+void foo() {
+  struct Agg {
+    float m;
+    float n;
+  } tstAgg;
+
+  tstAgg.m = 1.0;
+  tstAgg.n = 2.0;
+
+  gAgg.i = 1.0;
+  gAgg.j = 2.0;
+
+  printf("%f %f %d %d\n", tstAgg.m, tstAgg.n, gAgg.i, gAgg.j);
+}
+
+int main() {
+  foo();
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0106-SameStructName/expected.txt b/testsuite/c_test/ast_test/AST0106-SameStructName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..23be032774d7a0ab92d82849918359c190f16a53
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0106-SameStructName/expected.txt
@@ -0,0 +1 @@
+1.000000 2.000000 1 2
diff --git a/testsuite/c_test/ast_test/AST0106-SameStructName/test.cfg b/testsuite/c_test/ast_test/AST0106-SameStructName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fcd27d54c5e7207779b392de1056f627224e3fe9
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0106-SameStructName/test.cfg
@@ -0,0 +1,2 @@
+compile(SameStructName)
+run(SameStructName)
diff --git a/testsuite/c_test/ast_test/AST0107-Backtrace/Backtrace.c b/testsuite/c_test/ast_test/AST0107-Backtrace/Backtrace.c
new file mode 100644
index 0000000000000000000000000000000000000000..500423734d35b9421a83cdd80f419a3d88faedf4
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0107-Backtrace/Backtrace.c
@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <execinfo.h>
+
+void  __attribute__ ((noinline)) print_backtrace() {
+  void *buffer[64];
+  char **symbols;
+
+  int num = backtrace(buffer, 64);
+  printf("backtrace() returned %d addresses\n", num);
+
+  symbols = backtrace_symbols(buffer, num);
+  if (symbols == NULL) {
+    perror("backtrace_symbols");
+    exit(EXIT_FAILURE);
+  }
+
+  for (int j = 0; j < num; ++j) {
+    printf("%s\n", symbols[j]);
+  }
+
+  free(symbols);
+}
+
+void  __attribute__ ((noinline)) myfunc3() {
+  print_backtrace();
+}
+
+void  __attribute__ ((noinline)) myfunc2() {
+  myfunc3();
+}
+
+void  __attribute__ ((noinline)) myfunc1() {
+  myfunc2();
+}
+
+int main() {
+  myfunc1();
+}
diff --git a/testsuite/c_test/ast_test/AST0107-Backtrace/test.cfg b/testsuite/c_test/ast_test/AST0107-Backtrace/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7ddab2b763f8824c7d629fb345fe5c105020f91f
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0107-Backtrace/test.cfg
@@ -0,0 +1 @@
+compile(Backtrace)
diff --git a/testsuite/c_test/ast_test/AST0108-RegisterField/RegisterField.c b/testsuite/c_test/ast_test/AST0108-RegisterField/RegisterField.c
new file mode 100644
index 0000000000000000000000000000000000000000..f6c6bd47c1282c1dab667ec51adafc059e977c5a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0108-RegisterField/RegisterField.c
@@ -0,0 +1,15 @@
+#include<stdio.h>
+
+struct f_4 {unsigned i:4;unsigned j:4;unsigned k:4; } f_4 = {1,1,1}, F_4;
+
+struct f_4
+wack_field_4 (void)
+{
+  register struct f_4 u = f_4;
+  printf("%d\n", u.k);
+  return u;
+}
+
+int main() {
+  wack_field_4 ();
+}
diff --git a/testsuite/c_test/ast_test/AST0108-RegisterField/expected.txt b/testsuite/c_test/ast_test/AST0108-RegisterField/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0108-RegisterField/expected.txt
@@ -0,0 +1 @@
+1
diff --git a/testsuite/c_test/ast_test/AST0108-RegisterField/test.cfg b/testsuite/c_test/ast_test/AST0108-RegisterField/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..60a22d6f9cd55ec11babeb8ae77724522c2f3746
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0108-RegisterField/test.cfg
@@ -0,0 +1,2 @@
+compile(RegisterField)
+run(RegisterField)
diff --git a/testsuite/c_test/ast_test/AST0109-mergeBB/mergeBB.c b/testsuite/c_test/ast_test/AST0109-mergeBB/mergeBB.c
new file mode 100644
index 0000000000000000000000000000000000000000..50b59ba6b6dd3f4c400f7f820fd8e25df87c7310
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0109-mergeBB/mergeBB.c
@@ -0,0 +1,31 @@
+#include<stdio.h>
+
+int __attribute__ ((noinline)) test(int a, float b, int c, float d, int e, float f) {
+  if (a == 0) {
+    return c;
+  }
+
+  if (b < f) {
+    return a;
+  }
+
+  if (d > b) {
+    return e;
+  }
+
+  if (a > c) {
+    return c + a;
+  }
+
+  if (d > f + b) {
+    return e + a;
+  }
+
+  return a + c + e;
+}
+
+
+int main() {
+  int ans = test(2, 2.5, 4, 5.6, 6, 7.8);
+  printf("%d\n", ans);
+}
diff --git a/testsuite/c_test/ast_test/AST0109-mergeBB/test.cfg b/testsuite/c_test/ast_test/AST0109-mergeBB/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..133038d18373694f785b1a8c982ed0bc2d4a178b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0109-mergeBB/test.cfg
@@ -0,0 +1 @@
+compile(mergeBB)
diff --git a/testsuite/c_test/ast_test/AST0110-SameEnumName/SameEnumName.c b/testsuite/c_test/ast_test/AST0110-SameEnumName/SameEnumName.c
new file mode 100644
index 0000000000000000000000000000000000000000..20fae0c64ba813017818896ca8ae8bdedcf73733
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0110-SameEnumName/SameEnumName.c
@@ -0,0 +1,6 @@
+enum some_volatile_enum { enumvolval1, enumvolval2 };
+volatile enum some_volatile_enum some_volatile_enum = enumvolval1;
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0110-SameEnumName/expected.txt b/testsuite/c_test/ast_test/AST0110-SameEnumName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0110-SameEnumName/test.cfg b/testsuite/c_test/ast_test/AST0110-SameEnumName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7f420bba7d52fd8cf8d9cd9187c0d61f2a4d80ec
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0110-SameEnumName/test.cfg
@@ -0,0 +1,2 @@
+compile(SameEnumName)
+run(SameEnumName)
diff --git a/testsuite/c_test/ast_test/AST0111-Array/Array.c b/testsuite/c_test/ast_test/AST0111-Array/Array.c
new file mode 100644
index 0000000000000000000000000000000000000000..436c14ef55749624acbb19a86742e0a85b7089bc
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0111-Array/Array.c
@@ -0,0 +1,8 @@
+int int1dim[12] = {0,1,2,3,4,5,6,7,8,9,10,11};
+int int2dim[3][4] = {{0,1,2,3},{4,5,6,7},{8,9,10,11}};
+int int3dim[2][3][2] = {{{0,1},{2,3},{4,5}},{{6,7},{8,9},{10,11}}};
+int int4dim[1][2][3][2] = {{{{0,1},{2,3},{4,5}},{{6,7},{8,9},{10,11}}}};
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0111-Array/expected.txt b/testsuite/c_test/ast_test/AST0111-Array/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0111-Array/test.cfg b/testsuite/c_test/ast_test/AST0111-Array/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ef1fff5259b55a5d86c856b7c2d6e803d902bf4b
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0111-Array/test.cfg
@@ -0,0 +1,2 @@
+compile(Array)
+run(Array)
diff --git a/testsuite/c_test/ast_test/AST0112-FrameArgs/FrameArgs.c b/testsuite/c_test/ast_test/AST0112-FrameArgs/FrameArgs.c
new file mode 100644
index 0000000000000000000000000000000000000000..a1419a9efbec02a4433c2353d832e5756389e3d2
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0112-FrameArgs/FrameArgs.c
@@ -0,0 +1,14 @@
+enum color { red, green, blue };
+
+static void break_me(void) {
+
+}
+
+static void call_me(enum color e) {
+  break_me();
+}
+
+int main() {
+  call_me(green);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0112-FrameArgs/expected.txt b/testsuite/c_test/ast_test/AST0112-FrameArgs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0112-FrameArgs/test.cfg b/testsuite/c_test/ast_test/AST0112-FrameArgs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..74b8e9d96364a7037ed38f8bc856eff370ea75be
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0112-FrameArgs/test.cfg
@@ -0,0 +1,2 @@
+compile(FrameArgs)
+run(FrameArgs)
diff --git a/testsuite/c_test/ast_test/AST0113-structEnum/expected.txt b/testsuite/c_test/ast_test/AST0113-structEnum/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0113-structEnum/structEnum.c b/testsuite/c_test/ast_test/AST0113-structEnum/structEnum.c
new file mode 100644
index 0000000000000000000000000000000000000000..dab28a5dc803515dfd31c4b25f9115e1114077d7
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0113-structEnum/structEnum.c
@@ -0,0 +1,18 @@
+enum Color {
+  RED,
+  GREEN,
+  BLUE,
+};
+
+typedef int X;
+
+struct Point {
+  enum Color color;
+  X x;
+} point;
+
+int main() {
+  point.color = GREEN;
+  point.x = 2;
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0113-structEnum/test.cfg b/testsuite/c_test/ast_test/AST0113-structEnum/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..de8c26fb8152ed962d9259526068129414162c40
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0113-structEnum/test.cfg
@@ -0,0 +1,2 @@
+compile(structEnum)
+run(structEnum)
diff --git a/testsuite/c_test/ast_test/AST0114-Charset/Charset.c b/testsuite/c_test/ast_test/AST0114-Charset/Charset.c
new file mode 100644
index 0000000000000000000000000000000000000000..4b5f9b352a3a5bc48fd3d1b34117e05e17a040f5
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0114-Charset/Charset.c
@@ -0,0 +1,15 @@
+#define NUM_CHARS (4)
+
+typedef unsigned int wchar_t;
+wchar_t utf_32_string[NUM_CHARS];
+
+char iso_8859_1_string[NUM_CHARS] = {'a', 'b', 'c', 'd'};
+
+
+int main() {
+  int i;
+  for (i = 0; i < NUM_CHARS; ++i)
+    utf_32_string[i] = iso_8859_1_string[i] & 0xff;
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0114-Charset/expected.txt b/testsuite/c_test/ast_test/AST0114-Charset/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0114-Charset/test.cfg b/testsuite/c_test/ast_test/AST0114-Charset/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a51affb7df35b41c8352c26b10b88d20c219892c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0114-Charset/test.cfg
@@ -0,0 +1,2 @@
+compile(Charset)
+run(Charset)
diff --git a/testsuite/c_test/ast_test/AST0115-FunctionType/FunctionType.c b/testsuite/c_test/ast_test/AST0115-FunctionType/FunctionType.c
new file mode 100644
index 0000000000000000000000000000000000000000..6ef02b9c2acf6939512be817b4af70c657f2230a
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0115-FunctionType/FunctionType.c
@@ -0,0 +1,7 @@
+typedef int (*func_type) (int (*) (int, float), float);
+func_type v_func_type;
+
+int main() {
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0115-FunctionType/expected.txt b/testsuite/c_test/ast_test/AST0115-FunctionType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0115-FunctionType/test.cfg b/testsuite/c_test/ast_test/AST0115-FunctionType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5b68ca72c728af4a642246eecff069276ad683f6
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0115-FunctionType/test.cfg
@@ -0,0 +1,2 @@
+compile(FunctionType)
+run(FunctionType)
diff --git a/testsuite/c_test/ast_test/AST0116-AnonymousEnum/AnonymousEnum.c b/testsuite/c_test/ast_test/AST0116-AnonymousEnum/AnonymousEnum.c
new file mode 100644
index 0000000000000000000000000000000000000000..68bd67165be99891558af89bd38292388d6e2b68
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0116-AnonymousEnum/AnonymousEnum.c
@@ -0,0 +1,13 @@
+
+enum {red, green, blue} primary;
+enum {chevy, ford} clunker;
+
+#undef FALSE
+#undef TRUE
+typedef enum {FALSE, TRUE} boolean;
+boolean v_boolean;
+
+int main() {
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0116-AnonymousEnum/expected.txt b/testsuite/c_test/ast_test/AST0116-AnonymousEnum/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0116-AnonymousEnum/test.cfg b/testsuite/c_test/ast_test/AST0116-AnonymousEnum/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0651db467eca1cfb8f83356a003bb5a66da7afc1
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0116-AnonymousEnum/test.cfg
@@ -0,0 +1,2 @@
+compile(AnonymousEnum)
+run(AnonymousEnum)
diff --git a/testsuite/c_test/ast_test/AST0117-ListFunction/ListFunction.c b/testsuite/c_test/ast_test/AST0117-ListFunction/ListFunction.c
new file mode 100644
index 0000000000000000000000000000000000000000..317f8bd56b96cbac9cbf57cc8956d819d533af42
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0117-ListFunction/ListFunction.c
@@ -0,0 +1,12 @@
+
+typedef int foo;
+
+foo intfoo (afoo)
+{
+  return (afoo * 2);
+}
+
+int main() {
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0117-ListFunction/expected.txt b/testsuite/c_test/ast_test/AST0117-ListFunction/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0117-ListFunction/test.cfg b/testsuite/c_test/ast_test/AST0117-ListFunction/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7f6cef17cf5fd33a555a74ee910aca0938468afc
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0117-ListFunction/test.cfg
@@ -0,0 +1,2 @@
+compile(ListFunction)
+run(ListFunction)
diff --git a/testsuite/c_test/ast_test/AST0118-TypedefFuncPointer/TypedefFuncPointer.c b/testsuite/c_test/ast_test/AST0118-TypedefFuncPointer/TypedefFuncPointer.c
new file mode 100644
index 0000000000000000000000000000000000000000..b42b2371805a1dd6754817ad041ac4be834b3b9e
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0118-TypedefFuncPointer/TypedefFuncPointer.c
@@ -0,0 +1,11 @@
+
+typedef int X;
+typedef int Y;
+
+typedef X (*pointer)(X *x, Y *y);
+pointer p;
+
+int main() {
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0118-TypedefFuncPointer/expected.txt b/testsuite/c_test/ast_test/AST0118-TypedefFuncPointer/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0118-TypedefFuncPointer/test.cfg b/testsuite/c_test/ast_test/AST0118-TypedefFuncPointer/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a8e4964289d37137a5959ccc9373f313e5783631
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0118-TypedefFuncPointer/test.cfg
@@ -0,0 +1,2 @@
+compile(TypedefFuncPointer)
+run(TypedefFuncPointer)
diff --git a/testsuite/c_test/ast_test/AST0119-LongChar/LongChar.c b/testsuite/c_test/ast_test/AST0119-LongChar/LongChar.c
new file mode 100644
index 0000000000000000000000000000000000000000..3dfe1cb964d9cfa93398c588fb54296c74bc1700
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0119-LongChar/LongChar.c
@@ -0,0 +1,24 @@
+void
+marker1 ()
+{
+
+}
+
+int main() {
+   struct {
+    char c[100];
+  } cbig;
+
+  struct {
+    long l[900];
+  } lbig;
+
+  cbig.c[0] = '\0';
+  cbig.c[99] = 'A';
+
+  lbig.l[333] = 999999999;
+  marker1 ();
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/AST0119-LongChar/expected.txt b/testsuite/c_test/ast_test/AST0119-LongChar/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0119-LongChar/test.cfg b/testsuite/c_test/ast_test/AST0119-LongChar/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7972ab03e04b6bb62e6525dc1e3f2c184bad5c2c
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0119-LongChar/test.cfg
@@ -0,0 +1,2 @@
+compile(LongChar)
+run(LongChar)
diff --git a/testsuite/c_test/ast_test/AST0120-StructSize/StructSize.c b/testsuite/c_test/ast_test/AST0120-StructSize/StructSize.c
new file mode 100644
index 0000000000000000000000000000000000000000..f9147f3cd92ca7c39582b1dd8ed4174e946ee644
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0120-StructSize/StructSize.c
@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <stdint.h>
+
+#pragma pack(push)
+#pragma pack(1)
+struct subFoo {
+  int16_t f0;
+  int8_t f1;
+  volatile uint8_t f2;
+};
+#pragma pack(pop)
+
+struct Foo1 {
+  volatile uint64_t f0;
+  struct subFoo f1;
+  uint32_t f2;
+  signed f3 : 22;
+  const uint32_t f4;
+  const struct subFoo f5;
+  int64_t f6;
+  volatile int16_t f7;
+} __attribute__ ((packed));
+
+#pragma pack(push)
+#pragma pack(2)
+struct Foo2 {
+  volatile uint64_t f0;
+  struct subFoo f1;
+  signed f2 : 15  __attribute__ ((packed)); 
+  signed f3 : 18  __attribute__ ((packed)); 
+  const uint32_t f4;
+  const struct subFoo f5;
+};
+#pragma pack(pop)
+
+struct Foo3 {
+  volatile uint64_t f0;
+  struct subFoo f1;
+  signed f2 : 18;
+  char f3 : 3;
+  const uint32_t f4;
+} __attribute__ ((packed));
+
+
+struct Foo1 s1[1][2] = {{{0x55D2D43A6B74DC4BLL, {0L, 0xF8L, 0xF9L}, 6UL, 544, 0xD114BA5AL, {0xD87EL, 0x2AL, 8UL}, 0x2BD476EEB3D548DBLL, 0xC3D8L},
+                         {0x55D2D43A6B74DC4BLL, {0L, 0xF8L, 0xF9L}, 6UL, 544, 0xD114BA5AL, {0xD87EL, 0x2AL, 8UL}, 0x2BD476EEB3D548DBLL, 0xC3D8L}}};
+struct Foo2 s2[1][2] = {{{0x55D2D43A6B74DC4BLL, {0L, 0xF8L, 0xF9L}, 0x7fff, 0x3ffff, 0xD114BA5AL, {0xD87EL, 0x2AL, 8UL}},
+                         {0x55D2D43A6B74DC4BLL, {0L, 0xF8L, 0xF9L}, 0x7fff, 0x3ffff, 0xD114BA5AL, {0xD87EL, 0x2AL, 8UL}}}};
+struct Foo3 s3[1][2] = {{{0x55D2D43A6B74DC4BLL, {0L, 0xF8L, 0xF9L}, 0x3ffff, -3, 0xD114BA5AL},
+                         {0x55D2D43A6B74DC4BLL, {0L, 0xF8L, 0xF9L}, 0x3ffff, -3, 0xD114BA5AL}}};
+int64_t *a = &s1[0][1].f6;
+int8_t *b = &s2[0][1].f5.f1;
+uint32_t *c = &s3[0][1].f4;
+
+int main() {
+  if (*a != s1[0][1].f6) {
+    printf("%lx\n", *a);
+    printf("%lx\n", s1[0][1].f6);	  
+    return 1;
+  }
+  if (*b != s2[0][1].f5.f1) {
+    printf("%x\n", *b);
+    printf("%x\n", s2[0][1].f5.f1);
+    return 1;
+  }
+  if (*c != s3[0][1].f4) {
+    printf("%ux\n", *c);
+    printf("%ux\n", s3[0][1].f4);
+    return 1;
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0120-StructSize/expected.txt b/testsuite/c_test/ast_test/AST0120-StructSize/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0120-StructSize/test.cfg b/testsuite/c_test/ast_test/AST0120-StructSize/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c9c1b47cb9febc4506f0388db274ca5ce7227ce6
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0120-StructSize/test.cfg
@@ -0,0 +1,2 @@
+compile(StructSize)
+run(StructSize)
diff --git a/testsuite/c_test/ast_test/AST0120-SyncBuiltInReturnType/expected.txt b/testsuite/c_test/ast_test/AST0120-SyncBuiltInReturnType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/ast_test/AST0120-SyncBuiltInReturnType/rettype.c b/testsuite/c_test/ast_test/AST0120-SyncBuiltInReturnType/rettype.c
new file mode 100644
index 0000000000000000000000000000000000000000..68bedf51260a70929b9702edd46f51a01155dc11
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0120-SyncBuiltInReturnType/rettype.c
@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+
+static unsigned short AI[16];
+static unsigned short init_qi[16] = { 3,5,7,9,0,0,0,0,0,0,0,0,0,0,0,0 };
+static unsigned short BI[16] = { 2,4,6,8,1,1,1,1,1,1,1,1,1,1,1,1};
+static unsigned short test_qi[16] = { 3,5,7,9,0,0,1,65535,0,1,1,1,65535,0,1,1 };
+
+int do_qi ()
+{
+  if (__sync_fetch_and_add(AI+6, BI[6]) != 0)
+    printf("AI[6]=%u\n",AI[6]);
+  if (__sync_fetch_and_sub(AI+7, BI[7]) != 0)
+    printf("AI[7]=%u\n",AI[7]);
+  if (__sync_fetch_and_and(AI+8, BI[8]) != 0)
+    printf("AI[8]=%u\n",AI[8]);
+  if (__sync_fetch_and_or(AI+9, BI[9]) != 0)
+    printf("AI[9]=%u\n",AI[9]);
+  if (__sync_fetch_and_xor(AI+10, BI[10]) != 0)
+    printf("AI[10]=%u\n",AI[10]);
+
+  if (__sync_add_and_fetch(AI+11, BI[11]) != 1)
+    printf("AI[11]=%u\n",AI[11]);
+  if (__sync_sub_and_fetch(AI+12, BI[12]) != 65535)
+    {
+        printf("AI[12]=%u\n",AI[12]);
+        printf("__sync_sub_and_fetch(AI+12, BI[12])=%u\n",__sync_sub_and_fetch(AI+12, BI[12]));
+    }
+  if (__sync_and_and_fetch(AI+13, BI[13]) != 0)
+    printf("AI[13]=%u\n",AI[13]);
+  if (__sync_or_and_fetch(AI+14, BI[14]) != 1)
+    printf("AI[14]=%u\n",AI[14]);
+  if (__sync_xor_and_fetch(AI+15, BI[15]) != 1)
+    printf("AI[15]=%u\n",AI[15]);
+
+    return 0;
+}
+
+
+int main()
+{
+  memcpy(AI, init_qi, sizeof(init_qi));
+
+  do_qi ();
+
+  if (memcmp (AI, test_qi, sizeof(test_qi)))
+    return 1;
+
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/AST0120-SyncBuiltInReturnType/test.cfg b/testsuite/c_test/ast_test/AST0120-SyncBuiltInReturnType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84f0a96ce4aa7fa1df813df725743affdf211cab
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0120-SyncBuiltInReturnType/test.cfg
@@ -0,0 +1,2 @@
+compile(rettype)
+run(rettype)
diff --git a/testsuite/c_test/ast_test/AST0121-TpyeAlias/HelloWorld.c b/testsuite/c_test/ast_test/AST0121-TpyeAlias/HelloWorld.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a79f7be0e60077ecea31d0849f365f9f73a89ca
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0121-TpyeAlias/HelloWorld.c
@@ -0,0 +1,47 @@
+typedef int foo;
+foo i = 33;
+enum Num {
+	ONE,
+	TWO,
+};
+enum Num b = ONE;
+
+struct A {
+  int a;
+  foo b;
+};
+struct A a = {1, 1};
+
+int main() {
+  if (i >2) {
+    typedef float foo;
+    struct A {
+      int c;
+      foo d;
+    };
+    foo f = 1.8;
+    struct A a = {1, 1.0};
+		enum Num {
+			THREE,
+		};
+    i += (int)f;
+		enum Num b = THREE;
+  } else {
+    typedef char foo;
+    foo c = 8;
+		enum Num {
+			FOUR,
+		};
+		enum Num b = FOUR;
+    i += c;
+  }
+	printf("%d\n", i);
+  return 0;
+}
+
+int test () {
+	struct AA {
+		int a;
+	};
+	
+}
diff --git a/testsuite/c_test/ast_test/AST0121-TpyeAlias/expected.txt b/testsuite/c_test/ast_test/AST0121-TpyeAlias/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a7873645902455c63d166fdcaa4b2fe565f6de7d
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0121-TpyeAlias/expected.txt
@@ -0,0 +1 @@
+34
diff --git a/testsuite/c_test/ast_test/AST0121-TpyeAlias/test.cfg b/testsuite/c_test/ast_test/AST0121-TpyeAlias/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/c_test/ast_test/AST0121-TpyeAlias/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/c_test/ast_test/issue-AST0061-NEON-Mpl/Mpl.c b/testsuite/c_test/ast_test/issue-AST0061-NEON-Mpl/Mpl.c
new file mode 100644
index 0000000000000000000000000000000000000000..d1bbc881fbbb06e49181e30fb0ca366007031492
--- /dev/null
+++ b/testsuite/c_test/ast_test/issue-AST0061-NEON-Mpl/Mpl.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+#include <arm_neon.h>
+
+// void print_float64x1(float64x1_t *a, int n) {
+//   float64_t *p = (float64_t *)a;
+//   int i;
+//   for (i = 0; i < n; i++) {
+//     printf("%f ", *(p+i));
+//   }
+//   printf("\n");
+// }
+
+// int main() {
+//   float64x1_t A = {2.2}, B = {4.4};
+//   float64x1_t C;
+//   C = __builtin_mpl_vector_merge_v1f64(A, B, 0);
+//   print_float64x1(&C,1);
+
+//   return 0;
+// }
+
+// int main() {
+//   int64x1_t A = {2};
+//   int64_t B;
+//   B = __builtin_mpl_vector_get_element_v1i64(A, 0);
+//   printf("%d", B);
+
+//   return 0;
+// }
+
+void print_int64x1(int64x1_t *a, int n) {
+  int64_t *p = (int64_t *)a;
+  int i;
+  for (i = 0; i < n; i++) {
+    printf("%d ", *(p+i));
+  }
+  printf("\n");
+}
+
+int main() {
+  int64x1_t A = {2};
+  A = __builtin_mpl_vector_set_element_v1i64(9, A, 0);
+  print_int64x1(&A, 1);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/ast_test/issue-AST0061-NEON-Mpl/expected.txt b/testsuite/c_test/ast_test/issue-AST0061-NEON-Mpl/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ec635144f60048986bc560c5576355344005e6e7
--- /dev/null
+++ b/testsuite/c_test/ast_test/issue-AST0061-NEON-Mpl/expected.txt
@@ -0,0 +1 @@
+9
diff --git a/testsuite/c_test/ast_test/issue-AST0061-NEON-Mpl/test.cfg b/testsuite/c_test/ast_test/issue-AST0061-NEON-Mpl/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5597db7c6e766990ed49d7fb360961577119eb30
--- /dev/null
+++ b/testsuite/c_test/ast_test/issue-AST0061-NEON-Mpl/test.cfg
@@ -0,0 +1,3 @@
+compile(Mpl)
+run(Mpl)
+
diff --git a/testsuite/c_test/ast_test/issue-AST0078-Atomic/Atomic.c b/testsuite/c_test/ast_test/issue-AST0078-Atomic/Atomic.c
new file mode 100644
index 0000000000000000000000000000000000000000..b79dafcb7f771b75b05fc80cd014dfa6b8c640cf
--- /dev/null
+++ b/testsuite/c_test/ast_test/issue-AST0078-Atomic/Atomic.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int x;
+  __atomic_store_n(&x, 10, 0);
+  int y = __atomic_load_n(&x, 0);
+  __atomic_add_fetch(&y, 1, 0);
+  printf("y = %d\n", y);
+
+  x = 11;
+  if (__atomic_compare_exchange_n(&y, &x, 12, 0, 0, 0)) {
+    printf("y = %d\n", y);
+    printf("x = %d\n", x);
+  }
+  __atomic_exchange_n(&y, 13, 0);
+  printf("y = %d\n", y);
+  return 0;
+}
diff --git a/testsuite/c_test/ast_test/issue-AST0078-Atomic/expected.txt b/testsuite/c_test/ast_test/issue-AST0078-Atomic/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..549db8d71b0fa76d7ab54ae7155e17fed8dec2d3
--- /dev/null
+++ b/testsuite/c_test/ast_test/issue-AST0078-Atomic/expected.txt
@@ -0,0 +1,4 @@
+y = 11
+y = 12
+x = 11
+y = 13
diff --git a/testsuite/c_test/ast_test/issue-AST0078-Atomic/test.cfg b/testsuite/c_test/ast_test/issue-AST0078-Atomic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2ec32d7745dfde471a9208f3414b5081e7d9d7d1
--- /dev/null
+++ b/testsuite/c_test/ast_test/issue-AST0078-Atomic/test.cfg
@@ -0,0 +1,2 @@
+compile(Atomic)
+run(Atomic)
diff --git a/testsuite/c_test/driver_test/DRIVER0001-helloworld/expected.txt b/testsuite/c_test/driver_test/DRIVER0001-helloworld/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3b18e512dba79e4c8300dd08aeb37f8e728b8dad
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0001-helloworld/expected.txt
@@ -0,0 +1 @@
+hello world
diff --git a/testsuite/c_test/driver_test/DRIVER0001-helloworld/main.c b/testsuite/c_test/driver_test/DRIVER0001-helloworld/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..2945166ca0c5014c6a9f1542c755e5958ea89179
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0001-helloworld/main.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main()
+{
+    printf("hello world\n");
+    return 0;
+}
+
diff --git a/testsuite/c_test/driver_test/DRIVER0001-helloworld/test.cfg b/testsuite/c_test/driver_test/DRIVER0001-helloworld/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1fccbbc6863837a6c3d43c3e9d0a527e8ddc2873
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0001-helloworld/test.cfg
@@ -0,0 +1,2 @@
+compile(APP=main.c,OPTION="--maple-toolchain --static")
+run(a)
diff --git a/testsuite/c_test/driver_test/DRIVER0002-double/expected.txt b/testsuite/c_test/driver_test/DRIVER0002-double/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bc31c08eeb94faff697db3e1cc7a002dac2aea01
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0002-double/expected.txt
@@ -0,0 +1,3 @@
+MAIN
+HELPER
+RES: 20
diff --git a/testsuite/c_test/driver_test/DRIVER0002-double/helper.c b/testsuite/c_test/driver_test/DRIVER0002-double/helper.c
new file mode 100644
index 0000000000000000000000000000000000000000..d7b676ce7cac71417de1fb1657ba33c5808b0f51
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0002-double/helper.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int helper(int in)
+{
+    printf("HELPER\n");
+    return in * 2;
+}
+
diff --git a/testsuite/c_test/driver_test/DRIVER0002-double/main.c b/testsuite/c_test/driver_test/DRIVER0002-double/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..d5e646be26da3cd70401bb4db4b9d7e2b66151e6
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0002-double/main.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int helper(int in);
+
+int main(void)
+{
+    printf("MAIN\n");
+    int res = helper(10);
+    printf("RES: %d\n", res);
+    return 0;
+}
+
diff --git a/testsuite/c_test/driver_test/DRIVER0002-double/test.cfg b/testsuite/c_test/driver_test/DRIVER0002-double/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7765ebde63d858a91b11ec34af62162c97398990
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0002-double/test.cfg
@@ -0,0 +1,2 @@
+compile(APP="main.c helper.c",OPTION="--maple-toolchain --static")
+run(a)
diff --git a/testsuite/c_test/driver_test/DRIVER0003-macro/expected.txt b/testsuite/c_test/driver_test/DRIVER0003-macro/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f57d321a226e10e8394403ecfbcc7483a1cc7559
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0003-macro/expected.txt
@@ -0,0 +1,4 @@
+TEST1
+HELPER TEST1
+RES: 40
+HELPER TEST2 10
diff --git a/testsuite/c_test/driver_test/DRIVER0003-macro/helper.c b/testsuite/c_test/driver_test/DRIVER0003-macro/helper.c
new file mode 100644
index 0000000000000000000000000000000000000000..9ad6a5b4e3a812f216c2f72a9881363ace0bfe3d
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0003-macro/helper.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int helper(int in)
+{
+#ifdef TEST1
+    printf("HELPER TEST1\n");
+#endif
+
+#ifdef TEST2
+    printf("HELPER TEST2\n");
+#endif
+
+    return in * 2;
+}
+
diff --git a/testsuite/c_test/driver_test/DRIVER0003-macro/main.c b/testsuite/c_test/driver_test/DRIVER0003-macro/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..c967a6db28d63a92c82220a204fc321fdc827da8
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0003-macro/main.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int helper(int in);
+
+int main(void)
+{
+#ifdef TEST1
+    printf("TEST1\n");
+#endif
+
+#ifdef TEST2
+    printf("TEST2\n");
+#endif
+
+    int res = helper(NUM);
+    printf("RES: %d\n", res);
+
+#ifdef TEST3
+    printf("HELPER TEST2 %d\n", EXTRANUM);
+#endif
+    return 0;
+}
diff --git a/testsuite/c_test/driver_test/DRIVER0003-macro/test.cfg b/testsuite/c_test/driver_test/DRIVER0003-macro/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6e3d22dfd1221bc8beab30192492ed3e193568a3
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0003-macro/test.cfg
@@ -0,0 +1,2 @@
+compile(APP="main.c helper.c",OPTION="--maple-toolchain --static -DTEST1 -DNUM=20 -DTEST2 -UTEST2 -D TEST3 -D EXTRANUM=10")
+run(a)
diff --git a/testsuite/c_test/driver_test/DRIVER0004-syslibs/expected.txt b/testsuite/c_test/driver_test/DRIVER0004-syslibs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9ecdb58fc1a576ae1ad044f3b5894eb604e44cdf
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0004-syslibs/expected.txt
@@ -0,0 +1 @@
+sqrt(1024.0) = 32.0
diff --git a/testsuite/c_test/driver_test/DRIVER0004-syslibs/main.c b/testsuite/c_test/driver_test/DRIVER0004-syslibs/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..cb346561e86d715d2b8fac47dc4e0b566b9ad987
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0004-syslibs/main.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <math.h>
+
+#define PI 3.14
+
+int main()
+{
+  double param, result;
+  param = 1024.0;
+  result = sqrt(param);
+
+  printf ("sqrt(%.1f) = %.1f\n", param, result );
+  return 0;
+}
diff --git a/testsuite/c_test/driver_test/DRIVER0004-syslibs/test.cfg b/testsuite/c_test/driver_test/DRIVER0004-syslibs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cbb6dea33f670663eab321bc35eded103291353c
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0004-syslibs/test.cfg
@@ -0,0 +1,2 @@
+compile(APP=main.c,OPTION="--maple-toolchain --static -lm")
+run(a)
diff --git a/testsuite/c_test/driver_test/DRIVER0005-ExtenToMovPattern_infinity_recursion_issue/expected.txt b/testsuite/c_test/driver_test/DRIVER0005-ExtenToMovPattern_infinity_recursion_issue/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d88e313699871a6c780316c8df7479aebe6999c0
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0005-ExtenToMovPattern_infinity_recursion_issue/expected.txt
@@ -0,0 +1 @@
+81
diff --git a/testsuite/c_test/driver_test/DRIVER0005-ExtenToMovPattern_infinity_recursion_issue/main.c b/testsuite/c_test/driver_test/DRIVER0005-ExtenToMovPattern_infinity_recursion_issue/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..16adfc143e2ef411fefa0657c978761160559ab9
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0005-ExtenToMovPattern_infinity_recursion_issue/main.c
@@ -0,0 +1,97 @@
+#include <stdio.h>
+
+typedef struct tag_TPara {
+    short item;
+    struct tag_TPara *pNext;
+} TPara;
+
+typedef struct _TControl {
+    TPara *globalParaList;
+} TControl;
+
+typedef struct tag_TType {
+    struct tag_TType *pLeft, *pRight;
+    unsigned char CmpntAttr;
+    unsigned short GlobalSwitch;
+    TControl *pControl;
+} TType;
+
+static unsigned char GetGlobalSwitch(TType *pType, unsigned short *pGlobalSwitch)
+{
+    unsigned short GlobalSwitch;
+    TPara *pPara = ((void *)0);
+
+    if (!pGlobalSwitch || !pType) {
+        return 0;
+    }
+    *pGlobalSwitch = 0;
+
+    GlobalSwitch = (unsigned short)pType->GlobalSwitch;
+
+    if (pType->pControl != ((void *)0)) {
+        for (pPara = pType->pControl->globalParaList; ((void *)0) != pPara; pPara = pPara->pNext) {
+            if (0==((unsigned char)(pPara->item))) {
+                GlobalSwitch |= 0x70;
+            } else {
+                GlobalSwitch |= 0x80;
+            }
+        }
+    }
+
+    *pGlobalSwitch = GlobalSwitch;
+    return 1;
+}
+
+static void SetGlobalSwitch(TType *pType, unsigned short GlobalSwitch)
+{
+    pType->GlobalSwitch = GlobalSwitch;
+    return;
+}
+
+static void GlobalSwitchCover(TType *pF)
+{
+    TType *p = ((void *)0);
+    unsigned short GlobalSwitch;
+
+    if (GetGlobalSwitch(pF, &GlobalSwitch) == 0) {
+        return;
+    }
+    SetGlobalSwitch(pF, GlobalSwitch);
+
+    for (p = pF->pLeft; ((void *)0) != p; p = p->pRight) {
+        if (p->CmpntAttr != 0) {
+            SetGlobalSwitch(p, GlobalSwitch);
+        }
+        GlobalSwitchCover(p);
+    }
+
+    return;
+}
+
+static void InitGlobalSwitch(void)
+{
+    TType tType;
+    TControl tControl;
+    TPara tPara;
+
+    tType.GlobalSwitch = 1;
+    tType.CmpntAttr = 10;
+    tType.pLeft = 0;
+    tType.pRight = 0;
+
+    tPara.item = 10;
+    tPara.pNext = 0;
+
+    tControl.globalParaList = &tPara;
+    tType.pControl = &tControl;
+
+    GlobalSwitchCover(&tType);
+    printf("%x\n", tType.GlobalSwitch);
+    return;
+}
+
+int main()
+{
+    InitGlobalSwitch();
+    return 0;
+}
diff --git a/testsuite/c_test/driver_test/DRIVER0005-ExtenToMovPattern_infinity_recursion_issue/test.cfg b/testsuite/c_test/driver_test/DRIVER0005-ExtenToMovPattern_infinity_recursion_issue/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d8a91f1030cde2f9d5241e3dec2d94f5bbec9136
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0005-ExtenToMovPattern_infinity_recursion_issue/test.cfg
@@ -0,0 +1,2 @@
+compile(APP=main.c,OPTION="--maple-toolchain --static -O2")
+run(a)
diff --git a/testsuite/c_test/driver_test/DRIVER0006-bswap/expected.txt b/testsuite/c_test/driver_test/DRIVER0006-bswap/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0de5aa64e863a600a2c9644afcffe65e73d92ed8
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0006-bswap/expected.txt
@@ -0,0 +1,6 @@
+12345678abcdef4
+f4debc8a67452301
+12345678
+78563412
+1234
+3412
diff --git a/testsuite/c_test/driver_test/DRIVER0006-bswap/main.c b/testsuite/c_test/driver_test/DRIVER0006-bswap/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..bd48d2ed9eb1258dc5db61f3fce6fbdadcfd8d2c
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0006-bswap/main.c
@@ -0,0 +1,19 @@
+#include <stdint.h>
+#include <stdio.h>
+
+int main(void) {
+    uint64_t data64 = 0x012345678abcdef4;
+    printf("%lx\n", data64);
+    uint64_t res64 = __builtin_bswap64(data64);
+    printf("%lx\n", res64);
+
+    uint32_t data32 = 0x012345678;
+    printf("%x\n", data32);
+    uint32_t res32 = __builtin_bswap32(data32);
+    printf("%x\n", res32);
+
+    uint16_t data16 = 0x1234;
+    printf("%hx\n", data16);
+    uint16_t res16 = __builtin_bswap16(data16);
+    printf("%hx\n", res16);
+}
\ No newline at end of file
diff --git a/testsuite/c_test/driver_test/DRIVER0006-bswap/test.cfg b/testsuite/c_test/driver_test/DRIVER0006-bswap/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1fccbbc6863837a6c3d43c3e9d0a527e8ddc2873
--- /dev/null
+++ b/testsuite/c_test/driver_test/DRIVER0006-bswap/test.cfg
@@ -0,0 +1,2 @@
+compile(APP=main.c,OPTION="--maple-toolchain --static")
+run(a)
diff --git a/testsuite/c_test/enhancec_test/ENC0001-nonnull_check_insert/expected.txt b/testsuite/c_test/enhancec_test/ENC0001-nonnull_check_insert/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..681a89e0a8c84704a1d3cc38ef84db4169377d84
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0001-nonnull_check_insert/expected.txt
@@ -0,0 +1,2 @@
+*p=1, *p1=1
+*(q->a->i)=1
diff --git a/testsuite/c_test/enhancec_test/ENC0001-nonnull_check_insert/nonnull_check_insert.c b/testsuite/c_test/enhancec_test/ENC0001-nonnull_check_insert/nonnull_check_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..0d55f1faf1474032b178498eb4c0d03cb3810e7a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0001-nonnull_check_insert/nonnull_check_insert.c
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/ENC0001-nonnull_check_insert/nonnull_check_insert.c"
+
+#include <stdio.h>
+
+struct A {
+  int *i;
+};
+
+struct B {
+  struct A *a;
+};
+
+
+__attribute__((returns_nonnull, nonnull))
+int *getNonnullPtr(int *ptr) {
+  return ptr;
+}
+
+int *getNullablePtr(int *ptr) {
+ return ptr;
+}
+
+
+__attribute__((nonnull))
+void foo(int a, int *p, struct B *q) {
+  int *p1;
+  // pointer assignment
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: assertnonnull (dread ptr %p)
+  p1 = p;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertnonnull <&foo> (dread ptr %p1_{{.*}}
+  p = p1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK-NOT: assertnonnull (dread ptr %q)
+  // CHECK-NEXT: assertnonnull <&foo> (iread ptr <* <$B>> 1 (dread ptr %q))
+  // CHECK: assignassertnonnull <&foo> (iread ptr <* <$A>> 1 (iread ptr <* <$B>> 1 (dread ptr %q)))
+  p = q->a->i;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK-NEXT: callassertnonnull <&getNonnullPtr, 0, &foo> (dread ptr %p1_{{.*}}
+  // CHECK: callassigned &getNonnullPtr{{.*}}
+  // CHECK-NOT: assertnonnull <&foo> (dread ptr %retVar_{{.*}}
+  p = getNonnullPtr(p1);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK-NEXT: callassigned &getNullablePtr{{.*}}
+  // CHECK: assertnonnull <&foo> (dread ptr %retVar_{{.*}}
+  p = getNullablePtr(p1);
+
+  // *ptr
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertnonnull <&foo> (dread ptr %p1_{{.*}}
+  printf("*p=%d, *p1=%d\n", *p, *p1);
+
+  // ptr->a
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK-NOT: assertnonnull (dread ptr %q)
+  // CHECK-NEXT: assertnonnull <&foo> (iread ptr <* <$B>> 1 (dread ptr %q))
+  // CHECK: assertnonnull <&foo> (iread ptr <* <$A>> 1 (iread ptr <* <$B>> 1 (dread ptr %q)))
+  printf("*(q->a->i)=%d\n", *(q->a->i));
+}
+
+int main() {
+  int a = 1;
+  int *p = &a;
+
+  struct A aa;
+  struct B bb;
+  struct B *q = &bb;
+  q->a = &aa;
+  q->a->i = p;
+
+  // pointer caller
+  foo(1, p, q);
+
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0001-nonnull_check_insert/test.cfg b/testsuite/c_test/enhancec_test/ENC0001-nonnull_check_insert/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d6695eb47e0335b318ea6f0f391f4dee4853ed73
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0001-nonnull_check_insert/test.cfg
@@ -0,0 +1,17 @@
+ENCO2_N_D:
+compile(nonnull_check_insert)
+run(nonnull_check_insert)
+cat nonnull_check_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="assertnonnull"  --result=nonnull_check_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of nullable pointer"  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nullable pointer assignment of nonnull pointer"  --result=compile.log
+ENCO2_N_D_ALL:
+compile(nonnull_check_insert)
+run(nonnull_check_insert)
+cat nonnull_check_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=2 --str="assertnonnull"  --result=nonnull_check_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of nullable pointer"  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nullable pointer assignment of nonnull pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_insert)
+run(nonnull_check_insert)
diff --git a/testsuite/c_test/enhancec_test/ENC0002-nonnull_return_check_insert/expected.txt b/testsuite/c_test/enhancec_test/ENC0002-nonnull_return_check_insert/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0002-nonnull_return_check_insert/nonnull_return_check_insert.c b/testsuite/c_test/enhancec_test/ENC0002-nonnull_return_check_insert/nonnull_return_check_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..7fdced289d5c3645744edfec89257eeca48b770d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0002-nonnull_return_check_insert/nonnull_return_check_insert.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_return_check_insert.c"
+
+#include <stdio.h>
+
+__attribute__((returns_nonnull, nonnull))
+int *getNonnullPtr(int *ptr) {
+  return ptr;
+}
+
+int *getNullablePtr(int *ptr) {
+ return ptr;
+}
+
+__attribute__((returns_nonnull))
+int* test(int i) {
+  int *ptr = &i;
+  if (i) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+    // CHECK-NEXT: callassertnonnull <&getNonnullPtr, 0, &test> (dread ptr %ptr_{{.*}}
+    // CHECK: callassigned &getNonnullPtr{{.*}}
+    // CHECK-NOT: assertnonnull (dread ptr %retVar_{{.*}}
+    return getNonnullPtr(ptr);
+  } else {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+    // CHECK-NEXT: callassigned &getNullablePtr{{.*}}
+    // CHECK: returnassertnonnull <&test> (dread ptr %retVar_{{.*}}
+    return getNullablePtr(ptr);
+  }
+}
+
+int main() {
+ int *i = test(1);
+ return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0002-nonnull_return_check_insert/test.cfg b/testsuite/c_test/enhancec_test/ENC0002-nonnull_return_check_insert/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2fd43e6d12eaf24e3e64b50d57abe0c24f8d129c
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0002-nonnull_return_check_insert/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_return_check_insert)
+run(nonnull_return_check_insert)
+cat nonnull_return_check_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_return_check_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertnonnull"  --result=nonnull_return_check_insert.me.mpl
+ENCO2_B_D:
+compile(nonnull_return_check_insert)
+run(nonnull_return_check_insert)
diff --git a/testsuite/c_test/enhancec_test/ENC0003-nonnull_check_cast/expected.txt b/testsuite/c_test/enhancec_test/ENC0003-nonnull_check_cast/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0003-nonnull_check_cast/nonnull_check_cast.c b/testsuite/c_test/enhancec_test/ENC0003-nonnull_check_cast/nonnull_check_cast.c
new file mode 100644
index 0000000000000000000000000000000000000000..841b56093692fe7c8a61b03efb20926509855260
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0003-nonnull_check_cast/nonnull_check_cast.c
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_cast.c"
+
+// expected-no-warning
+
+#include <stddef.h>
+
+struct Foo {
+  unsigned int a;
+};
+
+int foo(void *f) {
+  if (f == NULL)
+    return 0;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertnonnull <&foo> (dread ptr %f)
+  if (((struct Foo *)f)->a > 0)
+    return 1;
+
+  return -1;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0003-nonnull_check_cast/test.cfg b/testsuite/c_test/enhancec_test/ENC0003-nonnull_check_cast/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a044105d3d0d5638126a12ff26639a5aaad1198c
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0003-nonnull_check_cast/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_check_cast)
+run(nonnull_check_cast)
+cat nonnull_check_cast.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_cast.c
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertnonnull"  --result=nonnull_check_cast.me.mpl
+ENCO2_B_D:
+compile(nonnull_check_cast)
+run(nonnull_check_cast)
diff --git a/testsuite/c_test/enhancec_test/ENC0004-nonnull_check_if/expected.txt b/testsuite/c_test/enhancec_test/ENC0004-nonnull_check_if/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0004-nonnull_check_if/nonnull_check_if.c b/testsuite/c_test/enhancec_test/ENC0004-nonnull_check_if/nonnull_check_if.c
new file mode 100644
index 0000000000000000000000000000000000000000..2b7446a350a1cf1562883b6d86028e32e92e1456
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0004-nonnull_check_if/nonnull_check_if.c
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if.c"
+
+// expected-no-warning
+#include <stddef.h>
+
+/* check if */
+int test1(int *x) {
+  if (x != NULL) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertnonnull <&test1> (dread ptr %x)
+    return *x;
+  }
+  return 0;
+}
+
+int test2(int *x) {
+  if (x == NULL) {
+    return 0;
+  } else {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertnonnull <&test2> (dread ptr %x)
+    return *x;
+  }
+}
+
+int test3(int *x) {
+  if (!x) {
+    return 0;
+  }
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertnonnull <&test3> (dread ptr %x)
+  return *x;
+}
+
+/*  check if or */
+int test4(int *a, int *b) {
+  if (a == NULL || b == NULL) {
+    return 0;
+  } else {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+    // CHECK-NEXT: assertnonnull <&test4> (dread ptr %a)
+    // CHECK: assertnonnull <&test4> (dread ptr %b)
+    return *a + *b;
+  }
+}
+
+/* chenck if and */
+int test5(int *a, int b) {
+  if (a != NULL && b > 0) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertnonnull <&test5> (dread ptr %a)
+    return *a + b;
+  }
+  return b;
+}
+
+/* check if nested */
+int test6(int *x, int b) {
+  if (x != NULL) {
+    if (b > 0) {
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK-NEXT: assertnonnull <&test6> (dread ptr %x)
+      return *x + b;
+    }
+  }
+  return 0;
+}
+
+/* check multi_if */
+int *bar(int *b) {
+  return b;
+}
+
+int test7(int *a) {
+  int *b;
+  if (a == NULL) return 0;
+
+  b = bar(b);
+
+  if (b == NULL) return 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK-NEXT: assertnonnull <&test7> (dread ptr %a)
+  // CHECK: assertnonnull <&test7> (dread ptr %b{{.*}}
+  return *a + *b;
+}
+
+
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0004-nonnull_check_if/test.cfg b/testsuite/c_test/enhancec_test/ENC0004-nonnull_check_if/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0cd500bc49605e3e28d9bf9e589000bcb9069308
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0004-nonnull_check_if/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_check_if)
+run(nonnull_check_if)
+cat nonnull_check_if.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_if.c
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertnonnull"  --result=nonnull_check_if.me.mpl
+ENCO2_B_D:
+compile(nonnull_check_if)
+run(nonnull_check_if)
diff --git a/testsuite/c_test/enhancec_test/ENC0006-nonnull_check_ternary/expected.txt b/testsuite/c_test/enhancec_test/ENC0006-nonnull_check_ternary/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0006-nonnull_check_ternary/nonnull_check_ternary.c b/testsuite/c_test/enhancec_test/ENC0006-nonnull_check_ternary/nonnull_check_ternary.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9d7219e541d12c47354eb4ea7c2d79e61549b11
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0006-nonnull_check_ternary/nonnull_check_ternary.c
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_ternary.c"
+
+// expected-no-warning
+#include <stddef.h>
+int test2(int *a, int b) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertnonnull <&test2> (dread ptr %a)
+  return (a != NULL) ? *a : b;
+}
+
+int test4(int *a, int b) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertnonnull <&test4> (dread ptr %a)
+  return (a == NULL) ? b : *a;
+}
+
+int test5(int *x, int *y) __attribute__((nonnull(2))) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertnonnull <&test5> (dread ptr %x)
+  return ( (x != NULL) ? (*x > 0) : (*y == 0) );
+}
+
+int test6(int *p, int *q) __attribute__((nonnull(2))) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertnonnull <&test6> (dread ptr %levVar{{.*}}
+  return *((p != NULL) ? p : q);
+}
+
+int *test7(int *p, int *q) __attribute__((nonnull(2), returns_nonnull)) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: returnassertnonnull <&test7> (dread ptr %levVar{{.*}}
+  return (p != NULL) ? p : q;
+}
+
+int test8(int a, int *p, int *q) __attribute__((nonnull)) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertnonnull <&test8> (dread ptr %levVar{{.*}}
+  return *(a ? p : q);
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0006-nonnull_check_ternary/test.cfg b/testsuite/c_test/enhancec_test/ENC0006-nonnull_check_ternary/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..57d61096738315be7f7794163b51603f138c47a4
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0006-nonnull_check_ternary/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_check_ternary)
+run(nonnull_check_ternary)
+cat nonnull_check_ternary.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_ternary.c
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertnonnull"  --result=nonnull_check_ternary.me.mpl
+ENCO2_B_D:
+compile(nonnull_check_ternary)
+run(nonnull_check_ternary)
diff --git a/testsuite/c_test/enhancec_test/ENC0008-nonnull_check_call/expected.txt b/testsuite/c_test/enhancec_test/ENC0008-nonnull_check_call/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0008-nonnull_check_call/nonnull_check_call.c b/testsuite/c_test/enhancec_test/ENC0008-nonnull_check_call/nonnull_check_call.c
new file mode 100644
index 0000000000000000000000000000000000000000..0391565783f8dbce32c845f9339aa4e047d4cae8
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0008-nonnull_check_call/nonnull_check_call.c
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_call.c"
+
+#include <stddef.h>
+void foo_nullable(int *a) {
+  return;
+}
+void foo_nonnull(int *a) __attribute__((nonnull)) {
+  return;
+}
+
+void call(int *a, int *b) __attribute__((nonnull(2))) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: assertnonnull (dread ptr %a)
+  foo_nullable(a);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: callassertnonnull <&foo_nonnull, 0, &call> (dread ptr %a)
+  foo_nonnull(a); // expected-warning
+  if (a) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: callassertnonnull <&foo_nonnull, 0, &call> (dread ptr %a)
+    foo_nonnull(a);
+  }
+  foo_nullable(b);
+  foo_nonnull(b);
+
+  int x;
+  foo_nullable(&x);
+  foo_nonnull(&x);
+
+  int *c = a;
+  foo_nullable(c);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: callassertnonnull <&foo_nonnull, 0, &call> (dread ptr %c{{.*}}
+  foo_nonnull(c); // expected-warning
+
+  int *d = b;
+  foo_nullable(d);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: callassertnonnull <&foo_nonnull, 0, &call> (dread ptr %d{{.*}}
+  foo_nonnull(d);
+
+  int *e = &x;
+  foo_nullable(e);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: callassertnonnull <&foo_nonnull, 0, &call> (dread ptr %e{{.*}}
+  foo_nonnull(e);
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0008-nonnull_check_call/test.cfg b/testsuite/c_test/enhancec_test/ENC0008-nonnull_check_call/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..205df47376f28095ff65b1544fe2e12c937504f5
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0008-nonnull_check_call/test.cfg
@@ -0,0 +1,9 @@
+ENCO2_N_D:
+compile(nonnull_check_call)
+run(nonnull_check_call)
+cat nonnull_check_call.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_call.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="callassertnonnull"  --result=nonnull_check_call.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nullable pointer passed to foo_nonnull that requires nonnull for 1st argument"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_call)
+run(nonnull_check_call)
diff --git a/testsuite/c_test/enhancec_test/ENC0009-nonnull_check_assign/expected.txt b/testsuite/c_test/enhancec_test/ENC0009-nonnull_check_assign/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0009-nonnull_check_assign/nonnull_check_assign.c b/testsuite/c_test/enhancec_test/ENC0009-nonnull_check_assign/nonnull_check_assign.c
new file mode 100644
index 0000000000000000000000000000000000000000..3fe8908063022fd42c59955c3bcb026076fa29d6
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0009-nonnull_check_assign/nonnull_check_assign.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_assign.c"
+
+#include <stddef.h>
+#include <stdio.h>
+
+void foo() {
+  int *data;
+  int tmp = 5;
+  data = &tmp;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertnonnull <&foo> (dread ptr %data{{.*}}
+  printf("%d", *data);
+
+  int **p2;
+  p2 = &data;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertnonnull <&foo> (dread ptr %p2{{.*}}
+  printf("%d", **p2);  // The nested pointer is temporarily not checked
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0009-nonnull_check_assign/test.cfg b/testsuite/c_test/enhancec_test/ENC0009-nonnull_check_assign/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..177f3cb5c14721c38313ffa32a4d7b4937a4c953
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0009-nonnull_check_assign/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_check_assign)
+run(nonnull_check_assign)
+cat nonnull_check_assign.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_assign.c
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertnonnull"  --result=nonnull_check_assign.me.mpl
+ENCO2_B_D:
+compile(nonnull_check_assign)
+run(nonnull_check_assign)
diff --git a/testsuite/c_test/enhancec_test/ENC0010-nonnull_check_opt/expected.txt b/testsuite/c_test/enhancec_test/ENC0010-nonnull_check_opt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0480aa8181fdcb7169e11b5f6177304f79ab7f23
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0010-nonnull_check_opt/expected.txt
@@ -0,0 +1,6 @@
+1
+*arg1=2 2
+*arg1=1 *arg2=2 3
+11
+47
+102
diff --git a/testsuite/c_test/enhancec_test/ENC0010-nonnull_check_opt/nonnull_check_insert.c b/testsuite/c_test/enhancec_test/ENC0010-nonnull_check_opt/nonnull_check_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..5faef86186bc77ce839bad0f6c7b08ece6d3a34b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0010-nonnull_check_opt/nonnull_check_insert.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+struct A {
+  int *i;
+};
+
+struct B {
+  struct A *a;
+};
+
+
+__attribute__((returns_nonnull, nonnull))
+int *testReturnPtr(int *ptr) {
+  for (int i = 0; i < 10; ++i) {
+    *ptr += i;
+  }
+  return ptr;
+}
+
+int test1(int *arg1, int *arg2) {
+  if (arg1 == NULL) {
+    return 1;
+  }
+  printf("*arg1=%d ", *arg1);
+  if (arg2 == NULL) {
+    return 2;
+  }
+  printf("*arg2=%d ", *arg2);
+  return 3;
+}
+
+int test2(int *arg1) {
+  int a = *arg1;
+  for (int i = 0; i < 10; ++i) {
+    a += *arg1;
+  }
+  return a;
+}
+
+void test3(int *arg1) {
+  if (arg1 != NULL) {
+    int *temp = testReturnPtr(arg1);
+    for (int i = 0; i < 10; ++i) {
+      (*temp)++;
+    }
+    printf("%d\n", *temp);
+  }
+}
+
+int main() {
+  int a = 1;
+  int *p = &a;
+  int b = 2;
+  int *q = &b;
+  printf("%d\n", test1(NULL, p));
+  printf("%d\n", test1(q, NULL));
+  printf("%d\n", test1(p, q));
+
+  printf("%d\n", test2(p));
+  printf("%d\n", *testReturnPtr(q));
+  test3(q);
+
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0010-nonnull_check_opt/test.cfg b/testsuite/c_test/enhancec_test/ENC0010-nonnull_check_opt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3f74b9125dfdbc19510bbe80558f5c12b6da36c
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0010-nonnull_check_opt/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_check_insert)
+run(nonnull_check_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertnonnull"  --result=nonnull_check_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="Dereference of nullable pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_insert)
+run(nonnull_check_insert)
diff --git a/testsuite/c_test/enhancec_test/ENC0011-boundary_count_insert/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0011-boundary_count_insert/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..06c5f0b8c5b906dae786d65b1b4f58039a406291
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0011-boundary_count_insert/boundary_count_insert.c
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_insert.c"
+
+#include <stdio.h>
+
+struct A {
+  int *i;
+};
+
+struct B {
+  struct A *a;
+};
+
+// Lack of attribute parameters means that only one pointer parameter is implicitly marked as boundary var in func.
+__attribute__((count("len")))
+void foo1(int len, int *p) {
+ // CHECK: dassign %_boundary.p.lower 0 (dread ptr %p)
+ // CHECK: LOC [[# FILENUM]] [[# @LINE + 1 ]]
+ return;
+}
+
+__attribute__((count("len", 2, 3)))
+void foo(int len, int *p, struct B *q) {
+  // The boundary assignment: l-value with or without a boundary, r-value with a boundary
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK: assertge{{.*}}
+  // CHECK: dassign %_boundary.p1{{.*}}.0.[[# IDX_P1:]].upper 0 (dread ptr %_boundary.p.upper)
+  int *p1 = len + p - 3 + 1;  //pointer computed assignment
+  if (1) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertge{{.*}}
+    printf("%d\n", p[1]);
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertge{{.*}}
+    printf("%d\n", *(p+1));
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NOT: assertge{{.*}}
+    printf("%d\n", q->a->i[1]);
+    // The boundary assignment and inserting undef r-value boundary: l-value with a boundary, the r-value without a boundary
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+    // CHECK-NOT: assertge{{.*}}
+    // CHECK: dassign %_boundary.p1{{.*}}.0.[[# IDX_P1]].upper 0 ({{.*}}
+    p1 = q->a->i;
+    p1 = p;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertge{{.*}}
+    printf("%d\n", p1[0]);
+  } else {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+    // CHECK-NOT: assertge{{.*}}
+    // CHECK: dassign %_boundary.A_i.[[# IDX_I:]].upper  0 (dread ptr %_boundary.{{.*}}.0.[[# IDX_P1:]].upper
+    q->a->i = p1;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertge{{.*}}
+    printf("%d\n", q->a->i[0]);
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertge{{.*}}
+    printf("%d\n", *(q->a->i+1));
+  }
+  struct A aa;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK-NOT: assertge{{.*}}
+  // CHECK: dassign %_boundary.aa{{.*}}.1.[[# IDX_aa:]].upper 0 (dread ptr %_boundary.p.upper)
+  aa.i = p;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK-NOT: assertge{{.*}}
+  // CHECK: dassign %_boundary.p1{{.*}}.0.[[# IDX_P1]].upper 0 (dread ptr %_boundary.aa{{.*}}.1.[[# IDX_aa]].upper)
+  p1 = aa.i;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(aa.i+2));
+}
+
+int main() {
+  int a[5] = {1, 2, 3, 4, 5};
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %_boundary.pa{{.*}}.upper 0 (add ptr (addrof ptr %a{{.*}}
+  int *pa = a;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK: assertge{{.*}}
+  // CHECK: dassign %_boundary.pa1{{.*}}.upper 0 (add ptr (addrof ptr %a{{.*}}
+  int *pa1 = a + 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(pa+2));
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", pa1[2]);
+  struct A aa;
+  struct B bb[5];
+  struct B *q = bb;
+  q->a = &aa;
+  q->a->i = pa;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK: callassertle{{.*}}
+  // CHECK: callassertle{{.*}}
+  foo(5, pa, q);
+
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0011-boundary_count_insert/expected.txt b/testsuite/c_test/enhancec_test/ENC0011-boundary_count_insert/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..077606edad9874c34ede2a534ed02e9efda5eb49
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0011-boundary_count_insert/expected.txt
@@ -0,0 +1,7 @@
+3
+4
+2
+2
+2
+1
+3
diff --git a/testsuite/c_test/enhancec_test/ENC0011-boundary_count_insert/test.cfg b/testsuite/c_test/enhancec_test/ENC0011-boundary_count_insert/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b929f56bda444155b4c405a81a38a63b6ea0f5bc
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0011-boundary_count_insert/test.cfg
@@ -0,0 +1,11 @@
+ENCO2_N_D:
+compile(boundary_count_insert)
+run(boundary_count_insert)
+ENCO2_B_D:
+compile(boundary_count_insert)
+run(boundary_count_insert)
+cat boundary_count_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertge"  --result=boundary_count_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=3 --str="assertlt"  --result=boundary_count_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="can't prove the pointer >= the lower bounds"  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=3 --str="can't prove the pointer < the upper bounds"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0012-boundary_count_return_insert/boundary_count_return_insert.c b/testsuite/c_test/enhancec_test/ENC0012-boundary_count_return_insert/boundary_count_return_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..097227a4711a9f037af6dd4c72c9b24f3f9bf518
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0012-boundary_count_return_insert/boundary_count_return_insert.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_return_insert.c"
+
+#include <stdio.h>
+
+__attribute__((returns_count("len"))) __attribute__((count("len", 1)))
+int *getBoundaryPtr(int *ptr, int len) {
+  ++len;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertle{{.*}}
+  return ptr;
+}
+
+int *getPtr(int *ptr) {
+ return ptr + 1;
+}
+
+struct A {
+  int *i;
+};
+
+struct B {
+  struct A *a;
+};
+
+int main() {
+  int a[5] = {1, 2, 3, 4, 5};
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK: assertle{{.*}}
+  // CHECK: dassign %_boundary.retVar{{.*}}.lower 0 (dread ptr %retVar{{.*}}
+  // CHECK: dassign %_boundary.pa{{.*}}.lower 0 (dread ptr %_boundary.retVar{{.*}}.lower
+  int *pa = getBoundaryPtr(a, 4);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 5 ]]
+  // CHECK: assertle{{.*}}
+  // CHECK: dassign %_boundary.retVar{{.*}}.lower 0 (dread ptr %retVar{{.*}}
+  // CHECK: assertge{{.*}}
+  // CHECK: dassign %_boundary.pa1{{.*}}.lower 0 (dread ptr %_boundary.retVar{{.*}}.lower
+  int *pa1 = getBoundaryPtr(a, 4) + 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(pa+2));
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", pa1[2]);
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: dassign %_boundary.pa2{{.*}}.lower{{.*}}
+  int *pa2 = getPtr(a);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: assertge{{.*}}
+  printf("%d\n", pa2[2]);
+
+  struct A aa;
+  struct B bb[4];
+  struct B *q = bb;
+  q->a = &aa;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK: assertle{{.*}}
+  // CHECK: dassign %_boundary.retVar{{.*}}.lower 0 (dread ptr %retVar{{.*}}
+  // CHECK: dassign %_boundary.A_i{{.*}}.lower 0 (dread ptr %_boundary.retVar{{.*}}.lower
+  q->a->i = getBoundaryPtr(a + 1, 4);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", q->a->i[3]);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0012-boundary_count_return_insert/expected.txt b/testsuite/c_test/enhancec_test/ENC0012-boundary_count_return_insert/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4155178d2cdf55fe7177b8338ee7acc04a6066b5
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0012-boundary_count_return_insert/expected.txt
@@ -0,0 +1,4 @@
+3
+4
+4
+5
diff --git a/testsuite/c_test/enhancec_test/ENC0012-boundary_count_return_insert/test.cfg b/testsuite/c_test/enhancec_test/ENC0012-boundary_count_return_insert/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b3588419836c7c5073b5cf1b1208677b36fa29b5
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0012-boundary_count_return_insert/test.cfg
@@ -0,0 +1,11 @@
+ENCO2_N_D:
+compile(boundary_count_return_insert)
+run(boundary_count_return_insert)
+ENCO2_B_D:
+compile(boundary_count_return_insert)
+run(boundary_count_return_insert)
+cat boundary_count_return_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_return_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertlt"  --result=boundary_count_return_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="returnassertle"  --result=boundary_count_return_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="the offset >= the upper bounds"  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="can't prove return value's bounds match the function declaration for getBoundaryPtrOutRange"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0013-boundary_count_array_insert/boundary_count_array_insert.c b/testsuite/c_test/enhancec_test/ENC0013-boundary_count_array_insert/boundary_count_array_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..6e150eee153f5e4e1edb372a6de434210c417890
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0013-boundary_count_array_insert/boundary_count_array_insert.c
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_array_insert.c"
+
+struct A {
+  int info[5];
+  short s;
+};
+
+int foo (int a, int b, int c, int d) {
+  return a + b + c + d;
+}
+
+__attribute__((count(5, 1)))
+int test (int *mac, int) {
+	// CHECK: LOC [[# FILENUM]] [[# @LINE + 5 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  // CHECK: assertge{{.*}}
+  // CHECK: assertge{{.*}}
+  // CHECK: assertge{{.*}}
+	return foo(mac[0], mac[1], mac[2], mac[3]);
+}
+
+__attribute__((count(5, 1)))
+int test1 (int *mac, int) {
+	// CHECK: LOC [[# FILENUM]] [[# @LINE + 5 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  // CHECK: assertge{{.*}}
+  // CHECK: assertge{{.*}}
+  // CHECK: assertge{{.*}}
+	return foo(*mac, *(mac + 1), *(mac + 2), *(mac + 3));
+}
+
+#include <stdio.h>
+int main() {
+  int a[5] = {1, 2, 3, 4, 5};
+  int i = 1;
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  printf("%d\n", a[2]);  // checking in constant subscript
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", a[i]);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(a + 2));
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %_boundary.pa{{.*}}.upper 0 (add ptr (addrof ptr %a{{.*}}
+  int *pa = a;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK: assertge{{.*}}
+  // CHECK: dassign %_boundary.pa1{{.*}}.upper 0 (add ptr (addrof ptr %a{{.*}}
+  int *pa1 = a + 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(pa+2));
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", pa1[2]);
+
+  int b[3][2] = {{1,2},{3,4},{5,6}};
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  printf("%d\n", b[2][1]);  // checking in constant subscript
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", b[i][1]);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(*(b + 2) + 1));
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %_boundary.pb{{.*}}.upper 0 (add ptr (addrof ptr %b{{.*}}
+  int (*pb)[2] = b;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(*(pb + 2) + 1));
+
+  int c[4][3][2] = {{{1,2},{3,4},{5,6}},{{1,2},{3,4},{5,6}},{{1,2},{3,4},{5,6}},{{1,2},{3,4},{5,6}}};
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  printf("%d\n", c[3][2][1]);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", c[i][2][1]);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(*(*(c + 3) + 2) + 1));
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %_boundary.pc{{.*}}.upper 0 (add ptr (addrof ptr %c{{.*}}
+  int (*pc)[3][2] = c;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(*(*(pc + 3) + 2) + 1));
+
+  /* addrof array/sub-array */
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  // CHECK: dassign %_boundary.x{{.*}}.lower 0  (addrof ptr %a{{.*}}
+  int *x = &a[i];  // i = 1
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(x - 1));  // a[0]
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  // CHECK: dassign %_boundary.y{{.*}}.lower 0  (addrof ptr %c{{.*}}
+  int *y = &c[i][2][1];
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(y - 11));  // c[0][0][0]
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  // CHECK: assertge{{.*}}
+  // CHECK: dassign %_boundary.z{{.*}}.lower 0  (addrof ptr %c{{.*}}
+  int *z = c[i][2] + 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(z - 11));  // c[0][0][0]
+
+  /* array of struct */
+  struct A aa = {{1,2,3,4,5}, 1};
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(aa.info + 2));
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", aa.info[i]);
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK: assertge{{.*}}
+  // CHECK: dassign %_boundary.pinfo{{.*}}.lower 0  (addrof ptr %aa{{.*}} 1)
+  int *pinfo = aa.info + 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", pinfo[2]);
+
+  struct A *paa = &aa;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", paa->info[i]);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0013-boundary_count_array_insert/expected.txt b/testsuite/c_test/enhancec_test/ENC0013-boundary_count_array_insert/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..91a6ba672254fec592e26358a30a922b687ef637
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0013-boundary_count_array_insert/expected.txt
@@ -0,0 +1,20 @@
+3
+2
+3
+3
+4
+6
+4
+6
+6
+6
+6
+6
+6
+1
+1
+1
+3
+2
+4
+2
diff --git a/testsuite/c_test/enhancec_test/ENC0013-boundary_count_array_insert/test.cfg b/testsuite/c_test/enhancec_test/ENC0013-boundary_count_array_insert/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..750b891e4a487424f45c23877b9639450d9d4be4
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0013-boundary_count_array_insert/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(boundary_count_array_insert)
+run(boundary_count_array_insert)
+ENCO2_B_D:
+compile(boundary_count_array_insert)
+run(boundary_count_array_insert)
+cat boundary_count_array_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_array_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="assert"  --result=boundary_count_array_insert.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0014-ABCO_opt_lower_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0014-ABCO_opt_lower_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..9f0feca95d33b8f641781cfbb354e3c764984d90
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0014-ABCO_opt_lower_bound/boundary_count_insert.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  if (len < 0) {
+    return;
+  }
+  for (int i = len; i >= 0; --i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+__attribute__((count("len", 2)))
+int test2(int len, int *p, int lo) {
+  int res = 0;
+  if (len < 0) {
+    return res;
+  }
+  for (int i = 10; i <= 20; i++) {
+    for (int j = 4; j < i - 5; j++) {
+      res += p[j - 4];
+    }
+  }
+  return res;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0014-ABCO_opt_lower_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0014-ABCO_opt_lower_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9bee824409f3855b8cc31c4322f542e958f11885
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0014-ABCO_opt_lower_bound/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertge"  --result=boundary_count_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=2 --str="assertlt"  --result=boundary_count_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=2 --str="can't prove the pointer < the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0015-ABCO_opt_upper_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0015-ABCO_opt_upper_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..560b51a495d40b095415977b3db5db765f12b34e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0015-ABCO_opt_upper_bound/boundary_count_insert.c
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  if (len != 10) {
+    return;
+  }
+  for (int i = len - 1; i >= *p; --i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = len -1; i > *p; --i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = *p; i != len; ++i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = len - 1; i != *p; --i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = *p; i < len; ++i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = *p; i <= len - 1; ++i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+__attribute__((count("len", 2)))
+int test3(int len, int *p) {
+  if (len != 1) {
+    return 0;
+  }
+  int res = 0;
+  for (int i = 0; i <= 10; i++) {
+    for (int j = 4; j < i - 5 ; j++) {
+      res += p[j - 4];
+    }
+  }
+  return res;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0015-ABCO_opt_upper_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0015-ABCO_opt_upper_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5f5d625bb19e052ac07dbc92638794dbc66f2ed1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0015-ABCO_opt_upper_bound/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=6 --str="assertge"  --result=boundary_count_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertlt"  --result=boundary_count_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=6 --str="can't prove the pointer >= the lower bounds"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0016-ABCO_opt_fully/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0016-ABCO_opt_fully/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..1138a299ccfab5cc711695ce0e3a4e2ba929072a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0016-ABCO_opt_fully/boundary_count_insert.c
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  if (len != 5) {
+    return;
+  }
+  for (int i = len - 1; i >= 0; --i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = len - 1; i > -1; --i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = 0; i != len; ++i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = len - 1; i != 0; --i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = len - 1; i != -1; --i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = 0; i < len; ++i) {
+    printf("%d\n", p[i]);
+  }
+
+  for (int i = 0; i <= len - 1; ++i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+__attribute__((count("len", 2)))
+int test2(int len, int *p) {
+  int res = 0;
+  if (len != 5) {
+    return res;
+  }
+  int x = 0;
+  do {
+    res += p[x];
+    x++;
+  } while (x < len);
+  return res;
+}
+
+__attribute__((count("len", 2)))
+int test4(int len, int *p) {
+  if (len != 1) {
+    return 0;
+  }
+  int res = 0;
+  for (int i = 0; i <= 10; i++) {
+    for (int j = 4; j < i - 5; j++) {
+      res += p[j - 4];
+    }
+  }
+  return res;
+}
+
+__attribute__((count("len", 2)))
+int test5(int len, int *p) {
+  if (len != 1) {
+    return 0;
+  }
+  int res = 0;
+  for (int i = 0; i <= 10; i++) {
+    for (int j = 4; ; j++) {
+      if (j > 20) {
+        break;
+      }
+      if (j > 9) {
+        break;
+      }
+      if (j > 4) {
+        break;
+      }
+
+      res += p[j - 4];
+    }
+  }
+  return res;
+}
+
+__attribute__((count("len", 2)))
+int test6(int len, int *p) {
+  if (len != 1) {
+    return 0;
+  }
+  int res = 0;
+  for (int i = 0; i <= 10; i++) {
+    for (int j = 4; ; j++) {
+      if (j > 9) {
+        break;
+      }
+      if (j > 4) {
+        printf("%d %d\n", i , j);
+      }
+      if (j > 4) {
+        break;
+      }
+
+      res += p[j - 4];
+    }
+  }
+  return res;
+}
+
+__attribute__((count("len", 2)))
+int test7(int len, int *p) {
+  if (len != 2) {
+    return 0;
+  }
+  int res = 0;
+  for (int i = 0; i <= 10; i++) {
+    for (int j = 4; j < 6; j++) {
+      switch (j) {
+        case 4:
+          res += p[j - 4];
+          break;
+        case 5:
+          res += p[j - 4];
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return res;
+}
+
+int main() {
+  int a[5] = {1, 2, 3, 4, 5};
+  int d[1] = {1};
+  int e[2] = {1, 2};
+  int i = 1;
+  int *p = &a;
+  test1(5, p);
+  p = &a;
+  test2(5, p);
+  p = &d;
+  test4(1, p);
+  test5(1, p);
+  test6(1, p);
+  p = &e;
+  test7(2, p);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0016-ABCO_opt_fully/expected.txt b/testsuite/c_test/enhancec_test/ENC0016-ABCO_opt_fully/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e158cd1dd0291dd24d7f9f429df23795d947daad
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0016-ABCO_opt_fully/expected.txt
@@ -0,0 +1,45 @@
+5
+4
+3
+2
+1
+5
+4
+3
+2
+1
+1
+2
+3
+4
+5
+5
+4
+3
+2
+5
+4
+3
+2
+1
+1
+2
+3
+4
+5
+1
+2
+3
+4
+5
+0 5
+1 5
+2 5
+3 5
+4 5
+5 5
+6 5
+7 5
+8 5
+9 5
+10 5
diff --git a/testsuite/c_test/enhancec_test/ENC0016-ABCO_opt_fully/test.cfg b/testsuite/c_test/enhancec_test/ENC0016-ABCO_opt_fully/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c331be3af5fc0c4010f5ee814cfc2575ca3fe541
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0016-ABCO_opt_fully/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(boundary_count_insert)
+run(boundary_count_insert)
+ENCO2_B_D:
+compile(boundary_count_insert)
+run(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertge"  --result=boundary_count_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertlt"  --result=boundary_count_insert.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0017-ABCO_can_not_opt/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0017-ABCO_can_not_opt/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..27c08ebb06ebb0c5ed25086d96ed3b3b3eeb63e4
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0017-ABCO_can_not_opt/boundary_count_insert.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  for (int i = len; i >= *p; --i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+__attribute__((count("len", 2)))
+int test2(int len, int *p, int lo) {
+  int res = 0;
+  for (int i = lo; i <= 10; i++) {
+    for (int j = 4; j < i - 5; j++) {
+      res += p[j - 4];
+    }
+  }
+  return res;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0017-ABCO_can_not_opt/test.cfg b/testsuite/c_test/enhancec_test/ENC0017-ABCO_can_not_opt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4c00ae67bf42927abef30aacae829076ba70fcce
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0017-ABCO_can_not_opt/test.cfg
@@ -0,0 +1,6 @@
+ENCO2_B_D:
+compile(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="assertge"  --result=boundary_count_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=3 --str="assertlt"  --result=boundary_count_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="can't prove the pointer >= the lower bounds when accessing the memory"  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=3 --str="can't prove the pointer < the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0018-boundary_count_call_insert/boundary_count_call_insert.c b/testsuite/c_test/enhancec_test/ENC0018-boundary_count_call_insert/boundary_count_call_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..f119083dee9b99e318beff92f3a7b4b1735ef914
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0018-boundary_count_call_insert/boundary_count_call_insert.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_call_insert.c"
+
+#include <stdio.h>
+
+int get(int *buf __attribute__((count(10)))) {
+  return buf[1];
+}
+
+void foo(int w, int x, int y, int z) {
+  int res;
+  int A[10] = {0};
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: callassertle{{.*}}
+  res = get(A);
+
+  int B[20] = {0};
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: callassertle{{.*}}
+  get(B);
+
+  int *J = A;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: callassertle{{.*}}
+  get(J);
+
+  int *K = B;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: callassertle{{.*}}
+  get(K);
+}
+
+struct S {
+  char info[2];
+  long a, b;
+  char tag[2];
+};
+
+struct A {
+  char info[2];
+  short s;
+};
+
+__attribute__((count(10)))
+void f(char *buf) {
+  return;
+}
+
+void bar() {
+  char array[12];
+  char array2d[3][12];
+  struct A a;
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: assertle{{.*}}
+  f(&array[0]);
+  char *x = &array[0];
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: assertle{{.*}}
+  f(x);
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: assertle{{.*}}
+  f(array2d[0]);
+  char *y = array2d[0];
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: assertle{{.*}}
+  f(y);
+
+  char *z = a.info;
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: assertle{{.*}}
+  f(&array[1]);
+  char *w = &array[3];
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]{{$}}
+  // CHECK: assertle{{.*}}
+  f(&array2d[1][3]);
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0018-boundary_count_call_insert/expected.txt b/testsuite/c_test/enhancec_test/ENC0018-boundary_count_call_insert/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0018-boundary_count_call_insert/test.cfg b/testsuite/c_test/enhancec_test/ENC0018-boundary_count_call_insert/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9547724e40278328fdec92db403c20507b0bd887
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0018-boundary_count_call_insert/test.cfg
@@ -0,0 +1,6 @@
+ENCO2_N_D:
+compile(boundary_count_call_insert)
+run(boundary_count_call_insert)
+ENCO2_B_D:
+compile(boundary_count_call_insert)
+run(boundary_count_call_insert)
diff --git a/testsuite/c_test/enhancec_test/ENC0019-nonnull_check_field/expected.txt b/testsuite/c_test/enhancec_test/ENC0019-nonnull_check_field/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0019-nonnull_check_field/nonnull_check_field.c b/testsuite/c_test/enhancec_test/ENC0019-nonnull_check_field/nonnull_check_field.c
new file mode 100644
index 0000000000000000000000000000000000000000..296c61f851f4b715e9d53a973d0fd3f89d24fd90
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0019-nonnull_check_field/nonnull_check_field.c
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_field.c"
+
+#include <stddef.h>
+
+int g_i = 1;
+int *g_p __attribute__((nonnull)) = &g_i;
+
+struct {
+  int (*f)();
+} g1;
+
+int test1() {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertnonnull <&test1> (dread ptr $g1 1)
+  return g1.f(); // expected-warning
+}
+
+
+struct {
+  int (*f)() __attribute__((nonnull));
+} g2;
+
+int test2() {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: assertnonnull <&test2> (dread ptr $g2 1)
+  return g2.f();
+}
+
+
+struct {
+  int *f;
+} g3;
+
+int test3() {
+  if (g3.f != NULL) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertnonnull <&test3> (dread ptr $g3 1)
+    return *g3.f;
+  }
+  return 0;
+}
+
+struct {
+  int *f __attribute__((nonnull));
+} g4;
+
+int test4() {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: assertnonnull <&test4> (dread ptr $g4 1)
+  return *g4.f;
+}
+
+typedef struct {
+  int count;
+  int val;
+} g5;
+
+int get_test5(g5 *f) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertnonnull <&get_test5> (dread ptr %f)
+  return f->count; // expected-warning {{illegal access of nullable pointer}}
+}
+
+typedef struct g6 {
+  int *count __attribute__((nonnull));
+  struct g6 *ptr;
+} g6;
+
+__attribute__((nonnull))
+void nonnull_field(g6 *f) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: assertnonnull{{.*}}
+  *(f->count);
+}
+
+__attribute__((nonnull(2, 3)))
+void call_nonnull_field(g6 *f, g6 *g, g6 *h) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: callassertnonnull <&nonnull_field, 0, &call_nonnull_field> (dread ptr %f)
+  nonnull_field(f); // expected-warning
+  nonnull_field(g);
+  nonnull_field(h);
+
+  if (f) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: callassertnonnull <&nonnull_field, 0, &call_nonnull_field> (dread ptr %f)
+    nonnull_field(f);
+    if (f->count)
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK-NEXT: callassertnonnull <&nonnull_field, 0, &call_nonnull_field> (dread ptr %f)
+      nonnull_field(f);
+  }
+
+  if (g->count) {
+    nonnull_field(g);
+  }
+}
+
+typedef struct g7 {
+  int *count;
+  struct g7 *ptr;
+} g7;
+
+void nullable_field(g7 *f) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertnonnull{{.*}}
+  *(f->count); // expected-warning
+  if (f != NULL && f->count) {
+    *(f->count);
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertnonnull{{.*}}
+    *((f + 1)->count); // expected-warning
+  }
+  if ((f + 1) != NULL && (f + 1)->count) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertnonnull{{.*}}
+    *((f + 1)->count);
+  }
+}
+
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0019-nonnull_check_field/test.cfg b/testsuite/c_test/enhancec_test/ENC0019-nonnull_check_field/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0b702755c44e1ed46faf72296f9c85c80d7cd069
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0019-nonnull_check_field/test.cfg
@@ -0,0 +1,17 @@
+ENCO2_N_D:
+compile(nonnull_check_field)
+run(nonnull_check_field)
+cat nonnull_check_field.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_field.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="assertnonnull"  --result=nonnull_check_field.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=4 --str="Dereference of nullable pointer"  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nullable pointer passed to nonnull_field that requires nonnull for 1st argument"  --result=compile.log
+ENCO2_N_D_ALL:
+compile(nonnull_check_field)
+run(nonnull_check_field)
+cat nonnull_check_field.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_field.c
+python3 ${TEST_BIN}/check.py --check=num  --n=5 --str="assertnonnull"  --result=nonnull_check_field.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=4 --str="Dereference of nullable pointer"  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nullable pointer passed to nonnull_field that requires nonnull for 1st argument"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_field)
+run(nonnull_check_field)
diff --git a/testsuite/c_test/enhancec_test/ENC0020-nonnull_check_warning/expected.txt b/testsuite/c_test/enhancec_test/ENC0020-nonnull_check_warning/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0020-nonnull_check_warning/nonnull_check_warning.c b/testsuite/c_test/enhancec_test/ENC0020-nonnull_check_warning/nonnull_check_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..cfb04951e1b21da18aa8404aa88b09bed0325fe6
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0020-nonnull_check_warning/nonnull_check_warning.c
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stddef.h>
+
+// ipa will insert nonnull
+void deref_nullable(int *x) {
+  int a = *x; // CHECK-NOT: [[# @LINE ]] warning
+  int *y = x;
+  a = *y;
+}
+
+__attribute__((nonnull))
+void deref_nonnull(int *x) {
+  int a = *x;
+  int *y = x;
+  a = *y; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+void deref_nullable_if_not_null(int *x, int y) {
+  if (x != NULL) {
+    int a = *x; // CHECK-NOT: [[# @LINE ]] warning
+    int *y = x;
+    a = *y; // CHECK-NOT: [[# @LINE ]] warning
+  } else {
+  }
+  int a = *x; // CHECK: [[# @LINE ]] warning
+
+  if (x != NULL && y > 0) {
+    int a = *x + y;  // CHECK-NOT: [[# @LINE ]] warning
+  }
+}
+
+void deref_nullable_if_return(int *x) {
+  if (!x)
+    return;
+  int a = *x; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+void deref_nullable_if_null(int *x) {
+  if (x == NULL) {
+  } else {
+    int a = *x; // CHECK-NOT: [[# @LINE ]] warning
+    int *y = x;
+    a = *y; // CHECK-NOT: [[# @LINE ]] warning
+  }
+  int a = *x; // CHECK: [[# @LINE ]] warning
+}
+
+void deref_nullable_if(int *x) {
+  if (x) {
+    int a = *x; // CHECK-NOT: [[# @LINE ]] warning
+    int *y = x;
+    a = *y; // CHECK-NOT: [[# @LINE ]] warning
+  } else {
+  }
+}
+
+void deref_nullable_if_not(int *x) {
+  if (!x) {
+  } else {
+    int a = *x; // CHECK-NOT: [[# @LINE ]] warning
+    int *y = x;
+    a = *y; // CHECK-NOT: [[# @LINE ]] warning
+  }
+}
+
+void deref_nullable_ternary(int *x, int *y __attribute__((nonnull)), int z) {
+  int a = x ? *x : 0; // CHECK-NOT: [[# @LINE ]] warning
+  int b = 0;
+  a = (x != NULL) ? *x : 0; // CHECK-NOT: [[# @LINE ]] warning
+  a = (x == NULL) ? 0 : *x; // CHECK-NOT: [[# @LINE ]] warning
+  a = *(z ? y : y); // CHECK-NOT: [[# @LINE ]] warning
+  b = *(z ? x : y); // CHECK: [[# @LINE ]] warning
+  a = *(x ? x : y); // CHECK-NOT:[[# @LINE ]] warning
+  b = *(x ? y : x); // CHECK: [[# @LINE ]] warning
+}
+
+void deref_nullable_shortcut(int *x) {
+  if (x && *x > 0) // CHECK-NOT: [[# @LINE ]] warning
+    return;
+}
+
+int null_check_or(int *a, int *b) {
+  if (a == NULL || b == NULL) {
+    return 0;
+  } else {
+    return *a + *b; // CHECK-NOT: [[# @LINE ]] warning
+  }
+}
+
+int null_check_or_error(int *a, int b) {
+  if (a != NULL || b > 0) {
+    return *a + b; // CHECK: [[# @LINE ]] warning
+  }
+  return b;
+}
+
+int null_check_and(int *a, int *b) {
+  if (a != NULL && b != NULL) {
+    return *a + *b; // CHECK-NOT: [[# @LINE ]] warning
+  } else {
+    return 0;
+  }
+}
+
+int null_check_and_error(int *a, int *b) {
+  if (a == NULL && b == NULL) {
+    return 0;
+  } else {
+    return *a + *b; // CHECK: [[# @LINE ]] warning
+  }
+}
+
+typedef struct foo {
+  int *count __attribute__((nonnull));
+  struct foo *ptr;
+} foo;
+
+void deref_nonnull_field(foo *f __attribute__((nonnull))) {
+  int a = *(f->count); // CHECK-NOT: [[# @LINE ]] warning
+}
+
+void deref_nullable_field_field(foo *f __attribute__((nonnull))) {
+  int a = *(f->ptr->count); // CHECK: [[# @LINE ]] warning
+}
+
+// ipa will insert nonnull
+void access_nullable(foo *f) {
+  int *a = f->count; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+__attribute__((nonnull))
+void access_nonnull(foo *f) {
+  int *a = f->count; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+// ipa will insert nonnull
+void array_indexing_nullable(char *in) {
+  char c = in[0]; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+void array_indexing_nonnull(char *in __attribute__((nonnull))) {
+  char *data = "abcde";
+  char c = in[0]; // CHECK-NOT: [[# @LINE ]] warning
+  c = data[0]; // COM:CHECK-NOT: [[# @LINE ]] warning
+}
+
+void func_ptr_nullable(void (*funcPtr)(void)) {
+  funcPtr(); // CHECK: [[# @LINE ]] warning
+}
+
+
+__attribute__((nonnull))
+void func_ptr_nonnull(void (*funcPtr)(void)) {
+  funcPtr(); // CHECK-NOT: [[# @LINE ]] warning
+}
+
+struct List {
+  struct List *next;
+  int value;
+};
+
+unsigned int access_loop_check(struct List *l) {
+  unsigned int length = 0;
+  for (; l != NULL; l = l->next, length++) // CHECK-NOT: [[# @LINE ]] warning
+    ;
+  return length;
+}
+
+struct {
+  int (*f)();
+} g1;
+
+int member_call_nullable() {
+  return g1.f(); // CHECK: [[# @LINE ]] warning
+}
+
+struct {
+  int (*f)() __attribute__((nonnull));
+} g2;
+
+int member_call_nonnull() {
+  return g2.f();
+}
+
+int multi_if(int *a, int *b) {
+  if (!a)
+    return 0;
+  if (!b)
+    return 1;
+  return *a + *b; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+int nested_if(int *a, int *b) {
+  if (a != 0) {
+    if (b != 0) {
+      *a = *b; // CHECK-NOT: [[# @LINE ]] warning
+      return 0;
+    }
+    *a = 1; // CHECK-NOT: [[# @LINE ]] warning
+    return 1;
+  }
+  return 2;
+}
+
+
+int ptr_ptr(int *p, int *q) {
+  int **ptr_p = &p;
+  if (p != NULL) {
+    *ptr_p = q;
+    return *p; // CHECK: [[# @LINE ]] warning
+  }
+  return 0;
+}
+
+int nonnull_ptr_ptr(int *p, int *q __attribute__((nonnull))) {
+  int **ptr_p = &p;
+  if (p != NULL) {
+    *ptr_p = q;
+    return *p; // CHECK-NOT: [[# @LINE ]] warning
+  }
+  return 0;
+}
+
+int *ptr_n_n(int **p) {
+  if (p == NULL)
+    return NULL;
+  return *p; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+int ptr_n_nn(int **p) {
+  if (p == NULL)
+    return 0;
+  if (*p == NULL)
+    return 0;
+  return **p; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+
+int *nonnull_ptr_n_n(int **p __attribute__((nonnull))) {
+  return *p; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+int nonnull_ptr_n_nn(int **p __attribute__((nonnull))) {
+  return **p; // CHECK-NOT: [[# @LINE ]] warning
+}
+
+struct k1 {
+  int **ptr;
+};
+
+int field_ptr_n_nn(struct k1 *p) {
+  if (p == NULL)
+    return 0;
+  if (p->ptr == NULL)
+    return 0;
+  if (*(p->ptr) == NULL)
+    return 0;
+  return **(p->ptr); // CHECK-NOT: [[# @LINE ]] warning
+}
+
+int field1_ptr_n_nn(struct k1 *p) {
+  int res = 0;
+  if (p + 1 != NULL && (p + 1)->ptr != NULL && *((p + 1)->ptr) != NULL)
+    res = **((p + 1)->ptr); // CHECK-NOT: [[# @LINE ]] warning
+  if (p + 1 != NULL && (p + 1)->ptr != NULL && *((p + 1)->ptr) + 1 != NULL)
+    res = *(*((p + 1)->ptr) + 1); // CHECK-NOT: [[# @LINE ]] warning
+  if (p != NULL && p->ptr != NULL && *(p->ptr) + 1 != NULL)
+    res =  *(*(p->ptr) + 1); // CHECK-NOT: [[# @LINE ]] warning
+  return res;
+}
+
+struct k2 {
+  int **ptr __attribute__((nonnull));
+};
+
+int nonnull_field_ptr_n_nn(struct k2 *p __attribute__((nonnull))) {
+  return **(p->ptr); // CHECK-NOT: [[# @LINE ]] warning
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0020-nonnull_check_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0020-nonnull_check_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9e6ff7d404accdd88fae389385b1b308bacabb7c
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0020-nonnull_check_warning/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_check_warning)
+run(nonnull_check_warning)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_warning.c
+ENCO2_B_D:
+compile(nonnull_check_warning)
+run(nonnull_check_warning)
diff --git a/testsuite/c_test/enhancec_test/ENC0021-boundary_count_malloc/boundary_count_malloc.c b/testsuite/c_test/enhancec_test/ENC0021-boundary_count_malloc/boundary_count_malloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..a0c640301eebc04b00ed9a37209f55c80a227ebf
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0021-boundary_count_malloc/boundary_count_malloc.c
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+int main() {
+  int *q;
+  int *p __attribute__((count(6)));
+  int *l __attribute__((count(5)));
+  p = l;
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0021-boundary_count_malloc/expected.txt b/testsuite/c_test/enhancec_test/ENC0021-boundary_count_malloc/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0021-boundary_count_malloc/test.cfg b/testsuite/c_test/enhancec_test/ENC0021-boundary_count_malloc/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dfed1935e7ac2036c0b00dfaa647a9aeb7942fd7
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0021-boundary_count_malloc/test.cfg
@@ -0,0 +1,6 @@
+ENCO2_N_D:
+compile(boundary_count_malloc)
+run(boundary_count_malloc)
+ENCO2_B_D:
+compile_err(boundary_count_malloc)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_malloc.c:20 error: l-value boundary should not be larger than r-value boundary"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0022-boundary_count_field/boundary_count_field.c b/testsuite/c_test/enhancec_test/ENC0022-boundary_count_field/boundary_count_field.c
new file mode 100644
index 0000000000000000000000000000000000000000..116c9b9973b745d903b3de671ca366ba6b4b3827
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0022-boundary_count_field/boundary_count_field.c
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_field.c"
+
+#include <stdio.h>
+
+struct A {
+  int *i __attribute__((count("len")));
+  int len;
+};
+
+struct B {
+  struct A a;
+  struct A *pa;
+};
+
+int g_a[] = {1,2,3,4,5};
+int *g_p __attribute__((count(5))) = g_a;
+
+
+int func(int x) {
+  return x;
+}
+
+int test_field(struct B b, struct B *pb) {
+  int res = 0;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  res += func(*(b.a.i + 4));
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  res += func(pb->pa->i[4]);
+}
+
+int test_field1(struct B b, int i) {
+  // init field boundary
+  // CHECK: dassign %_boundary.b{{.*}}.lower 0{{.*}}
+  int res = 0;
+  if (i > 0) {
+    int arr[7] = {1, 2, 3, 4, 5, 6, 7};
+    b.a.len = 7;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+    // CHECK: assignassertle{{.*}}
+    // CHECK: dassign %_boundary.b{{.*}}.lower 0{{.*}}
+    b.a.i = arr;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertge{{.*}}
+    res += func(*(b.a.i + 4));
+  } else {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertge{{.*}}
+    res += func(*(b.a.i + 4));
+  }
+  return res;
+}
+
+__attribute__((count("len", 1)))
+int test_arg(int* a, struct B *b, int len) {
+  int res = 0;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  res += func(a[1]);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  res += func(b->a.i[1]);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK: assignassertle{{.*}}
+  // CHECK: dassign %_boundary.a.upper 0 (add ptr {{.*}}
+  a = g_p;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK: assignassertle{{.*}}
+  // CHECK: dassign %_boundary.B_i{{.*}}
+  b->a.i = g_p;
+  res += func(a[1]);
+  return res;
+}
+
+struct A ga;
+void test_global_field_init1(int i) {
+  int res = 0;
+  ga.len = 5;
+  ga.i = g_p;
+}
+
+int test_global_field(int i) {
+  int res = 0;
+  if (i > 0) {
+    int arr[7] = {1, 2, 3, 4, 5, 6, 7};
+    ga.len = 7;
+    ga.i = arr;
+    res += func(*(ga.i + 3));
+  } else {
+    res += func(*(ga.i + 3));
+  }
+  return res;
+}
+
+
+int main() {
+  return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0022-boundary_count_field/expected.txt b/testsuite/c_test/enhancec_test/ENC0022-boundary_count_field/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0022-boundary_count_field/test.cfg b/testsuite/c_test/enhancec_test/ENC0022-boundary_count_field/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a83d3178cba451293add136e2a099e18f9ab1d7
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0022-boundary_count_field/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_count_field)
+run(boundary_count_field)
+ENCO2_B_D:
+compile(boundary_count_field)
+run(boundary_count_field)
+cat boundary_count_field.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_field.c
diff --git a/testsuite/c_test/enhancec_test/ENC0023-global_var_boundary_opt/boundary_count_var.c b/testsuite/c_test/enhancec_test/ENC0023-global_var_boundary_opt/boundary_count_var.c
new file mode 100644
index 0000000000000000000000000000000000000000..6eadd7117b95075913a2d8f8ae0b23a5fb9a5db0
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0023-global_var_boundary_opt/boundary_count_var.c
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_var.c"
+
+#include <stdio.h>
+
+struct A {
+  int *i __attribute__((count("len")));
+  int len;
+};
+
+struct B {
+  struct A a;
+  struct A *pa;
+};
+
+int g_a[] = {1,2,3,4,5};
+int *g_p __attribute__((count(5))) = g_a;
+
+int func(int x) {
+  return x;
+}
+
+int test_local() {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %_boundary.q{{.*}}.lower 0 (dread ptr %q{{.*}}
+  int *q __attribute__((count(3)));
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %_boundary.q1{{.*}}.lower 0 (dread ptr %_boundary.q{{.*}}
+  int *q1 = q;
+  int *q2;
+  int res = 0;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK-NEXT: dassign %_boundary.p{{.*}}.lower 0 (dread ptr %p{{.*}}
+  // CHECK: assignassertle{{.*}}
+  // CHECK: dassign %_boundary.p{{.*}}.lower 0 (addrof ptr $g_a)
+  int *p __attribute__((count(5))) = g_a;
+  res += func(*(p + 4));
+  int *p1 = p + 1;
+  res += func(*(p1 + 3));
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK: assertge{{.*}}
+  // CHECK: assignassertle{{.*}}
+  // CHECK: dassign %_boundary.q{{.*}}.lower 0 (dread ptr %_boundary.p{{.*}}
+  q = p + 1;
+  q1 = p;
+  q2 = p;
+  res += func(q[2]);
+  res += func(q1[4]);
+  res += func(q2[4]);
+  return res;
+}
+
+int test_global() {
+  int res = 0;
+  res += func(g_a[2]);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  res += func(g_p[2]);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %_boundary.p{{.*}}.lower 0 (dread ptr $g_p)
+  int *p = g_p;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK: dassign %_boundary.p1{{.*}}.lower 0 (dread ptr %p1{{.*}}
+  // CHECK: assignassertle{{.*}}
+  // CHECK: dassign %_boundary.p1{{.*}}.lower 0 (dread ptr $g_p)
+  int *p1 __attribute__((count(3))) = g_p;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: dassign %_boundary.p2{{.*}}.lower 0 (dread ptr %p2{{.*}}
+  int *p2 __attribute__((count(3)));
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK: assignassertle{{.*}}
+  // CHECK: dassign %_boundary.p2{{.*}}.lower 0 (dread ptr $g_p)
+  p2 = g_p;
+  res += func(p1[2]);
+  res += func(p2[2]);
+  return res;
+}
+
+int test_global_assign1(int a) {
+  int res = 0;
+  res += func(g_p[2]);
+ 
+  if (a > 0) {
+    res += func(g_p[2]);
+  } else {
+    int arr[7] = {1, 2, 3, 4, 5, 6, 7};
+    g_p = arr;
+    res += func(g_p[2]);
+  }
+  return res;
+}
+
+int test_global_assign2(int a) {
+  int res = 0;
+  res += func(g_p[2]);
+
+  if (a > 0) {
+    int arr[7] = {1, 2, 3, 4, 5, 6, 7};
+    g_p = arr;
+    res += func(g_p[2]);
+  } else {
+    res += func(g_p[2]);
+  }
+  return res;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0023-global_var_boundary_opt/expected.txt b/testsuite/c_test/enhancec_test/ENC0023-global_var_boundary_opt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0023-global_var_boundary_opt/test.cfg b/testsuite/c_test/enhancec_test/ENC0023-global_var_boundary_opt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..867f93834b9a676dbebaeb79cff2deeea70ee186
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0023-global_var_boundary_opt/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(boundary_count_var)
+run(boundary_count_var)
+ENCO2_B_D:
+compile(boundary_count_var)
+run(boundary_count_var)
+cat boundary_count_var.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_var.c
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assert"  --result=boundary_count_var.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0024-boundary_count_field_init/boundary_count_field.c b/testsuite/c_test/enhancec_test/ENC0024-boundary_count_field_init/boundary_count_field.c
new file mode 100644
index 0000000000000000000000000000000000000000..39622f0ae21484b58b75d3eb651e3386e51edc3b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0024-boundary_count_field_init/boundary_count_field.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_field.c"
+
+#include <stdio.h>
+
+struct A {
+  int *i __attribute__((count("len")));
+  int len;
+};
+
+struct B {
+  struct A a;
+  struct A *pa;
+};
+
+int g_a[] = {1,2,3,4,5};
+int *g_p __attribute__((count(5))) = g_a;
+
+
+int func(int x) {
+  return x;
+}
+
+int test_field_init() {
+  int res = 0;
+  // init field boundary
+  // CHECK: dassign %_boundary.b{{.*}}.lower 0 (dread ptr %b{{.*}}
+  // CHECK: dassign %_boundary.A_i{{.*}}.lower 0 (iread ptr {{.*}}
+  struct A a;
+  a.len = 4;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+  // CHECK: assignassertle{{.*}}
+  // CHECK: dassign %_boundary.a{{.*}}.lower 0 (dread ptr $g_p)
+  a.i = g_p;
+
+  struct B b;
+  b.a = a;
+  b.pa = &a;
+ 
+  //b.a.len = 5;
+  //b.pa->len = 5;
+
+  struct B arr_b[5];
+
+  struct B *pb = &b;
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  res += func(*(b.a.i + 3));
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  res += func(pb->pa->i[3]);
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK: assertge
+  // CHECK: assertle
+  // CHECK: dassign %_boundary.A_i{{.*}}.lower 0 (dread ptr $g_p)
+  pb->pa->i = g_p + 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK: assertge
+  // CHECK: assertle
+  // CHECK: dassign %_boundary.b{{.*}}.lower 0 (dread ptr $g_p)
+  b.a.i = g_p + 1;
+  
+  res += func(*(b.a.i + 3));
+  res += func(pb->pa->i[3]);
+  return res;
+}
+
+int test_field_init1(int i) {
+  int res = 0;
+  struct A a;
+  a.len = 5;
+  a.i = g_p;
+  if (i > 0) {
+    int arr[7] = {1, 2, 3, 4, 5, 6, 7};
+    a.len = 7;
+    a.i = arr;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertge
+    res += func(*(a.i + 3));
+  } else {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertge
+    res += func(*(a.i + 3));
+  }
+  return res;
+}
+
+struct A ga;
+int test_global_field_init1(int i) {
+  int res = 0;
+  ga.len = 5;
+  ga.i = g_p;
+  if (i > 0) {
+    int arr[7] = {1, 2, 3, 4, 5, 6, 7};
+    ga.len = 7;
+    ga.i = arr;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertge
+    res += func(*(ga.i + 3));
+  } else {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertge
+    res += func(*(ga.i + 3));
+  }
+  return res;
+}
+
+struct A *gpa;
+int test_global_field_init2(int i) {
+  int res = 0;
+  struct A a;
+  a.len = 5;
+  a.i = g_p;
+  gpa = &a;
+  if (i > 0) {
+    int arr[7] = {1, 2, 3, 4, 5, 6, 7};
+    gpa->len = 7;
+    gpa->i = arr;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertge
+    res += func(*(gpa->i + 3));
+  } else {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: assertge
+    res += func(*(gpa->i + 3));
+  }
+  return res;
+}
+
+
+int main() {
+  return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0024-boundary_count_field_init/expected.txt b/testsuite/c_test/enhancec_test/ENC0024-boundary_count_field_init/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0024-boundary_count_field_init/test.cfg b/testsuite/c_test/enhancec_test/ENC0024-boundary_count_field_init/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a83d3178cba451293add136e2a099e18f9ab1d7
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0024-boundary_count_field_init/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_count_field)
+run(boundary_count_field)
+ENCO2_B_D:
+compile(boundary_count_field)
+run(boundary_count_field)
+cat boundary_count_field.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_field.c
diff --git a/testsuite/c_test/enhancec_test/ENC0025-nonnull_check_null/expected.txt b/testsuite/c_test/enhancec_test/ENC0025-nonnull_check_null/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0025-nonnull_check_null/nonnull_check_var.c b/testsuite/c_test/enhancec_test/ENC0025-nonnull_check_null/nonnull_check_var.c
new file mode 100644
index 0000000000000000000000000000000000000000..96ad7d70e1ad7687a84085082b34550544c319bc
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0025-nonnull_check_null/nonnull_check_var.c
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+#include <stddef.h>
+
+struct A {
+  int *i;
+  int *j  __attribute__((nonnull));
+};
+
+int *gp;
+int *gq __attribute__((nonnull));  // CHECK: [[# @LINE ]] error
+int *gr __attribute__((nonnull)) = NULL;  // CHECK: [[# @LINE ]] error
+int i = 3;
+int *gw __attribute__((nonnull)) = &i; // CHECK-NOT: [[# @LINE ]] error
+
+__attribute__((returns_nonnull))
+int *foo(int *f __attribute__((nonnull))) {
+  int i = 1;
+  int *p = NULL;  // CHECK-NOT: [[# @LINE ]] error
+  int *q __attribute__((nonnull));  // CHECK: [[# @LINE ]] error
+  int *r __attribute__((nonnull)) = NULL;  // CHECK: [[# @LINE ]] error
+  int *w __attribute__((nonnull)) = &i;  // CHECK-NOT: [[# @LINE ]] error
+  w = NULL;  // CHECK: [[# @LINE ]] error
+  w = f;  // CHECK-NOT: [[# @LINE ]] error
+  int *x __attribute__((nonnull)) = f; // COM:CHECK-NOT: [[# @LINE ]] error
+  p = f;  // CHECK-NOT: [[# @LINE ]] error
+ return NULL;  // CHECK: [[# @LINE ]] error
+}
+
+void test_field() {
+  struct A a1;
+  a1.i = NULL;  // CHECK-NOT: [[# @LINE ]] error
+  a1.j = NULL;  // CHECK: [[# @LINE ]] error
+
+  struct A a2  = {NULL,   // CHECK-NOT: [[# @LINE ]] error
+                  NULL};  // CHECK: [[# @LINE ]] error
+
+  struct A *pa;
+  pa = &a1;
+  pa->i = NULL;  // CHECK-NOT: [[# @LINE ]] error
+  pa->j = NULL;  // CHECK: [[# @LINE ]] error
+  pa->i = &i;   // CHECK-NOT: [[# @LINE ]] error
+}
+
+struct A g_a1 = {NULL,  // CHECK: [[# @LINE ]] error
+                 NULL};  // CHECK-NOT: [[# @LINE ]] error
+
+struct A g_a2 = {&i, 
+                 &i};  // CHECK-NOT: [[# @LINE ]] error
+
+struct X {
+  int i[2][2];
+  char *j __attribute__((nonnull));
+};
+
+struct B {
+  int i;
+  double j;
+  struct X a;
+};
+
+union U {
+  int i;
+  char *c __attribute__((nonnull));
+};
+
+union U1 {
+ char *c __attribute__((nonnull));
+ int i;
+};
+
+struct D {
+ char *k  __attribute__((nonnull));
+};
+
+struct C {
+  int i;
+  struct X a;
+  struct D d[3];
+  int j;
+  union U1 u1;
+};
+
+struct X g_x = {{{1,2},{1,2}}, NULL};  // CHECK: [[# @LINE ]] error
+struct X g_x1 = {.j = NULL};  // CHECK: [[# @LINE ]] error
+struct B g_b = {1, 2.1, {{{1,2},{1,2}}, NULL}};  // CHECK: [[# @LINE ]] error
+struct B g_b_arr[2] = { {1, 2.1, { {{1,2},{1,2}}, "123456789"} },  // CHECK-NOT: [[# @LINE ]] error
+                        {1, 2.2, { {{1,2},{1,2}}, NULL} } };  // CHECK: [[# @LINE ]] error
+union U g_u = {.c=NULL};  // CHECK: [[# @LINE ]] error
+struct C g_c_arr[3] = { {1, { {{1,2},{1,2}}, NULL}, {"1", NULL, NULL}, 2, NULL },  // CHECK-COUNT-4: [[# @LINE ]] error
+                        {1, { {{1,2},{1,2}}, "123456"}, {"1", "2", "3"}, 2, NULL },   // CHECK: [[# @LINE ]] error
+                        {1, { {{1,2},{1,2}}, "123456"}, {"1", "2", "3"}, 2, "123456" } };  // CHECK-NOT: [[# @LINE ]] error
+
+
+int main() {
+  foo(NULL);  // CHECK: [[# @LINE ]] error
+  
+  struct C c_arr[3] = { {1, { {{1,2},{1,2}}, NULL}, {"1", NULL, NULL}, 2, NULL },  // CHECK-COUNT-4: [[# @LINE ]] error
+                          {1, { {{1,2},{1,2}}, "123456"}, {"1", "2", "3"}, 2, NULL },   // CHECK: [[# @LINE ]] error
+                          {1, { {{1,2},{1,2}}, "123456"}, {"1", "2", "3"}, 2, "123456" } };  // CHECK-NOT: [[# @LINE ]] error
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0025-nonnull_check_null/test.cfg b/testsuite/c_test/enhancec_test/ENC0025-nonnull_check_null/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fa424b09f82f77dc41ea6842ed64a53e98f759d2
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0025-nonnull_check_null/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile_err(nonnull_check_var)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_var.c
+ENCO2_B_D:
+compile(nonnull_check_var)
+run(nonnull_check_var)
diff --git a/testsuite/c_test/enhancec_test/ENC0027-nonnull_check_loop/expected.txt b/testsuite/c_test/enhancec_test/ENC0027-nonnull_check_loop/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c3ec80144cb1009fbead397836eade7cf19df5e5
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0027-nonnull_check_loop/expected.txt
@@ -0,0 +1,2 @@
+5
+10
diff --git a/testsuite/c_test/enhancec_test/ENC0027-nonnull_check_loop/nonnull_check_insert.c b/testsuite/c_test/enhancec_test/ENC0027-nonnull_check_loop/nonnull_check_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..10cd990f2fdd1d6931256bcafaba9f1339c8e2c9
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0027-nonnull_check_loop/nonnull_check_insert.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int k;
+    for(k = 0; k < 1; k++)
+    {
+        {
+            int *intPointer = NULL;
+            intPointer = (int *)malloc(sizeof(int));
+            *intPointer = 5;
+            printf("%d\n", *intPointer);
+            *intPointer = 10;
+            printf("%d\n", *intPointer);
+        }
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0027-nonnull_check_loop/test.cfg b/testsuite/c_test/enhancec_test/ENC0027-nonnull_check_loop/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e6441621c183bbf69e7a17d6d9f21f5f47e2799
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0027-nonnull_check_loop/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_check_insert)
+run(nonnull_check_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertnonnull"  --result=nonnull_check_insert.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of nullable pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_insert)
+run(nonnull_check_insert)
diff --git a/testsuite/c_test/enhancec_test/ENC0028-safe_region/expected.txt b/testsuite/c_test/enhancec_test/ENC0028-safe_region/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0028-safe_region/safe_region.c b/testsuite/c_test/enhancec_test/ENC0028-safe_region/safe_region.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c88f6926b0f82bb8492e3035d7c0ad7b4c0b073
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0028-safe_region/safe_region.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/safe_region.c"
+
+// CHECK: func &func0 public () void
+void func0(void) {
+}
+
+#pragma SAFE OFF
+
+// CHECK: func &func1 public unsafed () void
+void func1(void) {
+}
+
+// CHECK: func &func2 public safed () void
+__Safe__ void func2(void);
+
+#pragma SAFE ON
+
+// CHECK: func &func3 public unsafed () void
+__Unsafe__ void func3(void) {
+}
+
+// CHECK: func &func4 public safed () void
+void func4() {
+}
+
+// CHECK: func &main public safed () i32
+int main(void) {
+  return 0;
+}
+
+__Safe__ void func2(void) {
+  // CHECK: dassign %a{{.*}} 0 (constval i32 0)
+  int a = 0;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: safe
+  __Safe__ {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 1))
+    a += 1;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: unsafe
+    __Unsafe__ {
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK-NEXT: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 2))
+      a += 2;
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK-NEXT: safe
+      __Safe__ {
+        // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+        // CHECK-NEXT: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 3))
+        a += 3;
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK-NEXT: endsafe
+      }
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK-NEXT: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 4))
+      a += 4;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: endunsafe
+    }
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 5))
+    a += 5;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: endsafe
+  }
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 6))
+  a += 6;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0028-safe_region/test.cfg b/testsuite/c_test/enhancec_test/ENC0028-safe_region/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fa7f9239d87f9c05c0d3b1b8abe5f7c86fb1739e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0028-safe_region/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_S_D:
+compile(safe_region)
+run(safe_region)
+cat safe_region.mpl | ${OUT_ROOT}/tools/bin/FileCheck safe_region.c
diff --git a/testsuite/c_test/enhancec_test/ENC0029-boundary_byte_count/boundary_byte_count.c b/testsuite/c_test/enhancec_test/ENC0029-boundary_byte_count/boundary_byte_count.c
new file mode 100644
index 0000000000000000000000000000000000000000..e445ada47301e06a52b8566002083c04f063c5d9
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0029-boundary_byte_count/boundary_byte_count.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_byte_count.c"
+
+#include <stdio.h>
+
+__attribute__((returns_byte_count("len"), byte_count("len", 1)))
+int *getBoundaryPtr(int *ptr, int len) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertle{{.*}}
+  return ptr;
+}
+
+int *getPtr(int *ptr) {
+ return ptr;
+}
+
+
+struct A {
+  int *i;
+};
+
+struct B {
+  struct A *a;
+};
+
+int main() {
+  int a[5] = {1, 2, 3, 4, 5};
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK: assertle{{.*}}
+  // CHECK: dassign %_boundary.retVar{{.*}}.lower 0 (dread ptr %retVar{{.*}}
+  // CHECK: dassign %_boundary.pa{{.*}}.lower 0 (dread ptr %_boundary.retVar{{.*}}.lower
+  int *pa = getBoundaryPtr(a, 4 * 4);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 5 ]]
+  // CHECK: assertle{{.*}}
+  // CHECK: dassign %_boundary.retVar{{.*}}.lower 0 (dread ptr %retVar{{.*}}
+  // CHECK: assertge{{.*}}
+  // CHECK: dassign %_boundary.pa1{{.*}}.lower 0 (dread ptr %_boundary.retVar{{.*}}.lower
+  int *pa1 = getBoundaryPtr(a, 4 * 4) + 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", *(pa+2));
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", pa1[2]);
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: dassign %_boundary.pa2{{.*}}.lower{{.*}}
+  int *pa2 = getPtr(a);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: assertge{{.*}}
+  printf("%d\n", pa2[2]);
+
+  struct A aa;
+  struct B bb[4];
+  struct B *q = bb;
+  q->a = &aa;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 4 ]]
+  // CHECK: assertle{{.*}}
+  // CHECK: dassign %_boundary.retVar{{.*}}.lower 0 (dread ptr %retVar{{.*}}
+  // CHECK: dassign %_boundary.A_i{{.*}}.lower 0 (dread ptr %_boundary.retVar{{.*}}.lower
+  q->a->i = getBoundaryPtr(a, 4 * 4);
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertge{{.*}}
+  printf("%d\n", q->a->i[3]);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0029-boundary_byte_count/expected.txt b/testsuite/c_test/enhancec_test/ENC0029-boundary_byte_count/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..40e357c251b13ce495f5d09184c2460b11fafba5
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0029-boundary_byte_count/expected.txt
@@ -0,0 +1,4 @@
+3
+4
+3
+4
diff --git a/testsuite/c_test/enhancec_test/ENC0029-boundary_byte_count/test.cfg b/testsuite/c_test/enhancec_test/ENC0029-boundary_byte_count/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7e6450df6b0912f43633730e8ab6fd2fd1d7267e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0029-boundary_byte_count/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_byte_count)
+run(boundary_byte_count)
+ENCO2_B_D:
+compile(boundary_byte_count)
+run(boundary_byte_count)
+cat boundary_byte_count.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_byte_count.c
diff --git a/testsuite/c_test/enhancec_test/ENC0029-safe_func_warning/expected.txt b/testsuite/c_test/enhancec_test/ENC0029-safe_func_warning/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0029-safe_func_warning/safe_func_warning.c b/testsuite/c_test/enhancec_test/ENC0029-safe_func_warning/safe_func_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..18f89777dfb75db5dea2e2c29ca1d59062669dd6
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0029-safe_func_warning/safe_func_warning.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+__Safe__ void func1(void);
+__Unsafe__ void func2(void);
+
+
+__Unsafe__ void func1(void) { // CHECK: [[# @LINE]] error
+  int a = 0;
+  __Safe__ {
+    a += 1;
+  }
+}
+
+__Safe__ void func2(void) { // CHECK: [[# @LINE]] error
+  int a = 0;
+  __Safe__ {
+    a += 1;
+  }
+}
+
+__Safe__ void func3(void);
+
+void func3(void) { // CHECK-NOT: [[# @LINE]] error
+}
+
+void func4(void);
+
+__Safe__ void func4(void) { // CHECK-NOT: [[# @LINE]] error
+}
+
+__attribute__((count_index(2, 1)))
+__Safe__ extern int func5(char *a, int b);
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0029-safe_func_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0029-safe_func_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0efff4f6a2fe0e53945818aad2519e3086773a62
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0029-safe_func_warning/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile_err(safe_func_warning)
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck safe_func_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0030-nonnull_check_if_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0030-nonnull_check_if_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0030-nonnull_check_if_err/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0030-nonnull_check_if_err/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..b0ff0ac638ff2987b0d509b84532d2503640ddfa
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0030-nonnull_check_if_err/nonnull_check_if_err.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+
+#include <stddef.h>
+
+/* check if */
+int test(int *x) {
+  if (x == NULL) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertnonnull <&test> (dread ptr %x)
+    return *x; // expected-warning
+  }
+  return 0;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0030-nonnull_check_if_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0030-nonnull_check_if_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a97175c1e8376f516424d02c31079715d54baf75
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0030-nonnull_check_if_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile_err(nonnull_check_if_err)
+cat nonnull_check_if_err.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_if_err.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of null pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0031-nonnull_check_if_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0031-nonnull_check_if_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0031-nonnull_check_if_err/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0031-nonnull_check_if_err/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..618f0f7137d16a50d17ebff5d223a5c440232f4e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0031-nonnull_check_if_err/nonnull_check_if_err.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+
+#include <stddef.h>
+
+int test2(int *x) {
+    if (x) {
+        return 0;
+    }
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertnonnull <&test2> (dread ptr %x)
+    return *x; // expected-warning
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0031-nonnull_check_if_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0031-nonnull_check_if_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a97175c1e8376f516424d02c31079715d54baf75
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0031-nonnull_check_if_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile_err(nonnull_check_if_err)
+cat nonnull_check_if_err.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_if_err.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of null pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0032-nonnull_check_if_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0032-nonnull_check_if_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0032-nonnull_check_if_err/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0032-nonnull_check_if_err/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..4e3ef7e3bf341167e344c78f457b79a765102045
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0032-nonnull_check_if_err/nonnull_check_if_err.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+
+#include <stddef.h>
+
+int test3(int *x) {
+  if (x != NULL) {
+    return 0;
+  } else {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertnonnull <&test3> (dread ptr %x)
+    return *x; // expected-warning
+  }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0032-nonnull_check_if_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0032-nonnull_check_if_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a97175c1e8376f516424d02c31079715d54baf75
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0032-nonnull_check_if_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile_err(nonnull_check_if_err)
+cat nonnull_check_if_err.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_if_err.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of null pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0033-nonnull_check_if_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0033-nonnull_check_if_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0033-nonnull_check_if_err/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0033-nonnull_check_if_err/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..b747543eca954fac8e8161ca43008abc86ff49a0
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0033-nonnull_check_if_err/nonnull_check_if_err.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+
+#include <stddef.h>
+
+/*  check if or */
+int test4(int *a, int b) {
+  if (a != NULL || b > 0) {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: assertnonnull <&test4> (dread ptr %a)
+    return *a + b; // expected-warning
+  }
+  return b;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0033-nonnull_check_if_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0033-nonnull_check_if_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3531800949ec88e72958f81392761dfc8761103f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0033-nonnull_check_if_err/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_check_if_err)
+cat nonnull_check_if_err.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_if_err.c
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assertnonnull"  --result=nonnull_check_if_err.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of nullable pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0034-nonnull_check_if_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0034-nonnull_check_if_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0034-nonnull_check_if_err/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0034-nonnull_check_if_err/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..26ea8d22186b2da529b68a11151b3e37eb9721cd
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0034-nonnull_check_if_err/nonnull_check_if_err.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+
+#include <stddef.h>
+
+/*  check if and */
+int test5(int *a, int *b) {
+  if (a == NULL && b == NULL) {
+    return 0;
+  } else {
+    // expected-warning
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+    // CHECK-NEXT: assertnonnull <&test5> (dread ptr %a)
+    // CHECK: assertnonnull <&test5> (dread ptr %b)
+    return *a + *b;
+  }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0034-nonnull_check_if_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0034-nonnull_check_if_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..19cf935001087cc25e65efc00ae1ce67c0b68e51
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0034-nonnull_check_if_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(nonnull_check_if_err)
+cat nonnull_check_if_err.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_if_err.c
+python3 ${TEST_BIN}/check.py --check=num  --n=2 --str="Dereference of nullable pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0035-nonnull_check_if_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0035-nonnull_check_if_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0035-nonnull_check_if_err/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0035-nonnull_check_if_err/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..b4ab33556d23065053c1ca0e1a64df219603e665
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0035-nonnull_check_if_err/nonnull_check_if_err.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+
+#include <stddef.h>
+
+/* check nested if */
+int test6(int *p, int *q) {
+  if (p != 0) {
+    if (q != 0) {
+                return 0;
+        }
+        // CHECK: LOC [[# FILENUM]] [[# @LINE + 3 ]]
+        // CHECK-NEXT: assertnonnull <&test6> (dread ptr %q)
+        // CHECK: assertnonnull <&test6> (dread ptr %p)
+        *p = *q; // expected-warning
+  }
+  return 0;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0035-nonnull_check_if_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0035-nonnull_check_if_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a97175c1e8376f516424d02c31079715d54baf75
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0035-nonnull_check_if_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile_err(nonnull_check_if_err)
+cat nonnull_check_if_err.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_if_err.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of null pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0036-ABCO_byte_count/expected.txt b/testsuite/c_test/enhancec_test/ENC0036-ABCO_byte_count/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0036-ABCO_byte_count/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0036-ABCO_byte_count/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..45956321138c8d5bba2e3424e2374ece9ce163d8
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0036-ABCO_byte_count/nonnull_check_if_err.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+#include <stdio.h>
+#include <stdlib.h>
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+
+#define ARG_LEN 16
+#define RET_LEN 16
+#define ARG_BYTE_COUNT (ARG_LEN * sizeof (char))
+#define RET_BYTE_COUNT (RET_LEN * sizeof(int))
+#define NUM 2
+#define OFFSET ARG_LEN
+
+int g_arg_count = ARG_BYTE_COUNT - 1;
+
+__attribute__((count("arg_len", 1)))
+int* func(char* arg, int arg_len, int ret_len) __attribute__((returns_byte_count("ret_len")));
+
+int* func(char* arg, int arg_len, int ret_len)
+{
+    for (int i = 0; i < arg_len; i++) {
+        arg[i] = 1;
+    }
+    ret_len = ret_len / sizeof(int);
+    int* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, int);
+    int* ret = ret_p;
+    return ret;
+}
+
+int main(int argc, char* argv[])
+{
+    int arg_len = ARG_LEN + OFFSET;
+    int ret_len = RET_LEN;
+    char* arg __attribute__((count(arg_len))) = MALLOC(arg_len, char);
+    if (argc != 1) {
+        arg_len = ARG_LEN * NUM + OFFSET;
+    }
+    int* ret = func(arg + OFFSET, arg_len, ret_len * sizeof(int));
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0036-ABCO_byte_count/test.cfg b/testsuite/c_test/enhancec_test/ENC0036-ABCO_byte_count/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..88e5bb987dd33d7c05298d6fe77faa8e0259a02a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0036-ABCO_byte_count/test.cfg
@@ -0,0 +1,6 @@
+ENCO2_N_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
+ENCO2_B_D:
+compile_err(nonnull_check_if_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="error: the pointer's bounds does not match the function func declaration for the 1st argument"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0037-ABCO_byte_count/expected.txt b/testsuite/c_test/enhancec_test/ENC0037-ABCO_byte_count/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0037-ABCO_byte_count/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0037-ABCO_byte_count/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..55f0ec4d6b0342aacd605f2e397e220e4d6e0245
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0037-ABCO_byte_count/nonnull_check_if_err.c
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+
+#define ARG_LEN 16
+#define RET_LEN 16
+#define ARG_BYTE_COUNT (ARG_LEN * sizeof(long))
+#define RET_BYTE_COUNT (RET_LEN * sizeof(float))
+#define NUM 2
+
+int g_arg_count = ARG_BYTE_COUNT - 1;
+
+float* __attribute__((count(ARG_LEN))) func(long* arg, int ret_len) \
+__attribute__((returns_count_index(2)));
+
+float* func(long* arg, int ret_len)
+{
+    for (int i = 0; i < ARG_LEN; i++) {
+        arg[i] = 1;
+    }
+    ret_len = ret_len * sizeof(float) / sizeof(double);
+    double* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, double);
+    double* ret = ret_p;
+    return (float*)ret;
+}
+
+int main(int argc, char* argv[])
+{
+    int arg_len = ARG_LEN;
+    if (argc != 1) {
+        arg_len = ARG_LEN / 2;
+    }
+    arg_len = arg_len * sizeof(long) / sizeof(char);
+    char* arg_p __attribute__((count(arg_len))) = MALLOC(arg_len, char);
+    char* arg = arg_p;
+    float * ret = func((long*)arg, RET_LEN);
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0037-ABCO_byte_count/test.cfg b/testsuite/c_test/enhancec_test/ENC0037-ABCO_byte_count/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..09579c82c5c90f5627c787fe0767b05c5bc0b528
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0037-ABCO_byte_count/test.cfg
@@ -0,0 +1,6 @@
+ENCO2_N_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0038-nonnull_check_ternary_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0038-nonnull_check_ternary_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0038-nonnull_check_ternary_err/nonnull_check_ternary_err.c b/testsuite/c_test/enhancec_test/ENC0038-nonnull_check_ternary_err/nonnull_check_ternary_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..69167b3440ebb80bfc321bed23646b454c0f9494
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0038-nonnull_check_ternary_err/nonnull_check_ternary_err.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_ternary_err.c"
+
+#include <stddef.h>
+int test(int *x, int *y) __attribute__((nonnull(2))) {
+  // expected-warning
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertnonnull <&test> (dread ptr %x)
+  return ((x == NULL) ? (*x > 0) : (*y == 0));
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0038-nonnull_check_ternary_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0038-nonnull_check_ternary_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b476e0bed302620194b57821b00095b6c4548a1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0038-nonnull_check_ternary_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile_err(nonnull_check_ternary_err)
+cat nonnull_check_ternary_err.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_ternary_err.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of null pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_ternary_err)
+run(nonnull_check_ternary_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0039-nonnull_check_ternary_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0039-nonnull_check_ternary_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0039-nonnull_check_ternary_err/nonnull_check_ternary_err.c b/testsuite/c_test/enhancec_test/ENC0039-nonnull_check_ternary_err/nonnull_check_ternary_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..54dcd9e3d0df45ad51e525dcca8b2d3038dcafdc
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0039-nonnull_check_ternary_err/nonnull_check_ternary_err.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_ternary_err.c"
+
+#include <stddef.h>
+int test1(int *a, int b) {
+  // expected-warning
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertnonnull <&test1> (dread ptr %a)
+  return (a != NULL) ? b : *a;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0039-nonnull_check_ternary_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0039-nonnull_check_ternary_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b476e0bed302620194b57821b00095b6c4548a1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0039-nonnull_check_ternary_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile_err(nonnull_check_ternary_err)
+cat nonnull_check_ternary_err.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_ternary_err.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of null pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_ternary_err)
+run(nonnull_check_ternary_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0040-nonnull_check_ternary_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0040-nonnull_check_ternary_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0040-nonnull_check_ternary_err/nonnull_check_ternary_err.c b/testsuite/c_test/enhancec_test/ENC0040-nonnull_check_ternary_err/nonnull_check_ternary_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..027b070344cfcd65cdfff3da8d8cd95186deaf99
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0040-nonnull_check_ternary_err/nonnull_check_ternary_err.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_ternary_err.c"
+
+#include <stddef.h>
+
+int test2(int *a, int b) {
+  // expected-warning
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertnonnull <&test2> (dread ptr %a)
+  return (a == NULL) ? *a : b;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0040-nonnull_check_ternary_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0040-nonnull_check_ternary_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b476e0bed302620194b57821b00095b6c4548a1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0040-nonnull_check_ternary_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile_err(nonnull_check_ternary_err)
+cat nonnull_check_ternary_err.mpl | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_ternary_err.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="Dereference of null pointer"  --result=compile.log
+ENCO2_B_D:
+compile(nonnull_check_ternary_err)
+run(nonnull_check_ternary_err)
diff --git a/testsuite/c_test/enhancec_test/ENC0041-ABCO_opt_lower_bound_err/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0041-ABCO_opt_lower_bound_err/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..4491ecab64aa57aefb078a89dd7327027b599c67
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0041-ABCO_opt_lower_bound_err/boundary_count_insert.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+int test3(int len, int *p) {
+  if (len != 1) {
+    return 0;
+  }
+  int res = 0;
+  for (int i = 0; i <= 10; i++) {
+    for (int j = 4; ; j++) {
+      switch (j) {
+        case 5:
+          res += p[j - 4];
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return res;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0041-ABCO_opt_lower_bound_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0041-ABCO_opt_lower_bound_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3d98e51213e5900a1569a5b2b659640f2d33b515
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0041-ABCO_opt_lower_bound_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_insert.c:28 error: the pointer >= the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0042-ABCO_opt_lower_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0042-ABCO_opt_lower_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..d67dec600e845608385407b141f0e062320c0b25
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0042-ABCO_opt_lower_bound/boundary_count_insert.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+int test1(int len, int *p, int lo) {
+  int res = 0;
+  if (len != 1) {
+    return res;
+  }
+  for (int i = 10; i <= 20; i++) {
+    for (int j = 4; j < i - 5; j++) {
+      res += p[j - 4];
+    }
+  }
+  return res;
+}
+
+int main() {
+  int a[1] = {1};
+  int *p = &a;
+  test1(1, p, 1);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0042-ABCO_opt_lower_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0042-ABCO_opt_lower_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9fdbe6b656dd1788e7b2484bb6430f1d2eebdc6c
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0042-ABCO_opt_lower_bound/test.cfg
@@ -0,0 +1,2 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
diff --git a/testsuite/c_test/enhancec_test/ENC0043-ABCO_opt_lower_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0043-ABCO_opt_lower_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..262517f41c25f33a757430d17b0d7fa886747f2d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0043-ABCO_opt_lower_bound/boundary_count_insert.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  for (int i = len; i >= 0; --i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+int main() {
+  int a[5] = {1, 2};
+  int *p = &a;
+  test1(2, p);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0043-ABCO_opt_lower_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0043-ABCO_opt_lower_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..da6ed64aeabb56fb4a9e579bbe39cb5d4b9998fd
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0043-ABCO_opt_lower_bound/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_insert.c:21 error: the pointer >= the upper bounds when accessing the memory and inlined to main"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0044-ABCO_opt_lower_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0044-ABCO_opt_lower_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..1c38b3eabc50c987b5f16dc9b23e9dc4b79de8c3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0044-ABCO_opt_lower_bound/boundary_count_insert.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  for (int i = len + 1; i > -1; --i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+int main() {
+  int a[5] = {1, 2, 3, 4, 5};
+  test1(5, a);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0044-ABCO_opt_lower_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0044-ABCO_opt_lower_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..04960a09b7562595a6368390b009bbd5562e4db3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0044-ABCO_opt_lower_bound/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_insert.c:21 error: the pointer >= the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0045-ABCO_opt_lower_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0045-ABCO_opt_lower_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..399aa27f43ea0ac279f6aa21e64bf7d76d62810d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0045-ABCO_opt_lower_bound/boundary_count_insert.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  for (int i = 0; i != len + 1; ++i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0045-ABCO_opt_lower_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0045-ABCO_opt_lower_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..04960a09b7562595a6368390b009bbd5562e4db3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0045-ABCO_opt_lower_bound/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_insert.c:21 error: the pointer >= the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0046-ABCO_opt_lower_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0046-ABCO_opt_lower_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..9aeb01e7ab9fbe1183a08ef00f67bbd10d4612b2
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0046-ABCO_opt_lower_bound/boundary_count_insert.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  for (int i = len + 1; i != -1; --i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0046-ABCO_opt_lower_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0046-ABCO_opt_lower_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..04960a09b7562595a6368390b009bbd5562e4db3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0046-ABCO_opt_lower_bound/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_insert.c:21 error: the pointer >= the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0047-ABCO_opt_lower_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0047-ABCO_opt_lower_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..d55d3c3181ffa503073de912ba0cf252ed3f7306
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0047-ABCO_opt_lower_bound/boundary_count_insert.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  for (int i = 0; i < len + 5; ++i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0047-ABCO_opt_lower_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0047-ABCO_opt_lower_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..04960a09b7562595a6368390b009bbd5562e4db3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0047-ABCO_opt_lower_bound/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_insert.c:21 error: the pointer >= the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0048-ABCO_opt_lower_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0048-ABCO_opt_lower_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..40b70c9d8b4c7abec3c7c5a0ce75da248654063b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0048-ABCO_opt_lower_bound/boundary_count_insert.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  for (int i = 0; i <= len; ++i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0048-ABCO_opt_lower_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0048-ABCO_opt_lower_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..04960a09b7562595a6368390b009bbd5562e4db3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0048-ABCO_opt_lower_bound/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_insert.c:21 error: the pointer >= the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0049-ABCO_opt_upper_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0049-ABCO_opt_upper_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..21a05ae38a0218a2c5d2e1b81b98e258f58af9d5
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0049-ABCO_opt_upper_bound/boundary_count_insert.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+void test1(int len, int *p) {
+  for (int i = len - 1; i >= -1; --i) {
+    printf("%d\n", p[i]);
+  }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0049-ABCO_opt_upper_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0049-ABCO_opt_upper_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5ca942b519f1368075b5f443e2eb543eed2d789e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0049-ABCO_opt_upper_bound/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_insert.c:21 error: the pointer < the lower bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0050-ABCO_opt_upper_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0050-ABCO_opt_upper_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..9668cfb7cdfd89dd4cb5125fb8f442c50ccb7f1a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0050-ABCO_opt_upper_bound/boundary_count_insert.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+int test3(int len, int *p) {
+  if (len != 1) {
+    return 0;
+  }
+  int res = 0;
+  for (int i = 0; i <= 10; i++) {
+    for (int j = 4; j < i - 5 ; j++) {
+      res += p[j - 4];
+    }
+  }
+  return res;
+}
+
+int main() {
+  int a[5] = {1, 2, 3, 4, 5};
+  int d[1] = {1};
+  int i = 1;
+  test3(1, &d);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0050-ABCO_opt_upper_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0050-ABCO_opt_upper_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cbaf77c84704edc0aecdd5654f770fecafb66181
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0050-ABCO_opt_upper_bound/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile(boundary_count_insert)
+run_err(boundary_count_insert)
diff --git a/testsuite/c_test/enhancec_test/ENC0051-ABCO_opt_upper_bound/boundary_count_insert.c b/testsuite/c_test/enhancec_test/ENC0051-ABCO_opt_upper_bound/boundary_count_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..79109b7917413a17577dc3f434b228035ff9a2c3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0051-ABCO_opt_upper_bound/boundary_count_insert.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+__attribute__((count("len", 2)))
+int test2(int len, int *p) {
+  if (len != 1) {
+    return 0;
+  }
+  int res = 0;
+  for (int i = 0; i <= 10; i++) {
+    for (int j = 4; ; j--) {
+      switch (j) {
+        case 2:
+          res += p[j - 4];
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return res;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0051-ABCO_opt_upper_bound/test.cfg b/testsuite/c_test/enhancec_test/ENC0051-ABCO_opt_upper_bound/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cee73a47f31364d352085647b71abd2587ccee79
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0051-ABCO_opt_upper_bound/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_count_insert)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_insert.c:28 error: the pointer < the lower bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0052-boundary_count_malloc/boundary_count_malloc.c b/testsuite/c_test/enhancec_test/ENC0052-boundary_count_malloc/boundary_count_malloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..ad47f4bffcbc3e0774242fb1fa1b73736b818295
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0052-boundary_count_malloc/boundary_count_malloc.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdlib.h>
+__attribute__((noinline))
+int get(int *buf __attribute__((count(10)))) {
+  return buf[9];
+}
+
+int main() {
+  int *q;
+  int *p __attribute__((count(6)));
+
+  int *D = malloc(sizeof(int) * 10);
+  get(D);  // CHECK-NOT: [[# @LINE ]] error
+
+  int *F = calloc(sizeof(int), 10);
+
+  get(F);  // CHECK-NOT: [[# @LINE ]] error
+
+  int *E = malloc(sizeof(int) * 3);
+  get(E);  // CHECK: [[# @LINE ]] error
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0052-boundary_count_malloc/expected.txt b/testsuite/c_test/enhancec_test/ENC0052-boundary_count_malloc/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0052-boundary_count_malloc/test.cfg b/testsuite/c_test/enhancec_test/ENC0052-boundary_count_malloc/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e8b9c07a12eed2c9115971b3cabd16dd5e5e3046
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0052-boundary_count_malloc/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_count_malloc)
+run(boundary_count_malloc)
+ENCO2_B_D:
+compile_err(boundary_count_malloc)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_malloc.c
diff --git a/testsuite/c_test/enhancec_test/ENC0053-nonnull_malloc_cast/boundary_count_malloc.c b/testsuite/c_test/enhancec_test/ENC0053-nonnull_malloc_cast/boundary_count_malloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..6ef8f71e5dc98aee32e00cec66688992aee00c46
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0053-nonnull_malloc_cast/boundary_count_malloc.c
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+struct A {
+  int *i __attribute__((nonnull));
+  int *j;
+};
+
+struct B {
+  int *i;
+  int *j;
+};
+
+struct C {
+  int *k;
+  struct A a;
+};
+
+struct B* cvt(struct A *a) {
+  if (a == NULL) { // CHECK-NOT: [[# @LINE ]] error
+    return NULL;
+  }
+  return (struct B*)a;
+}
+
+struct A* cvt1(struct B *b) {
+  (struct A*)b; // CHECK-NOT: [[# @LINE ]] error
+  return (struct A*)b;  // CHECK: [[# @LINE ]] error
+}
+
+
+__attribute__((noinline))
+int get(int *buf __attribute__((count(10)))) {
+  return buf[9];
+}
+
+int main() {
+  struct A *a = (struct A*)malloc(sizeof(struct A)); // CHECK: [[# @LINE ]] error
+  bzero((void*)a, sizeof(struct A));  // CHECK: [[# @LINE ]] error
+  memset(a, 0, sizeof(struct A));  // CHECK: [[# @LINE ]] error
+
+  struct B *b = (struct B*)malloc(sizeof(struct B));  // CHECK-NOT: [[# @LINE ]] error
+  bzero((void*)b, sizeof(struct B));  // CHECK-NOT: [[# @LINE ]] error
+  memset(b, 0, sizeof(struct B));  // CHECK-NOT: [[# @LINE ]] error
+
+  struct C *c = malloc(sizeof(struct C));  // CHECK: [[# @LINE ]] error
+  bzero((void*)c, sizeof(struct C));  // CHECK: [[# @LINE ]] error
+  memset(c, 0, sizeof(struct C));  // CHECK: [[# @LINE ]] error
+
+  b = cvt(a);  // CHECK-NOT: [[# @LINE ]] error
+  b = cvt(b);  // CHECK: [[# @LINE ]] error
+  a = cvt(a);  // CHECK: [[# @LINE ]] error
+
+
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0053-nonnull_malloc_cast/expected.txt b/testsuite/c_test/enhancec_test/ENC0053-nonnull_malloc_cast/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0053-nonnull_malloc_cast/test.cfg b/testsuite/c_test/enhancec_test/ENC0053-nonnull_malloc_cast/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a437a5c128217ee361ec95e4e0bd4739496a5552
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0053-nonnull_malloc_cast/test.cfg
@@ -0,0 +1,6 @@
+ENCO2_N_D:
+compile_err(boundary_count_malloc)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_malloc.c
+ENCO2_B_D:
+compile(boundary_count_malloc)
diff --git a/testsuite/c_test/enhancec_test/ENC0054-boundary_count_call_insert_err/boundary_count_call_insert.c b/testsuite/c_test/enhancec_test/ENC0054-boundary_count_call_insert_err/boundary_count_call_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..2bab6dab2d338360fb629feed7f797c1ff13bd64
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0054-boundary_count_call_insert_err/boundary_count_call_insert.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_call_insert.c"
+
+#include <stdio.h>
+
+struct S {
+  char info[2];
+  long a, b;
+  char tag[2];
+};
+
+struct A {
+  char info[2];
+  short s;
+};
+
+__attribute__((count(10)))
+void f(char *buf) {
+  return;
+}
+
+void bar() {
+  char array[12];
+  char array2d[3][12];
+  struct A a;
+
+  char *m = &array2d[2][3];
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertle{{.*}}
+  f(m);  // expected-warning
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0054-boundary_count_call_insert_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0054-boundary_count_call_insert_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0054-boundary_count_call_insert_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0054-boundary_count_call_insert_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..23c9a7e83b42c102daa90acba1e814bddc1ac4e4
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0054-boundary_count_call_insert_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_count_call_insert)
+run(boundary_count_call_insert)
+ENCO2_B_D:
+compile_err(boundary_count_call_insert)
+cat boundary_count_call_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_call_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str=""boundary_count_call_insert.c:45 error: can't prove pointer's bounds match the function f declaration for the 1st argument  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0055-boundary_count_call_insert_err/boundary_count_call_insert.c b/testsuite/c_test/enhancec_test/ENC0055-boundary_count_call_insert_err/boundary_count_call_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..a38c06b369cd0f846a3dbdc5a2dc42b7b11c9c8b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0055-boundary_count_call_insert_err/boundary_count_call_insert.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_call_insert.c"
+
+#include <stdio.h>
+
+int get(int *buf __attribute__((count(10)))) {
+  return buf[1];
+}
+
+void foo(int w, int x, int y, int z) {
+  int C[5] = {0};
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: callassertle{{.*}}
+  get(C);  // expected-warning
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0055-boundary_count_call_insert_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0055-boundary_count_call_insert_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0055-boundary_count_call_insert_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0055-boundary_count_call_insert_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a88221fbd23cda71fa9917ef9ffa0801e9390074
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0055-boundary_count_call_insert_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_count_call_insert)
+run(boundary_count_call_insert)
+ENCO2_B_D:
+compile_err(boundary_count_call_insert)
+cat boundary_count_call_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_call_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_call_insert.c:29 error: the pointer's bounds does not match the function get declaration for the 1st argument"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0056-boundary_count_call_insert_err/boundary_count_call_insert.c b/testsuite/c_test/enhancec_test/ENC0056-boundary_count_call_insert_err/boundary_count_call_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..28502dd42c9d19b184baf8e967a3cf39ae2dfbaf
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0056-boundary_count_call_insert_err/boundary_count_call_insert.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_call_insert.c"
+
+#include <stdio.h>
+
+int get(int *buf __attribute__((count(10)))) {
+  return buf[1];
+}
+
+void foo(int w, int x, int y, int z) {
+  int C[5] = {0};
+  int *L = C;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: callassertle{{.*}}
+  get(L);  // expected-warning
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0056-boundary_count_call_insert_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0056-boundary_count_call_insert_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0056-boundary_count_call_insert_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0056-boundary_count_call_insert_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..71ffc8e769074a35d7711ac5a494f2a28ffc43b2
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0056-boundary_count_call_insert_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_count_call_insert)
+run(boundary_count_call_insert)
+ENCO2_B_D:
+compile_err(boundary_count_call_insert)
+cat boundary_count_call_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_call_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_call_insert.c:30 error: the pointer's bounds does not match the function get declaration for the 1st argument"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0057-boundary_count_call_insert_err/boundary_count_call_insert.c b/testsuite/c_test/enhancec_test/ENC0057-boundary_count_call_insert_err/boundary_count_call_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..8d9d5f5a356b19948c719adbbd7fd36e42d4363a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0057-boundary_count_call_insert_err/boundary_count_call_insert.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_call_insert.c"
+
+#include <stdio.h>
+
+struct S {
+  char info[2];
+  long a, b;
+  char tag[2];
+};
+
+struct A {
+  char info[2];
+  short s;
+};
+
+__attribute__((count(10)))
+void f(char *buf) {
+  return;
+}
+
+void bar() {
+  char array[12];
+  char array2d[3][12];
+  struct A a;
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertle{{.*}}
+  f(&array[0]);
+  char *x = &array[0];
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertle{{.*}}
+  f(x);
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertle{{.*}}
+  f(array2d[0]);
+  char *y = array2d[0];
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertle{{.*}}
+  f(y);
+
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertle{{.*}}
+  f(a.info);  // expected-warning 
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0057-boundary_count_call_insert_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0057-boundary_count_call_insert_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0057-boundary_count_call_insert_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0057-boundary_count_call_insert_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..18925d1c3da81037e7b0200efd85289256498392
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0057-boundary_count_call_insert_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_count_call_insert)
+run(boundary_count_call_insert)
+ENCO2_B_D:
+compile_err(boundary_count_call_insert)
+cat boundary_count_call_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_call_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="the pointer's bounds does not match the function f declaration for the 1st argument"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0058-boundary_count_call_insert_err/boundary_count_call_insert.c b/testsuite/c_test/enhancec_test/ENC0058-boundary_count_call_insert_err/boundary_count_call_insert.c
new file mode 100644
index 0000000000000000000000000000000000000000..739a05ca1d31486e2c7a3013ea9589f40b54974c
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0058-boundary_count_call_insert_err/boundary_count_call_insert.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_count_call_insert.c"
+
+#include <stdio.h>
+
+struct S {
+  char info[2];
+  long a, b;
+  char tag[2];
+};
+
+struct A {
+  char info[2];
+  short s;
+};
+
+__attribute__((count(10)))
+void f(char *buf) {
+  return;
+}
+
+void bar() {
+  char array[12];
+  char array2d[3][12];
+  struct A a;
+
+  char *z = a.info;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertle{{.*}}
+  f(z);  // expected-warning 
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0058-boundary_count_call_insert_err/expected.txt b/testsuite/c_test/enhancec_test/ENC0058-boundary_count_call_insert_err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0058-boundary_count_call_insert_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0058-boundary_count_call_insert_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..104ea1a52c017cb4ad3fc143e9934cd32432632d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0058-boundary_count_call_insert_err/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_count_call_insert)
+run(boundary_count_call_insert)
+ENCO2_B_D:
+compile_err(boundary_count_call_insert)
+cat boundary_count_call_insert.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_call_insert.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="boundary_count_call_insert.c:45 error: the pointer's bounds does not match the function f declaration for the 1st argument"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0059-nonnull_check_call_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0059-nonnull_check_call_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..75633a4612501b50dc3fb37c5efbd39eae2e71b3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0059-nonnull_check_call_err/nonnull_check_call_err.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+int test(int *x, int *y) __attribute__((nonnull(2))) {
+  return *y;
+}
+
+int main() {
+  int *p = malloc(sizeof(int));
+  int *q = NULL;
+  test(p, q); // error: NULL passed to a callee that requires a nonnull argument
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0059-nonnull_check_call_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0059-nonnull_check_call_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c0a1a8a436507d88d90ee0080f0fc8671d39e32
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0059-nonnull_check_call_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_N_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:24 error: NULL passed to test that requires a nonnull pointer for 2nd argument"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0060-nonnull_assign_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0060-nonnull_assign_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..d5b71d64783fa9153c73eca78070f70bcf01c811
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0060-nonnull_assign_err/nonnull_check_call_err.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int a = 1;
+  int *q;
+  int *p __attribute__((nonnull)) = malloc(sizeof(int));
+  if (a == 1) {
+    q = NULL;
+  }
+  p = q; // error: NULL passed to a callee that requires a nonnull argument
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0060-nonnull_assign_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0060-nonnull_assign_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..df12114e75e3c1b92ce80c86c4873f6c0b0dfff3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0060-nonnull_assign_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_N_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:24 error: null assignment of nonnull pointer"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0061-nonnull_funcptr_assign_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0061-nonnull_funcptr_assign_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..87f32053a9186a0037ae1902a64d899ec8fe14bf
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0061-nonnull_funcptr_assign_err/nonnull_check_call_err.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+__attribute__((returns_nonnull))
+int *GetNonnull() {
+  int *i = malloc(sizeof(int));
+  return i;
+}
+
+__attribute__((returns_nonnull))
+int* Test(int i) {
+    int *p = NULL;
+    if (i == 0) {
+        return GetNonnull();
+    } else {
+    	return p;
+    }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0061-nonnull_funcptr_assign_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0061-nonnull_funcptr_assign_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..07ff41c5f32857b9111a4e8b401ddbe5a790659b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0061-nonnull_funcptr_assign_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_N_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:29 error: Test return nonnull but got null pointer"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0062-boundary_assign_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0062-boundary_assign_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..d9aa9cbe3befa7377e89debbcfbda32d901bd595
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0062-boundary_assign_err/nonnull_check_call_err.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int *q __attribute__((count(5)));
+  int *p __attribute__((count(6))) = q;
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0062-boundary_assign_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0062-boundary_assign_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f05b8dcea055b65a0a95c0fcde0f8cba06cac882
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0062-boundary_assign_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:19 error: l-value boundary should not be larger than r-value boundary"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0063-boundary_from_multibranch_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0063-boundary_from_multibranch_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..16dc84c17bdecebb37b95e2db86351b9a9874fff
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0063-boundary_from_multibranch_err/nonnull_check_call_err.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((count(10, 1)))
+void func1(int* p) {
+  printf("func1");
+}
+
+int main() {
+  int *q;
+  int *l = NULL;
+  int *p __attribute__((count(10))) = malloc(sizeof(int) * 10);
+  if (*p) {
+    q = p;
+  } else {
+    q = l;
+  }
+  func1(q);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0063-boundary_from_multibranch_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0063-boundary_from_multibranch_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bde73a61decf3a9bb66fb5b3187cb76375572a7d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0063-boundary_from_multibranch_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="error: pointer assigned from multibranch requires the boundary info for all branches."  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:32" --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:30" --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0064-boundary_from_multibranch_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0064-boundary_from_multibranch_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..43f0404bbb31daa4fbb874548a186b6374f5986e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0064-boundary_from_multibranch_err/nonnull_check_call_err.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((count(10, 1)))
+void func1(int* p) {
+  printf("func1");
+}
+
+int main() {
+  int *q;
+  int *l = NULL;
+  int *p __attribute__((count(10))) = malloc(sizeof(int) * 10);
+  if (*p) {
+    q = l;
+  } else {
+    q = p;
+  }
+  func1(q);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0064-boundary_from_multibranch_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0064-boundary_from_multibranch_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d5b49e5c1ae2a8f3d165261fbf698df13a183415
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0064-boundary_from_multibranch_err/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_B_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="error: pointer assigned from multibranch requires the boundary info for all branches."  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:32" --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0065-boundary_func_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0065-boundary_func_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..b7572f0a407b093d13bd99b37267352c2835301a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0065-boundary_func_err/nonnull_check_call_err.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((returns_count(10)))
+int *func1() {
+  int *p __attribute__((count(5))) = malloc(sizeof(int) * 5);
+  return p;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0065-boundary_func_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0065-boundary_func_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9a899bd8dbfc98b60fa79fbf8ce8aac178db24cd
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0065-boundary_func_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:21 error: return value's bounds does not match the function declaration for func1"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0066-boundary_func_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0066-boundary_func_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f233c485ab436049bfc027e3445ecce9b78b077
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0066-boundary_func_err/nonnull_check_call_err.c
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main() {
+  int *p __attribute__((count(5)));
+  float *q __attribute__((count(2)));
+
+  p = (float*) q;
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0066-boundary_func_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0066-boundary_func_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f19d75faf8e13a71554cd8b7445e396bcce8d54
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0066-boundary_func_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:21 error: l-value boundary should not be larger than r-value boundary"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0067-boundary_func_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0067-boundary_func_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..847f9acf3c0642fcec6a55c1b0399738520b7d53
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0067-boundary_func_err/nonnull_check_call_err.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((count(10, 1)))
+void func1(int* p) {
+  printf("func1");
+}
+
+int main() {
+  int *q;
+  int *l = NULL;
+  int *p __attribute__((count(9))) = malloc(sizeof(int) * 9);
+  func1(p);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0067-boundary_func_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0067-boundary_func_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4b12025e29a2e2faafb2a215059c7972518804f7
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0067-boundary_func_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:27 error: the pointer's bounds does not match the function func1 declaration for the 1st argument"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0068-boundary_operator_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0068-boundary_operator_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..5f84572271a3f57f208aff8b4ae4a2411eec5ea1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0068-boundary_operator_err/nonnull_check_call_err.c
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  int *q __attribute__((count(5))) = malloc(sizeof(int) * 5);
+  int *p = q + 6;
+  printf("%d", *p);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0068-boundary_operator_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0068-boundary_operator_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc3b64d40f67f320576cb8529ad0d5065b7de3fb
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0068-boundary_operator_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:21 error: the pointer >= the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0069-boundary_func_retrun_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0069-boundary_func_retrun_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..39e17e1d6970a6d6acfcfea4d0f97a699d814a8d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0069-boundary_func_retrun_err/nonnull_check_call_err.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((returns_count(10)))
+int* func(int *arg) {
+  int *q;
+  if (*arg) {
+    int *p __attribute__((count(5))) = malloc(sizeof(int) * 5);
+    q = p;
+  } else {
+    int *p __attribute__((count(10))) = malloc(sizeof(int) * 10);
+    q = p;
+  }
+  return q;
+}
+
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0069-boundary_func_retrun_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0069-boundary_func_retrun_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..722f753713bc8c9a50e8c7e572baae2017038e95
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0069-boundary_func_retrun_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="can't prove return value's bounds match the function declaration for func"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0070-safe_region_boundary_unsafe/boundary_unsafe.c b/testsuite/c_test/enhancec_test/ENC0070-safe_region_boundary_unsafe/boundary_unsafe.c
new file mode 100644
index 0000000000000000000000000000000000000000..34650395e20d6756089bda543d23589f0d29b184
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0070-safe_region_boundary_unsafe/boundary_unsafe.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int *func(int *p, int len)  __attribute__((count("len", 1))) {
+  return p;
+}
+
+__attribute__((returns_count(5)))
+int* test() {
+  int i = 1;
+  int *p = &i;
+  __Unsafe__ {
+    func(p, 2);
+  return p;
+  }
+}
+
+__Unsafe__ int main() {
+  int *q __attribute__((count(5))) = malloc(sizeof(int) * 5);
+  int *p = q + 6;
+
+  int i = 1;
+  int *w = &i;
+  func(w, 2);
+  q = w;
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0070-safe_region_boundary_unsafe/test.cfg b/testsuite/c_test/enhancec_test/ENC0070-safe_region_boundary_unsafe/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..552e0d812890d54ac51684979d1f6538a8824fef
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0070-safe_region_boundary_unsafe/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile(boundary_unsafe)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assert"  --result=boundary_unsafe.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0071-safe_region_boundary_safe_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0071-safe_region_boundary_safe_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..b1f63fa558a2ad4727ab71d56edc87301a0b7be1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0071-safe_region_boundary_safe_err/nonnull_check_call_err.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((returns_count(5)))
+int* func() {
+  return (int*) malloc(sizeof(int) * 5);
+}
+
+__Safe__ int main() {
+  int *q __attribute__((count(5))) = func();
+  int *p = q + 6;
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0071-safe_region_boundary_safe_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0071-safe_region_boundary_safe_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d88a2bb76a313f2fae1d5f7d4c735757e5dd852a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0071-safe_region_boundary_safe_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c 24 error: call unsafe function func from safe region that requires safe function"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0072-safe_region_boundary_safeop_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0072-safe_region_boundary_safeop_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..385828bc8a9ce32f067325451c90117fdb0e18eb
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0072-safe_region_boundary_safeop_err/nonnull_check_call_err.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  int *q __attribute__((count(5))) = malloc(sizeof(int) * 5);
+  __Safe__ {
+    int *p = q + 6;
+    *p = 6;
+  }
+  printf("%d", *q);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0072-safe_region_boundary_safeop_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0072-safe_region_boundary_safeop_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6e06d89e6c482bdef9e58028c07e09aee3402dd1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0072-safe_region_boundary_safeop_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c:22 error: the pointer >= the upper bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0073-safe_region_boundary_unsafeop_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0073-safe_region_boundary_unsafeop_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..92355fdd1d1ad6f7c7e2beeb050b956ce0daa874
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0073-safe_region_boundary_unsafeop_err/nonnull_check_call_err.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  int *q __attribute__((count(5))) = malloc(sizeof(int) * 5);
+  __Unsafe__ {
+    int *p = q + 6;
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0073-safe_region_boundary_unsafeop_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0073-safe_region_boundary_unsafeop_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..511684b95eea5368b052a0398106387972658f07
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0073-safe_region_boundary_unsafeop_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assert"  --result=nonnull_check_call_err.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0074-safe_region_call_unsafe_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0074-safe_region_call_unsafe_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..b2fae45ac475c700e324a9036e26d9ea8302b9d3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0074-safe_region_call_unsafe_err/nonnull_check_call_err.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+__Unsafe__ void func() {
+  printf("func");
+}
+
+int main() {
+  __Safe__ {
+    func();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0074-safe_region_call_unsafe_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0074-safe_region_call_unsafe_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b566291fc49117f962748174742c8d96d93a7017
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0074-safe_region_call_unsafe_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c 23 error: call unsafe function func from safe region that requires safe function"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0075-boundary_check_funcptr_index_call/boundary_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0075-boundary_check_funcptr_index_call/boundary_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..42d270274719464236e01a24347d1ffa31f9a5d0
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0075-boundary_check_funcptr_index_call/boundary_check_funcptr.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int g_arr[] = {1,2,3,4,5};
+int *g_p __attribute__((count(5))) = g_arr;
+
+int* (*func1)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+int* (*func2)(int*, int*, int);
+int* (*func3)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+int* (*func4)(int*, int*, int)  __attribute__((count_index(3,1,2)));
+int* (*func5)(int*, int*, int)  __attribute__((count_index(3,1), returns_count_index(3)));
+int * vb __attribute__((count_index(1)));
+int * vc __attribute__((returns_count_index(1)));
+
+struct AA {
+  int* (*func1)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+  int* (*func2)(int *, int*, int);
+};
+
+struct BB {
+  int *i __attribute__((count(10)));
+};
+
+__attribute__((count_index(3,1,2), returns_count_index(3)))
+int *Test1(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((count_index(3,1), returns_count_index(3)))
+int *Test2(int* p, int *q, int len) {
+  return p;
+}
+
+int *Test3(int* p __attribute__((count_index(3))), int *q __attribute__((count_index(3))), int len) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int len) {
+  return p;
+}
+
+__attribute__((count("len",1,2), returns_count("len")))
+int *Test5(int* p, int *q, int len) {
+  return p;
+}
+
+int LEN = 10;
+__attribute__((count(LEN,1,2), returns_count(LEN)))
+int *Test6(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((returns_count("len")))
+int *Test7(int* p __attribute__((count("len"))), int *q __attribute__((count("len"))), int len) {
+ return p;
+}
+
+int Test() {
+  int len = 5;
+  int *p = g_p;
+  int array[] = {1,2,3,4,5,6,7,8,9,10};
+  int *q = array;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test7;  // CHECK-NOT: [[# @LINE ]] error
+
+  pa->func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+
+  int res = 0;
+  int *r1 = (*func1)(p, q, 5);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r1;
+  int *r2 = (*func2)(p, q, 10);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r2;
+  int *r3 = (*func3)(p, q, len);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r3;
+  // int *r4 = (*a.func1)(p, q, 10);  // COM:CHECK-NOT: [[# @LINE ]] error
+  // res += *r4;
+  int *r5 = (*pa->func1)(p, q, 5);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r5;
+  int *r6 = (*func1)(b.i, p, 5);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r6;
+  int *r7 = (*func1)(pb->i, q, 10);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r7;
+  // int *r8 = (*func1)(r1, r2, 5);  // COM:CHECK: [[# @LINE ]] error
+  int *r9 = (*func1)(r1, r3, 5);  // CHECK-NOT: [[# @LINE ]] error
+  // int *r10 = (*func1)(r1, r3, 10);  // COM:CHECK: [[# @LINE ]] error
+
+  return res;
+}
+
+int Test_arg(int* (*lfunc1)(int*, int*, int) __attribute__((count_index(3,1,2), returns_count_index(3))),
+             int* (*lfunc2)(int*, int*, int),
+             int* (*lfunc3)(int*, int*, int) __attribute__((count(10), count_index(3,1,2), returns_count_index(3)))) {
+  lfunc1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  lfunc2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  int *r1 = (*func1)(g_p, g_p, 3);  // CHECK-NOT: [[# @LINE ]] error
+  return 0;
+}
+
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0075-boundary_check_funcptr_index_call/expected.txt b/testsuite/c_test/enhancec_test/ENC0075-boundary_check_funcptr_index_call/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0075-boundary_check_funcptr_index_call/test.cfg b/testsuite/c_test/enhancec_test/ENC0075-boundary_check_funcptr_index_call/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc26de77132db0e3d7a739f51642c6304d80957f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0075-boundary_check_funcptr_index_call/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+ENCO2_B_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_funcptr.c
diff --git a/testsuite/c_test/enhancec_test/ENC0075-safe_region_call_unsafeop_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0075-safe_region_call_unsafeop_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..b18ad49d3ea4d0b0e72a1cb7c2e03a9f3280af63
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0075-safe_region_call_unsafeop_err/nonnull_check_call_err.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+void func() {
+  printf("func");
+}
+
+int main() {
+  __Safe__ {
+    func();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0075-safe_region_call_unsafeop_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0075-safe_region_call_unsafeop_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b566291fc49117f962748174742c8d96d93a7017
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0075-safe_region_call_unsafeop_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c 23 error: call unsafe function func from safe region that requires safe function"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0076-safe_region_nonnull_safe/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0076-safe_region_nonnull_safe/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..1f7a07b8f793d7bf41bdb6c1af6b1affbfa263fc
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0076-safe_region_nonnull_safe/nonnull_check_call_err.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+__attribute__((returns_nonnull))
+int *GetNonnull() {
+  int *i = malloc(sizeof(int));
+  return i;
+}
+
+__attribute__((returns_nonnull))
+__Safe__ int* Test(int i) {
+    if (i == 0) {
+        return GetNonnull();
+    }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0076-safe_region_nonnull_safe/test.cfg b/testsuite/c_test/enhancec_test/ENC0076-safe_region_nonnull_safe/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..864e95339578c2c31219f5b898cf08f8674d150a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0076-safe_region_nonnull_safe/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile_err(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="nonnull_check_call_err.c 26 error: call unsafe function GetNonnull from safe region that requires safe function"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0077-safe_region_nonnull_safe_err/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0077-safe_region_nonnull_safe_err/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..87f32053a9186a0037ae1902a64d899ec8fe14bf
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0077-safe_region_nonnull_safe_err/nonnull_check_call_err.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+__attribute__((returns_nonnull))
+int *GetNonnull() {
+  int *i = malloc(sizeof(int));
+  return i;
+}
+
+__attribute__((returns_nonnull))
+int* Test(int i) {
+    int *p = NULL;
+    if (i == 0) {
+        return GetNonnull();
+    } else {
+    	return p;
+    }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0077-safe_region_nonnull_safe_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0077-safe_region_nonnull_safe_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..511684b95eea5368b052a0398106387972658f07
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0077-safe_region_nonnull_safe_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assert"  --result=nonnull_check_call_err.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0078-nonnull_check_if_exit/expected.txt b/testsuite/c_test/enhancec_test/ENC0078-nonnull_check_if_exit/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0078-nonnull_check_if_exit/nonnull_check_if_exit.c b/testsuite/c_test/enhancec_test/ENC0078-nonnull_check_if_exit/nonnull_check_if_exit.c
new file mode 100644
index 0000000000000000000000000000000000000000..5bace5a2121824279a1b609a6e415476bcf1940a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0078-nonnull_check_if_exit/nonnull_check_if_exit.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+#include <stddef.h>
+
+//_Noreturn int panic(int err) { exit(err); }
+__attribute__((noreturn))
+int panic(int err) { 
+  exit(err);
+}
+
+int no_return(int *x) {
+  if (x == NULL) {
+    exit(-1); //  CHECK-NOT: [[# @LINE ]] warning
+  }
+  return *x;  // COM:CHECK-NOT: [[# @LINE ]] warning
+}
+
+int no_return1(int *x) {
+  if (x == NULL) {
+    panic(1);
+  }
+  return *x;  // COM:CHECK-NOT: [[# @LINE ]] warning
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0078-nonnull_check_if_exit/test.cfg b/testsuite/c_test/enhancec_test/ENC0078-nonnull_check_if_exit/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bfeedf86125b9a736419d8a6dec0b75a53d93fd0
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0078-nonnull_check_if_exit/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(nonnull_check_if_exit)
+run(nonnull_check_if_exit)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_if_exit.c
+ENCO2_B_D:
+compile(nonnull_check_if_exit)
+run(nonnull_check_if_exit)
diff --git a/testsuite/c_test/enhancec_test/ENC0079-boundary_size_change_warning/boundary_count_field.c b/testsuite/c_test/enhancec_test/ENC0079-boundary_size_change_warning/boundary_count_field.c
new file mode 100644
index 0000000000000000000000000000000000000000..61c195a98874f60332e9406e9632580fcbc9fbf6
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0079-boundary_size_change_warning/boundary_count_field.c
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+
+struct A {
+  int *i __attribute__((count("len")));
+  int len;
+};
+
+struct B {
+  struct A a;
+  struct A *pa;
+};
+
+int g_a[] = {1,2,3,4,5};
+int size = 5;
+int *g_p __attribute__((count(size))) = g_a;
+
+
+int func(int x) {
+  return x;
+}
+
+__Safe__ int* func1(int *p) {
+  return p;
+}
+
+__Unsafe__ int test_global() {
+  int res = 0;
+  res += func(*(g_p + 4));
+  int arr[] = {1,2,3,4};
+  g_p = arr;
+  __Safe__ {
+    size = 4;  // CHECK: [[# @LINE ]] warning
+    int *p_size = &size;  // CHECK: [[# @LINE ]] warning
+    p_size = func1(&size);  // CHECK: [[# @LINE ]] warning
+  }
+  int *p_size = &size;  // CHECK-NOT: [[# @LINE ]] warning
+  return res;
+}
+
+int test_field_init() {
+  int res = 0;
+  struct A a;
+  a.len = 5;  // CHECK: [[# @LINE ]] warning
+  int *p_size = &a.len;  // CHECK: [[# @LINE ]] warning
+  p_size = func1(&a.len);  // CHECK: [[# @LINE ]] warning
+  a.i = g_p;
+
+  __Unsafe__ {
+    a.len = 5;  // CHECK-NOT: [[# @LINE ]] warning
+    p_size = &a.len;  // CHECK-NOT: [[# @LINE ]] warning
+    p_size = func1(&a.len);  // CHECK-NOT: [[# @LINE ]] warning
+  }
+
+  struct B b;
+  b.a = a;
+  b.pa = &a;
+
+  struct B arr_b[5];
+  struct B *pb = &b;
+  pb->pa->len = 4;  // CHECK: [[# @LINE ]] warning
+  p_size = &pb->pa->len;  // CHECK: [[# @LINE ]] warning
+  p_size = func1(&pb->pa->len);  // CHECK: [[# @LINE ]] warning
+  res += func(pb->pa->i[3]);
+
+  __Unsafe__ {
+    pb->pa->len = 4;  // CHECK-NOT: [[# @LINE ]] warning
+    p_size = &pb->pa->len;  // CHECK-NOT: [[# @LINE ]] warning
+  }
+
+  return res;
+}
+
+int test_local_var() {
+  int res = 0;
+  int size = 5;
+  int *p __attribute__((count(size))) = g_a;
+  size = 4;  // CHECK-NOT: [[# @LINE ]] warning
+  res += func(p[3]);
+  return res;
+}
+
+int main() {
+  return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0079-boundary_size_change_warning/expected.txt b/testsuite/c_test/enhancec_test/ENC0079-boundary_size_change_warning/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0079-boundary_size_change_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0079-boundary_size_change_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..30be806fc9d8e839795f7b6599f368136bd4c7de
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0079-boundary_size_change_warning/test.cfg
@@ -0,0 +1,11 @@
+ENCO2_N_D:
+compile(boundary_count_field)
+run(boundary_count_field)
+ENCO2_B_D:
+compile(boundary_count_field)
+run(boundary_count_field)
+ENCO2_S_D:
+compile(boundary_count_field)
+run(boundary_count_field)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_count_field.c
diff --git a/testsuite/c_test/enhancec_test/ENC0080-nonnull_check_funcptr/expected.txt b/testsuite/c_test/enhancec_test/ENC0080-nonnull_check_funcptr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0080-nonnull_check_funcptr/nonnull_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0080-nonnull_check_funcptr/nonnull_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..a410e6c69a7b4abde0ca90f14e99996cd906fe01
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0080-nonnull_check_funcptr/nonnull_check_funcptr.c
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int* (*func1)(int*, int*, int*)  __attribute__((nonnull(1,3), returns_nonnull));
+int* (*func2)(int*, int*, int*);
+int* (*func3)(int*, int*, int*)  __attribute__((nonnull(1,3), returns_nonnull));
+int* (*func4)(int*, int*, int*)  __attribute__((nonnull(1,3)));
+int* (*func5)(int*, int*, int*)  __attribute__((nonnull(1), returns_nonnull));
+int * vc __attribute__((returns_nonnull));
+
+struct AA {
+  int* (*func1)(int*, int*, int*)  __attribute__((nonnull(1,3), returns_nonnull));
+  int* (*func2)(int *, int*, int*);
+};
+
+struct BB {
+  int *i;
+};
+
+__attribute__((nonnull(1,3), returns_nonnull))
+int *Test1(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((nonnull(1), returns_nonnull))
+int *Test2(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((nonnull(1,3)))
+int *Test3(int* p, int *q, int *w) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int *w) {
+  return p;
+}
+
+int Test() {
+  int i = 1;
+  int *p = &i;
+  int *q = &i;
+  int *w = &i;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = &Test2;  // CHECK: [[# @LINE ]] error
+  func1 = &Test3;  // CHECK: [[# @LINE ]] error
+  func1 = &Test4;  // CHECK: [[# @LINE ]] error
+
+  func2 = &Test1;  // CHECK: [[# @LINE ]] error
+  func2 = &Test2;  // CHECK: [[# @LINE ]] error
+  func2 = &Test3;  // CHECK: [[# @LINE ]] error
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  func1 = func2;  // CHECK: [[# @LINE ]] error
+  func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = func4;  // CHECK: [[# @LINE ]] error
+  func1 = func5;  // CHECK: [[# @LINE ]] error
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  a.func1 = &Test2;  // CHECK: [[# @LINE ]] error
+  a.func1 = &Test3;  // CHECK: [[# @LINE ]] error
+  a.func1 = &Test4;  // CHECK: [[# @LINE ]] error
+
+  a.func1 = func2;  // CHECK: [[# @LINE ]] error
+  a.func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  a.func1 = func4;  // CHECK: [[# @LINE ]] error
+  a.func1 = func5;  // CHECK: [[# @LINE ]] error
+
+  func1 = a.func1;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = a.func2;  // CHECK: [[# @LINE ]] error
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  pa->func1 = &Test2;  // CHECK: [[# @LINE ]] error
+  pa->func1 = &Test3;  // CHECK: [[# @LINE ]] error
+  pa->func1 = &Test4;  // CHECK: [[# @LINE ]] error
+
+  pa->func1 = func2;  // CHECK: [[# @LINE ]] error
+  pa->func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  pa->func1 = func4;  // CHECK: [[# @LINE ]] error
+  pa->func1 = func5;  // CHECK: [[# @LINE ]] error
+
+  func1 = pa->func1;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = pa->func2;  // CHECK: [[# @LINE ]] error
+
+  int res = 0;
+  return res;
+}
+
+struct CC {
+  int* (*func1)(int*, int*, int*)  __attribute__((nonnull, nonnull(1,2,3), returns_nonnull));
+  int* (*func2)(int *, int*, int*)  __attribute__((nonnull));
+};
+
+__attribute__((nonnull))
+int Test11(int *p, int *q, int *w) {
+  int* (*func11)(int*, int*, int*)  __attribute__((nonnull, nonnull(1,2,3), returns_nonnull));  // // CHECK: [[# @LINE ]] error
+  int* (*func12)(int*, int*, int*)  __attribute__((nonnull(1,2,3), returns_nonnull));
+
+  return 0;
+}
+
+int Test_arg(int* (*lfunc1)(int*, int*, int*) __attribute__((nonnull(1,3), returns_nonnull)),
+             int* (*lfunc2)(int*, int*, int*) __attribute__((nonnull)),
+             int* (*lfunc3)(int*, int*, int*) __attribute__((nonnull, nonnull(1,3), returns_nonnull))) {
+  lfunc1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  lfunc1 = &Test2;  // CHECK: [[# @LINE ]] error
+  lfunc1 = &Test3;  // CHECK: [[# @LINE ]] error
+  lfunc1 = &Test4;  // CHECK: [[# @LINE ]] error
+
+  lfunc2 = &Test1;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test2;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test3;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  lfunc1 = func2;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  lfunc1 = func4;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func5;  // CHECK: [[# @LINE ]] error
+  
+  return 0;
+}
+
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0080-nonnull_check_funcptr/test.cfg b/testsuite/c_test/enhancec_test/ENC0080-nonnull_check_funcptr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..564a7db3a371d5ccc354207e63c4d2a63d46e221
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0080-nonnull_check_funcptr/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile_err(nonnull_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_funcptr.c
+ENCO2_B_D:
+compile(nonnull_check_funcptr)
+run(nonnull_check_funcptr)
diff --git a/testsuite/c_test/enhancec_test/ENC0081-nonnull_check_funcptr_call/expected.txt b/testsuite/c_test/enhancec_test/ENC0081-nonnull_check_funcptr_call/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0081-nonnull_check_funcptr_call/nonnull_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0081-nonnull_check_funcptr_call/nonnull_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..97914b6fae24bbaffa03045f3276134ee9ce460f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0081-nonnull_check_funcptr_call/nonnull_check_funcptr.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int* (*func1)(int*, int*, int*)  __attribute__((nonnull(1,3), returns_nonnull));
+int* (*func2)(int*, int*, int*);
+int* (*func3)(int*, int*, int*)  __attribute__((nonnull(1,3), returns_nonnull));
+int* (*func4)(int*, int*, int*)  __attribute__((nonnull(1,3)));
+int* (*func5)(int*, int*, int*)  __attribute__((nonnull(1), returns_nonnull));
+
+struct AA {
+  int* (*func1)(int*, int*, int*)  __attribute__((nonnull(1,3), returns_nonnull));
+  int* (*func2)(int *, int*, int*);
+};
+
+struct BB {
+  int *i;
+};
+
+__attribute__((nonnull(1,3), returns_nonnull))
+int *Test1(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((nonnull(1), returns_nonnull))
+int *Test2(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((nonnull(1,3)))
+int *Test3(int* p, int *q, int *w) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int *w) {
+  return p;
+}
+
+ __attribute__((nonnull(1,2,3), returns_nonnull)) 
+int *Test5(int* p, int *q, int *w) {
+  return p;
+}
+
+int Test() {
+  int i = 1;
+  int *p = &i;
+  int *q = &i;
+  int *w = &i;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  int res = 0;
+  int *r1 = (*func1)(p, q, w);  // COM:CHECK-NOT: [[# @LINE ]] warning: Dereference{{.*}}
+  res += *r1;  // CHECK-NOT: [[# @LINE ]] warning: Dereference{{.*}}
+  int *r2 = (*func2)(p, q, w);  // COM:CHECK-NOT: [[# @LINE ]] warning: Dereference{{.*}}
+  // return nullable checking
+  res += *r2;  // CHECK: [[# @LINE ]] warning
+  int *r3 = (*a.func1)(p, q, w);  // COM:CHECK-NOT: [[# @LINE ]] warning: Dereference{{.*}}
+  res += *r3;  // CHECK-NOT: [[# @LINE ]] warning
+  int *r4 = (*pa->func1)(p, q, w);  // COM:CHECK-NOT: [[# @LINE ]] warning: Dereference{{.*}}
+  res += *r4;  // CHECK-NOT: [[# @LINE ]] warning
+  // COM:CHECK-NOT: [[# @LINE + 1 ]] warning: Dereference{{.*}}
+  int *r5 = (*func1)(p, x, b.i);  // CHECK: [[# @LINE ]] warning: nullable pointer{{.*}} 3rd argument
+  res += *r5;  // CHECK-NOT: [[# @LINE ]] warning
+  // COM: CHECK: [[# @LINE + 2 ]] warning: nullable pointer{{.*}} 1st argument
+  // CHECK: [[# @LINE + 1 ]] warning: nullable pointer{{.*}} 3rd argument
+  int *r6 = (*func1)(pb->i, p, x);  // COM:CHECK-NOT: [[# @LINE ]] warning: Dereference{{.*}}
+  res += *r6;  // CHECK-NOT: [[# @LINE ]] warning
+
+  return res;
+}
+
+struct CC {
+  int* (*func1)(int*, int*, int*)  __attribute__((nonnull, nonnull(1,2,3), returns_nonnull));
+  int* (*func2)(int *, int*, int*)  __attribute__((nonnull));
+};
+
+__attribute__((nonnull))
+int Test11(int *p, int *q, int *w) {
+  int* (*func11)(int*, int*, int*)  __attribute__((nonnull, nonnull(1,2,3), returns_nonnull)) = &Test5;
+  int* (*func12)(int*, int*, int*)  __attribute__((nonnull(1,2,3), returns_nonnull));
+
+  (*func11)(p,q,w);  // CHECK-NOT: [[# @LINE ]] warning
+  (*func12)(p,q,w);  // CHECK: [[# @LINE ]] warning
+  struct CC c;
+  (*c.func1)(p,q,w);  // CHECK-NOT: [[# @LINE ]] warning
+  (*c.func2)(p,q,w);  // CHECK-NOT: [[# @LINE ]] warning
+  return 0;
+}
+
+int Test_arg(int* (*lfunc1)(int*, int*, int*) __attribute__((nonnull(1,3), returns_nonnull)),
+             int* (*lfunc2)(int*, int*, int*) __attribute__((nonnull)),
+             int* (*lfunc3)(int*, int*, int*) __attribute__((nonnull, nonnull(1,3), returns_nonnull))) {
+  lfunc1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  lfunc2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  int i = 1;
+  int *p = &i;
+  int *q;
+  int *r1 = (*lfunc1)(p, q, p);  // CHECK-NOT: [[# @LINE ]] warning
+  int *r2 = (*lfunc2)(p, q, p);  // CHECK-NOT: [[# @LINE ]] warning
+  int *r3 = (*lfunc3)(p, q, p);  // CHECK-NOT: [[# @LINE ]] warning
+  int *r4 = (*lfunc3)(p, q, q);  // CHECK: [[# @LINE ]] warning
+  
+  return 0;
+}
+
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0081-nonnull_check_funcptr_call/test.cfg b/testsuite/c_test/enhancec_test/ENC0081-nonnull_check_funcptr_call/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..01e0f7f3629d5a13eaff6ceff013e9b87f82ac86
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0081-nonnull_check_funcptr_call/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(nonnull_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_funcptr.c
+ENCO2_B_D:
+compile(nonnull_check_funcptr)
+run(nonnull_check_funcptr)
diff --git a/testsuite/c_test/enhancec_test/ENC0082-boundary_count_funcptr/boundary_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0082-boundary_count_funcptr/boundary_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..57eb259ca017ce09237ccb2fb3ba1f242378425c
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0082-boundary_count_funcptr/boundary_check_funcptr.c
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int g_arr[] = {1,2,3,4,5};
+int *g_p __attribute__((count(5))) = g_arr;
+
+int* (*func1)(int*, int*, int*)  __attribute__((count(10,1,3), returns_count(10)));
+int* (*func2)(int*, int*, int*);
+int* (*func3)(int*, int*, int*)  __attribute__((count(10,1,3), returns_count(10)));
+int* (*func4)(int*, int*, int*)  __attribute__((count(10,1,3)));
+int* (*func5)(int*, int*, int*)  __attribute__((count(10,1), returns_count(10)));
+int* (*func6)(int*, int*, int*)  __attribute__((count(10,1,3), returns_count(5)));
+int * vc __attribute__((returns_count(10)));
+
+struct AA {
+  int* (*func1)(int*, int*, int*)  __attribute__((count(10,1,3), returns_count(10)));
+  int* (*func2)(int *, int*, int*);
+};
+
+struct BB {
+  int *i __attribute__((count(8)));
+};
+
+__attribute__((count(10,1,3), returns_count(10)))
+int *Test1(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((count(10,1), returns_count(10)))
+int *Test2(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((count(10,1,3)))
+int *Test3(int* p, int *q, int *w) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int *w) {
+  return p;
+}
+
+int Test() {
+  int i = 1;
+  int *p = g_p;
+  int array[] = {1,2,3,4,5,6,7,8,9,10};
+  int *q = array;
+  int *w __attribute__((count(5))) = array;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = &Test2;  // CHECK: [[# @LINE ]] error
+  func1 = &Test3;  // CHECK: [[# @LINE ]] error
+  func1 = &Test4;  // CHECK: [[# @LINE ]] error
+
+  func2 = &Test1;  // CHECK: [[# @LINE ]] error
+  func2 = &Test2;  // CHECK: [[# @LINE ]] error
+  func2 = &Test3;  // CHECK: [[# @LINE ]] error
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  func1 = func2;  // CHECK: [[# @LINE ]] error
+  func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = func4;  // CHECK: [[# @LINE ]] error
+  func1 = func5;  // CHECK: [[# @LINE ]] error
+  func1 = func6;  // CHECK: [[# @LINE ]] error
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  a.func1 = &Test2;  // CHECK: [[# @LINE ]] error
+  a.func1 = &Test3;  // CHECK: [[# @LINE ]] error
+  a.func1 = &Test4;  // CHECK: [[# @LINE ]] error
+
+  a.func1 = func2;  // CHECK: [[# @LINE ]] error
+  a.func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  a.func1 = func4;  // CHECK: [[# @LINE ]] error
+  a.func1 = func5;  // CHECK: [[# @LINE ]] error
+  a.func1 = func6;  // CHECK: [[# @LINE ]] error
+
+  func1 = a.func1;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = a.func2;  // CHECK: [[# @LINE ]] error
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  pa->func1 = &Test2;  // CHECK: [[# @LINE ]] error
+  pa->func1 = &Test3;  // CHECK: [[# @LINE ]] error
+  pa->func1 = &Test4;  // CHECK: [[# @LINE ]] error
+
+  pa->func1 = func2;  // CHECK: [[# @LINE ]] error
+  pa->func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  pa->func1 = func4;  // CHECK: [[# @LINE ]] error
+  pa->func1 = func5;  // CHECK: [[# @LINE ]] error
+
+  func1 = pa->func1;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = pa->func2;  // CHECK: [[# @LINE ]] error
+
+  int res = 0;
+  int *r1 = (*func1)(q, p, x);  // COM:CHECK: [[# @LINE ]] error: boundaryless
+  res += *r1;
+  int *r2 = (*func2)(p, q, x);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r2;
+  int *r3 = (*a.func1)(p, p, q);  // COM:CHECK: [[# @LINE ]] warning
+  res += *r3;
+  // int *r4 = (*pa->func1)(q, q, w);  // COM:CHECK: [[# @LINE ]] warning
+  // res += *r4;
+  // int *r5 = (*func1)(q, x, b.i);  // COM:CHECK: [[# @LINE ]] warning
+  // res += *r5;
+  // int *r6 = (*func6)(pb->i, p, q);  // COM:CHECK: [[# @LINE ]] warning
+  // res += *r6;  // COM:CHECK-NOT: [[# @LINE ]] warning
+
+  (*func1)(r1, r2, r3);  // CHECK-NOT: [[# @LINE ]] error
+  (*func1)(r1, r3, r2);  // CHECK: [[# @LINE ]] error: boundaryless
+  // (*func6)(r6, r3, r2);  // COM:CHECK: [[# @LINE ]] warning
+
+  return res;
+}
+
+struct CC {
+  int* (*func1)(int*, int*, int*)  __attribute__((count(10), count(10,1,2,3), returns_count(10)));
+  int* (*func2)(int *, int*, int*)  __attribute__((count(10)));
+};
+
+__attribute__((count(10,1,2), count(5,3)))
+int Test_var(int *p, int *q, int *w) {
+  int* (*func11)(int*, int*, int*)  __attribute__((count(10), count(10,1,2,3), returns_count(10)));
+  int* (*func12)(int*, int*, int*)  __attribute__((count(10,1,2,3), returns_count(10)));
+
+  // (*func11)(p,q,w);  // COM:CHECK: [[# @LINE ]] warning
+  // (*func12)(p,q,w);  // COM:CHECK: [[# @LINE ]] warning
+  struct CC c;
+  // (*c.func1)(p,q,w);  // COM:CHECK: [[# @LINE ]] warning
+  (*c.func2)(p,q,w);  // CHECK-NOT: [[# @LINE ]] warning
+
+  return 0;
+}
+
+int Test_arg(int* (*lfunc1)(int*, int*, int*) __attribute__((count(10,1,3), returns_count(10))),
+             int* (*lfunc2)(int*, int*, int*),
+             int* (*lfunc3)(int*, int*, int*) __attribute__((count(10), count(10,1,2,3), returns_count(10)))) {
+  lfunc1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  lfunc1 = &Test2;  // CHECK: [[# @LINE ]] error
+  lfunc1 = &Test3;  // CHECK: [[# @LINE ]] error
+  lfunc1 = &Test4;  // CHECK: [[# @LINE ]] error
+
+  lfunc2 = &Test1;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test2;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test3;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  lfunc1 = func2;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  lfunc1 = func4;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func5;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func6;  // CHECK: [[# @LINE ]] error
+  // int *r1 = (*func1)(g_p, g_p, g_p);  // COM:CHECK: [[# @LINE ]] warning
+  return 0;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0082-boundary_count_funcptr/expected.txt b/testsuite/c_test/enhancec_test/ENC0082-boundary_count_funcptr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0082-boundary_count_funcptr/test.cfg b/testsuite/c_test/enhancec_test/ENC0082-boundary_count_funcptr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e0fb31c19e0ceac78ba0166e12ffd4543499773
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0082-boundary_count_funcptr/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+ENCO2_B_D:
+compile_err(boundary_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_funcptr.c
diff --git a/testsuite/c_test/enhancec_test/ENC0083-boundary_count_funcptr_call/boundary_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0083-boundary_count_funcptr_call/boundary_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..4760b03647e03bad0f1c4d814268e9aadb62c663
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0083-boundary_count_funcptr_call/boundary_check_funcptr.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int g_arr[] = {1,2,3,4,5,6,7,8,9,10};
+int *g_p __attribute__((count(10))) = g_arr;
+
+int* (*func1)(int*, int*, int*)  __attribute__((count(10,1,3), returns_count(10)));
+int* (*func2)(int*, int*, int*);
+int* (*func3)(int*, int*, int*)  __attribute__((count(10,1,3), returns_count(10)));
+int* (*func4)(int*, int*, int*)  __attribute__((count(10,1,3)));
+int* (*func5)(int*, int*, int*)  __attribute__((count(10,1), returns_count(10)));
+int* (*func6)(int*, int*, int*)  __attribute__((count(10,1,3), returns_count(5)));
+int * vc __attribute__((returns_count(10)));
+
+struct AA {
+  int* (*func1)(int*, int*, int*)  __attribute__((count(10,1,3), returns_count(10)));
+  int* (*func2)(int *, int*, int*);
+};
+
+struct BB {
+  int *i __attribute__((count(12)));
+};
+
+__attribute__((count(10,1,3), returns_count(10)))
+int *Test1(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((count(10,1), returns_count(10)))
+int *Test2(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((count(10,1,3)))
+int *Test3(int* p, int *q, int *w) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int *w) {
+  return p;
+}
+
+int Test() {
+  int i = 1;
+  int *p = g_p;
+  int array[] = {1,2,3,4,5,6,7,8,9,10};
+  int *q = array;
+  int *w __attribute__((count(5))) = array;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  int res = 0;
+  int *r2 = (*func2)(p, q, x);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r2;
+  int *r3 = (*a.func1)(p, p, q);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r3;
+  // int *r4 = (*pa->func1)(q, q, w);  // COM:CHECK: [[# @LINE ]] error
+  // res += *r4;
+  int *r5 = (*func1)(q, x, b.i);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r5;
+  int *r6 = (*func6)(pb->i, p, q);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r6;  // CHECK-NOT: [[# @LINE ]] error
+
+  (*func1)(r3, r2, r3);  // CHECK-NOT: [[# @LINE ]] error
+  // (*func6)(r6, r3, r2);  // COM:CHECK: [[# @LINE ]] error
+
+  return res;
+}
+
+struct CC {
+  int* (*func1)(int*, int*, int*)  __attribute__((count(10), count(10,1,2,3), returns_count(10)));
+  int* (*func2)(int *, int*, int*)  __attribute__((count(10)));
+};
+
+__attribute__((count(10,1,2), count(15,3)))
+int Test_var(int *p, int *q, int *w) {
+  int* (*func11)(int*, int*, int*)  __attribute__((count(10), count(10,1,2,3), returns_count(10)));
+  int* (*func12)(int*, int*, int*)  __attribute__((count(10,1,2,3), returns_count(10)));
+
+  (*func11)(p,q,w);  // CHECK-NOT: [[# @LINE ]] error
+  (*func12)(p,q,w);  // CHECK-NOT: [[# @LINE ]] error
+  struct CC c;
+  (*c.func1)(p,q,w);  // CHECK-NOT: [[# @LINE ]] error
+  (*c.func2)(p,q,w);  // CHECK-NOT: [[# @LINE ]] error
+
+  return 0;
+}
+
+int Test_arg(int* (*lfunc1)(int*, int*, int*) __attribute__((count(10,1,3), returns_count(10))),
+             int* (*lfunc2)(int*, int*, int*),
+             int* (*lfunc3)(int*, int*, int*) __attribute__((count(10), count(10,1,2,3), returns_count(10)))) {
+  lfunc1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  lfunc2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  int *r1 = (*func1)(g_p, g_p, g_p);  // CHECK-NOT: [[# @LINE ]] error
+  return 0;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0083-boundary_count_funcptr_call/expected.txt b/testsuite/c_test/enhancec_test/ENC0083-boundary_count_funcptr_call/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0083-boundary_count_funcptr_call/test.cfg b/testsuite/c_test/enhancec_test/ENC0083-boundary_count_funcptr_call/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc26de77132db0e3d7a739f51642c6304d80957f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0083-boundary_count_funcptr_call/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+ENCO2_B_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_funcptr.c
diff --git a/testsuite/c_test/enhancec_test/ENC0084-boundary_count_funcptr_index/boundary_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0084-boundary_count_funcptr_index/boundary_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..ebfe07b9f25acca6fa3e7443f1f4640eb8c5a8b7
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0084-boundary_count_funcptr_index/boundary_check_funcptr.c
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int g_arr[] = {1,2,3,4,5};
+int *g_p __attribute__((count(5))) = g_arr;
+
+int* (*func1)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+int* (*func2)(int*, int*, int);
+int* (*func3)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+int* (*func4)(int*, int*, int)  __attribute__((count_index(3,1,2)));
+int* (*func5)(int*, int*, int)  __attribute__((count_index(3,1), returns_count_index(3)));
+int * vb __attribute__((count_index(1)));
+int * vc __attribute__((returns_count_index(1)));
+
+struct AA {
+  int* (*func1)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+  int* (*func2)(int *, int*, int);
+};
+
+struct BB {
+  int *i __attribute__((count(10)));
+};
+
+__attribute__((count_index(3,1,2), returns_count_index(3)))
+int *Test1(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((count_index(3,1), returns_count_index(3)))
+int *Test2(int* p, int *q, int len) {
+  return p;
+}
+
+int *Test3(int* p __attribute__((count_index(3))), int *q __attribute__((count_index(3))), int len) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int len) {
+  return p;
+}
+
+__attribute__((count("len",1,2), returns_count("len")))
+int *Test5(int* p, int *q, int len) {
+  return p;
+}
+
+int LEN = 10;
+__attribute__((count(LEN,1,2), returns_count(LEN)))
+int *Test6(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((returns_count("len")))
+int *Test7(int* p __attribute__((count("len"))), int *q __attribute__((count("len"))), int len) {
+ return p;
+}
+
+int Test() {
+  int len = 5;
+  int *p = g_p;
+  int array[] = {1,2,3,4,5,6,7,8,9,10};
+  int *q = array;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = &Test2;  // CHECK: [[# @LINE ]] error
+  func1 = &Test3;  // CHECK: [[# @LINE ]] error
+  func1 = &Test4;  // CHECK: [[# @LINE ]] error
+  func1 = &Test5;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = &Test6;  // CHECK: [[# @LINE ]] error
+  func1 = &Test7;  // CHECK-NOT: [[# @LINE ]] error
+
+  func2 = &Test1;  // CHECK: [[# @LINE ]] error
+  func2 = &Test2;  // CHECK: [[# @LINE ]] error
+  func2 = &Test3;  // CHECK: [[# @LINE ]] error
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+  func2 = &Test5;  // CHECK: [[# @LINE ]] error
+  func2 = &Test6;  // CHECK: [[# @LINE ]] error
+  func2 = &Test7;  // CHECK: [[# @LINE ]] error
+
+  func1 = func2;  // CHECK: [[# @LINE ]] error
+  func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = func4;  // CHECK: [[# @LINE ]] error
+  func1 = func5;  // CHECK: [[# @LINE ]] error
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  a.func1 = &Test2;  // CHECK: [[# @LINE ]] error
+  a.func1 = &Test3;  // CHECK: [[# @LINE ]] error
+  a.func1 = &Test4;  // CHECK: [[# @LINE ]] error
+  a.func1 = &Test5;  // CHECK-NOT: [[# @LINE ]] error
+  a.func1 = &Test6;  // CHECK: [[# @LINE ]] error
+  a.func1 = &Test7;  // CHECK-NOT: [[# @LINE ]] error
+
+  a.func1 = func2;  // CHECK: [[# @LINE ]] error
+  a.func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  a.func1 = func4;  // CHECK: [[# @LINE ]] error
+  a.func1 = func5;  // CHECK: [[# @LINE ]] error
+
+  func1 = a.func1;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = a.func2;  // CHECK: [[# @LINE ]] error
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  pa->func1 = &Test2;  // CHECK: [[# @LINE ]] error
+  pa->func1 = &Test3;  // CHECK: [[# @LINE ]] error
+  pa->func1 = &Test4;  // CHECK: [[# @LINE ]] error
+  pa->func1 = &Test5;  // CHECK-NOT: [[# @LINE ]] error
+  pa->func1 = &Test6;  // CHECK: [[# @LINE ]] error
+  pa->func1 = &Test7;  // CHECK-NOT: [[# @LINE ]] error
+
+  pa->func1 = func2;  // CHECK: [[# @LINE ]] error
+  pa->func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  pa->func1 = func4;  // CHECK: [[# @LINE ]] error
+  pa->func1 = func5;  // CHECK: [[# @LINE ]] error
+
+  func1 = pa->func1;  // CHECK-NOT: [[# @LINE ]] error
+  func1 = pa->func2;  // CHECK: [[# @LINE ]] error
+
+  int res = 0;
+  int *r1 = (*func1)(p, q, 5);  // CHECK-NOT: [[# @LINE ]] warning
+  res += *r1;
+  int *r2 = (*func2)(p, q, 10);  // CHECK-NOT: [[# @LINE ]] warning
+  res += *r2;
+  int *r3 = (*func3)(p, q, len);  // CHECK-NOT: [[# @LINE ]] warning
+  res += *r3;
+  // int *r4 = (*a.func1)(p, q, 10);  // COM:CHECK: [[# @LINE ]] warning
+  // res += *r4;
+  // COM:CHECK: [[# @LINE + 1 ]] warning
+  // int *r5 = (*pa->func1)(p, q, 11);  // COM:CHECK: [[# @LINE ]] warning
+  // res += *r5;
+  int *r6 = (*func1)(b.i, p, 5);  // CHECK-NOT: [[# @LINE ]] warning
+  res += *r6;
+  // COM:CHECK: [[# @LINE + 1 ]] warning
+  // int *r7 = (*func1)(pb->i, p, 11);  // COM:CHECK: [[# @LINE ]] warning
+  // res += *r7;
+  // int *r8 = (*func1)(r1, r2, 5);  // COM:CHECK: [[# @LINE ]] warning
+  int *r9 = (*func1)(r1, r3, 5);  // CHECK-NOT: [[# @LINE ]] warning
+  // COM:CHECK: [[# @LINE + 1 ]] warning
+  // int *r10 = (*func1)(r1, r3, 10);  // COM:CHECK: [[# @LINE ]] warning
+
+  return res;
+}
+
+int Test_arg(int* (*lfunc1)(int*, int*, int) __attribute__((count_index(3,1,2), returns_count_index(3))),
+             int* (*lfunc2)(int*, int*, int),
+             int* (*lfunc3)(int*, int*, int) __attribute__((count(10), count_index(3,1,2), returns_count_index(3)))) {
+  lfunc1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  lfunc1 = &Test2;  // CHECK: [[# @LINE ]] error
+  lfunc1 = &Test3;  // CHECK: [[# @LINE ]] error
+  lfunc1 = &Test4;  // CHECK: [[# @LINE ]] error
+
+  lfunc2 = &Test1;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test2;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test3;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  lfunc1 = func2;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  lfunc1 = func4;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func5;  // CHECK: [[# @LINE ]] error
+  // int *r1 = (*func1)(g_p, g_p, 10);  // COM:CHECK: [[# @LINE ]] warning
+  return 0;
+}
+
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0084-boundary_count_funcptr_index/expected.txt b/testsuite/c_test/enhancec_test/ENC0084-boundary_count_funcptr_index/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0084-boundary_count_funcptr_index/test.cfg b/testsuite/c_test/enhancec_test/ENC0084-boundary_count_funcptr_index/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e0fb31c19e0ceac78ba0166e12ffd4543499773
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0084-boundary_count_funcptr_index/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+ENCO2_B_D:
+compile_err(boundary_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_funcptr.c
diff --git a/testsuite/c_test/enhancec_test/ENC0085-boundary_count_funcptr_index_call/boundary_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0085-boundary_count_funcptr_index_call/boundary_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..c1a2f8ae2767533c6ccc7a6fc002a5dd7c09a15e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0085-boundary_count_funcptr_index_call/boundary_check_funcptr.c
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int g_arr[] = {1,2,3,4,5};
+int *g_p __attribute__((count(5))) = g_arr;
+
+int* (*func1)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+int* (*func2)(int*, int*, int);
+int* (*func3)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+int* (*func4)(int*, int*, int)  __attribute__((count_index(3,1,2)));
+int* (*func5)(int*, int*, int)  __attribute__((count_index(3,1), returns_count_index(3)));
+int * vb __attribute__((count_index(1)));
+int * vc __attribute__((returns_count_index(1)));
+
+struct AA {
+  int* (*func1)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+  int* (*func2)(int *, int*, int);
+};
+
+struct BB {
+  int *i __attribute__((count(10)));
+};
+
+__attribute__((count_index(3,1,2), returns_count_index(3)))
+int *Test1(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((count_index(3,1), returns_count_index(3)))
+int *Test2(int* p, int *q, int len) {
+  return p;
+}
+
+int *Test3(int* p __attribute__((count_index(3))), int *q __attribute__((count_index(3))), int len) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int len) {
+  return p;
+}
+
+__attribute__((count("len",1,2), returns_count("len")))
+int *Test5(int* p, int *q, int len) {
+  return p;
+}
+
+int LEN = 10;
+__attribute__((count(LEN,1,2), returns_count(LEN)))
+int *Test6(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((returns_count("len")))
+int *Test7(int* p __attribute__((count("len"))), int *q __attribute__((count("len"))), int len) {
+ return p;
+}
+
+int Test() {
+  int len = 5;
+  int *p = g_p;
+  int array[] = {1,2,3,4,5,6,7,8,9,10};
+  int *q = array;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  a.func1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  int res = 0;
+  int *r1 = (*func1)(p, q, 5);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r1;
+  int *r2 = (*func2)(p, q, 10);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r2;
+  int *r3 = (*func3)(p, q, len);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r3;
+  // int *r4 = (*a.func1)(p, q, 10);  // COM:CHECK: [[# @LINE ]] error
+  // res += *r4;
+  // COM:CHECK: [[# @LINE + 1 ]] warning
+  // int *r5 = (*pa->func1)(p, q, 11);  // COM:CHECK: [[# @LINE ]] warning
+  // res += *r5;
+  int *r6 = (*func1)(b.i, p, 5);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r6;
+  // COM:CHECK: [[# @LINE + 1 ]] warning
+  // int *r7 = (*func1)(pb->i, p, 11);  // COM:CHECK: [[# @LINE ]] warning
+  // res += *r7;
+  // int *r8 = (*func1)(r1, r2, 5);  // COM:CHECK: [[# @LINE ]] warning
+  int *r9 = (*func1)(r1, r3, 5);  // CHECK-NOT: [[# @LINE ]] error
+  // COM:CHECK: [[# @LINE + 1 ]] warning
+  // int *r10 = (*func1)(r1, r3, 10);  // COM:CHECK: [[# @LINE ]] warning
+
+  return res;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0085-boundary_count_funcptr_index_call/expected.txt b/testsuite/c_test/enhancec_test/ENC0085-boundary_count_funcptr_index_call/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0085-boundary_count_funcptr_index_call/test.cfg b/testsuite/c_test/enhancec_test/ENC0085-boundary_count_funcptr_index_call/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc26de77132db0e3d7a739f51642c6304d80957f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0085-boundary_count_funcptr_index_call/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+ENCO2_B_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_funcptr.c
diff --git a/testsuite/c_test/enhancec_test/ENC0086-boundary_bytecount_funcptr/boundary_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0086-boundary_bytecount_funcptr/boundary_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..905aaeac4c0dee03efc34479dc908db5565e51f3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0086-boundary_bytecount_funcptr/boundary_check_funcptr.c
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int g_arr[] = {1,2,3,4,5};
+int *g_p __attribute__((byte_count(20))) = g_arr;
+
+int* (*func1)(int*, int*, int*)  __attribute__((byte_count(10,1,3), returns_byte_count(10)));
+int* (*func2)(int*, int*, int*);
+int* (*func3)(int*, int*, int*)  __attribute__((byte_count(10,1,3), returns_byte_count(10)));
+int* (*func4)(int*, int*, int*)  __attribute__((byte_count(10,1,3)));
+int* (*func5)(int*, int*, int*)  __attribute__((byte_count(10,1), returns_byte_count(10)));
+int* (*func6)(int*, int*, int*)  __attribute__((byte_count(10,1,3), returns_byte_count(5)));
+int* (*func7)(int*, int*, int*)  __attribute__((count(10,1,3), returns_count(10)));
+int * vc __attribute__((returns_byte_count(10)));
+
+struct AA {
+  int* (*func1)(int*, int*, int*)  __attribute__((byte_count(10,1,3), returns_byte_count(10)));
+  int* (*func2)(int *, int*, int*);
+};
+
+struct BB {
+  int *i __attribute__((byte_count(32)));
+};
+
+__attribute__((byte_count(10,1,3), returns_byte_count(10)))
+int *Test1(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((byte_count(10,1), returns_byte_count(10)))
+int *Test2(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((byte_count(10,1,3)))
+int *Test3(int* p, int *q, int *w) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int *w) {
+  return p;
+}
+
+__attribute__((count(10,1,3), returns_count(10)))
+int *Test5(int* p, int *q, int *w) {
+  return p;
+}
+
+int Test() {
+  int i = 1;
+  int *p = g_p;
+  int array[] = {1,2,3,4,5,6,7,8,9,10};
+  int *q = array;
+  int *w __attribute__((byte_count(20))) = array;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = &Test2;  // CHECK: [[# @LINE ]] error:
+  func1 = &Test3;  // CHECK: [[# @LINE ]] error:
+  func1 = &Test4;  // CHECK: [[# @LINE ]] error:
+  func1 = &Test5;  // CHECK: [[# @LINE ]] error:
+
+  func2 = &Test1;  // CHECK: [[# @LINE ]] error:
+  func2 = &Test2;  // CHECK: [[# @LINE ]] error:
+  func2 = &Test3;  // CHECK: [[# @LINE ]] error:
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = &Test5;  // CHECK: [[# @LINE ]] error:
+
+  func1 = func2;  // CHECK: [[# @LINE ]] error:
+  func1 = func3;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = func4;  // CHECK: [[# @LINE ]] error:
+  func1 = func5;  // CHECK: [[# @LINE ]] error:
+  func1 = func6;  // CHECK: [[# @LINE ]] error:
+  func1 = func7;  // CHECK: [[# @LINE ]] error:
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+  a.func1 = &Test2;  // CHECK: [[# @LINE ]] error:
+  a.func1 = &Test3;  // CHECK: [[# @LINE ]] error:
+  a.func1 = &Test4;  // CHECK: [[# @LINE ]] error:
+  a.func1 = &Test5;  // CHECK: [[# @LINE ]] error:
+
+  a.func1 = func2;  // CHECK: [[# @LINE ]] error:
+  a.func1 = func3;  // CHECK-NOT: [[# @LINE ]] error:
+  a.func1 = func4;  // CHECK: [[# @LINE ]] error:
+  a.func1 = func5;  // CHECK: [[# @LINE ]] error:
+  a.func1 = func6;  // CHECK: [[# @LINE ]] error:
+  a.func1 = func7;  // CHECK: [[# @LINE ]] error:
+
+  func1 = a.func1;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = a.func2;  // CHECK: [[# @LINE ]] error:
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+  pa->func1 = &Test2;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = &Test3;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = &Test4;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = &Test5;  // CHECK: [[# @LINE ]] error:
+
+  pa->func1 = func2;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = func3;  // CHECK-NOT: [[# @LINE ]] error:
+  pa->func1 = func4;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = func5;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = func6;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = func7;  // CHECK: [[# @LINE ]] error:
+
+  func1 = pa->func1;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = pa->func2;  // CHECK: [[# @LINE ]] error:
+
+  int res = 0;
+  int *r1 = (*func1)(q, p, x);  // COM:CHECK: [[# @LINE ]] error: boundaryless
+  res += *r1;
+  int *r2 = (*func2)(p, q, x);  // CHECK-NOT: [[# @LINE ]] error:
+  res += *r2;
+  int *r3 = (*a.func1)(p, p, q);  // COM:CHECK: [[# @LINE ]] warning:
+  res += *r3;
+  // int *r4 = (*pa->func1)(q, q, w);  // COM:CHECK: [[# @LINE ]] warning:
+  // res += *r4;
+  // int *r5 = (*func1)(q, x, b.i);  // COM:CHECK: [[# @LINE ]] warning:
+  // res += *r5;
+  // int *r6 = (*func6)(pb->i, p, q);  // COM:CHECK: [[# @LINE ]] warning:
+  // res += *r6;  // COM:CHECK-NOT: [[# @LINE ]] warning:
+
+  (*func1)(r1, r2, r3);  // CHECK-NOT: [[# @LINE ]] error:
+  (*func1)(r1, r3, r2);  // CHECK: [[# @LINE ]] error: boundaryless
+  // (*func6)(r6, r3, r2);  // COM:CHECK: [[# @LINE ]] warning:
+
+  return res;
+}
+
+struct CC {
+  int* (*func1)(int*, int*, int*)  __attribute__((byte_count(10), byte_count(10,1,2,3), returns_byte_count(10)));
+  int* (*func2)(int *, int*, int*)  __attribute__((byte_count(10)));
+};
+
+__attribute__((byte_count(10,1,2), byte_count(5,3)))
+int Test_var(int *p, int *q, int *w) {
+  int* (*func11)(int*, int*, int*)  __attribute__((byte_count(10), byte_count(10,1,2,3), returns_byte_count(10)));
+  int* (*func12)(int*, int*, int*)  __attribute__((byte_count(10,1,2,3), returns_byte_count(10)));
+
+  // (*func11)(p,q,w);  // COM:CHECK: [[# @LINE ]] warning
+  // (*func12)(p,q,w);  // COM:CHECK: [[# @LINE ]] warning
+  struct CC c;
+  // (*c.func1)(p,q,w);  // COM:CHECK: [[# @LINE ]] warning
+  (*c.func2)(p,q,w);  // CHECK-NOT: [[# @LINE ]] warning
+
+  return 0;
+}
+
+int Test_arg(int* (*lfunc1)(int*, int*, int*) __attribute__((byte_count(10,1,3), returns_byte_count(10))),
+             int* (*lfunc2)(int*, int*, int*),
+             int* (*lfunc3)(int*, int*, int*) __attribute__((byte_count(10), byte_count(10,1,2,3), returns_byte_count(10)))) {
+  lfunc1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+  lfunc1 = &Test2;  // CHECK: [[# @LINE ]] error
+  lfunc1 = &Test3;  // CHECK: [[# @LINE ]] error
+  lfunc1 = &Test4;  // CHECK: [[# @LINE ]] error
+  lfunc1 = &Test5;  // CHECK: [[# @LINE ]] error
+
+  lfunc2 = &Test1;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test2;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test3;  // CHECK: [[# @LINE ]] error
+  lfunc2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+  lfunc2 = &Test5;  // CHECK: [[# @LINE ]] error
+
+  lfunc1 = func2;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func3;  // CHECK-NOT: [[# @LINE ]] error
+  lfunc1 = func4;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func5;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func6;  // CHECK: [[# @LINE ]] error
+  lfunc1 = func7;  // CHECK: [[# @LINE ]] error
+  // int *r1 = (*func1)(g_p, g_p, g_p);  // COM:CHECK: [[# @LINE ]] warning
+  return 0;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0086-boundary_bytecount_funcptr/expected.txt b/testsuite/c_test/enhancec_test/ENC0086-boundary_bytecount_funcptr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0086-boundary_bytecount_funcptr/test.cfg b/testsuite/c_test/enhancec_test/ENC0086-boundary_bytecount_funcptr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e0fb31c19e0ceac78ba0166e12ffd4543499773
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0086-boundary_bytecount_funcptr/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+ENCO2_B_D:
+compile_err(boundary_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_funcptr.c
diff --git a/testsuite/c_test/enhancec_test/ENC0087-boundary_bytecount_funcptr_call/boundary_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0087-boundary_bytecount_funcptr_call/boundary_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..acaa586cb3fc1961b50a78d3ef0adbce1b28b95f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0087-boundary_bytecount_funcptr_call/boundary_check_funcptr.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int g_arr[] = {1,2,3,4,5,6,7,8,9,10};
+int *g_p __attribute__((count(10))) = g_arr;
+
+int* (*func1)(int*, int*, int*)  __attribute__((byte_count(40,1,3), returns_byte_count(40)));
+int* (*func2)(int*, int*, int*);
+int* (*func3)(int*, int*, int*)  __attribute__((byte_count(40,1,3), returns_byte_count(40)));
+int* (*func4)(int*, int*, int*)  __attribute__((byte_count(40,1,3)));
+int* (*func5)(int*, int*, int*)  __attribute__((byte_count(40,1), returns_byte_count(40)));
+int* (*func6)(int*, int*, int*)  __attribute__((byte_count(40,1,3), returns_byte_count(20)));
+int * vc __attribute__((returns_byte_count(40)));
+
+struct AA {
+  int* (*func1)(int*, int*, int*)  __attribute__((byte_count(40,1,3), returns_byte_count(40)));
+  int* (*func2)(int *, int*, int*);
+};
+
+struct BB {
+  int *i __attribute__((byte_count(48)));
+};
+
+__attribute__((byte_count(40,1,3), returns_byte_count(40)))
+int *Test1(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((byte_count(40,1), returns_byte_count(40)))
+int *Test2(int* p, int *q, int *w) {
+  return p;
+}
+
+__attribute__((byte_count(40,1,3)))
+int *Test3(int* p, int *q, int *w) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int *w) {
+  return p;
+}
+
+int Test() {
+  int i = 1;
+  int *p = g_p;
+  int array[] = {1,2,3,4,5,6,7,8,9,10};
+  int *q = array;
+  int *w __attribute__((count(5))) = array;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  int res = 0;
+  int *r2 = (*func2)(p, q, x);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r2;
+  int *r3 = (*a.func1)(p, p, q);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r3;
+  // int *r4 = (*pa->func1)(q, q, w);  // COM:CHECK: [[# @LINE ]] error
+  // res += *r4;
+  int *r5 = (*func1)(q, x, b.i);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r5;
+  int *r6 = (*func6)(pb->i, p, q);  // CHECK-NOT: [[# @LINE ]] error
+  res += *r6;  // CHECK-NOT: [[# @LINE ]] error
+
+  (*func1)(r3, r2, r3);  // CHECK-NOT: [[# @LINE ]] error
+  // (*func6)(r6, r3, r2);  // COM:CHECK: [[# @LINE ]] error
+
+  return res;
+}
+
+struct CC {
+  int* (*func1)(int*, int*, int*)  __attribute__((byte_count(40), byte_count(40,1,2,3), returns_byte_count(40)));
+  int* (*func2)(int *, int*, int*)  __attribute__((byte_count(40)));
+};
+
+__attribute__((byte_count(40,1,2), byte_count(60,3)))
+int Test_var(int *p, int *q, int *w) {
+  int* (*func11)(int*, int*, int*)  __attribute__((byte_count(40), byte_count(40,1,2,3), returns_byte_count(40)));
+  int* (*func12)(int*, int*, int*)  __attribute__((byte_count(40,1,2,3), returns_byte_count(40)));
+
+  (*func11)(p,q,w);  // CHECK-NOT: [[# @LINE ]] error
+  (*func12)(p,q,w);  // CHECK-NOT: [[# @LINE ]] error
+  struct CC c;
+  (*c.func1)(p,q,w);  // CHECK-NOT: [[# @LINE ]] error
+  (*c.func2)(p,q,w);  // CHECK-NOT: [[# @LINE ]] error
+
+  return 0;
+}
+
+int Test_arg(int* (*lfunc1)(int*, int*, int*) __attribute__((byte_count(40,1,3), returns_byte_count(40))),
+             int* (*lfunc2)(int*, int*, int*),
+             int* (*lfunc3)(int*, int*, int*) __attribute__((byte_count(40), byte_count(40,1,2,3), returns_byte_count(40)))) {
+  lfunc1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error
+
+  lfunc2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error
+
+  int *r1 = (*func1)(g_p, g_p, g_p);  // CHECK-NOT: [[# @LINE ]] error
+  return 0;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0087-boundary_bytecount_funcptr_call/expected.txt b/testsuite/c_test/enhancec_test/ENC0087-boundary_bytecount_funcptr_call/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0087-boundary_bytecount_funcptr_call/test.cfg b/testsuite/c_test/enhancec_test/ENC0087-boundary_bytecount_funcptr_call/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc26de77132db0e3d7a739f51642c6304d80957f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0087-boundary_bytecount_funcptr_call/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+ENCO2_B_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_funcptr.c
diff --git a/testsuite/c_test/enhancec_test/ENC0088-boundary_bytecount_funcptr_index/boundary_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0088-boundary_bytecount_funcptr_index/boundary_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..7238f64bb1598dfb47fef5e6846d2c8c622a75a2
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0088-boundary_bytecount_funcptr_index/boundary_check_funcptr.c
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int g_arr[] = {1,2,3,4,5};
+int *g_p __attribute__((count(5))) = g_arr;
+
+int* (*func1)(int*, int*, int)  __attribute__((byte_count_index(3,1,2), returns_byte_count_index(3)));
+int* (*func2)(int*, int*, int);
+int* (*func3)(int*, int*, int)  __attribute__((byte_count_index(3,1,2), returns_byte_count_index(3)));
+int* (*func4)(int*, int*, int)  __attribute__((byte_count_index(3,1,2)));
+int* (*func5)(int*, int*, int)  __attribute__((byte_count_index(3,1), returns_byte_count_index(3)));
+int* (*func6)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+
+int * vb __attribute__((byte_count_index(1)));
+int * vc __attribute__((returns_byte_count_index(1)));
+
+struct AA {
+  int* (*func1)(int*, int*, int)  __attribute__((byte_count_index(3,1,2), returns_byte_count_index(3)));
+  int* (*func2)(int *, int*, int);
+};
+
+struct BB {
+  int *i __attribute__((count(10)));
+};
+
+__attribute__((byte_count_index(3,1,2), returns_byte_count_index(3)))
+int *Test1(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((byte_count_index(3,1), returns_byte_count_index(3)))
+int *Test2(int* p, int *q, int len) {
+  return p;
+}
+
+int *Test3(int* p __attribute__((byte_count_index(3))), int *q __attribute__((byte_count_index(3))), int len) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int len) {
+  return p;
+}
+
+__attribute__((byte_count("len",1,2), returns_byte_count("len")))
+int *Test5(int* p, int *q, int len) {
+  return p;
+}
+
+int LEN = 10;
+__attribute__((byte_count(LEN,1,2), returns_byte_count(LEN)))
+int *Test6(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((returns_byte_count("len")))
+int *Test7(int* p __attribute__((byte_count("len"))), int *q __attribute__((byte_count("len"))), int len) {
+ return p;
+}
+
+__attribute__((count_index(3,1,2), returns_count_index(3)))
+int *Test8(int* p, int *q, int len) {
+  return p;
+}
+
+
+int Test() {
+  int len = 5;
+  int *p = g_p;
+  int array[] = {1,2,3,4,5,6,7,8,9,10};
+  int *q = array;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = &Test2;  // CHECK: [[# @LINE ]] error:
+  func1 = &Test3;  // CHECK: [[# @LINE ]] error:
+  func1 = &Test4;  // CHECK: [[# @LINE ]] error:
+  func1 = &Test5;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = &Test6;  // CHECK: [[# @LINE ]] error:
+  func1 = &Test7;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = &Test8;  // CHECK: [[# @LINE ]] error:
+
+  func2 = &Test1;  // CHECK: [[# @LINE ]] error:
+  func2 = &Test2;  // CHECK: [[# @LINE ]] error:
+  func2 = &Test3;  // CHECK: [[# @LINE ]] error:
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error:
+  func2 = &Test5;  // CHECK: [[# @LINE ]] error:
+  func2 = &Test6;  // CHECK: [[# @LINE ]] error:
+  func2 = &Test7;  // CHECK: [[# @LINE ]] error:
+  func2 = &Test8;  // CHECK: [[# @LINE ]] error:
+
+  func1 = func2;  // CHECK: [[# @LINE ]] error:
+  func1 = func3;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = func4;  // CHECK: [[# @LINE ]] error:
+  func1 = func5;  // CHECK: [[# @LINE ]] error:
+  func1 = func6;  // CHECK: [[# @LINE ]] error:
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+  a.func1 = &Test2;  // CHECK: [[# @LINE ]] error:
+  a.func1 = &Test3;  // CHECK: [[# @LINE ]] error:
+  a.func1 = &Test4;  // CHECK: [[# @LINE ]] error:
+  a.func1 = &Test5;  // CHECK-NOT: [[# @LINE ]] error:
+  a.func1 = &Test6;  // CHECK: [[# @LINE ]] error:
+  a.func1 = &Test7;  // CHECK-NOT: [[# @LINE ]] error:
+  a.func1 = &Test8;  // CHECK: [[# @LINE ]] error:
+
+  a.func1 = func2;  // CHECK: [[# @LINE ]] error:
+  a.func1 = func3;  // CHECK-NOT: [[# @LINE ]] error:
+  a.func1 = func4;  // CHECK: [[# @LINE ]] error:
+  a.func1 = func5;  // CHECK: [[# @LINE ]] error:
+  a.func1 = func6;  // CHECK: [[# @LINE ]] error:
+
+  func1 = a.func1;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = a.func2;  // CHECK: [[# @LINE ]] error:
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+  pa->func1 = &Test2;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = &Test3;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = &Test4;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = &Test5;  // CHECK-NOT: [[# @LINE ]] error:
+  pa->func1 = &Test6;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = &Test7;  // CHECK-NOT: [[# @LINE ]] error:
+  pa->func1 = &Test8;  // CHECK: [[# @LINE ]] error:
+
+  pa->func1 = func2;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = func3;  // CHECK-NOT: [[# @LINE ]] error:
+  pa->func1 = func4;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = func5;  // CHECK: [[# @LINE ]] error:
+  pa->func1 = func6;  // CHECK: [[# @LINE ]] error:
+
+  func1 = pa->func1;  // CHECK-NOT: [[# @LINE ]] error:
+  func1 = pa->func2;  // CHECK: [[# @LINE ]] error:
+
+  int res = 0;
+  int *r1 = (*func1)(p, q, 5);  // CHECK-NOT: [[# @LINE ]] warning:
+  res += *r1;
+  int *r2 = (*func2)(p, q, 10);  // CHECK-NOT: [[# @LINE ]] warning:
+  res += *r2;
+  int *r3 = (*func3)(p, q, len);  // CHECK-NOT: [[# @LINE ]] warning:
+  res += *r3;
+  // int *r4 = (*a.func1)(p, q, 10);  // COM:CHECK: [[# @LINE ]] warning:
+  // res += *r4;
+  // COM:CHECK: [[# @LINE + 1 ]] warning:
+  // int *r5 = (*pa->func1)(p, q, 11);  // COM:CHECK: [[# @LINE ]] warning:
+  // res += *r5;
+  int *r6 = (*func1)(b.i, p, 5);  // CHECK-NOT: [[# @LINE ]] warning:
+  res += *r6;
+  // COM:CHECK: [[# @LINE + 1 ]] warning:
+  // int *r7 = (*func1)(pb->i, p, 11);  // COM:CHECK: [[# @LINE ]] warning:
+  // res += *r7;
+  // int *r8 = (*func1)(r1, r2, 5);  // COM:CHECK: [[# @LINE ]] warning:
+  int *r9 = (*func1)(r1, r3, 5);  // CHECK-NOT: [[# @LINE ]] warning:
+  // COM:CHECK: [[# @LINE + 1 ]] warning:
+  // int *r10 = (*func1)(r1, r3, 10);  // COM:CHECK: [[# @LINE ]] warning:
+
+  return res;
+}
+
+int Test_arg(int* (*lfunc1)(int*, int*, int) __attribute__((byte_count_index(3,1,2), returns_byte_count_index(3))),
+             int* (*lfunc2)(int*, int*, int),
+             int* (*lfunc3)(int*, int*, int) __attribute__((byte_count(40), byte_count_index(3,1,2), returns_byte_count_index(3)))) {
+  lfunc1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+  lfunc1 = &Test2;  // CHECK: [[# @LINE ]] error:
+  lfunc1 = &Test3;  // CHECK: [[# @LINE ]] error:
+  lfunc1 = &Test4;  // CHECK: [[# @LINE ]] error:
+
+  lfunc2 = &Test1;  // CHECK: [[# @LINE ]] error:
+  lfunc2 = &Test2;  // CHECK: [[# @LINE ]] error:
+  lfunc2 = &Test3;  // CHECK: [[# @LINE ]] error:
+  lfunc2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error:
+
+  lfunc1 = func2;  // CHECK: [[# @LINE ]] error:
+  lfunc1 = func3;  // CHECK-NOT: [[# @LINE ]] error:
+  lfunc1 = func4;  // CHECK: [[# @LINE ]] error:
+  lfunc1 = func5;  // CHECK: [[# @LINE ]] error:
+  // int *r1 = (*func1)(g_p, g_p, 10);  // COM:CHECK: [[# @LINE ]] warning:
+  return 0;
+}
+
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0088-boundary_bytecount_funcptr_index/expected.txt b/testsuite/c_test/enhancec_test/ENC0088-boundary_bytecount_funcptr_index/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0088-boundary_bytecount_funcptr_index/test.cfg b/testsuite/c_test/enhancec_test/ENC0088-boundary_bytecount_funcptr_index/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e0fb31c19e0ceac78ba0166e12ffd4543499773
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0088-boundary_bytecount_funcptr_index/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+ENCO2_B_D:
+compile_err(boundary_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_funcptr.c
diff --git a/testsuite/c_test/enhancec_test/ENC0089-boundary_bytecount_funcptr_index_call/boundary_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0089-boundary_bytecount_funcptr_index_call/boundary_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d7ef4481b2dcfa0eaa439516eff017a7731b04a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0089-boundary_bytecount_funcptr_index_call/boundary_check_funcptr.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+int g_arr[] = {1,2,3,4,5};
+int *g_p __attribute__((count(5))) = g_arr;
+
+int* (*func1)(int*, int*, int)  __attribute__((byte_count_index(3,1,2), returns_byte_count_index(3)));
+int* (*func2)(int*, int*, int);
+int* (*func3)(int*, int*, int)  __attribute__((byte_count_index(3,1,2), returns_byte_count_index(3)));
+int* (*func4)(int*, int*, int)  __attribute__((byte_count_index(3,1,2)));
+int* (*func5)(int*, int*, int)  __attribute__((byte_count_index(3,1), returns_byte_count_index(3)));
+int* (*func6)(int*, int*, int)  __attribute__((count_index(3,1,2), returns_count_index(3)));
+
+int * vb __attribute__((byte_count_index(1)));
+int * vc __attribute__((returns_byte_count_index(1)));
+
+struct AA {
+  int* (*func1)(int*, int*, int)  __attribute__((byte_count_index(3,1,2), returns_byte_count_index(3)));
+  int* (*func2)(int *, int*, int);
+};
+
+struct BB {
+  int *i __attribute__((count(10)));
+};
+
+__attribute__((byte_count_index(3,1,2), returns_byte_count_index(3)))
+int *Test1(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((byte_count_index(3,1), returns_byte_count_index(3)))
+int *Test2(int* p, int *q, int len) {
+  return p;
+}
+
+int *Test3(int* p __attribute__((byte_count_index(3))), int *q __attribute__((byte_count_index(3))), int len) {
+  return p;
+}
+
+int *Test4(int *p, int *q ,int len) {
+  return p;
+}
+
+__attribute__((byte_count("len",1,2), returns_byte_count("len")))
+int *Test5(int* p, int *q, int len) {
+  return p;
+}
+
+int LEN = 10;
+__attribute__((byte_count(LEN,1,2), returns_byte_count(LEN)))
+int *Test6(int* p, int *q, int len) {
+  return p;
+}
+
+__attribute__((returns_byte_count("len")))
+int *Test7(int* p __attribute__((byte_count("len"))), int *q __attribute__((byte_count("len"))), int len) {
+ return p;
+}
+
+__attribute__((count_index(3,1,2), returns_count_index(3)))
+int *Test8(int* p, int *q, int len) {
+  return p;
+}
+
+
+int Test() {
+  int len = 5;
+  int *p = g_p;
+  int array[] = {1,2,3,4,5,6,7,8,9,10};
+  int *q = array;
+  int *x;
+  struct BB b;
+  struct BB *pb = &b;
+
+  func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+
+  func2 = &Test4;  // CHECK-NOT: [[# @LINE ]] error:
+
+  struct AA a;
+  a.func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+
+  a.func1 = func3;  // CHECK-NOT: [[# @LINE ]] error:
+
+  struct AA *pa;
+  pa = &a;
+  pa->func1 = &Test1;  // CHECK-NOT: [[# @LINE ]] error:
+
+  pa->func1 = func3;  // CHECK-NOT: [[# @LINE ]] error:
+
+  int res = 0;
+  int *r1 = (*func1)(p, q, 20);  // CHECK-NOT: [[# @LINE ]] error:
+  res += *r1;
+  int *r2 = (*func2)(p, q, 40);  // CHECK-NOT: [[# @LINE ]] error:
+  res += *r2;
+  int *r3 = (*func3)(p, q, len * 4);  // CHECK-NOT: [[# @LINE ]] error:
+  res += *r3;
+  // int *r4 = (*a.func1)(p, q, 40);  // COM:CHECK: [[# @LINE ]] error:
+  // res += *r4;
+  // COM:CHECK: [[# @LINE + 1 ]] warning:
+  // int *r5 = (*pa->func1)(p, q, 11);  // COM:CHECK: [[# @LINE ]] warning:
+  // res += *r5;
+  int *r6 = (*func1)(b.i, p, 20);  // CHECK-NOT: [[# @LINE ]] warning:
+  res += *r6;
+  // COM:CHECK: [[# @LINE + 1 ]] warning:
+  // int *r7 = (*func1)(pb->i, p, 11);  // COM:CHECK: [[# @LINE ]] warning:
+  // res += *r7;
+  // int *r8 = (*func1)(r1, r2, 5);  // COM:CHECK: [[# @LINE ]] warning:
+  int *r9 = (*func1)(r1, r3, 20);  // CHECK-NOT: [[# @LINE ]] warning:
+  // COM:CHECK: [[# @LINE + 1 ]] warning:
+  // int *r10 = (*func1)(r1, r3, 10);  // COM:CHECK: [[# @LINE ]] warning:
+
+  return res;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0089-boundary_bytecount_funcptr_index_call/expected.txt b/testsuite/c_test/enhancec_test/ENC0089-boundary_bytecount_funcptr_index_call/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0089-boundary_bytecount_funcptr_index_call/test.cfg b/testsuite/c_test/enhancec_test/ENC0089-boundary_bytecount_funcptr_index_call/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc26de77132db0e3d7a739f51642c6304d80957f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0089-boundary_bytecount_funcptr_index_call/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_N_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+ENCO2_B_D:
+compile(boundary_check_funcptr)
+run(boundary_check_funcptr)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_funcptr.c
diff --git a/testsuite/c_test/enhancec_test/ENC0090-ABCO_byte_count/expected.txt b/testsuite/c_test/enhancec_test/ENC0090-ABCO_byte_count/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0090-ABCO_byte_count/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0090-ABCO_byte_count/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..3390d5a8600d7d26dd0156b618e8ac896a8862d9
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0090-ABCO_byte_count/nonnull_check_if_err.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+#include <stdio.h>
+#include <stdlib.h>
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+
+#define ARG_LEN 16
+#define RET_LEN 16
+#define ARG_BYTE_COUNT (ARG_LEN * sizeof (char))
+#define RET_BYTE_COUNT (RET_LEN * sizeof(int))
+#define NUM 2
+#define OFFSET ARG_LEN
+
+int g_arg_count = ARG_BYTE_COUNT - 1;
+
+__attribute__((count("arg_len", 1)))
+int* func(char* arg, int arg_len, int ret_len) __attribute__((returns_byte_count("ret_len")));
+
+int* func(char* arg, int arg_len, int ret_len)
+{
+    for (int i = 0; i < arg_len; i++) {
+        arg[i] = 1;
+    }
+    ret_len = ret_len / sizeof(int);
+    int* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, int);
+    int* ret = ret_p;
+    return ret;
+}
+
+int main(int argc, char* argv[])
+{
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0090-ABCO_byte_count/test.cfg b/testsuite/c_test/enhancec_test/ENC0090-ABCO_byte_count/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a1c957fc1bc2ca9f6c539175bf3f6d2efe11eee1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0090-ABCO_byte_count/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assert"  --result=nonnull_check_if_err.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0090-inline_boundary_check_return_warning/inline_boundary_check_return_warning.c b/testsuite/c_test/enhancec_test/ENC0090-inline_boundary_check_return_warning/inline_boundary_check_return_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..36639ac7fcb652367190a51ef80cc0a2cf6e2269
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0090-inline_boundary_check_return_warning/inline_boundary_check_return_warning.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+__attribute__((returns_count("len")))
+int *getBoundaryPtr(int len, int len1) {
+  int* ret = (int*) malloc(len1 * sizeof(int));
+  return ret; // CHECK: [[# @LINE ]] warning: can't prove return value's bounds match the function declaration for getBoundaryPtr
+}
+
+
+int main() {
+  int *pa1 = getBoundaryPtr(4, 3) + 1;
+  printf("%d\n", pa1[2]);
+
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0090-inline_boundary_check_return_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0090-inline_boundary_check_return_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..60093cbf159e1e5f2e9378a8ee7e011521abb7f9
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0090-inline_boundary_check_return_warning/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_return_warning)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_return_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0091-ABCO_byte_count/expected.txt b/testsuite/c_test/enhancec_test/ENC0091-ABCO_byte_count/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0091-ABCO_byte_count/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0091-ABCO_byte_count/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..51faffc9c145dc3fb7957b0427a944e4527401c3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0091-ABCO_byte_count/nonnull_check_if_err.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+
+#define ARG_LEN 16
+#define RET_LEN 16
+#define ARG_BYTE_COUNT (ARG_LEN * sizeof(long))
+#define RET_BYTE_COUNT (RET_LEN * sizeof(float))
+#define NUM 2
+
+int g_arg_count = ARG_BYTE_COUNT - 1;
+
+float* __attribute__((count(ARG_LEN))) func(long* arg, int ret_len) \
+__attribute__((returns_count_index(2)));
+
+float* func(long* arg, int ret_len)
+{
+    for (int i = 0; i < ARG_LEN; i++) {
+        arg[i] = 1;
+    }
+    ret_len = ret_len * sizeof(float) / sizeof(double);
+    double* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, double);
+    double* ret = ret_p;
+    return (float*)ret;
+}
+
+int main(int argc, char* argv[])
+{
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0091-ABCO_byte_count/test.cfg b/testsuite/c_test/enhancec_test/ENC0091-ABCO_byte_count/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a1c957fc1bc2ca9f6c539175bf3f6d2efe11eee1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0091-ABCO_byte_count/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assert"  --result=nonnull_check_if_err.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0091-inline_nonnull_check_return_err/inline_nonnull_check_return_err.c b/testsuite/c_test/enhancec_test/ENC0091-inline_nonnull_check_return_err/inline_nonnull_check_return_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..b9385de1dd0f4fa7581a6f95929aa4f497a11a36
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0091-inline_nonnull_check_return_err/inline_nonnull_check_return_err.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+unsigned int* __attribute__((returns_nonnull)) func_a(int*  __attribute__((nonnull)) p) ;
+unsigned int* __attribute__((returns_nonnull)) func_b(int p) ;
+unsigned int g_b = 0;
+inline unsigned int* func_a(int* p)
+{
+    int a = *p;
+    *p = a + 1;
+    g_b = g_b + 1;
+    unsigned int* ret = (unsigned int*) malloc(sizeof(unsigned int));
+    ret = &g_b;
+    if (a > 1) {
+        ret = NULL;
+    }
+    return ret; // CHECK: [[# @LINE ]] error: func_a return nonnull but got null pointer when inlined to main
+}
+
+int main(int argc, char* argv[])
+{
+    int c = 0;
+    int* cPtr = NULL;
+    if (argc == 1) {
+        c = 23;
+        cPtr = &c;
+    }
+    if (cPtr != NULL) {
+        unsigned int* __attribute__((nonnull)) ret = func_a(cPtr);
+        printf("%d, %d\n", *ret, c);
+    }
+
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0091-inline_nonnull_check_return_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0091-inline_nonnull_check_return_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0ec03eeab6a733e9a62bafa89e278e9cb48e8d29
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0091-inline_nonnull_check_return_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_N_D:
+compile_err(inline_nonnull_check_return_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_nonnull_check_return_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0092-ABCO_byte_count/expected.txt b/testsuite/c_test/enhancec_test/ENC0092-ABCO_byte_count/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0092-ABCO_byte_count/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0092-ABCO_byte_count/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..ed7e7bc0580a15b82ae8f42de1e5622c0b4181ea
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0092-ABCO_byte_count/nonnull_check_if_err.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+#include <stdio.h>
+#include <stdlib.h>
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+
+#define ARG_LEN 16
+#define RET_LEN 16
+#define ARG_BYTE_COUNT (ARG_LEN * sizeof (char))
+#define RET_BYTE_COUNT (RET_LEN * sizeof(int))
+#define NUM 2
+#define OFFSET ARG_LEN
+
+int g_arg_count = ARG_BYTE_COUNT - 1;
+
+__attribute__((count("arg_len", 1)))
+int* func(char* arg, int arg_len, int ret_len) __attribute__((returns_byte_count("ret_len")));
+
+int* func(char* arg, int arg_len, int ret_len)
+{
+    ret_len = ret_len / sizeof(long);
+    int* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, int);
+    int* ret = ret_p;
+    return ret; // need error
+}
+
+int* func1(char* arg, int arg_len, int ret_len) __attribute__((returns_byte_count("ret_len")));
+int* func1(char* arg, int arg_len, int ret_len)
+{
+    ret_len = ret_len / 7;
+    int* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, int);
+    int* ret = ret_p;
+    return ret; // need error
+}
+int* func2(char* arg, int arg_len, int ret_len) __attribute__((returns_byte_count("ret_len")));
+int* func2(char* arg, int arg_len, int ret_len)
+{
+    ret_len = ret_len;
+    int* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, int);
+    int* ret = ret_p;
+    return ret; // need delete the assert
+}
+int* func3(char* arg, int arg_len, int ret_len) __attribute__((returns_byte_count("ret_len")));
+int* func3(char* arg, int arg_len, int ret_len)
+{
+    ret_len = ret_len * 3;
+    int* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, int);
+    int* ret = ret_p;
+    return ret; // need delete the assert
+}
+
+int* func4(char* arg, int arg_len, int ret_len) __attribute__((returns_byte_count("ret_len")));
+int* func4(char* arg, int arg_len, int ret_len)
+{
+    ret_len = ret_len / 2;
+    int* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, int);
+    int* ret = ret_p;
+    return ret; // need delete the asert
+}
+
+
+int main(int argc, char* argv[])
+{
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0092-ABCO_byte_count/test.cfg b/testsuite/c_test/enhancec_test/ENC0092-ABCO_byte_count/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..082dd5bafaf602e8bdf36a42c8e1a73a84271520
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0092-ABCO_byte_count/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+run(nonnull_check_if_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=5 --str="returnassertle"  --result=nonnull_check_if_err.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0092-inline_nonnull_check_return_warning/inline_nonnull_check_return_warning.c b/testsuite/c_test/enhancec_test/ENC0092-inline_nonnull_check_return_warning/inline_nonnull_check_return_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..9269999f7d4d649a6761c1defb355e8b7cf3193b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0092-inline_nonnull_check_return_warning/inline_nonnull_check_return_warning.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+unsigned int* __attribute__((returns_nonnull)) func_a(int*  __attribute__((nonnull)) p) ;
+unsigned int* __attribute__((returns_nonnull)) func_b(int p) ;
+unsigned int g_b = 0;
+
+
+inline unsigned int* func_a(int* p)
+{
+    int a = *p;
+    *p = a + 1;
+    g_b = g_b + 1;
+    unsigned int* ret = (unsigned int*) malloc(sizeof(unsigned int));
+    ret = &g_b;
+    if (a > 1) {
+        ret = NULL;
+    }
+    return ret; // CHECK: [[# @LINE ]] warning: func_a return nonnull but got nullable pointer when inlined to main
+}
+
+unsigned int* func_b(int p)
+{
+    g_b = g_b + 1;
+    unsigned int* ret = (unsigned int*) malloc(sizeof(unsigned int));
+    if (p > 1) {
+        ret = NULL;
+    } else {
+        ret = &g_b;
+    }
+    return ret; // CHECK: [[# @LINE ]] warning: func_b return nonnull but got nullable pointer
+}
+
+int main(int argc, char* argv[])
+{
+    int c = 0;
+    int* cPtr = NULL;
+    if (argc == 1) {
+        c = 23;
+        cPtr = &c;
+    } else {
+        c = 1;
+        cPtr = &c;
+    }
+    if (cPtr != NULL) {
+        unsigned int* __attribute__((nonnull)) ret = func_a(cPtr);
+        printf("%d, %d\n", *ret, c);
+    }
+    c = 1;
+    cPtr = &c;
+    unsigned int* __attribute__((nonnull)) ret = func_b(1);
+    printf("%d, %d\n", *ret, c);
+
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0092-inline_nonnull_check_return_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0092-inline_nonnull_check_return_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..25b826a7c67586e26b4aabd2546e279c87703812
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0092-inline_nonnull_check_return_warning/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_N_D:
+compile(inline_nonnull_check_return_warning)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_nonnull_check_return_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0093-ABCO_byte_count/nonnull_check_if_err.c b/testsuite/c_test/enhancec_test/ENC0093-ABCO_byte_count/nonnull_check_if_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..b691cc505959bf1fe4e20adcf3f981cfd80a069f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0093-ABCO_byte_count/nonnull_check_if_err.c
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/nonnull_check_if_err.c"
+#include <stdio.h>
+#include <stdlib.h>
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+
+#define ARG_LEN 16
+#define RET_LEN 16
+#define ARG_BYTE_COUNT (ARG_LEN * sizeof (char))
+#define RET_BYTE_COUNT (RET_LEN * sizeof(int))
+#define NUM 2
+#define OFFSET ARG_LEN
+
+int g_arg_count = ARG_BYTE_COUNT - 1;
+
+__attribute__((count("arg_len", 1)))
+__attribute__((noinline))
+int* func(char* arg, int arg_len, int ret_len) __attribute__((returns_byte_count("ret_len")));
+
+int* func(char* arg, int arg_len, int ret_len)
+{
+    for (int i = 0; i < arg_len; i++) {
+        arg[i] = 1;
+    }
+    ret_len = ret_len / sizeof(int);
+    int* ret_p __attribute__((count(ret_len))) = MALLOC(ret_len, int);
+    int* ret = ret_p;
+    return ret;
+}
+
+int main(int argc, char* argv[])
+{
+    int arg_len = ARG_LEN;
+    int ret_len = RET_LEN;
+    char* arg __attribute__((count(arg_len * 2))) = MALLOC(arg_len * 2, char);
+    if (argc != 1) {
+        arg_len = ARG_LEN + OFFSET;
+    }
+    int* ret = func(arg, arg_len, ret_len * sizeof(int));
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0093-ABCO_byte_count/test.cfg b/testsuite/c_test/enhancec_test/ENC0093-ABCO_byte_count/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cafeaeb5bcad32569ee1c94feb68c0da35072bcb
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0093-ABCO_byte_count/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile(nonnull_check_if_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="assert"  --result=nonnull_check_if_err.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0093-boundary_check_i--/boundary_check_i--.c b/testsuite/c_test/enhancec_test/ENC0093-boundary_check_i--/boundary_check_i--.c
new file mode 100644
index 0000000000000000000000000000000000000000..85057f4a7f3d1b464235cc508b277376baad8c57
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0093-boundary_check_i--/boundary_check_i--.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+int main () {
+  static int a[] = { 0, 1, 2 };
+  int *i = &a[sizeof(a)/sizeof(*a)] - 1;
+  while (i > a) {
+    printf("%d\n", *i);
+    i--;
+  }
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0093-boundary_check_i--/expected.txt b/testsuite/c_test/enhancec_test/ENC0093-boundary_check_i--/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5f1d0ecea5d750ac0e30713a0aee40cdde3b2a52
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0093-boundary_check_i--/expected.txt
@@ -0,0 +1,2 @@
+2
+1
diff --git a/testsuite/c_test/enhancec_test/ENC0093-boundary_check_i--/test.cfg b/testsuite/c_test/enhancec_test/ENC0093-boundary_check_i--/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..435aed784465e36e96e747dd98580b959c727261
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0093-boundary_check_i--/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile(boundary_check_i--)
+run(boundary_check_i--)
diff --git a/testsuite/c_test/enhancec_test/ENC0094-boundary_byte_count_err/boundary_byte_count.c b/testsuite/c_test/enhancec_test/ENC0094-boundary_byte_count_err/boundary_byte_count.c
new file mode 100644
index 0000000000000000000000000000000000000000..00097eb9da43f0493cb53a54ae32de8dfc28b8d3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0094-boundary_byte_count_err/boundary_byte_count.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+// CHECK: [[# FILENUM:]] "{{.*}}/boundary_byte_count.c"
+
+#include <stdio.h>
+__attribute__((returns_byte_count_index(2), byte_count_index(2, 1)))
+int *getBoundaryPtrOutRange(int *ptr, int len) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: assertge{{.*}}
+  int *p = ptr + 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: assertle{{.*}}
+  return p;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0094-boundary_byte_count_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0094-boundary_byte_count_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..27ec1130c0871f89508697a04ba45ea4c29b25de
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0094-boundary_byte_count_err/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile_err(boundary_byte_count)
+cat boundary_byte_count.mpl | ${OUT_ROOT}/tools/bin/FileCheck boundary_byte_count.c
diff --git a/testsuite/c_test/enhancec_test/ENC0095-boundary_string/boundary_string.c b/testsuite/c_test/enhancec_test/ENC0095-boundary_string/boundary_string.c
new file mode 100644
index 0000000000000000000000000000000000000000..f657a15ddf6f208541d7db02a12d541c4ea335a9
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0095-boundary_string/boundary_string.c
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+
+char * const g_s = "12345";
+char g_s_arr[10] = "12345";
+char g_s_arr1[] = "12345";
+char * const g_s_arr2[2] = {"12345", "123456"};
+
+struct A {
+  int i[2][2];
+  char *j;
+};
+
+struct B {
+  int i;
+  double j;
+  struct A a;
+};
+
+union U {
+  int i;
+  char *c;
+};
+
+union U1 {
+ char *c;
+ int i;
+};
+
+struct C {
+  int i;
+  struct A a;
+  union U1 u1;
+};
+
+#define STR "123456"
+
+const struct A g_a = {{{1,2},{1,2}}, "12345678"};
+const struct A g_a1 = {.j = "12345678"};
+const struct B g_b = {1, 2.1, {{{1,2},{1,2}}, "123456789"}};
+const struct B g_b_arr[2] = { {1, 2.1, { {{1,2},{1,2}}, "123456789"} }, 
+                            {1, 2.2, { {{1,2},{1,2}}, "123456"} } };
+const union U g_u = {.c="12345"};
+const struct C g_c_arr[2] = { {1, { {{1,2},{1,2}}, "123456789"}, "1234567" },
+                            {1, { {{1,2},{1,2}}, "123456"}, "12345678" }};
+
+
+int get(char *buf __attribute__((count(5)))) {
+  return buf[1];
+}
+
+void test() {
+  int res = 0;
+  res += get(STR);  // CHECK-NOT: [[# @LINE ]] error
+
+  char *str = "abcdefg";
+  char str_arr[10] = "abcdefg";
+  char str_arr1[] = "abcdefg";
+  res += get(str);  // CHECK-NOT: [[# @LINE ]] error
+  res += get(str_arr);  // CHECK-NOT: [[# @LINE ]] error
+  res += get(str_arr1);  // CHECK-NOT: [[# @LINE ]] error
+  char *str1 = str;
+  res += get(str1);  // CHECK-NOT: [[# @LINE ]] error
+
+  res += get(g_s);  // CHECK-NOT: [[# @LINE ]] error
+  res += get(g_s_arr);  // CHECK-NOT: [[# @LINE ]] error
+  res += get(g_s_arr1);  // CHECK-NOT: [[# @LINE ]] error
+  res += get(g_s_arr2[1]);  // CHECK-NOT: [[# @LINE ]] error
+
+  res += get(g_a.j);  // CHECK-NOT: [[# @LINE ]] error
+  res += get(g_b.a.j);  // CHECK-NOT: [[# @LINE ]] error
+  res += get(g_b_arr[1].a.j);  // CHECK-NOT: [[# @LINE ]] error
+
+  res += get(g_u.c);  // CHECK-NOT: [[# @LINE ]] error
+  res += get(g_c_arr[1].a.j);  // CHECK-NOT: [[# @LINE ]] error
+  res += get(g_c_arr[1].u1.c);  // CHECK-NOT: [[# @LINE ]] error
+
+  char *l = g_s_arr;
+  res += get(l);  // CHECK-NOT: [[# @LINE ]] error
+
+  struct B b = {1, 2.1, {{{1,2},{1,2}}, "123456789"}};
+//  struct B b_arr[2] = { {1, 2.1, { {1,2}, "123456789"}},
+//                          {1, 2.2, { {1,2}, "123456"}}};
+  struct B b_arr[2];
+  res += get(b.a.j);  // CHECK-NOT: [[# @LINE ]] error
+  b_arr[1].a.j = "abcdf";
+  res += get(b_arr[1].a.j);  // CHECK-NOT: [[# @LINE ]] error
+
+  union U u = {.c="12345"};
+  res += get(u.c);  // CHECK-NOT: [[# @LINE ]] error
+
+  // char *i;
+  // res += get(i);  // COM:CHECK: [[# @LINE ]] error
+  
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0095-boundary_string/expected.txt b/testsuite/c_test/enhancec_test/ENC0095-boundary_string/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0095-boundary_string/test.cfg b/testsuite/c_test/enhancec_test/ENC0095-boundary_string/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c4d42b69cd4ece475c9770af76a5aea32b3a791
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0095-boundary_string/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_B_D:
+compile(boundary_string)
+run(boundary_string)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_string.c
+ENCO2_N_D:
+compile(boundary_string)
+run(boundary_string)
diff --git a/testsuite/c_test/enhancec_test/ENC0096-nonnull_check_funcptr1/nonnull_check_funcptr.c b/testsuite/c_test/enhancec_test/ENC0096-nonnull_check_funcptr1/nonnull_check_funcptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2675546e824160f3bd8ca63b1e6a39558327fec
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0096-nonnull_check_funcptr1/nonnull_check_funcptr.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stddef.h>
+
+#include <stdio.h>
+#include <float.h>
+
+float MaxFloat(float a, float b)
+{
+    return (a - b) > FLT_MIN ? a : b;
+}
+
+double MaxDouble(double a, double b)
+{
+    return (a - b) > DBL_MIN ? a : b;
+}
+
+long double MaxLongDouble(long double a, long double b)
+{
+    return (a - b) > LDBL_MIN ? a : b;
+}
+
+int main()
+{
+    float floatA = -1.0;
+    float floatB = 0.0;
+    float floatMaxValue;
+    double doubleA = 0.0;
+    double doubleB = 1.0;
+    double doubleMaxValue;
+    long double lDoubleA = 0.0; // -0.0;
+    long double lDoubleB = 0.0;
+    long double lDoubleMaxValue;
+    int errNum = 0;
+
+    float (*floatMax)(float, float) __attribute__((nonnull)) = MaxFloat;
+    double (*doubleTest)(double, double) __attribute__((nonnull)) = MaxDouble;
+    double (*doubleMax)(double, double) __attribute__((nonnull)) = doubleTest;
+    long double (*lDoubleTest1)(long double, long double) __attribute__((nonnull)) = MaxLongDouble;
+    long double (*lDoubleTest2)(long double, long double) = lDoubleTest1;
+    long double (*lDoubleMax)(long double, long double) __attribute__((nonnull)) = lDoubleTest2;
+
+    floatMaxValue = (*floatMax)(floatA, floatB);
+    doubleMaxValue = (*doubleMax)(doubleA, doubleB);
+    lDoubleMaxValue = (*lDoubleMax)(lDoubleA, lDoubleB);
+
+    errNum += ((floatMaxValue - MaxFloat(floatA, floatB)) < FLT_MIN ? 0 : 1);
+    errNum += ((doubleMaxValue - MaxDouble(doubleA, doubleB)) < DBL_MIN ? 0 : 1);
+    errNum += ((lDoubleMaxValue - MaxLongDouble(lDoubleA, lDoubleB)) < LDBL_MIN ? 0 : 1);
+
+    return errNum;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0096-nonnull_check_funcptr1/test.cfg b/testsuite/c_test/enhancec_test/ENC0096-nonnull_check_funcptr1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..423ba35564707bcc5b4c7d8e3022b929049d49b3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0096-nonnull_check_funcptr1/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_N_D:
+compile(nonnull_check_funcptr)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="warning"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0097-safe_boundary_check/expected.txt b/testsuite/c_test/enhancec_test/ENC0097-safe_boundary_check/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0097-safe_boundary_check/safe_region.c b/testsuite/c_test/enhancec_test/ENC0097-safe_boundary_check/safe_region.c
new file mode 100644
index 0000000000000000000000000000000000000000..4f2409d461a1dc422ff9d268bbb38fbb0038c50b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0097-safe_boundary_check/safe_region.c
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+int g_arr[] = {1,2,3,4,5};
+int *g_p = g_arr;
+
+void func0(void) {
+  g_p += 1;  // CHECK-NOT: [[# @LINE ]] error
+  __Safe__ {
+    g_p += 1;  // CHECK: [[# @LINE ]] error
+  }
+  g_p += 1;  // CHECK-NOT: [[# @LINE ]] error
+}
+
+#pragma SAFE OFF
+
+void func1(void) {
+  g_p += 1;  // CHECK-NOT: [[# @LINE ]] error
+}
+
+__Safe__ int func2(void);
+
+#pragma SAFE ON
+
+__Unsafe__ void func3(void) {
+  g_p += 1;  // CHECK-NOT: [[# @LINE ]] error
+}
+
+void func4() {
+  g_p += 1;  // CHECK: [[# @LINE ]] error
+}
+
+int main(void) {
+  return 0;
+}
+
+__Safe__ int func2(void) {
+  int a = 0;
+  __Safe__ {
+    g_p += 1;  // CHECK: [[# @LINE ]] error
+    __Unsafe__ {
+      g_p += 1;  // CHECK-NOT: [[# @LINE ]] error
+      __Safe__ {
+        g_p += 1;  // CHECK: [[# @LINE ]] error
+      }
+      g_p += 1;  // CHECK-NOT: [[# @LINE ]] error
+    }
+    g_p += 1;  // CHECK: [[# @LINE ]] error
+  }
+  g_p += 1;  // CHECK: [[# @LINE ]] error
+  return g_p[2];  // CHECK: [[# @LINE ]] error
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0097-safe_boundary_check/test.cfg b/testsuite/c_test/enhancec_test/ENC0097-safe_boundary_check/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..75897cd859e179365b3295105fe0f54370d6b349
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0097-safe_boundary_check/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_S_D:
+compile_err(safe_region)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck safe_region.c
diff --git a/testsuite/c_test/enhancec_test/ENC0098-boundary_call_opt/nonnull_check_call_err.c b/testsuite/c_test/enhancec_test/ENC0098-boundary_call_opt/nonnull_check_call_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ec9450bf9e934e5e86e0a22bfaeb5e522572db1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0098-boundary_call_opt/nonnull_check_call_err.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+
+__attribute__((count_index(2, 1)))
+void test3(char* p, size_t size) {
+    for (int i=0; i< size; ++i) {
+      printf("%p\n", p++ );
+    }
+}
+__attribute__((count_index(2, 1)))
+void test2(int *p, int len) {
+    if(len >=12 ) {
+      size_t count = (size_t)(unsigned int)len * (sizeof(int));
+      test3((char*)p, count);
+    }
+}
+
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0098-boundary_call_opt/test.cfg b/testsuite/c_test/enhancec_test/ENC0098-boundary_call_opt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0aa56ef9f834aa3da339be49ff80edcac457e310
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0098-boundary_call_opt/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile(nonnull_check_call_err)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="callassertle"  --result=nonnull_check_call_err.me.mpl
diff --git a/testsuite/c_test/enhancec_test/ENC0099-inline_boundary_check_return_err/inline_boundary_check_return_err.c b/testsuite/c_test/enhancec_test/ENC0099-inline_boundary_check_return_err/inline_boundary_check_return_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..d8210991c65476e843db958b03af6cfd6e0ff1ff
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0099-inline_boundary_check_return_err/inline_boundary_check_return_err.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+__attribute__((returns_count("len")))
+static inline int *getBoundaryPtr(int len, int len1) {
+  int* ret = (int*) malloc(len1 * sizeof(int));
+  return ret; // CHECK: [[# @LINE ]] error: return value's bounds does not match the function declaration for getBoundaryPtr  when inlined to main
+}
+
+
+int main() {
+  int *pa1 = getBoundaryPtr(4, 3) + 1;
+  printf("%d\n", pa1[2]);
+
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0099-inline_boundary_check_return_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0099-inline_boundary_check_return_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8a734efbf1ce6b84fc7b8308d52a551f2fa4ea59
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0099-inline_boundary_check_return_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_return_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_return_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0100-boundary-check-for-puzzle/expected.txt b/testsuite/c_test/enhancec_test/ENC0100-boundary-check-for-puzzle/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1f102645645abd8f9bc1352c4739e360e4e620a9
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0100-boundary-check-for-puzzle/expected.txt
@@ -0,0 +1,5 @@
+Found duplicate: 256943
+Found duplicate: 106186
+Found duplicate: 465226
+Found duplicate: 112763
+Found duplicate: 406647
diff --git a/testsuite/c_test/enhancec_test/ENC0100-boundary-check-for-puzzle/puzzle.c b/testsuite/c_test/enhancec_test/ENC0100-boundary-check-for-puzzle/puzzle.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb067a486e13084805d6edab0ea414e016278858
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0100-boundary-check-for-puzzle/puzzle.c
@@ -0,0 +1,84 @@
+#include "stdlib.h"
+#include "stdio.h"
+#define ARRAY_SIZE 500000
+#define NLOOPS1 5
+#define NLOOPS2 200
+
+// RNG implemented localy to avoid library incongruences
+#ifdef RAND_MAX
+#undef RAND_MAX
+#endif
+#define RAND_MAX 32767
+static unsigned long long int next = 1;
+int rand( void ) {
+    next = next * 1103515245 + 12345;
+    return (unsigned int)(next / 65536) % RAND_MAX+1;
+}
+void srand( unsigned int seed ) {
+    next = seed;
+}
+// End of RNG implementation
+
+int randInt(int min, int max) {
+    int k, n;
+    n = (max - min) + 1;
+    k = (int)(n * (rand() / (RAND_MAX + 1.0)));
+    return (k == n) ? k + min - 1 : k + min;
+}
+
+void shuffle(int* items, int len) {
+    size_t j, k, i;
+    int aux;
+
+    for(i = len-1; i > 0; --i) {
+        k = (int)((i + 1) * (rand() / (RAND_MAX + 1.0)));
+        j = (k == (i + 1)) ? k - 1 : k;
+
+        aux = items[i];
+        items[i] = items[j];
+        items[j] = aux;
+    }
+}
+
+int *createRandomArray(int size) {
+    int i, len;
+    int *result;
+
+    len = size + 1;
+    //result = (int*)malloc(0);
+    result = (int*)malloc(len * sizeof(int));
+    for (i = 0; i < len; i++)
+    // CHECK-NOT: [[# @LINE ]] warning: cant't prove the offset < the upper bounds
+    // CHECK-NOT: [[# @LINE ]] warning: cant't prove the offset >= the lower bounds
+        result[i] = i;
+    result[0] = randInt(1, size); // CHECK: [[# @LINE ]] warning: can't prove the pointer < the upper bounds when accessing the memory
+    shuffle(result, len);
+    return result;
+}
+
+int findDuplicate(int *data, int len) {
+    int i;
+    int result = 0;
+
+    for (i = 0; i < len; i++)
+        result = result ^ (i + 1) ^ data[i];
+    result ^= len;
+    return result;
+}
+
+int main() {
+    int i, j, duplicate;
+    int *rndArr;
+
+    srand(1);
+
+    for (i = 0; i < NLOOPS1; i++) {
+        rndArr = createRandomArray(ARRAY_SIZE);
+        for (j = 0; j < NLOOPS2; j++)
+            duplicate = findDuplicate(rndArr, ARRAY_SIZE+1);
+        free(rndArr);
+        printf("Found duplicate: %d\n", duplicate);
+    }
+
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0100-boundary-check-for-puzzle/test.cfg b/testsuite/c_test/enhancec_test/ENC0100-boundary-check-for-puzzle/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0c6d000473ef0b661859fb033e45bbb5533571a9
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0100-boundary-check-for-puzzle/test.cfg
@@ -0,0 +1,10 @@
+ENCO2_B_D:
+compile(puzzle)
+run(puzzle)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck puzzle.c
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="assert"  --result=puzzle.me.mpl
+ENCO2_N_D:
+compile(puzzle)
+run(puzzle)
diff --git a/testsuite/c_test/enhancec_test/ENC0101-boundary-check-for-heapsort/expected.txt b/testsuite/c_test/enhancec_test/ENC0101-boundary-check-for-heapsort/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3f81b9028cb4b7e27adae74a752b709272766713
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0101-boundary-check-for-heapsort/expected.txt
@@ -0,0 +1 @@
+0.999993
diff --git a/testsuite/c_test/enhancec_test/ENC0101-boundary-check-for-heapsort/heapsort.c b/testsuite/c_test/enhancec_test/ENC0101-boundary-check-for-heapsort/heapsort.c
new file mode 100644
index 0000000000000000000000000000000000000000..eeb595dcdfb80523eb77e3a855a68d2f82112610
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0101-boundary-check-for-heapsort/heapsort.c
@@ -0,0 +1,83 @@
+/* -*- mode: c -*-
+ * $Id$
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#define heapsort benchmark_heapsort
+
+#define IM 139968
+#define IA   3877
+#define IC  29573
+
+double
+gen_random(double max) {
+    static long last = 42;
+    return( max * (last = (last * IA + IC) % IM) / IM );
+}
+
+void
+heapsort(int n, double *ra) {
+    int i, j;
+    int ir = n;
+    int l = (n >> 1) + 1;
+    double rra;
+
+    for (;;) {
+      if (l > 1) {
+        rra = ra[--l];
+      } else {
+        rra = ra[ir];
+        ra[ir] = ra[1];
+        if (--ir == 1) {
+          ra[1] = rra;
+          return;
+        }
+      }
+
+      i = l;
+      j = l << 1;
+      while (j <= ir) {
+        if (j < ir && ra[j] < ra[j+1]) {
+          ++j;
+        }
+        if (rra < ra[j]) {
+          ra[i] = ra[j];
+          j += (i = j);
+        } else {
+          j = ir + 1;
+        }
+      }
+      ra[i] = rra;
+    }
+}
+
+int
+main(int argc, char *argv[]) {
+#ifdef SMALL_PROBLEM_SIZE
+#define LENGTH 800000
+#else
+#define LENGTH 8000000
+#endif
+    int N = ((argc == 2) ? atoi(argv[1]) : LENGTH);
+    double *ary;
+    int i;
+    /* create an array of N random doubles */
+    ary = (double *)malloc((N+1) * sizeof(double));
+    for (i=1; i<=N; i++) {
+        // CHECK-NOT: [[# @LINE+2 ]] warning: cant't prove the pointer < the upper bounds when accessing the memory
+        // CHECK-NOT: [[# @LINE+1 ]] warning: cant't prove the pointer >= the lower bounds when accessing the memory
+       ary[i] = gen_random(1);
+    }
+
+    heapsort(N, ary);
+
+    // CHECK: [[# @LINE+1 ]] warning: can't prove the pointer >= the lower bounds when accessing the memory
+    printf("%f\n", ary[N]);
+
+    free(ary);
+    return(0);
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0101-boundary-check-for-heapsort/test.cfg b/testsuite/c_test/enhancec_test/ENC0101-boundary-check-for-heapsort/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8d78f45616cb0f8501ca5123a67eba1637664144
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0101-boundary-check-for-heapsort/test.cfg
@@ -0,0 +1,11 @@
+ENCO2_B_D:
+compile(heapsort)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck heapsort.c
+# only one assertge
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="assert"  --result=heapsort.me.mpl
+run(heapsort)
+ENCO2_N_D:
+compile(heapsort)
+run(heapsort)
diff --git a/testsuite/c_test/enhancec_test/ENC0102-boundary-check-for-MAX/expected.txt b/testsuite/c_test/enhancec_test/ENC0102-boundary-check-for-MAX/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1674ee705692b0d1dbf4e7f6f7e35f00145842c7
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0102-boundary-check-for-MAX/expected.txt
@@ -0,0 +1,8 @@
+i=2147483645, INT_MAX=2147483647: j=-2147483648, INT_MIN=-2147483648: i:[0] j:[0]
+j=-2147483647, INT_MIN=-2147483648: i:[0] j:[1]
+j=-2147483646, INT_MIN=-2147483648: i:[0] j:[2]
+j=-2147483645, INT_MIN=-2147483648: i:[0] j:[3]
+i=2147483646, INT_MAX=2147483647: j=-2147483648, INT_MIN=-2147483648: i:[1] j:[0]
+j=-2147483647, INT_MIN=-2147483648: i:[1] j:[1]
+j=-2147483646, INT_MIN=-2147483648: i:[1] j:[2]
+j=-2147483645, INT_MIN=-2147483648: i:[1] j:[3]
diff --git a/testsuite/c_test/enhancec_test/ENC0102-boundary-check-for-MAX/test.cfg b/testsuite/c_test/enhancec_test/ENC0102-boundary-check-for-MAX/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..94fcf31c4e017f1db45b0d1259d26c07717d0b0b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0102-boundary-check-for-MAX/test.cfg
@@ -0,0 +1,8 @@
+ENCO2_B_D:
+compile(thvs2)
+cat compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=2 --str="assert"  --result=thvs2.me.mpl
+run(thvs2)
+ENCO2_N_D:
+compile(thvs2)
+run(thvs2)
diff --git a/testsuite/c_test/enhancec_test/ENC0102-boundary-check-for-MAX/thvs2.c b/testsuite/c_test/enhancec_test/ENC0102-boundary-check-for-MAX/thvs2.c
new file mode 100644
index 0000000000000000000000000000000000000000..4ae3aeb29b9b92416c852b1d333f8b156154dfce
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0102-boundary-check-for-MAX/thvs2.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <limits.h>
+
+/* I'm doing something trying to screw up loop optimizations
+ * and return 1 when I know everything is OK
+ */
+#define I 2
+#define K 3
+#define J 4
+int a[I][K] = { { 0, 1, 2}, {3, 4, 5} };
+int b[K][J] = { { 0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };
+int c[I][J];
+
+int
+test(void)
+{
+  int i;
+  int j;
+  int k;
+  int s = 0;
+
+  for (i=INT_MAX-I; i<INT_MAX; i++) {
+    printf("i=%d, INT_MAX=%d: ", i, INT_MAX);
+    for (j=INT_MIN; j<=J-1+INT_MIN; j++) {
+      printf("j=%d, INT_MIN=%d: ", j, INT_MIN);
+      printf("i:[%d] j:[%d]", i-INT_MAX+I, j-INT_MIN);
+      for (k=0; k<K; k++) {
+        c[i-INT_MAX+I][j-INT_MIN]
+          += a[i-INT_MAX+I][k]
+            *b[k][j-INT_MIN];
+      }
+      printf("\n");
+    }
+  }
+  for (i=0; i<I; i++) {
+    for (j=0; j<J; j++) {
+      s += c[i][j];
+    }
+  }
+  return s;
+}
+
+int main()
+{
+   if (test() != 394) {
+     printf("error\n");
+     return -1;
+   }
+   return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0103-boundary-check-for-replace-variable/ReedSolomon.c b/testsuite/c_test/enhancec_test/ENC0103-boundary-check-for-replace-variable/ReedSolomon.c
new file mode 100644
index 0000000000000000000000000000000000000000..51e69d3494b6291f7ac88ddf6a58364949eb1112
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0103-boundary-check-for-replace-variable/ReedSolomon.c
@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define mm  8           /* RS code over GF(2**4) - change to suit */
+#define nn  255         /* nn=2**mm -1   length of codeword */
+#define tt  8           /* number of errors that can be corrected */
+#define kk  239         /* kk = nn-2*tt  */
+
+static int pp [mm+1] = { 1, 0, 1, 1, 1, 0, 0, 0, 1} ; /* specify irreducible polynomial coeffts */
+static int alpha_to [nn+1], index_of [nn+1], gg [nn-kk+1] ;
+static int recd [nn], data [kk], bb [nn-kk] ;
+static int inited = 0;
+
+static void generate_gf()
+/* generate GF(2**mm) from the irreducible polynomial p(X) in pp[0]..pp[mm]
+   lookup tables:  index->polynomial form   alpha_to[] contains j=alpha**i;
+                   polynomial form -> index form  index_of[j=alpha**i] = i
+   alpha=2 is the primitive element of GF(2**mm)
+*/
+ {
+   register int i, mask ;
+
+  mask = 1 ;
+  alpha_to[mm] = 0 ;
+  for (i=0; i<mm; i++)
+   { alpha_to[i] = mask ;
+     index_of[alpha_to[i]] = i ;
+     if (pp[i]!=0)
+       alpha_to[mm] ^= mask ;
+     mask <<= 1 ;
+   }
+  index_of[alpha_to[mm]] = mm ;
+  mask >>= 1 ;
+  for (i=mm+1; i<nn; i++)
+   { if (alpha_to[i-1] >= mask)
+        alpha_to[i] = alpha_to[mm] ^ ((alpha_to[i-1]^mask)<<1) ;
+     else alpha_to[i] = alpha_to[i-1]<<1 ;
+     index_of[alpha_to[i]] = i ;
+   }
+  index_of[0] = -1 ;
+ }
+
+
+static void gen_poly()
+/* Obtain the generator polynomial of the tt-error correcting, length
+  nn=(2**mm -1) Reed Solomon code  from the product of (X+alpha**i), i=1..2*tt
+*/
+ {
+   register int i,j ;
+
+   gg[0] = 2 ;    /* primitive element alpha = 2  for GF(2**mm)  */
+   gg[1] = 1 ;    /* g(x) = (X+alpha) initially */
+   for (i=2; i<=nn-kk; i++)
+    { gg[i] = 1 ;
+      for (j=i-1; j>0; j--)
+        if (gg[j] != 0)  gg[j] = gg[j-1]^ alpha_to[(index_of[gg[j]]+i)%nn] ;
+        else gg[j] = gg[j-1] ;
+      gg[0] = alpha_to[(index_of[gg[0]]+i)%nn] ;     /* gg[0] can never be zero */
+    }
+   /* convert gg[] to index form for quicker encoding */
+   for (i=0; i<=nn-kk; i++)  gg[i] = index_of[gg[i]] ;
+ }
+
+
+static void encode_rs()
+/* take the string of symbols in data[i], i=0..(k-1) and encode systematically
+   to produce 2*tt parity symbols in bb[0]..bb[2*tt-1]
+   data[] is input and bb[] is output in polynomial form.
+   Encoding is done by using a feedback shift register with appropriate
+   connections specified by the elements of gg[], which was generated above.
+   Codeword is   c(X) = data(X)*X**(nn-kk)+ b(X)          */
+ {
+   register int i,j ;
+   int feedback ;
+
+   for (i=0; i<nn-kk; i++)   bb[i] = 0 ;
+   for (i=kk-1; i>=0; i--)
+    {  feedback = index_of[data[i]^bb[nn-kk-1]] ;
+       if (feedback != -1)
+        { for (j=nn-kk-1; j>0; j--)
+            if (gg[j] != -1)
+              bb[j] = bb[j-1]^alpha_to[(gg[j]+feedback)%nn] ;
+            else
+              bb[j] = bb[j-1] ;
+          bb[0] = alpha_to[(gg[0]+feedback)%nn] ;
+        }
+       else
+        { for (j=nn-kk-1; j>0; j--)
+            bb[j] = bb[j-1] ;
+          bb[0] = 0 ;
+        } ;
+    } ;
+ } ;
+
+
+
+static void decode_rs()
+/* assume we have received bits grouped into mm-bit symbols in recd[i],
+   i=0..(nn-1),  and recd[i] is index form (ie as powers of alpha).
+   We first compute the 2*tt syndromes by substituting alpha**i into rec(X) and
+   evaluating, storing the syndromes in s[i], i=1..2tt (leave s[0] zero) .
+   Then we use the Berlekamp iteration to find the error location polynomial
+   elp[i].   If the degree of the elp is >tt, we cannot correct all the errors
+   and hence just put out the information symbols uncorrected. If the degree of
+   elp is <=tt, we substitute alpha**i , i=1..n into the elp to get the roots,
+   hence the inverse roots, the error location numbers. If the number of errors
+   located does not equal the degree of the elp, we have more than tt errors
+   and cannot correct them.  Otherwise, we then solve for the error value at
+   the error location and correct the error.  The procedure is that found in
+   Lin and Costello. For the cases where the number of errors is known to be too
+   large to correct, the information symbols as received are output (the
+   advantage of systematic encoding is that hopefully some of the information
+   symbols will be okay and that if we are in luck, the errors are in the
+   parity part of the transmitted codeword).  Of course, these insoluble cases
+   can be returned as error flags to the calling routine if desired.   */
+ {
+   register int i,j,u,q ;
+   int elp[nn-kk+2][nn-kk], d[nn-kk+2], l[nn-kk+2], u_lu[nn-kk+2], s[nn-kk+1] ;
+   int count=0, syn_error=0, root[tt], loc[tt], z[tt+1], err[nn], reg[tt+1] ;
+
+/* first form the syndromes */
+   for (i=1; i<=nn-kk; i++)
+    { s[i] = 0 ;
+      for (j=0; j<nn; j++)
+        if (recd[j]!=-1)
+          s[i] ^= alpha_to[(recd[j]+i*j)%nn] ;      /* recd[j] in index form */
+/* convert syndrome from polynomial form to index form  */
+      if (s[i]!=0)  syn_error=1 ;        /* set flag if non-zero syndrome => error */
+      s[i] = index_of[s[i]] ;
+    } ;
+
+   if (syn_error)       /* if errors, try and correct */
+    {
+/* printf("RS: errors detected\n"); */
+/* compute the error location polynomial via the Berlekamp iterative algorithm,
+   following the terminology of Lin and Costello :   d[u] is the 'mu'th
+   discrepancy, where u='mu'+1 and 'mu' (the Greek letter!) is the step number
+   ranging from -1 to 2*tt (see L&C),  l[u] is the
+   degree of the elp at that step, and u_l[u] is the difference between the
+   step number and the degree of the elp.
+*/
+/* initialise table entries */
+      d[0] = 0 ;           /* index form */
+      d[1] = s[1] ;        /* index form */
+      elp[0][0] = 0 ;      /* index form */
+      elp[1][0] = 1 ;      /* polynomial form */
+      for (i=1; i<nn-kk; i++)
+        { elp[0][i] = -1 ;   /* index form */
+          elp[1][i] = 0 ;   /* polynomial form */
+        }
+      l[0] = 0 ;
+      l[1] = 0 ;
+      u_lu[0] = -1 ;
+      u_lu[1] = 0 ;
+      u = 0 ;
+
+      do
+      {
+        u++ ;
+        if (d[u]==-1)
+          { l[u+1] = l[u] ;
+            for (i=0; i<=l[u]; i++)
+             {  elp[u+1][i] = elp[u][i] ;
+                elp[u][i] = index_of[elp[u][i]] ;
+             }
+          }
+        else
+/* search for words with greatest u_lu[q] for which d[q]!=0 */
+          { q = u-1 ;
+            while ((d[q]==-1) && (q>0)) q-- ;
+/* have found first non-zero d[q]  */
+            if (q>0)
+             { j=q ;
+               do
+               { j-- ;
+                 if ((d[j]!=-1) && (u_lu[q]<u_lu[j]))
+                   q = j ;
+               }while (j>0) ;
+             } ;
+
+/* have now found q such that d[u]!=0 and u_lu[q] is maximum */
+/* store degree of new elp polynomial */
+            if (l[u]>l[q]+u-q)  l[u+1] = l[u] ;
+            else  l[u+1] = l[q]+u-q ;
+
+/* form new elp(x) */
+            for (i=0; i<nn-kk; i++)    elp[u+1][i] = 0 ;
+            for (i=0; i<=l[q]; i++)
+              if (elp[q][i]!=-1)
+                elp[u+1][i+u-q] = alpha_to[(d[u]+nn-d[q]+elp[q][i])%nn] ;
+            for (i=0; i<=l[u]; i++)
+              { elp[u+1][i] ^= elp[u][i] ;
+                elp[u][i] = index_of[elp[u][i]] ;  /*convert old elp value to index*/
+              }
+          }
+        u_lu[u+1] = u-l[u+1] ;
+
+/* form (u+1)th discrepancy */
+        if (u<nn-kk)    /* no discrepancy computed on last iteration */
+          {
+            if (s[u+1]!=-1)
+                   d[u+1] = alpha_to[s[u+1]] ;
+            else
+              d[u+1] = 0 ;
+            for (i=1; i<=l[u+1]; i++)
+              if ((s[u+1-i]!=-1) && (elp[u+1][i]!=0))
+                d[u+1] ^= alpha_to[(s[u+1-i]+index_of[elp[u+1][i]])%nn] ;
+            d[u+1] = index_of[d[u+1]] ;    /* put d[u+1] into index form */
+          }
+      } while ((u<nn-kk) && (l[u+1]<=tt)) ;
+
+      u++ ;
+      if (l[u]<=tt)         /* can correct error */
+       {
+/* put elp into index form */
+         for (i=0; i<=l[u]; i++)   elp[u][i] = index_of[elp[u][i]] ;
+
+/* find roots of the error location polynomial */
+         for (i=1; i<=l[u]; i++)
+           reg[i] = elp[u][i] ;
+         count = 0 ;
+         for (i=1; i<=nn; i++)
+          {  q = 1 ;
+             for (j=1; j<=l[u]; j++)
+              if (reg[j]!=-1)
+                { reg[j] = (reg[j]+j)%nn ;
+                  q ^= alpha_to[reg[j]] ;
+                } ;
+             if (!q)        /* store root and error location number indices */
+              { root[count] = i;
+                loc[count] = nn-i ;
+                count++ ;
+              };
+          } ;
+         if (count==l[u])    /* no. roots = degree of elp hence <= tt errors */
+          {
+/* form polynomial z(x) */
+           for (i=1; i<=l[u]; i++)        /* Z[0] = 1 always - do not need */
+            { if ((s[i]!=-1) && (elp[u][i]!=-1))
+                 z[i] = alpha_to[s[i]] ^ alpha_to[elp[u][i]] ;
+              else if ((s[i]!=-1) && (elp[u][i]==-1))
+                      z[i] = alpha_to[s[i]] ;
+                   else if ((s[i]==-1) && (elp[u][i]!=-1))
+                          z[i] = alpha_to[elp[u][i]] ;
+                        else
+                          z[i] = 0 ;
+              for (j=1; j<i; j++)
+                if ((s[j]!=-1) && (elp[u][i-j]!=-1))
+                   z[i] ^= alpha_to[(elp[u][i-j] + s[j])%nn] ;
+              z[i] = index_of[z[i]] ;         /* put into index form */
+            } ;
+
+  /* evaluate errors at locations given by error location numbers loc[i] */
+           for (i=0; i<nn; i++)
+             { err[i] = 0 ;
+               if (recd[i]!=-1)        /* convert recd[] to polynomial form */
+                 recd[i] = alpha_to[recd[i]] ;
+               else  recd[i] = 0 ;
+             }
+           for (i=0; i<l[u]; i++)    /* compute numerator of error term first */
+            { err[loc[i]] = 1;       /* accounts for z[0] */
+              for (j=1; j<=l[u]; j++)
+                if (z[j]!=-1)
+                  err[loc[i]] ^= alpha_to[(z[j]+j*root[i])%nn] ;
+              if (err[loc[i]]!=0)
+               { err[loc[i]] = index_of[err[loc[i]]] ;
+                 q = 0 ;     /* form denominator of error term */
+                 for (j=0; j<l[u]; j++)
+                   if (j!=i)
+                     q += index_of[1^alpha_to[(loc[j]+root[i])%nn]] ;
+                 q = q % nn ;
+                 err[loc[i]] = alpha_to[(err[loc[i]]-q+nn)%nn] ;
+                 recd[loc[i]] ^= err[loc[i]] ;  /*recd[i] must be in polynomial form */
+               }
+            }
+          }
+         else    /* no. roots != degree of elp => >tt errors and cannot solve */
+           for (i=0; i<nn; i++)        /* could return error flag if desired */
+               if (recd[i]!=-1)        /* convert recd[] to polynomial form */
+                 recd[i] = alpha_to[recd[i]] ;
+               else  recd[i] = 0 ;     /* just output received codeword as is */
+       }
+     else         /* elp has degree has degree >tt hence cannot solve */
+       for (i=0; i<nn; i++)       /* could return error flag if desired */
+          if (recd[i]!=-1)        /* convert recd[] to polynomial form */
+            recd[i] = alpha_to[recd[i]] ;
+          else  recd[i] = 0 ;     /* just output received codeword as is */
+    }
+   else       /* no non-zero syndromes => no errors: output received codeword */
+    for (i=0; i<nn; i++)
+       if (recd[i]!=-1)        /* convert recd[] to polynomial form */
+         recd[i] = alpha_to[recd[i]] ;
+       else  recd[i] = 0 ;
+ }
+
+
+void rsdec_204(unsigned char* data_out, unsigned char* data_in)
+{
+  int i;
+
+  if (!inited) {
+    /* generate the Galois Field GF(2**mm) */
+    generate_gf();
+    /* compute the generator polynomial for this RS code */
+    gen_poly();
+
+    inited = 1;
+  }
+
+  /* put the transmitted codeword, made up of data plus parity, in recd[] */
+
+  /* parity */
+  for (i=0; i<204-188; ++i) {
+    recd[i] = data_in[188 + i];
+  }
+  /* zeroes */
+  for (i=0; i<255-204; ++i) {
+    recd[204-188 + i] = 0;
+  }
+  /* data */
+  for (i=0; i<188; ++i) {
+    recd[255-188 + i] = data_in[i];
+  }
+
+  for (i=0; i<nn; i++)
+     recd[i] = index_of[recd[i]] ;          /* put recd[i] into index form */
+
+/* decode recv[] */
+  decode_rs() ;         /* recd[] is returned in polynomial form */
+
+  for (i=0; i<188; ++i) {
+    data_out [i] = recd[255-188 + i];
+  }
+}
+
+void rsenc_204(unsigned char* data_out, unsigned char* data_in)
+{
+  int i;
+
+  if (!inited) {
+    /* generate the Galois Field GF(2**mm) */
+    generate_gf();
+    /* compute the generator polynomial for this RS code */
+    gen_poly();
+
+    inited = 1;
+  }
+
+  /* zeroes */
+  for (i=0; i<255-204; ++i) {
+    data[i] = 0;
+  }
+  /* data */
+  for (i=0; i<188; ++i) {
+    data[255-204 + i] = data_in[i];
+  }
+
+  encode_rs();
+
+  for (i=0; i<188; ++i) {
+    data_out[i] = data_in[i];
+  }
+  for (i=0; i<204-188; ++i) {
+    data_out[188+i] = bb[i];
+  }
+
+}
+
+int main(void) {
+  unsigned char rs_in[204], rs_out[204];
+  int i, j, k;
+
+#ifdef SMALL_PROBLEM_SIZE
+#define LENGTH 15000
+#else
+#define LENGTH 150000
+#endif
+
+#ifdef __MINGW32__
+#define random() rand()
+#endif
+
+  for (i=0; i<LENGTH; ++i) {
+    /* Generate random data */
+    for (j=0; j<188; ++j) {
+      rs_in[j] = (random() & 0xFF);
+    }
+    rsenc_204(rs_out, rs_in);
+    /* Number of errors to insert */
+    k = random() & 0x7F;
+
+    for (j=0; j<k; ++j) {
+      rs_out[random() % 204] = (random() & 0xFF);
+    }
+
+    rsdec_204(rs_in, rs_out);
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0103-boundary-check-for-replace-variable/expected.txt b/testsuite/c_test/enhancec_test/ENC0103-boundary-check-for-replace-variable/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0103-boundary-check-for-replace-variable/test.cfg b/testsuite/c_test/enhancec_test/ENC0103-boundary-check-for-replace-variable/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5f33ab6179fa9db716a18a9c091ea6b0e3c2017d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0103-boundary-check-for-replace-variable/test.cfg
@@ -0,0 +1,6 @@
+ENCO2_B_D:
+compile(ReedSolomon)
+run(ReedSolomon)
+ENCO2_N_D:
+compile(ReedSolomon)
+run(ReedSolomon)
diff --git a/testsuite/c_test/enhancec_test/ENC0104-boundary-check-for-unreachable/expected.txt b/testsuite/c_test/enhancec_test/ENC0104-boundary-check-for-unreachable/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b6308a444bf474ac5d901dfebd0a750e8b265afa
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0104-boundary-check-for-unreachable/expected.txt
@@ -0,0 +1,14 @@
+	functions that have something to do with date
+
+	month_name function                                              PASSED
+
+	day_of_year function                                             PASSED
+
+	month_day function                                               PASSED
+
+	day_of_year pointer version                                      PASSED
+
+	month_day pointer version                                        PASSED
+
+RESULT: (unknown_test)                                                   PASSED
+
diff --git a/testsuite/c_test/enhancec_test/ENC0104-boundary-check-for-unreachable/tdate.c b/testsuite/c_test/enhancec_test/ENC0104-boundary-check-for-unreachable/tdate.c
new file mode 100644
index 0000000000000000000000000000000000000000..f229240453c0e602869209e31a94772bc6a4a395
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0104-boundary-check-for-unreachable/tdate.c
@@ -0,0 +1,188 @@
+/*
+ * (c) Copyright 2015-2020 by Solid Sands B.V.,
+ *     Amsterdam, the Netherlands. All rights reserved.
+ *     Subject to conditions in the RESTRICTIONS file.
+ * (c) Copyright 2003-2006 ACE Associated Compiler Experts bv
+ * (c) Copyright 1985,2003-2006 ACE Associated Computer Experts bv
+ * All rights reserved.  Subject to conditions in RESTRICTIONS file.
+ */
+
+/*
+ *      This test tests respectively the month_day, month_name and
+ *      the day_of_year function, and some versions of them.
+ *      These functions are taken from the Brian W. Kernighan &
+ *      Dennis M. Ritchie C-programming language book.
+ */
+
+#include "def.h"
+
+static int day_tab[2][13] = {
+  {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+  {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
+};
+struct date {
+  int day ;
+  int month ;
+  int year ;
+  int yearday ;
+};
+
+int
+day1_of_year(int year, int month, int day) /* set day of year */
+{
+  int i, leap;
+
+  leap = year%4 == 0 && year%100 != 0 || year%400 == 0;
+  for (i = 1; i < month; i++)
+    day += day_tab[leap][i];
+  return(day);
+}
+
+void
+month1_day(int year, int yearday, int *pmonth, int *pday) /* set month, day */
+{
+  int i, leap;
+
+  leap = year%4 == 0 && year%100 != 0 || year%400 == 0;
+  for (i = 1; yearday > day_tab[leap][i]; i++)
+    yearday -= day_tab[leap][i];
+  *pmonth = i;
+  *pday = yearday;
+}
+
+const char *
+month_name(int n) /* return name of n-th month */
+{
+  static const char * name[] = {
+    "illegal month",
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  };
+
+  return((n < 1 || n > 12) ? name[0] : name[n]);
+}
+
+int
+day2_of_year(struct date *pd) /* set day of year from month, day */
+{
+  int i, day, leap;
+
+  day = pd->day;
+  leap = pd->year % 4 == 0 && pd->year % 100 != 0
+         || pd->year % 400 == 0;
+  for (i = 0; i < pd->month; i++)
+    day += day_tab[leap][i];
+  return(day);
+}
+
+void
+month2_day(struct date *pd) /* set month and day from day of year */
+{
+  int i, leap;
+
+  leap = pd->year % 4 == 0 && pd->year % 100 != 0
+         || pd->year % 400 == 0;
+  pd->day = pd->yearday;
+  for (i = 1; pd->day > day_tab[leap][i]; i++)
+    pd->day -= day_tab[leap][i];
+  pd->month = i;
+}
+
+int month_global;
+int day_global;
+struct date date_global;
+
+MAIN
+{
+  int result;
+  const char *name;
+  int *dayptr, *monptr;
+  struct date *dateptr;
+
+  CVAL_HEADER("functions that have something to do with date");
+
+  CVAL_SECTION("month_name function" );
+  CVAL_DOTEST( name = month_name( 13 )) ;
+  CVAL_VERIFY(!(cval_strcmp( name, "illegal month" )));
+
+  CVAL_DOTEST( name = month_name( 1 )) ;
+  CVAL_VERIFY(!(cval_strcmp( name, "January" )));
+
+  CVAL_DOTEST( name = month_name( 12 )) ;
+  CVAL_VERIFY(!(cval_strcmp( name, "December" )));
+
+
+  CVAL_ENDSECTION();
+
+  CVAL_SECTION("day_of_year function" );
+  CVAL_DOTEST( result = day1_of_year(1985, 10, 23)) ;
+  CVAL_VERIFY( result == 296);
+
+  CVAL_DOTEST( result = day1_of_year(1985, 12, 31)) ;
+  CVAL_VERIFY( result == 365);
+
+  CVAL_DOTEST( result = day1_of_year(1988, 12, 31)) ;
+  CVAL_VERIFY( result == 366);
+
+
+  CVAL_ENDSECTION();
+
+  CVAL_SECTION("month_day function" );
+  monptr = &month_global ;
+  dayptr = &day_global;
+  CVAL_DOTEST( month1_day(1985,296,monptr,dayptr)) ;
+  CVAL_VERIFY( *monptr == 10 && *dayptr == 23);
+
+  CVAL_DOTEST( month1_day(1988,296,monptr,dayptr)) ;
+  CVAL_VERIFY( *monptr == 10 && *dayptr == 22);
+
+
+  CVAL_ENDSECTION();
+
+  CVAL_SECTION("day_of_year pointer version" );
+  dateptr = &date_global;
+  dateptr->day = 23 ;
+  dateptr->year = 1985 ;
+  dateptr->month = 10 ;
+  CVAL_DOTEST( result = day2_of_year( dateptr )) ;
+  CVAL_VERIFY( result == 296);
+
+  dateptr->day = 31 ;
+  dateptr->year = 1985 ;
+  dateptr->month = 12 ;
+  CVAL_DOTEST( result = day2_of_year( dateptr )) ;
+  CVAL_VERIFY( result == 365);
+
+  dateptr->day = 31 ;
+  dateptr->year = 1988 ;
+  dateptr->month = 12 ;
+  CVAL_DOTEST( result = day2_of_year( dateptr )) ;
+  CVAL_VERIFY( result == 366);
+
+
+  CVAL_ENDSECTION();
+
+  CVAL_SECTION("month_day pointer version" );
+  dateptr->year = 1985 ;
+  dateptr->yearday = 60 ;
+  CVAL_DOTEST( month2_day( dateptr )) ;
+  CVAL_VERIFY((dateptr->month == 3) && (dateptr->day == 1));
+
+  dateptr->year = 1988 ;
+  dateptr->yearday = 60 ;
+  CVAL_DOTEST( month2_day( dateptr )) ;
+  CVAL_VERIFY((dateptr->month == 2) && (dateptr->day == 29));
+
+
+  CVAL_ENDSECTION();
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0104-boundary-check-for-unreachable/test.cfg b/testsuite/c_test/enhancec_test/ENC0104-boundary-check-for-unreachable/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d733f4d7878c5fcbad9135ed189338e68e932b12
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0104-boundary-check-for-unreachable/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile(tdate)
+run(tdate)
diff --git a/testsuite/c_test/enhancec_test/ENC0104-inline_boundary_check_err/inline_boundary_check_err.c b/testsuite/c_test/enhancec_test/ENC0104-inline_boundary_check_err/inline_boundary_check_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..c0bf4b48a995aa39b645150f110292aead726163
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0104-inline_boundary_check_err/inline_boundary_check_err.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+static char * parson_strndup(const char *string, size_t n) {
+    char *output_string = (char*)malloc(n);
+    if (!output_string) {
+        return NULL;
+    }
+    output_string[n] = '\0'; // CHECK: [[# @LINE ]] error: the pointer >= the upper bounds when accessing the memory and inlined to main
+    return output_string;
+}
+
+int main() {
+    const char *string = "test";
+    char *s = parson_strndup(string, strlen(string) + 1);
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0104-inline_boundary_check_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0104-inline_boundary_check_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..94985b19baadb3222a480e507257e2a731a78a3c
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0104-inline_boundary_check_err/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_err)
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0105-boundary-check-lvalue/boundary-check-lvalue.c b/testsuite/c_test/enhancec_test/ENC0105-boundary-check-lvalue/boundary-check-lvalue.c
new file mode 100644
index 0000000000000000000000000000000000000000..6652f8c0b0baca9675fb0999eeb5101073c0427d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0105-boundary-check-lvalue/boundary-check-lvalue.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+int a[251];
+__attribute__ ((noinline))
+t(int i)
+{
+  if (i==0)
+    exit(0);
+  if (i>255)
+    abort ();
+}
+main()
+{
+  unsigned int i;
+  for (i=0;;i++)
+    {
+      a[i]=t((unsigned char)(i+5));
+    }
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0105-boundary-check-lvalue/expected.txt b/testsuite/c_test/enhancec_test/ENC0105-boundary-check-lvalue/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0105-boundary-check-lvalue/test.cfg b/testsuite/c_test/enhancec_test/ENC0105-boundary-check-lvalue/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6600947b37b5a6639bb4b9ad40219bab2d2afe23
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0105-boundary-check-lvalue/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile(boundary-check-lvalue)
+run(boundary-check-lvalue)
diff --git a/testsuite/c_test/enhancec_test/ENC0105-inline_nonnull_check_err/inline_nonnull_check_err.c b/testsuite/c_test/enhancec_test/ENC0105-inline_nonnull_check_err/inline_nonnull_check_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..0e1fcdb166d7eec1fcbf3cb5e3bc15da710b2c98
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0105-inline_nonnull_check_err/inline_nonnull_check_err.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+static int parse_utf16_hex(unsigned int *result) {
+    int x1, x2, x3, x4;
+    x1 = 1;
+    x2 = 2;
+    x3 = 3;
+    x4 = 4;
+    *result = (unsigned int)((x1 << 12) | (x2 << 8) | (x3 << 4) | x4); // CHECK: [[# @LINE ]] error: Dereference of null pointer when inlined to main
+    return 1;
+}
+
+int main() {
+    int hex = parse_utf16_hex(NULL);
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0105-inline_nonnull_check_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0105-inline_nonnull_check_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2a6491c607a72b4e38220dad39873ab8d1f0d025
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0105-inline_nonnull_check_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_N_D:
+compile_err(inline_nonnull_check_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_nonnull_check_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0106-nest_safe_region/expected.txt b/testsuite/c_test/enhancec_test/ENC0106-nest_safe_region/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0106-nest_safe_region/safe_region.c b/testsuite/c_test/enhancec_test/ENC0106-nest_safe_region/safe_region.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb576c3861f3857e386ceba1009a0d756238fc6e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0106-nest_safe_region/safe_region.c
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "stdio.h"
+// CHECK: [[# FILENUM:]] "{{.*}}/safe_region.c"
+
+// CHECK: func &func0 public () void
+void func0(void) {
+}
+
+#pragma SAFE OFF
+
+// CHECK: func &func1 public unsafed () void
+void func1(void) {
+}
+
+// CHECK: func &func2 public safed () void
+__Safe__ void func2(void);
+
+#pragma SAFE ON
+
+// CHECK: func &func3 public unsafed () void
+__Unsafe__ void func3(void) {
+}
+
+// CHECK: func &func4 public safed () void
+void func4() {
+}
+
+// CHECK: func &main public safed () i32
+int main(void) {
+  return 0;
+}
+
+__Safe__ void func2(void) {
+  // CHECK: dassign %a{{.*}} 0 (constval i32 0)
+  int a = 0;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: safe
+  __Safe__ {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: dassign %a{{.*}} (add i32 (dread i32 %a{{.*}}, constval i32 1))
+    a += 1;
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: unsafe
+    __Unsafe__ {
+      printf("%d", a);
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK-NEXT: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 2))
+      a += 2;
+      printf("%d", a);
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK: safe
+      __Safe__ {
+        // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+        // CHECK-NEXT: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 3))
+        a += 3;
+        __Unsafe__ {
+          printf("%d", a);
+        }
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK: endsafe
+      }
+      // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+      // CHECK: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 4))
+      a += 4;
+      printf("%d", a);
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: endunsafe
+    }
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 5))
+    a += 5;
+    __Unsafe__ {
+      printf("%d", a);
+    }
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: endsafe
+  }
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %a{{.*}} 0 (add i32 (dread i32 %a{{.*}}, constval i32 6))
+  a += 6;
+  __Unsafe__ {
+    printf("%d", a);
+  }
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0106-nest_safe_region/test.cfg b/testsuite/c_test/enhancec_test/ENC0106-nest_safe_region/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fa7f9239d87f9c05c0d3b1b8abe5f7c86fb1739e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0106-nest_safe_region/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_S_D:
+compile(safe_region)
+run(safe_region)
+cat safe_region.mpl | ${OUT_ROOT}/tools/bin/FileCheck safe_region.c
diff --git a/testsuite/c_test/enhancec_test/ENC0107-boundary_check_addrof/boundary_check_addrof.c b/testsuite/c_test/enhancec_test/ENC0107-boundary_check_addrof/boundary_check_addrof.c
new file mode 100644
index 0000000000000000000000000000000000000000..f4ca53d393bf3c892e5768d18192cf2c0861d893
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0107-boundary_check_addrof/boundary_check_addrof.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+int f(int *p __attribute__((count(5)))) {
+  return *p;
+}
+
+void test() {
+  int idx = 10;
+  int test[10] = {0};
+  int j = 1;
+  for (int *i = test;i < &test[idx]; i++, j++) {  // CHECK: [[# @LINE ]] warning
+    *i = j;
+  }
+
+  int res = 0;
+  int n = 3;
+  int b[3][2] = {{1,2},{3,4},{5,6}};
+  res += b[n - 1][1];  // CHECK-NOT: [[# @LINE ]] warning
+  int *x = *(b + 3);  // CHECK: [[# @LINE ]] warning  
+  int *y = b[n];  // CHECK: [[# @LINE ]] warning
+  (void)b[n];  // CHECK: [[# @LINE ]] warning
+
+  int *p = test + 10;  // CHECK: [[# @LINE ]] warning
+  int *q = &*p;  // CHECK: [[# @LINE ]] warning
+
+  // call
+  res += f(&test[5]);  // CHECK-NOT: [[# @LINE ]] error
+  // assign
+  int *w __attribute__((count(5))) = &test[6];  // CHECK: [[# @LINE ]] error
+}
+
+int main() {
+  test();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0107-boundary_check_addrof/expected.txt b/testsuite/c_test/enhancec_test/ENC0107-boundary_check_addrof/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0107-boundary_check_addrof/test.cfg b/testsuite/c_test/enhancec_test/ENC0107-boundary_check_addrof/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa7be4bfc5ef45a69aa7fe16cef575e839c2ea01
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0107-boundary_check_addrof/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_N_D:
+compile(boundary_check_addrof)
+run(boundary_check_addrof)
+ENCO2_B_D:
+compile_err(boundary_check_addrof)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_addrof.c
diff --git a/testsuite/c_test/enhancec_test/ENC0108-boundary-check-for-loop/boundary_check_loop.c b/testsuite/c_test/enhancec_test/ENC0108-boundary-check-for-loop/boundary_check_loop.c
new file mode 100755
index 0000000000000000000000000000000000000000..0c4072f522b6cedaeef988991e399550e52c9fd4
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0108-boundary-check-for-loop/boundary_check_loop.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int __attribute__((noinline,noclone))
+sort(int L)
+{
+  int end[2] = { 10, 10, }, i=0, R;
+  while (i<2)
+    {
+      R = end[i];
+      if (L<R)
+        {
+          end[i+1] = 1;
+          end[i] = 10;
+          ++i;
+        }
+      else
+        break;
+    }
+  return i;
+}
+extern void abort (void);
+int main()
+{
+  if (sort (5) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0108-boundary-check-for-loop/expected.txt b/testsuite/c_test/enhancec_test/ENC0108-boundary-check-for-loop/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0108-boundary-check-for-loop/test.cfg b/testsuite/c_test/enhancec_test/ENC0108-boundary-check-for-loop/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..079116d9343bd462a07652953780e1904f94624b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0108-boundary-check-for-loop/test.cfg
@@ -0,0 +1,2 @@
+compile(boundary_check_loop)
+run(boundary_check_loop)
diff --git a/testsuite/c_test/enhancec_test/ENC0109-boundary-check-for-loop-err/boundary_check_loop.c b/testsuite/c_test/enhancec_test/ENC0109-boundary-check-for-loop-err/boundary_check_loop.c
new file mode 100755
index 0000000000000000000000000000000000000000..5382372a83cc61f4c29c39205117b0692859cfbf
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0109-boundary-check-for-loop-err/boundary_check_loop.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main (void) {
+    int i;
+    int arr1[100];
+    int arr2[100];
+    int arr3[100];
+
+    arr1[1] = 2;
+    arr3[0] = 3;
+    for (i = 0; i <= 100; i++) {
+        arr2[i] = i + 1; // CHECK: [[# @LINE ]] error: the pointer >= the upper bounds when accessing the memory
+        /* Not compliant in iteration i==100 */
+    }
+    return arr1[1] - 2;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0109-boundary-check-for-loop-err/expected.txt b/testsuite/c_test/enhancec_test/ENC0109-boundary-check-for-loop-err/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0109-boundary-check-for-loop-err/test.cfg b/testsuite/c_test/enhancec_test/ENC0109-boundary-check-for-loop-err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a49c24bee4f20026596eb4150aad86e8257cf465
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0109-boundary-check-for-loop-err/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_B_D:
+compile_err(boundary_check_loop)
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_check_loop.c
diff --git a/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-rem/boundary-check-for-rem.c b/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-rem/boundary-check-for-rem.c
new file mode 100644
index 0000000000000000000000000000000000000000..a78dad1d78d18eb19eacbcb47fb80178bd23fbc2
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-rem/boundary-check-for-rem.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+char * parson_strndup(const char *string, size_t n, int x) {
+    char *output_string = (char*)malloc(4);
+    if (!output_string) {
+        return NULL;
+    }
+    if (x > 0 && x < 9) {
+        output_string[x % 5] = '\0';
+        return output_string;
+    }
+    output_string[0 % 0] = '\0';
+    return NULL;
+}
+
+int main() {
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-rem/test.cfg b/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-rem/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c8402ea8ebf281598f3da5d65cfd2333b8bd87a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-rem/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_B_D:
+compile(boundary-check-for-rem)
+sort compile.log -t ':' -k 3 -n -o compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=2 --str="assertlt"  --result=boundary-check-for-rem.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="assertge"  --result=boundary-check-for-rem.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=2 --str="can't prove the pointer < the upper bounds when accessing the memory"  --result=compile.log
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="can't prove the pointer >= the lower bounds when accessing the memory"  --result=compile.log
diff --git a/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-switch/boundary_check_loop.c b/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-switch/boundary_check_loop.c
new file mode 100755
index 0000000000000000000000000000000000000000..5e18516e73670cca845c3c367320b028366ccd27
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-switch/boundary_check_loop.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int stab_xcoff_builtin_type (int typenum)
+{
+  const char *name;
+  if (typenum >= 0 || typenum < -3)
+    {
+      return 0;
+    }
+  switch (-typenum)
+    {
+    case 1:
+      name = "int";
+      break;
+    case 2:
+      name = "char";
+    case 3:
+      name = "short";
+    }
+  return name[0];
+}
+
+extern void abort (void);
+int main()
+{
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-switch/expected.txt b/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-switch/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-switch/test.cfg b/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-switch/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..079116d9343bd462a07652953780e1904f94624b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0110-boundary-check-for-switch/test.cfg
@@ -0,0 +1,2 @@
+compile(boundary_check_loop)
+run(boundary_check_loop)
diff --git a/testsuite/c_test/enhancec_test/ENC0111-boundary-check-for-deadbeef/boundary_check_loop.c b/testsuite/c_test/enhancec_test/ENC0111-boundary-check-for-deadbeef/boundary_check_loop.c
new file mode 100755
index 0000000000000000000000000000000000000000..ec2d4b82c18d3112ae6aba685d3d5a6a01b8a128
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0111-boundary-check-for-deadbeef/boundary_check_loop.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int isdigit(int a) {
+  return a > 0;
+}
+char *fullname(char *gecos)
+{
+        static char fname[100];
+        register char *cend;
+
+        (void) strcpy(fname, gecos);
+        if (cend = index(fname, ','))
+                *cend = '\0';
+        if (cend = index(fname, '('))
+                *cend = '\0';
+        /*
+        ** Skip USG-style 0000-Name nonsense if necessary.
+        */
+        if (isdigit(*(cend = fname))) {
+                if ((cend = index(fname, '-')) != NULL)
+                        cend++;
+                else
+                        /*
+                        ** There was no `-' following digits.
+                        */
+                        cend = fname;
+        }
+        return (cend);
+}
+
+int main()
+{
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0111-boundary-check-for-deadbeef/expected.txt b/testsuite/c_test/enhancec_test/ENC0111-boundary-check-for-deadbeef/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0111-boundary-check-for-deadbeef/test.cfg b/testsuite/c_test/enhancec_test/ENC0111-boundary-check-for-deadbeef/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2433d8c188fbb17e70729d5fc15ce8a90de527c0
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0111-boundary-check-for-deadbeef/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_B_D:
+compile(boundary_check_loop)
+run(boundary_check_loop)
diff --git a/testsuite/c_test/enhancec_test/ENC0112-nonnull-check-in-safe-region/nonnull-check-in-safe-region.c b/testsuite/c_test/enhancec_test/ENC0112-nonnull-check-in-safe-region/nonnull-check-in-safe-region.c
new file mode 100644
index 0000000000000000000000000000000000000000..60f6067df410df40f57736330755de1aa0ba068f
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0112-nonnull-check-in-safe-region/nonnull-check-in-safe-region.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+
+#define ARG_LEN 16
+
+void func_safe_region_in_safe(int argc, char* argv[])
+{
+    int valA = 0;
+    int *ptr = argc == 1 ? NULL : &valA;
+    int valB = 233;
+    SAFE {
+        valB = *ptr;    // CHECK: [[# @LINE ]] error
+    }
+    printf("%d\n", valB);
+
+}
+
+void func_safe_region_not_in_safe(int argc, char* argv[])
+{
+    int valA = 0;
+    int *ptr = argc == 1 ? NULL : &valA;
+    int valB = 233;
+    valB = *ptr;    // CHECK-NOT: [[# @LINE ]] error
+    printf("%d\n", valB);
+
+}
+
+int main(int argc, char* argv[])
+{
+    return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0112-nonnull-check-in-safe-region/test.cfg b/testsuite/c_test/enhancec_test/ENC0112-nonnull-check-in-safe-region/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..901b1733e824d5deb4957ca0f78ec19f0fd3fd97
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0112-nonnull-check-in-safe-region/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_S_D:
+compile_err(nonnull-check-in-safe-region)
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull-check-in-safe-region.c
diff --git a/testsuite/c_test/enhancec_test/ENC0113-nonnull-check-not-in-safe-region/nonnull-check-not-in-safe-region.c b/testsuite/c_test/enhancec_test/ENC0113-nonnull-check-not-in-safe-region/nonnull-check-not-in-safe-region.c
new file mode 100644
index 0000000000000000000000000000000000000000..aae8dbf7597fed14922bd024bb6e0e4851590e98
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0113-nonnull-check-not-in-safe-region/nonnull-check-not-in-safe-region.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+
+#define ARG_LEN 16
+
+void func_safe_region_in_safe(int argc, char* argv[])
+{
+    int valA = 0;
+    int *ptr = argc == 1 ? NULL : &valA;
+    int valB = 233;
+    SAFE {
+        valB = *ptr;    // CHECK: [[# @LINE ]] warning
+    }
+    printf("%d\n", valB);
+
+}
+
+void func_safe_region_not_in_safe(int argc, char* argv[])
+{
+    int valA = 0;
+    int *ptr = argc == 1 ? NULL : &valA;
+    int valB = 233;
+    valB = *ptr;    // CHECK: [[# @LINE ]] warning
+    printf("%d\n", valB);
+
+}
+
+int main(int argc, char* argv[])
+{
+    return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0113-nonnull-check-not-in-safe-region/test.cfg b/testsuite/c_test/enhancec_test/ENC0113-nonnull-check-not-in-safe-region/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d2805e317531b49ccf0ee6eb85aea0b60614558
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0113-nonnull-check-not-in-safe-region/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_N_D:
+compile(nonnull-check-not-in-safe-region)
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull-check-not-in-safe-region.c
diff --git a/testsuite/c_test/enhancec_test/ENC0114-boundary-check-for-loop/expected.txt b/testsuite/c_test/enhancec_test/ENC0114-boundary-check-for-loop/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b99fe2c06863aa3a86e3e471dabae7bf8766ed17
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0114-boundary-check-for-loop/expected.txt
@@ -0,0 +1,4 @@
+	Some non-trivial loop control
+
+RESULT: (unknown_test)                                                   PASSED
+
diff --git a/testsuite/c_test/enhancec_test/ENC0114-boundary-check-for-loop/test.cfg b/testsuite/c_test/enhancec_test/ENC0114-boundary-check-for-loop/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e4949ced3fa88fc0086349970a303d216b39ff25
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0114-boundary-check-for-loop/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile(tsqpr)
+#python3 ${TEST_BIN}/check.py --check=num  --n=4 --str="assert" --result=tsqpr.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=5 --str="warning" --result=compile.log
+run(tsqpr)
diff --git a/testsuite/c_test/enhancec_test/ENC0114-boundary-check-for-loop/tsqpr.c b/testsuite/c_test/enhancec_test/ENC0114-boundary-check-for-loop/tsqpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..ecd11716590d14e15b563a2530fb1ff6a40fe21e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0114-boundary-check-for-loop/tsqpr.c
@@ -0,0 +1,79 @@
+/*
+ * (c) Copyright 2015-2020 by Solid Sands B.V.,
+ *     Amsterdam, the Netherlands. All rights reserved.
+ *     Subject to conditions in the RESTRICTIONS file.
+ * (c) Copyright 2011 ACE Associated Compiler Experts bv
+ * (c) Copyright 2011 ACE Associated Computer Experts bv
+ * All rights reserved.  Subject to conditions in RESTRICTIONS file.
+ */
+
+#include "def.h"
+
+#define N 1024
+
+char flags[N];
+
+/*
+ * Primes are sieved by eliminating multiples of numbers > 1
+ * Squares are sieved by counting divisors modulo 2 (squares have an odd
+ * number of divisors
+ * The loop is subject to peeling and shows iteration space dependences.
+ */
+void
+compute(void)
+{
+  int i;
+  int j;
+
+  for (i = 0; i < N; i++) {
+    if (i == 0) {
+      flags[i] = 7;
+    } else {
+    for (j = i; j < N; j += i) {
+      if (j < 2 || i > 1 && j > i) {
+        flags[j] |= 2;
+      }
+      flags[j] = (flags[j] ^ 1)
+          | 4 * (j <= 1 || i >= 2 && j > i);
+      }
+    }
+  }
+}
+
+MAIN
+{
+  int i;
+  int j;
+  int s;
+  int ns;
+  int ls;
+  ls=-1;
+
+  CVAL_HEADER("Some non-trivial loop control");
+
+  compute();
+
+  s = 0;
+  ns = 0;
+  for (i = 0; i < N; i++) {
+    CVAL_CASE(i);
+    if (flags[i] & 1) {
+      /* should be square */
+      CVAL_VERIFY(i == s);
+      CVAL_VERIFY(ns * ns == i);
+      /* compute next square */
+      ls = s;
+      s += 2 * ns++ + 1;
+    }
+    if (! (flags[i] & 2)) {
+      /* should be prime, so not divisible
+       * by 2 and odd integers > 2
+       */
+      for (j = 2; j < ls; j += (j == 2) + 2 * (j > 2)) {
+        CVAL_VERIFY(i == 2 || i % j != 0);
+      }
+    }
+
+    CVAL_VERIFY(((flags[i] & 2) != 0) == ((flags[i] & 4) != 0));
+  }
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0115-inline_nonnull_check_warning/inline_nonnull_check_warning.c b/testsuite/c_test/enhancec_test/ENC0115-inline_nonnull_check_warning/inline_nonnull_check_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..2ed34c25a57def73090a21229e24c2e9009906df
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0115-inline_nonnull_check_warning/inline_nonnull_check_warning.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static inline void inlineAssignedValueNullable() {
+  int* p = (int*)malloc(sizeof(int));
+  int *q __attribute__((nonnull)) = p; // CHECK: [[# @LINE ]] warning: nullable pointer assignment of nonnull pointer when inlined to main 
+}
+
+
+int main() {
+  inlineAssignedValueNullable();
+  return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0115-inline_nonnull_check_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0115-inline_nonnull_check_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e87af39c9795f3ba8289c4fed21033dee905e030
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0115-inline_nonnull_check_warning/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_N_D:
+compile(inline_nonnull_check_warning)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_nonnull_check_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0116-inline_nonnull_check_insert_warning/inline_nonnull_check_insert_warning.c b/testsuite/c_test/enhancec_test/ENC0116-inline_nonnull_check_insert_warning/inline_nonnull_check_insert_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..b990d8ccd7d4bb57d370d02b4fd5d5ce73f964a1
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0116-inline_nonnull_check_insert_warning/inline_nonnull_check_insert_warning.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void func2(int *p __attribute__((nonnull))) {
+  return;
+}
+
+static inline void func1() {
+  int *q = (int*)malloc(sizeof(int));
+  func2(q); // CHECK: [[# @LINE ]] warning: nullable pointer passed to func2 that requires nonnull for 1st argument when inlined to main
+}
+
+int main() {
+  func1();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0116-inline_nonnull_check_insert_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0116-inline_nonnull_check_insert_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c812b573ff64f6e6475bca3c410245ead3d01d85
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0116-inline_nonnull_check_insert_warning/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_N_D:
+compile(inline_nonnull_check_insert_warning)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_nonnull_check_insert_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0117-inline_boundary_check_upper_bound_warning/inline_boundary_check_upper_bound_warning.c b/testsuite/c_test/enhancec_test/ENC0117-inline_boundary_check_upper_bound_warning/inline_boundary_check_upper_bound_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..a3ae28e066e63847c2d666abc2a70a73ea387665
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0117-inline_boundary_check_upper_bound_warning/inline_boundary_check_upper_bound_warning.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int g_size = 1;
+
+static inline void func1(int a, int b) {
+  int *q __attribute__((count(a)));
+  int *p __attribute__((count(b)));
+  q = p; // CHECK: [[# @LINE ]] warning: can't prove l-value's upper bounds <= r-value's upper bounds when inlined to main
+}
+
+int main() {
+  int b = 1;
+  func1(g_size, b);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0117-inline_boundary_check_upper_bound_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0117-inline_boundary_check_upper_bound_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..032455a150a1eb171c71ec19ba1e1a911f79ffdb
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0117-inline_boundary_check_upper_bound_warning/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile(inline_boundary_check_upper_bound_warning)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_upper_bound_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0118-inline_boundary_check_insert_and_declaration_match_warning/inline_boundary_check_insert_and_declaration_match_warning.c b/testsuite/c_test/enhancec_test/ENC0118-inline_boundary_check_insert_and_declaration_match_warning/inline_boundary_check_insert_and_declaration_match_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..ccf2414704e8b6f0ea34d4e096ca1e8d0831d56b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0118-inline_boundary_check_insert_and_declaration_match_warning/inline_boundary_check_insert_and_declaration_match_warning.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int g_size = 3;
+
+__attribute__((count_index(2, 1)))
+void callee(int *p, size_t size) {
+  return;
+}
+
+static inline void caller(size_t size) {
+  int *p = (int*)malloc(sizeof(int) * size);
+  callee(p, 3); // CHECK: [[# @LINE ]] warning: can't prove pointer's bounds match the function callee declaration for the 1st argument when inlined to main
+}
+
+int main() {
+  caller(g_size);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0118-inline_boundary_check_insert_and_declaration_match_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0118-inline_boundary_check_insert_and_declaration_match_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..817d823fc9af48fc32213d7674e4a530a352f0b6
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0118-inline_boundary_check_insert_and_declaration_match_warning/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile(inline_boundary_check_insert_and_declaration_match_warning)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_insert_and_declaration_match_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0119-inline_boundary_check_return_and_declaration_match_warning/inline_boundary_check_return_and_declaration_match_warning.c b/testsuite/c_test/enhancec_test/ENC0119-inline_boundary_check_return_and_declaration_match_warning/inline_boundary_check_return_and_declaration_match_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..5cb326b99984929065684a7af3455ed3fe61a60b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0119-inline_boundary_check_return_and_declaration_match_warning/inline_boundary_check_return_and_declaration_match_warning.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int g_size = 3;
+
+__attribute__((returns_count(1)))
+static inline int *caller(size_t size) {
+  int *p = (int*)malloc(sizeof(int) * size);
+  return p; // CHECK: [[# @LINE ]] warning: can't prove return value's bounds match the function declaration for caller when inlined to main
+}
+
+int main() {
+  int *s = caller(g_size);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0119-inline_boundary_check_return_and_declaration_match_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0119-inline_boundary_check_return_and_declaration_match_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b0ac3785347f615c745b1b15287bdf027736d4f5
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0119-inline_boundary_check_return_and_declaration_match_warning/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile(inline_boundary_check_return_and_declaration_match_warning)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_return_and_declaration_match_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0120-inline_boundary_check_upper_bound_warning/inline_boundary_check_upper_bound_warning.c b/testsuite/c_test/enhancec_test/ENC0120-inline_boundary_check_upper_bound_warning/inline_boundary_check_upper_bound_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..8efae99ea952cd8f817dfbd0f5ba9766f38dae25
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0120-inline_boundary_check_upper_bound_warning/inline_boundary_check_upper_bound_warning.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int g_index = 2;
+
+__attribute__((count_index(2, 1)))
+static inline void caller(int *p, size_t size, int index) {
+  p = p + index; // CHECK: [[# @LINE ]] warning: can't prove the pointer >= the lower bounds after calculation when inlined to main
+  // CHECK: [[# @LINE - 1 ]] warning: can't prove the pointer < the upper bounds after calculation when inlined to main
+}
+
+int main() {
+  int size = 3;
+  int *p = (int*)malloc(sizeof(int) * size);
+  caller(p, size, g_index);
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0120-inline_boundary_check_upper_bound_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0120-inline_boundary_check_upper_bound_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..032455a150a1eb171c71ec19ba1e1a911f79ffdb
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0120-inline_boundary_check_upper_bound_warning/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile(inline_boundary_check_upper_bound_warning)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_upper_bound_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0121-inline_nonnull_check_err/inline_nonnull_check_err.c b/testsuite/c_test/enhancec_test/ENC0121-inline_nonnull_check_err/inline_nonnull_check_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..17612b0249f1add0a8b5d8f7463acd47913b4d4d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0121-inline_nonnull_check_err/inline_nonnull_check_err.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static inline void test() {
+  int *q = NULL;
+  int *p __attribute__((nonnull)) = q; // CHECK: [[# @LINE ]] error: null assignment of nonnull pointer when inlined to main
+}
+
+int main() {
+  test();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0121-inline_nonnull_check_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0121-inline_nonnull_check_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc5a4f87bedac4c2dd67144687db0091bae24546
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0121-inline_nonnull_check_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_N_D_ALL:
+compile_err(inline_nonnull_check_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_nonnull_check_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0122-nonnull_check_insert_err/nonnull_check_insert_err.c b/testsuite/c_test/enhancec_test/ENC0122-nonnull_check_insert_err/nonnull_check_insert_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b859f18b271a88daa88ded738d68034a596ff78
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0122-nonnull_check_insert_err/nonnull_check_insert_err.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+SAFE void func2(int *p __attribute__((nonnull)));
+SAFE void func3() {
+  int *q = (int*)malloc(sizeof(int));
+  func2(q); // CHECK: [[# @LINE ]] error: nullable pointer passed to func2 that requires a nonnull pointer for 1st argument in safe region
+}
+
+int main() {
+  func3();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0122-nonnull_check_insert_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0122-nonnull_check_insert_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc8eab204acccd69e66eededbac3c8cdb1151b55
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0122-nonnull_check_insert_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_S_D:
+compile_err(nonnull_check_insert_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_insert_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0123-inline_nonnull_check_insert_err/inline_nonnull_check_insert_err.c b/testsuite/c_test/enhancec_test/ENC0123-inline_nonnull_check_insert_err/inline_nonnull_check_insert_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..5fe00df32cde5795de99af97d1c78161d3f838a6
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0123-inline_nonnull_check_insert_err/inline_nonnull_check_insert_err.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+SAFE void func2(int *p __attribute__((nonnull)));
+SAFE static inline void func1() {
+  int *q = (int*)malloc(sizeof(int));
+  func2(q); // CHECK: [[# @LINE ]] error: nullable pointer passed to func2 that requires a nonnull pointer for 1st argument in safe region when inlined to main
+}
+
+int main() {
+  func1();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0123-inline_nonnull_check_insert_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0123-inline_nonnull_check_insert_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6b992a38fc0016b18d281d7cf566048f6a28af96
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0123-inline_nonnull_check_insert_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_S_D:
+compile_err(inline_nonnull_check_insert_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_nonnull_check_insert_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0124-nonnull_check_assignment_err/nonnull_check_assignment_err.c b/testsuite/c_test/enhancec_test/ENC0124-nonnull_check_assignment_err/nonnull_check_assignment_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a573293c021de5354b8e1ee2fe76e0b6e9fffaf
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0124-nonnull_check_assignment_err/nonnull_check_assignment_err.c
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+SAFE int main() {
+  int *q = (int*)malloc(sizeof(int));
+  int *p __attribute__((nonnull)) = q; // CHECK: [[# @LINE ]] error: nullable pointer assignment of nonnull pointer in safe region
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0124-nonnull_check_assignment_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0124-nonnull_check_assignment_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bdea681ee5c62237632c12c39fa87b113d10c38c
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0124-nonnull_check_assignment_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_S_D:
+compile_err(nonnull_check_assignment_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_assignment_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0125-inline_nonnull_check_assignment_err/inline_nonnull_check_assignment_err.c b/testsuite/c_test/enhancec_test/ENC0125-inline_nonnull_check_assignment_err/inline_nonnull_check_assignment_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..ed9c8a44c79492d70ea4ff410c5c486d65f9af1a
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0125-inline_nonnull_check_assignment_err/inline_nonnull_check_assignment_err.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+SAFE static inline void func(){
+  int *q = (int*)malloc(sizeof(int));
+  int *p __attribute__((nonnull)) = q; // CHECK: [[# @LINE ]] error: nullable pointer assignment of nonnull pointer in safe region when inlined to main
+}
+
+SAFE int main() {
+  func();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0125-inline_nonnull_check_assignment_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0125-inline_nonnull_check_assignment_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ce6005d2237b3f7b5961069fb0e2252c8882285d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0125-inline_nonnull_check_assignment_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_S_D:
+compile_err(inline_nonnull_check_assignment_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_nonnull_check_assignment_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0126-inline_return_nonnull_check_err/inline_return_nonnull_check_err.c b/testsuite/c_test/enhancec_test/ENC0126-inline_return_nonnull_check_err/inline_return_nonnull_check_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..c99eea1b331bd18cef3bdceea29c963be23e8fb0
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0126-inline_return_nonnull_check_err/inline_return_nonnull_check_err.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((returns_nonnull))
+SAFE static inline int* Test() {
+  return (int*)malloc(sizeof(int)); // CHECK: [[# @LINE ]] error: Test return nonnull but got nullable pointer in safe region when inlined to main
+}
+
+SAFE int main() {
+  int *p = Test();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0126-inline_return_nonnull_check_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0126-inline_return_nonnull_check_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a722a040accb72d22bc763e82c51faba8a94df9d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0126-inline_return_nonnull_check_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_S_D:
+compile_err(inline_return_nonnull_check_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_return_nonnull_check_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0127-inline_nonnull_check_dereference_err/inline_nonnull_check_dereference_err.c b/testsuite/c_test/enhancec_test/ENC0127-inline_nonnull_check_dereference_err/inline_nonnull_check_dereference_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..8be7cdeb7827df82c1a72d66e781a28d6325a975
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0127-inline_nonnull_check_dereference_err/inline_nonnull_check_dereference_err.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+SAFE static inline void Test() {
+  int *p = (int*)malloc(sizeof(int));
+  int *q = *p; // CHECK: [[# @LINE ]] error: Dereference of nullable pointer in safe region when inlined to main
+}
+
+SAFE int main() {
+  Test();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0127-inline_nonnull_check_dereference_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0127-inline_nonnull_check_dereference_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3fbd981133e5ce53689596281acb8b143cb61f9e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0127-inline_nonnull_check_dereference_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_S_D:
+compile_err(inline_nonnull_check_dereference_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_nonnull_check_dereference_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0128-inline_boundary_check_r-value_err/inline_boundary_check_r-value_err.c b/testsuite/c_test/enhancec_test/ENC0128-inline_boundary_check_r-value_err/inline_boundary_check_r-value_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..57f06ce5c54038b347ffc3f36af950c092e3f772
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0128-inline_boundary_check_r-value_err/inline_boundary_check_r-value_err.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static inline void Test() {
+  int *q;
+  int *p __attribute__((count(5))) = q; // CHECK: [[# @LINE ]] error: r-value requires a boundary pointer
+}
+
+int main() {
+  Test();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0128-inline_boundary_check_r-value_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0128-inline_boundary_check_r-value_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..88f4cdfdb097124f2493cdbec68df982918e9d4b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0128-inline_boundary_check_r-value_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_r-value_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_r-value_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0129-inline_boundary_check_l-value_larger_r-value_err/inline_boundary_check_l-value_larger_r-value_err.c b/testsuite/c_test/enhancec_test/ENC0129-inline_boundary_check_l-value_larger_r-value_err/inline_boundary_check_l-value_larger_r-value_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..655f1511b38baa48e38b3b52c0b37cd996edfa9b
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0129-inline_boundary_check_l-value_larger_r-value_err/inline_boundary_check_l-value_larger_r-value_err.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static inline void Test() {
+  int *q __attribute__((count(5)));
+  int *p __attribute__((count(6)));
+  p = q; // CHECK: [[# @LINE ]] error: l-value boundary should not be larger than r-value boundary when inlined to main
+}
+
+int main() {
+  Test();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0129-inline_boundary_check_l-value_larger_r-value_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0129-inline_boundary_check_l-value_larger_r-value_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b02d25469e89024341da3364e98b0d31d17b71aa
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0129-inline_boundary_check_l-value_larger_r-value_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_l-value_larger_r-value_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_l-value_larger_r-value_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0130-inline_boundary_check_con_l-value_larger_r-value_err/inline_boundary_check_con_l-value_larger_r-value_err.c b/testsuite/c_test/enhancec_test/ENC0130-inline_boundary_check_con_l-value_larger_r-value_err/inline_boundary_check_con_l-value_larger_r-value_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..d71f44d481ffea1a025c3bc6b7e88ab7d35881ac
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0130-inline_boundary_check_con_l-value_larger_r-value_err/inline_boundary_check_con_l-value_larger_r-value_err.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static inline void Test() {
+  short int *q __attribute__((count(5)));
+  int *p __attribute__((count(2)));
+  q = (short int*)p; // CHECK: [[# @LINE ]] error: l-value boundary should not be larger than r-value boundary when inlined to main
+}
+
+int main() {
+  Test();
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0130-inline_boundary_check_con_l-value_larger_r-value_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0130-inline_boundary_check_con_l-value_larger_r-value_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d50541badb3ea6c9a5b216e965231cfd67a58ba4
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0130-inline_boundary_check_con_l-value_larger_r-value_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_con_l-value_larger_r-value_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_con_l-value_larger_r-value_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0131-inline_boundary_check_transfer_boundaryless_err/inline_boundary_check_transfer_boundaryless_err.c b/testsuite/c_test/enhancec_test/ENC0131-inline_boundary_check_transfer_boundaryless_err/inline_boundary_check_transfer_boundaryless_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..7871bc7bddc09000078c8cd7f184593919c936f8
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0131-inline_boundary_check_transfer_boundaryless_err/inline_boundary_check_transfer_boundaryless_err.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((count(10, 1)))
+void func1(int* p);
+void func2() {
+  int *p;
+  func1(p); // CHECK: [[# @LINE ]] error: boundaryless pointer passed to func1 that requires a boundary pointer for the 1st argument
+}
+
+int main() {
+  func2();
+  return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0131-inline_boundary_check_transfer_boundaryless_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0131-inline_boundary_check_transfer_boundaryless_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9e7e247811ecedc0a0dc040a5864133571d69cb4
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0131-inline_boundary_check_transfer_boundaryless_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_transfer_boundaryless_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_transfer_boundaryless_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0132-inline_boundary_check_declaration_match_err/inline_boundary_check_declaration_match_err.c b/testsuite/c_test/enhancec_test/ENC0132-inline_boundary_check_declaration_match_err/inline_boundary_check_declaration_match_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..16b6f27acd0c70ae8063ca0a2f4c14c0c19948a6
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0132-inline_boundary_check_declaration_match_err/inline_boundary_check_declaration_match_err.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((count(10, 1)))
+void func1(int* p);
+static inline void func2() {
+  int *p = (int*)malloc(sizeof(int));
+  func1(p); // CHECK: [[# @LINE ]] error: the pointer's bounds does not match the function func1 declaration for the 1st argument when inlined to main
+}
+
+int main() {
+  func2();
+  return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0132-inline_boundary_check_declaration_match_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0132-inline_boundary_check_declaration_match_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0fdb89e02a3e33433ef1c9f9e9d36a27f5f43767
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0132-inline_boundary_check_declaration_match_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_declaration_match_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_declaration_match_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0133-inline_boundary_check_boundaryless_return_err/inline_boundary_check_boundaryless_return_err.c b/testsuite/c_test/enhancec_test/ENC0133-inline_boundary_check_boundaryless_return_err/inline_boundary_check_boundaryless_return_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..864046265221fbb34cd33675b9ae2ab11ee55800
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0133-inline_boundary_check_boundaryless_return_err/inline_boundary_check_boundaryless_return_err.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((returns_count(2)))
+int* func() {
+  int *p;
+  return p; // CHECK: [[# @LINE ]] error: boundaryless pointer returned from func that requires a boundary pointer
+}
+
+int main() {
+  int p = func();
+  return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0133-inline_boundary_check_boundaryless_return_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0133-inline_boundary_check_boundaryless_return_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68463247c720e4e3c31d6836c460b0bb7bdc20cf
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0133-inline_boundary_check_boundaryless_return_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_boundaryless_return_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_boundaryless_return_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0134-inline_boundary_check_ptr_operation_warning/inline_boundary_check_ptr_operation_warning.c b/testsuite/c_test/enhancec_test/ENC0134-inline_boundary_check_ptr_operation_warning/inline_boundary_check_ptr_operation_warning.c
new file mode 100644
index 0000000000000000000000000000000000000000..293e9386915f9401838844424b1836f62e9bdef3
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0134-inline_boundary_check_ptr_operation_warning/inline_boundary_check_ptr_operation_warning.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void func() {
+  int *p __attribute__((count(5)));
+  int *q = p - 5; // CHECK: [[# @LINE ]] warning: the pointer < the lower bounds after calculation
+}
+
+void func1() {
+  int *p __attribute__((count(5)));
+  int *q = p + 5; // CHECK: [[# @LINE ]] warning: the pointer >= the upper bounds after calculation
+}
+
+static inline void func2() {
+  int *p __attribute__((count(5)));
+  int *q = p + 5; // CHECK: [[# @LINE ]] warning: the pointer >= the upper bounds after calculation when inlined to main
+}
+
+static inline void func3() {
+  int *p __attribute__((count(5)));
+  int *q = p - 5; // CHECK: [[# @LINE ]] warning: the pointer < the lower bounds after calculation when inlined to main
+}
+
+int main() {
+  func();
+  func1();
+  func2();
+  func3();
+  return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0134-inline_boundary_check_ptr_operation_warning/test.cfg b/testsuite/c_test/enhancec_test/ENC0134-inline_boundary_check_ptr_operation_warning/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..32c9069c84692fe8825db669f4781a426d9fa77d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0134-inline_boundary_check_ptr_operation_warning/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile(inline_boundary_check_ptr_operation_warning)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_ptr_operation_warning.c
diff --git a/testsuite/c_test/enhancec_test/ENC0135-inline_boundary_check_accessing_memory_err/inline_boundary_check_accessing_memory_err.c b/testsuite/c_test/enhancec_test/ENC0135-inline_boundary_check_accessing_memory_err/inline_boundary_check_accessing_memory_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..06032a35083375e86bc35bfb6934a9f5701097b5
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0135-inline_boundary_check_accessing_memory_err/inline_boundary_check_accessing_memory_err.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static inline void func() {
+  int a[10] = {0};
+  int *b = a - 10; // CHECK: [[# @LINE ]] warning: the pointer < the lower bounds after calculation when inlined to main
+  printf("%d\n", *b); // CHECK: [[# @LINE ]] error: the pointer < the lower bounds when accessing the memory and inlined to main
+}
+
+int main() {
+  func();
+  return 0;
+}
+
diff --git a/testsuite/c_test/enhancec_test/ENC0135-inline_boundary_check_accessing_memory_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0135-inline_boundary_check_accessing_memory_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6754d6c39454a7c54f41374718b9fe7e3313e883
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0135-inline_boundary_check_accessing_memory_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(inline_boundary_check_accessing_memory_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck inline_boundary_check_accessing_memory_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0136-declaration_and_definition_inconsistent_err/declaration_and_definition_inconsistent_err.c b/testsuite/c_test/enhancec_test/ENC0136-declaration_and_definition_inconsistent_err/declaration_and_definition_inconsistent_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..c36f831e7f82aab06d4084278e7f41563965fb03
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0136-declaration_and_definition_inconsistent_err/declaration_and_definition_inconsistent_err.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2020-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void test1();
+SAFE void test1() {} // CHECK-NOT: [[# @LINE ]] error
+
+SAFE void test();
+UNSAFE void test() {} // CHECK: [[# @LINE ]] error: The function test declaration and definition security attributes are inconsistent.
+
diff --git a/testsuite/c_test/enhancec_test/ENC0136-declaration_and_definition_inconsistent_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0136-declaration_and_definition_inconsistent_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..243ffd64215a5e01c86ec6dc6f367b94869b8d03
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0136-declaration_and_definition_inconsistent_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_S_D:
+compile_err(declaration_and_definition_inconsistent_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck declaration_and_definition_inconsistent_err.c
diff --git a/testsuite/c_test/enhancec_test/ENC0137-boundary_count_inde_err/boundary_byte_count.c b/testsuite/c_test/enhancec_test/ENC0137-boundary_count_inde_err/boundary_byte_count.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a9bad1cedafb933937d311a7ccd8b8b8eecb9a7
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0137-boundary_count_inde_err/boundary_byte_count.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+__attribute__((byte_count_index(2))) // CHECK: boundary_byte_count.c:[[# @LINE ]]
+void foo(int *ptr, int len) {
+  return;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0137-boundary_count_inde_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0137-boundary_count_inde_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..656bea6a23e209969a5807e3af93fcc05cfc8068
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0137-boundary_count_inde_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_B_D:
+compile_err(boundary_byte_count)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck boundary_byte_count.c
+
diff --git a/testsuite/c_test/enhancec_test/ENC0138-safe_region_check_err_index/check_err_index.c b/testsuite/c_test/enhancec_test/ENC0138-safe_region_check_err_index/check_err_index.c
new file mode 100644
index 0000000000000000000000000000000000000000..b5ec9d3a1e4d7ddd8df8a83abb985af35cc58b98
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0138-safe_region_check_err_index/check_err_index.c
@@ -0,0 +1,29 @@
+#include<stdlib.h>
+#include<c_enhanced.h>
+#pragma SAFE ON
+
+typedef struct A {
+    int* p __attribute__((nonnull));
+}A;
+
+BCNTI(3, 1)
+SAFE void *ExtFunc(void *__s, int __c, size_t count);
+
+BCNTI(3, 1)
+SAFE void *memset(void *__s, int __c, size_t count);
+
+
+int main() {
+  A aa = {(int*)malloc(64)};
+  A *p1 = &aa;
+  int *p2 = (int*)&aa;
+  A a1 = {NULL};               // CHECK: [[# @LINE ]] error: null assignment of nonnull pointer
+  memset(p1, 0, sizeof(A));    // CHECK-NEXT: [[# @LINE ]] error: null assignment of nonnull structure field pointer in memset
+                               // CHECK-NEXT: [[# @LINE - 1]] error: boundaryless pointer passed to memset that requires a boundary pointer for the 1st argument
+  aa.p = NULL;                 // CHECK-NEXT: [[# @LINE ]] error: null assignment of nonnull pointer
+  memset(p2, 0, sizeof(A));    // CHECK-NEXT: [[# @LINE ]] error: boundaryless pointer passed to memset that requires a boundary pointer for the 1st argument
+  ExtFunc(&aa, 0, sizeof(A));
+  memset(&aa, 0, sizeof(A));   // CHECK-NEXT: [[# @LINE ]] error: null assignment of nonnull structure field pointer in memset
+                               // CHECK-NEXT: Info  00: 6 error(s) generated.
+  return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0138-safe_region_check_err_index/test.cfg b/testsuite/c_test/enhancec_test/ENC0138-safe_region_check_err_index/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5c03e1adf586e63f7950efca06f0101bd1af98bb
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0138-safe_region_check_err_index/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile_err(check_err_index)
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck check_err_index.c
diff --git a/testsuite/c_test/enhancec_test/ENC0139-safe_region_defaultSafe/defaultSafe.c b/testsuite/c_test/enhancec_test/ENC0139-safe_region_defaultSafe/defaultSafe.c
new file mode 100644
index 0000000000000000000000000000000000000000..148d32995db53a0bf88e1b4ddba800a918c37e75
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0139-safe_region_defaultSafe/defaultSafe.c
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+// CHECK: [[# FILENUM:]] "{{.*}}/defaultSafe.c"
+
+// CHECK: func &func0 public safed () void
+void func0(void) {
+  // CHECK: dassign %a{{.*}} 0 (constval i32 2)
+  int a = 2;
+  // CHECK-NOT: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: safe
+  {
+    // CHECK-NEXT: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NEXT: dassign %a{{.*}} 0 (constval i32 0)
+    int a = 0;
+    // CHECK-NOT: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NOT: endsafe
+  }
+}
+
+// CHECK: func &main public safed () i32
+__Safe__ int main() {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: unsafe
+  __Unsafe__ {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %a{{.*}} 0 (constval i32 1)
+  int a = 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: endunsafe
+  }
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: safe
+  __Safe__ {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %b{{.*}} 0 (constval i32 3)
+  int b = 3;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: endsafe
+  }
+  // CHECK-NOT: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: safe
+  {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: dassign %c{{.*}} 0 (constval i32 4)
+    int c = 4;
+    // CHECK-NOT: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NOT: endsafe
+  }
+  return 0;
+}
+
+// CHECK: func &func5 public unsafed () void
+__Unsafe__ void func5(void) {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: unsafe
+  __Unsafe__ {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %a{{.*}} 0 (constval i32 1)
+  int a = 1;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: endunsafe
+  }
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: safe
+  __Safe__ {
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK: dassign %b{{.*}} 0 (constval i32 3)
+  int b = 3;
+  // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NEXT: endsafe
+  }
+  // CHECK-NOT: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+  // CHECK-NOT: safe
+  {
+    // CHECK: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK: dassign %c{{.*}} 0 (constval i32 4)
+    int c = 4;
+    // CHECK-NOT: LOC [[# FILENUM]] [[# @LINE + 2 ]]
+    // CHECK-NOT: endsafe
+  }
+}
+
+#pragma SAFE OFF
+// CHECK: func &func1 public unsafed () void
+void func1(void) {
+}
+
+// CHECK: func &func2 public safed () void
+__Safe__ void func2(void){
+}
+
+#pragma SAFE ON
+
+// CHECK: func &func3 public safed () void
+void func3(void) {
+}
+
+// CHECK: func &func4 public unsafed () void
+__Unsafe__ void func4(void) {
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0139-safe_region_defaultSafe/expected.txt b/testsuite/c_test/enhancec_test/ENC0139-safe_region_defaultSafe/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0139-safe_region_defaultSafe/test.cfg b/testsuite/c_test/enhancec_test/ENC0139-safe_region_defaultSafe/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..df34b165bebf6413e5ba4d766ea26e44badf12c8
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0139-safe_region_defaultSafe/test.cfg
@@ -0,0 +1,7 @@
+ENCO2_S_D:
+${OUT_ROOT}/tools/bin/clang -emit-ast --target=aarch64 -U __SIZEOF_INT128__ -DC_ENHANCED -isystem ${MAPLE_BUILD_OUTPUT}/lib/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include -isystem ../lib/include -o defaultSafe.ast  defaultSafe.c>tmp.log 2>&1 && (cat tmp.log | tee -a compile.log && rm tmp.log) || (cat tmp.log | tee -a compile.log && rm tmp.log && exit 1)
+${MAPLE_BUILD_OUTPUT}/bin/hir2mpl -safe-region -defaultSafe defaultSafe.ast -o defaultSafe.mpl>tmp.log 2>&1 && (cat tmp.log | tee -a compile.log && rm tmp.log)
+${MAPLE_BUILD_OUTPUT}/bin/maple --run=me:mpl2mpl:mplcg --option="-O2 --quiet:-O2:-O2 --fpic --quiet" --save-temps --npe-check-dynamic --boundary-check-dynamic --safe-region --infile defaultSafe.mpl>tmp.log 2>&1 && (cat tmp.log | tee -a compile.log && rm tmp.log) || (cat tmp.log | tee -a compile.log && rm tmp.log && exit 1)
+${OUT_ROOT}/tools/bin/aarch64-linux-gnu-gcc  -o a.out `find *.s`  -lm>tmp.log 2>&1 && (cat tmp.log | tee -a compile.log && rm tmp.log) || (cat tmp.log | tee -a compile.log && rm tmp.log && exit 1)
+run(defaultSafe)
+cat defaultSafe.mpl | ${OUT_ROOT}/tools/bin/FileCheck defaultSafe.c
diff --git a/testsuite/c_test/enhancec_test/ENC0140-CreateValueRangeForLeOrLt-boundary_check/createValueRangeForLeOrLt-boundary_check.c b/testsuite/c_test/enhancec_test/ENC0140-CreateValueRangeForLeOrLt-boundary_check/createValueRangeForLeOrLt-boundary_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..d980921fb109a651d69c5f5d8d324ea3a9c783d0
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0140-CreateValueRangeForLeOrLt-boundary_check/createValueRangeForLeOrLt-boundary_check.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <limits.h>
+
+struct {
+  float a[1000];
+} b;
+int c = 0, d = 0, e = 0;
+float g = 0;
+int main() {
+  if (d != c)
+    return 0;
+  for (; e < d; e++)
+    g = b.a[e];
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0140-CreateValueRangeForLeOrLt-boundary_check/expected.txt b/testsuite/c_test/enhancec_test/ENC0140-CreateValueRangeForLeOrLt-boundary_check/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0140-CreateValueRangeForLeOrLt-boundary_check/test.cfg b/testsuite/c_test/enhancec_test/ENC0140-CreateValueRangeForLeOrLt-boundary_check/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50ac4876bcfad41e30e50066eeef129b4fed3820
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0140-CreateValueRangeForLeOrLt-boundary_check/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_B_D:
+compile(createValueRangeForLeOrLt-boundary_check)
+run(createValueRangeForLeOrLt-boundary_check)
+
diff --git a/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info/safe_region_no_boundary_info.c b/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info/safe_region_no_boundary_info.c
new file mode 100644
index 0000000000000000000000000000000000000000..4672fa71ea02ce79a050e0bc3dfaa96f0236c15d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info/safe_region_no_boundary_info.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+main() {
+  int32_t *b;
+  int32_t c[7];
+  if (0)
+    b = c;
+  __Safe__ {
+    int32_t *p2 = b + 1; // CHECK:error: the pointer has no boundary info.
+  }
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info/test.cfg b/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0e675c43486e9dc6c0512e624aa7005b515cd235
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_S_D:
+compile_err(safe_region_no_boundary_info)
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck safe_region_no_boundary_info.c
diff --git a/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info_2/expected.txt b/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info_2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info_2/safe_region_no_boundary_info.c b/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info_2/safe_region_no_boundary_info.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd0f180a640e1c396e9e9953c39dc5d215d1abef
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info_2/safe_region_no_boundary_info.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+main() {
+  int32_t *b;
+  int32_t c[7];
+  if (0)
+    b = c;
+  int32_t *p2 = b + 1;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info_2/test.cfg b/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info_2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ab26f8414d5a146661a985cf333048f5f8c276e
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0141-safe_region_no_boundary_info_2/test.cfg
@@ -0,0 +1,4 @@
+ENCO2_S_D:
+compile(safe_region_no_boundary_info)
+run(safe_region_no_boundary_info)
+
diff --git a/testsuite/c_test/enhancec_test/ENC0142-nonnull_check_return_err/nonnull_check_return_err.c b/testsuite/c_test/enhancec_test/ENC0142-nonnull_check_return_err/nonnull_check_return_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..fcc7a064c06abd571fba309e6278caa13a072fbe
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0142-nonnull_check_return_err/nonnull_check_return_err.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+unsigned int* __attribute__((returns_nonnull)) func_a(int*  __attribute__((nonnull)) p) ;
+unsigned int* func_a(int* p)
+{
+    unsigned int* ret = (unsigned int*) malloc(sizeof(unsigned int));
+    ret = NULL;
+    return ret; // CHECK: [[# @LINE ]] error: func_a return nonnull but got null pointer
+}
+
+int main(int argc, char* argv[])
+{
+    return 0;
+}
diff --git a/testsuite/c_test/enhancec_test/ENC0142-nonnull_check_return_err/test.cfg b/testsuite/c_test/enhancec_test/ENC0142-nonnull_check_return_err/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d0353f331ab40a43ce9ca5f4d389c2889dd27dc8
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/ENC0142-nonnull_check_return_err/test.cfg
@@ -0,0 +1,5 @@
+ENCO2_N_D:
+compile_err(nonnull_check_return_err)
+cat compile.log
+sort compile.log -t ':' -k 3 -n -o compile.log
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck nonnull_check_return_err.c
diff --git a/testsuite/c_test/enhancec_test/lib/include/cvaltarget.h b/testsuite/c_test/enhancec_test/lib/include/cvaltarget.h
new file mode 100644
index 0000000000000000000000000000000000000000..85f25620ee7f610c6b7991d5136cac07839919fc
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/lib/include/cvaltarget.h
@@ -0,0 +1,165 @@
+/*
+ * Always included file that describes the implementation's data model.
+ */
+
+#ifndef CVAL_TARGET_H
+#define CVAL_TARGET_H
+
+/*
+ * SuperTest Usage configuration
+ */
+
+        /* Uncomment this #define to compile tests without the diagnostic
+         * library. It makes tests smaller and tests do not generate any
+         * output, which is useful on bare-metal targets. See also CVAL_EXIT()
+         * below.
+         */
+/* #define CVAL_SILENT_LIBRARY  */
+
+        /* Remove this #define when C complex types are not supported. For C90
+         * or C++ compilers, this macro will automatically be undefined, since
+         * C complex types are only supported by C99 and later versions of C.
+         */
+#define CVAL_HAVE_COMPLEX
+
+        /* If the compiler does not support floating point,
+         * this #define skips floating point support in the
+         * SuperTest diagnostic library. It does NOT automatically
+         * skip tests with floating point. To achieve that,
+         * subtract any or all of the predefined test sets
+         * float/double/longdouble in SETS/ in the test set
+         * definition.
+         */
+/* #define CVAL_NOFLOAT		*/
+
+        /* The SuperTest diagnostic library reads the arguments to the
+         * main() function called argc and argv. If they are inconsistent
+         * (happens rarely and only on embedded systems), this can be
+         * turned off by enabling the #define CVAL_NO_ARGC_ARGV.
+         */
+/* #define CVAL_NO_ARGC_ARGV	*/
+
+        /*
+         * Uncomment this define to use static arrays instead
+         * of dynamically allocated memory in the test suite
+         * "optimize/". This is useful if your target does
+         * not support dynamically allocated memory.
+         */
+/* #define CVAL_STATIC_MEMORY */
+
+/*
+ * SuperTest has a very small footprint. When CVAL_SILENT_LIBRARY
+ * is set, it only needs to return its exit value. It uses the
+ * macro CVAL_EXIT(x) to do this. This macro can be redefined here
+ * its default definition of 'exit(x)' is not correct.
+ *
+ * If CVAL_SILENT_LIBRARY is not defined (which is the default),
+ * then additionally the tests use CVAL_PUTCHAR(x) to print
+ * diagnostic output. It can be redefined here is 'putchar(x)'
+ * is not the right way to do this.
+ */
+#ifdef COMPILING_CVAL_LIB
+
+    #include <stdlib.h>
+    #define CVAL_EXIT(x)	exit(x)
+
+    #ifdef CVAL_SILENT_LIBRARY
+            /* No output needed for CVAL_SILENT_LIBRARY, no
+             * stdio.h included.
+             */
+        #define CVAL_PUTCHAR(x)	/* No output */
+    #else
+        #include <stdio.h>
+        #define CVAL_PUTCHAR(x)	putchar(x)
+    #endif
+
+#endif
+
+/*
+ * Target dependent values.
+ *
+ * These values must be adapted to the data-model of the target architecture.
+ * This default file target/cvaltarget.h in SuperTest is set to work for
+ * the common 32 and 64 bit data models. For many not-so mainstream
+ * processors, they may need to be modified.
+ * If these value are not set up to match the target, SuperTest will fail
+ * with an error "Null test failed", when testing "suite/FIRST/test0.c"
+ */
+
+#include <limits.h>     /* Only needed for INT_MAX==LONG_MAX compare */
+#if INT_MAX == LONG_MAX
+    #define CVAL_LONGSIZE       32      /* The size of a long in bits. */
+    #define CVAL_POINTERSIZE    32      /* The size of a void* in bits. */
+#else
+    #define CVAL_LONGSIZE       64      /* The size of a long in bits. */
+    #define CVAL_POINTERSIZE    64      /* The size of a void* in bits. */
+#endif
+
+#define CVAL_LONGLONGSIZE       64      /* The size of a long long in bits. */
+#define CVAL_INTSIZE            32      /* The size of an int in bits. */
+#define CVAL_SHORTSIZE          16      /* The size of a short in bits.     */
+#define CVAL_CHARSIZE           8       /* The size of a char in bits.      */
+#define CVAL_WCHARSIZE          32      /* The size of wchar_t in bits.     */
+
+/* #define ONECOMPL	*/		/* machine is one's complement */
+#define TWOCOMPL			/* machine is two's complement */
+
+/*
+ * IEEE-754 example values
+ */
+#define FLOAT_MANTISSA		24
+#define DOUBLE_MANTISSA		53
+
+/*
+ * Floating point absolute and relative precision for float and double.
+ */
+
+#ifdef CVAL_FP_IEEE
+/*
+ * These values should be attainable for IEEE-754.
+ * Accumulating errors in eg math functions might exceed the bounds.
+ * From considerations of quality, an attempt should be made to fix such
+ * math functions.
+ * Otherwise these values might be adapted.
+ */
+#define CVAL_A_FLOAT_PRECISION		5E-6
+#define CVAL_R_FLOAT_PRECISION		5E-7
+
+#define CVAL_A_DOUBLE_PRECISION		1E-14
+#define CVAL_R_DOUBLE_PRECISION		1E-15
+
+#define CVAL_A_LDOUBLE_PRECISION	1E-14
+#define CVAL_R_LDOUBLE_PRECISION	1E-15
+
+#else	/* ! CVAL_FP_IEEE */
+
+/*
+ * These are well within ISO-C minimum precision requirements for
+ * the accuracy of floating point representation.
+ */
+#define CVAL_A_FLOAT_PRECISION		5E-4
+#define CVAL_R_FLOAT_PRECISION		5E-5
+
+#define CVAL_A_DOUBLE_PRECISION		5E-8
+#define CVAL_R_DOUBLE_PRECISION		5E-9
+
+#define CVAL_A_LDOUBLE_PRECISION	5E-8
+#define CVAL_R_LDOUBLE_PRECISION	5E-9
+
+#endif	/* CVAL_FP_IEEE */
+
+/*
+ * The locale category LC_CTYPE affects the behavior of the
+ * character handling functions and the multibyte and wide
+ * character functions. To test UTF-16 and UTF-32 Unicode
+ * utilities (Section C11:7.28) a specific UTF-8 encoding
+ * locale should be set. The default locale "C" commonly
+ * does not provide UTF-8 and the existence of any other
+ * locale is user defined. In this case, the well-known
+ * "en_US.UTF-8" locale is selected, however, any other
+ * UTF-8 compliant locale would be also suitable.
+ */
+#define CVAL_LOCALE     "en_US.UTF-8"
+
+#endif	/* CVAL_TARGET_H */
+
diff --git a/testsuite/c_test/enhancec_test/lib/include/def.h b/testsuite/c_test/enhancec_test/lib/include/def.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e2f8c284218999553a56b711bcf7de4a98c1c5d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/lib/include/def.h
@@ -0,0 +1,481 @@
+/*
+ *
+ * COPYRIGHT NOTICE (NOT TO BE REMOVED):
+ *
+ * This file, or parts of it, or modified versions of it, may not be copied,
+ * reproduced or transmitted in any form, including reprinting, translation,
+ * photocopying or microfilming, or by any means, electronic, mechanical or
+ * otherwise, or stored in a retrieval system, or used for any purpose, without
+ * the prior written permission of all Owners unless it is explicitly marked as
+ * having Classification `Public'.
+ *
+ * Owners of this file give notice:
+ *   (c) Copyright 2015-2019 by Solid Sands B.V.,
+ *       Amsterdam, the Netherlands. All rights reserved.
+ *   (c) Copyright 1996-2012 ACE Associated Compiler Experts bv
+ *   (c) Copyright 1995-2012 ACE Associated Computer Experts bv
+ * All rights, including copyrights, reserved.
+ *
+ * This file contains or may contain restricted information and is UNPUBLISHED
+ * PROPRIETARY SOURCE CODE OF THE Owners.  The Copyright Notice(s) above do not
+ * evidence any actual or intended publication of such source code.  This file
+ * is additionally subject to the conditions listed in the RESTRICTIONS file
+ * and is with NO WARRANTY.
+ *
+ * END OF COPYRIGHT NOTICE
+ */
+
+#ifndef CVAL_DEF_H
+#define CVAL_DEF_H
+
+#ifdef __cplusplus
+    extern "C" {
+#endif
+
+#include <limits.h>
+
+#include "cvaltarget.h"
+
+/********************************
+ * The following section define SuperTest specific macros used by the
+ * tests or by the diagnostic library. They are protected by #ifdefs, so
+ * that they can be overruled easily in the cvaltarget.h file.
+ */
+
+#ifndef CVAL_A_LDOUBLE_PRECISION
+#define CVAL_A_LDOUBLE_PRECISION CVAL_A_DOUBLE_PRECISION
+#endif
+
+#ifndef CVAL_R_LDOUBLE_PRECISION
+#define CVAL_R_LDOUBLE_PRECISION CVAL_R_DOUBLE_PRECISION
+#endif
+
+/*
+ *	This file does not (and should not) #include standard headers.
+ *	If testfiles need them, they should include them.
+ */
+
+#ifdef CVAL_SILENT_LIBRARY
+        /* Just shorthands */
+    #define CVAL_NODIAG
+#else
+    #define CVAL_YESDIAG
+#endif /* CVAL_SILENT_LIBRARY */
+
+#ifndef CVAL_HEADER
+    #ifdef CVAL_YESDIAG
+        #define CVAL_HEADER(s)		CVAL_HEADER_FUNC(s)
+    #else
+        #define CVAL_HEADER(s)          /* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_SECTION
+    #ifdef CVAL_YESDIAG
+        #define CVAL_SECTION(s)		CVAL_SECTION_FUNC(s)
+    #else
+        #define CVAL_SECTION(s)		/* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_ENDSECTION
+    #ifdef CVAL_YESDIAG
+        #define CVAL_ENDSECTION()	CVAL_ENDSECTION_FUNC()
+    #else
+        #define CVAL_ENDSECTION()	/* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_ACTION
+    #ifdef CVAL_YESDIAG
+        #define CVAL_ACTION(s)		CVAL_ACTION_FUNC(s)
+    #else
+        #define CVAL_ACTION(s)
+    #endif
+#endif
+
+#ifndef CVAL_DOTEST
+    #ifdef CVAL_YESDIAG
+        #define CVAL_DOTEST(do_str)	CVAL_ACTION (#do_str); do_str;
+    #else
+        #define CVAL_DOTEST(do_str)     do_str;
+    #endif
+#endif
+
+#ifndef CVAL_NOTEST
+    #ifdef CVAL_YESDIAG
+        #define CVAL_NOTEST()		CVAL_NOTEST_FUNC()
+    #else
+        #define CVAL_NOTEST()           /* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_CASE
+    #ifdef CVAL_YESDIAG
+        #define CVAL_CASE(c)		CVAL_CASE_FUNC(c)
+    #else
+        #define CVAL_CASE(c)            (void)(c);
+    #endif
+#endif
+
+#ifndef CVAL_NOCASE
+    #ifdef CVAL_YESDIAG
+        #define CVAL_NOCASE()		CVAL_NOCASE_FUNC()
+    #else
+        #define CVAL_NOCASE()           /* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_RFLAG
+#define CVAL_RFLAG	1
+#endif
+
+#ifndef CVAL_VFLAG
+#define CVAL_VFLAG	1
+#endif
+
+#ifndef CVAL_VERIFY
+    #ifdef CVAL_NODIAG
+            /* Use a library call because CVAL_EXIT is not
+             * available here, and is available in library.
+             */
+        #define CVAL_VERIFY(cond)   CVAL_VERIFY_MINIFUNC(cond)
+    #endif /* CVAL_NODIAG */
+#endif /* CVAL_VERIFY */
+
+#ifndef CVAL_VERIFY
+    #define CVAL_VERIFY(be)	CVAL_VERIFY_FUNC(be, #be, __LINE__)
+#endif /* CVAL_VERIFY */
+
+
+#define CVAL_ARRAY_COUNT(x)	(sizeof(x) / sizeof(x[0]))
+
+/*
+ *	For backwards compatibility.
+ */
+#define do_exit(eval)   (cval_exit_func(eval))
+#define CVAL_CONST	const
+
+#ifndef NULLCHAR
+    #define NULLCHAR	'\0'
+#endif /* NULLCHAR */
+
+/*
+ * The following is used to check floating point against some other value
+ * with a predefined precision.
+ */
+#ifndef CVAL_FC
+#define CVAL_FC(f, val) cval_float_approximates((f), (val))
+#endif
+#ifndef CVAL_DC
+#define CVAL_DC(f, val) cval_double_approximates((f), (val))
+#endif
+#ifndef CVAL_QC
+#define CVAL_QC(f, val) cval_ldouble_approximates((f), (val))
+#endif
+
+/******************************************
+ * The following section defines SuperTest specific macros to identify
+ * the C or C++ version of the compiler. This is done to make it easier
+ * to write version specific code in tests. (The macros defined by the
+ * language standard are harder to memorize and not so orthogonal.)
+ *
+ * Two sets of macros exists, and from each set EXACTLY ONE macro must
+ * be defined. The first set defines the current language that is compiled,
+ * C or C++. It respectively contains the macros:
+ *
+ *      CVAL_STDC, CVAL_CXX
+ *
+ * The other set defines the specific version of C or C++ that is compiled -
+ * C90, C99, C11, C++03, C++11, C++14 or C++17, respectively defined by:
+ *
+ *      CVAL_C90, CVAL_C99, CVAL_C11, CVAL_C18
+ *      CVAL_CXX03, CVAL_CXX11, CVAL_CXX14, CVAL_CXX17
+ *
+ * Notes:
+ *      - C89 and C90 are the same language.
+ *      - C++03 is an amendment ("fix update") of C++98. It is treated
+ *        the same in SuperTest and named CXX03.
+ *      - The C language committee has published corrigenda of language
+ *        revisions. They are named after the 'base' revision.
+ *      - The C++ language committee does not publish corrigenda, yet
+ *        C++03 is commonly considered, by the market and by compiler
+ *        developers, as a corrigendum of C++98.
+ *
+ * The code below computes the correct setting of the macros from the
+ * macros defined by the language standards. This code can be overruled
+ * by setting the macros (one from each set) explicitly in the target
+ * file "cvaltarget.h"
+ */
+
+            /* If not one of CVAL_STDC and CVAL_CXX is set explictly, figure
+             * it out in the enclosed block.
+             */
+#ifndef CVAL_STDC
+#ifndef CVAL_CXX
+
+    #ifdef __cplusplus
+        #define CVAL_CXX    1
+    #else
+        #ifdef __STDC__
+            #define CVAL_STDC   1
+        #else
+            #error "Expected definition of one of __STDC__ or __cplusplus__ \
+    not found - Explictly define CVAL_STDC or CVAL_CXX in cvaltarget.h"
+        #endif
+    #endif
+
+#endif /* CVAL_CXX */
+#endif /* CVAL_STDC */
+
+
+    /* If not one of CVAL_C* specific version macros is set, figure it out
+     * in the enclosed block.
+     */
+#ifndef CVAL_C90
+#ifndef CVAL_C99
+#ifndef CVAL_C11
+#ifndef CVAL_C18
+#ifndef CVAL_CXX03
+#ifndef CVAL_CXX11
+#ifndef CVAL_CXX14
+#ifndef CVAL_CXX17
+
+    #ifdef CVAL_CXX
+        #if __cplusplus == 199711L
+            #define CVAL_CXX03  1
+        #elif __cplusplus == 201103L
+            #define CVAL_CXX11  1
+        #elif __cplusplus == 201402L
+            #define CVAL_CXX14  1
+        #elif __cplusplus == 201703L
+            #define CVAL_CXX17  1
+        #else
+            #error "__cplusplus version is not recognized, set one of: \
+CVAL_CXX03, CVAL_CXX11, CVAL_CXX14 or CVAL_CXX17 explicitly in cvaltarget.h"
+        #endif
+    #endif
+
+    #ifdef CVAL_STDC
+        #ifndef __STDC_VERSION__
+            #define CVAL_C90    1
+        #elif __STDC_VERSION__ == 199409L   /* C90:Corrigendum 1 */
+            #define CVAL_C90    1
+        #elif __STDC_VERSION__ == 199603L   /* C90:Corrigendum 2 */
+            #define CVAL_C90    1
+        #elif __STDC_VERSION__ == 199901L
+            #define CVAL_C99    1
+        #elif __STDC_VERSION__ == 201112L
+            #define CVAL_C11    1
+        #elif __STDC_VERSION__ == 201710L
+            #define CVAL_C18    1
+        #else
+            #error "__STDC_VERSION__ is not recognized, set one of: \
+CVAL_C90, CVAL_C99 or CVAL_C11 explicitly in cvaltarget.h"
+        #endif
+    #endif
+
+#endif /* CVAL_CXX17 */
+#endif /* CVAL_CXX14 */
+#endif /* CVAL_CXX11 */
+#endif /* CVAL_CXX03 */
+#endif /* CVAL_C18 */
+#endif /* CVAL_C11 */
+#endif /* CVAL_C99 */
+#endif /* CVAL_C90 */
+
+#ifndef CVAL_C99_ONWARD
+#ifndef CVAL_C11_ONWARD
+#ifndef CVAL_C18_ONWARD
+#ifndef CVAL_CXX11_ONWARD
+#ifndef CVAL_CXX14_ONWARD
+#ifndef CVAL_CXX17_ONWARD
+
+    #ifdef CVAL_STDC
+        #if   defined( CVAL_C18 )
+            #define CVAL_C99_ONWARD
+            #define CVAL_C11_ONWARD
+            #define CVAL_C18_ONWARD
+        #elif   defined( CVAL_C11 )
+            #define CVAL_C99_ONWARD
+            #define CVAL_C11_ONWARD
+        #elif defined( CVAL_C99 )
+            #define CVAL_C99_ONWARD
+        #endif
+    #endif
+
+    #ifdef CVAL_CXX
+        #if   defined( CVAL_CXX17 )
+            #define CVAL_CXX11_ONWARD
+            #define CVAL_CXX14_ONWARD
+            #define CVAL_CXX17_ONWARD
+        #elif defined( CVAL_CXX14 )
+            #define CVAL_CXX11_ONWARD
+            #define CVAL_CXX14_ONWARD
+        #elif defined( CVAL_CXX11 )
+            #define CVAL_CXX11_ONWARD
+        #endif
+    #endif
+
+#endif /* CVAL_C99_ONWARD */
+#endif /* CVAL_C11_ONWARD */
+#endif /* CVAL_C18_ONWARD */
+#endif /* CVAL_CXX11_ONWARD */
+#endif /* CVAL_CXX14_ONWARD */
+#endif /* CVAL_CXX17_ONWARD */
+
+/* Undefine CVAL_HAVE_COMPLEX on C90 and C++ compilers, since C complex types
+ * are only supported on C99 and later.
+ */
+#ifdef CVAL_HAVE_COMPLEX
+    #ifdef CVAL_C90
+        #undef CVAL_HAVE_COMPLEX
+    #endif /* CVAL_C90 */
+
+    #ifdef CVAL_CXX
+        #undef CVAL_HAVE_COMPLEX
+    #endif /* CVAL_CXX */
+#endif /* CVAL_HAVE_COMPLEX */
+
+/*************************************
+ *	Declaration of library functions
+ */
+
+void	CVAL_VERBOSE (int);
+void	CVAL_VERIFY_FUNC (int, const char *, int);
+void    CVAL_VERIFY_MINIFUNC (int cond);
+void	CVAL_ACTION_FUNC (const char *);
+void	CVAL_HEADER_FUNC (const char *);
+void	CVAL_SECTION_FUNC (const char *);
+void	CVAL_ENDSECTION_FUNC (void);
+void	CVAL_NOTEST_FUNC (void);
+void	CVAL_CASE_FUNC (int);
+void	CVAL_NOCASE_FUNC (void);
+
+void            cval_exit_func (int);
+void            cval_exit_nolib (int);  /* For tests with own main() */
+void		cval_anyeffect (void);
+
+int		cval_identity_int (int);
+unsigned int	cval_identity_uint (unsigned int);
+long		cval_identity_long (long);
+unsigned long	cval_identity_ulong (unsigned long);
+void		*cval_identity_pointer (void *);
+
+/* Compatibility: Preprocessor condition intended */
+#if defined( CVAL_C90 ) || \
+    defined( CVAL_CXX03 )
+        /* Empty Case */
+#else
+        /* Have long long */
+    long long	   cval_identity_longlong (long long);
+    unsigned long long cval_identity_ulonglong (unsigned long long);
+#endif
+
+#ifndef CVAL_NOFLOAT
+float		cval_identity_float (float x);
+double		cval_identity_double (double x);
+long double	cval_identity_ldouble (long double x);
+int		cval_float_approximates (double, double);
+int		cval_double_approximates (double, double);
+int		cval_ldouble_approximates (long double, long double);
+
+#ifdef CVAL_HAVE_COMPLEX
+float _Complex		cval_identity_fcmplx (float _Complex);
+double _Complex		cval_identity_cmplx (double _Complex);
+long double _Complex	cval_identity_lcmplx (long double _Complex);
+
+int		cval_fcmplx_approximates (float _Complex, float _Complex);
+int 		cval_cmplx_approximates (double _Complex, double _Complex);
+int 		cval_lcmplx_approximates (
+				long double _Complex, long double _Complex);
+#endif
+#endif
+
+#ifdef __DSPC__
+__fixed		cval_identity_fixed(__fixed x);
+long __fixed	cval_identity_lfixed(long __fixed x);
+__accum		cval_identity_accum(__accum x);
+long __accum	cval_identity_laccum(long __accum x);
+#endif
+
+#ifdef __EMBEDDEDC__
+signed short _Fract cval_identity_shr( signed short _Fract );
+signed short _Accum cval_identity_shk( signed short _Accum );
+signed _Fract cval_identity_sr( signed _Fract );
+signed _Accum cval_identity_sk( signed _Accum );
+signed long _Fract cval_identity_slr( signed long _Fract );
+signed long _Accum cval_identity_slk( signed long _Accum );
+unsigned short _Fract cval_identity_uhr( unsigned short _Fract );
+unsigned short _Accum cval_identity_uhk( unsigned short _Accum );
+unsigned _Fract cval_identity_ur( unsigned _Fract );
+unsigned _Accum cval_identity_uk( unsigned _Accum );
+unsigned long _Fract cval_identity_ulr( unsigned long _Fract );
+unsigned long _Accum cval_identity_ulk( unsigned long _Accum );
+#endif
+
+    /* Temporary solution for cval_put*: these should not be used in
+     * tests at all. This stuff is instrumentation for debugging, which
+     * tests should not have. Instead, fail of comment
+     */
+#ifdef COMPILING_CVAL_LIB
+    extern int	cval_put_string(const char *);
+    extern void	cval_put_decimal(long);
+    extern void	cval_put_hex(long);
+#else
+    #ifdef CVAL_YESDIAG
+        extern int	cval_put_string(const char *);
+        extern void	cval_put_decimal(long);
+        extern void	cval_put_hex(long);
+    #else
+        #define	cval_put_string(s)  0
+        #define	cval_put_decimal(l) /* Nothing here */
+        #define	cval_put_hex(l)     /* Nothing here */
+    #endif /* CVAL_YESDIAG */
+#endif /* COMPILING_CVAL_LIB */
+
+
+extern char*	cval_strcat (char *, const char *);
+extern void     cval_reverse (char *s);
+extern int	cval_strlen (const char *);
+extern void	cval_itoa (int, char *);
+extern char*	cval_strcpy (char *, const char *);
+extern char*    cval_strncpy (char *s1, const char *s2, int n);
+extern int	cval_strcmp (const char *, const char *);
+extern int      cval_strncmp (const char *s1, const char *s2, int n);
+extern int	cval_memcmp (const void *, const void *, int);
+extern void*	cval_memcpy (void *, const void *, int);
+extern void*	cval_memset (void *, int, int);
+extern void	cval_exit_nolib (int);
+
+#define cval_never()	cval_identity_int(0)
+#define cval_always()	cval_identity_int(1)
+
+#ifndef MAIN
+    #ifdef CVAL_YESDIAG
+            /* Create the entry TEST__MAIN that is called by the real
+             * main in report.o the supertest library stlib.a
+             */
+        void TEST__MAIN (void);
+        # define MAIN	void TEST__MAIN(void)
+    #else
+            /* Place the main() function inline in the test. So main
+             * from library is not used, linker should not include
+             * report.o
+             */
+        #define MAIN                    \
+            void TEST__MAIN (void);     \
+            int main (void) {           \
+                TEST__MAIN ();          \
+                cval_exit_func (0);     \
+                return 0;               \
+            }                           \
+            void TEST__MAIN (void)
+    #endif /* CVAL_YESDIAG */
+#endif
+
+#ifdef __cplusplus
+    }
+#endif /* __cplusplus */
+
+#endif /* CVAL_DEF_H */
diff --git a/testsuite/c_test/enhancec_test/lib/include/h/cvaltarget.h b/testsuite/c_test/enhancec_test/lib/include/h/cvaltarget.h
new file mode 100644
index 0000000000000000000000000000000000000000..85f25620ee7f610c6b7991d5136cac07839919fc
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/lib/include/h/cvaltarget.h
@@ -0,0 +1,165 @@
+/*
+ * Always included file that describes the implementation's data model.
+ */
+
+#ifndef CVAL_TARGET_H
+#define CVAL_TARGET_H
+
+/*
+ * SuperTest Usage configuration
+ */
+
+        /* Uncomment this #define to compile tests without the diagnostic
+         * library. It makes tests smaller and tests do not generate any
+         * output, which is useful on bare-metal targets. See also CVAL_EXIT()
+         * below.
+         */
+/* #define CVAL_SILENT_LIBRARY  */
+
+        /* Remove this #define when C complex types are not supported. For C90
+         * or C++ compilers, this macro will automatically be undefined, since
+         * C complex types are only supported by C99 and later versions of C.
+         */
+#define CVAL_HAVE_COMPLEX
+
+        /* If the compiler does not support floating point,
+         * this #define skips floating point support in the
+         * SuperTest diagnostic library. It does NOT automatically
+         * skip tests with floating point. To achieve that,
+         * subtract any or all of the predefined test sets
+         * float/double/longdouble in SETS/ in the test set
+         * definition.
+         */
+/* #define CVAL_NOFLOAT		*/
+
+        /* The SuperTest diagnostic library reads the arguments to the
+         * main() function called argc and argv. If they are inconsistent
+         * (happens rarely and only on embedded systems), this can be
+         * turned off by enabling the #define CVAL_NO_ARGC_ARGV.
+         */
+/* #define CVAL_NO_ARGC_ARGV	*/
+
+        /*
+         * Uncomment this define to use static arrays instead
+         * of dynamically allocated memory in the test suite
+         * "optimize/". This is useful if your target does
+         * not support dynamically allocated memory.
+         */
+/* #define CVAL_STATIC_MEMORY */
+
+/*
+ * SuperTest has a very small footprint. When CVAL_SILENT_LIBRARY
+ * is set, it only needs to return its exit value. It uses the
+ * macro CVAL_EXIT(x) to do this. This macro can be redefined here
+ * its default definition of 'exit(x)' is not correct.
+ *
+ * If CVAL_SILENT_LIBRARY is not defined (which is the default),
+ * then additionally the tests use CVAL_PUTCHAR(x) to print
+ * diagnostic output. It can be redefined here is 'putchar(x)'
+ * is not the right way to do this.
+ */
+#ifdef COMPILING_CVAL_LIB
+
+    #include <stdlib.h>
+    #define CVAL_EXIT(x)	exit(x)
+
+    #ifdef CVAL_SILENT_LIBRARY
+            /* No output needed for CVAL_SILENT_LIBRARY, no
+             * stdio.h included.
+             */
+        #define CVAL_PUTCHAR(x)	/* No output */
+    #else
+        #include <stdio.h>
+        #define CVAL_PUTCHAR(x)	putchar(x)
+    #endif
+
+#endif
+
+/*
+ * Target dependent values.
+ *
+ * These values must be adapted to the data-model of the target architecture.
+ * This default file target/cvaltarget.h in SuperTest is set to work for
+ * the common 32 and 64 bit data models. For many not-so mainstream
+ * processors, they may need to be modified.
+ * If these value are not set up to match the target, SuperTest will fail
+ * with an error "Null test failed", when testing "suite/FIRST/test0.c"
+ */
+
+#include <limits.h>     /* Only needed for INT_MAX==LONG_MAX compare */
+#if INT_MAX == LONG_MAX
+    #define CVAL_LONGSIZE       32      /* The size of a long in bits. */
+    #define CVAL_POINTERSIZE    32      /* The size of a void* in bits. */
+#else
+    #define CVAL_LONGSIZE       64      /* The size of a long in bits. */
+    #define CVAL_POINTERSIZE    64      /* The size of a void* in bits. */
+#endif
+
+#define CVAL_LONGLONGSIZE       64      /* The size of a long long in bits. */
+#define CVAL_INTSIZE            32      /* The size of an int in bits. */
+#define CVAL_SHORTSIZE          16      /* The size of a short in bits.     */
+#define CVAL_CHARSIZE           8       /* The size of a char in bits.      */
+#define CVAL_WCHARSIZE          32      /* The size of wchar_t in bits.     */
+
+/* #define ONECOMPL	*/		/* machine is one's complement */
+#define TWOCOMPL			/* machine is two's complement */
+
+/*
+ * IEEE-754 example values
+ */
+#define FLOAT_MANTISSA		24
+#define DOUBLE_MANTISSA		53
+
+/*
+ * Floating point absolute and relative precision for float and double.
+ */
+
+#ifdef CVAL_FP_IEEE
+/*
+ * These values should be attainable for IEEE-754.
+ * Accumulating errors in eg math functions might exceed the bounds.
+ * From considerations of quality, an attempt should be made to fix such
+ * math functions.
+ * Otherwise these values might be adapted.
+ */
+#define CVAL_A_FLOAT_PRECISION		5E-6
+#define CVAL_R_FLOAT_PRECISION		5E-7
+
+#define CVAL_A_DOUBLE_PRECISION		1E-14
+#define CVAL_R_DOUBLE_PRECISION		1E-15
+
+#define CVAL_A_LDOUBLE_PRECISION	1E-14
+#define CVAL_R_LDOUBLE_PRECISION	1E-15
+
+#else	/* ! CVAL_FP_IEEE */
+
+/*
+ * These are well within ISO-C minimum precision requirements for
+ * the accuracy of floating point representation.
+ */
+#define CVAL_A_FLOAT_PRECISION		5E-4
+#define CVAL_R_FLOAT_PRECISION		5E-5
+
+#define CVAL_A_DOUBLE_PRECISION		5E-8
+#define CVAL_R_DOUBLE_PRECISION		5E-9
+
+#define CVAL_A_LDOUBLE_PRECISION	5E-8
+#define CVAL_R_LDOUBLE_PRECISION	5E-9
+
+#endif	/* CVAL_FP_IEEE */
+
+/*
+ * The locale category LC_CTYPE affects the behavior of the
+ * character handling functions and the multibyte and wide
+ * character functions. To test UTF-16 and UTF-32 Unicode
+ * utilities (Section C11:7.28) a specific UTF-8 encoding
+ * locale should be set. The default locale "C" commonly
+ * does not provide UTF-8 and the existence of any other
+ * locale is user defined. In this case, the well-known
+ * "en_US.UTF-8" locale is selected, however, any other
+ * UTF-8 compliant locale would be also suitable.
+ */
+#define CVAL_LOCALE     "en_US.UTF-8"
+
+#endif	/* CVAL_TARGET_H */
+
diff --git a/testsuite/c_test/enhancec_test/lib/include/h/def.h b/testsuite/c_test/enhancec_test/lib/include/h/def.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e2f8c284218999553a56b711bcf7de4a98c1c5d
--- /dev/null
+++ b/testsuite/c_test/enhancec_test/lib/include/h/def.h
@@ -0,0 +1,481 @@
+/*
+ *
+ * COPYRIGHT NOTICE (NOT TO BE REMOVED):
+ *
+ * This file, or parts of it, or modified versions of it, may not be copied,
+ * reproduced or transmitted in any form, including reprinting, translation,
+ * photocopying or microfilming, or by any means, electronic, mechanical or
+ * otherwise, or stored in a retrieval system, or used for any purpose, without
+ * the prior written permission of all Owners unless it is explicitly marked as
+ * having Classification `Public'.
+ *
+ * Owners of this file give notice:
+ *   (c) Copyright 2015-2019 by Solid Sands B.V.,
+ *       Amsterdam, the Netherlands. All rights reserved.
+ *   (c) Copyright 1996-2012 ACE Associated Compiler Experts bv
+ *   (c) Copyright 1995-2012 ACE Associated Computer Experts bv
+ * All rights, including copyrights, reserved.
+ *
+ * This file contains or may contain restricted information and is UNPUBLISHED
+ * PROPRIETARY SOURCE CODE OF THE Owners.  The Copyright Notice(s) above do not
+ * evidence any actual or intended publication of such source code.  This file
+ * is additionally subject to the conditions listed in the RESTRICTIONS file
+ * and is with NO WARRANTY.
+ *
+ * END OF COPYRIGHT NOTICE
+ */
+
+#ifndef CVAL_DEF_H
+#define CVAL_DEF_H
+
+#ifdef __cplusplus
+    extern "C" {
+#endif
+
+#include <limits.h>
+
+#include "cvaltarget.h"
+
+/********************************
+ * The following section define SuperTest specific macros used by the
+ * tests or by the diagnostic library. They are protected by #ifdefs, so
+ * that they can be overruled easily in the cvaltarget.h file.
+ */
+
+#ifndef CVAL_A_LDOUBLE_PRECISION
+#define CVAL_A_LDOUBLE_PRECISION CVAL_A_DOUBLE_PRECISION
+#endif
+
+#ifndef CVAL_R_LDOUBLE_PRECISION
+#define CVAL_R_LDOUBLE_PRECISION CVAL_R_DOUBLE_PRECISION
+#endif
+
+/*
+ *	This file does not (and should not) #include standard headers.
+ *	If testfiles need them, they should include them.
+ */
+
+#ifdef CVAL_SILENT_LIBRARY
+        /* Just shorthands */
+    #define CVAL_NODIAG
+#else
+    #define CVAL_YESDIAG
+#endif /* CVAL_SILENT_LIBRARY */
+
+#ifndef CVAL_HEADER
+    #ifdef CVAL_YESDIAG
+        #define CVAL_HEADER(s)		CVAL_HEADER_FUNC(s)
+    #else
+        #define CVAL_HEADER(s)          /* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_SECTION
+    #ifdef CVAL_YESDIAG
+        #define CVAL_SECTION(s)		CVAL_SECTION_FUNC(s)
+    #else
+        #define CVAL_SECTION(s)		/* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_ENDSECTION
+    #ifdef CVAL_YESDIAG
+        #define CVAL_ENDSECTION()	CVAL_ENDSECTION_FUNC()
+    #else
+        #define CVAL_ENDSECTION()	/* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_ACTION
+    #ifdef CVAL_YESDIAG
+        #define CVAL_ACTION(s)		CVAL_ACTION_FUNC(s)
+    #else
+        #define CVAL_ACTION(s)
+    #endif
+#endif
+
+#ifndef CVAL_DOTEST
+    #ifdef CVAL_YESDIAG
+        #define CVAL_DOTEST(do_str)	CVAL_ACTION (#do_str); do_str;
+    #else
+        #define CVAL_DOTEST(do_str)     do_str;
+    #endif
+#endif
+
+#ifndef CVAL_NOTEST
+    #ifdef CVAL_YESDIAG
+        #define CVAL_NOTEST()		CVAL_NOTEST_FUNC()
+    #else
+        #define CVAL_NOTEST()           /* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_CASE
+    #ifdef CVAL_YESDIAG
+        #define CVAL_CASE(c)		CVAL_CASE_FUNC(c)
+    #else
+        #define CVAL_CASE(c)            (void)(c);
+    #endif
+#endif
+
+#ifndef CVAL_NOCASE
+    #ifdef CVAL_YESDIAG
+        #define CVAL_NOCASE()		CVAL_NOCASE_FUNC()
+    #else
+        #define CVAL_NOCASE()           /* Nothing here */
+    #endif
+#endif
+
+#ifndef CVAL_RFLAG
+#define CVAL_RFLAG	1
+#endif
+
+#ifndef CVAL_VFLAG
+#define CVAL_VFLAG	1
+#endif
+
+#ifndef CVAL_VERIFY
+    #ifdef CVAL_NODIAG
+            /* Use a library call because CVAL_EXIT is not
+             * available here, and is available in library.
+             */
+        #define CVAL_VERIFY(cond)   CVAL_VERIFY_MINIFUNC(cond)
+    #endif /* CVAL_NODIAG */
+#endif /* CVAL_VERIFY */
+
+#ifndef CVAL_VERIFY
+    #define CVAL_VERIFY(be)	CVAL_VERIFY_FUNC(be, #be, __LINE__)
+#endif /* CVAL_VERIFY */
+
+
+#define CVAL_ARRAY_COUNT(x)	(sizeof(x) / sizeof(x[0]))
+
+/*
+ *	For backwards compatibility.
+ */
+#define do_exit(eval)   (cval_exit_func(eval))
+#define CVAL_CONST	const
+
+#ifndef NULLCHAR
+    #define NULLCHAR	'\0'
+#endif /* NULLCHAR */
+
+/*
+ * The following is used to check floating point against some other value
+ * with a predefined precision.
+ */
+#ifndef CVAL_FC
+#define CVAL_FC(f, val) cval_float_approximates((f), (val))
+#endif
+#ifndef CVAL_DC
+#define CVAL_DC(f, val) cval_double_approximates((f), (val))
+#endif
+#ifndef CVAL_QC
+#define CVAL_QC(f, val) cval_ldouble_approximates((f), (val))
+#endif
+
+/******************************************
+ * The following section defines SuperTest specific macros to identify
+ * the C or C++ version of the compiler. This is done to make it easier
+ * to write version specific code in tests. (The macros defined by the
+ * language standard are harder to memorize and not so orthogonal.)
+ *
+ * Two sets of macros exists, and from each set EXACTLY ONE macro must
+ * be defined. The first set defines the current language that is compiled,
+ * C or C++. It respectively contains the macros:
+ *
+ *      CVAL_STDC, CVAL_CXX
+ *
+ * The other set defines the specific version of C or C++ that is compiled -
+ * C90, C99, C11, C++03, C++11, C++14 or C++17, respectively defined by:
+ *
+ *      CVAL_C90, CVAL_C99, CVAL_C11, CVAL_C18
+ *      CVAL_CXX03, CVAL_CXX11, CVAL_CXX14, CVAL_CXX17
+ *
+ * Notes:
+ *      - C89 and C90 are the same language.
+ *      - C++03 is an amendment ("fix update") of C++98. It is treated
+ *        the same in SuperTest and named CXX03.
+ *      - The C language committee has published corrigenda of language
+ *        revisions. They are named after the 'base' revision.
+ *      - The C++ language committee does not publish corrigenda, yet
+ *        C++03 is commonly considered, by the market and by compiler
+ *        developers, as a corrigendum of C++98.
+ *
+ * The code below computes the correct setting of the macros from the
+ * macros defined by the language standards. This code can be overruled
+ * by setting the macros (one from each set) explicitly in the target
+ * file "cvaltarget.h"
+ */
+
+            /* If not one of CVAL_STDC and CVAL_CXX is set explictly, figure
+             * it out in the enclosed block.
+             */
+#ifndef CVAL_STDC
+#ifndef CVAL_CXX
+
+    #ifdef __cplusplus
+        #define CVAL_CXX    1
+    #else
+        #ifdef __STDC__
+            #define CVAL_STDC   1
+        #else
+            #error "Expected definition of one of __STDC__ or __cplusplus__ \
+    not found - Explictly define CVAL_STDC or CVAL_CXX in cvaltarget.h"
+        #endif
+    #endif
+
+#endif /* CVAL_CXX */
+#endif /* CVAL_STDC */
+
+
+    /* If not one of CVAL_C* specific version macros is set, figure it out
+     * in the enclosed block.
+     */
+#ifndef CVAL_C90
+#ifndef CVAL_C99
+#ifndef CVAL_C11
+#ifndef CVAL_C18
+#ifndef CVAL_CXX03
+#ifndef CVAL_CXX11
+#ifndef CVAL_CXX14
+#ifndef CVAL_CXX17
+
+    #ifdef CVAL_CXX
+        #if __cplusplus == 199711L
+            #define CVAL_CXX03  1
+        #elif __cplusplus == 201103L
+            #define CVAL_CXX11  1
+        #elif __cplusplus == 201402L
+            #define CVAL_CXX14  1
+        #elif __cplusplus == 201703L
+            #define CVAL_CXX17  1
+        #else
+            #error "__cplusplus version is not recognized, set one of: \
+CVAL_CXX03, CVAL_CXX11, CVAL_CXX14 or CVAL_CXX17 explicitly in cvaltarget.h"
+        #endif
+    #endif
+
+    #ifdef CVAL_STDC
+        #ifndef __STDC_VERSION__
+            #define CVAL_C90    1
+        #elif __STDC_VERSION__ == 199409L   /* C90:Corrigendum 1 */
+            #define CVAL_C90    1
+        #elif __STDC_VERSION__ == 199603L   /* C90:Corrigendum 2 */
+            #define CVAL_C90    1
+        #elif __STDC_VERSION__ == 199901L
+            #define CVAL_C99    1
+        #elif __STDC_VERSION__ == 201112L
+            #define CVAL_C11    1
+        #elif __STDC_VERSION__ == 201710L
+            #define CVAL_C18    1
+        #else
+            #error "__STDC_VERSION__ is not recognized, set one of: \
+CVAL_C90, CVAL_C99 or CVAL_C11 explicitly in cvaltarget.h"
+        #endif
+    #endif
+
+#endif /* CVAL_CXX17 */
+#endif /* CVAL_CXX14 */
+#endif /* CVAL_CXX11 */
+#endif /* CVAL_CXX03 */
+#endif /* CVAL_C18 */
+#endif /* CVAL_C11 */
+#endif /* CVAL_C99 */
+#endif /* CVAL_C90 */
+
+#ifndef CVAL_C99_ONWARD
+#ifndef CVAL_C11_ONWARD
+#ifndef CVAL_C18_ONWARD
+#ifndef CVAL_CXX11_ONWARD
+#ifndef CVAL_CXX14_ONWARD
+#ifndef CVAL_CXX17_ONWARD
+
+    #ifdef CVAL_STDC
+        #if   defined( CVAL_C18 )
+            #define CVAL_C99_ONWARD
+            #define CVAL_C11_ONWARD
+            #define CVAL_C18_ONWARD
+        #elif   defined( CVAL_C11 )
+            #define CVAL_C99_ONWARD
+            #define CVAL_C11_ONWARD
+        #elif defined( CVAL_C99 )
+            #define CVAL_C99_ONWARD
+        #endif
+    #endif
+
+    #ifdef CVAL_CXX
+        #if   defined( CVAL_CXX17 )
+            #define CVAL_CXX11_ONWARD
+            #define CVAL_CXX14_ONWARD
+            #define CVAL_CXX17_ONWARD
+        #elif defined( CVAL_CXX14 )
+            #define CVAL_CXX11_ONWARD
+            #define CVAL_CXX14_ONWARD
+        #elif defined( CVAL_CXX11 )
+            #define CVAL_CXX11_ONWARD
+        #endif
+    #endif
+
+#endif /* CVAL_C99_ONWARD */
+#endif /* CVAL_C11_ONWARD */
+#endif /* CVAL_C18_ONWARD */
+#endif /* CVAL_CXX11_ONWARD */
+#endif /* CVAL_CXX14_ONWARD */
+#endif /* CVAL_CXX17_ONWARD */
+
+/* Undefine CVAL_HAVE_COMPLEX on C90 and C++ compilers, since C complex types
+ * are only supported on C99 and later.
+ */
+#ifdef CVAL_HAVE_COMPLEX
+    #ifdef CVAL_C90
+        #undef CVAL_HAVE_COMPLEX
+    #endif /* CVAL_C90 */
+
+    #ifdef CVAL_CXX
+        #undef CVAL_HAVE_COMPLEX
+    #endif /* CVAL_CXX */
+#endif /* CVAL_HAVE_COMPLEX */
+
+/*************************************
+ *	Declaration of library functions
+ */
+
+void	CVAL_VERBOSE (int);
+void	CVAL_VERIFY_FUNC (int, const char *, int);
+void    CVAL_VERIFY_MINIFUNC (int cond);
+void	CVAL_ACTION_FUNC (const char *);
+void	CVAL_HEADER_FUNC (const char *);
+void	CVAL_SECTION_FUNC (const char *);
+void	CVAL_ENDSECTION_FUNC (void);
+void	CVAL_NOTEST_FUNC (void);
+void	CVAL_CASE_FUNC (int);
+void	CVAL_NOCASE_FUNC (void);
+
+void            cval_exit_func (int);
+void            cval_exit_nolib (int);  /* For tests with own main() */
+void		cval_anyeffect (void);
+
+int		cval_identity_int (int);
+unsigned int	cval_identity_uint (unsigned int);
+long		cval_identity_long (long);
+unsigned long	cval_identity_ulong (unsigned long);
+void		*cval_identity_pointer (void *);
+
+/* Compatibility: Preprocessor condition intended */
+#if defined( CVAL_C90 ) || \
+    defined( CVAL_CXX03 )
+        /* Empty Case */
+#else
+        /* Have long long */
+    long long	   cval_identity_longlong (long long);
+    unsigned long long cval_identity_ulonglong (unsigned long long);
+#endif
+
+#ifndef CVAL_NOFLOAT
+float		cval_identity_float (float x);
+double		cval_identity_double (double x);
+long double	cval_identity_ldouble (long double x);
+int		cval_float_approximates (double, double);
+int		cval_double_approximates (double, double);
+int		cval_ldouble_approximates (long double, long double);
+
+#ifdef CVAL_HAVE_COMPLEX
+float _Complex		cval_identity_fcmplx (float _Complex);
+double _Complex		cval_identity_cmplx (double _Complex);
+long double _Complex	cval_identity_lcmplx (long double _Complex);
+
+int		cval_fcmplx_approximates (float _Complex, float _Complex);
+int 		cval_cmplx_approximates (double _Complex, double _Complex);
+int 		cval_lcmplx_approximates (
+				long double _Complex, long double _Complex);
+#endif
+#endif
+
+#ifdef __DSPC__
+__fixed		cval_identity_fixed(__fixed x);
+long __fixed	cval_identity_lfixed(long __fixed x);
+__accum		cval_identity_accum(__accum x);
+long __accum	cval_identity_laccum(long __accum x);
+#endif
+
+#ifdef __EMBEDDEDC__
+signed short _Fract cval_identity_shr( signed short _Fract );
+signed short _Accum cval_identity_shk( signed short _Accum );
+signed _Fract cval_identity_sr( signed _Fract );
+signed _Accum cval_identity_sk( signed _Accum );
+signed long _Fract cval_identity_slr( signed long _Fract );
+signed long _Accum cval_identity_slk( signed long _Accum );
+unsigned short _Fract cval_identity_uhr( unsigned short _Fract );
+unsigned short _Accum cval_identity_uhk( unsigned short _Accum );
+unsigned _Fract cval_identity_ur( unsigned _Fract );
+unsigned _Accum cval_identity_uk( unsigned _Accum );
+unsigned long _Fract cval_identity_ulr( unsigned long _Fract );
+unsigned long _Accum cval_identity_ulk( unsigned long _Accum );
+#endif
+
+    /* Temporary solution for cval_put*: these should not be used in
+     * tests at all. This stuff is instrumentation for debugging, which
+     * tests should not have. Instead, fail of comment
+     */
+#ifdef COMPILING_CVAL_LIB
+    extern int	cval_put_string(const char *);
+    extern void	cval_put_decimal(long);
+    extern void	cval_put_hex(long);
+#else
+    #ifdef CVAL_YESDIAG
+        extern int	cval_put_string(const char *);
+        extern void	cval_put_decimal(long);
+        extern void	cval_put_hex(long);
+    #else
+        #define	cval_put_string(s)  0
+        #define	cval_put_decimal(l) /* Nothing here */
+        #define	cval_put_hex(l)     /* Nothing here */
+    #endif /* CVAL_YESDIAG */
+#endif /* COMPILING_CVAL_LIB */
+
+
+extern char*	cval_strcat (char *, const char *);
+extern void     cval_reverse (char *s);
+extern int	cval_strlen (const char *);
+extern void	cval_itoa (int, char *);
+extern char*	cval_strcpy (char *, const char *);
+extern char*    cval_strncpy (char *s1, const char *s2, int n);
+extern int	cval_strcmp (const char *, const char *);
+extern int      cval_strncmp (const char *s1, const char *s2, int n);
+extern int	cval_memcmp (const void *, const void *, int);
+extern void*	cval_memcpy (void *, const void *, int);
+extern void*	cval_memset (void *, int, int);
+extern void	cval_exit_nolib (int);
+
+#define cval_never()	cval_identity_int(0)
+#define cval_always()	cval_identity_int(1)
+
+#ifndef MAIN
+    #ifdef CVAL_YESDIAG
+            /* Create the entry TEST__MAIN that is called by the real
+             * main in report.o the supertest library stlib.a
+             */
+        void TEST__MAIN (void);
+        # define MAIN	void TEST__MAIN(void)
+    #else
+            /* Place the main() function inline in the test. So main
+             * from library is not used, linker should not include
+             * report.o
+             */
+        #define MAIN                    \
+            void TEST__MAIN (void);     \
+            int main (void) {           \
+                TEST__MAIN ();          \
+                cval_exit_func (0);     \
+                return 0;               \
+            }                           \
+            void TEST__MAIN (void)
+    #endif /* CVAL_YESDIAG */
+#endif
+
+#ifdef __cplusplus
+    }
+#endif /* __cplusplus */
+
+#endif /* CVAL_DEF_H */
diff --git a/testsuite/c_test/enhancec_test/lib/include/libst.a b/testsuite/c_test/enhancec_test/lib/include/libst.a
new file mode 100644
index 0000000000000000000000000000000000000000..86d7eb8c6e19117df6fa4596e8d3eb1e2da68d8b
Binary files /dev/null and b/testsuite/c_test/enhancec_test/lib/include/libst.a differ
diff --git a/testsuite/c_test/lib/c/libst.a b/testsuite/c_test/lib/c/libst.a
new file mode 100644
index 0000000000000000000000000000000000000000..7e249ce329a0c56d9c3746f4be2057c376f86687
Binary files /dev/null and b/testsuite/c_test/lib/c/libst.a differ
diff --git a/testsuite/c_test/noinline_test/NOINLINE0001-vrp-noinline-longmax-check/expected.txt b/testsuite/c_test/noinline_test/NOINLINE0001-vrp-noinline-longmax-check/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/noinline_test/NOINLINE0001-vrp-noinline-longmax-check/test.cfg b/testsuite/c_test/noinline_test/NOINLINE0001-vrp-noinline-longmax-check/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..afedc065504897039cf062d6dcc3d61249cf3d0d
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0001-vrp-noinline-longmax-check/test.cfg
@@ -0,0 +1,5 @@
+${OUT_ROOT}/tools/bin/clang -emit-ast --target=aarch64 -U __SIZEOF_INT128__ -isystem ${OUT_ROOT}/aarch64-clang-release/lib/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include -isystem ../lib/include -o vrp_longmax_check.ast  vrp_longmax_check.c
+${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl  vrp_longmax_check.ast -o vrp_longmax_check.mpl
+${OUT_ROOT}/aarch64-clang-release/bin/maple --run=me:mpl2mpl:mplcg --option="--O2 --quiet:--no-inline --O2 --quiet: --O2 --fpic --quiet --no-pie --verbose-asm" vrp_longmax_check.mpl
+${OUT_ROOT}/tools/bin/aarch64-linux-gnu-gcc  -o vrp_longmax_check.out  vrp_longmax_check.s -lm
+run(vrp_longmax_check)
diff --git a/testsuite/c_test/noinline_test/NOINLINE0001-vrp-noinline-longmax-check/vrp_longmax_check.c b/testsuite/c_test/noinline_test/NOINLINE0001-vrp-noinline-longmax-check/vrp_longmax_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..8055d2ea68882ae376726e0b19406b768726375b
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0001-vrp-noinline-longmax-check/vrp_longmax_check.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <limits.h>
+
+extern void abort (void);
+
+void testl (unsigned long l, int ok)
+{
+  if ((l>=1) && (l<=LONG_MAX))
+  {
+    if (!ok) abort ();
+  }
+  else {
+    if (ok) abort ();
+ }
+}
+
+int main ()
+{
+  testl (LONG_MAX+1UL, 0);
+  testl (ULONG_MAX, 0);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/noinline_test/NOINLINE0002-ipa-noinlne-proptype-check/expected.txt b/testsuite/c_test/noinline_test/NOINLINE0002-ipa-noinlne-proptype-check/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/noinline_test/NOINLINE0002-ipa-noinlne-proptype-check/nonull_test.c b/testsuite/c_test/noinline_test/NOINLINE0002-ipa-noinlne-proptype-check/nonull_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..b61be33c8001643da78e3108e8256e5e0268f7a1
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0002-ipa-noinlne-proptype-check/nonull_test.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((returns_nonnull, nonnull))
+int *testReturnPtr(int *ptr) {
+  for (int i = 0; i < 10; ++i) {
+    *ptr += i;
+  }
+  return ptr;
+}
+
+__attribute__((returns_nonnull))
+extern int *getNonnullPtr();
+
+int* testy() {
+  int *p =  getNonnullPtr();
+  return testReturnPtr(p);
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/noinline_test/NOINLINE0002-ipa-noinlne-proptype-check/test.cfg b/testsuite/c_test/noinline_test/NOINLINE0002-ipa-noinlne-proptype-check/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..532676f161576047345330680bd0ef5856b385c8
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0002-ipa-noinlne-proptype-check/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_N_D_NO_LINK:
+compile(nonull_test)
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="callassertnonnull"  --result=nonull_test.me.mpl
diff --git a/testsuite/c_test/noinline_test/NOINLINE0003-ipa-noinlne-proptype-check/expected.txt b/testsuite/c_test/noinline_test/NOINLINE0003-ipa-noinlne-proptype-check/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/noinline_test/NOINLINE0003-ipa-noinlne-proptype-check/nonull_test.c b/testsuite/c_test/noinline_test/NOINLINE0003-ipa-noinlne-proptype-check/nonull_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..f861f11f4eb487ea8f77f2e49b651fb4a2245f6b
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0003-ipa-noinlne-proptype-check/nonull_test.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__((returns_nonnull, nonnull))
+int *testReturnPtr(int *ptr) {
+  for (int i = 0; i < 10; ++i) {
+    *ptr += i;
+  }
+  return ptr;
+}
+
+int* test(int x) {
+  int *p;
+  if (x > 3) {
+    p = testReturnPtr(p);
+    return p;
+  } else {
+    int *q;
+    q = testReturnPtr(p);
+    return q;
+  }
+}
+int* test1(int x) {
+  int *p;
+  if (x > 3) {
+    p = testReturnPtr(p);
+    return p;
+  } else {
+    int *q;
+    q = malloc(sizeof(int) * 10);
+    return q;
+  }
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/noinline_test/NOINLINE0003-ipa-noinlne-proptype-check/test.cfg b/testsuite/c_test/noinline_test/NOINLINE0003-ipa-noinlne-proptype-check/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0b0f421c31616caf9cafd6109b0d6108c100b012
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0003-ipa-noinlne-proptype-check/test.cfg
@@ -0,0 +1,3 @@
+ENCO2_N_D_NO_LINK:
+compile(nonull_test)
+python3 ${TEST_BIN}/check.py --check=num  --n=3 --str="callassertnonnull"  --result=nonull_test.me.mpl
diff --git a/testsuite/c_test/noinline_test/NOINLINE0004-ipa-noinlne-proptype-check/call_sideeffect.c b/testsuite/c_test/noinline_test/NOINLINE0004-ipa-noinlne-proptype-check/call_sideeffect.c
new file mode 100644
index 0000000000000000000000000000000000000000..7430623ecaa4c01ce3c9bcdaa47066fba9470fce
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0004-ipa-noinlne-proptype-check/call_sideeffect.c
@@ -0,0 +1,25 @@
+int bar(int *y);
+
+__attribute__((noinline))
+int foo(int *x, int z) {
+  int y = 10;
+  int *p;
+  if (z > 0) {
+    p = x;
+  } else {
+    p = &y;
+  }
+  int w = bar(p);
+  return *p + *x;
+}
+
+__attribute__((noinline))
+int bar(int *y) {
+  return 1;
+}
+
+__attribute__((noinline))
+int call() {
+  int *p = 0;
+  return foo(p, 10);
+}
diff --git a/testsuite/c_test/noinline_test/NOINLINE0004-ipa-noinlne-proptype-check/test.cfg b/testsuite/c_test/noinline_test/NOINLINE0004-ipa-noinlne-proptype-check/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0519cbd7e35eab940425d22f61e9358489e1a357
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0004-ipa-noinlne-proptype-check/test.cfg
@@ -0,0 +1,7 @@
+${OUT_ROOT}/tools/bin/clang -emit-ast --target=aarch64 -U __SIZEOF_INT128__ -DC_ENHANCED -isystem ${OUT_ROOT}/aarch64-clang-release/lib/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include -isystem ../lib/include -o call_sideeffect.ast  call_sideeffect.c
+
+${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl -npe-check-dynamic call_sideeffect.ast -o call_sideeffect.mpl
+
+${OUT_ROOT}/aarch64-clang-release/bin/maple --run=me:mpl2mpl:mplcg --option="-O2 --quiet:-O2 --skip-phase=inline:-O2 --fpic --quiet" --save-temps --npe-check-dynamic --infile call_sideeffect.mpl
+
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="callassertnonnull"  --result=call_sideeffect.me.mpl
diff --git a/testsuite/c_test/noinline_test/NOINLINE0005-ipa-noinlne-clone-check/test.cfg b/testsuite/c_test/noinline_test/NOINLINE0005-ipa-noinlne-clone-check/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..17964e6335ecf03dcb2896f9a801195e315d4f51
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0005-ipa-noinlne-clone-check/test.cfg
@@ -0,0 +1,8 @@
+${OUT_ROOT}/tools/bin/clang -emit-ast --target=aarch64 -U __SIZEOF_INT128__ -DC_ENHANCED -isystem ${OUT_ROOT}/aarch64-clang-release/lib/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include -isystem ../lib/include -o test_clone.ast  test_clone.c
+
+${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl test_clone.ast -o test_clone.mpl
+
+${OUT_ROOT}/aarch64-clang-release/bin/maple --run=me:mpl2mpl:mplcg --option="-O2 --quiet:-O2 --skip-phase=inline --ipa-clone:-O2 --fpic --quiet" --save-temps --infile test_clone.mpl
+
+python3 ${TEST_BIN}/check.py --check=num  --n=6 --str="func &add.clone"  --result=test_clone.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=2 --str="func &sub.constprop"  --result=test_clone.me.mpl
diff --git a/testsuite/c_test/noinline_test/NOINLINE0005-ipa-noinlne-clone-check/test_clone.c b/testsuite/c_test/noinline_test/NOINLINE0005-ipa-noinlne-clone-check/test_clone.c
new file mode 100644
index 0000000000000000000000000000000000000000..f5695a61d6e3b65175c456872753d9d1d1d877be
--- /dev/null
+++ b/testsuite/c_test/noinline_test/NOINLINE0005-ipa-noinlne-clone-check/test_clone.c
@@ -0,0 +1,54 @@
+__attribute__((noinline))
+int add(int x, int y) {
+  int res = 4;
+  if (y > 4) {
+    res +=10;
+  }
+  if (y > 7)
+    return res - y + x;
+  else
+    return res - y - x;
+}
+
+__attribute__((noinline))
+int zbh(int x) {
+  int res = 0;
+  for (int i = 0; i < x; i++) {
+    res += add(x, 13);
+    if (res > 100) {
+      res += add(x, 14);
+    }
+  }
+  return res;
+}
+
+int main(int argc , char *argv[]) {
+  int x = 10 + add(11, 3);
+  return add(argc + x, 5) + sub(1) + add(x, 6) + sub(1) + foo(0);
+}
+
+__attribute__((noinline))
+int sub(int x) {
+  return 10 - add(x, 2);
+}
+
+
+__attribute__((noinline))
+int testHello(int x) {
+  int res;
+  while (x > 0) {
+    if (x < 10)
+      res += sub(1);
+  }
+  return res;
+}
+
+__attribute__((noinline))
+int foo(int *p) {
+  if (p > 0) {
+    if (p < 100) {
+      return *p + sub(1);
+    }
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0001-addr/addr.c b/testsuite/c_test/sanity_test/SANITY0001-addr/addr.c
new file mode 100644
index 0000000000000000000000000000000000000000..1e0281a16f456474f3638644f422a077bcf4ba10
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0001-addr/addr.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int deref(int *iptr) {
+  return *iptr;
+}
+
+int deref1(int *iptr) {
+  int j = 8;
+  j = *iptr + j;
+  return j;
+}
+
+int addrof(int *iptr) {
+  int j = 8;
+  int *jptr = &j;
+  *jptr = *iptr;
+  return *jptr;
+}
+
+int main()
+{
+  int v = 5;
+  int *vptr = &v;
+
+  if (*vptr != 5) {
+    abort();
+  }
+  if (deref(&v) != 5) {
+    abort();
+  }
+  if (deref1(&v) != 13) {
+    abort();
+  }
+  if (addrof(&v) != 5) {
+    abort();
+  }
+}
+
diff --git a/testsuite/c_test/sanity_test/SANITY0001-addr/expected.txt b/testsuite/c_test/sanity_test/SANITY0001-addr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0001-addr/test.cfg b/testsuite/c_test/sanity_test/SANITY0001-addr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..573f31bc8ee77d7eeb6c8da18f92049e6d24a0fb
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0001-addr/test.cfg
@@ -0,0 +1,2 @@
+compile(addr)
+run(addr)
diff --git a/testsuite/c_test/sanity_test/SANITY0002-argc/argc.c b/testsuite/c_test/sanity_test/SANITY0002-argc/argc.c
new file mode 100644
index 0000000000000000000000000000000000000000..2358a1da299fc3197592af44374d8cbea5d88707
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0002-argc/argc.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+  int i = 1;
+  if (i > argc) {
+    abort();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0002-argc/expected.txt b/testsuite/c_test/sanity_test/SANITY0002-argc/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0002-argc/test.cfg b/testsuite/c_test/sanity_test/SANITY0002-argc/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9673b656b1ad41d4fc5da1de50881daf63054a90
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0002-argc/test.cfg
@@ -0,0 +1,2 @@
+compile(argc)
+run(argc)
diff --git a/testsuite/c_test/sanity_test/SANITY0003-array_single/array_single.c b/testsuite/c_test/sanity_test/SANITY0003-array_single/array_single.c
new file mode 100644
index 0000000000000000000000000000000000000000..22c881cddefb5e4cfddcf11a505305631cf2659e
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0003-array_single/array_single.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int A[5];
+int foo(int i) {
+  A[3] = i + A[2];
+  return A[(i >= 0 && i < 5) ? i : 0];
+}
+
+float B[15];
+float bar(int i) {
+  B[3] = i + B[2];
+  return B[(i >= 0 && i < 5) ? i : 0];
+}
+
+// variable array type
+void vararr(int sz) {
+  int my[sz];
+  int i;
+  for (i = 0; i < sz; ++i) {
+    my[i] = i;
+  }
+  for (i = 0; i < sz; ++i) {
+    if (my[i] != i) {
+      abort();
+    }
+  }
+}
+
+int main()
+{
+  vararr(4);
+
+  A[0] = 0;
+  A[2] = A[3] = 2;
+  if (A[3] != 2) {
+    abort();
+  }
+  if (foo(2) != 2) {
+    abort();
+  }
+  if (A[3] != 4) {
+    abort();
+  }
+  if (foo(5) != 0) {
+    abort();
+  }
+  if (A[3] != 7) {
+    abort();
+  }
+
+  B[0] = 0;
+  B[1] = B[2] = B[3] = 3;
+  if (B[3] != 3) {
+    abort();
+  }
+  if (bar(1) != 3) {
+    abort();
+  }
+  if (B[3] != 4) {
+    abort();
+  }
+  if (bar(5) != 0) {
+    abort();
+  }
+  if (B[3] != 8) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0003-array_single/expected.txt b/testsuite/c_test/sanity_test/SANITY0003-array_single/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0003-array_single/test.cfg b/testsuite/c_test/sanity_test/SANITY0003-array_single/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6b50234de9837648015319d07d3ee0d0e9840d58
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0003-array_single/test.cfg
@@ -0,0 +1,2 @@
+compile(array_single)
+run(array_single)
diff --git a/testsuite/c_test/sanity_test/SANITY0004-binop/binop.c b/testsuite/c_test/sanity_test/SANITY0004-binop/binop.c
new file mode 100644
index 0000000000000000000000000000000000000000..733be02b68f2a7772f5decac6204c75f079fdbf8
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0004-binop/binop.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int a = 0x80000001;
+unsigned int ua = 0x00000002;
+unsigned int val = 0xffffff84;
+
+int main()
+{
+  int c = a;
+
+  c += a | 0;
+  c += a & 1;
+  c += a ^ 0;
+  c += a >> 0;
+  c += a << 0;
+
+  c += a | 1;
+  c += a & 5;
+  c += a ^ 1;
+  c += a >> 1;
+  c += a << 1;
+
+  c += a | 0x7ff;
+  c += a & 0x7ff;
+  c += a ^ 0x7ff;
+  c += a >> 16;
+  c += a << 16;
+
+  c += a | 0xfff;
+  c += a & 0xfff;
+  c += a ^ 0xfff;
+  c += a >> 24;
+  c += a << 24;
+
+  c += a | 0xffff;
+  c += a & 0xffff;
+  c += a ^ 0xffff;
+  c += a >> 31;
+  c += a << 31;
+
+  unsigned int u = ua;
+  u += ua >> 0;
+  u += ua >> 1;
+  u += ua >> 16;
+  u += a >> 24;
+  u += a >> 31;
+
+  if (c != 0xc102af83) {
+    abort();
+  }
+  if (u != 0xffffff84) {
+    abort();
+  }
+  if (u != val) {
+    abort();
+  }
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0004-binop/expected.txt b/testsuite/c_test/sanity_test/SANITY0004-binop/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0004-binop/test.cfg b/testsuite/c_test/sanity_test/SANITY0004-binop/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6b3fcdb87bf642b8c42ab5fb8cf21cfb0600e61d
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0004-binop/test.cfg
@@ -0,0 +1,2 @@
+compile(binop)
+run(binop)
diff --git a/testsuite/c_test/sanity_test/SANITY0005-cand/cand.c b/testsuite/c_test/sanity_test/SANITY0005-cand/cand.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa71bffcbb09d2873f2181fb4b43616789eccb50
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0005-cand/cand.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int i = 2;
+int main() {
+  int v = (((i > 0) && (i < 3)) ? 1 : 2);
+  if ( v != 1 ) {
+    abort();
+  }
+
+  v = (((i > 0) && (i < 2)) ? 1 : 2);
+  if ( v != 2 ) {
+    abort();
+  }
+
+  v = (((i > 2) && (i < 3)) ? 1 : 2);
+  if ( v != 2 ) {
+    abort();
+  }
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0005-cand/expected.txt b/testsuite/c_test/sanity_test/SANITY0005-cand/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0005-cand/test.cfg b/testsuite/c_test/sanity_test/SANITY0005-cand/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..63fc18f7f217b79eb8e014e24eb517e8d23df069
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0005-cand/test.cfg
@@ -0,0 +1,2 @@
+compile(cand)
+run(cand)
diff --git a/testsuite/c_test/sanity_test/SANITY0006-goto/expected.txt b/testsuite/c_test/sanity_test/SANITY0006-goto/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0006-goto/goto.c b/testsuite/c_test/sanity_test/SANITY0006-goto/goto.c
new file mode 100644
index 0000000000000000000000000000000000000000..a0bad57bf41a655f6006851822ecfd95008cbf1a
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0006-goto/goto.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int g = 5;
+
+int main() {
+  for (int i = 0; i < 10; i++) {
+    if (i == 1) {
+      goto label;
+    }
+    g = i;  // 0
+  }
+  abort();
+
+label:
+  if (g != 0) {
+    abort();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0006-goto/test.cfg b/testsuite/c_test/sanity_test/SANITY0006-goto/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7596a23520ae586a4e4b52d077391af1fa434754
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0006-goto/test.cfg
@@ -0,0 +1,2 @@
+compile(goto)
+run(goto)
diff --git a/testsuite/c_test/sanity_test/SANITY0007-hello/expected.txt b/testsuite/c_test/sanity_test/SANITY0007-hello/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0007-hello/hello.c b/testsuite/c_test/sanity_test/SANITY0007-hello/hello.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b6d7b83d5d7fe7586ce7c78400810e67555c8e9
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0007-hello/hello.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  char str[32];
+  int v = sprintf(str,"hello world\n");
+
+  if (v != 12) {
+    abort();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0007-hello/test.cfg b/testsuite/c_test/sanity_test/SANITY0007-hello/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ea0ab9a7950e0dadf8422377bb4dec45fcb8247a
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0007-hello/test.cfg
@@ -0,0 +1,2 @@
+compile(hello)
+run(hello)
diff --git a/testsuite/c_test/sanity_test/SANITY0008-if_call_return/expected.txt b/testsuite/c_test/sanity_test/SANITY0008-if_call_return/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0008-if_call_return/if_call_return.c b/testsuite/c_test/sanity_test/SANITY0008-if_call_return/if_call_return.c
new file mode 100644
index 0000000000000000000000000000000000000000..e55533bd1fbb89fdce2b16381c6ee2fc19d2f68a
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0008-if_call_return/if_call_return.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int i = 1;
+float f = 2.2;
+long long ll = 3;
+double d = 4.4;
+
+int fi(){ return i; }
+float ff(){ return f; }
+long long fll(){ return ll; }
+double fd(){ return d; }
+
+int main() {
+  if (fi() != 1) {
+    abort();
+  }
+  if (ff() != (float)2.2) {
+    abort();
+  }
+  if (fll() != 3) {
+    abort();
+  }
+  if (fd() != 4.4) {
+    abort();
+  }
+  return 0;
+}
+
diff --git a/testsuite/c_test/sanity_test/SANITY0008-if_call_return/test.cfg b/testsuite/c_test/sanity_test/SANITY0008-if_call_return/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dabc51d41cdd968fed63f1b6b1220dac090db354
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0008-if_call_return/test.cfg
@@ -0,0 +1,2 @@
+compile(if_call_return)
+run(if_call_return)
diff --git a/testsuite/c_test/sanity_test/SANITY0009-if_else/expected.txt b/testsuite/c_test/sanity_test/SANITY0009-if_else/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0009-if_else/if_else.c b/testsuite/c_test/sanity_test/SANITY0009-if_else/if_else.c
new file mode 100644
index 0000000000000000000000000000000000000000..63d19c2a83f1279f55ed509df7466dd9a0b7bd6f
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0009-if_else/if_else.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  int i = 1;
+
+  if (i > 1) {
+    abort();
+  } else {
+    printf("");
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0009-if_else/test.cfg b/testsuite/c_test/sanity_test/SANITY0009-if_else/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..75a6f6f1d621ec04d9de2ac712fbd01ee762aedb
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0009-if_else/test.cfg
@@ -0,0 +1,2 @@
+compile(if_else)
+run(if_else)
diff --git a/testsuite/c_test/sanity_test/SANITY0010-if_else_fp/expected.txt b/testsuite/c_test/sanity_test/SANITY0010-if_else_fp/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0010-if_else_fp/if_else_fp.c b/testsuite/c_test/sanity_test/SANITY0010-if_else_fp/if_else_fp.c
new file mode 100644
index 0000000000000000000000000000000000000000..65d0609a1489f46caf46379efc995592b250c304
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0010-if_else_fp/if_else_fp.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  double d1 = 10;
+  double d2 = 20;
+  int i = 0;
+
+  if (d1 <= d2) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (d2 >= d1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (d2 > d1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (d1 < d2 && d2 > d1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (d1 != d2) {
+    i++;
+  } else {
+    abort();
+  }
+
+  d1 = 20;
+  if (d1 <= d2) {
+    if (d1 == d2) {
+      i++;
+    } else {
+      abort();
+    }
+  }
+
+  float f1 = 10;
+  float f2 = 20;
+
+  if (f1 <= f2) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (f2 >= f1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (f2 > f1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (f1 < f2 && f2 > f1) {
+    i++;
+  } else {
+    abort();
+  }
+
+  if (f1 != f2) {
+    i++;
+  } else {
+    abort();
+  }
+
+  f1 = 20;
+  if (f1 <= f2) {
+    if (f1 == f2) {
+      i++;
+    } else {
+      abort();
+    }
+  }
+
+  if (i != 12) {
+    abort();
+  }
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0010-if_else_fp/test.cfg b/testsuite/c_test/sanity_test/SANITY0010-if_else_fp/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..58baf2b8b679104136b4f34eed0534e25def661c
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0010-if_else_fp/test.cfg
@@ -0,0 +1,2 @@
+compile(if_else_fp)
+run(if_else_fp)
diff --git a/testsuite/c_test/sanity_test/SANITY0011-ind_call/expected.txt b/testsuite/c_test/sanity_test/SANITY0011-ind_call/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0011-ind_call/ind_call.c b/testsuite/c_test/sanity_test/SANITY0011-ind_call/ind_call.c
new file mode 100644
index 0000000000000000000000000000000000000000..6cfda4c04c7b1e4ec4e4dd1b32131e525baeda3e
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0011-ind_call/ind_call.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int x = 1;
+
+int foo(){return x;}
+
+int main() {
+  int (*fptr)() = foo;
+  int v = fptr();
+
+  if (v != 1) {
+    abort();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0011-ind_call/test.cfg b/testsuite/c_test/sanity_test/SANITY0011-ind_call/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4159e3812a42daeca8e01b159c72ebfac07734b6
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0011-ind_call/test.cfg
@@ -0,0 +1,2 @@
+compile(ind_call)
+run(ind_call)
diff --git a/testsuite/c_test/sanity_test/SANITY0012-large_stack/expected.txt b/testsuite/c_test/sanity_test/SANITY0012-large_stack/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0012-large_stack/large_stack.c b/testsuite/c_test/sanity_test/SANITY0012-large_stack/large_stack.c
new file mode 100644
index 0000000000000000000000000000000000000000..41bc2c2449dc29ad6d971eeae6b762abac286bdc
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0012-large_stack/large_stack.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define asize 500
+int sum = 0;
+void vararr(int sz) {
+  int my[sz];
+  volatile int a[asize], b[asize], c[asize];
+
+  for (int i = 0; i< asize; i++) {
+    a[i] = i; b[i] = i + 1; c[i] = i + 2;
+    sum = a[i] + b[i] * c[i];
+    if (i < sz) {
+      my[i] = sum;
+    }
+  }
+
+  if ((my[0] != 2) ||
+      (my[1] != 7) ||
+      (my[2] != 14) ||
+      (my[3] != 23)) {
+    abort();
+  }
+}
+
+int main() {
+  vararr(4);
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0012-large_stack/test.cfg b/testsuite/c_test/sanity_test/SANITY0012-large_stack/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..912bdd32b998e96d7bc71b3c61f47549ca156af6
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0012-large_stack/test.cfg
@@ -0,0 +1,2 @@
+compile(large_stack)
+run(large_stack)
diff --git a/testsuite/c_test/sanity_test/SANITY0013-memexpr/expected.txt b/testsuite/c_test/sanity_test/SANITY0013-memexpr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0013-memexpr/memexpr.c b/testsuite/c_test/sanity_test/SANITY0013-memexpr/memexpr.c
new file mode 100644
index 0000000000000000000000000000000000000000..5417248d6ae6a5757952d51a5cfd07e6decb21e8
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0013-memexpr/memexpr.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  struct PSas {
+    short a, b;
+    int *p;
+  }(*PSas0), (*PSas1);
+
+  struct PSas pSas0, pSas1, pSasa[10];
+
+  int i = 5;
+  PSas0 = &pSas0;
+  PSas1 = &pSas1;
+
+  pSasa[8].a = 2;
+  (*PSas0).a = 3;
+  (*PSas1).p = &i;
+
+  if (pSasa[8].a != 2 || (*PSas0).a != 3 || *((*PSas1).p) != 5) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0013-memexpr/test.cfg b/testsuite/c_test/sanity_test/SANITY0013-memexpr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..21703699ad28c04d89a3b5690b2d619aa1344758
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0013-memexpr/test.cfg
@@ -0,0 +1,2 @@
+compile(memexpr)
+run(memexpr)
diff --git a/testsuite/c_test/sanity_test/SANITY0014-select/expected.txt b/testsuite/c_test/sanity_test/SANITY0014-select/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0014-select/select.c b/testsuite/c_test/sanity_test/SANITY0014-select/select.c
new file mode 100644
index 0000000000000000000000000000000000000000..dfe621fe53908cd13d10df3ee9138b9534cc03c0
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0014-select/select.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+  int i = (argc != 1) ? ((argc != 2) ? ((argc != 3) ? 6 : 7) : 5) : ((argc == 4) ? 8 : 9);
+
+  if (i != 9) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0014-select/test.cfg b/testsuite/c_test/sanity_test/SANITY0014-select/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5d46bdaf702b287df72efe06de528f3b713fcdc8
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0014-select/test.cfg
@@ -0,0 +1,2 @@
+compile(select)
+run(select)
diff --git a/testsuite/c_test/sanity_test/SANITY0015-select_fp/expected.txt b/testsuite/c_test/sanity_test/SANITY0015-select_fp/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0015-select_fp/select_fp.c b/testsuite/c_test/sanity_test/SANITY0015-select_fp/select_fp.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c3019a9757473356ce65272bf2d8a258c0bb115
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0015-select_fp/select_fp.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+  float f = 2000;
+  int i = (argc == 1) ? ((f != 200) ? ((f == 2000) ? 6 : 7) : 5) : ((argc == 4) ? 8 : 9);
+
+  if (i != 6) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0015-select_fp/test.cfg b/testsuite/c_test/sanity_test/SANITY0015-select_fp/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b44036188ff37c21963669076cc0c51e39f38b8
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0015-select_fp/test.cfg
@@ -0,0 +1,2 @@
+compile(select_fp)
+run(select_fp)
diff --git a/testsuite/c_test/sanity_test/SANITY0016-set/expected.txt b/testsuite/c_test/sanity_test/SANITY0016-set/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0016-set/set.c b/testsuite/c_test/sanity_test/SANITY0016-set/set.c
new file mode 100644
index 0000000000000000000000000000000000000000..3eaca49ef8540270ebd929be1991220138a2a3cd
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0016-set/set.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdlib.h>
+
+void foo1(int x) { // x = (0, 1, -1, 1, 0, 0)
+  int a1 = x++ == 0;
+  int a2 = x-- != 0;
+  int a3 = --x < 0;
+  int a4 = x+2 > 0;
+  int a5 = ++x <= 0;
+  int a6 = x >= 0;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo2(int x) { // x = (1, 2, 0, 2, 1, 1)
+  int a1 = x == 1;
+  int a2 = ++x != 1;
+  int a3 = x-2 < 1;
+  int a4 = x > 1;
+  int a5 = --x <= 1;
+  int a6 = x >= 1;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo3(int x, int y) { // x&y = (1==1, 1!=2, 0<2, 0>-1, 0<=0, 0>=0)
+  int a1 = x == y;
+  int a2 = x != ++y;
+  int a3 = --x < y--;
+  int a4 = x > y-2;
+  int a5 = x <= --y;
+  int a6 = x >= --y;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo4(unsigned x) { // x = (0, 1, 0xf-f, 1, 0, 0)
+  unsigned a1 = x++ == 0;
+  unsigned a2 = x-- != 0;
+  unsigned a3 = (--x < 0) + 1;
+  unsigned a4 = x+2 > 0;
+  unsigned a5 = ++x <= 0;
+  unsigned a6 = x >= 0;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo5(unsigned x) { // x = (1, 2, 0, 0xf-f, 1, 1)
+  unsigned a1 = x == 1;
+  unsigned a2 = ++x != 1;
+  unsigned a3 = x-2 < 1;
+  unsigned a4 = x-3 > 1;
+  unsigned a5 = --x <= 1;
+  unsigned a6 = x >= 1;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+void foo6(unsigned x, unsigned y) { // x&y = (1==1, 1!=2, 0<2, 0xf-f>1, 0<=0, 0>=0,
+  //        0xf-f>=0)
+  unsigned a1 = x == y;
+  unsigned a2 = x != ++y;
+  unsigned a3 = --x < y--;
+  unsigned a4 = --x > y;
+  unsigned a5 = ++x <= --y;
+  unsigned a6 = x >= y;
+  unsigned a7 = --x >= y;
+  if (a1+a2+a3+a4+a5+a6+a7 != 7) {
+    abort();
+  }
+}
+
+void foo7(unsigned x) { // x = (4096, 4097, 4094, 4097, 4096, 4096)
+  unsigned a1 = x == 4096;
+  unsigned a2 = ++x != 4096;
+  unsigned a3 = x-3 < 4095;
+  unsigned a4 = x > 4096;
+  unsigned a5 = --x <= 4096;
+  unsigned a6 = x >= 4096;
+  if (a1+a2+a3+a4+a5+a6 != 6) {
+    abort();
+  }
+}
+
+int main() {
+  foo1(0);
+  foo2(1);
+  foo3(1, 1);
+  foo4(0);
+  foo5(1);
+  foo6(1, 1);
+  foo7(4096);
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0016-set/test.cfg b/testsuite/c_test/sanity_test/SANITY0016-set/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0471cc6c53521dcff34f1c0882a51cd6a81c7ba9
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0016-set/test.cfg
@@ -0,0 +1,2 @@
+compile(set)
+run(set)
diff --git a/testsuite/c_test/sanity_test/SANITY0017-struct_bits/expected.txt b/testsuite/c_test/sanity_test/SANITY0017-struct_bits/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0017-struct_bits/struct_bits.c b/testsuite/c_test/sanity_test/SANITY0017-struct_bits/struct_bits.c
new file mode 100644
index 0000000000000000000000000000000000000000..7deea9e24a201a0bd0c6dfedae98d77c622d64e8
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0017-struct_bits/struct_bits.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct x {
+  long x;
+  unsigned int z1:3;
+  unsigned int z2:12;
+  int z3:2;
+  int z4:10;
+  int z5:5;
+  int y;
+  char z[32];
+} x;
+
+typedef struct y {
+  long x;
+  long long x1 : 5;
+  long long x2 : 16;
+  unsigned long long x3 : 33;
+  long long x4 : 10;
+  int y;
+} y;
+
+void foo() {
+  x xxx;
+  xxx.x = 1;
+  xxx.y = 2;
+  xxx.z1 = 0x7;
+  xxx.z2 = 0x800;
+  xxx.z3 = 0x3;
+  xxx.z4 = 0x201;
+  xxx.z5 = 0x11;
+  xxx.z[0] = 4;
+  xxx.z[31] = 6;
+  xxx.z[1] = 5;
+
+  if (xxx.z1 != 7) {
+    abort();
+  }
+  if (xxx.z2 != 0x800) {
+    abort();
+  }
+  if (xxx.z3 != -1) {
+    abort();
+  }
+  if (xxx.z4 != -511) {
+    abort();
+  }
+  if (xxx.z5 != -15) {
+    abort();
+  }
+}
+
+void bar() {
+  y yyy;
+
+  yyy.x = 3;
+  yyy.y = 4;
+  yyy.x1 = 7;
+  yyy.x2 = 0xff;
+  yyy.x3 = 0x800f0008;
+  yyy.x4 = 0x15;
+}
+
+int main() {
+  foo();
+  bar();
+  return 0;
+}
+
diff --git a/testsuite/c_test/sanity_test/SANITY0017-struct_bits/test.cfg b/testsuite/c_test/sanity_test/SANITY0017-struct_bits/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..20c264f5ceab95365caee08393056b2421b5b01d
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0017-struct_bits/test.cfg
@@ -0,0 +1,2 @@
+compile(struct_bits)
+run(struct_bits)
diff --git a/testsuite/c_test/sanity_test/SANITY0018-sum_array/expected.txt b/testsuite/c_test/sanity_test/SANITY0018-sum_array/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0018-sum_array/sum_array.c b/testsuite/c_test/sanity_test/SANITY0018-sum_array/sum_array.c
new file mode 100644
index 0000000000000000000000000000000000000000..9235f2768dda33a9b7443afc85956afa6d08933e
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0018-sum_array/sum_array.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+//int main(int argc, char *argv[])
+int main()
+{
+  int a[10], b[10], c[10], i;
+
+  for (i = 0; i < 10; i++) {
+    b[i] = i << 2;
+    c[i] = i << (b[i] % (sizeof(int)*CHAR_BIT));
+  }
+
+  for (i = 0; i < 10; i++) {
+    a[i] = b[i] + c[9-i];
+  }
+
+  int sum = 0;
+  for (i = 0; i < 10; i++) {
+    sum += a[i];
+  }
+
+  if (sum != 1985229660) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0018-sum_array/test.cfg b/testsuite/c_test/sanity_test/SANITY0018-sum_array/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5dd732351283455206ce73b3ebff02d456125ec2
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0018-sum_array/test.cfg
@@ -0,0 +1,2 @@
+compile(sum_array)
+run(sum_array)
diff --git a/testsuite/c_test/sanity_test/SANITY0019-sum/expected.txt b/testsuite/c_test/sanity_test/SANITY0019-sum/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0019-sum/sum.c b/testsuite/c_test/sanity_test/SANITY0019-sum/sum.c
new file mode 100644
index 0000000000000000000000000000000000000000..d49699cfd26d73c389f2019cd01402cf89ec2e9b
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0019-sum/sum.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  int sum = 0;
+
+  for (int i = 0; i < 10; i++) {
+    sum += i;
+  }
+
+  if (sum != 45) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0019-sum/test.cfg b/testsuite/c_test/sanity_test/SANITY0019-sum/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c99ee5da8b8e358953e62cab9da8c9bd62201548
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0019-sum/test.cfg
@@ -0,0 +1,2 @@
+compile(sum)
+run(sum)
diff --git a/testsuite/c_test/sanity_test/SANITY0020-vararg2/expected.txt b/testsuite/c_test/sanity_test/SANITY0020-vararg2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0020-vararg2/test.cfg b/testsuite/c_test/sanity_test/SANITY0020-vararg2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7c8daa21be4fb53f26647a591e486b3b380e97c6
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0020-vararg2/test.cfg
@@ -0,0 +1,2 @@
+compile(vararg2)
+run(vararg2)
diff --git a/testsuite/c_test/sanity_test/SANITY0020-vararg2/vararg2.c b/testsuite/c_test/sanity_test/SANITY0020-vararg2/vararg2.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb0fcd53dd5c71d78156cdf6819bfd6e76dc106a
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0020-vararg2/vararg2.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdarg.h>
+
+static double f (float a, ...);
+static double (*fp) (float a, ...);
+
+main () {
+  fp = f;
+  if (fp ((float) 1, (double)2) != 3.0) {
+    abort ();
+  }
+  exit (0);
+}
+
+static double
+f (float a, ...) {
+  va_list ap;
+
+  va_start(ap, a);
+  float i = va_arg(ap, double);
+  return (double)a + i;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0021-cc_param2/cc_param2.c b/testsuite/c_test/sanity_test/SANITY0021-cc_param2/cc_param2.c
new file mode 100644
index 0000000000000000000000000000000000000000..083050da0a3080ee4d2f7a03559bb0e1a5f6a9ff
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0021-cc_param2/cc_param2.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+//
+// Test calling convention of passing half-half struct param
+//
+#include <stdlib.h>
+typedef struct { long long i; int j; } S0;
+typedef struct { long long i; int j; } S1;
+typedef struct { long long i; int j; } S2;
+
+// IntCC: 1 intreg short, half of s passed on stack, half in fpreg
+void foo1( int i1, int i2, int i3, S0 r, int i4, int i5, int i6, int i7, S1 s, S1 t )
+{
+  if (r.j != 2) abort();
+  if (s.j != 4) abort();
+  if (t.j != 6) abort();
+}
+
+void foo2( int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, S1 s, S1 t )
+{
+  if (s.j != 4) abort();
+  if (t.j != 6) abort();
+}
+
+int main()
+{
+    S0 x = { 1, 2 };
+    S1 y = { 3, 4 };
+    S1 z = { 5, 6 };
+
+    foo1(1,2,3,x,4,5,6,7, y, z);
+    foo2(0,0,0,0,0,0,0,0, y, z);
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0021-cc_param2/expected.txt b/testsuite/c_test/sanity_test/SANITY0021-cc_param2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0021-cc_param2/test.cfg b/testsuite/c_test/sanity_test/SANITY0021-cc_param2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9adbeb875d615d9ff614e9a9dde84c4e2216ac7a
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0021-cc_param2/test.cfg
@@ -0,0 +1,2 @@
+compile(cc_param2)
+run(cc_param2)
diff --git a/testsuite/c_test/sanity_test/SANITY0022-cc_param3/cc_param3.c b/testsuite/c_test/sanity_test/SANITY0022-cc_param3/cc_param3.c
new file mode 100644
index 0000000000000000000000000000000000000000..9caad4774db86fc94595fbe1a1eb7707f1b3c2aa
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0022-cc_param3/cc_param3.c
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdlib.h>
+
+typedef struct { int i; long long j; } S1;
+// IntCC: no intreg, entire s passed on stack
+void foo0( int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, S1 s )
+{ if (s.j != 2) abort(); }
+
+// IntCC: 1 intreg short, half of s passed on stack, half $a7 reg
+void foo1( int i1, int i2, int i3, int i4, int i5, int i6, int i7, S1 s )
+{ if (s.j != 2) abort(); }
+
+// FpCC: 1 intreg short, move to IntCC: 1 stack
+typedef struct { float i; int j; } S2;
+void foo2( int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, S2 s )
+{ if (s.j != 4) abort(); }
+
+// FpCC: 1 fpreg short, move to IntCC: 1 intreg + 1 stack
+void foo3( float i1, float i2, float i3, float i4, float i5, float i6, float i7, float i8, S2 s )
+{ if (s.j != 4) abort(); }
+
+// FpCC: 2 fpregs short, move to IntCC: 2 stacks
+typedef struct { double i; double j; float k; } S4;
+void foo4( float i1, float i2, float i3, float i4, float i5, float i6, float i7, float i8, S4 s )
+{ if (s.j != 6) abort(); }
+
+// IntCC: 1 float on stack, 8 intregs
+typedef struct { float i; int j; } S5;
+void foo5( int i1, int i2, int i3, int i4, int i5, int i6, int i7,
+           float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8,
+           S5 s )
+{ if (s.i != 7.0f || s.j != 8) abort(); }
+
+// IntCC: 1 int on stack, 8 fpregs
+void foo6( int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8,
+           float f1, float f2, float f3, float f4, float f5, float f6, float f7,
+           S5 s )
+{ if (s.i != 7.0f || s.j != 8) abort(); }
+
+int main()
+{
+  S1 s1 = { 1, 2 };
+  foo0(1,2,3,4,5,6,7,8, s1);
+  foo1(1,2,3,4,5,6,7, s1);
+
+  S2 s2 = { 3, 4 };
+  foo2(1,2,3,4,5,6,7,8, s2);
+  foo3(0,0,0,0,0,0,0,0, s2);
+
+  S4 s4 = { 5, 6 };
+  foo4(0,0,0,0,0,0,0,0, s4);
+
+  S5 s5 = { 7.0f, 8 };
+  foo5( 1,2,3,4,5,6,7,    10,20,30,40,50,60,70,80, s5 );
+  foo6( 1,2,3,4,5,6,7,8,  10,20,30,40,50,60,70,    s5 );
+
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0022-cc_param3/expected.txt b/testsuite/c_test/sanity_test/SANITY0022-cc_param3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0022-cc_param3/test.cfg b/testsuite/c_test/sanity_test/SANITY0022-cc_param3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9eb29dc671da08197e5a8c6711b3c4a31c7ed823
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0022-cc_param3/test.cfg
@@ -0,0 +1,2 @@
+compile(cc_param3)
+run(cc_param3)
diff --git a/testsuite/c_test/sanity_test/SANITY0023-cc_sret/cc_sret.c b/testsuite/c_test/sanity_test/SANITY0023-cc_sret/cc_sret.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b32e2106e5042e0efe29cfe937b43d1a15111db
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0023-cc_sret/cc_sret.c
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+//
+// Test calling convention of struct return type
+#include <stdlib.h>
+typedef struct { int x; int y; } s1;
+typedef struct { long long x; long long y; } s2;
+typedef struct { long long x; long long y; int z; } s3;
+typedef struct { float x; float y; } f1;
+typedef struct { double x; double y; } f2;
+typedef struct { float x; char y; char z; short w; } m1;
+typedef struct { int x[4]; } a1;
+typedef struct { double x[4]; } a2;
+typedef struct { float x[2]; } f3;
+typedef struct { float x[3]; } f4;
+typedef struct { int x; float y; } m2;
+typedef struct { double x; long long y; } m3;
+
+s1 foo1(int i){ s1 x = {1,2}; return x; }             // 1 intreg return
+s2 foo2(int i){ s2 x = {3,4}; return x; }             // 2 intregs return
+s3 foo3(int i){ s3 x = {5,6,7}; return x; }           // hidden 1st arg, >16by
+f1 foo4(int i){ f1 x = {8,9}; return x; }             // 2 fpregs return
+f2 foo5(int i){ f2 x = {10,11}; return x; }           // 2 fpregs return
+m1 foo6(int i){ m1 x = {12,13,14,15}; return x; }     // 1 intregs return
+a1 foo7(int i){ a1 x = {16,17,18,19}; return x; }     // 2 intregs return
+a2 foo8(int i){ a2 x = {20,21,22,23}; return x; }     // hidden 1st arg, >16by
+f3 foo9(int i){ f3 x = {24,25}; return x; }           // 2 fpregs return
+f4 foo10(int i){ f4 x = {26,27,28}; return x; }       // 2 intregs return
+m2 foo11(int i){ m2 x = {29,30.0}; return x; }        // 1 intreg 1 fpreg
+m3 foo12(int i){ m3 x = {31.0,32}; return x; }        // 1 fpreg 1 intreg
+
+typedef struct { int a[2]; } sz8;  // 8 byte struct
+typedef struct { int a[4]; } sz16;  // 16 byte struct
+typedef struct { int a[8]; } sz32;  // 32 byte struct
+
+sz8 call8()
+{
+   s1 x;
+   s2 y;
+   s3 e;
+   f1 z;
+   f2 w;
+   f3 v;
+   f4 u;
+   m1 m;
+   m2 n;
+   m3 o;
+   a1 a;
+   a2 b;
+
+   x = foo1( 0 );
+   if (x.y != 2) abort();
+   y = foo2( 0 );
+   if (y.y != 4) abort();
+   e = foo3( 0 );
+   if (e.z != 7) abort();
+   z = foo4( 0 );
+   if (z.y != 9) abort();
+   w = foo5( 0 );
+   if (w.y != 11) abort();
+   m = foo6( 0 );
+   if (m.w != 15) abort();
+   a = foo7( 0 );
+   if (a.x[3] != 19) abort();
+   b = foo8( 0 );
+   if (b.x[3] != 23) abort();
+   v = foo9( 0 );
+   if (v.x[1] != 25) abort();
+   u = foo10( 0 );
+   if (u.x[2] != 28) abort();
+   n = foo11( 0 );
+   if (n.x != 29 || n.y != 30.0) abort();
+   o = foo12( 0 );
+   if (o.x != 31.0 || o.y != 32) abort();
+
+   sz8 x8 = { 1, 2};
+   return x8;
+}
+
+sz16 call16()
+{
+   s1 x;
+   s2 y;
+   s3 e;
+   f1 z;
+   f2 w;
+   f3 v;
+   f4 u;
+   m1 m;
+   m2 n;
+   m3 o;
+   a1 a;
+   a2 b;
+
+   x = foo1( 0 );
+   if (x.y != 2) abort();
+   y = foo2( 0 );
+   if (y.y != 4) abort();
+   e = foo3( 0 );
+   if (e.z != 7) abort();
+   z = foo4( 0 );
+   if (z.y != 9) abort();
+   w = foo5( 0 );
+   if (w.y != 11) abort();
+   m = foo6( 0 );
+   if (m.w != 15) abort();
+   a = foo7( 0 );
+   if (a.x[3] != 19) abort();
+   b = foo8( 0 );
+   if (b.x[3] != 23) abort();
+   v = foo9( 0 );
+   if (v.x[1] != 25) abort();
+   u = foo10( 0 );
+   if (u.x[2] != 28) abort();
+   n = foo11( 0 );
+   if (n.x != 29 || n.y != 30.0) abort();
+   o = foo12( 0 );
+   if (o.x != 31.0 || o.y != 32) abort();
+
+   sz16 x16 = { 1, 2, 3, 4};
+   return x16;
+}
+
+sz32 call32()
+{
+   s1 x;
+   s2 y;
+   s3 e;
+   f1 z;
+   f2 w;
+   f3 v;
+   f4 u;
+   m1 m;
+   m2 n;
+   m3 o;
+   a1 a;
+   a2 b;
+
+   x = foo1( 0 );
+   if (x.y != 2) abort();
+   y = foo2( 0 );
+   if (y.y != 4) abort();
+   e = foo3( 0 );
+   if (e.z != 7) abort();
+   z = foo4( 0 );
+   if (z.y != 9) abort();
+   w = foo5( 0 );
+   if (w.y != 11) abort();
+   m = foo6( 0 );
+   if (m.w != 15) abort();
+   a = foo7( 0 );
+   if (a.x[3] != 19) abort();
+   b = foo8( 0 );
+   if (b.x[3] != 23) abort();
+   v = foo9( 0 );
+   if (v.x[1] != 25) abort();
+   u = foo10( 0 );
+   if (u.x[2] != 28) abort();
+   n = foo11( 0 );
+   if (n.x != 29 || n.y != 30.0) abort();
+   o = foo12( 0 );
+   if (o.x != 31.0 || o.y != 32) abort();
+
+   sz32 x32 = { 1, 2, 3, 4, 5, 6, 7, 8};
+   return x32;
+}
+
+int main()
+{
+  call8();
+  call16();
+  call32();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0023-cc_sret/expected.txt b/testsuite/c_test/sanity_test/SANITY0023-cc_sret/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0023-cc_sret/test.cfg b/testsuite/c_test/sanity_test/SANITY0023-cc_sret/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aba08084a7f3eb5929c5d68c72d3b64c5b804786
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0023-cc_sret/test.cfg
@@ -0,0 +1,2 @@
+compile(cc_sret)
+run(cc_sret)
diff --git a/testsuite/c_test/sanity_test/SANITY0024-vararg1/expected.txt b/testsuite/c_test/sanity_test/SANITY0024-vararg1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0024-vararg1/test.cfg b/testsuite/c_test/sanity_test/SANITY0024-vararg1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9223bc88b0ea162962a05bd41a5582fb888640fd
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0024-vararg1/test.cfg
@@ -0,0 +1,2 @@
+compile(vararg1)
+run(vararg1)
diff --git a/testsuite/c_test/sanity_test/SANITY0024-vararg1/vararg1.c b/testsuite/c_test/sanity_test/SANITY0024-vararg1/vararg1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9560448c53b86e54a44c359b388cdbf1107e9435
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0024-vararg1/vararg1.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "stdarg.h"
+#include "stdlib.h"
+
+int a,b;
+typedef int vfunc_t(int x, int y, ...);
+int foo1( int x, int y, ... )
+{
+   va_list ap;
+
+   va_start(ap, y);
+   a = va_arg(ap, int);
+   b = va_arg(ap, int);
+   return (int)a + b;
+}
+
+typedef struct { int i; long long j; } S;
+int foo2( int a0, int a1, ... )
+{
+   va_list ap;
+
+   va_start(ap, a1);
+   S b = va_arg(ap, S);
+   if (b.i+b.j != 30)
+     abort();
+}
+
+typedef struct { long long x; long long y; int z; } T;
+void foo3( int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, T x, ...)
+{
+   va_list ap;
+
+   va_start(ap, x);
+   a = va_arg(ap, int);
+   if (a != 10)    // on the stack
+     abort();
+}
+
+int main()
+{
+    vfunc_t *f = &foo1;
+    int x;
+
+    x = foo1(1,2,3,4);
+    if (x != 7)
+      abort();
+    x = (*f)(1,2,5,6);
+    if (x != 11)
+      abort();
+
+    S s = {10,20};
+    foo2( 1,2, s );
+
+    T y = { 1, 2, 3 };
+
+    foo3(1,2,3,4,5,6,7,8, y,10 );
+}
+
+
diff --git a/testsuite/c_test/sanity_test/SANITY0025-cc_param1/cc_param1.c b/testsuite/c_test/sanity_test/SANITY0025-cc_param1/cc_param1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c2b2865213e9dc88d639a1859eba73d4bff188c1
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0025-cc_param1/cc_param1.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+//
+// Test calling convention of passing struct param
+//
+#include <stdlib.h>
+typedef struct { int x; int y; } s1;
+typedef struct { long long x; long long y; } s2;
+typedef struct { long long x; long long y; int z; } s3;
+typedef struct { float x; float y; } f1;
+typedef struct { double x; double y; } f2;
+typedef struct { float x; char y; char z; short w; } m1;
+typedef struct { int x[4]; } a1;
+typedef struct { float x[4]; } a2;
+
+void foo1( s1 x ){ if (x.y != 2) abort(); }     // 1 intreg
+void foo2( s2 x ){ if (x.y != 4) abort(); }     // 2 intregs
+void foo3( f1 x ){ if (x.y != 9.0f) abort(); }  // 2 fpregs
+void foo4( f2 x ){ if (x.y != 11.0) abort(); }  // 2 fpregs
+void foo5( m1 x ){ if (x.w != 15) abort(); }    // 1 intreg
+void foo6( int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, s2 x) {
+   if (x.y != 4) abort();                       // 8 intregs + 16-by stk
+}
+void foo7( int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, s3 x) {;
+   if (x.z != 7) abort();                       // 8 intregs + 8-by stk addr + 24-byte s3 anywhere
+}
+void foo8( a1 x ){ if (x.x[3] != 19) abort(); }   // 2 intregs
+void foo9( a2 x ){ if (x.x[3] != 23) abort(); }   // 2 intregs
+
+int main()
+{
+   s1 x = { 1, 2 };
+   s2 y = { 3, 4 };
+   s3 e = { 5, 6, 7 };
+   f1 z = { 8, 9 };
+   f2 w = { 10, 11 };;
+   m1 m = { 12, 13, 14, 15 };
+   a1 a = { 16, 17, 18, 19 };
+   a2 b = { 20, 21, 22, 23 };
+
+   foo1( x );
+   foo2( y );
+   foo3( z );
+   foo4( w );
+   foo5( m );
+   foo6( 1,2,3,4,5,6,7,8,y );
+   foo7( 1,2,3,4,5,6,7,8,e );
+   foo8( a );
+   foo9( b );
+
+   return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0025-cc_param1/expected.txt b/testsuite/c_test/sanity_test/SANITY0025-cc_param1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0025-cc_param1/test.cfg b/testsuite/c_test/sanity_test/SANITY0025-cc_param1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f324e0cff481933c4ee87359334ca463efe2508
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0025-cc_param1/test.cfg
@@ -0,0 +1,2 @@
+compile(cc_param1)
+run(cc_param1)
diff --git a/testsuite/c_test/sanity_test/SANITY0026-matrixmult/expected.txt b/testsuite/c_test/sanity_test/SANITY0026-matrixmult/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0026-matrixmult/matrixmult.c b/testsuite/c_test/sanity_test/SANITY0026-matrixmult/matrixmult.c
new file mode 100644
index 0000000000000000000000000000000000000000..d672640fe11937e6e36ef7bf21c66c2ce093c243
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0026-matrixmult/matrixmult.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main()
+{
+  int a[3][3], b[3][3], c[3][3];
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; j++) {
+      a[i][j] = i;
+      b[i][j] = j;
+      c[i][j] = 0;
+    }
+  }
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        c[i][j] += a[i][k] * b[k][j];
+      }
+    }
+  }
+  int sum = 0;
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; ++j) {
+      sum += c[i][j];
+      //printf("c[%d][%d] = %d\n", i, j, c[i][j]);
+    }
+  }
+  if (sum != 27) {
+    printf("sum = %d\n", sum);
+    abort();
+  }
+
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0026-matrixmult/test.cfg b/testsuite/c_test/sanity_test/SANITY0026-matrixmult/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..638151160670b1f75a31ef407a914e4c166af58b
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0026-matrixmult/test.cfg
@@ -0,0 +1,2 @@
+compile(matrixmult)
+run(matrixmult)
diff --git a/testsuite/c_test/sanity_test/SANITY0027-convert/convert.c b/testsuite/c_test/sanity_test/SANITY0027-convert/convert.c
new file mode 100644
index 0000000000000000000000000000000000000000..848ecbbe99809ca706089b6090e9b180f56a6c1a
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0027-convert/convert.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+signed char c = 0xff;
+unsigned char uc = 0xff;
+short s;
+int i;
+long long l;
+
+int main()
+{
+  s = c;
+  i = s;
+  l = i;
+  //printf("signed = %ld ", l);
+  if (l != -1) {
+    abort();
+  }
+
+  s = uc;
+  i = s;
+  l = i;
+  //printf("unsigned = %ld\n", l);
+  if (l != 255) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0027-convert/expected.txt b/testsuite/c_test/sanity_test/SANITY0027-convert/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0027-convert/test.cfg b/testsuite/c_test/sanity_test/SANITY0027-convert/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b82ff94211698b52aca2052a1b9e47c4d47290a
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0027-convert/test.cfg
@@ -0,0 +1,2 @@
+compile(convert)
+run(convert)
diff --git a/testsuite/c_test/sanity_test/SANITY0028-inlineasm/asm.c b/testsuite/c_test/sanity_test/SANITY0028-inlineasm/asm.c
new file mode 100644
index 0000000000000000000000000000000000000000..fbddbfedaa0c2279af3cfc05b9dff6e1cbc6ccbf
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0028-inlineasm/asm.c
@@ -0,0 +1,500 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define TEST01
+#define TEST02
+#define TEST03
+#define TEST04
+#define TEST05
+#define TEST06 // "m"
+#undef TEST07  // fail // goto label
+#define TEST08
+#define TEST09 // "m"
+#define TEST10
+#undef TEST11  // fail // unsupported op
+#define TEST12
+#define TEST13
+#undef TEST14  // works on arm server not qemu
+#define TEST15
+#define TEST16
+#define TEST17
+#define TEST18
+
+#ifdef TEST01
+int test01a(int a, int b) {
+  int c;
+//  asm volatile("\tadd %0, %1, %2\n"
+  asm volatile("\tadd %w0, %w1, %w2\n"
+	       	: "=r"(c)
+	       	: "r"(a), "r"(b));
+  return c;
+}
+void test01() {
+  long long l1 = 0x80000000LL;
+  long long l2 = 0x100000000LL;
+  if (test01a(l1, l2) != 0x80000000) {
+    printf("test01 failed\n");
+    abort();
+  }
+}
+#endif
+#ifdef TEST02
+int test02a(int a, int b) {
+  int c;
+  asm volatile("add %w0, %w1, %w2" : "=r"(c) : "r"(a), "r"(b) : "x5", "w4", "s2", "d3", "v9");
+  return c;
+}
+void test02() {
+  long long l1 = 0x80000000LL;
+  long long l2 = 0x100000000LL;
+  if (test02a(l1, l2) != 0x80000000) {
+    printf("test02 failed\n");
+    abort();
+  }
+}
+#endif
+#ifdef TEST03
+int test03a(int a, int b) {
+  int c, d;
+  asm volatile("add %w0, %w2, %w3\n\t"
+               "add %w1, %w2, %w3\n"
+      : "=&r"(c), "=r"(d) : "r"(a), "r"(b) : "x5", "w4", "s2", "d3", "v9");
+  return (c + d);
+}
+void test03() {
+  long long l1 = 0x00000800LL;
+  long long l2 = 0x00090000LL;
+  if (test03a(l1, l2) != 0x00121000) {
+    printf("test03 failed\n");
+    abort();
+  }
+}
+#endif
+#ifdef TEST04
+int test04a(int a, int b) {
+  int *e = &a;
+  asm ("mov %w[b], %w[e]" : [b] "=r" (b) : [e] "r" (*e));
+  return a;
+}
+void test04() {
+  long long l1 = 0x00000800LL;
+  long long l2 = 0x00090000LL;
+  if (test04a(l1, l2) != 0x00000800) {
+    printf("test04 failed\n");
+    abort();
+  }
+}
+#endif
+#ifdef TEST05
+int test05a(int a, int b) {
+  int c;
+  asm ("add %w[c], %w1, %w2" : [c] "=r" (c) : "r" (a), "r" (b));
+  return c;
+}
+void test05() {
+  long long l1 = 0x00000800LL;
+  long long l2 = 0x00090000LL;
+  if (test05a(l1, l2) != 0x00090800) {
+    printf("test05 failed\n");
+    abort();
+  }
+}
+#endif
+#ifdef TEST06
+int test06a(int a, int b) {
+  int c;
+  asm ("ldr %x[c], %x1" : [c] "=r" (c) : "m" (a));
+  return c;
+}
+void test06() {
+  long long l1 = 0x00000800LL;
+  long long l2 = 0x00090000LL;
+  if (test06a(l1, l2) != 0x00000800) {
+    printf("test06 failed\n");
+    abort();
+  }
+}
+#endif
+#ifdef TEST07
+int test07a(int a, int b) {
+  asm goto ("b %l0\n"
+   : /* no output */
+   : /* no input */
+   : /* no clobber */
+   : gohere);
+  return 0;
+gohere:
+  return 1;
+}
+void test07() {
+  long long l1 = 0x00000800LL;
+  long long l2 = 0x00090000LL;
+  if (test07a(l1, l2) != 1) {
+    printf("test07 failed\n");
+    abort();
+  }
+}
+#endif
+#ifdef TEST08
+int test08a(int a, int b) {
+  /* %w[c] should not be in the same reg as %w1 */
+  int c;
+  asm (
+    "add %w[c], %w1, %w2\n\t"
+    "mov %w[c], %w1"
+    : [c] "+r" (c)
+    : "r" (a), "r" (b));
+  return c;
+}
+void test08() {
+  long long l1 = 0x00000800LL;
+  long long l2 = 0x00090000LL;
+  if (test08a(l1, l2) != 0x00000800) {
+    printf("test08 failed\n");
+    abort();
+  }
+}
+#endif
+
+#ifdef TEST09
+long g;
+int test09a(long x) {
+  asm volatile("\tldr %0, %1\n"
+	       	: "=r"(x)
+	       	: "m"(g));
+  return x;
+};
+void test09() {
+  g = 0x400;
+  long l1 = 0x00000800LL;
+  if (test09a(l1) != 0x0400) {
+    printf("test09 failed\n");
+    abort();
+  }
+}
+#endif
+
+#ifdef TEST10
+int h1[2];
+int *h = h1;
+int test10a() {
+  long long y;
+  int z;
+  asm volatile("add %x0, %x2, #4\n"
+  "\tldr %w1, [%x0]\n"
+  : "=r"(y), "=r"(z)
+  : "r"(h), "m"(h)
+  : "x1");
+  return z;
+}
+void test10() {
+  h1[0] = 0x400;
+  h1[1] = 0x800;
+  if (test10a() != 0x0800) {
+    printf("test10 failed\n");
+    abort();
+  }
+}
+#endif
+
+#ifdef TEST11
+unsigned int
+crc32c_arm64_u8(unsigned char data, unsigned int init_val)
+{
+        __asm__ volatile(
+                        "crc32cb %w[crc], %w[crc], %w[value]"
+                        : [crc] "+r" (init_val)
+                        : [value] "r" (data));
+        return init_val;
+}
+unsigned int test11() {
+  unsigned char data = 10;
+  unsigned int init_val = 5;
+  init_val = crc32c_arm64_u8(data, init_val);
+  printf("init_val %x\n", init_val);
+}
+#endif
+
+#ifdef TEST12
+void
+prfm_arm64_u8(void *ptr)
+{
+        asm volatile(
+		"prfm pstl1keep, %a0\n"
+	       	:
+	       	: "p" (ptr));
+}
+unsigned int test12() {
+  long long ptr;
+  prfm_arm64_u8(&ptr);
+}
+#endif
+
+#ifdef TEST13
+#define octeontx_load_pair(val0, val1, addr) ({         \
+                        asm volatile(                   \
+                        "ldp %x[x0], %x[x1], [%x[p1]]"  \
+                        :[x0]"=r"(val0), [x1]"=r"(val1) \
+                        :[p1]"r"(addr)                  \
+                        ); })
+
+#define octeontx_store_pair(val0, val1, addr) ({                \
+                        asm volatile(                   \
+                        "stp %x[x0], %x[x1], [%x[p1]]"  \
+                        ::[x0]"r"(val0), [x1]"r"(val1), [p1]"r"(addr) \
+                        :"memory"); })
+void test13()
+{
+  long long addr[2] = {0x111, 0x222};
+  long long val0, val1;
+  long long *ptr = addr;
+  octeontx_load_pair(val0, val1, ptr);
+  if (val0 != 0x111) {
+    printf("test13 val0 failed\n");
+    abort();
+  }
+  if (val1 != 0x222) {
+    printf("test13 val1 failed\n");
+    abort();
+  }
+  addr[0] = 0x333;
+  addr[1] = 0x444;
+  octeontx_store_pair(val0, val1, ptr);
+  if (addr[0] != 0x111) {
+    printf("test13 addr[0] failed\n");
+    abort();
+  }
+  if (addr[1] != 0x222) {
+    printf("test13 addr[1] failed\n");
+    abort();
+  }
+}
+#endif
+
+#ifdef TEST14
+unsigned long long
+test14a(void *addr, long long off)
+{
+        unsigned long long old_val;
+
+        __asm__ volatile(
+                " .cpu   generic+lse+sve\n\t"
+                " ldadd %1, %0, [%2]\n"
+                : "=r" (old_val) : "r" (off), "r" (addr) : "memory");
+
+        return old_val;
+}
+void test14()
+{
+  long long val = 5;
+  long long off = 1;
+  if (test14a(&val, off) != 5LL && val != 6) {
+    printf("test14 failed\n");
+    abort();
+  }
+}
+#endif
+
+#ifdef TEST15
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <arm_neon.h>
+
+	uint16x4_t byte_cnt;
+unsigned char cp = 5;
+	unsigned char *p = &cp;
+	uint8x16_t rxdf;
+	uint64x2_t rearm;
+uint8_t e0p;
+	uint8_t *e0 = &e0p;
+uint8_t e1p;
+	uint8_t *e1 = &e1p;
+uint8_t e2p;
+	uint8_t *e2 = &e2p;
+uint8_t e3p;
+	uint8_t *e3 = &e3p;
+	uint8x16_t mcqe_shuf_m1;
+	uint8x16_t mcqe_shuf_m2;
+	uint16x8_t crc_adj;
+	uint8x8_t len_shuf_m;
+
+uint16x4_t
+test15()
+{
+		__asm__ volatile (
+		/* A.1 load mCQEs into a 128bit register. */
+		"ld1 {v16.16b - v17.16b}, [%[mcq]] \n\t"
+		/* B.1 store rearm data to mbuf. */
+	"st1 {%[rearm].2d}, [%[e0]] \n\t"
+		"add %[e0], %[e0], #16 \n\t"
+		"st1 {%[rearm].2d}, [%[e1]] \n\t"
+		"add %[e1], %[e1], #16 \n\t"
+		/* C.1 combine data from mCQEs with rx_descriptor_fields1. */
+		"tbl v18.16b, {v16.16b}, %[mcqe_shuf_m1].16b \n\t"
+		"tbl v19.16b, {v16.16b}, %[mcqe_shuf_m2].16b \n\t"
+		"sub v18.8h, v18.8h, %[crc_adj].8h \n\t"
+		"sub v19.8h, v19.8h, %[crc_adj].8h \n\t"
+		"orr v18.16b, v18.16b, %[rxdf].16b \n\t"
+		"orr v19.16b, v19.16b, %[rxdf].16b \n\t"
+		/* D.1 store rx_descriptor_fields1. */
+		"st1 {v18.2d}, [%[e0]] \n\t"
+		"st1 {v19.2d}, [%[e1]] \n\t"
+		/* B.1 store rearm data to mbuf. */
+		"st1 {%[rearm].2d}, [%[e2]] \n\t"
+		"add %[e2], %[e2], #16 \n\t"
+		"st1 {%[rearm].2d}, [%[e3]] \n\t"
+		"add %[e3], %[e3], #16 \n\t"
+		/* C.1 combine data from mCQEs with rx_descriptor_fields1. */
+		"tbl v18.16b, {v17.16b}, %[mcqe_shuf_m1].16b \n\t"
+		"tbl v19.16b, {v17.16b}, %[mcqe_shuf_m2].16b \n\t"
+		"sub v18.8h, v18.8h, %[crc_adj].8h \n\t"
+		"sub v19.8h, v19.8h, %[crc_adj].8h \n\t"
+		"orr v18.16b, v18.16b, %[rxdf].16b \n\t"
+		"orr v19.16b, v19.16b, %[rxdf].16b \n\t"
+		/* D.1 store rx_descriptor_fields1. */
+		"st1 {v18.2d}, [%[e2]] \n\t"
+		"st1 {v19.2d}, [%[e3]] \n\t"
+		:[byte_cnt]"=&w"(byte_cnt)
+		:[mcq]"r"(p),
+		 [rxdf]"w"(rxdf),
+		 [rearm]"w"(rearm),
+		 [e3]"r"(e3), [e2]"r"(e2), [e1]"r"(e1), [e0]"r"(e0),
+		 [mcqe_shuf_m1]"w"(mcqe_shuf_m1),
+		 [mcqe_shuf_m2]"w"(mcqe_shuf_m2),
+		 [crc_adj]"w"(crc_adj),
+		 [len_shuf_m]"w"(len_shuf_m)
+		:"memory", "v16", "v17", "v18", "v19");
+    return byte_cnt;
+}
+#endif
+
+#ifdef TEST16
+void test16(unsigned int a) {
+  __asm__ volatile("mrs %x0, CNTV_CTL_EL0\n\t" : "=r" (a) : : "memory");
+}
+#endif
+
+#ifdef TEST17
+int test17a(int a) {
+  int c;
+  asm volatile("\tadd %w0, %w1, %2\n"
+	       	: "=r"(c)
+	       	: "r"(a), "i"(16));
+  return c;
+}
+void test17() {
+  long long l1 = 0x80000000LL;
+  if (test17a(l1) != 0x80000010) {
+    printf("test01 failed\n");
+    abort();
+  }
+}
+#endif
+
+#ifdef TEST18
+#if 0
+#define _ATOMIC_CMPSET(bar, a, l)		\
+_ATOMIC_CMPSET_IMPL(8, w, b, bar, a, l)
+//_ATOMIC_CMPSET_IMPL(16, w, h, bar, a, l)
+//_ATOMIC_CMPSET_IMPL(32, w, , bar, a, l)
+//_ATOMIC_CMPSET_IMPL(64, , , bar, a, l)
+
+#define _ATOMIC_CMPSET_IMPL(t, w, s, bar, a, l)		\
+_ATOMIC_CMPSET_PROTO(t, bar, _llsc)		\
+{		\
+uint##t##_t tmp;		\
+int res;		\
+		\
+__asm __volatile(		\
+"1: mov %w1, #1\n"		\
+" ld"#a"xr"#s" %"#w"0, [%2]\n"		\
+" cmp %"#w"0, %"#w"3\n"		\
+" b.ne 2f\n"		\
+" st"#l"xr"#s" %w1, %"#w"4, [%2]\n"		\
+" cbnz %w1, 1b\n"		\
+"2:"		\
+: "=&r"(tmp), "=&r"(res)		\
+: "r" (p), "r" (cmpval), "r" (newval)		\
+: "cc", "memory"		\
+);	\
+return (!res); \
+
+#endif
+
+void *p1;
+long long cmpval;
+int newval;
+void test18a() {
+  unsigned long long tmp;
+  int res;
+    __asm __volatile(
+	"1: mov %w1, #1\n"
+	" ldr %x0, [%2]\n"
+	" cmp %x0, %x3\n"
+	" b.ne 2f\n"
+	" stp %w1, %w4, [%2]\n"
+	" cbnz %w1, 1b\n"
+	"2:"
+		: "=&r"(tmp), "=&r"(res)
+		: "r" (p1), "r" (cmpval), "r" (newval)
+		: "cc", "memory"
+	);
+}
+
+//void test18() {
+//  test18a();
+//}
+#endif
+
+int main()
+{
+#ifdef TEST01
+  test01();
+#endif
+#ifdef TEST02
+  test02();
+#endif
+#ifdef TEST03
+  test03();
+#endif
+#ifdef TEST04
+  test04();
+#endif
+#ifdef TEST05
+  test05();
+#endif
+#ifdef TEST06
+  test06();
+#endif
+#ifdef TEST07
+  test07();
+#endif
+#ifdef TEST08
+  test08();
+#endif
+#ifdef TEST09
+  test09();
+#endif
+#ifdef TEST10
+  test10();
+#endif
+#ifdef TEST11
+  test11();
+#endif
+#ifdef TEST12
+  test12();
+#endif
+#ifdef TEST13
+  test13();
+#endif
+#ifdef TEST14
+  test14();
+#endif
+#ifdef TEST15
+  test15();
+#endif
+#ifdef TEST17
+  test17();
+#endif
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0028-inlineasm/expected.txt b/testsuite/c_test/sanity_test/SANITY0028-inlineasm/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0028-inlineasm/test.cfg b/testsuite/c_test/sanity_test/SANITY0028-inlineasm/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0958817be27b81192c30be8332d99ddcb7e28b59
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0028-inlineasm/test.cfg
@@ -0,0 +1,2 @@
+compile(asm)
+run(asm)
diff --git a/testsuite/c_test/sanity_test/SANITY0029-extensions/expected.txt b/testsuite/c_test/sanity_test/SANITY0029-extensions/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0029-extensions/extensions.c b/testsuite/c_test/sanity_test/SANITY0029-extensions/extensions.c
new file mode 100644
index 0000000000000000000000000000000000000000..538ad2a4736ad6793964e7a4497472eeba7f5c26
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0029-extensions/extensions.c
@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+unsigned char u8 = 0x80;
+unsigned short u16 = 0x8000;
+unsigned int u32 = 0x80000000;
+unsigned long long u64 = 0x8000000000000000ULL;
+
+signed char i8 = 0x80;
+signed short i16 = 0x8000;
+signed int i32 = 0x80000000;
+signed long long i64 = 0x8000000000000000LL;
+
+int main() {
+  signed char ti8 = u8;
+  if (ti8 != 0xffffff80) abort();
+  signed short ti16 = u8;
+  if (ti16 != 0x80) abort();
+  signed int ti32 = u8;
+  if (ti32 != 0x80) abort();
+  signed long long ti64 = u8;
+  if (ti64 != 0x80) abort();
+
+  ti8 = u16;
+  if (ti8 != 0) abort();
+  ti16 = u16;
+  if (ti16 != 0xffff8000) abort();
+  ti32 = u16;
+  if (ti32 != 0x8000) abort();
+  ti64 = u16;
+  if (ti64 != 0x8000) abort();
+
+  ti8 = u32;
+  if (ti8 != 0) abort();
+  ti16 = u32;
+  if (ti16 != 0) abort();
+  ti32 = u32;
+  if (ti32 != 0x80000000) abort();
+  ti64 = u32;
+  if (ti64 != 0x80000000) abort();
+
+  ti8 = u64;
+  if (ti8 != 0) abort();
+  ti16 = u64;
+  if (ti16 != 0) abort();
+  ti32 = u64;
+  if (ti32 != 0) abort();
+  ti64 = u64;
+  if (ti64 != 0x8000000000000000) abort();
+
+  unsigned char tu8 = i8;
+  if (tu8 != 0x80) abort();
+  unsigned short tu16 = i8;
+  if (tu16 != 0xff80) abort();
+  unsigned int tu32 = i8;
+  if (tu32 != 0xffffff80) abort();
+  unsigned long long tu64 = i8;
+  if (tu64 != 0xffffffffffffff80) abort();
+
+  tu8 = i16;
+  if (tu8 != 0) abort();
+  tu16 = i16;
+  if (tu16 != 0x8000) abort();
+  tu32 = i16;
+  if (tu32 != 0xffff8000) abort();
+  tu64 = i16;
+  if (tu64 != 0xffffffffffff8000) abort();
+
+  tu8 = i32;
+  if (tu8 != 0) abort();
+  tu16 = i32;
+  if (tu16 != 0) abort();
+  tu32 = i32;
+  if (tu32 != 0x80000000) abort();
+  tu64 = i32;
+  if (tu64 != 0xffffffff80000000) abort();
+
+  tu8 = i64;
+  if (tu8 != 0) abort();
+  tu16 = i64;
+  if (tu16 != 0) abort();
+  tu32 = i64;
+  if (tu32 != 0) abort();
+  tu64 = i64;
+  if (tu64 != 0x8000000000000000) abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0029-extensions/test.cfg b/testsuite/c_test/sanity_test/SANITY0029-extensions/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6202a5eb32bef302cf6f5e4d2f4a9d8765ca048d
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0029-extensions/test.cfg
@@ -0,0 +1,2 @@
+compile(extensions)
+run(extensions)
diff --git a/testsuite/c_test/sanity_test/SANITY0029-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0029-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0029-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0029-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cf5f50caba3407ba37cccda967a3fe111d85751c
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0029-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test1)
+run(test1)
diff --git a/testsuite/c_test/sanity_test/SANITY0029-neonintrinscs/test1.c b/testsuite/c_test/sanity_test/SANITY0029-neonintrinscs/test1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a8ef4ea4013c74bad2d9cf7b4ecb69e32973b1b9
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0029-neonintrinscs/test1.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "arm_neon.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+uint32x4_t foo(void *p) {
+   uint16x8_t u16 = vld1q_u16(p);
+   return vpaddlq_u16(u16);
+}
+
+uint16_t foo2(void *p) {
+   uint16x8_t u16 = vld1q_u16(p);
+   return vaddvq_u16(u16);
+}
+
+int main()
+{
+   char s[] = {1,1,1,1, 2,2,2,2, 3,3,3,3, 4,4,4,4};
+   uint32x4_t f1 = foo( &s );
+   uint32_t t1, t2, t3, t4;
+   t1 = vgetq_lane_u32(f1, 0);
+   // printf("t0: 0x%x\n", t1);
+   t2 = vgetq_lane_u32(f1, 1);
+   // printf("t1: 0x%x\n", t2);
+   t3 = vgetq_lane_u32(f1, 2);
+   // printf("t2: 0x%x\n", t3);
+   t4 = vgetq_lane_u32(f1, 3);
+   // printf("t3: 0x%x\n", t4);
+   if (t1 != 0x202 || t2 != 0x404 || t3 != 0x606 || t4 != 0x808)
+     abort();
+
+   // printf("-- Test 2: --\n");
+   uint16_t f2 = foo2( &s );
+   // printf("f2: %d\n", f2);
+   if (f2 != 0x1414)
+     abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0030-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0030-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0030-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0030-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..af42566d9e3e10cc082e253de4cd3dbbe5d82774
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0030-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test2)
+run(test2)
diff --git a/testsuite/c_test/sanity_test/SANITY0030-neonintrinscs/test2.c b/testsuite/c_test/sanity_test/SANITY0030-neonintrinscs/test2.c
new file mode 100644
index 0000000000000000000000000000000000000000..1fd7deaad86a5eedc0eb3db5b99efd7e4a1b0146
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0030-neonintrinscs/test2.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "arm_neon.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+uint8x16_t foo(void *p) {
+   uint8x16_t u1 = vld1q_u8(p);
+   uint8x16_t u2 = vrev32q_u8(u1);        /* reverse */
+   return vextq_u8(u1, u2, 8);            /* merge at 8 */
+}
+
+int main()
+{
+   char s[] = {1,1,2,2, 3,3,4,4, 5,5,6,6, 7,7,8,8};
+   uint8x16_t f2 = foo( &s );
+   long u8m[2];
+   vst1q_u8((void*)&u8m, f2);
+   // printf("f2: 0x%lx,0x%lx\n", u8m[0], u8m[1]);
+   if (u8m[0] != 0x808070706060505 || u8m[1] != 0x303040401010202)
+     abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0031-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0031-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0031-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0031-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2aba26faad0334fdc8cc0154e749c97775fb9af7
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0031-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test3)
+run(test3)
diff --git a/testsuite/c_test/sanity_test/SANITY0031-neonintrinscs/test3.c b/testsuite/c_test/sanity_test/SANITY0031-neonintrinscs/test3.c
new file mode 100644
index 0000000000000000000000000000000000000000..d24ed9943e7474adc764a00636139d3b01e8bc5f
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0031-neonintrinscs/test3.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "arm_neon.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+uint32_t foo(void *p) {
+   uint32x4_t u1 = vld1q_u32(p);
+   uint32_t uit = vgetq_lane_u32(u1, 3);
+   unsigned int ui = uit;
+   if (ui != 4)
+     abort();
+   return uit;
+}
+
+int main()
+{
+   unsigned int s[] = {1, 2, 3, 4};
+   uint32_t ui = foo( &s );
+   uint32x4_t t = {1, 1, 1, 1};
+   t = vsetq_lane_u32(ui, t, 3);
+   ui = vgetq_lane_u32(t, 1);
+   if (ui != 1)
+     abort();
+   if (vgetq_lane_u32(t, 3) != 4)
+     abort();
+   // printf("t: 0x%x 0x%x\n", ui, vgetq_lane_u32(t, 3));
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0032-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0032-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0032-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0032-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4a845c3ef8940b01383d9bac5a523ea255a50d8a
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0032-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test4)
+run(test4)
diff --git a/testsuite/c_test/sanity_test/SANITY0032-neonintrinscs/test4.c b/testsuite/c_test/sanity_test/SANITY0032-neonintrinscs/test4.c
new file mode 100644
index 0000000000000000000000000000000000000000..7e0772e89bfcc5dbdac500b67fa2dfab8526d143
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0032-neonintrinscs/test4.c
@@ -0,0 +1,53 @@
+/*
+2
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "arm_neon.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+int32x4_t foo1(void *p) {
+   return vandq_s32( vld1q_s32(p), vdupq_n_s32(3));
+}
+
+uint16x8_t foo2(void *p, void *q) {
+   return vandq_u16( vld1q_u16(p), vld1q_u16(q));
+}
+
+int main()
+{
+   int s[] = {7,7,7,7};
+   int32x4_t r = foo1( &s );
+   int t[4];
+   vst1q_s32((void*)&t, r);
+   // printf("r: %x %x %x %x\n", t[0], t[1], t[2], t[3]);
+   if (t[0] != 3 || t[1] != 3 || t[2] != 3 || t[3] != 3)
+     abort();
+
+   // printf("-- Test 4b: uint16x8_t --\n");
+   unsigned short s2[] = {7,7,7,7,7,7,7,7};
+   unsigned short t2[] = {3,3,3,3,3,3,3,3};
+   uint32x4_t r2 = vpaddlq_u16( foo2( &s2, &t2 ) );
+   // printf("r2: %x %x %x %x\n",
+   //     vgetq_lane_u32(r2, 0),
+   //     vgetq_lane_u32(r2, 1),
+   //     vgetq_lane_u32(r2, 2),
+   //     vgetq_lane_u32(r2, 0));
+   if (vgetq_lane_u32(r2, 0) != 6 ||
+       vgetq_lane_u32(r2, 1) != 6 ||
+       vgetq_lane_u32(r2, 2) != 6 ||
+       vgetq_lane_u32(r2, 0) != 6)
+     abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0033-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0033-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0033-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0033-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6e218f5f160ec92e371b4491c51362852d2cc123
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0033-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test5)
+run(test5)
diff --git a/testsuite/c_test/sanity_test/SANITY0033-neonintrinscs/test5.c b/testsuite/c_test/sanity_test/SANITY0033-neonintrinscs/test5.c
new file mode 100644
index 0000000000000000000000000000000000000000..7e0772e89bfcc5dbdac500b67fa2dfab8526d143
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0033-neonintrinscs/test5.c
@@ -0,0 +1,53 @@
+/*
+2
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "arm_neon.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+int32x4_t foo1(void *p) {
+   return vandq_s32( vld1q_s32(p), vdupq_n_s32(3));
+}
+
+uint16x8_t foo2(void *p, void *q) {
+   return vandq_u16( vld1q_u16(p), vld1q_u16(q));
+}
+
+int main()
+{
+   int s[] = {7,7,7,7};
+   int32x4_t r = foo1( &s );
+   int t[4];
+   vst1q_s32((void*)&t, r);
+   // printf("r: %x %x %x %x\n", t[0], t[1], t[2], t[3]);
+   if (t[0] != 3 || t[1] != 3 || t[2] != 3 || t[3] != 3)
+     abort();
+
+   // printf("-- Test 4b: uint16x8_t --\n");
+   unsigned short s2[] = {7,7,7,7,7,7,7,7};
+   unsigned short t2[] = {3,3,3,3,3,3,3,3};
+   uint32x4_t r2 = vpaddlq_u16( foo2( &s2, &t2 ) );
+   // printf("r2: %x %x %x %x\n",
+   //     vgetq_lane_u32(r2, 0),
+   //     vgetq_lane_u32(r2, 1),
+   //     vgetq_lane_u32(r2, 2),
+   //     vgetq_lane_u32(r2, 0));
+   if (vgetq_lane_u32(r2, 0) != 6 ||
+       vgetq_lane_u32(r2, 1) != 6 ||
+       vgetq_lane_u32(r2, 2) != 6 ||
+       vgetq_lane_u32(r2, 0) != 6)
+     abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0034-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0034-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0034-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0034-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ab4b25a391fe12a9ff6a9706987378802140fd28
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0034-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test6)
+run(test6)
diff --git a/testsuite/c_test/sanity_test/SANITY0034-neonintrinscs/test6.c b/testsuite/c_test/sanity_test/SANITY0034-neonintrinscs/test6.c
new file mode 100644
index 0000000000000000000000000000000000000000..eaa326e6a1a2d05d6f815ede9753ee5325303df7
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0034-neonintrinscs/test6.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "arm_neon.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main()
+{
+   char s[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+   uint8x16_t p = vld1q_u8((void*)s);
+   uint8x16_t idx = vrev32q_u8(p);
+   char r[17] = {0};
+   uint8x16_t x;
+
+   x = vqtbl1q_u8(p, idx);  // reverse
+   vst1q_u8((void*)r, x);
+   //printf("r = %s\n", r);
+   char answer[] =  {5, 4, 3, 2, 9, 8, 7, 6, 13, 12, 11, 10, 0, 16, 15, 14};
+   if (memcmp(r, answer, 16))
+     abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0035-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0035-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0035-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0035-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8204c901339f845769d526ec9a07811c65a467aa
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0035-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test7)
+run(test7)
diff --git a/testsuite/c_test/sanity_test/SANITY0035-neonintrinscs/test7.c b/testsuite/c_test/sanity_test/SANITY0035-neonintrinscs/test7.c
new file mode 100644
index 0000000000000000000000000000000000000000..f8d20d4c18095d8adfec689a8919146e928efec6
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0035-neonintrinscs/test7.c
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "arm_neon.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+void foo1()
+{
+   uint32x2_t c = {1,1};
+
+   uint8x16_t x = vdupq_n_u8(10);
+   uint64x2_t y = vreinterpretq_u64_u8(x);
+   uint64x2_t z = vmlal_u32(y, c, vdup_n_u32(1));
+   uint32x4_t r = vreinterpretq_u32_u64(z);
+   //printf("r: 0x%x 0x%x 0x%x 0x%x\n", vgetq_lane_u32(r, 0), vgetq_lane_u32(r, 1),
+   //     vgetq_lane_u32(r, 2), vgetq_lane_u32(r, 3));
+   // printf("z = 0x%lx, 0x%lx\n", vget_high_u64(z), vget_low_u64(z));
+   if (vgetq_lane_u32(r, 0) != 0xa0a0a0b || vgetq_lane_u32(r, 1) != 0xa0a0a0a ||
+       vgetq_lane_u32(r, 2) != 0xa0a0a0b || vgetq_lane_u32(r, 3) != 0xa0a0a0a)
+     abort();
+}
+
+void foo2() {
+   uint64x2_t x = { 2, 4 };
+   uint32x4_t zero = { 0, 0, 0, 0 };
+   uint32x4_t r = veorq_u32( vreinterpretq_u32_u64(x), zero );
+   if (vgetq_lane_u32(r, 0) != 2)
+     abort();
+   if (vgetq_lane_u32(r, 1) != 0)
+     abort();
+   if (vgetq_lane_u32(r, 2) != 4)
+     abort();
+   if (vgetq_lane_u32(r, 3) != 0)
+     abort();
+}
+
+void foo3() {
+   uint64x2_t x = { 2, 4 };
+   uint64x2_t zero = { 0, 0 };
+   uint32x4_t r = vreinterpretq_u32_u64( veorq_u64( x, zero ) );
+   if (vgetq_lane_u32(r, 0) != 2)
+     abort();
+   if (vgetq_lane_u32(r, 1) != 0)
+     abort();
+   if (vgetq_lane_u32(r, 2) != 4)
+     abort();
+   if (vgetq_lane_u32(r, 3) != 0)
+     abort();
+}
+
+void foo4() {
+#if 0     // Turn off temporarily, awaiting arm_neon.h to be updated. Turn on
+          // again after that.
+  uint32x2_t a = {1, 0};
+  uint32x2_t b = vdup_n_u32(10);
+  uint32x4_t r = vreinterpretq_u32_u64( vmull_u32(a, b) );
+  if (vgetq_lane_u32(r, 0) != 0xa || vgetq_lane_u32(r, 1) != 0 ||
+      vgetq_lane_u32(r, 2) != 0   || vgetq_lane_u32(r, 3) != 0)
+    abort();
+#endif
+}
+
+int main()
+{
+   foo1();
+   foo2();
+   foo3();
+   foo4();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0036-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0036-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0036-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0036-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..556d304e2931a7fded5ddcd30cc8a5bb7e6a3f63
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0036-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test8)
+run(test8)
diff --git a/testsuite/c_test/sanity_test/SANITY0036-neonintrinscs/test8.c b/testsuite/c_test/sanity_test/SANITY0036-neonintrinscs/test8.c
new file mode 100644
index 0000000000000000000000000000000000000000..b1bf636d0f81943da445b521c76c29c2c4d72b18
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0036-neonintrinscs/test8.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "arm_neon.h"
+#include <stdlib.h>
+
+int32x4_t f1( int32x4_t p, int32x4_t q )
+{
+   return p << q;
+}
+
+uint32x2_t f2( uint32x2_t p, uint32x2_t q )
+{
+   return p >> q;
+}
+
+int main()
+{
+   int32x4_t x = vdupq_n_s32( 1 );
+   int32x4_t y = vdupq_n_s32( 1 );
+
+   int32x4_t m1 = f1( x, y );
+   uint32x4_t c1 = m1 == 2;
+   if (vgetq_lane_u32(c1, 0) != 0xffffffff ||
+       vgetq_lane_u32(c1, 1) != 0xffffffff ||
+       vgetq_lane_u32(c1, 2) != 0xffffffff ||
+       vgetq_lane_u32(c1, 3) != 0xffffffff)
+     abort();
+
+   uint32x2_t x2 = vdup_n_u32( 2 );
+   uint32x2_t y2 = vdup_n_u32( 1 );
+
+   uint32x2_t m2 = f2( x2, y2 );
+   uint32x2_t c2 = m2 == y2;
+   if (vget_lane_u32(c2, 0) != 0xffffffff ||
+       vget_lane_u32(c2, 1) != 0xffffffff)
+     abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0037-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0037-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0037-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0037-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9ce54eca7b59d2a5008f64eaba2a5559ab4ad78f
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0037-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test9)
+run(test9)
diff --git a/testsuite/c_test/sanity_test/SANITY0037-neonintrinscs/test9.c b/testsuite/c_test/sanity_test/SANITY0037-neonintrinscs/test9.c
new file mode 100644
index 0000000000000000000000000000000000000000..3bbe0841be1bda3fb5fa046ca211c054e2f7141b
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0037-neonintrinscs/test9.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include "arm_neon.h"
+#include <stdlib.h>
+
+int main()
+{
+   uint16x8_t s1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
+
+   uint16x8_t r1 = s1 == s1;
+   uint16x8_t r2 = vceqq_u16(s1, s1);
+   uint16x8_t r3 = r1 == r2;         // all 1s
+   int64x2_t r4 = (int64x2_t)r3;
+   int64x2_t r5 = ~r4;               // all 0s
+   uint32x4_t r6 = (uint32x4_t) (r5 < 0);  // zero compare instr
+   if (vgetq_lane_u32(r6, 0) != 0 ||
+       vgetq_lane_u32(r6, 1) != 0 ||
+       vgetq_lane_u32(r6, 2) != 0 ||
+       vgetq_lane_u32(r6, 3) != 0)
+     abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0038-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0038-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0038-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0038-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ecb64f630f4b4231ae8763ffcfe4a89f26538903
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0038-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test10)
+run(test10)
diff --git a/testsuite/c_test/sanity_test/SANITY0038-neonintrinscs/test10.c b/testsuite/c_test/sanity_test/SANITY0038-neonintrinscs/test10.c
new file mode 100644
index 0000000000000000000000000000000000000000..23f99d43ae5006c903eba59c0a31d8966912d7df
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0038-neonintrinscs/test10.c
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#include "arm_neon.h"
+#include "stdlib.h"
+
+uint64x1_t foo1( uint64x2_t s )
+{
+   return vget_high_u64(s) + vget_low_u64(s);
+}
+
+uint16x4_t foo2( uint16x8_t s )
+{
+   return vget_high_u16(s) + vget_low_u16(s);
+}
+
+int64x1_t foo3( int32x2_t s )
+{
+   return vpaddl_s32(s);
+}
+
+int main()
+{
+   uint64x2_t s = { 10, 20 };
+   uint64x1_t r1 = foo1( s );
+   if ((long)r1 != 30)
+     abort();
+
+#if 0
+   uint16x8_t s2 = { 1,1,1,1,2,2,2,2 };
+   uint16x4_t r2 = foo2( s2 );
+   if (vget_lane_u16(r2,0) != 3 ||
+       vget_lane_u16(r2,3) != 3)
+     abort();
+
+   int32x2_t s3 = { 10, 20 };
+   int64x1_t t3 = foo3( s3 );
+   if ((long)t3 != 30)
+     abort();
+#endif
+}
+
diff --git a/testsuite/c_test/sanity_test/SANITY0039-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0039-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0039-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0039-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b919065076cfc98ea6b0364525144da3220d5dc9
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0039-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test11)
+run(test11)
diff --git a/testsuite/c_test/sanity_test/SANITY0039-neonintrinscs/test11.c b/testsuite/c_test/sanity_test/SANITY0039-neonintrinscs/test11.c
new file mode 100644
index 0000000000000000000000000000000000000000..2000c202de4fdaf027df0550b64c73a172b03c40
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0039-neonintrinscs/test11.c
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#include "arm_neon.h"
+#include <stdlib.h>
+
+uint32x2x2_t foo( uint32x4_t data, uint32x2x2_t a )
+{
+   uint32x2x2_t r = vzip_u32( vget_low_u32(data), vget_high_u32(data) );
+   uint32x2_t t1 = r.val[0] == a.val[0];
+   uint32x2_t t2 = r.val[1] == a.val[1];
+
+   if (vget_lane_u32(t1, 0) != 0xffffffff ||
+       vget_lane_u32(t1, 1) != 0xffffffff ||
+       vget_lane_u32(t2, 0) != 0xffffffff ||
+       vget_lane_u32(t2, 1) != 0xffffffff)
+     abort();
+
+   return r;
+}
+
+int main()
+{
+   uint32x4_t data = { 10, 20, 30, 40 };
+   uint32x2x2_t a;
+   uint32x2x2_t r;
+
+   a.val[0] = vset_lane_u32(10, a.val[0], 0);
+   a.val[0] = vset_lane_u32(30, a.val[0], 1);
+   a.val[1] = vset_lane_u32(20, a.val[1], 0);
+   a.val[1] = vset_lane_u32(40, a.val[1], 1);
+
+   r = foo( data, a );
+
+   uint32x2_t a1 = { 1, 3 };
+   uint32x2_t b1 = { 2, 4 };
+   uint32x2_t m1 = { 1, 2 };
+   uint32x2_t m2 = { 4, 5 };
+
+   uint32x2x2_t c = vzip_u32( a1, b1 );
+   uint32x2_t r1 = c.val[0] == m1;  // vzip_u32(a,b).val[0] == m1;
+   if (vget_lane_u32(r1, 0) != 0xffffffff ||
+       vget_lane_u32(r1, 1) != 0xffffffff)
+     abort();
+
+   m1 = c.val[1] + 1;
+   uint32x2_t r2 = m1 == m2;
+   if (vget_lane_u32(r2, 0) != 0xffffffff ||
+       vget_lane_u32(r2, 1) != 0xffffffff)
+     abort();
+}
+
+
diff --git a/testsuite/c_test/sanity_test/SANITY0040-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0040-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0040-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0040-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7456f25b9e13f05136401158a13432989b005921
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0040-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test12)
+run(test12)
diff --git a/testsuite/c_test/sanity_test/SANITY0040-neonintrinscs/test12.c b/testsuite/c_test/sanity_test/SANITY0040-neonintrinscs/test12.c
new file mode 100644
index 0000000000000000000000000000000000000000..d3e945572ed03878ede650a40b80c59c8c142786
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0040-neonintrinscs/test12.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#include "arm_neon.h"
+#include <stdlib.h>
+
+/* Testing calling convention of 64x1 */
+
+uint64x1_t foo1( uint64x1_t x, uint64x1_t y )
+{
+   return x + y;
+}
+
+int64x1_t G = { 40 };
+int64x1_t foo2() {
+   return G;
+}
+
+int64x1_t foo3( int64x1_t x )
+{
+   return x;
+}
+
+typedef struct S {
+   int x;
+   int64x1_t y;
+} SS;
+
+int main()
+{
+   uint64x1_t a = { 10 };
+   uint64x1_t b = { 20 };
+
+   uint64x1_t r1 = foo1( a, b );
+   if ((uint64_t)r1 != 30)
+     abort();
+
+   int64x1_t r2 = foo3( foo2() );
+   if ((int64_t)r2 != 40)
+     abort();
+
+   SS s1 = { 1, 50 };
+   int64x1_t r3 = foo3( s1.y );
+   if ((int64_t)r3 != 50)
+     abort();
+
+   SS s2 = { 1, 50 };
+   SS *ps = &s2;
+   int64x1_t r4 = foo3( ps->y );
+   if ((int64_t)r4 != 50)
+     abort();
+
+   int64x1_t c = { 60 };
+   int64x1_t *p = &c;
+   int64x1_t **q = &p;
+   int64x1_t r5 = foo3( **q );
+   if ((int64_t)r5 != 60)
+     abort();
+
+    int64x1_t (*fp)(int64x1_t) = foo3;
+    uint64x1_t r6 = (uint64x1_t)foo3( fp(c) );
+    if ((int64_t)r6 != 60)
+      abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0041-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0041-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0041-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0041-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bb07d2bbd013683071ef14e5e3d7340cdf052277
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0041-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test13)
+run(test13)
diff --git a/testsuite/c_test/sanity_test/SANITY0041-neonintrinscs/test13.c b/testsuite/c_test/sanity_test/SANITY0041-neonintrinscs/test13.c
new file mode 100644
index 0000000000000000000000000000000000000000..147355f7dcbafdc054e94d706bdd2e3a06feffbe
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0041-neonintrinscs/test13.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#include "arm_neon.h"
+#include <stdlib.h>
+
+int main()
+{
+  uint32x4_t b128  = { 1,2,3,4 };
+  volatile uint16x4_t b64_1 =  vmovn_u32(b128);
+  volatile uint16x8_t b64_2 = vmovn_high_u32(b64_1, b128);
+  if (vgetq_lane_u16(b64_2,0) != 1 ||
+      vgetq_lane_u16(b64_2,1) != 2 ||
+      vgetq_lane_u16(b64_2,2) != 3 ||
+      vgetq_lane_u16(b64_2,3) != 4)
+    abort();
+
+  int32x4_t c128  = { 1,2,3,4 };
+  int32x2_t c64_1 = { 10, 20 };
+  int64x2_t c64_2 = vmovl_s32(c64_1);
+  if (vgetq_lane_s64(c64_2, 0) != 10 ||
+      vgetq_lane_s64(c64_2, 1) != 20)
+    abort();
+  int64x2_t c64_3 = vmovl_high_s32(c128);
+  if (vgetq_lane_s64(c64_3, 0) != 3 ||
+      vgetq_lane_s64(c64_3, 1) != 4)
+    abort();
+
+  uint32x4_t d128 = vdupq_n_u32(10);    // 10,10,10,10
+  uint16x4_t d64  = { 1,2 };            // 1,2
+  volatile uint32x4_t d128_1 = vaddw_u16(d128, d64);  // 11,12,0,0
+  uint16x8_t d128_2 = { 0,0,0,0,13,14,0,0 };
+  volatile uint32x4_t d128_3 = vaddw_high_u16(d128_1, d128_2); // 11,12,13,14
+  if (vgetq_lane_u32(d128_3, 0) != 24 ||
+      vgetq_lane_u32(d128_3, 1) != 26)
+    abort();
+
+  int16x4_t e64_1 = vdup_n_s16(20);     // 20,20,20,20
+  int16x4_t e64_2 = vdup_n_s16(1);      // 1,1,1,1
+  volatile int32x4_t e128 = vaddl_s16(e64_1, e64_2);  // 21,21,21,21
+  if (vgetq_lane_s32(e128, 0) != vgetq_lane_s32(e128, 3) ||
+      vgetq_lane_s32(e128, 1) != 21)
+    abort();
+  int32x4_t e128_2 = vdupq_n_s32(2);
+  volatile int64x2_t e128_3 = vaddl_high_s32(e128, e128_2);
+  if (vgetq_lane_s64(e128_3, 0) != 23 ||
+      vgetq_lane_s64(e128_3, 1) != 23)
+    abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0042-neonintrinscs/expected.txt b/testsuite/c_test/sanity_test/SANITY0042-neonintrinscs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/sanity_test/SANITY0042-neonintrinscs/test.cfg b/testsuite/c_test/sanity_test/SANITY0042-neonintrinscs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0ab829ebbfd2950230fcaf7a141b0d0614a19d0f
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0042-neonintrinscs/test.cfg
@@ -0,0 +1,2 @@
+compile(test14)
+run(test14)
diff --git a/testsuite/c_test/sanity_test/SANITY0042-neonintrinscs/test14.c b/testsuite/c_test/sanity_test/SANITY0042-neonintrinscs/test14.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb651a7863596bcac1c246b461c07ad54777fcd6
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0042-neonintrinscs/test14.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) [2021] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+#include "arm_neon.h"
+#include "stdlib.h"
+
+int main()
+{
+   uint32x4_t a = vdupq_n_u32(10);
+   uint16x8_t b = vdupq_n_u16(2);
+   volatile uint32x4_t c = vpadalq_u16(a, b);
+   if (vgetq_lane_u32(c,0) != 14 ||
+       vgetq_lane_u32(c,1) != 14 ||
+       vgetq_lane_u32(c,2) != 14 ||
+       vgetq_lane_u32(c,3) != 14)
+    abort();
+
+   int64x1_t x = vdup_n_s64(3);
+   int32x2_t y = vdup_n_s32(2);
+   volatile int64x1_t z = vpadal_s32(x, y);
+   if ((int64_t)z != 7)
+     abort();
+
+   int32x2_t i = vdup_n_s32(10);
+   int32x2_t j = vdup_n_s32(7);
+   volatile int64x2_t k = vabdl_s32(j, i);  // 3 3
+   if (vgetq_lane_s64(k,0) != 3 ||
+       vgetq_lane_s64(k,1) != 3)
+    abort();
+
+   uint32x4_t i2 = vdupq_n_u32(100);
+   uint32x4_t j2 = vdupq_n_u32(1);
+   volatile uint64x2_t l2 = vabdl_high_u32(j2, i2);
+   if (vgetq_lane_u64(l2,0) != 99 ||
+       vgetq_lane_u64(l2,1) != 99)
+    abort();
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0043-attr_aligned/attr_aligned.c b/testsuite/c_test/sanity_test/SANITY0043-attr_aligned/attr_aligned.c
new file mode 100644
index 0000000000000000000000000000000000000000..2e18e2becaba6c14e0bfc35f38cf122f70ba6244
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0043-attr_aligned/attr_aligned.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stddef.h>
+
+#define STR(s) #s
+
+#define SHOW_STRUCT(t)                                                         \
+  do {                                                                         \
+    printf(STR(t) " is size %zd, align %zd\n", sizeof(struct t),               \
+           _Alignof(struct t));                                                \
+    printf("  a is at offset %zd\n", offsetof(struct t, a));                   \
+    printf("  b is at offset %zd\n", offsetof(struct t, b));                   \
+  } while (0)
+
+
+struct __attribute__((aligned(16))) my_struct
+{
+  int a;
+  char b;
+};
+
+struct my_struct_reduced
+{
+  char a;
+  int b __attribute__((aligned (2)));
+};
+
+struct my_struct_packed
+{
+  char a;
+  int b __attribute__((packed)) __attribute__((aligned (2)));
+};
+
+int main() {
+  SHOW_STRUCT(my_struct);
+  SHOW_STRUCT(my_struct_reduced);
+  SHOW_STRUCT(my_struct_packed);
+  return 0;
+}
diff --git a/testsuite/c_test/sanity_test/SANITY0043-attr_aligned/expected.txt b/testsuite/c_test/sanity_test/SANITY0043-attr_aligned/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a4469ceb4ea3be515e6f0adcb5297eff2e029a6c
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0043-attr_aligned/expected.txt
@@ -0,0 +1,9 @@
+my_struct is size 16, align 16
+  a is at offset 0
+  b is at offset 4
+my_struct_reduced is size 8, align 4
+  a is at offset 0
+  b is at offset 4
+my_struct_packed is size 6, align 2
+  a is at offset 0
+  b is at offset 2
diff --git a/testsuite/c_test/sanity_test/SANITY0043-attr_aligned/test.cfg b/testsuite/c_test/sanity_test/SANITY0043-attr_aligned/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4a70bc034671c14b6e9549118687206c4f2127ba
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0043-attr_aligned/test.cfg
@@ -0,0 +1,2 @@
+compile(attr_aligned)
+run(attr_aligned)
\ No newline at end of file
diff --git a/testsuite/c_test/sanity_test/SANITY0044-attr_fallthrough/attr_fallthrough.c b/testsuite/c_test/sanity_test/SANITY0044-attr_fallthrough/attr_fallthrough.c
new file mode 100644
index 0000000000000000000000000000000000000000..fb8e3564919b77251e702e137ede2293e9734e7e
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0044-attr_fallthrough/attr_fallthrough.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+
+int main() {
+  int cond = 1;
+  switch (cond)
+  {
+    case 1:
+      cond += 10;
+      __attribute__((fallthrough));
+    case 2:
+      printf("Fallthrough passed var=%d\n", cond);
+      return 0;
+  }
+}
+
diff --git a/testsuite/c_test/sanity_test/SANITY0044-attr_fallthrough/expected.txt b/testsuite/c_test/sanity_test/SANITY0044-attr_fallthrough/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d7536845cfa0f66d7b95798ecc070957bd9fbaeb
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0044-attr_fallthrough/expected.txt
@@ -0,0 +1 @@
+Fallthrough passed var=11
diff --git a/testsuite/c_test/sanity_test/SANITY0044-attr_fallthrough/test.cfg b/testsuite/c_test/sanity_test/SANITY0044-attr_fallthrough/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..72cfbe965c8ac7ebb9f107c41e8112e309bd496d
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0044-attr_fallthrough/test.cfg
@@ -0,0 +1,2 @@
+compile(attr_fallthrough)
+run(attr_fallthrough)
\ No newline at end of file
diff --git a/testsuite/c_test/sanity_test/SANITY0045-pragma_packed/expected.txt b/testsuite/c_test/sanity_test/SANITY0045-pragma_packed/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..23e89525f04c9ea95e37e91828e9b022e9dae522
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0045-pragma_packed/expected.txt
@@ -0,0 +1,8 @@
+A size 16, A align 8
+a is at offset 0
+b is at offset 4
+c is at offset 8
+B size 13, B align 1
+a is at offset 0
+b is at offset 4
+c is at offset 5
diff --git a/testsuite/c_test/sanity_test/SANITY0045-pragma_packed/pragma_packed.c b/testsuite/c_test/sanity_test/SANITY0045-pragma_packed/pragma_packed.c
new file mode 100644
index 0000000000000000000000000000000000000000..0fedec3ab834dadeffbff88a08e537db38b27b02
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0045-pragma_packed/pragma_packed.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved.
+ *
+ * Licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+
+struct A {
+  int a;
+  char b;
+  long c;
+};
+
+#pragma pack(push, 1)
+
+struct B {
+  int a;
+  char b;
+  long c;
+};
+
+int main() {
+  printf("A size %zd, A align %zd\n", sizeof(struct A), _Alignof(struct A));
+  printf("a is at offset %zd\n", offsetof(struct A, a));
+  printf("b is at offset %zd\n", offsetof(struct A, b));
+  printf("c is at offset %zd\n", offsetof(struct A, c));
+
+  printf("B size %zd, B align %zd\n", sizeof(struct B), _Alignof(struct B));
+  printf("a is at offset %zd\n", offsetof(struct B, a));
+  printf("b is at offset %zd\n", offsetof(struct B, b));
+  printf("c is at offset %zd\n", offsetof(struct B, c));
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/sanity_test/SANITY0045-pragma_packed/test.cfg b/testsuite/c_test/sanity_test/SANITY0045-pragma_packed/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5f472e1709f01aaef4dc58c9f7f40d04124a5613
--- /dev/null
+++ b/testsuite/c_test/sanity_test/SANITY0045-pragma_packed/test.cfg
@@ -0,0 +1,2 @@
+compile(pragma_packed)
+run(pragma_packed)
diff --git a/testsuite/c_test/simple_test/SIM00001-hello_world/expected.txt b/testsuite/c_test/simple_test/SIM00001-hello_world/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..af5626b4a114abcb82d63db7c8082c3c4756e51b
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00001-hello_world/expected.txt
@@ -0,0 +1 @@
+Hello, world!
diff --git a/testsuite/c_test/simple_test/SIM00001-hello_world/hello_world.c b/testsuite/c_test/simple_test/SIM00001-hello_world/hello_world.c
new file mode 100644
index 0000000000000000000000000000000000000000..39d5a645744c69ced62f590a975427c86b4cc517
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00001-hello_world/hello_world.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+int main()
+{
+    printf("Hello, world!\n");
+    return 0;
+}
diff --git a/testsuite/c_test/simple_test/SIM00001-hello_world/test.cfg b/testsuite/c_test/simple_test/SIM00001-hello_world/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..158bb2abc23b4e9fa92ef6c0e24a94be3ad4cd93
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00001-hello_world/test.cfg
@@ -0,0 +1,2 @@
+compile(hello_world)
+run(hello_world)
diff --git a/testsuite/c_test/simple_test/SIM00002-variables_initialization_test1/expected.txt b/testsuite/c_test/simple_test/SIM00002-variables_initialization_test1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..901d3620a741ff6744c24bafae1f050cf93d5970
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00002-variables_initialization_test1/expected.txt
@@ -0,0 +1,11 @@
+a
+b
+c
+1
+2
+3
+4
+5
+1.000000
+0.007623
+100
diff --git a/testsuite/c_test/simple_test/SIM00002-variables_initialization_test1/test.cfg b/testsuite/c_test/simple_test/SIM00002-variables_initialization_test1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3b3fc6dc32cfd032d7c1282090ce9f442165daa7
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00002-variables_initialization_test1/test.cfg
@@ -0,0 +1,2 @@
+compile(variables_initialization_test1)
+run(variables_initialization_test1)
diff --git a/testsuite/c_test/simple_test/SIM00002-variables_initialization_test1/variables_initialization_test1.c b/testsuite/c_test/simple_test/SIM00002-variables_initialization_test1/variables_initialization_test1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f4ea3cef27cf47bd5d323cd38ad8f6d62b4752e8
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00002-variables_initialization_test1/variables_initialization_test1.c
@@ -0,0 +1,54 @@
+#include <stdio.h>
+
+int main(){
+
+    char a;
+    a = 'a';
+    printf("%c\n", a);
+
+    unsigned char b;
+    b = 'b';
+    printf("%c\n", b);
+
+    signed char c;
+    c = 'c';
+    printf("%c\n", c);
+
+    int d;
+    d = 1;
+    printf("%d\n", d);
+
+    unsigned int e;
+    e = 2;
+    printf("%d\n", e);
+
+    short f;
+    f = 3;
+    printf("%d\n", f);
+
+    unsigned short g;
+    g = 4;
+    printf("%d\n", g);
+
+    long h;
+    h = 5;
+    printf("%ld\n", h);
+
+    float i;
+    i = 1.;
+    printf("%f\n", i);
+
+    double j;
+    j = 0.7623e-2;
+    printf("%lf\n", j);
+
+//    long double k;
+//    k = 0.7623e-2;
+//    printf("%Lf\n", k);
+
+    long long l;
+    l = 100;
+    printf("%lld\n", l);
+
+    return 0;
+}
diff --git a/testsuite/c_test/simple_test/SIM00003-variables_initialization_test2/expected.txt b/testsuite/c_test/simple_test/SIM00003-variables_initialization_test2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..901d3620a741ff6744c24bafae1f050cf93d5970
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00003-variables_initialization_test2/expected.txt
@@ -0,0 +1,11 @@
+a
+b
+c
+1
+2
+3
+4
+5
+1.000000
+0.007623
+100
diff --git a/testsuite/c_test/simple_test/SIM00003-variables_initialization_test2/test.cfg b/testsuite/c_test/simple_test/SIM00003-variables_initialization_test2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e00cda439a869d4d84d58ecfdfc7cf8e551c3fa1
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00003-variables_initialization_test2/test.cfg
@@ -0,0 +1,2 @@
+compile(variables_initialization_test2)
+run(variables_initialization_test2)
diff --git a/testsuite/c_test/simple_test/SIM00003-variables_initialization_test2/variables_initialization_test2.c b/testsuite/c_test/simple_test/SIM00003-variables_initialization_test2/variables_initialization_test2.c
new file mode 100644
index 0000000000000000000000000000000000000000..6123840236cee17e4f7db103dfe02c010deace7f
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00003-variables_initialization_test2/variables_initialization_test2.c
@@ -0,0 +1,42 @@
+#include <stdio.h>
+
+int main(){
+
+    char a = 'a';
+    printf("%c\n", a);
+
+    unsigned char b = 'b';
+    printf("%c\n", b);
+
+    signed char c = 'c';
+    printf("%c\n", c);
+
+    int d = 1;
+    printf("%d\n", d);
+
+    unsigned int e = 2;
+    printf("%d\n", e);
+
+    short f = 3;
+    printf("%d\n", f);
+
+    unsigned short g = 4;
+    printf("%d\n", g);
+
+    long h = 5;
+    printf("%ld\n", h);
+
+    float i = 1.;
+    printf("%f\n", i);
+
+    double j = 0.7623e-2;
+    printf("%lf\n", j);
+
+//    long double k = 0.7623e-2;
+//    printf("%Lf\n", k);
+
+    long long l = 100;
+    printf("%lld\n", l);
+
+    return 0;
+}
diff --git a/testsuite/c_test/simple_test/SIM00004-array_initialization_test/array_initialization_test.c b/testsuite/c_test/simple_test/SIM00004-array_initialization_test/array_initialization_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..a8304631c1e032ef3072b7d3f4b679960721ba94
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00004-array_initialization_test/array_initialization_test.c
@@ -0,0 +1,31 @@
+#include <stdio.h>
+
+int main(){
+    int array1[5];
+    array1 = {1, 2, 3, 4, 5};
+    printf("%d %d %d %d %d\n", array1[0], array1[1], array1[2], array1[3], array1[4]);
+
+    float array2[5] = {1., 2., 3., 4., 5.};
+    printf("%f %f %f %f %f\n", array2[0], array2[1], array2[2], array2[3], array2[4]);
+
+    char array3[] = {'a', 'b', 'c', 'd', 'e'};
+    printf("%c %c %c %c %c\n", array3[0], array3[1], array3[2], array3[3], array3[4]);
+
+    double array4[5];
+    array4[0] = 0.0;
+    array4[1] = 0.1;
+    array4[2] = 0.2;
+    array4[3] = 0.3;
+    array4[4] = 0.4;
+    printf("%lf %lf %lf %lf %lf\n", array4[0], array4[1], array4[2], array4[3], array4[4]);
+
+    int array5[2][3];
+    array5 = {{1, 2, 3}, {4, 5, 6}};
+    printf("%d %d %d %d %d %d\n", array5[0][0], array5[0][1], array5[0][2], array5[1][0], array5[1][1], array5[1][2]);
+
+    float array6[2][3] = {{1., 2., 3.}, {4., 5., 6.}};
+    printf("%f %f %f %f %f %f\n", array6[0][0], array6[0][1], array6[0][2], array6[1][0], array6[1][1], array6[1][2]);
+
+    char array7[2][3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};
+    return 0;
+}
diff --git a/testsuite/c_test/simple_test/SIM00004-array_initialization_test/test.cfg b/testsuite/c_test/simple_test/SIM00004-array_initialization_test/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..48b8edf866116f13546c5a55a03f43b1f80c9636
--- /dev/null
+++ b/testsuite/c_test/simple_test/SIM00004-array_initialization_test/test.cfg
@@ -0,0 +1,2 @@
+compile(array_initialization_test)
+run(array_initialization_test)
diff --git a/testsuite/c_test/simple_test/add_case.sh b/testsuite/c_test/simple_test/add_case.sh
new file mode 100644
index 0000000000000000000000000000000000000000..30456a5056c10f31a7a593aefdc0c09cf34c5454
--- /dev/null
+++ b/testsuite/c_test/simple_test/add_case.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+str_num=$(ls | grep ^SIM | tail -n 1 | cut -d "-" -f 1 | cut -d "M" -f 2)
+let str_num++
+str_num_next=$(printf "%05d\n" ${str_num})
+next_name=SIM${str_num_next}-${1}
+mkdir ${next_name}
+cd ${next_name}
+echo "clean()" >> test.cfg
+echo "compile(${2})" >> test.cfg
+echo "run(${2})" >> test.cfg
+echo "#include <stdio.h>" >> ${2}.c
+echo "" >> ${2}.c
+echo "int main(){" >> ${2}.c
+echo "" >> ${2}.c
+echo "    return 0;" >> ${2}.c
+echo "}" >> ${2}.c
diff --git a/testsuite/c_test/unit_test/UNIT0001-AA_Addr2Prim1/alias_analysis_addr2prim.c b/testsuite/c_test/unit_test/UNIT0001-AA_Addr2Prim1/alias_analysis_addr2prim.c
new file mode 100644
index 0000000000000000000000000000000000000000..9020eeabd418096a03243b19ac5fb361a34db6e7
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0001-AA_Addr2Prim1/alias_analysis_addr2prim.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+int main() {
+  int a = 0;
+  int *ptrA = &a;
+  long long tmp = (long long)(ptrA);
+
+  int *ptrB = (int*)(tmp);
+  *ptrB = 10;
+  if (a != 10)
+    abort();
+  printf("%d\n", a); // 10
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0001-AA_Addr2Prim1/expected.txt b/testsuite/c_test/unit_test/UNIT0001-AA_Addr2Prim1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f599e28b8ab0d8c9c57a486c89c4a5132dcbd3b2
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0001-AA_Addr2Prim1/expected.txt
@@ -0,0 +1 @@
+10
diff --git a/testsuite/c_test/unit_test/UNIT0001-AA_Addr2Prim1/test.cfg b/testsuite/c_test/unit_test/UNIT0001-AA_Addr2Prim1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ae305889ad77ea1ff02bad624708de4a095f95e7
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0001-AA_Addr2Prim1/test.cfg
@@ -0,0 +1,2 @@
+compile(alias_analysis_addr2prim)
+run(alias_analysis_addr2prim)
diff --git a/testsuite/c_test/unit_test/UNIT0002-AA_Addr2Prim2/alias_analysis_addr2prim.c b/testsuite/c_test/unit_test/UNIT0002-AA_Addr2Prim2/alias_analysis_addr2prim.c
new file mode 100644
index 0000000000000000000000000000000000000000..41e0814245383a2e51c67171c9cedd3d9bd967af
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0002-AA_Addr2Prim2/alias_analysis_addr2prim.c
@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+struct A {
+  long long tmp;
+} ;
+
+int main() {
+  int a = 0;
+  int *ptrA = &a;
+  struct A structA, *ptrStructA = &structA;
+
+  ptrStructA->tmp = (long long)(ptrA);
+
+  int *ptrB = (int*)(structA.tmp);
+  *ptrB = 10;
+  if (a != 10)
+    abort();
+  printf("%d\n", a); // 10
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0002-AA_Addr2Prim2/expected.txt b/testsuite/c_test/unit_test/UNIT0002-AA_Addr2Prim2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f599e28b8ab0d8c9c57a486c89c4a5132dcbd3b2
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0002-AA_Addr2Prim2/expected.txt
@@ -0,0 +1 @@
+10
diff --git a/testsuite/c_test/unit_test/UNIT0002-AA_Addr2Prim2/test.cfg b/testsuite/c_test/unit_test/UNIT0002-AA_Addr2Prim2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ae305889ad77ea1ff02bad624708de4a095f95e7
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0002-AA_Addr2Prim2/test.cfg
@@ -0,0 +1,2 @@
+compile(alias_analysis_addr2prim)
+run(alias_analysis_addr2prim)
diff --git a/testsuite/c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc/alias_analysis_diff_field_same_memloc.c b/testsuite/c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc/alias_analysis_diff_field_same_memloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..8dc1d72c6fc1e919dad9c68990847839d9312e43
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc/alias_analysis_diff_field_same_memloc.c
@@ -0,0 +1,36 @@
+#include <stdio.h>
+
+struct A {
+  int fld1;
+  int fld2;
+};
+
+struct B {
+  int fld1;
+  int fld2;
+  int fld3;
+  int fld4;
+};
+
+// move struct A's base ptr, and access different field of struct A
+// but get the same memory location actually
+int main()
+{
+  struct A *ptr;
+  struct B structB;
+  //                   structB
+  // struct A *ptr--->| fld1 |
+  //               └->| fld2 | <- assign 2 to fld2
+  //                  | fld3 |
+  //                  | fld4 |
+  ptr = (struct A*)&structB;
+  ptr->fld2 = 2;
+  //                   structB
+  //                  | fld1 |
+  // struct A *ptr--->| fld2 | -> get fld1 of ptr, and it is actually fld2 of structB
+  //               └->| fld3 |    the result expected is 2
+  //                  | fld4 |
+  ptr = (struct A*)((int*)ptr + 1);
+  printf("%d\n", ptr->fld1);
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc/expected.txt b/testsuite/c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0cfbf08886fca9a91cb753ec8734c84fcbe52c9f
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc/expected.txt
@@ -0,0 +1 @@
+2
diff --git a/testsuite/c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc/test.cfg b/testsuite/c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..796728cf6a167081a4f000ea95988c9806381e85
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc/test.cfg
@@ -0,0 +1,2 @@
+compile(alias_analysis_diff_field_same_memloc)
+run(alias_analysis_diff_field_same_memloc)
diff --git a/testsuite/c_test/unit_test/UNIT0004-AA_EscapePtr/alias_analysis_escapeptr.c b/testsuite/c_test/unit_test/UNIT0004-AA_EscapePtr/alias_analysis_escapeptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..63f484da051df326c8676d28e5bb23e1f4783da9
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0004-AA_EscapePtr/alias_analysis_escapeptr.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+int main()
+{
+  int *PintA[4];
+  int **PPintA[2];
+  int a = 1;
+  int *ptr = &a;
+  PintA[2] = ptr;
+  PPintA[1] = PintA;
+  *PPintA[1][2] = 3;
+  int b = *PPintA[1][2];
+  printf("%d\n", a);
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0004-AA_EscapePtr/expected.txt b/testsuite/c_test/unit_test/UNIT0004-AA_EscapePtr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..00750edc07d6415dcc07ae0351e9397b0222b7ba
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0004-AA_EscapePtr/expected.txt
@@ -0,0 +1 @@
+3
diff --git a/testsuite/c_test/unit_test/UNIT0004-AA_EscapePtr/test.cfg b/testsuite/c_test/unit_test/UNIT0004-AA_EscapePtr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..98e7bbb2a98e95534beef66bdd203d6d48957a51
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0004-AA_EscapePtr/test.cfg
@@ -0,0 +1,2 @@
+compile(alias_analysis_escapeptr)
+run(alias_analysis_escapeptr)
diff --git a/testsuite/c_test/unit_test/UNIT0005-BitField_zeroWidth/expected.txt b/testsuite/c_test/unit_test/UNIT0005-BitField_zeroWidth/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b03b8eacc07b8dcab799c4a533f1dd6f71cdfe8d
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0005-BitField_zeroWidth/expected.txt
@@ -0,0 +1,2 @@
+6
+12
diff --git a/testsuite/c_test/unit_test/UNIT0005-BitField_zeroWidth/test.cfg b/testsuite/c_test/unit_test/UNIT0005-BitField_zeroWidth/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..95d875101f5322912d502ef8cf1fa43fd592e5e4
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0005-BitField_zeroWidth/test.cfg
@@ -0,0 +1,2 @@
+compile(zero-width-bitfield)
+run(zero-width-bitfield)
diff --git a/testsuite/c_test/unit_test/UNIT0005-BitField_zeroWidth/zero-width-bitfield.c b/testsuite/c_test/unit_test/UNIT0005-BitField_zeroWidth/zero-width-bitfield.c
new file mode 100644
index 0000000000000000000000000000000000000000..101907b16a3cef953cac8e63735652c4fc8234f7
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0005-BitField_zeroWidth/zero-width-bitfield.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+
+struct FieldStruct1 {
+  int fld1 : 20; // (0, 0)
+  int      : 10; // (0, 20)
+  int fld3 : 4;  // 20 + 10 + 4 > 32, over sizeof(int), start from next int unit
+                 // (4, 0)
+  int      : 0;  // zero field, force next field start from new int unit
+                 // (4, 4)
+  int fld5 : 13; // (8, 0)
+};
+
+int main() {
+  struct FieldStruct1 s1 = {0};
+  char *ptr = (char *)&s1;
+  s1.fld1 = 33;
+  s1.fld3 = 2;
+  s1.fld5 = 5;
+  // (gdb)x/12xb ptr
+  // 0x7fffffffce8c:	0x21	0x00	0x00	0x00	0x02	0x00	0x00	0x00
+  // 0x7fffffffce94:	0x05	0x00	0x00	0x00
+
+  int *intptr = (int*)(ptr + 8); // point to field5;
+  *intptr = 6;
+
+  printf("%d\n", s1.fld5);
+  printf("%ld\n", sizeof(s1));
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0006-MS_IassSameField/expected.txt b/testsuite/c_test/unit_test/UNIT0006-MS_IassSameField/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0006-MS_IassSameField/merge_store_iassignsamefield.c b/testsuite/c_test/unit_test/UNIT0006-MS_IassSameField/merge_store_iassignsamefield.c
new file mode 100644
index 0000000000000000000000000000000000000000..efccc87904fd7ec8d71bb1ebcd92803e2c76d203
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0006-MS_IassSameField/merge_store_iassignsamefield.c
@@ -0,0 +1,30 @@
+struct A {
+  int i;
+  int j;
+  int k;
+  int x;
+  int y;
+  int z;
+} a;
+
+int main ()
+{
+  int i;
+  // insert many iassign here
+  a.i = 0x12991212;
+  a.i = 0x12121212;
+  a.j = 0x12991212;
+  a.j = 0x12121212;
+  a.x = 0x12991212;
+  a.x = 0x12121212;
+  a.y = 0x12991212;
+  a.y = 0x12121212;
+  a.z = 0x12991212;
+  a.z = 0x12121212;
+  a.k = 0x12991212;
+  a.k = 0x12121212;
+  for (i = 0; i < sizeof a; i++)
+    if (((char *)&a)[i] != 0x12)
+      __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0006-MS_IassSameField/test.cfg b/testsuite/c_test/unit_test/UNIT0006-MS_IassSameField/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ee94c3731ba3bb6cbd70cd2efb003f81e67d17b8
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0006-MS_IassSameField/test.cfg
@@ -0,0 +1,2 @@
+compile(merge_store_iassignsamefield)
+run(merge_store_iassignsamefield)
diff --git a/testsuite/c_test/unit_test/UNIT0007-MS_DassSameField/expected.txt b/testsuite/c_test/unit_test/UNIT0007-MS_DassSameField/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0007-MS_DassSameField/merge_store_dassignsamefield.c b/testsuite/c_test/unit_test/UNIT0007-MS_DassSameField/merge_store_dassignsamefield.c
new file mode 100644
index 0000000000000000000000000000000000000000..c464385e2702f34d52f512e5f59dd7aa024f323d
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0007-MS_DassSameField/merge_store_dassignsamefield.c
@@ -0,0 +1,31 @@
+typedef struct A {
+  int i;
+  int j;
+  int k;
+  int x;
+  int y;
+  int z;
+} StructA;
+
+int main ()
+{
+  StructA a;
+  // insert many dassign pair here
+  // dassign pair : first is to set a value, second is to override the first value
+  a.i = 0x12991212;
+  a.i = 0x12121212;
+  a.j = 0x12991212;
+  a.j = 0x12121212;
+  a.x = 0x12991212;
+  a.x = 0x12121212;
+  a.y = 0x12991212;
+  a.y = 0x12121212;
+  a.z = 0x12991212;
+  a.z = 0x12121212;
+  a.k = 0x12991212;
+  a.k = 0x12121212;
+  for (int i = 0; i < sizeof a; i++)
+    if (((char *)&a)[i] != 0x12)
+      __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0007-MS_DassSameField/test.cfg b/testsuite/c_test/unit_test/UNIT0007-MS_DassSameField/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..04ebdcc042b28eda77936095673d08473d598229
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0007-MS_DassSameField/test.cfg
@@ -0,0 +1,2 @@
+compile(merge_store_dassignsamefield)
+run(merge_store_dassignsamefield)
diff --git a/testsuite/c_test/unit_test/UNIT0008-VolatileOst/expected.txt b/testsuite/c_test/unit_test/UNIT0008-VolatileOst/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0008-VolatileOst/test.cfg b/testsuite/c_test/unit_test/UNIT0008-VolatileOst/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cfafe4b7658fdcacdf26bcee14f1d423fe61d304
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0008-VolatileOst/test.cfg
@@ -0,0 +1,3 @@
+compile(volatile_ost)
+run(volatile_ost)
+
diff --git a/testsuite/c_test/unit_test/UNIT0008-VolatileOst/volatile_ost.c b/testsuite/c_test/unit_test/UNIT0008-VolatileOst/volatile_ost.c
new file mode 100644
index 0000000000000000000000000000000000000000..44382c6f20cc7194a29103b97cb9fcf5b61826e2
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0008-VolatileOst/volatile_ost.c
@@ -0,0 +1,20 @@
+// For fixing `compilation error` in SimplifyCFG from DTS2021120818280
+// Description:
+//   maple middle end won't optimize volatile variable, so the following
+//   `return x` has no phi node for x. We skip cond2select in SimplifyCFG
+//   when phi is empty to cover the issue
+#define GUARD 8
+
+int main (void) {
+  volatile int x;
+  x = 8;
+
+  if ( GUARD >= x ) {
+     x = 0;
+  } else {
+     x = 1;
+  }
+
+  return x;
+}
+
diff --git a/testsuite/c_test/unit_test/UNIT0009-CallGraph/test.c b/testsuite/c_test/unit_test/UNIT0009-CallGraph/test.c
new file mode 100644
index 0000000000000000000000000000000000000000..1711c6dae50057a63d5e6d650d52f1df97b11750
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0009-CallGraph/test.c
@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int max(int a, int b) {
+  return (a > b ? a : b);
+}
+int min(int a, int b) {
+  return (a < b ? a : b);
+}
+
+void populate_array(int *array, size_t arraySize, int (*getNextValue)(void)) {
+  for (size_t i = 0; i < arraySize; i++) {
+    array[i] = getNextValue();
+  }
+}
+
+int getNextRandomValue(void) {
+  return rand();
+}
+
+typedef struct T {
+  int (*func1)(int, int);
+  int (*func2)(int, int);
+} T;
+
+const T t = {min, max};
+
+int (*const gConsts1[][2])(int, int) = {{min, max}, {max, min}};
+int (*const gConsts2[2])(int, int) = {min, max};
+int (*const gConst)(int, int) = max;
+const int (*gVar)(int, int) = max;
+int main(int argc, char *argv[]) {
+  gVar = min;
+  int (*const lConst)(int, int) = min;
+  int (*const lConstFuncArray[])(int, int) = {min, max};
+  int a = 1, b = 2, c, d, e, f, g, h, i;
+  c = gConst(a, b);
+  d = lConst(a, b);
+  e = gVar(a, b);
+  f = gConsts1[0][1](a, b);
+  g = gConsts2[1](a, b);
+  h = lConstFuncArray[1](a, b);
+  i = t.func1(a, b);
+  printf("%d\n", c);
+  printf("%d\n", d);
+  printf("%d\n", e);
+  printf("%d\n", f);
+  printf("%d\n", g);
+  printf("%d\n", h);
+  printf("%d\n", i);
+
+  int myarray[10];
+  populate_array(myarray, 10, getNextRandomValue);
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0009-CallGraph/test.cfg b/testsuite/c_test/unit_test/UNIT0009-CallGraph/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..821a3788b0d924ccb3224554b7e421006644162c
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0009-CallGraph/test.cfg
@@ -0,0 +1,5 @@
+${OUT_ROOT}/tools/bin/clang -emit-ast --target=aarch64 -U __SIZEOF_INT128__ -isystem ${OUT_ROOT}/aarch64-clang-release/lib/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include -isystem ../lib/include -o test.ast test.c
+${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl test.ast -o test.mpl
+${OUT_ROOT}/aarch64-clang-release/bin/maple --run=me:mpl2mpl --option="--O2 --quiet:--O2 --quiet --dump-phase=callgraph" test.mpl > compile.log
+# hir2mpl replace icall with icallproto, n=0
+python3 ${TEST_BIN}/check.py --check=num  --n=0 --str="replace icall successfully"  --result=compile.log
diff --git a/testsuite/c_test/unit_test/UNIT0011-AA_PtrValueAlias/alias_analysis_ptr_value_alias.c b/testsuite/c_test/unit_test/UNIT0011-AA_PtrValueAlias/alias_analysis_ptr_value_alias.c
new file mode 100644
index 0000000000000000000000000000000000000000..a6c242b746b96fbb918dfa705a3e39421eb438ec
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0011-AA_PtrValueAlias/alias_analysis_ptr_value_alias.c
@@ -0,0 +1,19 @@
+#include <stdio.h>
+
+extern void abort();
+struct MemArrays { char a[4], b[4]; };
+
+int main (void)
+{
+  const struct MemArrays ma[] = {
+    { { '1', '2', '3', '4' }, { '5', '\0', '\0', '\0' } },
+  };
+
+  const char *s = ma[0].a;
+  unsigned n = strlen (s);
+  printf("%d\n", n);
+  if (n != 5) {
+    abort();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0011-AA_PtrValueAlias/expected.txt b/testsuite/c_test/unit_test/UNIT0011-AA_PtrValueAlias/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7ed6ff82de6bcc2a78243fc9c54d3ef5ac14da69
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0011-AA_PtrValueAlias/expected.txt
@@ -0,0 +1 @@
+5
diff --git a/testsuite/c_test/unit_test/UNIT0011-AA_PtrValueAlias/test.cfg b/testsuite/c_test/unit_test/UNIT0011-AA_PtrValueAlias/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fdcc9d4a9f10dc9f02bf2ab280654f95e89683d5
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0011-AA_PtrValueAlias/test.cfg
@@ -0,0 +1,7 @@
+compile(alias_analysis_ptr_value_alias)
+${OUT_ROOT}/tools/bin/clang -emit-ast --target=aarch64 -U __SIZEOF_INT128__ -isystem ${MAPLE_BUILD_OUTPUT}/lib/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include -isystem ../lib/include -o alias_analysis_ptr_value_alias.ast  alias_analysis_ptr_value_alias.c
+${MAPLE_BUILD_OUTPUT}/bin/hir2mpl --enable-variable-array alias_analysis_ptr_value_alias.ast -o alias_analysis_ptr_value_alias.mpl
+${MAPLE_BUILD_OUTPUT}/bin/maple --run=me:mplcg --option="-O2 --quiet:-O2 --fpic --quiet"  --infile alias_analysis_ptr_value_alias.mpl
+${OUT_ROOT}/tools/bin/aarch64-linux-gnu-gcc  -o alias_analysis_ptr_value_alias.out  alias_analysis_ptr_value_alias.s -lm
+${OUT_ROOT}/tools/bin/qemu-aarch64 -L ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc alias_analysis_ptr_value_alias.out > output.log 2>&1
+diff output.log expected.txt
diff --git a/testsuite/c_test/unit_test/UNIT0012-SE_PINoUse/expected.txt b/testsuite/c_test/unit_test/UNIT0012-SE_PINoUse/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0012-SE_PINoUse/sideeffect_PI_nouse.c b/testsuite/c_test/unit_test/UNIT0012-SE_PINoUse/sideeffect_PI_nouse.c
new file mode 100644
index 0000000000000000000000000000000000000000..7d2431342c28763da1b5b04ba6ac2dda8e708f0b
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0012-SE_PINoUse/sideeffect_PI_nouse.c
@@ -0,0 +1,32 @@
+extern void abort();
+int *g = 0;
+// argument a is nouse
+__attribute__((__noinline__)) void bar(int *a) {
+  *g = 20;
+}
+
+__attribute__((__noinline__)) int foo(int cond) {
+  int i = 10;
+  int k = 11;
+  g = &i;
+  int *j = 0;
+  // use a branch to disable propagation of j
+  if (cond) {
+    j = &i;
+  } else {
+    j = &k;
+  }
+  *j = 10;
+  bar(j); // j is no use in bar, but *j will be modified through g
+          // we should add *j to MAYD list, otherwise return will be
+          // propagated as 10
+  return *j;
+}
+
+int main() {
+  int res = foo(1);
+  if (res != 20) {
+    abort();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0012-SE_PINoUse/test.cfg b/testsuite/c_test/unit_test/UNIT0012-SE_PINoUse/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65aeca2448297612838952ad909f69e480d2d704
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0012-SE_PINoUse/test.cfg
@@ -0,0 +1,2 @@
+compile(sideeffect_PI_nouse)
+run(sideeffect_PI_nouse)
diff --git a/testsuite/c_test/unit_test/UNIT0013-SE_PINoUse2/expected.txt b/testsuite/c_test/unit_test/UNIT0013-SE_PINoUse2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0013-SE_PINoUse2/sideeffect_PI_nouse.c b/testsuite/c_test/unit_test/UNIT0013-SE_PINoUse2/sideeffect_PI_nouse.c
new file mode 100644
index 0000000000000000000000000000000000000000..7d8f496b31858b35fb201ee971dfd65bc34547b0
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0013-SE_PINoUse2/sideeffect_PI_nouse.c
@@ -0,0 +1,28 @@
+extern void abort();
+int g = 0;
+
+// argument a is nouse
+// FI:Unknown  RI:  PI:nouse
+__attribute__((__noinline__)) void bar(int *a) {
+  g = 20;
+}
+
+__attribute__((__noinline__)) int foo(int *k, int cond) { // FI unknown
+  int *j = k;
+  if (cond == 1) {
+    j = 0;
+  }
+  *j = 10;
+  bar(j); // *j is def here, should be inserted into mayDef list
+  return *j;
+}
+
+
+int main() {
+  int res = foo(&g, 0);
+  if (res != 20) {
+    abort();
+  }
+  return 0;
+}
+
diff --git a/testsuite/c_test/unit_test/UNIT0013-SE_PINoUse2/test.cfg b/testsuite/c_test/unit_test/UNIT0013-SE_PINoUse2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65aeca2448297612838952ad909f69e480d2d704
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0013-SE_PINoUse2/test.cfg
@@ -0,0 +1,2 @@
+compile(sideeffect_PI_nouse)
+run(sideeffect_PI_nouse)
diff --git a/testsuite/c_test/unit_test/UNIT0014-CFGO_Volatile1/expected.txt b/testsuite/c_test/unit_test/UNIT0014-CFGO_Volatile1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d0d3751a6186496d8cf8ba4bfaedcc85a84a4624
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0014-CFGO_Volatile1/expected.txt
@@ -0,0 +1,10 @@
+0 0
+1 4
+2 8
+3 12
+4 16
+5 20
+6 24
+7 28
+8 32
+9 36
diff --git a/testsuite/c_test/unit_test/UNIT0014-CFGO_Volatile1/optimize_cfg_volatile.c b/testsuite/c_test/unit_test/UNIT0014-CFGO_Volatile1/optimize_cfg_volatile.c
new file mode 100644
index 0000000000000000000000000000000000000000..3484bc4cc84c15d3487f60b05bff2c45e90297e5
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0014-CFGO_Volatile1/optimize_cfg_volatile.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+int main() {
+  volatile int b[10], i;
+  for (i = 0; i < 10; i++) {
+    b[i] = i << 2;
+  }
+  for (i = 0; i < 10; i++) {
+    printf("%d %d\n", i, b[i]);
+  }
+}
diff --git a/testsuite/c_test/unit_test/UNIT0014-CFGO_Volatile1/test.cfg b/testsuite/c_test/unit_test/UNIT0014-CFGO_Volatile1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..856f5775c92ac6796be425c79498363b1305acda
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0014-CFGO_Volatile1/test.cfg
@@ -0,0 +1,2 @@
+compile(optimize_cfg_volatile)
+run(optimize_cfg_volatile)
diff --git a/testsuite/c_test/unit_test/UNIT0015-CFGO_Volatile2/expected.txt b/testsuite/c_test/unit_test/UNIT0015-CFGO_Volatile2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0015-CFGO_Volatile2/optimize_cfg_volatile.c b/testsuite/c_test/unit_test/UNIT0015-CFGO_Volatile2/optimize_cfg_volatile.c
new file mode 100644
index 0000000000000000000000000000000000000000..49866030d13b4e1edbc13e71791f20b71b3ab9df
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0015-CFGO_Volatile2/optimize_cfg_volatile.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+int main()
+{
+  volatile int a[10], b[10], c[10], i;
+
+  for (i = 0; i < 10; i++) {
+    b[i] = i << 2;
+    c[i] = i << (b[i] % (sizeof(int)*CHAR_BIT));
+  }
+
+  for (i = 0; i < 10; i++) {
+    a[i] = b[i] + c[9-i];
+  }
+
+  int sum = 0;
+  for (i = 0; i < 10; i++) {
+    sum += a[i];
+  }
+
+  if (sum != 1985229660) {
+    abort();
+  }
+
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0015-CFGO_Volatile2/test.cfg b/testsuite/c_test/unit_test/UNIT0015-CFGO_Volatile2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..856f5775c92ac6796be425c79498363b1305acda
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0015-CFGO_Volatile2/test.cfg
@@ -0,0 +1,2 @@
+compile(optimize_cfg_volatile)
+run(optimize_cfg_volatile)
diff --git a/testsuite/c_test/unit_test/UNIT0016-SE_ConfigInfo/expected.txt b/testsuite/c_test/unit_test/UNIT0016-SE_ConfigInfo/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0016-SE_ConfigInfo/ipa_sideeffect_configinfo.c b/testsuite/c_test/unit_test/UNIT0016-SE_ConfigInfo/ipa_sideeffect_configinfo.c
new file mode 100644
index 0000000000000000000000000000000000000000..af56313fd606688ed548325d8bddd4b813997e08
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0016-SE_ConfigInfo/ipa_sideeffect_configinfo.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+
+int main()
+{
+    char buffer[64];
+    buffer[0] = 0;
+    // {PI::kWriteMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly, PI::kReadMemoryOnly}
+    // Let opnd0 == opnd2, make readMemOnly opnd can be written.
+    sprintf(buffer, "%p", buffer);
+
+
+    if ( buffer[0] != 48) {  // charater '0' ascii value is 48
+        abort();
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0016-SE_ConfigInfo/test.cfg b/testsuite/c_test/unit_test/UNIT0016-SE_ConfigInfo/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..47c2a7f0c0ed7c334de6472b91f05c54d17d9b66
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0016-SE_ConfigInfo/test.cfg
@@ -0,0 +1,2 @@
+compile(ipa_sideeffect_configinfo)
+run(ipa_sideeffect_configinfo)
diff --git a/testsuite/c_test/unit_test/UNIT0017-SIMPLIFY_sprintf/sprintf.c b/testsuite/c_test/unit_test/UNIT0017-SIMPLIFY_sprintf/sprintf.c
new file mode 100644
index 0000000000000000000000000000000000000000..32ad11a9c45ffd6a15432bf85ddcb7638031ddd6
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0017-SIMPLIFY_sprintf/sprintf.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2022-2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+extern void abort();
+int test(char *s) {
+  return sprintf_s(s, 4, "123"); // replace with memcpy(s, "123", 3)
+}
+
+int test1(char *s) {
+  return snprintf_s(s, 4, 5, "123"); // replace with memcpy(s, "123", 3)
+}
+int test2(char *s) {
+  return vsnprintf_s(s, 4, 5, "%s", "123"); // replace with memcpy(s, "123", 3)
+}
+
+int test3(char *s) {
+  return sprintf(s, "123"); // replace with memcpy(s, "123", 3)
+}
+
+int test4(char *s) {
+  char *s1;
+  return sprintf(s, s1); // no need replace
+}
+
+int test5(char *s) {
+  char *s1;
+  return sprintf_s(s, 4, "1234"); // truncate, no need replace, return -1
+}
+
+int test6(char *s) {
+  return sprintf_s(s, 0, "123"); // dstMax = 0, no need replace, return -1
+}
+
+int test7(char *s) {
+  return snprintf_s(s, 1, 0, "123"); // count = 0, no need replace, return -1
+}
+
+int test8(char *s) {
+  int n = 1;
+  return snprintf_s(s, n, 1, "123"); // unknow dstMax, no need replace
+}
+
+int test9(char *s) {
+  return sprintf_s(s, 5, "%s", "123", "123"); // too many parameters, no need replace
+}
+
+int test10(char *s) {
+  return snprintf_s(s, 5, 4,  "%s", "123", "123"); // too many parameters, no need replace
+}
+
+int test11(char *s) {
+  return snprintf_s(s, 5, 4,  "string %s", "123"); // fmt string is not only "%s", no need replace
+}
+int test12(char *s) {
+  return sprintf_s(s, 5, "string %u", 1); // fmt string is not only "%s", no need replace
+}
+
+char *test13() {
+  static char Result_PATH[300] = {'l', 'e', '/', 'C', 'V', 'S', 'A', '/', 'T', 'E', 'S', 'T', 'S', 'R', 'C', '/', 'P'};
+  sprintf(Result_PATH, "%s", "running.path");
+  return Result_PATH;
+}
+
+char *test14() {
+  int n = 3;
+  static char Result_PATH[300] = {'l', 'e', '/', 'C', 'V', 'S', 'A', '/', 'T', 'E', 'S', 'T', 'S', 'R', 'C', '/', 'P'};
+  sprintf_s(Result_PATH, n, "%s", "run");
+  return Result_PATH;
+}
+
+int main() {
+  char s[10];
+  int a = test(s);
+  if (a != 3 || strcmp(s, "123") != 0){
+    abort();
+  }
+  a = test1(s);
+  if (a != 3 || strcmp(s, "123") != 0) {
+    abort();
+  }
+  a = test2(s);
+  if (a != 3 || strcmp(s, "123") != 0) {
+    abort();
+  }
+  a = test3(s);
+  if (a != 3 || strcmp(s, "123") != 0) {
+    abort();
+  }
+  a = test5(s);
+  if (a != -2) {
+    abort();
+  }
+  a = test6(s);
+  if (a != -1) {
+    abort();
+  }
+  a = test7(s);
+  if (a != -1) {
+    abort();
+  }
+  char *res = test13();
+  if (strcmp(res, "running.path") != 0) {
+    abort();
+  }
+  res = test14();
+  if (res[0] != '\0') {
+    abort();
+  }
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/unit_test/UNIT0017-SIMPLIFY_sprintf/test.cfg b/testsuite/c_test/unit_test/UNIT0017-SIMPLIFY_sprintf/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7539eebb13db76f48edd666c7d2a4d9cb707cfe9
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0017-SIMPLIFY_sprintf/test.cfg
@@ -0,0 +1,7 @@
+${OUT_ROOT}/tools/bin/clang -emit-ast --target=aarch64 -U __SIZEOF_INT128__ -isystem ${OUT_ROOT}/aarch64-clang-release/lib/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include -isystem ${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include -isystem ../lib/include -o sprintf.ast sprintf.c
+${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl sprintf.ast -o sprintf.mpl
+${OUT_ROOT}/aarch64-clang-release/bin/maple --run=me:mpl2mpl --option="--O2 --quiet:--O2 --quiet" sprintf.mpl --save-temps
+python3 ${TEST_BIN}/check.py --check=num  --n=13 --str="callassigned &memcpy"  --result=comb.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=1 --str="callassigned &sprintf "  --result=comb.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=3 --str="callassigned &sprintf_s "  --result=comb.me.mpl
+python3 ${TEST_BIN}/check.py --check=num  --n=3 --str="callassigned &snprintf_s "  --result=comb.me.mpl
diff --git a/testsuite/c_test/unit_test/UNIT0018-SE_mktime/expected.txt b/testsuite/c_test/unit_test/UNIT0018-SE_mktime/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4d6aa1ef55194faed06ba50b7c066dc1b9a96049
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0018-SE_mktime/expected.txt
@@ -0,0 +1,2 @@
+mktime set tm_wday is Thursday
+mktime set tm_wday is Thursday
diff --git a/testsuite/c_test/unit_test/UNIT0018-SE_mktime/sideeffect_mktime.c b/testsuite/c_test/unit_test/UNIT0018-SE_mktime/sideeffect_mktime.c
new file mode 100644
index 0000000000000000000000000000000000000000..0845c0c77423454407515378424e30aa8b22fd11
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0018-SE_mktime/sideeffect_mktime.c
@@ -0,0 +1,27 @@
+#include <stdio.h>      /* printf, scanf */
+#include <time.h>       /* time_t, struct tm, time, mktime */
+
+int main ()
+{
+    time_t rawtime;
+    struct tm timeinfo;
+    int year, month ,day;
+    const char * weekday[] = { "Sunday", "Monday","Tuesday", "Wednesday","Thursday", "Friday", "Saturday"};
+
+    timeinfo.tm_sec = 0;
+    timeinfo.tm_min = 1;
+    timeinfo.tm_hour = 1;
+    timeinfo.tm_mday = 10;
+    timeinfo.tm_mon = 7;
+    timeinfo.tm_year = 95;
+    timeinfo.tm_isdst = -1;
+
+    mktime ( &timeinfo );
+    printf ("mktime set tm_wday is %s\n", weekday[timeinfo.tm_wday]);
+
+    timeinfo.tm_wday = 3;
+    // may modify timeinfo
+    mktime ( &timeinfo );
+    printf ("mktime set tm_wday is %s\n", weekday[timeinfo.tm_wday]);
+    return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0018-SE_mktime/test.cfg b/testsuite/c_test/unit_test/UNIT0018-SE_mktime/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1aa758f7b1a3d8e75f9f41cb3af77fbd3772a489
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0018-SE_mktime/test.cfg
@@ -0,0 +1,2 @@
+compile(sideeffect_mktime)
+run(sideeffect_mktime)
diff --git a/testsuite/c_test/unit_test/UNIT0019-AA_InlineAsm/aliasanalysis_inlineasm.c b/testsuite/c_test/unit_test/UNIT0019-AA_InlineAsm/aliasanalysis_inlineasm.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b386d3926850d6db3199d12c056ec8ed9df958f
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0019-AA_InlineAsm/aliasanalysis_inlineasm.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define ARG 13
+#define EXPECT 26
+
+int func(int input)
+{
+    int result = input;
+    int *a = &input;
+    asm volatile ("ldr x1, [%[a]]\n\t"
+                "add %[result], %[result], x1\n\t"
+                : [result] "+X" (result)
+                : [a] "p" (a)
+                : "x1");
+    return result;
+}
+
+int main()
+{
+    int result = func(ARG);
+    if (EXPECT != result) {
+        printf("Error: expect result is %d, but actual result is %d\n", EXPECT, result);
+        return 1;
+    }
+    return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0019-AA_InlineAsm/expected.txt b/testsuite/c_test/unit_test/UNIT0019-AA_InlineAsm/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0019-AA_InlineAsm/test.cfg b/testsuite/c_test/unit_test/UNIT0019-AA_InlineAsm/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..239cb82f3579e608458e7a8433d4042287de7ed3
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0019-AA_InlineAsm/test.cfg
@@ -0,0 +1,2 @@
+compile(aliasanalysis_inlineasm)
+run(aliasanalysis_inlineasm)
diff --git a/testsuite/c_test/unit_test/UNIT0020-FORTIFY_O2_PHI1/expected.txt b/testsuite/c_test/unit_test/UNIT0020-FORTIFY_O2_PHI1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0020-FORTIFY_O2_PHI1/fortify.c b/testsuite/c_test/unit_test/UNIT0020-FORTIFY_O2_PHI1/fortify.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b074a4dfaedab85ca5bab5755aa7a1be370870f
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0020-FORTIFY_O2_PHI1/fortify.c
@@ -0,0 +1,18 @@
+#include <stdlib.h>
+#include <string.h> // 注意：此头文件必须包含
+
+struct C {
+  char *buf;
+};
+
+int main() {
+  struct C c;
+  if (rand()) {
+    c.buf = malloc(10 * sizeof(char));
+  } else {
+    c.buf = malloc(8 * sizeof(char));
+  }
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 12
+  memcpy(c.buf, "ddddddddddddddddddddd", 12); // warning 10/8
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0020-FORTIFY_O2_PHI1/test.cfg b/testsuite/c_test/unit_test/UNIT0020-FORTIFY_O2_PHI1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0c78df8e4dc51fd8f16d54245e1ddb977df8eed0
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0020-FORTIFY_O2_PHI1/test.cfg
@@ -0,0 +1,11 @@
+FORTIFY_O2:
+compile(fortify)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify.c
+run_err(fortify)
+
+FORTIFY_O1:
+compile(fortify)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify.c
+run_err(fortify)
diff --git a/testsuite/c_test/unit_test/UNIT0021-FORTIFY_O2_StringCheck/expected.txt b/testsuite/c_test/unit_test/UNIT0021-FORTIFY_O2_StringCheck/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0021-FORTIFY_O2_StringCheck/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0021-FORTIFY_O2_StringCheck/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..f7825e657e8dcd07f5c1a140521d7d4473f86f55
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0021-FORTIFY_O2_StringCheck/fortify_O2_string_check.c
@@ -0,0 +1,62 @@
+#define _GNU_SOURCE
+#include <string.h> // 注意：此头文件必须包含
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+volatile void *vx;
+char buf1[20];
+int x;
+int test(int arg, ...) {
+  char buf2[20];
+  va_list ap;
+  memcpy (&buf2[19], "ab", 1);
+  memcpy (&buf2[19], "ab", 2); // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1, but size argument is 2
+  vx = mempcpy (&buf2[19], "ab", 1);
+  vx = mempcpy (&buf2[19], "ab", 2); // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1, but size argument is 2 
+  memmove (&buf2[18], &buf1[10], 2);
+  memmove (&buf2[18], &buf1[10], 3); // CHECK:warning: ‘__builtin___memmove_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  memset (&buf2[16], 'a', 4);
+  memset (&buf2[15], 'b', 6); // CHECK:warning: ‘__builtin___memset_chk’ will always overflow; destination buffer has size 5, but size argument is 6
+  strcpy (&buf2[18], "a");
+  strcpy (&buf2[18], "aaaaaa\0\0\a"); // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2, but size argument is 7
+  strcpy (&buf2[18], "ab"); // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  vx = stpcpy (&buf2[18], "a");
+  vx = stpcpy (&buf2[18], "ab"); // CHECK:warning: ‘__builtin___stpcpy_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  strncpy (&buf2[18], "a", 2);
+  strncpy (&buf2[18], "a", 3); // CHECK:warning: ‘__builtin___strncpy_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  strncpy (&buf2[18], "abc", 2);
+  strncpy (&buf2[18], "abc", 3); // CHECK:warning: ‘__builtin___strncpy_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  memset (buf2, '\0', sizeof (buf2));
+  strcat (&buf2[18], "a");
+  memset (buf2, '\0', sizeof (buf2));
+  strcat (&buf2[18], "ab"); // CHECK:warning: ‘__builtin___strcat_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  sprintf (&buf2[18], "%s", buf1);
+  sprintf (&buf2[18], "%s", "a");
+  sprintf (&buf2[18], "%s", "ab"); // CHECK:warning: ‘__builtin___sprintf_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  sprintf (&buf2[18], "a");
+  sprintf (&buf2[18], "ab"); // CHECK:warning: ‘__builtin___sprintf_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  snprintf (&buf2[18], 2, "%d", x); // sprintf (&buf2[18], "aaaaa%s", "ab");
+  /* N argument to snprintf is the size of the buffer.
+     Although this particular call wouldn't overflow buf2,
+     incorrect buffer size was passed to it and therefore
+     we want a warning and runtime failure.  */
+  snprintf (&buf2[18], 3, "%d", x); // CHECK:warning: ‘__builtin___snprintf_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  va_start (ap, arg);
+  vsprintf (&buf2[18], "a", ap);
+  va_end (ap);
+  va_start (ap, arg);
+  vsprintf (&buf2[18], "abaaaaa", ap); // CHECK:warning: ‘__builtin___vsprintf_chk’ will always overflow; destination buffer has size 2, but size argument is 8
+  va_end (ap);
+  va_start (ap, arg);
+  vsnprintf (&buf2[18], 2, "%sSssssssssssssssssssssss", ap);
+  va_end (ap);
+  va_start (ap, arg);
+  /* See snprintf above.  */
+  vsnprintf (&buf2[18], 3, "%s", ap); // CHECK:warning: ‘__builtin___vsnprintf_chk’ will always overflow; destination buffer has size 2, but size argument is 3
+  va_end (ap);
+  return 0;
+}
+
+int main() {
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0021-FORTIFY_O2_StringCheck/test.cfg b/testsuite/c_test/unit_test/UNIT0021-FORTIFY_O2_StringCheck/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ceeeffade3ded706ba838774a2d8aff0f1c1c3b0
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0021-FORTIFY_O2_StringCheck/test.cfg
@@ -0,0 +1,11 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify_O2_string_check.c
+run(fortify_O2_string_check)
+
+FORTIFY_O1:
+compile(fortify_O2_string_check)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify_O2_string_check.c
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0022-FORTIFY_O2_Memset/expected.txt b/testsuite/c_test/unit_test/UNIT0022-FORTIFY_O2_Memset/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0022-FORTIFY_O2_Memset/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0022-FORTIFY_O2_Memset/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..f0a1e7bcdb8375615c390b8b8d15952fec6b802d
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0022-FORTIFY_O2_Memset/fortify_O2_string_check.c
@@ -0,0 +1,83 @@
+#include <stdio.h>
+#include <string.h> // 注意：此头文件必须包含
+struct Z {
+  char a; // bit
+  char b;
+} z;
+
+
+struct A {
+  char a[10]; // char *
+  struct Z b;
+  char c[10];
+} y, w[4];
+
+int main() {
+  char buf4[1000];
+  struct B {
+    struct A a[2];
+    struct A b;
+    char c[4];
+    char d;
+    double e;
+    _Complex double f;
+  } x;
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 96, but size argument is 1000
+  memcpy(&x, buf4, 1000);             // 96 96
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 96, but size argument is 1000
+  memcpy(&x.a, buf4, 1000);           // 96 44
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 96, but size argument is 1000
+  memcpy(&x.a[0], buf4, 1000);        // 96 44
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 96, but size argument is 1000
+  memcpy(&x.a[0].a, buf4, 1000);      // 96 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 96, but size argument is 1000
+  memcpy(&x.a[0].a[0], buf4, 1000);   // 96 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 93, but size argument is 1000
+  memcpy(&x.a[0].a[3], buf4, 1000);   // 93 41
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 86, but size argument is 1000
+  memcpy(&x.a[0].b, buf4, 1000);      // 86 2
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 64, but size argument is 1000
+  memcpy(&x.a[1].b, buf4, 1000);      // 64 2
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 63, but size argument is 1000
+  memcpy(&x.a[1].b.b, buf4, 1000);    // 63 1
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 41, but size argument is 1000
+  memcpy(&x.a[2].b.b, buf4, 1000);    // 41 1
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 62, but size argument is 1000
+  memcpy(&x.a[1].c, buf4, 1000);      // 62 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 62, but size argument is 1000
+  memcpy(&x.a[1].c[0], buf4, 1000);   // 62 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 59, but size argument is 1000
+  memcpy(&x.a[1].c[3], buf4, 1000);   // 59 7
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 52, but size argument is 1000
+  memcpy(&x.b, buf4, 1000);           // 52 22
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 52, but size argument is 1000
+  memcpy(&x.b.a, buf4, 1000);         // 52 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 52, but size argument is 1000
+  memcpy(&x.b.a[0], buf4, 1000);      // 52 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 49, but size argument is 1000
+  memcpy(&x.b.a[3], buf4, 1000);      // 49 7
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 42, but size argument is 1000
+  memcpy(&x.b.b, buf4, 1000);         // 42 2
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 40, but size argument is 1000
+  memcpy(&x.b.c, buf4, 1000);         // 40 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 40, but size argument is 1000
+  memcpy(&x.b.c[0], buf4, 1000);      // 40 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 37, but size argument is 1000
+  memcpy(&x.b.c[3], buf4, 1000);      // 37 7
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 30, but size argument is 1000
+  memcpy(&x.c, buf4, 1000);           // 30 4
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 30, but size argument is 1000
+  memcpy(&x.c[0], buf4, 1000);        // 30 4
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 29, but size argument is 1000
+  memcpy(&x.c[1], buf4, 1000);        // 29 3
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 26, but size argument is 1000
+  memcpy(&x.d, buf4, 1000);           // 26 1
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 24, but size argument is 1000
+  memcpy(&x.e, buf4, 1000);           // 24 8
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 16, but size argument is 1000
+  memcpy(&x.f, buf4, 1000);           // 16 16
+  struct A a[10];
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 44, but size argument is 1000
+  memcpy(&a[8], buf4, 1000);
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0022-FORTIFY_O2_Memset/test.cfg b/testsuite/c_test/unit_test/UNIT0022-FORTIFY_O2_Memset/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1b9ac8065ba8ba722a5c3ed25946273e1861bc63
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0022-FORTIFY_O2_Memset/test.cfg
@@ -0,0 +1,5 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify_O2_string_check.c
+run_err(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0023-FORTIFY_O2_Strcpy/expected.txt b/testsuite/c_test/unit_test/UNIT0023-FORTIFY_O2_Strcpy/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0023-FORTIFY_O2_Strcpy/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0023-FORTIFY_O2_Strcpy/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..5efe68a9fc44b45e91bfd1393cca325ec0387022
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0023-FORTIFY_O2_Strcpy/fortify_O2_string_check.c
@@ -0,0 +1,81 @@
+#define _GNU_SOURCE
+#include <string.h> // 注意：此头文件必须包含
+#include <stdio.h>
+struct Z {
+  char a; // bit
+  char b;
+} z;
+
+
+struct A {
+  char a[10]; // char *
+  struct Z b;
+  char c[10];
+} y, w[4];
+
+int main() {
+  char buf4[1000];
+  struct B {
+    struct A a[2];
+    struct A b;
+    char c[4];
+    char d;
+    double e;
+    _Complex double f;
+  } x;
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 96, but size argument is 1000
+  strcpy((char*)&x, buf4);             // 96 96
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 44, but size argument is 1000
+  strcpy((char*)&x.a, buf4);           // 96 44
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 44, but size argument is 1000
+  strcpy((char*)&x.a[0], buf4);        // 96 44
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 1000
+  strcpy((char*)&x.a[0].a, buf4);      // 96 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 1000
+  strcpy((char*)&x.a[0].a[0], buf4);   // 96 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 7, but size argument is 1000
+  strcpy((char*)&x.a[0].a[3], buf4);   // 93 7
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2, but size argument is 1000
+  strcpy((char*)&x.a[0].b, buf4);      // 86 2
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2, but size argument is 1000
+  strcpy((char*)&x.a[1].b, buf4);      // 64 2
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1, but size argument is 1000
+  strcpy((char*)&x.a[1].b.b, buf4);    // 63 1
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1, but size argument is 1000
+  strcpy((char*)&x.a[2].b.b, buf4);    // 41 1
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 1000
+  strcpy((char*)&x.a[1].c, buf4);      // 62 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 1000
+  strcpy((char*)&x.a[1].c[0], buf4);   // 62 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 7, but size argument is 1000
+  strcpy((char*)&x.a[1].c[3], buf4);   // 59 7
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 22, but size argument is 1000
+  strcpy((char*)&x.b, buf4);           // 52 22
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 1000
+  strcpy((char*)&x.b.a, buf4);         // 52 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 1000
+  strcpy((char*)&x.b.a[0], buf4);      // 52 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 7, but size argument is 1000
+  strcpy((char*)&x.b.a[3], buf4);      // 49 7
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2, but size argument is 1000
+  strcpy((char*)&x.b.b, buf4);         // 42 2
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 1000
+  strcpy((char*)&x.b.c, buf4);         // 40 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 1000
+  strcpy((char*)&x.b.c[0], buf4);      // 40 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 7, but size argument is 1000
+  strcpy((char*)&x.b.c[3], buf4);      // 37 7
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4, but size argument is 1000
+  strcpy((char*)&x.c, buf4);           // 30 4
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4, but size argument is 1000
+  strcpy((char*)&x.c[0], buf4);        // 30 4
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 3, but size argument is 1000
+  strcpy((char*)&x.c[1], buf4);        // 29 3
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1, but size argument is 1000
+  strcpy((char*)&x.d, buf4);           // 26 1
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 8, but size argument is 1000
+  strcpy((char*)&x.e, buf4);           // 24 8
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 16, but size argument is 1000
+  strcpy((char*)&x.f, buf4);           // 16 16
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0023-FORTIFY_O2_Strcpy/test.cfg b/testsuite/c_test/unit_test/UNIT0023-FORTIFY_O2_Strcpy/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1b9ac8065ba8ba722a5c3ed25946273e1861bc63
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0023-FORTIFY_O2_Strcpy/test.cfg
@@ -0,0 +1,5 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify_O2_string_check.c
+run_err(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0024-FORTIFY_O2_Memset2/expected.txt b/testsuite/c_test/unit_test/UNIT0024-FORTIFY_O2_Memset2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0024-FORTIFY_O2_Memset2/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0024-FORTIFY_O2_Memset2/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..02873023e969df81ef8e2313fec53867b6aea740
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0024-FORTIFY_O2_Memset2/fortify_O2_string_check.c
@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <string.h> // 注意：此头文件必须包含
+struct C {
+  short a[10];
+} c;
+
+struct Z {
+  int a[10]; // bit
+  struct C b[5];
+} z;
+
+
+struct A {
+  int a[10]; // char *
+  struct Z b[10];
+  short c[10];
+} y, w[4];
+
+int main() {
+  char buf4[10000];
+  struct B {
+    struct A a[2];
+    struct A b;
+    int c[4];
+    char d;
+    double e;
+    _Complex double f;
+  } x;
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 2374, but size argument is 10000
+  memcpy(&x.a[1].b[3].b[4].a[5], buf4, 10000);
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 2384, but size argument is 10000
+  memcpy(&x.a[1].b[3].b[4].a, buf4, 10000);
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 2424, but size argument is 10000
+  memcpy(&x.a[1].b[3].b[2], buf4, 10000);
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 2464, but size argument is 10000
+  memcpy(&x.a[1].b[3].b, buf4, 10000);
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 2484, but size argument is 10000
+  memcpy(&x.a[1].b[3].a[5], buf4, 10000);
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 2504, but size argument is 10000
+  memcpy(&x.a[1].b[3].a, buf4, 10000);
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  memcpy(&x, buf4, 10000);             // 96 96
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  memcpy(&x.a, buf4, 10000);           // 96 44
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  memcpy(&x.a[0], buf4, 10000);        // 96 44
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  memcpy(&x.a[0].a, buf4, 10000);      // 96 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  memcpy(&x.a[0].a[0], buf4, 10000);   // 96 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 4412, but size argument is 10000
+  memcpy(&x.a[0].a[3], buf4, 10000);   // 93 41
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 4384, but size argument is 10000
+  memcpy(&x.a[0].b, buf4, 10000);      // 86 2
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 2924, but size argument is 10000
+  memcpy(&x.a[1].b, buf4, 10000);      // 64 2
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 2884, but size argument is 10000
+  memcpy(&x.a[1].b[0].b, buf4, 10000);    // 63 1
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1144, but size argument is 10000
+  memcpy(&x.a[2].b[2].b, buf4, 10000);    // 41 1
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1524, but size argument is 10000
+  memcpy(&x.a[1].c, buf4, 10000);      // 62 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1524, but size argument is 10000
+  memcpy(&x.a[1].c[0], buf4, 10000);   // 62 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1518, but size argument is 10000
+  memcpy(&x.a[1].c[3], buf4, 10000);   // 59 7
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1504, but size argument is 10000
+  memcpy(&x.b, buf4, 10000);           // 52 22
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1504, but size argument is 10000
+  memcpy(&x.b.a, buf4, 10000);         // 52 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1504, but size argument is 10000
+  memcpy(&x.b.a[0], buf4, 10000);      // 52 10
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1492, but size argument is 10000
+  memcpy(&x.b.a[3], buf4, 10000);      // 49 7
+  // CHECK:warning: ‘__builtin___memcpy_chk’ will always overflow; destination buffer has size 1464, but size argument is 10000
+  memcpy(&x.b.b, buf4, 10000);         // 42 2
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0024-FORTIFY_O2_Memset2/test.cfg b/testsuite/c_test/unit_test/UNIT0024-FORTIFY_O2_Memset2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1b9ac8065ba8ba722a5c3ed25946273e1861bc63
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0024-FORTIFY_O2_Memset2/test.cfg
@@ -0,0 +1,5 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify_O2_string_check.c
+run_err(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0025-FORTIFY_O2_Strcpy2/expected.txt b/testsuite/c_test/unit_test/UNIT0025-FORTIFY_O2_Strcpy2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0025-FORTIFY_O2_Strcpy2/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0025-FORTIFY_O2_Strcpy2/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..e8e5ec72b41a24783cd56b388c774a23640b59d5
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0025-FORTIFY_O2_Strcpy2/fortify_O2_string_check.c
@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <string.h> // 注意：此头文件必须包含
+struct C {
+  short a[10];
+} c;
+
+struct Z {
+  int a[10]; // bit
+  struct C b[5];
+} z;
+
+
+struct A {
+  int a[10]; // char *
+  struct Z b[10];
+  short c[10];
+} y, w[4];
+
+int main() {
+  char buf4[10000];
+  struct B {
+    struct A a[2];
+    struct A b;
+    int c[4];
+    char d;
+    double e;
+    _Complex double f;
+  } x;
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 10, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].b[4].a[5], buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 20, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].b[4].a, buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 60, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].b[2], buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 100, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].b, buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 20, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].a[5], buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 40, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].a, buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  strcpy((char*)&x, buf4);             // 96 96
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2920, but size argument is 10000
+  strcpy((char*)&x.a, buf4);           // 96 44
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2920, but size argument is 10000
+  strcpy((char*)&x.a[0], buf4);        // 96 44
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 40, but size argument is 10000
+  strcpy((char*)&x.a[0].a, buf4);      // 96 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 40, but size argument is 10000
+  strcpy((char*)&x.a[0].a[0], buf4);   // 96 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 28, but size argument is 10000
+  strcpy((char*)&x.a[0].a[3], buf4);   // 93 41
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1400, but size argument is 10000
+  strcpy((char*)&x.a[0].b, buf4);      // 86 2
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1400, but size argument is 10000
+  strcpy((char*)&x.a[1].b, buf4);      // 64 2
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 100, but size argument is 10000
+  strcpy((char*)&x.a[1].b[0].b, buf4);    // 63 1
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 100, but size argument is 10000
+  strcpy((char*)&x.a[2].b[2].b, buf4);    // 41 1
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 20, but size argument is 10000
+  strcpy((char*)&x.a[1].c, buf4);      // 62 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 20, but size argument is 10000
+  strcpy((char*)&x.a[1].c[0], buf4);   // 62 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 14, but size argument is 10000
+  strcpy((char*)&x.a[1].c[3], buf4);   // 59 7
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1460, but size argument is 10000
+  strcpy((char*)&x.b, buf4);           // 52 22
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 40, but size argument is 10000
+  strcpy((char*)&x.b.a, buf4);         // 52 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 40, but size argument is 10000
+  strcpy((char*)&x.b.a[0], buf4);      // 52 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 28, but size argument is 10000
+  strcpy((char*)&x.b.a[3], buf4);      // 49 7
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1400, but size argument is 10000
+  strcpy((char*)&x.b.b, buf4);         // 42 2
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0025-FORTIFY_O2_Strcpy2/test.cfg b/testsuite/c_test/unit_test/UNIT0025-FORTIFY_O2_Strcpy2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5db460630502eba1a17f65dbf739067a90205e42
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0025-FORTIFY_O2_Strcpy2/test.cfg
@@ -0,0 +1,5 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify_O2_string_check.c
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0026-FORTIFY_O1_Strcpy/expected.txt b/testsuite/c_test/unit_test/UNIT0026-FORTIFY_O1_Strcpy/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0026-FORTIFY_O1_Strcpy/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0026-FORTIFY_O1_Strcpy/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..c00a7b0e744f1a0ab66ea6982eaa9ff19b7c44bb
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0026-FORTIFY_O1_Strcpy/fortify_O2_string_check.c
@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <string.h> // 注意：此头文件必须包含
+struct C {
+  short a[10];
+} c;
+
+struct Z {
+  int a[10]; // bit
+  struct C b[5];
+} z;
+
+
+struct A {
+  int a[10]; // char *
+  struct Z b[10];
+  short c[10];
+} y, w[4];
+
+int main() {
+  char buf4[10000];
+  struct B {
+    struct A a[2];
+    struct A b;
+    int c[4];
+    char d;
+    double e;
+    _Complex double f;
+  } x;
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2374, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].b[4].a[5], buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2384, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].b[4].a, buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2424, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].b[2], buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2464, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].b, buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2484, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].a[5], buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2504, but size argument is 10000
+  strcpy((char*)&x.a[1].b[3].a, buf4);
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  strcpy((char*)&x, buf4);             // 96 96
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  strcpy((char*)&x.a, buf4);           // 96 44
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  strcpy((char*)&x.a[0], buf4);        // 96 44
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  strcpy((char*)&x.a[0].a, buf4);      // 96 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4424, but size argument is 10000
+  strcpy((char*)&x.a[0].a[0], buf4);   // 96 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4412, but size argument is 10000
+  strcpy((char*)&x.a[0].a[3], buf4);   // 93 41
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 4384, but size argument is 10000
+  strcpy((char*)&x.a[0].b, buf4);      // 86 2
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2924, but size argument is 10000
+  strcpy((char*)&x.a[1].b, buf4);      // 64 2
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 2884, but size argument is 10000
+  strcpy((char*)&x.a[1].b[0].b, buf4);    // 63 1
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1144, but size argument is 10000
+  strcpy((char*)&x.a[2].b[2].b, buf4);    // 41 1
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1524, but size argument is 10000
+  strcpy((char*)&x.a[1].c, buf4);      // 62 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1524, but size argument is 10000
+  strcpy((char*)&x.a[1].c[0], buf4);   // 62 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1518, but size argument is 10000
+  strcpy((char*)&x.a[1].c[3], buf4);   // 59 7
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1504, but size argument is 10000
+  strcpy((char*)&x.b, buf4);           // 52 22
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1504, but size argument is 10000
+  strcpy((char*)&x.b.a, buf4);         // 52 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1504, but size argument is 10000
+  strcpy((char*)&x.b.a[0], buf4);      // 52 10
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1492, but size argument is 10000
+  strcpy((char*)&x.b.a[3], buf4);      // 49 7
+  // CHECK:warning: ‘__builtin___strcpy_chk’ will always overflow; destination buffer has size 1464, but size argument is 10000
+  strcpy((char*)&x.b.b, buf4);         // 42 2
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0026-FORTIFY_O1_Strcpy/test.cfg b/testsuite/c_test/unit_test/UNIT0026-FORTIFY_O1_Strcpy/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d3859df873cb35b187596586d952035948d6419
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0026-FORTIFY_O1_Strcpy/test.cfg
@@ -0,0 +1,5 @@
+FORTIFY_O1:
+compile(fortify_O2_string_check)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify_O2_string_check.c
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0027-FORTIFY_O2_Sprintf/expected.txt b/testsuite/c_test/unit_test/UNIT0027-FORTIFY_O2_Sprintf/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..56b6510f1d6b862ca30ce2e7c05b48760ba28fd7
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0027-FORTIFY_O2_Sprintf/expected.txt
@@ -0,0 +1 @@
+11111
\ No newline at end of file
diff --git a/testsuite/c_test/unit_test/UNIT0027-FORTIFY_O2_Sprintf/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0027-FORTIFY_O2_Sprintf/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..ce9ef62b4dd3926430d8220639440b5f5d5318ce
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0027-FORTIFY_O2_Sprintf/fortify_O2_string_check.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <string.h>
+
+#define LEN 10
+
+int main()
+{
+  char dest[LEN] = "11111";
+  char *str = "abcdefghi";
+  int res;
+  int err = 0;
+
+  snprintf(dest, 0, "%s", str);
+  printf("%s", dest);
+  if(dest[0] != '1') {
+    err++;
+  }
+
+  snprintf(dest, LEN, "%s", str);
+  res = memcmp(dest, str, LEN - 1);
+  if(res != 0) {
+    err++;
+  }
+  return err;
+}
+
diff --git a/testsuite/c_test/unit_test/UNIT0027-FORTIFY_O2_Sprintf/test.cfg b/testsuite/c_test/unit_test/UNIT0027-FORTIFY_O2_Sprintf/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..12b02dcfa8aeac944f4d2eca6c93a0797768e01c
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0027-FORTIFY_O2_Sprintf/test.cfg
@@ -0,0 +1,3 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0028-FORTIFY_O2_Sprintf2/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0028-FORTIFY_O2_Sprintf2/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..a54ec4c1404733c41383e8cd2bee9b65e130b745
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0028-FORTIFY_O2_Sprintf2/fortify_O2_string_check.c
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <string.h>
+
+#define LEN 5
+
+int main()
+{
+  char dest[LEN] = "111";
+  char *str = "adcde";
+  int res;
+  int err = 0;
+  // CHECK:warning: ‘__builtin___sprintf_chk’ will always overflow; destination buffer has size 5, but size argument is 6
+  sprintf(dest, "%s", str);
+  res = memcmp(dest, str, LEN);
+  if(res != 0) {
+    err++;
+  }
+  return err;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0028-FORTIFY_O2_Sprintf2/test.cfg b/testsuite/c_test/unit_test/UNIT0028-FORTIFY_O2_Sprintf2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..090cd9e07acab28a1561a82530f40271fb1038e6
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0028-FORTIFY_O2_Sprintf2/test.cfg
@@ -0,0 +1,4 @@
+FORTIFY_O1:
+compile(fortify_O2_string_check)
+sort compile.log -t ':' -k 3 -n -o compile.log # sort warning by index
+cat compile.log | ${OUT_ROOT}/tools/bin/FileCheck fortify_O2_string_check.c
diff --git a/testsuite/c_test/unit_test/UNIT0029-FORTIFY_O2_stpcpy/expected.txt b/testsuite/c_test/unit_test/UNIT0029-FORTIFY_O2_stpcpy/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0029-FORTIFY_O2_stpcpy/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0029-FORTIFY_O2_stpcpy/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..47ce8d3158fba83369dceedb1e12362475e60d18
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0029-FORTIFY_O2_stpcpy/fortify_O2_string_check.c
@@ -0,0 +1,23 @@
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <string.h>
+
+#define LEN 6
+
+int main()
+{
+    char dest[LEN];
+    char *str = "abcde";
+    int res;
+    char *cp = dest;
+    int err = 0;
+
+    cp = stpcpy(dest, str);//stpcpy预期返回值为指向dest结尾'\0'的指针
+    res = memcmp(dest, str, LEN);
+    if(res != 0 || cp != &dest[LEN - 1]) {
+        printf("cp = %p, dest[5] = %p", cp , &dest[5]);
+        err++;
+    }
+    return err;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0029-FORTIFY_O2_stpcpy/test.cfg b/testsuite/c_test/unit_test/UNIT0029-FORTIFY_O2_stpcpy/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a595ea40297a6accedeed5fe46eb31aa9ca58131
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0029-FORTIFY_O2_stpcpy/test.cfg
@@ -0,0 +1,7 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+run(fortify_O2_string_check)
+
+CO2:
+compile(fortify_O2_string_check)
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0030-FORTIFY_O2_mempcpy/expected.txt b/testsuite/c_test/unit_test/UNIT0030-FORTIFY_O2_mempcpy/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0030-FORTIFY_O2_mempcpy/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0030-FORTIFY_O2_mempcpy/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..75ee1adde44341d6dcc6a287aa582a6f64246d2a
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0030-FORTIFY_O2_mempcpy/fortify_O2_string_check.c
@@ -0,0 +1,29 @@
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <string.h>
+
+#define LEN 6
+
+int main()
+{
+    char dest[LEN] = "11111";
+    char *str = "abcde";
+    int res;
+    int err = 0;
+    char *cp;
+
+    cp = mempcpy(dest, str, 0);//mempcpy返回指针指向复制到dest后的字符串后一位，在此处由于长度为0指向dest本身
+    if(dest[0] != '1' || cp != dest) {
+        printf("cp =%p, dest = %p\n", cp, dest);
+        err++;
+    }
+
+    cp = mempcpy(dest, str, LEN);//在此处长度为LEN指向dest + LEN
+    res = memcmp(dest, str, LEN);
+    if(res != 0 || cp != dest + LEN) {
+        printf("cp =%p, dest = %p\n", cp, dest + LEN);
+        err++;
+    }
+    return err;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0030-FORTIFY_O2_mempcpy/test.cfg b/testsuite/c_test/unit_test/UNIT0030-FORTIFY_O2_mempcpy/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a595ea40297a6accedeed5fe46eb31aa9ca58131
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0030-FORTIFY_O2_mempcpy/test.cfg
@@ -0,0 +1,7 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+run(fortify_O2_string_check)
+
+CO2:
+compile(fortify_O2_string_check)
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0031-VRP_O2_FindVRP/expected.txt b/testsuite/c_test/unit_test/UNIT0031-VRP_O2_FindVRP/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0031-VRP_O2_FindVRP/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0031-VRP_O2_FindVRP/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..cce8ba97c4b36040e671a9d7c5a5725c9a28d40e
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0031-VRP_O2_FindVRP/fortify_O2_string_check.c
@@ -0,0 +1,100 @@
+extern void abort ();
+
+double
+dneg (double x)
+{
+  return -x;
+}
+
+double
+dmult (double x)
+{
+  return -1.0 * x;
+}
+
+double
+ddiv (double x)
+{
+  return x / -1.0;
+}
+
+float
+fneg (float x)
+{
+  return -x;
+}
+
+float
+fmult (float x)
+{
+  return -1.0f * x;
+}
+
+float
+fdiv (float x)
+{
+  return x / -1.0f;
+}
+
+
+void
+ftest(float src, float dst)
+{
+  if (fneg (src) != dst)
+    abort ();
+
+  if (src != fneg (dst))
+    abort ();
+
+  if (fmult (src) != dst)
+    abort ();
+
+  if (src != fmult (dst))
+    abort ();
+
+  if (fdiv (src) != dst)
+    abort ();
+
+  if (src != fdiv(dst))
+    abort ();
+}
+void
+dtest(double src, double dst)
+{
+  if (dneg (src) != dst)
+    abort ();
+
+  if (src != dneg (dst))
+    abort ();
+
+  if (dmult (src) != dst)
+    abort ();
+
+  if (src != dmult (dst))
+    abort ();
+
+  if (ddiv (src) != dst)
+    abort ();
+
+  if (src != ddiv(dst))
+    abort ();
+}
+
+
+int
+main ()
+{
+  ftest (1.0f, -1.0f);
+  ftest (2.0f, -2.0f);
+  ftest (-3.0f, 3.0f);
+  ftest (0.0f, -0.0f);
+  ftest (-0.0f, 0.0f);
+
+  dtest (1.0, -1.0);
+  dtest (2.0, -2.0);
+  dtest (-3.0, 3.0);
+  dtest (0.0, -0.0);
+  dtest (-0.0, 0.0);
+  
+  return 0;
+}
diff --git a/testsuite/c_test/unit_test/UNIT0031-VRP_O2_FindVRP/test.cfg b/testsuite/c_test/unit_test/UNIT0031-VRP_O2_FindVRP/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..89bb02c68ce7d08100d4dceb5fa0094e17b3a743
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0031-VRP_O2_FindVRP/test.cfg
@@ -0,0 +1,3 @@
+CO2:
+compile(fortify_O2_string_check)
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0032-FORTIFY_O2_sprintf/expected.txt b/testsuite/c_test/unit_test/UNIT0032-FORTIFY_O2_sprintf/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0032-FORTIFY_O2_sprintf/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0032-FORTIFY_O2_sprintf/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..82b4ae40a772954ba1983a14917efec5d146bc2c
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0032-FORTIFY_O2_sprintf/fortify_O2_string_check.c
@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+#define LEN 5
+
+int main(int argc, char * argv[])
+{
+    char dest[LEN - 3];
+    char *str;
+    int res;
+    int err = 0;
+
+    if(argc > 1) {
+        str = MALLOC(LEN, char);
+        str = "abcd";
+    } else {
+        str = MALLOC(LEN + 1, char);
+        str = "abcde";
+    }
+
+    sprintf(dest, "%s", str);
+    res = memcmp(dest, str, LEN);
+    if(res != 0) {
+        err++;
+    }
+    return err;
+}
+
+//测试在打开fortify_source下已知destnation，但在运行时才能确定需要写入的副本大小时，应该调用检查函数在运行发生溢出时报错
+// RUN: %CC %CFLAGS   %FORTIFY_2 %s -o %t
+// RUN: %OBJDUMP -S %t | FileCheck %s
+// CHECK: __sprintf_chk
+// RUN: ! %SIM %t
+
diff --git a/testsuite/c_test/unit_test/UNIT0032-FORTIFY_O2_sprintf/test.cfg b/testsuite/c_test/unit_test/UNIT0032-FORTIFY_O2_sprintf/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dbf872737a3cc47be1c15e06356620cd2da95e4a
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0032-FORTIFY_O2_sprintf/test.cfg
@@ -0,0 +1,7 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+run_err(fortify_O2_string_check)
+
+CO2:
+compile(fortify_O2_string_check)
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0033-FORTIFY_O2_vsprintf/expected.txt b/testsuite/c_test/unit_test/UNIT0033-FORTIFY_O2_vsprintf/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0033-FORTIFY_O2_vsprintf/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0033-FORTIFY_O2_vsprintf/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..b0b0e62f199a72ef6d587e644f858cf2ee2b3aeb
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0033-FORTIFY_O2_vsprintf/fortify_O2_string_check.c
@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+#define LEN 5
+
+static char dest[LEN - 1] = "111";
+
+static void vsprintf_base(int arg, ...)
+{
+    char* str;
+    if(rand()) {
+        str = MALLOC(LEN + 1, char);
+        str = "abcde";
+    } else {
+        str = MALLOC(LEN, char);
+        str = "abcd";
+    }
+    va_list args;
+    va_start(args, arg);
+    vsprintf(dest, str, args);
+    va_end(args);
+}
+
+int main()
+{
+    int res;
+    int err = 0;
+
+    vsprintf_base(res);
+    res = memcmp(dest, "abcd", LEN - 1);
+    if(res != 0) {
+        err++;
+    }
+    return err;
+}
+// RUN: %CC %CFLAGS   %FORTIFY_2 %s -o %t
+// RUN: %OBJDUMP -S %t | FileCheck %s
+// CHECK: __vsprintf_chk
+// RUN: ! %SIM %t
diff --git a/testsuite/c_test/unit_test/UNIT0033-FORTIFY_O2_vsprintf/test.cfg b/testsuite/c_test/unit_test/UNIT0033-FORTIFY_O2_vsprintf/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dbf872737a3cc47be1c15e06356620cd2da95e4a
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0033-FORTIFY_O2_vsprintf/test.cfg
@@ -0,0 +1,7 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+run_err(fortify_O2_string_check)
+
+CO2:
+compile(fortify_O2_string_check)
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/unit_test/UNIT0034-FORTIFY_O2_vsnprintf/expected.txt b/testsuite/c_test/unit_test/UNIT0034-FORTIFY_O2_vsnprintf/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/unit_test/UNIT0034-FORTIFY_O2_vsnprintf/fortify_O2_string_check.c b/testsuite/c_test/unit_test/UNIT0034-FORTIFY_O2_vsnprintf/fortify_O2_string_check.c
new file mode 100644
index 0000000000000000000000000000000000000000..a526ad7805639ddfc2a2e7e276d4778e98780d16
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0034-FORTIFY_O2_vsnprintf/fortify_O2_string_check.c
@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define MALLOC(n, type) ((type *) malloc((n)* sizeof(type)))
+#define LEN 5
+
+static char dest[LEN - 1] = "111";
+
+static void vsnprintf_base(int arg, ...)
+{
+    char* str;
+    if(rand()) {
+        str = MALLOC(LEN + 1, char);
+        str = "abcde";
+    } else {
+        str = MALLOC(LEN, char);
+        str = "abcd";
+    }
+    va_list args;
+    va_start(args, arg);
+    vsnprintf(dest, strlen(str), str, args);
+    va_end(args);
+}
+
+int main()
+{
+    int res;
+    int err = 0;
+
+    vsnprintf_base(res);
+    res = memcmp(dest, "abcd", LEN - 1);
+    if(res != 0) {
+        err++;
+    }
+    return err;
+}
+
+
+// RUN: %CC %CFLAGS   %FORTIFY_2 %s -o %t
+// RUN: %OBJDUMP -S %t | FileCheck %s
+// CHECK: __vsnprintf_chk
+// RUN: ! %SIM %t
diff --git a/testsuite/c_test/unit_test/UNIT0034-FORTIFY_O2_vsnprintf/test.cfg b/testsuite/c_test/unit_test/UNIT0034-FORTIFY_O2_vsnprintf/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dbf872737a3cc47be1c15e06356620cd2da95e4a
--- /dev/null
+++ b/testsuite/c_test/unit_test/UNIT0034-FORTIFY_O2_vsnprintf/test.cfg
@@ -0,0 +1,7 @@
+FORTIFY_O2:
+compile(fortify_O2_string_check)
+run_err(fortify_O2_string_check)
+
+CO2:
+compile(fortify_O2_string_check)
+run(fortify_O2_string_check)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0001-HelloWorld/HelloWorld.c b/testsuite/c_test/x64_be_enable_test/ENABLE0001-HelloWorld/HelloWorld.c
new file mode 100644
index 0000000000000000000000000000000000000000..95021b9a33e558652d666d5f960684e4faa3e099
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0001-HelloWorld/HelloWorld.c
@@ -0,0 +1,6 @@
+#include "stdio.h"
+
+int main() {
+  printf("hellowold");
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0001-HelloWorld/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0001-HelloWorld/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bc23ac2ba05a77ee71525d5c882301e293016c5b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0001-HelloWorld/expected.txt
@@ -0,0 +1 @@
+hellowold
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0001-HelloWorld/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0001-HelloWorld/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0001-HelloWorld/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0002-AddInt/AddInt.c b/testsuite/c_test/x64_be_enable_test/ENABLE0002-AddInt/AddInt.c
new file mode 100644
index 0000000000000000000000000000000000000000..a405a5023af3d77451b226ba4de3e26db7d5516c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0002-AddInt/AddInt.c
@@ -0,0 +1,7 @@
+int main() {
+  int a = 1;
+  int b = 2;
+  int c = a + b;
+  printf("%d", c);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0002-AddInt/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0002-AddInt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e440e5c842586965a7fb77deda2eca68612b1f53
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0002-AddInt/expected.txt
@@ -0,0 +1 @@
+3
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0002-AddInt/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0002-AddInt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9861e6f729047497e5ee407f967c83d764a22e2e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0002-AddInt/test.cfg
@@ -0,0 +1,2 @@
+compile(AddInt)
+run(AddInt)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0003-SubInt/SubInt.c b/testsuite/c_test/x64_be_enable_test/ENABLE0003-SubInt/SubInt.c
new file mode 100644
index 0000000000000000000000000000000000000000..98bbe85dff84b3eabb4b93b16680706702feced5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0003-SubInt/SubInt.c
@@ -0,0 +1,9 @@
+#include "stdio.h"
+
+int main() {
+  int i = 5;
+  int j = 2;
+  int k = i - j;
+  printf("%d", k);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0003-SubInt/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0003-SubInt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e440e5c842586965a7fb77deda2eca68612b1f53
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0003-SubInt/expected.txt
@@ -0,0 +1 @@
+3
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0003-SubInt/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0003-SubInt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e5e605876be3e07065293277b3be006f903ffd1e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0003-SubInt/test.cfg
@@ -0,0 +1,2 @@
+compile(SubInt)
+run(SubInt)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0004-Shl/Shl.c b/testsuite/c_test/x64_be_enable_test/ENABLE0004-Shl/Shl.c
new file mode 100644
index 0000000000000000000000000000000000000000..d8b5a574e747e16ca09453e31912256220c4cf5b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0004-Shl/Shl.c
@@ -0,0 +1,7 @@
+int main() {
+  int a = 1;
+  int b = a << 4;
+  int c = a << b;
+  printf("%d,%d\n", b, c);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0004-Shl/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0004-Shl/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e46b08d9eeb384bfad4b7c84f431a0cbb5ec7eb7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0004-Shl/expected.txt
@@ -0,0 +1 @@
+16,65536
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0004-Shl/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0004-Shl/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b75a8eb34317224ddac07403306114ebf571f654
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0004-Shl/test.cfg
@@ -0,0 +1,2 @@
+compile(Shl)
+run(Shl)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0005-Goto/Goto.c b/testsuite/c_test/x64_be_enable_test/ENABLE0005-Goto/Goto.c
new file mode 100644
index 0000000000000000000000000000000000000000..5cbefeafc23f2502f0779d3fb58a6c4591a73f76
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0005-Goto/Goto.c
@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int main()
+{
+  int x = 1;
+  goto Lab;
+  x = x + 1;
+  Lab: x = x + 5;
+  printf("x = %d\n", x);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0005-Goto/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0005-Goto/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bc173cabcfc58d70e8264cddb67a901f61849343
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0005-Goto/expected.txt
@@ -0,0 +1 @@
+x = 6
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0005-Goto/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0005-Goto/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8d5f0fb5e6376c724305408fc29934ee4a035d76
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0005-Goto/test.cfg
@@ -0,0 +1,2 @@
+compile(Goto)
+run(Goto)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0006-IAssign/IAssign.c b/testsuite/c_test/x64_be_enable_test/ENABLE0006-IAssign/IAssign.c
new file mode 100644
index 0000000000000000000000000000000000000000..ae874ab9ad2e0263abd273118256b78976780dfd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0006-IAssign/IAssign.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+int main()
+{
+  int x = 1;
+  int *p = &x;
+  *p = x + 5;
+  printf("*p = %d\n", x);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0006-IAssign/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0006-IAssign/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2128d179901bbe9f190d5127ddbfa50e48c7ba14
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0006-IAssign/expected.txt
@@ -0,0 +1 @@
+*p = 6
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0006-IAssign/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0006-IAssign/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d73c91e32dac560174ff8119ae2b54238298f5e1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0006-IAssign/test.cfg
@@ -0,0 +1,2 @@
+compile(IAssign)
+run(IAssign)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0007-Conv/Conv.c b/testsuite/c_test/x64_be_enable_test/ENABLE0007-Conv/Conv.c
new file mode 100644
index 0000000000000000000000000000000000000000..c28bc9a7c0ff60ab2db20b1ea762ae52dc4d2ba6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0007-Conv/Conv.c
@@ -0,0 +1,14 @@
+int callconv(int a, int b, int c, int d, int e, int f) {
+  return a + b + c + d + e + f;
+}
+int main() {
+  int a = 0;
+  int b = 1;
+  int c = 2;
+  int d = 3;
+  int e = 4;
+  int f = 5;
+  int h = callconv(a, b, c, d, e, f);
+  printf("%d", h);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0007-Conv/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0007-Conv/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3f10ffe7a4c473619c926cfb1e8d95e726e5a0ec
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0007-Conv/expected.txt
@@ -0,0 +1 @@
+15
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0007-Conv/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0007-Conv/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8ce6a5cbfe32c67faa15b4a9d8ec0bb5faaae52d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0007-Conv/test.cfg
@@ -0,0 +1,2 @@
+compile(Conv)
+run(Conv)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0008-Neg/Neg.c b/testsuite/c_test/x64_be_enable_test/ENABLE0008-Neg/Neg.c
new file mode 100644
index 0000000000000000000000000000000000000000..f1af252a2e9c1fb474b3641d523fb6dc3b705946
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0008-Neg/Neg.c
@@ -0,0 +1,5 @@
+int main() {
+  int a = 5;
+  printf("%d\n", -a);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0008-Neg/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0008-Neg/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d83d2bc1dc4c75557d22594f5c9defc741df1038
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0008-Neg/expected.txt
@@ -0,0 +1 @@
+-5
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0008-Neg/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0008-Neg/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..34a35648622d1d0f62a3419cfc418667837758f5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0008-Neg/test.cfg
@@ -0,0 +1,2 @@
+compile(Neg)
+run(Neg)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0009-Iread/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0009-Iread/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b1bd38b62a0800a4f6a80c34e21c5acffae52c7e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0009-Iread/expected.txt
@@ -0,0 +1 @@
+13
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0009-Iread/iread.c b/testsuite/c_test/x64_be_enable_test/ENABLE0009-Iread/iread.c
new file mode 100644
index 0000000000000000000000000000000000000000..9cb755419e2e4387bd0876f634cd64204e69dddd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0009-Iread/iread.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+int main () {
+        int d = 13;
+        int *a = &d;
+        int b = *a;
+        int c = b;
+        printf("%d\n", c);
+        return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0009-Iread/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0009-Iread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..31f98d678ce0b2db5768d0aaa83e9966d035a0a0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0009-Iread/test.cfg
@@ -0,0 +1,2 @@
+compile(iread)
+run(iread)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0010-Bior-Bxor/bior-bxor.c b/testsuite/c_test/x64_be_enable_test/ENABLE0010-Bior-Bxor/bior-bxor.c
new file mode 100644
index 0000000000000000000000000000000000000000..c1b8ae0742e6a654b0077cc056862fcbd977ec27
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0010-Bior-Bxor/bior-bxor.c
@@ -0,0 +1,10 @@
+#include "stdio.h"
+int main() {
+	int a = 1;
+	int b = 2;
+	int m = a | b;
+	printf("%d\n", m);
+	int x = a ^ b;
+	printf("%d\n", x);
+	return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0010-Bior-Bxor/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0010-Bior-Bxor/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a5c8806279fa7d6b7d04418a47e21b7e89ab18f8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0010-Bior-Bxor/expected.txt
@@ -0,0 +1,2 @@
+3
+3
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0010-Bior-Bxor/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0010-Bior-Bxor/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4c49411ec40518522a807da255c6e377629b8367
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0010-Bior-Bxor/test.cfg
@@ -0,0 +1,2 @@
+compile(bior-bxor)
+run(bior-bxor)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0011-Brfalse/Brfalse.c b/testsuite/c_test/x64_be_enable_test/ENABLE0011-Brfalse/Brfalse.c
new file mode 100644
index 0000000000000000000000000000000000000000..1545a039cb69001afb9cd105098ec6ffa450fe6f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0011-Brfalse/Brfalse.c
@@ -0,0 +1,9 @@
+int main() {
+  int a = 0;
+  if (a == 0) {
+    a += 5;
+  }
+  a += 10;
+  printf("%d", a);
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0011-Brfalse/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0011-Brfalse/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3f10ffe7a4c473619c926cfb1e8d95e726e5a0ec
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0011-Brfalse/expected.txt
@@ -0,0 +1 @@
+15
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0011-Brfalse/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0011-Brfalse/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..02d243a96747b602a5417de43f899da62a6f90f3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0011-Brfalse/test.cfg
@@ -0,0 +1,2 @@
+compile(Brfalse)
+run(Brfalse)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0012-Mul/Mul.c b/testsuite/c_test/x64_be_enable_test/ENABLE0012-Mul/Mul.c
new file mode 100644
index 0000000000000000000000000000000000000000..9b01e524bff85305c437d8cc88e61f5e07ebad75
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0012-Mul/Mul.c
@@ -0,0 +1,5 @@
+int main() {
+  int a = 3, b = 4;
+  printf("%d", a * b);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0012-Mul/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0012-Mul/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3cacc0b93c9c9c03a72da624ca28a09ba5c1336f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0012-Mul/expected.txt
@@ -0,0 +1 @@
+12
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0012-Mul/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0012-Mul/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..babded49058da41c2ea7706686049c59ccccf5aa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0012-Mul/test.cfg
@@ -0,0 +1,2 @@
+compile(Mul)
+run(Mul)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0013-Struct/Struct.c b/testsuite/c_test/x64_be_enable_test/ENABLE0013-Struct/Struct.c
new file mode 100644
index 0000000000000000000000000000000000000000..a5f568cfb017bb416792ac775efc6b81c9e67d1e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0013-Struct/Struct.c
@@ -0,0 +1,12 @@
+typedef struct d {
+  int a;
+  int b;
+  int c;
+  int d;
+} IntStruct;
+
+int main() {
+  IntStruct data = {6, 9, 3, 4};
+  printf("%d", data.b);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0013-Struct/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0013-Struct/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f11c82a4cb6cc2e8f3bdf52b5cdeaad4d5bb214e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0013-Struct/expected.txt
@@ -0,0 +1 @@
+9
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0013-Struct/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0013-Struct/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c874ac00139830db20780480c63972c8f8103d40
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0013-Struct/test.cfg
@@ -0,0 +1,2 @@
+compile(Struct)
+run(Struct)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0014-Band/Band.c b/testsuite/c_test/x64_be_enable_test/ENABLE0014-Band/Band.c
new file mode 100644
index 0000000000000000000000000000000000000000..5f4b1d42d75adc791b52e4d54748c3b19d8d3928
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0014-Band/Band.c
@@ -0,0 +1,7 @@
+int main() {
+  int a = 4;
+  int b = 12;
+  int c = a & b;
+  printf("%d", c);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0014-Band/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0014-Band/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bf0d87ab1b2b0ec1a11a3973d2845b42413d9767
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0014-Band/expected.txt
@@ -0,0 +1 @@
+4
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0014-Band/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0014-Band/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..30fafee7812cd1c77c9ea67234ec094d1bde40eb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0014-Band/test.cfg
@@ -0,0 +1,2 @@
+compile(Band)
+run(Band)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0015-Struct2/Struct2.c b/testsuite/c_test/x64_be_enable_test/ENABLE0015-Struct2/Struct2.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb20af91ae32073ed825de8a5308f8ba03157714
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0015-Struct2/Struct2.c
@@ -0,0 +1,12 @@
+typedef struct IntStruct_t {
+  int a;
+  int b;
+} IntStruct;
+
+int main() {
+  IntStruct data = {1, 2};
+  IntStruct* ptr = &data;
+  ptr->b = 4;
+  printf("%d,%d\n", ptr->a, ptr->b);
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0015-Struct2/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0015-Struct2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a2c82fff120236e8e186c0202f33f1b832342096
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0015-Struct2/expected.txt
@@ -0,0 +1 @@
+1,4
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0015-Struct2/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0015-Struct2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7848d2564995b0f75223b7c1d2c8c80187bcdd0b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0015-Struct2/test.cfg
@@ -0,0 +1,2 @@
+compile(Struct2)
+run(Struct2)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0016-Bnot/bnot_32.c b/testsuite/c_test/x64_be_enable_test/ENABLE0016-Bnot/bnot_32.c
new file mode 100644
index 0000000000000000000000000000000000000000..dec8865673fb235162769491d8a3c877a8de4ff2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0016-Bnot/bnot_32.c
@@ -0,0 +1,8 @@
+#include <stdio.h>
+
+int main() {
+        int a = 1;
+        int b = ~a;
+        printf("a = %x b = %x\n", a, b);
+        return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0016-Bnot/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0016-Bnot/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d1164ad66a4552f317ce34a7aa7cebc8f2279a18
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0016-Bnot/expected.txt
@@ -0,0 +1 @@
+a = 1 b = fffffffe
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0016-Bnot/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0016-Bnot/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..13ad41434d1d8be63f9ec2d0527c11986b6309b4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0016-Bnot/test.cfg
@@ -0,0 +1,2 @@
+compile(bnot_32)
+run(bnot_32)
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0017-Cvt/Cvt.c b/testsuite/c_test/x64_be_enable_test/ENABLE0017-Cvt/Cvt.c
new file mode 100644
index 0000000000000000000000000000000000000000..c2718d01433d9a6d6850dd4ab6c24989caafacb0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0017-Cvt/Cvt.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+int main()
+{
+  int i0 = 25;
+  unsigned int i1 = i0;
+  printf("int->uint: i1 = %d\n", i1);
+  int i3 = i1;
+  printf("uint->int: i3 = %d\n", i3);
+  unsigned long long l0 = i0;
+  printf("int->ulonglong: l0 = %lld\n", l0);
+  unsigned long long l1 = i1;
+  printf("uint->ulonglong: l1 = %lld\n", l1);
+  long long l2 = i0;
+  printf("int->longlong: l2 = %lld\n", l2);
+  long long l3 = i1;
+  printf("uint->longlong: l3 = %lld\n", l3);
+
+  int i4 = l1;
+  printf("ulonglong->int: i4 = %d\n", i4);
+  unsigned int i5 = l1;
+  printf("ulonglong->uint: i5 = %d\n", i5);
+  int i6 = l2;
+  printf("longlong->int: i6 = %d\n", i6);
+  unsigned int i7 = l2;
+  printf("longlong->uint: i7 = %d\n", i7);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0017-Cvt/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0017-Cvt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b6c17bc53fb41573270e69572acfa1db16d687a0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0017-Cvt/expected.txt
@@ -0,0 +1,10 @@
+int->uint: i1 = 25
+uint->int: i3 = 25
+int->ulonglong: l0 = 25
+uint->ulonglong: l1 = 25
+int->longlong: l2 = 25
+uint->longlong: l3 = 25
+ulonglong->int: i4 = 25
+ulonglong->uint: i5 = 25
+longlong->int: i6 = 25
+longlong->uint: i7 = 25
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0017-Cvt/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0017-Cvt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..62cbf0e2ad18f7845f8277c8b549fefabf5216d7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0017-Cvt/test.cfg
@@ -0,0 +1,2 @@
+compile(Cvt)
+run(Cvt)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0018-Array/Array.c b/testsuite/c_test/x64_be_enable_test/ENABLE0018-Array/Array.c
new file mode 100644
index 0000000000000000000000000000000000000000..5fd12454b25c4ad0f737b0facba6295e1de2b2ec
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0018-Array/Array.c
@@ -0,0 +1,5 @@
+int main() {
+  int a[2] = {1, 2};
+  printf("%d,%d", a[0], a[1]);
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0018-Array/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0018-Array/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0e88c499a701c205ecb5e5a9b2d6e8f89508813f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0018-Array/expected.txt
@@ -0,0 +1 @@
+1,2
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0018-Array/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0018-Array/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ef1fff5259b55a5d86c856b7c2d6e803d902bf4b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0018-Array/test.cfg
@@ -0,0 +1,2 @@
+compile(Array)
+run(Array)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0019-DivInt/DivInt.c b/testsuite/c_test/x64_be_enable_test/ENABLE0019-DivInt/DivInt.c
new file mode 100644
index 0000000000000000000000000000000000000000..93c885f523d8de8b84f48e5d00f4be105ea6ef8b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0019-DivInt/DivInt.c
@@ -0,0 +1,13 @@
+#include "stdio.h"
+
+int DivInt(int a, int b) {
+  return a/b;
+}
+
+int main() {
+  int a = 5;
+  int b = 3;
+  int c = DivInt(a, b);
+  printf("%d", c);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0019-DivInt/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0019-DivInt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..56a6051ca2b02b04ef92d5150c9ef600403cb1de
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0019-DivInt/expected.txt
@@ -0,0 +1 @@
+1
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0019-DivInt/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0019-DivInt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..df4f97a5dc6c01e53fbf4a9bac60fe8d79f08bba
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0019-DivInt/test.cfg
@@ -0,0 +1,2 @@
+compile(DivInt)
+run(DivInt)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0020-Param/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0020-Param/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b1efbe3ff750eb4d135589c819bb3fc2eb6371f4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0020-Param/expected.txt
@@ -0,0 +1,2 @@
+7
+55
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0020-Param/tenParm.c b/testsuite/c_test/x64_be_enable_test/ENABLE0020-Param/tenParm.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ebab2cd3db8a08663705ec71d8f98b3e31a3407
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0020-Param/tenParm.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+int Add(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j) {
+    int res = a + b + c + d + e + f + g + h + i + j;
+    int m = g;
+    printf("%d\n", m);
+    return res;
+}
+int main() {
+    int a = 1;
+    int b = 2;
+    int c = 3;
+    int d = 4;
+    int e = 5;
+    int f = 6;
+    int g = 7;
+    int h = 8;
+    int i = 9;
+    int j = 10;
+    int res = Add(a, b, c, d, e, f, g, h, i ,j);
+    printf("%d\n", res);
+    return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0020-Param/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0020-Param/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5f6d711e8143f6408cfbe9d154dc837800bb4b5b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0020-Param/test.cfg
@@ -0,0 +1,2 @@
+compile(tenParm)
+run(tenParm)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0021-Ashr/Ashr.c b/testsuite/c_test/x64_be_enable_test/ENABLE0021-Ashr/Ashr.c
new file mode 100644
index 0000000000000000000000000000000000000000..9d256fe87a76d5fa139ab4633a84b2290ced3926
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0021-Ashr/Ashr.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+int main() {
+    //test ashr
+    int c = -128;
+    int d = c >> 4;
+    printf("%x %x\n", c, d);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0021-Ashr/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0021-Ashr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..43d78e3ecfb6cde1800b7d751be5cd6f1fbb635c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0021-Ashr/expected.txt
@@ -0,0 +1 @@
+ffffff80 fffffff8
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0021-Ashr/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0021-Ashr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..38ad88321290009f0563596d5fba56ce3ed92c41
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0021-Ashr/test.cfg
@@ -0,0 +1,2 @@
+compile(Ashr)
+run(Ashr)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/Ashr2.c b/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/Ashr2.c
new file mode 100644
index 0000000000000000000000000000000000000000..c0909b5abca36bce0f1228c37181f4de8f72d41c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/Ashr2.c
@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+void testAshr64bit() {
+  long long a = 8589934592;
+  long long b = a >> 31;
+  printf("%lld %lld\n", a, b);
+}
+
+void testLshr32bit() {
+  int a = 123456;
+  int b = a >> 4;
+  printf("%d %d\n", a, b);
+}
+
+void testLshr16bit() {
+  short a = 12345;
+  short b = a >> 4;
+  printf("%d %d\n", a, b);
+}
+
+int main() {
+    testLshr64bit();
+    testLshr32bit();
+    testLshr16bit();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/Lshr.c b/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/Lshr.c
new file mode 100644
index 0000000000000000000000000000000000000000..f1fffba3389993b41458aeea4dac27b38bb30ad8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/Lshr.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+int main() {
+    //test lshr
+    unsigned int  a = 128;
+    unsigned int  b = a >> 4;
+    printf("%x %x\n", a, b);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e9ee05f6d20e204d5c57b5dd95648eca64a49bc2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/expected.txt
@@ -0,0 +1 @@
+80 8
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1d1cdc37b1e92336f97af62274669633fc1c9aff
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0022-Lshr/test.cfg
@@ -0,0 +1,2 @@
+compile(Lshr)
+run(Lshr)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0023-Cmp/Cmp.c b/testsuite/c_test/x64_be_enable_test/ENABLE0023-Cmp/Cmp.c
new file mode 100644
index 0000000000000000000000000000000000000000..799b30d0aa33b3ebd45a5936ac812073f12fd159
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0023-Cmp/Cmp.c
@@ -0,0 +1,31 @@
+int testSigned() {
+  int a = 3, b = 4;
+  int c = (a == b); // 0
+  int d = (a != b); // 1
+  int e = (a >= b); // 0
+  int f = (a > b);  // 0
+  int g = (a <= b); // 1
+  int h = (a < b);  // 1
+  printf("%d,%d,%d\n", c, d, e);
+  printf("%d,%d,%d\n", f, g, h);
+  return 0;
+}
+
+int testUnsigned() {
+  unsigned int a = 3, b = 4;
+  unsigned int c = (a == b); // 0
+  unsigned int d = (a != b); // 1
+  unsigned int e = (a >= b); // 0
+  unsigned int f = (a > b);  // 0
+  unsigned int g = (a <= b); // 1
+  unsigned int h = (a < b);  // 1
+  printf("%u,%u,%u\n", c, d, e);
+  printf("%u,%u,%u\n", f, g, h);
+  return 0;
+}
+
+int main() {
+  testSigned();
+  testUnsigned();
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0023-Cmp/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0023-Cmp/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4c52285eb05455b8ee1b0c4ba7eecd32d46f2073
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0023-Cmp/expected.txt
@@ -0,0 +1,4 @@
+0,1,0
+0,1,1
+0,1,0
+0,1,1
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0023-Cmp/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0023-Cmp/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..797734db2c08594b1bf2bc4b1c051a03f1b84dd4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0023-Cmp/test.cfg
@@ -0,0 +1,2 @@
+compile(Cmp)
+run(Cmp)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0024-Switch/Switch.c b/testsuite/c_test/x64_be_enable_test/ENABLE0024-Switch/Switch.c
new file mode 100644
index 0000000000000000000000000000000000000000..9cd3f68443150fb4083b83c8a5fc23d0c85baed0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0024-Switch/Switch.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+int main ()
+{
+  int sel = 9;
+  int res = 0;
+  switch (sel)
+  {
+    case -1:
+      res = 12;
+      break;
+    case 1:
+      res = 1;
+      break;
+    case 4:
+      res = 2;
+    case 2:
+      res = 3;
+      break;
+    case 3:
+      res = 4;
+      break;
+    case 5:
+      res = 5;
+    case 9:
+      res = 6;
+      break;
+    case 7:
+      res = 34;
+    default:
+      res = 99;
+  }
+  printf("res = %d\n",res);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0024-Switch/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0024-Switch/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e5110320e3f1e06f3b6999112d969deb7dfb4b27
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0024-Switch/expected.txt
@@ -0,0 +1 @@
+res = 6
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0024-Switch/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0024-Switch/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b3ae165f7240ac14cd2051d19eb9fbb17eaa6bf7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0024-Switch/test.cfg
@@ -0,0 +1,2 @@
+compile(Switch)
+run(Switch)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0025-Get-Static-Auto-Global-Val-And-Addr/Get-Static-Auto-Global-Val-And-Addr.c b/testsuite/c_test/x64_be_enable_test/ENABLE0025-Get-Static-Auto-Global-Val-And-Addr/Get-Static-Auto-Global-Val-And-Addr.c
new file mode 100644
index 0000000000000000000000000000000000000000..df04558a2d85eebac5c72df96c2d17ff30606f59
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0025-Get-Static-Auto-Global-Val-And-Addr/Get-Static-Auto-Global-Val-And-Addr.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+int g_a[5] = {0,1,2,3,4};
+int b = 12;
+
+int main() {
+  // auto
+  int a = 1;
+  int b = a + 1;
+  printf("b = %d\n", b);
+  int *c = &a;
+  printf("*c = %d\n", *c);
+  // static is unsupported well now.
+  // global
+  int *b2 = g_a;
+  printf("*ga[2] = %d\n", *(b2 + 2));
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0025-Get-Static-Auto-Global-Val-And-Addr/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0025-Get-Static-Auto-Global-Val-And-Addr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7a7ede173737dfbc0736178f7a44102b53175062
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0025-Get-Static-Auto-Global-Val-And-Addr/expected.txt
@@ -0,0 +1,3 @@
+b = 2
+*c = 1
+*ga[2] = 2
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0025-Get-Static-Auto-Global-Val-And-Addr/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0025-Get-Static-Auto-Global-Val-And-Addr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ada39e13ec240cf2e3e1e04796a85e9ba104dab0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0025-Get-Static-Auto-Global-Val-And-Addr/test.cfg
@@ -0,0 +1,2 @@
+compile(Get-Static-Auto-Global-Val-And-Addr)
+run(Get-Static-Auto-Global-Val-And-Addr)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0026-Add2/Add2.c b/testsuite/c_test/x64_be_enable_test/ENABLE0026-Add2/Add2.c
new file mode 100644
index 0000000000000000000000000000000000000000..dee56194a4edfc3a03ba7e4b6ef7ccadc9af5256
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0026-Add2/Add2.c
@@ -0,0 +1,39 @@
+void testChar() {
+  char a = 1, b = 2;
+  unsigned char c = 3, d = 4;
+  char m = a + b;
+  unsigned char n = c + d;
+  printf("%d,%u\n", m, n);
+}
+
+void testShort() {
+  short a = 1, b = 2;
+  unsigned short c = 3, d = 4;
+  short m = a + b;
+  unsigned short n = c + d;
+  printf("%d,%u\n", m, n);
+}
+
+void testInt() {
+  int a = 1, b = 2;
+  unsigned int c = 3, d = 4;
+  int m = a + b;
+  unsigned int n = c + d;
+  printf("%d,%u\n", m, n);
+}
+
+void testLong() {
+  long long a = 1, b = 2;
+  unsigned long long c = 3, d = 4;
+  long long m = a + b;
+  unsigned long long n = c + d;
+  printf("%lld,%llu\n", m, n);
+}
+
+int main() {
+  testChar();
+  testShort();
+  testInt();
+  testLong();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0026-Add2/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0026-Add2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9d4afa86ca59c6dac29fb8be829418458b3d3c1c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0026-Add2/expected.txt
@@ -0,0 +1,4 @@
+3,7
+3,7
+3,7
+3,7
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0026-Add2/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0026-Add2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84e19c02b8271b8eb4d9f09c55b8e106a252c3cd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0026-Add2/test.cfg
@@ -0,0 +1,2 @@
+compile(Add2)
+run(Add2)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0027-Add3/Add-Reg-64bitImm.c b/testsuite/c_test/x64_be_enable_test/ENABLE0027-Add3/Add-Reg-64bitImm.c
new file mode 100644
index 0000000000000000000000000000000000000000..785b8cda4372b8c1923e77be3de114143c829f48
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0027-Add3/Add-Reg-64bitImm.c
@@ -0,0 +1,12 @@
+typedef unsigned long long T;
+#define N (__SIZEOF_LONG_LONG__ * __CHAR_BIT__ / 2)
+
+//test add reg(opnd0) 64bit imm(opnd1)
+int
+main ()
+{
+  T a = ((T) 1) << (N + 1);
+  a += ((T) 1) << (N + 1);
+  printf("%lld\n", a);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0027-Add3/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0027-Add3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c612a244f33fb4c9433989c59ce5a0d51aa80e5e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0027-Add3/expected.txt
@@ -0,0 +1 @@
+17179869184
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0027-Add3/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0027-Add3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0f4a193ecafc4043c9a219415edea251de6278e4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0027-Add3/test.cfg
@@ -0,0 +1,2 @@
+compile(Add-Reg-64bitImm)
+run(Add-Reg-64bitImm)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0028-Bior2/Bior2.c b/testsuite/c_test/x64_be_enable_test/ENABLE0028-Bior2/Bior2.c
new file mode 100644
index 0000000000000000000000000000000000000000..9841e58f7f6597aa9118972c6ee17f090b070e4c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0028-Bior2/Bior2.c
@@ -0,0 +1,39 @@
+void testChar() {
+  char a = 1, b = 2;
+  unsigned char c = 3, d = 4;
+  char m = a | b;
+  unsigned char n = c | d;
+  printf("%d,%u\n", m, n);
+}
+
+void testShort() {
+  short a = 1, b = 2;
+  unsigned short c = 3, d = 4;
+  short m = a | b;
+  unsigned short n = c | d;
+  printf("%d,%u\n", m, n);
+}
+
+void testInt() {
+  int a = 1, b = 2;
+  unsigned int c = 3, d = 4;
+  int m = a | b;
+  unsigned int n = c | d;
+  printf("%d,%u\n", m, n);
+}
+
+void testLong() {
+  long long a = 1, b = 2;
+  unsigned long long c = 3, d = 4;
+  long long m = a | b;
+  unsigned long long n = c | d;
+  printf("%lld,%llu\n", m, n);
+}
+
+int main() {
+  testChar();
+  testShort();
+  testInt();
+  testLong();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0028-Bior2/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0028-Bior2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9d4afa86ca59c6dac29fb8be829418458b3d3c1c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0028-Bior2/expected.txt
@@ -0,0 +1,4 @@
+3,7
+3,7
+3,7
+3,7
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0028-Bior2/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0028-Bior2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc045910ce6490c03b512220c90f32a441e55fbd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0028-Bior2/test.cfg
@@ -0,0 +1,2 @@
+compile(Bior2)
+run(Bior2)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0029-Ashr2/Ashr2.c b/testsuite/c_test/x64_be_enable_test/ENABLE0029-Ashr2/Ashr2.c
new file mode 100644
index 0000000000000000000000000000000000000000..42bb9ba2ae4389daee58a58e0e36942c1c5db458
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0029-Ashr2/Ashr2.c
@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+void testAshr64bit() {
+  long long a = 8589934592;
+  long long b = a >> 31;
+  printf("%lld %lld\n", a, b);
+}
+
+void testAshr32bit() {
+  int a = 123456;
+  int b = a >> 4;
+  printf("%d %d\n", a, b);
+}
+
+void testAshr16bit() {
+  short a = 12345;
+  short b = a >> 4;
+  printf("%d %d\n", a, b);
+}
+
+int main() {
+    testAshr64bit();
+    testAshr32bit();
+    testAshr16bit();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0029-Ashr2/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0029-Ashr2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..781a1c008818b3afa8f310f2a6985a5e7d8fbabe
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0029-Ashr2/expected.txt
@@ -0,0 +1,3 @@
+8589934592 4
+123456 7716
+12345 771
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0029-Ashr2/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0029-Ashr2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fdb48e9cfe9f08f5963859b786a78ed96677f295
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0029-Ashr2/test.cfg
@@ -0,0 +1,2 @@
+compile(Ashr2)
+run(Ashr2)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0030-DepositBits/DepositBits.c b/testsuite/c_test/x64_be_enable_test/ENABLE0030-DepositBits/DepositBits.c
new file mode 100644
index 0000000000000000000000000000000000000000..03f7f0885053bb0f139e41b44ac3a43ec8d97883
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0030-DepositBits/DepositBits.c
@@ -0,0 +1,12 @@
+struct __attribute__((packed)) S {
+  int s : 12;
+  int t : 16;
+};
+
+int main() {
+  struct S i = {-0x111, 0x2222}, j = {0x00, 0x00};
+  j.s = 0x333;
+  j.t = 0x4444;
+  printf("%x,%x,%x,%x\n", i.s, i.t, j.s, j.t);
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0030-DepositBits/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0030-DepositBits/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0dffb8112481d85c6d19c0dcfa590ac133a4d435
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0030-DepositBits/expected.txt
@@ -0,0 +1 @@
+fffffeef,2222,333,4444
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0030-DepositBits/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0030-DepositBits/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d67288aa2118a916c4fceef78fb580a68d25b7ca
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0030-DepositBits/test.cfg
@@ -0,0 +1,2 @@
+compile(DepositBits)
+run(DepositBits)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0031-Abs/Abs.c b/testsuite/c_test/x64_be_enable_test/ENABLE0031-Abs/Abs.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d580a7f731d1da82ca7781efb3372e12508c510
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0031-Abs/Abs.c
@@ -0,0 +1,6 @@
+int main() {
+  int a = -1;
+  int b = abs(a);
+  printf("%d\n", b);
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0031-Abs/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0031-Abs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0031-Abs/expected.txt
@@ -0,0 +1 @@
+1
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0031-Abs/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0031-Abs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7d9fbd71d0a5fd6e9fd34249dd4f995423d30007
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0031-Abs/test.cfg
@@ -0,0 +1,2 @@
+compile(Abs)
+run(Abs)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0032-Vararg/Vararg.c b/testsuite/c_test/x64_be_enable_test/ENABLE0032-Vararg/Vararg.c
new file mode 100644
index 0000000000000000000000000000000000000000..032d798a83631b6881dbd64856cb07cd6b07ccd3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0032-Vararg/Vararg.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <stdarg.h>
+
+int average(int num,...) {
+  va_list valist;
+  int sum = 0;
+  int i;
+
+  va_start(valist, num);
+
+  for (i = 0; i < num; i++)
+  {
+     sum += va_arg(valist, int);
+  }
+  va_end(valist);
+  return sum/num;
+}
+int main() {
+   printf("%d\n", average(3, 5,10,15));
+   return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0032-Vararg/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0032-Vararg/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f599e28b8ab0d8c9c57a486c89c4a5132dcbd3b2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0032-Vararg/expected.txt
@@ -0,0 +1 @@
+10
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0032-Vararg/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0032-Vararg/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8386fd8c931b04d256eb74dac1a005b4ace9dcb4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0032-Vararg/test.cfg
@@ -0,0 +1,2 @@
+compile(Vararg)
+run(Vararg)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0033-EightQueen/EightQueen.c b/testsuite/c_test/x64_be_enable_test/ENABLE0033-EightQueen/EightQueen.c
new file mode 100644
index 0000000000000000000000000000000000000000..24219405eb732203e6bf55380e8ed4572de853c1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0033-EightQueen/EightQueen.c
@@ -0,0 +1,43 @@
+#define QUEEN_NUM (8)
+
+int queen[QUEEN_NUM] = {0};
+int num = 0;
+
+int abs(int n) {
+  return n > 0 ? n : -n;
+}
+
+void show() {
+  printf("%d:", ++num);
+  for (int i = 0; i < QUEEN_NUM; ++i) {
+    printf("(%d,%d) ", i, queen[i]);
+  }
+  printf("\n");
+}
+
+int check(int n) {
+  for (int i = 0; i < n; ++i) {
+    if (queen[i] == queen[n] || abs(queen[n] - queen[i]) == abs(n - i)) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+void eight_queen(int n) {
+  for (int i = 0; i < QUEEN_NUM; ++i) {
+    queen[n] = i;
+    if (check(n) == 0) {
+      if (n == QUEEN_NUM - 1) {
+        show();
+      } else {
+        eight_queen(n + 1);
+      }
+    }
+  }
+}
+
+int main() {
+  eight_queen(0);
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0033-EightQueen/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0033-EightQueen/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..02a153f580ad3956d82c09cc2a63444a50cc078c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0033-EightQueen/expected.txt
@@ -0,0 +1,92 @@
+1:(0,0) (1,4) (2,7) (3,5) (4,2) (5,6) (6,1) (7,3) 
+2:(0,0) (1,5) (2,7) (3,2) (4,6) (5,3) (6,1) (7,4) 
+3:(0,0) (1,6) (2,3) (3,5) (4,7) (5,1) (6,4) (7,2) 
+4:(0,0) (1,6) (2,4) (3,7) (4,1) (5,3) (6,5) (7,2) 
+5:(0,1) (1,3) (2,5) (3,7) (4,2) (5,0) (6,6) (7,4) 
+6:(0,1) (1,4) (2,6) (3,0) (4,2) (5,7) (6,5) (7,3) 
+7:(0,1) (1,4) (2,6) (3,3) (4,0) (5,7) (6,5) (7,2) 
+8:(0,1) (1,5) (2,0) (3,6) (4,3) (5,7) (6,2) (7,4) 
+9:(0,1) (1,5) (2,7) (3,2) (4,0) (5,3) (6,6) (7,4) 
+10:(0,1) (1,6) (2,2) (3,5) (4,7) (5,4) (6,0) (7,3) 
+11:(0,1) (1,6) (2,4) (3,7) (4,0) (5,3) (6,5) (7,2) 
+12:(0,1) (1,7) (2,5) (3,0) (4,2) (5,4) (6,6) (7,3) 
+13:(0,2) (1,0) (2,6) (3,4) (4,7) (5,1) (6,3) (7,5) 
+14:(0,2) (1,4) (2,1) (3,7) (4,0) (5,6) (6,3) (7,5) 
+15:(0,2) (1,4) (2,1) (3,7) (4,5) (5,3) (6,6) (7,0) 
+16:(0,2) (1,4) (2,6) (3,0) (4,3) (5,1) (6,7) (7,5) 
+17:(0,2) (1,4) (2,7) (3,3) (4,0) (5,6) (6,1) (7,5) 
+18:(0,2) (1,5) (2,1) (3,4) (4,7) (5,0) (6,6) (7,3) 
+19:(0,2) (1,5) (2,1) (3,6) (4,0) (5,3) (6,7) (7,4) 
+20:(0,2) (1,5) (2,1) (3,6) (4,4) (5,0) (6,7) (7,3) 
+21:(0,2) (1,5) (2,3) (3,0) (4,7) (5,4) (6,6) (7,1) 
+22:(0,2) (1,5) (2,3) (3,1) (4,7) (5,4) (6,6) (7,0) 
+23:(0,2) (1,5) (2,7) (3,0) (4,3) (5,6) (6,4) (7,1) 
+24:(0,2) (1,5) (2,7) (3,0) (4,4) (5,6) (6,1) (7,3) 
+25:(0,2) (1,5) (2,7) (3,1) (4,3) (5,0) (6,6) (7,4) 
+26:(0,2) (1,6) (2,1) (3,7) (4,4) (5,0) (6,3) (7,5) 
+27:(0,2) (1,6) (2,1) (3,7) (4,5) (5,3) (6,0) (7,4) 
+28:(0,2) (1,7) (2,3) (3,6) (4,0) (5,5) (6,1) (7,4) 
+29:(0,3) (1,0) (2,4) (3,7) (4,1) (5,6) (6,2) (7,5) 
+30:(0,3) (1,0) (2,4) (3,7) (4,5) (5,2) (6,6) (7,1) 
+31:(0,3) (1,1) (2,4) (3,7) (4,5) (5,0) (6,2) (7,6) 
+32:(0,3) (1,1) (2,6) (3,2) (4,5) (5,7) (6,0) (7,4) 
+33:(0,3) (1,1) (2,6) (3,2) (4,5) (5,7) (6,4) (7,0) 
+34:(0,3) (1,1) (2,6) (3,4) (4,0) (5,7) (6,5) (7,2) 
+35:(0,3) (1,1) (2,7) (3,4) (4,6) (5,0) (6,2) (7,5) 
+36:(0,3) (1,1) (2,7) (3,5) (4,0) (5,2) (6,4) (7,6) 
+37:(0,3) (1,5) (2,0) (3,4) (4,1) (5,7) (6,2) (7,6) 
+38:(0,3) (1,5) (2,7) (3,1) (4,6) (5,0) (6,2) (7,4) 
+39:(0,3) (1,5) (2,7) (3,2) (4,0) (5,6) (6,4) (7,1) 
+40:(0,3) (1,6) (2,0) (3,7) (4,4) (5,1) (6,5) (7,2) 
+41:(0,3) (1,6) (2,2) (3,7) (4,1) (5,4) (6,0) (7,5) 
+42:(0,3) (1,6) (2,4) (3,1) (4,5) (5,0) (6,2) (7,7) 
+43:(0,3) (1,6) (2,4) (3,2) (4,0) (5,5) (6,7) (7,1) 
+44:(0,3) (1,7) (2,0) (3,2) (4,5) (5,1) (6,6) (7,4) 
+45:(0,3) (1,7) (2,0) (3,4) (4,6) (5,1) (6,5) (7,2) 
+46:(0,3) (1,7) (2,4) (3,2) (4,0) (5,6) (6,1) (7,5) 
+47:(0,4) (1,0) (2,3) (3,5) (4,7) (5,1) (6,6) (7,2) 
+48:(0,4) (1,0) (2,7) (3,3) (4,1) (5,6) (6,2) (7,5) 
+49:(0,4) (1,0) (2,7) (3,5) (4,2) (5,6) (6,1) (7,3) 
+50:(0,4) (1,1) (2,3) (3,5) (4,7) (5,2) (6,0) (7,6) 
+51:(0,4) (1,1) (2,3) (3,6) (4,2) (5,7) (6,5) (7,0) 
+52:(0,4) (1,1) (2,5) (3,0) (4,6) (5,3) (6,7) (7,2) 
+53:(0,4) (1,1) (2,7) (3,0) (4,3) (5,6) (6,2) (7,5) 
+54:(0,4) (1,2) (2,0) (3,5) (4,7) (5,1) (6,3) (7,6) 
+55:(0,4) (1,2) (2,0) (3,6) (4,1) (5,7) (6,5) (7,3) 
+56:(0,4) (1,2) (2,7) (3,3) (4,6) (5,0) (6,5) (7,1) 
+57:(0,4) (1,6) (2,0) (3,2) (4,7) (5,5) (6,3) (7,1) 
+58:(0,4) (1,6) (2,0) (3,3) (4,1) (5,7) (6,5) (7,2) 
+59:(0,4) (1,6) (2,1) (3,3) (4,7) (5,0) (6,2) (7,5) 
+60:(0,4) (1,6) (2,1) (3,5) (4,2) (5,0) (6,3) (7,7) 
+61:(0,4) (1,6) (2,1) (3,5) (4,2) (5,0) (6,7) (7,3) 
+62:(0,4) (1,6) (2,3) (3,0) (4,2) (5,7) (6,5) (7,1) 
+63:(0,4) (1,7) (2,3) (3,0) (4,2) (5,5) (6,1) (7,6) 
+64:(0,4) (1,7) (2,3) (3,0) (4,6) (5,1) (6,5) (7,2) 
+65:(0,5) (1,0) (2,4) (3,1) (4,7) (5,2) (6,6) (7,3) 
+66:(0,5) (1,1) (2,6) (3,0) (4,2) (5,4) (6,7) (7,3) 
+67:(0,5) (1,1) (2,6) (3,0) (4,3) (5,7) (6,4) (7,2) 
+68:(0,5) (1,2) (2,0) (3,6) (4,4) (5,7) (6,1) (7,3) 
+69:(0,5) (1,2) (2,0) (3,7) (4,3) (5,1) (6,6) (7,4) 
+70:(0,5) (1,2) (2,0) (3,7) (4,4) (5,1) (6,3) (7,6) 
+71:(0,5) (1,2) (2,4) (3,6) (4,0) (5,3) (6,1) (7,7) 
+72:(0,5) (1,2) (2,4) (3,7) (4,0) (5,3) (6,1) (7,6) 
+73:(0,5) (1,2) (2,6) (3,1) (4,3) (5,7) (6,0) (7,4) 
+74:(0,5) (1,2) (2,6) (3,1) (4,7) (5,4) (6,0) (7,3) 
+75:(0,5) (1,2) (2,6) (3,3) (4,0) (5,7) (6,1) (7,4) 
+76:(0,5) (1,3) (2,0) (3,4) (4,7) (5,1) (6,6) (7,2) 
+77:(0,5) (1,3) (2,1) (3,7) (4,4) (5,6) (6,0) (7,2) 
+78:(0,5) (1,3) (2,6) (3,0) (4,2) (5,4) (6,1) (7,7) 
+79:(0,5) (1,3) (2,6) (3,0) (4,7) (5,1) (6,4) (7,2) 
+80:(0,5) (1,7) (2,1) (3,3) (4,0) (5,6) (6,4) (7,2) 
+81:(0,6) (1,0) (2,2) (3,7) (4,5) (5,3) (6,1) (7,4) 
+82:(0,6) (1,1) (2,3) (3,0) (4,7) (5,4) (6,2) (7,5) 
+83:(0,6) (1,1) (2,5) (3,2) (4,0) (5,3) (6,7) (7,4) 
+84:(0,6) (1,2) (2,0) (3,5) (4,7) (5,4) (6,1) (7,3) 
+85:(0,6) (1,2) (2,7) (3,1) (4,4) (5,0) (6,5) (7,3) 
+86:(0,6) (1,3) (2,1) (3,4) (4,7) (5,0) (6,2) (7,5) 
+87:(0,6) (1,3) (2,1) (3,7) (4,5) (5,0) (6,2) (7,4) 
+88:(0,6) (1,4) (2,2) (3,0) (4,5) (5,7) (6,1) (7,3) 
+89:(0,7) (1,1) (2,3) (3,0) (4,6) (5,4) (6,2) (7,5) 
+90:(0,7) (1,1) (2,4) (3,2) (4,0) (5,6) (6,3) (7,5) 
+91:(0,7) (1,2) (2,0) (3,5) (4,1) (5,4) (6,6) (7,3) 
+92:(0,7) (1,3) (2,0) (3,2) (4,5) (5,1) (6,6) (7,4) 
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0033-EightQueen/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0033-EightQueen/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8566fa01512fadd61eb614af07f3cc0d2dc2743a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0033-EightQueen/test.cfg
@@ -0,0 +1,2 @@
+compile(EightQueen)
+run(EightQueen)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0034-Rem/Rem.c b/testsuite/c_test/x64_be_enable_test/ENABLE0034-Rem/Rem.c
new file mode 100644
index 0000000000000000000000000000000000000000..07c4c3b27f32fc42269f16952d2550d39edfe840
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0034-Rem/Rem.c
@@ -0,0 +1,6 @@
+int main() {
+  int a = 4, b = 3;
+  int c = a % 3;
+  printf("%d\n", c);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0034-Rem/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0034-Rem/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0034-Rem/expected.txt
@@ -0,0 +1 @@
+1
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0034-Rem/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0034-Rem/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cfec507fd7b9e21f1738239b9444c17cd5bc3b63
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0034-Rem/test.cfg
@@ -0,0 +1,2 @@
+compile(Rem)
+run(Rem)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0035-ReturnParm/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0035-ReturnParm/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ef8ea4d77a62d91f3c73009c26f55a07b56196d9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0035-ReturnParm/expected.txt
@@ -0,0 +1,3 @@
+15
+3
+11
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0035-ReturnParm/returnStruct.c b/testsuite/c_test/x64_be_enable_test/ENABLE0035-ReturnParm/returnStruct.c
new file mode 100644
index 0000000000000000000000000000000000000000..3078bffd285f30ad44322c72b041fd971c597dd3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0035-ReturnParm/returnStruct.c
@@ -0,0 +1,44 @@
+ #include <stdio.h>
+ struct sc {
+     int a;
+     int b;
+     int c;
+ };
+
+ struct sc teSmall(int a, int b, int c, int d, int e, int f, int g, struct sc ml){
+     int m1 = ml.c;
+     ml.a = f;
+     ml.b = b;
+     ml.c = 3;
+     printf("%d\n", ml.c);
+     return ml;
+ }
+
+ struct sd {
+     int a;
+     int b;
+     int c;
+     int d;
+     int e;
+ };
+ struct sd teLarge(int a, int b){
+     struct sd ml;
+     ml.a = a;
+     ml.b = b;
+     ml.c = 3;
+     ml.d = 4;
+     ml.e = 5;
+     return ml;
+ }
+
+ int main() {
+     struct sd larg  = teLarge(1, 2);
+     printf("%d\n", larg.a + larg.b + larg.c + larg.d + larg.e);
+     struct sc teSmal;
+     teSmal.a = 7;
+     teSmal.b = 8;
+     teSmal.c = 9;
+     struct sc smal = teSmall(1, 2, 3, 4, 5, 6, 7, teSmal);
+     printf("%d\n", smal.a + smal.b + smal.c);
+     return 0;
+  }
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0035-ReturnParm/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0035-ReturnParm/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..27cb5ec54ea1d781a1b9d746edd46d4300020735
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0035-ReturnParm/test.cfg
@@ -0,0 +1,2 @@
+compile(returnStruct)
+run(returnStruct)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0036-Sub2/Sub2.c b/testsuite/c_test/x64_be_enable_test/ENABLE0036-Sub2/Sub2.c
new file mode 100644
index 0000000000000000000000000000000000000000..57eefeac85c00e2907617e4c36478423f5a74d48
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0036-Sub2/Sub2.c
@@ -0,0 +1,39 @@
+void testChar() {
+  char a = 9, b = 6;
+  unsigned char c = 5, d = 3;
+  char m = a - b;
+  unsigned char n = c - d;
+  printf("%d,%u\n", m, n);
+}
+
+void testShort() {
+  short a = 9, b = 6;
+  unsigned short c = 5, d = 3;
+  short m = a - b;
+  unsigned short n = c - d;
+  printf("%d,%u\n", m, n);
+}
+
+void testInt() {
+  int a = 9, b = 6;
+  unsigned int c = 5, d = 3;
+  int m = a - b;
+  unsigned int n = c - d;
+  printf("%d,%u\n", m, n);
+}
+
+void testLong() {
+  long long a = 9, b = 6;
+  unsigned long long c = 5, d = 3;
+  long long m = a - b;
+  unsigned long long n = c - d;
+  printf("%lld,%llu\n", m, n);
+}
+
+int main() {
+  testChar();
+  testShort();
+  testInt();
+  testLong();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0036-Sub2/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0036-Sub2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..154d03515765dbf94077102725a85fc0446747e0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0036-Sub2/expected.txt
@@ -0,0 +1,4 @@
+3,2
+3,2
+3,2
+3,2
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0036-Sub2/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0036-Sub2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65e4882e07c89b747ab65452da96eacbc708a499
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0036-Sub2/test.cfg
@@ -0,0 +1,2 @@
+compile(Sub2)
+run(Sub2)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0037-Lshr2/Lshr2.c b/testsuite/c_test/x64_be_enable_test/ENABLE0037-Lshr2/Lshr2.c
new file mode 100644
index 0000000000000000000000000000000000000000..53252d4ae4869dd60b0e74150ce09db604b29fdd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0037-Lshr2/Lshr2.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+//test 64bit Lshr
+void testLshr64bit() {
+  //test lshr(64bit)
+  unsigned long long a = 8589934592;
+  unsigned long long b = a >> 31;
+  printf("%llu %llu\n", a, b);
+}
+
+void testLshr32bit() {
+  unsigned int a = 123456;
+  unsigned int b = a >> 4;
+  printf("%u %u\n", a, b);
+}
+
+void testLshr16bit() {
+  unsigned short a = 12345;
+  unsigned short b = a >> 4;
+  printf("%u %u\n", a, b);
+}
+
+int main() {
+    testLshr64bit();
+    testLshr32bit();
+    testLshr16bit();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0037-Lshr2/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0037-Lshr2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..781a1c008818b3afa8f310f2a6985a5e7d8fbabe
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0037-Lshr2/expected.txt
@@ -0,0 +1,3 @@
+8589934592 4
+123456 7716
+12345 771
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0037-Lshr2/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0037-Lshr2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f1733d32366b6efe2b1a92d25e7f541098baaad8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0037-Lshr2/test.cfg
@@ -0,0 +1,2 @@
+compile(Lshr2)
+run(Lshr2)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0038-Band2/Band2.c b/testsuite/c_test/x64_be_enable_test/ENABLE0038-Band2/Band2.c
new file mode 100644
index 0000000000000000000000000000000000000000..7ac33d30f2119ebdae47c6b598802065f294aa2f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0038-Band2/Band2.c
@@ -0,0 +1,39 @@
+void testChar() {
+  char a = 4, b = 12;
+  unsigned char c = 4, d = 12;
+  char m = a & b;
+  unsigned char n = c & d;
+  printf("%d,%u\n", m, n);
+}
+
+void testShort() {
+  short a = 4, b = 12;
+  unsigned short c = 4, d = 12;
+  short m = a & b;
+  unsigned short n = c & d;
+  printf("%d,%u\n", m, n);
+}
+
+void testInt() {
+  int a = 4, b = 12;
+  unsigned int c = 4, d = 12;
+  int m = a & b;
+  unsigned int n = c & d;
+  printf("%d,%u\n", m, n);
+}
+
+void testLong() {
+  long long a = 4, b = 12;
+  unsigned long long c = 4, d = 12;
+  long long m = a & b;
+  unsigned long long n = c & d;
+  printf("%lld,%llu\n", m, n);
+}
+
+int main() {
+  testChar();
+  testShort();
+  testInt();
+  testLong();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0038-Band2/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0038-Band2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f2ba5e039297b8968302e3f56919eda2dce09092
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0038-Band2/expected.txt
@@ -0,0 +1,4 @@
+4,4
+4,4
+4,4
+4,4
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0038-Band2/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0038-Band2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..860ed504a6d1b09e35ff803f2db1eba1d543c78c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0038-Band2/test.cfg
@@ -0,0 +1,2 @@
+compile(Band2)
+run(Band2)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0039-Return2/Return2.c b/testsuite/c_test/x64_be_enable_test/ENABLE0039-Return2/Return2.c
new file mode 100644
index 0000000000000000000000000000000000000000..a35006a45680ec9171099fd3d5aa0f43027f5901
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0039-Return2/Return2.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+int feq (){
+  int a = 1, b = 2;
+  if (a == b)
+    return 10;
+  else
+    return 20;
+}
+
+int main() {
+  printf("res = %d\n", feq());
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0039-Return2/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0039-Return2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..819ecaafe278bac45169879d2ac3ccf0ca0317d5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0039-Return2/expected.txt
@@ -0,0 +1 @@
+res = 20
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0039-Return2/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0039-Return2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..adbf2a1027a621d8f83e1d72d709e3d49b4820b7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0039-Return2/test.cfg
@@ -0,0 +1,2 @@
+compile(Return2)
+run(Return2)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0040-Nonret/Nonret.c b/testsuite/c_test/x64_be_enable_test/ENABLE0040-Nonret/Nonret.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb107f3479d1f9cc1c5ff2a221e412e0fe0b3f0e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0040-Nonret/Nonret.c
@@ -0,0 +1,8 @@
+void func(int a) {
+  printf("%d\n", a);
+}
+
+int main() {
+  func(1);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0040-Nonret/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0040-Nonret/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0040-Nonret/expected.txt
@@ -0,0 +1 @@
+1
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0040-Nonret/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0040-Nonret/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..93bccd5f3bb8b128e81606d2286eb61819558fa2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0040-Nonret/test.cfg
@@ -0,0 +1,2 @@
+compile(Nonret)
+run(Nonret)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0041-FibonacciSequence/FibonacciSequence.c b/testsuite/c_test/x64_be_enable_test/ENABLE0041-FibonacciSequence/FibonacciSequence.c
new file mode 100644
index 0000000000000000000000000000000000000000..44e5894802b50dc674d1f00824e12c05c0c93755
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0041-FibonacciSequence/FibonacciSequence.c
@@ -0,0 +1,11 @@
+long long fibonacci(long long num) {
+  if (num < 2) {
+    return num;
+  }
+  return fibonacci(num - 1) + fibonacci(num - 2);
+}
+
+int main() {
+  printf("%lld\n", fibonacci(10));
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0041-FibonacciSequence/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0041-FibonacciSequence/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c3f407c0955bb5738e40a82664c79b63f04a9adb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0041-FibonacciSequence/expected.txt
@@ -0,0 +1 @@
+55
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0041-FibonacciSequence/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0041-FibonacciSequence/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ab8cb2aae402564e75a3296351f91e8c5ea1a7c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0041-FibonacciSequence/test.cfg
@@ -0,0 +1,2 @@
+compile(FibonacciSequence)
+run(FibonacciSequence)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0042-Igoto/Igoto.c b/testsuite/c_test/x64_be_enable_test/ENABLE0042-Igoto/Igoto.c
new file mode 100644
index 0000000000000000000000000000000000000000..331d758b7fa74b2ccab847c7dc021503b2b415c3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0042-Igoto/Igoto.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+void bar(int pc) {
+  static const void *l[] = {&&lab0,&&lab1};
+  goto *l[pc];
+ lab0:
+   printf("1\n");
+   return;
+ lab1:
+   printf("2\n");
+  return;
+}
+
+int main() {
+  bar(0);
+  bar(1);
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0042-Igoto/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0042-Igoto/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1191247b6d9a206f6ba3d8ac79e26d041dd86941
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0042-Igoto/expected.txt
@@ -0,0 +1,2 @@
+1
+2
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0042-Igoto/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0042-Igoto/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dddc4fc9a3b76feae73ec765d6be3f7872f4efa6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0042-Igoto/test.cfg
@@ -0,0 +1,2 @@
+compile(Igoto)
+run(Igoto)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0043-StructParm/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0043-StructParm/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a1b7109db1b881ee63218dc91045bf41123c01ef
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0043-StructParm/expected.txt
@@ -0,0 +1,4 @@
+4
+11
+3
+27
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0043-StructParm/struct.c b/testsuite/c_test/x64_be_enable_test/ENABLE0043-StructParm/struct.c
new file mode 100644
index 0000000000000000000000000000000000000000..ecf802c3bd5540c4c2d675e6b48fe0fbfceea27c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0043-StructParm/struct.c
@@ -0,0 +1,47 @@
+ #include <stdio.h>
+ struct sd {
+     int a;
+     int b;
+     int c;
+ };
+ int te1(int a, int b, int c, int d, struct sd ml){
+     int m1 = ml.a + ml.b + ml.c;
+     ml.b = b;
+     ml.c = 3;
+     printf("%d\n", ml.c);
+     return m1;
+ }
+
+ struct sc {
+     int a;
+     int b;
+     int c;
+     int d;
+     int e;
+ };
+ int te(struct sc ml, int a, int b, int c, int d, int e, int f, int g, int h, int i){
+     int m = ml.e;
+     ml.b = b;
+     ml.c = 3;
+     ml.d = 4;
+     ml.e = 5;
+     printf("%d\n", ml.d);
+     return m;
+ }
+ int main() {
+     struct sd mn;
+     mn.a = 10;
+     mn.b = 9;
+     mn.c = 8;
+     struct sc mm;
+     mm.a = 7;
+     mm.b = 8;
+     mm.c = 9;
+     mm.d = 10;
+     mm.e = 11;
+     int m  = te(mm, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+     printf("%d\n", m);
+     int n = te1(1, 2, 3, 4, mn);
+     printf("%d\n", n);
+     return 0;
+ }
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0043-StructParm/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0043-StructParm/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..614d1a9394f1cf6e885354fcdadad10a15a1462f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0043-StructParm/test.cfg
@@ -0,0 +1,2 @@
+compile(struct)
+run(struct)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0044-Signed2Unsigned/Signed2Unsigned.c b/testsuite/c_test/x64_be_enable_test/ENABLE0044-Signed2Unsigned/Signed2Unsigned.c
new file mode 100644
index 0000000000000000000000000000000000000000..76ac1b0ad555eab6e308f72c2f3bd3ecfd8f54a2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0044-Signed2Unsigned/Signed2Unsigned.c
@@ -0,0 +1,6 @@
+int main() {
+  int a = -2;
+  unsigned long b = a;
+  printf("%lu\n", b);
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0044-Signed2Unsigned/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0044-Signed2Unsigned/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..28cceb8b8035485e6da6c6a507438e955f46220b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0044-Signed2Unsigned/expected.txt
@@ -0,0 +1 @@
+18446744073709551614
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0044-Signed2Unsigned/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0044-Signed2Unsigned/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..758e0ea87e8ec80cb0ec82a8db28aacbad938c7a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0044-Signed2Unsigned/test.cfg
@@ -0,0 +1,2 @@
+compile(Signed2Unsigned)
+run(Signed2Unsigned)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0045-UsePhyRegInCall/UsePhyRegInCall.c b/testsuite/c_test/x64_be_enable_test/ENABLE0045-UsePhyRegInCall/UsePhyRegInCall.c
new file mode 100644
index 0000000000000000000000000000000000000000..db8f4fd7e4029bb3a0b96bb28cb5d0daf940e00d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0045-UsePhyRegInCall/UsePhyRegInCall.c
@@ -0,0 +1,21 @@
+void testShift() {
+  int a = 1, b = 2, c = 3, d = 4, e = 5;
+  printf("%x,%x,%x,%x\n", a << b, a << c, a << d, a << e);
+}
+
+void testDiv() {
+  int a = 100, b = 2, c = 3, d = 4, e = 5;
+  printf("%d,%d,%d,%d\n", a / b, a / c, a / d, a / e);
+}
+
+void testRem() {
+  int a = 101, b = 2, c = 3, d = 4, e = 5;
+  printf("%d,%d,%d,%d\n", a % b, a % c, a % d, a % e);
+}
+
+int main() {
+  testShift();
+  testDiv();
+  testRem();
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0045-UsePhyRegInCall/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0045-UsePhyRegInCall/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a9a2486e6d3711867238f5ffaa5bafb51266423d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0045-UsePhyRegInCall/expected.txt
@@ -0,0 +1,3 @@
+4,8,10,20
+50,33,25,20
+1,2,1,1
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0045-UsePhyRegInCall/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0045-UsePhyRegInCall/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d88372da783b8bac4bd900c00b11c80416e9f790
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0045-UsePhyRegInCall/test.cfg
@@ -0,0 +1,2 @@
+compile(UsePhyRegInCall)
+run(UsePhyRegInCall)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0046-LeafFuncAlloca/LeafFuncAlloca.c b/testsuite/c_test/x64_be_enable_test/ENABLE0046-LeafFuncAlloca/LeafFuncAlloca.c
new file mode 100644
index 0000000000000000000000000000000000000000..964a9f10c598289e92abc2620a2e5af8127cbd65
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0046-LeafFuncAlloca/LeafFuncAlloca.c
@@ -0,0 +1,19 @@
+_Bool foo() {
+  int x0 = 0, x1 = 1, x2 = 2, x3 = 3, x4 = 4;
+  int *p = __builtin_alloca(5 * sizeof(int));
+  p[0] = 0;
+  p[1] = 1;
+  p[2] = 2;
+  p[3] = 3;
+  p[4] = 4;
+
+  return (x0 == 0 && x1 == 1 && x2 == 2 && x3 == 3 && x4 == 4 && p[0] == 0 &&
+          p[1] == 1 && p[2] == 2 && p[3] == 3 && p[4] == 4);
+}
+
+int main() {
+  if (!foo()) {
+    abort();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0046-LeafFuncAlloca/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0046-LeafFuncAlloca/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0046-LeafFuncAlloca/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0046-LeafFuncAlloca/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1d2505ce272752a0b3be3c4c2a8eeeb77e0c2aca
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0046-LeafFuncAlloca/test.cfg
@@ -0,0 +1,2 @@
+compile(LeafFuncAlloca)
+run(LeafFuncAlloca)
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0047-ByteSwap16/ByteSwap16.c b/testsuite/c_test/x64_be_enable_test/ENABLE0047-ByteSwap16/ByteSwap16.c
new file mode 100644
index 0000000000000000000000000000000000000000..88d42e1f30b74db91804d50e827350ec6d523708
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0047-ByteSwap16/ByteSwap16.c
@@ -0,0 +1,9 @@
+unsigned short func(unsigned short x) {
+  return (unsigned short int)(((x >> 8) & 0xff) | ((x & 0xff) << 8));
+}
+
+int main() {
+  unsigned short x = 0xabcd;
+  printf("%x\n", (unsigned int)func(x));
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0047-ByteSwap16/expected.txt b/testsuite/c_test/x64_be_enable_test/ENABLE0047-ByteSwap16/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ddc58c0c0cfedd024114d740e7322ace9eb48c59
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0047-ByteSwap16/expected.txt
@@ -0,0 +1 @@
+cdab
diff --git a/testsuite/c_test/x64_be_enable_test/ENABLE0047-ByteSwap16/test.cfg b/testsuite/c_test/x64_be_enable_test/ENABLE0047-ByteSwap16/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..793cc5f4fffb7b9c36e66a6dd035c6b3e5609cce
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/ENABLE0047-ByteSwap16/test.cfg
@@ -0,0 +1,2 @@
+compile(ByteSwap16)
+run(ByteSwap16)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00001-g.torture.execute-20040703-1/20040703-1.c b/testsuite/c_test/x64_be_enable_test/GCC00001-g.torture.execute-20040703-1/20040703-1.c
new file mode 100755
index 0000000000000000000000000000000000000000..a1b75d90bbc016490e3cd6bb5bb61cc905903e23
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00001-g.torture.execute-20040703-1/20040703-1.c
@@ -0,0 +1,148 @@
+/* PR 16341 */
+/* { dg-require-effective-target int32plus } */
+
+#define PART_PRECISION (sizeof (cpp_num_part) * 8)
+
+typedef unsigned int cpp_num_part;
+typedef struct cpp_num cpp_num;
+struct cpp_num
+{
+   cpp_num_part high;
+   cpp_num_part low;
+   int unsignedp;  /* True if value should be treated as unsigned.  */
+   int overflow;   /* True if the most recent calculation overflowed.  */
+};
+
+static  int
+num_positive (cpp_num num, unsigned int precision)
+{
+   if (precision > PART_PRECISION)
+     {
+       precision -= PART_PRECISION;
+       return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
+     }
+
+   return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
+}
+
+static cpp_num
+num_trim (cpp_num num, unsigned int precision)
+{
+   if (precision > PART_PRECISION)
+     {
+       precision -= PART_PRECISION;
+       if (precision < PART_PRECISION)
+         num.high &= ((cpp_num_part) 1 << precision) - 1;
+     }
+   else
+     {
+       if (precision < PART_PRECISION)
+         num.low &= ((cpp_num_part) 1 << precision) - 1;
+       num.high = 0;
+     }
+
+   return num;
+}
+
+/* Shift NUM, of width PRECISION, right by N bits.  */
+static cpp_num
+num_rshift (cpp_num num, unsigned int precision, unsigned int n)
+{
+   cpp_num_part sign_mask;
+   int x = num_positive (num, precision);
+
+   if (num.unsignedp || x)
+     sign_mask = 0;
+   else
+     sign_mask = ~(cpp_num_part) 0;
+
+   if (n >= precision)
+     num.high = num.low = sign_mask;
+   else
+     {
+       /* Sign-extend.  */
+       if (precision < PART_PRECISION)
+         num.high = sign_mask, num.low |= sign_mask << precision;
+       else if (precision < 2 * PART_PRECISION)
+         num.high |= sign_mask << (precision - PART_PRECISION);
+
+       if (n >= PART_PRECISION)
+         {
+           n -= PART_PRECISION;
+           num.low = num.high;
+           num.high = sign_mask;
+         }
+
+       if (n)
+         {
+           num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
+           num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
+         }
+     }
+
+   num = num_trim (num, precision);
+   num.overflow = 0;
+   return num;
+}
+                              #define num_zerop(num) ((num.low | num.high) == 0)
+#define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
+
+cpp_num
+num_lshift (cpp_num num, unsigned int precision, unsigned int n)
+{
+   if (n >= precision)
+     {
+       num.overflow = !num.unsignedp && !num_zerop (num);
+       num.high = num.low = 0;
+     }
+   else
+     {
+       cpp_num orig;
+       unsigned int m = n;
+
+       orig = num;
+       if (m >= PART_PRECISION)
+         {
+           m -= PART_PRECISION;
+           num.high = num.low;
+           num.low = 0;
+         }
+       if (m)
+         {
+           num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
+           num.low <<= m;
+         }
+       num = num_trim (num, precision);
+
+       if (num.unsignedp)
+         num.overflow = 0;
+       else
+         {
+           cpp_num maybe_orig = num_rshift (num, precision, n);
+           num.overflow = !num_eq (orig, maybe_orig);
+         }
+     }
+
+   return num;
+}
+
+unsigned int precision = 64;
+unsigned int n = 16;
+
+cpp_num num = { 0, 3, 0, 0 };
+
+int main()
+{
+   cpp_num res = num_lshift (num, 64, n);
+
+   if (res.low != 0x30000)
+     abort ();
+
+   if (res.high != 0)
+     abort ();
+
+   if (res.overflow != 0)
+     abort ();
+
+   exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00001-g.torture.execute-20040703-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00001-g.torture.execute-20040703-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00001-g.torture.execute-20040703-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00001-g.torture.execute-20040703-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0be5497ca65ce8e51170ff426d319976d6309e0b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00001-g.torture.execute-20040703-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040703-1)
+run(20040703-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00002-g.torture.execute-20070623-1/20070623-1.c b/testsuite/c_test/x64_be_enable_test/GCC00002-g.torture.execute-20070623-1/20070623-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e9c7d2a952d0f20e090ef42f7057a62601594ea4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00002-g.torture.execute-20070623-1/20070623-1.c
@@ -0,0 +1,41 @@
+#include <limits.h>
+
+int __attribute__((noinline)) nge(int a, int b) {return -(a >= b);}
+int __attribute__((noinline)) ngt(int a, int b) {return -(a > b);}
+int __attribute__((noinline)) nle(int a, int b) {return -(a <= b);}
+int __attribute__((noinline)) nlt(int a, int b) {return -(a < b);}
+int __attribute__((noinline)) neq(int a, int b) {return -(a == b);}
+int __attribute__((noinline)) nne(int a, int b) {return -(a != b);}
+int __attribute__((noinline)) ngeu(unsigned a, unsigned b) {return -(a >= b);}
+int __attribute__((noinline)) ngtu(unsigned a, unsigned b) {return -(a > b);}
+int __attribute__((noinline)) nleu(unsigned a, unsigned b) {return -(a <= b);}
+int __attribute__((noinline)) nltu(unsigned a, unsigned b) {return -(a < b);}
+
+
+int main()
+{
+  if (nge(INT_MIN, INT_MAX) !=  0) abort();
+  if (nge(INT_MAX, INT_MIN) != -1) abort();
+  if (ngt(INT_MIN, INT_MAX) !=  0) abort();
+  if (ngt(INT_MAX, INT_MIN) != -1) abort();
+  if (nle(INT_MIN, INT_MAX) != -1) abort();
+  if (nle(INT_MAX, INT_MIN) !=  0) abort();
+  if (nlt(INT_MIN, INT_MAX) != -1) abort();
+  if (nlt(INT_MAX, INT_MIN) !=  0) abort();
+
+  if (neq(INT_MIN, INT_MAX) !=  0) abort();
+  if (neq(INT_MAX, INT_MIN) !=  0) abort();
+  if (nne(INT_MIN, INT_MAX) != -1) abort();
+  if (nne(INT_MAX, INT_MIN) != -1) abort();
+
+  if (ngeu(0, ~0U) !=  0) abort();
+  if (ngeu(~0U, 0) != -1) abort();
+  if (ngtu(0, ~0U) !=  0) abort();
+  if (ngtu(~0U, 0) != -1) abort();
+  if (nleu(0, ~0U) != -1) abort();
+  if (nleu(~0U, 0) !=  0) abort();
+  if (nltu(0, ~0U) != -1) abort();
+  if (nltu(~0U, 0) !=  0) abort();
+  
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00002-g.torture.execute-20070623-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00002-g.torture.execute-20070623-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00002-g.torture.execute-20070623-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00002-g.torture.execute-20070623-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d380ae22e33ad71a3b460fe92b7570afebd0c17c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00002-g.torture.execute-20070623-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20070623-1)
+run(20070623-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00003-g.torture.execute-cmpdi-1/cmpdi-1.c b/testsuite/c_test/x64_be_enable_test/GCC00003-g.torture.execute-cmpdi-1/cmpdi-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e3e9c86060365545503065662a76749a088b67d3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00003-g.torture.execute-cmpdi-1/cmpdi-1.c
@@ -0,0 +1,218 @@
+#define F 140
+#define T 13
+
+feq (x, y)
+     long long int x;
+     long long int y;
+{
+  if (x == y)
+    return T;
+  else
+    return F;
+}
+
+fne (x, y)
+     long long int x;
+     long long int y;
+{
+  if (x != y)
+    return T;
+  else
+    return F;
+}
+
+flt (x, y)
+     long long int x;
+     long long int y;
+{
+  if (x < y)
+    return T;
+  else
+    return F;
+}
+
+fge (x, y)
+     long long int x;
+     long long int y;
+{
+  if (x >= y)
+    return T;
+  else
+    return F;
+}
+
+fgt (x, y)
+     long long int x;
+     long long int y;
+{
+  if (x > y)
+    return T;
+  else
+    return F;
+}
+
+fle (x, y)
+     long long int x;
+     long long int y;
+{
+  if (x <= y)
+    return T;
+  else
+    return F;
+}
+
+fltu (x, y)
+     unsigned long long int x;
+     unsigned long long int y;
+{
+  if (x < y)
+    return T;
+  else
+    return F;
+}
+
+fgeu (x, y)
+     unsigned long long int x;
+     unsigned long long int y;
+{
+  if (x >= y)
+    return T;
+  else
+    return F;
+}
+
+fgtu (x, y)
+     unsigned long long int x;
+     unsigned long long int y;
+{
+  if (x > y)
+    return T;
+  else
+    return F;
+}
+
+fleu (x, y)
+     unsigned long long int x;
+     unsigned long long int y;
+{
+  if (x <= y)
+    return T;
+  else
+    return F;
+}
+
+long long args[] =
+{
+  0LL,
+  1LL,
+  -1LL,
+  0x7fffffffffffffffLL,
+  0x8000000000000000LL,
+  0x8000000000000001LL,
+  0x1A3F237394D36C58LL,
+  0x93850E92CAAC1B04LL
+};
+
+int correct_results[] =
+{
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, T, F, F, T,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T
+};
+
+main ()
+{
+  int i, j, *res = correct_results;
+
+  for (i = 0; i < 8; i++)
+    {
+      long long arg0 = args[i];
+      for (j = 0; j < 8; j++)
+	{
+	  long long arg1 = args[j];
+
+	  if (feq (arg0, arg1) != *res++)
+	    abort ();
+	  if (fne (arg0, arg1) != *res++)
+	    abort ();
+	  if (flt (arg0, arg1) != *res++)
+	    abort ();
+	  if (fge (arg0, arg1) != *res++)
+	    abort ();
+	  if (fgt (arg0, arg1) != *res++)
+	    abort ();
+	  if (fle (arg0, arg1) != *res++)
+	    abort ();
+	  if (fltu (arg0, arg1) != *res++)
+	    abort ();
+	  if (fgeu (arg0, arg1) != *res++)
+	    abort ();
+	  if (fgtu (arg0, arg1) != *res++)
+	    abort ();
+	  if (fleu (arg0, arg1) != *res++)
+	    abort ();
+	}
+    }
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00003-g.torture.execute-cmpdi-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00003-g.torture.execute-cmpdi-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00003-g.torture.execute-cmpdi-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00003-g.torture.execute-cmpdi-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eb524da3d667ad4a615a1a200cdfc7bfef2583c2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00003-g.torture.execute-cmpdi-1/test.cfg
@@ -0,0 +1,2 @@
+compile(cmpdi-1)
+run(cmpdi-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00004-g.torture.execute-pr35800/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00004-g.torture.execute-pr35800/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00004-g.torture.execute-pr35800/pr35800.c b/testsuite/c_test/x64_be_enable_test/GCC00004-g.torture.execute-pr35800/pr35800.c
new file mode 100644
index 0000000000000000000000000000000000000000..22b36f0b3bb4617ef802d2bf19d2c648c9e93f7e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00004-g.torture.execute-pr35800/pr35800.c
@@ -0,0 +1,103 @@
+extern void abort (void);
+
+int stab_xcoff_builtin_type (int typenum)
+{
+  const char *name;
+  if (typenum >= 0 || typenum < -34)
+    {
+      return 0;
+    }
+  switch (-typenum)
+    {
+    case 1:
+      name = "int";
+      break;
+    case 2:
+      name = "char";
+    case 3:
+      name = "short";
+      break;
+    case 4:
+      name = "long";
+    case 5:
+      name = "unsigned char";
+    case 6:
+      name = "signed char";
+    case 7:
+      name = "unsigned short";
+    case 8:
+      name = "unsigned int";
+    case 9:
+      name = "unsigned";
+    case 10:
+      name = "unsigned long";
+    case 11:
+      name = "void";
+    case 12:
+      name = "float";
+    case 13:
+      name = "double";
+    case 14:
+      name = "long double";
+    case 15:
+      name = "integer";
+    case 16:
+      name = "boolean";
+    case 17:
+      name = "short real";
+    case 18:
+      name = "real";
+    case 19:
+      name = "stringptr";
+    case 20:
+      name = "character";
+    case 21:
+      name = "logical*1";
+    case 22:
+      name = "logical*2";
+    case 23:
+      name = "logical*4";
+    case 24:
+      name = "logical";
+    case 25:
+      name = "complex";
+    case 26:
+      name = "double complex";
+    case 27:
+      name = "integer*1";
+    case 28:
+      name = "integer*2";
+    case 29:
+      name = "integer*4";
+    case 30:
+      name = "wchar";
+    case 31:
+      name = "long long";
+    case 32:
+      name = "unsigned long long";
+    case 33:
+      name = "logical*8";
+    case 34:
+      name = "integer*8";
+    }
+  return name[0];
+}
+
+int main()
+{
+  int i;
+  if (stab_xcoff_builtin_type(0) != 0)
+    abort ();
+  if (stab_xcoff_builtin_type(-1) != 'i')
+    abort ();
+  if (stab_xcoff_builtin_type(-2) != 's')
+    abort ();
+  if (stab_xcoff_builtin_type(-3) != 's')
+    abort ();
+  for (i = -4; i >= -34; --i)
+    if (stab_xcoff_builtin_type(i) != 'i')
+      abort ();
+  if (stab_xcoff_builtin_type(-35) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00004-g.torture.execute-pr35800/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00004-g.torture.execute-pr35800/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16a091bec4f4ed8131fa3d9c64034254ccd4c7f9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00004-g.torture.execute-pr35800/test.cfg
@@ -0,0 +1,2 @@
+compile(pr35800)
+run(pr35800)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00005-g.torture.execute-pr49186/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00005-g.torture.execute-pr49186/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00005-g.torture.execute-pr49186/pr49186.c b/testsuite/c_test/x64_be_enable_test/GCC00005-g.torture.execute-pr49186/pr49186.c
new file mode 100644
index 0000000000000000000000000000000000000000..743815b98026748780d1cad93ba6ca8fb2006ab9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00005-g.torture.execute-pr49186/pr49186.c
@@ -0,0 +1,15 @@
+/* PR target/49186 */
+extern void abort (void);
+
+int
+main ()
+{
+  int x;
+  unsigned long long uv = 0x1000000001ULL;
+
+  x = (uv < 0x80) ? 1 : ((uv < 0x800) ? 2 : 3);
+  if (x != 3)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00005-g.torture.execute-pr49186/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00005-g.torture.execute-pr49186/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f4257241f4ab0b2c719c4f13b5a2e43bd1b578d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00005-g.torture.execute-pr49186/test.cfg
@@ -0,0 +1,2 @@
+compile(pr49186)
+run(pr49186)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00006-g.torture.execute-pr70005/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00006-g.torture.execute-pr70005/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00006-g.torture.execute-pr70005/pr70005.c b/testsuite/c_test/x64_be_enable_test/GCC00006-g.torture.execute-pr70005/pr70005.c
new file mode 100644
index 0000000000000000000000000000000000000000..bc37efe00cbd74d2bfba562e999142a9de1e0f4b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00006-g.torture.execute-pr70005/pr70005.c
@@ -0,0 +1,25 @@
+
+unsigned char a = 6;
+int b, c;
+
+static void
+fn1 ()
+{
+  int i = a > 1 ? 1 : a, j = 6 & (c = a && (b = a));
+  int d = 0, e = a, f = ~c, g = b || a;
+  unsigned char h = ~a;
+  if (a)
+    f = j;
+  if (h && g)
+    d = a;
+  i = -~(f * d * h) + c && (e || i) ^ f;
+  if (i != 1) 
+    __builtin_abort (); 
+}
+
+int
+main ()
+{
+  fn1 ();
+  return 0; 
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00006-g.torture.execute-pr70005/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00006-g.torture.execute-pr70005/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d4cbee1261ded2b03073ac2cb3b5d9d173330af7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00006-g.torture.execute-pr70005/test.cfg
@@ -0,0 +1,2 @@
+compile(pr70005)
+run(pr70005)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00007-g.torture.execute-pr70602/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00007-g.torture.execute-pr70602/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00007-g.torture.execute-pr70602/pr70602.c b/testsuite/c_test/x64_be_enable_test/GCC00007-g.torture.execute-pr70602/pr70602.c
new file mode 100644
index 0000000000000000000000000000000000000000..4a931fc4b74326e30181d0a9b7d352a4ee20e238
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00007-g.torture.execute-pr70602/pr70602.c
@@ -0,0 +1,24 @@
+/* PR tree-optimization/70602 */
+/* { dg-require-effective-target int32plus } */
+
+struct __attribute__((packed)) S
+{
+  int s : 1;
+  int t : 20;
+};
+
+int a, b, c;
+
+int
+main ()
+{
+  for (; a < 1; a++)
+    {
+      struct S e[] = { {0, 9}, {0, 9}, {0, 9}, {0, 0}, {0, 9}, {0, 9}, {0, 9}, 
+		       {0, 0}, {0, 9}, {0, 9}, {0, 9}, {0, 0}, {0, 9}, {0, 9}, 
+		       {0, 9}, {0, 0}, {0, 9}, {0, 9}, {0, 9}, {0, 0}, {0, 9} };
+      b = b || e[0].s;
+      c = e[0].t;
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00007-g.torture.execute-pr70602/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00007-g.torture.execute-pr70602/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..96733665b6599fbb103ffb9f00f6ee858e65dd88
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00007-g.torture.execute-pr70602/test.cfg
@@ -0,0 +1,2 @@
+compile(pr70602)
+run(pr70602)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00008-g.torture.execute-strlen-6/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00008-g.torture.execute-strlen-6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00008-g.torture.execute-strlen-6/strlen-6.c b/testsuite/c_test/x64_be_enable_test/GCC00008-g.torture.execute-strlen-6/strlen-6.c
new file mode 100644
index 0000000000000000000000000000000000000000..1df5b21f6164f75b82ee0e6ccadaadfaa40850df
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00008-g.torture.execute-strlen-6/strlen-6.c
@@ -0,0 +1,113 @@
+/* Test to verify that strlen() calls with conditional expressions
+   and unterminated arrays or pointers to such things as arguments
+   are evaluated without making assumptions about array sizes.  */
+
+extern __SIZE_TYPE__ strlen (const char *);
+
+unsigned nfails;
+
+#define A(expr, N)						\
+  do {								\
+    const char *_s = (expr);					\
+    unsigned _n = strlen (_s);					\
+    ((_n == N)							\
+     ? 0							\
+     : (__builtin_printf ("line %i: strlen ((%s) = (\"%s\"))"	\
+			  " == %u failed\n",			\
+			  __LINE__, #expr, _s, N),		\
+	++nfails));						\
+  } while (0)
+
+
+volatile int i0 = 0;
+
+const char ca[2][3] = { "12" };
+const char cb[2][3] = { { '1', '2', '3', }, { '4' } };
+
+char va[2][3] = { "123" };
+char vb[2][3] = { { '1', '2', '3', }, { '4', '5' } };
+
+const char *s = "123456";
+
+
+static void test_binary_cond_expr_global (void)
+{
+  A (i0 ? "1" : ca[0], 2);
+  A (i0 ? ca[0] : "123", 3);
+
+  /* The call to strlen (cb[0]) is strictly undefined because the array
+     isn't nul-terminated.  This test verifies that the strlen range
+     optimization doesn't assume that the argument is necessarily nul
+     terminated.
+     Ditto for strlen (vb[0]).  */
+  A (i0 ? "1" : cb[0], 4);              /* GCC 8.2 failure */
+  A (i0 ? cb[0] : "12", 2);
+
+  A (i0 ? "1" : va[0], 3);              /* GCC 8.2 failure */
+  A (i0 ? va[0] : "1234", 4);
+
+  A (i0 ? "1" : vb[0], 5);              /* GCC 8.2 failure */
+  A (i0 ? vb[0] : "12", 2);
+}
+
+
+static void test_binary_cond_expr_local (void)
+{
+  const char lca[2][3] = { "12" };
+  const char lcb[2][3] = { { '1', '2', '3', }, { '4' } };
+
+  char lva[2][3] = { "123" };
+  char lvb[2][3] = { { '1', '2', '3', }, { '4', '5' } };
+
+  /* Also undefined as above.  */
+  A (i0 ? "1" : lca[0], 2);
+  A (i0 ? lca[0] : "123", 3);
+
+  A (i0 ? "1" : lcb[0], 4);             /* GCC 8.2 failure */
+  A (i0 ? lcb[0] : "12", 2);
+
+  A (i0 ? "1" : lva[0], 3);             /* GCC 8.2 failure */
+  A (i0 ? lva[0] : "1234", 4);
+
+  A (i0 ? "1" : lvb[0], 5);             /* GCC 8.2 failure */
+  A (i0 ? lvb[0] : "12", 2);
+}
+
+
+static void test_ternary_cond_expr (void)
+{
+  /* Also undefined.  */
+  A (i0 == 0 ? s : i0 == 1 ? vb[0] : "123", 6);
+  A (i0 == 0 ? vb[0] : i0 == 1 ? s : "123", 5);
+  A (i0 == 0 ? "123" : i0 == 1 ? s : vb[0], 3);
+}
+
+
+const char (*pca)[3] = &ca[0];
+const char (*pcb)[3] = &cb[0];
+
+char (*pva)[3] = &va[0];
+char (*pvb)[3] = &vb[0];
+
+static void test_binary_cond_expr_arrayptr (void)
+{
+  /* Also undefined.  */
+  A (i0 ? *pca : *pcb, 4);              /* GCC 8.2 failure */
+  A (i0 ? *pcb : *pca, 2);
+
+  A (i0 ? *pva : *pvb, 5);              /* GCC 8.2 failure */
+  A (i0 ? *pvb : *pva, 3);
+}
+
+
+int main (void)
+{
+  test_binary_cond_expr_global ();
+  test_binary_cond_expr_local ();
+
+  test_ternary_cond_expr ();
+  test_binary_cond_expr_arrayptr ();
+
+  if (nfails)
+    __builtin_abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00008-g.torture.execute-strlen-6/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00008-g.torture.execute-strlen-6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..63e40334aeeb4a4ca2ab853773684ee4aa301a2c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00008-g.torture.execute-strlen-6/test.cfg
@@ -0,0 +1,2 @@
+compile(strlen-6)
+run(strlen-6)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00009-g.torture.execute-pr98474/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00009-g.torture.execute-pr98474/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00009-g.torture.execute-pr98474/pr98474.c b/testsuite/c_test/x64_be_enable_test/GCC00009-g.torture.execute-pr98474/pr98474.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c287994580b236782c196ee9a2d412cd2444278
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00009-g.torture.execute-pr98474/pr98474.c
@@ -0,0 +1,30 @@
+/* PR tree-optimization/98474 */
+
+#ifdef __SIZEOF_INT128__
+typedef __uint128_t T;
+#define N (__SIZEOF_INT128__ * __CHAR_BIT__ / 2)
+#else
+typedef unsigned long long T;
+#define N (__SIZEOF_LONG_LONG__ * __CHAR_BIT__ / 2)
+#endif
+
+__attribute__ ((noipa)) void
+foo (T *x)
+{
+  *x += ((T) 1) << (N + 1);
+}
+
+int
+main ()
+{
+  T a = ((T) 1) << (N + 1);
+  T b = a;
+  T n;
+  foo (&b);
+  n = b;
+  while (n >= a)
+    n -= a;
+  if ((int) (n >> N) != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00009-g.torture.execute-pr98474/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00009-g.torture.execute-pr98474/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e11e93c48fbb6cd09b714df58e6f5f9e9692a65d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00009-g.torture.execute-pr98474/test.cfg
@@ -0,0 +1,2 @@
+compile(pr98474)
+run(pr98474)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00010-g.torture.execute-stdarg-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00010-g.torture.execute-stdarg-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00010-g.torture.execute-stdarg-2/stdarg-2.c b/testsuite/c_test/x64_be_enable_test/GCC00010-g.torture.execute-stdarg-2/stdarg-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..40246f937efe6a99119d0e8ffb631ffa08002e79
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00010-g.torture.execute-stdarg-2/stdarg-2.c
@@ -0,0 +1,180 @@
+#include <stdarg.h>
+
+extern void abort (void);
+
+int foo_arg, bar_arg;
+long x;
+double d;
+va_list gap;
+
+void
+foo (int v, va_list ap)
+{
+  switch (v)
+    {
+    case 5:
+      foo_arg = va_arg (ap, int);
+      foo_arg += va_arg (ap, double);
+      foo_arg += va_arg (ap, long long);
+      break;
+    case 8:
+      foo_arg = va_arg (ap, long long);
+      foo_arg += va_arg (ap, double);
+      break;
+    case 11:
+      foo_arg = va_arg (ap, int);
+      foo_arg += va_arg (ap, long double);
+      break;
+    default:
+      abort ();
+    }
+}
+
+void
+bar (int v)
+{
+  if (v == 0x4002)
+    {
+      if (va_arg (gap, int) != 13 || va_arg (gap, double) != -14.0)
+	abort ();
+    }
+  bar_arg = v;
+}
+
+void
+f1 (int i, ...)
+{
+  va_start (gap, i);
+  x = va_arg (gap, long);
+  va_end (gap);
+}
+
+void
+f2 (int i, ...)
+{
+  va_start (gap, i);
+  bar (i);
+  va_end (gap);
+}
+
+void
+f3 (int i, ...)
+{
+  va_list aps[10];
+  va_start (aps[4], i);
+  x = va_arg (aps[4], long);
+  va_end (aps[4]);
+}
+
+void
+f4 (int i, ...)
+{
+  va_list aps[10];
+  va_start (aps[4], i);
+  bar (i);
+  va_end (aps[4]);
+}
+
+void
+f5 (int i, ...)
+{
+  va_list aps[10];
+  va_start (aps[4], i);
+  foo (i, aps[4]);
+  va_end (aps[4]);
+}
+
+struct A { int i; va_list g; va_list h[2]; };
+
+void
+f6 (int i, ...)
+{
+  struct A a;
+  va_start (a.g, i);
+  x = va_arg (a.g, long);
+  va_end (a.g);
+}
+
+void
+f7 (int i, ...)
+{
+  struct A a;
+  va_start (a.g, i);
+  bar (i);
+  va_end (a.g);
+}
+
+void
+f8 (int i, ...)
+{
+  struct A a;
+  va_start (a.g, i);
+  foo (i, a.g);
+  va_end (a.g);
+}
+
+void
+f10 (int i, ...)
+{
+  struct A a;
+  va_start (a.h[1], i);
+  x = va_arg (a.h[1], long);
+  va_end (a.h[1]);
+}
+
+void
+f11 (int i, ...)
+{
+  struct A a;
+  va_start (a.h[1], i);
+  bar (i);
+  va_end (a.h[1]);
+}
+
+void
+f12 (int i, ...)
+{
+  struct A a;
+  va_start (a.h[1], i);
+  foo (i, a.h[1]);
+  va_end (a.h[1]);
+}
+
+int
+main (void)
+{
+  f1 (1, 79L);
+  if (x != 79L)
+    abort ();
+  f2 (0x4002, 13, -14.0);
+  if (bar_arg != 0x4002)
+    abort ();
+  f3 (3, 2031L);
+  if (x != 2031)
+    abort ();
+  f4 (4, 18);
+  if (bar_arg != 4)
+    abort ();
+  f5 (5, 1, 19.0, 18LL);
+  if (foo_arg != 38)
+    abort ();
+  f6 (6, 18L);
+  if (x != 18L)
+    abort ();
+  f7 (7);
+  if (bar_arg != 7)
+    abort ();
+  f8 (8, 2031LL, 13.0);
+  if (foo_arg != 2044)
+    abort ();
+  f10 (9, 180L);
+  if (x != 180L)
+    abort ();
+  f11 (10);
+  if (bar_arg != 10)
+    abort ();
+  f12 (11, 2030, 12.0L);
+  if (foo_arg != 2042)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00010-g.torture.execute-stdarg-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00010-g.torture.execute-stdarg-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..42c3c805bfb8869281bde7ef7e017060c843aee1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00010-g.torture.execute-stdarg-2/test.cfg
@@ -0,0 +1,2 @@
+compile(stdarg-2)
+run(stdarg-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00011-g.torture.execute-pr81423/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00011-g.torture.execute-pr81423/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00011-g.torture.execute-pr81423/pr81423.c b/testsuite/c_test/x64_be_enable_test/GCC00011-g.torture.execute-pr81423/pr81423.c
new file mode 100644
index 0000000000000000000000000000000000000000..be7413be334aacd4e70c328a5df7cc935d4de601
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00011-g.torture.execute-pr81423/pr81423.c
@@ -0,0 +1,39 @@
+/* PR rtl-optimization/81423 */
+
+extern void abort (void);
+
+unsigned long long int ll = 0;
+unsigned long long int ull1 = 1ULL;
+unsigned long long int ull2 = 12008284144813806346ULL;
+unsigned long long int ull3;
+
+unsigned long long int __attribute__ ((noinline))
+foo (void)
+{
+  ll = -5597998501375493990LL;
+
+  ll = (unsigned int) (5677365550390624949LL - ll) - (ull1 > 0);
+  unsigned long long int ull3;
+  ull3 = (unsigned int)
+    (2067854353LL <<
+     (((ll + -2129105131LL) ^ 10280750144413668236ULL) -
+      10280750143997242009ULL)) >> ((2873442921854271231ULL | ull2)
+				    - 12098357307243495419ULL);
+
+  return ull3;
+}
+
+int
+main (void)
+{
+  /* We need a long long of exactly 64 bits and int of exactly 32 bits
+     for this test.  */
+  if (__SIZEOF_LONG_LONG__ * __CHAR_BIT__ != 64
+      || __SIZEOF_INT__ * __CHAR_BIT__ != 32)
+    return 0;
+
+  ull3 = foo ();
+  if (ull3 != 3998784)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00011-g.torture.execute-pr81423/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00011-g.torture.execute-pr81423/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..df13bfcc57d9a90298a49f94718ba627db5b1aba
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00011-g.torture.execute-pr81423/test.cfg
@@ -0,0 +1,2 @@
+compile(pr81423)
+run(pr81423)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00012-g.torture.execute-loop-2f/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00012-g.torture.execute-loop-2f/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00012-g.torture.execute-loop-2f/loop-2f.c b/testsuite/c_test/x64_be_enable_test/GCC00012-g.torture.execute-loop-2f/loop-2f.c
new file mode 100644
index 0000000000000000000000000000000000000000..a857f270c3008d8670bb87c42cd9032c6cc59ded
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00012-g.torture.execute-loop-2f/loop-2f.c
@@ -0,0 +1,64 @@
+/* { dg-require-effective-target mmap } */
+/* { dg-skip-if "the executable is at the same position the test tries to remap" { m68k-*-linux* } } */
+
+#include <limits.h>
+
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#ifndef MAP_ANON
+#ifdef MAP_ANONYMOUS
+#define MAP_ANON MAP_ANONYMOUS
+#else
+#define MAP_ANON MAP_FILE
+#endif
+#endif
+#ifndef MAP_FILE
+#define MAP_FILE 0
+#endif
+#ifndef MAP_FIXED
+#define MAP_FIXED 0
+#endif
+
+#define MAP_START (void *)0x7fff8000
+#define MAP_LEN 0x10000
+
+#define OFFSET (MAP_LEN/2 - 2 * sizeof (char));
+
+f (int s, char *p)
+{
+  int i;
+  for (i = s; i >= 0 && &p[i] < &p[40]; i++)
+    {
+      p[i] = -2;
+    }
+}
+
+main ()
+{
+#ifdef MAP_ANON
+  char *p;
+  int dev_zero;
+
+  dev_zero = open ("/dev/zero", O_RDONLY);
+  /* -1 is OK when we have MAP_ANON; else mmap will flag an error.  */
+  if (INT_MAX != 0x7fffffffL || sizeof (char *) != sizeof (int))
+    exit (0);
+  p = mmap (MAP_START, MAP_LEN, PROT_READ|PROT_WRITE,
+	    MAP_ANON|MAP_FIXED|MAP_PRIVATE, dev_zero, 0);
+  if (p != (char *)-1)
+    {
+      p += OFFSET;
+      p[39] = 0;
+      f (0, p);
+      if (p[39] != (char)-2)
+	abort ();
+      p[39] = 0;
+      f (-1, p);
+      if (p[39] != 0)
+	abort ();
+    }
+#endif
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00012-g.torture.execute-loop-2f/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00012-g.torture.execute-loop-2f/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1d2f353dc63d0f78c844df5c54af83f24df2609d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00012-g.torture.execute-loop-2f/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-2f)
+run(loop-2f)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00013-g.torture.execute-alloca-1/alloca-1.c b/testsuite/c_test/x64_be_enable_test/GCC00013-g.torture.execute-alloca-1/alloca-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6a65ddfe9145e327ba9757f9955b0457c0facd66
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00013-g.torture.execute-alloca-1/alloca-1.c
@@ -0,0 +1,22 @@
+/* { dg-skip-if "requires alloca" { ! alloca } { "-O0" } { "" } } */
+/* Verify that alloca storage is sufficiently aligned.  */
+/* ??? May fail if BIGGEST_ALIGNMENT > STACK_BOUNDARY.  Which, I guess
+   can only happen on !STRICT_ALIGNMENT targets.  */
+
+typedef __SIZE_TYPE__ size_t;
+
+struct dummy { int x __attribute__((aligned)); };
+#define BIGGEST_ALIGNMENT __alignof__(struct dummy)
+
+_Bool foo(void)
+{
+  char *p = __builtin_alloca(32);
+  return ((size_t)p & (BIGGEST_ALIGNMENT - 1)) == 0;
+}
+
+int main()
+{
+  if (!foo())
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00013-g.torture.execute-alloca-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00013-g.torture.execute-alloca-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00013-g.torture.execute-alloca-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00013-g.torture.execute-alloca-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..46a20f71457ffb7f9ddd8023972dcab6b2250330
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00013-g.torture.execute-alloca-1/test.cfg
@@ -0,0 +1,2 @@
+compile(alloca-1)
+run(alloca-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00014-g.torture.execute-20020611-1/20020611-1.c b/testsuite/c_test/x64_be_enable_test/GCC00014-g.torture.execute-20020611-1/20020611-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..b4ca945fde0516bb4eeb96bd8dc84a44cf44e691
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00014-g.torture.execute-20020611-1/20020611-1.c
@@ -0,0 +1,32 @@
+/* PR target/6997.  Missing (set_attr "cc" "none") in sleu pattern in
+   cris.md.  Testcase from hp@axis.com.  */
+ 
+int p;
+int k;
+unsigned int n;
+ 
+void x ()
+{
+  unsigned int h;
+ 
+  h = n <= 30;
+  if (h)
+    p = 1;
+  else
+    p = 0;
+ 
+  if (h)
+    k = 1;
+  else
+    k = 0;
+}
+ 
+unsigned int n = 30;
+ 
+main ()
+{
+  x ();
+  if (p != 1 || k != 1)
+    abort ();
+  exit (0);
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00014-g.torture.execute-20020611-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00014-g.torture.execute-20020611-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00014-g.torture.execute-20020611-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00014-g.torture.execute-20020611-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b83b22ad7725245757e727a67b51b515e76a4d20
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00014-g.torture.execute-20020611-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020611-1)
+run(20020611-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00015-g.torture.execute-20001124-1/20001124-1.c b/testsuite/c_test/x64_be_enable_test/GCC00015-g.torture.execute-20001124-1/20001124-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d53dfb6534ead6c2bedf13b08c42bff295c185b4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00015-g.torture.execute-20001124-1/20001124-1.c
@@ -0,0 +1,76 @@
+ 
+struct inode {
+	long long		i_size;
+	struct super_block	*i_sb;
+};
+ 
+struct file {
+	long long		f_pos;
+};
+ 
+struct super_block {
+	int			s_blocksize;
+	unsigned char		s_blocksize_bits;
+	int			s_hs;
+};
+ 
+static char *
+isofs_bread(unsigned int block)
+{
+	if (block)
+	  abort ();
+	exit(0);
+}
+ 
+static int
+do_isofs_readdir(struct inode *inode, struct file *filp)
+{
+	int bufsize = inode->i_sb->s_blocksize;
+	unsigned char bufbits = inode->i_sb->s_blocksize_bits;
+	unsigned int block, offset;
+	char *bh = 0;
+	int hs;
+ 
+ 	if (filp->f_pos >= inode->i_size)
+		return 0;
+ 
+	offset = filp->f_pos & (bufsize - 1);
+	block = filp->f_pos >> bufbits;
+	hs = inode->i_sb->s_hs;
+ 
+	while (filp->f_pos < inode->i_size) {
+		if (!bh)
+			bh = isofs_bread(block);
+ 
+		hs += block << bufbits;
+ 
+		if (hs == 0)
+			filp->f_pos++;
+ 
+		if (offset >= bufsize)
+			offset &= bufsize - 1;
+ 
+		if (*bh)
+			filp->f_pos++;
+ 
+		filp->f_pos++;
+	}
+	return 0;
+}
+ 
+struct super_block s;
+struct inode i;
+struct file f;
+ 
+int
+main(int argc, char **argv)
+{
+	s.s_blocksize = 512;
+	s.s_blocksize_bits = 9;
+	i.i_size = 2048;
+	i.i_sb = &s;
+	f.f_pos = 0;
+ 
+	do_isofs_readdir(&i,&f);
+	abort ();
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00015-g.torture.execute-20001124-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00015-g.torture.execute-20001124-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00015-g.torture.execute-20001124-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00015-g.torture.execute-20001124-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c0ea431aa7dd69bb1b897f23970b33c2d2736a3e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00015-g.torture.execute-20001124-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001124-1)
+run(20001124-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00016-g.torture.execute-pr45262/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00016-g.torture.execute-pr45262/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00016-g.torture.execute-pr45262/pr45262.c b/testsuite/c_test/x64_be_enable_test/GCC00016-g.torture.execute-pr45262/pr45262.c
new file mode 100644
index 0000000000000000000000000000000000000000..45cc8de3c59a2a05aacf70bdce7e0581d800d2d6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00016-g.torture.execute-pr45262/pr45262.c
@@ -0,0 +1,35 @@
+/* PR middle-end/45262 */
+
+/* { dg-require-effective-target int32plus } */
+
+extern void abort (void);
+
+int
+foo (unsigned int x)
+{
+  return ((int) x < 0) || ((int) (-x) < 0);
+}
+
+int
+bar (unsigned int x)
+{
+  return x >> 31 || (-x) >> 31;
+}
+
+int
+main (void)
+{
+  if (foo (1) != 1)
+    abort ();
+  if (foo (0) != 0)
+    abort ();
+  if (foo (-1) != 1)
+    abort ();
+  if (bar (1) != 1)
+    abort ();
+  if (bar (0) != 0)
+    abort ();
+  if (bar (-1) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00016-g.torture.execute-pr45262/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00016-g.torture.execute-pr45262/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..be56c2fce4347092b3af277f8d5b01f989156d21
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00016-g.torture.execute-pr45262/test.cfg
@@ -0,0 +1,2 @@
+compile(pr45262)
+run(pr45262)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00017-g.torture.execute-20040302-1/20040302-1.c b/testsuite/c_test/x64_be_enable_test/GCC00017-g.torture.execute-20040302-1/20040302-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..10bc133e7fc387ce210bc99b87ceb3b6cca9a913
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00017-g.torture.execute-20040302-1/20040302-1.c
@@ -0,0 +1,25 @@
+/* { dg-require-effective-target label_values } */
+int code[]={0,0,0,0,1};
+
+void foo(int x) {
+  volatile int b;
+  b = 0xffffffff;
+}
+
+void bar(int *pc) {
+  static const void *l[] = {&&lab0, &&end};
+
+  foo(0);
+  goto *l[*pc];
+ lab0:
+  foo(0);
+  pc++;
+  goto *l[*pc];
+ end:
+  return;
+}
+
+int main() {
+  bar(code);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00017-g.torture.execute-20040302-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00017-g.torture.execute-20040302-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00017-g.torture.execute-20040302-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00017-g.torture.execute-20040302-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d02bea62a41b91ca2b075251a2e6023c6438207b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00017-g.torture.execute-20040302-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040302-1)
+run(20040302-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00018-g.torture.execute-pr86231/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00018-g.torture.execute-pr86231/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00018-g.torture.execute-pr86231/pr86231.c b/testsuite/c_test/x64_be_enable_test/GCC00018-g.torture.execute-pr86231/pr86231.c
new file mode 100644
index 0000000000000000000000000000000000000000..79232ebd7f163fa01dba685e5765bb3012ec8c9e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00018-g.torture.execute-pr86231/pr86231.c
@@ -0,0 +1,30 @@
+/* PR tree-optimization/86231 */
+
+#define ONE ((void *) 1)
+#define TWO ((void *) 2)
+
+__attribute__((noipa)) int
+foo (void *p, int x)
+{
+  if (p == ONE) return 0;
+  if (!p)
+    p = x ? TWO : ONE;
+  return p == ONE ? 0 : 1;
+}
+
+int v[8];
+
+int
+main ()
+{
+  if (foo ((void *) 0, 0) != 0
+      || foo ((void *) 0, 1) != 1
+      || foo (ONE, 0) != 0
+      || foo (ONE, 1) != 0
+      || foo (TWO, 0) != 1
+      || foo (TWO, 1) != 1
+      || foo (&v[7], 0) != 1
+      || foo (&v[7], 1) != 1)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00018-g.torture.execute-pr86231/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00018-g.torture.execute-pr86231/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..99a48807b4e5c055276ebeb1231d1f6452215893
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00018-g.torture.execute-pr86231/test.cfg
@@ -0,0 +1,2 @@
+compile(pr86231)
+run(pr86231)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00019-g.torture.execute-20000818-1/20000818-1.c b/testsuite/c_test/x64_be_enable_test/GCC00019-g.torture.execute-20000818-1/20000818-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..827397058611c1287a5a1da59c97b13cc03d94fb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00019-g.torture.execute-20000818-1/20000818-1.c
@@ -0,0 +1,60 @@
+/* Copyright (C) 2000  Free Software Foundation.
+ 
+   by Manfred Hollstein <manfredh@redhat.com>  */
+ 
+void *temporary_obstack;
+ 
+static int input (void);
+static int ISALNUM (int ch);
+static void obstack_1grow (void **ptr, int ch);
+ 
+int yylex (void);
+int main (void);
+ 
+int main (void)
+{
+  int ch = yylex ();
+ 
+  exit (0);
+}
+ 
+int yylex (void)
+{
+  int ch;
+ 
+#ifndef WORK_AROUND
+  for (;;)
+    {
+      ch = input ();
+      if (ISALNUM (ch))
+        obstack_1grow (&temporary_obstack, ch);
+      else if (ch != '_')
+        break;
+    }
+#else
+  do
+    {
+      ch = input ();
+      if (ISALNUM (ch))
+        obstack_1grow (&temporary_obstack, ch);
+    } while (ch == '_');
+#endif
+ 
+  return ch;
+}
+ 
+static int input (void)
+{
+  return 0;
+}
+ 
+static int ISALNUM (int ch)
+{
+  return ((ch >= 'A' && ch <= 'Z')
+	  || (ch >= 'a' && ch <= 'z')
+	  || (ch >= '0' && ch <= '0'));
+}
+ 
+static void obstack_1grow (void **ptr, int ch)
+{
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00019-g.torture.execute-20000818-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00019-g.torture.execute-20000818-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00019-g.torture.execute-20000818-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00019-g.torture.execute-20000818-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..98a69b833ed9633818b2d9e0d3ed6df8e9a7fd9d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00019-g.torture.execute-20000818-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000818-1)
+run(20000818-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00020-g.torture.execute-return-addr/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00020-g.torture.execute-return-addr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00020-g.torture.execute-return-addr/return-addr.c b/testsuite/c_test/x64_be_enable_test/GCC00020-g.torture.execute-return-addr/return-addr.c
new file mode 100644
index 0000000000000000000000000000000000000000..827397058611c1287a5a1da59c97b13cc03d94fb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00020-g.torture.execute-return-addr/return-addr.c
@@ -0,0 +1,60 @@
+/* Copyright (C) 2000  Free Software Foundation.
+ 
+   by Manfred Hollstein <manfredh@redhat.com>  */
+ 
+void *temporary_obstack;
+ 
+static int input (void);
+static int ISALNUM (int ch);
+static void obstack_1grow (void **ptr, int ch);
+ 
+int yylex (void);
+int main (void);
+ 
+int main (void)
+{
+  int ch = yylex ();
+ 
+  exit (0);
+}
+ 
+int yylex (void)
+{
+  int ch;
+ 
+#ifndef WORK_AROUND
+  for (;;)
+    {
+      ch = input ();
+      if (ISALNUM (ch))
+        obstack_1grow (&temporary_obstack, ch);
+      else if (ch != '_')
+        break;
+    }
+#else
+  do
+    {
+      ch = input ();
+      if (ISALNUM (ch))
+        obstack_1grow (&temporary_obstack, ch);
+    } while (ch == '_');
+#endif
+ 
+  return ch;
+}
+ 
+static int input (void)
+{
+  return 0;
+}
+ 
+static int ISALNUM (int ch)
+{
+  return ((ch >= 'A' && ch <= 'Z')
+	  || (ch >= 'a' && ch <= 'z')
+	  || (ch >= '0' && ch <= '0'));
+}
+ 
+static void obstack_1grow (void **ptr, int ch)
+{
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00020-g.torture.execute-return-addr/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00020-g.torture.execute-return-addr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..02abc39bf12277bccf7c0aeddad6de2ddc0d7bc5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00020-g.torture.execute-return-addr/test.cfg
@@ -0,0 +1,2 @@
+compile(return-addr)
+run(return-addr)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00021-g.torture.execute-pr68376-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00021-g.torture.execute-pr68376-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00021-g.torture.execute-pr68376-1/pr68376-1.c b/testsuite/c_test/x64_be_enable_test/GCC00021-g.torture.execute-pr68376-1/pr68376-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..cb52657646cb5ff0f71108d755d76b79724cefd6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00021-g.torture.execute-pr68376-1/pr68376-1.c
@@ -0,0 +1,24 @@
+/* PR rtl-optimization/68376 */
+
+int a, b, c = 1;
+signed char d;
+
+int
+main ()
+{
+  for (; a < 1; a++)
+    for (; b < 1; b++)
+      {
+	signed char e = ~d;
+	if (d < 1)
+	  e = d;
+	d = e;
+	if (!c)
+	  __builtin_abort ();
+      }
+
+  if (d != 0)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00021-g.torture.execute-pr68376-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00021-g.torture.execute-pr68376-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3982b033bd2e1f1c8f614852f2d7a65f15a4348d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00021-g.torture.execute-pr68376-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr68376-1)
+run(pr68376-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00022-g.torture.execute-cmpsi-2/cmpsi-2.c b/testsuite/c_test/x64_be_enable_test/GCC00022-g.torture.execute-cmpsi-2/cmpsi-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..52c8065dd1b7576727565fe06f54ee2de13f4f2a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00022-g.torture.execute-cmpsi-2/cmpsi-2.c
@@ -0,0 +1,200 @@
+/* { dg-require-effective-target int32plus } */
+#define F 140
+#define T 13
+
+feq (int x, int y)
+{
+  if (x == y)
+    return T;
+  else
+    return F;
+}
+
+fne (int x, int y)
+{
+  if (x != y)
+    return T;
+  else
+    return F;
+}
+
+flt (int x, int y)
+{
+  if (x < y)
+    return T;
+  else
+    return F;
+}
+
+fge (int x, int y)
+{
+  if (x >= y)
+    return T;
+  else
+    return F;
+}
+
+fgt (int x, int y)
+{
+  if (x > y)
+    return T;
+  else
+    return F;
+}
+
+fle (int x, int y)
+{
+  if (x <= y)
+    return T;
+  else
+    return F;
+}
+
+fltu (unsigned int x, unsigned int y)
+{
+  if (x < y)
+    return T;
+  else
+    return F;
+}
+
+fgeu (unsigned int x, unsigned int y)
+{
+  if (x >= y)
+    return T;
+  else
+    return F;
+}
+
+fgtu (unsigned int x, unsigned int y)
+{
+  if (x > y)
+    return T;
+  else
+    return F;
+}
+
+fleu (unsigned int x, unsigned int y)
+{
+  if (x <= y)
+    return T;
+  else
+    return F;
+}
+
+unsigned int args[] =
+{
+  0L,
+  1L,
+  -1L,
+  0x7fffffffL,
+  0x80000000L,
+  0x80000001L,
+  0x1A3F2373L,
+  0x93850E92L
+};
+
+int correct_results[] =
+{
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, T, F, F, T,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  T, F, F, T, F, T, F, T, F, T,
+  F, T, F, T, T, F, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, T, F, F, T, T, F, F, T,
+  F, T, T, F, F, T, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, F, T, T, F, F, T, T, F,
+  F, T, T, F, F, T, F, T, T, F,
+  T, F, F, T, F, T, F, T, F, T
+};
+
+int
+main (void)
+{
+  int i, j, *res = correct_results;
+
+  for (i = 0; i < 8; i++)
+    {
+      unsigned int arg0 = args[i];
+      for (j = 0; j < 8; j++)
+	{
+	  unsigned int arg1 = args[j];
+
+	  if (feq (arg0, arg1) != *res++)
+	    abort ();
+	  if (fne (arg0, arg1) != *res++)
+	    abort ();
+	  if (flt (arg0, arg1) != *res++)
+	    abort ();
+	  if (fge (arg0, arg1) != *res++)
+	    abort ();
+	  if (fgt (arg0, arg1) != *res++)
+	    abort ();
+	  if (fle (arg0, arg1) != *res++)
+	    abort ();
+	  if (fltu (arg0, arg1) != *res++)
+	    abort ();
+	  if (fgeu (arg0, arg1) != *res++)
+	    abort ();
+	  if (fgtu (arg0, arg1) != *res++)
+	    abort ();
+	  if (fleu (arg0, arg1) != *res++)
+	    abort ();
+	}
+    }
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00022-g.torture.execute-cmpsi-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00022-g.torture.execute-cmpsi-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00022-g.torture.execute-cmpsi-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00022-g.torture.execute-cmpsi-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ac4b22205afb5385ff3717861b5b4b0d0a0eccbb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00022-g.torture.execute-cmpsi-2/test.cfg
@@ -0,0 +1,2 @@
+compile(cmpsi-2)
+run(cmpsi-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00023-g.torture.execute-20000112-1/20000112-1.c b/testsuite/c_test/x64_be_enable_test/GCC00023-g.torture.execute-20000112-1/20000112-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..080b6627cbeb5e1853abb07830a32a098e8e4c04
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00023-g.torture.execute-20000112-1/20000112-1.c
@@ -0,0 +1,21 @@
+#include <string.h>
+
+static int
+special_format (fmt)
+     const char *fmt;
+{
+  return (strchr (fmt, '*') != 0
+          || strchr (fmt, 'V') != 0
+          || strchr (fmt, 'S') != 0
+          || strchr (fmt, 'n') != 0);
+}
+
+main()
+{
+  if (special_format ("ee"))
+    abort ();
+  if (!special_format ("*e"))
+    abort ();
+  exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00023-g.torture.execute-20000112-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00023-g.torture.execute-20000112-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00023-g.torture.execute-20000112-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00023-g.torture.execute-20000112-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a9e508de2f030338b69749d4955e36b3d809e0c6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00023-g.torture.execute-20000112-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000112-1)
+run(20000112-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00024-g.torture.execute-20000205-1/20000205-1.c b/testsuite/c_test/x64_be_enable_test/GCC00024-g.torture.execute-20000205-1/20000205-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..b605b84b6b116f21c8001195e99eab90cd11d5f7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00024-g.torture.execute-20000205-1/20000205-1.c
@@ -0,0 +1,17 @@
+static int f (int a)
+{
+  if (a == 0)
+    return 0;
+  do
+    if (a & 128)
+      return 1;
+  while (f (0));
+  return 0;
+}
+
+int main(void)
+{
+  if (f (~128))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00024-g.torture.execute-20000205-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00024-g.torture.execute-20000205-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00024-g.torture.execute-20000205-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00024-g.torture.execute-20000205-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a8bd120a123a4c76e48449aa2c37aabee53ae469
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00024-g.torture.execute-20000205-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000205-1)
+run(20000205-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00025-g.torture.execute-20000224-1/20000224-1.c b/testsuite/c_test/x64_be_enable_test/GCC00025-g.torture.execute-20000224-1/20000224-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..295cc473b3e1bcbf2503dbde0f6a0958ea6d27d7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00025-g.torture.execute-20000224-1/20000224-1.c
@@ -0,0 +1,28 @@
+int loop_1 = 100;
+int loop_2 = 7;
+int flag = 0;
+
+int test (void)
+{
+    int i;
+    int counter  = 0;
+
+    while (loop_1 > counter) {
+        if (flag & 1) {
+            for (i = 0; i < loop_2; i++) {
+                counter++;
+            }
+        }
+        flag++;
+    }
+    return 1;
+}
+
+int main()
+{
+    if (test () != 1)
+      abort ();
+    
+    exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00025-g.torture.execute-20000224-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00025-g.torture.execute-20000224-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00025-g.torture.execute-20000224-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00025-g.torture.execute-20000224-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..26c7a199b01bf9a62d0eb2cf916de5774f41d2f6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00025-g.torture.execute-20000224-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000224-1)
+run(20000224-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00026-g.torture.execute-20000227-1/20000227-1.c b/testsuite/c_test/x64_be_enable_test/GCC00026-g.torture.execute-20000227-1/20000227-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8308a7438c74423b22748319d60c17be5a0fdb14
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00026-g.torture.execute-20000227-1/20000227-1.c
@@ -0,0 +1,14 @@
+static const unsigned char f[] = "\0\377";
+static const unsigned char g[] = "\0�";
+
+int main(void) {
+  if (sizeof f != 3 || sizeof g != 3)
+    abort();
+  if (f[0] != g[0])
+    abort();
+  if (f[1] != g[1])
+    abort();
+  if (f[2] != g[2])
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00026-g.torture.execute-20000227-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00026-g.torture.execute-20000227-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00026-g.torture.execute-20000227-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00026-g.torture.execute-20000227-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3f91b784719f853b517125700c9f8d667f778ba2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00026-g.torture.execute-20000227-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000227-1)
+run(20000227-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00027-g.torture.execute-20000313-1/20000313-1.c b/testsuite/c_test/x64_be_enable_test/GCC00027-g.torture.execute-20000313-1/20000313-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c9a5569bdc37aa3b17b07d49cddaabc1472b311
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00027-g.torture.execute-20000313-1/20000313-1.c
@@ -0,0 +1,20 @@
+unsigned int buggy (unsigned int *param)
+{
+  unsigned int accu, zero = 0, borrow;
+  accu    = - *param;
+  borrow  = - (accu > zero);
+  *param += accu;
+  return borrow;
+}
+
+int main (void)
+{
+  unsigned int param  = 1;
+  unsigned int borrow = buggy (&param);
+
+  if (param != 0)
+    abort ();
+  if (borrow + 1 != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00027-g.torture.execute-20000313-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00027-g.torture.execute-20000313-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00027-g.torture.execute-20000313-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00027-g.torture.execute-20000313-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0a7544f5d5a590976aace0d1a42188155281adea
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00027-g.torture.execute-20000313-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000313-1)
+run(20000313-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00028-g.torture.execute-20000314-2/20000314-2.c b/testsuite/c_test/x64_be_enable_test/GCC00028-g.torture.execute-20000314-2/20000314-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..c190d8f79b5e993378619cd7384d89a9d1dbcf72
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00028-g.torture.execute-20000314-2/20000314-2.c
@@ -0,0 +1,23 @@
+typedef unsigned long long uint64;
+const uint64 bigconst = 1ULL << 34;
+
+int a = 1;
+
+static
+uint64 getmask(void)
+{
+    if (a)
+      return bigconst;
+    else
+      return 0;
+}
+
+main()
+{
+    uint64 f = getmask();
+    if (sizeof (long long) == 8
+	&& f != bigconst) abort ();
+    exit (0);
+}
+
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00028-g.torture.execute-20000314-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00028-g.torture.execute-20000314-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00028-g.torture.execute-20000314-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00028-g.torture.execute-20000314-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..075557d989ea6b58860c2347ae330b1d442f70f2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00028-g.torture.execute-20000314-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20000314-2)
+run(20000314-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00029-g.torture.execute-20000314-3/20000314-3.c b/testsuite/c_test/x64_be_enable_test/GCC00029-g.torture.execute-20000314-3/20000314-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..a141bfa6a024d0837a391a908066cccb14938c29
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00029-g.torture.execute-20000314-3/20000314-3.c
@@ -0,0 +1,42 @@
+extern void abort (void);
+
+static char arg0[] = "arg0";
+static char arg1[] = "arg1";
+
+static void attr_rtx		(char *, char *);
+static char *attr_string        (char *);
+static void attr_eq		(char *, char *);
+
+static void 
+attr_rtx (char *varg0, char *varg1)
+{
+  if (varg0 != arg0)
+    abort ();
+
+  if (varg1 != arg1)
+    abort ();
+
+  return;
+}
+
+static void 
+attr_eq (name, value)
+     char *name, *value;
+{
+  return attr_rtx (attr_string (name),
+		   attr_string (value));
+}
+
+static char *
+attr_string (str)
+     char *str;
+{
+  return str;
+}
+
+int main()
+{
+  attr_eq (arg0, arg1);
+  exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00029-g.torture.execute-20000314-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00029-g.torture.execute-20000314-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00029-g.torture.execute-20000314-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00029-g.torture.execute-20000314-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9efb5cf0c6667ace45351ce3e306d04d0bca8ebd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00029-g.torture.execute-20000314-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20000314-3)
+run(20000314-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00030-g.torture.execute-20000412-2/20000412-2.c b/testsuite/c_test/x64_be_enable_test/GCC00030-g.torture.execute-20000412-2/20000412-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..de3ebf9e8638683d0f13e3eef6b7d127c177ce5a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00030-g.torture.execute-20000412-2/20000412-2.c
@@ -0,0 +1,16 @@
+int f(int a,int *y)
+{
+  int x = a;
+
+  if (a==0)
+    return *y;
+
+  return f(a-1,&x);
+}
+
+int main(int argc,char **argv)
+{
+  if (f (100, (int *) 0) != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00030-g.torture.execute-20000412-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00030-g.torture.execute-20000412-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00030-g.torture.execute-20000412-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00030-g.torture.execute-20000412-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dcc29026af3654073c771878a7bad218a60e10b3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00030-g.torture.execute-20000412-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20000412-2)
+run(20000412-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00031-g.torture.execute-20000419-1/20000419-1.c b/testsuite/c_test/x64_be_enable_test/GCC00031-g.torture.execute-20000419-1/20000419-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6127d8b13b0738a58528e5448019846c36089058
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00031-g.torture.execute-20000419-1/20000419-1.c
@@ -0,0 +1,22 @@
+struct foo { int a, b, c; };
+
+void
+brother (int a, int b, int c)
+{
+  if (a)
+    abort ();
+}
+
+void
+sister (struct foo f, int b, int c)
+{
+  brother ((f.b == b), b, c);
+}
+
+int
+main ()
+{
+  struct foo f = { 7, 8, 9 };
+  sister (f, 1, 2);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00031-g.torture.execute-20000419-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00031-g.torture.execute-20000419-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00031-g.torture.execute-20000419-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00031-g.torture.execute-20000419-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..37522f8eb621866d1365897dc99aa4ad0d79edff
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00031-g.torture.execute-20000419-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000419-1)
+run(20000419-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00032-g.torture.execute-20000422-1/20000422-1.c b/testsuite/c_test/x64_be_enable_test/GCC00032-g.torture.execute-20000422-1/20000422-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f94d4c5efc21ae903d62e6d505bb5ddd2abdb93e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00032-g.torture.execute-20000422-1/20000422-1.c
@@ -0,0 +1,39 @@
+int ops[13] =
+{
+  11, 12, 46, 3, 2, 2, 3, 2, 1, 3, 2, 1, 2
+};
+
+int correct[13] = 
+{
+  46, 12, 11, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1
+};
+
+int num = 13;
+
+int main()
+{
+  int i;
+
+  for (i = 0; i < num; i++)
+    {
+      int j;
+
+      for (j = num - 1; j > i; j--)
+        {
+          if (ops[j-1] < ops[j])
+            {
+              int op = ops[j];
+              ops[j] = ops[j-1];
+              ops[j-1] = op;
+            }
+        }
+    }
+
+
+  for (i = 0; i < num; i++)
+    if (ops[i] != correct[i])
+      abort ();
+
+  exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00032-g.torture.execute-20000422-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00032-g.torture.execute-20000422-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00032-g.torture.execute-20000422-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00032-g.torture.execute-20000422-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65eb82fa5963e8126d3768d45679e5feb67129c9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00032-g.torture.execute-20000422-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000422-1)
+run(20000422-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00033-g.torture.execute-20000503-1/20000503-1.c b/testsuite/c_test/x64_be_enable_test/GCC00033-g.torture.execute-20000503-1/20000503-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..bbf32623f439752dd72ebca6f80d7db0d85ec10c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00033-g.torture.execute-20000503-1/20000503-1.c
@@ -0,0 +1,13 @@
+unsigned long
+sub (int a)
+{
+  return ((0 > a - 2) ? 0 : a - 2) * sizeof (long);
+}
+
+main ()
+{
+  if (sub (0) != 0)
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00033-g.torture.execute-20000503-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00033-g.torture.execute-20000503-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00033-g.torture.execute-20000503-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00033-g.torture.execute-20000503-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b525cc4c776cfea6ded1f451ffbe9bb82a464fbc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00033-g.torture.execute-20000503-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000503-1)
+run(20000503-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00034-g.torture.execute-20000519-2/20000519-2.c b/testsuite/c_test/x64_be_enable_test/GCC00034-g.torture.execute-20000519-2/20000519-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..9635e324240f870c710701dda1f562e37c9cf932
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00034-g.torture.execute-20000519-2/20000519-2.c
@@ -0,0 +1,12 @@
+long x = -1L;
+
+int main()
+{
+  long b = (x != -1L);
+
+  if (b)
+    abort();
+
+  exit(0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00034-g.torture.execute-20000519-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00034-g.torture.execute-20000519-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00034-g.torture.execute-20000519-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00034-g.torture.execute-20000519-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6c2c81bfa7381fddb27497f4d12bda0731297729
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00034-g.torture.execute-20000519-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20000519-2)
+run(20000519-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00035-g.torture.execute-20000605-3/20000605-3.c b/testsuite/c_test/x64_be_enable_test/GCC00035-g.torture.execute-20000605-3/20000605-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..7ebb27fdb780f8e0c8a2ff9f4e52ccc7d50d8510
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00035-g.torture.execute-20000605-3/20000605-3.c
@@ -0,0 +1,18 @@
+struct F { int x; int y; };
+
+int main()
+{
+  int timeout = 0;
+  int x = 0;
+  while (1)
+    {
+      const struct F i = { x++, };
+      if (i.x > 0)
+	break;
+      if (++timeout > 5)
+	goto die;
+    }
+  return 0;
+ die:
+  abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00035-g.torture.execute-20000605-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00035-g.torture.execute-20000605-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00035-g.torture.execute-20000605-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00035-g.torture.execute-20000605-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2e93c2d1798258ad821a5bdf70f11f3c424fc7af
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00035-g.torture.execute-20000605-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20000605-3)
+run(20000605-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00036-g.torture.execute-20000622-1/20000622-1.c b/testsuite/c_test/x64_be_enable_test/GCC00036-g.torture.execute-20000622-1/20000622-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d853ea840865ca3ef558be2a2304276719f83333
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00036-g.torture.execute-20000622-1/20000622-1.c
@@ -0,0 +1,21 @@
+long foo(long a, long b, long c)
+{
+  if (a != 12 || b != 1 || c != 11)
+    abort();
+  return 0;
+}
+long bar (long a, long b)
+{
+  return b;
+}
+void baz (long a, long b, void *c)
+{
+  long d;
+  d = (long)c;
+  foo(d, bar (a, 1), b);
+}
+int main()
+{
+  baz (10, 11, (void *)12);
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00036-g.torture.execute-20000622-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00036-g.torture.execute-20000622-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00036-g.torture.execute-20000622-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00036-g.torture.execute-20000622-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..92ba248031617870ef6373fc416e2a53e40b5db7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00036-g.torture.execute-20000622-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000622-1)
+run(20000622-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00037-g.torture.execute-20000706-3/20000706-3.c b/testsuite/c_test/x64_be_enable_test/GCC00037-g.torture.execute-20000706-3/20000706-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..b5758d9abb01ffc77572d042477a85ec6227864b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00037-g.torture.execute-20000706-3/20000706-3.c
@@ -0,0 +1,27 @@
+extern void abort(void);
+extern void exit(int);
+
+int c;
+
+void baz(int *p)
+{
+  c = *p;
+}
+
+void bar(int b)
+{
+  if (c != 1 || b != 2)
+    abort();
+}
+
+void foo(int a, int b)
+{
+  baz(&a);
+  bar(b);
+}
+
+int main()
+{
+  foo(1, 2);
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00037-g.torture.execute-20000706-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00037-g.torture.execute-20000706-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00037-g.torture.execute-20000706-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00037-g.torture.execute-20000706-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5e101c8d94fc6e7ac45171f715b0a693265faa3d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00037-g.torture.execute-20000706-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20000706-3)
+run(20000706-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00038-g.torture.execute-20000706-4/20000706-4.c b/testsuite/c_test/x64_be_enable_test/GCC00038-g.torture.execute-20000706-4/20000706-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..01cc879c34a6606bd632b2a0d35da2fe7fb28aa0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00038-g.torture.execute-20000706-4/20000706-4.c
@@ -0,0 +1,22 @@
+extern void abort(void);
+extern void exit(int);
+
+int *c;
+
+void bar(int b)
+{
+  if (*c != 1 || b != 2)
+    abort();
+}
+
+void foo(int a, int b)
+{
+  c = &a;
+  bar(b);
+}
+
+int main()
+{
+  foo(1, 2);
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00038-g.torture.execute-20000706-4/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00038-g.torture.execute-20000706-4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00038-g.torture.execute-20000706-4/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00038-g.torture.execute-20000706-4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..55aaedbb8ff18c2a3ba538435f8f4714930988a0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00038-g.torture.execute-20000706-4/test.cfg
@@ -0,0 +1,2 @@
+compile(20000706-4)
+run(20000706-4)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00039-g.torture.execute-20000706-5/20000706-5.c b/testsuite/c_test/x64_be_enable_test/GCC00039-g.torture.execute-20000706-5/20000706-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..18756f29ddc3e66382bb41fb400d5a90fff99356
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00039-g.torture.execute-20000706-5/20000706-5.c
@@ -0,0 +1,28 @@
+extern void abort(void);
+extern void exit(int);
+
+struct baz { int a, b, c; };
+
+struct baz *c;
+
+void bar(int b)
+{
+  if (c->a != 1 || c->b != 2 || c->c != 3 || b != 4)
+    abort();
+}
+
+void foo(struct baz a, int b)
+{
+  c = &a;
+  bar(b);
+}
+
+int main()
+{
+  struct baz a;
+  a.a = 1;
+  a.b = 2;
+  a.c = 3;
+  foo(a, 4);
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00039-g.torture.execute-20000706-5/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00039-g.torture.execute-20000706-5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00039-g.torture.execute-20000706-5/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00039-g.torture.execute-20000706-5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..07e44f0730e0c2883aea63078abb8d728778af7f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00039-g.torture.execute-20000706-5/test.cfg
@@ -0,0 +1,2 @@
+compile(20000706-5)
+run(20000706-5)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00040-g.torture.execute-20000707-1/20000707-1.c b/testsuite/c_test/x64_be_enable_test/GCC00040-g.torture.execute-20000707-1/20000707-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f1c50a923600ce596add7c7964761daa8b27184f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00040-g.torture.execute-20000707-1/20000707-1.c
@@ -0,0 +1,27 @@
+extern void abort(void);
+extern void exit(int);
+
+struct baz {
+  int a, b, c;
+};
+
+void
+foo (int a, int b, int c)
+{
+  if (a != 4)
+    abort ();
+}
+
+void
+bar (struct baz x, int b, int c)
+{
+  foo (x.b, b, c);
+}
+
+int
+main ()
+{
+  struct baz x = { 3, 4, 5 };
+  bar (x, 1, 2);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00040-g.torture.execute-20000707-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00040-g.torture.execute-20000707-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00040-g.torture.execute-20000707-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00040-g.torture.execute-20000707-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e13fbfbfdb9f5deea0f701ac42761996dbc2655b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00040-g.torture.execute-20000707-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000707-1)
+run(20000707-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00041-g.torture.execute-20000715-1/20000715-1.c b/testsuite/c_test/x64_be_enable_test/GCC00041-g.torture.execute-20000715-1/20000715-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..43af11480b41cd369919382315e2d4a4f4cd754f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00041-g.torture.execute-20000715-1/20000715-1.c
@@ -0,0 +1,118 @@
+void abort(void);
+void exit(int);
+
+void
+test1(void)
+{
+  int x = 3, y = 2;
+
+  if ((x < y ? x++ : y++) != 2)
+    abort ();
+
+  if (x != 3)
+    abort ();
+
+  if (y != 3)
+    abort ();
+}
+
+void
+test2(void)
+{
+  int x = 3, y = 2, z;
+
+  z = (x < y) ? x++ : y++;
+  if (z != 2)
+    abort ();
+
+  if (x != 3)
+    abort ();
+
+  if (y != 3)
+    abort ();
+}
+
+void
+test3(void)
+{
+  int x = 3, y = 2;
+  int xx = 3, yy = 2;
+
+  if ((xx < yy ? x++ : y++) != 2)
+    abort ();
+
+  if (x != 3)
+    abort ();
+
+  if (y != 3)
+    abort ();
+}
+
+int x, y;
+
+static void
+init_xy(void)
+{
+  x = 3;
+  y = 2;
+}
+
+void
+test4(void)
+{
+  init_xy();
+  if ((x < y ? x++ : y++) != 2)
+    abort ();
+
+  if (x != 3)
+    abort ();
+
+  if (y != 3)
+    abort ();
+}
+
+void
+test5(void)
+{
+  int z;
+
+  init_xy();
+  z = (x < y) ? x++ : y++;
+  if (z != 2)
+    abort ();
+
+  if (x != 3)
+    abort ();
+
+  if (y != 3)
+    abort ();
+}
+
+void
+test6(void)
+{
+  int xx = 3, yy = 2;
+  int z;
+
+  init_xy();
+  z = (xx < y) ? x++ : y++;
+  if (z != 2)
+    abort ();
+
+  if (x != 3)
+    abort ();
+
+  if (y != 3)
+    abort ();
+}
+
+int
+main(){
+  test1 ();
+  test2 ();
+  test3 ();
+  test4 ();
+  test5 ();
+  test6 ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00041-g.torture.execute-20000715-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00041-g.torture.execute-20000715-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00041-g.torture.execute-20000715-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00041-g.torture.execute-20000715-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cb3e0bb6c5cd4e19113f072ca8026275a8099013
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00041-g.torture.execute-20000715-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000715-1)
+run(20000715-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00042-g.torture.execute-20000715-2/20000715-2.c b/testsuite/c_test/x64_be_enable_test/GCC00042-g.torture.execute-20000715-2/20000715-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..03836bd3ad457d47044020fa1afb7e2a2e9fc761
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00042-g.torture.execute-20000715-2/20000715-2.c
@@ -0,0 +1,12 @@
+extern void abort(void);
+extern void exit(int);
+
+unsigned int foo(unsigned int a) {
+  return ((unsigned char)(a + 1)) * 4;
+}
+
+int main(void) {
+  if (foo((unsigned char)~0))
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00042-g.torture.execute-20000715-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00042-g.torture.execute-20000715-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00042-g.torture.execute-20000715-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00042-g.torture.execute-20000715-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c37f83447f112bfd8a8744ec545b5f18379bb575
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00042-g.torture.execute-20000715-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20000715-2)
+run(20000715-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00043-g.torture.execute-20000717-1/20000717-1.c b/testsuite/c_test/x64_be_enable_test/GCC00043-g.torture.execute-20000717-1/20000717-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..039ae5f342dd6692d978f8504015f3ed5163fbb5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00043-g.torture.execute-20000717-1/20000717-1.c
@@ -0,0 +1,22 @@
+typedef struct trio { int a, b, c; } trio;
+
+int
+bar (int i, trio t)
+{
+  if (t.a == t.b || t.a == t.c)
+    abort ();
+}
+
+int
+foo (trio t, int i)
+{
+  return bar (i, t);
+}
+
+main ()
+{
+  trio t = { 1, 2, 3 };
+
+  foo (t, 4);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00043-g.torture.execute-20000717-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00043-g.torture.execute-20000717-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00043-g.torture.execute-20000717-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00043-g.torture.execute-20000717-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..705246bda49fd596ca3c1e8089802ee89727460e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00043-g.torture.execute-20000717-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000717-1)
+run(20000717-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00044-g.torture.execute-20000717-3/20000717-3.c b/testsuite/c_test/x64_be_enable_test/GCC00044-g.torture.execute-20000717-3/20000717-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..e87d00b00185ff7c7f704871297c22dff114a2ae
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00044-g.torture.execute-20000717-3/20000717-3.c
@@ -0,0 +1,26 @@
+int c = -1;
+
+foo (p)
+     int *p;
+{
+  int x;
+  int a;
+
+  a = p[0];
+  x = a + 5;
+  a = c;
+  p[0] = x - 15;
+  return a;
+}
+
+int main()
+{
+   int b = 1;
+   int a = foo(&b);
+
+   if (a != -1 || b != (1 + 5 - 15))
+     abort ();
+
+   exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00044-g.torture.execute-20000717-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00044-g.torture.execute-20000717-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00044-g.torture.execute-20000717-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00044-g.torture.execute-20000717-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cfab266f513d9cf5bebe6c8e5fd5f6e8eaf1d9a5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00044-g.torture.execute-20000717-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20000717-3)
+run(20000717-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00045-g.torture.execute-20000717-4/20000717-4.c b/testsuite/c_test/x64_be_enable_test/GCC00045-g.torture.execute-20000717-4/20000717-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..c3d27bbac237aa0220e6cbddb275ce4d84e58400
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00045-g.torture.execute-20000717-4/20000717-4.c
@@ -0,0 +1,26 @@
+/* Extracted from gas.  Incorrectly generated non-pic code at -O0 for
+   IA-64, which produces linker errors on some operating systems.  */
+
+struct
+{
+  int offset;
+  struct slot
+  {
+    int field[6];
+  }
+  slot[4];
+} s;
+
+int
+x ()
+{
+  int toggle = 0;
+  int r = s.slot[0].field[!toggle];
+  return r;
+}
+
+int
+main ()
+{
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00045-g.torture.execute-20000717-4/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00045-g.torture.execute-20000717-4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00045-g.torture.execute-20000717-4/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00045-g.torture.execute-20000717-4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e32ce339b76636c5fff18cb8df4d9d97ba65e388
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00045-g.torture.execute-20000717-4/test.cfg
@@ -0,0 +1,2 @@
+compile(20000717-4)
+run(20000717-4)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00046-g.torture.execute-20000717-5/20000717-5.c b/testsuite/c_test/x64_be_enable_test/GCC00046-g.torture.execute-20000717-5/20000717-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..49dcbbc66f1760bfa73ab1dc03110417ee574b53
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00046-g.torture.execute-20000717-5/20000717-5.c
@@ -0,0 +1,23 @@
+typedef struct trio { int a, b, c; } trio;
+
+int
+bar (int i, int j, int k, trio t)
+{
+  if (t.a != 1 || t.b != 2 || t.c != 3 ||
+      i != 4 || j != 5 || k != 6)
+    abort ();
+}
+
+int
+foo (trio t, int i, int j, int k)
+{
+  return bar (i, j, k, t);
+}
+
+main ()
+{
+  trio t = { 1, 2, 3 };
+
+  foo (t, 4, 5, 6);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00046-g.torture.execute-20000717-5/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00046-g.torture.execute-20000717-5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00046-g.torture.execute-20000717-5/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00046-g.torture.execute-20000717-5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a9357db785a1ef1427c95aa22f18910e24423e85
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00046-g.torture.execute-20000717-5/test.cfg
@@ -0,0 +1,2 @@
+compile(20000717-5)
+run(20000717-5)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00047-g.torture.execute-20000801-1/20000801-1.c b/testsuite/c_test/x64_be_enable_test/GCC00047-g.torture.execute-20000801-1/20000801-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1bc386ea2528b2387c757eaa47700e95f4d18c96
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00047-g.torture.execute-20000801-1/20000801-1.c
@@ -0,0 +1,39 @@
+extern void abort(void);
+extern void exit(int);
+
+void
+foo (char *bp, unsigned n)
+{
+  register char c;
+  register char *ep = bp + n;
+  register char *sp;
+
+  while (bp < ep)
+    {
+      sp = bp + 3;
+      c = *sp;
+      *sp = *bp;
+      *bp++ = c;
+      sp = bp + 1;
+      c = *sp;
+      *sp = *bp;
+      *bp++ = c;
+      bp += 2;
+    }
+}
+
+int main(void)
+{
+  int one = 1;
+
+  if (sizeof(int) != 4 * sizeof(char))
+    exit(0);
+
+  foo((char *)&one, sizeof(one));
+  foo((char *)&one, sizeof(one));
+
+  if (one != 1)
+    abort();
+
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00047-g.torture.execute-20000801-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00047-g.torture.execute-20000801-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00047-g.torture.execute-20000801-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00047-g.torture.execute-20000801-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8ac4f8b37064d19de46a6f425a9a1ee74e0e4fdc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00047-g.torture.execute-20000801-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000801-1)
+run(20000801-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00048-g.torture.execute-20000801-3/20000801-3.c b/testsuite/c_test/x64_be_enable_test/GCC00048-g.torture.execute-20000801-3/20000801-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..8d47a8155fe7593e271f7227719dc9dc55a60494
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00048-g.torture.execute-20000801-3/20000801-3.c
@@ -0,0 +1,24 @@
+/* Origin: PR c/92 from Simon Marlow <t-simonm@microsoft.com>, adapted
+   to a testcase by Joseph Myers <jsm28@cam.ac.uk>.
+*/
+
+typedef struct { } empty;
+
+typedef struct {
+  int i;
+  empty e;
+  int i2;
+} st;
+
+st s = { .i = 0, .i2 = 1 };
+
+extern void abort (void);
+
+int
+main (void)
+{
+  if (s.i2 == 1)
+    exit (0);
+  else
+    abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00048-g.torture.execute-20000801-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00048-g.torture.execute-20000801-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00048-g.torture.execute-20000801-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00048-g.torture.execute-20000801-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e2fad390bd2c4f93a0df0beac668969e4651a33
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00048-g.torture.execute-20000801-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20000801-3)
+run(20000801-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00049-g.torture.execute-20000808-1/20000808-1.c b/testsuite/c_test/x64_be_enable_test/GCC00049-g.torture.execute-20000808-1/20000808-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a905aad96dbe380a18c2089764908214e05c035e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00049-g.torture.execute-20000808-1/20000808-1.c
@@ -0,0 +1,56 @@
+typedef struct {
+  long int p_x, p_y;
+} Point;
+
+void
+bar ()
+{
+}
+
+void
+f (p0, p1, p2, p3, p4, p5)
+     Point p0, p1, p2, p3, p4, p5;
+{
+  if (p0.p_x != 0 || p0.p_y != 1
+      || p1.p_x != -1 || p1.p_y != 0
+      || p2.p_x != 1 || p2.p_y != -1
+      || p3.p_x != -1 || p3.p_y != 1
+      || p4.p_x != 0 || p4.p_y != -1
+      || p5.p_x != 1 || p5.p_y != 0)
+    abort ();
+}
+
+void
+foo ()
+{
+  Point p0, p1, p2, p3, p4, p5;
+
+  bar();
+  
+  p0.p_x = 0;
+  p0.p_y = 1;
+
+  p1.p_x = -1;
+  p1.p_y = 0;
+
+  p2.p_x = 1;
+  p2.p_y = -1;
+
+  p3.p_x = -1;
+  p3.p_y = 1;
+
+  p4.p_x = 0;
+  p4.p_y = -1;
+
+  p5.p_x = 1;
+  p5.p_y = 0;
+
+  f (p0, p1, p2, p3, p4, p5);
+}
+
+int
+main()
+{
+  foo();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00049-g.torture.execute-20000808-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00049-g.torture.execute-20000808-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00049-g.torture.execute-20000808-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00049-g.torture.execute-20000808-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9805fcb65373543674843d5a968dc97901306d15
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00049-g.torture.execute-20000808-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000808-1)
+run(20000808-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00050-g.torture.execute-20000819-1/20000819-1.c b/testsuite/c_test/x64_be_enable_test/GCC00050-g.torture.execute-20000819-1/20000819-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e1c2769c08d481dc481b6362d8938d9b4c93efa3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00050-g.torture.execute-20000819-1/20000819-1.c
@@ -0,0 +1,17 @@
+int a[2] = { 2, 0 };
+
+void foo(int *sp, int cnt)
+{
+  int *p, *top;
+
+  top = sp; sp -= cnt;
+
+  for(p = sp; p <= top; p++)
+    if (*p < 2) exit(0);
+}
+
+int main()
+{
+  foo(a + 1, 1);
+  abort();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00050-g.torture.execute-20000819-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00050-g.torture.execute-20000819-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00050-g.torture.execute-20000819-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00050-g.torture.execute-20000819-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..164a2b0a14ca5f4028a0d5f21cd9968c4212c7e5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00050-g.torture.execute-20000819-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000819-1)
+run(20000819-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00051-g.torture.execute-20000910-1/20000910-1.c b/testsuite/c_test/x64_be_enable_test/GCC00051-g.torture.execute-20000910-1/20000910-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..487b7b85593a71dcca080f6ccfc6fac4c4ef0b58
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00051-g.torture.execute-20000910-1/20000910-1.c
@@ -0,0 +1,31 @@
+/* Copyright (C) 2000  Free Software Foundation  */
+/* by Alexandre Oliva <aoliva@redhat.com> */
+
+#include <stdlib.h>
+
+void bar(int);
+void foo(int *);
+
+int main() {
+  static int a[] = { 0, 1, 2 };
+  int *i = &a[sizeof(a) / sizeof(*a)];
+
+  while (i-- > a)
+    foo(i);
+
+  exit(0);
+}
+
+void baz(int, int);
+
+void bar(int i) {
+  baz(i, i);
+}
+void foo(int *i) {
+  bar(*i);
+}
+
+void baz(int i, int j) {
+  if (i != j)
+    abort();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00051-g.torture.execute-20000910-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00051-g.torture.execute-20000910-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00051-g.torture.execute-20000910-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00051-g.torture.execute-20000910-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..782de8cf2c17b70b5bf6f9bbce7c99904c6b5d93
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00051-g.torture.execute-20000910-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000910-1)
+run(20000910-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00052-g.torture.execute-20000910-2/20000910-2.c b/testsuite/c_test/x64_be_enable_test/GCC00052-g.torture.execute-20000910-2/20000910-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..0023d2451e0b6976278f13ffd86a66715f02e116
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00052-g.torture.execute-20000910-2/20000910-2.c
@@ -0,0 +1,28 @@
+/* Copyright (C) 2000  Free Software Foundation  */
+/* by Alexandre Oliva <aoliva@redhat.com> */
+
+#include <stdlib.h>
+#include <string.h>
+
+char *list[] = { "*", "e" };
+
+static int bar (const char *fmt) {
+  return (strchr (fmt, '*') != 0);
+}
+
+static void foo () {
+  int i;
+  for (i = 0; i < sizeof (list) / sizeof (*list); i++) {
+    const char *fmt = list[i];
+    if (bar (fmt))
+      continue;
+    if (i == 0)
+      abort ();
+    else
+      exit (0);
+  }
+}
+
+int main () {
+  foo ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00052-g.torture.execute-20000910-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00052-g.torture.execute-20000910-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00052-g.torture.execute-20000910-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00052-g.torture.execute-20000910-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6036d45fb3ccbac6d519deeb2c1dd07737259d67
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00052-g.torture.execute-20000910-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20000910-2)
+run(20000910-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00053-g.torture.execute-20000914-1/20000914-1.c b/testsuite/c_test/x64_be_enable_test/GCC00053-g.torture.execute-20000914-1/20000914-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1e8bb0ce73cc5d2835b35802fe17044f29d31801
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00053-g.torture.execute-20000914-1/20000914-1.c
@@ -0,0 +1,292 @@
+extern void *malloc(__SIZE_TYPE__);
+
+enum tree_code {
+ERROR_MARK,
+IDENTIFIER_NODE,
+OP_IDENTIFIER,
+TREE_LIST,
+TREE_VEC,
+BLOCK,
+VOID_TYPE,
+INTEGER_TYPE,
+REAL_TYPE,
+COMPLEX_TYPE,
+VECTOR_TYPE,
+ENUMERAL_TYPE,
+BOOLEAN_TYPE,
+CHAR_TYPE,
+POINTER_TYPE,
+OFFSET_TYPE,
+REFERENCE_TYPE,
+METHOD_TYPE,
+FILE_TYPE,
+ARRAY_TYPE,
+SET_TYPE,
+RECORD_TYPE,
+UNION_TYPE,
+QUAL_UNION_TYPE,
+FUNCTION_TYPE,
+LANG_TYPE,
+INTEGER_CST,
+REAL_CST,
+COMPLEX_CST,
+STRING_CST,
+FUNCTION_DECL,
+LABEL_DECL,
+CONST_DECL,
+TYPE_DECL,
+VAR_DECL,
+PARM_DECL,
+RESULT_DECL,
+FIELD_DECL,
+NAMESPACE_DECL,
+COMPONENT_REF,
+BIT_FIELD_REF,
+INDIRECT_REF,
+BUFFER_REF,
+ARRAY_REF,
+CONSTRUCTOR,
+COMPOUND_EXPR,
+MODIFY_EXPR,
+INIT_EXPR,
+TARGET_EXPR,
+COND_EXPR,
+BIND_EXPR,
+CALL_EXPR,
+METHOD_CALL_EXPR,
+WITH_CLEANUP_EXPR,
+CLEANUP_POINT_EXPR,
+PLACEHOLDER_EXPR,
+WITH_RECORD_EXPR,
+PLUS_EXPR,
+MINUS_EXPR,
+MULT_EXPR,
+TRUNC_DIV_EXPR,
+CEIL_DIV_EXPR,
+FLOOR_DIV_EXPR,
+ROUND_DIV_EXPR,
+TRUNC_MOD_EXPR,
+CEIL_MOD_EXPR,
+FLOOR_MOD_EXPR,
+ROUND_MOD_EXPR,
+RDIV_EXPR,
+EXACT_DIV_EXPR,
+FIX_TRUNC_EXPR,
+FIX_CEIL_EXPR,
+FIX_FLOOR_EXPR,
+FIX_ROUND_EXPR,
+FLOAT_EXPR,
+EXPON_EXPR,
+NEGATE_EXPR,
+MIN_EXPR,
+MAX_EXPR,
+ABS_EXPR,
+FFS_EXPR,
+LSHIFT_EXPR,
+RSHIFT_EXPR,
+LROTATE_EXPR,
+RROTATE_EXPR,
+BIT_IOR_EXPR,
+BIT_XOR_EXPR,
+BIT_AND_EXPR,
+BIT_ANDTC_EXPR,
+BIT_NOT_EXPR,
+TRUTH_ANDIF_EXPR,
+TRUTH_ORIF_EXPR,
+TRUTH_AND_EXPR,
+TRUTH_OR_EXPR,
+TRUTH_XOR_EXPR,
+TRUTH_NOT_EXPR,
+LT_EXPR,
+LE_EXPR,
+GT_EXPR,
+GE_EXPR,
+EQ_EXPR,
+NE_EXPR,
+UNORDERED_EXPR,
+ORDERED_EXPR,
+UNLT_EXPR,
+UNLE_EXPR,
+UNGT_EXPR,
+UNGE_EXPR,
+UNEQ_EXPR,
+IN_EXPR,
+SET_LE_EXPR,
+CARD_EXPR,
+RANGE_EXPR,
+CONVERT_EXPR,
+NOP_EXPR,
+NON_LVALUE_EXPR,
+SAVE_EXPR,
+UNSAVE_EXPR,
+RTL_EXPR,
+ADDR_EXPR,
+REFERENCE_EXPR,
+ENTRY_VALUE_EXPR,
+COMPLEX_EXPR,
+CONJ_EXPR,
+REALPART_EXPR,
+IMAGPART_EXPR,
+PREDECREMENT_EXPR,
+PREINCREMENT_EXPR,
+POSTDECREMENT_EXPR,
+POSTINCREMENT_EXPR,
+VA_ARG_EXPR,
+TRY_CATCH_EXPR,
+TRY_FINALLY_EXPR,
+GOTO_SUBROUTINE_EXPR,
+POPDHC_EXPR,
+POPDCC_EXPR,
+LABEL_EXPR,
+GOTO_EXPR,
+RETURN_EXPR,
+EXIT_EXPR,
+LOOP_EXPR,
+LABELED_BLOCK_EXPR,
+EXIT_BLOCK_EXPR,
+EXPR_WITH_FILE_LOCATION,
+SWITCH_EXPR,
+  LAST_AND_UNUSED_TREE_CODE
+};
+typedef union tree_node *tree;
+struct tree_common
+{
+  union tree_node *chain;
+  union tree_node *type;
+  enum tree_code code : 8;
+  unsigned side_effects_flag : 1;
+  unsigned constant_flag : 1;
+  unsigned permanent_flag : 1;
+  unsigned addressable_flag : 1;
+  unsigned volatile_flag : 1;
+  unsigned readonly_flag : 1;
+  unsigned unsigned_flag : 1;
+  unsigned asm_written_flag: 1;
+  unsigned used_flag : 1;
+  unsigned nothrow_flag : 1;
+  unsigned static_flag : 1;
+  unsigned public_flag : 1;
+  unsigned private_flag : 1;
+  unsigned protected_flag : 1;
+  unsigned bounded_flag : 1;
+  unsigned lang_flag_0 : 1;
+  unsigned lang_flag_1 : 1;
+  unsigned lang_flag_2 : 1;
+  unsigned lang_flag_3 : 1;
+  unsigned lang_flag_4 : 1;
+  unsigned lang_flag_5 : 1;
+  unsigned lang_flag_6 : 1;
+};
+union tree_node
+{
+  struct tree_common common;
+ };
+enum c_tree_code {
+  C_DUMMY_TREE_CODE = LAST_AND_UNUSED_TREE_CODE,
+SRCLOC,
+SIZEOF_EXPR,
+ARROW_EXPR,
+ALIGNOF_EXPR,
+EXPR_STMT,
+COMPOUND_STMT,
+DECL_STMT,
+IF_STMT,
+FOR_STMT,
+WHILE_STMT,
+DO_STMT,
+RETURN_STMT,
+BREAK_STMT,
+CONTINUE_STMT,
+SWITCH_STMT,
+GOTO_STMT,
+LABEL_STMT,
+ASM_STMT,
+SCOPE_STMT,
+CASE_LABEL,
+STMT_EXPR,
+  LAST_C_TREE_CODE
+};
+enum cplus_tree_code {
+  CP_DUMMY_TREE_CODE = LAST_C_TREE_CODE,
+OFFSET_REF,
+PTRMEM_CST,
+NEW_EXPR,
+VEC_NEW_EXPR,
+DELETE_EXPR,
+VEC_DELETE_EXPR,
+SCOPE_REF,
+MEMBER_REF,
+TYPE_EXPR,
+AGGR_INIT_EXPR,
+THROW_EXPR,
+EMPTY_CLASS_EXPR,
+TEMPLATE_DECL,
+TEMPLATE_PARM_INDEX,
+TEMPLATE_TYPE_PARM,
+TEMPLATE_TEMPLATE_PARM,
+BOUND_TEMPLATE_TEMPLATE_PARM,
+TYPENAME_TYPE,
+TYPEOF_TYPE,
+USING_DECL,
+DEFAULT_ARG,
+TEMPLATE_ID_EXPR,
+CPLUS_BINDING,
+OVERLOAD,
+WRAPPER,
+LOOKUP_EXPR,
+FUNCTION_NAME,
+MODOP_EXPR,
+CAST_EXPR,
+REINTERPRET_CAST_EXPR,
+CONST_CAST_EXPR,
+STATIC_CAST_EXPR,
+DYNAMIC_CAST_EXPR,
+DOTSTAR_EXPR,
+TYPEID_EXPR,
+PSEUDO_DTOR_EXPR,
+SUBOBJECT,
+CTOR_STMT,
+CLEANUP_STMT,
+START_CATCH_STMT,
+CTOR_INITIALIZER,
+RETURN_INIT,
+TRY_BLOCK,
+HANDLER,
+TAG_DEFN,
+IDENTITY_CONV,
+LVALUE_CONV,
+QUAL_CONV,
+STD_CONV,
+PTR_CONV,
+PMEM_CONV,
+BASE_CONV,
+REF_BIND,
+USER_CONV,
+AMBIG_CONV,
+RVALUE_CONV,
+  LAST_CPLUS_TREE_CODE
+};
+
+blah(){}
+
+convert_like_real (convs)
+     tree convs;
+{
+  switch (((enum tree_code) (convs)->common.code))
+    {
+    case AMBIG_CONV:
+      return blah();
+    default:
+      break;
+    };
+   abort ();
+}
+
+main()
+{
+  tree convs = (void *)malloc (sizeof (struct tree_common));;
+
+  convs->common.code = AMBIG_CONV;
+  convert_like_real (convs);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00053-g.torture.execute-20000914-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00053-g.torture.execute-20000914-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00053-g.torture.execute-20000914-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00053-g.torture.execute-20000914-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..939c2793160adff848f96db97efad815c14d078b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00053-g.torture.execute-20000914-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000914-1)
+run(20000914-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00054-g.torture.execute-20000917-1/20000917-1.c b/testsuite/c_test/x64_be_enable_test/GCC00054-g.torture.execute-20000917-1/20000917-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..05b00ffe699b37066896b96b9470635b2b17dd73
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00054-g.torture.execute-20000917-1/20000917-1.c
@@ -0,0 +1,42 @@
+/* This bug exists in gcc-2.95, egcs-1.1.2, gcc-2.7.2 and probably
+   every other version as well.  */
+
+typedef struct int3 { int a, b, c; } int3;
+
+int3
+one (void)
+{
+  return (int3) { 1, 1, 1 };
+}
+
+int3
+zero (void)
+{
+  return (int3) { 0, 0, 0 };
+}
+
+int
+main (void)
+{
+  int3 a;
+
+  /* gcc allocates a temporary for the inner expression statement
+     to store the return value of `one'.
+
+     gcc frees the temporaries for the inner expression statement.
+
+     gcc realloates the same temporary slot to store the return
+     value of `zero'.
+
+     gcc expands the call to zero ahead of the expansion of the
+     statement expressions.  The temporary gets the value of `zero'.
+
+     gcc expands statement expressions and the stale temporary is
+     clobbered with the value of `one'.  The bad value is copied from
+     the temporary into *&a.  */
+
+  *({ ({ one (); &a; }); }) = zero ();
+  if (a.a && a.b && a.c)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00054-g.torture.execute-20000917-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00054-g.torture.execute-20000917-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00054-g.torture.execute-20000917-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00054-g.torture.execute-20000917-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f2c784be10536bb66e41eec443c3ba9307687e3f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00054-g.torture.execute-20000917-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000917-1)
+run(20000917-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00055-g.torture.execute-20001013-1/20001013-1.c b/testsuite/c_test/x64_be_enable_test/GCC00055-g.torture.execute-20001013-1/20001013-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0d139fc8039ca6cf361ea41f8df839de1e54ea21
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00055-g.torture.execute-20001013-1/20001013-1.c
@@ -0,0 +1,17 @@
+struct x {
+	int a, b;
+} z = { -4028, 4096 };
+
+int foo(struct x *p, int y)
+{
+  if ((y & 0xff) != y || -p->b >= p->a)
+    return 1;
+  return 0;
+}
+
+main()
+{
+  if (foo (&z, 10))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00055-g.torture.execute-20001013-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00055-g.torture.execute-20001013-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00055-g.torture.execute-20001013-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00055-g.torture.execute-20001013-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7be1986082c09e514b2e35056c1c0effb89719cd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00055-g.torture.execute-20001013-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001013-1)
+run(20001013-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00056-g.torture.execute-20001017-2/20001017-2.c b/testsuite/c_test/x64_be_enable_test/GCC00056-g.torture.execute-20001017-2/20001017-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..3263bb9b54e7f5ba59d2d51f80927b781adc48e5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00056-g.torture.execute-20001017-2/20001017-2.c
@@ -0,0 +1,17 @@
+void
+fn_4parms (unsigned char a, long *b, long *c, unsigned int *d)
+{
+  if (*b != 1 || *c != 2 || *d != 3)
+    abort ();
+}
+
+int
+main ()
+{
+  unsigned char a = 0;
+  unsigned long b = 1, c = 2;
+  unsigned int d = 3;
+
+  fn_4parms (a, &b, &c, &d);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00056-g.torture.execute-20001017-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00056-g.torture.execute-20001017-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00056-g.torture.execute-20001017-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00056-g.torture.execute-20001017-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d0a6c93b3129985b506df65cf9598c11924b988c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00056-g.torture.execute-20001017-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20001017-2)
+run(20001017-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00057-g.torture.execute-20001024-1/20001024-1.c b/testsuite/c_test/x64_be_enable_test/GCC00057-g.torture.execute-20001024-1/20001024-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..42be8abca6acf11d8570502e9fd8326521901c5c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00057-g.torture.execute-20001024-1/20001024-1.c
@@ -0,0 +1,34 @@
+struct a;
+
+extern int baz (struct a *__restrict x);
+
+struct a {
+  long v;
+  long w;
+};
+
+struct b {
+  struct a c;
+  struct a d;
+};
+
+int bar (int x, const struct b *__restrict y, struct b *__restrict z)
+{
+  if (y->c.v || y->c.w != 250000 || y->d.v || y->d.w != 250000)
+    abort();
+}
+
+void foo(void)
+{
+  struct b x;
+  x.c.v = 0;
+  x.c.w = 250000;
+  x.d = x.c;
+  bar(0, &x, ((void *)0));
+}
+
+int main()
+{
+  foo();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00057-g.torture.execute-20001024-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00057-g.torture.execute-20001024-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00057-g.torture.execute-20001024-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00057-g.torture.execute-20001024-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..39a92555993fb950a81d556d9cccdb3fb31f33f7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00057-g.torture.execute-20001024-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001024-1)
+run(20001024-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00058-g.torture.execute-20001026-1/20001026-1.c b/testsuite/c_test/x64_be_enable_test/GCC00058-g.torture.execute-20001026-1/20001026-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6ddcc5a6f250be045dda08ccab99a0bd67eeee0f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00058-g.torture.execute-20001026-1/20001026-1.c
@@ -0,0 +1,44 @@
+extern void abort (void);
+
+typedef struct {
+  long r[(19 + sizeof (long))/(sizeof (long))];
+} realvaluetype;
+
+typedef void *tree;
+
+static realvaluetype
+real_value_from_int_cst (tree x, tree y)
+{
+  realvaluetype r;
+  int i;
+  for (i = 0; i < sizeof(r.r)/sizeof(long); ++i)
+    r.r[i] = -1;
+  return r;
+}
+
+struct brfic_args
+{
+  tree type;
+  tree i;
+  realvaluetype d;
+};
+
+static void
+build_real_from_int_cst_1 (data)
+     void * data;
+{
+  struct brfic_args *args = (struct brfic_args *) data;
+  args->d = real_value_from_int_cst (args->type, args->i);
+}
+
+int main()
+{
+  struct brfic_args args;
+
+  __builtin_memset (&args, 0, sizeof(args));
+  build_real_from_int_cst_1 (&args);
+
+  if (args.d.r[0] == 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00058-g.torture.execute-20001026-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00058-g.torture.execute-20001026-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00058-g.torture.execute-20001026-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00058-g.torture.execute-20001026-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..29c7051bab0ccf88687223c412e686df5e8b66b5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00058-g.torture.execute-20001026-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001026-1)
+run(20001026-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00059-g.torture.execute-20001027-1/20001027-1.c b/testsuite/c_test/x64_be_enable_test/GCC00059-g.torture.execute-20001027-1/20001027-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..89ac9a024dd664b72c2c2fc1dcf526bc4204faf4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00059-g.torture.execute-20001027-1/20001027-1.c
@@ -0,0 +1,11 @@
+int x,*p=&x;
+
+int main()
+{
+  int i=0;
+  x=1;
+  p[i]=2;
+  if (x != 2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00059-g.torture.execute-20001027-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00059-g.torture.execute-20001027-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00059-g.torture.execute-20001027-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00059-g.torture.execute-20001027-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6921eb616ebe5061b50a9ed798b8309c2991fa56
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00059-g.torture.execute-20001027-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001027-1)
+run(20001027-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00060-g.torture.execute-20001101/20001101.c b/testsuite/c_test/x64_be_enable_test/GCC00060-g.torture.execute-20001101/20001101.c
new file mode 100644
index 0000000000000000000000000000000000000000..475211e25f9710dc34a8007cd426d1dee74850ec
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00060-g.torture.execute-20001101/20001101.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target untyped_assembly } */
+extern void abort(void);
+			 
+typedef struct
+{
+  unsigned int unchanging : 1;
+} struc, *rtx;
+
+rtx dummy ( int *a, rtx *b)
+{
+  *a = 1;
+  *b = (rtx)7;
+  return (rtx)1;
+}
+
+void bogus (insn, thread, delay_list)
+     rtx insn;
+     rtx thread;
+     rtx delay_list;
+{
+  rtx new_thread;
+  int must_annul;
+
+  delay_list = dummy ( &must_annul, &new_thread);
+  if (delay_list == 0 &&  new_thread )
+    {
+      thread = new_thread;
+    }
+  if (delay_list && must_annul)
+    insn->unchanging = 1;
+  if (new_thread != thread )
+    abort();
+}
+
+int main()
+{
+  struc baz;
+  bogus (&baz, (rtx)7, 0);
+  exit(0);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00060-g.torture.execute-20001101/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00060-g.torture.execute-20001101/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00060-g.torture.execute-20001101/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00060-g.torture.execute-20001101/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..82019fa54b319ac1a3a32c324b213b6fbdebaf86
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00060-g.torture.execute-20001101/test.cfg
@@ -0,0 +1,2 @@
+compile(20001101)
+run(20001101)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00061-g.torture.execute-20001111-1/20001111-1.c b/testsuite/c_test/x64_be_enable_test/GCC00061-g.torture.execute-20001111-1/20001111-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..85617c23d44c52fa4d5381d8888a15f850d4f6c8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00061-g.torture.execute-20001111-1/20001111-1.c
@@ -0,0 +1,41 @@
+
+static int next_buffer = 0;
+void bar (void);
+
+static int t = 1, u = 0;
+
+long
+foo (unsigned int offset)
+{
+  unsigned i, buffer;
+  int x;
+  char *data;
+
+  i = u;
+  if (i)
+    return i * 0xce2f;
+
+  buffer = next_buffer;
+  data = buffer * 0xce2f;
+  for (i = 0; i < 2; i++)
+    bar ();
+  buffer = next_buffer;
+  return buffer * 0xce2f + offset;
+
+}
+
+void
+bar (void)
+{
+}
+
+int
+main ()
+{
+  if (foo (3) != 3)
+    abort ();
+  next_buffer = 1;
+  if (foo (2) != 0xce2f + 2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00061-g.torture.execute-20001111-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00061-g.torture.execute-20001111-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00061-g.torture.execute-20001111-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00061-g.torture.execute-20001111-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..95b203c6a9f5d3fe5e43c1f924cb2849651cb2e2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00061-g.torture.execute-20001111-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001111-1)
+run(20001111-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00062-g.torture.execute-20001121-1/20001121-1.c b/testsuite/c_test/x64_be_enable_test/GCC00062-g.torture.execute-20001121-1/20001121-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a3c68584905b01fc0b67f0a130c1085710bb5944
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00062-g.torture.execute-20001121-1/20001121-1.c
@@ -0,0 +1,24 @@
+/* { dg-options "-fgnu89-inline" } */
+
+extern void abort (void);
+extern void exit (int);
+
+double d;
+
+__inline__ double foo (void)
+{
+  return d;
+}
+
+__inline__ int bar (void)
+{
+  foo();
+  return 0;
+}
+
+int main (void)
+{
+  if (bar ())
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00062-g.torture.execute-20001121-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00062-g.torture.execute-20001121-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00062-g.torture.execute-20001121-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00062-g.torture.execute-20001121-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0eb191620d23beb8081e64d751d983c145d6dbd9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00062-g.torture.execute-20001121-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001121-1)
+run(20001121-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00063-g.torture.execute-20001130-1/20001130-1.c b/testsuite/c_test/x64_be_enable_test/GCC00063-g.torture.execute-20001130-1/20001130-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4a996ee6ad3a56a850e8e564c666b0907c4a9eb4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00063-g.torture.execute-20001130-1/20001130-1.c
@@ -0,0 +1,21 @@
+static inline int bar(void) { return 1; }
+static int mem[3];
+
+static int foo(int x)
+{
+  if (x != 0)
+    return x;
+
+  mem[x++] = foo(bar());
+
+  if (x != 1)
+    abort();
+
+  return 0;
+}
+
+int main()
+{
+  foo(0);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00063-g.torture.execute-20001130-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00063-g.torture.execute-20001130-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00063-g.torture.execute-20001130-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00063-g.torture.execute-20001130-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f0b3c35400cf1f3aca12019485de96c848ff323c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00063-g.torture.execute-20001130-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001130-1)
+run(20001130-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00064-g.torture.execute-20001203-1/20001203-1.c b/testsuite/c_test/x64_be_enable_test/GCC00064-g.torture.execute-20001203-1/20001203-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..803c6a8905233e4933d3962b875c242fb04192e3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00064-g.torture.execute-20001203-1/20001203-1.c
@@ -0,0 +1,24 @@
+/* Origin: PR c/410 from Jan Echternach
+   <jan.echternach@informatik.uni-rostock.de>,
+   adapted to a testcase by Joseph Myers <jsm28@cam.ac.uk>.
+*/
+
+extern void exit (int);
+
+static void
+foo (void)
+{
+  struct {
+    long a;
+    char b[1];
+  } x = { 2, { 0 } };
+}
+
+int
+main (void)
+{
+  int tmp;
+  foo ();
+  tmp = 1;
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00064-g.torture.execute-20001203-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00064-g.torture.execute-20001203-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00064-g.torture.execute-20001203-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00064-g.torture.execute-20001203-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9a455f250c56d5aeecdb0d04d1c345c989a8bef6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00064-g.torture.execute-20001203-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001203-1)
+run(20001203-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00065-g.torture.execute-20010106-1/20010106-1.c b/testsuite/c_test/x64_be_enable_test/GCC00065-g.torture.execute-20010106-1/20010106-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9e149c314629b0e0f31b019b2f396bcedf81e9b8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00065-g.torture.execute-20010106-1/20010106-1.c
@@ -0,0 +1,30 @@
+/* Copyright 2001 Free Software Foundation
+   Contributed by Alexandre Oliva <aoliva@redhat.com> */
+
+int f(int i) {
+  switch (i)
+  {
+    case -2:
+      return 33;
+    case -1:
+      return 0;
+    case 0:
+      return 7;
+    case 1:
+      return 4;
+    case 2:
+      return 3;
+    case 3:
+      return 15;
+    case 4:
+     return 9;
+    default:
+      abort ();
+  }
+}
+
+int main() {
+  if (f(-1))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00065-g.torture.execute-20010106-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00065-g.torture.execute-20010106-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00065-g.torture.execute-20010106-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00065-g.torture.execute-20010106-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c26a32c2c439d587d385d91dd73f5a90713ea5cd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00065-g.torture.execute-20010106-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010106-1)
+run(20010106-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00066-g.torture.execute-20010206-1/20010206-1.c b/testsuite/c_test/x64_be_enable_test/GCC00066-g.torture.execute-20010206-1/20010206-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3aa8cad86625ac59de953fbaf497554c71f98b8f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00066-g.torture.execute-20010206-1/20010206-1.c
@@ -0,0 +1,16 @@
+int foo (void)
+{
+  int i;
+#line 1 "20010206-1.c"
+  if (0) i = 1; else i
+#line 1 "20010206-1.c"
+    = 26;
+  return i;
+}
+
+int main ()
+{
+  if (foo () != 26)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00066-g.torture.execute-20010206-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00066-g.torture.execute-20010206-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00066-g.torture.execute-20010206-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00066-g.torture.execute-20010206-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fdf61821d3a67f053549d6a76ac4e9b75533c3a1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00066-g.torture.execute-20010206-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010206-1)
+run(20010206-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00067-g.torture.execute-20010221-1/20010221-1.c b/testsuite/c_test/x64_be_enable_test/GCC00067-g.torture.execute-20010221-1/20010221-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3caff81931a0a79d35f5c453590a94aec04fd3a4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00067-g.torture.execute-20010221-1/20010221-1.c
@@ -0,0 +1,17 @@
+
+int n = 2;
+
+main ()
+{
+  int i, x = 45;
+
+  for (i = 0; i < n; i++)
+    {
+      if (i != 0)
+	x = ( i > 0 ) ? i : 0;
+    }
+
+  if (x != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00067-g.torture.execute-20010221-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00067-g.torture.execute-20010221-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00067-g.torture.execute-20010221-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00067-g.torture.execute-20010221-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..231feef939b0f40c5108599c2afe86dc7f54380c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00067-g.torture.execute-20010221-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010221-1)
+run(20010221-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00068-g.torture.execute-20010325-1/20010325-1.c b/testsuite/c_test/x64_be_enable_test/GCC00068-g.torture.execute-20010325-1/20010325-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..100679fa1848a4ee89df02d958dad5b29250cf86
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00068-g.torture.execute-20010325-1/20010325-1.c
@@ -0,0 +1,15 @@
+/* Origin: Joseph Myers <jsm28@cam.ac.uk>.
+
+   This tests for inconsistency in whether wide STRING_CSTs use the host
+   or the target endianness.  */
+
+extern void exit (int);
+extern void abort (void);
+
+int
+main (void)
+{
+  if (L"a" "b"[1] != L'b')
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00068-g.torture.execute-20010325-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00068-g.torture.execute-20010325-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00068-g.torture.execute-20010325-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00068-g.torture.execute-20010325-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ba52b44866e0decf79618349a757a2ac38020840
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00068-g.torture.execute-20010325-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010325-1)
+run(20010325-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00069-g.torture.execute-20010403-1/20010403-1.c b/testsuite/c_test/x64_be_enable_test/GCC00069-g.torture.execute-20010403-1/20010403-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6a8f2a4242ceee52faa2ce1caa2bff5e86bf24a8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00069-g.torture.execute-20010403-1/20010403-1.c
@@ -0,0 +1,36 @@
+void b (int *);
+void c (int, int);
+void d (int);
+
+int e;
+
+void a (int x, int y)
+{
+  int f = x ? e : 0;
+  int z = y;
+
+  b (&y);
+  c (z, y);
+  d (f);
+}
+
+void b (int *y)
+{
+  (*y)++;
+}
+
+void c (int x, int y)
+{
+  if (x == y)
+    abort ();
+}
+
+void d (int x)
+{
+}
+
+int main (void)
+{
+  a (0, 0);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00069-g.torture.execute-20010403-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00069-g.torture.execute-20010403-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00069-g.torture.execute-20010403-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00069-g.torture.execute-20010403-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6062a6099b96e34e9d2c8d75f573a04070d85b45
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00069-g.torture.execute-20010403-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010403-1)
+run(20010403-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00070-g.torture.execute-20010422-1/20010422-1.c b/testsuite/c_test/x64_be_enable_test/GCC00070-g.torture.execute-20010422-1/20010422-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c6bccc9ed134d6312ed8c4d55802492da0d7d4b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00070-g.torture.execute-20010422-1/20010422-1.c
@@ -0,0 +1,15 @@
+unsigned int foo(unsigned int x)
+{
+  if (x < 5)
+    x = 4;
+  else
+    x = 8;
+  return x;
+}
+
+int main(void)
+{
+  if (foo (8) != 8)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00070-g.torture.execute-20010422-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00070-g.torture.execute-20010422-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00070-g.torture.execute-20010422-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00070-g.torture.execute-20010422-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fcd80b265a8511a465731a48ce2b5eb8fd9dd300
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00070-g.torture.execute-20010422-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010422-1)
+run(20010422-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00071-g.torture.execute-20010518-1/20010518-1.c b/testsuite/c_test/x64_be_enable_test/GCC00071-g.torture.execute-20010518-1/20010518-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..94b2d8f6f2546253948617015930ddb772ca5a65
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00071-g.torture.execute-20010518-1/20010518-1.c
@@ -0,0 +1,28 @@
+/* Leaf functions with many arguments.  */
+
+int
+add (int a,
+    int b,
+    int c,
+    int d,
+    int e,
+    int f,
+    int g,
+    int h,
+    int i,
+    int j,
+    int k,
+    int l,
+    int m)
+{
+  return a+b+c+d+e+f+g+h+i+j+k+l+m;
+}
+
+int
+main(void)
+{
+  if (add (1,2,3,4,5,6,7,8,9,10,11,12,13) != 91)
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00071-g.torture.execute-20010518-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00071-g.torture.execute-20010518-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00071-g.torture.execute-20010518-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00071-g.torture.execute-20010518-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84b3709cfb8f35e60b22d28b6a2ebe937c8ed23d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00071-g.torture.execute-20010518-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010518-1)
+run(20010518-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00072-g.torture.execute-20010520-1/20010520-1.c b/testsuite/c_test/x64_be_enable_test/GCC00072-g.torture.execute-20010520-1/20010520-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa94418ca960d4415d57b367c9000cee48a66e2b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00072-g.torture.execute-20010520-1/20010520-1.c
@@ -0,0 +1,12 @@
+static unsigned int expr_hash_table_size = 1;
+
+int
+main ()
+{
+  int del = 1;
+  unsigned int i = 0;
+
+  if (i < expr_hash_table_size && del)
+    exit (0);
+  abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00072-g.torture.execute-20010520-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00072-g.torture.execute-20010520-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00072-g.torture.execute-20010520-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00072-g.torture.execute-20010520-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b43aafa55af3bb6ff4fe2b94a5be2da83fb20c87
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00072-g.torture.execute-20010520-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010520-1)
+run(20010520-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00073-g.torture.execute-20010711-1/20010711-1.c b/testsuite/c_test/x64_be_enable_test/GCC00073-g.torture.execute-20010711-1/20010711-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..12971a55a155edceb2966c799a7579dab6731dee
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00073-g.torture.execute-20010711-1/20010711-1.c
@@ -0,0 +1,13 @@
+void foo (int *a) {}
+
+int main ()
+{
+  int a;
+  if (&a == 0)
+    abort ();
+  else
+    {
+      foo (&a);
+      exit (0);
+    }
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00073-g.torture.execute-20010711-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00073-g.torture.execute-20010711-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00073-g.torture.execute-20010711-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00073-g.torture.execute-20010711-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4207c7f64a29e93453d60f73c9eba1d0fd2781d0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00073-g.torture.execute-20010711-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010711-1)
+run(20010711-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00074-g.torture.execute-20010717-1/20010717-1.c b/testsuite/c_test/x64_be_enable_test/GCC00074-g.torture.execute-20010717-1/20010717-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..65199da90350baff01b1ca8c5a7b408b72b11bc6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00074-g.torture.execute-20010717-1/20010717-1.c
@@ -0,0 +1,22 @@
+extern void abort (void);
+
+int
+main ()
+{
+  int i, j;
+  unsigned long u, r1, r2;
+
+  i = -16;
+  j = 1;
+  u = i + j;
+
+  /* no sign extension upon shift */
+  r1 = u >> 1;
+  /* sign extension upon shift, but there shouldn't be */
+  r2 = ((unsigned long) (i + j)) >> 1;
+
+  if (r1 != r2)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00074-g.torture.execute-20010717-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00074-g.torture.execute-20010717-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00074-g.torture.execute-20010717-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00074-g.torture.execute-20010717-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..230ec165d0ee007130a4da63d9f46d7b03dfb2fd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00074-g.torture.execute-20010717-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010717-1)
+run(20010717-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00075-g.torture.execute-20010904-1/20010904-1.c b/testsuite/c_test/x64_be_enable_test/GCC00075-g.torture.execute-20010904-1/20010904-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..cb4d759e6b87df1902525b3455ae132903fab04b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00075-g.torture.execute-20010904-1/20010904-1.c
@@ -0,0 +1,19 @@
+/* If some target has a Max alignment less than 32, please create
+   a #ifdef around the alignment and add your alignment.  */
+#ifdef __pdp11__
+#define alignment 2
+#else
+#define alignment 32
+#endif
+
+typedef struct x { int a; int b; } __attribute__((aligned(alignment))) X;
+typedef struct y { X x[32]; int c; } Y;
+
+Y y[2];
+
+int main(void)
+{
+  if (((char *)&y[1] - (char *)&y[0]) & 31)
+    abort ();
+  exit (0);
+}                
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00075-g.torture.execute-20010904-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00075-g.torture.execute-20010904-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00075-g.torture.execute-20010904-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00075-g.torture.execute-20010904-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0dcc687645f10fe610f1ca405f944c03bda3ba13
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00075-g.torture.execute-20010904-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010904-1)
+run(20010904-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00076-g.torture.execute-20010904-2/20010904-2.c b/testsuite/c_test/x64_be_enable_test/GCC00076-g.torture.execute-20010904-2/20010904-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..a0f2626e766b51645776ca6a51225ca2623f5173
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00076-g.torture.execute-20010904-2/20010904-2.c
@@ -0,0 +1,19 @@
+/* If some target has a Max alignment less than 32, please create
+   a #ifdef around the alignment and add your alignment.  */
+#ifdef __pdp11__
+#define alignment 2
+#else
+#define alignment 32
+#endif
+
+typedef struct x { int a; int b; } __attribute__((aligned(alignment))) X;
+typedef struct y { X x; X y[31]; int c; } Y;
+
+Y y[2];
+
+int main(void)
+{
+  if (((char *)&y[1] - (char *)&y[0]) & 31)
+    abort ();
+  exit (0);
+}                
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00076-g.torture.execute-20010904-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00076-g.torture.execute-20010904-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00076-g.torture.execute-20010904-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00076-g.torture.execute-20010904-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a24a0f9c72ab62fe1cea6da68db66894a0cf111d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00076-g.torture.execute-20010904-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20010904-2)
+run(20010904-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00077-g.torture.execute-20010925-1/20010925-1.c b/testsuite/c_test/x64_be_enable_test/GCC00077-g.torture.execute-20010925-1/20010925-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..90507e7951a64dd9e59c725c669b02301dca25e8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00077-g.torture.execute-20010925-1/20010925-1.c
@@ -0,0 +1,24 @@
+extern void exit(int);
+extern void abort (void);
+
+extern void * memcpy (void *, const void *, __SIZE_TYPE__);
+int foo (void *, void *, unsigned int c);
+
+int src[10];
+int dst[10];
+
+int main()
+{
+   if (foo (dst, src, 10) != 0)
+     abort();
+   exit(0);
+}
+
+int foo (void *a, void *b, unsigned int c)
+{
+  if (c == 0)
+    return 1;
+
+  memcpy (a, b, c);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00077-g.torture.execute-20010925-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00077-g.torture.execute-20010925-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00077-g.torture.execute-20010925-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00077-g.torture.execute-20010925-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bb4a5f22c8a188227d55667b11e371866bc2e070
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00077-g.torture.execute-20010925-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20010925-1)
+run(20010925-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00078-g.torture.execute-20011008-3/20011008-3.c b/testsuite/c_test/x64_be_enable_test/GCC00078-g.torture.execute-20011008-3/20011008-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..0f56302c43de8f51eb3381f5db7dd5b3a22a6095
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00078-g.torture.execute-20011008-3/20011008-3.c
@@ -0,0 +1,107 @@
+/* { dg-add-options stack_size } */
+
+extern void exit (int);
+extern void abort (void);
+
+typedef unsigned int u_int32_t;
+typedef unsigned char u_int8_t;
+typedef int int32_t;
+
+typedef enum {
+        TXNLIST_DELETE,
+        TXNLIST_LSN,
+        TXNLIST_TXNID,
+        TXNLIST_PGNO
+} db_txnlist_type;
+
+struct __db_lsn; typedef struct __db_lsn DB_LSN;
+struct __db_lsn {
+        u_int32_t file;
+        u_int32_t offset;
+};
+struct __db_txnlist; typedef struct __db_txnlist DB_TXNLIST;
+
+struct __db_txnlist {
+        db_txnlist_type type;
+        struct { struct __db_txnlist *le_next; struct __db_txnlist **le_prev; } links;
+        union {
+                struct {
+                        u_int32_t txnid;
+                        int32_t generation;
+                        int32_t aborted;
+                } t;
+                struct {
+
+
+                        u_int32_t flags;
+                        int32_t fileid;
+                        u_int32_t count;
+                        char *fname;
+                } d;
+                struct {
+                        int32_t ntxns;
+                        int32_t maxn;
+                        DB_LSN *lsn_array;
+                } l;
+                struct {
+                        int32_t nentries;
+                        int32_t maxentry;
+                        char *fname;
+                        int32_t fileid;
+                        void *pgno_array;
+                        u_int8_t uid[20];
+                } p;
+        } u;
+};
+
+int log_compare (const DB_LSN *a, const DB_LSN *b)
+{
+  return 1;
+}
+
+
+int
+__db_txnlist_lsnadd(int val, DB_TXNLIST *elp, DB_LSN *lsnp, u_int32_t flags)
+{
+   int i;
+ 
+   for (i = 0; i < (!(flags & (0x1)) ? 1 : elp->u.l.ntxns); i++)
+     {
+	int __j;
+	DB_LSN __tmp;
+	val++; 
+	for (__j = 0; __j < elp->u.l.ntxns - 1; __j++)
+	  if (log_compare(&elp->u.l.lsn_array[__j], &elp->u.l.lsn_array[__j + 1]) < 0)
+	  {
+	     __tmp = elp->u.l.lsn_array[__j];
+	     elp->u.l.lsn_array[__j] = elp->u.l.lsn_array[__j + 1];
+	     elp->u.l.lsn_array[__j + 1] = __tmp;
+	  }
+     }
+
+   *lsnp = elp->u.l.lsn_array[0];
+   return val;
+}
+
+#if defined (STACK_SIZE) && STACK_SIZE < 12350
+#define VLEN (STACK_SIZE/10)
+#else
+#define VLEN 1235
+#endif
+
+int main (void)
+{
+  DB_TXNLIST el;
+  DB_LSN lsn, lsn_a[VLEN];
+  
+  el.u.l.ntxns = VLEN-1;
+  el.u.l.lsn_array = lsn_a;
+  
+  if (__db_txnlist_lsnadd (0, &el, &lsn, 0) != 1)
+    abort ();
+  
+  if (__db_txnlist_lsnadd (0, &el, &lsn, 1) != VLEN-1)
+    abort ();
+  
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00078-g.torture.execute-20011008-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00078-g.torture.execute-20011008-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00078-g.torture.execute-20011008-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00078-g.torture.execute-20011008-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..450edfda98f88f1a504910617e1ca53182582deb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00078-g.torture.execute-20011008-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20011008-3)
+run(20011008-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00079-g.torture.execute-20011019-1/20011019-1.c b/testsuite/c_test/x64_be_enable_test/GCC00079-g.torture.execute-20011019-1/20011019-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ebaa411c4101bfbd9468962cc026e7b79bf0a501
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00079-g.torture.execute-20011019-1/20011019-1.c
@@ -0,0 +1,18 @@
+extern void exit (int);
+extern void abort (void);
+
+struct { int a; int b[5]; } x;
+int *y;
+
+int foo (void)
+{
+  return y - x.b;
+}
+
+int main (void)
+{
+  y = x.b;
+  if (foo ())
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00079-g.torture.execute-20011019-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00079-g.torture.execute-20011019-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00079-g.torture.execute-20011019-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00079-g.torture.execute-20011019-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a002812b562e897afffff4dfa087262c808e1e25
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00079-g.torture.execute-20011019-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20011019-1)
+run(20011019-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00080-g.torture.execute-20011024-1/20011024-1.c b/testsuite/c_test/x64_be_enable_test/GCC00080-g.torture.execute-20011024-1/20011024-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5b871bbb9ec7c7852ab9d49f92774a867d4e1505
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00080-g.torture.execute-20011024-1/20011024-1.c
@@ -0,0 +1,22 @@
+/* Test whether store motion recognizes pure functions as potentially reading
+   any memory.  */
+
+typedef __SIZE_TYPE__ size_t;
+extern void *memcpy (void *dest, const void *src, size_t n);
+extern size_t strlen (const char *s);
+extern int strcmp (const char *s1, const char *s2) __attribute__((pure));
+
+char buf[50];
+
+static void foo (void)
+{
+  if (memcpy (buf, "abc", 4) != buf) abort ();
+  if (strcmp (buf, "abc")) abort ();
+  memcpy (buf, "abcdefgh", strlen ("abcdefgh") + 1);
+}
+
+int main (void)
+{
+  foo ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00080-g.torture.execute-20011024-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00080-g.torture.execute-20011024-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00080-g.torture.execute-20011024-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00080-g.torture.execute-20011024-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7c5985c9e2dcc1c5e72b87628a467dc5938a4b16
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00080-g.torture.execute-20011024-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20011024-1)
+run(20011024-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00081-g.torture.execute-20011109-1/20011109-1.c b/testsuite/c_test/x64_be_enable_test/GCC00081-g.torture.execute-20011109-1/20011109-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0f013d3b5656d407eb71cf998c44180ec9870c7d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00081-g.torture.execute-20011109-1/20011109-1.c
@@ -0,0 +1,58 @@
+void fail1(void)
+{
+  abort ();
+}
+void fail2(void)
+{
+  abort ();
+}
+void fail3(void)
+{
+  abort ();
+}
+void fail4(void)
+{
+  abort ();
+}
+
+
+void foo(long x)
+{
+  switch (x)
+    {
+    case -6: 
+      fail1 (); break;
+    case 0: 
+      fail2 (); break;
+    case 1: case 2: 
+      break;
+    case 3: case 4: case 5: 
+      fail3 ();
+      break;
+    default:
+      fail4 ();
+      break;
+    }
+  switch (x)
+    {
+      
+    case -3: 
+      fail1 (); break;
+    case 0: case 4: 
+      fail2 (); break;
+    case 1: case 3: 
+      break;
+    case 2: case 8: 
+      abort ();
+      break;
+    default:
+      fail4 ();
+      break;
+    }
+}
+
+int main(void)
+{
+  foo (1);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00081-g.torture.execute-20011109-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00081-g.torture.execute-20011109-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00081-g.torture.execute-20011109-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00081-g.torture.execute-20011109-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50845c8f98e94f16480c4c3787d4212dcda5c960
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00081-g.torture.execute-20011109-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20011109-1)
+run(20011109-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00082-g.torture.execute-20011113-1/20011113-1.c b/testsuite/c_test/x64_be_enable_test/GCC00082-g.torture.execute-20011113-1/20011113-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2eb86b6df6dcd2eca954a0598fd3cf0f13e4016
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00082-g.torture.execute-20011113-1/20011113-1.c
@@ -0,0 +1,55 @@
+typedef __SIZE_TYPE__ size_t;
+extern void *memcpy (void *__restrict, const void *__restrict, size_t);
+extern void abort (void);
+extern void exit (int);
+
+typedef struct t
+{
+  unsigned a : 16;
+  unsigned b : 8;
+  unsigned c : 8;
+  long d[4];
+} *T;
+
+typedef struct {
+  long r[3];
+} U;
+
+T bar (U, unsigned int);
+
+T foo (T x)
+{
+  U d, u;
+
+  memcpy (&u, &x->d[1], sizeof u);
+  d = u;
+  return bar (d, x->b);
+}
+
+T baz (T x)
+{
+  U d, u;
+
+  d.r[0] = 0x123456789;
+  d.r[1] = 0xfedcba987;
+  d.r[2] = 0xabcdef123;
+  memcpy (&u, &x->d[1], sizeof u);
+  d = u;
+  return bar (d, x->b);
+}
+
+T bar (U d, unsigned int m)
+{
+  if (d.r[0] != 21 || d.r[1] != 22 || d.r[2] != 23)
+    abort ();
+  return 0;
+}
+
+struct t t = { 26, 0, 0, { 0, 21, 22, 23 }};
+
+int main (void)
+{
+  baz (&t);
+  foo (&t);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00082-g.torture.execute-20011113-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00082-g.torture.execute-20011113-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00082-g.torture.execute-20011113-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00082-g.torture.execute-20011113-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..78762e8c014c594f49114dcd41db7ce5c6aad536
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00082-g.torture.execute-20011113-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20011113-1)
+run(20011113-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00083-g.torture.execute-20011115-1/20011115-1.c b/testsuite/c_test/x64_be_enable_test/GCC00083-g.torture.execute-20011115-1/20011115-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..17a35658e2b493389d34d33fd04b4205656defec
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00083-g.torture.execute-20011115-1/20011115-1.c
@@ -0,0 +1,26 @@
+extern void exit (int);
+
+static inline int
+foo (void)
+{
+#ifdef __OPTIMIZE__
+  extern int undefined_reference;
+  return undefined_reference;
+#else
+  return 0;
+#endif
+}
+
+static inline int
+bar (void)
+{
+  if (foo == foo)
+    return 1;
+  else
+    return foo ();
+}
+
+int main (void)
+{
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00083-g.torture.execute-20011115-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00083-g.torture.execute-20011115-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00083-g.torture.execute-20011115-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00083-g.torture.execute-20011115-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..783523319923a7b68f700c86f15909dac95f40a7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00083-g.torture.execute-20011115-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20011115-1)
+run(20011115-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00084-g.torture.execute-20011126-1/20011126-1.c b/testsuite/c_test/x64_be_enable_test/GCC00084-g.torture.execute-20011126-1/20011126-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ede938b00427b8e2445f1d7c6eb43261a590bad3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00084-g.torture.execute-20011126-1/20011126-1.c
@@ -0,0 +1,19 @@
+/* Produced a overflow in ifcvt.c, causing S to contain 0xffffffff7fffffff.  */
+
+int a = 1;
+
+int main ()
+{
+  long long s;
+
+  s = a;
+  if (s < 0)
+    s = -2147483648LL;
+  else
+    s = 2147483647LL;
+
+  if (s < 0)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00084-g.torture.execute-20011126-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00084-g.torture.execute-20011126-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00084-g.torture.execute-20011126-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00084-g.torture.execute-20011126-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a698751f06a888c3716f787c2b2811f696bc97e3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00084-g.torture.execute-20011126-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20011126-1)
+run(20011126-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00085-g.torture.execute-20011219-1/20011219-1.c b/testsuite/c_test/x64_be_enable_test/GCC00085-g.torture.execute-20011219-1/20011219-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d6455ab5090a1f0cb34f0079f40b7dc4bfb84427
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00085-g.torture.execute-20011219-1/20011219-1.c
@@ -0,0 +1,49 @@
+/* This testcase failed on IA-32 at -O and above, because combine attached
+   a REG_LABEL note to jump instruction already using JUMP_LABEL.  */
+
+extern void abort (void);
+extern void exit (int);
+
+enum X { A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q };
+
+void
+bar (const char *x, int y, const char *z)
+{
+}
+
+long
+foo (enum X x, const void *y)
+{
+  long a;
+
+  switch (x)
+    {
+    case K:
+      a = *(long *)y;
+      break;
+    case L:
+      a = *(long *)y;
+      break;
+    case M:
+      a = *(long *)y;
+      break;
+    case N:
+      a = *(long *)y;
+      break;
+    case O:
+      a = *(long *)y;
+      break;
+    default:
+      bar ("foo", 1, "bar");
+    }
+  return a;
+}
+
+int
+main ()
+{
+  long i = 24;
+  if (foo (N, &i) != 24)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00085-g.torture.execute-20011219-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00085-g.torture.execute-20011219-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00085-g.torture.execute-20011219-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00085-g.torture.execute-20011219-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd87ee7aa6a3c19e3e998199e73e69865134b6f1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00085-g.torture.execute-20011219-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20011219-1)
+run(20011219-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00086-g.torture.execute-20020103-1/20020103-1.c b/testsuite/c_test/x64_be_enable_test/GCC00086-g.torture.execute-20020103-1/20020103-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c010aeaad9fc97e7a049d71254b60f9f483c59dd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00086-g.torture.execute-20020103-1/20020103-1.c
@@ -0,0 +1,28 @@
+/* On h8300 port, the following used to be broken with -mh or -ms.  */
+
+extern void abort (void);
+extern void exit (int);
+
+unsigned long
+foo (unsigned long a)
+{
+  return a ^ 0x0000ffff;
+}
+
+unsigned long
+bar (unsigned long a)
+{
+  return a ^ 0xffff0000;
+}
+
+int
+main ()
+{
+  if (foo (0) != 0x0000ffff)
+    abort ();
+
+  if (bar (0) != 0xffff0000)
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00086-g.torture.execute-20020103-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00086-g.torture.execute-20020103-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00086-g.torture.execute-20020103-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00086-g.torture.execute-20020103-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..92e89563a49e5600f201b1569666823955915c58
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00086-g.torture.execute-20020103-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020103-1)
+run(20020103-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00087-g.torture.execute-20020107-1/20020107-1.c b/testsuite/c_test/x64_be_enable_test/GCC00087-g.torture.execute-20020107-1/20020107-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..23d8aebf45eeaa6669aef448921fd97446fbc579
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00087-g.torture.execute-20020107-1/20020107-1.c
@@ -0,0 +1,29 @@
+/* This testcase failed because - 1 - buf was simplified into ~buf and when
+   later expanding it back into - buf + -1, -1 got lost.  */
+/* { dg-options "-fgnu89-inline" } */
+
+extern void abort (void);
+extern void exit (int);
+
+static void
+bar (int x)
+{
+  if (!x)
+    abort ();
+}
+
+char buf[10];
+
+inline char *
+foo (char *tmp)
+{
+  asm ("" : "=r" (tmp) : "0" (tmp));
+  return tmp + 2;
+}
+
+int
+main (void)
+{
+  bar ((foo (buf) - 1 - buf) == 1);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00087-g.torture.execute-20020107-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00087-g.torture.execute-20020107-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00087-g.torture.execute-20020107-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00087-g.torture.execute-20020107-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..061cc9390f84cfdf7ddd0aa324977e827e25ceac
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00087-g.torture.execute-20020107-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020107-1)
+run(20020107-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00088-g.torture.execute-20020127-1/20020127-1.c b/testsuite/c_test/x64_be_enable_test/GCC00088-g.torture.execute-20020127-1/20020127-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..88078dc500d8c01ad49a27e968106ab821f5e987
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00088-g.torture.execute-20020127-1/20020127-1.c
@@ -0,0 +1,22 @@
+/* This used to fail on h8300.  */
+
+extern void abort (void);
+extern void exit (int);
+
+unsigned long
+foo (unsigned long n)
+{
+  return (~n >> 3) & 1;
+}
+
+int
+main ()
+{
+  if (foo (1 << 3) != 0)
+    abort ();
+
+  if (foo (0) != 1)
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00088-g.torture.execute-20020127-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00088-g.torture.execute-20020127-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00088-g.torture.execute-20020127-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00088-g.torture.execute-20020127-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4f2b4a662346885eb3471167928a0fe580bd1f2a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00088-g.torture.execute-20020127-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020127-1)
+run(20020127-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00089-g.torture.execute-20020129-1/20020129-1.c b/testsuite/c_test/x64_be_enable_test/GCC00089-g.torture.execute-20020129-1/20020129-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6430c4c1c2f810d70d8d05d7bd6f8654cea6ec5a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00089-g.torture.execute-20020129-1/20020129-1.c
@@ -0,0 +1,51 @@
+/* This testcase failed at -O2 on IA-64, because scheduling did not take
+   into account conditional execution when using cselib for alias
+   analysis.  */
+
+struct D { int d1; struct D *d2; };
+struct C { struct D c1; long c2, c3, c4, c5, c6; };
+struct A { struct A *a1; struct C *a2; };
+struct B { struct C b1; struct A *b2; };
+
+extern void abort (void);
+extern void exit (int);
+
+void
+foo (struct B *x, struct B *y)
+{
+  if (x->b2 == 0)
+    {
+      struct A *a;
+
+      x->b2 = a = y->b2;
+      y->b2 = 0;
+      for (; a; a = a->a1)
+	a->a2 = &x->b1;
+    }
+
+  if (y->b2 != 0)
+    abort ();
+
+  if (x->b1.c3 == -1)
+    {
+      x->b1.c3 = y->b1.c3;
+      x->b1.c4 = y->b1.c4;
+      y->b1.c3 = -1;
+      y->b1.c4 = 0;
+    }
+
+  if (y->b1.c3 != -1)
+    abort ();
+}
+
+struct B x, y;
+
+int main ()
+{
+  y.b1.c1.d1 = 6;
+  y.b1.c3 = 145;
+  y.b1.c4 = 2448;
+  x.b1.c3 = -1;
+  foo (&x, &y);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00089-g.torture.execute-20020129-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00089-g.torture.execute-20020129-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00089-g.torture.execute-20020129-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00089-g.torture.execute-20020129-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a1d7afb4e820f8cae087c2d01f518ea597f307ee
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00089-g.torture.execute-20020129-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020129-1)
+run(20020129-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00090-g.torture.execute-20020206-1/20020206-1.c b/testsuite/c_test/x64_be_enable_test/GCC00090-g.torture.execute-20020206-1/20020206-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8450800a1768851ca2fb8e401fc8b4ac5843be43
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00090-g.torture.execute-20020206-1/20020206-1.c
@@ -0,0 +1,26 @@
+struct A {
+  unsigned int a, b, c;
+};
+
+extern void abort (void);
+extern void exit (int);
+
+struct A bar (void)
+{
+  return (struct A) { 176, 52, 31 };
+}
+
+void baz (struct A *a)
+{
+  if (a->a != 176 || a->b != 52 || a->c != 31)
+    abort ();
+}
+
+int main ()
+{
+  struct A d;
+
+  d = ({ ({ bar (); }); });
+  baz (&d);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00090-g.torture.execute-20020206-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00090-g.torture.execute-20020206-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00090-g.torture.execute-20020206-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00090-g.torture.execute-20020206-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bc47e5f30a886ea8300686875485f9007272f3d6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00090-g.torture.execute-20020206-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020206-1)
+run(20020206-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00091-g.torture.execute-20020219-1/20020219-1.c b/testsuite/c_test/x64_be_enable_test/GCC00091-g.torture.execute-20020219-1/20020219-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..48200e3192b98b9f92f7c1f597c1a1e2fa315856
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00091-g.torture.execute-20020219-1/20020219-1.c
@@ -0,0 +1,21 @@
+/* PR c/4308
+   This testcase failed because 0x8000000000000000 >> 0
+   was incorrectly folded into 0xffffffff00000000.  */
+
+extern void abort (void);
+extern void exit (int);
+
+long long foo (void)
+{
+  long long C = 1ULL << 63, X;
+  int Y = 32;
+  X = C >> (Y & 31);
+  return X;
+}
+
+int main (void)
+{
+  if (foo () != 1ULL << 63)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00091-g.torture.execute-20020219-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00091-g.torture.execute-20020219-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00091-g.torture.execute-20020219-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00091-g.torture.execute-20020219-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..239400ba930af6989e90701f36cb105607b6bd4d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00091-g.torture.execute-20020219-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020219-1)
+run(20020219-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00092-g.torture.execute-20020225-1/20020225-1.c b/testsuite/c_test/x64_be_enable_test/GCC00092-g.torture.execute-20020225-1/20020225-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..514730a09aa851de3830adec38f5702bcf344293
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00092-g.torture.execute-20020225-1/20020225-1.c
@@ -0,0 +1,17 @@
+/* This testcase failed at -O2 on powerpc64 due to andsi3 writing
+   nonzero bits to the high 32 bits of a 64 bit register.  */
+
+extern void abort (void);
+extern void exit (int);
+
+unsigned long foo (unsigned long base, unsigned int val)
+{
+  return base + (val & 0x80000001);
+}
+
+int main (void)
+{
+  if (foo (0L, 0x0ffffff0) != 0L)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00092-g.torture.execute-20020225-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00092-g.torture.execute-20020225-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00092-g.torture.execute-20020225-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00092-g.torture.execute-20020225-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..59aa3d1d878869b4c83edfec869f02427e2b1c2f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00092-g.torture.execute-20020225-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020225-1)
+run(20020225-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00093-g.torture.execute-20020307-1/20020307-1.c b/testsuite/c_test/x64_be_enable_test/GCC00093-g.torture.execute-20020307-1/20020307-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c6379de3e8bb957fe94f9aeb410744f08772a2b5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00093-g.torture.execute-20020307-1/20020307-1.c
@@ -0,0 +1,69 @@
+#define MASK(N) ((1UL << (N)) - 1)
+#define BITS(N) ((1UL << ((N) - 1)) + 2)
+
+#define FUNC(N) void f##N(long j) { if ((j & MASK(N)) >= BITS(N)) abort();}
+
+FUNC(3)
+FUNC(4)
+FUNC(5)
+FUNC(6)
+FUNC(7)
+FUNC(8)
+FUNC(9)
+FUNC(10)
+FUNC(11)
+FUNC(12)
+FUNC(13)
+FUNC(14)
+FUNC(15)
+FUNC(16)
+FUNC(17)
+FUNC(18)
+FUNC(19)
+FUNC(20)
+FUNC(21)
+FUNC(22)
+FUNC(23)
+FUNC(24)
+FUNC(25)
+FUNC(26)
+FUNC(27)
+FUNC(28)
+FUNC(29)
+FUNC(30)
+FUNC(31)
+
+int main ()
+{
+  f3(0);
+  f4(0);
+  f5(0);
+  f6(0);
+  f7(0);
+  f8(0);
+  f9(0);
+  f10(0);
+  f11(0);
+  f12(0);
+  f13(0);
+  f14(0);
+  f15(0);
+  f16(0);
+  f17(0);
+  f18(0);
+  f19(0);
+  f20(0);
+  f21(0);
+  f22(0);
+  f23(0);
+  f24(0);
+  f25(0);
+  f26(0);
+  f27(0);
+  f28(0);
+  f29(0);
+  f30(0);
+  f31(0);
+
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00093-g.torture.execute-20020307-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00093-g.torture.execute-20020307-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00093-g.torture.execute-20020307-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00093-g.torture.execute-20020307-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b73edb800c5967d1936bf010cf044d5789bc2a2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00093-g.torture.execute-20020307-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020307-1)
+run(20020307-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00094-g.torture.execute-20020320-1/20020320-1.c b/testsuite/c_test/x64_be_enable_test/GCC00094-g.torture.execute-20020320-1/20020320-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..05f72c65482c71183c196d229c962a5d04b5f9ea
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00094-g.torture.execute-20020320-1/20020320-1.c
@@ -0,0 +1,23 @@
+/* PR c/5354 */
+/* Verify that GCC preserves relevant stack slots.  */
+
+extern void abort(void);
+extern void exit(int);
+
+struct large { int x, y[9]; };
+
+int main()
+{
+  int fixed;
+
+  fixed = ({ int temp1 = 2; temp1; }) - ({ int temp2 = 1; temp2; });
+  if (fixed != 1)
+    abort();
+
+  fixed = ({ struct large temp3; temp3.x = 2; temp3; }).x
+	  - ({ struct large temp4; temp4.x = 1; temp4; }).x;
+  if (fixed != 1)
+    abort();
+
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00094-g.torture.execute-20020320-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00094-g.torture.execute-20020320-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00094-g.torture.execute-20020320-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00094-g.torture.execute-20020320-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..499ce401094f039232d38adc5c10788407e1fe8c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00094-g.torture.execute-20020320-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020320-1)
+run(20020320-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00095-g.torture.execute-20020328-1/20020328-1.c b/testsuite/c_test/x64_be_enable_test/GCC00095-g.torture.execute-20020328-1/20020328-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4b6f2bf4e211aa8f375af0c5a49cf8d8f52ca328
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00095-g.torture.execute-20020328-1/20020328-1.c
@@ -0,0 +1,25 @@
+int b = 0;
+
+func () { }
+
+void
+testit(int x)
+{
+  if (x != 20)
+    abort ();
+}
+
+int
+main()
+
+{
+  int a = 0;
+
+  if (b)
+    func();
+
+  /* simplify_and_const_int would incorrectly omit the mask in
+     the line below.  */
+  testit ((a + 23) & 0xfffffffc);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00095-g.torture.execute-20020328-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00095-g.torture.execute-20020328-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00095-g.torture.execute-20020328-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00095-g.torture.execute-20020328-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..80723347432933fd9586dc46fa7ec8ca8bc88ab2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00095-g.torture.execute-20020328-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020328-1)
+run(20020328-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00096-g.torture.execute-20020402-2/20020402-2.c b/testsuite/c_test/x64_be_enable_test/GCC00096-g.torture.execute-20020402-2/20020402-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..e14233f3e3ae8fef8596532836d29087a2cd2f27
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00096-g.torture.execute-20020402-2/20020402-2.c
@@ -0,0 +1,230 @@
+/* PR 3967
+
+   local-alloc screwed up consideration of high+lo_sum and created
+   reg_equivs that it shouldn't have, resulting in lo_sum with
+   uninitialized data, resulting in segv.  The test has to remain
+   relatively large, since register spilling is required to twig
+   the bug.  */
+
+unsigned long *Local1;
+unsigned long *Local2;
+unsigned long *Local3;
+unsigned long *RDbf1;
+unsigned long *RDbf2;
+unsigned long *RDbf3;
+unsigned long *IntVc1;
+unsigned long *IntVc2;
+unsigned long *IntCode3;
+unsigned long *IntCode4;
+unsigned long *IntCode5;
+unsigned long *IntCode6;
+unsigned long *Lom1;
+unsigned long *Lom2;
+unsigned long *Lom3;
+unsigned long *Lom4;
+unsigned long *Lom5;
+unsigned long *Lom6;
+unsigned long *Lom7;
+unsigned long *Lom8;
+unsigned long *Lom9;
+unsigned long *Lom10;
+unsigned long *RDbf11;
+unsigned long *RDbf12;
+
+typedef struct
+  {
+    long a1;
+    unsigned long n1;
+    unsigned long local1;
+    unsigned long local2;
+    unsigned long local3;
+    unsigned long rdbf1;
+    unsigned long rdbf2;
+    unsigned long milli;
+    unsigned long frames1;
+    unsigned long frames2;
+    unsigned long nonShared;
+    long newPrivate;
+    long freeLimit;
+    unsigned long cache1;
+    unsigned long cache2;
+    unsigned long cache3;
+    unsigned long cache4;
+    unsigned long cache5;
+    unsigned long time6;
+    unsigned long frames7;
+    unsigned long page8;
+    unsigned long ot9;
+    unsigned long data10;
+    unsigned long bm11;
+    unsigned long misc12;
+  }
+ShrPcCommonStatSType;
+
+
+typedef struct
+  {
+    unsigned long sharedAttached;
+    unsigned long totalAttached;
+    long avgPercentShared;
+    unsigned long numberOfFreeFrames;
+    unsigned long localDirtyPageCount;
+    unsigned long globalDirtyPageCount;
+    long wakeupInterval;
+    unsigned long numActiveProcesses;
+    unsigned long numRecentActiveProcesses;
+    unsigned long gemDirtyPageKinds[10];
+    unsigned long stoneDirtyPageKinds[10];
+    unsigned long gemsInCacheCount;
+    long targetFreeFrameCount;
+  }
+ShrPcMonStatSType;
+
+typedef struct
+  {
+    unsigned long c1;
+    unsigned long c2;
+    unsigned long c3;
+    unsigned long c4;
+    unsigned long c5;
+    unsigned long c6;
+    unsigned long c7;
+    unsigned long c8;
+    unsigned long c9;
+    unsigned long c10;
+    unsigned long c11;
+    unsigned long c12;
+    unsigned long a1;
+    unsigned long a2;
+    unsigned long a3;
+    unsigned long a4;
+    unsigned long a5;
+    unsigned long a6;
+    unsigned long a7;
+    unsigned long a8;
+    unsigned long a9;
+    unsigned long a10;
+    unsigned long a11;
+    unsigned long a12;
+    unsigned long a13;
+    unsigned long a14;
+    unsigned long a15;
+    unsigned long a16;
+    unsigned long a17;
+    unsigned long a18;
+    unsigned long a19;
+    unsigned long sessionStats[40];
+  }
+ShrPcGemStatSType;
+
+union ShrPcStatUnion
+  {
+    ShrPcMonStatSType monitor;
+    ShrPcGemStatSType gem;
+  };
+
+typedef struct
+  {
+    int processId;
+    int sessionId;
+    ShrPcCommonStatSType cmn;
+    union ShrPcStatUnion u;
+  } ShrPcStatsSType;
+
+typedef struct
+  {
+    unsigned long *p1;
+    unsigned long *p2;
+    unsigned long *p3;
+    unsigned long *p4;
+    unsigned long *p5;
+    unsigned long *p6;
+    unsigned long *p7;
+    unsigned long *p8;
+    unsigned long *p9;
+    unsigned long *p10;
+    unsigned long *p11;
+  }
+WorkEntrySType;
+
+WorkEntrySType Workspace;
+
+static void 
+setStatPointers (ShrPcStatsSType * statsPtr, long sessionId)
+{
+  statsPtr->sessionId = sessionId;
+  statsPtr->cmn.a1 = 0;
+  statsPtr->cmn.n1 = 5;
+
+  Local1 = &statsPtr->cmn.local1;
+  Local2 = &statsPtr->cmn.local2;
+  Local3 = &statsPtr->cmn.local3;
+  RDbf1 = &statsPtr->cmn.rdbf1;
+  RDbf2 = &statsPtr->cmn.rdbf2;
+  RDbf3 = &statsPtr->cmn.milli;
+  *RDbf3 = 1;
+
+  IntVc1 = &statsPtr->u.gem.a1;
+  IntVc2 = &statsPtr->u.gem.a2;
+  IntCode3 = &statsPtr->u.gem.a3;
+  IntCode4 = &statsPtr->u.gem.a4;
+  IntCode5 = &statsPtr->u.gem.a5;
+  IntCode6 = &statsPtr->u.gem.a6;
+
+  {
+    WorkEntrySType *workSpPtr;
+    workSpPtr = &Workspace;
+    workSpPtr->p1 = &statsPtr->u.gem.a7;
+    workSpPtr->p2 = &statsPtr->u.gem.a8;
+    workSpPtr->p3 = &statsPtr->u.gem.a9;
+    workSpPtr->p4 = &statsPtr->u.gem.a10;
+    workSpPtr->p5 = &statsPtr->u.gem.a11;
+    workSpPtr->p6 = &statsPtr->u.gem.a12;
+    workSpPtr->p7 = &statsPtr->u.gem.a13;
+    workSpPtr->p8 = &statsPtr->u.gem.a14;
+    workSpPtr->p9 = &statsPtr->u.gem.a15;
+    workSpPtr->p10 = &statsPtr->u.gem.a16;
+    workSpPtr->p11 = &statsPtr->u.gem.a17;
+  }
+  Lom1 = &statsPtr->u.gem.c1;
+  Lom2 = &statsPtr->u.gem.c2;
+  Lom3 = &statsPtr->u.gem.c3;
+  Lom4 = &statsPtr->u.gem.c4;
+  Lom5 = &statsPtr->u.gem.c5;
+  Lom6 = &statsPtr->u.gem.c6;
+  Lom7 = &statsPtr->u.gem.c7;
+  Lom8 = &statsPtr->u.gem.c8;
+  Lom9 = &statsPtr->u.gem.c9;
+  Lom10 = &statsPtr->u.gem.c10;
+  RDbf11 = &statsPtr->u.gem.c11;
+  RDbf12 = &statsPtr->u.gem.c12;
+}
+
+typedef struct
+{
+  ShrPcStatsSType stats;
+} ShrPcPteSType;
+
+ShrPcPteSType MyPte;
+
+static void 
+initPte (void *shrpcPtr, long sessionId)
+{
+  ShrPcPteSType *ptePtr;
+
+  ptePtr = &MyPte;
+  setStatPointers (&ptePtr->stats, sessionId);
+}
+
+void 
+InitCache (int sessionId)
+{
+  initPte (0, sessionId);
+}
+
+int 
+main (int argc, char *argv[])
+{
+  InitCache (5);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00096-g.torture.execute-20020402-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00096-g.torture.execute-20020402-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00096-g.torture.execute-20020402-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00096-g.torture.execute-20020402-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9402d60116706891ea36511006153a164f7c5092
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00096-g.torture.execute-20020402-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20020402-2)
+run(20020402-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00097-g.torture.execute-20020402-3/20020402-3.c b/testsuite/c_test/x64_be_enable_test/GCC00097-g.torture.execute-20020402-3/20020402-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..eef27409327bb926062390fb40621f7e3ef76074
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00097-g.torture.execute-20020402-3/20020402-3.c
@@ -0,0 +1,81 @@
+/* extracted from gdb sources */
+
+typedef unsigned long long CORE_ADDR;
+
+struct blockvector;
+
+struct symtab {
+  struct blockvector *blockvector;
+};
+
+struct sec {
+  void *unused;
+};
+
+struct symbol {
+  int len;
+  char *name;
+};
+
+struct block {
+	CORE_ADDR startaddr, endaddr;
+	struct symbol *function;
+	struct block *superblock;
+	unsigned char gcc_compile_flag;
+	int nsyms;
+	struct symbol syms[1];
+};
+
+struct blockvector {
+	int nblocks;
+	struct block *block[2];
+};
+
+struct blockvector *blockvector_for_pc_sect(register CORE_ADDR pc,
+					    struct symtab *symtab)
+{
+  register struct block *b;
+  register int bot, top, half;
+  struct blockvector *bl;
+
+  bl = symtab->blockvector;
+  b = bl->block[0];
+
+  bot = 0;
+  top = bl->nblocks;
+
+  while (top - bot > 1)
+    {
+      half = (top - bot + 1) >> 1;
+      b = bl->block[bot + half];
+      if (b->startaddr <= pc)
+	bot += half;
+      else
+	top = bot + half;
+    }
+
+  while (bot >= 0)
+    {
+      b = bl->block[bot];
+      if (b->endaddr > pc)
+	{
+	  return bl;
+	}
+      bot--;
+    }
+  return 0;
+}
+
+int main(void)
+{
+  struct block a = { 0, 0x10000, 0, 0, 1, 20 };
+  struct block b = { 0x10000, 0x20000, 0, 0, 1, 20 };
+  struct blockvector bv = { 2, { &a, &b } };
+  struct symtab s = { &bv };
+
+  struct blockvector *ret;
+
+  ret = blockvector_for_pc_sect(0x500, &s);
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00097-g.torture.execute-20020402-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00097-g.torture.execute-20020402-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00097-g.torture.execute-20020402-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00097-g.torture.execute-20020402-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..122effad8668b7ad10b649226c35656530470703
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00097-g.torture.execute-20020402-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20020402-3)
+run(20020402-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00098-g.torture.execute-20020404-1/20020404-1.c b/testsuite/c_test/x64_be_enable_test/GCC00098-g.torture.execute-20020404-1/20020404-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..34173e520f186c145519a798883d26285ce91149
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00098-g.torture.execute-20020404-1/20020404-1.c
@@ -0,0 +1,104 @@
+/* { dg-require-effective-target int32plus } */
+/* { dg-skip-if "pointers can be truncated" { m32c-*-* } } */
+/* Extracted from GDB sources. */
+
+typedef long long bfd_signed_vma;
+typedef bfd_signed_vma file_ptr;
+
+typedef enum bfd_boolean {false, true} boolean;
+
+typedef unsigned long long bfd_size_type;
+
+typedef unsigned int flagword;
+
+typedef unsigned long long CORE_ADDR;
+typedef unsigned long long bfd_vma;
+
+struct bfd_struct {
+	int x;
+};
+
+struct asection_struct {
+  unsigned int user_set_vma : 1;
+  bfd_vma vma;
+  bfd_vma lma;
+  unsigned int alignment_power;
+  unsigned int entsize;
+};
+
+typedef struct bfd_struct bfd;
+typedef struct asection_struct asection;
+
+static bfd *
+bfd_openw_with_cleanup (char *filename, const char *target, char *mode);
+
+static asection *
+bfd_make_section_anyway (bfd *abfd, const char *name);
+
+static boolean
+bfd_set_section_size (bfd *abfd, asection *sec, bfd_size_type val);
+
+static boolean
+bfd_set_section_flags (bfd *abfd, asection *sec, flagword flags);
+
+static boolean
+bfd_set_section_contents (bfd *abfd, asection *section, void * data, file_ptr offset, bfd_size_type count);
+
+static void
+dump_bfd_file (char *filename, char *mode,
+               char *target, CORE_ADDR vaddr,
+               char *buf, int len)
+{
+  bfd *obfd;
+  asection *osection;
+
+  obfd = bfd_openw_with_cleanup (filename, target, mode);
+  osection = bfd_make_section_anyway (obfd, ".newsec");
+  bfd_set_section_size (obfd, osection, len);
+  (((osection)->vma = (osection)->lma= (vaddr)), ((osection)->user_set_vma = (boolean)true), true);
+  (((osection)->alignment_power = (0)),true);
+  bfd_set_section_flags (obfd, osection, 0x203);
+  osection->entsize = 0;
+  bfd_set_section_contents (obfd, osection, buf, 0, len);
+}
+
+static bfd *
+bfd_openw_with_cleanup (char *filename, const char *target, char *mode)
+{
+	static bfd foo_bfd = { 0 };
+	return &foo_bfd;
+}
+
+static asection *
+bfd_make_section_anyway (bfd *abfd, const char *name)
+{
+	static asection foo_section = { false, 0x0, 0x0, 0 };
+
+	return &foo_section;
+}
+
+static boolean
+bfd_set_section_size (bfd *abfd, asection *sec, bfd_size_type val)
+{
+	return true;
+}
+
+static boolean
+bfd_set_section_flags (bfd *abfd, asection *sec, flagword flags)
+{
+}
+
+static boolean
+bfd_set_section_contents (bfd *abfd, asection *section, void * data, file_ptr offset, bfd_size_type count)
+{
+	if (count != (bfd_size_type)0x1eadbeef)
+		abort();
+}
+
+static char hello[] = "hello";
+
+int main(void)
+{
+	dump_bfd_file(0, 0, 0, (CORE_ADDR)0xdeadbeef, hello, (int)0x1eadbeef);
+	exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00098-g.torture.execute-20020404-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00098-g.torture.execute-20020404-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00098-g.torture.execute-20020404-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00098-g.torture.execute-20020404-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..312974585934321385669803c6da506a19eafdfa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00098-g.torture.execute-20020404-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020404-1)
+run(20020404-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00099-g.torture.execute-20020406-1/20020406-1.c b/testsuite/c_test/x64_be_enable_test/GCC00099-g.torture.execute-20020406-1/20020406-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..69a82f6589a4692f6905785e8565b4ba9dcb7901
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00099-g.torture.execute-20020406-1/20020406-1.c
@@ -0,0 +1,126 @@
+// Origin: abbott@dima.unige.it
+// PR c/5120
+
+extern void * malloc (__SIZE_TYPE__);
+extern void * calloc (__SIZE_TYPE__, __SIZE_TYPE__);
+
+typedef unsigned int FFelem;
+
+FFelem FFmul(const FFelem x, const FFelem y)
+{
+  return x;
+}
+
+
+struct DUPFFstruct
+{
+  int maxdeg;
+  int deg;
+  FFelem *coeffs;
+};
+
+typedef struct DUPFFstruct *DUPFF;
+
+
+int DUPFFdeg(const DUPFF f)
+{
+  return f->deg;
+}
+
+
+DUPFF DUPFFnew(const int maxdeg)
+{
+  DUPFF ans = (DUPFF)malloc(sizeof(struct DUPFFstruct));
+  ans->coeffs = 0;
+  if (maxdeg >= 0) ans->coeffs = (FFelem*)calloc(maxdeg+1,sizeof(FFelem));
+  ans->maxdeg = maxdeg;
+  ans->deg = -1;
+  return ans;
+}
+
+void DUPFFfree(DUPFF x)
+{
+}
+
+void DUPFFswap(DUPFF x, DUPFF y)
+{
+}
+
+
+DUPFF DUPFFcopy(const DUPFF x)
+{
+  return x;
+}
+
+
+void DUPFFshift_add(DUPFF f, const DUPFF g, int deg, const FFelem coeff)
+{
+}
+
+
+DUPFF DUPFFexgcd(DUPFF *fcofac, DUPFF *gcofac, const DUPFF f, const DUPFF g)
+{
+  DUPFF u, v, uf, ug, vf, vg;
+  FFelem q, lcu, lcvrecip, p;
+  int df, dg, du, dv;
+
+  printf("DUPFFexgcd called on degrees %d and %d\n", DUPFFdeg(f), DUPFFdeg(g));
+  if (DUPFFdeg(f) < DUPFFdeg(g)) return DUPFFexgcd(gcofac, fcofac, g, f);  /*** BUG IN THIS LINE ***/
+  if (DUPFFdeg(f) != 2 || DUPFFdeg(g) != 1) abort();
+  if (f->coeffs[0] == 0) return f;
+  /****** NEVER REACH HERE IN THE EXAMPLE ******/
+  p = 2;
+
+  df = DUPFFdeg(f);  if (df < 0) df = 0; /* both inputs are zero */
+  dg = DUPFFdeg(g);  if (dg < 0) dg = 0; /* one input is zero */
+  u = DUPFFcopy(f);
+  v = DUPFFcopy(g);
+
+  uf = DUPFFnew(dg); uf->coeffs[0] = 1; uf->deg = 0;
+  ug = DUPFFnew(df);
+  vf = DUPFFnew(dg);
+  vg = DUPFFnew(df); vg->coeffs[0] = 1; vg->deg = 0;
+
+  while (DUPFFdeg(v) > 0)
+  {
+    dv = DUPFFdeg(v);
+    lcvrecip = FFmul(1, v->coeffs[dv]);
+    while (DUPFFdeg(u) >= dv)
+    {
+      du = DUPFFdeg(u);
+      lcu = u->coeffs[du];
+      q = FFmul(lcu, lcvrecip);
+      DUPFFshift_add(u, v, du-dv, p-q);
+      DUPFFshift_add(uf, vf, du-dv, p-q);
+      DUPFFshift_add(ug, vg, du-dv, p-q);
+    }
+    DUPFFswap(u, v);
+    DUPFFswap(uf, vf);
+    DUPFFswap(ug, vg);
+  }
+  if (DUPFFdeg(v) == 0)
+  {
+    DUPFFswap(u, v);
+    DUPFFswap(uf, vf);
+    DUPFFswap(ug, vg);
+  }
+  DUPFFfree(vf);
+  DUPFFfree(vg);
+  DUPFFfree(v);
+  *fcofac = uf;
+  *gcofac = ug;
+  return u;
+}
+
+
+
+int main()
+{
+  DUPFF f, g, cf, cg, h;
+  f = DUPFFnew(1); f->coeffs[1] = 1; f->deg = 1;
+  g = DUPFFnew(2); g->coeffs[2] = 1; g->deg = 2;
+
+  printf("calling DUPFFexgcd on degrees %d and %d\n", DUPFFdeg(f), DUPFFdeg(g)) ;
+  h = DUPFFexgcd(&cf, &cg, f, g);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00099-g.torture.execute-20020406-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00099-g.torture.execute-20020406-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5bd9e0afe9e0b389aedb384960ac41d4e1fc36ff
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00099-g.torture.execute-20020406-1/expected.txt
@@ -0,0 +1,3 @@
+calling DUPFFexgcd on degrees 1 and 2
+DUPFFexgcd called on degrees 1 and 2
+DUPFFexgcd called on degrees 2 and 1
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00099-g.torture.execute-20020406-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00099-g.torture.execute-20020406-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4b092877eff734e008230285619fcb6c75c1a9e3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00099-g.torture.execute-20020406-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020406-1)
+run(20020406-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00100-g.torture.execute-20020423-1/20020423-1.c b/testsuite/c_test/x64_be_enable_test/GCC00100-g.torture.execute-20020423-1/20020423-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1e9be99b8836824d8b404250c3d49f36acb7ec4e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00100-g.torture.execute-20020423-1/20020423-1.c
@@ -0,0 +1,32 @@
+/* PR c/5430 */
+/* Verify that the multiplicative folding code is not fooled
+   by the mix between signed variables and unsigned constants. */
+
+extern void abort(void);
+extern void exit(int);
+
+int main(void) {
+  int my_int = 924;
+  unsigned int result;
+
+  result = ((my_int * 2 + 4) - 8U) / 2;
+  if (result != 922U)
+    abort();
+
+  result = ((my_int * 2 - 4U) + 2) / 2;
+  if (result != 923U)
+    abort();
+
+  result = (((my_int + 2) * 2) - 8U - 4) / 2;
+  if (result != 920U)
+    abort();
+  result = (((my_int + 2) * 2) - (8U + 4)) / 2;
+  if (result != 920U)
+    abort();
+
+  result = ((my_int * 4 + 2U) - 4U) / 2;
+  if (result != 1847U)
+    abort();
+
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00100-g.torture.execute-20020423-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00100-g.torture.execute-20020423-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00100-g.torture.execute-20020423-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00100-g.torture.execute-20020423-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..09b488f26e9c73ca5cda32d8167862f701a96104
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00100-g.torture.execute-20020423-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020423-1)
+run(20020423-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00101-g.torture.execute-20020619-1/20020619-1.c b/testsuite/c_test/x64_be_enable_test/GCC00101-g.torture.execute-20020619-1/20020619-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a1503e8930af5e0d8db9e60ef2979d49c11e9f5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00101-g.torture.execute-20020619-1/20020619-1.c
@@ -0,0 +1,31 @@
+#if (__SIZEOF_INT__ == 4)
+typedef int int32;
+#elif (__SIZEOF_LONG__ == 4)
+typedef long int32;
+#else
+#error Add target support for int32
+#endif
+static int32 ref(void)
+{
+  union {
+    char c[5];
+    int32 i;
+  } u;
+
+  __builtin_memset (&u, 0, sizeof(u));
+  u.c[0] = 1;
+  u.c[1] = 2;
+  u.c[2] = 3;
+  u.c[3] = 4;
+
+  return u.i;
+}
+
+int main()
+{
+  int32 b = ref();
+  if (b != 0x01020304
+      && b != 0x04030201)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00101-g.torture.execute-20020619-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00101-g.torture.execute-20020619-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00101-g.torture.execute-20020619-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00101-g.torture.execute-20020619-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b426dfb64ba9f1daf2c9f95bcb631772b864fdd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00101-g.torture.execute-20020619-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020619-1)
+run(20020619-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00102-g.torture.execute-20020716-1/20020716-1.c b/testsuite/c_test/x64_be_enable_test/GCC00102-g.torture.execute-20020716-1/20020716-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7f559590e9a6d568587f9d70a0fa99fe8d776120
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00102-g.torture.execute-20020716-1/20020716-1.c
@@ -0,0 +1,36 @@
+extern void abort (void);
+extern void exit (int);
+
+int sub1 (int val)
+{
+  return val;
+}
+
+int testcond (int val)
+{
+  int flag1;
+
+    {
+      int t1 = val;
+        {
+          int t2 = t1;
+            {
+              flag1 = sub1 (t2) ==0;
+              goto lab1;
+            };
+        }
+      lab1: ;
+    }
+
+  if (flag1 != 0)
+    return 0x4d0000;
+  else
+    return 0;
+}
+
+int main (void)
+{
+  if (testcond (1))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00102-g.torture.execute-20020716-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00102-g.torture.execute-20020716-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00102-g.torture.execute-20020716-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00102-g.torture.execute-20020716-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c688a5417bf85501c40a550bdcd2674759920227
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00102-g.torture.execute-20020716-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020716-1)
+run(20020716-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00103-g.torture.execute-20020805-1/20020805-1.c b/testsuite/c_test/x64_be_enable_test/GCC00103-g.torture.execute-20020805-1/20020805-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e7d517996f5e94222e500f49150127c29eb4c2d7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00103-g.torture.execute-20020805-1/20020805-1.c
@@ -0,0 +1,21 @@
+/* This testcase was miscompiled on IA-32, because fold-const
+   assumed associate_trees is always done on PLUS_EXPR.  */
+
+extern void abort (void);
+extern void exit (int);
+
+void check (unsigned int m)
+{
+  if (m != (unsigned int) -1)
+    abort ();
+}
+
+unsigned int n = 1;
+
+int main (void)
+{
+  unsigned int m;
+  m = (1 | (2 - n)) | (-n);
+  check (m);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00103-g.torture.execute-20020805-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00103-g.torture.execute-20020805-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00103-g.torture.execute-20020805-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00103-g.torture.execute-20020805-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..234f7ae92986efaec576afae9ed826abdad2ceb1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00103-g.torture.execute-20020805-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020805-1)
+run(20020805-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00104-g.torture.execute-20020819-1/20020819-1.c b/testsuite/c_test/x64_be_enable_test/GCC00104-g.torture.execute-20020819-1/20020819-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..549da910cd4fc371f5fa78d730713be432fa16af
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00104-g.torture.execute-20020819-1/20020819-1.c
@@ -0,0 +1,22 @@
+foo ()
+{
+  return 0;
+}
+
+main()
+{
+  int i, j, k, ccp_bad = 0;
+
+  for (i = 0; i < 10; i++)
+    {
+      for (j = 0; j < 10; j++)
+	if (foo ())
+	  ccp_bad = 1;
+    
+      k = ccp_bad != 0;
+      if (k)
+	abort ();
+    }
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00104-g.torture.execute-20020819-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00104-g.torture.execute-20020819-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00104-g.torture.execute-20020819-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00104-g.torture.execute-20020819-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0c43bbc4eb1b68a3e718b3d4b12ad34b7f3ce62b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00104-g.torture.execute-20020819-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020819-1)
+run(20020819-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00105-g.torture.execute-20020916-1/20020916-1.c b/testsuite/c_test/x64_be_enable_test/GCC00105-g.torture.execute-20020916-1/20020916-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3f2db15d019573a04530cc8c6a372eed4529ec7e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00105-g.torture.execute-20020916-1/20020916-1.c
@@ -0,0 +1,19 @@
+/* Distilled from try_pre_increment in flow.c.  If-conversion inserted
+   new instructions at the wrong place on ppc.  */
+
+int foo(int a)
+{
+  int x;
+  x = 0;
+  if (a > 0) x = 1;
+  if (a < 0) x = 1;
+  return x;
+}
+
+int main()
+{
+  if (foo(1) != 1)
+    abort();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00105-g.torture.execute-20020916-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00105-g.torture.execute-20020916-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00105-g.torture.execute-20020916-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00105-g.torture.execute-20020916-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..23eebd9381d27116cc05e6b0f70b2cbc9c1be836
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00105-g.torture.execute-20020916-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020916-1)
+run(20020916-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00106-g.torture.execute-20020920-1/20020920-1.c b/testsuite/c_test/x64_be_enable_test/GCC00106-g.torture.execute-20020920-1/20020920-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4539742dd38d06295e75f2f21565c763c13e777d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00106-g.torture.execute-20020920-1/20020920-1.c
@@ -0,0 +1,31 @@
+extern void abort (void);
+extern void exit (int);
+
+struct B
+{
+  int x;
+  int y;
+};
+
+struct A
+{
+  int z;
+  struct B b;
+};
+
+struct A
+f ()
+{
+  struct B b = { 0, 1 };
+  struct A a = { 2, b };
+  return a;
+}
+
+int
+main (void)
+{
+  struct A a = f ();
+  if (a.z != 2 || a.b.x != 0 || a.b.y != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00106-g.torture.execute-20020920-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00106-g.torture.execute-20020920-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00106-g.torture.execute-20020920-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00106-g.torture.execute-20020920-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c908905b27e39fcaf32c4b73e0b88f2d188227b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00106-g.torture.execute-20020920-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020920-1)
+run(20020920-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00107-g.torture.execute-20021011-1/20021011-1.c b/testsuite/c_test/x64_be_enable_test/GCC00107-g.torture.execute-20021011-1/20021011-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..b1b2c406a712e28308611c8f2620e04ae412a0ad
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00107-g.torture.execute-20021011-1/20021011-1.c
@@ -0,0 +1,24 @@
+/* PR opt/8165.  */
+
+extern void abort (void);
+
+char buf[64];
+
+int
+main (void)
+{
+  int i;
+
+  __builtin_strcpy (buf, "mystring");
+  if (__builtin_strcmp (buf, "mystring") != 0)
+    abort ();
+
+  for (i = 0; i < 16; ++i)
+    {
+      __builtin_strcpy (buf + i, "mystring");
+      if (__builtin_strcmp (buf + i, "mystring") != 0)
+	abort ();
+    }
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00107-g.torture.execute-20021011-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00107-g.torture.execute-20021011-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00107-g.torture.execute-20021011-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00107-g.torture.execute-20021011-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c0118649e829a8f9d14c4c36b0b470f2ea599010
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00107-g.torture.execute-20021011-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20021011-1)
+run(20021011-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00108-g.torture.execute-20021024-1/20021024-1.c b/testsuite/c_test/x64_be_enable_test/GCC00108-g.torture.execute-20021024-1/20021024-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..93504f2254a9b1e6627f0216a95f6bd7e34c4b8b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00108-g.torture.execute-20021024-1/20021024-1.c
@@ -0,0 +1,44 @@
+/* Origin: PR target/6981 from Mattias Engdegaard <mattias@virtutech.se>.  */
+/* { dg-require-effective-target int32plus } */
+
+void exit (int);
+void abort (void);
+
+unsigned long long *cp, m;
+
+void foo (void)
+{
+}
+
+void bar (unsigned rop, unsigned long long *r)
+{
+  unsigned rs1, rs2, rd;
+
+top:
+  rs2 = (rop >> 23) & 0x1ff;
+  rs1 = (rop >> 9) & 0x1ff;
+  rd = rop & 0x1ff;
+
+  *cp = 1;
+  m = r[rs1] + r[rs2];
+  *cp = 2;
+  foo();
+  if (!rd)
+    goto top;
+  r[rd] = 1;
+}
+
+int main(void)
+{
+  static unsigned long long r[64];
+  unsigned long long cr;
+  cp = &cr;
+
+  r[4] = 47;
+  r[8] = 11;
+  bar((8 << 23) | (4 << 9) | 15, r);
+
+  if (m != 47 + 11)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00108-g.torture.execute-20021024-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00108-g.torture.execute-20021024-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00108-g.torture.execute-20021024-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00108-g.torture.execute-20021024-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a0f38b6ba446e1980fc3b8d037c50bb34c4d5904
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00108-g.torture.execute-20021024-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20021024-1)
+run(20021024-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00109-g.torture.execute-20021113-1/20021113-1.c b/testsuite/c_test/x64_be_enable_test/GCC00109-g.torture.execute-20021113-1/20021113-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8226d3a85662ba610b955dbc47a8539da9412f73
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00109-g.torture.execute-20021113-1/20021113-1.c
@@ -0,0 +1,19 @@
+/* { dg-require-effective-target alloca } */
+
+/* This program tests a data flow bug that would cause constant propagation
+   to propagate constants through function calls.  */
+
+foo (int *p)
+{
+  *p = 10;
+}
+
+main()
+{
+  int *ptr = alloca (sizeof (int));
+  *ptr = 5;
+  foo (ptr);
+  if (*ptr == 5)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00109-g.torture.execute-20021113-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00109-g.torture.execute-20021113-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00109-g.torture.execute-20021113-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00109-g.torture.execute-20021113-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2956165f080acb38a26507c89375877097e33569
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00109-g.torture.execute-20021113-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20021113-1)
+run(20021113-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00110-g.torture.execute-20021118-1/20021118-1.c b/testsuite/c_test/x64_be_enable_test/GCC00110-g.torture.execute-20021118-1/20021118-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c1f800de76f84e1fef0fb0ec307cd85f0319b0a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00110-g.torture.execute-20021118-1/20021118-1.c
@@ -0,0 +1,15 @@
+struct s { int f[4]; };
+
+int foo (struct s s, int x1, int x2, int x3, int x4, int x5, int x6, int x7)
+{
+  return s.f[3] + x7;
+}
+
+int main ()
+{
+  struct s s = { 1, 2, 3, 4 };
+
+  if (foo (s, 100, 200, 300, 400, 500, 600, 700) != 704)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00110-g.torture.execute-20021118-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00110-g.torture.execute-20021118-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00110-g.torture.execute-20021118-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00110-g.torture.execute-20021118-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b7bc103b283e35c51efdb09ab22f1e84ae1c447d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00110-g.torture.execute-20021118-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20021118-1)
+run(20021118-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00111-g.torture.execute-20021118-3/20021118-3.c b/testsuite/c_test/x64_be_enable_test/GCC00111-g.torture.execute-20021118-3/20021118-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..8ec01caa5dda2ee21ab47e62c5aa1fddbad40209
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00111-g.torture.execute-20021118-3/20021118-3.c
@@ -0,0 +1,18 @@
+extern void abort (void);
+extern void exit (int);
+
+int
+foo (int x)
+{
+  if (x == -2 || -x - 100 >= 0)
+    abort ();
+  return 0;
+}
+           
+int
+main ()
+{
+  foo (-3);
+  foo (-99);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00111-g.torture.execute-20021118-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00111-g.torture.execute-20021118-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00111-g.torture.execute-20021118-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00111-g.torture.execute-20021118-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..db57b883ae248bca169b6067c3e6ad914704bc42
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00111-g.torture.execute-20021118-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20021118-3)
+run(20021118-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00112-g.torture.execute-20021204-1/20021204-1.c b/testsuite/c_test/x64_be_enable_test/GCC00112-g.torture.execute-20021204-1/20021204-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e92c408a7b59e1cc5dfc2fb945c110bf866f194e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00112-g.torture.execute-20021204-1/20021204-1.c
@@ -0,0 +1,25 @@
+/* This test was miscompiled when using sibling call optimization,
+   because X ? Y : Y - 1 optimization changed X into !X in place
+   and haven't reverted it if do_store_flag was successful, so
+   when expanding the expression the second time it was
+   !X ? Y : Y - 1.  */
+
+extern void abort (void);
+extern void exit (int);
+
+void foo (int x)
+{
+  if (x != 1)
+    abort ();
+}
+
+int z;
+
+int main (int argc, char **argv)
+{
+  char *a = "test";
+  char *b = a + 2;
+
+  foo (z > 0 ? b - a : b - a - 1);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00112-g.torture.execute-20021204-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00112-g.torture.execute-20021204-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00112-g.torture.execute-20021204-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00112-g.torture.execute-20021204-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b0f1a88b272845ab9515086b52c09d10936831c2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00112-g.torture.execute-20021204-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20021204-1)
+run(20021204-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00113-g.torture.execute-20030109-1/20030109-1.c b/testsuite/c_test/x64_be_enable_test/GCC00113-g.torture.execute-20030109-1/20030109-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1bea931f64ca9fc8bcdb0cf016b48d2d30217a18
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00113-g.torture.execute-20030109-1/20030109-1.c
@@ -0,0 +1,20 @@
+/* PR c/8032 */
+/* Verify that an empty initializer inside a partial
+   parent initializer doesn't confuse GCC.  */
+
+struct X
+{
+  int a;
+  int b;
+  int z[];
+};
+
+struct X x = { .b = 40, .z = {} };
+
+int main ()
+{
+  if (x.b != 40)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00113-g.torture.execute-20030109-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00113-g.torture.execute-20030109-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00113-g.torture.execute-20030109-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00113-g.torture.execute-20030109-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1501045f7c3ee8ffb640c26fa12a37adb14d2e59
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00113-g.torture.execute-20030109-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030109-1)
+run(20030109-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00114-g.torture.execute-20030120-2/20030120-2.c b/testsuite/c_test/x64_be_enable_test/GCC00114-g.torture.execute-20030120-2/20030120-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..298bc4f5b4f57eab26410fe759290110623de5d5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00114-g.torture.execute-20030120-2/20030120-2.c
@@ -0,0 +1,19 @@
+/* PR 8848 */
+
+extern void abort ();
+
+int foo(int status)
+{
+  int s = 0;
+  if (status == 1) s=1;
+  if (status == 3) s=3;
+  if (status == 4) s=4;
+  return s;
+}
+
+int main()
+{
+  if (foo (3) != 3)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00114-g.torture.execute-20030120-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00114-g.torture.execute-20030120-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00114-g.torture.execute-20030120-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00114-g.torture.execute-20030120-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..99bfc9fd43ac96ce37d4660bff66816a3c6e6729
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00114-g.torture.execute-20030120-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20030120-2)
+run(20030120-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00115-g.torture.execute-20030203-1/20030203-1.c b/testsuite/c_test/x64_be_enable_test/GCC00115-g.torture.execute-20030203-1/20030203-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ce3d611ef6e3456f6ab3d88f724f63dd05338e7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00115-g.torture.execute-20030203-1/20030203-1.c
@@ -0,0 +1,23 @@
+void f(int);
+int do_layer3(int single)
+{
+  int stereo1;
+
+  if(single >= 0) /* stream is stereo, but force to mono */
+    stereo1 = 1;
+  else
+    stereo1 = 2;
+  f(single);
+
+  return stereo1;
+}
+
+extern void abort ();
+int main()
+{
+  if (do_layer3(-1) != 2)
+    abort ();
+  return 0;
+}
+
+void f(int i) {}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00115-g.torture.execute-20030203-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00115-g.torture.execute-20030203-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00115-g.torture.execute-20030203-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00115-g.torture.execute-20030203-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8a4ea39b7eba3308b7379a0d6612797aa2d13bbb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00115-g.torture.execute-20030203-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030203-1)
+run(20030203-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00116-g.torture.execute-20030307-1/20030307-1.c b/testsuite/c_test/x64_be_enable_test/GCC00116-g.torture.execute-20030307-1/20030307-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3f4eb864d6c277725f76057436fed6878056e666
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00116-g.torture.execute-20030307-1/20030307-1.c
@@ -0,0 +1,26 @@
+/* PR optimization/8726 */
+/* Originator: Paul Eggert <eggert@twinsun.com> */
+
+/* Verify that GCC doesn't miscompile tail calls on Sparc. */
+
+extern void abort(void);
+
+int fcntl_lock(int fd, int op, long long offset, long long count, int type);
+
+int vfswrap_lock(char *fsp, int fd, int op, long long offset, long long count, int type)
+{
+  return fcntl_lock(fd, op, offset, count, type);
+}
+
+int fcntl_lock(int fd, int op, long long offset, long long count, int type)
+{
+  return type;
+}
+
+int main(void)
+{
+  if (vfswrap_lock (0, 1, 2, 3, 4, 5) != 5)
+    abort();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00116-g.torture.execute-20030307-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00116-g.torture.execute-20030307-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00116-g.torture.execute-20030307-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00116-g.torture.execute-20030307-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3d093ee0a5c87843febbfe642b44b7481ff49c1e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00116-g.torture.execute-20030307-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030307-1)
+run(20030307-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00117-g.torture.execute-20030313-1/20030313-1.c b/testsuite/c_test/x64_be_enable_test/GCC00117-g.torture.execute-20030313-1/20030313-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..49245a0b39f151bfe6084ed0c7067c908e1c2622
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00117-g.torture.execute-20030313-1/20030313-1.c
@@ -0,0 +1,68 @@
+struct A
+{
+  unsigned long p, q, r, s;
+} x = { 13, 14, 15, 16 };
+
+extern void abort (void);
+extern void exit (int);
+
+static inline struct A *
+bar (void)
+{
+  struct A *r;
+
+  switch (8)
+    {
+    case 2:
+      abort ();
+      break;
+    case 8:
+      r = &x;
+      break;
+    default:
+      abort ();
+      break;
+    }
+  return r;
+}
+
+void
+foo (unsigned long *x, int y)
+{
+  if (y != 12)
+    abort ();
+  if (x[0] != 1 || x[1] != 11)
+    abort ();
+  if (x[2] != 2 || x[3] != 12)
+    abort ();
+  if (x[4] != 3 || x[5] != 13)
+    abort ();
+  if (x[6] != 4 || x[7] != 14)
+    abort ();
+  if (x[8] != 5 || x[9] != 15)
+    abort ();
+  if (x[10] != 6 || x[11] != 16)
+    abort ();
+}
+
+int
+main (void)
+{
+  unsigned long a[40];
+  int b = 0;
+
+  a[b++] = 1;
+  a[b++] = 11;
+  a[b++] = 2;
+  a[b++] = 12;
+  a[b++] = 3;
+  a[b++] = bar()->p;
+  a[b++] = 4;
+  a[b++] = bar()->q;
+  a[b++] = 5;
+  a[b++] = bar()->r;
+  a[b++] = 6;
+  a[b++] = bar()->s;
+  foo (a, b);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00117-g.torture.execute-20030313-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00117-g.torture.execute-20030313-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00117-g.torture.execute-20030313-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00117-g.torture.execute-20030313-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc78962e767480a0d6b4f6d62c93a72318ff5963
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00117-g.torture.execute-20030313-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030313-1)
+run(20030313-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00118-g.torture.execute-20030330-1/20030330-1.c b/testsuite/c_test/x64_be_enable_test/GCC00118-g.torture.execute-20030330-1/20030330-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..639e47ba7a13366c058e913bda871530ca0d8b12
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00118-g.torture.execute-20030330-1/20030330-1.c
@@ -0,0 +1,14 @@
+/* PR opt/10011 */
+/* This is link test for builtin_constant_p simplification + DCE.  */
+
+extern void link_error(void);
+static void usb_hub_port_wait_reset(unsigned int delay)
+{
+        int delay_time;
+        for (delay_time = 0; delay_time < 500; delay_time += delay) {
+                if (__builtin_constant_p(delay))
+                        link_error();
+        }
+}
+
+int main() { return 0; }
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00118-g.torture.execute-20030330-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00118-g.torture.execute-20030330-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00118-g.torture.execute-20030330-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00118-g.torture.execute-20030330-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b6f4b2b730382d6da6477b99c4c731afd48201d3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00118-g.torture.execute-20030330-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030330-1)
+run(20030330-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00119-g.torture.execute-20030401-1/20030401-1.c b/testsuite/c_test/x64_be_enable_test/GCC00119-g.torture.execute-20030401-1/20030401-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0cc144a8560574226944f4dd110107e971a9c72a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00119-g.torture.execute-20030401-1/20030401-1.c
@@ -0,0 +1,27 @@
+/* Testcase for PR fortran/9974.  This was a miscompilation of the g77
+   front-end caused by the jump bypassing optimizations not handling
+   instructions inserted on CFG edges.  */
+
+extern void abort ();
+
+int bar ()
+{
+  return 1;
+}
+
+void foo (int x)
+{
+  unsigned char error = 0;
+
+  if (! (error = ((x == 0) || bar ())))
+    bar ();
+  if (! error)
+    abort ();
+}
+
+int main()
+{
+  foo (1);
+  return 0;
+}
+  
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00119-g.torture.execute-20030401-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00119-g.torture.execute-20030401-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00119-g.torture.execute-20030401-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00119-g.torture.execute-20030401-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..affb324e1c205da597ca06c2423a8b2e3c32a3db
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00119-g.torture.execute-20030401-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030401-1)
+run(20030401-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00120-g.torture.execute-20030606-1/20030606-1.c b/testsuite/c_test/x64_be_enable_test/GCC00120-g.torture.execute-20030606-1/20030606-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..51054d90a2557546a6fc8a42d3813c49b8de1c17
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00120-g.torture.execute-20030606-1/20030606-1.c
@@ -0,0 +1,27 @@
+
+int * foo (int *x, int b)
+{
+
+  *(x++) = 55;
+  if (b)
+    *(x++) = b;
+
+  return x;
+}
+
+main()
+{
+  int a[5];
+
+  memset (a, 1, sizeof (a));
+
+  if (foo(a, 0) - a != 1 || a[0] != 55 || a[1] != a[4])
+    abort();
+
+  memset (a, 1, sizeof (a));
+
+  if (foo(a, 2) - a != 2 || a[0] != 55 || a[1] != 2)
+    abort();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00120-g.torture.execute-20030606-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00120-g.torture.execute-20030606-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00120-g.torture.execute-20030606-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00120-g.torture.execute-20030606-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e73ccd6bad925f83d7e594f16e524a4165027ca6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00120-g.torture.execute-20030606-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030606-1)
+run(20030606-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00121-g.torture.execute-20030613-1/20030613-1.c b/testsuite/c_test/x64_be_enable_test/GCC00121-g.torture.execute-20030613-1/20030613-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..cb1623d9617ad2c213ffbd63b6cadee20bb846b7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00121-g.torture.execute-20030613-1/20030613-1.c
@@ -0,0 +1,62 @@
+/* PR optimization/10955 */
+/* Originator: <heinrich.brand@fujitsu-siemens.com> */
+
+/* This used to fail on SPARC32 at -O3 because the loop unroller
+   wrongly thought it could eliminate a pseudo in a loop, while
+   the pseudo was used outside the loop.  */
+
+extern void abort(void);
+
+#define COMPLEX struct CS
+
+COMPLEX {
+  long x;
+  long y;
+};
+
+
+static COMPLEX CCID (COMPLEX x)
+{
+  COMPLEX a;
+
+  a.x = x.x;
+  a.y = x.y;
+
+  return a;
+}
+
+
+static COMPLEX CPOW (COMPLEX x, int y)
+{
+  COMPLEX a;
+  a = x;
+
+  while (--y > 0)
+    a=CCID(a);
+
+  return a;
+}
+
+
+static int c5p (COMPLEX x)
+{
+  COMPLEX a,b;
+  a = CPOW (x, 2);
+  b = CCID( CPOW(a,2) );
+    
+  return (b.x == b.y); 
+}
+
+
+int main (void)
+{
+  COMPLEX  x;  
+
+  x.x = -7;
+  x.y = -7;
+
+  if (!c5p(x))
+    abort();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00121-g.torture.execute-20030613-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00121-g.torture.execute-20030613-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00121-g.torture.execute-20030613-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00121-g.torture.execute-20030613-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..975916b34f9829b8384242daa1c8b28b431ca9bc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00121-g.torture.execute-20030613-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030613-1)
+run(20030613-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00122-g.torture.execute-20030626-1/20030626-1.c b/testsuite/c_test/x64_be_enable_test/GCC00122-g.torture.execute-20030626-1/20030626-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b985f03530cead8aa162938036d93ba30310f3f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00122-g.torture.execute-20030626-1/20030626-1.c
@@ -0,0 +1,13 @@
+char buf[10];
+
+extern void abort (void);
+extern int sprintf (char*, const char*, ...);
+
+int main()
+{
+  int l = sprintf (buf, "foo\0bar");
+  if (l != 3)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00122-g.torture.execute-20030626-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00122-g.torture.execute-20030626-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00122-g.torture.execute-20030626-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00122-g.torture.execute-20030626-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d8a287ffb056eec00b6f941316ac9033e102c460
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00122-g.torture.execute-20030626-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030626-1)
+run(20030626-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00123-g.torture.execute-20030626-2/20030626-2.c b/testsuite/c_test/x64_be_enable_test/GCC00123-g.torture.execute-20030626-2/20030626-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..5483d0cba5471aae7dffd8528bdd26b493b270cc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00123-g.torture.execute-20030626-2/20030626-2.c
@@ -0,0 +1,14 @@
+char buf[40];
+
+extern int sprintf (char*, const char*, ...);
+extern void abort (void);
+
+int main()
+{
+  int i = 0;
+  int l = sprintf (buf, "%s", i++ ? "string" : "other string");
+  if (l != sizeof ("other string") - 1 || i != 1)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00123-g.torture.execute-20030626-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00123-g.torture.execute-20030626-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00123-g.torture.execute-20030626-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00123-g.torture.execute-20030626-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1b4311ff128b8c05bea1f7ad88369030f5442e1c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00123-g.torture.execute-20030626-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20030626-2)
+run(20030626-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00124-g.torture.execute-20030715-1/20030715-1.c b/testsuite/c_test/x64_be_enable_test/GCC00124-g.torture.execute-20030715-1/20030715-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2a28ce962c87a215d7c54bc6acb7cb3e13d503c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00124-g.torture.execute-20030715-1/20030715-1.c
@@ -0,0 +1,35 @@
+/* PR optimization/11320 */
+/* Origin: Andreas Schwab <schwab@suse.de> */
+
+/* Verify that the scheduler correctly computes the dependencies
+   in the presence of conditional instructions.  */
+
+int strcmp (const char *, const char *);
+int ap_standalone;
+
+const char *ap_check_cmd_context (void *a, int b)
+{
+  return 0;
+}
+
+const char *server_type (void *a, void *b, char *arg)
+{
+  const char *err = ap_check_cmd_context (a, 0x01|0x02|0x04|0x08|0x10);
+  if (err)
+    return err;
+
+  if (!strcmp (arg, "inetd"))
+    ap_standalone = 0;
+  else if (!strcmp (arg, "standalone"))
+      ap_standalone = 1;
+  else
+    return "ServerType must be either 'inetd' or 'standalone'";
+
+  return 0;
+}
+
+int main ()
+{
+  server_type (0, 0, "standalone");
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00124-g.torture.execute-20030715-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00124-g.torture.execute-20030715-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00124-g.torture.execute-20030715-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00124-g.torture.execute-20030715-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..51e58a46cdfaf421c5b33a51cfd8713742ed5f36
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00124-g.torture.execute-20030715-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030715-1)
+run(20030715-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00125-g.torture.execute-20030821-1/20030821-1.c b/testsuite/c_test/x64_be_enable_test/GCC00125-g.torture.execute-20030821-1/20030821-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..b82c2f2d75be5bc6f90eab4cb0f435400e720b21
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00125-g.torture.execute-20030821-1/20030821-1.c
@@ -0,0 +1,16 @@
+extern void abort (void);
+
+int
+foo (int x)
+{
+  if ((int) (x & 0x80ffffff) != (int) (0x8000fffe))
+    abort ();
+
+  return 0;
+}
+
+int
+main ()
+{
+  return foo (0x8000fffe);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00125-g.torture.execute-20030821-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00125-g.torture.execute-20030821-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00125-g.torture.execute-20030821-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00125-g.torture.execute-20030821-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e2861257dc1da90653153a0e21f7c9667636d656
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00125-g.torture.execute-20030821-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030821-1)
+run(20030821-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00126-g.torture.execute-20030828-1/20030828-1.c b/testsuite/c_test/x64_be_enable_test/GCC00126-g.torture.execute-20030828-1/20030828-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e8c1f0195df439918d93010150de136dc2d0e63f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00126-g.torture.execute-20030828-1/20030828-1.c
@@ -0,0 +1,18 @@
+const int *p;
+
+int bar (void)
+{
+  return *p + 1;
+}
+
+main ()
+{
+  /* Variable 'i' is never used but it's aliased to a global pointer.  The
+     alias analyzer was not considering that 'i' may be used in the call to
+     bar().  */
+  const int i = 5;
+  p = &i;
+  if (bar() != 6)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00126-g.torture.execute-20030828-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00126-g.torture.execute-20030828-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00126-g.torture.execute-20030828-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00126-g.torture.execute-20030828-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3dcc93ca184e97186671703768a702d3f1943538
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00126-g.torture.execute-20030828-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030828-1)
+run(20030828-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00127-g.torture.execute-20030903-1/20030903-1.c b/testsuite/c_test/x64_be_enable_test/GCC00127-g.torture.execute-20030903-1/20030903-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..95dad576f2db95a7d0eee99c10a2079714fed304
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00127-g.torture.execute-20030903-1/20030903-1.c
@@ -0,0 +1,21 @@
+/* Test that we don't let stmt.c think that the enumeration's values are
+   the entire set of possibilities.  Such an assumption is false for C,
+   but true for other languages.  */
+
+enum X { X1 = 1, X2, X3, X4 };
+static volatile enum X test = 0;
+static void y(int);
+
+int main()
+{
+  switch (test)
+    {
+    case X1: y(1); break;
+    case X2: y(2); break;
+    case X3: y(3); break;
+    case X4: y(4); break;
+    }
+  return 0;
+}
+
+static void y(int x) { abort (); }
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00127-g.torture.execute-20030903-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00127-g.torture.execute-20030903-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00127-g.torture.execute-20030903-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00127-g.torture.execute-20030903-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..957a20599092da79048d515d2e33875d96374f09
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00127-g.torture.execute-20030903-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030903-1)
+run(20030903-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00128-g.torture.execute-20030913-1/20030913-1.c b/testsuite/c_test/x64_be_enable_test/GCC00128-g.torture.execute-20030913-1/20030913-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ed8724bc2441d76170a03ba450371dd683a125b1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00128-g.torture.execute-20030913-1/20030913-1.c
@@ -0,0 +1,26 @@
+/* Assignments via pointers pointing to global variables were being killed
+   by SSA-DCE.  Test contributed by Paul Brook <paul@nowt.org>  */
+
+int g;
+ 
+void 
+fn2(int ** q) 
+{ 
+  *q = &g;
+} 
+ 
+void test() 
+{ 
+  int *p; 
+ 
+  fn2(&p); 
+ 
+  *p=42; 
+} 
+ 
+int main() 
+{ 
+  test(); 
+  if (g != 42) abort();
+  exit (0); 
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00128-g.torture.execute-20030913-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00128-g.torture.execute-20030913-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00128-g.torture.execute-20030913-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00128-g.torture.execute-20030913-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d1f249ce61b3c87eaccc03320351a1a186100569
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00128-g.torture.execute-20030913-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030913-1)
+run(20030913-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00129-g.torture.execute-20030916-1/20030916-1.c b/testsuite/c_test/x64_be_enable_test/GCC00129-g.torture.execute-20030916-1/20030916-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b460c6dd68399d490037c985ba76d9dc74fca52
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00129-g.torture.execute-20030916-1/20030916-1.c
@@ -0,0 +1,35 @@
+/* "i" overflows in f().  Check that x[i] is not treated as a giv.  */
+#include <limits.h>
+
+#if CHAR_BIT == 8
+
+void f (unsigned int *x)
+{
+  unsigned char i;
+  int j;
+
+  i = 0x10;
+  for (j = 0; j < 0x10; j++)
+    {
+      i += 0xe8;
+      x[i] = 0;
+      i -= 0xe7;
+    }
+}
+
+int main ()
+{
+  unsigned int x[256];
+  int i;
+
+  for (i = 0; i < 256; i++)
+    x[i] = 1;
+  f (x);
+  for (i = 0; i < 256; i++)
+    if (x[i] != (i >= 0x08 && i < 0xf8))
+      abort ();
+  exit (0);
+}
+#else
+int main () { exit (0); }
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00129-g.torture.execute-20030916-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00129-g.torture.execute-20030916-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00129-g.torture.execute-20030916-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00129-g.torture.execute-20030916-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..41e72bcdc10f77d1603cbad229c6e11a62b58e5a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00129-g.torture.execute-20030916-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030916-1)
+run(20030916-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00130-g.torture.execute-20030920-1/20030920-1.c b/testsuite/c_test/x64_be_enable_test/GCC00130-g.torture.execute-20030920-1/20030920-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..2d22115c9fd92141744202e32863b961267a4aff
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00130-g.torture.execute-20030920-1/20030920-1.c
@@ -0,0 +1,15 @@
+extern void abort (void);
+
+int main()
+{
+  int hicount = 0;
+  unsigned char *c;
+  char *str = "\x7f\xff";
+  for (c = (unsigned char *)str; *c ; c++) {
+    if (!(((unsigned int)(*c)) < 0x80)) hicount++;
+  }
+  if (hicount != 1)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00130-g.torture.execute-20030920-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00130-g.torture.execute-20030920-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00130-g.torture.execute-20030920-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00130-g.torture.execute-20030920-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..451a22772db2e548ef466aaaf26ed9664720c29c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00130-g.torture.execute-20030920-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030920-1)
+run(20030920-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00131-g.torture.execute-20031003-1/20031003-1.c b/testsuite/c_test/x64_be_enable_test/GCC00131-g.torture.execute-20031003-1/20031003-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d39d799e50447d610368d561eb959595f5a8f50
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00131-g.torture.execute-20031003-1/20031003-1.c
@@ -0,0 +1,27 @@
+/* PR optimization/9325  */
+
+#include <limits.h>
+
+extern void abort (void);
+
+int f1()
+{
+  return (int)2147483648.0f;
+}
+
+int f2()
+{
+  return (int)(float)(2147483647);
+}
+
+int main()
+{
+#if INT_MAX == 2147483647
+  if (f1() != 2147483647)
+    abort ();
+  if (f2() != 2147483647)
+    abort ();
+#endif
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00131-g.torture.execute-20031003-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00131-g.torture.execute-20031003-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00131-g.torture.execute-20031003-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00131-g.torture.execute-20031003-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f999256260d838b488bc2d0fefdd9e4bfe1c800f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00131-g.torture.execute-20031003-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20031003-1)
+run(20031003-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00132-g.torture.execute-20031010-1/20031010-1.c b/testsuite/c_test/x64_be_enable_test/GCC00132-g.torture.execute-20031010-1/20031010-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..54457f964c338fd8bdd8fbc411ae1a08a97da9de
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00132-g.torture.execute-20031010-1/20031010-1.c
@@ -0,0 +1,34 @@
+/* A reminder to process ops in generate_expr_as_of_bb exactly once.  */
+
+long __attribute__((noinline))
+foo (long ct, long cf, _Bool p1, _Bool p2, _Bool p3)
+{
+  long diff;
+
+  diff = ct - cf;
+
+  if (p1)
+    {
+      if (p2)
+	{
+	  if (p3)
+	    {
+	      long tmp = ct;
+	      ct = cf;
+	      cf = tmp;
+	    }
+	  diff = ct - cf;
+	}
+
+      return diff;
+    }
+
+  abort ();
+}
+
+int main ()
+{
+  if (foo(2, 3, 1, 1, 1) == 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00132-g.torture.execute-20031010-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00132-g.torture.execute-20031010-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00132-g.torture.execute-20031010-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00132-g.torture.execute-20031010-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f0ac5b564a551680b207e3517054f29e01bfd5d1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00132-g.torture.execute-20031010-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20031010-1)
+run(20031010-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00133-g.torture.execute-20031012-1/20031012-1.c b/testsuite/c_test/x64_be_enable_test/GCC00133-g.torture.execute-20031012-1/20031012-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e02baf55cbc774e4155f00a8b6fc4f8f5dd782ec
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00133-g.torture.execute-20031012-1/20031012-1.c
@@ -0,0 +1,34 @@
+/* { dg-add-options stack_size } */
+
+/* PR optimization/8750
+   Used to fail under Cygwin with 
+   -O2 -fomit-frame-pointer        
+   Testcase by David B. Trout     */
+
+#if defined(STACK_SIZE) && STACK_SIZE < 16000
+#define ARRAY_SIZE (STACK_SIZE / 2)
+#define STRLEN	   (ARRAY_SIZE - 9)
+#else
+#define ARRAY_SIZE 15000
+#define STRLEN     13371
+#endif
+
+extern void *memset (void *, int, __SIZE_TYPE__);
+extern void abort (void);
+
+static void foo ()
+{
+    char a[ARRAY_SIZE];
+
+    a[0]=0;
+    memset( &a[0], 0xCD, STRLEN );
+    a[STRLEN]=0;
+    if (strlen(a) != STRLEN)
+      abort ();
+}
+
+int main ( int argc, char* argv[] )
+{
+    foo();
+    return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00133-g.torture.execute-20031012-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00133-g.torture.execute-20031012-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00133-g.torture.execute-20031012-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00133-g.torture.execute-20031012-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a59b88d0160181cd5ff81ed9f861cf4c4223b226
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00133-g.torture.execute-20031012-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20031012-1)
+run(20031012-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00134-g.torture.execute-20031201-1/20031201-1.c b/testsuite/c_test/x64_be_enable_test/GCC00134-g.torture.execute-20031201-1/20031201-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7c8e0ea290f76273f46182fafb4cd478cb8e4c4f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00134-g.torture.execute-20031201-1/20031201-1.c
@@ -0,0 +1,76 @@
+/* Copyright (C) 2003  Free Software Foundation.
+   PR target/13256
+   STRICT_LOW_PART was handled incorrectly in delay slots.
+   Origin: Hans-Peter Nilsson.  */
+
+typedef struct { unsigned int e0 : 16; unsigned int e1 : 16; } s1;
+typedef struct { unsigned int e0 : 16; unsigned int e1 : 16; } s2;
+typedef struct { s1 i12; s2 i16; } io;
+static int test_length = 2;
+static io *i;
+static int m = 1;
+static int d = 1;
+static unsigned long test_t0;
+static unsigned long test_t1;
+void test(void) __attribute__ ((__noinline__));
+extern int f1 (void *port) __attribute__ ((__noinline__));
+extern void f0 (void) __attribute__ ((__noinline__));
+int
+f1 (void *port)
+{
+  int fail_count = 0;
+  unsigned long tlen;
+  s1 x0 = {0};
+  s2 x1 = {0};
+
+  i = port;
+  x0.e0 = x1.e0 = 32;
+  i->i12 = x0;
+  i->i16 = x1;
+  do f0(); while (test_t1);
+  x0.e0 = x1.e0 = 8;
+  i->i12 = x0;
+  i->i16 = x1;
+  test ();
+  if (m)
+    {
+      unsigned long e = 1000000000 / 460800 * test_length;
+      tlen = test_t1 - test_t0;
+      if (((tlen-e) & 0x7FFFFFFF) > 1000)
+	f0();
+    }
+  if (d)
+    {
+      unsigned long e = 1000000000 / 460800 * test_length;
+      tlen = test_t1 - test_t0;
+      if (((tlen - e) & 0x7FFFFFFF) > 1000)
+	f0();
+    }
+  return fail_count != 0 ? 1 : 0;
+}
+
+int
+main ()
+{
+  io io0;
+  f1 (&io0);
+  abort ();
+}
+
+void
+test (void)
+{
+  io *iop = i;
+  if (iop->i12.e0 != 8 || iop->i16.e0 != 8)
+    abort ();
+  exit (0);
+}
+
+void
+f0 (void)
+{
+  static int washere = 0;
+  io *iop = i;
+  if (washere++ || iop->i12.e0 != 32 || iop->i16.e0 != 32)
+    abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00134-g.torture.execute-20031201-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00134-g.torture.execute-20031201-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00134-g.torture.execute-20031201-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00134-g.torture.execute-20031201-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84e12a1281d24b13e7089ab95f1cc87f7106b810
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00134-g.torture.execute-20031201-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20031201-1)
+run(20031201-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00135-g.torture.execute-20031211-1/20031211-1.c b/testsuite/c_test/x64_be_enable_test/GCC00135-g.torture.execute-20031211-1/20031211-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..2361509a096acae2027d74ec4dda6072da5216fb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00135-g.torture.execute-20031211-1/20031211-1.c
@@ -0,0 +1,13 @@
+struct a { unsigned int bitfield : 1; };
+
+unsigned int x;
+
+main()
+{
+  struct a a = {0};
+  x = 0xbeef;
+  a.bitfield |= x;
+  if (a.bitfield != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00135-g.torture.execute-20031211-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00135-g.torture.execute-20031211-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00135-g.torture.execute-20031211-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00135-g.torture.execute-20031211-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..22e242e284979b2f53457955a45eb796bf84c04e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00135-g.torture.execute-20031211-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20031211-1)
+run(20031211-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00136-g.torture.execute-20031211-2/20031211-2.c b/testsuite/c_test/x64_be_enable_test/GCC00136-g.torture.execute-20031211-2/20031211-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..555b17d9ac69d1cd50d7d033ddc7025359646ff2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00136-g.torture.execute-20031211-2/20031211-2.c
@@ -0,0 +1,19 @@
+struct a
+{
+  unsigned int bitfield : 3;
+};
+
+int main()
+{
+  struct a a;
+
+  a.bitfield = 131;
+  foo (a.bitfield);
+  exit (0);
+}
+
+foo(unsigned int z)
+{
+  if (z != 3)
+    abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00136-g.torture.execute-20031211-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00136-g.torture.execute-20031211-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00136-g.torture.execute-20031211-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00136-g.torture.execute-20031211-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4360ccffbbf2f9ab05ed94d200a1e6cdd4c6403e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00136-g.torture.execute-20031211-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20031211-2)
+run(20031211-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00137-g.torture.execute-20031214-1/20031214-1.c b/testsuite/c_test/x64_be_enable_test/GCC00137-g.torture.execute-20031214-1/20031214-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e52200c01e66234fcb3d62e463447889036a0065
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00137-g.torture.execute-20031214-1/20031214-1.c
@@ -0,0 +1,32 @@
+/* PR optimization/10312 */
+/* Originator: Peter van Hoof <p dot van-hoof at qub dot ac dot uk> */
+
+/* Verify that the strength reduction pass doesn't find
+   illegitimate givs.  */
+
+struct
+{
+  double a;
+  int n[2];
+} g = { 0., { 1, 2}};
+
+int k = 0;
+
+void
+b (int *j)
+{
+}
+
+int
+main ()
+{
+  int j;
+
+  for (j = 0; j < 2; j++)
+    k = (k > g.n[j]) ? k : g.n[j];
+
+  k++;
+  b (&j);
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00137-g.torture.execute-20031214-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00137-g.torture.execute-20031214-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00137-g.torture.execute-20031214-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00137-g.torture.execute-20031214-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1bfcc8d78372679f333172747db0ad7e3d40466e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00137-g.torture.execute-20031214-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20031214-1)
+run(20031214-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00138-g.torture.execute-20031215-1/20031215-1.c b/testsuite/c_test/x64_be_enable_test/GCC00138-g.torture.execute-20031215-1/20031215-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d62177b261877e093ce488ba3f2b36d831cfe21a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00138-g.torture.execute-20031215-1/20031215-1.c
@@ -0,0 +1,38 @@
+/* PR middle-end/13400 */
+/* The following test used to fail at run-time with a write to read-only
+   memory, caused by if-conversion converting a conditional write into an
+   unconditional write.  */
+
+typedef struct {int c, l; char ch[3];} pstr;
+const pstr ao = {2, 2, "OK"};
+const pstr * const a = &ao;
+
+void test1(void)
+{
+    if (a->ch[a->l]) {
+        ((char *)a->ch)[a->l] = 0;
+    }
+}
+
+void test2(void)
+{
+    if (a->ch[a->l]) {
+        ((char *)a->ch)[a->l] = -1;
+    }
+}
+
+void test3(void)
+{
+    if (a->ch[a->l]) {
+        ((char *)a->ch)[a->l] = 1;
+    }
+}
+
+int main(void)
+{
+    test1();
+    test2();
+    test3();
+    return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00138-g.torture.execute-20031215-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00138-g.torture.execute-20031215-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00138-g.torture.execute-20031215-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00138-g.torture.execute-20031215-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2519ecd128eed39bfe445b43c43683f6d8b405b8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00138-g.torture.execute-20031215-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20031215-1)
+run(20031215-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00139-g.torture.execute-20031216-1/20031216-1.c b/testsuite/c_test/x64_be_enable_test/GCC00139-g.torture.execute-20031216-1/20031216-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..709f0166a207b6a01581774782a262564e70481e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00139-g.torture.execute-20031216-1/20031216-1.c
@@ -0,0 +1,23 @@
+/* PR optimization/13313 */
+/* Origin: Mike Lerwill <mike@ml-solutions.co.uk> */
+
+extern void abort(void);
+
+void DisplayNumber (unsigned long v)
+{
+  if (v != 0x9aL)
+    abort();
+}
+
+unsigned long ReadNumber (void)
+{
+  return 0x009a0000L;
+}
+
+int main (void)
+{
+  unsigned long tmp;
+  tmp = (ReadNumber() & 0x00ff0000L) >> 16;
+  DisplayNumber (tmp);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00139-g.torture.execute-20031216-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00139-g.torture.execute-20031216-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00139-g.torture.execute-20031216-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00139-g.torture.execute-20031216-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ec2d5338b195326250e5f228d135349e78f9409f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00139-g.torture.execute-20031216-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20031216-1)
+run(20031216-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00140-g.torture.execute-20040223-1/20040223-1.c b/testsuite/c_test/x64_be_enable_test/GCC00140-g.torture.execute-20040223-1/20040223-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c295e4b09eaeda683e53f9acff83f01c4b425212
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00140-g.torture.execute-20040223-1/20040223-1.c
@@ -0,0 +1,17 @@
+/* { dg-require-effective-target alloca } */
+#include <string.h>
+#include <stdio.h>
+
+void
+a(void *x,int y)
+{
+  if (y != 1234)
+    abort ();
+}
+
+int
+main()
+{
+  a(strcpy(alloca(100),"abc"),1234);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00140-g.torture.execute-20040223-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00140-g.torture.execute-20040223-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00140-g.torture.execute-20040223-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00140-g.torture.execute-20040223-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a29aad11e4998aaa6e90cb080be2f6ba6ca5cbae
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00140-g.torture.execute-20040223-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040223-1)
+run(20040223-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00141-g.torture.execute-20040307-1/20040307-1.c b/testsuite/c_test/x64_be_enable_test/GCC00141-g.torture.execute-20040307-1/20040307-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8ab8008bb994af89ce6961940b8a215c54186e31
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00141-g.torture.execute-20040307-1/20040307-1.c
@@ -0,0 +1,25 @@
+int main()
+{
+  int b = 0;
+
+  struct {
+    unsigned int bit0:1;
+    unsigned int bit1:1;
+    unsigned int bit2:1;
+    unsigned int bit3:1;
+    unsigned int bit4:1;
+    unsigned int bit5:1;
+    unsigned int bit6:1;
+    unsigned int bit7:1;
+  } sdata = {0x01};
+
+  while ( sdata.bit0-- > 0 ) {
+    b++ ;
+    if ( b > 100 ) break;
+  }
+
+  if (b != 1)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00141-g.torture.execute-20040307-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00141-g.torture.execute-20040307-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00141-g.torture.execute-20040307-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00141-g.torture.execute-20040307-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e7a24fe807d4ee99a522f03b382a0948a3a0e84a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00141-g.torture.execute-20040307-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040307-1)
+run(20040307-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00142-g.torture.execute-20040311-1/20040311-1.c b/testsuite/c_test/x64_be_enable_test/GCC00142-g.torture.execute-20040311-1/20040311-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..013d869abf4de1f483d9ba815c703bfb686d9e19
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00142-g.torture.execute-20040311-1/20040311-1.c
@@ -0,0 +1,68 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that constant folding and RTL simplification of -(x >> y) doesn't
+   break anything and produces the expected results.
+
+   Written by Roger Sayle, 11th March 2004.  */
+
+extern void abort (void);
+
+#define INT_BITS  (sizeof(int)*8)
+
+int test1(int x)
+{
+  return -(x >> (INT_BITS-1));
+}
+
+int test2(unsigned int x)
+{
+  return -((int)(x >> (INT_BITS-1)));
+}
+
+int test3(int x)
+{
+  int y;
+  y = INT_BITS-1;
+  return -(x >> y);
+}
+
+int test4(unsigned int x)
+{
+  int y;
+  y = INT_BITS-1;
+  return -((int)(x >> y));
+}
+
+int main()
+{
+  if (test1(0) != 0)
+    abort ();
+  if (test1(1) != 0)
+    abort ();
+  if (test1(-1) != 1)
+    abort ();
+
+  if (test2(0) != 0)
+    abort ();
+  if (test2(1) != 0)
+    abort ();
+  if (test2((unsigned int)-1) != -1)
+    abort ();
+
+  if (test3(0) != 0)
+    abort ();
+  if (test3(1) != 0)
+    abort ();
+  if (test3(-1) != 1)
+    abort ();
+
+  if (test4(0) != 0)
+    abort ();
+  if (test4(1) != 0)
+    abort ();
+  if (test4((unsigned int)-1) != -1)
+    abort ();
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00142-g.torture.execute-20040311-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00142-g.torture.execute-20040311-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00142-g.torture.execute-20040311-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00142-g.torture.execute-20040311-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e6272b5b23423038dd2aec76bb7e5874cd6fca4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00142-g.torture.execute-20040311-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040311-1)
+run(20040311-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00143-g.torture.execute-20040319-1/20040319-1.c b/testsuite/c_test/x64_be_enable_test/GCC00143-g.torture.execute-20040319-1/20040319-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..357932d9b247abd7db2f8f9e6343f2ba9f32eea5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00143-g.torture.execute-20040319-1/20040319-1.c
@@ -0,0 +1,17 @@
+int
+blah (int zzz)
+{
+  int foo;
+  if (zzz >= 0)
+    return 1;
+  foo = (zzz >= 0 ? (zzz) : -(zzz));
+  return foo;
+}
+
+main()
+{
+  if (blah (-1) != 1)
+    abort ();
+  else
+    exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00143-g.torture.execute-20040319-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00143-g.torture.execute-20040319-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00143-g.torture.execute-20040319-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00143-g.torture.execute-20040319-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..73f3fbbc96af6062484de3867f2936cf837a1b13
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00143-g.torture.execute-20040319-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040319-1)
+run(20040319-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00144-g.torture.execute-20040331-1/20040331-1.c b/testsuite/c_test/x64_be_enable_test/GCC00144-g.torture.execute-20040331-1/20040331-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..2e8f9e86748883e7aa5a7e49b80149157221e676
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00144-g.torture.execute-20040331-1/20040331-1.c
@@ -0,0 +1,20 @@
+/* PR c++/14755 */
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+#if __INT_MAX__ >= 2147483647
+  struct { int count: 31; } s = { 0 };
+  while (s.count--)
+    abort ();
+#elif __INT_MAX__ >= 32767
+  struct { int count: 15; } s = { 0 };
+  while (s.count--)
+    abort ();
+#else
+  /* Don't bother because __INT_MAX__ is too small.  */
+#endif
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00144-g.torture.execute-20040331-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00144-g.torture.execute-20040331-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00144-g.torture.execute-20040331-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00144-g.torture.execute-20040331-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..92252314f3e8c3792d22095212ead5a3e9adcb4b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00144-g.torture.execute-20040331-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040331-1)
+run(20040331-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00145-g.torture.execute-20040409-1/20040409-1.c b/testsuite/c_test/x64_be_enable_test/GCC00145-g.torture.execute-20040409-1/20040409-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d9649ab5a19f6713a24691ceb01fefca3d66ae2f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00145-g.torture.execute-20040409-1/20040409-1.c
@@ -0,0 +1,112 @@
+#include <limits.h>
+
+extern void abort ();
+
+int test1(int x)
+{
+  return x ^ INT_MIN;
+}
+
+unsigned int test1u(unsigned int x)
+{
+  return x ^ (unsigned int)INT_MIN;
+}
+
+unsigned int test2u(unsigned int x)
+{
+  return x + (unsigned int)INT_MIN;
+}
+
+unsigned int test3u(unsigned int x)
+{
+  return x - (unsigned int)INT_MIN;
+}
+
+int test4(int x)
+{
+  int y = INT_MIN;
+  return x ^ y;
+}
+
+unsigned int test4u(unsigned int x)
+{
+  unsigned int y = (unsigned int)INT_MIN;
+  return x ^ y;
+}
+
+unsigned int test5u(unsigned int x)
+{
+  unsigned int y = (unsigned int)INT_MIN;
+  return x + y;
+}
+
+unsigned int test6u(unsigned int x)
+{
+  unsigned int y = (unsigned int)INT_MIN;
+  return x - y;
+}
+
+
+
+void test(int a, int b)
+{
+  if (test1(a) != b)
+    abort();
+  if (test4(a) != b)
+    abort();
+}
+
+void testu(unsigned int a, unsigned int b)
+{
+  if (test1u(a) != b)
+    abort();
+  if (test2u(a) != b)
+    abort();
+  if (test3u(a) != b)
+    abort();
+  if (test4u(a) != b)
+    abort();
+  if (test5u(a) != b)
+    abort();
+  if (test6u(a) != b)
+    abort();
+}
+
+
+int main()
+{
+#if INT_MAX == 2147483647
+  test(0x00000000,0x80000000);
+  test(0x80000000,0x00000000);
+  test(0x12345678,0x92345678);
+  test(0x92345678,0x12345678);
+  test(0x7fffffff,0xffffffff);
+  test(0xffffffff,0x7fffffff);
+
+  testu(0x00000000,0x80000000);
+  testu(0x80000000,0x00000000);
+  testu(0x12345678,0x92345678);
+  testu(0x92345678,0x12345678);
+  testu(0x7fffffff,0xffffffff);
+  testu(0xffffffff,0x7fffffff);
+#endif
+
+#if INT_MAX == 32767
+  test(0x0000,0x8000);
+  test(0x8000,0x0000);
+  test(0x1234,0x9234);
+  test(0x9234,0x1234);
+  test(0x7fff,0xffff);
+  test(0xffff,0x7fff);
+
+  testu(0x0000,0x8000);
+  testu(0x8000,0x0000);
+  testu(0x1234,0x9234);
+  testu(0x9234,0x1234);
+  testu(0x7fff,0xffff);
+  testu(0xffff,0x7fff);
+#endif
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00145-g.torture.execute-20040409-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00145-g.torture.execute-20040409-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00145-g.torture.execute-20040409-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00145-g.torture.execute-20040409-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2062c6251db458c201628e54a6c79653bff97154
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00145-g.torture.execute-20040409-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040409-1)
+run(20040409-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00146-g.torture.execute-20040409-1w/20040409-1w.c b/testsuite/c_test/x64_be_enable_test/GCC00146-g.torture.execute-20040409-1w/20040409-1w.c
new file mode 100644
index 0000000000000000000000000000000000000000..bd0157dd8f09f46361bc6c069983c4a863be7e87
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00146-g.torture.execute-20040409-1w/20040409-1w.c
@@ -0,0 +1,65 @@
+/* { dg-additional-options "-fwrapv" } */
+
+#include <limits.h>
+
+extern void abort ();
+
+int test2(int x)
+{
+  return x + INT_MIN;
+}
+
+int test3(int x)
+{
+  return x - INT_MIN;
+}
+
+int test5(int x)
+{
+  int y = INT_MIN;
+  return x + y;
+}
+
+int test6(int x)
+{
+  int y = INT_MIN;
+  return x - y;
+}
+
+
+
+void test(int a, int b)
+{
+  if (test2(a) != b)
+    abort();
+  if (test3(a) != b)
+    abort();
+  if (test5(a) != b)
+    abort();
+  if (test6(a) != b)
+    abort();
+}
+
+
+int main()
+{
+#if INT_MAX == 2147483647
+  test(0x00000000,0x80000000);
+  test(0x80000000,0x00000000);
+  test(0x12345678,0x92345678);
+  test(0x92345678,0x12345678);
+  test(0x7fffffff,0xffffffff);
+  test(0xffffffff,0x7fffffff);
+#endif
+
+#if INT_MAX == 32767
+  test(0x0000,0x8000);
+  test(0x8000,0x0000);
+  test(0x1234,0x9234);
+  test(0x9234,0x1234);
+  test(0x7fff,0xffff);
+  test(0xffff,0x7fff);
+#endif
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00146-g.torture.execute-20040409-1w/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00146-g.torture.execute-20040409-1w/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00146-g.torture.execute-20040409-1w/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00146-g.torture.execute-20040409-1w/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b066d704d152a8c4904f8e74e52da95a391ff9e7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00146-g.torture.execute-20040409-1w/test.cfg
@@ -0,0 +1,2 @@
+compile(20040409-1w)
+run(20040409-1w)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00147-g.torture.execute-20040409-2/20040409-2.c b/testsuite/c_test/x64_be_enable_test/GCC00147-g.torture.execute-20040409-2/20040409-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..c04c7be373963b96d548497d9244a727c67cc19a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00147-g.torture.execute-20040409-2/20040409-2.c
@@ -0,0 +1,179 @@
+#include <limits.h>
+
+extern void abort ();
+
+int test1(int x)
+{
+  return (x ^ INT_MIN) ^ 0x1234;
+}
+
+unsigned int test1u(unsigned int x)
+{
+  return (x ^ (unsigned int)INT_MIN) ^ 0x1234;
+}
+
+int test2(int x)
+{
+  return (x ^ 0x1234) ^ INT_MIN;
+}
+
+unsigned int test2u(unsigned int x)
+{
+  return (x ^ 0x1234) ^ (unsigned int)INT_MIN;
+}
+
+unsigned int test3u(unsigned int x)
+{
+  return (x + (unsigned int)INT_MIN) ^ 0x1234;
+}
+
+unsigned int test4u(unsigned int x)
+{
+  return (x ^ 0x1234) + (unsigned int)INT_MIN;
+}
+
+unsigned int test5u(unsigned int x)
+{
+  return (x - (unsigned int)INT_MIN) ^ 0x1234;
+}
+
+unsigned int test6u(unsigned int x)
+{
+  return (x ^ 0x1234) - (unsigned int)INT_MIN;
+}
+
+int test7(int x)
+{
+  int y = INT_MIN;
+  int z = 0x1234;
+  return (x ^ y) ^ z;
+}
+
+unsigned int test7u(unsigned int x)
+{
+  unsigned int y = (unsigned int)INT_MIN;
+  unsigned int z = 0x1234;
+  return (x ^ y) ^ z;
+}
+
+int test8(int x)
+{
+  int y = 0x1234;
+  int z = INT_MIN;
+  return (x ^ y) ^ z;
+}
+
+unsigned int test8u(unsigned int x)
+{
+  unsigned int y = 0x1234;
+  unsigned int z = (unsigned int)INT_MIN;
+  return (x ^ y) ^ z;
+}
+
+unsigned int test9u(unsigned int x)
+{
+  unsigned int y = (unsigned int)INT_MIN;
+  unsigned int z = 0x1234;
+  return (x + y) ^ z;
+}
+
+unsigned int test10u(unsigned int x)
+{
+  unsigned int y = 0x1234;
+  unsigned int z = (unsigned int)INT_MIN;
+  return (x ^ y) + z;
+}
+
+unsigned int test11u(unsigned int x)
+{
+  unsigned int y = (unsigned int)INT_MIN;
+  unsigned int z = 0x1234;
+  return (x - y) ^ z;
+}
+
+unsigned int test12u(unsigned int x)
+{
+  unsigned int y = 0x1234;
+  unsigned int z = (unsigned int)INT_MIN;
+  return (x ^ y) - z;
+}
+
+
+void test(int a, int b)
+{
+  if (test1(a) != b)
+    abort();
+  if (test2(a) != b)
+    abort();
+  if (test7(a) != b)
+    abort();
+  if (test8(a) != b)
+    abort();
+}
+
+void testu(unsigned int a, unsigned int b)
+{
+  if (test1u(a) != b)
+    abort();
+  if (test2u(a) != b)
+    abort();
+  if (test3u(a) != b)
+    abort();
+  if (test4u(a) != b)
+    abort();
+  if (test5u(a) != b)
+    abort();
+  if (test6u(a) != b)
+    abort();
+  if (test7u(a) != b)
+    abort();
+  if (test8u(a) != b)
+    abort();
+  if (test9u(a) != b)
+    abort();
+  if (test10u(a) != b)
+    abort();
+  if (test11u(a) != b)
+    abort();
+  if (test12u(a) != b)
+    abort();
+}
+
+
+int main()
+{
+#if INT_MAX == 2147483647
+  test(0x00000000,0x80001234);
+  test(0x00001234,0x80000000);
+  test(0x80000000,0x00001234);
+  test(0x80001234,0x00000000);
+  test(0x7fffffff,0xffffedcb);
+  test(0xffffffff,0x7fffedcb);
+
+  testu(0x00000000,0x80001234);
+  testu(0x00001234,0x80000000);
+  testu(0x80000000,0x00001234);
+  testu(0x80001234,0x00000000);
+  testu(0x7fffffff,0xffffedcb);
+  testu(0xffffffff,0x7fffedcb);
+#endif
+
+#if INT_MAX == 32767
+  test(0x0000,0x9234);
+  test(0x1234,0x8000);
+  test(0x8000,0x1234);
+  test(0x9234,0x0000);
+  test(0x7fff,0xedcb);
+  test(0xffff,0x6dcb);
+
+  testu(0x0000,0x9234);
+  testu(0x8000,0x1234);
+  testu(0x1234,0x8000);
+  testu(0x9234,0x0000);
+  testu(0x7fff,0xedcb);
+  testu(0xffff,0x6dcb);
+#endif
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00147-g.torture.execute-20040409-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00147-g.torture.execute-20040409-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00147-g.torture.execute-20040409-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00147-g.torture.execute-20040409-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1fa73c0d16d889077fcb82280c41fd322108759d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00147-g.torture.execute-20040409-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20040409-2)
+run(20040409-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00148-g.torture.execute-20040409-2w/20040409-2w.c b/testsuite/c_test/x64_be_enable_test/GCC00148-g.torture.execute-20040409-2w/20040409-2w.c
new file mode 100644
index 0000000000000000000000000000000000000000..f6c5f2c45d95a4ee82ebd7e05cefd4f0c1ea7ba9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00148-g.torture.execute-20040409-2w/20040409-2w.c
@@ -0,0 +1,99 @@
+/* { dg-additional-options "-fwrapv" } */
+
+#include <limits.h>
+
+extern void abort ();
+
+int test3(int x)
+{
+  return (x + INT_MIN) ^ 0x1234;
+}
+
+int test4(int x)
+{
+  return (x ^ 0x1234) + INT_MIN;
+}
+
+int test5(int x)
+{
+  return (x - INT_MIN) ^ 0x1234;
+}
+
+int test6(int x)
+{
+  return (x ^ 0x1234) - INT_MIN;
+}
+
+int test9(int x)
+{
+  int y = INT_MIN;
+  int z = 0x1234;
+  return (x + y) ^ z;
+}
+
+int test10(int x)
+{
+  int y = 0x1234;
+  int z = INT_MIN;
+  return (x ^ y) + z;
+}
+
+int test11(int x)
+{
+  int y = INT_MIN;
+  int z = 0x1234;
+  return (x - y) ^ z;
+}
+
+int test12(int x)
+{
+  int y = 0x1234;
+  int z = INT_MIN;
+  return (x ^ y) - z;
+}
+
+
+void test(int a, int b)
+{
+  if (test3(a) != b)
+    abort();
+  if (test4(a) != b)
+    abort();
+  if (test5(a) != b)
+    abort();
+  if (test6(a) != b)
+    abort();
+  if (test9(a) != b)
+    abort();
+  if (test10(a) != b)
+    abort();
+  if (test11(a) != b)
+    abort();
+  if (test12(a) != b)
+    abort();
+}
+
+
+int main()
+{
+#if INT_MAX == 2147483647
+  test(0x00000000,0x80001234);
+  test(0x00001234,0x80000000);
+  test(0x80000000,0x00001234);
+  test(0x80001234,0x00000000);
+  test(0x7fffffff,0xffffedcb);
+  test(0xffffffff,0x7fffedcb);
+#endif
+
+#if INT_MAX == 32767
+  test(0x0000,0x9234);
+  test(0x1234,0x8000);
+  test(0x8000,0x1234);
+  test(0x9234,0x0000);
+  test(0x7fff,0xedcb);
+  test(0xffff,0x6dcb);
+#endif
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00148-g.torture.execute-20040409-2w/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00148-g.torture.execute-20040409-2w/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00148-g.torture.execute-20040409-2w/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00148-g.torture.execute-20040409-2w/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68807f32fde5bbb816ed7e438d0e9c0b7317409b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00148-g.torture.execute-20040409-2w/test.cfg
@@ -0,0 +1,2 @@
+compile(20040409-2w)
+run(20040409-2w)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00149-g.torture.execute-20040409-3/20040409-3.c b/testsuite/c_test/x64_be_enable_test/GCC00149-g.torture.execute-20040409-3/20040409-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..279cab1803b65ffb8bab282869c0d289f422add2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00149-g.torture.execute-20040409-3/20040409-3.c
@@ -0,0 +1,112 @@
+#include <limits.h>
+
+extern void abort ();
+
+int test1(int x)
+{
+  return ~(x ^ INT_MIN);
+}
+
+unsigned int test1u(unsigned int x)
+{
+  return ~(x ^ (unsigned int)INT_MIN);
+}
+
+unsigned int test2u(unsigned int x)
+{
+  return ~(x + (unsigned int)INT_MIN);
+}
+
+unsigned int test3u(unsigned int x)
+{
+  return ~(x - (unsigned int)INT_MIN);
+}
+
+int test4(int x)
+{
+  int y = INT_MIN;
+  return ~(x ^ y);
+}
+
+unsigned int test4u(unsigned int x)
+{
+  unsigned int y = (unsigned int)INT_MIN;
+  return ~(x ^ y);
+}
+
+unsigned int test5u(unsigned int x)
+{
+  unsigned int y = (unsigned int)INT_MIN;
+  return ~(x + y);
+}
+
+unsigned int test6u(unsigned int x)
+{
+  unsigned int y = (unsigned int)INT_MIN;
+  return ~(x - y);
+}
+
+
+
+void test(int a, int b)
+{
+  if (test1(a) != b)
+    abort();
+  if (test4(a) != b)
+    abort();
+}
+
+void testu(unsigned int a, unsigned int b)
+{
+  if (test1u(a) != b)
+    abort();
+  if (test2u(a) != b)
+    abort();
+  if (test3u(a) != b)
+    abort();
+  if (test4u(a) != b)
+    abort();
+  if (test5u(a) != b)
+    abort();
+  if (test6u(a) != b)
+    abort();
+}
+
+
+int main()
+{
+#if INT_MAX == 2147483647
+  test(0x00000000,0x7fffffff);
+  test(0x80000000,0xffffffff);
+  test(0x12345678,0x6dcba987);
+  test(0x92345678,0xedcba987);
+  test(0x7fffffff,0x00000000);
+  test(0xffffffff,0x80000000);
+
+  testu(0x00000000,0x7fffffff);
+  testu(0x80000000,0xffffffff);
+  testu(0x12345678,0x6dcba987);
+  testu(0x92345678,0xedcba987);
+  testu(0x7fffffff,0x00000000);
+  testu(0xffffffff,0x80000000);
+#endif
+
+#if INT_MAX == 32767
+  test(0x0000,0x7fff);
+  test(0x8000,0xffff);
+  test(0x1234,0x6dcb);
+  test(0x9234,0xedcb);
+  test(0x7fff,0x0000);
+  test(0xffff,0x8000);
+
+  testu(0x0000,0x7fff);
+  testu(0x8000,0xffff);
+  testu(0x1234,0x6dcb);
+  testu(0x9234,0xedcb);
+  testu(0x7fff,0x0000);
+  testu(0xffff,0x8000);
+#endif
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00149-g.torture.execute-20040409-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00149-g.torture.execute-20040409-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00149-g.torture.execute-20040409-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00149-g.torture.execute-20040409-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9b37617211442272dd6e5801421a5e03bf68d723
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00149-g.torture.execute-20040409-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20040409-3)
+run(20040409-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00150-g.torture.execute-20040409-3w/20040409-3w.c b/testsuite/c_test/x64_be_enable_test/GCC00150-g.torture.execute-20040409-3w/20040409-3w.c
new file mode 100644
index 0000000000000000000000000000000000000000..3a1883d51d59a322e3441b7ea38dae8319e816ce
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00150-g.torture.execute-20040409-3w/20040409-3w.c
@@ -0,0 +1,65 @@
+/* { dg-additional-options "-fwrapv" } */
+
+#include <limits.h>
+
+extern void abort ();
+
+int test2(int x)
+{
+  return ~(x + INT_MIN);
+}
+
+int test3(int x)
+{
+  return ~(x - INT_MIN);
+}
+
+int test5(int x)
+{
+  int y = INT_MIN;
+  return ~(x + y);
+}
+
+int test6(int x)
+{
+  int y = INT_MIN;
+  return ~(x - y);
+}
+
+
+void test(int a, int b)
+{
+  if (test2(a) != b)
+    abort();
+  if (test3(a) != b)
+    abort();
+  if (test5(a) != b)
+    abort();
+  if (test6(a) != b)
+    abort();
+}
+
+
+int main()
+{
+#if INT_MAX == 2147483647
+  test(0x00000000,0x7fffffff);
+  test(0x80000000,0xffffffff);
+  test(0x12345678,0x6dcba987);
+  test(0x92345678,0xedcba987);
+  test(0x7fffffff,0x00000000);
+  test(0xffffffff,0x80000000);
+#endif
+
+#if INT_MAX == 32767
+  test(0x0000,0x7fff);
+  test(0x8000,0xffff);
+  test(0x1234,0x6dcb);
+  test(0x9234,0xedcb);
+  test(0x7fff,0x0000);
+  test(0xffff,0x8000);
+#endif
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00150-g.torture.execute-20040409-3w/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00150-g.torture.execute-20040409-3w/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00150-g.torture.execute-20040409-3w/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00150-g.torture.execute-20040409-3w/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1d2333f6420c2b03d5ec75d7df1c3e15997fc143
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00150-g.torture.execute-20040409-3w/test.cfg
@@ -0,0 +1,2 @@
+compile(20040409-3w)
+run(20040409-3w)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00151-g.torture.execute-20040625-1/20040625-1.c b/testsuite/c_test/x64_be_enable_test/GCC00151-g.torture.execute-20040625-1/20040625-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c426055db7265b58e41814b578e04b68515e12d5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00151-g.torture.execute-20040625-1/20040625-1.c
@@ -0,0 +1,20 @@
+/* From PR target/16176 */
+struct __attribute__ ((packed)) s { struct s *next; };
+
+struct s * __attribute__ ((noinline))
+maybe_next (struct s *s, int t)
+{
+  if (t)
+    s = s->next;
+  return s;
+}
+
+int main ()
+{
+  struct s s1, s2;
+
+  s1.next = &s2;
+  if (maybe_next (&s1, 1) != &s2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00151-g.torture.execute-20040625-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00151-g.torture.execute-20040625-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00151-g.torture.execute-20040625-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00151-g.torture.execute-20040625-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f62077e7cd908dcc50f93b32819f6c9ba1d04300
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00151-g.torture.execute-20040625-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040625-1)
+run(20040625-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00152-g.torture.execute-20040704-1/20040704-1.c b/testsuite/c_test/x64_be_enable_test/GCC00152-g.torture.execute-20040704-1/20040704-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c6b23d03258de6aefd0a175d14dbd0ea2bdc6d70
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00152-g.torture.execute-20040704-1/20040704-1.c
@@ -0,0 +1,14 @@
+/* PR 16348: Make sure that condition-first false loops DTRT.  */
+
+extern void abort ();
+
+int main()
+{
+  for (; 0 ;)
+    {
+      abort ();
+    label:
+      return 0;
+    }
+  goto label;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00152-g.torture.execute-20040704-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00152-g.torture.execute-20040704-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00152-g.torture.execute-20040704-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00152-g.torture.execute-20040704-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a095c9cd590198a14ef399802bb08da2516b236b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00152-g.torture.execute-20040704-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040704-1)
+run(20040704-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00153-g.torture.execute-20040805-1/20040805-1.c b/testsuite/c_test/x64_be_enable_test/GCC00153-g.torture.execute-20040805-1/20040805-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f31109266b1488da93404ca60b393cf673fdc1a1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00153-g.torture.execute-20040805-1/20040805-1.c
@@ -0,0 +1,33 @@
+/* { dg-require-stack-size "0x12000" } */
+
+#if __INT_MAX__ < 32768
+int main () { exit (0); }
+#else
+int a[2] = { 2, 3 };
+
+static int __attribute__((noinline))
+bar (int x, void *b)
+{
+  a[0]++;
+  return x;
+}
+
+static int __attribute__((noinline))
+foo (int x)
+{
+  char buf[0x10000];
+  int y = a[0];
+  a[1] = y;
+  x = bar (x, buf);
+  y = bar (y, buf);
+  return x + y;
+}
+
+int
+main ()
+{
+  if (foo (100) != 102)
+    abort ();
+  exit (0);
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00153-g.torture.execute-20040805-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00153-g.torture.execute-20040805-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00153-g.torture.execute-20040805-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00153-g.torture.execute-20040805-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8e82aea881391c2aa2c003c0bb51588ad44e2064
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00153-g.torture.execute-20040805-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040805-1)
+run(20040805-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00154-g.torture.execute-20040823-1/20040823-1.c b/testsuite/c_test/x64_be_enable_test/GCC00154-g.torture.execute-20040823-1/20040823-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..83bf4027a94ccbc7932f7e85849ccd8dac1eee69
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00154-g.torture.execute-20040823-1/20040823-1.c
@@ -0,0 +1,29 @@
+/* Ensure that we create VUSE operands also for noreturn functions.  */
+
+#include <stdlib.h>
+#include <string.h>
+
+int *pwarn;
+
+void bla (void) __attribute__ ((noreturn));
+
+void bla (void)
+{
+  if (!*pwarn)
+    abort ();
+    
+  exit (0);
+}
+
+int main (void)
+{
+  int warn;
+
+  memset (&warn, 0, sizeof (warn));
+
+  pwarn = &warn;
+
+  warn = 1;
+
+  bla ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00154-g.torture.execute-20040823-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00154-g.torture.execute-20040823-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00154-g.torture.execute-20040823-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00154-g.torture.execute-20040823-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..049f5c3b5cee8ea03095b6feebf5fd776fd2264d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00154-g.torture.execute-20040823-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040823-1)
+run(20040823-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00155-g.torture.execute-20040917-1/20040917-1.c b/testsuite/c_test/x64_be_enable_test/GCC00155-g.torture.execute-20040917-1/20040917-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..73bc6c6479c666e81a4d1d4c8bed6866bd7875d5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00155-g.torture.execute-20040917-1/20040917-1.c
@@ -0,0 +1,32 @@
+/* submitted by kenneth zadeck */
+
+static int test_var;
+
+/* the idea here is that not only is inlinable, inlinable but since it
+   is static, the cgraph node will not be marked as output.  The
+   current version of the code ignores these cgraph nodes.  */
+
+void not_inlinable()  __attribute__((noinline));
+
+static void  
+inlinable ()
+{
+  test_var = -10;
+}
+
+void 
+not_inlinable ()
+{
+  inlinable();
+}
+
+main ()
+{
+  test_var = 10;
+  /* Variable test_var should be considered call-clobbered by the call
+     to not_inlinable().  */
+  not_inlinable ();
+  if (test_var == 10)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00155-g.torture.execute-20040917-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00155-g.torture.execute-20040917-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00155-g.torture.execute-20040917-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00155-g.torture.execute-20040917-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..08e70ddf3a8f41f6e879835a3b4f3710a70d61a5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00155-g.torture.execute-20040917-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20040917-1)
+run(20040917-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00156-g.torture.execute-20041019-1/20041019-1.c b/testsuite/c_test/x64_be_enable_test/GCC00156-g.torture.execute-20041019-1/20041019-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3c56b31e9ceb919a1d6ce4f7fdd433882e2bde78
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00156-g.torture.execute-20041019-1/20041019-1.c
@@ -0,0 +1,52 @@
+test_store_ccp (int i)
+{
+  int *p, a, b, c;
+
+  if (i < 5)
+    p = &a;
+  else if (i > 8)
+    p = &b;
+  else
+    p = &c;
+
+  *p = 10;
+  b = 3;
+
+  /* STORE-CCP was wrongfully propagating 10 into *p.  */
+  return *p + 2;
+}
+
+
+test_store_copy_prop (int i)
+{
+  int *p, a, b, c;
+
+  if (i < 5)
+    p = &a;
+  else if (i > 8)
+    p = &b;
+  else
+    p = &c;
+
+  *p = i;
+  b = i + 1;
+
+  /* STORE-COPY-PROP was wrongfully propagating i into *p.  */
+  return *p;
+}
+
+
+main()
+{
+  int x;
+  
+  x = test_store_ccp (10);
+  if (x == 12)
+    abort ();
+  
+  x = test_store_copy_prop (9);
+  if (x == 9)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00156-g.torture.execute-20041019-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00156-g.torture.execute-20041019-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00156-g.torture.execute-20041019-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00156-g.torture.execute-20041019-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d132e06e9b601695249f58dd7ae7e3c129fc3992
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00156-g.torture.execute-20041019-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20041019-1)
+run(20041019-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00157-g.torture.execute-20041112-1/20041112-1.c b/testsuite/c_test/x64_be_enable_test/GCC00157-g.torture.execute-20041112-1/20041112-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c6251ca34e3dd27cb7fe331df07bf6273062adf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00157-g.torture.execute-20041112-1/20041112-1.c
@@ -0,0 +1,40 @@
+/* This was failing on Alpha because the comparison (p != -1) was rewritten
+   as (p+1 != 0) and p+1 isn't allowed to wrap for pointers.  */
+
+extern void abort(void);
+
+typedef __SIZE_TYPE__ size_t;
+
+int global;
+
+static void *foo(int p)
+{
+  if (p == 0)
+   {
+      global++;
+      return &global;
+   }
+
+  return (void *)(size_t)-1;
+}
+
+int bar(void)
+{
+  void *p;
+
+  p = foo(global);
+  if (p != (void *)(size_t)-1)
+    return 1;
+
+  global++;
+  return 0;
+}
+
+int main(void)
+{
+  global = 1;
+  if (bar () != 0)
+    abort();
+  
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00157-g.torture.execute-20041112-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00157-g.torture.execute-20041112-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00157-g.torture.execute-20041112-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00157-g.torture.execute-20041112-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..adcace44d1521fccb294892f66754dc9cbd733fa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00157-g.torture.execute-20041112-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20041112-1)
+run(20041112-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00158-g.torture.execute-20041126-1/20041126-1.c b/testsuite/c_test/x64_be_enable_test/GCC00158-g.torture.execute-20041126-1/20041126-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..58855ae8c195a397a9afd884b96654107ba69572
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00158-g.torture.execute-20041126-1/20041126-1.c
@@ -0,0 +1,26 @@
+extern int abs (int);
+extern void abort (void);
+
+void
+check (int *p)
+{
+  int i;
+  for (i = 0; i < 5; ++i)
+    if (p[i])
+      abort ();
+  for (; i < 10; ++i)
+    if (p[i] != i + 1)
+      abort ();
+}
+
+int
+main (void)
+{
+  int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+  int i;
+
+  for (i = -5; i < 0; i++)
+    a[abs (i - 10) - 11] = 0;
+  check (a);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00158-g.torture.execute-20041126-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00158-g.torture.execute-20041126-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00158-g.torture.execute-20041126-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00158-g.torture.execute-20041126-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3f0446e725ebd53b8cb361b5acdc06186978d3dc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00158-g.torture.execute-20041126-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20041126-1)
+run(20041126-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00159-g.torture.execute-20041210-1/20041210-1.c b/testsuite/c_test/x64_be_enable_test/GCC00159-g.torture.execute-20041210-1/20041210-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ef266a0a2e83dd7aa252e40f93e40e6df4ce4ba2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00159-g.torture.execute-20041210-1/20041210-1.c
@@ -0,0 +1,14 @@
+/* The FR-V port used to fail this test because the andcc patterns
+   wrongly claimed to set the C and V flags.  */
+#include <limits.h>
+
+int x[4] = { INT_MIN / 2, INT_MAX, 2, 4 };
+
+int
+main ()
+{
+  if (x[0] < x[1])
+    if ((x[2] & x[3]) < 0)
+      abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00159-g.torture.execute-20041210-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00159-g.torture.execute-20041210-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00159-g.torture.execute-20041210-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00159-g.torture.execute-20041210-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa5e6dd6d197e0184dc7430546e206a11d2adce9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00159-g.torture.execute-20041210-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20041210-1)
+run(20041210-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00160-g.torture.execute-20041212-1/20041212-1.c b/testsuite/c_test/x64_be_enable_test/GCC00160-g.torture.execute-20041212-1/20041212-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ea2d0fbd78e9fed18b913e26a545b47c560c2291
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00160-g.torture.execute-20041212-1/20041212-1.c
@@ -0,0 +1,15 @@
+/* A function pointer compared with a void pointer should not be canonicalized.
+   See PR middle-end/17564.  */
+void *f (void) __attribute__ ((__noinline__));
+void *
+f (void)
+{
+  return f;
+}
+int
+main (void)
+{
+  if (f () != f)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00160-g.torture.execute-20041212-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00160-g.torture.execute-20041212-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00160-g.torture.execute-20041212-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00160-g.torture.execute-20041212-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84d4845eb9d84c6e9418d79d6e62518c57468460
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00160-g.torture.execute-20041212-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20041212-1)
+run(20041212-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00161-g.torture.execute-20041218-1/20041218-1.c b/testsuite/c_test/x64_be_enable_test/GCC00161-g.torture.execute-20041218-1/20041218-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d113e4557cae2e21e0374bef400d227f7f1cff1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00161-g.torture.execute-20041218-1/20041218-1.c
@@ -0,0 +1,117 @@
+/* PR rtl-optimization/16968 */
+/* Testcase by Jakub Jelinek  <jakub@redhat.com> */
+
+struct T
+{
+  unsigned int b, c, *d;
+  unsigned char e;
+};
+struct S
+{
+  unsigned int a;
+  struct T f;
+};
+struct U
+{
+  struct S g, h;
+};
+struct V
+{
+  unsigned int i;
+  struct U j;
+};
+
+extern void exit (int);
+extern void abort (void);
+
+void *
+dummy1 (void *x)
+{
+  return "";
+}
+
+void *
+dummy2 (void *x, void *y)
+{
+  exit (0);
+}
+
+struct V *
+baz (unsigned int x)
+{
+  static struct V v;
+  __builtin_memset (&v, 0x55, sizeof (v));
+  return &v;
+}
+
+int
+check (void *x, struct S *y)
+{
+  if (y->a || y->f.b || y->f.c || y->f.d || y->f.e)
+    abort ();
+  return 1;
+}
+
+static struct V *
+bar (unsigned int x, void *y)
+{
+  const struct T t = { 0, 0, (void *) 0, 0 };
+  struct V *u;
+  void *v;
+  v = dummy1 (y);
+  if (!v)
+    return (void *) 0;
+
+  u = baz (sizeof (struct V));
+  u->i = x;
+  u->j.g.a = 0;
+  u->j.g.f = t;
+  u->j.h.a = 0;
+  u->j.h.f = t;
+
+  if (!check (v, &u->j.g) || !check (v, &u->j.h))
+    return (void *) 0;
+  return u;
+}
+
+int
+foo (unsigned int *x, unsigned int y, void **z)
+{
+  void *v;
+  unsigned int i, j;
+
+  *z = v = (void *) 0;
+
+  for (i = 0; i < y; i++)
+    {
+      struct V *c;
+
+      j = *x;
+
+      switch (j)
+	{
+	case 1:
+	  c = bar (j, x);
+	  break;
+	default:
+	  c = 0;
+	  break;
+	}
+      if (c)
+	v = dummy2 (v, c);
+      else
+        return 1;
+    }
+
+  *z = v;
+  return 0;
+}
+
+int
+main (void)
+{
+  unsigned int one = 1;
+  void *p;
+  foo (&one, 1, &p);
+  abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00161-g.torture.execute-20041218-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00161-g.torture.execute-20041218-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00161-g.torture.execute-20041218-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00161-g.torture.execute-20041218-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..20037601339f14775523d5b8d67bfaaeb0883acf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00161-g.torture.execute-20041218-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20041218-1)
+run(20041218-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00162-g.torture.execute-20050104-1/20050104-1.c b/testsuite/c_test/x64_be_enable_test/GCC00162-g.torture.execute-20050104-1/20050104-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6083e9c0686f006e4e0572df3e6e155573dced28
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00162-g.torture.execute-20050104-1/20050104-1.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/19060 */
+
+void abort (void);
+
+static
+long long min ()
+{
+  return -__LONG_LONG_MAX__ - 1;
+}
+
+void
+foo (long long j)
+{
+  if (j > 10 || j < min ())
+    abort ();
+}
+
+int
+main (void)
+{
+  foo (10);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00162-g.torture.execute-20050104-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00162-g.torture.execute-20050104-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00162-g.torture.execute-20050104-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00162-g.torture.execute-20050104-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a96ab512106ec6442bc3340489c376c56e6da976
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00162-g.torture.execute-20050104-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050104-1)
+run(20050104-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00163-g.torture.execute-20050107-1/20050107-1.c b/testsuite/c_test/x64_be_enable_test/GCC00163-g.torture.execute-20050107-1/20050107-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..903c54a25e6a3abfc0e8007ba0025057fcac18f4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00163-g.torture.execute-20050107-1/20050107-1.c
@@ -0,0 +1,25 @@
+typedef enum { C = 1, D = 2 } B;
+extern void abort (void);
+
+struct S
+{
+  B __attribute__ ((mode (byte))) a;
+  B __attribute__ ((mode (byte))) b;
+};
+
+void
+foo (struct S *x)
+{
+  if (x->a != C || x->b != D)
+    abort ();
+}
+
+int
+main (void)
+{
+  struct S s;
+  s.a = C;
+  s.b = D;
+  foo (&s);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00163-g.torture.execute-20050107-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00163-g.torture.execute-20050107-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00163-g.torture.execute-20050107-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00163-g.torture.execute-20050107-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..09fa808811d31c7343a661e6c94d108fadf95667
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00163-g.torture.execute-20050107-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050107-1)
+run(20050107-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00164-g.torture.execute-20050119-1/20050119-1.c b/testsuite/c_test/x64_be_enable_test/GCC00164-g.torture.execute-20050119-1/20050119-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..55f33a0656d63b82530b57346a9bfe3d5a4f8667
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00164-g.torture.execute-20050119-1/20050119-1.c
@@ -0,0 +1,37 @@
+/* PR c/19342 */
+typedef enum { A, B, C, D } E;
+
+struct S {
+  E __attribute__ ((mode (__byte__))) a;
+  E __attribute__ ((mode (__byte__))) b;
+  E __attribute__ ((mode (__byte__))) c;
+  E __attribute__ ((mode (__byte__))) d;
+};
+
+extern void abort (void);
+extern void exit (int);
+
+void
+foo (struct S *s)
+{
+  if (s->a != s->b)
+    abort ();
+  if (s->c != C)
+    abort ();
+}
+
+int
+main (void)
+{
+  struct S s[2];
+  s[0].a = B;
+  s[0].b = B;
+  s[0].c = C;
+  s[0].d = D;
+  s[1].a = D;
+  s[1].b = C;
+  s[1].c = B;
+  s[1].d = A;
+  foo (s);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00164-g.torture.execute-20050119-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00164-g.torture.execute-20050119-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00164-g.torture.execute-20050119-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00164-g.torture.execute-20050119-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c174e7103afe7119dd52314d011eb685052c96f3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00164-g.torture.execute-20050119-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050119-1)
+run(20050119-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00165-g.torture.execute-20050119-2/20050119-2.c b/testsuite/c_test/x64_be_enable_test/GCC00165-g.torture.execute-20050119-2/20050119-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..568109cb2c9bb6b219bf887e368af3ff9cc27e74
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00165-g.torture.execute-20050119-2/20050119-2.c
@@ -0,0 +1,40 @@
+/* PR middle-end/19874 */
+typedef enum { A, B, C, D } E;
+
+struct S {
+  E __attribute__ ((mode (__byte__))) a;
+  E __attribute__ ((mode (__byte__))) b;
+  E __attribute__ ((mode (__byte__))) c;
+  E __attribute__ ((mode (__byte__))) d;
+};
+
+extern void abort (void);
+extern void exit (int);
+
+E
+foo (struct S *s)
+{
+  if (s->a != s->b)
+    abort ();
+  if (s->c != C)
+    abort ();
+  return s->d;
+}
+
+int
+main (void)
+{
+  struct S s[2];
+  s[0].a = B;
+  s[0].b = B;
+  s[0].c = C;
+  s[0].d = D;
+  s[1].a = D;
+  s[1].b = C;
+  s[1].c = B;
+  s[1].d = A;
+  if (foo (s) != D)
+    abort ();
+  exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00165-g.torture.execute-20050119-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00165-g.torture.execute-20050119-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00165-g.torture.execute-20050119-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00165-g.torture.execute-20050119-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a156c8454eb28d1e96412166fa582a730459377
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00165-g.torture.execute-20050119-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20050119-2)
+run(20050119-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00166-g.torture.execute-20050124-1/20050124-1.c b/testsuite/c_test/x64_be_enable_test/GCC00166-g.torture.execute-20050124-1/20050124-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9d039ef6623437117d57e6836e804d98a1eef657
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00166-g.torture.execute-20050124-1/20050124-1.c
@@ -0,0 +1,41 @@
+/* PR rtl-optimization/19579 */
+
+extern void abort (void);
+
+int
+foo (int i, int j)
+{
+  int k = i + 1;
+
+  if (j)
+    {
+      if (k > 0)
+	k++;
+      else if (k < 0)
+	k--;
+    }
+
+  return k;
+}
+
+int
+main (void)
+{
+  if (foo (-2, 0) != -1)
+    abort ();
+  if (foo (-1, 0) != 0)
+    abort ();
+  if (foo (0, 0) != 1)
+    abort ();
+  if (foo (1, 0) != 2)
+    abort ();
+  if (foo (-2, 1) != -2)
+    abort ();
+  if (foo (-1, 1) != 0)
+    abort ();
+  if (foo (0, 1) != 2)
+    abort ();
+  if (foo (1, 1) != 3)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00166-g.torture.execute-20050124-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00166-g.torture.execute-20050124-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00166-g.torture.execute-20050124-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00166-g.torture.execute-20050124-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e60754703ae89da4bbda3b360ba64f9d5d7f38ae
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00166-g.torture.execute-20050124-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050124-1)
+run(20050124-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00167-g.torture.execute-20050203-1/20050203-1.c b/testsuite/c_test/x64_be_enable_test/GCC00167-g.torture.execute-20050203-1/20050203-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0b3827794d8aa45d877f7478167914b474129e48
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00167-g.torture.execute-20050203-1/20050203-1.c
@@ -0,0 +1,29 @@
+/* Reduced testcase extracted from Samba source code.  */
+
+#include <stdlib.h>
+
+static void __attribute__((__noinline__))
+     foo (unsigned char *p) {
+  *p = 0x81;
+}
+
+static void __attribute__((__noinline__))
+     bar (int x) {
+  asm ("");
+}
+
+int main() {
+  unsigned char b;
+
+  foo(&b);
+  if (b & 0x80)
+    {
+      bar (b & 0x7f);
+      exit (0);
+    }
+  else
+    {
+      bar (b & 1);
+      abort ();
+    }
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00167-g.torture.execute-20050203-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00167-g.torture.execute-20050203-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00167-g.torture.execute-20050203-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00167-g.torture.execute-20050203-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..82e603b952f4a8ecaea41b7ee7d0dab81577acd6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00167-g.torture.execute-20050203-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050203-1)
+run(20050203-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00168-g.torture.execute-20050215-1/20050215-1.c b/testsuite/c_test/x64_be_enable_test/GCC00168-g.torture.execute-20050215-1/20050215-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f4920ce5fd95ebd07754810ae50db43bf996cdd6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00168-g.torture.execute-20050215-1/20050215-1.c
@@ -0,0 +1,25 @@
+/* PR middle-end/19857 */
+
+typedef struct { char c[8]; } V
+#ifdef __ELF__
+  __attribute__ ((aligned (8)))
+#endif
+  ;
+typedef __SIZE_TYPE__ size_t;
+V v;
+void abort (void);
+
+int
+main (void)
+{
+  V *w = &v;
+  if (((size_t) ((float *) ((size_t) w & ~(size_t) 3)) % 8) != 0
+      || ((size_t) w & 1))
+    {
+#ifndef __ELF__
+      if (((size_t) &v & 7) == 0)
+#endif
+	abort ();
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00168-g.torture.execute-20050215-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00168-g.torture.execute-20050215-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00168-g.torture.execute-20050215-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00168-g.torture.execute-20050215-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..129635272236576e2e6d9235ccf16724603d4ee7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00168-g.torture.execute-20050215-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050215-1)
+run(20050215-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00169-g.torture.execute-20050218-1/20050218-1.c b/testsuite/c_test/x64_be_enable_test/GCC00169-g.torture.execute-20050218-1/20050218-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..104174f923a802bd0eda4561b9a365032dc3aae4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00169-g.torture.execute-20050218-1/20050218-1.c
@@ -0,0 +1,30 @@
+/* PR tree-optimization/19828 */
+typedef __SIZE_TYPE__ size_t;
+extern size_t strlen (const char *s);
+extern int strncmp (const char *s1, const char *s2, size_t n);
+extern void abort (void);
+
+const char *a[16] = { "a", "bc", "de", "fgh" };
+
+int
+foo (char *x, const char *y, size_t n)
+{
+  size_t i, j = 0;
+  for (i = 0; i < n; i++)
+    {
+      if (strncmp (x + j, a[i], strlen (a[i])) != 0)
+        return 2;
+      j += strlen (a[i]);
+      if (y)
+        j += strlen (y);
+    }
+  return 0;
+}
+
+int
+main (void)
+{
+  if (foo ("abcde", (const char *) 0, 3) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00169-g.torture.execute-20050218-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00169-g.torture.execute-20050218-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00169-g.torture.execute-20050218-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00169-g.torture.execute-20050218-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..59fdc243be423d9fdb0edf79705a0a3b1657076b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00169-g.torture.execute-20050218-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050218-1)
+run(20050218-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00170-g.torture.execute-20050224-1/20050224-1.c b/testsuite/c_test/x64_be_enable_test/GCC00170-g.torture.execute-20050224-1/20050224-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..681200364c13776b2f2aaa7b4b4415ba7ec449c6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00170-g.torture.execute-20050224-1/20050224-1.c
@@ -0,0 +1,33 @@
+/* Origin: Mikael Pettersson <mikpe@csd.uu.se> and the Linux kernel.  */
+
+extern void abort (void);
+unsigned long a = 0xc0000000, b = 0xd0000000;
+unsigned long c = 0xc01bb958, d = 0xc0264000;
+unsigned long e = 0xc0288000, f = 0xc02d4378;
+
+void
+foo (int x, int y, int z)
+{
+  if (x != 245 || y != 36 || z != 444)
+    abort ();
+}
+
+int
+main (void)
+{
+  unsigned long g;
+  int h = 0, i = 0, j = 0;
+
+  if (sizeof (unsigned long) < 4)
+    return 0;
+
+  for (g = a; g < b; g += 0x1000)
+    if (g < c)
+      h++;
+    else if (g >= d && g < e)
+      j++;
+    else if (g < f)
+      i++;
+  foo (i, j, h);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00170-g.torture.execute-20050224-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00170-g.torture.execute-20050224-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00170-g.torture.execute-20050224-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00170-g.torture.execute-20050224-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d5ab0957576d2f122cd04c105b493ee59e754712
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00170-g.torture.execute-20050224-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050224-1)
+run(20050224-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00171-g.torture.execute-20050713-1/20050713-1.c b/testsuite/c_test/x64_be_enable_test/GCC00171-g.torture.execute-20050713-1/20050713-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d669cb8e452c502f7585a0ccb6c20bdd71b4a7a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00171-g.torture.execute-20050713-1/20050713-1.c
@@ -0,0 +1,56 @@
+/* Test that sibling call is not used if there is an argument overlap.  */
+
+extern void abort (void);
+
+struct S
+{
+  int a, b, c;
+};
+
+int
+foo2 (struct S x, struct S y)
+{
+  if (x.a != 3 || x.b != 4 || x.c != 5)
+    abort ();
+  if (y.a != 6 || y.b != 7 || y.c != 8)
+    abort ();
+  return 0;
+}
+
+int
+foo3 (struct S x, struct S y, struct S z)
+{
+  foo2 (x, y);
+  if (z.a != 9 || z.b != 10 || z.c != 11)
+    abort ();
+  return 0;
+}
+
+int
+bar2 (struct S x, struct S y)
+{
+  return foo2 (y, x);
+}
+
+int
+bar3 (struct S x, struct S y, struct S z)
+{
+  return foo3 (y, x, z);
+}
+
+int
+baz3 (struct S x, struct S y, struct S z)
+{
+  return foo3 (y, z, x);
+}
+
+int
+main (void)
+{
+  struct S a = { 3, 4, 5 }, b = { 6, 7, 8 }, c = { 9, 10, 11 };
+
+  bar2 (b, a);
+  bar3 (b, a, c);
+  baz3 (c, a, b);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00171-g.torture.execute-20050713-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00171-g.torture.execute-20050713-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00171-g.torture.execute-20050713-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00171-g.torture.execute-20050713-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e688df1544a442d324c00c0d582db904d2762ece
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00171-g.torture.execute-20050713-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050713-1)
+run(20050713-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00172-g.torture.execute-20050929-1/20050929-1.c b/testsuite/c_test/x64_be_enable_test/GCC00172-g.torture.execute-20050929-1/20050929-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7be2eb813f74e3e397b92bafb05982c66543a79e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00172-g.torture.execute-20050929-1/20050929-1.c
@@ -0,0 +1,20 @@
+/* PR middle-end/24109 */
+
+extern void abort (void);
+
+struct A { int i; int j; };
+struct B { struct A *a; struct A *b; };
+struct C { struct B *c; struct A *d; };
+struct C e = { &(struct B) { &(struct A) { 1, 2 }, &(struct A) { 3, 4 } }, &(struct A) { 5, 6 } };
+
+int
+main (void)
+{
+  if (e.c->a->i != 1 || e.c->a->j != 2)
+    abort ();
+  if (e.c->b->i != 3 || e.c->b->j != 4)
+    abort ();
+  if (e.d->i != 5 || e.d->j != 6)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00172-g.torture.execute-20050929-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00172-g.torture.execute-20050929-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00172-g.torture.execute-20050929-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00172-g.torture.execute-20050929-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0ee8f877c1af3487fdd89fb4da47081bd8a081d7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00172-g.torture.execute-20050929-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050929-1)
+run(20050929-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00173-g.torture.execute-20051012-1/20051012-1.c b/testsuite/c_test/x64_be_enable_test/GCC00173-g.torture.execute-20051012-1/20051012-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d43aeda82855816b09f61d4af3ae898a0704585c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00173-g.torture.execute-20051012-1/20051012-1.c
@@ -0,0 +1,25 @@
+/* { dg-require-effective-target untyped_assembly } */
+extern void abort (void);
+
+struct type 
+{
+  int *a;
+  
+  int b:16;
+  unsigned int p:9;
+} t;
+
+unsigned int 
+foo ()
+{
+  return t.p;
+}
+
+int 
+main (void)
+{
+  t.p = 8;
+  if (foo (t) != 8)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00173-g.torture.execute-20051012-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00173-g.torture.execute-20051012-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00173-g.torture.execute-20051012-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00173-g.torture.execute-20051012-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..123970eb85dcd0b57fad43a6a451e4ac39a0bad7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00173-g.torture.execute-20051012-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20051012-1)
+run(20051012-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00174-g.torture.execute-20051021-1/20051021-1.c b/testsuite/c_test/x64_be_enable_test/GCC00174-g.torture.execute-20051021-1/20051021-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0cd2c89ad8f3fe3fd5e7d0697e52b7a41715de4b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00174-g.torture.execute-20051021-1/20051021-1.c
@@ -0,0 +1,28 @@
+/* Verify that TRUTH_AND_EXPR is not wrongly changed to TRUTH_ANDIF_EXPR.  */
+
+extern void abort (void);
+
+int count = 0;
+
+int foo1(void)
+{
+  count++;
+  return 0;
+}
+
+int foo2(void)
+{
+  count++;
+  return 0;
+}
+
+int main(void)
+{
+  if ((foo1() == 1) & (foo2() == 1))
+    abort ();
+
+  if (count != 2)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00174-g.torture.execute-20051021-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00174-g.torture.execute-20051021-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00174-g.torture.execute-20051021-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00174-g.torture.execute-20051021-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..46faf92beafe8c59482e54c49f1b88901cb2cddf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00174-g.torture.execute-20051021-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20051021-1)
+run(20051021-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00175-g.torture.execute-20051110-1/20051110-1.c b/testsuite/c_test/x64_be_enable_test/GCC00175-g.torture.execute-20051110-1/20051110-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..97e8bae0b42f4c29a39fb348639c28bc3d7db5d4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00175-g.torture.execute-20051110-1/20051110-1.c
@@ -0,0 +1,27 @@
+void add_unwind_adjustsp(long);
+void abort(void);
+
+unsigned char bytes[5];
+
+void add_unwind_adjustsp(long offset) {
+  int n;
+  unsigned long o;
+
+  o = (long)((offset - 0x204) >> 2);
+
+  n = 0;
+  while (o) {
+    bytes[n] = o & 0x7f;
+    o >>= 7;
+    if (o)
+      bytes[n] |= 0x80;
+    n++;
+  }
+}
+
+int main(void) {
+  add_unwind_adjustsp(4132);
+  if (bytes[0] != 0x88 || bytes[1] != 0x07)
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00175-g.torture.execute-20051110-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00175-g.torture.execute-20051110-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00175-g.torture.execute-20051110-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00175-g.torture.execute-20051110-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..117cb6670e783c43878a45dcd50b2b6cb5660219
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00175-g.torture.execute-20051110-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20051110-1)
+run(20051110-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00176-g.torture.execute-20051110-2/20051110-2.c b/testsuite/c_test/x64_be_enable_test/GCC00176-g.torture.execute-20051110-2/20051110-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..57bfeeb03bb963de8fe9571316cc19b3fe2af26e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00176-g.torture.execute-20051110-2/20051110-2.c
@@ -0,0 +1,39 @@
+void add_unwind_adjustsp (long);
+void abort (void);
+
+unsigned char bytes[5];
+
+int flag;
+
+void
+add_unwind_adjustsp (long offset)
+{
+  int n;
+  unsigned long o;
+
+  o = (long) ((offset - 0x204) >> 2);
+
+  n = 0;
+  do
+    {
+a:
+      bytes[n] = o & 0x7f;
+      o >>= 7;
+      if (o)
+        {
+	  bytes[n] |= 0x80;
+	  if (flag)
+	    goto a;
+	}
+      n++;
+    }
+  while (o);
+}
+
+int main(void)
+{
+  add_unwind_adjustsp (4132);
+  if (bytes[0] != 0x88 || bytes[1] != 0x07)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00176-g.torture.execute-20051110-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00176-g.torture.execute-20051110-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00176-g.torture.execute-20051110-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00176-g.torture.execute-20051110-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d36918cc52dbddc8ca91ea89fa45ad25858d4b16
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00176-g.torture.execute-20051110-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20051110-2)
+run(20051110-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00177-g.torture.execute-20060102-1/20060102-1.c b/testsuite/c_test/x64_be_enable_test/GCC00177-g.torture.execute-20060102-1/20060102-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..04b6a67d928a0231979fc52ab5f7fe9bf4a92458
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00177-g.torture.execute-20060102-1/20060102-1.c
@@ -0,0 +1,17 @@
+extern void abort ();
+
+int f(int x)
+{
+  return (x >> (sizeof (x) * __CHAR_BIT__ - 1)) ? -1 : 1;
+}
+
+volatile int one = 1;
+int main (void)
+{
+  /* Test that the function above returns different values for
+     different signs.  */
+  if (f(one) == f(-one))
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00177-g.torture.execute-20060102-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00177-g.torture.execute-20060102-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00177-g.torture.execute-20060102-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00177-g.torture.execute-20060102-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6cafe718e7b31d50b82272e0cbff4492aa6f3e6f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00177-g.torture.execute-20060102-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20060102-1)
+run(20060102-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00178-g.torture.execute-20060110-1/20060110-1.c b/testsuite/c_test/x64_be_enable_test/GCC00178-g.torture.execute-20060110-1/20060110-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..112528ecf70f9e6796288aae8268034bdc1e4530
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00178-g.torture.execute-20060110-1/20060110-1.c
@@ -0,0 +1,16 @@
+extern void abort (void);
+
+long long 
+f (long long a) 
+{ 
+  return (a << 32) >> 32; 
+} 
+long long a = 0x1234567876543210LL;
+long long b = (0x1234567876543210LL << 32) >> 32;
+int
+main ()
+{
+  if (f (a) != b)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00178-g.torture.execute-20060110-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00178-g.torture.execute-20060110-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00178-g.torture.execute-20060110-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00178-g.torture.execute-20060110-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3793b7abb0e60c669f4b2accca911171c730aff
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00178-g.torture.execute-20060110-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20060110-1)
+run(20060110-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00179-g.torture.execute-20060110-2/20060110-2.c b/testsuite/c_test/x64_be_enable_test/GCC00179-g.torture.execute-20060110-2/20060110-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..bf60f94366a94124a734677a5e747521ee0f9433
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00179-g.torture.execute-20060110-2/20060110-2.c
@@ -0,0 +1,19 @@
+extern void abort (void);
+
+long long 
+f (long long a, long long b) 
+{ 
+  return ((a + b) << 32) >> 32; 
+} 
+
+long long a = 0x1234567876543210LL;
+long long b = 0x2345678765432101LL;
+long long c = ((0x1234567876543210LL + 0x2345678765432101LL) << 32) >> 32;
+
+int
+main ()
+{
+  if (f (a, b) != c)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00179-g.torture.execute-20060110-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00179-g.torture.execute-20060110-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00179-g.torture.execute-20060110-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00179-g.torture.execute-20060110-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..229d968b1d62fb6883d969dbbd2d6b6b6f6c6a75
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00179-g.torture.execute-20060110-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20060110-2)
+run(20060110-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00180-g.torture.execute-20060127-1/20060127-1.c b/testsuite/c_test/x64_be_enable_test/GCC00180-g.torture.execute-20060127-1/20060127-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..fe73253a58739a3c3faebb9d3043c6010b84136f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00180-g.torture.execute-20060127-1/20060127-1.c
@@ -0,0 +1,17 @@
+void abort ();
+
+void
+f (long long a)
+{
+  if ((a & 0xffffffffLL) != 0)
+    abort ();
+}
+
+long long a = 0x1234567800000000LL;
+
+int
+main ()
+{
+  f (a);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00180-g.torture.execute-20060127-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00180-g.torture.execute-20060127-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00180-g.torture.execute-20060127-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00180-g.torture.execute-20060127-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0d2b1d26f944e539c9a5bc131e0ef440f01b4c62
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00180-g.torture.execute-20060127-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20060127-1)
+run(20060127-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00181-g.torture.execute-20060412-1/20060412-1.c b/testsuite/c_test/x64_be_enable_test/GCC00181-g.torture.execute-20060412-1/20060412-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a4cc4d450391b320ca8a891709ff7e5159f3f72c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00181-g.torture.execute-20060412-1/20060412-1.c
@@ -0,0 +1,33 @@
+extern void abort (void);
+
+struct S
+{
+  long o;
+};
+
+struct T
+{
+  long o;
+  struct S m[82];
+};
+
+struct T t;
+
+int
+main ()
+{
+  struct S *p, *q;
+
+  p = (struct S *) &t;
+  p = &((struct T *) p)->m[0];
+  q = p + 82;
+  while (--q > p)
+    q->o = -1;
+  q->o = 0;
+
+  if (q > p)
+    abort ();
+  if (q - p > 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00181-g.torture.execute-20060412-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00181-g.torture.execute-20060412-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00181-g.torture.execute-20060412-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00181-g.torture.execute-20060412-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8cd8295e753dc29c7a832500ab8a65fcc48a8677
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00181-g.torture.execute-20060412-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20060412-1)
+run(20060412-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00182-g.torture.execute-20060910-1/20060910-1.c b/testsuite/c_test/x64_be_enable_test/GCC00182-g.torture.execute-20060910-1/20060910-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..78bf301397f6b5a065c87b5b1e10051f1b1bba99
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00182-g.torture.execute-20060910-1/20060910-1.c
@@ -0,0 +1,37 @@
+/* PR rtl-optimization/28636 */
+/* Origin: Andreas Schwab <schwab@suse.de> */
+
+extern void abort(void);
+
+struct input_ty
+{
+  unsigned char *buffer_position;
+  unsigned char *buffer_end;
+};
+
+int input_getc_complicated (struct input_ty *x) { return 0; }
+
+int check_header (struct input_ty *deeper)
+{
+  unsigned len;
+  for (len = 0; len < 6; len++)
+    if (((deeper)->buffer_position < (deeper)->buffer_end
+         ? *((deeper)->buffer_position)++
+         : input_getc_complicated((deeper))) < 0)
+      return 0;
+  return 1;
+}
+
+struct input_ty s;
+unsigned char b[6];
+
+int main (void)
+{
+  s.buffer_position = b;
+  s.buffer_end = b + sizeof b;
+  if (!check_header(&s))
+    abort();
+  if (s.buffer_position != s.buffer_end)
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00182-g.torture.execute-20060910-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00182-g.torture.execute-20060910-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00182-g.torture.execute-20060910-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00182-g.torture.execute-20060910-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b572e3c7c21749e8a122a82f4203c695dd7d55d5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00182-g.torture.execute-20060910-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20060910-1)
+run(20060910-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00183-g.torture.execute-20060929-1/20060929-1.c b/testsuite/c_test/x64_be_enable_test/GCC00183-g.torture.execute-20060929-1/20060929-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..76c447fd5b3c43ef04cee696903a9f693834fecd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00183-g.torture.execute-20060929-1/20060929-1.c
@@ -0,0 +1,44 @@
+/* PR c/29154 */
+
+extern void abort (void);
+
+void
+foo (int **p, int *q)
+{
+  *(*p++)++ = *q++;
+}
+
+void
+bar (int **p, int *q)
+{
+  **p = *q++;
+  *(*p++)++;
+}
+
+void
+baz (int **p, int *q)
+{
+  **p = *q++;
+  (*p++)++;
+}
+
+int
+main (void)
+{
+  int i = 42, j = 0;
+  int *p = &i;
+  foo (&p, &j);
+  if (p - 1 != &i || j != 0 || i != 0)
+    abort ();
+  i = 43;
+  p = &i;
+  bar (&p, &j);
+  if (p - 1 != &i || j != 0 || i != 0)
+    abort ();
+  i = 44;
+  p = &i;
+  baz (&p, &j);
+  if (p - 1 != &i || j != 0 || i != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00183-g.torture.execute-20060929-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00183-g.torture.execute-20060929-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00183-g.torture.execute-20060929-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00183-g.torture.execute-20060929-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..53c8fec694ab67c13e3c3c3457d5c9d9414eebe5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00183-g.torture.execute-20060929-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20060929-1)
+run(20060929-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00184-g.torture.execute-20060930-1/20060930-1.c b/testsuite/c_test/x64_be_enable_test/GCC00184-g.torture.execute-20060930-1/20060930-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f12ee55ddfc119e6ca8fc7c51fe93ba3207cde04
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00184-g.torture.execute-20060930-1/20060930-1.c
@@ -0,0 +1,42 @@
+/* PR rtl-optimization/28096 */
+/* Origin: Jan Stein <jan@gatespacetelematics.com> */
+
+extern void abort (void);
+
+int bar (int, int) __attribute__((noinline));
+int bar (int a, int b)
+{
+  if (b != 1)
+    abort ();
+}
+
+void foo(int, int) __attribute__((noinline));
+void foo (int e, int n)
+{
+  int i, bb2, bb5;
+
+  if (e > 0)
+    e = -e;
+
+  for (i = 0; i < n; i++)
+    {
+      if (e >= 0)
+	{
+	  bb2 = 0;
+	  bb5 = 0;
+	}
+      else
+	{
+	  bb5 = -e;
+	  bb2 = bb5;
+	}
+
+      bar (bb5, bb2);
+    }
+}
+
+int main(void)
+{
+  foo (1, 1);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00184-g.torture.execute-20060930-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00184-g.torture.execute-20060930-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00184-g.torture.execute-20060930-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00184-g.torture.execute-20060930-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..95cf403f5431e37e2ef325c9f4785e9ee201b8ca
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00184-g.torture.execute-20060930-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20060930-1)
+run(20060930-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00185-g.torture.execute-20060930-2/20060930-2.c b/testsuite/c_test/x64_be_enable_test/GCC00185-g.torture.execute-20060930-2/20060930-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..498f7811d1c838d689315fff5937f0540378a38a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00185-g.torture.execute-20060930-2/20060930-2.c
@@ -0,0 +1,31 @@
+/* PR middle-end/29272 */
+
+extern void abort (void);
+
+struct S { struct S *s; } s;
+struct T { struct T *t; } t;
+
+static inline void
+foo (void *s)
+{
+  struct T *p = s;
+  __builtin_memcpy (&p->t, &t.t, sizeof (t.t));
+}
+
+void *
+__attribute__((noinline))
+bar (void *p, struct S *q)
+{
+  q->s = &s;
+  foo (p);
+  return q->s;
+}
+
+int
+main (void)
+{
+  t.t = &t;
+  if (bar (&s, &s) != (void *) &t)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00185-g.torture.execute-20060930-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00185-g.torture.execute-20060930-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00185-g.torture.execute-20060930-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00185-g.torture.execute-20060930-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2091427738566ca45b3af4403f0d8a56526f4926
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00185-g.torture.execute-20060930-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20060930-2)
+run(20060930-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00186-g.torture.execute-20070212-1/20070212-1.c b/testsuite/c_test/x64_be_enable_test/GCC00186-g.torture.execute-20070212-1/20070212-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..efda7f9cf66867f256f5d0e34a683951f41aeb14
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00186-g.torture.execute-20070212-1/20070212-1.c
@@ -0,0 +1,26 @@
+struct f
+{
+  int i;
+};
+
+int g(int i, int c, struct f *ff, int *p)
+{
+  int *t;
+  if (c)
+   t = &i;
+  else
+   t = &ff->i;
+  *p = 0;
+  return *t;
+}
+
+extern void abort(void);
+
+int main()
+{
+  struct f f;
+  f.i = 1;
+  if (g(5, 0, &f, &f.i) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00186-g.torture.execute-20070212-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00186-g.torture.execute-20070212-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00186-g.torture.execute-20070212-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00186-g.torture.execute-20070212-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2a127439ae47022ec7eb30d9b3256c8c26d78c31
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00186-g.torture.execute-20070212-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20070212-1)
+run(20070212-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00187-g.torture.execute-20070212-2/20070212-2.c b/testsuite/c_test/x64_be_enable_test/GCC00187-g.torture.execute-20070212-2/20070212-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..a107d0efb93c822e26adcd66973185f5344a6ffa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00187-g.torture.execute-20070212-2/20070212-2.c
@@ -0,0 +1,19 @@
+int f(int k, int i1, int j1)
+{
+  int *f1;
+  if(k)
+   f1 = &i1;
+  else
+   f1 = &j1;
+  i1 = 0;
+  return *f1;
+}
+
+extern void abort (void);
+
+int main()
+{
+  if (f(1, 1, 2) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00187-g.torture.execute-20070212-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00187-g.torture.execute-20070212-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00187-g.torture.execute-20070212-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00187-g.torture.execute-20070212-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c067783154d72edbc5e5580320bb65c7dbdb206d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00187-g.torture.execute-20070212-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20070212-2)
+run(20070212-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00188-g.torture.execute-20070212-3/20070212-3.c b/testsuite/c_test/x64_be_enable_test/GCC00188-g.torture.execute-20070212-3/20070212-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..174be2bd90a197669cf570ee2fb3fd8bba6c5f29
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00188-g.torture.execute-20070212-3/20070212-3.c
@@ -0,0 +1,30 @@
+struct foo { int i; int j; };
+
+int bar (struct foo *k, int k2, int f, int f2)
+{
+  int *p, *q;
+  int res;
+  if (f)
+    p = &k->i;
+  else
+    p = &k->j;
+  res = *p;
+  k->i = 1;
+  if (f2)
+    q = p;
+  else
+    q = &k2;
+  return res + *q;
+}
+
+extern void abort (void);
+
+int main()
+{
+  struct foo k;
+  k.i = 0;
+  k.j = 1;
+  if (bar (&k, 1, 1, 1) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00188-g.torture.execute-20070212-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00188-g.torture.execute-20070212-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00188-g.torture.execute-20070212-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00188-g.torture.execute-20070212-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..87337c92dd70fb38e306e29e3c49abe9a8de7758
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00188-g.torture.execute-20070212-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20070212-3)
+run(20070212-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00189-g.torture.execute-20070517-1/20070517-1.c b/testsuite/c_test/x64_be_enable_test/GCC00189-g.torture.execute-20070517-1/20070517-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c81cbc639be1bdd87564d1b7c5eb8255d70f9c7a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00189-g.torture.execute-20070517-1/20070517-1.c
@@ -0,0 +1,41 @@
+/* PR rtl-optimization/31691 */
+/* Origin: Chi-Hua Chen <stephaniechc-gccbug@yahoo.com> */
+
+extern void abort (void);
+
+static int get_kind(int) __attribute__ ((noinline));
+
+static int get_kind(int v)
+{
+  volatile int k = v;
+  return k;
+}
+
+static int some_call(void) __attribute__ ((noinline));
+
+static int some_call(void)
+{
+  return 0;
+}
+
+static void example (int arg)
+{
+  int tmp, kind = get_kind (arg);
+
+  if (kind == 9 || kind == 10 || kind == 5)
+    {
+      if (some_call() == 0)
+        {
+          if (kind == 9 || kind == 10)
+            tmp = arg;
+          else
+            abort();
+        }
+    }
+} 
+
+int main(void)
+{
+  example(10);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00189-g.torture.execute-20070517-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00189-g.torture.execute-20070517-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00189-g.torture.execute-20070517-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00189-g.torture.execute-20070517-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f4ae9cec1b19158af3b81ad2f08da396bd28192d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00189-g.torture.execute-20070517-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20070517-1)
+run(20070517-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00190-g.torture.execute-20070724-1/20070724-1.c b/testsuite/c_test/x64_be_enable_test/GCC00190-g.torture.execute-20070724-1/20070724-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..011a903f8d31f00d00c975ee12a1878dd55a70b1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00190-g.torture.execute-20070724-1/20070724-1.c
@@ -0,0 +1,11 @@
+void abort (void);
+
+static unsigned char magic[] = "\235";
+static unsigned char value = '\235';
+
+int main()
+{
+  if (value != magic[0])
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00190-g.torture.execute-20070724-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00190-g.torture.execute-20070724-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00190-g.torture.execute-20070724-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00190-g.torture.execute-20070724-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..93651361b010d03f65bc5eacba2d8717a03d0fc4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00190-g.torture.execute-20070724-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20070724-1)
+run(20070724-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00191-g.torture.execute-20070824-1/20070824-1.c b/testsuite/c_test/x64_be_enable_test/GCC00191-g.torture.execute-20070824-1/20070824-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4842bfe218c9c278c8687b83318261435e4a9162
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00191-g.torture.execute-20070824-1/20070824-1.c
@@ -0,0 +1,25 @@
+/* PR tree-optimization/33136 */
+/* { dg-require-effective-target alloca } */
+
+extern void abort (void);
+
+struct S
+{
+  struct S *a;
+  int b;
+};
+
+int
+main (void)
+{
+  struct S *s = (struct S *) 0, **p, *n;
+  for (p = &s; *p; p = &(*p)->a);
+  n = (struct S *) __builtin_alloca (sizeof (*n));
+  n->a = *p;
+  n->b = 1;
+  *p = n;
+
+  if (!s)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00191-g.torture.execute-20070824-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00191-g.torture.execute-20070824-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00191-g.torture.execute-20070824-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00191-g.torture.execute-20070824-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a6aa1b6eb3d55af327e6481c583d8273bbe58a4d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00191-g.torture.execute-20070824-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20070824-1)
+run(20070824-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00192-g.torture.execute-20071018-1/20071018-1.c b/testsuite/c_test/x64_be_enable_test/GCC00192-g.torture.execute-20071018-1/20071018-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0a594945977597d655041b47693cbfb3e29164fe
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00192-g.torture.execute-20071018-1/20071018-1.c
@@ -0,0 +1,31 @@
+extern void abort(void);
+
+struct foo {
+  int rank;
+  char *name;
+};
+
+struct mem {
+  struct foo *x[4];
+};
+
+void __attribute__((noinline)) bar(struct foo **f)
+{
+  *f = malloc(sizeof(struct foo));
+}
+struct foo * __attribute__((noinline, noclone)) foo(int rank)
+{
+  void *x = malloc(sizeof(struct mem));
+  struct mem *as = x;
+  struct foo **upper = &as->x[rank * 8 - 5];
+  *upper = 0;
+  bar(upper);
+  return *upper;
+}
+
+int main()
+{
+  if (foo(1) == 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00192-g.torture.execute-20071018-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00192-g.torture.execute-20071018-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00192-g.torture.execute-20071018-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00192-g.torture.execute-20071018-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5dd02ae092644338a5b4bb0798b9f97be1a2cd1f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00192-g.torture.execute-20071018-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071018-1)
+run(20071018-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00193-g.torture.execute-20071029-1/20071029-1.c b/testsuite/c_test/x64_be_enable_test/GCC00193-g.torture.execute-20071029-1/20071029-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6b895d60a5e336fe2ece03a03a44009a4b888bbc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00193-g.torture.execute-20071029-1/20071029-1.c
@@ -0,0 +1,56 @@
+extern void exit (int);
+extern void abort (void);
+
+typedef union
+{
+  struct
+  {
+    int f1, f2, f3, f4, f5, f6, f7, f8;
+    long int f9, f10;
+    int f11;
+  } f;
+  char s[56];
+  long int a;
+} T;
+
+__attribute__((noinline))
+void
+test (T *t)
+{
+  static int i = 11;
+  if (t->f.f1 != i++)
+    abort ();
+  if (t->f.f2 || t->f.f3 || t->f.f4 || t->f.f5 || t->f.f6
+      || t->f.f7 || t->f.f8 || t->f.f9 || t->f.f10 || t->f.f11)
+    abort ();
+  if (i == 20)
+    exit (0);
+}
+
+__attribute__((noinline))
+void
+foo (int i)
+{
+  T t;
+again:
+  t = (T) { { ++i, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
+  test (&t);
+  goto again;
+}
+
+int
+main (void)
+{
+  T *t1, *t2;
+  int cnt = 0;
+  t1 = (T *) 0;
+loop:
+  t2 = t1;
+  t1 = & (T) { .f.f9 = cnt++ };
+  if (cnt < 3)
+    goto loop;
+  if (t1 != t2 || t1->f.f9 != 2)
+    abort ();
+  foo (10);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00193-g.torture.execute-20071029-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00193-g.torture.execute-20071029-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00193-g.torture.execute-20071029-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00193-g.torture.execute-20071029-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..134dbbd96097648edda6a5c2d394f9562175f9e7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00193-g.torture.execute-20071029-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071029-1)
+run(20071029-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00194-g.torture.execute-20071108-1/20071108-1.c b/testsuite/c_test/x64_be_enable_test/GCC00194-g.torture.execute-20071108-1/20071108-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f5460579b6b70c2dadcc249f20c601d621f1b2bc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00194-g.torture.execute-20071108-1/20071108-1.c
@@ -0,0 +1,53 @@
+/* PR tree-optimization/32575 */
+
+extern void abort (void);
+
+struct S
+{
+  void *s1, *s2;
+  unsigned char s3, s4, s5;
+};
+
+__attribute__ ((noinline))
+void *
+foo (void)
+{
+  static struct S s;
+  return &s;
+}
+
+__attribute__ ((noinline))
+void *
+bar ()
+{
+  return (void *) 0;
+}
+
+__attribute__ ((noinline))
+struct S *
+test (void *a, void *b)
+{
+  struct S *p, q;
+  p = foo ();
+  if (p == 0)
+    {
+      p = &q;
+      __builtin_memset (p, 0, sizeof (*p));
+    }
+  p->s1 = a;
+  p->s2 = b;
+  if (p == &q)
+    p = 0;
+  return p;
+}
+
+int
+main (void)
+{
+  int a;
+  int b;
+  struct S *z = test ((void *) &a, (void *) &b);
+  if (z == 0 || z->s1 != (void *) &a || z->s2 != (void *) &b || z->s3 || z->s4)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00194-g.torture.execute-20071108-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00194-g.torture.execute-20071108-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00194-g.torture.execute-20071108-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00194-g.torture.execute-20071108-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b1cc22dbe9ce5e5e07e53a1173b348a0bf4b4658
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00194-g.torture.execute-20071108-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071108-1)
+run(20071108-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00195-g.torture.execute-20071120-1/20071120-1.c b/testsuite/c_test/x64_be_enable_test/GCC00195-g.torture.execute-20071120-1/20071120-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5a268babaaa493081111c437b0c75f8dab1cfc87
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00195-g.torture.execute-20071120-1/20071120-1.c
@@ -0,0 +1,81 @@
+extern void abort (void);
+
+void __attribute__((noinline,noreturn))
+vec_assert_fail (void)
+{
+    abort ();
+}
+
+struct ggc_root_tab {
+    void *base;
+};
+
+typedef struct deferred_access_check {} VEC_deferred_access_check_gc;
+
+typedef struct deferred_access {
+    VEC_deferred_access_check_gc* deferred_access_checks;
+    int deferring_access_checks_kind;
+} deferred_access;
+
+typedef struct VEC_deferred_access_base {
+    unsigned num;
+    deferred_access vec[1];
+} VEC_deferred_access_base;
+
+static __inline__ deferred_access *
+VEC_deferred_access_base_last (VEC_deferred_access_base *vec_)
+{
+    (void)((vec_ && vec_->num) ? 0 : (vec_assert_fail (), 0));
+    return &vec_->vec[vec_->num - 1];
+}
+
+static __inline__  void
+VEC_deferred_access_base_pop (VEC_deferred_access_base *vec_)
+{
+    (void)((vec_->num) ? 0 : (vec_assert_fail (), 0));
+    --vec_->num;
+}
+
+void __attribute__((noinline))
+perform_access_checks (VEC_deferred_access_check_gc* p)
+{
+    abort ();
+}
+
+typedef struct VEC_deferred_access_gc {
+    VEC_deferred_access_base base;
+} VEC_deferred_access_gc;
+
+static VEC_deferred_access_gc *deferred_access_stack;
+static unsigned deferred_access_no_check;
+
+const struct ggc_root_tab gt_pch_rs_gt_cp_semantics_h[] = {
+    {
+	&deferred_access_no_check
+    }
+};
+
+void __attribute__((noinline)) pop_to_parent_deferring_access_checks (void)
+{
+    if (deferred_access_no_check)
+	deferred_access_no_check--;
+    else
+    {
+        VEC_deferred_access_check_gc *checks;
+        deferred_access *ptr;
+	checks = (VEC_deferred_access_base_last(deferred_access_stack ? &deferred_access_stack->base : 0))->deferred_access_checks;
+        VEC_deferred_access_base_pop(deferred_access_stack ? &deferred_access_stack->base : 0);
+        ptr = VEC_deferred_access_base_last(deferred_access_stack ? &deferred_access_stack->base : 0);
+        if (ptr->deferring_access_checks_kind == 0)
+	    perform_access_checks (checks);
+    }
+}
+
+int main()
+{
+    deferred_access_stack = malloc (sizeof(VEC_deferred_access_gc) + sizeof(deferred_access) * 8);
+    deferred_access_stack->base.num = 2;
+    deferred_access_stack->base.vec[0].deferring_access_checks_kind = 1;
+    pop_to_parent_deferring_access_checks ();
+    return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00195-g.torture.execute-20071120-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00195-g.torture.execute-20071120-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00195-g.torture.execute-20071120-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00195-g.torture.execute-20071120-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fa949b19647d9eb3935089e59ea73beb5ff652b9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00195-g.torture.execute-20071120-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071120-1)
+run(20071120-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00196-g.torture.execute-20071202-1/20071202-1.c b/testsuite/c_test/x64_be_enable_test/GCC00196-g.torture.execute-20071202-1/20071202-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..14fb8ec352e80e709589f3fee55f0ce13dc64908
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00196-g.torture.execute-20071202-1/20071202-1.c
@@ -0,0 +1,25 @@
+extern void abort (void);
+struct T { int t; int r[8]; };
+struct S { int a; int b; int c[6]; struct T d; };
+
+__attribute__((noinline)) void
+foo (struct S *s)
+{
+  *s = (struct S) { s->b, s->a, { 0, 0, 0, 0, 0, 0 }, s->d };
+}
+
+int
+main (void)
+{
+  struct S s = { 6, 12, { 1, 2, 3, 4, 5, 6 },
+		 { 7, { 8, 9, 10, 11, 12, 13, 14, 15 } } };
+  foo (&s);
+  if (s.a != 12 || s.b != 6
+      || s.c[0] || s.c[1] || s.c[2] || s.c[3] || s.c[4] || s.c[5])
+    abort ();
+  if (s.d.t != 7 || s.d.r[0] != 8 || s.d.r[1] != 9 || s.d.r[2] != 10
+      || s.d.r[3] != 11 || s.d.r[4] != 12 || s.d.r[5] != 13
+      || s.d.r[6] != 14 || s.d.r[7] != 15)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00196-g.torture.execute-20071202-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00196-g.torture.execute-20071202-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00196-g.torture.execute-20071202-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00196-g.torture.execute-20071202-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..287f0b3c6315e04460dfae3245d09f6871d66143
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00196-g.torture.execute-20071202-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071202-1)
+run(20071202-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00197-g.torture.execute-20071205-1/20071205-1.c b/testsuite/c_test/x64_be_enable_test/GCC00197-g.torture.execute-20071205-1/20071205-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa19ec067c29d5934eb1b7fed8fbdaaedc6700a0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00197-g.torture.execute-20071205-1/20071205-1.c
@@ -0,0 +1,17 @@
+/* PR middle-end/34337 */
+
+extern void abort (void);
+
+int
+foo (int x)
+{
+  return ((x << 8) & 65535) | 255;
+}
+
+int
+main (void)
+{
+  if (foo (0x32) != 0x32ff || foo (0x174) != 0x74ff)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00197-g.torture.execute-20071205-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00197-g.torture.execute-20071205-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00197-g.torture.execute-20071205-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00197-g.torture.execute-20071205-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dd1ff289ce623578952042c20b2ddc04600ea605
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00197-g.torture.execute-20071205-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071205-1)
+run(20071205-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00198-g.torture.execute-20071211-1/20071211-1.c b/testsuite/c_test/x64_be_enable_test/GCC00198-g.torture.execute-20071211-1/20071211-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4a4f1fefc90675272b549f1790c3252ba4907987
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00198-g.torture.execute-20071211-1/20071211-1.c
@@ -0,0 +1,23 @@
+extern void abort() __attribute__ ((noreturn));
+
+struct s
+{
+  unsigned long long f1 : 40;
+#if(__SIZEOF_INT__ >= 4)
+  unsigned int f2 : 24;
+#else
+  unsigned long int f2 : 24;
+#endif
+} sv;
+
+int main()
+{
+  int f2;
+  sv.f2 = (1 << 24) - 1;
+  __asm__ volatile ("" : : : "memory");
+  ++sv.f2;
+  f2 = sv.f2;
+  if (f2 != 0)
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00198-g.torture.execute-20071211-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00198-g.torture.execute-20071211-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00198-g.torture.execute-20071211-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00198-g.torture.execute-20071211-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..13140e4dc39751e9d0b543ec960311f8005a81a3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00198-g.torture.execute-20071211-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071211-1)
+run(20071211-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00199-g.torture.execute-20071216-1/20071216-1.c b/testsuite/c_test/x64_be_enable_test/GCC00199-g.torture.execute-20071216-1/20071216-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a337b773af8f26065d03e1f94808f8d6a4e95a2c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00199-g.torture.execute-20071216-1/20071216-1.c
@@ -0,0 +1,38 @@
+/* PR rtl-optimization/34490 */
+
+extern void abort (void);
+
+static int x;
+
+int
+__attribute__((noinline))
+bar (void)
+{
+  return x;
+}
+
+int
+foo (void)
+{
+  long int b = bar ();
+  if ((unsigned long) b < -4095L)
+    return b;
+  if (-b != 38)
+    b = -2;
+  return b + 1;
+}
+
+int
+main (void)
+{
+  x = 26;
+  if (foo () != 26)
+    abort ();
+  x = -39;
+  if (foo () != -1)
+    abort ();
+  x = -38;
+  if (foo () != -37)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00199-g.torture.execute-20071216-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00199-g.torture.execute-20071216-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00199-g.torture.execute-20071216-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00199-g.torture.execute-20071216-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..94917e5d5b498a86d9a63b1afba1575d7555d935
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00199-g.torture.execute-20071216-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071216-1)
+run(20071216-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00200-g.torture.execute-20071220-1/20071220-1.c b/testsuite/c_test/x64_be_enable_test/GCC00200-g.torture.execute-20071220-1/20071220-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e832acc8492f61734aa8d1bb9436b9552180ee11
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00200-g.torture.execute-20071220-1/20071220-1.c
@@ -0,0 +1,42 @@
+/* PR tree-optimization/29484 */
+/* { dg-require-effective-target label_values } */
+/* { dg-require-effective-target indirect_jumps } */
+
+extern void abort (void);
+
+void *__attribute__((noinline))
+baz (void **lab)
+{
+  asm volatile ("" : "+r" (lab));
+  return *lab;
+}
+
+static inline
+int bar (void)
+{
+  static void *b[] = { &&addr };
+  void *p = baz (b);
+  goto *p;
+addr:
+  return 17;
+}
+
+int __attribute__((noinline))
+f1 (void)
+{
+  return bar ();
+}
+
+int __attribute__((noinline))
+f2 (void)
+{
+  return bar ();
+}
+
+int
+main (void)
+{
+  if (f1 () != 17 || f1 () != 17 || f2 () != 17 || f2 () != 17)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00200-g.torture.execute-20071220-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00200-g.torture.execute-20071220-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00200-g.torture.execute-20071220-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00200-g.torture.execute-20071220-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..144d6b99465c9a4ff1d510b32aef41a2af82c0c2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00200-g.torture.execute-20071220-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071220-1)
+run(20071220-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00201-g.torture.execute-20071220-2/20071220-2.c b/testsuite/c_test/x64_be_enable_test/GCC00201-g.torture.execute-20071220-2/20071220-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..6cd9bb500657ea7c8edad3939f403691a1626cde
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00201-g.torture.execute-20071220-2/20071220-2.c
@@ -0,0 +1,40 @@
+/* PR tree-optimization/29484 */
+/* { dg-require-effective-target label_values } */
+
+extern void abort (void);
+
+void *__attribute__((noinline))
+baz (void **lab)
+{
+  asm volatile ("" : "+r" (lab));
+  return *lab;
+}
+
+static inline
+int bar (void)
+{
+  static void *b[] = { &&addr };
+  baz (b);
+addr:
+  return 17;
+}
+
+int __attribute__((noinline))
+f1 (void)
+{
+  return bar ();
+}
+
+int __attribute__((noinline))
+f2 (void)
+{
+  return bar ();
+}
+
+int
+main (void)
+{
+  if (f1 () != 17 || f1 () != 17 || f2 () != 17 || f2 () != 17)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00201-g.torture.execute-20071220-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00201-g.torture.execute-20071220-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00201-g.torture.execute-20071220-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00201-g.torture.execute-20071220-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..62831f9cb7956ced0eec648348acba2234a5de1f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00201-g.torture.execute-20071220-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20071220-2)
+run(20071220-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00202-g.torture.execute-20080117-1/20080117-1.c b/testsuite/c_test/x64_be_enable_test/GCC00202-g.torture.execute-20080117-1/20080117-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..94b7c75312fd573ac0dce3c193f812c048adb9f1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00202-g.torture.execute-20080117-1/20080117-1.c
@@ -0,0 +1,24 @@
+typedef struct gs_imager_state_s {
+  struct {
+    int half_width;
+    int cap;
+    float miter_limit;
+  } line_params;
+} gs_imager_state;
+static const gs_imager_state gstate_initial = { { 1 } };
+void gstate_path_memory(gs_imager_state *pgs) {
+  *pgs = gstate_initial;
+}
+int gs_state_update_overprint(void)
+{
+  return gstate_initial.line_params.half_width;
+}
+
+extern void abort (void);
+int main()
+{
+  if (gs_state_update_overprint() != 1)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00202-g.torture.execute-20080117-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00202-g.torture.execute-20080117-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00202-g.torture.execute-20080117-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00202-g.torture.execute-20080117-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ed44a3d194bc6fd5ff46cd9cf0a38612357ac3f8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00202-g.torture.execute-20080117-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20080117-1)
+run(20080117-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00203-g.torture.execute-20080122-1/20080122-1.c b/testsuite/c_test/x64_be_enable_test/GCC00203-g.torture.execute-20080122-1/20080122-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2f7fed87e0d8e7f7fc7e974566e7f01f2dc7d5c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00203-g.torture.execute-20080122-1/20080122-1.c
@@ -0,0 +1,35 @@
+/* PR rtl-optimization/34628 */
+/* Origin: Martin Michlmayr <tbm@cyrius.com> */
+
+typedef unsigned short u16;
+typedef unsigned char u8;
+
+static void
+do_segfault(u8 in_buf[], const u8 out_buf[], const int len)
+{
+  int i;
+
+  for (i = 0; i < len; i++) {
+    asm("");
+
+    in_buf[2*i] = (   out_buf[2*i] | out_buf[(2*i)+1]<<8  ) & 0xFF;
+
+    asm("");
+
+    in_buf[(2*i)+1] =  ( out_buf[2*i] | out_buf[(2*i)+1]<<8 ) >> 8;
+
+    asm("");
+  }
+}
+
+int main(int argc, char *argv[])
+{
+  u8 outbuf[32] = "buffer     ";
+  u8 inbuf[32] = "\f";
+
+  asm("");
+  do_segfault(inbuf, outbuf, 12);
+  asm("");
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00203-g.torture.execute-20080122-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00203-g.torture.execute-20080122-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00203-g.torture.execute-20080122-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00203-g.torture.execute-20080122-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..04d58bf1f9c2d963add3be89c9610527cb4634b3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00203-g.torture.execute-20080122-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20080122-1)
+run(20080122-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00204-g.torture.execute-20080222-1/20080222-1.c b/testsuite/c_test/x64_be_enable_test/GCC00204-g.torture.execute-20080222-1/20080222-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6db83ccdf9028a7f10bfce67af6c7632d087407b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00204-g.torture.execute-20080222-1/20080222-1.c
@@ -0,0 +1,22 @@
+extern void abort (void);
+
+struct container
+{
+  unsigned char data[1];
+};
+
+unsigned char space[6] = {1, 2, 3, 4, 5, 6};
+
+int
+foo (struct container *p)
+{
+  return p->data[4];
+}
+
+int
+main ()
+{
+  if (foo ((struct container *) space) != 5)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00204-g.torture.execute-20080222-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00204-g.torture.execute-20080222-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00204-g.torture.execute-20080222-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00204-g.torture.execute-20080222-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ce5875c2f4fbc0dea37536171c416e90da7cb264
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00204-g.torture.execute-20080222-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20080222-1)
+run(20080222-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00205-g.torture.execute-20080519-1/20080519-1.c b/testsuite/c_test/x64_be_enable_test/GCC00205-g.torture.execute-20080519-1/20080519-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..303c4e65f637d85ee962fd53898c43c86938a4a2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00205-g.torture.execute-20080519-1/20080519-1.c
@@ -0,0 +1,58 @@
+extern void abort (void);
+
+typedef unsigned long HARD_REG_SET[2];
+HARD_REG_SET reg_class_contents[2];
+
+struct du_chain
+{
+  struct du_chain *next_use;
+  int cl;
+};
+
+void __attribute__((noinline))
+merge_overlapping_regs (HARD_REG_SET *p)
+{
+  if ((*p)[0] != -1 || (*p)[1] != -1)
+    abort ();
+}
+
+void __attribute__((noinline))
+regrename_optimize (struct du_chain *this)
+{
+  HARD_REG_SET this_unavailable;
+  unsigned long *scan_fp_;
+  int n_uses;
+  struct du_chain *last;
+
+  this_unavailable[0] = 0;
+  this_unavailable[1] = 0;
+
+  n_uses = 0;
+  for (last = this; last->next_use; last = last->next_use)
+    {
+      scan_fp_ = reg_class_contents[last->cl];
+      n_uses++;
+      this_unavailable[0] |= ~ scan_fp_[0];
+      this_unavailable[1] |= ~ scan_fp_[1];
+    }
+  if (n_uses < 1)
+    return;
+
+  scan_fp_ = reg_class_contents[last->cl];
+  this_unavailable[0] |= ~ scan_fp_[0];
+  this_unavailable[1] |= ~ scan_fp_[1];
+
+  merge_overlapping_regs (&this_unavailable);
+}
+
+int main()
+{
+  struct du_chain du1 = { 0, 0 };
+  struct du_chain du0 = { &du1, 1 };
+  reg_class_contents[0][0] = -1;
+  reg_class_contents[0][1] = -1;
+  reg_class_contents[1][0] = 0;
+  reg_class_contents[1][1] = 0;
+  regrename_optimize (&du0);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00205-g.torture.execute-20080519-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00205-g.torture.execute-20080519-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00205-g.torture.execute-20080519-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00205-g.torture.execute-20080519-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cb6bb71b4c20e903dfed9817a7dfda6e77d07d97
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00205-g.torture.execute-20080519-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20080519-1)
+run(20080519-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00206-g.torture.execute-20080522-1/20080522-1.c b/testsuite/c_test/x64_be_enable_test/GCC00206-g.torture.execute-20080522-1/20080522-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..75bc533f557f6425760c5d813551910e7d654b3a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00206-g.torture.execute-20080522-1/20080522-1.c
@@ -0,0 +1,43 @@
+/* This testcase is to make sure we have i in referenced vars and that we
+   properly compute aliasing for the loads and stores.  */
+
+extern void abort (void);
+
+static int i;
+static int *p = &i;
+
+int __attribute__((noinline))
+foo(int *q)
+{
+  *p = 1;
+  *q = 2;
+  return *p;
+}
+
+int __attribute__((noinline))
+bar(int *q)
+{
+  *q = 2;
+  *p = 1;
+  return *q;
+}
+
+int main()
+{
+  int j = 0;
+
+  if (foo(&i) != 2)
+    abort ();
+  if (bar(&i) != 1)
+    abort ();
+  if (foo(&j) != 1)
+    abort ();
+  if (j != 2)
+    abort ();
+  if (bar(&j) != 2)
+    abort ();
+  if (j != 2)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00206-g.torture.execute-20080522-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00206-g.torture.execute-20080522-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00206-g.torture.execute-20080522-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00206-g.torture.execute-20080522-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3b78383ce56ab3ff1c5f0ef118b8397e4f4d09ea
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00206-g.torture.execute-20080522-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20080522-1)
+run(20080522-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00207-g.torture.execute-20080604-1/20080604-1.c b/testsuite/c_test/x64_be_enable_test/GCC00207-g.torture.execute-20080604-1/20080604-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5ba35cb2cf5c22ef825793facfcdff697da3e3f7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00207-g.torture.execute-20080604-1/20080604-1.c
@@ -0,0 +1,32 @@
+struct barstruct { char const* some_string; } x;
+extern void abort (void);
+void __attribute__((noinline))
+foo(void)
+{
+  if (!x.some_string)
+    abort ();
+}
+void baz(int b)
+{
+  struct barstruct bar;
+  struct barstruct* barptr;
+  if (b)
+    barptr = &bar;
+  else
+    {
+      barptr = &x + 1;
+      barptr = barptr - 1;
+    }
+  barptr->some_string = "Everything OK";
+  foo();
+  barptr->some_string = "Everything OK";
+}
+int main()
+{
+  x.some_string = (void *)0;
+  baz(0);
+  if (!x.some_string)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00207-g.torture.execute-20080604-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00207-g.torture.execute-20080604-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00207-g.torture.execute-20080604-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00207-g.torture.execute-20080604-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9d0d4694363d8fc5f5b7031254907a6e078dc42f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00207-g.torture.execute-20080604-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20080604-1)
+run(20080604-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00208-g.torture.execute-20080719-1/20080719-1.c b/testsuite/c_test/x64_be_enable_test/GCC00208-g.torture.execute-20080719-1/20080719-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..694abcbf9851bbc563578a30c4ea4972ba5a58c8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00208-g.torture.execute-20080719-1/20080719-1.c
@@ -0,0 +1,65 @@
+typedef unsigned int u32;
+
+static const u32 deadfish = 0xdeadf155;
+
+static const u32 cfb_tab8_be[] = {
+    0x00000000,0x000000ff,0x0000ff00,0x0000ffff,
+    0x00ff0000,0x00ff00ff,0x00ffff00,0x00ffffff,
+    0xff000000,0xff0000ff,0xff00ff00,0xff00ffff,
+    0xffff0000,0xffff00ff,0xffffff00,0xffffffff
+};
+
+static const u32 cfb_tab8_le[] = {
+    0x00000000,0xff000000,0x00ff0000,0xffff0000,
+    0x0000ff00,0xff00ff00,0x00ffff00,0xffffff00,
+    0x000000ff,0xff0000ff,0x00ff00ff,0xffff00ff,
+    0x0000ffff,0xff00ffff,0x00ffffff,0xffffffff
+};
+
+static const u32 cfb_tab16_be[] = {
+    0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff
+};
+
+static const u32 cfb_tab16_le[] = {
+    0x00000000, 0xffff0000, 0x0000ffff, 0xffffffff
+};
+
+static const u32 cfb_tab32[] = {
+ 0x00000000, 0xffffffff
+};
+
+
+
+
+
+
+const u32 *xxx(int bpp)
+{
+ const u32 *tab;
+
+if (0) return &deadfish;
+
+ switch (bpp) {
+ case 8:
+  tab = cfb_tab8_be;
+  break;
+ case 16:
+  tab = cfb_tab16_be;
+  break;
+ case 32:
+ default:
+  tab = cfb_tab32;
+  break;
+ }
+
+ return tab;
+}
+
+int main(void)
+{
+  const u32 *a = xxx(8);
+  int b = a[0];
+  if (b != cfb_tab8_be[0])
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00208-g.torture.execute-20080719-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00208-g.torture.execute-20080719-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00208-g.torture.execute-20080719-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00208-g.torture.execute-20080719-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7d55bfcf0fd48e96779c966e6a5daebffc8250cd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00208-g.torture.execute-20080719-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20080719-1)
+run(20080719-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00209-g.torture.execute-20081117-1/20081117-1.c b/testsuite/c_test/x64_be_enable_test/GCC00209-g.torture.execute-20081117-1/20081117-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8fa00d2f9537d82c213a5a7f14a0ed4ce0f5b919
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00209-g.torture.execute-20081117-1/20081117-1.c
@@ -0,0 +1,25 @@
+/* { dg-require-effective-target int32plus } */
+extern void abort (void);
+
+struct s
+{
+  unsigned long long a:16;
+  unsigned long long b:32;
+  unsigned long long c:16;
+};
+
+__attribute__ ((noinline)) unsigned
+f (struct s s, unsigned i)
+{
+  return s.b == i;
+}
+
+struct s s = { 1, 0x87654321u, 2};
+
+int
+main ()
+{
+  if (!f (s, 0x87654321u))
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00209-g.torture.execute-20081117-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00209-g.torture.execute-20081117-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00209-g.torture.execute-20081117-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00209-g.torture.execute-20081117-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..90dcfff7734cf8db8580e952af5b7372232db1f5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00209-g.torture.execute-20081117-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20081117-1)
+run(20081117-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00210-g.torture.execute-20090113-2/20090113-2.c b/testsuite/c_test/x64_be_enable_test/GCC00210-g.torture.execute-20090113-2/20090113-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..9871a66ffbc3cd17f15bb5d53c955abc50a47231
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00210-g.torture.execute-20090113-2/20090113-2.c
@@ -0,0 +1,160 @@
+struct obstack {};
+struct bitmap_head_def;
+typedef struct bitmap_head_def *bitmap;
+typedef const struct bitmap_head_def *const_bitmap;
+typedef unsigned long BITMAP_WORD;
+typedef struct bitmap_obstack
+{
+  struct bitmap_element_def *elements;
+  struct bitmap_head_def *heads;
+  struct obstack obstack;
+} bitmap_obstack;
+typedef struct bitmap_element_def
+{
+  struct bitmap_element_def *next;
+  struct bitmap_element_def *prev;
+  unsigned int indx;
+  BITMAP_WORD bits[((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u))];
+} bitmap_element;
+
+struct bitmap_descriptor;
+
+typedef struct bitmap_head_def {
+    bitmap_element *first;
+    bitmap_element *current;
+    unsigned int indx;
+    bitmap_obstack *obstack;
+} bitmap_head;
+
+bitmap_element bitmap_zero_bits;
+
+typedef struct
+{
+  bitmap_element *elt1;
+  bitmap_element *elt2;
+  unsigned word_no;
+  BITMAP_WORD bits;
+} bitmap_iterator;
+
+static void __attribute__((noinline))
+bmp_iter_set_init (bitmap_iterator *bi, const_bitmap map,
+		   unsigned start_bit, unsigned *bit_no)
+{
+  bi->elt1 = map->first;
+  bi->elt2 = ((void *)0);
+
+  while (1)
+    {
+      if (!bi->elt1)
+	{
+	  bi->elt1 = &bitmap_zero_bits;
+	  break;
+	}
+
+      if (bi->elt1->indx >= start_bit / (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)))
+	break;
+      bi->elt1 = bi->elt1->next;
+    }
+
+  if (bi->elt1->indx != start_bit / (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)))
+    start_bit = bi->elt1->indx * (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u));
+
+  bi->word_no = start_bit / (8 * 8 * 1u) % ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u));
+  bi->bits = bi->elt1->bits[bi->word_no];
+  bi->bits >>= start_bit % (8 * 8 * 1u);
+
+  start_bit += !bi->bits;
+
+  *bit_no = start_bit;
+}
+
+static void __attribute__((noinline))
+bmp_iter_next (bitmap_iterator *bi, unsigned *bit_no)
+{
+  bi->bits >>= 1;
+  *bit_no += 1;
+}
+
+static unsigned char __attribute__((noinline))
+bmp_iter_set_tail (bitmap_iterator *bi, unsigned *bit_no)
+{
+  while (!(bi->bits & 1))
+    {
+      bi->bits >>= 1;
+      *bit_no += 1;
+    }
+  return 1;
+}
+
+static __inline__ unsigned char
+bmp_iter_set (bitmap_iterator *bi, unsigned *bit_no)
+{
+  unsigned bno = *bit_no;
+  BITMAP_WORD bits = bi->bits;
+  bitmap_element *elt1;
+
+  if (bits)
+    {
+      while (!(bits & 1))
+	{
+	  bits >>= 1;
+	  bno += 1;
+	}
+      *bit_no = bno;
+      return 1;
+    }
+
+  *bit_no = ((bno + 64 - 1) / 64 * 64);
+  bi->word_no++;
+
+  elt1 = bi->elt1;
+  while (1)
+    {
+      while (bi->word_no != 2)
+	{
+	  bi->bits = elt1->bits[bi->word_no];
+	  if (bi->bits)
+	    {
+	      bi->elt1 = elt1;
+	      return bmp_iter_set_tail (bi, bit_no);
+	    }
+	  *bit_no += 64;
+	  bi->word_no++;
+	}
+
+      elt1 = elt1->next;
+      if (!elt1)
+	{
+	  bi->elt1 = elt1;
+	  return 0;
+	}
+      *bit_no = elt1->indx * (2 * 64);
+      bi->word_no = 0;
+    }
+}
+
+extern void abort (void);
+
+static void __attribute__((noinline)) catchme(int i)
+{
+  if (i != 0 && i != 64)
+    abort ();
+}
+static void __attribute__((noinline)) foobar (bitmap_head *chain)
+{
+  bitmap_iterator rsi;
+  unsigned int regno;
+  for (bmp_iter_set_init (&(rsi), (chain), (0), &(regno));
+       bmp_iter_set (&(rsi), &(regno));
+       bmp_iter_next (&(rsi), &(regno)))
+    catchme(regno);
+}
+
+int main()
+{
+  bitmap_element elem = { (void *)0, (void *)0, 0, { 1, 1 } };
+  bitmap_head live_throughout = { &elem, &elem, 0, (void *)0 };
+  foobar (&live_throughout);
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00210-g.torture.execute-20090113-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00210-g.torture.execute-20090113-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00210-g.torture.execute-20090113-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00210-g.torture.execute-20090113-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e9950a03d602adc3a00a6e3476f7193e966fb897
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00210-g.torture.execute-20090113-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20090113-2)
+run(20090113-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00211-g.torture.execute-20090113-3/20090113-3.c b/testsuite/c_test/x64_be_enable_test/GCC00211-g.torture.execute-20090113-3/20090113-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..f67bac241351b522816d8a30f5ee89cdfb6aad28
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00211-g.torture.execute-20090113-3/20090113-3.c
@@ -0,0 +1,138 @@
+struct obstack {};
+struct bitmap_head_def;
+typedef struct bitmap_head_def *bitmap;
+typedef const struct bitmap_head_def *const_bitmap;
+typedef unsigned long BITMAP_WORD;
+
+typedef struct bitmap_obstack
+{
+  struct bitmap_element_def *elements;
+  struct bitmap_head_def *heads;
+  struct obstack obstack;
+} bitmap_obstack;
+typedef struct bitmap_element_def
+{
+  struct bitmap_element_def *next;
+  struct bitmap_element_def *prev;
+  unsigned int indx;
+  BITMAP_WORD bits[(2)];
+} bitmap_element;
+
+struct bitmap_descriptor;
+
+typedef struct bitmap_head_def {
+    bitmap_element *first;
+    bitmap_element *current;
+    unsigned int indx;
+    bitmap_obstack *obstack;
+} bitmap_head;
+
+bitmap_element bitmap_zero_bits;
+
+typedef struct
+{
+  bitmap_element *elt1;
+  bitmap_element *elt2;
+  unsigned word_no;
+  BITMAP_WORD bits;
+} bitmap_iterator;
+
+static __attribute__((noinline)) void
+bmp_iter_set_init (bitmap_iterator *bi, const_bitmap map,
+		   unsigned start_bit, unsigned *bit_no)
+{
+  bi->elt1 = map->first;
+  bi->elt2 = ((void *)0);
+
+  while (1)
+    {
+      if (!bi->elt1)
+	{
+	  bi->elt1 = &bitmap_zero_bits;
+	  break;
+	}
+
+      if (bi->elt1->indx >= start_bit / (128u))
+	break;
+      bi->elt1 = bi->elt1->next;
+    }
+
+  if (bi->elt1->indx != start_bit / (128u))
+    start_bit = bi->elt1->indx * (128u);
+
+  bi->word_no = start_bit / 64u % (2);
+  bi->bits = bi->elt1->bits[bi->word_no];
+  bi->bits >>= start_bit % 64u;
+
+  start_bit += !bi->bits;
+
+  *bit_no = start_bit;
+}
+
+static __inline__ __attribute__((always_inline)) void
+bmp_iter_next (bitmap_iterator *bi, unsigned *bit_no)
+{
+  bi->bits >>= 1;
+  *bit_no += 1;
+}
+
+static __inline__ __attribute__((always_inline)) unsigned char
+bmp_iter_set (bitmap_iterator *bi, unsigned *bit_no)
+{
+  if (bi->bits)
+    {
+      while (!(bi->bits & 1))
+	{
+	  bi->bits >>= 1;
+	  *bit_no += 1;
+	}
+      return 1;
+    }
+
+  *bit_no = ((*bit_no + 64u - 1) / 64u * 64u);
+  bi->word_no++;
+
+  while (1)
+    {
+      while (bi->word_no != (2))
+	{
+	  bi->bits = bi->elt1->bits[bi->word_no];
+	  if (bi->bits)
+	    {
+	      while (!(bi->bits & 1))
+		{
+		  bi->bits >>= 1;
+		  *bit_no += 1;
+		}
+	      return 1;
+	    }
+	  *bit_no += 64u;
+	  bi->word_no++;
+	}
+
+      bi->elt1 = bi->elt1->next;
+      if (!bi->elt1)
+	return 0;
+      *bit_no = bi->elt1->indx * (128u);
+      bi->word_no = 0;
+    }
+}
+
+static void __attribute__((noinline))
+foobar (bitmap_head *live_throughout)
+{
+  bitmap_iterator rsi;
+  unsigned int regno;
+  for (bmp_iter_set_init (&(rsi), (live_throughout), (0), &(regno));
+       bmp_iter_set (&(rsi), &(regno));
+       bmp_iter_next (&(rsi), &(regno)))
+    ;
+}
+int main()
+{
+  bitmap_element elem = { (void *)0, (void *)0, 0, { 1, 1 } };
+  bitmap_head live_throughout = { &elem, &elem, 0, (void *)0 };
+  foobar (&live_throughout);
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00211-g.torture.execute-20090113-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00211-g.torture.execute-20090113-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00211-g.torture.execute-20090113-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00211-g.torture.execute-20090113-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ea45b2ff3e7c91f38183ac23e4981247cfb9acf6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00211-g.torture.execute-20090113-3/test.cfg
@@ -0,0 +1,2 @@
+compile(20090113-3)
+run(20090113-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00212-g.torture.execute-20090207-1/20090207-1.c b/testsuite/c_test/x64_be_enable_test/GCC00212-g.torture.execute-20090207-1/20090207-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..51a686028ea9e803269b0c6b4d6fca794a297ebc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00212-g.torture.execute-20090207-1/20090207-1.c
@@ -0,0 +1,16 @@
+int foo(int i)
+{
+  int a[32];
+  a[1] = 3;
+  a[0] = 1;
+  a[i] = 2;
+  return a[0];
+}
+extern void abort (void);
+int main()
+{
+  if (foo (0) != 2
+      || foo (1) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00212-g.torture.execute-20090207-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00212-g.torture.execute-20090207-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00212-g.torture.execute-20090207-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00212-g.torture.execute-20090207-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84b645f653a05aa88aa4aa727636d9c942cf98b4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00212-g.torture.execute-20090207-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20090207-1)
+run(20090207-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00213-g.torture.execute-20090623-1/20090623-1.c b/testsuite/c_test/x64_be_enable_test/GCC00213-g.torture.execute-20090623-1/20090623-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..09a5672cd7484893471006ca57d4708a1dd24b72
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00213-g.torture.execute-20090623-1/20090623-1.c
@@ -0,0 +1,18 @@
+int * __restrict__ x;
+
+int foo (int y)
+{
+  *x = y;
+  return *x;
+}
+
+extern void abort (void);
+
+int main()
+{
+  int i = 0;
+  x = &i;
+  if (foo(1) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00213-g.torture.execute-20090623-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00213-g.torture.execute-20090623-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00213-g.torture.execute-20090623-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00213-g.torture.execute-20090623-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..52ece750b7d54b6822e603ac340cff4612403c21
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00213-g.torture.execute-20090623-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20090623-1)
+run(20090623-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00214-g.torture.execute-20090814-1/20090814-1.c b/testsuite/c_test/x64_be_enable_test/GCC00214-g.torture.execute-20090814-1/20090814-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..857393b5760cb555fb44d049e54b518dd6254781
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00214-g.torture.execute-20090814-1/20090814-1.c
@@ -0,0 +1,23 @@
+int __attribute__((noinline))
+bar (int *a)
+{
+  return *a;
+}
+int i;
+int __attribute__((noinline))
+foo (int (*a)[2])
+{
+  return bar (&(*a)[i]);
+}
+
+extern void abort (void);
+int a[2];
+int main()
+{
+  a[0] = -1;
+  a[1] = 42;
+  i = 1;
+  if (foo (&a) != 42)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00214-g.torture.execute-20090814-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00214-g.torture.execute-20090814-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00214-g.torture.execute-20090814-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00214-g.torture.execute-20090814-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b981bbe40235977091f18b76e3509470e053690
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00214-g.torture.execute-20090814-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20090814-1)
+run(20090814-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00215-g.torture.execute-20100209-1/20100209-1.c b/testsuite/c_test/x64_be_enable_test/GCC00215-g.torture.execute-20100209-1/20100209-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7f450454c9450264a41d0505a6ca350e253e34f6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00215-g.torture.execute-20100209-1/20100209-1.c
@@ -0,0 +1,9 @@
+int bar(int foo) {
+  return (int)(((unsigned long long)(long long)foo) / 8);
+}
+extern void abort(void);
+int main() {
+  if (sizeof(long long) > sizeof(int) && bar(-1) != -1)
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00215-g.torture.execute-20100209-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00215-g.torture.execute-20100209-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00215-g.torture.execute-20100209-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00215-g.torture.execute-20100209-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..929460ae08036c9a343651307509251847969715
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00215-g.torture.execute-20100209-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20100209-1)
+run(20100209-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00216-g.torture.execute-20100416-1/20100416-1.c b/testsuite/c_test/x64_be_enable_test/GCC00216-g.torture.execute-20100416-1/20100416-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b5a6f45e87509c7a040c9187a69cb6769f73b4e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00216-g.torture.execute-20100416-1/20100416-1.c
@@ -0,0 +1,40 @@
+void abort(void);
+
+int
+movegt(int x, int y, long long a)
+{
+  int i;
+  int ret = 0;
+  for (i = 0; i < y; i++)
+    {
+      if (a >= (long long) 0xf000000000000000LL)
+	ret = x;
+      else
+	ret = y;
+    }
+  return ret;
+}
+
+struct test
+{
+  long long val;
+  int ret;
+} tests[] = {
+  { 0xf000000000000000LL, -1 },
+  { 0xefffffffffffffffLL, 1 },
+  { 0xf000000000000001LL, -1 },
+  { 0x0000000000000000LL, -1 },
+  { 0x8000000000000000LL, 1 },
+};
+
+int
+main()
+{
+  int i;
+  for (i = 0; i < sizeof (tests) / sizeof (tests[0]); i++)
+    {
+      if (movegt (-1, 1, tests[i].val) != tests[i].ret)
+	abort ();
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00216-g.torture.execute-20100416-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00216-g.torture.execute-20100416-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00216-g.torture.execute-20100416-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00216-g.torture.execute-20100416-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e27066409690b7b0e4489f838627006355b07c6c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00216-g.torture.execute-20100416-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20100416-1)
+run(20100416-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00217-g.torture.execute-20100805-1/20100805-1.c b/testsuite/c_test/x64_be_enable_test/GCC00217-g.torture.execute-20100805-1/20100805-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5b476960ed7beef2644a33d5d35bd7479e035395
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00217-g.torture.execute-20100805-1/20100805-1.c
@@ -0,0 +1,15 @@
+unsigned int foo (unsigned int a, unsigned int b)
+{
+  unsigned i;
+  a = a & 1;
+  for (i = 0; i < b; ++i)
+    a = a << 1 | a >> (sizeof (unsigned int) * 8 - 1);
+  return a;
+}
+extern void abort (void);
+int main()
+{
+  if (foo (1, sizeof (unsigned int) * 8 + 1) != 2)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00217-g.torture.execute-20100805-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00217-g.torture.execute-20100805-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00217-g.torture.execute-20100805-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00217-g.torture.execute-20100805-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..15bc4e8c9a4b6fb87ed4464ffc5c6f8ad27f2b92
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00217-g.torture.execute-20100805-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20100805-1)
+run(20100805-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00218-g.torture.execute-20101025-1/20101025-1.c b/testsuite/c_test/x64_be_enable_test/GCC00218-g.torture.execute-20101025-1/20101025-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..95361a924871ce57c0128581c4196bc6b15b2f56
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00218-g.torture.execute-20101025-1/20101025-1.c
@@ -0,0 +1,30 @@
+static int g_7;
+static int *volatile g_6 = &g_7;
+int g_3;
+
+static int f1 (int *p_58)
+{
+    return *p_58;
+}
+
+void f2 (int i) __attribute__ ((noinline));
+void f2 (int i)
+{
+  g_3 = i;
+}
+
+int f3 (void) __attribute__ ((noinline));
+int f3 (void)
+{
+    *g_6 = 1;
+    f2 (f1 (&g_7));
+    return 0;
+}
+
+int main ()
+{
+  f3 ();
+  if (g_3 != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00218-g.torture.execute-20101025-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00218-g.torture.execute-20101025-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00218-g.torture.execute-20101025-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00218-g.torture.execute-20101025-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f939948ce3672e570cb4e79f5aca63e9f82b4db8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00218-g.torture.execute-20101025-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20101025-1)
+run(20101025-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00219-g.torture.execute-20110418-1/20110418-1.c b/testsuite/c_test/x64_be_enable_test/GCC00219-g.torture.execute-20110418-1/20110418-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..df2636080e35f6b8146273f898b8082675dd8f6c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00219-g.torture.execute-20110418-1/20110418-1.c
@@ -0,0 +1,29 @@
+typedef unsigned long long uint64_t;
+void f(uint64_t *a, uint64_t aa) __attribute__((noinline));
+void f(uint64_t *a, uint64_t aa)
+{
+  uint64_t new_value = aa;
+  uint64_t old_value = *a;
+  int bit_size = 32;
+    uint64_t mask = (uint64_t)(unsigned)(-1);
+    uint64_t tmp = old_value & mask;
+    new_value &= mask;
+    /* On overflow we need to add 1 in the upper bits */
+    if (tmp > new_value)
+        new_value += 1ull<<bit_size;
+    /* Add in the upper bits from the old value */
+    new_value += old_value & ~mask;
+    *a = new_value;
+}
+int main(void)
+{
+  uint64_t value, new_value, old_value;
+  value = 0x100000001;
+  old_value = value;
+  new_value = (value+1)&(uint64_t)(unsigned)(-1);
+  f(&value, new_value);
+  if (value != old_value+1)
+    __builtin_abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00219-g.torture.execute-20110418-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00219-g.torture.execute-20110418-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00219-g.torture.execute-20110418-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00219-g.torture.execute-20110418-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..61fd10b0d5deb8e1b85edf5e53608e938b231136
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00219-g.torture.execute-20110418-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20110418-1)
+run(20110418-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00220-g.torture.execute-20111212-1/20111212-1.c b/testsuite/c_test/x64_be_enable_test/GCC00220-g.torture.execute-20111212-1/20111212-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c46e6e94636efbaae07f115768b10d839fd9a2f0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00220-g.torture.execute-20111212-1/20111212-1.c
@@ -0,0 +1,34 @@
+/* PR tree-optimization/50569 */
+/* Reported by Paul Koning <pkoning@gcc.gnu.org> */
+/* Reduced testcase by Mikael Pettersson <mikpe@it.uu.se> */
+
+struct event {
+    struct {
+	unsigned int sec;
+    } sent __attribute__((packed));
+};
+
+void __attribute__((noinline,noclone)) frob_entry(char *buf)
+{
+    struct event event;
+
+    __builtin_memcpy(&event, buf, sizeof(event));
+    if (event.sent.sec < 64) {
+	event.sent.sec = -1U;
+	__builtin_memcpy(buf, &event, sizeof(event));
+    }
+}
+
+int main(void)
+{
+    union {
+	char buf[1 + sizeof(struct event)];
+	int align;
+    } u;
+
+    __builtin_memset(&u, 0, sizeof u);
+
+    frob_entry(&u.buf[1]);
+
+    return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00220-g.torture.execute-20111212-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00220-g.torture.execute-20111212-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00220-g.torture.execute-20111212-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00220-g.torture.execute-20111212-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9ab8af6d861365be763ff1fc0afeeab252ae175f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00220-g.torture.execute-20111212-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20111212-1)
+run(20111212-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00221-g.torture.execute-20120105-1/20120105-1.c b/testsuite/c_test/x64_be_enable_test/GCC00221-g.torture.execute-20120105-1/20120105-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..115ba1509d4948096f5312093138bb4e75ef1693
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00221-g.torture.execute-20120105-1/20120105-1.c
@@ -0,0 +1,24 @@
+struct __attribute__((packed)) S
+{
+  int a, b, c;
+};
+
+static int __attribute__ ((noinline,noclone))
+extract(const char *p)
+{
+  struct S s;
+  __builtin_memcpy (&s, p, sizeof(struct S));
+  return s.a;
+}
+
+volatile int i;
+
+int main (void)
+{
+  char p[sizeof(struct S) + 1];
+
+  __builtin_memset (p, 0, sizeof(struct S) + 1);
+  i = extract (p + 1);
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00221-g.torture.execute-20120105-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00221-g.torture.execute-20120105-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00221-g.torture.execute-20120105-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00221-g.torture.execute-20120105-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7535faae535f7f49b0f6a236af628aaf9ac64dfa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00221-g.torture.execute-20120105-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20120105-1)
+run(20120105-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00222-g.torture.execute-20120111-1/20120111-1.c b/testsuite/c_test/x64_be_enable_test/GCC00222-g.torture.execute-20120111-1/20120111-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..cd18a3b66b26723dc826f294b1fd4d8124945500
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00222-g.torture.execute-20120111-1/20120111-1.c
@@ -0,0 +1,18 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+uint32_t f0a (uint64_t arg2) __attribute__((noinline));
+
+uint32_t
+f0a (uint64_t arg)
+{
+  return ~((unsigned) (arg > -3));
+}
+
+int main() {
+  uint32_t r1;
+  r1 = f0a (12094370573988097329ULL);
+  if (r1 != ~0U)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00222-g.torture.execute-20120111-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00222-g.torture.execute-20120111-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00222-g.torture.execute-20120111-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00222-g.torture.execute-20120111-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4357c11da22c3e869827c7a12f839ea9881738d2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00222-g.torture.execute-20120111-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20120111-1)
+run(20120111-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00223-g.torture.execute-20120427-1/20120427-1.c b/testsuite/c_test/x64_be_enable_test/GCC00223-g.torture.execute-20120427-1/20120427-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..46ed76ae9430d4545426894f91fe287aa0a98b15
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00223-g.torture.execute-20120427-1/20120427-1.c
@@ -0,0 +1,36 @@
+typedef struct sreal
+{
+  unsigned sig;		/* Significant.  */
+  int exp;		/* Exponent.  */
+} sreal;
+
+sreal_compare (sreal *a, sreal *b)
+{
+  if (a->exp > b->exp)
+    return 1;
+  if (a->exp < b->exp)
+    return -1;
+  if (a->sig > b->sig)
+    return 1;
+  return -(a->sig < b->sig);
+}
+
+sreal a[] = {
+   { 0, 0 },
+   { 1, 0 },
+   { 0, 1 },
+   { 1, 1 }
+};
+
+int main()
+{
+  int i, j;
+  for (i = 0; i <= 3; i++) {
+    for (j = 0; j < 3; j++) {
+      if (i < j && sreal_compare(&a[i], &a[j]) != -1) abort();
+      if (i == j && sreal_compare(&a[i], &a[j]) != 0) abort();
+      if (i > j && sreal_compare(&a[i], &a[j]) != 1) abort();
+    }
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00223-g.torture.execute-20120427-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00223-g.torture.execute-20120427-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00223-g.torture.execute-20120427-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00223-g.torture.execute-20120427-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..18a68d45f3e37fd8b7341c05682165fd017d5c27
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00223-g.torture.execute-20120427-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20120427-1)
+run(20120427-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00224-g.torture.execute-20120427-2/20120427-2.c b/testsuite/c_test/x64_be_enable_test/GCC00224-g.torture.execute-20120427-2/20120427-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..e473a4772a9ee1316fb6ae36c1d76bf9ea78f584
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00224-g.torture.execute-20120427-2/20120427-2.c
@@ -0,0 +1,38 @@
+typedef struct sreal
+{
+  unsigned sig;		/* Significant.  */
+  int exp;		/* Exponent.  */
+} sreal;
+
+sreal_compare (sreal *a, sreal *b)
+{
+  if (a->exp > b->exp)
+    return 1;
+  if (a->exp < b->exp)
+    return -1;
+  if (a->sig > b->sig)
+    return 1;
+  if (a->sig < b->sig)
+    return -1;
+  return 0;
+}
+
+sreal a[] = {
+   { 0, 0 },
+   { 1, 0 },
+   { 0, 1 },
+   { 1, 1 }
+};
+
+int main()
+{
+  int i, j;
+  for (i = 0; i <= 3; i++) {
+    for (j = 0; j < 3; j++) {
+      if (i < j && sreal_compare(&a[i], &a[j]) != -1) abort();
+      if (i == j && sreal_compare(&a[i], &a[j]) != 0) abort();
+      if (i > j && sreal_compare(&a[i], &a[j]) != 1) abort();
+    }
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00224-g.torture.execute-20120427-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00224-g.torture.execute-20120427-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00224-g.torture.execute-20120427-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00224-g.torture.execute-20120427-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8e1bade1ed83eceb6c77d9cb72af6c97b207524c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00224-g.torture.execute-20120427-2/test.cfg
@@ -0,0 +1,2 @@
+compile(20120427-2)
+run(20120427-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00225-g.torture.execute-20120808-1/20120808-1.c b/testsuite/c_test/x64_be_enable_test/GCC00225-g.torture.execute-20120808-1/20120808-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3cbab2ba8437a75dedc4b00821c818b4404e0bdd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00225-g.torture.execute-20120808-1/20120808-1.c
@@ -0,0 +1,37 @@
+extern void exit (int);
+extern void abort (void);
+
+volatile int i;
+unsigned char *volatile cp;
+unsigned char d[32] = { 0 };
+
+int
+main (void)
+{
+  unsigned char c[32] = { 0 };
+  unsigned char *p = d + i;
+  int j;
+  for (j = 0; j < 30; j++)
+    {
+      int x = 0xff;
+      int y = *++p;
+      switch (j)
+	{
+	case 1: x ^= 2; break;
+	case 2: x ^= 4; break;
+	case 25: x ^= 1; break;
+	default: break;
+	}
+      c[j] = y | x;
+      cp = p;
+    }
+  if (c[0] != 0xff
+      || c[1] != 0xfd
+      || c[2] != 0xfb
+      || c[3] != 0xff
+      || c[4] != 0xff
+      || c[25] != 0xfe
+      || cp != d + 30)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00225-g.torture.execute-20120808-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00225-g.torture.execute-20120808-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00225-g.torture.execute-20120808-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00225-g.torture.execute-20120808-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65ea42260f50a8bead7c2757e242773ac594f122
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00225-g.torture.execute-20120808-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20120808-1)
+run(20120808-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00226-g.torture.execute-20140425-1/20140425-1.c b/testsuite/c_test/x64_be_enable_test/GCC00226-g.torture.execute-20140425-1/20140425-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c447ef95b6c1fa0c065ec18fd8c20de3048c8279
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00226-g.torture.execute-20140425-1/20140425-1.c
@@ -0,0 +1,23 @@
+/* PR target/60941 */
+/* Reported by Martin Husemann <martin@netbsd.org> */
+
+extern void abort (void);
+
+static void __attribute__((noinline))
+set (unsigned long *l)
+{
+  *l = 31;
+}
+
+int main (void)
+{
+  unsigned long l;
+  int i;
+
+  set (&l);
+  i = (int) l;
+  l = (unsigned long)(2U << i);
+  if (l != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00226-g.torture.execute-20140425-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00226-g.torture.execute-20140425-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00226-g.torture.execute-20140425-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00226-g.torture.execute-20140425-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e01c1354daa9739649461e333337ac1f599165e6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00226-g.torture.execute-20140425-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20140425-1)
+run(20140425-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00227-g.torture.execute-20140622-1/20140622-1.c b/testsuite/c_test/x64_be_enable_test/GCC00227-g.torture.execute-20140622-1/20140622-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d57b33ba25c231a4580b79b1e8ad37e8a8dd1d31
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00227-g.torture.execute-20140622-1/20140622-1.c
@@ -0,0 +1,23 @@
+unsigned p;
+
+long __attribute__((noinline, noclone)) test(unsigned a) {
+  return (long)(p + a) - (long)p;
+}
+
+int main() {
+  p = (unsigned)-2;
+  if (test(0) != 0)
+    __builtin_abort();
+  if (test(1) != 1)
+    __builtin_abort();
+  if (test(2) != -(long)(unsigned)-2)
+    __builtin_abort();
+  p = (unsigned)-1;
+  if (test(0) != 0)
+    __builtin_abort();
+  if (test(1) != -(long)(unsigned)-1)
+    __builtin_abort();
+  if (test(2) != -(long)(unsigned)-2)
+    __builtin_abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00227-g.torture.execute-20140622-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00227-g.torture.execute-20140622-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00227-g.torture.execute-20140622-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00227-g.torture.execute-20140622-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d23d55c323019be4ff03c18b5a2e8a3f2e4d9a08
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00227-g.torture.execute-20140622-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20140622-1)
+run(20140622-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00228-g.torture.execute-20141022-1/20141022-1.c b/testsuite/c_test/x64_be_enable_test/GCC00228-g.torture.execute-20141022-1/20141022-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ab71877fb551b268fd6371ef4237d69fb7762385
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00228-g.torture.execute-20141022-1/20141022-1.c
@@ -0,0 +1,25 @@
+#define ABORT() do { __builtin_printf("assert.\n");  __builtin_abort (); }while(0)
+int f(int a) __attribute__((noinline));
+int f(int a)
+{
+  int fem_key_src;
+  int D2930 = a & 4294967291;
+  fem_key_src = a == 6 ? 0 : 15;
+  fem_key_src = D2930 != 1 ? fem_key_src : 0;
+  return fem_key_src;
+}
+
+int main(void)
+{
+  if (f(0) != 15)
+    ABORT ();
+  if (f(1) != 0)
+    ABORT ();
+  if (f(6) != 0)
+    ABORT ();
+  if (f(5) != 0)
+    ABORT ();
+  if (f(15) != 15)
+    ABORT ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00228-g.torture.execute-20141022-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00228-g.torture.execute-20141022-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00228-g.torture.execute-20141022-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00228-g.torture.execute-20141022-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7f362a6e6a71420477d62fed9343f55fe8eac9a9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00228-g.torture.execute-20141022-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20141022-1)
+run(20141022-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00229-g.torture.execute-20141125-1/20141125-1.c b/testsuite/c_test/x64_be_enable_test/GCC00229-g.torture.execute-20141125-1/20141125-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6aa5665fbaf9f7ab93b209509fd0bd4b0195bf32
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00229-g.torture.execute-20141125-1/20141125-1.c
@@ -0,0 +1,17 @@
+int f(long long a) __attribute__((noinline,noclone));
+int f(long long a)
+{
+  if (a & 0x3ffffffffffffffull)
+    return 1;
+  return 1024;
+}
+
+int main(void)
+{
+  if(f(0x48375d8000000000ull) != 1)
+    __builtin_abort ();
+  if (f(0xfc00000000000000ull) != 1024)
+    __builtin_abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00229-g.torture.execute-20141125-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00229-g.torture.execute-20141125-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00229-g.torture.execute-20141125-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00229-g.torture.execute-20141125-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ed13ba2484fe0e04dc48e6793b8d33c945339840
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00229-g.torture.execute-20141125-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20141125-1)
+run(20141125-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00230-g.torture.execute-20170419-1/20170419-1.c b/testsuite/c_test/x64_be_enable_test/GCC00230-g.torture.execute-20170419-1/20170419-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f59dbc7a0578ea20277a7360ea7d2273a777c337
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00230-g.torture.execute-20170419-1/20170419-1.c
@@ -0,0 +1,24 @@
+/* PR tree-optimization/80426 */
+/* Testcase by <ishiura-compiler@ml.kwansei.ac.jp> */
+
+#define INT_MAX 0x7fffffff
+#define INT_MIN (-INT_MAX-1)
+
+int x;
+
+int main (void)
+{
+  volatile int a = 0;
+  volatile int b = -INT_MAX;
+  int j;
+
+  for(j = 0; j < 18; j += 1) {
+    x = ( (a == 0) != (b - (int)(INT_MIN) ) );
+  }
+
+  if (x != 0)
+    __builtin_abort ();
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00230-g.torture.execute-20170419-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00230-g.torture.execute-20170419-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00230-g.torture.execute-20170419-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00230-g.torture.execute-20170419-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6ea0c34a9d5f55c988dd92d015d221df1a47c598
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00230-g.torture.execute-20170419-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20170419-1)
+run(20170419-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00231-g.torture.execute-20180112-1/20180112-1.c b/testsuite/c_test/x64_be_enable_test/GCC00231-g.torture.execute-20180112-1/20180112-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d01ac72db88b7ea7c8340738e285e9d7148cde40
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00231-g.torture.execute-20180112-1/20180112-1.c
@@ -0,0 +1,32 @@
+/* PR rtl-optimization/83565 */
+/* Testcase by Sergei Trofimovich <slyfox@inbox.ru> */
+
+extern void abort (void);
+
+typedef __UINT32_TYPE__ u32;
+
+u32 bug (u32 * result) __attribute__((noinline));
+u32 bug (u32 * result)
+{
+  volatile u32 ss = 0xFFFFffff;
+  volatile u32 d  = 0xEEEEeeee;
+  u32 tt = d & 0x00800000;
+  u32 r  = tt << 8;
+
+  r = (r >> 31) | (r <<  1);
+
+  u32 u = r^ss;
+  u32 off = u >> 1;
+
+  *result = tt;
+  return off;
+}
+
+int main(void)
+{
+  u32 l;
+  u32 off = bug(&l);
+  if (off != 0x7fffffff)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00231-g.torture.execute-20180112-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00231-g.torture.execute-20180112-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00231-g.torture.execute-20180112-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00231-g.torture.execute-20180112-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1f0a5bb604adad54d6d589829a37660611b2c4b7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00231-g.torture.execute-20180112-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20180112-1)
+run(20180112-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00232-g.torture.execute-20180226-1/20180226-1.c b/testsuite/c_test/x64_be_enable_test/GCC00232-g.torture.execute-20180226-1/20180226-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e2b678c8fc79c4448aa01038cb801ff93905b091
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00232-g.torture.execute-20180226-1/20180226-1.c
@@ -0,0 +1,31 @@
+/* PR rtl-optimization/83496 */
+/* Reported by Hauke Mehrtens <gcc@hauke-m.de> */
+
+extern void abort (void);
+
+typedef unsigned long mp_digit;
+
+typedef struct { int used, alloc, sign; mp_digit *dp; } mp_int;
+
+int mytest(mp_int *a, mp_digit b) __attribute__((noclone, noinline));
+
+int mytest(mp_int *a, mp_digit b)
+{
+  if (a->sign == 1)
+    return -1;
+  if (a->used > 1)
+    return 1;
+  if (a->dp[0] > b)
+    return 1;
+  if (a->dp[0] < b)
+    return -1;
+  return 0;
+}
+
+int main (void)
+{
+  mp_int i = { 2, 0, -1 };
+  if (mytest (&i, 0) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00232-g.torture.execute-20180226-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00232-g.torture.execute-20180226-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00232-g.torture.execute-20180226-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00232-g.torture.execute-20180226-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..34ae084b45f0b2bd0538538dc09ac51f22c465e5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00232-g.torture.execute-20180226-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20180226-1)
+run(20180226-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00233-g.torture.execute-20190228-1/20190228-1.c b/testsuite/c_test/x64_be_enable_test/GCC00233-g.torture.execute-20190228-1/20190228-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e71f33a279bdd470b5c02ba3428877333e51cd75
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00233-g.torture.execute-20190228-1/20190228-1.c
@@ -0,0 +1,16 @@
+/* PR tree-optimization/89536 */
+/* Testcase by Zhendong Su <su@cs.ucdavis.edu> */
+
+int a = 1;
+
+int main (void)
+{
+  a = ~(a && 1); 
+  if (a < -1)
+    a = ~a;
+  
+  if (!a)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00233-g.torture.execute-20190228-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00233-g.torture.execute-20190228-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00233-g.torture.execute-20190228-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00233-g.torture.execute-20190228-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..559aefeb73b55825d5dbd2eb4282806a9bec4ff4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00233-g.torture.execute-20190228-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20190228-1)
+run(20190228-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00234-g.torture.execute-20191023-1/20191023-1.c b/testsuite/c_test/x64_be_enable_test/GCC00234-g.torture.execute-20191023-1/20191023-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0e3aa67799c129db04c5f5f680b3c2d3ef388703
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00234-g.torture.execute-20191023-1/20191023-1.c
@@ -0,0 +1,74 @@
+/* PR tree-optimization/92131 */
+/* Testcase by Armin Rigo <arigo@tunes.org> */
+
+long b, c, d, e, f, i;
+char g, h, j, k;
+int *aa;
+
+static void error(void) __attribute__((noipa));
+static void error(void) {
+  __builtin_abort();
+}
+
+static void see_me_here(void) __attribute__((noipa));
+static void see_me_here(void) {}
+
+static void aaa(void) __attribute__((noipa));
+static void aaa(void) {}
+
+static void a(void) __attribute__((noipa));
+static void a(void) {
+  long am, ao;
+  if (aa == 0) {
+    aaa();
+    if (j)
+      goto ay;
+  }
+  return;
+ay:
+  aaa();
+  if (k) {
+    aaa();
+    goto az;
+  }
+  return;
+az:
+  if (i)
+    if (g)
+      if (h)
+        if (e)
+          goto bd;
+  return;
+bd:
+  am = 0;
+  while (am < e) {
+    switch (c) {
+      case 8:
+        goto bh;
+      case 4:
+        return;
+    }
+  bh:
+    if (am >= 0)
+      b = -am;
+    ao = am + b;
+    f = ao & 7;
+    if (f == 0)
+      see_me_here();
+    if (ao >= 0)
+      am++;
+    else
+      error();
+  }
+}
+
+int main(void) {
+  j++;
+  k++;
+  i++;
+  g++;
+  h++;
+  e = 1;
+  a();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00234-g.torture.execute-20191023-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00234-g.torture.execute-20191023-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00234-g.torture.execute-20191023-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00234-g.torture.execute-20191023-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd84d646d001a30cdc4cccbd3574d0ebec40f9cc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00234-g.torture.execute-20191023-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20191023-1)
+run(20191023-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00235-g.torture.execute-900409-1/900409-1.c b/testsuite/c_test/x64_be_enable_test/GCC00235-g.torture.execute-900409-1/900409-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3112effaf2f34699b7553b822a857fd67ac53527
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00235-g.torture.execute-900409-1/900409-1.c
@@ -0,0 +1,20 @@
+long f1(long a){return a&0xff000000L;}
+long f2 (long a){return a&~0xff000000L;}
+long f3(long a){return a&0x000000ffL;}
+long f4(long a){return a&~0x000000ffL;}
+long f5(long a){return a&0x0000ffffL;}
+long f6(long a){return a&~0x0000ffffL;}
+
+main ()
+{
+  long a = 0x89ABCDEF;
+
+  if (f1(a)!=0x89000000L||
+      f2(a)!=0x00ABCDEFL||
+      f3(a)!=0x000000EFL||
+      f4(a)!=0x89ABCD00L||
+      f5(a)!=0x0000CDEFL||
+      f6(a)!=0x89AB0000L)
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00235-g.torture.execute-900409-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00235-g.torture.execute-900409-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00235-g.torture.execute-900409-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00235-g.torture.execute-900409-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9a0c26dccf192bd7d35b11b2fdf98c430e9b6f03
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00235-g.torture.execute-900409-1/test.cfg
@@ -0,0 +1,2 @@
+compile(900409-1)
+run(900409-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00236-g.torture.execute-920202-1/920202-1.c b/testsuite/c_test/x64_be_enable_test/GCC00236-g.torture.execute-920202-1/920202-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e30ce2fd5c224e951c2c31f20a88894b7c6f6d76
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00236-g.torture.execute-920202-1/920202-1.c
@@ -0,0 +1,18 @@
+static int rule_text_needs_stack_pop = 0;
+static int input_stack_pos = 1;
+
+f (void)
+{
+  rule_text_needs_stack_pop = 1;
+
+  if (input_stack_pos <= 0)
+    return 1;
+  else
+    return 0;
+}
+
+main ()
+{
+  f ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00236-g.torture.execute-920202-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00236-g.torture.execute-920202-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00236-g.torture.execute-920202-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00236-g.torture.execute-920202-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..820b8befa707881f7ac4950785ce9a90e77be66b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00236-g.torture.execute-920202-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920202-1)
+run(920202-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00237-g.torture.execute-920411-1/920411-1.c b/testsuite/c_test/x64_be_enable_test/GCC00237-g.torture.execute-920411-1/920411-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e3e981001088b38ff566098311b5f930e172ff8f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00237-g.torture.execute-920411-1/920411-1.c
@@ -0,0 +1,24 @@
+long f (w)
+     char *w;
+{
+  long k, i, c = 0, x;
+  char *p = (char*) &x;
+  for (i = 0; i < 1; i++)
+    {
+      for (k = 0; k < sizeof (long); k++)
+	p[k] = w[k];
+      c += x;
+    }
+  return c;
+}
+
+main ()
+{
+  int i;
+  char a[sizeof (long)];
+
+  for (i = sizeof (long); --i >= 0;) a[i] = ' ';
+  if (f (a) != ~0UL / (unsigned char) ~0 * ' ')
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00237-g.torture.execute-920411-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00237-g.torture.execute-920411-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00237-g.torture.execute-920411-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00237-g.torture.execute-920411-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..92b4e5db8c4c98ba4cc216cbbe4ad51b59969c17
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00237-g.torture.execute-920411-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920411-1)
+run(920411-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00238-g.torture.execute-920429-1/920429-1.c b/testsuite/c_test/x64_be_enable_test/GCC00238-g.torture.execute-920429-1/920429-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f37bf68bdd408221bc9ea674d36c68da6972baba
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00238-g.torture.execute-920429-1/920429-1.c
@@ -0,0 +1,3 @@
+typedef unsigned char t;int i,j;
+t*f(t*p){t c;c=*p++;i=((c&2)?1:0);j=(c&7)+1;return p;}
+main(){t*p0="ab",*p1;p1=f(p0);if(p0+1!=p1)abort();exit(0);}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00238-g.torture.execute-920429-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00238-g.torture.execute-920429-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00238-g.torture.execute-920429-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00238-g.torture.execute-920429-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..02fa7de71f864d082dc13b71108eb50a1fc5da00
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00238-g.torture.execute-920429-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920429-1)
+run(920429-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00239-g.torture.execute-920501-1/920501-1.c b/testsuite/c_test/x64_be_enable_test/GCC00239-g.torture.execute-920501-1/920501-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a057943ce78d5eea2e8e3db47257e51f8505056c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00239-g.torture.execute-920501-1/920501-1.c
@@ -0,0 +1,4 @@
+/* { dg-require-effective-target untyped_assembly } */
+int s[2];
+x(){if(!s[0]){s[1+s[1]]=s[1];return 1;}}
+main(){s[0]=s[1]=0;if(x(0)!=1)abort();exit(0);}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00239-g.torture.execute-920501-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00239-g.torture.execute-920501-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00239-g.torture.execute-920501-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00239-g.torture.execute-920501-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3a6e988ea9a26cb93fe9b47bb462eeafd040aa30
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00239-g.torture.execute-920501-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920501-1)
+run(920501-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00240-g.torture.execute-920501-4/920501-4.c b/testsuite/c_test/x64_be_enable_test/GCC00240-g.torture.execute-920501-4/920501-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..c99857079aa2c570cb3d22cd96e7627133ccbe25
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00240-g.torture.execute-920501-4/920501-4.c
@@ -0,0 +1,24 @@
+/* { dg-require-effective-target label_values } */
+
+int
+x (int i)
+{
+  static const void *j[] = {&& x, && y, && z};
+  
+  goto *j[i];
+  
+ x: return 2;
+ y: return 3;
+ z: return 5;
+}
+
+int
+main (void)
+{
+  if (   x (0) != 2
+      || x (1) != 3
+      || x (2) != 5)
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00240-g.torture.execute-920501-4/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00240-g.torture.execute-920501-4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00240-g.torture.execute-920501-4/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00240-g.torture.execute-920501-4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c5a00d8f9cc4fd4a737e87bb9cc0786d7570fa6c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00240-g.torture.execute-920501-4/test.cfg
@@ -0,0 +1,2 @@
+compile(920501-4)
+run(920501-4)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00241-g.torture.execute-920501-5/920501-5.c b/testsuite/c_test/x64_be_enable_test/GCC00241-g.torture.execute-920501-5/920501-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..8233f248b4a8c01d7ee3c1162ac895afe9754860
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00241-g.torture.execute-920501-5/920501-5.c
@@ -0,0 +1,17 @@
+/* { dg-require-effective-target label_values } */
+
+x(int i) {
+  void *j[] = { &&x, &&y, &&z };
+  goto *j[i];
+x:
+  return 2;
+y:
+  return 3;
+z:
+  return 5;
+}
+main() {
+  if (x(0) != 2 || x(1) != 3 || x(2) != 5)
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00241-g.torture.execute-920501-5/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00241-g.torture.execute-920501-5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00241-g.torture.execute-920501-5/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00241-g.torture.execute-920501-5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ea3a5f044070047e2650e72d1c1ced5421227882
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00241-g.torture.execute-920501-5/test.cfg
@@ -0,0 +1,2 @@
+compile(920501-5)
+run(920501-5)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00242-g.torture.execute-920501-9/920501-9.c b/testsuite/c_test/x64_be_enable_test/GCC00242-g.torture.execute-920501-9/920501-9.c
new file mode 100644
index 0000000000000000000000000000000000000000..f585ac6e0f42c047780bf5dd11fbd87143575878
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00242-g.torture.execute-920501-9/920501-9.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+
+long long proc1(){return 1LL;}
+long long proc2(){return 0x12345678LL;}
+long long proc3(){return 0xaabbccdd12345678LL;}
+long long proc4(){return -1LL;}
+long long proc5(){return 0xaabbccddLL;}
+
+print_longlong(x,buf)
+     long long x;
+     char *buf;
+{
+  unsigned long l;
+  l= (x >> 32) & 0xffffffff;
+  if (l != 0)
+    sprintf(buf,"%lx%08.lx",l,((unsigned long)x & 0xffffffff));
+  else
+    sprintf(buf,"%lx",((unsigned long)x & 0xffffffff));
+}
+
+main(){char buf[100];
+print_longlong(proc1(),buf);if(strcmp("1",buf))abort();
+print_longlong(proc2(),buf);if(strcmp("12345678",buf))abort();
+print_longlong(proc3(),buf);if(strcmp("aabbccdd12345678",buf))abort();
+print_longlong(proc4(),buf);if(strcmp("ffffffffffffffff",buf))abort();
+print_longlong(proc5(),buf);if(strcmp("aabbccdd",buf))abort();
+exit(0);}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00242-g.torture.execute-920501-9/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00242-g.torture.execute-920501-9/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00242-g.torture.execute-920501-9/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00242-g.torture.execute-920501-9/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..565c6e822ae2020c06df9d74c268b7c6016e5364
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00242-g.torture.execute-920501-9/test.cfg
@@ -0,0 +1,2 @@
+compile(920501-9)
+run(920501-9)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00243-g.torture.execute-920506-1/920506-1.c b/testsuite/c_test/x64_be_enable_test/GCC00243-g.torture.execute-920506-1/920506-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9a646a30fc298ac082df927cb6d4d11414486c75
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00243-g.torture.execute-920506-1/920506-1.c
@@ -0,0 +1,2 @@
+int l[]={0,1};
+main(){int*p=l;switch(*p++){case 0:exit(0);case 1:break;case 2:break;case 3:case 4:break;}abort();}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00243-g.torture.execute-920506-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00243-g.torture.execute-920506-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00243-g.torture.execute-920506-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00243-g.torture.execute-920506-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..97f545b22b021c7f1ffdfd066228e8786a482a9b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00243-g.torture.execute-920506-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920506-1)
+run(920506-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00244-g.torture.execute-920618-1/920618-1.c b/testsuite/c_test/x64_be_enable_test/GCC00244-g.torture.execute-920618-1/920618-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..224f7208953b237976171995bb4a671ad0c7cad3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00244-g.torture.execute-920618-1/920618-1.c
@@ -0,0 +1 @@
+main(){if(1.17549435e-38F<=1.1)exit(0);abort();}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00244-g.torture.execute-920618-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00244-g.torture.execute-920618-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00244-g.torture.execute-920618-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00244-g.torture.execute-920618-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..145d5b5e2df3f9caa09d4f3e6cee0ca01279350f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00244-g.torture.execute-920618-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920618-1)
+run(920618-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00245-g.torture.execute-920710-1/920710-1.c b/testsuite/c_test/x64_be_enable_test/GCC00245-g.torture.execute-920710-1/920710-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7c6f871e2acdcb96069b3cc1962178523b7a79c0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00245-g.torture.execute-920710-1/920710-1.c
@@ -0,0 +1,11 @@
+main()
+{
+  if ((double) 18446744073709551615ULL < 1.84467440737095e+19 ||
+      (double) 18446744073709551615ULL > 1.84467440737096e+19)
+    abort();
+
+  if (16777217L != (float)16777217e0)
+    abort();
+
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00245-g.torture.execute-920710-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00245-g.torture.execute-920710-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00245-g.torture.execute-920710-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00245-g.torture.execute-920710-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..365a4aa843b656a02efd65a46f7ff2f45356e439
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00245-g.torture.execute-920710-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920710-1)
+run(920710-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00246-g.torture.execute-920728-1/920728-1.c b/testsuite/c_test/x64_be_enable_test/GCC00246-g.torture.execute-920728-1/920728-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..42e79f2ea536279a7c00d1f0708c9cd6935a1ef9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00246-g.torture.execute-920728-1/920728-1.c
@@ -0,0 +1,32 @@
+typedef struct {
+  int dims[0];
+} * A;
+
+int f(unsigned long obj) {
+  unsigned char y = obj >> 24;
+  y &= ~4;
+
+  if ((y == 0) || (y != 251))
+    abort();
+
+  if (((int)obj & 7) != 7)
+    return 0;
+
+REST_OF_CODE_JUST_HERE_TO_TRIGGER_THE_BUG :
+
+  {
+    unsigned char t = obj >> 24;
+    if (!(t == 0) && (t <= 0x03))
+      return 0;
+    return ((A)(obj & 0x00FFFFFFL))->dims[1];
+  }
+}
+
+long g() {
+  return 0xff000000L;
+}
+main() {
+  int x;
+  f(g());
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00246-g.torture.execute-920728-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00246-g.torture.execute-920728-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00246-g.torture.execute-920728-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00246-g.torture.execute-920728-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3cdc4d703831d658702d24f692db24e9ccfe74b6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00246-g.torture.execute-920728-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920728-1)
+run(920728-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00247-g.torture.execute-920731-1/920731-1.c b/testsuite/c_test/x64_be_enable_test/GCC00247-g.torture.execute-920731-1/920731-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..de0fb58fcde24b53ca45510d8799084495c16351
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00247-g.torture.execute-920731-1/920731-1.c
@@ -0,0 +1,2 @@
+f(x){int i;for(i=0;i<8&&(x&1)==0;x>>=1,i++);return i;}
+main(){if(f(4)!=2)abort();exit(0);}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00247-g.torture.execute-920731-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00247-g.torture.execute-920731-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00247-g.torture.execute-920731-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00247-g.torture.execute-920731-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4ff9ad405191f1a3773b5ee2f056385d4e4f9dc2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00247-g.torture.execute-920731-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920731-1)
+run(920731-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00248-g.torture.execute-920810-1/920810-1.c b/testsuite/c_test/x64_be_enable_test/GCC00248-g.torture.execute-920810-1/920810-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9565bfc1a2bb89fc1be5687693c495252e99dbd3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00248-g.torture.execute-920810-1/920810-1.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+typedef struct{void*super;int name;int size;}t;
+t*f(t*clas,int size)
+{
+  t*child=(t*)malloc(size);
+  memcpy(child,clas,clas->size);
+  child->super=clas;
+  child->name=0;
+  child->size=size;
+  return child;
+}
+main()
+{
+  t foo,*bar;
+  memset(&foo,37,sizeof(t));
+  foo.size=sizeof(t);
+  bar=f(&foo,sizeof(t));
+  if(bar->super!=&foo||bar->name!=0||bar->size!=sizeof(t))abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00248-g.torture.execute-920810-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00248-g.torture.execute-920810-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00248-g.torture.execute-920810-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00248-g.torture.execute-920810-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dea618b3405cee05506e7f07027822a270162ab9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00248-g.torture.execute-920810-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920810-1)
+run(920810-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00249-g.torture.execute-920812-1/920812-1.c b/testsuite/c_test/x64_be_enable_test/GCC00249-g.torture.execute-920812-1/920812-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..b49ab425b21675fc0669182c4b1e61870c3bff23
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00249-g.torture.execute-920812-1/920812-1.c
@@ -0,0 +1,3 @@
+typedef int t;
+f(t y){switch(y){case 1:return 1;}return 0;}
+main(){if(f((t)1)!=1)abort();exit(0);}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00249-g.torture.execute-920812-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00249-g.torture.execute-920812-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00249-g.torture.execute-920812-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00249-g.torture.execute-920812-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..85c4df93ea654ae7e2e31ad3295097975a627f71
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00249-g.torture.execute-920812-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920812-1)
+run(920812-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00250-g.torture.execute-920909-1/920909-1.c b/testsuite/c_test/x64_be_enable_test/GCC00250-g.torture.execute-920909-1/920909-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c8880348c122f18d25d6d026bac93f0ca2a3d985
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00250-g.torture.execute-920909-1/920909-1.c
@@ -0,0 +1,2 @@
+f(a){switch(a){case 0x402:return a+1;case 0x403:return a+2;case 0x404:return a+3;case 0x405:return a+4;case 0x406:return 1;case 0x407:return 4;}return 0;}
+main(){if(f(1))abort();exit(0);}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00250-g.torture.execute-920909-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00250-g.torture.execute-920909-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00250-g.torture.execute-920909-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00250-g.torture.execute-920909-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..093a06db2c061a1d5273a67df11adc48247ba231
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00250-g.torture.execute-920909-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920909-1)
+run(920909-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00251-g.torture.execute-920922-1/920922-1.c b/testsuite/c_test/x64_be_enable_test/GCC00251-g.torture.execute-920922-1/920922-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4fae192bb90d94133f163bdf74def8b18144c3cd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00251-g.torture.execute-920922-1/920922-1.c
@@ -0,0 +1,14 @@
+unsigned long*
+f(p)unsigned long*p;
+{
+  unsigned long a = (*p++) >> 24;
+  return p + a;
+}
+
+main ()
+{
+  unsigned long x = 0x80000000UL;
+  if (f(&x) != &x + 0x81)
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00251-g.torture.execute-920922-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00251-g.torture.execute-920922-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00251-g.torture.execute-920922-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00251-g.torture.execute-920922-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d2bb15abcc763994d5528e2a1d5b3acf798ba58b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00251-g.torture.execute-920922-1/test.cfg
@@ -0,0 +1,2 @@
+compile(920922-1)
+run(920922-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00252-g.torture.execute-921006-1/921006-1.c b/testsuite/c_test/x64_be_enable_test/GCC00252-g.torture.execute-921006-1/921006-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..50fbdb711251754ad713fca078f640fa36032055
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00252-g.torture.execute-921006-1/921006-1.c
@@ -0,0 +1,6 @@
+/* REPRODUCED:RUN:SIGNAL MACHINE:i386 OPTIONS:-O */
+main()
+{
+if(strcmp("X","")<0)abort();
+exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00252-g.torture.execute-921006-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00252-g.torture.execute-921006-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00252-g.torture.execute-921006-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00252-g.torture.execute-921006-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c3be0740361b1a8004b28d098f57d99f0268b97c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00252-g.torture.execute-921006-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921006-1)
+run(921006-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00253-g.torture.execute-921007-1/921007-1.c b/testsuite/c_test/x64_be_enable_test/GCC00253-g.torture.execute-921007-1/921007-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..23ab52e7ae89cdea8a50a6e396f78ead7ab41b1c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00253-g.torture.execute-921007-1/921007-1.c
@@ -0,0 +1,7 @@
+static int strcmp(){return-1;}
+#define strcmp __builtin_strcmp
+main()
+{
+if(strcmp("X","X\376")>=0)abort();
+exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00253-g.torture.execute-921007-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00253-g.torture.execute-921007-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00253-g.torture.execute-921007-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00253-g.torture.execute-921007-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ef25c9b2299663ba79bbf974023532bd62844cb5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00253-g.torture.execute-921007-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921007-1)
+run(921007-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00254-g.torture.execute-921029-1/921029-1.c b/testsuite/c_test/x64_be_enable_test/GCC00254-g.torture.execute-921029-1/921029-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..76fc974c2f088b0ec853172fe35ac21d1ad3654b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00254-g.torture.execute-921029-1/921029-1.c
@@ -0,0 +1,42 @@
+typedef unsigned long long ULL;
+ULL back;
+ULL hpart, lpart;
+ULL
+build(long h, long l)
+{
+  hpart = h;
+  hpart <<= 32;
+  lpart = l;
+  lpart &= 0xFFFFFFFFLL;
+  back = hpart | lpart;
+  return back;
+}
+
+main()
+{
+  if (build(0, 1) != 0x0000000000000001LL)
+    abort();
+  if (build(0, 0) != 0x0000000000000000LL)
+    abort();
+  if (build(0, 0xFFFFFFFF) != 0x00000000FFFFFFFFLL)
+    abort();
+  if (build(0, 0xFFFFFFFE) != 0x00000000FFFFFFFELL)
+    abort();
+  if (build(1, 1) != 0x0000000100000001LL)
+    abort();
+  if (build(1, 0) != 0x0000000100000000LL)
+    abort();
+  if (build(1, 0xFFFFFFFF) != 0x00000001FFFFFFFFLL)
+    abort();
+  if (build(1, 0xFFFFFFFE) != 0x00000001FFFFFFFELL)
+    abort();
+  if (build(0xFFFFFFFF, 1) != 0xFFFFFFFF00000001LL)
+    abort();
+  if (build(0xFFFFFFFF, 0) != 0xFFFFFFFF00000000LL)
+    abort();
+  if (build(0xFFFFFFFF, 0xFFFFFFFF) != 0xFFFFFFFFFFFFFFFFLL)
+    abort();
+  if (build(0xFFFFFFFF, 0xFFFFFFFE) != 0xFFFFFFFFFFFFFFFELL)
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00254-g.torture.execute-921029-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00254-g.torture.execute-921029-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00254-g.torture.execute-921029-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00254-g.torture.execute-921029-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..843a16e2bc088d479f4767dbe28a00e24245aa5d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00254-g.torture.execute-921029-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921029-1)
+run(921029-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00255-g.torture.execute-921112-1/921112-1.c b/testsuite/c_test/x64_be_enable_test/GCC00255-g.torture.execute-921112-1/921112-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5946398e3c0ddc1c0cbe06b60877dae6afab7818
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00255-g.torture.execute-921112-1/921112-1.c
@@ -0,0 +1,21 @@
+union u {
+  struct { int i1, i2; } t;
+  double d;
+} x[2], v;
+
+f (x, v)
+     union u *x, v;
+{
+  *++x = v;
+}
+
+main()
+{
+  x[1].t.i1 = x[1].t.i2 = 0;
+  v.t.i1 = 1;
+  v.t.i2 = 2;
+  f (x, v);
+  if (x[1].t.i1 != 1 || x[1].t.i2 != 2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00255-g.torture.execute-921112-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00255-g.torture.execute-921112-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00255-g.torture.execute-921112-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00255-g.torture.execute-921112-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..530d910d469904952a468059205edd5a7a9204ff
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00255-g.torture.execute-921112-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921112-1)
+run(921112-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00256-g.torture.execute-921117-1/921117-1.c b/testsuite/c_test/x64_be_enable_test/GCC00256-g.torture.execute-921117-1/921117-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..2ed30fbeeef8688413120d50708cf1c75de5931b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00256-g.torture.execute-921117-1/921117-1.c
@@ -0,0 +1,22 @@
+struct s {
+  char text[11];
+  int flag;
+} cell;
+
+int
+check (struct s p)
+{
+  if (p.flag != 99)
+    return 1;
+  return strcmp (p.text, "0123456789");
+}
+
+main ()
+{
+  cell.flag = 99;
+  strcpy (cell.text, "0123456789");
+
+  if (check (cell))
+    abort();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00256-g.torture.execute-921117-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00256-g.torture.execute-921117-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00256-g.torture.execute-921117-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00256-g.torture.execute-921117-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc451b65a4703b768e2b6cf6987457625c2101da
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00256-g.torture.execute-921117-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921117-1)
+run(921117-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00257-g.torture.execute-921202-1/921202-1.c b/testsuite/c_test/x64_be_enable_test/GCC00257-g.torture.execute-921202-1/921202-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c6b8c79fc548756613a19c49e2ed7bdbe80cd40
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00257-g.torture.execute-921202-1/921202-1.c
@@ -0,0 +1,44 @@
+/* { dg-require-effective-target untyped_assembly } */
+/* { dg-add-options stack_size } */
+
+#ifndef STACK_SIZE
+#define	VLEN	2055
+#else
+#define VLEN ((STACK_SIZE/16) - 1)
+#endif
+main ()
+{
+  long dx[VLEN+1];
+  long dy[VLEN+1];
+  long s1[VLEN];
+  int cyx, cyy;
+  int i;
+  long size;
+
+  for (;;)
+    {
+      size = VLEN;
+      mpn_random2 (s1, size);
+
+      for (i = 0; i < 1; i++)
+	;
+
+      dy[size] = 0x12345678;
+
+      for (i = 0; i < 1; i++)
+	cyy = mpn_mul_1 (dy, s1, size);
+
+      if (cyx != cyy || mpn_cmp (dx, dy, size + 1) != 0 || dx[size] != 0x12345678)
+	{
+	  foo ("", 8, cyy); mpn_print (dy, size);
+	}
+      exxit();
+    }
+}
+
+foo (){}
+mpn_mul_1(){}
+mpn_print (){}
+mpn_random2(){}
+mpn_cmp(){}
+exxit(){exit(0);}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00257-g.torture.execute-921202-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00257-g.torture.execute-921202-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00257-g.torture.execute-921202-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00257-g.torture.execute-921202-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d209cccad9a7363ef0c5728fdbc40a4bbc38eb1e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00257-g.torture.execute-921202-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921202-1)
+run(921202-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00258-g.torture.execute-921202-2/921202-2.c b/testsuite/c_test/x64_be_enable_test/GCC00258-g.torture.execute-921202-2/921202-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..48d4a412d1bdb65dcff61198ec916fc8fed67a6a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00258-g.torture.execute-921202-2/921202-2.c
@@ -0,0 +1,13 @@
+int
+f(long long x)
+{
+  x >>= 8;
+  return x & 0xff;
+}
+
+main()
+{
+  if (f(0x0123456789ABCDEFLL) != 0xCD)
+    abort();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00258-g.torture.execute-921202-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00258-g.torture.execute-921202-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00258-g.torture.execute-921202-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00258-g.torture.execute-921202-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..13f4c379b6b6bad39f9529a613d4a83c23f97af2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00258-g.torture.execute-921202-2/test.cfg
@@ -0,0 +1,2 @@
+compile(921202-2)
+run(921202-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00259-g.torture.execute-921204-1/921204-1.c b/testsuite/c_test/x64_be_enable_test/GCC00259-g.torture.execute-921204-1/921204-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a7bba830a34ca0f794986d772560e610d99c147e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00259-g.torture.execute-921204-1/921204-1.c
@@ -0,0 +1,46 @@
+/* The bit-field below would have a problem if __INT_MAX__ is too
+   small.  */
+#if __INT_MAX__ < 2147483647
+int
+main (void)
+{
+  exit (0);
+}
+#else
+typedef struct {
+  unsigned b0:1, f1:17, b18:1, b19:1, b20:1, f2:11;
+} bf;
+
+typedef union {
+  bf b;
+  unsigned w;
+} bu;
+
+bu
+f(bu i)
+{
+  bu o = i;
+
+  if (o.b.b0)
+    o.b.b18 = 1,
+    o.b.b20 = 1;
+  else
+    o.b.b18 = 0,
+    o.b.b20 = 0;
+
+  return o;
+}
+
+main()
+{
+  bu a;
+  bu r;
+
+  a.w = 0x4000000;
+  a.b.b0 = 0;
+  r = f(a);
+  if (a.w != r.w)
+    abort();
+  exit(0);
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00259-g.torture.execute-921204-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00259-g.torture.execute-921204-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00259-g.torture.execute-921204-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00259-g.torture.execute-921204-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fadf7e6805b910a250e425d9295edfccf73d3137
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00259-g.torture.execute-921204-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921204-1)
+run(921204-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00260-g.torture.execute-930111-1/930111-1.c b/testsuite/c_test/x64_be_enable_test/GCC00260-g.torture.execute-930111-1/930111-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e908f14f67f665f8faa4e39f137c35e29f94c3df
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00260-g.torture.execute-930111-1/930111-1.c
@@ -0,0 +1,22 @@
+main()
+{
+  if (wwrite((long long) 0) != 123)
+    abort();
+  exit(0);
+}
+
+int
+wwrite(long long i)
+{
+  switch(i)
+    {
+    case 3:
+    case 10:
+    case 23:
+    case 28:
+    case 47:
+      return 0;
+    default:
+      return 123;
+    }
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00260-g.torture.execute-930111-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00260-g.torture.execute-930111-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00260-g.torture.execute-930111-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00260-g.torture.execute-930111-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ab6a4edb078f7921d416bd2851aee990523657f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00260-g.torture.execute-930111-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930111-1)
+run(930111-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00261-g.torture.execute-930126-1/930126-1.c b/testsuite/c_test/x64_be_enable_test/GCC00261-g.torture.execute-930126-1/930126-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ff08e7d6131c029cc39ef5361c37d3765149ac6e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00261-g.torture.execute-930126-1/930126-1.c
@@ -0,0 +1,20 @@
+struct s {
+  unsigned long long a:8, b:32;
+};
+
+struct s
+f(struct s x)
+{
+  x.b = 0xcdef1234;
+  return x;
+}
+
+main()
+{
+  static struct s i;
+  i.a = 12;
+  i = f(i);
+  if (i.a != 12 || i.b != 0xcdef1234)
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00261-g.torture.execute-930126-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00261-g.torture.execute-930126-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00261-g.torture.execute-930126-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00261-g.torture.execute-930126-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5450aca7f2dbbfbf9bce0ce7bf50199d0635b33e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00261-g.torture.execute-930126-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930126-1)
+run(930126-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00262-g.torture.execute-930408-1/930408-1.c b/testsuite/c_test/x64_be_enable_test/GCC00262-g.torture.execute-930408-1/930408-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..42ffc098f8007d011527d5b09890c7f277829832
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00262-g.torture.execute-930408-1/930408-1.c
@@ -0,0 +1,27 @@
+typedef enum foo E;
+enum foo { e0, e1 };
+
+struct {
+  E eval;
+} s;
+
+p()
+{
+  abort();
+}
+
+f()
+{
+  switch (s.eval)
+    {
+    case e0:
+      p();
+    }
+}
+
+main()
+{
+  s.eval = e1;
+  f();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00262-g.torture.execute-930408-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00262-g.torture.execute-930408-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00262-g.torture.execute-930408-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00262-g.torture.execute-930408-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..29503f60304c672e0b72ddf5097425108a636620
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00262-g.torture.execute-930408-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930408-1)
+run(930408-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00263-g.torture.execute-930513-2/930513-2.c b/testsuite/c_test/x64_be_enable_test/GCC00263-g.torture.execute-930513-2/930513-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..3731f6204975b40dd733dc5ad682e111789ddbdf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00263-g.torture.execute-930513-2/930513-2.c
@@ -0,0 +1,27 @@
+sub3 (i)
+     const int *i;
+{
+}
+
+eq (a, b)
+{
+  static int i = 0;
+  if (a != i)
+    abort ();
+  i++;
+}
+
+main ()
+{
+  int i;
+
+  for (i = 0; i < 4; i++)
+    {
+      const int j = i;
+      int k;
+      sub3 (&j);
+      k = j;
+      eq (k, k);
+    }
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00263-g.torture.execute-930513-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00263-g.torture.execute-930513-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00263-g.torture.execute-930513-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00263-g.torture.execute-930513-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fe3f94e16aeca59bd2ee60cac6c53ef5f4228392
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00263-g.torture.execute-930513-2/test.cfg
@@ -0,0 +1,2 @@
+compile(930513-2)
+run(930513-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00264-g.torture.execute-930518-1/930518-1.c b/testsuite/c_test/x64_be_enable_test/GCC00264-g.torture.execute-930518-1/930518-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..44bdf96afb739e6dd25fca7441e63d27aa7aaf6c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00264-g.torture.execute-930518-1/930518-1.c
@@ -0,0 +1,24 @@
+int bar = 0;
+
+f (p)
+     int *p;
+{
+  int foo = 2;
+
+  while (foo > bar)
+    {
+      foo -=  bar;
+      *p++ = foo;
+      bar = 1;
+    }
+}
+
+main ()
+{
+  int tab[2];
+  tab[0] = tab[1] = 0;
+  f (tab);
+  if (tab[0] != 2 || tab[1] != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00264-g.torture.execute-930518-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00264-g.torture.execute-930518-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00264-g.torture.execute-930518-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00264-g.torture.execute-930518-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1183d9adfe26428bf0748268ed9ff5d188a1b434
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00264-g.torture.execute-930518-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930518-1)
+run(930518-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00265-g.torture.execute-930527-1/930527-1.c b/testsuite/c_test/x64_be_enable_test/GCC00265-g.torture.execute-930527-1/930527-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..fef34bf6b7f759ebfe7bfd42133ff129feffb847
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00265-g.torture.execute-930527-1/930527-1.c
@@ -0,0 +1,11 @@
+f (unsigned char x)
+{
+  return (0x50 | (x >> 4)) ^ 0xff;
+}
+
+main ()
+{
+  if (f (0) != 0xaf)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00265-g.torture.execute-930527-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00265-g.torture.execute-930527-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00265-g.torture.execute-930527-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00265-g.torture.execute-930527-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa4c556a6d08e65d804803d39bcbad4db2ae6733
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00265-g.torture.execute-930527-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930527-1)
+run(930527-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00266-g.torture.execute-930603-2/930603-2.c b/testsuite/c_test/x64_be_enable_test/GCC00266-g.torture.execute-930603-2/930603-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..8cf06a211390b796784f19fdc2b86b1c0617e652
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00266-g.torture.execute-930603-2/930603-2.c
@@ -0,0 +1,19 @@
+int w[2][2];
+
+f ()
+{
+  int i, j;
+
+  for (i = 0; i < 2; i++)
+    for (j = 0; j < 2; j++)
+      if (i == j)
+	w[i][j] = 1;
+}
+
+main ()
+{
+  f ();
+  if (w[0][0] != 1 || w[1][1] != 1 || w[1][0] != 0 || w[0][1] != 0)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00266-g.torture.execute-930603-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00266-g.torture.execute-930603-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00266-g.torture.execute-930603-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00266-g.torture.execute-930603-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3f49e694db9f42ed31aec8cd3d1e2877443c6a9b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00266-g.torture.execute-930603-2/test.cfg
@@ -0,0 +1,2 @@
+compile(930603-2)
+run(930603-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00267-g.torture.execute-930603-3/930603-3.c b/testsuite/c_test/x64_be_enable_test/GCC00267-g.torture.execute-930603-3/930603-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..22e5aed4a8b9e5bdb490828abc31acd9b262de74
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00267-g.torture.execute-930603-3/930603-3.c
@@ -0,0 +1,30 @@
+f (b, c)
+     unsigned char *b;
+     int c;
+{
+  unsigned long v = 0;
+  switch (c)
+    {
+    case 'd':
+      v = ((unsigned long)b[0] << 8) + b[1];
+      v >>= 9;
+      break;
+
+    case 'k':
+      v = b[3] >> 4;
+      break;
+
+    default:
+      abort ();
+    }
+
+  return v;
+}
+main ()
+{
+  char buf[4];
+  buf[0] = 170; buf[1] = 5;
+  if (f (buf, 'd') != 85)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00267-g.torture.execute-930603-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00267-g.torture.execute-930603-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00267-g.torture.execute-930603-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00267-g.torture.execute-930603-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..53e2bb57baf09e9dd68e8ff2df2afe401fce8413
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00267-g.torture.execute-930603-3/test.cfg
@@ -0,0 +1,2 @@
+compile(930603-3)
+run(930603-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00268-g.torture.execute-930621-1/930621-1.c b/testsuite/c_test/x64_be_enable_test/GCC00268-g.torture.execute-930621-1/930621-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4bb7cdbe0760beb9ea08d7e257f38eebe8ce7083
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00268-g.torture.execute-930621-1/930621-1.c
@@ -0,0 +1,29 @@
+/* The bit-field below would have a problem if __INT_MAX__ is too
+   small.  */
+#if __INT_MAX__ < 2147483647
+int
+main (void)
+{
+  exit (0);
+}
+#else
+f ()
+{
+  struct {
+    int x : 18;
+    int y : 14;
+  } foo;
+
+  foo.x = 10;
+  foo.y = 20;
+
+  return foo.y;
+}
+
+main ()
+{
+  if (f () != 20)
+    abort ();
+  exit (0);
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00268-g.torture.execute-930621-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00268-g.torture.execute-930621-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00268-g.torture.execute-930621-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00268-g.torture.execute-930621-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b0eff7a8e06d09957e5bb60577f0706c921ad3c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00268-g.torture.execute-930621-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930621-1)
+run(930621-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00269-g.torture.execute-930622-1/930622-1.c b/testsuite/c_test/x64_be_enable_test/GCC00269-g.torture.execute-930622-1/930622-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d733e133d35af6d3608b390f90e35e442039b2a2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00269-g.torture.execute-930622-1/930622-1.c
@@ -0,0 +1,22 @@
+int a = 1, b;
+
+g () { return 0; }
+h (x) {}
+
+f ()
+{
+  if (g () == -1)
+    return 0;
+  a = g ();
+  if (b >= 1)
+    h (a);
+  return 0;
+}
+
+main ()
+{
+  f ();
+  if (a != 0)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00269-g.torture.execute-930622-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00269-g.torture.execute-930622-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00269-g.torture.execute-930622-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00269-g.torture.execute-930622-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..56531a9aa0d938861222b0f17d07d4ab8494a376
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00269-g.torture.execute-930622-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930622-1)
+run(930622-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00270-g.torture.execute-930630-1/930630-1.c b/testsuite/c_test/x64_be_enable_test/GCC00270-g.torture.execute-930630-1/930630-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..38ad1fdfd7ba8e9c2ad07143839243a7910dbde3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00270-g.torture.execute-930630-1/930630-1.c
@@ -0,0 +1,29 @@
+/* The bit-field below would have a problem if __INT_MAX__ is too
+   small.  */
+#if __INT_MAX__ < 2147483647
+int
+main (void)
+{
+  exit (0);
+}
+#else
+main ()
+{
+  struct
+    {
+      signed int bf0:17;
+      signed int bf1:7;
+    } bf;
+
+  bf.bf1 = 7;
+  f (bf.bf1);
+  exit (0);
+}
+
+f (x)
+     int x;
+{
+  if (x != 7)
+    abort ();
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00270-g.torture.execute-930630-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00270-g.torture.execute-930630-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00270-g.torture.execute-930630-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00270-g.torture.execute-930630-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cf7d1cedcf3eb999b68287ec0f916caae92cef6b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00270-g.torture.execute-930630-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930630-1)
+run(930630-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00271-g.torture.execute-930719-1/930719-1.c b/testsuite/c_test/x64_be_enable_test/GCC00271-g.torture.execute-930719-1/930719-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c6557efc73530d7935cd40c50c339c002e413691
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00271-g.torture.execute-930719-1/930719-1.c
@@ -0,0 +1,23 @@
+int
+f (foo, bar, com)
+{
+  unsigned align;
+  if (foo)
+    return 0;
+  while (1)
+    {
+      switch (bar)
+	{
+	case 1:
+	  if (com != 0)
+ 	    return align;
+	  *(char *) 0 = 0;
+	}
+    }
+}
+
+main ()
+{
+  f (0, 1, 1);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00271-g.torture.execute-930719-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00271-g.torture.execute-930719-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00271-g.torture.execute-930719-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00271-g.torture.execute-930719-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a34ae6121c3347f5f6150e593c091aad40138207
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00271-g.torture.execute-930719-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930719-1)
+run(930719-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00272-g.torture.execute-930725-1/930725-1.c b/testsuite/c_test/x64_be_enable_test/GCC00272-g.torture.execute-930725-1/930725-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3bd738ca08a92438a70bf5d7ab61436b75ae0092
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00272-g.torture.execute-930725-1/930725-1.c
@@ -0,0 +1,21 @@
+int v;
+
+char *
+g ()
+{
+  return "";
+}
+
+char *
+f ()
+{
+  return (v == 0 ? g () : "abc");
+}
+
+main ()
+{
+  v = 1;
+  if (!strcmp (f (), "abc"))
+    exit (0);
+  abort();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00272-g.torture.execute-930725-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00272-g.torture.execute-930725-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00272-g.torture.execute-930725-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00272-g.torture.execute-930725-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..14db7870780da48c80d00f12d782f59dd9cf7ddf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00272-g.torture.execute-930725-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930725-1)
+run(930725-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00273-g.torture.execute-930929-1/930929-1.c b/testsuite/c_test/x64_be_enable_test/GCC00273-g.torture.execute-930929-1/930929-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..31f695442f57973b14576b9eff92c5e3b72193bb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00273-g.torture.execute-930929-1/930929-1.c
@@ -0,0 +1,36 @@
+sub1 (i)
+     int i;
+{
+  return i - (5 - i);
+}
+
+sub2 (i)
+     int i;
+{
+  return i + (5 + i);
+}
+
+sub3 (i)
+     int i;
+{
+  return i - (5 + i);
+}
+
+sub4 (i)
+     int i;
+{
+  return i + (5 - i);
+}
+
+main()
+{
+  if (sub1 (20) != 35)
+    abort ();
+  if (sub2 (20) != 45)
+    abort ();
+  if (sub3 (20) != -5)
+    abort ();
+  if (sub4 (20) != 5)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00273-g.torture.execute-930929-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00273-g.torture.execute-930929-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00273-g.torture.execute-930929-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00273-g.torture.execute-930929-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..654a8b9a8a7ed1e6ec0ba749c4ad9fee88dbd417
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00273-g.torture.execute-930929-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930929-1)
+run(930929-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00274-g.torture.execute-930930-1/930930-1.c b/testsuite/c_test/x64_be_enable_test/GCC00274-g.torture.execute-930930-1/930930-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..101a5f9ef2688e4c2e8289476cf32ac6df6b2be3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00274-g.torture.execute-930930-1/930930-1.c
@@ -0,0 +1,36 @@
+__extension__ typedef __PTRDIFF_TYPE__ ptr_t;
+ptr_t *wm_TR;
+ptr_t *wm_HB;
+ptr_t *wm_SPB;
+
+ptr_t mem[100];
+
+f (mr_TR, mr_SPB, mr_HB, reg1, reg2)
+     ptr_t *mr_TR;
+     ptr_t *mr_SPB;
+     ptr_t *mr_HB;
+     ptr_t *reg1;
+     ptr_t *reg2;
+{
+  ptr_t *x = mr_TR;
+
+  for (;;)
+    {
+      if (reg1 < reg2)
+	goto out;
+      if ((ptr_t *) *reg1 < mr_HB && (ptr_t *) *reg1 >= mr_SPB)
+	*--mr_TR = *reg1;
+      reg1--;
+    }
+ out:
+
+  if (x != mr_TR)
+    abort ();
+}
+
+main ()
+{
+  mem[99] = (ptr_t) mem;
+  f (mem + 100, mem + 6, mem + 8, mem + 99, mem + 99);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00274-g.torture.execute-930930-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00274-g.torture.execute-930930-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00274-g.torture.execute-930930-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00274-g.torture.execute-930930-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa736bf3eb3778f07e91afaa7cd717a43b43db50
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00274-g.torture.execute-930930-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930930-1)
+run(930930-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00275-g.torture.execute-931004-1/931004-1.c b/testsuite/c_test/x64_be_enable_test/GCC00275-g.torture.execute-931004-1/931004-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9c89afdae35afeef720a95290359b8b00d343a1d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00275-g.torture.execute-931004-1/931004-1.c
@@ -0,0 +1,30 @@
+struct tiny
+{
+  int c;
+};
+
+f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
+{
+  if (x.c != 10)
+    abort();
+
+  if (y.c != 11)
+    abort();
+
+  if (z.c != 12)
+    abort();
+
+  if (l != 123)
+    abort ();
+}
+
+main ()
+{
+  struct tiny x[3];
+  x[0].c = 10;
+  x[1].c = 11;
+  x[2].c = 12;
+  f (3, x[0], x[1], x[2], (long) 123);
+  exit(0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00275-g.torture.execute-931004-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00275-g.torture.execute-931004-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00275-g.torture.execute-931004-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00275-g.torture.execute-931004-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6236390f5e83d91328d6586fad9e7d668d8f07b9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00275-g.torture.execute-931004-1/test.cfg
@@ -0,0 +1,2 @@
+compile(931004-1)
+run(931004-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00276-g.torture.execute-931012-1/931012-1.c b/testsuite/c_test/x64_be_enable_test/GCC00276-g.torture.execute-931012-1/931012-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d9c958ddb90ec9accb8222aa44588d82205fc91a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00276-g.torture.execute-931012-1/931012-1.c
@@ -0,0 +1,13 @@
+f (int b, int c)
+{
+  if (b != 0 && b != 1 && c != 0)
+    b = 0;
+  return b;
+}
+
+main ()
+{
+  if (!f (1, 2))
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00276-g.torture.execute-931012-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00276-g.torture.execute-931012-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00276-g.torture.execute-931012-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00276-g.torture.execute-931012-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5cd019e5195fcc94acb835c782d47e6a1d2c1eb0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00276-g.torture.execute-931012-1/test.cfg
@@ -0,0 +1,2 @@
+compile(931012-1)
+run(931012-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00277-g.torture.execute-931017-1/931017-1.c b/testsuite/c_test/x64_be_enable_test/GCC00277-g.torture.execute-931017-1/931017-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5917bd95b76daf388039ec17cff89f423435845c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00277-g.torture.execute-931017-1/931017-1.c
@@ -0,0 +1,54 @@
+int v;
+
+main ()
+{
+  f ();
+  exit (0);
+}
+
+h1 ()
+{
+  return 0;
+}
+
+h2 (e)
+     int *e;
+{
+  if (e != &v)
+    abort ();
+  return 0;
+}
+
+g (c)
+     char *c;
+{
+  int i;
+  int b;
+
+  do
+    {
+      i = h1 ();
+      if (i == -1)
+	return 0;
+      else if (i == 1)
+	h1 ();
+    }
+  while (i == 1);
+
+  do
+    b = h2 (&v);
+  while (i == 5);
+
+  if (i != 2)
+    return b;
+  *c = 'a';
+
+  return 0;
+}
+
+
+f ()
+{
+  char c;
+  g (&c);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00277-g.torture.execute-931017-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00277-g.torture.execute-931017-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00277-g.torture.execute-931017-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00277-g.torture.execute-931017-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a61b6dde78c00f6ff71a90d167ff898189e6d7a3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00277-g.torture.execute-931017-1/test.cfg
@@ -0,0 +1,2 @@
+compile(931017-1)
+run(931017-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00278-g.torture.execute-931018-1/931018-1.c b/testsuite/c_test/x64_be_enable_test/GCC00278-g.torture.execute-931018-1/931018-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..01b6050bf3531933a866512f2f37812223c69754
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00278-g.torture.execute-931018-1/931018-1.c
@@ -0,0 +1,18 @@
+unsigned int a[0x1000];
+extern const unsigned long v;
+
+main ()
+{
+  f (v);
+  f (v);
+  exit (0);
+}
+
+f (a)
+     unsigned long a;
+{
+  if (a != 0xdeadbeefL)
+    abort();
+}
+
+const unsigned long v = 0xdeadbeefL;
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00278-g.torture.execute-931018-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00278-g.torture.execute-931018-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00278-g.torture.execute-931018-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00278-g.torture.execute-931018-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a3262742fe2dcb3f7c7fa54c3720c73107fc7e7e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00278-g.torture.execute-931018-1/test.cfg
@@ -0,0 +1,2 @@
+compile(931018-1)
+run(931018-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00279-g.torture.execute-931031-1/931031-1.c b/testsuite/c_test/x64_be_enable_test/GCC00279-g.torture.execute-931031-1/931031-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e9ce337955d66926546bce89b1cf45c33d92e693
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00279-g.torture.execute-931031-1/931031-1.c
@@ -0,0 +1,34 @@
+/* The bit-field below would have a problem if __INT_MAX__ is too
+   small.  */
+#if __INT_MAX__ < 2147483647
+int
+main (void)
+{
+  exit (0);
+}
+#else
+struct foo
+{
+  unsigned y:1;
+  unsigned x:32;
+};
+
+int
+f (x)
+     struct foo x;
+{
+  int t = x.x;
+  if (t < 0)
+    return 1;
+  return t+1;
+}
+
+main ()
+{
+  struct foo x;
+  x.x = -1;
+  if (f (x) == 0)
+    abort ();
+  exit (0);
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00279-g.torture.execute-931031-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00279-g.torture.execute-931031-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00279-g.torture.execute-931031-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00279-g.torture.execute-931031-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f30c335968a98b7df51bb992695e3f7e9ba4dfc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00279-g.torture.execute-931031-1/test.cfg
@@ -0,0 +1,2 @@
+compile(931031-1)
+run(931031-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00280-g.torture.execute-931208-1/931208-1.c b/testsuite/c_test/x64_be_enable_test/GCC00280-g.torture.execute-931208-1/931208-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ee2bc9f1e04df8806e2cf1613afcfbdcb813eaa9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00280-g.torture.execute-931208-1/931208-1.c
@@ -0,0 +1,14 @@
+f ()
+{
+  unsigned long x, y = 1;
+
+  x = ((y * 8192) - 216) / 16;
+  return x;
+}
+
+main ()
+{
+  if (f () != 498)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00280-g.torture.execute-931208-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00280-g.torture.execute-931208-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00280-g.torture.execute-931208-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00280-g.torture.execute-931208-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e2634523d3f442a30b2a2002be7c3020c60c7e26
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00280-g.torture.execute-931208-1/test.cfg
@@ -0,0 +1,2 @@
+compile(931208-1)
+run(931208-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00281-g.torture.execute-931228-1/931228-1.c b/testsuite/c_test/x64_be_enable_test/GCC00281-g.torture.execute-931228-1/931228-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..dcd3b65ff3bacc0712ce4b9ce8d569d346b43a98
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00281-g.torture.execute-931228-1/931228-1.c
@@ -0,0 +1,15 @@
+f (x)
+{
+  x &= 010000;
+  x &= 007777;
+  x ^= 017777;
+  x &= 017770;
+  return x;
+}
+
+main ()
+{
+  if (f (-1) != 017770)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00281-g.torture.execute-931228-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00281-g.torture.execute-931228-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00281-g.torture.execute-931228-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00281-g.torture.execute-931228-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..11d85bd7b5767ef380b269e52288b1089ce52b03
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00281-g.torture.execute-931228-1/test.cfg
@@ -0,0 +1,2 @@
+compile(931228-1)
+run(931228-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00282-g.torture.execute-940115-1/940115-1.c b/testsuite/c_test/x64_be_enable_test/GCC00282-g.torture.execute-940115-1/940115-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d0fac9077a1d1a45958a4d58291f373f48e9961e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00282-g.torture.execute-940115-1/940115-1.c
@@ -0,0 +1,13 @@
+f (cp, end)
+     char *cp;
+     char *end;
+{
+  return (cp < end);
+}
+
+main ()
+{
+  if (! f ((char *) 0, (char *) 1))
+    abort();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00282-g.torture.execute-940115-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00282-g.torture.execute-940115-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00282-g.torture.execute-940115-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00282-g.torture.execute-940115-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4023436ceeaecd7a10ce8500fbd0b798d6058bca
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00282-g.torture.execute-940115-1/test.cfg
@@ -0,0 +1,2 @@
+compile(940115-1)
+run(940115-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00283-g.torture.execute-941014-1/941014-1.c b/testsuite/c_test/x64_be_enable_test/GCC00283-g.torture.execute-941014-1/941014-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..98db917428fd19a459c1fd08240190bc31805db4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00283-g.torture.execute-941014-1/941014-1.c
@@ -0,0 +1,15 @@
+int f (int a, int b) { }
+
+main ()
+{
+  unsigned long addr1;
+  unsigned long addr2;
+
+  addr1 = (unsigned long) &f;
+  addr1 += 5;
+  addr2 = 5 + (unsigned long) &f;
+
+  if (addr1 != addr2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00283-g.torture.execute-941014-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00283-g.torture.execute-941014-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00283-g.torture.execute-941014-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00283-g.torture.execute-941014-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..418a767629a092f05b3636c274b5fc018088247e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00283-g.torture.execute-941014-1/test.cfg
@@ -0,0 +1,2 @@
+compile(941014-1)
+run(941014-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00284-g.torture.execute-941025-1/941025-1.c b/testsuite/c_test/x64_be_enable_test/GCC00284-g.torture.execute-941025-1/941025-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..2daf0ad25cc28c3813070b40a1d9935a818bc383
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00284-g.torture.execute-941025-1/941025-1.c
@@ -0,0 +1,12 @@
+long f (x, y)
+     long x,y;
+{
+  return (x > 1) ? y : (y & 1);
+}
+
+main ()
+{
+  if (f (2L, 0xdecadeL) != 0xdecadeL)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00284-g.torture.execute-941025-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00284-g.torture.execute-941025-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00284-g.torture.execute-941025-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00284-g.torture.execute-941025-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..df7a0241b8f8988dedff6534ca320b17018d73cc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00284-g.torture.execute-941025-1/test.cfg
@@ -0,0 +1,2 @@
+compile(941025-1)
+run(941025-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00285-g.torture.execute-941031-1/941031-1.c b/testsuite/c_test/x64_be_enable_test/GCC00285-g.torture.execute-941031-1/941031-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..134f966c6f3dffd72ecc1a5ed1310374f269db41
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00285-g.torture.execute-941031-1/941031-1.c
@@ -0,0 +1,27 @@
+typedef long mpt;
+
+int
+f (mpt us, mpt vs)
+{
+  long aus;
+  long avs;
+
+  aus = us >= 0 ? us : -us;
+  avs = vs >= 0 ? vs : -vs;
+
+  if (aus < avs)
+    {
+      long t = aus;
+      aus = avs;
+      avs = aus;
+    }
+
+  return avs;
+}
+
+main ()
+{
+  if (f ((mpt) 3, (mpt) 17) != 17)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00285-g.torture.execute-941031-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00285-g.torture.execute-941031-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00285-g.torture.execute-941031-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00285-g.torture.execute-941031-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5bc999936273340e26fd8461e2cf9479a9c2bad6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00285-g.torture.execute-941031-1/test.cfg
@@ -0,0 +1,2 @@
+compile(941031-1)
+run(941031-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00286-g.torture.execute-941110-1/941110-1.c b/testsuite/c_test/x64_be_enable_test/GCC00286-g.torture.execute-941110-1/941110-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..b78256d3c3f4018f0d4e5ff84650815767cd3d86
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00286-g.torture.execute-941110-1/941110-1.c
@@ -0,0 +1,16 @@
+f (const int x)
+{
+  int y = 0;
+  y = x ? y : -y;
+  {
+    const int *p = &x;
+  }
+  return y;
+}
+
+main ()
+{
+  if (f (0))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00286-g.torture.execute-941110-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00286-g.torture.execute-941110-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00286-g.torture.execute-941110-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00286-g.torture.execute-941110-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a02f5c134d477f7a9f9042d1c5598302e32993f4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00286-g.torture.execute-941110-1/test.cfg
@@ -0,0 +1,2 @@
+compile(941110-1)
+run(941110-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00287-g.torture.execute-941202-1/941202-1.c b/testsuite/c_test/x64_be_enable_test/GCC00287-g.torture.execute-941202-1/941202-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..b97ae0e34a736be0b7ac099605dd3e6513536fab
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00287-g.torture.execute-941202-1/941202-1.c
@@ -0,0 +1,22 @@
+/* { dg-skip-if "requires alloca" { ! alloca } { "-O0" } { "" } } */
+g (x, y)
+{
+  if (x != 3)
+    abort ();
+}
+
+static inline
+f (int i)
+{
+  int *tmp;
+
+  tmp = (int *) alloca (sizeof (i));
+  *tmp = i;
+  g (*tmp, 0);
+}
+
+main ()
+{
+  f (3);
+  exit (0);
+};
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00287-g.torture.execute-941202-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00287-g.torture.execute-941202-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00287-g.torture.execute-941202-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00287-g.torture.execute-941202-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b1d1b49862ea959ba5c5fe3fb3174b00c7377d98
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00287-g.torture.execute-941202-1/test.cfg
@@ -0,0 +1,2 @@
+compile(941202-1)
+run(941202-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00288-g.torture.execute-950221-1/950221-1.c b/testsuite/c_test/x64_be_enable_test/GCC00288-g.torture.execute-950221-1/950221-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8ef83fd5c13cf369c6a0dc7999a5bc498b7bba28
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00288-g.torture.execute-950221-1/950221-1.c
@@ -0,0 +1,57 @@
+/* { dg-add-options stack_size } */
+
+struct parsefile
+{
+  long fd;
+  char *buf;
+};
+struct parsefile basepf;
+struct parsefile *parsefile = &basepf;
+#ifdef STACK_SIZE
+int filler[STACK_SIZE / (2*sizeof(int))];
+#else
+int filler[0x3000];
+#endif
+int el;
+
+char *
+g1 (a, b)
+     int a;
+     int *b;
+{
+}
+
+g2 (a)
+     long a;
+{
+  if (a != 0xdeadbeefL)
+    abort ();
+  exit (0);
+}
+
+f ()
+{
+  register char *p, *q;
+  register int i;
+  register int something;
+
+  if (parsefile->fd == 0L && el)
+    {
+      const char *rl_cp;
+      int len;
+      rl_cp = g1 (el, &len);
+      strcpy (p, rl_cp);
+    }
+  else
+    {
+    alabel:
+      i = g2 (parsefile->fd);
+    }
+}
+
+main ()
+{
+  el = 0;
+  parsefile->fd = 0xdeadbeefL;
+  f ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00288-g.torture.execute-950221-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00288-g.torture.execute-950221-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00288-g.torture.execute-950221-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00288-g.torture.execute-950221-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1113a3cf83a41994e66ca69dfcf1b7a7575ddb75
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00288-g.torture.execute-950221-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950221-1)
+run(950221-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00289-g.torture.execute-950322-1/950322-1.c b/testsuite/c_test/x64_be_enable_test/GCC00289-g.torture.execute-950322-1/950322-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..28a1469fea0b820da2830a4a20f4ba312b2ccb4a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00289-g.torture.execute-950322-1/950322-1.c
@@ -0,0 +1,30 @@
+f (unsigned char *a)
+{
+  int i, j;
+  int x, y;
+
+  j = a[1];
+  i = a[0] - j;
+  if (i < 0)
+    {
+      x = 1;
+      y = -i;
+    }
+  else
+    {
+      x = 0;
+      y =  i;
+    }
+  return x + y;
+}
+
+
+main ()
+{
+  unsigned char a[2];
+  a[0] = 8;
+  a[1] = 9;
+  if (f (a) != 2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00289-g.torture.execute-950322-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00289-g.torture.execute-950322-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00289-g.torture.execute-950322-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00289-g.torture.execute-950322-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d5602852d5c9612b447a265b5bdeac44e75eb365
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00289-g.torture.execute-950322-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950322-1)
+run(950322-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00290-g.torture.execute-950426-1/950426-1.c b/testsuite/c_test/x64_be_enable_test/GCC00290-g.torture.execute-950426-1/950426-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..024c4b74f1d221034fa39ae48e459f823e71f5c3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00290-g.torture.execute-950426-1/950426-1.c
@@ -0,0 +1,33 @@
+
+struct tag {
+  int m1;
+  char *m2[5];
+} s1, *p1;
+
+int i;
+
+main() {
+  s1.m1 = -1;
+  p1 = &s1;
+
+  if (func1(&p1->m1) == -1)
+    foo("ok");
+  else
+    abort();
+
+  i = 3;
+  s1.m2[3] = "123";
+
+  if (strlen((p1->m2[i])++) == 3)
+    foo("ok");
+  else
+    abort();
+
+  exit(0);
+}
+
+func1(int *p) {
+  return (*p);
+}
+
+foo(char *s) {}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00290-g.torture.execute-950426-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00290-g.torture.execute-950426-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00290-g.torture.execute-950426-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00290-g.torture.execute-950426-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..de0e3d0518fdb470d732b7c5e6da28e61d78ef6e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00290-g.torture.execute-950426-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950426-1)
+run(950426-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00291-g.torture.execute-950503-1/950503-1.c b/testsuite/c_test/x64_be_enable_test/GCC00291-g.torture.execute-950503-1/950503-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1c95b369c50ac84f0df3a73472d9d739d8686994
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00291-g.torture.execute-950503-1/950503-1.c
@@ -0,0 +1,15 @@
+main ()
+{
+  int tmp;
+  unsigned long long utmp1, utmp2;
+
+  tmp = 16;
+
+  utmp1 = (~((unsigned long long) 0)) >> tmp;
+  utmp2 = (~((unsigned long long) 0)) >> 16;
+
+  if (utmp1 != utmp2)
+    abort ();
+  exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00291-g.torture.execute-950503-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00291-g.torture.execute-950503-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00291-g.torture.execute-950503-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00291-g.torture.execute-950503-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a6a9a92e828f8eb99049a0caa6af32716e0bed0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00291-g.torture.execute-950503-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950503-1)
+run(950503-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00292-g.torture.execute-950512-1/950512-1.c b/testsuite/c_test/x64_be_enable_test/GCC00292-g.torture.execute-950512-1/950512-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8aa116d27caa21ad57b19da6f610991aad959cad
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00292-g.torture.execute-950512-1/950512-1.c
@@ -0,0 +1,24 @@
+unsigned
+f1 (x)
+{
+  return ((unsigned) (x != 0) - 3) / 2;
+}
+
+unsigned long long
+f2 (x)
+{
+  return ((unsigned long long) (x != 0) - 3) / 2;
+}
+
+main ()
+{
+  if (f1 (1) != (~(unsigned) 0) >> 1)
+    abort ();
+  if (f1 (0) != ((~(unsigned) 0) >> 1) - 1)
+    abort ();
+  if (f2 (1) != (~(unsigned long long) 0) >> 1)
+    abort ();
+  if (f2 (0) != ((~(unsigned long long) 0) >> 1) - 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00292-g.torture.execute-950512-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00292-g.torture.execute-950512-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00292-g.torture.execute-950512-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00292-g.torture.execute-950512-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f7e3207714c61ac5228363d5eb87ff333b07aff4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00292-g.torture.execute-950512-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950512-1)
+run(950512-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00293-g.torture.execute-950605-1/950605-1.c b/testsuite/c_test/x64_be_enable_test/GCC00293-g.torture.execute-950605-1/950605-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d89a42e49c64ea5f90450a0480b11e68134d76ac
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00293-g.torture.execute-950605-1/950605-1.c
@@ -0,0 +1,12 @@
+f (c)
+    unsigned char c;
+{
+  if (c != 0xFF)
+    abort ();
+}
+
+main ()
+{
+  f (-1);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00293-g.torture.execute-950605-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00293-g.torture.execute-950605-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00293-g.torture.execute-950605-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00293-g.torture.execute-950605-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cb86bf2fb99b2336b11b1aeda79869016fdb8118
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00293-g.torture.execute-950605-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950605-1)
+run(950605-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00294-g.torture.execute-950607-1/950607-1.c b/testsuite/c_test/x64_be_enable_test/GCC00294-g.torture.execute-950607-1/950607-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7b1503ad11d37a98a9ce61599713f6d58327d43e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00294-g.torture.execute-950607-1/950607-1.c
@@ -0,0 +1,9 @@
+main ()
+{
+  struct { long status; } h;
+
+  h.status = 0;
+  if (((h.status & 128) == 1) && ((h.status & 32) == 0))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00294-g.torture.execute-950607-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00294-g.torture.execute-950607-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00294-g.torture.execute-950607-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00294-g.torture.execute-950607-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4ac6e4a197e1543f7489628fe41d9030e9028d16
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00294-g.torture.execute-950607-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950607-1)
+run(950607-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00295-g.torture.execute-950612-1/950612-1.c b/testsuite/c_test/x64_be_enable_test/GCC00295-g.torture.execute-950612-1/950612-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f9885279c33a15191ddac912e98cd5ae615451ad
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00295-g.torture.execute-950612-1/950612-1.c
@@ -0,0 +1,48 @@
+unsigned int
+f1 (int diff)
+{
+  return ((unsigned int) (diff < 0 ? -diff : diff));
+}
+
+unsigned int
+f2 (unsigned int diff)
+{
+  return ((unsigned int) ((signed int) diff < 0 ? -diff : diff));
+}
+
+unsigned long long
+f3 (long long diff)
+{
+  return ((unsigned long long) (diff < 0 ? -diff : diff));
+}
+
+unsigned long long
+f4 (unsigned long long diff)
+{
+  return ((unsigned long long) ((signed long long) diff < 0 ? -diff : diff));
+}
+
+main ()
+{
+  int i;
+  for (i = 0; i <= 10; i++)
+    {
+      if (f1 (i) != i)
+	abort ();
+      if (f1 (-i) != i)
+	abort ();
+      if (f2 (i) != i)
+	abort ();
+      if (f2 (-i) != i)
+	abort ();
+      if (f3 ((long long) i) != i)
+	abort ();
+      if (f3 ((long long) -i) != i)
+	abort ();
+      if (f4 ((long long) i) != i)
+	abort ();
+      if (f4 ((long long) -i) != i)
+	abort ();
+    }
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00295-g.torture.execute-950612-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00295-g.torture.execute-950612-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00295-g.torture.execute-950612-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00295-g.torture.execute-950612-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3f04e5abb3276579687f8361536a9f825e14e406
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00295-g.torture.execute-950612-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950612-1)
+run(950612-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00296-g.torture.execute-950704-1/950704-1.c b/testsuite/c_test/x64_be_enable_test/GCC00296-g.torture.execute-950704-1/950704-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f11aff8cabc88a984aec6bc5dde043e9a66c205f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00296-g.torture.execute-950704-1/950704-1.c
@@ -0,0 +1,59 @@
+int errflag;
+
+long long
+f (long long x, long long y)
+{
+  long long r;
+
+  errflag = 0;
+  r = x + y;
+  if (x >= 0)
+    {
+      if ((y < 0) || (r >= 0))
+	return r;
+    }
+  else
+    {
+      if ((y > 0) || (r < 0))
+	return r;
+    }
+  errflag = 1;
+  return 0;
+}
+
+main ()
+{
+  f (0, 0);
+  if (errflag)
+    abort ();
+
+  f (1, -1);
+  if (errflag)
+    abort ();
+
+  f (-1, 1);
+  if (errflag)
+    abort ();
+
+  f (0x8000000000000000LL, 0x8000000000000000LL);
+  if (!errflag)
+    abort ();
+
+  f (0x8000000000000000LL, -1LL);
+  if (!errflag)
+    abort ();
+
+  f (0x7fffffffffffffffLL, 0x7fffffffffffffffLL);
+  if (!errflag)
+    abort ();
+
+  f (0x7fffffffffffffffLL, 1LL);
+  if (!errflag)
+    abort ();
+
+  f (0x7fffffffffffffffLL, 0x8000000000000000LL);
+  if (errflag)
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00296-g.torture.execute-950704-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00296-g.torture.execute-950704-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00296-g.torture.execute-950704-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00296-g.torture.execute-950704-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dac91e7c41867b6e16d06608cbd977cace83cccb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00296-g.torture.execute-950704-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950704-1)
+run(950704-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00297-g.torture.execute-950710-1/950710-1.c b/testsuite/c_test/x64_be_enable_test/GCC00297-g.torture.execute-950710-1/950710-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..26ff9b2a8a0f3f93d91b1aaffc29fb4284d20e0c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00297-g.torture.execute-950710-1/950710-1.c
@@ -0,0 +1,54 @@
+struct twelve
+{
+  int a;
+  int b;
+  int c;
+};
+
+struct pair
+{
+  int first;
+  int second;
+};
+
+struct pair
+g ()
+{
+  struct pair p;
+  return p;
+}
+
+static void
+f ()
+{
+  int i;
+  for (i = 0; i < 1; i++)
+    {
+      int j;
+      for (j = 0; j < 1; j++)
+	{
+	  if (0)
+	    {
+	      int k;
+	      for (k = 0; k < 1; k++)
+		{
+		  struct pair e = g ();
+		}
+	    }
+	  else
+	    {
+	      struct twelve a, b;
+	      if ((((char *) &b - (char *) &a) < 0
+		   ? (-((char *) &b - (char *) &a))
+		   : ((char *) &b - (char *) &a))  < sizeof (a))
+		abort ();
+	    }
+	}
+    }
+}
+
+main ()
+{
+  f ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00297-g.torture.execute-950710-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00297-g.torture.execute-950710-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00297-g.torture.execute-950710-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00297-g.torture.execute-950710-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..23ad2bdf8ad9b6edaebc2f8caf8fa46a25280bbc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00297-g.torture.execute-950710-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950710-1)
+run(950710-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00298-g.torture.execute-950714-1/950714-1.c b/testsuite/c_test/x64_be_enable_test/GCC00298-g.torture.execute-950714-1/950714-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5dc44a906e2948ace252f52df6b884ba5b0bf540
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00298-g.torture.execute-950714-1/950714-1.c
@@ -0,0 +1,17 @@
+int array[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+
+main ()
+{
+  int i, j;
+  int *p;
+
+  for (i = 0; i < 10; i++)
+    for (p = &array[0]; p != &array[9]; p++)
+      if (*p == i)
+	goto label;
+
+ label:
+  if (i != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00298-g.torture.execute-950714-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00298-g.torture.execute-950714-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00298-g.torture.execute-950714-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00298-g.torture.execute-950714-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..272e60a0bbd8f51ec97059f697c78f3757fb567e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00298-g.torture.execute-950714-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950714-1)
+run(950714-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00299-g.torture.execute-950809-1/950809-1.c b/testsuite/c_test/x64_be_enable_test/GCC00299-g.torture.execute-950809-1/950809-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a33d42bd7cd624708b068e3b08c692ab9a007103
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00299-g.torture.execute-950809-1/950809-1.c
@@ -0,0 +1,33 @@
+struct S
+{
+  int *sp, fc, *sc, a[2];
+};
+
+f (struct S *x)
+{
+  int *t = x->sc;
+  int t1 = t[0];
+  int t2 = t[1];
+  int t3 = t[2];
+  int a0 = x->a[0];
+  int a1 = x->a[1];
+  t[2] = t1;
+  t[0] = a1;
+  x->a[1] = a0;
+  x->a[0] = t3;
+  x->fc = t2;
+  x->sp = t;
+}
+
+main ()
+{
+  struct S s;
+  static int sc[3] = {2, 3, 4};
+  s.sc = sc;
+  s.a[0] = 10;
+  s.a[1] = 11;
+  f (&s);
+  if (s.sp[2] != 2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00299-g.torture.execute-950809-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00299-g.torture.execute-950809-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00299-g.torture.execute-950809-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00299-g.torture.execute-950809-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..263465f4aab1de6d637ec51edd5b6ed60fd2a51d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00299-g.torture.execute-950809-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950809-1)
+run(950809-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00300-g.torture.execute-950906-1/950906-1.c b/testsuite/c_test/x64_be_enable_test/GCC00300-g.torture.execute-950906-1/950906-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..31997d5c25745d5a7b6a6925e29cb01107994cf0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00300-g.torture.execute-950906-1/950906-1.c
@@ -0,0 +1,16 @@
+g (int i)
+{
+}
+
+f (int i)
+{
+  g (0);
+  while ( ({ i--; }) )
+    g (0);
+}
+
+main ()
+{
+  f (10);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00300-g.torture.execute-950906-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00300-g.torture.execute-950906-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00300-g.torture.execute-950906-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00300-g.torture.execute-950906-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..88077b8323bd1de50b942b4928688939b7ded6b1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00300-g.torture.execute-950906-1/test.cfg
@@ -0,0 +1,2 @@
+compile(950906-1)
+run(950906-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00301-g.torture.execute-951115-1/951115-1.c b/testsuite/c_test/x64_be_enable_test/GCC00301-g.torture.execute-951115-1/951115-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..03520c99ca256339f592c84aa7908fbc9a3673d7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00301-g.torture.execute-951115-1/951115-1.c
@@ -0,0 +1,24 @@
+int var = 0;
+
+g ()
+{
+  var = 1;
+}
+
+f ()
+{
+  int f2 = 0;
+
+  if (f2 == 0)
+    ;
+
+  g ();
+}
+
+main ()
+{
+  f ();
+  if (var != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00301-g.torture.execute-951115-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00301-g.torture.execute-951115-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00301-g.torture.execute-951115-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00301-g.torture.execute-951115-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d0c09c7e92f7a9f029fcbff2d1b84c3c9693d521
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00301-g.torture.execute-951115-1/test.cfg
@@ -0,0 +1,2 @@
+compile(951115-1)
+run(951115-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00302-g.torture.execute-960116-1/960116-1.c b/testsuite/c_test/x64_be_enable_test/GCC00302-g.torture.execute-960116-1/960116-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6d7624ca1a19042bae3538a46a242768add3692d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00302-g.torture.execute-960116-1/960116-1.c
@@ -0,0 +1,20 @@
+static inline
+p (int *p)
+{
+  return !((long) p & 1);
+}
+
+int
+f (int *q)
+{
+  if (p (q) && *q)
+    return 1;
+  return 0;
+}
+
+main ()
+{
+  if (f ((int*) 0xffffffff) != 0)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00302-g.torture.execute-960116-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00302-g.torture.execute-960116-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00302-g.torture.execute-960116-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00302-g.torture.execute-960116-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7fcba3b24518c2f004de1dc6567429b9b05d9b29
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00302-g.torture.execute-960116-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960116-1)
+run(960116-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00303-g.torture.execute-960218-1/960218-1.c b/testsuite/c_test/x64_be_enable_test/GCC00303-g.torture.execute-960218-1/960218-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..dc94734a81f98749b5cd1e4d2006f88b6ea8d279
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00303-g.torture.execute-960218-1/960218-1.c
@@ -0,0 +1,22 @@
+int gl;
+
+g (x)
+{
+  gl = x;
+  return 0;
+}
+
+f (x)
+{
+  int a = ~x;
+  while (a)
+    a = g (a);
+}
+
+main ()
+{
+  f (3);
+  if (gl != -4)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00303-g.torture.execute-960218-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00303-g.torture.execute-960218-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00303-g.torture.execute-960218-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00303-g.torture.execute-960218-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b3691ec3515e951b5a34341fe52460ebbfefb46f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00303-g.torture.execute-960218-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960218-1)
+run(960218-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00304-g.torture.execute-960219-1/960219-1.c b/testsuite/c_test/x64_be_enable_test/GCC00304-g.torture.execute-960219-1/960219-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d21bcfcad243bea85419c576311f09ad43c96642
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00304-g.torture.execute-960219-1/960219-1.c
@@ -0,0 +1,11 @@
+f (int i)
+{
+  if (((1 << i) & 1) == 0)
+    abort ();
+}
+
+main ()
+{
+  f (0);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00304-g.torture.execute-960219-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00304-g.torture.execute-960219-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00304-g.torture.execute-960219-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00304-g.torture.execute-960219-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84dd4edffc2f764ae635b8156d3944697e7c1c8a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00304-g.torture.execute-960219-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960219-1)
+run(960219-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00305-g.torture.execute-960302-1/960302-1.c b/testsuite/c_test/x64_be_enable_test/GCC00305-g.torture.execute-960302-1/960302-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7a9426a4635a0ae8b532b63dc193962ffbacf550
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00305-g.torture.execute-960302-1/960302-1.c
@@ -0,0 +1,21 @@
+long a = 1;
+
+foo ()
+{
+  switch (a % 2 % 2 % 2 % 2 % 2 % 2 % 2 % 2)
+    {
+    case 0:
+      return 0;
+    case 1:
+      return 1;
+    default:
+      return -1;
+    }
+}
+
+main ()
+{
+  if (foo () != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00305-g.torture.execute-960302-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00305-g.torture.execute-960302-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00305-g.torture.execute-960302-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00305-g.torture.execute-960302-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e4513df06f4cdc50ec3e78ea21528e0364d22b72
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00305-g.torture.execute-960302-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960302-1)
+run(960302-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00306-g.torture.execute-960311-1/960311-1.c b/testsuite/c_test/x64_be_enable_test/GCC00306-g.torture.execute-960311-1/960311-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3029384c378919ca83c6c9ff2c9c27e4696b819d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00306-g.torture.execute-960311-1/960311-1.c
@@ -0,0 +1,71 @@
+#include <stdio.h>
+
+#ifdef DEBUG
+#define abort() printf("error, line %d\n", __LINE__)
+#endif
+
+int count;
+
+void a1() {
+  ++count;
+}
+
+void b(unsigned char data) {
+  if (data & 0x80)
+    a1();
+  data <<= 1;
+
+  if (data & 0x80)
+    a1();
+  data <<= 1;
+
+  if (data & 0x80)
+    a1();
+}
+
+main() {
+  count = 0;
+  b(0);
+  if (count != 0)
+    abort();
+
+  count = 0;
+  b(0x80);
+  if (count != 1)
+    abort();
+
+  count = 0;
+  b(0x40);
+  if (count != 1)
+    abort();
+
+  count = 0;
+  b(0x20);
+  if (count != 1)
+    abort();
+
+  count = 0;
+  b(0xc0);
+  if (count != 2)
+    abort();
+
+  count = 0;
+  b(0xa0);
+  if (count != 2)
+    abort();
+
+  count = 0;
+  b(0x60);
+  if (count != 2)
+    abort();
+
+  count = 0;
+  b(0xe0);
+  if (count != 3)
+    abort();
+
+#ifdef DEBUG
+  printf("Done.\n");
+#endif
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00306-g.torture.execute-960311-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00306-g.torture.execute-960311-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00306-g.torture.execute-960311-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00306-g.torture.execute-960311-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1aba9619069959c208d4b9965c5736275bd126c2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00306-g.torture.execute-960311-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960311-1)
+run(960311-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00307-g.torture.execute-960311-3/960311-3.c b/testsuite/c_test/x64_be_enable_test/GCC00307-g.torture.execute-960311-3/960311-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..755fc723f85a3b9eedc156838c327e0c6ee340a3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00307-g.torture.execute-960311-3/960311-3.c
@@ -0,0 +1,69 @@
+#include <stdio.h>
+
+#ifdef DEBUG
+#define abort() printf ("error, line %d\n", __LINE__)
+#endif
+
+int count;
+
+void a1() { ++count; }
+
+void
+b (unsigned long data)
+{
+  if (data & 0x80000000) a1();
+  data <<= 1;
+
+  if (data & 0x80000000) a1();
+  data <<= 1;
+
+  if (data & 0x80000000) a1();
+}
+
+main ()
+{
+  count = 0;
+  b (0);
+  if (count != 0)
+    abort ();
+
+  count = 0;
+  b (0x80000000);
+  if (count != 1)
+    abort ();
+
+  count = 0;
+  b (0x40000000);
+  if (count != 1)
+    abort ();
+
+  count = 0;
+  b (0x20000000);
+  if (count != 1)
+    abort ();
+
+  count = 0;
+  b (0xc0000000);
+  if (count != 2)
+    abort ();
+
+  count = 0;
+  b (0xa0000000);
+  if (count != 2)
+    abort ();
+
+  count = 0;
+  b (0x60000000);
+  if (count != 2)
+    abort ();
+
+  count = 0;
+  b (0xe0000000);
+  if (count != 3)
+    abort ();
+
+#ifdef DEBUG
+  printf ("Done.\n");
+#endif
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00307-g.torture.execute-960311-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00307-g.torture.execute-960311-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00307-g.torture.execute-960311-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00307-g.torture.execute-960311-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4568aeab516773b904f31117cb2e6aa552ff9aa5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00307-g.torture.execute-960311-3/test.cfg
@@ -0,0 +1,2 @@
+compile(960311-3)
+run(960311-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00308-g.torture.execute-960312-1/960312-1.c b/testsuite/c_test/x64_be_enable_test/GCC00308-g.torture.execute-960312-1/960312-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..94e67df23bd5cac1804fae2a42ce41c797f2a933
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00308-g.torture.execute-960312-1/960312-1.c
@@ -0,0 +1,34 @@
+struct S
+{
+  int *sp, fc, *sc, a[2];
+};
+
+f (struct S *x)
+{
+  int *t = x->sc;
+  int t1 = t[0];
+  int t2 = t[1];
+  int t3 = t[2];
+  int a0 = x->a[0];
+  int a1 = x->a[1];
+  asm("": :"r" (t2), "r" (t3));
+  t[2] = t1;
+  t[0] = a1;
+  x->a[1] = a0;
+  x->a[0] = t3;
+  x->fc = t2;
+  x->sp = t;
+}
+
+main ()
+{
+  struct S s;
+  static int sc[3] = {2, 3, 4};
+  s.sc = sc;
+  s.a[0] = 10;
+  s.a[1] = 11;
+  f (&s);
+  if (s.sp[2] != 2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00308-g.torture.execute-960312-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00308-g.torture.execute-960312-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00308-g.torture.execute-960312-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00308-g.torture.execute-960312-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..979c78808edd356419b1ea7b37c07a34b4682e7d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00308-g.torture.execute-960312-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960312-1)
+run(960312-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00309-g.torture.execute-960317-1/960317-1.c b/testsuite/c_test/x64_be_enable_test/GCC00309-g.torture.execute-960317-1/960317-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8d7907d751c34bfd1691e54d8aba35b8ac7b5b4b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00309-g.torture.execute-960317-1/960317-1.c
@@ -0,0 +1,22 @@
+int
+f (unsigned bitcount, int mant)
+{
+  int mask = -1 << bitcount;
+  {
+    if (! (mant & -mask))
+      goto ab;
+    if (mant & ~mask)
+      goto auf;
+  }
+ab:
+  return 0;
+auf:
+  return 1;
+}
+
+main ()
+{
+  if (f (0, -1))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00309-g.torture.execute-960317-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00309-g.torture.execute-960317-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00309-g.torture.execute-960317-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00309-g.torture.execute-960317-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c5c5426f8302c00eeb48551bae4fe01024462d97
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00309-g.torture.execute-960317-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960317-1)
+run(960317-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00310-g.torture.execute-960326-1/960326-1.c b/testsuite/c_test/x64_be_enable_test/GCC00310-g.torture.execute-960326-1/960326-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f201373702257e14bbc9a57af3e9e37ca341fef8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00310-g.torture.execute-960326-1/960326-1.c
@@ -0,0 +1,16 @@
+struct s
+{
+  int a;
+  int b;
+  short c;
+  int d[3];
+};
+
+struct s s = { .b = 3, .d = {2,0,0} };
+
+main ()
+{
+  if (s.b != 3)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00310-g.torture.execute-960326-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00310-g.torture.execute-960326-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00310-g.torture.execute-960326-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00310-g.torture.execute-960326-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d655e8d74613ff0182cd4f5da06ff0bbbd88f39d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00310-g.torture.execute-960326-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960326-1)
+run(960326-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00311-g.torture.execute-960402-1/960402-1.c b/testsuite/c_test/x64_be_enable_test/GCC00311-g.torture.execute-960402-1/960402-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..601a9a3b09135f474c1b50fee8c21079e4a7eeff
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00311-g.torture.execute-960402-1/960402-1.c
@@ -0,0 +1,11 @@
+f (signed long long int x)
+{
+  return x > 0xFFFFFFFFLL || x < -0x80000000LL;
+}
+
+main ()
+{
+  if (f (0) != 0)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00311-g.torture.execute-960402-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00311-g.torture.execute-960402-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00311-g.torture.execute-960402-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00311-g.torture.execute-960402-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4d2727d9d915aafa17f85e0ea4b50950d23b4895
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00311-g.torture.execute-960402-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960402-1)
+run(960402-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00312-g.torture.execute-960521-1/960521-1.c b/testsuite/c_test/x64_be_enable_test/GCC00312-g.torture.execute-960521-1/960521-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0174e7be552bf7f0a95ca65ad0e29b122b67b318
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00312-g.torture.execute-960521-1/960521-1.c
@@ -0,0 +1,32 @@
+/* { dg-add-options stack_size } */
+
+#include <stdlib.h>
+
+int *a, *b;
+int n;
+
+#ifdef STACK_SIZE
+#define BLOCK_SIZE (STACK_SIZE / (sizeof (*a) + sizeof (*b)))
+#else
+#define BLOCK_SIZE 32768
+#endif
+foo ()
+{
+  int i;
+  for (i = 0; i < n; i++)
+    a[i] = -1;
+  for (i = 0; i < BLOCK_SIZE - 1; i++)
+    b[i] = -1;
+}
+
+main ()
+{
+  n = BLOCK_SIZE;
+  a = malloc (n * sizeof(*a));
+  b = malloc (n * sizeof(*b));
+  *b++ = 0;
+  foo ();
+  if (b[-1])
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00312-g.torture.execute-960521-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00312-g.torture.execute-960521-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00312-g.torture.execute-960521-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00312-g.torture.execute-960521-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a53696b1ef033f5035b5258e26394003733bb5c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00312-g.torture.execute-960521-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960521-1)
+run(960521-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00313-g.torture.execute-960608-1/960608-1.c b/testsuite/c_test/x64_be_enable_test/GCC00313-g.torture.execute-960608-1/960608-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1f47d02d9d58dac8d3a2f4c094509023c12e8cc7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00313-g.torture.execute-960608-1/960608-1.c
@@ -0,0 +1,34 @@
+typedef struct
+{
+  unsigned char a  : 2;
+  unsigned char b  : 3;
+  unsigned char c  : 1;
+  unsigned char d  : 1;
+  unsigned char e  : 1;
+} a_struct;
+
+foo (flags)
+     a_struct *flags;
+{
+  return (flags->c != 0
+	  || flags->d != 1
+	  || flags->e != 1
+	  || flags->a != 2
+	  || flags->b != 3);
+}
+
+main ()
+{
+  a_struct flags;
+
+  flags.c  = 0;
+  flags.d  = 1;
+  flags.e  = 1;
+  flags.a  = 2;
+  flags.b  = 3;
+
+  if (foo (&flags) != 0)
+    abort ();
+  else
+    exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00313-g.torture.execute-960608-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00313-g.torture.execute-960608-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00313-g.torture.execute-960608-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00313-g.torture.execute-960608-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..181c312c18cd914cacc38edac7343aacfc6f801c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00313-g.torture.execute-960608-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960608-1)
+run(960608-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00314-g.torture.execute-960802-1/960802-1.c b/testsuite/c_test/x64_be_enable_test/GCC00314-g.torture.execute-960802-1/960802-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f9ee75260be377d95833795c4b34e853d0084ff7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00314-g.torture.execute-960802-1/960802-1.c
@@ -0,0 +1,36 @@
+long val = 0x5e000000;
+
+long
+f1 (void)
+{
+  return 0x132;
+}
+
+long
+f2 (void)
+{
+  return 0x5e000000;
+}
+
+void
+f3 (long b)
+{
+  val = b;
+}
+
+void
+f4 ()
+{
+  long v = f1 ();
+  long o = f2 ();
+  v = (v & 0x00ffffff) | (o & 0xff000000);
+  f3 (v);
+}
+
+main ()
+{
+  f4 ();
+  if (val != 0x5e000132)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00314-g.torture.execute-960802-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00314-g.torture.execute-960802-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00314-g.torture.execute-960802-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00314-g.torture.execute-960802-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a30231e6aec55fe59ec37991f5c9fa2efeeb436e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00314-g.torture.execute-960802-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960802-1)
+run(960802-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00315-g.torture.execute-960909-1/960909-1.c b/testsuite/c_test/x64_be_enable_test/GCC00315-g.torture.execute-960909-1/960909-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..de1ed9339781c21a26eefa1c70d6570bd59e36ac
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00315-g.torture.execute-960909-1/960909-1.c
@@ -0,0 +1,29 @@
+int
+ffs (x)
+     int x;
+{
+  int bit, mask;
+
+  if (x == 0)
+    return 0;
+
+  for (bit = 1, mask = 1; !(x & mask); bit++, mask <<= 1)
+    ;
+
+  return bit;
+}
+
+f (x)
+     int x;
+{
+  int y;
+  y = ffs (x) - 1;
+  if (y < 0) 
+    abort ();
+}
+
+main ()
+{
+  f (1);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00315-g.torture.execute-960909-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00315-g.torture.execute-960909-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00315-g.torture.execute-960909-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00315-g.torture.execute-960909-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..32b8db7f85811b2a29cf6a4ab4b822afc11f6070
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00315-g.torture.execute-960909-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960909-1)
+run(960909-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00316-g.torture.execute-961004-1/961004-1.c b/testsuite/c_test/x64_be_enable_test/GCC00316-g.torture.execute-961004-1/961004-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7ebba2d7b1ee04b81c47542986f80c669b7405d6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00316-g.torture.execute-961004-1/961004-1.c
@@ -0,0 +1,22 @@
+int k = 0;
+
+main()
+{
+  int i;
+  int j;
+
+  for (i = 0; i < 2; i++)
+    {
+      if (k)
+	{
+	  if (j != 2)
+	    abort ();
+	}
+      else
+	{
+	  j = 2;
+	  k++;
+	}
+    }
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00316-g.torture.execute-961004-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00316-g.torture.execute-961004-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00316-g.torture.execute-961004-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00316-g.torture.execute-961004-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..26d1fa0ef73bc195a13813fe8347cdcd09cef531
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00316-g.torture.execute-961004-1/test.cfg
@@ -0,0 +1,2 @@
+compile(961004-1)
+run(961004-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00317-g.torture.execute-961017-1/961017-1.c b/testsuite/c_test/x64_be_enable_test/GCC00317-g.torture.execute-961017-1/961017-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..88c9d9505a199ddecd596a36f79e6a93b17e5cb5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00317-g.torture.execute-961017-1/961017-1.c
@@ -0,0 +1,8 @@
+main ()
+{
+  unsigned char z = 0;
+
+  do ;
+  while (--z > 0);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00317-g.torture.execute-961017-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00317-g.torture.execute-961017-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00317-g.torture.execute-961017-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00317-g.torture.execute-961017-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8ddac4a228b4b48ba04781580d6a1f0824595a8e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00317-g.torture.execute-961017-1/test.cfg
@@ -0,0 +1,2 @@
+compile(961017-1)
+run(961017-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00318-g.torture.execute-961017-2/961017-2.c b/testsuite/c_test/x64_be_enable_test/GCC00318-g.torture.execute-961017-2/961017-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..768ddbc6e74b387df66a4d11556b600770fdec9c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00318-g.torture.execute-961017-2/961017-2.c
@@ -0,0 +1,32 @@
+main ()
+{
+  int i = 0;
+
+
+  if (sizeof (unsigned long int) == 4)
+    {
+      unsigned long int z = 0;
+
+      do {
+	z -= 0x00004000;
+	i++;
+	if (i > 0x00040000)
+	  abort ();
+      } while (z > 0);
+      exit (0);
+    }
+  else if (sizeof (unsigned int) == 4)
+    {
+      unsigned int z = 0;
+
+      do {
+	z -= 0x00004000;
+	i++;
+	if (i > 0x00040000)
+	  abort ();
+      } while (z > 0);
+      exit (0);
+    }
+  else
+    exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00318-g.torture.execute-961017-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00318-g.torture.execute-961017-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00318-g.torture.execute-961017-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00318-g.torture.execute-961017-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..87afbb2ef3306fd0028254e7f4da75c0ec4e089e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00318-g.torture.execute-961017-2/test.cfg
@@ -0,0 +1,2 @@
+compile(961017-2)
+run(961017-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00319-g.torture.execute-961026-1/961026-1.c b/testsuite/c_test/x64_be_enable_test/GCC00319-g.torture.execute-961026-1/961026-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..942a6eb131aa8ba53140fe1cf0532d8d4b0e0cb3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00319-g.torture.execute-961026-1/961026-1.c
@@ -0,0 +1,17 @@
+int
+test (arg)
+     int arg;
+{
+  if (arg > 0 || arg == 0)
+    return 0;
+  return -1;
+}
+
+main ()
+{
+  if (test (0) != 0)
+    abort ();
+  if (test (-1) != -1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00319-g.torture.execute-961026-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00319-g.torture.execute-961026-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00319-g.torture.execute-961026-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00319-g.torture.execute-961026-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..90f266f8adfbf9e8da87ac19ecd421f1c0bf8d74
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00319-g.torture.execute-961026-1/test.cfg
@@ -0,0 +1,2 @@
+compile(961026-1)
+run(961026-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00320-g.torture.execute-961112-1/961112-1.c b/testsuite/c_test/x64_be_enable_test/GCC00320-g.torture.execute-961112-1/961112-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4b1c31222caf1b8421edf1ab4690c0de67cd3153
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00320-g.torture.execute-961112-1/961112-1.c
@@ -0,0 +1,13 @@
+f (x)
+{
+  if (x != 0 || x == 0)
+    return 0;
+  return 1;
+}
+
+main ()
+{
+  if (f (3))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00320-g.torture.execute-961112-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00320-g.torture.execute-961112-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00320-g.torture.execute-961112-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00320-g.torture.execute-961112-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..55ab254eb8d523629f2d0f1f6a252ba31b622de6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00320-g.torture.execute-961112-1/test.cfg
@@ -0,0 +1,2 @@
+compile(961112-1)
+run(961112-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00321-g.torture.execute-961206-1/961206-1.c b/testsuite/c_test/x64_be_enable_test/GCC00321-g.torture.execute-961206-1/961206-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..943ac66804d6b815c6a73c0b40ad930dcbf193e4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00321-g.torture.execute-961206-1/961206-1.c
@@ -0,0 +1,52 @@
+int
+sub1 (unsigned long long i)
+{
+  if (i < 0x80000000)
+    return 1;
+  else
+    return 0;
+}
+
+int
+sub2 (unsigned long long i)
+{
+  if (i <= 0x7FFFFFFF)
+    return 1;
+  else
+    return 0;
+}
+
+int
+sub3 (unsigned long long i)
+{
+  if (i >= 0x80000000)
+    return 0;
+  else
+    return 1;
+}
+
+int
+sub4 (unsigned long long i)
+{
+  if (i > 0x7FFFFFFF)
+    return 0;
+  else
+    return 1;
+}
+
+main()
+{
+  if (sub1 (0x80000000ULL))
+    abort ();
+
+  if (sub2 (0x80000000ULL))
+    abort ();
+
+  if (sub3 (0x80000000ULL))
+    abort ();
+
+  if (sub4 (0x80000000ULL))
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00321-g.torture.execute-961206-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00321-g.torture.execute-961206-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00321-g.torture.execute-961206-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00321-g.torture.execute-961206-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..24db3b2b9ef40ba72b2116e223cb50f22ba89e68
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00321-g.torture.execute-961206-1/test.cfg
@@ -0,0 +1,2 @@
+compile(961206-1)
+run(961206-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00322-g.torture.execute-970217-1/970217-1.c b/testsuite/c_test/x64_be_enable_test/GCC00322-g.torture.execute-970217-1/970217-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..09e716a330bca5f1b07ac48075ac172d000069d7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00322-g.torture.execute-970217-1/970217-1.c
@@ -0,0 +1,10 @@
+sub (int i, int array[i++])
+{
+  return i;
+}
+
+main()
+{
+  int array[10];
+  exit (sub (10, array) != 11);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00322-g.torture.execute-970217-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00322-g.torture.execute-970217-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00322-g.torture.execute-970217-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00322-g.torture.execute-970217-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..967fcc2df9f8293f9cbdfee0fbfd293062848086
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00322-g.torture.execute-970217-1/test.cfg
@@ -0,0 +1,2 @@
+compile(970217-1)
+run(970217-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00323-g.torture.execute-970923-1/970923-1.c b/testsuite/c_test/x64_be_enable_test/GCC00323-g.torture.execute-970923-1/970923-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1d78b47c724b8d5e30645369939614fdbd30fb98
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00323-g.torture.execute-970923-1/970923-1.c
@@ -0,0 +1,27 @@
+int
+ts(a)
+     int a;
+{
+  if (a < 1000 && a > 2000)
+    return 1;
+  else
+    return 0;
+}
+
+int
+tu(a)
+     unsigned int a;
+{
+  if (a < 1000 && a > 2000)
+    return 1;
+  else
+    return 0;
+}
+
+
+main()
+{
+  if (ts (0) || tu (0))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00323-g.torture.execute-970923-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00323-g.torture.execute-970923-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00323-g.torture.execute-970923-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00323-g.torture.execute-970923-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3c7856ac4933aad9f9472ebc979074ebf68cbfd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00323-g.torture.execute-970923-1/test.cfg
@@ -0,0 +1,2 @@
+compile(970923-1)
+run(970923-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00324-g.torture.execute-980424-1/980424-1.c b/testsuite/c_test/x64_be_enable_test/GCC00324-g.torture.execute-980424-1/980424-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..514e91773a5d2fd9af8198cbf2c6690d12186567
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00324-g.torture.execute-980424-1/980424-1.c
@@ -0,0 +1,22 @@
+int i, a[99];
+
+void f (int one)
+{
+  if (one != 1)
+    abort ();
+}
+
+void
+g ()
+{
+  f (a[i & 0x3f]);
+}
+
+int
+main ()
+{
+  a[0] = 1;
+  i = 0x40;
+  g ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00324-g.torture.execute-980424-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00324-g.torture.execute-980424-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00324-g.torture.execute-980424-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00324-g.torture.execute-980424-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7d0814925aedd92186760807570812d41325eedd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00324-g.torture.execute-980424-1/test.cfg
@@ -0,0 +1,2 @@
+compile(980424-1)
+run(980424-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00325-g.torture.execute-980506-1/980506-1.c b/testsuite/c_test/x64_be_enable_test/GCC00325-g.torture.execute-980506-1/980506-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a48b3ad4cd7f1d994899a08de2f6b2f24ba8c744
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00325-g.torture.execute-980506-1/980506-1.c
@@ -0,0 +1,26 @@
+struct decision
+{
+  char enforce_mode;             
+  struct decision *next;         
+};
+
+
+static void
+clear_modes (p)
+     register struct decision *p;
+{
+  goto blah;
+
+foo:
+  p->enforce_mode = 0;
+blah:
+  if (p)
+    goto foo;
+}
+
+main()
+{
+  struct decision *p = 0;
+  clear_modes (p);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00325-g.torture.execute-980506-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00325-g.torture.execute-980506-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00325-g.torture.execute-980506-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00325-g.torture.execute-980506-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d97434757d33b0fb3e0ea7f2215f1db805eb1af
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00325-g.torture.execute-980506-1/test.cfg
@@ -0,0 +1,2 @@
+compile(980506-1)
+run(980506-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00326-g.torture.execute-980506-3/980506-3.c b/testsuite/c_test/x64_be_enable_test/GCC00326-g.torture.execute-980506-3/980506-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..a943e9ad62c2a35f0d475e34254821644d37b68b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00326-g.torture.execute-980506-3/980506-3.c
@@ -0,0 +1,24 @@
+unsigned char lookup_table [257];
+
+static int 
+build_lookup (pattern)
+     unsigned char *pattern;
+{
+  int m;
+
+  m = strlen (pattern) - 1;
+  
+  memset (lookup_table, ++m, 257);
+  return m;
+}
+
+int main(argc, argv)
+     int argc;
+     char **argv;
+{
+  if (build_lookup ("bind") != 4)
+    abort ();
+  else
+    exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00326-g.torture.execute-980506-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00326-g.torture.execute-980506-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00326-g.torture.execute-980506-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00326-g.torture.execute-980506-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..38c89f5ebf6f0d8fe7453b4d01fc764daef798f7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00326-g.torture.execute-980506-3/test.cfg
@@ -0,0 +1,2 @@
+compile(980506-3)
+run(980506-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00327-g.torture.execute-980526-1/980526-1.c b/testsuite/c_test/x64_be_enable_test/GCC00327-g.torture.execute-980526-1/980526-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..15c580791aba64427dc4bf294708b961724f69f7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00327-g.torture.execute-980526-1/980526-1.c
@@ -0,0 +1,35 @@
+/* { dg-require-effective-target label_values } */
+
+int expect_do1 = 1, expect_do2 = 2;
+ 
+static int doit(int x){
+  __label__ lbl1;
+  __label__ lbl2;
+  static int jtab_init = 0;
+  static void *jtab[2];
+ 
+  if(!jtab_init) {
+    jtab[0] = &&lbl1;
+    jtab[1] = &&lbl2;
+    jtab_init = 1;
+  }
+  goto *jtab[x];
+lbl1:
+  return 1;
+lbl2:
+  return 2;
+}
+ 
+static void do1(void) {
+  if (doit(0) != expect_do1)
+    abort ();
+}
+ 
+static void do2(void){
+  if (doit(1) != expect_do2)
+    abort ();
+}
+ 
+int main(void){
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00327-g.torture.execute-980526-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00327-g.torture.execute-980526-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00327-g.torture.execute-980526-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00327-g.torture.execute-980526-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..99812d21972355128de98ae4b72b0428a572db50
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00327-g.torture.execute-980526-1/test.cfg
@@ -0,0 +1,2 @@
+compile(980526-1)
+run(980526-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00328-g.torture.execute-980602-2/980602-2.c b/testsuite/c_test/x64_be_enable_test/GCC00328-g.torture.execute-980602-2/980602-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..972553ed584c7659a382bd44b27ea38ee8fa6e6c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00328-g.torture.execute-980602-2/980602-2.c
@@ -0,0 +1,21 @@
+/* The bit-field below would have a problem if __INT_MAX__ is too
+   small.  */
+#if __INT_MAX__ < 2147483647
+int
+main (void)
+{
+  exit (0);
+}
+#else
+struct {
+    unsigned bit : 30;
+} t;
+
+int main()
+{
+    if (!(t.bit++))
+	exit (0);
+    else
+	abort ();
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00328-g.torture.execute-980602-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00328-g.torture.execute-980602-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00328-g.torture.execute-980602-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00328-g.torture.execute-980602-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8414ea39bafcac9f10a7540ff5381f917c70db1c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00328-g.torture.execute-980602-2/test.cfg
@@ -0,0 +1,2 @@
+compile(980602-2)
+run(980602-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00329-g.torture.execute-980612-1/980612-1.c b/testsuite/c_test/x64_be_enable_test/GCC00329-g.torture.execute-980612-1/980612-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..db2438731a12c428a3c3df8ef87979868ee64916
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00329-g.torture.execute-980612-1/980612-1.c
@@ -0,0 +1,17 @@
+struct fd
+{
+	unsigned char a;
+	unsigned char b;
+} f = { 5 };
+
+struct fd *g() { return &f; }
+int h() { return -1; }
+
+int main()
+{
+	struct fd *f = g();
+	f->b = h();
+	if (((f->a & 0x7f) & ~0x10) <= 2)
+		abort ();
+	exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00329-g.torture.execute-980612-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00329-g.torture.execute-980612-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00329-g.torture.execute-980612-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00329-g.torture.execute-980612-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..139d381f030e9b22485de084a8d29d28b75638b1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00329-g.torture.execute-980612-1/test.cfg
@@ -0,0 +1,2 @@
+compile(980612-1)
+run(980612-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00330-g.torture.execute-980701-1/980701-1.c b/testsuite/c_test/x64_be_enable_test/GCC00330-g.torture.execute-980701-1/980701-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..391cc0ee1c2aa70a663de982a3f3078e4fcce764
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00330-g.torture.execute-980701-1/980701-1.c
@@ -0,0 +1,22 @@
+ns_name_skip (unsigned char **x, unsigned char *y)
+{
+  *x = 0;
+  return 0;
+}
+
+unsigned char a[2];
+
+int dn_skipname(unsigned char *ptr, unsigned char *eom) {
+    unsigned char *saveptr = ptr;
+
+    if (ns_name_skip(&ptr, eom) == -1)
+	        return (-1);
+    return (ptr - saveptr);
+}
+
+main()
+{
+  if (dn_skipname (&a[0], &a[1]) == 0)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00330-g.torture.execute-980701-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00330-g.torture.execute-980701-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00330-g.torture.execute-980701-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00330-g.torture.execute-980701-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..12f4f2f48ae7f91a418214a6a9dd49d6be8a7989
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00330-g.torture.execute-980701-1/test.cfg
@@ -0,0 +1,2 @@
+compile(980701-1)
+run(980701-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00331-g.torture.execute-981019-1/981019-1.c b/testsuite/c_test/x64_be_enable_test/GCC00331-g.torture.execute-981019-1/981019-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d1f009009bfd16cce34ce076f23159ffe63933d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00331-g.torture.execute-981019-1/981019-1.c
@@ -0,0 +1,44 @@
+extern int f2(void);
+extern int f3(void);
+extern void f1(void);
+
+void
+ff(int fname, int part, int nparts)
+{
+  if (fname)  /* bb 0 */
+    {
+      if (nparts)  /* bb 1 */
+	f1();  /* bb 2 */
+    }
+  else
+    fname = 2; /* bb 3  */
+
+  /* bb 4 is the branch to bb 10
+     (bb 10 is physically at the end of the loop) */
+  while (f3() /* bb 10 */)
+    {
+      if (nparts /* bb 5 */ && f2() /* bb 6 */)
+	{
+	  f1();  /* bb 7 ... */
+	  nparts = part;
+	  if (f3())  /* ... bb 7 */
+	    f1();  /* bb 8 */
+	  f1(); /* bb 9 */
+	  break;
+	}
+    }
+
+  if (nparts)  /* bb 11 */
+    f1(); /* bb 12 */
+  return; /* bb 13 */
+}
+
+int main(void)
+{
+  ff(0, 1, 0);
+  return 0;
+}
+
+int f3(void) { static int x = 0; x = !x; return x; }
+void f1(void) { abort(); }
+int f2(void) { abort(); }
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00331-g.torture.execute-981019-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00331-g.torture.execute-981019-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00331-g.torture.execute-981019-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00331-g.torture.execute-981019-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1afcc2ec50f23f65fe0b6e83d0d7f7c72f378cc5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00331-g.torture.execute-981019-1/test.cfg
@@ -0,0 +1,2 @@
+compile(981019-1)
+run(981019-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00332-g.torture.execute-981130-1/981130-1.c b/testsuite/c_test/x64_be_enable_test/GCC00332-g.torture.execute-981130-1/981130-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c4ca227d1e857ef1745cf92d7ca96c0b8d4e3266
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00332-g.torture.execute-981130-1/981130-1.c
@@ -0,0 +1,31 @@
+/* { dg-xfail-if "alias analysis conflicts with instruction scheduling" { m32r-*-* } { "-O2" "-O1" "-O0" "-Os"} { "" } } */
+struct s { int a; int b;};
+struct s s1;
+struct s s2 = { 1, 2, };
+
+void
+check (a, b)
+     int a;
+     int b;
+{
+  if (a == b)
+    exit (0);
+  else
+    abort ();
+}
+
+int
+main ()
+{
+  int * p;
+  int x;
+  
+  s1.a = 9;
+  p    = & s1.a;
+  s1   = s2;
+  x    = * p;
+  
+  check (x, 1);
+}
+
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00332-g.torture.execute-981130-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00332-g.torture.execute-981130-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00332-g.torture.execute-981130-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00332-g.torture.execute-981130-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f0bf2406dc6deda8006636aa040a1f8a6940fe0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00332-g.torture.execute-981130-1/test.cfg
@@ -0,0 +1,2 @@
+compile(981130-1)
+run(981130-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00333-g.torture.execute-990128-1/990128-1.c b/testsuite/c_test/x64_be_enable_test/GCC00333-g.torture.execute-990128-1/990128-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..cfdab3e87e5eb11a49950fe05c30b2115cf6b3f9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00333-g.torture.execute-990128-1/990128-1.c
@@ -0,0 +1,50 @@
+extern int printf (const char *,...);
+
+struct s { struct s *n; } *p;
+struct s ss;
+#define MAX     10
+struct s sss[MAX];
+int count = 0;
+
+void sub( struct s *p, struct s **pp );
+int look( struct s *p, struct s **pp );
+
+main()
+{
+    struct s *pp;
+    struct s *next;
+    int i;
+
+    p = &ss;
+    next = p;
+    for ( i = 0; i < MAX; i++ ) {
+        next->n = &sss[i];
+        next = next->n;
+    }
+    next->n = 0;
+
+    sub( p, &pp );
+    if (count != MAX+2)
+      abort ();
+
+    exit( 0 );
+}
+
+void sub( struct s *p, struct s **pp )
+{
+   for ( ; look( p, pp ); ) {
+        if ( p )
+            p = p->n;
+        else
+            break;
+   }
+}
+
+int look( struct s *p, struct s **pp )
+{
+    for ( ; p; p = p->n )
+        ;
+    *pp = p;
+    count++;
+    return( 1 );
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00333-g.torture.execute-990128-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00333-g.torture.execute-990128-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00333-g.torture.execute-990128-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00333-g.torture.execute-990128-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f4707c27b992892c9ba6a25d41fe45269da809b1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00333-g.torture.execute-990128-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990128-1)
+run(990128-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00334-g.torture.execute-990130-1/990130-1.c b/testsuite/c_test/x64_be_enable_test/GCC00334-g.torture.execute-990130-1/990130-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c38ecddbe596bae136d54f9b70d8d26ecdd0ab48
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00334-g.torture.execute-990130-1/990130-1.c
@@ -0,0 +1,23 @@
+int count = 0;
+int dummy;
+
+static int *
+bar(void)
+{
+  ++count;
+  return &dummy;
+}
+
+static void
+foo(void)
+{
+  asm("" : "+r"(*bar()));
+}
+
+main()
+{
+  foo();
+  if (count != 1)
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00334-g.torture.execute-990130-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00334-g.torture.execute-990130-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00334-g.torture.execute-990130-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00334-g.torture.execute-990130-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1f12a7cdea305a6fbe39c330a6615f528ee58202
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00334-g.torture.execute-990130-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990130-1)
+run(990130-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00335-g.torture.execute-990208-1/990208-1.c b/testsuite/c_test/x64_be_enable_test/GCC00335-g.torture.execute-990208-1/990208-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..15dcdfbdf7acbe7c83a2c8c441a73dd9c1555373
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00335-g.torture.execute-990208-1/990208-1.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target label_values } */
+
+/* As a quality of implementation issue, we should not prevent inlining
+   of function explicitly marked inline just because a label therein had
+   its address taken.  */
+
+static void *ptr1, *ptr2;
+static int i = 1;
+
+static __inline__ void doit(void **pptr, int cond)
+{
+  if (cond) {
+  here:
+    *pptr = &&here;
+  }
+}
+
+__attribute__ ((noinline))
+static void f(int cond)
+{
+  doit (&ptr1, cond);
+}
+
+__attribute__ ((noinline))
+static void g(int cond)
+{
+  doit (&ptr2, cond);
+}
+
+__attribute__ ((noinline))
+static void bar(void);
+
+int main()
+{
+  f (i);
+  bar();
+  g (i);
+
+#ifdef  __OPTIMIZE__
+  if (ptr1 == ptr2)
+    abort ();
+#endif
+
+  exit (0);
+}
+
+void bar(void) { }
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00335-g.torture.execute-990208-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00335-g.torture.execute-990208-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00335-g.torture.execute-990208-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00335-g.torture.execute-990208-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f35253d699b7b7b552d60cc0c6224fc30b08d402
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00335-g.torture.execute-990208-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990208-1)
+run(990208-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00336-g.torture.execute-990326-1/990326-1.c b/testsuite/c_test/x64_be_enable_test/GCC00336-g.torture.execute-990326-1/990326-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d7427cf85122b1172e29cc9f39bae54fd9a7d300
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00336-g.torture.execute-990326-1/990326-1.c
@@ -0,0 +1,407 @@
+struct a {
+	char a, b;
+	short c;
+};
+
+int
+a1()
+{
+	static struct a x = { 1, 2, ~1 }, y = { 65, 2, ~2 };
+
+	return (x.a == (y.a & ~64) && x.b == y.b);
+}
+
+int
+a2()
+{
+	static struct a x = { 1, 66, ~1 }, y = { 1, 2, ~2 };
+
+	return (x.a == y.a && (x.b & ~64) == y.b);
+}
+
+int
+a3()
+{
+	static struct a x = { 9, 66, ~1 }, y = { 33, 18, ~2 };
+
+	return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
+}
+
+struct b {
+	int c;
+	short b, a;
+};
+
+int
+b1()
+{
+	static struct b x = { ~1, 2, 1 }, y = { ~2, 2, 65 };
+
+	return (x.a == (y.a & ~64) && x.b == y.b);
+}
+
+int
+b2()
+{
+	static struct b x = { ~1, 66, 1 }, y = { ~2, 2, 1 };
+
+	return (x.a == y.a && (x.b & ~64) == y.b);
+}
+
+int
+b3()
+{
+	static struct b x = { ~1, 66, 9 }, y = { ~2, 18, 33 };
+
+	return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
+}
+
+struct c {
+	unsigned int c:4, b:14, a:14;
+} __attribute__ ((aligned));
+
+int
+c1()
+{
+	static struct c x = { ~1, 2, 1 }, y = { ~2, 2, 65 };
+
+	return (x.a == (y.a & ~64) && x.b == y.b);
+}
+
+int
+c2()
+{
+	static struct c x = { ~1, 66, 1 }, y = { ~2, 2, 1 };
+
+	return (x.a == y.a && (x.b & ~64) == y.b);
+}
+
+int
+c3()
+{
+	static struct c x = { ~1, 66, 9 }, y = { ~2, 18, 33 };
+
+	return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
+}
+
+struct d {
+	unsigned int a:14, b:14, c:4;
+} __attribute__ ((aligned));
+
+int
+d1()
+{
+	static struct d x = { 1, 2, ~1 }, y = { 65, 2, ~2 };
+
+	return (x.a == (y.a & ~64) && x.b == y.b);
+}
+
+int
+d2()
+{
+	static struct d x = { 1, 66, ~1 }, y = { 1, 2, ~2 };
+
+	return (x.a == y.a && (x.b & ~64) == y.b);
+}
+
+int
+d3()
+{
+	static struct d x = { 9, 66, ~1 }, y = { 33, 18, ~2 };
+
+	return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
+}
+
+struct e {
+	int c:4, b:14, a:14;
+} __attribute__ ((aligned));
+
+int
+e1()
+{
+	static struct e x = { ~1, -2, -65 }, y = { ~2, -2, -1 };
+
+	return (x.a == (y.a & ~64) && x.b == y.b);
+}
+
+int
+e2()
+{
+	static struct e x = { ~1, -2, -1 }, y = { ~2, -66, -1 };
+
+	return (x.a == y.a && (x.b & ~64) == y.b);
+}
+
+int
+e3()
+{
+	static struct e x = { ~1, -18, -33 }, y = { ~2, -66, -9 };
+
+	return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
+}
+
+int
+e4()
+{
+	static struct e x = { -1, -1, 0 };
+
+	return x.a == 0 && x.b & 0x2000;
+}
+
+struct f {
+	int a:14, b:14, c:4;
+} __attribute__ ((aligned));
+
+int
+f1()
+{
+	static struct f x = { -65, -2, ~1 }, y = { -1, -2, ~2 };
+
+	return (x.a == (y.a & ~64) && x.b == y.b);
+}
+
+int
+f2()
+{
+	static struct f x = { -1, -2, ~1 }, y = { -1, -66, ~2 };
+
+	return (x.a == y.a && (x.b & ~64) == y.b);
+}
+
+int
+f3()
+{
+	static struct f x = { -33, -18, ~1 }, y = { -9, -66, ~2 };
+
+	return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
+}
+
+int
+f4()
+{
+	static struct f x = { 0, -1, -1 };
+
+	return x.a == 0 && x.b & 0x2000;
+}
+
+struct gx {
+	int c:4, b:14, a:14;
+} __attribute__ ((aligned));
+struct gy {
+	int b:14, a:14, c:4;
+} __attribute__ ((aligned));
+
+int
+g1()
+{
+	static struct gx x = { ~1, -2, -65 };
+	static struct gy y = { -2, -1, ~2 };
+
+	return (x.a == (y.a & ~64) && x.b == y.b);
+}
+
+int
+g2()
+{
+	static struct gx x = { ~1, -2, -1 };
+	static struct gy y = { -66, -1, ~2 };
+
+	return (x.a == y.a && (x.b & ~64) == y.b);
+}
+
+int
+g3()
+{
+	static struct gx x = { ~1, -18, -33 };
+	static struct gy y = { -66, -9, ~2 };
+
+	return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
+}
+
+int
+g4()
+{
+	static struct gx x = { ~1, 0x0020, 0x0010 };
+	static struct gy y = { 0x0200, 0x0100, ~2 };
+
+	return ((x.a & 0x00f0) == (y.a & 0x0f00) &&
+		(x.b & 0x00f0) == (y.b & 0x0f00));
+}
+
+int
+g5()
+{
+	static struct gx x = { ~1, 0x0200, 0x0100 };
+	static struct gy y = { 0x0020, 0x0010, ~2 };
+
+	return ((x.a & 0x0f00) == (y.a & 0x00f0) &&
+		(x.b & 0x0f00) == (y.b & 0x00f0));
+}
+
+int
+g6()
+{
+	static struct gx x = { ~1, 0xfe20, 0xfd10 };
+	static struct gy y = { 0xc22f, 0xc11f, ~2 };
+
+	return ((x.a & 0x03ff) == (y.a & 0x3ff0) &&
+		(x.b & 0x03ff) == (y.b & 0x3ff0));
+}
+
+int
+g7()
+{
+	static struct gx x = { ~1, 0xc22f, 0xc11f };
+	static struct gy y = { 0xfe20, 0xfd10, ~2 };
+
+	return ((x.a & 0x3ff0) == (y.a & 0x03ff) &&
+		(x.b & 0x3ff0) == (y.b & 0x03ff));
+}
+
+struct hx {
+	int a:14, b:14, c:4;
+} __attribute__ ((aligned));
+struct hy {
+	int c:4, a:14, b:14;
+} __attribute__ ((aligned));
+
+int
+h1()
+{
+	static struct hx x = { -65, -2, ~1 };
+	static struct hy y = { ~2, -1, -2 };
+
+	return (x.a == (y.a & ~64) && x.b == y.b);
+}
+
+int
+h2()
+{
+	static struct hx x = { -1, -2, ~1 };
+	static struct hy y = { ~2, -1, -66 };
+
+	return (x.a == y.a && (x.b & ~64) == y.b);
+}
+
+int
+h3()
+{
+	static struct hx x = { -33, -18, ~1 };
+	static struct hy y = { ~2, -9, -66 };
+
+	return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
+}
+
+int
+h4()
+{
+	static struct hx x = { 0x0010, 0x0020, ~1 };
+	static struct hy y = { ~2, 0x0100, 0x0200 };
+
+	return ((x.a & 0x00f0) == (y.a & 0x0f00) &&
+		(x.b & 0x00f0) == (y.b & 0x0f00));
+}
+
+int
+h5()
+{
+	static struct hx x = { 0x0100, 0x0200, ~1 };
+	static struct hy y = { ~2, 0x0010, 0x0020 };
+
+	return ((x.a & 0x0f00) == (y.a & 0x00f0) &&
+		(x.b & 0x0f00) == (y.b & 0x00f0));
+}
+
+int
+h6()
+{
+	static struct hx x = { 0xfd10, 0xfe20, ~1 };
+	static struct hy y = { ~2, 0xc11f, 0xc22f };
+
+	return ((x.a & 0x03ff) == (y.a & 0x3ff0) &&
+		(x.b & 0x03ff) == (y.b & 0x3ff0));
+}
+
+int
+h7()
+{
+	static struct hx x = { 0xc11f, 0xc22f, ~1 };
+	static struct hy y = { ~2, 0xfd10, 0xfe20 };
+
+	return ((x.a & 0x3ff0) == (y.a & 0x03ff) &&
+		(x.b & 0x3ff0) == (y.b & 0x03ff));
+}
+
+int
+main()
+{
+  if (!a1 ())
+    abort ();
+  if (!a2 ())
+    abort ();
+  if (!a3 ())
+    abort ();
+  if (!b1 ())
+    abort ();
+  if (!b2 ())
+    abort ();
+  if (!b3 ())
+    abort ();
+  if (!c1 ())
+    abort ();
+  if (!c2 ())
+    abort ();
+  if (!c3 ())
+    abort ();
+  if (!d1 ())
+    abort ();
+  if (!d2 ())
+    abort ();
+  if (!d3 ())
+    abort ();
+  if (!e1 ())
+    abort ();
+  if (!e2 ())
+    abort ();
+  if (!e3 ())
+    abort ();
+  if (!e4 ())
+    abort ();
+  if (!f1 ())
+    abort ();
+  if (!f2 ())
+    abort ();
+  if (!f3 ())
+    abort ();
+  if (!f4 ())
+    abort ();
+  if (!g1 ())
+    abort ();
+  if (!g2 ())
+    abort ();
+  if (!g3 ())
+    abort ();
+  if (g4 ())
+    abort ();
+  if (g5 ())
+    abort ();
+  if (!g6 ())
+    abort ();
+  if (!g7 ())
+    abort ();
+  if (!h1 ())
+    abort ();
+  if (!h2 ())
+    abort ();
+  if (!h3 ())
+    abort ();
+  if (h4 ())
+    abort ();
+  if (h5 ())
+    abort ();
+  if (!h6 ())
+    abort ();
+  if (!h7 ())
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00336-g.torture.execute-990326-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00336-g.torture.execute-990326-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00336-g.torture.execute-990326-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00336-g.torture.execute-990326-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..34224b242f78b123be0669f48e4b546910b5b6e2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00336-g.torture.execute-990326-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990326-1)
+run(990326-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00337-g.torture.execute-990404-1/990404-1.c b/testsuite/c_test/x64_be_enable_test/GCC00337-g.torture.execute-990404-1/990404-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..be917d6d292591cb0ee7b0441244b333edd5f40a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00337-g.torture.execute-990404-1/990404-1.c
@@ -0,0 +1,27 @@
+
+int x[10] = { 0,1,2,3,4,5,6,7,8,9};
+
+int
+main()
+{
+  int niterations = 0, i;
+
+  for (;;) {
+    int i, mi, max;
+    max = 0;
+    for (i = 0; i < 10 ; i++) {
+      if (x[i] > max) {
+	max = x[i];
+	mi = i;
+      }
+    }
+    if (max == 0)
+      break;
+    x[mi] = 0;
+    niterations++;
+    if (niterations > 10)
+      abort ();
+  }
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00337-g.torture.execute-990404-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00337-g.torture.execute-990404-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00337-g.torture.execute-990404-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00337-g.torture.execute-990404-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b014862f0d10028c6f7c3785a8193ae0e66d683d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00337-g.torture.execute-990404-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990404-1)
+run(990404-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00338-g.torture.execute-990513-1/990513-1.c b/testsuite/c_test/x64_be_enable_test/GCC00338-g.torture.execute-990513-1/990513-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6ad228fb0062e3dee3e3ae79da0a8d5c29b99f83
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00338-g.torture.execute-990513-1/990513-1.c
@@ -0,0 +1,26 @@
+#include <string.h>
+
+void foo (int *BM_tab, int j)
+{
+  int *BM_tab_base;
+
+  BM_tab_base = BM_tab;
+  BM_tab += 0400;
+  while (BM_tab_base != BM_tab)
+    {
+      *--BM_tab = j;
+      *--BM_tab = j;
+      *--BM_tab = j;
+      *--BM_tab = j;
+    }
+}
+
+int main ()
+{
+  int BM_tab[0400];
+  memset (BM_tab, 0, sizeof (BM_tab));
+  foo (BM_tab, 6);
+  if (BM_tab[0] != 6)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00338-g.torture.execute-990513-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00338-g.torture.execute-990513-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00338-g.torture.execute-990513-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00338-g.torture.execute-990513-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..183f5358d16082b7bd29d5ad8a3d80c553163e3b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00338-g.torture.execute-990513-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990513-1)
+run(990513-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00339-g.torture.execute-990525-1/990525-1.c b/testsuite/c_test/x64_be_enable_test/GCC00339-g.torture.execute-990525-1/990525-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..39b65d101d66ede2228c7ee8c8fc3023b42cac72
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00339-g.torture.execute-990525-1/990525-1.c
@@ -0,0 +1,23 @@
+struct blah {
+    int m1, m2;
+};
+
+void die(struct blah arg)
+{
+    int i ;
+    struct blah buf[1];
+
+    for (i = 0; i < 1 ; buf[i++] = arg)
+        ;
+    if (buf[0].m1 != 1) {
+        abort ();
+    }
+}
+
+int main()
+{
+    struct blah s = { 1, 2 };
+
+    die(s);
+    exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00339-g.torture.execute-990525-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00339-g.torture.execute-990525-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00339-g.torture.execute-990525-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00339-g.torture.execute-990525-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc59e824052dd749a0608b3ecdb421e7c43d5a1f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00339-g.torture.execute-990525-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990525-1)
+run(990525-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00340-g.torture.execute-990525-2/990525-2.c b/testsuite/c_test/x64_be_enable_test/GCC00340-g.torture.execute-990525-2/990525-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..749785262efc534e7eb3669aa732ade90f5e1455
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00340-g.torture.execute-990525-2/990525-2.c
@@ -0,0 +1,39 @@
+typedef struct {
+    int v[4];
+} Test1;
+
+Test1 func2();
+
+int func1()
+{
+    Test1 test;
+    test = func2();
+
+    if (test.v[0] != 10)
+      abort ();
+    if (test.v[1] != 20)
+      abort ();
+    if (test.v[2] != 30)
+      abort ();
+    if (test.v[3] != 40)
+      abort ();
+}
+
+Test1 func2()
+{
+    Test1 tmp;
+    tmp.v[0] = 10;
+    tmp.v[1] = 20;
+    tmp.v[2] = 30;
+    tmp.v[3] = 40;
+    return tmp;
+}
+
+
+int main()
+{
+    func1();
+    exit (0);
+}
+
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00340-g.torture.execute-990525-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00340-g.torture.execute-990525-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00340-g.torture.execute-990525-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00340-g.torture.execute-990525-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..205ba04fd45b6dee8598994904a43aff27fdb377
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00340-g.torture.execute-990525-2/test.cfg
@@ -0,0 +1,2 @@
+compile(990525-2)
+run(990525-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00341-g.torture.execute-990527-1/990527-1.c b/testsuite/c_test/x64_be_enable_test/GCC00341-g.torture.execute-990527-1/990527-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a865cbbc69ab7f7a5dca2f93ef058cb16d5bd62f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00341-g.torture.execute-990527-1/990527-1.c
@@ -0,0 +1,30 @@
+int sum;
+
+void
+g (int i)
+{
+  sum += i;
+}
+
+void
+f(int j)
+{
+  int i;
+
+  for (i = 0; i < 9; i++)
+    {
+      j++;
+      g (j);
+      j = 9;
+    }
+}
+
+int
+main ()
+{
+  f (0);
+  if (sum != 81)
+    abort ();
+  exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00341-g.torture.execute-990527-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00341-g.torture.execute-990527-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00341-g.torture.execute-990527-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00341-g.torture.execute-990527-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f91460066acbd2ce72cdac0cf858c4c991d087fc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00341-g.torture.execute-990527-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990527-1)
+run(990527-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00342-g.torture.execute-990531-1/990531-1.c b/testsuite/c_test/x64_be_enable_test/GCC00342-g.torture.execute-990531-1/990531-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d5501d3a7d746d59e8e4d3940013e5443bc9313c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00342-g.torture.execute-990531-1/990531-1.c
@@ -0,0 +1,23 @@
+   unsigned long bad(int reg, unsigned long inWord)
+   {
+       union {
+           unsigned long word;
+           unsigned char byte[4];
+       } data;
+
+       data.word = inWord;
+       data.byte[reg] = 0;
+
+       return data.word;
+   }
+
+main()
+{
+  /* XXX This test could be generalized.  */
+  if (sizeof (long) != 4)
+    exit (0);
+
+  if (bad (0, 0xdeadbeef) == 0xdeadbeef)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00342-g.torture.execute-990531-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00342-g.torture.execute-990531-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00342-g.torture.execute-990531-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00342-g.torture.execute-990531-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eab2af3351a57f96d55b337739a6989cf7b24ca1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00342-g.torture.execute-990531-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990531-1)
+run(990531-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00343-g.torture.execute-990604-1/990604-1.c b/testsuite/c_test/x64_be_enable_test/GCC00343-g.torture.execute-990604-1/990604-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4e23a8ea880d9c37cce164c4067c14678ee791d6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00343-g.torture.execute-990604-1/990604-1.c
@@ -0,0 +1,19 @@
+int b;
+void f ()
+{
+  int i = 0;
+  if (b == 0)
+    do {
+      b = i;
+      i++;
+    } while (i < 10);
+}
+
+int main ()
+{
+  f ();
+  if (b != 9)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00343-g.torture.execute-990604-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00343-g.torture.execute-990604-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00343-g.torture.execute-990604-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00343-g.torture.execute-990604-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e883f9eb4ee6f1a27661ae1c7360d6bef48652d0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00343-g.torture.execute-990604-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990604-1)
+run(990604-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00344-g.torture.execute-990827-1/990827-1.c b/testsuite/c_test/x64_be_enable_test/GCC00344-g.torture.execute-990827-1/990827-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6116e788627dbbabdb207342f6963f9db1042619
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00344-g.torture.execute-990827-1/990827-1.c
@@ -0,0 +1,21 @@
+unsigned test(unsigned one , unsigned  bit)
+{
+    unsigned val=  bit & 1;
+    unsigned zero= one >> 1;
+
+    val++;
+    return zero + ( val>> 1 );
+}
+
+int main()
+{
+  if (test (1,0) != 0)
+    abort ();
+  if (test (1,1) != 1)
+    abort ();
+  if (test (1,65535) != 1)
+    abort ();
+  exit (0);
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00344-g.torture.execute-990827-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00344-g.torture.execute-990827-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00344-g.torture.execute-990827-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00344-g.torture.execute-990827-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c3c7fab3e1e45ac9b442ad52e5a0e05ebd7bb9b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00344-g.torture.execute-990827-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990827-1)
+run(990827-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00345-g.torture.execute-990923-1/990923-1.c b/testsuite/c_test/x64_be_enable_test/GCC00345-g.torture.execute-990923-1/990923-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4f4e87abcf443f53a6f02218d1806547b6d358c1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00345-g.torture.execute-990923-1/990923-1.c
@@ -0,0 +1,19 @@
+#define mask  0xffff0000L
+#define value 0xabcd0000L
+
+long
+foo (long x)
+{
+  if ((x & mask) == value)
+    return x & 0xffffL;
+  return 1;
+}
+
+int 
+main (void)
+{
+  if (foo (value) != 0 || foo (0) != 1)
+    abort ();
+  
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00345-g.torture.execute-990923-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00345-g.torture.execute-990923-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00345-g.torture.execute-990923-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00345-g.torture.execute-990923-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b97681444e76d82f023d5c220d837f0039b7956b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00345-g.torture.execute-990923-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990923-1)
+run(990923-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00346-g.torture.execute-991016-1/991016-1.c b/testsuite/c_test/x64_be_enable_test/GCC00346-g.torture.execute-991016-1/991016-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c3122342db774ed112584d417ee49082374ef3ab
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00346-g.torture.execute-991016-1/991016-1.c
@@ -0,0 +1,55 @@
+/* Two of these types will, on current gcc targets, have the same
+   mode but have different alias sets.  DOIT tries to get gcse to
+   invalidly hoist one of the values out of the loop.  */
+
+typedef int T0;
+typedef long T1;
+typedef long long T2;
+
+int
+doit(int sel, int n, void *p)
+{
+  T0 * const p0 = p;
+  T1 * const p1 = p;
+  T2 * const p2 = p;
+
+  switch (sel)
+    {
+    case 0:
+      do 
+	*p0 += *p0;
+      while (--n);
+      return *p0 == 0;
+
+    case 1:
+      do 
+	*p1 += *p1;
+      while (--n);
+      return *p1 == 0;
+
+    case 2:
+      do 
+	*p2 += *p2;
+      while (--n);
+      return *p2 == 0;
+
+    default:
+      abort ();
+    }
+}
+
+int
+main()
+{
+  T0 v0; T1 v1; T2 v2;
+
+  v0 = 1; doit(0, 5, &v0);
+  v1 = 1; doit(1, 5, &v1);
+  v2 = 1; doit(2, 5, &v2);
+
+  if (v0 != 32) abort ();
+  if (v1 != 32) abort ();
+  if (v2 != 32) abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00346-g.torture.execute-991016-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00346-g.torture.execute-991016-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00346-g.torture.execute-991016-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00346-g.torture.execute-991016-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d956be1868174774595d47fa7ee077fbb943493f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00346-g.torture.execute-991016-1/test.cfg
@@ -0,0 +1,2 @@
+compile(991016-1)
+run(991016-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00347-g.torture.execute-991023-1/991023-1.c b/testsuite/c_test/x64_be_enable_test/GCC00347-g.torture.execute-991023-1/991023-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..697eb931faec31328d8b52025014ef180e8ad2b2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00347-g.torture.execute-991023-1/991023-1.c
@@ -0,0 +1,24 @@
+
+
+int blah;
+foo()
+{
+  int i;
+
+  for (i=0 ; i< 7 ; i++)
+    {
+      if (i == 7 - 1)
+	blah = 0xfcc;
+      else
+	blah = 0xfee;
+    }
+  return blah;
+}
+
+
+main()
+{
+  if (foo () != 0xfcc)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00347-g.torture.execute-991023-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00347-g.torture.execute-991023-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00347-g.torture.execute-991023-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00347-g.torture.execute-991023-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b0ea46830390f97a08fec0c643246eb672be7a45
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00347-g.torture.execute-991023-1/test.cfg
@@ -0,0 +1,2 @@
+compile(991023-1)
+run(991023-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00348-g.torture.execute-991112-1/991112-1.c b/testsuite/c_test/x64_be_enable_test/GCC00348-g.torture.execute-991112-1/991112-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e43c7beeb87673a414913bcf58e189f5367c672b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00348-g.torture.execute-991112-1/991112-1.c
@@ -0,0 +1,19 @@
+/* This code was miscompiled at -O3 on x86.
+   Reported by Jim Meyering; distilled from bash.  */
+
+int rl_show_char (int c) { return 0; }
+
+int rl_character_len (int c, int pos)
+{
+  return isprint (c) ? 1 : 2;
+}
+
+int main(void)
+{
+  int (*x)(int, int) = rl_character_len;
+  if (x('a', 1) != 1)
+    abort();
+  if (x('\002', 1) != 2)
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00348-g.torture.execute-991112-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00348-g.torture.execute-991112-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00348-g.torture.execute-991112-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00348-g.torture.execute-991112-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d46f3f3c13357ec541270e5508ad9766339af6bf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00348-g.torture.execute-991112-1/test.cfg
@@ -0,0 +1,2 @@
+compile(991112-1)
+run(991112-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00349-g.torture.execute-991118-1/991118-1.c b/testsuite/c_test/x64_be_enable_test/GCC00349-g.torture.execute-991118-1/991118-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..77ba888a2a011030416b72237324dd5fbbf31279
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00349-g.torture.execute-991118-1/991118-1.c
@@ -0,0 +1,79 @@
+struct tmp
+{
+  long long int pad : 12;
+  long long int field : 52;
+};
+
+struct tmp2
+{
+  long long int field : 52;
+  long long int pad : 12;
+};
+
+struct tmp3
+{
+  long long int pad : 11;
+  long long int field : 53;
+};
+
+struct tmp4
+{
+  long long int field : 53;
+  long long int pad : 11;
+};
+
+struct tmp
+sub (struct tmp tmp)
+{
+  tmp.field ^= 0x0008765412345678LL;
+  return tmp;
+}
+
+struct tmp2
+sub2 (struct tmp2 tmp2)
+{
+  tmp2.field ^= 0x0008765412345678LL;
+  return tmp2;
+}
+
+struct tmp3
+sub3 (struct tmp3 tmp3)
+{
+  tmp3.field ^= 0x0018765412345678LL;
+  return tmp3;
+}
+
+struct tmp4
+sub4 (struct tmp4 tmp4)
+{
+  tmp4.field ^= 0x0018765412345678LL;
+  return tmp4;
+}
+
+struct tmp tmp = {0x123, 0x123456789ABCDLL};
+struct tmp2 tmp2 = {0x123456789ABCDLL, 0x123};
+struct tmp3 tmp3 = {0x123, 0x1FFFF00000000LL};
+struct tmp4 tmp4 = {0x1FFFF00000000LL, 0x123};
+
+main()
+{
+
+  if (sizeof (long long) != 8)
+    exit (0);
+
+  tmp = sub (tmp);
+  tmp2 = sub2 (tmp2);
+
+  if (tmp.pad != 0x123 || tmp.field != 0xFFF9551175BDFDB5LL)
+    abort ();
+  if (tmp2.pad != 0x123 || tmp2.field != 0xFFF9551175BDFDB5LL)
+    abort ();
+
+  tmp3 = sub3 (tmp3);
+  tmp4 = sub4 (tmp4);
+  if (tmp3.pad != 0x123 || tmp3.field != 0xFFF989AB12345678LL)
+    abort ();
+  if (tmp4.pad != 0x123 || tmp4.field != 0xFFF989AB12345678LL)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00349-g.torture.execute-991118-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00349-g.torture.execute-991118-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00349-g.torture.execute-991118-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00349-g.torture.execute-991118-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5f6957c317b8ccda36ae9c579a85450d6604827c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00349-g.torture.execute-991118-1/test.cfg
@@ -0,0 +1,2 @@
+compile(991118-1)
+run(991118-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00350-g.torture.execute-991201-1/991201-1.c b/testsuite/c_test/x64_be_enable_test/GCC00350-g.torture.execute-991201-1/991201-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..16595a45d14f827c5b00bd60b9acbec8d84b7c24
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00350-g.torture.execute-991201-1/991201-1.c
@@ -0,0 +1,39 @@
+struct vc_data {
+	unsigned long	space;
+	unsigned char   vc_palette[16*3];        
+};
+
+struct vc {
+	struct vc_data *d;
+};
+
+struct vc_data a_con;
+struct vc vc_cons[63] = { &a_con };
+int default_red[16];
+int default_grn[16];
+int default_blu[16];
+
+extern void bar(int);
+
+void reset_palette(int currcons)
+{
+	int j, k;
+	for (j=k=0; j<16; j++) {
+		(vc_cons[currcons].d->vc_palette) [k++] = default_red[j];
+		(vc_cons[currcons].d->vc_palette) [k++] = default_grn[j];
+		(vc_cons[currcons].d->vc_palette) [k++] = default_blu[j];
+	}
+	bar(k);
+}
+
+void bar(int k)
+{
+	if (k != 16*3)
+		abort();
+}
+
+int main()
+{
+	reset_palette(0);
+	exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00350-g.torture.execute-991201-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00350-g.torture.execute-991201-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00350-g.torture.execute-991201-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00350-g.torture.execute-991201-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e37d46933e4db0941b88639b6b985ae5b29477e3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00350-g.torture.execute-991201-1/test.cfg
@@ -0,0 +1,2 @@
+compile(991201-1)
+run(991201-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00351-g.torture.execute-991202-2/991202-2.c b/testsuite/c_test/x64_be_enable_test/GCC00351-g.torture.execute-991202-2/991202-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa97e2d431ef77ef0bd0df689ca627567e7f7abd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00351-g.torture.execute-991202-2/991202-2.c
@@ -0,0 +1,17 @@
+
+int
+f1 ()
+{
+  unsigned long x, y = 1;
+
+  x = ((y * 8192) - 216) % 16;
+  return x;
+}
+
+int
+main ()
+{
+  if (f1 () != 8)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00351-g.torture.execute-991202-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00351-g.torture.execute-991202-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00351-g.torture.execute-991202-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00351-g.torture.execute-991202-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..25c1f3b8937d01a5d68f29df5d4012eb5f10d4b8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00351-g.torture.execute-991202-2/test.cfg
@@ -0,0 +1,2 @@
+compile(991202-2)
+run(991202-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00352-g.torture.execute-991202-3/991202-3.c b/testsuite/c_test/x64_be_enable_test/GCC00352-g.torture.execute-991202-3/991202-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..f5718b22031ef5c64e79b5d51c68ec7f3b97285e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00352-g.torture.execute-991202-3/991202-3.c
@@ -0,0 +1,22 @@
+
+unsigned int f (unsigned int a)
+{
+  return a * 65536 / 8;
+}
+
+unsigned int g (unsigned int a)
+{
+  return a * 65536;
+}
+
+unsigned int h (unsigned int a)
+{
+  return a / 8;
+}
+
+int main ()
+{
+  if (f (65536) != h (g (65536)))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00352-g.torture.execute-991202-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00352-g.torture.execute-991202-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00352-g.torture.execute-991202-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00352-g.torture.execute-991202-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f362030094dc382b491ef0d51cc9c0d1cfd17704
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00352-g.torture.execute-991202-3/test.cfg
@@ -0,0 +1,2 @@
+compile(991202-3)
+run(991202-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00353-g.torture.execute-991221-1/991221-1.c b/testsuite/c_test/x64_be_enable_test/GCC00353-g.torture.execute-991221-1/991221-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7106fee606d8f954217ac69c957e653366dd72ba
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00353-g.torture.execute-991221-1/991221-1.c
@@ -0,0 +1,13 @@
+int main( void )
+{
+   unsigned long totalsize = 80;
+   unsigned long msize = 64;
+
+   if (sizeof(long) != 4)
+     exit(0);
+   
+   if ( totalsize > (2147483647L   * 2UL + 1)  
+        || (msize != 0 && ((msize - 1) > (2147483647L   * 2UL + 1) )))
+      abort();
+   exit( 0 );
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00353-g.torture.execute-991221-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00353-g.torture.execute-991221-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00353-g.torture.execute-991221-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00353-g.torture.execute-991221-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3f6d65d598c4c623b2f5368d0b434da4d843a092
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00353-g.torture.execute-991221-1/test.cfg
@@ -0,0 +1,2 @@
+compile(991221-1)
+run(991221-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00354-g.torture.execute-alias-access-path-1/alias-access-path-1.c b/testsuite/c_test/x64_be_enable_test/GCC00354-g.torture.execute-alias-access-path-1/alias-access-path-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6693a2b176d61b4f2c962ea729de8cfce2de8eee
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00354-g.torture.execute-alias-access-path-1/alias-access-path-1.c
@@ -0,0 +1,19 @@
+/* Test that variable
+     int val;
+   may hold value of tyope "struct c" which has same size.
+   This is valid in GIMPLE memory model.  */
+
+struct a {int val;} a={1},a2;
+struct b {struct a a;};
+int val;
+struct c {struct b b;} *cptr=(void *)&val;
+
+int
+main(void)
+{
+  cptr->b.a=a;
+  val = 2;
+  a2=cptr->b.a;
+  if (a2.val == a.val)
+    __builtin_abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00354-g.torture.execute-alias-access-path-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00354-g.torture.execute-alias-access-path-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00354-g.torture.execute-alias-access-path-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00354-g.torture.execute-alias-access-path-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..20ae1fce06f82dc65587319867941bd6eb460b55
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00354-g.torture.execute-alias-access-path-1/test.cfg
@@ -0,0 +1,2 @@
+compile(alias-access-path-1)
+run(alias-access-path-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00355-g.torture.execute-align-1/align-1.c b/testsuite/c_test/x64_be_enable_test/GCC00355-g.torture.execute-align-1/align-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..2dc1aad2abc0ee6ed814c703e973a5ba25205861
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00355-g.torture.execute-align-1/align-1.c
@@ -0,0 +1,9 @@
+typedef int new_int __attribute__ ((aligned(16)));
+struct S { int x; };
+ 
+int main()
+{
+  if (sizeof(struct S) != sizeof(int))
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00355-g.torture.execute-align-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00355-g.torture.execute-align-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00355-g.torture.execute-align-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00355-g.torture.execute-align-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..93061f34596d7f36b35712f64bb4bda259c5f53f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00355-g.torture.execute-align-1/test.cfg
@@ -0,0 +1,2 @@
+compile(align-1)
+run(align-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00356-g.torture.execute-align-3/align-3.c b/testsuite/c_test/x64_be_enable_test/GCC00356-g.torture.execute-align-3/align-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..7478c9e4a19ed75554eb07c7e53567d9f794d6d1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00356-g.torture.execute-align-3/align-3.c
@@ -0,0 +1,14 @@
+/* { dg-skip-if "small alignment" { pdp11-*-* } } */
+
+void func(void) __attribute__((aligned(256)));
+
+void func(void) 
+{
+}
+
+int main()
+{
+  if (__alignof__(func) != 256)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00356-g.torture.execute-align-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00356-g.torture.execute-align-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00356-g.torture.execute-align-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00356-g.torture.execute-align-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a892aa7f709f8ba8c5e4eaeffe987c92e6c46d12
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00356-g.torture.execute-align-3/test.cfg
@@ -0,0 +1,2 @@
+compile(align-3)
+run(align-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00357-g.torture.execute-anon-1/anon-1.c b/testsuite/c_test/x64_be_enable_test/GCC00357-g.torture.execute-anon-1/anon-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..98a9ed71d46ba6244d81cbc5f9bbc9fcd5bc5cf8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00357-g.torture.execute-anon-1/anon-1.c
@@ -0,0 +1,29 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* Source: Neil Booth, 4 Nov 2001, derived from PR 2820 - field lookup in
+   nested anonymous entities was broken.  */
+
+struct
+{
+  int x;
+  struct
+  {
+    int a;
+    union
+    {
+      int b;
+    };
+  };
+} foo;
+
+int
+main(int argc, char *argv[])
+{
+  foo.b = 6;
+  foo.a = 5;
+
+  if (foo.b != 6)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00357-g.torture.execute-anon-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00357-g.torture.execute-anon-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00357-g.torture.execute-anon-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00357-g.torture.execute-anon-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c06be63a29aae5d4bfef6b5ce313cba135989700
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00357-g.torture.execute-anon-1/test.cfg
@@ -0,0 +1,2 @@
+compile(anon-1)
+run(anon-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00358-g.torture.execute-arith-1/arith-1.c b/testsuite/c_test/x64_be_enable_test/GCC00358-g.torture.execute-arith-1/arith-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6168d77af670d113519f4a4fd7a1a35463aebf94
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00358-g.torture.execute-arith-1/arith-1.c
@@ -0,0 +1,47 @@
+unsigned
+sat_add (unsigned i)
+{
+  unsigned ret = i + 1;
+  if (ret < i)
+    ret = i;
+  return ret;
+}
+
+unsigned
+sat_add2 (unsigned i)
+{
+  unsigned ret = i + 1;
+  if (ret > i)
+    return ret;
+  return i;
+}
+
+unsigned
+sat_add3 (unsigned i)
+{
+  unsigned ret = i - 1;
+  if (ret > i)
+    ret = i;
+  return ret;
+}
+
+unsigned
+sat_add4 (unsigned i)
+{
+  unsigned ret = i - 1;
+  if (ret < i)
+    return ret;
+  return i;
+}
+main ()
+{
+  if (sat_add (~0U) != ~0U)
+    abort ();
+  if (sat_add2 (~0U) != ~0U)
+    abort ();
+  if (sat_add3 (0U) != 0U)
+    abort ();
+  if (sat_add4 (0U) != 0U)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00358-g.torture.execute-arith-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00358-g.torture.execute-arith-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00358-g.torture.execute-arith-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00358-g.torture.execute-arith-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..69f82c03d515bc9023475388b74db80fb971c3d4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00358-g.torture.execute-arith-1/test.cfg
@@ -0,0 +1,2 @@
+compile(arith-1)
+run(arith-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00359-g.torture.execute-ashldi-1/ashldi-1.c b/testsuite/c_test/x64_be_enable_test/GCC00359-g.torture.execute-ashldi-1/ashldi-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..66716972f48f782ebc62583040778f5bbe13980c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00359-g.torture.execute-ashldi-1/ashldi-1.c
@@ -0,0 +1,221 @@
+#include <limits.h>
+
+extern void abort(void);
+extern void exit(int);
+
+#if __LONG_LONG_MAX__ == 9223372036854775807LL
+#define BITS 64
+
+static unsigned long long const data[64] = {
+  0x123456789abcdefULL,
+  0x2468acf13579bdeULL,
+  0x48d159e26af37bcULL,
+  0x91a2b3c4d5e6f78ULL,
+  0x123456789abcdef0ULL,
+  0x2468acf13579bde0ULL,
+  0x48d159e26af37bc0ULL,
+  0x91a2b3c4d5e6f780ULL,
+  0x23456789abcdef00ULL,
+  0x468acf13579bde00ULL,
+  0x8d159e26af37bc00ULL,
+  0x1a2b3c4d5e6f7800ULL,
+  0x3456789abcdef000ULL,
+  0x68acf13579bde000ULL,
+  0xd159e26af37bc000ULL,
+  0xa2b3c4d5e6f78000ULL,
+  0x456789abcdef0000ULL,
+  0x8acf13579bde0000ULL,
+  0x159e26af37bc0000ULL,
+  0x2b3c4d5e6f780000ULL,
+  0x56789abcdef00000ULL,
+  0xacf13579bde00000ULL,
+  0x59e26af37bc00000ULL,
+  0xb3c4d5e6f7800000ULL,
+  0x6789abcdef000000ULL,
+  0xcf13579bde000000ULL,
+  0x9e26af37bc000000ULL,
+  0x3c4d5e6f78000000ULL,
+  0x789abcdef0000000ULL,
+  0xf13579bde0000000ULL,
+  0xe26af37bc0000000ULL,
+  0xc4d5e6f780000000ULL,
+  0x89abcdef00000000ULL,
+  0x13579bde00000000ULL,
+  0x26af37bc00000000ULL,
+  0x4d5e6f7800000000ULL,
+  0x9abcdef000000000ULL,
+  0x3579bde000000000ULL,
+  0x6af37bc000000000ULL,
+  0xd5e6f78000000000ULL,
+  0xabcdef0000000000ULL,
+  0x579bde0000000000ULL,
+  0xaf37bc0000000000ULL,
+  0x5e6f780000000000ULL,
+  0xbcdef00000000000ULL,
+  0x79bde00000000000ULL,
+  0xf37bc00000000000ULL,
+  0xe6f7800000000000ULL,
+  0xcdef000000000000ULL,
+  0x9bde000000000000ULL,
+  0x37bc000000000000ULL,
+  0x6f78000000000000ULL,
+  0xdef0000000000000ULL,
+  0xbde0000000000000ULL,
+  0x7bc0000000000000ULL,
+  0xf780000000000000ULL,
+  0xef00000000000000ULL,
+  0xde00000000000000ULL,
+  0xbc00000000000000ULL,
+  0x7800000000000000ULL,
+  0xf000000000000000ULL,
+  0xe000000000000000ULL,
+  0xc000000000000000ULL,
+  0x8000000000000000ULL
+};
+
+#elif __LONG_LONG_MAX__ == 2147483647LL
+#define BITS 32
+
+static unsigned long long const data[32] = {
+  0x1234567fULL,
+  0x2468acfeULL,
+  0x48d159fcULL,
+  0x91a2b3f8ULL,
+  0x234567f0ULL,
+  0x468acfe0ULL,
+  0x8d159fc0ULL,
+  0x1a2b3f80ULL,
+  0x34567f00ULL,
+  0x68acfe00ULL,
+  0xd159fc00ULL,
+  0xa2b3f800ULL,
+  0x4567f000ULL,
+  0x8acfe000ULL,
+  0x159fc000ULL,
+  0x2b3f8000ULL,
+  0x567f0000ULL,
+  0xacfe0000ULL,
+  0x59fc0000ULL,
+  0xb3f80000ULL,
+  0x67f00000ULL,
+  0xcfe00000ULL,
+  0x9fc00000ULL,
+  0x3f800000ULL,
+  0x7f000000ULL,
+  0xfe000000ULL,
+  0xfc000000ULL,
+  0xf8000000ULL,
+  0xf0000000ULL,
+  0xe0000000ULL,
+  0xc0000000ULL,
+  0x80000000ULL
+};
+
+#else
+#error "Update the test case."
+#endif
+
+static unsigned long long
+variable_shift(unsigned long long x, int i)
+{
+  return x << i;
+}
+
+static unsigned long long
+constant_shift(unsigned long long x, int i)
+{
+  switch (i)
+    {
+    case 0: x = x << 0; break;
+    case 1: x = x << 1; break;
+    case 2: x = x << 2; break;
+    case 3: x = x << 3; break;
+    case 4: x = x << 4; break;
+    case 5: x = x << 5; break;
+    case 6: x = x << 6; break;
+    case 7: x = x << 7; break;
+    case 8: x = x << 8; break;
+    case 9: x = x << 9; break;
+    case 10: x = x << 10; break;
+    case 11: x = x << 11; break;
+    case 12: x = x << 12; break;
+    case 13: x = x << 13; break;
+    case 14: x = x << 14; break;
+    case 15: x = x << 15; break;
+    case 16: x = x << 16; break;
+    case 17: x = x << 17; break;
+    case 18: x = x << 18; break;
+    case 19: x = x << 19; break;
+    case 20: x = x << 20; break;
+    case 21: x = x << 21; break;
+    case 22: x = x << 22; break;
+    case 23: x = x << 23; break;
+    case 24: x = x << 24; break;
+    case 25: x = x << 25; break;
+    case 26: x = x << 26; break;
+    case 27: x = x << 27; break;
+    case 28: x = x << 28; break;
+    case 29: x = x << 29; break;
+    case 30: x = x << 30; break;
+    case 31: x = x << 31; break;
+#if BITS > 32
+    case 32: x = x << 32; break;
+    case 33: x = x << 33; break;
+    case 34: x = x << 34; break;
+    case 35: x = x << 35; break;
+    case 36: x = x << 36; break;
+    case 37: x = x << 37; break;
+    case 38: x = x << 38; break;
+    case 39: x = x << 39; break;
+    case 40: x = x << 40; break;
+    case 41: x = x << 41; break;
+    case 42: x = x << 42; break;
+    case 43: x = x << 43; break;
+    case 44: x = x << 44; break;
+    case 45: x = x << 45; break;
+    case 46: x = x << 46; break;
+    case 47: x = x << 47; break;
+    case 48: x = x << 48; break;
+    case 49: x = x << 49; break;
+    case 50: x = x << 50; break;
+    case 51: x = x << 51; break;
+    case 52: x = x << 52; break;
+    case 53: x = x << 53; break;
+    case 54: x = x << 54; break;
+    case 55: x = x << 55; break;
+    case 56: x = x << 56; break;
+    case 57: x = x << 57; break;
+    case 58: x = x << 58; break;
+    case 59: x = x << 59; break;
+    case 60: x = x << 60; break;
+    case 61: x = x << 61; break;
+    case 62: x = x << 62; break;
+    case 63: x = x << 63; break;
+#endif
+
+    default:
+      abort ();
+    }
+  return x;
+}
+
+int
+main()
+{
+  int i;
+
+  for (i = 0; i < BITS; ++i)
+    {
+      unsigned long long y = variable_shift (data[0], i);
+      if (y != data[i])
+	abort ();
+    }
+  for (i = 0; i < BITS; ++i)
+    {
+      unsigned long long y = constant_shift (data[0], i);
+      if (y != data[i])
+	abort ();
+    }
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00359-g.torture.execute-ashldi-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00359-g.torture.execute-ashldi-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00359-g.torture.execute-ashldi-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00359-g.torture.execute-ashldi-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..762949fa46178f3de466fe596b3882b0221648dc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00359-g.torture.execute-ashldi-1/test.cfg
@@ -0,0 +1,2 @@
+compile(ashldi-1)
+run(ashldi-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00360-g.torture.execute-ashrdi-1/ashrdi-1.c b/testsuite/c_test/x64_be_enable_test/GCC00360-g.torture.execute-ashrdi-1/ashrdi-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c032b0c18be04da35c29192058d2c71d3e2aef27
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00360-g.torture.execute-ashrdi-1/ashrdi-1.c
@@ -0,0 +1,335 @@
+#include <limits.h>
+
+extern void abort(void);
+extern void exit(int);
+
+#if __LONG_LONG_MAX__ == 9223372036854775807LL
+#define BITS 64
+
+static long long const zext[64] = {
+  0x7654321fedcba980LL,
+  0x3b2a190ff6e5d4c0LL,
+  0x1d950c87fb72ea60LL,
+  0xeca8643fdb97530LL,
+  0x7654321fedcba98LL,
+  0x3b2a190ff6e5d4cLL,
+  0x1d950c87fb72ea6LL,
+  0xeca8643fdb9753LL,
+  0x7654321fedcba9LL,
+  0x3b2a190ff6e5d4LL,
+  0x1d950c87fb72eaLL,
+  0xeca8643fdb975LL,
+  0x7654321fedcbaLL,
+  0x3b2a190ff6e5dLL,
+  0x1d950c87fb72eLL,
+  0xeca8643fdb97LL,
+  0x7654321fedcbLL,
+  0x3b2a190ff6e5LL,
+  0x1d950c87fb72LL,
+  0xeca8643fdb9LL,
+  0x7654321fedcLL,
+  0x3b2a190ff6eLL,
+  0x1d950c87fb7LL,
+  0xeca8643fdbLL,
+  0x7654321fedLL,
+  0x3b2a190ff6LL,
+  0x1d950c87fbLL,
+  0xeca8643fdLL,
+  0x7654321feLL,
+  0x3b2a190ffLL,
+  0x1d950c87fLL,
+  0xeca8643fLL,
+  0x7654321fLL,
+  0x3b2a190fLL,
+  0x1d950c87LL,
+  0xeca8643LL,
+  0x7654321LL,
+  0x3b2a190LL,
+  0x1d950c8LL,
+  0xeca864LL,
+  0x765432LL,
+  0x3b2a19LL,
+  0x1d950cLL,
+  0xeca86LL,
+  0x76543LL,
+  0x3b2a1LL,
+  0x1d950LL,
+  0xeca8LL,
+  0x7654LL,
+  0x3b2aLL,
+  0x1d95LL,
+  0xecaLL,
+  0x765LL,
+  0x3b2LL,
+  0x1d9LL,
+  0xecLL,
+  0x76LL,
+  0x3bLL,
+  0x1dLL,
+  0xeLL,
+  0x7LL,
+  0x3LL,
+  0x1LL,
+  0LL
+};
+
+static long long const sext[64] = {
+  0x8edcba9f76543210LL,
+  0xc76e5d4fbb2a1908LL,
+  0xe3b72ea7dd950c84LL,
+  0xf1db9753eeca8642LL,
+  0xf8edcba9f7654321LL,
+  0xfc76e5d4fbb2a190LL,
+  0xfe3b72ea7dd950c8LL,
+  0xff1db9753eeca864LL,
+  0xff8edcba9f765432LL,
+  0xffc76e5d4fbb2a19LL,
+  0xffe3b72ea7dd950cLL,
+  0xfff1db9753eeca86LL,
+  0xfff8edcba9f76543LL,
+  0xfffc76e5d4fbb2a1LL,
+  0xfffe3b72ea7dd950LL,
+  0xffff1db9753eeca8LL,
+  0xffff8edcba9f7654LL,
+  0xffffc76e5d4fbb2aLL,
+  0xffffe3b72ea7dd95LL,
+  0xfffff1db9753eecaLL,
+  0xfffff8edcba9f765LL,
+  0xfffffc76e5d4fbb2LL,
+  0xfffffe3b72ea7dd9LL,
+  0xffffff1db9753eecLL,
+  0xffffff8edcba9f76LL,
+  0xffffffc76e5d4fbbLL,
+  0xffffffe3b72ea7ddLL,
+  0xfffffff1db9753eeLL,
+  0xfffffff8edcba9f7LL,
+  0xfffffffc76e5d4fbLL,
+  0xfffffffe3b72ea7dLL,
+  0xffffffff1db9753eLL,
+  0xffffffff8edcba9fLL,
+  0xffffffffc76e5d4fLL,
+  0xffffffffe3b72ea7LL,
+  0xfffffffff1db9753LL,
+  0xfffffffff8edcba9LL,
+  0xfffffffffc76e5d4LL,
+  0xfffffffffe3b72eaLL,
+  0xffffffffff1db975LL,
+  0xffffffffff8edcbaLL,
+  0xffffffffffc76e5dLL,
+  0xffffffffffe3b72eLL,
+  0xfffffffffff1db97LL,
+  0xfffffffffff8edcbLL,
+  0xfffffffffffc76e5LL,
+  0xfffffffffffe3b72LL,
+  0xffffffffffff1db9LL,
+  0xffffffffffff8edcLL,
+  0xffffffffffffc76eLL,
+  0xffffffffffffe3b7LL,
+  0xfffffffffffff1dbLL,
+  0xfffffffffffff8edLL,
+  0xfffffffffffffc76LL,
+  0xfffffffffffffe3bLL,
+  0xffffffffffffff1dLL,
+  0xffffffffffffff8eLL,
+  0xffffffffffffffc7LL,
+  0xffffffffffffffe3LL,
+  0xfffffffffffffff1LL,
+  0xfffffffffffffff8LL,
+  0xfffffffffffffffcLL,
+  0xfffffffffffffffeLL,
+  0xffffffffffffffffLL
+};
+
+#elif __LONG_LONG_MAX__ == 2147483647LL
+#define BITS 32
+
+static long long const zext[32] = {
+  0x76543218LL,
+  0x3b2a190cLL,
+  0x1d950c86LL,
+  0xeca8643LL,
+  0x7654321LL,
+  0x3b2a190LL,
+  0x1d950c8LL,
+  0xeca864LL,
+  0x765432LL,
+  0x3b2a19LL,
+  0x1d950cLL,
+  0xeca86LL,
+  0x76543LL,
+  0x3b2a1LL,
+  0x1d950LL,
+  0xeca8LL,
+  0x7654LL,
+  0x3b2aLL,
+  0x1d95LL,
+  0xecaLL,
+  0x765LL,
+  0x3b2LL,
+  0x1d9LL,
+  0xecLL,
+  0x76LL,
+  0x3bLL,
+  0x1dLL,
+  0xeLL,
+  0x7LL,
+  0x3LL,
+  0x1LL,
+  0LL
+};
+
+static long long const sext[64] = {
+  0x87654321LL,
+  0xc3b2a190LL,
+  0xe1d950c8LL,
+  0xf0eca864LL,
+  0xf8765432LL,
+  0xfc3b2a19LL,
+  0xfe1d950cLL,
+  0xff0eca86LL,
+  0xff876543LL,
+  0xffc3b2a1LL,
+  0xffe1d950LL,
+  0xfff0eca8LL,
+  0xfff87654LL,
+  0xfffc3b2aLL,
+  0xfffe1d95LL,
+  0xffff0ecaLL,
+  0xffff8765LL,
+  0xffffc3b2LL,
+  0xffffe1d9LL,
+  0xfffff0ecLL,
+  0xfffff876LL,
+  0xfffffc3bLL,
+  0xfffffe1dLL,
+  0xffffff0eLL,
+  0xffffff87LL,
+  0xffffffc3LL,
+  0xffffffe1LL,
+  0xfffffff0LL,
+  0xfffffff8LL,
+  0xfffffffcLL,
+  0xfffffffeLL,
+  0xffffffffLL
+};
+
+#else
+#error "Update the test case."
+#endif
+
+static long long
+variable_shift(long long x, int i)
+{
+  return x >> i;
+}
+
+static long long
+constant_shift(long long x, int i)
+{
+  switch (i)
+    {
+    case 0: x = x >> 0; break;
+    case 1: x = x >> 1; break;
+    case 2: x = x >> 2; break;
+    case 3: x = x >> 3; break;
+    case 4: x = x >> 4; break;
+    case 5: x = x >> 5; break;
+    case 6: x = x >> 6; break;
+    case 7: x = x >> 7; break;
+    case 8: x = x >> 8; break;
+    case 9: x = x >> 9; break;
+    case 10: x = x >> 10; break;
+    case 11: x = x >> 11; break;
+    case 12: x = x >> 12; break;
+    case 13: x = x >> 13; break;
+    case 14: x = x >> 14; break;
+    case 15: x = x >> 15; break;
+    case 16: x = x >> 16; break;
+    case 17: x = x >> 17; break;
+    case 18: x = x >> 18; break;
+    case 19: x = x >> 19; break;
+    case 20: x = x >> 20; break;
+    case 21: x = x >> 21; break;
+    case 22: x = x >> 22; break;
+    case 23: x = x >> 23; break;
+    case 24: x = x >> 24; break;
+    case 25: x = x >> 25; break;
+    case 26: x = x >> 26; break;
+    case 27: x = x >> 27; break;
+    case 28: x = x >> 28; break;
+    case 29: x = x >> 29; break;
+    case 30: x = x >> 30; break;
+    case 31: x = x >> 31; break;
+#if BITS > 32
+    case 32: x = x >> 32; break;
+    case 33: x = x >> 33; break;
+    case 34: x = x >> 34; break;
+    case 35: x = x >> 35; break;
+    case 36: x = x >> 36; break;
+    case 37: x = x >> 37; break;
+    case 38: x = x >> 38; break;
+    case 39: x = x >> 39; break;
+    case 40: x = x >> 40; break;
+    case 41: x = x >> 41; break;
+    case 42: x = x >> 42; break;
+    case 43: x = x >> 43; break;
+    case 44: x = x >> 44; break;
+    case 45: x = x >> 45; break;
+    case 46: x = x >> 46; break;
+    case 47: x = x >> 47; break;
+    case 48: x = x >> 48; break;
+    case 49: x = x >> 49; break;
+    case 50: x = x >> 50; break;
+    case 51: x = x >> 51; break;
+    case 52: x = x >> 52; break;
+    case 53: x = x >> 53; break;
+    case 54: x = x >> 54; break;
+    case 55: x = x >> 55; break;
+    case 56: x = x >> 56; break;
+    case 57: x = x >> 57; break;
+    case 58: x = x >> 58; break;
+    case 59: x = x >> 59; break;
+    case 60: x = x >> 60; break;
+    case 61: x = x >> 61; break;
+    case 62: x = x >> 62; break;
+    case 63: x = x >> 63; break;
+#endif
+
+    default:
+      abort ();
+    }
+  return x;
+}
+
+int
+main()
+{
+  int i;
+
+  for (i = 0; i < BITS; ++i)
+    {
+      long long y = variable_shift (zext[0], i);
+      if (y != zext[i])
+	abort ();
+    }
+  for (i = 0; i < BITS; ++i)
+    {
+      long long y = variable_shift (sext[0], i);
+      if (y != sext[i])
+	abort ();
+    }
+  for (i = 0; i < BITS; ++i)
+    {
+      long long y = constant_shift (zext[0], i);
+      if (y != zext[i])
+	abort ();
+    }
+  for (i = 0; i < BITS; ++i)
+    {
+      long long y = constant_shift (sext[0], i);
+      if (y != sext[i])
+	abort ();
+    }
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00360-g.torture.execute-ashrdi-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00360-g.torture.execute-ashrdi-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00360-g.torture.execute-ashrdi-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00360-g.torture.execute-ashrdi-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4c5cec3ee8471e0e24303c128215fcac2a9df0f7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00360-g.torture.execute-ashrdi-1/test.cfg
@@ -0,0 +1,2 @@
+compile(ashrdi-1)
+run(ashrdi-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00361-g.torture.execute-bcp-1/bcp-1.c b/testsuite/c_test/x64_be_enable_test/GCC00361-g.torture.execute-bcp-1/bcp-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..19c038bcc5ada8f1f04bd65969786cbde3d9d9a8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00361-g.torture.execute-bcp-1/bcp-1.c
@@ -0,0 +1,96 @@
+/* { dg-options "-fgnu89-inline" } */
+
+extern void abort (void);
+extern void exit (int);
+
+__attribute__ ((externally_visible)) int global;
+int func(void);
+
+/* These must fail.  */
+int bad0(void) { return __builtin_constant_p(global); }
+int bad1(void) { return __builtin_constant_p(global++); }
+inline int bad2(int x) { return __builtin_constant_p(x++); }
+inline int bad3(int x) { return __builtin_constant_p(x); }
+inline int bad4(const char *x) { return __builtin_constant_p(x); }
+int bad5(void) { return bad2(1); }
+inline int bad6(int x) { return __builtin_constant_p(x+1); }
+int bad7(void) { return __builtin_constant_p(func()); }
+int bad8(void) { char buf[10]; return __builtin_constant_p(buf); }
+int bad9(const char *x) { return __builtin_constant_p(x[123456]); }
+int bad10(void) { return __builtin_constant_p(&global); }
+
+/* These must pass, or we've broken gcc2 functionality.  */
+int good0(void) { return __builtin_constant_p(1); }
+int good1(void) { return __builtin_constant_p("hi"); }
+int good2(void) { return __builtin_constant_p((1234 + 45) & ~7); }
+
+/* These are extensions to gcc2.  Failure indicates an optimization
+   regression.  */
+int opt0(void) { return bad3(1); }
+int opt1(void) { return bad6(1); }
+int opt2(void) { return __builtin_constant_p("hi"[0]); }
+
+/* 
+ * Opt3 is known to fail.  It is one of the important cases that glibc
+ * was interested in though, so keep this around as a reminder.
+ *
+ * The solution is to add bits to recover bytes from constant pool
+ * elements given nothing but a constant pool label and an offset.
+ * When we can do that, and we can simplify strlen after the fact,
+ * then we can enable recognition of constant pool labels as constants.
+ */
+
+/* int opt3(void) { return bad4("hi"); } */
+
+
+/* Call through tables so -finline-functions can't screw with us.  */
+int (* volatile bad_t0[])(void) = {
+	bad0, bad1, bad5, bad7, bad8, bad10
+};
+
+int (* volatile bad_t1[])(int x) = {
+	bad2, bad3, bad6
+};
+
+int (* volatile bad_t2[])(const char *x) = {
+	bad4, bad9
+};
+
+int (* volatile good_t0[])(void) = {
+	good0, good1, good2
+};
+
+int (* volatile opt_t0[])(void) = {
+	opt0, opt1, opt2 /* , opt3 */
+};
+
+#define N(arr) (sizeof(arr)/sizeof(*arr))
+
+int main()
+{
+  int i;
+
+  for (i = 0; i < N(bad_t0); ++i)
+    if ((*bad_t0[i])())
+      abort();
+
+  for (i = 0; i < N(bad_t1); ++i)
+    if ((*bad_t1[i])(1))
+      abort();
+
+  for (i = 0; i < N(bad_t2); ++i)
+    if ((*bad_t2[i])("hi"))
+      abort();
+
+  for (i = 0; i < N(good_t0); ++i)
+    if (! (*good_t0[i])())
+      abort();
+
+#ifdef __OPTIMIZE__
+  for (i = 0; i < N(opt_t0); ++i)
+    if (! (*opt_t0[i])())
+      abort();
+#endif
+
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00361-g.torture.execute-bcp-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00361-g.torture.execute-bcp-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00361-g.torture.execute-bcp-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00361-g.torture.execute-bcp-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..882999cb3ab7850f170ae8c3569dd0468eaaebef
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00361-g.torture.execute-bcp-1/test.cfg
@@ -0,0 +1,2 @@
+compile(bcp-1)
+run(bcp-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00362-g.torture.execute-bf64-1/bf64-1.c b/testsuite/c_test/x64_be_enable_test/GCC00362-g.torture.execute-bf64-1/bf64-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c9241e281c59ef399974aa4a657f59714d338d4e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00362-g.torture.execute-bf64-1/bf64-1.c
@@ -0,0 +1,41 @@
+/* { dg-xfail-if "ABI specifies bitfields cannot exceed 32 bits" { mcore-*-* } } */
+struct tmp
+{
+  long long int pad : 12;
+  long long int field : 52;
+};
+
+struct tmp2
+{
+  long long int field : 52;
+  long long int pad : 12;
+};
+
+struct tmp
+sub (struct tmp tmp)
+{
+  tmp.field |= 0x0008765412345678LL;
+  return tmp;
+}
+
+struct tmp2
+sub2 (struct tmp2 tmp2)
+{
+  tmp2.field |= 0x0008765412345678LL;
+  return tmp2;
+}
+
+main()
+{
+  struct tmp tmp = {0x123, 0xFFF000FFF000FLL};
+  struct tmp2 tmp2 = {0xFFF000FFF000FLL, 0x123};
+
+  tmp = sub (tmp);
+  tmp2 = sub2 (tmp2);
+
+  if (tmp.pad != 0x123 || tmp.field != 0xFFFFFF541FFF567FLL)
+    abort ();
+  if (tmp2.pad != 0x123 || tmp2.field != 0xFFFFFF541FFF567FLL)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00362-g.torture.execute-bf64-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00362-g.torture.execute-bf64-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00362-g.torture.execute-bf64-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00362-g.torture.execute-bf64-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e4a514932af10059be585877e4f2167cefe6d007
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00362-g.torture.execute-bf64-1/test.cfg
@@ -0,0 +1,2 @@
+compile(bf64-1)
+run(bf64-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00363-g.torture.execute-bf-layout-1/bf-layout-1.c b/testsuite/c_test/x64_be_enable_test/GCC00363-g.torture.execute-bf-layout-1/bf-layout-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a82429ba2088f52eeee412097c7d4731fd50b270
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00363-g.torture.execute-bf-layout-1/bf-layout-1.c
@@ -0,0 +1,9 @@
+struct { long f8:8; long f24:24; } a;
+struct { long f32:32; } b;
+
+main ()
+{
+  if (sizeof (a) != sizeof (b))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00363-g.torture.execute-bf-layout-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00363-g.torture.execute-bf-layout-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00363-g.torture.execute-bf-layout-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00363-g.torture.execute-bf-layout-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..392acf5685f4797ef90fb4700ef9ea412e94630a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00363-g.torture.execute-bf-layout-1/test.cfg
@@ -0,0 +1,2 @@
+compile(bf-layout-1)
+run(bf-layout-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00364-g.torture.execute-bf-pack-1/bf-pack-1.c b/testsuite/c_test/x64_be_enable_test/GCC00364-g.torture.execute-bf-pack-1/bf-pack-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ca3b1db763b50604774d5a8176362d9968e0ea4a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00364-g.torture.execute-bf-pack-1/bf-pack-1.c
@@ -0,0 +1,23 @@
+struct foo
+{
+  unsigned half:16;
+  unsigned long whole:32 __attribute__ ((packed));
+};
+
+f (struct foo *q)
+{
+  if (q->half != 0x1234)
+    abort ();
+  if (q->whole != 0x56789abcL)
+    abort ();
+}
+
+main ()
+{
+  struct foo bar;
+
+  bar.half = 0x1234;
+  bar.whole = 0x56789abcL;
+  f (&bar);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00364-g.torture.execute-bf-pack-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00364-g.torture.execute-bf-pack-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00364-g.torture.execute-bf-pack-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00364-g.torture.execute-bf-pack-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cf4364b936c9945b94196b0cd01a06ba1bd47856
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00364-g.torture.execute-bf-pack-1/test.cfg
@@ -0,0 +1,2 @@
+compile(bf-pack-1)
+run(bf-pack-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00365-g.torture.execute-bf-sign-2/bf-sign-2.c b/testsuite/c_test/x64_be_enable_test/GCC00365-g.torture.execute-bf-sign-2/bf-sign-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..e8e17176ac07e1787a50101759f22c424fb7eb4d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00365-g.torture.execute-bf-sign-2/bf-sign-2.c
@@ -0,0 +1,66 @@
+/* 
+ This test checks promotion of bitfields.  Bitfields should be promoted
+ very much like chars and shorts: 
+
+ Bitfields (signed or unsigned) should be promoted to signed int if their
+ value will fit in a signed int, otherwise to an unsigned int if their 
+ value will fit in an unsigned int, otherwise we don't promote them (ANSI/ISO
+ does not specify the behavior of bitfields larger than an unsigned int).
+
+ We test the behavior by subtracting two from the promoted value: this will
+ result in a negitive value for signed types, a positive value for unsigned
+ types.  This test (of course) assumes that the compiler is correctly 
+ implementing signed and unsigned arithmetic.
+ */
+
+struct X {
+  unsigned int	     u3:3;
+    signed long int  s31:31;
+    signed long int  s32:32;
+  unsigned long int  u31:31;
+  unsigned long int  u32:32;
+  unsigned long long ull3 :3;
+  unsigned long long ull35:35;
+  unsigned u15:15;
+};
+
+struct X x;
+
+main ()
+{
+  if ((x.u3 - 2) >= 0)		/* promoted value should be signed */
+    abort ();
+
+  if ((x.s31 - 2) >= 0)		/* promoted value should be signed */
+    abort ();
+
+  if ((x.s32 - 2) >= 0)		/* promoted value should be signed */
+    abort ();
+
+  if ((x.u15 - 2) >= 0)		/* promoted value should be signed */
+    abort ();
+
+  /* Conditionalize check on whether integers are 4 bytes or larger, i.e.
+     larger than a 31 bit bitfield.  */
+  if (sizeof (int) >= 4)
+    {
+      if ((x.u31 - 2) >= 0)	/* promoted value should be signed */
+	abort ();
+    }
+  else
+    {
+      if ((x.u31 - 2) < 0)	/* promoted value should be UNsigned */
+	abort ();
+    }
+
+  if ((x.u32 - 2) < 0)		/* promoted value should be UNsigned */
+    abort ();
+
+  if ((x.ull3 - 2) >= 0)	/* promoted value should be signed */
+    abort ();
+
+  if ((x.ull35 - 2) < 0)	/* promoted value should be UNsigned */
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00365-g.torture.execute-bf-sign-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00365-g.torture.execute-bf-sign-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00365-g.torture.execute-bf-sign-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00365-g.torture.execute-bf-sign-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0106501a4870cd6fc3b734de6a9b383b24b70b70
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00365-g.torture.execute-bf-sign-2/test.cfg
@@ -0,0 +1,2 @@
+compile(bf-sign-2)
+run(bf-sign-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00366-g.torture.execute-bitfld-2/bitfld-2.c b/testsuite/c_test/x64_be_enable_test/GCC00366-g.torture.execute-bitfld-2/bitfld-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..445879b14cc9948ad90aaf816fd832567b141871
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00366-g.torture.execute-bitfld-2/bitfld-2.c
@@ -0,0 +1,28 @@
+/* Test whether bit field boundaries aren't advanced if bit field type
+   has alignment large enough.  */
+extern void abort (void);
+extern void exit (int);
+
+struct A {
+  unsigned short a : 5;
+  unsigned short b : 5;
+  unsigned short c : 6;
+};
+
+struct B {
+  unsigned short a : 5;
+  unsigned short b : 3;
+  unsigned short c : 8;
+};
+
+int main ()
+{
+  /* If short is not at least 16 bits wide, don't test anything.  */
+  if ((unsigned short) 65521 != 65521)
+    exit (0);
+
+  if (sizeof (struct A) != sizeof (struct B))
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00366-g.torture.execute-bitfld-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00366-g.torture.execute-bitfld-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00366-g.torture.execute-bitfld-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00366-g.torture.execute-bitfld-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ce4f540a0e35848f9b4d09f46346207e7509f75a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00366-g.torture.execute-bitfld-2/test.cfg
@@ -0,0 +1,2 @@
+compile(bitfld-2)
+run(bitfld-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00367-g.torture.execute-bitfld-4/bitfld-4.c b/testsuite/c_test/x64_be_enable_test/GCC00367-g.torture.execute-bitfld-4/bitfld-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..13a5c691dd2185edcda2573bf3191da2cae4c871
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00367-g.torture.execute-bitfld-4/bitfld-4.c
@@ -0,0 +1,23 @@
+/* When comparisons of bit-fields to unsigned constants got shortened,
+   the shortened signed constant was wrongly marked as overflowing,
+   leading to a later integer_zerop failure and misoptimization.
+
+   Related to bug tree-optimization/16437 but shows the problem on
+   32-bit systems.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-require-effective-target int32plus } */
+
+extern void abort (void);
+
+struct s { int a:12, b:20; };
+
+struct s x = { -123, -456 };
+
+int
+main (void)
+{
+  if (x.a != -123U || x.b != -456U)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00367-g.torture.execute-bitfld-4/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00367-g.torture.execute-bitfld-4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00367-g.torture.execute-bitfld-4/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00367-g.torture.execute-bitfld-4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..992d264374a853b78d95c160dbf472f24bf01071
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00367-g.torture.execute-bitfld-4/test.cfg
@@ -0,0 +1,2 @@
+compile(bitfld-4)
+run(bitfld-4)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00368-g.torture.execute-bitfld-6/bitfld-6.c b/testsuite/c_test/x64_be_enable_test/GCC00368-g.torture.execute-bitfld-6/bitfld-6.c
new file mode 100644
index 0000000000000000000000000000000000000000..b8c5cbd285859cd1bf556b79b31009c00fbe6ca0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00368-g.torture.execute-bitfld-6/bitfld-6.c
@@ -0,0 +1,24 @@
+/* { dg-require-effective-target int32plus } */
+union U
+{
+  const int a;
+  unsigned b : 20;
+};
+
+static union U u = { 0x12345678 };
+
+/* Constant folding used to fail to account for endianness when folding a
+   union.  */
+
+int
+main (void)
+{
+#ifdef __BYTE_ORDER__
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+  return u.b - 0x45678;
+#else
+  return u.b - 0x12345;
+#endif
+#endif
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00368-g.torture.execute-bitfld-6/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00368-g.torture.execute-bitfld-6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00368-g.torture.execute-bitfld-6/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00368-g.torture.execute-bitfld-6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8ceb3d4c626bfd09241aa6854bdb62271b3dc08d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00368-g.torture.execute-bitfld-6/test.cfg
@@ -0,0 +1,2 @@
+compile(bitfld-6)
+run(bitfld-6)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00369-g.torture.execute-bitfld-7/bitfld-7.c b/testsuite/c_test/x64_be_enable_test/GCC00369-g.torture.execute-bitfld-7/bitfld-7.c
new file mode 100644
index 0000000000000000000000000000000000000000..350e7a3672b4db8e6269445890948ae872a70736
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00369-g.torture.execute-bitfld-7/bitfld-7.c
@@ -0,0 +1,24 @@
+/* { dg-require-effective-target int32plus } */
+union U
+{
+  const int a;
+  unsigned b : 24;
+};
+
+static union U u = { 0x12345678 };
+
+/* Constant folding used to fail to account for endianness when folding a
+   union.  */
+
+int
+main (void)
+{
+#ifdef __BYTE_ORDER__
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+  return u.b - 0x345678;
+#else
+  return u.b - 0x123456;
+#endif
+#endif
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00369-g.torture.execute-bitfld-7/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00369-g.torture.execute-bitfld-7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00369-g.torture.execute-bitfld-7/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00369-g.torture.execute-bitfld-7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ed6efc792d398331016cbfab93e9411a3b3dea7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00369-g.torture.execute-bitfld-7/test.cfg
@@ -0,0 +1,2 @@
+compile(bitfld-7)
+run(bitfld-7)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00370-g.torture.execute-bswap-2/bswap-2.c b/testsuite/c_test/x64_be_enable_test/GCC00370-g.torture.execute-bswap-2/bswap-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..63e7807d3d92f317942da9b5b9eb516c4bdbac5d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00370-g.torture.execute-bswap-2/bswap-2.c
@@ -0,0 +1,136 @@
+/* { dg-require-effective-target int32plus } */
+
+#ifdef __UINT32_TYPE__
+typedef __UINT32_TYPE__ uint32_t;
+#else
+typedef __UINT32_TYPE__ unsigned;
+#endif
+
+struct bitfield {
+  unsigned char f0:7;
+  unsigned char   :1;
+  unsigned char f1:7;
+  unsigned char   :1;
+  unsigned char f2:7;
+  unsigned char   :1;
+  unsigned char f3:7;
+};
+
+struct ok {
+  unsigned char f0;
+  unsigned char f1;
+  unsigned char f2;
+  unsigned char f3;
+};
+
+union bf_or_uint32 {
+  struct ok inval;
+  struct bitfield bfval;
+};
+
+__attribute__ ((noinline, noclone)) uint32_t
+partial_read_le32 (union bf_or_uint32 in)
+{
+  return in.bfval.f0 | (in.bfval.f1 << 8)
+	 | (in.bfval.f2 << 16) | (in.bfval.f3 << 24);
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+partial_read_be32 (union bf_or_uint32 in)
+{
+  return in.bfval.f3 | (in.bfval.f2 << 8)
+	 | (in.bfval.f1 << 16) | (in.bfval.f0 << 24);
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+fake_read_le32 (char *x, char *y)
+{
+  unsigned char c0, c1, c2, c3;
+
+  c0 = x[0];
+  c1 = x[1];
+  *y = 1;
+  c2 = x[2];
+  c3 = x[3];
+  return c0 | c1 << 8 | c2 << 16 | c3 << 24;
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+fake_read_be32 (char *x, char *y)
+{
+  unsigned char c0, c1, c2, c3;
+
+  c0 = x[0];
+  c1 = x[1];
+  *y = 1;
+  c2 = x[2];
+  c3 = x[3];
+  return c3 | c2 << 8 | c1 << 16 | c0 << 24;
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+incorrect_read_le32 (char *x, char *y)
+{
+  unsigned char c0, c1, c2, c3;
+
+  c0 = x[0];
+  c1 = x[1];
+  c2 = x[2];
+  c3 = x[3];
+  *y = 1;
+  return c0 | c1 << 8 | c2 << 16 | c3 << 24;
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+incorrect_read_be32 (char *x, char *y)
+{
+  unsigned char c0, c1, c2, c3;
+
+  c0 = x[0];
+  c1 = x[1];
+  c2 = x[2];
+  c3 = x[3];
+  *y = 1;
+  return c3 | c2 << 8 | c1 << 16 | c0 << 24;
+}
+
+int
+main ()
+{
+  union bf_or_uint32 bfin;
+  uint32_t out;
+  char cin[] = { 0x83, 0x85, 0x87, 0x89 };
+
+  if (sizeof (uint32_t) * __CHAR_BIT__ != 32)
+    return 0;
+  bfin.inval = (struct ok) { 0x83, 0x85, 0x87, 0x89 };
+  out = partial_read_le32 (bfin);
+  /* Test what bswap would do if its check are not strict enough instead of
+     what is the expected result as there is too many possible results with
+     bitfields.  */
+  if (out == 0x89878583)
+    __builtin_abort ();
+  bfin.inval = (struct ok) { 0x83, 0x85, 0x87, 0x89 };
+  out = partial_read_be32 (bfin);
+  /* Test what bswap would do if its check are not strict enough instead of
+     what is the expected result as there is too many possible results with
+     bitfields.  */
+  if (out == 0x83858789)
+    __builtin_abort ();
+  out = fake_read_le32 (cin, &cin[2]);
+  if (out != 0x89018583)
+    __builtin_abort ();
+  cin[2] = 0x87;
+  out = fake_read_be32 (cin, &cin[2]);
+  if (out != 0x83850189)
+    __builtin_abort ();
+  cin[2] = 0x87;
+  out = incorrect_read_le32 (cin, &cin[2]);
+  if (out != 0x89878583)
+    __builtin_abort ();
+  cin[2] = 0x87;
+  out = incorrect_read_be32 (cin, &cin[2]);
+  if (out != 0x83858789)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00370-g.torture.execute-bswap-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00370-g.torture.execute-bswap-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00370-g.torture.execute-bswap-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00370-g.torture.execute-bswap-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..78b76bdefe203e70750ff72f6fc7bb9cc5dbe9fb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00370-g.torture.execute-bswap-2/test.cfg
@@ -0,0 +1,2 @@
+compile(bswap-2)
+run(bswap-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00371-g.torture.execute-builtin-constant/builtin-constant.c b/testsuite/c_test/x64_be_enable_test/GCC00371-g.torture.execute-builtin-constant/builtin-constant.c
new file mode 100644
index 0000000000000000000000000000000000000000..9e5bfb8bfe80496aa5812ace3de848d02edc4ecb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00371-g.torture.execute-builtin-constant/builtin-constant.c
@@ -0,0 +1,26 @@
+/* PR optimization/8423.  */
+
+#define btest(x) __builtin_constant_p(x) ? "1" : "0"
+
+#ifdef __OPTIMIZE__
+void
+foo (char *i)
+{
+  if (*i == '0')
+    abort ();
+}
+#else
+void
+foo (char *i)
+{
+}
+#endif
+
+int
+main (void)
+{
+  int size = sizeof (int);
+  foo (btest (size));
+  foo (btest (size));
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00371-g.torture.execute-builtin-constant/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00371-g.torture.execute-builtin-constant/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00371-g.torture.execute-builtin-constant/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00371-g.torture.execute-builtin-constant/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dd8d379e06818c99bca672c021b89f3f13e9b18f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00371-g.torture.execute-builtin-constant/test.cfg
@@ -0,0 +1,2 @@
+compile(builtin-constant)
+run(builtin-constant)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00372-g.torture.execute-builtin-types-compatible-p/builtin-types-compatible-p.c b/testsuite/c_test/x64_be_enable_test/GCC00372-g.torture.execute-builtin-types-compatible-p/builtin-types-compatible-p.c
new file mode 100644
index 0000000000000000000000000000000000000000..a998ef776f7d422cbaad19eeaf341ccfd1a4c8ef
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00372-g.torture.execute-builtin-types-compatible-p/builtin-types-compatible-p.c
@@ -0,0 +1,35 @@
+int i;
+double d;
+
+/* Make sure we return a constant.  */
+float rootbeer[__builtin_types_compatible_p (int, typeof(i))];
+
+typedef enum { hot, dog, poo, bear } dingos;
+typedef enum { janette, laura, amanda } cranberry;
+
+typedef float same1;
+typedef float same2;
+
+int main (void);
+
+int main (void)
+{
+  /* Compatible types.  */
+  if (!(__builtin_types_compatible_p (int, const int)
+	&& __builtin_types_compatible_p (typeof (hot), int)
+	&& __builtin_types_compatible_p (typeof (hot), typeof (laura))
+	&& __builtin_types_compatible_p (int[5], int[])
+	&& __builtin_types_compatible_p (same1, same2)))
+    abort ();
+
+  /* Incompatible types.  */
+  if (__builtin_types_compatible_p (char *, int)
+      || __builtin_types_compatible_p (char *, const char *)
+      || __builtin_types_compatible_p (long double, double)
+      || __builtin_types_compatible_p (typeof (i), typeof (d))
+      || __builtin_types_compatible_p (typeof (dingos), typeof (cranberry))
+      || __builtin_types_compatible_p (char, int)
+      || __builtin_types_compatible_p (char *, char **))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00372-g.torture.execute-builtin-types-compatible-p/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00372-g.torture.execute-builtin-types-compatible-p/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00372-g.torture.execute-builtin-types-compatible-p/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00372-g.torture.execute-builtin-types-compatible-p/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0da11cef488562e691a27c78628e787eb61ddd45
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00372-g.torture.execute-builtin-types-compatible-p/test.cfg
@@ -0,0 +1,2 @@
+compile(builtin-types-compatible-p)
+run(builtin-types-compatible-p)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00373-g.torture.execute-cmpsi-1/cmpsi-1.c b/testsuite/c_test/x64_be_enable_test/GCC00373-g.torture.execute-cmpsi-1/cmpsi-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9fce104fefb1dedcdb19259ec1fae5d135de7088
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00373-g.torture.execute-cmpsi-1/cmpsi-1.c
@@ -0,0 +1,32 @@
+f1 (unsigned int x, unsigned int y)
+{
+  if (x == 0)
+    dummy ();
+  x -= y;
+  /* 0xfffffff2 < 0x80000000? */
+  if (x < ~(~(unsigned int) 0 >> 1))
+    abort ();
+  return x;
+}
+
+f2 (unsigned long int x, unsigned long int y)
+{
+  if (x == 0)
+    dummy ();
+  x -= y;
+  /* 0xfffffff2 < 0x80000000? */
+  if (x < ~(~(unsigned long int) 0 >> 1))
+    abort ();
+  return x;
+}
+
+
+dummy () {}
+
+main ()
+{
+  /*      0x7ffffff3			0x80000001 */
+  f1 ((~(unsigned int) 0 >> 1) - 12, ~(~(unsigned int) 0 >> 1) + 1);
+  f2 ((~(unsigned long int) 0 >> 1) - 12, ~(~(unsigned long int) 0 >> 1) + 1);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00373-g.torture.execute-cmpsi-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00373-g.torture.execute-cmpsi-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00373-g.torture.execute-cmpsi-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00373-g.torture.execute-cmpsi-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b403b9eee394de900d1dd9170629a7fe2c738d40
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00373-g.torture.execute-cmpsi-1/test.cfg
@@ -0,0 +1,2 @@
+compile(cmpsi-1)
+run(cmpsi-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00374-g.torture.execute-compare-1/compare-1.c b/testsuite/c_test/x64_be_enable_test/GCC00374-g.torture.execute-compare-1/compare-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..78b465024ea622641312008146031b39530e1b6a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00374-g.torture.execute-compare-1/compare-1.c
@@ -0,0 +1,119 @@
+/* Copyright (C) 2002 Free Software Foundation.
+
+   Test for correctness of composite comparisons.
+
+   Written by Roger Sayle, 3rd June 2002.  */
+
+extern void abort (void);
+
+int ieq (int x, int y, int ok)
+{
+  if ((x<=y) && (x>=y))
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+
+  if ((x<=y) && (x==y))
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+
+  if ((x<=y) && (y<=x))
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+
+  if ((y==x) && (x<=y))
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+int ine (int x, int y, int ok)
+{
+  if ((x<y) || (x>y))
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+int ilt (int x, int y, int ok)
+{
+  if ((x<y) && (x!=y))
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+int ile (int x, int y, int ok)
+{
+  if ((x<y) || (x==y))
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+int igt (int x, int y, int ok)
+{
+  if ((x>y) && (x!=y))
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+int ige (int x, int y, int ok)
+{
+  if ((x>y) || (x==y))
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+int
+main ()
+{
+  ieq (1, 4, 0);
+  ieq (3, 3, 1);
+  ieq (5, 2, 0);
+
+  ine (1, 4, 1);
+  ine (3, 3, 0);
+  ine (5, 2, 1);
+
+  ilt (1, 4, 1);
+  ilt (3, 3, 0);
+  ilt (5, 2, 0);
+
+  ile (1, 4, 1);
+  ile (3, 3, 1);
+  ile (5, 2, 0);
+
+  igt (1, 4, 0);
+  igt (3, 3, 0);
+  igt (5, 2, 1);
+
+  ige (1, 4, 0);
+  ige (3, 3, 1);
+  ige (5, 2, 1);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00374-g.torture.execute-compare-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00374-g.torture.execute-compare-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00374-g.torture.execute-compare-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00374-g.torture.execute-compare-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..688314186a600e768b559b6cf75f97b3b736803c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00374-g.torture.execute-compare-1/test.cfg
@@ -0,0 +1,2 @@
+compile(compare-1)
+run(compare-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00375-g.torture.execute-compare-2/compare-2.c b/testsuite/c_test/x64_be_enable_test/GCC00375-g.torture.execute-compare-2/compare-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..858df294ecaf9a264e451bb25fef98071cbbe210
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00375-g.torture.execute-compare-2/compare-2.c
@@ -0,0 +1,24 @@
+/* Copyright (C) 2002 Free Software Foundation.
+
+   Ensure that the composite comparison optimization doesn't misfire
+   and attempt to combine a signed comparison with an unsigned one.
+
+   Written by Roger Sayle, 3rd June 2002.  */
+
+extern void abort (void);
+
+int
+foo (int x, int y)
+{
+  /* If miscompiled the following may become "x == y".  */
+  return (x<=y) && ((unsigned int)x >= (unsigned int)y);
+}
+
+int
+main ()
+{
+  if (! foo (-1,0))
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00375-g.torture.execute-compare-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00375-g.torture.execute-compare-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00375-g.torture.execute-compare-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00375-g.torture.execute-compare-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84394866c5b9ccda91a486feb2b101a8184f8f1a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00375-g.torture.execute-compare-2/test.cfg
@@ -0,0 +1,2 @@
+compile(compare-2)
+run(compare-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00376-g.torture.execute-comp-goto-1/comp-goto-1.c b/testsuite/c_test/x64_be_enable_test/GCC00376-g.torture.execute-comp-goto-1/comp-goto-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4379fe70e9ceb5270effe4f5d6d0658b7558c17a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00376-g.torture.execute-comp-goto-1/comp-goto-1.c
@@ -0,0 +1,167 @@
+/* { dg-require-effective-target label_values } */
+/* { dg-require-stack-size "4000" } */
+
+#include <stdlib.h>
+
+#if __INT_MAX__ >= 2147483647
+typedef unsigned int uint32;
+typedef signed int sint32;
+
+typedef uint32 reg_t;
+
+typedef unsigned long int host_addr_t;
+typedef uint32 target_addr_t;
+typedef sint32 target_saddr_t;
+
+typedef union
+{
+  struct
+    {
+      signed int	offset:18;
+      unsigned int	ignore:4;
+      unsigned int	s1:8;
+      int		:2;
+      signed int	simm:14;
+      unsigned int	s3:8;
+      unsigned int	s2:8;
+      int		pad2:2;
+    } f1;
+  long long ll;
+  double d;
+} insn_t;
+
+typedef struct
+{
+  target_addr_t vaddr_tag;
+  unsigned long int rigged_paddr;
+} tlb_entry_t;
+
+typedef struct
+{
+  insn_t *pc;
+  reg_t registers[256];
+  insn_t *program;
+  tlb_entry_t tlb_tab[0x100];
+} environment_t;
+
+enum operations
+{
+  LOAD32_RR,
+  METAOP_DONE
+};
+
+host_addr_t
+f ()
+{
+  abort ();
+}
+
+reg_t
+simulator_kernel (int what, environment_t *env)
+{
+  register insn_t *pc = env->pc;
+  register reg_t *regs = env->registers;
+  register insn_t insn;
+  register int s1;
+  register reg_t r2;
+  register void *base_addr = &&sim_base_addr;
+  register tlb_entry_t *tlb = env->tlb_tab;
+
+  if (what != 0)
+    {
+      int i;
+      static void *op_map[] =
+	{
+	  &&L_LOAD32_RR,
+	  &&L_METAOP_DONE,
+	};
+      insn_t *program = env->program;
+      for (i = 0; i < what; i++)
+	program[i].f1.offset = op_map[program[i].f1.offset] - base_addr;
+    }
+
+ sim_base_addr:;
+
+  insn = *pc++;
+  r2 = (*(reg_t *) (((char *) regs) + (insn.f1.s2 << 2)));
+  s1 = (insn.f1.s1 << 2);
+  goto *(base_addr + insn.f1.offset);
+
+ L_LOAD32_RR:
+  {
+    target_addr_t vaddr_page = r2 / 4096;
+    unsigned int x = vaddr_page % 0x100;
+    insn = *pc++;
+
+    for (;;)
+      {
+	target_addr_t tag = tlb[x].vaddr_tag;
+	host_addr_t rigged_paddr = tlb[x].rigged_paddr;
+
+	if (tag == vaddr_page)
+	  {
+	    *(reg_t *) (((char *) regs) + s1) = *(uint32 *) (rigged_paddr + r2);
+	    r2 = *(reg_t *) (((char *) regs) + (insn.f1.s2 << 2));
+	    s1 = insn.f1.s1 << 2;
+	    goto *(base_addr + insn.f1.offset);
+	  }
+
+	if (((target_saddr_t) tag < 0))
+	  {
+	    *(reg_t *) (((char *) regs) + s1) = *(uint32 *) f ();
+	    r2 = *(reg_t *) (((char *) regs) + (insn.f1.s2 << 2));
+	    s1 = insn.f1.s1 << 2;
+	    goto *(base_addr + insn.f1.offset);
+	  }
+
+	x = (x - 1) % 0x100;
+      }
+
+    L_METAOP_DONE:
+      return (*(reg_t *) (((char *) regs) + s1));
+  }
+}
+
+insn_t program[2 + 1];
+
+void *malloc ();
+
+int
+main ()
+{
+  environment_t env;
+  insn_t insn;
+  int i, res;
+  host_addr_t a_page = (host_addr_t) malloc (2 * 4096);
+  target_addr_t a_vaddr = 0x123450;
+  target_addr_t vaddr_page = a_vaddr / 4096;
+  a_page = (a_page + 4096 - 1) & -4096;
+
+  env.tlb_tab[((vaddr_page) % 0x100)].vaddr_tag = vaddr_page;
+  env.tlb_tab[((vaddr_page) % 0x100)].rigged_paddr = a_page - vaddr_page * 4096;
+  insn.f1.offset = LOAD32_RR;
+  env.registers[0] = 0;
+  env.registers[2] = a_vaddr;
+  *(sint32 *) (a_page + a_vaddr % 4096) = 88;
+  insn.f1.s1 = 0;
+  insn.f1.s2 = 2;
+
+  for (i = 0; i < 2; i++)
+    program[i] = insn;
+
+  insn.f1.offset = METAOP_DONE;
+  insn.f1.s1 = 0;
+  program[2] = insn;
+
+  env.pc = program;
+  env.program = program;
+
+  res = simulator_kernel (2 + 1, &env);
+
+  if (res != 88)
+    abort ();
+  exit (0);
+}
+#else
+main(){ exit (0); }
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00376-g.torture.execute-comp-goto-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00376-g.torture.execute-comp-goto-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00376-g.torture.execute-comp-goto-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00376-g.torture.execute-comp-goto-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..066911a12f9ff22857f10d8380a0fd4386a66be8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00376-g.torture.execute-comp-goto-1/test.cfg
@@ -0,0 +1,2 @@
+compile(comp-goto-1)
+run(comp-goto-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00377-g.torture.execute-complex-4/complex-4.c b/testsuite/c_test/x64_be_enable_test/GCC00377-g.torture.execute-complex-4/complex-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..1c458d21fba9b992c67434e2b8f70fa19aaf7473
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00377-g.torture.execute-complex-4/complex-4.c
@@ -0,0 +1,9 @@
+main ()
+{
+  if ((__complex__ double) 0.0 != (__complex__ double) (-0.0))
+    abort ();
+
+  if (0.0 != -0.0)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00377-g.torture.execute-complex-4/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00377-g.torture.execute-complex-4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00377-g.torture.execute-complex-4/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00377-g.torture.execute-complex-4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7fe225dee88fa7bd8b490671605bce8c409ed763
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00377-g.torture.execute-complex-4/test.cfg
@@ -0,0 +1,2 @@
+compile(complex-4)
+run(complex-4)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00378-g.torture.execute-compndlit-1/compndlit-1.c b/testsuite/c_test/x64_be_enable_test/GCC00378-g.torture.execute-compndlit-1/compndlit-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..76328c21c2e7f072e74724f5906c1a93fb33b864
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00378-g.torture.execute-compndlit-1/compndlit-1.c
@@ -0,0 +1,25 @@
+/* The bit-field below would have a problem if __INT_MAX__ is too
+   small.  */
+#if __INT_MAX__ < 2147483647
+int
+main (void)
+{
+  exit (0);
+}
+#else
+struct S
+{
+  int a:3;
+  unsigned b:1, c:28;
+};
+
+struct S x = {1, 1, 1};
+
+main ()
+{
+  x = (struct S) {b:0, a:0, c:({ struct S o = x; o.a == 1 ? 10 : 20;})};
+  if (x.c != 10)
+    abort ();
+  exit (0);
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00378-g.torture.execute-compndlit-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00378-g.torture.execute-compndlit-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00378-g.torture.execute-compndlit-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00378-g.torture.execute-compndlit-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7cdd5ea283d666f3abb1be3e4e40f6b5a8d2fc44
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00378-g.torture.execute-compndlit-1/test.cfg
@@ -0,0 +1,2 @@
+compile(compndlit-1)
+run(compndlit-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00379-g.torture.execute-const-addr-expr-1/const-addr-expr-1.c b/testsuite/c_test/x64_be_enable_test/GCC00379-g.torture.execute-const-addr-expr-1/const-addr-expr-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..dc34368cb4a4bb3a1c2ab1c40d9215e2041a5ee7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00379-g.torture.execute-const-addr-expr-1/const-addr-expr-1.c
@@ -0,0 +1,33 @@
+#include        <stdio.h>
+#include        <stdlib.h>
+extern void abort();
+
+typedef struct foo
+{
+        int     uaattrid;
+        char    *name;
+} FOO;
+
+FOO     Upgrade_items[] =
+{
+        {1, "1"},
+        {2, "2"},
+        {0, NULL}
+};
+
+int     *Upgd_minor_ID = 
+        (int *) &((Upgrade_items + 1)->uaattrid);
+
+int     *Upgd_minor_ID1 = 
+        (int *) &((Upgrade_items)->uaattrid);
+
+int
+main(int argc, char **argv)
+{
+	if (*Upgd_minor_ID != 2)
+	  abort();
+
+	if (*Upgd_minor_ID1 != 1)
+	  abort();
+	return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00379-g.torture.execute-const-addr-expr-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00379-g.torture.execute-const-addr-expr-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00379-g.torture.execute-const-addr-expr-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00379-g.torture.execute-const-addr-expr-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..70b5ada42b6e221afd06fc5523dfa03d1f157d61
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00379-g.torture.execute-const-addr-expr-1/test.cfg
@@ -0,0 +1,2 @@
+compile(const-addr-expr-1)
+run(const-addr-expr-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00380-g.torture.execute-dbra-1/dbra-1.c b/testsuite/c_test/x64_be_enable_test/GCC00380-g.torture.execute-dbra-1/dbra-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..20ae8988ec8961ec338b56db58b76f97e5b1ac4f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00380-g.torture.execute-dbra-1/dbra-1.c
@@ -0,0 +1,95 @@
+f1 (a)
+     long a;
+{
+  int i;
+  for (i = 0; i < 10; i++)
+    {
+      if (--a == -1)
+	return i;
+    }
+  return -1;
+}
+
+f2 (a)
+     long a;
+{
+  int i;
+  for (i = 0; i < 10; i++)
+    {
+      if (--a != -1)
+	return i;
+    }
+  return -1;
+}
+
+f3 (a)
+     long a;
+{
+  int i;
+  for (i = 0; i < 10; i++)
+    {
+      if (--a == 0)
+	return i;
+    }
+  return -1;
+}
+
+f4 (a)
+     long a;
+{
+  int i;
+  for (i = 0; i < 10; i++)
+    {
+      if (--a != 0)
+	return i;
+    }
+  return -1;
+}
+
+f5 (a)
+     long a;
+{
+  int i;
+  for (i = 0; i < 10; i++)
+    {
+      if (++a == 0)
+	return i;
+    }
+  return -1;
+}
+
+f6 (a)
+     long a;
+{
+  int i;
+  for (i = 0; i < 10; i++)
+    {
+      if (++a != 0)
+	return i;
+    }
+  return -1;
+}
+
+
+main()
+{
+  if (f1 (5L) != 5)
+    abort ();
+  if (f2 (1L) != 0)
+    abort ();
+  if (f2 (0L) != 1)
+    abort ();
+  if (f3 (5L) != 4)
+    abort ();
+  if (f4 (1L) != 1)
+    abort ();
+  if (f4 (0L) != 0)
+    abort ();
+  if (f5 (-5L) != 4)
+    abort ();
+  if (f6 (-1L) != 1)
+    abort ();
+  if (f6 (0L) != 0)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00380-g.torture.execute-dbra-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00380-g.torture.execute-dbra-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00380-g.torture.execute-dbra-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00380-g.torture.execute-dbra-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..174fcfcd23d6544980585fe115866860847a84d8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00380-g.torture.execute-dbra-1/test.cfg
@@ -0,0 +1,2 @@
+compile(dbra-1)
+run(dbra-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00381-g.torture.execute-doloop-1/doloop-1.c b/testsuite/c_test/x64_be_enable_test/GCC00381-g.torture.execute-doloop-1/doloop-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d2394a62ec2613295c4660f8778129e6d2c6d5bf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00381-g.torture.execute-doloop-1/doloop-1.c
@@ -0,0 +1,18 @@
+#include <limits.h>
+
+extern void exit (int);
+extern void abort (void);
+
+volatile unsigned int i;
+
+int
+main (void)
+{
+  unsigned char z = 0;
+
+  do ++i;
+  while (--z > 0);
+  if (i != UCHAR_MAX + 1U)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00381-g.torture.execute-doloop-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00381-g.torture.execute-doloop-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00381-g.torture.execute-doloop-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00381-g.torture.execute-doloop-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..19f44fb8c0b4e99b57906f6e92d5bbe7112e191e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00381-g.torture.execute-doloop-1/test.cfg
@@ -0,0 +1,2 @@
+compile(doloop-1)
+run(doloop-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00382-g.torture.execute-enum-1/enum-1.c b/testsuite/c_test/x64_be_enable_test/GCC00382-g.torture.execute-enum-1/enum-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..381e354918c41407b619b166be541053567c1154
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00382-g.torture.execute-enum-1/enum-1.c
@@ -0,0 +1,43 @@
+typedef enum
+{
+  END = -1,
+  EMPTY = (1 << 8 ) ,
+  BACKREF,
+  BEGLINE,
+  ENDLINE,
+  BEGWORD,
+  ENDWORD,
+  LIMWORD,
+  NOTLIMWORD,
+  QMARK,
+  STAR,
+  PLUS,
+  REPMN,
+  CAT,
+  OR,
+  ORTOP,
+  LPAREN,
+  RPAREN,
+  CSET
+} token;
+
+static token tok;
+
+static int
+atom ()
+{
+  if ((tok >= 0 && tok < (1 << 8 ) ) || tok >= CSET || tok == BACKREF
+      || tok == BEGLINE || tok == ENDLINE || tok == BEGWORD
+      || tok == ENDWORD || tok == LIMWORD || tok == NOTLIMWORD)
+    return 1;
+  else
+    return 0;
+}
+
+main ()
+{
+  tok = 0;
+  if (atom () != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00382-g.torture.execute-enum-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00382-g.torture.execute-enum-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00382-g.torture.execute-enum-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00382-g.torture.execute-enum-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bb17e239f7fb82d35fdbcce9aab0025568cded34
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00382-g.torture.execute-enum-1/test.cfg
@@ -0,0 +1,2 @@
+compile(enum-1)
+run(enum-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00383-g.torture.execute-enum-3/enum-3.c b/testsuite/c_test/x64_be_enable_test/GCC00383-g.torture.execute-enum-3/enum-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..f57bc7f7838b1f7580b99c0b70bd0976e250db7d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00383-g.torture.execute-enum-3/enum-3.c
@@ -0,0 +1,24 @@
+/* The composite type of int and an enum compatible with int might be
+   either of the two types, but it isn't an unsigned type.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+#include <limits.h>
+
+#include <stdio.h>
+
+extern void abort (void);
+extern void exit (int);
+
+enum e { a = INT_MIN };
+
+int *p;
+enum e *q;
+int
+main (void)
+{
+  enum e x = a;
+  q = &x;
+  if (*(1 ? q : p) > 0)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00383-g.torture.execute-enum-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00383-g.torture.execute-enum-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00383-g.torture.execute-enum-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00383-g.torture.execute-enum-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..077be14d9d95e6f1fc2835d319b7ec015c63c9b4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00383-g.torture.execute-enum-3/test.cfg
@@ -0,0 +1,2 @@
+compile(enum-3)
+run(enum-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00384-g.torture.execute-extzvsi/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00384-g.torture.execute-extzvsi/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00384-g.torture.execute-extzvsi/extzvsi.c b/testsuite/c_test/x64_be_enable_test/GCC00384-g.torture.execute-extzvsi/extzvsi.c
new file mode 100644
index 0000000000000000000000000000000000000000..81f16185d21aaced1d51f4766be2097c83e3f49b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00384-g.torture.execute-extzvsi/extzvsi.c
@@ -0,0 +1,41 @@
+/* The bit-field below would have a problem if __INT_MAX__ is too
+   small.  */
+#if __INT_MAX__ < 2147483647
+int
+main (void)
+{
+  exit (0);
+}
+#else
+/* Failed on powerpc due to bad extzvsi pattern.  */
+
+struct ieee
+{
+  unsigned int negative:1;
+  unsigned int exponent:11;
+  unsigned int mantissa0:20;
+  unsigned int mantissa1:32;
+} x;
+
+unsigned int
+foo (void)
+{
+  unsigned int exponent;
+
+  exponent = x.exponent;
+  if (exponent == 0)
+    return 1;
+  else if (exponent > 1)
+    return 2;
+  return 0;
+}
+
+int
+main (void)
+{
+  x.exponent = 1;
+  if (foo () != 0)
+    abort ();
+  return 0;
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00384-g.torture.execute-extzvsi/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00384-g.torture.execute-extzvsi/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..623005fa1a98066441e7be55d25952cc10513989
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00384-g.torture.execute-extzvsi/test.cfg
@@ -0,0 +1,2 @@
+compile(extzvsi)
+run(extzvsi)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00385-g.torture.execute-fprintf-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00385-g.torture.execute-fprintf-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..63b29a219d5b16d0b37edf195e45913dfecabdd1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00385-g.torture.execute-fprintf-1/expected.txt
@@ -0,0 +1,10 @@
+hellohellohello
+hello
+aahellohellohello
+hello
+aaxxhello
+
+hello
+
+0
+0
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00385-g.torture.execute-fprintf-1/fprintf-1.c b/testsuite/c_test/x64_be_enable_test/GCC00385-g.torture.execute-fprintf-1/fprintf-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..15996ef22c513d913ca6e9e3a448c129012819bd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00385-g.torture.execute-fprintf-1/fprintf-1.c
@@ -0,0 +1,25 @@
+/* { dg-skip-if "requires io" { freestanding } }  */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int
+main (void)
+{
+#define test(ret, args...) \
+  fprintf (stdout, args); 		\
+  if (fprintf (stdout, args) != ret)	\
+    abort ();
+  test (5, "hello");
+  test (6, "hello\n");
+  test (1, "a");
+  test (0, "");
+  test (5, "%s", "hello");
+  test (6, "%s", "hello\n");
+  test (1, "%s", "a");
+  test (0, "%s", "");
+  test (1, "%c", 'x');
+  test (7, "%s\n", "hello\n");
+  test (2, "%d\n", 0);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00385-g.torture.execute-fprintf-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00385-g.torture.execute-fprintf-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b37265ec9744abf24b6bfca568d005c652ddef10
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00385-g.torture.execute-fprintf-1/test.cfg
@@ -0,0 +1,2 @@
+compile(fprintf-1)
+run(fprintf-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00386-g.torture.execute-fprintf-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00386-g.torture.execute-fprintf-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00386-g.torture.execute-fprintf-2/fprintf-2.c b/testsuite/c_test/x64_be_enable_test/GCC00386-g.torture.execute-fprintf-2/fprintf-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..d8e19e7b2f8f51852facdae03724214ce132da84
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00386-g.torture.execute-fprintf-2/fprintf-2.c
@@ -0,0 +1,56 @@
+/* Verify that calls to fprintf don't get eliminated even if their
+   result on success can be computed at compile time (they can fail).
+   The calls can still be transformed into those of other functions.
+   { dg-require-effective-target fileio }
+   { dg-prune-output "warning: warning: \[^\n\r\]* possibly used unsafely" }
+   { dg-skip-if "requires io" { avr-*-* } }
+   { dg-skip-if "requires io" { freestanding } } */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main (void)
+{
+  char *tmpfname = tmpnam (0);
+  FILE *f = fopen (tmpfname, "w");
+  if (!f)
+    {
+      perror ("fopen for writing");
+      return 1;
+    }
+
+  fprintf (f, "1");
+  fprintf (f, "%c", '2');
+  fprintf (f, "%c%c", '3', '4');
+  fprintf (f, "%s", "5");
+  fprintf (f, "%s%s", "6", "7");
+  fprintf (f, "%i", 8);
+  fprintf (f, "%.1s\n", "9x");
+  fclose (f);
+
+  f = fopen (tmpfname, "r");
+  if (!f)
+    {
+      perror ("fopen for reading");
+      remove (tmpfname);
+      return 1;
+    }
+
+  char buf[12] = "";
+  if (1 != fscanf (f, "%s", buf))
+    {
+      perror ("fscanf");
+      fclose (f);
+      remove (tmpfname);
+      return 1;
+    }
+
+  fclose (f);
+  remove (tmpfname);
+
+  if (strcmp (buf, "123456789"))
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00386-g.torture.execute-fprintf-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00386-g.torture.execute-fprintf-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a5eb2226462f5b3a324a4291df43ceead13ee7c4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00386-g.torture.execute-fprintf-2/test.cfg
@@ -0,0 +1,2 @@
+compile(fprintf-2)
+run(fprintf-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00387-g.torture.execute-ifcvt-onecmpl-abs-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00387-g.torture.execute-ifcvt-onecmpl-abs-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00387-g.torture.execute-ifcvt-onecmpl-abs-1/ifcvt-onecmpl-abs-1.c b/testsuite/c_test/x64_be_enable_test/GCC00387-g.torture.execute-ifcvt-onecmpl-abs-1/ifcvt-onecmpl-abs-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..679e552f8482db43f0401c04249da619fb00cf5d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00387-g.torture.execute-ifcvt-onecmpl-abs-1/ifcvt-onecmpl-abs-1.c
@@ -0,0 +1,19 @@
+
+extern void abort(void);
+
+__attribute__ ((noinline))
+int foo(int n)
+{
+  if (n < 0)
+    n = ~n;
+
+  return n;
+}
+
+int main(void)
+{
+  if (foo (-1) != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00387-g.torture.execute-ifcvt-onecmpl-abs-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00387-g.torture.execute-ifcvt-onecmpl-abs-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fcc7f36de6654134a123ab2d4f9ee7764fbb67f5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00387-g.torture.execute-ifcvt-onecmpl-abs-1/test.cfg
@@ -0,0 +1,2 @@
+compile(ifcvt-onecmpl-abs-1)
+run(ifcvt-onecmpl-abs-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00388-g.torture.execute-index-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00388-g.torture.execute-index-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00388-g.torture.execute-index-1/index-1.c b/testsuite/c_test/x64_be_enable_test/GCC00388-g.torture.execute-index-1/index-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d96be4c77b8b093ddb79ac009471c4ae2aa27019
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00388-g.torture.execute-index-1/index-1.c
@@ -0,0 +1,22 @@
+/* { dg-skip-if "strict reloc overflow checking" { msp430-*-* } { "*" } { "-mcpu=msp430" "-mlarge"} } */
+
+int a[] =
+{
+  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+  20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+  30, 31, 32, 33, 34, 35, 36, 37, 38, 39
+};
+
+int
+f (long n)
+{
+  return a[n - 100000];
+}
+
+main ()
+{
+  if (f (100030L) != 30)
+    abort();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00388-g.torture.execute-index-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00388-g.torture.execute-index-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d2cd6e64651d684ad1d610c4057af2b21946bc6f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00388-g.torture.execute-index-1/test.cfg
@@ -0,0 +1,2 @@
+compile(index-1)
+run(index-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00389-g.torture.execute-longlong/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00389-g.torture.execute-longlong/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00389-g.torture.execute-longlong/longlong.c b/testsuite/c_test/x64_be_enable_test/GCC00389-g.torture.execute-longlong/longlong.c
new file mode 100644
index 0000000000000000000000000000000000000000..56f1d8eab107ca7506e77fe9d2f46e8636236490
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00389-g.torture.execute-longlong/longlong.c
@@ -0,0 +1,39 @@
+/* Source: PR 321 modified for test suite by Neil Booth 14 Jan 2001.  */
+
+typedef unsigned long long uint64;
+unsigned long pars;
+
+uint64 b[32];
+uint64 *r = b;
+
+void alpha_ep_extbl_i_eq_0()
+{
+  unsigned int rb, ra, rc;
+
+  rb  = (((unsigned long)(pars) >> 27)) & 0x1fUL;
+  ra  = (((unsigned int)(pars) >> 5)) & 0x1fUL;
+  rc  = (((unsigned int)(pars) >> 0)) & 0x1fUL;
+  {
+    uint64 temp = ((r[ra] >> ((r[rb] & 0x7) << 3)) & 0x00000000000000FFLL); 
+    if (rc != 31) 
+      r[rc] = temp;  
+  }
+}
+
+int 
+main(void)
+{
+  if (sizeof (uint64) == 8)
+    {
+      b[17] = 0x0000000000303882ULL; /* rb */
+      b[2] = 0x534f4f4c494d000aULL; /* ra & rc */
+
+      pars = 0x88000042;	/* 17, 2, 2 coded */
+      alpha_ep_extbl_i_eq_0();
+
+      if (b[2] != 0x4d)
+	abort ();
+    }
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00389-g.torture.execute-longlong/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00389-g.torture.execute-longlong/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e5550a2710495e9d07e04d2567d8343d76dad9c1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00389-g.torture.execute-longlong/test.cfg
@@ -0,0 +1,2 @@
+compile(longlong)
+run(longlong)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00390-g.torture.execute-loop-10/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00390-g.torture.execute-loop-10/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00390-g.torture.execute-loop-10/loop-10.c b/testsuite/c_test/x64_be_enable_test/GCC00390-g.torture.execute-loop-10/loop-10.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a6afba6b9592e058fd0b1b4e90bd1cdc1d17b40
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00390-g.torture.execute-loop-10/loop-10.c
@@ -0,0 +1,31 @@
+/* Reduced from PR optimization/5076, PR optimization/2847 */
+
+static int count = 0;
+
+static void
+inc (void)
+{
+  count++;
+}
+
+int
+main (void)
+{
+  int iNbr = 1;
+  int test = 0;
+  while (test == 0)
+    {
+      inc ();
+      if (iNbr == 0)
+        break;
+      else
+        {
+          inc ();
+          iNbr--;
+        }
+      test = 1;
+    }
+  if (count != 2)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00390-g.torture.execute-loop-10/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00390-g.torture.execute-loop-10/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4659aff12973e3da9c7974917715e8789c53b5b8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00390-g.torture.execute-loop-10/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-10)
+run(loop-10)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00391-g.torture.execute-loop-15/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00391-g.torture.execute-loop-15/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00391-g.torture.execute-loop-15/loop-15.c b/testsuite/c_test/x64_be_enable_test/GCC00391-g.torture.execute-loop-15/loop-15.c
new file mode 100644
index 0000000000000000000000000000000000000000..8cb5125a29ea691731155d245c819a0fcf8a2822
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00391-g.torture.execute-loop-15/loop-15.c
@@ -0,0 +1,40 @@
+/* Bombed with a segfault on powerpc-linux.  doloop.c generated wrong
+   loop count.  */
+void
+foo (unsigned long *start, unsigned long *end)
+{
+  unsigned long *temp = end - 1;
+
+  while (end > start)
+    *end-- = *temp--;
+}
+
+int
+main (void)
+{
+  unsigned long a[5];
+  int start, end, k;
+
+  for (start = 0; start < 5; start++)
+    for (end = 0; end < 5; end++)
+      {
+	for (k = 0; k < 5; k++)
+	  a[k] = k;
+
+	foo (a + start, a + end);
+
+	for (k = 0; k <= start; k++)
+	  if (a[k] != k)
+	    abort ();
+
+	for (k = start + 1; k <= end; k++)
+	  if (a[k] != k - 1)
+	    abort ();
+
+	for (k = end + 1; k < 5; k++)
+	  if (a[k] != k)
+	    abort ();
+      }
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00391-g.torture.execute-loop-15/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00391-g.torture.execute-loop-15/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..563f46ea0f4dac422ba9f665c4f6f30b6fe6415e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00391-g.torture.execute-loop-15/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-15)
+run(loop-15)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00392-g.torture.execute-loop-2b/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00392-g.torture.execute-loop-2b/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00392-g.torture.execute-loop-2b/loop-2b.c b/testsuite/c_test/x64_be_enable_test/GCC00392-g.torture.execute-loop-2b/loop-2b.c
new file mode 100644
index 0000000000000000000000000000000000000000..7f67bcd639db0287937c491f25b92c059a365643
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00392-g.torture.execute-loop-2b/loop-2b.c
@@ -0,0 +1,22 @@
+#include <limits.h>
+
+int a[2];
+
+f (int i)
+{
+  for (; i < INT_MAX; i++)
+    {
+      a[i] = -2;
+      if (&a[i] == &a[1])
+	break;
+    }
+}
+
+main ()
+{
+  a[0] = a[1] = 0;
+  f (0);
+  if (a[0] != -2 || a[1] != -2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00392-g.torture.execute-loop-2b/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00392-g.torture.execute-loop-2b/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c3a0561badd59b3501ad34977e2aafa929e8ed19
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00392-g.torture.execute-loop-2b/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-2b)
+run(loop-2b)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00393-g.torture.execute-loop-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00393-g.torture.execute-loop-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00393-g.torture.execute-loop-2/loop-2.c b/testsuite/c_test/x64_be_enable_test/GCC00393-g.torture.execute-loop-2/loop-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..3227734fbf8bc1454d6b75cdc0ec5adcf32d9e91
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00393-g.torture.execute-loop-2/loop-2.c
@@ -0,0 +1,17 @@
+int a[2];
+
+f (b)
+{
+  unsigned int i;
+  for (i = 0; i < b; i++)
+    a[i] = i - 2;
+}
+
+main ()
+{
+  a[0] = a[1] = 0;
+  f (2);
+  if (a[0] != -2 || a[1] != -1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00393-g.torture.execute-loop-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00393-g.torture.execute-loop-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..954aaa89935e6534ded68c33cdf966e73a8b03eb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00393-g.torture.execute-loop-2/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-2)
+run(loop-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00394-g.torture.execute-loop-2c/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00394-g.torture.execute-loop-2c/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00394-g.torture.execute-loop-2c/loop-2c.c b/testsuite/c_test/x64_be_enable_test/GCC00394-g.torture.execute-loop-2c/loop-2c.c
new file mode 100644
index 0000000000000000000000000000000000000000..17cdaaa095f36757feb547e6e47ceda124d2f98b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00394-g.torture.execute-loop-2c/loop-2c.c
@@ -0,0 +1,30 @@
+/* { dg-options "-fgnu89-inline -Wno-pointer-to-int-cast" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int a[2];
+
+__inline__ void f (int b, int o)
+{
+  unsigned int i;
+  int *p;
+  for (p = &a[b], i = b; --i < ~0; )
+    *--p = i * 3 + o;
+}
+
+void
+g(int b)
+{
+  f (b, (int)a);
+}
+
+int
+main ()
+{
+  a[0] = a[1] = 0;
+  g (2);
+  if (a[0] != (int)a || a[1] != (int)a + 3)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00394-g.torture.execute-loop-2c/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00394-g.torture.execute-loop-2c/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8c7c96d10ab3c4107644be43c1c14dac02558569
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00394-g.torture.execute-loop-2c/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-2c)
+run(loop-2c)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00395-g.torture.execute-loop-2e/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00395-g.torture.execute-loop-2e/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00395-g.torture.execute-loop-2e/loop-2e.c b/testsuite/c_test/x64_be_enable_test/GCC00395-g.torture.execute-loop-2e/loop-2e.c
new file mode 100644
index 0000000000000000000000000000000000000000..71c7a4d1d87b57e78c2651b9c224e4bbe0729e7d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00395-g.torture.execute-loop-2e/loop-2e.c
@@ -0,0 +1,39 @@
+void f (int *p, int **q)
+{
+  int i;
+  for (i = 0; i < 40; i++)
+    {
+      *q++ = &p[i];
+    }
+}
+
+int main ()
+{
+  void *p;
+  int *q[40];
+  __SIZE_TYPE__ start;
+
+  /* Find the signed middle of the address space.  */
+  if (sizeof(start) == sizeof(int))
+    start = (__SIZE_TYPE__) __INT_MAX__;
+  else if (sizeof(start) == sizeof(long))
+    start = (__SIZE_TYPE__) __LONG_MAX__;
+  else if (sizeof(start) == sizeof(long long))
+    start = (__SIZE_TYPE__) __LONG_LONG_MAX__;
+  else
+    return 0;
+
+  /* Arbitrarily align the pointer.  */
+  start &= -32;
+
+  /* Pretend that's good enough to start address arithmetic.  */
+  p = (void *)start;
+
+  /* Verify that GIV replacement computes the correct results.  */
+  q[39] = 0;
+  f (p, q);
+  if (q[39] != (int *)p + 39)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00395-g.torture.execute-loop-2e/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00395-g.torture.execute-loop-2e/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8a118c4c9e1a31c45dc6cddb6734a20f673219db
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00395-g.torture.execute-loop-2e/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-2e)
+run(loop-2e)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00396-g.torture.execute-loop-3b/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00396-g.torture.execute-loop-3b/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00396-g.torture.execute-loop-3b/loop-3b.c b/testsuite/c_test/x64_be_enable_test/GCC00396-g.torture.execute-loop-3b/loop-3b.c
new file mode 100644
index 0000000000000000000000000000000000000000..3de322cf146785dd7bf620f19ed86f7aafd0ad88
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00396-g.torture.execute-loop-3b/loop-3b.c
@@ -0,0 +1,28 @@
+#include <limits.h>
+
+int n = 0;
+
+g (i)
+{
+  n++;
+}
+
+f (m)
+{
+  int i;
+  i = m;
+  do
+    {
+      g (i * 4);
+      i -= INT_MAX / 8;
+    }
+  while (i > 0);
+}
+
+main ()
+{
+  f (INT_MAX/8*4);
+  if (n != 4)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00396-g.torture.execute-loop-3b/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00396-g.torture.execute-loop-3b/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b62a94e59ddb896c3538123bd83fb964f86ab3f1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00396-g.torture.execute-loop-3b/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-3b)
+run(loop-3b)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00397-g.torture.execute-loop-3c/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00397-g.torture.execute-loop-3c/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00397-g.torture.execute-loop-3c/loop-3c.c b/testsuite/c_test/x64_be_enable_test/GCC00397-g.torture.execute-loop-3c/loop-3c.c
new file mode 100644
index 0000000000000000000000000000000000000000..bc74c2e6d9b211279b40f808debabdc7f4f498de
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00397-g.torture.execute-loop-3c/loop-3c.c
@@ -0,0 +1,31 @@
+#include <limits.h>
+
+void * a[255];
+
+f (m)
+{
+  int i;
+  int sh = 0x100;
+  i = m;
+  do
+    {
+      a[sh >>= 1] = ((unsigned)i << 3)  + (char*)a;
+      i += 4;
+    }
+  while (i < INT_MAX/2 + 1 + 4 * 4);
+}
+
+main ()
+{
+  a[0x10] = 0;
+  a[0x08] = 0;
+  f (INT_MAX/2 + INT_MAX/4 + 2);
+  if (a[0x10] || a[0x08])
+    abort ();
+  a[0x10] = 0;
+  a[0x08] = 0;
+  f (INT_MAX/2 + 1);
+  if (! a[0x10] || a[0x08])
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00397-g.torture.execute-loop-3c/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00397-g.torture.execute-loop-3c/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..37671d7533b6e9d31a59f46baf073860a45f50d0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00397-g.torture.execute-loop-3c/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-3c)
+run(loop-3c)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00398-g.torture.execute-loop-5/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00398-g.torture.execute-loop-5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00398-g.torture.execute-loop-5/loop-5.c b/testsuite/c_test/x64_be_enable_test/GCC00398-g.torture.execute-loop-5/loop-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..44ece275be1c35868200f16ed38dece192771753
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00398-g.torture.execute-loop-5/loop-5.c
@@ -0,0 +1,36 @@
+static int ap(int i);
+static void testit(void){
+  int ir[4] = {0,1,2,3};
+  int ix,n,m;
+  n=1; m=3;
+  for (ix=1;ix<=4;ix++) {
+    if (n == 1) m = 4;
+    else        m = n-1;
+    ap(ir[n-1]);
+    n = m;
+  }
+}
+
+static int t = 0;
+static int a[4];
+
+static int ap(int i){
+  if (t > 3)
+    abort();
+  a[t++] = i;
+  return 1;
+}
+
+int main(void)
+{
+  testit();
+  if (a[0] != 0)
+    abort();
+  if (a[1] != 3)
+    abort();
+  if (a[2] != 2)
+    abort();
+  if (a[3] != 1)
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00398-g.torture.execute-loop-5/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00398-g.torture.execute-loop-5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..07bd52c5a57b699206291acda1a8d90e29ba530b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00398-g.torture.execute-loop-5/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-5)
+run(loop-5)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00399-g.torture.execute-loop-7/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00399-g.torture.execute-loop-7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00399-g.torture.execute-loop-7/loop-7.c b/testsuite/c_test/x64_be_enable_test/GCC00399-g.torture.execute-loop-7/loop-7.c
new file mode 100644
index 0000000000000000000000000000000000000000..48a2599b281ffafb4239d9870ced001fa6e590db
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00399-g.torture.execute-loop-7/loop-7.c
@@ -0,0 +1,19 @@
+void foo (unsigned int n)
+{
+  int i, j = -1;
+
+  for (i = 0; i < 10 && j < 0; i++)
+    {
+      if ((1UL << i) == n)
+	j = i;
+    }
+
+  if (j < 0)
+    abort ();
+}
+
+main()
+{
+  foo (64);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00399-g.torture.execute-loop-7/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00399-g.torture.execute-loop-7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d49d2437f4800eb5788523ade1ec540d3bfdc2c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00399-g.torture.execute-loop-7/test.cfg
@@ -0,0 +1,2 @@
+compile(loop-7)
+run(loop-7)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00400-g.torture.execute-lshrdi-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00400-g.torture.execute-lshrdi-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00400-g.torture.execute-lshrdi-1/lshrdi-1.c b/testsuite/c_test/x64_be_enable_test/GCC00400-g.torture.execute-lshrdi-1/lshrdi-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..df53f8bd856c871415dd2471b125e4973d0a9019
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00400-g.torture.execute-lshrdi-1/lshrdi-1.c
@@ -0,0 +1,221 @@
+#include <limits.h>
+
+extern void abort(void);
+extern void exit(int);
+
+#if __LONG_LONG_MAX__ == 9223372036854775807LL
+#define BITS 64
+
+static unsigned long long const zext[64] = {
+  0x87654321fedcba90ULL,
+  0x43b2a190ff6e5d48ULL,
+  0x21d950c87fb72ea4ULL,
+  0x10eca8643fdb9752ULL,
+  0x87654321fedcba9ULL,
+  0x43b2a190ff6e5d4ULL,
+  0x21d950c87fb72eaULL,
+  0x10eca8643fdb975ULL,
+  0x87654321fedcbaULL,
+  0x43b2a190ff6e5dULL,
+  0x21d950c87fb72eULL,
+  0x10eca8643fdb97ULL,
+  0x87654321fedcbULL,
+  0x43b2a190ff6e5ULL,
+  0x21d950c87fb72ULL,
+  0x10eca8643fdb9ULL,
+  0x87654321fedcULL,
+  0x43b2a190ff6eULL,
+  0x21d950c87fb7ULL,
+  0x10eca8643fdbULL,
+  0x87654321fedULL,
+  0x43b2a190ff6ULL,
+  0x21d950c87fbULL,
+  0x10eca8643fdULL,
+  0x87654321feULL,
+  0x43b2a190ffULL,
+  0x21d950c87fULL,
+  0x10eca8643fULL,
+  0x87654321fULL,
+  0x43b2a190fULL,
+  0x21d950c87ULL,
+  0x10eca8643ULL,
+  0x87654321ULL,
+  0x43b2a190ULL,
+  0x21d950c8ULL,
+  0x10eca864ULL,
+  0x8765432ULL,
+  0x43b2a19ULL,
+  0x21d950cULL,
+  0x10eca86ULL,
+  0x876543ULL,
+  0x43b2a1ULL,
+  0x21d950ULL,
+  0x10eca8ULL,
+  0x87654ULL,
+  0x43b2aULL,
+  0x21d95ULL,
+  0x10ecaULL,
+  0x8765ULL,
+  0x43b2ULL,
+  0x21d9ULL,
+  0x10ecULL,
+  0x876ULL,
+  0x43bULL,
+  0x21dULL,
+  0x10eULL,
+  0x87ULL,
+  0x43ULL,
+  0x21ULL,
+  0x10ULL,
+  0x8ULL,
+  0x4ULL,
+  0x2ULL,
+  0x1ULL
+};
+
+#elif __LONG_LONG_MAX__ == 2147483647LL
+#define BITS 32
+
+static unsigned long long const zext[32] = {
+  0x87654321ULL,
+  0x43b2a190ULL,
+  0x21d950c8ULL,
+  0x10eca864ULL,
+  0x8765432ULL,
+  0x43b2a19ULL,
+  0x21d950cULL,
+  0x10eca86ULL,
+  0x876543ULL,
+  0x43b2a1ULL,
+  0x21d950ULL,
+  0x10eca8ULL,
+  0x87654ULL,
+  0x43b2aULL,
+  0x21d95ULL,
+  0x10ecaULL,
+  0x8765ULL,
+  0x43b2ULL,
+  0x21d9ULL,
+  0x10ecULL,
+  0x876ULL,
+  0x43bULL,
+  0x21dULL,
+  0x10eULL,
+  0x87ULL,
+  0x43ULL,
+  0x21ULL,
+  0x10ULL,
+  0x8ULL,
+  0x4ULL,
+  0x2ULL,
+  0x1ULL,
+};
+
+#else
+#error "Update the test case."
+#endif
+
+static unsigned long long
+variable_shift(unsigned long long x, int i)
+{
+  return x >> i;
+}
+
+static unsigned long long
+constant_shift(unsigned long long x, int i)
+{
+  switch (i)
+    {
+    case 0: x = x >> 0; break;
+    case 1: x = x >> 1; break;
+    case 2: x = x >> 2; break;
+    case 3: x = x >> 3; break;
+    case 4: x = x >> 4; break;
+    case 5: x = x >> 5; break;
+    case 6: x = x >> 6; break;
+    case 7: x = x >> 7; break;
+    case 8: x = x >> 8; break;
+    case 9: x = x >> 9; break;
+    case 10: x = x >> 10; break;
+    case 11: x = x >> 11; break;
+    case 12: x = x >> 12; break;
+    case 13: x = x >> 13; break;
+    case 14: x = x >> 14; break;
+    case 15: x = x >> 15; break;
+    case 16: x = x >> 16; break;
+    case 17: x = x >> 17; break;
+    case 18: x = x >> 18; break;
+    case 19: x = x >> 19; break;
+    case 20: x = x >> 20; break;
+    case 21: x = x >> 21; break;
+    case 22: x = x >> 22; break;
+    case 23: x = x >> 23; break;
+    case 24: x = x >> 24; break;
+    case 25: x = x >> 25; break;
+    case 26: x = x >> 26; break;
+    case 27: x = x >> 27; break;
+    case 28: x = x >> 28; break;
+    case 29: x = x >> 29; break;
+    case 30: x = x >> 30; break;
+    case 31: x = x >> 31; break;
+#if BITS > 32
+    case 32: x = x >> 32; break;
+    case 33: x = x >> 33; break;
+    case 34: x = x >> 34; break;
+    case 35: x = x >> 35; break;
+    case 36: x = x >> 36; break;
+    case 37: x = x >> 37; break;
+    case 38: x = x >> 38; break;
+    case 39: x = x >> 39; break;
+    case 40: x = x >> 40; break;
+    case 41: x = x >> 41; break;
+    case 42: x = x >> 42; break;
+    case 43: x = x >> 43; break;
+    case 44: x = x >> 44; break;
+    case 45: x = x >> 45; break;
+    case 46: x = x >> 46; break;
+    case 47: x = x >> 47; break;
+    case 48: x = x >> 48; break;
+    case 49: x = x >> 49; break;
+    case 50: x = x >> 50; break;
+    case 51: x = x >> 51; break;
+    case 52: x = x >> 52; break;
+    case 53: x = x >> 53; break;
+    case 54: x = x >> 54; break;
+    case 55: x = x >> 55; break;
+    case 56: x = x >> 56; break;
+    case 57: x = x >> 57; break;
+    case 58: x = x >> 58; break;
+    case 59: x = x >> 59; break;
+    case 60: x = x >> 60; break;
+    case 61: x = x >> 61; break;
+    case 62: x = x >> 62; break;
+    case 63: x = x >> 63; break;
+#endif
+
+    default:
+      abort ();
+    }
+  return x;
+}
+
+int
+main()
+{
+  int i;
+
+  for (i = 0; i < BITS; ++i)
+    {
+      unsigned long long y = variable_shift (zext[0], i);
+      if (y != zext[i])
+	abort ();
+    }
+  for (i = 0; i < BITS; ++i)
+    {
+      unsigned long long y = constant_shift (zext[0], i);
+      if (y != zext[i])
+	abort ();
+    }
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00400-g.torture.execute-lshrdi-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00400-g.torture.execute-lshrdi-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eb6d1188cd01eb3da2698012d98a55bb6b018ecd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00400-g.torture.execute-lshrdi-1/test.cfg
@@ -0,0 +1,2 @@
+compile(lshrdi-1)
+run(lshrdi-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00401-g.torture.execute-lto-tbaa-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00401-g.torture.execute-lto-tbaa-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00401-g.torture.execute-lto-tbaa-1/lto-tbaa-1.c b/testsuite/c_test/x64_be_enable_test/GCC00401-g.torture.execute-lto-tbaa-1/lto-tbaa-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..fe1e1771c7f9e496d600141aab7ae3883f4a4f1b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00401-g.torture.execute-lto-tbaa-1/lto-tbaa-1.c
@@ -0,0 +1,42 @@
+/* { dg-additional-options "-fno-early-inlining -fno-ipa-cp" }  */
+struct a {
+  float *b;
+} *a;
+struct b {
+  int *b;
+} b;
+struct c {
+  float *b;
+} *c;
+int d;
+use_a (struct a *a)
+{
+}
+set_b (int **a)
+{
+  *a=&d;
+}
+use_c (struct c *a)
+{
+}
+__attribute__ ((noinline)) int **retme(int **val)
+{
+  return val;
+}
+int e;
+struct b b= {&e};
+struct b b2;
+struct b b3;
+int **ptr = &b2.b;
+main ()
+{
+  a= (void *)0;
+  b.b=&e;
+  ptr =retme ( &b.b);
+  set_b (ptr);
+  b3=b;
+  if (b3.b != &d)
+  __builtin_abort ();
+  c= (void *)0;
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00401-g.torture.execute-lto-tbaa-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00401-g.torture.execute-lto-tbaa-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bb0fa371f4709694b56d93392843feee21adbdde
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00401-g.torture.execute-lto-tbaa-1/test.cfg
@@ -0,0 +1,2 @@
+compile(lto-tbaa-1)
+run(lto-tbaa-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00402-g.torture.execute-medce-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00402-g.torture.execute-medce-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00402-g.torture.execute-medce-1/medce-1.c b/testsuite/c_test/x64_be_enable_test/GCC00402-g.torture.execute-medce-1/medce-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c0a77274f5a35026256a67f22effad1eb75af3a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00402-g.torture.execute-medce-1/medce-1.c
@@ -0,0 +1,33 @@
+
+extern void abort (void);
+extern void link_error (void);
+
+static int ok = 0;
+
+void bar (void)
+{
+  ok = 1;
+}
+
+void foo(int x)
+{
+  switch (x)
+  {
+  case 0:
+    if (0)
+    {
+      link_error();
+  case 1:
+      bar();
+    }
+  }
+}
+
+int main()
+{
+  foo (1);
+  if (!ok)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00402-g.torture.execute-medce-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00402-g.torture.execute-medce-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..14fb83ec6afe270dfbafcfaf4ae6fc6684275cea
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00402-g.torture.execute-medce-1/test.cfg
@@ -0,0 +1,2 @@
+compile(medce-1)
+run(medce-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00403-g.torture.execute-memchr-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00403-g.torture.execute-memchr-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00403-g.torture.execute-memchr-1/memchr-1.c b/testsuite/c_test/x64_be_enable_test/GCC00403-g.torture.execute-memchr-1/memchr-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f769fa159d6653ae01c1276ec85e5bb7490da90d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00403-g.torture.execute-memchr-1/memchr-1.c
@@ -0,0 +1,207 @@
+/* PR tree-optimization/86711 - wrong folding of memchr
+
+   Verify that memchr() of arrays initialized with string literals
+   where the nul doesn't fit in the array doesn't find the nul.  */
+typedef __SIZE_TYPE__  size_t;
+typedef __WCHAR_TYPE__ wchar_t;
+
+extern void* memchr (const void*, int, size_t);
+
+#define A(expr)							\
+  ((expr)							\
+   ? (void)0							\
+   : (__builtin_printf ("assertion failed on line %i: %s\n",	\
+			__LINE__, #expr),			\
+      __builtin_abort ()))
+
+static const char c = '1';
+static const char s1[1] = "1";
+static const char s4[4] = "1234";
+
+static const char s4_2[2][4] = { "1234", "5678" };
+static const char s5_3[3][5] = { "12345", "6789", "01234" };
+
+volatile int v0 = 0;
+volatile int v1 = 1;
+volatile int v2 = 2;
+volatile int v3 = 3;
+volatile int v4 = 3;
+
+void test_narrow (void)
+{
+  int i0 = 0;
+  int i1 = i0 + 1;
+  int i2 = i1 + 1;
+  int i3 = i2 + 1;
+  int i4 = i3 + 1;
+
+  A (memchr ("" + 1, 0, 0) == 0);
+
+  A (memchr (&c, 0, sizeof c) == 0);
+  A (memchr (&c + 1, 0, sizeof c - 1) == 0);
+  A (memchr (&c + i1, 0, sizeof c - i1) == 0);
+  A (memchr (&c + v1, 0, sizeof c - v1) == 0);
+
+  A (memchr (s1, 0, sizeof s1) == 0);
+  A (memchr (s1 + 1, 0, sizeof s1 - 1) == 0);
+  A (memchr (s1 + i1, 0, sizeof s1 - i1) == 0);
+  A (memchr (s1 + v1, 0, sizeof s1 - v1) == 0);
+
+  A (memchr (&s1, 0, sizeof s1) == 0);
+  A (memchr (&s1 + 1, 0, sizeof s1 - 1) == 0);
+  A (memchr (&s1 + i1, 0, sizeof s1 - i1) == 0);
+  A (memchr (&s1 + v1, 0, sizeof s1 - v1) == 0);
+
+  A (memchr (&s1[0], 0, sizeof s1) == 0);
+  A (memchr (&s1[0] + 1, 0, sizeof s1 - 1) == 0);
+  A (memchr (&s1[0] + i1, 0, sizeof s1 - i1) == 0);
+  A (memchr (&s1[0] + v1, 0, sizeof s1 - v1) == 0);
+
+  A (memchr (&s1[i0], 0, sizeof s1) == 0);
+  A (memchr (&s1[i0] + 1, 0, sizeof s1 - 1) == 0);
+  A (memchr (&s1[i0] + i1, 0, sizeof s1 - i1) == 0);
+  A (memchr (&s1[i0] + v1, 0, sizeof s1 - v1) == 0);
+
+  A (memchr (&s1[v0], 0, sizeof s1) == 0);
+  A (memchr (&s1[v0] + 1, 0, sizeof s1 - 1) == 0);
+  A (memchr (&s1[v0] + i1, 0, sizeof s1 - i1) == 0);
+  A (memchr (&s1[v0] + v1, 0, sizeof s1 - v1) == 0);
+
+
+  A (memchr (s4 + i0, 0, sizeof s4 - i0) == 0);
+  A (memchr (s4 + i1, 0, sizeof s4 - i1) == 0);
+  A (memchr (s4 + i2, 0, sizeof s4 - i2) == 0);
+  A (memchr (s4 + i3, 0, sizeof s4 - i3) == 0);
+  A (memchr (s4 + i4, 0, sizeof s4 - i4) == 0);
+
+  A (memchr (s4 + v0, 0, sizeof s4 - v0) == 0);
+  A (memchr (s4 + v1, 0, sizeof s4 - v1) == 0);
+  A (memchr (s4 + v2, 0, sizeof s4 - v2) == 0);
+  A (memchr (s4 + v3, 0, sizeof s4 - v3) == 0);
+  A (memchr (s4 + v4, 0, sizeof s4 - v4) == 0);
+
+
+  A (memchr (s4_2, 0, sizeof s4_2) == 0);
+
+  A (memchr (s4_2[0], 0, sizeof s4_2[0]) == 0);
+  A (memchr (s4_2[1], 0, sizeof s4_2[1]) == 0);
+
+  A (memchr (s4_2[0] + 1, 0, sizeof s4_2[0] - 1) == 0);
+  A (memchr (s4_2[1] + 2, 0, sizeof s4_2[1] - 2) == 0);
+  A (memchr (s4_2[1] + 3, 0, sizeof s4_2[1] - 3) == 0);
+
+  A (memchr (s4_2[v0], 0, sizeof s4_2[v0]) == 0);
+  A (memchr (s4_2[v0] + 1, 0, sizeof s4_2[v0] - 1) == 0);
+
+
+  /* The following calls must find the nul.  */
+  A (memchr ("", 0, 1) != 0);
+  A (memchr (s5_3, 0, sizeof s5_3) == &s5_3[1][4]);
+
+  A (memchr (&s5_3[0][0] + i0, 0, sizeof s5_3 - i0) == &s5_3[1][4]);
+  A (memchr (&s5_3[0][0] + i1, 0, sizeof s5_3 - i1) == &s5_3[1][4]);
+  A (memchr (&s5_3[0][0] + i2, 0, sizeof s5_3 - i2) == &s5_3[1][4]);
+  A (memchr (&s5_3[0][0] + i4, 0, sizeof s5_3 - i4) == &s5_3[1][4]);
+
+  A (memchr (&s5_3[1][i0], 0, sizeof s5_3[1] - i0) == &s5_3[1][4]);
+}
+
+#if 4 == __WCHAR_WIDTH__
+
+static const wchar_t wc = L'1';
+static const wchar_t ws1[] = L"1";
+static const wchar_t ws4[] = L"\x00123456\x12005678\x12340078\x12345600";
+
+void test_wide (void)
+{
+  int i0 = 0;
+  int i1 = i0 + 1;
+  int i2 = i1 + 1;
+  int i3 = i2 + 1;
+  int i4 = i3 + 1;
+
+  A (memchr (L"" + 1, 0, 0) == 0);
+  A (memchr (&wc + 1, 0, 0) == 0);
+  A (memchr (L"\x12345678", 0, sizeof (wchar_t)) == 0);
+
+  const size_t nb = sizeof ws4;
+  const size_t nwb = sizeof (wchar_t);
+
+  const char *pws1 = (const char*)ws1;
+  const char *pws4 = (const char*)ws4;
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+  A (memchr (ws1, 0, sizeof ws1) == pws1 + 1);
+
+  A (memchr (&ws4[0], 0, nb) == pws4 + 3);
+  A (memchr (&ws4[1], 0, nb - 1 * nwb) == pws4 + 1 * nwb + 2);
+  A (memchr (&ws4[2], 0, nb - 2 * nwb) == pws4 + 2 * nwb + 1);
+  A (memchr (&ws4[3], 0, nb - 3 * nwb) == pws4 + 3 * nwb + 0);
+#else
+  A (memchr (ws1, 0, sizeof ws1) == pws1 + 0);
+
+  A (memchr (&ws4[0], 0, nb) == pws4 + 0);
+  A (memchr (&ws4[1], 0, nb - 1 * nwb) == pws4 + 1 * nwb + 1);
+  A (memchr (&ws4[2], 0, nb - 2 * nwb) == pws4 + 2 * nwb + 2);
+  A (memchr (&ws4[3], 0, nb - 3 * nwb) == pws4 + 3 * nwb + 3);
+#endif
+}
+
+#elif 2 == __WCHAR_WIDTH__
+
+static const wchar_t wc = L'1';
+static const wchar_t ws1[] = L"1";
+static const wchar_t ws2[2] = L"\x1234\x5678";   /* no terminating nul */
+static const wchar_t ws4[] = L"\x0012\x1200\x1234";
+
+void test_wide (void)
+{
+  int i0 = 0;
+  int i1 = i0 + 1;
+  int i2 = i1 + 1;
+
+  A (sizeof (wchar_t) == 2);
+
+  A (memchr (L"" + 1, 0, 0) == 0);
+  A (memchr (&wc + 1, 0, 0) == 0);
+  A (memchr (L"\x1234", 0, sizeof (wchar_t)) == 0);
+
+  A (memchr (L"" + i1, i0, i0) == 0);
+  A (memchr (&wc + i1, i0, i0) == 0);
+  A (memchr (L"\x1234", i0, sizeof (wchar_t)) == 0);
+
+  A (memchr (ws2, 0, sizeof ws2) == 0);
+  A (memchr (ws2, i0, sizeof ws2) == 0);
+
+  const size_t nb = sizeof ws4;
+  const size_t nwb = sizeof (wchar_t);
+
+  const char *pws1 = (const char*)ws1;
+  const char *pws4 = (const char*)ws4;
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+  A (memchr (ws1, i0, sizeof ws1) == pws1 + 1);
+
+  A (memchr (&ws4[0], i0, nb) == pws4 + i1);
+  A (memchr (&ws4[1], i0, nb - i1 * nwb) == pws4 + i1 * nwb);
+  A (memchr (&ws4[2], i0, nb - i2 * nwb) == pws4 + i2 * nwb + i2);
+#else
+  A (memchr (ws1, i0, sizeof ws1) == pws1 + 0);
+
+  A (memchr (&ws4[0], i0, nb) == pws4 + 0);
+  A (memchr (&ws4[1], i0, nb - i1 * nwb) == pws4 + i1 * nwb + i1);
+  A (memchr (&ws4[2], i0, nb - i2 * nwb) == pws4 + i2 * nwb + i2);
+#endif
+}
+
+#else
+
+void test_wide (void) { }
+
+#endif
+
+int main ()
+{
+  test_narrow ();
+  test_wide ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00403-g.torture.execute-memchr-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00403-g.torture.execute-memchr-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..989fb7d1696a3558b70398d71a29fac26871844d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00403-g.torture.execute-memchr-1/test.cfg
@@ -0,0 +1,2 @@
+compile(memchr-1)
+run(memchr-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00404-g.torture.execute-memcpy-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00404-g.torture.execute-memcpy-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00404-g.torture.execute-memcpy-1/memcpy-1.c b/testsuite/c_test/x64_be_enable_test/GCC00404-g.torture.execute-memcpy-1/memcpy-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..558c9370abb9aae09773381b3d6bafe7661f2daf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00404-g.torture.execute-memcpy-1/memcpy-1.c
@@ -0,0 +1,65 @@
+/* { dg-add-options stack_size } */
+
+#include <string.h>
+
+#if defined (STACK_SIZE)
+#define MEMCPY_SIZE (STACK_SIZE / 3)
+#else
+#define MEMCPY_SIZE (1 << 17)
+#endif
+
+
+void *copy (void *o, const void *i, unsigned l)
+{
+  return memcpy (o, i, l);
+}
+
+main ()
+{
+  unsigned i;
+  unsigned char src[MEMCPY_SIZE];
+  unsigned char dst[MEMCPY_SIZE];
+
+  for (i = 0; i < MEMCPY_SIZE; i++)
+    src[i] = (unsigned char) i,  dst[i] = 0;
+
+  (void) memcpy (dst, src, MEMCPY_SIZE / 128);
+
+  for (i = 0; i < MEMCPY_SIZE / 128; i++)
+    if (dst[i] != (unsigned char) i)
+      abort ();
+
+  (void) memset (dst, 1, MEMCPY_SIZE / 128);
+
+  for (i = 0; i < MEMCPY_SIZE / 128; i++)
+    if (dst[i] != 1)
+      abort ();
+
+  (void) memcpy (dst, src, MEMCPY_SIZE);
+
+  for (i = 0; i < MEMCPY_SIZE; i++)
+    if (dst[i] != (unsigned char) i)
+      abort ();
+
+  (void) memset (dst, 0, MEMCPY_SIZE);
+
+  for (i = 0; i < MEMCPY_SIZE; i++)
+    if (dst[i] != 0)
+      abort ();
+
+  (void) copy (dst, src, MEMCPY_SIZE / 128);
+
+  for (i = 0; i < MEMCPY_SIZE / 128; i++)
+    if (dst[i] != (unsigned char) i)
+      abort ();
+
+  (void) memset (dst, 0, MEMCPY_SIZE);
+
+  (void) copy (dst, src, MEMCPY_SIZE);
+
+  for (i = 0; i < MEMCPY_SIZE; i++)
+    if (dst[i] != (unsigned char) i)
+      abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00404-g.torture.execute-memcpy-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00404-g.torture.execute-memcpy-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b66bbfbf7b2584a245c37b7cd4233280239b4cb6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00404-g.torture.execute-memcpy-1/test.cfg
@@ -0,0 +1,2 @@
+compile(memcpy-1)
+run(memcpy-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00405-g.torture.execute-nestfunc-4/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00405-g.torture.execute-nestfunc-4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00405-g.torture.execute-nestfunc-4/nestfunc-4.c b/testsuite/c_test/x64_be_enable_test/GCC00405-g.torture.execute-nestfunc-4/nestfunc-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..c7225700709f3112c50c3afaf790ca960bb75c66
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00405-g.torture.execute-nestfunc-4/nestfunc-4.c
@@ -0,0 +1,39 @@
+/* { dg-add-options stack_size } */
+
+/* Origin: hp@bitrange.com
+   Test that return values come out right from a 1000-level call chain to
+   functions without parameters that each need at least one "long"
+   preserved.  Exposed problems related to the MMIX port.  */
+
+long level = 0;
+extern long foo (void);
+extern long bar (void);
+
+#ifdef STACK_SIZE
+#define DEPTH ((STACK_SIZE) / 512 + 1)
+#else
+#define DEPTH 500
+#endif
+
+int
+main (void)
+{
+  if (foo () == -42)
+    exit (0);
+
+  abort ();
+}
+
+long
+foo (void)
+{
+  long tmp = ++level;
+  return bar () + tmp;
+}
+
+long
+bar (void)
+{
+  long tmp = level;
+  return tmp > DEPTH - 1 ? -42 - tmp : foo () - tmp;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00405-g.torture.execute-nestfunc-4/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00405-g.torture.execute-nestfunc-4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fd02dcd83375c720e0c604978959886c81e30a61
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00405-g.torture.execute-nestfunc-4/test.cfg
@@ -0,0 +1,2 @@
+compile(nestfunc-4)
+run(nestfunc-4)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00406-g.torture.execute-p18298/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00406-g.torture.execute-p18298/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00406-g.torture.execute-p18298/p18298.c b/testsuite/c_test/x64_be_enable_test/GCC00406-g.torture.execute-p18298/p18298.c
new file mode 100644
index 0000000000000000000000000000000000000000..50589962e229059a03d5540b919eb96ab8d6a0d8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00406-g.torture.execute-p18298/p18298.c
@@ -0,0 +1,21 @@
+/* { dg-options "-fgnu89-inline" } */
+
+#include <stdbool.h>
+#include <stdlib.h>
+extern void abort (void);
+int strcmp (const char*, const char*);
+char s[2048] = "a";
+inline bool foo(const char *str) {
+  return !strcmp(s,str);
+}
+int main() {
+int i = 0;
+  while(!(foo(""))) {
+    i ++;
+    s[0] = '\0';
+    if (i>2)
+     abort ();
+  }
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00406-g.torture.execute-p18298/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00406-g.torture.execute-p18298/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e1d9bb3b0fb91dbc7ee55adbe3f1af714e1b171
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00406-g.torture.execute-p18298/test.cfg
@@ -0,0 +1,2 @@
+compile(p18298)
+run(p18298)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00407-g.torture.execute-packed-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00407-g.torture.execute-packed-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00407-g.torture.execute-packed-2/packed-2.c b/testsuite/c_test/x64_be_enable_test/GCC00407-g.torture.execute-packed-2/packed-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c579008849c6c63694a71c55208be761d495b62
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00407-g.torture.execute-packed-2/packed-2.c
@@ -0,0 +1,12 @@
+typedef struct s {
+	unsigned short a;
+	unsigned long b __attribute__ ((packed));
+} s;
+
+s t;
+
+int main()
+{
+        t.b = 0;
+	return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00407-g.torture.execute-packed-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00407-g.torture.execute-packed-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..07378a77ee7ac50bf6f2f14f34f87fed482247c1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00407-g.torture.execute-packed-2/test.cfg
@@ -0,0 +1,2 @@
+compile(packed-2)
+run(packed-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00408-g.torture.execute-pr17078-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00408-g.torture.execute-pr17078-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00408-g.torture.execute-pr17078-1/pr17078-1.c b/testsuite/c_test/x64_be_enable_test/GCC00408-g.torture.execute-pr17078-1/pr17078-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9380bf48593ee2991723b6752284545c2bdd5eb0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00408-g.torture.execute-pr17078-1/pr17078-1.c
@@ -0,0 +1,25 @@
+extern void abort(void);
+
+void test(int *ptr)
+{
+  int i = 1;
+  goto useless;
+  if (0)
+    {
+      useless:
+      i = 0;
+    }
+  else
+    i = 1;
+  *ptr = i;
+}
+
+int main()
+{
+  int i = 1;
+  test(&i);
+  if (i)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00408-g.torture.execute-pr17078-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00408-g.torture.execute-pr17078-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aaef6ca7e53b79f120d3892028ed2b4c05c9ba07
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00408-g.torture.execute-pr17078-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr17078-1)
+run(pr17078-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00409-g.torture.execute-pr17133/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00409-g.torture.execute-pr17133/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00409-g.torture.execute-pr17133/pr17133.c b/testsuite/c_test/x64_be_enable_test/GCC00409-g.torture.execute-pr17133/pr17133.c
new file mode 100644
index 0000000000000000000000000000000000000000..63352c07ac18af348dbfdbaade0be2e2fc5983ef
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00409-g.torture.execute-pr17133/pr17133.c
@@ -0,0 +1,27 @@
+extern void abort (void);
+
+int foo = 0;
+void *bar = 0;
+unsigned int baz = 100;
+
+void *pure_alloc ()
+{
+  void *res;
+  
+  while (1)
+    {
+      res = (void *) ((((unsigned int) (foo + bar))) & ~1);
+      foo += 2;
+      if (foo < baz)
+        return res;
+      foo = 0;
+    }
+}
+
+int main ()
+{
+  pure_alloc ();
+  if (!foo)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00409-g.torture.execute-pr17133/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00409-g.torture.execute-pr17133/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..20322cb54cb01648ac7281e9eba37e7fdca004dd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00409-g.torture.execute-pr17133/test.cfg
@@ -0,0 +1,2 @@
+compile(pr17133)
+run(pr17133)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00410-g.torture.execute-pr17252/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00410-g.torture.execute-pr17252/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00410-g.torture.execute-pr17252/pr17252.c b/testsuite/c_test/x64_be_enable_test/GCC00410-g.torture.execute-pr17252/pr17252.c
new file mode 100644
index 0000000000000000000000000000000000000000..bd1b6b99e982781721a6592beba0a231fe017cae
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00410-g.torture.execute-pr17252/pr17252.c
@@ -0,0 +1,21 @@
+/* PR 17252.  When a char * pointer P takes its own address, storing
+   into *P changes P itself.  */
+
+char *a;
+
+main ()
+{
+  /* Make 'a' point to itself.  */
+  a = (char *)&a;
+
+  /* Change what 'a' is pointing to.  */
+  a[0]++;
+
+  /* If a's memory tag does not contain 'a' in its alias set, we will
+     think that this predicate is superfluous and change it to
+     'if (1)'.  */
+  if (a == (char *)&a)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00410-g.torture.execute-pr17252/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00410-g.torture.execute-pr17252/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5cb1845dd5f94a7aa20ed40e6ef5fa6548b3d0d9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00410-g.torture.execute-pr17252/test.cfg
@@ -0,0 +1,2 @@
+compile(pr17252)
+run(pr17252)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00411-g.torture.execute-pr19005/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00411-g.torture.execute-pr19005/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00411-g.torture.execute-pr19005/pr19005.c b/testsuite/c_test/x64_be_enable_test/GCC00411-g.torture.execute-pr19005/pr19005.c
new file mode 100644
index 0000000000000000000000000000000000000000..0397424c7332698f7dc8baff0fd5e188085c622d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00411-g.torture.execute-pr19005/pr19005.c
@@ -0,0 +1,32 @@
+/* PR target/19005 */
+extern void abort(void);
+
+int v, s;
+
+void bar(int a, int b) {
+  unsigned char x = v;
+
+  if (!s) {
+    if (a != x || b != (unsigned char)(x + 1))
+      abort();
+  } else if (a != (unsigned char)(x + 1) || b != x)
+    abort();
+  s ^= 1;
+}
+
+int foo(int x) {
+  unsigned char a = x, b = x + 1;
+
+  bar(a, b);
+  a ^= b;
+  b ^= a;
+  a ^= b;
+  bar(a, b);
+  return 0;
+}
+
+int main(void) {
+  for (v = -10; v < 266; v++)
+    foo(v);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00411-g.torture.execute-pr19005/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00411-g.torture.execute-pr19005/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a9510e95f55eb649c6a88cc031fa4e80dec1798
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00411-g.torture.execute-pr19005/test.cfg
@@ -0,0 +1,2 @@
+compile(pr19005)
+run(pr19005)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00412-g.torture.execute-pr19449/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00412-g.torture.execute-pr19449/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00412-g.torture.execute-pr19449/pr19449.c b/testsuite/c_test/x64_be_enable_test/GCC00412-g.torture.execute-pr19449/pr19449.c
new file mode 100644
index 0000000000000000000000000000000000000000..63cc2e74e190ee73c847b7750864d5182d5feb5c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00412-g.torture.execute-pr19449/pr19449.c
@@ -0,0 +1,20 @@
+/* PR c/19449 */
+
+extern void abort (void);
+
+int y;
+int z = __builtin_choose_expr (!__builtin_constant_p (y), 3, 4);
+
+int
+foo (int x)
+{
+  return __builtin_choose_expr (!__builtin_constant_p (x), 3, y++);
+}
+
+int
+main ()
+{
+  if (y || z != 3 || foo (4) != 3)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00412-g.torture.execute-pr19449/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00412-g.torture.execute-pr19449/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5ccfabdfa59bbb9b4bedb3ac03faeeb217a5f224
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00412-g.torture.execute-pr19449/test.cfg
@@ -0,0 +1,2 @@
+compile(pr19449)
+run(pr19449)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00413-g.torture.execute-pr20527-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00413-g.torture.execute-pr20527-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00413-g.torture.execute-pr20527-1/pr20527-1.c b/testsuite/c_test/x64_be_enable_test/GCC00413-g.torture.execute-pr20527-1/pr20527-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..81162dfebb44234ca934b85fa142852cb1813abd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00413-g.torture.execute-pr20527-1/pr20527-1.c
@@ -0,0 +1,81 @@
+/* PR rtl-optimization/20527
+   Mishandled postincrement.  This test-case is derived from the
+   function BZ2_hbCreateDecodeTables in the file huffman.c from
+   bzip2-1.0.2, hence requiring the following disclaimer copied here:  */
+
+/*--
+  This file is a part of bzip2 and/or libbzip2, a program and
+  library for lossless, block-sorting data compression.
+
+  Copyright (C) 1996-2002 Julian R Seward.  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+  2. The origin of this software must not be misrepresented; you must 
+     not claim that you wrote the original software.  If you use this 
+     software in a product, an acknowledgment in the product 
+     documentation would be appreciated but is not required.
+
+  3. Altered source versions must be plainly marked as such, and must
+     not be misrepresented as being the original software.
+
+  4. The name of the author may not be used to endorse or promote 
+     products derived from this software without specific prior written 
+     permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  Julian Seward, Cambridge, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 1.0 of 21 March 2000
+
+  This program is based on (at least) the work of:
+     Mike Burrows
+     David Wheeler
+     Peter Fenwick
+     Alistair Moffat
+     Radford Neal
+     Ian H. Witten
+     Robert Sedgewick
+     Jon L. Bentley
+
+  For more information on these sources, see the manual.
+--*/
+
+void f (long *limit, long *base, long minLen, long maxLen) __attribute__ ((__noinline__));
+void f (long *limit, long *base, long minLen, long maxLen)
+{
+  long i;
+  long vec;
+  vec = 0;
+  for (i = minLen; i <= maxLen; i++) {
+    vec += (base[i+1] - base[i]);
+    limit[i] = vec-1;
+  }
+}
+extern void abort (void);
+extern void exit (int);
+long b[] = {1, 5, 11, 23};
+int main (void)
+{
+  long l[3];
+  f (l, b, 0, 2);
+  if (l[0] != 3 || l[1] != 9 || l[2] != 21)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00413-g.torture.execute-pr20527-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00413-g.torture.execute-pr20527-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e0948196330f8fadb48fcc77d0a5f6a1ca93067f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00413-g.torture.execute-pr20527-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr20527-1)
+run(pr20527-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00414-g.torture.execute-pr21173/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00414-g.torture.execute-pr21173/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00414-g.torture.execute-pr21173/pr21173.c b/testsuite/c_test/x64_be_enable_test/GCC00414-g.torture.execute-pr21173/pr21173.c
new file mode 100644
index 0000000000000000000000000000000000000000..61459bca7e56c84b0a2b23813e7e70536b00dbf2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00414-g.torture.execute-pr21173/pr21173.c
@@ -0,0 +1,21 @@
+void abort (void);
+
+char q;
+void *a[2];
+
+void foo (char *p)
+{
+  int i;
+  for (i = 0; i < 2; i++)
+    a[i] += p - &q;
+}
+
+int main (void)
+{
+  int i;
+  foo (&q);
+  for (i = 0; i < 2; i ++)
+    if (a[i])
+      abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00414-g.torture.execute-pr21173/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00414-g.torture.execute-pr21173/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ac29fc1b13bb5fae43b18d10434bf10b0a8aefec
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00414-g.torture.execute-pr21173/test.cfg
@@ -0,0 +1,2 @@
+compile(pr21173)
+run(pr21173)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00415-g.torture.execute-pr22098-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00415-g.torture.execute-pr22098-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00415-g.torture.execute-pr22098-3/pr22098-3.c b/testsuite/c_test/x64_be_enable_test/GCC00415-g.torture.execute-pr22098-3/pr22098-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..4f37be86c8c966fd4489f1b02521c67839c37038
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00415-g.torture.execute-pr22098-3/pr22098-3.c
@@ -0,0 +1,16 @@
+extern void abort (void);
+extern void exit (int);
+typedef __UINTPTR_TYPE__ uintptr_t;
+int n = 0;
+int f (void) { return ++n; }
+int
+main (void)
+{
+  int a = 0;
+  int *p;
+  uintptr_t b;
+  b = (uintptr_t)(p = &(int []){0, f(), 2}[1]);
+  if (*p != 1 || *(int *)b != 1 || n != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00415-g.torture.execute-pr22098-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00415-g.torture.execute-pr22098-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1aaab2f82cdf7cf30911ff2c8b8d392fb51c2819
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00415-g.torture.execute-pr22098-3/test.cfg
@@ -0,0 +1,2 @@
+compile(pr22098-3)
+run(pr22098-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00416-g.torture.execute-pr22429/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00416-g.torture.execute-pr22429/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00416-g.torture.execute-pr22429/pr22429.c b/testsuite/c_test/x64_be_enable_test/GCC00416-g.torture.execute-pr22429/pr22429.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa55b6e88acc6fdbbf7520aaf39cbc402b9aa219
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00416-g.torture.execute-pr22429/pr22429.c
@@ -0,0 +1,17 @@
+extern void abort (void);
+
+#define N	(1 << (sizeof(int) * __CHAR_BIT__ - 2))
+
+int f(int n)
+{
+  if (-N <= n && n <= N-1)
+    return 1;
+  return 0;
+}
+
+int main ()
+{
+  if (f (N))
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00416-g.torture.execute-pr22429/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00416-g.torture.execute-pr22429/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1968b481af2db43adc4a7b59119b5a26f0597f58
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00416-g.torture.execute-pr22429/test.cfg
@@ -0,0 +1,2 @@
+compile(pr22429)
+run(pr22429)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00417-g.torture.execute-pr22630/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00417-g.torture.execute-pr22630/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00417-g.torture.execute-pr22630/pr22630.c b/testsuite/c_test/x64_be_enable_test/GCC00417-g.torture.execute-pr22630/pr22630.c
new file mode 100644
index 0000000000000000000000000000000000000000..d3a564999ba795af3f197b662b1b3875327c7d98
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00417-g.torture.execute-pr22630/pr22630.c
@@ -0,0 +1,23 @@
+void abort (void);
+
+int j;
+
+void bla (int *r)
+{
+  int *p, *q;
+
+  p = q = r;
+  if (!p)
+    p = &j;
+  
+  if (p != q)
+    j = 1;
+}
+
+int main (void)
+{
+  bla (0);
+  if (!j)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00417-g.torture.execute-pr22630/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00417-g.torture.execute-pr22630/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..626b1f68723938e9410d78a092b241c335756e1c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00417-g.torture.execute-pr22630/test.cfg
@@ -0,0 +1,2 @@
+compile(pr22630)
+run(pr22630)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00418-g.torture.execute-pr23467/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00418-g.torture.execute-pr23467/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00418-g.torture.execute-pr23467/pr23467.c b/testsuite/c_test/x64_be_enable_test/GCC00418-g.torture.execute-pr23467/pr23467.c
new file mode 100644
index 0000000000000000000000000000000000000000..97a5af7780f0863ec777a8e20225f3a0043029d0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00418-g.torture.execute-pr23467/pr23467.c
@@ -0,0 +1,20 @@
+/* { dg-skip-if "small alignment" { pdp11-*-* } } */
+
+struct s1
+{
+  int __attribute__ ((aligned (8))) a;
+};
+
+struct
+{
+  char c;
+  struct s1 m;
+} v;
+
+int
+main (void)
+{
+  if ((int)&v.m & 7)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00418-g.torture.execute-pr23467/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00418-g.torture.execute-pr23467/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9d637a4337aaf60bd0755fa94acd556be38590f6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00418-g.torture.execute-pr23467/test.cfg
@@ -0,0 +1,2 @@
+compile(pr23467)
+run(pr23467)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00419-g.torture.execute-pr23604/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00419-g.torture.execute-pr23604/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00419-g.torture.execute-pr23604/pr23604.c b/testsuite/c_test/x64_be_enable_test/GCC00419-g.torture.execute-pr23604/pr23604.c
new file mode 100644
index 0000000000000000000000000000000000000000..4c2b80d56ca8d51cd7f730df585463cf4311aa30
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00419-g.torture.execute-pr23604/pr23604.c
@@ -0,0 +1,22 @@
+extern void abort (void);
+
+int g(int i, int j)
+{
+  if (i>-1)
+    if (i<2)
+     {
+        if (i != j)
+          {
+            if (j != 0)
+                return 0;
+          }
+     }
+  return 1;
+}
+
+int main(void)
+{
+  if (!g(1, 0))
+   abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00419-g.torture.execute-pr23604/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00419-g.torture.execute-pr23604/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bed263e5b051f27d9210fd7d84166277a1fb27e3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00419-g.torture.execute-pr23604/test.cfg
@@ -0,0 +1,2 @@
+compile(pr23604)
+run(pr23604)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00420-g.torture.execute-pr24141/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00420-g.torture.execute-pr24141/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00420-g.torture.execute-pr24141/pr24141.c b/testsuite/c_test/x64_be_enable_test/GCC00420-g.torture.execute-pr24141/pr24141.c
new file mode 100644
index 0000000000000000000000000000000000000000..301296206cb5e5b7babb41be75b7684d332e6c03
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00420-g.torture.execute-pr24141/pr24141.c
@@ -0,0 +1,33 @@
+// reduced testcase, compile with -O2. Also, with --disable-checking
+// gcc produces wrong code.
+
+void abort (void);
+int i;
+
+void g (void)
+{
+  i = 1;
+}
+
+void f (int a, int b)
+{
+  int c = 0;
+  if (a == 0)
+    c = 1;
+  if (c)
+    return;
+  if (c == 1)
+    c = 0;
+  if (b == 0)
+    c = 1;
+  if (c)
+    g ();
+}
+
+int main (void)
+{
+  f (1, 0);
+  if (i != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00420-g.torture.execute-pr24141/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00420-g.torture.execute-pr24141/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..04bc74e6697995724dad49969378e14d4e487061
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00420-g.torture.execute-pr24141/test.cfg
@@ -0,0 +1,2 @@
+compile(pr24141)
+run(pr24141)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00421-g.torture.execute-pr24142/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00421-g.torture.execute-pr24142/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00421-g.torture.execute-pr24142/pr24142.c b/testsuite/c_test/x64_be_enable_test/GCC00421-g.torture.execute-pr24142/pr24142.c
new file mode 100644
index 0000000000000000000000000000000000000000..eed3e8bc67934079f3423ba334d7e1002661f580
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00421-g.torture.execute-pr24142/pr24142.c
@@ -0,0 +1,19 @@
+void abort (void);
+
+int f (int a, int b)
+{
+  if (a == 1)
+    a = 0;
+  if (b == 0)
+    a = 1;
+  if (a != 0)
+    return 0;
+  return 1;
+}
+
+int main (void)
+{
+  if (f (1, 1) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00421-g.torture.execute-pr24142/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00421-g.torture.execute-pr24142/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1232af52292887d4a93e9953b7faa0fa6d7af431
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00421-g.torture.execute-pr24142/test.cfg
@@ -0,0 +1,2 @@
+compile(pr24142)
+run(pr24142)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00422-g.torture.execute-pr24716/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00422-g.torture.execute-pr24716/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00422-g.torture.execute-pr24716/pr24716.c b/testsuite/c_test/x64_be_enable_test/GCC00422-g.torture.execute-pr24716/pr24716.c
new file mode 100644
index 0000000000000000000000000000000000000000..c2473f84c3155c581b86f0e21ab9f37873d8e96a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00422-g.torture.execute-pr24716/pr24716.c
@@ -0,0 +1,59 @@
+/* PR24716, scalar evolution returning the wrong result
+   for pdest.  */
+
+int Link[] = { -1 };
+int W[] = { 2 };
+
+extern void abort (void);
+
+int f (int k, int p)
+{
+  int pdest, j, D1361;
+  j = 0;
+  pdest = 0;
+  for (;;) {
+    if (pdest > 2)
+      do
+        j--, pdest++;
+      while (j > 2);
+
+    if (j == 1)
+      break;
+
+    while (pdest > p)
+      if (j == p)
+        pdest++;
+
+    do
+      {
+        D1361 = W[k];
+        do
+          if (D1361 != 0)
+            pdest = 1, W[k] = D1361 = 0;
+        while (p < 1);
+    } while (k > 0);
+
+    do
+      {
+        p = 0;
+        k = Link[k];
+        while (p < j)
+          if (k != -1)
+            pdest++, p++;
+      }
+    while (k != -1);
+    j = 1;
+  }
+
+  /* The correct return value should be pdest (1 in the call from main).
+     DOM3 is mistaken and propagates a 0 here.  */
+  return pdest;
+}
+
+int main ()
+{
+  if (!f (0, 2))
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00422-g.torture.execute-pr24716/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00422-g.torture.execute-pr24716/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0e644445c55ea1a067905c3d5ddbc6ae268995db
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00422-g.torture.execute-pr24716/test.cfg
@@ -0,0 +1,2 @@
+compile(pr24716)
+run(pr24716)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00423-g.torture.execute-pr25737/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00423-g.torture.execute-pr25737/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00423-g.torture.execute-pr25737/pr25737.c b/testsuite/c_test/x64_be_enable_test/GCC00423-g.torture.execute-pr25737/pr25737.c
new file mode 100644
index 0000000000000000000000000000000000000000..9da63adceab56829ac2553cf2ab3d3daae74d841
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00423-g.torture.execute-pr25737/pr25737.c
@@ -0,0 +1,23 @@
+extern void abort (void);
+
+struct delay_block {
+  struct delay_block *succ;
+};
+
+static struct delay_block Timer_Queue;
+
+struct delay_block* time_enqueue (struct delay_block *d)
+{
+  struct delay_block *q = Timer_Queue.succ; 
+  d->succ =  (void *)0;
+  return Timer_Queue.succ;
+}
+
+int main(void)
+{
+  Timer_Queue.succ = &Timer_Queue;
+  if (time_enqueue (&Timer_Queue) != (void*)0)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00423-g.torture.execute-pr25737/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00423-g.torture.execute-pr25737/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e2dc735f3f9fd431ec4da870e044b86700fde905
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00423-g.torture.execute-pr25737/test.cfg
@@ -0,0 +1,2 @@
+compile(pr25737)
+run(pr25737)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00424-g.torture.execute-pr27671-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00424-g.torture.execute-pr27671-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00424-g.torture.execute-pr27671-1/pr27671-1.c b/testsuite/c_test/x64_be_enable_test/GCC00424-g.torture.execute-pr27671-1/pr27671-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd2982cc843da958f03b37694897a0ea4b6d3f34
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00424-g.torture.execute-pr27671-1/pr27671-1.c
@@ -0,0 +1,21 @@
+/* PR rtl-optimization/27671.
+   The combiner used to simplify "a ^ b == a" to "a" via
+   simplify_relational_operation_1 in simplify-rtx.c.  */
+
+extern void abort (void) __attribute__ ((noreturn));
+extern void exit (int) __attribute__ ((noreturn));
+
+static int __attribute__((noinline))
+foo (int a, int b)
+{
+  int c = a ^ b;
+  if (c == a)
+    abort ();
+}
+
+int
+main (void)
+{
+  foo (0, 1);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00424-g.torture.execute-pr27671-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00424-g.torture.execute-pr27671-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c2b81baf1fe5fdf853c621e417e8122937afffdb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00424-g.torture.execute-pr27671-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr27671-1)
+run(pr27671-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00425-g.torture.execute-pr28289/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00425-g.torture.execute-pr28289/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00425-g.torture.execute-pr28289/pr28289.c b/testsuite/c_test/x64_be_enable_test/GCC00425-g.torture.execute-pr28289/pr28289.c
new file mode 100644
index 0000000000000000000000000000000000000000..93e922cbb1fa7c7bb750ff61a5528129fcec207c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00425-g.torture.execute-pr28289/pr28289.c
@@ -0,0 +1,33 @@
+extern int ok (int);
+extern void exit ();
+static int gen_x86_64_shrd (int);
+static int
+gen_x86_64_shrd(int a __attribute__ ((__unused__)))
+{
+  return 0;
+}
+
+extern int gen_x86_shrd_1 (int);
+extern void ix86_split_ashr (int);
+
+void
+ix86_split_ashr (int mode)
+{
+          (mode != 0
+                      ? ok
+                      : gen_x86_64_shrd) (0);
+}
+
+volatile int one = 1;
+int
+main (void)
+{
+  ix86_split_ashr (one);
+  return 1;
+}
+
+int
+ok (int i)
+{
+  exit (i);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00425-g.torture.execute-pr28289/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00425-g.torture.execute-pr28289/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6ac7f0ba95e826f5c7ea013b8b2c9db974feb4c0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00425-g.torture.execute-pr28289/test.cfg
@@ -0,0 +1,2 @@
+compile(pr28289)
+run(pr28289)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00426-g.torture.execute-pr28403/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00426-g.torture.execute-pr28403/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00426-g.torture.execute-pr28403/pr28403.c b/testsuite/c_test/x64_be_enable_test/GCC00426-g.torture.execute-pr28403/pr28403.c
new file mode 100644
index 0000000000000000000000000000000000000000..26d16dd0dd29c4a44d722d3800eba0a7a724d911
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00426-g.torture.execute-pr28403/pr28403.c
@@ -0,0 +1,17 @@
+typedef unsigned long long ull;
+int global;
+
+int __attribute__((noinline)) foo(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8) {
+  global = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8;
+}
+
+ull __attribute__((noinline)) bar(ull x) {
+  foo(1, 2, 1, 3, 1, 4, 1, 5);
+  return x >> global;
+}
+
+int main(void) {
+  if (bar(0x123456789abcdefULL) != (0x123456789abcdefULL >> 18))
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00426-g.torture.execute-pr28403/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00426-g.torture.execute-pr28403/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c2688c4a4b118983d6357de7921adf352ecbdfe9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00426-g.torture.execute-pr28403/test.cfg
@@ -0,0 +1,2 @@
+compile(pr28403)
+run(pr28403)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00427-g.torture.execute-pr28651/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00427-g.torture.execute-pr28651/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00427-g.torture.execute-pr28651/pr28651.c b/testsuite/c_test/x64_be_enable_test/GCC00427-g.torture.execute-pr28651/pr28651.c
new file mode 100644
index 0000000000000000000000000000000000000000..74656fd01ff58c004bbf4a466f2024dbe08c9c66
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00427-g.torture.execute-pr28651/pr28651.c
@@ -0,0 +1,19 @@
+#include <limits.h>
+
+extern void abort (void);
+int __attribute__((noinline))
+foo (unsigned int u)
+{
+  return (int)(u + 4) < (int)u;
+}
+
+int
+main (int argc, char *argv[])
+{
+  unsigned int u = INT_MAX;
+
+  if (foo (u) == 0)
+    abort();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00427-g.torture.execute-pr28651/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00427-g.torture.execute-pr28651/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..839585ce3eb93b754f8bc5a23338187f70ac0b81
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00427-g.torture.execute-pr28651/test.cfg
@@ -0,0 +1,2 @@
+compile(pr28651)
+run(pr28651)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00428-g.torture.execute-pr29006/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00428-g.torture.execute-pr29006/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00428-g.torture.execute-pr29006/pr29006.c b/testsuite/c_test/x64_be_enable_test/GCC00428-g.torture.execute-pr29006/pr29006.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d1f1388465de74b75016f629c70aef188aadc4c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00428-g.torture.execute-pr29006/pr29006.c
@@ -0,0 +1,3 @@
+struct __attribute__((__packed__)) s { char c; unsigned long long x; };
+void __attribute__((__noinline__)) foo (struct s *s) { s->x = 0; }
+int main (void) { struct s s = { 1, ~0ULL }; foo (&s); return s.x != 0; }
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00428-g.torture.execute-pr29006/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00428-g.torture.execute-pr29006/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5ae8a668a3a31303228f7b64d09f313d7acdd1c8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00428-g.torture.execute-pr29006/test.cfg
@@ -0,0 +1,2 @@
+compile(pr29006)
+run(pr29006)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00429-g.torture.execute-pr29156/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00429-g.torture.execute-pr29156/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00429-g.torture.execute-pr29156/pr29156.c b/testsuite/c_test/x64_be_enable_test/GCC00429-g.torture.execute-pr29156/pr29156.c
new file mode 100644
index 0000000000000000000000000000000000000000..20f5f9979c56041d3f4398db0e8624534a21496c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00429-g.torture.execute-pr29156/pr29156.c
@@ -0,0 +1,32 @@
+extern void abort(void);
+struct test1
+{
+  int a;
+  int b;
+};
+struct test2
+{
+  float d;
+  struct test1 sub;
+};
+
+int global;
+
+int bla(struct test1 *xa, struct test2 *xb)
+{
+  global = 1;
+  xb->sub.a = 1;
+  xa->a = 8;
+  return xb->sub.a;
+}
+
+int main(void)
+{
+  struct test2 pom;
+
+  if (bla (&pom.sub, &pom) != 8)
+    abort ();
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00429-g.torture.execute-pr29156/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00429-g.torture.execute-pr29156/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aaa45c90a3b68a0817d51276b03f5aaa908cc29a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00429-g.torture.execute-pr29156/test.cfg
@@ -0,0 +1,2 @@
+compile(pr29156)
+run(pr29156)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00430-g.torture.execute-pr29695-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00430-g.torture.execute-pr29695-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00430-g.torture.execute-pr29695-1/pr29695-1.c b/testsuite/c_test/x64_be_enable_test/GCC00430-g.torture.execute-pr29695-1/pr29695-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9ecb3142509d218aa49d7d1b4bdad85db2e5757c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00430-g.torture.execute-pr29695-1/pr29695-1.c
@@ -0,0 +1,83 @@
+/* PR middle-end/29695 */
+
+extern void abort (void);
+
+int
+f1 (void)
+{
+  int a = 128;
+  return (a & 0x80) ? 0x80 : 0;
+}
+
+int
+f2 (void)
+{
+  unsigned char a = 128;
+  return (a & 0x80) ? 0x80 : 0;
+}
+
+int
+f3 (void)
+{
+  unsigned char a = 128;
+  return (a & 0x80) ? 0x380 : 0;
+}
+
+int
+f4 (void)
+{
+  unsigned char a = 128;
+  return (a & 0x80) ? -128 : 0;
+}
+
+long long
+f5 (void)
+{
+  long long a = 0x80000000LL;
+  return (a & 0x80000000) ? 0x80000000LL : 0LL;
+}
+
+long long
+f6 (void)
+{
+  unsigned int a = 0x80000000;
+  return (a & 0x80000000) ? 0x80000000LL : 0LL;
+}
+
+long long
+f7 (void)
+{
+  unsigned int a = 0x80000000;
+  return (a & 0x80000000) ? 0x380000000LL : 0LL;
+}
+
+long long
+f8 (void)
+{
+  unsigned int a = 0x80000000;
+  return (a & 0x80000000) ? -2147483648LL : 0LL;
+}
+
+int
+main (void)
+{
+  if ((char) 128 != -128 || (int) 0x80000000 != -2147483648)
+    return 0;
+  if (f1 () != 128)
+    abort ();
+  if (f2 () != 128)
+    abort ();
+  if (f3 () != 896)
+    abort ();
+  if (f4 () != -128)
+    abort ();
+  if (f5 () != 0x80000000LL)
+    abort ();
+  if (f6 () != 0x80000000LL)
+    abort ();
+  if (f7 () != 0x380000000LL)
+    abort ();
+  if (f8 () != -2147483648LL)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00430-g.torture.execute-pr29695-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00430-g.torture.execute-pr29695-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..21f98135eebd03d83f7dcc37c00fe9945efe87c4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00430-g.torture.execute-pr29695-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr29695-1)
+run(pr29695-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00431-g.torture.execute-pr29695-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00431-g.torture.execute-pr29695-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00431-g.torture.execute-pr29695-2/pr29695-2.c b/testsuite/c_test/x64_be_enable_test/GCC00431-g.torture.execute-pr29695-2/pr29695-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..339428e32792b3d6803e6da7eb3a37e5ba857731
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00431-g.torture.execute-pr29695-2/pr29695-2.c
@@ -0,0 +1,80 @@
+/* PR middle-end/29695 */
+
+extern void abort (void);
+
+int a = 128;
+unsigned char b = 128;
+long long c = 0x80000000LL;
+unsigned int d = 0x80000000;
+
+int
+f1 (void)
+{
+  return (a & 0x80) ? 0x80 : 0;
+}
+
+int
+f2 (void)
+{
+  return (b & 0x80) ? 0x80 : 0;
+}
+
+int
+f3 (void)
+{
+  return (b & 0x80) ? 0x380 : 0;
+}
+
+int
+f4 (void)
+{
+  return (b & 0x80) ? -128 : 0;
+}
+
+long long
+f5 (void)
+{
+  return (c & 0x80000000) ? 0x80000000LL : 0LL;
+}
+
+long long
+f6 (void)
+{
+  return (d & 0x80000000) ? 0x80000000LL : 0LL;
+}
+
+long long
+f7 (void)
+{
+  return (d & 0x80000000) ? 0x380000000LL : 0LL;
+}
+
+long long
+f8 (void)
+{
+  return (d & 0x80000000) ? -2147483648LL : 0LL;
+}
+
+int
+main (void)
+{
+  if ((char) 128 != -128 || (int) 0x80000000 != -2147483648)
+    return 0;
+  if (f1 () != 128)
+    abort ();
+  if (f2 () != 128)
+    abort ();
+  if (f3 () != 896)
+    abort ();
+  if (f4 () != -128)
+    abort ();
+  if (f5 () != 0x80000000LL)
+    abort ();
+  if (f6 () != 0x80000000LL)
+    abort ();
+  if (f7 () != 0x380000000LL)
+    abort ();
+  if (f8 () != -2147483648LL)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00431-g.torture.execute-pr29695-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00431-g.torture.execute-pr29695-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..13042b3210d68af1098a006019953953bd05d7c1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00431-g.torture.execute-pr29695-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr29695-2)
+run(pr29695-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00432-g.torture.execute-pr29797-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00432-g.torture.execute-pr29797-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00432-g.torture.execute-pr29797-2/pr29797-2.c b/testsuite/c_test/x64_be_enable_test/GCC00432-g.torture.execute-pr29797-2/pr29797-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..9313bf4c635b3d4ac8a5e8ef4d22e2a3ddfa650e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00432-g.torture.execute-pr29797-2/pr29797-2.c
@@ -0,0 +1,14 @@
+extern void abort(void);
+
+unsigned long bar(void) { return 32768; }
+
+int main()
+{
+  unsigned long nStyle = bar ();
+  if (nStyle & 32768)
+    nStyle |= 65536;
+  if (nStyle != (32768 | 65536))
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00432-g.torture.execute-pr29797-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00432-g.torture.execute-pr29797-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..39fa6cb8b414e8198cd3257091fb309876f16ef2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00432-g.torture.execute-pr29797-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr29797-2)
+run(pr29797-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00433-g.torture.execute-pr30778/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00433-g.torture.execute-pr30778/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00433-g.torture.execute-pr30778/pr30778.c b/testsuite/c_test/x64_be_enable_test/GCC00433-g.torture.execute-pr30778/pr30778.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a930e63f33d78b93068737bd23298fa3811e230
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00433-g.torture.execute-pr30778/pr30778.c
@@ -0,0 +1,34 @@
+extern void *memset (void *, int, __SIZE_TYPE__);
+extern void abort (void);
+
+struct reg_stat {
+  void *last_death;
+  void *last_set;
+  void *last_set_value;
+  int   last_set_label;
+  char  last_set_sign_bit_copies;
+  int   last_set_mode : 8;
+  char  last_set_invalid;
+  char sign_bit_copies;
+  long nonzero_bits;
+};
+
+static struct reg_stat *reg_stat;
+
+void __attribute__((noinline))
+init_reg_last (void)
+{
+  memset (reg_stat, 0, __builtin_offsetof (struct reg_stat, sign_bit_copies));
+}
+
+int main (void)
+{
+  struct reg_stat r;
+
+  reg_stat = &r;
+  r.nonzero_bits = -1;
+  init_reg_last ();
+  if (r.nonzero_bits != -1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00433-g.torture.execute-pr30778/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00433-g.torture.execute-pr30778/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cdfe9502f9651fe507f273bc6cf073af4d96d8ee
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00433-g.torture.execute-pr30778/test.cfg
@@ -0,0 +1,2 @@
+compile(pr30778)
+run(pr30778)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00434-g.torture.execute-pr31072/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00434-g.torture.execute-pr31072/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00434-g.torture.execute-pr31072/pr31072.c b/testsuite/c_test/x64_be_enable_test/GCC00434-g.torture.execute-pr31072/pr31072.c
new file mode 100644
index 0000000000000000000000000000000000000000..beb4b558e34e3ef69c5a514e96f77eff78c46ec7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00434-g.torture.execute-pr31072/pr31072.c
@@ -0,0 +1,10 @@
+extern volatile int ReadyFlag_NotProperlyInitialized;
+
+volatile int ReadyFlag_NotProperlyInitialized=1;
+
+int main(void)
+{
+  if (ReadyFlag_NotProperlyInitialized != 1)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00434-g.torture.execute-pr31072/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00434-g.torture.execute-pr31072/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..283f2b3d11d031b6a0aa56c76487655fda2d8c6c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00434-g.torture.execute-pr31072/test.cfg
@@ -0,0 +1,2 @@
+compile(pr31072)
+run(pr31072)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00435-g.torture.execute-pr31448-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00435-g.torture.execute-pr31448-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00435-g.torture.execute-pr31448-2/pr31448-2.c b/testsuite/c_test/x64_be_enable_test/GCC00435-g.torture.execute-pr31448-2/pr31448-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..ad920c9d00e52d1637778f03f4e2a0ca740fe8b3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00435-g.torture.execute-pr31448-2/pr31448-2.c
@@ -0,0 +1,36 @@
+/* PR middle-end/31448, this used to ICE during expand because
+   reduce_to_bit_field_precision was not ready to handle constants. */
+
+typedef struct _st {
+    long int iIndex : 24;
+    long int iIndex1 : 24;
+} st;
+st *next;
+void g(void)
+{
+    st *next = 0;
+    int nIndx;
+    const static int constreg[] = { 0,};
+    nIndx = 0;
+    next->iIndex = constreg[nIndx];
+}
+void f(void)
+{
+    int nIndx;
+    const static long int constreg[] = { 0xFEFEFEFE,};
+    nIndx = 0;
+    next->iIndex = constreg[nIndx];
+    next->iIndex1 = constreg[nIndx];
+}
+int main(void)
+{
+  st a;
+  next = &a;
+  f();
+  if (next->iIndex != 0xFFFEFEFE)
+    __builtin_abort ();
+  if (next->iIndex1 != 0xFFFEFEFE)
+    __builtin_abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00435-g.torture.execute-pr31448-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00435-g.torture.execute-pr31448-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4079d25030e3a1978051f5eb84935bd060496b78
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00435-g.torture.execute-pr31448-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr31448-2)
+run(pr31448-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00436-g.torture.execute-pr31448/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00436-g.torture.execute-pr31448/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00436-g.torture.execute-pr31448/pr31448.c b/testsuite/c_test/x64_be_enable_test/GCC00436-g.torture.execute-pr31448/pr31448.c
new file mode 100644
index 0000000000000000000000000000000000000000..fb8c2471a6d3efd032ccef44dceaf016fda4ce61
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00436-g.torture.execute-pr31448/pr31448.c
@@ -0,0 +1,37 @@
+/* PR middle-end/31448, this used to ICE during expand because
+   reduce_to_bit_field_precision was not ready to handle constants. */
+/* { dg-require-effective-target int32plus } */
+
+typedef struct _st {
+    int iIndex : 24;
+    int iIndex1 : 24;
+} st;
+st *next;
+void g(void)
+{
+    st *next = 0;
+    int nIndx;
+    const static int constreg[] = { 0,};
+    nIndx = 0;
+    next->iIndex = constreg[nIndx];
+}
+void f(void)
+{
+    int nIndx;
+    const static int constreg[] = { 0xFEFEFEFE,};
+    nIndx = 0;
+    next->iIndex = constreg[nIndx];
+    next->iIndex1 = constreg[nIndx];
+}
+int main(void)
+{
+  st a;
+  next = &a;
+  f();
+  if (next->iIndex != 0xFFFEFEFE)
+    __builtin_abort ();
+  if (next->iIndex1 != 0xFFFEFEFE)
+    __builtin_abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00436-g.torture.execute-pr31448/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00436-g.torture.execute-pr31448/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..49d1a0eae42068b8561479b2c936f696916f9ae2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00436-g.torture.execute-pr31448/test.cfg
@@ -0,0 +1,2 @@
+compile(pr31448)
+run(pr31448)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00437-g.torture.execute-pr31605/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00437-g.torture.execute-pr31605/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00437-g.torture.execute-pr31605/pr31605.c b/testsuite/c_test/x64_be_enable_test/GCC00437-g.torture.execute-pr31605/pr31605.c
new file mode 100644
index 0000000000000000000000000000000000000000..12a57ac1ea68a28835c8b8e90c632d8b6c7901e0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00437-g.torture.execute-pr31605/pr31605.c
@@ -0,0 +1,13 @@
+void put_field (unsigned int start, unsigned int len)
+{
+  int cur_bitshift = ((start + len) % 8) - 8;
+  if (cur_bitshift > -8)
+    exit (0);
+}
+
+int
+main ()
+{
+  put_field (0, 1);
+  abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00437-g.torture.execute-pr31605/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00437-g.torture.execute-pr31605/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..298b4419751f00938ae54d8ec5acd29206dfbb82
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00437-g.torture.execute-pr31605/test.cfg
@@ -0,0 +1,2 @@
+compile(pr31605)
+run(pr31605)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00438-g.torture.execute-pr32500/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00438-g.torture.execute-pr32500/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00438-g.torture.execute-pr32500/pr32500.c b/testsuite/c_test/x64_be_enable_test/GCC00438-g.torture.execute-pr32500/pr32500.c
new file mode 100644
index 0000000000000000000000000000000000000000..41c455e451ed1a537fd58d491a923d806710f20d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00438-g.torture.execute-pr32500/pr32500.c
@@ -0,0 +1,26 @@
+extern void abort(void);
+extern void exit(int);
+void foo(int) __attribute__((noinline));
+void bar(void) __attribute__((noinline));
+
+/* Make sure foo is not inlined or considered pure/const.  */
+int x;
+void foo(int i) { x = i; }
+void bar(void) { exit(0); }
+
+int
+main(int argc, char *argv[])
+{
+	int i;
+	int numbers[4] = { 0xdead, 0xbeef, 0x1337, 0x4242 };
+
+	for (i = 1; i <= 12; i++) {
+		if (i <= 4)
+			foo(numbers[i-1]);
+		else if (i >= 7 && i <= 9)
+			bar();
+	}
+
+	abort();
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00438-g.torture.execute-pr32500/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00438-g.torture.execute-pr32500/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..30cb3c533ee1e56b57af31d18faa534a036415be
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00438-g.torture.execute-pr32500/test.cfg
@@ -0,0 +1,2 @@
+compile(pr32500)
+run(pr32500)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00439-g.torture.execute-pr33142/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00439-g.torture.execute-pr33142/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00439-g.torture.execute-pr33142/pr33142.c b/testsuite/c_test/x64_be_enable_test/GCC00439-g.torture.execute-pr33142/pr33142.c
new file mode 100644
index 0000000000000000000000000000000000000000..7bfc5b584dbd34057727c951f687f3126b513e82
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00439-g.torture.execute-pr33142/pr33142.c
@@ -0,0 +1,16 @@
+int abs(int j);
+extern void abort(void);
+
+__attribute__((noinline)) int lisp_atan2(long dy, long dx) {
+    if (dx <= 0)
+        if (dy > 0)
+            return abs(dx) <= abs(dy);
+    return 0;
+}
+
+int main() {   
+    volatile long dy = 63, dx = -77;
+    if (lisp_atan2(dy, dx))
+        abort();
+    return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00439-g.torture.execute-pr33142/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00439-g.torture.execute-pr33142/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..188ad509a896792e56e9db3ddd4de972a878dcdc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00439-g.torture.execute-pr33142/test.cfg
@@ -0,0 +1,2 @@
+compile(pr33142)
+run(pr33142)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00440-g.torture.execute-pr33382/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00440-g.torture.execute-pr33382/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00440-g.torture.execute-pr33382/pr33382.c b/testsuite/c_test/x64_be_enable_test/GCC00440-g.torture.execute-pr33382/pr33382.c
new file mode 100644
index 0000000000000000000000000000000000000000..ee539643ae67906f863c4798e102ea951d99da3b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00440-g.torture.execute-pr33382/pr33382.c
@@ -0,0 +1,21 @@
+struct Foo {
+  int i;
+  int j[];
+};
+
+struct Foo x = { 1, { 2, 0, 2, 3 } };
+
+int foo(void)
+{
+  x.j[0] = 1;
+  return x.j[1];
+}
+
+extern void abort(void);
+
+int main()
+{
+  if (foo() != 0)
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00440-g.torture.execute-pr33382/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00440-g.torture.execute-pr33382/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..990d130406dc8b2e8f5b1a580abc13ea6d1afe53
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00440-g.torture.execute-pr33382/test.cfg
@@ -0,0 +1,2 @@
+compile(pr33382)
+run(pr33382)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00441-g.torture.execute-pr33779-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00441-g.torture.execute-pr33779-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00441-g.torture.execute-pr33779-1/pr33779-1.c b/testsuite/c_test/x64_be_enable_test/GCC00441-g.torture.execute-pr33779-1/pr33779-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..da08e013a05f83af9e9cb46df79913b33b7c407c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00441-g.torture.execute-pr33779-1/pr33779-1.c
@@ -0,0 +1,14 @@
+int foo(int i)
+{
+  if (((unsigned)(i + 1)) * 4 == 0)
+    return 1;
+  return 0;
+}
+
+extern void abort(void);
+int main()
+{
+  if (foo(0x3fffffff) == 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00441-g.torture.execute-pr33779-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00441-g.torture.execute-pr33779-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..644bdaa807877c525c08d29fb1d5f4e3d609e925
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00441-g.torture.execute-pr33779-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr33779-1)
+run(pr33779-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00442-g.torture.execute-pr33870-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00442-g.torture.execute-pr33870-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00442-g.torture.execute-pr33870-1/pr33870-1.c b/testsuite/c_test/x64_be_enable_test/GCC00442-g.torture.execute-pr33870-1/pr33870-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..af5a40db66b995c2ada21f8616412dbbaa5e9dec
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00442-g.torture.execute-pr33870-1/pr33870-1.c
@@ -0,0 +1,94 @@
+extern void abort (void);
+
+typedef struct PgHdr PgHdr;
+typedef unsigned char u8;
+struct PgHdr {
+int y;
+struct {
+ unsigned int pgno;
+ PgHdr *pNextHash, *pPrevHash;
+ PgHdr *pNextFree, *pPrevFree;
+ PgHdr *pNextAll;
+ u8 inJournal;
+ short int nRef;
+ PgHdr *pDirty, *pPrevDirty;
+ unsigned int notUsed;
+} x;
+};
+PgHdr **xx;
+volatile int vx;
+static inline PgHdr *merge_pagelist(PgHdr *pA, PgHdr *pB)
+{
+ PgHdr result;
+ PgHdr *pTail;
+ xx = &result.x.pDirty;
+ pTail = &result;
+ while( pA && pB ){
+   if( pA->x.pgno<pB->x.pgno ){
+     pTail->x.pDirty = pA;
+     pTail = pA;
+     pA = pA->x.pDirty;
+   }else{
+     pTail->x.pDirty = pB;
+     pTail = pB;
+     pB = pB->x.pDirty;
+   }
+   vx = (*xx)->y;
+ }
+ if( pA ){
+   pTail->x.pDirty = pA;
+ }else if( pB ){
+   pTail->x.pDirty = pB;
+ }else{
+   pTail->x.pDirty = 0;
+ }
+ return result.x.pDirty;
+}
+
+PgHdr * __attribute__((noinline)) sort_pagelist(PgHdr *pIn)
+{
+ PgHdr *a[25], *p;
+ int i;
+ __builtin_memset (a, 0, sizeof (a));
+ while( pIn ){
+   p = pIn;
+   pIn = p->x.pDirty;
+   p->x.pDirty = 0;
+   for(i=0; i<25 -1; i++){
+     if( a[i]==0 ){
+       a[i] = p;
+       break;
+     }else{
+       p = merge_pagelist(a[i], p);
+       a[i] = 0;
+       a[i] = 0;
+     }
+   }
+   if( i==25 -1 ){
+     a[i] = merge_pagelist(a[i], p);
+   }
+ }
+ p = a[0];
+ for(i=1; i<25; i++){
+   p = merge_pagelist (p, a[i]);
+ }
+ return p;
+}
+
+int main()
+{
+ PgHdr a[5];
+ PgHdr *p;
+ a[0].x.pgno = 5;
+ a[0].x.pDirty = &a[1];
+ a[1].x.pgno = 4;
+ a[1].x.pDirty = &a[2];
+ a[2].x.pgno = 1;
+ a[2].x.pDirty = &a[3];
+ a[3].x.pgno = 3;
+ a[3].x.pDirty = 0;
+ p = sort_pagelist (&a[0]);
+ if (p->x.pDirty == p)
+   abort ();
+ return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00442-g.torture.execute-pr33870-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00442-g.torture.execute-pr33870-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b8642a4fcd7280826123ff24df47aa40e33e8d0f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00442-g.torture.execute-pr33870-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr33870-1)
+run(pr33870-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00443-g.torture.execute-pr33870/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00443-g.torture.execute-pr33870/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00443-g.torture.execute-pr33870/pr33870.c b/testsuite/c_test/x64_be_enable_test/GCC00443-g.torture.execute-pr33870/pr33870.c
new file mode 100644
index 0000000000000000000000000000000000000000..9189b4a905458fc4b0ec9c725bef774b35a42ac1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00443-g.torture.execute-pr33870/pr33870.c
@@ -0,0 +1,87 @@
+extern void abort (void);
+
+typedef struct PgHdr PgHdr;
+typedef unsigned char u8;
+struct PgHdr {
+  unsigned int pgno;
+  PgHdr *pNextHash, *pPrevHash;
+  PgHdr *pNextFree, *pPrevFree;
+  PgHdr *pNextAll;
+  u8 inJournal;
+  short int nRef;
+  PgHdr *pDirty, *pPrevDirty;
+  unsigned int notUsed;
+};
+
+static inline PgHdr *merge_pagelist(PgHdr *pA, PgHdr *pB)
+{
+  PgHdr result;
+  PgHdr *pTail;
+  pTail = &result;
+  while( pA && pB ){
+    if( pA->pgno<pB->pgno ){
+      pTail->pDirty = pA;
+      pTail = pA;
+      pA = pA->pDirty;
+    }else{
+      pTail->pDirty = pB;
+      pTail = pB;
+      pB = pB->pDirty;
+    }
+  }
+  if( pA ){
+    pTail->pDirty = pA;
+  }else if( pB ){
+    pTail->pDirty = pB;
+  }else{
+    pTail->pDirty = 0;
+  }
+  return result.pDirty;
+}
+
+PgHdr * __attribute__((noinline)) sort_pagelist(PgHdr *pIn)
+{
+  PgHdr *a[25], *p;
+  int i;
+  __builtin_memset (a, 0, sizeof (a));
+  while( pIn ){
+    p = pIn;
+    pIn = p->pDirty;
+    p->pDirty = 0;
+    for(i=0; i<25 -1; i++){
+      if( a[i]==0 ){
+        a[i] = p;
+        break;
+      }else{
+        p = merge_pagelist(a[i], p);
+        a[i] = 0;
+      }
+    }
+    if( i==25 -1 ){
+      a[i] = merge_pagelist(a[i], p);
+    }
+  }
+  p = a[0];
+  for(i=1; i<25; i++){
+    p = merge_pagelist (p, a[i]);
+  }
+  return p;
+}
+
+int main()
+{
+  PgHdr a[5];
+  PgHdr *p;
+  a[0].pgno = 5;
+  a[0].pDirty = &a[1];
+  a[1].pgno = 4;
+  a[1].pDirty = &a[2];
+  a[2].pgno = 1;
+  a[2].pDirty = &a[3];
+  a[3].pgno = 3;
+  a[3].pDirty = 0;
+  p = sort_pagelist (&a[0]);
+  if (p->pDirty == p)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00443-g.torture.execute-pr33870/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00443-g.torture.execute-pr33870/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4439f158a501a3aa559b8220d29a72ba36287dac
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00443-g.torture.execute-pr33870/test.cfg
@@ -0,0 +1,2 @@
+compile(pr33870)
+run(pr33870)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00444-g.torture.execute-pr33992/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00444-g.torture.execute-pr33992/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00444-g.torture.execute-pr33992/pr33992.c b/testsuite/c_test/x64_be_enable_test/GCC00444-g.torture.execute-pr33992/pr33992.c
new file mode 100644
index 0000000000000000000000000000000000000000..92b80e51bb047b9f8dfd9401059d301cfee541e1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00444-g.torture.execute-pr33992/pr33992.c
@@ -0,0 +1,37 @@
+extern void abort ();
+
+void __attribute__((noinline))
+bar (unsigned long long i)
+{
+  if (i)
+    abort ();
+}
+
+static void __attribute__((always_inline))
+foo (unsigned long long *r)
+{
+  int i;
+
+  for (i = 0; ; i++)
+    if (*r & ((unsigned long long)1 << (63 - i)))
+      break;
+
+  bar (i);
+}
+
+void __attribute__((noinline))
+do_test (unsigned long long *r)
+{
+  int i;
+
+  for (i = 0; i < 2; ++i)
+    foo (r);
+}
+
+int main()
+{
+  unsigned long long r = 0x8000000000000001ull;
+
+  do_test (&r);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00444-g.torture.execute-pr33992/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00444-g.torture.execute-pr33992/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b3d48f31ac02ec19960de04c0226e27d3386a669
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00444-g.torture.execute-pr33992/test.cfg
@@ -0,0 +1,2 @@
+compile(pr33992)
+run(pr33992)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00445-g.torture.execute-pr34099/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00445-g.torture.execute-pr34099/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00445-g.torture.execute-pr34099/pr34099.c b/testsuite/c_test/x64_be_enable_test/GCC00445-g.torture.execute-pr34099/pr34099.c
new file mode 100644
index 0000000000000000000000000000000000000000..d6f5ad1f6517118d67fad66ebcee920568007ed3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00445-g.torture.execute-pr34099/pr34099.c
@@ -0,0 +1,16 @@
+int foo (int b, int c)
+{
+  int x;
+  if (b)
+    return x & c;
+  else
+    return 1;
+}
+extern void abort (void);
+int main()
+{
+  if (foo(1, 0) != 0)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00445-g.torture.execute-pr34099/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00445-g.torture.execute-pr34099/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3439be31efe90767a33df4338f9547f13be9f3de
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00445-g.torture.execute-pr34099/test.cfg
@@ -0,0 +1,2 @@
+compile(pr34099)
+run(pr34099)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00446-g.torture.execute-pr34176/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00446-g.torture.execute-pr34176/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00446-g.torture.execute-pr34176/pr34176.c b/testsuite/c_test/x64_be_enable_test/GCC00446-g.torture.execute-pr34176/pr34176.c
new file mode 100644
index 0000000000000000000000000000000000000000..3bbdb22c74cdc9cbc5acdb1f1c98741e11286c08
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00446-g.torture.execute-pr34176/pr34176.c
@@ -0,0 +1,68 @@
+
+typedef __SIZE_TYPE__ size_t;
+typedef unsigned int index_ty;
+typedef index_ty *index_list_ty;
+
+struct mult_index
+{
+  index_ty index;
+  unsigned int count;
+};
+
+struct mult_index_list
+{
+  struct mult_index *item;
+  size_t nitems;
+  size_t nitems_max;
+
+  struct mult_index *item2;
+  size_t nitems2_max;
+};
+
+int __attribute__((noinline))
+hash_find_entry (size_t *result)
+{
+    *result = 2;
+    return 0;
+}
+
+extern void abort (void);
+struct mult_index * __attribute__((noinline))
+foo (size_t n)
+{
+  static count = 0;
+  if (count++ > 0)
+    abort ();
+  return 0;
+}
+
+int
+main (void)
+{
+    size_t nitems = 0;
+
+    for (;;)
+    {
+        size_t list;
+
+        hash_find_entry (&list);
+        {
+            size_t len2 = list;
+            struct mult_index *destptr;
+            struct mult_index *dest;
+            size_t new_max  = nitems + len2;
+
+            if (new_max != len2)
+                break;
+            dest = foo (new_max);
+
+            destptr = dest;
+            while (len2--)
+                destptr++;
+
+            nitems = destptr - dest;
+        }
+    }
+
+    return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00446-g.torture.execute-pr34176/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00446-g.torture.execute-pr34176/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6891d443bfbc4f04c9da64ad9c2927971c6ed788
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00446-g.torture.execute-pr34176/test.cfg
@@ -0,0 +1,2 @@
+compile(pr34176)
+run(pr34176)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00447-g.torture.execute-pr34456/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00447-g.torture.execute-pr34456/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00447-g.torture.execute-pr34456/pr34456.c b/testsuite/c_test/x64_be_enable_test/GCC00447-g.torture.execute-pr34456/pr34456.c
new file mode 100644
index 0000000000000000000000000000000000000000..b4a845ec14b1a4b5c0cd3233cf632d54a5507d80
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00447-g.torture.execute-pr34456/pr34456.c
@@ -0,0 +1,32 @@
+/* { dg-skip-if "requires qsort" { freestanding } }  */
+
+#include <stdlib.h>
+
+int __attribute__ ((noinline)) debug (void) { return 1; }
+int errors;
+
+struct s { int elt; int (*compare) (int); };
+
+static int
+compare (const void *x, const void *y)
+{
+  const struct s *s1 = x, *s2 = y;
+  int (*compare1) (int);
+  int elt2;
+
+  compare1 = s1->compare;
+  elt2 = s2->elt;
+  if (elt2 != 0 && debug () && compare1 (s1->elt) != 0)
+    errors++;
+  return compare1 (elt2);
+}
+
+int bad_compare (int x) { return -x; }
+struct s array[2] = { { 1, bad_compare }, { -1, bad_compare } };
+
+int
+main (void)
+{
+  qsort (array, 2, sizeof (struct s), compare);
+  return errors == 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00447-g.torture.execute-pr34456/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00447-g.torture.execute-pr34456/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9cce059760ab76bf807f164fa9b9076800fa4ad2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00447-g.torture.execute-pr34456/test.cfg
@@ -0,0 +1,2 @@
+compile(pr34456)
+run(pr34456)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00448-g.torture.execute-pr34768-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00448-g.torture.execute-pr34768-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00448-g.torture.execute-pr34768-1/pr34768-1.c b/testsuite/c_test/x64_be_enable_test/GCC00448-g.torture.execute-pr34768-1/pr34768-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb16adbf1f351153993698a6d41f4061153df7d3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00448-g.torture.execute-pr34768-1/pr34768-1.c
@@ -0,0 +1,26 @@
+int x;
+
+void __attribute__((noinline)) foo (void)
+{
+  x = -x;
+}
+void __attribute__((const,noinline)) bar (void)
+{
+}
+
+int __attribute__((noinline))
+test (int c)
+{
+  int tmp = x;
+  (c ? foo : bar) ();
+  return tmp + x;
+}
+
+extern void abort (void);
+int main()
+{
+  x = 1;
+  if (test (1) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00448-g.torture.execute-pr34768-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00448-g.torture.execute-pr34768-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e5db77c733e3a807f0f131f1e3f70a2ba229f3fc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00448-g.torture.execute-pr34768-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr34768-1)
+run(pr34768-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00449-g.torture.execute-pr34768-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00449-g.torture.execute-pr34768-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00449-g.torture.execute-pr34768-2/pr34768-2.c b/testsuite/c_test/x64_be_enable_test/GCC00449-g.torture.execute-pr34768-2/pr34768-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..917bf9e2b6f99e6f355b038792c6be4ade53c2fa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00449-g.torture.execute-pr34768-2/pr34768-2.c
@@ -0,0 +1,28 @@
+int x;
+
+int __attribute__((noinline)) foo (void)
+{
+  x = -x;
+  return 0;
+}
+int __attribute__((const,noinline)) bar (void)
+{
+  return 0;
+}
+
+int __attribute__((noinline))
+test (int c)
+{
+  int tmp = x;
+  int res = (c ? foo : bar) ();
+  return tmp + x + res;
+}
+
+extern void abort (void);
+int main()
+{
+  x = 1;
+  if (test (1) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00449-g.torture.execute-pr34768-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00449-g.torture.execute-pr34768-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d8349c9b760024528097bc27f18409bac2b2511a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00449-g.torture.execute-pr34768-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr34768-2)
+run(pr34768-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00450-g.torture.execute-pr35231/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00450-g.torture.execute-pr35231/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00450-g.torture.execute-pr35231/pr35231.c b/testsuite/c_test/x64_be_enable_test/GCC00450-g.torture.execute-pr35231/pr35231.c
new file mode 100644
index 0000000000000000000000000000000000000000..e0327eb5f8a549fb857ff179ff7f98d6dd7a706d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00450-g.torture.execute-pr35231/pr35231.c
@@ -0,0 +1,16 @@
+extern void abort(void);
+
+int __attribute__((noinline))
+foo(int bits_per_pixel, int depth)
+{
+  if ((bits_per_pixel | depth) == 1)
+    abort ();
+  return bits_per_pixel;
+}
+
+int main()
+{
+  if (foo(2, 0) != 2)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00450-g.torture.execute-pr35231/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00450-g.torture.execute-pr35231/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16b9386751bc311c69ea3e623cf49d445544aa14
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00450-g.torture.execute-pr35231/test.cfg
@@ -0,0 +1,2 @@
+compile(pr35231)
+run(pr35231)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00451-g.torture.execute-pr35390/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00451-g.torture.execute-pr35390/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00451-g.torture.execute-pr35390/pr35390.c b/testsuite/c_test/x64_be_enable_test/GCC00451-g.torture.execute-pr35390/pr35390.c
new file mode 100644
index 0000000000000000000000000000000000000000..7103a9b5414a88252ea73ca834e96d4795aaeb3d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00451-g.torture.execute-pr35390/pr35390.c
@@ -0,0 +1,13 @@
+extern void abort (void);
+
+unsigned int foo (int n)
+{
+  return ~((unsigned int)~n);
+}
+
+int main()
+{
+  if (foo(0) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00451-g.torture.execute-pr35390/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00451-g.torture.execute-pr35390/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..93264786c03edf87fcca15fe8867b5acb05b98eb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00451-g.torture.execute-pr35390/test.cfg
@@ -0,0 +1,2 @@
+compile(pr35390)
+run(pr35390)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00452-g.torture.execute-pr35472/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00452-g.torture.execute-pr35472/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00452-g.torture.execute-pr35472/pr35472.c b/testsuite/c_test/x64_be_enable_test/GCC00452-g.torture.execute-pr35472/pr35472.c
new file mode 100644
index 0000000000000000000000000000000000000000..6981dd812a8ce0e6891fd890b17ad256ef28b359
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00452-g.torture.execute-pr35472/pr35472.c
@@ -0,0 +1,22 @@
+extern void abort (void);
+extern void *memset (void *s, int c, __SIZE_TYPE__ n);
+struct S { int i[16]; };
+struct S *p;
+void __attribute__((noinline,noclone))
+foo(struct S *a, struct S *b) { a->i[0] = -1; p = b; }
+void test (void)
+{
+  struct S a, b;
+  memset (&a.i[0], '\0', sizeof (a.i));
+  memset (&b.i[0], '\0', sizeof (b.i));
+  foo (&a, &b);
+  *p = a;
+  *p = b;
+  if (b.i[0] != -1)
+    abort ();
+}
+int main()
+{
+  test();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00452-g.torture.execute-pr35472/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00452-g.torture.execute-pr35472/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7795628da2233ff4d74643fa7975709eaecd5e22
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00452-g.torture.execute-pr35472/test.cfg
@@ -0,0 +1,2 @@
+compile(pr35472)
+run(pr35472)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00453-g.torture.execute-pr36038/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00453-g.torture.execute-pr36038/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00453-g.torture.execute-pr36038/pr36038.c b/testsuite/c_test/x64_be_enable_test/GCC00453-g.torture.execute-pr36038/pr36038.c
new file mode 100644
index 0000000000000000000000000000000000000000..de4bef3d40e9004972922e7b625aa5557ea790bf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00453-g.torture.execute-pr36038/pr36038.c
@@ -0,0 +1,43 @@
+/* PR tree-optimization/36038 */
+
+long long list[10];
+long long expect[10] = { 0, 1, 2, 3, 4, 4, 5, 6, 7, 9 };
+long long *stack_base;
+int indices[10];
+int *markstack_ptr;
+
+void
+doit (void)
+{
+  long long *src;
+  long long *dst;
+  long long *sp = stack_base + 5;
+  int diff = 2;
+  int shift;
+  int count;
+
+  shift = diff - (markstack_ptr[-1] - markstack_ptr[-2]);
+  count = (sp - stack_base) - markstack_ptr[-1] + 2;
+  src = sp;
+  dst = (sp += shift);
+  while (--count)
+    *dst-- = *src--;
+}
+
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 10; i++)
+    list[i] = i;
+
+  markstack_ptr = indices + 9;
+  markstack_ptr[-1] = 2;
+  markstack_ptr[-2] = 1;
+
+  stack_base = list + 2;
+  doit ();
+  if (__builtin_memcmp (expect, list, sizeof (list)))
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00453-g.torture.execute-pr36038/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00453-g.torture.execute-pr36038/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cca7880224318d49d0716367c1e2f9c333de4720
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00453-g.torture.execute-pr36038/test.cfg
@@ -0,0 +1,2 @@
+compile(pr36038)
+run(pr36038)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00454-g.torture.execute-pr36339/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00454-g.torture.execute-pr36339/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00454-g.torture.execute-pr36339/pr36339.c b/testsuite/c_test/x64_be_enable_test/GCC00454-g.torture.execute-pr36339/pr36339.c
new file mode 100644
index 0000000000000000000000000000000000000000..c4f36ddcaceb32b291e17ff607c6a440f6690f07
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00454-g.torture.execute-pr36339/pr36339.c
@@ -0,0 +1,32 @@
+extern void abort (void);
+
+typedef unsigned long my_uintptr_t;
+
+int check_a(my_uintptr_t tagged_ptr);
+
+int __attribute__((noinline)) try_a(my_uintptr_t x)
+{
+  my_uintptr_t heap[2];
+  my_uintptr_t *hp = heap;
+
+  hp[0] = x;
+  hp[1] = 0;
+  return check_a((my_uintptr_t)(void*)((char*)hp + 1));
+}
+
+int __attribute__((noinline)) check_a(my_uintptr_t tagged_ptr)
+{
+  my_uintptr_t *hp = (my_uintptr_t*)(void*)((char*)tagged_ptr - 1);
+
+  if (hp[0] == 42 && hp[1] == 0)
+    return 0;
+  return -1;
+}
+
+int main(void)
+{
+  if (try_a(42) < 0)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00454-g.torture.execute-pr36339/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00454-g.torture.execute-pr36339/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d72f6dbc9d9d22248c8abda956e7932e373e9e38
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00454-g.torture.execute-pr36339/test.cfg
@@ -0,0 +1,2 @@
+compile(pr36339)
+run(pr36339)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00455-g.torture.execute-pr36691/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00455-g.torture.execute-pr36691/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00455-g.torture.execute-pr36691/pr36691.c b/testsuite/c_test/x64_be_enable_test/GCC00455-g.torture.execute-pr36691/pr36691.c
new file mode 100644
index 0000000000000000000000000000000000000000..81fe6fd55d984712e549896e144039ca2afb75ad
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00455-g.torture.execute-pr36691/pr36691.c
@@ -0,0 +1,17 @@
+unsigned char g_5;
+
+void func_1 (void)
+{
+  for (g_5 = 9; g_5 >= 4; g_5 -= 5)
+    ;
+}
+
+extern void abort (void);
+int main (void)
+{
+  func_1 ();
+  if (g_5 != 0)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00455-g.torture.execute-pr36691/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00455-g.torture.execute-pr36691/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4fbeba53c9b4cca63880e6bb9ba923f0d59a925d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00455-g.torture.execute-pr36691/test.cfg
@@ -0,0 +1,2 @@
+compile(pr36691)
+run(pr36691)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00456-g.torture.execute-pr36765/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00456-g.torture.execute-pr36765/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00456-g.torture.execute-pr36765/pr36765.c b/testsuite/c_test/x64_be_enable_test/GCC00456-g.torture.execute-pr36765/pr36765.c
new file mode 100644
index 0000000000000000000000000000000000000000..f408585d7337561cf0a0d3682428812161c70258
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00456-g.torture.execute-pr36765/pr36765.c
@@ -0,0 +1,15 @@
+int __attribute__((noinline))
+foo(int i)
+{
+  int *p = malloc (4 * sizeof(int));
+  *p = 0;
+  p[i] = 1;
+  return *p;
+}
+extern void abort (void);
+int main()
+{
+  if (foo(0) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00456-g.torture.execute-pr36765/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00456-g.torture.execute-pr36765/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5cab155039c42abd19ca4da7b45f6ce13c6e0686
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00456-g.torture.execute-pr36765/test.cfg
@@ -0,0 +1,2 @@
+compile(pr36765)
+run(pr36765)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00457-g.torture.execute-pr37102/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00457-g.torture.execute-pr37102/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00457-g.torture.execute-pr37102/pr37102.c b/testsuite/c_test/x64_be_enable_test/GCC00457-g.torture.execute-pr37102/pr37102.c
new file mode 100644
index 0000000000000000000000000000000000000000..32c18ba88a10b2284fc5bf837d0088e6aea0498e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00457-g.torture.execute-pr37102/pr37102.c
@@ -0,0 +1,25 @@
+extern void abort (void);
+
+unsigned int a, b = 1, c;
+
+void __attribute__ ((noinline))
+foo (int x)
+{
+  if (x != 5)
+    abort ();
+}
+
+int
+main ()
+{
+  unsigned int d, e;
+  for (d = 1; d < 5; d++)
+    if (c)
+      a = b;
+  a = b;
+  e = a << 1;
+  if (e)
+    e = (e << 1) ^ 1;
+  foo (e);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00457-g.torture.execute-pr37102/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00457-g.torture.execute-pr37102/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..be5c01754841cd0c83876eea43c1194245139caf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00457-g.torture.execute-pr37102/test.cfg
@@ -0,0 +1,2 @@
+compile(pr37102)
+run(pr37102)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00458-g.torture.execute-pr37573/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00458-g.torture.execute-pr37573/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00458-g.torture.execute-pr37573/pr37573.c b/testsuite/c_test/x64_be_enable_test/GCC00458-g.torture.execute-pr37573/pr37573.c
new file mode 100644
index 0000000000000000000000000000000000000000..173a8d478881245e96086b7f3f1cd4e8b0afef66
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00458-g.torture.execute-pr37573/pr37573.c
@@ -0,0 +1,66 @@
+/* PR tree-optimization/37573 */
+/* { dg-require-effective-target int32plus } */
+
+struct S
+{
+  unsigned int *a;
+  unsigned int b;
+  unsigned int c[624];
+};
+
+static unsigned char __attribute__((noinline))
+foo (struct S *s)
+{
+  unsigned int r;
+  if (!--s->b)
+    {
+      unsigned int *c = s->c;
+      unsigned int i;
+      s->a = c;
+      for (i = 0; i < 227; i++)
+	c[i] = ((((c[i] ^ c[i + 1]) & 0x7ffffffe) ^ c[i]) >> 1)
+	    ^ ((0 - (c[i + 1] & 1)) & 0x9908b0df) ^ c[i + 397];
+    }
+  r = *(s->a++);
+  r ^= (r >> 11);
+  r ^= ((r & 0xff3a58ad) << 7);
+  r ^= ((r & 0xffffdf8c) << 15);
+  r ^= (r >> 18);
+  return (unsigned char) (r >> 1);
+}
+
+static void __attribute__((noinline))
+bar (unsigned char *p, unsigned int q, unsigned int r)
+{
+  struct S s;
+  unsigned int i;
+  unsigned int *c = s.c;
+  *c = r;
+  for (i = 1; i < 624; i++)
+    c[i] = i + 0x6c078965 * ((c[i - 1] >> 30) ^ c[i - 1]);
+  s.b = 1;
+  while (q--)
+    *p++ ^= foo (&s);
+};
+
+static unsigned char p[23] = {
+  0xc0, 0x49, 0x17, 0x32, 0x62, 0x1e, 0x2e, 0xd5, 0x4c, 0x19, 0x28, 0x49,
+  0x91, 0xe4, 0x72, 0x83, 0x91, 0x3d, 0x93, 0x83, 0xb3, 0x61, 0x38
+};
+
+static unsigned char q[23] = {
+  0x3e, 0x41, 0x55, 0x54, 0x4f, 0x49, 0x54, 0x20, 0x55, 0x4e, 0x49, 0x43,
+  0x4f, 0x44, 0x45, 0x20, 0x53, 0x43, 0x52, 0x49, 0x50, 0x54, 0x3c
+};
+
+int
+main (void)
+{
+  unsigned int s;
+  s = 23;
+  bar (p, s, s + 0xa25e);
+  if (__builtin_memcmp (p, q, s) != 0)
+    __builtin_abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00458-g.torture.execute-pr37573/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00458-g.torture.execute-pr37573/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c442a8c09991acfc5b8b72177a593eb4243f3a80
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00458-g.torture.execute-pr37573/test.cfg
@@ -0,0 +1,2 @@
+compile(pr37573)
+run(pr37573)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00459-g.torture.execute-pr37882/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00459-g.torture.execute-pr37882/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00459-g.torture.execute-pr37882/pr37882.c b/testsuite/c_test/x64_be_enable_test/GCC00459-g.torture.execute-pr37882/pr37882.c
new file mode 100644
index 0000000000000000000000000000000000000000..d90e1ee342675a19b8499d6a913a4ee3b6293af6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00459-g.torture.execute-pr37882/pr37882.c
@@ -0,0 +1,15 @@
+/* PR middle-end/37882 */
+
+struct S
+{
+  unsigned char b : 3;
+} s;
+
+int
+main ()
+{
+  s.b = 4;
+  if (s.b > 0 && s.b < 4)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00459-g.torture.execute-pr37882/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00459-g.torture.execute-pr37882/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..282b282bd9d9cde3e301e070b7261311fd081f88
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00459-g.torture.execute-pr37882/test.cfg
@@ -0,0 +1,2 @@
+compile(pr37882)
+run(pr37882)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00460-g.torture.execute-pr37931/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00460-g.torture.execute-pr37931/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00460-g.torture.execute-pr37931/pr37931.c b/testsuite/c_test/x64_be_enable_test/GCC00460-g.torture.execute-pr37931/pr37931.c
new file mode 100644
index 0000000000000000000000000000000000000000..0077a21ba33e4a8cf7cee4201e8e9d92a673f238
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00460-g.torture.execute-pr37931/pr37931.c
@@ -0,0 +1,23 @@
+/* PR middle-end/37931 */
+
+extern void abort (void);
+
+int
+foo (int a, unsigned int b)
+{
+  return (a | 1) & (b | 1);
+}
+
+int
+main (void)
+{
+  if (foo (6, 0xc6) != 7)
+    abort ();
+  if (foo (0x80, 0xc1) != 0x81)
+    abort ();
+  if (foo (4, 4) != 5)
+    abort ();
+  if (foo (5, 4) != 5)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00460-g.torture.execute-pr37931/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00460-g.torture.execute-pr37931/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a5a1838163728bf5487f2b066566096f1c690a91
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00460-g.torture.execute-pr37931/test.cfg
@@ -0,0 +1,2 @@
+compile(pr37931)
+run(pr37931)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00461-g.torture.execute-pr38212/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00461-g.torture.execute-pr38212/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00461-g.torture.execute-pr38212/pr38212.c b/testsuite/c_test/x64_be_enable_test/GCC00461-g.torture.execute-pr38212/pr38212.c
new file mode 100644
index 0000000000000000000000000000000000000000..867d4c17431645eecdcfc480289575619b57bb02
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00461-g.torture.execute-pr38212/pr38212.c
@@ -0,0 +1,22 @@
+int __attribute__((noinline))
+foo (int *__restrict p, int i)
+{
+  int *__restrict q;
+  int *__restrict r;
+  int v, w;
+  q = p + 1;
+  r = q - i;
+  v = *r;
+  *p = 1;
+  w = *r;
+  return v + w;
+}
+extern void abort (void);
+int main()
+{
+  int i = 0;
+  if (foo (&i, 1) != 1)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00461-g.torture.execute-pr38212/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00461-g.torture.execute-pr38212/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1eabb70c4cfcc5c4052ba941e70574c9d32db635
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00461-g.torture.execute-pr38212/test.cfg
@@ -0,0 +1,2 @@
+compile(pr38212)
+run(pr38212)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00462-g.torture.execute-pr38236/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00462-g.torture.execute-pr38236/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00462-g.torture.execute-pr38236/pr38236.c b/testsuite/c_test/x64_be_enable_test/GCC00462-g.torture.execute-pr38236/pr38236.c
new file mode 100644
index 0000000000000000000000000000000000000000..d781542c7ccab5590b7ff1885ad4889aa215d1f5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00462-g.torture.execute-pr38236/pr38236.c
@@ -0,0 +1,22 @@
+struct X { int i; };
+
+int __attribute__((noinline))
+foo (struct X *p, int *q, int a, int b)
+{
+  struct X x, y;
+  if (a)
+    p = &x;
+  if (b)
+    q = &x.i;
+  else
+    q = &y.i;
+  *q = 1;
+  return p->i; 
+}
+extern void abort (void);
+int main()
+{
+  if (foo((void *)0, (void *)0, 1, 1) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00462-g.torture.execute-pr38236/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00462-g.torture.execute-pr38236/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fedbc835e5edf6907adc0e06a9effd60909d800d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00462-g.torture.execute-pr38236/test.cfg
@@ -0,0 +1,2 @@
+compile(pr38236)
+run(pr38236)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00463-g.torture.execute-pr38422/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00463-g.torture.execute-pr38422/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00463-g.torture.execute-pr38422/pr38422.c b/testsuite/c_test/x64_be_enable_test/GCC00463-g.torture.execute-pr38422/pr38422.c
new file mode 100644
index 0000000000000000000000000000000000000000..e36879d7fe6d6141d2b54b9220d8d69910caa0c7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00463-g.torture.execute-pr38422/pr38422.c
@@ -0,0 +1,24 @@
+/* PR middle-end/38422 */
+
+extern void abort (void);
+
+struct S
+{
+  int s : (sizeof (int) * __CHAR_BIT__ - 2);
+} s;
+
+void
+foo (void)
+{
+  s.s *= 2;
+}
+
+int
+main ()
+{
+  s.s = 24;
+  foo ();
+  if (s.s != 48)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00463-g.torture.execute-pr38422/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00463-g.torture.execute-pr38422/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..66aef698722a5fbf1b638a458523d0e4e309ee84
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00463-g.torture.execute-pr38422/test.cfg
@@ -0,0 +1,2 @@
+compile(pr38422)
+run(pr38422)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00464-g.torture.execute-pr38533/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00464-g.torture.execute-pr38533/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00464-g.torture.execute-pr38533/pr38533.c b/testsuite/c_test/x64_be_enable_test/GCC00464-g.torture.execute-pr38533/pr38533.c
new file mode 100644
index 0000000000000000000000000000000000000000..44eb5b87d41dff5cd3a55159c1a5db44f1999104
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00464-g.torture.execute-pr38533/pr38533.c
@@ -0,0 +1,21 @@
+/* PR middle-end/38533 */
+
+#define A asm volatile ("" : "=r" (f) : "0" (0)); e |= f;
+#define B A A A A A A A A A A A
+#define C B B B B B B B B B B B
+
+int
+foo (void)
+{
+  int e = 0, f;
+  C C B B B B B A A A A A A
+  return e;
+}
+
+int
+main (void)
+{
+  if (foo ())
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00464-g.torture.execute-pr38533/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00464-g.torture.execute-pr38533/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8e7f3f9e7218381d2520c4ba5383a2c7b57675c6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00464-g.torture.execute-pr38533/test.cfg
@@ -0,0 +1,2 @@
+compile(pr38533)
+run(pr38533)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00465-g.torture.execute-pr39120/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00465-g.torture.execute-pr39120/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00465-g.torture.execute-pr39120/pr39120.c b/testsuite/c_test/x64_be_enable_test/GCC00465-g.torture.execute-pr39120/pr39120.c
new file mode 100644
index 0000000000000000000000000000000000000000..8859848007ba03e222f7bfe2cd634b45254908be
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00465-g.torture.execute-pr39120/pr39120.c
@@ -0,0 +1,18 @@
+struct X { int *p; } x;
+
+struct X __attribute__((noinline))
+foo(int *p) { struct X x; x.p = p; return x; }
+
+void __attribute((noinline))
+bar() { *x.p = 1; }
+
+extern void abort (void);
+int main()
+{
+  int i = 0;
+  x = foo(&i);
+  bar();
+  if (i != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00465-g.torture.execute-pr39120/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00465-g.torture.execute-pr39120/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f89a1bdcca0ca9c4a5f3df9c1b666b9e404cae7a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00465-g.torture.execute-pr39120/test.cfg
@@ -0,0 +1,2 @@
+compile(pr39120)
+run(pr39120)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00466-g.torture.execute-pr39339/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00466-g.torture.execute-pr39339/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00466-g.torture.execute-pr39339/pr39339.c b/testsuite/c_test/x64_be_enable_test/GCC00466-g.torture.execute-pr39339/pr39339.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c1b9e72ede0a5a0d2fd61cb7bade14a45923119
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00466-g.torture.execute-pr39339/pr39339.c
@@ -0,0 +1,81 @@
+struct C
+{
+  unsigned int c;
+  struct D
+  {
+    unsigned int columns : 4;
+    unsigned int fore : 12;
+    unsigned int back : 6;
+    unsigned int fragment : 1;
+    unsigned int standout : 1;
+    unsigned int underline : 1;
+    unsigned int strikethrough : 1;
+    unsigned int reverse : 1;
+    unsigned int blink : 1;
+    unsigned int half : 1;
+    unsigned int bold : 1;
+    unsigned int invisible : 1;
+    unsigned int pad : 1;
+  } attr;
+};
+
+struct A
+{
+  struct C *data;
+  unsigned int len;
+};
+
+struct B
+{
+  struct A *cells;
+  unsigned char soft_wrapped : 1;
+};
+
+struct E
+{
+  long row, col;
+  struct C defaults;
+};
+
+__attribute__ ((noinline))
+void foo (struct E *screen, unsigned int c, int columns, struct B *row)
+{
+  struct D attr;
+  long col;
+  int i;
+  col = screen->col;
+  attr = screen->defaults.attr;
+  attr.columns = columns;
+  row->cells->data[col].c = c;
+  row->cells->data[col].attr = attr;
+  col++;
+  attr.fragment = 1;
+  for (i = 1; i < columns; i++)
+    {
+      row->cells->data[col].c = c;
+      row->cells->data[col].attr = attr;
+      col++;
+    }
+}
+
+int
+main (void)
+{
+  struct E e = {.row = 5,.col = 0,.defaults =
+      {6, {-1, -1, -1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0}} };
+  struct C c[4];
+  struct A a = { c, 4 };
+  struct B b = { &a, 1 };
+  struct D d;
+  __builtin_memset (&c, 0, sizeof c);
+  foo (&e, 65, 2, &b);
+  d = e.defaults.attr;
+  d.columns = 2;
+  if (__builtin_memcmp (&d, &c[0].attr, sizeof d))
+    __builtin_abort ();
+  d.fragment = 1;
+  if (__builtin_memcmp (&d, &c[1].attr, sizeof d))
+    __builtin_abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00466-g.torture.execute-pr39339/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00466-g.torture.execute-pr39339/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5a18859b5672b2ef3d37f7adeaab3ce9b4eaf3f7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00466-g.torture.execute-pr39339/test.cfg
@@ -0,0 +1,2 @@
+compile(pr39339)
+run(pr39339)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00467-g.torture.execute-pr40022/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00467-g.torture.execute-pr40022/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00467-g.torture.execute-pr40022/pr40022.c b/testsuite/c_test/x64_be_enable_test/GCC00467-g.torture.execute-pr40022/pr40022.c
new file mode 100644
index 0000000000000000000000000000000000000000..1e8f728ab4438415067610fae652ea79bc6d5a60
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00467-g.torture.execute-pr40022/pr40022.c
@@ -0,0 +1,51 @@
+extern void abort (void);
+
+struct A
+{
+  struct A *a;
+};
+
+struct B
+{
+  struct A *b;
+};
+
+__attribute__((noinline))
+struct A *
+foo (struct A *x)
+{
+  asm volatile ("" : : "g" (x) : "memory");
+  return x;
+}
+
+__attribute__((noinline))
+void
+bar (struct B *w, struct A *x, struct A *y, struct A *z)
+{
+  struct A **c;
+  c = &w->b;
+  *c = foo (x);
+  while (*c)
+    c = &(*c)->a;
+  *c = foo (y);
+  while (*c)
+    c = &(*c)->a;
+  *c = foo (z);
+}
+
+struct B d;
+struct A e, f, g;
+
+int
+main (void)
+{
+  f.a = &g;
+  bar (&d, &e, &f, 0);
+  if (d.b == 0
+      || d.b->a == 0
+      || d.b->a->a == 0
+      || d.b->a->a->a != 0)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00467-g.torture.execute-pr40022/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00467-g.torture.execute-pr40022/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1cc8ee1c72a541abaf0dd1290719ca2b6d90ca81
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00467-g.torture.execute-pr40022/test.cfg
@@ -0,0 +1,2 @@
+compile(pr40022)
+run(pr40022)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00468-g.torture.execute-pr40057/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00468-g.torture.execute-pr40057/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00468-g.torture.execute-pr40057/pr40057.c b/testsuite/c_test/x64_be_enable_test/GCC00468-g.torture.execute-pr40057/pr40057.c
new file mode 100644
index 0000000000000000000000000000000000000000..9d5c4e31e87e2f7be7bf43952ab6552faae50dba
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00468-g.torture.execute-pr40057/pr40057.c
@@ -0,0 +1,37 @@
+/* PR middle-end/40057 */
+
+extern void abort (void);
+
+__attribute__((noinline)) int
+foo (unsigned long long x)
+{
+  unsigned long long y = (x >> 31ULL) & 1ULL;
+  if (y == 0ULL)
+    return 0;
+  return -1;
+}
+
+__attribute__((noinline)) int
+bar (long long x)
+{
+  long long y = (x >> 31LL) & 1LL;
+  if (y == 0LL)
+    return 0;
+  return -1;
+}
+
+int
+main (void)
+{
+  if (sizeof (long long) != 8)
+    return 0;
+  if (foo (0x1682a9aaaULL))
+    abort ();
+  if (!foo (0x1882a9aaaULL))
+    abort ();
+  if (bar (0x1682a9aaaLL))
+    abort ();
+  if (!bar (0x1882a9aaaLL))
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00468-g.torture.execute-pr40057/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00468-g.torture.execute-pr40057/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..abef6472282b2a743ef60fc83e199d47412e1a30
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00468-g.torture.execute-pr40057/test.cfg
@@ -0,0 +1,2 @@
+compile(pr40057)
+run(pr40057)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00469-g.torture.execute-pr40404/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00469-g.torture.execute-pr40404/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00469-g.torture.execute-pr40404/pr40404.c b/testsuite/c_test/x64_be_enable_test/GCC00469-g.torture.execute-pr40404/pr40404.c
new file mode 100644
index 0000000000000000000000000000000000000000..b2e0ea2755c5525846bc407483825bbc176d47d1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00469-g.torture.execute-pr40404/pr40404.c
@@ -0,0 +1,19 @@
+extern void abort (void);
+
+#if (__SIZEOF_INT__ <= 2)
+struct S {
+  unsigned long ui17 : 17;
+} s;
+#else
+struct S {
+  unsigned int ui17 : 17;
+} s;
+#endif
+int main()
+{
+  s.ui17 = 0x1ffff;
+  if (s.ui17 >= 0xfffffffeu)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00469-g.torture.execute-pr40404/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00469-g.torture.execute-pr40404/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..92f5386ff8377727b011cbda8106c871abea1a05
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00469-g.torture.execute-pr40404/test.cfg
@@ -0,0 +1,2 @@
+compile(pr40404)
+run(pr40404)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00470-g.torture.execute-pr40493/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00470-g.torture.execute-pr40493/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00470-g.torture.execute-pr40493/pr40493.c b/testsuite/c_test/x64_be_enable_test/GCC00470-g.torture.execute-pr40493/pr40493.c
new file mode 100644
index 0000000000000000000000000000000000000000..c30786525eaea247d1931a3b9bdb9f3c83b77ed7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00470-g.torture.execute-pr40493/pr40493.c
@@ -0,0 +1,82 @@
+extern void abort (void);
+
+typedef union i386_operand_type
+{
+  struct
+    {
+      unsigned int reg8:1;
+      unsigned int reg16:1;
+      unsigned int reg32:1;
+      unsigned int reg64:1;
+      unsigned int floatreg:1;
+      unsigned int regmmx:1;
+      unsigned int regxmm:1;
+      unsigned int regymm:1;
+      unsigned int control:1;
+      unsigned int debug:1;
+      unsigned int test:1;
+      unsigned int sreg2:1;
+      unsigned int sreg3:1;
+      unsigned int imm1:1;
+      unsigned int imm8:1;
+      unsigned int imm8s:1;
+      unsigned int imm16:1;
+      unsigned int imm32:1;
+      unsigned int imm32s:1;
+      unsigned int imm64:1;
+      unsigned int disp8:1;
+      unsigned int disp16:1;
+      unsigned int disp32:1;
+      unsigned int disp32s:1;
+      unsigned int disp64:1;
+      unsigned int acc:1;
+      unsigned int floatacc:1;
+      unsigned int baseindex:1;
+      unsigned int inoutportreg:1;
+      unsigned int shiftcount:1;
+      unsigned int jumpabsolute:1;
+      unsigned int esseg:1;
+      unsigned int regmem:1;
+      unsigned int mem:1;
+      unsigned int byte:1;
+      unsigned int word:1;
+      unsigned int dword:1;
+      unsigned int fword:1;
+      unsigned int qword:1;
+      unsigned int tbyte:1;
+      unsigned int xmmword:1;
+      unsigned int ymmword:1;
+      unsigned int unspecified:1;
+      unsigned int anysize:1;
+    } bitfield;
+  unsigned int array[2];
+} i386_operand_type;
+
+unsigned int x00, x01, y00, y01;
+
+int main (int argc, char *argv[])
+{
+  i386_operand_type a,b,c,d;
+
+  a.bitfield.reg16 = 1;
+  a.bitfield.imm16 = 0;
+  a.array[1] = 22;
+
+  b = a;
+  x00 = b.array[0];
+  x01 = b.array[1];
+
+  c = b;
+  y00 = c.array[0];
+  y01 = c.array[1];
+
+  d = c;
+  if (d.bitfield.reg16 != 1)
+    abort();
+  if (d.bitfield.imm16 != 0)
+    abort();
+  if (d.array[1] != 22)
+    abort();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00470-g.torture.execute-pr40493/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00470-g.torture.execute-pr40493/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..75be2463d42c38cb5b6aa4dfc115d2b8807ebf4c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00470-g.torture.execute-pr40493/test.cfg
@@ -0,0 +1,2 @@
+compile(pr40493)
+run(pr40493)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00471-g.torture.execute-pr40657/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00471-g.torture.execute-pr40657/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00471-g.torture.execute-pr40657/pr40657.c b/testsuite/c_test/x64_be_enable_test/GCC00471-g.torture.execute-pr40657/pr40657.c
new file mode 100644
index 0000000000000000000000000000000000000000..e6d8dda9f99e8cb8fadaa15cc8a1f769aa03127c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00471-g.torture.execute-pr40657/pr40657.c
@@ -0,0 +1,23 @@
+/* Verify that that Thumb-1 epilogue size optimization does not clobber the
+   return value.  */
+
+long long v = 0x123456789abc;
+
+__attribute__((noinline)) void bar (int *x)
+{
+  asm volatile ("" : "=m" (x) ::);
+}
+
+__attribute__((noinline)) long long foo()
+{
+  int x;
+  bar(&x);
+  return v;
+}
+
+int main ()
+{
+  if (foo () != v)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00471-g.torture.execute-pr40657/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00471-g.torture.execute-pr40657/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50768a0afd93a65e57792ec58f6d94f8d0b778e1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00471-g.torture.execute-pr40657/test.cfg
@@ -0,0 +1,2 @@
+compile(pr40657)
+run(pr40657)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00472-g.torture.execute-pr40668/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00472-g.torture.execute-pr40668/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00472-g.torture.execute-pr40668/pr40668.c b/testsuite/c_test/x64_be_enable_test/GCC00472-g.torture.execute-pr40668/pr40668.c
new file mode 100644
index 0000000000000000000000000000000000000000..b860dd7c9ecced2f000db2408f7d50e39c4f358b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00472-g.torture.execute-pr40668/pr40668.c
@@ -0,0 +1,40 @@
+#if (__SIZEOF_INT__ == 2)
+#define TESTVALUE 0x1234
+#else
+#define TESTVALUE 0x12345678
+#endif
+static void
+foo (unsigned int x, void *p)
+{
+  __builtin_memcpy (p, &x, sizeof x);
+}
+
+void
+bar (int type, void *number)
+{
+  switch (type)
+    {
+    case 1:
+      foo (TESTVALUE, number);
+      break;
+    case 7:
+      foo (0, number);
+      break;
+    case 8:
+      foo (0, number);
+      break;
+    case 9:
+      foo (0, number);
+      break;
+    }
+}
+
+int
+main (void)
+{
+  unsigned int x;
+  bar (1, &x);
+  if (x != TESTVALUE)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00472-g.torture.execute-pr40668/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00472-g.torture.execute-pr40668/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b2457ec6bd0695ace36a46ad40d6e926f9587fa8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00472-g.torture.execute-pr40668/test.cfg
@@ -0,0 +1,2 @@
+compile(pr40668)
+run(pr40668)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00473-g.torture.execute-pr40747/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00473-g.torture.execute-pr40747/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00473-g.torture.execute-pr40747/pr40747.c b/testsuite/c_test/x64_be_enable_test/GCC00473-g.torture.execute-pr40747/pr40747.c
new file mode 100644
index 0000000000000000000000000000000000000000..1c75be3fcc5b4c609efd04e856a61088cac6794c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00473-g.torture.execute-pr40747/pr40747.c
@@ -0,0 +1,22 @@
+/* PR middle-end/40747 */
+
+extern void abort (void);
+
+int
+foo (int i)
+{
+  return (i < 4 && i >= 0) ? i : 4;
+}
+
+int
+main ()
+{
+  if (foo (-1) != 4) abort ();
+  if (foo (0) != 0) abort ();
+  if (foo (1) != 1) abort ();
+  if (foo (2) != 2) abort ();
+  if (foo (3) != 3) abort ();
+  if (foo (4) != 4) abort ();
+  if (foo (5) != 4) abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00473-g.torture.execute-pr40747/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00473-g.torture.execute-pr40747/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a99ea0e9aab643d246a3d8b87e23e432413ad9ba
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00473-g.torture.execute-pr40747/test.cfg
@@ -0,0 +1,2 @@
+compile(pr40747)
+run(pr40747)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00474-g.torture.execute-pr41463/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00474-g.torture.execute-pr41463/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00474-g.torture.execute-pr41463/pr41463.c b/testsuite/c_test/x64_be_enable_test/GCC00474-g.torture.execute-pr41463/pr41463.c
new file mode 100644
index 0000000000000000000000000000000000000000..c410fe0218be09c812e496053e52bc5fe24d4227
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00474-g.torture.execute-pr41463/pr41463.c
@@ -0,0 +1,56 @@
+#include <stdlib.h>
+
+union tree_node;
+
+struct tree_common 
+{
+  int a;
+  long b;
+  long c;
+  void *p;
+  int d;
+};
+
+struct other_tree
+{
+  struct tree_common common;
+  int arr[14];
+};
+
+struct tree_vec
+{
+  struct tree_common common;
+  int length;
+  union tree_node *a[1];
+};
+
+union tree_node
+{
+  struct other_tree othr;
+  struct tree_vec vec;
+};
+
+union tree_node global;
+
+union tree_node * __attribute__((noinline))
+foo (union tree_node *p, int i)
+{
+  union tree_node **q;
+  p->vec.a[i] = (union tree_node *) 0;
+  q = &p->vec.a[1];
+  *q = &global;
+  return p->vec.a[i];
+}
+
+extern void abort (void);
+extern void *malloc (__SIZE_TYPE__);
+
+int
+main()
+{
+  union tree_node *p = malloc (sizeof (union tree_node));
+  if (foo (p, 1) != &global)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00474-g.torture.execute-pr41463/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00474-g.torture.execute-pr41463/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ca9c9d879398f359c1349ba7deead0b4748016f2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00474-g.torture.execute-pr41463/test.cfg
@@ -0,0 +1,2 @@
+compile(pr41463)
+run(pr41463)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00475-g.torture.execute-pr41750/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00475-g.torture.execute-pr41750/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00475-g.torture.execute-pr41750/pr41750.c b/testsuite/c_test/x64_be_enable_test/GCC00475-g.torture.execute-pr41750/pr41750.c
new file mode 100644
index 0000000000000000000000000000000000000000..3f5cb635d16c010e4b3905e3f4861bc1ebf4439b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00475-g.torture.execute-pr41750/pr41750.c
@@ -0,0 +1,68 @@
+/* PR 41750 - IPA-SRA used to pass hash->sgot by value rather than by
+   reference.  */
+
+struct bfd_link_hash_table
+{
+  int hash;
+};
+
+struct foo_link_hash_table
+{
+  struct bfd_link_hash_table root;
+  int *dynobj;
+  int *sgot;
+};
+
+struct foo_link_info
+{
+  struct foo_link_hash_table *hash;
+};
+
+extern void abort (void);
+
+int __attribute__((noinline))
+foo_create_got_section (int *abfd, struct foo_link_info *info)
+{
+  info->hash->sgot = abfd;
+  return 1;
+}
+
+static int *
+get_got (int *abfd, struct foo_link_info *info,
+	 struct foo_link_hash_table *hash)
+{
+  int *got;
+  int *dynobj;
+
+  got = hash->sgot;
+  if (!got)
+    {
+      dynobj = hash->dynobj;
+      if (!dynobj)
+	hash->dynobj = dynobj = abfd;
+      if (!foo_create_got_section (dynobj, info))
+	return 0;
+      got = hash->sgot;
+    }
+  return got;
+}
+
+int * __attribute__((noinline,noclone))
+elf64_ia64_check_relocs (int *abfd, struct foo_link_info *info)
+{
+  return get_got (abfd, info, info->hash);
+}
+
+struct foo_link_info link_info;
+struct foo_link_hash_table hash;
+int abfd;
+
+int
+main ()
+{
+  link_info.hash = &hash;
+  if (elf64_ia64_check_relocs (&abfd, &link_info) != &abfd)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00475-g.torture.execute-pr41750/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00475-g.torture.execute-pr41750/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4a2319c2755286087d9bc3228871adb993096593
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00475-g.torture.execute-pr41750/test.cfg
@@ -0,0 +1,2 @@
+compile(pr41750)
+run(pr41750)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00476-g.torture.execute-pr42006/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00476-g.torture.execute-pr42006/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00476-g.torture.execute-pr42006/pr42006.c b/testsuite/c_test/x64_be_enable_test/GCC00476-g.torture.execute-pr42006/pr42006.c
new file mode 100644
index 0000000000000000000000000000000000000000..f40fc179659185ac1cfacf6d86da470c4018f2ae
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00476-g.torture.execute-pr42006/pr42006.c
@@ -0,0 +1,33 @@
+extern void abort (void);
+
+static unsigned int
+my_add(unsigned int si1, unsigned int si2)
+{
+  return (si1 > (50-si2)) ? si1 : (si1 + si2);
+}
+
+static unsigned int
+my_shift(unsigned int left, unsigned int right)
+{
+  return  (right > 100) ? left : (left >> right);
+}
+
+static int func_4(unsigned int p_6)
+{
+  int count = 0;
+  for (p_6 = 1; p_6 < 3; p_6 = my_add(p_6, 1))
+    {
+      if (count++ > 1)
+	abort ();
+
+      if (my_shift(p_6, p_6))
+	return 0;
+    }
+  return 0;
+}
+
+int main(void)
+{
+  func_4(0);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00476-g.torture.execute-pr42006/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00476-g.torture.execute-pr42006/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..099342aa739f32cf2d2234c4d3405c46dde96c56
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00476-g.torture.execute-pr42006/test.cfg
@@ -0,0 +1,2 @@
+compile(pr42006)
+run(pr42006)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00477-g.torture.execute-pr42142/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00477-g.torture.execute-pr42142/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00477-g.torture.execute-pr42142/pr42142.c b/testsuite/c_test/x64_be_enable_test/GCC00477-g.torture.execute-pr42142/pr42142.c
new file mode 100644
index 0000000000000000000000000000000000000000..43cf57e7b308ae7cfcf8597c66aa23e8247f9991
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00477-g.torture.execute-pr42142/pr42142.c
@@ -0,0 +1,26 @@
+int __attribute__((noinline,noclone))
+sort(int L)
+{
+  int end[2] = { 10, 10, }, i=0, R;
+  while (i<2)
+    {
+      R = end[i];
+      if (L<R)
+        {
+          end[i+1] = 1;
+          end[i] = 10;
+          ++i;
+        }
+      else
+        break;
+    }
+  return i;
+}
+extern void abort (void);
+int main()
+{
+  if (sort (5) != 1)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00477-g.torture.execute-pr42142/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00477-g.torture.execute-pr42142/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d5c575abeb268c9cb7db4aa81b60e71a34ee110
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00477-g.torture.execute-pr42142/test.cfg
@@ -0,0 +1,2 @@
+compile(pr42142)
+run(pr42142)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00478-g.torture.execute-pr42231/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00478-g.torture.execute-pr42231/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00478-g.torture.execute-pr42231/pr42231.c b/testsuite/c_test/x64_be_enable_test/GCC00478-g.torture.execute-pr42231/pr42231.c
new file mode 100644
index 0000000000000000000000000000000000000000..2e46f5f3604230d5105fc08dad886435b42a3a9e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00478-g.torture.execute-pr42231/pr42231.c
@@ -0,0 +1,35 @@
+extern void abort (void);
+
+static max;
+
+static void __attribute__((noinline)) storemax (int i)
+{
+  if (i > max)
+    max = i;
+}
+
+static int CallFunctionRec(int (*fun)(int depth), int depth) {
+  if (!fun(depth)) {
+    return 0;
+  }
+  if (depth < 10) {
+    CallFunctionRec(fun, depth + 1);
+  }
+  return 1;
+}
+
+static int CallFunction(int (*fun)(int depth)) {
+  return CallFunctionRec(fun, 1) && !fun(0);
+}
+
+static int callback(int depth) {
+  storemax (depth);
+  return depth != 0;
+}
+
+int main() {
+  CallFunction(callback);
+  if (max != 10)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00478-g.torture.execute-pr42231/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00478-g.torture.execute-pr42231/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7209ec4e5d9da28eb6a3556d86ba8da126ae026e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00478-g.torture.execute-pr42231/test.cfg
@@ -0,0 +1,2 @@
+compile(pr42231)
+run(pr42231)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00479-g.torture.execute-pr42570/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00479-g.torture.execute-pr42570/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00479-g.torture.execute-pr42570/pr42570.c b/testsuite/c_test/x64_be_enable_test/GCC00479-g.torture.execute-pr42570/pr42570.c
new file mode 100644
index 0000000000000000000000000000000000000000..99a8d8072867b8f957e82c582f811c4c492b5f71
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00479-g.torture.execute-pr42570/pr42570.c
@@ -0,0 +1,9 @@
+typedef unsigned char uint8_t;
+uint8_t foo[1][0];
+extern void abort (void);
+int main()
+{
+  if (sizeof (foo) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00479-g.torture.execute-pr42570/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00479-g.torture.execute-pr42570/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b9bf989bccd50087a6f8f85be4a6f065eb9fc744
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00479-g.torture.execute-pr42570/test.cfg
@@ -0,0 +1,2 @@
+compile(pr42570)
+run(pr42570)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00480-g.torture.execute-pr42614/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00480-g.torture.execute-pr42614/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00480-g.torture.execute-pr42614/pr42614.c b/testsuite/c_test/x64_be_enable_test/GCC00480-g.torture.execute-pr42614/pr42614.c
new file mode 100644
index 0000000000000000000000000000000000000000..d3680539bdceb29dd5b21e726850461b975fca70
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00480-g.torture.execute-pr42614/pr42614.c
@@ -0,0 +1,68 @@
+extern void *malloc(__SIZE_TYPE__);
+extern void abort(void);
+extern void free(void *);
+
+typedef struct SEntry
+{
+  unsigned char num;
+} TEntry;
+
+typedef struct STable
+{
+  TEntry data[2];
+} TTable;
+
+TTable *init ()
+{
+  return malloc(sizeof(TTable));
+}
+
+void
+expect_func (int a, unsigned char *b) __attribute__ ((noinline));
+
+static inline void
+inlined_wrong (TEntry *entry_p, int flag);
+
+void
+inlined_wrong (TEntry *entry_p, int flag)
+{
+  unsigned char index;
+  entry_p->num = 0;
+
+  if (flag == 0)
+    abort();
+
+  for (index = 0; index < 1; index++)
+    entry_p->num++;
+
+  if (!entry_p->num)
+    {
+      abort();
+    }
+}
+
+void
+expect_func (int a, unsigned char *b)
+{
+  if (abs ((a == 0)))
+    abort ();
+  if (abs ((b == 0)))
+    abort ();
+}
+
+int
+main ()
+{
+  unsigned char index = 0;
+  TTable *table_p = init();
+  TEntry work;
+
+  inlined_wrong (&(table_p->data[1]), 1);
+  expect_func (1, &index);
+  inlined_wrong (&work, 1);
+
+  free (table_p);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00480-g.torture.execute-pr42614/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00480-g.torture.execute-pr42614/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d8e85d1ed1c63bbca025344da6252d8aebef7aba
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00480-g.torture.execute-pr42614/test.cfg
@@ -0,0 +1,2 @@
+compile(pr42614)
+run(pr42614)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00481-g.torture.execute-pr43008/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00481-g.torture.execute-pr43008/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00481-g.torture.execute-pr43008/pr43008.c b/testsuite/c_test/x64_be_enable_test/GCC00481-g.torture.execute-pr43008/pr43008.c
new file mode 100644
index 0000000000000000000000000000000000000000..81b670b291c62e55a9afee4d3588347446a6bade
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00481-g.torture.execute-pr43008/pr43008.c
@@ -0,0 +1,23 @@
+int i;
+struct X {
+  int *p;
+};
+struct X * __attribute__((malloc))
+my_alloc (void)
+{
+  struct X *p = malloc (sizeof (struct X));
+  p->p = &i;
+  return p;
+}
+extern void abort (void);
+int main()
+{
+  struct X *p, *q;
+  p = my_alloc ();
+  q = my_alloc ();
+  *(p->p) = 1;
+  *(q->p) = 0;
+  if (*(p->p) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00481-g.torture.execute-pr43008/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00481-g.torture.execute-pr43008/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dca475604d1d06c3cbdbffcc353ed89fd400097d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00481-g.torture.execute-pr43008/test.cfg
@@ -0,0 +1,2 @@
+compile(pr43008)
+run(pr43008)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00482-g.torture.execute-pr43236/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00482-g.torture.execute-pr43236/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00482-g.torture.execute-pr43236/pr43236.c b/testsuite/c_test/x64_be_enable_test/GCC00482-g.torture.execute-pr43236/pr43236.c
new file mode 100644
index 0000000000000000000000000000000000000000..0401c88a3dcc27974ea03bba8d2fc2922db9b637
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00482-g.torture.execute-pr43236/pr43236.c
@@ -0,0 +1,32 @@
+/* { dg-options "-ftree-loop-distribution" } */
+extern void abort(void);
+extern void *memset(void *s, int c, __SIZE_TYPE__ n);
+extern int memcmp(const void *s1, const void *s2, __SIZE_TYPE__ n);
+/*extern int printf(const char *format, ...);*/
+
+int main()
+{
+  char A[30], B[30], C[30];
+  int i;
+
+  /* prepare arrays */
+  memset(A, 1, 30);
+  memset(B, 1, 30);
+
+  for (i = 20; i-- > 10;) {
+    A[i] = 0;
+    B[i] = 0;
+  }
+
+  /* expected result */
+  memset(C, 1, 30);
+  memset(C + 10, 0, 10);
+
+  /* show result */
+/*  for (i = 0; i < 30; i++)
+    printf("%d %d %d\n", A[i], B[i], C[i]); */
+
+  /* compare results */
+  if (memcmp(A, C, 30) || memcmp(B, C, 30)) abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00482-g.torture.execute-pr43236/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00482-g.torture.execute-pr43236/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b95ffda2455bf98925b18ab3e5e2c7badfe3eecf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00482-g.torture.execute-pr43236/test.cfg
@@ -0,0 +1,2 @@
+compile(pr43236)
+run(pr43236)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00483-g.torture.execute-pr43269/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00483-g.torture.execute-pr43269/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00483-g.torture.execute-pr43269/pr43269.c b/testsuite/c_test/x64_be_enable_test/GCC00483-g.torture.execute-pr43269/pr43269.c
new file mode 100644
index 0000000000000000000000000000000000000000..9f599a2dd5d4cc85d94f298f6d7c8a0e308478ab
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00483-g.torture.execute-pr43269/pr43269.c
@@ -0,0 +1,31 @@
+int g_21;
+int g_211;
+int g_261;
+
+static void __attribute__((noinline,noclone))
+func_32 (int b)
+{
+  if (b) {
+lbl_370:
+      g_21 = 1;
+  }
+
+  for (g_261 = -1; g_261 > -2; g_261--) {
+      if (g_211 + 1) {
+	  return;
+      } else {
+	  g_21 = 1;
+	  goto lbl_370;
+      }
+  }
+}
+
+extern void abort (void);
+
+int main(void)
+{
+  func_32(0);
+  if (g_261 != -1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00483-g.torture.execute-pr43269/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00483-g.torture.execute-pr43269/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..328114b0bac1a852e2993746886424b095cc999e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00483-g.torture.execute-pr43269/test.cfg
@@ -0,0 +1,2 @@
+compile(pr43269)
+run(pr43269)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00484-g.torture.execute-pr43385/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00484-g.torture.execute-pr43385/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00484-g.torture.execute-pr43385/pr43385.c b/testsuite/c_test/x64_be_enable_test/GCC00484-g.torture.execute-pr43385/pr43385.c
new file mode 100644
index 0000000000000000000000000000000000000000..eeb9096a8e597f6cdd0ee894af98ae13fd3b1822
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00484-g.torture.execute-pr43385/pr43385.c
@@ -0,0 +1,59 @@
+/* PR c/43385 */
+
+extern void abort (void);
+
+int e;
+
+__attribute__((noinline)) void
+foo (int x, int y)
+{
+  if (__builtin_expect (x, 0) && y != 0)
+    e++;
+}
+
+__attribute__((noinline)) int
+bar (int x, int y)
+{
+  if (__builtin_expect (x, 0) && y != 0)
+    return 1;
+  else
+    return 0;
+}
+
+int
+main (void)
+{
+  int z = 0;
+  asm ("" : "+r" (z));
+  foo (z + 2, z + 1);
+  if (e != 1)
+    abort ();
+  foo (z + 2, z);
+  if (e != 1)
+    abort ();
+  foo (z + 1, z + 1);
+  if (e != 2)
+    abort ();
+  foo (z + 1, z);
+  if (e != 2)
+    abort ();
+  foo (z, z + 1);
+  if (e != 2)
+    abort ();
+  foo (z, z);
+  if (e != 2)
+    abort ();
+  if (bar (z + 2, z + 1) != 1)
+    abort ();
+  if (bar (z + 2, z) != 0)
+    abort ();
+  if (bar (z + 1, z + 1) != 1)
+    abort ();
+  if (bar (z + 1, z) != 0)
+    abort ();
+  if (bar (z, z + 1) != 0)
+    abort ();
+  if (bar (z, z) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00484-g.torture.execute-pr43385/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00484-g.torture.execute-pr43385/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e0fd3877bf89478b4034f208ee68828791a89d1e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00484-g.torture.execute-pr43385/test.cfg
@@ -0,0 +1,2 @@
+compile(pr43385)
+run(pr43385)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00485-g.torture.execute-pr43438/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00485-g.torture.execute-pr43438/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00485-g.torture.execute-pr43438/pr43438.c b/testsuite/c_test/x64_be_enable_test/GCC00485-g.torture.execute-pr43438/pr43438.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa901ce0f9046fbe4adb43a2695a602d37b17cdd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00485-g.torture.execute-pr43438/pr43438.c
@@ -0,0 +1,23 @@
+extern void abort (void);
+
+static unsigned char g_2 = 1;
+static int g_9;
+static int *l_8 = &g_9;
+
+static void func_12(int p_13)
+{
+  int * l_17 = &g_9;
+  *l_17 &= 0 < p_13;
+}
+
+int main(void)
+{
+  unsigned char l_11 = 254;
+  *l_8 |= g_2;
+  l_11 |= *l_8;
+  func_12(l_11);
+  if (g_9 != 1)
+    abort ();
+  return 0;
+} 
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00485-g.torture.execute-pr43438/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00485-g.torture.execute-pr43438/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d39a6b5fa556db1324b13ac90bf4164ba0cad81d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00485-g.torture.execute-pr43438/test.cfg
@@ -0,0 +1,2 @@
+compile(pr43438)
+run(pr43438)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00486-g.torture.execute-pr43629/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00486-g.torture.execute-pr43629/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00486-g.torture.execute-pr43629/pr43629.c b/testsuite/c_test/x64_be_enable_test/GCC00486-g.torture.execute-pr43629/pr43629.c
new file mode 100644
index 0000000000000000000000000000000000000000..10c0196c89bde7d46cf78ffd394ba56783856c26
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00486-g.torture.execute-pr43629/pr43629.c
@@ -0,0 +1,13 @@
+int flag;
+extern void abort (void);
+int main()
+{
+  int x;
+  if (flag)
+    x = -1;
+  else 
+    x &= 0xff;
+  if (x & ~0xff)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00486-g.torture.execute-pr43629/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00486-g.torture.execute-pr43629/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..29d509d38614f2971c3e912c206197fb8419918e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00486-g.torture.execute-pr43629/test.cfg
@@ -0,0 +1,2 @@
+compile(pr43629)
+run(pr43629)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00487-g.torture.execute-pr43784/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00487-g.torture.execute-pr43784/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00487-g.torture.execute-pr43784/pr43784.c b/testsuite/c_test/x64_be_enable_test/GCC00487-g.torture.execute-pr43784/pr43784.c
new file mode 100644
index 0000000000000000000000000000000000000000..622232725a278903fde574760f08e419b71c9cc7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00487-g.torture.execute-pr43784/pr43784.c
@@ -0,0 +1,33 @@
+struct s {
+  unsigned char a[256];
+};
+union u {
+  struct { struct s b; int c; } d;
+  struct { int c; struct s b; } e;
+};
+
+static union u v;
+static struct s *p = &v.d.b;
+static struct s *q = &v.e.b;
+
+static struct s __attribute__((noinline)) rp(void)
+{
+  return *p;
+}
+
+static void qp(void)
+{
+  *q = rp();
+}
+
+int main()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    p->a[i] = i;
+  qp();
+  for (i = 0; i < 256; i++)
+    if (q->a[i] != i)
+      __builtin_abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00487-g.torture.execute-pr43784/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00487-g.torture.execute-pr43784/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..37930f716554bea481a81c238e253444702ecccc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00487-g.torture.execute-pr43784/test.cfg
@@ -0,0 +1,2 @@
+compile(pr43784)
+run(pr43784)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00488-g.torture.execute-pr43987/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00488-g.torture.execute-pr43987/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00488-g.torture.execute-pr43987/pr43987.c b/testsuite/c_test/x64_be_enable_test/GCC00488-g.torture.execute-pr43987/pr43987.c
new file mode 100644
index 0000000000000000000000000000000000000000..ee41bdf2717fd8103b295d83f3706e779ad0bcad
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00488-g.torture.execute-pr43987/pr43987.c
@@ -0,0 +1,20 @@
+char B[256 * sizeof(void *)];
+typedef void *FILE;
+typedef struct globals {
+    int c;
+    FILE *l;
+} __attribute__((may_alias)) T;
+void add_input_file(FILE *file)
+{
+  (*(T*)&B).l[0] = file;
+}
+extern void abort (void);
+int main()
+{
+  FILE x;
+  (*(T*)&B).l = &x;
+  add_input_file ((void *)-1);
+  if ((*(T*)&B).l[0] != (void *)-1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00488-g.torture.execute-pr43987/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00488-g.torture.execute-pr43987/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5ed124375824f2c9b06dfadfb4815e9f32f9a38d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00488-g.torture.execute-pr43987/test.cfg
@@ -0,0 +1,2 @@
+compile(pr43987)
+run(pr43987)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00489-g.torture.execute-pr44164/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00489-g.torture.execute-pr44164/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00489-g.torture.execute-pr44164/pr44164.c b/testsuite/c_test/x64_be_enable_test/GCC00489-g.torture.execute-pr44164/pr44164.c
new file mode 100644
index 0000000000000000000000000000000000000000..171f9c39f59760a98f2c81d8303a9791919cc3a1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00489-g.torture.execute-pr44164/pr44164.c
@@ -0,0 +1,24 @@
+struct X {
+    struct Y {
+	struct YY {
+	    struct Z {
+		int i;
+	    } c;
+	} bb;
+    } b;
+} a;
+int __attribute__((noinline, noclone))
+foo (struct Z *p)
+{
+  int i = p->i;
+  a.b = (struct Y){};
+  return p->i + i;
+}
+extern void abort (void);
+int main()
+{
+  a.b.bb.c.i = 1;
+  if (foo (&a.b.bb.c) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00489-g.torture.execute-pr44164/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00489-g.torture.execute-pr44164/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e6016515a1518b2fc5765d8bd8dda7526065363
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00489-g.torture.execute-pr44164/test.cfg
@@ -0,0 +1,2 @@
+compile(pr44164)
+run(pr44164)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00490-g.torture.execute-pr44202-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00490-g.torture.execute-pr44202-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00490-g.torture.execute-pr44202-1/pr44202-1.c b/testsuite/c_test/x64_be_enable_test/GCC00490-g.torture.execute-pr44202-1/pr44202-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..37e84f2fc377631f7ca986c7f3dfce92c8da4e92
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00490-g.torture.execute-pr44202-1/pr44202-1.c
@@ -0,0 +1,30 @@
+extern __attribute__ ((__noreturn__)) void exit(int);
+extern __attribute__ ((__noreturn__)) void abort(void);
+__attribute__ ((__noinline__))
+int
+add512(int a, int *b)
+{
+  int c = a + 512;
+  if (c != 0)
+    *b = a;
+  return c;
+}
+
+__attribute__ ((__noinline__))
+int
+add513(int a, int *b)
+{
+  int c = a + 513;
+  if (c == 0)
+    *b = a;
+  return c;
+}
+
+int main(void)
+{
+  int b0 = -1;
+  int b1 = -1;
+  if (add512(-512, &b0) != 0 || b0 != -1 || add513(-513, &b1) != 0 || b1 != -513)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00490-g.torture.execute-pr44202-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00490-g.torture.execute-pr44202-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6468dfe31f59e057d7b77bb7f586d7809692bb79
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00490-g.torture.execute-pr44202-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr44202-1)
+run(pr44202-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00491-g.torture.execute-pr44468/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00491-g.torture.execute-pr44468/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00491-g.torture.execute-pr44468/pr44468.c b/testsuite/c_test/x64_be_enable_test/GCC00491-g.torture.execute-pr44468/pr44468.c
new file mode 100644
index 0000000000000000000000000000000000000000..c4bd492656d474ee404126e7f32856d64dd87caf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00491-g.torture.execute-pr44468/pr44468.c
@@ -0,0 +1,60 @@
+#include <stddef.h>
+
+struct S {
+  int i;
+  int j;
+};
+struct R {
+  int k;
+  struct S a;
+};
+struct Q {
+  float k;
+  struct S a;
+};
+struct Q s;
+int __attribute__((noinline,noclone))
+test1 (void *q)
+{
+  struct S *b = (struct S *)((char *)q + sizeof (int));
+  s.a.i = 0;
+  b->i = 3;
+  return s.a.i;
+}
+int __attribute__((noinline,noclone))
+test2 (void *q)
+{
+  struct S *b = &((struct R *)q)->a;
+  s.a.i = 0;
+  b->i = 3;
+  return s.a.i;
+}
+int __attribute__((noinline,noclone))
+test3 (void *q)
+{
+  s.a.i = 0;
+  ((struct S *)((char *)q + sizeof (int)))->i = 3;
+  return s.a.i;
+}
+extern void abort (void);
+int
+main()
+{
+  if (sizeof (float) != sizeof (int)
+      || offsetof (struct R, a) != sizeof (int)
+      || offsetof (struct Q, a) != sizeof (int))
+    return 0;
+  s.a.i = 1;
+  s.a.j = 2;
+  if (test1 ((void *)&s) != 3)
+    abort ();
+  s.a.i = 1;
+  s.a.j = 2;
+  if (test2 ((void *)&s) != 3)
+    abort ();
+  s.a.i = 1;
+  s.a.j = 2;
+  if (test3 ((void *)&s) != 3)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00491-g.torture.execute-pr44468/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00491-g.torture.execute-pr44468/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5134e65f9deb2f55f139638284549ae965c19a46
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00491-g.torture.execute-pr44468/test.cfg
@@ -0,0 +1,2 @@
+compile(pr44468)
+run(pr44468)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00492-g.torture.execute-pr44555/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00492-g.torture.execute-pr44555/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00492-g.torture.execute-pr44555/pr44555.c b/testsuite/c_test/x64_be_enable_test/GCC00492-g.torture.execute-pr44555/pr44555.c
new file mode 100644
index 0000000000000000000000000000000000000000..6ba8e491971dc66b6412eaf0f8ac7a6cb377dc7c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00492-g.torture.execute-pr44555/pr44555.c
@@ -0,0 +1,16 @@
+struct a {
+    char b[100];
+};
+int foo(struct a *a)
+{
+  if (&a->b)
+    return 1;
+  return 0;
+}
+extern void abort (void);
+int main()
+{
+  if (foo((struct a *)0) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00492-g.torture.execute-pr44555/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00492-g.torture.execute-pr44555/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68c9e50b62b9c6e8c3e5181849ee0a3e5e3cb595
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00492-g.torture.execute-pr44555/test.cfg
@@ -0,0 +1,2 @@
+compile(pr44555)
+run(pr44555)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00493-g.torture.execute-pr46309/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00493-g.torture.execute-pr46309/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00493-g.torture.execute-pr46309/pr46309.c b/testsuite/c_test/x64_be_enable_test/GCC00493-g.torture.execute-pr46309/pr46309.c
new file mode 100644
index 0000000000000000000000000000000000000000..46e10ab4bf43a0e090c268c7585b4dbefa0897b6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00493-g.torture.execute-pr46309/pr46309.c
@@ -0,0 +1,31 @@
+/* PR tree-optimization/46309 */
+
+extern void abort (void);
+
+unsigned int *q;
+
+__attribute__((noinline, noclone)) void
+bar (unsigned int *p)
+{
+  if (*p != 2 && *p != 3)
+    (!(!(*q & 263) || *p != 1)) ? abort () : 0;
+}
+
+int
+main ()
+{
+  unsigned int x, y;
+  asm volatile ("" : : : "memory");
+  x = 2;
+  bar (&x);
+  x = 3;
+  bar (&x);
+  y = 1;
+  x = 0;
+  q = &y;
+  bar (&x);
+  y = 0;
+  x = 1;
+  bar (&x);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00493-g.torture.execute-pr46309/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00493-g.torture.execute-pr46309/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd52b321b307a45bff5e89af4e4dacf11277af6e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00493-g.torture.execute-pr46309/test.cfg
@@ -0,0 +1,2 @@
+compile(pr46309)
+run(pr46309)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00494-g.torture.execute-pr46316/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00494-g.torture.execute-pr46316/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00494-g.torture.execute-pr46316/pr46316.c b/testsuite/c_test/x64_be_enable_test/GCC00494-g.torture.execute-pr46316/pr46316.c
new file mode 100644
index 0000000000000000000000000000000000000000..7aafaa740ba9732651cdf01079c6a73302d5f04e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00494-g.torture.execute-pr46316/pr46316.c
@@ -0,0 +1,17 @@
+extern void abort (void);
+
+long long __attribute__((noinline,noclone))
+foo (long long t)
+{
+  while (t > -4)
+    t -= 2;
+
+  return t;
+}
+
+int main(void)
+{
+  if (foo (0) != -4)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00494-g.torture.execute-pr46316/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00494-g.torture.execute-pr46316/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b6de008d75dee8ad85778bbc048d0497f9fe00f2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00494-g.torture.execute-pr46316/test.cfg
@@ -0,0 +1,2 @@
+compile(pr46316)
+run(pr46316)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00495-g.torture.execute-pr46909-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00495-g.torture.execute-pr46909-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00495-g.torture.execute-pr46909-1/pr46909-1.c b/testsuite/c_test/x64_be_enable_test/GCC00495-g.torture.execute-pr46909-1/pr46909-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c6c92fcbb1e1d4445522b37bfff14f52a8c08b05
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00495-g.torture.execute-pr46909-1/pr46909-1.c
@@ -0,0 +1,22 @@
+/* PR tree-optimization/46909 */
+
+extern void abort ();
+
+int
+__attribute__ ((__noinline__))
+foo (unsigned int x)
+{
+  if (! (x == 4 || x == 6) || (x == 2 || x == 6))
+    return 1;
+  return -1;
+}
+
+int
+main ()
+{
+  int i;
+  for (i = -10; i < 10; i++)
+    if (foo (i) != 1 - 2 * (i == 4))
+      abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00495-g.torture.execute-pr46909-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00495-g.torture.execute-pr46909-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fd16c9799069c564b8de0ec8003a9215733e2c14
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00495-g.torture.execute-pr46909-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr46909-1)
+run(pr46909-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00496-g.torture.execute-pr46909-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00496-g.torture.execute-pr46909-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00496-g.torture.execute-pr46909-2/pr46909-2.c b/testsuite/c_test/x64_be_enable_test/GCC00496-g.torture.execute-pr46909-2/pr46909-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..33da2189c447a78e91235aa3d18021beefc0a3ca
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00496-g.torture.execute-pr46909-2/pr46909-2.c
@@ -0,0 +1,22 @@
+/* PR tree-optimization/46909 */
+
+extern void abort (void);
+
+int
+__attribute__((noinline))
+foo (int x)
+{
+  if ((x != 0 && x != 13) || x == 5 || x == 20)
+    return 1;
+  return -1;
+}
+
+int
+main (void)
+{
+  int i;
+  for (i = -10; i < 30; i++)
+    if (foo (i) != 1 - 2 * (i == 0) - 2 * (i == 13))
+      abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00496-g.torture.execute-pr46909-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00496-g.torture.execute-pr46909-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2e27620b0123f90db701a8a0b423511921716f1c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00496-g.torture.execute-pr46909-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr46909-2)
+run(pr46909-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00497-g.torture.execute-pr47925/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00497-g.torture.execute-pr47925/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00497-g.torture.execute-pr47925/pr47925.c b/testsuite/c_test/x64_be_enable_test/GCC00497-g.torture.execute-pr47925/pr47925.c
new file mode 100644
index 0000000000000000000000000000000000000000..89f54c13a55028b0d89d7f9304a382eef62d848a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00497-g.torture.execute-pr47925/pr47925.c
@@ -0,0 +1,24 @@
+struct s { volatile struct s *next; };
+
+void __attribute__((noinline))
+bar (int ignored, int n)
+{
+  asm volatile ("");
+}
+
+int __attribute__((noinline))
+foo (volatile struct s *ptr, int n)
+{
+  int i;
+
+  bar (0, n);
+  for (i = 0; i < n; i++)
+    ptr = ptr->next;
+}
+
+int main (void)
+{
+  volatile struct s rec = { &rec };
+  foo (&rec, 10);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00497-g.torture.execute-pr47925/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00497-g.torture.execute-pr47925/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ed529e0ecc8e28a541c656a06fc64f581c77ee64
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00497-g.torture.execute-pr47925/test.cfg
@@ -0,0 +1,2 @@
+compile(pr47925)
+run(pr47925)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00498-g.torture.execute-pr48571-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00498-g.torture.execute-pr48571-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00498-g.torture.execute-pr48571-1/pr48571-1.c b/testsuite/c_test/x64_be_enable_test/GCC00498-g.torture.execute-pr48571-1/pr48571-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..06ac103601c116960b88544fba27e54a50fc0ba5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00498-g.torture.execute-pr48571-1/pr48571-1.c
@@ -0,0 +1,30 @@
+#define S (sizeof (int))
+
+unsigned int c[624];
+void __attribute__((noinline))
+bar (void)
+{
+  unsigned int i;
+  /* Obfuscated c[i] = c[i-1] * 2.  */
+  for (i = 1; i < 624; ++i)
+    *(unsigned int *)((void *)c + (__SIZE_TYPE__)i * S)
+	= 2 * *(unsigned int *)((void *)c + ((__SIZE_TYPE__)i +
+					     ((__SIZE_TYPE__)-S)/S) * S);
+}
+extern void abort (void);
+int
+main()
+{
+  unsigned int i, j;
+  for (i = 0; i < 624; ++i)
+    c[i] = 1;
+  bar();
+  j = 1;
+  for (i = 0; i < 624; ++i)
+    {
+      if (c[i] != j)
+	abort ();
+      j = j * 2;
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00498-g.torture.execute-pr48571-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00498-g.torture.execute-pr48571-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cd6169078d9b32943aa9d90ff3423a2176f69521
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00498-g.torture.execute-pr48571-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr48571-1)
+run(pr48571-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00499-g.torture.execute-pr48814-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00499-g.torture.execute-pr48814-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00499-g.torture.execute-pr48814-1/pr48814-1.c b/testsuite/c_test/x64_be_enable_test/GCC00499-g.torture.execute-pr48814-1/pr48814-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..452aaab30f9593d1116d3d94d7c9b0f46fc76468
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00499-g.torture.execute-pr48814-1/pr48814-1.c
@@ -0,0 +1,18 @@
+extern void abort (void);
+
+int arr[] = {1,2,3,4};
+int count = 0;
+
+int __attribute__((noinline))
+incr (void)
+{
+  return ++count;
+}
+
+int main()
+{
+  arr[count++] = incr ();
+  if (count != 2 || arr[count] != 3)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00499-g.torture.execute-pr48814-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00499-g.torture.execute-pr48814-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eaeb0a71150bf2d10591aa52a1b2aea1c5a711a8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00499-g.torture.execute-pr48814-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr48814-1)
+run(pr48814-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00500-g.torture.execute-pr48814-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00500-g.torture.execute-pr48814-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00500-g.torture.execute-pr48814-2/pr48814-2.c b/testsuite/c_test/x64_be_enable_test/GCC00500-g.torture.execute-pr48814-2/pr48814-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..9eea3289ab1a594fb254642f08239acf480eff5b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00500-g.torture.execute-pr48814-2/pr48814-2.c
@@ -0,0 +1,18 @@
+extern void abort (void);
+
+int arr[] = {1,2,3,4};
+int count = 0;
+
+int
+incr (void)
+{
+  return ++count;
+}
+
+int main()
+{
+  arr[count++] = incr ();
+  if (count != 2 || arr[count] != 3)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00500-g.torture.execute-pr48814-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00500-g.torture.execute-pr48814-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..15f06a7f5741fcdd9a0648d040c0a02504e76fba
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00500-g.torture.execute-pr48814-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr48814-2)
+run(pr48814-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00501-g.torture.execute-pr49039/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00501-g.torture.execute-pr49039/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00501-g.torture.execute-pr49039/pr49039.c b/testsuite/c_test/x64_be_enable_test/GCC00501-g.torture.execute-pr49039/pr49039.c
new file mode 100644
index 0000000000000000000000000000000000000000..546d114fedcb2d54c3843745eb15496c8e70addc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00501-g.torture.execute-pr49039/pr49039.c
@@ -0,0 +1,26 @@
+/* PR tree-optimization/49039 */
+extern void abort (void);
+int cnt;
+
+__attribute__((noinline, noclone)) void
+foo (unsigned int x, unsigned int y)
+{
+  unsigned int minv, maxv;
+  if (x == 1 || y == -2U)
+    return;
+  minv = x < y ? x : y;
+  maxv = x > y ? x : y;
+  if (minv == 1)
+    ++cnt;
+  if (maxv == -2U)
+    ++cnt;
+}
+
+int
+main ()
+{
+  foo (-2U, 1);
+  if (cnt != 2)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00501-g.torture.execute-pr49039/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00501-g.torture.execute-pr49039/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b6c4a20a1dd972b52ec23365e1ebb2361d107bed
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00501-g.torture.execute-pr49039/test.cfg
@@ -0,0 +1,2 @@
+compile(pr49039)
+run(pr49039)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00502-g.torture.execute-pr49073/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00502-g.torture.execute-pr49073/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00502-g.torture.execute-pr49073/pr49073.c b/testsuite/c_test/x64_be_enable_test/GCC00502-g.torture.execute-pr49073/pr49073.c
new file mode 100644
index 0000000000000000000000000000000000000000..92b923b8258981075d78680d3fc4dc5442ad00f4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00502-g.torture.execute-pr49073/pr49073.c
@@ -0,0 +1,26 @@
+/* PR tree-optimization/49073 */
+
+extern void abort (void);
+int a[] = { 1, 2, 3, 4, 5, 6, 7 }, c;
+
+int
+main ()
+{
+  int d = 1, i = 1;
+  _Bool f = 0;
+  do
+    {
+      d = a[i];
+      if (f && d == 4)
+	{
+	  ++c;
+	  break;
+	}
+      i++;
+      f = (d == 3);
+    }
+  while (d < 7);
+  if (c != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00502-g.torture.execute-pr49073/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00502-g.torture.execute-pr49073/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1df4839bbf389e97944410384b05113dd7b61fb1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00502-g.torture.execute-pr49073/test.cfg
@@ -0,0 +1,2 @@
+compile(pr49073)
+run(pr49073)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00503-g.torture.execute-pr49161/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00503-g.torture.execute-pr49161/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00503-g.torture.execute-pr49161/pr49161.c b/testsuite/c_test/x64_be_enable_test/GCC00503-g.torture.execute-pr49161/pr49161.c
new file mode 100644
index 0000000000000000000000000000000000000000..cc822dae8c3cde3bf0b235da1c8b191a5e271d3f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00503-g.torture.execute-pr49161/pr49161.c
@@ -0,0 +1,46 @@
+/* PR tree-optimization/49161 */
+
+extern void abort (void);
+
+int c;
+
+__attribute__((noinline, noclone)) void
+bar (int x)
+{
+  if (x != c++)
+    abort ();
+}
+
+__attribute__((noinline, noclone)) void
+foo (int x)
+{
+  switch (x)
+    {
+    case 3: goto l1;
+    case 4: goto l2;
+    case 6: goto l3;
+    default: return;
+    }
+l1:
+  goto l4;
+l2:
+  goto l4;
+l3:
+  bar (-1);
+l4:
+  bar (0);
+  if (x != 4)
+    bar (1);
+  if (x != 3)
+    bar (-1);
+  bar (2);
+}
+
+int
+main ()
+{
+  foo (3);
+  if (c != 3)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00503-g.torture.execute-pr49161/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00503-g.torture.execute-pr49161/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4661cd22357b59683234c13ccdc7a193dfb05329
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00503-g.torture.execute-pr49161/test.cfg
@@ -0,0 +1,2 @@
+compile(pr49161)
+run(pr49161)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00504-g.torture.execute-pr49281/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00504-g.torture.execute-pr49281/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00504-g.torture.execute-pr49281/pr49281.c b/testsuite/c_test/x64_be_enable_test/GCC00504-g.torture.execute-pr49281/pr49281.c
new file mode 100644
index 0000000000000000000000000000000000000000..75f5314116aed653b1fef2954b12d4ffea2f1195
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00504-g.torture.execute-pr49281/pr49281.c
@@ -0,0 +1,25 @@
+/* PR target/49281 */
+
+extern void abort (void);
+
+__attribute__((noinline, noclone)) int
+foo (int x)
+{
+  return (x << 2) | 4;
+}
+
+__attribute__((noinline, noclone)) int
+bar (int x)
+{
+  return (x << 2) | 3;
+}
+
+int
+main ()
+{
+  if (foo (43) != 172 || foo (1) != 4 || foo (2) != 12)
+    abort ();
+  if (bar (43) != 175 || bar (1) != 7 || bar (2) != 11)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00504-g.torture.execute-pr49281/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00504-g.torture.execute-pr49281/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fd01fabfd991d93ed8135199fd6ca37983242c6b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00504-g.torture.execute-pr49281/test.cfg
@@ -0,0 +1,2 @@
+compile(pr49281)
+run(pr49281)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00505-g.torture.execute-pr49712/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00505-g.torture.execute-pr49712/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00505-g.torture.execute-pr49712/pr49712.c b/testsuite/c_test/x64_be_enable_test/GCC00505-g.torture.execute-pr49712/pr49712.c
new file mode 100644
index 0000000000000000000000000000000000000000..b85887bfcf027909c5e54c7de44a823dca7f5a72
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00505-g.torture.execute-pr49712/pr49712.c
@@ -0,0 +1,28 @@
+/* PR tree-optimization/49712 */
+
+int a[2], b, c, d, e;
+
+void
+foo (int x, int y)
+{
+}
+
+int
+bar (void)
+{
+  int i;
+  for (; d <= 0; d = 1)
+    for (i = 0; i < 4; i++)
+      for (e = 0; e; e = 1)
+	;
+  return 0;
+}
+
+int
+main ()
+{
+  for (b = 0; b < 2; b++)
+    while (c)
+      foo (a[b] = 0, bar ());
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00505-g.torture.execute-pr49712/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00505-g.torture.execute-pr49712/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eaf6d8e733f8f3379e4dcd6863b30a591345a35d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00505-g.torture.execute-pr49712/test.cfg
@@ -0,0 +1,2 @@
+compile(pr49712)
+run(pr49712)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00506-g.torture.execute-pr49768/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00506-g.torture.execute-pr49768/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00506-g.torture.execute-pr49768/pr49768.c b/testsuite/c_test/x64_be_enable_test/GCC00506-g.torture.execute-pr49768/pr49768.c
new file mode 100644
index 0000000000000000000000000000000000000000..85bc9d2a06f2f4eeb0a2c554db4f0800cbebc448
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00506-g.torture.execute-pr49768/pr49768.c
@@ -0,0 +1,12 @@
+/* PR tree-optimization/49768 */
+
+extern void abort (void);
+
+int
+main ()
+{
+  static struct { unsigned int : 1; unsigned int s : 1; } s = { .s = 1 };
+  if (s.s != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00506-g.torture.execute-pr49768/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00506-g.torture.execute-pr49768/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3aab5ed0e62a0c2542cc88ecbf71397c27e8a4fa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00506-g.torture.execute-pr49768/test.cfg
@@ -0,0 +1,2 @@
+compile(pr49768)
+run(pr49768)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00507-g.torture.execute-pr49886/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00507-g.torture.execute-pr49886/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00507-g.torture.execute-pr49886/pr49886.c b/testsuite/c_test/x64_be_enable_test/GCC00507-g.torture.execute-pr49886/pr49886.c
new file mode 100644
index 0000000000000000000000000000000000000000..9e9ceb2629435cb24690c3474be8e2f49384d094
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00507-g.torture.execute-pr49886/pr49886.c
@@ -0,0 +1,100 @@
+struct PMC {
+    unsigned flags;
+};
+
+typedef struct Pcc_cell
+{
+    struct PMC *p;
+    long bla;
+    long type;
+} Pcc_cell;
+
+int gi;
+int cond;
+
+extern void abort ();
+extern void never_ever(int interp, struct PMC *pmc)
+  __attribute__((noinline,noclone));
+
+void never_ever (int interp, struct PMC *pmc)
+{
+  abort ();
+}
+
+static void mark_cell(int * interp, Pcc_cell *c)
+  __attribute__((__nonnull__(1)));
+
+static void
+mark_cell(int * interp, Pcc_cell *c)
+{
+  if (!cond)
+    return;
+
+  if (c && c->type == 4 && c->p
+      && !(c->p->flags & (1<<18)))
+    never_ever(gi + 1, c->p);
+  if (c && c->type == 4 && c->p
+      && !(c->p->flags & (1<<17)))
+    never_ever(gi + 2, c->p);
+  if (c && c->type == 4 && c->p
+      && !(c->p->flags & (1<<16)))
+    never_ever(gi + 3, c->p);
+  if (c && c->type == 4 && c->p
+      && !(c->p->flags & (1<<15)))
+    never_ever(gi + 4, c->p);
+  if (c && c->type == 4 && c->p
+      && !(c->p->flags & (1<<14)))
+    never_ever(gi + 5, c->p);
+  if (c && c->type == 4 && c->p
+      && !(c->p->flags & (1<<13)))
+    never_ever(gi + 6, c->p);
+  if (c && c->type == 4 && c->p
+      && !(c->p->flags & (1<<12)))
+    never_ever(gi + 7, c->p);
+  if (c && c->type == 4 && c->p
+      && !(c->p->flags & (1<<11)))
+    never_ever(gi + 8, c->p);
+  if (c && c->type == 4 && c->p
+      && !(c->p->flags & (1<<10)))
+    never_ever(gi + 9, c->p);
+}
+
+static void
+foo(int * interp, Pcc_cell *c)
+{
+  mark_cell(interp, c);
+}
+
+static struct Pcc_cell *
+__attribute__((noinline,noclone))
+getnull(void)
+{
+  return (struct Pcc_cell *) 0;
+}
+
+
+int main()
+{
+  int i;
+
+  cond = 1;
+  for (i = 0; i < 100; i++)
+    foo (&gi, getnull ());
+  return 0;
+}
+
+
+void
+bar_1 (int * interp, Pcc_cell *c)
+{
+  c->bla += 1;
+  mark_cell(interp, c);
+}
+
+void
+bar_2 (int * interp, Pcc_cell *c)
+{
+  c->bla += 2;
+  mark_cell(interp, c);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00507-g.torture.execute-pr49886/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00507-g.torture.execute-pr49886/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..df46372b9744df48edff715e9cdd86047c098b57
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00507-g.torture.execute-pr49886/test.cfg
@@ -0,0 +1,2 @@
+compile(pr49886)
+run(pr49886)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00508-g.torture.execute-pr51323/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00508-g.torture.execute-pr51323/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00508-g.torture.execute-pr51323/pr51323.c b/testsuite/c_test/x64_be_enable_test/GCC00508-g.torture.execute-pr51323/pr51323.c
new file mode 100644
index 0000000000000000000000000000000000000000..929579983261d4dfc58d3746315828dbc9c83fe0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00508-g.torture.execute-pr51323/pr51323.c
@@ -0,0 +1,35 @@
+/* PR middle-end/51323 */
+
+extern void abort (void);
+struct S { int a, b, c; };
+int v;
+
+__attribute__((noinline, noclone)) void
+foo (int x, int y, int z)
+{
+  if (x != v || y != 0 || z != 9)
+    abort ();
+}
+
+static inline int
+baz (const struct S *p)
+{
+  return p->b;
+}
+
+__attribute__((noinline, noclone)) void
+bar (int x, struct S y)
+{
+  foo (baz (&y), 0, x);
+}
+
+int
+main ()
+{
+  struct S s;
+  v = 3; s.a = v - 1; s.b = v; s.c = v + 1;
+  bar (9, s);
+  v = 17; s.a = v - 1; s.b = v; s.c = v + 1;
+  bar (9, s);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00508-g.torture.execute-pr51323/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00508-g.torture.execute-pr51323/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c0c3a7abbf6c0652420b37ae2c8c8886b47cab85
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00508-g.torture.execute-pr51323/test.cfg
@@ -0,0 +1,2 @@
+compile(pr51323)
+run(pr51323)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00509-g.torture.execute-pr51466/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00509-g.torture.execute-pr51466/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00509-g.torture.execute-pr51466/pr51466.c b/testsuite/c_test/x64_be_enable_test/GCC00509-g.torture.execute-pr51466/pr51466.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa0b7fd4fb91cf50c5c7d92ecc841e27535141ce
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00509-g.torture.execute-pr51466/pr51466.c
@@ -0,0 +1,43 @@
+/* PR tree-optimization/51466 */
+
+extern void abort (void);
+
+__attribute__((noinline, noclone)) int
+foo (int i)
+{
+  volatile int v[4];
+  int *p;
+  v[i] = 6;
+  p = (int *) &v[i];
+  return *p;
+}
+
+__attribute__((noinline, noclone)) int
+bar (int i)
+{
+  volatile int v[4];
+  int *p;
+  v[i] = 6;
+  p = (int *) &v[i];
+  *p = 8;
+  return v[i];
+}
+
+__attribute__((noinline, noclone)) int
+baz (int i)
+{
+  volatile int v[4];
+  int *p;
+  v[i] = 6;
+  p = (int *) &v[0];
+  *p = 8;
+  return v[i];
+}
+
+int
+main ()
+{
+  if (foo (3) != 6 || bar (2) != 8 || baz (0) != 8 || baz (1) != 6)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00509-g.torture.execute-pr51466/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00509-g.torture.execute-pr51466/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bc068cb916ffc6d67994511a60f66eefb8bbfd06
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00509-g.torture.execute-pr51466/test.cfg
@@ -0,0 +1,2 @@
+compile(pr51466)
+run(pr51466)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00510-g.torture.execute-pr52129/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00510-g.torture.execute-pr52129/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00510-g.torture.execute-pr52129/pr52129.c b/testsuite/c_test/x64_be_enable_test/GCC00510-g.torture.execute-pr52129/pr52129.c
new file mode 100644
index 0000000000000000000000000000000000000000..a60bfa8bb6af30ad6c7e5458cd3eac245341ff2d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00510-g.torture.execute-pr52129/pr52129.c
@@ -0,0 +1,28 @@
+/* PR target/52129 */
+
+extern void abort (void);
+struct S { void *p; unsigned int q; };
+struct T { char a[64]; char b[64]; } t;
+
+__attribute__((noinline, noclone)) int
+foo (void *x, struct S s, void *y, void *z)
+{
+  if (x != &t.a[2] || s.p != &t.b[5] || s.q != 27 || y != &t.a[17] || z != &t.b[17])
+    abort ();
+  return 29;
+}
+
+__attribute__((noinline, noclone)) int
+bar (void *x, void *y, void *z, struct S s, int t, struct T *u)
+{
+  return foo (x, s, &u->a[t], &u->b[t]);
+}
+
+int
+main ()
+{
+  struct S s = { &t.b[5], 27 };
+  if (bar (&t.a[2], (void *) 0, (void *) 0, s, 17, &t) != 29)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00510-g.torture.execute-pr52129/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00510-g.torture.execute-pr52129/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6099707de06bcc6fc44c0f525d87a81ad394bfc5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00510-g.torture.execute-pr52129/test.cfg
@@ -0,0 +1,2 @@
+compile(pr52129)
+run(pr52129)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00511-g.torture.execute-pr52286/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00511-g.torture.execute-pr52286/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00511-g.torture.execute-pr52286/pr52286.c b/testsuite/c_test/x64_be_enable_test/GCC00511-g.torture.execute-pr52286/pr52286.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb56295ab5296124538b12f842e3a64b56d8e00b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00511-g.torture.execute-pr52286/pr52286.c
@@ -0,0 +1,20 @@
+/* PR tree-optimization/52286 */
+
+extern void abort (void);
+
+int
+main ()
+{
+#if __SIZEOF_INT__ > 2
+  int a, b;
+  asm ("" : "=r" (a) : "0" (0));
+  b = (~a | 1) & -2038094497;
+#else
+  long a, b;
+  asm ("" : "=r" (a) : "0" (0));
+  b = (~a | 1) & -2038094497L;
+#endif
+  if (b >= 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00511-g.torture.execute-pr52286/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00511-g.torture.execute-pr52286/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6cd5acf65127028f534dcd4dc328000ea340c737
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00511-g.torture.execute-pr52286/test.cfg
@@ -0,0 +1,2 @@
+compile(pr52286)
+run(pr52286)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00512-g.torture.execute-pr52979-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00512-g.torture.execute-pr52979-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00512-g.torture.execute-pr52979-1/pr52979-1.c b/testsuite/c_test/x64_be_enable_test/GCC00512-g.torture.execute-pr52979-1/pr52979-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..13ecb7933548a93c03d1a37ebc4bd0b2d68a20f2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00512-g.torture.execute-pr52979-1/pr52979-1.c
@@ -0,0 +1,42 @@
+/* PR middle-end/52979 */
+
+/* { dg-require-effective-target int32plus } */
+
+extern void abort (void);
+int c, d, e;
+
+void
+foo (void)
+{
+}
+
+struct __attribute__((packed)) S { int g : 31; int h : 6; };
+struct S a = { 1 };
+static struct S b = { 1 };
+
+void
+bar (void)
+{
+  a.h = 1;
+  struct S f = { };
+  b = f;
+  e = 0;
+  if (d)
+    c = a.g;
+}
+
+void
+baz (void)
+{
+  bar ();
+  a = b;
+}
+
+int
+main ()
+{
+  baz ();
+  if (a.g)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00512-g.torture.execute-pr52979-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00512-g.torture.execute-pr52979-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..104eb97ff2fa2699144cd8c3c69e39035a765be2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00512-g.torture.execute-pr52979-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr52979-1)
+run(pr52979-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00513-g.torture.execute-pr52979-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00513-g.torture.execute-pr52979-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00513-g.torture.execute-pr52979-2/pr52979-2.c b/testsuite/c_test/x64_be_enable_test/GCC00513-g.torture.execute-pr52979-2/pr52979-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..91d4fbca8ac5137cb2d333679fa83f7453b65db6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00513-g.torture.execute-pr52979-2/pr52979-2.c
@@ -0,0 +1,41 @@
+/* PR middle-end/52979 */
+/* { dg-require-effective-target int32plus } */
+
+extern void abort (void);
+int c, d, e;
+
+void
+foo (void)
+{
+}
+
+struct __attribute__((packed)) S { int g : 31; int h : 6; };
+static struct S b = { 1 };
+struct S a = { 1 };
+
+void
+bar (void)
+{
+  a.h = 1;
+  struct S f = { };
+  b = f;
+  e = 0;
+  if (d)
+    c = a.g;
+}
+
+void
+baz (void)
+{
+  bar ();
+  a = b;
+}
+
+int
+main ()
+{
+  baz ();
+  if (a.g)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00513-g.torture.execute-pr52979-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00513-g.torture.execute-pr52979-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c32c3cd12ae54ce686a9e125ba448273185c557
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00513-g.torture.execute-pr52979-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr52979-2)
+run(pr52979-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00514-g.torture.execute-pr54937/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00514-g.torture.execute-pr54937/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00514-g.torture.execute-pr54937/pr54937.c b/testsuite/c_test/x64_be_enable_test/GCC00514-g.torture.execute-pr54937/pr54937.c
new file mode 100644
index 0000000000000000000000000000000000000000..13dae6063f975986aa52634d8a2f5726b742ffb2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00514-g.torture.execute-pr54937/pr54937.c
@@ -0,0 +1,22 @@
+
+void exit (int);
+void abort (void);
+int a[1];
+void (*terminate_me)(int);
+
+__attribute__((noinline,noclone))
+t(int c)
+{ int i;
+  for (i=0;i<c;i++)
+    {
+      if (i)
+       terminate_me(0);
+      a[i]=0;
+    }
+}
+main()
+{
+  terminate_me = exit;
+  t(100);
+  abort();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00514-g.torture.execute-pr54937/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00514-g.torture.execute-pr54937/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5efe20f460d6b84fa4713a01f4989066e7278462
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00514-g.torture.execute-pr54937/test.cfg
@@ -0,0 +1,2 @@
+compile(pr54937)
+run(pr54937)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00515-g.torture.execute-pr54985/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00515-g.torture.execute-pr54985/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00515-g.torture.execute-pr54985/pr54985.c b/testsuite/c_test/x64_be_enable_test/GCC00515-g.torture.execute-pr54985/pr54985.c
new file mode 100644
index 0000000000000000000000000000000000000000..678c9f47ae735c86678113cef6bc51f67c295e52
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00515-g.torture.execute-pr54985/pr54985.c
@@ -0,0 +1,36 @@
+
+typedef struct st {
+    int a;
+} ST;
+
+int __attribute__((noinline,noclone))
+foo(ST *s, int c)
+{
+  int first = 1;
+  int count = c;
+  ST *item = s;
+  int a = s->a;
+  int x;
+
+  while (count--)
+    {
+      x = item->a;
+      if (first)
+        first = 0;
+      else if (x >= a)
+        return 1;
+      a = x;
+      item++;
+    }
+  return 0;
+}
+
+extern void abort (void);
+
+int main ()
+{
+  ST _1[2] = {{2}, {1}};
+  if (foo(_1, 2) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00515-g.torture.execute-pr54985/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00515-g.torture.execute-pr54985/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..29c9fa5567a64ee42c6912ffaf676b841ee404f8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00515-g.torture.execute-pr54985/test.cfg
@@ -0,0 +1,2 @@
+compile(pr54985)
+run(pr54985)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00516-g.torture.execute-pr55137/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00516-g.torture.execute-pr55137/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00516-g.torture.execute-pr55137/pr55137.c b/testsuite/c_test/x64_be_enable_test/GCC00516-g.torture.execute-pr55137/pr55137.c
new file mode 100644
index 0000000000000000000000000000000000000000..80bc973f7f8dc04a3304819e2daf3c2aa255f335
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00516-g.torture.execute-pr55137/pr55137.c
@@ -0,0 +1,30 @@
+/* PR c++/55137 */
+
+extern void abort (void);
+
+int
+foo (unsigned int x)
+{
+  return ((int) (x + 1U) + 1) < (int) x;
+}
+
+int
+bar (unsigned int x)
+{
+  return (int) (x + 1U) + 1;
+}
+
+int
+baz (unsigned int x)
+{
+  return x + 1U;
+}
+
+int
+main ()
+{
+  if (foo (__INT_MAX__) != (bar (__INT_MAX__) < __INT_MAX__)
+      || foo (__INT_MAX__) != ((int) baz (__INT_MAX__) + 1 < __INT_MAX__))
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00516-g.torture.execute-pr55137/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00516-g.torture.execute-pr55137/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d681967fae2ad4688b8151dec52b5d96fc532fa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00516-g.torture.execute-pr55137/test.cfg
@@ -0,0 +1,2 @@
+compile(pr55137)
+run(pr55137)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00517-g.torture.execute-pr55875/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00517-g.torture.execute-pr55875/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00517-g.torture.execute-pr55875/pr55875.c b/testsuite/c_test/x64_be_enable_test/GCC00517-g.torture.execute-pr55875/pr55875.c
new file mode 100644
index 0000000000000000000000000000000000000000..4e56f7c26c1c84d92d1058079ed4b769cbfa278a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00517-g.torture.execute-pr55875/pr55875.c
@@ -0,0 +1,17 @@
+int a[251];
+__attribute__ ((noinline))
+t(int i)
+{
+  if (i==0)
+    exit(0);
+  if (i>255)
+    abort ();
+}
+main()
+{
+  unsigned int i;
+  for (i=0;;i++)
+    {
+      a[i]=t((unsigned char)(i+5));
+    }
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00517-g.torture.execute-pr55875/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00517-g.torture.execute-pr55875/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..140dbd68a1b949d477d1ec4ab012b9aa8bd4bbb1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00517-g.torture.execute-pr55875/test.cfg
@@ -0,0 +1,2 @@
+compile(pr55875)
+run(pr55875)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00518-g.torture.execute-pr56051/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00518-g.torture.execute-pr56051/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00518-g.torture.execute-pr56051/pr56051.c b/testsuite/c_test/x64_be_enable_test/GCC00518-g.torture.execute-pr56051/pr56051.c
new file mode 100644
index 0000000000000000000000000000000000000000..4ff6b9e267b858cd1f3d22de8425dc76ddd0c638
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00518-g.torture.execute-pr56051/pr56051.c
@@ -0,0 +1,32 @@
+/* PR tree-optimization/56051 */
+
+extern void abort (void);
+
+int
+main ()
+{
+  unsigned char x1[1] = { 0 };
+  unsigned int s1 = __CHAR_BIT__;
+  int a1 = x1[0] < (unsigned char) (1 << s1);
+  unsigned char y1 = (unsigned char) (1 << s1);
+  int b1 = x1[0] < y1;
+  if (a1 != b1)
+    abort ();
+#if __SIZEOF_LONG_LONG__ > __SIZEOF_INT__
+  unsigned long long x2[1] = { 2ULL << (sizeof (int) * __CHAR_BIT__) };
+  unsigned int s2 = sizeof (int) * __CHAR_BIT__ - 1;
+  int a2 = x2[0] >= (unsigned long long) (1 << s2);
+  unsigned long long y2 = 1 << s2;
+  int b2 = x2[0] >= y2;
+  if (a2 != b2)
+    abort ();
+  unsigned long long x3[1] = { 2ULL << (sizeof (int) * __CHAR_BIT__) };
+  unsigned int s3 = sizeof (int) * __CHAR_BIT__ - 1;
+  int a3 = x3[0] >= (unsigned long long) (1U << s3);
+  unsigned long long y3 = 1U << s3;
+  int b3 = x3[0] >= y3;
+  if (a3 != b3)
+    abort ();
+#endif
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00518-g.torture.execute-pr56051/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00518-g.torture.execute-pr56051/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e51c88ad1b33d21081e450fe636a70236de4d05a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00518-g.torture.execute-pr56051/test.cfg
@@ -0,0 +1,2 @@
+compile(pr56051)
+run(pr56051)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00519-g.torture.execute-pr56982/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00519-g.torture.execute-pr56982/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00519-g.torture.execute-pr56982/pr56982.c b/testsuite/c_test/x64_be_enable_test/GCC00519-g.torture.execute-pr56982/pr56982.c
new file mode 100644
index 0000000000000000000000000000000000000000..0fa9c8ab4ba82ae53cb20321c3bdad5f162ddd08
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00519-g.torture.execute-pr56982/pr56982.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target indirect_jumps } */
+#include <setjmp.h>
+
+extern void abort (void);
+extern void exit (int);
+
+static jmp_buf env;
+
+void baz (void)
+{
+  __asm__ volatile ("" : : : "memory");
+}
+
+static inline int g(int x)
+{
+    if (x)
+    {
+        baz();
+        return 0;
+    }
+    else
+    {
+        baz();
+        return 1;
+    }
+}
+
+int f(int *e)
+{
+    if (*e)
+      return 1;
+
+    int x = setjmp(env);
+    int n = g(x);
+    if (n == 0)
+      exit(0);
+    if (x)
+      abort();
+    longjmp(env, 42);
+}
+
+int main(int argc, char** argv)
+{
+    int v = 0;
+    return f(&v);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00519-g.torture.execute-pr56982/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00519-g.torture.execute-pr56982/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c9b667f0bb7cb9b5b1fcb2031c638695d50edff9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00519-g.torture.execute-pr56982/test.cfg
@@ -0,0 +1,2 @@
+compile(pr56982)
+run(pr56982)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00520-g.torture.execute-pr57281/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00520-g.torture.execute-pr57281/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00520-g.torture.execute-pr57281/pr57281.c b/testsuite/c_test/x64_be_enable_test/GCC00520-g.torture.execute-pr57281/pr57281.c
new file mode 100644
index 0000000000000000000000000000000000000000..db3db10d9e75074069df3dd3710608cb58be7253
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00520-g.torture.execute-pr57281/pr57281.c
@@ -0,0 +1,25 @@
+/* PR rtl-optimization/57281 */
+
+int a = 1, b, d, *e = &d;
+long long c, *g = &c;
+volatile long long f;
+
+int
+foo (int h)
+{
+  int j = *g = b;
+  return h == 0 ? j : 0;
+}
+
+int
+main ()
+{
+  int h = a;
+  for (; b != -20; b--)
+    {
+      (int) f;
+      *e = 0;
+      *e = foo (h);
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00520-g.torture.execute-pr57281/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00520-g.torture.execute-pr57281/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0692dc4240bae54e57dd88d609fd6298b8919262
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00520-g.torture.execute-pr57281/test.cfg
@@ -0,0 +1,2 @@
+compile(pr57281)
+run(pr57281)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00521-g.torture.execute-pr57321/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00521-g.torture.execute-pr57321/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00521-g.torture.execute-pr57321/pr57321.c b/testsuite/c_test/x64_be_enable_test/GCC00521-g.torture.execute-pr57321/pr57321.c
new file mode 100644
index 0000000000000000000000000000000000000000..79b3d4d17740b7a563dcda21e7c327f3a176cb07
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00521-g.torture.execute-pr57321/pr57321.c
@@ -0,0 +1,24 @@
+/* PR tree-optimization/57321 */
+
+int a = 1, *b, **c;
+
+static int
+foo (int *p)
+{
+  if (*p == a)
+    {
+      int *i[7][5] = { { 0 } };
+      int **j[1][1];
+      j[0][0] = &i[0][0];
+      *b = &p != c;
+    }
+  return 0;
+}
+
+int
+main ()
+{
+  int i = 0;
+  foo (&i);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00521-g.torture.execute-pr57321/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00521-g.torture.execute-pr57321/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0f59483d57ec7f284f28a83ecc467139c739eee2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00521-g.torture.execute-pr57321/test.cfg
@@ -0,0 +1,2 @@
+compile(pr57321)
+run(pr57321)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00522-g.torture.execute-pr57344-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00522-g.torture.execute-pr57344-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00522-g.torture.execute-pr57344-1/pr57344-1.c b/testsuite/c_test/x64_be_enable_test/GCC00522-g.torture.execute-pr57344-1/pr57344-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..66893269efa5cd8ecd636a399594a9e84e2b85f9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00522-g.torture.execute-pr57344-1/pr57344-1.c
@@ -0,0 +1,32 @@
+/* PR middle-end/57344 */
+
+struct __attribute__((packed)) S
+{
+  int a : 11;
+#if __SIZEOF_INT__ * __CHAR_BIT__ >= 32
+  int b : 22;
+#else
+  int b : 13;
+#endif
+  char c;
+  int : 0;
+} s[2];
+int i;
+
+__attribute__((noinline, noclone)) void
+foo (int x)
+{
+  if (x != -3161)
+    __builtin_abort ();
+  asm volatile ("" : : : "memory");
+}
+
+int
+main ()
+{
+  struct S t = { 0, -3161L };
+  s[1] = t;
+  for (; i < 1; i++)
+    foo (s[1].b);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00522-g.torture.execute-pr57344-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00522-g.torture.execute-pr57344-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f46e90e2938c7e59c7c05f73f934c64460a78ab8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00522-g.torture.execute-pr57344-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr57344-1)
+run(pr57344-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00523-g.torture.execute-pr57568/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00523-g.torture.execute-pr57568/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00523-g.torture.execute-pr57568/pr57568.c b/testsuite/c_test/x64_be_enable_test/GCC00523-g.torture.execute-pr57568/pr57568.c
new file mode 100644
index 0000000000000000000000000000000000000000..9a7ddb0c56fd96ce5aa6b21adebdd1ca63dc4974
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00523-g.torture.execute-pr57568/pr57568.c
@@ -0,0 +1,12 @@
+/* PR target/57568 */
+
+extern void abort (void);
+int a[6][9] = { }, b = 1, *c = &a[3][5];
+
+int
+main ()
+{
+  if (b && (*c = *c + *c))
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00523-g.torture.execute-pr57568/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00523-g.torture.execute-pr57568/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d76222ad54787f0dd88b7dcbe55e73f9fccd16e1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00523-g.torture.execute-pr57568/test.cfg
@@ -0,0 +1,2 @@
+compile(pr57568)
+run(pr57568)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00524-g.torture.execute-pr57829/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00524-g.torture.execute-pr57829/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00524-g.torture.execute-pr57829/pr57829.c b/testsuite/c_test/x64_be_enable_test/GCC00524-g.torture.execute-pr57829/pr57829.c
new file mode 100644
index 0000000000000000000000000000000000000000..b5c3d185d0a939e5623913c0fd0224bb2a084c13
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00524-g.torture.execute-pr57829/pr57829.c
@@ -0,0 +1,31 @@
+/* PR rtl-optimization/57829 */
+
+__attribute__((noinline, noclone))
+int
+f1 (int k)
+{
+  return 2 | ((k - 1) >> ((int) sizeof (int) * __CHAR_BIT__ - 1));
+}
+
+__attribute__((noinline, noclone))
+long int
+f2 (long int k)
+{
+  return 2L | ((k - 1L) >> ((int) sizeof (long int) * __CHAR_BIT__ - 1));
+}
+
+__attribute__((noinline, noclone))
+int
+f3 (int k)
+{
+  k &= 63;
+  return 4 | ((k + 2) >> 5);
+}
+
+int
+main ()
+{
+  if (f1 (1) != 2 || f2 (1L) != 2L || f3 (63) != 6 || f3 (1) != 4)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00524-g.torture.execute-pr57829/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00524-g.torture.execute-pr57829/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a855f4f9b1ba0e231f72e9ccfb004736902d7e97
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00524-g.torture.execute-pr57829/test.cfg
@@ -0,0 +1,2 @@
+compile(pr57829)
+run(pr57829)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00525-g.torture.execute-pr58209/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00525-g.torture.execute-pr58209/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00525-g.torture.execute-pr58209/pr58209.c b/testsuite/c_test/x64_be_enable_test/GCC00525-g.torture.execute-pr58209/pr58209.c
new file mode 100644
index 0000000000000000000000000000000000000000..78743bfb959c5db0069d27945115d52d962b7e31
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00525-g.torture.execute-pr58209/pr58209.c
@@ -0,0 +1,32 @@
+/* PR tree-optimization/58209 */
+
+extern void abort (void);
+typedef __INTPTR_TYPE__ T;
+T buf[1024];
+
+T *
+foo (T n)
+{
+  if (n == 0)
+    return (T *) buf;
+  T s = (T) foo (n - 1);
+  return (T *) (s + sizeof (T));
+}
+
+T *
+bar (T n)
+{
+  if (n == 0)
+    return buf;
+  return foo (n - 1) + 1;
+}
+
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 27; i++)
+    if (foo (i) != buf + i || bar (i) != buf + i)
+      abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00525-g.torture.execute-pr58209/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00525-g.torture.execute-pr58209/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ef6096d44c988a808daab41c74980ca8c52598f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00525-g.torture.execute-pr58209/test.cfg
@@ -0,0 +1,2 @@
+compile(pr58209)
+run(pr58209)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00526-g.torture.execute-pr58387/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00526-g.torture.execute-pr58387/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00526-g.torture.execute-pr58387/pr58387.c b/testsuite/c_test/x64_be_enable_test/GCC00526-g.torture.execute-pr58387/pr58387.c
new file mode 100644
index 0000000000000000000000000000000000000000..74c32dfaf10d717df4ccf7a1be3f8a311cb25d41
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00526-g.torture.execute-pr58387/pr58387.c
@@ -0,0 +1,11 @@
+extern void abort(void);
+
+int a = -1; 
+
+int main ()
+{
+  int b = a == 0 ? 0 : -a;
+  if (b < 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00526-g.torture.execute-pr58387/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00526-g.torture.execute-pr58387/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..220320d57d462df0b24843f172506b9108b696bf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00526-g.torture.execute-pr58387/test.cfg
@@ -0,0 +1,2 @@
+compile(pr58387)
+run(pr58387)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00527-g.torture.execute-pr58943/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00527-g.torture.execute-pr58943/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00527-g.torture.execute-pr58943/pr58943.c b/testsuite/c_test/x64_be_enable_test/GCC00527-g.torture.execute-pr58943/pr58943.c
new file mode 100644
index 0000000000000000000000000000000000000000..75e87ae0950ca25a79a1e01d171e513bc3edd70f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00527-g.torture.execute-pr58943/pr58943.c
@@ -0,0 +1,19 @@
+/* PR c/58943 */
+
+unsigned int x[1] = { 2 };
+
+unsigned int
+foo (void)
+{
+  x[0] |= 128;
+  return 1;
+}
+
+int
+main ()
+{
+  x[0] |= foo ();
+  if (x[0] != 131)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00527-g.torture.execute-pr58943/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00527-g.torture.execute-pr58943/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e51a5e4f7498037e6c4eb7de42fc6434ccd6d066
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00527-g.torture.execute-pr58943/test.cfg
@@ -0,0 +1,2 @@
+compile(pr58943)
+run(pr58943)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00528-g.torture.execute-pr59014-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00528-g.torture.execute-pr59014-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00528-g.torture.execute-pr59014-2/pr59014-2.c b/testsuite/c_test/x64_be_enable_test/GCC00528-g.torture.execute-pr59014-2/pr59014-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..18da0059eab10487a53daaed656ef17cb41a1b67
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00528-g.torture.execute-pr59014-2/pr59014-2.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/59014 */
+
+__attribute__((noinline, noclone)) long long int
+foo (long long int x, long long int y)
+{
+  if (((int) x | (int) y) != 0)
+    return 6;
+  return x + y;
+}
+
+int
+main ()
+{
+  if (sizeof (long long) == sizeof (int))
+    return 0;
+  int shift_half = sizeof (int) * __CHAR_BIT__ / 2;
+  long long int x = (3LL << shift_half) << shift_half;
+  long long int y = (5LL << shift_half) << shift_half;
+  long long int z = foo (x, y);
+  if (z != ((8LL << shift_half) << shift_half))
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00528-g.torture.execute-pr59014-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00528-g.torture.execute-pr59014-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..22fd5e84f25c9f299822dca7ccbd0996f26067fe
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00528-g.torture.execute-pr59014-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr59014-2)
+run(pr59014-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00529-g.torture.execute-pr59229/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00529-g.torture.execute-pr59229/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00529-g.torture.execute-pr59229/pr59229.c b/testsuite/c_test/x64_be_enable_test/GCC00529-g.torture.execute-pr59229/pr59229.c
new file mode 100644
index 0000000000000000000000000000000000000000..d2a776778de37d5130c5c74089a5ec72a6a4c921
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00529-g.torture.execute-pr59229/pr59229.c
@@ -0,0 +1,29 @@
+int i;
+
+__attribute__((noinline, noclone)) void
+bar (char *p)
+{
+  if (i < 1 || i > 6)
+    __builtin_abort ();
+  if (__builtin_memcmp (p, "abcdefg", i + 1) != 0)
+    __builtin_abort ();
+  __builtin_memset (p, ' ', 7);
+}
+
+__attribute__((noinline, noclone)) void
+foo (char *p, unsigned long l)
+{
+  if (l < 1 || l > 6)
+    return;
+  char buf[7];
+  __builtin_memcpy (buf, p, l + 1);
+  bar (buf);
+}
+
+int
+main ()
+{
+  for (i = 0; i < 16; i++)
+    foo ("abcdefghijklmnop", i);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00529-g.torture.execute-pr59229/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00529-g.torture.execute-pr59229/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fd22a45bb3c9797d6d187a8292670132b5c89e89
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00529-g.torture.execute-pr59229/test.cfg
@@ -0,0 +1,2 @@
+compile(pr59229)
+run(pr59229)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00530-g.torture.execute-pr59358/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00530-g.torture.execute-pr59358/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00530-g.torture.execute-pr59358/pr59358.c b/testsuite/c_test/x64_be_enable_test/GCC00530-g.torture.execute-pr59358/pr59358.c
new file mode 100644
index 0000000000000000000000000000000000000000..674026d62588d8ba0a84e9b15ae6dd6cd134f660
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00530-g.torture.execute-pr59358/pr59358.c
@@ -0,0 +1,44 @@
+/* PR tree-optimization/59358 */
+
+__attribute__((noinline, noclone)) int
+foo (int *x, int y)
+{
+  int z = *x;
+  if (y > z && y <= 16)
+    while (y > z)
+      z *= 2;
+  return z;
+}
+
+int
+main ()
+{
+  int i;
+  for (i = 1; i < 17; i++)
+    {
+      int j = foo (&i, 16);
+      int k;
+      if (i >= 8 && i <= 15)
+	k = 16 + (i - 8) * 2;
+      else if (i >= 4 && i <= 7)
+	k = 16 + (i - 4) * 4;
+      else if (i == 3)
+	k = 24;
+      else
+	k = 16;
+      if (j != k)
+	__builtin_abort ();
+      j = foo (&i, 7);
+      if (i >= 7)
+	k = i;
+      else if (i >= 4)
+	k = 8 + (i - 4) * 2;
+      else if (i == 3)
+	k = 12;
+      else
+	k = 8;
+      if (j != k)
+	__builtin_abort ();
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00530-g.torture.execute-pr59358/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00530-g.torture.execute-pr59358/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7f2c01882249a62d8c6bc7565296a540fe335ab4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00530-g.torture.execute-pr59358/test.cfg
@@ -0,0 +1,2 @@
+compile(pr59358)
+run(pr59358)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00531-g.torture.execute-pr59387/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00531-g.torture.execute-pr59387/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00531-g.torture.execute-pr59387/pr59387.c b/testsuite/c_test/x64_be_enable_test/GCC00531-g.torture.execute-pr59387/pr59387.c
new file mode 100644
index 0000000000000000000000000000000000000000..e226cf112507dad69a72274a6f930df8c89415d1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00531-g.torture.execute-pr59387/pr59387.c
@@ -0,0 +1,19 @@
+/* PR tree-optimization/59387 */
+
+int a, *d, **e = &d, f;
+char c;
+struct S { int f1; } b;
+
+int
+main ()
+{
+  for (a = -19; a; a++)
+    {
+      for (b.f1 = 0; b.f1 < 24; b.f1++)
+	c--;
+      *e = &f;
+      if (!d)
+	return 0;
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00531-g.torture.execute-pr59387/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00531-g.torture.execute-pr59387/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b5df8e04c12516122dbe01b5d3c7ca405c483c46
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00531-g.torture.execute-pr59387/test.cfg
@@ -0,0 +1,2 @@
+compile(pr59387)
+run(pr59387)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00532-g.torture.execute-pr59388/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00532-g.torture.execute-pr59388/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00532-g.torture.execute-pr59388/pr59388.c b/testsuite/c_test/x64_be_enable_test/GCC00532-g.torture.execute-pr59388/pr59388.c
new file mode 100644
index 0000000000000000000000000000000000000000..de3648a003eda0240d98964794e3a6924a4088ae
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00532-g.torture.execute-pr59388/pr59388.c
@@ -0,0 +1,11 @@
+/* PR tree-optimization/59388 */
+
+int a;
+struct S { unsigned int f:1; } b;
+
+int
+main ()
+{
+  a = (0 < b.f) | b.f;
+  return a;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00532-g.torture.execute-pr59388/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00532-g.torture.execute-pr59388/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..614ab9f17376a2d380eeba43ab7416582ba588f8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00532-g.torture.execute-pr59388/test.cfg
@@ -0,0 +1,2 @@
+compile(pr59388)
+run(pr59388)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00533-g.torture.execute-pr60062/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00533-g.torture.execute-pr60062/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00533-g.torture.execute-pr60062/pr60062.c b/testsuite/c_test/x64_be_enable_test/GCC00533-g.torture.execute-pr60062/pr60062.c
new file mode 100644
index 0000000000000000000000000000000000000000..62973d458a44625f2ff2822563259dc66c79711a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00533-g.torture.execute-pr60062/pr60062.c
@@ -0,0 +1,25 @@
+/* PR target/60062 */
+
+int a;
+
+static void
+foo (const char *p1, int p2)
+{
+  if (__builtin_strcmp (p1, "hello") != 0)
+    __builtin_abort ();
+}
+
+static void
+bar (const char *p1)
+{
+  if (__builtin_strcmp (p1, "hello") != 0)
+    __builtin_abort ();
+}
+
+__attribute__((optimize (0))) int
+main ()
+{
+  foo ("hello", a);
+  bar ("hello");
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00533-g.torture.execute-pr60062/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00533-g.torture.execute-pr60062/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ed62f66a4e1c8d1d49d01d18b020787c25a608ef
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00533-g.torture.execute-pr60062/test.cfg
@@ -0,0 +1,2 @@
+compile(pr60062)
+run(pr60062)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00534-g.torture.execute-pr60072/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00534-g.torture.execute-pr60072/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00534-g.torture.execute-pr60072/pr60072.c b/testsuite/c_test/x64_be_enable_test/GCC00534-g.torture.execute-pr60072/pr60072.c
new file mode 100644
index 0000000000000000000000000000000000000000..566874d635e660f6ef0b0a541c4a9bdd880e324c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00534-g.torture.execute-pr60072/pr60072.c
@@ -0,0 +1,16 @@
+/* PR target/60072 */
+
+int c = 1;
+
+__attribute__ ((optimize (1)))
+static int *foo (int *p)
+{
+  return p;
+}
+
+int
+main ()
+{
+  *foo (&c) = 2;
+  return c - 2;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00534-g.torture.execute-pr60072/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00534-g.torture.execute-pr60072/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..74f41035e5666f382165cd2894fb840196038cfa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00534-g.torture.execute-pr60072/test.cfg
@@ -0,0 +1,2 @@
+compile(pr60072)
+run(pr60072)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00535-g.torture.execute-pr60454/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00535-g.torture.execute-pr60454/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00535-g.torture.execute-pr60454/pr60454.c b/testsuite/c_test/x64_be_enable_test/GCC00535-g.torture.execute-pr60454/pr60454.c
new file mode 100644
index 0000000000000000000000000000000000000000..ceec45e699ff4f78ec83d9f4a26ad9ec69e79c9f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00535-g.torture.execute-pr60454/pr60454.c
@@ -0,0 +1,31 @@
+#ifdef __UINT32_TYPE__
+typedef __UINT32_TYPE__ uint32_t;
+#else
+typedef unsigned uint32_t;
+#endif
+
+#define __fake_const_swab32(x) ((uint32_t)(			      \
+        (((uint32_t)(x) & (uint32_t)0x000000ffUL) << 24) |            \
+        (((uint32_t)(x) & (uint32_t)0x0000ff00UL) <<  8) |            \
+        (((uint32_t)(x) & (uint32_t)0x000000ffUL) <<  8) |            \
+        (((uint32_t)(x) & (uint32_t)0x0000ff00UL)      ) |            \
+        (((uint32_t)(x) & (uint32_t)0xff000000UL) >> 24)))
+
+/* Previous version of bswap optimization would detect byte swap when none
+   happen. This test aims at catching such wrong detection to avoid
+   regressions.  */
+
+__attribute__ ((noinline, noclone)) uint32_t
+fake_swap32 (uint32_t in)
+{
+  return __fake_const_swab32 (in);
+}
+
+int main(void)
+{
+  if (sizeof (uint32_t) * __CHAR_BIT__ != 32)
+    return 0;
+  if (fake_swap32 (0x12345678UL) != 0x78567E12UL)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00535-g.torture.execute-pr60454/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00535-g.torture.execute-pr60454/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d4f3d8a030ea6622184d551757620ba3cff5e332
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00535-g.torture.execute-pr60454/test.cfg
@@ -0,0 +1,2 @@
+compile(pr60454)
+run(pr60454)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00536-g.torture.execute-pr61306-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00536-g.torture.execute-pr61306-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00536-g.torture.execute-pr61306-1/pr61306-1.c b/testsuite/c_test/x64_be_enable_test/GCC00536-g.torture.execute-pr61306-1/pr61306-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ebc90a32f986750e566a5bdb64112f3b9432e5dd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00536-g.torture.execute-pr61306-1/pr61306-1.c
@@ -0,0 +1,39 @@
+#ifdef __INT32_TYPE__
+typedef __INT32_TYPE__ int32_t;
+#else
+typedef int int32_t;
+#endif
+
+#ifdef __UINT32_TYPE__
+typedef __UINT32_TYPE__ uint32_t;
+#else
+typedef unsigned uint32_t;
+#endif
+
+#define __fake_const_swab32(x) ((uint32_t)(		      \
+	(((uint32_t)(x) & (uint32_t)0x000000ffUL) << 24) |    \
+	(((uint32_t)(x) & (uint32_t)0x0000ff00UL) <<  8) |    \
+	(((uint32_t)(x) & (uint32_t)0x00ff0000UL) >>  8) |    \
+	(( (int32_t)(x) &  (int32_t)0xff000000UL) >> 24)))
+
+/* Previous version of bswap optimization failed to consider sign extension
+   and as a result would replace an expression *not* doing a bswap by a
+   bswap.  */
+
+__attribute__ ((noinline, noclone)) uint32_t
+fake_bswap32 (uint32_t in)
+{
+  return __fake_const_swab32 (in);
+}
+
+int
+main(void)
+{
+  if (sizeof (int32_t) * __CHAR_BIT__ != 32)
+    return 0;
+  if (sizeof (uint32_t) * __CHAR_BIT__ != 32)
+    return 0;
+  if (fake_bswap32 (0x87654321) != 0xffffff87)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00536-g.torture.execute-pr61306-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00536-g.torture.execute-pr61306-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1bddd8d420e798f1944fd06d8fa4785797b35f01
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00536-g.torture.execute-pr61306-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr61306-1)
+run(pr61306-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00537-g.torture.execute-pr61375/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00537-g.torture.execute-pr61375/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00537-g.torture.execute-pr61375/pr61375.c b/testsuite/c_test/x64_be_enable_test/GCC00537-g.torture.execute-pr61375/pr61375.c
new file mode 100644
index 0000000000000000000000000000000000000000..325f340932f925986af4687d25655dd61feb0deb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00537-g.torture.execute-pr61375/pr61375.c
@@ -0,0 +1,35 @@
+#ifdef __UINT64_TYPE__
+typedef __UINT64_TYPE__ uint64_t;
+#else
+typedef unsigned long long uint64_t;
+#endif
+
+#ifndef __SIZEOF_INT128__
+#define __int128 long long
+#endif
+
+/* Some version of bswap optimization would ICE when analyzing a mask constant
+   too big for an uint64_t variable (PR210931).  */
+
+__attribute__ ((noinline, noclone)) uint64_t
+uint128_central_bitsi_ior (unsigned __int128 in1, uint64_t in2)
+{
+  __int128 mask = (__int128)0xffff << 56;
+  return ((in1 & mask) >> 56) | in2;
+}
+
+int
+main(int argc, char **argv)
+{
+  __int128 in = 1;
+#ifdef __SIZEOF_INT128__
+  in <<= 64;
+#endif
+  if (sizeof (uint64_t) * __CHAR_BIT__ != 64)
+    return 0;
+  if (sizeof (unsigned __int128) * __CHAR_BIT__ != 128)
+    return 0;
+  if (uint128_central_bitsi_ior (in, 2) != 0x102)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00537-g.torture.execute-pr61375/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00537-g.torture.execute-pr61375/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..882b2adb06fbd000f424ae1fb39739d41e9fcfc4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00537-g.torture.execute-pr61375/test.cfg
@@ -0,0 +1,2 @@
+compile(pr61375)
+run(pr61375)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00538-g.torture.execute-pr63209/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00538-g.torture.execute-pr63209/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00538-g.torture.execute-pr63209/pr63209.c b/testsuite/c_test/x64_be_enable_test/GCC00538-g.torture.execute-pr63209/pr63209.c
new file mode 100644
index 0000000000000000000000000000000000000000..9bcb58745638e067cce8f3837a304a91c975f4ca
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00538-g.torture.execute-pr63209/pr63209.c
@@ -0,0 +1,27 @@
+static int Sub(int a, int b) {
+  return  b -a;
+}
+
+static unsigned Select(unsigned a, unsigned b, unsigned c) {
+  const int pa_minus_pb =
+      Sub((a >>  8) & 0xff, (b >>  8) & 0xff) + 
+      Sub((a >>  0) & 0xff, (b >>  0) & 0xff); 
+  return (pa_minus_pb <= 0) ? a : b;
+}
+
+__attribute__((noinline)) unsigned Predictor(unsigned left, const unsigned* const top) {
+  const unsigned pred = Select(top[1], left, top[0]);
+  return pred;
+}
+
+int main(void) {
+  const unsigned top[2] = {0xff7a7a7a, 0xff7a7a7a};
+  const unsigned left = 0xff7b7b7b;
+  const unsigned pred = Predictor(left, top /*+ 1*/);
+  if (pred == left)
+    return 0;
+  return 1;
+}
+
+
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00538-g.torture.execute-pr63209/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00538-g.torture.execute-pr63209/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c28ee8d8abb544aa3fb968b285177bcd27e7825a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00538-g.torture.execute-pr63209/test.cfg
@@ -0,0 +1,2 @@
+compile(pr63209)
+run(pr63209)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00539-g.torture.execute-pr64242/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00539-g.torture.execute-pr64242/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00539-g.torture.execute-pr64242/pr64242.c b/testsuite/c_test/x64_be_enable_test/GCC00539-g.torture.execute-pr64242/pr64242.c
new file mode 100644
index 0000000000000000000000000000000000000000..49b74f659c8024522222a6a83766e82f58553805
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00539-g.torture.execute-pr64242/pr64242.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target indirect_jumps } */
+
+#include <setjmp.h>
+
+extern void abort (void);
+
+__attribute ((noinline)) void
+broken_longjmp (void *p)
+{
+  char *buf[sizeof(jmp_buf)];
+  memcpy (buf, p, sizeof(jmp_buf));
+  memset (p, 0, sizeof(jmp_buf));
+  /* Corrupts stack pointer...  */
+  longjmp (buf, 1);
+}
+
+volatile int x = 0;
+char *volatile p;
+char *volatile q;
+
+int
+main ()
+{
+  jmp_buf buf;
+  p = alloca (x);
+  q = alloca (x);
+  if (!setjmp(buf)) {
+    broken_longjmp (buf);
+  }
+
+  /* Compute expected next alloca offset - some targets don't align properly
+     and allocate too much.  */
+  p = q + (q - p);
+
+  /* Fails if stack pointer corrupted.  */
+  if (p != alloca (x))
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00539-g.torture.execute-pr64242/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00539-g.torture.execute-pr64242/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b20205faf3fed17c12af5fae3512ffd14146ef59
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00539-g.torture.execute-pr64242/test.cfg
@@ -0,0 +1,2 @@
+compile(pr64242)
+run(pr64242)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00540-g.torture.execute-pr64255/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00540-g.torture.execute-pr64255/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00540-g.torture.execute-pr64255/pr64255.c b/testsuite/c_test/x64_be_enable_test/GCC00540-g.torture.execute-pr64255/pr64255.c
new file mode 100644
index 0000000000000000000000000000000000000000..447638af35f17d942a899531455e09d1ae52a4f3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00540-g.torture.execute-pr64255/pr64255.c
@@ -0,0 +1,28 @@
+/* PR rtl-optimization/64255 */
+
+__attribute__((noinline, noclone)) void
+bar (long i, unsigned long j)
+{
+  if (i != 1 || j != 1)
+    __builtin_abort ();
+}
+
+__attribute__((noinline, noclone)) void
+foo (long i)
+{
+  unsigned long j;
+
+  if (!i)
+    return;
+  j = i >= 0 ? (unsigned long) i : - (unsigned long) i;
+  if ((i >= 0 ? (unsigned long) i : - (unsigned long) i) != j)
+    __builtin_abort ();
+  bar (i, j);
+}
+
+int
+main ()
+{
+  foo (1);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00540-g.torture.execute-pr64255/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00540-g.torture.execute-pr64255/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..765a5fc538dfb268d805216355e1916e1fc0c9d3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00540-g.torture.execute-pr64255/test.cfg
@@ -0,0 +1,2 @@
+compile(pr64255)
+run(pr64255)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00541-g.torture.execute-pr64756/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00541-g.torture.execute-pr64756/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00541-g.torture.execute-pr64756/pr64756.c b/testsuite/c_test/x64_be_enable_test/GCC00541-g.torture.execute-pr64756/pr64756.c
new file mode 100644
index 0000000000000000000000000000000000000000..b76f278291db7c0f8819a7530a2a3d479924e459
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00541-g.torture.execute-pr64756/pr64756.c
@@ -0,0 +1,30 @@
+/* PR rtl-optimization/64756 */
+
+int a, *tmp, **c = &tmp;
+volatile int d;
+static int *volatile *e = &tmp;
+unsigned int f;
+
+static void
+fn1 (int *p)
+{
+  int g;
+  for (; f < 1; f++)
+    for (g = 1; g >= 0; g--)
+      {
+	d || d;
+	*c = p;
+
+	if (tmp != &a)
+	  __builtin_abort ();
+
+	*e = 0;
+      }
+}
+
+int
+main ()
+{
+  fn1 (&a);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00541-g.torture.execute-pr64756/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00541-g.torture.execute-pr64756/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6936ba0aebee868832aa7dd4e9d4919a25478dea
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00541-g.torture.execute-pr64756/test.cfg
@@ -0,0 +1,2 @@
+compile(pr64756)
+run(pr64756)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00542-g.torture.execute-pr64957/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00542-g.torture.execute-pr64957/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00542-g.torture.execute-pr64957/pr64957.c b/testsuite/c_test/x64_be_enable_test/GCC00542-g.torture.execute-pr64957/pr64957.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a70e172d37907ebbea7b9f6d5d0b6472fcc280d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00542-g.torture.execute-pr64957/pr64957.c
@@ -0,0 +1,23 @@
+/* PR rtl-optimization/64957 */
+
+__attribute__((noinline, noclone)) int
+foo (int b)
+{
+  return (((b ^ 5) | 1) ^ 5) | 1;
+}
+
+__attribute__((noinline, noclone)) int
+bar (int b)
+{
+  return (((b ^ ~5) & ~1) ^ ~5) & ~1;
+}
+
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 16; i++)
+    if (foo (i) != (i | 1) || bar (i) != (i & ~1))
+      __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00542-g.torture.execute-pr64957/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00542-g.torture.execute-pr64957/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..75620f2f812ea31442f190df003f5a41fdf834ab
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00542-g.torture.execute-pr64957/test.cfg
@@ -0,0 +1,2 @@
+compile(pr64957)
+run(pr64957)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00543-g.torture.execute-pr65053-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00543-g.torture.execute-pr65053-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00543-g.torture.execute-pr65053-1/pr65053-1.c b/testsuite/c_test/x64_be_enable_test/GCC00543-g.torture.execute-pr65053-1/pr65053-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..edcf41ddb453b1670804b396ee7ad87eda802511
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00543-g.torture.execute-pr65053-1/pr65053-1.c
@@ -0,0 +1,32 @@
+/* PR tree-optimization/65053 */
+
+int i;
+
+__attribute__ ((noinline, noclone))
+unsigned int foo (void)
+{
+  return 0;
+}
+
+int
+main ()
+{
+  unsigned int u = -1;
+  if (u == -1)
+    {
+      unsigned int n = foo ();
+      if (n > 0)
+	u = n - 1;
+    }
+
+  while (u != -1)
+    {
+      asm ("" : "+g" (u));
+      u = -1;
+      i = 1;
+    }
+
+  if (i)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00543-g.torture.execute-pr65053-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00543-g.torture.execute-pr65053-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..130a9f77349d1a2fac774808e749e78b7402208a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00543-g.torture.execute-pr65053-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65053-1)
+run(pr65053-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00544-g.torture.execute-pr65053-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00544-g.torture.execute-pr65053-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00544-g.torture.execute-pr65053-2/pr65053-2.c b/testsuite/c_test/x64_be_enable_test/GCC00544-g.torture.execute-pr65053-2/pr65053-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a0f4e4636131edd3f8d1683003622dea3cea707
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00544-g.torture.execute-pr65053-2/pr65053-2.c
@@ -0,0 +1,27 @@
+/* PR tree-optimization/65053 */
+
+int i;
+unsigned int x;
+
+int
+main ()
+{
+  asm volatile ("" : "+g" (x));
+  unsigned int n = x;
+  unsigned int u = 32;
+  if (n >= 32)
+    __builtin_abort ();
+  if (n != 0)
+    u = n + 32;
+
+  while (u != 32)
+    {
+      asm ("" : : "g" (u));
+      u = 32;
+      i = 1;
+    }
+
+  if (i)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00544-g.torture.execute-pr65053-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00544-g.torture.execute-pr65053-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8375dc6893500c73227e06abdd56bd57d44e2e1a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00544-g.torture.execute-pr65053-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65053-2)
+run(pr65053-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00545-g.torture.execute-pr65215-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00545-g.torture.execute-pr65215-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00545-g.torture.execute-pr65215-1/pr65215-1.c b/testsuite/c_test/x64_be_enable_test/GCC00545-g.torture.execute-pr65215-1/pr65215-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..07b89fc8fb7e3a409b6dd78ea0691eef9982ab9f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00545-g.torture.execute-pr65215-1/pr65215-1.c
@@ -0,0 +1,24 @@
+/* PR tree-optimization/65215 */
+
+static inline unsigned int
+foo (unsigned int x)
+{
+  return (x >> 24) | ((x >> 8) & 0xff00) | ((x << 8) & 0xff0000) | (x << 24);
+}
+
+__attribute__((noinline, noclone)) unsigned int
+bar (unsigned long long *x)
+{
+  return foo (*x);
+}
+
+int
+main ()
+{
+  if (__CHAR_BIT__ != 8 || sizeof (unsigned int) != 4 || sizeof (unsigned long long) != 8)
+    return 0;
+  unsigned long long l = foo (0xdeadbeefU) | 0xfeedbea800000000ULL;
+  if (bar (&l) != 0xdeadbeefU)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00545-g.torture.execute-pr65215-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00545-g.torture.execute-pr65215-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f1bc90e4d7f7e6258ca6f2c34a10d38a8278e150
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00545-g.torture.execute-pr65215-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65215-1)
+run(pr65215-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00546-g.torture.execute-pr65215-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00546-g.torture.execute-pr65215-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00546-g.torture.execute-pr65215-2/pr65215-2.c b/testsuite/c_test/x64_be_enable_test/GCC00546-g.torture.execute-pr65215-2/pr65215-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2842057c50a8eff0e2d683fbe5c0d38c38a61fb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00546-g.torture.execute-pr65215-2/pr65215-2.c
@@ -0,0 +1,24 @@
+/* PR tree-optimization/65215 */
+
+static inline unsigned int
+foo (unsigned int x)
+{
+  return (x >> 24) | ((x >> 8) & 0xff00) | ((x << 8) & 0xff0000) | (x << 24);
+}
+
+__attribute__((noinline, noclone)) unsigned long long
+bar (unsigned long long *x)
+{
+  return ((unsigned long long) foo (*x) << 32) | foo (*x >> 32);
+}
+
+int
+main ()
+{
+  if (__CHAR_BIT__ != 8 || sizeof (unsigned int) != 4 || sizeof (unsigned long long) != 8)
+    return 0;
+  unsigned long long l = foo (0xfeedbea8U) | ((unsigned long long) foo (0xdeadbeefU) << 32);
+  if (bar (&l) != 0xfeedbea8deadbeefULL)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00546-g.torture.execute-pr65215-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00546-g.torture.execute-pr65215-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7f2707eea1019680bd1fb7a50d2cc226f6b234e1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00546-g.torture.execute-pr65215-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65215-2)
+run(pr65215-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00547-g.torture.execute-pr65215-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00547-g.torture.execute-pr65215-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00547-g.torture.execute-pr65215-3/pr65215-3.c b/testsuite/c_test/x64_be_enable_test/GCC00547-g.torture.execute-pr65215-3/pr65215-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..0874e193b9db3430ff567b7abd1fa12db4816f00
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00547-g.torture.execute-pr65215-3/pr65215-3.c
@@ -0,0 +1,31 @@
+/* PR tree-optimization/65215 */
+
+struct S { unsigned long long l1 : 24, l2 : 8, l3 : 32; };
+
+static inline unsigned int
+foo (unsigned int x)
+{
+  return (x >> 24) | ((x >> 8) & 0xff00) | ((x << 8) & 0xff0000) | (x << 24);
+}
+
+__attribute__((noinline, noclone)) unsigned long long
+bar (struct S *x)
+{
+  unsigned long long x1 = foo (((unsigned int) x->l1 << 8) | x->l2);
+  unsigned long long x2 = foo (x->l3);
+  return (x2 << 32) | x1;
+}
+
+int
+main ()
+{
+  if (__CHAR_BIT__ != 8 || sizeof (unsigned int) != 4 || sizeof (unsigned long long) != 8)
+    return 0;
+  struct S s = { 0xdeadbeU, 0xefU, 0xfeedbea8U };
+  unsigned long long l = bar (&s);
+  if (foo (l >> 32) != s.l3
+      || (foo (l) >> 8) != s.l1
+      || (foo (l) & 0xff) != s.l2)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00547-g.torture.execute-pr65215-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00547-g.torture.execute-pr65215-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d57b178f243fcdda1b63ae1f7417212424a4262d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00547-g.torture.execute-pr65215-3/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65215-3)
+run(pr65215-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00548-g.torture.execute-pr65215-4/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00548-g.torture.execute-pr65215-4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00548-g.torture.execute-pr65215-4/pr65215-4.c b/testsuite/c_test/x64_be_enable_test/GCC00548-g.torture.execute-pr65215-4/pr65215-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..8044d123ae029b571d3093551bcea7abca51e45c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00548-g.torture.execute-pr65215-4/pr65215-4.c
@@ -0,0 +1,27 @@
+/* PR tree-optimization/65215 */
+
+struct S { unsigned long long l1 : 48; };
+
+static inline unsigned int
+foo (unsigned int x)
+{
+  return (x >> 24) | ((x >> 8) & 0xff00) | ((x << 8) & 0xff0000) | (x << 24);
+}
+
+__attribute__((noinline, noclone)) unsigned int
+bar (struct S *x)
+{
+  return foo (x->l1);
+}
+
+int
+main ()
+{
+  if (__CHAR_BIT__ != 8 || sizeof (unsigned int) != 4 || sizeof (unsigned long long) != 8)
+    return 0;
+  struct S s;
+  s.l1 = foo (0xdeadbeefU) | (0xfeedULL << 32);
+  if (bar (&s) != 0xdeadbeefU)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00548-g.torture.execute-pr65215-4/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00548-g.torture.execute-pr65215-4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..428bf51804226e4625c93366fec9c65de4fd44bb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00548-g.torture.execute-pr65215-4/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65215-4)
+run(pr65215-4)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00549-g.torture.execute-pr65215-5/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00549-g.torture.execute-pr65215-5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00549-g.torture.execute-pr65215-5/pr65215-5.c b/testsuite/c_test/x64_be_enable_test/GCC00549-g.torture.execute-pr65215-5/pr65215-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..c30d11f19ad9c4231a25f8decbfb2f34996d4260
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00549-g.torture.execute-pr65215-5/pr65215-5.c
@@ -0,0 +1,27 @@
+/* PR tree-optimization/65215 */
+
+__attribute__((noinline, noclone)) unsigned int
+foo (unsigned char *p)
+{
+  return ((unsigned int) p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
+}
+
+__attribute__((noinline, noclone)) unsigned int
+bar (unsigned char *p)
+{
+  return ((unsigned int) p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+}
+
+struct S { unsigned int a; unsigned char b[5]; };
+
+int
+main ()
+{
+  struct S s = { 1, { 2, 3, 4, 5, 6 } };
+  if (__CHAR_BIT__ != 8 || sizeof (unsigned int) != 4)
+    return 0;
+  if (foo (&s.b[1]) != 0x03040506U
+      || bar (&s.b[1]) != 0x06050403U)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00549-g.torture.execute-pr65215-5/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00549-g.torture.execute-pr65215-5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1756ec1ff175d701a4c739a00d0d8dcb8d18356c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00549-g.torture.execute-pr65215-5/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65215-5)
+run(pr65215-5)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00550-g.torture.execute-pr65216/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00550-g.torture.execute-pr65216/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00550-g.torture.execute-pr65216/pr65216.c b/testsuite/c_test/x64_be_enable_test/GCC00550-g.torture.execute-pr65216/pr65216.c
new file mode 100644
index 0000000000000000000000000000000000000000..0714d8ceebb30e457eda517b4064f4306797e50e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00550-g.torture.execute-pr65216/pr65216.c
@@ -0,0 +1,20 @@
+/* PR tree-optimization/65216 */
+
+int a, b = 62, e;
+volatile int c, d;
+
+int
+main ()
+{
+  int f = 0;
+  for (a = 0; a < 2; a++)
+    {
+      b &= (8 ^ f) & 1;
+      for (e = 0; e < 6; e++)
+	if (c)
+	  f = d;
+    }
+  if (b != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00550-g.torture.execute-pr65216/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00550-g.torture.execute-pr65216/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..41ac8d303cbdf1810ee85f191b83c618023efe50
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00550-g.torture.execute-pr65216/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65216)
+run(pr65216)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00551-g.torture.execute-pr65369/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00551-g.torture.execute-pr65369/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00551-g.torture.execute-pr65369/pr65369.c b/testsuite/c_test/x64_be_enable_test/GCC00551-g.torture.execute-pr65369/pr65369.c
new file mode 100644
index 0000000000000000000000000000000000000000..017fe1b01ce26d169b94b52ddbb4f95387bf73a5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00551-g.torture.execute-pr65369/pr65369.c
@@ -0,0 +1,46 @@
+/* PR tree-optimization/65369 */
+#include <stdint.h>
+
+static const char data[] =
+  "12345678901234567890123456789012345678901234567890"
+  "123456789012345678901234567890";
+
+__attribute__ ((noinline))
+static void foo (const unsigned int *buf)
+{
+  if (__builtin_memcmp (buf, data, 64))
+    __builtin_abort ();
+}
+
+__attribute__ ((noinline))
+static void bar (const unsigned char *block)
+{
+  uint32_t buf[16];
+  __builtin_memcpy (buf +  0, block +  0, 4);
+  __builtin_memcpy (buf +  1, block +  4, 4);
+  __builtin_memcpy (buf +  2, block +  8, 4);
+  __builtin_memcpy (buf +  3, block + 12, 4);
+  __builtin_memcpy (buf +  4, block + 16, 4);
+  __builtin_memcpy (buf +  5, block + 20, 4);
+  __builtin_memcpy (buf +  6, block + 24, 4);
+  __builtin_memcpy (buf +  7, block + 28, 4);
+  __builtin_memcpy (buf +  8, block + 32, 4);
+  __builtin_memcpy (buf +  9, block + 36, 4);
+  __builtin_memcpy (buf + 10, block + 40, 4);
+  __builtin_memcpy (buf + 11, block + 44, 4);
+  __builtin_memcpy (buf + 12, block + 48, 4);
+  __builtin_memcpy (buf + 13, block + 52, 4);
+  __builtin_memcpy (buf + 14, block + 56, 4);
+  __builtin_memcpy (buf + 15, block + 60, 4);
+  foo (buf);
+}
+
+int
+main ()
+{
+  unsigned char input[sizeof data + 16] __attribute__((aligned (16)));
+  __builtin_memset (input, 0, sizeof input);
+  __builtin_memcpy (input + 1, data, sizeof data);
+  bar (input + 1);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00551-g.torture.execute-pr65369/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00551-g.torture.execute-pr65369/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..173b05ce2290be8e5f195318f1a9b1e5405be0d2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00551-g.torture.execute-pr65369/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65369)
+run(pr65369)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00552-g.torture.execute-pr66940/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00552-g.torture.execute-pr66940/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00552-g.torture.execute-pr66940/pr66940.c b/testsuite/c_test/x64_be_enable_test/GCC00552-g.torture.execute-pr66940/pr66940.c
new file mode 100644
index 0000000000000000000000000000000000000000..fbd109dccc72c290d935d81a3f3dd219f11f908d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00552-g.torture.execute-pr66940/pr66940.c
@@ -0,0 +1,20 @@
+long long __attribute__ ((noinline, noclone))
+foo (long long ival)
+{
+ if (ival <= 0)
+    return -0x7fffffffffffffffL - 1;
+
+ return 0x7fffffffffffffffL;
+}
+
+int
+main (void)
+{
+  if (foo (-1) != (-0x7fffffffffffffffL - 1))
+    __builtin_abort ();
+
+  if (foo (1) != 0x7fffffffffffffffL)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00552-g.torture.execute-pr66940/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00552-g.torture.execute-pr66940/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b27bea6109b984b2bdaf5cecb48eb5bebc0de77a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00552-g.torture.execute-pr66940/test.cfg
@@ -0,0 +1,2 @@
+compile(pr66940)
+run(pr66940)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00553-g.torture.execute-pr67226/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00553-g.torture.execute-pr67226/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00553-g.torture.execute-pr67226/pr67226.c b/testsuite/c_test/x64_be_enable_test/GCC00553-g.torture.execute-pr67226/pr67226.c
new file mode 100644
index 0000000000000000000000000000000000000000..c533496cbc6fa06872d415c3bba5cc5fe8d4c651
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00553-g.torture.execute-pr67226/pr67226.c
@@ -0,0 +1,42 @@
+struct assembly_operand
+{
+  int type, value, symtype, symflags, marker;
+};
+
+struct assembly_operand to_input, from_input;
+
+void __attribute__ ((__noinline__, __noclone__))
+assemblez_1 (int internal_number, struct assembly_operand o1)
+{
+  if (o1.type != from_input.type)
+    __builtin_abort ();
+}
+
+void __attribute__ ((__noinline__, __noclone__))
+t0 (struct assembly_operand to, struct assembly_operand from)
+{
+  if (to.value == 0)
+    assemblez_1 (32, from);
+  else
+    __builtin_abort ();
+}
+
+int
+main (void)
+{
+  to_input.value = 0;
+  to_input.type = 1;
+  to_input.symtype = 2;
+  to_input.symflags = 3;
+  to_input.marker = 4;
+
+  from_input.value = 5;
+  from_input.type = 6;
+  from_input.symtype = 7;
+  from_input.symflags = 8;
+  from_input.marker = 9;
+
+  t0 (to_input, from_input);
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00553-g.torture.execute-pr67226/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00553-g.torture.execute-pr67226/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b6e07089abcef294b612ea1ebea5724e345e5d6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00553-g.torture.execute-pr67226/test.cfg
@@ -0,0 +1,2 @@
+compile(pr67226)
+run(pr67226)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00554-g.torture.execute-pr67781/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00554-g.torture.execute-pr67781/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00554-g.torture.execute-pr67781/pr67781.c b/testsuite/c_test/x64_be_enable_test/GCC00554-g.torture.execute-pr67781/pr67781.c
new file mode 100644
index 0000000000000000000000000000000000000000..71ccd6a45af4b6dbc41460596fe70749c72146ef
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00554-g.torture.execute-pr67781/pr67781.c
@@ -0,0 +1,35 @@
+/* { dg-require-effective-target int32plus } */
+#ifdef __UINT32_TYPE__
+typedef __UINT32_TYPE__ uint32_t;
+#else
+typedef unsigned uint32_t;
+#endif
+
+#ifdef __UINT8_TYPE__
+typedef __UINT8_TYPE__ uint8_t;
+#else
+typedef unsigned char uint8_t;
+#endif
+
+struct
+{
+  uint32_t a;
+  uint8_t b;
+} s = { 0x123456, 0x78 };
+
+int pr67781()
+{
+  uint32_t c = (s.a << 8) | s.b;
+  return c;
+}
+
+int
+main ()
+{
+  if (sizeof (uint32_t) * __CHAR_BIT__ != 32)
+    return 0;
+
+  if (pr67781 () != 0x12345678)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00554-g.torture.execute-pr67781/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00554-g.torture.execute-pr67781/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cddf089da92dacaf469a291a7b3f64a51859098b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00554-g.torture.execute-pr67781/test.cfg
@@ -0,0 +1,2 @@
+compile(pr67781)
+run(pr67781)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00555-g.torture.execute-pr68376-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00555-g.torture.execute-pr68376-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00555-g.torture.execute-pr68376-2/pr68376-2.c b/testsuite/c_test/x64_be_enable_test/GCC00555-g.torture.execute-pr68376-2/pr68376-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..963d441b53f5c16052e2fb6f03939df7ccdd5f04
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00555-g.torture.execute-pr68376-2/pr68376-2.c
@@ -0,0 +1,73 @@
+/* PR rtl-optimization/68376 */
+
+extern void abort (void);
+
+__attribute__((noinline, noclone)) int
+f1 (int x)
+{
+  return x < 0 ? ~x : x;
+}
+
+__attribute__((noinline, noclone)) int
+f2 (int x)
+{
+  return x < 0 ? x : ~x;
+}
+
+__attribute__((noinline, noclone)) int
+f3 (int x)
+{
+  return x <= 0 ? ~x : x;
+}
+
+__attribute__((noinline, noclone)) int
+f4 (int x)
+{
+  return x <= 0 ? x : ~x;
+}
+
+__attribute__((noinline, noclone)) int
+f5 (int x)
+{
+  return x >= 0 ? ~x : x;
+}
+
+__attribute__((noinline, noclone)) int
+f6 (int x)
+{
+  return x >= 0 ? x : ~x;
+}
+
+__attribute__((noinline, noclone)) int
+f7 (int x)
+{
+  return x > 0 ? ~x : x;
+}
+
+__attribute__((noinline, noclone)) int
+f8 (int x)
+{
+  return x > 0 ? x : ~x;
+}
+
+int
+main ()
+{
+  if (f1 (5) != 5 || f1 (-5) != 4 || f1 (0) != 0)
+    abort ();
+  if (f2 (5) != -6 || f2 (-5) != -5 || f2 (0) != -1)
+    abort ();
+  if (f3 (5) != 5 || f3 (-5) != 4 || f3 (0) != -1)
+    abort ();
+  if (f4 (5) != -6 || f4 (-5) != -5 || f4 (0) != 0)
+    abort ();
+  if (f5 (5) != -6 || f5 (-5) != -5 || f5 (0) != -1)
+    abort ();
+  if (f6 (5) != 5 || f6 (-5) != 4 || f6 (0) != 0)
+    abort ();
+  if (f7 (5) != -6 || f7 (-5) != -5 || f7 (0) != 0)
+    abort ();
+  if (f8 (5) != 5 || f8 (-5) != 4 || f8 (0) != -1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00555-g.torture.execute-pr68376-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00555-g.torture.execute-pr68376-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2173bc4374fd06b8d2e09073b2a325e63ca9950d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00555-g.torture.execute-pr68376-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr68376-2)
+run(pr68376-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00556-g.torture.execute-pr68648/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00556-g.torture.execute-pr68648/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00556-g.torture.execute-pr68648/pr68648.c b/testsuite/c_test/x64_be_enable_test/GCC00556-g.torture.execute-pr68648/pr68648.c
new file mode 100644
index 0000000000000000000000000000000000000000..db55bd0ebce65f29561102879e7bd063d6ecff88
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00556-g.torture.execute-pr68648/pr68648.c
@@ -0,0 +1,21 @@
+/* { dg-require-effective-target int32plus } */
+int __attribute__ ((noinline))
+foo (void)
+{
+  return 123;
+}
+
+int __attribute__ ((noinline))
+bar (void)
+{
+  int c = 1;
+  c |= 4294967295 ^ (foo () | 4073709551608);
+  return c;
+}
+
+int
+main ()
+{
+  if (bar () != 0x83fd4005)
+    __builtin_abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00556-g.torture.execute-pr68648/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00556-g.torture.execute-pr68648/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6492c537a7c5bc76f1cb31bbf8e88dff932aaa5f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00556-g.torture.execute-pr68648/test.cfg
@@ -0,0 +1,2 @@
+compile(pr68648)
+run(pr68648)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00557-g.torture.execute-pr68841/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00557-g.torture.execute-pr68841/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00557-g.torture.execute-pr68841/pr68841.c b/testsuite/c_test/x64_be_enable_test/GCC00557-g.torture.execute-pr68841/pr68841.c
new file mode 100644
index 0000000000000000000000000000000000000000..15a27e7dc382d97398ca05427f431f5ecd3b89da
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00557-g.torture.execute-pr68841/pr68841.c
@@ -0,0 +1,31 @@
+static inline int
+foo (int *x, int y)
+{
+  int z = *x;
+  while (y > z)
+    z *= 2;
+  return z;
+}
+
+int
+main ()
+{
+  int i;
+  for (i = 1; i < 17; i++)
+    {
+      int j;
+      int k;
+      j = foo (&i, 7);
+      if (i >= 7)
+	k = i;
+      else if (i >= 4)
+	k = 8 + (i - 4) * 2;
+      else if (i == 3)
+	k = 12;
+      else
+	k = 8;
+      if (j != k)
+	__builtin_abort ();
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00557-g.torture.execute-pr68841/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00557-g.torture.execute-pr68841/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e15f5851b93688ab79b70336275ef8137ed5815
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00557-g.torture.execute-pr68841/test.cfg
@@ -0,0 +1,2 @@
+compile(pr68841)
+run(pr68841)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00558-g.torture.execute-pr69403/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00558-g.torture.execute-pr69403/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00558-g.torture.execute-pr69403/pr69403.c b/testsuite/c_test/x64_be_enable_test/GCC00558-g.torture.execute-pr69403/pr69403.c
new file mode 100644
index 0000000000000000000000000000000000000000..097d366079df46e5bc41b05d835d5f3b3ea0e1a4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00558-g.torture.execute-pr69403/pr69403.c
@@ -0,0 +1,20 @@
+/* PR target/69403.  */
+
+int a, b, c;
+
+__attribute__ ((__noinline__)) int
+fn1 ()
+{
+  if ((b | (a != (a & c))) == 1)
+    __builtin_abort ();
+  return 0;
+}
+
+int
+main (void)
+{
+  a = 5;
+  c = 1;
+  b = 6;
+  return fn1 ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00558-g.torture.execute-pr69403/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00558-g.torture.execute-pr69403/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a1fa5bacbec07ce723bf109c06a9b7225bed22a6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00558-g.torture.execute-pr69403/test.cfg
@@ -0,0 +1,2 @@
+compile(pr69403)
+run(pr69403)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00559-g.torture.execute-pr70222-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00559-g.torture.execute-pr70222-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00559-g.torture.execute-pr70222-2/pr70222-2.c b/testsuite/c_test/x64_be_enable_test/GCC00559-g.torture.execute-pr70222-2/pr70222-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..7611c986a9b752c5a25bd88081a7b9ba034fdf95
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00559-g.torture.execute-pr70222-2/pr70222-2.c
@@ -0,0 +1,20 @@
+/* PR rtl-optimization/70222 */
+
+#if __CHAR_BIT__ == 8 && __SIZEOF_INT__ == 4 && __SIZEOF_LONG_LONG__ == 8
+__attribute__((noinline, noclone)) unsigned int
+foo (int x)
+{
+  unsigned long long y = -1ULL >> x;
+  return (unsigned int) y >> 31;
+}
+#endif
+
+int
+main ()
+{
+#if __CHAR_BIT__ == 8 && __SIZEOF_INT__ == 4 && __SIZEOF_LONG_LONG__ == 8
+  if (foo (15) != 1 || foo (32) != 1 || foo (33) != 0)
+    __builtin_abort ();
+#endif
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00559-g.torture.execute-pr70222-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00559-g.torture.execute-pr70222-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc923e32270d397dd616823a86928bc1021eefbf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00559-g.torture.execute-pr70222-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr70222-2)
+run(pr70222-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00560-g.torture.execute-pr70429/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00560-g.torture.execute-pr70429/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00560-g.torture.execute-pr70429/pr70429.c b/testsuite/c_test/x64_be_enable_test/GCC00560-g.torture.execute-pr70429/pr70429.c
new file mode 100644
index 0000000000000000000000000000000000000000..6b08c8ead08492c3f3e767bddd31c0d1eeda6e8e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00560-g.torture.execute-pr70429/pr70429.c
@@ -0,0 +1,17 @@
+/* PR rtl-optimization/70429 */
+
+__attribute__((noinline, noclone)) int
+foo (int a)
+{
+  return (int) (0x14ff6e2207db5d1fLL >> a) >> 4;
+}
+
+int
+main ()
+{
+  if (sizeof (int) != 4 || sizeof (long long) != 8 || __CHAR_BIT__ != 8)
+    return 0;
+  if (foo (1) != 0x3edae8 || foo (2) != -132158092)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00560-g.torture.execute-pr70429/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00560-g.torture.execute-pr70429/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0287c1680694a97054071c67f100abfac9df136e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00560-g.torture.execute-pr70429/test.cfg
@@ -0,0 +1,2 @@
+compile(pr70429)
+run(pr70429)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00561-g.torture.execute-pr70460/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00561-g.torture.execute-pr70460/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00561-g.torture.execute-pr70460/pr70460.c b/testsuite/c_test/x64_be_enable_test/GCC00561-g.torture.execute-pr70460/pr70460.c
new file mode 100644
index 0000000000000000000000000000000000000000..04fa1efc19937bcc5c9e3ae7539929741b7eb64a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00561-g.torture.execute-pr70460/pr70460.c
@@ -0,0 +1,33 @@
+/* { dg-require-effective-target indirect_jumps } */
+/* { dg-require-effective-target label_values } */
+/* { dg-skip-if "label differences not supported" { avr-*-* } } */
+
+/* PR rtl-optimization/70460 */
+
+int c;
+
+__attribute__((noinline, noclone)) void
+foo (int x)
+{
+  static int b[] = { &&lab1 - &&lab0, &&lab2 - &&lab0 };
+  void *a = &&lab0 + b[x];
+  goto *a;
+lab1:
+  c += 2;
+lab2:
+  c++;
+lab0:
+  ;
+}
+
+int
+main ()
+{
+  foo (0);
+  if (c != 3)
+    __builtin_abort ();
+  foo (1);
+  if (c != 4)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00561-g.torture.execute-pr70460/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00561-g.torture.execute-pr70460/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..64cb2e44ab0b97b8bb6b430b7ffde618006e21fd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00561-g.torture.execute-pr70460/test.cfg
@@ -0,0 +1,2 @@
+compile(pr70460)
+run(pr70460)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00562-g.torture.execute-pr70566/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00562-g.torture.execute-pr70566/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00562-g.torture.execute-pr70566/pr70566.c b/testsuite/c_test/x64_be_enable_test/GCC00562-g.torture.execute-pr70566/pr70566.c
new file mode 100644
index 0000000000000000000000000000000000000000..f47106e70c7d4d7f3623f9505c02445a63332a9d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00562-g.torture.execute-pr70566/pr70566.c
@@ -0,0 +1,47 @@
+/* PR target/70566.  */
+
+#define NULL 0
+
+struct mystruct
+{
+  unsigned int f1 : 1;
+  unsigned int f2 : 1;
+  unsigned int f3 : 1;
+};
+
+__attribute__ ((noinline)) void
+myfunc (int a, void *b)
+{
+}
+__attribute__ ((noinline)) int
+myfunc2 (void *a)
+{
+  return 0;
+}
+
+static void
+set_f2 (struct mystruct *user, int f2)
+{
+  if (user->f2 != f2)
+    myfunc (myfunc2 (NULL), NULL);
+  else
+    __builtin_abort ();
+}
+
+__attribute__ ((noinline)) void
+foo (void *data)
+{
+  struct mystruct *user = data;
+  if (!user->f2)
+    set_f2 (user, 1);
+}
+
+int
+main (void)
+{
+  struct mystruct a;
+  a.f1 = 1;
+  a.f2 = 0;
+  foo (&a);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00562-g.torture.execute-pr70566/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00562-g.torture.execute-pr70566/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eca5108ef9c37386c5ff5a63d20adb4baf64373c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00562-g.torture.execute-pr70566/test.cfg
@@ -0,0 +1,2 @@
+compile(pr70566)
+run(pr70566)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00563-g.torture.execute-pr71335/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00563-g.torture.execute-pr71335/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00563-g.torture.execute-pr71335/pr71335.c b/testsuite/c_test/x64_be_enable_test/GCC00563-g.torture.execute-pr71335/pr71335.c
new file mode 100644
index 0000000000000000000000000000000000000000..cbfd99083d072d9fb16ae2c8c754b079d5df260f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00563-g.torture.execute-pr71335/pr71335.c
@@ -0,0 +1,13 @@
+int a;
+int
+main ()
+{
+  int b = 0;
+  while (a < 0 || b)
+    {
+      b = 0;
+      for (; b < 9; b++)
+	;
+    }
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00563-g.torture.execute-pr71335/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00563-g.torture.execute-pr71335/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..06ab570ff7389654b4ceaee4a398dbe70107f0fa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00563-g.torture.execute-pr71335/test.cfg
@@ -0,0 +1,2 @@
+compile(pr71335)
+run(pr71335)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00564-g.torture.execute-pr71700/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00564-g.torture.execute-pr71700/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00564-g.torture.execute-pr71700/pr71700.c b/testsuite/c_test/x64_be_enable_test/GCC00564-g.torture.execute-pr71700/pr71700.c
new file mode 100644
index 0000000000000000000000000000000000000000..80afd3809c3abd24135fb36b757ace9f41ba3112
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00564-g.torture.execute-pr71700/pr71700.c
@@ -0,0 +1,19 @@
+struct S
+{
+  signed f0 : 16;
+  unsigned f1 : 1;
+};
+
+int b;
+static struct S c[] = {{-1, 0}, {-1, 0}};
+struct S d;
+
+int
+main ()
+{
+  struct S e = c[0];
+  d = e;
+  if (d.f1 != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00564-g.torture.execute-pr71700/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00564-g.torture.execute-pr71700/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f840ad39bc65bcd41b54a6dd4cead6ea2d200950
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00564-g.torture.execute-pr71700/test.cfg
@@ -0,0 +1,2 @@
+compile(pr71700)
+run(pr71700)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00565-g.torture.execute-pr77718/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00565-g.torture.execute-pr77718/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00565-g.torture.execute-pr77718/pr77718.c b/testsuite/c_test/x64_be_enable_test/GCC00565-g.torture.execute-pr77718/pr77718.c
new file mode 100644
index 0000000000000000000000000000000000000000..a76effef801f51e67e989a3cd5ff027950fc6bf7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00565-g.torture.execute-pr77718/pr77718.c
@@ -0,0 +1,25 @@
+/* PR middle-end/77718 */
+
+char a[64] __attribute__((aligned (8)));
+
+__attribute__((noinline, noclone)) int
+foo (void)
+{
+  return __builtin_memcmp ("bbbbbb", a, 6);
+}
+
+__attribute__((noinline, noclone)) int
+bar (void)
+{
+  return __builtin_memcmp (a, "bbbbbb", 6);
+}
+
+int
+main ()
+{
+  __builtin_memset (a, 'a', sizeof (a));
+  if (((foo () < 0) ^ ('a' > 'b'))
+      || ((bar () < 0) ^ ('a' < 'b')))
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00565-g.torture.execute-pr77718/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00565-g.torture.execute-pr77718/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..30d4fd080793c513bf05584528be0ae8050231b3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00565-g.torture.execute-pr77718/test.cfg
@@ -0,0 +1,2 @@
+compile(pr77718)
+run(pr77718)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00566-g.torture.execute-pr78170/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00566-g.torture.execute-pr78170/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00566-g.torture.execute-pr78170/pr78170.c b/testsuite/c_test/x64_be_enable_test/GCC00566-g.torture.execute-pr78170/pr78170.c
new file mode 100644
index 0000000000000000000000000000000000000000..dce8a3eee362f43216210abb20df14520ded0cd7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00566-g.torture.execute-pr78170/pr78170.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target int32plus } */
+
+/* PR tree-optimization/78170.
+   Check that sign-extended store to a bitfield
+   doesn't overwrite other fields.  */
+
+int a, b, d;
+
+struct S0
+{
+  int f0;
+  int f1;
+  int f2;
+  int f3;
+  int f4;
+  int f5:15;
+  int f6:17;
+  int f7:2;
+  int f8:30;
+} c;
+
+void fn1 ()
+{
+  d = b = 1;
+  for (; b; b = a)
+    {
+      struct S0 e = { 0, 0, 0, 0, 0, 0, 1, 0, 1 };
+      c = e;
+      c.f6 = -1;
+    }
+}
+
+int main ()
+{
+  fn1 ();
+  if (c.f7 != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00566-g.torture.execute-pr78170/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00566-g.torture.execute-pr78170/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0e16365ea7e7e254dcdc46ccecb0fbafa62bdc0c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00566-g.torture.execute-pr78170/test.cfg
@@ -0,0 +1,2 @@
+compile(pr78170)
+run(pr78170)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00567-g.torture.execute-pr78586/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00567-g.torture.execute-pr78586/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00567-g.torture.execute-pr78586/pr78586.c b/testsuite/c_test/x64_be_enable_test/GCC00567-g.torture.execute-pr78586/pr78586.c
new file mode 100644
index 0000000000000000000000000000000000000000..accc24061a9d96c8a60612a25a9a6582b7e98262
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00567-g.torture.execute-pr78586/pr78586.c
@@ -0,0 +1,17 @@
+/* PR tree-optimization/78586 */
+
+void
+foo (unsigned long x)
+{
+  char a[30];
+  unsigned long b = sprintf (a, "%lu", x);
+  if (b != 4)
+    __builtin_abort ();
+}
+
+int
+main ()
+{
+  foo (1000);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00567-g.torture.execute-pr78586/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00567-g.torture.execute-pr78586/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4684a5b3767ff70fbce21fa5ae9574a39c76b40f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00567-g.torture.execute-pr78586/test.cfg
@@ -0,0 +1,2 @@
+compile(pr78586)
+run(pr78586)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00568-g.torture.execute-pr78622/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00568-g.torture.execute-pr78622/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ae69da84b39e5a1a38ad8c17732c69c2611d580b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00568-g.torture.execute-pr78622/expected.txt
@@ -0,0 +1,8 @@
+"9" => 1
+"32" => 2
+"127" => 3
+"-128" => 4
+"-16" => 3
+"-8" => 2
+"-1" => 2
+"0" => 1
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00568-g.torture.execute-pr78622/pr78622.c b/testsuite/c_test/x64_be_enable_test/GCC00568-g.torture.execute-pr78622/pr78622.c
new file mode 100644
index 0000000000000000000000000000000000000000..c09bb433e2347a1f3b2c135fb12d776e4fd79495
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00568-g.torture.execute-pr78622/pr78622.c
@@ -0,0 +1,36 @@
+/* PR middle-end/78622 - [7 Regression] -Wformat-overflow/-fprintf-return-value
+   incorrect with overflow/wrapping
+   { dg-skip-if "Requires %hhd format" { hppa*-*-hpux* } }
+   { dg-require-effective-target c99_runtime }
+   { dg-additional-options "-Wformat-overflow=2" } */
+
+__attribute__((noinline, noclone)) int
+foo (int x)
+{
+  if (x < 4096 + 8 || x >= 4096 + 256 + 8)
+    return -1;
+
+  char buf[5];
+  int n = __builtin_snprintf (buf, sizeof buf, "%hhd", x + 1);
+  __builtin_printf ("\"%hhd\" => %i\n", x + 1, n);
+  return n;
+}
+
+int
+main (void)
+{
+  if (__SCHAR_MAX__ != 127 || __CHAR_BIT__ != 8 || __SIZEOF_INT__ != 4)
+    return 0;
+
+  if (foo (4095 + 9) != 1
+      || foo (4095 + 32) != 2
+      || foo (4095 + 127) != 3
+      || foo (4095 + 128) != 4
+      || foo (4095 + 240) != 3
+      || foo (4095 + 248) != 2
+      || foo (4095 + 255) != 2
+      || foo (4095 + 256) != 1)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00568-g.torture.execute-pr78622/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00568-g.torture.execute-pr78622/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d45c457064f13a5ac284722f935d73a98b14457
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00568-g.torture.execute-pr78622/test.cfg
@@ -0,0 +1,2 @@
+compile(pr78622)
+run(pr78622)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00569-g.torture.execute-pr78675/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00569-g.torture.execute-pr78675/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00569-g.torture.execute-pr78675/pr78675.c b/testsuite/c_test/x64_be_enable_test/GCC00569-g.torture.execute-pr78675/pr78675.c
new file mode 100644
index 0000000000000000000000000000000000000000..7cef3425f7644306ebe3929be8d4fdd15934d63e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00569-g.torture.execute-pr78675/pr78675.c
@@ -0,0 +1,38 @@
+/* PR tree-optimization/78675 */
+
+long int a;
+
+__attribute__((noinline, noclone)) long int
+foo (long int x)
+{
+  long int b;
+  while (a < 1)
+    {
+      b = a && x;
+      ++a;
+    }
+  return b;
+}
+
+int
+main ()
+{
+  if (foo (0) != 0)
+    __builtin_abort ();
+  a = 0;
+  if (foo (1) != 0)
+    __builtin_abort ();
+  a = 0;
+  if (foo (25) != 0)
+    __builtin_abort ();
+  a = -64;
+  if (foo (0) != 0)
+    __builtin_abort ();
+  a = -64;
+  if (foo (1) != 0)
+    __builtin_abort ();
+  a = -64;
+  if (foo (25) != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00569-g.torture.execute-pr78675/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00569-g.torture.execute-pr78675/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bddc8ef6213834a7c6c8cae6fbc1a8e450369b56
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00569-g.torture.execute-pr78675/test.cfg
@@ -0,0 +1,2 @@
+compile(pr78675)
+run(pr78675)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00570-g.torture.execute-pr78856/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00570-g.torture.execute-pr78856/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00570-g.torture.execute-pr78856/pr78856.c b/testsuite/c_test/x64_be_enable_test/GCC00570-g.torture.execute-pr78856/pr78856.c
new file mode 100644
index 0000000000000000000000000000000000000000..80f2317a15bccdd4806dbc22925e4e9c3731a323
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00570-g.torture.execute-pr78856/pr78856.c
@@ -0,0 +1,25 @@
+extern void exit (int);
+
+int a, b, c, d, e, f[3]; 
+
+int main() 
+{
+  while (d)
+    while (1)
+      ;
+  int g = 0, h, i = 0;
+  for (; g < 21; g += 9) 
+    {
+      int j = 1;
+      for (h = 0; h < 3; h++)
+	f[h] = 1;
+      for (; j < 10; j++) {
+	d = i && (b ? 0 : c); 
+	i = 1;
+	if (g)
+	  a = e;
+      }
+  }
+  exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00570-g.torture.execute-pr78856/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00570-g.torture.execute-pr78856/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8c6f2099ce7e77ac0642d95592490040594f4269
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00570-g.torture.execute-pr78856/test.cfg
@@ -0,0 +1,2 @@
+compile(pr78856)
+run(pr78856)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00571-g.torture.execute-pr79121/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00571-g.torture.execute-pr79121/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00571-g.torture.execute-pr79121/pr79121.c b/testsuite/c_test/x64_be_enable_test/GCC00571-g.torture.execute-pr79121/pr79121.c
new file mode 100644
index 0000000000000000000000000000000000000000..5593acc7d297d26ed0f6ccd047a22872e12b2070
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00571-g.torture.execute-pr79121/pr79121.c
@@ -0,0 +1,42 @@
+#if __SIZEOF_INT__ < 4
+  __extension__ typedef __UINT32_TYPE__ uint32_t;
+  __extension__ typedef __INT32_TYPE__ int32_t;
+#else
+  typedef unsigned uint32_t;
+  typedef int int32_t;
+#endif
+
+extern void abort (void);
+
+__attribute__ ((noinline, noclone)) unsigned long long f1 (int32_t x)
+{
+  return ((unsigned long long) x) << 4;
+}
+
+__attribute__ ((noinline, noclone)) long long f2 (uint32_t x)
+{
+  return ((long long) x) << 4;
+}
+
+__attribute__ ((noinline, noclone)) unsigned long long f3 (uint32_t x)
+{
+  return ((unsigned long long) x) << 4;
+}
+
+__attribute__ ((noinline, noclone)) long long f4 (int32_t x)
+{
+  return ((long long) x) << 4;
+}
+
+int main ()
+{
+  if (f1 (0xf0000000) != 0xffffffff00000000)
+    abort ();
+  if (f2 (0xf0000000) != 0xf00000000)
+    abort ();
+  if (f3 (0xf0000000) != 0xf00000000)
+    abort ();
+  if (f4 (0xf0000000) != 0xffffffff00000000)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00571-g.torture.execute-pr79121/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00571-g.torture.execute-pr79121/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..efde5a40e017ada63e7aac06d754df5122d53f5d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00571-g.torture.execute-pr79121/test.cfg
@@ -0,0 +1,2 @@
+compile(pr79121)
+run(pr79121)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00572-g.torture.execute-pr79286/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00572-g.torture.execute-pr79286/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bc856dafab0941942ccea4202bfa3a5b02bf4371
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00572-g.torture.execute-pr79286/expected.txt
@@ -0,0 +1,4 @@
+0
+1
+2
+3
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00572-g.torture.execute-pr79286/pr79286.c b/testsuite/c_test/x64_be_enable_test/GCC00572-g.torture.execute-pr79286/pr79286.c
new file mode 100644
index 0000000000000000000000000000000000000000..e6d0e935a87b9f7b35772eb081049682812d6643
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00572-g.torture.execute-pr79286/pr79286.c
@@ -0,0 +1,15 @@
+int a = 0, c = 0;
+static int d[][8] = {};
+
+int main ()
+{
+  int e;
+  for (int b = 0; b < 4; b++)
+    {
+      __builtin_printf ("%d\n", b, e);
+      while (a && c++)
+	e = d[300000000000000000][0];
+    }
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00572-g.torture.execute-pr79286/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00572-g.torture.execute-pr79286/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..69c71cb3949026ccdc048265322c3bfc6760dc04
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00572-g.torture.execute-pr79286/test.cfg
@@ -0,0 +1,2 @@
+compile(pr79286)
+run(pr79286)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00573-g.torture.execute-pr79327/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00573-g.torture.execute-pr79327/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00573-g.torture.execute-pr79327/pr79327.c b/testsuite/c_test/x64_be_enable_test/GCC00573-g.torture.execute-pr79327/pr79327.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb8b3804cc3345414d08de5a18c23f54adb4bdbd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00573-g.torture.execute-pr79327/pr79327.c
@@ -0,0 +1,26 @@
+/* PR tree-optimization/79327 */
+/* { dg-require-effective-target c99_runtime } */
+
+volatile int a;
+
+int
+main (void)
+{
+  int i;
+  char buf[64];
+  if (sprintf (buf, "%#hho", a) != 1)
+    __builtin_abort ();
+  if (sprintf (buf, "%#hhx", a) != 1)
+    __builtin_abort ();
+  a = 1;
+  if (sprintf (buf, "%#hho", a) != 2)
+    __builtin_abort ();
+  if (sprintf (buf, "%#hhx", a) != 3)
+    __builtin_abort ();
+  a = 127;
+  if (sprintf (buf, "%#hho", a) != 4)
+    __builtin_abort ();
+  if (sprintf (buf, "%#hhx", a) != 4)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00573-g.torture.execute-pr79327/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00573-g.torture.execute-pr79327/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c2e4bd98970d60d8126d34366840c073f3fa2b1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00573-g.torture.execute-pr79327/test.cfg
@@ -0,0 +1,2 @@
+compile(pr79327)
+run(pr79327)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00574-g.torture.execute-pr81555/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00574-g.torture.execute-pr81555/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00574-g.torture.execute-pr81555/pr81555.c b/testsuite/c_test/x64_be_enable_test/GCC00574-g.torture.execute-pr81555/pr81555.c
new file mode 100644
index 0000000000000000000000000000000000000000..d546368a39b53cf3a03c638bf8ff5f8a656335cd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00574-g.torture.execute-pr81555/pr81555.c
@@ -0,0 +1,24 @@
+/* PR tree-optimization/81555 */
+
+unsigned int a = 1, d = 0xfaeU, e = 0xe376U;
+_Bool b = 0, f = 1;
+unsigned char g = 1;
+
+void
+foo (void)
+{
+  _Bool c = a != b;
+  if (c)
+    f = 0;
+  if (e & c & (unsigned char)d & c)
+    g = 0;
+}
+
+int
+main ()
+{
+  foo ();
+  if (f || g != 1)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00574-g.torture.execute-pr81555/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00574-g.torture.execute-pr81555/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8e9790fb27a61e8c9d142c9ff76df3bd68c1281a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00574-g.torture.execute-pr81555/test.cfg
@@ -0,0 +1,2 @@
+compile(pr81555)
+run(pr81555)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00575-g.torture.execute-pr81588/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00575-g.torture.execute-pr81588/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00575-g.torture.execute-pr81588/pr81588.c b/testsuite/c_test/x64_be_enable_test/GCC00575-g.torture.execute-pr81588/pr81588.c
new file mode 100644
index 0000000000000000000000000000000000000000..b8f84b3e18c42075205fe8aaaaf9777b3662ff44
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00575-g.torture.execute-pr81588/pr81588.c
@@ -0,0 +1,45 @@
+/* PR tree-optimization/81588 */
+
+__attribute__((noinline, noclone)) int
+bar (int x)
+{
+  __asm volatile ("" : : "g" (x) : "memory");
+}
+
+__attribute__((noinline, noclone)) int
+foo (unsigned x, long long y)
+{
+  if (y < 0)
+    return 0;
+  if (y < (long long) (4 * x))
+    {
+      bar (y);
+      return 1;
+    }
+  return 0;
+}     
+
+int
+main ()
+{
+  volatile unsigned x = 10;
+  volatile long long y = -10000;
+  if (foo (x, y) != 0)
+    __builtin_abort ();
+  y = -1;
+  if (foo (x, y) != 0)
+    __builtin_abort ();
+  y = 0;
+  if (foo (x, y) != 1)
+    __builtin_abort ();
+  y = 39;
+  if (foo (x, y) != 1)
+    __builtin_abort ();
+  y = 40;
+  if (foo (x, y) != 0)
+    __builtin_abort ();
+  y = 10000;
+  if (foo (x, y) != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00575-g.torture.execute-pr81588/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00575-g.torture.execute-pr81588/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..63b2bfa04c5dc0211389105226610d7488bf0fb6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00575-g.torture.execute-pr81588/test.cfg
@@ -0,0 +1,2 @@
+compile(pr81588)
+run(pr81588)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00576-g.torture.execute-pr81913/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00576-g.torture.execute-pr81913/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00576-g.torture.execute-pr81913/pr81913.c b/testsuite/c_test/x64_be_enable_test/GCC00576-g.torture.execute-pr81913/pr81913.c
new file mode 100644
index 0000000000000000000000000000000000000000..c8338f404abe490a601e704b9a95952566c288cf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00576-g.torture.execute-pr81913/pr81913.c
@@ -0,0 +1,27 @@
+/* PR tree-optimization/81913 */
+
+typedef __UINT8_TYPE__ u8;
+typedef __UINT32_TYPE__ u32;
+
+static u32
+b (u8 d, u32 e, u32 g)
+{
+  do
+    {
+      e += g + 1;
+      d--;
+    }
+  while (d >= (u8) e);
+
+  return e;
+}
+
+int
+main (void)
+{
+  u32 x = b (1, -0x378704, ~0xba64fc);
+  if (x != 0xd93190d0)
+    __builtin_abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00576-g.torture.execute-pr81913/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00576-g.torture.execute-pr81913/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d228ad33f65a98ee49d07dd7cc6e4ef4ff6ad2ae
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00576-g.torture.execute-pr81913/test.cfg
@@ -0,0 +1,2 @@
+compile(pr81913)
+run(pr81913)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00577-g.torture.execute-pr82387/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00577-g.torture.execute-pr82387/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00577-g.torture.execute-pr82387/pr82387.c b/testsuite/c_test/x64_be_enable_test/GCC00577-g.torture.execute-pr82387/pr82387.c
new file mode 100644
index 0000000000000000000000000000000000000000..ead1a2a70daf071b6a6ba6e540f4d6eed437c259
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00577-g.torture.execute-pr82387/pr82387.c
@@ -0,0 +1,27 @@
+/* PR tree-optimization/82387 */
+
+struct A { int b; };
+int f = 1;
+
+struct A
+foo (void)
+{
+  struct A h[] = { 
+    {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, 
+    {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, 
+    {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, 
+    {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, 
+    {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, 
+    {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, 
+    {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, 
+  };
+  return h[24];
+}
+
+int
+main ()
+{
+  struct A i = foo (), j = i;
+  j.b && (f = 0);
+  return f; 
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00577-g.torture.execute-pr82387/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00577-g.torture.execute-pr82387/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..63d587542d099c7591465958be0c0773a2b2b66e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00577-g.torture.execute-pr82387/test.cfg
@@ -0,0 +1,2 @@
+compile(pr82387)
+run(pr82387)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00578-g.torture.execute-pr82388/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00578-g.torture.execute-pr82388/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00578-g.torture.execute-pr82388/pr82388.c b/testsuite/c_test/x64_be_enable_test/GCC00578-g.torture.execute-pr82388/pr82388.c
new file mode 100644
index 0000000000000000000000000000000000000000..51e30f88269c7d373d24c027914f92d918fdf05a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00578-g.torture.execute-pr82388/pr82388.c
@@ -0,0 +1,17 @@
+/* PR tree-optimization/82388 */
+
+struct A { int b; int c; int d; } e;
+
+struct A
+foo (void)
+{
+  struct A h[30] = {{0,0,0}};
+  return h[29]; 
+}
+
+int
+main ()
+{
+  e = foo ();
+  return e.b; 
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00578-g.torture.execute-pr82388/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00578-g.torture.execute-pr82388/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65d005e5bce71d82a847568d9e7236f276bd842d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00578-g.torture.execute-pr82388/test.cfg
@@ -0,0 +1,2 @@
+compile(pr82388)
+run(pr82388)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00579-g.torture.execute-pr82954/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00579-g.torture.execute-pr82954/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00579-g.torture.execute-pr82954/pr82954.c b/testsuite/c_test/x64_be_enable_test/GCC00579-g.torture.execute-pr82954/pr82954.c
new file mode 100644
index 0000000000000000000000000000000000000000..5ced28544e5a234cec5ef60c02ebb5a0f263084f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00579-g.torture.execute-pr82954/pr82954.c
@@ -0,0 +1,22 @@
+/* PR tree-optimization/82954 */
+
+__attribute__((noipa)) void
+foo (int *__restrict p, int *__restrict q)
+{
+  p[0] = p[0] ^ 1;
+  p[1] = p[1] ^ 2;
+  p[2] = p[2] ^ q[2];
+  p[3] = p[3] ^ q[3];
+}
+
+int
+main ()
+{
+  int p[4] = { 16, 32, 64, 128 };
+  int q[4] = { 8, 4, 2, 1 };
+  asm volatile ("" : : "g" (p), "g" (q) : "memory");
+  foo (p, q);
+  if (p[0] != 17 || p[1] != 34 || p[2] != 66 || p[3] != 129)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00579-g.torture.execute-pr82954/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00579-g.torture.execute-pr82954/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc2452b7c6c7eef78bdcaa6e3b2a7de87dddc054
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00579-g.torture.execute-pr82954/test.cfg
@@ -0,0 +1,2 @@
+compile(pr82954)
+run(pr82954)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00580-g.torture.execute-pr83269/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00580-g.torture.execute-pr83269/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00580-g.torture.execute-pr83269/pr83269.c b/testsuite/c_test/x64_be_enable_test/GCC00580-g.torture.execute-pr83269/pr83269.c
new file mode 100644
index 0000000000000000000000000000000000000000..37fc5d14db7ab93d16c73c4b701043d6b2f4cea2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00580-g.torture.execute-pr83269/pr83269.c
@@ -0,0 +1,14 @@
+/* PR tree-optimization/83269 */
+
+int
+main ()
+{
+#if __SIZEOF_INT__ == 4 && __SIZEOF_LONG_LONG__ > 4 && __CHAR_BIT__ == 8
+  volatile unsigned char a = 1;
+  long long b = 0x80000000L;
+  int c = -((int)(-b) - (-0x7fffffff * a));
+  if (c != 1)
+    __builtin_abort ();
+#endif
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00580-g.torture.execute-pr83269/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00580-g.torture.execute-pr83269/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4a2cef0327fe4e3f35dea71134143b0201478d6c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00580-g.torture.execute-pr83269/test.cfg
@@ -0,0 +1,2 @@
+compile(pr83269)
+run(pr83269)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00581-g.torture.execute-pr84339/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00581-g.torture.execute-pr84339/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00581-g.torture.execute-pr84339/pr84339.c b/testsuite/c_test/x64_be_enable_test/GCC00581-g.torture.execute-pr84339/pr84339.c
new file mode 100644
index 0000000000000000000000000000000000000000..160da664d1277fe222a7de68709cbcfd17252aab
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00581-g.torture.execute-pr84339/pr84339.c
@@ -0,0 +1,30 @@
+/* PR tree-optimization/84339 */
+
+struct S { int a; char b[1]; };
+
+__attribute__((noipa)) int
+foo (struct S *p)
+{
+  return __builtin_strlen (&p->b[0]);
+}
+
+__attribute__((noipa)) int
+bar (struct S *p)
+{
+  return __builtin_strlen (p->b);
+}
+
+int
+main ()
+{
+  struct S *p = malloc (sizeof (struct S) + 16);
+  if (p)
+    {
+      p->a = 1;
+      __builtin_strcpy (p->b, "abcdefg");
+      if (foo (p) != 7 || bar (p) != 7)
+	__builtin_abort ();
+      free (p);
+    }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00581-g.torture.execute-pr84339/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00581-g.torture.execute-pr84339/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..069c71f4e2dbee189178b062d75bc9d8f5078bb9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00581-g.torture.execute-pr84339/test.cfg
@@ -0,0 +1,2 @@
+compile(pr84339)
+run(pr84339)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00582-g.torture.execute-pr84478/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00582-g.torture.execute-pr84478/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00582-g.torture.execute-pr84478/pr84478.c b/testsuite/c_test/x64_be_enable_test/GCC00582-g.torture.execute-pr84478/pr84478.c
new file mode 100644
index 0000000000000000000000000000000000000000..03df99a794cd798fa9385d138b5fd32b5cbd74ca
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00582-g.torture.execute-pr84478/pr84478.c
@@ -0,0 +1,49 @@
+/* PR tree-optimization/84478 */
+
+long poolptr;
+unsigned char *strpool;
+static const char *poolfilearr[] = {
+  "mu",
+  "",
+#define A "x",
+#define B A "xx", A A "xxx", A A A A A
+#define C B B B B B B B B B B
+#define D C C C C C C C C C C
+  D C C C C C C C B B B
+ ((void *)0) 
+};
+
+__attribute__((noipa)) long
+makestring (void)
+{
+  return 1;
+}
+
+__attribute__((noipa)) long
+loadpoolstrings (long spare_size)
+{
+  const char *s;
+  long g = 0;
+  int i = 0, j = 0;
+  while ((s = poolfilearr[j++]))
+    {
+      int l = strlen (s);
+      i += l;
+      if (i >= spare_size) return 0;
+      while (l-- > 0) strpool[poolptr++] = *s++;
+      g = makestring ();
+    }
+  return g;
+}
+
+int
+main ()
+{
+  strpool = malloc (4000);
+  if (!strpool)
+    return 0;
+  asm volatile ("" : : : "memory");
+  volatile int r = loadpoolstrings (4000);
+  free (strpool);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00582-g.torture.execute-pr84478/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00582-g.torture.execute-pr84478/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d49cc179bcb31c19c7e2b19c1af850a9d6b22a4b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00582-g.torture.execute-pr84478/test.cfg
@@ -0,0 +1,2 @@
+compile(pr84478)
+run(pr84478)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00583-g.torture.execute-pr84521/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00583-g.torture.execute-pr84521/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00583-g.torture.execute-pr84521/pr84521.c b/testsuite/c_test/x64_be_enable_test/GCC00583-g.torture.execute-pr84521/pr84521.c
new file mode 100644
index 0000000000000000000000000000000000000000..51715162c9296685a9247551bccbccf5ba870a5f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00583-g.torture.execute-pr84521/pr84521.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target indirect_jumps } */
+/* { dg-additional-options "-fomit-frame-pointer -fno-inline" }  */
+
+#include <setjmp.h>
+
+extern void abort (void);
+
+void
+broken_longjmp (void *p)
+{
+  longjmp (p, 1);
+}
+
+volatile int x = 256;
+void *volatile p = (void*)&x;
+void *volatile p1;
+
+void
+test (void)
+{
+  jmp_buf buf;
+  void *volatile q = p;
+
+  if (!setjmp (buf))
+    broken_longjmp (buf);
+
+  /* Fails if stack pointer corrupted.  */
+  if (p != q)
+    abort ();
+}
+
+void
+test2 (void)
+{
+  void *volatile q = p;
+  p1 = alloca (x);
+  test ();
+
+  /* Fails if frame pointer corrupted.  */
+  if (p != q)
+    abort ();
+}
+
+int
+main (void)
+{
+  void *volatile q = p;
+  test ();
+  test2 ();
+  /* Fails if stack pointer corrupted.  */
+  if (p != q)
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00583-g.torture.execute-pr84521/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00583-g.torture.execute-pr84521/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..77ef788b435cf4339878553ca332413712430b7c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00583-g.torture.execute-pr84521/test.cfg
@@ -0,0 +1,2 @@
+compile(pr84521)
+run(pr84521)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00584-g.torture.execute-pr85156/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00584-g.torture.execute-pr85156/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00584-g.torture.execute-pr85156/pr85156.c b/testsuite/c_test/x64_be_enable_test/GCC00584-g.torture.execute-pr85156/pr85156.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2968370283080d91a06ab3692410b8104d9a666
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00584-g.torture.execute-pr85156/pr85156.c
@@ -0,0 +1,21 @@
+/* PR tree-optimization/85156 */
+
+int x, y;
+
+__attribute__((noipa)) int
+foo (int z)
+{
+  if (__builtin_expect (x ? y != 0 : 0, z++))
+    return 7;
+  return z;
+}
+
+int
+main ()
+{
+  x = 1;
+  asm volatile ("" : "+m" (x), "+m" (y));
+  if (foo (10) != 11)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00584-g.torture.execute-pr85156/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00584-g.torture.execute-pr85156/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..774ad4c6817d992bc08c53969f8ce27eb32f8519
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00584-g.torture.execute-pr85156/test.cfg
@@ -0,0 +1,2 @@
+compile(pr85156)
+run(pr85156)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00585-g.torture.execute-pr86492/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00585-g.torture.execute-pr86492/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00585-g.torture.execute-pr86492/pr86492.c b/testsuite/c_test/x64_be_enable_test/GCC00585-g.torture.execute-pr86492/pr86492.c
new file mode 100644
index 0000000000000000000000000000000000000000..049563d92091dae226546bc830556dd0f9a71d44
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00585-g.torture.execute-pr86492/pr86492.c
@@ -0,0 +1,34 @@
+/* PR tree-optimization/86492 */
+
+union U
+{
+  unsigned int r;
+  struct S
+  {
+    unsigned int a:12;
+    unsigned int b:4;
+    unsigned int c:16;
+  } f;
+};
+
+__attribute__((noipa)) unsigned int
+foo (unsigned int x)
+{
+  union U u;
+  u.r = 0;
+  u.f.c = x;
+  u.f.b = 0xe;
+  return u.r;
+}
+
+int
+main ()
+{
+  union U u;
+  if (__CHAR_BIT__ * __SIZEOF_INT__ != 32 || sizeof (u.r) != sizeof (u.f))
+    return 0;
+  u.r = foo (0x72);
+  if (u.f.a != 0 || u.f.b != 0xe || u.f.c != 0x72)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00585-g.torture.execute-pr86492/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00585-g.torture.execute-pr86492/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..134555646005f4a789a1966df8b00330f1374168
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00585-g.torture.execute-pr86492/test.cfg
@@ -0,0 +1,2 @@
+compile(pr86492)
+run(pr86492)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00586-g.torture.execute-pr86659-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00586-g.torture.execute-pr86659-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00586-g.torture.execute-pr86659-1/pr86659-1.c b/testsuite/c_test/x64_be_enable_test/GCC00586-g.torture.execute-pr86659-1/pr86659-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..693b9aa8438eb215e676bff850b244bc002a9440
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00586-g.torture.execute-pr86659-1/pr86659-1.c
@@ -0,0 +1,42 @@
+#define ENDIANBIG __attribute((scalar_storage_order ("big-endian")))
+
+typedef struct ENDIANBIG 
+{
+  unsigned long long  field0:29;
+  unsigned long long  field1:4; 
+  unsigned long long  field2:31;
+}struct1;  
+
+int
+main(void)
+{
+  int value1 = 0;
+  int value2 = 0;
+  int value3 = 0;
+  unsigned int flag;
+  struct1 var1;
+  var1.field0 = 23;
+  
+  flag = var1.field0;
+  value1 = ((var1.field0)?10:20);
+  if(var1.field0)
+    {
+      value2 =  10;
+    } else
+    {
+      value2 = 20;
+    }
+
+  value3 = ((flag)?10:20);
+
+  if (value1 != 10)
+    __builtin_abort ();
+
+  if (value2 != 10)
+    __builtin_abort ();
+
+  if (value3 != 10)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00586-g.torture.execute-pr86659-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00586-g.torture.execute-pr86659-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..de66b89a11762b982f3c49798da0c94315630bed
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00586-g.torture.execute-pr86659-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr86659-1)
+run(pr86659-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00587-g.torture.execute-pr86659-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00587-g.torture.execute-pr86659-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00587-g.torture.execute-pr86659-2/pr86659-2.c b/testsuite/c_test/x64_be_enable_test/GCC00587-g.torture.execute-pr86659-2/pr86659-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..71b98d7fb46836df7d3f0092d5333e34ba442b40
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00587-g.torture.execute-pr86659-2/pr86659-2.c
@@ -0,0 +1,42 @@
+#define ENDIANBIG __attribute((scalar_storage_order ("little-endian")))
+
+typedef struct ENDIANBIG 
+{
+  unsigned long long  field0:29;
+  unsigned long long  field1:4; 
+  unsigned long long  field2:31;
+}struct1;  
+
+int
+main(void)
+{
+  int value1 = 0;
+  int value2 = 0;
+  int value3 = 0;
+  unsigned int flag;
+  struct1 var1;
+  var1.field0 = 23;
+  
+  flag = var1.field0;
+  value1 = ((var1.field0)?10:20);
+  if(var1.field0)
+    {
+      value2 =  10;
+    } else
+    {
+      value2 = 20;
+    }
+
+  value3 = ((flag)?10:20);
+
+  if (value1 != 10)
+    __builtin_abort ();
+
+  if (value2 != 10)
+    __builtin_abort ();
+
+  if (value3 != 10)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00587-g.torture.execute-pr86659-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00587-g.torture.execute-pr86659-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b380eb199d36e9e6dbd76e8e01a0438c1a2e0ac4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00587-g.torture.execute-pr86659-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr86659-2)
+run(pr86659-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00588-g.torture.execute-pr87053/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00588-g.torture.execute-pr87053/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00588-g.torture.execute-pr87053/pr87053.c b/testsuite/c_test/x64_be_enable_test/GCC00588-g.torture.execute-pr87053/pr87053.c
new file mode 100644
index 0000000000000000000000000000000000000000..0170731860b132074b7ce5b96758135cf3465c1a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00588-g.torture.execute-pr87053/pr87053.c
@@ -0,0 +1,17 @@
+/* PR middle-end/87053 */
+
+const union
+{ struct {
+    char x[4];
+    char y[4];
+  };
+  struct {
+    char z[8];
+  };
+} u = {{"1234", "567"}};
+
+int main ()
+{
+  if (__builtin_strlen (u.z) != 7)
+    __builtin_abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00588-g.torture.execute-pr87053/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00588-g.torture.execute-pr87053/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..18d0fde065488110d5ad769003fa27261f4608f4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00588-g.torture.execute-pr87053/test.cfg
@@ -0,0 +1,2 @@
+compile(pr87053)
+run(pr87053)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00589-g.torture.execute-pr87623/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00589-g.torture.execute-pr87623/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00589-g.torture.execute-pr87623/pr87623.c b/testsuite/c_test/x64_be_enable_test/GCC00589-g.torture.execute-pr87623/pr87623.c
new file mode 100644
index 0000000000000000000000000000000000000000..54d8b5e45711d42662b630ecf7d1019d8d329336
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00589-g.torture.execute-pr87623/pr87623.c
@@ -0,0 +1,34 @@
+/* PR middle-end/87623 */
+/* Testcase by George Thopas <george.thopas@gmail.com> */
+
+struct be {
+    unsigned short pad[1];
+    unsigned char  a;
+    unsigned char  b;
+} __attribute__((scalar_storage_order("big-endian")));
+
+typedef struct be t_be;
+
+struct le {
+    unsigned short pad[3];
+    unsigned char  a;
+    unsigned char  b;
+};
+
+typedef struct le t_le;
+
+int a_or_b_different(t_be *x,t_le *y)
+{
+   return (x->a != y->a) || (x->b != y->b);
+}
+
+int main (void)
+{
+   t_be x = { .a=1, .b=2  };
+   t_le y = { .a=1, .b=2  };
+  
+   if (a_or_b_different(&x,&y))
+       __builtin_abort ();
+
+   return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00589-g.torture.execute-pr87623/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00589-g.torture.execute-pr87623/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3bc0c7998bdf852b9cd8ce6ca9da7b3a3b94d866
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00589-g.torture.execute-pr87623/test.cfg
@@ -0,0 +1,2 @@
+compile(pr87623)
+run(pr87623)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00590-g.torture.execute-pr88714/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00590-g.torture.execute-pr88714/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00590-g.torture.execute-pr88714/pr88714.c b/testsuite/c_test/x64_be_enable_test/GCC00590-g.torture.execute-pr88714/pr88714.c
new file mode 100644
index 0000000000000000000000000000000000000000..614ad9ac4a0662ba752532270e2d687505504d48
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00590-g.torture.execute-pr88714/pr88714.c
@@ -0,0 +1,43 @@
+/* PR bootstrap/88714 */
+
+struct S { int a, b, c; int *d; };
+struct T { int *e, *f, *g; } *t = 0;
+int *o = 0;
+
+__attribute__((noipa))
+void bar (int *x, int y, int z, int w)
+{
+  if (w == -1)
+    {
+      if (x != 0 || y != 0 || z != 0)
+	__builtin_abort ();
+    }
+  else if (w != 0 || x != t->g || y != 0 || z != 12)
+    __builtin_abort ();
+}
+
+__attribute__((noipa)) void
+foo (struct S *x, struct S *y, int *z, int w)
+{
+  *o = w;
+  if (w)
+    bar (0, 0, 0, -1);
+  x->d = z;
+  if (y->d)
+    y->c = y->c + y->d[0];
+  bar (t->g, 0, y->c, 0);
+}
+
+int
+main ()
+{
+  int a[4] = { 8, 9, 10, 11 };
+  struct S s = { 1, 2, 3, &a[0] };
+  struct T u = { 0, 0, &a[3] };
+  o = &a[2];
+  t = &u;
+  foo (&s, &s, &a[1], 5);
+  if (s.c != 12 || s.d != &a[1])
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00590-g.torture.execute-pr88714/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00590-g.torture.execute-pr88714/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fed04db24ca9c2ba310466e5da713e36e47e7130
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00590-g.torture.execute-pr88714/test.cfg
@@ -0,0 +1,2 @@
+compile(pr88714)
+run(pr88714)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00591-g.torture.execute-pr88904/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00591-g.torture.execute-pr88904/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00591-g.torture.execute-pr88904/pr88904.c b/testsuite/c_test/x64_be_enable_test/GCC00591-g.torture.execute-pr88904/pr88904.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c285671321cc3ce39c5bd4ea512e6454e045084
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00591-g.torture.execute-pr88904/pr88904.c
@@ -0,0 +1,38 @@
+/* PR rtl-optimization/88904 */
+
+volatile int v;
+
+__attribute__((noipa)) void
+bar (const char *x, const char *y, int z)
+{
+  if (!v)
+    __builtin_abort ();
+  asm volatile ("" : "+g" (x));
+  asm volatile ("" : "+g" (y));
+  asm volatile ("" : "+g" (z));
+}
+
+#define my_assert(e) ((e) ? (void) 0 : bar (#e, __FILE__, __LINE__))
+
+typedef struct {
+  unsigned M1;
+  unsigned M2 : 1;
+  int : 0;
+  unsigned M3 : 1;
+} S;
+
+S
+foo ()
+{
+  S result = {0, 0, 1};
+  return result;
+}
+
+int
+main ()
+{
+  S ret = foo ();
+  my_assert (ret.M2 == 0);
+  my_assert (ret.M3 == 1);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00591-g.torture.execute-pr88904/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00591-g.torture.execute-pr88904/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ea80a7871fb37ce815608a941b63a7adc028b277
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00591-g.torture.execute-pr88904/test.cfg
@@ -0,0 +1,2 @@
+compile(pr88904)
+run(pr88904)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00592-g.torture.execute-pr89195/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00592-g.torture.execute-pr89195/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00592-g.torture.execute-pr89195/pr89195.c b/testsuite/c_test/x64_be_enable_test/GCC00592-g.torture.execute-pr89195/pr89195.c
new file mode 100644
index 0000000000000000000000000000000000000000..017f5b4309aa5a670ce1261c73cabfed967237a6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00592-g.torture.execute-pr89195/pr89195.c
@@ -0,0 +1,22 @@
+/* PR rtl-optimization/89195 */
+/* { dg-require-effective-target int32plus } */
+
+struct S { unsigned i : 24; };
+
+volatile unsigned char x;
+
+__attribute__((noipa)) int
+foo (struct S d) 
+{
+  return d.i & x;
+}
+
+int
+main ()
+{
+  struct S d = { 0x123456 };
+  x = 0x75;
+  if (foo (d) != (0x56 & 0x75))
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00592-g.torture.execute-pr89195/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00592-g.torture.execute-pr89195/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f210cee461561c56a2c54a7413b27ea49ff046b5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00592-g.torture.execute-pr89195/test.cfg
@@ -0,0 +1,2 @@
+compile(pr89195)
+run(pr89195)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00593-g.torture.execute-pr89369/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00593-g.torture.execute-pr89369/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00593-g.torture.execute-pr89369/pr89369.c b/testsuite/c_test/x64_be_enable_test/GCC00593-g.torture.execute-pr89369/pr89369.c
new file mode 100644
index 0000000000000000000000000000000000000000..a8f095e0b578ecc1e828566bd3d2b3704d33b74f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00593-g.torture.execute-pr89369/pr89369.c
@@ -0,0 +1,69 @@
+/* PR target/89369 */
+
+#if __SIZEOF_INT__ == 4 && __SIZEOF_LONG_LONG__ == 8 && __CHAR_BIT__ == 8
+struct S { unsigned int u[4]; };
+
+static void
+foo (struct S *out, struct S const *in, int shift)
+{
+  unsigned long long th, tl, oh, ol;
+  th = ((unsigned long long) in->u[3] << 32) | in->u[2];
+  tl = ((unsigned long long) in->u[1] << 32) | in->u[0];
+  oh = th >> (shift * 8);
+  ol = tl >> (shift * 8);
+  ol |= th << (64 - shift * 8);
+  out->u[1] = ol >> 32;
+  out->u[0] = ol;
+  out->u[3] = oh >> 32;
+  out->u[2] = oh;
+}
+
+static void
+bar (struct S *out, struct S const *in, int shift)
+{
+  unsigned long long th, tl, oh, ol;
+  th = ((unsigned long long) in->u[3] << 32) | in->u[2];
+  tl = ((unsigned long long) in->u[1] << 32) | in->u[0];
+  oh = th << (shift * 8);
+  ol = tl << (shift * 8);
+  oh |= tl >> (64 - shift * 8);
+  out->u[1] = ol >> 32;
+  out->u[0] = ol;
+  out->u[3] = oh >> 32;
+  out->u[2] = oh;
+}
+
+__attribute__((noipa)) static void
+baz (struct S *r, struct S *a, struct S *b, struct S *c, struct S *d)
+{
+  struct S x, y;
+  bar (&x, a, 1);
+  foo (&y, c, 1);
+  r->u[0] = a->u[0] ^ x.u[0] ^ ((b->u[0] >> 11) & 0xdfffffefU) ^ y.u[0] ^ (d->u[0] << 18);
+  r->u[1] = a->u[1] ^ x.u[1] ^ ((b->u[1] >> 11) & 0xddfecb7fU) ^ y.u[1] ^ (d->u[1] << 18);
+  r->u[2] = a->u[2] ^ x.u[2] ^ ((b->u[2] >> 11) & 0xbffaffffU) ^ y.u[2] ^ (d->u[2] << 18);
+  r->u[3] = a->u[3] ^ x.u[3] ^ ((b->u[3] >> 11) & 0xbffffff6U) ^ y.u[3] ^ (d->u[3] << 18);
+}
+
+int
+main ()
+{
+  struct S a[] = { { 0x000004d3, 0xbc5448db, 0xf22bde9f, 0xebb44f8f },
+		   { 0x03a32799, 0x60be8246, 0xa2d266ed, 0x7aa18536 },
+		   { 0x15a38518, 0xcf655ce1, 0xf3e09994, 0x50ef69fe },
+		   { 0x88274b07, 0xe7c94866, 0xc0ea9f47, 0xb6a83c43 },
+		   { 0xcd0d0032, 0x5d47f5d7, 0x5a0afbf6, 0xaea87b24 },
+		   { 0, 0, 0, 0 } };
+  baz (&a[5], &a[0], &a[1], &a[2], &a[3]);
+  if (a[4].u[0] != a[5].u[0] || a[4].u[1] != a[5].u[1]
+      || a[4].u[2] != a[5].u[2] || a[4].u[3] != a[5].u[3])
+    __builtin_abort ();
+  return 0;
+}
+#else
+int
+main ()
+{
+  return 0;
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00593-g.torture.execute-pr89369/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00593-g.torture.execute-pr89369/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8cc0f16c90982345ba44542a2c37ab2d2018c78d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00593-g.torture.execute-pr89369/test.cfg
@@ -0,0 +1,2 @@
+compile(pr89369)
+run(pr89369)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00594-g.torture.execute-pr89826/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00594-g.torture.execute-pr89826/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00594-g.torture.execute-pr89826/pr89826.c b/testsuite/c_test/x64_be_enable_test/GCC00594-g.torture.execute-pr89826/pr89826.c
new file mode 100644
index 0000000000000000000000000000000000000000..091644849d321afb5db16bb1c052591fef7dc8b7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00594-g.torture.execute-pr89826/pr89826.c
@@ -0,0 +1,21 @@
+typedef unsigned int u32;
+typedef unsigned long long u64;
+u64 a;
+u32 b;
+
+u64
+foo (u32 d)
+{
+  a -= d ? 0 : ~a;
+  return a + b;
+}
+
+int
+main (void)
+{
+  u64 x = foo (2);
+  if (x != 0)
+    __builtin_abort();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00594-g.torture.execute-pr89826/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00594-g.torture.execute-pr89826/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0cf42ce875cffe5131ae84f1be6bfc93c337e280
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00594-g.torture.execute-pr89826/test.cfg
@@ -0,0 +1,2 @@
+compile(pr89826)
+run(pr89826)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00595-g.torture.execute-pr90949/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00595-g.torture.execute-pr90949/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00595-g.torture.execute-pr90949/pr90949.c b/testsuite/c_test/x64_be_enable_test/GCC00595-g.torture.execute-pr90949/pr90949.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c2ae3972d4fe00ea32b029accff1a26dcc09649
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00595-g.torture.execute-pr90949/pr90949.c
@@ -0,0 +1,42 @@
+void __attribute__ ((noipa, noinline)) my_puts (const char *str) { }
+
+void __attribute__ ((noipa, noinline)) my_free (void *p) { }
+
+
+struct Node
+{
+  struct Node *child;
+};
+
+struct Node space[2] = { };
+
+struct Node * __attribute__ ((noipa, noinline)) my_malloc (int bytes)
+{
+  return &space[0];
+}
+
+void
+walk (struct Node *module, int cleanup)
+{
+  if (module == 0)
+    {
+      return;
+    }
+  if (!cleanup)
+    {
+      my_puts ("No cleanup");
+    }
+  walk (module->child, cleanup);
+  if (cleanup)
+    {
+      my_free (module);
+    }
+}
+
+int
+main ()
+{
+  struct Node *node = my_malloc (sizeof (struct Node));
+  node->child = 0;
+  walk (node, 1);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00595-g.torture.execute-pr90949/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00595-g.torture.execute-pr90949/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..22bbbb373259e304bfb49f1d2f89701f64b42424
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00595-g.torture.execute-pr90949/test.cfg
@@ -0,0 +1,2 @@
+compile(pr90949)
+run(pr90949)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00596-g.torture.execute-pr91137/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00596-g.torture.execute-pr91137/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00596-g.torture.execute-pr91137/pr91137.c b/testsuite/c_test/x64_be_enable_test/GCC00596-g.torture.execute-pr91137/pr91137.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa6bb6ca02165c39e6b820ebe505a36049bdc433
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00596-g.torture.execute-pr91137/pr91137.c
@@ -0,0 +1,34 @@
+long long a;
+unsigned b;
+int c[70];
+int d[70][70];
+int e;
+
+__attribute__ ((noinline)) void f(long long *g, int p2) {
+  *g = p2;
+}
+
+__attribute__ ((noinline)) void fn2() {
+  for (int j = 0; j < 70; j++) {
+    for (int i = 0; i < 70; i++) {
+      if (b)
+        c[i] = 0;
+      for (int l = 0; l < 70; l++)
+        d[i][1] = d[l][i];
+    }
+    for (int k = 0; k < 70; k++)
+      e = c[0];
+  }
+}
+
+int main() {
+  b = 5;
+  for (int j = 0; j < 70; ++j)
+    c[j] = 2075593088;
+  fn2();
+  f(&a, e);
+  if (a)
+    __builtin_abort();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00596-g.torture.execute-pr91137/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00596-g.torture.execute-pr91137/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..727412eca4b741ba777de016a69d4ab5e7bab9af
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00596-g.torture.execute-pr91137/test.cfg
@@ -0,0 +1,2 @@
+compile(pr91137)
+run(pr91137)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00597-g.torture.execute-pr91597/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00597-g.torture.execute-pr91597/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00597-g.torture.execute-pr91597/pr91597.c b/testsuite/c_test/x64_be_enable_test/GCC00597-g.torture.execute-pr91597/pr91597.c
new file mode 100644
index 0000000000000000000000000000000000000000..6a917cb58af4e2f96a985cf19dacc1df9faf0910
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00597-g.torture.execute-pr91597/pr91597.c
@@ -0,0 +1,48 @@
+/* PR tree-optimization/91597 */
+
+enum E { A, B, C };
+struct __attribute__((aligned (4))) S { enum E e; };
+
+enum E
+foo (struct S *o)
+{
+  if (((__UINTPTR_TYPE__) (o) & 1) == 0)
+    return o->e;
+  else
+    return A;
+}
+
+int
+bar (struct S *o)
+{
+  return foo (o) == B || foo (o) == C;
+}
+
+static inline void
+baz (struct S *o, int d)
+{
+  if (__builtin_expect (!bar (o), 0))
+    __builtin_abort ();
+  if (d > 2) return;
+  baz (o, d + 1);
+}
+
+void
+qux (struct S *o)
+{
+  switch (o->e)
+    {
+    case A: return;
+    case B: baz (o, 0); break;
+    case C: baz (o, 0); break;
+    }
+}
+
+struct S s = { C };
+
+int
+main ()
+{
+  qux (&s);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00597-g.torture.execute-pr91597/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00597-g.torture.execute-pr91597/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..88c108ef0c68885d7473eb497cb33588891ce4fa
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00597-g.torture.execute-pr91597/test.cfg
@@ -0,0 +1,2 @@
+compile(pr91597)
+run(pr91597)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00598-g.torture.execute-pr93744-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00598-g.torture.execute-pr93744-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00598-g.torture.execute-pr93744-1/pr93744-1.c b/testsuite/c_test/x64_be_enable_test/GCC00598-g.torture.execute-pr93744-1/pr93744-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3229c9b2bd6752eb4ad6bcccc482455daf366dce
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00598-g.torture.execute-pr93744-1/pr93744-1.c
@@ -0,0 +1,14 @@
+/* PR tree-optimization/93744 */
+
+typedef int I;
+
+int
+main ()
+{
+  int a = 0;
+  I b = 0;
+  (a > 0) * (b |= 2);
+  if (b != 2)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00598-g.torture.execute-pr93744-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00598-g.torture.execute-pr93744-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..07577e02a0983f4f3fd9465a3ff53046130512f9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00598-g.torture.execute-pr93744-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr93744-1)
+run(pr93744-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00599-g.torture.execute-pr93744-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00599-g.torture.execute-pr93744-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00599-g.torture.execute-pr93744-2/pr93744-2.c b/testsuite/c_test/x64_be_enable_test/GCC00599-g.torture.execute-pr93744-2/pr93744-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c1baaac77b3e10af52fdc4165d89a14c7f8900d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00599-g.torture.execute-pr93744-2/pr93744-2.c
@@ -0,0 +1,21 @@
+/* PR tree-optimization/93744 */
+
+int w;
+
+int
+foo (int x, int y, int z)
+{
+  int r = z - ((z - w++) & -(x < y));
+  return r;
+}
+
+int
+main ()
+{
+  w = 4;
+  if (foo (5, 7, 12) != 4 || w != 5)
+    __builtin_abort ();
+  if (foo (7, 5, 12) != 12 || w != 6)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00599-g.torture.execute-pr93744-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00599-g.torture.execute-pr93744-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..554810e7294008af2dddb9173802cce7c769c7ee
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00599-g.torture.execute-pr93744-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr93744-2)
+run(pr93744-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00600-g.torture.execute-pr93744-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00600-g.torture.execute-pr93744-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00600-g.torture.execute-pr93744-3/pr93744-3.c b/testsuite/c_test/x64_be_enable_test/GCC00600-g.torture.execute-pr93744-3/pr93744-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..8542c7c53ba08d6b0150a3fea0072ca5ac22caba
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00600-g.torture.execute-pr93744-3/pr93744-3.c
@@ -0,0 +1,21 @@
+/* PR tree-optimization/93744 */
+
+int w;
+
+int
+foo (int x, int y, int z)
+{
+  int r = z + ((w++ - z) & -(x < y));
+  return r;
+}
+
+int
+main ()
+{
+  w = 4;
+  if (foo (5, 7, 12) != 4 || w != 5)
+    __builtin_abort ();
+  if (foo (7, 5, 12) != 12 || w != 6)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00600-g.torture.execute-pr93744-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00600-g.torture.execute-pr93744-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..95b2a23de287dd2f5c9cfe8db0731630f3c9efbe
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00600-g.torture.execute-pr93744-3/test.cfg
@@ -0,0 +1,2 @@
+compile(pr93744-3)
+run(pr93744-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00601-g.torture.execute-pr93945/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00601-g.torture.execute-pr93945/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00601-g.torture.execute-pr93945/pr93945.c b/testsuite/c_test/x64_be_enable_test/GCC00601-g.torture.execute-pr93945/pr93945.c
new file mode 100644
index 0000000000000000000000000000000000000000..99e455cce52105f9595f6eb8ca87e34ec2a5c6ab
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00601-g.torture.execute-pr93945/pr93945.c
@@ -0,0 +1,45 @@
+/* PR tree-optimization/93945 */
+
+union U { char a[8]; struct S { unsigned int b : 8, c : 13, d : 11; } e; } u;
+
+__attribute__((noipa)) int
+foo (void)
+{
+  __builtin_memset (&u.a, 0xf4, sizeof (u.a));
+  return u.e.c;
+}
+
+__attribute__((noipa)) int
+bar (void)
+{
+  asm volatile ("" : : "g" (&u) : "memory");
+  return u.e.c;
+}
+
+__attribute__((noipa)) int
+baz (void)
+{
+  __builtin_memset (&u.a, 0xf4, sizeof (u.a));
+  return u.e.d;
+}
+
+__attribute__((noipa)) int
+qux (void)
+{
+  asm volatile ("" : : "g" (&u) : "memory");
+  return u.e.d;
+}
+
+int
+main ()
+{
+  int a = foo ();
+  int b = bar ();
+  if (a != b)
+    __builtin_abort ();
+  a = baz ();
+  b = qux ();
+  if (a != b)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00601-g.torture.execute-pr93945/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00601-g.torture.execute-pr93945/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..24505049186dd7ab62be220090d1dd6c410ed4f1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00601-g.torture.execute-pr93945/test.cfg
@@ -0,0 +1,2 @@
+compile(pr93945)
+run(pr93945)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00602-g.torture.execute-pr94130/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00602-g.torture.execute-pr94130/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00602-g.torture.execute-pr94130/pr94130.c b/testsuite/c_test/x64_be_enable_test/GCC00602-g.torture.execute-pr94130/pr94130.c
new file mode 100644
index 0000000000000000000000000000000000000000..044e578d373938e717127df30ee100b6fbc156ca
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00602-g.torture.execute-pr94130/pr94130.c
@@ -0,0 +1,16 @@
+/* PR tree-optimization/94130 */
+
+int
+main ()
+{
+  int a[8];
+  char *b = __builtin_memset (a, 0, sizeof (a));
+  a[0] = 1;
+  a[1] = 2;
+  a[2] = 3;
+  if (b != (char *) a)
+    __builtin_abort ();
+  else
+    asm volatile ("" : : "g" (a) : "memory");
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00602-g.torture.execute-pr94130/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00602-g.torture.execute-pr94130/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..39af06155bb11744c8fec47a17ae3201c9897676
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00602-g.torture.execute-pr94130/test.cfg
@@ -0,0 +1,2 @@
+compile(pr94130)
+run(pr94130)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00603-g.torture.execute-pr94134/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00603-g.torture.execute-pr94134/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00603-g.torture.execute-pr94134/pr94134.c b/testsuite/c_test/x64_be_enable_test/GCC00603-g.torture.execute-pr94134/pr94134.c
new file mode 100644
index 0000000000000000000000000000000000000000..b1b44c3b184d851e4ffd6f7e3007a05ad6d55e16
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00603-g.torture.execute-pr94134/pr94134.c
@@ -0,0 +1,14 @@
+/* PR target/94134 */
+
+static volatile int a = 0;
+static volatile int b = 1;
+
+int
+main ()
+{
+  a++;
+  b++;
+  if (a != 1 || b != 2)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00603-g.torture.execute-pr94134/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00603-g.torture.execute-pr94134/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8d82a9fed513247036959a49581b280c1982a9e9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00603-g.torture.execute-pr94134/test.cfg
@@ -0,0 +1,2 @@
+compile(pr94134)
+run(pr94134)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00604-g.torture.execute-pr94734/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00604-g.torture.execute-pr94734/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00604-g.torture.execute-pr94734/pr94734.c b/testsuite/c_test/x64_be_enable_test/GCC00604-g.torture.execute-pr94734/pr94734.c
new file mode 100644
index 0000000000000000000000000000000000000000..9df0de626ed84b1158615bdd069f365683afeda8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00604-g.torture.execute-pr94734/pr94734.c
@@ -0,0 +1,59 @@
+/* PR tree-optimization/94734 */
+
+__attribute__((noipa)) int
+foo (int n)
+{
+  int arr[16], s = 0;
+  for (int i = 0; i < n; i++)
+    {
+      if (i < 16)
+	arr[i] = i;
+    }
+  for (int i = 0; i < 16; i++)
+    s += arr[i];
+  return s;
+}
+
+__attribute__((noipa)) int
+bar (int n, int x, unsigned long y, unsigned long z)
+{
+  int arr[16], s = 0;
+  arr[4] = 42;
+  for (int i = 0; i < n; i++)
+    {
+      if (x == (i & 0x25))
+	arr[y] = i;
+    }
+  return arr[z];
+}
+
+__attribute__((noipa)) int
+baz (int n, int x, unsigned long z)
+{
+  int arr[16], s = 0;
+  arr[12] = 42;
+  for (int i = 0; i < n; i++)
+    {
+      if (x == (i & 0x25))
+	arr[7] = i;
+    }
+  return arr[z];
+}
+
+int
+main ()
+{
+  if (foo (10374) != 15 * 16 / 2)
+    __builtin_abort ();
+  if (bar (25, 0x25, (unsigned long) 0xdeadbeefbeefdeadULL, 4) != 42)
+    __builtin_abort ();
+  if (bar (25, 4, 15, 15) != 22)
+    __builtin_abort ();
+  if (baz (25, 0x25, 12) != 42)
+    __builtin_abort ();
+  if (baz (25, 4, 7) != 22)
+    __builtin_abort ();
+  if (baz (25, 4, 12) != 42)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00604-g.torture.execute-pr94734/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00604-g.torture.execute-pr94734/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..179eb7aa2de5e70682df2c3903079476d947cbbf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00604-g.torture.execute-pr94734/test.cfg
@@ -0,0 +1,2 @@
+compile(pr94734)
+run(pr94734)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00605-g.torture.execute-pr97073/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00605-g.torture.execute-pr97073/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00605-g.torture.execute-pr97073/pr97073.c b/testsuite/c_test/x64_be_enable_test/GCC00605-g.torture.execute-pr97073/pr97073.c
new file mode 100644
index 0000000000000000000000000000000000000000..1955e6b8bd258960da03a75522e185b37985318c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00605-g.torture.execute-pr97073/pr97073.c
@@ -0,0 +1,21 @@
+/* PR middle-end/97073 */
+/* { dg-additional-options "-mno-stv" { target i?86-*-* x86_64-*-* } } */
+
+typedef unsigned long long L;
+union U { L i; struct T { unsigned k; L l; } j; } u;
+
+__attribute__((noinline,noclone)) void
+foo (L x)
+{
+  u.j.l = u.i & x;
+}
+
+int
+main ()
+{
+  u.i = 5;
+  foo (-1ULL);
+  if (u.j.l != 5)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00605-g.torture.execute-pr97073/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00605-g.torture.execute-pr97073/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9cff7faaa10df9dbf50858414d7ae6c79cef6eec
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00605-g.torture.execute-pr97073/test.cfg
@@ -0,0 +1,2 @@
+compile(pr97073)
+run(pr97073)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00606-g.torture.execute-pr97386-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00606-g.torture.execute-pr97386-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00606-g.torture.execute-pr97386-2/pr97386-2.c b/testsuite/c_test/x64_be_enable_test/GCC00606-g.torture.execute-pr97386-2/pr97386-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..e61829d71abded76a16a852a25b82a44e758d103
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00606-g.torture.execute-pr97386-2/pr97386-2.c
@@ -0,0 +1,20 @@
+/* PR rtl-optimization/97386 */
+
+__attribute__((noipa)) unsigned
+foo (int x)
+{
+  unsigned long long a = (0x800000000000ccccULL << x) | (0x800000000000ccccULL >> (64 - x));
+  unsigned int b = a;
+  return (b << 24) | (b >> 8);
+}
+
+int
+main ()
+{
+  if (__CHAR_BIT__ == 8
+      && __SIZEOF_INT__ == 4
+      &&  __SIZEOF_LONG_LONG__ == 8
+      && foo (1) != 0x99000199U)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00606-g.torture.execute-pr97386-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00606-g.torture.execute-pr97386-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..28dcd2376b2488ca631bd0ac70a6bebdf83e0ed9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00606-g.torture.execute-pr97386-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr97386-2)
+run(pr97386-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00607-g.torture.execute-pr97421-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00607-g.torture.execute-pr97421-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00607-g.torture.execute-pr97421-1/pr97421-1.c b/testsuite/c_test/x64_be_enable_test/GCC00607-g.torture.execute-pr97421-1/pr97421-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e32fb129f1833cee49a4f6dc18ec999a6635a653
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00607-g.torture.execute-pr97421-1/pr97421-1.c
@@ -0,0 +1,23 @@
+/* PR rtl-optimization/97421 */
+/* { dg-additional-options "-fmodulo-sched" } */
+
+int a, b, d, e;
+int *volatile c = &a;
+
+__attribute__((noinline))
+void f(void)
+{
+  for (int g = 2; g >= 0; g--) {
+    d = 0;
+    for (b = 0; b <= 2; b++)
+      ;
+    e = *c;
+  }
+}
+
+int main(void)
+{
+  f();
+  if (b != 3)
+    __builtin_abort();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00607-g.torture.execute-pr97421-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00607-g.torture.execute-pr97421-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16a9ff7cadfa47000016af730b3cd883f55e7fc0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00607-g.torture.execute-pr97421-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr97421-1)
+run(pr97421-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00608-g.torture.execute-pr97421-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00608-g.torture.execute-pr97421-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00608-g.torture.execute-pr97421-2/pr97421-2.c b/testsuite/c_test/x64_be_enable_test/GCC00608-g.torture.execute-pr97421-2/pr97421-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..142bcbcee91eb3340d11e4a830fb00afa849e6b6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00608-g.torture.execute-pr97421-2/pr97421-2.c
@@ -0,0 +1,18 @@
+/* PR rtl-optimization/97421 */
+/* { dg-additional-options "-fmodulo-sched -fno-dce -fno-strict-aliasing" } */
+
+static int a, b, c;
+int *d = &c;
+int **e = &d;
+int ***f = &e;
+int main()
+{
+  int h;
+  for (a = 2; a; a--)
+    for (h = 0; h <= 2; h++)
+      for (b = 0; b <= 2; b++)
+        ***f = 6;
+
+  if (b != 3)
+    __builtin_abort();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00608-g.torture.execute-pr97421-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00608-g.torture.execute-pr97421-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f14d397ab67751c021c9c7eab8a516eb44272a57
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00608-g.torture.execute-pr97421-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr97421-2)
+run(pr97421-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00609-g.torture.execute-pr97764/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00609-g.torture.execute-pr97764/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00609-g.torture.execute-pr97764/pr97764.c b/testsuite/c_test/x64_be_enable_test/GCC00609-g.torture.execute-pr97764/pr97764.c
new file mode 100644
index 0000000000000000000000000000000000000000..4ceaab8e87eb15886ea3e20761a1f1ea5ae3c7ca
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00609-g.torture.execute-pr97764/pr97764.c
@@ -0,0 +1,14 @@
+/* PR tree-optimization/97764 */
+/* { dg-require-effective-target int32plus } */
+
+struct S { int b : 3; int c : 28; int d : 1; };
+
+int
+main ()
+{
+  struct S e = {};
+  e.c = -1;
+  if (e.d)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00609-g.torture.execute-pr97764/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00609-g.torture.execute-pr97764/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..719acc168881f6837e26b90c9d7887e3cc852377
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00609-g.torture.execute-pr97764/test.cfg
@@ -0,0 +1,2 @@
+compile(pr97764)
+run(pr97764)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00610-g.torture.execute-pr97836/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00610-g.torture.execute-pr97836/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00610-g.torture.execute-pr97836/pr97836.c b/testsuite/c_test/x64_be_enable_test/GCC00610-g.torture.execute-pr97836/pr97836.c
new file mode 100644
index 0000000000000000000000000000000000000000..4585e1fc69d27ac7c3b66e3396b0b99c6a086d3d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00610-g.torture.execute-pr97836/pr97836.c
@@ -0,0 +1,17 @@
+int a;
+
+int b(int c) { return 0; }
+
+static int *d(int *e) {
+  if (a) {
+    a = a && b(*e);
+  }
+  return e;
+}
+
+int main() {
+  int f;
+  if (d(&f) != &f)
+    __builtin_abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00610-g.torture.execute-pr97836/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00610-g.torture.execute-pr97836/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d4cb95f9fa7e8f777a69637eb4623389b99527d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00610-g.torture.execute-pr97836/test.cfg
@@ -0,0 +1,2 @@
+compile(pr97836)
+run(pr97836)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00611-g.torture.execute-pr98366/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00611-g.torture.execute-pr98366/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00611-g.torture.execute-pr98366/pr98366.c b/testsuite/c_test/x64_be_enable_test/GCC00611-g.torture.execute-pr98366/pr98366.c
new file mode 100644
index 0000000000000000000000000000000000000000..14415bfab9f7cac159efc55806ec65ec2990d1f3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00611-g.torture.execute-pr98366/pr98366.c
@@ -0,0 +1,13 @@
+/* PR middle-end/98366 */
+/* { dg-require-effective-target int32 } */
+
+typedef struct S { int a, b, c : 7, d : 8, e : 17; } S;
+const S f[] = { {0, 3, 4, 2, 0} };
+
+int
+main ()
+{
+  if (__builtin_memcmp (f, (S[]){{.b = 3, .c = 4, .d = 2, .e = 0}}, sizeof (S)))
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00611-g.torture.execute-pr98366/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00611-g.torture.execute-pr98366/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c5018e4bc150ca70a720d414df8d404472bcd7e2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00611-g.torture.execute-pr98366/test.cfg
@@ -0,0 +1,2 @@
+compile(pr98366)
+run(pr98366)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00612-g.torture.execute-pr98681/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00612-g.torture.execute-pr98681/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00612-g.torture.execute-pr98681/pr98681.c b/testsuite/c_test/x64_be_enable_test/GCC00612-g.torture.execute-pr98681/pr98681.c
new file mode 100644
index 0000000000000000000000000000000000000000..a256881342fc9790f8220f9d5c3bf7b643ec9666
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00612-g.torture.execute-pr98681/pr98681.c
@@ -0,0 +1,18 @@
+/* PR target/98681 */
+
+__attribute__((noipa)) int
+foo (int x)
+{
+  if (x > 32)
+    return (x << -64) & 255;
+  else
+    return x;
+}
+
+int
+main ()
+{
+  if (foo (32) != 32 || foo (-150) != -150)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00612-g.torture.execute-pr98681/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00612-g.torture.execute-pr98681/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..25236740d377f0c4f351c148d946254a378da2d3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00612-g.torture.execute-pr98681/test.cfg
@@ -0,0 +1,2 @@
+compile(pr98681)
+run(pr98681)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00613-g.torture.execute-pr98853-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00613-g.torture.execute-pr98853-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00613-g.torture.execute-pr98853-2/pr98853-2.c b/testsuite/c_test/x64_be_enable_test/GCC00613-g.torture.execute-pr98853-2/pr98853-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a3b0f2e9ba635eddf2397207a6704d86aa220cc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00613-g.torture.execute-pr98853-2/pr98853-2.c
@@ -0,0 +1,19 @@
+/* PR target/98853 */
+
+#if __SIZEOF_INT__ == 4 && __SIZEOF_LONG_LONG__ == 8
+__attribute__((noipa)) unsigned long long
+foo (unsigned long long x, unsigned int y)
+{
+  return ((unsigned) x & 0xfffe0000U) | (y & 0x1ffff);
+}
+#endif
+
+int
+main ()
+{
+#if __SIZEOF_INT__ == 4 && __SIZEOF_LONG_LONG__ == 8
+  if (foo (0xdeadbeefcaf2babeULL, 0xdeaffeedU) != 0x00000000caf3feedULL)
+    __builtin_abort ();
+#endif
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00613-g.torture.execute-pr98853-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00613-g.torture.execute-pr98853-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..28c0512fbcb3d32729bc2d321e59541b37680a37
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00613-g.torture.execute-pr98853-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr98853-2)
+run(pr98853-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00614-g.torture.execute-pr99751/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00614-g.torture.execute-pr99751/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00614-g.torture.execute-pr99751/pr99751.c b/testsuite/c_test/x64_be_enable_test/GCC00614-g.torture.execute-pr99751/pr99751.c
new file mode 100644
index 0000000000000000000000000000000000000000..f1d5101c359ad5a830d4ca9819cf8b7c2e98ce07
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00614-g.torture.execute-pr99751/pr99751.c
@@ -0,0 +1,20 @@
+int *ptr1 = 0, **ptr2 = &ptr1;
+
+int *identity(int *p)
+{
+  return p;
+}
+
+void store_to_c(int *p)
+{
+  *ptr2 = identity(p);
+}
+
+int main()
+{
+  int f;
+  store_to_c(&f);
+  if (ptr1 != &f)
+    __builtin_abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00614-g.torture.execute-pr99751/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00614-g.torture.execute-pr99751/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a4c73b6b3b9ba52c16c7ad2a9c1fea22243f0d0e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00614-g.torture.execute-pr99751/test.cfg
@@ -0,0 +1,2 @@
+compile(pr99751)
+run(pr99751)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00615-g.torture.execute-printf-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00615-g.torture.execute-printf-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..63b29a219d5b16d0b37edf195e45913dfecabdd1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00615-g.torture.execute-printf-1/expected.txt
@@ -0,0 +1,10 @@
+hellohellohello
+hello
+aahellohellohello
+hello
+aaxxhello
+
+hello
+
+0
+0
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00615-g.torture.execute-printf-1/printf-1.c b/testsuite/c_test/x64_be_enable_test/GCC00615-g.torture.execute-printf-1/printf-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..654e62766a85e879a3c0a3920788a3845415d1db
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00615-g.torture.execute-printf-1/printf-1.c
@@ -0,0 +1,25 @@
+/* { dg-skip-if "requires io" { freestanding } }  */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int
+main (void)
+{
+#define test(ret, args...) \
+  printf (args); 		\
+  if (printf (args) != ret)	\
+    abort ();
+  test (5, "hello");
+  test (6, "hello\n");
+  test (1, "a");
+  test (0, "");
+  test (5, "%s", "hello");
+  test (6, "%s", "hello\n");
+  test (1, "%s", "a");
+  test (0, "%s", "");
+  test (1, "%c", 'x');
+  test (7, "%s\n", "hello\n");
+  test (2, "%d\n", 0);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00615-g.torture.execute-printf-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00615-g.torture.execute-printf-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3aadc12be1dade16c4bcf58cc159d12c9d85528e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00615-g.torture.execute-printf-1/test.cfg
@@ -0,0 +1,2 @@
+compile(printf-1)
+run(printf-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00616-g.torture.execute-printf-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00616-g.torture.execute-printf-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00616-g.torture.execute-printf-2/printf-2.c b/testsuite/c_test/x64_be_enable_test/GCC00616-g.torture.execute-printf-2/printf-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..4e7d8f7cdfad6c6023fc8eae469b9f9a0f290be9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00616-g.torture.execute-printf-2/printf-2.c
@@ -0,0 +1,64 @@
+/* Verify that calls to printf don't get eliminated even if their
+   result on success can be computed at compile time (they can fail).
+   The calls can still be transformed into those of other functions.
+   { dg-require-effective-target unwrapped }
+   { dg-require-effective-target fileio }
+   { dg-prune-output "warning: warning: \[^\n\r\]* possibly used unsafely" }
+   { dg-skip-if "requires io" { avr-*-* } }
+   { dg-skip-if "requires io" { freestanding } } */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+__attribute__ ((noipa)) void
+write_file (void)
+{
+  printf ("1");
+  printf ("%c", '2');
+  printf ("%c%c", '3', '4');
+  printf ("%s", "5");
+  printf ("%s%s", "6", "7");
+  printf ("%i", 8);
+  printf ("%.1s\n", "9x");
+}
+
+
+int main (void)
+{
+  char *tmpfname = tmpnam (0);
+  FILE *f = freopen (tmpfname, "w", stdout);
+  if (!f)
+    {
+      perror ("fopen for writing");
+      return 1;
+    }
+
+  write_file ();
+  fclose (f);
+
+  f = fopen (tmpfname, "r");
+  if (!f)
+    {
+      perror ("fopen for reading");
+      remove (tmpfname);
+      return 1;
+    }
+
+  char buf[12] = "";
+  if (1 != fscanf (f, "%s", buf))
+    {
+      perror ("fscanf");
+      fclose (f);
+      remove (tmpfname);
+      return 1;
+    }
+
+  fclose (f);
+  remove (tmpfname);
+
+  if (strcmp (buf, "123456789"))
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00616-g.torture.execute-printf-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00616-g.torture.execute-printf-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d9d4b28237ee8936254111a8bd0e683f431a5f41
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00616-g.torture.execute-printf-2/test.cfg
@@ -0,0 +1,2 @@
+compile(printf-2)
+run(printf-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00617-g.torture.execute-pta-field-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00617-g.torture.execute-pta-field-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00617-g.torture.execute-pta-field-2/pta-field-2.c b/testsuite/c_test/x64_be_enable_test/GCC00617-g.torture.execute-pta-field-2/pta-field-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..dffd7154ce0057b2675db83ceada196872d39b70
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00617-g.torture.execute-pta-field-2/pta-field-2.c
@@ -0,0 +1,29 @@
+struct Foo {
+  int *p;
+  int *q;
+};
+
+void __attribute__((noinline))
+bar (int **x)
+{
+  struct Foo *f = (struct Foo *)(x - 1);
+  *(f->p) = 0;
+}
+
+int foo(void)
+{
+  struct Foo f;
+  int i = 1, j = 2;
+  f.p = &i;
+  f.q = &j;
+  bar(&f.q);
+  return i;
+}
+
+extern void abort (void);
+int main()
+{
+  if (foo () != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00617-g.torture.execute-pta-field-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00617-g.torture.execute-pta-field-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9724ee4a22005e12d1592e17f3a7a8646c100480
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00617-g.torture.execute-pta-field-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pta-field-2)
+run(pta-field-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00618-g.torture.execute-ptr-arith-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00618-g.torture.execute-ptr-arith-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00618-g.torture.execute-ptr-arith-1/ptr-arith-1.c b/testsuite/c_test/x64_be_enable_test/GCC00618-g.torture.execute-ptr-arith-1/ptr-arith-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..46162b8964d8b01937ade4d12fa42da62a16150f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00618-g.torture.execute-ptr-arith-1/ptr-arith-1.c
@@ -0,0 +1,14 @@
+char *
+f (char *s, unsigned int i)
+{
+  return &s[i + 3 - 1];
+}
+
+main ()
+{
+  char *str = "abcdefghijkl";
+  char *x2 = f (str, 12);
+  if (str + 14 != x2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00618-g.torture.execute-ptr-arith-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00618-g.torture.execute-ptr-arith-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..756de6c69426c4cf9a9bd71c22215b0cd8af5e8c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00618-g.torture.execute-ptr-arith-1/test.cfg
@@ -0,0 +1,2 @@
+compile(ptr-arith-1)
+run(ptr-arith-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00619-g.torture.execute-pushpop_macro/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00619-g.torture.execute-pushpop_macro/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00619-g.torture.execute-pushpop_macro/pushpop_macro.c b/testsuite/c_test/x64_be_enable_test/GCC00619-g.torture.execute-pushpop_macro/pushpop_macro.c
new file mode 100644
index 0000000000000000000000000000000000000000..08a82204313e899fbd5643ca8e3d79a27a46e642
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00619-g.torture.execute-pushpop_macro/pushpop_macro.c
@@ -0,0 +1,15 @@
+extern void abort ();
+
+#define _ 2
+#pragma push_macro("_")
+#undef _
+#define _ 1
+#pragma pop_macro("_")
+
+int main ()
+{
+  if (_ != 2)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00619-g.torture.execute-pushpop_macro/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00619-g.torture.execute-pushpop_macro/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c7a73016ff56adfdfe6d80da7009e4e1b5ab17c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00619-g.torture.execute-pushpop_macro/test.cfg
@@ -0,0 +1,2 @@
+compile(pushpop_macro)
+run(pushpop_macro)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00620-g.torture.execute-restrict-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00620-g.torture.execute-restrict-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00620-g.torture.execute-restrict-1/restrict-1.c b/testsuite/c_test/x64_be_enable_test/GCC00620-g.torture.execute-restrict-1/restrict-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c55286152376d1f00a7f23af60ff9fecd28605a5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00620-g.torture.execute-restrict-1/restrict-1.c
@@ -0,0 +1,31 @@
+/*  PR rtl-optimization/16536
+    Origin:  Jeremy Denise      <jeremy.denise@libertysurf.fr>
+    Reduced: Wolfgang Bangerth  <bangerth@dealii.org>
+             Volker Reichelt    <reichelt@igpm.rwth-aachen.de>  */
+/* { dg-options "-fgnu89-inline" } */
+
+extern void abort ();
+
+typedef struct
+{
+  int i, dummy;
+} A;
+
+inline A foo (const A* p, const A* q)
+{
+  return (A){p->i+q->i};
+}
+
+void bar (A* __restrict__ p)
+{
+  *p=foo(p,p);
+  if (p->i!=2)
+    abort();
+}
+
+int main ()
+{
+  A a={1};
+  bar(&a);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00620-g.torture.execute-restrict-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00620-g.torture.execute-restrict-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d595bf03b8ce262273012f42ceff1bcfdbaed7ef
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00620-g.torture.execute-restrict-1/test.cfg
@@ -0,0 +1,2 @@
+compile(restrict-1)
+run(restrict-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00621-g.torture.execute-scope-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00621-g.torture.execute-scope-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00621-g.torture.execute-scope-1/scope-1.c b/testsuite/c_test/x64_be_enable_test/GCC00621-g.torture.execute-scope-1/scope-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..cedd0b48ccb2026c5b4ae98759f2c4fe9a6f40a0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00621-g.torture.execute-scope-1/scope-1.c
@@ -0,0 +1,17 @@
+int v = 3;
+
+f ()
+{
+  int v = 4;
+  {
+    extern int v;
+    if (v != 3)
+      abort ();
+  }
+}
+
+main ()
+{
+  f ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00621-g.torture.execute-scope-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00621-g.torture.execute-scope-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..862893e8fe8026380c159a9f7b59308dd8994567
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00621-g.torture.execute-scope-1/test.cfg
@@ -0,0 +1,2 @@
+compile(scope-1)
+run(scope-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00622-g.torture.execute-shiftdi-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00622-g.torture.execute-shiftdi-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00622-g.torture.execute-shiftdi-2/shiftdi-2.c b/testsuite/c_test/x64_be_enable_test/GCC00622-g.torture.execute-shiftdi-2/shiftdi-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..812946f2850c2ed60d0f355f2177069d42cb26a9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00622-g.torture.execute-shiftdi-2/shiftdi-2.c
@@ -0,0 +1,24 @@
+/* { dg-require-effective-target longlong64 } */
+
+long long a = 568513516876543756;
+long long b = -754324895235774564;
+unsigned long long c = 156789543257562457;
+
+long long expected_a[64] = {568513516876543756, 1137027033753087512, 2274054067506175024, 4548108135012350048, 9096216270024700096, -254311533660151424, -508623067320302848, -1017246134640605696, -2034492269281211392, -4068984538562422784, -8137969077124845568, 2170805919459860480, 4341611838919720960, 8683223677839441920, -1080296718030667776, -2160593436061335552, -4321186872122671104, -8642373744245342208, 1161996585218867200, 2323993170437734400, 4647986340875468800, -9150771391958614016, 145201289792323584, 290402579584647168, 580805159169294336, 1161610318338588672, 2323220636677177344, 4646441273354354688, -9153861527000842240, 139021019707867136, 278042039415734272, 556084078831468544, 1112168157662937088, 2224336315325874176, 4448672630651748352, 8897345261303496704, -652053551102558208, -1304107102205116416, -2608214204410232832, -5216428408820465664, 8013887256068620288, -2418969561572311040, -4837939123144622080, 8770865827420307456, -905012418868936704, -1810024837737873408, -3620049675475746816, -7240099350951493632, 3966545371806564352, 7933090743613128704, -2580562586483294208, -5161125172966588416, 8124493727776374784, -2197756618156802048, -4395513236313604096, -8791026472627208192, 864691128455135232, 1729382256910270464, 3458764513820540928, 6917529027641081856, -4611686018427387904, -9223372036854775808ULL, 0, 0};
+long long expected_b[64] = {-754324895235774564, -377162447617887282, -188581223808943641, -94290611904471821, -47145305952235911, -23572652976117956, -11786326488058978, -5893163244029489, -2946581622014745, -1473290811007373, -736645405503687, -368322702751844, -184161351375922, -92080675687961, -46040337843981, -23020168921991, -11510084460996, -5755042230498, -2877521115249, -1438760557625, -719380278813, -359690139407, -179845069704, -89922534852, -44961267426, -22480633713, -11240316857, -5620158429, -2810079215, -1405039608, -702519804, -351259902, -175629951, -87814976, -43907488, -21953744, -10976872, -5488436, -2744218, -1372109, -686055, -343028, -171514, -85757, -42879, -21440, -10720, -5360, -2680, -1340, -670, -335, -168, -84, -42, -21, -11, -6, -3, -2, -1, -1, -1, -1};
+unsigned long long expected_c[64] = {156789543257562457, 78394771628781228, 39197385814390614, 19598692907195307, 9799346453597653, 4899673226798826, 2449836613399413, 1224918306699706, 612459153349853, 306229576674926, 153114788337463, 76557394168731, 38278697084365, 19139348542182, 9569674271091, 4784837135545, 2392418567772, 1196209283886, 598104641943, 299052320971, 149526160485, 74763080242, 37381540121, 18690770060, 9345385030, 4672692515, 2336346257, 1168173128, 584086564, 292043282, 146021641, 73010820, 36505410, 18252705, 9126352, 4563176, 2281588, 1140794, 570397, 285198, 142599, 71299, 35649, 17824, 8912, 4456, 2228, 1114, 557, 278, 139, 69, 34, 17, 8, 4, 2, 1, 0, 0, 0, 0, 0, 0};
+
+int
+main (void)
+{
+  int i;
+
+  for (i = 0; i < 64; i++)
+  {
+    if ((a << i) != expected_a[i]
+	|| (b >> i) != expected_b[i]
+	|| (c >> i) != expected_c[i])
+      __builtin_abort ();
+  }
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00622-g.torture.execute-shiftdi-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00622-g.torture.execute-shiftdi-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..75d0d63a591e917ef475671843f24ff3d094bdad
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00622-g.torture.execute-shiftdi-2/test.cfg
@@ -0,0 +1,2 @@
+compile(shiftdi-2)
+run(shiftdi-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00623-g.torture.execute-shiftdi/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00623-g.torture.execute-shiftdi/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00623-g.torture.execute-shiftdi/shiftdi.c b/testsuite/c_test/x64_be_enable_test/GCC00623-g.torture.execute-shiftdi/shiftdi.c
new file mode 100644
index 0000000000000000000000000000000000000000..7e0409800c43744038b363eb767de3c426079c88
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00623-g.torture.execute-shiftdi/shiftdi.c
@@ -0,0 +1,22 @@
+/* { dg-require-effective-target int32plus } */
+
+/* Failed on sparc with -mv8plus because sparc.c:set_extends() thought
+   erroneously that SImode ASHIFT chops the upper bits, it does not.  */
+
+typedef unsigned long long uint64;
+
+void g(uint64 x, int y, int z, uint64 *p)
+{
+	unsigned w = ((x >> y) & 0xffffffffULL) << (z & 0x1f);
+	*p |= (w & 0xffffffffULL) << z;
+}
+
+int main(void)
+{
+	uint64 a = 0;
+	g(0xdeadbeef01234567ULL, 0, 0, &a);
+	return (a == 0x01234567) ? 0 : 1;
+}
+
+
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00623-g.torture.execute-shiftdi/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00623-g.torture.execute-shiftdi/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f4237b365aab4812994396f1e3b9ea2d769871f8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00623-g.torture.execute-shiftdi/test.cfg
@@ -0,0 +1,2 @@
+compile(shiftdi)
+run(shiftdi)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00624-g.torture.execute-shiftopt-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00624-g.torture.execute-shiftopt-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00624-g.torture.execute-shiftopt-1/shiftopt-1.c b/testsuite/c_test/x64_be_enable_test/GCC00624-g.torture.execute-shiftopt-1/shiftopt-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c855b88895bbe211a683c34a984ed14176db6dc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00624-g.torture.execute-shiftopt-1/shiftopt-1.c
@@ -0,0 +1,67 @@
+/* Copyright (C) 2002  Free Software Foundation
+
+   Check that constant folding of shift operations is working.
+
+   Roger Sayle, 10th October 2002.  */
+
+extern void abort (void);
+extern void link_error (void);
+
+void
+utest (unsigned int x)
+{
+  if (x >> 0 != x)
+    link_error ();
+
+  if (x << 0 != x)
+    link_error ();
+
+  if (0 << x != 0)
+    link_error ();
+
+  if (0 >> x != 0)
+    link_error ();
+
+  if (-1 >> x != -1)
+    link_error ();
+
+  if (~0 >> x != ~0)
+    link_error ();
+}
+
+void
+stest (int x)
+{
+  if (x >> 0 != x)
+    link_error ();
+
+  if (x << 0 != x)
+    link_error ();
+
+  if (0 << x != 0)
+    link_error ();
+
+  if (0 >> x != 0)
+    link_error ();
+}
+
+int
+main ()
+{
+  utest(9);
+  utest(0);
+
+  stest(9);
+  stest(0);
+
+  return 0;
+}
+
+#ifndef __OPTIMIZE__
+void
+link_error ()
+{
+  abort ();
+}
+#endif
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00624-g.torture.execute-shiftopt-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00624-g.torture.execute-shiftopt-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b89e1e9afe3854abb08f6c87cdcd408d1eeb6c34
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00624-g.torture.execute-shiftopt-1/test.cfg
@@ -0,0 +1,2 @@
+compile(shiftopt-1)
+run(shiftopt-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00625-g.torture.execute-stkalign/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00625-g.torture.execute-stkalign/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00625-g.torture.execute-stkalign/stkalign.c b/testsuite/c_test/x64_be_enable_test/GCC00625-g.torture.execute-stkalign/stkalign.c
new file mode 100644
index 0000000000000000000000000000000000000000..e10a1d2ec24fb4e58552c5b038969c99118c324a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00625-g.torture.execute-stkalign/stkalign.c
@@ -0,0 +1,44 @@
+/* { dg-options "-fno-inline" } */
+/* Check that stack alignment is not affected by variables not placed
+   on the stack.  */
+
+#include <assert.h>
+
+#define ALIGNMENT 64
+
+unsigned test(unsigned n, unsigned p)
+{
+  static struct { char __attribute__((__aligned__(ALIGNMENT))) c; } s;
+  unsigned x;
+
+  assert(__alignof__(s) == ALIGNMENT);
+  asm ("" : "=g" (x), "+m" (s) : "0" (&x));
+
+  return n ? test(n - 1, x) : (x ^ p);
+}
+
+unsigned test2(unsigned n, unsigned p)
+{
+  static struct { char c; } s;
+  unsigned x;
+
+  assert(__alignof__(s) != ALIGNMENT);
+  asm ("" : "=g" (x), "+m" (s) : "0" (&x));
+
+  return n ? test2(n - 1, x) : (x ^ p);
+}
+
+int main (int argc, char *argv[] __attribute__((unused)))
+{
+  unsigned int x, y;
+
+  x = test(argc, 0);
+  x |= test(argc + 1, 0);
+  x |= test(argc + 2, 0);
+
+  y = test2(argc, 0);
+  y |= test2(argc + 1, 0);
+  y |= test2(argc + 2, 0);
+
+  return (x & (ALIGNMENT - 1)) == 0 && (y & (ALIGNMENT - 1)) != 0 ? 1 : 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00625-g.torture.execute-stkalign/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00625-g.torture.execute-stkalign/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7cf8c8a6ebf2d59d07590a4d9adf03e7249989d1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00625-g.torture.execute-stkalign/test.cfg
@@ -0,0 +1,2 @@
+compile(stkalign)
+run(stkalign)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00626-g.torture.execute-strcmp-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00626-g.torture.execute-strcmp-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00626-g.torture.execute-strcmp-1/strcmp-1.c b/testsuite/c_test/x64_be_enable_test/GCC00626-g.torture.execute-strcmp-1/strcmp-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..79999af3cbe8866f85b0efba48ae4227cdf89594
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00626-g.torture.execute-strcmp-1/strcmp-1.c
@@ -0,0 +1,131 @@
+/* Copyright (C) 2002  Free Software Foundation.
+
+   Test strcmp with various combinations of pointer alignments and lengths to
+   make sure any optimizations in the library are correct.
+
+   Written by Michael Meissner, March 9, 2002.  */
+
+#include <string.h>
+#include <stddef.h>
+
+#ifndef MAX_OFFSET
+#define MAX_OFFSET (sizeof (long long))
+#endif
+
+#ifndef MAX_TEST
+#define MAX_TEST (8 * sizeof (long long))
+#endif
+
+#ifndef MAX_EXTRA
+#define MAX_EXTRA (sizeof (long long))
+#endif
+
+#define MAX_LENGTH (MAX_OFFSET + MAX_TEST + MAX_EXTRA + 2)
+
+static union {
+  unsigned char buf[MAX_LENGTH];
+  long long align_int;
+  long double align_fp;
+} u1, u2;
+
+void
+test (const unsigned char *s1, const unsigned char *s2, int expected)
+{
+  int value = strcmp ((char *) s1, (char *) s2);
+
+  if (expected < 0 && value >= 0)
+    abort ();
+  else if (expected == 0 && value != 0)
+    abort ();
+  else if (expected > 0 && value <= 0)
+    abort ();
+}
+
+main ()
+{
+  size_t off1, off2, len, i;
+  unsigned char *buf1, *buf2;
+  unsigned char *mod1, *mod2;
+  unsigned char *p1, *p2;
+
+  for (off1 = 0; off1 < MAX_OFFSET; off1++)
+    for (off2 = 0; off2 < MAX_OFFSET; off2++)
+      for (len = 0; len < MAX_TEST; len++)
+	{
+	  p1 = u1.buf;
+	  for (i = 0; i < off1; i++)
+	    *p1++ = '\0';
+
+	  buf1 = p1;
+	  for (i = 0; i < len; i++)
+	    *p1++ = 'a';
+
+	  mod1 = p1;
+	  for (i = 0; i < MAX_EXTRA+2; i++)
+	    *p1++ = 'x';
+
+	  p2 = u2.buf;
+	  for (i = 0; i < off2; i++)
+	    *p2++ = '\0';
+
+	  buf2 = p2;
+	  for (i = 0; i < len; i++)
+	    *p2++ = 'a';
+
+	  mod2 = p2;
+	  for (i = 0; i < MAX_EXTRA+2; i++)
+	    *p2++ = 'x';
+
+	  mod1[0] = '\0';
+	  mod2[0] = '\0';
+	  test (buf1, buf2, 0);
+
+	  mod1[0] = 'a';
+	  mod1[1] = '\0';
+	  mod2[0] = '\0';
+	  test (buf1, buf2, +1);
+
+	  mod1[0] = '\0';
+	  mod2[0] = 'a';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, -1);
+
+	  mod1[0] = 'b';
+	  mod1[1] = '\0';
+	  mod2[0] = 'c';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, -1);
+
+	  mod1[0] = 'c';
+	  mod1[1] = '\0';
+	  mod2[0] = 'b';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, +1);
+
+	  mod1[0] = 'b';
+	  mod1[1] = '\0';
+	  mod2[0] = (unsigned char)'\251';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, -1);
+
+	  mod1[0] = (unsigned char)'\251';
+	  mod1[1] = '\0';
+	  mod2[0] = 'b';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, +1);
+
+	  mod1[0] = (unsigned char)'\251';
+	  mod1[1] = '\0';
+	  mod2[0] = (unsigned char)'\252';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, -1);
+
+	  mod1[0] = (unsigned char)'\252';
+	  mod1[1] = '\0';
+	  mod2[0] = (unsigned char)'\251';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, +1);
+	}
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00626-g.torture.execute-strcmp-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00626-g.torture.execute-strcmp-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..26782470f7871f696eebcdebac9f7e0e5e3124d5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00626-g.torture.execute-strcmp-1/test.cfg
@@ -0,0 +1,2 @@
+compile(strcmp-1)
+run(strcmp-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00627-g.torture.execute-string-opt-17/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00627-g.torture.execute-string-opt-17/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00627-g.torture.execute-string-opt-17/string-opt-17.c b/testsuite/c_test/x64_be_enable_test/GCC00627-g.torture.execute-string-opt-17/string-opt-17.c
new file mode 100644
index 0000000000000000000000000000000000000000..76a351bfb6b86207515bcb24ba9347aa6b9f48c6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00627-g.torture.execute-string-opt-17/string-opt-17.c
@@ -0,0 +1,45 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Test strcpy optimizations don't evaluate side-effects twice.
+      
+   Written by Jakub Jelinek, June 23, 2003.  */
+
+typedef __SIZE_TYPE__ size_t;
+extern char *strcpy (char *, const char *);
+extern int memcmp (const void *, const void *, size_t);
+extern void abort (void);
+extern void exit (int);
+
+size_t
+test1 (char *s, size_t i)
+{
+  strcpy (s, "foobarbaz" + i++);
+  return i;
+}
+
+size_t
+check2 (void)
+{
+  static size_t r = 5;
+  if (r != 5)
+    abort ();
+  return ++r;
+}
+
+void
+test2 (char *s)
+{
+  strcpy (s, "foobarbaz" + check2 ());
+}
+
+int
+main (void)
+{
+  char buf[10];
+  if (test1 (buf, 7) != 8 || memcmp (buf, "az", 3))
+    abort ();
+  test2 (buf);
+  if (memcmp (buf, "baz", 4))
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00627-g.torture.execute-string-opt-17/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00627-g.torture.execute-string-opt-17/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7636980b806c1081bef78a29f8d3c99dff60a2d0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00627-g.torture.execute-string-opt-17/test.cfg
@@ -0,0 +1,2 @@
+compile(string-opt-17)
+run(string-opt-17)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00628-g.torture.execute-string-opt-18/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00628-g.torture.execute-string-opt-18/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00628-g.torture.execute-string-opt-18/string-opt-18.c b/testsuite/c_test/x64_be_enable_test/GCC00628-g.torture.execute-string-opt-18/string-opt-18.c
new file mode 100644
index 0000000000000000000000000000000000000000..610c4caf1ca2db2b4eb9113f211092c8e6b3043d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00628-g.torture.execute-string-opt-18/string-opt-18.c
@@ -0,0 +1,76 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Test equal pointer optimizations don't break anything.
+
+   Written by Roger Sayle, July 14, 2003.  */
+
+extern void abort ();
+typedef __SIZE_TYPE__ size_t;
+
+extern void *memcpy(void*, const void*, size_t);
+extern void *mempcpy(void*, const void*, size_t);
+extern void *memmove(void*, const void*, size_t);
+extern char *strcpy(char*, const char*);
+extern int memcmp(const void*, const void*, size_t);
+extern int strcmp(const char*, const char*);
+extern int strncmp(const char*, const char*, size_t);
+
+
+void test1 (void *ptr)
+{
+  if (memcpy(ptr,ptr,8) != ptr)
+    abort ();
+}
+
+void test2 (char *ptr)
+{
+  if (mempcpy(ptr,ptr,8) != ptr+8)
+    abort ();
+}
+
+void test3 (void *ptr)
+{
+  if (memmove(ptr,ptr,8) != ptr)
+    abort ();
+}
+
+void test4 (char *ptr)
+{
+  if (strcpy(ptr,ptr) != ptr)
+    abort ();
+}
+
+void test5 (void *ptr)
+{
+  if (memcmp(ptr,ptr,8) != 0)
+    abort ();
+}
+
+void test6 (const char *ptr)
+{
+  if (strcmp(ptr,ptr) != 0)
+    abort ();
+}
+
+void test7 (const char *ptr)
+{
+  if (strncmp(ptr,ptr,8) != 0)
+    abort ();
+}
+
+
+int main ()
+{
+  char buf[10];
+
+  test1 (buf);
+  test2 (buf);
+  test3 (buf);
+  test4 (buf);
+  test5 (buf);
+  test6 (buf);
+  test7 (buf);
+
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00628-g.torture.execute-string-opt-18/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00628-g.torture.execute-string-opt-18/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b32171b5934dfae49049adf08780c269b7bff368
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00628-g.torture.execute-string-opt-18/test.cfg
@@ -0,0 +1,2 @@
+compile(string-opt-18)
+run(string-opt-18)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00629-g.torture.execute-string-opt-5/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00629-g.torture.execute-string-opt-5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00629-g.torture.execute-string-opt-5/string-opt-5.c b/testsuite/c_test/x64_be_enable_test/GCC00629-g.torture.execute-string-opt-5/string-opt-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..178812226dc390d087abdebca1b7013b285ae72c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00629-g.torture.execute-string-opt-5/string-opt-5.c
@@ -0,0 +1,107 @@
+/* Copyright (C) 2000  Free Software Foundation.
+
+   Ensure builtin strlen, strcmp, strchr, strrchr and strncpy
+   perform correctly.
+
+   Written by Jakub Jelinek, 11/7/2000.  */
+
+extern void abort (void);
+extern __SIZE_TYPE__ strlen (const char *);
+extern int strcmp (const char *, const char *);
+extern char *strchr (const char *, int);
+extern char *strrchr (const char *, int);
+extern char *strncpy (char *, const char *, __SIZE_TYPE__);
+extern void *memset (void *, int, __SIZE_TYPE__);
+extern int memcmp (const void *, const void *, __SIZE_TYPE__);
+
+int x = 6;
+int y = 1;
+char *bar = "hi world";
+char buf [64];
+
+int main()
+{
+  const char *const foo = "hello world";
+  char dst [64];
+
+  if (strlen (bar) != 8)
+    abort ();
+  if (strlen (bar + (++x & 2)) != 6)
+    abort ();
+  if (x != 7)
+    abort ();
+  if (strlen (foo + (x++, 6)) != 5)
+    abort ();
+  if (x != 8)
+    abort ();
+  if (strlen (foo + (++x & 1)) != 10)
+    abort ();
+  if (x != 9)
+    abort ();
+  if (strcmp (foo + (x -= 6), "lo world"))
+    abort ();
+  if (x != 3)
+    abort ();
+  if (strcmp (foo, bar) >= 0)
+    abort ();
+  if (strcmp (foo, bar + (x++ & 1)) >= 0)
+    abort ();
+  if (x != 4)
+    abort ();
+  if (strchr (foo + (x++ & 7), 'l') != foo + 9)
+    abort ();
+  if (x != 5)
+    abort ();
+  if (strchr (bar, 'o') != bar + 4)
+    abort ();
+  if (strchr (bar, '\0')  != bar + 8)
+    abort ();
+  if (strrchr (bar, 'x'))
+    abort ();
+  if (strrchr (bar, 'o') != bar + 4)
+    abort ();
+  if (strcmp (foo + (x++ & 1), "ello world" + (--y & 1)))
+    abort ();
+  if (x != 6 || y != 0)
+    abort ();
+  dst[5] = ' ';
+  dst[6] = '\0';
+  x = 5;
+  y = 1;
+  if (strncpy (dst + 1, foo + (x++ & 3), 4) != dst + 1
+      || x != 6
+      || strcmp (dst + 1, "ello "))
+    abort ();
+  memset (dst, ' ', sizeof dst);
+  if (strncpy (dst + (++x & 1), (y++ & 3) + "foo", 10) != dst + 1
+      || x != 7
+      || y != 2
+      || memcmp (dst, " oo\0\0\0\0\0\0\0\0 ", 12))
+    abort ();
+  memset (dst, ' ', sizeof dst);
+  if (strncpy (dst, "hello", 8) != dst || memcmp (dst, "hello\0\0\0 ", 9))
+    abort ();
+  x = '!';
+  memset (buf, ' ', sizeof buf);
+  if (memset (buf, x++, ++y) != buf
+      || x != '!' + 1
+      || y != 3
+      || memcmp (buf, "!!!", 3))
+    abort ();
+  if (memset (buf + y++, '-', 8) != buf + 3
+      || y != 4
+      || memcmp (buf, "!!!--------", 11))
+    abort ();
+  x = 10;
+  if (memset (buf + ++x, 0, y++) != buf + 11
+      || x != 11
+      || y != 5
+      || memcmp (buf + 8, "---\0\0\0", 7))
+    abort ();
+  if (memset (buf + (x += 4), 0, 6) != buf + 15
+      || x != 15
+      || memcmp (buf + 10, "-\0\0\0\0\0\0\0\0\0", 11))
+    abort ();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00629-g.torture.execute-string-opt-5/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00629-g.torture.execute-string-opt-5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..58463d77f7d50d9b5539ec1fcf1730f75764fdf6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00629-g.torture.execute-string-opt-5/test.cfg
@@ -0,0 +1,2 @@
+compile(string-opt-5)
+run(string-opt-5)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00630-g.torture.execute-strlen-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00630-g.torture.execute-strlen-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00630-g.torture.execute-strlen-1/strlen-1.c b/testsuite/c_test/x64_be_enable_test/GCC00630-g.torture.execute-strlen-1/strlen-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c29592b8b88791d9f7a380edfc81f268b62f891d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00630-g.torture.execute-strlen-1/strlen-1.c
@@ -0,0 +1,57 @@
+/* Copyright (C) 2002  Free Software Foundation.
+
+   Test strlen with various combinations of pointer alignments and lengths to
+   make sure any optimizations in the library are correct.
+
+   Written by Michael Meissner, March 9, 2002.  */
+
+#include <string.h>
+#include <stddef.h>
+
+#ifndef MAX_OFFSET
+#define MAX_OFFSET (sizeof (long long))
+#endif
+
+#ifndef MAX_TEST
+#define MAX_TEST (8 * sizeof (long long))
+#endif
+
+#ifndef MAX_EXTRA
+#define MAX_EXTRA (sizeof (long long))
+#endif
+
+#define MAX_LENGTH (MAX_OFFSET + MAX_TEST + MAX_EXTRA + 1)
+
+static union {
+  char buf[MAX_LENGTH];
+  long long align_int;
+  long double align_fp;
+} u;
+
+main ()
+{
+  size_t off, len, len2, i;
+  char *p;
+
+  for (off = 0; off < MAX_OFFSET; off++)
+    for (len = 0; len < MAX_TEST; len++)
+      {
+	p = u.buf;
+	for (i = 0; i < off; i++)
+	  *p++ = '\0';
+
+	for (i = 0; i < len; i++)
+	  *p++ = 'a';
+
+	*p++ = '\0';
+	for (i = 0; i < MAX_EXTRA; i++)
+	  *p++ = 'b';
+
+	p = u.buf + off;
+	len2 = strlen (p);
+	if (len != len2)
+	  abort ();
+      }
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00630-g.torture.execute-strlen-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00630-g.torture.execute-strlen-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8ba30959d160ad7661cf616c3d2463760de9bca8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00630-g.torture.execute-strlen-1/test.cfg
@@ -0,0 +1,2 @@
+compile(strlen-1)
+run(strlen-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00631-g.torture.execute-strlen-5/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00631-g.torture.execute-strlen-5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00631-g.torture.execute-strlen-5/strlen-5.c b/testsuite/c_test/x64_be_enable_test/GCC00631-g.torture.execute-strlen-5/strlen-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..9af57d5ee394f1f329ee3f8daaec2a44d7b2c138
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00631-g.torture.execute-strlen-5/strlen-5.c
@@ -0,0 +1,653 @@
+/* Test to verify that even strictly undefined strlen() calls with
+   unterminated character arrays yield the "expected" results when
+   the terminating nul is present in a subsequent suobobject.  */
+
+extern __SIZE_TYPE__ strlen (const char *);
+
+unsigned nfails;
+
+#define A(expr, N)						\
+  do {								\
+    const char *s = (expr);					\
+    unsigned n = strlen (s);					\
+    ((n == N)							\
+     ? 0							\
+     : (__builtin_printf ("line %i: strlen (%s = \"%s\")"	\
+			  " == %u failed\n",			\
+			  __LINE__, #expr, s, N),		\
+	++nfails));						\
+  } while (0)
+
+
+int idx;
+
+
+const char ca[][4] = {
+  { '1', '2', '3', '4' }, { '5' },
+  { '1', '2', '3', '4' }, { '5', '6' },
+  { '1', '2', '3', '4' }, { '5', '6', '7' },
+  { '1', '2', '3', '4' }, { '5', '6', '7', '8' },
+  { '9' }
+};
+
+static void test_const_global_arrays (void)
+{
+  A (ca[0], 5);
+  A (&ca[0][0], 5);
+  A (&ca[0][1], 4);
+  A (&ca[0][3], 2);
+
+  int i = 0;
+  A (ca[i], 5);
+  A (&ca[i][0], 5);
+  A (&ca[i][1], 4);
+  A (&ca[i][3], 2);
+
+  int j = i;
+  A (&ca[i][i], 5);
+  A (&ca[i][j + 1], 4);
+  A (&ca[i][j + 2], 3);
+
+  A (&ca[idx][i], 5);
+  A (&ca[idx][j + 1], 4);
+  A (&ca[idx][j + 2], 3);
+
+  A (&ca[idx][idx], 5);
+  A (&ca[idx][idx + 1], 4);
+  A (&ca[idx][idx + 2], 3);
+
+  A (&ca[0][++j], 4);
+  A (&ca[0][++j], 3);
+  A (&ca[0][++j], 2);
+
+  if (j != 3)
+    ++nfails;
+}
+
+
+static void test_const_local_arrays (void)
+{
+  const char a[][4] = {
+    { '1', '2', '3', '4' }, { '5' },
+    { '1', '2', '3', '4' }, { '5', '6' },
+    { '1', '2', '3', '4' }, { '5', '6', '7' },
+    { '1', '2', '3', '4' }, { '5', '6', '7', '8' },
+    { '9' }
+  };
+
+  A (a[0], 5);
+  A (&a[0][0], 5);
+  A (&a[0][1], 4);
+  A (&a[0][3], 2);
+
+  int i = 0;
+  A (a[i], 5);
+  A (&a[i][0], 5);
+  A (&a[i][1], 4);
+  A (&a[i][3], 2);
+
+  int j = i;
+  A (&a[i][i], 5);
+  A (&a[i][j + 1], 4);
+  A (&a[i][j + 2], 3);
+
+  A (&a[idx][i], 5);
+  A (&a[idx][j + 1], 4);
+  A (&a[idx][j + 2], 3);
+
+  A (&a[idx][idx], 5);
+  A (&a[idx][idx + 1], 4);
+  A (&a[idx][idx + 2], 3);
+
+  A (&a[0][++j], 4);
+  A (&a[0][++j], 3);
+  A (&a[0][++j], 2);
+
+  if (j != 3)
+    ++nfails;
+}
+
+
+char va[][4] = {
+  { '1', '2', '3', '4' }, { '5' },
+  { '1', '2', '3', '4' }, { '5', '6' },
+  { '1', '2', '3', '4' }, { '5', '6', '7' },
+  { '1', '2', '3', '4' }, { '5', '6', '7', '8' },
+  { '9' }
+};
+
+static void test_nonconst_global_arrays (void)
+{
+  {
+    A (va[0], 5);
+    A (&va[0][0], 5);
+    A (&va[0][1], 4);
+    A (&va[0][3], 2);
+
+    int i = 0;
+    A (va[i], 5);
+    A (&va[i][0], 5);
+    A (&va[i][1], 4);
+    A (&va[i][3], 2);
+
+    int j = i;
+    A (&va[i][i], 5);
+    A (&va[i][j + 1], 4);
+    A (&va[i][j + 2], 3);
+
+    A (&va[idx][i], 5);
+    A (&va[idx][j + 1], 4);
+    A (&va[idx][j + 2], 3);
+
+    A (&va[idx][idx], 5);
+    A (&va[idx][idx + 1], 4);
+    A (&va[idx][idx + 2], 3);
+  }
+
+  {
+    A (va[2], 6);
+    A (&va[2][0], 6);
+    A (&va[2][1], 5);
+    A (&va[2][3], 3);
+
+    int i = 2;
+    A (va[i], 6);
+    A (&va[i][0], 6);
+    A (&va[i][1], 5);
+    A (&va[i][3], 3);
+
+    int j = i - 1;
+    A (&va[i][j - 1], 6);
+    A (&va[i][j], 5);
+    A (&va[i][j + 1], 4);
+
+    A (&va[idx + 2][i - 1], 5);
+    A (&va[idx + 2][j], 5);
+    A (&va[idx + 2][j + 1], 4);
+  }
+
+  int j = 0;
+
+  A (&va[0][++j], 4);
+  A (&va[0][++j], 3);
+  A (&va[0][++j], 2);
+
+  if (j != 3)
+    ++nfails;
+}
+
+
+static void test_nonconst_local_arrays (void)
+{
+  char a[][4] = {
+    { '1', '2', '3', '4' }, { '5' },
+    { '1', '2', '3', '4' }, { '5', '6' },
+    { '1', '2', '3', '4' }, { '5', '6', '7' },
+    { '1', '2', '3', '4' }, { '5', '6', '7', '8' },
+    { '9' }
+  };
+
+  A (a[0], 5);
+  A (&a[0][0], 5);
+  A (&a[0][1], 4);
+  A (&a[0][3], 2);
+
+  int i = 0;
+  A (a[i], 5);
+  A (&a[i][0], 5);
+  A (&a[i][1], 4);
+  A (&a[i][3], 2);
+
+  int j = i;
+  A (&a[i][i], 5);
+  A (&a[i][j + 1], 4);
+  A (&a[i][j + 2], 3);
+
+  A (&a[idx][i], 5);
+  A (&a[idx][j + 1], 4);
+  A (&a[idx][j + 2], 3);
+
+  A (&a[idx][idx], 5);
+  A (&a[idx][idx + 1], 4);
+  A (&a[idx][idx + 2], 3);
+
+  A (&a[0][++j], 4);
+  A (&a[0][++j], 3);
+  A (&a[0][++j], 2);
+
+  if (j != 3)
+    ++nfails;
+}
+
+
+struct MemArrays { char a[4], b[4]; };
+
+const struct MemArrays cma[] = {
+  { { '1', '2', '3', '4' }, { '5' } },
+  { { '1', '2', '3', '4' }, { '5', '6' } },
+  { { '1', '2', '3', '4' }, { '5', '6' } },
+  { { '1', '2', '3', '4' }, { '5', '6', '7' } },
+  { { '1', '2', '3', '4' }, { '5', '6', '7', '8' } },
+  { { '9' }, { '\0' } }
+};
+
+static void test_const_global_member_arrays (void)
+{
+  {
+    A (cma[0].a, 5);
+    A (&cma[0].a[0], 5);
+    A (&cma[0].a[1], 4);
+    A (&cma[0].a[2], 3);
+
+    int i = 0;
+    A (cma[i].a, 5);
+    A (&cma[i].a[0], 5);
+    A (&cma[i].a[1], 4);
+    A (&cma[i].a[2], 3);
+
+    int j = i;
+    A (&cma[i].a[j], 5);
+    A (&cma[i].a[j + 1], 4);
+    A (&cma[i].a[j + 2], 3);
+
+    A (&cma[idx].a[i], 5);
+    A (&cma[idx].a[j + 1], 4);
+    A (&cma[idx].a[j + 2], 3);
+
+    A (&cma[idx].a[idx], 5);
+    A (&cma[idx].a[idx + 1], 4);
+    A (&cma[idx].a[idx + 2], 3);
+  }
+
+  {
+    A (cma[1].a, 6);
+    A (&cma[1].a[0], 6);
+    A (&cma[1].a[1], 5);
+    A (&cma[1].a[2], 4);
+
+    int i = 1;
+    A (cma[i].a, 6);
+    A (&cma[i].a[0], 6);
+    A (&cma[i].a[1], 5);
+    A (&cma[i].a[2], 4);
+
+    int j = i - 1;
+    A (&cma[i].a[j], 6);
+    A (&cma[i].a[j + 1], 5);
+    A (&cma[i].a[j + 2], 4);
+
+    A (&cma[idx + 1].a[j], 6);
+    A (&cma[idx + 1].a[j + 1], 5);
+    A (&cma[idx + 1].a[j + 2], 4);
+
+    A (&cma[idx + 1].a[idx], 6);
+    A (&cma[idx + 1].a[idx + 1], 5);
+    A (&cma[idx + 1].a[idx + 2], 4);
+  }
+
+  {
+    A (cma[4].a, 9);
+    A (&cma[4].a[0], 9);
+    A (&cma[4].a[1], 8);
+    A (&cma[4].b[0], 5);
+
+    int i = 4;
+    A (cma[i].a, 9);
+    A (&cma[i].a[0], 9);
+    A (&cma[i].a[1], 8);
+    A (&cma[i].b[0], 5);
+
+    int j = i - 1;
+    A (&cma[i].a[j], 6);
+    A (&cma[i].a[j + 1], 5);
+    A (&cma[i].b[j - 2], 4);
+
+    A (&cma[idx + 4].a[j], 6);
+    A (&cma[idx + 4].a[j + 1], 5);
+    A (&cma[idx + 4].b[j - 2], 4);
+
+    A (&cma[idx + 4].a[idx], 9);
+    A (&cma[idx + 4].a[idx + 1], 8);
+    A (&cma[idx + 4].b[idx + 1], 4);
+  }
+}
+
+
+static void test_const_local_member_arrays (void)
+{
+  const struct MemArrays ma[] = {
+    { { '1', '2', '3', '4' }, { '5' } },
+    { { '1', '2', '3', '4' }, { '5', '6' } },
+    { { '1', '2', '3', '4' }, { '5', '6' } },
+    { { '1', '2', '3', '4' }, { '5', '6', '7' } },
+    { { '1', '2', '3', '4' }, { '5', '6', '7', '8' } },
+    { { '9' }, { '\0' } }
+  };
+
+  {
+    A (ma[0].a, 5);
+    A (&ma[0].a[0], 5);
+    A (&ma[0].a[1], 4);
+    A (&ma[0].a[2], 3);
+
+    int i = 0;
+    A (ma[i].a, 5);
+    A (&ma[i].a[0], 5);
+    A (&ma[i].a[1], 4);
+    A (&ma[i].a[2], 3);
+
+    int j = i;
+    A (&ma[i].a[j], 5);
+    A (&ma[i].a[j + 1], 4);
+    A (&ma[i].a[j + 2], 3);
+
+    A (&ma[idx].a[i], 5);
+    A (&ma[idx].a[j + 1], 4);
+    A (&ma[idx].a[j + 2], 3);
+
+    A (&ma[idx].a[idx], 5);
+    A (&ma[idx].a[idx + 1], 4);
+    A (&ma[idx].a[idx + 2], 3);
+  }
+
+  {
+    A (ma[1].a, 6);
+    A (&ma[1].a[0], 6);
+    A (&ma[1].a[1], 5);
+    A (&ma[1].a[2], 4);
+
+    int i = 1;
+    A (ma[i].a, 6);
+    A (&ma[i].a[0], 6);
+    A (&ma[i].a[1], 5);
+    A (&ma[i].a[2], 4);
+
+    int j = i - 1;
+    A (&ma[i].a[j], 6);
+    A (&ma[i].a[j + 1], 5);
+    A (&ma[i].a[j + 2], 4);
+
+    A (&ma[idx + 1].a[j], 6);
+    A (&ma[idx + 1].a[j + 1], 5);
+    A (&ma[idx + 1].a[j + 2], 4);
+
+    A (&ma[idx + 1].a[idx], 6);
+    A (&ma[idx + 1].a[idx + 1], 5);
+    A (&ma[idx + 1].a[idx + 2], 4);
+  }
+
+  {
+    A (ma[4].a, 9);
+    A (&ma[4].a[0], 9);
+    A (&ma[4].a[1], 8);
+    A (&ma[4].b[0], 5);
+
+    int i = 4;
+    A (ma[i].a, 9);
+    A (&ma[i].a[0], 9);
+    A (&ma[i].a[1], 8);
+    A (&ma[i].b[0], 5);
+
+    int j = i - 1;
+    A (&ma[i].a[j], 6);
+    A (&ma[i].a[j + 1], 5);
+    A (&ma[i].b[j - 2], 4);
+
+    A (&ma[idx + 4].a[j], 6);
+    A (&ma[idx + 4].a[j + 1], 5);
+    A (&ma[idx + 4].b[j - 2], 4);
+
+    A (&ma[idx + 4].a[idx], 9);
+    A (&ma[idx + 4].a[idx + 1], 8);
+    A (&ma[idx + 4].b[idx + 1], 4);
+  }
+}
+
+struct MemArrays vma[] = {
+  { { '1', '2', '3', '4' }, { '5' } },
+  { { '1', '2', '3', '4' }, { '5', '6' } },
+  { { '1', '2', '3', '4' }, { '5', '6' } },
+  { { '1', '2', '3', '4' }, { '5', '6', '7' } },
+  { { '1', '2', '3', '4' }, { '5', '6', '7', '8' } },
+  { { '9' }, { '\0' } }
+};
+
+static void test_nonconst_global_member_arrays (void)
+{
+  {
+    A (vma[0].a, 5);
+    A (&vma[0].a[0], 5);
+    A (&vma[0].a[1], 4);
+    A (&vma[0].a[2], 3);
+
+    int i = 0;
+    A (vma[i].a, 5);
+    A (&vma[i].a[0], 5);
+    A (&vma[i].a[1], 4);
+    A (&vma[i].a[2], 3);
+
+    int j = i;
+    A (&vma[i].a[j], 5);
+    A (&vma[i].a[j + 1], 4);
+    A (&vma[i].a[j + 2], 3);
+
+    A (&vma[idx].a[i], 5);
+    A (&vma[idx].a[j + 1], 4);
+    A (&vma[idx].a[j + 2], 3);
+
+    A (&vma[idx].a[idx], 5);
+    A (&vma[idx].a[idx + 1], 4);
+    A (&vma[idx].a[idx + 2], 3);
+  }
+
+  {
+    A (vma[1].a, 6);
+    A (&vma[1].a[0], 6);
+    A (&vma[1].a[1], 5);
+    A (&vma[1].a[2], 4);
+
+    int i = 1;
+    A (vma[i].a, 6);
+    A (&vma[i].a[0], 6);
+    A (&vma[i].a[1], 5);
+    A (&vma[i].a[2], 4);
+
+    int j = i - 1;
+    A (&vma[i].a[j], 6);
+    A (&vma[i].a[j + 1], 5);
+    A (&vma[i].a[j + 2], 4);
+
+    A (&vma[idx + 1].a[j], 6);
+    A (&vma[idx + 1].a[j + 1], 5);
+    A (&vma[idx + 1].a[j + 2], 4);
+
+    A (&vma[idx + 1].a[idx], 6);
+    A (&vma[idx + 1].a[idx + 1], 5);
+    A (&vma[idx + 1].a[idx + 2], 4);
+  }
+
+  {
+    A (vma[4].a, 9);
+    A (&vma[4].a[0], 9);
+    A (&vma[4].a[1], 8);
+    A (&vma[4].b[0], 5);
+
+    int i = 4;
+    A (vma[i].a, 9);
+    A (&vma[i].a[0], 9);
+    A (&vma[i].a[1], 8);
+    A (&vma[i].b[0], 5);
+
+    int j = i - 1;
+    A (&vma[i].a[j], 6);
+    A (&vma[i].a[j + 1], 5);
+    A (&vma[i].b[j - 2], 4);
+
+    A (&vma[idx + 4].a[j], 6);
+    A (&vma[idx + 4].a[j + 1], 5);
+    A (&vma[idx + 4].b[j - 2], 4);
+
+    A (&vma[idx + 4].a[idx], 9);
+    A (&vma[idx + 4].a[idx + 1], 8);
+    A (&vma[idx + 4].b[idx + 1], 4);
+  }
+}
+
+
+static void test_nonconst_local_member_arrays (void)
+{
+  struct MemArrays ma[] = {
+    { { '1', '2', '3', '4' }, { '5' } },
+    { { '1', '2', '3', '4' }, { '5', '6' } },
+    { { '1', '2', '3', '4' }, { '5', '6' } },
+    { { '1', '2', '3', '4' }, { '5', '6', '7' } },
+    { { '1', '2', '3', '4' }, { '5', '6', '7', '8' } },
+    { { '9' }, { '\0' } }
+  };
+
+  {
+    A (ma[0].a, 5);
+    A (&ma[0].a[0], 5);
+    A (&ma[0].a[1], 4);
+    A (&ma[0].a[2], 3);
+
+    int i = 0;
+    A (ma[i].a, 5);
+    A (&ma[i].a[0], 5);
+    A (&ma[i].a[1], 4);
+    A (&ma[i].a[2], 3);
+
+    int j = i;
+    A (&ma[i].a[j], 5);
+    A (&ma[i].a[j + 1], 4);
+    A (&ma[i].a[j + 2], 3);
+
+    A (&ma[idx].a[i], 5);
+    A (&ma[idx].a[j + 1], 4);
+    A (&ma[idx].a[j + 2], 3);
+
+    A (&ma[idx].a[idx], 5);
+    A (&ma[idx].a[idx + 1], 4);
+    A (&ma[idx].a[idx + 2], 3);
+  }
+
+  {
+    A (ma[1].a, 6);
+    A (&ma[1].a[0], 6);
+    A (&ma[1].a[1], 5);
+    A (&ma[1].a[2], 4);
+
+    int i = 1;
+    A (ma[i].a, 6);
+    A (&ma[i].a[0], 6);
+    A (&ma[i].a[1], 5);
+    A (&ma[i].a[2], 4);
+
+    int j = i - 1;
+    A (&ma[i].a[j], 6);
+    A (&ma[i].a[j + 1], 5);
+    A (&ma[i].a[j + 2], 4);
+
+    A (&ma[idx + 1].a[j], 6);
+    A (&ma[idx + 1].a[j + 1], 5);
+    A (&ma[idx + 1].a[j + 2], 4);
+
+    A (&ma[idx + 1].a[idx], 6);
+    A (&ma[idx + 1].a[idx + 1], 5);
+    A (&ma[idx + 1].a[idx + 2], 4);
+  }
+
+  {
+    A (ma[4].a, 9);
+    A (&ma[4].a[0], 9);
+    A (&ma[4].a[1], 8);
+    A (&ma[4].b[0], 5);
+
+    int i = 4;
+    A (ma[i].a, 9);
+    A (&ma[i].a[0], 9);
+    A (&ma[i].a[1], 8);
+    A (&ma[i].b[0], 5);
+
+    int j = i - 1;
+    A (&ma[i].a[j], 6);
+    A (&ma[i].a[j + 1], 5);
+    A (&ma[i].b[j - 2], 4);
+
+    A (&ma[idx + 4].a[j], 6);
+    A (&ma[idx + 4].a[j + 1], 5);
+    A (&ma[idx + 4].b[j - 2], 4);
+
+    A (&ma[idx + 4].a[idx], 9);
+    A (&ma[idx + 4].a[idx + 1], 8);
+    A (&ma[idx + 4].b[idx + 1], 4);
+  }
+}
+
+
+union UnionMemberArrays
+{
+  struct { char a[4], b[4]; } a;
+  struct { char a[8]; } c;
+};
+
+const union UnionMemberArrays cu = {
+  { { '1', '2', '3', '4' }, { '5', } }
+};
+
+static void test_const_union_member_arrays (void)
+{
+  A (cu.a.a, 5);
+  A (cu.a.b, 1);
+  A (cu.c.a, 5);
+
+  const union UnionMemberArrays clu = {
+    { { '1', '2', '3', '4' }, { '5', '6' } }
+  };
+
+  A (clu.a.a, 6);
+  A (clu.a.b, 2);
+  A (clu.c.a, 6);
+}
+
+
+union UnionMemberArrays vu = {
+  { { '1', '2', '3', '4' }, { '5', '6' } }
+};
+
+static void test_nonconst_union_member_arrays (void)
+{
+  A (vu.a.a, 6);
+  A (vu.a.b, 2);
+  A (vu.c.a, 6);
+
+  union UnionMemberArrays lvu = {
+    { { '1', '2', '3', '4' }, { '5', '6', '7' } }
+  };
+
+  A (lvu.a.a, 7);
+  A (lvu.a.b, 3);
+  A (lvu.c.a, 7);
+}
+
+
+int main (void)
+{
+  test_const_global_arrays ();
+  test_const_local_arrays ();
+
+  test_nonconst_global_arrays ();
+  test_nonconst_local_arrays ();
+
+  test_const_global_member_arrays ();
+  test_const_local_member_arrays ();
+
+  test_nonconst_global_member_arrays ();
+  test_nonconst_local_member_arrays ();
+
+  test_const_union_member_arrays ();
+  test_nonconst_union_member_arrays ();
+
+  if (nfails)
+    __builtin_abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00631-g.torture.execute-strlen-5/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00631-g.torture.execute-strlen-5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..db6fbbb523b97021b16bde557c547d5d41e6c87d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00631-g.torture.execute-strlen-5/test.cfg
@@ -0,0 +1,2 @@
+compile(strlen-5)
+run(strlen-5)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00632-g.torture.execute-strlen-7/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00632-g.torture.execute-strlen-7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00632-g.torture.execute-strlen-7/strlen-7.c b/testsuite/c_test/x64_be_enable_test/GCC00632-g.torture.execute-strlen-7/strlen-7.c
new file mode 100644
index 0000000000000000000000000000000000000000..cf2c7dbabcfc0a6981010177f166c2f9dce44cbf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00632-g.torture.execute-strlen-7/strlen-7.c
@@ -0,0 +1,37 @@
+/* Test to verify that a strlen() call with a pointer to a dynamic type
+   doesn't make assumptions based on the static type of the original
+   pointer.  See g++.dg/init/strlen.C for the corresponding C++ test.  */
+
+struct A { int i; char a[1]; void (*p)(); };
+struct B { char a[sizeof (struct A) - __builtin_offsetof (struct A, a)]; };
+
+__attribute__ ((noipa)) void
+init (char *d, const char *s)
+{
+  __builtin_strcpy (d, s);
+}
+
+struct B b;
+
+__attribute__ ((noipa)) void
+test_dynamic_type (struct A *p)
+{
+  /* The following call is undefined because it writes past the end
+     of the p->a subobject, but the corresponding GIMPLE considers
+     it valid and there's apparently no way to distinguish invalid
+     cases from ones like it that might be valid.  If/when GIMPLE
+     changes to make this possible this test can be removed.  */
+  char *q = (char*)__builtin_memcpy (p->a, &b, sizeof b);
+
+  init (q, "foobar");
+
+  if (6 != __builtin_strlen (q))
+    __builtin_abort();
+}
+
+int main (void)
+{
+  struct A *p = (struct A*)malloc (sizeof *p);
+  test_dynamic_type (p);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00632-g.torture.execute-strlen-7/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00632-g.torture.execute-strlen-7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d805e649bc40c4976940c10bc5c9a22784328eb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00632-g.torture.execute-strlen-7/test.cfg
@@ -0,0 +1,2 @@
+compile(strlen-7)
+run(strlen-7)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00633-g.torture.execute-strncmp-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00633-g.torture.execute-strncmp-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00633-g.torture.execute-strncmp-1/strncmp-1.c b/testsuite/c_test/x64_be_enable_test/GCC00633-g.torture.execute-strncmp-1/strncmp-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c2448591d96c57c71768025d5d629a8e2b35707a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00633-g.torture.execute-strncmp-1/strncmp-1.c
@@ -0,0 +1,141 @@
+/* { dg-xfail-if "kernel strncmp does not perform unsigned comparisons" { vxworks_kernel } } */
+/* Copyright (C) 2002  Free Software Foundation.
+
+   Test strncmp with various combinations of pointer alignments and lengths to
+   make sure any optimizations in the library are correct.
+
+   Written by Michael Meissner, March 9, 2002.  */
+
+#include <string.h>
+#include <stddef.h>
+
+#ifndef MAX_OFFSET
+#define MAX_OFFSET (sizeof (long long))
+#endif
+
+#ifndef MAX_TEST
+#define MAX_TEST (8 * sizeof (long long))
+#endif
+
+#ifndef MAX_EXTRA
+#define MAX_EXTRA (sizeof (long long))
+#endif
+
+#define MAX_LENGTH (MAX_OFFSET + MAX_TEST + MAX_EXTRA)
+
+static union {
+  unsigned char buf[MAX_LENGTH];
+  long long align_int;
+  long double align_fp;
+} u1, u2;
+
+void
+test (const unsigned char *s1, const unsigned char *s2, size_t len, int expected)
+{
+  int value = strncmp ((char *) s1, (char *) s2, len);
+
+  if (expected < 0 && value >= 0)
+    abort ();
+  else if (expected == 0 && value != 0)
+    abort ();
+  else if (expected > 0 && value <= 0)
+    abort ();
+}
+
+main ()
+{
+  size_t off1, off2, len, i;
+  unsigned char *buf1, *buf2;
+  unsigned char *mod1, *mod2;
+  unsigned char *p1, *p2;
+
+  for (off1 = 0; off1 < MAX_OFFSET; off1++)
+    for (off2 = 0; off2 < MAX_OFFSET; off2++)
+      for (len = 0; len < MAX_TEST; len++)
+	{
+	  p1 = u1.buf;
+	  for (i = 0; i < off1; i++)
+	    *p1++ = '\0';
+
+	  buf1 = p1;
+	  for (i = 0; i < len; i++)
+	    *p1++ = 'a';
+
+	  mod1 = p1;
+	  for (i = 0; i < MAX_EXTRA; i++)
+	    *p1++ = 'x';
+
+	  p2 = u2.buf;
+	  for (i = 0; i < off2; i++)
+	    *p2++ = '\0';
+
+	  buf2 = p2;
+	  for (i = 0; i < len; i++)
+	    *p2++ = 'a';
+
+	  mod2 = p2;
+	  for (i = 0; i < MAX_EXTRA; i++)
+	    *p2++ = 'x';
+
+	  mod1[0] = '\0';
+	  mod2[0] = '\0';
+	  test (buf1, buf2, MAX_LENGTH, 0);
+	  test (buf1, buf2, len, 0);
+
+	  mod1[0] = 'a';
+	  mod1[1] = '\0';
+	  mod2[0] = '\0';
+	  test (buf1, buf2, MAX_LENGTH, +1);
+	  test (buf1, buf2, len, 0);
+
+	  mod1[0] = '\0';
+	  mod2[0] = 'a';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, MAX_LENGTH, -1);
+	  test (buf1, buf2, len, 0);
+
+	  mod1[0] = 'b';
+	  mod1[1] = '\0';
+	  mod2[0] = 'c';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, MAX_LENGTH, -1);
+	  test (buf1, buf2, len, 0);
+
+	  mod1[0] = 'c';
+	  mod1[1] = '\0';
+	  mod2[0] = 'b';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, MAX_LENGTH, +1);
+	  test (buf1, buf2, len, 0);
+
+	  mod1[0] = 'b';
+	  mod1[1] = '\0';
+	  mod2[0] = (unsigned char)'\251';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, MAX_LENGTH, -1);
+	  test (buf1, buf2, len, 0);
+
+	  mod1[0] = (unsigned char)'\251';
+	  mod1[1] = '\0';
+	  mod2[0] = 'b';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, MAX_LENGTH, +1);
+	  test (buf1, buf2, len, 0);
+
+	  mod1[0] = (unsigned char)'\251';
+	  mod1[1] = '\0';
+	  mod2[0] = (unsigned char)'\252';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, MAX_LENGTH, -1);
+	  test (buf1, buf2, len, 0);
+
+	  mod1[0] = (unsigned char)'\252';
+	  mod1[1] = '\0';
+	  mod2[0] = (unsigned char)'\251';
+	  mod2[1] = '\0';
+	  test (buf1, buf2, MAX_LENGTH, +1);
+	  test (buf1, buf2, len, 0);
+	}
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00633-g.torture.execute-strncmp-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00633-g.torture.execute-strncmp-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..33a9bbf1e74c59e4cc376344eb6f126201b024f8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00633-g.torture.execute-strncmp-1/test.cfg
@@ -0,0 +1,2 @@
+compile(strncmp-1)
+run(strncmp-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00634-g.torture.execute-struct-cpy-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00634-g.torture.execute-struct-cpy-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00634-g.torture.execute-struct-cpy-1/struct-cpy-1.c b/testsuite/c_test/x64_be_enable_test/GCC00634-g.torture.execute-struct-cpy-1/struct-cpy-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..52886feee0f98d062dd8659912288804a5768967
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00634-g.torture.execute-struct-cpy-1/struct-cpy-1.c
@@ -0,0 +1,43 @@
+/* powerpc64-linux gcc miscompiled this due to rs6000.c:expand_block_move
+   not setting mem aliasing info correctly for the code implementing the
+   structure assignment.  */
+
+struct termios
+{
+  unsigned int a;
+  unsigned int b;
+  unsigned int c;
+  unsigned int d;
+  unsigned char pad[28];
+};
+
+struct tty_driver
+{
+  unsigned char pad1[38];
+  struct termios t __attribute__ ((aligned (8)));
+};
+
+static struct termios zero_t;
+static struct tty_driver pty;
+
+void ini (void)
+{
+  pty.t = zero_t;
+  pty.t.a = 1;
+  pty.t.b = 2;
+  pty.t.c = 3;
+  pty.t.d = 4;
+}
+
+int main (void)
+{
+  extern void abort (void);
+
+  ini ();
+  if (pty.t.a != 1
+      || pty.t.b != 2
+      || pty.t.c != 3
+      || pty.t.d != 4)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00634-g.torture.execute-struct-cpy-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00634-g.torture.execute-struct-cpy-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e2e797a7af367761c946cf76401c9b5e467575c3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00634-g.torture.execute-struct-cpy-1/test.cfg
@@ -0,0 +1,2 @@
+compile(struct-cpy-1)
+run(struct-cpy-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00635-g.torture.execute-struct-ini-4/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00635-g.torture.execute-struct-ini-4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00635-g.torture.execute-struct-ini-4/struct-ini-4.c b/testsuite/c_test/x64_be_enable_test/GCC00635-g.torture.execute-struct-ini-4/struct-ini-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..3342439e54d26d456828d65e6045075a7860f553
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00635-g.torture.execute-struct-ini-4/struct-ini-4.c
@@ -0,0 +1,15 @@
+struct s {
+  int a[3];
+  int c[3];
+};
+
+struct s s = {
+  c: {1, 2, 3}
+};
+
+main()
+{
+  if (s.c[0] != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00635-g.torture.execute-struct-ini-4/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00635-g.torture.execute-struct-ini-4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b4348148e4c16f40b9787748970af0e95a21680
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00635-g.torture.execute-struct-ini-4/test.cfg
@@ -0,0 +1,2 @@
+compile(struct-ini-4)
+run(struct-ini-4)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00636-g.torture.execute-tstdi-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00636-g.torture.execute-tstdi-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00636-g.torture.execute-tstdi-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00636-g.torture.execute-tstdi-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e76498cc54eeec38a726bdf8456a373955e9006e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00636-g.torture.execute-tstdi-1/test.cfg
@@ -0,0 +1,2 @@
+compile(tstdi-1)
+run(tstdi-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00636-g.torture.execute-tstdi-1/tstdi-1.c b/testsuite/c_test/x64_be_enable_test/GCC00636-g.torture.execute-tstdi-1/tstdi-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3e31fdf59343fd78d0e7aed52f747b540d079bae
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00636-g.torture.execute-tstdi-1/tstdi-1.c
@@ -0,0 +1,139 @@
+#define FALSE 140
+#define TRUE 13
+
+feq (x)
+     long long int x;
+{
+  if (x == 0)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+fne (x)
+     long long int x;
+{
+  if (x != 0)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+flt (x)
+     long long int x;
+{
+  if (x < 0)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+fge (x)
+     long long int x;
+{
+  if (x >= 0)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+fgt (x)
+     long long int x;
+{
+  if (x > 0)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+fle (x)
+     long long int x;
+{
+  if (x <= 0)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+main ()
+{
+  if (feq (0LL) != TRUE)
+    abort ();
+  if (feq (-1LL) != FALSE)
+    abort ();
+  if (feq (0x8000000000000000LL) != FALSE)
+    abort ();
+  if (feq (0x8000000000000001LL) != FALSE)
+    abort ();
+  if (feq (1LL) != FALSE)
+    abort ();
+  if (feq (0x7fffffffffffffffLL) != FALSE)
+    abort ();
+
+  if (fne (0LL) != FALSE)
+    abort ();
+  if (fne (-1LL) != TRUE)
+    abort ();
+  if (fne (0x8000000000000000LL) != TRUE)
+    abort ();
+  if (fne (0x8000000000000001LL) != TRUE)
+    abort ();
+  if (fne (1LL) != TRUE)
+    abort ();
+  if (fne (0x7fffffffffffffffLL) != TRUE)
+    abort ();
+
+  if (flt (0LL) != FALSE)
+    abort ();
+  if (flt (-1LL) != TRUE)
+    abort ();
+  if (flt (0x8000000000000000LL) != TRUE)
+    abort ();
+  if (flt (0x8000000000000001LL) != TRUE)
+    abort ();
+  if (flt (1LL) != FALSE)
+    abort ();
+  if (flt (0x7fffffffffffffffLL) != FALSE)
+    abort ();
+
+  if (fge (0LL) != TRUE)
+    abort ();
+  if (fge (-1LL) != FALSE)
+    abort ();
+  if (fge (0x8000000000000000LL) != FALSE)
+    abort ();
+  if (fge (0x8000000000000001LL) != FALSE)
+    abort ();
+  if (fge (1LL) != TRUE)
+    abort ();
+  if (fge (0x7fffffffffffffffLL) != TRUE)
+    abort ();
+
+  if (fgt (0LL) != FALSE)
+    abort ();
+  if (fgt (-1LL) != FALSE)
+    abort ();
+  if (fgt (0x8000000000000000LL) != FALSE)
+    abort ();
+  if (fgt (0x8000000000000001LL) != FALSE)
+    abort ();
+  if (fgt (1LL) != TRUE)
+    abort ();
+  if (fgt (0x7fffffffffffffffLL) != TRUE)
+    abort ();
+
+  if (fle (0LL) != TRUE)
+    abort ();
+  if (fle (-1LL) != TRUE)
+    abort ();
+  if (fle (0x8000000000000000LL) != TRUE)
+    abort ();
+  if (fle (0x8000000000000001LL) != TRUE)
+    abort ();
+  if (fle (1LL) != FALSE)
+    abort ();
+  if (fle (0x7fffffffffffffffLL) != FALSE)
+    abort ();
+
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00637-g.torture.execute-unroll-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00637-g.torture.execute-unroll-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00637-g.torture.execute-unroll-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00637-g.torture.execute-unroll-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b780c8b5d2adbcd6b34e0b7360c028fb673d0eef
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00637-g.torture.execute-unroll-1/test.cfg
@@ -0,0 +1,2 @@
+compile(unroll-1)
+run(unroll-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00637-g.torture.execute-unroll-1/unroll-1.c b/testsuite/c_test/x64_be_enable_test/GCC00637-g.torture.execute-unroll-1/unroll-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5606978539fed272ed9d2d67918e06b56f0052c8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00637-g.torture.execute-unroll-1/unroll-1.c
@@ -0,0 +1,24 @@
+/* { dg-options "-fgnu89-inline" } */
+
+extern void abort (void);
+extern void exit (int);
+
+inline int
+f (int x)
+{
+  return (x + 1);
+}
+ 
+int
+main (void)
+{
+  int a = 0 ;
+ 
+  while ( (f(f(f(f(f(f(f(f(f(f(1))))))))))) + a < 12 )
+    {
+      a++;
+      exit (0);
+    }
+  if (a != 1)
+    abort();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00638-g.torture.execute-vrp-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00638-g.torture.execute-vrp-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00638-g.torture.execute-vrp-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00638-g.torture.execute-vrp-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..336f073e0884c5aa27beaa836a2941912cccbc9b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00638-g.torture.execute-vrp-1/test.cfg
@@ -0,0 +1,2 @@
+compile(vrp-1)
+run(vrp-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00638-g.torture.execute-vrp-1/vrp-1.c b/testsuite/c_test/x64_be_enable_test/GCC00638-g.torture.execute-vrp-1/vrp-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ac42e6c37dc48c2cfd1c9c415f5dda3c4a39ce99
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00638-g.torture.execute-vrp-1/vrp-1.c
@@ -0,0 +1,20 @@
+
+extern void abort ();
+extern void exit (int);
+
+int f (int a) {
+	if (a != 2) {
+		a = -a;
+		if (a == 2)
+		  return 0;
+		return 1;
+	}
+	return 1;
+}
+
+int main (int argc, char *argv[]) {
+	if (f (-2))
+		abort ();
+	exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00639-g.torture.execute-vrp-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00639-g.torture.execute-vrp-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00639-g.torture.execute-vrp-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00639-g.torture.execute-vrp-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a0f63b548f0648b1c1bba184ddeecdf9ab03ad19
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00639-g.torture.execute-vrp-2/test.cfg
@@ -0,0 +1,2 @@
+compile(vrp-2)
+run(vrp-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00639-g.torture.execute-vrp-2/vrp-2.c b/testsuite/c_test/x64_be_enable_test/GCC00639-g.torture.execute-vrp-2/vrp-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..69ed3e702810fd350167b962682f56c4f7add154
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00639-g.torture.execute-vrp-2/vrp-2.c
@@ -0,0 +1,19 @@
+extern void abort ();
+extern void exit (int);
+
+int f (int a) {
+	if (a != 2) {
+		a = a > 0 ? a : -a;
+		if (a == 2)
+		  return 0;
+		return 1;
+	}
+	return 1;
+}
+
+int main (int argc, char *argv[]) {
+	if (f (-2))
+		abort ();
+	exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00640-g.torture.execute-vrp-3/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00640-g.torture.execute-vrp-3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00640-g.torture.execute-vrp-3/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00640-g.torture.execute-vrp-3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e1a3a739757cabbd6d01a6e252db59735ed86ed0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00640-g.torture.execute-vrp-3/test.cfg
@@ -0,0 +1,2 @@
+compile(vrp-3)
+run(vrp-3)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00640-g.torture.execute-vrp-3/vrp-3.c b/testsuite/c_test/x64_be_enable_test/GCC00640-g.torture.execute-vrp-3/vrp-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..bc0e490dc57f84e2a965bbd2a4e49d85a3c4a72a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00640-g.torture.execute-vrp-3/vrp-3.c
@@ -0,0 +1,21 @@
+extern void abort ();
+extern void exit (int);
+
+int f (int a) {
+	if (a < 12) {
+	  if (a > -15) {
+		a = a > 0 ? a : -a;
+		if (a == 2)
+		  return 0;
+		return 1;
+	  }
+	}
+	return 1;
+}
+
+int main (int argc, char *argv[]) {
+	if (f (-2))
+		abort ();
+	exit (0);
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00641-g.torture.execute-wchar_t-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00641-g.torture.execute-wchar_t-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00641-g.torture.execute-wchar_t-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00641-g.torture.execute-wchar_t-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa6e4166318f6af605a0fa272496500d7f8f0784
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00641-g.torture.execute-wchar_t-1/test.cfg
@@ -0,0 +1,2 @@
+compile(wchar_t-1)
+run(wchar_t-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00641-g.torture.execute-wchar_t-1/wchar_t-1.c b/testsuite/c_test/x64_be_enable_test/GCC00641-g.torture.execute-wchar_t-1/wchar_t-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7e90cc08f5ea5361d42a8f639fd284eb5c5916ea
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00641-g.torture.execute-wchar_t-1/wchar_t-1.c
@@ -0,0 +1,17 @@
+/* { dg-options "-finput-charset=utf-8" } */
+typedef __WCHAR_TYPE__ wchar_t;
+wchar_t x[] = L"Ä";
+wchar_t y = L'Ä';
+extern void abort (void);
+extern void exit (int);
+
+int main (void)
+{
+  if (sizeof (x) / sizeof (wchar_t) != 2)
+    abort ();
+  if (x[0] != L'Ä' || x[1] != L'\0')
+    abort ();
+  if (y != L'Ä')
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00642-g.torture.execute-widechar-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00642-g.torture.execute-widechar-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00642-g.torture.execute-widechar-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00642-g.torture.execute-widechar-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8c3082c2aa7a9479f11f590ab8907fee0343a270
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00642-g.torture.execute-widechar-1/test.cfg
@@ -0,0 +1,2 @@
+compile(widechar-1)
+run(widechar-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00642-g.torture.execute-widechar-1/widechar-1.c b/testsuite/c_test/x64_be_enable_test/GCC00642-g.torture.execute-widechar-1/widechar-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..45b9d89b4b46c0bd9d6bd609de3cbcfd6b74c0f9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00642-g.torture.execute-widechar-1/widechar-1.c
@@ -0,0 +1,14 @@
+#define C L'\400'
+
+#if C
+#define zero (!C)
+#else
+#define zero C
+#endif
+
+main()
+{
+  if (zero != 0)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00643-g.torture.execute-widechar-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00643-g.torture.execute-widechar-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00643-g.torture.execute-widechar-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00643-g.torture.execute-widechar-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6bf6f271e2c110fd73c7a86d41729709ac97839b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00643-g.torture.execute-widechar-2/test.cfg
@@ -0,0 +1,2 @@
+compile(widechar-2)
+run(widechar-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00643-g.torture.execute-widechar-2/widechar-2.c b/testsuite/c_test/x64_be_enable_test/GCC00643-g.torture.execute-widechar-2/widechar-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..9e6a73bcd29d7eafac0cb7109159d690e016ba13
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00643-g.torture.execute-widechar-2/widechar-2.c
@@ -0,0 +1,11 @@
+#include <stddef.h>
+
+const wchar_t ws[] = L"foo";
+
+int
+main (void)
+{
+  if (ws[0] != L'f' || ws[1] != L'o' || ws[2] != L'o' || ws[3] != L'\0')
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00644-g.torture.execute-zerolen-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00644-g.torture.execute-zerolen-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00644-g.torture.execute-zerolen-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00644-g.torture.execute-zerolen-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..845b7237c3704670fd57bad93b5181322bc409e8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00644-g.torture.execute-zerolen-2/test.cfg
@@ -0,0 +1,2 @@
+compile(zerolen-2)
+run(zerolen-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00644-g.torture.execute-zerolen-2/zerolen-2.c b/testsuite/c_test/x64_be_enable_test/GCC00644-g.torture.execute-zerolen-2/zerolen-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..7c933384396ebcb5293429bf558739dd6e6d78cd
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00644-g.torture.execute-zerolen-2/zerolen-2.c
@@ -0,0 +1,19 @@
+/* { dg-skip-if "assumes absence of larger-than-word padding" { epiphany-*-* } } */
+extern void abort(void);
+
+typedef int word __attribute__((mode(word)));
+
+struct foo
+{
+  word x;
+  word y[0];
+};
+
+int main()
+{
+  if (sizeof(word) != sizeof(struct foo))
+    abort();
+  if (__alignof__(word) != __alignof__(struct foo))
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00645-g.torture.execute-zero-struct-1/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00645-g.torture.execute-zero-struct-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00645-g.torture.execute-zero-struct-1/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00645-g.torture.execute-zero-struct-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..12099e6f269659e92063097966964eeb30e16066
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00645-g.torture.execute-zero-struct-1/test.cfg
@@ -0,0 +1,2 @@
+compile(zero-struct-1)
+run(zero-struct-1)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00645-g.torture.execute-zero-struct-1/zero-struct-1.c b/testsuite/c_test/x64_be_enable_test/GCC00645-g.torture.execute-zero-struct-1/zero-struct-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d673adf5c31dcc82feaa44a6d37eacb146c9547f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00645-g.torture.execute-zero-struct-1/zero-struct-1.c
@@ -0,0 +1,23 @@
+struct g{};
+char y[3];
+char *f = &y[0];
+char *ff = &y[0];
+void h(void)
+{
+  struct g t;
+  *((struct g*)(f++)) = *((struct g*)(ff++));
+  *((struct g*)(f++)) = (struct g){};
+  t = *((struct g*)(ff++));
+}
+
+void abort (void);
+
+int main(void)
+{
+  h();
+  if (f != &y[2])
+    abort();
+  if (ff != &y[2])
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00646-g.torture.execute-zero-struct-2/expected.txt b/testsuite/c_test/x64_be_enable_test/GCC00646-g.torture.execute-zero-struct-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00646-g.torture.execute-zero-struct-2/test.cfg b/testsuite/c_test/x64_be_enable_test/GCC00646-g.torture.execute-zero-struct-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ceba4cc8bddeae40e02d005a5da038f323952ad3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00646-g.torture.execute-zero-struct-2/test.cfg
@@ -0,0 +1,2 @@
+compile(zero-struct-2)
+run(zero-struct-2)
diff --git a/testsuite/c_test/x64_be_enable_test/GCC00646-g.torture.execute-zero-struct-2/zero-struct-2.c b/testsuite/c_test/x64_be_enable_test/GCC00646-g.torture.execute-zero-struct-2/zero-struct-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..ed1d5a027b33c639a4ee4eb619dd6f0b404ea43e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/GCC00646-g.torture.execute-zero-struct-2/zero-struct-2.c
@@ -0,0 +1,20 @@
+void abort (void);
+int ii;
+typedef struct {} raw_spinlock_t;
+typedef struct {
+  raw_spinlock_t raw_lock;
+} spinlock_t;
+raw_spinlock_t one_raw_spinlock (void)
+{
+  raw_spinlock_t raw_lock;
+  ii++;
+  return raw_lock;
+}
+int main(void)
+{
+  spinlock_t lock = (spinlock_t) { .raw_lock = one_raw_spinlock() };
+  if (ii != 1)
+    abort ();
+  return 0;
+}
+
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00001-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-2/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00001-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00001-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-2/pr65053-2.c b/testsuite/c_test/x64_be_enable_test/LLVM00001-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-2/pr65053-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a0f4e4636131edd3f8d1683003622dea3cea707
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00001-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-2/pr65053-2.c
@@ -0,0 +1,27 @@
+/* PR tree-optimization/65053 */
+
+int i;
+unsigned int x;
+
+int
+main ()
+{
+  asm volatile ("" : "+g" (x));
+  unsigned int n = x;
+  unsigned int u = 32;
+  if (n >= 32)
+    __builtin_abort ();
+  if (n != 0)
+    u = n + 32;
+
+  while (u != 32)
+    {
+      asm ("" : : "g" (u));
+      u = 32;
+      i = 1;
+    }
+
+  if (i)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00001-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-2/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00001-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8375dc6893500c73227e06abdd56bd57d44e2e1a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00001-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65053-2)
+run(pr65053-2)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00002-Regression-C-gcc-c-torture-execute-GCC-C-execute-stkalign/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00002-Regression-C-gcc-c-torture-execute-GCC-C-execute-stkalign/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00002-Regression-C-gcc-c-torture-execute-GCC-C-execute-stkalign/stkalign.c b/testsuite/c_test/x64_be_enable_test/LLVM00002-Regression-C-gcc-c-torture-execute-GCC-C-execute-stkalign/stkalign.c
new file mode 100644
index 0000000000000000000000000000000000000000..e10a1d2ec24fb4e58552c5b038969c99118c324a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00002-Regression-C-gcc-c-torture-execute-GCC-C-execute-stkalign/stkalign.c
@@ -0,0 +1,44 @@
+/* { dg-options "-fno-inline" } */
+/* Check that stack alignment is not affected by variables not placed
+   on the stack.  */
+
+#include <assert.h>
+
+#define ALIGNMENT 64
+
+unsigned test(unsigned n, unsigned p)
+{
+  static struct { char __attribute__((__aligned__(ALIGNMENT))) c; } s;
+  unsigned x;
+
+  assert(__alignof__(s) == ALIGNMENT);
+  asm ("" : "=g" (x), "+m" (s) : "0" (&x));
+
+  return n ? test(n - 1, x) : (x ^ p);
+}
+
+unsigned test2(unsigned n, unsigned p)
+{
+  static struct { char c; } s;
+  unsigned x;
+
+  assert(__alignof__(s) != ALIGNMENT);
+  asm ("" : "=g" (x), "+m" (s) : "0" (&x));
+
+  return n ? test2(n - 1, x) : (x ^ p);
+}
+
+int main (int argc, char *argv[] __attribute__((unused)))
+{
+  unsigned int x, y;
+
+  x = test(argc, 0);
+  x |= test(argc + 1, 0);
+  x |= test(argc + 2, 0);
+
+  y = test2(argc, 0);
+  y |= test2(argc + 1, 0);
+  y |= test2(argc + 2, 0);
+
+  return (x & (ALIGNMENT - 1)) == 0 && (y & (ALIGNMENT - 1)) != 0 ? 1 : 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00002-Regression-C-gcc-c-torture-execute-GCC-C-execute-stkalign/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00002-Regression-C-gcc-c-torture-execute-GCC-C-execute-stkalign/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7cf8c8a6ebf2d59d07590a4d9adf03e7249989d1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00002-Regression-C-gcc-c-torture-execute-GCC-C-execute-stkalign/test.cfg
@@ -0,0 +1,2 @@
+compile(stkalign)
+run(stkalign)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00003-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071220-1/20071220-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00003-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071220-1/20071220-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e832acc8492f61734aa8d1bb9436b9552180ee11
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00003-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071220-1/20071220-1.c
@@ -0,0 +1,42 @@
+/* PR tree-optimization/29484 */
+/* { dg-require-effective-target label_values } */
+/* { dg-require-effective-target indirect_jumps } */
+
+extern void abort (void);
+
+void *__attribute__((noinline))
+baz (void **lab)
+{
+  asm volatile ("" : "+r" (lab));
+  return *lab;
+}
+
+static inline
+int bar (void)
+{
+  static void *b[] = { &&addr };
+  void *p = baz (b);
+  goto *p;
+addr:
+  return 17;
+}
+
+int __attribute__((noinline))
+f1 (void)
+{
+  return bar ();
+}
+
+int __attribute__((noinline))
+f2 (void)
+{
+  return bar ();
+}
+
+int
+main (void)
+{
+  if (f1 () != 17 || f1 () != 17 || f2 () != 17 || f2 () != 17)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00003-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071220-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00003-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071220-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00003-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071220-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00003-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071220-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..144d6b99465c9a4ff1d510b32aef41a2af82c0c2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00003-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071220-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071220-1)
+run(20071220-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00004-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82388/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00004-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82388/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00004-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82388/pr82388.c b/testsuite/c_test/x64_be_enable_test/LLVM00004-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82388/pr82388.c
new file mode 100644
index 0000000000000000000000000000000000000000..b3f7ce722e6bf964fec64c6d975dea2b162f5737
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00004-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82388/pr82388.c
@@ -0,0 +1,17 @@
+/* PR tree-optimization/82388 */
+
+struct A { int b; int c; int d; } e;
+
+struct A
+foo (void)
+{
+  struct A h[30] = {{0,0,0}};
+  return h[29];
+}
+
+int
+main ()
+{
+  e = foo ();
+  return e.b;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00004-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82388/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00004-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82388/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65d005e5bce71d82a847568d9e7236f276bd842d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00004-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82388/test.cfg
@@ -0,0 +1,2 @@
+compile(pr82388)
+run(pr82388)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00005-Regression-C-Regression-C-2003-05-23-TransparentUnion/2003-05-23-TransparentUnion.c b/testsuite/c_test/x64_be_enable_test/LLVM00005-Regression-C-Regression-C-2003-05-23-TransparentUnion/2003-05-23-TransparentUnion.c
new file mode 100644
index 0000000000000000000000000000000000000000..870826a595aff7b4aab0eedf8447b9da4bb7c318
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00005-Regression-C-Regression-C-2003-05-23-TransparentUnion/2003-05-23-TransparentUnion.c
@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+typedef union {
+  float *__fptr;
+  int *__iptr;
+} UNION __attribute__ ((__transparent_union__));
+
+int try(UNION U) {
+  return 1;
+}
+int test() {
+  int I;
+  float F;
+  return try(&I) | try(&F);
+}
+
+int main() {
+  if (test()) printf("ok");
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00005-Regression-C-Regression-C-2003-05-23-TransparentUnion/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00005-Regression-C-Regression-C-2003-05-23-TransparentUnion/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b5754e20373fdaa5331ef6e4623dbae636225e3b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00005-Regression-C-Regression-C-2003-05-23-TransparentUnion/expected.txt
@@ -0,0 +1 @@
+ok
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00005-Regression-C-Regression-C-2003-05-23-TransparentUnion/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00005-Regression-C-Regression-C-2003-05-23-TransparentUnion/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7e0a1c502fdd43964da448fc98b717c45009b99e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00005-Regression-C-Regression-C-2003-05-23-TransparentUnion/test.cfg
@@ -0,0 +1,2 @@
+compile(2003-05-23-TransparentUnion)
+run(2003-05-23-TransparentUnion)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00006-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr56982/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00006-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr56982/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00006-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr56982/pr56982.c b/testsuite/c_test/x64_be_enable_test/LLVM00006-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr56982/pr56982.c
new file mode 100644
index 0000000000000000000000000000000000000000..0fa9c8ab4ba82ae53cb20321c3bdad5f162ddd08
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00006-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr56982/pr56982.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target indirect_jumps } */
+#include <setjmp.h>
+
+extern void abort (void);
+extern void exit (int);
+
+static jmp_buf env;
+
+void baz (void)
+{
+  __asm__ volatile ("" : : : "memory");
+}
+
+static inline int g(int x)
+{
+    if (x)
+    {
+        baz();
+        return 0;
+    }
+    else
+    {
+        baz();
+        return 1;
+    }
+}
+
+int f(int *e)
+{
+    if (*e)
+      return 1;
+
+    int x = setjmp(env);
+    int n = g(x);
+    if (n == 0)
+      exit(0);
+    if (x)
+      abort();
+    longjmp(env, 42);
+}
+
+int main(int argc, char** argv)
+{
+    int v = 0;
+    return f(&v);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00006-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr56982/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00006-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr56982/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c9b667f0bb7cb9b5b1fcb2031c638695d50edff9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00006-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr56982/test.cfg
@@ -0,0 +1,2 @@
+compile(pr56982)
+run(pr56982)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00007-Regression-C-gcc-c-torture-execute-GCC-C-execute-930126-1/930126-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00007-Regression-C-gcc-c-torture-execute-GCC-C-execute-930126-1/930126-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ff08e7d6131c029cc39ef5361c37d3765149ac6e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00007-Regression-C-gcc-c-torture-execute-GCC-C-execute-930126-1/930126-1.c
@@ -0,0 +1,20 @@
+struct s {
+  unsigned long long a:8, b:32;
+};
+
+struct s
+f(struct s x)
+{
+  x.b = 0xcdef1234;
+  return x;
+}
+
+main()
+{
+  static struct s i;
+  i.a = 12;
+  i = f(i);
+  if (i.a != 12 || i.b != 0xcdef1234)
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00007-Regression-C-gcc-c-torture-execute-GCC-C-execute-930126-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00007-Regression-C-gcc-c-torture-execute-GCC-C-execute-930126-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00007-Regression-C-gcc-c-torture-execute-GCC-C-execute-930126-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00007-Regression-C-gcc-c-torture-execute-GCC-C-execute-930126-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5450aca7f2dbbfbf9bce0ce7bf50199d0635b33e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00007-Regression-C-gcc-c-torture-execute-GCC-C-execute-930126-1/test.cfg
@@ -0,0 +1,2 @@
+compile(930126-1)
+run(930126-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00008-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr34456/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00008-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr34456/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00008-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr34456/pr34456.c b/testsuite/c_test/x64_be_enable_test/LLVM00008-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr34456/pr34456.c
new file mode 100644
index 0000000000000000000000000000000000000000..b4a845ec14b1a4b5c0cd3233cf632d54a5507d80
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00008-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr34456/pr34456.c
@@ -0,0 +1,32 @@
+/* { dg-skip-if "requires qsort" { freestanding } }  */
+
+#include <stdlib.h>
+
+int __attribute__ ((noinline)) debug (void) { return 1; }
+int errors;
+
+struct s { int elt; int (*compare) (int); };
+
+static int
+compare (const void *x, const void *y)
+{
+  const struct s *s1 = x, *s2 = y;
+  int (*compare1) (int);
+  int elt2;
+
+  compare1 = s1->compare;
+  elt2 = s2->elt;
+  if (elt2 != 0 && debug () && compare1 (s1->elt) != 0)
+    errors++;
+  return compare1 (elt2);
+}
+
+int bad_compare (int x) { return -x; }
+struct s array[2] = { { 1, bad_compare }, { -1, bad_compare } };
+
+int
+main (void)
+{
+  qsort (array, 2, sizeof (struct s), compare);
+  return errors == 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00008-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr34456/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00008-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr34456/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9cce059760ab76bf807f164fa9b9076800fa4ad2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00008-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr34456/test.cfg
@@ -0,0 +1,2 @@
+compile(pr34456)
+run(pr34456)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00009-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr43385/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00009-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr43385/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00009-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr43385/pr43385.c b/testsuite/c_test/x64_be_enable_test/LLVM00009-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr43385/pr43385.c
new file mode 100644
index 0000000000000000000000000000000000000000..eeb9096a8e597f6cdd0ee894af98ae13fd3b1822
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00009-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr43385/pr43385.c
@@ -0,0 +1,59 @@
+/* PR c/43385 */
+
+extern void abort (void);
+
+int e;
+
+__attribute__((noinline)) void
+foo (int x, int y)
+{
+  if (__builtin_expect (x, 0) && y != 0)
+    e++;
+}
+
+__attribute__((noinline)) int
+bar (int x, int y)
+{
+  if (__builtin_expect (x, 0) && y != 0)
+    return 1;
+  else
+    return 0;
+}
+
+int
+main (void)
+{
+  int z = 0;
+  asm ("" : "+r" (z));
+  foo (z + 2, z + 1);
+  if (e != 1)
+    abort ();
+  foo (z + 2, z);
+  if (e != 1)
+    abort ();
+  foo (z + 1, z + 1);
+  if (e != 2)
+    abort ();
+  foo (z + 1, z);
+  if (e != 2)
+    abort ();
+  foo (z, z + 1);
+  if (e != 2)
+    abort ();
+  foo (z, z);
+  if (e != 2)
+    abort ();
+  if (bar (z + 2, z + 1) != 1)
+    abort ();
+  if (bar (z + 2, z) != 0)
+    abort ();
+  if (bar (z + 1, z + 1) != 1)
+    abort ();
+  if (bar (z + 1, z) != 0)
+    abort ();
+  if (bar (z, z + 1) != 0)
+    abort ();
+  if (bar (z, z) != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00009-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr43385/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00009-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr43385/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e0fd3877bf89478b4034f208ee68828791a89d1e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00009-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr43385/test.cfg
@@ -0,0 +1,2 @@
+compile(pr43385)
+run(pr43385)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00010-Regression-C-gcc-c-torture-execute-GCC-C-execute-20000917-1/20000917-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00010-Regression-C-gcc-c-torture-execute-GCC-C-execute-20000917-1/20000917-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..05b00ffe699b37066896b96b9470635b2b17dd73
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00010-Regression-C-gcc-c-torture-execute-GCC-C-execute-20000917-1/20000917-1.c
@@ -0,0 +1,42 @@
+/* This bug exists in gcc-2.95, egcs-1.1.2, gcc-2.7.2 and probably
+   every other version as well.  */
+
+typedef struct int3 { int a, b, c; } int3;
+
+int3
+one (void)
+{
+  return (int3) { 1, 1, 1 };
+}
+
+int3
+zero (void)
+{
+  return (int3) { 0, 0, 0 };
+}
+
+int
+main (void)
+{
+  int3 a;
+
+  /* gcc allocates a temporary for the inner expression statement
+     to store the return value of `one'.
+
+     gcc frees the temporaries for the inner expression statement.
+
+     gcc realloates the same temporary slot to store the return
+     value of `zero'.
+
+     gcc expands the call to zero ahead of the expansion of the
+     statement expressions.  The temporary gets the value of `zero'.
+
+     gcc expands statement expressions and the stale temporary is
+     clobbered with the value of `one'.  The bad value is copied from
+     the temporary into *&a.  */
+
+  *({ ({ one (); &a; }); }) = zero ();
+  if (a.a && a.b && a.c)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00010-Regression-C-gcc-c-torture-execute-GCC-C-execute-20000917-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00010-Regression-C-gcc-c-torture-execute-GCC-C-execute-20000917-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00010-Regression-C-gcc-c-torture-execute-GCC-C-execute-20000917-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00010-Regression-C-gcc-c-torture-execute-GCC-C-execute-20000917-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f2c784be10536bb66e41eec443c3ba9307687e3f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00010-Regression-C-gcc-c-torture-execute-GCC-C-execute-20000917-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20000917-1)
+run(20000917-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00011-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40657/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00011-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40657/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00011-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40657/pr40657.c b/testsuite/c_test/x64_be_enable_test/LLVM00011-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40657/pr40657.c
new file mode 100644
index 0000000000000000000000000000000000000000..e6d8dda9f99e8cb8fadaa15cc8a1f769aa03127c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00011-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40657/pr40657.c
@@ -0,0 +1,23 @@
+/* Verify that that Thumb-1 epilogue size optimization does not clobber the
+   return value.  */
+
+long long v = 0x123456789abc;
+
+__attribute__((noinline)) void bar (int *x)
+{
+  asm volatile ("" : "=m" (x) ::);
+}
+
+__attribute__((noinline)) long long foo()
+{
+  int x;
+  bar(&x);
+  return v;
+}
+
+int main ()
+{
+  if (foo () != v)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00011-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40657/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00011-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40657/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50768a0afd93a65e57792ec58f6d94f8d0b778e1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00011-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40657/test.cfg
@@ -0,0 +1,2 @@
+compile(pr40657)
+run(pr40657)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00012-Regression-C-gcc-c-torture-execute-GCC-C-execute-bitfld-4/bitfld-4.c b/testsuite/c_test/x64_be_enable_test/LLVM00012-Regression-C-gcc-c-torture-execute-GCC-C-execute-bitfld-4/bitfld-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..13a5c691dd2185edcda2573bf3191da2cae4c871
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00012-Regression-C-gcc-c-torture-execute-GCC-C-execute-bitfld-4/bitfld-4.c
@@ -0,0 +1,23 @@
+/* When comparisons of bit-fields to unsigned constants got shortened,
+   the shortened signed constant was wrongly marked as overflowing,
+   leading to a later integer_zerop failure and misoptimization.
+
+   Related to bug tree-optimization/16437 but shows the problem on
+   32-bit systems.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-require-effective-target int32plus } */
+
+extern void abort (void);
+
+struct s { int a:12, b:20; };
+
+struct s x = { -123, -456 };
+
+int
+main (void)
+{
+  if (x.a != -123U || x.b != -456U)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00012-Regression-C-gcc-c-torture-execute-GCC-C-execute-bitfld-4/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00012-Regression-C-gcc-c-torture-execute-GCC-C-execute-bitfld-4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00012-Regression-C-gcc-c-torture-execute-GCC-C-execute-bitfld-4/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00012-Regression-C-gcc-c-torture-execute-GCC-C-execute-bitfld-4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..992d264374a853b78d95c160dbf472f24bf01071
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00012-Regression-C-gcc-c-torture-execute-GCC-C-execute-bitfld-4/test.cfg
@@ -0,0 +1,2 @@
+compile(bitfld-4)
+run(bitfld-4)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00013-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030330-1/20030330-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00013-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030330-1/20030330-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..639e47ba7a13366c058e913bda871530ca0d8b12
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00013-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030330-1/20030330-1.c
@@ -0,0 +1,14 @@
+/* PR opt/10011 */
+/* This is link test for builtin_constant_p simplification + DCE.  */
+
+extern void link_error(void);
+static void usb_hub_port_wait_reset(unsigned int delay)
+{
+        int delay_time;
+        for (delay_time = 0; delay_time < 500; delay_time += delay) {
+                if (__builtin_constant_p(delay))
+                        link_error();
+        }
+}
+
+int main() { return 0; }
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00013-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030330-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00013-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030330-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00013-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030330-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00013-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030330-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b6f4b2b730382d6da6477b99c4c731afd48201d3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00013-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030330-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030330-1)
+run(20030330-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00014-Regression-C-gcc-c-torture-execute-GCC-C-execute-lto-tbaa-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00014-Regression-C-gcc-c-torture-execute-GCC-C-execute-lto-tbaa-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00014-Regression-C-gcc-c-torture-execute-GCC-C-execute-lto-tbaa-1/lto-tbaa-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00014-Regression-C-gcc-c-torture-execute-GCC-C-execute-lto-tbaa-1/lto-tbaa-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..fe1e1771c7f9e496d600141aab7ae3883f4a4f1b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00014-Regression-C-gcc-c-torture-execute-GCC-C-execute-lto-tbaa-1/lto-tbaa-1.c
@@ -0,0 +1,42 @@
+/* { dg-additional-options "-fno-early-inlining -fno-ipa-cp" }  */
+struct a {
+  float *b;
+} *a;
+struct b {
+  int *b;
+} b;
+struct c {
+  float *b;
+} *c;
+int d;
+use_a (struct a *a)
+{
+}
+set_b (int **a)
+{
+  *a=&d;
+}
+use_c (struct c *a)
+{
+}
+__attribute__ ((noinline)) int **retme(int **val)
+{
+  return val;
+}
+int e;
+struct b b= {&e};
+struct b b2;
+struct b b3;
+int **ptr = &b2.b;
+main ()
+{
+  a= (void *)0;
+  b.b=&e;
+  ptr =retme ( &b.b);
+  set_b (ptr);
+  b3=b;
+  if (b3.b != &d)
+  __builtin_abort ();
+  c= (void *)0;
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00014-Regression-C-gcc-c-torture-execute-GCC-C-execute-lto-tbaa-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00014-Regression-C-gcc-c-torture-execute-GCC-C-execute-lto-tbaa-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bb0fa371f4709694b56d93392843feee21adbdde
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00014-Regression-C-gcc-c-torture-execute-GCC-C-execute-lto-tbaa-1/test.cfg
@@ -0,0 +1,2 @@
+compile(lto-tbaa-1)
+run(lto-tbaa-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00015-Regression-C-gcc-c-torture-execute-GCC-C-execute-931004-1/931004-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00015-Regression-C-gcc-c-torture-execute-GCC-C-execute-931004-1/931004-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..ee91c1047e329b42a93c7c3cddf8add9b721d877
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00015-Regression-C-gcc-c-torture-execute-GCC-C-execute-931004-1/931004-1.c
@@ -0,0 +1,29 @@
+struct tiny
+{
+  int c;
+};
+
+f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
+{
+  if (x.c != 10)
+    abort();
+
+  if (y.c != 11)
+    abort();
+
+  if (z.c != 12)
+    abort();
+
+  if (l != 123)
+    abort ();
+}
+
+main ()
+{
+  struct tiny x[3];
+  x[0].c = 10;
+  x[1].c = 11;
+  x[2].c = 12;
+  f (3, x[0], x[1], x[2], (long) 123);
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00015-Regression-C-gcc-c-torture-execute-GCC-C-execute-931004-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00015-Regression-C-gcc-c-torture-execute-GCC-C-execute-931004-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00015-Regression-C-gcc-c-torture-execute-GCC-C-execute-931004-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00015-Regression-C-gcc-c-torture-execute-GCC-C-execute-931004-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6236390f5e83d91328d6586fad9e7d668d8f07b9
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00015-Regression-C-gcc-c-torture-execute-GCC-C-execute-931004-1/test.cfg
@@ -0,0 +1,2 @@
+compile(931004-1)
+run(931004-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00016-Regression-C-gcc-c-torture-execute-GCC-C-execute-921117-1/921117-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00016-Regression-C-gcc-c-torture-execute-GCC-C-execute-921117-1/921117-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..2ed30fbeeef8688413120d50708cf1c75de5931b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00016-Regression-C-gcc-c-torture-execute-GCC-C-execute-921117-1/921117-1.c
@@ -0,0 +1,22 @@
+struct s {
+  char text[11];
+  int flag;
+} cell;
+
+int
+check (struct s p)
+{
+  if (p.flag != 99)
+    return 1;
+  return strcmp (p.text, "0123456789");
+}
+
+main ()
+{
+  cell.flag = 99;
+  strcpy (cell.text, "0123456789");
+
+  if (check (cell))
+    abort();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00016-Regression-C-gcc-c-torture-execute-GCC-C-execute-921117-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00016-Regression-C-gcc-c-torture-execute-GCC-C-execute-921117-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00016-Regression-C-gcc-c-torture-execute-GCC-C-execute-921117-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00016-Regression-C-gcc-c-torture-execute-GCC-C-execute-921117-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc451b65a4703b768e2b6cf6987457625c2101da
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00016-Regression-C-gcc-c-torture-execute-GCC-C-execute-921117-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921117-1)
+run(921117-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00017-Regression-C-gcc-c-torture-execute-GCC-C-execute-960312-1/960312-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00017-Regression-C-gcc-c-torture-execute-GCC-C-execute-960312-1/960312-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..94e67df23bd5cac1804fae2a42ce41c797f2a933
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00017-Regression-C-gcc-c-torture-execute-GCC-C-execute-960312-1/960312-1.c
@@ -0,0 +1,34 @@
+struct S
+{
+  int *sp, fc, *sc, a[2];
+};
+
+f (struct S *x)
+{
+  int *t = x->sc;
+  int t1 = t[0];
+  int t2 = t[1];
+  int t3 = t[2];
+  int a0 = x->a[0];
+  int a1 = x->a[1];
+  asm("": :"r" (t2), "r" (t3));
+  t[2] = t1;
+  t[0] = a1;
+  x->a[1] = a0;
+  x->a[0] = t3;
+  x->fc = t2;
+  x->sp = t;
+}
+
+main ()
+{
+  struct S s;
+  static int sc[3] = {2, 3, 4};
+  s.sc = sc;
+  s.a[0] = 10;
+  s.a[1] = 11;
+  f (&s);
+  if (s.sp[2] != 2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00017-Regression-C-gcc-c-torture-execute-GCC-C-execute-960312-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00017-Regression-C-gcc-c-torture-execute-GCC-C-execute-960312-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00017-Regression-C-gcc-c-torture-execute-GCC-C-execute-960312-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00017-Regression-C-gcc-c-torture-execute-GCC-C-execute-960312-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..979c78808edd356419b1ea7b37c07a34b4682e7d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00017-Regression-C-gcc-c-torture-execute-GCC-C-execute-960312-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960312-1)
+run(960312-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00018-Regression-C-gcc-c-torture-execute-GCC-C-execute-bf64-1/bf64-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00018-Regression-C-gcc-c-torture-execute-GCC-C-execute-bf64-1/bf64-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c9241e281c59ef399974aa4a657f59714d338d4e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00018-Regression-C-gcc-c-torture-execute-GCC-C-execute-bf64-1/bf64-1.c
@@ -0,0 +1,41 @@
+/* { dg-xfail-if "ABI specifies bitfields cannot exceed 32 bits" { mcore-*-* } } */
+struct tmp
+{
+  long long int pad : 12;
+  long long int field : 52;
+};
+
+struct tmp2
+{
+  long long int field : 52;
+  long long int pad : 12;
+};
+
+struct tmp
+sub (struct tmp tmp)
+{
+  tmp.field |= 0x0008765412345678LL;
+  return tmp;
+}
+
+struct tmp2
+sub2 (struct tmp2 tmp2)
+{
+  tmp2.field |= 0x0008765412345678LL;
+  return tmp2;
+}
+
+main()
+{
+  struct tmp tmp = {0x123, 0xFFF000FFF000FLL};
+  struct tmp2 tmp2 = {0xFFF000FFF000FLL, 0x123};
+
+  tmp = sub (tmp);
+  tmp2 = sub2 (tmp2);
+
+  if (tmp.pad != 0x123 || tmp.field != 0xFFFFFF541FFF567FLL)
+    abort ();
+  if (tmp2.pad != 0x123 || tmp2.field != 0xFFFFFF541FFF567FLL)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00018-Regression-C-gcc-c-torture-execute-GCC-C-execute-bf64-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00018-Regression-C-gcc-c-torture-execute-GCC-C-execute-bf64-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00018-Regression-C-gcc-c-torture-execute-GCC-C-execute-bf64-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00018-Regression-C-gcc-c-torture-execute-GCC-C-execute-bf64-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e4a514932af10059be585877e4f2167cefe6d007
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00018-Regression-C-gcc-c-torture-execute-GCC-C-execute-bf64-1/test.cfg
@@ -0,0 +1,2 @@
+compile(bf64-1)
+run(bf64-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00019-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52286/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00019-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52286/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00019-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52286/pr52286.c b/testsuite/c_test/x64_be_enable_test/LLVM00019-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52286/pr52286.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb56295ab5296124538b12f842e3a64b56d8e00b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00019-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52286/pr52286.c
@@ -0,0 +1,20 @@
+/* PR tree-optimization/52286 */
+
+extern void abort (void);
+
+int
+main ()
+{
+#if __SIZEOF_INT__ > 2
+  int a, b;
+  asm ("" : "=r" (a) : "0" (0));
+  b = (~a | 1) & -2038094497;
+#else
+  long a, b;
+  asm ("" : "=r" (a) : "0" (0));
+  b = (~a | 1) & -2038094497L;
+#endif
+  if (b >= 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00019-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52286/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00019-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52286/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6cd5acf65127028f534dcd4dc328000ea340c737
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00019-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52286/test.cfg
@@ -0,0 +1,2 @@
+compile(pr52286)
+run(pr52286)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00020-Regression-C-gcc-c-torture-execute-GCC-C-execute-20051012-1/20051012-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00020-Regression-C-gcc-c-torture-execute-GCC-C-execute-20051012-1/20051012-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..786f27a4b4e920376a9b1d2a5936e4cec5d603c6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00020-Regression-C-gcc-c-torture-execute-GCC-C-execute-20051012-1/20051012-1.c
@@ -0,0 +1,25 @@
+/* { dg-require-effective-target untyped_assembly } */
+extern void abort (void);
+
+struct type
+{
+  int *a;
+
+  int b:16;
+  unsigned int p:9;
+} t;
+
+unsigned int
+foo ()
+{
+  return t.p;
+}
+
+int
+main (void)
+{
+  t.p = 8;
+  if (foo (t) != 8)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00020-Regression-C-gcc-c-torture-execute-GCC-C-execute-20051012-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00020-Regression-C-gcc-c-torture-execute-GCC-C-execute-20051012-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00020-Regression-C-gcc-c-torture-execute-GCC-C-execute-20051012-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00020-Regression-C-gcc-c-torture-execute-GCC-C-execute-20051012-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..123970eb85dcd0b57fad43a6a451e4ac39a0bad7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00020-Regression-C-gcc-c-torture-execute-GCC-C-execute-20051012-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20051012-1)
+run(20051012-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00021-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030613-1/20030613-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00021-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030613-1/20030613-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9f3c44a0160f9632958807c9f279e7b55dc498d1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00021-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030613-1/20030613-1.c
@@ -0,0 +1,62 @@
+/* PR optimization/10955 */
+/* Originator: <heinrich.brand@fujitsu-siemens.com> */
+
+/* This used to fail on SPARC32 at -O3 because the loop unroller
+   wrongly thought it could eliminate a pseudo in a loop, while
+   the pseudo was used outside the loop.  */
+
+extern void abort(void);
+
+#define COMPLEX struct CS
+
+COMPLEX {
+  long x;
+  long y;
+};
+
+
+static COMPLEX CCID (COMPLEX x)
+{
+  COMPLEX a;
+
+  a.x = x.x;
+  a.y = x.y;
+
+  return a;
+}
+
+
+static COMPLEX CPOW (COMPLEX x, int y)
+{
+  COMPLEX a;
+  a = x;
+
+  while (--y > 0)
+    a=CCID(a);
+
+  return a;
+}
+
+
+static int c5p (COMPLEX x)
+{
+  COMPLEX a,b;
+  a = CPOW (x, 2);
+  b = CCID( CPOW(a,2) );
+
+  return (b.x == b.y);
+}
+
+
+int main (void)
+{
+  COMPLEX  x;
+
+  x.x = -7;
+  x.y = -7;
+
+  if (!c5p(x))
+    abort();
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00021-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030613-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00021-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030613-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00021-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030613-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00021-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030613-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..975916b34f9829b8384242daa1c8b28b431ca9bc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00021-Regression-C-gcc-c-torture-execute-GCC-C-execute-20030613-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20030613-1)
+run(20030613-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00022-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr67226/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00022-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr67226/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00022-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr67226/pr67226.c b/testsuite/c_test/x64_be_enable_test/LLVM00022-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr67226/pr67226.c
new file mode 100644
index 0000000000000000000000000000000000000000..c533496cbc6fa06872d415c3bba5cc5fe8d4c651
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00022-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr67226/pr67226.c
@@ -0,0 +1,42 @@
+struct assembly_operand
+{
+  int type, value, symtype, symflags, marker;
+};
+
+struct assembly_operand to_input, from_input;
+
+void __attribute__ ((__noinline__, __noclone__))
+assemblez_1 (int internal_number, struct assembly_operand o1)
+{
+  if (o1.type != from_input.type)
+    __builtin_abort ();
+}
+
+void __attribute__ ((__noinline__, __noclone__))
+t0 (struct assembly_operand to, struct assembly_operand from)
+{
+  if (to.value == 0)
+    assemblez_1 (32, from);
+  else
+    __builtin_abort ();
+}
+
+int
+main (void)
+{
+  to_input.value = 0;
+  to_input.type = 1;
+  to_input.symtype = 2;
+  to_input.symflags = 3;
+  to_input.marker = 4;
+
+  from_input.value = 5;
+  from_input.type = 6;
+  from_input.symtype = 7;
+  from_input.symflags = 8;
+  from_input.marker = 9;
+
+  t0 (to_input, from_input);
+
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00022-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr67226/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00022-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr67226/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b6e07089abcef294b612ea1ebea5724e345e5d6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00022-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr67226/test.cfg
@@ -0,0 +1,2 @@
+compile(pr67226)
+run(pr67226)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00023-Regression-C-gcc-c-torture-execute-GCC-C-execute-struct-cpy-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00023-Regression-C-gcc-c-torture-execute-GCC-C-execute-struct-cpy-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00023-Regression-C-gcc-c-torture-execute-GCC-C-execute-struct-cpy-1/struct-cpy-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00023-Regression-C-gcc-c-torture-execute-GCC-C-execute-struct-cpy-1/struct-cpy-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..52886feee0f98d062dd8659912288804a5768967
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00023-Regression-C-gcc-c-torture-execute-GCC-C-execute-struct-cpy-1/struct-cpy-1.c
@@ -0,0 +1,43 @@
+/* powerpc64-linux gcc miscompiled this due to rs6000.c:expand_block_move
+   not setting mem aliasing info correctly for the code implementing the
+   structure assignment.  */
+
+struct termios
+{
+  unsigned int a;
+  unsigned int b;
+  unsigned int c;
+  unsigned int d;
+  unsigned char pad[28];
+};
+
+struct tty_driver
+{
+  unsigned char pad1[38];
+  struct termios t __attribute__ ((aligned (8)));
+};
+
+static struct termios zero_t;
+static struct tty_driver pty;
+
+void ini (void)
+{
+  pty.t = zero_t;
+  pty.t.a = 1;
+  pty.t.b = 2;
+  pty.t.c = 3;
+  pty.t.d = 4;
+}
+
+int main (void)
+{
+  extern void abort (void);
+
+  ini ();
+  if (pty.t.a != 1
+      || pty.t.b != 2
+      || pty.t.c != 3
+      || pty.t.d != 4)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00023-Regression-C-gcc-c-torture-execute-GCC-C-execute-struct-cpy-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00023-Regression-C-gcc-c-torture-execute-GCC-C-execute-struct-cpy-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e2e797a7af367761c946cf76401c9b5e467575c3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00023-Regression-C-gcc-c-torture-execute-GCC-C-execute-struct-cpy-1/test.cfg
@@ -0,0 +1,2 @@
+compile(struct-cpy-1)
+run(struct-cpy-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00024-Regression-C-gcc-c-torture-execute-GCC-C-execute-921112-1/921112-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00024-Regression-C-gcc-c-torture-execute-GCC-C-execute-921112-1/921112-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5946398e3c0ddc1c0cbe06b60877dae6afab7818
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00024-Regression-C-gcc-c-torture-execute-GCC-C-execute-921112-1/921112-1.c
@@ -0,0 +1,21 @@
+union u {
+  struct { int i1, i2; } t;
+  double d;
+} x[2], v;
+
+f (x, v)
+     union u *x, v;
+{
+  *++x = v;
+}
+
+main()
+{
+  x[1].t.i1 = x[1].t.i2 = 0;
+  v.t.i1 = 1;
+  v.t.i2 = 2;
+  f (x, v);
+  if (x[1].t.i1 != 1 || x[1].t.i2 != 2)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00024-Regression-C-gcc-c-torture-execute-GCC-C-execute-921112-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00024-Regression-C-gcc-c-torture-execute-GCC-C-execute-921112-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00024-Regression-C-gcc-c-torture-execute-GCC-C-execute-921112-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00024-Regression-C-gcc-c-torture-execute-GCC-C-execute-921112-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..530d910d469904952a468059205edd5a7a9204ff
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00024-Regression-C-gcc-c-torture-execute-GCC-C-execute-921112-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921112-1)
+run(921112-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00025-Regression-C-gcc-c-torture-execute-GCC-C-execute-20020920-1/20020920-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00025-Regression-C-gcc-c-torture-execute-GCC-C-execute-20020920-1/20020920-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4539742dd38d06295e75f2f21565c763c13e777d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00025-Regression-C-gcc-c-torture-execute-GCC-C-execute-20020920-1/20020920-1.c
@@ -0,0 +1,31 @@
+extern void abort (void);
+extern void exit (int);
+
+struct B
+{
+  int x;
+  int y;
+};
+
+struct A
+{
+  int z;
+  struct B b;
+};
+
+struct A
+f ()
+{
+  struct B b = { 0, 1 };
+  struct A a = { 2, b };
+  return a;
+}
+
+int
+main (void)
+{
+  struct A a = f ();
+  if (a.z != 2 || a.b.x != 0 || a.b.y != 1)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00025-Regression-C-gcc-c-torture-execute-GCC-C-execute-20020920-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00025-Regression-C-gcc-c-torture-execute-GCC-C-execute-20020920-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00025-Regression-C-gcc-c-torture-execute-GCC-C-execute-20020920-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00025-Regression-C-gcc-c-torture-execute-GCC-C-execute-20020920-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c908905b27e39fcaf32c4b73e0b88f2d188227b
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00025-Regression-C-gcc-c-torture-execute-GCC-C-execute-20020920-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20020920-1)
+run(20020920-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00026-Regression-C-gcc-c-torture-execute-GCC-C-execute-zero-struct-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00026-Regression-C-gcc-c-torture-execute-GCC-C-execute-zero-struct-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00026-Regression-C-gcc-c-torture-execute-GCC-C-execute-zero-struct-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00026-Regression-C-gcc-c-torture-execute-GCC-C-execute-zero-struct-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..12099e6f269659e92063097966964eeb30e16066
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00026-Regression-C-gcc-c-torture-execute-GCC-C-execute-zero-struct-1/test.cfg
@@ -0,0 +1,2 @@
+compile(zero-struct-1)
+run(zero-struct-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00026-Regression-C-gcc-c-torture-execute-GCC-C-execute-zero-struct-1/zero-struct-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00026-Regression-C-gcc-c-torture-execute-GCC-C-execute-zero-struct-1/zero-struct-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..d673adf5c31dcc82feaa44a6d37eacb146c9547f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00026-Regression-C-gcc-c-torture-execute-GCC-C-execute-zero-struct-1/zero-struct-1.c
@@ -0,0 +1,23 @@
+struct g{};
+char y[3];
+char *f = &y[0];
+char *ff = &y[0];
+void h(void)
+{
+  struct g t;
+  *((struct g*)(f++)) = *((struct g*)(ff++));
+  *((struct g*)(f++)) = (struct g){};
+  t = *((struct g*)(ff++));
+}
+
+void abort (void);
+
+int main(void)
+{
+  h();
+  if (f != &y[2])
+    abort();
+  if (ff != &y[2])
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00027-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071211-1/20071211-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00027-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071211-1/20071211-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4a4f1fefc90675272b549f1790c3252ba4907987
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00027-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071211-1/20071211-1.c
@@ -0,0 +1,23 @@
+extern void abort() __attribute__ ((noreturn));
+
+struct s
+{
+  unsigned long long f1 : 40;
+#if(__SIZEOF_INT__ >= 4)
+  unsigned int f2 : 24;
+#else
+  unsigned long int f2 : 24;
+#endif
+} sv;
+
+int main()
+{
+  int f2;
+  sv.f2 = (1 << 24) - 1;
+  __asm__ volatile ("" : : : "memory");
+  ++sv.f2;
+  f2 = sv.f2;
+  if (f2 != 0)
+    abort();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00027-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071211-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00027-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071211-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00027-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071211-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00027-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071211-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..13140e4dc39751e9d0b543ec960311f8005a81a3
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00027-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071211-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071211-1)
+run(20071211-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00028-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52129/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00028-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52129/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00028-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52129/pr52129.c b/testsuite/c_test/x64_be_enable_test/LLVM00028-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52129/pr52129.c
new file mode 100644
index 0000000000000000000000000000000000000000..ab43ca60cfe67243644c925a796ff9cb03fc57e8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00028-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52129/pr52129.c
@@ -0,0 +1,29 @@
+/* PR target/52129 */
+/* { dg-xfail-if "ptxas crashes" { nvptx-*-* } { "-O1" } { "" } } */
+
+extern void abort (void);
+struct S { void *p; unsigned int q; };
+struct T { char a[64]; char b[64]; } t;
+
+__attribute__((noinline, noclone)) int
+foo (void *x, struct S s, void *y, void *z)
+{
+  if (x != &t.a[2] || s.p != &t.b[5] || s.q != 27 || y != &t.a[17] || z != &t.b[17])
+    abort ();
+  return 29;
+}
+
+__attribute__((noinline, noclone)) int
+bar (void *x, void *y, void *z, struct S s, int t, struct T *u)
+{
+  return foo (x, s, &u->a[t], &u->b[t]);
+}
+
+int
+main ()
+{
+  struct S s = { &t.b[5], 27 };
+  if (bar (&t.a[2], (void *) 0, (void *) 0, s, 17, &t) != 29)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00028-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52129/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00028-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52129/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6099707de06bcc6fc44c0f525d87a81ad394bfc5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00028-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52129/test.cfg
@@ -0,0 +1,2 @@
+compile(pr52129)
+run(pr52129)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00029-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr46309/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00029-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr46309/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00029-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr46309/pr46309.c b/testsuite/c_test/x64_be_enable_test/LLVM00029-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr46309/pr46309.c
new file mode 100644
index 0000000000000000000000000000000000000000..46e10ab4bf43a0e090c268c7585b4dbefa0897b6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00029-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr46309/pr46309.c
@@ -0,0 +1,31 @@
+/* PR tree-optimization/46309 */
+
+extern void abort (void);
+
+unsigned int *q;
+
+__attribute__((noinline, noclone)) void
+bar (unsigned int *p)
+{
+  if (*p != 2 && *p != 3)
+    (!(!(*q & 263) || *p != 1)) ? abort () : 0;
+}
+
+int
+main ()
+{
+  unsigned int x, y;
+  asm volatile ("" : : : "memory");
+  x = 2;
+  bar (&x);
+  x = 3;
+  bar (&x);
+  y = 1;
+  x = 0;
+  q = &y;
+  bar (&x);
+  y = 0;
+  x = 1;
+  bar (&x);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00029-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr46309/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00029-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr46309/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd52b321b307a45bff5e89af4e4dacf11277af6e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00029-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr46309/test.cfg
@@ -0,0 +1,2 @@
+compile(pr46309)
+run(pr46309)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00030-Benchmarks-BenchmarkGame-nsieve-bits/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00030-Benchmarks-BenchmarkGame-nsieve-bits/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6e3704c648096c69c03a6cc458edf4fe9b3eca17
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00030-Benchmarks-BenchmarkGame-nsieve-bits/expected.txt
@@ -0,0 +1,3 @@
+Primes up to 40960000  2488465
+Primes up to 20480000  1299069
+Primes up to 10240000   679461
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00030-Benchmarks-BenchmarkGame-nsieve-bits/nsieve-bits.c b/testsuite/c_test/x64_be_enable_test/LLVM00030-Benchmarks-BenchmarkGame-nsieve-bits/nsieve-bits.c
new file mode 100644
index 0000000000000000000000000000000000000000..3a35e0f14732c78768a1b6dc3ef3bfd1a1244093
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00030-Benchmarks-BenchmarkGame-nsieve-bits/nsieve-bits.c
@@ -0,0 +1,36 @@
+/*
+** The Great Computer Language Shootout
+** http://shootout.alioth.debian.org/
+** contributed by Mike Pall
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef unsigned int bits;
+#define BBITS		(sizeof(bits) * 8)
+#define BSIZE(x)	(((x) / 8) + sizeof(bits))
+#define BMASK(x)	(1 << ((x) % BBITS))
+#define BTEST(p, x)	((p)[(x) / BBITS] & BMASK(x))
+#define BFLIP(p, x)	(p)[(x) / BBITS] ^= BMASK(x)
+
+int main(int argc, char **argv)
+{
+  unsigned int m, sz = 10000 << 12;
+  bits *primes = (bits *)malloc(BSIZE(sz));
+  if (!primes) return 1;
+  for (m = 0; m <= 2; m++) {
+    unsigned int i, j, count = 0, n = sz >> m;
+    memset(primes, 0xff, BSIZE(n));
+    for (i = 2; i <= n; i++)
+      if (BTEST(primes, i)) {
+	count++;
+	for (j = i + i; j <= n; j += i)
+	  if (BTEST(primes, j)) BFLIP(primes, j);
+      }
+    printf("Primes up to %8d %8d\n", n, count);
+  }
+  free(primes);
+  return 0;
+}
\ No newline at end of file
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00030-Benchmarks-BenchmarkGame-nsieve-bits/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00030-Benchmarks-BenchmarkGame-nsieve-bits/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bfecd6574f25f11b18108a8154d4d3b57076c949
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00030-Benchmarks-BenchmarkGame-nsieve-bits/test.cfg
@@ -0,0 +1,2 @@
+compile(nsieve-bits)
+run(nsieve-bits)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00031-Regression-C-gcc-c-torture-execute-GCC-C-execute-990130-1/990130-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00031-Regression-C-gcc-c-torture-execute-GCC-C-execute-990130-1/990130-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c38ecddbe596bae136d54f9b70d8d26ecdd0ab48
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00031-Regression-C-gcc-c-torture-execute-GCC-C-execute-990130-1/990130-1.c
@@ -0,0 +1,23 @@
+int count = 0;
+int dummy;
+
+static int *
+bar(void)
+{
+  ++count;
+  return &dummy;
+}
+
+static void
+foo(void)
+{
+  asm("" : "+r"(*bar()));
+}
+
+main()
+{
+  foo();
+  if (count != 1)
+    abort();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00031-Regression-C-gcc-c-torture-execute-GCC-C-execute-990130-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00031-Regression-C-gcc-c-torture-execute-GCC-C-execute-990130-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00031-Regression-C-gcc-c-torture-execute-GCC-C-execute-990130-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00031-Regression-C-gcc-c-torture-execute-GCC-C-execute-990130-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1f12a7cdea305a6fbe39c330a6615f528ee58202
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00031-Regression-C-gcc-c-torture-execute-GCC-C-execute-990130-1/test.cfg
@@ -0,0 +1,2 @@
+compile(990130-1)
+run(990130-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00032-Regression-C-gcc-c-torture-execute-GCC-C-execute-compndlit-1/compndlit-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00032-Regression-C-gcc-c-torture-execute-GCC-C-execute-compndlit-1/compndlit-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..76328c21c2e7f072e74724f5906c1a93fb33b864
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00032-Regression-C-gcc-c-torture-execute-GCC-C-execute-compndlit-1/compndlit-1.c
@@ -0,0 +1,25 @@
+/* The bit-field below would have a problem if __INT_MAX__ is too
+   small.  */
+#if __INT_MAX__ < 2147483647
+int
+main (void)
+{
+  exit (0);
+}
+#else
+struct S
+{
+  int a:3;
+  unsigned b:1, c:28;
+};
+
+struct S x = {1, 1, 1};
+
+main ()
+{
+  x = (struct S) {b:0, a:0, c:({ struct S o = x; o.a == 1 ? 10 : 20;})};
+  if (x.c != 10)
+    abort ();
+  exit (0);
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00032-Regression-C-gcc-c-torture-execute-GCC-C-execute-compndlit-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00032-Regression-C-gcc-c-torture-execute-GCC-C-execute-compndlit-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00032-Regression-C-gcc-c-torture-execute-GCC-C-execute-compndlit-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00032-Regression-C-gcc-c-torture-execute-GCC-C-execute-compndlit-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7cdd5ea283d666f3abb1be3e4e40f6b5a8d2fc44
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00032-Regression-C-gcc-c-torture-execute-GCC-C-execute-compndlit-1/test.cfg
@@ -0,0 +1,2 @@
+compile(compndlit-1)
+run(compndlit-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00033-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr44164/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00033-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr44164/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00033-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr44164/pr44164.c b/testsuite/c_test/x64_be_enable_test/LLVM00033-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr44164/pr44164.c
new file mode 100644
index 0000000000000000000000000000000000000000..171f9c39f59760a98f2c81d8303a9791919cc3a1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00033-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr44164/pr44164.c
@@ -0,0 +1,24 @@
+struct X {
+    struct Y {
+	struct YY {
+	    struct Z {
+		int i;
+	    } c;
+	} bb;
+    } b;
+} a;
+int __attribute__((noinline, noclone))
+foo (struct Z *p)
+{
+  int i = p->i;
+  a.b = (struct Y){};
+  return p->i + i;
+}
+extern void abort (void);
+int main()
+{
+  a.b.bb.c.i = 1;
+  if (foo (&a.b.bb.c) != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00033-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr44164/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00033-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr44164/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e6016515a1518b2fc5765d8bd8dda7526065363
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00033-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr44164/test.cfg
@@ -0,0 +1,2 @@
+compile(pr44164)
+run(pr44164)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00034-Regression-C-Regression-C-PR1386/PR1386.c b/testsuite/c_test/x64_be_enable_test/LLVM00034-Regression-C-Regression-C-PR1386/PR1386.c
new file mode 100644
index 0000000000000000000000000000000000000000..5cbb571a9cf99fd9713e7d44cde93c43b3dcfa11
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00034-Regression-C-Regression-C-PR1386/PR1386.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdint.h>
+
+struct X {
+  unsigned char pad : 4;
+  uint64_t a : 64;
+  uint64_t b : 60;
+} __attribute__((packed));
+
+int main (void)
+{
+  struct X x;
+  uint64_t bad_bits;
+
+  x.pad = 255;
+  x.a = -1ULL;
+  x.b = -1ULL;
+
+  bad_bits = ((uint64_t)-1ULL) ^ *(1+(uint64_t *) &x);
+  printf("bad bits: %llx\n", bad_bits);
+  return bad_bits != 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00034-Regression-C-Regression-C-PR1386/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00034-Regression-C-Regression-C-PR1386/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a5a20ff349d9b001a3f7a39da5e50ca82eee5d4
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00034-Regression-C-Regression-C-PR1386/expected.txt
@@ -0,0 +1 @@
+bad bits: 0
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00034-Regression-C-Regression-C-PR1386/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00034-Regression-C-Regression-C-PR1386/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a75e317f7c04510fa2ac809b803b0ac3674203fc
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00034-Regression-C-Regression-C-PR1386/test.cfg
@@ -0,0 +1,2 @@
+compile(PR1386)
+run(PR1386)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00035-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr88904/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00035-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr88904/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00035-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr88904/pr88904.c b/testsuite/c_test/x64_be_enable_test/LLVM00035-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr88904/pr88904.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c285671321cc3ce39c5bd4ea512e6454e045084
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00035-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr88904/pr88904.c
@@ -0,0 +1,38 @@
+/* PR rtl-optimization/88904 */
+
+volatile int v;
+
+__attribute__((noipa)) void
+bar (const char *x, const char *y, int z)
+{
+  if (!v)
+    __builtin_abort ();
+  asm volatile ("" : "+g" (x));
+  asm volatile ("" : "+g" (y));
+  asm volatile ("" : "+g" (z));
+}
+
+#define my_assert(e) ((e) ? (void) 0 : bar (#e, __FILE__, __LINE__))
+
+typedef struct {
+  unsigned M1;
+  unsigned M2 : 1;
+  int : 0;
+  unsigned M3 : 1;
+} S;
+
+S
+foo ()
+{
+  S result = {0, 0, 1};
+  return result;
+}
+
+int
+main ()
+{
+  S ret = foo ();
+  my_assert (ret.M2 == 0);
+  my_assert (ret.M3 == 1);
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00035-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr88904/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00035-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr88904/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ea80a7871fb37ce815608a941b63a7adc028b277
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00035-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr88904/test.cfg
@@ -0,0 +1,2 @@
+compile(pr88904)
+run(pr88904)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00036-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr78170/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00036-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr78170/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00036-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr78170/pr78170.c b/testsuite/c_test/x64_be_enable_test/LLVM00036-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr78170/pr78170.c
new file mode 100644
index 0000000000000000000000000000000000000000..dce8a3eee362f43216210abb20df14520ded0cd7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00036-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr78170/pr78170.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target int32plus } */
+
+/* PR tree-optimization/78170.
+   Check that sign-extended store to a bitfield
+   doesn't overwrite other fields.  */
+
+int a, b, d;
+
+struct S0
+{
+  int f0;
+  int f1;
+  int f2;
+  int f3;
+  int f4;
+  int f5:15;
+  int f6:17;
+  int f7:2;
+  int f8:30;
+} c;
+
+void fn1 ()
+{
+  d = b = 1;
+  for (; b; b = a)
+    {
+      struct S0 e = { 0, 0, 0, 0, 0, 0, 1, 0, 1 };
+      c = e;
+      c.f6 = -1;
+    }
+}
+
+int main ()
+{
+  fn1 ();
+  if (c.f7 != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00036-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr78170/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00036-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr78170/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0e16365ea7e7e254dcdc46ccecb0fbafa62bdc0c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00036-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr78170/test.cfg
@@ -0,0 +1,2 @@
+compile(pr78170)
+run(pr78170)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00037-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82954/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00037-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82954/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00037-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82954/pr82954.c b/testsuite/c_test/x64_be_enable_test/LLVM00037-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82954/pr82954.c
new file mode 100644
index 0000000000000000000000000000000000000000..5ced28544e5a234cec5ef60c02ebb5a0f263084f
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00037-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82954/pr82954.c
@@ -0,0 +1,22 @@
+/* PR tree-optimization/82954 */
+
+__attribute__((noipa)) void
+foo (int *__restrict p, int *__restrict q)
+{
+  p[0] = p[0] ^ 1;
+  p[1] = p[1] ^ 2;
+  p[2] = p[2] ^ q[2];
+  p[3] = p[3] ^ q[3];
+}
+
+int
+main ()
+{
+  int p[4] = { 16, 32, 64, 128 };
+  int q[4] = { 8, 4, 2, 1 };
+  asm volatile ("" : : "g" (p), "g" (q) : "memory");
+  foo (p, q);
+  if (p[0] != 17 || p[1] != 34 || p[2] != 66 || p[3] != 129)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00037-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82954/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00037-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82954/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc2452b7c6c7eef78bdcaa6e3b2a7de87dddc054
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00037-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr82954/test.cfg
@@ -0,0 +1,2 @@
+compile(pr82954)
+run(pr82954)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00038-UnitTests-2003-05-14-AtExit/2003-05-14-AtExit.c b/testsuite/c_test/x64_be_enable_test/LLVM00038-UnitTests-2003-05-14-AtExit/2003-05-14-AtExit.c
new file mode 100644
index 0000000000000000000000000000000000000000..1f40b665b46ecfd02d402e747c224407932eb90a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00038-UnitTests-2003-05-14-AtExit/2003-05-14-AtExit.c
@@ -0,0 +1,16 @@
+/* This test checks to make sure that LLI and the JIT both implement at_exit 
+ * handlers correctly.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+static void foo() {
+  printf("Exiting!\n");
+}
+
+int main() {
+  atexit(foo);
+  printf("in main\n");
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00038-UnitTests-2003-05-14-AtExit/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00038-UnitTests-2003-05-14-AtExit/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4118e6adc2496f9efae49a05700bb37ef91c046c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00038-UnitTests-2003-05-14-AtExit/expected.txt
@@ -0,0 +1,2 @@
+in main
+Exiting!
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00038-UnitTests-2003-05-14-AtExit/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00038-UnitTests-2003-05-14-AtExit/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0f8bf352305decd266b6d75c9a2c0a79936872bf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00038-UnitTests-2003-05-14-AtExit/test.cfg
@@ -0,0 +1,2 @@
+compile(2003-05-14-AtExit)
+run(2003-05-14-AtExit)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00039-Regression-C-gcc-c-torture-execute-GCC-C-execute-991118-1/991118-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00039-Regression-C-gcc-c-torture-execute-GCC-C-execute-991118-1/991118-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..77ba888a2a011030416b72237324dd5fbbf31279
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00039-Regression-C-gcc-c-torture-execute-GCC-C-execute-991118-1/991118-1.c
@@ -0,0 +1,79 @@
+struct tmp
+{
+  long long int pad : 12;
+  long long int field : 52;
+};
+
+struct tmp2
+{
+  long long int field : 52;
+  long long int pad : 12;
+};
+
+struct tmp3
+{
+  long long int pad : 11;
+  long long int field : 53;
+};
+
+struct tmp4
+{
+  long long int field : 53;
+  long long int pad : 11;
+};
+
+struct tmp
+sub (struct tmp tmp)
+{
+  tmp.field ^= 0x0008765412345678LL;
+  return tmp;
+}
+
+struct tmp2
+sub2 (struct tmp2 tmp2)
+{
+  tmp2.field ^= 0x0008765412345678LL;
+  return tmp2;
+}
+
+struct tmp3
+sub3 (struct tmp3 tmp3)
+{
+  tmp3.field ^= 0x0018765412345678LL;
+  return tmp3;
+}
+
+struct tmp4
+sub4 (struct tmp4 tmp4)
+{
+  tmp4.field ^= 0x0018765412345678LL;
+  return tmp4;
+}
+
+struct tmp tmp = {0x123, 0x123456789ABCDLL};
+struct tmp2 tmp2 = {0x123456789ABCDLL, 0x123};
+struct tmp3 tmp3 = {0x123, 0x1FFFF00000000LL};
+struct tmp4 tmp4 = {0x1FFFF00000000LL, 0x123};
+
+main()
+{
+
+  if (sizeof (long long) != 8)
+    exit (0);
+
+  tmp = sub (tmp);
+  tmp2 = sub2 (tmp2);
+
+  if (tmp.pad != 0x123 || tmp.field != 0xFFF9551175BDFDB5LL)
+    abort ();
+  if (tmp2.pad != 0x123 || tmp2.field != 0xFFF9551175BDFDB5LL)
+    abort ();
+
+  tmp3 = sub3 (tmp3);
+  tmp4 = sub4 (tmp4);
+  if (tmp3.pad != 0x123 || tmp3.field != 0xFFF989AB12345678LL)
+    abort ();
+  if (tmp4.pad != 0x123 || tmp4.field != 0xFFF989AB12345678LL)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00039-Regression-C-gcc-c-torture-execute-GCC-C-execute-991118-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00039-Regression-C-gcc-c-torture-execute-GCC-C-execute-991118-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00039-Regression-C-gcc-c-torture-execute-GCC-C-execute-991118-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00039-Regression-C-gcc-c-torture-execute-GCC-C-execute-991118-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5f6957c317b8ccda36ae9c579a85450d6604827c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00039-Regression-C-gcc-c-torture-execute-GCC-C-execute-991118-1/test.cfg
@@ -0,0 +1,2 @@
+compile(991118-1)
+run(991118-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00040-Regression-C-gcc-c-torture-execute-GCC-C-execute-921204-1/921204-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00040-Regression-C-gcc-c-torture-execute-GCC-C-execute-921204-1/921204-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a7bba830a34ca0f794986d772560e610d99c147e
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00040-Regression-C-gcc-c-torture-execute-GCC-C-execute-921204-1/921204-1.c
@@ -0,0 +1,46 @@
+/* The bit-field below would have a problem if __INT_MAX__ is too
+   small.  */
+#if __INT_MAX__ < 2147483647
+int
+main (void)
+{
+  exit (0);
+}
+#else
+typedef struct {
+  unsigned b0:1, f1:17, b18:1, b19:1, b20:1, f2:11;
+} bf;
+
+typedef union {
+  bf b;
+  unsigned w;
+} bu;
+
+bu
+f(bu i)
+{
+  bu o = i;
+
+  if (o.b.b0)
+    o.b.b18 = 1,
+    o.b.b20 = 1;
+  else
+    o.b.b18 = 0,
+    o.b.b20 = 0;
+
+  return o;
+}
+
+main()
+{
+  bu a;
+  bu r;
+
+  a.w = 0x4000000;
+  a.b.b0 = 0;
+  r = f(a);
+  if (a.w != r.w)
+    abort();
+  exit(0);
+}
+#endif
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00040-Regression-C-gcc-c-torture-execute-GCC-C-execute-921204-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00040-Regression-C-gcc-c-torture-execute-GCC-C-execute-921204-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00040-Regression-C-gcc-c-torture-execute-GCC-C-execute-921204-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00040-Regression-C-gcc-c-torture-execute-GCC-C-execute-921204-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fadf7e6805b910a250e425d9295edfccf73d3137
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00040-Regression-C-gcc-c-torture-execute-GCC-C-execute-921204-1/test.cfg
@@ -0,0 +1,2 @@
+compile(921204-1)
+run(921204-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00041-Regression-C-gcc-c-torture-execute-GCC-C-execute-alias-access-path-1/alias-access-path-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00041-Regression-C-gcc-c-torture-execute-GCC-C-execute-alias-access-path-1/alias-access-path-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..6693a2b176d61b4f2c962ea729de8cfce2de8eee
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00041-Regression-C-gcc-c-torture-execute-GCC-C-execute-alias-access-path-1/alias-access-path-1.c
@@ -0,0 +1,19 @@
+/* Test that variable
+     int val;
+   may hold value of tyope "struct c" which has same size.
+   This is valid in GIMPLE memory model.  */
+
+struct a {int val;} a={1},a2;
+struct b {struct a a;};
+int val;
+struct c {struct b b;} *cptr=(void *)&val;
+
+int
+main(void)
+{
+  cptr->b.a=a;
+  val = 2;
+  a2=cptr->b.a;
+  if (a2.val == a.val)
+    __builtin_abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00041-Regression-C-gcc-c-torture-execute-GCC-C-execute-alias-access-path-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00041-Regression-C-gcc-c-torture-execute-GCC-C-execute-alias-access-path-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00041-Regression-C-gcc-c-torture-execute-GCC-C-execute-alias-access-path-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00041-Regression-C-gcc-c-torture-execute-GCC-C-execute-alias-access-path-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..20ae1fce06f82dc65587319867941bd6eb460b55
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00041-Regression-C-gcc-c-torture-execute-GCC-C-execute-alias-access-path-1/test.cfg
@@ -0,0 +1,2 @@
+compile(alias-access-path-1)
+run(alias-access-path-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00042-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr71700/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00042-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr71700/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00042-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr71700/pr71700.c b/testsuite/c_test/x64_be_enable_test/LLVM00042-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr71700/pr71700.c
new file mode 100644
index 0000000000000000000000000000000000000000..80afd3809c3abd24135fb36b757ace9f41ba3112
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00042-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr71700/pr71700.c
@@ -0,0 +1,19 @@
+struct S
+{
+  signed f0 : 16;
+  unsigned f1 : 1;
+};
+
+int b;
+static struct S c[] = {{-1, 0}, {-1, 0}};
+struct S d;
+
+int
+main ()
+{
+  struct S e = c[0];
+  d = e;
+  if (d.f1 != 0)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00042-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr71700/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00042-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr71700/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f840ad39bc65bcd41b54a6dd4cead6ea2d200950
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00042-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr71700/test.cfg
@@ -0,0 +1,2 @@
+compile(pr71700)
+run(pr71700)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00043-Regression-C-gcc-c-torture-execute-GCC-C-execute-991216-1/991216-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00043-Regression-C-gcc-c-torture-execute-GCC-C-execute-991216-1/991216-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..bfedefb1ec31a31e6670aafa1529c26ea85de24a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00043-Regression-C-gcc-c-torture-execute-GCC-C-execute-991216-1/991216-1.c
@@ -0,0 +1,116 @@
+#define VALUE 0x123456789abcdefLL
+#define AFTER 0x55
+
+void
+test1 (int a, long long value, int after)
+{
+  if (a != 1
+      || value != VALUE
+      || after != AFTER)
+    abort ();
+}
+
+void
+test2 (int a, int b, long long value, int after)
+{
+  if (a != 1
+      || b != 2
+      || value != VALUE
+      || after != AFTER)
+    abort ();
+}
+
+void
+test3 (int a, int b, int c, long long value, int after)
+{
+  if (a != 1
+      || b != 2
+      || c != 3
+      || value != VALUE
+      || after != AFTER)
+    abort ();
+}
+
+void
+test4 (int a, int b, int c, int d, long long value, int after)
+{
+  if (a != 1
+      || b != 2
+      || c != 3
+      || d != 4
+      || value != VALUE
+      || after != AFTER)
+    abort ();
+}
+
+void
+test5 (int a, int b, int c, int d, int e, long long value, int after)
+{
+  if (a != 1
+      || b != 2
+      || c != 3
+      || d != 4
+      || e != 5
+      || value != VALUE
+      || after != AFTER)
+    abort ();
+}
+
+void
+test6 (int a, int b, int c, int d, int e, int f, long long value, int after)
+{
+  if (a != 1
+      || b != 2
+      || c != 3
+      || d != 4
+      || e != 5
+      || f != 6
+      || value != VALUE
+      || after != AFTER)
+    abort ();
+}
+
+void
+test7 (int a, int b, int c, int d, int e, int f, int g, long long value, int after)
+{
+  if (a != 1
+      || b != 2
+      || c != 3
+      || d != 4
+      || e != 5
+      || f != 6
+      || g != 7
+      || value != VALUE
+      || after != AFTER)
+    abort ();
+}
+
+void
+test8 (int a, int b, int c, int d, int e, int f, int g, int h, long long value, int after)
+{
+  if (a != 1
+      || b != 2
+      || c != 3
+      || d != 4
+      || e != 5
+      || f != 6
+      || g != 7
+      || h != 8
+      || value != VALUE
+      || after != AFTER)
+    abort ();
+}
+
+int
+main ()
+{
+  test1 (1, VALUE, AFTER);
+  test2 (1, 2, VALUE, AFTER);
+  test3 (1, 2, 3, VALUE, AFTER);
+  test4 (1, 2, 3, 4, VALUE, AFTER);
+  test5 (1, 2, 3, 4, 5, VALUE, AFTER);
+  test6 (1, 2, 3, 4, 5, 6, VALUE, AFTER);
+  test7 (1, 2, 3, 4, 5, 6, 7, VALUE, AFTER);
+  test8 (1, 2, 3, 4, 5, 6, 7, 8, VALUE, AFTER);
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00043-Regression-C-gcc-c-torture-execute-GCC-C-execute-991216-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00043-Regression-C-gcc-c-torture-execute-GCC-C-execute-991216-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00043-Regression-C-gcc-c-torture-execute-GCC-C-execute-991216-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00043-Regression-C-gcc-c-torture-execute-GCC-C-execute-991216-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bdbeb83f3ae93aa38e44a16ac86ac3d2d03bbc34
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00043-Regression-C-gcc-c-torture-execute-GCC-C-execute-991216-1/test.cfg
@@ -0,0 +1,2 @@
+compile(991216-1)
+run(991216-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00044-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00044-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00044-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-1/pr65053-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00044-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-1/pr65053-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..edcf41ddb453b1670804b396ee7ad87eda802511
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00044-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-1/pr65053-1.c
@@ -0,0 +1,32 @@
+/* PR tree-optimization/65053 */
+
+int i;
+
+__attribute__ ((noinline, noclone))
+unsigned int foo (void)
+{
+  return 0;
+}
+
+int
+main ()
+{
+  unsigned int u = -1;
+  if (u == -1)
+    {
+      unsigned int n = foo ();
+      if (n > 0)
+	u = n - 1;
+    }
+
+  while (u != -1)
+    {
+      asm ("" : "+g" (u));
+      u = -1;
+      i = 1;
+    }
+
+  if (i)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00044-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00044-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..130a9f77349d1a2fac774808e749e78b7402208a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00044-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr65053-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr65053-1)
+run(pr65053-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00045-Regression-C-gcc-c-torture-execute-GCC-C-execute-20001024-1/20001024-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00045-Regression-C-gcc-c-torture-execute-GCC-C-execute-20001024-1/20001024-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..42be8abca6acf11d8570502e9fd8326521901c5c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00045-Regression-C-gcc-c-torture-execute-GCC-C-execute-20001024-1/20001024-1.c
@@ -0,0 +1,34 @@
+struct a;
+
+extern int baz (struct a *__restrict x);
+
+struct a {
+  long v;
+  long w;
+};
+
+struct b {
+  struct a c;
+  struct a d;
+};
+
+int bar (int x, const struct b *__restrict y, struct b *__restrict z)
+{
+  if (y->c.v || y->c.w != 250000 || y->d.v || y->d.w != 250000)
+    abort();
+}
+
+void foo(void)
+{
+  struct b x;
+  x.c.v = 0;
+  x.c.w = 250000;
+  x.d = x.c;
+  bar(0, &x, ((void *)0));
+}
+
+int main()
+{
+  foo();
+  exit(0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00045-Regression-C-gcc-c-torture-execute-GCC-C-execute-20001024-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00045-Regression-C-gcc-c-torture-execute-GCC-C-execute-20001024-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00045-Regression-C-gcc-c-torture-execute-GCC-C-execute-20001024-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00045-Regression-C-gcc-c-torture-execute-GCC-C-execute-20001024-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..39a92555993fb950a81d556d9cccdb3fb31f33f7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00045-Regression-C-gcc-c-torture-execute-GCC-C-execute-20001024-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20001024-1)
+run(20001024-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00046-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-2/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00046-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00046-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-2/pr52979-2.c b/testsuite/c_test/x64_be_enable_test/LLVM00046-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-2/pr52979-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..91d4fbca8ac5137cb2d333679fa83f7453b65db6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00046-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-2/pr52979-2.c
@@ -0,0 +1,41 @@
+/* PR middle-end/52979 */
+/* { dg-require-effective-target int32plus } */
+
+extern void abort (void);
+int c, d, e;
+
+void
+foo (void)
+{
+}
+
+struct __attribute__((packed)) S { int g : 31; int h : 6; };
+static struct S b = { 1 };
+struct S a = { 1 };
+
+void
+bar (void)
+{
+  a.h = 1;
+  struct S f = { };
+  b = f;
+  e = 0;
+  if (d)
+    c = a.g;
+}
+
+void
+baz (void)
+{
+  bar ();
+  a = b;
+}
+
+int
+main ()
+{
+  baz ();
+  if (a.g)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00046-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-2/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00046-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c32c3cd12ae54ce686a9e125ba448273185c557
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00046-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-2/test.cfg
@@ -0,0 +1,2 @@
+compile(pr52979-2)
+run(pr52979-2)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00047-Regression-C-gcc-c-torture-execute-GCC-C-execute-960608-1/960608-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00047-Regression-C-gcc-c-torture-execute-GCC-C-execute-960608-1/960608-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1f47d02d9d58dac8d3a2f4c094509023c12e8cc7
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00047-Regression-C-gcc-c-torture-execute-GCC-C-execute-960608-1/960608-1.c
@@ -0,0 +1,34 @@
+typedef struct
+{
+  unsigned char a  : 2;
+  unsigned char b  : 3;
+  unsigned char c  : 1;
+  unsigned char d  : 1;
+  unsigned char e  : 1;
+} a_struct;
+
+foo (flags)
+     a_struct *flags;
+{
+  return (flags->c != 0
+	  || flags->d != 1
+	  || flags->e != 1
+	  || flags->a != 2
+	  || flags->b != 3);
+}
+
+main ()
+{
+  a_struct flags;
+
+  flags.c  = 0;
+  flags.d  = 1;
+  flags.e  = 1;
+  flags.a  = 2;
+  flags.b  = 3;
+
+  if (foo (&flags) != 0)
+    abort ();
+  else
+    exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00047-Regression-C-gcc-c-torture-execute-GCC-C-execute-960608-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00047-Regression-C-gcc-c-torture-execute-GCC-C-execute-960608-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00047-Regression-C-gcc-c-torture-execute-GCC-C-execute-960608-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00047-Regression-C-gcc-c-torture-execute-GCC-C-execute-960608-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..181c312c18cd914cacc38edac7343aacfc6f801c
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00047-Regression-C-gcc-c-torture-execute-GCC-C-execute-960608-1/test.cfg
@@ -0,0 +1,2 @@
+compile(960608-1)
+run(960608-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00048-Regression-C-gcc-c-torture-execute-GCC-C-execute-bswap-2/bswap-2.c b/testsuite/c_test/x64_be_enable_test/LLVM00048-Regression-C-gcc-c-torture-execute-GCC-C-execute-bswap-2/bswap-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..63e7807d3d92f317942da9b5b9eb516c4bdbac5d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00048-Regression-C-gcc-c-torture-execute-GCC-C-execute-bswap-2/bswap-2.c
@@ -0,0 +1,136 @@
+/* { dg-require-effective-target int32plus } */
+
+#ifdef __UINT32_TYPE__
+typedef __UINT32_TYPE__ uint32_t;
+#else
+typedef __UINT32_TYPE__ unsigned;
+#endif
+
+struct bitfield {
+  unsigned char f0:7;
+  unsigned char   :1;
+  unsigned char f1:7;
+  unsigned char   :1;
+  unsigned char f2:7;
+  unsigned char   :1;
+  unsigned char f3:7;
+};
+
+struct ok {
+  unsigned char f0;
+  unsigned char f1;
+  unsigned char f2;
+  unsigned char f3;
+};
+
+union bf_or_uint32 {
+  struct ok inval;
+  struct bitfield bfval;
+};
+
+__attribute__ ((noinline, noclone)) uint32_t
+partial_read_le32 (union bf_or_uint32 in)
+{
+  return in.bfval.f0 | (in.bfval.f1 << 8)
+	 | (in.bfval.f2 << 16) | (in.bfval.f3 << 24);
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+partial_read_be32 (union bf_or_uint32 in)
+{
+  return in.bfval.f3 | (in.bfval.f2 << 8)
+	 | (in.bfval.f1 << 16) | (in.bfval.f0 << 24);
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+fake_read_le32 (char *x, char *y)
+{
+  unsigned char c0, c1, c2, c3;
+
+  c0 = x[0];
+  c1 = x[1];
+  *y = 1;
+  c2 = x[2];
+  c3 = x[3];
+  return c0 | c1 << 8 | c2 << 16 | c3 << 24;
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+fake_read_be32 (char *x, char *y)
+{
+  unsigned char c0, c1, c2, c3;
+
+  c0 = x[0];
+  c1 = x[1];
+  *y = 1;
+  c2 = x[2];
+  c3 = x[3];
+  return c3 | c2 << 8 | c1 << 16 | c0 << 24;
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+incorrect_read_le32 (char *x, char *y)
+{
+  unsigned char c0, c1, c2, c3;
+
+  c0 = x[0];
+  c1 = x[1];
+  c2 = x[2];
+  c3 = x[3];
+  *y = 1;
+  return c0 | c1 << 8 | c2 << 16 | c3 << 24;
+}
+
+__attribute__ ((noinline, noclone)) uint32_t
+incorrect_read_be32 (char *x, char *y)
+{
+  unsigned char c0, c1, c2, c3;
+
+  c0 = x[0];
+  c1 = x[1];
+  c2 = x[2];
+  c3 = x[3];
+  *y = 1;
+  return c3 | c2 << 8 | c1 << 16 | c0 << 24;
+}
+
+int
+main ()
+{
+  union bf_or_uint32 bfin;
+  uint32_t out;
+  char cin[] = { 0x83, 0x85, 0x87, 0x89 };
+
+  if (sizeof (uint32_t) * __CHAR_BIT__ != 32)
+    return 0;
+  bfin.inval = (struct ok) { 0x83, 0x85, 0x87, 0x89 };
+  out = partial_read_le32 (bfin);
+  /* Test what bswap would do if its check are not strict enough instead of
+     what is the expected result as there is too many possible results with
+     bitfields.  */
+  if (out == 0x89878583)
+    __builtin_abort ();
+  bfin.inval = (struct ok) { 0x83, 0x85, 0x87, 0x89 };
+  out = partial_read_be32 (bfin);
+  /* Test what bswap would do if its check are not strict enough instead of
+     what is the expected result as there is too many possible results with
+     bitfields.  */
+  if (out == 0x83858789)
+    __builtin_abort ();
+  out = fake_read_le32 (cin, &cin[2]);
+  if (out != 0x89018583)
+    __builtin_abort ();
+  cin[2] = 0x87;
+  out = fake_read_be32 (cin, &cin[2]);
+  if (out != 0x83850189)
+    __builtin_abort ();
+  cin[2] = 0x87;
+  out = incorrect_read_le32 (cin, &cin[2]);
+  if (out != 0x89878583)
+    __builtin_abort ();
+  cin[2] = 0x87;
+  out = incorrect_read_be32 (cin, &cin[2]);
+  if (out != 0x83858789)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00048-Regression-C-gcc-c-torture-execute-GCC-C-execute-bswap-2/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00048-Regression-C-gcc-c-torture-execute-GCC-C-execute-bswap-2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00048-Regression-C-gcc-c-torture-execute-GCC-C-execute-bswap-2/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00048-Regression-C-gcc-c-torture-execute-GCC-C-execute-bswap-2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..78b76bdefe203e70750ff72f6fc7bb9cc5dbe9fb
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00048-Regression-C-gcc-c-torture-execute-GCC-C-execute-bswap-2/test.cfg
@@ -0,0 +1,2 @@
+compile(bswap-2)
+run(bswap-2)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00049-Regression-C-gcc-c-torture-execute-GCC-C-execute-20050203-1/20050203-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00049-Regression-C-gcc-c-torture-execute-GCC-C-execute-20050203-1/20050203-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0b3827794d8aa45d877f7478167914b474129e48
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00049-Regression-C-gcc-c-torture-execute-GCC-C-execute-20050203-1/20050203-1.c
@@ -0,0 +1,29 @@
+/* Reduced testcase extracted from Samba source code.  */
+
+#include <stdlib.h>
+
+static void __attribute__((__noinline__))
+     foo (unsigned char *p) {
+  *p = 0x81;
+}
+
+static void __attribute__((__noinline__))
+     bar (int x) {
+  asm ("");
+}
+
+int main() {
+  unsigned char b;
+
+  foo(&b);
+  if (b & 0x80)
+    {
+      bar (b & 0x7f);
+      exit (0);
+    }
+  else
+    {
+      bar (b & 1);
+      abort ();
+    }
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00049-Regression-C-gcc-c-torture-execute-GCC-C-execute-20050203-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00049-Regression-C-gcc-c-torture-execute-GCC-C-execute-20050203-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00049-Regression-C-gcc-c-torture-execute-GCC-C-execute-20050203-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00049-Regression-C-gcc-c-torture-execute-GCC-C-execute-20050203-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..82e603b952f4a8ecaea41b7ee7d0dab81577acd6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00049-Regression-C-gcc-c-torture-execute-GCC-C-execute-20050203-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20050203-1)
+run(20050203-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00050-Regression-C-gcc-c-torture-execute-GCC-C-execute-20021118-1/20021118-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00050-Regression-C-gcc-c-torture-execute-GCC-C-execute-20021118-1/20021118-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c1f800de76f84e1fef0fb0ec307cd85f0319b0a
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00050-Regression-C-gcc-c-torture-execute-GCC-C-execute-20021118-1/20021118-1.c
@@ -0,0 +1,15 @@
+struct s { int f[4]; };
+
+int foo (struct s s, int x1, int x2, int x3, int x4, int x5, int x6, int x7)
+{
+  return s.f[3] + x7;
+}
+
+int main ()
+{
+  struct s s = { 1, 2, 3, 4 };
+
+  if (foo (s, 100, 200, 300, 400, 500, 600, 700) != 704)
+    abort ();
+  exit (0);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00050-Regression-C-gcc-c-torture-execute-GCC-C-execute-20021118-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00050-Regression-C-gcc-c-torture-execute-GCC-C-execute-20021118-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00050-Regression-C-gcc-c-torture-execute-GCC-C-execute-20021118-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00050-Regression-C-gcc-c-torture-execute-GCC-C-execute-20021118-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b7bc103b283e35c51efdb09ab22f1e84ae1c447d
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00050-Regression-C-gcc-c-torture-execute-GCC-C-execute-20021118-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20021118-1)
+run(20021118-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00051-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40022/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00051-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40022/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00051-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40022/pr40022.c b/testsuite/c_test/x64_be_enable_test/LLVM00051-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40022/pr40022.c
new file mode 100644
index 0000000000000000000000000000000000000000..6dd04e2b18890639a302f94ddc82b03f1b3187a6
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00051-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40022/pr40022.c
@@ -0,0 +1,50 @@
+extern void abort (void);
+
+struct A
+{
+  struct A *a;
+};
+
+struct B
+{
+  struct A *b;
+};
+
+__attribute__((noinline))
+struct A *
+foo (struct A *x)
+{
+  asm volatile ("" : : "g" (x) : "memory");
+  return x;
+}
+
+__attribute__((noinline))
+void
+bar (struct B *w, struct A *x, struct A *y, struct A *z)
+{
+  struct A **c;
+  c = &w->b;
+  *c = foo (x);
+  while (*c)
+    c = &(*c)->a;
+  *c = foo (y);
+  while (*c)
+    c = &(*c)->a;
+  *c = foo (z);
+}
+
+struct B d;
+struct A e, f, g;
+
+int
+main (void)
+{
+  f.a = &g;
+  bar (&d, &e, &f, 0);
+  if (d.b == 0
+      || d.b->a == 0
+      || d.b->a->a == 0
+      || d.b->a->a->a != 0)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00051-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40022/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00051-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40022/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1cc8ee1c72a541abaf0dd1290719ca2b6d90ca81
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00051-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr40022/test.cfg
@@ -0,0 +1,2 @@
+compile(pr40022)
+run(pr40022)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00052-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00052-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00052-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-1/pr52979-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00052-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-1/pr52979-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..13ecb7933548a93c03d1a37ebc4bd0b2d68a20f2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00052-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-1/pr52979-1.c
@@ -0,0 +1,42 @@
+/* PR middle-end/52979 */
+
+/* { dg-require-effective-target int32plus } */
+
+extern void abort (void);
+int c, d, e;
+
+void
+foo (void)
+{
+}
+
+struct __attribute__((packed)) S { int g : 31; int h : 6; };
+struct S a = { 1 };
+static struct S b = { 1 };
+
+void
+bar (void)
+{
+  a.h = 1;
+  struct S f = { };
+  b = f;
+  e = 0;
+  if (d)
+    c = a.g;
+}
+
+void
+baz (void)
+{
+  bar ();
+  a = b;
+}
+
+int
+main ()
+{
+  baz ();
+  if (a.g)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00052-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00052-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..104eb97ff2fa2699144cd8c3c69e39035a765be2
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00052-Regression-C-gcc-c-torture-execute-GCC-C-execute-pr52979-1/test.cfg
@@ -0,0 +1,2 @@
+compile(pr52979-1)
+run(pr52979-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00053-Regression-C-gcc-c-torture-execute-GCC-C-execute-20080117-1/20080117-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00053-Regression-C-gcc-c-torture-execute-GCC-C-execute-20080117-1/20080117-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c9f3387428daa1ded00f25e0f437e4838e218e1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00053-Regression-C-gcc-c-torture-execute-GCC-C-execute-20080117-1/20080117-1.c
@@ -0,0 +1,23 @@
+typedef struct gs_imager_state_s {
+  struct {
+    int half_width;
+    int cap;
+    float miter_limit;
+  } line_params;
+} gs_imager_state;
+static const gs_imager_state gstate_initial = { { 1 } };
+void gstate_path_memory(gs_imager_state *pgs) {
+  *pgs = gstate_initial;
+}
+int gs_state_update_overprint(void)
+{
+  return gstate_initial.line_params.half_width;
+}
+
+extern void abort (void);
+int main()
+{
+  if (gs_state_update_overprint() != 1)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00053-Regression-C-gcc-c-torture-execute-GCC-C-execute-20080117-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00053-Regression-C-gcc-c-torture-execute-GCC-C-execute-20080117-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00053-Regression-C-gcc-c-torture-execute-GCC-C-execute-20080117-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00053-Regression-C-gcc-c-torture-execute-GCC-C-execute-20080117-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ed44a3d194bc6fd5ff46cd9cf0a38612357ac3f8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00053-Regression-C-gcc-c-torture-execute-GCC-C-execute-20080117-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20080117-1)
+run(20080117-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00054-Regression-C-gcc-c-torture-execute-GCC-C-execute-20041218-1/20041218-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00054-Regression-C-gcc-c-torture-execute-GCC-C-execute-20041218-1/20041218-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d113e4557cae2e21e0374bef400d227f7f1cff1
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00054-Regression-C-gcc-c-torture-execute-GCC-C-execute-20041218-1/20041218-1.c
@@ -0,0 +1,117 @@
+/* PR rtl-optimization/16968 */
+/* Testcase by Jakub Jelinek  <jakub@redhat.com> */
+
+struct T
+{
+  unsigned int b, c, *d;
+  unsigned char e;
+};
+struct S
+{
+  unsigned int a;
+  struct T f;
+};
+struct U
+{
+  struct S g, h;
+};
+struct V
+{
+  unsigned int i;
+  struct U j;
+};
+
+extern void exit (int);
+extern void abort (void);
+
+void *
+dummy1 (void *x)
+{
+  return "";
+}
+
+void *
+dummy2 (void *x, void *y)
+{
+  exit (0);
+}
+
+struct V *
+baz (unsigned int x)
+{
+  static struct V v;
+  __builtin_memset (&v, 0x55, sizeof (v));
+  return &v;
+}
+
+int
+check (void *x, struct S *y)
+{
+  if (y->a || y->f.b || y->f.c || y->f.d || y->f.e)
+    abort ();
+  return 1;
+}
+
+static struct V *
+bar (unsigned int x, void *y)
+{
+  const struct T t = { 0, 0, (void *) 0, 0 };
+  struct V *u;
+  void *v;
+  v = dummy1 (y);
+  if (!v)
+    return (void *) 0;
+
+  u = baz (sizeof (struct V));
+  u->i = x;
+  u->j.g.a = 0;
+  u->j.g.f = t;
+  u->j.h.a = 0;
+  u->j.h.f = t;
+
+  if (!check (v, &u->j.g) || !check (v, &u->j.h))
+    return (void *) 0;
+  return u;
+}
+
+int
+foo (unsigned int *x, unsigned int y, void **z)
+{
+  void *v;
+  unsigned int i, j;
+
+  *z = v = (void *) 0;
+
+  for (i = 0; i < y; i++)
+    {
+      struct V *c;
+
+      j = *x;
+
+      switch (j)
+	{
+	case 1:
+	  c = bar (j, x);
+	  break;
+	default:
+	  c = 0;
+	  break;
+	}
+      if (c)
+	v = dummy2 (v, c);
+      else
+        return 1;
+    }
+
+  *z = v;
+  return 0;
+}
+
+int
+main (void)
+{
+  unsigned int one = 1;
+  void *p;
+  foo (&one, 1, &p);
+  abort ();
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00054-Regression-C-gcc-c-torture-execute-GCC-C-execute-20041218-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00054-Regression-C-gcc-c-torture-execute-GCC-C-execute-20041218-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00054-Regression-C-gcc-c-torture-execute-GCC-C-execute-20041218-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00054-Regression-C-gcc-c-torture-execute-GCC-C-execute-20041218-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..20037601339f14775523d5b8d67bfaaeb0883acf
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00054-Regression-C-gcc-c-torture-execute-GCC-C-execute-20041218-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20041218-1)
+run(20041218-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00055-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071202-1/20071202-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00055-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071202-1/20071202-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..14fb8ec352e80e709589f3fee55f0ce13dc64908
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00055-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071202-1/20071202-1.c
@@ -0,0 +1,25 @@
+extern void abort (void);
+struct T { int t; int r[8]; };
+struct S { int a; int b; int c[6]; struct T d; };
+
+__attribute__((noinline)) void
+foo (struct S *s)
+{
+  *s = (struct S) { s->b, s->a, { 0, 0, 0, 0, 0, 0 }, s->d };
+}
+
+int
+main (void)
+{
+  struct S s = { 6, 12, { 1, 2, 3, 4, 5, 6 },
+		 { 7, { 8, 9, 10, 11, 12, 13, 14, 15 } } };
+  foo (&s);
+  if (s.a != 12 || s.b != 6
+      || s.c[0] || s.c[1] || s.c[2] || s.c[3] || s.c[4] || s.c[5])
+    abort ();
+  if (s.d.t != 7 || s.d.r[0] != 8 || s.d.r[1] != 9 || s.d.r[2] != 10
+      || s.d.r[3] != 11 || s.d.r[4] != 12 || s.d.r[5] != 13
+      || s.d.r[6] != 14 || s.d.r[7] != 15)
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00055-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071202-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00055-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071202-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00055-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071202-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00055-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071202-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..287f0b3c6315e04460dfae3245d09f6871d66143
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00055-Regression-C-gcc-c-torture-execute-GCC-C-execute-20071202-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20071202-1)
+run(20071202-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00056-Regression-C-gcc-c-torture-execute-GCC-C-execute-20081117-1/20081117-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00056-Regression-C-gcc-c-torture-execute-GCC-C-execute-20081117-1/20081117-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8fa00d2f9537d82c213a5a7f14a0ed4ce0f5b919
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00056-Regression-C-gcc-c-torture-execute-GCC-C-execute-20081117-1/20081117-1.c
@@ -0,0 +1,25 @@
+/* { dg-require-effective-target int32plus } */
+extern void abort (void);
+
+struct s
+{
+  unsigned long long a:16;
+  unsigned long long b:32;
+  unsigned long long c:16;
+};
+
+__attribute__ ((noinline)) unsigned
+f (struct s s, unsigned i)
+{
+  return s.b == i;
+}
+
+struct s s = { 1, 0x87654321u, 2};
+
+int
+main ()
+{
+  if (!f (s, 0x87654321u))
+    abort ();
+  return 0;
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00056-Regression-C-gcc-c-torture-execute-GCC-C-execute-20081117-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00056-Regression-C-gcc-c-torture-execute-GCC-C-execute-20081117-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00056-Regression-C-gcc-c-torture-execute-GCC-C-execute-20081117-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00056-Regression-C-gcc-c-torture-execute-GCC-C-execute-20081117-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..90dcfff7734cf8db8580e952af5b7372232db1f5
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00056-Regression-C-gcc-c-torture-execute-GCC-C-execute-20081117-1/test.cfg
@@ -0,0 +1,2 @@
+compile(20081117-1)
+run(20081117-1)
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00057-Regression-C-gcc-c-torture-execute-GCC-C-execute-981130-1/981130-1.c b/testsuite/c_test/x64_be_enable_test/LLVM00057-Regression-C-gcc-c-torture-execute-GCC-C-execute-981130-1/981130-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c672b5d6c3ef6b9533c8a7a67109bd1828daa9f8
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00057-Regression-C-gcc-c-torture-execute-GCC-C-execute-981130-1/981130-1.c
@@ -0,0 +1,29 @@
+/* { dg-xfail-if "alias analysis conflicts with instruction scheduling" { m32r-*-* } { "-O2" "-O1" "-O0" "-Os"} { "" } } */
+struct s { int a; int b;};
+struct s s1;
+struct s s2 = { 1, 2, };
+
+void
+check (a, b)
+     int a;
+     int b;
+{
+  if (a == b)
+    exit (0);
+  else
+    abort ();
+}
+
+int
+main ()
+{
+  int * p;
+  int x;
+
+  s1.a = 9;
+  p    = & s1.a;
+  s1   = s2;
+  x    = * p;
+
+  check (x, 1);
+}
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00057-Regression-C-gcc-c-torture-execute-GCC-C-execute-981130-1/expected.txt b/testsuite/c_test/x64_be_enable_test/LLVM00057-Regression-C-gcc-c-torture-execute-GCC-C-execute-981130-1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/c_test/x64_be_enable_test/LLVM00057-Regression-C-gcc-c-torture-execute-GCC-C-execute-981130-1/test.cfg b/testsuite/c_test/x64_be_enable_test/LLVM00057-Regression-C-gcc-c-torture-execute-GCC-C-execute-981130-1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f0bf2406dc6deda8006636aa040a1f8a6940fe0
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/LLVM00057-Regression-C-gcc-c-torture-execute-GCC-C-execute-981130-1/test.cfg
@@ -0,0 +1,2 @@
+compile(981130-1)
+run(981130-1)
diff --git a/testsuite/c_test/x64_be_enable_test/compiler.sh b/testsuite/c_test/x64_be_enable_test/compiler.sh
new file mode 100755
index 0000000000000000000000000000000000000000..727bc5be6623fe481288ed373d0d57e278c02370
--- /dev/null
+++ b/testsuite/c_test/x64_be_enable_test/compiler.sh
@@ -0,0 +1,155 @@
+#!/bin/bash
+
+check_error()
+{
+  error_no=$?
+  if [ $error_no != 0 ];then
+    exit $error_no
+  fi
+}
+
+init_env()
+{
+  if [ -f multiprocess.sh ]; then
+    source multiprocess.sh
+    MultiProcessInit
+  fi
+}
+
+check_env()
+{
+  if [ ! -n ${MAPLE_ROOT} ];then
+     echo "plz cd to maple root dir and source build/envsetup.sh arm release/debug"
+     exit -2
+  fi
+
+  if [ ! -f ${BIN_MPLFE} ] || [ ! -f ${BIN_MAPLE} ];then
+     echo "plz make to ${MAPLE_ROOT} and make tool chain first!!!"
+     exit -3
+  fi
+}
+
+init_parameter()
+{
+ OUT="a.out"
+ LINK_OPTIONS=
+ BIN_MPLFE=${MAPLE_BUILD_OUTPUT}/bin/hir2mpl
+ BIN_MAPLE=${MAPLE_BUILD_OUTPUT}/bin/maple
+ BIN_CLANG=${MAPLE_ROOT}/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/clang
+ OPT_LEVEL="-O0"
+ DEBUG="false"
+ DEBUG_OPTION=
+ CFLAGS=
+}
+
+prepare_options()
+{
+ if [ "${DEBUG}" == "true" ]; then
+   # inline may delete func node and didn't update debug info, it'll cause debug info error when linking
+   DEBUG_OPTION="-g --mpl2mpl-opt=--skip-phase=inline"
+ fi
+}
+
+# $1 cfilePath
+# $2 cfileName
+generate_ast()
+{
+  set -x
+  $BIN_CLANG ${CFLAGS} -I ${MAPLE_BUILD_OUTPUT}/lib/include -I ${OUT_ROOT}/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04/lib/clang/12.0.0/include  --target=x86_64 -U __SIZEOF_INT128__ -emit-ast $1 -o "$2.ast"
+  check_error
+  set +x
+}
+
+# $1 cfileName
+generate_mpl()
+{
+  set -x
+  ${BIN_MPLFE} "$1.ast" -o "${1}_mplfe.mpl"
+  check_error
+  set +x
+}
+
+# $1 cfileName
+generate_s()
+{
+  set -x
+  ${BIN_MAPLE} ${OPT_LEVEL} ${DEBUG_OPTION} --mplcg-opt="--verbose-asm --verbose-cg" --genVtableImpl --save-temps "${1}_mplfe.mpl"
+  check_error
+  set +x
+}
+
+# $@ sFilePaths
+link()
+{
+  set -x
+  $BIN_CLANG ${OPT_LEVEL} ${LINK_OPTIONS} -o $OUT $@
+  check_error
+  set +x
+}
+
+help()
+{
+  echo
+  echo "USAGE"
+  echo "    ./compile.sh [options=...] files..."
+  echo
+  echo "EXAMPLE"
+  echo "    ./compile.sh out=test.out ldflags=\"-lm -pthread\" test1.c test2.c"
+  echo
+  echo "OPTIONS"
+  echo "    out:           binary output path, default is a.out"
+  echo "    ldflags:       ldflags"
+  echo "    optlevel:      -O0 -O1 -O2(default)"
+  echo "    debug:         true(-g), false(default)"
+  echo "    cflags:        cflags"
+  echo "    help:          print help"
+  echo
+  exit -1
+}
+
+parse_cmdline()
+{
+ while [ -n "$1" ]
+ do
+   OPTIONS=`echo "$1" | sed 's/\(.*\)=\(.*\)/\1/'`
+   PARAM=`echo "$1" | sed 's/.*=//'`
+   case "$OPTIONS" in
+   out) OUT=$PARAM;;
+   ldflags) LINK_OPTIONS=$PARAM;;
+   optlevel) OPT_LEVEL=$PARAM;;
+   debug) DEBUG=$PARAM;;
+   cflags) CFLAGS=$PARAM;;
+   help) help;;
+   *) if [ `echo "$1" | sed -n '/.*=/p'` ];then
+        echo "Error!!! the parttern \"$OPTIONS=$PARAM\" can not be recognized!!!"
+        help;
+      fi
+      break;;
+   esac
+   shift
+ done
+ files=$@
+ if [ ! -n "$files" ];then
+    help
+ fi
+}
+
+main()
+{
+ init_env
+ init_parameter
+ check_env
+ parse_cmdline $@
+ prepare_options
+ s_files=`echo ${files}|sed 's\\.c$\_mplfe.s\g'`
+ for i in $files
+ do
+   fileName=${i//.c/}
+   generate_ast $i $fileName
+   generate_mpl $fileName
+   generate_s $fileName
+ done
+ link $s_files
+}
+
+main $@ 2>&1 | tee log.txt
diff --git a/testsuite/driver/config/ci_testall.conf b/testsuite/driver/config/ci_testall.conf
new file mode 100755
index 0000000000000000000000000000000000000000..1035305802c4273536e7e7ab29b301a29e18ef73
--- /dev/null
+++ b/testsuite/driver/config/ci_testall.conf
@@ -0,0 +1,477 @@
+[MODE_SET]
+    java_common_mode_set: O0, O2, GC_O0, GC_O2
+    c_common_mode_set: CO0, CO2
+    c_driver_mode_set: DRIVER
+
+[DEFAULT_TEST_SUITE]
+    c_test/ast_test: ASTO0, ASTO2
+    c_test/sanity_test: c_common_mode_set
+    c_test/gtorture_test: c_common_mode_set
+    c_test/unit_test: CO2
+    c_test/driver_test: c_driver_mode_set
+    java_test/app_test: java_common_mode_set
+    java_test/arrayboundary_test: java_common_mode_set
+    java_test/clinit_test: java_common_mode_set
+    java_test/compact_test: java_common_mode_set
+    java_test/eh_test: java_common_mode_set
+    java_test/fuzzapi_test: java_common_mode_set
+    java_test/other_test: java_common_mode_set
+    java_test/parent_test: java_common_mode_set
+    java_test/rc_test: java_common_mode_set
+    java_test/reflection_test: java_common_mode_set
+    java_test/stmtpre_test: java_common_mode_set
+    java_test/string_test: java_common_mode_set
+    java_test/subsumeRC_test: java_common_mode_set
+    java_test/thread_test: java_common_mode_set
+    java_test/unsafe_test: java_common_mode_set
+    java_test/gconly_test: GC_O0, GC_O2
+    irbuild_test: IR
+
+[BAN_TEST_SUITE]
+    java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable: GC_O0, GC_O2
+    java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest: GC_O0, GC_O2
+    java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest: GC_O0, GC_O2
+    java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet: GC_O0, GC_O2
+    java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest: GC_O0, GC_O2
+    java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable: GC_O0, GC_O2
+    java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet: GC_O0, GC_O2
+    java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread: GC_O0, GC_O2
+    java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread: GC_O0, GC_O2
+    java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter: GC_O0, GC_O2
+    java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest: GC_O0, GC_O2
+    java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet: GC_O0, GC_O2
+    java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet: GC_O0, GC_O2
+    java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest: GC_O0, GC_O2
+    java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter: GC_O0, GC_O2
+    java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest: GC_O0, GC_O2
+    java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest: GC_O0, GC_O2
+    java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest: GC_O0, GC_O2
+    java_test/gconly_test/GC0008-GCOnly_WeakRefTest08: GC_O0, GC_O2
+    java_test/gconly_test/GC0009-GCOnly_ThreadList01: GC_O0, GC_O2
+    irbuild_test/I0062-mapleall-irbuild-edge-pregs: IR
+    java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest: O0, GC_O0, GC_O2
+    java_test/other_test/RT0008-rt-other-PassingFloat: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest: O0, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest: O0, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04: O0
+    java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06: O0, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest: O0, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02: O0, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03: O0, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06: O0, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07: O0, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040: O0
+    java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030: O0
+    java_test/rc_test/RC0248-rc-function-RC_Finalize_02: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0249-rc-function-RC_Finalize_03: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0338-rc-Memory-normalTestCase28: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0339-rc-rp-cycle_all_weak: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0340-rc-rp-cycle_weak_strong: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0341-rc-rp-mutator: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0342-rc-rp-weak_ref_boundary: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0343-rc-rp-wcb_test_ref: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0344-rc-rp-test_aged_ref: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0345-rc-rp-single_or_more: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0346-rc-rp-strong_and_weak: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0347-rc-rp-simulthread: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0348-rc-rp-simpleweakref_01: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0349-rc-rp-simpleweakref_02: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0350-rc-rp-simpleweakref_03: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0351-rc-rp-simpleweakref_04: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0352-rc-rp-simpleweakref_05: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0353-rc-rp-simpleweakref_06: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0354-rc-rp-simpleweakref_07: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0355-rc-rp-simpleweakref_08: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0356-rc-rp-simpleweakref_09: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0357-rc-rp-simpleweakref_10: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0358-rc-rp-simpleweakref_11: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0359-rc-rp-simpleweakref_12: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0457-rc-GC-TriggerGCTest01: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0458-rc-GC-TriggerGCTest02: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0459-rc-GC-TriggerGCTest03: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0463-rc-GC-TriggerGCTest07: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0464-rc-GC-TriggerGCTest08: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0465-rc-GC-TriggerGCTest09: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0466-rc-GC-TriggerGCTest10: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01: O0, GC_O0, GC_O2
+    java_test/rc_test/RC0515-GC-FrequentGCTest01: O0, GC_O0, GC_O2
+    java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest: O0, GC_O0, GC_O2
+    java_test/thread_test/RT0086-rt-thread-ThreadStatewait1: O0
+    java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating: O0
+    java_test/thread_test/RT0200-rt-thread-TestSynchronized: O0
+    java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest: O2
+    java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest: O0, O2, GC_O0, GC_O2
+    java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest: O0, O2, GC_O0, GC_O2
+    java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest: O0, O2, GC_O0, GC_O2
+    java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest: O0, O2, GC_O0, GC_O2
+    java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest: O0, O2, GC_O0, GC_O2
+    java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest: O0, O2, GC_O0, GC_O2
+    java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest: O0, O2, GC_O0, GC_O2
+    java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest: O2
+    java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest: O2
+    java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04: O2
+    java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06: O2
+    java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest: O2
+    java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02: O2
+    java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03: O2
+    java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06: O2
+    java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07: O2
+    java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03: O2
+    java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2: O0, O2, GC_O0, GC_O2
+    java_test/rc_test/RC0248-rc-function-RC_Finalize_02: O2
+    java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B: O2
+    java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2: O2
+    java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest: O2
+    java_test/rc_test/RC0338-rc-Memory-normalTestCase28: O2
+    java_test/rc_test/RC0339-rc-rp-cycle_all_weak: O2
+    java_test/rc_test/RC0340-rc-rp-cycle_weak_strong: O2
+    java_test/rc_test/RC0341-rc-rp-mutator: O2
+    java_test/rc_test/RC0342-rc-rp-weak_ref_boundary: O2
+    java_test/rc_test/RC0343-rc-rp-wcb_test_ref: O2
+    java_test/rc_test/RC0344-rc-rp-test_aged_ref: O2
+    java_test/rc_test/RC0345-rc-rp-single_or_more: O2
+    java_test/rc_test/RC0346-rc-rp-strong_and_weak: O2
+    java_test/rc_test/RC0347-rc-rp-simulthread: O2
+    java_test/rc_test/RC0348-rc-rp-simpleweakref_01: O2
+    java_test/rc_test/RC0349-rc-rp-simpleweakref_02: O2
+    java_test/rc_test/RC0350-rc-rp-simpleweakref_03: O2
+    java_test/rc_test/RC0351-rc-rp-simpleweakref_04: O2
+    java_test/rc_test/RC0352-rc-rp-simpleweakref_05: O2
+    java_test/rc_test/RC0353-rc-rp-simpleweakref_06: O2
+    java_test/rc_test/RC0354-rc-rp-simpleweakref_07: O2
+    java_test/rc_test/RC0355-rc-rp-simpleweakref_08: O2
+    java_test/rc_test/RC0356-rc-rp-simpleweakref_09: O2
+    java_test/rc_test/RC0357-rc-rp-simpleweakref_10: O2
+    java_test/rc_test/RC0358-rc-rp-simpleweakref_11: O2
+    java_test/rc_test/RC0359-rc-rp-simpleweakref_12: O2
+    java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01: O2
+    java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02: O2
+    java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03: O2
+    java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04: O2
+    java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05: O2
+    java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06: O2
+    java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest: O2
+    java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2: O2
+    java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4: O2
+    java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest: O2
+    java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest: O2
+    java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2: O2
+    java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle: O2
+    java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread: O2
+    java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02: O2
+    java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04: O2
+    java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05: O2
+    java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle: O2
+    java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread: O2
+    java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle: O2
+    java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2: O2
+    java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread: O2
+    java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2: O2
+    java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle: O2
+    java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2: O2
+    java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread: O2
+    java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2: O2
+    java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3: O2
+    java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3: O2
+    java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest: O2
+    java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest: O2
+    java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest: O2
+    java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03: O2
+    java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04: O2
+    java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01: O2
+    java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02: O2
+    java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04: O2
+    java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01: O2
+    java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02: O2
+    java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03: O2
+    java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04: O2
+    java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05: O2
+    java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06: O2
+    java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07: O2
+    java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08: O2
+    java_test/rc_test/RC0457-rc-GC-TriggerGCTest01: O2
+    java_test/rc_test/RC0458-rc-GC-TriggerGCTest02: O2
+    java_test/rc_test/RC0459-rc-GC-TriggerGCTest03: O2
+    java_test/rc_test/RC0463-rc-GC-TriggerGCTest07: O2
+    java_test/rc_test/RC0464-rc-GC-TriggerGCTest08: O2
+    java_test/rc_test/RC0465-rc-GC-TriggerGCTest09: O2
+    java_test/rc_test/RC0466-rc-GC-TriggerGCTest10: O2
+    java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01: O2
+    java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02: O2
+    java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01: O2
+    java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01: O2
+    java_test/rc_test/RC0515-GC-FrequentGCTest01: O2
+    java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest: O2
+    java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest: O0
+    java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest: O0
+    java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest: O0
+    java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest: O0
+    java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest: O0
+    java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest: O0
+    java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest: O0
+    java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest: O0
+    java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest: O0
+    java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread: O0
+    java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter: O0
+    java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable: O0
+    java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet: O0
+    java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet: O0
+    java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080: O0
+    java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest: O0
+    java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest: O0
+    java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest: O0
+    java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest: O0
+    java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest: O0
+    java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest: O0
+    java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest: O0
+    java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest: O0
+    java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest: O0
+    java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread: O0
+    java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter: O0
+    java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable: O0
+    java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet: O0
+    java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet: O0
+    java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest: O0
+
+    #clang compiler error
+    c_test/gtorture_test/GCC00061-g.torture.execute-20000822-1: CO0, CO2
+    c_test/gtorture_test/GCC00098-g.torture.execute-20010209-1: CO0, CO2
+    c_test/gtorture_test/GCC00111-g.torture.execute-20010605-1: CO0, CO2
+    c_test/gtorture_test/GCC00165-g.torture.execute-20020412-1: CO0, CO2
+    c_test/gtorture_test/GCC00229-g.torture.execute-20030501-1: CO0, CO2
+    c_test/gtorture_test/GCC00268-g.torture.execute-20040308-1: CO0, CO2
+    c_test/gtorture_test/GCC00281-g.torture.execute-20040423-1: CO0, CO2
+    c_test/gtorture_test/GCC00282-g.torture.execute-20040520-1: CO0, CO2
+    c_test/gtorture_test/GCC00313-g.torture.execute-20041218-2: CO0, CO2
+    c_test/gtorture_test/GCC00362-g.torture.execute-20061220-1: CO0, CO2
+    c_test/gtorture_test/GCC00373-g.torture.execute-20070919-1: CO0, CO2
+    c_test/gtorture_test/GCC00411-g.torture.execute-20090219-1: CO0, CO2
+    c_test/gtorture_test/GCC00472-g.torture.execute-920415-1: CO0, CO2
+    c_test/gtorture_test/GCC00474-g.torture.execute-920428-2: CO0, CO2
+    c_test/gtorture_test/GCC00482-g.torture.execute-920501-7: CO0, CO2
+    c_test/gtorture_test/GCC00490-g.torture.execute-920612-2: CO0, CO2
+    c_test/gtorture_test/GCC00498-g.torture.execute-920721-4: CO0, CO2
+    c_test/gtorture_test/GCC00515-g.torture.execute-921017-1: CO0, CO2
+    c_test/gtorture_test/GCC00533-g.torture.execute-921215-1: CO0, CO2
+    c_test/gtorture_test/GCC00573-g.torture.execute-931002-1: CO0, CO2
+    c_test/gtorture_test/GCC00720-g.torture.execute-990413-2: CO0, CO2
+    c_test/gtorture_test/GCC00735-g.torture.execute-991014-1: CO0, CO2
+    c_test/gtorture_test/GCC00761-g.torture.execute-align-nest: CO0, CO2
+    c_test/gtorture_test/GCC00807-g.torture.execute-comp-goto-2: CO0, CO2
+    c_test/gtorture_test/GCC00897-g.torture.execute-nest-align-1: CO0, CO2
+    c_test/gtorture_test/GCC00898-g.torture.execute-nestfunc-1: CO0, CO2
+    c_test/gtorture_test/GCC00899-g.torture.execute-nestfunc-2: CO0, CO2
+    c_test/gtorture_test/GCC00900-g.torture.execute-nestfunc-3: CO0, CO2
+    c_test/gtorture_test/GCC00902-g.torture.execute-nestfunc-5: CO0, CO2
+    c_test/gtorture_test/GCC00903-g.torture.execute-nestfunc-6: CO0, CO2
+    c_test/gtorture_test/GCC00904-g.torture.execute-nestfunc-7: CO0, CO2
+    c_test/gtorture_test/GCC00905-g.torture.execute-nest-stdar-1: CO0, CO2
+    c_test/gtorture_test/GCC00938-g.torture.execute-pr22061-3: CO0, CO2
+    c_test/gtorture_test/GCC00939-g.torture.execute-pr22061-4: CO0, CO2
+    c_test/gtorture_test/GCC00955-g.torture.execute-pr24135: CO0, CO2
+    c_test/gtorture_test/GCC00971-g.torture.execute-pr28865: CO0, CO2
+    c_test/gtorture_test/GCC01069-g.torture.execute-pr41935: CO0, CO2
+    c_test/gtorture_test/GCC01115-g.torture.execute-pr47237: CO0, CO2
+    c_test/gtorture_test/GCC01145-g.torture.execute-pr51447: CO0, CO2
+    c_test/gtorture_test/GCC01225-g.torture.execute-pr60003: CO0, CO2
+    c_test/gtorture_test/GCC01318-g.torture.execute-pr71494: CO0, CO2
+    c_test/gtorture_test/GCC01322-g.torture.execute-pr71626-2: CO0, CO2
+    c_test/gtorture_test/GCC01355-g.torture.execute-pr80692: CO0, CO2
+    c_test/gtorture_test/GCC01364-g.torture.execute-pr82210: CO0, CO2
+    c_test/gtorture_test/GCC01383-g.torture.execute-pr85331: CO0, CO2
+    c_test/gtorture_test/GCC01438-g.torture.execute-pr94591: CO0, CO2
+    c_test/gtorture_test/GCC01553-g.torture.execute-va-arg-pack-1: CO0, CO2
+
+    #hir2mpl compiler error
+    c_test/gtorture_test/GCC00153-g.torture.execute-20020227-1: CO0, CO2
+    c_test/gtorture_test/GCC00164-g.torture.execute-20020411-1: CO0, CO2
+    c_test/gtorture_test/GCC00305-g.torture.execute-20041124-1: CO0, CO2
+    c_test/gtorture_test/GCC00307-g.torture.execute-20041201-1: CO0, CO2
+    c_test/gtorture_test/GCC00328-g.torture.execute-20050316-1: CO0, CO2
+    c_test/gtorture_test/GCC00329-g.torture.execute-20050316-2: CO0, CO2
+    c_test/gtorture_test/GCC00330-g.torture.execute-20050316-3: CO0, CO2
+    c_test/gtorture_test/GCC00334-g.torture.execute-20050604-1: CO0, CO2
+    c_test/gtorture_test/GCC00335-g.torture.execute-20050607-1: CO0, CO2
+    c_test/gtorture_test/GCC00353-g.torture.execute-20060420-1: CO0, CO2
+    c_test/gtorture_test/GCC00369-g.torture.execute-20070614-1: CO0, CO2
+    c_test/gtorture_test/GCC00656-g.torture.execute-960512-1: CO0, CO2
+    c_test/gtorture_test/GCC00787-g.torture.execute-builtin-bitops-1: CO0, CO2
+    c_test/gtorture_test/GCC00809-g.torture.execute-complex-2: CO0, CO2
+    c_test/gtorture_test/GCC00812-g.torture.execute-complex-5: CO0, CO2
+    c_test/gtorture_test/GCC00813-g.torture.execute-complex-6: CO0, CO2
+    c_test/gtorture_test/GCC00814-g.torture.execute-complex-7: CO0, CO2
+    c_test/gtorture_test/GCC00950-g.torture.execute-pr23135: CO0, CO2
+    c_test/gtorture_test/GCC01038-g.torture.execute-pr38151: CO0, CO2
+    c_test/gtorture_test/GCC01138-g.torture.execute-pr49644: CO0, CO2
+    c_test/gtorture_test/GCC01160-g.torture.execute-pr53645-2: CO0, CO2
+    c_test/gtorture_test/GCC01161-g.torture.execute-pr53645: CO0, CO2
+    c_test/gtorture_test/GCC01173-g.torture.execute-pr56837: CO0, CO2
+    c_test/gtorture_test/GCC01231-g.torture.execute-pr60960: CO0, CO2
+    c_test/gtorture_test/GCC01268-g.torture.execute-pr65427: CO0, CO2
+    c_test/gtorture_test/GCC01315-g.torture.execute-pr70903: CO0, CO2
+    c_test/gtorture_test/GCC01321-g.torture.execute-pr71626-1: CO0, CO2
+    c_test/gtorture_test/GCC01382-g.torture.execute-pr85169: CO0, CO2
+    c_test/gtorture_test/GCC01419-g.torture.execute-pr92618: CO0, CO2
+    c_test/gtorture_test/GCC01434-g.torture.execute-pr94412: CO0, CO2
+    c_test/gtorture_test/GCC01435-g.torture.execute-pr94524-1: CO0, CO2
+    c_test/gtorture_test/GCC01436-g.torture.execute-pr94524-2: CO0, CO2
+    c_test/gtorture_test/GCC01477-g.torture.execute-scal-to-vec1: CO0, CO2
+    c_test/gtorture_test/GCC01478-g.torture.execute-scal-to-vec2: CO0, CO2
+    c_test/gtorture_test/GCC01479-g.torture.execute-scal-to-vec3: CO0, CO2
+    c_test/gtorture_test/GCC01484-g.torture.execute-simd-1: CO0, CO2
+    c_test/gtorture_test/GCC01485-g.torture.execute-simd-2: CO0, CO2
+    c_test/gtorture_test/GCC01486-g.torture.execute-simd-4: CO0, CO2
+    c_test/gtorture_test/GCC01487-g.torture.execute-simd-5: CO0, CO2
+    c_test/gtorture_test/GCC01488-g.torture.execute-simd-6: CO0, CO2
+
+    #maple compiler error
+    c_test/gtorture_test/GCC01074-g.torture.execute-pr42248: CO0, CO2
+
+    #linker error
+    c_test/gtorture_test/GCC00094-g.torture.execute-20010122-1: CO0, CO2
+    c_test/gtorture_test/GCC00167-g.torture.execute-20020418-1: CO0, CO2
+    c_test/gtorture_test/GCC00223-g.torture.execute-20030323-1: CO0, CO2
+    c_test/gtorture_test/GCC00238-g.torture.execute-20030811-1: CO0, CO2
+    c_test/gtorture_test/GCC00753-g.torture.execute-alias-2: CO0, CO2
+    c_test/gtorture_test/GCC00388-g.torture.execute-20071220-2: CO2
+    c_test/gtorture_test/GCC00754-g.torture.execute-alias-3: CO0, CO2
+    c_test/gtorture_test/GCC00755-g.torture.execute-alias-4: CO0, CO2
+    c_test/gtorture_test/GCC00784-g.torture.execute-bswap-1: CO0, CO2
+    c_test/gtorture_test/GCC00786-g.torture.execute-bswap-3: CO0, CO2
+    c_test/gtorture_test/GCC00843-g.torture.execute-frame-address: CO0, CO2
+    c_test/gtorture_test/GCC00920-g.torture.execute-pr17377: CO0, CO2
+    c_test/gtorture_test/GCC01246-g.torture.execute-pr64006: CO0, CO2
+    c_test/gtorture_test/GCC01289-g.torture.execute-pr68381: CO0, CO2
+    c_test/gtorture_test/GCC01320-g.torture.execute-pr71554: CO0, CO2
+    c_test/gtorture_test/GCC01356-g.torture.execute-pr81281: CO0, CO2
+    c_test/gtorture_test/GCC01374-g.torture.execute-pr84169: CO0, CO2
+    c_test/gtorture_test/GCC01380-g.torture.execute-pr85095: CO0, CO2
+    c_test/gtorture_test/GCC01406-g.torture.execute-pr89434: CO0, CO2
+    c_test/gtorture_test/GCC01409-g.torture.execute-pr90025: CO0, CO2
+    c_test/gtorture_test/GCC01410-g.torture.execute-pr90311: CO0, CO2
+    c_test/gtorture_test/GCC01413-g.torture.execute-pr91450-1: CO0, CO2
+    c_test/gtorture_test/GCC01414-g.torture.execute-pr91450-2: CO0, CO2
+    c_test/gtorture_test/GCC01417-g.torture.execute-pr91635: CO0, CO2
+    c_test/gtorture_test/GCC01421-g.torture.execute-pr93213: CO0, CO2
+    c_test/gtorture_test/GCC01425-g.torture.execute-pr93494: CO0, CO2
+    c_test/gtorture_test/GCC01446-g.torture.execute-pr97386-1: CO0, CO2
+    c_test/gtorture_test/GCC01455-g.torture.execute-pr97888-1: CO0, CO2
+
+    #run error
+    c_test/gtorture_test/GCC00203-g.torture.execute-20021127-1: CO0, CO2
+    c_test/gtorture_test/GCC00218-g.torture.execute-20030222-1: CO0, CO2
+    c_test/gtorture_test/GCC00777-g.torture.execute-bitfld-3: CO0, CO2
+    c_test/gtorture_test/GCC00779-g.torture.execute-bitfld-5: CO0, CO2
+    c_test/gtorture_test/GCC00831-g.torture.execute-eeprof-1: CO0, CO2
+    c_test/gtorture_test/GCC00989-g.torture.execute-pr32244-1: CO0, CO2
+    c_test/gtorture_test/GCC01011-g.torture.execute-pr34971: CO0, CO2
+    c_test/gtorture_test/GCC01042-g.torture.execute-pr38533: CO2
+    c_test/gtorture_test/GCC01044-g.torture.execute-pr38969: CO0
+    c_test/gtorture_test/GCC01089-g.torture.execute-pr43560: CO2
+    c_test/gtorture_test/GCC01107-g.torture.execute-pr45695: CO0, CO2
+    c_test/gtorture_test/GCC01134-g.torture.execute-pr49279: CO0, CO2
+
+    #maple issue
+    c_test/sanity_test/SANITY0012-large_stack: CO0, CO2
+    c_test/sanity_test/SANITY0027-convert: CO0, CO2
+
+    c_test/ast_test/AST0012-AssignExpr: ASTO2
+    c_test/ast_test/AST0028-PtrBinary: ASTO2
+
+    # Intercepts variable arrays, because the backend does not yet support
+    c_test/gtorture_test/GCC00510-g.torture.execute-920929-1: CO0, CO2, CO3_INLINE, CO3_NOINLINE
+    c_test/gtorture_test/GCC00936-g.torture.execute-pr22061-1: CO0, CO2, CO3_INLINE, CO3_NOINLINE
+    c_test/gtorture_test/GCC01557-g.torture.execute-vla-dealloc-1: CO0, CO2, CO3_INLINE, CO3_NOINLINE
+    c_test/gtorture_test/GCC00295-g.torture.execute-20040811-1: CO0, CO2, CO3_INLINE, CO3_NOINLINE
+    c_test/gtorture_test/GCC00496-g.torture.execute-920721-2: CO0, CO2, CO3_INLINE, CO3_NOINLINE
+    c_test/gtorture_test/GCC01084-g.torture.execute-pr43220: CO0, CO2, CO3_INLINE, CO3_NOINLINE
+    c_test/sanity_test/SANITY0003-array_single: CO0,CO2
+    c_test/unit_test/UNIT0003-AA_DiffFieldSameMemLoc: CO2
+    c_test/gtorture_test/GCC00752-g.torture.execute-alias-1: CO2
+    c_test/gtorture_test/GCC01343-g.torture.execute-pr79043: CO2
+
+    # O3 cases failed because of alias lib function info.
+    c_test/gtorture_test/GCC00872-g.torture.execute-loop-5: CO3_INLINE
+    c_test/gtorture_test/GCC00546-g.torture.execute-930513-2: CO3_INLINE
+    c_test/gtorture_test/GCC01319-g.torture.execute-pr71550: CO3_INLINE,CO3_NOINLINE
+
+    # need debug later.
+    java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510: GC_O0,O0,O2,GC_O2
+    java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240: GC_O0,O0,O2,GC_O2
+    java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190: GC_O0,O0,O2,GC_O2
diff --git a/testsuite/driver/config/testall.conf b/testsuite/driver/config/testall.conf
new file mode 100644
index 0000000000000000000000000000000000000000..73a2ddd0608fca76ad51e08bda4a14a6437da842
--- /dev/null
+++ b/testsuite/driver/config/testall.conf
@@ -0,0 +1,305 @@
+[MODE_SET]
+    java_common_mode_set: O0, O2
+    c_common_mode_set: CO0, CO2
+    c_driver_mode_set: DRIVER
+
+[DEFAULT_TEST_SUITE]
+    java_test/app_test: java_common_mode_set
+    java_test/arrayboundary_test: java_common_mode_set
+    java_test/clinit_test: java_common_mode_set
+    java_test/compact_test: java_common_mode_set
+    java_test/eh_test: java_common_mode_set
+    java_test/fuzzapi_test: java_common_mode_set
+    java_test/other_test: java_common_mode_set
+    java_test/parent_test: java_common_mode_set
+    java_test/rc_test: java_common_mode_set
+    java_test/reflection_test: java_common_mode_set
+    java_test/stmtpre_test: java_common_mode_set
+    java_test/string_test: java_common_mode_set
+    java_test/subsumeRC_test: java_common_mode_set
+    java_test/thread_test: java_common_mode_set
+    java_test/unsafe_test: java_common_mode_set
+    irbuild_test: IR
+    c_test/sanity_test: c_common_mode_set
+    c_test/driver_test: c_driver_mode_set
+
+[BAN_TEST_SUITE]
+    irbuild_test/I0062-mapleall-irbuild-edge-pregs: IR
+    java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest: O2
+    java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet: O2
+    java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest: O2
+    java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest: O2
+    java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest: O2
+    java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest: O2
+    java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable: O2
+    java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet: O2
+    java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest: O2
+    java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest: O2
+    java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter: O2
+    java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest: O2
+    java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread: O2
+    java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest: O2
+    java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200: O2
+    java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220: O2
+    java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220: O0
+    java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130: O0
+    java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320: O0
+    java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet: O2
+    java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet: O2
+    java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest: O2
+    java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest: O2
+    java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest: O2
+    java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest: O2
+    java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable: O2
+    java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest: O2
+    java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest: O2
+    java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest: O2
+    java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest: O2
+    java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest: O2
+    java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest: O2
+    java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter: O2
+    java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread: O2
+    java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest: O0
+    java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest: O0
+    java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest: O0
+    java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest: O0
+    java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest: O0
+    java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest: O0
+    java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest: O0
+    java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest: O0
+    java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest: O0
+    java_test/other_test/RT0008-rt-other-PassingFloat: O0
+    java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest: O0
+    java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest: O0
+    java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04: O0
+    java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06: O0
+    java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest: O0
+    java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02: O0
+    java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03: O0
+    java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06: O0
+    java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07: O0
+    java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03: O0
+    java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest: O0
+    java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2: O0
+    java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3: O0
+    java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4: O0
+    java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5: O0
+    java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread: O0
+    java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6: O0
+    java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2: O0
+    java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7: O0
+    java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3: O0
+    java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8: O0
+    java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4: O0
+    java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2: O0
+    java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040: O0
+    java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030: O0
+    java_test/rc_test/RC0248-rc-function-RC_Finalize_02: O0
+    java_test/rc_test/RC0249-rc-function-RC_Finalize_03: O0
+    java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B: O0
+    java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2: O0
+    java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest: O0
+    java_test/rc_test/RC0338-rc-Memory-normalTestCase28: O0
+    java_test/rc_test/RC0339-rc-rp-cycle_all_weak: O0
+    java_test/rc_test/RC0340-rc-rp-cycle_weak_strong: O0
+    java_test/rc_test/RC0341-rc-rp-mutator: O0
+    java_test/rc_test/RC0342-rc-rp-weak_ref_boundary: O0
+    java_test/rc_test/RC0343-rc-rp-wcb_test_ref: O0
+    java_test/rc_test/RC0344-rc-rp-test_aged_ref: O0
+    java_test/rc_test/RC0345-rc-rp-single_or_more: O0
+    java_test/rc_test/RC0346-rc-rp-strong_and_weak: O0
+    java_test/rc_test/RC0347-rc-rp-simulthread: O0
+    java_test/rc_test/RC0348-rc-rp-simpleweakref_01: O0
+    java_test/rc_test/RC0349-rc-rp-simpleweakref_02: O0
+    java_test/rc_test/RC0350-rc-rp-simpleweakref_03: O0
+    java_test/rc_test/RC0351-rc-rp-simpleweakref_04: O0
+    java_test/rc_test/RC0352-rc-rp-simpleweakref_05: O0
+    java_test/rc_test/RC0353-rc-rp-simpleweakref_06: O0
+    java_test/rc_test/RC0354-rc-rp-simpleweakref_07: O0
+    java_test/rc_test/RC0355-rc-rp-simpleweakref_08: O0
+    java_test/rc_test/RC0356-rc-rp-simpleweakref_09: O0
+    java_test/rc_test/RC0357-rc-rp-simpleweakref_10: O0
+    java_test/rc_test/RC0358-rc-rp-simpleweakref_11: O0
+    java_test/rc_test/RC0359-rc-rp-simpleweakref_12: O0
+    java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01: O0
+    java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02: O0
+    java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03: O0
+    java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04: O0
+    java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05: O0
+    java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06: O0
+    java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest: O0
+    java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2: O0
+    java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4: O0
+    java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest: O0
+    java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest: O0
+    java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2: O0
+    java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle: O0
+    java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread: O0
+    java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02: O0
+    java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04: O0
+    java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05: O0
+    java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle: O0
+    java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread: O0
+    java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle: O0
+    java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2: O0
+    java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread: O0
+    java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2: O0
+    java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle: O0
+    java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2: O0
+    java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread: O0
+    java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2: O0
+    java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3: O0
+    java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3: O0
+    java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest: O0
+    java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest: O0
+    java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest: O0
+    java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03: O0
+    java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04: O0
+    java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01: O0
+    java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02: O0
+    java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04: O0
+    java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01: O0
+    java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02: O0
+    java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03: O0
+    java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04: O0
+    java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05: O0
+    java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06: O0
+    java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07: O0
+    java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08: O0
+    java_test/rc_test/RC0457-rc-GC-TriggerGCTest01: O0
+    java_test/rc_test/RC0458-rc-GC-TriggerGCTest02: O0
+    java_test/rc_test/RC0459-rc-GC-TriggerGCTest03: O0
+    java_test/rc_test/RC0463-rc-GC-TriggerGCTest07: O0
+    java_test/rc_test/RC0464-rc-GC-TriggerGCTest08: O0
+    java_test/rc_test/RC0465-rc-GC-TriggerGCTest09: O0
+    java_test/rc_test/RC0466-rc-GC-TriggerGCTest10: O0
+    java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01: O0
+    java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02: O0
+    java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01: O0
+    java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01: O0
+    java_test/rc_test/RC0515-GC-FrequentGCTest01: O0
+    java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest: O0
+    java_test/thread_test/RT0086-rt-thread-ThreadStatewait1: O0
+    java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating: O0
+    java_test/thread_test/RT0200-rt-thread-TestSynchronized: O0
+    java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest: O2
+    java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest: O2
+    java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest: O2
+    java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest: O2
+    java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest: O2
+    java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest: O2
+    java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest: O2
+    java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest: O2
+    java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest: O2
+    java_test/other_test/RT0008-rt-other-PassingFloat: O2
+    java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest: O2
+    java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest: O2
+    java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04: O2
+    java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06: O2
+    java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest: O2
+    java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02: O2
+    java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03: O2
+    java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06: O2
+    java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07: O2
+    java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03: O2
+    java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest: O2
+    java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2: O2
+    java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3: O2
+    java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4: O2
+    java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5: O2
+    java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread: O2
+    java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6: O2
+    java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2: O2
+    java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7: O2
+    java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3: O2
+    java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8: O2
+    java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4: O2
+    java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2: O2
+    java_test/rc_test/RC0248-rc-function-RC_Finalize_02: O2
+    java_test/rc_test/RC0249-rc-function-RC_Finalize_03: O2
+    java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B: O2
+    java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2: O2
+    java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest: O2
+    java_test/rc_test/RC0338-rc-Memory-normalTestCase28: O2
+    java_test/rc_test/RC0339-rc-rp-cycle_all_weak: O2
+    java_test/rc_test/RC0340-rc-rp-cycle_weak_strong: O2
+    java_test/rc_test/RC0341-rc-rp-mutator: O2
+    java_test/thread_test/RT0088-rt-thread-ThreadStatewait3: O2
+    java_test/rc_test/RC0331-rc-Memory-normalTestCase16: O2
+    java_test/rc_test/RC0342-rc-rp-weak_ref_boundary: O2
+    java_test/rc_test/RC0343-rc-rp-wcb_test_ref: O2
+    java_test/rc_test/RC0344-rc-rp-test_aged_ref: O2
+    java_test/rc_test/RC0345-rc-rp-single_or_more: O2
+    java_test/rc_test/RC0346-rc-rp-strong_and_weak: O2
+    java_test/rc_test/RC0347-rc-rp-simulthread: O2
+    java_test/rc_test/RC0348-rc-rp-simpleweakref_01: O2
+    java_test/rc_test/RC0349-rc-rp-simpleweakref_02: O2
+    java_test/rc_test/RC0350-rc-rp-simpleweakref_03: O2
+    java_test/rc_test/RC0351-rc-rp-simpleweakref_04: O2
+    java_test/rc_test/RC0352-rc-rp-simpleweakref_05: O2
+    java_test/rc_test/RC0353-rc-rp-simpleweakref_06: O2
+    java_test/rc_test/RC0354-rc-rp-simpleweakref_07: O2
+    java_test/rc_test/RC0355-rc-rp-simpleweakref_08: O2
+    java_test/rc_test/RC0356-rc-rp-simpleweakref_09: O2
+    java_test/rc_test/RC0357-rc-rp-simpleweakref_10: O2
+    java_test/rc_test/RC0358-rc-rp-simpleweakref_11: O2
+    java_test/rc_test/RC0359-rc-rp-simpleweakref_12: O2
+    java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01: O2
+    java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02: O2
+    java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03: O2
+    java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04: O2
+    java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05: O2
+    java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06: O2
+    java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest: O2
+    java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2: O2
+    java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4: O2
+    java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest: O2
+    java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest: O2
+    java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2: O2
+    java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle: O2
+    java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread: O2
+    java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02: O2
+    java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04: O2
+    java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05: O2
+    java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle: O2
+    java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread: O2
+    java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle: O2
+    java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2: O2
+    java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread: O2
+    java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2: O2
+    java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle: O2
+    java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2: O2
+    java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread: O2
+    java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2: O2
+    java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3: O2
+    java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3: O2
+    java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest: O2
+    java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest: O2
+    java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest: O2
+    java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03: O2
+    java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04: O2
+    java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01: O2
+    java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02: O2
+    java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04: O2
+    java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01: O2
+    java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02: O2
+    java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03: O2
+    java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04: O2
+    java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05: O2
+    java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06: O2
+    java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07: O2
+    java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08: O2
+    java_test/rc_test/RC0457-rc-GC-TriggerGCTest01: O2
+    java_test/rc_test/RC0458-rc-GC-TriggerGCTest02: O2
+    java_test/rc_test/RC0459-rc-GC-TriggerGCTest03: O2
+    java_test/rc_test/RC0463-rc-GC-TriggerGCTest07: O2
+    java_test/rc_test/RC0464-rc-GC-TriggerGCTest08: O2
+    java_test/rc_test/RC0465-rc-GC-TriggerGCTest09: O2
+    java_test/rc_test/RC0466-rc-GC-TriggerGCTest10: O2
+    java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01: O2
+    java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02: O2
+    java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01: O2
+    java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01: O2
+    java_test/rc_test/RC0515-GC-FrequentGCTest01: O2
+    java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest: O2
+    c_test/sanity_test/SANITY0027-convert: CO2,CO0
diff --git a/testsuite/driver/config/testall_c.conf b/testsuite/driver/config/testall_c.conf
new file mode 100755
index 0000000000000000000000000000000000000000..c53482a5439fe065dd8c0ab3779f2302b6968b43
--- /dev/null
+++ b/testsuite/driver/config/testall_c.conf
@@ -0,0 +1,1735 @@
+[MODE_SET]
+    c_common_mode_set: CO0, CO2
+    spec_mode_set: SCO0_TEST, SCO2_TEST, SCO0_TRAIN, SCO2_TRAIN
+    c_driver_mode_set: DRIVER
+
+[DEFAULT_TEST_SUITE]
+    c_test/spec_test: spec_mode_set
+    c_test/ast_test: ASTO0
+    c_test/sanity_test: c_common_mode_set
+    c_test/gtorture_test: c_common_mode_set
+    c_test/unit_test: c_common_mode_set
+    c_test/super_test: SUPO0, SUPO2
+    c_test/driver_test: c_driver_mode_set
+
+[BAN_TEST_SUITE]
+    #clang compiler error
+    c_test/gtorture_test/GCC00061-g.torture.execute-20000822-1: CO0, CO2
+    c_test/gtorture_test/GCC00098-g.torture.execute-20010209-1: CO0, CO2
+    c_test/gtorture_test/GCC00111-g.torture.execute-20010605-1: CO0, CO2
+    c_test/gtorture_test/GCC00165-g.torture.execute-20020412-1: CO0, CO2
+    c_test/gtorture_test/GCC00229-g.torture.execute-20030501-1: CO0, CO2
+    c_test/gtorture_test/GCC00268-g.torture.execute-20040308-1: CO0, CO2
+    c_test/gtorture_test/GCC00281-g.torture.execute-20040423-1: CO0, CO2
+    c_test/gtorture_test/GCC00282-g.torture.execute-20040520-1: CO0, CO2
+    c_test/gtorture_test/GCC00313-g.torture.execute-20041218-2: CO0, CO2
+    c_test/gtorture_test/GCC00362-g.torture.execute-20061220-1: CO0, CO2
+    c_test/gtorture_test/GCC00373-g.torture.execute-20070919-1: CO0, CO2
+    c_test/gtorture_test/GCC00411-g.torture.execute-20090219-1: CO0, CO2
+    c_test/gtorture_test/GCC00472-g.torture.execute-920415-1: CO0, CO2
+    c_test/gtorture_test/GCC00474-g.torture.execute-920428-2: CO0, CO2
+    c_test/gtorture_test/GCC00482-g.torture.execute-920501-7: CO0, CO2
+    c_test/gtorture_test/GCC00490-g.torture.execute-920612-2: CO0, CO2
+    c_test/gtorture_test/GCC00498-g.torture.execute-920721-4: CO0, CO2
+    c_test/gtorture_test/GCC00515-g.torture.execute-921017-1: CO0, CO2
+    c_test/gtorture_test/GCC00533-g.torture.execute-921215-1: CO0, CO2
+    c_test/gtorture_test/GCC00573-g.torture.execute-931002-1: CO0, CO2
+    c_test/gtorture_test/GCC00720-g.torture.execute-990413-2: CO0, CO2
+    c_test/gtorture_test/GCC00735-g.torture.execute-991014-1: CO0, CO2
+    c_test/gtorture_test/GCC00761-g.torture.execute-align-nest: CO0, CO2
+    c_test/gtorture_test/GCC00807-g.torture.execute-comp-goto-2: CO0, CO2
+    c_test/gtorture_test/GCC00897-g.torture.execute-nest-align-1: CO0, CO2
+    c_test/gtorture_test/GCC00898-g.torture.execute-nestfunc-1: CO0, CO2
+    c_test/gtorture_test/GCC00899-g.torture.execute-nestfunc-2: CO0, CO2
+    c_test/gtorture_test/GCC00900-g.torture.execute-nestfunc-3: CO0, CO2
+    c_test/gtorture_test/GCC00902-g.torture.execute-nestfunc-5: CO0, CO2
+    c_test/gtorture_test/GCC00903-g.torture.execute-nestfunc-6: CO0, CO2
+    c_test/gtorture_test/GCC00904-g.torture.execute-nestfunc-7: CO0, CO2
+    c_test/gtorture_test/GCC00905-g.torture.execute-nest-stdar-1: CO0, CO2
+    c_test/gtorture_test/GCC00938-g.torture.execute-pr22061-3: CO0, CO2
+    c_test/gtorture_test/GCC00939-g.torture.execute-pr22061-4: CO0, CO2
+    c_test/gtorture_test/GCC00955-g.torture.execute-pr24135: CO0, CO2
+    c_test/gtorture_test/GCC00971-g.torture.execute-pr28865: CO0, CO2
+    c_test/gtorture_test/GCC01069-g.torture.execute-pr41935: CO0, CO2
+    c_test/gtorture_test/GCC01115-g.torture.execute-pr47237: CO0, CO2
+    c_test/gtorture_test/GCC01145-g.torture.execute-pr51447: CO0, CO2
+    c_test/gtorture_test/GCC01225-g.torture.execute-pr60003: CO0, CO2
+    c_test/gtorture_test/GCC01318-g.torture.execute-pr71494: CO0, CO2
+    c_test/gtorture_test/GCC01322-g.torture.execute-pr71626-2: CO0, CO2
+    c_test/gtorture_test/GCC01355-g.torture.execute-pr80692: CO0, CO2
+    c_test/gtorture_test/GCC01364-g.torture.execute-pr82210: CO0, CO2
+    c_test/gtorture_test/GCC01383-g.torture.execute-pr85331: CO0, CO2
+    c_test/gtorture_test/GCC01438-g.torture.execute-pr94591: CO0, CO2
+    c_test/gtorture_test/GCC01553-g.torture.execute-va-arg-pack-1: CO0, CO2
+    c_test/super_test/SUP00005-2-2-1-1-t100: SUPO0, SUPO2
+    c_test/super_test/SUP00106-3-1-2-6-tspr4236: SUPO0, SUPO2
+    c_test/super_test/SUP00344-3-0-2-tspr1439: SUPO0, SUPO2
+    c_test/super_test/SUP00626-3-3-2-2-2_4-tspr4105: SUPO0, SUPO2
+    c_test/super_test/SUP01630-3-5-4-2-tspr4667b: SUPO0, SUPO2
+    c_test/super_test/SUP01631-3-5-4-2-tspr4667a: SUPO0, SUPO2
+    c_test/super_test/SUP01633-3-5-4-2-tspr4667: SUPO0, SUPO2
+    c_test/super_test/SUP02067-embeddedc-TR-4-1-1-tminmax: SUPO0, SUPO2
+    c_test/super_test/SUP02068-embeddedc-TR-4-1-9-tscan: SUPO0, SUPO2
+    c_test/super_test/SUP02069-embeddedc-TR-4-1-9-tprint: SUPO0, SUPO2
+    c_test/super_test/SUP02070-embeddedc-TR-4-1-3-tovf: SUPO0, SUPO2
+    c_test/super_test/SUP02071-embeddedc-TR-4-1-4-tspr5380: SUPO0, SUPO2
+    c_test/super_test/SUP02072-embeddedc-TR-4-1-4-tconv: SUPO0, SUPO2
+    c_test/super_test/SUP02073-embeddedc-TR-4-1-7-1-tabs: SUPO0, SUPO2
+    c_test/super_test/SUP02074-embeddedc-TR-4-1-7-3-tcount: SUPO0, SUPO2
+    c_test/super_test/SUP02075-embeddedc-TR-4-1-7-4-tbits: SUPO0, SUPO2
+    c_test/super_test/SUP02076-embeddedc-TR-4-1-7-2-tround: SUPO0, SUPO2
+    c_test/super_test/SUP02077-embeddedc-TR-4-1-7-7-tstrtofx: SUPO0, SUPO2
+    c_test/super_test/SUP02078-embeddedc-TR-4-1-7-5-tbits: SUPO0, SUPO2
+    c_test/super_test/SUP02079-embeddedc-TR-4-1-6-1-1-tprepost: SUPO0, SUPO2
+    c_test/super_test/SUP02080-embeddedc-TR-4-1-6-1-2-tunary: SUPO0, SUPO2
+    c_test/super_test/SUP02081-embeddedc-TR-4-1-6-3-tasop: SUPO0, SUPO2
+    c_test/super_test/SUP02082-embeddedc-TR-4-1-6-2-1-tbinary: SUPO0, SUPO2
+    c_test/super_test/SUP02083-embeddedc-TR-4-1-6-2-3-tcomp: SUPO0, SUPO2
+    c_test/super_test/SUP02084-embeddedc-TR-4-1-6-2-2-tshift: SUPO0, SUPO2
+    c_test/super_test/SUP02085-embeddedc-TR-4-1-6-2-2-tspr5313: SUPO0, SUPO2
+    c_test/super_test/SUP02086-embeddedc-TR-4-1-5-tsuffx: SUPO0, SUPO2
+    c_test/super_test/SUP02087-embeddedc-7-18a-6-1-tsupport: SUPO0, SUPO2
+    c_test/super_test/SUP02088-embeddedc-7-18a-6-3-tround: SUPO0, SUPO2
+    c_test/super_test/SUP02089-embeddedc-7-18a-6-4-tcount: SUPO0, SUPO2
+    c_test/super_test/SUP02090-embeddedc-7-18a-6-2-tabs: SUPO0, SUPO2
+    c_test/super_test/SUP02091-embeddedc-7-18a-6-7-tcount: SUPO0, SUPO2
+    c_test/super_test/SUP02092-embeddedc-7-18a-6-7-tround: SUPO0, SUPO2
+    c_test/super_test/SUP02093-embeddedc-7-18a-6-7-tabs: SUPO0, SUPO2
+    c_test/super_test/SUP02094-embeddedc-7-18a-6-6-tbits: SUPO0, SUPO2
+    c_test/super_test/SUP02095-embeddedc-7-18a-6-5-tbits: SUPO0, SUPO2
+    c_test/super_test/SUP02096-embeddedc-7-18a-6-8-tofx: SUPO0, SUPO2
+    c_test/super_test/SUP02097-embeddedc-6-3-1-3a-tis14: SUPO0, SUPO2
+    c_test/super_test/SUP02098-embeddedc-6-3-1-3a-tu41: SUPO0, SUPO2
+    c_test/super_test/SUP02099-embeddedc-6-3-1-3a-tu10: SUPO0, SUPO2
+    c_test/super_test/SUP02100-embeddedc-6-3-1-3a-t41: SUPO0, SUPO2
+    c_test/super_test/SUP02101-embeddedc-6-3-1-3a-tu21: SUPO0, SUPO2
+    c_test/super_test/SUP02102-embeddedc-6-3-1-3a-t22: SUPO0, SUPO2
+    c_test/super_test/SUP02103-embeddedc-6-3-1-3a-t51: SUPO0, SUPO2
+    c_test/super_test/SUP02104-embeddedc-6-3-1-3a-t2: SUPO0, SUPO2
+    c_test/super_test/SUP02105-embeddedc-6-3-1-3a-tis24: SUPO0, SUPO2
+    c_test/super_test/SUP02106-embeddedc-6-3-1-3a-tu24: SUPO0, SUPO2
+    c_test/super_test/SUP02107-embeddedc-6-3-1-3a-tu20: SUPO0, SUPO2
+    c_test/super_test/SUP02108-embeddedc-6-3-1-3a-tu11: SUPO0, SUPO2
+    c_test/super_test/SUP02109-embeddedc-6-3-1-3a-tis4: SUPO0, SUPO2
+    c_test/super_test/SUP02110-embeddedc-6-3-1-3a-tu51: SUPO0, SUPO2
+    c_test/super_test/SUP02111-embeddedc-6-3-1-3a-tis21: SUPO0, SUPO2
+    c_test/super_test/SUP02112-embeddedc-6-3-1-3a-tu50: SUPO0, SUPO2
+    c_test/super_test/SUP02113-embeddedc-6-3-1-3a-t43: SUPO0, SUPO2
+    c_test/super_test/SUP02114-embeddedc-6-3-1-3a-t32: SUPO0, SUPO2
+    c_test/super_test/SUP02115-embeddedc-6-3-1-3a-tu22: SUPO0, SUPO2
+    c_test/super_test/SUP02116-embeddedc-6-3-1-3a-t11: SUPO0, SUPO2
+    c_test/super_test/SUP02117-embeddedc-6-3-1-3a-t50: SUPO0, SUPO2
+    c_test/super_test/SUP02118-embeddedc-6-3-1-3a-ts1: SUPO0, SUPO2
+    c_test/super_test/SUP02119-embeddedc-6-3-1-3a-tu31: SUPO0, SUPO2
+    c_test/super_test/SUP02120-embeddedc-6-3-1-3a-tu54: SUPO0, SUPO2
+    c_test/super_test/SUP02121-embeddedc-6-3-1-3a-tis1: SUPO0, SUPO2
+    c_test/super_test/SUP02122-embeddedc-6-3-1-3a-tu12: SUPO0, SUPO2
+    c_test/super_test/SUP02123-embeddedc-6-3-1-3a-t34: SUPO0, SUPO2
+    c_test/super_test/SUP02124-embeddedc-6-3-1-3a-tu13: SUPO0, SUPO2
+    c_test/super_test/SUP02125-embeddedc-6-3-1-3a-tu60: SUPO0, SUPO2
+    c_test/super_test/SUP02126-embeddedc-6-3-1-3a-tu53: SUPO0, SUPO2
+    c_test/super_test/SUP02127-embeddedc-6-3-1-3a-t24: SUPO0, SUPO2
+    c_test/super_test/SUP02128-embeddedc-6-3-1-3a-tu14: SUPO0, SUPO2
+    c_test/super_test/SUP02129-embeddedc-6-3-1-3a-tu61: SUPO0, SUPO2
+    c_test/super_test/SUP02130-embeddedc-6-3-1-3a-tis13: SUPO0, SUPO2
+    c_test/super_test/SUP02131-embeddedc-6-3-1-3a-t30: SUPO0, SUPO2
+    c_test/super_test/SUP02132-embeddedc-6-3-1-3a-tu42: SUPO0, SUPO2
+    c_test/super_test/SUP02133-embeddedc-6-3-1-3a-t4: SUPO0, SUPO2
+    c_test/super_test/SUP02134-embeddedc-6-3-1-3a-t33: SUPO0, SUPO2
+    c_test/super_test/SUP02135-embeddedc-6-3-1-3a-tis3: SUPO0, SUPO2
+    c_test/super_test/SUP02136-embeddedc-6-3-1-3a-tu64: SUPO0, SUPO2
+    c_test/super_test/SUP02137-embeddedc-6-3-1-3a-ts2: SUPO0, SUPO2
+    c_test/super_test/SUP02138-embeddedc-6-3-1-3a-tis2: SUPO0, SUPO2
+    c_test/super_test/SUP02139-embeddedc-6-3-1-3a-t23: SUPO0, SUPO2
+    c_test/super_test/SUP02140-embeddedc-6-3-1-3a-tu32: SUPO0, SUPO2
+    c_test/super_test/SUP02141-embeddedc-6-3-1-3a-t13: SUPO0, SUPO2
+    c_test/super_test/SUP02142-embeddedc-6-3-1-3a-t12: SUPO0, SUPO2
+    c_test/super_test/SUP02143-embeddedc-6-3-1-3a-tu62: SUPO0, SUPO2
+    c_test/super_test/SUP02144-embeddedc-6-3-1-3a-tu43: SUPO0, SUPO2
+    c_test/super_test/SUP02145-embeddedc-6-3-1-3a-tis23: SUPO0, SUPO2
+    c_test/super_test/SUP02146-embeddedc-6-3-1-3a-t20: SUPO0, SUPO2
+    c_test/super_test/SUP02147-embeddedc-6-3-1-3a-t63: SUPO0, SUPO2
+    c_test/super_test/SUP02148-embeddedc-6-3-1-3a-t62: SUPO0, SUPO2
+    c_test/super_test/SUP02149-embeddedc-6-3-1-3a-tis12: SUPO0, SUPO2
+    c_test/super_test/SUP02150-embeddedc-6-3-1-3a-tu52: SUPO0, SUPO2
+    c_test/super_test/SUP02151-embeddedc-6-3-1-3a-t53: SUPO0, SUPO2
+    c_test/super_test/SUP02152-embeddedc-6-3-1-3a-t1: SUPO0, SUPO2
+    c_test/super_test/SUP02153-embeddedc-6-3-1-3a-tu23: SUPO0, SUPO2
+    c_test/super_test/SUP02154-embeddedc-6-3-1-3a-t60: SUPO0, SUPO2
+    c_test/super_test/SUP02155-embeddedc-6-3-1-3a-t61: SUPO0, SUPO2
+    c_test/super_test/SUP02156-embeddedc-6-3-1-3a-ts3: SUPO0, SUPO2
+    c_test/super_test/SUP02157-embeddedc-6-3-1-3a-t54: SUPO0, SUPO2
+    c_test/super_test/SUP02158-embeddedc-6-3-1-3a-t3: SUPO0, SUPO2
+    c_test/super_test/SUP02159-embeddedc-6-3-1-3a-tis22: SUPO0, SUPO2
+    c_test/super_test/SUP02160-embeddedc-6-3-1-3a-t44: SUPO0, SUPO2
+    c_test/super_test/SUP02161-embeddedc-6-3-1-3a-t42: SUPO0, SUPO2
+    c_test/super_test/SUP02162-embeddedc-6-3-1-3a-t21: SUPO0, SUPO2
+    c_test/super_test/SUP02163-embeddedc-6-3-1-3a-tu33: SUPO0, SUPO2
+    c_test/super_test/SUP02164-embeddedc-6-3-1-3a-t31: SUPO0, SUPO2
+    c_test/super_test/SUP02165-embeddedc-6-3-1-3a-t64: SUPO0, SUPO2
+    c_test/super_test/SUP02166-embeddedc-6-3-1-3a-t10: SUPO0, SUPO2
+    c_test/super_test/SUP02167-embeddedc-6-3-1-3a-tu40: SUPO0, SUPO2
+    c_test/super_test/SUP02168-embeddedc-6-3-1-3a-tu30: SUPO0, SUPO2
+    c_test/super_test/SUP02169-embeddedc-6-3-1-3a-tu44: SUPO0, SUPO2
+    c_test/super_test/SUP02170-embeddedc-6-3-1-3a-tu63: SUPO0, SUPO2
+    c_test/super_test/SUP02171-embeddedc-6-3-1-3a-tis11: SUPO0, SUPO2
+    c_test/super_test/SUP02172-embeddedc-6-3-1-3a-tu34: SUPO0, SUPO2
+    c_test/super_test/SUP02173-embeddedc-6-3-1-3a-t14: SUPO0, SUPO2
+    c_test/super_test/SUP02174-embeddedc-6-3-1-3a-t40: SUPO0, SUPO2
+    c_test/super_test/SUP02175-embeddedc-6-3-1-3a-t52: SUPO0, SUPO2
+    c_test/super_test/SUP02176-embeddedc-6-5-9-tcula: SUPO0, SUPO2
+    c_test/super_test/SUP02177-embeddedc-6-5-9-tcusa: SUPO0, SUPO2
+    c_test/super_test/SUP02178-embeddedc-6-5-9-t2: SUPO0, SUPO2
+    c_test/super_test/SUP02179-embeddedc-6-5-9-tcuna: SUPO0, SUPO2
+    c_test/super_test/SUP02180-embeddedc-6-5-9-tcsnf: SUPO0, SUPO2
+    c_test/super_test/SUP02181-embeddedc-6-5-9-tcslf: SUPO0, SUPO2
+    c_test/super_test/SUP02182-embeddedc-6-5-9-tcsna: SUPO0, SUPO2
+    c_test/super_test/SUP02183-embeddedc-6-5-9-t8: SUPO0, SUPO2
+    c_test/super_test/SUP02184-embeddedc-6-5-9-tcssf: SUPO0, SUPO2
+    c_test/super_test/SUP02185-embeddedc-6-5-9-t4: SUPO0, SUPO2
+    c_test/super_test/SUP02186-embeddedc-6-5-9-tcunf: SUPO0, SUPO2
+    c_test/super_test/SUP02187-embeddedc-6-5-9-t6: SUPO0, SUPO2
+    c_test/super_test/SUP02188-embeddedc-6-5-9-tcusf: SUPO0, SUPO2
+    c_test/super_test/SUP02189-embeddedc-6-5-9-tcsla: SUPO0, SUPO2
+    c_test/super_test/SUP02190-embeddedc-6-5-9-t1: SUPO0, SUPO2
+    c_test/super_test/SUP02191-embeddedc-6-5-9-t3: SUPO0, SUPO2
+    c_test/super_test/SUP02192-embeddedc-6-5-9-t5: SUPO0, SUPO2
+    c_test/super_test/SUP02193-embeddedc-6-5-9-t7: SUPO0, SUPO2
+    c_test/super_test/SUP02194-embeddedc-6-5-9-tcssa: SUPO0, SUPO2
+    c_test/super_test/SUP02195-embeddedc-6-5-9-tculf: SUPO0, SUPO2
+    c_test/super_test/SUP02196-embeddedc-6-5-3-3-t2: SUPO0, SUPO2
+    c_test/super_test/SUP02197-embeddedc-6-5-3-3-t4: SUPO0, SUPO2
+    c_test/super_test/SUP02198-embeddedc-6-5-3-3-t1: SUPO0, SUPO2
+    c_test/super_test/SUP02199-embeddedc-6-5-3-3-t3: SUPO0, SUPO2
+    c_test/super_test/SUP02200-embeddedc-6-5-3-3-t5: SUPO0, SUPO2
+    c_test/super_test/SUP02201-embeddedc-6-5-16-1-t2: SUPO0, SUPO2
+    c_test/super_test/SUP02202-embeddedc-6-5-16-1-t4: SUPO0, SUPO2
+    c_test/super_test/SUP02203-embeddedc-6-5-16-1-t6: SUPO0, SUPO2
+    c_test/super_test/SUP02204-embeddedc-6-5-16-1-t1: SUPO0, SUPO2
+    c_test/super_test/SUP02205-embeddedc-6-5-16-1-t3: SUPO0, SUPO2
+    c_test/super_test/SUP02206-embeddedc-6-5-16-1-t5: SUPO0, SUPO2
+    c_test/super_test/SUP02207-embeddedc-6-5-7-t20: SUPO0, SUPO2
+    c_test/super_test/SUP02208-embeddedc-6-5-7-t1: SUPO0, SUPO2
+    c_test/super_test/SUP02209-embeddedc-6-5-7-t10: SUPO0, SUPO2
+    c_test/super_test/SUP02210-embeddedc-6-5-6-tsunf: SUPO0, SUPO2
+    c_test/super_test/SUP02211-embeddedc-6-5-6-tausf: SUPO0, SUPO2
+    c_test/super_test/SUP02212-embeddedc-6-5-6-t2: SUPO0, SUPO2
+    c_test/super_test/SUP02213-embeddedc-6-5-6-ts17: SUPO0, SUPO2
+    c_test/super_test/SUP02214-embeddedc-6-5-6-tsula: SUPO0, SUPO2
+    c_test/super_test/SUP02215-embeddedc-6-5-6-tassf: SUPO0, SUPO2
+    c_test/super_test/SUP02216-embeddedc-6-5-6-taulf: SUPO0, SUPO2
+    c_test/super_test/SUP02217-embeddedc-6-5-6-tm1: SUPO0, SUPO2
+    c_test/super_test/SUP02218-embeddedc-6-5-6-tssnf: SUPO0, SUPO2
+    c_test/super_test/SUP02219-embeddedc-6-5-6-tsssa: SUPO0, SUPO2
+    c_test/super_test/SUP02220-embeddedc-6-5-6-tspr5729: SUPO0, SUPO2
+    c_test/super_test/SUP02221-embeddedc-6-5-6-t32: SUPO0, SUPO2
+    c_test/super_test/SUP02222-embeddedc-6-5-6-ts1: SUPO0, SUPO2
+    c_test/super_test/SUP02223-embeddedc-6-5-6-ts11: SUPO0, SUPO2
+    c_test/super_test/SUP02224-embeddedc-6-5-6-ts16: SUPO0, SUPO2
+    c_test/super_test/SUP02225-embeddedc-6-5-6-ts8: SUPO0, SUPO2
+    c_test/super_test/SUP02226-embeddedc-6-5-6-tausa: SUPO0, SUPO2
+    c_test/super_test/SUP02227-embeddedc-6-5-6-ts9: SUPO0, SUPO2
+    c_test/super_test/SUP02228-embeddedc-6-5-6-ts10: SUPO0, SUPO2
+    c_test/super_test/SUP02229-embeddedc-6-5-6-ts15: SUPO0, SUPO2
+    c_test/super_test/SUP02230-embeddedc-6-5-6-tasnf: SUPO0, SUPO2
+    c_test/super_test/SUP02231-embeddedc-6-5-6-t30: SUPO0, SUPO2
+    c_test/super_test/SUP02232-embeddedc-6-5-6-ts13: SUPO0, SUPO2
+    c_test/super_test/SUP02233-embeddedc-6-5-6-t4: SUPO0, SUPO2
+    c_test/super_test/SUP02234-embeddedc-6-5-6-tssna: SUPO0, SUPO2
+    c_test/super_test/SUP02235-embeddedc-6-5-6-tsuna: SUPO0, SUPO2
+    c_test/super_test/SUP02236-embeddedc-6-5-6-ts2: SUPO0, SUPO2
+    c_test/super_test/SUP02237-embeddedc-6-5-6-ts4: SUPO0, SUPO2
+    c_test/super_test/SUP02238-embeddedc-6-5-6-tsusf: SUPO0, SUPO2
+    c_test/super_test/SUP02239-embeddedc-6-5-6-tsusa: SUPO0, SUPO2
+    c_test/super_test/SUP02240-embeddedc-6-5-6-tsssf: SUPO0, SUPO2
+    c_test/super_test/SUP02241-embeddedc-6-5-6-tssla: SUPO0, SUPO2
+    c_test/super_test/SUP02242-embeddedc-6-5-6-t20: SUPO0, SUPO2
+    c_test/super_test/SUP02243-embeddedc-6-5-6-taunf: SUPO0, SUPO2
+    c_test/super_test/SUP02244-embeddedc-6-5-6-ts5: SUPO0, SUPO2
+    c_test/super_test/SUP02245-embeddedc-6-5-6-tfold: SUPO0, SUPO2
+    c_test/super_test/SUP02246-embeddedc-6-5-6-taslf: SUPO0, SUPO2
+    c_test/super_test/SUP02247-embeddedc-6-5-6-tasla: SUPO0, SUPO2
+    c_test/super_test/SUP02248-embeddedc-6-5-6-ts7: SUPO0, SUPO2
+    c_test/super_test/SUP02249-embeddedc-6-5-6-ts6: SUPO0, SUPO2
+    c_test/super_test/SUP02250-embeddedc-6-5-6-ts18: SUPO0, SUPO2
+    c_test/super_test/SUP02251-embeddedc-6-5-6-ts3: SUPO0, SUPO2
+    c_test/super_test/SUP02252-embeddedc-6-5-6-tasna: SUPO0, SUPO2
+    c_test/super_test/SUP02253-embeddedc-6-5-6-t3: SUPO0, SUPO2
+    c_test/super_test/SUP02254-embeddedc-6-5-6-ts14: SUPO0, SUPO2
+    c_test/super_test/SUP02255-embeddedc-6-5-6-tassa: SUPO0, SUPO2
+    c_test/super_test/SUP02256-embeddedc-6-5-6-tsslf: SUPO0, SUPO2
+    c_test/super_test/SUP02257-embeddedc-6-5-6-t21: SUPO0, SUPO2
+    c_test/super_test/SUP02258-embeddedc-6-5-6-t5: SUPO0, SUPO2
+    c_test/super_test/SUP02259-embeddedc-6-5-6-t31: SUPO0, SUPO2
+    c_test/super_test/SUP02260-embeddedc-6-5-6-taula: SUPO0, SUPO2
+    c_test/super_test/SUP02261-embeddedc-6-5-6-tauna: SUPO0, SUPO2
+    c_test/super_test/SUP02262-embeddedc-6-5-6-ts12: SUPO0, SUPO2
+    c_test/super_test/SUP02263-embeddedc-6-5-6-tsulf: SUPO0, SUPO2
+    c_test/super_test/SUP02264-embeddedc-6-5-6-ts19: SUPO0, SUPO2
+    c_test/super_test/SUP02265-embeddedc-6-5-5-tcp: SUPO0, SUPO2
+    c_test/super_test/SUP02266-embeddedc-6-5-5-tu8: SUPO0, SUPO2
+    c_test/super_test/SUP02267-embeddedc-6-5-5-tu10: SUPO0, SUPO2
+    c_test/super_test/SUP02268-embeddedc-6-5-5-tm2: SUPO0, SUPO2
+    c_test/super_test/SUP02269-embeddedc-6-5-5-t2: SUPO0, SUPO2
+    c_test/super_test/SUP02270-embeddedc-6-5-5-t36: SUPO0, SUPO2
+    c_test/super_test/SUP02271-embeddedc-6-5-5-tu9: SUPO0, SUPO2
+    c_test/super_test/SUP02272-embeddedc-6-5-5-tu3: SUPO0, SUPO2
+    c_test/super_test/SUP02273-embeddedc-6-5-5-tu20: SUPO0, SUPO2
+    c_test/super_test/SUP02274-embeddedc-6-5-5-tu11: SUPO0, SUPO2
+    c_test/super_test/SUP02275-embeddedc-6-5-5-tu5: SUPO0, SUPO2
+    c_test/super_test/SUP02276-embeddedc-6-5-5-tm1: SUPO0, SUPO2
+    c_test/super_test/SUP02277-embeddedc-6-5-5-t32: SUPO0, SUPO2
+    c_test/super_test/SUP02278-embeddedc-6-5-5-tu1: SUPO0, SUPO2
+    c_test/super_test/SUP02279-embeddedc-6-5-5-t11: SUPO0, SUPO2
+    c_test/super_test/SUP02280-embeddedc-6-5-5-t8: SUPO0, SUPO2
+    c_test/super_test/SUP02281-embeddedc-6-5-5-tu7: SUPO0, SUPO2
+    c_test/super_test/SUP02282-embeddedc-6-5-5-ts1: SUPO0, SUPO2
+    c_test/super_test/SUP02283-embeddedc-6-5-5-tu2: SUPO0, SUPO2
+    c_test/super_test/SUP02284-embeddedc-6-5-5-tu31: SUPO0, SUPO2
+    c_test/super_test/SUP02285-embeddedc-6-5-5-tu4: SUPO0, SUPO2
+    c_test/super_test/SUP02286-embeddedc-6-5-5-tu12: SUPO0, SUPO2
+    c_test/super_test/SUP02287-embeddedc-6-5-5-t34: SUPO0, SUPO2
+    c_test/super_test/SUP02288-embeddedc-6-5-5-t30: SUPO0, SUPO2
+    c_test/super_test/SUP02289-embeddedc-6-5-5-t4: SUPO0, SUPO2
+    c_test/super_test/SUP02290-embeddedc-6-5-5-t33: SUPO0, SUPO2
+    c_test/super_test/SUP02291-embeddedc-6-5-5-t12: SUPO0, SUPO2
+    c_test/super_test/SUP02292-embeddedc-6-5-5-t20: SUPO0, SUPO2
+    c_test/super_test/SUP02293-embeddedc-6-5-5-t6: SUPO0, SUPO2
+    c_test/super_test/SUP02294-embeddedc-6-5-5-tfold: SUPO0, SUPO2
+    c_test/super_test/SUP02295-embeddedc-6-5-5-t35: SUPO0, SUPO2
+    c_test/super_test/SUP02296-embeddedc-6-5-5-t1: SUPO0, SUPO2
+    c_test/super_test/SUP02297-embeddedc-6-5-5-t9: SUPO0, SUPO2
+    c_test/super_test/SUP02298-embeddedc-6-5-5-tu6: SUPO0, SUPO2
+    c_test/super_test/SUP02299-embeddedc-6-5-5-t3: SUPO0, SUPO2
+    c_test/super_test/SUP02300-embeddedc-6-5-5-t5: SUPO0, SUPO2
+    c_test/super_test/SUP02301-embeddedc-6-5-5-t31: SUPO0, SUPO2
+    c_test/super_test/SUP02302-embeddedc-6-5-5-t10: SUPO0, SUPO2
+    c_test/super_test/SUP02303-embeddedc-6-5-5-tu30: SUPO0, SUPO2
+    c_test/super_test/SUP02304-embeddedc-6-5-5-t7: SUPO0, SUPO2
+    c_test/super_test/SUP02305-embeddedc-6-5-8-tcula: SUPO0, SUPO2
+    c_test/super_test/SUP02306-embeddedc-6-5-8-tcusa: SUPO0, SUPO2
+    c_test/super_test/SUP02307-embeddedc-6-5-8-t2: SUPO0, SUPO2
+    c_test/super_test/SUP02308-embeddedc-6-5-8-tcuna: SUPO0, SUPO2
+    c_test/super_test/SUP02309-embeddedc-6-5-8-tcsnf: SUPO0, SUPO2
+    c_test/super_test/SUP02310-embeddedc-6-5-8-tcslf: SUPO0, SUPO2
+    c_test/super_test/SUP02311-embeddedc-6-5-8-tcsna: SUPO0, SUPO2
+    c_test/super_test/SUP02312-embeddedc-6-5-8-t11: SUPO0, SUPO2
+    c_test/super_test/SUP02313-embeddedc-6-5-8-t8: SUPO0, SUPO2
+    c_test/super_test/SUP02314-embeddedc-6-5-8-tcssf: SUPO0, SUPO2
+    c_test/super_test/SUP02315-embeddedc-6-5-8-t4: SUPO0, SUPO2
+    c_test/super_test/SUP02316-embeddedc-6-5-8-tcunf: SUPO0, SUPO2
+    c_test/super_test/SUP02317-embeddedc-6-5-8-tcusf: SUPO0, SUPO2
+    c_test/super_test/SUP02318-embeddedc-6-5-8-tcsla: SUPO0, SUPO2
+    c_test/super_test/SUP02319-embeddedc-6-5-8-t1: SUPO0, SUPO2
+    c_test/super_test/SUP02320-embeddedc-6-5-8-t9: SUPO0, SUPO2
+    c_test/super_test/SUP02321-embeddedc-6-5-8-t3: SUPO0, SUPO2
+    c_test/super_test/SUP02322-embeddedc-6-5-8-t5: SUPO0, SUPO2
+    c_test/super_test/SUP02323-embeddedc-6-5-8-t10: SUPO0, SUPO2
+    c_test/super_test/SUP02324-embeddedc-6-5-8-t7: SUPO0, SUPO2
+    c_test/super_test/SUP02325-embeddedc-6-5-8-tcssa: SUPO0, SUPO2
+    c_test/super_test/SUP02326-embeddedc-6-5-8-tculf: SUPO0, SUPO2
+    c_test/super_test/SUP10486-depth-embed-bin1-t0070.0: SUPO0, SUPO2
+    c_test/super_test/SUP10487-depth-embed-bin1-t0037.3: SUPO0, SUPO2
+    c_test/super_test/SUP10488-depth-embed-bin1-t0160.0: SUPO0, SUPO2
+    c_test/super_test/SUP10489-depth-embed-bin1-t0105.0: SUPO0, SUPO2
+    c_test/super_test/SUP10490-depth-embed-bin1-t0130.2: SUPO0, SUPO2
+    c_test/super_test/SUP10491-depth-embed-bin1-t0045.0: SUPO0, SUPO2
+    c_test/super_test/SUP10492-depth-embed-bin1-t0055.2: SUPO0, SUPO2
+    c_test/super_test/SUP10493-depth-embed-bin1-t0107.6: SUPO0, SUPO2
+    c_test/super_test/SUP10494-depth-embed-bin1-t0147.0: SUPO0, SUPO2
+    c_test/super_test/SUP10495-depth-embed-bin1-t0126.1: SUPO0, SUPO2
+    c_test/super_test/SUP10496-depth-embed-bin1-t0061.2: SUPO0, SUPO2
+    c_test/super_test/SUP10497-depth-embed-bin1-t0004.1: SUPO0, SUPO2
+    c_test/super_test/SUP10498-depth-embed-bin1-t0187.1: SUPO0, SUPO2
+    c_test/super_test/SUP10499-depth-embed-bin1-t0126.0: SUPO0, SUPO2
+    c_test/super_test/SUP10500-depth-embed-bin1-t0123.0: SUPO0, SUPO2
+    c_test/super_test/SUP10501-depth-embed-bin1-t0036.0: SUPO0, SUPO2
+    c_test/super_test/SUP10502-depth-embed-bin1-t0102.0: SUPO0, SUPO2
+    c_test/super_test/SUP10503-depth-embed-bin1-t0119.1: SUPO0, SUPO2
+    c_test/super_test/SUP10504-depth-embed-bin1-t0063.2: SUPO0, SUPO2
+    c_test/super_test/SUP10505-depth-embed-bin1-t0103.3: SUPO0, SUPO2
+    c_test/super_test/SUP10506-depth-embed-bin1-t0126.4: SUPO0, SUPO2
+    c_test/super_test/SUP10507-depth-embed-bin1-t0025.2: SUPO0, SUPO2
+    c_test/super_test/SUP10508-depth-embed-bin1-t0106.2: SUPO0, SUPO2
+    c_test/super_test/SUP10509-depth-embed-bin1-t0120.3: SUPO0, SUPO2
+    c_test/super_test/SUP10510-depth-embed-bin1-t0129.2: SUPO0, SUPO2
+    c_test/super_test/SUP10511-depth-embed-bin1-t0021.1: SUPO0, SUPO2
+    c_test/super_test/SUP10512-depth-embed-bin1-t0167.2: SUPO0, SUPO2
+    c_test/super_test/SUP10513-depth-embed-bin1-t0066.1: SUPO0, SUPO2
+    c_test/super_test/SUP10514-depth-embed-bin1-t0019.1: SUPO0, SUPO2
+    c_test/super_test/SUP10515-depth-embed-bin1-t0033.2: SUPO0, SUPO2
+    c_test/super_test/SUP10516-depth-embed-bin1-t0074.0: SUPO0, SUPO2
+    c_test/super_test/SUP10517-depth-embed-bin1-t0003.3: SUPO0, SUPO2
+    c_test/super_test/SUP10518-depth-embed-bin1-t0177.0: SUPO0, SUPO2
+    c_test/super_test/SUP10519-depth-embed-bin1-t0091.0: SUPO0, SUPO2
+    c_test/super_test/SUP10520-depth-embed-bin1-t0061.1: SUPO0, SUPO2
+    c_test/super_test/SUP10521-depth-embed-bin1-t0037.0: SUPO0, SUPO2
+    c_test/super_test/SUP10522-depth-embed-bin1-t0127.6: SUPO0, SUPO2
+    c_test/super_test/SUP10523-depth-embed-bin1-t0087.0: SUPO0, SUPO2
+    c_test/super_test/SUP10524-depth-embed-bin1-t0046.0: SUPO0, SUPO2
+    c_test/super_test/SUP10525-depth-embed-bin1-t0024.3: SUPO0, SUPO2
+    c_test/super_test/SUP10526-depth-embed-bin1-t0015.3: SUPO0, SUPO2
+    c_test/super_test/SUP10527-depth-embed-bin1-t0160.1: SUPO0, SUPO2
+    c_test/super_test/SUP10528-depth-embed-bin1-t0114.2: SUPO0, SUPO2
+    c_test/super_test/SUP10529-depth-embed-bin1-t0033.3: SUPO0, SUPO2
+    c_test/super_test/SUP10530-depth-embed-bin1-t0131.1: SUPO0, SUPO2
+    c_test/super_test/SUP10531-depth-embed-bin1-t0167.0: SUPO0, SUPO2
+    c_test/super_test/SUP10532-depth-embed-bin1-t0114.0: SUPO0, SUPO2
+    c_test/super_test/SUP10533-depth-embed-bin1-t0142.0: SUPO0, SUPO2
+    c_test/super_test/SUP10534-depth-embed-bin1-t0060.0: SUPO0, SUPO2
+    c_test/super_test/SUP10535-depth-embed-bin1-t0067.0: SUPO0, SUPO2
+    c_test/super_test/SUP10536-depth-embed-bin1-t0073.1: SUPO0, SUPO2
+    c_test/super_test/SUP10537-depth-embed-bin1-t0014.2: SUPO0, SUPO2
+    c_test/super_test/SUP10538-depth-embed-bin1-t0054.0: SUPO0, SUPO2
+    c_test/super_test/SUP10539-depth-embed-bin1-t0023.0: SUPO0, SUPO2
+    c_test/super_test/SUP10540-depth-embed-bin1-t0130.1: SUPO0, SUPO2
+    c_test/super_test/SUP10541-depth-embed-bin1-t0021.3: SUPO0, SUPO2
+    c_test/super_test/SUP10542-depth-embed-bin1-t0104.1: SUPO0, SUPO2
+    c_test/super_test/SUP10543-depth-embed-bin1-t0001.4: SUPO0, SUPO2
+    c_test/super_test/SUP10544-depth-embed-bin1-t0057.1: SUPO0, SUPO2
+    c_test/super_test/SUP10545-depth-embed-bin1-t0140.0: SUPO0, SUPO2
+    c_test/super_test/SUP10546-depth-embed-bin1-t0113.4: SUPO0, SUPO2
+    c_test/super_test/SUP10547-depth-embed-bin1-t0029.1: SUPO0, SUPO2
+    c_test/super_test/SUP10548-depth-embed-bin1-t0101.1: SUPO0, SUPO2
+    c_test/super_test/SUP10549-depth-embed-bin1-t0093.1: SUPO0, SUPO2
+    c_test/super_test/SUP10550-depth-embed-bin1-t0032.0: SUPO0, SUPO2
+    c_test/super_test/SUP10551-depth-embed-bin1-t0120.2: SUPO0, SUPO2
+    c_test/super_test/SUP10552-depth-embed-bin1-t0107.5: SUPO0, SUPO2
+    c_test/super_test/SUP10553-depth-embed-bin1-t0151.0: SUPO0, SUPO2
+    c_test/super_test/SUP10554-depth-embed-bin1-t0009.1: SUPO0, SUPO2
+    c_test/super_test/SUP10555-depth-embed-bin1-t0036.3: SUPO0, SUPO2
+    c_test/super_test/SUP10556-depth-embed-bin1-t0020.1: SUPO0, SUPO2
+    c_test/super_test/SUP10557-depth-embed-bin1-t0185.0: SUPO0, SUPO2
+    c_test/super_test/SUP10558-depth-embed-bin1-t0052.0: SUPO0, SUPO2
+    c_test/super_test/SUP10559-depth-embed-bin1-t0191.0: SUPO0, SUPO2
+    c_test/super_test/SUP10560-depth-embed-bin1-t0103.1: SUPO0, SUPO2
+    c_test/super_test/SUP10561-depth-embed-bin1-t0122.1: SUPO0, SUPO2
+    c_test/super_test/SUP10562-depth-embed-bin1-t0121.2: SUPO0, SUPO2
+    c_test/super_test/SUP10563-depth-embed-bin1-t0150.1: SUPO0, SUPO2
+    c_test/super_test/SUP10564-depth-embed-bin1-t0028.1: SUPO0, SUPO2
+    c_test/super_test/SUP10565-depth-embed-bin1-t0100.0: SUPO0, SUPO2
+    c_test/super_test/SUP10566-depth-embed-bin1-t0171.2: SUPO0, SUPO2
+    c_test/super_test/SUP10567-depth-embed-bin1-t0119.0: SUPO0, SUPO2
+    c_test/super_test/SUP10568-depth-embed-bin1-t0029.0: SUPO0, SUPO2
+    c_test/super_test/SUP10569-depth-embed-bin1-t0135.2: SUPO0, SUPO2
+    c_test/super_test/SUP10570-depth-embed-bin1-t0112.1: SUPO0, SUPO2
+    c_test/super_test/SUP10571-depth-embed-bin1-t0034.1: SUPO0, SUPO2
+    c_test/super_test/SUP10572-depth-embed-bin1-t0175.0: SUPO0, SUPO2
+    c_test/super_test/SUP10573-depth-embed-bin1-t0170.0: SUPO0, SUPO2
+    c_test/super_test/SUP10574-depth-embed-bin1-t0106.4: SUPO0, SUPO2
+    c_test/super_test/SUP10575-depth-embed-bin1-t0193.1: SUPO0, SUPO2
+    c_test/super_test/SUP10576-depth-embed-bin1-t0129.3: SUPO0, SUPO2
+    c_test/super_test/SUP10577-depth-embed-bin1-t0128.2: SUPO0, SUPO2
+    c_test/super_test/SUP10578-depth-embed-bin1-t0137.3: SUPO0, SUPO2
+    c_test/super_test/SUP10579-depth-embed-bin1-t0083.0: SUPO0, SUPO2
+    c_test/super_test/SUP10580-depth-embed-bin1-t0008.0: SUPO0, SUPO2
+    c_test/super_test/SUP10581-depth-embed-bin1-t0073.0: SUPO0, SUPO2
+    c_test/super_test/SUP10582-depth-embed-bin1-t0181.0: SUPO0, SUPO2
+    c_test/super_test/SUP10583-depth-embed-bin1-t0031.0: SUPO0, SUPO2
+    c_test/super_test/SUP10584-depth-embed-bin1-t0103.5: SUPO0, SUPO2
+    c_test/super_test/SUP10585-depth-embed-bin1-t0152.0: SUPO0, SUPO2
+    c_test/super_test/SUP10586-depth-embed-bin1-t0066.0: SUPO0, SUPO2
+    c_test/super_test/SUP10587-depth-embed-bin1-t0153.0: SUPO0, SUPO2
+    c_test/super_test/SUP10588-depth-embed-bin1-t0120.1: SUPO0, SUPO2
+    c_test/super_test/SUP10589-depth-embed-bin1-t0017.0: SUPO0, SUPO2
+    c_test/super_test/SUP10590-depth-embed-bin1-t0195.1: SUPO0, SUPO2
+    c_test/super_test/SUP10591-depth-embed-bin1-t0039.1: SUPO0, SUPO2
+    c_test/super_test/SUP10592-depth-embed-bin1-t0013.3: SUPO0, SUPO2
+    c_test/super_test/SUP10593-depth-embed-bin1-t0108.2: SUPO0, SUPO2
+    c_test/super_test/SUP10594-depth-embed-bin1-t0064.0: SUPO0, SUPO2
+    c_test/super_test/SUP10595-depth-embed-bin1-t0011.2: SUPO0, SUPO2
+    c_test/super_test/SUP10596-depth-embed-bin1-t0125.3: SUPO0, SUPO2
+    c_test/super_test/SUP10597-depth-embed-bin1-t0010.1: SUPO0, SUPO2
+    c_test/super_test/SUP10598-depth-embed-bin1-t0022.2: SUPO0, SUPO2
+    c_test/super_test/SUP10599-depth-embed-bin1-t0123.3: SUPO0, SUPO2
+    c_test/super_test/SUP10600-depth-embed-bin1-t0040.0: SUPO0, SUPO2
+    c_test/super_test/SUP10601-depth-embed-bin1-t0125.2: SUPO0, SUPO2
+    c_test/super_test/SUP10602-depth-embed-bin1-t0157.1: SUPO0, SUPO2
+    c_test/super_test/SUP10603-depth-embed-bin1-t0064.1: SUPO0, SUPO2
+    c_test/super_test/SUP10604-depth-embed-bin1-t0054.1: SUPO0, SUPO2
+    c_test/super_test/SUP10605-depth-embed-bin1-t0172.0: SUPO0, SUPO2
+    c_test/super_test/SUP10606-depth-embed-bin1-t0183.2: SUPO0, SUPO2
+    c_test/super_test/SUP10607-depth-embed-bin1-t0019.3: SUPO0, SUPO2
+    c_test/super_test/SUP10608-depth-embed-bin1-t0131.2: SUPO0, SUPO2
+    c_test/super_test/SUP10609-depth-embed-bin1-t0141.0: SUPO0, SUPO2
+    c_test/super_test/SUP10610-depth-embed-bin1-t0075.0: SUPO0, SUPO2
+    c_test/super_test/SUP10611-depth-embed-bin1-t0037.2: SUPO0, SUPO2
+    c_test/super_test/SUP10612-depth-embed-bin1-t0121.6: SUPO0, SUPO2
+    c_test/super_test/SUP10613-depth-embed-bin1-t0025.3: SUPO0, SUPO2
+    c_test/super_test/SUP10614-depth-embed-bin1-t0020.2: SUPO0, SUPO2
+    c_test/super_test/SUP10615-depth-embed-bin1-t0076.1: SUPO0, SUPO2
+    c_test/super_test/SUP10616-depth-embed-bin1-t0126.2: SUPO0, SUPO2
+    c_test/super_test/SUP10617-depth-embed-bin1-t0164.1: SUPO0, SUPO2
+    c_test/super_test/SUP10618-depth-embed-bin1-t0106.0: SUPO0, SUPO2
+    c_test/super_test/SUP10619-depth-embed-bin1-t0091.1: SUPO0, SUPO2
+    c_test/super_test/SUP10620-depth-embed-bin1-t0021.2: SUPO0, SUPO2
+    c_test/super_test/SUP10621-depth-embed-bin1-t0028.2: SUPO0, SUPO2
+    c_test/super_test/SUP10622-depth-embed-bin1-t0071.0: SUPO0, SUPO2
+    c_test/super_test/SUP10623-depth-embed-bin1-t0110.1: SUPO0, SUPO2
+    c_test/super_test/SUP10624-depth-embed-bin1-t0113.1: SUPO0, SUPO2
+    c_test/super_test/SUP10625-depth-embed-bin1-t0111.3: SUPO0, SUPO2
+    c_test/super_test/SUP10626-depth-embed-bin1-t0104.0: SUPO0, SUPO2
+    c_test/super_test/SUP10627-depth-embed-bin1-t0125.5: SUPO0, SUPO2
+    c_test/super_test/SUP10628-depth-embed-bin1-t0133.2: SUPO0, SUPO2
+    c_test/super_test/SUP10629-depth-embed-bin1-t0003.4: SUPO0, SUPO2
+    c_test/super_test/SUP10630-depth-embed-bin1-t0033.4: SUPO0, SUPO2
+    c_test/super_test/SUP10631-depth-embed-bin1-t0027.4: SUPO0, SUPO2
+    c_test/super_test/SUP10632-depth-embed-bin1-t0016.3: SUPO0, SUPO2
+    c_test/super_test/SUP10633-depth-embed-bin1-t0164.0: SUPO0, SUPO2
+    c_test/super_test/SUP10634-depth-embed-bin1-t0038.1: SUPO0, SUPO2
+    c_test/super_test/SUP10635-depth-embed-bin1-t0097.1: SUPO0, SUPO2
+    c_test/super_test/SUP10636-depth-embed-bin1-t0122.2: SUPO0, SUPO2
+    c_test/super_test/SUP10637-depth-embed-bin1-t0112.2: SUPO0, SUPO2
+    c_test/super_test/SUP10638-depth-embed-bin1-t0109.1: SUPO0, SUPO2
+    c_test/super_test/SUP10639-depth-embed-bin1-t0131.0: SUPO0, SUPO2
+    c_test/super_test/SUP10640-depth-embed-bin1-t0137.1: SUPO0, SUPO2
+    c_test/super_test/SUP10641-depth-embed-bin1-t0013.4: SUPO0, SUPO2
+    c_test/super_test/SUP10642-depth-embed-bin1-t0116.0: SUPO0, SUPO2
+    c_test/super_test/SUP10643-depth-embed-bin1-t0112.3: SUPO0, SUPO2
+    c_test/super_test/SUP10644-depth-embed-bin1-t0001.3: SUPO0, SUPO2
+    c_test/super_test/SUP10645-depth-embed-bin1-t0019.0: SUPO0, SUPO2
+    c_test/super_test/SUP10646-depth-embed-bin1-t0016.0: SUPO0, SUPO2
+    c_test/super_test/SUP10647-depth-embed-bin1-t0124.3: SUPO0, SUPO2
+    c_test/super_test/SUP10648-depth-embed-bin1-t0166.0: SUPO0, SUPO2
+    c_test/super_test/SUP10649-depth-embed-bin1-t0127.0: SUPO0, SUPO2
+    c_test/super_test/SUP10650-depth-embed-bin1-t0013.2: SUPO0, SUPO2
+    c_test/super_test/SUP10651-depth-embed-bin1-t0009.2: SUPO0, SUPO2
+    c_test/super_test/SUP10652-depth-embed-bin1-t0010.2: SUPO0, SUPO2
+    c_test/super_test/SUP10653-depth-embed-bin1-t0101.3: SUPO0, SUPO2
+    c_test/super_test/SUP10654-depth-embed-bin1-t0171.0: SUPO0, SUPO2
+    c_test/super_test/SUP10655-depth-embed-bin1-t0108.1: SUPO0, SUPO2
+    c_test/super_test/SUP10656-depth-embed-bin1-t0077.2: SUPO0, SUPO2
+    c_test/super_test/SUP10657-depth-embed-bin1-t0034.0: SUPO0, SUPO2
+    c_test/super_test/SUP10658-depth-embed-bin1-t0003.2: SUPO0, SUPO2
+    c_test/super_test/SUP10659-depth-embed-bin1-t0019.2: SUPO0, SUPO2
+    c_test/super_test/SUP10660-depth-embed-bin1-t0097.0: SUPO0, SUPO2
+    c_test/super_test/SUP10661-depth-embed-bin1-t0025.0: SUPO0, SUPO2
+    c_test/super_test/SUP10662-depth-embed-bin1-t0018.2: SUPO0, SUPO2
+    c_test/super_test/SUP10663-depth-embed-bin1-t0075.1: SUPO0, SUPO2
+    c_test/super_test/SUP10664-depth-embed-bin1-t0012.0: SUPO0, SUPO2
+    c_test/super_test/SUP10665-depth-embed-bin1-t0185.1: SUPO0, SUPO2
+    c_test/super_test/SUP10666-depth-embed-bin1-t0028.0: SUPO0, SUPO2
+    c_test/super_test/SUP10667-depth-embed-bin1-t0009.0: SUPO0, SUPO2
+    c_test/super_test/SUP10668-depth-embed-bin1-t0106.1: SUPO0, SUPO2
+    c_test/super_test/SUP10669-depth-embed-bin1-t0126.3: SUPO0, SUPO2
+    c_test/super_test/SUP10670-depth-embed-bin1-t0055.1: SUPO0, SUPO2
+    c_test/super_test/SUP10671-depth-embed-bin1-t0065.1: SUPO0, SUPO2
+    c_test/super_test/SUP10672-depth-embed-bin1-t0004.0: SUPO0, SUPO2
+    c_test/super_test/SUP10673-depth-embed-bin1-t0166.1: SUPO0, SUPO2
+    c_test/super_test/SUP10674-depth-embed-bin1-t0035.0: SUPO0, SUPO2
+    c_test/super_test/SUP10675-depth-embed-bin1-t0116.1: SUPO0, SUPO2
+    c_test/super_test/SUP10676-depth-embed-bin1-t0118.0: SUPO0, SUPO2
+    c_test/super_test/SUP10677-depth-embed-bin1-t0057.0: SUPO0, SUPO2
+    c_test/super_test/SUP10678-depth-embed-bin1-t0030.3: SUPO0, SUPO2
+    c_test/super_test/SUP10679-depth-embed-bin1-t0030.2: SUPO0, SUPO2
+    c_test/super_test/SUP10680-depth-embed-bin1-t0116.2: SUPO0, SUPO2
+    c_test/super_test/SUP10681-depth-embed-bin1-t0006.0: SUPO0, SUPO2
+    c_test/super_test/SUP10682-depth-embed-bin1-t0162.0: SUPO0, SUPO2
+    c_test/super_test/SUP10683-depth-embed-bin1-t0010.3: SUPO0, SUPO2
+    c_test/super_test/SUP10684-depth-embed-bin1-t0121.4: SUPO0, SUPO2
+    c_test/super_test/SUP10685-depth-embed-bin1-t0191.2: SUPO0, SUPO2
+    c_test/super_test/SUP10686-depth-embed-bin1-t0070.1: SUPO0, SUPO2
+    c_test/super_test/SUP10687-depth-embed-bin1-t0056.0: SUPO0, SUPO2
+    c_test/super_test/SUP10688-depth-embed-bin1-t0177.1: SUPO0, SUPO2
+    c_test/super_test/SUP10689-depth-embed-bin1-t0072.1: SUPO0, SUPO2
+    c_test/super_test/SUP10690-depth-embed-bin1-t0103.2: SUPO0, SUPO2
+    c_test/super_test/SUP10691-depth-embed-bin1-t0118.1: SUPO0, SUPO2
+    c_test/super_test/SUP10692-depth-embed-bin1-t0176.1: SUPO0, SUPO2
+    c_test/super_test/SUP10693-depth-embed-bin1-t0105.1: SUPO0, SUPO2
+    c_test/super_test/SUP10694-depth-embed-bin1-t0101.6: SUPO0, SUPO2
+    c_test/super_test/SUP10695-depth-embed-bin1-t0007.2: SUPO0, SUPO2
+    c_test/super_test/SUP10696-depth-embed-bin1-t0117.1: SUPO0, SUPO2
+    c_test/super_test/SUP10697-depth-embed-bin1-t0137.2: SUPO0, SUPO2
+    c_test/super_test/SUP10698-depth-embed-bin1-t0087.1: SUPO0, SUPO2
+    c_test/super_test/SUP10699-depth-embed-bin1-t0007.4: SUPO0, SUPO2
+    c_test/super_test/SUP10700-depth-embed-bin1-t0029.3: SUPO0, SUPO2
+    c_test/super_test/SUP10701-depth-embed-bin1-t0077.1: SUPO0, SUPO2
+    c_test/super_test/SUP10702-depth-embed-bin1-t0024.0: SUPO0, SUPO2
+    c_test/super_test/SUP10703-depth-embed-bin1-t0037.4: SUPO0, SUPO2
+    c_test/super_test/SUP10704-depth-embed-bin1-t0001.5: SUPO0, SUPO2
+    c_test/super_test/SUP10705-depth-embed-bin1-t0173.2: SUPO0, SUPO2
+    c_test/super_test/SUP10706-depth-embed-bin1-t0002.1: SUPO0, SUPO2
+    c_test/super_test/SUP10707-depth-embed-bin1-t0121.0: SUPO0, SUPO2
+    c_test/super_test/SUP10708-depth-embed-bin1-t0115.0: SUPO0, SUPO2
+    c_test/super_test/SUP10709-depth-embed-bin1-t0008.1: SUPO0, SUPO2
+    c_test/super_test/SUP10710-depth-embed-bin1-t0174.0: SUPO0, SUPO2
+    c_test/super_test/SUP10711-depth-embed-bin1-t0075.2: SUPO0, SUPO2
+    c_test/super_test/SUP10712-depth-embed-bin1-t0115.1: SUPO0, SUPO2
+    c_test/super_test/SUP10713-depth-embed-bin1-t0031.1: SUPO0, SUPO2
+    c_test/super_test/SUP10714-depth-embed-bin1-t0123.4: SUPO0, SUPO2
+    c_test/super_test/SUP10715-depth-embed-bin1-t0029.2: SUPO0, SUPO2
+    c_test/super_test/SUP10716-depth-embed-bin1-t0043.0: SUPO0, SUPO2
+    c_test/super_test/SUP10717-depth-embed-bin1-t0125.6: SUPO0, SUPO2
+    c_test/super_test/SUP10718-depth-embed-bin1-t0073.2: SUPO0, SUPO2
+    c_test/super_test/SUP10719-depth-embed-bin1-t0122.0: SUPO0, SUPO2
+    c_test/super_test/SUP10720-depth-embed-bin1-t0005.4: SUPO0, SUPO2
+    c_test/super_test/SUP10721-depth-embed-bin1-t0007.0: SUPO0, SUPO2
+    c_test/super_test/SUP10722-depth-embed-bin1-t0127.3: SUPO0, SUPO2
+    c_test/super_test/SUP10723-depth-embed-bin1-t0067.1: SUPO0, SUPO2
+    c_test/super_test/SUP10724-depth-embed-bin1-t0173.0: SUPO0, SUPO2
+    c_test/super_test/SUP10725-depth-embed-bin1-t0035.2: SUPO0, SUPO2
+    c_test/super_test/SUP10726-depth-embed-bin1-t0133.3: SUPO0, SUPO2
+    c_test/super_test/SUP10727-depth-embed-bin1-t0001.0: SUPO0, SUPO2
+    c_test/super_test/SUP10728-depth-embed-bin1-t0065.2: SUPO0, SUPO2
+    c_test/super_test/SUP10729-depth-embed-bin1-t0115.4: SUPO0, SUPO2
+    c_test/super_test/SUP10730-depth-embed-bin1-t0023.2: SUPO0, SUPO2
+    c_test/super_test/SUP10731-depth-embed-bin1-t0161.0: SUPO0, SUPO2
+    c_test/super_test/SUP10732-depth-embed-bin1-t0102.4: SUPO0, SUPO2
+    c_test/super_test/SUP10733-depth-embed-bin1-t0102.1: SUPO0, SUPO2
+    c_test/super_test/SUP10734-depth-embed-bin1-t0051.0: SUPO0, SUPO2
+    c_test/super_test/SUP10735-depth-embed-bin1-t0138.2: SUPO0, SUPO2
+    c_test/super_test/SUP10736-depth-embed-bin1-t0014.3: SUPO0, SUPO2
+    c_test/super_test/SUP10737-depth-embed-bin1-t0050.0: SUPO0, SUPO2
+    c_test/super_test/SUP10738-depth-embed-bin1-t0015.0: SUPO0, SUPO2
+    c_test/super_test/SUP10739-depth-embed-bin1-t0195.2: SUPO0, SUPO2
+    c_test/super_test/SUP10740-depth-embed-bin1-t0119.2: SUPO0, SUPO2
+    c_test/super_test/SUP10741-depth-embed-bin1-t0024.1: SUPO0, SUPO2
+    c_test/super_test/SUP10742-depth-embed-bin1-t0144.0: SUPO0, SUPO2
+    c_test/super_test/SUP10743-depth-embed-bin1-t0001.1: SUPO0, SUPO2
+    c_test/super_test/SUP10744-depth-embed-bin1-t0134.1: SUPO0, SUPO2
+    c_test/super_test/SUP10745-depth-embed-bin1-t0044.0: SUPO0, SUPO2
+    c_test/super_test/SUP10746-depth-embed-bin1-t0026.0: SUPO0, SUPO2
+    c_test/super_test/SUP10747-depth-embed-bin1-t0193.2: SUPO0, SUPO2
+    c_test/super_test/SUP10748-depth-embed-bin1-t0035.3: SUPO0, SUPO2
+    c_test/super_test/SUP10749-depth-embed-bin1-t0009.3: SUPO0, SUPO2
+    c_test/super_test/SUP10750-depth-embed-bin1-t0161.1: SUPO0, SUPO2
+    c_test/super_test/SUP10751-depth-embed-bin1-t0116.4: SUPO0, SUPO2
+    c_test/super_test/SUP10752-depth-embed-bin1-t0124.0: SUPO0, SUPO2
+    c_test/super_test/SUP10753-depth-embed-bin1-t0018.0: SUPO0, SUPO2
+    c_test/super_test/SUP10754-depth-embed-bin1-t0114.4: SUPO0, SUPO2
+    c_test/super_test/SUP10755-depth-embed-bin1-t0035.4: SUPO0, SUPO2
+    c_test/super_test/SUP10756-depth-embed-bin1-t0125.1: SUPO0, SUPO2
+    c_test/super_test/SUP10757-depth-embed-bin1-t0007.3: SUPO0, SUPO2
+    c_test/super_test/SUP10758-depth-embed-bin1-t0109.3: SUPO0, SUPO2
+    c_test/super_test/SUP10759-depth-embed-bin1-t0011.0: SUPO0, SUPO2
+    c_test/super_test/SUP10760-depth-embed-bin1-t0117.2: SUPO0, SUPO2
+    c_test/super_test/SUP10761-depth-embed-bin1-t0119.3: SUPO0, SUPO2
+    c_test/super_test/SUP10762-depth-embed-bin1-t0062.0: SUPO0, SUPO2
+    c_test/super_test/SUP10763-depth-embed-bin1-t0156.0: SUPO0, SUPO2
+    c_test/super_test/SUP10764-depth-embed-bin1-t0035.1: SUPO0, SUPO2
+    c_test/super_test/SUP10765-depth-embed-bin1-t0187.2: SUPO0, SUPO2
+    c_test/super_test/SUP10766-depth-embed-bin1-t0022.1: SUPO0, SUPO2
+    c_test/super_test/SUP10767-depth-embed-bin1-t0017.3: SUPO0, SUPO2
+    c_test/super_test/SUP10768-depth-embed-bin1-t0027.1: SUPO0, SUPO2
+    c_test/super_test/SUP10769-depth-embed-bin1-t0128.1: SUPO0, SUPO2
+    c_test/super_test/SUP10770-depth-embed-bin1-t0004.3: SUPO0, SUPO2
+    c_test/super_test/SUP10771-depth-embed-bin1-t0020.0: SUPO0, SUPO2
+    c_test/super_test/SUP10772-depth-embed-bin1-t0015.2: SUPO0, SUPO2
+    c_test/super_test/SUP10773-depth-embed-bin1-t0130.0: SUPO0, SUPO2
+    c_test/super_test/SUP10774-depth-embed-bin1-t0032.1: SUPO0, SUPO2
+    c_test/super_test/SUP10775-depth-embed-bin1-t0107.2: SUPO0, SUPO2
+    c_test/super_test/SUP10776-depth-embed-bin1-t0038.0: SUPO0, SUPO2
+    c_test/super_test/SUP10777-depth-embed-bin1-t0112.4: SUPO0, SUPO2
+    c_test/super_test/SUP10778-depth-embed-bin1-t0191.1: SUPO0, SUPO2
+    c_test/super_test/SUP10779-depth-embed-bin1-t0136.2: SUPO0, SUPO2
+    c_test/super_test/SUP10780-depth-embed-bin1-t0053.0: SUPO0, SUPO2
+    c_test/super_test/SUP10781-depth-embed-bin1-t0138.0: SUPO0, SUPO2
+    c_test/super_test/SUP10782-depth-embed-bin1-t0109.0: SUPO0, SUPO2
+    c_test/super_test/SUP10783-depth-embed-bin1-t0022.3: SUPO0, SUPO2
+    c_test/super_test/SUP10784-depth-embed-bin1-t0103.0: SUPO0, SUPO2
+    c_test/super_test/SUP10785-depth-embed-bin1-t0124.4: SUPO0, SUPO2
+    c_test/super_test/SUP10786-depth-embed-bin1-t0135.3: SUPO0, SUPO2
+    c_test/super_test/SUP10787-depth-embed-bin1-t0163.0: SUPO0, SUPO2
+    c_test/super_test/SUP10788-depth-embed-bin1-t0131.3: SUPO0, SUPO2
+    c_test/super_test/SUP10789-depth-embed-bin1-t0134.0: SUPO0, SUPO2
+    c_test/super_test/SUP10790-depth-embed-bin1-t0101.2: SUPO0, SUPO2
+    c_test/super_test/SUP10791-depth-embed-bin1-t0127.1: SUPO0, SUPO2
+    c_test/super_test/SUP10792-depth-embed-bin1-t0012.1: SUPO0, SUPO2
+    c_test/super_test/SUP10793-depth-embed-bin1-t0031.4: SUPO0, SUPO2
+    c_test/super_test/SUP10794-depth-embed-bin1-t0021.0: SUPO0, SUPO2
+    c_test/super_test/SUP10795-depth-embed-bin1-t0185.2: SUPO0, SUPO2
+    c_test/super_test/SUP10796-depth-embed-bin1-t0071.2: SUPO0, SUPO2
+    c_test/super_test/SUP10797-depth-embed-bin1-t0023.3: SUPO0, SUPO2
+    c_test/super_test/SUP10798-depth-embed-bin1-t0111.5: SUPO0, SUPO2
+    c_test/super_test/SUP10799-depth-embed-bin1-t0162.1: SUPO0, SUPO2
+    c_test/super_test/SUP10800-depth-embed-bin1-t0104.2: SUPO0, SUPO2
+    c_test/super_test/SUP10801-depth-embed-bin1-t0014.1: SUPO0, SUPO2
+    c_test/super_test/SUP10802-depth-embed-bin1-t0085.1: SUPO0, SUPO2
+    c_test/super_test/SUP10803-depth-embed-bin1-t0031.3: SUPO0, SUPO2
+    c_test/super_test/SUP10804-depth-embed-bin1-t0012.2: SUPO0, SUPO2
+    c_test/super_test/SUP10805-depth-embed-bin1-t0183.1: SUPO0, SUPO2
+    c_test/super_test/SUP10806-depth-embed-bin1-t0024.2: SUPO0, SUPO2
+    c_test/super_test/SUP10807-depth-embed-bin1-t0025.1: SUPO0, SUPO2
+    c_test/super_test/SUP10808-depth-embed-bin1-t0157.0: SUPO0, SUPO2
+    c_test/super_test/SUP10809-depth-embed-bin1-t0134.2: SUPO0, SUPO2
+    c_test/super_test/SUP10810-depth-embed-bin1-t0113.6: SUPO0, SUPO2
+    c_test/super_test/SUP10811-depth-embed-bin1-t0102.2: SUPO0, SUPO2
+    c_test/super_test/SUP10812-depth-embed-bin1-t0017.2: SUPO0, SUPO2
+    c_test/super_test/SUP10813-depth-embed-bin1-t0122.3: SUPO0, SUPO2
+    c_test/super_test/SUP10814-depth-embed-bin1-t0027.2: SUPO0, SUPO2
+    c_test/super_test/SUP10815-depth-embed-bin1-t0165.0: SUPO0, SUPO2
+    c_test/super_test/SUP10816-depth-embed-bin1-t0110.0: SUPO0, SUPO2
+    c_test/super_test/SUP10817-depth-embed-bin1-t0132.1: SUPO0, SUPO2
+    c_test/super_test/SUP10818-depth-embed-bin1-t0000.2: SUPO0, SUPO2
+    c_test/super_test/SUP10819-depth-embed-bin1-t0062.1: SUPO0, SUPO2
+    c_test/super_test/SUP10820-depth-embed-bin1-t0104.3: SUPO0, SUPO2
+    c_test/super_test/SUP10821-depth-embed-bin1-t0107.1: SUPO0, SUPO2
+    c_test/super_test/SUP10822-depth-embed-bin1-t0107.3: SUPO0, SUPO2
+    c_test/super_test/SUP10823-depth-embed-bin1-t0110.2: SUPO0, SUPO2
+    c_test/super_test/SUP10824-depth-embed-bin1-t0033.0: SUPO0, SUPO2
+    c_test/super_test/SUP10825-depth-embed-bin1-t0115.3: SUPO0, SUPO2
+    c_test/super_test/SUP10826-depth-embed-bin1-t0117.6: SUPO0, SUPO2
+    c_test/super_test/SUP10827-depth-embed-bin1-t0115.5: SUPO0, SUPO2
+    c_test/super_test/SUP10828-depth-embed-bin1-t0123.2: SUPO0, SUPO2
+    c_test/super_test/SUP10829-depth-embed-bin1-t0132.2: SUPO0, SUPO2
+    c_test/super_test/SUP10830-depth-embed-bin1-t0108.0: SUPO0, SUPO2
+    c_test/super_test/SUP10831-depth-embed-bin1-t0011.3: SUPO0, SUPO2
+    c_test/super_test/SUP10832-depth-embed-bin1-t0181.2: SUPO0, SUPO2
+    c_test/super_test/SUP10833-depth-embed-bin1-t0151.2: SUPO0, SUPO2
+    c_test/super_test/SUP10834-depth-embed-bin1-t0093.0: SUPO0, SUPO2
+    c_test/super_test/SUP10835-depth-embed-bin1-t0121.5: SUPO0, SUPO2
+    c_test/super_test/SUP10836-depth-embed-bin1-t0081.0: SUPO0, SUPO2
+    c_test/super_test/SUP10837-depth-embed-bin1-t0109.2: SUPO0, SUPO2
+    c_test/super_test/SUP10838-depth-embed-bin1-t0006.1: SUPO0, SUPO2
+    c_test/super_test/SUP10839-depth-embed-bin1-t0197.1: SUPO0, SUPO2
+    c_test/super_test/SUP10840-depth-embed-bin1-t0023.4: SUPO0, SUPO2
+    c_test/super_test/SUP10841-depth-embed-bin1-t0004.2: SUPO0, SUPO2
+    c_test/super_test/SUP10842-depth-embed-bin1-t0016.2: SUPO0, SUPO2
+    c_test/super_test/SUP10843-depth-embed-bin1-t0187.0: SUPO0, SUPO2
+    c_test/super_test/SUP10844-depth-embed-bin1-t0103.6: SUPO0, SUPO2
+    c_test/super_test/SUP10845-depth-embed-bin1-t0076.0: SUPO0, SUPO2
+    c_test/super_test/SUP10846-depth-embed-bin1-t0101.0: SUPO0, SUPO2
+    c_test/super_test/SUP10847-depth-embed-bin1-t0163.1: SUPO0, SUPO2
+    c_test/super_test/SUP10848-depth-embed-bin1-t0030.1: SUPO0, SUPO2
+    c_test/super_test/SUP10849-depth-embed-bin1-t0113.0: SUPO0, SUPO2
+    c_test/super_test/SUP10850-depth-embed-bin1-t0065.0: SUPO0, SUPO2
+    c_test/super_test/SUP10851-depth-embed-bin1-t0017.4: SUPO0, SUPO2
+    c_test/super_test/SUP10852-depth-embed-bin1-t0133.0: SUPO0, SUPO2
+    c_test/super_test/SUP10853-depth-embed-bin1-t0110.3: SUPO0, SUPO2
+    c_test/super_test/SUP10854-depth-embed-bin1-t0005.0: SUPO0, SUPO2
+    c_test/super_test/SUP10855-depth-embed-bin1-t0181.1: SUPO0, SUPO2
+    c_test/super_test/SUP10856-depth-embed-bin1-t0174.1: SUPO0, SUPO2
+    c_test/super_test/SUP10857-depth-embed-bin1-t0105.4: SUPO0, SUPO2
+    c_test/super_test/SUP10858-depth-embed-bin1-t0005.1: SUPO0, SUPO2
+    c_test/super_test/SUP10859-depth-embed-bin1-t0170.1: SUPO0, SUPO2
+    c_test/super_test/SUP10860-depth-embed-bin1-t0027.0: SUPO0, SUPO2
+    c_test/super_test/SUP10861-depth-embed-bin1-t0177.2: SUPO0, SUPO2
+    c_test/super_test/SUP10862-depth-embed-bin1-t0183.0: SUPO0, SUPO2
+    c_test/super_test/SUP10863-depth-embed-bin1-t0007.1: SUPO0, SUPO2
+    c_test/super_test/SUP10864-depth-embed-bin1-t0139.0: SUPO0, SUPO2
+    c_test/super_test/SUP10865-depth-embed-bin1-t0000.3: SUPO0, SUPO2
+    c_test/super_test/SUP10866-depth-embed-bin1-t0081.1: SUPO0, SUPO2
+    c_test/super_test/SUP10867-depth-embed-bin1-t0107.4: SUPO0, SUPO2
+    c_test/super_test/SUP10868-depth-embed-bin1-t0143.0: SUPO0, SUPO2
+    c_test/super_test/SUP10869-depth-embed-bin1-t0157.2: SUPO0, SUPO2
+    c_test/super_test/SUP10870-depth-embed-bin1-t0117.4: SUPO0, SUPO2
+    c_test/super_test/SUP10871-depth-embed-bin1-t0120.0: SUPO0, SUPO2
+    c_test/super_test/SUP10872-depth-embed-bin1-t0105.6: SUPO0, SUPO2
+    c_test/super_test/SUP10873-depth-embed-bin1-t0117.3: SUPO0, SUPO2
+    c_test/super_test/SUP10874-depth-embed-bin1-t0125.4: SUPO0, SUPO2
+    c_test/super_test/SUP10875-depth-embed-bin1-t0154.1: SUPO0, SUPO2
+    c_test/super_test/SUP10876-depth-embed-bin1-t0153.1: SUPO0, SUPO2
+    c_test/super_test/SUP10877-depth-embed-bin1-t0129.1: SUPO0, SUPO2
+    c_test/super_test/SUP10878-depth-embed-bin1-t0127.2: SUPO0, SUPO2
+    c_test/super_test/SUP10879-depth-embed-bin1-t0197.2: SUPO0, SUPO2
+    c_test/super_test/SUP10880-depth-embed-bin1-t0111.6: SUPO0, SUPO2
+    c_test/super_test/SUP10881-depth-embed-bin1-t0114.3: SUPO0, SUPO2
+    c_test/super_test/SUP10882-depth-embed-bin1-t0113.2: SUPO0, SUPO2
+    c_test/super_test/SUP10883-depth-embed-bin1-t0176.0: SUPO0, SUPO2
+    c_test/super_test/SUP10884-depth-embed-bin1-t0013.0: SUPO0, SUPO2
+    c_test/super_test/SUP10885-depth-embed-bin1-t0113.3: SUPO0, SUPO2
+    c_test/super_test/SUP10886-depth-embed-bin1-t0105.3: SUPO0, SUPO2
+    c_test/super_test/SUP10887-depth-embed-bin1-t0037.1: SUPO0, SUPO2
+    c_test/super_test/SUP10888-depth-embed-bin1-t0042.0: SUPO0, SUPO2
+    c_test/super_test/SUP10889-depth-embed-bin1-t0017.1: SUPO0, SUPO2
+    c_test/super_test/SUP10890-depth-embed-bin1-t0175.2: SUPO0, SUPO2
+    c_test/super_test/SUP10891-depth-embed-bin1-t0085.0: SUPO0, SUPO2
+    c_test/super_test/SUP10892-depth-embed-bin1-t0011.1: SUPO0, SUPO2
+    c_test/super_test/SUP10893-depth-embed-bin1-t0161.2: SUPO0, SUPO2
+    c_test/super_test/SUP10894-depth-embed-bin1-t0050.1: SUPO0, SUPO2
+    c_test/super_test/SUP10895-depth-embed-bin1-t0124.2: SUPO0, SUPO2
+    c_test/super_test/SUP10896-depth-embed-bin1-t0100.4: SUPO0, SUPO2
+    c_test/super_test/SUP10897-depth-embed-bin1-t0001.2: SUPO0, SUPO2
+    c_test/super_test/SUP10898-depth-embed-bin1-t0165.1: SUPO0, SUPO2
+    c_test/super_test/SUP10899-depth-embed-bin1-t0016.1: SUPO0, SUPO2
+    c_test/super_test/SUP10900-depth-embed-bin1-t0106.3: SUPO0, SUPO2
+    c_test/super_test/SUP10901-depth-embed-bin1-t0025.4: SUPO0, SUPO2
+    c_test/super_test/SUP10902-depth-embed-bin1-t0171.1: SUPO0, SUPO2
+    c_test/super_test/SUP10903-depth-embed-bin1-t0135.1: SUPO0, SUPO2
+    c_test/super_test/SUP10904-depth-embed-bin1-t0101.5: SUPO0, SUPO2
+    c_test/super_test/SUP10905-depth-embed-bin1-t0121.3: SUPO0, SUPO2
+    c_test/super_test/SUP10906-depth-embed-bin1-t0026.2: SUPO0, SUPO2
+    c_test/super_test/SUP10907-depth-embed-bin1-t0100.2: SUPO0, SUPO2
+    c_test/super_test/SUP10908-depth-embed-bin1-t0155.2: SUPO0, SUPO2
+    c_test/super_test/SUP10909-depth-embed-bin1-t0005.2: SUPO0, SUPO2
+    c_test/super_test/SUP10910-depth-embed-bin1-t0137.0: SUPO0, SUPO2
+    c_test/super_test/SUP10911-depth-embed-bin1-t0061.0: SUPO0, SUPO2
+    c_test/super_test/SUP10912-depth-embed-bin1-t0133.1: SUPO0, SUPO2
+    c_test/super_test/SUP10913-depth-embed-bin1-t0030.0: SUPO0, SUPO2
+    c_test/super_test/SUP10914-depth-embed-bin1-t0115.2: SUPO0, SUPO2
+    c_test/super_test/SUP10915-depth-embed-bin1-t0112.0: SUPO0, SUPO2
+    c_test/super_test/SUP10916-depth-embed-bin1-t0071.1: SUPO0, SUPO2
+    c_test/super_test/SUP10917-depth-embed-bin1-t0193.0: SUPO0, SUPO2
+    c_test/super_test/SUP10918-depth-embed-bin1-t0051.1: SUPO0, SUPO2
+    c_test/super_test/SUP10919-depth-embed-bin1-t0039.2: SUPO0, SUPO2
+    c_test/super_test/SUP10920-depth-embed-bin1-t0135.0: SUPO0, SUPO2
+    c_test/super_test/SUP10921-depth-embed-bin1-t0139.1: SUPO0, SUPO2
+    c_test/super_test/SUP10922-depth-embed-bin1-t0021.4: SUPO0, SUPO2
+    c_test/super_test/SUP10923-depth-embed-bin1-t0010.0: SUPO0, SUPO2
+    c_test/super_test/SUP10924-depth-embed-bin1-t0038.2: SUPO0, SUPO2
+    c_test/super_test/SUP10925-depth-embed-bin1-t0152.1: SUPO0, SUPO2
+    c_test/super_test/SUP10926-depth-embed-bin1-t0039.3: SUPO0, SUPO2
+    c_test/super_test/SUP10927-depth-embed-bin1-t0128.0: SUPO0, SUPO2
+    c_test/super_test/SUP10928-depth-embed-bin1-t0006.2: SUPO0, SUPO2
+    c_test/super_test/SUP10929-depth-embed-bin1-t0103.4: SUPO0, SUPO2
+    c_test/super_test/SUP10930-depth-embed-bin1-t0113.5: SUPO0, SUPO2
+    c_test/super_test/SUP10931-depth-embed-bin1-t0100.3: SUPO0, SUPO2
+    c_test/super_test/SUP10932-depth-embed-bin1-t0111.4: SUPO0, SUPO2
+    c_test/super_test/SUP10933-depth-embed-bin1-t0138.1: SUPO0, SUPO2
+    c_test/super_test/SUP10934-depth-embed-bin1-t0083.1: SUPO0, SUPO2
+    c_test/super_test/SUP10935-depth-embed-bin1-t0011.4: SUPO0, SUPO2
+    c_test/super_test/SUP10936-depth-embed-bin1-t0034.2: SUPO0, SUPO2
+    c_test/super_test/SUP10937-depth-embed-bin1-t0175.1: SUPO0, SUPO2
+    c_test/super_test/SUP10938-depth-embed-bin1-t0095.0: SUPO0, SUPO2
+    c_test/super_test/SUP10939-depth-embed-bin1-t0012.3: SUPO0, SUPO2
+    c_test/super_test/SUP10940-depth-embed-bin1-t0127.5: SUPO0, SUPO2
+    c_test/super_test/SUP10941-depth-embed-bin1-t0105.2: SUPO0, SUPO2
+    c_test/super_test/SUP10942-depth-embed-bin1-t0039.0: SUPO0, SUPO2
+    c_test/super_test/SUP10943-depth-embed-bin1-t0053.2: SUPO0, SUPO2
+    c_test/super_test/SUP10944-depth-embed-bin1-t0118.2: SUPO0, SUPO2
+    c_test/super_test/SUP10945-depth-embed-bin1-t0002.0: SUPO0, SUPO2
+    c_test/super_test/SUP10946-depth-embed-bin1-t0018.1: SUPO0, SUPO2
+    c_test/super_test/SUP10947-depth-embed-bin1-t0000.0: SUPO0, SUPO2
+    c_test/super_test/SUP10948-depth-embed-bin1-t0155.1: SUPO0, SUPO2
+    c_test/super_test/SUP10949-depth-embed-bin1-t0000.1: SUPO0, SUPO2
+    c_test/super_test/SUP10950-depth-embed-bin1-t0057.2: SUPO0, SUPO2
+    c_test/super_test/SUP10951-depth-embed-bin1-t0132.0: SUPO0, SUPO2
+    c_test/super_test/SUP10952-depth-embed-bin1-t0022.0: SUPO0, SUPO2
+    c_test/super_test/SUP10953-depth-embed-bin1-t0053.1: SUPO0, SUPO2
+    c_test/super_test/SUP10954-depth-embed-bin1-t0129.0: SUPO0, SUPO2
+    c_test/super_test/SUP10955-depth-embed-bin1-t0104.4: SUPO0, SUPO2
+    c_test/super_test/SUP10956-depth-embed-bin1-t0173.1: SUPO0, SUPO2
+    c_test/super_test/SUP10957-depth-embed-bin1-t0026.1: SUPO0, SUPO2
+    c_test/super_test/SUP10958-depth-embed-bin1-t0003.1: SUPO0, SUPO2
+    c_test/super_test/SUP10959-depth-embed-bin1-t0013.1: SUPO0, SUPO2
+    c_test/super_test/SUP10960-depth-embed-bin1-t0124.1: SUPO0, SUPO2
+    c_test/super_test/SUP10961-depth-embed-bin1-t0111.1: SUPO0, SUPO2
+    c_test/super_test/SUP10962-depth-embed-bin1-t0139.3: SUPO0, SUPO2
+    c_test/super_test/SUP10963-depth-embed-bin1-t0052.1: SUPO0, SUPO2
+    c_test/super_test/SUP10964-depth-embed-bin1-t0002.3: SUPO0, SUPO2
+    c_test/super_test/SUP10965-depth-embed-bin1-t0002.2: SUPO0, SUPO2
+    c_test/super_test/SUP10966-depth-embed-bin1-t0172.1: SUPO0, SUPO2
+    c_test/super_test/SUP10967-depth-embed-bin1-t0032.3: SUPO0, SUPO2
+    c_test/super_test/SUP10968-depth-embed-bin1-t0100.1: SUPO0, SUPO2
+    c_test/super_test/SUP10969-depth-embed-bin1-t0123.6: SUPO0, SUPO2
+    c_test/super_test/SUP10970-depth-embed-bin1-t0156.1: SUPO0, SUPO2
+    c_test/super_test/SUP10971-depth-embed-bin1-t0163.2: SUPO0, SUPO2
+    c_test/super_test/SUP10972-depth-embed-bin1-t0111.0: SUPO0, SUPO2
+    c_test/super_test/SUP10973-depth-embed-bin1-t0117.5: SUPO0, SUPO2
+    c_test/super_test/SUP10974-depth-embed-bin1-t0136.0: SUPO0, SUPO2
+    c_test/super_test/SUP10975-depth-embed-bin1-t0125.0: SUPO0, SUPO2
+    c_test/super_test/SUP10976-depth-embed-bin1-t0055.0: SUPO0, SUPO2
+    c_test/super_test/SUP10977-depth-embed-bin1-t0056.1: SUPO0, SUPO2
+    c_test/super_test/SUP10978-depth-embed-bin1-t0077.0: SUPO0, SUPO2
+    c_test/super_test/SUP10979-depth-embed-bin1-t0008.2: SUPO0, SUPO2
+    c_test/super_test/SUP10980-depth-embed-bin1-t0121.1: SUPO0, SUPO2
+    c_test/super_test/SUP10981-depth-embed-bin1-t0167.1: SUPO0, SUPO2
+    c_test/super_test/SUP10982-depth-embed-bin1-t0072.0: SUPO0, SUPO2
+    c_test/super_test/SUP10983-depth-embed-bin1-t0033.1: SUPO0, SUPO2
+    c_test/super_test/SUP10984-depth-embed-bin1-t0116.3: SUPO0, SUPO2
+    c_test/super_test/SUP10985-depth-embed-bin1-t0127.4: SUPO0, SUPO2
+    c_test/super_test/SUP10986-depth-embed-bin1-t0145.0: SUPO0, SUPO2
+    c_test/super_test/SUP10987-depth-embed-bin1-t0151.1: SUPO0, SUPO2
+    c_test/super_test/SUP10988-depth-embed-bin1-t0005.3: SUPO0, SUPO2
+    c_test/super_test/SUP10989-depth-embed-bin1-t0195.0: SUPO0, SUPO2
+    c_test/super_test/SUP10990-depth-embed-bin1-t0026.3: SUPO0, SUPO2
+    c_test/super_test/SUP10991-depth-embed-bin1-t0095.1: SUPO0, SUPO2
+    c_test/super_test/SUP10992-depth-embed-bin1-t0154.0: SUPO0, SUPO2
+    c_test/super_test/SUP10993-depth-embed-bin1-t0060.1: SUPO0, SUPO2
+    c_test/super_test/SUP10994-depth-embed-bin1-t0155.0: SUPO0, SUPO2
+    c_test/super_test/SUP10995-depth-embed-bin1-t0107.0: SUPO0, SUPO2
+    c_test/super_test/SUP10996-depth-embed-bin1-t0063.0: SUPO0, SUPO2
+    c_test/super_test/SUP10997-depth-embed-bin1-t0102.3: SUPO0, SUPO2
+    c_test/super_test/SUP10998-depth-embed-bin1-t0015.4: SUPO0, SUPO2
+    c_test/super_test/SUP10999-depth-embed-bin1-t0023.1: SUPO0, SUPO2
+    c_test/super_test/SUP11000-depth-embed-bin1-t0146.0: SUPO0, SUPO2
+    c_test/super_test/SUP11001-depth-embed-bin1-t0123.1: SUPO0, SUPO2
+    c_test/super_test/SUP11002-depth-embed-bin1-t0036.1: SUPO0, SUPO2
+    c_test/super_test/SUP11003-depth-embed-bin1-t0115.6: SUPO0, SUPO2
+    c_test/super_test/SUP11004-depth-embed-bin1-t0139.2: SUPO0, SUPO2
+    c_test/super_test/SUP11005-depth-embed-bin1-t0197.0: SUPO0, SUPO2
+    c_test/super_test/SUP11006-depth-embed-bin1-t0047.0: SUPO0, SUPO2
+    c_test/super_test/SUP11007-depth-embed-bin1-t0027.3: SUPO0, SUPO2
+    c_test/super_test/SUP11008-depth-embed-bin1-t0014.0: SUPO0, SUPO2
+    c_test/super_test/SUP11009-depth-embed-bin1-t0111.2: SUPO0, SUPO2
+    c_test/super_test/SUP11010-depth-embed-bin1-t0036.2: SUPO0, SUPO2
+    c_test/super_test/SUP11011-depth-embed-bin1-t0114.1: SUPO0, SUPO2
+    c_test/super_test/SUP11012-depth-embed-bin1-t0051.2: SUPO0, SUPO2
+    c_test/super_test/SUP11013-depth-embed-bin1-t0031.2: SUPO0, SUPO2
+    c_test/super_test/SUP11014-depth-embed-bin1-t0041.0: SUPO0, SUPO2
+    c_test/super_test/SUP11015-depth-embed-bin1-t0006.3: SUPO0, SUPO2
+    c_test/super_test/SUP11016-depth-embed-bin1-t0063.1: SUPO0, SUPO2
+    c_test/super_test/SUP11017-depth-embed-bin1-t0034.3: SUPO0, SUPO2
+    c_test/super_test/SUP11018-depth-embed-bin1-t0067.2: SUPO0, SUPO2
+    c_test/super_test/SUP11019-depth-embed-bin1-t0153.2: SUPO0, SUPO2
+    c_test/super_test/SUP11020-depth-embed-bin1-t0165.2: SUPO0, SUPO2
+    c_test/super_test/SUP11021-depth-embed-bin1-t0074.1: SUPO0, SUPO2
+    c_test/super_test/SUP11022-depth-embed-bin1-t0117.0: SUPO0, SUPO2
+    c_test/super_test/SUP11023-depth-embed-bin1-t0032.2: SUPO0, SUPO2
+    c_test/super_test/SUP11024-depth-embed-bin1-t0015.1: SUPO0, SUPO2
+    c_test/super_test/SUP11025-depth-embed-bin1-t0123.5: SUPO0, SUPO2
+    c_test/super_test/SUP11026-depth-embed-bin1-t0003.0: SUPO0, SUPO2
+    c_test/super_test/SUP11027-depth-embed-bin1-t0150.0: SUPO0, SUPO2
+    c_test/super_test/SUP11028-depth-embed-bin1-t0110.4: SUPO0, SUPO2
+    c_test/super_test/SUP11029-depth-embed-bin1-t0105.5: SUPO0, SUPO2
+    c_test/super_test/SUP11030-depth-embed-bin1-t0136.1: SUPO0, SUPO2
+    c_test/super_test/SUP11031-depth-embed-bin1-t0101.4: SUPO0, SUPO2
+    c_test/super_test/SUP11267-depth-embed-bin3-t0070.0: SUPO0, SUPO2
+    c_test/super_test/SUP11268-depth-embed-bin3-t0160.0: SUPO0, SUPO2
+    c_test/super_test/SUP11269-depth-embed-bin3-t0105.0: SUPO0, SUPO2
+    c_test/super_test/SUP11270-depth-embed-bin3-t0045.0: SUPO0, SUPO2
+    c_test/super_test/SUP11271-depth-embed-bin3-t0147.0: SUPO0, SUPO2
+    c_test/super_test/SUP11272-depth-embed-bin3-t0126.1: SUPO0, SUPO2
+    c_test/super_test/SUP11273-depth-embed-bin3-t0004.1: SUPO0, SUPO2
+    c_test/super_test/SUP11274-depth-embed-bin3-t0187.1: SUPO0, SUPO2
+    c_test/super_test/SUP11275-depth-embed-bin3-t0126.0: SUPO0, SUPO2
+    c_test/super_test/SUP11276-depth-embed-bin3-t0123.0: SUPO0, SUPO2
+    c_test/super_test/SUP11277-depth-embed-bin3-t0036.0: SUPO0, SUPO2
+    c_test/super_test/SUP11278-depth-embed-bin3-t0102.0: SUPO0, SUPO2
+    c_test/super_test/SUP11279-depth-embed-bin3-t0119.1: SUPO0, SUPO2
+    c_test/super_test/SUP11280-depth-embed-bin3-t0021.1: SUPO0, SUPO2
+    c_test/super_test/SUP11281-depth-embed-bin3-t0019.1: SUPO0, SUPO2
+    c_test/super_test/SUP11282-depth-embed-bin3-t0033.2: SUPO0, SUPO2
+    c_test/super_test/SUP11283-depth-embed-bin3-t0074.0: SUPO0, SUPO2
+    c_test/super_test/SUP11284-depth-embed-bin3-t0177.0: SUPO0, SUPO2
+    c_test/super_test/SUP11285-depth-embed-bin3-t0091.0: SUPO0, SUPO2
+    c_test/super_test/SUP11286-depth-embed-bin3-t0061.1: SUPO0, SUPO2
+    c_test/super_test/SUP11287-depth-embed-bin3-t0037.0: SUPO0, SUPO2
+    c_test/super_test/SUP11288-depth-embed-bin3-t0087.0: SUPO0, SUPO2
+    c_test/super_test/SUP11289-depth-embed-bin3-t0046.0: SUPO0, SUPO2
+    c_test/super_test/SUP11290-depth-embed-bin3-t0131.1: SUPO0, SUPO2
+    c_test/super_test/SUP11291-depth-embed-bin3-t0167.0: SUPO0, SUPO2
+    c_test/super_test/SUP11292-depth-embed-bin3-t0114.0: SUPO0, SUPO2
+    c_test/super_test/SUP11293-depth-embed-bin3-t0142.0: SUPO0, SUPO2
+    c_test/super_test/SUP11294-depth-embed-bin3-t0060.0: SUPO0, SUPO2
+    c_test/super_test/SUP11295-depth-embed-bin3-t0067.0: SUPO0, SUPO2
+    c_test/super_test/SUP11296-depth-embed-bin3-t0073.1: SUPO0, SUPO2
+    c_test/super_test/SUP11297-depth-embed-bin3-t0054.0: SUPO0, SUPO2
+    c_test/super_test/SUP11298-depth-embed-bin3-t0023.0: SUPO0, SUPO2
+    c_test/super_test/SUP11299-depth-embed-bin3-t0130.1: SUPO0, SUPO2
+    c_test/super_test/SUP11300-depth-embed-bin3-t0104.1: SUPO0, SUPO2
+    c_test/super_test/SUP11301-depth-embed-bin3-t0057.1: SUPO0, SUPO2
+    c_test/super_test/SUP11302-depth-embed-bin3-t0140.0: SUPO0, SUPO2
+    c_test/super_test/SUP11303-depth-embed-bin3-t0029.1: SUPO0, SUPO2
+    c_test/super_test/SUP11304-depth-embed-bin3-t0101.1: SUPO0, SUPO2
+    c_test/super_test/SUP11305-depth-embed-bin3-t0032.0: SUPO0, SUPO2
+    c_test/super_test/SUP11306-depth-embed-bin3-t0151.0: SUPO0, SUPO2
+    c_test/super_test/SUP11307-depth-embed-bin3-t0009.1: SUPO0, SUPO2
+    c_test/super_test/SUP11308-depth-embed-bin3-t0020.1: SUPO0, SUPO2
+    c_test/super_test/SUP11309-depth-embed-bin3-t0185.0: SUPO0, SUPO2
+    c_test/super_test/SUP11310-depth-embed-bin3-t0052.0: SUPO0, SUPO2
+    c_test/super_test/SUP11311-depth-embed-bin3-t0191.0: SUPO0, SUPO2
+    c_test/super_test/SUP11312-depth-embed-bin3-t0103.1: SUPO0, SUPO2
+    c_test/super_test/SUP11313-depth-embed-bin3-t0122.1: SUPO0, SUPO2
+    c_test/super_test/SUP11314-depth-embed-bin3-t0121.2: SUPO0, SUPO2
+    c_test/super_test/SUP11315-depth-embed-bin3-t0028.1: SUPO0, SUPO2
+    c_test/super_test/SUP11316-depth-embed-bin3-t0100.0: SUPO0, SUPO2
+    c_test/super_test/SUP11317-depth-embed-bin3-t0119.0: SUPO0, SUPO2
+    c_test/super_test/SUP11318-depth-embed-bin3-t0029.0: SUPO0, SUPO2
+    c_test/super_test/SUP11319-depth-embed-bin3-t0112.1: SUPO0, SUPO2
+    c_test/super_test/SUP11320-depth-embed-bin3-t0034.1: SUPO0, SUPO2
+    c_test/super_test/SUP11321-depth-embed-bin3-t0175.0: SUPO0, SUPO2
+    c_test/super_test/SUP11322-depth-embed-bin3-t0170.0: SUPO0, SUPO2
+    c_test/super_test/SUP11323-depth-embed-bin3-t0193.1: SUPO0, SUPO2
+    c_test/super_test/SUP11324-depth-embed-bin3-t0083.0: SUPO0, SUPO2
+    c_test/super_test/SUP11325-depth-embed-bin3-t0008.0: SUPO0, SUPO2
+    c_test/super_test/SUP11326-depth-embed-bin3-t0073.0: SUPO0, SUPO2
+    c_test/super_test/SUP11327-depth-embed-bin3-t0181.0: SUPO0, SUPO2
+    c_test/super_test/SUP11328-depth-embed-bin3-t0031.0: SUPO0, SUPO2
+    c_test/super_test/SUP11329-depth-embed-bin3-t0152.0: SUPO0, SUPO2
+    c_test/super_test/SUP11330-depth-embed-bin3-t0066.0: SUPO0, SUPO2
+    c_test/super_test/SUP11331-depth-embed-bin3-t0153.0: SUPO0, SUPO2
+    c_test/super_test/SUP11332-depth-embed-bin3-t0120.1: SUPO0, SUPO2
+    c_test/super_test/SUP11333-depth-embed-bin3-t0017.0: SUPO0, SUPO2
+    c_test/super_test/SUP11334-depth-embed-bin3-t0195.1: SUPO0, SUPO2
+    c_test/super_test/SUP11335-depth-embed-bin3-t0039.1: SUPO0, SUPO2
+    c_test/super_test/SUP11336-depth-embed-bin3-t0064.0: SUPO0, SUPO2
+    c_test/super_test/SUP11337-depth-embed-bin3-t0011.2: SUPO0, SUPO2
+    c_test/super_test/SUP11338-depth-embed-bin3-t0010.1: SUPO0, SUPO2
+    c_test/super_test/SUP11339-depth-embed-bin3-t0040.0: SUPO0, SUPO2
+    c_test/super_test/SUP11340-depth-embed-bin3-t0125.2: SUPO0, SUPO2
+    c_test/super_test/SUP11341-depth-embed-bin3-t0157.1: SUPO0, SUPO2
+    c_test/super_test/SUP11342-depth-embed-bin3-t0172.0: SUPO0, SUPO2
+    c_test/super_test/SUP11343-depth-embed-bin3-t0141.0: SUPO0, SUPO2
+    c_test/super_test/SUP11344-depth-embed-bin3-t0075.0: SUPO0, SUPO2
+    c_test/super_test/SUP11345-depth-embed-bin3-t0037.2: SUPO0, SUPO2
+    c_test/super_test/SUP11346-depth-embed-bin3-t0106.0: SUPO0, SUPO2
+    c_test/super_test/SUP11347-depth-embed-bin3-t0021.2: SUPO0, SUPO2
+    c_test/super_test/SUP11348-depth-embed-bin3-t0071.0: SUPO0, SUPO2
+    c_test/super_test/SUP11349-depth-embed-bin3-t0110.1: SUPO0, SUPO2
+    c_test/super_test/SUP11350-depth-embed-bin3-t0113.1: SUPO0, SUPO2
+    c_test/super_test/SUP11351-depth-embed-bin3-t0104.0: SUPO0, SUPO2
+    c_test/super_test/SUP11352-depth-embed-bin3-t0164.0: SUPO0, SUPO2
+    c_test/super_test/SUP11353-depth-embed-bin3-t0038.1: SUPO0, SUPO2
+    c_test/super_test/SUP11354-depth-embed-bin3-t0109.1: SUPO0, SUPO2
+    c_test/super_test/SUP11355-depth-embed-bin3-t0131.0: SUPO0, SUPO2
+    c_test/super_test/SUP11356-depth-embed-bin3-t0137.1: SUPO0, SUPO2
+    c_test/super_test/SUP11357-depth-embed-bin3-t0116.0: SUPO0, SUPO2
+    c_test/super_test/SUP11358-depth-embed-bin3-t0019.0: SUPO0, SUPO2
+    c_test/super_test/SUP11359-depth-embed-bin3-t0016.0: SUPO0, SUPO2
+    c_test/super_test/SUP11360-depth-embed-bin3-t0166.0: SUPO0, SUPO2
+    c_test/super_test/SUP11361-depth-embed-bin3-t0127.0: SUPO0, SUPO2
+    c_test/super_test/SUP11362-depth-embed-bin3-t0013.2: SUPO0, SUPO2
+    c_test/super_test/SUP11363-depth-embed-bin3-t0171.0: SUPO0, SUPO2
+    c_test/super_test/SUP11364-depth-embed-bin3-t0108.1: SUPO0, SUPO2
+    c_test/super_test/SUP11365-depth-embed-bin3-t0034.0: SUPO0, SUPO2
+    c_test/super_test/SUP11366-depth-embed-bin3-t0003.2: SUPO0, SUPO2
+    c_test/super_test/SUP11367-depth-embed-bin3-t0097.0: SUPO0, SUPO2
+    c_test/super_test/SUP11368-depth-embed-bin3-t0025.0: SUPO0, SUPO2
+    c_test/super_test/SUP11369-depth-embed-bin3-t0075.1: SUPO0, SUPO2
+    c_test/super_test/SUP11370-depth-embed-bin3-t0012.0: SUPO0, SUPO2
+    c_test/super_test/SUP11371-depth-embed-bin3-t0185.1: SUPO0, SUPO2
+    c_test/super_test/SUP11372-depth-embed-bin3-t0028.0: SUPO0, SUPO2
+    c_test/super_test/SUP11373-depth-embed-bin3-t0009.0: SUPO0, SUPO2
+    c_test/super_test/SUP11374-depth-embed-bin3-t0106.1: SUPO0, SUPO2
+    c_test/super_test/SUP11375-depth-embed-bin3-t0055.1: SUPO0, SUPO2
+    c_test/super_test/SUP11376-depth-embed-bin3-t0065.1: SUPO0, SUPO2
+    c_test/super_test/SUP11377-depth-embed-bin3-t0004.0: SUPO0, SUPO2
+    c_test/super_test/SUP11378-depth-embed-bin3-t0035.0: SUPO0, SUPO2
+    c_test/super_test/SUP11379-depth-embed-bin3-t0116.1: SUPO0, SUPO2
+    c_test/super_test/SUP11380-depth-embed-bin3-t0118.0: SUPO0, SUPO2
+    c_test/super_test/SUP11381-depth-embed-bin3-t0057.0: SUPO0, SUPO2
+    c_test/super_test/SUP11382-depth-embed-bin3-t0006.0: SUPO0, SUPO2
+    c_test/super_test/SUP11383-depth-embed-bin3-t0162.0: SUPO0, SUPO2
+    c_test/super_test/SUP11384-depth-embed-bin3-t0056.0: SUPO0, SUPO2
+    c_test/super_test/SUP11385-depth-embed-bin3-t0177.1: SUPO0, SUPO2
+    c_test/super_test/SUP11386-depth-embed-bin3-t0103.2: SUPO0, SUPO2
+    c_test/super_test/SUP11387-depth-embed-bin3-t0118.1: SUPO0, SUPO2
+    c_test/super_test/SUP11388-depth-embed-bin3-t0105.1: SUPO0, SUPO2
+    c_test/super_test/SUP11389-depth-embed-bin3-t0007.2: SUPO0, SUPO2
+    c_test/super_test/SUP11390-depth-embed-bin3-t0117.1: SUPO0, SUPO2
+    c_test/super_test/SUP11391-depth-embed-bin3-t0077.1: SUPO0, SUPO2
+    c_test/super_test/SUP11392-depth-embed-bin3-t0024.0: SUPO0, SUPO2
+    c_test/super_test/SUP11393-depth-embed-bin3-t0002.1: SUPO0, SUPO2
+    c_test/super_test/SUP11394-depth-embed-bin3-t0121.0: SUPO0, SUPO2
+    c_test/super_test/SUP11395-depth-embed-bin3-t0115.0: SUPO0, SUPO2
+    c_test/super_test/SUP11396-depth-embed-bin3-t0008.1: SUPO0, SUPO2
+    c_test/super_test/SUP11397-depth-embed-bin3-t0174.0: SUPO0, SUPO2
+    c_test/super_test/SUP11398-depth-embed-bin3-t0115.1: SUPO0, SUPO2
+    c_test/super_test/SUP11399-depth-embed-bin3-t0031.1: SUPO0, SUPO2
+    c_test/super_test/SUP11400-depth-embed-bin3-t0043.0: SUPO0, SUPO2
+    c_test/super_test/SUP11401-depth-embed-bin3-t0122.0: SUPO0, SUPO2
+    c_test/super_test/SUP11402-depth-embed-bin3-t0007.0: SUPO0, SUPO2
+    c_test/super_test/SUP11403-depth-embed-bin3-t0067.1: SUPO0, SUPO2
+    c_test/super_test/SUP11404-depth-embed-bin3-t0173.0: SUPO0, SUPO2
+    c_test/super_test/SUP11405-depth-embed-bin3-t0035.2: SUPO0, SUPO2
+    c_test/super_test/SUP11406-depth-embed-bin3-t0001.0: SUPO0, SUPO2
+    c_test/super_test/SUP11407-depth-embed-bin3-t0023.2: SUPO0, SUPO2
+    c_test/super_test/SUP11408-depth-embed-bin3-t0161.0: SUPO0, SUPO2
+    c_test/super_test/SUP11409-depth-embed-bin3-t0102.1: SUPO0, SUPO2
+    c_test/super_test/SUP11410-depth-embed-bin3-t0051.0: SUPO0, SUPO2
+    c_test/super_test/SUP11411-depth-embed-bin3-t0050.0: SUPO0, SUPO2
+    c_test/super_test/SUP11412-depth-embed-bin3-t0015.0: SUPO0, SUPO2
+    c_test/super_test/SUP11413-depth-embed-bin3-t0024.1: SUPO0, SUPO2
+    c_test/super_test/SUP11414-depth-embed-bin3-t0144.0: SUPO0, SUPO2
+    c_test/super_test/SUP11415-depth-embed-bin3-t0001.1: SUPO0, SUPO2
+    c_test/super_test/SUP11416-depth-embed-bin3-t0134.1: SUPO0, SUPO2
+    c_test/super_test/SUP11417-depth-embed-bin3-t0044.0: SUPO0, SUPO2
+    c_test/super_test/SUP11418-depth-embed-bin3-t0026.0: SUPO0, SUPO2
+    c_test/super_test/SUP11419-depth-embed-bin3-t0161.1: SUPO0, SUPO2
+    c_test/super_test/SUP11420-depth-embed-bin3-t0124.0: SUPO0, SUPO2
+    c_test/super_test/SUP11421-depth-embed-bin3-t0018.0: SUPO0, SUPO2
+    c_test/super_test/SUP11422-depth-embed-bin3-t0125.1: SUPO0, SUPO2
+    c_test/super_test/SUP11423-depth-embed-bin3-t0011.0: SUPO0, SUPO2
+    c_test/super_test/SUP11424-depth-embed-bin3-t0117.2: SUPO0, SUPO2
+    c_test/super_test/SUP11425-depth-embed-bin3-t0062.0: SUPO0, SUPO2
+    c_test/super_test/SUP11426-depth-embed-bin3-t0156.0: SUPO0, SUPO2
+    c_test/super_test/SUP11427-depth-embed-bin3-t0035.1: SUPO0, SUPO2
+    c_test/super_test/SUP11428-depth-embed-bin3-t0022.1: SUPO0, SUPO2
+    c_test/super_test/SUP11429-depth-embed-bin3-t0027.1: SUPO0, SUPO2
+    c_test/super_test/SUP11430-depth-embed-bin3-t0128.1: SUPO0, SUPO2
+    c_test/super_test/SUP11431-depth-embed-bin3-t0020.0: SUPO0, SUPO2
+    c_test/super_test/SUP11432-depth-embed-bin3-t0015.2: SUPO0, SUPO2
+    c_test/super_test/SUP11433-depth-embed-bin3-t0130.0: SUPO0, SUPO2
+    c_test/super_test/SUP11434-depth-embed-bin3-t0032.1: SUPO0, SUPO2
+    c_test/super_test/SUP11435-depth-embed-bin3-t0107.2: SUPO0, SUPO2
+    c_test/super_test/SUP11436-depth-embed-bin3-t0038.0: SUPO0, SUPO2
+    c_test/super_test/SUP11437-depth-embed-bin3-t0191.1: SUPO0, SUPO2
+    c_test/super_test/SUP11438-depth-embed-bin3-t0053.0: SUPO0, SUPO2
+    c_test/super_test/SUP11439-depth-embed-bin3-t0138.0: SUPO0, SUPO2
+    c_test/super_test/SUP11440-depth-embed-bin3-t0109.0: SUPO0, SUPO2
+    c_test/super_test/SUP11441-depth-embed-bin3-t0103.0: SUPO0, SUPO2
+    c_test/super_test/SUP11442-depth-embed-bin3-t0163.0: SUPO0, SUPO2
+    c_test/super_test/SUP11443-depth-embed-bin3-t0134.0: SUPO0, SUPO2
+    c_test/super_test/SUP11444-depth-embed-bin3-t0101.2: SUPO0, SUPO2
+    c_test/super_test/SUP11445-depth-embed-bin3-t0127.1: SUPO0, SUPO2
+    c_test/super_test/SUP11446-depth-embed-bin3-t0012.1: SUPO0, SUPO2
+    c_test/super_test/SUP11447-depth-embed-bin3-t0021.0: SUPO0, SUPO2
+    c_test/super_test/SUP11448-depth-embed-bin3-t0014.1: SUPO0, SUPO2
+    c_test/super_test/SUP11449-depth-embed-bin3-t0183.1: SUPO0, SUPO2
+    c_test/super_test/SUP11450-depth-embed-bin3-t0025.1: SUPO0, SUPO2
+    c_test/super_test/SUP11451-depth-embed-bin3-t0157.0: SUPO0, SUPO2
+    c_test/super_test/SUP11452-depth-embed-bin3-t0017.2: SUPO0, SUPO2
+    c_test/super_test/SUP11453-depth-embed-bin3-t0165.0: SUPO0, SUPO2
+    c_test/super_test/SUP11454-depth-embed-bin3-t0110.0: SUPO0, SUPO2
+    c_test/super_test/SUP11455-depth-embed-bin3-t0132.1: SUPO0, SUPO2
+    c_test/super_test/SUP11456-depth-embed-bin3-t0107.1: SUPO0, SUPO2
+    c_test/super_test/SUP11457-depth-embed-bin3-t0033.0: SUPO0, SUPO2
+    c_test/super_test/SUP11458-depth-embed-bin3-t0123.2: SUPO0, SUPO2
+    c_test/super_test/SUP11459-depth-embed-bin3-t0108.0: SUPO0, SUPO2
+    c_test/super_test/SUP11460-depth-embed-bin3-t0093.0: SUPO0, SUPO2
+    c_test/super_test/SUP11461-depth-embed-bin3-t0081.0: SUPO0, SUPO2
+    c_test/super_test/SUP11462-depth-embed-bin3-t0006.1: SUPO0, SUPO2
+    c_test/super_test/SUP11463-depth-embed-bin3-t0197.1: SUPO0, SUPO2
+    c_test/super_test/SUP11464-depth-embed-bin3-t0187.0: SUPO0, SUPO2
+    c_test/super_test/SUP11465-depth-embed-bin3-t0076.0: SUPO0, SUPO2
+    c_test/super_test/SUP11466-depth-embed-bin3-t0101.0: SUPO0, SUPO2
+    c_test/super_test/SUP11467-depth-embed-bin3-t0163.1: SUPO0, SUPO2
+    c_test/super_test/SUP11468-depth-embed-bin3-t0030.1: SUPO0, SUPO2
+    c_test/super_test/SUP11469-depth-embed-bin3-t0113.0: SUPO0, SUPO2
+    c_test/super_test/SUP11470-depth-embed-bin3-t0065.0: SUPO0, SUPO2
+    c_test/super_test/SUP11471-depth-embed-bin3-t0133.0: SUPO0, SUPO2
+    c_test/super_test/SUP11472-depth-embed-bin3-t0005.0: SUPO0, SUPO2
+    c_test/super_test/SUP11473-depth-embed-bin3-t0181.1: SUPO0, SUPO2
+    c_test/super_test/SUP11474-depth-embed-bin3-t0005.1: SUPO0, SUPO2
+    c_test/super_test/SUP11475-depth-embed-bin3-t0027.0: SUPO0, SUPO2
+    c_test/super_test/SUP11476-depth-embed-bin3-t0183.0: SUPO0, SUPO2
+    c_test/super_test/SUP11477-depth-embed-bin3-t0007.1: SUPO0, SUPO2
+    c_test/super_test/SUP11478-depth-embed-bin3-t0139.0: SUPO0, SUPO2
+    c_test/super_test/SUP11479-depth-embed-bin3-t0143.0: SUPO0, SUPO2
+    c_test/super_test/SUP11480-depth-embed-bin3-t0120.0: SUPO0, SUPO2
+    c_test/super_test/SUP11481-depth-embed-bin3-t0153.1: SUPO0, SUPO2
+    c_test/super_test/SUP11482-depth-embed-bin3-t0129.1: SUPO0, SUPO2
+    c_test/super_test/SUP11483-depth-embed-bin3-t0127.2: SUPO0, SUPO2
+    c_test/super_test/SUP11484-depth-embed-bin3-t0113.2: SUPO0, SUPO2
+    c_test/super_test/SUP11485-depth-embed-bin3-t0176.0: SUPO0, SUPO2
+    c_test/super_test/SUP11486-depth-embed-bin3-t0013.0: SUPO0, SUPO2
+    c_test/super_test/SUP11487-depth-embed-bin3-t0037.1: SUPO0, SUPO2
+    c_test/super_test/SUP11488-depth-embed-bin3-t0042.0: SUPO0, SUPO2
+    c_test/super_test/SUP11489-depth-embed-bin3-t0017.1: SUPO0, SUPO2
+    c_test/super_test/SUP11490-depth-embed-bin3-t0085.0: SUPO0, SUPO2
+    c_test/super_test/SUP11491-depth-embed-bin3-t0011.1: SUPO0, SUPO2
+    c_test/super_test/SUP11492-depth-embed-bin3-t0001.2: SUPO0, SUPO2
+    c_test/super_test/SUP11493-depth-embed-bin3-t0165.1: SUPO0, SUPO2
+    c_test/super_test/SUP11494-depth-embed-bin3-t0016.1: SUPO0, SUPO2
+    c_test/super_test/SUP11495-depth-embed-bin3-t0171.1: SUPO0, SUPO2
+    c_test/super_test/SUP11496-depth-embed-bin3-t0135.1: SUPO0, SUPO2
+    c_test/super_test/SUP11497-depth-embed-bin3-t0005.2: SUPO0, SUPO2
+    c_test/super_test/SUP11498-depth-embed-bin3-t0137.0: SUPO0, SUPO2
+    c_test/super_test/SUP11499-depth-embed-bin3-t0061.0: SUPO0, SUPO2
+    c_test/super_test/SUP11500-depth-embed-bin3-t0133.1: SUPO0, SUPO2
+    c_test/super_test/SUP11501-depth-embed-bin3-t0030.0: SUPO0, SUPO2
+    c_test/super_test/SUP11502-depth-embed-bin3-t0115.2: SUPO0, SUPO2
+    c_test/super_test/SUP11503-depth-embed-bin3-t0112.0: SUPO0, SUPO2
+    c_test/super_test/SUP11504-depth-embed-bin3-t0071.1: SUPO0, SUPO2
+    c_test/super_test/SUP11505-depth-embed-bin3-t0193.0: SUPO0, SUPO2
+    c_test/super_test/SUP11506-depth-embed-bin3-t0051.1: SUPO0, SUPO2
+    c_test/super_test/SUP11507-depth-embed-bin3-t0135.0: SUPO0, SUPO2
+    c_test/super_test/SUP11508-depth-embed-bin3-t0139.1: SUPO0, SUPO2
+    c_test/super_test/SUP11509-depth-embed-bin3-t0010.0: SUPO0, SUPO2
+    c_test/super_test/SUP11510-depth-embed-bin3-t0128.0: SUPO0, SUPO2
+    c_test/super_test/SUP11511-depth-embed-bin3-t0138.1: SUPO0, SUPO2
+    c_test/super_test/SUP11512-depth-embed-bin3-t0175.1: SUPO0, SUPO2
+    c_test/super_test/SUP11513-depth-embed-bin3-t0095.0: SUPO0, SUPO2
+    c_test/super_test/SUP11514-depth-embed-bin3-t0105.2: SUPO0, SUPO2
+    c_test/super_test/SUP11515-depth-embed-bin3-t0039.0: SUPO0, SUPO2
+    c_test/super_test/SUP11516-depth-embed-bin3-t0002.0: SUPO0, SUPO2
+    c_test/super_test/SUP11517-depth-embed-bin3-t0018.1: SUPO0, SUPO2
+    c_test/super_test/SUP11518-depth-embed-bin3-t0000.0: SUPO0, SUPO2
+    c_test/super_test/SUP11519-depth-embed-bin3-t0155.1: SUPO0, SUPO2
+    c_test/super_test/SUP11520-depth-embed-bin3-t0000.1: SUPO0, SUPO2
+    c_test/super_test/SUP11521-depth-embed-bin3-t0132.0: SUPO0, SUPO2
+    c_test/super_test/SUP11522-depth-embed-bin3-t0022.0: SUPO0, SUPO2
+    c_test/super_test/SUP11523-depth-embed-bin3-t0053.1: SUPO0, SUPO2
+    c_test/super_test/SUP11524-depth-embed-bin3-t0129.0: SUPO0, SUPO2
+    c_test/super_test/SUP11525-depth-embed-bin3-t0173.1: SUPO0, SUPO2
+    c_test/super_test/SUP11526-depth-embed-bin3-t0026.1: SUPO0, SUPO2
+    c_test/super_test/SUP11527-depth-embed-bin3-t0003.1: SUPO0, SUPO2
+    c_test/super_test/SUP11528-depth-embed-bin3-t0013.1: SUPO0, SUPO2
+    c_test/super_test/SUP11529-depth-embed-bin3-t0124.1: SUPO0, SUPO2
+    c_test/super_test/SUP11530-depth-embed-bin3-t0111.1: SUPO0, SUPO2
+    c_test/super_test/SUP11531-depth-embed-bin3-t0100.1: SUPO0, SUPO2
+    c_test/super_test/SUP11532-depth-embed-bin3-t0111.0: SUPO0, SUPO2
+    c_test/super_test/SUP11533-depth-embed-bin3-t0136.0: SUPO0, SUPO2
+    c_test/super_test/SUP11534-depth-embed-bin3-t0125.0: SUPO0, SUPO2
+    c_test/super_test/SUP11535-depth-embed-bin3-t0055.0: SUPO0, SUPO2
+    c_test/super_test/SUP11536-depth-embed-bin3-t0077.0: SUPO0, SUPO2
+    c_test/super_test/SUP11537-depth-embed-bin3-t0121.1: SUPO0, SUPO2
+    c_test/super_test/SUP11538-depth-embed-bin3-t0167.1: SUPO0, SUPO2
+    c_test/super_test/SUP11539-depth-embed-bin3-t0072.0: SUPO0, SUPO2
+    c_test/super_test/SUP11540-depth-embed-bin3-t0033.1: SUPO0, SUPO2
+    c_test/super_test/SUP11541-depth-embed-bin3-t0145.0: SUPO0, SUPO2
+    c_test/super_test/SUP11542-depth-embed-bin3-t0151.1: SUPO0, SUPO2
+    c_test/super_test/SUP11543-depth-embed-bin3-t0195.0: SUPO0, SUPO2
+    c_test/super_test/SUP11544-depth-embed-bin3-t0154.0: SUPO0, SUPO2
+    c_test/super_test/SUP11545-depth-embed-bin3-t0155.0: SUPO0, SUPO2
+    c_test/super_test/SUP11546-depth-embed-bin3-t0107.0: SUPO0, SUPO2
+    c_test/super_test/SUP11547-depth-embed-bin3-t0063.0: SUPO0, SUPO2
+    c_test/super_test/SUP11548-depth-embed-bin3-t0023.1: SUPO0, SUPO2
+    c_test/super_test/SUP11549-depth-embed-bin3-t0146.0: SUPO0, SUPO2
+    c_test/super_test/SUP11550-depth-embed-bin3-t0123.1: SUPO0, SUPO2
+    c_test/super_test/SUP11551-depth-embed-bin3-t0036.1: SUPO0, SUPO2
+    c_test/super_test/SUP11552-depth-embed-bin3-t0197.0: SUPO0, SUPO2
+    c_test/super_test/SUP11553-depth-embed-bin3-t0047.0: SUPO0, SUPO2
+    c_test/super_test/SUP11554-depth-embed-bin3-t0014.0: SUPO0, SUPO2
+    c_test/super_test/SUP11555-depth-embed-bin3-t0111.2: SUPO0, SUPO2
+    c_test/super_test/SUP11556-depth-embed-bin3-t0114.1: SUPO0, SUPO2
+    c_test/super_test/SUP11557-depth-embed-bin3-t0031.2: SUPO0, SUPO2
+    c_test/super_test/SUP11558-depth-embed-bin3-t0041.0: SUPO0, SUPO2
+    c_test/super_test/SUP11559-depth-embed-bin3-t0063.1: SUPO0, SUPO2
+    c_test/super_test/SUP11560-depth-embed-bin3-t0117.0: SUPO0, SUPO2
+    c_test/super_test/SUP11561-depth-embed-bin3-t0015.1: SUPO0, SUPO2
+    c_test/super_test/SUP11562-depth-embed-bin3-t0003.0: SUPO0, SUPO2
+    c_test/super_test/SUP11563-depth-embed-bin3-t0150.0: SUPO0, SUPO2
+    c_test/super_test/SUP11564-depth-embed-bin3-t0136.1: SUPO0, SUPO2
+    c_test/super_test/SUP11565-depth-embed-side-t0045.0: SUPO0, SUPO2
+    c_test/super_test/SUP11566-depth-embed-side-t0055.2: SUPO0, SUPO2
+    c_test/super_test/SUP11567-depth-embed-side-t0004.1: SUPO0, SUPO2
+    c_test/super_test/SUP11568-depth-embed-side-t0036.0: SUPO0, SUPO2
+    c_test/super_test/SUP11569-depth-embed-side-t0048.1: SUPO0, SUPO2
+    c_test/super_test/SUP11570-depth-embed-side-t0025.2: SUPO0, SUPO2
+    c_test/super_test/SUP11571-depth-embed-side-t0021.1: SUPO0, SUPO2
+    c_test/super_test/SUP11572-depth-embed-side-t0066.1: SUPO0, SUPO2
+    c_test/super_test/SUP11573-depth-embed-side-t0019.1: SUPO0, SUPO2
+    c_test/super_test/SUP11574-depth-embed-side-t0003.3: SUPO0, SUPO2
+    c_test/super_test/SUP11575-depth-embed-side-t0049.0: SUPO0, SUPO2
+    c_test/super_test/SUP11576-depth-embed-side-t0037.0: SUPO0, SUPO2
+    c_test/super_test/SUP11577-depth-embed-side-t0046.0: SUPO0, SUPO2
+    c_test/super_test/SUP11578-depth-embed-side-t0024.3: SUPO0, SUPO2
+    c_test/super_test/SUP11579-depth-embed-side-t0015.3: SUPO0, SUPO2
+    c_test/super_test/SUP11580-depth-embed-side-t0014.2: SUPO0, SUPO2
+    c_test/super_test/SUP11581-depth-embed-side-t0054.0: SUPO0, SUPO2
+    c_test/super_test/SUP11582-depth-embed-side-t0023.0: SUPO0, SUPO2
+    c_test/super_test/SUP11583-depth-embed-side-t0021.3: SUPO0, SUPO2
+    c_test/super_test/SUP11584-depth-embed-side-t0001.4: SUPO0, SUPO2
+    c_test/super_test/SUP11585-depth-embed-side-t0057.1: SUPO0, SUPO2
+    c_test/super_test/SUP11586-depth-embed-side-t0032.0: SUPO0, SUPO2
+    c_test/super_test/SUP11587-depth-embed-side-t0009.1: SUPO0, SUPO2
+    c_test/super_test/SUP11588-depth-embed-side-t0020.1: SUPO0, SUPO2
+    c_test/super_test/SUP11589-depth-embed-side-t0052.0: SUPO0, SUPO2
+    c_test/super_test/SUP11590-depth-embed-side-t0050.2: SUPO0, SUPO2
+    c_test/super_test/SUP11591-depth-embed-side-t0029.0: SUPO0, SUPO2
+    c_test/super_test/SUP11592-depth-embed-side-t0059.1: SUPO0, SUPO2
+    c_test/super_test/SUP11593-depth-embed-side-t0008.0: SUPO0, SUPO2
+    c_test/super_test/SUP11594-depth-embed-side-t0031.0: SUPO0, SUPO2
+    c_test/super_test/SUP11595-depth-embed-side-t0066.0: SUPO0, SUPO2
+    c_test/super_test/SUP11596-depth-embed-side-t0017.0: SUPO0, SUPO2
+    c_test/super_test/SUP11597-depth-embed-side-t0039.1: SUPO0, SUPO2
+    c_test/super_test/SUP11598-depth-embed-side-t0013.3: SUPO0, SUPO2
+    c_test/super_test/SUP11599-depth-embed-side-t0064.0: SUPO0, SUPO2
+    c_test/super_test/SUP11600-depth-embed-side-t0011.2: SUPO0, SUPO2
+    c_test/super_test/SUP11601-depth-embed-side-t0010.1: SUPO0, SUPO2
+    c_test/super_test/SUP11602-depth-embed-side-t0022.2: SUPO0, SUPO2
+    c_test/super_test/SUP11603-depth-embed-side-t0040.0: SUPO0, SUPO2
+    c_test/super_test/SUP11604-depth-embed-side-t0064.1: SUPO0, SUPO2
+    c_test/super_test/SUP11605-depth-embed-side-t0047.1: SUPO0, SUPO2
+    c_test/super_test/SUP11606-depth-embed-side-t0054.1: SUPO0, SUPO2
+    c_test/super_test/SUP11607-depth-embed-side-t0025.3: SUPO0, SUPO2
+    c_test/super_test/SUP11608-depth-embed-side-t0020.2: SUPO0, SUPO2
+    c_test/super_test/SUP11609-depth-embed-side-t0021.2: SUPO0, SUPO2
+    c_test/super_test/SUP11610-depth-embed-side-t0003.4: SUPO0, SUPO2
+    c_test/super_test/SUP11611-depth-embed-side-t0027.4: SUPO0, SUPO2
+    c_test/super_test/SUP11612-depth-embed-side-t0043.1: SUPO0, SUPO2
+    c_test/super_test/SUP11613-depth-embed-side-t0038.1: SUPO0, SUPO2
+    c_test/super_test/SUP11614-depth-embed-side-t0013.4: SUPO0, SUPO2
+    c_test/super_test/SUP11615-depth-embed-side-t0001.3: SUPO0, SUPO2
+    c_test/super_test/SUP11616-depth-embed-side-t0019.0: SUPO0, SUPO2
+    c_test/super_test/SUP11617-depth-embed-side-t0016.0: SUPO0, SUPO2
+    c_test/super_test/SUP11618-depth-embed-side-t0013.2: SUPO0, SUPO2
+    c_test/super_test/SUP11619-depth-embed-side-t0009.2: SUPO0, SUPO2
+    c_test/super_test/SUP11620-depth-embed-side-t0010.2: SUPO0, SUPO2
+    c_test/super_test/SUP11621-depth-embed-side-t0041.2: SUPO0, SUPO2
+    c_test/super_test/SUP11622-depth-embed-side-t0034.0: SUPO0, SUPO2
+    c_test/super_test/SUP11623-depth-embed-side-t0003.2: SUPO0, SUPO2
+    c_test/super_test/SUP11624-depth-embed-side-t0019.2: SUPO0, SUPO2
+    c_test/super_test/SUP11625-depth-embed-side-t0025.0: SUPO0, SUPO2
+    c_test/super_test/SUP11626-depth-embed-side-t0018.2: SUPO0, SUPO2
+    c_test/super_test/SUP11627-depth-embed-side-t0012.0: SUPO0, SUPO2
+    c_test/super_test/SUP11628-depth-embed-side-t0042.1: SUPO0, SUPO2
+    c_test/super_test/SUP11629-depth-embed-side-t0028.0: SUPO0, SUPO2
+    c_test/super_test/SUP11630-depth-embed-side-t0046.1: SUPO0, SUPO2
+    c_test/super_test/SUP11631-depth-embed-side-t0009.0: SUPO0, SUPO2
+    c_test/super_test/SUP11632-depth-embed-side-t0055.1: SUPO0, SUPO2
+    c_test/super_test/SUP11633-depth-embed-side-t0004.0: SUPO0, SUPO2
+    c_test/super_test/SUP11634-depth-embed-side-t0059.0: SUPO0, SUPO2
+    c_test/super_test/SUP11635-depth-embed-side-t0035.0: SUPO0, SUPO2
+    c_test/super_test/SUP11636-depth-embed-side-t0057.0: SUPO0, SUPO2
+    c_test/super_test/SUP11637-depth-embed-side-t0006.0: SUPO0, SUPO2
+    c_test/super_test/SUP11638-depth-embed-side-t0010.3: SUPO0, SUPO2
+    c_test/super_test/SUP11639-depth-embed-side-t0049.1: SUPO0, SUPO2
+    c_test/super_test/SUP11640-depth-embed-side-t0007.2: SUPO0, SUPO2
+    c_test/super_test/SUP11641-depth-embed-side-t0024.0: SUPO0, SUPO2
+    c_test/super_test/SUP11642-depth-embed-side-t0002.1: SUPO0, SUPO2
+    c_test/super_test/SUP11643-depth-embed-side-t0008.1: SUPO0, SUPO2
+    c_test/super_test/SUP11644-depth-embed-side-t0043.0: SUPO0, SUPO2
+    c_test/super_test/SUP11645-depth-embed-side-t0007.0: SUPO0, SUPO2
+    c_test/super_test/SUP11646-depth-embed-side-t0045.1: SUPO0, SUPO2
+    c_test/super_test/SUP11647-depth-embed-side-t0001.0: SUPO0, SUPO2
+    c_test/super_test/SUP11648-depth-embed-side-t0023.2: SUPO0, SUPO2
+    c_test/super_test/SUP11649-depth-embed-side-t0048.2: SUPO0, SUPO2
+    c_test/super_test/SUP11650-depth-embed-side-t0051.0: SUPO0, SUPO2
+    c_test/super_test/SUP11651-depth-embed-side-t0050.0: SUPO0, SUPO2
+    c_test/super_test/SUP11652-depth-embed-side-t0015.0: SUPO0, SUPO2
+    c_test/super_test/SUP11653-depth-embed-side-t0024.1: SUPO0, SUPO2
+    c_test/super_test/SUP11654-depth-embed-side-t0001.1: SUPO0, SUPO2
+    c_test/super_test/SUP11655-depth-embed-side-t0044.0: SUPO0, SUPO2
+    c_test/super_test/SUP11656-depth-embed-side-t0026.0: SUPO0, SUPO2
+    c_test/super_test/SUP11657-depth-embed-side-t0009.3: SUPO0, SUPO2
+    c_test/super_test/SUP11658-depth-embed-side-t0008.3: SUPO0, SUPO2
+    c_test/super_test/SUP11659-depth-embed-side-t0018.0: SUPO0, SUPO2
+    c_test/super_test/SUP11660-depth-embed-side-t0007.3: SUPO0, SUPO2
+    c_test/super_test/SUP11661-depth-embed-side-t0011.0: SUPO0, SUPO2
+    c_test/super_test/SUP11662-depth-embed-side-t0062.0: SUPO0, SUPO2
+    c_test/super_test/SUP11663-depth-embed-side-t0035.1: SUPO0, SUPO2
+    c_test/super_test/SUP11664-depth-embed-side-t0022.1: SUPO0, SUPO2
+    c_test/super_test/SUP11665-depth-embed-side-t0017.3: SUPO0, SUPO2
+    c_test/super_test/SUP11666-depth-embed-side-t0027.1: SUPO0, SUPO2
+    c_test/super_test/SUP11667-depth-embed-side-t0004.3: SUPO0, SUPO2
+    c_test/super_test/SUP11668-depth-embed-side-t0020.0: SUPO0, SUPO2
+    c_test/super_test/SUP11669-depth-embed-side-t0015.2: SUPO0, SUPO2
+    c_test/super_test/SUP11670-depth-embed-side-t0044.1: SUPO0, SUPO2
+    c_test/super_test/SUP11671-depth-embed-side-t0038.0: SUPO0, SUPO2
+    c_test/super_test/SUP11672-depth-embed-side-t0053.0: SUPO0, SUPO2
+    c_test/super_test/SUP11673-depth-embed-side-t0022.3: SUPO0, SUPO2
+    c_test/super_test/SUP11674-depth-embed-side-t0012.1: SUPO0, SUPO2
+    c_test/super_test/SUP11675-depth-embed-side-t0021.0: SUPO0, SUPO2
+    c_test/super_test/SUP11676-depth-embed-side-t0045.2: SUPO0, SUPO2
+    c_test/super_test/SUP11677-depth-embed-side-t0023.3: SUPO0, SUPO2
+    c_test/super_test/SUP11678-depth-embed-side-t0014.1: SUPO0, SUPO2
+    c_test/super_test/SUP11679-depth-embed-side-t0012.2: SUPO0, SUPO2
+    c_test/super_test/SUP11680-depth-embed-side-t0024.2: SUPO0, SUPO2
+    c_test/super_test/SUP11681-depth-embed-side-t0025.1: SUPO0, SUPO2
+    c_test/super_test/SUP11682-depth-embed-side-t0017.2: SUPO0, SUPO2
+    c_test/super_test/SUP11683-depth-embed-side-t0027.2: SUPO0, SUPO2
+    c_test/super_test/SUP11684-depth-embed-side-t0000.2: SUPO0, SUPO2
+    c_test/super_test/SUP11685-depth-embed-side-t0062.1: SUPO0, SUPO2
+    c_test/super_test/SUP11686-depth-embed-side-t0043.2: SUPO0, SUPO2
+    c_test/super_test/SUP11687-depth-embed-side-t0022.4: SUPO0, SUPO2
+    c_test/super_test/SUP11688-depth-embed-side-t0033.0: SUPO0, SUPO2
+    c_test/super_test/SUP11689-depth-embed-side-t0020.3: SUPO0, SUPO2
+    c_test/super_test/SUP11690-depth-embed-side-t0011.3: SUPO0, SUPO2
+    c_test/super_test/SUP11691-depth-embed-side-t0006.1: SUPO0, SUPO2
+    c_test/super_test/SUP11692-depth-embed-side-t0004.2: SUPO0, SUPO2
+    c_test/super_test/SUP11693-depth-embed-side-t0016.2: SUPO0, SUPO2
+    c_test/super_test/SUP11694-depth-embed-side-t0017.4: SUPO0, SUPO2
+    c_test/super_test/SUP11695-depth-embed-side-t0005.0: SUPO0, SUPO2
+    c_test/super_test/SUP11696-depth-embed-side-t0005.1: SUPO0, SUPO2
+    c_test/super_test/SUP11697-depth-embed-side-t0027.0: SUPO0, SUPO2
+    c_test/super_test/SUP11698-depth-embed-side-t0007.1: SUPO0, SUPO2
+    c_test/super_test/SUP11699-depth-embed-side-t0069.0: SUPO0, SUPO2
+    c_test/super_test/SUP11700-depth-embed-side-t0000.3: SUPO0, SUPO2
+    c_test/super_test/SUP11701-depth-embed-side-t0013.0: SUPO0, SUPO2
+    c_test/super_test/SUP11702-depth-embed-side-t0037.1: SUPO0, SUPO2
+    c_test/super_test/SUP11703-depth-embed-side-t0042.0: SUPO0, SUPO2
+    c_test/super_test/SUP11704-depth-embed-side-t0017.1: SUPO0, SUPO2
+    c_test/super_test/SUP11705-depth-embed-side-t0011.1: SUPO0, SUPO2
+    c_test/super_test/SUP11706-depth-embed-side-t0050.1: SUPO0, SUPO2
+    c_test/super_test/SUP11707-depth-embed-side-t0001.2: SUPO0, SUPO2
+    c_test/super_test/SUP11708-depth-embed-side-t0016.1: SUPO0, SUPO2
+    c_test/super_test/SUP11709-depth-embed-side-t0010.4: SUPO0, SUPO2
+    c_test/super_test/SUP11710-depth-embed-side-t0026.2: SUPO0, SUPO2
+    c_test/super_test/SUP11711-depth-embed-side-t0048.0: SUPO0, SUPO2
+    c_test/super_test/SUP11712-depth-embed-side-t0069.1: SUPO0, SUPO2
+    c_test/super_test/SUP11713-depth-embed-side-t0005.2: SUPO0, SUPO2
+    c_test/super_test/SUP11714-depth-embed-side-t0030.0: SUPO0, SUPO2
+    c_test/super_test/SUP11715-depth-embed-side-t0051.1: SUPO0, SUPO2
+    c_test/super_test/SUP11716-depth-embed-side-t0010.0: SUPO0, SUPO2
+    c_test/super_test/SUP11717-depth-embed-side-t0020.4: SUPO0, SUPO2
+    c_test/super_test/SUP11718-depth-embed-side-t0038.2: SUPO0, SUPO2
+    c_test/super_test/SUP11719-depth-embed-side-t0006.2: SUPO0, SUPO2
+    c_test/super_test/SUP11720-depth-embed-side-t0006.4: SUPO0, SUPO2
+    c_test/super_test/SUP11721-depth-embed-side-t0012.3: SUPO0, SUPO2
+    c_test/super_test/SUP11722-depth-embed-side-t0039.0: SUPO0, SUPO2
+    c_test/super_test/SUP11723-depth-embed-side-t0002.0: SUPO0, SUPO2
+    c_test/super_test/SUP11724-depth-embed-side-t0018.1: SUPO0, SUPO2
+    c_test/super_test/SUP11725-depth-embed-side-t0000.0: SUPO0, SUPO2
+    c_test/super_test/SUP11726-depth-embed-side-t0000.1: SUPO0, SUPO2
+    c_test/super_test/SUP11727-depth-embed-side-t0022.0: SUPO0, SUPO2
+    c_test/super_test/SUP11728-depth-embed-side-t0053.1: SUPO0, SUPO2
+    c_test/super_test/SUP11729-depth-embed-side-t0026.1: SUPO0, SUPO2
+    c_test/super_test/SUP11730-depth-embed-side-t0003.1: SUPO0, SUPO2
+    c_test/super_test/SUP11731-depth-embed-side-t0013.1: SUPO0, SUPO2
+    c_test/super_test/SUP11732-depth-embed-side-t0052.2: SUPO0, SUPO2
+    c_test/super_test/SUP11733-depth-embed-side-t0052.1: SUPO0, SUPO2
+    c_test/super_test/SUP11734-depth-embed-side-t0002.3: SUPO0, SUPO2
+    c_test/super_test/SUP11735-depth-embed-side-t0002.2: SUPO0, SUPO2
+    c_test/super_test/SUP11736-depth-embed-side-t0055.0: SUPO0, SUPO2
+    c_test/super_test/SUP11737-depth-embed-side-t0008.2: SUPO0, SUPO2
+    c_test/super_test/SUP11738-depth-embed-side-t0005.3: SUPO0, SUPO2
+    c_test/super_test/SUP11739-depth-embed-side-t0026.3: SUPO0, SUPO2
+    c_test/super_test/SUP11740-depth-embed-side-t0015.4: SUPO0, SUPO2
+    c_test/super_test/SUP11741-depth-embed-side-t0023.1: SUPO0, SUPO2
+    c_test/super_test/SUP11742-depth-embed-side-t0036.1: SUPO0, SUPO2
+    c_test/super_test/SUP11743-depth-embed-side-t0040.1: SUPO0, SUPO2
+    c_test/super_test/SUP11744-depth-embed-side-t0047.0: SUPO0, SUPO2
+    c_test/super_test/SUP11745-depth-embed-side-t0027.3: SUPO0, SUPO2
+    c_test/super_test/SUP11746-depth-embed-side-t0014.0: SUPO0, SUPO2
+    c_test/super_test/SUP11747-depth-embed-side-t0036.2: SUPO0, SUPO2
+    c_test/super_test/SUP11748-depth-embed-side-t0041.0: SUPO0, SUPO2
+    c_test/super_test/SUP11749-depth-embed-side-t0006.3: SUPO0, SUPO2
+    c_test/super_test/SUP11750-depth-embed-side-t0008.4: SUPO0, SUPO2
+    c_test/super_test/SUP11751-depth-embed-side-t0041.1: SUPO0, SUPO2
+    c_test/super_test/SUP11752-depth-embed-side-t0015.1: SUPO0, SUPO2
+    c_test/super_test/SUP11753-depth-embed-side-t0003.0: SUPO0, SUPO2
+    c_test/super_test/SUP11754-depth-embed-side-t0024.4: SUPO0, SUPO2
+    c_test/super_test/SUP11755-depth-embed-bin2-t0070.0: SUPO0, SUPO2
+    c_test/super_test/SUP11756-depth-embed-bin2-t0160.0: SUPO0, SUPO2
+    c_test/super_test/SUP11757-depth-embed-bin2-t0105.0: SUPO0, SUPO2
+    c_test/super_test/SUP11758-depth-embed-bin2-t0045.0: SUPO0, SUPO2
+    c_test/super_test/SUP11759-depth-embed-bin2-t0147.0: SUPO0, SUPO2
+    c_test/super_test/SUP11760-depth-embed-bin2-t0126.1: SUPO0, SUPO2
+    c_test/super_test/SUP11761-depth-embed-bin2-t0004.1: SUPO0, SUPO2
+    c_test/super_test/SUP11762-depth-embed-bin2-t0126.0: SUPO0, SUPO2
+    c_test/super_test/SUP11763-depth-embed-bin2-t0123.0: SUPO0, SUPO2
+    c_test/super_test/SUP11764-depth-embed-bin2-t0036.0: SUPO0, SUPO2
+    c_test/super_test/SUP11765-depth-embed-bin2-t0102.0: SUPO0, SUPO2
+    c_test/super_test/SUP11766-depth-embed-bin2-t0119.1: SUPO0, SUPO2
+    c_test/super_test/SUP11767-depth-embed-bin2-t0021.1: SUPO0, SUPO2
+    c_test/super_test/SUP11768-depth-embed-bin2-t0019.1: SUPO0, SUPO2
+    c_test/super_test/SUP11769-depth-embed-bin2-t0033.2: SUPO0, SUPO2
+    c_test/super_test/SUP11770-depth-embed-bin2-t0074.0: SUPO0, SUPO2
+    c_test/super_test/SUP11771-depth-embed-bin2-t0177.0: SUPO0, SUPO2
+    c_test/super_test/SUP11772-depth-embed-bin2-t0091.0: SUPO0, SUPO2
+    c_test/super_test/SUP11773-depth-embed-bin2-t0061.1: SUPO0, SUPO2
+    c_test/super_test/SUP11774-depth-embed-bin2-t0037.0: SUPO0, SUPO2
+    c_test/super_test/SUP11775-depth-embed-bin2-t0087.0: SUPO0, SUPO2
+    c_test/super_test/SUP11776-depth-embed-bin2-t0131.1: SUPO0, SUPO2
+    c_test/super_test/SUP11777-depth-embed-bin2-t0167.0: SUPO0, SUPO2
+    c_test/super_test/SUP11778-depth-embed-bin2-t0114.0: SUPO0, SUPO2
+    c_test/super_test/SUP11779-depth-embed-bin2-t0060.0: SUPO0, SUPO2
+    c_test/super_test/SUP11780-depth-embed-bin2-t0067.0: SUPO0, SUPO2
+    c_test/super_test/SUP11781-depth-embed-bin2-t0073.1: SUPO0, SUPO2
+    c_test/super_test/SUP11782-depth-embed-bin2-t0054.0: SUPO0, SUPO2
+    c_test/super_test/SUP11783-depth-embed-bin2-t0023.0: SUPO0, SUPO2
+    c_test/super_test/SUP11784-depth-embed-bin2-t0130.1: SUPO0, SUPO2
+    c_test/super_test/SUP11785-depth-embed-bin2-t0104.1: SUPO0, SUPO2
+    c_test/super_test/SUP11786-depth-embed-bin2-t0057.1: SUPO0, SUPO2
+    c_test/super_test/SUP11787-depth-embed-bin2-t0029.1: SUPO0, SUPO2
+    c_test/super_test/SUP11788-depth-embed-bin2-t0101.1: SUPO0, SUPO2
+    c_test/super_test/SUP11789-depth-embed-bin2-t0032.0: SUPO0, SUPO2
+    c_test/super_test/SUP11790-depth-embed-bin2-t0151.0: SUPO0, SUPO2
+    c_test/super_test/SUP11791-depth-embed-bin2-t0009.1: SUPO0, SUPO2
+    c_test/super_test/SUP11792-depth-embed-bin2-t0020.1: SUPO0, SUPO2
+    c_test/super_test/SUP11793-depth-embed-bin2-t0185.0: SUPO0, SUPO2
+    c_test/super_test/SUP11794-depth-embed-bin2-t0052.0: SUPO0, SUPO2
+    c_test/super_test/SUP11795-depth-embed-bin2-t0191.0: SUPO0, SUPO2
+    c_test/super_test/SUP11796-depth-embed-bin2-t0103.1: SUPO0, SUPO2
+    c_test/super_test/SUP11797-depth-embed-bin2-t0122.1: SUPO0, SUPO2
+    c_test/super_test/SUP11798-depth-embed-bin2-t0028.1: SUPO0, SUPO2
+    c_test/super_test/SUP11799-depth-embed-bin2-t0100.0: SUPO0, SUPO2
+    c_test/super_test/SUP11800-depth-embed-bin2-t0119.0: SUPO0, SUPO2
+    c_test/super_test/SUP11801-depth-embed-bin2-t0029.0: SUPO0, SUPO2
+    c_test/super_test/SUP11802-depth-embed-bin2-t0112.1: SUPO0, SUPO2
+    c_test/super_test/SUP11803-depth-embed-bin2-t0034.1: SUPO0, SUPO2
+    c_test/super_test/SUP11804-depth-embed-bin2-t0175.0: SUPO0, SUPO2
+    c_test/super_test/SUP11805-depth-embed-bin2-t0170.0: SUPO0, SUPO2
+    c_test/super_test/SUP11806-depth-embed-bin2-t0083.0: SUPO0, SUPO2
+    c_test/super_test/SUP11807-depth-embed-bin2-t0008.0: SUPO0, SUPO2
+    c_test/super_test/SUP11808-depth-embed-bin2-t0073.0: SUPO0, SUPO2
+    c_test/super_test/SUP11809-depth-embed-bin2-t0181.0: SUPO0, SUPO2
+    c_test/super_test/SUP11810-depth-embed-bin2-t0031.0: SUPO0, SUPO2
+    c_test/super_test/SUP11811-depth-embed-bin2-t0152.0: SUPO0, SUPO2
+    c_test/super_test/SUP11812-depth-embed-bin2-t0066.0: SUPO0, SUPO2
+    c_test/super_test/SUP11813-depth-embed-bin2-t0153.0: SUPO0, SUPO2
+    c_test/super_test/SUP11814-depth-embed-bin2-t0120.1: SUPO0, SUPO2
+    c_test/super_test/SUP11815-depth-embed-bin2-t0017.0: SUPO0, SUPO2
+    c_test/super_test/SUP11816-depth-embed-bin2-t0039.1: SUPO0, SUPO2
+    c_test/super_test/SUP11817-depth-embed-bin2-t0064.0: SUPO0, SUPO2
+    c_test/super_test/SUP11818-depth-embed-bin2-t0010.1: SUPO0, SUPO2
+    c_test/super_test/SUP11819-depth-embed-bin2-t0157.1: SUPO0, SUPO2
+    c_test/super_test/SUP11820-depth-embed-bin2-t0172.0: SUPO0, SUPO2
+    c_test/super_test/SUP11821-depth-embed-bin2-t0131.2: SUPO0, SUPO2
+    c_test/super_test/SUP11822-depth-embed-bin2-t0141.0: SUPO0, SUPO2
+    c_test/super_test/SUP11823-depth-embed-bin2-t0075.0: SUPO0, SUPO2
+    c_test/super_test/SUP11824-depth-embed-bin2-t0037.2: SUPO0, SUPO2
+    c_test/super_test/SUP11825-depth-embed-bin2-t0106.0: SUPO0, SUPO2
+    c_test/super_test/SUP11826-depth-embed-bin2-t0071.0: SUPO0, SUPO2
+    c_test/super_test/SUP11827-depth-embed-bin2-t0110.1: SUPO0, SUPO2
+    c_test/super_test/SUP11828-depth-embed-bin2-t0113.1: SUPO0, SUPO2
+    c_test/super_test/SUP11829-depth-embed-bin2-t0104.0: SUPO0, SUPO2
+    c_test/super_test/SUP11830-depth-embed-bin2-t0133.2: SUPO0, SUPO2
+    c_test/super_test/SUP11831-depth-embed-bin2-t0164.0: SUPO0, SUPO2
+    c_test/super_test/SUP11832-depth-embed-bin2-t0038.1: SUPO0, SUPO2
+    c_test/super_test/SUP11833-depth-embed-bin2-t0109.1: SUPO0, SUPO2
+    c_test/super_test/SUP11834-depth-embed-bin2-t0131.0: SUPO0, SUPO2
+    c_test/super_test/SUP11835-depth-embed-bin2-t0137.1: SUPO0, SUPO2
+    c_test/super_test/SUP11836-depth-embed-bin2-t0116.0: SUPO0, SUPO2
+    c_test/super_test/SUP11837-depth-embed-bin2-t0019.0: SUPO0, SUPO2
+    c_test/super_test/SUP11838-depth-embed-bin2-t0016.0: SUPO0, SUPO2
+    c_test/super_test/SUP11839-depth-embed-bin2-t0166.0: SUPO0, SUPO2
+    c_test/super_test/SUP11840-depth-embed-bin2-t0127.0: SUPO0, SUPO2
+    c_test/super_test/SUP11841-depth-embed-bin2-t0171.0: SUPO0, SUPO2
+    c_test/super_test/SUP11842-depth-embed-bin2-t0108.1: SUPO0, SUPO2
+    c_test/super_test/SUP11843-depth-embed-bin2-t0034.0: SUPO0, SUPO2
+    c_test/super_test/SUP11844-depth-embed-bin2-t0003.2: SUPO0, SUPO2
+    c_test/super_test/SUP11845-depth-embed-bin2-t0097.0: SUPO0, SUPO2
+    c_test/super_test/SUP11846-depth-embed-bin2-t0025.0: SUPO0, SUPO2
+    c_test/super_test/SUP11847-depth-embed-bin2-t0075.1: SUPO0, SUPO2
+    c_test/super_test/SUP11848-depth-embed-bin2-t0012.0: SUPO0, SUPO2
+    c_test/super_test/SUP11849-depth-embed-bin2-t0028.0: SUPO0, SUPO2
+    c_test/super_test/SUP11850-depth-embed-bin2-t0009.0: SUPO0, SUPO2
+    c_test/super_test/SUP11851-depth-embed-bin2-t0106.1: SUPO0, SUPO2
+    c_test/super_test/SUP11852-depth-embed-bin2-t0055.1: SUPO0, SUPO2
+    c_test/super_test/SUP11853-depth-embed-bin2-t0065.1: SUPO0, SUPO2
+    c_test/super_test/SUP11854-depth-embed-bin2-t0004.0: SUPO0, SUPO2
+    c_test/super_test/SUP11855-depth-embed-bin2-t0035.0: SUPO0, SUPO2
+    c_test/super_test/SUP11856-depth-embed-bin2-t0116.1: SUPO0, SUPO2
+    c_test/super_test/SUP11857-depth-embed-bin2-t0118.0: SUPO0, SUPO2
+    c_test/super_test/SUP11858-depth-embed-bin2-t0057.0: SUPO0, SUPO2
+    c_test/super_test/SUP11859-depth-embed-bin2-t0006.0: SUPO0, SUPO2
+    c_test/super_test/SUP11860-depth-embed-bin2-t0162.0: SUPO0, SUPO2
+    c_test/super_test/SUP11861-depth-embed-bin2-t0056.0: SUPO0, SUPO2
+    c_test/super_test/SUP11862-depth-embed-bin2-t0177.1: SUPO0, SUPO2
+    c_test/super_test/SUP11863-depth-embed-bin2-t0103.2: SUPO0, SUPO2
+    c_test/super_test/SUP11864-depth-embed-bin2-t0118.1: SUPO0, SUPO2
+    c_test/super_test/SUP11865-depth-embed-bin2-t0105.1: SUPO0, SUPO2
+    c_test/super_test/SUP11866-depth-embed-bin2-t0007.2: SUPO0, SUPO2
+    c_test/super_test/SUP11867-depth-embed-bin2-t0117.1: SUPO0, SUPO2
+    c_test/super_test/SUP11868-depth-embed-bin2-t0077.1: SUPO0, SUPO2
+    c_test/super_test/SUP11869-depth-embed-bin2-t0024.0: SUPO0, SUPO2
+    c_test/super_test/SUP11870-depth-embed-bin2-t0002.1: SUPO0, SUPO2
+    c_test/super_test/SUP11871-depth-embed-bin2-t0121.0: SUPO0, SUPO2
+    c_test/super_test/SUP11872-depth-embed-bin2-t0115.0: SUPO0, SUPO2
+    c_test/super_test/SUP11873-depth-embed-bin2-t0008.1: SUPO0, SUPO2
+    c_test/super_test/SUP11874-depth-embed-bin2-t0174.0: SUPO0, SUPO2
+    c_test/super_test/SUP11875-depth-embed-bin2-t0115.1: SUPO0, SUPO2
+    c_test/super_test/SUP11876-depth-embed-bin2-t0031.1: SUPO0, SUPO2
+    c_test/super_test/SUP11877-depth-embed-bin2-t0043.0: SUPO0, SUPO2
+    c_test/super_test/SUP11878-depth-embed-bin2-t0122.0: SUPO0, SUPO2
+    c_test/super_test/SUP11879-depth-embed-bin2-t0007.0: SUPO0, SUPO2
+    c_test/super_test/SUP11880-depth-embed-bin2-t0067.1: SUPO0, SUPO2
+    c_test/super_test/SUP11881-depth-embed-bin2-t0173.0: SUPO0, SUPO2
+    c_test/super_test/SUP11882-depth-embed-bin2-t0035.2: SUPO0, SUPO2
+    c_test/super_test/SUP11883-depth-embed-bin2-t0001.0: SUPO0, SUPO2
+    c_test/super_test/SUP11884-depth-embed-bin2-t0161.0: SUPO0, SUPO2
+    c_test/super_test/SUP11885-depth-embed-bin2-t0102.1: SUPO0, SUPO2
+    c_test/super_test/SUP11886-depth-embed-bin2-t0051.0: SUPO0, SUPO2
+    c_test/super_test/SUP11887-depth-embed-bin2-t0050.0: SUPO0, SUPO2
+    c_test/super_test/SUP11888-depth-embed-bin2-t0015.0: SUPO0, SUPO2
+    c_test/super_test/SUP11889-depth-embed-bin2-t0024.1: SUPO0, SUPO2
+    c_test/super_test/SUP11890-depth-embed-bin2-t0001.1: SUPO0, SUPO2
+    c_test/super_test/SUP11891-depth-embed-bin2-t0134.1: SUPO0, SUPO2
+    c_test/super_test/SUP11892-depth-embed-bin2-t0026.0: SUPO0, SUPO2
+    c_test/super_test/SUP11893-depth-embed-bin2-t0161.1: SUPO0, SUPO2
+    c_test/super_test/SUP11894-depth-embed-bin2-t0124.0: SUPO0, SUPO2
+    c_test/super_test/SUP11895-depth-embed-bin2-t0018.0: SUPO0, SUPO2
+    c_test/super_test/SUP11896-depth-embed-bin2-t0125.1: SUPO0, SUPO2
+    c_test/super_test/SUP11897-depth-embed-bin2-t0011.0: SUPO0, SUPO2
+    c_test/super_test/SUP11898-depth-embed-bin2-t0062.0: SUPO0, SUPO2
+    c_test/super_test/SUP11899-depth-embed-bin2-t0156.0: SUPO0, SUPO2
+    c_test/super_test/SUP11900-depth-embed-bin2-t0035.1: SUPO0, SUPO2
+    c_test/super_test/SUP11901-depth-embed-bin2-t0022.1: SUPO0, SUPO2
+    c_test/super_test/SUP11902-depth-embed-bin2-t0027.1: SUPO0, SUPO2
+    c_test/super_test/SUP11903-depth-embed-bin2-t0128.1: SUPO0, SUPO2
+    c_test/super_test/SUP11904-depth-embed-bin2-t0020.0: SUPO0, SUPO2
+    c_test/super_test/SUP11905-depth-embed-bin2-t0015.2: SUPO0, SUPO2
+    c_test/super_test/SUP11906-depth-embed-bin2-t0130.0: SUPO0, SUPO2
+    c_test/super_test/SUP11907-depth-embed-bin2-t0032.1: SUPO0, SUPO2
+    c_test/super_test/SUP11908-depth-embed-bin2-t0038.0: SUPO0, SUPO2
+    c_test/super_test/SUP11909-depth-embed-bin2-t0053.0: SUPO0, SUPO2
+    c_test/super_test/SUP11910-depth-embed-bin2-t0138.0: SUPO0, SUPO2
+    c_test/super_test/SUP11911-depth-embed-bin2-t0109.0: SUPO0, SUPO2
+    c_test/super_test/SUP11912-depth-embed-bin2-t0103.0: SUPO0, SUPO2
+    c_test/super_test/SUP11913-depth-embed-bin2-t0163.0: SUPO0, SUPO2
+    c_test/super_test/SUP11914-depth-embed-bin2-t0134.0: SUPO0, SUPO2
+    c_test/super_test/SUP11915-depth-embed-bin2-t0101.2: SUPO0, SUPO2
+    c_test/super_test/SUP11916-depth-embed-bin2-t0127.1: SUPO0, SUPO2
+    c_test/super_test/SUP11917-depth-embed-bin2-t0012.1: SUPO0, SUPO2
+    c_test/super_test/SUP11918-depth-embed-bin2-t0021.0: SUPO0, SUPO2
+    c_test/super_test/SUP11919-depth-embed-bin2-t0014.1: SUPO0, SUPO2
+    c_test/super_test/SUP11920-depth-embed-bin2-t0025.1: SUPO0, SUPO2
+    c_test/super_test/SUP11921-depth-embed-bin2-t0157.0: SUPO0, SUPO2
+    c_test/super_test/SUP11922-depth-embed-bin2-t0017.2: SUPO0, SUPO2
+    c_test/super_test/SUP11923-depth-embed-bin2-t0165.0: SUPO0, SUPO2
+    c_test/super_test/SUP11924-depth-embed-bin2-t0110.0: SUPO0, SUPO2
+    c_test/super_test/SUP11925-depth-embed-bin2-t0132.1: SUPO0, SUPO2
+    c_test/super_test/SUP11926-depth-embed-bin2-t0107.1: SUPO0, SUPO2
+    c_test/super_test/SUP11927-depth-embed-bin2-t0033.0: SUPO0, SUPO2
+    c_test/super_test/SUP11928-depth-embed-bin2-t0108.0: SUPO0, SUPO2
+    c_test/super_test/SUP11929-depth-embed-bin2-t0093.0: SUPO0, SUPO2
+    c_test/super_test/SUP11930-depth-embed-bin2-t0081.0: SUPO0, SUPO2
+    c_test/super_test/SUP11931-depth-embed-bin2-t0006.1: SUPO0, SUPO2
+    c_test/super_test/SUP11932-depth-embed-bin2-t0187.0: SUPO0, SUPO2
+    c_test/super_test/SUP11933-depth-embed-bin2-t0076.0: SUPO0, SUPO2
+    c_test/super_test/SUP11934-depth-embed-bin2-t0101.0: SUPO0, SUPO2
+    c_test/super_test/SUP11935-depth-embed-bin2-t0163.1: SUPO0, SUPO2
+    c_test/super_test/SUP11936-depth-embed-bin2-t0030.1: SUPO0, SUPO2
+    c_test/super_test/SUP11937-depth-embed-bin2-t0113.0: SUPO0, SUPO2
+    c_test/super_test/SUP11938-depth-embed-bin2-t0065.0: SUPO0, SUPO2
+    c_test/super_test/SUP11939-depth-embed-bin2-t0133.0: SUPO0, SUPO2
+    c_test/super_test/SUP11940-depth-embed-bin2-t0005.0: SUPO0, SUPO2
+    c_test/super_test/SUP11941-depth-embed-bin2-t0005.1: SUPO0, SUPO2
+    c_test/super_test/SUP11942-depth-embed-bin2-t0027.0: SUPO0, SUPO2
+    c_test/super_test/SUP11943-depth-embed-bin2-t0183.0: SUPO0, SUPO2
+    c_test/super_test/SUP11944-depth-embed-bin2-t0007.1: SUPO0, SUPO2
+    c_test/super_test/SUP11945-depth-embed-bin2-t0139.0: SUPO0, SUPO2
+    c_test/super_test/SUP11946-depth-embed-bin2-t0143.0: SUPO0, SUPO2
+    c_test/super_test/SUP11947-depth-embed-bin2-t0120.0: SUPO0, SUPO2
+    c_test/super_test/SUP11948-depth-embed-bin2-t0153.1: SUPO0, SUPO2
+    c_test/super_test/SUP11949-depth-embed-bin2-t0129.1: SUPO0, SUPO2
+    c_test/super_test/SUP11950-depth-embed-bin2-t0176.0: SUPO0, SUPO2
+    c_test/super_test/SUP11951-depth-embed-bin2-t0013.0: SUPO0, SUPO2
+    c_test/super_test/SUP11952-depth-embed-bin2-t0037.1: SUPO0, SUPO2
+    c_test/super_test/SUP11953-depth-embed-bin2-t0017.1: SUPO0, SUPO2
+    c_test/super_test/SUP11954-depth-embed-bin2-t0085.0: SUPO0, SUPO2
+    c_test/super_test/SUP11955-depth-embed-bin2-t0011.1: SUPO0, SUPO2
+    c_test/super_test/SUP11956-depth-embed-bin2-t0001.2: SUPO0, SUPO2
+    c_test/super_test/SUP11957-depth-embed-bin2-t0165.1: SUPO0, SUPO2
+    c_test/super_test/SUP11958-depth-embed-bin2-t0016.1: SUPO0, SUPO2
+    c_test/super_test/SUP11959-depth-embed-bin2-t0171.1: SUPO0, SUPO2
+    c_test/super_test/SUP11960-depth-embed-bin2-t0135.1: SUPO0, SUPO2
+    c_test/super_test/SUP11961-depth-embed-bin2-t0005.2: SUPO0, SUPO2
+    c_test/super_test/SUP11962-depth-embed-bin2-t0137.0: SUPO0, SUPO2
+    c_test/super_test/SUP11963-depth-embed-bin2-t0061.0: SUPO0, SUPO2
+    c_test/super_test/SUP11964-depth-embed-bin2-t0133.1: SUPO0, SUPO2
+    c_test/super_test/SUP11965-depth-embed-bin2-t0030.0: SUPO0, SUPO2
+    c_test/super_test/SUP11966-depth-embed-bin2-t0112.0: SUPO0, SUPO2
+    c_test/super_test/SUP11967-depth-embed-bin2-t0071.1: SUPO0, SUPO2
+    c_test/super_test/SUP11968-depth-embed-bin2-t0193.0: SUPO0, SUPO2
+    c_test/super_test/SUP11969-depth-embed-bin2-t0051.1: SUPO0, SUPO2
+    c_test/super_test/SUP11970-depth-embed-bin2-t0135.0: SUPO0, SUPO2
+    c_test/super_test/SUP11971-depth-embed-bin2-t0139.1: SUPO0, SUPO2
+    c_test/super_test/SUP11972-depth-embed-bin2-t0010.0: SUPO0, SUPO2
+    c_test/super_test/SUP11973-depth-embed-bin2-t0128.0: SUPO0, SUPO2
+    c_test/super_test/SUP11974-depth-embed-bin2-t0138.1: SUPO0, SUPO2
+    c_test/super_test/SUP11975-depth-embed-bin2-t0175.1: SUPO0, SUPO2
+    c_test/super_test/SUP11976-depth-embed-bin2-t0095.0: SUPO0, SUPO2
+    c_test/super_test/SUP11977-depth-embed-bin2-t0039.0: SUPO0, SUPO2
+    c_test/super_test/SUP11978-depth-embed-bin2-t0002.0: SUPO0, SUPO2
+    c_test/super_test/SUP11979-depth-embed-bin2-t0018.1: SUPO0, SUPO2
+    c_test/super_test/SUP11980-depth-embed-bin2-t0000.0: SUPO0, SUPO2
+    c_test/super_test/SUP11981-depth-embed-bin2-t0155.1: SUPO0, SUPO2
+    c_test/super_test/SUP11982-depth-embed-bin2-t0000.1: SUPO0, SUPO2
+    c_test/super_test/SUP11983-depth-embed-bin2-t0132.0: SUPO0, SUPO2
+    c_test/super_test/SUP11984-depth-embed-bin2-t0022.0: SUPO0, SUPO2
+    c_test/super_test/SUP11985-depth-embed-bin2-t0053.1: SUPO0, SUPO2
+    c_test/super_test/SUP11986-depth-embed-bin2-t0129.0: SUPO0, SUPO2
+    c_test/super_test/SUP11987-depth-embed-bin2-t0173.1: SUPO0, SUPO2
+    c_test/super_test/SUP11988-depth-embed-bin2-t0026.1: SUPO0, SUPO2
+    c_test/super_test/SUP11989-depth-embed-bin2-t0003.1: SUPO0, SUPO2
+    c_test/super_test/SUP11990-depth-embed-bin2-t0013.1: SUPO0, SUPO2
+    c_test/super_test/SUP11991-depth-embed-bin2-t0124.1: SUPO0, SUPO2
+    c_test/super_test/SUP11992-depth-embed-bin2-t0111.1: SUPO0, SUPO2
+    c_test/super_test/SUP11993-depth-embed-bin2-t0100.1: SUPO0, SUPO2
+    c_test/super_test/SUP11994-depth-embed-bin2-t0111.0: SUPO0, SUPO2
+    c_test/super_test/SUP11995-depth-embed-bin2-t0136.0: SUPO0, SUPO2
+    c_test/super_test/SUP11996-depth-embed-bin2-t0125.0: SUPO0, SUPO2
+    c_test/super_test/SUP11997-depth-embed-bin2-t0055.0: SUPO0, SUPO2
+    c_test/super_test/SUP11998-depth-embed-bin2-t0077.0: SUPO0, SUPO2
+    c_test/super_test/SUP11999-depth-embed-bin2-t0121.1: SUPO0, SUPO2
+    c_test/super_test/SUP12000-depth-embed-bin2-t0167.1: SUPO0, SUPO2
+    c_test/super_test/SUP12001-depth-embed-bin2-t0072.0: SUPO0, SUPO2
+    c_test/super_test/SUP12002-depth-embed-bin2-t0033.1: SUPO0, SUPO2
+    c_test/super_test/SUP12003-depth-embed-bin2-t0145.0: SUPO0, SUPO2
+    c_test/super_test/SUP12004-depth-embed-bin2-t0151.1: SUPO0, SUPO2
+    c_test/super_test/SUP12005-depth-embed-bin2-t0195.0: SUPO0, SUPO2
+    c_test/super_test/SUP12006-depth-embed-bin2-t0154.0: SUPO0, SUPO2
+    c_test/super_test/SUP12007-depth-embed-bin2-t0155.0: SUPO0, SUPO2
+    c_test/super_test/SUP12008-depth-embed-bin2-t0107.0: SUPO0, SUPO2
+    c_test/super_test/SUP12009-depth-embed-bin2-t0063.0: SUPO0, SUPO2
+    c_test/super_test/SUP12010-depth-embed-bin2-t0023.1: SUPO0, SUPO2
+    c_test/super_test/SUP12011-depth-embed-bin2-t0123.1: SUPO0, SUPO2
+    c_test/super_test/SUP12012-depth-embed-bin2-t0036.1: SUPO0, SUPO2
+    c_test/super_test/SUP12013-depth-embed-bin2-t0197.0: SUPO0, SUPO2
+    c_test/super_test/SUP12014-depth-embed-bin2-t0047.0: SUPO0, SUPO2
+    c_test/super_test/SUP12015-depth-embed-bin2-t0014.0: SUPO0, SUPO2
+    c_test/super_test/SUP12016-depth-embed-bin2-t0114.1: SUPO0, SUPO2
+    c_test/super_test/SUP12017-depth-embed-bin2-t0031.2: SUPO0, SUPO2
+    c_test/super_test/SUP12018-depth-embed-bin2-t0041.0: SUPO0, SUPO2
+    c_test/super_test/SUP12019-depth-embed-bin2-t0063.1: SUPO0, SUPO2
+    c_test/super_test/SUP12020-depth-embed-bin2-t0117.0: SUPO0, SUPO2
+    c_test/super_test/SUP12021-depth-embed-bin2-t0015.1: SUPO0, SUPO2
+    c_test/super_test/SUP12022-depth-embed-bin2-t0003.0: SUPO0, SUPO2
+    c_test/super_test/SUP12023-depth-embed-bin2-t0150.0: SUPO0, SUPO2
+    c_test/super_test/SUP12024-depth-embed-bin2-t0136.1: SUPO0, SUPO2
+
+    #hir2mpl compiler error
+    c_test/gtorture_test/GCC00153-g.torture.execute-20020227-1: CO0, CO2
+    c_test/gtorture_test/GCC00164-g.torture.execute-20020411-1: CO0, CO2
+    c_test/gtorture_test/GCC00305-g.torture.execute-20041124-1: CO0, CO2
+    c_test/gtorture_test/GCC00307-g.torture.execute-20041201-1: CO0, CO2
+    c_test/gtorture_test/GCC00328-g.torture.execute-20050316-1: CO0, CO2
+    c_test/gtorture_test/GCC00329-g.torture.execute-20050316-2: CO0, CO2
+    c_test/gtorture_test/GCC00330-g.torture.execute-20050316-3: CO0, CO2
+    c_test/gtorture_test/GCC00334-g.torture.execute-20050604-1: CO0, CO2
+    c_test/gtorture_test/GCC00335-g.torture.execute-20050607-1: CO0, CO2
+    c_test/gtorture_test/GCC00353-g.torture.execute-20060420-1: CO0, CO2
+    c_test/gtorture_test/GCC00369-g.torture.execute-20070614-1: CO0, CO2
+    c_test/gtorture_test/GCC00656-g.torture.execute-960512-1: CO0, CO2
+    c_test/gtorture_test/GCC00787-g.torture.execute-builtin-bitops-1: CO0, CO2
+    c_test/gtorture_test/GCC00809-g.torture.execute-complex-2: CO0, CO2
+    c_test/gtorture_test/GCC00812-g.torture.execute-complex-5: CO0, CO2
+    c_test/gtorture_test/GCC00813-g.torture.execute-complex-6: CO0, CO2
+    c_test/gtorture_test/GCC00814-g.torture.execute-complex-7: CO0, CO2
+    c_test/gtorture_test/GCC00950-g.torture.execute-pr23135: CO0, CO2
+    c_test/gtorture_test/GCC01038-g.torture.execute-pr38151: CO0, CO2
+    c_test/gtorture_test/GCC01138-g.torture.execute-pr49644: CO0, CO2
+    c_test/gtorture_test/GCC01160-g.torture.execute-pr53645-2: CO0, CO2
+    c_test/gtorture_test/GCC01161-g.torture.execute-pr53645: CO0, CO2
+    c_test/gtorture_test/GCC01173-g.torture.execute-pr56837: CO0, CO2
+    c_test/gtorture_test/GCC01231-g.torture.execute-pr60960: CO0, CO2
+    c_test/gtorture_test/GCC01268-g.torture.execute-pr65427: CO0, CO2
+    c_test/gtorture_test/GCC01311-g.torture.execute-pr70460: CO0, CO2
+    c_test/gtorture_test/GCC01315-g.torture.execute-pr70903: CO0, CO2
+    c_test/gtorture_test/GCC01321-g.torture.execute-pr71626-1: CO0, CO2
+    c_test/gtorture_test/GCC01382-g.torture.execute-pr85169: CO0, CO2
+    c_test/gtorture_test/GCC01419-g.torture.execute-pr92618: CO0, CO2
+    c_test/gtorture_test/GCC01434-g.torture.execute-pr94412: CO0, CO2
+    c_test/gtorture_test/GCC01435-g.torture.execute-pr94524-1: CO0, CO2
+    c_test/gtorture_test/GCC01436-g.torture.execute-pr94524-2: CO0, CO2
+    c_test/gtorture_test/GCC01477-g.torture.execute-scal-to-vec1: CO0, CO2
+    c_test/gtorture_test/GCC01478-g.torture.execute-scal-to-vec2: CO0, CO2
+    c_test/gtorture_test/GCC01479-g.torture.execute-scal-to-vec3: CO0, CO2
+    c_test/gtorture_test/GCC01484-g.torture.execute-simd-1: CO0, CO2
+    c_test/gtorture_test/GCC01485-g.torture.execute-simd-2: CO0, CO2
+    c_test/gtorture_test/GCC01486-g.torture.execute-simd-4: CO0, CO2
+    c_test/gtorture_test/GCC01487-g.torture.execute-simd-5: CO0, CO2
+    c_test/gtorture_test/GCC01488-g.torture.execute-simd-6: CO0, CO2
+    c_test/super_test/SUP00196-3-0-2-tmartien5: SUPO0, SUPO2
+
+    #maple compiler error
+    c_test/gtorture_test/GCC01074-g.torture.execute-pr42248: CO0, CO2
+
+    #linker error
+    c_test/gtorture_test/GCC00094-g.torture.execute-20010122-1: CO0, CO2
+    c_test/gtorture_test/GCC00167-g.torture.execute-20020418-1: CO0, CO2
+    c_test/gtorture_test/GCC00223-g.torture.execute-20030323-1: CO0, CO2
+    c_test/gtorture_test/GCC00238-g.torture.execute-20030811-1: CO0, CO2
+    c_test/gtorture_test/GCC00753-g.torture.execute-alias-2: CO0, CO2
+    c_test/gtorture_test/GCC00388-g.torture.execute-20071220-2: CO2
+    c_test/gtorture_test/GCC00754-g.torture.execute-alias-3: CO0, CO2
+    c_test/gtorture_test/GCC00755-g.torture.execute-alias-4: CO0, CO2
+    c_test/gtorture_test/GCC00784-g.torture.execute-bswap-1: CO0, CO2
+    c_test/gtorture_test/GCC00786-g.torture.execute-bswap-3: CO0, CO2
+    c_test/gtorture_test/GCC00843-g.torture.execute-frame-address: CO0, CO2
+    c_test/gtorture_test/GCC00920-g.torture.execute-pr17377: CO0, CO2
+    c_test/gtorture_test/GCC01246-g.torture.execute-pr64006: CO0, CO2
+    c_test/gtorture_test/GCC01289-g.torture.execute-pr68381: CO0, CO2
+    c_test/gtorture_test/GCC01320-g.torture.execute-pr71554: CO0, CO2
+    c_test/gtorture_test/GCC01356-g.torture.execute-pr81281: CO0, CO2
+    c_test/gtorture_test/GCC01374-g.torture.execute-pr84169: CO0, CO2
+    c_test/gtorture_test/GCC01380-g.torture.execute-pr85095: CO0, CO2
+    c_test/gtorture_test/GCC01406-g.torture.execute-pr89434: CO0, CO2
+    c_test/gtorture_test/GCC01409-g.torture.execute-pr90025: CO0, CO2
+    c_test/gtorture_test/GCC01410-g.torture.execute-pr90311: CO0, CO2
+    c_test/gtorture_test/GCC01413-g.torture.execute-pr91450-1: CO0, CO2
+    c_test/gtorture_test/GCC01414-g.torture.execute-pr91450-2: CO0, CO2
+    c_test/gtorture_test/GCC01417-g.torture.execute-pr91635: CO0, CO2
+    c_test/gtorture_test/GCC01421-g.torture.execute-pr93213: CO0, CO2
+    c_test/gtorture_test/GCC01425-g.torture.execute-pr93494: CO0, CO2
+    c_test/gtorture_test/GCC01446-g.torture.execute-pr97386-1: CO0, CO2
+    c_test/gtorture_test/GCC01455-g.torture.execute-pr97888-1: CO0, CO2
+
+    #run error
+    c_test/gtorture_test/GCC00203-g.torture.execute-20021127-1: CO0, CO2
+    c_test/gtorture_test/GCC00218-g.torture.execute-20030222-1: CO0, CO2
+    c_test/gtorture_test/GCC00777-g.torture.execute-bitfld-3: CO0, CO2
+    c_test/gtorture_test/GCC00779-g.torture.execute-bitfld-5: CO0, CO2
+    c_test/gtorture_test/GCC00831-g.torture.execute-eeprof-1: CO0, CO2
+    c_test/gtorture_test/GCC00989-g.torture.execute-pr32244-1: CO0, CO2
+    c_test/gtorture_test/GCC01011-g.torture.execute-pr34971: CO0, CO2
+    c_test/gtorture_test/GCC01042-g.torture.execute-pr38533: CO2
+    c_test/gtorture_test/GCC01044-g.torture.execute-pr38969: CO0
+    c_test/gtorture_test/GCC01089-g.torture.execute-pr43560: CO2
+    c_test/gtorture_test/GCC01107-g.torture.execute-pr45695: CO0, CO2
+    c_test/gtorture_test/GCC01134-g.torture.execute-pr49279: CO0, CO2
+    c_test/super_test/SUP00796-3-3-6-t6: SUPO0, SUPO2
+    c_test/super_test/SUP01305-3-7-2-t1: SUPO0, SUPO2
+    c_test/super_test/SUP02029-4-6-2-1-t10: SUPO2
+    c_test/super_test/SUP00022-2-2-4-2-t15: SUPO0, SUPO2
+    c_test/super_test/SUP00243-3-0-2-tspr889: SUPO0, SUPO2
+    c_test/super_test/SUP01242-3-2-1-2-a-t301: SUPO0, SUPO2
+
+    #maple issue
+    c_test/sanity_test/SANITY0012-large_stack: CO0, CO2
+    c_test/sanity_test/SANITY0027-convert: CO0, CO2
diff --git a/testsuite/driver/script/ExtraJavaFileOpt.py b/testsuite/driver/script/ExtraJavaFileOpt.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c1dc4c8f1edb31df42f015e993978ab4a98cbd7
--- /dev/null
+++ b/testsuite/driver/script/ExtraJavaFileOpt.py
@@ -0,0 +1,86 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+'''
+this script is used for modify the test.cfg of JAVA test cases, note the spaces!
+1. ,EXTRA_JAVA_FILE = "a.java:b.java" ---> EXTRA_JAVA_FILE = [a.java,b.java]
+2. ,EXTRA_JAVA_FILE = "a.java" ---> EXTRA_JAVA_FILE = a.java
+3. ,EXTRA_JAVA_FILE = 'a.java' ---> EXTRA_JAVA_FILE = a.java
+4. ,EXTRA_JAVA_FILE = 'a.java:b.java' ---> EXTRA_JAVA_FILE = [a.java,b.java]
+5. ,EXTRA_JAVA_FILE = 'a.java,' ---> EXTRA_JAVA_FILE = a.java
+'''
+
+import os, re
+cur_path = os.path.abspath(__file__)
+HOME_PATH = os.path.dirname(os.path.dirname(os.path.dirname(cur_path)))     # ouroboros project
+
+# get test.cfg in all test cases
+def record_all_testCFG(PATH):
+    compile_record = open("compile_record.txt",'w')     # save compile command
+    run_record = open("run_record.txt",'w')             # save run command
+    for fpathe,dirs,fs in os.walk(PATH):
+        for file in fs:
+            if file == 'test.cfg':
+                f_tmp = open(os.path.join(fpathe, file),'r')
+                try:
+                    line = f_tmp.readline()
+                    while line != "":
+                        if 'compile(' in line:
+                            compile_record.write(line.strip() + " @" + fpathe + '\n')
+                        elif 'run(' in line:
+                            run_record.write(line.strip() + " @" + fpathe + '\n')
+                        line = f_tmp.readline()
+                    f_tmp.close()
+                except:
+                    print(os.path.join(fpathe, file)+"  open fail")
+    compile_record.close()
+    run_record.close()
+
+def quote2bracket_ExtraJavaFile(command, log=False):
+    if type(command) != str:
+        return
+    new_command = command.replace(" ", "")
+    new_command = re.sub(r':(?=.+(\"|\'))', ',', new_command)                   # : -> ,
+    new_command = re.sub(r'(?<=,EXTRA_JAVA_FILE=)(\"|\')', '[', new_command)    # '/" -> [
+    new_command = re.sub(r'(\"|\')(?=\)|,)', ']', new_command)                  # '/" -> ]
+    if log and (command != new_command):
+        print(command + " ---> " + new_command)
+    return new_command
+
+def modify_testCFG(file):
+    new_commands = []
+    f = open(file,'r+')
+    lines = f.readlines()
+    f.close()
+    for line in lines:
+        if 'compile(' in line and "EXTRA_JAVA_FILE" in line:
+            new_commands.append(quote2bracket_ExtraJavaFile(line,True))
+        else:
+            new_commands.append(line)
+    f = open(file,'w+')
+    f.writelines(new_commands)
+    f.close()
+
+def main():
+    # record_all_testCFG(HOME_PATH)
+    for fpathe,dirs,fs in os.walk(HOME_PATH):
+        for file in fs:
+            if file == 'test.cfg':
+                try:
+                    modify_testCFG(os.path.join(fpathe, file))
+                except:
+                    print(os.path.join(fpathe, file)+"  open fail")
+
+if __name__ == '__main__':
+    main()
diff --git a/testsuite/driver/script/RemoveCleanInConf.py b/testsuite/driver/script/RemoveCleanInConf.py
new file mode 100644
index 0000000000000000000000000000000000000000..50d28406a4d077fa91fd3cdf0906c7cd60e8aa07
--- /dev/null
+++ b/testsuite/driver/script/RemoveCleanInConf.py
@@ -0,0 +1,79 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+'''
+this script is used to remove 'clean()' in test.cfg of each test case;
+and also remove 'clean' command in mode/*.py
+'''
+
+import os
+import re
+import sys
+import optparse
+
+cur_path = os.path.abspath(__file__)
+HOME_PATH = os.path.dirname(os.path.dirname(os.path.dirname(cur_path)))     # ouroboros project
+MODE_PATH = os.path.join(HOME_PATH, 'driver', 'src', 'mode')
+MODE_OPS_PATH = os.path.join(HOME_PATH, 'driver', 'src', 'mode_ops')
+
+init_opt = optparse.OptionParser()
+init_opt.add_option('-f', '--file', dest="one_file", default=None, help='it must be test.cfg with abs path')
+init_opt.add_option('-a', '--all', dest="all_files", action='store_true',default=False, help='whether to modify all cases test.cfg')
+init_opt.add_option('-m', '--mode', dest="mode_path", default=None, help='~/ouroboros/driver/src/mode path')
+
+def remove_clean_in_testCFG(file):
+    with open(file,'r+') as f:
+        old_commands = f.read()
+    new_commands = old_commands.replace('clean()\n','')
+    with open(file, 'w+') as f:
+        f.writelines(new_commands)
+
+def remove_clean_command_in_mode(path):
+    file_pattern = r'[A-Z0-9_]+\.py'
+    clean_pattern = r'\    "clean\": \[[\s]*Shell\([\s]*"rm -rf .*"[\s]*\)[\s]*\]\,\n(?=[\s]*")'
+    for file in os.listdir(path):
+        if re.match(file_pattern, file) is None:
+            continue
+        with open(os.path.join(path, file), 'r+') as f:
+            file_content = f.read()
+        new_file_content = re.sub(clean_pattern, '', file_content)
+        with open(os.path.join(path, file), 'w+') as f:
+            f.write(new_file_content)
+
+def main(orig_args):
+    opt, args = init_opt.parse_args(orig_args)
+    if args:
+        init_optparse.print_usage()
+        sys.exit(1)
+    file = opt.one_file
+    is_all = opt.all_files
+    mode_path = opt.mode_path
+    if is_all:
+        remove_clean_command_in_mode(MODE_PATH)
+        remove_clean_command_in_mode(MODE_OPS_PATH)
+        for fpathe,dirs,fs in os.walk(os.path.dirname(HOME_PATH)):
+            for file in fs:
+                if file == 'test.cfg':
+                    try:
+                        remove_clean_in_testCFG(os.path.join(fpathe, file))
+                    except:
+                        print(os.path.join(fpathe, file)+"  open fail")
+    elif file is not None and file.endswith('test.cfg'):
+        remove_clean_in_testCFG(os.path.join(HOME_PATH, file))
+
+    if mode_path is not None:
+        remove_clean_command_in_mode(mode_path)
+
+if __name__ == '__main__':
+    main(sys.argv[1:])
diff --git a/testsuite/driver/script/check.py b/testsuite/driver/script/check.py
new file mode 100755
index 0000000000000000000000000000000000000000..cce8ee0b3f0aa3e18e6aa5e18863c2385f007d29
--- /dev/null
+++ b/testsuite/driver/script/check.py
@@ -0,0 +1,69 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+#!/usr/bin/python3
+
+import os
+import sys
+import kernel
+import paramiko
+from optparse import OptionParser
+
+parser = OptionParser()
+parser.add_option("-c", "--check", dest="check", default="assert", help="This is the kind of log check.Three kinds can be choose: assert regx")
+parser.add_option("-r", "--regx", dest="regx", default="regx", help="This is the kind of log check.")
+parser.add_option("-f", "--result", dest="result", default="output.log", help="This is the filename used to compare")
+parser.add_option("-s", "--str", dest="str", default="", help="This is the string used to compare")
+parser.add_option("-e", "--expected", dest="expected", default="expected.txt", help="This is the filename used to compare")
+parser.add_option("-n", "--num", dest="num", default="0", help="This is the filename used to compare")
+
+(options, args) = parser.parse_args()
+
+if options.check == "assert":
+    checkstatus = kernel.assertEqual("", options.expected, options.result)
+    if checkstatus :
+        print("\033[32;1m assert check pass \033[0m")
+    else:
+        print("\033[31;1m FAIL : " + options.expected + " and " + options.result + " are not equal \033[0m")
+
+if options.check == "regx":
+    checkstatus = kernel.Regx_check(options.regx, options.result)
+    if checkstatus :
+        print("\033[32;1m regx check pass \033[0m")
+    else:
+        print("\033[31;1m FAIL : regx cannot be found in " + options.result  + " \033[0m")
+
+if options.check == "contain":
+    checkstatus = kernel.assertContain(options.str, options.result)
+    if checkstatus :
+        print("\033[32;1m contain check pass \033[0m")
+    else:
+        print("\033[31;1m FAIL : string cannot be found in " + options.result  + "  \033[0m")
+
+if options.check == "num":
+    checkstatus = kernel.Str_CheckNum(options.result,options.str,options.num)
+    if checkstatus :
+        print("\033[32;1m  num check pass \033[0m")
+    else:
+        print("\033[31;1m FAIL : the number of" + options.str + "in " + options.result + " is incorrect  \033[0m")
+
+if options.check == "not_contain":
+    checkstatus = kernel.assertContain(options.str, options.result)
+    checkstatus = not checkstatus
+    if checkstatus :
+        print("\033[32;1m not contain check pass \033[0m")
+    else:
+        print("\033[31;1m FAIL : string can be found in " + options.result  + "  \033[0m")
+
+sys.exit(checkstatus == False)
diff --git a/testsuite/driver/script/kernel.py b/testsuite/driver/script/kernel.py
new file mode 100755
index 0000000000000000000000000000000000000000..3b063638dd6adce950487bf464c153acb1d7cb25
--- /dev/null
+++ b/testsuite/driver/script/kernel.py
@@ -0,0 +1,131 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+#! /usr/bin/python3
+
+import os
+import subprocess
+import types
+import filecmp
+import re
+
+#Assert Area
+def assertEqual(message, expected, actual):
+    print(message)
+    if not type(expected) is type(actual):
+        print("assertError: compare type ain't the same")
+        return False
+
+    if expected == None or actual == None:
+        print("assertError: No correct input for equals")
+        return False
+    if os.path.isfile(expected) and os.path.isfile(actual):
+        fcmp = filecmp.cmp(expected, actual)
+        if not fcmp:
+            assertError("equal", str(expected), str(actual))
+            return False
+        else:
+            print(expected+" and "+actual+" are the same")
+            return True
+
+    if type(actual) is int or type(actual) is float or type(actual) is str:
+        if not expected == actual:
+            assertError("equal", str(expected), str(actual))
+            return False
+        else:
+            print("expected:"+str(expected)+" and "+"actual:"+str(actual)+" are equal")
+            return True
+
+def assertTrue(message, condition):
+    print(message)
+    if type(condition) is int or type(condition) is float:
+        print("condition is value, goto assertEqual")
+        return assertEqual("Check if condition value would be Zero", 0, condition )
+    else:
+        if type(condition) is str :
+            cmd = Executor(condition)
+            res = cmd.execute()
+            if res.returnValue == 0:
+                print("Condition got True")
+                return True
+            else: 
+                print("Condition got  Failed")
+                return False
+        else:
+            return False
+
+def assertContain(message, filename):
+    print(message)
+    if os.path.isfile(filename):
+        fp = open(filename, "r")
+        strr = fp.read()
+        if(strr.find(message) != -1):
+            print(filename + " contains the string:" + message)
+            fp.close()
+            return True
+        fp.close()
+    return False
+
+
+def assertFalse(message, condition):
+    return True
+
+def assertArrayEquals(expected, actuals):
+    return True
+
+def assertNotNull(obj):
+    return True
+
+def assertNull(obj):
+    return True
+
+def assertThat(actual,expr):
+#Dirty API. Need to work well with python.
+    tool = os.environ['MAPLE_ROOT']+"/Zeiss/prebuilt/tools/regx_checker.sh "
+    cmd = Executor(tool + actual + " " + expr)
+    res = cmd.execute()
+    if res.returnValue == 0:
+        return True
+    else:
+        return False
+
+#AssertInfo Area
+def assertError(cmptype, name1, name2):
+    print("assertError: "+ name1 + " and " + name2 + " are not "+ cmptype)
+
+def Regx_check(regx,resultfile):
+    if not os.path.isfile(resultfile) and not os.path.isfile(regx):
+        return False
+    fp = open(regx,"r",encoding="latin1")
+    fo = open(resultfile,"r",encoding="latin1")
+    strr = fo.read()
+    for s in fp.readlines():
+        s=s.strip()
+        if(strr.find(s) == -1):
+            fp.close()
+            fo.close()
+            return False
+    fp.close()
+    fo.close()
+    return True
+
+def Str_CheckNum(resultfile,string,num):
+    fm = open(resultfile,"r")
+    fs = fm.read()
+    strnum = re.findall(string,fs)
+    num=int(num)
+    if num != len(strnum) :
+        return False
+    fm.close()
+    return True
diff --git a/testsuite/driver/script/mm b/testsuite/driver/script/mm
new file mode 100755
index 0000000000000000000000000000000000000000..2b212bf05654fe65d0951a0f6f3214d48b0e9919
--- /dev/null
+++ b/testsuite/driver/script/mm
@@ -0,0 +1,70 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+#!/bin/bash
+
+THREADS=$(cat /proc/cpuinfo| grep "processor"| wc -l)
+PWD=$(pwd)
+num=${#CASE_ROOT}
+let num++
+
+#mm MODE=O0
+if [ $# = 1 ] && [[ "x${1}" =~ ^xMODE=.* ]]
+then
+    TARGET=${PWD:${num}}
+    MODE=${1#*=}
+    python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --mode=${MODE} --detail
+
+#mm clean
+elif [ $# = 1 ] && [ "x${1}" = "xclean" ]
+then
+    TARGET=${PWD:${num}}
+    python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --clean --detail
+
+#mm save
+elif [ $# = 1 ] && [ "x${1}" = "xsave" ]
+then
+    TARGET=${PWD:${num}}
+    python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --save
+
+#mm testall
+elif [ $# = 1 ] && [ -f ${CASE_ROOT}/driver/config/${1}.conf ]
+then
+    TARGET=${1}
+    python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --run-path=${OUT_ROOT}/host/test --j=${THREADS}
+
+#mm testall MODE=O0
+elif [ $# = 2 ] && [ -f ${CASE_ROOT}/driver/config/${1}.conf ] && [[ "x${2}" =~ ^xMODE=.* ]]
+then
+    MODE=${2#*=}
+    TARGET=${1}
+    python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --run-path=${OUT_ROOT}/host/test --mode=${MODE} --j=${THREADS}
+
+#mm app_test
+elif [ $# = 1 ] && [ -d ${CASE_ROOT}/${1} ]
+then
+    TARGET=${1}
+    python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --run-path=${OUT_ROOT}/host/test --j=${THREADS}
+
+#mm app_test MODE=O2
+elif [ $# = 2 ] && [ -d ${CASE_ROOT}/${1} ] && [[ "x${2}" =~ ^xMODE=.* ]]
+then
+    TARGET=${1}
+    MODE=${2#*=}
+    python3 ${CASE_ROOT}/driver/src/driver.py --target=${TARGET} --run-path=${OUT_ROOT}/host/test --mode=${MODE} --j=${THREADS}
+
+else
+    echo "Input Wrong~!"
+    exit 1
+fi
diff --git a/testsuite/driver/src/api/__init__.py b/testsuite/driver/src/api/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a055c3126768375451e1e962ccf8ba049192afc
--- /dev/null
+++ b/testsuite/driver/src/api/__init__.py
@@ -0,0 +1,32 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+
+names = locals()
+
+my_dir = os.path.dirname(__file__)
+for py in os.listdir(my_dir):
+    if py == '__init__.py':
+        continue
+
+    if py.endswith('.py'):
+        name = py[:-3]
+
+        clsn = name.capitalize()
+        while clsn.find('_') > 0:
+            h = clsn.index('_')
+            clsn = clsn[0:h] + clsn[h + 1:].capitalize()
+        api = __import__("api." + name, fromlist=[clsn])
+        names[clsn] = getattr(api, clsn)
diff --git a/testsuite/driver/src/api/c2ast.py b/testsuite/driver/src/api/c2ast.py
new file mode 100755
index 0000000000000000000000000000000000000000..0c76f72ee9fa136d6e2ae4ed0ce22860cb11c684
--- /dev/null
+++ b/testsuite/driver/src/api/c2ast.py
@@ -0,0 +1,32 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class C2ast(ShellOperator):
+
+    def __init__(self, clang, infile, include_path, outfile, option="", return_value_list=None, redirection=None, extra_opt=""):
+        super().__init__(return_value_list, redirection)
+        self.clang = clang
+        self.infile = infile
+        self.option = option
+        self.include_path = include_path
+        self.outfile = outfile
+        self.extra_opt = extra_opt
+
+    def get_command(self, variables):
+        include_path_str = " ".join(["-isystem " + path for path in self.include_path])
+        self.command = self.clang + " -emit-ast " + self.option + " " + include_path_str + " -o " + self.outfile + " " + self.extra_opt + " " + self.infile
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/c_linker.py b/testsuite/driver/src/api/c_linker.py
new file mode 100644
index 0000000000000000000000000000000000000000..039b8da44989dd8d6802724100f94a367253cff1
--- /dev/null
+++ b/testsuite/driver/src/api/c_linker.py
@@ -0,0 +1,30 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class CLinker(ShellOperator):
+
+    def __init__(self, infile, front_option, outfile, back_option, mid_opt="",return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.infile = infile
+        self.front_option = front_option
+        self.outfile = outfile
+        self.back_option = back_option
+        self.mid_opt = mid_opt
+
+    def get_command(self, variables):
+        self.command = "${OUT_ROOT}/tools/bin/aarch64-linux-gnu-gcc " + self.front_option + " -o " + self.outfile + " " + self.mid_opt + " " +  self.infile + " " + self.back_option
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/check_file_equal.py b/testsuite/driver/src/api/check_file_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..4741025b7152e178b985b09cab043c004b751052
--- /dev/null
+++ b/testsuite/driver/src/api/check_file_equal.py
@@ -0,0 +1,27 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class CheckFileEqual(ShellOperator):
+
+    def __init__(self, file1, file2, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.file1 = file1
+        self.file2 = file2
+
+    def get_command(self, variables):
+        self.command = "diff " + self.file1 + " " + self.file2
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/check_reg_contain.py b/testsuite/driver/src/api/check_reg_contain.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9964972a293f2224cf4397c1266911fd8c4ade4
--- /dev/null
+++ b/testsuite/driver/src/api/check_reg_contain.py
@@ -0,0 +1,27 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class CheckRegContain(ShellOperator):
+
+    def __init__(self, reg, file, return_value_list=None):
+        super().__init__(return_value_list)
+        self.reg = reg
+        self.file = file
+
+    def get_command(self, variables):
+        self.command = "python3 ${OUT_ROOT}/script/check.py --check=contain --str=\"" + self.reg + "\" --result=" + self.file
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/driver.py b/testsuite/driver/src/api/driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..41b1dc476465b27d5ae3ab56e8f343e34c1711ee
--- /dev/null
+++ b/testsuite/driver/src/api/driver.py
@@ -0,0 +1,31 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class Driver(ShellOperator):
+
+    def __init__(self, maple, global_option, inputs, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.maple = maple
+        self.global_option = global_option
+        self.inputs = inputs
+
+    def get_command(self, variables):
+        self.command = self.maple + " "
+        self.command += self.global_option + " "
+        self.command += self.inputs + " "
+
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/gen_bin.py b/testsuite/driver/src/api/gen_bin.py
new file mode 100755
index 0000000000000000000000000000000000000000..05c76397be3d94409eeb58ecba9b589a3e02d66d
--- /dev/null
+++ b/testsuite/driver/src/api/gen_bin.py
@@ -0,0 +1,27 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class GenBin(ShellOperator):
+
+    def __init__(self, infile, outfile, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.infile = infile
+        self.outfile = outfile
+
+    def get_command(self, variables):
+        self.command = "aarch64-linux-gnu-gcc -O2 -static -L../../lib/c -std=c89 -o " + self.outfile + " " + self.infile + " -lst -lm"
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/hir2mpl.py b/testsuite/driver/src/api/hir2mpl.py
new file mode 100755
index 0000000000000000000000000000000000000000..346bca9652c1a8136c40ec8ab0f6e1b8ecdec037
--- /dev/null
+++ b/testsuite/driver/src/api/hir2mpl.py
@@ -0,0 +1,29 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class Hir2mpl(ShellOperator):
+
+    def __init__(self, hir2mpl, infile, outfile, option="--enable-variable-array", return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.hir2mpl = hir2mpl
+        self.infile = infile
+        self.outfile = outfile
+        self.option = option
+
+    def get_command(self, variables):
+        self.command = self.hir2mpl + " " + self.option + " " + self.infile + " -o " + self.outfile
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/irbuild.py b/testsuite/driver/src/api/irbuild.py
new file mode 100644
index 0000000000000000000000000000000000000000..b71f7424491b906a3ee1fb229b19723ac8ca7c95
--- /dev/null
+++ b/testsuite/driver/src/api/irbuild.py
@@ -0,0 +1,27 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class Irbuild(ShellOperator):
+
+    def __init__(self, irbuild, infile, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.irbuild = irbuild
+        self.infile = infile
+
+    def get_command(self, variables):
+        self.command = self.irbuild + " " + self.infile
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/java2dex.py b/testsuite/driver/src/api/java2dex.py
new file mode 100644
index 0000000000000000000000000000000000000000..43c61e6a0f1dda6e5dbdcba3a909bc1cd71ae3c0
--- /dev/null
+++ b/testsuite/driver/src/api/java2dex.py
@@ -0,0 +1,28 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class Java2dex(ShellOperator):
+
+    def __init__(self, jar_file, outfile, infile, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.jar_file = jar_file
+        self.outfile = outfile
+        self.infile = infile
+
+    def get_command(self, variables):
+        self.command = "bash ${OUT_ROOT}/tools/bin/java2dex  -o " + self.outfile + " -p " + ":".join(self.jar_file) + " -i " + ":".join(self.infile)
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/linker.py b/testsuite/driver/src/api/linker.py
new file mode 100644
index 0000000000000000000000000000000000000000..300cc265711d9ff009ce2377f2a9e99cf354c9ba
--- /dev/null
+++ b/testsuite/driver/src/api/linker.py
@@ -0,0 +1,26 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class Linker(ShellOperator):
+
+    def __init__(self, lib, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.lib = lib
+
+    def get_command(self, variables):
+        self.command = "${OUT_ROOT}/tools/bin/clang++ -g3 -O2 -x assembler-with-cpp -march=armv8-a -target aarch64-linux-gnu -c ${APP}.VtableImpl.s && ${OUT_ROOT}/tools/bin/clang++ ${APP}.VtableImpl.o -L${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/" + self.lib + " -g3 -O2 -march=armv8-a -target aarch64-linux-gnu -fPIC -shared -o ${APP}.so ${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/mrt_module_init.o -fuse-ld=lld -rdynamic -lcore-all -lcommon-bridge -Wl,-z,notext -Wl,-T${OUT_ROOT}/${MAPLE_BUILD_TYPE}/ops/linker/maplelld.so.lds"
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/maple.py b/testsuite/driver/src/api/maple.py
new file mode 100644
index 0000000000000000000000000000000000000000..6417addd2d0e0e6cf97d12717e6e0eb5f2fb6996
--- /dev/null
+++ b/testsuite/driver/src/api/maple.py
@@ -0,0 +1,36 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class Maple(ShellOperator):
+
+    def __init__(self, maple, run, option, global_option, infile, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.maple = maple
+        self.run = run
+        self.option_dict = option
+        self.global_option = global_option
+        self.infile = infile
+
+    def get_command(self, variables):
+        self.command = self.maple + " --run=" + ":".join(self.run) + " "
+        option = []
+        for cmd in self.run:
+            option.append(self.option_dict[cmd])
+        self.command += "--option=\"" + ":".join(option) + "\" "
+        self.command += self.global_option + " "
+        self.command += "--infile " + self.infile
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/mplsh.py b/testsuite/driver/src/api/mplsh.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec379177b9716c738a8c0f0356e3df8402d77fff
--- /dev/null
+++ b/testsuite/driver/src/api/mplsh.py
@@ -0,0 +1,47 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class Mplsh(ShellOperator):
+
+    def __init__(self, mplsh, xbootclasspath, infile, garbage_collection_kind, return_value_list=None, env=None, qemu=None, qemu_libc=None, qemu_ld_lib=None, main="${APP}", args=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.env = env
+        self.qemu = qemu
+        self.qemu_libc = qemu_libc
+        self.qemu_ld_lib = qemu_ld_lib
+        self.mplsh = mplsh
+        self.garbage_collection_kind = garbage_collection_kind
+        self.xbootclasspath = xbootclasspath
+        self.infile = infile
+        self.main = main
+        self.args = args
+
+    def get_command(self, variables):
+        self.command = ""
+        if self.env is not None:
+            for env_var in self.env.keys():
+                self.command += env_var + "=" + self.env[env_var] + " "
+        if self.qemu is not None:
+            self.command += self.qemu + " -L " + self.qemu_libc + " -E LD_LIBRARY_PATH=" + ":".join(self.qemu_ld_lib) + " "
+        self.command += self.mplsh + " "
+        if self.garbage_collection_kind == "GC":
+            self.command += "-Xgconly "
+        if self.args is not None:
+            self.command +="-Xbootclasspath:" + self.xbootclasspath + " -cp " + self.infile + " " + self.main + " " + self.args
+        else:
+            self.command += "-Xbootclasspath:" + self.xbootclasspath + " -cp " + self.infile + " " + self.main
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/qemu.py b/testsuite/driver/src/api/qemu.py
new file mode 100755
index 0000000000000000000000000000000000000000..3dcd08d8a47e356ef64f82a1aa6c1f6172f86db5
--- /dev/null
+++ b/testsuite/driver/src/api/qemu.py
@@ -0,0 +1,27 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class Qemu(ShellOperator):
+
+    def __init__(self, qemu, infile, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.qemu = qemu
+        self.infile = infile
+
+    def get_command(self, variables):
+        self.command = self.qemu + " " + self.infile
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/shell.py b/testsuite/driver/src/api/shell.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb3a626da731dac7ea3388a06803fcc14cb5df1b
--- /dev/null
+++ b/testsuite/driver/src/api/shell.py
@@ -0,0 +1,25 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class Shell(ShellOperator):
+
+    def __init__(self, command, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.command = command
+
+    def get_command(self, variables):
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/api/shell_operator.py b/testsuite/driver/src/api/shell_operator.py
new file mode 100644
index 0000000000000000000000000000000000000000..04fed42760b007990d39fe20bb6189d518d2c4b9
--- /dev/null
+++ b/testsuite/driver/src/api/shell_operator.py
@@ -0,0 +1,52 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+class ShellOperator(object):
+
+    def __init__(self, return_value_list, redirection=None):
+        self.command = ""
+        if return_value_list is None:
+            self.return_value_list = [0]
+        else:
+            self.return_value_list = return_value_list
+        self.redirection = redirection
+
+    def get_redirection(self):
+        if self.redirection is not None:
+            return " > " + self.redirection + " 2>&1"
+        else:
+            return ""
+
+    def get_check_command(self):
+        if len(self.return_value_list) == 1:
+            if 0 in self.return_value_list:
+                return ""
+            else:
+                return " || [ $? -eq " + str(self.return_value_list[0]) + " ]"
+        elif len(self.return_value_list) == 0:
+            return " || true"
+        else:
+            return_value_check_str_list = []
+            for return_value in self.return_value_list:
+                return_value_check_str_list.append("[ ${return_value} -eq " + str(return_value) + " ]")
+            return " || (return_value=$? && (" + " || ".join(return_value_check_str_list) + "))"
+
+    def get_final_command(self, variables):
+        final_command = self.command
+        if variables is not None:
+            for variable in variables.keys():
+                final_command = final_command.replace("${" + variable + "}", variables[variable])
+        final_command += self.get_redirection()
+        final_command += self.get_check_command()
+        return final_command
diff --git a/testsuite/driver/src/api/simple_maple.py b/testsuite/driver/src/api/simple_maple.py
new file mode 100755
index 0000000000000000000000000000000000000000..2ac1c695d43cdd5e3b84199e02fc0f2598e8257b
--- /dev/null
+++ b/testsuite/driver/src/api/simple_maple.py
@@ -0,0 +1,28 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api.shell_operator import ShellOperator
+
+
+class SimpleMaple(ShellOperator):
+
+    def __init__(self, maple, option, infile, return_value_list=None, redirection=None):
+        super().__init__(return_value_list, redirection)
+        self.maple = maple
+        self.option = option
+        self.infile = infile
+
+    def get_command(self, variables):
+        self.command = self.maple + " " + self.option + " " + self.infile
+        return super().get_final_command(variables)
diff --git a/testsuite/driver/src/basic_tools/file.py b/testsuite/driver/src/basic_tools/file.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9ccf735e1a6f36ef5889c13707662656510c80f
--- /dev/null
+++ b/testsuite/driver/src/basic_tools/file.py
@@ -0,0 +1,140 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+
+from .string import pre_deal
+
+
+def read_file(file):
+    f = open(file, 'r')
+    source_lines = f.readlines()
+    f.close()
+    result_lines = []
+    for line in source_lines:
+        result_lines.append(pre_deal(line))
+    return result_lines
+
+
+def read_file_in_string(file):
+    f = open(file, 'r')
+    str = f.read()
+    f.close()
+    return str
+
+
+def file_exist(path, file):
+    target_file = search_file(path, file, equal)
+    if target_file == "":
+        return False
+    else:
+        return True
+
+
+def directory_exist(path, dir):
+    target_file = search_dir(path, dir, equal)
+    if target_file == "":
+        return False
+    else:
+        return True
+
+
+def lambda_fun(a, b, fun):
+    return fun(a, b)
+
+
+def contain(a, b):
+    return True if a in b else False
+
+
+def equal(a, b):
+    return True if a == b else False
+
+
+def regular(a, b):
+    return True if a.match(b) else False
+
+
+def search_dir(path, dir_name, type):
+    """Search directory in certain path"""
+    target_path = ""
+    for item in os.listdir(path):
+        item_path = os.path.join(path, item)
+        if os.path.isdir(item_path):
+            if lambda_fun(dir_name, item, type):
+                target_path = item_path
+                break
+            else:
+                target_path = search_dir(item_path, dir_name, type)
+                if target_path != "":
+                    break
+    return target_path
+
+
+def search_file(path, file_name, type):
+    """Search file in certain path"""
+    target_path = ""
+    for item in os.listdir(path):
+        item_path = os.path.join(path, item)
+        if os.path.isdir(item_path):
+            target_path = search_file(item_path, file_name, type)
+            if target_path != "":
+                break
+        elif os.path.isfile(item_path):
+            if lambda_fun(file_name, item, type):
+                target_path = item_path
+                break
+    return target_path
+
+
+def search_all_file(path, file_name, type):
+    """Search all file in certain path"""
+    all_target_path = []
+    target_path = []
+    for item in os.listdir(path):
+        item_path = os.path.join(path, item)
+        if os.path.isdir(item_path):
+            target_path = search_all_file(item_path, file_name, type)
+            if target_path != []:
+                all_target_path += target_path
+        elif os.path.isfile(item_path):
+            if lambda_fun(file_name, item, type):
+                all_target_path.append(item_path)
+                break
+    return all_target_path
+
+def walk_all_files(path):
+    all_file_list = []
+    for fpathe, dirs, fs in os.walk(path):
+        all_file_list += [os.path.join(fpathe,f) for f in fs]
+    return all_file_list
+
+def rm_empty_folder(path):
+    if not os.path.isdir(path):
+        return
+    files = os.listdir(path)
+    for fullpath in [os.path.join(path, f) for f in files]:
+        rm_empty_folder(fullpath)
+    files = os.listdir(path)
+    if not len(files):
+        os.rmdir(path)
+
+def get_sub_files(path):
+    all_sub_files = []
+    for folder in os.listdir(path):
+        if not os.path.isdir(folder):
+            continue
+        for fpathe, dirs, fs in os.walk(folder):
+            all_sub_files += [os.path.join(fpathe,file) for file in fs]
+    return all_sub_files
diff --git a/testsuite/driver/src/basic_tools/string.py b/testsuite/driver/src/basic_tools/string.py
new file mode 100644
index 0000000000000000000000000000000000000000..7077c7e70c58ff7df5e7da63280e492728a71f25
--- /dev/null
+++ b/testsuite/driver/src/basic_tools/string.py
@@ -0,0 +1,221 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+def pre_deal(str):
+    str = rm_outermost_quotes(str)
+    str = rm_outermost_double_quotes(str)
+    str = rm_wrap(str)
+    str = rm_outermost_blank(str)
+    return str
+
+
+def rm_outermost_blank(str):
+    return str.strip()
+
+
+def rm_outermost_double_quotes(str):
+    if str.startswith('"') and str.endswith('"'):
+        return str[1:-1]
+    else:
+        return str
+
+
+def rm_outermost_quotes(str):
+    if str.startswith("'") and str.endswith("'"):
+        return str[1:-1]
+    else:
+        return str
+
+
+def rm_wrap(str):
+    if str.endswith('\n'):
+        return str.strip('\n')
+    else:
+        return str
+
+
+def get_char_count(char, str):
+    count = 0
+    for i in str:
+        if i == char:
+            count += 1
+    return count
+
+
+def get_outermost_layer_with_two_symbols(split_symbol1, split_symbol2, str):
+    if split_symbol1 not in str or split_symbol2 not in str:
+        return ""
+    result_str = ""
+    start = 0
+    num = get_char_count(split_symbol2, str)
+    for char in str:
+        if char == split_symbol1:
+            if start == 0:
+                start = 1
+            else:
+                result_str += char
+        elif char == split_symbol2:
+            num -= 1
+            if num > 0 and start == 1:
+                result_str += char
+        else:
+            if num >= 1 and start == 1:
+                result_str += char
+    return result_str
+
+
+def get_outermost_layer_with_one_symbol(split_symbol, str):
+    if split_symbol not in str:
+        return str
+    result_str = ""
+    num = get_char_count(split_symbol, str)
+    start = 0
+    for char in str:
+        if char == split_symbol:
+            num -= 1
+            if start == 0:
+                start = 1
+            else:
+                if num > 0:
+                    result_str += char
+            num -= 1
+        else:
+            if start == 1:
+                result_str += char
+    return result_str
+
+
+def get_string_in_outermost_brackets(str):
+    return get_outermost_layer_with_two_symbols('(', ')', str)
+
+
+def get_string_in_outermost_double_quotes(str):
+    return get_outermost_layer_with_one_symbol('"', str)
+
+
+def split_string_not_in_two_symbols(symbol1, symbol2, split_symbol, str):
+    in_or_not = 0
+    split_list = []
+    tmp = ""
+    for char in str:
+        if char == symbol1:
+            in_or_not += 1
+            tmp += char
+        elif char == symbol2:
+            in_or_not -= 1
+            tmp += char
+        elif char == split_symbol and in_or_not == 0:
+            split_list.append(tmp)
+            tmp = ""
+        else:
+            tmp += char
+    if tmp != "":
+        split_list.append(tmp)
+    return split_list
+
+
+def split_string_not_in_the_same_symbols(symbol, split_symbol, str):
+    in_or_not = 0
+    split_list = []
+    tmp = ""
+    old_char = ""
+    for char in str:
+        if char == symbol and in_or_not == 0:
+            in_or_not = 1
+            tmp += char
+        elif char == symbol and in_or_not == 1:
+            in_or_not = 0
+            tmp += char
+        elif char == split_symbol and old_char != "\\" and in_or_not == 0:
+            split_list.append(tmp)
+            tmp = ""
+        else:
+            tmp += char
+        old_char = char
+    if tmp != "":
+        split_list.append(tmp)
+    return split_list
+
+def split_string_by_comma_not_in_double_quotes(str):
+    return split_string_not_in_the_same_symbols('"', ',', str)
+
+
+def contain_symbol_outside_outermost_two_symbols(symbol, symbol1, symbol2, str):
+    in_or_not = 0
+    for char in str:
+        if char == symbol1:
+            in_or_not += 1
+        elif char == symbol2:
+            in_or_not -= 1
+        elif char == symbol and in_or_not == 0:
+            return True
+        else:
+            continue
+    return False
+
+
+def contain_symbol_outside_outermost_the_same_symbols(symbol, symbol_in, str):
+    in_or_not = 0
+    for char in str:
+        if char == symbol_in and in_or_not == 0:
+            in_or_not = 1
+        elif char == symbol_in and in_or_not == 1:
+            in_or_not = 0
+        elif char == symbol and in_or_not == 0:
+            return True
+        else:
+            continue
+    return False
+
+
+def contain_symbol_outside_outermost_common_symbols(symbol, str):
+    pre_deal(str)
+    result1 = contain_symbol_outside_outermost_the_same_symbols(symbol, '"', str)
+    result2 = contain_symbol_outside_outermost_the_same_symbols(symbol, "'", str)
+    result3 = contain_symbol_outside_outermost_two_symbols(symbol, '(', ')', str)
+    result4 = contain_symbol_outside_outermost_two_symbols(symbol, '[', ']', str)
+    result5 = contain_symbol_outside_outermost_two_symbols(symbol, '{', '}', str)
+    return result1 & result2 & result3 & result4
+
+
+def split_string_by_comma_not_in_bracket_and_quote(String):
+    in_bracket = 0
+    in_double_quote = 0
+    in_single_quote = 0
+    split_list = []
+    tmp = ""
+    old_char = ""
+    for ch in String:
+        if ch == '[' and in_bracket == 0:
+            in_bracket = 1
+        elif ch == ']' and in_bracket == 1:
+            in_bracket = 0
+        elif ch == '"' and in_double_quote == 0:
+            in_double_quote = 1
+        elif ch == '"' and in_double_quote == 1:
+            in_double_quote = 0
+        elif ch == "'" and in_single_quote == 0:
+            in_single_quote = 1
+        elif ch == "'" and in_single_quote == 1:
+            in_single_quote = 0
+        elif ch == ',' and old_char != '\\' and not (in_bracket or in_double_quote or in_single_quote):
+            split_list.append(tmp)
+            old_char = ch
+            tmp = ''
+            continue
+        tmp += ch
+        old_char = ch
+    if tmp != "":
+        split_list.append(tmp)
+    return split_list
\ No newline at end of file
diff --git a/testsuite/driver/src/basic_tools/string_list.py b/testsuite/driver/src/basic_tools/string_list.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6091fa47dd3a78755fc963ca228df24b5098935
--- /dev/null
+++ b/testsuite/driver/src/basic_tools/string_list.py
@@ -0,0 +1,30 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+def rm_wrap(string_list):
+    for index in range(len(string_list)):
+        string_list[index] = string_list[index].strip('\n')
+
+
+def rm_note(string_list):
+    string_list_tmp = string_list
+    for line in string_list_tmp:
+        if line.startswith("#"):
+            string_list.remove(line)
+
+
+def rm_outermost_double_quotes(string_list):
+    for item in range(len(string_list)):
+        if string_list[item].startswith('"') and string_list[item].endswith('"'):
+            string_list[item] = string_list[item][1:-1]
diff --git a/testsuite/driver/src/case/case_executor/clean.py b/testsuite/driver/src/case/case_executor/clean.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa1b53928b03ab8946043bdbe847b07bb95b6c93
--- /dev/null
+++ b/testsuite/driver/src/case/case_executor/clean.py
@@ -0,0 +1,56 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+
+from case.component import Component
+from env_var import EnvVar
+from basic_tools.file import get_sub_files
+
+
+class Clean(Component):
+
+    def __init__(self, input: dict):
+        self.case_name = input["case_name"]
+        self.case_path = os.path.join(EnvVar.TEST_SUITE_ROOT, self.case_name)
+        self.detail = input["detail"]
+
+    def rm_tmp_files(self):
+        all_cur_files = [file for file in os.listdir(self.case_path) if not file.endswith('_tmp@')]
+        if '.raw_file_list.txt' not in all_cur_files:
+            return
+        with open(os.path.join(self.case_path,'.raw_file_list.txt'), 'r') as f:
+            raw_cur_files, raw_sub_files = f.read().split('\n-----\n')
+        tmp_cur_files = list(set(all_cur_files) - set(raw_cur_files.split('\n')))
+        if tmp_cur_files:
+            os.system('rm -rf %s'%(' '.join([os.path.join(self.case_path,f) for f in tmp_cur_files])))
+        all_sub_files = [file for file in get_sub_files(self.case_path) if '_tmp@' not in file]
+        tmp_sub_files = list(set(all_sub_files) - set(raw_sub_files.split('\n')))
+        if tmp_sub_files:
+            os.system('rm -rf %s'%(' '.join([os.path.join(self.case_path,f) for f in tmp_sub_files])))
+        if self.detail and (tmp_cur_files or tmp_sub_files):
+            print("\033[1;32m [[ CMD : rm -rf %s ]]\033[0m"%('  '.join(tmp_cur_files + tmp_sub_files)))
+
+    def rm_tmp_folders(self):
+        del_file_list = [os.path.join(self.case_path,f) for f in os.listdir(self.case_path) if f.endswith("_tmp@")]
+        if self.detail and del_file_list != []:
+            os.system('rm -rf ' + " ".join(del_file_list))
+            print("\033[1;32m [[ CMD : rm -rf %s ]]\033[0m"%('  '.join(del_file_list)))
+
+    def execute(self):
+        self.rm_tmp_files()
+        self.rm_tmp_folders()
+
+    def get_output(self):
+        pass
diff --git a/testsuite/driver/src/case/case_executor/command_executor/python_api.py b/testsuite/driver/src/case/case_executor/command_executor/python_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..49156f55b240e976421b5e6554966c8c0063937b
--- /dev/null
+++ b/testsuite/driver/src/case/case_executor/command_executor/python_api.py
@@ -0,0 +1,27 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from case.component import Component
+
+
+# To be done
+class PythonAPI(Component):
+    def __init__(self):
+        pass
+
+    def execute(self):
+        pass
+
+    def get_output(self):
+        return {}
diff --git a/testsuite/driver/src/case/case_executor/command_executor/shell.py b/testsuite/driver/src/case/case_executor/command_executor/shell.py
new file mode 100644
index 0000000000000000000000000000000000000000..2eafab067784f84cbe2954471c5aae56b5ebba9a
--- /dev/null
+++ b/testsuite/driver/src/case/case_executor/command_executor/shell.py
@@ -0,0 +1,53 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+import locale
+import subprocess
+import signal
+
+from case.component import Component
+
+
+class Shell(Component):
+
+    def __init__(self, command, workdir, timeout):
+        self.command = command
+        self.workdir = workdir
+        self.timeout = timeout
+        self.return_code = None
+        self.com_out = None
+        self.com_err = None
+
+    def execute(self):
+        process_command = subprocess.Popen(self.command, shell=True, cwd=self.workdir, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        try:
+            self.com_out, self.com_err = process_command.communicate(timeout=self.timeout)
+        except subprocess.CalledProcessError as err:
+            self.return_code, self.com_out, self.com_err = err.returncode, "", err
+        except subprocess.TimeoutExpired:
+            self.return_code, self.com_out, self.com_err = 124, "", "timeout"
+        else:
+            self.return_code = process_command.returncode
+            self.com_out = self.com_out.decode(locale.getpreferredencoding(False), errors="ignore").strip()
+            self.com_err = self.com_err.decode(locale.getpreferredencoding(False), errors="ignore").strip()
+        finally:
+            process_command.kill()
+            try:
+                os.killpg(process_command.pid, signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+
+    def get_output(self):
+        return self.com_out, self.com_err, self.return_code
diff --git a/testsuite/driver/src/case/case_executor/generate_shell_script.py b/testsuite/driver/src/case/case_executor/generate_shell_script.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce780bdd00c56b59f5429bd6509fb07160be58c5
--- /dev/null
+++ b/testsuite/driver/src/case/case_executor/generate_shell_script.py
@@ -0,0 +1,45 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+import stat
+
+from case.component import Component
+from env_var import EnvVar
+
+
+class GenerateShellScript(Component):
+
+    def __init__(self, input: dict):
+        self.case_name = input["case_name"]
+        self.case_path = os.path.join(EnvVar.TEST_SUITE_ROOT, self.case_name)
+        self.command_suite = input["command_suite"]
+
+    def execute(self):
+        for mode in self.command_suite.keys():
+            mode_file_path = os.path.join(self.case_path, mode + "_test.sh")
+            with open(mode_file_path, 'w') as f:
+                f.write("#!/bin/bash\nset -e\nset -x\n")
+                f.write("\n".join(self.command_suite[mode]) + "\n")
+            os.chmod(mode_file_path, stat.S_IRWXU)
+
+    def get_output(self):
+        return [{
+            "name": self.case_name,
+            "memory": 0,
+            "cpu": 0.7,
+            "option": mode,
+            "cmd": "cd ${WORKSPACE}/out/host/test/" + self.case_name + ";export OUT_ROOT=${WORKSPACE}/out;bash " + mode + "_test.sh",
+            "timeout": 900
+        } for mode in self.command_suite.keys()]
diff --git a/testsuite/driver/src/case/case_executor/note_src.py b/testsuite/driver/src/case/case_executor/note_src.py
new file mode 100644
index 0000000000000000000000000000000000000000..715f0647fb58c146c70b79e638037890e93fc454
--- /dev/null
+++ b/testsuite/driver/src/case/case_executor/note_src.py
@@ -0,0 +1,38 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+
+from basic_tools.file import get_sub_files
+from env_var import EnvVar
+from case.component import Component
+
+
+class NoteSrc(Component):
+    def __init__(self, input: dict):
+        self.case_name = input["case_name"]
+        self.case_path = os.path.join(EnvVar.TEST_SUITE_ROOT, self.case_name)
+
+    def execute(self):
+        all_cur_files = os.listdir(self.case_path)
+        all_sub_files = [file for file in get_sub_files(self.case_path) if '_tmp@' not in file]
+        if '.raw_file_list.txt' in all_cur_files:
+            return
+        with open(os.path.join(self.case_path, '.raw_file_list.txt'), 'w') as f:
+            f.writelines('\n'.join(all_cur_files))
+            f.writelines('\n-----\n')
+            f.writelines('\n'.join(all_sub_files))
+
+    def get_output(self):
+        pass
diff --git a/testsuite/driver/src/case/case_executor/origin_execute.py b/testsuite/driver/src/case/case_executor/origin_execute.py
new file mode 100644
index 0000000000000000000000000000000000000000..81595625799dbc9f7b35427282bc300570196232
--- /dev/null
+++ b/testsuite/driver/src/case/case_executor/origin_execute.py
@@ -0,0 +1,97 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+import sys
+
+from case.component import Component
+from env_var import EnvVar
+from case.case_executor.command_executor.shell import Shell
+
+
+class OriginExecute(Component):
+
+    def __init__(self, input: dict):
+        self.case_name = input["case_name"]
+        self.command_suite = input["command_suite"]
+        self.detail = input["detail"]
+        self.result_suite = {"PASSED": set(), "FAILED": set(), "TIMEOUT": set()}
+
+    def execute(self):
+        for mode in self.command_suite.keys():
+            case = SingleCaseExecutor(self.case_name, mode, self.command_suite[mode], self.detail)
+            case.execute()
+            result = case.get_result()
+            self.result_suite[result].add(mode)
+
+    def get_output(self):
+        return {self.case_name: self.result_suite}
+
+class SingleCaseExecutor(object):
+
+    def __init__(self, case_name: str, mode: str, command_list: list, detail: bool):
+        self.case_name = case_name
+        self.mode = mode
+        self.command_list = command_list
+        self.detail = detail
+        self.case_path = os.path.join(EnvVar.TEST_SUITE_ROOT, self.case_name)
+        self.result = ""
+
+    def execute(self):
+        passed, passed_in_color = "PASSED", "\033[1;32mPASSED\033[0m"
+        failed, failed_in_color = "FAILED", "\033[1;31mFAILED\033[0m"
+        timeout, timeout_in_color = "TIMEOUT", "\033[1;33mTIMEOUT\033[0m"
+        self.result, result_in_color = passed, passed_in_color
+        if self.detail:
+            for command in self.command_list:
+                print("\033[1;32m[[ CMD : " + command + " ]]\033[0m")
+                exe = Shell(command=command, workdir=self.case_path, timeout=5000)
+                exe.execute()
+                com_out, com_err, return_code = exe.get_output()
+                if com_out is not None and len(com_out) != 0:
+                    print(com_out)
+                if com_err is not None and len(com_err) != 0:
+                    print(com_err)
+                if return_code == 124:
+                    print("ERROR : TIMEOUT !")
+                    self.result, result_in_color = timeout, timeout_in_color
+                    break
+                elif return_code != 0:
+                    print("ERROR : FAILED !")
+                    self.result, result_in_color = failed, failed_in_color
+                    break
+        else:
+            log_file = open(os.path.join(self.case_path, self.mode + "_run.log"), "w+")
+            for command in self.command_list:
+                log_file.write("[[ CMD : " + command + " ]]\n")
+                exe = Shell(command=command, workdir=self.case_path, timeout=5000)
+                exe.execute()
+                com_out, com_err, return_code = exe.get_output()
+                if com_out is not None and len(com_out) != 0:
+                    log_file.write(com_out + "\n")
+                if com_err is not None and len(com_err) != 0:
+                    log_file.write(com_err + "\n")
+                if return_code == 124:
+                    log_file.write("ERROR : TIMEOUT !\n")
+                    self.result, result_in_color = timeout, timeout_in_color
+                    break
+                elif exe.return_code != 0:
+                    log_file.write("ERROR : FAILED !\n")
+                    self.result, result_in_color = failed, failed_in_color
+                    break
+        print(self.case_name + " " + self.mode + " " + result_in_color)
+        sys.stdout.flush()
+
+    def get_result(self):
+        return self.result
diff --git a/testsuite/driver/src/case/case_executor/save_tmp.py b/testsuite/driver/src/case/case_executor/save_tmp.py
new file mode 100644
index 0000000000000000000000000000000000000000..839ca988604f5c182b578b2397b3e972d742cbb7
--- /dev/null
+++ b/testsuite/driver/src/case/case_executor/save_tmp.py
@@ -0,0 +1,40 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+
+from case.component import Component
+from env_var import EnvVar
+
+
+class SaveTmp(Component):
+
+    def __init__(self, input: dict):
+        self.case_name = input["case_name"]
+        self.case_path = os.path.join(EnvVar.TEST_SUITE_ROOT, self.case_name)
+
+    def execute(self):
+        all_cur_files = [file for file in os.listdir(self.case_path) if not file.endswith('_tmp@')]
+        if '.raw_file_list.txt' not in all_cur_files:
+            return
+        tmp_folder = [int(file.split('_tmp@')[0]) for file in os.listdir(self.case_path) if file.endswith('_tmp@')]
+        cur_max_folder = 0
+        if tmp_folder != []:
+            cur_max_folder = max(tmp_folder)
+        os.mkdir(str(cur_max_folder + 1) + '_tmp@')
+        for file in all_cur_files:
+            os.system('cp -r %s %d_tmp@' % (file, cur_max_folder + 1))
+
+    def get_output(self):
+        pass
diff --git a/testsuite/driver/src/case/case_parser/origin_parse.py b/testsuite/driver/src/case/case_parser/origin_parse.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ece6804e3124a792516461979266b2a2ead77b6
--- /dev/null
+++ b/testsuite/driver/src/case/case_parser/origin_parse.py
@@ -0,0 +1,125 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import re
+import os
+
+from basic_tools.file import read_file
+from basic_tools.string_list import *
+from basic_tools.string import split_string_by_comma_not_in_bracket_and_quote, get_string_in_outermost_brackets
+from case.component import Component
+from env_var import EnvVar
+from api.shell import Shell
+from mode import mode_dict
+
+
+class OriginParse(Component):
+
+    def __init__(self, input: dict):
+        self.case_name = input["case_name"]
+        self.mode_set = input["mode_set"]
+        self.case_command_suite = {}
+
+    def execute(self):
+        test_cfg = TestCFG(os.path.join(EnvVar.TEST_SUITE_ROOT, self.case_name, "test.cfg"))
+        test_cfg_content = test_cfg.test_cfg
+        for mode in self.mode_set:
+            case = SingleCaseParser(self.case_name, mode, test_cfg_content)
+            case.parse_case_config()
+            self.case_command_suite[mode] = case.get_command_suite()
+
+    def get_output(self):
+        return self.case_command_suite
+
+
+class SingleCaseParser():
+
+    def __init__(self, case_name: str, mode: str, test_cfg_content: dict):
+        self.case_name = case_name
+        self.mode = mode
+        self.test_cfg_content = test_cfg_content
+        self.command_suite = []
+        self.global_variables = {"CASE": self.case_name, "MODE": self.mode}
+        if EnvVar.MAPLE_BUILD_TYPE is not None:
+            self.global_variables["MAPLE_BUILD_TYPE"] = EnvVar.MAPLE_BUILD_TYPE
+
+    def parse_case_config(self):
+        if self.mode in self.test_cfg_content.keys():
+            mode_cfg_content = self.test_cfg_content[self.mode]
+        else:
+            mode_cfg_content = self.test_cfg_content["default"]
+        for line in mode_cfg_content:
+            if line[0] == "global":
+                self.global_variables.update(line[1])
+            elif line[0] == "shell":
+                self.command_suite.append(Shell(line[1]).get_command(self.global_variables))
+            else:
+                local_variables = line[1]
+                variables = self.global_variables.copy()
+                variables.update(local_variables)
+                phase = line[0]
+                if phase in mode_dict[self.mode].keys():
+                    for command_object in mode_dict[self.mode][phase]:
+                        self.command_suite.append(command_object.get_command(variables))
+                else:
+                    print(line[0] + " not found !")
+                    os._exit(1)
+
+    def get_command_suite(self):
+        return self.command_suite
+
+
+class TestCFG(object):
+
+    mode_phase_pattern = re.compile('^[0-9a-zA-Z_]+$')
+    global_var_pattern = re.compile(r"^[\w]+=[\"\'][-\w/\\=. ]+[\"\']$|^[\w]+=[-\w/\\.]+$")
+
+    def __init__(self, test_cfg_path):
+        self.test_cfg_content = read_file(test_cfg_path)
+        rm_note(self.test_cfg_content)
+        rm_wrap(self.test_cfg_content)
+        self.test_cfg = {"default":[]}
+        self.parse_test_cfg_contest()
+
+    def parse_test_cfg_contest(self):
+        mode_list = ["default"]
+        for line in self.test_cfg_content:
+            if line.endswith(":"):
+                mode_list = line[:-1].split(",")
+                for mode in mode_list:
+                    self.test_cfg[mode] = []
+            else:
+                for mode in mode_list:
+                    if "(" in line and line[-1] == ")" and TestCFG.mode_phase_pattern.match(line.split("(")[0]):
+                        phase = line.split("(")[0]
+                        variable_table = {}
+                        variables_list = split_string_by_comma_not_in_bracket_and_quote(get_string_in_outermost_brackets(line))
+                        for variable in variables_list:
+                            if "=" in variable:
+                                variable_name = variable.split("=")[0]
+                                variable_value = "=".join(variable.split("=")[1:])
+                                if variable_value.startswith('"') and variable_value.endswith('"'):
+                                    variable_value = variable_value[1:-1]
+                                variable_table[variable_name] = variable_value
+                            else:
+                                variable_table["APP"] = variable
+                        self.test_cfg[mode].append((phase, variable_table))
+                    elif TestCFG.global_var_pattern.match(line):
+                        global_variable_name = line.split("=")[0]
+                        global_variable_value = "=".join(line.split("=")[1:])
+                        if global_variable_value.startswith('"') and global_variable_value.endswith('"'):
+                            global_variable_value = global_variable_value[1:-1]
+                        self.test_cfg[mode].append(("global", {global_variable_name: global_variable_value}))
+                    else:
+                        self.test_cfg[mode].append(("shell", line))
diff --git a/testsuite/driver/src/case/case_pipeline/__init__.py b/testsuite/driver/src/case/case_pipeline/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..356c8d4124c070e7ffa2755f76fedee180e9759f
--- /dev/null
+++ b/testsuite/driver/src/case/case_pipeline/__init__.py
@@ -0,0 +1,18 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from case.case_pipeline import origin_run
+from case.case_pipeline import cicd_run
+from case.case_pipeline import clean_run
+from case.case_pipeline import save_tmp_run
diff --git a/testsuite/driver/src/case/case_pipeline/cicd_run.py b/testsuite/driver/src/case/case_pipeline/cicd_run.py
new file mode 100644
index 0000000000000000000000000000000000000000..788d9f10991bc4c7b3a38207e1f6be477cfb9b55
--- /dev/null
+++ b/testsuite/driver/src/case/case_pipeline/cicd_run.py
@@ -0,0 +1,33 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from case.case_executor.clean import Clean
+from case.case_executor.generate_shell_script import GenerateShellScript
+from case.case_parser.origin_parse import OriginParse
+
+
+class CICDRun():
+
+    def __init__(self, input: dict):
+        self.input = input
+
+    def execute(self):
+        clean = Clean(self.input)
+        clean.execute()
+        origin_parse = OriginParse(self.input)
+        origin_parse.execute()
+        self.input["command_suite"] = origin_parse.get_output()
+        generate_shell_script = GenerateShellScript(self.input)
+        generate_shell_script.execute()
+        return generate_shell_script.get_output()
diff --git a/testsuite/driver/src/case/case_pipeline/clean_run.py b/testsuite/driver/src/case/case_pipeline/clean_run.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ac748426f218ea4c3420f073ab63eefa00796cc
--- /dev/null
+++ b/testsuite/driver/src/case/case_pipeline/clean_run.py
@@ -0,0 +1,28 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from case.case_executor.clean import Clean
+
+
+class CleanRun():
+
+    def __init__(self, input: dict):
+        self.input = input
+
+    def execute(self):
+        clean = Clean(self.input)
+        clean.execute()
+
+    def get_output(self):
+        pass
diff --git a/testsuite/driver/src/case/case_pipeline/origin_run.py b/testsuite/driver/src/case/case_pipeline/origin_run.py
new file mode 100644
index 0000000000000000000000000000000000000000..618f1f9fae8e3e1e7b71d0d804c903dc2f42ca34
--- /dev/null
+++ b/testsuite/driver/src/case/case_pipeline/origin_run.py
@@ -0,0 +1,40 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import sys
+
+from case.case_executor.clean import Clean
+from case.case_executor.note_src import NoteSrc
+from case.case_executor.origin_execute import OriginExecute
+from case.case_parser.origin_parse import OriginParse
+
+
+class OriginRun():
+
+    def __init__(self, input: dict):
+        self.input = input
+        self.result_suite = {}
+
+    def execute(self):
+        sys.stdout.flush()
+        clean = Clean(self.input)
+        clean.execute()
+        note_src = NoteSrc(self.input)
+        note_src.execute()
+        origin_parse = OriginParse(self.input)
+        origin_parse.execute()
+        self.input["command_suite"] = origin_parse.get_output()
+        origin_execute = OriginExecute(self.input)
+        origin_execute.execute()
+        return origin_execute.get_output()
diff --git a/testsuite/driver/src/case/case_pipeline/save_tmp_run.py b/testsuite/driver/src/case/case_pipeline/save_tmp_run.py
new file mode 100644
index 0000000000000000000000000000000000000000..d74df2012ce006f069af7e71aa5336650415c3a9
--- /dev/null
+++ b/testsuite/driver/src/case/case_pipeline/save_tmp_run.py
@@ -0,0 +1,28 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from case.case_executor.save_tmp import SaveTmp
+
+
+class SaveTmpRun():
+
+    def __init__(self, input: dict):
+        self.input = input
+
+    def execute(self):
+        save_tmp = SaveTmp(self.input)
+        save_tmp.execute()
+
+    def get_output(self):
+        pass
diff --git a/testsuite/driver/src/case/component.py b/testsuite/driver/src/case/component.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ea412c791ea3ac6a1b3d2ce2f574e6ed0958f40
--- /dev/null
+++ b/testsuite/driver/src/case/component.py
@@ -0,0 +1,26 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from abc import ABCMeta, abstractmethod
+
+
+class Component(metaclass=ABCMeta):
+
+    @abstractmethod
+    def execute(self):
+        pass
+
+    @abstractmethod
+    def get_output(self):
+        pass
diff --git a/testsuite/driver/src/driver.py b/testsuite/driver/src/driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..9278f30fd80af4be43034c4af8fd42f08160953a
--- /dev/null
+++ b/testsuite/driver/src/driver.py
@@ -0,0 +1,95 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+import sys
+import optparse
+
+from env_var import EnvVar
+from pipeline.case_clean import CaseClean
+from pipeline.cicd_run import CICDRun
+from pipeline.local_run import LocalRun
+from pipeline.save_tmp import SaveTmp
+
+init_optparse = optparse.OptionParser()
+env_args = init_optparse.add_option_group("Environment options")
+env_args.add_option('--sdk-root', dest="sdk_root", default=None, help='Sdk location')
+env_args.add_option('--test-suite-root', dest="test_suite_root", default=None, help='Test suite location')
+env_args.add_option('--source-code-root', dest="source_code_root", default=None, help='Source code location')
+
+target_args = init_optparse.add_option_group("Target options")
+target_args.add_option('--target', dest="target", help='Target. It can be a case, a module or a target suite')
+# TODO: Add executor
+target_args.add_option('-j', '--jobs', dest="jobs", type=int, default=1, help='Number of parallel jobs')
+target_args.add_option('--run-path', dest="run_path", default=None, help='Where to run cases')
+target_args.add_option('--mode', dest="mode", default=None, help='Which mode to run')
+target_args.add_option('--detail', dest="detail", action="store_true", default=False, help="show details")
+# TODO: Add phone test
+target_args.add_option('--platform', dest="platform", default="qemu", help='qemu or phone')
+target_args.add_option('--clean', dest="clean", action='store_true', default=False, help='clean the path')
+target_args.add_option('--save', dest="save", action='store_true', default=False, help='save temp files')
+target_args.add_option('--cicd', dest="cicd", action='store_true', default=False, help='cicd use')
+
+
+# TODO: Only Copy dirs to be used
+def prebuild(run_path):
+    if run_path is not None:
+        if os.path.exists(run_path):
+            os.system("rm -rf " + run_path)
+        os.makedirs(run_path)
+        for dir in os.listdir(EnvVar.TEST_SUITE_ROOT):
+            if dir.endswith("_test"):
+                os.system("cp " + os.path.join(EnvVar.TEST_SUITE_ROOT, dir) + "/ " + run_path + '/ -r')
+        EnvVar.TEST_SUITE_ROOT = run_path
+
+
+def main(orig_args):
+    opt, args = init_optparse.parse_args(orig_args)
+    if args:
+        init_optparse.print_usage()
+        sys.exit(1)
+
+    sdk_root = opt.sdk_root
+    test_suite_root = opt.test_suite_root
+    source_code_root = opt.source_code_root
+    run_path = opt.run_path
+    input = {
+        "target": opt.target,
+        "jobs": opt.jobs,
+        "mode": opt.mode,
+        "detail": opt.detail
+    }
+    clean = opt.clean
+    save = opt.save
+    cicd = opt.cicd
+
+    EnvVar(sdk_root, test_suite_root, source_code_root)
+    prebuild(run_path)
+
+    if clean:
+        task = CaseClean(input)
+        task.case_clean_pipeline()
+    elif save:
+        task = SaveTmp(input)
+        task.save_tmp_pipeline()
+    elif cicd:
+        task = CICDRun(input)
+        task.cicd_run_pipeline()
+    else:
+        task = LocalRun(input)
+        task.local_run_pipeline()
+
+
+if __name__ == '__main__':
+    main(sys.argv[1:])
diff --git a/testsuite/driver/src/env_var.py b/testsuite/driver/src/env_var.py
new file mode 100644
index 0000000000000000000000000000000000000000..604f6600dd3eecf655a102591c965f0b99433281
--- /dev/null
+++ b/testsuite/driver/src/env_var.py
@@ -0,0 +1,53 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+import sys
+
+class EnvVar(object):
+
+    SDK_ROOT = None
+    TEST_SUITE_ROOT = None
+    SOURCE_CODE_ROOT = None
+    MAPLE_BUILD_TYPE = None
+    #TODO:Delete
+    CONFIG_FILE_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), "config")
+
+    def __init__(self, sdk_root, test_suite_root, source_code_root):
+        if sdk_root is None:
+            if "OUT_ROOT" in os.environ.keys():
+                EnvVar.SDK_ROOT = os.environ["OUT_ROOT"]
+            else:
+                print("Please source zeiss/envsetup.sh")
+                sys.exit(1)
+        else:
+            EnvVar.SDK_ROOT = sdk_root
+        if test_suite_root is None:
+            if "CASE_ROOT" in os.environ.keys():
+                EnvVar.TEST_SUITE_ROOT = os.environ["CASE_ROOT"]
+            else:
+                print("Please source zeiss/envsetup.sh")
+                sys.exit(1)
+        else:
+            EnvVar.TEST_SUITE_ROOT = test_suite_root
+        if source_code_root is None:
+            if "MAPLE_ROOT" in os.environ.keys():
+                EnvVar.SOURCE_CODE_ROOT = os.environ["MAPLE_ROOT"]
+            else:
+                print("Please source zeiss/envsetup.sh")
+                sys.exit(1)
+        else:
+            EnvVar.SOURCE_CODE_ROOT = source_code_root
+        if "MAPLE_BUILD_TYPE" in os.environ.keys():
+            EnvVar.MAPLE_BUILD_TYPE = os.environ["MAPLE_BUILD_TYPE"]
diff --git a/testsuite/driver/src/mode/ASTO0.py b/testsuite/driver/src/mode/ASTO0.py
new file mode 100644
index 0000000000000000000000000000000000000000..994cb90b7e6c825dfdb0732ae83a955a820d563b
--- /dev/null
+++ b/testsuite/driver/src/mode/ASTO0.py
@@ -0,0 +1,54 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+ASTO0 = {
+    "compile": [
+        C2ast(
+            clang="${OUT_ROOT}/tools/bin/clang",
+            include_path=[
+                "${OUT_ROOT}/aarch64-clang-release/lib/include"
+            ],
+            option="--target=aarch64",
+            infile="${APP}.c",
+            outfile="${APP}.ast"
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            infile="${APP}.ast",
+            outfile="${APP}.mpl"
+        ),
+        SimpleMaple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            option="-O0",
+            infile="${APP}.mpl"
+        ),
+        GenBin(
+            infile="${APP}.s",
+            outfile="${APP}.exe"
+        )
+    ],
+    "run": [
+        Qemu(
+            qemu="qemu-aarch64",
+            infile="${APP}.exe",
+            redirection="output.log"
+        ),
+        CheckFileEqual(
+            file1="output.log",
+            file2="expected.txt"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/ASTO2.py b/testsuite/driver/src/mode/ASTO2.py
new file mode 100644
index 0000000000000000000000000000000000000000..094e8b48715672ad01f8ea26a73608fa40685f83
--- /dev/null
+++ b/testsuite/driver/src/mode/ASTO2.py
@@ -0,0 +1,62 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+ASTO2 = {
+    "compile": [
+        C2ast(
+            clang="${OUT_ROOT}/tools/bin/clang",
+            include_path=[
+                "${OUT_ROOT}/aarch64-clang-release/lib/include"
+            ],
+            option="--target=aarch64",
+            infile="${APP}.c",
+            outfile="${APP}.ast"
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            option="-O2 -func-inline-size 10",
+            infile="${APP}.ast",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            run=["me", "mpl2mpl", "mplcg"],
+            option={
+                "me": "-O2 --quiet",
+                "mpl2mpl": "-O2",
+                "mplcg": "-O2 --fpic --quiet"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        GenBin(
+            infile="${APP}.s",
+            outfile="${APP}.exe"
+        )
+    ],
+    "run": [
+        Qemu(
+            qemu="qemu-aarch64",
+            infile="${APP}.exe",
+            redirection="output.log"
+        ),
+        CheckFileEqual(
+            file1="output.log",
+            file2="expected.txt"
+        )
+    ]
+}
+
diff --git a/testsuite/driver/src/mode/CO0.py b/testsuite/driver/src/mode/CO0.py
new file mode 100644
index 0000000000000000000000000000000000000000..faa45a1f5a0b3c51ab16e90027940197ca3b5420
--- /dev/null
+++ b/testsuite/driver/src/mode/CO0.py
@@ -0,0 +1,61 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+CO0 = {
+    "compile": [
+        C2ast(
+            clang="${OUT_ROOT}/tools/bin/clang",
+            include_path=[
+                "${OUT_ROOT}/${MAPLE_BUILD_TYPE}/lib/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include",
+                "../lib/include"
+            ],
+            option="--target=aarch64 -U __SIZEOF_INT128__",
+            infile="${APP}.c",
+            outfile="${APP}.ast"
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/${MAPLE_BUILD_TYPE}/bin/hir2mpl",
+            infile="${APP}.ast",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/${MAPLE_BUILD_TYPE}/bin/maple",
+            run=["mplcg"],
+            option={
+                "mplcg": "--quiet"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        CLinker(
+            infile="${APP}.s",
+            front_option="",
+            outfile="${APP}.out",
+            back_option="-lm"
+        )
+    ],
+    "run": [
+        Shell(
+            "${OUT_ROOT}/tools/bin/qemu-aarch64 -L ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc ${APP}.out > output.log 2>&1"
+        ),
+	CheckFileEqual(
+	    file1="output.log",
+	    file2="expected.txt"
+	)
+    ]
+}
diff --git a/testsuite/driver/src/mode/CO2.py b/testsuite/driver/src/mode/CO2.py
new file mode 100644
index 0000000000000000000000000000000000000000..d90abd9ad80334e04f3174d4b602129bfc2981e9
--- /dev/null
+++ b/testsuite/driver/src/mode/CO2.py
@@ -0,0 +1,63 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+CO2 = {
+    "compile": [
+        C2ast(
+            clang="${OUT_ROOT}/tools/bin/clang",
+            include_path=[
+                "${OUT_ROOT}/${MAPLE_BUILD_TYPE}/lib/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include",
+                "../lib/include"
+            ],
+            option="--target=aarch64 -U __SIZEOF_INT128__",
+            infile="${APP}.c",
+            outfile="${APP}.ast"
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/${MAPLE_BUILD_TYPE}/bin/hir2mpl",
+            infile="${APP}.ast",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/${MAPLE_BUILD_TYPE}/bin/maple",
+            run=["me", "mpl2mpl", "mplcg"],
+            option={
+                "me": "-O2 --quiet",
+                "mpl2mpl": "-O2",
+                "mplcg": "-O2 --fpic --quiet"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        CLinker(
+            infile="${APP}.s",
+            front_option="",
+            outfile="${APP}.out",
+            back_option="-lm"
+        )
+    ],
+    "run": [
+        Shell(
+            "${OUT_ROOT}/tools/bin/qemu-aarch64 -L ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc ${APP}.out > output.log 2>&1"
+        ),
+        CheckFileEqual(
+            file1="output.log",
+            file2="expected.txt"
+	)
+    ]
+}
diff --git a/testsuite/driver/src/mode/DRIVER.py b/testsuite/driver/src/mode/DRIVER.py
new file mode 100644
index 0000000000000000000000000000000000000000..0743434509b1d88c394f778a42367b8e905ce627
--- /dev/null
+++ b/testsuite/driver/src/mode/DRIVER.py
@@ -0,0 +1,34 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+DRIVER = {
+    "compile": [
+        Driver(
+            maple="${OUT_ROOT}/${MAPLE_BUILD_TYPE}/bin/maple",
+            global_option="${OPTION}",
+            inputs="${APP}"
+        )
+    ],
+    "run": [
+        Shell(
+            "${OUT_ROOT}/tools/bin/qemu-aarch64 -L ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc ${APP}.out > output.log 2>&1"
+        ),
+	CheckFileEqual(
+	    file1="output.log",
+	    file2="expected.txt"
+	)
+    ]
+}
diff --git a/testsuite/driver/src/mode/GC_O0.py b/testsuite/driver/src/mode/GC_O0.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4c3ee6a8ccf68126140cafc230423a7c6dee309
--- /dev/null
+++ b/testsuite/driver/src/mode/GC_O0.py
@@ -0,0 +1,68 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+GC_O0 = {
+    "compile": [
+        Java2dex(
+            jar_file=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party/JAVA_LIBRARIES/core-oj_intermediates/classes.jar",
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party/JAVA_LIBRARIES/core-libart_intermediates/classes.jar"
+            ],
+            outfile="${APP}.dex",
+            infile=["${APP}.java","${EXTRA_JAVA_FILE}"]
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            option="-mplt ${OUT_ROOT}/aarch64-clang-release/libjava-core/host-x86_64-GC_O0/libcore-all.mplt",
+            infile="${APP}.dex",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            run=["me", "mpl2mpl", "mplcg"],
+            option={
+                "me": "--O2 --quiet --gconly",
+                "mpl2mpl": "--O2 --quiet --regnativefunc --no-nativeopt --maplelinker --emitVtableImpl --gconly",
+                "mplcg": "--O2 --quiet --no-pie --fpic --verbose-asm --maplelinker --gconly"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        Linker(
+            lib="host-x86_64-GC_O0",
+        )
+    ],
+    "run": [
+        Mplsh(
+            qemu="${OUT_ROOT}/tools/bin/qemu-aarch64",
+            qemu_libc="/usr/aarch64-linux-gnu",
+            qemu_ld_lib=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party",
+                "${OUT_ROOT}/aarch64-clang-release/ops/host-x86_64-GC_O0",
+                "./"
+            ],
+            mplsh="${OUT_ROOT}/aarch64-clang-release/ops/mplsh",
+            garbage_collection_kind="GC",
+            xbootclasspath="libcore-all.so",
+            infile="${APP}.so",
+            redirection="output.log"
+        ),
+        CheckFileEqual(
+            file1="output.log",
+            file2="expected.txt"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/GC_O2.py b/testsuite/driver/src/mode/GC_O2.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5d01f05d05812f8b8c80a499b943018f764be64
--- /dev/null
+++ b/testsuite/driver/src/mode/GC_O2.py
@@ -0,0 +1,68 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+GC_O2 = {
+    "compile": [
+        Java2dex(
+            jar_file=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party/JAVA_LIBRARIES/core-oj_intermediates/classes.jar",
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party/JAVA_LIBRARIES/core-libart_intermediates/classes.jar"
+            ],
+            outfile="${APP}.dex",
+            infile=["${APP}.java","${EXTRA_JAVA_FILE}"]
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            option="-mplt ${OUT_ROOT}/aarch64-clang-release/libjava-core/host-x86_64-GC_O2/libcore-all.mplt",
+            infile="${APP}.dex",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            run=["me", "mpl2mpl", "mplcg"],
+            option={
+                "me": "--O2 --quiet --gconly",
+                "mpl2mpl": "--O2 --quiet --regnativefunc --no-nativeopt --maplelinker --emitVtableImpl --gconly",
+                "mplcg": "--O2 --quiet --no-pie --fpic --verbose-asm --maplelinker --gconly"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        Linker(
+            lib="host-x86_64-GC_O2",
+        )
+    ],
+    "run": [
+        Mplsh(
+            qemu="${OUT_ROOT}/tools/bin/qemu-aarch64",
+            qemu_libc="/usr/aarch64-linux-gnu",
+            qemu_ld_lib=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party",
+                "${OUT_ROOT}/aarch64-clang-release/ops/host-x86_64-GC_O2",
+                "./"
+            ],
+            mplsh="${OUT_ROOT}/aarch64-clang-release/ops/mplsh",
+            garbage_collection_kind="GC",
+            xbootclasspath="libcore-all.so",
+            infile="${APP}.so",
+            redirection="output.log"
+        ),
+        CheckFileEqual(
+            file1="output.log",
+            file2="expected.txt"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/IR.py b/testsuite/driver/src/mode/IR.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe7cbe3bc50cad61ecaad7b9ed5a648ce99e4606
--- /dev/null
+++ b/testsuite/driver/src/mode/IR.py
@@ -0,0 +1,32 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+IR = {
+    "compile": [
+        Irbuild(
+            irbuild="${OUT_ROOT}/${MAPLE_BUILD_TYPE}/bin/irbuild",
+            infile="${APP}.mpl"
+        ),
+        Irbuild(
+            irbuild="${OUT_ROOT}/${MAPLE_BUILD_TYPE}/bin/irbuild",
+            infile="${APP}.irb.mpl"
+        ),
+        CheckFileEqual(
+            file1="${APP}.irb.mpl",
+            file2="${APP}.irb.irb.mpl"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/O0.py b/testsuite/driver/src/mode/O0.py
new file mode 100644
index 0000000000000000000000000000000000000000..220b48c05dec58aed674a61a196728485b25135e
--- /dev/null
+++ b/testsuite/driver/src/mode/O0.py
@@ -0,0 +1,123 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+O0 = {
+    "compile": [
+        Java2dex(
+            jar_file=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party/JAVA_LIBRARIES/core-oj_intermediates/classes.jar",
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party/JAVA_LIBRARIES/core-libart_intermediates/classes.jar"
+            ],
+            outfile="${APP}.dex",
+            infile=["${APP}.java","${EXTRA_JAVA_FILE}"]
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            option="-mplt ${OUT_ROOT}/aarch64-clang-release/libjava-core/host-x86_64-O0/libcore-all.mplt --rc",
+            infile="${APP}.dex",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            run=["me", "mpl2mpl", "mplcg"],
+            option={
+                "me": "--quiet",
+                "mpl2mpl": "--quiet --regnativefunc --maplelinker --emitVtableImpl",
+                "mplcg": "--quiet --no-pie --fpic --verbose-asm --maplelinker"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        Linker(
+            lib="host-x86_64-O0",
+        )
+    ],
+    "run": [
+        Mplsh(
+            env={
+                "USE_OLD_STACK_SCAN": "1"
+            },
+            qemu="${OUT_ROOT}/tools/bin/qemu-aarch64",
+            qemu_libc="/usr/aarch64-linux-gnu",
+            qemu_ld_lib=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party",
+                "${OUT_ROOT}/aarch64-clang-release/ops/host-x86_64-O0",
+                "./"
+            ],
+            mplsh="${OUT_ROOT}/aarch64-clang-release/ops/mplsh",
+            garbage_collection_kind="RC",
+            xbootclasspath="libcore-all.so",
+            infile="${APP}.so",
+            redirection="output.log"
+        ),
+        CheckFileEqual(
+            file1="output.log",
+            file2="expected.txt"
+        ),
+        Mplsh(
+            env={
+            	"USE_OLD_STACK_SCAN": "1",
+                "MAPLE_REPORT_RC_LEAK": "1"
+            },
+            qemu="${OUT_ROOT}/tools/bin/qemu-aarch64",
+            qemu_libc="/usr/aarch64-linux-gnu",
+            qemu_ld_lib=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party",
+                "${OUT_ROOT}/aarch64-clang-release/ops/host-x86_64-O0",
+                "./"
+            ],
+            mplsh="${OUT_ROOT}/aarch64-clang-release/ops/mplsh",
+            garbage_collection_kind="RC",
+            xbootclasspath="libcore-all.so",
+            infile="${APP}.so",
+            redirection="leak.log"
+        ),
+        CheckRegContain(
+            reg="Total none-cycle root objects 0",
+            file="leak.log"
+        ),
+        Mplsh(
+            env={
+            	"USE_OLD_STACK_SCAN": "1",
+                "MAPLE_VERIFY_RC": "1"
+            },
+            qemu="${OUT_ROOT}/tools/bin/qemu-aarch64",
+            qemu_libc="/usr/aarch64-linux-gnu",
+            qemu_ld_lib=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party",
+                "${OUT_ROOT}/aarch64-clang-release/ops/host-x86_64-O0",
+                "./"
+            ],
+            mplsh="${OUT_ROOT}/aarch64-clang-release/ops/mplsh",
+            garbage_collection_kind="RC",
+            xbootclasspath="libcore-all.so",
+            infile="${APP}.so",
+            redirection="rcverify.log"
+        ),
+        CheckRegContain(
+            reg="[MS] [RC Verify] total 0 objects potential early release",
+            file="rcverify.log"
+        ),
+        CheckRegContain(
+            reg="[MS] [RC Verify] total 0 objects potential leak",
+            file="rcverify.log"
+        ),
+        CheckRegContain(
+            reg="[MS] [RC Verify] total 0 objects weak rc are wrong",
+            file="rcverify.log"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/O2.py b/testsuite/driver/src/mode/O2.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cad688be4b818537b10c2c340a809ecf9b01f6f
--- /dev/null
+++ b/testsuite/driver/src/mode/O2.py
@@ -0,0 +1,118 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+O2 = {
+    "compile": [
+        Java2dex(
+            jar_file=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party/JAVA_LIBRARIES/core-oj_intermediates/classes.jar",
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party/JAVA_LIBRARIES/core-libart_intermediates/classes.jar"
+            ],
+            outfile="${APP}.dex",
+            infile=["${APP}.java","${EXTRA_JAVA_FILE}"]
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            option="-mplt ${OUT_ROOT}/aarch64-clang-release/libjava-core/host-x86_64-O2/libcore-all.mplt --rc",
+            infile="${APP}.dex",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            run=["me", "mpl2mpl", "mplcg"],
+            option={
+                "me": "--O2 --quiet",
+                "mpl2mpl": "--O2 --quiet --regnativefunc --no-nativeopt --maplelinker --emitVtableImpl",
+                "mplcg": "--O2 --quiet --no-pie --fpic --verbose-asm --maplelinker"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        Linker(
+            lib="host-x86_64-O2",
+        )
+    ],
+    "run": [
+        Mplsh(
+            qemu="${OUT_ROOT}/tools/bin/qemu-aarch64",
+            qemu_libc="/usr/aarch64-linux-gnu",
+            qemu_ld_lib=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party",
+                "${OUT_ROOT}/aarch64-clang-release/ops/host-x86_64-O2",
+                "./"
+            ],
+            mplsh="${OUT_ROOT}/aarch64-clang-release/ops/mplsh",
+            garbage_collection_kind="RC",
+            xbootclasspath="libcore-all.so",
+            infile="${APP}.so",
+            redirection="output.log"
+        ),
+        CheckFileEqual(
+            file1="output.log",
+            file2="expected.txt"
+        ),
+        Mplsh(
+            env={
+                "MAPLE_REPORT_RC_LEAK": "1"
+            },
+            qemu="${OUT_ROOT}/tools/bin/qemu-aarch64",
+            qemu_libc="/usr/aarch64-linux-gnu",
+            qemu_ld_lib=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party",
+                "${OUT_ROOT}/aarch64-clang-release/ops/host-x86_64-O2",
+                "./"
+            ],
+            mplsh="${OUT_ROOT}/aarch64-clang-release/ops/mplsh",
+            garbage_collection_kind="RC",
+            xbootclasspath="libcore-all.so",
+            infile="${APP}.so",
+            redirection="leak.log"
+        ),
+        CheckRegContain(
+            reg="Total none-cycle root objects 0",
+            file="leak.log"
+        ),
+        Mplsh(
+            env={
+                "MAPLE_VERIFY_RC": "1"
+            },
+            qemu="${OUT_ROOT}/tools/bin/qemu-aarch64",
+            qemu_libc="/usr/aarch64-linux-gnu",
+            qemu_ld_lib=[
+                "${OUT_ROOT}/aarch64-clang-release/ops/third_party",
+                "${OUT_ROOT}/aarch64-clang-release/ops/host-x86_64-O2",
+                "./"
+            ],
+            mplsh="${OUT_ROOT}/aarch64-clang-release/ops/mplsh",
+            garbage_collection_kind="RC",
+            xbootclasspath="libcore-all.so",
+            infile="${APP}.so",
+            redirection="rcverify.log"
+        ),
+        CheckRegContain(
+            reg="[MS] [RC Verify] total 0 objects potential early release",
+            file="rcverify.log"
+        ),
+        CheckRegContain(
+            reg="[MS] [RC Verify] total 0 objects potential leak",
+            file="rcverify.log"
+        ),
+        CheckRegContain(
+            reg="[MS] [RC Verify] total 0 objects weak rc are wrong",
+            file="rcverify.log"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/SCO0_TEST.py b/testsuite/driver/src/mode/SCO0_TEST.py
new file mode 100644
index 0000000000000000000000000000000000000000..65cd3a4d5cb930cd2f2415fa5d9cb7a377940769
--- /dev/null
+++ b/testsuite/driver/src/mode/SCO0_TEST.py
@@ -0,0 +1,78 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+
+SCO0_TEST = {
+    "compile": [
+        C2ast(
+            clang="${OUT_ROOT}/tools/bin/clang",
+            include_path=[
+                "${OUT_ROOT}/aarch64-clang-release/lib/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include"
+            ],
+            option="--target=aarch64",
+            infile="${APP}.c",
+            outfile="${APP}.ast",
+            extra_opt="${SPEC_PARAM}"
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            infile="${APP}.ast",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            run=["mplcg"],
+            option={
+                "mplcg": "--O0 --patch-long-branch --quiet --no-pie --fpic --verbose-asm"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        CLinker(
+            infile="${APP}.s",
+            front_option="-O2 -std=c99",
+            outfile="${APP}.o",
+            back_option="",
+            mid_opt="-c"
+        )
+    ],
+    "link": [
+        CLinker(
+            infile="${APP}",
+            front_option="-std=gnu99 -no-pie",
+            outfile="${EXE}",
+            back_option="-lm -L${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/lib/",
+            mid_opt="${MID_OPT}"
+        )
+    ],
+    "cp_data":[
+        Shell(
+            "cp -r data/test/${APP} ${TARGET}"
+        )
+    ],
+    "run": [
+        Shell(
+            "${OUT_ROOT}/tools/bin/qemu-aarch64 -L ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc ${EXE} ${APP} > output.log"
+        )
+    ],
+    "compare": [
+        Shell(
+            "${MAPLE_ROOT}/testsuite/c_test/spec_test/specperl ${MAPLE_ROOT}/testsuite/c_test/spec_test/specdiff -m -l 10 ${EXTRA_COMPARE} output.log data/test/${APP}"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/SCO0_TRAIN.py b/testsuite/driver/src/mode/SCO0_TRAIN.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1fb051bc888b8052bc5673f5076cd730d217862
--- /dev/null
+++ b/testsuite/driver/src/mode/SCO0_TRAIN.py
@@ -0,0 +1,77 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+
+SCO0_TRAIN = {
+    "compile": [
+        C2ast(
+            clang="${OUT_ROOT}/tools/bin/clang",
+            include_path=[
+                "${OUT_ROOT}/aarch64-clang-release/lib/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include"
+            ],
+            option="--target=aarch64",
+            infile="${APP}.c",
+            outfile="${APP}.ast",
+            extra_opt="${SPEC_PARAM}"
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            infile="${APP}.ast",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            run=["mplcg"],
+            option={
+                "mplcg": "--O0 --patch-long-branch --quiet --no-pie --fpic --verbose-asm"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        CLinker(
+            infile="${APP}.s",
+            front_option="-O2 -std=c99",
+            outfile="${APP}.o",
+            back_option="",
+            mid_opt="-c"
+        )
+    ],
+    "link": [
+        CLinker(
+            infile="${APP}",
+            front_option="-std=gnu99 -no-pie",
+            outfile="${EXE}",
+            back_option="-lm -L${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/lib/"
+        )
+    ],
+    "cp_data":[
+        Shell(
+            "cp -r data/train/${APP} ${TARGET}"
+        )
+    ],
+    "run": [
+        Shell(
+            "${OUT_ROOT}/tools/bin/qemu-aarch64 -L ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc ${EXE} ${APP} > output.log"
+        )
+    ],
+    "compare": [
+        Shell(
+            "${MAPLE_ROOT}/testsuite/c_test/spec_test/specperl ${MAPLE_ROOT}/testsuite/c_test/spec_test/specdiff -m -l 10 ${EXTRA_COMPARE} output.log data/train/${APP}"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/SCO2_TEST.py b/testsuite/driver/src/mode/SCO2_TEST.py
new file mode 100644
index 0000000000000000000000000000000000000000..eabf287dbb75a70ee3e23c0d6155e3ec221e4aee
--- /dev/null
+++ b/testsuite/driver/src/mode/SCO2_TEST.py
@@ -0,0 +1,79 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+
+SCO2_TEST = {
+    "compile": [
+        C2ast(
+            clang="${OUT_ROOT}/tools/bin/clang",
+            include_path=[
+                "${OUT_ROOT}/aarch64-clang-release/lib/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include"
+            ],
+            option="--target=aarch64",
+            infile="${APP}.c",
+            outfile="${APP}.ast",
+            extra_opt="${SPEC_PARAM}"
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            infile="${APP}.ast",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            run=["me", "mpl2mpl", "mplcg"],
+            option={
+                "me": "-O2 --quiet",
+                "mpl2mpl": "-O2 --quiet",
+                "mplcg": "--O2 --fpic --quiet --no-pie --verbose-asm"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        CLinker(
+            infile="${APP}.s",
+            front_option="-O2 -std=c99",
+            outfile="${APP}.o",
+            back_option="",
+            mid_opt="-c"
+        )
+    ],
+    "link": [
+        CLinker(
+            infile="${APP}",
+            front_option="-std=gnu99 -no-pie",
+            outfile="${EXE}",
+            back_option="-lm -L${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/lib/"
+        )
+    ],
+    "cp_data":[
+        Shell(
+            "cp -r data/test/${APP} ${TARGET}"
+        )
+    ],
+    "run": [
+        Shell(
+            "${OUT_ROOT}/tools/bin/qemu-aarch64 -L ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc ${EXE} ${APP} > output.log"
+        )
+    ],
+    "compare": [
+        Shell(
+            "${MAPLE_ROOT}/testsuite/c_test/spec_test/specperl ${MAPLE_ROOT}/testsuite/c_test/spec_test/specdiff -m -l 10 ${EXTRA_COMPARE} output.log data/test/${APP}"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/SCO2_TRAIN.py b/testsuite/driver/src/mode/SCO2_TRAIN.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bc1519f3439dda591a8278205d90d2956fe1d1e
--- /dev/null
+++ b/testsuite/driver/src/mode/SCO2_TRAIN.py
@@ -0,0 +1,79 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+
+SCO2_TRAIN = {
+    "compile": [
+        C2ast(
+            clang="${OUT_ROOT}/tools/bin/clang",
+            include_path=[
+                "${OUT_ROOT}/aarch64-clang-release/lib/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/usr/include",
+                "${OUT_ROOT}/tools/gcc-linaro-7.5.0/lib/gcc/aarch64-linux-gnu/7.5.0/include"
+            ],
+            option="--target=aarch64",
+            infile="${APP}.c",
+            outfile="${APP}.ast",
+            extra_opt="${SPEC_PARAM}"
+        ),
+        Hir2mpl(
+            hir2mpl="${OUT_ROOT}/aarch64-clang-release/bin/hir2mpl",
+            infile="${APP}.ast",
+            outfile="${APP}.mpl"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/aarch64-clang-release/bin/maple",
+            run=["me", "mpl2mpl", "mplcg"],
+            option={
+                "me": "-O2 --quiet",
+                "mpl2mpl": "-O2 --quiet",
+                "mplcg": "--O2 --fpic --quiet --no-pie --verbose-asm"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        CLinker(
+            infile="${APP}.s",
+            front_option="-O2 -std=c99",
+            outfile="${APP}.o",
+            back_option="",
+            mid_opt="-c"
+        )
+    ],
+    "link": [
+        CLinker(
+            infile="${APP}",
+            front_option="-std=gnu99 -no-pie",
+            outfile="${EXE}",
+            back_option="-lm -L${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/lib/"
+        )
+    ],
+    "cp_data":[
+        Shell(
+            "cp -r data/train/${APP} ${TARGET}"
+        )
+    ],
+    "run": [
+        Shell(
+            "${OUT_ROOT}/tools/bin/qemu-aarch64 -L ${OUT_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc ${EXE} ${APP} > output.log"
+        )
+    ],
+    "compare": [
+        Shell(
+            "${MAPLE_ROOT}/testsuite/c_test/spec_test/specperl ${MAPLE_ROOT}/testsuite/c_test/spec_test/specdiff -m -l 10 ${EXTRA_COMPARE} output.log data/train/${APP}"
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode/__init__.py b/testsuite/driver/src/mode/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4784970c2c08e3d28962337eb9eed451c6d888ac
--- /dev/null
+++ b/testsuite/driver/src/mode/__init__.py
@@ -0,0 +1,26 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+
+mode_dict = {}
+my_dir = os.path.dirname(__file__)
+for py in os.listdir(my_dir):
+    if py == '__init__.py':
+        continue
+
+    if py.endswith('.py'):
+        name = py[:-3]
+        mode = __import__(__name__, globals(), locals(), ['%s' % name])
+        mode_dict[name] = getattr(getattr(mode, name), name)
\ No newline at end of file
diff --git a/testsuite/driver/src/mode_old/CO0_OLD.py b/testsuite/driver/src/mode_old/CO0_OLD.py
new file mode 100644
index 0000000000000000000000000000000000000000..15f73ea21dd2d1e9ad65093c74c8c368e439b3ee
--- /dev/null
+++ b/testsuite/driver/src/mode_old/CO0_OLD.py
@@ -0,0 +1,56 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+CO0 = {
+    "clean": [
+        Shell(
+            "rm -rf *.mpl *.s *.out *.B *.log"
+        )
+    ],
+    "compile": [
+        Clang2mpl(
+            infile="${APP}.c"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/${MAPLE_BUILD_TYPE}/bin/maple",
+            run=["mplcg"],
+            option={
+                "mplcg": "--quiet"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        CLinker(
+            infile="${APP}.s",
+            front_option="",
+            outfile="${APP}.out",
+            back_option="-lm"
+        )
+    ],
+    "run": [
+        QemuRun(
+            qemu_libc=[
+                "${MAPLE_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc"
+            ],
+            infile="${APP}.out",
+            redirection="output.log"
+        ),
+        CheckFileEqual(
+            file1="output.log",
+            file2="expected.txt"         
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode_old/CO2_OLD.py b/testsuite/driver/src/mode_old/CO2_OLD.py
new file mode 100644
index 0000000000000000000000000000000000000000..325e3f582c27d52438448a41969ac983330a345d
--- /dev/null
+++ b/testsuite/driver/src/mode_old/CO2_OLD.py
@@ -0,0 +1,56 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from api import *
+
+CO2 = {
+    "clean": [
+        Shell(
+            "rm -rf *.mpl *.s *.out *.B"
+        )
+    ],
+    "compile": [
+        Clang2mpl(
+            infile="${APP}.c"
+        ),
+        Maple(
+            maple="${OUT_ROOT}/${MAPLE_BUILD_TYPE}/bin/maple",
+            run=["mplcg"],
+            option={
+                "mplcg": "-O2 --quiet"
+            },
+            global_option="",
+            infile="${APP}.mpl"
+        ),
+        CLinker(
+            infile="${APP}.s",
+            front_option="",
+            outfile="${APP}.out",
+            back_option="-lm"
+        )
+    ],
+    "run": [
+        QemuRun(
+            qemu_libc=[
+                "${MAPLE_ROOT}/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc"                            
+            ],
+            infile="${APP}.out",
+            redirection="output.log"                                
+        ),
+        CheckFileEqual(
+            file1="output.log",
+            file2="expected.txt"                                         
+        )
+    ]
+}
diff --git a/testsuite/driver/src/mode_table.py b/testsuite/driver/src/mode_table.py
new file mode 100644
index 0000000000000000000000000000000000000000..879c96fff61b1132eaef9dd90c296ae5855d14bc
--- /dev/null
+++ b/testsuite/driver/src/mode_table.py
@@ -0,0 +1,72 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+
+from basic_tools.file import read_file
+
+class ModeTable(object):
+
+    def __init__(self, table_file):
+        global key
+        mode_table_content_tmp = read_file(table_file)
+        self.mode_table_content = {}
+        for line in mode_table_content_tmp:
+            line = line.replace(" ", "")
+            if line == "" or line.startswith("#"):
+                continue
+            elif line.startswith("["):
+                key = line.split("[")[1].split("]")[0]
+                self.mode_table_content[key] = {}
+            elif line.endswith(":all"):
+                target = line.split(":")[0]
+                self.mode_table_content[key][target] = {"all"}
+            else:
+                target = line.split(":")[0]
+                mode_set = set(line.split(":")[1].split(","))
+                if target in self.mode_table_content[key].keys():
+                    self.mode_table_content[key][target] = self.mode_table_content[key][target].union(mode_set)
+                else:
+                    self.mode_table_content[key][target] = mode_set
+        self.mode_table = {}
+        self._parse()
+
+    def _parse(self):
+        self.mode_table = self.mode_table_content["DEFAULT_TEST_SUITE"]
+        if "MODE_SET" in self.mode_table_content.keys():
+            for options in self.mode_table_content["MODE_SET"].keys():
+                for target in self.mode_table.keys():
+                    if options in self.mode_table[target]:
+                        self.mode_table[target].remove(options)
+                        self.mode_table[target] = self.mode_table[target].union(self.mode_table_content["MODE_SET"][options])
+        if "BAN_TEST_SUITE" in self.mode_table_content.keys():
+            for target in self.mode_table_content["BAN_TEST_SUITE"].keys():
+                if "all" in self.mode_table_content["BAN_TEST_SUITE"][target]:
+                    self.mode_table[target] = set()
+                    continue
+                father_target = target
+                while father_target not in self.mode_table.keys():
+                    father_target = os.path.dirname(father_target)
+                self.mode_table[target] = self.mode_table[father_target] - self.mode_table_content["BAN_TEST_SUITE"][target]
+
+    def get_case_mode_set(self, case):
+        target = case
+        while target not in self.mode_table.keys() and len(target) != 0:
+            target = os.path.dirname(target)
+            if len(target) == 0:
+                return set()
+        return self.mode_table[target]
+
+    def get_targets(self):
+        return self.mode_table.keys()
\ No newline at end of file
diff --git a/testsuite/driver/src/pipeline/__init__.py b/testsuite/driver/src/pipeline/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..62a921895d3bf3adbd83108402d35b90fcb7c6ca
--- /dev/null
+++ b/testsuite/driver/src/pipeline/__init__.py
@@ -0,0 +1,4 @@
+from pipeline import case_clean
+from pipeline import cicd_run
+from pipeline import local_run
+from pipeline import save_tmp
\ No newline at end of file
diff --git a/testsuite/driver/src/pipeline/case_clean.py b/testsuite/driver/src/pipeline/case_clean.py
new file mode 100644
index 0000000000000000000000000000000000000000..5df35773000612d557d38ad6ff5714d3f3d5f8bb
--- /dev/null
+++ b/testsuite/driver/src/pipeline/case_clean.py
@@ -0,0 +1,30 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import sys
+
+from case import case_pipeline
+
+
+class CaseClean(object):
+
+    def __init__(self, input):
+        self.input = input
+
+    def case_clean_pipeline(self):
+        self.input["case_name"] = self.input["target"]
+        case_clean = case_pipeline.clean_run.CleanRun(self.input)
+        case_clean.execute()
+        sys.exit(0)
+
diff --git a/testsuite/driver/src/pipeline/cicd_run.py b/testsuite/driver/src/pipeline/cicd_run.py
new file mode 100644
index 0000000000000000000000000000000000000000..933643e64b4d4113e45fc373da17a8e9ed65d04b
--- /dev/null
+++ b/testsuite/driver/src/pipeline/cicd_run.py
@@ -0,0 +1,58 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import json
+import time
+
+import target_parser
+from case import case_pipeline
+from multiprocessing import Pool, cpu_count
+
+from env_var import EnvVar
+
+
+class CICDRun(object):
+
+    def __init__(self, input):
+        self.input = input
+
+    def cicd_run_pipeline(self):
+        results = []
+        target_parse = target_parser.common_parse.CommonParse(self.input)
+        target_parse.execute()
+        cases = target_parse.get_output()
+        pool = Pool(min(cpu_count(), self.input["jobs"]))
+        return_results = []
+        for case_name in cases.keys():
+            self.input["case_name"] = case_name
+            self.input["mode_set"] = cases[case_name]
+            case_run = case_pipeline.cicd_run.CICDRun(self.input.copy())
+            return_results.append(pool.apply_async(case_run.execute, ()))
+        finished = 0
+        total = len(cases)
+        while total != finished:
+            time.sleep(1)
+            finished = sum([return_result.ready() for return_result in return_results])
+        for return_result in return_results:
+            results += return_result.get()
+        pool.close()
+        pool.join()
+        package = {
+            "container_image": "cpl-eqm-docker-sh.rnd.huawei.com/valoran-run:0.6",
+            "case_retry_num": 4,
+            "total_retry_num": 1000,
+            "tasks": results
+        }
+        with open(EnvVar.SOURCE_CODE_ROOT + "/json.txt", "wt") as f:
+            json.dump(package, f)
diff --git a/testsuite/driver/src/pipeline/local_run.py b/testsuite/driver/src/pipeline/local_run.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2bb060d3a744973637f43706e7286ae2b70b048
--- /dev/null
+++ b/testsuite/driver/src/pipeline/local_run.py
@@ -0,0 +1,72 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import sys
+import time
+
+import target_parser
+import result_parser
+from case import case_pipeline
+from multiprocessing import Pool, cpu_count
+
+
+class LocalRun(object):
+
+    def __init__(self, input):
+        self.input = input
+
+    def local_run_pipeline(self):
+        results = {}
+        target_parse = target_parser.common_parse.CommonParse(self.input)
+        target_parse.execute()
+        cases = target_parse.get_output()
+        pool = Pool(min(cpu_count(), self.input["jobs"]))
+        return_results = []
+        for case_name in cases.keys():
+            self.input["case_name"] = case_name
+            self.input["mode_set"] = cases[case_name]
+            case_run = case_pipeline.origin_run.OriginRun(self.input.copy())
+            return_results.append(pool.apply_async(case_run.execute, ()))
+        finished = 0
+        total = len(cases)
+        while total != finished:
+            time.sleep(1)
+            finished = sum([return_result.ready() for return_result in return_results])
+        for return_result in return_results:
+            results.update(return_result.get())
+        pool.close()
+        pool.join()
+        result_parse = result_parser.origin_parse.OriginParse(results)
+        result_parse.result_parse()
+        result_parse.gen_report()
+        result_parse.print_report()
+        if result_parse.all_pass() is False and result_parse.all_failed_num + result_parse.all_timeout_num <= 20:
+            print("================ Test Again =================")
+            again_suite = result_parse.get_again_suite()
+            print(again_suite)
+            results = {}
+            for case_name in again_suite.keys():
+                self.input["case_name"] = case_name
+                self.input["mode_set"] = again_suite[case_name]
+                self.input["detail"] = True
+                case_run = case_pipeline.origin_run.OriginRun(self.input.copy())
+                results.update(case_run.execute())
+            result_parse = result_parser.origin_parse.OriginParse(results)
+            result_parse.result_parse()
+            result_parse.gen_report()
+            result_parse.print_report()
+            result_parse.write_report()
+            if not result_parse.all_pass():
+                sys.exit(1)
+
diff --git a/testsuite/driver/src/pipeline/save_tmp.py b/testsuite/driver/src/pipeline/save_tmp.py
new file mode 100644
index 0000000000000000000000000000000000000000..181994785e06e3019127bef00ec85155cd6bb660
--- /dev/null
+++ b/testsuite/driver/src/pipeline/save_tmp.py
@@ -0,0 +1,30 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import sys
+
+from case import case_pipeline
+
+
+class SaveTmp(object):
+
+    def __init__(self, input):
+        self.input = input
+
+    def save_tmp_pipeline(self):
+        self.input["case_name"] = self.input["target"]
+        save_tmp = case_pipeline.save_tmp_run.SaveTmpRun(self.input)
+        save_tmp.execute()
+        sys.exit(0)
+
diff --git a/testsuite/driver/src/result_parser/__init__.py b/testsuite/driver/src/result_parser/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..481c64a2754e6dbf022d045c2770ff1c280d84b7
--- /dev/null
+++ b/testsuite/driver/src/result_parser/__init__.py
@@ -0,0 +1,15 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from result_parser import origin_parse
diff --git a/testsuite/driver/src/result_parser/origin_parse.py b/testsuite/driver/src/result_parser/origin_parse.py
new file mode 100644
index 0000000000000000000000000000000000000000..13c7e4cef8f57645ae7e7975f4e691da05971ea5
--- /dev/null
+++ b/testsuite/driver/src/result_parser/origin_parse.py
@@ -0,0 +1,79 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from env_var import EnvVar
+
+
+class OriginParse(object):
+
+    def __init__(self, results: dict):
+        self.results = results
+        self.report = []
+        self.all_passed_num = 0
+        self.all_failed_num = 0
+        self.all_timeout_num = 0
+        self.failed_suite = {}
+        self.timeout_suite = {}
+
+    def result_parse(self):
+        for case_name in self.results.keys():
+            passed_num = len(self.results[case_name]["PASSED"])
+            failed_num = len(self.results[case_name]["FAILED"])
+            timeout_num = len(self.results[case_name]["TIMEOUT"])
+            self.all_passed_num += passed_num
+            self.all_failed_num += failed_num
+            self.all_timeout_num += timeout_num
+            if failed_num != 0:
+                self.failed_suite[case_name] = self.results[case_name]["FAILED"]
+            if timeout_num != 0:
+                self.timeout_suite[case_name] = self.results[case_name]["TIMEOUT"]
+
+    def gen_report(self):
+        if self.all_failed_num == 0 and self.all_timeout_num == 0:
+            self.report.append("============ ALL CASE RUN SUCCESSFULLY ================")
+            return
+        self.report.append("=========== case total num : " + str(
+            self.all_passed_num + self.all_failed_num + self.all_timeout_num) + "  passed num : " + str(
+            self.all_passed_num) + "  failed num : " + str(self.all_failed_num) + "  timeout num : " + str(
+            self.all_timeout_num) + " ================\n\n")
+        if self.all_failed_num != 0:
+            self.report.append("failed case list:\n")
+            for case_name in self.failed_suite:
+                self.report.append(case_name + ": " + ",".join(self.failed_suite[case_name]))
+        if self.all_timeout_num != 0:
+            self.report.append("timeout case list:\n")
+            for case_name in self.timeout_suite:
+                self.report.append(case_name + ": " + ",".join(self.timeout_suite[case_name]))
+
+    def print_report(self):
+        for line in self.report:
+            print(line)
+
+    def write_report(self):
+        with open(EnvVar.SOURCE_CODE_ROOT + "/report.txt", "wt") as f:
+            for line in self.report:
+                f.write(line)
+
+    def all_pass(self):
+        return self.all_failed_num == 0 and self.all_timeout_num == 0
+
+    def get_again_suite(self):
+        again_suite = self.failed_suite
+        for case_name in self.timeout_suite.keys():
+            if case_name in again_suite.keys():
+                again_suite[case_name] = again_suite[case_name] | self.timeout_suite[case_name]
+            else:
+                again_suite[case_name] = self.timeout_suite[case_name]
+        return again_suite
+
diff --git a/testsuite/driver/src/target_parser/__init__.py b/testsuite/driver/src/target_parser/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dad48730a88221d673ae24d810df245c4eda4649
--- /dev/null
+++ b/testsuite/driver/src/target_parser/__init__.py
@@ -0,0 +1,15 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+from target_parser import common_parse
diff --git a/testsuite/driver/src/target_parser/common_parse.py b/testsuite/driver/src/target_parser/common_parse.py
new file mode 100644
index 0000000000000000000000000000000000000000..383f001dc15f860710c28fcbb9f65be4685c766f
--- /dev/null
+++ b/testsuite/driver/src/target_parser/common_parse.py
@@ -0,0 +1,66 @@
+#
+# Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+#
+
+import os
+import re
+import sys
+
+from env_var import EnvVar
+from mode_table import ModeTable
+
+
+class CommonParse(object):
+    case_regx = re.compile("^[A-Z]{1,9}[0-9]{3,10}-[a-zA-Z0-9_.]")
+    module_regx = re.compile("^[a-z0-9_]{1,20}_test$")
+
+    def __init__(self, input: dict):
+        self.target = input["target"]
+        self.mode = input["mode"]
+        if os.path.exists(os.path.join(EnvVar.CONFIG_FILE_PATH, self.target + ".conf")):
+            self.mode_table = ModeTable(os.path.join(EnvVar.CONFIG_FILE_PATH, self.target + ".conf"))
+        else:
+            self.mode_table = ModeTable(os.path.join(EnvVar.CONFIG_FILE_PATH, "testall.conf"))
+        self.cases = {}
+
+    def parser_cases(self):
+        targets = [self.target]
+        if os.path.exists(os.path.join(EnvVar.CONFIG_FILE_PATH, self.target + ".conf")):
+            targets = self.mode_table.get_targets()
+        for single_target in targets:
+            if not os.path.exists(os.path.join(EnvVar.TEST_SUITE_ROOT, single_target)):
+                print("Target " + single_target + " doesn't exist !")
+                sys.exit(1)
+            if CommonParse.case_regx.match(single_target.split('/')[-1]):
+                self.cases[single_target] = self.mode_table.get_case_mode_set(single_target)
+            elif CommonParse.module_regx.match(single_target.split('/')[-1]):
+                subtarget_list = [single_target]
+                while subtarget_list:
+                    subtarget = subtarget_list.pop(0)
+                    for dir in os.listdir(os.path.join(EnvVar.TEST_SUITE_ROOT, subtarget)):
+                        if CommonParse.case_regx.match(dir):
+                            self.cases[os.path.join(subtarget, dir)] = self.mode_table.get_case_mode_set(os.path.join(subtarget, dir))
+                        elif CommonParse.module_regx.match(dir):
+                            subtarget_list.append(os.path.join(subtarget, dir))
+
+    def execute(self):
+        self.parser_cases()
+        if self.mode != None:
+            for case in list(self.cases.keys()):
+                if self.mode in self.cases[case]:
+                    self.cases[case] = {self.mode}
+                else:
+                    del self.cases[case]
+
+    def get_output(self):
+        return self.cases
diff --git a/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/.raw_file_list.txt b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/.raw_file_list.txt
new file mode 100644
index 0000000000000000000000000000000000000000..85c80ce6fa7a46e7727039d29f68758ea283d9dc
--- /dev/null
+++ b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/.raw_file_list.txt
@@ -0,0 +1,7 @@
+addf32_main.c
+Info.txt
+expected.txt
+test.cfg
+expected.mplme.txt
+Main.mpl
+-----
diff --git a/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Info.txt b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Info.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e57ec8eb2c11638fc8a0375f3dcc1bfa5bfb70ee
--- /dev/null
+++ b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Info.txt
@@ -0,0 +1,2 @@
+#Addf32 test
+#Test case for fload add with 32bit architecture
diff --git a/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Main.mpl b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..ed1c250fcdf70fc71419fbbb69e39c86aa0c1180
--- /dev/null
+++ b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Main.mpl
@@ -0,0 +1,15 @@
+ func &addf32r(
+  var %i f32, var %j f32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i, dread f32 %j))}
+
+ func &addf32I (
+  var %i f32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i,
+       constval f32 1.234f))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/addf32_main.c b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/addf32_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..03bade47fe2ea55bc5caf37468c49fa4ea5443ea
--- /dev/null
+++ b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/addf32_main.c
@@ -0,0 +1,8 @@
+extern float addf32r(float, float);
+extern float addf32I(float);
+
+int main(){
+  printf("%f vs %f\n", addf32r(1.2345, -1.234f), 1.2345 - 1.234);
+  printf("%f vs %f\n", addf32I(-2.2222), -2.2222 + 1.234f);
+}
+
diff --git a/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/expected.mplme.txt b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/expected.txt b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/test.cfg b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..b93dc8e37e7b9e31edbb1d181f3d54481aea05fe
--- /dev/null
+++ b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl
@@ -0,0 +1,15 @@
+ func $fooi64 (
+  var %i i64, var %j i64
+  ) i64 { 
+   return (
+     add i64(dread i64 %i, dread i64 %j))}
+
+ func $addi64I (
+  var %i i64
+  ) i64 { 
+   return (
+#add i64(dread i64 %i, constval i64 0x123456789))}
+     add i64(dread i64 %i, constval i64 0x800000115))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/addi64_main.c b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/addi64_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..62dbc25137f80b54c278f6b30c2d540ada391a7c
--- /dev/null
+++ b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/addi64_main.c
@@ -0,0 +1,22 @@
+#include "typedef.h"
+extern int64 fooi64(int64 a ,int64 b);
+extern int64 addi64I(int64 a);
+
+int main() {
+  if (fooi64(0x1234343, 0x123456789) == (0x1234343+0x123456789))
+    printf("%llx pass\n", fooi64(0x1234343, 0x123456789));
+  else
+    printf("failed\n");
+  if (addi64I(0x1234343) == (0x1234343+0x123456789))
+    printf("pass\n");
+  else {
+    printf("failed\n");
+    printf("%llx vs 0x12468aacc\n", addi64I(0x1234343));
+  }
+  if (addi64I(0x800000008) == (0x800000008 + 0x800000008))
+    printf("pass3\n");
+  else {
+    printf("failed3\n");
+    printf("%llx\n", addi64I(0x800000008));
+  }
+}
diff --git a/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/expected.mplme.txt b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/expected.txt b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/test.cfg b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..4164e27feb5fcfc12b594bec646e87429eb9e62b
--- /dev/null
+++ b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl
@@ -0,0 +1,17 @@
+ func $foo1 (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i, dread i32 %j))}
+
+ func $addi32I (
+  var %i i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i,
+#constval i32 0xfff))}
+#       constval i32 0xffff))}
+       constval i32 0xfffff))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/addi_main.c b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/addi_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..f5d09d7e4c2a705e14caf5eae026749eeb7c1ac9
--- /dev/null
+++ b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/addi_main.c
@@ -0,0 +1,7 @@
+extern int foo1(int a ,int b);
+extern int addi32I(int a);
+
+int main() {
+  printf("%d\n", foo1(7,5));
+  printf("%d\n", addi32I(7));
+}
diff --git a/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/expected.mplme.txt b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/expected.txt b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/test.cfg b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/Main.mpl b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..f0229b09393423172997ee3f56ca7795d711216a
--- /dev/null
+++ b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/Main.mpl
@@ -0,0 +1,69 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i, 
+       constval i32 -998))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i, dread i32 %j))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     add i32(dread i32 %i, constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     add i64(dread i64 %i, constval i64 0x111111111))}
+
+ func $foo4 (
+  var %i i64, var %j i64, var %k i32
+  )i64  { 
+   return (
+     add i64(dread i64 %i, dread i64 %j))}
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     add i64(dread i64 %i, constval i64 0x11111))}
+
+ func $foo6 (
+  var %i f64, var %j f64, var %k i32
+  ) f64 { 
+   return (
+     add f64(dread f64 %i, constval f64 2.237))}
+
+ func $foo66 (
+  var %i f64, var %j f64, var %k i32
+  ) f64 {
+   return (
+     add f64(dread f64 %i, constval f64 2.237))}
+ func $foo7 (
+  var %i f32, var %j f32, var %k i32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i, dread f32 %j))}
+
+ func $foo8 (
+  var %i f32, var %j f32, var %k i32
+  ) f32 { 
+   return (
+     add f32(dread f32 %i, constval f32 2.237f))}
+
+ func $foo9 (
+  var %i i8, var %j u8, var %k i32) i32 { 
+   return (
+     add i32(dread i32 %i, dread u32 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/add_main.c b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/add_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..ec1c66e3ded3f37403bbddf9bc66c091b4afd82b
--- /dev/null
+++ b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/add_main.c
@@ -0,0 +1,5 @@
+extern int foo1(int a ,int b);
+
+int main() {
+  return foo1(7,5);
+}
diff --git a/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/expected.mplme.txt b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/expected.txt b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/test.cfg b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0004-mapleall-irbuild-edge-add/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl b/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..6a12bf5e8c4014a5c556bf8d1f8946cad643fbc1
--- /dev/null
+++ b/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl
@@ -0,0 +1,24 @@
+var $arr1 <[10] i32>
+var $arr2 <[10] i32>
+var $arr3 <[10] i32>
+
+func $ArrayAdd () void {
+ var %i i32
+ doloop %i ( 
+  constval i32 0, 
+  lt i32 i32 (dread i32 %i, constval i32 10), 
+  add i32(dread i32 %i, constval i32 1)){
+   iassign <* [10] i32>(
+    array 1 a32 <* [10] i32>(addrof a32 $arr1, dread i32 %i),
+    add i32(
+     iread i32 <* [10] i32>(
+      array 1 a32 <* [10] i32>(addrof a32 $arr2, dread i32 %i)), 
+     iread i32 <* [10] i32>(
+      array 1 a32 <* [10] i32>(addrof a32 $arr3, dread i32 %i))
+     ))
+  }
+  return() 
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/expected.mplme.txt b/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/expected.txt b/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/test.cfg b/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/Main.mpl b/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3f0dd9f3814eb67a6c31c9f1bb03414579ba1105
--- /dev/null
+++ b/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/Main.mpl
@@ -0,0 +1,12 @@
+var $iconst1 <[4] [4] i32> = [ [1007, 707, -273, 75], [0113, 0x4b, 75u, 75l], [75ul, 75lu, 31425926, 60223], [60223, 1619, 30, 314159]]
+var $fconst1 <[4] [4] f64> = [ [1007.0, 707.0, -273.0, 75.0], [113.1, 4.0, 75.0, 75.1], [75.0, 75.1, 3.1425926, 6.02e23], [6.02e+23, 1.6e-19, 3.0, 3.14159]]
+func &printf (var %p1 <* i8>)void
+func &main ( ) i32 {
+   call &printf (addrof a32 $fconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/expected.mplme.txt b/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/expected.txt b/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/test.cfg b/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/Main.mpl b/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..82200c59f71e249301b6c4fefb811eb4b7a8dae3
--- /dev/null
+++ b/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/Main.mpl
@@ -0,0 +1,19 @@
+var $i i32 align(4) = 987
+type $SS1 <struct {
+  @f1 i32 volatile const,
+  @f2 i32 align(8),
+  @f3 i32 const } > 
+var $iconst1 <[4] [4] i32> const = [ [1007, 707, -273, 75], [0113, 0x4b, 75u, 75l], [75ul, 75lu, 31425926, 60223], [60223, 1619, 30, 314159]]
+var $fconst1 <[4] [4] f64 > volatile = [ [1007.0, 707.0, -273.0, 75.0], [113.1, 4.0, 75.0, 75.1], [75.0, 75.1, 3.1425926, 6.02e23], [6.02e+23, 1.6e-19, 3.0, 3.14159]]
+func &printf const static varargs (var %p1 <* i8 > volatile const, var %p2 <* i32> volatile)void 
+func &noarg varargs ( ... ) void
+func $main static ( ) i32 {
+   var %jj i32 volatile align(16)
+   call &printf (addrof a32 $fconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/expected.mplme.txt b/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/expected.txt b/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/test.cfg b/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/Main.mpl b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..6b716d0e83ed8c381af78ebf3ce46eb3f8e73b8d
--- /dev/null
+++ b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/Main.mpl
@@ -0,0 +1,41 @@
+ func $band32I (
+  var %i i32
+  ) i32 { 
+   return (
+     band i32(dread i32 %i,
+       constval i32 0x12))}	  
+ func $band32I_2 (
+  var %i i32
+  ) i32 { 
+   return (
+     band i32(dread i32 %i,
+       constval i32 0x112))}	 
+ func $band32RR (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     band i32(dread i32 %i,
+       dread i32 %j))}	   
+
+ func $band64I (
+  var %i i64
+  ) i64 {
+   return (
+     band i64(dread i64 %i,
+       constval i64 0x1200000015))}
+ func $band64I_2 (
+  var %i i64
+  ) i64 {
+   return (
+     band i64(dread i64 %i,
+       constval i64 0x1200000115))}
+ func $band64RR (
+  var %i i64,
+  var %j i64
+  ) i64 {
+   return (
+     band i64(dread i64 %i,
+              dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/band_main.c b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/band_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..a6133cf67aee7d52a51069c9234628efe7adfac7
--- /dev/null
+++ b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/band_main.c
@@ -0,0 +1,48 @@
+extern int band32I(int a);
+extern int band32I_2(int a);
+extern int band32RR(int a, int b);
+
+extern long long band64I(long long a);
+extern long long band64I_2(long long a);
+extern long long band64RR(long long a, long long b);
+
+int main() {
+
+  if((7 & 0x12)== band32I(7))
+    printf("band32I pass.\n");
+  else {
+    printf("band32I false.\n");
+    return 1;
+  }
+  if((7 & 0x112)== band32I_2(7))
+    printf("band32I_2 pass.\n");
+  else {
+    printf("band32I_2 false.\n");
+    return 1;
+  }
+  if((7 & 5)== band32RR(7, 5))
+    printf("band32RR pass.\n");
+  else {
+    printf("band32RR false.\n");
+    return 1;
+  }
+  if((0x1200000007 & 0x1200000015)== band64I(0x1200000007))
+    printf("band64I pass.\n");
+  else {
+    printf("band64I false.\n");
+    return 1;
+  }
+  if((0x1200000115 & 0x11200000127)== band64I_2(0x11200000127))
+    printf("band64I_2 pass.\n");
+  else {
+    printf("band64I_2 false.\n");
+    return 1;
+  }
+  if((0x1200000007 & 0x11200000127)== band64RR(0x1200000007, 0x11200000127))
+    printf("band64RR pass.\n");
+  else {
+    printf("band64RR false.\n");
+    return 1;
+  }
+  return 0;
+}
diff --git a/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/expected.mplme.txt b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/expected.txt b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/test.cfg b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/Main.mpl b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..7f5f81bb65f0dc026ae77f120f478fde986cc779
--- /dev/null
+++ b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/Main.mpl
@@ -0,0 +1,41 @@
+ func $bior32I (
+  var %i i32
+  ) i32 { 
+   return (
+     bior i32(dread i32 %i,
+       constval i32 0x12))}	  
+ func $bior32I_2 (
+  var %i i32
+  ) i32 { 
+   return (
+     bior i32(dread i32 %i,
+       constval i32 0x112))}	 
+ func $bior32RR (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     bior i32(dread i32 %i,
+       dread i32 %j))}	   
+
+ func $bior64I (
+  var %i i64
+  ) i64 {
+   return (
+     bior i64(dread i64 %i,
+       constval i64 0x1200000015))}
+ func $bior64I_2 (
+  var %i i64
+  ) i64 {
+   return (
+     bior i64(dread i64 %i,
+       constval i64 0x1200000115))}
+ func $bior64RR (
+  var %i i64,
+  var %j i64
+  ) i64 {
+   return (
+     bior i64(dread i64 %i,
+              dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/bior_main.c b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/bior_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..93f9db2cc8b4c565008e4d04b5c55fac39924d51
--- /dev/null
+++ b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/bior_main.c
@@ -0,0 +1,48 @@
+extern int bior32I(int a);
+extern int bior32I_2(int a);
+extern int bior32RR(int a, int b);
+
+extern long long bior64I(long long a);
+extern long long bior64I_2(long long a);
+extern long long bior64RR(long long a, long long b);
+
+int main() {
+
+  if((7 | 0x12)== bior32I(7))
+    printf("bior32I pass.\n");
+  else {
+    printf("bior32I false.\n");
+    return 1;
+  }
+  if((7 | 0x112)== bior32I_2(7))
+    printf("bior32I_2 pass.\n");
+  else {
+    printf("bior32I_2 false.\n");
+    return 1;
+  }
+  if((7 | 5)== bior32RR(7, 5))
+    printf("bior32RR pass.\n");
+  else {
+    printf("bior32RR false.\n");
+    return 1;
+  }
+  if((0x1200000007 | 0x1200000015)== bior64I(0x1200000007))
+    printf("bior64I pass.\n");
+  else {
+    printf("bior64I false.\n");
+    return 1;
+  }
+  if((0x1200000115 | 0x11200000127)== bior64I_2(0x11200000127))
+    printf("bior64I_2 pass.\n");
+  else {
+    printf("bior64I_2 false.\n");
+    return 1;
+  }
+  if((0x1200000007 | 0x11200000127)== bior64RR(0x1200000007, 0x11200000127))
+    printf("bior64RR pass.\n");
+  else {
+    printf("bior64RR false.\n");
+    return 1;
+  }
+  return 0;
+}
diff --git a/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/expected.mplme.txt b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/expected.txt b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/test.cfg b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/Main.mpl b/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..67004f9cf3559aadc39fd54273cbebf9b4e74884
--- /dev/null
+++ b/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/Main.mpl
@@ -0,0 +1,37 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     bnot i32(dread i32 %i))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     bnot i32(dread i32 %i))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     bnot i32(constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     bnot i64(dread i64 %i))}
+
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     bnot i64(constval i64 0x11111))}
+
+# todo float bnot
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/expected.mplme.txt b/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/expected.txt b/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/test.cfg b/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/Main.mpl b/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..1ab362e93145a2e23cdce26fa55806c416ca0f45
--- /dev/null
+++ b/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/Main.mpl
@@ -0,0 +1,12 @@
+func $fact (
+ var %n i32) i32 {
+@fred2
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+     brfalse @fred2 (dread i32 %n)
+@fred1
+     return (constval i32 0) } 
+ else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/expected.mplme.txt b/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/expected.txt b/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/test.cfg b/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/Main.mpl b/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8f622b06a1ec5b674f9bebea4bd9ed0b8a34f242
--- /dev/null
+++ b/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/Main.mpl
@@ -0,0 +1,23 @@
+func $singlefoo(var %a i32) i32 {
+  return (dread i32 %a)
+}
+
+func $fact(var %n i32) i32 {
+  var %m i32
+  var %r1 i32
+  var  %r2 i32
+  var  %r3 i32
+  callassigned &singlefoo(dread i32 %n) {
+    dassign %m 0
+  }
+  # Not correct, but for parse and dump test.
+  callassigned &singlefoo(dread i32 %n) {
+    dassign %r1 1
+    dassign %r2 2
+    dassign %r3 3
+  }
+  return (dread i32 %n)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/expected.mplme.txt b/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/expected.txt b/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/test.cfg b/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/Main.mpl b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..452853a54d985de2e3cdffec63b7965ff8661cf3
--- /dev/null
+++ b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/Main.mpl
@@ -0,0 +1,29 @@
+ func $ceilf64toi32 (
+  var %i f64
+  ) i32 { 
+   return (
+     ceil i32 f64(dread f64 %i))}
+
+ func $ceilf64toi64 (
+  var %i f64
+  ) i64 { 
+   return (
+     ceil i64 f64(dread f64 %i))}
+
+ func $ceilf32toi32 (
+  var %i f32
+  ) i32 { 
+   return (
+     ceil i32 f32(dread f32 %i))}
+
+
+ func $ceilf32toi64 (
+  var %i f32
+  ) i64 { 
+   return (
+     ceil i64 f32(dread f32 %i))}
+
+# todo float ceil
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/ceilmain.c b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/ceilmain.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb2343458ec010336dcb4052325ed7f2dfedc8e5
--- /dev/null
+++ b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/ceilmain.c
@@ -0,0 +1,36 @@
+extern int ceilf64toi32(double x);
+extern int ceilf32toi32(float x);
+extern long long int ceilf64toi64(double x);
+extern long long int ceilf32toi64(float x);
+
+int main(void) {
+    printf("%d\n", ceilf64toi32(1.22));
+    printf("%d\n", ceilf64toi32(1.00f));
+    printf("%d\n", ceilf64toi32(0));
+    printf("%d\n", ceilf64toi32(-1));
+    printf("%d\n", ceilf64toi32(-1.22));
+    printf("%d\n", ceilf64toi32(-111.22));
+ 
+    printf("%d\n", ceilf32toi32(1.22));
+    printf("%d\n", ceilf32toi32(1.00f));
+    printf("%d\n", ceilf32toi32(0));
+    printf("%d\n", ceilf32toi32(-1));
+    printf("%d\n", ceilf32toi32(-1.22));
+    printf("%d\n", ceilf32toi32(-111.22));
+
+    printf("%lld\n", ceilf64toi64(111111111111.21));
+    printf("%lld\n", ceilf64toi64(1.22));
+    printf("%lld\n", ceilf64toi64(1.00f));
+    printf("%lld\n", ceilf64toi64(0));
+    printf("%lld\n", ceilf64toi64(-1));
+    printf("%lld\n", ceilf64toi64(-1.22));
+    printf("%lld\n", ceilf64toi64(-111.22));
+    printf("%lld\n", ceilf32toi64(1.22));
+    printf("%lld\n", ceilf32toi64(1.00f));
+    printf("%lld\n", ceilf32toi64(0));
+    printf("%lld\n", ceilf32toi64(-1));
+    printf("%lld\n", ceilf32toi64(-1.22));
+    printf("%lld\n", ceilf32toi64(-111.22));
+      return 0;
+}
+
diff --git a/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/expected.mplme.txt b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/expected.txt b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/test.cfg b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/Main.mpl b/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8e05e65c4c36851a22091b6477713bfaa2c83c03
--- /dev/null
+++ b/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/Main.mpl
@@ -0,0 +1,21 @@
+ flavor 1
+ func &ciori32 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   if (cior i32 ( cior i32(dread i32 %i, dread i32 %j), dread i32 %k)) {
+     return (constval i32 1)
+   }
+   return (
+     cior i32(dread i32 %i, dread i32 %j))}
+
+ func &candi64 (
+  var %i i64, var %j i64, var %k i64
+  ) i32 { 
+   if (cand i32 (cand i32(dread i32 %i, dread i32 %j), dread i32 %k)) {
+     return (constval i32 1)
+   }
+   return (
+     cand i64(dread i64 %i, dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/expected.mplme.txt b/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/expected.txt b/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/test.cfg b/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/Main.mpl b/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a2c9a0952c01e35aa66c27e97e3cbae948813cd4
--- /dev/null
+++ b/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/Main.mpl
@@ -0,0 +1,11 @@
+type $RR <class {@e1 i32, @e2 f32, @e3 f64}>
+type $SS <class <$RR> {@f1 i32, @f2 i8, @f3 i8}>
+type $TT <class {@e1 i32, @e2 f32, @e3 f64}>
+type $UU <class <$RR> {@f1 i32, @f2 i8, @f3 i8}>
+func &foo ( var %x <$SS>) void {
+  var %y <$UU>
+  dassign %y 0 ( dread agg %x 0 )
+  return () }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/expected.mplme.txt b/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/expected.txt b/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/test.cfg b/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/Main.mpl b/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..5c446b85b76fe2954a1e5951ade166130449e877
--- /dev/null
+++ b/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/Main.mpl
@@ -0,0 +1,10 @@
+type $RR <class {@e1 i32, @e2 f32, @e3 f64}>
+type $SS <classincomplete <$RR> {@f1 i32, @f2 i8, @f3 i8}>
+javaclass $TT <$SS> public static
+func &foo (
+	var %x <$SS>) i32 {
+  dassign %x 2 ( constval i32 32 )
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/expected.mplme.txt b/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/expected.txt b/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/test.cfg b/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..d476e46c4586f3ba3a39abfb9bae814690b0fe04
--- /dev/null
+++ b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl
@@ -0,0 +1,15 @@
+var $nan_f32 <f32> = nanf
+var $nan_f64 <f64> = nan
+var $inf_f32 <f32> = -inff
+var $inf_f64 <f64> = inf
+var $g_f32 <f32> = -1.2f
+var $g_f64 <f64> = 1.2
+func $add_f32 () f32 {
+  return (
+    add f32(dread f32 $g_f32, constval f32 inff))}
+func $add_f64 () f64 {
+  return (
+    add f64(dread f64 $g_f64, constval f64 -inf))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/constfloatmain.c b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/constfloatmain.c
new file mode 100644
index 0000000000000000000000000000000000000000..51ffc37d5eb8708950bc6d4850ea1e1c4addb3ed
--- /dev/null
+++ b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/constfloatmain.c
@@ -0,0 +1,18 @@
+#include<stdio.h>
+extern float add_f32();
+extern double add_f64();
+int main(){
+  float fresult = add_f32();
+  printf ("%f\n", fresult);
+  if(fabsf(1.7f - fresult) > 0.00001) {
+    printf("FAIL : f32 test fail.\n");
+    return 1;
+  }
+  double dresult = add_f64();
+  if(fabs(1.7 - dresult) > 0.0000000001){
+    printf("%lf, FAIL : f64 test fail.\n", add_f64());
+    return 1;
+  }
+  printf("PASS : emit constant f32&f64 test pass.\n");
+  return 0;
+}
diff --git a/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/expected.mplme.txt b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/expected.txt b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/test.cfg b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/Main.mpl b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..d0b562cc934797ab3ecb9e62d007de68e85cb57c
--- /dev/null
+++ b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/Main.mpl
@@ -0,0 +1,582 @@
+# 1 + 8 -> 9
+func $testSum (var %i i32) i32 {
+  return (
+    add i32(constval i32 1, constval i32 8))
+}
+
+# sqrt(4.0) -> 2.0
+func $testSqrt (var %i i32) f32 {
+  return (
+    sqrt f32(constval f32 4.0f))
+}
+
+# 5 + (5 + a) -> a + 10
+func &testConstVarFold00 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 5,
+    add i32 (constval i32 5, dread i32 %a)))
+}
+
+# 5 + (5 - a) -> 10 - a
+func &testConstVarFold01 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 5,
+    sub i32 (constval i32 5, dread i32 %a)))
+}
+
+# 5 + (a + 5) ->  a + 10
+func &testConstVarFold02 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 5,
+    add i32 (dread i32 %a, constval i32 5)))
+}
+
+# 6 + (a - 5) ->  a + 1
+func &testConstVarFold03 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 6,
+    sub i32 (dread i32 %a, constval i32 5)))
+}
+
+# 5 * (5 * a) -> 5 * (5 * a)
+func &testConstVarFold04 (var %a i32) i32 {
+  return (mul i32 (
+    constval i32 5,
+    mul i32 (constval i32 5, dread i32 %a)))
+}
+
+# 5 * (a * 5) -> 5 * (a * 5)
+func &testConstVarFold05 (var %a i32) i32 {
+  return (mul i32 (
+    constval i32 5,
+    mul i32 (dread i32 %a, constval i32 5)))
+}
+
+# 3 - (2 - a) -> a + 1
+func &testConstVarFold06 (var %a i32) i32 {
+  return (sub i32 (
+    constval i32 3,
+    sub i32 (constval i32 2, dread i32 %a)))
+}
+
+# 3 - (2 + a) -> 1 - a
+func &testConstVarFold07 (var %a i32) i32 {
+  return (sub i32 (
+    constval i32 3,
+    add i32 (constval i32 2, dread i32 %a)))
+}
+
+# 3 - (a + 2) -> 1 - a
+func &testConstVarFold08 (var %a i32) i32 {
+  return (sub i32 (
+    constval i32 3,
+    add i32 (dread i32 %a, constval i32 2)))
+}
+
+# 3 - (a - 2) -> 5 - a
+func &testConstVarFold09 (var %a i32) i32 {
+  return (sub i32 (
+    constval i32 3,
+    sub i32 (dread i32 %a, constval i32 2)))
+}
+
+# (2 + a) - 3 -> a - 1
+func &testConstVarFold10 (var %a i32) i32 {
+  return (sub i32 (
+    add i32 (constval i32 2, dread i32 %a),
+    constval i32 3))
+}
+
+# (2 - a) - 3 -> -a - 1
+func &testConstVarFold11 (var %a i32) i32 {
+  return (sub i32 (
+    sub i32 (constval i32 2, dread i32 %a),
+    constval i32 3))
+}
+
+# (a + 2) - 3 -> a - 1
+func &testConstVarFold12 (var %a i32) i32 {
+  return (sub i32 (
+    add i32 (dread i32 %a, constval i32 2),
+    constval i32 3))
+}
+
+#  (a - 2) - 3 -> a - 5
+func &testConstVarFold13 (var %a i32) i32 {
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 2),
+    constval i32 3))
+}
+
+# 1 + (5 + ((5 - a) - 3)) -> 8 - a
+func &testConstVarFold15 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 1,
+    add i32 (
+      constval i32 5,
+      sub i32 (
+        sub i32 (constval i32 5, dread i32 %a),
+        constval i32 3))))
+}
+
+# 1 + (5 + ((5 - a) * 3)) -> ((5 - a) * 3) + 6
+func &testConstVarFold16 (var %a i32) i32 {
+  return (add i32 (
+    constval i32 1,
+    add i32 (
+      constval i32 5,
+      mul i32 (
+        sub i32 (constval i32 5, dread i32 %a),
+        constval i32 3))))
+}
+
+# (-a) + b --> (-a) + b
+func &testConstantFoldAdd00 (var %a i32, var %b i32) i32 {
+  return (add i32 (
+    neg i32 (dread i32 %a),
+    dread i32 %b))
+}
+
+#  a + (-b) --> a + (-b)
+func &testConstantFoldAdd01 (var %a i32, var %b i32) i32 {
+  return (add i32 (
+    dread i32 %a,
+    neg i32 (dread i32 %b)))
+}
+
+
+# 5.0f + (5 - a) -> same, no folding with floating point numbers
+func &testConstVarFold20 (var %a i32) i32 {
+  return (add f32 (
+    constval f32 5.0f,
+    sub i32 (constval i32 5, dread i32 %a)))
+}
+
+
+func &testConstFold0 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a + 5) + ((2 + c) + (4 + 2))) -> ((a + c) + 13)
+  return (add i32 (
+    add i32 (dread i32 %a, constval i32 0x5),
+    add i32 (
+      add i32 (constval i32 0x2, dread i32 %c),
+      add i32 (constval i32 0x4, constval i32 0x2))))
+}
+
+func &testConstFold1 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a + 5) + (2 + c)) -> ((a + c) + 7)
+  return (add i32 (
+    add i32 (dread i32 %a, constval i32 0x5),
+    add i32 (constval i32 0x2, dread i32 %c)))
+}
+
+func &testConstFold2 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((b - c) - (4 - 2))) -> ((a - (b - c)) - 3)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      sub i32 (dread i32 %b, dread i32 %c),
+      sub i32 (constval i32 0x4, constval i32 0x2))))
+}
+
+func &testConstFold3 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) + ((b - c) - (4 - 2))) -> ((a + (b - c)) - 7)
+  return (add i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      sub i32 (dread i32 %b, dread i32 %c),
+      sub i32 (constval i32 0x4, constval i32 0x2))))
+}
+
+func &testConstFold4 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((4 - 2) - (4 - b))) -> ((a - b) - 3)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      sub i32 (constval i32 0x4, constval i32 0x2),
+      sub i32 (constval i32 0x4, dread i32 %b))))
+}
+
+func &testConstFold5 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((5 - a) - ((b - 4) - (4 - b))) -> (((-a) - (b - (-b))) + 13)
+  return (sub i32 (
+    sub i32 (constval i32 0x5, dread i32 %a),
+    sub i32 (
+      sub i32 (dread i32 %b, constval i32 0x4),
+      sub i32 (constval i32 0x4, dread i32 %b))))
+}
+
+func &testConstFold6 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((5 - a) - ((4 - b) - (b - 4))) -> (((-a) - ((-b) - b)) - 3)
+  return (sub i32 (
+    sub i32 (constval i32 0x5, dread i32 %a),
+    sub i32 (
+      sub i32 (constval i32 0x4, dread i32 %b),
+      sub i32 (dread i32 %b, constval i32 0x4))))
+}
+
+func &testConstFold7 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((4 + 2) - (4 - (b - c)))) -> ((a - (b - c)) - 7)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      add i32 (constval i32 0x4, constval i32 0x2),
+      sub i32 (
+        constval i32 0x4,
+        sub i32 (dread i32 %b, dread i32 %c)))))
+}
+
+func &testConstFold8 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((4 + 2) - (4 * (b - c)))) -> ((a - (-(4 * (b - c)))) - 11)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      add i32 (constval i32 0x4, constval i32 0x2),
+      mul i32 (
+        constval i32 0x4,
+        sub i32 (dread i32 %b, dread i32 %c)))))
+}
+
+func &testConstFold9 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((a - 5) - ((4 + 2) - (-(4 - (b - c))))) -> ((a - (-(b - c))) - 15)
+  return (sub i32 (
+    sub i32 (dread i32 %a, constval i32 0x5),
+    sub i32 (
+      add i32 (constval i32 0x4, constval i32 0x2),
+      neg i32 (sub i32 (
+        constval i32 0x4,
+        sub i32 (dread i32 %b, dread i32 %c))))))
+}
+
+func &testConstFold10 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((4 + 2) * (-(4 - (3 - c)))) -> (6 * ((-c) - 1))
+  return (mul i32 (
+    add i32 (constval i32 0x4, constval i32 0x2),
+    neg i32 (sub i32 (
+      constval i32 0x4,
+      sub i32 (constval i32 0x3, dread i32 %c)))))
+}
+
+func &testConstFold11 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((4 + 2) * (4 - (3 - c))) -> (6 * (c + 1))
+  return (mul i32 (
+    add i32 (constval i32 0x4, constval i32 0x2),
+    sub i32 (
+      constval i32 0x4,
+      sub i32 (constval i32 0x3, dread i32 %c))))
+}
+
+func &testConstFold12 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((4 + 2) * (~(4 - (3 - c)))) -> (6 * (~(c + 1)))
+  return (mul i32 (
+    add i32 (constval i32 0x4, constval i32 0x2),
+    bnot i32 (sub i32 (
+      constval i32 0x4,
+      sub i32 (constval i32 0x3, dread i32 %c)))))
+}
+
+func &testConstFold13 (var %a i32, var %b i32, var %c i32) i32 {
+  # (5 * (((4 - 2) + (2 & 4)) - (4 - (c | 3)))) -> (5 * ((c | 3) - 2))
+  return (mul i32 (
+    constval i32 0x5,
+    sub i32 (
+      add i32 (
+        sub i32 (constval i32 0x4, constval i32 0x2),
+        band i32 (constval i32 0x2, constval i32 0x4)),
+      sub i32 (
+        constval i32 0x4,
+        bior i32 (dread i32 %c, constval i32 0x3)))))
+}
+
+func &testConstFold14 (var %a i32, var %b i32, var %c i32) i32 {
+  # (5 * (((4 - 2) + (2 & 4)) * (4 - (c | 3)))) -> (5 * (2 * (4 - (c | 3))))
+  return (mul i32 (
+    constval i32 0x5,
+    mul i32 (
+      add i32 (
+        sub i32 (constval i32 0x4, constval i32 0x2),
+        band i32 (constval i32 0x2, constval i32 0x4)),
+      sub i32 (
+        constval i32 0x4,
+        bior i32 (dread i32 %c, constval i32 0x3)))))
+}
+
+func &testConstFold15 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((1 + 0) * (~(4 - (0 * c)))) -> (~4)
+  return (mul i32 (
+    add i32 (constval i32 0x1, constval i32 0x0),
+    bnot i32 (sub i32 (
+      constval i32 0x4,
+      mul i32 (constval i32 0x0, dread i32 %c)))))
+}
+
+func &testConstFold16 (var %a i32, var %b i32, var %c i32) i32 {
+  # ((~(4 - (c * 0))) * (1 + 0)) -> (~4)
+  return (mul i32 (
+    bnot i32 (sub i32 (
+      constval i32 0x4,
+      mul i32 (dread i32 %c, constval i32 0x0))),
+    add i32 (constval i32 0x1, constval i32 0x0)))
+}
+
+
+func &testConstFoldDiv0 (var %a i32, var %b i32, var %c i32) i32 {
+  # (5 / 0) * (1 + 1) -> 2
+  return (mul i32 (
+    div i32 (constval i32 0x5, constval i32 0x0),
+    add i32 (constval i32 0x1, constval i32 0x1)))
+}
+
+func &testConstFoldFloor00 (var %a i32, var %b i32, var %c i32) i32 {
+  # (floor(4.25) + c) * (1 + 1) -> (c + 4) * 2
+  return (mul i32 (
+    add i32 (floor i32 f32 (constval f32 4.25f), dread i32 %c),
+    add i32 (constval i32 0x1, constval i32 0x1)))
+}
+
+func &testConstFoldFloor01 (var %a i32, var %b i32, var %c i32) i32 {
+  # (floor(4.25) + 2) * (1 + 1) -> 12
+  return (mul i32 (
+    add i32 (floor i32 f32 (constval f32 4.25f), constval i32 0x2),
+    add i32 (constval i32 0x1, constval i32 0x1)))
+}
+
+func &testConstFoldFloor02 (var %a i32, var %b i32, var %c i32) i32 {
+  # floor((floor(4.25) + 1) + (1 + a)) -> floor(a + 6)
+  return (floor i32 i32 (add i32 (
+    add i32 (floor i32 f32 (constval f32 4.25f), constval i32 0x1),
+    add i32 (constval i32 0x1, dread i32 %a))))
+}
+
+func &testConstFoldExtractbitsNode00 () i32 {
+  # 487 = 00111100111
+  # extractbits i32 6 5 (487) = 7 = 0111
+  return (extractbits i32 6 5 (constval i32 487))
+}
+
+func &testConstFoldExtractbitsNode01 () i32 {
+  # 487 = 00111100111
+  # extractbits i32 4 5 (487) = -2 = 0xfffffffffffffffe
+  return (extractbits i32 4 5 (constval i32 487))
+}
+
+func &testConstFoldExtractbitsNode02 (var %a i32, var %b i32, var %c i32) i32 {
+  # 487 = 00111100111
+  # extractbits i32 4 5 (487) = -2 = 0xfffffffffffffffe
+  # extractbits((extractbits(487) + 1) + (1 + a)) -> extractbits(a)
+  return (extractbits i32 4 5 (add i32 (
+    add i32 (extractbits i32 4 5 (constval i32 487), constval i32 0x1),
+    add i32 (constval i32 0x1, dread i32 %a))))
+}
+
+func &testConstFoldExtractbitsNode03 (var %a i32, var %b i32, var %c i32) i32 {
+  # 487 = 00111100111
+  # extractbits i32 6 5 (487) = 7 = 0111
+  # extractbits((extractbits(487) + 1) + (1 + a)) -> extractbits(a + 9)
+  return (extractbits i32 6 5 (add i32 (
+    add i32 (extractbits i32 6 5 (constval i32 487), constval i32 0x1),
+    add i32 (constval i32 0x1, dread i32 %a))))
+}
+
+func &testConstFoldCompareNode00 (var %a i32, var %b i32, var %c i32) i32 {
+  # (ge(6, 2) + 1) + (1 + 2) -> 5
+  return (add i32 (
+    add i32 (
+      ge i32 i32 (constval i32 6, constval i32 2),
+      constval i32 1),
+    add i32 (constval i32 1, constval i32 2)))
+}
+
+func &testConstFoldCompareNode01 (var %a i32, var %b i32, var %c i32) i32 {
+  # ge((ge(6, 2) + 1), (1 + a)) -> ge(2, a + 1)
+  return (ge i32 i32 (
+    add i32 (
+      ge i32 i32 (constval i32 6, constval i32 2),
+      constval i32 1),
+    add i32 (constval i32 1, dread i32 %a)))
+}
+
+func &testConstFoldTernaryNode00 (var %a i32, var %b i32, var %c i32) i32 {
+  # (6 > 2 ? 5 : 0) + (1 + 2) -> 8
+  return ( add i32 (
+    select i32 (
+      ge i32 i32 (constval i32 6, constval i32 2),
+      constval i32 5,
+      constval i32 0),
+    add i32 (constval i32 1,  constval i32 2)))
+}
+
+func &testConstFoldTernaryNode01 (var %a i32, var %b i32, var %c i32) i32 {
+  # (6 > 10 ? 5 : 0) + (1 + a) -> (a + 1)
+  return ( add i32 (
+    select i32 (
+      ge i32 i32 (constval i32 6, constval i32 10),
+      constval i32 5,
+      constval i32 0),
+    add i32 (constval i32 1, dread i32 %a)))
+}
+
+func &testConstFoldTernaryNode02 (var %a i32, var %b i32, var %c i32) i32 {
+  # 6 > a ? (1 + 6) + (1 + a) : 0 -> 6 > a ? a + 8 : 0
+  return ( select i32 (
+    ge i32 i32 (constval i32 6, dread i32 %a),
+    add i32 (
+      add i32 (constval i32 1, constval i32 6),
+      add i32 (constval i32 1, dread i32 %a)),
+    constval i32 0))
+}
+
+type $Hello <struct {
+    @h i32,
+    @e i32,
+    @l i32,
+    @o i32
+  }>
+
+type $Person <struct {
+  @age i32,
+  @extra <$Hello>,
+  @sex u1}>
+
+
+func &testConstFoldIassignNode00 (var %a i32) void {
+  # this is equivalent to dassign %a 0 (constval i32 0x6)
+  iassign <* i32> 0 (addrof ptr %a 0, add i32 (constval i32 1, constval i32 5))
+}
+
+func &testConstFoldIassignNode01 (var %a i32) void {
+  var %bob $Person
+
+  # this is equivalent to dassign %bob 5 (constval i32 0x6)
+  iassign <* $Hello> 3 (addrof ptr %bob 2, add i32 (constval i32 1, constval i32 5))
+}
+
+
+func &testConstFoldIassignNode02 (var %a i32) void {
+  # this is equivalent to dassign %a 0 (constval i32 0x6)
+  iassign <* i32> 0 (
+    iaddrof ptr <* i32> 0 (addrof ptr %a 0),
+    add i32 (constval i32 1, constval i32 5))
+}
+
+func &testConstFoldIassignNode03 (var %a i32) void {
+
+  var %bob $Person
+  # this is equivalent to dassign %bob 5 (constval i32 0x6)
+  iassign <* <$Hello>> 3 (
+    iaddrof ptr <* <$Person>> 2 (addrof ptr %bob 0),
+    add i32 (constval i32 1, constval i32 5))
+}
+
+func &testConstFoldIassignNode04 (var %a i32) void {
+
+  var %bob $Person
+  # this is equivalent to dassign %bob 5 (constval i32 0x6)
+  iassign <* <$Hello>> 3 (
+    iaddrof ptr <* <$Hello>> 0 (addrof ptr %bob 2),
+    add i32 (constval i32 1, constval i32 5))
+}
+
+
+func &testConstFoldIassignNode05 (var %a i32) void {
+  var %b <* i32>
+
+  dassign %b (addrof ptr %a 0)
+
+  # this is equivalent to iassign <* i32> 0 (dread ptr %a, constval i32 0x6)
+  iassign <* i32> 0 (
+    iaddrof ptr <* i32> 0 (dread ptr %a),
+    add i32 (constval i32 1, constval i32 5))
+}
+
+func &testConstFoldIassignNode06 (var %a i32) void {
+  var %bob $Person
+  # this is equivalent to dassign %a 0 (dread i32 %bob 1)
+  dassign %a 0 (iread agg <* <$Person>> 1 (addrof ptr %bob 0))
+}
+
+func &testConstFoldSwitchNode00 () void {
+  # switch (1+4) ... -> goto @lab1
+  switch ( add i32 (constval i32 1, constval i32 4)) @labdft {
+  -2: goto @lab0
+  5: goto @lab1
+  8: goto @lab9 }
+
+  @lab0
+   return (constval i32 1)
+  @labdft
+   return (constval i32 2)
+  @lab9
+   return (constval i32 3)
+  @lab1
+   return (constval i32 4)
+}
+
+func &testConstFoldSwitchNode01 () void {
+  # switch (1 + 10) ... -> goto @labdft
+  switch ( add i32 (constval i32 1, constval i32 10)) @labdft {
+  -2: goto @lab0
+  5: goto @lab1
+  8: goto @lab9 }
+
+  @lab0
+   return (constval i32 1)
+  @labdft
+   return (constval i32 2)
+  @lab9
+   return (constval i32 3)
+  @lab1
+   return (constval i32 4)
+}
+
+func &testConstFoldSwitchNode02 (var %a i32) void {
+  # switch (5 + (5 - a)) ... -> switch (10 - a) ...
+  switch (add i32 (
+    constval i32 5,
+    sub i32 (constval i32 5, dread i32 %a))) @labdft {
+  -2: goto @lab0
+  5: goto @lab1
+  8: goto @lab9 }
+
+  @lab0
+   return (constval i32 1)
+  @labdft
+   return (constval i32 2)
+  @lab9
+   return (constval i32 3)
+  @lab1
+   return (constval i32 4)
+}
+
+
+func &testConstFoldArrayNode00 (var %x i32) void {
+  var %a <* [15][15] i32>
+  # fold indexes -> array ptr <* <[15][15] i32>> (constval i32 0x6, constval i32 0x4)
+  dassign %x (
+    iread i32 <* i32> (
+      array 1 ptr <* [15][15] i32> (addrof ptr %a,
+                                add i32 (constval i32 1, constval i32 5),
+                                sub i32 (constval i32 5, constval i32 1))))
+}
+
+func &testDepositbitsNodeNode00 (var %a i32, var %c i32) i32 {
+  return ( depositbits i32 1 23 (
+             add i32 (
+               add i32 (dread i32 %a, constval i32 0x5),
+               add i32 (
+                 add i32 (constval i32 0x2, dread i32 %c),
+                 add i32 (constval i32 0x4, constval i32 0x2))),
+             add i32 (constval i32 0x4, constval i32 0x8)))
+}
+
+func &testDepositbitsNodeNode01 () i32 {
+  return ( depositbits i32 1 23 (
+             add i32 (
+               add i32 (constval i32 0x5, constval i32 0x5),
+               add i32 (
+                 add i32 (constval i32 0x2, constval i32 0x2),
+                 add i32 (constval i32 0x4, constval i32 0x2))),
+             add i32 (constval i32 0x4, constval i32 0x8)))
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/constFoldTest.expected b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/constFoldTest.expected
new file mode 100644
index 0000000000000000000000000000000000000000..f737a0d29b03c72439fad32cdffe2219a3aaed86
--- /dev/null
+++ b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/constFoldTest.expected
@@ -0,0 +1,508 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
+id 65535
+numfuncs 0
+type $Hello <struct {
+  @h i32,
+  @e i32,
+  @l i32,
+  @o i32}>
+type $Person <struct {
+  @age i32,
+  @extra <$Hello>,
+  @sex u1}>
+func &testSum (var %i i32) i32
+func &testSqrt (var %i i32) f32
+func &testConstVarFold00 (var %a i32) i32
+func &testConstVarFold01 (var %a i32) i32
+func &testConstVarFold02 (var %a i32) i32
+func &testConstVarFold03 (var %a i32) i32
+func &testConstVarFold04 (var %a i32) i32
+func &testConstVarFold05 (var %a i32) i32
+func &testConstVarFold06 (var %a i32) i32
+func &testConstVarFold07 (var %a i32) i32
+func &testConstVarFold08 (var %a i32) i32
+func &testConstVarFold09 (var %a i32) i32
+func &testConstVarFold10 (var %a i32) i32
+func &testConstVarFold11 (var %a i32) i32
+func &testConstVarFold12 (var %a i32) i32
+func &testConstVarFold13 (var %a i32) i32
+func &testConstVarFold15 (var %a i32) i32
+func &testConstVarFold16 (var %a i32) i32
+func &testConstantFoldAdd00 (var %a i32, var %b i32) i32
+func &testConstantFoldAdd01 (var %a i32, var %b i32) i32
+func &testConstVarFold20 (var %a i32) i32
+func &testConstFold0 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold1 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold2 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold3 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold4 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold5 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold6 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold7 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold8 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold9 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold10 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold11 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold12 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold13 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold14 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold15 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFold16 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldDiv0 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldFloor00 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldFloor01 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldFloor02 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldExtractbitsNode00 () i32
+func &testConstFoldExtractbitsNode01 () i32
+func &testConstFoldExtractbitsNode02 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldExtractbitsNode03 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldCompareNode00 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldCompareNode01 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldTernaryNode00 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldTernaryNode01 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldTernaryNode02 (var %a i32, var %b i32, var %c i32) i32
+func &testConstFoldIassignNode00 (var %a i32) void
+func &testConstFoldIassignNode01 (var %a i32) void
+func &testConstFoldIassignNode02 (var %a i32) void
+func &testConstFoldIassignNode03 (var %a i32) void
+func &testConstFoldIassignNode04 (var %a i32) void
+func &testConstFoldIassignNode05 (var %a i32) void
+func &testConstFoldIassignNode06 (var %a i32) void
+func &testConstFoldSwitchNode00 () void
+func &testConstFoldSwitchNode01 () void
+func &testConstFoldSwitchNode02 (var %a i32) void
+func &testConstFoldArrayNode00 (var %x i32) void
+func &testDepositbitsNodeNode00 (var %a i32, var %c i32) i32
+func &testDepositbitsNodeNode01 () i32
+func &testSum (var %i i32) i32 {
+  funcid 0
+  # 1 + 8 -> 9
+  return (constval i32 0x9)
+}
+func &testSqrt (var %i i32) f32 {
+  funcid 0
+  # sqrt(4.0) -> 2.0
+  return (constval f32 2f)
+}
+func &testConstVarFold00 (var %a i32) i32 {
+  funcid 0
+  # 5 + (5 + a) -> a + 10
+  return (add i32 (dread i32 %a, constval i32 0xa))
+}
+func &testConstVarFold01 (var %a i32) i32 {
+  funcid 0
+  # 5 + (5 - a) -> 10 - a
+  return (sub i32 (constval i32 0xa, dread i32 %a))
+}
+func &testConstVarFold02 (var %a i32) i32 {
+  funcid 0
+  # 5 + (a + 5) ->  a + 10
+  return (add i32 (dread i32 %a, constval i32 0xa))
+}
+func &testConstVarFold03 (var %a i32) i32 {
+  funcid 0
+  # 6 + (a - 5) ->  a + 1
+  return (add i32 (dread i32 %a, constval i32 0x1))
+}
+func &testConstVarFold04 (var %a i32) i32 {
+  funcid 0
+  # 5 * (5 * a) -> 5 * (5 * a)
+  return (mul i32 (
+    constval i32 0x5,
+    mul i32 (constval i32 0x5, dread i32 %a)))
+}
+func &testConstVarFold05 (var %a i32) i32 {
+  funcid 0
+  # 5 * (a * 5) -> 5 * (a * 5)
+  return (mul i32 (
+    constval i32 0x5,
+    mul i32 (dread i32 %a, constval i32 0x5)))
+}
+func &testConstVarFold06 (var %a i32) i32 {
+  funcid 0
+  # 3 - (2 - a) -> a + 1
+  return (add i32 (dread i32 %a, constval i32 0x1))
+}
+func &testConstVarFold07 (var %a i32) i32 {
+  funcid 0
+  # 3 - (2 + a) -> 1 - a
+  return (sub i32 (constval i32 0x1, dread i32 %a))
+}
+func &testConstVarFold08 (var %a i32) i32 {
+  funcid 0
+  # 3 - (a + 2) -> 1 - a
+  return (sub i32 (constval i32 0x1, dread i32 %a))
+}
+func &testConstVarFold09 (var %a i32) i32 {
+  funcid 0
+  # 3 - (a - 2) -> 5 - a
+  return (sub i32 (constval i32 0x5, dread i32 %a))
+}
+func &testConstVarFold10 (var %a i32) i32 {
+  funcid 0
+  # (2 + a) - 3 -> a - 1
+  return (sub i32 (dread i32 %a, constval i32 0x1))
+}
+func &testConstVarFold11 (var %a i32) i32 {
+  funcid 0
+  # (2 - a) - 3 -> -a - 1
+  return (sub i32 (
+    neg i32 (dread i32 %a),
+    constval i32 0x1))
+}
+func &testConstVarFold12 (var %a i32) i32 {
+  funcid 0
+  # (a + 2) - 3 -> a - 1
+  return (sub i32 (dread i32 %a, constval i32 0x1))
+}
+func &testConstVarFold13 (var %a i32) i32 {
+  funcid 0
+  #  (a - 2) - 3 -> a - 5
+  return (sub i32 (dread i32 %a, constval i32 0x5))
+}
+func &testConstVarFold15 (var %a i32) i32 {
+  funcid 0
+  # 1 + (5 + ((5 - a) - 3)) -> 8 - a
+  return (sub i32 (constval i32 0x8, dread i32 %a))
+}
+func &testConstVarFold16 (var %a i32) i32 {
+  funcid 0
+  # 1 + (5 + ((5 - a) * 3)) -> ((5 - a) * 3) + 6
+  return (add i32 (
+    mul i32 (
+      sub i32 (constval i32 0x5, dread i32 %a),
+      constval i32 0x3),
+    constval i32 0x6))
+}
+func &testConstantFoldAdd00 (var %a i32, var %b i32) i32 {
+  funcid 0
+  # (-a) + b --> (-a) + b
+  return (add i32 (
+    neg i32 (dread i32 %a),
+    dread i32 %b))
+}
+func &testConstantFoldAdd01 (var %a i32, var %b i32) i32 {
+  funcid 0
+  #  a + (-b) --> a + (-b)
+  return (add i32 (
+    dread i32 %a,
+    neg i32 (dread i32 %b)))
+}
+func &testConstVarFold20 (var %a i32) i32 {
+  funcid 0
+  # 5.0f + (5 - a) -> same, no folding with floating point numbers
+  return (add f32 (
+    constval f32 5f,
+    sub i32 (constval i32 0x5, dread i32 %a)))
+}
+func &testConstFold0 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((a + 5) + ((2 + c) + (4 + 2))) -> ((a + c) + 13)
+  return (add i32 (
+    add i32 (dread i32 %a, dread i32 %c),
+    constval i32 0xd))
+}
+func &testConstFold1 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((a + 5) + (2 + c)) -> ((a + c) + 7)
+  return (add i32 (
+    add i32 (dread i32 %a, dread i32 %c),
+    constval i32 0x7))
+}
+func &testConstFold2 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((a - 5) - ((b - c) - (4 - 2))) -> ((a - (b - c)) - 3)
+  return (sub i32 (
+    sub i32 (
+      dread i32 %a,
+      sub i32 (dread i32 %b, dread i32 %c)),
+    constval i32 0x3))
+}
+func &testConstFold3 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((a - 5) + ((b - c) - (4 - 2))) -> ((a + (b - c)) - 7)
+  return (sub i32 (
+    add i32 (
+      dread i32 %a,
+      sub i32 (dread i32 %b, dread i32 %c)),
+    constval i32 0x7))
+}
+func &testConstFold4 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((a - 5) - ((4 - 2) - (4 - b))) -> ((a - b) - 3)
+  return (sub i32 (
+    sub i32 (dread i32 %a, dread i32 %b),
+    constval i32 0x3))
+}
+func &testConstFold5 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((5 - a) - ((b - 4) - (4 - b))) -> (((-a) - (b - (-b))) + 13)
+  return (add i32 (
+    sub i32 (
+      neg i32 (dread i32 %a),
+      sub i32 (
+        dread i32 %b,
+        neg i32 (dread i32 %b))),
+    constval i32 0xd))
+}
+func &testConstFold6 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((5 - a) - ((4 - b) - (b - 4))) -> (((-a) - ((-b) - b)) - 3)
+  return (sub i32 (
+    sub i32 (
+      neg i32 (dread i32 %a),
+      sub i32 (
+        neg i32 (dread i32 %b),
+        dread i32 %b)),
+    constval i32 0x3))
+}
+func &testConstFold7 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((a - 5) - ((4 + 2) - (4 - (b - c)))) -> ((a - (b - c)) - 7)
+  return (sub i32 (
+    sub i32 (
+      dread i32 %a,
+      sub i32 (dread i32 %b, dread i32 %c)),
+    constval i32 0x7))
+}
+func &testConstFold8 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((a - 5) - ((4 + 2) - (4 * (b - c)))) -> ((a - (-(4 * (b - c)))) - 11)
+  return (sub i32 (
+    sub i32 (
+      dread i32 %a,
+      neg i32 (mul i32 (
+        constval i32 0x4,
+        sub i32 (dread i32 %b, dread i32 %c)))),
+    constval i32 0xb))
+}
+func &testConstFold9 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((a - 5) - ((4 + 2) - (-(4 - (b - c))))) -> ((a - (-(b - c))) - 15)
+  return (sub i32 (
+    sub i32 (
+      dread i32 %a,
+      neg i32 (sub i32 (dread i32 %b, dread i32 %c))),
+    constval i32 0xf))
+}
+func &testConstFold10 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((4 + 2) * (-(4 - (3 - c)))) -> (6 * ((-c) - 1))
+  return (mul i32 (
+    constval i32 0x6,
+    sub i32 (
+      neg i32 (dread i32 %c),
+      constval i32 0x1)))
+}
+func &testConstFold11 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((4 + 2) * (4 - (3 - c))) -> (6 * (c + 1))
+  return (mul i32 (
+    constval i32 0x6,
+    add i32 (dread i32 %c, constval i32 0x1)))
+}
+func &testConstFold12 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((4 + 2) * (~(4 - (3 - c)))) -> (6 * (~(c + 1)))
+  return (mul i32 (
+    constval i32 0x6,
+    bnot i32 (add i32 (dread i32 %c, constval i32 0x1))))
+}
+func &testConstFold13 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # (5 * (((4 - 2) + (2 & 4)) - (4 - (c | 3)))) -> (5 * ((c | 3) - 2))
+  return (mul i32 (
+    constval i32 0x5,
+    sub i32 (
+      bior i32 (dread i32 %c, constval i32 0x3),
+      constval i32 0x2)))
+}
+func &testConstFold14 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # (5 * (((4 - 2) + (2 & 4)) * (4 - (c | 3)))) -> (5 * (2 * (4 - (c | 3))))
+  return (mul i32 (
+    constval i32 0x5,
+    mul i32 (
+      constval i32 0x2,
+      sub i32 (
+        constval i32 0x4,
+        bior i32 (dread i32 %c, constval i32 0x3)))))
+}
+func &testConstFold15 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((1 + 0) * (~(4 - (0 * c)))) -> (~4)
+  return (constval i32 0xfffffffffffffffb)
+}
+func &testConstFold16 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ((~(4 - (c * 0))) * (1 + 0)) -> (~4)
+  return (constval i32 0xfffffffffffffffb)
+}
+func &testConstFoldDiv0 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # (5 / 0) * (1 + 1) -> 2
+  return (constval i32 0x2)
+}
+func &testConstFoldFloor00 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # (floor(4.25) + c) * (1 + 1) -> (c + 4) * 2
+  return (mul i32 (
+    add i32 (dread i32 %c, constval i32 0x4),
+    constval i32 0x2))
+}
+func &testConstFoldFloor01 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # (floor(4.25) + 2) * (1 + 1) -> 12
+  return (constval i32 0xc)
+}
+func &testConstFoldFloor02 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # floor((floor(4.25) + 1) + (1 + a)) -> floor(a + 6)
+  return (floor i32 i32 (add i32 (dread i32 %a, constval i32 0x6)))
+}
+func &testConstFoldExtractbitsNode00 () i32 {
+  funcid 0
+  # 487 = 00111100111
+  # extractbits i32 6 5 (487) = 7 = 0111
+  return (constval i32 0x7)
+}
+func &testConstFoldExtractbitsNode01 () i32 {
+  funcid 0
+  # 487 = 00111100111
+  # extractbits i32 4 5 (487) = -2 = 0xfffffffffffffffe
+  return (constval i32 0xfffffffffffffffe)
+}
+func &testConstFoldExtractbitsNode02 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # 487 = 00111100111
+  # extractbits i32 4 5 (487) = -2 = 0xfffffffffffffffe
+  # extractbits((extractbits(487) + 1) + (1 + a)) -> extractbits(a)
+  return (extractbits i32 4 5 (dread i32 %a))
+}
+func &testConstFoldExtractbitsNode03 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # 487 = 00111100111
+  # extractbits i32 6 5 (487) = 7 = 0111
+  # extractbits((extractbits(487) + 1) + (1 + a)) -> extractbits(a + 9)
+  return (extractbits i32 6 5 (add i32 (dread i32 %a, constval i32 0x9)))
+}
+func &testConstFoldCompareNode00 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # (ge(6, 2) + 1) + (1 + 2) -> 5
+  return (constval u1 0x5)
+}
+func &testConstFoldCompareNode01 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # ge((ge(6, 2) + 1), (1 + a)) -> ge(2, a + 1)
+  return (ge i32 i32 (
+    constval u1 0x2,
+    add i32 (dread i32 %a, constval i32 0x1)))
+}
+func &testConstFoldTernaryNode00 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # (6 > 2 ? 5 : 0) + (1 + 2) -> 8
+  return (constval i32 0x8)
+}
+func &testConstFoldTernaryNode01 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # (6 > 10 ? 5 : 0) + (1 + a) -> (a + 1)
+  return (add i32 (dread i32 %a, constval i32 0x1))
+}
+func &testConstFoldTernaryNode02 (var %a i32, var %b i32, var %c i32) i32 {
+  funcid 0
+  # 6 > a ? (1 + 6) + (1 + a) : 0 -> 6 > a ? a + 8 : 0
+  return (select i32 (
+    ge i32 i32 (constval i32 0x6, dread i32 %a),
+    add i32 (dread i32 %a, constval i32 0x8),
+    constval i32 0x0))
+}
+func &testConstFoldIassignNode00 (var %a i32) void {
+  funcid 0
+  # this is equivalent to dassign %a 0 (constval i32 0x6)
+  dassign %a 0 (constval i32 0x6)
+}
+func &testConstFoldIassignNode01 (var %a i32) void {
+  funcid 0
+  var %bob <$Person>
+  # this is equivalent to dassign %bob 5 (constval i32 0x6)
+  dassign %bob 5 (constval i32 0x6)
+}
+func &testConstFoldIassignNode02 (var %a i32) void {
+  funcid 0
+  # this is equivalent to dassign %a 0 (constval i32 0x6)
+  dassign %a 0 (constval i32 0x6)
+}
+func &testConstFoldIassignNode03 (var %a i32) void {
+  funcid 0
+  var %bob <$Person>
+  # this is equivalent to dassign %bob 5 (constval i32 0x6)
+  dassign %bob 5 (constval i32 0x6)
+}
+func &testConstFoldIassignNode04 (var %a i32) void {
+  funcid 0
+  var %bob <$Person>
+  # this is equivalent to dassign %bob 5 (constval i32 0x6)
+  dassign %bob 5 (constval i32 0x6)
+}
+func &testConstFoldIassignNode05 (var %a i32) void {
+  funcid 0
+  var %b <* i32>
+  dassign %b 0 (addrof ptr %a)
+  # this is equivalent to iassign <* i32> 0 (dread ptr %a, constval i32 0x6)
+  iassign <* i32> 0 (dread ptr %a, constval i32 0x6)
+}
+func &testConstFoldIassignNode06 (var %a i32) void {
+  funcid 0
+  var %bob <$Person>
+  # this is equivalent to dassign %a 0 (dread i32 %bob 1)
+  dassign %a 0 (dread i32 %bob 1)
+}
+func &testConstFoldSwitchNode00 () void {
+  funcid 0
+  # switch (1+4) ... -> goto @lab1
+  goto @lab1
+@lab0   return (constval i32 0x1)
+@labdft   return (constval i32 0x2)
+@lab9   return (constval i32 0x3)
+@lab1   return (constval i32 0x4)
+}
+func &testConstFoldSwitchNode01 () void {
+  funcid 0
+  # switch (1 + 10) ... -> goto @labdft
+  goto @labdft
+@lab0   return (constval i32 0x1)
+@labdft   return (constval i32 0x2)
+@lab9   return (constval i32 0x3)
+@lab1   return (constval i32 0x4)
+}
+func &testConstFoldSwitchNode02 (var %a i32) void {
+  funcid 0
+  # switch (5 + (5 - a)) ... -> switch (10 - a) ...
+  switch (sub i32 (constval i32 0xa, dread i32 %a)) @labdft {
+    -2: goto @lab0
+    5: goto @lab1
+    8: goto @lab9 }
+@lab0   return (constval i32 0x1)
+@labdft   return (constval i32 0x2)
+@lab9   return (constval i32 0x3)
+@lab1   return (constval i32 0x4)
+}
+func &testConstFoldArrayNode00 (var %x i32) void {
+  funcid 0
+  var %a <* <[15][15] i32>>
+  # fold indexes -> array ptr <* <[15][15] i32>> (constval i32 0x6, constval i32 0x4)
+  dassign %x 0 (iread i32 <* i32> 0 (array ptr <* <[15][15] i32>> (constval i32 0x6, constval i32 0x4)))
+}
+func &testDepositbitsNodeNode00 (var %a i32, var %c i32) i32 {
+  funcid 0
+  return (depositbits i32 1 23 (
+    add i32 (
+      add i32 (dread i32 %a, dread i32 %c),
+      constval i32 0xd),
+    constval i32 0xc))
+}
+func &testDepositbitsNodeNode01 () i32 {
+  funcid 0
+  return (constval i32 0x18)
+}
diff --git a/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/expected.mplme.txt b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/expected.txt b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/test.cfg b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0019-mapleall-irbuild-edge-constFoldTest/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/Main.mpl b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..b3a908413eb2eed59812f58d46face8b5c1503f3
--- /dev/null
+++ b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/Main.mpl
@@ -0,0 +1,8 @@
+ func $cvtu64tof32 (
+  var %i u64
+  ) f32 { 
+   return (
+     cvt f32 u64(dread u64 %i))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/cvtu64tof32main.c b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/cvtu64tof32main.c
new file mode 100644
index 0000000000000000000000000000000000000000..7610b6ef691f6f64fa4d20b72bb592babeb88a8b
--- /dev/null
+++ b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/cvtu64tof32main.c
@@ -0,0 +1,8 @@
+extern float cvtu64tof32(unsigned long long int x);
+
+int main(){
+  //printf("%f\n", cvtu64tof32(0xffffffff));
+  //printf("%f\n", cvtu64tof32(0xfffffffffffff));
+  //printf("%f\n", cvtu64tof32(1));
+  printf("%f\n", cvtu64tof32(-1));
+}
diff --git a/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/expected.mplme.txt b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/expected.txt b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/test.cfg b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/Main.mpl b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8cfabdb80ae05938b81b862982b79bb3bcdccb07
--- /dev/null
+++ b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/Main.mpl
@@ -0,0 +1,8 @@
+ func $cvtu64tof64 (
+  var %i u64
+  ) f64 { 
+   return (
+     cvt f64 u64(dread u64 %i))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/cvtu64tof64main.c b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/cvtu64tof64main.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c2e7a63b2557ba653e490c3da68cceb319a3bfa
--- /dev/null
+++ b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/cvtu64tof64main.c
@@ -0,0 +1,14 @@
+extern double cvtu64tof64(unsigned long long int x);
+
+int main(){
+  //printf("%f\n", cvtu64tof32(0xffffffff));
+  //printf("%f\n", cvtu64tof32(0xfffffffffffff));
+  //printf("%f\n", cvtu64tof32(1));
+  printf("%f\n", cvtu64tof64(-1));
+  printf("%f\n", cvtu64tof64(-111111111111111111));
+  printf("%f\n", cvtu64tof64(1343423432));
+  printf("%f\n", cvtu64tof64(44444444444444444444));
+  printf("%f\n", cvtu64tof64(0));
+  printf("%f\n", cvtu64tof64(0xffffffffffffffff));
+  printf("%f\n", cvtu64tof64(1));
+}
diff --git a/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/expected.mplme.txt b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/expected.txt b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/test.cfg b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl b/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..80efe03affd5546fc7b9db7a81a16ba23539695e
--- /dev/null
+++ b/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl
@@ -0,0 +1,10 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     depositbits i32 1 23(
+       constval i32 0xfff, constval i32 0x11))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/expected.mplme.txt b/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/expected.txt b/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/test.cfg b/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/DirectStorageAccess.c b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/DirectStorageAccess.c
new file mode 100644
index 0000000000000000000000000000000000000000..803deea20c742d1dad23c4cad66dfeff699a31b4
--- /dev/null
+++ b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/DirectStorageAccess.c
@@ -0,0 +1,47 @@
+#include <iostream>
+#include <string.h>
+//Define a struct
+typedef struct{
+  char *address;
+  char name[10];
+  int age;
+}People;
+
+typedef struct{
+  int number;
+  People employee;
+}Info;
+
+int main()
+{
+  //direct read and assign
+  //direct read from scalar
+  char a = 'x';
+  char b = a;
+
+  int i = 5;
+  int ii = i;
+  
+  float j = 12.9;
+  float jj = j;
+
+  double k = 20.5;
+  double kk = k;
+  
+  //direct read/write to fields inside a structure
+  //Structure field assign
+  People p, pp;
+  p.age = 25;
+  p.address = NULL;
+  strcpy(p.name,"Huawei");
+
+  //structure field read
+  pp.age = p.age;
+  pp.address = p.address;
+  strcpy(pp.name, p.name);
+
+  Info info, info2;
+  info.employee = p;
+  info2.employee = info.employee;
+  return 1;
+}
diff --git a/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/Main.mpl b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..daf3d347ea19797fdba977e824add6046ea88b6a
--- /dev/null
+++ b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/Main.mpl
@@ -0,0 +1,61 @@
+#This test case covers the following items:
+            
+#MapleIR Direct read/write 
+#Direct acfgrecesses are associated with scalar variables and fixed fields inside 
+#structures. Direct accesses can be mapped to pseudo-register if the variable 
+#or field has no alias.  
+#In MAPLE IR, dassign and dread are the opcodes for direct assignments and 
+#direct references; 
+
+#Syntax
+#dread<prim-type><var-name><field-id>
+#dassign<var-name><field-id>(<rhs-expression>)
+#Type syntax
+#type <id-name><derived-type>
+func $strcpy ( var %dest <*i8>, var %src <*i8> ) <*i8> 
+
+type $People < struct{
+     @name <[10] i8>, 
+     @age i8 }>
+
+type $Info < struct{
+     @number i32,
+     @employee <$People> }>
+
+var $p <$People>
+var $temp<[6] i8>= [ 104, 117, 97, 119, 101, 105 ]
+
+func $main ( )i32 {
+     var %a i8
+     dassign %a ( constval i8 120 )
+     var %b i8
+     dassign %b ( dread i32 %a )
+     var %i i32
+     dassign %i ( constval i32 5 )
+     var %ii i32
+     dassign %ii ( dread i32 %i )
+     var %j f32
+     dassign %j ( constval f32 12.9f )
+     var %jj f32
+     dassign %jj ( dread f32 %j )
+     var %k f64
+     dassign %k ( constval f64 20.5 )
+     var %kk f64
+     dassign %kk ( dread f64 %k )
+     var %p < $People >
+     var %pp < $People >
+     dassign $p 2 ( constval i32 25)
+     # dassign $p 1 ( constval i32 0 )
+     #call <pu-name>(<opnd0>,...,<opndn>)
+     call &strcpy ( addrof a64 %p, addrof a64 $temp)
+     call &strcpy ( addrof a64 %pp, addrof a64 %p)
+     var %info < $Info >
+     var %info2 < $Info >
+     dassign %info 2( dread agg %p )
+     dassign %info2 2( dread agg %info 2)
+     return ( constval i32 444 )
+}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/expected.mplme.txt b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/expected.txt b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/test.cfg b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0023-mapleall-irbuild-edge-DirectStorageAccess/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/Main.mpl b/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..67b210a10c947e8fefa363e1db8c5c391e3bd07d
--- /dev/null
+++ b/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/Main.mpl
@@ -0,0 +1,12 @@
+func $foo (var %i i32) i32 {
+  dowhile {
+    dassign %i (
+      mul i32 (dread i32 %i, dread i32 %i))
+    dassign %i (
+      add i32 (dread i32 %i, constval i32 1) )} (
+        lt i32 i32 ( dread i32 %i, constval i32 10) )
+  return ( constval i32 0 )
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/expected.mplme.txt b/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/expected.txt b/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/test.cfg b/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/Main.mpl b/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..880fd8705f0a5a85ed6f46d5721c1bcb79334cd8
--- /dev/null
+++ b/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/Main.mpl
@@ -0,0 +1,7 @@
+var $g <*ptr>
+var $h <*ptr> = addrof ptr $g
+var $g <*ptr> = addrof ptr $h
+var $h <*ptr>
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/expected.mplme.txt b/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/expected.txt b/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/test.cfg b/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/Main.mpl b/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3a797ae50b147b854397f72ee724e260840ae412
--- /dev/null
+++ b/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/Main.mpl
@@ -0,0 +1,19 @@
+func $foo ( var %i i32 ) i32 
+func $fact ( var %n i32) i32 
+func $fact ( var %n i32) i32 
+func $foo ( var %i i32 ) i32 
+
+func $fact (
+ var %n i32) i32 {
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    call &foo(
+      sub i32 (dread i32 %n, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     return (constval i32 1) } }
+
+func $foo ( var %i i32 ) i32 {
+  return (dread i32 %i) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/expected.mplme.txt b/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/expected.txt b/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/test.cfg b/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/Main.mpl b/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8739173e937d4869d8ea5bf327a6ddbaadbbab8e
--- /dev/null
+++ b/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/Main.mpl
@@ -0,0 +1,7 @@
+var $extern_var extern i32 public
+
+func $test_extern_var ( var %i i32 ) i32 {
+  return (dread i32 $extern_var) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/expected.mplme.txt b/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/expected.txt b/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/test.cfg b/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/Main.mpl b/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..4b33225b45ac0c3615f02dc00297bde74bd6d9ef
--- /dev/null
+++ b/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/Main.mpl
@@ -0,0 +1,83 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     extractbits i32 1 23(
+       constval i32 -998))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     extractbits i32 0 5(dread i32 %i))}
+
+ func $foo11 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) u32 { 
+   return (
+     extractbits u32 0 5(dread i32 %i))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     extractbits i32 3 20(constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     extractbits i64 5 50(dread i64 %i))}
+
+ func $foo4 (
+  var %i i64, var %j i64, var %k i32
+  )i64  { 
+   return (
+     extractbits i64 6 44 (dread i64 %i))}
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     extractbits i64 1 10(constval i64 0x11111))}
+
+ func $foo9 (
+  var %i i8, var %j u8, var %k i32) u32 { 
+   return (
+     extractbits u32 1 31(dread u32 %j))}
+
+ func $foo51 (
+  var %i u64
+  ) u64 { 
+   return (
+     extractbits u64 0 15(constval i64 0x11111))}
+
+ func $foo52 (
+  var %i i32
+  ) i32 { 
+   return (
+     sext i32 11 (constval i32 99))}
+
+ func $foo53 (
+  var %i u64
+  ) u64 { 
+   return (
+     zext u64 11 (constval u64 88))}
+
+ func $foo54 (
+  var %i i32
+  ) i32 { 
+   return (
+     sext i32 11 (dread i32 %i))}
+
+ func $foo55 (
+  var %i u64
+  ) u64 { 
+   return (
+     zext u64 41 (dread u64 %i))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/expected.mplme.txt b/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/expected.txt b/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/test.cfg b/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0028-mapleall-irbuild-edge-extractbits/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/Main.mpl b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..31a0f83b6c8f2854e8adf0bc09555df2d874588b
--- /dev/null
+++ b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/Main.mpl
@@ -0,0 +1,17 @@
+#int fact(int n) {
+#  if (n == 1)
+#    return 1;
+#  return n * fact(n-1);
+#}
+
+func $fact (var %n i32) i32 {
+  if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+       call &fact (sub i32 (dread i32 %n, constval i32 1))
+            return (mul i32 (dread i32 %n, regread i32 %%retval)) 
+             }
+  return (constval i32 1) 
+}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/expected.mplme.txt b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/expected.txt b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/factmain.c b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/factmain.c
new file mode 100644
index 0000000000000000000000000000000000000000..25af761793ad29628b894bdea4d5ccf3a0aa0739
--- /dev/null
+++ b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/factmain.c
@@ -0,0 +1,7 @@
+extern int fact(int n);
+
+int main(void) {
+    printf("%d\n", fact(5));
+      return 0;
+}
+
diff --git a/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/test.cfg b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/Main.mpl b/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a329387a2862f5e25d90e3bbf08806dfe07918d4
--- /dev/null
+++ b/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/Main.mpl
@@ -0,0 +1,18 @@
+# typedef struct { int f1, char f2, unsigned short f3[]} SS;
+# void foo(SS *x, SS *y) {
+#   int i, j;
+#   x->f3[ij] = y->f3[j];
+# }
+
+type $SS <struct {@f1 i32, @f2 i8, @f3 <[] u16>}>
+func $foo ( var %x <*<$SS>>, var %y <*<$SS>>) void {
+  var %i i32
+  var %j i32
+  iassign <* u16> ( array 1 ptr <*[]u16> (
+                iaddrof ptr <* <$SS>> 3 (dread ptr %x), dread i32 %i),
+                iread u16 <* u16> ( array 1 ptr <*[]u16> (
+                    iaddrof ptr <* <$SS>> 3 (dread ptr %y), dread i32 %j)))
+  return()  }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/expected.mplme.txt b/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/expected.txt b/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/test.cfg b/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/Main.mpl b/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..5bb0c2903e534d3fa66d7c2c16a6a0067464d350
--- /dev/null
+++ b/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/Main.mpl
@@ -0,0 +1,38 @@
+fileinfo{ 
+  @magic 345, 
+  @filename "adir/thisisafile.dex",
+  @dexoffset 560,
+  @flags 0x01ef,
+  @linksize 100
+}
+type $SS <class {
+        @real f32,
+        @imag f32}>
+var $sconst1 <class {
+        @classidx 22,
+        @f11 i32,
+        @f22 <$SS>,
+        @f33 i32,
+        @accessflag 0x45e,
+        @classdataoffset 118,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32,
+        @superclassid 3333
+           }>
+func $fact () i32 {
+  funcinfo{ 
+    @funcname "afunc",
+    @registers 345, 
+    @ins 560,
+    @outs 444
+  }
+  return (dread i32 $sconst1 1)
+  funcinfo{ 
+    @funcidx 345, 
+    @classidx 560
+  }
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/expected.mplme.txt b/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/expected.txt b/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/test.cfg b/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/Main.mpl b/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..911d3a1d307e80de543ab6d0bfe28b53c46b3306
--- /dev/null
+++ b/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/Main.mpl
@@ -0,0 +1,13 @@
+ # a function returning (i + j) * -998
+ func $foo (
+# var %i xxx,
+  var %i i32,
+   var %j i32) i32 { 
+   return (
+     mul i32 (
+       add i32 ( dread i32 %i, dread i32 %j), 
+       constval i32 -998))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/expected.mplme.txt b/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/expected.txt b/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/test.cfg b/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/Main.mpl b/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..9e14dbb7d094b91c67fec8de6880f6d23143eef9
--- /dev/null
+++ b/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/Main.mpl
@@ -0,0 +1,29 @@
+ func $floorf64toi32 (
+  var %i f64
+  ) i32 { 
+   return (
+     floor i32 f64(dread f64 %i))}
+
+ func $floorf64toi64 (
+  var %i f64
+  ) i64 { 
+   return (
+     floor i64 f64(dread f64 %i))}
+
+ func $floorf32toi32 (
+  var %i f32
+  ) i32 { 
+   return (
+     floor i32 f32(dread f32 %i))}
+
+
+ func $floorf32toi64 (
+  var %i f32
+  ) i64 { 
+   return (
+     floor i64 f32(dread f32 %i))}
+
+# todo float floor
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/expected.mplme.txt b/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/expected.txt b/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/test.cfg b/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/Main.mpl b/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3a903d4dfd942181c787ac7bbe5183f6f39c0e89
--- /dev/null
+++ b/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/Main.mpl
@@ -0,0 +1,14 @@
+var $arr1 <[10] f32>
+
+func $ArrayAdd () f32 {
+ var %ff i32
+ var %sum f32
+ dassign %sum ( constval f32 0.0f )
+ foreachelem %ff $arr1 { 
+   dassign %sum ( add f32 ( dread f32 %sum, dread f32 %ff ) )
+ }
+ return ( dread f32 %sum ) 
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/expected.mplme.txt b/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/expected.txt b/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/test.cfg b/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/Main.mpl b/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..f84b8d638026709ef8f764f798d49cefa5f40550
--- /dev/null
+++ b/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/Main.mpl
@@ -0,0 +1,10 @@
+var $test_var i32 public
+
+func $test_extern_var ( var %i i32 ) i32 {
+  return (dread i32 $test_var) 
+}
+
+var $test_var i32 public = 0
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/expected.mplme.txt b/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/expected.txt b/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/test.cfg b/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/Main.mpl b/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..20e537607e60a307e1a9f6d4046efdfbe7292903
--- /dev/null
+++ b/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/Main.mpl
@@ -0,0 +1,12 @@
+func $fact (
+ var %n i32) i32 {
+ var %foo <func(i32) i32>
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    icall ( dread a64 %foo,
+      sub i32 (dread i32 %n, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/expected.mplme.txt b/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/expected.txt b/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/test.cfg b/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/Main.mpl b/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..d3875879ee5b2321a4c34fd2828552cc283e5549
--- /dev/null
+++ b/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/Main.mpl
@@ -0,0 +1,31 @@
+type $ss1 <struct {@b <!T>,
+                       @x <* f32>}>
+type $ss2 <struct {@b1 <struct {@b <!SS>, 
+                                    @x <* f32>}>,
+                       @pa <* <struct {@b f64, 
+                                       @x <* f32>}>>, 
+                       @x1 <[10] f64>,
+                       @dx <!U>}>
+type $ss3 <[] <!AAA>>
+func &foo (var %x <!W>) i32 { 
+  var %y <!W>
+  dassign %y (dread agg %x)
+  return (dread i32 %y 1)
+}
+var $g <$ss1{!T=i32}>
+var $h <$ss2{!U=i32,!SS=<$ss1{!T=f32}>}>
+func &bar () i32 {
+  var %i i32
+  callinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g )
+  callinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 }
+  virtualcallinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g )
+  virtualcallinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 }
+  superclasscallinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g )
+  superclasscallinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 }
+  interfacecallinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g )
+  interfacecallinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 }
+  return ( dread i32 %i )
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/expected.mplme.txt b/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/expected.txt b/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/test.cfg b/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/Main.mpl b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..37e344e4952365c8ef1546107276b9eb9e6356ac
--- /dev/null
+++ b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/Main.mpl
@@ -0,0 +1,114 @@
+var $g_i8_u <i8>
+var $g_i8 <i8> = 8
+var $g_u8_u <u8>
+var $g_u8 <u8> = 8
+
+var $g_i16_u <i16>
+var $g_i16 <i16> = 16
+var $g_u16_u <u16>
+var $g_u16 <u16> = 16
+
+var $g_i32_u <i32>
+var $g_i32 <i32> = 32
+var $g_u32_u <u32>
+var $g_u32 <u32> = 32
+
+var $g_i64_u <i64>
+var $g_i64 <i64> = 0x123456789a
+var $g_u64_u <u64>
+var $g_u64 <u64> = 0x123456789a
+
+var $g_f32_u <f32>
+var $g_f32 <f32> = 1.2f
+
+var $g_f64_u <f64>
+var $g_f64 <f64> = 2.4
+
+# i8/u8
+func $add_i8_u () i8 { 
+   return (
+     add i32(dread i32 $g_i8_u, constval i32 0))}
+
+func $add_i8 () i8 { 
+   return (
+     add i32(dread i32 $g_i8, constval i32 0))}
+	 
+func $add_u8_u () u8 { 
+   return (
+     add u32(dread u32 $g_u8_u, constval u32 0))}
+
+func $add_u8 () u8 { 
+   return (
+     add u32(dread u32 $g_u8, constval u32 0))}
+	 
+# i16/u16
+func $add_i16_u () i16 { 
+   return (
+     add i32(dread i32 $g_i16_u, constval i32 0))}
+
+func $add_i16 () i16 { 
+   return (
+     add i32(dread i32 $g_i16, constval i32 0))}
+	 
+func $add_u16_u () u16 { 
+   return (
+     add u32(dread u32 $g_u16_u, constval u32 0))}
+
+func $add_u16 () u16 { 
+   return (
+     add u32(dread u32 $g_u16, constval u32 0))}
+	 
+# i32/u32
+func $add_i32_u () i32 { 
+   return (
+     add i32(dread i32 $g_i32_u, constval i32 0))}
+
+func $add_i32 () i32 { 
+   return (
+     add i32(dread i32 $g_i32, constval i32 0))}
+	 
+func $add_u32_u () u32 { 
+   return (
+     add u32(dread u32 $g_u32_u, constval u32 0))}
+
+func $add_u32 () u32 { 
+   return (
+     add u32(dread u32 $g_u32, constval u32 0))}
+	 
+# i64/u64
+func $add_i64_u () i64 { 
+   return (
+     add i64(dread i64 $g_i64_u, constval i64 0))}
+
+func $add_i64 () i64 { 
+   return (
+     add i64(dread i64 $g_i64, constval i64 0))}
+	 
+func $add_u64_u () u64 { 
+   return (
+     add u64(dread u64 $g_u64_u, constval u64 0))}
+
+func $add_u64 () u64 { 
+   return (
+     add u64(dread u64 $g_u64, constval u64 0))}
+	 
+# # f32
+# func $add_f32_u () f32 { 
+   # return (
+     # add f32(dread f32 $g_f32_u, constval f32 0.0f))}
+
+# func $add_f32 () f32 { 
+   # return (
+     # add f32(dread f32 $g_f32, constval f32 0.0f))}
+	 
+# # f64
+# func $add_f64_u () f64 { 
+   # return (
+     # add f64(dread f64 $g_f64_u, constval f64 0))}
+
+# func $add_f64 () f64 { 
+   # return (
+     # add f64(dread f64 $g_f64, constval f64 0))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/expected.mplme.txt b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/expected.txt b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/global.mpl.c b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/global.mpl.c
new file mode 100644
index 0000000000000000000000000000000000000000..584ef81e2f4da6db7756844f221c88ebd056ec02
--- /dev/null
+++ b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/global.mpl.c
@@ -0,0 +1,127 @@
+#include<stdio.h>
+extern char add_i8_u();
+extern char add_i8();
+extern unsigned char add_u8_u();
+extern unsigned char add_u8();
+
+extern short add_i16_u();
+extern short add_i16();
+extern unsigned short add_u16_u();
+extern unsigned short add_u16();
+
+extern int add_i32_u();
+extern int add_i32();
+extern unsigned int add_u32_u();
+extern unsigned int add_u32();
+
+extern long long add_i64_u();
+extern long long add_i64();
+extern unsigned long long add_u64_u();
+extern unsigned long long add_u64();
+
+extern float add_f32_u();
+extern float add_f32();
+
+extern double add_f64_u();
+extern double add_f64();
+
+int main(){
+  char g_i8_u = add_i8_u();
+  char g_i8 = add_i8();
+  unsigned char g_u8_u = add_u8_u();
+  unsigned char g_u8 = add_u8();
+  short g_i16_u = add_i16_u();
+  short g_i16 = add_i16();
+  unsigned short g_u16_u = add_u16_u();
+  unsigned short g_u16 = add_i16();
+  int g_i32_u = add_i32_u();
+  int g_i32 = add_i32();
+  unsigned int g_u32_u = add_u32_u();
+  unsigned int g_u32 = add_u32();
+  
+  long long g_i64_u = add_i64_u();
+  long long g_i64 = add_i64();
+  unsigned long long g_u64_u = add_u64_u();
+  unsigned long long g_u64 = add_u64();
+  
+  // float g_f32_u = add_f32_u();
+  // float g_f32 = add_f32();
+  
+  // double g_f64_u = add_f64_u();
+  // double g_f64 = add_f64();
+  // i8/u8
+  printf("%d\n",g_i8_u);
+  printf("%d\n",g_i8);
+  if (8 != g_i8) {
+    printf("FAIL : g_i8 is not correct\n");
+    return 1;
+  }
+  printf("%d\n",g_u8_u);
+  printf("%d\n",g_u8);
+  if (8 != g_u8) {
+    printf("FAIL : g_i8 is not correct\n");
+    return 1;
+  }
+  
+  // i16/u16
+  printf("%d\n",g_i16_u);
+  printf("%d\n",g_i16);
+  if (16 != g_i16) {
+    printf("FAIL : g_i16 is not correct\n");
+    return 1;
+  }
+  printf("%d\n",g_u16_u);
+  printf("%d\n",g_u16);
+  if (16 != g_u16) {
+    printf("FAIL : g_u16 is not correct\n");
+    return 1;
+  }
+  
+  // i32/u32
+  printf("%d\n",g_i32_u);
+  printf("%d\n",g_i32);
+  if (32 != g_i32) {
+    printf("FAIL : g_i32 is not correct\n");
+    return 1;
+  }
+  printf("%d\n",g_u32_u);
+  printf("%d\n",g_u32);
+  if (32 != g_u32) {
+    printf("FAIL : g_u32 is not correct\n");
+    return 1;
+  }
+  
+  // i64/u64
+  printf("%lld\n",g_i64_u);
+  printf("0x%llx\n",g_i64);
+  if (0x123456789a != g_i64) {
+    printf("FAIL : g_i64 is not correct\n");
+    return 1;
+  }
+  printf("%lld\n",g_u64_u);
+  printf("0x%llx\n",g_u64);
+  if (0x123456789a != g_u64) {
+    printf("FAIL : g_u64 is not correct\n");
+    return 1;
+  }
+  
+  // // f32
+  // printf("%f\n",g_f32_u);
+  // printf("%f\n",g_f32);
+  // if (1.2f != g_f32) {
+    // printf("FAIL : g_f32 is not correct\n");
+    // return 1;
+  // }
+
+  // // f64
+  // printf("%lf\n",g_f64_u);
+  // printf("%lf\n",g_f64);
+  // if (2.4 != g_f64) {
+    // printf("FAIL : g_f64 is not correct\n");
+    // return 1;
+  // }
+  
+  printf("PASS : Scalar global variables initialization test.\n");
+  
+  return 0;
+}
diff --git a/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/test.cfg b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0038-mapleall-irbuild-edge-global/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/Main.mpl b/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..6983956b7ccf14a7801288ec8887bf70579dbfc1
--- /dev/null
+++ b/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/Main.mpl
@@ -0,0 +1,11 @@
+var $const1 <[13] i8> = [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 10, 0 ]
+func $printf (var %p1 <* i8>)void
+func $main ( ) i32 {
+   call &printf (addrof a32 $const1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/expected.mplme.txt b/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/expected.txt b/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/test.cfg b/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/Main.mpl b/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..0a253eb2ee7cc4a4b61403d9a4c2734562f855ba
--- /dev/null
+++ b/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/Main.mpl
@@ -0,0 +1,24 @@
+func $fact (
+ var %n i32) i32 {
+ var %foo <func(i32) i32>
+ var %r1 i32
+ var %r2 i32
+ var %r3 i32
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    icallassigned ( dread a64 %foo,
+      sub i32 (dread i32 %n, constval i32 1)) {
+      dassign %r1 0
+    }
+    # Not correct, but for parse and dump test.
+    icallassigned ( dread a64 %foo,
+      sub i32 (dread i32 %n, constval i32 1)) {
+      dassign %r1 1
+      dassign %r2 2
+      dassign %r3 3
+    }
+    return (dread i32 %n)
+  }
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/expected.mplme.txt b/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/expected.txt b/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/test.cfg b/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/Main.mpl b/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..cf4e726d1e75fab5eeec53aa40476ff0470a8ec4
--- /dev/null
+++ b/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/Main.mpl
@@ -0,0 +1,13 @@
+#int fact (int n) {
+#  if(n != 1)
+#    return foo(n - 1);
+#  else return 1;
+#}
+
+func $fact (
+ var %n i32) i32 {
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+     return (constval i32 0) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/expected.mplme.txt b/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/expected.txt b/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/test.cfg b/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/Main.mpl b/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..640bba9d4007aff19ef3460b6c74d17c05b3d301
--- /dev/null
+++ b/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/Main.mpl
@@ -0,0 +1,15 @@
+#int fact (int n) {
+#  if(n != 1)
+#    return foo(n - 1);
+#  else return 1;
+#}
+
+func $fact (
+ var %n i32) i32 {
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+     return (constval i32 0) } 
+ else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/expected.mplme.txt b/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/expected.txt b/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/test.cfg b/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/Main.mpl b/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..7d4bd99632214a9fe0305f2eab1400df55637c22
--- /dev/null
+++ b/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/Main.mpl
@@ -0,0 +1,21 @@
+type $atyp <[10] f32>
+var $fff <i32> = 7789
+func $foo ( var %i i32 )i32 
+type $i32ty <struct {
+      @FF1 i32,
+      @FF2 f64 }>
+
+func $fact (
+ var %n i32, var %m f32) i32 {
+ var %alocal <$i32ty>
+ dassign %alocal (constval i32 999)
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    eval (dread i32 %n)
+    call &foo(
+      add i32 (dread i32 %n, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
\ No newline at end of file
diff --git a/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/expected.mplme.txt b/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/expected.txt b/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/test.cfg b/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/Main.mpl b/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a6810f4fe2fd556964c776f3e9bd713f9a3aadbb
--- /dev/null
+++ b/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/Main.mpl
@@ -0,0 +1,11 @@
+importpath "."
+importpath ".."
+importpath "../ff"
+var $x i32
+importpath "/a/bb/ccc/"
+func $foo (var %y i32) void {
+  dassign $x (dread i32 %y)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/expected.mplme.txt b/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/expected.txt b/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/test.cfg b/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/Main.mpl b/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..743f6913fa4ad0756e9812d8b312871e93ca51e4
--- /dev/null
+++ b/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/Main.mpl
@@ -0,0 +1,12 @@
+var $p <* i32>
+func $Foo (var %i i32) void {
+ iassign <* i32>(
+    dread a64 $p,
+    add i32(
+     iread i32 <* i32> ( dread a64 $p ), 
+     dread i32 %i))
+  return() 
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/expected.mplme.txt b/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/expected.txt b/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/test.cfg b/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/InDirectStorageAccess.c b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/InDirectStorageAccess.c
new file mode 100644
index 0000000000000000000000000000000000000000..f857f2abd815cb139eb1960a58cfd75f05d38c87
--- /dev/null
+++ b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/InDirectStorageAccess.c
@@ -0,0 +1,78 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct{
+  char *name;
+  int *number;
+}People;
+
+int addition(int a, int b)
+{
+  return a+b;
+}
+int main()
+{
+  //pointers
+  //reference 
+  char *cPtr = NULL;
+  char name[] = "Huawei";
+  cPtr = name;
+  
+  //Pointer arithematic
+  char cPtr1 = *cPtr++;
+  char *cPtr2 = ++cPtr;
+    
+  //dereference
+  int *iPtr1, *iPtr2;
+  *iPtr1 = 10;
+  *iPtr2 = *iPtr1;
+
+  People *sPtr;
+  sPtr = new People();
+  strcpy(sPtr->name, "huawei");
+  *(sPtr->number) = 5;
+
+  //arrays
+  int i, j;
+  int aPtr1[10];
+  int aPtr2[10][10];
+  int aPtr3[10][10][10];
+
+  //1D array
+  for(i=0;i<10;i++){
+    aPtr1[i] = 10; //constant
+    aPtr1[i] = i;  //varaible
+    aPtr1[i] = *iPtr1; //pointer dereference
+  }  
+
+  //2D array
+  for(i=0;i<10;i++){
+    for(j=0;j<10;j++){
+      aPtr2[i][j] = 10;      //constant value
+      aPtr2[i][j] = i*j;     //variable arithmatic
+      aPtr2[i][j] = aPtr1[(i*j)%10]; //pointer access
+    }
+  }
+  
+  //3D array
+  int k;
+  for(i=0;i<10;i++){
+    for(j=0;j<10;j++){
+      for(k=0;k<10;k++){
+	aPtr3[i][j][k] = 10;
+	aPtr3[i][j][k] = i*j*k;
+	aPtr3[i][j][k] = aPtr2[i][j]*10;
+      }
+    }
+  }
+  
+  //function pointer
+  int (*fPtr1)(int, int);
+  int (*fPtr2)(int, int);
+  fPtr1 = addition;
+  fPtr2 = &addition;
+  int result = fPtr1(2,3);
+      
+  return result;
+}
diff --git a/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/Main.mpl b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..7abf80f7dd59d7f1a0f09af448f8e3ef9340269d
--- /dev/null
+++ b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/Main.mpl
@@ -0,0 +1,191 @@
+#indirect access are associated with pionters and arrays
+#iassign<type><field-id>(<addr-expr>, <rhs-expr>)
+# type gives the high level type of <addr-expr> and must be a pointer type
+# <addr-expr> is computed to return an address
+# <rhs-expr> return a value
+#iread<prim-type><type><field-id>(<addr-expr>)
+# 
+func $new ( var %n i32 )a64 
+func $strcpy ( var %dest <*i8>, var %src <*i8> )<*i8> 
+type $People < struct{
+     @name < * i8 >,
+     @number < * i32> }>
+func $addition ( var %a i32, var %b i32 )i32 {
+     return(
+	add i32( dread i32 %a, dread i32 %b ))}
+var $name < [6] i8 > = [ 104, 117, 97, 119, 101, 105 ]
+var $temp<[6] i8> = [ 104, 117, 97, 119, 101, 105 ]
+func $main ( ) i32 {
+     var %cPtr < * i8 >
+     dassign %cPtr ( constval a64 0)
+     dassign %cPtr (
+     	     addrof a64 $name)
+     
+     var %cPtr1 i8
+     dassign %cPtr1(
+     	     iread i32 < * i8 >( dread a64 %cPtr ))
+     dassign %cPtr(
+     	     add u64(
+	     	 dread a64 %cPtr,
+		 constval u64 1))
+     var %cPtr2 <* i8>
+     dassign %cPtr2(
+     	     add u64(
+	     	 dread a64 %cPtr,
+		 constval u64 1))
+     
+     var %iPtr1 <* i32 >
+     var %iPtr2 <* i32 >	     
+     iassign < * i32>(
+     	     dread a64 %iPtr1,
+	     constval i32 10)
+     iassign < * i32 >(
+     	     dread a64 %iPtr2,
+	     iread i32 < * i32> (
+	     	   dread a64 %iPtr1))
+     var %sPtr <* $People >
+     #call $new(
+     #	  iread <>)
+     call &new (constval u32 128)
+     dassign %sPtr(
+         regread a64 %%retval
+         )
+     call &strcpy ( dread a64 %sPtr 0 ,
+     	  	    addrof a64 $temp)               
+     iassign <* i32>(
+     	     dread a64 %sPtr 0,
+	     constval i32 5)
+     var %i i32
+     var %j i32
+     var %aPtr1 < [10] i32 >
+     var %aPtr2	< [10][10] i32 >  
+     var %aPtr3	< [10][10][10] i32 >
+     dassign %i ( constval i32 0 )
+     while(
+       lt i32 i32 ( dread i32 %i, constval i32 10 )){
+       	  iassign < *[10] i32 >(
+	  	  array 1 a64 < *[10] i32 >(addrof a64 %aPtr1, 
+		  		          dread i32 %i),
+                  constval i32 10 )
+
+          iassign< *[10] i32 >(
+	  	  array 1 a64 < *[10] i32 >( addrof a64 %aPtr1,
+		  	                   dread i32 %i),
+		  dread i32 %i )
+
+          iassign < *[10] i32 >(
+	  	  array 1 a64 < *[10] i32 >( addrof a64 %aPtr1,
+		  	      	    	   dread i32 %i ),
+		  iread i32 <* i32 >(
+		  	addrof a64 %aPtr1 ))
+       dassign %i(
+	 	 add i32(
+		     dread i32 %i,	
+		     constval i32 1))}
+
+
+     dassign %i ( constval i32 0 )
+     while(
+	lt i32 i32 ( dread i32 %i, constval i32 10 )){
+	dassign %j ( constval i32 0 )
+	while(
+		lt i32 i32 ( dread i32 %j, constval i32 10 )){
+		   iassign < *[10][10] i32 >( 
+		   	   array 1 a64 < *[10][10] i32 >( addrof a64 %aPtr2,
+		   	   	 dread i32 %i,
+				 dread i32 %j),
+		           constval i32 10 )
+	           iassign < *[10][10] i32 >(
+		   	  array 1 a64< *[10][10] i32 >( addrof a64 %aPtr2,
+			  	dread i32 %i,
+				dread i32 %j),
+			  mul i32 (
+			      dread i32 %i,
+			      dread i32 %j))
+		   iassign< *[10][10] i32 >(
+		   	    array 1 a64 < *[10][10] i32 >( addrof a64 %aPtr2,
+			    	  dread i32 %i,
+				  dread i32 %j),
+		            iread i32 < *[10] i32 >(
+			    	  array 1 a64< *[10] i32 >(
+				  	addrof a64 %aPtr1,
+				  	rem i32 (
+					    mul i32 (
+					    	dread i32 %i,
+						dread i32 %j),
+					    constval i32 10))))
+                dassign %j(
+			add i32(
+		 	    dread i32 %j,	
+		     	    constval i32 1))}
+     dassign %i(
+     	     add i32(
+	     	 dread i32 %i,	
+		 constval i32 1))}
+     var %k i32
+     dassign %i ( constval i32 0)
+     while(
+	lt i32 i32 ( dread i32 %i, constval i32 10 )){
+	dassign %j ( constval i32 0)
+	while(
+	lt i32 i32 ( dread i32 %j, constval i32 10)){
+	   while(
+		lt i32 i32 ( dread i32 %k, constval i32 10)){
+		iassign < *[10][10][10] i32 >(
+			array 1 a64 < *[10][10][10] i32 >(addrof a64 %aPtr3,
+			dread i32 %i, 
+			dread i32 %j,
+			dread i32 %k),
+			constval i32 10)
+		iassign < *[10][10][10] i32 >(
+			array 1 a64 < *[10][10][10] i32>(addrof a64 %aPtr3,
+			dread i32 %i, 
+			dread i32 %j,
+			dread i32 %k),
+			mul i32 (
+			    mul i32 (
+			    	dread i32 %i,
+				dread i32 %j),
+			    dread i32 %k))
+	        iassign < *[10][10][10] i32 >(
+			array 1 a64 < *[10][10][10] i32 >(addrof a64 %aPtr3,
+			dread i32 %i, 
+			dread i32 %j,
+			dread i32 %k),
+			mul i32 (
+			    iread i32 < *[10][10] i32>(
+			    	  array 1 a64 <*[10][10] i32>( addrof a64 %aPtr1,
+				  dread i32 %i,
+				  dread i32 %j)),
+				  constval i32 10))
+ 		dassign %k(
+			add i32(
+			    dread i32 %k,
+			    constval i32 1))}
+         dassign %j(
+	 	 add i32(
+		     dread i32 %j,	
+		     constval i32 1))}
+    dassign %i(
+    	    add i32(
+	    	dread i32 %i,	
+		constval i32 1))}
+    
+    var %fPtr1 <func( i32, i32) i32 >
+    var %fPtr2 <func( i32, i32) i32 >
+    
+    dassign %fPtr1(
+          addrof a64 $addition)
+    dassign %fPtr2(
+          addrof a64 $addition)
+    var %result i32
+    icall ( dread a64 %fPtr1, constval i32 2, constval i32 3)
+    dassign %result(
+    	    regread i32 %%retval)
+    return ( dread i32 %result)}
+			
+    
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/expected.mplme.txt b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/expected.txt b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/test.cfg b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0046-mapleall-irbuild-edge-InDirectStorageAccess/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/Main.mpl b/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..f4c0354e7f513018cdfffc17dc64f8cd1a7b09c0
--- /dev/null
+++ b/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/Main.mpl
@@ -0,0 +1,9 @@
+type $I1 <interface {@g0 i32}>
+type $I2 <interfaceincomplete {@g1 i32}>
+type $RR <interface <$I1> <$I2> {@e1 i32, &method1(agg)agg, &method2(void)void}>
+javainterface $UU <$RR> public static
+type $CC <interface {@h0 i32}>
+type $TT <class <$CC> {@f1 i32, @f2 i8, @f3 i8, $I1, $I2, $RR}>
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/expected.mplme.txt b/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/expected.txt b/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/test.cfg b/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/Main.mpl b/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..02dfd61c5161647183736fddc408c1032e8cab79
--- /dev/null
+++ b/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/Main.mpl
@@ -0,0 +1,13 @@
+srclang 3
+type $SS <struct {@f1 i32, @f2 i8, @f3 <[] u16>}>
+func $foo ( var %x <*<$SS>>, var %y <*<$SS>>) void {
+  var %i i32
+  var %j i32
+  iassign <* u16> ( array 1 ptr <*[]u16> (
+                iaddrof ptr <* <$SS>> 3 (dread ptr %x), dread i32 %i),
+                iread u16 <* u16> ( array 1 ptr <*[]u16> (
+                    iaddrof ptr <* <$SS>> 3 (dread ptr %y), dread i32 %j)))
+  return()  }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/expected.mplme.txt b/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/expected.txt b/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/test.cfg b/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/Main.mpl b/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..1a95394d113ffa191e4887dfe1fd0b536d2389c3
--- /dev/null
+++ b/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/Main.mpl
@@ -0,0 +1,10 @@
+type $atyp <[10] f32>
+var $fff <i32> = 7789
+func $foo ( var %i i32 )i32 
+
+func $fact (
+ var %n i32, var %m f32) void {
+  return () }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/expected.mplme.txt b/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/expected.txt b/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/test.cfg b/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/Main.mpl b/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a69899900b708d617827eb390e793be96bb06431
--- /dev/null
+++ b/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/Main.mpl
@@ -0,0 +1,14 @@
+ func $landi32 (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     land i32(dread i32 %i, dread i32 %j))}
+
+ func $landi64 (
+  var %i i64, var %j i64
+  ) i32 { 
+   return (
+     land i64(dread i64 %i, dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/expected.mplme.txt b/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/expected.txt b/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/test.cfg b/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/Main.mpl b/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..900ffdf6706556ad56c9170525f2e0a7f332c8ea
--- /dev/null
+++ b/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/Main.mpl
@@ -0,0 +1,14 @@
+ func $liori32 (
+  var %i i32, var %j i32
+  ) i32 { 
+   return (
+     lior i32(dread i32 %i, dread i32 %j))}
+
+ func $liori64 (
+  var %i i64, var %j i64
+  ) i32 { 
+   return (
+     lior i64(dread i64 %i, dread i64 %j))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/expected.mplme.txt b/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/expected.txt b/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/test.cfg b/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/Main.mpl b/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..84b8db30091eeeb9ba22d273cdad94f6a7d5c0c6
--- /dev/null
+++ b/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/Main.mpl
@@ -0,0 +1,37 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     lnot i32(dread i32 %i))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     lnot i32(dread i32 %i))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     lnot i32(constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     lnot i64(dread i64 %i))}
+
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     lnot i64(constval i64 0x11111))}
+
+# todo float lnot
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/expected.mplme.txt b/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/expected.txt b/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/test.cfg b/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl b/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3b8711cb5f6b2307bf4a3e30da208114bc67be4a
--- /dev/null
+++ b/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl
@@ -0,0 +1,22 @@
+# float a[10];
+# void init(void) {
+#   int i;
+#   for (i=0; i<10; i++)
+#     a[i] = i*3;
+# }
+
+var $a <[10] f32>
+var $f1 f32
+func $init () void {
+  var %i i32
+  dassign %i ( constval i32 0 )
+  while (
+    lt i32 i32 ( dread i32 %i, constval i32 10) ) {
+      iassign <* [10] f32> (
+        array 1 a32 <* [10] f32> (addrof a32 $a, dread i32 %i),
+	      mul f32 (dread f32 $f1, constval f32 3.33f) ) 
+      dassign %i (
+        add i32 (dread i32 %i, constval i32 1) )} }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/expected.mplme.txt b/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/expected.txt b/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/test.cfg b/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/Main.mpl b/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..9f93b5a3d9b94f69fb189e2aa8609e0e562f288e
--- /dev/null
+++ b/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/Main.mpl
@@ -0,0 +1,12 @@
+func &foo ( var %i i32 ) void {
+   var %p ptr
+   dassign %p ( malloc ptr ( constval i32 8 ))
+   dassign %p ( alloca ptr ( constval i32 16 ))
+   dassign %p ( gcmalloc ref i32 )
+   dassign %p ( gcmallocjarray ref <[] i32> ( constval i32 5 ))
+   free ( dread ref %p)
+}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/expected.mplme.txt b/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/expected.txt b/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/test.cfg b/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/Main.mpl b/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..96ff02f6b439a646334b5bff704ed4d7f77b361e
--- /dev/null
+++ b/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/Main.mpl
@@ -0,0 +1,15 @@
+type $RR <class {
+  @e1 i32, 
+  @e2 f32, 
+  @classname "foo",
+  @e3 f64}>
+type $SS <class <$RR> { @accessflag 1234, 
+                        &method1(agg)agg,
+                        &method2(void)void}>
+func $foo (
+	var %x <$SS>) i32 {
+  dassign %x 2 ( constval i32 32 )
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/expected.mplme.txt b/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/expected.txt b/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/test.cfg b/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/Main.mpl b/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..178efb2aacea200a522e16652939f486bc6bf9d7
--- /dev/null
+++ b/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/Main.mpl
@@ -0,0 +1,21 @@
+func &meth1() void
+func &meth3() i32
+var $sconst1 <struct {
+        @f11 i32,
+        @f22:15 i32,
+        @f33 i32,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32,
+        &meth1 () void,
+        &meth3 (i32, f64) i32 }> = [ 6=10.07f, 2=699, 3=-273, 4=75, 1=31425926, 5=6.02e+23f ]
+func &printf (var %p1 <* i8>)void
+func &main ( ) i32 {
+   call &printf (addrof a32 $sconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/expected.mplme.txt b/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/expected.txt b/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/test.cfg b/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/Main.mpl b/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..bf7891e3f110b036719a3e9487acf6baf492f50b
--- /dev/null
+++ b/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/Main.mpl
@@ -0,0 +1,20 @@
+var $g i32
+var $h i32
+func $multiwayfunc ( var %n i32) i32 {
+ multiway (dread i32 %n) @labdft {
+   (add i32 (dread i32 $g, dread i32 $h)): goto @lab0
+   (dread i32 $h): goto @lab1
+   (constval i32 888): goto @lab0
+   (constval i32 'Y'): goto @lab0
+   (neg i32 (dread i32 $h)) : goto @lab9 }
+@lab0
+ return (constval i32 -3)
+@labdft
+ return (constval i32 100)
+@lab9
+ return (constval i32 9)
+@lab1
+ return (constval i32 1) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/expected.mplme.txt b/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/expected.txt b/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/test.cfg b/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/Main.mpl b/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..de974cbccd567b7c4d3b64835b2104cf7a1d1da1
--- /dev/null
+++ b/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/Main.mpl
@@ -0,0 +1,18 @@
+var $g ptr
+var $h i32
+func $multiwayfunc ( var %p ptr) ptr {
+ multiway (dread ptr %p) @labdft {
+   (dread ptr $g): goto @lab1
+   (add ptr (dread i32 $g, dread i32 $h)): goto @lab0
+   (conststr ptr "world"): goto @lab9 }
+@lab0
+ return (dread ptr $g)
+@labdft
+ return (conststr ptr "hello")
+@lab9
+ return (add ptr (conststr ptr "foo", dread i32 $h))
+@lab1
+ return (addrof ptr $h) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/expected.mplme.txt b/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/expected.txt b/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/test.cfg b/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/Main.mpl b/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..c06bc9c2dc1ae05dea9f5f4fe868265d9c01833e
--- /dev/null
+++ b/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/Main.mpl
@@ -0,0 +1,60 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     neg i32(dread i32 %i))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     neg i32(dread i32 %i))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     neg i32(constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     neg i64(dread i64 %i))}
+
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     neg i64(constval i64 0x11111))}
+
+ func $foo6 (
+  var %i f64
+  ) f64 { 
+   return (
+     neg f64(dread f64 %i))}
+
+ func $foo7 (
+  var %i f32
+  ) f32 { 
+   return (
+     neg f32(dread f32 %i))}
+
+ func $foo8 (
+  var %i f64
+  ) f64 { 
+   return (
+     neg f64(constval f64 -1.24))}
+
+ func $foo9 (
+  var %i f32
+  ) f32 { 
+   return (
+     neg f32(constval f32 -1.24f))}
+# todo float neg
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/expected.mplme.txt b/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/expected.txt b/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/test.cfg b/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/Main.mpl b/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..d10a0c552fb09ee5e75b886b371159aa59d9d2a9
--- /dev/null
+++ b/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/Main.mpl
@@ -0,0 +1,10 @@
+type $RR <class {@e1 i32, ^e2 f32, @e3 f64}>
+type $SS <class <$RR> {^f1 i32, @f2 i8, ^f3 i8}>
+javaclass $TT <$SS> public static
+func &foo (
+	var %x <$SS>) i32 {
+  dassign %x -1 ( constval i32 32 )
+  return ( dread i32 %x -2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/expected.mplme.txt b/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/expected.txt b/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/test.cfg b/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/Main.mpl b/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..693163aa4e9b8647df64e52ee812ac1e311a4351
--- /dev/null
+++ b/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/Main.mpl
@@ -0,0 +1,15 @@
+type $SS <class {@f1 i32, @f2 i8, @f3 i8, &fun(i32) i32}>
+javaclass $TT <$SS> public static
+
+func &bar (var %y i32) i32 {
+  return (dread i32 %y)
+}
+
+func &foo (var %x <$SS>) i32 {
+  var %ret i32
+  polymorphiccallassigned <func(i32) i32> &bar (dread i32 %x 1) {dassign %ret 0}
+  return (dread i32 %ret)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/expected.mplme.txt b/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/expected.txt b/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/test.cfg b/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/Main.mpl b/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..cb0fed58de37945afa50bf4e958e411d7e8d77cd
--- /dev/null
+++ b/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/Main.mpl
@@ -0,0 +1,20 @@
+type $atyp <[10] f32>
+type $aaaa <f32>
+var $fff <$atyp>
+func $foo ( var %i i32 )i32 
+
+func $fact (
+ var %n i32, var %m f32) i32 {
+ regassign i32 %987 (constval i32 '0')
+ if (ne i32 i32 (regread i32 %987, constval i32 10)) {
+    eval (regread i32 %987)
+    call &foo(
+      sub i32 (regread i32 %1, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     regassign i32 %987 (constval i32 111)
+     return (constval i32 '1') } 
+ }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/expected.mplme.txt b/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/expected.txt b/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/test.cfg b/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/Main.mpl b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8222d5e88729be1684f178d5341f398d7ff92176
--- /dev/null
+++ b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/Main.mpl
@@ -0,0 +1,46 @@
+var $myStruct < struct{
+    @number i32,
+    @p <* i8> }>
+func $main ()i32{
+     #Character
+     var %sChar i8
+     var %usChar i8
+     #signed and unsigned short integer
+     var %shortInt i16
+     var %shortInt2 i16
+     var %sShortInt i16
+     var %sShortInt2 i16
+     var %usShortInt i16
+     var %usShortInt2 i16
+     #signed and unsigned integer
+     var %int1 i32
+     var %sInt i32
+     var %usInt i32
+     var %usInt2 i32
+     #signed and unsigned long integer
+     var %long1 i64
+     var %long2 i64
+     var %sLong1 i64
+     var %sLong2 i64
+     var %usLong i64
+     var %usLong2 i64
+     var %lLong1 i64
+     var %iLong2 i64
+     var %sLlong1 i64
+     var %sLlonog2 i64
+     var %usLlong i64
+     var %usLlong2 i64
+     #float
+     var %Float f32
+     #double
+     var %Double f64
+     #long double
+     var %lDouble f64
+     #Address
+     var %array <[10] i8>
+     iassign<* i8>(
+      array 1 a64<*[10] i8>(addrof a64 %array, constval i64 1),
+      constval i32 120)}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/PrimTypes.c b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/PrimTypes.c
new file mode 100644
index 0000000000000000000000000000000000000000..cb2ecce7834ab2c5a5c23366e3b4935e116cb32c
--- /dev/null
+++ b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/PrimTypes.c
@@ -0,0 +1,52 @@
+//This testcase covers all mapleIR's primitive types
+#include <stdio.h>
+#include <stdlib.h>
+
+struct{
+  int number;
+  char *p
+    }myStruct;
+
+int main()
+{
+
+    //Character
+    char sChar;
+    signed char sChar2;
+    unsigned char usChar;
+    //signed and unsigned short Integer
+    short shortInt;
+    short int shortInt2;
+    signed short sShortInt;
+    signed short int sShortInt2;
+    unsigned short usShortInt;
+    unsigned short int usShortInt2;
+    //signed and unsigned integer
+    int int1;
+    signed int sInt;
+    unsigned usInt;
+    unsigned int usInt2;
+    //signed and unsigned long integer
+    long long1;
+    long int long2;
+    signed long sLong1;
+    signed long int sLong2;
+    unsigned long usLong;
+    unsigned long int usLong2;
+    long long lLong1;
+    long long int lLong2;
+    signed long long sLlong1;
+    signed long long int sLlong2;
+    unsigned long long usLlong;
+    unsigned long long usLlong2;
+    //float
+    float Float;
+    //double
+    double Double;
+    //long double
+    long double lDouble;
+    //Address
+    char array[10];
+    array[1] = 'x';
+    return;
+}
diff --git a/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/expected.mplme.txt b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/expected.txt b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/test.cfg b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/Main.mpl b/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..e1f91e8403cba11e0be313b1778910f20a6976ae
--- /dev/null
+++ b/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/Main.mpl
@@ -0,0 +1,27 @@
+ func $foo6 (
+  var %i f64
+  ) f64 { 
+   return (
+     recip f64(dread f64 %i))}
+
+ func $foo7 (
+  var %i f32
+  ) f32 { 
+   return (
+     recip f32(dread f32 %i))}
+
+ func $foo8 (
+  var %i f64
+  ) f64 { 
+   return (
+     recip f64(constval f64 -1.24))}
+
+ func $foo9 (
+  var %i f32
+  ) f32 { 
+   return (
+     recip f32(constval f32 -1.24f))}
+# todo float recip
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/expected.mplme.txt b/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/expected.txt b/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/test.cfg b/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/Main.mpl b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..7ac65fa78234fc15668f4661677acc4ff28ee764
--- /dev/null
+++ b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/Main.mpl
@@ -0,0 +1,26 @@
+ func $retypef64toi64 (
+  var %i f64
+  ) i64 { 
+   return (
+     retype i64 <i64> (dread f64 %i))}
+
+ func $retypei64tof64 (
+  var %i i64
+  ) f64 { 
+   return (
+     retype f64 <f64> (dread i64 %i))}
+
+ func $retypef32toi32 (
+  var %i f32
+  ) i32 { 
+   return (
+     retype i32 <i32> (dread f32 %i))}
+
+ func $retypei32tof32 (
+  var %i i32
+  ) f32 { 
+   return (
+     retype f32 <f32> (dread i32 %i))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/expected.mplme.txt b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/expected.txt b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/retypemain.c b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/retypemain.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c6b7a7d055c515ee20ae6f4984c62aa07f12bc2
--- /dev/null
+++ b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/retypemain.c
@@ -0,0 +1,19 @@
+extern int retypef32toi32(float x);
+extern float retypei32tof32(int x);
+extern long long int retypef64toi64(double x);
+extern double retypei64tof64(long long int x);
+
+int main(void) {
+    union {float f1; int i1;} valf1, valf2;
+    union {double d1; long long int i1;} vald1, vald2;
+    valf1.f1 = 1.2343;
+    valf2.f1 = 22.222;
+    vald1.d1 = 1111111111111.1234343434;
+    vald2.d1 = 222222222222222222.22222222222222;
+    printf("%d vs %d\n", valf1.i1, retypef32toi32(valf1.f1));
+    printf("%f vs %f\n", valf1.f1, retypei32tof32(valf1.i1));
+    printf("%lld vs %lld\n", vald1.i1, retypef64toi64(vald1.d1));
+    printf("%f vs %f\n", vald1.d1,  retypei64tof64(vald1.i1));
+    return 0;
+}
+
diff --git a/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/test.cfg b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/Main.mpl b/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..6a5e4beebaa091088129cf5c4f9b621a9cbfe697
--- /dev/null
+++ b/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/Main.mpl
@@ -0,0 +1,42 @@
+ func $selecti32 (
+  var %i i32,
+   var %j i32,
+   var %k i32) i32 { 
+   return (
+     select i32 (
+      dread i32 %i, 
+      dread i32 %j, 
+      dread i32 %k))}
+
+ func $selecti64 (
+  var %i i32,
+   var %j i64,
+   var %k i64) i64 { 
+   return (
+     select i64 (
+      dread i32 %i, 
+      dread i64 %j, 
+      dread i64 %k))}
+
+ func $selectf32 (
+  var %i i32,
+   var %j f32,
+   var %k f32) f32 { 
+   return (
+     select f32 (
+      dread i32 %i, 
+      dread f32 %j, 
+      dread f32 %k))}
+
+ func $selectf64 (
+  var %i i32,
+   var %j f64,
+   var %k f64) f64 { 
+   return (
+     select f64 (
+      dread i32 %i, 
+      dread f64 %j, 
+      dread f64 %k))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/expected.mplme.txt b/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/expected.txt b/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/test.cfg b/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/Main.mpl b/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..741f792157a2a19c6c36b013260e4b746d45a159
--- /dev/null
+++ b/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/Main.mpl
@@ -0,0 +1,10 @@
+# ;, / and | are allowed name characters, but they cannot be the starting char
+ func $foo (
+  var %i; i32,
+  var %j|/ i32 
+  ) i32 { 
+   return (
+     add i32(dread i32 %i;, dread i32 %j|/))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/expected.mplme.txt b/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/expected.txt b/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/test.cfg b/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/Main.mpl b/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..5ce01267dbaf3f0ef76a58313b389d49e89b76c9
--- /dev/null
+++ b/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/Main.mpl
@@ -0,0 +1,27 @@
+ func $foo6 (
+  var %i f64
+  ) f64 {
+   return (
+     sqrt f64(dread f64 %i))}
+
+ func $foo7 (
+  var %i f32
+  ) f32 {
+   return (
+     sqrt f32(dread f32 %i))}
+
+ func $foo8 (
+  var %i f64
+  ) f64 {
+   return (
+     sqrt f64(constval f64 4.0))}
+
+ func $foo9 (
+  var %i f32
+  ) f32 {
+   return (
+     sqrt f32(constval f32 4.0f))}
+# todo float sqrt
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/expected.mplme.txt b/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/expected.txt b/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/test.cfg b/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/Main.mpl b/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..f8b22e9c384af0e669b22dfb7bb012d9f6ea7bd5
--- /dev/null
+++ b/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/Main.mpl
@@ -0,0 +1,16 @@
+type $SS <struct {
+        @real f32,
+        @imag f32}>
+var $sconst1 <struct {
+        @f11 i32,
+        @f22 <$SS>,
+        @f33 i32,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32}> = [ 1=1007, 2= [1=11.11f, 2=22.22f], 5=-273.0f, 6=75.0f, 4=6023 ]
+func $fact () i32 {
+  return (dread i32 $sconst1 1)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/expected.mplme.txt b/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/expected.txt b/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/test.cfg b/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/Main.mpl b/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..41ff062188c1aedd365c357399d0f84399d9d0de
--- /dev/null
+++ b/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/Main.mpl
@@ -0,0 +1,13 @@
+type $__field_meta__ <struct {
+  @fieldname i32,
+  @offset i32,
+  @declaringclass <* void>,
+  @type <* void>}>
+var $v1 <* void> public
+var $v2 <* void> public
+var $vs <[1] <$__field_meta__>> public = [[1= 0x35ad1b, 2= 0xabcd, 3= addrof ptr $v2, 4= addrof ptr $v1]]
+var $vvs <[2][1] <$__field_meta__>> public = [[[1= 11, 2= 22, 3= addrof ptr $v1, 4= addrof ptr $v1]],
+                                              [[1= 33, 2= 44, 3= addrof ptr $v2, 4= addrof ptr $v2]]]
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/expected.mplme.txt b/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/expected.txt b/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/test.cfg b/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/Main.mpl b/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..84c7a1cebd7852237570d41822cce2f7c25c634f
--- /dev/null
+++ b/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/Main.mpl
@@ -0,0 +1,17 @@
+var $sconst1 <struct {
+        @f11 i32,
+        @f22:15 i32,
+        @f33 i32,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32}> = [ 6=10.07f, 2=699, 3=-273, 4=75, 1=31425926, 5=6.02e+23f ]
+func &printf (var %p1 <* i8>)void
+func &main ( ) i32 {
+   call &printf (addrof a32 $sconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/expected.mplme.txt b/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/expected.txt b/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/test.cfg b/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/Main.mpl b/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..972dfaabacc967135306ac668068391c9d282ad7
--- /dev/null
+++ b/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/Main.mpl
@@ -0,0 +1,17 @@
+# typedef struct ss {
+#   int f1;
+#   char f2:3;
+#   char f3:5;
+# } SS;
+# SS foo(SS x) {
+#   x.f2 = 32;
+#   return x;
+# }
+type $SS <struct {@f1 i32, @f2:3 i8, @f3:5 i8}>
+func $foo (
+	var %x <$SS>) i32 {
+  dassign %x 2 ( constval i32 32 )
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/expected.mplme.txt b/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/expected.txt b/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/test.cfg b/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/Main.mpl b/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8ec155e6f829f1a086a61fa49f3f0df909bddc44
--- /dev/null
+++ b/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/Main.mpl
@@ -0,0 +1,54 @@
+#struct aa{
+#  double b;
+#  float *x;
+#};
+
+#struct bb {
+#  struct aa b1;
+#  struct aa *pa;
+#  double x1[10];
+#  double dx;
+#};
+
+#typedef struct ss {
+#  int f1;
+#  char f2:3;
+#  struct aa a3;
+#  struct aa *pa1;
+#  char f3:5;
+#  struct bb *b3;
+#  struct bb *b2;
+#  struct aa xt[23];
+#  struct aa(* funcc)(int, int, double);
+#}SS;
+
+type $unname1 <struct {@b f64,
+                       @x <* f32>}>
+type $unname2 <struct {@b1 <struct {@b f64, 
+                                    @x <* f32>}>,
+                       @pa <* <struct {@b f64, 
+                                       @x <* f32>}>>, 
+                       @x1 <[10] f64>,
+                       @dx f64}>
+type $SS      <struct {@f1 i32,
+                       @f2:3 i8,
+                       @a3 <structincomplete {@b f64, 
+                                    @x <*f32>}>,
+                       @pa1 <* <struct {@b f64, 
+                                       @x <* f32> } >>,
+                       @f3:5 i32,
+                       @b3 <* <struct {@b1 <struct {@b f64,
+                                                    @x <* f32>}>,
+                                       @pa <* <struct {@b f64,
+                                                       @x <* f32>}>>,
+                                       @x1 <[10] f64>,
+                                       @dx f64}>>,
+                       @b2 <* $unname2>,
+                       @xt <[23] <struct {@b f64, 
+                                          @a <*f32>}>>,
+                       @funcc <func(i32, i32, f64)<struct {@b f64,
+                                                           @x <* f32>}>>}>
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/expected.mplme.txt b/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/expected.txt b/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/test.cfg b/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0073-mapleall-irbuild-edge-struct_type/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/Main.mpl b/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3d75348527b70cb616949e1d317070b8870a1152
--- /dev/null
+++ b/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/Main.mpl
@@ -0,0 +1,64 @@
+ func $foo (
+  var %i i32 
+#var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     sub i32(dread i32 %i, 
+       constval i32 -998))}
+
+ func $foo1 (
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 { 
+   return (
+     sub i32(dread i32 %i, dread i32 %j))}
+
+ func $foo2 (
+  var %i i32, var %j i32, var %k i32
+  ) i32 { 
+   return (
+     sub i32(dread i32 %i, constval i32 0x111111111))}
+
+ func $foo3 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     sub i64(dread i64 %i, constval i64 0x111111111))}
+
+ func $foo4 (
+  var %i i64, var %j i64, var %k i32
+  )i64  { 
+   return (
+     sub i64(dread i64 %i, dread i64 %j))}
+
+ func $foo5 (
+  var %i i64, var %j i64, var %k i32
+  ) i64 { 
+   return (
+     sub i64(dread i64 %i, constval i64 0x11111))}
+
+ func $foo6 (
+  var %i f64, var %j f64, var %k i32
+  ) f64 { 
+   return (
+     sub f64(dread f64 %i, constval f64 2.237))}
+
+ func $foo66 (
+  var %i f64, var %j f64, var %k i32
+  ) f64 {
+   return (
+     sub f64(dread f64 %i, constval f64 2.237))}
+ func $foo7 (
+  var %i f32, var %j f32, var %k i32
+  ) f32 { 
+   return (
+     sub f32(dread f32 %i, dread f32 %j))}
+
+ func $foo8 (
+  var %i f32, var %j f64, var %k i32
+  ) f32 { 
+   return (
+     sub f32(dread f32 %i, constval f32 2.237f))}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/expected.mplme.txt b/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/expected.txt b/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/test.cfg b/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0074-mapleall-irbuild-edge-sub/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/Main.mpl b/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..0a9dd08bb4ddd3d158e662307d60a75bbb85e4fa
--- /dev/null
+++ b/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/Main.mpl
@@ -0,0 +1,20 @@
+type $SS <struct {
+        @real f32,
+        @imag f32}>
+var $sconst1 <struct {
+        @f11 i32,
+        @f22 <$SS>,
+        @f33 i32,
+        @f44 i32,
+        @f55 f32,
+        @f66 f32}> = [ 6=1007.0f, 2= [1=11.11f, 2=22.22f], 3=-273, 4=75, 1=1425926, 5=6023.0f ]
+func $printf (var %p1 <* i8>)void
+func $main ( ) i32 {
+   call &printf (addrof a32 $sconst1)
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/expected.mplme.txt b/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/expected.txt b/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/test.cfg b/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/Main.mpl b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..8750d119201ac691f3c2c067808eb86ec0f2c23b
--- /dev/null
+++ b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/Main.mpl
@@ -0,0 +1,17 @@
+func $switchfunc ( var %n i32) i32 {
+ var %alocal i32
+ switch (dread i32 %n) @labdft {
+   -3: goto @lab0
+   1: goto @lab1
+   9: goto @lab9 }
+@lab0
+ return (constval i32 -3)
+@labdft
+ return (constval i32 100)
+@lab9
+ return (constval i32 9)
+@lab1
+ return (constval i32 1) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/expected.mplme.txt b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/expected.txt b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/switch_main.c b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/switch_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..0b30d2724f21aab6020c8cd770677c39ad14b132
--- /dev/null
+++ b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/switch_main.c
@@ -0,0 +1,11 @@
+extern int switchfunc(int n);
+int main(){
+  printf("%d\n", switchfunc(1));
+  printf("%d\n", switchfunc(-3));
+  printf("%d\n", switchfunc(1));
+  printf("%d\n", switchfunc(9));
+  printf("%d\n", switchfunc(1));
+  printf("%d\n", switchfunc(100));
+  printf("%d\n", switchfunc(-4));
+  printf("%d\n", switchfunc(-5));
+}
diff --git a/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/test.cfg b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/Main.mpl b/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..bac9bc95caf5a9ae4a8d54c0fd0735f5c063ada5
--- /dev/null
+++ b/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/Main.mpl
@@ -0,0 +1,42 @@
+#     1  public class sync {
+#     2      private Object go = new Object();
+#     3      private int waiters = 0;
+#     4
+#     5      public void foo() {
+#     6          synchronized (go) {
+#     7              waiters++;
+#     8          }
+#     9      }
+#    10  }
+
+# some unrelated functions are removed
+type $Ljava/lang/Object; <class  {}>
+type $Lsync; <class <$Ljava/lang/Object;> {
+  @go <* <$Ljava/lang/Object;>> private,
+  @waiters i32 private,
+  &Lsync;|foo|__V|(<* <$Lsync;>>) void}>
+func &Lsync;|foo|__V| (var %_this <* <$Lsync;>>) void {
+  var %Reg1_R33 <* <$Ljava/lang/Object;>>
+  var %Reg0_I i32
+  var %Reg0_R38 <* void>
+  #LINE sync.java:6 
+  dassign %Reg1_R33 0 (iread ptr <* <$Lsync;>> 1 (dread ptr %_this 0))
+  syncenter (dread ptr %Reg1_R33 0)
+  #LINE sync.java:7 
+  dassign %Reg0_I 0 (iread i32 <* <$Lsync;>> 2 (dread ptr %_this 0))
+  dassign %Reg0_I 0 (add i32 (
+      dread i32 %Reg0_I 0,
+      cvt i32 i8 (constval i8 1)))
+  iassign <* <$Lsync;>> 2 (dread ptr %_this 0, dread i32 %Reg0_I 0)
+  #LINE sync.java:8 
+  syncexit (dread ptr %Reg1_R33 0)
+  #LINE sync.java:9 
+  return ()
+  #LINE sync.java:8 
+  dassign %Reg0_R38 0 (regread ptr %%thrownval)
+  syncexit (dread ptr %Reg1_R33 0)
+  throw (dread ptr %Reg0_R38 0)
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/expected.mplme.txt b/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/expected.txt b/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/test.cfg b/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/Main.mpl b/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..12acd02e4a9d9cc1617d25cfab42c5ff660b8eb0
--- /dev/null
+++ b/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/Main.mpl
@@ -0,0 +1,15 @@
+ # a function returning (i + j) * -998
+ func $foo (
+# var %i xxx,
+  var %i i32,
+   var %j i32,
+   var %k i32) i32 { 
+   return (
+     select i32 (
+      dread i32 %i, 
+      dread i32 %j, 
+      dread i32 %k))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/expected.mplme.txt b/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/expected.txt b/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/test.cfg b/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/Main.mpl b/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..e88694db1e68f23b1867e83018b1fe3fd68b2783
--- /dev/null
+++ b/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/Main.mpl
@@ -0,0 +1,15 @@
+#var $const1 <[13] i8> [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 10, 0 ]
+var $fconst1 <[18] f64> = [ 1007, 707, -273, 75, 0113, 0x4b, 75u, 75l, 75ul, 75lu, 3.1425926, 6.02e23, 6.02e+23, 1.6e-19, 3.0, 3.14159, 6.02e23, .233 ]
+func $printf (var %p1 <* i8>)void
+func $main ( ) i32 {
+   call &printf (addrof a32 $fconst1)
+   call &printf (conststr ptr "\"hello maple\"", conststr a32 "\nworld\n")
+   # 你好: E4 BD A0 E5 A5 BD  中国: E4 B8 AD E5 9B BD
+   call &printf (conststr16 ptr "\xE4\xBD\xA0\xE5\xA5\xBD", conststr16 a32 "\xE4\xB8\xAD\xE5\x9B\xBD")
+   return (constval i32 0) }
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/expected.mplme.txt b/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/expected.txt b/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/test.cfg b/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/Main.mpl b/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..9f79476c5eae1a8a1a207845375cb1bbae5a9114
--- /dev/null
+++ b/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/Main.mpl
@@ -0,0 +1,50 @@
+func $foo1 (var %p1 i8, var %p2 i16, var %p3 i32, var %p4 i64, ...)i32 {
+   return (
+       constval i32 33)}
+func $foo2 (var %p1 u8, var %p2 u16, var %p3 u32, var %p4 u64,...) i32 {
+   return (
+       constval i32 33)}
+func $foo4 (var %p1 f32, var %p2 f64, ... ) i32 {
+   return (
+       constval i32 33)}
+
+func $foo5 (var %p1 a32, var %p2 a64,...) i32 
+func $foo6 (var %p1 c64, var %p2 c128, ...) i32
+
+func $foo7 (var %p1 <* i8>, var %p2 <* i16>, var %p3 <* i32>, var %p4 <* i64>) i32 {
+   return (
+       constval i32 33)}
+func $foo8 (var %p1 <* u8>, var %p2 <* u16>, var %p3 <* u32>, var %p4 <* u64>) i32 {
+   return (
+       constval i32 33)}
+func $foo9 (var %p1 <* u1>) i32 {
+   return (
+       constval i32 33)}
+func $foo10 (var %p1 <* f32>, var %p2 <* f64>) i32 {
+   return (
+       constval i32 33)}
+func $foo11 (var %p1 <* void>)void
+
+func $foo12 (var %p1 <[10] i8>) i32 {
+   return (
+       constval i32 33)}
+func $foo13 (var %p1 <[10][32] i32>) i32 {
+   return (
+       constval i32 33)}
+func $foo14 (var %p1 <[10][32][43] i32>) i32 {
+   return (
+       constval i32 33)}
+func $foo15 (var %p1 <[10][32][43][54][56][78][90][122][223][334] i32>) i32 {
+   return (
+       constval i32 33)}
+
+type $SS <struct {@f1 i32, @f2:3 i8, @f3:5 i8}>
+func $foo16 (var %x <$SS>) i32 {
+   return (
+       constval i32 33)}
+
+
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/expected.mplme.txt b/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/expected.txt b/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/test.cfg b/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0081-mapleall-irbuild-edge-test_type/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/Main.mpl b/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3aa3c48c666596cdfeb9f0a77fe301eadaeebc5b
--- /dev/null
+++ b/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/Main.mpl
@@ -0,0 +1,21 @@
+#int fact (int n) {
+#  if(n != 1)
+#    return foo(n - 1);
+#  else return 1;
+#}
+func $foo varargs ( var %i i32, ... ) i32 {
+  return (dread i32 %i) }
+func $foo1 varargs ( ... ) i32 {
+  return (constval i32 99) }
+
+func $fact (
+ var %n i32) i32 {
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    call &foo(
+      sub i32 (dread i32 %n, constval i32 1))
+    return (regread i32 %%retval)}
+   else {
+     return (constval i32 1) } }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/expected.mplme.txt b/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/expected.txt b/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/test.cfg b/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/Main.mpl b/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..1ee6f5f094c9ebf9bc4d9b8c82986505690ee583
--- /dev/null
+++ b/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/Main.mpl
@@ -0,0 +1,13 @@
+ # a function returning unary(i + j) * -998
+#type $SS <struct {@f1 f32}>
+ func $foo (
+  var %k <struct {@f1 f32}>,
+  var %f f32,
+  var %i i32,
+   var %j i32)i64  { 
+   return (
+       cvt i64 i32 (constval i32 12345))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/expected.mplme.txt b/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/expected.txt b/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/test.cfg b/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl b/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..a6e95d9cb500cfd1abc4b544e778c26dc97f53ea
--- /dev/null
+++ b/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl
@@ -0,0 +1,15 @@
+ # a function returning unary(i + j) * -998
+ func $foo (
+  var %i i32,
+   var %j i32) f32 { 
+   return (
+     recip f32(
+       sqrt f32(  
+      cvt f32 i32(
+        mul i32 (
+         extractbits i32 1 23 ( add i32 ( bnot i32 (dread i32 %i), lnot i32 (dread i32 %j))), 
+         neg i32 ( constval i32 -998))))))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/expected.mplme.txt b/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/expected.txt b/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/test.cfg b/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/Main.mpl b/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..3529c000291396e1a9125c91d7d3294bff33d3da
--- /dev/null
+++ b/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/Main.mpl
@@ -0,0 +1,29 @@
+type $RR <class {@e1 i32, @e2 f32, @e3 f64}>
+type $SS <class <$RR> { &method1(agg)agg,
+                        &method2(void)void}>
+func $foo (
+  var %x <$SS>) i32 {
+  var %r1 i32
+  var  %r2 i32
+  var  %r3 i32
+  dassign %x 2 ( constval i32 32 )
+  # Not correct, but for parse and dump test.
+  virtualcallassigned &method2(addrof ptr %x) {
+    dassign %r1 1
+    dassign %r2 2
+    dassign %r3 3
+  }
+  superclasscallassigned &method2(addrof ptr %x) {
+    dassign %r1 1
+    dassign %r2 2
+    dassign %r3 3
+  }
+  interfacecallassigned &method2(addrof ptr %x) {
+    dassign %r1 1
+    dassign %r2 2
+    dassign %r3 3
+  }
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/expected.mplme.txt b/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/expected.txt b/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/test.cfg b/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/Main.mpl b/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..02a30ee4d9a7178e22106ac402dbbe802fda2db8
--- /dev/null
+++ b/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/Main.mpl
@@ -0,0 +1,13 @@
+type $RR <class {@e1 i32, @e2 f32, @e3 f64}>
+type $SS <class <$RR> { &method1(agg)agg,
+                        &method2(void)void}>
+func $foo (
+	var %x <$SS>) i32 {
+  dassign %x 2 ( constval i32 32 )
+  virtualcall &method2(addrof ptr %x)
+  superclasscall &method2(addrof ptr %x)
+  interfacecall &method2(addrof ptr %x)
+  return ( dread i32 %x 2 ) }
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/expected.mplme.txt b/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/expected.txt b/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/test.cfg b/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/Main.mpl b/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..b00128d06ff9aa81b73e85db6abae1a9bf934348
--- /dev/null
+++ b/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/Main.mpl
@@ -0,0 +1,19 @@
+# int foo(void) {
+#   int n = 1;
+#   int i;
+#   for (i=1; i<10; i++)
+#     n = n * i;
+# }
+
+func $foo (var %i i32) i32 {
+  while (
+    lt i32 i32 ( dread i32 %i, constval i32 10) ) {
+      dassign %i (
+	mul i32 (dread i32 %i, dread i32 %i))
+      dassign %i (
+        add i32 (dread i32 %i, constval i32 1) )} 
+  return ( constval i32 1 )
+}
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/expected.mplme.txt b/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/expected.txt b/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/test.cfg b/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/Main.mpl b/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..1dcae2c67515a5a94043e0e666c2d37414537327
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/Main.mpl
@@ -0,0 +1,32 @@
+ # a function returning (i + j) * -998
+ func $foo (
+# var %i xxx,
+  var %i i32, var %j i32, var %k i32, 
+  var %i1 i32, var %j1 i32, var %k1 i32
+  ) i32 {
+   assertge (dread i32 %i, constval i32 0)
+   assertlt (dread i32 %i, dread i32 %k)
+   return (
+     ashr i32(
+      mul i32 (
+       add i32 ( 
+        band i32 (dread i32 %i, dread i32 %j),
+        bior i32 ( 
+         bxor i32(dread i32 %i1, dread i32 %k1), 
+         eq i32 i32 (
+          depositbits i32 1 23 (
+           land i32 (dread i32 %j1, dread i32 %k), 
+           lior i32 (
+             min i32 (
+              shl i32 (dread i32 %k1, dread i32 %j), 
+              sub i32 (dread i32 %j1, dread i32 %i)), 
+             rem i32 (dread i32 %i, dread i32 %k))), 
+          div i32( 
+           lshr i32 ( dread i32 %k, dread i32 %i), 
+           max i32 ( dread i32 %i, dread i32 %j))))), 
+       constval i32 -998), 
+      dread i32 %i))}
+
+ # EXEC: %irbuild Main.mpl
+ # EXEC: %irbuild Main.irb.mpl
+ # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
diff --git a/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/expected.mplme.txt b/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/expected.txt b/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/test.cfg b/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c5aa987c9ffa0eca7185a1be1b3b66510e6f365
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0009-mapleall-irbuild-edge-binary/test.cfg
@@ -0,0 +1 @@
+compile(Main)
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-all-assigned/Main.mpl b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-all-assigned/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..52cc6d496af49400438b0f7279cd85fae52995f5
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-all-assigned/Main.mpl
@@ -0,0 +1,17 @@
+
+func $fact (
+ var %n i32, var %p1 a64, var %p2 a64) i32 {
+  var %r1 i32
+  var  %r2 i32
+  var  %r3 i32
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    # Not correct, but for parse and dump test.
+    intrinsiccallassigned JSOP_ADD (
+      dread a64 %p1, dread a64 %p2, dread i32 %n) {
+      dassign %r1 1
+      dassign %r2 2
+      dassign %r3 3
+    }
+    return (constval i32 0)
+  }
+}
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-all-assigned/expected.mplme.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-all-assigned/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aded01e0942a507d16571767ed86e039aaf8a1cf
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-all-assigned/expected.mplme.txt
@@ -0,0 +1,3 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-all-assigned/expected.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-all-assigned/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-all-assigned/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-call/Main.mpl b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-call/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..5d2cc9848044c2b377785d8ab6b97e252b4c204f
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-call/Main.mpl
@@ -0,0 +1,14 @@
+#int fact (int n) {
+#  if(n != 1)
+#    return foo(n - 1);
+#  else return 1;
+#}
+
+func $fact (
+ var %n i32, var %p1 a64, var %p2 a64) i32 {
+ if (ne i32 i32 (dread i32 %n, constval i32 1)) {
+    intrinsiccall JSOP_ADD (
+      dread a64 %p1, dread a64 %p2, dread i32 %n)
+    return (regread i32 %%retval)}
+   else {
+     return (constval i32 1) } }
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-call/expected.mplme.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-call/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-call/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-call/expected.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-call/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-call/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-javaeh/Main.mpl b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-javaeh/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..850291610ccba8ebfe93733ebd6d8cf47285da0c
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-javaeh/Main.mpl
@@ -0,0 +1,61 @@
+type $Ljava/lang/Object; <class  {
+  @DEXINFO_isuserclass 0}>
+type $Leh; <class <$Ljava/lang/Object;> {
+  @DEXINFO_isuserclass 1,
+  &foo public static (<* <$Leh;>>,<* <[0] <* <$Ljava/lang/String;>>>>) void}>
+type $Ljava/lang/String; <class  {
+  @DEXINFO_isuserclass 0}>
+type $Ljava/io/PrintStream; <class  {
+  @DEXINFO_isuserclass 0}>
+type $Ljava/lang/System; <class  {
+  @DEXINFO_isuserclass 0,
+  @out <* <$Ljava/io/PrintStream;>>}>
+type $Ljava/lang/Exception; <class  {
+  @DEXINFO_isuserclass 0}>
+  javaclass $javaclass|Leh; <$Leh;>
+
+func &foo public static (var %_this <* <$Leh;>>, var %Reg2_R39 <* <[0] <* <$Ljava/lang/String;>>>>) void
+var $const_array_0 <[3] i32> readonly = [1, 2, 3]
+var $static|Ljava/lang/System;|out|Ljava/io/PrintStream;| <* <$Ljava/io/PrintStream;>>
+func &Ljava/io/PrintStream;|print|_I_V| (var %_this <* <$Ljava/io/PrintStream;>>, var %Reg1_I i32) void
+var $const_chars_1 <[11] u8> const readonly = [0, 0, 7, 0, 101, 114, 114, 111, 114, 49, 10]
+func &Ljava/io/PrintStream;|print|_Ljava/lang/String;_V| (var %_this <* <$Ljava/io/PrintStream;>>, var %Reg1_R37 <* <$Ljava/lang/String;>>) void
+var $const_chars_2 <[11] u8> const readonly = [0, 0, 7, 0, 101, 114, 114, 111, 114, 50, 10]
+
+func &foo public static (var %_this <* <$Leh;>>, var %Reg2_R39 <* <[0] <* <$Ljava/lang/String;>>>>) void {
+  var %Reg0_I i32
+  var %Reg0_R45 <* <[3] i32>>
+  var %Reg1_I i32
+  var %Reg1_R47 <* <$Ljava/io/PrintStream;>>
+  var %Reg0_R51 <* <$Ljava/lang/Exception;>>
+  var %Reg0_R47 <* <$Ljava/io/PrintStream;>>
+  var %Reg1_R53 <* u8>
+  var %Reg0_R55 <* dynany>
+  dassign %Reg0_I 0 (cvt i32 i8 (constval i8 3))
+  javatry { @label1 }
+  dassign %Reg0_R45 0 (malloc ptr (mul i32 (dread i32 %Reg0_I, sizeoftype u32 i32)))
+  endtry
+  intrinsiccallassigned DEX_ARRAY_SETELEM (dread ptr %Reg0_R45, constval i32 3, addrof ptr $const_array_0) {}
+  dassign %Reg1_I 0 (cvt i32 i8 (constval i8 4))
+  javatry { @label1 @label2 }
+  dassign %Reg0_I 0 (iread i32 <* <[3] i32>> 0 (array ptr <* <[3] i32>> (dread ptr %Reg0_R45, dread i32 %Reg1_I)))
+  dassign %Reg1_R47 0 (dread ptr $static|Ljava/lang/System;|out|Ljava/io/PrintStream;|)
+  virtualcallassigned &Ljava/io/PrintStream;|print|_I_V| (dread ptr %Reg1_R47, dread i32 %Reg0_I) {}
+  endtry
+@label0   return ()
+@label2   javacatch <* <$Ljava/lang/Exception;>>
+  dassign %Reg0_R51 0 (regread ptr %%thrownval)
+  javatry { @label1 }
+  dassign %Reg0_R47 0 (dread ptr $static|Ljava/lang/System;|out|Ljava/io/PrintStream;|)
+  dassign %Reg1_R53 0 (addrof ptr $const_chars_1)
+  virtualcallassigned &Ljava/io/PrintStream;|print|_Ljava/lang/String;_V| (dread ptr %Reg0_R47, dread ptr %Reg1_R53) {}
+  endtry
+  goto @label0
+@label1   javacatch <* <$Ljava/lang/Exception;>>
+  dassign %Reg0_R51 0 (regread ptr %%thrownval)
+  dassign %Reg0_R47 0 (dread ptr $static|Ljava/lang/System;|out|Ljava/io/PrintStream;|)
+  dassign %Reg1_R53 0 (addrof ptr $const_chars_2)
+  virtualcallassigned &Ljava/io/PrintStream;|print|_Ljava/lang/String;_V| (dread ptr %Reg0_R47, dread ptr %Reg1_R53) {}
+  goto @label0
+}
+
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-javaeh/expected.mplme.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-javaeh/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aded01e0942a507d16571767ed86e039aaf8a1cf
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-javaeh/expected.mplme.txt
@@ -0,0 +1,3 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-javaeh/expected.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-javaeh/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e8ea2f49dfcc306508ba60744b7d32a8caf69377
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-javaeh/expected.txt
@@ -0,0 +1 @@
+Compare irbuild result!
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-with-type/Main.mpl b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-with-type/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..db947da0c98e284834ccdc594826d6dcf447242c
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-with-type/Main.mpl
@@ -0,0 +1,9 @@
+type $ClassA <class {@e1 i32, @e2 f32, @e3 f64}>
+type $ClassB <class {@e1 i32}>
+
+func $foo() void {
+  var %Reg1 <* <$ClassB>>
+  dassign %Reg1 0 (intrinsicopwithtype ptr <* <$ClassB>> DEX_CONST_CLASS ())
+  intrinsiccallwithtype <* <$ClassA>> DEX_CHECK_CAST (dread ptr %Reg1 0)
+}
+
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-with-type/expected.mplme.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-with-type/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aded01e0942a507d16571767ed86e039aaf8a1cf
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-with-type/expected.mplme.txt
@@ -0,0 +1,3 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-with-type/expected.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-with-type/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic-with-type/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic/Main.mpl b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic/Main.mpl
new file mode 100644
index 0000000000000000000000000000000000000000..fcbebfcd68934bcf4bcee96bed96e0eef85e9108
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic/Main.mpl
@@ -0,0 +1,7 @@
+func $foo ( var %i i32, var %j i32, var %k i32) i32 { 
+   return (
+     intrinsicop i32 JSOP_STRICTEQ (
+      dread i32 %i, 
+      intrinsicop i32 JS_NUMBER (dread i32 %k)))
+}
+
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic/expected.mplme.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic/expected.txt b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c876141802aeeff6a10f38274a0d5c0167e6dda5
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0088-mapleall-irbuild-edge-intrinsic/expected.txt
@@ -0,0 +1,2 @@
+Compare irbuild result!
+Main.irb.mpl and Main.irb.irb.mpl are the same
diff --git a/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/expected.mplme.txt b/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/expected.mplme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d05948d001e19172b191ae6049fae148ad0c11f
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/expected.mplme.txt
@@ -0,0 +1,4 @@
+Test if programe got passed!
+condition is value, goto assertEqual
+Check if condition value would be Zero
+expected:0 and actual:0 are equal
diff --git a/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/expected.txt b/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..10fc75a29e5c00059ca003d7396a83b751f2125d
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/expected.txt
@@ -0,0 +1,128 @@
+LHelloWorld;|main|(Ljava/lang/String;)V	
+
+Info  00: Test passed.
+
+Ldalvik/system/BlockGuard$1;|onWriteToDisk|()V	
+
+Info  00: Test passed.
+
+Ldalvik/system/BlockGuard;|getThreadPolicy|()Ldalvik/system/BlockGuard$Policy;	
+
+Info  00: Test passed.
+
+Ldalvik/system/VMRuntime;|registerNativeAllocation|(I)V	
+
+Info  00: Test passed.
+
+Ljava/io/BufferedWriter;|<clinit>|()V	
+
+Info  00: Test passed.
+
+Ljava/io/BufferedWriter;|<init>|(Ljava/io/Writer;I)V	
+
+Info  00: Test passed.
+
+Ljava/io/BufferedWriter;|write|(Ljava/lang/String;II)V	
+
+Info  00: Test passed.
+
+Ljava/io/FileOutputStream;|<init>|(Ljava/lang/String;)V
+
+Info  00: Test passed.
+
+Ljava/io/FileOutputStream;|write|([BII)V	
+
+Info  00: Test passed.
+
+Ljava/lang/Daemons$FinalizerDaemon;|-get0|()Ljava/lang/Daemons$FinalizerDaemon;	
+
+Info  00: Test passed.
+
+Ljava/lang/ref/Reference;|get|()Ljava/lang/Object;	
+
+Info  00: Test passed.
+
+Ljava/lang/ref/Reference;|getReferent|()Ljava/lang/Object;	
+
+Info  00: Test passed.
+
+Ljava/lang/ref/Reference;|<init>|(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V	
+
+Info  00: Test passed.
+
+Ljava/lang/String;|getChars|(II[CI)V
+
+Info  00: Test passed.
+
+Ljava/lang/ThreadLocal;|getMap|(Ljava/lang/Thread;)Ljava/lang/ThreadLocal$ThreadLocalMap;	
+
+Info  00: Test passed.
+
+Ljava/lang/ThreadLocal$ThreadLocalMap;|getEntry|(Ljava/lang/ThreadLocal;)Ljava/lang/ThreadLocal$ThreadLocalMap$Entry;	
+
+Info  00: Test passed.
+
+Ljava/lang/ThreadLocal$ThreadLocalMap;|-wrap0|(Ljava/lang/ThreadLocal$ThreadLocalMap;Ljava/lang/ThreadLocal;)Ljava/lang/ThreadLocal$ThreadLocalMap$Entry;	
+
+Info  00: Test passed.
+
+Ljava/nio/Buffer;|<init>|(IIIII)V	
+
+Info  00: Test passed.
+
+Ljava/nio/ByteBuffer;|array|()[B	
+
+Info  00: Test passed.
+
+Ljava/nio/ByteBuffer;|<init>|(IIII[BI)V
+
+Info  00: Test passed.
+
+Ljava/nio/CharBuffer;|wrap|([CII)Ljava/nio/CharBuffer;	
+
+Info  00: Test passed.
+
+Ljava/nio/charset/CharsetEncoderICU;|<init>|(Ljava/nio/charset/Charset;FF[BJ)V	
+
+Info  00: Test passed.
+
+Ljava/nio/charset/Charset;|<init>|(Ljava/lang/String;[Ljava/lang/String;)V	
+
+Info  00: Test passed.
+
+Llibcore/icu/ICU;|U_FAILURE|(I)Z	
+
+Info  00: Test passed.
+
+Llibcore/icu/NativeConverter;|encode|(J[CI[BI[IZ)I	
+
+Info  00: Test passed.
+
+Llibcore/icu/NativeConverter;|setCallbackEncode|(JII[B)V	
+
+Info  00: Test passed.
+
+Llibcore/io/BlockGuardOs;|write|(Ljava/io/FileDescriptor;[BII)I	
+
+Info  00: Test passed.
+
+Llibcore/io/Posix;|writeBytes|(Ljava/io/FileDescriptor;Ljava/lang/Object;II)I	
+
+Info  00: Test passed.
+
+Lsun/nio/cs/StreamEncoder;|implWrite|([CII)V	
+
+Info  00: Test passed.
+
+Ljava/lang/StringFactory;|newStringFromChars|(II[C)Ljava/lang/String;
+
+Info  00: Test passed.
+
+Llibcore/icu/NativeConverter;|getSubstitutionBytes|(J)[B
+
+Info  00: Test passed.
+
+LA;|fooALA|([I[LA;J)LA;
+
+Info  00: Test passed.
+
diff --git a/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/java_signature_test.txt b/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/java_signature_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dfbdd3b9224afdfe46f2ed67c1f18a1506482454
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/java_signature_test.txt
@@ -0,0 +1,32 @@
+LHelloWorld;|main|(Ljava/lang/String;)V	
+Ldalvik/system/BlockGuard$1;|onWriteToDisk|()V	
+Ldalvik/system/BlockGuard;|getThreadPolicy|()Ldalvik/system/BlockGuard$Policy;	
+Ldalvik/system/VMRuntime;|registerNativeAllocation|(I)V	
+Ljava/io/BufferedWriter;|<clinit>|()V	
+Ljava/io/BufferedWriter;|<init>|(Ljava/io/Writer;I)V	
+Ljava/io/BufferedWriter;|write|(Ljava/lang/String;II)V	
+Ljava/io/FileOutputStream;|<init>|(Ljava/lang/String;)V
+Ljava/io/FileOutputStream;|write|([BII)V	
+Ljava/lang/Daemons$FinalizerDaemon;|-get0|()Ljava/lang/Daemons$FinalizerDaemon;	
+Ljava/lang/ref/Reference;|get|()Ljava/lang/Object;	
+Ljava/lang/ref/Reference;|getReferent|()Ljava/lang/Object;	
+Ljava/lang/ref/Reference;|<init>|(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V	
+Ljava/lang/String;|getChars|(II[CI)V
+Ljava/lang/ThreadLocal;|getMap|(Ljava/lang/Thread;)Ljava/lang/ThreadLocal$ThreadLocalMap;	
+Ljava/lang/ThreadLocal$ThreadLocalMap;|getEntry|(Ljava/lang/ThreadLocal;)Ljava/lang/ThreadLocal$ThreadLocalMap$Entry;	
+Ljava/lang/ThreadLocal$ThreadLocalMap;|-wrap0|(Ljava/lang/ThreadLocal$ThreadLocalMap;Ljava/lang/ThreadLocal;)Ljava/lang/ThreadLocal$ThreadLocalMap$Entry;	
+Ljava/nio/Buffer;|<init>|(IIIII)V	
+Ljava/nio/ByteBuffer;|array|()[B	
+Ljava/nio/ByteBuffer;|<init>|(IIII[BI)V
+Ljava/nio/CharBuffer;|wrap|([CII)Ljava/nio/CharBuffer;	
+Ljava/nio/charset/CharsetEncoderICU;|<init>|(Ljava/nio/charset/Charset;FF[BJ)V	
+Ljava/nio/charset/Charset;|<init>|(Ljava/lang/String;[Ljava/lang/String;)V	
+Llibcore/icu/ICU;|U_FAILURE|(I)Z	
+Llibcore/icu/NativeConverter;|encode|(J[CI[BI[IZ)I	
+Llibcore/icu/NativeConverter;|setCallbackEncode|(JII[B)V	
+Llibcore/io/BlockGuardOs;|write|(Ljava/io/FileDescriptor;[BII)I	
+Llibcore/io/Posix;|writeBytes|(Ljava/io/FileDescriptor;Ljava/lang/Object;II)I	
+Lsun/nio/cs/StreamEncoder;|implWrite|([CII)V	
+Ljava/lang/StringFactory;|newStringFromChars|(II[C)Ljava/lang/String;
+Llibcore/icu/NativeConverter;|getSubstitutionBytes|(J)[B
+LA;|fooALA|([I[LA;J)LA;
diff --git a/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/run b/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/run
new file mode 100755
index 0000000000000000000000000000000000000000..b292266d8c3762fb3dccd15fe8f839e2559059ed
--- /dev/null
+++ b/testsuite/irbuild_test/issue-I0089-mapleall-irbuild-edge-java-signature-test/run
@@ -0,0 +1,16 @@
+#! /usr/bin/python3
+import os
+import subprocess
+
+f = open('./java_signature_test.txt', 'r')
+data = f.readlines()
+
+for line in data:
+    print(line)
+    cmd = "mplverf --javaname '"+line + "'"
+    cmd = cmd.split()
+    result = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+    print(result.decode("utf-8"))
+
+
+
diff --git a/testsuite/java_test/app_test/APP0001-app-Application-Application-helloworld/HelloWorld.java b/testsuite/java_test/app_test/APP0001-app-Application-Application-helloworld/HelloWorld.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb4f7beb10589aaaf0fe6ac5456ed42ba6ea2b8b
--- /dev/null
+++ b/testsuite/java_test/app_test/APP0001-app-Application-Application-helloworld/HelloWorld.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+public class HelloWorld {
+
+  public static void main(String[] args) {
+    System.out.println("Hello World!");
+  }
+}
+
diff --git a/testsuite/java_test/app_test/APP0001-app-Application-Application-helloworld/expected.txt b/testsuite/java_test/app_test/APP0001-app-Application-Application-helloworld/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..980a0d5f19a64b4b30a87d4206aade58726b60e3
--- /dev/null
+++ b/testsuite/java_test/app_test/APP0001-app-Application-Application-helloworld/expected.txt
@@ -0,0 +1 @@
+Hello World!
diff --git a/testsuite/java_test/app_test/APP0001-app-Application-Application-helloworld/test.cfg b/testsuite/java_test/app_test/APP0001-app-Application-Application-helloworld/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/java_test/app_test/APP0001-app-Application-Application-helloworld/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/java_test/app_test/APP0002-app-Application-Application-ThreadhelloWorld/ThreadHelloWorld.java b/testsuite/java_test/app_test/APP0002-app-Application-Application-ThreadhelloWorld/ThreadHelloWorld.java
new file mode 100644
index 0000000000000000000000000000000000000000..94bbafa1c40ca0a405108a7e95aaca33657878e9
--- /dev/null
+++ b/testsuite/java_test/app_test/APP0002-app-Application-Application-ThreadhelloWorld/ThreadHelloWorld.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+import java.lang.Thread;
+
+public class ThreadHelloWorld implements Runnable {
+
+  private final String helloworld;
+
+  public static void main(String args[]) throws InterruptedException {
+    Thread thread = new Thread(new ThreadHelloWorld("Hello, World"));
+    thread.start();
+    thread.join();
+  }
+
+  public ThreadHelloWorld(String str){
+    helloworld = str;
+  }
+  
+  public void run(){
+    System.out.println(helloworld);
+  }
+}
+
+
diff --git a/testsuite/java_test/app_test/APP0002-app-Application-Application-ThreadhelloWorld/expected.txt b/testsuite/java_test/app_test/APP0002-app-Application-Application-ThreadhelloWorld/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3fa0d4b98289a95a7cd3a45c9545e622718f8d2b
--- /dev/null
+++ b/testsuite/java_test/app_test/APP0002-app-Application-Application-ThreadhelloWorld/expected.txt
@@ -0,0 +1 @@
+Hello, World
diff --git a/testsuite/java_test/app_test/APP0002-app-Application-Application-ThreadhelloWorld/test.cfg b/testsuite/java_test/app_test/APP0002-app-Application-Application-ThreadhelloWorld/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c0f93bafe7faa16561a5021dc9d798beaf0ce836
--- /dev/null
+++ b/testsuite/java_test/app_test/APP0002-app-Application-Application-ThreadhelloWorld/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadHelloWorld)
+run(ThreadHelloWorld)
diff --git a/testsuite/java_test/app_test/APP0003-app-Application-Application-reflection/HelloWorld.java b/testsuite/java_test/app_test/APP0003-app-Application-Application-reflection/HelloWorld.java
new file mode 100755
index 0000000000000000000000000000000000000000..9f99189dad839c9d9c475ca22a42dfa69526909d
--- /dev/null
+++ b/testsuite/java_test/app_test/APP0003-app-Application-Application-reflection/HelloWorld.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+import java.lang.reflect.*;
+class Pertnn {
+    public Pertnn() {
+      age = 1234;
+    }
+    public int getAge() {
+        return age;
+    }
+    public void setAge(int age) {
+        this.age = age;
+    }
+    public int age;
+}
+
+class Person {
+    public Person() {
+      System.out.println("Invoking Person Constructor!");
+      age = 5678;
+    }
+    public int getAge() {
+      System.out.println("Invoking Person getAge!");
+      return age;
+    }
+    public void setAge(int age) {
+        this.age = age;
+    }
+    public int age;
+}
+public final class HelloWorld {
+  public static void main(String [] args) {
+        System.out.println("HelloWorld!");			
+        Class<?> demo=null;
+        try{
+            demo=Class.forName("Person");
+        }catch (Exception e) {
+            System.out.println("ex1");
+        }
+
+        try{
+            Method method=demo.getMethod("getAge");
+            Object o =	demo.newInstance();
+            method.invoke(o);
+            Field field = demo.getDeclaredField("age");
+            long value = field.getLong(o);
+            if(value == 5678)
+              System.out.println("Good Value Before Setting!");			
+        /*    field.setLong(o, 9876);  // This should throw exception
+            value = field.getLong(o);
+            if(value == 9876)
+              System.out.println("Good Value After Setting!");	*/
+        }catch (Exception e) {
+            System.out.println("ex2");
+        }
+}
+}
+
diff --git a/testsuite/java_test/app_test/APP0003-app-Application-Application-reflection/expected.txt b/testsuite/java_test/app_test/APP0003-app-Application-Application-reflection/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2c7fa253e3b942963b527d44739d0bb13c156640
--- /dev/null
+++ b/testsuite/java_test/app_test/APP0003-app-Application-Application-reflection/expected.txt
@@ -0,0 +1,4 @@
+HelloWorld!
+Invoking Person Constructor!
+Invoking Person getAge!
+Good Value Before Setting!
diff --git a/testsuite/java_test/app_test/APP0003-app-Application-Application-reflection/test.cfg b/testsuite/java_test/app_test/APP0003-app-Application-Application-reflection/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/java_test/app_test/APP0003-app-Application-Application-reflection/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/java_test/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/ABCOcatchArrayIndexOutOfBoundsException.java b/testsuite/java_test/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/ABCOcatchArrayIndexOutOfBoundsException.java
new file mode 100755
index 0000000000000000000000000000000000000000..b70b7da790b0a17b4b67ca99e6319b56db0df32c
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/ABCOcatchArrayIndexOutOfBoundsException.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOcatchArrayIndexOutOfBoundsException {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        try {
+            func();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        } catch (Exception e) {
+            res = res + 2;
+        }
+        return res;
+    }
+    public static void func() throws Exception {
+        int[] a = new int[1024];
+        int c = a[1024];
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/expected.txt b/testsuite/java_test/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/test.cfg b/testsuite/java_test/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc477debb4d126a7cb1b837ec61b9980fd097a1c
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOcatchArrayIndexOutOfBoundsException)
+run(ABCOcatchArrayIndexOutOfBoundsException)
diff --git a/testsuite/java_test/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/ABCOcatchIndexOutOfBoundsException.java b/testsuite/java_test/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/ABCOcatchIndexOutOfBoundsException.java
new file mode 100755
index 0000000000000000000000000000000000000000..b8ed315046297ca89eed9c42873b9aa6d0a901c9
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/ABCOcatchIndexOutOfBoundsException.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOcatchIndexOutOfBoundsException {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        try {
+            func();
+        } catch (IndexOutOfBoundsException e) {
+            res--;
+        } catch (Exception e) {
+            res = res + 2;
+        }
+        return res;
+    }
+    public static void func() throws Exception {
+        int[] a = new int[1024];
+        int c = a[1024];
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/expected.txt b/testsuite/java_test/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/test.cfg b/testsuite/java_test/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..edc433716d083bc6d1842c4256c0abdc72801b4b
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOcatchIndexOutOfBoundsException)
+run(ABCOcatchIndexOutOfBoundsException)
diff --git a/testsuite/java_test/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/ABCOcatchStringIndexOutOfBoundsException.java b/testsuite/java_test/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/ABCOcatchStringIndexOutOfBoundsException.java
new file mode 100755
index 0000000000000000000000000000000000000000..cbc9fb2eefde71bbd9ab6c0f3542cfc0e7303096
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/ABCOcatchStringIndexOutOfBoundsException.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOcatchStringIndexOutOfBoundsException {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        try {
+            func();
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        } catch (Exception e) {
+            res = res + 2;
+        }
+        return res;
+    }
+    public static void func() throws Exception {
+        char[] a = new char[1024];
+        int index = 0;
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'a';
+            index++;
+        }
+        String joinLine = a.toString();
+        char c = joinLine.charAt(index);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/expected.txt b/testsuite/java_test/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/test.cfg b/testsuite/java_test/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..680d1d5b3c8d4a4495f7d086506b002e5f16bec9
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOcatchStringIndexOutOfBoundsException)
+run(ABCOcatchStringIndexOutOfBoundsException)
diff --git a/testsuite/java_test/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/ABCOconstOperation.java b/testsuite/java_test/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/ABCOconstOperation.java
new file mode 100755
index 0000000000000000000000000000000000000000..ea2a5214a61688d324687d5dd9ae5d4588266f64
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/ABCOconstOperation.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOconstOperation {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 10 /*STATUS_FAILED*/;
+        int[] arr1 = new int[15];
+        for (int i = 0; i < arr1.length; i++) {
+            arr1[i] = i;
+        }
+        int index = 1;
+        int y = 6;
+        try {
+            index = index + y + 9;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = y - 16 - index;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = y * y * index;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = index + 937;
+            index = (y / index) * y;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = (y + 9) & 15;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = y | index;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = ~index;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = 15;
+            index = index ^ 16;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = index % 16;
+            int c = arr1[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/expected.txt b/testsuite/java_test/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/test.cfg b/testsuite/java_test/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..876d1e858f7f5fc307eb2b5d24c922967446e1f0
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0004-rt-arrayboundary-ABCOconstOperation/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOconstOperation)
+run(ABCOconstOperation)
diff --git a/testsuite/java_test/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/ABCOcustomClass.java b/testsuite/java_test/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/ABCOcustomClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..d85ccd6ba72ee23ee0b9a77b82047950169d15c0
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/ABCOcustomClass.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOcustomClass {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        People p = new People(3);
+        int x = p.n;
+        try {
+            Student a = p.s[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+class People {
+    int n;
+    Student s[] = new Student[n];
+    public People(int n) {
+        this.n = n;
+    }
+}
+class Student {
+    int number;
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/expected.txt b/testsuite/java_test/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/test.cfg b/testsuite/java_test/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5b3b7d38bb56c246de6bf7450f45d16234133987
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0005-rt-arrayboundary-ABCOcustomClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOcustomClass)
+run(ABCOcustomClass)
diff --git a/testsuite/java_test/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/ABCOdoWhile.java b/testsuite/java_test/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/ABCOdoWhile.java
new file mode 100755
index 0000000000000000000000000000000000000000..fa64aceb7ad353ceb2248fda4ee877fc3307a9f8
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/ABCOdoWhile.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOdoWhile {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] c = new int[a.length];
+        int x = 0;
+        int y = a.length;
+        try {
+            do {
+                c[x] = a[x];
+                x++;
+            } while (x <= y);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/expected.txt b/testsuite/java_test/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/test.cfg b/testsuite/java_test/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..443494ca0352e134487b2081794e709c4108e684
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0006-rt-arrayboundary-ABCOdoWhile/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOdoWhile)
+run(ABCOdoWhile)
diff --git a/testsuite/java_test/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/ABCOemptyArray.java b/testsuite/java_test/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/ABCOemptyArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..bfc3de11dc0f6012a420907ff4d0a60be216f2cc
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/ABCOemptyArray.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOemptyArray {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        int result2 = 4;
+        try {
+            result = test1();
+            result2 = test2();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && result2 == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        Object[] a = new Object[0];
+        try {
+            a[0] = new Object[0];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            Object c = a[-1];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+    public static int test2() {
+        int res = 2 /*STATUS_FAILED*/;
+        String[] data;
+        try {
+            data = new String[] {}; // 初始化
+            data[0] = "lisi";
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/expected.txt b/testsuite/java_test/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/test.cfg b/testsuite/java_test/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f32a1048056d1085e5cc54a58bf813e8a0aa7a4
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0007-rt-arrayboundary-ABCOemptyArray/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOemptyArray)
+run(ABCOemptyArray)
diff --git a/testsuite/java_test/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/ABCOemptyString.java b/testsuite/java_test/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/ABCOemptyString.java
new file mode 100755
index 0000000000000000000000000000000000000000..4c4a6a0dd91b030dcd34902196f202e9ad2dbb5b
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/ABCOemptyString.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOemptyString {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        try {
+            String string = "";
+            char c = string.charAt(0);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            String string = new String("");
+            int c = string.codePointAt(0);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/expected.txt b/testsuite/java_test/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/test.cfg b/testsuite/java_test/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ab958ff44a5919857b95579e5fa79c96961d4294
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0008-rt-arrayboundary-ABCOemptyString/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOemptyString)
+run(ABCOemptyString)
diff --git a/testsuite/java_test/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/ABCOfor.java b/testsuite/java_test/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/ABCOfor.java
new file mode 100755
index 0000000000000000000000000000000000000000..066f667f95a21226a55382877bba2b74b261f1a5
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/ABCOfor.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOfor {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[1024];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+        int[] b = new int[a.length];
+        try {
+            for (int i = 0; i <= a.length; i++) {
+                b[i] = a[i];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/expected.txt b/testsuite/java_test/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/test.cfg b/testsuite/java_test/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65b1bffdee956cbe2d0cc6218753dda1c622578d
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0009-rt-arrayboundary-ABCOfor/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOfor)
+run(ABCOfor)
diff --git a/testsuite/java_test/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/ABCOglobalArray.java b/testsuite/java_test/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/ABCOglobalArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..3fd53d6c5d131719965a5f2b93827996229bf9e3
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/ABCOglobalArray.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+public class ABCOglobalArray {
+    static int RES_PROCESS = 99;
+    static int[] a = new int[5];
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] b = new int[6];
+        Arrays.fill(a, 9);
+        for (int i = 0; i <= a.length; i++) {
+            b[i] = i;
+        }
+        int[] c = new int[6];
+        try {
+            for (int j = 0; j <= a.length; j++) {
+                int x = b[j];
+                c[x] = a[x];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/expected.txt b/testsuite/java_test/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/test.cfg b/testsuite/java_test/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c6c8118bb11f1711d467c6e19b4d19076c02ca91
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0010-rt-arrayboundary-ABCOglobalArray/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOglobalArray)
+run(ABCOglobalArray)
diff --git a/testsuite/java_test/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/ABCOglobalIndex.java b/testsuite/java_test/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/ABCOglobalIndex.java
new file mode 100755
index 0000000000000000000000000000000000000000..e3bffc1bed533c3c8a9241b759ef792d29b43fcf
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/ABCOglobalIndex.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOglobalIndex {
+    static int RES_PROCESS = 99;
+    static int x = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[1024];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+        int y = a.length;
+        try {
+            while (x < y) {
+                x = a[x + 1];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/expected.txt b/testsuite/java_test/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/test.cfg b/testsuite/java_test/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..247526a3b8cd7f8f57339ba5843de13b2238fc33
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0011-rt-arrayboundary-ABCOglobalIndex/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOglobalIndex)
+run(ABCOglobalIndex)
diff --git a/testsuite/java_test/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/ABCOglobalString.java b/testsuite/java_test/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/ABCOglobalString.java
new file mode 100755
index 0000000000000000000000000000000000000000..18fcb6539db351072525fd7450a08da9a516bea4
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/ABCOglobalString.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOglobalString {
+    static int RES_PROCESS = 99;
+    static String joinLine = new String();
+    static int index = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        joinLine = a.toString();
+        char[] b = new char[joinLine.length()];
+        try {
+            for (int j = 0; j <= joinLine.length(); j++) {
+                index = j;
+                b[index] = joinLine.charAt(index);
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/expected.txt b/testsuite/java_test/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/test.cfg b/testsuite/java_test/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16d5c3825e7dce13fbf23374246c1ab5b132ca9b
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0012-rt-arrayboundary-ABCOglobalString/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOglobalString)
+run(ABCOglobalString)
diff --git a/testsuite/java_test/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/ABCOif.java b/testsuite/java_test/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/ABCOif.java
new file mode 100755
index 0000000000000000000000000000000000000000..db709b45dffaa511ac5949adfe43f783012b2526
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/ABCOif.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOif {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] arr = new int[5];
+        int[] arrCp = arr;
+        for (int i = 0; i < arr.length; i++) {
+            arrCp[i] = i;
+        }
+        int y = arr.length;
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/expected.txt b/testsuite/java_test/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/test.cfg b/testsuite/java_test/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c927c7bbecc678d570102f19d7c2290815984cc2
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0013-rt-arrayboundary-ABCOif/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOif)
+run(ABCOif)
diff --git a/testsuite/java_test/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/ABCOincreaseArray.java b/testsuite/java_test/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/ABCOincreaseArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..1fa947c454107fc3cb0a6fb2f3bf019d18abc304
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/ABCOincreaseArray.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+public class ABCOincreaseArray {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        int[] a = new int[10];
+        Arrays.fill(a, 20);
+        int[] newArray = (int[]) func(a);
+        int index = newArray[0];
+        try {
+            int c = a[index - 11];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 5;
+        }
+        try {
+            int c = newArray[index];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+    public static Object func(Object array) {
+        Class<?> clazz = array.getClass();
+        if (clazz.isArray()) {
+            Class<?> componentType = clazz.getComponentType();
+            int length = Array.getLength(array);
+            Object newArray = Array.newInstance(componentType, length + 10);
+            System.arraycopy(array, 0, newArray, 0, length);
+            return newArray;
+        }
+        return null;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/expected.txt b/testsuite/java_test/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/test.cfg b/testsuite/java_test/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..38aa399edf2091c433fcd16757eaafe5ac976bb7
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0014-rt-arrayboundary-ABCOincreaseArray/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOincreaseArray)
+run(ABCOincreaseArray)
diff --git a/testsuite/java_test/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/ABCOindexAssociation.java b/testsuite/java_test/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/ABCOindexAssociation.java
new file mode 100755
index 0000000000000000000000000000000000000000..ec6ff2658537fe9c716201653d91346459364be4
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/ABCOindexAssociation.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOindexAssociation {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        int result2 = 4;
+        try {
+            result = test1();
+            result2 = test2();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && result2 == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] c = a;
+        try {
+            for (int i = 0; i <= a.length; i++) {
+                c[i] = i;
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int test2() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+        try {
+            for (int j = 1; j <= a.length; j++) {
+                if (a[j] > a[j - 1]) {
+                    j = a[j];
+                }
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/expected.txt b/testsuite/java_test/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/test.cfg b/testsuite/java_test/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6c3cc3d7719688f1dce125cb364f6233832a9812
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0015-rt-arrayboundary-ABCOindexAssociation/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOindexAssociation)
+run(ABCOindexAssociation)
diff --git a/testsuite/java_test/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/ABCOindexDoWhile.java b/testsuite/java_test/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/ABCOindexDoWhile.java
new file mode 100755
index 0000000000000000000000000000000000000000..2734deb425f4ccc71b0de024d83d50e919efb6e1
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/ABCOindexDoWhile.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOindexDoWhile {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        // catch ArrayIndexOutOfBoundsException
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[1000];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+        int[] b = new int[a.length];
+        int x = funx(100);
+        int y = funx(1000);
+        try {
+            do {
+                b[x] = a[x];
+                x++;
+            } while (x <= y);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index = 0;
+        do {
+            index = funy(index);
+        } while (index < endIndex);
+        return index;
+    }
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/expected.txt b/testsuite/java_test/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/test.cfg b/testsuite/java_test/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3b9d8065fb04226d74b886f692fc6eaa0990edc
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0016-rt-arrayboundary-ABCOindexDoWhile/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOindexDoWhile)
+run(ABCOindexDoWhile)
diff --git a/testsuite/java_test/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/ABCOindexFor.java b/testsuite/java_test/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/ABCOindexFor.java
new file mode 100755
index 0000000000000000000000000000000000000000..70fa28b99e666a5a1ec72a13dd43a8e701be4e23
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/ABCOindexFor.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOindexFor {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[1000];
+        int[] c = a;
+        for (int ii = 0; ii < a.length; ii++) {
+            c[ii] = ii;
+        }
+        int[] b = new int[a.length];
+        try {
+            for (int i = funx(100); i <= funx(1000); i++) {
+                if (i >= 1000) {
+                    for (int j = i; j > 0; j--) {
+                        int index = funx(1000);
+                        b[index] = a[index];
+                    }
+                }
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index;
+        for (index = 0; index <= endIndex; index++) {
+            index = funy(index);
+        }
+        return index;
+    }
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/expected.txt b/testsuite/java_test/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/test.cfg b/testsuite/java_test/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b9596d823b90d04c32feea6fd82427db23b7bb6e
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0017-rt-arrayboundary-ABCOindexFor/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOindexFor)
+run(ABCOindexFor)
diff --git a/testsuite/java_test/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/ABCOindexFromArrayFromParam.java b/testsuite/java_test/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/ABCOindexFromArrayFromParam.java
new file mode 100755
index 0000000000000000000000000000000000000000..02b073671711b41cae0ecf3fcd94bbd47d203e74
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/ABCOindexFromArrayFromParam.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOindexFromArrayFromParam {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            int num = 5;
+            result = test1(num);
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1(int num) {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        a[4] = num;
+        int[] c = a.clone();
+        int x = c[4];
+        try {
+            int b = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/expected.txt b/testsuite/java_test/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/test.cfg b/testsuite/java_test/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4a1914c0600a2cec527114aa2afb37aa8975b4ef
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOindexFromArrayFromParam)
+run(ABCOindexFromArrayFromParam)
diff --git a/testsuite/java_test/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/ABCOindexIf.java b/testsuite/java_test/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/ABCOindexIf.java
new file mode 100755
index 0000000000000000000000000000000000000000..c1425bc4b222a1bc4ab116323474a7dd72c1d421
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/ABCOindexIf.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Random;
+public class ABCOindexIf {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] arr = new int[5];
+        int[] arrCp = arr;
+        for (int i = 0; i < arr.length; i++) {
+            arrCp[i] = i;
+        }
+        int y = func();
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int func() {
+        Random r = new Random();
+        int get = r.nextInt(6);
+        if (get >= 5) {
+            return get;
+        } else {
+            get = func();
+            return get;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/expected.txt b/testsuite/java_test/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/test.cfg b/testsuite/java_test/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68baa68a1c0e6028e4e8296e11a4aeedbba828ad
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0019-rt-arrayboundary-ABCOindexIf/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOindexIf)
+run(ABCOindexIf)
diff --git a/testsuite/java_test/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/ABCOindexMutiLoop.java b/testsuite/java_test/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/ABCOindexMutiLoop.java
new file mode 100755
index 0000000000000000000000000000000000000000..94f497baa2d6eb7dfe891147017958fcfd43a25e
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/ABCOindexMutiLoop.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+public class ABCOindexMutiLoop {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        Arrays.fill(a, 8000);
+        int x;
+        try {
+            x = func();
+            int c = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+    public static int func() {
+        int index = 0;
+        for (int i = 0; i < 5; i++) {
+            for (int j = 0; j < 5; j++) {
+                for (int k = 0; k < 5; k++) {
+                    for (int ii = 0; ii < 5; ii++) {
+                        for (int jj = 0; jj < 5; jj++) {
+                            for (int kk = 0; kk < 5; kk++) {
+                                for (int iii = 0; iii < 5; iii++) {
+                                    for (int jjj = 0; jjj < 5; jjj++) {
+                                        for (int kkk = 0; kkk < 5; kkk++) {
+                                            for (int n = 0; n < 5; n++) {
+                                                index = index + n;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return index;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/expected.txt b/testsuite/java_test/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/test.cfg b/testsuite/java_test/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6716c9c5141d43177b21e60fdf0aaeb51c87957d
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0020-rt-arrayboundary-ABCOindexMutiLoop/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOindexMutiLoop)
+run(ABCOindexMutiLoop)
diff --git a/testsuite/java_test/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/ABCOindexNesting.java b/testsuite/java_test/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/ABCOindexNesting.java
new file mode 100755
index 0000000000000000000000000000000000000000..3fc7f00ea9501f98d546f1e23314849a2d8af3ea
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/ABCOindexNesting.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOindexNesting {
+    static int RES_PROCESS = 99;
+    static int arrNum = 1023;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[arrNum];
+        int[] c = a;
+        for (int i = 0; i < a.length; i++) {
+            c[i] = i;
+        }
+        int index = 0;
+        try {
+            for (int j = 1; j <= a.length; j++) {
+                if (j == a.length) {
+                    index = func(j, index);
+                    j = a[index];
+                }
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int func(int index, int getIndex) {
+        getIndex = funx(getIndex, index);
+        getIndex = getIndex + 10;
+        if (getIndex < index) {
+            getIndex = func(index, getIndex);
+        }
+        return getIndex;
+    }
+    public static int funx(int getIndex, int index) {
+        getIndex = getIndex + index;
+        getIndex = funy(getIndex, index);
+        return getIndex;
+    }
+    public static int funy(int getIndex, int index) {
+        getIndex = getIndex * index;
+        getIndex = funz(getIndex, index);
+        return getIndex;
+    }
+    public static int funz(int getIndex, int index) {
+        getIndex = getIndex / index;
+        getIndex = funw(getIndex, index);
+        return getIndex;
+    }
+    public static int funw(int getIndex, int index) {
+        getIndex = getIndex - index;
+        return getIndex;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/expected.txt b/testsuite/java_test/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/test.cfg b/testsuite/java_test/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9bc7fbb1d95ebec57f6a319ce799dc7e7f799131
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0021-rt-arrayboundary-ABCOindexNesting/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOindexNesting)
+run(ABCOindexNesting)
diff --git a/testsuite/java_test/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/ABCOindexSwitch.java b/testsuite/java_test/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/ABCOindexSwitch.java
new file mode 100755
index 0000000000000000000000000000000000000000..feffa2ec7f4785cc97402d784555fa860e9bb064
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/ABCOindexSwitch.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Random;
+public class ABCOindexSwitch {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] arrCp = a;
+        for (int i = 0; i < a.length; i++) {
+            arrCp[i] = i;
+        }
+        int c;
+        int x = func();
+        try {
+            c = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int func() {
+        Random r = new Random();
+        int getI = r.nextInt(3);
+        int y = getI % 3;
+        getI = getI + 5;
+        switch (y) {
+            case 0:
+                getI = getI + 0;
+                break;
+            case 1:
+                getI = getI + 1;
+                break;
+            default:
+                getI = getI + 2;
+        }
+        return getI;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/expected.txt b/testsuite/java_test/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/test.cfg b/testsuite/java_test/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5307a1284777029840cc6f423edbef888dc5c5c3
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0022-rt-arrayboundary-ABCOindexSwitch/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOindexSwitch)
+run(ABCOindexSwitch)
diff --git a/testsuite/java_test/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/ABCOlength.java b/testsuite/java_test/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/ABCOlength.java
new file mode 100755
index 0000000000000000000000000000000000000000..91b471564f31ac8b04fab549836a84cb630f01cb
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/ABCOlength.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOlength {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        try {
+            int b = a.length;
+            int c = a[b];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/expected.txt b/testsuite/java_test/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/test.cfg b/testsuite/java_test/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2386444e72b4d7f0536bb297f49ac97e5967d0db
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0023-rt-arrayboundary-ABCOlength/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOlength)
+run(ABCOlength)
diff --git a/testsuite/java_test/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/ABCOlistToArray.java b/testsuite/java_test/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/ABCOlistToArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..0e4dfa7a17f9fbbca6a385b81f60eca65dd908d9
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/ABCOlistToArray.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.List;
+public class ABCOlistToArray {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        String[] a = func();
+        int x = -1;
+        try {
+            String c = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        x = Integer.parseInt(a[a.length - 1]);
+        try {
+            String c = a[x];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+    public static String[] func() {
+        List<String> list = new ArrayList<>();
+        list.add("1");
+        list.add("2");
+        list.add("3");
+        list.add("4");
+        list.add("5");
+        String[] arr = new String[list.size()];
+        try {
+            list.toArray(arr);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return arr;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/expected.txt b/testsuite/java_test/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/test.cfg b/testsuite/java_test/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..00acfaeff3b95b416434b51ae88bcff27c2e69f3
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0024-rt-arrayboundary-ABCOlistToArray/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOlistToArray)
+run(ABCOlistToArray)
diff --git a/testsuite/java_test/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/ABCOlocalArray.java b/testsuite/java_test/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/ABCOlocalArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..ecd66d9d7c70518594b681abc5400273504d4170
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/ABCOlocalArray.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOlocalArray {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[][] arr = {{1, 2, 3}, {4, 5}, {6, 7, 8, 9}, {0}};
+        int y = arr.length - 1;
+        try {
+            int c = arr[-1][y];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            int c = arr[y][1];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/expected.txt b/testsuite/java_test/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/test.cfg b/testsuite/java_test/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..827637696d8092a71bd2a28ec4c19da0d825ce28
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0025-rt-arrayboundary-ABCOlocalArray/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOlocalArray)
+run(ABCOlocalArray)
diff --git a/testsuite/java_test/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/ABCOlocalIndex.java b/testsuite/java_test/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/ABCOlocalIndex.java
new file mode 100755
index 0000000000000000000000000000000000000000..5d34228a8ea1cd597524a47d2b70fa7d24b5d234
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/ABCOlocalIndex.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOlocalIndex {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[][] arr = {{1, 2, 3}, {4, 5}, {6, 7, 8, 9}, {0}};
+        int y = func();
+        try {
+            int c = arr[0][y];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            int c = arr[y][0];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+    public static int func() {
+        int getRand = 0;
+        for (int i = 0; i < 100; i++) {
+            getRand = getRand + i;
+            if (getRand > 100) {
+                break;
+            }
+        }
+        getRand = getRand + 4;
+        return getRand;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/expected.txt b/testsuite/java_test/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/test.cfg b/testsuite/java_test/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..384f7b887f288e97a809fc3d2bf5d98e69b526bc
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0026-rt-arrayboundary-ABCOlocalIndex/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOlocalIndex)
+run(ABCOlocalIndex)
diff --git a/testsuite/java_test/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/ABCOnewArraySize.java b/testsuite/java_test/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/ABCOnewArraySize.java
new file mode 100755
index 0000000000000000000000000000000000000000..d89ff31bbbfa109a6884df69088b40480d2bbf95
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/ABCOnewArraySize.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOnewArraySize {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] d = {0, 1, -1, 5};
+        try {
+            int b = d[2];
+            int c = a[b];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            int b = d[3];
+            int c = a[b];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/expected.txt b/testsuite/java_test/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/test.cfg b/testsuite/java_test/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..29dc9157108e926514ad7458159b23884e93186a
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0027-rt-arrayboundary-ABCOnewArraySize/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOnewArraySize)
+run(ABCOnewArraySize)
diff --git a/testsuite/java_test/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/ABCOnormal.java b/testsuite/java_test/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/ABCOnormal.java
new file mode 100755
index 0000000000000000000000000000000000000000..1cc7e8fbedf7cc0bcf65f41dfdd3980f9f8a58af
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/ABCOnormal.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOnormal {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        try {
+            int c = a[-1];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            int c = a[6];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/expected.txt b/testsuite/java_test/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/test.cfg b/testsuite/java_test/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5eaba25014de58eeed5dccb1a657133c4e7873f0
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0028-rt-arrayboundary-ABCOnormal/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOnormal)
+run(ABCOnormal)
diff --git a/testsuite/java_test/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/ABCOparamIndex.java b/testsuite/java_test/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/ABCOparamIndex.java
new file mode 100755
index 0000000000000000000000000000000000000000..93312b0ccb2971489359ab492a1b7289404d3c3a
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/ABCOparamIndex.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOparamIndex {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            int[] a = new int[5];
+            int[] c = a;
+            for (int i = 0; i < a.length; i++) {
+                c[i] = i + 1;
+            }
+            int y = c[4];
+            result = test1(a, y);
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1(int[] arr, int index) {
+        int res = 3 /*STATUS_FAILED*/;
+        try {
+            if (index >= 0) {
+                int c = arr[index];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/expected.txt b/testsuite/java_test/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/test.cfg b/testsuite/java_test/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7374ea1f2ce3c1b588255deb0fcb8f84a6f42b40
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0029-rt-arrayboundary-ABCOparamIndex/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOparamIndex)
+run(ABCOparamIndex)
diff --git a/testsuite/java_test/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/ABCOparam.java b/testsuite/java_test/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/ABCOparam.java
new file mode 100755
index 0000000000000000000000000000000000000000..53a4913edbadd9a238cbe6bf177fd98bfca79b02
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/ABCOparam.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOparam {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            int[] arr = new int[5];
+            result = test1(arr);
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1(int[] arr) {
+        int res = 3 /*STATUS_FAILED*/;
+        int y = arr.length;
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/expected.txt b/testsuite/java_test/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/test.cfg b/testsuite/java_test/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c65943ec4286649e9c25992ad6a955997d7b9e6a
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0030-rt-arrayboundary-ABCOparam/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOparam)
+run(ABCOparam)
diff --git a/testsuite/java_test/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/ABCOreflectArray.java b/testsuite/java_test/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/ABCOreflectArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..b91bf73c8db7ec587939bc7c6f315aeff03edfde
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/ABCOreflectArray.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Array;
+public class ABCOreflectArray {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        Array.setInt(a, 4, 5);
+        int x = (int) Array.get(a, 4);
+        try {
+            int c = (int) Array.get(a, x);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            Array.setInt(a, x, 5);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/expected.txt b/testsuite/java_test/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/test.cfg b/testsuite/java_test/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2db2f2c4c25c6d5737d3fe09c33712e195bd5138
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0031-rt-arrayboundary-ABCOreflectArray/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOreflectArray)
+run(ABCOreflectArray)
diff --git a/testsuite/java_test/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/ABCOreturnArray.java b/testsuite/java_test/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/ABCOreturnArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e63ae447c2d1ad9f08b57fb64b1affc9c18108c
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/ABCOreturnArray.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOreturnArray {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int[] func() {
+        int[] arr = new int[5];
+        return arr;
+    }
+    public static int test1() {
+        int[] arr = func();
+        int res = 3 /*STATUS_FAILED*/;
+        int y = arr.length;
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/expected.txt b/testsuite/java_test/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/test.cfg b/testsuite/java_test/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c412cf34a0a466f7751338f3259893de11987fc3
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0032-rt-arrayboundary-ABCOreturnArray/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOreturnArray)
+run(ABCOreturnArray)
diff --git a/testsuite/java_test/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/ABCOreturnIndex.java b/testsuite/java_test/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/ABCOreturnIndex.java
new file mode 100755
index 0000000000000000000000000000000000000000..ed860664e767cac33de3b1da65b468d941f86fbc
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/ABCOreturnIndex.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOreturnIndex {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int func() {
+        int getRand = 0;
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                for (int k = 0; k < 10; k++) {
+                    getRand = getRand + k;
+                    if (getRand > 200) {
+                        break;
+                    }
+                }
+            }
+        }
+        return getRand;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] arr = new int[100];
+        int[] arrCopy = arr;
+        for (int i = 0; i < arr.length; i++) {
+            arrCopy[i] = i;
+        }
+        int y = func();
+        try {
+            if (y >= 0) {
+                int c = arr[y];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/expected.txt b/testsuite/java_test/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/test.cfg b/testsuite/java_test/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ea95fc2b1329f3c5657235bad4bfdaca67ac67a
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0033-rt-arrayboundary-ABCOreturnIndex/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOreturnIndex)
+run(ABCOreturnIndex)
diff --git a/testsuite/java_test/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/ABCOreturnString.java b/testsuite/java_test/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/ABCOreturnString.java
new file mode 100755
index 0000000000000000000000000000000000000000..5465694bd16dbe46f1d492385f9102943c9d6913
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/ABCOreturnString.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+public class ABCOreturnString {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        String joinLine = funx();
+        int y = func();
+        try {
+            if (y >= 0) {
+                char c = joinLine.charAt(y);
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int func() {
+        int getRand = 0;
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                for (int k = 0; k < 10; k++) {
+                    getRand = getRand + k;
+                    if (getRand > 300) {
+                        break;
+                    }
+                }
+            }
+        }
+        return getRand;
+    }
+    public static String funx() {
+        char[] a = new char[100];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+        return joinLine;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/expected.txt b/testsuite/java_test/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/test.cfg b/testsuite/java_test/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..70e52df9f636eabddd3a653126213b76662679a8
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0034-rt-arrayboundary-ABCOreturnString/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOreturnString)
+run(ABCOreturnString)
diff --git a/testsuite/java_test/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/ABCOStringBuilderCatchEx.java b/testsuite/java_test/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/ABCOStringBuilderCatchEx.java
new file mode 100755
index 0000000000000000000000000000000000000000..61cb16cbc1036f00030510c8817f280b7feac9e9
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/ABCOStringBuilderCatchEx.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.List;
+public class ABCOStringBuilderCatchEx {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        try {
+            func();
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        } catch (Exception e) {
+            res = res + 2;
+        }
+        return res;
+    }
+    public static void func() throws Exception {
+        StringBuilder sbu = new StringBuilder();
+        List<String> lii = new ArrayList<>();
+        lii.add("welcome");
+        lii.add("to");
+        lii.add("hang");
+        lii.add("zhou");
+        lii.add("huawei");
+        lii.add("company");
+        for (String str : lii) {
+            sbu.append(str).append(",");
+        }
+        int endIndex = (sbu.toString()).length() + 1;
+        String getStr = sbu.toString().substring(0, endIndex);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/expected.txt b/testsuite/java_test/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/test.cfg b/testsuite/java_test/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..481586d5c0589fe96d71d1ad77965340623dc614
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOStringBuilderCatchEx)
+run(ABCOStringBuilderCatchEx)
diff --git a/testsuite/java_test/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/ABCOStringConstOperation.java b/testsuite/java_test/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/ABCOStringConstOperation.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1c1245796a7166f13a6e546fb71c62ba3d45572
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/ABCOStringConstOperation.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+public class ABCOStringConstOperation {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 10 /*STATUS_FAILED*/;
+        byte[] a = new byte[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = '1';
+        }
+        String joinLine = Arrays.toString(a);
+        int index = 1;
+        int y = joinLine.length();
+        try {
+            index = index + y + 9;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = y - joinLine.length() - index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = y * y * index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = index + 167772161;
+            index = (y / index) * y;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = index & index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = y | index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = ~index;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = y + y;
+            index = index ^ y;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            index = index + index;
+            y = 8195;
+            index = index % y;
+            String c = joinLine.substring(index);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/expected.txt b/testsuite/java_test/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/test.cfg b/testsuite/java_test/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..377a92c99fa124320e5a2d35751b3a2e3403fcb0
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0036-rt-arrayboundary-ABCOStringConstOperation/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOStringConstOperation)
+run(ABCOStringConstOperation)
diff --git a/testsuite/java_test/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/ABCOstringDoWhile.java b/testsuite/java_test/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/ABCOstringDoWhile.java
new file mode 100755
index 0000000000000000000000000000000000000000..84ec19ce098473d54c9a21a4403b85d86dbfdebb
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/ABCOstringDoWhile.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOstringDoWhile {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        String aCp = new String();
+        int x = 0;
+        do {
+            aCp = aCp + "hashl@^&@&2894684";
+            x++;
+        } while (x <= 9999);
+        String a = aCp;
+        x = funx(1000);
+        int y = funx(170000);
+        try {
+            do {
+                char c = a.charAt(x);
+                x++;
+            } while (x <= y);
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index = 0;
+        do {
+            index = funy(index);
+        } while (index < endIndex);
+        return index;
+    }
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/expected.txt b/testsuite/java_test/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/test.cfg b/testsuite/java_test/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8dbb5bb54a41e842a023bafad7cb4792d7d35019
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0037-rt-arrayboundary-ABCOstringDoWhile/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOstringDoWhile)
+run(ABCOstringDoWhile)
diff --git a/testsuite/java_test/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/ABCOstringFor.java b/testsuite/java_test/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/ABCOstringFor.java
new file mode 100755
index 0000000000000000000000000000000000000000..91b68191850d2c4430c3a17f41250c2eff4505ef
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/ABCOstringFor.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+public class ABCOstringFor {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+        char[] b = new char[joinLine.length()];
+        try {
+            for (int i = 0; i <= joinLine.length(); i++) {
+                int index = funx(i);
+                b[index] = joinLine.charAt(index);
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index;
+        for (index = 0; index <= endIndex; index++) {
+            index = funy(index);
+        }
+        return index;
+    }
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/expected.txt b/testsuite/java_test/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/test.cfg b/testsuite/java_test/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2794c5d3c1ef8857c76745d5a7b5f2086d063a1c
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0038-rt-arrayboundary-ABCOstringFor/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOstringFor)
+run(ABCOstringFor)
diff --git a/testsuite/java_test/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/ABCOstringIf.java b/testsuite/java_test/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/ABCOstringIf.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d15bc47cc80f9d23f78a69846ff167de8731f8a
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/ABCOstringIf.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.Random;
+public class ABCOstringIf {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        int result2 = 4;
+        try {
+            result = test1();
+            result2 = test2();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && result2 == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+        int y = func();
+        try {
+            if (y >= 0) {
+                char c = joinLine.charAt(y);
+                ;
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int test2() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+        try {
+            for (int i = 0; i < joinLine.length(); i++) {
+                if (joinLine.charAt(i) == joinLine.charAt(i + 1)) {
+                    char c = joinLine.charAt(i);
+                }
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int func() {
+        Random r = new Random();
+        int get = r.nextInt(6);
+        if (get >= 5) {
+            return get + 3072;
+        } else {
+            return get + 3072;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/expected.txt b/testsuite/java_test/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/test.cfg b/testsuite/java_test/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..29ab5c0d096faaba75a068c99cf7a86c70efbba6
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0039-rt-arrayboundary-ABCOstringIf/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOstringIf)
+run(ABCOstringIf)
diff --git a/testsuite/java_test/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/ABCOstringIndexNesting.java b/testsuite/java_test/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/ABCOstringIndexNesting.java
new file mode 100755
index 0000000000000000000000000000000000000000..0e57e5d44d7331ad6df5e98eb8b7b215ff31c117
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/ABCOstringIndexNesting.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+public class ABCOstringIndexNesting {
+    static int RES_PROCESS = 99;
+    static int arrNum = 1023;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'w';
+        }
+        String joinLine = Arrays.toString(a);
+        int index = 0;
+        try {
+            for (int j = 1; j <= joinLine.length(); j++) {
+                if (j == joinLine.length()) {
+                    index = func(j, index);
+                    char c = joinLine.charAt(index);
+                }
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int func(int index, int getIndex) {
+        getIndex = funx(getIndex, index);
+        getIndex = getIndex + 10;
+        if (getIndex < index) {
+            getIndex = func(index, getIndex);
+        }
+        return getIndex;
+    }
+    public static int funx(int getIndex, int index) {
+        getIndex = getIndex + index;
+        getIndex = funy(getIndex, index);
+        return getIndex;
+    }
+    public static int funy(int getIndex, int index) {
+        getIndex = getIndex * index;
+        getIndex = funz(getIndex, index);
+        return getIndex;
+    }
+    public static int funz(int getIndex, int index) {
+        getIndex = getIndex / index;
+        getIndex = funw(getIndex, index);
+        return getIndex;
+    }
+    public static int funw(int getIndex, int index) {
+        getIndex = getIndex - index;
+        return getIndex;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/expected.txt b/testsuite/java_test/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/test.cfg b/testsuite/java_test/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..56117614d247269eed4230101b3173c58524a2dd
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0040-rt-arrayboundary-ABCOstringIndexNesting/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOstringIndexNesting)
+run(ABCOstringIndexNesting)
diff --git a/testsuite/java_test/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/ABCOStringMaxValue.java b/testsuite/java_test/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/ABCOStringMaxValue.java
new file mode 100755
index 0000000000000000000000000000000000000000..f24b0849a9ad6b227187fd5aa14004c5092df2c0
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/ABCOStringMaxValue.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+public class ABCOStringMaxValue {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 5 /*STATUS_FAILED*/;
+        char[] a = new char[1024];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+        int max = Integer.MAX_VALUE;
+        int min = Integer.MIN_VALUE;
+        try {
+            int c = joinLine.codePointCount(min, 2);
+        } catch (IndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            char c = joinLine.charAt(min);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            int c = joinLine.codePointCount(0, max);
+        } catch (IndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            char c = joinLine.charAt(max);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/expected.txt b/testsuite/java_test/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/test.cfg b/testsuite/java_test/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3b52638ebf9fdd0fe2af0559c1b074eab46a1c97
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0041-rt-arrayboundary-ABCOStringMaxValue/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOStringMaxValue)
+run(ABCOStringMaxValue)
diff --git a/testsuite/java_test/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/ABCOstringMutiLoop.java b/testsuite/java_test/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/ABCOstringMutiLoop.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f9a4e9c8b495b567474ee11750c0d5879e90194
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/ABCOstringMutiLoop.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+public class ABCOstringMutiLoop {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 2 /*STATUS_FAILED*/;
+        char[] a = new char[8000];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+        int x;
+        try {
+            x = func();
+            char c = joinLine.charAt(x);
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+    public static int func() {
+        int index = 0;
+        for (int i = 0; i < 5; i++) {
+            for (int j = 0; j < 5; j++) {
+                for (int k = 0; k < 5; k++) {
+                    for (int ii = 0; ii < 5; ii++) {
+                        for (int jj = 0; jj < 5; jj++) {
+                            for (int kk = 0; kk < 5; kk++) {
+                                for (int iii = 0; iii < 5; iii++) {
+                                    for (int jjj = 0; jjj < 5; jjj++) {
+                                        for (int kkk = 0; kkk < 5; kkk++) {
+                                            for (int n = 0; n < 5; n++) {
+                                                index = index + n;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return index;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/expected.txt b/testsuite/java_test/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/test.cfg b/testsuite/java_test/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6896d8c0c6a5db6acfdec99e727ad512cf018144
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0042-rt-arrayboundary-ABCOstringMutiLoop/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOstringMutiLoop)
+run(ABCOstringMutiLoop)
diff --git a/testsuite/java_test/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/ABCOstringSwitch.java b/testsuite/java_test/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/ABCOstringSwitch.java
new file mode 100755
index 0000000000000000000000000000000000000000..2a009cfa5c24f71e4e2bacfcd4284715950ae5a0
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/ABCOstringSwitch.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.Random;
+public class ABCOstringSwitch {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[3000];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+        char c;
+        int x = func();
+        int y = x % 2;
+        try {
+            switch (y) {
+                case 0:
+                    c = joinLine.charAt(x);
+                    break;
+                default:
+                    c = joinLine.charAt(x);
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int func() {
+        Random r = new Random();
+        int getI = r.nextInt(3);
+        int y = getI % 3;
+        getI = getI + 9000;
+        switch (y) {
+            case 0:
+                getI = getI + 0;
+                break;
+            case 1:
+                getI = getI + 1;
+                break;
+            default:
+                getI = getI + 2;
+        }
+        return getI;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/expected.txt b/testsuite/java_test/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/test.cfg b/testsuite/java_test/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ec54308760c5fdf95178abcb7b08160adf477cfa
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0043-rt-arrayboundary-ABCOstringSwitch/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOstringSwitch)
+run(ABCOstringSwitch)
diff --git a/testsuite/java_test/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/ABCOswitch.java b/testsuite/java_test/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/ABCOswitch.java
new file mode 100755
index 0000000000000000000000000000000000000000..111a23866595893196ad8a8e8c2bf9d305e22645
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/ABCOswitch.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Random;
+public class ABCOswitch {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int c;
+        Random r = new Random();
+        int x = r.nextInt(2);
+        int y = x % 2;
+        x = x + 5;
+        try {
+            switch (y) {
+                case 0:
+                    c = a[x];
+                    break;
+                default:
+                    c = a[x];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/expected.txt b/testsuite/java_test/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/test.cfg b/testsuite/java_test/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ea3517f094f64e9eab1f909d3dbe9b4b71302fc8
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0044-rt-arrayboundary-ABCOswitch/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOswitch)
+run(ABCOswitch)
diff --git a/testsuite/java_test/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/ABCOtryExtEh.java b/testsuite/java_test/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/ABCOtryExtEh.java
new file mode 100755
index 0000000000000000000000000000000000000000..3471dd336374d6c24fd7c27a6af0a12a67318ab5
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/ABCOtryExtEh.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOtryExtEh {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        try {
+            int c = a[-1];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        } catch (IndexOutOfBoundsException e) {
+            res++;
+        }
+        try {
+            int c = a[6];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        } catch (IndexOutOfBoundsException e) {
+            res++;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/expected.txt b/testsuite/java_test/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/test.cfg b/testsuite/java_test/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..29224b329cf6c3212da3cd6563501fa4a0aa0792
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0045-rt-arrayboundary-ABCOtryExtEh/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOtryExtEh)
+run(ABCOtryExtEh)
diff --git a/testsuite/java_test/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/ABCOmaxValue.java b/testsuite/java_test/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/ABCOmaxValue.java
new file mode 100755
index 0000000000000000000000000000000000000000..403ca4653ba8a44b19ab9d76c1722a6722642614
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/ABCOmaxValue.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOmaxValue {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int max = Integer.MAX_VALUE;
+        int min = Integer.MIN_VALUE;
+        try {
+            int c = a[min];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        try {
+            int c = a[max];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res--;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/expected.txt b/testsuite/java_test/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/test.cfg b/testsuite/java_test/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3a2da34db5c35546ce01c4178e5da44837c6242e
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0046-rt-arrayboundary-ABCOmaxValue/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOmaxValue)
+run(ABCOmaxValue)
diff --git a/testsuite/java_test/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/ABCOwhile.java b/testsuite/java_test/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/ABCOwhile.java
new file mode 100755
index 0000000000000000000000000000000000000000..5a4f724ed124539f3ba4f6702b83b9a17175deea
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/ABCOwhile.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ABCOwhile {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out)); //
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        int[] a = new int[5];
+        int[] c = new int[a.length];
+        int x = 0;
+        int y = a.length;
+        try {
+            while (x <= y) {
+                c[x] = a[x];
+                x++;
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/expected.txt b/testsuite/java_test/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/test.cfg b/testsuite/java_test/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..317e9dc395e1fcb57981d9f07e2020fe0c5f4104
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0047-rt-arrayboundary-ABCOwhile/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOwhile)
+run(ABCOwhile)
diff --git a/testsuite/java_test/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/ABCOwhileString.java b/testsuite/java_test/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/ABCOwhileString.java
new file mode 100755
index 0000000000000000000000000000000000000000..f7f0cb012e29c86c7a783396e9fd7ce76097dc2b
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/ABCOwhileString.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Arrays;
+public class ABCOwhileString {
+    static int RES_PROCESS = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 4 /*STATUS_FAILED*/;
+        try {
+            result = test1();
+        } catch (Exception e) {
+            RES_PROCESS -= 10;
+        }
+        if (result == 1 && RES_PROCESS == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int test1() {
+        int res = 3 /*STATUS_FAILED*/;
+        char[] a = new char[100];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = 'h';
+        }
+        String joinLine = Arrays.toString(a);
+        char[] c = new char[joinLine.length()];
+        int x = funx(1000);
+        int y = funx(170000);
+        try {
+            while (x <= y) {
+                c[x] = joinLine.charAt(y);
+                ;
+                x++;
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            res = 1;
+        }
+        return res;
+    }
+    public static int funx(int maxFlag) {
+        int endIndex = maxFlag + 5;
+        int index = 0;
+        while (index < endIndex) {
+            index = funy(index);
+        }
+        return index;
+    }
+    public static int funy(int forIdx) {
+        int idx = forIdx + 100;
+        return idx;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/expected.txt b/testsuite/java_test/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/test.cfg b/testsuite/java_test/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..da7b14a3fe77c39b2f878636ff661bd1d2bc87b1
--- /dev/null
+++ b/testsuite/java_test/arrayboundary_test/RT0048-rt-arrayboundary-ABCOwhileString/test.cfg
@@ -0,0 +1,2 @@
+compile(ABCOwhileString)
+run(ABCOwhileString)
diff --git a/testsuite/java_test/clinit_test/RT0001-rt-clinit-clinit_base_001/ClinitBase001.java b/testsuite/java_test/clinit_test/RT0001-rt-clinit-clinit_base_001/ClinitBase001.java
new file mode 100644
index 0000000000000000000000000000000000000000..934141f965a43d58e5ccf2aa72f7253e558e25cd
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0001-rt-clinit-clinit_base_001/ClinitBase001.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+class TopLevelClass1 {
+    static int field;
+    static {
+        if (ClinitBase001.getCount() == 3) {
+            field = ClinitBase001.getCount();
+        }
+    }
+    int getField() {
+        return field;
+    }
+    static class StaticClass {
+        static int field;
+        static {
+            if (ClinitBase001.getCount() == 5) {
+                field = ClinitBase001.getCount();
+            }
+        }
+        int getField() {
+            return field;
+        }
+        static class StaticNestClass {
+            static int field;
+            static {
+                if (ClinitBase001.getCount() == 7) {
+                    field = ClinitBase001.getCount();
+                }
+            }
+            int getField() {
+                return field;
+            }
+            static class StaticInnerClass {
+                static int field;
+                static {
+                    if (ClinitBase001.getCount() == 1) {
+                        field = ClinitBase001.getCount();
+                    }
+                }
+                int getField() {
+                    return field;
+                }
+            }
+        }
+    }
+}
+public class ClinitBase001 {
+    static private int count = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0/*STATUS_PASSED*/;
+        // 创建内部静态类实例，触发内部静态类初始化，不触发外部类的初始化
+        TopLevelClass1.StaticClass.StaticNestClass.StaticInnerClass case4 =
+                new TopLevelClass1.StaticClass.StaticNestClass.StaticInnerClass();
+        // 创建外部类实例，触发外部类初始化，不触发内部类的初始化
+        TopLevelClass1 case1 = new TopLevelClass1();
+        // 创建内部静态类的实例，触发内部静态类初始化，不触发它内部类的初始化
+        TopLevelClass1.StaticClass case2 = new TopLevelClass1.StaticClass();
+        TopLevelClass1.StaticClass.StaticNestClass case3 =
+                new TopLevelClass1.StaticClass.StaticNestClass();
+        if (case1.getField() != 4) {
+            out.println("Error: TopLevelClass1 initialized Failed");
+            res = 2;
+        }
+        if (case2.getField() != 6) {
+            out.println("Error: TopLevelClass1.StaticClass initialized Failed");
+            res = 2;
+        }
+        if (case3.getField() != 8) {
+            out.println("Error: TopLevelClass1.StaticClass.StaticNestClass initialized Failed");
+            res = 2;
+        }
+        if (case4.getField() != 2) {
+            out.println("Error: TopLevelClass1.StaticClass.StaticNestClass initialized Failed");
+            res = 2;
+        }
+        //  new数组不触发对应类的初始化
+        TopLevelClass1[] array = new TopLevelClass1[4];
+        if (array.length != 4) {
+            res = 2;
+        }
+        if (count != 8) {
+            out.println("Error: class initialized should not be invoked twice");
+            res = 2;
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0001-rt-clinit-clinit_base_001/expected.txt b/testsuite/java_test/clinit_test/RT0001-rt-clinit-clinit_base_001/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0001-rt-clinit-clinit_base_001/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0001-rt-clinit-clinit_base_001/test.cfg b/testsuite/java_test/clinit_test/RT0001-rt-clinit-clinit_base_001/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f52765938f101322faf442007e5cbca9ba635b14
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0001-rt-clinit-clinit_base_001/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitBase001)
+run(ClinitBase001)
diff --git a/testsuite/java_test/clinit_test/RT0002-rt-clinit-clinit_base_002/ClinitBase002.java b/testsuite/java_test/clinit_test/RT0002-rt-clinit-clinit_base_002/ClinitBase002.java
new file mode 100644
index 0000000000000000000000000000000000000000..91bf2ee0f31c8b12b7d91a072e755b45a92bbc91
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0002-rt-clinit-clinit_base_002/ClinitBase002.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+abstract class CaseClass {
+    static float field;
+    static {
+        if (ClinitBase002.getCount() == 3) {
+            field = ClinitBase002.getCount();
+        }
+    }
+    static float getField() {
+        return (float) (field * 1.2);
+    }
+    public abstract int uselessFunction();
+    static class StaticClass {
+        static float field;
+        static {
+            if (ClinitBase002.getCount() == 1) {
+                field = ClinitBase002.getCount();
+            }
+        }
+        static float getField() {
+            return (float) (field * 1.2);
+        }
+    }
+}
+public class ClinitBase002 {
+    static private float count = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    static float getCount() {
+        count += 1.0f;
+        return count;
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+        // 创建继承内部静态类的局部类
+        class AnonymousClass extends CaseClass.StaticClass {
+        }
+        // 访问局部类的静态方法，触发父类初始化
+        if (AnonymousClass.getField() != 2.4f) {
+            res = 2;
+            out.println("Error: CaseClass.StaticClass not initialized");
+        }
+        // 创建继承外部类的局部类
+        class ClassChild extends CaseClass {
+            public int uselessFunction() {
+                return 0;
+            }
+        }
+        // 访问局部类的静态方法，触发父类初始化
+        if (ClassChild.getField() != 4.8f) {
+            res = 2;
+            out.println("Error: CaseClass not initialized");
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0002-rt-clinit-clinit_base_002/expected.txt b/testsuite/java_test/clinit_test/RT0002-rt-clinit-clinit_base_002/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0002-rt-clinit-clinit_base_002/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0002-rt-clinit-clinit_base_002/test.cfg b/testsuite/java_test/clinit_test/RT0002-rt-clinit-clinit_base_002/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cadaf59723a6b9ff70a40cb56a7a29183af6fd91
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0002-rt-clinit-clinit_base_002/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitBase002)
+run(ClinitBase002)
diff --git a/testsuite/java_test/clinit_test/RT0003-rt-clinit-clinit_base_003/ClinitBase003.java b/testsuite/java_test/clinit_test/RT0003-rt-clinit-clinit_base_003/ClinitBase003.java
new file mode 100644
index 0000000000000000000000000000000000000000..b0302d343eadfc98f5b64fa279116540d4cd95ed
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0003-rt-clinit-clinit_base_003/ClinitBase003.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+class CaseClass {
+    static float field;
+    static {
+        if (ClinitBase003.getCount() == 3) {
+            field = ClinitBase003.getCount();
+        }
+    }
+    public static class StaticClass {
+        public static float field;
+        static {
+            if (ClinitBase003.getCount() == 1) {
+                field = ClinitBase003.getCount();
+            }
+        }
+    }
+}
+public class ClinitBase003 {
+    static private float count = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    static float getCount() {
+        count += 1.0f;
+        return count;
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+        class CaseChild extends CaseClass {
+            class CaseStaticChild extends StaticClass {
+            }
+        }
+        // 对局部类的内部类的静态字段赋值，触发此类的初始化
+        CaseChild.CaseStaticChild.field = 20.0f;
+        // 对局部类的静态字段赋值，触发此类的初始化
+        CaseChild.field = 10.0f;
+        if (CaseClass.field != 10.0f) {
+            res = 2;
+            out.println("Error: CaseClass not initialized");
+        }
+        if (CaseClass.StaticClass.field != 20.0f) {
+            out.println(CaseClass.StaticClass.field);
+            res = 2;
+            out.println("Error: CaseClass.StaticClass not initialized");
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0003-rt-clinit-clinit_base_003/expected.txt b/testsuite/java_test/clinit_test/RT0003-rt-clinit-clinit_base_003/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0003-rt-clinit-clinit_base_003/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0003-rt-clinit-clinit_base_003/test.cfg b/testsuite/java_test/clinit_test/RT0003-rt-clinit-clinit_base_003/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..df990ffef0bbf024f492b71818a23627efc51851
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0003-rt-clinit-clinit_base_003/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitBase003)
+run(ClinitBase003)
diff --git a/testsuite/java_test/clinit_test/RT0004-rt-clinit-clinit_base_004/ClinitBase004.java b/testsuite/java_test/clinit_test/RT0004-rt-clinit-clinit_base_004/ClinitBase004.java
new file mode 100644
index 0000000000000000000000000000000000000000..930c482a7318ceb0b5134d9b945e2799734f6de7
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0004-rt-clinit-clinit_base_004/ClinitBase004.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+class Other {
+}
+class CaseClass {
+    static final float FIELD1 = ClinitBase004.getCount1();
+    static final String FIELD2 = ClinitBase004.getCount2();
+    static Other field3;
+    static {
+        if (ClinitBase004.count == 12) {
+            field3 = ClinitBase004.getCount3();
+        }
+    }
+}
+public class ClinitBase004 {
+    public static int count;
+    static {
+        count = 10;
+    }
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    static float getCount1() {
+        count += 1;
+        return (float) count;
+    }
+    static String getCount2() {
+        count += 1;
+        return String.valueOf(count);
+    }
+    static Other getCount3() {
+        count += 1;
+        return new Other();
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+        // 访问静态常量不应该触发类初始化
+        if (CaseClass.FIELD1 != 11.0f) {
+            res = 2;
+            out.println("Error1: CaseClass should not be initialized");
+        }
+        count++;
+        if (!CaseClass.FIELD2.equals("12")) {
+            res = 2;
+            out.println("Error2: CaseClass should not be initialized");
+        }
+        count++;
+        // 访问静态变量触发类初始化
+        if (CaseClass.field3 == null || count != 15) {
+            res = 2;
+            out.println("Error3: CaseClass not initialized");
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0004-rt-clinit-clinit_base_004/expected.txt b/testsuite/java_test/clinit_test/RT0004-rt-clinit-clinit_base_004/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0004-rt-clinit-clinit_base_004/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0004-rt-clinit-clinit_base_004/test.cfg b/testsuite/java_test/clinit_test/RT0004-rt-clinit-clinit_base_004/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1f73012da7dfb0698335adf658a8ed7861d2a6f2
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0004-rt-clinit-clinit_base_004/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitBase004)
+run(ClinitBase004)
diff --git a/testsuite/java_test/clinit_test/RT0005-rt-clinit-clinit_base_005/ClinitBase005.java b/testsuite/java_test/clinit_test/RT0005-rt-clinit-clinit_base_005/ClinitBase005.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d4522341a08a811bc26e27d546b98dec0a07ad0
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0005-rt-clinit-clinit_base_005/ClinitBase005.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+interface CaseInterface {
+    float FIELD1 = ClinitBase005.getCount1();
+    String FIELD2 = ClinitBase005.getCount2();
+    OtherCase FIELD3 = (ClinitBase005.count == 12) ? ClinitBase005.getCount3() : null;
+}
+class OtherCase {
+}
+class CaseClass implements CaseInterface {
+}
+public class ClinitBase005 {
+    public static int count;
+    static {
+        count = 10;
+    }
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    static float getCount1() {
+        count += 1;
+        return (float) count;
+    }
+    static String getCount2() {
+        count += 1;
+        return String.valueOf(count);
+    }
+    static OtherCase getCount3() {
+        count += 1;
+        return new OtherCase();
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+        if (CaseClass.FIELD1 != 11.0f) {
+            res = 2;
+            out.println("Error1: interface should not be initialized");
+        }
+        count++;
+        if (!CaseClass.FIELD2.equals("12")) {
+            res = 2;
+            out.println("Error2: interface should not be initialized");
+        }
+        count++;
+        if (CaseClass.FIELD3 == null || count != 15) {
+            res = 2;
+            out.println("Error3: interface not initialized");
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0005-rt-clinit-clinit_base_005/expected.txt b/testsuite/java_test/clinit_test/RT0005-rt-clinit-clinit_base_005/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0005-rt-clinit-clinit_base_005/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0005-rt-clinit-clinit_base_005/test.cfg b/testsuite/java_test/clinit_test/RT0005-rt-clinit-clinit_base_005/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b34e0baa63a1c8bad20ae25f2d052cb7477726cf
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0005-rt-clinit-clinit_base_005/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitBase005)
+run(ClinitBase005)
diff --git a/testsuite/java_test/clinit_test/RT0006-rt-clinit-clinit_base_006/ClinitBase006.java b/testsuite/java_test/clinit_test/RT0006-rt-clinit-clinit_base_006/ClinitBase006.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a55e17d7aa8b22649bc3cd5113bd14f82a7ba50
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0006-rt-clinit-clinit_base_006/ClinitBase006.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+class CaseForName1 {
+    static int field;
+    static {
+        if (ClinitBase006.getCount() == 1) {
+            field = ClinitBase006.getCount();
+        }
+    }
+}
+class CaseForName2 {
+    static int field;
+    static {
+        if (ClinitBase006.getCount() == 3) {
+            field = ClinitBase006.getCount();
+        }
+    }
+}
+class CaseForName3 {
+    static int field;
+    static {
+        if (ClinitBase006.getCount() == 5) {
+            field = ClinitBase006.getCount();
+        }
+    }
+}
+class CaseClassInstance {
+    static int field;
+    static {
+        if (ClinitBase006.getCount() == 7) {
+            field = ClinitBase006.getCount();
+        }
+    }
+}
+class CaseClassMethod {
+    static int field;
+    static {
+        if (ClinitBase006.getCount() == 5) {
+            field = ClinitBase006.getCount();
+        }
+        System.out.println("hello");
+    }
+    static int getField() {
+        return field;
+    }
+}
+public class ClinitBase006 {
+    public static int count;
+    public static void main(String[] argv) {
+        ClinitBase006 test = new ClinitBase006();
+        System.out.println(test.run(argv, System.out)/*STATUS_TEMP*/);
+    }
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+    private int run(String[] argv, PrintStream out) {
+        int res = 0;
+        try {
+            Class forName1 = Class.forName("CaseForName1");
+            if (count != 2 || forName1.getDeclaredField("field").getInt(null) != 2) {
+                res = 2;
+                out.println("Error, CaseForName1 not initialized");
+            }
+            Class forName2 = Class.forName("CaseForName2", true, this.getClass().getClassLoader());
+            if (count != 4 || forName2.getDeclaredField("field").getInt(null) != 4) {
+                res = 2;
+                out.println("Error, CaseForName2 not initialized");
+            }
+            Class forName3 = Class.forName("CaseForName3", false, this.getClass().getClassLoader());
+            if (count != 4 || forName3.getDeclaredField("field").getInt(null) != 6) {
+                res = 2;
+                out.println("Error, CaseForName3 not initialized");
+            }
+            CaseClassInstance caseInstance = CaseClassInstance.class.newInstance();
+            if (count != 8 || CaseClassInstance.field != 8) {
+                res = 2;
+                out.println("Error, case6_instance not initialized");
+            }
+        } catch (Exception e) {
+            res = 2;
+            out.println(e);
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0006-rt-clinit-clinit_base_006/expected.txt b/testsuite/java_test/clinit_test/RT0006-rt-clinit-clinit_base_006/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0006-rt-clinit-clinit_base_006/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0006-rt-clinit-clinit_base_006/test.cfg b/testsuite/java_test/clinit_test/RT0006-rt-clinit-clinit_base_006/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50b6719561f97a2fc894283b8d5474088b7b3666
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0006-rt-clinit-clinit_base_006/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitBase006)
+run(ClinitBase006)
diff --git a/testsuite/java_test/clinit_test/RT0007-rt-clinit-clinit_base_007/ClinitBase007.java b/testsuite/java_test/clinit_test/RT0007-rt-clinit-clinit_base_007/ClinitBase007.java
new file mode 100755
index 0000000000000000000000000000000000000000..93eb7d3506134bc7322837d0a76e544f5b3131b9
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0007-rt-clinit-clinit_base_007/ClinitBase007.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ClinitBase007 {
+    static int res = 2;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        ClinitBaseB.testAsserts();
+        return res;
+    }
+}
+class ClinitBaseA {
+    static {
+        ClinitBaseB.testAsserts();
+    }
+}
+class ClinitBaseB extends ClinitBaseA {
+    static void testAsserts() {
+        boolean enable = false;
+        assert enable = true;
+        if (!enable) {
+            ClinitBase007.res -= 1;
+        } else {
+            System.out.println("Asserts enable");
+        }
+    }
+}
diff --git a/testsuite/java_test/clinit_test/RT0007-rt-clinit-clinit_base_007/expected.txt b/testsuite/java_test/clinit_test/RT0007-rt-clinit-clinit_base_007/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0007-rt-clinit-clinit_base_007/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0007-rt-clinit-clinit_base_007/test.cfg b/testsuite/java_test/clinit_test/RT0007-rt-clinit-clinit_base_007/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ccd9a5fc4cf498ab2f155bad615e4ddb1bb154c7
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0007-rt-clinit-clinit_base_007/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitBase007)
+run(ClinitBase007)
diff --git a/testsuite/java_test/clinit_test/RT0008-rt-clinit-clinit_base_008/ClinitBase008.java b/testsuite/java_test/clinit_test/RT0008-rt-clinit-clinit_base_008/ClinitBase008.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5b9bc63995744a52d908901461249a6f42ac20e
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0008-rt-clinit-clinit_base_008/ClinitBase008.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ClinitBase008 {
+    static int res = 0;
+    static {
+        res = 1;
+    }
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        if (res == 1) {
+            return 0;
+        } else {
+            return 1;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0008-rt-clinit-clinit_base_008/expected.txt b/testsuite/java_test/clinit_test/RT0008-rt-clinit-clinit_base_008/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0008-rt-clinit-clinit_base_008/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0008-rt-clinit-clinit_base_008/test.cfg b/testsuite/java_test/clinit_test/RT0008-rt-clinit-clinit_base_008/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..32c6e691e1635d2b858453f25839f567f2479626
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0008-rt-clinit-clinit_base_008/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitBase008)
+run(ClinitBase008)
diff --git a/testsuite/java_test/clinit_test/RT0009-rt-clinit-clinit_seq_001/ClinitSeq001.java b/testsuite/java_test/clinit_test/RT0009-rt-clinit-clinit_seq_001/ClinitSeq001.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6312ee00f63a9187d7b40fcffd7c833601fcc8e
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0009-rt-clinit-clinit_seq_001/ClinitSeq001.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+class FatherClass {
+    static int field;
+    static {
+        if (ClinitSeq001.getCount() == 1) {
+            field = ClinitSeq001.getCount();
+        }
+    }
+}
+class ChildClass extends FatherClass {
+    static int field;
+    static {
+        if (ClinitSeq001.getCount() == 3) {
+            field = ClinitSeq001.getCount();
+        }
+    }
+}
+public class ClinitSeq001 {
+    static private int count = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out) /*STATUS_TEMP*/);
+    }
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0/*STATUS_PASSED*/;
+        if (ChildClass.field != 4) {
+            res = 2;
+            out.println("Error, ChildClass not initialized");
+        }
+        if (FatherClass.field != 2) {
+            res = 2;
+            out.println("Error, FatherClass not initialized");
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0009-rt-clinit-clinit_seq_001/expected.txt b/testsuite/java_test/clinit_test/RT0009-rt-clinit-clinit_seq_001/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0009-rt-clinit-clinit_seq_001/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0009-rt-clinit-clinit_seq_001/test.cfg b/testsuite/java_test/clinit_test/RT0009-rt-clinit-clinit_seq_001/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..289eaa7ab1a16bb1052791e4178539379512aa27
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0009-rt-clinit-clinit_seq_001/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitSeq001)
+run(ClinitSeq001)
diff --git a/testsuite/java_test/clinit_test/RT0010-rt-clinit-clinit_seq_002/ClinitSeq002.java b/testsuite/java_test/clinit_test/RT0010-rt-clinit-clinit_seq_002/ClinitSeq002.java
new file mode 100644
index 0000000000000000000000000000000000000000..dbf40ccb35cbc5e8ffbec094396621612be82d0c
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0010-rt-clinit-clinit_seq_002/ClinitSeq002.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+interface CaseInterface {
+    int FIELD = ClinitSeq002.getCount();
+    CaseOtherClass MEMBER = new CaseOtherClass();
+    default int uselessFunction(int a, int b) {
+        return a + b;
+    }
+}
+class CaseOtherClass {
+    static int field;
+    static {
+        if (ClinitSeq002.getCount() == 2) {
+            field = ClinitSeq002.getCount();
+        }
+    }
+}
+class CaseChild implements CaseInterface {
+    static int field;
+    static {
+        if (ClinitSeq002.getCount() == 4) {
+            field = ClinitSeq002.getCount();
+        }
+    }
+}
+public class ClinitSeq002 {
+    static private int count = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out) /*STATUS_TEMP*/);
+    }
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+        // 访问child field触发类初始化
+        if (CaseChild.field != 5) {
+            res = 2;
+            out.println("Error, child not initialized");
+        }
+        // 访问CaseOtherClass field触发类初始化
+        if (CaseOtherClass.field != 3) {
+            res = 2;
+            out.println("Error, other not initialized");
+        }
+        // 访问interface常量，触发初始化
+        if (CaseInterface.FIELD != 1) {
+            res = 2;
+            out.println("Error, interface not initialized");
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0010-rt-clinit-clinit_seq_002/expected.txt b/testsuite/java_test/clinit_test/RT0010-rt-clinit-clinit_seq_002/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0010-rt-clinit-clinit_seq_002/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0010-rt-clinit-clinit_seq_002/test.cfg b/testsuite/java_test/clinit_test/RT0010-rt-clinit-clinit_seq_002/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..994d1af1b09c95c31310a1812ba67f9e18762ead
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0010-rt-clinit-clinit_seq_002/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitSeq002)
+run(ClinitSeq002)
diff --git a/testsuite/java_test/clinit_test/RT0011-rt-clinit-clinit_seq_003/ClinitSeq003.java b/testsuite/java_test/clinit_test/RT0011-rt-clinit-clinit_seq_003/ClinitSeq003.java
new file mode 100644
index 0000000000000000000000000000000000000000..f566a75ebcc475d5479d2e4d8211487b97b4984b
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0011-rt-clinit-clinit_seq_003/ClinitSeq003.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+interface CaseInterface {
+    int FIELD = ClinitSeq003.getCount();
+    CaseOtherClass MEMBER = new CaseOtherClass();
+    default int uselessFunction(int a, int b) {
+        return a + b;
+    }
+}
+class CaseOtherClass {
+    static int field;
+    static {
+        if (ClinitSeq003.getCount() == 4) {
+            field = ClinitSeq003.getCount();
+        }
+    }
+}
+class CaseFather {
+    static int field;
+    static {
+        if (ClinitSeq003.getCount() == 1) {
+            field = ClinitSeq003.getCount();
+        }
+    }
+}
+class CaseChild extends CaseFather implements CaseInterface {
+    static int field;
+    static {
+        if (ClinitSeq003.getCount() == 6) {
+            field = ClinitSeq003.getCount();
+        }
+    }
+}
+public class ClinitSeq003 {
+    static private int count = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out) /*STATUS_TEMP*/);
+    }
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+        // 访问子类的字段
+        if (CaseChild.field != 7) {
+            res = 2;
+            out.println(CaseChild.field);
+            out.println("Error, child not initialized");
+        }
+        // 接口中的字段对应的类被触发初始化
+        if (CaseOtherClass.field != 5) {
+            res = 2;
+            out.println("Error, other not initialized");
+        }
+        // 包含有default方法的接口被触发初始化
+        if (CaseInterface.FIELD != 3) {
+            res = 2;
+            out.println("Error, interface not initialized");
+        }
+        // 父类被触发初始化
+        if (CaseFather.field != 2) {
+            res = 2;
+            out.println("Error, father not initialized");
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0011-rt-clinit-clinit_seq_003/expected.txt b/testsuite/java_test/clinit_test/RT0011-rt-clinit-clinit_seq_003/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0011-rt-clinit-clinit_seq_003/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0011-rt-clinit-clinit_seq_003/test.cfg b/testsuite/java_test/clinit_test/RT0011-rt-clinit-clinit_seq_003/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a6a8e4988ccd10853581b42934fb5b6b51d2183
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0011-rt-clinit-clinit_seq_003/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitSeq003)
+run(ClinitSeq003)
diff --git a/testsuite/java_test/clinit_test/RT0012-rt-clinit-clinit_seq_004/ClinitSeq004.java b/testsuite/java_test/clinit_test/RT0012-rt-clinit-clinit_seq_004/ClinitSeq004.java
new file mode 100644
index 0000000000000000000000000000000000000000..df053c7d6a41585d35d8d53c5813293d6b4342aa
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0012-rt-clinit-clinit_seq_004/ClinitSeq004.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+interface CaseInterface {
+    int FIELD = ClinitSeq004.getCount();
+    CaseOtherClass MEMBER = new CaseOtherClass();
+    default int uselessFunction(int a, int b) {
+        return a + b;
+    }
+}
+interface CaseChild extends CaseInterface {
+    int FIELD_CHILD = ClinitSeq004.getCount();
+}
+class CaseOtherClass {
+    static int field;
+    static {
+        if (ClinitSeq004.getCount() == 3) {
+            field = ClinitSeq004.getCount();
+        }
+    }
+}
+public class ClinitSeq004 {
+    static private int count = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+        if (CaseChild.FIELD_CHILD != 1) {
+            res = 2;
+            out.println("Error, child not initialized");
+        }
+        if (CaseInterface.FIELD != 2) {
+            res = 2;
+            out.println("Error, interface not initialized");
+        }
+        if (CaseOtherClass.field != 4) {
+            res = 2;
+            out.println("Error, other not initialized");
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0012-rt-clinit-clinit_seq_004/expected.txt b/testsuite/java_test/clinit_test/RT0012-rt-clinit-clinit_seq_004/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0012-rt-clinit-clinit_seq_004/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0012-rt-clinit-clinit_seq_004/test.cfg b/testsuite/java_test/clinit_test/RT0012-rt-clinit-clinit_seq_004/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1358ff1f76dbe350ca4d0f36d3ae4cb30ed36c75
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0012-rt-clinit-clinit_seq_004/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitSeq004)
+run(ClinitSeq004)
diff --git a/testsuite/java_test/clinit_test/RT0013-rt-clinit-clinit_seq_005/ClinitSeq005.java b/testsuite/java_test/clinit_test/RT0013-rt-clinit-clinit_seq_005/ClinitSeq005.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7360622ffa7de94a9d53d9490611395636fec98
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0013-rt-clinit-clinit_seq_005/ClinitSeq005.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+interface CaseInterface {
+    int FIELD = ClinitSeq005.getCount();
+    CaseOtherClass MEMBER = new CaseOtherClass();
+    int uselessFunction(int a, int b);
+}
+class CaseOtherClass {
+    static int field;
+    static {
+        if (ClinitSeq005.getCount() == 4) {
+            field = ClinitSeq005.getCount();
+        }
+    }
+}
+class CaseChild implements CaseInterface {
+    static int field;
+    static {
+        if (ClinitSeq005.getCount() == 1) {
+            field = ClinitSeq005.getCount();
+        }
+    }
+    public int uselessFunction(int a, int b) {
+        return a + b;
+    }
+}
+public class ClinitSeq005 {
+    static private int count = 0;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    static int getCount() {
+        count += 1;
+        return count;
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int res = 0;
+        if (CaseChild.field != 2) {
+            res = 2;
+            out.println("Error, child not initialized");
+        }
+        if (CaseInterface.MEMBER.field != 5) {
+            res = 2;
+            out.println("Error, other not initialized");
+        }
+        if (CaseInterface.FIELD != 3) {
+            res = 2;
+            out.println("Error, interface not initialized");
+        }
+        return res;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/clinit_test/RT0013-rt-clinit-clinit_seq_005/expected.txt b/testsuite/java_test/clinit_test/RT0013-rt-clinit-clinit_seq_005/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0013-rt-clinit-clinit_seq_005/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0013-rt-clinit-clinit_seq_005/test.cfg b/testsuite/java_test/clinit_test/RT0013-rt-clinit-clinit_seq_005/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6963e4931b4565930d507eae5955c5da6f1a1699
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0013-rt-clinit-clinit_seq_005/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitSeq005)
+run(ClinitSeq005)
diff --git a/testsuite/java_test/clinit_test/RT0014-rt-clinit-clinit_eh_001/ClinitEh001.java b/testsuite/java_test/clinit_test/RT0014-rt-clinit-clinit_eh_001/ClinitEh001.java
new file mode 100755
index 0000000000000000000000000000000000000000..493d32aa16b960ad57c550a05e940e1d7b6143be
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0014-rt-clinit-clinit_eh_001/ClinitEh001.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+class ThreadCaseClass {
+    static volatile int field;
+    static {
+        int temp = ClinitEh001.getCount();
+        if (temp == 0) {
+            int a = ClinitEh001.getCount();
+            int b = ClinitEh001.getCount();
+            field = a / (b - 2);
+        }
+        System.out.println("Only be invoked once");
+    }
+}
+public class ClinitEh001 {
+    private static final int THREAD_COUNT = 10;
+    private static int count = 0;
+    static volatile private int initErrCount = 0;
+    static volatile private int notDefCount = 0;
+    // CyclicBarrier 适用再多线程相互等待，直到到达一个屏障点。并且CyclicBarrier是可重用的
+    private CyclicBarrier cyclicBarrier = new CyclicBarrier(THREAD_COUNT);
+    static int getCount() {
+        return count++;
+    }
+    static synchronized void InitializerErrorCnt() {
+        initErrCount += 1;
+    }
+    static synchronized void NotDefErrorCnt() {
+        notDefCount += 1;
+    }
+    public static void main(String[] args) {
+        ClinitEh001 test = new ClinitEh001();
+        ExecutorService executorService = test.runThread();
+        executorService.shutdown();
+        try {
+            if (executorService.awaitTermination(10, TimeUnit.SECONDS)) {
+                if (count != 3) {
+                    System.out.println(1);
+                } else {
+                    System.out.println(0);
+                }
+            }
+        } catch (InterruptedException ex) {
+            ex.printStackTrace();
+            System.out.println(1);
+        }
+        if (count != 3) {
+            System.out.println("Error, ClinitEh001 initialized error");
+        }
+        if (initErrCount != 1) {
+            System.out.println("Should be only invoked once, but actual invoked "
+                    + initErrCount);
+        }
+        if (notDefCount != (THREAD_COUNT - 1)) {
+            System.out.println("Should be invoked " + (THREAD_COUNT - 1)
+                    + ", but actual invoked " + notDefCount);
+        }
+    }
+    private ExecutorService runThread() {
+        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            executorService.submit(createThread(i));
+        }
+        return executorService;
+    }
+    private Thread createThread(int i) {
+        return new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    cyclicBarrier.await();
+                    try {
+                        if (ThreadCaseClass.field == 2) {
+                            ThreadCaseClass.field = ClinitEh001.getCount();
+                        }
+                    } catch (ExceptionInInitializerError e) {
+                        ClinitEh001.InitializerErrorCnt();
+                    } catch (NoClassDefFoundError e) {
+                        ClinitEh001.NotDefErrorCnt();
+                    }
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}
diff --git a/testsuite/java_test/clinit_test/RT0014-rt-clinit-clinit_eh_001/expected.txt b/testsuite/java_test/clinit_test/RT0014-rt-clinit-clinit_eh_001/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0014-rt-clinit-clinit_eh_001/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0014-rt-clinit-clinit_eh_001/test.cfg b/testsuite/java_test/clinit_test/RT0014-rt-clinit-clinit_eh_001/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a618d7f7cca0e8bc9e2459059737a6ad965240ec
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0014-rt-clinit-clinit_eh_001/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitEh001)
+run(ClinitEh001)
diff --git a/testsuite/java_test/clinit_test/RT0015-rt-clinit-clinit_eh_002/ClinitEh002.java b/testsuite/java_test/clinit_test/RT0015-rt-clinit-clinit_eh_002/ClinitEh002.java
new file mode 100755
index 0000000000000000000000000000000000000000..63d7bf68b782e1f344a0f2cba3f705694c3ea749
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0015-rt-clinit-clinit_eh_002/ClinitEh002.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+class ThreadFatherClass {
+    static volatile int field;
+    static {
+        int temp = ClinitEh002.getCount();
+        if (temp == 0) {
+            int a = ClinitEh002.getCount();
+            int b = ClinitEh002.getCount();
+            field = a / (b - 2);
+        }
+        System.out.println("Only be invoked once");
+    }
+}
+class ThreadChildClass extends ThreadFatherClass {
+    static volatile int field = ClinitEh002.getCount();
+}
+public class ClinitEh002 {
+    private static final int THREAD_COUNT = 10;
+    private static int count = 0;
+    static volatile private int initErrCount = 0;
+    static volatile private int notDefCount = 0;
+    // CyclicBarrier 适用再多线程相互等待，直到到达一个屏障点。并且CyclicBarrier是可重用的
+    private CyclicBarrier cyclicBarrier = new CyclicBarrier(THREAD_COUNT);
+    static int getCount() {
+        return count++;
+    }
+    static synchronized void InitializerErrorCnt() {
+        initErrCount += 1;
+    }
+    static synchronized void NotDefErrorCnt() {
+        notDefCount += 1;
+    }
+    public static void main(String[] args) {
+        ClinitEh002 test = new ClinitEh002();
+        ExecutorService executorService = test.runThread();
+        executorService.shutdown();
+        try {
+            if (executorService.awaitTermination(10, TimeUnit.SECONDS)) {
+                if (count != 3) {
+                    System.out.println(1);
+                } else {
+                    System.out.println(0);
+                }
+            }
+        } catch (InterruptedException ex) {
+            ex.printStackTrace();
+            System.out.println(1);
+        }
+        if (count != 3) {
+            System.out.println("Error, ClinitEh002 initialized error");
+        }
+        if (initErrCount != 1) {
+            System.out.println("Should be only invoked once, but actual invoked "
+                    + initErrCount);
+        }
+        if (notDefCount != (THREAD_COUNT - 1)) {
+            System.out.println("Should be invoked " + (THREAD_COUNT - 1)
+                    + ", but actual invoked " + notDefCount);
+        }
+    }
+    private ExecutorService runThread() {
+        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            executorService.submit(createThread(i));
+        }
+        return executorService;
+    }
+    private Thread createThread(int i) {
+        return new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    cyclicBarrier.await();
+                    try {
+                        if (ThreadChildClass.field == 2) {
+                            ThreadFatherClass.field = ClinitEh002.getCount();
+                        }
+                    } catch (ExceptionInInitializerError e) {
+                        ClinitEh002.InitializerErrorCnt();
+                    } catch (NoClassDefFoundError e) {
+                        ClinitEh002.NotDefErrorCnt();
+                    }
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}
diff --git a/testsuite/java_test/clinit_test/RT0015-rt-clinit-clinit_eh_002/expected.txt b/testsuite/java_test/clinit_test/RT0015-rt-clinit-clinit_eh_002/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0015-rt-clinit-clinit_eh_002/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0015-rt-clinit-clinit_eh_002/test.cfg b/testsuite/java_test/clinit_test/RT0015-rt-clinit-clinit_eh_002/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b621ede32c481523c0e0ae01a6a582975a19e704
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0015-rt-clinit-clinit_eh_002/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitEh002)
+run(ClinitEh002)
diff --git a/testsuite/java_test/clinit_test/RT0016-rt-clinit-clinit_eh_003/ClinitEh003.java b/testsuite/java_test/clinit_test/RT0016-rt-clinit-clinit_eh_003/ClinitEh003.java
new file mode 100755
index 0000000000000000000000000000000000000000..9a74c3ff30068999964c364ec2fe662c0e48585a
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0016-rt-clinit-clinit_eh_003/ClinitEh003.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+class ThreadClass {
+    static volatile int field;
+    static {
+        try {
+            int temp = ClinitEh003.getCount();
+            if (temp == 0) {
+                int a = ClinitEh003.getCount();
+                int b = ClinitEh003.getCount();
+                field = a / (b - 2);
+            }
+        } catch (Exception e) {
+            ClinitEh003.getCount();
+        }
+    }
+}
+public class ClinitEh003 {
+    private static final int THREAD_COUNT = 10;
+    private static int count = 0;
+    static volatile private int initErrCount = 0;
+    static volatile private int notDefCount = 0;
+    // CyclicBarrier 适用再多线程相互等待，直到到达一个屏障点。并且CyclicBarrier是可重用的
+    private CyclicBarrier cyclicBarrier = new CyclicBarrier(THREAD_COUNT);
+    static int getCount() {
+        return count++;
+    }
+    static synchronized void InitializerErrorCnt() {
+        initErrCount += 1;
+    }
+    static synchronized void NotDefErrorCnt() {
+        notDefCount += 1;
+    }
+    public static void main(String[] args) {
+        ClinitEh003 test = new ClinitEh003();
+        ExecutorService executorService = test.runThread();
+        executorService.shutdown();
+        try {
+            if (executorService.awaitTermination(10, TimeUnit.SECONDS)) {
+                if (count != 4) {
+                    System.out.println(1);
+                } else {
+                    System.out.println(0);
+                }
+            }
+        } catch (InterruptedException ex) {
+            ex.printStackTrace();
+        }
+        if (initErrCount != 0) {
+            System.out.println("Should be only invoked once, but actual invoked "
+                    + initErrCount);
+        }
+        if (notDefCount != 0) {
+            System.out.println("Should be invoked " + (THREAD_COUNT - 1)
+                    + ", but actual invoked " + notDefCount);
+        }
+    }
+    private ExecutorService runThread() {
+        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            executorService.submit(createThread(i));
+        }
+        return executorService;
+    }
+    private Thread createThread(int i) {
+        return new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    cyclicBarrier.await();
+                    try {
+                        if (ThreadClass.field == 0) {
+                            ThreadClass.field = 5;
+                        }
+                    } catch (ExceptionInInitializerError e) {
+                        ClinitEh003.InitializerErrorCnt();
+                    } catch (NoClassDefFoundError e) {
+                        ClinitEh003.NotDefErrorCnt();
+                    }
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}
diff --git a/testsuite/java_test/clinit_test/RT0016-rt-clinit-clinit_eh_003/expected.txt b/testsuite/java_test/clinit_test/RT0016-rt-clinit-clinit_eh_003/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0016-rt-clinit-clinit_eh_003/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0016-rt-clinit-clinit_eh_003/test.cfg b/testsuite/java_test/clinit_test/RT0016-rt-clinit-clinit_eh_003/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..378036c3cc6c10d225a720a79c07faddd8d5c27c
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0016-rt-clinit-clinit_eh_003/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitEh003)
+run(ClinitEh003)
diff --git a/testsuite/java_test/clinit_test/RT0017-rt-clinit-clinit_thread_001/ClinitThread001.java b/testsuite/java_test/clinit_test/RT0017-rt-clinit-clinit_thread_001/ClinitThread001.java
new file mode 100755
index 0000000000000000000000000000000000000000..274d11d2110828b3ac80d1454232ca8bde0cdca9
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0017-rt-clinit-clinit_thread_001/ClinitThread001.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+class CaseThreadClass {
+    static CaseThreadClass member;
+    static int field;
+    static {
+        if (ClinitThread001.getCount() == 0) {
+            // 不会重复触发初始化
+            member = new CaseThreadClass();
+            field = ClinitThread001.getCount();
+        }
+    }
+    CaseThreadClass() {
+        ClinitThread001.getCount();
+    }
+}
+class ClassA {
+    static ClassB member;
+    static int field;
+    static {
+        if (ClinitThread001.getCount() == 3) {
+            field = ClinitThread001.getCount();
+            member = new ClassB();
+        }
+    }
+    ClassA() {
+        ClinitThread001.getCount();
+    }
+}
+class ClassB {
+    static ClassA member;
+    static int field;
+    static {
+        if (ClinitThread001.getCount() == 5) {
+            member = new ClassA();
+            field = ClinitThread001.getCount();
+        }
+    }
+    ClassB() {
+        ClinitThread001.getCount();
+    }
+}
+public class ClinitThread001 {
+    private static final int THREAD_COUNT = 10;
+    private static int count = 0;
+    // CyclicBarrier 适用再多线程相互等待，直到到达一个屏障点。并且CyclicBarrier是可重用的
+    private CyclicBarrier cyclicBarrier = new CyclicBarrier(THREAD_COUNT);
+    static int getCount() {
+        return count++;
+    }
+    public static void main(String[] args) {
+        ClinitThread001 test = new ClinitThread001();
+        ExecutorService executorService = test.runThread();
+        executorService.shutdown();
+        try {
+            if (executorService.awaitTermination(10, TimeUnit.SECONDS)) {
+                if (count != 9) {
+                    System.out.println(1);
+                } else {
+                    System.out.println(0);
+                }
+            }
+        } catch (InterruptedException ex) {
+            ex.printStackTrace();
+            System.out.println(1);
+        }
+    }
+    private ExecutorService runThread() {
+        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            executorService.submit(createThread(i));
+        }
+        return executorService;
+    }
+    private Thread createThread(int i) {
+        return new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    cyclicBarrier.await();
+                    if (CaseThreadClass.field != 2) {
+                        System.out.println("Error, CaseThreadClass not initialized");
+                    }
+                    if (ClassA.field != 4) {
+                        System.out.println("Error, ClassA not initialized");
+                    }
+                    if (ClassB.field != 7) {
+                        System.out.println("Error, ClassB not initialized");
+                    }
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}
diff --git a/testsuite/java_test/clinit_test/RT0017-rt-clinit-clinit_thread_001/expected.txt b/testsuite/java_test/clinit_test/RT0017-rt-clinit-clinit_thread_001/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0017-rt-clinit-clinit_thread_001/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0017-rt-clinit-clinit_thread_001/test.cfg b/testsuite/java_test/clinit_test/RT0017-rt-clinit-clinit_thread_001/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..acff0ba81b2e32f8078c6930230e73693ae5fb44
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0017-rt-clinit-clinit_thread_001/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitThread001)
+run(ClinitThread001)
diff --git a/testsuite/java_test/clinit_test/RT0018-rt-clinit-clinit_gc_001/ClinitGC001.java b/testsuite/java_test/clinit_test/RT0018-rt-clinit-clinit_gc_001/ClinitGC001.java
new file mode 100644
index 0000000000000000000000000000000000000000..3146026dca8b76c5920386271433fcf6376bf2ed
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0018-rt-clinit-clinit_gc_001/ClinitGC001.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.io.PrintStream;
+class TemplateClassTest<T> {
+    static {
+        Runtime.getRuntime().gc();
+    }
+    public TemplateClassTest(T init) {
+        field = init;
+    }
+    private T field;
+    public void Show() {
+        System.out.println(field);
+    }
+}
+public class ClinitGC001 {
+    public static void main(String[] argv) {
+        ArrayList<Integer> al = new ArrayList<Integer>();
+        TemplateClassTest<Integer> test = new TemplateClassTest<Integer>(0);
+        try {
+            test.Show();
+            al.add(1);
+        } catch (NullPointerException e) {
+            System.out.println(2);
+        }
+    }
+}
diff --git a/testsuite/java_test/clinit_test/RT0018-rt-clinit-clinit_gc_001/expected.txt b/testsuite/java_test/clinit_test/RT0018-rt-clinit-clinit_gc_001/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0018-rt-clinit-clinit_gc_001/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/RT0018-rt-clinit-clinit_gc_001/test.cfg b/testsuite/java_test/clinit_test/RT0018-rt-clinit-clinit_gc_001/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..05288e0c18343cfd1dca878a57659b76104093c8
--- /dev/null
+++ b/testsuite/java_test/clinit_test/RT0018-rt-clinit-clinit_gc_001/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitGC001)
+run(ClinitGC001)
diff --git a/testsuite/java_test/clinit_test/issue-RT0018-rt-clinit-clinit_thread_002/ClinitThread002.java b/testsuite/java_test/clinit_test/issue-RT0018-rt-clinit-clinit_thread_002/ClinitThread002.java
new file mode 100755
index 0000000000000000000000000000000000000000..7363c6029bd71c406da82f5daff7d64a714f9882
--- /dev/null
+++ b/testsuite/java_test/clinit_test/issue-RT0018-rt-clinit-clinit_thread_002/ClinitThread002.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+class ThreadCaseClass {
+    static int field;
+    static {
+        field = ClinitThread002.getCount();
+        field++;
+    }
+}
+public class ClinitThread002 {
+    private static final int THREAD_COUNT = 4096;
+    private static int count = 0;
+    // CyclicBarrier 适用再多线程相互等待，直到到达一个屏障点。并且CyclicBarrier是可重用的    
+    private CyclicBarrier cyclicBarrier = new CyclicBarrier(THREAD_COUNT);
+    static int getCount() {
+        return count++;
+    }
+    public static void main(String[] args) {
+        ClinitThread002 test = new ClinitThread002();
+        ExecutorService executorService = test.runThread();
+        executorService.shutdown();
+        try {
+            if (executorService.awaitTermination(10, TimeUnit.SECONDS)) {
+                if (count != 1 || ThreadCaseClass.field != 1) {
+                    System.out.println(1/*STATUS_TEMP*/);
+                } else {
+                    System.out.println(0/*STATUS_TEMP*/);
+                }
+            }
+        } catch (InterruptedException ex) {
+            ex.printStackTrace();
+            System.out.println(1/*STATUS_TEMP*/);
+        }
+    }
+    private ExecutorService runThread() {
+        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            executorService.submit(createThread(i));
+        }
+        return executorService;
+    }
+    private Thread createThread(int i) {
+        return new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    cyclicBarrier.await();
+                    if (ThreadCaseClass.field != 1) {
+                        count++;
+                    }
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}
diff --git a/testsuite/java_test/clinit_test/issue-RT0018-rt-clinit-clinit_thread_002/expected.txt b/testsuite/java_test/clinit_test/issue-RT0018-rt-clinit-clinit_thread_002/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/issue-RT0018-rt-clinit-clinit_thread_002/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/issue-RT0018-rt-clinit-clinit_thread_002/test.cfg b/testsuite/java_test/clinit_test/issue-RT0018-rt-clinit-clinit_thread_002/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b392bb9aeb49b0bc3684ab5c21a2e2f525b79e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/issue-RT0018-rt-clinit-clinit_thread_002/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitThread002)
+run(ClinitThread002)
diff --git a/testsuite/java_test/clinit_test/issue-RT0019-rt-clinit-clinit_thread_003/ClinitThread003.java b/testsuite/java_test/clinit_test/issue-RT0019-rt-clinit-clinit_thread_003/ClinitThread003.java
new file mode 100755
index 0000000000000000000000000000000000000000..3a97daf11e29b7c3b77fdbac32153889ff4e1073
--- /dev/null
+++ b/testsuite/java_test/clinit_test/issue-RT0019-rt-clinit-clinit_thread_003/ClinitThread003.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+class ThreadCaseClassA {
+    private static int field = 1;
+    static {
+        field = ThreadCaseClassB.getField();
+        field++;
+    }
+    public static int getField() {
+        return field;
+    }
+}
+class ThreadCaseClassB {
+    private static int field = 2;
+    static {
+        field = ThreadCaseClassA.getField();
+        field++;
+    }
+    public static int getField() {
+        return field;
+    }
+}
+public class ClinitThread003 {
+    private static final int THREAD_COUNT = 4096;
+    private int result = 0;
+    /**
+     * CyclicBarrier 适用再多线程相互等待，直到到达一个屏障点。并且CyclicBarrier是可重用的。
+    */
+
+    private CyclicBarrier cyclicBarrier = new CyclicBarrier(THREAD_COUNT);
+    public static void main(String[] args) {
+        ClinitThread003 test = new ClinitThread003();
+        ExecutorService executorService = test.runThread();
+        executorService.shutdown();
+        try {
+            if (executorService.awaitTermination(10, TimeUnit.SECONDS)) {
+                if (ThreadCaseClassA.getField() != 3 || ThreadCaseClassB.getField() != 2) {
+                    System.out.println(1/*STATUS_TEMP*/);
+                } else {
+                    System.out.println(0/*STATUS_TEMP*/);
+                }
+            }
+        } catch (InterruptedException ex) {
+            ex.printStackTrace();
+            System.out.println(1/*STATUS_TEMP*/);
+        }
+    }
+    private ExecutorService runThread() {
+        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            executorService.submit(createThread(i));
+        }
+        return executorService;
+    }
+    private Thread createThread(int i) {
+        return new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    cyclicBarrier.await();
+                    if (ThreadCaseClassA.getField() != 3) {
+                        result = ThreadCaseClassB.getField();
+                    }
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}
diff --git a/testsuite/java_test/clinit_test/issue-RT0019-rt-clinit-clinit_thread_003/expected.txt b/testsuite/java_test/clinit_test/issue-RT0019-rt-clinit-clinit_thread_003/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/clinit_test/issue-RT0019-rt-clinit-clinit_thread_003/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/clinit_test/issue-RT0019-rt-clinit-clinit_thread_003/test.cfg b/testsuite/java_test/clinit_test/issue-RT0019-rt-clinit-clinit_thread_003/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..801a1340cc251f8d95fc0f6a5c978aa58a6cc7ee
--- /dev/null
+++ b/testsuite/java_test/clinit_test/issue-RT0019-rt-clinit-clinit_thread_003/test.cfg
@@ -0,0 +1,2 @@
+compile(ClinitThread003)
+run(ClinitThread003)
diff --git a/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/ReflectingGetConstructor1.java b/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/ReflectingGetConstructor1.java
new file mode 100755
index 0000000000000000000000000000000000000000..801e0cef1a1314bc4ec285e6afcbff28efcdabf5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/ReflectingGetConstructor1.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetConstructor1 {
+    public GetConstructor1() {
+    }
+    public GetConstructor1(String name) {
+    }
+    public GetConstructor1(String name, int number) {
+    }
+    GetConstructor1(int number) {
+    }
+}
+public class ReflectingGetConstructor1 {
+    public static void main(String[] args) {
+        try {
+            Class getConstructor1 = Class.forName("GetConstructor1");
+            Constructor constructor1 = getConstructor1.getConstructor(String.class);
+            Constructor constructor2 = getConstructor1.getConstructor();
+            Constructor constructor3 = getConstructor1.getConstructor(String.class, int.class);
+            if (constructor1.toString().equals("public GetConstructor1(java.lang.String)")
+                    && constructor2.toString().equals("public GetConstructor1()")
+                    && constructor3.toString().equals("public GetConstructor1(java.lang.String,int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/expected.txt b/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/maple.prof b/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..4612f79292d7ea26c43d14e8c11b7357ef366140
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/test.cfg b/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..855189b008ae06d7d2417f6b38a0b4d0422c101b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0001-rt-compact-ReflectingetConstructor1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetConstructor1)
+run(ReflectingGetConstructor1)
diff --git a/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/ReflectingGetConstructor2.java b/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/ReflectingGetConstructor2.java
new file mode 100755
index 0000000000000000000000000000000000000000..ce57a58609be63609721633a94c8dc1127a3ca5b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/ReflectingGetConstructor2.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetConstructor2 {
+    public GetConstructor2() {
+    }
+    public GetConstructor2(String name) {
+    }
+    public GetConstructor2(String name, int number) {
+    }
+    GetConstructor2(int number) {
+    }
+}
+public class ReflectingGetConstructor2 {
+    public static void main(String[] args) {
+        try {
+            Class getConstructor21 = Class.forName("GetConstructor2");
+            Constructor constructor1 = getConstructor21.getConstructor(int.class);
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e) {
+            try {
+                Class getConstructor22 = Class.forName("GetConstructor2");
+                Constructor constructor2 = getConstructor22.getConstructor(String.class, char.class, int.class);
+                System.out.println(2);
+            } catch (ClassNotFoundException ee) {
+                System.err.println(ee);
+                System.out.println(2);
+            } catch (NoSuchMethodException ee) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/expected.txt b/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/maple.prof b/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..72ea063b6c7afd7ffde71b93970d4c0d6d15a9ec
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/test.cfg b/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..574f8841605dbe0f84510694b9e1c18937ee3e9a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0002-rt-compact-ReflectingetConstructor2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetConstructor2)
+run(ReflectingGetConstructor2)
diff --git a/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/ReflectingGetConstructors.java b/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/ReflectingGetConstructors.java
new file mode 100755
index 0000000000000000000000000000000000000000..6e063cae22f458bcdeb5755f5f7e2a8f17dc151e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/ReflectingGetConstructors.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetConstructors {
+    public GetConstructors() {
+    }
+    public GetConstructors(String name) {
+    }
+    public GetConstructors(String name, int number) {
+    }
+    GetConstructors(int number) {
+    }
+    GetConstructors(double id) {
+    }
+    public GetConstructors(double id, String name) {
+    }
+}
+class GetConstructors_a extends GetConstructors {
+    public GetConstructors_a() {
+    }
+    public GetConstructors_a(String name) {
+    }
+    public GetConstructors_a(String name, int number) {
+    }
+    GetConstructors_a(int number) {
+    }
+}
+public class ReflectingGetConstructors {
+    public static void main(String[] args) {
+        try {
+            Class getConstructors_a = Class.forName("GetConstructors_a");
+            Constructor<?>[] constructors = getConstructors_a.getConstructors();
+            if (constructors.length == 3) {
+                for (int i = 0; i < constructors.length; i++) {
+                    if (constructors[i].toString().indexOf("GetConstructors_a(int)") != -1) {
+                        System.out.println(2);
+                    }
+                }
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (ArrayIndexOutOfBoundsException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/expected.txt b/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/maple.prof b/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..9bf9d41056e64150ab6c43d18a3f956dc2689826
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/test.cfg b/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5b876ecb1d0e8dfe9983e5238e9ad52f1c5c6932
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0003-rt-compact-ReflectingetConstructors/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetConstructors)
+run(ReflectingGetConstructors)
diff --git a/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java b/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java
new file mode 100755
index 0000000000000000000000000000000000000000..da947533320e533fca3a5b23c9530906994d7ebf
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetDeclaredConstructor1 {
+    public GetDeclaredConstructor1() {
+    }
+    private GetDeclaredConstructor1(String name) {
+    }
+    protected GetDeclaredConstructor1(String name, int number) {
+    }
+    GetDeclaredConstructor1(int number) {
+    }
+}
+public class ReflectingGetDeclaredConstructor1 {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructor1 = Class.forName("GetDeclaredConstructor1");
+            Constructor constructor1 = getDeclaredConstructor1.getDeclaredConstructor(String.class);
+            Constructor constructor2 = getDeclaredConstructor1.getDeclaredConstructor();
+            Constructor constructor3 = getDeclaredConstructor1.getDeclaredConstructor(String.class, int.class);
+            Constructor constructor4 = getDeclaredConstructor1.getDeclaredConstructor(int.class);
+            if (constructor1.toString().equals("private GetDeclaredConstructor1(java.lang.String)")
+                    && constructor2.toString().equals("public GetDeclaredConstructor1()")
+                    && constructor3.toString().equals("protected GetDeclaredConstructor1(java.lang.String,int)")
+                    && constructor4.toString().equals("GetDeclaredConstructor1(int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/expected.txt b/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/maple.prof b/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..6447924aea62fef7dd8726ffd2c5ef4e541356d0
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/test.cfg b/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9c2f15bac2380dffe1d4a3601c7e7e818c62151f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0004-rt-compact-ReflectingetDeclaredConstructor1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetDeclaredConstructor1)
+run(ReflectingGetDeclaredConstructor1)
diff --git a/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java b/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java
new file mode 100755
index 0000000000000000000000000000000000000000..7545445a44b97a5111513b9ed3595a4d03e66373
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetDeclaredConstructor2 {
+    public GetDeclaredConstructor2() {
+    }
+    private GetDeclaredConstructor2(String name) {
+    }
+    protected GetDeclaredConstructor2(String name, int number) {
+    }
+    GetDeclaredConstructor2(int number) {
+    }
+}
+public class ReflectingGetDeclaredConstructor2 {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructor2 = Class.forName("GetDeclaredConstructor2");
+            Constructor constructor = getDeclaredConstructor2.getDeclaredConstructor(String.class, char.class, int.class);
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/expected.txt b/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/maple.prof b/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..f18872c6311c1d512348968c60aa5f4588e7a74c
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/test.cfg b/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e4e52a3b940c68cedc2ec6bd71020cc4abe4936a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0005-rt-compact-ReflectingetDeclaredConstructor2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetDeclaredConstructor2)
+run(ReflectingGetDeclaredConstructor2)
diff --git a/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java b/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java
new file mode 100755
index 0000000000000000000000000000000000000000..e81e536fb84642ecb42b2040269755f83517fe05
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetDeclaredConstructors {
+    public GetDeclaredConstructors() {
+    }
+    private GetDeclaredConstructors(String name) {
+    }
+    protected GetDeclaredConstructors(String name, int number) {
+    }
+    GetDeclaredConstructors(int number) {
+    }
+}
+public class ReflectingGetDeclaredConstructors {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructors = Class.forName("GetDeclaredConstructors");
+            Constructor<?>[] constructors = getDeclaredConstructors.getDeclaredConstructors();
+            if (constructors.length == 4) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/expected.txt b/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/maple.prof b/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..8f249fa42d13f42c5842afd565ef8e16e542df32
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/test.cfg b/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..20069c05220bc05823f069b167ba1b37421fba9f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0006-rt-compact-ReflectingetDeclaredConstructors/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetDeclaredConstructors)
+run(ReflectingGetDeclaredConstructors)
diff --git a/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/ReflectionAsSubclass1.java b/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/ReflectionAsSubclass1.java
new file mode 100755
index 0000000000000000000000000000000000000000..1ce216e7f483801d06e059ecf70a3a77eefb77ae
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/ReflectionAsSubclass1.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+interface A {
+}
+class A1 implements A {
+}
+class A2 extends A1 {
+}
+public class ReflectionAsSubclass1 {
+    public static void main(String[] args) {
+        try {
+            Class a2 = Class.forName("A1").asSubclass(A.class);
+            Class a1 = Class.forName("A2").asSubclass(A.class);
+            if (a2.newInstance() instanceof A) {
+                if (a1.newInstance() instanceof A) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(e1);
+        } catch (InstantiationException e2) {
+            System.out.println(e2);
+        } catch (IllegalAccessException e3) {
+            System.out.println(e3);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/expected.txt b/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/maple.prof b/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..f523fa51ed819044613423a2ba7103c2874b60eb
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/test.cfg b/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..89eb8c0438a589745addf4cbe184527ced5177dc
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0007-rt-compact-ReflectionasSubclass1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionAsSubclass1)
+run(ReflectionAsSubclass1)
diff --git a/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/ReflectionAsSubclass2.java b/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/ReflectionAsSubclass2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a9c7fab8e77d8e37ea99331959071efa5304566b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/ReflectionAsSubclass2.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class B {
+}
+class B_1 extends B {
+}
+public class ReflectionAsSubclass2 {
+    public static void main(String[] args) {
+        try {
+            Class.forName("B_1").asSubclass(B.class);
+        } catch (ClassCastException e) {
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/expected.txt b/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/maple.prof b/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..de7b6e92c282a5146c08ee3979b003000b1457d9
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/test.cfg b/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e897c60b5ff3b8e880f45791c710766a5cf5c735
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0008-rt-compact-ReflectionasSubclass2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionAsSubclass2)
+run(ReflectionAsSubclass2)
diff --git a/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/ReflectionAsSubclass3.java b/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/ReflectionAsSubclass3.java
new file mode 100755
index 0000000000000000000000000000000000000000..499c886e2cadc484f3c345c4807ccd875a8e7e0d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/ReflectionAsSubclass3.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+interface C {
+}
+class C_1 implements C {
+}
+class C_2 extends C_1 {
+}
+class D {
+}
+class D_1 extends D {
+}
+public class ReflectionAsSubclass3 {
+    public static void main(String[] args) {
+        try {
+            Class.forName("C_1").asSubclass(D.class);
+        } catch (ClassCastException e1) {
+            try {
+                Class.forName("C_2").asSubclass(D.class);
+            } catch (ClassCastException e2) {
+                try {
+                    Class.forName("D_1").asSubclass(C.class);
+                } catch (ClassCastException e3) {
+                    System.out.println(0);
+                } catch (ClassNotFoundException e4) {
+                    System.out.println(2);
+                }
+            } catch (ClassNotFoundException e5) {
+                System.out.println(2);
+            }
+        } catch (ClassNotFoundException e6) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/expected.txt b/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/maple.prof b/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..054ad8e7fd39d1859e9965f47f034630abfc8e6b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/test.cfg b/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b2589926c7798e818365044284f6a3d0d4209176
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0009-rt-compact-ReflectionasSubclass3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionAsSubclass3)
+run(ReflectionAsSubclass3)
diff --git a/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/ReflectionCast1.java b/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/ReflectionCast1.java
new file mode 100755
index 0000000000000000000000000000000000000000..c8c9a1dcb995f37895317be7803a468cb09b4dc0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/ReflectionCast1.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cast1 {
+}
+class Cast1_a extends Cast1 {
+}
+public class ReflectionCast1 {
+    public static void main(String[] args) {
+        Cast1_a cast1_a = new Cast1_a();
+        Cast1 cast1 = new Cast1();
+        cast1 = Cast1.class.cast(cast1_a);
+        if (cast1.getClass().toString().equals("class Cast1_a")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/expected.txt b/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/maple.prof b/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..9c4bd2fd1a81aed16d85fd478c43db9bc12e2010
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/test.cfg b/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..48241ccf96e39e67c5169bf6f66586c005bd7a2f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0010-rt-compact-Reflectioncast1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionCast1)
+run(ReflectionCast1)
diff --git a/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/ReflectionCast2.java b/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/ReflectionCast2.java
new file mode 100755
index 0000000000000000000000000000000000000000..0a5c13948b20fef7de74793a3aa0407fee72daf7
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/ReflectionCast2.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cast2 {
+}
+class Cast2_a extends Cast2 {
+}
+public class ReflectionCast2 {
+    public static void main(String[] args) {
+        Cast2_a cast2_a = new Cast2_a();
+        Cast2 cast2 = new Cast2();
+        try {
+            cast2_a = Cast2_a.class.cast(cast2);
+        } catch (ClassCastException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/expected.txt b/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/maple.prof b/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..5420427eaef756263311612c9e60245dce5f4f66
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/test.cfg b/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..77458af7236cd0facb1bce803f83540b42e647f2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0011-rt-compact-Reflectioncast2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionCast2)
+run(ReflectionCast2)
diff --git a/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/ReflectionCast3.java b/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/ReflectionCast3.java
new file mode 100755
index 0000000000000000000000000000000000000000..cb03e46e21c67605f2e71f59cb0b842b44437346
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/ReflectionCast3.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cast3 {
+}
+class Cast3_a {
+}
+public class ReflectionCast3 {
+    public static void main(String[] args) {
+        Cast3_a cast3_a = new Cast3_a();
+        Cast3 cast3 = new Cast3();
+        try {
+            cast3_a = Cast3_a.class.cast(cast3);
+        } catch (ClassCastException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/expected.txt b/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/maple.prof b/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3faa10d6b519dbeeefdf11bc8a645bf54ab1500b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/test.cfg b/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..277a7056b00bbe487bf9a3bc774ed10dbc32443c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0012-rt-compact-Reflectioncast3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionCast3)
+run(ReflectionCast3)
diff --git a/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/ReflectionCast4.java b/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/ReflectionCast4.java
new file mode 100755
index 0000000000000000000000000000000000000000..6eced584c14b614262d877f97cc035e47be88f42
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/ReflectionCast4.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cast4 {
+}
+public class ReflectionCast4 {
+    public static void main(String[] args) {
+        Object object = null;
+        Cast4 cast4 = new Cast4();
+        cast4 = Cast4.class.cast(object);
+        if (cast4 == null) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/expected.txt b/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/maple.prof b/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..a464b6f8dbe707fff17b7a160fa0dbeb10c03032
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/test.cfg b/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..154de1da59229c12f805ba27049111321e46f08c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0013-rt-compact-Reflectioncast4/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionCast4)
+run(ReflectionCast4)
diff --git a/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java b/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java
new file mode 100755
index 0000000000000000000000000000000000000000..73da000272effdae2fdc9b55cf0bb8873bf41922
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionDesiredAssertionStatus {
+    public static void main(String[] args) {
+        ReflectionDesiredAssertionStatus reflectionDesiredAssertionStatus = new ReflectionDesiredAssertionStatus();
+        Class clazz = reflectionDesiredAssertionStatus.getClass();
+        if (!clazz.desiredAssertionStatus()) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/expected.txt b/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/maple.prof b/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..02d7ff77d4dcd150b63e5855df82892a4d53a306
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/test.cfg b/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..63db2513f4c4473d08593c9ffad6735c8326ccd6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0014-rt-compact-ReflectiondesiredAssertionStatus/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionDesiredAssertionStatus)
+run(ReflectionDesiredAssertionStatus)
diff --git a/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/ReflectionForName1.java b/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/ReflectionForName1.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd8f9f5e3dd2cab1e8c0a3339b8f359af7914917
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/ReflectionForName1.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ForName1 {
+}
+public class ReflectionForName1 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        Class clazz = Class.forName("ForName1");
+        if (clazz.toString().equals("class ForName1")) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/expected.txt b/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/maple.prof b/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..15c26afbe540e27c971d8561f068ce3d99a0fc09
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/test.cfg b/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..718481cfd4dd0523fa3307e30438ef0c7e27ba24
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0015-rt-compact-ReflectionforName1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName1)
+run(ReflectionForName1)
diff --git a/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/ReflectionForName4.java b/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/ReflectionForName4.java
new file mode 100755
index 0000000000000000000000000000000000000000..124822946c4c7d403fac64cf306ea378671832a4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/ReflectionForName4.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ForName4 {
+    static {
+    }
+}
+class ForName4_a {
+    static {
+    }
+}
+public class ReflectionForName4 extends Thread {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("for*", true, ForName4_a.class.getClassLoader());
+        } catch (ClassNotFoundException e) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/expected.txt b/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/maple.prof b/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..a5610cef452b56e6ff0b11f27b7189b7e9f8374e
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/test.cfg b/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0857d14c6de0bc1477d338f12578f68e5a85fe0f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0016-rt-compact-ReflectionforName4/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName4)
+run(ReflectionForName4)
diff --git a/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/ReflectionForName5.java b/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/ReflectionForName5.java
new file mode 100755
index 0000000000000000000000000000000000000000..30bb2fc5336dfbd82a376b86bcd57a2322c7494d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/ReflectionForName5.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+interface ForName55_c {
+}
+class ForName55_b implements ForName55_c {
+}
+class ForName55_a extends ForName55_b {
+}
+class ForName55 extends ForName55_a {
+}
+class ForName5_e {
+}
+class ForName5_d extends ForName5_e {
+}
+class ForName5_c extends ForName5_d {
+}
+class ForName5_b extends ForName5_c {
+}
+class ForName5_a extends ForName5_b {
+}
+class ForName5 extends ForName5_a {
+}
+public class ReflectionForName5 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        Class clazz = Class.forName("ForName5");
+        if (clazz.toString().equals("class ForName5")) {
+            Class clazz2 = Class.forName("ForName55");
+            if (clazz2.toString().equals("class ForName55")) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/expected.txt b/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/maple.prof b/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..cd38a79b514f768c30f7223f15234c903a4ef887
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/test.cfg b/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35f30f0a123dbd0067408bc2a6562ed97141b0e0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0017-rt-compact-ReflectionforName5/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName5)
+run(ReflectionForName5)
diff --git a/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java b/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..62a6f3e8f42b430cdb5e7f78e229f405492fe985
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz1 {
+int i() default 0;
+String t() default "";
+}
+@Zzz1(i = 333, t = "getAnnotation")
+class GetAnnotation1_a {
+}
+class GetAnnotation1_b {
+}
+public class ReflectionGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetAnnotation1_a");
+            Class clazz2 = Class.forName("GetAnnotation1_b");
+            if (clazz1.getAnnotation(Zzz1.class).toString().indexOf("t=getAnnotation") != -1
+                    && clazz1.getAnnotation(Zzz1.class).toString().indexOf("i=333") != -1
+                    && clazz2.getAnnotation(Zzz1.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/expected.txt b/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/maple.prof b/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3dc54069082d9792db16614895577ac3aef44728
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/test.cfg b/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ea370ea1cc66f565a7989953010f2b77f00112f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0018-rt-compact-ReflectiongetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation1)
+run(ReflectionGetAnnotation1)
diff --git a/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/ReflectionGetAnnotation2.java b/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/ReflectionGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..0a76bdd67d65025399add05cf1bef062286b08dd
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/ReflectionGetAnnotation2.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+class GetAnnotation2_a {
+    @IF2(i = 333, t = "getAnnotation")
+    public int i_a;
+    public String t_a;
+}
+class GetAnnotation2_b {
+    public int i_b;
+    public String t_b;
+}
+public class ReflectionGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls1 = Class.forName("GetAnnotation2_a");
+            Class cls2 = Class.forName("GetAnnotation2_b");
+            Field instance1 = cls1.getField("i_a");
+            Field instance2 = cls1.getField("t_a");
+            Field instance3 = cls2.getField("i_b");
+            if (instance1.getAnnotation(IF2.class).i() == 333 && instance1.getAnnotation(IF2.class).
+                    t().equals("getAnnotation") && instance2.getAnnotation(IF2.class) == null &&
+                    instance3.getAnnotation(IF2.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/expected.txt b/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/maple.prof b/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..cd013302038cc0344c7db0b7262cc888f85c8821
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/test.cfg b/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7775516b4fd34e7cd2ee6af7e94daa49acba0ded
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0019-rt-compact-ReflectiongetAnnotation2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation2)
+run(ReflectionGetAnnotation2)
diff --git a/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java b/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java
new file mode 100755
index 0000000000000000000000000000000000000000..3bf294fd0d7456eccb20861bd2c011065ba845d9
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz3 {
+    int i() default 0;
+    String t() default "";
+}
+class GetAnnotation3_a {
+    @Zzz3(i = 333, t = "getAnnotation")
+    public void qqq() {
+    };
+    public void rrr() {
+    };
+}
+class GetAnnotation3_b {
+    public void www() {
+    };
+}
+public class ReflectionGetAnnotation3 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation3_a");
+            Method zhu1 = zqp1.getMethod("qqq");
+            Method zhu2 = zqp1.getMethod("rrr");
+            zhu1.getAnnotation(Zzz3.class).t();
+            zhu2.getAnnotation(Zzz3.class).i();
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            try {
+                Class zqp2 = Class.forName("GetAnnotation3_b");
+                Method zhu3 = zqp2.getMethod("www");
+                zhu3.getAnnotation(Zzz3.class).i();
+                System.out.println(2);
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                System.out.println(2);
+            } catch (NoSuchMethodException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NullPointerException e5){
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/expected.txt b/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/maple.prof b/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..62128a5aafb047e536bf5feac2d199d784b95dc7
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/test.cfg b/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5b9e88591bddd419360dfcaabec01e4c524a9bab
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0020-rt-compact-ReflectiongetAnnotation3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation3)
+run(ReflectionGetAnnotation3)
diff --git a/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java b/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java
new file mode 100755
index 0000000000000000000000000000000000000000..d1115f2633c22f41dfaa6dfc1651a0fcb0bb54cd
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz4 {
+    int i() default 0;
+    String t() default "";
+}
+@interface Zzz4_a {
+int ii() default 0;
+String tt() default "";
+}
+class GetAnnotation4_a {
+    @Zzz4(i = 333, t = "getAnnotation")
+    public void qqq() {
+    };
+    @Zzz4_a(ii = 555, tt = "test")
+    public void rrr() {
+    };
+}
+public class ReflectionGetAnnotation4 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation4_a");
+            Method zhu1 = zqp1.getMethod("qqq");
+            Method zhu2 = zqp1.getMethod("rrr");
+            if (zhu1.getAnnotation(Zzz4_a.class) == null && zhu2.getAnnotation(Zzz4.class) == null) {
+                zhu1.getAnnotation(Zzz4_a.class).ii();
+                System.out.println(2);
+            }
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/expected.txt b/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/maple.prof b/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..7ef50e69467a56c33c768029e0bca5cb2da375f4
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/test.cfg b/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c8ef96f668dd3c478687d95e9d2087946aac9c8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0021-rt-compact-ReflectiongetAnnotation4/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation4)
+run(ReflectionGetAnnotation4)
diff --git a/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/ReflectionGetAnnotation5.java b/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/ReflectionGetAnnotation5.java
new file mode 100755
index 0000000000000000000000000000000000000000..46a8164fecde1d499fea9e1291b8dafee8f6e9e9
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/ReflectionGetAnnotation5.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz5 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz5_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Zzz5(i = 333, t = "test1")
+class GetAnnotation5 {
+    public int i;
+    public String t;
+}
+@Zzz5_a(i_a = 666, t_a = "right1")
+class GetAnnotation5_a extends GetAnnotation5 {
+    public int i_a;
+    public String t_a;
+}
+class GetAnnotation5_b extends GetAnnotation5_a {
+}
+public class ReflectionGetAnnotation5 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation5_b");
+            if (zqp1.getAnnotation(Zzz5.class).toString().indexOf("t=test1") != -1 && zqp1.getAnnotation(Zzz5.class).
+                    toString().indexOf("i=333") != -1) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/expected.txt b/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/maple.prof b/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..53c1bd10131e9fd176f5230cc8585dbccfd3aed2
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/test.cfg b/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..17609280c06de75390ae445dbce0453b52022aec
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0022-rt-compact-ReflectiongetAnnotation5/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation5)
+run(ReflectionGetAnnotation5)
diff --git a/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/ReflectionGetAnnotation6.java b/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/ReflectionGetAnnotation6.java
new file mode 100755
index 0000000000000000000000000000000000000000..810b4e4a268d400bdb4895f625d5cd315483dfbd
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/ReflectionGetAnnotation6.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz6 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz6_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Zzz6(i = 333, t = "test1")
+class GetAnnotation6 {
+    public int i;
+    public String t;
+    @Zzz6_a(i_a = 666, t_a = "right1")
+    public static class GetAnnotation6_a {
+        public int j;
+    }
+}
+public class ReflectionGetAnnotation6 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation6");
+            Class[] zhu1 = zqp1.getDeclaredClasses();
+            if (zhu1[0].getAnnotation(Zzz6_a.class).toString().indexOf("t_a=right1") != -1 && zhu1[0].
+                    getAnnotation(Zzz6_a.class).toString().indexOf("i_a=666") != -1) {
+                if (zhu1[0].getAnnotation(Zzz6.class) == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/expected.txt b/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/maple.prof b/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ca557fb09c1adfdff701411a401fbe20a12eb4df
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/test.cfg b/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..14887ad141ad99fa502095377a56c17935c15217
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0023-rt-compact-ReflectiongetAnnotation6/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation6)
+run(ReflectionGetAnnotation6)
diff --git a/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/ReflectionGetAnnotation7.java b/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/ReflectionGetAnnotation7.java
new file mode 100755
index 0000000000000000000000000000000000000000..82e1cba5eabad10d4a53249df54ad9ee6110cc54
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/ReflectionGetAnnotation7.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+class GetAnnotation7 {
+    @Deprecated
+    public int aa(int num) {
+        return 0;
+    }
+}
+class GetAnnotation7_a extends GetAnnotation7 {
+    @Override
+    public int aa(int num) {
+        return 2;
+    }
+}
+public class ReflectionGetAnnotation7 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation7_a");
+            Method zhu1 = zqp1.getMethod("aa", int.class);
+            Annotation[] j = zhu1.getAnnotations();
+            if (j.length == 0) {
+                try {
+                    Class zqp2 = Class.forName("GetAnnotation7");
+                    Method zhu2 = zqp2.getMethod("aa", int.class);
+                    if (zhu2.getAnnotation(Deprecated.class).toString().indexOf("Deprecated") != -1) {
+                        System.out.println(0);
+                    }
+                } catch (ClassNotFoundException e1) {
+                    System.err.println(e1);
+                    System.out.println(2);
+                } catch (NoSuchMethodException e2) {
+                    System.err.println(e2);
+                    System.out.println(2);
+                } catch (NullPointerException e3) {
+                    System.err.println(e3);
+                    System.out.println(2);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/expected.txt b/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/maple.prof b/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..8eb1d6934fd8bdf1c455b62fdb4bc2934fd49648
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/test.cfg b/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4b9ef5370b6510797a303414b844b94251494184
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0024-rt-compact-ReflectiongetAnnotation7/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation7)
+run(ReflectionGetAnnotation7)
diff --git a/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/ReflectionGetAnnotationsByType1.java b/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/ReflectionGetAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..ef8640cca4f5b79bb9f63d94cfe6c99c131bbc48
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/ReflectionGetAnnotationsByType1.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz1 {
+    int i() default 0;
+    String t() default "";
+}
+@interface Zzzz1_a {
+}
+@interface Zzzz1_b {
+}
+class GetAnnotationsByType1_a {
+    @Zzzz1(i = 333, t = "GetAnnotationsByType")
+    public int i_a;
+    @Zzzz1(i = 333, t = "GetAnnotationsByType")
+    public int i_aa;
+    @Zzzz1(i = 333, t = "GetAnnotationsByType")
+    public int i_aaa;
+    public String t_a;
+    @Zzzz1_a
+    public String t_aa;
+    @Zzzz1_b
+    public String t_aaa;
+}
+public class ReflectionGetAnnotationsByType1 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType1_a");
+            Field zhu1 = zqp1.getField("i_a");
+            Field zhu2 = zqp1.getField("t_a");
+            if (zqp1.getAnnotationsByType(Zzzz1.class).length == 0) {
+                if (zhu2.getAnnotationsByType(Zzzz1_a.class).length == 0) {
+                    Annotation[] k = zhu1.getAnnotationsByType(Zzzz1.class);
+                    if (k[0].toString().indexOf("t=GetAnnotationsByType") != -1 && k[0].toString().indexOf("i=333")
+                            != -1) {
+                        System.out.println(0);
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/expected.txt b/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/maple.prof b/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3e706dc6ec666d0bd978984f533291082cdd796c
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/test.cfg b/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eb77f0fef1b032d4b8af2603149df1285294d426
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0025-rt-compact-ReflectiongetAnnotationsByType1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotationsByType1)
+run(ReflectionGetAnnotationsByType1)
diff --git a/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java b/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java
new file mode 100755
index 0000000000000000000000000000000000000000..d534366640e81c6e0b37d2a5e0b5fa4645bc4906
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz2 {
+    int i() default 0;
+    String t() default "";
+}
+class GetAnnotationsByType2_a {
+    @Zzzz2(i = 333, t = "GetAnnotationsByType")
+    public int i_a;
+    public String t_a;
+}
+class GetAnnotationsByType2_b {
+    public int i_b;
+    public String t_b;
+}
+public class ReflectionGetAnnotationsByType2 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType2_a");
+            Field zhu1 = zqp1.getField("t_a");
+            Annotation[] j = zhu1.getAnnotationsByType(null);
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            try {
+                Class zqp2 = Class.forName("GetAnnotationsByType2_b");
+                Field zhu2 = zqp2.getField("i_b");
+                Annotation[] k = zhu2.getAnnotationsByType(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                System.out.println(2);
+            } catch (NoSuchFieldException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/expected.txt b/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/maple.prof b/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..c5fc5d1aefba966b506e49af001597a9dac92e3f
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/test.cfg b/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3de58b38ec6d4c7889ccb7fa81f092294203d605
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0026-rt-compact-ReflectiongetAnnotationsByType2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotationsByType2)
+run(ReflectionGetAnnotationsByType2)
diff --git a/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/ReflectionGetAnnotationsByType3.java b/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/ReflectionGetAnnotationsByType3.java
new file mode 100755
index 0000000000000000000000000000000000000000..72e09dda2465a3284f78f6f699b1cfba18a9ece3
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/ReflectionGetAnnotationsByType3.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz3 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz3_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Zzzz3(i = 333, t = "test1")
+class GetAnnotationsByType3 {
+    public int i;
+    public String t;
+}
+@Zzzz3_a(i_a = 666, t_a = "right1")
+class GetAnnotationsByType3_a extends GetAnnotationsByType3 {
+    public int i_a;
+    public String t_a;
+}
+class GetAnnotationsByType3_b extends GetAnnotationsByType3_a {
+}
+public class ReflectionGetAnnotationsByType3 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType3_b");
+            Annotation[] j = zqp1.getAnnotationsByType(Zzzz3.class);
+            if (j[0].toString().indexOf("t=test1") != -1 && j[0].toString().indexOf("i=333") != -1) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/expected.txt b/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/maple.prof b/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..7d4d043608b922002515c2cc27b1993a9dbfca0c
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/test.cfg b/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc7cf1d3ba3e52e092d427566287b1c47fa57956
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0027-rt-compact-ReflectiongetAnnotationsByType3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotationsByType3)
+run(ReflectionGetAnnotationsByType3)
diff --git a/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java b/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java
new file mode 100755
index 0000000000000000000000000000000000000000..3878c6a85d65ca8b73ee074b7e35bdc36d4a1b85
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class GetCanonicalNameTest {
+}
+public class ReflectionGetCanonicalName {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("GetCanonicalNameTest");
+            if (zqp.getCanonicalName().equals("GetCanonicalNameTest")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/expected.txt b/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/maple.prof b/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..0477cf9c4717809f8eaf32cdace2db3e696d74ea
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/test.cfg b/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8d40d428a28710dbb4e8ea640ff751f080310444
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0028-rt-compact-ReflectiongetCanonicalName/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetCanonicalName)
+run(ReflectionGetCanonicalName)
diff --git a/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/ReflectionGetComponentType.java b/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/ReflectionGetComponentType.java
new file mode 100755
index 0000000000000000000000000000000000000000..5da606df77a3ff3a363b658976217f9f052b8d03
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/ReflectionGetComponentType.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionGetComponentType {
+    public static void main(String[] args) {
+        if (char.class.getComponentType() == null && String[].class.getComponentType().toString().
+                equals("class java.lang.String") && int[].class.getComponentType().toString().equals("int")) {
+            System.out.println(0);
+        }else{
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/expected.txt b/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/maple.prof b/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..36654133782c4608216f204feb75aa2e2c5472a6
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/test.cfg b/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c6da763cba88896b4458d9c6d91a00b8467002e1
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0029-rt-compact-ReflectiongetComponentType/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetComponentType)
+run(ReflectionGetComponentType)
diff --git a/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java b/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..24bd4a63a8b138a0bd72783b9802ba22ccdaa955
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Ddd1(i = 333, t = "test1")
+class GetDeclaredAnnotations1 {
+    public int i;
+    public String t;
+}
+@Ddd1_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotations1_a extends GetDeclaredAnnotations1 {
+    public int i_a;
+    public String t_a;
+}
+public class ReflectionGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotations1_a");
+            if (zqp1.getDeclaredAnnotations().length == 1) {
+                Annotation[] j = zqp1.getDeclaredAnnotations();
+                if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                    result = 0;
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/expected.txt b/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/maple.prof b/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..4a5863e672c91d69286335102ebe0041c1b42464
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/test.cfg b/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9823fe8304cf5a24161ed1398718aa35f50c0fa0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0030-rt-compact-ReflectiongetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredAnnotations1)
+run(ReflectionGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java b/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e67d42f9bad470921331f34b74512c7875ae129
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Ddd2(i = 333, t = "test1")
+class GetDeclaredAnnotations2 {
+    public int i;
+    public String t;
+}
+@Ddd2_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotations2_a extends GetDeclaredAnnotations2 {
+    public int i_a;
+    public String t_a;
+}
+class GetDeclaredAnnotations2_b extends GetDeclaredAnnotations2_a {
+}
+public class ReflectionGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotations2_b");
+            if (zqp1.getDeclaredAnnotations().length == 0) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/expected.txt b/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/maple.prof b/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..eafe35dfa89e5e6005f3beb8f4cef93cd5870c65
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/test.cfg b/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ec3924c4a8988f8ab4152eb8ab59a573cf8006fe
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0031-rt-compact-ReflectiongetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredAnnotations2)
+run(ReflectionGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/ReflectionGetDeclaredAnnotationsByType1.java b/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/ReflectionGetDeclaredAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..f7ee97cd5c7ad080f86209dcbdbd9832aa151c8a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/ReflectionGetDeclaredAnnotationsByType1.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Dddd1(i = 333, t = "test1")
+class GetDeclaredAnnotationsByType1 {
+    public int i;
+    public String t;
+}
+@Dddd1_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotationsByType1_a extends GetDeclaredAnnotationsByType1 {
+    public int i_a;
+    public String t_a;
+}
+class GetDeclaredAnnotationsByType1_b extends GetDeclaredAnnotationsByType1_a {
+}
+public class ReflectionGetDeclaredAnnotationsByType1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotationsByType1_b");
+            Class zqp2 = Class.forName("GetDeclaredAnnotationsByType1_a");
+            if (zqp1.getDeclaredAnnotationsByType(Dddd1.class).length == 0) {
+                Annotation[] j = zqp2.getDeclaredAnnotationsByType(Dddd1_a.class);
+                if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                    result = 0;
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/expected.txt b/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/maple.prof b/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ae82812dfc8a5a83501f2b888d5f0a09a913e840
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/test.cfg b/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7369f4f33c37ce2e3d1c77b0f08dcbc961e3ceba
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0032-rt-compact-ReflectiongetDeclaredAnnotationsByType1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredAnnotationsByType1)
+run(ReflectionGetDeclaredAnnotationsByType1)
diff --git a/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java b/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..209b49b7a64c215ab8b1a481f77d960a84c73a93
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Dddd2(i = 333, t = "test1")
+class GetDeclaredAnnotationsByType2 {
+    public int i;
+    public String t;
+}
+@Dddd2_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotationsByType2_a extends GetDeclaredAnnotationsByType2 {
+    public int i_a;
+    public String t_a;
+}
+class GetDeclaredAnnotationsByType2_b extends GetDeclaredAnnotationsByType2_a {
+}
+public class ReflectionGetDeclaredAnnotationsByTypeNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotationsByType2_b");
+            Annotation[] j = zqp1.getDeclaredAnnotationsByType(null);
+            result = 0;
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/maple.prof b/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..4e0c92a0c36e2c1884f641948b7ecfe63d3be968
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7316d61dcc35b0e2715162fed41c6cc5fcb0e8b4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0033-rt-compact-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredAnnotationsByTypeNullPointerException)
+run(ReflectionGetDeclaredAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java b/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java
new file mode 100755
index 0000000000000000000000000000000000000000..d5511f15b728f76c124f3465f265b362a1a1ac53
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ReflectiongetDeclaredClasses_a {
+    public class getDeclaredClasses_a1 {
+    }
+    private class getDeclaredClasses_a2 {
+    }
+    protected class getDeclaredClasses_a3 {
+    }
+}
+public class ReflectionGetDeclaredClasses extends ReflectiongetDeclaredClasses_a {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("ReflectionGetDeclaredClasses");
+            Class<?>[] j = zqp.getDeclaredClasses();
+            if (j.length == 3) {
+                for (int i = 0; i < j.length; i++) {
+                    if (j[i].getName().indexOf("getDeclaredClasses_a") != -1) {
+                        result = -1;
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+    public class getDeclaredClassestest1 {
+    }
+    private class getDeclaredClassestest2 {
+    }
+    protected class getDeclaredClassestest3 {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/expected.txt b/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/maple.prof b/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..a7fb4f084db9c4c3f0f4e0d85a89c22358a88e17
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/test.cfg b/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..45ec5eb17dfffacc3a3971bcdc24f830f24e4209
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0034-rt-compact-ReflectiongetDeclaredClasses/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredClasses)
+run(ReflectionGetDeclaredClasses)
diff --git a/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java b/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java
new file mode 100755
index 0000000000000000000000000000000000000000..d79e0b0cbe601e8d50d327b18ef2fd2a2d1befd6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetDeclaredField1 {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+public class ReflectionGetDeclaredField1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("GetDeclaredField1");
+            Field zhu1 = zqp.getDeclaredField("i");
+            Field zhu2 = zqp.getDeclaredField("s");
+            Field zhu3 = zqp.getDeclaredField("d");
+            Field zhu4 = zqp.getDeclaredField("f");
+            if (zhu1.getName().equals("i") && zhu2.getName().equals("s") && zhu3.getName().equals("d") &&
+                    zhu4.getName().equals("f")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            result = -1;
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/expected.txt b/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/maple.prof b/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..14a6a3fba2fc33591b65da325706499f7a18c0ec
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/test.cfg b/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bb780c56d82e7ae80567d96d5d1a12ebdf4c171e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0035-rt-compact-ReflectiongetDeclaredField1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredField1)
+run(ReflectionGetDeclaredField1)
diff --git a/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java b/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..e73b2081748c744a38822b1308a8984373937782
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetDeclaredField2_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+class GetDeclaredField2 extends GetDeclaredField2_a {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+public class ReflectionGetDeclaredFieldNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("GetDeclaredField2");
+            Field zhu1 = zqp.getDeclaredField("i_a");
+            result = -1;
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        } catch (NoSuchFieldException e3) {
+            try {
+                Class zqp = Class.forName("GetDeclaredField2");
+                Field zhu1 = zqp.getDeclaredField(null);
+                result = -1;
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                result = -1;
+            } catch (NoSuchFieldException e5) {
+                System.err.println(e5);
+                result = -1;
+            } catch (NullPointerException e6) {
+                result = 0;
+            }
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/expected.txt b/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/maple.prof b/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3b3dd1ac09fbec894e8a3cea682695c1132c49e4
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/test.cfg b/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a6ad430a38b8a8cc93d80cbdcfb4335241f19ca
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0036-rt-compact-ReflectionGetDeclaredFieldNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredFieldNullPointerException)
+run(ReflectionGetDeclaredFieldNullPointerException)
diff --git a/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java b/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java
new file mode 100755
index 0000000000000000000000000000000000000000..4a2597c3cdb4ca9f2fffb3e46c7f0ea5d67e2ce3
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetDeclaredFields1_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+class GetDeclaredFields1 extends GetDeclaredFields1_a {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+interface GetDeclaredFields1_b {
+    public int i_b = 2;
+    String s_b = "ccc";
+}
+public class ReflectionGetDeclaredFields1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredFields1");
+            Class zqp2 = Class.forName("GetDeclaredFields1_b");
+            Field[] j = zqp1.getDeclaredFields();
+            Field[] k = zqp2.getDeclaredFields();
+            if (j.length == 4 && k.length == 2) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/expected.txt b/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/maple.prof b/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..fdf18a38498e2274eb0b09045e796eb480a61f15
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/test.cfg b/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f16f86d15dce560a924f46b8154651a16e681e1b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0037-rt-compact-ReflectiongetDeclaredFields1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredFields1)
+run(ReflectionGetDeclaredFields1)
diff --git a/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java b/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java
new file mode 100755
index 0000000000000000000000000000000000000000..974e9279941c73844398efcd657865fbb34df029
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetDeclaredFields_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+class GetDeclaredFields extends GetDeclaredFields_a {
+}
+enum GetDeclaredFields_b {
+    i_b, s_b, f_b
+}
+public class ReflectionGetDeclaredFields {
+    public static void main(String[] args) {
+        int result = 0;
+        try {
+            Class zqp1 = Class.forName("GetDeclaredFields");
+            Class zqp2 = Class.forName("GetDeclaredFields_b");
+            Field[] j = zqp1.getDeclaredFields();
+            Field[] k = zqp2.getDeclaredFields();
+            if (j.length == 0 && k.length == 4) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/expected.txt b/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/maple.prof b/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..7a4ce3710f2ecc4f29f9439d3c98487c02da6b88
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/test.cfg b/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..379c7ff0b35afb856df39ce7f4631efddce2e373
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0038-rt-compact-ReflectiongetDeclaredFields2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredFields)
+run(ReflectionGetDeclaredFields)
diff --git a/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java b/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java
new file mode 100755
index 0000000000000000000000000000000000000000..dc49bcf36a4cdfeaedbbc053361f36f286d2331b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetDeclaredMethod1 {
+    public void empty1() {
+    }
+    void empty2() {
+    }
+    int getZero() {
+        return 0;
+    }
+    private String getDd() {
+        return "dd";
+    }
+    public void empty1(int number) {
+    }
+    int getZero(String name) {
+        return 2;
+    }
+}
+public class ReflectionGetDeclaredMethod1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethod1");
+            Method method1 = clazz.getDeclaredMethod("empty1", int.class);
+            Method method2 = clazz.getDeclaredMethod("getDd");
+            Method method3 = clazz.getDeclaredMethod("empty1");
+            Method method4 = clazz.getDeclaredMethod("empty2");
+            Method method5 = clazz.getDeclaredMethod("getZero");
+            Method method6 = clazz.getDeclaredMethod("getZero", String.class);
+            if (method1.toString().equals("public void GetDeclaredMethod1.empty1(int)")
+                    && method2.toString().equals("private java.lang.String GetDeclaredMethod1.getDd()")
+                    && method3.toString().equals("public void GetDeclaredMethod1.empty1()")
+                    && method4.toString().equals("void GetDeclaredMethod1.empty2()")
+                    && method5.toString().equals("int GetDeclaredMethod1.getZero()")
+                    && method6.toString().equals("int GetDeclaredMethod1.getZero(java.lang.String)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/expected.txt b/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/maple.prof b/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..63f79a286941dc03785b6117ca573c0aa930d3f8
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/test.cfg b/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4938010f56a9d2641a7a9a3efbc113c6e084dae1
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0039-rt-compact-ReflectiongetDeclaredMethod1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethod1)
+run(ReflectionGetDeclaredMethod1)
diff --git a/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java b/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java
new file mode 100755
index 0000000000000000000000000000000000000000..d8be6287d3568dcb7234a25d08f1db37bb555c49
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetDeclaredMethod2_a {
+    public void empty1() {
+    }
+    public void empty2() {
+    }
+}
+class GetDeclaredMethod2 extends GetDeclaredMethod2_a {
+    public void void1() {
+    }
+    void void2() {
+    }
+    int getZero() {
+        return 0;
+    }
+    private String getDd() {
+        return "dd";
+    }
+    public void setNumber(int number) {
+    }
+    int setName(String name) {
+        return 2;
+    }
+}
+public class ReflectionGetDeclaredMethod2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetDeclaredMethod2");
+            Method method1 = clazz1.getDeclaredMethod("empty1");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            try {
+                Class clazz2 = Class.forName("GetDeclaredMethod2");
+                Method method2 = clazz2.getDeclaredMethod(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchMethodException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/expected.txt b/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/maple.prof b/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..bb3ff4a53fd614bc7fa458dbc3b3f5db46fca83f
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/test.cfg b/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..deff9505b54fb911c691f4689ca5f46ad4cbb9ea
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0040-rt-compact-ReflectiongetDeclaredMethod2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethod2)
+run(ReflectionGetDeclaredMethod2)
diff --git a/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java b/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java
new file mode 100755
index 0000000000000000000000000000000000000000..9762c1c34f796fa7cb4ddae3c8af8b2ddc9bd1ff
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+abstract class GetDeclaredMethod3 {
+    abstract void empty1();
+    abstract public int empty2();
+}
+public class ReflectionGetDeclaredMethod3 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethod3");
+            Method method1 = clazz.getDeclaredMethod("empty1");
+            Method method2 = clazz.getMethod("empty2");
+            if (method1.toString().equals("abstract void GetDeclaredMethod3.empty1()")
+                    && method2.toString().equals("public abstract int GetDeclaredMethod3.empty2()")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/expected.txt b/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/maple.prof b/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..d41107a4c1cf9d78dabb51e5f9aba3d1f09bd91d
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/test.cfg b/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d0ff610ec2f5d1209f4d6284fc55cb857ff2c6da
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0041-rt-compact-ReflectiongetDeclaredMethod3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethod3)
+run(ReflectionGetDeclaredMethod3)
diff --git a/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java b/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java
new file mode 100755
index 0000000000000000000000000000000000000000..d367eb2f3c7615d86314f03a875fd21a31b2db93
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetDeclaredMethods1_a {
+    public void empty1() {
+    }
+    public void empty2() {
+    }
+}
+class GetDeclaredMethods1 extends GetDeclaredMethods1_a {
+    public void void1() {
+    }
+    void void2() {
+    }
+    int getZero() {
+        return 0;
+    }
+    private String getDd() {
+        return "dd";
+    }
+    public void setNumber(int number) {
+    }
+    int setName(String name) {
+        return 2;
+    }
+}
+interface GetDeclaredMethods1_b {
+    public default void test1() {
+    }
+    default void test2() {
+    }
+}
+public class ReflectionGetDeclaredMethods1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetDeclaredMethods1");
+            Class clazz2 = Class.forName("GetDeclaredMethods1_b");
+            Method[] methods1 = clazz1.getDeclaredMethods();
+            Method[] methods2 = clazz2.getDeclaredMethods();
+            if (methods1.length == 6 && methods2.length == 2) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/expected.txt b/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/maple.prof b/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..582e2d9ee3bfe6da38602010a660ac0da783b0ee
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/test.cfg b/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c3a592dfc3e8c54f3c55859fddbeb769a4f4267
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0042-rt-compact-ReflectiongetDeclaredMethods1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethods1)
+run(ReflectionGetDeclaredMethods1)
diff --git a/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java b/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java
new file mode 100755
index 0000000000000000000000000000000000000000..49b2cbf28dad446cdb555dac260d11d04c2fe661
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetDeclaredMethods2_a {
+    public void empty1() {
+    }
+    public void empty2() {
+    }
+}
+class GetDeclaredMethods2 extends GetDeclaredMethods2_a {
+}
+public class ReflectionGetDeclaredMethods2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethods2");
+            Method[] method = clazz.getDeclaredMethods();
+            if (method.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/expected.txt b/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/maple.prof b/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3b83dd67a34c1271440997f3089328ec2e3f11c6
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/test.cfg b/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4c20aa127bd44d61aaef44c8ee93276e46964ef8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0043-rt-compact-ReflectiongetDeclaredMethods2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethods2)
+run(ReflectionGetDeclaredMethods2)
diff --git a/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java b/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..e483bd074bc7227410f5ae4001bf7e87d09b24f3
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+class GetDeclaringClass {
+    public int num;
+    String str;
+    float fNum;
+    public GetDeclaringClass() {
+    }
+    GetDeclaringClass(int number) {
+    }
+    GetDeclaringClass(String name) {
+    }
+    GetDeclaringClass(int number, String name) {
+    }
+}
+class GetDeclaringClass_a {
+}
+public class ReflectionGetDeclaringClass {
+    public static void main(String[] args) {
+        try {
+            int num = 0;
+            Class clazz = Class.forName("GetDeclaringClass");
+            Field[] fields = clazz.getDeclaredFields();
+            Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+            for (int i = 0; i < fields.length; i++) {
+                if (fields[i].getDeclaringClass().getName().equals("GetDeclaringClass")) {
+                    for (int j = 0; j < constructors.length; j++) {
+                        if (constructors[j].getDeclaringClass().getName().equals("GetDeclaringClass")) {
+                            Class clazz2 = Class.forName("GetDeclaringClass_a");
+                            if (clazz2.getDeclaringClass() == null) {
+                                num++;
+                            }
+                        }
+                    }
+                }
+            }
+            if (num == 12) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/expected.txt b/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/maple.prof b/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..c677bfc6f555f1f15dbda77cb46cd1b3189b6420
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/test.cfg b/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5555ab58e841a7b7b136117b043197cd0e766453
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0044-rt-compact-ReflectiongetDeclaringClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaringClass)
+run(ReflectionGetDeclaringClass)
diff --git a/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/ReflectionGetEnclosingClass1.java b/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/ReflectionGetEnclosingClass1.java
new file mode 100755
index 0000000000000000000000000000000000000000..7d333556f3754ebaae06e5ee7c4b77e40a61da41
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/ReflectionGetEnclosingClass1.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionGetEnclosingClass1 {
+    public static void main(String[] args) {
+        Class clazz1 = (new GetEnclosingClassTest1()).test1().getClass();
+        Class clazz2 = (new GetEnclosingClassTest1()).test2().getClass();
+        if (clazz1.getEnclosingClass().getName().equals("ReflectionGetEnclosingClass1$GetEnclosingClassTest1")
+                && clazz2.getEnclosingClass().getName().equals("ReflectionGetEnclosingClass1$GetEnclosingClassTest1")) {
+            System.out.println(0);
+        }
+    }
+    public static class GetEnclosingClassTest1 {
+        public Object test1() {
+            class classA {
+            }
+            return new classA();
+        }
+        Object test2() {
+            class classB {
+            }
+            return new classB();
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/expected.txt b/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/maple.prof b/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..7f1f172700bdf2f2ae5d979823633fd8d1139acd
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/test.cfg b/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd6e544817050e3d7e2bd0c392941913b9bb951e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0045-rt-compact-ReflectiongetEnclosingClass1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetEnclosingClass1)
+run(ReflectionGetEnclosingClass1)
diff --git a/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/ReflectionGetEnclosingClass2.java b/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/ReflectionGetEnclosingClass2.java
new file mode 100755
index 0000000000000000000000000000000000000000..1a2db0a6c4063de4a22ec2cbf3770ab488748fad
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/ReflectionGetEnclosingClass2.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class GetEnclosingClassTest2 {
+    public Object test1() {
+        class classA {
+        }
+        return new classA();
+    }
+    Object test2() {
+        class classB {
+        }
+        return new classB();
+    }
+}
+public class ReflectionGetEnclosingClass2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetEnclosingClassTest2");
+            Class clazz2 = (new GetEnclosingClassTest2()).test2().getClass();
+            if (clazz1.getEnclosingClass() == null
+                    && clazz2.getEnclosingClass().getName().equals("GetEnclosingClassTest2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/expected.txt b/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/maple.prof b/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..bbf8c9bce3c8f9fc091755d7893cf4b2326b1dd0
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/test.cfg b/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..41264be065f527fd67fbda41661d0647d303bc88
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0046-rt-compact-ReflectiongetEnclosingClass2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetEnclosingClass2)
+run(ReflectionGetEnclosingClass2)
diff --git a/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java b/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java
new file mode 100755
index 0000000000000000000000000000000000000000..7370ff82691b8b2e9cbfc91562ec1ad67adf3254
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+enum Weekday {
+    MONDAY {
+        Object test1() {
+            class classA {
+            }
+            return new classA();
+        }
+    },
+    TUESDAY {
+        Object test2() {
+            class classB {
+            }
+            return new classB();
+        }
+    },
+    WEDNESDAY {
+        Object test3() {
+            class classC {
+            }
+            return new classC();
+        }
+    },
+    THURSDAY {
+        Object test4() {
+            class classD {
+            }
+            return new classD();
+        }
+    },
+    FRIDAY {
+        Object test5() {
+            class classE {
+            }
+            return new classE();
+        }
+    },
+    SATURDAY {
+        Object test6() {
+            class classF {
+            }
+            return new classF();
+        }
+    },
+    SUNDAY {
+        Object test7() {
+            class classG {
+            }
+            return new classG();
+        }
+    }
+}
+class GetEnumConstants {
+}
+public class ReflectionGetEnumConstants {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("Weekday");
+            Class clazz2 = Class.forName("GetEnumConstants");
+            Object[] objects1 = clazz1.getEnumConstants();
+            Object[] objects2 = clazz2.getEnumConstants();
+            if (objects1.length == 7) {
+                if (objects2 == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/expected.txt b/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/maple.prof b/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3366b41f63b00ec1213f219a2395cf13bcf13322
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/test.cfg b/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4f1d747cdabf13f243f205bbc1113c7ceb56a0b6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0047-rt-compact-ReflectiongetEnumConstants/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetEnumConstants)
+run(ReflectionGetEnumConstants)
diff --git a/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/ReflectionGetField1.java b/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/ReflectionGetField1.java
new file mode 100755
index 0000000000000000000000000000000000000000..16a4e1644438fee3292e944e64cd97f26e59c6e0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/ReflectionGetField1.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetField1_a {
+    int num2 = 5;
+    public String str = "bbb";
+}
+class GetField1 extends GetField1_a {
+    public int num = 1;
+    String string = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+public class ReflectionGetField1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetField1");
+            Field field1 = clazz.getField("num");
+            Field field2 = clazz.getField("str");
+            if (field1.getName().equals("num") && field2.getName().equals("str")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/expected.txt b/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/maple.prof b/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..f8ad2b084a49c2bb99383d619ca416efaf002e5b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/test.cfg b/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84acf80dc0c426c8221f34a64bbe9001ac5e2165
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0048-rt-compact-ReflectiongetField1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetField1)
+run(ReflectionGetField1)
diff --git a/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/ReflectionGetField2.java b/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/ReflectionGetField2.java
new file mode 100755
index 0000000000000000000000000000000000000000..5fdf07a82212aa2ae962fd667b25303f481791e2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/ReflectionGetField2.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetField2_a {
+    int num = 5;
+    public String str = "bbb";
+}
+class GetField2 extends GetField2_a {
+    public int num = 1;
+    String str2 = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+public class ReflectionGetField2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetField2");
+            Field field1 = clazz1.getField("str2");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            try {
+                Class clazz2 = Class.forName("GetField2");
+                Field field2 = clazz2.getField(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchFieldException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/expected.txt b/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/maple.prof b/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..82cefe9e6ea38e288ee692295d923993848eceaf
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/test.cfg b/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..623369a4ee90461c04fec1486b1bcd637b7e224c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0049-rt-compact-ReflectiongetField2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetField2)
+run(ReflectionGetField2)
diff --git a/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/ReflectionGetFields.java b/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/ReflectionGetFields.java
new file mode 100755
index 0000000000000000000000000000000000000000..d87fc863cfbfff7b7e1005bd23223e3aa4fe54cd
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/ReflectionGetFields.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetFields_a {
+    public int num = 5;
+    String str = "bbb";
+}
+class GetFields extends GetFields_a {
+    public int num = 1;
+    String str = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+interface GetFields_b {
+    public int num = 2;
+    String str = "ccc";
+}
+class GetFields_c {
+}
+public class ReflectionGetFields {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetFields");
+            Class clazz2 = Class.forName("GetFields_b");
+            Class clazz3 = Class.forName("GetFields_c");
+            Field[] fields1 = clazz1.getFields();
+            Field[] fields2 = clazz2.getFields();
+            Field[] fields3 = clazz3.getFields();
+            if (fields1.length == 2 && fields2.length == 2 && fields3.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/expected.txt b/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/maple.prof b/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..2069b3be4b7c02667f18af02f60d0863bf1334fd
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/test.cfg b/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c14243b075c0923bc5e9b7d1a7f02dae34aa1963
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0050-rt-compact-ReflectiongetFields/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetFields)
+run(ReflectionGetFields)
diff --git a/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/ReflectionGetMethod1.java b/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/ReflectionGetMethod1.java
new file mode 100755
index 0000000000000000000000000000000000000000..37930216dcf8aa0590f63d40055214fe2bd57c07
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/ReflectionGetMethod1.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetMethod1_a {
+    public int setName(String name) {
+        return 10;
+    }
+    public String getStr() {
+        return "getDda";
+    }
+}
+class GetMethod1 extends GetMethod1_a {
+    public void empty() {
+    }
+    void emptyB() {
+    }
+    int getNum() {
+        return 0;
+    }
+    private String getDd() {
+        return "getDd";
+    }
+    public void empty(int number) {
+    }
+    int getNum(String name) {
+        return 2;
+    }
+}
+public class ReflectionGetMethod1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetMethod1");
+            Method method1 = clazz.getMethod("empty");
+            Method method2 = clazz.getMethod("empty", int.class);
+            Method method3 = clazz.getMethod("setName", String.class);
+            Method method4 = clazz.getMethod("getStr");
+            if (method1.toString().equals("public void GetMethod1.empty()")
+                    && method2.toString().equals("public void GetMethod1.empty(int)")
+                    && method3.toString().equals("public int GetMethod1_a.setName(java.lang.String)")
+                    && method4.toString().equals("public java.lang.String GetMethod1_a.getStr()")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/expected.txt b/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/maple.prof b/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..8e563240fcda693b0b781e3197697968b29e0c64
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/test.cfg b/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d1b4d987bbfd22cb854bc4a5f50121dd4566066
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0051-rt-compact-ReflectiongetMethod1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetMethod1)
+run(ReflectionGetMethod1)
diff --git a/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/ReflectionGetMethod2.java b/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/ReflectionGetMethod2.java
new file mode 100755
index 0000000000000000000000000000000000000000..869034cd4ec387c502fdb85b9bdc750a7bf00483
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/ReflectionGetMethod2.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetMethod2_a {
+    public int getName(String name) {
+        return 10;
+    }
+    public String getString() {
+        return "dda";
+    }
+}
+class GetMethod2 extends GetMethod2_a {
+    public void getVoid() {
+    }
+    void empty() {
+    }
+    int getZero() {
+        return 0;
+    }
+    private String getStr() {
+        return "dd";
+    }
+    public void setNum(int number) {
+    }
+    int getSecondNum(String name) {
+        return 2;
+    }
+}
+public class ReflectionGetMethod2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetMethod2");
+            Method method1 = clazz1.getMethod("empty");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            // NoSuchMethodException is thrown when method not exist.
+            try {
+                Class clazz2 = Class.forName("GetMethod2");
+                Method method2 = clazz2.getMethod(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchMethodException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                // Expected result: NullPointerException is thrown when method is null.
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/expected.txt b/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/maple.prof b/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..216df7fe3a2d1dddfe7bb497d0dea09c2048b576
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/test.cfg b/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c8bd7ac97a63b007d2398cf4d90126643be71e0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0052-rt-compact-ReflectiongetMethod2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetMethod2)
+run(ReflectionGetMethod2)
diff --git a/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/ReflectionGetSigners.java b/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/ReflectionGetSigners.java
new file mode 100755
index 0000000000000000000000000000000000000000..67f397c3c1e61d1ccb4b9a59cf4e3652103ad70b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/ReflectionGetSigners.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class GetSigners {
+}
+public class ReflectionGetSigners {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetSigners");
+            Object[] objects = clazz.getSigners();
+            if (objects == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/expected.txt b/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/maple.prof b/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..b78cbd88ed14c1e2600ee16a1bcd3cf838409afb
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/test.cfg b/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ec7f078485d2adf793e030d022b22348e5c9d0db
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0053-rt-compact-ReflectiongetSigners/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetSigners)
+run(ReflectionGetSigners)
diff --git a/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/ReflectionGetSimpleName.java b/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/ReflectionGetSimpleName.java
new file mode 100755
index 0000000000000000000000000000000000000000..f3cab4f35f567237c0a3b8e4b7754c97d337e7db
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/ReflectionGetSimpleName.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class GetSimpleName {
+}
+public class ReflectionGetSimpleName {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetSimpleName");
+            String string = clazz.getSimpleName();
+            if (string.equals("GetSimpleName")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/expected.txt b/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/maple.prof b/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ee6f87bed03254968dec69ab0d1fbc36dbdfb2c2
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/test.cfg b/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2e1b172f63dc2719d81babb429116e77e6a4969c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0054-rt-compact-ReflectiongetSimpleName/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetSimpleName)
+run(ReflectionGetSimpleName)
diff --git a/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/ReflectionGetTypeParameters.java b/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/ReflectionGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..724c8c4c4d9492a33b449fcf9adb560f0adc831a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/ReflectionGetTypeParameters.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.TypeVariable;
+class GetTypeParameters<s, T> {
+}
+public class ReflectionGetTypeParameters {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetTypeParameters");
+            TypeVariable[] typeParameters = clazz.getTypeParameters();
+            if (typeParameters.length == 2 && typeParameters[0].getName().equals("s")
+                    && typeParameters[1].getName().equals("T")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/expected.txt b/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/maple.prof b/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..7ed49b978a42a81c95b399ea5ddc16c6fdf44375
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/test.cfg b/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7bf45370b3c138d07f472eb6c734fe6cd5e2c367
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0055-rt-compact-ReflectiongetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetTypeParameters)
+run(ReflectionGetTypeParameters)
diff --git a/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/ReflectionIsArray.java b/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/ReflectionIsArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..167d9047c6fc4b0b352209ef961a5aa3a00f9cd3
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/ReflectionIsArray.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class IsArray {
+    public int num;
+    String str;
+    float fNum;
+}
+public class ReflectionIsArray {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("IsArray");
+            Field[] fields = clazz.getDeclaredFields();
+            Class clazz1 = fields.getClass();
+            if (clazz1.isArray()) {
+                if (!clazz.isArray()) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/expected.txt b/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/maple.prof b/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..dca8326dbf9335fc7e989919795a8ae8a9fa3c63
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/test.cfg b/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e394d5efb9f3041b988159e9d88f2a240454d9b7
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0056-rt-compact-ReflectionisArray/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsArray)
+run(ReflectionIsArray)
diff --git a/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java b/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java
new file mode 100755
index 0000000000000000000000000000000000000000..f628c5e0035525d5ce84608e70f90e538cf08110
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class AssignableFrom1 {
+}
+class AssignableFrom1_a extends AssignableFrom1 {
+}
+interface AssignableFromTest1 {
+}
+interface AssignableFromTest1_a extends AssignableFromTest1 {
+}
+public class ReflectionIsAssignableFrom1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("AssignableFrom1");
+            Class clazz2 = Class.forName("AssignableFrom1_a");
+            Class clazz3 = Class.forName("AssignableFromTest1");
+            Class clazz4 = Class.forName("AssignableFromTest1_a");
+            if (clazz1.isAssignableFrom(clazz2) && !clazz2.isAssignableFrom(clazz1) && clazz3.isAssignableFrom(clazz4)
+                    && !clazz4.isAssignableFrom(clazz3)) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/expected.txt b/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/maple.prof b/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..535eed8bf0d78bfb3a3d5331f990eabd7e55d9f6
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/test.cfg b/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..baffcdd8bac1781e70fbb8ebab0c3d217ff56c6b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0057-rt-compact-ReflectionisAssignableFrom1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsAssignableFrom1)
+run(ReflectionIsAssignableFrom1)
diff --git a/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java b/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..1bdbfaf35f523b87f5680184bd639cf8b6206e31
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class AssignableFromNullPointerException {
+}
+public class ReflectionIsAssignableFromNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("AssignableFromNullPointerException");
+            zqp1.isAssignableFrom(null);
+            result = -1;
+        } catch (ClassNotFoundException e1) {
+            result = -1;
+        } catch (NullPointerException e2) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/expected.txt b/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/maple.prof b/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..23b2691ee85c3e0a1aa944080459f47485a2ef5e
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/test.cfg b/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f1532263804f3e0d733ca881e3647ecf285a4b56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0058-rt-compact-ReflectionisAssignableFrom2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsAssignableFromNullPointerException)
+run(ReflectionIsAssignableFromNullPointerException)
diff --git a/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/ReflectionIsLocalClass.java b/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/ReflectionIsLocalClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..13eb67b9e6eaed210f6e6ffb95a7b0b67c8ed2b7
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/ReflectionIsLocalClass.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionIsLocalClass {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        class isLocalClass {
+        }
+        try {
+            Class zqp1 = isLocalClass.class;
+            Class zqp2 = Class.forName("ReflectionIsLocalClass");
+            Class zqp3 = IsLocalClass_a.class;
+            Class zqp4 = IsLocalClass_b.class;
+            Class zqp5 = (new isLocalClass() {
+            }).getClass();
+            if (!zqp2.isLocalClass()) {
+                if (!zqp3.isLocalClass()) {
+                    if (!zqp4.isLocalClass()) {
+                        if (!zqp5.isLocalClass()) {
+                            if (zqp1.isLocalClass()) {
+                                result = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = 2;
+        }
+        System.out.println(result);
+    }
+    class IsLocalClass_a {
+    }
+    static class IsLocalClass_b {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/expected.txt b/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/maple.prof b/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..41a6c01f1ca87136d1697eaecb76ede0d9524081
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/test.cfg b/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a62a8fad4d8141ac022dee5d815098e01f670f41
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0059-rt-compact-ReflectionisLocalClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsLocalClass)
+run(ReflectionIsLocalClass)
diff --git a/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/ReflectionIsMemberClass.java b/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/ReflectionIsMemberClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..5d6e4d624f8f22f2ff8573807824c4c5c1b80a91
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/ReflectionIsMemberClass.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionIsMemberClass {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        class IsMemberClass_a {
+        }
+        try {
+            Class zqp1 = IsMemberClass.class;
+            Class zqp2 = Class.forName("ReflectionIsMemberClass");
+            Class zqp3 = IsMemberClass_a.class;
+            Class zqp4 = IsMemberClass_b.class;
+            Class zqp5 = (new IsMemberClass_b() {
+            }).getClass();
+            if (!zqp2.isMemberClass()) {
+                if (!zqp3.isMemberClass()) {
+                    if (zqp4.isMemberClass()) {
+                        if (!zqp5.isMemberClass()) {
+                            if (zqp1.isMemberClass()) {
+                                result = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+    class IsMemberClass {
+    }
+    static class IsMemberClass_b {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/expected.txt b/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/maple.prof b/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..12809ece0268319ea295d25fa1fc6328bea249c9
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/test.cfg b/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..059b9c6a50bca10d682dc16df52c16b519b4555e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0060-rt-compact-ReflectionisMemberClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsMemberClass)
+run(ReflectionIsMemberClass)
diff --git a/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/ReflectionIsPrimitive.java b/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/ReflectionIsPrimitive.java
new file mode 100755
index 0000000000000000000000000000000000000000..32a86b762392dfbc44088059d98da13fd8322720
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/ReflectionIsPrimitive.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionIsPrimitive {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        Class zqp1 = ReflectionIsPrimitive.class;
+        Class zqp2 = int.class;
+        Class zqp3 = boolean.class;
+        Class zqp4 = byte.class;
+        Class zqp5 = char.class;
+        Class zqp6 = short.class;
+        Class zqp7 = long.class;
+        Class zqp8 = float.class;
+        Class zqp9 = double.class;
+        Class zqp10 = void.class;
+        if (!zqp1.isPrimitive() && zqp2.isPrimitive() && zqp3.isPrimitive() && zqp4.isPrimitive() && zqp5.isPrimitive()
+                && zqp6.isPrimitive() && zqp7.isPrimitive() && zqp8.isPrimitive() && zqp9.isPrimitive() &&
+                zqp10.isPrimitive()) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/expected.txt b/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/maple.prof b/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..aeb056928162bb28c944627eb6262a26232fb797
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/test.cfg b/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a36146eb8d5be1a2e45a6f5206f1f07878a6c2e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0061-rt-compact-ReflectionisPrimitive/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsPrimitive)
+run(ReflectionIsPrimitive)
diff --git a/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/ReflectionIsSynthetic.java b/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/ReflectionIsSynthetic.java
new file mode 100755
index 0000000000000000000000000000000000000000..fc4a7be61301a7de30a6371abf6fd3fff8453151
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/ReflectionIsSynthetic.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionIsSynthetic {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        new IsSynthetic();
+        try {
+            Class zqp1 = IsSynthetic.class;
+            Class zqp2 = int.class;
+            Class zqp3 = Class.forName("ReflectionIsSynthetic$1");
+            if (!zqp2.isSynthetic()) {
+                if (!zqp1.isSynthetic()) {
+                    if (zqp3.isSynthetic()) {
+                        result = 0;
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+    private static class IsSynthetic {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/expected.txt b/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/maple.prof b/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..cdc6a5394f96cd4c6b7c513a06c76ba23289c4ef
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/test.cfg b/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ae536c99a1b846c5f978c388170599fb04710743
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0062-rt-compact-ReflectionisSynthetic/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsSynthetic)
+run(ReflectionIsSynthetic)
diff --git a/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/ReflectionNewInstance1.java b/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/ReflectionNewInstance1.java
new file mode 100755
index 0000000000000000000000000000000000000000..528af2f2ee885c7b7de826092f024be5ddfb6278
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/ReflectionNewInstance1.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class NewInstance1 {
+}
+public class ReflectionNewInstance1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("NewInstance1");
+            Object zhu = zqp.newInstance();
+            if (zhu.toString().indexOf("NewInstance1@") != -1) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/expected.txt b/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/maple.prof b/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..c2e4687ce6c44ce8bebc176022352ef814eaecc4
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/test.cfg b/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..81422d607c0cc1577019e7fb001692205bf212c8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0063-rt-compact-ReflectionnewInstance1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionNewInstance1)
+run(ReflectionNewInstance1)
diff --git a/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java b/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
new file mode 100755
index 0000000000000000000000000000000000000000..e7e9c146866bd8cc17940aac9d63de6ac9e14bab
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+interface NewInstance2 {
+}
+class NewInstance2_a {
+    private NewInstance2_a() {
+    }
+}
+public class ReflectionNewInstanceInstantiationExceptionIllegalAccessException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("NewInstance2");
+            Object zhu1 = zqp1.newInstance();
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (InstantiationException e1) {
+            try {
+                Class zqp2 = Class.forName("NewInstance2_a");
+                Object zhu2 = zqp2.newInstance();
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                result = -1;
+            } catch (InstantiationException e4) {
+                System.err.println(e4);
+                result = -1;
+            } catch (IllegalAccessException e5) {
+                result = 0;
+            }
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/expected.txt b/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/maple.prof b/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..4b1e607df6243fd7eb05ff639567391f75dac585
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/test.cfg b/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8177d6f3259f5eb30d5c11e21430d8d47648d996
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0064-rt-compact-ReflectionnewInstance2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionNewInstanceInstantiationExceptionIllegalAccessException)
+run(ReflectionNewInstanceInstantiationExceptionIllegalAccessException)
diff --git a/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/ReflectionToGenericString.java b/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/ReflectionToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e9ecfc96fa561ec6399a175eca76bfd6cfe83f4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/ReflectionToGenericString.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+@interface Eee {
+}
+@Eee
+abstract class ToGenericString<t> {
+}
+public class ReflectionToGenericString {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("ToGenericString");
+            String zhu = zqp.toGenericString();
+            if (zhu.equals("abstract class ToGenericString<t>")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/expected.txt b/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/maple.prof b/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..5ef48df1f2a792ce27a625d5db727829ab499add
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/test.cfg b/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d634a9ec1b268adb47cf7f75a8abf8292ab305ac
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0065-rt-compact-ReflectiontoGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionToGenericString)
+run(ReflectionToGenericString)
diff --git a/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/ReflectionToString.java b/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/ReflectionToString.java
new file mode 100755
index 0000000000000000000000000000000000000000..2077f1c8950ddff27b592803c018d83cc6e1f4dc
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/ReflectionToString.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+@interface Fff {
+}
+@Fff
+abstract class ToString_$<t> {
+}
+public class ReflectionToString {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("ToString_$");
+            String zhu = zqp.toString();
+            if (zhu.equals("class ToString_$")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/expected.txt b/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/maple.prof b/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..1aa2a4719c7d88fed1ff777dcf1a005252146ee0
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/test.cfg b/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9efdf9adbad0c5b375455b3c9f1fc59a6eb93189
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0066-rt-compact-ReflectiontoString/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionToString)
+run(ReflectionToString)
diff --git a/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/RTConstructorGetAnnotation1.java b/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/RTConstructorGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..3580eecc5fed26635b40686d1c6667c472f87f92
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/RTConstructorGetAnnotation1.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Www1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Www1_a {
+    int c() default 0;
+    String d() default "";
+}
+class ConstructorGetAnnotation1 {
+    @Www1(i = 333, t = "ConstructorgetAnnotation")
+    public ConstructorGetAnnotation1() {
+    }
+    public ConstructorGetAnnotation1(String name) {
+    }
+    @Www1_a(c = 666, d = "Constructor")
+    ConstructorGetAnnotation1(int number) {
+    }
+    ConstructorGetAnnotation1(String name, int number) {
+    }
+}
+public class RTConstructorGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class zqp = Class.forName("ConstructorGetAnnotation1");
+            Constructor zhu1 = zqp.getDeclaredConstructor(int.class);
+            Constructor zhu2 = zqp.getConstructor();
+            Constructor zhu3 = zqp.getConstructor(String.class);
+            if ((zhu1.getAnnotation(Www1_a.class).toString().indexOf("c=666") != -1 &&
+                    zhu1.getAnnotation(Www1_a.class).toString().indexOf("d=Constructor") != -1 &&
+                    zhu2.getAnnotation(Www1.class).toString().indexOf("i=333") != -1 &&
+                    zhu2.getAnnotation(Www1.class).toString().indexOf("t=ConstructorgetAnnotation") != -1)) {
+                if (zhu3.getAnnotation(Www1.class) == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/expected.txt b/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/maple.prof b/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..8240ad65dc2a7cac3a678d0f253748213042dd16
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/test.cfg b/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0288a9ece4c3c7106c9fab0e33fa0f31e88fb738
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0067-rt-compact-RTConstructorgetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetAnnotation1)
+run(RTConstructorGetAnnotation1)
diff --git a/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java b/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..18126ce2ed74ba8e368facb012be5ae48ddd337e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+class ConstructorGetAnnotation2 {
+    @IF2(i = 333, t = "ConstructorGetAnnotation")
+    public ConstructorGetAnnotation2() {
+    }
+    @IF2_a(c = 666, d = "Constructor")
+    ConstructorGetAnnotation2(int number) {
+    }
+}
+class ConstructorGetAnnotation2_a {
+    ConstructorGetAnnotation2_a(String name, int number) {
+    }
+}
+public class RTConstructorGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetAnnotation2");
+            Constructor instance1 = cls.getDeclaredConstructor(int.class);
+            Constructor instance2 = cls.getConstructor();
+            if (instance1.getAnnotation(IF2.class) == null && instance2.getAnnotation(IF2_a.class) == null) {
+                instance1.getAnnotation(IF2.class).toString();
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(1);
+            return;
+        } catch (NullPointerException e3) {
+            try {
+                Class cls = Class.forName("ConstructorGetAnnotation2_a");
+                Constructor instance3 = cls.getDeclaredConstructor(String.class, int.class);
+                if (instance3.getAnnotation(IF2.class) == null && instance3.getAnnotation(IF2_a.class) == null) {
+                    instance3.getAnnotation(IF2.class).toString();
+                }
+                System.out.println(1);
+                return;
+            } catch (ClassNotFoundException e4) {
+                System.out.println(2);
+                return;
+            } catch (NoSuchMethodException e5) {
+                System.out.println(3);
+                return;
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+                return;
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/expected.txt b/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/maple.prof b/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..585d2445d6471b98daa9abc8a9fc62b94fa0fc70
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/test.cfg b/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3d083ec105646fbb384186edfdb83daa22ac168
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0068-rt-compact-RTConstructorgetAnnotation2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetAnnotation2)
+run(RTConstructorGetAnnotation2)
diff --git a/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/RTConstructorGetDeclaredAnnotations1.java b/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/RTConstructorGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..5e985b15f35fc7cda0e3c448577990ec5495e4b3
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/RTConstructorGetDeclaredAnnotations1.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class ConstructorGetDeclaredAnnotations1 {
+    public ConstructorGetDeclaredAnnotations1() {
+    }
+    @IF1(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations1(String name) {
+    }
+    @IF1(i = 333, t = "test1")
+    ConstructorGetDeclaredAnnotations1(int number) {
+    }
+}
+class ConstructorGetDeclaredAnnotations1_a extends ConstructorGetDeclaredAnnotations1 {
+    @IF1_a(i_a = 666, t_a = "right1")
+    @IF1(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations1_a(String name) {
+    }
+    @IF1_a(i_a = 666, t_a = "right1")
+    ConstructorGetDeclaredAnnotations1_a(int number) {
+    }
+}
+public class RTConstructorGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetDeclaredAnnotations1_a");
+            Constructor instance1 = cls.getConstructor(String.class);
+            if (instance1.getDeclaredAnnotations().length == 2) {
+                Constructor instance2 = cls.getDeclaredConstructor(int.class);
+                if (instance2.getDeclaredAnnotations().length == 1) {
+                    Annotation[] j = instance2.getDeclaredAnnotations();
+                    if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                        System.out.println(0);
+                        return;
+                    }
+                }
+                System.out.println(1);
+                return;
+            }
+            System.out.println(2);
+            return;
+        } catch (ClassNotFoundException e) {
+            System.out.println(3);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(4);
+            return;
+        } catch (NullPointerException e2) {
+            System.out.println(5);
+            return;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/expected.txt b/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/maple.prof b/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..f7478a072c7f85f4206ff67b3f85301ac353e4c9
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/test.cfg b/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b4ffbb7fa2d6dc6de2346ceb074977494da4f516
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0069-rt-compact-RTConstructorgetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetDeclaredAnnotations1)
+run(RTConstructorGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java b/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..d0d85fefc04351ac49a3b99e2130fc2426bf9a88
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class ConstructorGetDeclaredAnnotations2 {
+    public ConstructorGetDeclaredAnnotations2() {
+    }
+    @IF2(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations2(String name) {
+    }
+    @IF2(i = 333, t = "test1")
+    ConstructorGetDeclaredAnnotations2(int number) {
+    }
+}
+class ConstructorGetDeclaredAnnotations2_a extends ConstructorGetDeclaredAnnotations2 {
+    public ConstructorGetDeclaredAnnotations2_a(String name) {
+    }
+    ConstructorGetDeclaredAnnotations2_a(int number) {
+    }
+}
+public class RTConstructorGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetDeclaredAnnotations2_a");
+            Constructor instance1 = cls.getConstructor(String.class);
+            Constructor instance2 = cls.getDeclaredConstructor(int.class);
+            if (instance1.getDeclaredAnnotations().length == 0 && instance2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        } catch (NullPointerException e2) {
+            System.out.println(4);
+            return;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/expected.txt b/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/maple.prof b/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..62d86fd243bb9e27544d30edb7d5dbd85bcbfa96
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/test.cfg b/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b7763007e500a539b5b403aae2768f02595568af
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0070-rt-compact-RTConstructorgetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetDeclaredAnnotations2)
+run(RTConstructorGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/RTConstructorGetExceptionTypes.java b/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/RTConstructorGetExceptionTypes.java
new file mode 100755
index 0000000000000000000000000000000000000000..57c41b0f023491e06d74d47e0eda9fb966cb39b9
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/RTConstructorGetExceptionTypes.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class ConstructorGetExceptionTypes {
+    ConstructorGetExceptionTypes() throws ExceptionInInitializerError, InstantiationException {
+    }
+}
+public class RTConstructorGetExceptionTypes {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetExceptionTypes");
+            Constructor cons = cls.getDeclaredConstructor();
+            Class<?>[] exClass = cons.getExceptionTypes();
+            if (exClass.length == 2) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(3);
+            return;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/expected.txt b/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/maple.prof b/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..82973935da1f9853f5f756cf048b11905af32c92
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/test.cfg b/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..28cfff70c27fdc9fe6aefcf916df16ec15625e25
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0071-rt-compact-RTConstructorgetExceptionTypes/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetExceptionTypes)
+run(RTConstructorGetExceptionTypes)
diff --git a/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/RTConstructorGetTypeParameters.java b/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/RTConstructorGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..6b2e34ecf3186975641bcea0c6867f764ba43bb9
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/RTConstructorGetTypeParameters.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.TypeVariable;
+class ConstructorGetTypeParameters {
+    public <t, s, d, f, g> ConstructorGetTypeParameters(int number) {
+    }
+    ConstructorGetTypeParameters() {
+    }
+}
+public class RTConstructorGetTypeParameters {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetTypeParameters");
+            Constructor instance1 = cls.getConstructor(int.class);
+            Constructor instance2 = cls.getDeclaredConstructor();
+            TypeVariable[] q1 = instance1.getTypeParameters();
+            TypeVariable[] q2 = instance2.getTypeParameters();
+            if (q1.length == 5 && q2.length == 0) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(3);
+            return;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/expected.txt b/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/maple.prof b/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ab55b85c4a309b8834d09a527854c728cd9af5d3
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/test.cfg b/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e123110e3b2f21d6013e9995dfde410e249a0011
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0072-rt-compact-RTConstructorgetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetTypeParameters)
+run(RTConstructorGetTypeParameters)
diff --git a/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/RTConstructorToGenericString1.java b/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/RTConstructorToGenericString1.java
new file mode 100755
index 0000000000000000000000000000000000000000..bb250a151730358c6bcf90fe51b8ff2268ee67d1
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/RTConstructorToGenericString1.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class ConstructorToGenericString1 {
+    public <t, s, d, f, g> ConstructorToGenericString1(int number) {
+    }
+}
+public class RTConstructorToGenericString1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorToGenericString1");
+            Constructor instance1 = cls.getConstructor(int.class);
+            if (instance1.toGenericString().equals("public <t,s,d,f,g> ConstructorToGenericString1(int)")) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/expected.txt b/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/maple.prof b/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..eca6b0e214429eac376e58ecec276e7a0327ae2c
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/test.cfg b/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..780d7839896896f7f79cbd4902d639b9b836a02f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0073-rt-compact-RTConstructortoGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorToGenericString1)
+run(RTConstructorToGenericString1)
diff --git a/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/RTFieldGet1.java b/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/RTFieldGet1.java
new file mode 100755
index 0000000000000000000000000000000000000000..9986a72d0b37ccacd85d6b65481effe6cd644be7
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/RTFieldGet1.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class FieldGet1_a {
+    public static String str = "aaa";
+    public int num = 2;
+    public int num1 = 5;
+    public static boolean aBoolean = false;
+}
+class FieldGet1 extends FieldGet1_a {
+    public static String str = "bbb";
+    public int number = 1;
+    public int test = super.num1 + 1;
+    public static boolean bBoolean = true;
+    public char aChar = '国';
+}
+public class RTFieldGet1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet1");
+            Object obj = cls.newInstance();
+            Object q1 = cls.getField("str").get(obj);
+            Object q2 = cls.getField("number").get(obj);
+            Object q3 = cls.getField("test").get(obj);
+            Object q4 = cls.getField("bBoolean").get(obj);
+            Object q5 = cls.getField("aChar").get(obj);
+            Object q6 = cls.getField("num").get(obj);
+            Object q7 = cls.getField("aBoolean").get(null);
+            if (q1.toString().equals("bbb") && (int) q2 == 1 && (int) q3 == 6 && (boolean) q4 && q5.toString().
+                    equals("国") && (int) q6 == 2) {
+                Class cls1 = Class.forName("FieldGet1_a");
+                Object instance1 = cls1.newInstance();
+                Object q8 = cls1.getField("str").get(instance1);
+                if (q8.toString().equals("aaa")) {
+                    if (!(boolean) q7) {
+                        System.out.println(0);
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/expected.txt b/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/maple.prof b/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..20ed22c1926d355b971660a7dd5f78adaf8ba25b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/test.cfg b/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d26c0c731765bf2d8c769b63b7a0f0275f8e7c89
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0074-rt-compact-RTFieldget1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGet1)
+run(RTFieldGet1)
diff --git a/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/RTFieldGet2.java b/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/RTFieldGet2.java
new file mode 100755
index 0000000000000000000000000000000000000000..8ca4b1a64152cb161c09f0cf761941f8c6f82696
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/RTFieldGet2.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class FieldGet2_a {
+    public int num;
+}
+class FieldGet2 extends FieldGet2_a {
+    private int number = 1;
+    public boolean aBoolean = true;
+    public int number1 = 8;
+}
+class FieldGet2_b {
+    public int number1 = 18;
+}
+public class RTFieldGet2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet2");
+            Object obj = cls.newInstance();
+            Object q1 = cls.getDeclaredField("number").get(obj);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            try {
+                Class cls = Class.forName("FieldGet2");
+                Class cls1 = Class.forName("FieldGet2_b");
+                Object instance1 = cls1.newInstance();
+                Object q2 = cls.getDeclaredField("number1").get(instance1);
+            } catch (ClassNotFoundException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (InstantiationException e6) {
+                System.err.println(e6);
+                System.out.println(2);
+            } catch (NoSuchFieldException e7) {
+                System.err.println(e7);
+                System.out.println(2);
+            } catch (IllegalAccessException e8) {
+                System.err.println(e8);
+                System.out.println(2);
+            } catch (IllegalArgumentException e9) {
+                try {
+                    Class cls = Class.forName("FieldGet2");
+                    Object q3 = cls.getDeclaredField("aBoolean").get(null);
+                } catch (ClassNotFoundException e10) {
+                    System.err.println(e10);
+                    System.out.println(2);
+                } catch (NoSuchFieldException e11) {
+                    System.err.println(e11);
+                    System.out.println(2);
+                } catch (IllegalAccessException e12) {
+                    System.err.println(e12);
+                    System.out.println(2);
+                } catch (NullPointerException e13) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/expected.txt b/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/maple.prof b/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..651ab54fe4e8d4076afad6d38544afacb887e0b9
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/test.cfg b/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc8135c4f2804b4cfe275b0517dacd3aaa376c12
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0075-rt-compact-RTFieldget2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGet2)
+run(RTFieldGet2)
diff --git a/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/RTFieldGet3.java b/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/RTFieldGet3.java
new file mode 100755
index 0000000000000000000000000000000000000000..c6e48ee1fbabf99ecd990329748effb16c3ee368
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/RTFieldGet3.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class FieldGet3_a {
+    public int num;
+}
+class FieldGet3 extends FieldGet3_a {
+    public static String str;
+}
+public class RTFieldGet3 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet3");
+            Object obj = cls.newInstance();
+            Object obj1 = cls.getField("str").get(obj);
+            Object obj2 = cls.getField("num").get(obj);
+            if (obj1 == null && (int) obj2 == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/expected.txt b/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/maple.prof b/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..c93544089afca2c37a068865dc3b81e2025905e7
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/test.cfg b/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e03d65831474e9d2e35c9806a7270d0b7ea88f6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0076-rt-compact-RTFieldget3/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGet3)
+run(RTFieldGet3)
diff --git a/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/RTFieldGetAnnotation1.java b/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/RTFieldGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..08617b324f7bd4dd592cf19b96c363998f23d48c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/RTFieldGetAnnotation1.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface4 {
+    int num() default 0;
+    String str() default "";
+}
+@interface interface4_a {
+    int number() default 0;
+    String string() default "";
+}
+class FieldGetAnnotation1 {
+    @interface4(num = 333, str = "GetAnnotation")
+    public int num1;
+    @interface4_a(number = 555, string = "test")
+    public String str1;
+}
+public class RTFieldGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls1 = Class.forName("FieldGetAnnotation1");
+            Field instance1 = cls1.getField("num1");
+            Field instance2 = cls1.getField("str1");
+            if (instance1.getAnnotation(interface4_a.class) == null && instance2.getAnnotation(interface4.class) == null)
+            {
+                instance1.getAnnotation(interface4_a.class).number();
+            }
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/expected.txt b/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/maple.prof b/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..91a36170d74d89ebd6712d0f352260b00a51ab96
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/test.cfg b/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..038efbbe99c922b3c43d2a5d922de442b16b447e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0077-rt-compact-RTFieldgetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetAnnotation1)
+run(RTFieldGetAnnotation1)
diff --git a/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/RTFieldGetDeclaredAnnotations1.java b/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/RTFieldGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..c837033e3e024041c2aeb98b463c73d4d43843f8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/RTFieldGetDeclaredAnnotations1.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface1 {
+    int num() default 0;
+    String str() default "";
+}
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface1_a {
+    int num_a() default 2;
+    String str_a() default "";
+}
+class FieldGetDeclaredAnnotations1 {
+    @interface1(num = 333, str = "test1")
+    public int num;
+    @interface1(num = 333, str = "test1")
+    public String str;
+}
+class FieldGetDeclaredAnnotations1_a extends FieldGetDeclaredAnnotations1 {
+    @interface1_a(num_a = 666, str_a = "right1")
+    public int num;
+    @interface1_a(num_a = 666, str_a = "right1")
+    public String str;
+}
+public class RTFieldGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaredAnnotations1_a");
+            Field instance1 = cls.getField("num");
+            if (instance1.getDeclaredAnnotations().length == 1) {
+                Annotation[] j = instance1.getDeclaredAnnotations();
+                if (j[0].toString().indexOf("num_a=666") != -1 && j[0].toString().indexOf("str_a=right1") != -1) {
+                    Field instance2 = cls.getDeclaredField("str");
+                    if (instance2.getDeclaredAnnotations().length == 1) {
+                        Annotation[] k = instance2.getDeclaredAnnotations();
+                        if (k[0].toString().indexOf("num_a=666") != -1 && k[0].toString().indexOf("str_a=right1") != -1)
+                        {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/expected.txt b/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/maple.prof b/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..5a4b9e20520f68d232352278aee47894cd9b1e1c
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/test.cfg b/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..713f37be93b64a395a9aa6954b6cd60ef9e6e15d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0078-rt-compact-RTFieldgetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetDeclaredAnnotations1)
+run(RTFieldGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java b/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..69210be25f0c4e4e77676b1a20cf44fe98c0d70e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface2 {
+    int num() default 0;
+    String str() default "";
+}
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class FieldGetDeclaredAnnotations2 {
+    @interface2(num = 333, str = "test1")
+    public int num;
+    @interface2(num = 333, str = "test1")
+    public String str;
+}
+class FieldGetDeclaredAnnotations2_a extends FieldGetDeclaredAnnotations2 {
+    @interface2_a(i_a = 666, t_a = "right1")
+    public int num;
+    public String str;
+}
+public class RTFieldGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaredAnnotations2_a");
+            Field instance1 = cls.getField("str");
+            Field instance2 = cls.getDeclaredField("str");
+            if (instance1.getDeclaredAnnotations().length == 0 && instance2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/expected.txt b/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/maple.prof b/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3823b46a14856a0c26881f675aa8bad1b76c4691
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/test.cfg b/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..edc2fa4b88b3f94f2d4052ca150ff67395e0885d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0079-rt-compact-RTFieldgetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetDeclaredAnnotations2)
+run(RTFieldGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java b/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..79dd428df0a6230af282dc2db660dfa65b9f9574
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldGetDeclaringClass {
+    public int num;
+    char aChar;
+}
+public class RTFieldGetDeclaringClass {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaringClass");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("aChar");
+            Class<?> j = instance1.getDeclaringClass();
+            Class<?> k = instance2.getDeclaringClass();
+            if (j.getName().equals("FieldGetDeclaringClass") && k.getName().equals("FieldGetDeclaringClass")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/expected.txt b/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/maple.prof b/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..1a6dde231ebee00de1d0784c7def6feeb1530e8a
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/test.cfg b/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..78abc74919e406847c2fc46b73307aeec9407306
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0080-rt-compact-RTFieldgetDeclaringClass/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetDeclaringClass)
+run(RTFieldGetDeclaringClass)
diff --git a/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/RTFieldGetModifiers.java b/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/RTFieldGetModifiers.java
new file mode 100755
index 0000000000000000000000000000000000000000..6bd3b08cb2fdeeae08e778195400cabb5fca1775
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/RTFieldGetModifiers.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldGetModifiers {
+    public static int num;
+    final String str = "aaa";
+    private String string = "ccc";
+    protected static int number;
+}
+public class RTFieldGetModifiers {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetModifiers");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("str");
+            Field instance3 = cls.getDeclaredField("string");
+            Field field = cls.getDeclaredField("number");
+            if (instance1.getModifiers() == 9 && instance2.getModifiers() == 16 && instance3.getModifiers() == 2
+                    && field.getModifiers()
+                    == 12) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/expected.txt b/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/maple.prof b/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ab04abcec4b1f3c9e4cd16d9feb6ce21dd6d57d5
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/test.cfg b/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9fba25ad93c47c3e2ccd452364326b370c0a2eed
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0081-rt-compact-RTFieldgetModifiers/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetModifiers)
+run(RTFieldGetModifiers)
diff --git a/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/RTFieldGetName.java b/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/RTFieldGetName.java
new file mode 100755
index 0000000000000000000000000000000000000000..d9a174b23e09e9f6c156abaf711ba8f5fd96ccb4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/RTFieldGetName.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldGetName {
+    public static int num;
+    final String str = "aaa";
+}
+public class RTFieldGetName {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetName");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("str");
+            if (instance1.getName().equals("num") && instance2.getName().equals("str")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/expected.txt b/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/maple.prof b/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3b177b5b135ed79877a9f8f018b1f6f4e39e795b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/test.cfg b/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e6bb647a31aecf3b2fa6d3c5dd87a074c0ddc15
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0082-rt-compact-RTFieldgetName/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetName)
+run(RTFieldGetName)
diff --git a/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/RTFieldGetType.java b/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/RTFieldGetType.java
new file mode 100755
index 0000000000000000000000000000000000000000..7ecb6cf13dc518f459216fb74d3e5f06345b9fa4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/RTFieldGetType.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldGetType {
+    public static short sNum;
+    final char aChar = '什';
+    private float fNum;
+}
+public class RTFieldGetType {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetType");
+            Field instance1 = cls.getField("sNum");
+            Field instance2 = cls.getDeclaredField("aChar");
+            Field instance3 = cls.getDeclaredField("fNum");
+            if (instance1.getType().getName().equals("short") && instance2.getType().getName().equals("char")
+                    && instance3.getType().getName().equals("float")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/expected.txt b/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/maple.prof b/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..46382a3e98b5b74e0b2d4e1795fce9249f18d15f
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/test.cfg b/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..51d322a0d0fa561f363cdf697f9326d73c2d487a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0083-rt-compact-RTFieldgetType/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetType)
+run(RTFieldGetType)
diff --git a/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/RTFieldSet1.java b/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/RTFieldSet1.java
new file mode 100755
index 0000000000000000000000000000000000000000..ed28cef52403d4ec726174b325b1572577acd24c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/RTFieldSet1.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldSet1_a {
+    public static String str = "aaa";
+    public int num2 = 2;
+    public int number = 5;
+    public static int num1;
+}
+class FieldSet1 extends FieldSet1_a {
+    public static String str = "bbb";
+    public int num = 1;
+    public int test = super.number + 1;
+    public static boolean aBoolean = true;
+    public char aChar;
+}
+public class RTFieldSet1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet1");
+            Object obj = cls.newInstance();
+            Field f1 = cls.getField("str");
+            Field f2 = cls.getField("num");
+            Field f3 = cls.getField("aBoolean");
+            Field f4 = cls.getField("aChar");
+            Field f5 = cls.getField("num1");
+            Field f6 = cls.getField("num2");
+            Field f7 = cls.getField("number");
+            f1.set(obj, "ccc");
+            f2.set(obj, 10);
+            f3.set(obj, false);
+            f4.set(obj, '国');
+            f5.set(obj, 20);
+            f6.set(obj, 30);
+            f7.set(obj, 40);
+            if (f1.get(obj).toString().equals("ccc") && (int) f2.get(obj) == 10 && !(boolean) f3.get(obj) && (int)
+                    f6.get(obj) == 30) {
+                if (f4.get(obj).toString().equals("国") && (int) f5.get(obj) == 20) {
+                    if ((int) cls.getField("test").get(obj) == 6) {
+                        Class cls1 = Class.forName("FieldSet1_a");
+                        Object instance1 = cls1.newInstance();
+                        Object p = cls1.getDeclaredField("str").get(instance1);
+                        if (p.toString().equals("aaa")) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/expected.txt b/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/maple.prof b/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..8eb03c13f1da10242174ca9365bcc01cce31b494
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/test.cfg b/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..24631a745c304682776f3326ac25d65e07ff5810
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0084-rt-compact-RTFieldset1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldSet1)
+run(RTFieldSet1)
diff --git a/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/RTFieldSet2.java b/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/RTFieldSet2.java
new file mode 100755
index 0000000000000000000000000000000000000000..e2f65c1a1e33cf6b6db150fa5f845c02e32fb349
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/RTFieldSet2.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldSet2_a {
+    public static String str = "aaa";
+    public int num;
+}
+class FieldSet2 extends FieldSet2_a {
+    public static String str;
+    private int num = 1;
+    public boolean aBoolean = true;
+    public int num1 = 8;
+}
+class FieldSet2_b {
+    public int num = 18;
+}
+public class RTFieldSet2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet2");
+            Object obj = cls.newInstance();
+            Field field = cls.getDeclaredField("num");
+            field.set(obj, 10);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            try {
+                Class cls = Class.forName("FieldSet2");
+                Class cls1 = Class.forName("FieldSet2_b");
+                Object instance1 = cls1.newInstance();
+                Field f1 = cls.getDeclaredField("aBoolean");
+                f1.set(instance1, 10);
+            } catch (ClassNotFoundException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (InstantiationException e6) {
+                System.err.println(e6);
+                System.out.println(2);
+            } catch (NoSuchFieldException e7) {
+                System.err.println(e7);
+                System.out.println(2);
+            } catch (IllegalAccessException e8) {
+                System.err.println(e8);
+                System.out.println(2);
+            } catch (IllegalArgumentException e9) {
+                try {
+                    Class cls = Class.forName("FieldSet2");
+                    Field f2 = cls.getDeclaredField("aBoolean");
+                    f2.set(null, false);
+                } catch (ClassNotFoundException e10) {
+                    System.err.println(e10);
+                    System.out.println(2);
+                } catch (NoSuchFieldException e11) {
+                    System.err.println(e11);
+                    System.out.println(2);
+                } catch (IllegalAccessException e12) {
+                    System.err.println(e12);
+                    System.out.println(2);
+                } catch (NullPointerException e13) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/expected.txt b/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/maple.prof b/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..30da4d3d87208726ca7c75b5df4d56623dd1e4f7
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/test.cfg b/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..64dcadda7d2e4e32184858c065e4f980c13aedcb
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0085-rt-compact-RTFieldset2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldSet2)
+run(RTFieldSet2)
diff --git a/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/RTFieldSet3.java b/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/RTFieldSet3.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e44394ec0c1241858263c9acade58d7a811d3f1
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/RTFieldSet3.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldSet3_a {
+    public final static String str = "aaa";
+    public int num = 2;
+}
+class FieldSet3 extends FieldSet3_a {
+    public final int num = 1;
+}
+public class RTFieldSet3 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet3");
+            Object obj = cls.newInstance();
+            Field q1 = cls.getField("str");
+            Field q2 = cls.getField("num");
+            q1.set(obj, "bbb");
+            q2.set(obj, 10);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/expected.txt b/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/maple.prof b/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..882da918103a149a0976ffe03325b4f6337d4410
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/test.cfg b/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a6cabbc7493a4f8093f206ee3f995fcc22ad9f2a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0086-rt-compact-RTFieldset3/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldSet3)
+run(RTFieldSet3)
diff --git a/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/RTFieldSet4.java b/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/RTFieldSet4.java
new file mode 100755
index 0000000000000000000000000000000000000000..c631e7691589020bdb5620a90b9d3a37897c441a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/RTFieldSet4.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldSet4 {
+    public static String str;
+    private int num = 1;
+    public boolean aBoolean = true;
+    public int num1 = 8;
+}
+public class RTFieldSet4 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet4");
+            Object obj = cls.newInstance();
+            Field field = cls.getDeclaredField("str");
+            field.set(null, "aaa");
+            System.out.println(0);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/expected.txt b/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/maple.prof b/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..8efac0a7218c7394ac2d28f6f5e4ff65ffad18b7
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/test.cfg b/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..920b758deac9632cda1d2d787dc1eeaebd08a6a9
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0087-rt-compact-RTFieldset4/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldSet4)
+run(RTFieldSet4)
diff --git a/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/RTFieldToGenericString.java b/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/RTFieldToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..5edd578b1e2f39139601675eefbcbcc05f8eadbf
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/RTFieldToGenericString.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.util.List;
+class FieldToGenericString<E, F> {
+    public List<F> list1;
+    private List<E> list2;
+}
+public class RTFieldToGenericString {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldToGenericString");
+            Field instance1 = cls.getField("list1");
+            Field instance2 = cls.getDeclaredField("list2");
+            String q1 = instance1.toGenericString();
+            String q2 = instance2.toGenericString();
+            if (q1.equals("public java.util.List<F> FieldToGenericString.list1") && q2.equals
+                    ("private java.util.List<E> FieldToGenericString.list2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/expected.txt b/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/maple.prof b/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..775704ba186984986b514a9cbb1696cd4e5d36c7
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/test.cfg b/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e72437fa5b4538e177d899305ce9d930a62bc76b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0088-rt-compact-RTFieldtoGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldToGenericString)
+run(RTFieldToGenericString)
diff --git a/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/RTFieldToString.java b/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/RTFieldToString.java
new file mode 100755
index 0000000000000000000000000000000000000000..87c9e346b49e32234d3db39d0a98c21911973a31
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/RTFieldToString.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.util.List;
+class FieldToString<E, F> {
+    public List<F> list1;
+    private List<E> list2;
+}
+public class RTFieldToString {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldToString");
+            Field instance1 = cls.getField("list1");
+            Field instance2 = cls.getDeclaredField("list2");
+            String q1 = instance1.toString();
+            String q2 = instance2.toString();
+            if (q1.equals("public java.util.List FieldToString.list1")
+                    && q2.equals("private java.util.List FieldToString.list2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/expected.txt b/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/maple.prof b/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..610b1589292e242ec69ee8d56e89d11de076686e
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/test.cfg b/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc1097bce3be5ddd05b51be644ce77af115fd3c4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0089-rt-compact-RTFieldtoString/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldToString)
+run(RTFieldToString)
diff --git a/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/RTMethodGetAnnotation1.java b/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/RTMethodGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..7486687061da0505f6b29ac679c5d77ae3872ea5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/RTMethodGetAnnotation1.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i_a() default 0;
+    String t_b() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    int c() default 0;
+    String d() default "";
+}
+class MethodGetAnnotation1 {
+    @IF1(i_a = 333, t_b = "MethodGetAnnotation")
+    public void test1() {
+    }
+    public void test2(String name) {
+    }
+    @IF1_a(c = 666, d = "Method")
+    void test3(int number) {
+    }
+    void test4(String name, int number) {
+    }
+}
+public class RTMethodGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetAnnotation1");
+            Method method1 = clazz.getDeclaredMethod("test3", int.class);
+            Method method2 = clazz.getMethod("test1");
+            Method method3 = clazz.getMethod("test2", String.class);
+            if (method1.getAnnotation(IF1_a.class).c() == 666
+                    && method1.getAnnotation(IF1_a.class).d().equals("Method")
+                    && method2.getAnnotation(IF1.class).i_a() == 333
+                    && method2.getAnnotation(IF1.class).t_b().equals("MethodGetAnnotation")) {
+                if (method3.getAnnotation(IF1.class) == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/expected.txt b/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/maple.prof b/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3ae0da937e85c28a6f76f993b0581e0df120d3c1
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/test.cfg b/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa315cf69ebfa7c6e286549039f3a7b525fe782c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0090-rt-compact-RTMethodgetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetAnnotation1)
+run(RTMethodGetAnnotation1)
diff --git a/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java b/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..f5cce1f0045f5994218efbde68d6b5e738928249
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.CLASS)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.SOURCE)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+class MethodGetAnnotation2 {
+    @IF2(i = 333, t = "MethodGetAnnotation")
+    public void test1() {
+    }
+    @IF2_a(c = 666, d = "Method")
+    void test3(int number) {
+    }
+}
+public class RTMethodGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetAnnotation2");
+            Method method1 = clazz.getDeclaredMethod("test3", int.class);
+            Method method2 = clazz.getMethod("test1");
+            if (method1.getAnnotation(IF2_a.class) == null && method2.getAnnotation(IF2.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/expected.txt b/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/maple.prof b/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..fafd0688f8e711cc8a86e53d9172be6709552632
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/test.cfg b/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a1120b7692649e7ca29098b91e9eecb17b5b2c6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0091-rt-compact-RTMethodgetAnnotation2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetAnnotation2)
+run(RTMethodGetAnnotation2)
diff --git a/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/RTMethodGetDeclaredAnnotations1.java b/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/RTMethodGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..edcf864dcb084ab3234fe97c0ef52d94446cb757
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/RTMethodGetDeclaredAnnotations1.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class MethodGetDeclaredAnnotations1 {
+    @IFw1(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+    @IFw1(i = 333, t = "test1")
+    void tt(int number) {
+    }
+}
+class MethodGetDeclaredAnnotations1_a extends MethodGetDeclaredAnnotations1 {
+    @IFw1_a(i_a = 666, t_a = "right1")
+    public static void ii(String name) {
+    }
+    @IFw1_a(i_a = 666, t_a = "right1")
+    void tt(int number) {
+    }
+}
+public class RTMethodGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetDeclaredAnnotations1_a");
+            Method method1 = clazz.getMethod("ii", String.class);
+            if (method1.getDeclaredAnnotations().length == 1) {
+                Annotation[] annotations1 = method1.getDeclaredAnnotations();
+                if (annotations1[0].toString().indexOf("i_a=666") != -1
+                        && annotations1[0].toString().indexOf("t_a=right1") != -1) {
+                    Method method2 = clazz.getDeclaredMethod("tt", int.class);
+                    if (method2.getDeclaredAnnotations().length == 1) {
+                        Annotation[] annotations2 = method2.getDeclaredAnnotations();
+                        if (annotations2[0].toString().indexOf("i_a=666") != -1
+                                && annotations2[0].toString().indexOf("t_a=right1") != -1) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/expected.txt b/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/maple.prof b/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ce2c31567b055d1d6cddc07ab9eec9a1f8629071
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/test.cfg b/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..22660d016852a77db15ac79b48a832a6b3dad09b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0092-rt-compact-RTMethodgetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetDeclaredAnnotations1)
+run(RTMethodGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java b/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..6c494882f903a7b489284293c571218720480171
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class MethodGetDeclaredAnnotations2 {
+    @IFw2(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+    @IFw2_a(i_a = 666, t_a = "right1")
+    void tt(int number) {
+    }
+}
+class MethodGetDeclaredAnnotations2_a extends MethodGetDeclaredAnnotations2 {
+    public static void ii(String name) {
+    }
+    void tt() {
+    }
+}
+public class RTMethodGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetDeclaredAnnotations2_a");
+            Method method1 = clazz.getMethod("ii", String.class);
+            Method method2 = clazz.getDeclaredMethod("tt");
+            if (method1.getDeclaredAnnotations().length == 0 && method2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/expected.txt b/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/maple.prof b/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..5c4c92fdc7a5fd833c9b80e8db711134ace79232
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/test.cfg b/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a00193b5142acdb017e6edc9281e0455b9237b5d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0093-rt-compact-RTMethodgetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetDeclaredAnnotations2)
+run(RTMethodGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/RTMethodGetDefaultValue1.java b/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/RTMethodGetDefaultValue1.java
new file mode 100755
index 0000000000000000000000000000000000000000..5b1784f2ab01cb6c0e206b804d14789083072d1b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/RTMethodGetDefaultValue1.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    public int i_a() default 2;
+    String t_a() default "string default value";
+    String s();
+}
+class MethodGetDefaultValue1 {
+    @IF1(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+    void tt(int number) {
+    }
+}
+public class RTMethodGetDefaultValue1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("IF1_a");
+            Class clazz2 = Class.forName("IF1");
+            Class clazz3 = Class.forName("MethodGetDefaultValue1");
+            Method method1 = clazz1.getDeclaredMethod("i_a");
+            Method method2 = clazz1.getMethod("t_a");
+            Method method3 = clazz2.getDeclaredMethod("t");
+            Method[] methods = clazz3.getMethods();
+            Method method5 = clazz3.getDeclaredMethod("tt", int.class);
+            Method method6 = clazz1.getDeclaredMethod("s");
+            if ((int) method1.getDefaultValue() == 2
+                    && method2.getDefaultValue().toString().equals("string default value")) {
+                if (method3.getDefaultValue().equals("")) {
+                    if (methods[0].getDefaultValue() == null && method5.getDefaultValue() == null) {
+                        if (method6.getDefaultValue() == null) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/expected.txt b/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/maple.prof b/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..356f4df261d42140cac769d0de7f41c4bd0542f1
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/test.cfg b/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..213868a4dda5099572882cd23aa7eb799defb2c8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0094-rt-compact-RTMethodgetDefaultValue1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetDefaultValue1)
+run(RTMethodGetDefaultValue1)
diff --git a/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/RTMethodGetParameterCount.java b/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/RTMethodGetParameterCount.java
new file mode 100755
index 0000000000000000000000000000000000000000..ee8614285c236a87f670372a83a4e3e235f56e9c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/RTMethodGetParameterCount.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class MethodGetParameterCount2 {
+    void test1() {
+    }
+    public void test2(String name, int number, char c, short s, float f, double d, long l, boolean b, byte bb) {
+    }
+}
+public class RTMethodGetParameterCount {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetParameterCount2");
+            Method method = clazz.getDeclaredMethod("test1");
+            Method[] methods = clazz.getMethods();
+            if (method.getParameterCount() == 0) {
+                if (methods[0].getParameterCount() == 9) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/expected.txt b/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/maple.prof b/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..549496029bef957186f6da9ee2c84be4b20a71d0
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/test.cfg b/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b616ccbbc4d2638a88ca937c5d40f5bdd71d330
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0095-rt-compact-RTMethodgetParameterCount/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetParameterCount)
+run(RTMethodGetParameterCount)
diff --git a/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/RTMethodGetTypeParameters.java b/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/RTMethodGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..d7b58159429cc8f99d631d2b7087def4759593c0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/RTMethodGetTypeParameters.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+import java.lang.reflect.TypeVariable;
+class MethodGetTypeParameters2 {
+    public <t, s, d, f, g> void ss(int number) {
+    }
+    void kk() {
+    }
+}
+public class RTMethodGetTypeParameters {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetTypeParameters2");
+            Method method1 = clazz.getMethod("ss", int.class);
+            Method method2 = clazz.getDeclaredMethod("kk");
+            TypeVariable[] typeVariables1 = method1.getTypeParameters();
+            TypeVariable[] typeVariables2 = method2.getTypeParameters();
+            if (typeVariables1.length == 5 && typeVariables2.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/expected.txt b/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/maple.prof b/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..b5061cbebe8eee55f56dd8c6e684e5b1593c19bf
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/test.cfg b/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..865572a6c9a152a3c223cf7e125fb5888bc9b14a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0096-rt-compact-RTMethodgetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetTypeParameters)
+run(RTMethodGetTypeParameters)
diff --git a/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/RTMethodIsDefault.java b/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/RTMethodIsDefault.java
new file mode 100755
index 0000000000000000000000000000000000000000..96fe28490abea660ec1f4482c76d16d5be01706f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/RTMethodIsDefault.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+interface MethodIsDefault_A {
+    default public void run() {
+        String i;
+    }
+}
+class MethodIsDefault implements MethodIsDefault_A {
+    public void run() {
+        String i = "abc";
+    }
+    void ss(int number) {
+    }
+}
+public class RTMethodIsDefault {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("MethodIsDefault_A");
+            Class clazz2 = Class.forName("MethodIsDefault");
+            Method method1 = clazz1.getMethod("run");
+            Method method2 = clazz2.getMethod("run");
+            Method method3 = clazz2.getDeclaredMethod("ss", int.class);
+            if (method1.isDefault()) {
+                if (!method2.isDefault() && !method3.isDefault()) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e) {
+            System.err.println(e);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/expected.txt b/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/maple.prof b/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..6cad59bd6d53c1ba6997afb5780fdcf48ddb09c9
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/test.cfg b/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6ebfab5a8cc99ffcdefeed7815e4210f750a01bf
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0097-rt-compact-RTMethonisDefault/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodIsDefault)
+run(RTMethodIsDefault)
diff --git a/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/RTMethodToGenericString.java b/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/RTMethodToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..68a02ceda5c6d0758e3fe98c234f697bc839db52
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/RTMethodToGenericString.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class MethodToGenericString {
+    public <t, s, d, f, g> void ss(int number) {
+    }
+}
+public class RTMethodToGenericString {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodToGenericString");
+            Method method = clazz.getMethod("ss", int.class);
+            if (method.toGenericString().equals("public <t,s,d,f,g> void MethodToGenericString.ss(int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/expected.txt b/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/maple.prof b/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..1ade6876276fefdaab333403ad396add823bb782
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/test.cfg b/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..adf4fe232874cf02803c21e7c86534a7f367ea91
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0098-rt-compact-RTMethontoGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodToGenericString)
+run(RTMethodToGenericString)
diff --git a/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/RTModifierParameterModifiers.java b/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/RTModifierParameterModifiers.java
new file mode 100755
index 0000000000000000000000000000000000000000..8000f727351831a442186359e8d7f899047fa64b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/RTModifierParameterModifiers.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class RTModifierParameterModifiers {
+    public static void main(String[] args) {
+        if (Modifier.parameterModifiers() == 16) {
+            System.out.println(0);
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/expected.txt b/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/maple.prof b/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..16e2e1b349d7a962eb26c11a9a353d47b038da6c
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/test.cfg b/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a8ad20be5c90d8e31efc75d94fa916ac2eb3be7d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0099-rt-compact-RTModifierparameterModifiers/test.cfg
@@ -0,0 +1,2 @@
+compile(RTModifierParameterModifiers)
+run(RTModifierParameterModifiers)
diff --git a/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/RTParameterGetAnnotation1.java b/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/RTParameterGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..ea539b8bb3ef1a46bdae43ef65be3986d69008d8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/RTParameterGetAnnotation1.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotation1 {
+    ParameterGetAnnotation1(@IF1(i = 222, t = "Parameter") int number) {
+    }
+    public ParameterGetAnnotation1(String name) {
+    }
+    public void test1(@IF1_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotation1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            if (p1[0].getAnnotation(IF1.class).i() == 222 && p1[0].getAnnotation(IF1.class).t().equals("Parameter")
+                    && p3[0].getAnnotation(IF1_a.class).c() == 666
+                    && p3[0].getAnnotation(IF1_a.class).d().equals("Happy new year")) {
+                if (p2[0].getAnnotation(IF1.class) == null) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(2);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(3);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(4);
+            return;
+        }
+        System.out.println(5);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/expected.txt b/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/maple.prof b/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..c8f35acebdb248302aba7037e31f1bfe20264a36
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/test.cfg b/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..37c38048aebe6890094975c42edd8b3cbdea9f3f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0100-rt-compact-RTParametergetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotation1)
+run(RTParameterGetAnnotation1)
diff --git a/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/RTParameterGetAnnotation2.java b/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/RTParameterGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a90a33962a5a490592cf7be0ffca1753f61fcc5f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/RTParameterGetAnnotation2.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotation2 {
+    ParameterGetAnnotation2(@IF2(i = 222, t = "Parameter") int number) {
+    }
+    public void test1(@IF2_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotation2");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getAnnotation(IF2_a.class) == null && p2[0].getAnnotation(IF2.class) == null) {
+                p1[0].getAnnotation(IF2_a.class).c();
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        } catch (NullPointerException e2) {
+            try {
+                Class cls1 = Class.forName("ParameterGetAnnotation2");
+                Method method2 = cls1.getMethod("test1", int.class);
+                Parameter[] p3 = method2.getParameters();
+                p3[0].getAnnotation(null);
+                System.out.println(3);
+                return;
+            } catch (ClassNotFoundException e3) {
+                System.out.println(4);
+                return;
+            } catch (NoSuchMethodException e4) {
+                System.out.println(5);
+                return;
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(6);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/expected.txt b/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/maple.prof b/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..21f583c5e75e25752fef3a4e61ca52a99741db69
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/test.cfg b/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35b895fd68e27ba60ae1fcd2a3967739c9130c2a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0101-rt-compact-RTParametergetAnnotation2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotation2)
+run(RTParameterGetAnnotation2)
diff --git a/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/RTParameterGetAnnotations1.java b/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/RTParameterGetAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..0e9965732244df5d9686548c56f010f545bbec63
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/RTParameterGetAnnotations1.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF3 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF3_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotations1 {
+    ParameterGetAnnotations1(@IF3(i = 222, t = "Parameter") @IF3_a(c = 666, d = "Happy new year") int number) {
+    }
+    public void test1(String name) {
+    }
+}
+public class RTParameterGetAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotations1");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getAnnotations().length == 2 && p2[0].getAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/expected.txt b/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/maple.prof b/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..c04d5330c0f1a1f7dab3ff57aa37203e654760cb
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/test.cfg b/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3543d246cb42173ca70eead172bb09dd7142945e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0102-rt-compact-RTParametergetAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotations1)
+run(RTParameterGetAnnotations1)
diff --git a/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/RTParameterGetAnnotationsByType1.java b/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/RTParameterGetAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..3517bb0c03ff66261526274e1f10d4c4007ca5a6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/RTParameterGetAnnotationsByType1.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF7 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF7_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotationsByType1 {
+    ParameterGetAnnotationsByType1(@IF7(i = 222, t = "Parameter") int number) {
+    }
+    public ParameterGetAnnotationsByType1(String name) {
+    }
+    public void test1(@IF7_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetAnnotationsByType1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotationsByType1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            Annotation[] q1 = p1[0].getAnnotationsByType(IF7.class);
+            Annotation[] q3 = p3[0].getAnnotationsByType(IF7_a.class);
+            if (p2[0].getAnnotationsByType(IF7.class).length == 0) {
+                if (q1[0].toString().indexOf("i=222") != -1 && q1[0].toString().indexOf("t=Parameter") != -1
+                        && q3[0].toString().indexOf("c=666") != -1
+                        && q3[0].toString().indexOf("d=Happy new year") != -1) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(1);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(4);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/expected.txt b/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/maple.prof b/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..54010ded1a2aa137fb1c26e2200db62370064fd4
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/test.cfg b/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..40b4d88c9d8a4c2a949def245fef2ee26c89fef2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0103-rt-compact-RTParametergetAnnotationsByType1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotationsByType1)
+run(RTParameterGetAnnotationsByType1)
diff --git a/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java b/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java
new file mode 100755
index 0000000000000000000000000000000000000000..e0e1dd66eddf414d8d847b25823c04b43ff57118
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF8 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF8_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotationsByType2 {
+    ParameterGetAnnotationsByType2(@IF8(i = 222, t = "Parameter") int number) {
+    }
+    public void test1(@IF8_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetAnnotationsByType2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotationsByType2");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            Annotation[] q1 = p1[0].getAnnotationsByType(IF8_a.class);
+            Annotation[] q2 = p2[0].getAnnotationsByType(IF8.class);
+            q1[0].toString();
+            q2[0].toString();
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        } catch (ArrayIndexOutOfBoundsException e2) {
+            try {
+                Class cls1 = Class.forName("ParameterGetAnnotationsByType2");
+                Constructor cons1 = cls1.getDeclaredConstructor(int.class);
+                Parameter[] p3 = cons1.getParameters();
+                Annotation[] q3 = p3[0].getAnnotationsByType(null);
+                System.out.println(3);
+                return;
+            } catch (ClassNotFoundException e3) {
+                System.out.println(4);
+                return;
+            } catch (NoSuchMethodException e4) {
+                System.out.println(5);
+                return;
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(6);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/expected.txt b/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/maple.prof b/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..773fd5f0662b3bf45ff217942250818c733ba05f
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/test.cfg b/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e09808848473401901c12d923b13d46f67501f3
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0104-rt-compact-RTParametergetAnnotationsByType2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotationsByType2)
+run(RTParameterGetAnnotationsByType2)
diff --git a/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/RTParameterGetDeclaredAnnotation1.java b/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/RTParameterGetDeclaredAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..9d396087885fe2bdac360b2dc1afd37b07e6b4a5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/RTParameterGetDeclaredAnnotation1.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF6 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF6_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetDeclaredAnnotation1 {
+    ParameterGetDeclaredAnnotation1(@IF6(i = 222, t = "Parameter") int number) {
+    }
+    public ParameterGetDeclaredAnnotation1(String name) {
+    }
+    public void test1(@IF6_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetDeclaredAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotation1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            if (p1[0].getDeclaredAnnotation(IF6.class).i() == 222 && p1[0].getDeclaredAnnotation(IF6.class).t()
+                    .equals("Parameter") && p3[0].getDeclaredAnnotation(IF6_a.class).c() == 666
+                    && p3[0].getDeclaredAnnotation(IF6_a.class).d().equals("Happy new year")) {
+                if (p2[0].getDeclaredAnnotation(IF6.class) == null) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(1);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(4);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/expected.txt b/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/maple.prof b/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..cb2f0aeb56accc017f81f1af4571996beb0c3c71
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/test.cfg b/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35306c952436c270263350c96aed4416e333ac48
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0105-rt-compact-RTParametergetDeclaredAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetDeclaredAnnotation1)
+run(RTParameterGetDeclaredAnnotation1)
diff --git a/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/RTParameterGetDeclaredAnnotations1.java b/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/RTParameterGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..97badfbc064bed9111c93fbb391ac52f326f0aba
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/RTParameterGetDeclaredAnnotations1.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF5 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF5_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetDeclaredAnnotations1 {
+    ParameterGetDeclaredAnnotations1(@IF5(i = 222, t = "Parameter") @IF5_a(c = 666, d = "Happy new year") int number) {
+    }
+    public void test1(String name) {
+    }
+}
+public class RTParameterGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotations1");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getDeclaredAnnotations().length == 2 && p2[0].getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/expected.txt b/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/maple.prof b/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..bd9d05c16271d80ad4b4c6183778e22881204433
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/test.cfg b/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a56164a0bdd7162c492e926bbe8eea14178f1101
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0106-rt-compact-RTParametergetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetDeclaredAnnotations1)
+run(RTParameterGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java b/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..78f4b2c8f0222b16e5de47bd1671049c10037a88
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF4 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF4_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetDeclaredAnnotations2 {
+    ParameterGetDeclaredAnnotations2() {
+    }
+    ParameterGetDeclaredAnnotations2(@IF4(i = 222, t = "Parameter") int number) {
+    }
+    public void test1(@IF4(i = 222, t = "Parameter") String name) {
+    }
+}
+class ParameterGetDeclaredAnnotations2_a extends ParameterGetDeclaredAnnotations2 {
+    ParameterGetDeclaredAnnotations2_a() {
+    }
+    ParameterGetDeclaredAnnotations2_a(@IF4_a(c = 666, d = "Happy new year") int number) {
+    }
+    public void test1(@IF4_a(c = 666, d = "Happy new year") String name) {
+    }
+}
+class ParameterGetDeclaredAnnotations2_b extends ParameterGetDeclaredAnnotations2_a {
+    ParameterGetDeclaredAnnotations2_b(int number) {
+    }
+    public void test1(String name) {
+    }
+}
+public class RTParameterGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotations2_b");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getDeclaredAnnotations().length == 0 && p2[0].getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/expected.txt b/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/maple.prof b/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..04130830137180955fd5095da7e4c49bcaa23298
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/test.cfg b/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..184ca2b1fd76d4b466903be11803828e8c3d8c4c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0107-rt-compact-RTParametergetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetDeclaredAnnotations2)
+run(RTParameterGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/RTParameterGetDeclaredAnnotationsByType1.java b/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/RTParameterGetDeclaredAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..d8c9b01962d8a50dd53c666c818a675491b29752
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/RTParameterGetDeclaredAnnotationsByType1.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF9 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF9_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetDeclaredAnnotationsByType1 {
+    ParameterGetDeclaredAnnotationsByType1(@IF9(i = 222, t = "Parameter") int number) {
+    }
+    public ParameterGetDeclaredAnnotationsByType1(String name) {
+    }
+    public void test1(@IF9_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetDeclaredAnnotationsByType1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotationsByType1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            Annotation[] q1 = p1[0].getDeclaredAnnotationsByType(IF9.class);
+            Annotation[] q3 = p3[0].getDeclaredAnnotationsByType(IF9_a.class);
+            if (p2[0].getDeclaredAnnotationsByType(IF9.class).length == 0) {
+                if (q1[0].toString().indexOf("i=222") != -1 && q1[0].toString().indexOf("t=Parameter") != -1
+                        && q3[0].toString().indexOf("c=666") != -1
+                        && q3[0].toString().indexOf("d=Happy new year") != -1) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(1);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(4);
+        return;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/expected.txt b/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/maple.prof b/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..d4b976ea5d6283654c1e8beba65135a8f2e3448b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/test.cfg b/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a5fdcc4753c84b599f1a1b2bcd23b7f3d40f6e72
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0108-rt-compact-RTParametergetDeclaredAnnotationsByType1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetDeclaredAnnotationsByType1)
+run(RTParameterGetDeclaredAnnotationsByType1)
diff --git a/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/RTProxyGetProxyClass1.java b/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/RTProxyGetProxyClass1.java
new file mode 100755
index 0000000000000000000000000000000000000000..61a977101f645a3a67be93c6b96bb2e97232c865
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/RTProxyGetProxyClass1.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Proxy;
+interface ProxyGetProxyClass1_1 {
+    default void test1() {
+    }
+    default void test2() {
+    }
+    default void test3() {
+    }
+    default void test4() {
+    }
+    default void test5() {
+    }
+    default void test6() {
+    }
+    default void test7() {
+    }
+    default void test8() {
+    }
+    default void test9() {
+    }
+    default void test10() {
+    }
+    default void test11() {
+    }
+    default void test12() {
+    }
+    default void test13() {
+    }
+    default void test14() {
+    }
+    default void test15() {
+    }
+    default void test16() {
+    }
+    default void test17() {
+    }
+    default void test18() {
+    }
+    default void test19() {
+    }
+    default void test20() {
+    }
+    default void test21() {
+    }
+    default void test22() {
+    }
+    default void test23() {
+    }
+    default void test24() {
+    }
+    default void test25() {
+    }
+    default void test26() {
+    }
+    default void test27() {
+    }
+    default void test28() {
+    }
+    default void test29() {
+    }
+    default void test30() {
+    }
+}
+interface ProxyGetProxyClass1_2 extends ProxyGetProxyClass1_1 {
+    default void test30() {
+    }
+}
+interface ProxyGetProxyClass1_3 {
+    default void test31() {
+    }
+}
+public class RTProxyGetProxyClass1 {
+    public static void main(String[] args) {
+        try {
+            Proxy.getProxyClass(ProxyGetProxyClass1_1.class.getClassLoader(), new Class[] {ProxyGetProxyClass1_1.class,
+                    ProxyGetProxyClass1_2.class});
+            Proxy.getProxyClass(ProxyGetProxyClass1_1.class.getClassLoader(), new Class[] {ProxyGetProxyClass1_1.class,
+                    ProxyGetProxyClass1_3.class});
+        } catch (IllegalArgumentException e) {
+            System.err.println(e);
+        }
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/expected.txt b/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/maple.prof b/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..978ae6792f4b933956d601734d05588f7d571850
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/test.cfg b/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d78975803b8e406ec0b9744a0873300a7d5ac9a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0109-rt-compact-RTProxygetProxyClass1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTProxyGetProxyClass1)
+run(RTProxyGetProxyClass1)
diff --git a/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java b/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java
new file mode 100755
index 0000000000000000000000000000000000000000..9579b393258b936b9ed2c6e3cbc7c02b43b5ed90
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+public class ClassGetDeclaredAnnotationNPE {
+    public static void main(String argv[]) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = ClassGetDeclaredAnnotationNPE_1();
+        } catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetDeclaredAnnotationNPE_1() {
+        try {
+            Annotation a = MyClass.class.getDeclaredAnnotation(Deprecated.class);
+            a = MyClass.class.getDeclaredAnnotation(null);
+        } catch (NullPointerException e) {
+            return 0;
+        }
+        return 4;
+    }
+    @Deprecated
+    class MyClass extends MySuperClass {
+    }
+    @MyAnnotation
+    class MySuperClass {
+    }
+    @interface MyAnnotation {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/expected.txt b/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/maple.prof b/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..70f33fce889dd21876465414e5b55982931a9dec
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/test.cfg b/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..11d42b16a7053f585ed8ce24e657b917a7b54d19
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0110-rt-compact-ClassgetDeclaredAnnotationNPE/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetDeclaredAnnotationNPE)
+run(ClassGetDeclaredAnnotationNPE)
diff --git a/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java b/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java
new file mode 100755
index 0000000000000000000000000000000000000000..3931497f0afa366dc8cd1e4c3ceb0313e7bfaeac
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ClassIsAssignableFromNPE {
+    public static void main(String argv[]) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = ClassIsAssignableFromNPE_1();
+        } catch (Exception e) {
+            System.out.println(e);
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassIsAssignableFromNPE_1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        int intArray[] = {1, 2, 3, 4, 5};
+        Class cl = null;
+        try {
+            intArray.getClass().isAssignableFrom(cl);
+        } catch (SecurityException e) {
+            return 1;
+        } catch (NullPointerException e) {
+            return 0;
+        }
+        return result1;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/expected.txt b/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/maple.prof b/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..fd0125d67407e7186c537778c20813f8be62c814
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/test.cfg b/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..05a5d21e657eea9de01b7cc44de6772fa1b61fb5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0111-rt-compact-reflectClasssetisAssignableFrom/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassIsAssignableFromNPE)
+run(ClassIsAssignableFromNPE)
diff --git a/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java b/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..101b52baf82057b2146bff925fec7adf7f393f6e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetAnnotationsByType1() {
+        Class<MyTargetTest0> m;
+        try {
+            m = MyTargetTest0.class;
+            MyTarget[] Target = m.getAnnotationsByType(MyTarget.class);
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest0 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest0(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/expected.txt b/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/maple.prof b/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..5d9e65e13ae35e9fa7a5da77b5b90356aed8d3e3
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/test.cfg b/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1746ae1d4c38eb5f6fbc5a49626203dd6d18a5c7
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0112-rt-compact-ClassGetAnnotationsByType/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetAnnotationsByType)
+run(ClassGetAnnotationsByType)
diff --git a/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/ClassGetCanonicalName.java b/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/ClassGetCanonicalName.java
new file mode 100755
index 0000000000000000000000000000000000000000..ebb4a3e2e5a564f1c029576a2dd8c1d13818be62
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/ClassGetCanonicalName.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetCanonicalName {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetCanonicalName1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetCanonicalName1() {
+        Class<MyTargetTest1> m;
+        try {
+            m = MyTargetTest1.class;
+            String str = m.getCanonicalName();
+            if ("ClassGetCanonicalName.MyTargetTest1".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest1 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest1(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/expected.txt b/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/maple.prof b/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..cb437a51df801fbf9322a55284e859cd126808b7
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/test.cfg b/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..99bdb27ce2323527b2393dd59483cb5461ecc3a3
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0113-rt-compact-ClassGetCanonicalName/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetCanonicalName)
+run(ClassGetCanonicalName)
diff --git a/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/ClassGetEnclosingClass.java b/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/ClassGetEnclosingClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..37cbfb439ea53d1b34a79e960dfdf675fc39ebf0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/ClassGetEnclosingClass.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetEnclosingClass {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetEnclosingClass1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetEnclosingClass1() {
+        Class<MyTargetTest2> m;
+        try {
+            m = MyTargetTest2.class;
+            Class<?> cl = m.getEnclosingClass();
+            if (cl != null) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest2 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest2(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/expected.txt b/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/maple.prof b/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..f35335a17ec9d3ebe7911ca4f3f5cb804b8fdcaa
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/test.cfg b/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fb1fa999d94db1a2375eb612a28d4b651fa985aa
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0114-rt-compact-ClassGetEnclosingClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetEnclosingClass)
+run(ClassGetEnclosingClass)
diff --git a/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/ClassGetEnumConstants.java b/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/ClassGetEnumConstants.java
new file mode 100755
index 0000000000000000000000000000000000000000..7dc673343c1313e73e606cef11a932701e78199e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/ClassGetEnumConstants.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetEnumConstants {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetEnumConstants1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetEnumConstants1() {
+        Class<MyTargetTest3> m;
+        try {
+            m = MyTargetTest3.class;
+            MyTargetTest3[] target = m.getEnumConstants();
+            if (target == null) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest3 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest3(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/expected.txt b/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/maple.prof b/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..761c64b4d9bb7e88feecd1964cb06f9d2d00e3ad
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/test.cfg b/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8716e599ee7ed2fc1473feeab82a24bffe0b30e7
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0115-rt-compact-ClassGetEnumConstants/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetEnumConstants)
+run(ClassGetEnumConstants)
diff --git a/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/ClassGetSimpleName.java b/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/ClassGetSimpleName.java
new file mode 100755
index 0000000000000000000000000000000000000000..afa45ec540d7e92849f0cc18a55c2d8a8d482c8c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/ClassGetSimpleName.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetSimpleName {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetSimpleName1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetSimpleName1() {
+        Class<MyTargetTest4> m;
+        try {
+            m = MyTargetTest4.class;
+            String str = m.getSimpleName();
+            if ("MyTargetTest4".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest4 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest4(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/expected.txt b/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/maple.prof b/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..4fc1161f0a4a82597f5107c8b98b819e3d86ec39
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/test.cfg b/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6414f8f96ec176b92f89fc487a1b20043216e79a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0116-rt-compact-ClassGetSimpleName/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetSimpleName)
+run(ClassGetSimpleName)
diff --git a/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/ClassGetTypeParameters.java b/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/ClassGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..fdb333816dd1d0e3348bde827a4cd6614aff77d2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/ClassGetTypeParameters.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.TypeVariable;
+public class ClassGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetTypeParameters1() {
+        Class<MyTargetTest5> m;
+        try {
+            m = MyTargetTest5.class;
+            TypeVariable<Class<MyTargetTest5>>[] target = m.getTypeParameters();
+            if (target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest5 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest5(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/expected.txt b/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/maple.prof b/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..4b93c9a18629de8a83a039631ab33bf0502b4541
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/test.cfg b/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8cc856d7705d514508350c12b9075d78d8286135
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0117-rt-compact-ClassGetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetTypeParameters)
+run(ClassGetTypeParameters)
diff --git a/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/ClassToGenericString.java b/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/ClassToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..4592b809ec96e4af44e1b3a91b548b690fcad66a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/ClassToGenericString.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassToGenericString1() {
+        Class<MyTargetTest6> m;
+        try {
+            m = MyTargetTest6.class;
+            String str = m.toGenericString();
+            if ("class ClassToGenericString$MyTargetTest6".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest6 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest6(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/expected.txt b/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/maple.prof b/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..075bb095b3f93659382527c0c4dda9765a8ee4bd
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/test.cfg b/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..82b925b0b8d865e48ced9cbe2653e332282ee5a6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0118-rt-compact-ClassToGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassToGenericString)
+run(ClassToGenericString)
diff --git a/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/ConstructorGetAnnotation.java b/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/ConstructorGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..5181be859c0a409aa3f651d8315db0f5c861ed26
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/ConstructorGetAnnotation.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+public class ConstructorGetAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorAnnotation1() {
+        Constructor<?> m;
+        try {
+            m = MyTargetTest00.class.getConstructor(new Class[] {ConstructorGetAnnotation.class, String.class});
+            MyTarget Target = m.getAnnotation(MyTarget.class);
+            if ("@ConstructorGetAnnotation$MyTarget(name=cons, value=constructor)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest00 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest00(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/expected.txt b/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/maple.prof b/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..552bd12563181c74778a9f099ce0dce8882288d7
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/test.cfg b/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..54b390155e72078c49fe10152fa56be3e3c33cf7
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0119-rt-compact-ConstructorGetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorGetAnnotation)
+run(ConstructorGetAnnotation)
diff --git a/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/ConstructorGetDeclaredAnnotations.java b/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/ConstructorGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..3dd363fa0e2b73d101a473921a76ecddf7628d3a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/ConstructorGetDeclaredAnnotations.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+public class ConstructorGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorGetDeclaredAnnotations1() {
+        Constructor<MyTargetTest01> m;
+        try {
+            m = MyTargetTest01.class.getConstructor(new Class[] {ConstructorGetDeclaredAnnotations.class, String.class});
+            MyTarget Target = m.getDeclaredAnnotation(MyTarget.class);
+            if ("@ConstructorGetDeclaredAnnotations$MyTarget(name=cons, value=constructor)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest01 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest01(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/expected.txt b/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/maple.prof b/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..085302dfb984c5728f8343b4cc10a2eaf37b1db5
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/test.cfg b/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..11801b80486cdf8170f6312c7ba512a56c65a763
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0120-rt-compact-ConstructorGetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorGetDeclaredAnnotations)
+run(ConstructorGetDeclaredAnnotations)
diff --git a/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java b/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java
new file mode 100755
index 0000000000000000000000000000000000000000..3d0c5a3622a3604e543f32e337441d23c96fdf76
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+public class ConstructorGetExceptionTypes {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetExceptionTypes1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorGetExceptionTypes1() {
+        Constructor<MyTargetTest02> m;
+        try {
+            m = MyTargetTest02.class.getConstructor(new Class[] {ConstructorGetExceptionTypes.class, String.class});
+            Class<?>[] Target = m.getExceptionTypes();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest02 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest02(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/expected.txt b/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/maple.prof b/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..b2cd3e02120f2091eed13ffd4572474a73608c7e
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/test.cfg b/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..13fb057a727642d2efb45cefa56074453816a710
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0121-rt-compact-ConstructorGetExceptionTypes/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorGetExceptionTypes)
+run(ConstructorGetExceptionTypes)
diff --git a/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java b/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..f61edcd64be3fbdf325bdc964962822e4d302115
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.TypeVariable;
+public class ConstructorGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorGetTypeParameters1() {
+        Constructor<MyTargetTest03> m;
+        try {
+            m = MyTargetTest03.class.getConstructor(new Class[] {ConstructorGetTypeParameters.class, String.class});
+            TypeVariable<Constructor<MyTargetTest03>>[] Target = m.getTypeParameters();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest03 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest03(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/expected.txt b/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/maple.prof b/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..2dd0b0c04118abb2b7a1ad89b352edf24868cf2f
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/test.cfg b/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f9bb972a1b576153bba3ac2192b1323c2b1327fc
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0122-rt-compact-ConstructorGetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorGetTypeParameters)
+run(ConstructorGetTypeParameters)
diff --git a/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/ConstructorToGenericString.java b/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/ConstructorToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..dec909bdeb32054b261933cc908dc8dbda39b98b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/ConstructorToGenericString.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+public class ConstructorToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorToGenericString1() {
+        Constructor<MyTargetTest04> m;
+        try {
+            m = MyTargetTest04.class.getConstructor(new Class[] {ConstructorToGenericString.class, String.class});
+            String str = m.toGenericString();
+            if ("public ConstructorToGenericString$MyTargetTest04(ConstructorToGenericString,java.lang.String)"
+                    .equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest04 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest04(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/expected.txt b/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/maple.prof b/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ab5f0dd2c754e92e7bc61ed2f5f25927f0d8e0b0
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/test.cfg b/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..69af375db60ee8062093f561671bff0da906977b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0123-rt-compact-ConstructorToGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorToGenericString)
+run(ConstructorToGenericString)
diff --git a/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/FieldGetAnnotation.java b/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/FieldGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..e0b85f5d354c1cfc24d8d9125fbd93113901ea2a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/FieldGetAnnotation.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldGetAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldGetAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int FieldGetAnnotation1() {
+        Field m;
+        try {
+            m = MyTargetTest06.class.getField("home");
+            MyTarget Target = m.getAnnotation(MyTarget.class);
+            if ("@FieldGetAnnotation$MyTarget(name=newName, value=newValue)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest06 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/expected.txt b/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/maple.prof b/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..9bfd759ddad0362b885976ebba367b70e10ca791
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/test.cfg b/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..70b9ee3acb085745bb72a8a195db940ebd009a50
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0124-rt-compact-FieldGetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetAnnotation)
+run(FieldGetAnnotation)
diff --git a/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/FieldGetAnnotationsByType.java b/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/FieldGetAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..b1f004b7f4ec48251fb7002a40d3fbc3abefdc4d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/FieldGetAnnotationsByType.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int FieldGetAnnotationsByType1() {
+        Field m;
+        try {
+            m = MyTargetTest07.class.getField("home");
+            MyTarget[] Target = m.getAnnotationsByType(MyTarget.class);
+            if (Target.length > 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest07 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest07(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/expected.txt b/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/maple.prof b/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..799833896d1ce75d683727bf2de076f1c727cdd4
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/test.cfg b/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fdbc885a3e3720c03490fc555bf9c523931d94f5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0125-rt-compact-FieldGetAnnotationsByType/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetAnnotationsByType)
+run(FieldGetAnnotationsByType)
diff --git a/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/FieldGetDeclaredAnnotations.java b/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/FieldGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..290d16ec7c6ea26f34fbd05907aeb53ae2c9d9af
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/FieldGetDeclaredAnnotations.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetDeclaredAnnotations1() {
+        Field m;
+        try {
+            m = MyTargetTest08.class.getField("home");
+            MyTarget Target = m.getDeclaredAnnotation(MyTarget.class);
+            if ("@FieldGetDeclaredAnnotations$MyTarget(name=newName, value=newValue)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest08 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest08(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/expected.txt b/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/maple.prof b/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..a09ce87613b3ae4245f25f02d85f724254df535f
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/test.cfg b/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..89d4c1ad916e134bf3885445a302690f09f26bd2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0126-rt-compact-FieldGetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetDeclaredAnnotations)
+run(FieldGetDeclaredAnnotations)
diff --git a/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/FieldIsAnnotationPresent.java b/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/FieldIsAnnotationPresent.java
new file mode 100755
index 0000000000000000000000000000000000000000..455f873a5dab30fbd6e0bae68f075bf725329303
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/FieldIsAnnotationPresent.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldIsAnnotationPresent {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodIsAnnotationPresent1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodIsAnnotationPresent1() {
+        Field m;
+        try {
+            m = MyTargetTest09.class.getField("home");
+            boolean flag = m.isAnnotationPresent(MyTarget.class);
+            if (flag) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest09 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest09(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/expected.txt b/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/maple.prof b/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..234705e7f08d1d416aec05346b6835dd6596775b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/test.cfg b/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2257a4f4866251512e0c6b9976f701a70f6fa0c1
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0127-rt-compact-FieldIsAnnotationPresent/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldIsAnnotationPresent)
+run(FieldIsAnnotationPresent)
diff --git a/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/FieldToGenericString.java b/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/FieldToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..3e6e3973ce063a18b2f5f55dc7d05f8a03ed3da1
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/FieldToGenericString.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int FieldToGenericString1() {
+        Field m;
+        try {
+            m = MyTargetTest10.class.getField("home");
+            String str = m.toGenericString();
+            if ("public java.lang.String FieldToGenericString$MyTargetTest10.home".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest10 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest10(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/expected.txt b/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/maple.prof b/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..53af6823df70d282298f82af51f7c4540ccf6132
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/test.cfg b/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e26bcb6528f91352ca299ef2a04efd63acbeca3f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0128-rt-compact-FieldToGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldToGenericString)
+run(FieldToGenericString)
diff --git a/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/MethodGetAnnotation.java b/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/MethodGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..5bb4751d5326dce5d3bf063f27f7dd9cb06048f2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/MethodGetAnnotation.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodGetAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetAnnotation1() {
+        Method m;
+        try {
+            m = MyTargetTest11.class.getMethod("MyTargetTest_1");
+            MyTarget Target = m.getAnnotation(MyTarget.class);
+            if ("@MethodGetAnnotation$MyTarget(name=name, value=value)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest11 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/expected.txt b/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/maple.prof b/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ea9534cce1933d5db20ce9e3949aa705721e0b64
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/test.cfg b/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a00548a8f302ca65b375f01264072446162f5429
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0129-rt-compact-MethodGetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetAnnotation)
+run(MethodGetAnnotation)
diff --git a/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/MethodGetDeclaredAnnotations.java b/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/MethodGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..0861a328eb1ac79f6cb2a4e2fc03b104bed4bc03
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/MethodGetDeclaredAnnotations.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetDeclaredAnnotations1() {
+        Method m;
+        try {
+            m = MyTargetTest12.class.getMethod("MyTargetTest_1");
+            MyTarget Target = m.getDeclaredAnnotation(MyTarget.class);
+            if ("@MethodGetDeclaredAnnotations$MyTarget(name=name, value=value)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest12 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest12(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/expected.txt b/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/maple.prof b/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..0d438ba0c4ab5b96885b70da5c9d58221461e056
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/test.cfg b/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5b1644f9189bef694f20ad9e104331e39bb5c6a2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0130-rt-compact-MethodGetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetDeclaredAnnotations)
+run(MethodGetDeclaredAnnotations)
diff --git a/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/MethodGetDefaultValue.java b/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/MethodGetDefaultValue.java
new file mode 100755
index 0000000000000000000000000000000000000000..2ecbb22ea12d3c54d3144f786fc315a1e7de119c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/MethodGetDefaultValue.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+public class MethodGetDefaultValue {
+    public static void main(String[] argv) {
+        int result = 2/* STATUS_FAILED*/
+;
+        try {
+            result = MethodGetDefaultValueTypeNotPresent_1();
+        } catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetDefaultValueTypeNotPresent_1() {
+        try {
+            Method m = MyTargetTest13.class.getMethod("MyTargetTest_1");
+            Object a = m.getDefaultValue();
+        } catch (TypeNotPresentException e) {
+            return 3;
+        } catch (NoSuchMethodException e) {
+            return 4;
+        }
+        return 0;
+    }
+    @Target(ElementType.TYPE)
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        Class style() default String.class;
+    }
+    @MyTarget()
+    class MyTargetTest13 {
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/expected.txt b/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/maple.prof b/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..4ee12d1e19e081e9266dda5d027d9d9b23885347
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/test.cfg b/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2e09141962b90f73494b56721539350fdcbc9bf8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0131-rt-compact-MethodgetDefaultValue/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetDefaultValue)
+run(MethodGetDefaultValue)
diff --git a/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/MethodGetParameterCount.java b/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/MethodGetParameterCount.java
new file mode 100755
index 0000000000000000000000000000000000000000..1c3095665c90f65735e8eb14880192a4b3e13de6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/MethodGetParameterCount.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodGetParameterCount {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetParameterCount1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetParameterCount1() {
+        Method m;
+        try {
+            m = MyTargetTest14.class.getMethod("MyTargetTest_1");
+            int num = m.getParameterCount();
+            if (num == 0) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest14 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest14(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/expected.txt b/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/maple.prof b/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..d3390d6203f6a2260aee46f637752014f1606cf9
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/test.cfg b/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6861c2480f7468521d78ebf2526df25aea62e9de
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0132-rt-compact-MethodGetParameterCount/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetParameterCount)
+run(MethodGetParameterCount)
diff --git a/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/MethodGetTypeParameters.java b/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/MethodGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..d3eae3bbf994db2e0e6a578f01c817b7f7538112
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/MethodGetTypeParameters.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.TypeVariable;
+public class MethodGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetTypeParameters1() {
+        Method m;
+        try {
+            m = MyTargetTest15.class.getMethod("MyTargetTest_1");
+            TypeVariable<Method>[] Target = m.getTypeParameters();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest15 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest15(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/expected.txt b/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/maple.prof b/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..7528ffafc33f2528f456ba445c9753d02e44f281
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/test.cfg b/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a9da6d2fc2dde49b4c682d84a8165cfdcfee7c34
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0133-rt-compact-MethodGetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetTypeParameters)
+run(MethodGetTypeParameters)
diff --git a/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/MethodIsDefault.java b/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/MethodIsDefault.java
new file mode 100755
index 0000000000000000000000000000000000000000..2d8d68adf456aa661980aff9a587b91fce760817
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/MethodIsDefault.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodIsDefault {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodIsDefault1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodIsDefault1() {
+        Method m;
+        try {
+            m = MyTargetTest16.class.getMethod("MyTargetTest_1");
+            boolean flag = m.isDefault();
+            if (!flag) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest16 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest16(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/expected.txt b/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/maple.prof b/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..55e20e6391474898464df9bc788db90cdec82861
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/test.cfg b/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c6f17112622ac86bb62b30f152bd060b487b6f0c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0134-rt-compact-MethodIsDefault/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodIsDefault)
+run(MethodIsDefault)
diff --git a/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/MethodToGenericString.java b/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/MethodToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..75deeb8479aae561216fbd2358b8bd11fd5c3960
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/MethodToGenericString.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodToGenericString1() {
+        Method m;
+        try {
+            m = MyTargetTest17.class.getMethod("MyTargetTest_1");
+            String str = m.toGenericString();
+            if ("public void MethodToGenericString$MyTargetTest17.MyTargetTest_1()".equals(str)) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest17 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest17(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/expected.txt b/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/maple.prof b/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..cd4d742fd63120f90ff1ba811721a71b3fb0bcf8
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/test.cfg b/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..db0eec92f99d634aabbfd135b03aec95afb3ef78
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0135-rt-compact-MethodToGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodToGenericString)
+run(MethodToGenericString)
diff --git a/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/ParameterGetAnnotation.java b/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/ParameterGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..d29e8dd576f404696f0cbbc7660ab13be3e1d9d6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/ParameterGetAnnotation.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetAnnotation {
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetAnnotation1() {
+        Method m;
+        try {
+            m = MyTargetTest18.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget Target = parameters[0].getAnnotation(MyTarget.class);
+            if ("@ParameterGetAnnotation$MyTarget(name=name1, value=value1)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest18 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+    }
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/expected.txt b/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/maple.prof b/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..cdd76b025b89fb793a953f8f6fa59be3e9ca35e1
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/test.cfg b/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8554f71699f7e6139e7044d524a89f9786360509
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0136-rt-compact-ParameterGetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetAnnotation)
+run(ParameterGetAnnotation)
diff --git a/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/ParameterGetAnnotations.java b/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/ParameterGetAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..15be545dcfe324fa51b18c33c804c0e98fe9bc20
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/ParameterGetAnnotations.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ParameterGetAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetAnnotations1() {
+        Method m;
+        try {
+            m = MyTargetTest19.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            Annotation[] Target = parameters[0].getAnnotations();
+            if ("@ParameterGetAnnotations$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest19 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest19(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/expected.txt b/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/maple.prof b/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..4cfecfef66425467dad382ffe1619c265b68d09d
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/test.cfg b/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f582e9e52295cb23bfaba1d197b4704e2cf999aa
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0137-rt-compact-ParameterGetAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetAnnotations)
+run(ParameterGetAnnotations)
diff --git a/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/ParameterGetAnnotationsByType.java b/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/ParameterGetAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..43feb6a2af6f7a878a6558d6de7162dc2100b8a2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/ParameterGetAnnotationsByType.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetAnnotationsByType1() {
+        Method m;
+        try {
+            m = MyTargetTest20.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget[] Target = parameters[0].getAnnotationsByType(MyTarget.class);
+            if ("@ParameterGetAnnotationsByType$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest20 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest20(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/expected.txt b/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/maple.prof b/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..03ade2daa7ca1be15f65931a5d286d7510c28825
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/test.cfg b/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7388addf17fc452d9d8ca87280919815794fe9e0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0138-rt-compact-ParameterGetAnnotationsByType/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetAnnotationsByType)
+run(ParameterGetAnnotationsByType)
diff --git a/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/ParameterGetDeclaredAnnotation.java b/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/ParameterGetDeclaredAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..7d4624f9dcb22b7432ac705f183b78ef252b268b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/ParameterGetDeclaredAnnotation.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetDeclaredAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetDeclaredAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetDeclaredAnnotation1() {
+        Method m;
+        try {
+            m = MyTargetTest21.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget Target = parameters[0].getDeclaredAnnotation(MyTarget.class);
+            if ("@ParameterGetDeclaredAnnotation$MyTarget(name=name1, value=value1)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest21 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest21(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/expected.txt b/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/maple.prof b/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..b6980d2f4d0174ac95abb718b68878b985e5441a
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/test.cfg b/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f2abad221b17a1f6bbe372c085c3b81c6fc97d69
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0139-rt-compact-ParameterGetDeclaredAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetDeclaredAnnotation)
+run(ParameterGetDeclaredAnnotation)
diff --git a/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/ParameterGetDeclaredAnnotations.java b/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/ParameterGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..01e226346d667fa0e3292e860f33e725dccafa9b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/ParameterGetDeclaredAnnotations.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetDeclaredAnnotations1() {
+        Method m;
+        try {
+            m = MyTargetTest22.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            Annotation[] Target = parameters[0].getDeclaredAnnotations();
+            if ("@ParameterGetDeclaredAnnotations$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest22 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest22(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/expected.txt b/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/maple.prof b/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..659d53fed6bbda4cc7f28e1340a96ebf6e1879e1
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/test.cfg b/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68fd03412f5a225a92ede3f516656ec435489d70
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0140-rt-compact-ParameterGetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetDeclaredAnnotations)
+run(ParameterGetDeclaredAnnotations)
diff --git a/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/ParameterGetDeclaredAnnotationsByType.java b/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/ParameterGetDeclaredAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..c9f930e1117158a4981754bad7f31b49be9f51f0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/ParameterGetDeclaredAnnotationsByType.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetDeclaredAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetDeclaredAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetDeclaredAnnotationsByType1() {
+        Method m;
+        try {
+            m = MyTargetTest23.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget[] Target = parameters[0].getDeclaredAnnotationsByType(MyTarget.class);
+            if ("@ParameterGetDeclaredAnnotationsByType$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest23 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest23(String home) {
+            this.home = home;
+        }
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/expected.txt b/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/maple.prof b/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..cc7520ea0ee4cdb1007e2fccdd7db8ce7c92e064
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/test.cfg b/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d994d2af026b54aa06adcfb1e5eec7a3dcd0c58
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0141-rt-compact-ParameterGetDeclaredAnnotationsByType/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetDeclaredAnnotationsByType)
+run(ParameterGetDeclaredAnnotationsByType)
diff --git a/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java b/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..4717e4dd38aaeb92c595d8b7caa51fddb47ca654
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.util.Arrays;
+public class ReflectionAnnotationGetClass {
+    public static void main(String[] args) {
+        int result = 2;
+        try{
+            // Check point 1 : only 1 annotation in user-defined Class Two.
+            Annotation[] annotations1 = Class.forName("Two").getAnnotations();
+            if (annotations1.length == 1){
+                if (annotations1[0].getClass().toString().startsWith("class $Proxy")) {
+                    result --;
+                }
+            }
+            // Check point 2 : 3 annotations in Class java.lang.annotation.Documented.
+            Annotation[] annotations2 = Class.forName("java.lang.annotation.Documented").getAnnotations();
+            String [] annoClazz = new String[annotations2.length];
+            for (int i = 0; i < annoClazz.length; i++) {
+                annoClazz[i] = annotations2[i].getClass().toString();
+            }
+            Arrays.sort(annoClazz);
+            if (annotations2.length == 3) {
+                if (annoClazz[0].startsWith("class $Proxy") && annoClazz[1]
+                        .startsWith("class $Proxy")
+                        && annoClazz[2].startsWith("class $Proxy")) {
+                    result --;
+                }
+            }
+        }catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+}
+@A0
+class Two{}
+@Retention(RetentionPolicy.RUNTIME) @interface A0 {}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/expected.txt b/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/maple.prof b/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..31693821f867d12610d3aa266aba45a4344d8307
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/test.cfg b/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4784ac8797c300c5f14036eb0ab3233022d4330d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0142-rt-compact-ReflectionAnnotationGetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionAnnotationGetClass)
+run(ReflectionAnnotationGetClass)
diff --git a/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/ClassInitClassNewInstance.java b/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/ClassInitClassNewInstance.java
new file mode 100755
index 0000000000000000000000000000000000000000..0cebf64695a4a76c80ce88f4f7daf58fec23bb26
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/ClassInitClassNewInstance.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+public class ClassInitClassNewInstance {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try{
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            /* Check point 1: no class initialization when calling following methods of Class
+             * not test clazz.cast(Object obj) because it success only when obj is an instance of One or Two,
+             * and need to call new One(), which result in Class initialization.*/
+
+            clazz.asSubclass(clazz);
+            clazz.desiredAssertionStatus();
+            clazz.getAnnotation(A.class);
+            clazz.getAnnotations();
+            clazz.getAnnotationsByType(A.class);
+            clazz.getCanonicalName();
+            clazz.getClasses();
+            clazz.getClassLoader();
+            clazz.getComponentType();
+            clazz.getConstructor(String.class);
+            clazz.getConstructors();
+            clazz.getDeclaredAnnotation(A.class);
+            clazz.getDeclaredAnnotations();
+            clazz.getDeclaredAnnotationsByType(A.class);
+            clazz.getDeclaredClasses();
+            clazz.getDeclaredConstructor(String.class);
+            clazz.getDeclaredConstructors();
+            clazz.getDeclaredField("what");
+            clazz.getDeclaredFields();
+            clazz.getDeclaredMethod("testOne", String.class);
+            clazz.getDeclaredMethods();
+            clazz.getDeclaringClass();
+            clazz.getEnclosingClass();
+            clazz.getEnclosingConstructor();
+            clazz.getEnclosingMethod();
+            clazz.getEnumConstants();
+            clazz.getField("hi");
+            clazz.getFields();
+            clazz.getGenericInterfaces();
+            clazz.getGenericSuperclass();
+            clazz.getInterfaces();
+            clazz.getMethod("testOne",String.class);
+            clazz.getMethods();
+            clazz.getModifiers();
+            clazz.getName();
+            clazz.getPackage();
+            clazz.getProtectionDomain();
+            clazz.getSigners();
+            clazz.getSimpleName();
+            clazz.getSuperclass();
+            clazz.getTypeName();
+            clazz.getTypeParameters();
+            clazz.isAnnotation();
+            clazz.isAnnotationPresent(A.class);
+            clazz.isAnonymousClass();
+            clazz.isArray();
+            clazz.isAssignableFrom(clazz);
+            clazz.isEnum();
+            clazz.isInstance(new Object());
+            clazz.isInterface();
+            clazz.isLocalClass();
+            clazz.isMemberClass();
+            clazz.isPrimitive();
+            clazz.isSynthetic();
+            clazz.toString();
+            clazz.toGenericString();
+            clazz.getResource("hi");
+            clazz.getResourceAsStream("hi");
+            // Check point 2: when call newInstance, start class initialization
+            if (result.toString().compareTo("") == 0) {
+                clazz.newInstance();
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitClassNewInstance.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitClassNewInstance.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitClassNewInstance.result.append("One");
+    }
+    String what = "lala";
+    public String hi = "";
+    One(){}
+    public One(String s){
+        what = s;
+        System.out.println(s);
+    }
+    public int testOne(String a){
+        System.out.println(a);
+        return 0;
+    }
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitClassNewInstance.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitClassNewInstance.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/expected.txt b/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/maple.prof b/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ab74fad4735046e305e394d5486aa7424f4daddd
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/test.cfg b/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..91b181ff9f3f736fafacb015666bc963ca6fb181
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0143-rt-compact-ClinitClassNewInstance/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitClassNewInstance)
+run(ClassInitClassNewInstance)
diff --git a/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java b/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java
new file mode 100755
index 0000000000000000000000000000000000000000..43188d985c6ab58e0c37ded17d66cd57a577817e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+public class ClassInitConstructorNewInstance {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Constructor constructor = clazz.getConstructor(String.class);
+            //check point 1: calling following methods, class not initialized
+            constructor.equals(constructor);
+            constructor.getAnnotation(A.class);
+            constructor.getDeclaredAnnotations();
+            constructor.getDeclaringClass();
+            constructor.getExceptionTypes();
+            constructor.getGenericExceptionTypes();
+            constructor.getGenericParameterTypes();
+            constructor.getModifiers();
+            constructor.getName();
+            constructor.getParameterAnnotations();
+            constructor.getParameterCount();
+            constructor.getParameterTypes();
+            constructor.hashCode();
+            constructor.isSynthetic();
+            constructor.isVarArgs();
+            constructor.toString();
+            constructor.toGenericString();
+            //check point 2: after call newInstance(), class initialized
+            if (result.toString().compareTo("") == 0) {
+                constructor.newInstance("newInstance");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitConstructorNewInstance.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitConstructorNewInstance.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitConstructorNewInstance.result.append("One");
+    }
+    String what = "lala";
+    One(){}
+    public One(String s){
+        what = s;
+    }
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitConstructorNewInstance.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitConstructorNewInstance.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/expected.txt b/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/maple.prof b/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..a2b01f6b43dbaa564b55e6a619e5bb954e2116cc
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/test.cfg b/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0fed7c57507044ba044125b0f252ea00cc4103aa
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0144-rt-compact-ClinitConstructorNewInstance/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitConstructorNewInstance)
+run(ClassInitConstructorNewInstance)
diff --git a/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java b/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..22859f3cb37183fc8555fe2c7eb686ca7b7a917c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetBooleanStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.getBoolean(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetBooleanStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("One");
+    }
+    public static boolean hiBoolean = false;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetBooleanStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/expected.txt b/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/maple.prof b/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..bdf0dcb8b451dc9bc954905a2ece47ce52bb59c5
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/test.cfg b/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c84bf6ec919619b1f76d1660cf13e0fca15613e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0145-rt-compact-ClinitFieldGetBooleanStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetBooleanStatic)
+run(ClassInitFieldGetBooleanStatic)
diff --git a/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java b/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..ee32596a5ad26e3d3c7ebde22ab652397226f83b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetByteStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.getByte(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetByteStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetByteStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetByteStatic.result.append("One");
+    }
+    public static byte hiByte = (byte)0;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetByteStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetByteStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/expected.txt b/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/maple.prof b/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..52104d1b2988a8b077a8dd87275b30774e0feb5b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/test.cfg b/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0de9ca38faba745f43622c2af342bff73a27b2f2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0146-rt-compact-ClinitFieldGetByteStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetByteStatic)
+run(ClassInitFieldGetByteStatic)
diff --git a/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java b/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..773e6fb668cc67dacda74bc6d8acf13c7845aaf2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetCharStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.getChar(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetCharStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetCharStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetCharStatic.result.append("One");
+    }
+    public static char hiChar = (char)45;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetCharStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetCharStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/expected.txt b/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/maple.prof b/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..8d507e96a53e0e8ca3f60d57039e6e501c7c7c9a
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/test.cfg b/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16ceb031ca56b781747385b666e3985a2470dc4d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0147-rt-compact-ClinitFieldGetCharStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetCharStatic)
+run(ClassInitFieldGetCharStatic)
diff --git a/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java b/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..7c3fd33b685d1c44bb5695db839ddf38cb5d94b0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetDoubleStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.getDouble(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetDoubleStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("One");
+    }
+    public static double hiDouble = 4.5;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetDoubleStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/expected.txt b/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/maple.prof b/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..84e88ad6756d015aea91f08ed92edd7e50763df9
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/test.cfg b/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e9e751d166058cc4ee776f993fff8dfa151f490c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0148-rt-compact-ClinitFieldGetDoubleStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetDoubleStatic)
+run(ClassInitFieldGetDoubleStatic)
diff --git a/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java b/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..bf25f361c715e3796989955d071653bfde338c8c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetFloatStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.getFloat(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetFloatStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("One");
+    }
+    public static float hiFloat = 0.25f;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetFloatStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/expected.txt b/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/maple.prof b/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..5457e15323328a2af64349508f3256544f2311af
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/test.cfg b/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4620d0f6aa51e1b3e02948f99e4b0354df3aad26
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0149-rt-compact-ClinitFieldGetFloatStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetFloatStatic)
+run(ClassInitFieldGetFloatStatic)
diff --git a/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java b/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..235d4b1fbc3a38e2227301d715716b3ce227dfbd
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetIntStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.getInt(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetIntStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetIntStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetIntStatic.result.append("One");
+    }
+    public static int hiInt = 0;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetIntStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetIntStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/expected.txt b/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/maple.prof b/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..22d956ee7716377cf6402e6702ae679596be87c6
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/test.cfg b/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7cdd9f9f975c60bf56017eda537b4748b1369ad0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0150-rt-compact-ClinitFieldGetIntStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetIntStatic)
+run(ClassInitFieldGetIntStatic)
diff --git a/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java b/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd0d9514caebd6bf678120db2db2d7db4394624d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetLongStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.getLong(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetLongStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetLongStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetLongStatic.result.append("One");
+    }
+    public static long hiLong = 4859l;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetLongStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetLongStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/expected.txt b/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/maple.prof b/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..a5e845268fd172dca84696fc6605b3f12bb3e0f9
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/test.cfg b/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd34e1a6d5f0f26a327ef02041138fa258c05840
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0151-rt-compact-ClinitFieldGetLongStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetLongStatic)
+run(ClassInitFieldGetLongStatic)
diff --git a/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java b/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..5329320a1f5ebd3f0049d6a6fc591ad22d917f58
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetShortStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.getShort(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetShortStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetShortStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetShortStatic.result.append("One");
+    }
+    public static short hiShort = 48;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetShortStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetShortStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/expected.txt b/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/maple.prof b/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..f181b24c76180624382eb30c3e5a0503cfe3f1be
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/test.cfg b/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..14b4d7892e3de3e0383ca6360ff3e4853c5442d5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0152-rt-compact-ClinitFieldGetShortStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetShortStatic)
+run(ClassInitFieldGetShortStatic)
diff --git a/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/ClassInitFieldGetStatic.java b/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/ClassInitFieldGetStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..819bfa169e26808d81670b8095020680e91af300
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/ClassInitFieldGetStatic.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        String fValue = "";
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                fValue = (String)f.get(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0 && fValue.compareTo("hi") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetStatic.result.append("One");
+    }
+    public static String hi = "hi";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/expected.txt b/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/maple.prof b/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..76a3877ba7a4348fb05dec49aa1384c1c4f5cc99
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/test.cfg b/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c040570d94a741207ae4f81f7a572fcb7aec176c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0153-rt-compact-ClinitFieldGetStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetStatic)
+run(ClassInitFieldGetStatic)
diff --git a/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java b/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java
new file mode 100755
index 0000000000000000000000000000000000000000..df55352820b73d755401811d1e2e38a99def6707
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldOtherMethod {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            f.equals(f);
+            f.getAnnotation(B.class);
+            f.getAnnotationsByType(B.class);
+            f.getDeclaredAnnotations();
+            f.getDeclaringClass();
+            f.getGenericType();
+            f.getModifiers();
+            f.getName();
+            f.getType();
+            f.hashCode();
+            f.isEnumConstant();
+            f.isSynthetic();
+            f.toGenericString();
+            f.toString();
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if(result.toString().compareTo("") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldOtherMethod.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldOtherMethod.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldOtherMethod.result.append("One");
+    }
+    @B("hello")
+    public static String hi = "value";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldOtherMethod.result.append("|InterfaceA|").toString();
+}
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@interface B{
+    String value() default "hi";
+}
+class Two extends One {
+    static {
+        ClassInitFieldOtherMethod.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/expected.txt b/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/maple.prof b/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..0d2d2d2980e4b97da46bd914447ac0202156498d
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/test.cfg b/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a47f119bb71d8635767ca8a9fa7b9c16779251ac
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0154-rt-compact-ClinitFieldOtherMethod/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldOtherMethod)
+run(ClassInitFieldOtherMethod)
diff --git a/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java b/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..508e9f0f0c51568b11576b47510274442c2e9def
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetBooleanStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.setBoolean(null, false);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetBooleanStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("One");
+    }
+    String what = "lala";
+    public static boolean hiBoolean = false;
+    One(){}
+    public One(String s){
+        what = s;
+        System.out.println(s);
+    }
+    public int testOne(String a){
+        System.out.println(a);
+        return 0;
+    }
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetBooleanStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/expected.txt b/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/maple.prof b/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..594cdfa2d24d54413aaf55cb05cd3f98aa8d8318
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/test.cfg b/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..af30a4c09ea374df1b5e929ff9cd52ca094ca76d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0155-rt-compact-ClinitFieldSetBooleanStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetBooleanStatic)
+run(ClassInitFieldSetBooleanStatic)
diff --git a/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java b/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..1223281b7d096e167515c4c496e67496e8ba9820
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetByteStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.setByte(null, (byte)1);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetByteStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetByteStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetByteStatic.result.append("One");
+    }
+    public static byte hiByte = (byte)0;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetByteStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetByteStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/expected.txt b/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/maple.prof b/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..0ee2cabb73e9105032568e4eaa46e989f23a484f
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/test.cfg b/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8caa52cbccca282d8f49bc2acc1173641e28ac56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0156-rt-compact-ClinitFieldSetByteStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetByteStatic)
+run(ClassInitFieldSetByteStatic)
diff --git a/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java b/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..2063f11bad479e8ecc775f03d83221973a713d5b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetCharStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.setChar(null, (char)1);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetCharStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetCharStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetCharStatic.result.append("One");
+    }
+    public static char hiChar = (char)45;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetCharStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetCharStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/expected.txt b/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/maple.prof b/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb275c3e1af5b2ea02f59e4c7caf8629fec7b5
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/test.cfg b/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65c9d60e7681d912286d61bc6d530f3358f061da
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0157-rt-compact-ClinitFieldSetCharStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetCharStatic)
+run(ClassInitFieldSetCharStatic)
diff --git a/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java b/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..a41a577099b6269475a56dcdede923ced70bc629
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetDoubleStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.setDouble(null, 0.2589);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetDoubleStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("One");
+    }
+    public static double hiDouble = 4.5;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetDoubleStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/expected.txt b/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/maple.prof b/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..f29a113b91fbacb7fd26ea0a050f21a6527bb5bf
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/test.cfg b/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16f3434b4ed66e617b4a8c639fe92ee0fa9cb5fc
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0158-rt-compact-ClinitFieldSetDoubleStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetDoubleStatic)
+run(ClassInitFieldSetDoubleStatic)
diff --git a/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java b/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..89101036bc7eae5998d05bcedd0311bea7c20940
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetFloatStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.setFloat(null, 0.2589f);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetFloatStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("One");
+    }
+    public static float hiFloat = 0.25f;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetFloatStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/expected.txt b/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/maple.prof b/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..fc1c2cdf27c79eb0843f7c1bca82f6c60a4d7a1b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/test.cfg b/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35973a71ce353e05a42effbbbda64bbc9afb40b4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0159-rt-compact-ClinitFieldSetFloatStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetFloatStatic)
+run(ClassInitFieldSetFloatStatic)
diff --git a/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java b/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..28c8dce2017371a6f9aecb71e16de89be751dc0c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetIntStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.setInt(null, 25);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetIntStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetIntStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetIntStatic.result.append("One");
+    }
+    public static int hiInt = 0;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetIntStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetIntStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/expected.txt b/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/maple.prof b/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..54b270055f4f6024697914b92445c2a19e4cc331
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/test.cfg b/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e89ccd9fcedd1789e8358bca5803c89d3b026f10
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0160-rt-compact-ClinitFieldSetIntStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetIntStatic)
+run(ClassInitFieldSetIntStatic)
diff --git a/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java b/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..b91898581c835c128011fbf980030c6290865583
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetLongStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.setLong(null, 25l);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetLongStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetLongStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetLongStatic.result.append("One");
+    }
+    public static long hiLong = 4859l;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetLongStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetLongStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/expected.txt b/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/maple.prof b/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..c3aca0e10b09ed707d697d9f33c85dd14dd51c83
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/test.cfg b/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3678b49933e6674fb6e53732aea55d6681731451
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0161-rt-compact-ClinitFieldSetLongStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetLongStatic)
+run(ClassInitFieldSetLongStatic)
diff --git a/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java b/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f90973512f88927a2b20647c3efd360583afbfb
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetShortStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.setShort(null, (short)25);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetShortStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetShortStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetShortStatic.result.append("One");
+    }
+    public static short hiShort = 48;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetShortStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetShortStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/expected.txt b/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/maple.prof b/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..451e795c411f2cf01bc0f60fb105251a0d4969cc
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/test.cfg b/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..80d1f7ef311072296e75eb014a29089d8393521c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0162-rt-compact-ClinitFieldSetShortStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetShortStatic)
+run(ClassInitFieldSetShortStatic)
diff --git a/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/ClassInitFieldSetStatic.java b/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/ClassInitFieldSetStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..11407e69bb17c706dc416fbf491c67a570777e7e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/ClassInitFieldSetStatic.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.set(null, "what");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetStatic.result.append("One");
+    }
+    public static String hi = "hi";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/expected.txt b/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/maple.prof b/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..2b27332d72e603c2f9be28270b7fdfdc15f698fa
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/test.cfg b/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..820a7ecaf10a554e54d67e6c99e2112211ab76d8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0163-rt-compact-ClinitFieldSetStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetStatic)
+run(ClassInitFieldSetStatic)
diff --git a/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java b/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..56b013962bce7e95bc27d59e9ab171310095fb54
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+public class ClassInitMethodInvokeStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Method m = clazz.getDeclaredMethod("testOne", String.class);
+            // Check point 1: calling following methods, class not initialized.
+            m.equals(m);
+            m.getAnnotation(A.class);
+            m.getDeclaredAnnotations();
+            m.getDeclaringClass();
+            m.getDefaultValue();
+            m.getExceptionTypes();
+            m.getGenericExceptionTypes();
+            m.getGenericParameterTypes();
+            m.getGenericReturnType();
+            m.getModifiers();
+            m.getName();
+            m.getParameterAnnotations();
+            m.getParameterCount();
+            m.getParameterTypes();
+            m.getReturnType();
+            m.getTypeParameters();
+            m.hashCode();
+            m.isBridge();
+            m.isDefault();
+            m.isSynthetic();
+            m.isVarArgs();
+            m.toString();
+            m.toGenericString();
+            // Check point 2: after newInstance, class initialized.
+            if (result.toString().compareTo("") == 0) {
+                m.invoke(null, "hi");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitMethodInvokeStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitMethodInvokeStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitMethodInvokeStatic.result.append("One");
+    }
+    public static int testOne(String a){
+        return 0;
+    }
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitMethodInvokeStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitMethodInvokeStatic.result.append("Two");
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/expected.txt b/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/maple.prof b/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..e7f2a82b283dc49a43f0c044e1615de79a0b2451
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/test.cfg b/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4466c393970b01470cd5f88be576d6cbaed0d98e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0164-rt-compact-ClinitMethodInvokeStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitMethodInvokeStatic)
+run(ClassInitMethodInvokeStatic)
diff --git a/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java b/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..52bb177ed5fe44f1ed48d1d4788e6bf149547abd
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetBooleanInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.getBoolean(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetBooleanInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetBooleanInterface.result.append("One").toString();
+    boolean hiBoolean = false;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetBooleanInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetBooleanInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/expected.txt b/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/maple.prof b/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..738d92b88054332b9f2dc9b19fe365611b801128
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/test.cfg b/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f13798e6abfd9ee418095d894e64bf65520d7304
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0165-rt-compact-ClinitFieldGetBooleanInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetBooleanInterface)
+run(ClassInitFieldGetBooleanInterface)
diff --git a/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java b/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..ab9a8fb4e4935d77ea4f7b72d5ed2e0da0688f22
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetByteInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.getByte(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetByteInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetByteInterface.result.append("One").toString();
+    byte hiByte = (byte)1;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetByteInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetByteInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/expected.txt b/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/maple.prof b/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..e811b56ac8e431cb446f4f34e85e5effd9885a05
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/test.cfg b/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0d0e8742d65e4bb00ebd26557dc3ba6e26d5040f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0166-rt-compact-ClinitFieldGetByteInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetByteInterface)
+run(ClassInitFieldGetByteInterface)
diff --git a/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java b/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..e676411c9569942bf28312214c2fb9d5aef8cb13
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetCharInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.getChar(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetCharInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetCharInterface.result.append("One").toString();
+    char hiChar = (char)45;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetCharInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetCharInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/expected.txt b/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/maple.prof b/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..fe354ed637d305aad97babd1fba141fd317eade6
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/test.cfg b/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6231c9e9b97a065ceb61fdf7fda327ff300407d1
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0167-rt-compact-ClinitFieldGetCharInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetCharInterface)
+run(ClassInitFieldGetCharInterface)
diff --git a/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java b/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..d4e17c4d41882052b243008baef8a25bf764e13f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetDoubleInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.getDouble(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetDoubleInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetDoubleInterface.result.append("One").toString();
+    double hiDouble = 0.1532;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetDoubleInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetDoubleInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/expected.txt b/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/maple.prof b/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..c9fa68a8c7617a1d8b94e653a856c9d4570610e3
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/test.cfg b/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5365c21066c8a89e10357fd17fb719506af14d12
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0168-rt-compact-ClinitFieldGetDoubleInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetDoubleInterface)
+run(ClassInitFieldGetDoubleInterface)
diff --git a/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java b/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..9822ef1d728aac8efcd0166b6104e614ca8ee778
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetFloatInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.getFloat(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetFloatInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetFloatInterface.result.append("One").toString();
+    float hiFloat = 0.25f;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetFloatInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetFloatInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/expected.txt b/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/maple.prof b/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..086fbf8f9ba15b096712a448ff6f2cc5e79bd59f
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/test.cfg b/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bae327b7366c60e40eb7d2c83ddfc3d8c773a75b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0169-rt-compact-ClinitFieldGetFloatInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetFloatInterface)
+run(ClassInitFieldGetFloatInterface)
diff --git a/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/ClassInitFieldGetInterface.java b/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/ClassInitFieldGetInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..03b692a3bf91ffcf6a68597e616c35000dbcb2fd
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/ClassInitFieldGetInterface.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.get(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetInterface.result.append("One").toString();
+    String hi = "hiField";
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/expected.txt b/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/maple.prof b/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..5f03bddbb01e3a4d32c366670c46f31e4dadb8f7
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/test.cfg b/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3b28d6ef59371fc8c267c39e4741bab96febcb81
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0170-rt-compact-ClinitFieldGetInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetInterface)
+run(ClassInitFieldGetInterface)
diff --git a/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java b/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..b62d582a229462110083228bf6eeb35899515acf
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetIntInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.getInt(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetIntInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetIntInterface.result.append("One").toString();
+    int hiInt = 125;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetIntInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetIntInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/expected.txt b/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/maple.prof b/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..115e270885d6d455632c9e54714dac61fd373aea
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/test.cfg b/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1575a30fdfe1ee788fa0949a9bd53e9bc51c9a7d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0171-rt-compact-ClinitFieldGetIntInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetIntInterface)
+run(ClassInitFieldGetIntInterface)
diff --git a/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java b/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..10374aff55406ae75bc661de436da26d51996539
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetLongInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.getLong(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetLongInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetLongInterface.result.append("One").toString();
+    long hiLong = 4859l;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetLongInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetLongInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/expected.txt b/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/maple.prof b/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..e80a274ac9770849cc1a09960c328a79af6cf307
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/test.cfg b/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d9724c00a8da921fa881bfac7a15407686cf0ea2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0172-rt-compact-ClinitFieldGetLongInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetLongInterface)
+run(ClassInitFieldGetLongInterface)
diff --git a/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java b/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..e781980e191f96ac66edc44b2bbc9eb77a636ffb
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetShortInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.getShort(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetShortInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetShortInterface.result.append("One").toString();
+    short hiShort = 14;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetShortInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetShortInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/expected.txt b/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/maple.prof b/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..d777cbda119bdda66d74df796b285348711a52f2
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/test.cfg b/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e571f4ebcf7a1422cf7cc375dce793eb31481945
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0173-rt-compact-ClinitFieldGetShortInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetShortInterface)
+run(ClassInitFieldGetShortInterface)
diff --git a/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java b/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..fa3d881a8df0db4a9fac96824d56733775ea1ae2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldOtherMethodInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            f.equals(f);
+            f.getAnnotation(A.class);
+            f.getAnnotationsByType(A.class);
+            f.getDeclaredAnnotations();
+            f.getDeclaringClass();
+            f.getGenericType();
+            f.getModifiers();
+            f.getName();
+            f.getType();
+            f.hashCode();
+            f.isEnumConstant();
+            f.isSynthetic();
+            f.toGenericString();
+            f.toString();
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if(result.toString().compareTo("") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldOtherMethodInterface.result.append("Super").toString();
+}
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldOtherMethodInterface.result.append("One").toString();
+    @A
+    short hi = 14;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldOtherMethodInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldOtherMethodInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/expected.txt b/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/maple.prof b/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..fa247c97c257a0391181aac3bc05dcc3da73350e
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/test.cfg b/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ae6f283fe1ea44a4742fdf87081fba0928275d90
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0174-rt-compact-ClinitFieldOtherMethodInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldOtherMethodInterface)
+run(ClassInitFieldOtherMethodInterface)
diff --git a/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java b/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..75c21a2cb5f60ae9d9848c267c0406612a8cf03e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetBooleanInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.setBoolean(null, true);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetBooleanInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetBooleanInterface.result.append("One").toString();
+    boolean hiBoolean = false;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetBooleanInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetBooleanInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/expected.txt b/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/maple.prof b/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..6eedb8817e29294e89f45a5b13b32c172bff1830
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/test.cfg b/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a26eb0d13e6aa5db5d8f3c72ef237e3eb7284f69
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0175-rt-compact-ClinitFieldSetBooleanInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetBooleanInterface)
+run(ClassInitFieldSetBooleanInterface)
diff --git a/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java b/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..d79a20b195087acdaca4d67bcfe692dca857228b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetByteInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.setByte(null, (byte)0);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetByteInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetByteInterface.result.append("One").toString();
+    byte hiByte = (byte)1;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetByteInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetByteInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/expected.txt b/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/maple.prof b/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..36824c084dd45fe4c73433aed279daaff554dd2e
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/test.cfg b/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68d2181359ae204544f244ce5c226b2aa8e5bafe
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0176-rt-compact-ClinitFieldSetByteInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetByteInterface)
+run(ClassInitFieldSetByteInterface)
diff --git a/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java b/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..24dd6cf65ca4cd138ad1c7ff180985f69395192b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetFloatInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.setFloat(null, 0.654f);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetFloatInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetFloatInterface.result.append("One").toString();
+    float hiFloat = 0.25f;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetFloatInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetFloatInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/expected.txt b/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/maple.prof b/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..e0738f89b3fc6c3e240f12e908c40f8446d12506
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/test.cfg b/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..39f4ed2d2fdbdeb1c1e210c1f9e076842180521d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0177-rt-compact-ClinitFieldSetFloatInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetFloatInterface)
+run(ClassInitFieldSetFloatInterface)
diff --git a/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/ClassInitFieldSetInterface.java b/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/ClassInitFieldSetInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..d3a2c2d5cf6633b6ed4ba3ae5a3f0d879a1caf61
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/ClassInitFieldSetInterface.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.set(null, "newString");
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetInterface.result.append("One").toString();
+    String hi = "hiField";
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/expected.txt b/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/maple.prof b/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ca7ab9c5d6bfe28709f89b4e6b1f394ccc39736b
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/test.cfg b/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0009d5a0b7daafd84f536ca7fae33071a716e061
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0178-rt-compact-ClinitFieldSetInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetInterface)
+run(ClassInitFieldSetInterface)
diff --git a/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java b/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..3d41dbdaa7ca9452431ad025ffe20a5c92ba5bf5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetIntInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.setInt(null, 98);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetIntInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetIntInterface.result.append("One").toString();
+    int hiInt = 125;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetIntInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetIntInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/expected.txt b/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/maple.prof b/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..a7784e399729d698bdd8965d1a3b7f603df958bf
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/test.cfg b/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6ff549308b6fa94bda271d2d8a335f7e6bcb6e36
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0179-rt-compact-ClinitFieldSetIntInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetIntInterface)
+run(ClassInitFieldSetIntInterface)
diff --git a/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java b/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..62ca4b007746cc226dccbeabea43f4912bdc0dc5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetLongInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.setLong(null, 7456l);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetLongInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetLongInterface.result.append("One").toString();
+    long hiLong = 4859l;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetLongInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetLongInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/expected.txt b/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/maple.prof b/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..b377bffc689254d4b104c6faec7e059397d023e7
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/test.cfg b/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e1b4cf8ab67072f3044abc9370fd1b3e55617d9
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0180-rt-compact-ClinitFieldSetLongInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetLongInterface)
+run(ClassInitFieldSetLongInterface)
diff --git a/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java b/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..7a2949b124f3ae6bd325a92116bd2cbd42082051
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetShortInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.setShort(null, (short)124);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetShortInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetShortInterface.result.append("One").toString();
+    short hiShort = 14;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetShortInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetShortInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/expected.txt b/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/maple.prof b/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..6d8d8dd0fb5300d392f0eab1a5f4f2cdd0b68fdf
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/test.cfg b/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2bb37a45a1ce8e0c32116cb0b3faec0560003a11
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0181-rt-compact-ClinitFieldSetShortInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetShortInterface)
+run(ClassInitFieldSetShortInterface)
diff --git a/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java b/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..95f3596dcee61fa113912d76b0f779f050187df7
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class ClassInitMethodInvokeInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Method m = clazz.getDeclaredMethod("runInterface", String.class);
+            //check point 1: calling following methods, class not initialized
+            m.equals(m);
+            m.getAnnotation(A.class);
+            m.getDeclaredAnnotations();
+            m.getDeclaringClass();
+            m.getDefaultValue();
+            m.getExceptionTypes();
+            m.getGenericExceptionTypes();
+            m.getGenericParameterTypes();
+            m.getGenericReturnType();
+            m.getModifiers();
+            m.getName();
+            m.getParameterAnnotations();
+            m.getParameterCount();
+            m.getParameterTypes();
+            m.getReturnType();
+            m.getTypeParameters();
+            m.hashCode();
+            m.isBridge();
+            m.isDefault();
+            m.isSynthetic();
+            m.isVarArgs();
+            m.toString();
+            m.toGenericString();
+            //check point 2: after newInstance, class initialized
+            if (result.toString().compareTo("") == 0) {
+                m.invoke(null, "hi");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneRunInterface") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitMethodInvokeInterface.result.append("Super").toString();
+}
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitMethodInvokeInterface.result.append("One").toString();
+    @A
+    static void runInterface(String a){
+        ClassInitMethodInvokeInterface.result.append("RunInterface");
+    }
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitMethodInvokeInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitMethodInvokeInterface.result.append("Annotation").toString();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/expected.txt b/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/maple.prof b/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..a481097f6a8e96a40b120bbbc50dd13b6b84bb99
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/test.cfg b/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a9af44cc4bf47ec4d25885ddfb4d58e78956a8b2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0182-rt-compact-ClinitMethodInvokeInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitMethodInvokeInterface)
+run(ClassInitMethodInvokeInterface)
diff --git a/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/FieldMultiThreadTest.java b/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/FieldMultiThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..1c4a71bf0cfcfcbca79061503ed90dcf5184d837
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/FieldMultiThreadTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldMultiThreadTest {
+    volatile static boolean keepRunning = true;
+    static int passCnt = 0;
+    static int executeCnt = 0;
+    public static void main(String[] args) {
+        try {
+            fieldMultithread();
+            System.out.println(passCnt/executeCnt - 10);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+    private static int fieldMultithread() throws Exception {
+        Class clazz = Class.forName("TestMultiThread");
+        String[] allFields = new String[] {"charPub", "fieldIntPri", "fieldIntPro", "fieldString"};
+        Thread writer = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (String s : allFields) {
+                        Field field = clazz.getDeclaredField(s);
+                        field.setAccessible(true);
+                    }
+                    for (Field f: clazz.getDeclaredFields()) {
+                        f.setAccessible(true);
+                    }
+                    Field field = clazz.getField("charPub");
+                    field.setAccessible(true);
+                    for (Field f: clazz.getFields()) {
+                        f.setAccessible(true);
+                    }
+                }
+            } catch (Exception e) {
+                System.out.println(e);
+            }
+        });
+        Thread reader = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (String s : allFields) {
+                        Field field = clazz.getDeclaredField(s);
+                        passCnt += field.isAccessible()== false ? 1 : 0;
+                    }
+                    for (Field f: clazz.getDeclaredFields()) {
+                        passCnt += f.isAccessible()== false ? 1 : 0;
+                    }
+                    Field field = clazz.getField("charPub");
+                    passCnt += field.isAccessible()== false ? 1 : 0;
+                    for (Field f: clazz.getFields()) {
+                        passCnt += f.isAccessible()== false ? 1 : 0;
+                    }
+                    executeCnt++;
+                }
+            } catch (Exception e) {
+                System.out.println(e);
+            }
+        });
+        writer.start();
+        reader.start();
+        Thread.sleep(100);
+        keepRunning = false;
+        Thread.sleep(100);
+        writer.join();
+        reader.join();
+        return passCnt;
+    }
+}
+class TestMultiThread {
+    public char charPub = 'a';
+    private int fieldIntPri = 416;
+    protected int[] fieldIntPro = {123};
+    String fieldString = "hey, hello";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/expected.txt b/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/maple.prof b/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..aaefced92d2cbc274ef79ffc3f30c40b59c512cd
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/test.cfg b/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..58d2a6fd3e56d8d428a1d702f266d8bc8ab6ea55
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0183-rt-compact-FieldMultiThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldMultiThreadTest)
+run(FieldMultiThreadTest)
diff --git a/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/MethodTest.java b/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/MethodTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..020bf5dac705259bd9b01e82fa157e35c6dcfc4f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/MethodTest.java
@@ -0,0 +1,346 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+public class MethodTest {
+    /**
+     * Verify that for the same method, different Method object is return when call following API twice:
+     * - Class.getMethods(),
+     * - Class.getEnclosingMethod(),
+     * - Class.getDeclaredMethods(),
+     * - Class.getMethod(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredMethod(String name, Class<?>... parameterTypes),
+     * if any Method failed the check, will print error message including testcase and method name;
+     * after all check is pass, casePassed will be increased;
+    */
+
+    private static void classAllMethodTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getMethods()
+        Method[] methods1 = clazz.getMethods();
+        Method[] methods2 = clazz.getMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 2. Class.getMethod(String name)
+            Method m1 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed");
+            }
+        }
+        // checkpoint 3. Class.getDeclaredMethods()
+        methods1 = clazz.getDeclaredMethods();
+        methods2 = clazz.getDeclaredMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 4. Class.getDeclaredMethod(String name)
+            Method m1 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for declared method");
+            }
+        }
+        // checkpoint 5. Class.getEnclosingMethod()
+        if (clazz.getEnclosingMethod() != null) {
+            Method m1 = clazz.getEnclosingMethod();
+            Method m2 = clazz.getEnclosingMethod();
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for Enclosing method");
+            }
+        }
+        casesPassed++;
+    }
+    private static void checkMethods(Method[] methods1, Method[] methods2) {
+        for (Method m1: methods1) {
+            for (Method m2: methods2) {
+                // only when modifers and class and name is same, two Method object is for same method
+                if(m1.toString().equals(m2.toString())) {
+                    if (singleMethodCheck(m1, m2) != 3) {
+                        System.out.println(m1.getName()+" failed in checkMethods");
+                    }
+                }
+            }
+        }
+    }
+    private static int singleMethodCheck(Method m1, Method m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    static int casesPassed = 0;
+    public static void main(String [] args) {
+        method01();
+        method02();
+        method03();
+        method04();
+        method05();
+        method06();
+        method07();
+        method08();
+        method09();
+        method10();
+        method11();
+        System.out.println(casesPassed - 11);
+    }
+
+    private static void method01() {
+        try {
+            classAllMethodTest(Class.forName("java.lang.Thread"), "method01");
+        } catch (Exception e) {
+            System.out.println("Case method01 failed with exception" + e);
+        }
+    }
+
+    private static void method02() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod02"), "method02");
+        } catch (Exception e) {
+            System.out.println("Case method02 failed with exception" + e);
+        }
+    }
+
+    private static void method03() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod03"), "method03");
+        } catch (Exception e) {
+            System.out.println("Case method03 failed with exception" + e);
+        }
+    }
+
+    private static void method04() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod04"), "method04");
+        } catch (Exception e) {
+            System.out.println("Case method04 failed with exception" + e);
+        }
+    }
+
+    private static void method05() {
+        try {
+            // step 1
+            Class clazz = Class.forName("MethodTest");
+            MethodTest mainClass = new MethodTest();
+            Field method = clazz.getDeclaredField("testMethod05");
+            classAllMethodTest(method.get(mainClass).getClass(), "method05");
+        } catch (Exception e) {
+            System.out.println("Case method05 failed with exception" + e);
+        }
+    }
+    private Runnable testMethod05 = new Runnable() {
+        private final synchronized int intRunnable() {
+            return 1;
+        }
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    private static void method06() {
+        class TestMethod06 {
+            private final int intLocalMethod() {
+                return 9;
+            }
+            public synchronized String stringLocal() {
+                return "a fake behind the fear";
+            }
+        }
+        try {
+            classAllMethodTest(Class.forName("MethodTest$1TestMethod06"), "method06");
+        } catch (Exception e) {
+            System.out.println("Case method06 failed with exception" + e);
+        }
+    }
+
+    private static void method07() {
+        try {
+            classAllMethodTest(Class.forName("MethodTest$TestMethod07"), "method07");
+        } catch (Exception e) {
+            System.out.println("Case method07 failed with exception" + e);
+        }
+    }
+    class TestMethod07 {
+        private char charInnerMethod(int a, double... b) {
+            return 'l';
+        }
+        final public double doubleInnerMethod() {
+            return 1988.0416;
+        }
+    }
+
+    private static void method08() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod08"), "method08");
+        } catch (Exception e) {
+            System.out.println("Case method08 failed with exception" + e);
+        }
+    }
+
+    private static void method09() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod09"), "method09");
+        } catch (Exception e) {
+            System.out.println("Case method09 failed with exception" + e);
+        }
+    }
+
+    private static void method10() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod10"), "method10");
+        } catch (Exception e) {
+            System.out.println("Case method10 failed with exception" + e);
+        }
+    }
+
+    private static void method11() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod11"), "method11");
+        } catch (Exception e) {
+            System.out.println("Case method11 failed with exception" + e);
+        }
+    }
+}
+class TestMethod02 {
+    // step1
+    void voidMethod() {}
+    boolean booleanMethod() {
+        return true;
+    }
+    byte byteMethod() {
+        return (byte)1;
+    }
+    short shortMethod() {
+        return (short)2;
+    }
+    int intMethod() {
+        return 3;
+    }
+    long longMethod() {
+        return 4l;
+    }
+    char charMethod() {
+        return 'a';
+    }
+    float floatMethod() {
+        return 0.9f;
+    }
+    double doubleMethod() {
+        return 0.416;
+    }
+    String stringMethod() {
+        return "The queerest of the queer";
+    }
+    Runnable[] rArrayMethod() {
+        return null;
+    }
+    boolean[][][][][][][] booleanArray7Method() {
+        return new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    }
+    String[][][] stringArray3Method() {
+        return new String[][][] {{{"the strangest of the strange"}}};
+    }
+    int parameterMethod(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                        boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                        String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+        return 1;
+    }
+    // step2
+    public int publicIntMethod(boolean a) {
+        return 88;
+    }
+    protected double protectedDoubleMethod(byte a) {
+        return 99;
+    }
+    private String privateStringMethod(String a) {
+        return "the coldest of the cool";
+    }
+    // step3
+    strictfp double[][] transientDoubleArrayMethod(float[][] a) {
+        return new double[][] {{1988, 4.16}};
+    }
+    final int finalIntMethod() {
+        return 9876;
+    }
+    synchronized String volatileStringMethod() {
+        return "the lamest of the lame";
+    }
+    static Character staticCharacterMethod(Thread.State a) {
+        return 'd';
+    }
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotationMethod() {
+        return new String[][] {{"the numbest of the dumb"}};
+    }
+}
+interface TestMethod03 {
+    String stringInterfaceMethod(int[] a);
+    char[][][] charArrayInterfaceMethod(double... a);
+}
+abstract class TestMethod04 {
+    public static final synchronized String[] stringsAbstractArrayMethod() {
+        return new String[] {"i hate to see you here", "you choke behind a smile"};
+    }
+    abstract Runnable runnableAbstractMethod();
+}
+enum TestMethod08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnumMethod() {
+        return (short)6;
+    }
+    public final String stringEnumMethod(int... a) {
+        return "Dry Martini";
+    }
+}
+class TestMethod09 {
+    public int int09Method() {
+        return 1;
+    }
+    protected boolean boolean09Method() {
+        return false;
+    }
+    char[] chars09Method() {
+        return new char[] {'a', 'b', 'c'};
+    }
+    private String string09Method() {
+        return "I'm only happy when it rains";
+    }
+}
+class TestMethod10 extends TestMethod09 implements TestMethod11 {
+    public boolean boolean09Method() {
+        return true;
+    }
+    public double double10Method() {
+        return 0.416;
+    }
+    public char[] chars09Method() {
+        return new char[] {'a'};
+    }
+    public String string09Method() {
+        return "SHALALALA";
+    }
+}
+interface TestMethod11 {
+    int int09Method();
+    boolean boolean09Method();
+    char[] chars09Method();
+    String string09Method();
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/expected.txt b/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/maple.prof b/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..773fd5f0662b3bf45ff217942250818c733ba05f
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/test.cfg b/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..aa8bf99c4867fb93b0d709a4546853c164b163ae
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0184-rt-compact-MethodTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodTest)
+run(MethodTest)
diff --git a/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/MethodMultiThreadTest.java b/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/MethodMultiThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..203a6f1510813a0e76ef2c167729bd7351b4d342
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/MethodMultiThreadTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodMultiThreadTest {
+    volatile static boolean keepRunning = true;
+    static int passCnt = 0;
+    static int executeCnt = 0;
+    public static void main(String[] args) {
+        try {
+            methodMultithread();
+            System.out.println(passCnt/executeCnt - 28);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+    private static int methodMultithread() throws Exception {
+        Class clazz = Class.forName("TestMultiThreadM");
+        Thread writer = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Method m: clazz.getDeclaredMethods()) {
+                        m.setAccessible(true);
+                        Method method = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+                        method.setAccessible(true);
+                    }
+                    for (Method m: clazz.getMethods()) {
+                        m.setAccessible(true);
+                        Method method = clazz.getMethod(m.getName(), m.getParameterTypes());
+                        method.setAccessible(true);
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+        Thread reader = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Method m: clazz.getDeclaredMethods()) {
+                        passCnt += m.isAccessible()== false ? 1 : 0;
+                        Method method = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+                        passCnt += method.isAccessible()== false ? 1 : 0;
+                    }
+                    for (Method m: clazz.getMethods()) {
+                        passCnt += m.isAccessible()== false ? 1 : 0;
+                        Method method = clazz.getMethod(m.getName(), m.getParameterTypes());
+                        passCnt += method.isAccessible()== false ? 1 : 0;
+                    }
+                    executeCnt++;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+        writer.start();
+        reader.start();
+        Thread.sleep(100);
+        keepRunning = false;
+        Thread.sleep(100);
+        writer.join();
+        reader.join();
+        return passCnt;
+    }
+}
+class TestMultiThreadM {
+    public char charPubMethod(int... a) {
+        return 'a';
+    }
+    private int intPriMethod() {
+        return 416;
+    }
+    protected int[] intProMethod(Double... b) {
+        return new int[] {123};
+    }
+    String stringMethod() {
+        return "hey, hello";
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/expected.txt b/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/maple.prof b/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..e41d19f9a11af20f5e2bbf5ef5bbe79c0d209339
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/test.cfg b/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6c8c5ec8970d136358e86a25df6ff0bec2635c67
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0185-rt-compact-MethodMultiThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodMultiThreadTest)
+run(MethodMultiThreadTest)
diff --git a/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/ConstructorTest.java b/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/ConstructorTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..293d509f55e6573a2ddf40082faae8ad497a5b0a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/ConstructorTest.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Constructor;
+public class ConstructorTest {
+    /**
+     * Verify that for the same constructor, different Constructor object is return when call following API twice:
+     * - Class.getConstructors(),
+     * - Class.getEnclosingConstructor(),
+     * - Class.getDeclaredConstructors(),
+     * - Class.getConstructor(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredConstructor(String name, Class<?>... parameterTypes),
+     * if any Constructor failed the check, will print error message including testcase and constructor name;
+     * after all check is pass, casePassed will be increased;
+    */
+
+    private static void classAllConstructorTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getConstructors()
+        Constructor[] constructors1 = clazz.getConstructors();
+        Constructor[] constructors2 = clazz.getConstructors();
+        checkConstructors(constructors1, constructors2);
+        for (Constructor c : constructors1) {
+            // checkpoint 2. Class.getConstructor(String name)
+            Constructor c1 = clazz.getConstructor(c.getParameterTypes());
+            Constructor c2 = clazz.getConstructor(c.getParameterTypes());
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed");
+            }
+        }
+        // checkpoint 3. Class.getDeclaredConstructors()
+        constructors1 = clazz.getDeclaredConstructors();
+        constructors2 = clazz.getDeclaredConstructors();
+        checkConstructors(constructors1, constructors2);
+        for (Constructor c : constructors1) {
+            // checkpoint 4. Class.getDeclaredConstructor(String name)
+            Constructor c1 = clazz.getDeclaredConstructor(c.getParameterTypes());
+            Constructor c2 = clazz.getDeclaredConstructor(c.getParameterTypes());
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed for declared constructor");
+            }
+        }
+        // checkpoint 5. Class.getEnclosingConstructor()
+        if (clazz.getEnclosingConstructor() != null) {
+            Constructor c1 = clazz.getEnclosingConstructor();
+            Constructor c2 = clazz.getEnclosingConstructor();
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed for Enclosing constructor");
+            }
+        }
+        casesPassed++;
+    }
+    private static void checkConstructors(Constructor[] constructors1, Constructor[] constructors2) {
+        for (Constructor c1: constructors1) {
+            for (Constructor c2: constructors2) {
+                // only when modifers and class and name is same, two Constructor object is for same constructor
+                if(c1.toString().equals(c2.toString())) {
+                    if (singleConstructorCheck(c1, c2) != 3) {
+                        System.out.println(c1.getName()+" failed in checkConstructors");
+                    }
+                }
+            }
+        }
+    }
+    private static int singleConstructorCheck(Constructor c1, Constructor c2) {
+        int passCnt = 0;
+        passCnt += c1 == c2 ? 0 : 1;
+        passCnt += c1.equals(c2) ? 1 : 0;
+        passCnt += c1.hashCode() == c2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    static int casesPassed = 0;
+    public static void main(String [] args) {
+        constructor01();
+        constructor02();
+        constructor03();
+        constructor04();
+        constructor05();
+        constructor06();
+        constructor07();
+        constructor08();
+        constructor09();
+        constructor10();
+        constructor11();
+        System.out.println(casesPassed - 11);
+    }
+
+    private static void constructor01() {
+        try {
+            classAllConstructorTest(Class.forName("java.lang.Thread"), "constructor01");
+        } catch (Exception e) {
+            System.out.println("Case constructor01 failed with exception" + e);
+        }
+    }
+
+    private static void constructor02() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor02"), "constructor02");
+        } catch (Exception e) {
+            System.out.println("Case constructor02 failed with exception" + e);
+        }
+    }
+
+    private static void constructor03() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor03"), "constructor03");
+        } catch (Exception e) {
+            System.out.println("Case constructor03 failed with exception" + e);
+        }
+    }
+
+    private static void constructor04() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor04"), "constructor04");
+        } catch (Exception e) {
+            System.out.println("Case constructor04 failed with exception" + e);
+        }
+    }
+
+    private static void constructor05() {
+        try {
+            Class clazz = Class.forName("ConstructorTest");
+            ConstructorTest mainClass = new ConstructorTest();
+            Field constructor = clazz.getDeclaredField("testConstructor05");
+            classAllConstructorTest(constructor.get(mainClass).getClass(), "constructor05");
+        } catch (Exception e) {
+            System.out.println("Case constructor05 failed with exception" + e);
+        }
+    }
+    private Runnable testConstructor05 = new Runnable() {
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    private static void constructor06() {
+        class TestConstructor06 {
+            private TestConstructor06(int a) {
+            }
+            public TestConstructor06(String[][][] a) {
+            }
+        }
+        try {
+            classAllConstructorTest(Class.forName("ConstructorTest$1TestConstructor06"), "constructor06");
+        } catch (Exception e) {
+            System.out.println("Case constructor06 failed with exception" + e);
+        }
+    }
+
+    private static void constructor07() {
+        try {
+            classAllConstructorTest(Class.forName("ConstructorTest$TestConstructor07"), "constructor07");
+        } catch (Exception e) {
+            System.out.println("Case constructor07 failed with exception" + e);
+        }
+    }
+    class TestConstructor07 {
+        private TestConstructor07(int a, double... b) {
+        }
+        public TestConstructor07() {
+        }
+    }
+
+    private static void constructor08() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor08"), "constructor08");
+        } catch (Exception e) {
+            System.out.println("Case constructor08 failed with exception" + e);
+        }
+    }
+
+    private static void constructor09() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor09"), "constructor09");
+        } catch (Exception e) {
+            System.out.println("Case constructor09 failed with exception" + e);
+        }
+    }
+
+    private static void constructor10() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor10"), "constructor10");
+        } catch (Exception e) {
+            System.out.println("Case constructor10 failed with exception" + e);
+        }
+    }
+
+    private static void constructor11() {
+        try {
+            Class clazz = (new TestConstructor11()).c.getClass();
+            classAllConstructorTest(clazz, "constructor11");
+        } catch (Exception e) {
+            System.out.println("Case constructor11 failed with exception" + e);
+        }
+    }
+}
+class TestConstructor02 {
+    // step1
+    TestConstructor02() {
+    }
+    TestConstructor02(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                      boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                      String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+    }
+    // step2
+    public TestConstructor02(int a) {}
+    TestConstructor02(byte a) {}
+    protected TestConstructor02(String a) {}
+    private TestConstructor02(Runnable[] a) {}
+    // step3
+    @Deprecated
+    TestConstructor02(int... a) {}
+}
+strictfp class TestConstructor03 {
+    public TestConstructor03(float... a) {
+    }
+    TestConstructor03(float a, double b) {
+    }
+}
+abstract class TestConstructor04 {
+    public TestConstructor04() {
+    }
+    TestConstructor04(int a) {
+    }
+}
+enum TestConstructor08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    TestConstructor08() {
+    }
+    TestConstructor08(String a) {
+    }
+}
+class TestConstructor09 {
+    public TestConstructor09() {
+    }
+    TestConstructor09(int... a) {
+    }
+    protected TestConstructor09(double[] a) {
+    }
+    private TestConstructor09(int a) {
+    }
+}
+class TestConstructor10 extends TestConstructor09 {
+    public TestConstructor10() {
+    }
+    TestConstructor10(int... a) {
+    }
+    protected TestConstructor10(double[] a) {
+    }
+    private TestConstructor10(int a) {
+    }
+}
+class TestConstructor11 {
+    public Object c;
+    public TestConstructor11( ) {
+        class ClassA { }
+        c = new ClassA( );
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/expected.txt b/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/maple.prof b/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..33a2e3fb511aaba51692f5742a294bed45354382
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/test.cfg b/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b219b5e0811527d5de8a06099a013320d37c9836
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0186-rt-compact-ConstructorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorTest)
+run(ConstructorTest)
diff --git a/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/ConstructorMultiThreadTest.java b/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/ConstructorMultiThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f69eac02fc39b9ee86d759095f9f9d1cb5d94ac
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/ConstructorMultiThreadTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+public class ConstructorMultiThreadTest {
+    volatile static boolean keepRunning = true;
+    static int passCnt = 0;
+    static int executeCnt = 0;
+    public static void main(String[] args) {
+        try {
+            constructorMultithread();
+            System.out.println(passCnt/executeCnt - 10);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+    private static int constructorMultithread() throws Exception {
+        Class clazz = Class.forName("TestMultiThreadC");
+        Thread writer = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Constructor c: clazz.getDeclaredConstructors()) {
+                        c.setAccessible(true);
+                        Constructor constructor = clazz.getDeclaredConstructor(c.getParameterTypes());
+                        constructor.setAccessible(true);
+                    }
+                    for (Constructor c: clazz.getConstructors()) {
+                        c.setAccessible(true);
+                        Constructor constructor = clazz.getConstructor(c.getParameterTypes());
+                        constructor.setAccessible(true);
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+        Thread reader = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Constructor c: clazz.getDeclaredConstructors()) {
+                        passCnt += c.isAccessible()== false ? 1 : 0;
+                        Constructor constructor = clazz.getDeclaredConstructor(c.getParameterTypes());
+                        passCnt += constructor.isAccessible()== false ? 1 : 0;
+                    }
+                    for (Constructor c: clazz.getConstructors()) {
+                        passCnt += c.isAccessible()== false ? 1 : 0;
+                        Constructor constructor = clazz.getConstructor(c.getParameterTypes());
+                        passCnt += constructor.isAccessible()== false ? 1 : 0;
+                    }
+                    executeCnt++;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+        writer.start();
+        reader.start();
+        Thread.sleep(100);
+        keepRunning = false;
+        Thread.sleep(100);
+        writer.join();
+        reader.join();
+        return passCnt;
+    }
+}
+class TestMultiThreadC {
+    public TestMultiThreadC(int... a) {
+    }
+    private TestMultiThreadC(String a) {
+    }
+    protected TestMultiThreadC(Double... a) {
+    }
+    TestMultiThreadC() {
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/expected.txt b/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/maple.prof b/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..3000b900c1d80fcf013bec4b66e48ffa06409cfc
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/test.cfg b/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a4130034c429f0fdb598ad72e7009135a644a4f4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0187-rt-compact-ConstructorMultiThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorMultiThreadTest)
+run(ConstructorMultiThreadTest)
diff --git a/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java b/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c01d422c908c56ac948702c6981bd9e3e5c52755
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import static java.lang.invoke.MethodHandles.lookup;
+import static java.lang.invoke.MethodHandles.reflectAs;
+import static java.lang.invoke.MethodType.methodType;
+public class MethodHandleReflectCombineTest {
+    static int passCnt = 0;
+    private static <T extends Member> int singleMethodCheck(T m1, T m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    public static void main(String[] args) {
+        try {
+            System.out.println(run());
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+    private static int run() throws Throwable {
+        Object[][] testData = new Object[][] {
+            {Member.class, lookup().findVirtual(String.class, "concat", methodType(String.class, String.class))},
+            {Member.class, lookup().findStatic(String.class, "copyValueOf", methodType(String.class, char[].class))},
+            {Member.class, RATest.LOOKUP().findSpecial(RATest.class, "mhVar", methodType(int.class, Object[].class), RATest.class)},
+            {Constructor.class, lookup().findConstructor(RATest.class, methodType(void.class, int.class))},
+            {Constructor.class, lookup().findConstructor(RATest.class, methodType(void.class, double[].class))},
+            {Field.class, lookup().findStaticGetter(RATest.class, "svi", int.class)},
+            {Field.class, lookup().findStaticSetter(RATest.class, "svi", int.class)},
+            {Field.class, RATest.LOOKUP().findGetter(RATest.class, "vd", double.class)},
+            {Field.class, lookup().findGetter(RATest.class, "vs", String[].class)},
+            {Field.class, lookup().findSetter(RATest.class, "vs", String[].class)}
+        };
+        for (int i = 0; i<testData.length; i++) {
+            passCnt += singleMethodCheck(reflectAs((Class)testData[i][0], (MethodHandle) testData[i][1]), reflectAs((Class)testData[i][0], (MethodHandle) testData[i][1])) == 3 ? 1 : 0;
+        }
+        Constructor privC = Class.forName("RATest").getDeclaredConstructor();
+        privC.setAccessible(true);
+        MethodHandle raCon = lookup().unreflectConstructor(privC);
+        passCnt += singleMethodCheck(privC, reflectAs( Constructor.class, raCon))==3 ? 1 : 0;
+        return passCnt - 11;
+    }
+}
+class RATest {
+    public static MethodHandles.Lookup LOOKUP() {
+        return lookup();
+    }
+    static public double count = 0;
+    protected static int svi = 333;
+    private double vd = 136;
+    String[] vs = {"hi"};
+    RATest(int i) {
+        count = i;
+    }
+    public RATest(double[] i) {
+        count = i.length;
+    }
+    private RATest() {
+        count = -1;
+    }
+    private int mhVar(Object... a) {
+        return a.length;
+    }
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/expected.txt b/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/maple.prof b/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..674e75595384c41e5f883e290495ff4ab4025cf5
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/test.cfg b/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..baf8c24b3b0fc5e7929c3699a0396205be726a8f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0188-rt-compact-MethodHandleReflectCombineTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodHandleReflectCombineTest)
+run(MethodHandleReflectCombineTest)
diff --git a/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/FieldTest.java b/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/FieldTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..14a54590232e99226cc3401a4160ed8fedb3aaf4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/FieldTest.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldTest {
+    /**
+     * Verify that for the same field, different Field object is return when call following API twice:
+     * - Class.getFields()
+     * - Class.getDeclaredFields()
+     * - Class.getField(String name)
+     * - Class.getDeclareedField(String name)
+     * if any Field failed the check, will print error message including testcase and field name;
+     * after all check is pass, casePassed will be increased;
+    */
+
+    private static void classAllFieldTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getFields()
+        Field[] fields1 = clazz.getFields();
+        Field[] fields2 = clazz.getFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 2. Class.getDeclaredFields()
+            Field f1 = clazz.getField(f.getName());
+            Field f2 = clazz.getField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed");
+            }
+        }
+        // checkpoint 3. Class.getField(String name)
+        fields1 = clazz.getDeclaredFields();
+        fields2 = clazz.getDeclaredFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 4. Class.getDeclareedField(String name)
+            Field f1 = clazz.getDeclaredField(f.getName());
+            Field f2 = clazz.getDeclaredField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed for declared fields");
+            }
+        }
+        casesPassed++;
+    }
+    private static void checkFields(Field[] fields1, Field[] fields2) {
+        for (Field f1: fields1) {
+            for (Field f2: fields2) {
+                // only when modifers and class and name is same, two Field object is for same field
+                if(f1.toGenericString().equals(f2.toGenericString())) {
+                    if (singleFieldCheck(f1, f2) != 3) {
+                        System.out.println(f1.getName()+" failed in checkFields");
+                    }
+                }
+            }
+        }
+    }
+    private static int singleFieldCheck(Field f1, Field f2) {
+        int passCnt = 0;
+        passCnt += f1 == f2 ? 0 : 1;
+        passCnt += f1.equals(f2) ? 1 : 0;
+        passCnt += f1.hashCode() == f2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    static int casesPassed = 0;
+    public static void main(String [] args) {
+        field01();
+        field02();
+        field03();
+        field04();
+        field05();
+        field06();
+        field07();
+        field08();
+        field09();
+        field10();
+        field11();
+        field12();
+        System.out.println(casesPassed - 12);
+    }
+
+    private static void field01() {
+        try {
+            classAllFieldTest(Class.forName("java.lang.Thread"), "field01");
+        } catch (Exception e) {
+            System.out.println("Case field01 failed with exception" + e);
+        }
+    }
+
+    private static void field02() {
+        try {
+            classAllFieldTest(Class.forName("TestField02"), "field02");
+        } catch (Exception e) {
+            System.out.println("Case field02 failed with exception" + e);
+        }
+    }
+
+    private static void field03() {
+        try {
+            classAllFieldTest(Class.forName("TestField03"), "field03");
+        } catch (Exception e) {
+            System.out.println("Case field03 failed with exception" + e);
+        }
+    }
+
+    private static void field04() {
+        try {
+            classAllFieldTest(Class.forName("TestField04"), "field04");
+        } catch (Exception e) {
+            System.out.println("Case field04 failed with exception" + e);
+        }
+    }
+
+    private static void field05() {
+        try {
+            classAllFieldTest(Class.forName("TestField05"), "field05");
+        } catch (Exception e) {
+            System.out.println("Case field05 failed with exception" + e);
+        }
+    }
+
+    private static void field06() {
+        try {
+            // step 1
+            Class clazz = Class.forName("FieldTest");
+            FieldTest mainClass = new FieldTest();
+            Field field = clazz.getDeclaredField("testField06");
+            classAllFieldTest(field.get(mainClass).getClass(), "field06");
+        } catch (Exception e) {
+            System.out.println("Case field06 failed with exception" + e);
+        }
+    }
+    private Runnable testField06 = new Runnable() {
+        int intAnonymous = 10;
+        public double doubleAnonymous = 1988.416;
+        @Override
+        public void run() {
+            for (int i = 0; i < intAnonymous; i++) {
+                intAnonymous += i;
+            }
+        }
+    };
+
+    private static void field07() {
+        class TestField07 {
+            private final transient int intLocal = 9;
+            public volatile String stringLocal = "a fake behind the fear";
+        }
+        try {
+            classAllFieldTest(Class.forName("FieldTest$1TestField07"), "field07");
+        } catch (Exception e) {
+            System.out.println("Case field07 failed with exception" + e);
+        }
+    }
+
+    private static void field08() {
+        try {
+            classAllFieldTest(Class.forName("FieldTest$TestField08"), "field08");
+        } catch (Exception e) {
+            System.out.println("Case field08 failed with exception" + e);
+        }
+    }
+    class TestField08 {
+        volatile private char charInner = 'l';
+        public final static transient double doubleInner = 0.88;
+    }
+
+    private static void field09() {
+        try {
+            classAllFieldTest(Class.forName("TestField09"), "field09");
+        } catch (Exception e) {
+            System.out.println("Case field09 failed with exception" + e);
+        }
+    }
+
+    private static void field10() {
+        try {
+            classAllFieldTest(Class.forName("TestField10"), "field10");
+        } catch (Exception e) {
+            System.out.println("Case field10 failed with exception" + e);
+        }
+    }
+
+    private static void field11() {
+        try {
+            classAllFieldTest(Class.forName("TestField11"), "field11");
+        } catch (Exception e) {
+            System.out.println("Case field11 failed with exception" + e);
+        }
+    }
+
+    private static void field12() {
+        try {
+            classAllFieldTest(Class.forName("TestField12"), "field12");
+        } catch (Exception e) {
+            System.out.println("Case field12 failed with exception" + e);
+        }
+    }
+}
+class TestField02 {
+    // step1
+    boolean booleanField = true;
+    byte byteField = (byte)2;
+    short shortField = (short)4;
+    int intField = 6;
+    long longField = 8;
+    char charField = 10;
+    float floatField = 0.4f;
+    double doubleField = 0.8;
+    String stringField = "The queerest of the queer";
+    Runnable r = null;
+    boolean[][][][][][][] booleanArray7 = new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    String[][][] stringArray3 = new String[][][] {{{"the strangest of the strange"}}};
+    // step2
+    public int publicInt = 88;
+    protected double protectedDouble = 99;
+    private String privateString = "the coldest of the cool";
+    // step3
+    transient double[][] transientDoubleArray = new double[][] {{1988, 4.16}};
+    final int finalInt = 9876;
+    volatile String volatileString = "the lamest of the lame";
+    static Character staticCharacter = 'd';
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotation = new String[][] {{"the numbest of the dumb"}};
+}
+strictfp class TestField03 {
+    float floatField = 4.16f;
+    public double doubleField = 19.88;
+}
+interface TestField04 {
+    String stringInterface = "i know what's good for you";
+    char[] charInterface = new char[] {'l', 'e', 't'};
+}
+abstract class TestField05 {
+    String[] stringsAbstractArray = {"i hate to see you here", "you choke behind a smile"};
+    Runnable[] runnableAbstractArray = {new Runnable() {
+            @Override
+            public void run() {
+            }
+        }
+    };
+}
+enum TestField09 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnum = (short)6;
+    public final String stringEnum = "Dry Martini";
+}
+class TestField10 {
+    public int int10;
+    protected boolean boolean10;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    private String string10 = "I'm only happy when it rains";
+}
+class TestField11 extends TestField10 implements TestField12 {
+    boolean boolean10 = true;
+    public double double11 = 0.416;
+}
+interface TestField12 {
+    int int10 = 9;
+    boolean boolean10 = false;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    String string10 = "I'm only happy when it rains";
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/expected.txt b/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/maple.prof b/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..70058bf0f85092b1150e23053cd32dd11e8bab6a
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/test.cfg b/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ec3f12a923126e4b93fb41a72a53faaff0d137a1
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0189-rt-compact-FieldTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldTest)
+run(FieldTest)
diff --git a/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnotationTypeSetTest.java b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnotationTypeSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..d1be1ee23c81668faa7b14617bb0c9fc7760c0a2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/AnnotationTypeSetTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeSetTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+class Test{
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/expected.txt b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/maple.prof b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..7b3f0d5a169a203c2ddb7f38d75c918e8262e4a8
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/test.cfg b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8ea5008fce368287bdb16089a1867d80a13fa794
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0190-rt-compact-AnnotationTypeSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeSetTest)
+run(AnnotationTypeSetTest)
diff --git a/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnotationTypeInterfaceSetTest.java b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnotationTypeInterfaceSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..4a2097ca17f1412ade23ad607b5a613319731ba0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/AnnotationTypeInterfaceSetTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeInterfaceSetTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+interface Test{
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/expected.txt b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/maple.prof b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..d3d4828f5ee8ed5dff0ad5235a322a06590b2d6c
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/test.cfg b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6b32e873b414967370df1b01aa0f2106ea68592a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0191-rt-compact-AnnotationTypeInterfaceSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeInterfaceSetTest)
+run(AnnotationTypeInterfaceSetTest)
diff --git a/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnotationTypeEnumSetTest.java b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnotationTypeEnumSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b1d1f42ab38e5d3e3d3072c3dae7a55a0292bbd0
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/AnnotationTypeEnumSetTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeEnumSetTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+enum Test{
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/expected.txt b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/maple.prof b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ddc2388ab795a518a17d689049647beabd09f354
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/test.cfg b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ee4cdfc20d21f089b6047692f139fab83cdcb42b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0192-rt-compact-AnnotationTypeEnumSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeEnumSetTest)
+run(AnnotationTypeEnumSetTest)
diff --git a/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..614f2371bbeaf23b65039b3d59d70baf177a4ea2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnotationFieldSetTest.java b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnotationFieldSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..9b3dc1a2445554e8d17f63544e9fdbc89618ec29
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/AnnotationFieldSetTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationFieldSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchFieldException {
+        AnnoA anno = Test.class.getDeclaredField("a").getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    String a;
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/expected.txt b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/maple.prof b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..11b0b5e980f29024cb41f47a4b4e4f09826c05f3
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/test.cfg b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4dc898cb309c6f3cacc1906f934c8dcc2fc7e98c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0193-rt-compact-AnnotationFieldSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationFieldSetTest)
+run(AnnotationFieldSetTest)
diff --git a/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..614f2371bbeaf23b65039b3d59d70baf177a4ea2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnotationStaticFieldSetTest.java b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnotationStaticFieldSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d2da079f0961de969c0787e0ca6af889a30202c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/AnnotationStaticFieldSetTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationStaticFieldSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchFieldException {
+        AnnoA anno = Test.class.getDeclaredField("a").getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    private static int[] a;
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/expected.txt b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/maple.prof b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..e8225c97f27400180043827cf14224c2c1d0ca51
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/test.cfg b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50f69044c8556d1542458239cfd76ed14c981750
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0194-rt-compact-AnnotationStaticFieldSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationStaticFieldSetTest)
+run(AnnotationStaticFieldSetTest)
diff --git a/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..c98e2c01ccecf2600dfe57f57c78b9e1aaeaad49
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnotationMethodSetTest.java b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnotationMethodSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..70f12f8d7516af649691eef80e92c12a79d5d3a6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/AnnotationMethodSetTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationMethodSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchMethodException {
+        AnnoA anno = Test.class.getDeclaredMethod("a").getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // arrays
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    private Thread.State[] a(){
+        return new Thread.State[]{};
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/expected.txt b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/maple.prof b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..83e2810ca5ff39438d822298cc8d02c741c28855
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/test.cfg b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..61341eb20d657afc2afe463acdb6f1884a60c7cb
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0195-rt-compact-AnnotationMethodSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationMethodSetTest)
+run(AnnotationMethodSetTest)
diff --git a/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..12b3d7209f62d594b70c2ef4513da23de3efdd9f
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnotationParameterSetTest.java b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnotationParameterSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..44cf7036036cb1a79772a4f1e825329ed740cd3a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/AnnotationParameterSetTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationParameterSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchMethodException {
+//        System.out.println(Test.class.getDeclaredMethod("a"));
+        AnnoA anno = (AnnoA) Test.class.getDeclaredMethod("a", Object[].class).getParameterAnnotations()[0][0];
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    private Thread.State[] a(@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) Object... aaa){
+        return new Thread.State[]{};
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/expected.txt b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/maple.prof b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..0af0af4e2801d4e07d60689ddb51aa531b1425c8
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/test.cfg b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6275cf89e424906deba258479f8c0aea1cb829c5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0196-rt-compact-AnnotationParameterSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationParameterSetTest)
+run(AnnotationParameterSetTest)
diff --git a/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..19269167aff51739e573b950db0253dc59e213c2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnotationConstructorSetTest.java b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnotationConstructorSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..9c3c1f90debe424a99ecb503cd8583d967ba8d5e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/AnnotationConstructorSetTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationConstructorSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchMethodException {
+//        System.out.println(Test.class.getDeclaredMethod("a"));
+        AnnoA anno = Test.class.getDeclaredConstructor(Object[].class).getDeclaredAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    Test(Object... aaa){
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/expected.txt b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/maple.prof b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..493744b250221f5eac586855918f5b9ba9594314
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/test.cfg b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d5a9e85d95e56d7c521deaa9232123eb8900c5dd
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0197-rt-compact-AnnotationConstructorSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationConstructorSetTest)
+run(AnnotationConstructorSetTest)
diff --git a/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..945eba1f83594c4b9e07b6dce5fe009a9ed5426d
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..bf518f610518fcb606b9ff58471235f978594fa8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnoB.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnotationAnnotationTypeSetTest.java b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnotationAnnotationTypeSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..2ed5922ea16d43fe8b477298c6d8ba0413b3d4d6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/AnnotationAnnotationTypeSetTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationAnnotationTypeSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        AnnoA anno = AnnoB.class.getDeclaredAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/expected.txt b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/maple.prof b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..8312e36f8a60b644f5599f52bfdd7527472fecb9
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/test.cfg b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cb99dab576754a54961ea3da7cd1d2c381bba592
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0198-rt-compact-AnnotationAnnotationTypeSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationAnnotationTypeSetTest)
+run(AnnotationAnnotationTypeSetTest)
diff --git a/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/Run.java b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/Run.java
new file mode 100755
index 0000000000000000000000000000000000000000..67287b007efa51b07a2b5da40bd055166306d152
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/Run.java
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
diff --git a/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoA.java b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..f9e0aa843b412b552fefe037de229df9bf18b8ef
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoA.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+package com.huawei;
+import com.huawei.AnnoB;
+import java.lang.annotation.*;
+@Target(ElementType.PACKAGE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoB.java b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..caad060f5bfd03b07219bea689246e26a02446ea
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnoB.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+package com.huawei;
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnotationPackageSetTest.java b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnotationPackageSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..9165389c6806bbdb7ca17e56a0b57f9dab7ccdfd
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/AnnotationPackageSetTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+package com.huawei;
+import java.util.Arrays;
+public class AnnotationPackageSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        Package packageInfo = Package.getPackage("com.huawei");
+        AnnoA anno = packageInfo.getDeclaredAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@com.huawei.AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@com.huawei.AnnoB(intB=999), @com.huawei.AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java package-info.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java package-info.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/package-info.java b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/package-info.java
new file mode 100755
index 0000000000000000000000000000000000000000..6fecb28ff09adb5e73d399015808339a1feeca26
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/com/huawei/package-info.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+package com.huawei;
+class PackageInfo{
+    public void say(){
+        System.out.println("hello");
+    }
+}
+class PackageInfoGeneric<T extends Throwable>{
+    private T obj;
+    public void setObj(T obj) {
+        this.obj = obj;
+    }
+    public void say(){
+        System.out.println("hello "+obj);
+    }
+}
+interface PackageInfoInterface {
+    void test();
+}
+class PackageInfoConst {
+    public static final String MESSAGE="Annotation Study";
+}
diff --git a/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/expected.txt b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/maple.prof b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..36e3cbf01de54ee248146595c824dc35ae92cfed
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/test.cfg b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..443b58b1a819d0291bb34f5198d6afca7ad6d8af
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0199-rt-compact-AnnotationPackageSetTest/test.cfg
@@ -0,0 +1,5 @@
+javac com/huawei/*.java
+jar -cvf com.huawei.AnnotationPackageSetTest.jar com/
+${OUT_ROOT}/target/product/public/bin/jar2dex -p ${OUT_ROOT}/target/product/public/third-party/JAVA_LIBRARIES/core-oj_intermediates/classes.jar:${OUT_ROOT}/target/product/public/third-party/JAVA_LIBRARIES/core-libart_intermediates/classes.jar:${OUT_ROOT}/target/product/public/third-party/JAVA_LIBRARIES/framework_intermediates/classes.jar:${OUT_ROOT}/target/product/public/third-party/JAVA_LIBRARIES/services_intermediates/classes.jar -i com.huawei.AnnotationPackageSetTest.jar
+compile(com.huawei.AnnotationPackageSetTest)
+run(com.huawei.AnnotationPackageSetTest)
diff --git a/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f06bbbee2c53d37e325643d7aad8d49273e72e7
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE_PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..2b56b10bf3c4d823730b99c7eb7e864c84ea8066
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Arrays;
+public class AnnotationTypeParameterSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        System.out.println(Test.class.getAnnotations().length);
+//      TypeVeriable.getAnnotation not supported in ART
+/*      AnnoA anno = Test.class.getTypeParameters()[0].getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));*/
+    }
+}
+class Test<@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) T> {
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/expected.txt b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/maple.prof b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..2f268376b5074906587a000d126c46dbdd735a68
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/test.cfg b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..91858c287691e1809a305f3e6ff1261427c46223
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0200-rt-compact-AnnotationTypeParameterSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeParameterSetTest)
+run(AnnotationTypeParameterSetTest)
diff --git a/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoA.java b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..2104c625abbc58059295356101ddb20286205228
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE_USE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoB.java b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..d22082df949761952d83b6beaac2cabd77d5d808
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeUseSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        System.out.println(Test.class.getAnnotations().length);
+/*        AnnoA anno = Test.class.getTypeParameters()[0].getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));*/
+    }
+}
+class Test<@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) T> {
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/expected.txt b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/maple.prof b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ba3e4d6d6ed34252e61d2116b43de86470b95565
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/test.cfg b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..32e449eb780f2b69be5acb1f25cc093f5bb90fc8
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0201-rt-compact-AnnotationTypeUseSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeUseSetTest)
+run(AnnotationTypeUseSetTest)
diff --git a/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoA.java b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..bd35de2ef9e511bcbbe9ee4c21c20725314de948
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoA.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA() default Integer.MAX_VALUE;
+    double doubleA() default Double.MIN_VALUE;
+    String stringA() default "";
+    AnnoB annoBA();
+    ENUMA enumA() default ENUMA.A;
+}
diff --git a/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoB.java b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoC.java b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoC.java
new file mode 100755
index 0000000000000000000000000000000000000000..cbf9e24cbbebe37e60dd66f776a237c46fded798
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoC.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoC {
+    int[] intA() default Integer.MAX_VALUE;
+    double[] doubleA() default Double.MIN_VALUE;
+    String[] stringA() default "";
+    AnnoB[] annoBA() default @AnnoB;
+    ENUMA[] enumA() default ENUMA.A;
+}
diff --git a/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoD.java b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoD.java
new file mode 100755
index 0000000000000000000000000000000000000000..e15b5d4c2881118deef1cd9bef9303abc3959410
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnoD.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoD {
+    int intA() default Integer.MAX_VALUE;
+    double doubleA() default Double.MIN_VALUE;
+    String stringA() default "";
+    AnnoB annoBA();
+    ENUMA enumA() default ENUMA.A;
+}
diff --git a/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnotationMultiThread.java b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnotationMultiThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..a7fb8eb6ae4e1d5de6ebfe32a4c0a7e06bb486ec
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/AnnotationMultiThread.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.Annotation;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicInteger;
+public class AnnotationMultiThread {
+    static AtomicInteger passCnt = new AtomicInteger();
+    public static void main(String[] args) throws ClassNotFoundException {
+        ThreadGroup threadGroup = new ThreadGroup("myGroup");
+        String[][] expectedGF = new String[][]{
+                {"@AnnoA", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+                {"@AnnoB(intB=999)"},
+                {"@AnnoC", "annoBA=[@AnnoB(intB=999)]", "intA=[2147483647]", "enumA=[A]", "stringA=[]", "doubleA=[4.9E-324]"}
+        };
+        String[][] expectedF = new String[][]{
+                {"@AnnoA", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+                {"@AnnoB(intB=999)"},
+                {"@AnnoC", "annoBA=[@AnnoB(intB=999)]", "intA=[2147483647]", "enumA=[A]", "stringA=[]", "doubleA=[4.9E-324]"},
+                {"@AnnoD", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+        };
+        new AnnotationGetter("GrandFather", expectedGF, expectedGF, threadGroup, "threadGF").start();
+        new AnnotationGetter("Father", expectedF, expectedF, threadGroup, "threadF").start();
+        new AnnotationGetter("Interface", expectedF, expectedF, threadGroup, "threadI").start();
+        new AnnotationGetter("Son", expectedF, new String[][]{}, threadGroup, "threadS").start();
+        new AnnotationGetter("Son2", expectedF, new String[][]{}, threadGroup, "threadS2").start();
+        new AnnotationGetter("GrandFather", expectedGF, expectedGF, threadGroup, "threadGF").start();
+        new AnnotationGetter("Father", expectedF, expectedF, threadGroup, "threadF").start();
+        new AnnotationGetter("Interface", expectedF, expectedF, threadGroup, "threadI").start();
+        new AnnotationGetter("Son", expectedF, new String[][]{}, threadGroup, "threadI").start();
+        new AnnotationGetter("Son2", expectedF, new String[][]{}, threadGroup, "threadI").start();
+        int i = 0;
+        while (threadGroup.activeCount() > 0){
+            i++;
+            try {
+                Thread.sleep(100);
+            }catch (InterruptedException e){
+                System.out.println(e);
+            }
+            if(i > 1000){
+                break;
+            }
+        }
+        System.out.println(passCnt.get() - 200);
+    }
+    public static boolean checkAllAnnotations(Annotation[] annotations, String[][] expected){
+        String[] actual = new String[annotations.length];
+        for (int i = 0; i < annotations.length; i++){
+            actual[i] = annotations[i].toString();
+        }
+        Arrays.sort(actual);
+        if (actual.length != expected.length){
+            return false;
+        }
+//        System.out.println(Arrays.toString(actual));
+        for (int i = 0; i < annotations.length; i++){
+            if (expected[i].length == 1){
+                if (actual[i].compareTo(expected[i][0])!=0){
+                    System.out.println(actual[i]);
+                    System.out.println(expected[i][0]);
+                    return false;
+                }
+            }else {
+                for (int j = 0; j < expected[i].length; j++){
+                    if (!actual[i].contains(expected[i][j])){
+                        System.out.println(actual[i]);
+                        System.out.println(expected[i][j]);
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+}
+class AnnotationGetter extends Thread{
+    String name;
+    String[][] expected;
+    String[][] expectedD;
+    AnnotationGetter(String nameI, String[][] expectedI, String[][] expectedDI, ThreadGroup threadGroup, String thread_name){
+        super(threadGroup, thread_name);
+        name = nameI;
+        expected = expectedI;
+        expectedD = expectedDI;
+    }
+    @Override
+    public void run() {
+        try {
+            for (int i = 0; i < 10; i++) {
+                if (AnnotationMultiThread.checkAllAnnotations(Class.forName(this.name).getAnnotations(), this.expected)){
+                    AnnotationMultiThread.passCnt.incrementAndGet();
+                }
+                if (AnnotationMultiThread.checkAllAnnotations(Class.forName(this.name).getDeclaredAnnotations(), this.expectedD)){
+                    AnnotationMultiThread.passCnt.incrementAndGet();
+                }
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+}
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+class GrandFather{
+    public void method1(int a, double b, Object... objects){
+    }
+}
+@SuppressWarnings("all")
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+@AnnoD(annoBA = @AnnoB)
+class Father extends GrandFather implements Interface{
+    @Override
+    public void method1(int a, double b, Object... objects) {
+    }
+    @Deprecated
+    public void method2(){
+    }
+}
+class Son extends Father{
+    @Override
+    @Deprecated
+    public void method2(){
+    }
+}
+class Son2 extends Father{
+    @Override
+    @Deprecated
+    public void method2(){
+    }
+}
+@SuppressWarnings("all")
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+@AnnoD(annoBA = @AnnoB)
+interface Interface{
+}
+// DEPENDENCE: AnnoA.java AnnoB.java AnnoC.java AnnoD.java ENUMA.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java AnnoC.java AnnoD.java ENUMA.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/ENUMA.java b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/ENUMA.java
new file mode 100755
index 0000000000000000000000000000000000000000..bb9cee8770af2ae1fdcc7206c31bd5062d02d38c
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/ENUMA.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+public enum  ENUMA {
+    A,
+    B,
+    C
+}
diff --git a/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/expected.txt b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/maple.prof b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..a131d387bcc52c7f48ddeaf85eba27f24f6e136a
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/test.cfg b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f0a86e6cb9812d985916785bd09af15e8e23af70
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0202-rt-compact-AnnotationMultiThread/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationMultiThread)
+run(AnnotationMultiThread)
diff --git a/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/ReflectClassNameTest.java b/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/ReflectClassNameTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..33e46b4ff5e4e4f38e7b8d3ea60d4e4cabdd133a
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/ReflectClassNameTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+public class ReflectClassNameTest {
+    static int[] passCnt = new int[6];
+    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {
+        int i = 0;
+        Class clazz = Class.forName("一");
+        passCnt[i++] = clazz.getName().compareTo("一") == 0 ? 1 : 0;
+        Method method = clazz.getDeclaredMethod("дракон");
+        passCnt[i++] = method.getName().compareTo("дракон") == 0 ? 1 : 0;
+        Field field = clazz.getDeclaredField("Rồng");
+        passCnt[i++] = field.getName().compareTo("Rồng") == 0 ? 1 : 0;
+        Class clazz2 = Class.forName("二");
+        passCnt[i++] = clazz2.getName().compareTo("二") == 0 ? 1 : 0;
+        class 三{
+        }
+        Class clazz3 = Class.forName("ReflectClassNameTest$1三");
+        passCnt[i++] = clazz3.getName().compareTo("ReflectClassNameTest$1三") == 0 ? 1 : 0;
+        Class clazz4 = Class.forName("ReflectClassNameTest$二");
+        passCnt[i++] = clazz4.getName().compareTo("ReflectClassNameTest$二") == 0 ? 1 : 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1]"));
+    }
+    class 二{
+    }
+}
+class 一{
+    int Rồng;
+    public void дракон(){
+    }
+}
+interface 二{
+}
+// EXEC:%maple  %f %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/expected.txt b/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/maple.prof b/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..c3d0d48e9349ab0ccf72d38e1ac0f903b340bf5e
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/test.cfg b/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..06e0b8123d3b6722f80e331462957ad233cf55e5
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0203-rt-compact-ReflectSpecialClassNameTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectClassNameTest)
+run(ReflectClassNameTest)
diff --git a/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoA.java b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..157d9b9509e006c87c49782ccf9f20b56e3716f4
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int 整型();
+    byte 字节();
+    char 字符();
+    double 双精度浮点();
+    boolean 布尔();
+    long 长整();
+    float 浮点();
+    short 短整型();
+    int[] あ();
+    byte[] い();
+    char[] う();
+    double[] え();
+    boolean[] お();
+    long[] か();
+    float[] き();
+    short[] く();
+    String 长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长();
+    String[] 神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马();
+    Class 类();
+    Class[] 类类();
+    Thread.State 类类类();
+    Thread.State[] 类类类类();
+    AnnoB 类类类类类();
+    AnnoB[] 类类类类类类();
+}
diff --git a/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoB.java b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnotationNotAscii.java b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnotationNotAscii.java
new file mode 100755
index 0000000000000000000000000000000000000000..9b4528b0d432a3ea25efb7591e49193bbc77e8cf
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/AnnotationNotAscii.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationNotAscii {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.整型() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.字节() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.字符() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.双精度浮点()) ? 1: 0;
+        passCnt[i++] += anno.布尔() ? 1: 0;
+        passCnt[i++] += anno.长整() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.浮点())? 1: 0;
+        passCnt[i++] += anno.短整型() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.类类类() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.类() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.あ()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.い().length == 1 && anno.い()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.う().length == 1 && anno.う()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.え().length == 3 && Double.isNaN(anno.え()[0]) && Double.isInfinite(anno.え()[1]) && Double.isInfinite(anno.え()[2]))? 1: 0;
+        passCnt[i++] += (anno.お().length == 1 && anno.お()[0]) ? 1: 0;
+        passCnt[i++] += (anno.か().length == 1 && anno.か()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.き().length == 3 && Float.isNaN(anno.き()[0]) && Float.isInfinite(anno.き()[1]) && Float.isInfinite(anno.き()[2])) ? 1: 0;
+        passCnt[i++] += (anno.く().length == 1 && anno.く()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马().length == 1 && anno.神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.类类().length == 1 && anno.类类()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.类类类类().length == 1 && anno.类类类类()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.类类类类类().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.类类类类类类()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+@AnnoA(整型 = Integer.MAX_VALUE, 字节 = Byte.MAX_VALUE, 字符 = Character.MAX_VALUE, 双精度浮点 = Double.NaN,
+        布尔 = true, 长整 = Long.MAX_VALUE, 浮点 = Float.NaN, 短整型 = Short.MAX_VALUE,
+        あ = {1,2}, い = {0}, う = {' '}, え = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        お = {true}, か = {Long.MAX_VALUE}, き = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, く = {0},
+        长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长 = "", 神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马 = "", 类 = Thread.class, 类类 = Thread.class, 类类类 = Thread.State.BLOCKED,
+        类类类类 = Thread.State.NEW, 类类类类类 = @AnnoB, 类类类类类类 = {@AnnoB, @AnnoB})
+class Test{
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/expected.txt b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/maple.prof b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..0b55ee358c790d9322c4bd73635eda9ceb81beea
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/test.cfg b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..860876a2f7d84dbdfff587aee4e706cf29ab7c35
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0204-rt-compact-AnnotationSpecialCharacter/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationNotAscii)
+run(AnnotationNotAscii)
diff --git a/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoA.java b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..a11eacb37f45e1ebb430d60436afaf8f42ab27dc
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoA.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Repeatable(Test.class)
+@AnnoB(intB = 1)
+@AnnoB(intB = 2)
+@AnnoB(intB = 3)
+@AnnoB(intB = 4)
+@AnnoB(intB = 5)
+@AnnoB(intB = 6)
+@AnnoB(intB = 7)
+@AnnoB(intB = 8)
+@AnnoB(intB = 9)
+@AnnoB(intB = 10)
+@AnnoB(intB = 11)
+@AnnoB(intB = 12)
+@AnnoB(intB = 13)
+@AnnoB(intB = 14)
+@AnnoB(intB = 15)
+@AnnoB(intB = 16)
+@AnnoB(intB = 17)
+@AnnoB(intB = 18)
+public @interface AnnoA {
+    int intA() default 0;
+    byte byteA() default 0;
+    char charA() default 0;
+    double doubleA() default 0;
+    boolean booleanA() default true;
+    long longA() default 0;
+    float floatA() default 0;
+    short shortA() default 0;
+    int[] intAA() default 0;
+    byte[] byteAA() default 0;
+    char[] charAA() default 0;
+    double[] doubleAA() default 0;
+    boolean[] booleanAA() default true;
+    long[] longAA() default 0;
+    float[] floatAA() default 0;
+    short[] shortAA() default 0;
+    String stringA() default "";
+    String[] stringAA() default "";
+    Class classA() default Thread.class;
+    Class[] classAA() default Thread.class;
+    Thread.State stateA() default Thread.State.BLOCKED;
+    Thread.State[] stateAA() default Thread.State.BLOCKED;
+    AnnoB annoBA() default @AnnoB;
+    AnnoB[] annoBAA() default @AnnoB;
+    AnnoB[] value();
+}
diff --git a/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoB.java b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d15656d5f53fd8dcd0d941b293cf4f9a6ba6d30
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnoB.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Repeatable(AnnoA.class)
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnotationRepeatable.java b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnotationRepeatable.java
new file mode 100755
index 0000000000000000000000000000000000000000..7c5942b0ae4a25c21d22479cf61bd5b6628b99a2
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/AnnotationRepeatable.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationRepeatable {
+    static int[] passCnt = new int[25];
+    public static void main(String[] args) {
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[0], "[@AnnoB(intB=-1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[1], "[@AnnoB(intB=-2), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[2], "[@AnnoB(intB=-3), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[3], "[@AnnoB(intB=-4), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[4], "[@AnnoB(intB=-5), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[5], "[@AnnoB(intB=-6), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[6], "[@AnnoB(intB=-7), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[7], "[@AnnoB(intB=-8), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[8], "[@AnnoB(intB=-9), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[9], "[@AnnoB(intB=-10), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        boolean checkAnnoA = Arrays.toString(passCnt).compareTo("[1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]") == 0;
+        boolean checkAnnoB = Arrays.toString(AnnoA.class.getAnnotation(AnnoA.class).value()).compareTo("[@AnnoB(intB=1), @AnnoB(intB=2), @AnnoB(intB=3), @AnnoB(intB=4), @AnnoB(intB=5), @AnnoB(intB=6), @AnnoB(intB=7), @AnnoB(intB=8), @AnnoB(intB=9), @AnnoB(intB=10), @AnnoB(intB=11), @AnnoB(intB=12), @AnnoB(intB=13), @AnnoB(intB=14), @AnnoB(intB=15), @AnnoB(intB=16), @AnnoB(intB=17), @AnnoB(intB=18)]") == 0;
+        if (checkAnnoA && checkAnnoB){
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+    private static void checkAnnoA(AnnoA anno, String value){
+        int i = 0;
+        passCnt[i++] = anno.intA() == 0 ? 1: 0;
+        passCnt[i++] += anno.byteA() == 0 ? 1: 0;
+        passCnt[i++] += anno.charA() == 0 ? 1: 0;
+        passCnt[i++] += anno.doubleA() == 0 ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == 0 ? 1: 0;
+        passCnt[i++] += anno.floatA() == 0? 1: 0;
+        passCnt[i++] += anno.shortA() == 0 ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        // array
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[0]") == 0 ? 1: 0;
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 1 && anno.doubleAA()[0] == 0)? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 1 && anno.floatAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.BLOCKED) ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999)]") == 0 ? 1: 0;
+        // value
+        passCnt[i++] += Arrays.toString(anno.value()).compareTo(value) == 0 ? 1: 0;
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java Test.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java Test.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/Test.java b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/Test.java
new file mode 100755
index 0000000000000000000000000000000000000000..cb55e7627fe78db39c9395e773c54f456969b2d6
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/Test.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@AnnoA( value = @AnnoB(intB = -1))
+@AnnoA( value = {@AnnoB(intB = -2), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -3), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -4), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -5), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -6), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -7), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -8), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -9), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -10), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+public @interface Test{
+    AnnoA[] value();
+}
diff --git a/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/expected.txt b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/maple.prof b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..90f7fe583ae4ce2553da679343d7c93814d4402d
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/test.cfg b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c755472308797f164e619c2fef54eea464504963
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0205-rt-compact-AnnotationRepeatable/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationRepeatable)
+run(AnnotationRepeatable)
diff --git a/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoA.java b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoB.java b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnotationTypeInnerClassSet.java b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnotationTypeInnerClassSet.java
new file mode 100755
index 0000000000000000000000000000000000000000..fd2f62941f47823a3f3689d5d2b37dc7846c2254
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/AnnotationTypeInnerClassSet.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeInnerClassSet {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) throws ClassNotFoundException {
+        AnnoA anno = Class.forName("AnnotationTypeInnerClassSet$Test").getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) &&
+                Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) &&
+                Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt)
+                .compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY,
+            Double.POSITIVE_INFINITY}, booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN,
+            Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    class Test{
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/expected.txt b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/maple.prof b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..227d3f2f979dc82aef2a45250c6bd33e1211a1fa
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/test.cfg b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cf69c82b1885bc7d69ac92346fd6334b1cc54179
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0206-rt-compact-AnnotationTypeInnerClassSet/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeInnerClassSet)
+run(AnnotationTypeInnerClassSet)
diff --git a/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoA.java b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoB.java b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnotationTypeLocalClassSet.java b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnotationTypeLocalClassSet.java
new file mode 100755
index 0000000000000000000000000000000000000000..3f9c0891e493e966729490d11a430a834915576e
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/AnnotationTypeLocalClassSet.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeLocalClassSet {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) throws ClassNotFoundException {
+        @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+                booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+                intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+                booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+                stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+                stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+        class Test{
+        }
+        AnnoA anno = Class.forName("AnnotationTypeLocalClassSet$1Test").getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+// DEPENDENCE: AnnoA.java AnnoB.java
+// EXEC:%maple  %f AnnoA.java AnnoB.java %build_option -o %n.so
+// EXEC:%run %n.so %n %run_option | compare %f
+// ASSERT: scan-full 0\n
diff --git a/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/expected.txt b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/maple.prof b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/maple.prof
new file mode 100644
index 0000000000000000000000000000000000000000..ca77c458b56482b1fc3e441d1957313f3eb72b94
Binary files /dev/null and b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/maple.prof differ
diff --git a/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/test.cfg b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7c4510af3ca837721799887d8d51cd598afe9ffb
--- /dev/null
+++ b/testsuite/java_test/compact_test/RT0207-rt-compact-AnnotationTypeLocalClassSet/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeLocalClassSet)
+run(AnnotationTypeLocalClassSet)
diff --git a/testsuite/java_test/compact_test/issue-0000-rt-compact-ReflectionforName2/ReflectionForName2.java b/testsuite/java_test/compact_test/issue-0000-rt-compact-ReflectionforName2/ReflectionForName2.java
new file mode 100755
index 0000000000000000000000000000000000000000..b43cf87b0fa99734a20dff514f3dfe1a83751f88
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-0000-rt-compact-ReflectionforName2/ReflectionForName2.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.File;
+import java.io.IOException;
+class ForName2 {
+    static {
+        File cls2 = new File("/data/local/tmp/ReflectionForName2.txt");
+        try {
+            cls2.createNewFile();
+        } catch (IOException e) {
+            System.err.println(e);
+        }
+    }
+}
+public class ReflectionForName2 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        File cls1 = new File("/data/local/tmp/ReflectionForName2.txt");
+        File theDir = new File(cls1.getParentFile().getAbsolutePath());
+        if (!theDir.exists()) {
+            theDir.mkdirs();
+        }
+        if (cls1.exists()) {
+            cls1.delete();
+        }
+        Class cls = Class.forName("ForName2", true, ForName2.class.getClassLoader());
+        if (cls1.exists()) {
+            System.out.println(0);
+        }else{
+            System.out.println(2);
+        }
+    }
+}
diff --git a/testsuite/java_test/compact_test/issue-0000-rt-compact-ReflectionforName2/expected.txt b/testsuite/java_test/compact_test/issue-0000-rt-compact-ReflectionforName2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-0000-rt-compact-ReflectionforName2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/issue-0000-rt-compact-ReflectionforName2/test.cfg b/testsuite/java_test/compact_test/issue-0000-rt-compact-ReflectionforName2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4c244676cce45772899772587753ff1982e65e5b
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-0000-rt-compact-ReflectionforName2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName2)
+run(ReflectionForName2)
diff --git a/testsuite/java_test/compact_test/issue-RT0096-rt-compact-ReflectionforName3/ReflectionForName3.java b/testsuite/java_test/compact_test/issue-RT0096-rt-compact-ReflectionforName3/ReflectionForName3.java
new file mode 100755
index 0000000000000000000000000000000000000000..54b63aa920a1dd79ef6599801ad3b6fceddcf3c6
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-RT0096-rt-compact-ReflectionforName3/ReflectionForName3.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.File;
+import java.io.IOException;
+class ForName3 {
+    static {
+        File cls2 = new File("/data/local/tmp/ReflectionForName3.txt");
+        try {
+            cls2.createNewFile();
+        } catch (IOException e) {
+            System.err.println(e);
+        }
+    }
+}
+public class ReflectionForName3 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        File cls1 = new File("/data/local/tmp/ReflectionForName3.txt");
+        if (cls1.exists()) {
+            cls1.delete();
+        }
+        Class cls = Class.forName("ForName3", false, ForName3.class.getClassLoader());
+        if (!cls1.exists()) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+        return;
+    }
+}
diff --git a/testsuite/java_test/compact_test/issue-RT0096-rt-compact-ReflectionforName3/expected.txt b/testsuite/java_test/compact_test/issue-RT0096-rt-compact-ReflectionforName3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-RT0096-rt-compact-ReflectionforName3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/issue-RT0096-rt-compact-ReflectionforName3/test.cfg b/testsuite/java_test/compact_test/issue-RT0096-rt-compact-ReflectionforName3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0136d23a392c4878cf3af7d97bfd60f8b1913584
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-RT0096-rt-compact-ReflectionforName3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName3)
+run(ReflectionForName3)
diff --git a/testsuite/java_test/compact_test/issue-RT0893-rt-compact-ClinitFieldSetCharInterface/ClassInitFieldSetCharInterface.java b/testsuite/java_test/compact_test/issue-RT0893-rt-compact-ClinitFieldSetCharInterface/ClassInitFieldSetCharInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..ac953606f1e5ca1c81d589ccde2d38a61e51855a
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-RT0893-rt-compact-ClinitFieldSetCharInterface/ClassInitFieldSetCharInterface.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetCharInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.setChar(null, (char)46);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetCharInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetCharInterface.result.append("One").toString();
+    char hiChar = (char)45;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetCharInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetCharInterface.result.append("Annotation").toString();
+}
diff --git a/testsuite/java_test/compact_test/issue-RT0893-rt-compact-ClinitFieldSetCharInterface/expected.txt b/testsuite/java_test/compact_test/issue-RT0893-rt-compact-ClinitFieldSetCharInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-RT0893-rt-compact-ClinitFieldSetCharInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/issue-RT0893-rt-compact-ClinitFieldSetCharInterface/test.cfg b/testsuite/java_test/compact_test/issue-RT0893-rt-compact-ClinitFieldSetCharInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b14f56245e4a4f2fdb3965481961aa0caca6d1a5
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-RT0893-rt-compact-ClinitFieldSetCharInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetCharInterface)
+run(ClassInitFieldSetCharInterface)
diff --git a/testsuite/java_test/compact_test/issue-RT0894-rt-compact-ClinitFieldSetDoubleInterface/ClassInitFieldSetDoubleInterface.java b/testsuite/java_test/compact_test/issue-RT0894-rt-compact-ClinitFieldSetDoubleInterface/ClassInitFieldSetDoubleInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..8393ae0c666e7455f424cef1e1b589ca8318051d
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-RT0894-rt-compact-ClinitFieldSetDoubleInterface/ClassInitFieldSetDoubleInterface.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetDoubleInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.setDouble(null, 0.265874);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+            return;
+        } else {
+            System.out.println(2);
+            return;
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetDoubleInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetDoubleInterface.result.append("One").toString();
+    double hiDouble = 0.1532;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetDoubleInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetDoubleInterface.result.append("Annotation").toString();
+}
diff --git a/testsuite/java_test/compact_test/issue-RT0894-rt-compact-ClinitFieldSetDoubleInterface/expected.txt b/testsuite/java_test/compact_test/issue-RT0894-rt-compact-ClinitFieldSetDoubleInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-RT0894-rt-compact-ClinitFieldSetDoubleInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/compact_test/issue-RT0894-rt-compact-ClinitFieldSetDoubleInterface/test.cfg b/testsuite/java_test/compact_test/issue-RT0894-rt-compact-ClinitFieldSetDoubleInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fff29896c515dfc547414e070f05871dad011685
--- /dev/null
+++ b/testsuite/java_test/compact_test/issue-RT0894-rt-compact-ClinitFieldSetDoubleInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetDoubleInterface)
+run(ClassInitFieldSetDoubleInterface)
diff --git a/testsuite/java_test/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/TryFinallyExceptionTest.java b/testsuite/java_test/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/TryFinallyExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d60b7f507da12f18fcd22860e5ff208bd766950
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/TryFinallyExceptionTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryFinallyExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+        try {
+            tryFinallyExceptionTest();
+        } catch (NumberFormatException e) {
+            processResult -= 3;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try-finally mode: try{exception}-finally-->caller.
+    */
+
+    public static void tryFinallyExceptionTest() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } finally {
+            processResult--;
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..77bcd40b2e974d3f2d184786ceeafbc709368f22
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0032-rt-eh-TryFinallyExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryFinallyExceptionTest)
+run(TryFinallyExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0033-rt-eh-TryCatchExceptionTest/TryCatchExceptionTest.java b/testsuite/java_test/eh_test/RT0033-rt-eh-TryCatchExceptionTest/TryCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..495f2d2b912a0c01f14a81ba250e8585b599e34c
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0033-rt-eh-TryCatchExceptionTest/TryCatchExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryCatchExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+        try {
+            tryCatchExceptionTest1();
+            tryCatchExceptionTest2();
+            tryCatchExceptionTest3();
+            tryCatchExceptionTest4();
+        } catch (Exception e) {
+            processResult -= 10;
+            result = 3;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Check NumberFormatException
+    */
+
+    public static void tryCatchExceptionTest1() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        }
+    }
+    /**
+     * Check IllegalArgumentException
+    */
+
+    public static void tryCatchExceptionTest2() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+        }
+    }
+    /**
+     * Check RuntimeException
+    */
+
+    public static void tryCatchExceptionTest3() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (RuntimeException e) {
+            processResult--;
+        }
+    }
+    /**
+     * Check Exception
+    */
+
+    public static void tryCatchExceptionTest4() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (Exception e) {
+            processResult--;
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0033-rt-eh-TryCatchExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0033-rt-eh-TryCatchExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0033-rt-eh-TryCatchExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0033-rt-eh-TryCatchExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0033-rt-eh-TryCatchExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f7d07134dfec722bb08a4f9c60a8f2c3a0bed5d8
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0033-rt-eh-TryCatchExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryCatchExceptionTest)
+run(TryCatchExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/TryMultiCatchExceptionTest.java b/testsuite/java_test/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/TryMultiCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bebe9cc4fae74a717de5a5b1b3f11bd4da9059cd
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/TryMultiCatchExceptionTest.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+public class TryMultiCatchExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+        try {
+            tryMultiCatchExceptionTest1();
+            tryMultiCatchExceptionTest2();
+            tryMultiCatchExceptionTest3();
+            tryMultiCatchExceptionTest4();
+            tryMultiCatchExceptionTest5();
+        } catch (Exception e) {
+            processResult -= 10;
+            result = 3;
+        }
+        if (result == 2 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in first catch.
+    */
+
+    public static void tryMultiCatchExceptionTest1() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult -= 10;
+        }
+    }
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in second catch.
+    */
+
+    public static void tryMultiCatchExceptionTest2() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult -= 10;
+        }
+    }
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in third catch.
+    */
+
+    public static void tryMultiCatchExceptionTest3() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult -= 10;
+        }
+    }
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in forth catch.
+    */
+
+    public static void tryMultiCatchExceptionTest4() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        } catch (IllegalArgumentException e) {
+            processResult -= 10;
+        }
+    }
+    /**
+     * Use try-catch/catch/...(multi-catch) test static int parseInt(String s), NumberFormatException is in fifth catch.
+    */
+
+    public static void tryMultiCatchExceptionTest5() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            processResult -= 10;
+        } catch (InvalidPathException e) {
+            processResult -= 10;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (NumberFormatException e) {
+            processResult--;
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b0c2bf2cc90f292546eabf56bba1c90fe8f24f22
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0034-rt-eh-TryMultiCatchExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryMultiCatchExceptionTest)
+run(TryMultiCatchExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/TryMultiCatchMatchFirstExceptionTest.java b/testsuite/java_test/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/TryMultiCatchMatchFirstExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..57bbbd38b8689e19d278dcaf1137ce1fce8db068
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/TryMultiCatchMatchFirstExceptionTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryMultiCatchMatchFirstExceptionTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        result = tryMultiCatchMatchFirstExceptionTest1();
+        if (result != 0) {
+            return 2;
+        }
+        return result;
+    }
+    /**
+     * Test try-catch/catch/...(multi-catch) mode.
+     * @return status code
+    */
+
+    public static int tryMultiCatchMatchFirstExceptionTest1() {
+        int result1 = 2; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            result1 = 0;
+        } catch (IllegalArgumentException e) {
+            result1 = 2;
+        } catch (RuntimeException e) {
+            result1 = 2;
+        } catch (Exception e) {
+            result1 = 2;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7bfd273aa052fd8bf8428e10ea0bda583fe8cb11
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryMultiCatchMatchFirstExceptionTest)
+run(TryMultiCatchMatchFirstExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/TryCatchPipelineExceptionTest.java b/testsuite/java_test/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/TryCatchPipelineExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5ea482d7a61b1ae9f93ced15db0b700fc07ff853
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/TryCatchPipelineExceptionTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+public class TryCatchPipelineExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+        try {
+            tryCatchPipelineExceptionTest1();
+            tryCatchPipelineExceptionTest2();
+            tryCatchPipelineExceptionTest3();
+            tryCatchPipelineExceptionTest4();
+            tryCatchPipelineExceptionTest5();
+        } catch (Exception e) {
+            processResult -= 10;
+            result = 3;
+        }
+        if (result == 2 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in first type.
+    */
+
+    public static void tryCatchPipelineExceptionTest1() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (NumberFormatException
+                | ClassCastException
+                | InvalidPathException
+                | IllegalStateException
+                | IndexOutOfBoundsException e) {
+            processResult--;
+        }
+    }
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in second type.
+    */
+
+    public static void tryCatchPipelineExceptionTest2() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException
+                | NumberFormatException
+                | InvalidPathException
+                | IllegalStateException
+                | IndexOutOfBoundsException e) {
+            processResult--;
+        }
+    }
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in third type.
+    */
+
+    public static void tryCatchPipelineExceptionTest3() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException
+                | InvalidPathException
+                | NumberFormatException
+                | IllegalStateException
+                | IndexOutOfBoundsException e) {
+            processResult--;
+        }
+    }
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in fourth type.
+    */
+
+    public static void tryCatchPipelineExceptionTest4() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException
+                | InvalidPathException
+                | IllegalStateException
+                | NumberFormatException
+                | IndexOutOfBoundsException e) {
+            processResult--;
+        }
+    }
+    /**
+     * Use try-catch(type1 | type 2 | ...) to test static int parseInt(String s), NumberFormatException is in fifth+ type.
+    */
+
+    public static void tryCatchPipelineExceptionTest5() {
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            processResult -= 10;
+        } catch (ClassCastException
+                | InvalidPathException
+                | IllegalStateException
+                | IndexOutOfBoundsException
+                | NumberFormatException e) {
+            processResult--;
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c88eea1bae52ec5f8046f31acb257e5bfd0a8182
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0036-rt-eh-TryCatchPipelineExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryCatchPipelineExceptionTest)
+run(TryCatchPipelineExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/TryMultiCatchFinallyExceptionTest.java b/testsuite/java_test/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/TryMultiCatchFinallyExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..934607ce30fba84584b5a81be746493cac93e4fd
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/TryMultiCatchFinallyExceptionTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryMultiCatchFinallyExceptionTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;
+        result = tryMultiCatchFinallyExceptionTest();
+        if (result != 0) {
+            return 2;
+        }
+        try {
+            result = tryMultiCatchFinallyExceptionTest2();
+        } catch (NumberFormatException e) {
+            if (result != 0) {
+                return 2;
+            }
+        }
+        return result;
+    }
+    /**
+     * Use try-catch/catch…-finally to test static int parseInt(String s), NumberFormatException is in catch.
+     * @return status code
+    */
+
+    public static int tryMultiCatchFinallyExceptionTest() {
+        int result1 = 2; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            result1--;
+        } catch (IllegalArgumentException e) {
+            result1 = 2;
+        } catch (RuntimeException e) {
+            result1 = 2;
+        } catch (Exception e) {
+            result1 = 2;
+        } finally {
+            result1--;
+        }
+        return result1;
+    }
+    /**
+     * Use try-catch/catch…-finally to test static int parseInt(String s), NumberFormatException is not in catch.
+     * @return status code
+     * @throws NumberFormatException
+    */
+
+    public static int tryMultiCatchFinallyExceptionTest2() throws NumberFormatException {
+        int result2 = 2; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (IndexOutOfBoundsException e) {
+            result2 = 2;
+        } finally {
+            result2 = 0;
+        }
+        return result2;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c9a63d2c06eb07a8156bd563f635ed095781cec8
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0037-rt-eh-TryMultiCatchFinallyExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryMultiCatchFinallyExceptionTest)
+run(TryMultiCatchFinallyExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/TryCatchResourceExceptionTest.java b/testsuite/java_test/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/TryCatchResourceExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a666e3bd94c342952dfb61f90a5df5f249d96c4
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/TryCatchResourceExceptionTest.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryCatchResourceExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 4; /* STATUS_FAILED*/
+
+        try {
+            // No Exception occur: conn.start->conn.close->finally.
+            result = result - tryCatchResourceExceptionTest1();
+            // Exception in try: conn.start->conn.close->catch(catch e in try,ignore e in close)->finally.
+            result = result - tryCatchResourceExceptionTest2();
+            // Exception in try: conn.start->conn.close->catch(catch e in start,ignore e in try & close)->finally.
+            result = result - tryCatchResourceExceptionTest3();
+        } catch (Exception e) {
+            processResult += 10;
+        }
+        if (result == 1 && processResult == 90) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * No Exception occur: conn.start->conn.close->finally.
+     * @return status code
+    */
+
+    public static int tryCatchResourceExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        try (MyResourceA conn = new MyResourceA()) {
+            conn.start();
+            result1 = 1;
+            processResult--;
+        } catch (Exception e) {
+            System.out.println("catch ......");
+            processResult -= 10;
+            result1++;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+    /**
+     * Exception in try: conn.start->conn.close->catch(catch e in try,ignore e in close)->finally.
+     * @return status code
+    */
+
+    public static int tryCatchResourceExceptionTest2() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        try (MyResourceB conn = new MyResourceB()) {
+            conn.start();
+            int num = 1 / (result1 - 4);
+            processResult -= 10;
+        } catch (Exception e) {
+            processResult--;
+            result1 = 1;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+    /**
+     * Exception in try: conn.start->conn.close->catch(catch e in start,ignore e in try & close)->finally.
+     * @return status code
+    */
+
+    public static int tryCatchResourceExceptionTest3() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        try (MyResourceC conn = new MyResourceC()) {
+            conn.start();
+            int num = 1 / (result1 - 4);
+            processResult -= 10;
+        } catch (Exception e) {
+            processResult--;
+            result1 = 1;
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+    public static class MyResourceA implements AutoCloseable {
+        /**
+         * start fun
+        */
+
+        public void start() {
+            processResult = processResult * 2;
+        }
+        @Override
+        public void close() {
+            processResult = processResult / 2;
+        }
+    }
+    public static class MyResourceB implements AutoCloseable {
+        /**
+         * start fun
+        */
+
+        public void start() {
+            processResult = processResult * 2;
+        }
+        @Override
+        public void close() throws Exception {
+            processResult = processResult / 2;
+            throw new NoSuchFieldException("ee");
+        }
+    }
+    public static class MyResourceC implements AutoCloseable {
+        /**
+         * start fun
+        */
+
+        public void start() throws Exception {
+            processResult = processResult * 2;
+            throw new NoSuchMethodException("mm");
+        }
+        @Override
+        public void close() throws Exception {
+            processResult = processResult / 2;
+            throw new NoSuchFieldException("ee");
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1e19eaf1db7463c50787560eb6b9d9e5d63d6ca5
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0038-rt-eh-TryCatchResourceExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryCatchResourceExceptionTest)
+run(TryCatchResourceExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/TryCatchThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/TryCatchThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e08cf6287571f18058ce958860853e943cd15d6b
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/TryCatchThrowExceptionTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryCatchThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryCatchThrowExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult--;
+        }
+        if (processResult == 97) {
+            result--;
+        }
+        try {
+            tryCatchThrowExceptionTest3();
+        } catch (Exception3 e) {
+            processResult--;
+        }
+        if (processResult == 95) {
+            result--;
+        }
+        return result;
+    }
+    /**
+     * Test static int parseInt(String s), NumberFormatException is caught by catch
+     * @return status code
+     * @throws NumberFormatException
+    */
+
+    public static int tryCatchThrowExceptionTest1() throws NumberFormatException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            processResult--;
+            throw e;
+        }
+        processResult -= 10; // Compiled successfully, but cannot execute.
+        return result1;
+    }
+    /**
+     * Create a new Exception extends from Exception.
+     * @return status code
+     * @throws Exception3
+    */
+
+    public static int tryCatchThrowExceptionTest3() throws Exception3 {
+        int result3 = 3; /* STATUS_FAILED*/
+
+        if (result3 != 4) {
+            processResult--;
+            throw new Exception3();
+        }
+        processResult -= 10; // Compiled successfully, but cannot execute.
+        return result3;
+    }
+    static class Exception3 extends Exception {
+        Exception3() {
+            super("yes");
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16ecd468c148a6df747e80396e869d296dddcd8a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0039-rt-eh-TryCatchThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryCatchThrowExceptionTest)
+run(TryCatchThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/TryExceptionFinallyExceptionTest.java b/testsuite/java_test/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/TryExceptionFinallyExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f16e574677d6e1c3aa60be9f631468a3c7d6b6a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/TryExceptionFinallyExceptionTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryExceptionFinallyExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryExceptionFinallyExceptionTest1();
+        } catch (NumberFormatException e) {
+            if (processResult == 97) {
+                processResult -= 2;
+            }
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{exception}-finally：handler is caller.
+     * @return status code
+    */
+
+    public static int tryExceptionFinallyExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } finally {
+                if (processResult == 99) {
+                    processResult--;
+                }
+            }
+            processResult -= 10;
+        } finally {
+            if (processResult == 98) {
+                processResult--;
+            }
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..91034e7ed09a0c0c2882de7fecc8544e9fe124b3
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0040-rt-eh-TryExceptionFinallyExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryExceptionFinallyExceptionTest)
+run(TryExceptionFinallyExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/TryTryThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/TryTryThrowExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..f615e61a89ce1605e07cb2cc38d4f2ebd56b3e07
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/TryTryThrowExceptionTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryTryThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryTryThrowExceptionTest1();
+        } catch (NumberFormatException e) {
+            if (processResult == 97) {
+                processResult -= 2;
+            }
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{exception}-catch（x）-finally：handler is caller.
+     * @return status code
+    */
+
+    public static int tryTryThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } finally {
+                if (processResult == 99) {
+                    processResult --;
+                }
+            }
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            if (processResult == 98) {
+                processResult --;
+            }
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc63ce6d4898e803590a82b9cc562df3cd016308
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0041-rt-eh-TryTryThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryTryThrowExceptionTest)
+run(TryTryThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/TryTryCatchExceptionTest.java b/testsuite/java_test/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/TryTryCatchExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..9bc42c62e4bf4ddda6895ddfcaa9afb72cb9aeae
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/TryTryCatchExceptionTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+/**
+ * Testcase for EH module
+*/
+
+public class TryTryCatchExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryTryCatchExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{exception}-catch（e）-finally.
+     * @return status code
+    */
+
+    public static int tryTryCatchExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } finally {
+                if (processResult == 99) {
+                    processResult--;
+                }
+            }
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IllegalArgumentException e) {
+            if (processResult == 98) {
+                processResult--;
+                result1 = 1;
+            }
+        } finally {
+            if (processResult == 97) {
+                processResult--;
+            }
+        }
+        if (processResult == 96) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..467159c7b9e1c1acfc6e913d92b2b1599f13fb60
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0042-rt-eh-TryTryCatchExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryTryCatchExceptionTest)
+run(TryTryCatchExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/TryCatchTryExceptionTest.java b/testsuite/java_test/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/TryCatchTryExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..7c0d441f6a5d7dc55e92058bbeb646c5a0ac9791
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/TryCatchTryExceptionTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+/**
+ * Testcase for EH module
+*/
+
+public class TryCatchTryExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryCatchTryExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{try{exception} catch(e)}-catch-finally.
+     * @return status code
+    */
+
+    public static int tryCatchTryExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (NumberFormatException e) {
+                result1 = 1;
+                if (processResult == 99) {
+                    processResult--;
+                }
+            }
+            if (processResult == 98) {
+                processResult--;
+            }
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            System.out.println("=====See:ERROR!!!");
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            if (processResult == 97) {
+                processResult--;
+            }
+        }
+        if (processResult == 96) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3db69ff7baef0a735d2287742c5303ba8e6bbae
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0043-rt-eh-TryCatchTryExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryCatchTryExceptionTest)
+run(TryCatchTryExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/DoubleTryCatchFinallyExceptionTest.java b/testsuite/java_test/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/DoubleTryCatchFinallyExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ad390b3bf3e82d705c6658cf75438effcf06105a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/DoubleTryCatchFinallyExceptionTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+/**
+ * Testcase for EH module
+*/
+
+public class DoubleTryCatchFinallyExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = doubleTryCatchFinallyExceptionTest1();
+        } catch (IllegalArgumentException e) {
+            processResult -= 2;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{try{exception} catch(x)}-finally -->caller.
+     * @return status code
+    */
+
+    public static int doubleTryCatchFinallyExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (ClassCastException e) {
+                result1 = 3;
+                processResult -= 10;
+            } finally {
+                if (processResult == 99) {
+                    processResult--;
+                }
+            }
+            processResult -= 10;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            if (processResult == 98) {
+                processResult--;
+            }
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..046f02bd0ac48539e1acfcbfa048c5067dcba78f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(DoubleTryCatchFinallyExceptionTest)
+run(DoubleTryCatchFinallyExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/TryCatchTryCatchFinallyExceptionTest.java b/testsuite/java_test/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/TryCatchTryCatchFinallyExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..12dae4b090e90ba91ff78a299b0681ccab161a13
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/TryCatchTryCatchFinallyExceptionTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.FormatterClosedException;
+public class TryCatchTryCatchFinallyExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryCatchTryCatchFinallyExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult--;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{try{exception} catch(x)}-catch()-finally --> caller.
+     * @return status code
+    */
+
+    public static int tryCatchTryCatchFinallyExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (IllegalStateException e113) {
+                System.out.println("=====See:ERROR!!!");
+                processResult -= 10;
+            }
+            processResult -= 10;
+        } catch (FormatterClosedException e1132) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 3;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd87a7783ed8fdd8068476da4f067fba1a8046db
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryCatchTryCatchFinallyExceptionTest)
+run(TryCatchTryCatchFinallyExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/TryCatchTryCatchExceptionFinallyTest.java b/testsuite/java_test/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/TryCatchTryCatchExceptionFinallyTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1de441e628be1806fbc0cede791b3064036dd1b3
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/TryCatchTryCatchExceptionFinallyTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.FormatterClosedException;
+public class TryCatchTryCatchExceptionFinallyTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryCatchTryCatchExceptionFinallyTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{try{exception} catch(x)}-catch(e)-finally.
+     * @return status code
+    */
+
+    public static int tryCatchTryCatchExceptionFinallyTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (IllegalStateException e113) {
+                System.out.println("=====See:ERROR!!!");
+                processResult -= 10;
+            }
+            processResult -= 10;
+        } catch (FormatterClosedException e1132) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (IllegalArgumentException e111) {
+            result1 = 1;
+        } catch (IndexOutOfBoundsException e112) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 1;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/expected.txt b/testsuite/java_test/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/test.cfg b/testsuite/java_test/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9ae9cc1dcc86600fbf60433875f7d4f5c854c368
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryCatchTryCatchExceptionFinallyTest)
+run(TryCatchTryCatchExceptionFinallyTest)
diff --git a/testsuite/java_test/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/CatchThrowNewExceptionTest.java b/testsuite/java_test/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/CatchThrowNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..098db9c9b6feb8f335d0fb7d82bfe21aff7a39de
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/CatchThrowNewExceptionTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CatchThrowNewExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = catchThrowNewExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            if (result == 2 && processResult == 95) {
+                return 0;
+            }
+        }
+        return result;
+    }
+    /**
+     * Test catch(){exception}, handler is caller.
+     * @return status code
+    */
+
+    public static int catchThrowNewExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            processResult -= 2;
+            System.out.println(str.substring(-5));
+            System.out.println("=====See:ERROR!!!");
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 2;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d0eb4e1f70c9b982e1179d8e6fc6b8c3ac442c7e
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0047-rt-eh-CatchThrowNewExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(CatchThrowNewExceptionTest)
+run(CatchThrowNewExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/CatchTryCatchNewExceptionTest.java b/testsuite/java_test/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/CatchTryCatchNewExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..f5d8d18c88ef4ac180fc76b11ed4f77fbee8b120
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/CatchTryCatchNewExceptionTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CatchTryCatchNewExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = catchTryCatchNewExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try-catch(){try{exception},catch(e)}-finally.
+     * @return status code
+    */
+
+    public static int catchTryCatchNewExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            try {
+                System.out.println(str.substring(-5));
+            } catch (StringIndexOutOfBoundsException e2) {
+                if (processResult == 99) {
+                    processResult--;
+                }
+            }
+            result1 = 1;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            if (processResult == 98) {
+                processResult--;
+            }
+        }
+        if (processResult == 97) {
+            processResult -= 2;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..abe9946f02992a0a621215258f92fd771bf4b3a0
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0048-rt-eh-CatchTryCatchNewExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(CatchTryCatchNewExceptionTest)
+run(CatchTryCatchNewExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/CatchTryThrowNewExceptionTest.java b/testsuite/java_test/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/CatchTryThrowNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee4315ef18d683343cf9fa6901b513c22bbd2369
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/CatchTryThrowNewExceptionTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CatchTryThrowNewExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = catchTryThrowNewExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult--;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try-catch(){try{exception},catch(x)}-finally --> caller.
+     * @return status code
+    */
+
+    public static int catchTryThrowNewExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            result1 = 1;
+            try {
+                System.out.println(str.substring(-5));
+            } catch (NumberFormatException e2) {
+                processResult -= 10;
+            }
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 3;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6772b7e7266cb1d0dbf56e10d71a65474cd39063
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0049-rt-eh-CatchTryThrowNewExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(CatchTryThrowNewExceptionTest)
+run(CatchTryThrowNewExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/FinallyThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/FinallyThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f4434ea12052121dfec42762825205225ec9c69
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/FinallyThrowExceptionTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class FinallyThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = finallyThrowExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            if (result == 2 && processResult == 95) {
+                return 0;
+            }
+        }
+        return result;
+    }
+    /**
+     * Test finally{exception}, handler is caller.
+     * @return status code
+    */
+
+    public static int finallyThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            result1 = 1;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 4;
+            System.out.println(str.substring(-5));
+            System.out.println("=====See:ERROR!!!");
+            processResult -= 10;
+        }
+        System.out.println("=====See:ERROR!!!");
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5cec292c6a3c0af45f036287edb78744fa986933
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0050-rt-eh-FinallyThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FinallyThrowExceptionTest)
+run(FinallyThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/FinallyTryCatchExceptionTest.java b/testsuite/java_test/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/FinallyTryCatchExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..38dde8c369ac907e839003080c115e435acffd31
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/FinallyTryCatchExceptionTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class FinallyTryCatchExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = finallyTryCatchExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try-catch-finally{try{exception},catch(e)}.
+     * @return status code
+    */
+
+    public static int finallyTryCatchExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            result1 = 1;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+            try {
+                System.out.println(str.substring(-5));
+            } catch (StringIndexOutOfBoundsException e) {
+                processResult--;
+            }
+        }
+        processResult -= 2;
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8091ff8575355f714d145b9d47a83d79147e3817
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0051-rt-eh-FinallyTryCatchExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FinallyTryCatchExceptionTest)
+run(FinallyTryCatchExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/FinallyTryThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/FinallyTryThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..01477e93320accbe719f3fb6dea58bd00166203f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/FinallyTryThrowExceptionTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class FinallyTryThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = finallyTryThrowExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 3;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try-catch-finally{try{exception},catch(x)}--> caller.
+     * @return status code
+    */
+
+    public static int finallyTryThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            System.out.println("=====See:ERROR!!!");
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            result1 = 1;
+        } catch (IllegalArgumentException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+            try {
+                System.out.println(str.substring(-5));
+            } catch (NumberFormatException e) {
+                processResult -= 10;
+            }
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6c962b9e20241515308660e16f09e1d12fa5f7a7
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0052-rt-eh-FinallyTryThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FinallyTryThrowExceptionTest)
+run(FinallyTryThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/TryResourceStartThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/TryResourceStartThrowExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..69143bec85d87396041ffc95ce020017f09233a0
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/TryResourceStartThrowExceptionTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryResourceStartThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryResourceStartThrowExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+    public static class MyResource implements AutoCloseable {
+        /**
+         * start fun
+         * @throws NumberFormatException
+        */
+
+        public void start() throws NumberFormatException {
+            if (processResult == 99) {
+                processResult--;
+            }
+            throw new NumberFormatException("start:exception!!!");
+        }
+        @Override
+        public void close() throws StringIndexOutOfBoundsException {
+            if (processResult == 98) {
+                processResult--;
+            }
+        }
+    }
+    /**
+     * Test try(exception){}-catch(e){}-close()-finally.
+     * @return status code
+    */
+
+    public static int tryResourceStartThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        try (MyResource conn = new MyResource()) {
+            conn.start();
+        } catch (NumberFormatException e) {
+            if (processResult == 97) {
+                processResult--;
+            }
+            result1 = 1;
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+            result1 = 3;
+        } finally {
+            if (processResult == 96) {
+                processResult--;
+            }
+        }
+        if (processResult == 95) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..be6391290e1fe2db6751d73c58be7ec6a6db3c07
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0053-rt-eh-TryResourceStartThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryResourceStartThrowExceptionTest)
+run(TryResourceStartThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/TryResourceCloseThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/TryResourceCloseThrowExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..f26c43e7a091035a2f1ea5bfa52e85dff47837eb
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/TryResourceCloseThrowExceptionTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryResourceCloseThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryResourceCloseThrowExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+    public static class MyResource implements AutoCloseable {
+        /**
+         * start fun
+         * @throws NumberFormatException
+        */
+
+        public void start() throws NumberFormatException {
+            if (processResult == 99) {
+                processResult--;
+            }
+        }
+        @Override
+        public void close() throws StringIndexOutOfBoundsException {
+            if (processResult == 98) {
+                processResult--;
+            }
+            throw new StringIndexOutOfBoundsException("end:exception!!!");
+        }
+    }
+    /**
+     * Test try(){}-catch(e){}-close(exception)-finally.
+     * @return status code
+    */
+
+    public static int tryResourceCloseThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        try (MyResource conn = new MyResource()) {
+            conn.start();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+            e.printStackTrace();
+            result1 = 3;
+        } catch (StringIndexOutOfBoundsException e) {
+            if (processResult == 97) {
+                processResult--;
+            }
+            result1 = 1;
+        } finally {
+            if (processResult == 96) {
+                processResult--;
+            }
+        }
+        if (processResult == 95) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc8662a758774243f9137600b0d45009ad0a16b6
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0054-rt-eh-TryResourceCloseThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryResourceCloseThrowExceptionTest)
+run(TryResourceCloseThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/TryResourceStartAndCloseExceptionTest.java b/testsuite/java_test/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/TryResourceStartAndCloseExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..68972eee71df0598a59c74fb10049770c8ff7be6
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/TryResourceStartAndCloseExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+public class TryResourceStartAndCloseExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryResourceStartAndCloseExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+    public static class MyResource implements AutoCloseable {
+        /**
+         * start fun
+         * @throws NumberFormatException
+        */
+
+        public void start() throws NumberFormatException {
+            if (processResult == 99) {
+                processResult--;
+            }
+            throw new NumberFormatException("start:exception!!!");
+        }
+        @Override
+        public void close() throws StringIndexOutOfBoundsException {
+            if (processResult == 98) {
+                processResult--;
+            }
+            throw new StringIndexOutOfBoundsException("end:exception!!!");
+        }
+    }
+    /**
+     * Test try(exception1){}-catch(e1){}-close(exception2)-finally.
+     * @return status code
+    */
+
+    public static int tryResourceStartAndCloseExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        try (MyResource conn = new MyResource()) {
+            conn.start();
+        } catch (NumberFormatException e) {
+            StringWriter sw = new StringWriter();
+            PrintWriter pw = new PrintWriter(sw);
+            e.printStackTrace(pw);
+            String msg=sw.toString();
+//            System.out.println(msg);
+            if (processResult == 97 && msg.contains("start:exception!!!") && msg.contains("end:exception!!!")) {
+                processResult--;
+            }
+            result1 = 1;
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 10;
+            result1 = 3;
+        } finally {
+            if (processResult == 96) {
+                processResult--;
+            }
+        }
+        if (processResult == 95) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eb89de018faff624ae38c9b0d81838445bacd2c2
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0055-rt-eh-TryResourceStartAndCloseExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryResourceStartAndCloseExceptionTest)
+run(TryResourceStartAndCloseExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0056-rt-eh-MultiTryCatchExceptionTest/MultiTryCatchExceptionTest.java b/testsuite/java_test/eh_test/RT0056-rt-eh-MultiTryCatchExceptionTest/MultiTryCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f852159e8d3b113e2603a55052c56dffd505758d
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0056-rt-eh-MultiTryCatchExceptionTest/MultiTryCatchExceptionTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class MultiTryCatchExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = multiTryCatchExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{try{try{try{try{exception}catch()}catch()}catch()}catch()},catch(e).
+     * @return status code
+    */
+
+    public static int multiTryCatchExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            processResult += 100;
+            try {
+                processResult += 100;
+                try {
+                    processResult += 100;
+                    try {
+                        processResult += 100;
+                        try {
+                            processResult += 100;
+                            Integer.parseInt(str);
+                        } catch (ClassCastException e) {
+                            processResult -= 10;
+                        } finally {
+                            processResult -= 100;
+                        }
+                    } catch (ClassCastException e) {
+                        processResult -= 10;
+                    } finally {
+                        processResult -= 100;
+                    }
+                } catch (ClassCastException e) {
+                    processResult -= 10;
+                } finally {
+                    processResult -= 100;
+                }
+            } catch (IllegalStateException e) {
+                processResult -= 10;
+            } finally {
+                processResult -= 100;
+            }
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+            result1 = 1;
+        } finally {
+            processResult -= 100;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0056-rt-eh-MultiTryCatchExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0056-rt-eh-MultiTryCatchExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0056-rt-eh-MultiTryCatchExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0056-rt-eh-MultiTryCatchExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0056-rt-eh-MultiTryCatchExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d915d937a7c6c6cab7f1f8ce5a7de66e7d576323
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0056-rt-eh-MultiTryCatchExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MultiTryCatchExceptionTest)
+run(MultiTryCatchExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0057-rt-eh-MultiTryCatchThrowExceptionTest/MultiTryCatchThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0057-rt-eh-MultiTryCatchThrowExceptionTest/MultiTryCatchThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..80706d50c1d5555a725d9a554db8f68fe721d32a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0057-rt-eh-MultiTryCatchThrowExceptionTest/MultiTryCatchThrowExceptionTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class MultiTryCatchThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = multiTryCatchThrowExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 4;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{try{try{try{try{exception}catch()}catch()}catch()}catch()},catch(x):-->caller.
+     * @return status code
+    */
+
+    public static int multiTryCatchThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            processResult += 100;
+            try {
+                processResult += 100;
+                try {
+                    processResult += 100;
+                    try {
+                        processResult += 100;
+                        try {
+                            processResult += 100;
+                            Integer.parseInt(str);
+                        } catch (ClassCastException e) {
+                            processResult -= 10;
+                        } finally {
+                            processResult -= 100;
+                        }
+                    } catch (ClassCastException e) {
+                        processResult -= 10;
+                    } finally {
+                        processResult -= 100;
+                    }
+                } catch (ClassCastException e) {
+                    processResult -= 10;
+                } finally {
+                    processResult -= 100;
+                }
+            } catch (IllegalStateException e) {
+                processResult -= 10;
+            } finally {
+                processResult -= 100;
+            }
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (IllegalStateException e) {
+            processResult -= 10;
+        } finally {
+            processResult -= 100;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0057-rt-eh-MultiTryCatchThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0057-rt-eh-MultiTryCatchThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0057-rt-eh-MultiTryCatchThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0057-rt-eh-MultiTryCatchThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0057-rt-eh-MultiTryCatchThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7352c21ed96b1a6b3dc157f7e7a7246116f6630a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0057-rt-eh-MultiTryCatchThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MultiTryCatchThrowExceptionTest)
+run(MultiTryCatchThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0058-rt-eh-FunctionNestMultiTryCatchExceptionTest/FunctionNestMultiTryCatchExceptionTest.java b/testsuite/java_test/eh_test/RT0058-rt-eh-FunctionNestMultiTryCatchExceptionTest/FunctionNestMultiTryCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e39e05e429645dbb43b454227401a11616c4f61
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0058-rt-eh-FunctionNestMultiTryCatchExceptionTest/FunctionNestMultiTryCatchExceptionTest.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.charset.IllegalCharsetNameException;
+import java.util.IllegalFormatException;
+public class FunctionNestMultiTryCatchExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = run1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 0 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run1 fun
+     * @return status code
+    */
+
+    public static int run1() {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = run2();
+        } catch (IllegalArgumentException e) {
+            processResult -= 1;
+        }
+        if (processResult == 98) {
+            result = 0;
+            processResult -= 3;
+        }
+        return result;
+    }
+    /**
+     * Nested run2 fun
+     * @return status code
+    */
+
+    public static int run2() {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = run3();
+        } catch (ClassCastException e) {
+            processResult -= 2;
+        }
+        if (processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run3 fun
+     * @return status code
+    */
+
+    public static int run3() {
+        int result = 3; /* STATUS_FAILED*/
+
+        try {
+            result = run4();
+        } catch (IllegalStateException e) {
+            processResult -= 3;
+        }
+        if (processResult == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run4 fun
+     * @return status code
+    */
+
+    public static int run4() {
+        int result = 4; /* STATUS_FAILED*/
+
+        try {
+            result = run5();
+        } catch (IllegalFormatException e) {
+            processResult -= 4;
+        }
+        if (processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run5 fun
+     * @return status code
+    */
+
+    public static int run5() {
+        int result = 5; /* STATUS_FAILED*/
+
+        try {
+            result = functionNestMultiTryCatchExceptionTest1();
+        } catch (IllegalCharsetNameException e) {
+            processResult -= 5;
+        }
+        if (processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{try{try{try{try{exception}catch()}catch()}catch()}catch()}, -->caller.caller.caller
+     * @return status code
+    */
+
+    public static int functionNestMultiTryCatchExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            processResult += 100;
+            try {
+                processResult += 100;
+                try {
+                    processResult += 100;
+                    try {
+                        processResult += 100;
+                        try {
+                            processResult += 100;
+                            Integer.parseInt(str);
+                        } catch (ClassCastException e) {
+                            processResult -= 10;
+                        } finally {
+                            processResult -= 100;
+                        }
+                    } catch (ClassCastException e) {
+                        processResult -= 10;
+                    } finally {
+                        processResult -= 100;
+                    }
+                } catch (ClassCastException e) {
+                    processResult -= 10;
+                } finally {
+                    processResult -= 100;
+                }
+            } catch (IllegalStateException e) {
+                processResult -= 10;
+            } finally {
+                processResult -= 100;
+            }
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (IllegalCharsetNameException e) {
+            processResult -= 10;
+        } finally {
+            processResult -= 100;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0058-rt-eh-FunctionNestMultiTryCatchExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0058-rt-eh-FunctionNestMultiTryCatchExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0058-rt-eh-FunctionNestMultiTryCatchExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0058-rt-eh-FunctionNestMultiTryCatchExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0058-rt-eh-FunctionNestMultiTryCatchExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..47a2dae5d3767197be63db422a8f59913f82955e
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0058-rt-eh-FunctionNestMultiTryCatchExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FunctionNestMultiTryCatchExceptionTest)
+run(FunctionNestMultiTryCatchExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0059-rt-eh-CatchMultiTryCatchExceptionTest/CatchMultiTryCatchExceptionTest.java b/testsuite/java_test/eh_test/RT0059-rt-eh-CatchMultiTryCatchExceptionTest/CatchMultiTryCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e8fbf3120abf25a363ef6dbf56ad113ad2e963f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0059-rt-eh-CatchMultiTryCatchExceptionTest/CatchMultiTryCatchExceptionTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CatchMultiTryCatchExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = catchMultiTryCatchExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try -catch(){try{try{try{try{try{exception}catch()}catch()}catch()}catch()}catch(e)}.
+     * @return status code
+    */
+
+    public static int catchMultiTryCatchExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+            try {
+                processResult += 100;
+                try {
+                    processResult += 100;
+                    try {
+                        processResult += 100;
+                        try {
+                            processResult += 100;
+                            try {
+                                processResult += 100;
+                                System.out.println(str.substring(-5));
+                            } catch (ClassCastException e1) {
+                                processResult -= 10;
+                            } finally {
+                                processResult -= 100;
+                            }
+                        } catch (ClassCastException e1) {
+                            processResult -= 10;
+                        } finally {
+                            processResult -= 100;
+                        }
+                    } catch (IllegalStateException e2) {
+                        processResult -= 10;
+                    } finally {
+                        processResult -= 100;
+                    }
+                } catch (ClassCastException e3) {
+                    processResult -= 10;
+                } finally {
+                    processResult -= 100;
+                }
+            } catch (StringIndexOutOfBoundsException e4) {
+                processResult--;
+                result1 = 1;
+            } finally {
+                processResult -= 100;
+            }
+        } finally {
+            processResult--;
+        }
+        processResult--;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0059-rt-eh-CatchMultiTryCatchExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0059-rt-eh-CatchMultiTryCatchExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0059-rt-eh-CatchMultiTryCatchExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0059-rt-eh-CatchMultiTryCatchExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0059-rt-eh-CatchMultiTryCatchExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..02d8b9e2318f68d277e363b41b9244773ca50ba3
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0059-rt-eh-CatchMultiTryCatchExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(CatchMultiTryCatchExceptionTest)
+run(CatchMultiTryCatchExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0060-rt-eh-CatchMultiTryCatchThrowExceptionTest/CatchMultiTryCatchThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0060-rt-eh-CatchMultiTryCatchThrowExceptionTest/CatchMultiTryCatchThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..793ca45da6315d9c6e46db9561531229e9003dc9
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0060-rt-eh-CatchMultiTryCatchThrowExceptionTest/CatchMultiTryCatchThrowExceptionTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CatchMultiTryCatchThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = catchMultiTryCatchThrowExceptionTest1();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 2;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Try -catch(){try{try{try{try{try{exception}catch()}catch()}catch()}catch()}catch()}: -->caller.
+     * @return status code
+    */
+
+    public static int catchMultiTryCatchThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+            try {
+                processResult += 100;
+                try {
+                    processResult += 100;
+                    try {
+                        processResult += 100;
+                        try {
+                            processResult += 100;
+                            try {
+                                processResult += 100;
+                                System.out.println(str.substring(-5));
+                            } catch (ClassCastException e1) {
+                                processResult -= 10;
+                            } finally {
+                                processResult -= 100;
+                            }
+                        } catch (ClassCastException e1) {
+                            processResult -= 10;
+                        } finally {
+                            processResult -= 100;
+                        }
+                    } catch (IllegalStateException e2) {
+                        processResult -= 10;
+                    } finally {
+                        processResult -= 100;
+                    }
+                } catch (ClassCastException e3) {
+                    processResult -= 10;
+                } finally {
+                    processResult -= 100;
+                }
+            } catch (IllegalStateException e4) {
+                processResult -= 10;
+            } finally {
+                processResult -= 100;
+            }
+        } finally {
+            processResult--;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0060-rt-eh-CatchMultiTryCatchThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0060-rt-eh-CatchMultiTryCatchThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0060-rt-eh-CatchMultiTryCatchThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0060-rt-eh-CatchMultiTryCatchThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0060-rt-eh-CatchMultiTryCatchThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3791c08957723cd86f459b8ced922a6109ff3dc
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0060-rt-eh-CatchMultiTryCatchThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(CatchMultiTryCatchThrowExceptionTest)
+run(CatchMultiTryCatchThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0061-rt-eh-FunctionNestCatchMultiTryExceptionTest/FunctionNestCatchMultiTryExceptionTest.java b/testsuite/java_test/eh_test/RT0061-rt-eh-FunctionNestCatchMultiTryExceptionTest/FunctionNestCatchMultiTryExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..058b0668ceadc262f563020865034aaf3438600e
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0061-rt-eh-FunctionNestCatchMultiTryExceptionTest/FunctionNestCatchMultiTryExceptionTest.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.charset.IllegalCharsetNameException;
+import java.util.IllegalFormatException;
+public class FunctionNestCatchMultiTryExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = run1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 0 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run1 fun
+     * @return status code
+    */
+
+    public static int run1() {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = run2();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult--;
+        }
+        if (processResult == 96) {
+            result = 0;
+            processResult--;
+        }
+        return result;
+    }
+    /**
+     * Nested run2 fun
+     * @return status code
+    */
+
+    public static int run2() {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = run3();
+        } catch (ClassCastException e) {
+            processResult -= 2;
+        }
+        if (processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run3 fun
+     * @return status code
+    */
+
+    public static int run3() {
+        int result = 3; /* STATUS_FAILED*/
+
+        try {
+            result = run4();
+        } catch (IllegalStateException e) {
+            processResult -= 3;
+        }
+        if (processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run4 fun
+     * @return status code
+    */
+
+    public static int run4() {
+        int result = 4; /* STATUS_FAILED*/
+
+        try {
+            result = run5();
+        } catch (IllegalFormatException e) {
+            processResult -= 4;
+        }
+        if (processResult == 93) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run5 fun
+     * @return status code
+    */
+
+    public static int run5() {
+        int result = 5; /* STATUS_FAILED*/
+
+        try {
+            result = functionNestCatchMultiTryExceptionTest1();
+        } catch (IllegalCharsetNameException e) {
+            processResult -= 5;
+        }
+        if (processResult == 92) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try-catch(){try{try{try{try{try{exception}catch()}catch()}catch()}catch()}catch()}:
+     * @return status code
+    */
+
+    public static int functionNestCatchMultiTryExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+            try {
+                processResult += 100;
+                try {
+                    processResult += 100;
+                    try {
+                        processResult += 100;
+                        try {
+                            processResult += 100;
+                            try {
+                                processResult += 100;
+                                System.out.println(str.substring(-5));
+                            } catch (ClassCastException e1) {
+                                processResult -= 10;
+                            } finally {
+                                processResult -= 100;
+                            }
+                        } catch (ClassCastException e1) {
+                            processResult -= 10;
+                        } finally {
+                            processResult -= 100;
+                        }
+                    } catch (IllegalStateException e2) {
+                        processResult -= 10;
+                    } finally {
+                        processResult -= 100;
+                    }
+                } catch (ClassCastException e3) {
+                    processResult -= 10;
+                } finally {
+                    processResult -= 100;
+                }
+            } catch (IllegalStateException e4) {
+                processResult -= 10;
+            } finally {
+                processResult -= 100;
+            }
+        } finally {
+            processResult--;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0061-rt-eh-FunctionNestCatchMultiTryExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0061-rt-eh-FunctionNestCatchMultiTryExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0061-rt-eh-FunctionNestCatchMultiTryExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0061-rt-eh-FunctionNestCatchMultiTryExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0061-rt-eh-FunctionNestCatchMultiTryExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d6906da2e458979ebe39fa9c0dd3ba842de99d22
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0061-rt-eh-FunctionNestCatchMultiTryExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FunctionNestCatchMultiTryExceptionTest)
+run(FunctionNestCatchMultiTryExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0062-rt-eh-FinallyMultiTryCatchExceptionTest/FinallyMultiTryCatchExceptionTest.java b/testsuite/java_test/eh_test/RT0062-rt-eh-FinallyMultiTryCatchExceptionTest/FinallyMultiTryCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e07e8c270a00aebc948e885eb233e26ed4e4789
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0062-rt-eh-FinallyMultiTryCatchExceptionTest/FinallyMultiTryCatchExceptionTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class FinallyMultiTryCatchExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = finallyMultiTryCatchExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Try-catch()-finally{try{try{try{try{try{exception}catch()}catch()}catch()}catch()}catch(e)}.
+     * @return status code
+    */
+
+    public static int finallyMultiTryCatchExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+        } finally {
+            processResult--;
+            try {
+                processResult += 100;
+                try {
+                    processResult += 100;
+                    try {
+                        processResult += 100;
+                        try {
+                            processResult += 100;
+                            try {
+                                processResult += 100;
+                                System.out.println(str.substring(-5));
+                            } catch (ClassCastException e) {
+                                processResult -= 10;
+                            } finally {
+                                processResult -= 100;
+                            }
+                        } catch (ClassCastException e1) {
+                            processResult -= 10;
+                        } finally {
+                            processResult -= 100;
+                        }
+                    } catch (IllegalStateException e2) {
+                        processResult -= 10;
+                    } finally {
+                        processResult -= 100;
+                    }
+                } catch (ClassCastException e3) {
+                    processResult -= 10;
+                } finally {
+                    processResult -= 100;
+                }
+            } catch (StringIndexOutOfBoundsException e4) {
+                processResult -= 100;
+                result1 = 1;
+            } finally {
+                processResult--;
+            }
+        }
+        processResult--;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0062-rt-eh-FinallyMultiTryCatchExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0062-rt-eh-FinallyMultiTryCatchExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0062-rt-eh-FinallyMultiTryCatchExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0062-rt-eh-FinallyMultiTryCatchExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0062-rt-eh-FinallyMultiTryCatchExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50fbe1f77a2e06ec78faef10b2ec708676bcee7e
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0062-rt-eh-FinallyMultiTryCatchExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FinallyMultiTryCatchExceptionTest)
+run(FinallyMultiTryCatchExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0063-rt-eh-FinallyMultiTryThrowExceptionTest/FinallyMultiTryThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0063-rt-eh-FinallyMultiTryThrowExceptionTest/FinallyMultiTryThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..80bd83de0cc9da993f6352b260d3f63d54200f0f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0063-rt-eh-FinallyMultiTryThrowExceptionTest/FinallyMultiTryThrowExceptionTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class FinallyMultiTryThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = finallyMultiTryThrowExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 2;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Try-catch()-finally{try{try{try{try{try{exception}catch()}catch()}catch()}catch()}catch()}：
+     * @return status code
+    */
+
+    public static int finallyMultiTryThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+        } finally {
+            processResult -= 1;
+            try {
+                processResult += 100;
+                try {
+                    processResult += 100;
+                    try {
+                        processResult += 100;
+                        try {
+                            processResult += 100;
+                            try {
+                                processResult += 100;
+                                System.out.println(str.substring(-5));
+                            } catch (ClassCastException e) {
+                                processResult -= 10;
+                            } finally {
+                                processResult -= 100;
+                            }
+                        } catch (ClassCastException e1) {
+                            processResult -= 10;
+                        } finally {
+                            processResult -= 100;
+                        }
+                    } catch (IllegalStateException e2) {
+                        processResult -= 10;
+                    } finally {
+                        processResult -= 100;
+                    }
+                } catch (ClassCastException e3) {
+                    processResult -= 10;
+                } finally {
+                    processResult -= 100;
+                }
+            } catch (IllegalArgumentException e4) {
+                processResult -= 10;
+            } finally {
+                processResult -= 100;
+            }
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0063-rt-eh-FinallyMultiTryThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0063-rt-eh-FinallyMultiTryThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0063-rt-eh-FinallyMultiTryThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0063-rt-eh-FinallyMultiTryThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0063-rt-eh-FinallyMultiTryThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a58b516e0c15dbbe1024fa9cff5dccb15e106ce5
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0063-rt-eh-FinallyMultiTryThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FinallyMultiTryThrowExceptionTest)
+run(FinallyMultiTryThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0064-rt-eh-MultiTryRecursiveThrowExceptionTest/MultiTryRecursiveThrowExceptionTest.java b/testsuite/java_test/eh_test/RT0064-rt-eh-MultiTryRecursiveThrowExceptionTest/MultiTryRecursiveThrowExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..53c08786dfe2677c0cd73768b43df1887643d8e5
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0064-rt-eh-MultiTryRecursiveThrowExceptionTest/MultiTryRecursiveThrowExceptionTest.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.charset.IllegalCharsetNameException;
+import java.util.IllegalFormatException;
+public class MultiTryRecursiveThrowExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = run1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 0 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run1 fun
+     * @return status code
+    */
+
+    public static int run1() {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = run2();
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult--;
+        }
+        if (processResult == 96) {
+            result = 0;
+            processResult--;
+        }
+        return result;
+    }
+    /**
+     * Nested run2 fun
+     * @return status code
+    */
+
+    public static int run2() {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = run3();
+        } catch (ClassCastException e) {
+            processResult -= 2;
+        }
+        if (processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run3 fun
+     * @return status code
+    */
+
+    public static int run3() {
+        int result = 3; /* STATUS_FAILED*/
+
+        try {
+            result = run4();
+        } catch (IllegalStateException e) {
+            processResult -= 3;
+        }
+        if (processResult == 94) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run4 fun
+     * @return status code
+    */
+
+    public static int run4() {
+        int result = 4; /* STATUS_FAILED*/
+
+        try {
+            result = run5();
+        } catch (IllegalFormatException e) {
+            processResult -= 4;
+        }
+        if (processResult == 93) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Nested run5 fun
+     * @return status code
+    */
+
+    public static int run5() {
+        int result = 5; /* STATUS_FAILED*/
+
+        try {
+            result = multiTryRecursiveThrowExceptionTest1();
+        } catch (IllegalCharsetNameException e) {
+            processResult -= 5;
+        }
+        if (processResult == 92) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Try-catch()-finally{try{try{try{try{try{exception}catch()}catch()}catch()}catch()}catch()}：
+     * @return status code
+    */
+
+    public static int multiTryRecursiveThrowExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+        } catch (IndexOutOfBoundsException e) {
+            processResult -= 10;
+        } catch (IllegalArgumentException e) {
+            processResult--;
+        } finally {
+            processResult--;
+            try {
+                processResult += 100;
+                try {
+                    processResult += 100;
+                    try {
+                        processResult += 100;
+                        try {
+                            processResult += 100;
+                            try {
+                                processResult += 100;
+                                System.out.println(str.substring(-5));
+                            } catch (ClassCastException e) {
+                                processResult -= 10;
+                            } finally {
+                                processResult -= 100;
+                            }
+                        } catch (ClassCastException e1) {
+                            processResult -= 10;
+                        } finally {
+                            processResult -= 100;
+                        }
+                    } catch (IllegalStateException e2) {
+                        processResult -= 10;
+                    } finally {
+                        processResult -= 100;
+                    }
+                } catch (ClassCastException e3) {
+                    processResult -= 10;
+                } finally {
+                    processResult -= 100;
+                }
+            } catch (IllegalArgumentException e4) {
+                processResult -= 10;
+            } finally {
+                processResult -= 100;
+            }
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0064-rt-eh-MultiTryRecursiveThrowExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0064-rt-eh-MultiTryRecursiveThrowExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0064-rt-eh-MultiTryRecursiveThrowExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0064-rt-eh-MultiTryRecursiveThrowExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0064-rt-eh-MultiTryRecursiveThrowExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c974229a87a0cdc44723e977803ad964a9c3f16b
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0064-rt-eh-MultiTryRecursiveThrowExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MultiTryRecursiveThrowExceptionTest)
+run(MultiTryRecursiveThrowExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/JvmArrayIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/JvmArrayIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..63607389a6b7ef93a8d656fd46b1327c46d11681
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/JvmArrayIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class JvmArrayIndexOutOfBoundsExceptionTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    static final int len = 10;
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        Object[] objs = new Object[len];
+        try {
+            Object obj1 = objs[len];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            return 0; // STATUS_PASSED
+        }
+        return 2; // STATUS_FAILED
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..263cd6c5bb12db51ce7a45ec27478465d994462c
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(JvmArrayIndexOutOfBoundsExceptionTest)
+run(JvmArrayIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/JvmStaticExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/JvmStaticExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f1b88ae47fa643fcc0d0b08ba2b300491153109
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/JvmStaticExceptionInInitializerErrorTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+class JvmStaticExceptionInInitializerErrorTesta {
+    static int other_class_test_field = 21;
+    static int local_field = 5 / 0;
+    static int testFail() {
+        int aNum = 1;
+        return aNum;
+    }
+}
+public class JvmStaticExceptionInInitializerErrorTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        try {
+            int tmp = JvmStaticExceptionInInitializerErrorTesta.testFail();
+        } catch (ExceptionInInitializerError e1) {
+            try {
+                int tmp = JvmStaticExceptionInInitializerErrorTesta.testFail();
+            } catch (NoClassDefFoundError e2) {
+                return 0; // STATUS_PASSED
+            }
+        }
+        return 2; // STATUS_FAILED
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d32ba9bca916ebb05efef8a909085c34d2d4dcc5
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(JvmStaticExceptionInInitializerErrorTest)
+run(JvmStaticExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/MultiTryNoExceptionTest.java b/testsuite/java_test/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/MultiTryNoExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..30d157533f6a41a47012cce7e4fd788c7a317aaa
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/MultiTryNoExceptionTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class MultiTryNoExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = multiTryNoExceptionTest1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test no Exception in try-multi catch-finally.
+     * @return status code
+    */
+
+    public static int multiTryNoExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123456";
+        try {
+            try {
+                Integer.parseInt(str);
+            } catch (ClassCastException e) {
+                result1 = 3;
+            } catch (IllegalStateException e) {
+                result1 = 3;
+            } catch (IndexOutOfBoundsException e) {
+                result1 = 3;
+            } finally {
+                processResult--;
+            }
+            processResult--;
+        } catch (ClassCastException e) {
+            result1 = 3;
+        } catch (IllegalStateException e) {
+            result1 = 3;
+        } catch (IndexOutOfBoundsException e) {
+            result1 = 3;
+        } finally {
+            processResult--;
+            result1 = 1;
+        }
+        processResult--;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d939b787acbd327fdd7b2402d019f68ed1c06825
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0073-rt-eh-MultiTryNoExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MultiTryNoExceptionTest)
+run(MultiTryNoExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/TryCatchReturnExceptionTest.java b/testsuite/java_test/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/TryCatchReturnExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8917417782347aebdfb18bb1d6d5fb00cc2c39e3
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/TryCatchReturnExceptionTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryCatchReturnExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryCatchReturnExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test try{exception return_x}-catch（e){return_x}-finally{return_v}.
+     * @return status code
+    */
+
+    public static int tryCatchReturnExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            processResult -= 1;
+            result1 = 1;
+            return result1;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 3;
+            result1++;
+            return result1; // Execute return 2
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dcb412e00188763a2e943d8ac37447cf3a58c15f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0074-rt-eh-TryCatchReturnExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryCatchReturnExceptionTest)
+run(TryCatchReturnExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/TryReturnValueExceptionTest.java b/testsuite/java_test/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/TryReturnValueExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..391eadbd4d559d6659c9324e141edfadaaa95999
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/TryReturnValueExceptionTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryReturnValueExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryReturnValueExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+        if (result == 5 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * try{return_v}-catch（x){return_x}-finally{return_x}
+     * @return status code
+    */
+
+    public static int tryReturnValueExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123456";
+        try {
+            Integer.parseInt(str);
+            return result1; // Execute return result1++.
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return 3;
+        } catch (NumberFormatException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return 3;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return 3;
+        } finally {
+            processResult -= 4;
+            result1++;
+            return result1;
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..94e5936e60f6232cf77f56669c2735eefcb8fdcf
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0075-rt-eh-TryReturnValueExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryReturnValueExceptionTest)
+run(TryReturnValueExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/TryCatchReturnValueExceptionTest.java b/testsuite/java_test/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/TryCatchReturnValueExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c30bba462022e429dbaea878dbfd8be9d3d13dd
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/TryCatchReturnValueExceptionTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class TryCatchReturnValueExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = tryCatchReturnValueExceptionTest1();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Try{exception return_x}-catch（e){return_v}-finally{}.
+     * @return status code
+    */
+
+    public static int tryCatchReturnValueExceptionTest1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            processResult--;
+            result1 = 1;
+            return result1; // Execute return 1.
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult -= 3;
+            result1++;
+        }
+        processResult -= 10;
+        return processResult;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..427d1c270c0f9f23f77df3efd2787da305284e21
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0076-rt-eh-TryCatchReturnValueExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(TryCatchReturnValueExceptionTest)
+run(TryCatchReturnValueExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0077-rt-eh-ExcpReturn04140/ExcpReturn04140.java b/testsuite/java_test/eh_test/RT0077-rt-eh-ExcpReturn04140/ExcpReturn04140.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4763e68f016886a0a461dc98c5f8e740c5a90f3
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0077-rt-eh-ExcpReturn04140/ExcpReturn04140.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ExcpReturn04140 {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = excpReturn041401();
+        } catch (NumberFormatException e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * try{exception return_x}-catch（e){}-finally{},return_v
+     * @return status code
+    */
+
+    public static int excpReturn041401() {
+        int result1 = 4; /*STATUS_FAILED*/
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (NumberFormatException e) {
+            processResult--;
+            result1 = 1;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } finally {
+            processResult--;
+            result1++;
+        }
+        processResult -= 2;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0077-rt-eh-ExcpReturn04140/expected.txt b/testsuite/java_test/eh_test/RT0077-rt-eh-ExcpReturn04140/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0077-rt-eh-ExcpReturn04140/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0077-rt-eh-ExcpReturn04140/test.cfg b/testsuite/java_test/eh_test/RT0077-rt-eh-ExcpReturn04140/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c8c55bad879a972768bd853a941c8016ef6de31f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0077-rt-eh-ExcpReturn04140/test.cfg
@@ -0,0 +1,2 @@
+compile(ExcpReturn04140)
+run(ExcpReturn04140)
diff --git a/testsuite/java_test/eh_test/RT0078-rt-eh-ExcpReturn04150/ExcpReturn04150.java b/testsuite/java_test/eh_test/RT0078-rt-eh-ExcpReturn04150/ExcpReturn04150.java
new file mode 100644
index 0000000000000000000000000000000000000000..3962ce01e869ca311a5015ffcb677f80a95db95b
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0078-rt-eh-ExcpReturn04150/ExcpReturn04150.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ExcpReturn04150 {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = excpReturn04150();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 5 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * try{exception return_x}-catch（x){}-finally{return_v},-->caller(x)
+     * @return status code
+    */
+
+    public static int excpReturn04150() {
+        int result1 = 4; /*STATUS_FAILED*/
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } catch (StringIndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } finally {
+            processResult -= 4;
+            result1++;
+            return result1; // execute return 5
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0078-rt-eh-ExcpReturn04150/expected.txt b/testsuite/java_test/eh_test/RT0078-rt-eh-ExcpReturn04150/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0078-rt-eh-ExcpReturn04150/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0078-rt-eh-ExcpReturn04150/test.cfg b/testsuite/java_test/eh_test/RT0078-rt-eh-ExcpReturn04150/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..46dc57a40b747d4804abc2837f11ace184ca8a79
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0078-rt-eh-ExcpReturn04150/test.cfg
@@ -0,0 +1,2 @@
+compile(ExcpReturn04150)
+run(ExcpReturn04150)
diff --git a/testsuite/java_test/eh_test/RT0079-rt-eh-ExcpReturn04160/ExcpReturn04160.java b/testsuite/java_test/eh_test/RT0079-rt-eh-ExcpReturn04160/ExcpReturn04160.java
new file mode 100644
index 0000000000000000000000000000000000000000..12c6675df9d9e031b4a5ea75dcd53e111ce58688
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0079-rt-eh-ExcpReturn04160/ExcpReturn04160.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ExcpReturn04160 {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = excpReturn04160();
+        } catch (Exception e) {
+            processResult -= 2;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * try{exception return_x}-catch（x){}-finally{},return_x-->caller(v)
+     * @return status code
+    */
+
+    public static int excpReturn04160() {
+        int result1 = 4; /*STATUS_FAILED*/
+        String str = "123#456";
+        try {
+            Integer.parseInt(str);
+            return processResult;
+        } catch (ClassCastException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+        } catch (StringIndexOutOfBoundsException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } catch (IllegalStateException e) {
+            System.out.println("=====See:ERROR!!!");
+            result1 = 3;
+            return result1;
+        } finally {
+            processResult -= 2;
+            result1++;
+        }
+        processResult -= 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0079-rt-eh-ExcpReturn04160/expected.txt b/testsuite/java_test/eh_test/RT0079-rt-eh-ExcpReturn04160/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0079-rt-eh-ExcpReturn04160/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0079-rt-eh-ExcpReturn04160/test.cfg b/testsuite/java_test/eh_test/RT0079-rt-eh-ExcpReturn04160/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..707658bb6f911c9cde9803098846bf4c3adbea9a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0079-rt-eh-ExcpReturn04160/test.cfg
@@ -0,0 +1,2 @@
+compile(ExcpReturn04160)
+run(ExcpReturn04160)
diff --git a/testsuite/java_test/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest.java b/testsuite/java_test/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..00b8157c860be84fc9e9db0df4f26559223cc6c4
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.AccessibleObject;
+public class AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = accessibleObjectgAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in addSuppressed:public T[] getAnnotationsByType(Class<T> annotationClass).
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int accessibleObjectgAnnotationsByTypeNullPointerException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        AccessibleObject accessibleObject = Test013.class.getMethod("getName", new Class[] {});
+        try {
+            Object file1 = accessibleObject.getAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test013 {
+    private String name = "default";
+    public String getName() {
+        return name;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3751ea04e4c5e37cd230082f9b725587185dc2b2
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest)
+run(AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/AccessibleObjectGetDeclaredAnnotationExceptionTest.java b/testsuite/java_test/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/AccessibleObjectGetDeclaredAnnotationExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1cf742a55f5e2b125e0bf62448f52bed664a0803
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/AccessibleObjectGetDeclaredAnnotationExceptionTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.AccessibleObject;
+public class AccessibleObjectGetDeclaredAnnotationExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = accessibleObjectgDeclaredAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in AccessibleObject: T getDeclaredAnnotation(Class<T> annotationClass).
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int accessibleObjectgDeclaredAnnotationNullPointerException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        AccessibleObject accessibleObject = Test02aa.class.getMethod("getName", new Class[] {});
+        try {
+            Object file1 = accessibleObject.getDeclaredAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test02aa {
+    private String name = "default";
+    public String getName() {
+        return name;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3f438fce2b53fe378ff279226f47acb27f7ee064
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectGetDeclaredAnnotationExceptionTest)
+run(AccessibleObjectGetDeclaredAnnotationExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest.java b/testsuite/java_test/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f096a781d57657a1c9468b53d47a3148b06b3a6f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.AccessibleObject;
+public class AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = accessibleObjectgDeclaredAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in AccessibleObject:public T[] getAnnotationsByType(Class<T> annotationClass).
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int accessibleObjectgDeclaredAnnotationsByTypeNullPointerException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        AccessibleObject mt = Test01a.class.getMethod("getName", new Class[] {});
+        try {
+            Object file1 = mt.getDeclaredAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
+class Test01a {
+    private String name = "default";
+    public String getName() {
+        return name;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ec87d06dcbbe6518e835fed722d5b0b631c58074
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest)
+run(AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/CharacterCodePointCountIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/CharacterCodePointCountIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd9789f02b757cf51a8351f0f3aafa13c9acb93b
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/CharacterCodePointCountIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CharacterCodePointCountIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = charactercodePointCountIndexOutOfBoundsException1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        try {
+            result = charactercodePointCountIndexOutOfBoundsException2();
+        } catch (Exception e) {
+            processResult -= 40;
+        }
+        if (result == 4 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Test method codePointCount(char[] seq, int offset, int count).
+     * @return status code
+    */
+
+    public static int charactercodePointCountIndexOutOfBoundsException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        char[] chars = new char[] {'a', 'b', 'c', 'd', 'e'};
+        int offset = 1;
+        int count = 10;
+        try {
+            int obj = Character.codePointCount(chars, offset, count);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+    /**
+     * Test method codePointCount(CharSequence seq, int beginIndex, int endIndex).
+     * @return status code
+    */
+
+    public static int charactercodePointCountIndexOutOfBoundsException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        CharSequence seq = "a b c d e";
+        int offset = 1;
+        int count = 10;
+        try {
+            int obj = Character.codePointCount(seq, offset, count);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..629d8c400728c647ee8e9b44c6a7811f00525eca
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterCodePointCountIndexOutOfBoundsExceptionTest)
+run(CharacterCodePointCountIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/CharactercodePointCountNullPointerException.java b/testsuite/java_test/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/CharactercodePointCountNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..f98216c2f8ef155eaf18012b7e46de769e91a068
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/CharactercodePointCountNullPointerException.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CharactercodePointCountNullPointerException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = charactercodePointCountNullPointerException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        try {
+            result = charactercodePointCountNullPointerException2();
+        } catch (Exception e) {
+            processResult -= 40;
+        }
+        if (result == 4 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * codePointCount(char[] a, int offset, int count),a is null,catch NullPointerException
+     * @return status code
+    */
+
+    public static int charactercodePointCountNullPointerException() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - if seq is null.
+        //
+        // public static int codePointCount(char[] a, int offset, int count)
+        int offset = 1;
+        int count = 4;
+        char[] chars = null;
+        try {
+            int obj = Character.codePointCount(chars, offset, count);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    /**
+     * codePointCount(CharSequence seq, int beginIndex, int endIndex), seq is null,catch NullPointerException
+     * @return status code
+    */
+
+    public static int charactercodePointCountNullPointerException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - if seq is null.
+        //
+        // public static int codePointCount(CharSequence seq, int beginIndex, int endIndex)
+        int offset = 1;
+        int count = 4;
+        CharSequence seq = null;
+        try {
+            int obj = Character.codePointCount(seq, offset, count);
+            processResult -= 30;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/expected.txt b/testsuite/java_test/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/test.cfg b/testsuite/java_test/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e887a2219ebec2303d64ea1dea0530a3b6b64d1a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0520-rt-eh-CharactercodePointCountNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharactercodePointCountNullPointerException)
+run(CharactercodePointCountNullPointerException)
diff --git a/testsuite/java_test/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/CharacteroffsetByCodePointsIndexOutOfBoundsException.java b/testsuite/java_test/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/CharacteroffsetByCodePointsIndexOutOfBoundsException.java
new file mode 100644
index 0000000000000000000000000000000000000000..774ba8e8ddbd5d3961bb6aa5a043e7ba809cdd5d
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/CharacteroffsetByCodePointsIndexOutOfBoundsException.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CharacteroffsetByCodePointsIndexOutOfBoundsException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characteroffsetByCodePointsIndexOutOfBoundsException1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        try {
+            result = characteroffsetByCodePointsIndexOutOfBoundsException2();
+        } catch (Exception e) {
+            processResult -= 40;
+        }
+        if (result == 4 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset), check IndexOutOfBoundsException
+     * @return status code
+    */
+
+    public static int characteroffsetByCodePointsIndexOutOfBoundsException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IndexOutOfBoundsException -if start or count is negative, or if start + count is larger than the length
+        // of the given array, or if index is less than start or larger then start + count, or if codePointOffset
+        // is positive and the text range starting with index and ending with start + count - 1 has fewer than
+        // codePointOffset code points, or if codePointOffset is negative and the text range starting with start and
+        // ending with index - 1 has fewer than the absolute value of codePointOffset code points.
+        //
+        // public static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)
+        int offset = 0;
+        int count = 10;
+        char[] chars = new char[] {'a', 'b', 'c', 'd', 'e'};
+        try {
+            int obj = Character.offsetByCodePoints(chars, offset, count, 0, 0);
+            System.out.println(obj);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    /**
+     * offsetByCodePoints(CharSequence seq, int index, int codePointOffset), catch IndexOutOfBoundsException
+     * @return status code
+    */
+
+    public static int characteroffsetByCodePointsIndexOutOfBoundsException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IndexOutOfBoundsException -if start or count is negative, or if start + count is larger than the length
+        // of the given array, or if index is less than start or larger then start + count, or if codePointOffset
+        // is positive and the text range starting with index and ending with start + count - 1 has fewer than
+        // codePointOffset code points, or if codePointOffset is negative and the text range starting with start and
+        // ending with index - 1 has fewer than the absolute value of codePointOffset code points.
+        //
+        // public static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset)
+        int offset = 0;
+        int count = 10;
+        CharSequence seq = "a b c d e";
+        try {
+            int obj = Character.offsetByCodePoints(seq, offset, count);
+            System.out.println(obj);
+            processResult -= 30;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/expected.txt b/testsuite/java_test/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/test.cfg b/testsuite/java_test/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..507e56e767f87ad0e4df8a8c2b248994f2829818
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacteroffsetByCodePointsIndexOutOfBoundsException)
+run(CharacteroffsetByCodePointsIndexOutOfBoundsException)
diff --git a/testsuite/java_test/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/CharacteroffsetByCodePointsNullPointerException.java b/testsuite/java_test/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/CharacteroffsetByCodePointsNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..5bbc7e6f87588fb4eb4d0338c7323ec3e3cb8213
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/CharacteroffsetByCodePointsNullPointerException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CharacteroffsetByCodePointsNullPointerException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        ;
+        try {
+            result = characteroffsetByCodePointsNullPointerException1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        try {
+            result = characteroffsetByCodePointsNullPointerException2();
+        } catch (Exception e) {
+            processResult -= 40;
+        }
+        if (result == 4 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset), catch NullPointerException
+     * @return status code
+    */
+
+    public static int characteroffsetByCodePointsNullPointerException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - if seq is null.
+        //
+        // public static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)
+        int offset = 1;
+        int count = 4;
+        char[] chars = null;
+        try {
+            int obj = Character.offsetByCodePoints(chars, offset, count, 0, 2);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    /**
+     * offsetByCodePoints(CharSequence seq, int index, int codePointOffset), catch NullPointerException
+     * @return status code
+    */
+
+    public static int characteroffsetByCodePointsNullPointerException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - if seq is null.
+        //
+        // public static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset)
+        int offset = 1;
+        int count = 4;
+        CharSequence seq = null;
+        try {
+            int obj = Character.offsetByCodePoints(seq, offset, count);
+            processResult -= 30;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/expected.txt b/testsuite/java_test/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/test.cfg b/testsuite/java_test/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7de9a9de68fd3f8d977433703db879999131d76d
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacteroffsetByCodePointsNullPointerException)
+run(CharacteroffsetByCodePointsNullPointerException)
diff --git a/testsuite/java_test/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/ClassasSubclassClassCastException.java b/testsuite/java_test/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/ClassasSubclassClassCastException.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4e4e3a2f8d67090eff1c2a392fc9c07af7be0fb
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/ClassasSubclassClassCastException.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.List;
+public class ClassasSubclassClassCastException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classAsSubclassClassCastException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * asSubclass(Class<U> clazz), check ClassCastException
+     * @return status code
+    */
+
+    public static int classAsSubclassClassCastException() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ClassCastException - if this Class object does not represent a subclass of the specified class
+        // (here "subclass" includes the class itself).
+        //
+        // public Class<? extends U> asSubclass(Class<U> clazz)
+        La1 la1 = new La1();
+        try {
+            Class<? extends List> strListCast = la1.getClass().asSubclass(List.class);
+            processResult -= 10;
+        } catch (ClassCastException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
+class La1 {
+    /**
+     * just for test
+    */
+
+    public int field1 = 1;
+    /**
+     * just for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * just for test
+    */
+
+    public static int field3 = field2[3];
+}
diff --git a/testsuite/java_test/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/expected.txt b/testsuite/java_test/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/test.cfg b/testsuite/java_test/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ee140d2327b39df2369c9ff3c913423e31ccf879
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0523-rt-eh-ClassasSubclassClassCastException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassasSubclassClassCastException)
+run(ClassasSubclassClassCastException)
diff --git a/testsuite/java_test/eh_test/RT0524-rt-eh-ClasscastClassCastException/ClasscastClassCastException.java b/testsuite/java_test/eh_test/RT0524-rt-eh-ClasscastClassCastException/ClasscastClassCastException.java
new file mode 100644
index 0000000000000000000000000000000000000000..b4dd242a80da080e269b0947e2c5ce2074d4fef5
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0524-rt-eh-ClasscastClassCastException/ClasscastClassCastException.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ClasscastClassCastException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classCastClassCastException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Class:public T cast(Object obj)
+     * @return status code
+    */
+
+    public static int classCastClassCastException() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ClassCastException - if this Class object does not represent a subclass of the specified class
+        // (here "subclass" includes the class itself).
+        //
+        // public T cast(Object obj)
+        Object obj1 = new Cast1();
+        Cast2 cast22 = new Cast2();
+        try {
+            Object type1 = Cast1.class.cast(cast22);
+            System.out.println(type1.getClass());
+            processResult -= 10;
+        } catch (ClassCastException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
+class Cast1 {
+    String str1 = "str1";
+    /**
+     * set String method1
+    */
+
+    public static void setStr() {
+        String method1 = "1";
+    }
+}
+class Cast2 {
+    String str2 = "str2";
+    /**
+     * set String method2
+    */
+
+    public static void setInt() {
+        int method2 = 2;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0524-rt-eh-ClasscastClassCastException/expected.txt b/testsuite/java_test/eh_test/RT0524-rt-eh-ClasscastClassCastException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0524-rt-eh-ClasscastClassCastException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0524-rt-eh-ClasscastClassCastException/test.cfg b/testsuite/java_test/eh_test/RT0524-rt-eh-ClasscastClassCastException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d69b94d1933b44e66f2500a0932c16f19c1958dc
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0524-rt-eh-ClasscastClassCastException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClasscastClassCastException)
+run(ClasscastClassCastException)
diff --git a/testsuite/java_test/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/ClassforName1ParExceptionInInitializerError.java b/testsuite/java_test/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/ClassforName1ParExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd003dfbc981ebcfbbfcefc00230939e49ab00e8
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/ClassforName1ParExceptionInInitializerError.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ClassforName1ParExceptionInInitializerError {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classForName1ParExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Class :public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
+     * @return status code
+     * @throws ClassNotFoundException
+    */
+
+    public static int classForName1ParExceptionInInitializerError() throws ClassNotFoundException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError - if the initialization provoked by this method fails
+        //
+        // public static Class<?> forName(String className)
+        Class cls = Class.forName("ClassforName1ParExceptionInInitializerError");
+        ClassLoader cLoader = cls.getClassLoader();
+        try {
+            Class cls2 = Class.forName("Cast6");
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Cast6 {
+    String str1 = "str1";
+    /**
+     * set String method1
+    */
+
+    public static void setStr() {
+        String method1 = "1";
+    }
+    static {
+        int num = 1 / 0;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/expected.txt b/testsuite/java_test/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/test.cfg b/testsuite/java_test/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e68ad8b06accca7c3e8568e5afeecc10011ea078
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0525-rt-eh-ClassforName1ParExceptionInInitializerError/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassforName1ParExceptionInInitializerError)
+run(ClassforName1ParExceptionInInitializerError)
diff --git a/testsuite/java_test/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/ClassforNameExceptionInInitializerError.java b/testsuite/java_test/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/ClassforNameExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..d91a427b6457123e207e903214384f1599aa7ef3
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/ClassforNameExceptionInInitializerError.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ClassforNameExceptionInInitializerError {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classForNameExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Class :public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
+     * @return status code
+     * @throws ClassNotFoundException
+    */
+
+    public static int classForNameExceptionInInitializerError() throws ClassNotFoundException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError - if the initialization provoked by this method fails
+        //
+        // public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
+        Class cls = Class.forName("ClassforNameExceptionInInitializerError");
+        ClassLoader cLoader = cls.getClassLoader();
+        try {
+            Class cls2 = Class.forName("Cast5", true, cLoader);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Cast5 {
+    String str1 = "str1";
+    /**
+     * set String method1
+    */
+
+    public static void setStr() {
+        String method1 = "1";
+    }
+    static {
+        int num = 1 / 0;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/expected.txt b/testsuite/java_test/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/test.cfg b/testsuite/java_test/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e84d113c73e4b61ebee4822c938f4b9f1e6ca0d3
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0526-rt-eh-ClassforNameExceptionInInitializerError/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassforNameExceptionInInitializerError)
+run(ClassforNameExceptionInInitializerError)
diff --git a/testsuite/java_test/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/ClassgAnnotationsByTypeNullPointerException.java b/testsuite/java_test/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/ClassgAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..705de15d40f41524841154f3bdbeb83c96b4a402
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/ClassgAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ClassgAnnotationsByTypeNullPointerException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classGAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in AccessibleObject:public A[] getAnnotationsByType(Class<A> annotationClass)
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int classGAnnotationsByTypeNullPointerException() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException- Null pointer exception
+        // public A[] getAnnotationsByType(Class<A> annotationClass)
+        Class class1 = Class.class;
+        try {
+            Object file1 = class1.getAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test01c {
+    private String name = "default";
+    public String getName() {
+        return name;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f2cc7a2dfabd04009a5a091a76aece13ce356cfb
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassgAnnotationsByTypeNullPointerException)
+run(ClassgAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/ClassgetDeclaredAnnotationNullPointerException.java b/testsuite/java_test/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/ClassgetDeclaredAnnotationNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e7e8f1957edc4c6da8d4a1d343c35a1dca896d3
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/ClassgetDeclaredAnnotationNullPointerException.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.annotation.Annotation;
+public class ClassgetDeclaredAnnotationNullPointerException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classGetDeclaredAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in AccessibleObject:public A getDeclaredAnnotation
+     * @return status code
+    */
+
+    public static int classGetDeclaredAnnotationNullPointerException() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException- Null pointer exception
+        // public A getDeclaredAnnotation(Class<A> annotationClass)
+        Class class1 = Class.class;
+        try {
+            // Object file1  = m. getAnnotationsByType(null);
+            // getDeclaredAnnotation
+            Annotation file1 = class1.getDeclaredAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/expected.txt b/testsuite/java_test/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/test.cfg b/testsuite/java_test/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9d66574043361ea92c69b3a8c09fefb178835a44
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassgetDeclaredAnnotationNullPointerException)
+run(ClassgetDeclaredAnnotationNullPointerException)
diff --git a/testsuite/java_test/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/ClassgetDeclaredFieldNoSuchFieldException.java b/testsuite/java_test/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/ClassgetDeclaredFieldNoSuchFieldException.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6a5f6b556e4691b1659c2e4460231c3cbda05a1
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/ClassgetDeclaredFieldNoSuchFieldException.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class ClassgetDeclaredFieldNoSuchFieldException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classGetDeclaredFieldNoSuchFieldException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Class constructor:public Field getDeclaredField(String name)
+     * @return status code
+    */
+
+    public static int classGetDeclaredFieldNoSuchFieldException() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NoSuchFieldException - if a field with the specified name is not found.
+        //
+        // public Field getDeclaredField(String name)
+        Class class1 = Class.class;
+        try {
+            Field file1 = class1.getDeclaredField("abc123");
+            processResult -= 10;
+        } catch (NoSuchFieldException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/expected.txt b/testsuite/java_test/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/test.cfg b/testsuite/java_test/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d913b2f10ace79efba5a5ff9f0b602fe7c36ea60
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassgetDeclaredFieldNoSuchFieldException)
+run(ClassgetDeclaredFieldNoSuchFieldException)
diff --git a/testsuite/java_test/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/ClassgetDeclaredFieldNullPointerException.java b/testsuite/java_test/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/ClassgetDeclaredFieldNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3254b58d0efb785c0590826d07c3919ac1e16d9
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/ClassgetDeclaredFieldNullPointerException.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class ClassgetDeclaredFieldNullPointerException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classGetDeclaredFieldNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Class constructor:public Field getDeclaredField(String name)
+     * @return status code
+     * @throws NoSuchFieldException
+    */
+
+    public static int classGetDeclaredFieldNullPointerException() throws NoSuchFieldException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException -     if name is null.
+        //
+        // public Field getDeclaredField(String name)
+        String string = null;
+        Class class1 = Class.class;
+        try {
+            Field file1 = class1.getDeclaredField(string);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/expected.txt b/testsuite/java_test/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/test.cfg b/testsuite/java_test/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8fa5862a975980e9d8a280a3dc9baa7ac63ad67e
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassgetDeclaredFieldNullPointerException)
+run(ClassgetDeclaredFieldNullPointerException)
diff --git a/testsuite/java_test/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/ConstructorgAnnotationNullPointerException.java b/testsuite/java_test/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/ConstructorgAnnotationNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d9c17946beda4f2ea97ed24a2b85bc4ec05b274
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/ConstructorgAnnotationNullPointerException.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Constructor;
+public class ConstructorgAnnotationNullPointerException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = constructorGAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Constructor:public T getAnnotation
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int constructorGAnnotationNullPointerException() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - Null pointer exception
+        // public T getAnnotation(Class<T> annotationClass)
+        Class<Test01b> class1 = Test01b.class;
+        Constructor<Test01b> c1 = class1.getConstructor(new Class[] {String.class});
+        //        Constructor m = Class.class.getMethod("getName", new Class[] {});
+        try {
+            Object file1 = c1.getAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
+class Test01b {
+    /**
+     * just for test
+    */
+
+    public String name = "default";
+    public String getName() {
+        return name;
+    }
+    public Test01b(String hh) {
+        this.name = hh;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/expected.txt b/testsuite/java_test/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/test.cfg b/testsuite/java_test/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..22a6291c1ba7647bd5bdf8c8321179a63be71b19
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0531-rt-eh-ConstructorgAnnotationNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorgAnnotationNullPointerException)
+run(ConstructorgAnnotationNullPointerException)
diff --git a/testsuite/java_test/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/ConstructornewInstanceExceptionInInitializerError.java b/testsuite/java_test/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/ConstructornewInstanceExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..adb4389c95eea3700991bad113b7d2abe05201d1
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/ConstructornewInstanceExceptionInInitializerError.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+public class ConstructornewInstanceExceptionInInitializerError {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = constructorNewInstanceExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        //        System.out.println("result: " + result);
+        //        System.out.println("ConstructornewInstanceExceptionInInitializerError.res: " +
+        // ConstructornewInstanceExceptionInInitializerError.res);
+        return result;
+    }
+    /**
+     * In a static variable initialization exception occurs
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     * @throws InstantiationException
+     * @throws IllegalAccessException
+     * @throws IllegalArgumentException
+     * @throws InvocationTargetException
+    */
+
+    public static int constructorNewInstanceExceptionInInitializerError()
+            throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException,
+                    IllegalArgumentException, InvocationTargetException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError - In a static variable initialization exception occurs
+        // public T newInstance(Object... initargs)
+        Class<Test01n> class1 = Test01n.class;
+        Constructor<Test01n> c1 = class1.getConstructor(new Class[] {});
+        try {
+            Object file1 = c1.newInstance();
+            // System.out.println(file1);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+}
+class Test01n {
+    /**
+     * test a String val
+    */
+
+    public String name = "default";
+    public String getName() {
+        return name;
+    }
+    public Test01n() {
+        this.name = "init";
+    }
+    static {
+        int num = 1 / 0;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/expected.txt b/testsuite/java_test/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/test.cfg b/testsuite/java_test/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..89ae80115cbf0d8ee4cd3820c1e7c17101da3283
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructornewInstanceExceptionInInitializerError)
+run(ConstructornewInstanceExceptionInInitializerError)
diff --git a/testsuite/java_test/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/FieldgetAnnotationNullPointerException.java b/testsuite/java_test/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/FieldgetAnnotationNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..f70d44a75555ace8e3c268d2547e9d4dce68f328
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/FieldgetAnnotationNullPointerException.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldgetAnnotationNullPointerException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldGetAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Class reflect Field:public T getAnnotation(Class<T> annotationClass)
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+    */
+
+    public static int fieldGetAnnotationNullPointerException() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException -         if the specified object is null and the field is an instance field.
+        // public T getAnnotation(Class<T> annotationClass)
+        Field field = Test01a.class.getDeclaredField("field1");
+        try {
+            Object value = field.getAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    class Test01a {
+        /**
+         * a field for test
+        */
+
+        public int field1 = 1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/expected.txt b/testsuite/java_test/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/test.cfg b/testsuite/java_test/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..09d14e7b6073a142e42b8474a0ea784fa21f0b1f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0533-rt-eh-FieldgetAnnotationNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldgetAnnotationNullPointerException)
+run(FieldgetAnnotationNullPointerException)
diff --git a/testsuite/java_test/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/FieldgetAnnotationsByTypeNullPointerException.java b/testsuite/java_test/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/FieldgetAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb672728b0ecec5429999553ac5398b9117a8de9
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/FieldgetAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldgetAnnotationsByTypeNullPointerException {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldGetAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect Field:public T[] getAnnotationsByType(Class<T> annotationClass)
+     * @return status code
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+    */
+
+    public static int fieldGetAnnotationsByTypeNullPointerException()
+            throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException -         if the specified object is null and the field is an instance field.
+        // public T[] getAnnotationsByType(Class<T> annotationClass)
+        Field field = Test01a.class.getDeclaredField("field1");
+        try {
+            Object value = field.getAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult -= 1;
+        }
+        return result1;
+    }
+    class Test01a {
+        /**
+         * a field for test
+        */
+
+        public int field1 = 1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..80f0fa6fb7ee62f1459c2c4153c5cf45794b3d3b
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldgetAnnotationsByTypeNullPointerException)
+run(FieldgetAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/FieldgetByteExceptionInInitializerError.java b/testsuite/java_test/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/FieldgetByteExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f746628c75cc1e30ddb53ce6ea9d02cb171435f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/FieldgetByteExceptionInInitializerError.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldgetByteExceptionInInitializerError {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldGetByteExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed:public byte getByte(Object obj)
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldGetByteExceptionInInitializerError()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public byte getByte(Object obj)
+        Field field = Test03aa.class.getDeclaredField("field6");
+        try {
+            byte obj = field.getByte(new Test03aa());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test03aa {
+    /**
+     * define a byte for test
+    */
+
+    public static byte field6 = selfByte();
+    /**
+     * define a int[] filed for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set bValue and return
+     * @return bValue
+    */
+
+    public static byte selfByte() {
+        int self1 = field2[2];
+        byte bValue = 11;
+        return bValue;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/expected.txt b/testsuite/java_test/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/test.cfg b/testsuite/java_test/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..80f68720facc2358db9f76daeb4323f0a676c932
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0535-rt-eh-FieldgetByteExceptionInInitializerError/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldgetByteExceptionInInitializerError)
+run(FieldgetByteExceptionInInitializerError)
diff --git a/testsuite/java_test/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/FieldgetCharExceptionInInitializerError.java b/testsuite/java_test/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/FieldgetCharExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fd89613d82cb3f5610edec08bb2f6b19e175c36
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/FieldgetCharExceptionInInitializerError.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldgetCharExceptionInInitializerError {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldGetCharExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed:public byte getByte(Object obj)
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldGetCharExceptionInInitializerError()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public char getChar(Object obj)
+        Field field = TestChar.class.getDeclaredField("field6");
+        try {
+            char obj = field.getChar(new TestChar());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestChar {
+    /**
+     * a char field for test
+    */
+
+    public static char field6 = selfChar();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set cValue and return
+    */
+
+    public static char selfChar() {
+        int self1 = field2[2];
+        char cValue = 11;
+        return cValue;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/expected.txt b/testsuite/java_test/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/test.cfg b/testsuite/java_test/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6322392111c7c9c02dc658705eef2c0b89c08b50
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0536-rt-eh-FieldgetCharExceptionInInitializerError/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldgetCharExceptionInInitializerError)
+run(FieldgetCharExceptionInInitializerError)
diff --git a/testsuite/java_test/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/FieldgetDoubleExceptionInInitializerError.java b/testsuite/java_test/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/FieldgetDoubleExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e10ec96ff279e9b47961b5a6709f2cc3f42015a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/FieldgetDoubleExceptionInInitializerError.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldgetDoubleExceptionInInitializerError {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldGetDoubleExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed:public double getDouble(Object obj)
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldGetDoubleExceptionInInitializerError()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public double getDouble(Object obj)
+        Field field = TestDouble.class.getDeclaredField("field6");
+        try {
+            double obj = field.getDouble(new TestDouble());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestDouble {
+    /**
+     * a double field for test
+    */
+
+    public static double field6 = selfDouble();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set dValue and return
+    */
+
+    public static double selfDouble() {
+        int self1 = field2[2];
+        double dValue = 11;
+        return dValue;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/expected.txt b/testsuite/java_test/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/test.cfg b/testsuite/java_test/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..55e1ac48ac4bb2550821a9723532f5aab6aec37f
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldgetDoubleExceptionInInitializerError)
+run(FieldgetDoubleExceptionInInitializerError)
diff --git a/testsuite/java_test/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/FieldgetExceptionInInitializerError.java b/testsuite/java_test/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/FieldgetExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..9addf445cb1084c072091b66faf85d718fd9a423
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/FieldgetExceptionInInitializerError.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldgetExceptionInInitializerError {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldGetExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect field:public Object get(Object obj)
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldGetExceptionInInitializerError()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public Object get(Object obj)
+        //        Test01aa class1 = new Test01aa();
+        Field field = Test01aa.class.getDeclaredField("field1");
+        try {
+            Object obj = field.get(new Test01aa());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test01aa {
+    /**
+     * a int field for test
+    */
+
+    public int field1 = 1;
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * a int field for test
+    */
+
+    public static int field3 = field2[3];
+    static {
+        int field4 = 1 / 0;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/expected.txt b/testsuite/java_test/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/test.cfg b/testsuite/java_test/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..575bbcb72591c941bbaaaa8476375ab3d32219cf
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0538-rt-eh-FieldgetExceptionInInitializerError/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldgetExceptionInInitializerError)
+run(FieldgetExceptionInInitializerError)
diff --git a/testsuite/java_test/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/FieldgetFloatExceptionInInitializerError.java b/testsuite/java_test/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/FieldgetFloatExceptionInInitializerError.java
new file mode 100644
index 0000000000000000000000000000000000000000..0cbda1c5bda2ea8db4a263376316bef4f75fae96
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/FieldgetFloatExceptionInInitializerError.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldgetFloatExceptionInInitializerError {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldGetFloatExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed:public float getFloat(Object obj)
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldGetFloatExceptionInInitializerError()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // ExceptionInInitializerError -if the initialization provoked by this method fails.
+        //
+        // public float getFloat(Object obj)
+        Field field = TestFloat.class.getDeclaredField("field6");
+        try {
+            float obj = field.getFloat(new TestFloat());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestFloat {
+    /**
+     * a float field for test
+    */
+
+    public static float field6 = selfDouble();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set fValue and return
+     * @return fValue
+    */
+
+    public static float selfDouble() {
+        int self1 = field2[2];
+        float fValue = 11;
+        return fValue;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/expected.txt b/testsuite/java_test/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/test.cfg b/testsuite/java_test/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5beed65753ddff76a33253ecfb78b0659a33a9ec
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0539-rt-eh-FieldgetFloatExceptionInInitializerError/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldgetFloatExceptionInInitializerError)
+run(FieldgetFloatExceptionInInitializerError)
diff --git a/testsuite/java_test/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/FieldGetIntExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/FieldGetIntExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..033c9613f83b5cc67eb1a3002a27673ce2d9dbd8
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/FieldGetIntExceptionInInitializerErrorTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldGetIntExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = fieldGetIntExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public int getInt(Object obj).
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldGetIntExceptionInInitializerErrorTest()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Field field = TestInt.class.getDeclaredField("field6");
+        try {
+            int obj = field.getInt(new TestInt());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestInt {
+    /**
+     * a int field for test
+    */
+
+    public static int field6 = selfDouble();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set iValue and return
+     * @return iValue
+    */
+
+    public static int selfDouble() {
+        int self1 = field2[2];
+        int iValue = 11;
+        return iValue;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7435c1112f7d6b5714d424e646d85a979b9b64ca
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetIntExceptionInInitializerErrorTest)
+run(FieldGetIntExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/FieldGetLongExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/FieldGetLongExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..465c9063106f0369106163a097c3060568b6f1ce
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/FieldGetLongExceptionInInitializerErrorTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldGetLongExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = fieldGetLongExceptionInInitializerErrorTes1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public double getLong(Object obj).
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldGetLongExceptionInInitializerErrorTes1()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Field fe = TestLong.class.getDeclaredField("field6");
+        try {
+            long obj = fe.getLong(new TestLong());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestLong {
+    /**
+     * a long field for test
+    */
+
+    public static long field6 = selfDouble();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set lValue and return
+     * @return lValue
+    */
+
+    public static long selfDouble() {
+        int self1 = field2[2];
+        long lValue = 11;
+        return lValue;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eac35ba1d4b2d64d92017d4b7961b5b987037520
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetLongExceptionInInitializerErrorTest)
+run(FieldGetLongExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/FieldGetShortExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/FieldGetShortExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6df9f34b16494757b127d1378410fb844f547ab8
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/FieldGetShortExceptionInInitializerErrorTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldGetShortExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = fieldGetShortExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public short getShort(Object obj).
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldGetShortExceptionInInitializerErrorTest()
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Field field = TestShort.class.getDeclaredField("field6");
+        try {
+            short obj = field.getShort(new TestShort());
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestShort {
+    /**
+     * a short field for test
+    */
+
+    public static short field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static short selfShort() {
+        int self1 = field2[2];
+        short value = 11;
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..25095a02c0851c46ef88ac00c10083e369c84fa0
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetShortExceptionInInitializerErrorTest)
+run(FieldGetShortExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/FieldSetBooleanExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/FieldSetBooleanExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..53656510a0213c7b00c7bbc4ceae372d578e584a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/FieldSetBooleanExceptionInInitializerErrorTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldSetBooleanExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = fieldSetBooleanExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public void setBoolean(Object obj, boolean z).
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldSetBooleanExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Field field = TestSetBoolean.class.getDeclaredField("field6");
+        try {
+            field.setBoolean(new TestSetBoolean(), false);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestSetBoolean {
+    /**
+     * a boolean field for test
+    */
+
+    public static boolean field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static boolean selfShort() {
+        int self1 = field2[2];
+        boolean value = true;
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..58ea76b6404fdd2a1a7d738a90ede353ff5b362a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,3 @@
+compile(FieldSetBooleanExceptionInInitializerErrorTest)
+run(FieldSetBooleanExceptionInInitializerErrorTest)
+
diff --git a/testsuite/java_test/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/FieldSetByteExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/FieldSetByteExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..06dcea300d93ec7560d145c76227754884de01a1
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/FieldSetByteExceptionInInitializerErrorTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldSetByteExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = fieldSetByteExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public void setByte(Object obj, byte b).
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldSetByteExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Field field = TestSetByte.class.getDeclaredField("field6");
+        try {
+            field.setByte(new TestSetByte(), (byte) 1);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestSetByte {
+    /**
+     * a byte field for test
+    */
+
+    public static byte field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static byte selfShort() {
+        int self1 = field2[2];
+        byte value = (byte) 2;
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e94fb5dc5b9a292cc12c5d46649150b0a0d8f4df
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldSetByteExceptionInInitializerErrorTest)
+run(FieldSetByteExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/FieldSetCharExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/FieldSetCharExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f58ac91fb4e0c380f8e00641b2b03e90ea0b328
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/FieldSetCharExceptionInInitializerErrorTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldSetCharExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = fieldSetCharExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed:public void setChar(Object obj, char c).
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldSetCharExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Field field = TestSetChar.class.getDeclaredField("field6");
+        try {
+            field.setChar(new TestSetChar(), 'c');
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestSetChar {
+    /**
+     * a char field for test
+    */
+
+    public static char field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static char selfShort() {
+        int self1 = field2[2];
+        char value = 'a';
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..24473c5d15307a6dac97c89ba5970020443eeb33
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldSetCharExceptionInInitializerErrorTest)
+run(FieldSetCharExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/FieldSetDoubleExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/FieldSetDoubleExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c951841d828f350a191d2830c39aa43b91cfdd65
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/FieldSetDoubleExceptionInInitializerErrorTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldSetDoubleExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = fieldSetDoubleExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed:public void setDouble(Object obj, double d).
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldSetDoubleExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Field field = TestSetDouble.class.getDeclaredField("field6");
+        try {
+            field.setDouble(new TestSetDouble(), 23);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestSetDouble {
+    /**
+     * a double field for test
+    */
+
+    public static double field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static double selfShort() {
+        int self1 = field2[2];
+        double value = 12;
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..67c11b1f65a6982f9e474b74d780a470844b281a
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldSetDoubleExceptionInInitializerErrorTest)
+run(FieldSetDoubleExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/FieldSetExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/FieldSetExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..571c1db7cddbb959952ba504e56136df667bc24c
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/FieldSetExceptionInInitializerErrorTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldSetExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = fieldSetExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public void set(Object obj, Object value).
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldSetExceptionInInitializerError()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Field field = TestSet.class.getDeclaredField("field6");
+        try {
+            field.set(new TestSet(), 123);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestSet {
+    /**
+     * a int field for test
+    */
+
+    public static int field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static int selfShort() {
+        int self1 = field2[2];
+        int value = 11;
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a879e34b130ae08a9a227f5785c2fd1d1dbba6b3
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldSetExceptionInInitializerErrorTest)
+run(FieldSetExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/FieldSetFloatExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/FieldSetFloatExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a56824f92f102665e95913de42e85224b1f154c
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/FieldSetFloatExceptionInInitializerErrorTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldSetFloatExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = fieldSetFloatExceptionInInitializerErrorTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public void setFloat(Object obj, float f).
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldSetFloatExceptionInInitializerErrorTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Field field = TestSetFloat.class.getDeclaredField("field6");
+        try {
+            field.setFloat(new TestSetFloat(), (float) 0.12);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestSetFloat {
+    /**
+     * a float field for test
+    */
+
+    public static float field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static float selfShort() {
+        int self1 = field2[2];
+        float value = (float) 12.54;
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1f7799674d7cd034c69ffb359e0b0c9c1be698df
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldSetFloatExceptionInInitializerErrorTest)
+run(FieldSetFloatExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/FieldSetIntExceptionTest.java b/testsuite/java_test/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/FieldSetIntExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e36710b6ba8253c810616c656c7c8a3f44000dc1
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/FieldSetIntExceptionTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldSetIntExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldSetIntExceptionTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public void setInt(Object obj, int i).
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldSetIntExceptionTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        Field field = TestSetInt.class.getDeclaredField("field6");
+        try {
+            field.setInt(new TestSetInt(), 123);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestSetInt {
+    /**
+     * a int field for test
+    */
+
+    public static int field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static int selfShort() {
+        int self1 = field2[2];
+        int value = 11;
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8744182b042c6dc264c26b47ecf500d08980cec8
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0550-rt-eh-FieldSetIntExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldSetIntExceptionTest)
+run(FieldSetIntExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/FieldSetLongExceptionTest.java b/testsuite/java_test/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/FieldSetLongExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f08ac5b01ba6f37093124da4d34546cfdc5f7f4
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/FieldSetLongExceptionTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldSetLongExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldSetLongExceptionTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public void setLong(Object obj, long l).
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldSetLongExceptionTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        Field field = TestSetLong.class.getDeclaredField("field6");
+        try {
+            field.setLong(new TestSetLong(), 123);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestSetLong {
+    /**
+     * a long field for test
+    */
+
+    public static long field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static long selfShort() {
+        int self1 = field2[2];
+        long value = 11;
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..491e4e34e7c811977557ee750580846ac27c6f86
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0551-rt-eh-FieldSetLongExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldSetLongExceptionTest)
+run(FieldSetLongExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/FieldSetShortExceptionTest.java b/testsuite/java_test/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/FieldSetShortExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec78633b4e2103f87d744f756e230463261f464c
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/FieldSetShortExceptionTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class FieldSetShortExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldSetShortExceptionTest();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect filed: public void setShort(Object obj, short s).
+     * @return status code
+     * @throws ClassNotFoundException
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+     * @throws IllegalArgumentException
+     * @throws IllegalAccessException
+    */
+
+    public static int fieldSetShortExceptionTest()
+            throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException,
+                    IllegalAccessException {
+        int result1 = 4; /*STATUS_FAILED*/
+        Field field = TestSetShort.class.getDeclaredField("field6");
+        try {
+            field.setShort(new TestSetShort(), (short) 12);
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestSetShort {
+    /**
+     * a short field for test
+    */
+
+    public static short field6 = selfShort();
+    /**
+     * a int[] field for test
+    */
+
+    public static int[] field2 = {1, 2, 3, 4};
+    /**
+     * set value and return
+     * @return value
+    */
+
+    public static short selfShort() {
+        int self1 = field2[2];
+        short value = 11;
+        return value;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..784f05c23b38b6775a581c268a1e164da9173801
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0552-rt-eh-FieldSetShortExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldSetShortExceptionTest)
+run(FieldSetShortExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/MethodGetAnnotationExceptionTest.java b/testsuite/java_test/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/MethodGetAnnotationExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb024e62c5b9100004a5daaf2667685794113131
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/MethodGetAnnotationExceptionTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+public class MethodGetAnnotationExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = methodGetAnnotationExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect Method: public T getAnnotation(Class<T> annotationClass).
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int methodGetAnnotationExceptionTest() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Method method = Test02a.class.getMethod("getName", new Class[] {});
+        try {
+            Object value = method.getAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test02a {
+    private String name = "default";
+    public String getName() {
+        return name;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f3598dffa432fae1b7ce40da3fa6673e4a022c74
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0553-rt-eh-MethodGetAnnotationExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetAnnotationExceptionTest)
+run(MethodGetAnnotationExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/MethodInvokeExceptionInInitializerErrorTest.java b/testsuite/java_test/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/MethodInvokeExceptionInInitializerErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..61e2e17f1278da0f24f18ae0d4ce0d021f9c55a4
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/MethodInvokeExceptionInInitializerErrorTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class MethodInvokeExceptionInInitializerErrorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodInvokeExceptionInInitializerError();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect method : public Object invoke(Object obj, Object... args).
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+     * @throws IllegalAccessException
+     * @throws IllegalArgumentException
+     * @throws InvocationTargetException
+    */
+
+    public static int methodInvokeExceptionInInitializerError()
+            throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException,
+                    InvocationTargetException {
+        int result1 = 4; /*STATUS_FAILED*/
+        Class<TestExceptionInInitializerError> class1 = TestExceptionInInitializerError.class;
+        Method method = class1.getMethod("setInt", new Class[] {int.class});
+        try {
+            method.invoke(new TestExceptionInInitializerError(10), new Object[] {20});
+            processResult -= 10;
+        } catch (ExceptionInInitializerError e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class TestExceptionInInitializerError {
+    int nu;
+    /**
+     * set num
+     * @param num for test
+    */
+
+    public static void setInt(int num) {
+        int num1 = num;
+    }
+    public TestExceptionInInitializerError(int num) {
+        this.nu = num;
+    }
+    static {
+        int num = 1 / 0;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/expected.txt b/testsuite/java_test/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/test.cfg b/testsuite/java_test/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..48bece723795d152e1f2851b30f844f736c94f36
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodInvokeExceptionInInitializerErrorTest)
+run(MethodInvokeExceptionInInitializerErrorTest)
diff --git a/testsuite/java_test/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/ParameterGetAnnotationNullPointerExceptionTest.java b/testsuite/java_test/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/ParameterGetAnnotationNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..694f4245b3ee0a5493a70225e0a5202426f18dce
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/ParameterGetAnnotationNullPointerExceptionTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetAnnotationNullPointerExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterGetAnnotationNullPointerException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect.Parameter: public T getAnnotation(Class<T> annotationClass).
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int parameterGetAnnotationNullPointerException() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        Method method = Test03a.class.getMethod("getName", new Class[] {String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            Object value = parameters[0].getAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test03a {
+    private String name = "default";
+    public String getName(String str1) {
+        return str1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0c1ecaf750baa1815eaa873a54b9b4d5fa01e40e
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetAnnotationNullPointerExceptionTest)
+run(ParameterGetAnnotationNullPointerExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/ParameterGetAnnotationsByTypeNullPointerExceptionTest.java b/testsuite/java_test/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/ParameterGetAnnotationsByTypeNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9ad9c0db19ccc07c92bc2778bf604246892e186
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/ParameterGetAnnotationsByTypeNullPointerExceptionTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetAnnotationsByTypeNullPointerExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterGetAnnotationsByTypeNullPointerException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect.Parameter: public T[] getAnnotationsByType(Class<T> annotationClass).
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int parameterGetAnnotationsByTypeNullPointerException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        Method method = Test04a.class.getMethod("getName", new Class[] {String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            Object value = parameters[0].getAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test04a {
+    private String name = "default";
+    public String getName(String str1) {
+        return str1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..103f4107b1ba4f48426c87a5b529606d5067ade9
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetAnnotationsByTypeNullPointerExceptionTest)
+run(ParameterGetAnnotationsByTypeNullPointerExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/ParameterGetDeclaredAnnotationNullPointerExceptionTest.java b/testsuite/java_test/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/ParameterGetDeclaredAnnotationNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4633497a949cec24b72846cd924441455c990419
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/ParameterGetDeclaredAnnotationNullPointerExceptionTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetDeclaredAnnotationNullPointerExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterGetDeclaredAnnotationNullPointerException1();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in reflect.Parameter: public T getDeclaredAnnotation(Class<T> annotationClass).
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int parameterGetDeclaredAnnotationNullPointerException1()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        Method method = Test05a.class.getMethod("getName", new Class[] {String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            Object value = parameters[0].getDeclaredAnnotation(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test05a {
+    private String name = "default";
+    public String getName(String str1) {
+        return str1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2652240c5080626450ffc325450eebd2e00a9496
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetDeclaredAnnotationNullPointerExceptionTest)
+run(ParameterGetDeclaredAnnotationNullPointerExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/ParameterGetDeclaredAnnotationsByTypeExceptionTest.java b/testsuite/java_test/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/ParameterGetDeclaredAnnotationsByTypeExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5683caa626f8e5e771c5d78ed71af006cc7ba8e
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/ParameterGetDeclaredAnnotationsByTypeExceptionTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetDeclaredAnnotationsByTypeExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = parameterGetDeclaredAnnotationsByTypeException();
+        } catch (Exception e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Parameter: public T[] getDeclaredAnnotationsByType(Class<T> annotationClass).
+     * @return status code
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int parameterGetDeclaredAnnotationsByTypeException()
+            throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Method method = Test06a.class.getMethod("getName", new Class[] {String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            Object value = parameters[0].getDeclaredAnnotationsByType(null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test06a {
+    private String name = "default";
+    public String getName(String str1) {
+        return str1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..946443cacdc31c611678cb6bbe6857986dcf43fe
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetDeclaredAnnotationsByTypeExceptionTest)
+run(ParameterGetDeclaredAnnotationsByTypeExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/ThrowableAddSuppressedExceptionTest.java b/testsuite/java_test/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/ThrowableAddSuppressedExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fbd0c8592be76f1ca1e6b6f9d09b8b99af0fe456
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/ThrowableAddSuppressedExceptionTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ThrowableAddSuppressedExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = throwableAddSuppressedException();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Throwable: public final void addSuppressed(Throwable exception).
+     * @return status code
+    */
+
+    public static int throwableAddSuppressedException() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        Throwable cause = new Throwable();
+        try {
+            cause.addSuppressed(cause);
+            processResult -= 10;
+        } catch (IllegalArgumentException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa18d0e1cb5ea1388f733b98493a7ba9ece40ed2
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0560-rt-eh-ThrowableAddSuppressedExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableAddSuppressedExceptionTest)
+run(ThrowableAddSuppressedExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/ThrowableAddSuppressedNullPointerExceptionTest.java b/testsuite/java_test/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/ThrowableAddSuppressedNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9654a87cb3e6de405f9ae52d3897e3c0089ea1fa
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/ThrowableAddSuppressedNullPointerExceptionTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ThrowableAddSuppressedNullPointerExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = throwableAddSuppressedNullPointerException1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Exception in Throwable: public final void addSuppressed(Throwable exception).
+     * @return status code
+    */
+
+    public static int throwableAddSuppressedNullPointerException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        Throwable cause = new Throwable();
+        try {
+            cause.addSuppressed((Throwable) null);
+            processResult -= 10;
+        } catch (NullPointerException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Test02ga {
+    private String name = "default";
+    public String getName() {
+        return name;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..75d5fd2c9c3d958eac0099a146429d3fc73229a1
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableAddSuppressedNullPointerExceptionTest)
+run(ThrowableAddSuppressedNullPointerExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/MethodInvokeExceptionTest.java b/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/MethodInvokeExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0465a0d8377c5ea57a14059fe906f5b13e5bbcad
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/MethodInvokeExceptionTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+public class MethodInvokeExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    private static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            invokeMethod();
+        } catch (Exception e) {
+            processResult--;
+            System.out.println(3);
+        }
+        try {
+            invokeMethodTest();
+        } catch (Exception e) {
+            processResult--;
+            System.out.println(6);
+        }
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    static void invokeMethod() throws Exception {
+        Method method = Class.forName("java.lang.Class").getDeclaredMethod("getConstructor", Class[].class);
+        Object instance = Class.forName("java.security.CodeSigner");
+        Object[] parameters = new Object[1];
+        parameters[0] =
+                new Class[] {
+                    java.security.CodeSigner.class,
+                    java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                    java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                    java.util.LinkedHashMap.class,
+                    java.nio.channels.AsynchronousFileChannel.class,
+                    java.sql.Time.class,
+                    java.util.EnumMap.class,
+                    java.nio.channels.FileLock.class,
+                    java.util.WeakHashMap.class
+                };
+        System.out.println(1);
+        method.invoke(instance, parameters);
+        System.out.println(2);
+    }
+    static void invokeMethodTest() throws Exception {
+        Method method =
+                Class.forName("java.lang.Character").getDeclaredMethod("CharConversionException", Class[].class);
+        Object instance = Class.forName("java.security.CodeSigner");
+        Object[] parameters = new Object[1];
+        parameters[0] =
+                new Class[] {
+                    java.security.CodeSigner.class,
+                    java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                    java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                    java.util.LinkedHashMap.class,
+                    java.nio.channels.AsynchronousFileChannel.class,
+                    java.sql.Time.class,
+                    java.util.EnumMap.class,
+                    java.nio.channels.FileLock.class,
+                    java.util.WeakHashMap.class
+                };
+        System.out.println(4);
+        method.invoke(instance, parameters);
+        System.out.println(5);
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..71991f9527b9147d7c993ab4aaa599d49b38b405
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/expected.txt
@@ -0,0 +1,4 @@
+1
+3
+6
+0
diff --git a/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/old_result_figo.log b/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/old_result_figo.log
new file mode 100644
index 0000000000000000000000000000000000000000..2bdf79d1340d622634a928845f9dd9084ce5e1f9
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/old_result_figo.log
@@ -0,0 +1,2 @@
+/home/chenliliu/emui/maple/cll/important/RT0817-runtime-mrtUT-MethodInvokeExceptionTest/
+MethodInvokeException.java Failed 0 run check unexpected output
diff --git a/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2fd1fc704be7b2379c77dede788d503e3920801c
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0817-rt-mrtUT-MethodInvokeExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodInvokeExceptionTest)
+run(MethodInvokeExceptionTest)
diff --git a/testsuite/java_test/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/MethodInvokeObjectObjectsTest.java b/testsuite/java_test/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/MethodInvokeObjectObjectsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc5042d1eb2ec31d9fe18506368477ff99090acb
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/MethodInvokeObjectObjectsTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.*;
+import java.nio.charset.Charset;
+import java.util.*;
+public class MethodInvokeObjectObjectsTest {
+    /**
+     * test class
+    */
+
+    public static Class<?> clazz;
+    public static void main(String[] args) {
+        try {
+            System.out.println(run());
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        try {
+            clazz = Class.forName("java.lang.reflect.Method");
+            Method method = clazz.getMethod("invoke", Object.class, Object[].class);
+            String fcn2 = "java.util.concurrent.ConcurrentHashMap";
+            int mIndex6 = 1;
+            Method[] methods2 = Class.forName(fcn2).getDeclaredMethods();
+            Arrays.sort(methods2, new ConstructorComparator());
+            Object instance = methods2[mIndex6];
+            Constructor con = java.lang.StringBuffer.class.getDeclaredConstructor();
+            Object param1 = con.newInstance();
+            Object[] param2 = new Object[4];
+            Constructor con0 = java.lang.StringBuffer.class.getDeclaredConstructor();
+            param2[0] = con0.newInstance();
+            Constructor con1 =
+                    java.security.spec.MGF1ParameterSpec.class.getDeclaredConstructor(java.lang.String.class);
+            param2[1] = con1.newInstance("abcdefghijklmnopqrstuvwxxzABCDEFGHIJKLMNOPQRSTUVWXYZ-9223372036854775551");
+            Constructor con2 = java.util.Stack.class.getDeclaredConstructor();
+            param2[2] = con2.newInstance();
+            Constructor con3 =
+                    java.security.spec.ECGenParameterSpec.class.getDeclaredConstructor(java.lang.String.class);
+            param2[3] = con3.newInstance("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
+            Object result = method.invoke(instance, param1, param2);
+            System.out.println(result);
+        } catch (Exception e) {
+            if (e.toString().equals("java.lang.reflect.InvocationTargetException")
+                    && e.getCause().getClass().getName().toString().equals("java.lang.IllegalArgumentException")) {
+                return 0;
+            }
+        }
+        return -1;
+    }
+}
+class ConstructorComparator implements Comparator<Object> {
+    @Override
+    public int compare(Object c1, Object c2) {
+        byte[] b1 = c1.toString().getBytes(Charset.defaultCharset());
+        byte[] b2 = c2.toString().getBytes(Charset.defaultCharset());
+        int len = (b1.length < b2.length ? b1.length : b2.length);
+        for (int i = 0; i < len; i++) {
+            if (b1[i] < b2[i]) {
+                return 1;
+            } else if (b1[i] > b2[i]) {
+                return -1;
+            }
+        }
+        if (b1.length > b2.length) {
+            return -1;
+        } else if (b1.length < b2.length) {
+            return 1;
+        }
+        return 1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/expected.txt b/testsuite/java_test/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/test.cfg b/testsuite/java_test/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1b6bd2986b0a70a84077ae386d58d295dec85d63
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodInvokeObjectObjectsTest)
+run(MethodInvokeObjectObjectsTest)
diff --git a/testsuite/java_test/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/MethodInvokeInvocationTargetExceptionTest.java b/testsuite/java_test/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/MethodInvokeInvocationTargetExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..33e3cd4989c542e1e7438abc15de6cd8221f9743
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/MethodInvokeInvocationTargetExceptionTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class MethodInvokeInvocationTargetExceptionTest {
+    public static void main(String[] args) {
+        try {
+            invokeMethod();
+        } catch (InvocationTargetException e) {
+            System.out.println(0);
+        } catch (Exception e) {
+            System.out.println(3);
+        }
+    }
+    static void invokeMethod()
+            throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InvocationTargetException {
+        Method method = Class.forName("java.lang.Class").getDeclaredMethod("getConstructor", Class[].class);
+        Object instance = Class.forName("java.security.CodeSigner");
+        Object[] parameters = new Object[1];
+        parameters[0] =
+                new Class[] {
+                    java.security.CodeSigner.class,
+                    java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                    java.util.concurrent.locks.AbstractOwnableSynchronizer.class,
+                    java.util.LinkedHashMap.class,
+                    java.nio.channels.AsynchronousFileChannel.class,
+                    java.sql.Time.class,
+                    java.util.EnumMap.class,
+                    java.nio.channels.FileLock.class,
+                    java.util.WeakHashMap.class
+                };
+        method.invoke(instance, parameters);
+        System.out.println(2);
+    }
+}
diff --git a/testsuite/java_test/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/expected.txt b/testsuite/java_test/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/test.cfg b/testsuite/java_test/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bce0397c53850bc09797d8c530bb2750313c3e4b
--- /dev/null
+++ b/testsuite/java_test/eh_test/RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodInvokeInvocationTargetExceptionTest)
+run(MethodInvokeInvocationTargetExceptionTest)
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmDefaultUnsatisfiedLinkErrorTest/JvmDefaultUnsatisfiedLinkErrorTest.java b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmDefaultUnsatisfiedLinkErrorTest/JvmDefaultUnsatisfiedLinkErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..26f9bbfed2be7257ef985551fe2432e46bf776d9
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmDefaultUnsatisfiedLinkErrorTest/JvmDefaultUnsatisfiedLinkErrorTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+class JvmDefaultUnsatisfiedLinkErrorTesta {
+    native int testFail();
+}
+public class JvmDefaultUnsatisfiedLinkErrorTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        JvmDefaultUnsatisfiedLinkErrorTesta test = new JvmDefaultUnsatisfiedLinkErrorTesta();
+        try {
+            int tmp = test.testFail();
+        } catch (UnsatisfiedLinkError e1) {
+            return 0; // STATUS_PASSED
+        }
+        return 2; // STATUS_FAILED
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmDefaultUnsatisfiedLinkErrorTest/expected.txt b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmDefaultUnsatisfiedLinkErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmDefaultUnsatisfiedLinkErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmDefaultUnsatisfiedLinkErrorTest/test.cfg b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmDefaultUnsatisfiedLinkErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4120af72bfa5c905e6adb574408e9e8de2421f23
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmDefaultUnsatisfiedLinkErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(JvmDefaultUnsatisfiedLinkErrorTest.java)
+run(JvmDefaultUnsatisfiedLinkErrorTest)
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmInterfaceUnsatisfiedLinkErrorTest/JvmInterfaceUnsatisfiedLinkErrorTest.java b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmInterfaceUnsatisfiedLinkErrorTest/JvmInterfaceUnsatisfiedLinkErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9537c6e61c5377f3fbb13082a3e1b6b533b51b7c
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmInterfaceUnsatisfiedLinkErrorTest/JvmInterfaceUnsatisfiedLinkErrorTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+interface JvmInterfaceUnsatisfiedLinkErrorTesti {
+    /**
+     * just a simple method for test
+     * @return null
+    */
+
+    int testFail();
+}
+class JvmInterfaceUnsatisfiedLinkErrorTesta implements JvmInterfaceUnsatisfiedLinkErrorTesti {
+    /**
+     * just a simple native method for test
+     * @return null
+    */
+
+    public native int testFail();
+}
+public class JvmInterfaceUnsatisfiedLinkErrorTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        JvmInterfaceUnsatisfiedLinkErrorTesta test = new JvmInterfaceUnsatisfiedLinkErrorTesta();
+        try {
+            int tmp = test.testFail();
+        } catch (UnsatisfiedLinkError e1) {
+            return 0; // STATUS_PASSED
+        }
+        return 2; // STATUS_FAILED
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmInterfaceUnsatisfiedLinkErrorTest/expected.txt b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmInterfaceUnsatisfiedLinkErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmInterfaceUnsatisfiedLinkErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmInterfaceUnsatisfiedLinkErrorTest/test.cfg b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmInterfaceUnsatisfiedLinkErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..302421efeb83caa90b450b84bb08fdd9057554b5
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmInterfaceUnsatisfiedLinkErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(JvmInterfaceUnsatisfiedLinkErrorTest.java)
+run(JvmInterfaceUnsatisfiedLinkErrorTest)
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmStaticUnsatisfiedLinkErrorTest/JvmStaticUnsatisfiedLinkErrorTest.java b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmStaticUnsatisfiedLinkErrorTest/JvmStaticUnsatisfiedLinkErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f23dac7b550d5433f4fb5fb5a20ab00bbf8c756
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmStaticUnsatisfiedLinkErrorTest/JvmStaticUnsatisfiedLinkErrorTest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+class JvmStaticUnsatisfiedLinkErrorTesta {
+    static native int testFail();
+}
+public class JvmStaticUnsatisfiedLinkErrorTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        try {
+            int tmp = JvmStaticUnsatisfiedLinkErrorTesta.testFail();
+        } catch (UnsatisfiedLinkError e1) {
+            return 0; // STATUS_PASSED
+        }
+        return 2; // STATUS_FAILED
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmStaticUnsatisfiedLinkErrorTest/expected.txt b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmStaticUnsatisfiedLinkErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmStaticUnsatisfiedLinkErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmStaticUnsatisfiedLinkErrorTest/test.cfg b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmStaticUnsatisfiedLinkErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c800401d6fe2fffbbb2fed81e856bfa89012c72
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmStaticUnsatisfiedLinkErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(JvmStaticUnsatisfiedLinkErrorTest.java)
+run(JvmStaticUnsatisfiedLinkErrorTest)
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmUnsatisfiedLinkErrorTest/JvmUnsatisfiedLinkErrorTest.java b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmUnsatisfiedLinkErrorTest/JvmUnsatisfiedLinkErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f8fc99024e872a36df692043b213daea2111c5b
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmUnsatisfiedLinkErrorTest/JvmUnsatisfiedLinkErrorTest.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class JvmUnsatisfiedLinkErrorTest {
+    private native int testFail2();
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        JvmUnsatisfiedLinkErrorTest test = new JvmUnsatisfiedLinkErrorTest();
+        try {
+            int tmp = test.testFail2();
+        } catch (UnsatisfiedLinkError e1) {
+            return 0; // STATUS_PASSED
+        }
+        return 2; // STATUS_FAILED
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmUnsatisfiedLinkErrorTest/expected.txt b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmUnsatisfiedLinkErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmUnsatisfiedLinkErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmUnsatisfiedLinkErrorTest/test.cfg b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmUnsatisfiedLinkErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7e2b00c681dfc1e452c4cbbc32e733be30635adc
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-eh-JvmUnsatisfiedLinkErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(JvmUnsatisfiedLinkErrorTest.java)
+run(JvmUnsatisfiedLinkErrorTest)
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/MethodGetDefaultValueExceptionTest.jar b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/MethodGetDefaultValueExceptionTest.jar
new file mode 100644
index 0000000000000000000000000000000000000000..0aa33147d740835bf821aa293669de95f7547fe8
Binary files /dev/null and b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/MethodGetDefaultValueExceptionTest.jar differ
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/MethodGetDefaultValueExceptionTest.java b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/MethodGetDefaultValueExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..11c868f0f60d0ca0aaa2b2de9113bd5d069353ee
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/MethodGetDefaultValueExceptionTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.annotation.AnnotationFormatError;
+import java.lang.reflect.Method;
+public class MethodGetDefaultValueExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = methodGetDefaultValueExceptionTest();
+        } catch (NoSuchMethodException | SecurityException e) {
+            processResult -= 20;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * main test fun
+     * @return return STATUS
+     * @throws NoSuchMethodException
+     * @throws SecurityException
+    */
+
+    public static int methodGetDefaultValueExceptionTest() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // TypeNotPresentException - if the annotation is of type Class and no definition can be found for the default
+        // class value.
+        // Test public Object getDefaultValue().
+        Method method = RequestForEnhancementDefault.class.getMethod("cTest");
+        Object value = new Object();
+        try {
+            value = method.getDefaultValue();
+            processResult -= 10;
+        } catch (AnnotationFormatError e1) {
+            processResult--;
+        } catch (TypeNotPresentException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+@interface RequestForEnhancementDefault {
+    int id();
+    String synopsis();
+    String engineer() default "[assigned]";
+    String date() default "[unassigned]";
+    Class<Tt01> cTest() default Tt01.class;
+}
+/*
+ * interface RequestForEnhancementDefault {
+ *     int id();
+ *     String synopsis();
+ * //    String engineer() default "[assigned]";
+ * //    String date() default "[unassigned]";
+ * //    default Class<Tt01> cTest(){return   Tt01.class;}
+ *     default Tt01 cTest(){return   new Tt01();}
+ * }
+*/
+
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/expected.txt b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/test.cfg b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a3777ba7fd9d059bdb23486653ea1bab4e66734f
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-MethodGetDefaultValueExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetDefaultValueExceptionTest.java)
+run(MethodGetDefaultValueExceptionTest)
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/Readme b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/Readme
new file mode 100644
index 0000000000000000000000000000000000000000..34e40461fd2353da3786633c4a1bcee6b2a34209
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/Readme
@@ -0,0 +1,3 @@
+maybe
+
+expected.txt will changed along with runtime
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/StringMethodsNullPointExceptionTest.java b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/StringMethodsNullPointExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..3693f6d855598dd7a9cc593ba0c716acce0ba2cb
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/StringMethodsNullPointExceptionTest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringMethodsNullPointExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2 /* STATUS_FAILED*/
+;
+        try {
+            stringMethodsNullPointExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 83) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * main test fun
+    */
+
+    public static void stringMethodsNullPointExceptionTest() {
+        String str1 = "abc123";
+        String str2 = null;
+        test0(str1);
+        test1(str2);
+        test2(str2);
+        test3(str2);
+        test4(str2);
+        test5(str2);
+        test6(str2);
+        test7(str2);
+    }
+    private static void test0(String str) {
+        try {
+            char t0 = str.charAt(-2);
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 2;
+        }
+    }
+    private static void test1(String str) {
+        try {
+            char t1 = str.charAt(0);
+        } catch (NullPointerException e) {
+            System.out.println("======Please check below information as manual======");
+            System.out.println(e);
+            processResult -= 2;
+        }
+    }
+    private static void test2(String str) {
+        char[] t2 = null;
+        try {
+            t2 = str.toCharArray();
+        } catch (NullPointerException e) {
+            System.out.println("======Please check below information as manual======");
+            System.out.println(e);
+            processResult -= 2;
+        }
+    }
+    private static void test3(String str) {
+        String t3 = null;
+        try {
+            t3 = str.substring(1);
+        } catch (NullPointerException e) {
+            System.out.println("======Please check below information as manual======");
+            System.out.println(e);
+            processResult -= 2;
+        }
+    }
+    private static void test4(String str) {
+        try {
+            int t4 = str.compareTo("aaa");
+        } catch (NullPointerException e) {
+            System.out.println("======Please check below information as manual======");
+            System.out.println(e);
+            processResult -= 2;
+        }
+    }
+    private static void test5(String str) {
+        try {
+            String t5 = str.intern();
+        } catch (NullPointerException e) {
+            System.out.println("======Please check below information as manual======");
+            System.out.println(e);
+            processResult -= 2;
+        }
+    }
+    private static void test6(String str) {
+        try {
+            String t6 = str.replace("a", "b");
+        } catch (NullPointerException e) {
+            System.out.println("======Please check below information as manual======");
+            System.out.println(e);
+            processResult -= 2;
+        }
+    }
+    private static void test7(String str) {
+        try {
+            String t7 = str.concat("aaa");
+        } catch (NullPointerException e) {
+            System.out.println("======Please check below information as manual======");
+            System.out.println(e);
+            processResult -= 2;
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/expected.txt b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..322fc475908a25b683b6c84a3deeb8ab1d1d82d9
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/expected.txt
@@ -0,0 +1,15 @@
+======Please check below information as manual======
+java.lang.NullPointerException: unknown reason
+======Please check below information as manual======
+java.lang.NullPointerException: Attempt to invoke a virtual method on a null object reference
+======Please check below information as manual======
+java.lang.NullPointerException: unknown reason
+======Please check below information as manual======
+java.lang.NullPointerException: Attempt to invoke a virtual method on a null object reference
+======Please check below information as manual======
+java.lang.NullPointerException: Attempt to invoke a virtual method on a null object reference
+======Please check below information as manual======
+java.lang.NullPointerException: unknown reason
+======Please check below information as manual======
+java.lang.NullPointerException: Attempt to invoke a virtual method on a null object reference
+0
diff --git a/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/test.cfg b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3105d210630a5a75befc52ce04d656c5adfeaf4
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-0000-rt-runtime-eh-StringMethodsNullPointExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringMethodsNullPointExceptionTest.java)
+run(StringMethodsNullPointExceptionTest)
diff --git a/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/NativeExNumberFormatExceptionTest.c b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/NativeExNumberFormatExceptionTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..d46708b9079735a36a48f4c4ef2ac7a95f9260dc
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/NativeExNumberFormatExceptionTest.c
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <assert.h>
+
+void native_nativeNativeExNumberFormatExceptionTest (JNIEnv *env, jobject obj) {
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+    (*env)->CallVoidMethod(env, obj, mid); // NumberFormatException:"Java_Method_throw_xxx"
+
+    jboolean chk = (*env)->ExceptionCheck(env);
+
+    if(chk){
+        (*env)->ExceptionDescribe(env);
+    }
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env = NULL;
+    jint result = -1;
+
+    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
+        return -1;
+    }
+    assert(env != NULL);
+
+    JNINativeMethod gMethods [] =
+    {
+        {"nativeNativeExNumberFormatExceptionTest", "()V", (void*)&native_nativeNativeExNumberFormatExceptionTest },
+    };
+
+    jclass cls = (*env)->FindClass(env, "NativeExNumberFormatExceptionTest"); // if package is test:"test/ExcpAsync06110"
+    (*env)->RegisterNatives(env, cls, gMethods, 1);
+
+    /* success -- return valid version number */
+    result = JNI_VERSION_1_4;
+
+    return result;
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/NativeExNumberFormatExceptionTest.java b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/NativeExNumberFormatExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..76f794c704ed774ab4517871119c4134ce2f4fb6
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/NativeExNumberFormatExceptionTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+public class NativeExNumberFormatExceptionTest extends Exception {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out) + 95); /* STATUS_TEMP*/
+
+    }
+    private native void nativeNativeExNumberFormatExceptionTest() throws InvalidPathException; // e2
+    private void callback() throws NumberFormatException { // e1
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = nativeExNumberFormatExceptionTest1();
+        } catch (Exception e) {
+            NativeExNumberFormatExceptionTest.processResult = NativeExNumberFormatExceptionTest.processResult - 10;
+        }
+        if (result == 3 && NativeExNumberFormatExceptionTest.processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * main test fun Entrance
+     * @return status code
+    */
+
+    public static int nativeExNumberFormatExceptionTest1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        NativeExNumberFormatExceptionTest cTest = new NativeExNumberFormatExceptionTest();
+        try {
+            cTest.nativeNativeExNumberFormatExceptionTest();
+            NativeExNumberFormatExceptionTest.processResult = NativeExNumberFormatExceptionTest.processResult - 10;
+        } catch (NumberFormatException e1) {
+            result1 = 3;
+            NativeExNumberFormatExceptionTest.processResult = NativeExNumberFormatExceptionTest.processResult - 1;
+        } catch (InvalidPathException e2) {
+            result1 = 3;
+            System.out.println("======>" + e2.getMessage());
+            NativeExNumberFormatExceptionTest.processResult = NativeExNumberFormatExceptionTest.processResult - 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 3;
+            System.out.println("======>" + e3.getMessage());
+            NativeExNumberFormatExceptionTest.processResult = NativeExNumberFormatExceptionTest.processResult - 10;
+        }
+        NativeExNumberFormatExceptionTest.processResult = NativeExNumberFormatExceptionTest.processResult - 3;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/expected.txt b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50ecd3e2edcbd78fc15ac3c591ff3fb9a06f1bee
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/expected.txt
@@ -0,0 +1 @@
+------>CheckPoint:CcanContinue
diff --git a/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/jniNativeExNumberFormatExceptionTest.cpp b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/jniNativeExNumberFormatExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..95d765997867df48a14972368601a52ad3803383
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/jniNativeExNumberFormatExceptionTest.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeExNumberFormatExceptionTest_nativeNativeExNumberFormatExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jboolean chk = env->ExceptionCheck();
+    if (chk){
+        env->ExceptionDescribe();
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+
+}
+}
diff --git a/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/test.cfg b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c9d9d61fb92eb0e043356832550a79b8146b6b23
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0031-rt-eh-NativeExNumberFormatExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NativeExNumberFormatExceptionTest.java)
+run(NativeExNumberFormatExceptionTest)
diff --git a/testsuite/java_test/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/UninitializedExNullPointerExceptionTest.java b/testsuite/java_test/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/UninitializedExNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2d44e0d964c869550a3aa859c3225075ca5097d
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/UninitializedExNullPointerExceptionTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class UninitializedExNullPointerExceptionTest {
+    static int processResult = 2;
+    static UninitializedExNullPointerExceptionTest iv;
+    private void proc2() {}
+    /**
+     * Test Jvm instr: invoke special throw NullPointException.
+    */
+
+    public static void proc1() {
+        try {
+            iv.proc2(); // the invoke special instruction is used here
+        } catch (NullPointerException e) {
+            processResult = 0; // STATUS_PASSED
+        }
+    }
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        proc1();
+        return processResult;
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/expected.txt b/testsuite/java_test/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/test.cfg b/testsuite/java_test/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..156f036e91bf7629926889fb5938859c3469a89c
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UninitializedExNullPointerExceptionTest.java)
+run(UninitializedExNullPointerExceptionTest)
diff --git a/testsuite/java_test/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/JvmInitializeOutOfMemoryErrorTest.java b/testsuite/java_test/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/JvmInitializeOutOfMemoryErrorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a58593623f30657b733187e70a1619036dbb4006
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/JvmInitializeOutOfMemoryErrorTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class JvmInitializeOutOfMemoryErrorTest {
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        JvmInitializeOutOfMemoryErrorTest tTest = new JvmInitializeOutOfMemoryErrorTest();
+        return tTest.test();
+    }
+    /**
+     * Test jvm instr: invoke virtual thrown Exception InInitializerError.
+     * @return status code
+    */
+
+    public static int test() {
+        try {
+            int[] num;
+            num = new int[1024 * 1024 * 1280]; // 1024*1024*4B = 4M, *128=512M
+            num[0] = 1; // If no this, y = new int[] will be optimizated and deleted.
+        } catch (OutOfMemoryError e2) {
+            return 0;
+        }
+        return 2;
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/expected.txt b/testsuite/java_test/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/test.cfg b/testsuite/java_test/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebc9f6983e7f54bbd69bbb1beadfc50f6f803b99
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(JvmInitializeOutOfMemoryErrorTest.java)
+run(JvmInitializeOutOfMemoryErrorTest)
diff --git a/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/FieldGetGenericTypeExceptionTest.jar b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/FieldGetGenericTypeExceptionTest.jar
new file mode 100644
index 0000000000000000000000000000000000000000..ae23171bde804360e3bc59ab48e7768b951652c1
Binary files /dev/null and b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/FieldGetGenericTypeExceptionTest.jar differ
diff --git a/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/FieldGetGenericTypeExceptionTest.java b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/FieldGetGenericTypeExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..01616a688fdc99e747caf7cbeeb10ae093596576
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/FieldGetGenericTypeExceptionTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Type;
+import java.util.List;
+public class FieldGetGenericTypeExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldGetGenericTypeExceptionTest();
+        } catch (Exception e) {
+            e.printStackTrace();
+            processResult -= 20;
+        }
+        //  System.out.println("============================"+result);
+        // System.out.println("============================"+processResult);
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * TypeNotPresentException in reflect Field: public Type getGenericType().
+     * @return status code
+     * @throws NoSuchFieldException
+     * @throws SecurityException
+    */
+
+    public static int fieldGetGenericTypeExceptionTest() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        // TypeNotPresentException - if the generic type signature of the underlying field refers to a non-existent type
+        // declaration.
+        // Test public Type getGenericType().
+        Field field = Wrapper.class.getDeclaredField("people");
+        Type value = new Type() {};
+        try {
+            value = field.getGenericType();
+            processResult -= 10;
+        } catch (TypeNotPresentException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
+class Wrapper {
+    List<Person> people;
+}
diff --git a/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/Person.java b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/Person.java
new file mode 100644
index 0000000000000000000000000000000000000000..19cb1a6296c68ee00c4c07e5acf85b389fbe0939
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/Person.java
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+public class Person {
+    int num = 1;
+}
diff --git a/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/expected.txt b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/test.cfg b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..73bd1e1cca0efaca0b03633ac0406de105fabb37
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0540-rt-eh-FieldGetGenericTypeExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetGenericTypeExceptionTest.java)
+run(FieldGetGenericTypeExceptionTest)
diff --git a/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/StaticNativeNumberFormatExceptionTest.c b/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/StaticNativeNumberFormatExceptionTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..9f82e058af23119815ab9e3f5e7e944786b5bceb
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/StaticNativeNumberFormatExceptionTest.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <jni.h>
+
+JNIEXPORT void JNICALL Java_StaticNativeNumberFormatExceptionTest_nativeStaticNativeNumberFormatExceptionTest(JNIEnv *env, jobject obj) {
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    (*env)->CallVoidMethod(env, obj, mid);
+    printf("------>CheckPoint:CcanContinue\n");
+}
diff --git a/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/StaticNativeNumberFormatExceptionTest.java b/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/StaticNativeNumberFormatExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2adacf5093bc86127dda0cf2e2a91e6862e229f4
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/StaticNativeNumberFormatExceptionTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StaticNativeNumberFormatExceptionTest extends Exception {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out) + 95); /* STATUS_TEMP*/
+
+    }
+    private native void nativeStaticNativeNumberFormatExceptionTest() throws IllegalStateException; // e2
+    private void callback() throws NumberFormatException { // e1
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = staticNativeNumberFormatExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     *  Asynchronous: Static Binding: Native(exception at callback from Java), catch by Java.
+     * @return status code
+    */
+
+    public static int staticNativeNumberFormatExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        StaticNativeNumberFormatExceptionTest cTest = new StaticNativeNumberFormatExceptionTest();
+        try {
+            cTest.nativeStaticNativeNumberFormatExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 1;
+            processResult--;
+        } catch (IllegalStateException e2) {
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            processResult -= 10;
+        }
+        processResult -= 3;
+        return result1;
+    }
+    static {
+        try {
+            System.loadLibrary("JniStaticNativeNumberFormatExceptionTest");
+        } catch (UnsatisfiedLinkError e) {
+            System.out.println("======>load:UnsatisfiedLinkError"); // Export LD_LIBRARY_PATH=/data/local/tmp.
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/expected.txt b/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50ecd3e2edcbd78fc15ac3c591ff3fb9a06f1bee
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/expected.txt
@@ -0,0 +1 @@
+------>CheckPoint:CcanContinue
diff --git a/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/test.cfg b/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1bd3d23f5fb126a9d4f72999f519e0731466822c
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0595-rt-eh-StaticNativeNumberFormatExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StaticNativeNumberFormatExceptionTest.java)
+run(StaticNativeNumberFormatExceptionTest)
diff --git a/testsuite/java_test/eh_test/issue-RT0638-rt-eh-ResourceExNumberFormatExceptionTest/ResourceExNumberFormatExceptionTest.java b/testsuite/java_test/eh_test/issue-RT0638-rt-eh-ResourceExNumberFormatExceptionTest/ResourceExNumberFormatExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..342bdf7ccdfeff5b43395e734d9b346e97674b59
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0638-rt-eh-ResourceExNumberFormatExceptionTest/ResourceExNumberFormatExceptionTest.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.*;
+public class ResourceExNumberFormatExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = resourceExNumberFormatExceptionTest();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    public static class MyResource implements AutoCloseable {
+        /**
+         * start fun
+         * @throws NumberFormatException
+        */
+
+        public void start() throws NumberFormatException {
+            if (processResult == 99) {
+                processResult--;
+            }
+            throw new NumberFormatException("start:exception!!!");
+        }
+        @Override
+        public void close() {}
+    }
+    /**
+     * Test 1 try with resource.
+     * @return status code
+    */
+
+    public static int resourceExNumberFormatExceptionTest() throws IOException {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String exception = "";
+        try (MyResource conn = new MyResource()) {
+            conn.start();
+        } catch (NumberFormatException e) {
+            //            e.printStackTrace();
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            e.printStackTrace(new PrintStream(baos)); // 将e的调用栈信息输出到ByteArrayOutputStream
+            InputStream ins = new ByteArrayInputStream(baos.toByteArray()); // 将信息放到InputStream
+            BufferedReader buffer = new BufferedReader(new InputStreamReader(ins, "UTF-8"));
+            int checkFlag = 0;
+            String line = null;
+            while ((line = buffer.readLine()) != null) {
+//                System.out.println(line);
+                if (line.contains("java.lang.NumberFormatException")) {
+                    //                    System.out.println(checkFlag);
+                    checkFlag++;
+                }
+                if (line.contains("ResourceExNumberFormatExceptionTest.java") && line.contains("60")) {
+                    if (checkFlag == 1) {
+                        //                        System.out.println(checkFlag);
+                        checkFlag++;
+                    }
+                }
+                if (line.contains("ResourceExNumberFormatExceptionTest.java") && line.contains("75")) {
+                    if (checkFlag == 2) {
+                        //                        System.out.println(checkFlag);
+                        checkFlag++;
+                    }
+                }
+                if (line.contains("ResourceExNumberFormatExceptionTest.java") && line.contains("40")) {
+                    if (checkFlag == 3) {
+                        checkFlag++;
+                    }
+                }
+                if (line.contains("ResourceExNumberFormatExceptionTest.java") && line.contains("30")) {
+                    if (checkFlag == 4) {
+                        checkFlag++;
+                    }
+                }
+            }
+            if (processResult == 98) {
+                if (checkFlag == 5) {
+                    processResult--;
+                }
+            }
+            result1 = 1;
+        } finally {
+            if (processResult == 97) {
+                processResult--;
+            }
+        }
+        if (processResult == 96) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/issue-RT0638-rt-eh-ResourceExNumberFormatExceptionTest/expected.txt b/testsuite/java_test/eh_test/issue-RT0638-rt-eh-ResourceExNumberFormatExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0638-rt-eh-ResourceExNumberFormatExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/eh_test/issue-RT0638-rt-eh-ResourceExNumberFormatExceptionTest/test.cfg b/testsuite/java_test/eh_test/issue-RT0638-rt-eh-ResourceExNumberFormatExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6afe2d87224aef72ef1e2b77664ce69e2252be22
--- /dev/null
+++ b/testsuite/java_test/eh_test/issue-RT0638-rt-eh-ResourceExNumberFormatExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ResourceExNumberFormatExceptionTest)
+run(ResourceExNumberFormatExceptionTest)
diff --git a/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/NativeCatchExceptionTest.c b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/NativeCatchExceptionTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..3fc1c78f7b9ee15f5c4fad22a1b2f2f18f170e67
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/NativeCatchExceptionTest.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+void native_nativeNativeCatchExceptionTest(JNIEnv *env, jobject obj){
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    (*env)->CallVoidMethod(env, obj, mid);
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env = NULL;
+    jint result = -1;
+
+    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
+        return -1;
+    }
+    assert(env != NULL);
+
+    JNINativeMethod gMethods [] =
+    {
+        {"nativeNativeCatchExceptionTest", "()V", (void*)&native_nativeNativeCatchExceptionTest },
+    };
+
+    jclass cls = (*env)->FindClass(env, "NativeCatchExceptionTest"); //if package is test:"test/NativeCatchExceptionTest"
+    (*env)->RegisterNatives(env, cls, gMethods, 1);
+
+    /* success -- return valid version number */
+    result = JNI_VERSION_1_4;
+
+    return result;
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/NativeCatchExceptionTest.java b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/NativeCatchExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1117a45723a7ba9c811482834e02a29000621887
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/NativeCatchExceptionTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class NativeCatchExceptionTest extends Exception {
+    private static int processResult = 99;
+    static {
+        System.loadLibrary("jniNativeCatchExceptionTest");
+    }
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+    private native void nativeNativeCatchExceptionTest() throws IllegalStateException;
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = nativeCatchExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Asynchronous: Native(exception at callback from Java), captured by Java.
+     * @return status code
+    */
+
+    public static int nativeCatchExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        NativeCatchExceptionTest cTest = new NativeCatchExceptionTest();
+        try {
+            cTest.nativeNativeCatchExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 1;
+            processResult--;
+        } catch (IllegalStateException e2) {
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            processResult -= 10;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/expected.txt b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50ecd3e2edcbd78fc15ac3c591ff3fb9a06f1bee
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/expected.txt
@@ -0,0 +1 @@
+------>CheckPoint:CcanContinue
diff --git a/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/jniNativeCatchExceptionTest.cpp b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/jniNativeCatchExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5c46fb461228929110b35683a67e26dd9b921174
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/jniNativeCatchExceptionTest.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCatchExceptionTest_nativeNativeCatchExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if ( cls == NULL ) {
+        return;
+    }
+
+    mid = env->GetMethodID(cls, "callback", "()V");
+    if ( mid == NULL ) {
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("NativeCatchExceptionTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"nativeNativeCatchExceptionTest", "()V", reinterpret_cast<void*>(Java_NativeCatchExceptionTest_nativeNativeCatchExceptionTest__)},
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/test.cfg b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4278bcc2d0e9d5a6139411b02c7a96679d644ddb
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0023-rt-eh-NativeCatchExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NativeCatchExceptionTest,NATIVE_SRC=jniNativeCatchExceptionTest)
+run(NativeCatchExceptionTest)
diff --git a/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/NativeCodeCheckExceptionTest.c b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/NativeCodeCheckExceptionTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..bd2a45bea5206036c3f43bf3fd8caf4eff3f3a1b
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/NativeCodeCheckExceptionTest.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <assert.h>
+
+void native_nativeNativeCodeCheckExceptionTest (JNIEnv *env, jobject obj){
+
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+    (*env)->CallVoidMethod(env, obj, mid);
+
+    jthrowable exc = (*env)->ExceptionOccurred(env); // catch
+    if(exc){
+        (*env)->Throw(env, exc);
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env = NULL;
+    jint result = -1;
+
+    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
+        return -1;
+    }
+    assert(env != NULL);
+
+        JNINativeMethod gMethods [] =
+        {
+                {"nativeNativeCodeCheckExceptionTest", "()V", (void*)&native_nativeNativeCodeCheckExceptionTest },
+        };
+
+        // if package is test: "test/NativeCodeCheckExceptionTest"
+        jclass cls = (*env)->FindClass(env, "NativeCodeCheckExceptionTest");
+        (*env)->RegisterNatives(env, cls, gMethods, 1);
+
+    /* success -- return valid version number */
+    result = JNI_VERSION_1_4;
+
+    return result;
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/NativeCodeCheckExceptionTest.java b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/NativeCodeCheckExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a90719c0cfc86d40d67ca1796a609aeb3a11c52
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/NativeCodeCheckExceptionTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class NativeCodeCheckExceptionTest extends Exception {
+    static {
+        System.loadLibrary("jniNativeCodeCheckExceptionTest");
+    }
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+    private native void nativeNativeCodeCheckExceptionTest() throws IllegalStateException;
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = nativeCodeCheckExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 3 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Asynchronous: Native(exception at callback from Java, then throw)，captured by Java.
+     * @return status code
+    */
+
+    public static int nativeCodeCheckExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        NativeCodeCheckExceptionTest cTest = new NativeCodeCheckExceptionTest();
+        try {
+            cTest.nativeNativeCodeCheckExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 3;
+            processResult -= 1;
+        } catch (IllegalStateException e2) {
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            processResult -= 10;
+        } finally {
+            processResult -= 3;
+            return result1;
+        }
+    }
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/expected.txt b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50ecd3e2edcbd78fc15ac3c591ff3fb9a06f1bee
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/expected.txt
@@ -0,0 +1 @@
+------>CheckPoint:CcanContinue
diff --git a/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/jniNativeCodeCheckExceptionTest.cpp b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/jniNativeCodeCheckExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b1649dcfe1e536ac2234e1910c2a1644b5e31d76
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/jniNativeCodeCheckExceptionTest.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCodeCheckExceptionTest_nativeNativeCodeCheckExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jthrowable j_exc = NULL;
+    j_exc = env->ExceptionOccurred();
+
+    if(j_exc){
+        env->Throw(j_exc);
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("NativeCodeCheckExceptionTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"nativeNativeCodeCheckExceptionTest", "()V", reinterpret_cast<void*>(Java_NativeCodeCheckExceptionTest_nativeNativeCodeCheckExceptionTest__)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/test.cfg b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5ded805cf55353fc33eb491f1d74dc868c4028de
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NativeCodeCheckExceptionTest,NATIVE_SRC=jniNativeCodeCheckExceptionTest)
+run(NativeCodeCheckExceptionTest)
diff --git a/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/NativeNewExceptionTest.c b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/NativeNewExceptionTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..959e6b574e3dc048d60b388323ee6217319e410d
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/NativeNewExceptionTest.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <assert.h>
+
+void native_nativeNativeNewExceptionTest (JNIEnv *env, jobject obj){
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+    (*env)->CallVoidMethod(env, obj, mid);
+    jclass newExcCls = (*env)->FindClass(env,"java/lang/StringIndexOutOfBoundsException");
+    (*env)->ThrowNew(env,newExcCls,"NativeThrowNew"); // throw new exception
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env = NULL;
+    jint result = -1;
+
+    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
+        return -1;
+    }
+    assert(env != NULL);
+
+        JNINativeMethod gMethods [] =
+        {
+                {"nativeNativeNewExceptionTest", "()V", (void*)&native_nativeNativeNewExceptionTest },
+        };
+
+        // if package is test:"test/NativeNewExceptionTest"
+        jclass cls = (*env)->FindClass(env, "NativeNewExceptionTest");
+        (*env)->RegisterNatives(env, cls, gMethods, 1);
+
+    /* success -- return valid version number */
+    result = JNI_VERSION_1_4;
+    return result;
+}
+
diff --git a/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/NativeNewExceptionTest.java b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/NativeNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..984884190f54545572f7eb437c8cae28070148f0
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/NativeNewExceptionTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class NativeNewExceptionTest extends Exception {
+    static {
+        System.loadLibrary("jniNativeNewExceptionTest");
+    }
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+    private native void nativeNativeNewExceptionTest() throws IllegalStateException;
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = nativeNewExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 3 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Asynchronous: Native(exception-throw new), captured by Java.
+     * @return status code
+    */
+
+    public static int nativeNewExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        NativeNewExceptionTest cTest = new NativeNewExceptionTest();
+        try {
+            cTest.nativeNativeNewExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            processResult -= 10;
+        } catch (IllegalStateException e2) {
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 3;
+            processResult--;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/expected.txt b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50ecd3e2edcbd78fc15ac3c591ff3fb9a06f1bee
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/expected.txt
@@ -0,0 +1 @@
+------>CheckPoint:CcanContinue
diff --git a/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/jniNativeNewExceptionTest.cpp b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/jniNativeNewExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..13882d3e4895c35ea30e9f3d14e45c343870b961
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/jniNativeNewExceptionTest.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeNewExceptionTest_nativeNativeNewExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+    jclass newExcCls = NULL;
+    newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+    if (newExcCls == NULL){
+        return;
+    }
+
+    env->ThrowNew(newExcCls,"NativeThrowNew");
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("NativeNewExceptionTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"nativeNativeNewExceptionTest", "()V", reinterpret_cast<void*>(Java_NativeNewExceptionTest_nativeNativeNewExceptionTest__)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/test.cfg b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..088277c98f033f34beb4820ffe5a54d65f620472
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0025-rt-eh-NativeNewExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NativeNewExceptionTest,NATIVE_SRC=jniNativeNewExceptionTest)
+run(NativeNewExceptionTest)
diff --git a/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/NativeTryCatchNewExceptionTest.c b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/NativeTryCatchNewExceptionTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..f95e9650d50e8d03d4d1c5448c377d1f60299df8
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/NativeTryCatchNewExceptionTest.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <assert.h>
+
+void native_nativeNativeTryCatchNewExceptionTest (JNIEnv *env, jobject obj){
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+    (*env)->CallVoidMethod(env, obj, mid);
+    jclass newExcCls = (*env)->FindClass(env,"java/lang/StringIndexOutOfBoundsException");
+    (*env)->ThrowNew(env,newExcCls,"NativeThrowNew");
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env = NULL;
+    jint result = -1;
+
+    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
+        return -1;
+    }
+    assert(env != NULL);
+
+        JNINativeMethod gMethods [] =
+        {
+                {"nativeNativeTryCatchNewExceptionTest", "()V", (void*)&native_nativeNativeTryCatchNewExceptionTest },
+        };
+        // if package is test:"test/NativeTryCatchNewExceptionTest"
+        jclass cls = (*env)->FindClass(env, "NativeTryCatchNewExceptionTest");
+        (*env)->RegisterNatives(env, cls, gMethods, 1);
+
+    /* success -- return valid version number */
+    result = JNI_VERSION_1_4;
+
+    return result;
+}
+
diff --git a/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/NativeTryCatchNewExceptionTest.java b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/NativeTryCatchNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f480f29e3f2767d8e7043229401b180c50b2d06
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/NativeTryCatchNewExceptionTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class NativeTryCatchNewExceptionTest extends Exception {
+    static {
+        System.loadLibrary("jniNativeTryCatchNewExceptionTest");
+    }
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+    private native void nativeNativeTryCatchNewExceptionTest() throws IllegalArgumentException;
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = nativeTryCatchNewExceptionTest();
+        } catch (Exception e) {
+            processResult--;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Asynchronous: Native(exception at callback from Java-throw new), captured by Java(try-catch).
+     * @return status code
+    */
+
+    public static int nativeTryCatchNewExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        NativeTryCatchNewExceptionTest cTest = new NativeTryCatchNewExceptionTest();
+        try {
+            cTest.nativeNativeTryCatchNewExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            processResult -= 10;
+        } catch (IllegalStateException e2) {
+            processResult -= 10;
+        } finally {
+            processResult -= 3;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/expected.txt b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50ecd3e2edcbd78fc15ac3c591ff3fb9a06f1bee
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/expected.txt
@@ -0,0 +1 @@
+------>CheckPoint:CcanContinue
diff --git a/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/jniNativeTryCatchNewExceptionTest.cpp b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/jniNativeTryCatchNewExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a6e37a34ecf5af3c2bf0e2035f13b12e959125d0
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/jniNativeTryCatchNewExceptionTest.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeTryCatchNewExceptionTest_nativeNativeTryCatchNewExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jclass newExcCls = NULL;
+    newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+    if (newExcCls == NULL){
+        return;
+    }
+
+    env->ThrowNew(newExcCls,"NativeThrowNew");
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("NativeTryCatchNewExceptionTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"nativeNativeTryCatchNewExceptionTest", "()V", reinterpret_cast<void*>(Java_NativeTryCatchNewExceptionTest_nativeNativeTryCatchNewExceptionTest__)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/test.cfg b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c13b7ac6b4c627fb6533b30cf23d24f75aa61743
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NativeTryCatchNewExceptionTest,NATIVE_SRC=jniNativeTryCatchNewExceptionTest)
+run(NativeTryCatchNewExceptionTest)
diff --git a/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/NativeCodeCheckNewExceptionTest.c b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/NativeCodeCheckNewExceptionTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..a63e9f8839c28f6f86f2796691fbd578a954b84d
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/NativeCodeCheckNewExceptionTest.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+
+#include <stdio.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <assert.h>
+
+void native_NativeExcpAsync06150 (JNIEnv *env, jobject obj){
+
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+    (*env)->CallVoidMethod(env, obj, mid); // NumberFormatException:"Java_Method_throw_xxx"
+
+    jthrowable exc = (*env)->ExceptionOccurred(env); // catch
+    if(exc){
+        jclass newExcCls = (*env)->FindClass(env,"java/lang/StringIndexOutOfBoundsException");
+        (*env)->ThrowNew(env,newExcCls,"NativeThrowNew"); // throw new exception
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env = NULL;
+    jint result = -1;
+
+    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
+        return -1;
+    }
+    assert(env != NULL);
+
+        JNINativeMethod gMethods [] =
+        {
+                {"NativeExcpAsync06150", "()V", (void*)&native_NativeExcpAsync06150 },
+        };
+
+        jclass cls = (*env)->FindClass(env, "ExcpAsync06150");  //if package is test:"test/ExcpAsync06110"
+        (*env)->RegisterNatives(env, cls, gMethods, 1);
+
+    /* success -- return valid version number */
+    result = JNI_VERSION_1_4;
+
+    return result;
+}
+
+
diff --git a/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/NativeCodeCheckNewExceptionTest.java b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/NativeCodeCheckNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d1e647e4182f586a3f1c06fd9fd9f0aaff156bfb
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/NativeCodeCheckNewExceptionTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+public class NativeCodeCheckNewExceptionTest extends Exception {
+    static {
+        System.loadLibrary("jniNativeCodeCheckNewExceptionTest");
+    }
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+    private native void nativeNativeCodeCheckNewExceptionTest() throws InvalidPathException;
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = nativeCodeCheckNewExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Asynchronous: Native(exception at callback from Java, then Occurred-throw new), catch by Java.
+     * @return status code
+    */
+
+    public static int nativeCodeCheckNewExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        NativeCodeCheckNewExceptionTest cTest = new NativeCodeCheckNewExceptionTest();
+        try {
+            cTest.nativeNativeCodeCheckNewExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 3;
+            System.out.println("======>" + e1.getMessage());
+            processResult -= 10;
+        } catch (InvalidPathException e2) {
+            result1 = 3;
+            System.out.println("======>" + e2.getMessage());
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 1;
+            processResult--;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/expected.txt b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50ecd3e2edcbd78fc15ac3c591ff3fb9a06f1bee
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/expected.txt
@@ -0,0 +1 @@
+------>CheckPoint:CcanContinue
diff --git a/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/jniNativeCodeCheckNewExceptionTest.cpp b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/jniNativeCodeCheckNewExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..537e069736cd545826d83afa67c8249c98e24021
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/jniNativeCodeCheckNewExceptionTest.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCodeCheckNewExceptionTest_nativeNativeCodeCheckNewExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jthrowable j_exc =NULL;
+    j_exc=env->ExceptionOccurred();
+    if (j_exc == NULL){
+        return;
+    }
+
+    if (j_exc){
+        jclass newExcCls = NULL;
+        newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+        if (newExcCls == NULL){
+            return;
+        }
+        env->ThrowNew(newExcCls,"NativeThrowNew");
+    }
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("NativeCodeCheckNewExceptionTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"nativeNativeCodeCheckNewExceptionTest", "()V", reinterpret_cast<void*>(Java_NativeCodeCheckNewExceptionTest_nativeNativeCodeCheckNewExceptionTest__)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/test.cfg b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b99630a835be559f530b864b1b8dff6bec962dd5
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0027-rt-eh-NativeCodeCheckNewExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NativeCodeCheckNewExceptionTest,NATIVE_SRC=jniNativeCodeCheckNewExceptionTest)
+run(NativeCodeCheckNewExceptionTest)
diff --git a/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/NativeClearExceptionTest.c b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/NativeClearExceptionTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..0ff1015e8941d25e1314798fd56e9c0aaa57dedb
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/NativeClearExceptionTest.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <assert.h>
+
+void native_nativeNativeClearExceptionTest (JNIEnv *env, jobject obj){
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+    return;
+    }
+    (*env)->CallVoidMethod(env, obj, mid); // NumberFormatException:"Java_Method_throw_xxx"
+
+    jthrowable exc = (*env)->ExceptionOccurred(env); // catch
+    if(exc){
+        jclass newExcCls = (*env)->FindClass(env,"java/lang/StringIndexOutOfBoundsException");
+        (*env)->ThrowNew(env,newExcCls,"NativeThrowNew"); // throw new exception
+        (*env)->ExceptionClear(env);
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env = NULL;
+    jint result = -1;
+
+    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
+        return -1;
+    }
+    assert(env != NULL);
+
+        JNINativeMethod gMethods [] =
+        {
+                {"nativeNativeClearExceptionTest", "()V", (void*)&native_nativeNativeClearExceptionTest },
+        };
+
+        //if package is test:"test/NativeClearExceptionTest"
+        jclass cls = (*env)->FindClass(env, "NativeClearExceptionTest");
+        (*env)->RegisterNatives(env, cls, gMethods, 1);
+
+    /* success -- return valid version number */
+    result = JNI_VERSION_1_4;
+
+    return result;
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/NativeClearExceptionTest.java b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/NativeClearExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..baf9d7c31aea0a6ef35a17525bef9cb0bda15da9
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/NativeClearExceptionTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+public class NativeClearExceptionTest extends Exception {
+    static {
+        System.loadLibrary("jniNativeClearExceptionTest");
+    }
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+    private native void nativeNativeClearExceptionTest() throws InvalidPathException;
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = nativeClearExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     * Asynchronous: Native(exception at callback from Java, then Occurred-throw new-clear).
+     * @return status code
+    */
+
+    public static int nativeClearExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        NativeClearExceptionTest cTest = new NativeClearExceptionTest();
+        try {
+            cTest.nativeNativeClearExceptionTest();
+            processResult -= 1;
+        } catch (NumberFormatException e1) {
+            result1 = 3;
+            System.out.println("======>" + e1.getMessage());
+            processResult -= 10;
+        } catch (InvalidPathException e2) {
+            result1 = 3;
+            System.out.println("======>" + e2.getMessage());
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 3;
+            System.out.println("======>" + e3.getMessage());
+            processResult -= 10;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/expected.txt b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50ecd3e2edcbd78fc15ac3c591ff3fb9a06f1bee
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/expected.txt
@@ -0,0 +1 @@
+------>CheckPoint:CcanContinue
diff --git a/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/jniNativeClearExceptionTest.cpp b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/jniNativeClearExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dc111d3d5804ea4e5d8eb4a7b1efc1957784de4a
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/jniNativeClearExceptionTest.cpp
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeClearExceptionTest_nativeNativeClearExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jthrowable j_exc =NULL;
+    j_exc=env->ExceptionOccurred();
+    if (j_exc == NULL){
+        return;
+    }
+
+    if (j_exc){
+        jclass newExcCls = NULL;
+        newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+        if (newExcCls == NULL){
+            return;
+        }
+        env->ThrowNew(newExcCls,"NativeThrowNew");
+        env->ExceptionClear();
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("NativeClearExceptionTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"nativeNativeClearExceptionTest", "()V", reinterpret_cast<void*>(Java_NativeClearExceptionTest_nativeNativeClearExceptionTest__)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/test.cfg b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c640d7e0a3462efb82caddaa9f5909942a249d4f
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0028-rt-eh-NativeClearExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NativeClearExceptionTest,NATIVE_SRC=jniNativeClearExceptionTest)
+run(NativeClearExceptionTest)
diff --git a/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/NativeCodeCatchThrowNewExceptionTest.c b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/NativeCodeCatchThrowNewExceptionTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..89934cb53d3c37d105416927394091f6b08a624b
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/NativeCodeCatchThrowNewExceptionTest.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <assert.h>
+
+void native_nativeNativeCodeCatchThrowNewExceptionTest (JNIEnv *env, jobject obj){
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+    (*env)->CallVoidMethod(env, obj, mid); // NumberFormatException:"Java_Method_throw_xxx"
+
+    jboolean chk = (*env)->ExceptionCheck(env);
+
+    if(chk){
+        jclass newExcCls = (*env)->FindClass(env,"java/lang/StringIndexOutOfBoundsException");
+        (*env)->ThrowNew(env,newExcCls,"NativeThrowNew"); // Throw new exception
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env = NULL;
+    jint result = -1;
+
+    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
+        return -1;
+    }
+    assert(env != NULL);
+
+        JNINativeMethod gMethods [] =
+        {
+                {"nativeNativeCodeCatchThrowNewExceptionTest", "()V", (void*)&native_nativeNativeCodeCatchThrowNewExceptionTest },
+        };
+
+         //if package is test:"test/NativeCodeCatchThrowNewExceptionTest"
+        jclass cls = (*env)->FindClass(env, "NativeCodeCatchThrowNewExceptionTest");
+        (*env)->RegisterNatives(env, cls, gMethods, 1);
+
+    /* success -- return valid version number */
+    result = JNI_VERSION_1_4;
+
+    return result;
+}
+
+
diff --git a/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/NativeCodeCatchThrowNewExceptionTest.java b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/NativeCodeCatchThrowNewExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8748620cda49260c47d20e2c65c7266efe7d8b84
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/NativeCodeCatchThrowNewExceptionTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+public class NativeCodeCatchThrowNewExceptionTest extends Exception {
+    static {
+        System.loadLibrary("jniNativeCodeCatchThrowNewExceptionTest");
+    }
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+    private native void nativeNativeCodeCatchThrowNewExceptionTest() throws InvalidPathException;
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = nativeCodeCatchThrowNewExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     *  Asynchronous: Native(exception at callback from Java, then check-throw new), captured by Java.
+     * @return status code
+    */
+
+    public static int nativeCodeCatchThrowNewExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        NativeCodeCatchThrowNewExceptionTest cTest = new NativeCodeCatchThrowNewExceptionTest();
+        try {
+            cTest.nativeNativeCodeCatchThrowNewExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 3;
+            System.out.println("======>" + e1.getMessage());
+            processResult -= 10;
+        } catch (InvalidPathException e2) {
+            result1 = 3;
+            System.out.println("======>" + e2.getMessage());
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 1;
+            processResult--;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/expected.txt b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50ecd3e2edcbd78fc15ac3c591ff3fb9a06f1bee
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/expected.txt
@@ -0,0 +1 @@
+------>CheckPoint:CcanContinue
diff --git a/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/jniNativeCodeCatchThrowNewExceptionTest.cpp b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/jniNativeCodeCatchThrowNewExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..38b53f3a76b6f6f4a379bbdc93ad3ed80ad2c2cd
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/jniNativeCodeCatchThrowNewExceptionTest.cpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCodeCatchThrowNewExceptionTest_nativeNativeCodeCatchThrowNewExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+
+    jboolean chk = '\0';
+    chk = env->ExceptionCheck();
+    if (chk == '\0'){
+        return;
+    }
+
+    if (chk){
+        jclass newExcCls = NULL;
+        newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException");
+        if (newExcCls == NULL){
+            return;
+        }
+        env->ThrowNew(newExcCls,"NativeThrowNew");
+    }
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("NativeCodeCatchThrowNewExceptionTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"nativeNativeCodeCatchThrowNewExceptionTest", "()V", reinterpret_cast<void*>(Java_NativeCodeCatchThrowNewExceptionTest_nativeNativeCodeCatchThrowNewExceptionTest__)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/test.cfg b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a51f325ae80c7fdd6ee0ff9c58a754b90205430
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NativeCodeCatchThrowNewExceptionTest,NATIVE_SRC=jniNativeCodeCatchThrowNewExceptionTest)
+run(NativeCodeCatchThrowNewExceptionTest)
diff --git a/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/NativeCheckFatalErrorExceptionTest.java b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/NativeCheckFatalErrorExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8740e0f5b52aee74702d2ecf7fce33a1896df4df
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/NativeCheckFatalErrorExceptionTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.file.InvalidPathException;
+public class NativeCheckFatalErrorExceptionTest extends Exception {
+    static {
+        System.loadLibrary("jniNativeCheckFatalErrorExceptionTest");
+    }
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.exit(run(argv, System.out));
+    }
+    private native void nativeNativeCheckFatalErrorExceptionTest() throws InvalidPathException;
+    private void callback() throws NumberFormatException {
+        throw new NumberFormatException("JavaMethodThrows");
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = nativeCheckFatalErrorExceptionTest();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    /**
+     *  Asynchronous: Native(exception at callback from Java, then FatalError), catch by Java.
+     * @return status code
+    */
+
+    public static int nativeCheckFatalErrorExceptionTest() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        NativeCheckFatalErrorExceptionTest cTest = new NativeCheckFatalErrorExceptionTest();
+        try {
+            cTest.nativeNativeCheckFatalErrorExceptionTest();
+            processResult -= 10;
+        } catch (NumberFormatException e1) {
+            result1 = 1;
+            System.out.println("======>" + e1.getMessage());
+            processResult--;
+        } catch (InvalidPathException e2) {
+            result1 = 3;
+            System.out.println("======>" + e2.getMessage());
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e3) {
+            result1 = 3;
+            processResult -= 10;
+        }
+        processResult -= 3;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/NativeCheckFatalErrorTest.c b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/NativeCheckFatalErrorTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..5b7123bfe6910dc8c7c6a14fa82df0a217bb60af
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/NativeCheckFatalErrorTest.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <assert.h>
+
+void native_nativeNativeCheckFatalErrorExceptionTest (JNIEnv *env, jobject obj){
+
+    jclass cls = (*env)->GetObjectClass(env, obj);
+    jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+    (*env)->CallVoidMethod(env, obj, mid); // NumberFormatException:"Java_Method_throw_xxx"
+
+    (*env)->FatalError(env,"------>CheckPoint:FatalError");
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env = NULL;
+    jint result = -1;
+
+    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
+        return -1;
+    }
+    assert(env != NULL);
+
+        JNINativeMethod gMethods [] =
+        {
+            {"nativeNativeCheckFatalErrorExceptionTest", "()V", (void*)&native_nativeNativeCheckFatalErrorExceptionTest},
+        };
+
+        jclass cls = (*env)->FindClass(env, "NativeCheckFatalErrorExceptionTest");  // if package is test:"test/ExcpAsync06110"
+        (*env)->RegisterNatives(env, cls, gMethods, 1);
+
+    /* success -- return valid version number */
+    result = JNI_VERSION_1_4;
+
+    return result;
+}
\ No newline at end of file
diff --git a/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/expected.txt b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b2be12b8908ac503d84094b43385256ebcfb311b
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/expected.txt
@@ -0,0 +1,2 @@
+------>CheckPoint:CcanContinue
+======>JavaMethodThrows
diff --git a/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/jniNativeCheckFatalErrorExceptionTest.cpp b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/jniNativeCheckFatalErrorExceptionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4cfc6a93c444fe869f984a5e568d874c03b4aac
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/jniNativeCheckFatalErrorExceptionTest.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT void JNICALL Java_NativeCheckFatalErrorExceptionTest_nativeNativeCheckFatalErrorExceptionTest__
+(JNIEnv *env, jobject j_obj)
+{
+    jclass cls = NULL;
+    jmethodID mid = NULL;
+
+    cls = env->GetObjectClass(j_obj);
+    if (cls == NULL){
+        return;
+    }
+    mid = env->GetMethodID(cls,"callback", "()V");
+    if (mid == NULL){
+        return;
+    }
+
+    env->CallVoidMethod(j_obj, mid);
+    env->FatalError("------>CheckPoint:FatalError");
+
+    printf("------>CheckPoint:CcanContinue\n");
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("NativeCheckFatalErrorExceptionTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"nativeNativeCheckFatalErrorExceptionTest", "()V", reinterpret_cast<void*>(Java_NativeCheckFatalErrorExceptionTest_nativeNativeCheckFatalErrorExceptionTest__)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+
+}
diff --git a/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/test.cfg b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8337a06e65c2d7135a2a605066effd2b8f7b926e
--- /dev/null
+++ b/testsuite/java_test/eh_test/native_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NativeCheckFatalErrorExceptionTest,NATIVE_SRC=jniNativeCheckFatalErrorExceptionTest)
+run(NativeCheckFatalErrorExceptionTest)
diff --git a/testsuite/java_test/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/Message125004.java b/testsuite/java_test/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/Message125004.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e4df93cc832d3f4bc34f51a70e9ed87f5440c6b
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/Message125004.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class Message125004 {
+    private static int RES = 99;
+    private static Class<?> clazz;
+    public static void main(String[] args){
+        int result;
+        try{
+            result = message125004();
+            if(result == 4 && Message125004.RES == 89){
+                result = 0;
+            }
+            System.out.println(result);
+        }catch(Exception e){
+            e.printStackTrace();
+        }
+    }
+    /**测试实例：[{NeedRandomClass=java.io.PipedReader}]     测试入参：abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ257     测试api信息：java.lang.Class
+     *  测试api信息：getField
+     测试api信息：String
+    */
+
+    public static int message125004() {
+        try {
+            clazz = Class.forName("java.lang.Class");
+            Method method = clazz.getMethod("getField",java.lang.String.class);
+            String parameters1 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ257";
+            Class instance = Class.forName("java.io.PipedReader") ;
+            Object result1 = method.invoke(instance, parameters1);
+            Message125004.RES -= 10;
+            return 4;
+            } catch (InvocationTargetException e) {
+                // 只打印类型 由Agent端接受进行对比
+                // 打印全错误信息
+//                e.printStackTrace();
+                Message125004.RES -= 10;
+                return 4;
+            } catch (Exception e) {
+            // 只打印类型 由Agent端接受进行对比
+            // 打印全错误信息
+//            e.printStackTrace();
+            Message125004.RES -= 10;
+            return 4;
+        }
+    }
+}
diff --git a/testsuite/java_test/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/expected.txt b/testsuite/java_test/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/test.cfg b/testsuite/java_test/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..74d189da45509d851480a425c6d2266e451e70cb
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0001-rt-fuzzapi-PipedReaderEH/test.cfg
@@ -0,0 +1,2 @@
+compile(Message125004)
+run(Message125004)
diff --git a/testsuite/java_test/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/Message011706.java b/testsuite/java_test/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/Message011706.java
new file mode 100755
index 0000000000000000000000000000000000000000..5d37a3b97aca3ccf3b11ef9aaaf0fa68aabbbb5b
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/Message011706.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.*;
+import java.util.*;
+public class Message011706 {
+    public static Class<?> clazz;
+    private static List<Object> resultlist = new LinkedList<>();
+    public static void main(String[] args) {
+        try {
+            System.out.println(messageCommonUse());
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+    public static int messageCommonUse() {
+        try {
+            clazz = Class.forName("java.lang.reflect.Method");
+            Method method = clazz.getMethod("invoke",Object.class,Object[].class);
+            String fcn2 = "java.util.concurrent.ConcurrentHashMap";
+            int mIndex6 = 1;
+            Method[] methods2 = Class.forName(fcn2).getDeclaredMethods();
+            Arrays.sort(methods2, new ConstructorComparator());
+            Object instance =  methods2[mIndex6];
+            Constructor con = java.lang.StringBuffer.class.getDeclaredConstructor();
+            Object param1 = con.newInstance();
+            Object param2[] = new Object[4];
+            Constructor con0 = java.lang.StringBuffer.class.getDeclaredConstructor();
+            param2[0] = con0.newInstance();
+            Constructor con1 = java.security.spec.MGF1ParameterSpec.class.getDeclaredConstructor(java.lang.String.class);
+            param2[1] = con1.newInstance("abcdefghijklmnopqrstuvwxxzABCDEFGHIJKLMNOPQRSTUVWXYZ-9223372036854775551");
+            Constructor con2 = java.util.Stack.class.getDeclaredConstructor();
+            param2[2] = con2.newInstance();
+            Constructor con3 = java.security.spec.ECGenParameterSpec.class.getDeclaredConstructor(java.lang.String.class);
+            param2[3] = con3.newInstance("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
+            Object Result = method.invoke(instance,param1,param2);
+            System.out.println(Result);
+        }  catch (Exception e) {
+            if (e.toString().equals("java.lang.reflect.InvocationTargetException") &&
+                    e.getCause().getClass().getName().toString().equals("java.lang.IllegalArgumentException"))
+            {
+                return 0;
+            }
+        }
+        return -1;
+    }
+}
+class ConstructorComparator implements Comparator<Object>{
+    @Override
+    public int compare(Object c1, Object c2){
+        byte[] b1 = c1.toString().getBytes();
+        byte[] b2 = c2.toString().getBytes();
+        int len = (b1.length<b2.length?b1.length:b2.length);
+        for(int i = 0; i<len; i++){
+            if(b1[i]<b2[i]){
+                return 1;
+            }else if (b1[i]>b2[i]){
+                return -1;
+            }
+        }
+        if(b1.length > b2.length){
+            return -1;
+        }else if(b1.length < b2.length){
+            return 1;
+        }
+        return 1;
+    }
+}
diff --git a/testsuite/java_test/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/expected.txt b/testsuite/java_test/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/test.cfg b/testsuite/java_test/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4046378ca419bdfbc6ddf914d3decb5d56a6cdb1
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0002-rt-fuzzapi-EHOrder/test.cfg
@@ -0,0 +1,2 @@
+compile(Message011706)
+run(Message011706)
diff --git a/testsuite/java_test/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/ThreadcountStackFramesTest.java b/testsuite/java_test/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/ThreadcountStackFramesTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c3091a955931954ce0633bb64e55b01f4ef534b
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/ThreadcountStackFramesTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadcountStackFramesTest {
+	static int RES = 99;
+	public static void main(String[] args) {
+		System.out.println(run());
+	}
+	private static int run() {
+		int result;
+		result = countStackFramesTest();
+		if(result == 4 && ThreadcountStackFramesTest.RES == 89) {
+			result = 0;
+		}
+		return result;
+	}
+	private static int countStackFramesTest() {
+		Runnable ra = new MyThread1();
+		String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ4294967295";
+		Thread t = new Thread(ra, str);
+		@SuppressWarnings("deprecation")
+		int i = t.countStackFrames();
+		if(i == 0) {
+			ThreadcountStackFramesTest.RES -= 10;
+		}
+		return 4;
+	}
+}
+class MyThread1 implements Runnable {
+    private int ticket = 10;
+    @SuppressWarnings("unused")
+	private String name;
+    public void run() {
+            for (int i = 0; i < 500; i++) {
+                    if (this.ticket > 0) {
+                            System.out.println(Thread.currentThread().getName() + "---->" + (this.ticket--));
+                    }
+            }
+    }
+    public Object handler() {
+            Thread thread = new Thread(new MyThread1());
+            thread.setUncaughtExceptionHandler(new MyExceptionHandler());
+            thread.start();
+            return thread.getUncaughtExceptionHandler();
+    }
+    class MyExceptionHandler implements Thread.UncaughtExceptionHandler {
+            public void uncaughtException(Thread t, Throwable e) {
+                    System.out.printf("An exception has been captured\n");
+                    System.out.printf("Thread:%s\n", t.getName());
+                    System.out.printf("Exception: %s: %s:\n", e.getClass().getName(), e.getMessage());
+                    System.out.printf("Stack Trace:\n");
+                    e.printStackTrace();
+                    System.out.printf("Thread status:%s\n", t.getState());
+            }
+    }
+}
diff --git a/testsuite/java_test/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/expected.txt b/testsuite/java_test/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/test.cfg b/testsuite/java_test/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..49de69e8bbd70acd90690bae3bf7f9b58e6850f2
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0003-rt-fuzzapi-noStartThreadInfo/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadcountStackFramesTest)
+run(ThreadcountStackFramesTest)
diff --git a/testsuite/java_test/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/Message021404.java b/testsuite/java_test/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/Message021404.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab4dd2a44492c2566c4f76855bcfed84e5383812
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/Message021404.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class Message021404 {
+    private static int res = 99;
+    public static void main(String[] args){
+        try{
+            System.out.println(run());
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+    private static int run() throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
+        int result;
+        result = message021404();
+        if(result == 4 && Message021404.res == 89){
+            result = 0;
+        }
+        return result;
+    }
+    private static int message021404() throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
+        Field f = Unsafe.class.getDeclaredField("theUnsafe");
+        f.setAccessible(true);
+        Unsafe s = (Unsafe)f.get(null);
+        Method m = Unsafe.class.getDeclaredMethod("getUnsafe");
+        m.invoke(s);
+        Message021404.res -= 10;
+        return 4;
+    }
+}
diff --git a/testsuite/java_test/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/expected.txt b/testsuite/java_test/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/test.cfg b/testsuite/java_test/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a3d74cb4c57b6779abf9cdeed6236664db5ff756
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/RT0004-rt-fuzzapi-stackframeless/test.cfg
@@ -0,0 +1,2 @@
+compile(Message021404)
+run(Message021404)
diff --git a/testsuite/java_test/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/Message61004.java b/testsuite/java_test/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/Message61004.java
new file mode 100755
index 0000000000000000000000000000000000000000..6da2b56fc56e39eb7d1b8733a5f9440a884c1bd4
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/Message61004.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class Message61004 {
+    private static int RES = 99;
+    private static Class<?> clazz;
+    public static void main(String[] args) {
+//message61104();
+        int result = 2;
+        try {
+            result = message61004();
+            if(result == 4 && Message61004.RES == 89){
+                result = 0;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        System.out.println(result);
+    }
+    /*    测试实例：测试入参：1389308892测试入参：-1727641912测试api信息：java.lang.String测试api信息：substring测试api信息：int测试api信息：int
+    */
+
+    private static int message61004() {
+        String str = null;
+        try {
+            clazz = Class.forName("java.lang.String");
+//            Method[] met = clazz.getMethods();
+//            Method method = clazz.getMethod("substring", int.class, int.class);
+            int parameters1 = 1389308892;
+            int parameters2 = -1727641912;
+            String instance = new String();
+            instance.substring(parameters1, parameters2);
+//            Object result1 = method.invoke(instance, parameters1, parameters2);
+        } catch (Error e) {
+            str = e.getClass().toString();
+            //System.out.println(str);
+            //e.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if(str != null && str.equals("class java.lang.OutOfMemoryError")){
+            Message61004.RES -= 10;
+        }
+        return 4;
+    }
+}
diff --git a/testsuite/java_test/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/expected.txt b/testsuite/java_test/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/test.cfg b/testsuite/java_test/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fb9b2879be9cfde7e19cfdb1375d3a47304d8d2b
--- /dev/null
+++ b/testsuite/java_test/fuzzapi_test/issue-RT0901-rt-fuzzapi-Message61004-subStringOOM/test.cfg
@@ -0,0 +1,2 @@
+compile(Message61004.java)
+run(Message61004)
diff --git a/testsuite/java_test/gconly_test/GC0001-GCOnly_WeakRefTest01/GCOnly_WeakRefTest01.java b/testsuite/java_test/gconly_test/GC0001-GCOnly_WeakRefTest01/GCOnly_WeakRefTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..875f449f35d9e9c568a5514db90b9e9a91787d23
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0001-GCOnly_WeakRefTest01/GCOnly_WeakRefTest01.java
@@ -0,0 +1,70 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_GCOnly_WeakRefTest01
+ *- @TestCaseName: GCOnly_WeakRefTest01
+ *- @TestCaseType: Function Testing for WeakReference Test
+ *- @RequirementID: AR000D0OR9
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，弱引用内存回收正确。
+ *  -#step1: 创建一个弱引用，判断该引用可以通过get（）正常获得object;
+ *  -#step2: 在一个线程中创建一个60个无RP关联的弱引用，再次判断步骤一里创建的弱引用仍然可以通过get()方法获得对象。
+ *  -#step3: 触发用户GC，判断该引用被回收到的RP中。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: GCOnly_WeakRefTest01.java
+ *- @ExecuteClass: GCOnly_WeakRefTest01
+ *- @ExecuteArgs:
+ *- @Remark:RC0304-rc-function-Ref-WeakRefTest
+ *- @Author:zhangwenlong 00292413
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class GCOnly_WeakRefTest01 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int aa = 100;
+
+    static void setWeakReference() {
+        rp = new WeakReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            aa++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        setWeakReference();
+        new Thread(new TriggerRP()).start();
+        Thread.sleep(3000);
+        if (rp.get() == null) {
+            aa++;
+        }
+        Runtime.getRuntime().gc();
+        Reference rr;
+        while ((rr = rq.poll()) != null) {
+            if (!rr.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                aa++;
+            }
+        }
+
+        if (aa == 100) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 60; i++) {
+                WeakReference wr = new WeakReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (InterruptedException e) {
+                    // do nothing
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/gconly_test/GC0001-GCOnly_WeakRefTest01/expected.txt b/testsuite/java_test/gconly_test/GC0001-GCOnly_WeakRefTest01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0001-GCOnly_WeakRefTest01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/gconly_test/GC0001-GCOnly_WeakRefTest01/test.cfg b/testsuite/java_test/gconly_test/GC0001-GCOnly_WeakRefTest01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ccec264cacc6811819b1bbfa3cff46b42d20b439
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0001-GCOnly_WeakRefTest01/test.cfg
@@ -0,0 +1,2 @@
+compile(GCOnly_WeakRefTest01)
+run(GCOnly_WeakRefTest01)
diff --git a/testsuite/java_test/gconly_test/GC0002-GCOnly_WeakRefTest02/GCOnly_WeakRefTest02.java b/testsuite/java_test/gconly_test/GC0002-GCOnly_WeakRefTest02/GCOnly_WeakRefTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d2598d4e26fbc2310931c575d7a19cd6b603a7d
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0002-GCOnly_WeakRefTest02/GCOnly_WeakRefTest02.java
@@ -0,0 +1,190 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_GCOnly_WeakRefTest02
+ *- @TestCaseName: GCOnly_WeakRefTest02
+ *- @TestCaseType: Function Testing for WeakReference Test
+ *- @RequirementID: AR000D0OR9
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 无
+ *- @Brief:测试正常情况下，弱引用内存回收正确。
+ * -#step1: 分别创建CycleA、CycleB、CycleC、CycleD 四个类的对象，均含有弱引用，并且这四个对象互为循环引用；
+ * -#step2: 分别取出step1中四个对象的sum属性的值，计算它们的和并赋值给allSum；
+ * -#step3: 触发GC；
+ * -#step4: 确认四个类的对象的引用均已经释放；
+ * -#step5: 将step1中CycleA的实例对象cycleA赋值为null；
+ * -#step6: 让当前线程休眠2000ms；
+ * -#step7: 经判断得出step1中的四个实例对象均为null；
+ * -#step8: 分别判断allSum和checkCount的值，并确定step1中四个互为循环引用的对象为弱引用；
+ * -#step9: 分别判断allSum和checkCount的值，并确定step1中四个互为循环引用的对象为弱引用；
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: GCOnly_WeakRefTest02.java
+ *- @ExecuteClass: GCOnly_WeakRefTest02
+ *- @ExecuteArgs:
+ *- @Remark:RC0339-rc-rp-CycleAll_weak
+ *- @Author:zhangwenlong 00292413
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+
+public class GCOnly_WeakRefTest02 {
+    static int checkCount = 0;
+    static final int TEST_NUM = 1;
+    static int allSum;
+
+    public static void main(String[] args) {
+        checkCount = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            test01();
+            if (allSum == 20) {
+                checkCount++;
+                System.out.println("sum is wrong");
+            }
+
+            if (checkCount == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println("errorResult ---- checkCount: " + checkCount);
+            }
+        }
+    }
+
+    private static void test01() {
+        CycleA cycleA = new CycleA();
+        cycleA.cyb = new CycleB();
+        cycleA.cyb.cyc = new CycleC();
+        cycleA.cyb.cyc.cyd = new CycleD();
+        cycleA.cyb.cyc.cyd.cya = cycleA;
+        allSum = cycleA.sum + cycleA.cyb.sum + cycleA.cyb.cyc.sum + cycleA.cyb.cyc.cyd.sum;
+        Runtime.getRuntime().gc();
+        if ((cycleA.wr.get() != null) || (cycleA.cyb.sr.get() != null) || (cycleA.cyb.cyc.pr.get() != null)
+                || (cycleA.cyb.cyc.cyd.str.get() != null)) {
+            checkCount++;
+        }
+        cycleA = null;
+        sleep(2000);
+        if (cycleA != null && cycleA.cyb != null && cycleA.cyb.cyc != null && cycleA.cyb.cyc.cyd != null
+                && cycleA.cyb.cyc.cyd.cya != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " [test01]a1 has not free");
+        }
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+
+class CycleA {
+    Reference wr;
+    CycleB cyb;
+    int aNum;
+    int sum;
+    static StringBuffer stringBufferA = new StringBuffer("ref_processor_CycleA");
+
+    CycleA() {
+        stringBufferA = new StringBuffer("ref_processor_CycleA");
+        wr = new WeakReference<>(stringBufferA);
+        if (wr.get() == null) {
+            assert false;
+        }
+        stringBufferA = null;
+        cyb = null;
+        aNum = 1;
+    }
+
+    int joinStr() {
+        try {
+            sum = aNum + cyb.bNum;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+        return sum;
+    }
+}
+
+class CycleB {
+    Reference sr;
+    CycleC cyc;
+    int bNum;
+    int sum;
+    static StringBuffer stringBufferB = new StringBuffer("ref_processor_CycleB");
+
+    CycleB() {
+        stringBufferB = new StringBuffer("ref_processor_CycleB");
+        sr = new WeakReference<>(stringBufferB);
+        if (sr.get() == null) {
+            assert false;
+        }
+        stringBufferB = null;
+        cyc = null;
+        bNum = 2;
+    }
+
+    int joinStr() {
+        try {
+            sum = bNum + cyc.cNum;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+        return sum;
+    }
+}
+
+class CycleC {
+    Reference pr;
+    CycleD cyd;
+    StringBuffer stringBufferC = new StringBuffer("ref_processor_CycleC");
+    int sum;
+    int cNum;
+
+    CycleC() {
+        stringBufferC = new StringBuffer("ref_processor_CycleC");
+        pr = new WeakReference<>(stringBufferC);
+        if (pr.get() == null) {
+            assert false;
+        }
+        stringBufferC = null;
+        cyd = null;
+        cNum = 3;
+    }
+
+    int joinStr() {
+        try {
+            sum = cNum + cyd.dNum;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+        return sum;
+    }
+}
+
+class CycleD {
+    Reference str;
+    CycleA cya;
+    StringBuffer stringBufferD = new StringBuffer("ref_processor_CycleD");
+    int dNum;
+    int sum;
+
+    CycleD() {
+        stringBufferD = new StringBuffer("ref_processor_CycleD");
+        str = new WeakReference<StringBuffer>(stringBufferD);
+        stringBufferD = null;
+        cya = null;
+        dNum = 4;
+    }
+
+    int joinStr() {
+        try {
+            sum = dNum + cya.aNum;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+        return sum;
+    }
+}
+
diff --git a/testsuite/java_test/gconly_test/GC0002-GCOnly_WeakRefTest02/expected.txt b/testsuite/java_test/gconly_test/GC0002-GCOnly_WeakRefTest02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0002-GCOnly_WeakRefTest02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/gconly_test/GC0002-GCOnly_WeakRefTest02/test.cfg b/testsuite/java_test/gconly_test/GC0002-GCOnly_WeakRefTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..442ec6370685ecf6030f7a1bc8fc6715e1973a03
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0002-GCOnly_WeakRefTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(GCOnly_WeakRefTest02)
+run(GCOnly_WeakRefTest02)
diff --git a/testsuite/java_test/gconly_test/GC0003-GCOnly_WeakRefTest03/GCOnly_WeakRefTest03.java b/testsuite/java_test/gconly_test/GC0003-GCOnly_WeakRefTest03/GCOnly_WeakRefTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..f41ea1eed6b07daa11092ee5dda176adc55e7d7c
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0003-GCOnly_WeakRefTest03/GCOnly_WeakRefTest03.java
@@ -0,0 +1,175 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_GCOnly_WeakRefTest03
+ *- @TestCaseName: GCOnly_WeakRefTest03
+ *- @TestCaseType: Function Testing for WeakReference Test
+ *- @RequirementID: AR000D0OR9
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，弱引用内存回收正确。
+ * -#step1: 分别创建CycleA、CycleB、CycleC、CycleD 四个类的对象，含有强弱引用，并且这四个对象互为循环引用；
+ * -#step2: 分别取出step1中四个对象的sum属性的值，计算它们的和并赋值给allSum；
+ * -#step3: 让当前线程休眠2000ms；
+ * -#step4: 确认四个类的对象的引用均已经释放；
+ * -#step5: 将step1中CycleA的实例对象cycleA赋值为null；
+ * -#step6: 让当前线程休眠2000ms；
+ * -#step7: 经判断得出step1中的四个实例对象均为null；
+ * -#step8: 调用Runtime.getRuntime().gc()进行垃圾回收，重复步骤2~8；
+ * -#step9: 分别判断allSum和checkCount的值，并确定step1中四个互为循环引用的对象既有强引用，又有弱引用；
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: GCOnly_WeakRefTest03.java
+ *- @ExecuteClass: GCOnly_WeakRefTest03
+ *- @ExecuteArgs:
+ *- @Remark:RC0340-rc-rp-cycle_weak_strong
+ *- @Author:zhangwenlong 00292413
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+
+public class GCOnly_WeakRefTest03 {
+    static final int TEST_NUM = 1;
+    static int checkCount = 0;
+    static int allSum;
+
+    public static void main(String[] args) {
+        checkCount = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            test01();
+            if (allSum == 20) {
+                checkCount++;
+                System.out.println("sum is wrong");
+            }
+            if (checkCount == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println("errorResult ---- checkCount: " + checkCount);
+            }
+        }
+    }
+
+    private static void test01() {
+        CycleA cycleA = new CycleA();
+        cycleA.cyb = new CycleB();
+        cycleA.cyb.cyc = new CycleC();
+        cycleA.cyb.cyc.cyd = new CycleD();
+        cycleA.cyb.cyc.cyd.cya = cycleA;
+        allSum = cycleA.sum + cycleA.cyb.sum + cycleA.cyb.cyc.sum + cycleA.cyb.cyc.cyd.sum;
+        Runtime.getRuntime().gc();
+        if ((cycleA.wr.get() != null) || (cycleA.cyb.sr.get() != null) || (cycleA.cyb.cyc.pr.get() != null)
+                || (cycleA.cyb.cyc.cyd.string == null)) {
+            checkCount++;
+        }
+        cycleA = null;
+        sleep(2000);
+        if (cycleA != null && cycleA.cyb != null && cycleA.cyb.cyc != null && cycleA.cyb.cyc.cyd != null
+                && cycleA.cyb.cyc.cyd.cya != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " [test01]a1 has not free");
+        }
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+
+class CycleA {
+    static StringBuffer stringBufferA = new StringBuffer("ref_processor_CycleA");
+    Reference wr;
+    CycleB cyb;
+    int aNum;
+    int sum;
+
+    CycleA() {
+        stringBufferA = new StringBuffer("ref_processor_CycleA");
+        wr = new WeakReference<>(stringBufferA);
+        assert wr.get() != null;
+        stringBufferA = null;
+        cyb = null;
+        aNum = 1;
+    }
+
+    int joinStr() {
+        try {
+            sum = aNum + cyb.bNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+class CycleB {
+    static StringBuffer stringBufferB = new StringBuffer("ref_processor_CycleB");
+    Reference sr;
+    CycleC cyc;
+    int bNum;
+    int sum;
+
+    CycleB() {
+        stringBufferB = new StringBuffer("ref_processor_CycleB");
+        sr = new WeakReference<>(stringBufferB);
+        assert sr.get() != null;
+        stringBufferB = null;
+        cyc = null;
+        bNum = 2;
+    }
+
+    int joinStr() {
+        try {
+            sum = bNum + cyc.cNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+class CycleC {
+    Reference pr;
+    CycleD cyd;
+    StringBuffer stringBufferC = new StringBuffer("ref_processor_CycleC");
+    int sum;
+    int cNum;
+
+    CycleC() {
+        stringBufferC = new StringBuffer("ref_processor_CycleC");
+        pr = new WeakReference<>(stringBufferC);
+        assert pr.get() != null;
+        stringBufferC = null;
+        cyd = null;
+        cNum = 3;
+    }
+
+    int joinStr() {
+        try {
+            sum = cNum + cyd.dNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+
+class CycleD {
+    String string;
+    CycleA cya;
+    int dNum;
+    int sum;
+
+    CycleD() {
+        string = "ref_processor_CycleD";
+        cya = null;
+        dNum = 4;
+    }
+
+    int joinStr() {
+        try {
+            int sum = dNum + cya.aNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
diff --git a/testsuite/java_test/gconly_test/GC0003-GCOnly_WeakRefTest03/expected.txt b/testsuite/java_test/gconly_test/GC0003-GCOnly_WeakRefTest03/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0003-GCOnly_WeakRefTest03/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/gconly_test/GC0003-GCOnly_WeakRefTest03/test.cfg b/testsuite/java_test/gconly_test/GC0003-GCOnly_WeakRefTest03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..3bf4597ea5f2369885f34043322c461eb2d15d79
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0003-GCOnly_WeakRefTest03/test.cfg
@@ -0,0 +1,2 @@
+compile(GCOnly_WeakRefTest03)
+run(GCOnly_WeakRefTest03)
diff --git a/testsuite/java_test/gconly_test/GC0004-GCOnly_WeakRefTest04/GCOnly_WeakRefTest04.java b/testsuite/java_test/gconly_test/GC0004-GCOnly_WeakRefTest04/GCOnly_WeakRefTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..641a9b6cb084378bf0eb01f4a0099b4ca643a1bc
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0004-GCOnly_WeakRefTest04/GCOnly_WeakRefTest04.java
@@ -0,0 +1,177 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_GCOnly_WeakRefTest04
+ *- @TestCaseName: GCOnly_WeakRefTest04
+ *- @TestCaseType: Function Testing for WeakReference Test
+ *- @RequirementID: AR000D0OR9
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，弱引用内存回收正确。
+ * -#step1: 声明一个ReferenceQueue类的实例对象srq，以stringBuffer1和srq为参数，创建一个WeakReference类的实例对象并赋值给sr，
+ *          判断sr.get()的返回值不为null；
+ * -#step2: 重复step1四次后，令stringBuffer1等于null；
+ * -#step3: gc后，经判断sr不为null；
+ * -#step4: 判断得出sr.get()的返回值为null；
+ * -#step5: 重复步骤4四次后，经判断srq.poll()的返回值不为null，并且其是WeakReference类的一个实例对象；
+ * -#step6: 创建一个StringBuffer类型的变量stringBuffer2，并赋初值为weak，同时声明一个ReferenceQueue类的实例对象wrq，以
+ *          stringBuffer2和wrq为参数，创建一个WeakReference类的实例对象并赋值给wr，经判断wr.get()的返回值不为null；
+ * -#step7: 重复step6三次后，令stringBuffer2等于null；让当前线程休眠2000ms，经判断wr不为null；
+ * -#step8: 判断得出wr.get()的返回值不为null，否则将check_count的值加1，并打印相关信息；
+ * -#step9: 重复步骤8三次后，经判断wrq.poll()的返回值不为null，并且其是WeakReference类的一个实例对象；
+ * -#step10: 创建一个StringBuffer类型的变量stringBuffer3，并赋初值为phantom，同时声明一个ReferenceQueue类的实例对象prq，
+ *           以stringBuffer3和prq为参数，创建一个WeakReference类的实例对象并赋值给pr，经判断pr.get()的返回值不为null；
+ * -#step11: 重复step10四次后，令stringBuffer3等于null；
+ * -#step12: 经判断prq.poll()的返回值不为null，并且其是WeakReference类的一个实例对象；
+ * -#step13: 重复步骤1~12，但是在执行步骤7的时候，由原来的重复步骤step6三次变为四次；同样，在执行步骤9的时候，由原来的
+ *           重复步骤8三次变为四次；
+ * -#step14: 重复步骤1~12，但是在执行步骤7的时候，由原来的重复步骤step6三次变为五次；同样，在执行步骤9的时候，由原来的
+ *           重复步骤8三次变为五次；
+ * -#step15: 让当前线程休眠1000ms；
+ * -#step16: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: GCOnly_WeakRefTest04.java
+ *- @ExecuteClass: GCOnly_WeakRefTest04
+ *- @ExecuteArgs:
+ *- @Remark:RC0342-rc-rp-weak_ref_boundary
+ *- @Author:zhangwenlong 00292413
+ */
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class GCOnly_WeakRefTest04 {
+    static final int TEST_NUM = 1;
+    static int checkCount = 0;
+    static WeakReference[] wr = new WeakReference[500];
+    static WeakReference[] sr = new WeakReference[500];
+    static PhantomReference[] pr = new PhantomReference[500];
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+
+    public static void main(String[] args) {
+        test();
+        if (checkCount == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("errorResult,checkNum: " + checkCount);
+        }
+    }
+
+    private static void test() {
+        //test01: 14 mix weak references
+        for (int i = 0; i < TEST_NUM; i++) {
+            test01();
+        }
+        sleep(1000);
+    }
+
+    public static void setSoftRef(int times) {
+        stringBuffer1 = new StringBuffer("soft");
+        for (int i = 0; i < times; i++) {
+            sr[i] = new WeakReference<Object>(stringBuffer1, srq);
+            if (sr[i].get() == null) {
+                System.out.println(" ---------------error in sr of test01");
+                checkCount++;
+            }
+        }
+        stringBuffer1 = null;
+    }
+
+    public static void setWeakRef(int times) {
+        stringBuffer2 = new StringBuffer("Weak");
+        for (int i = 0; i < times; i++) {
+            wr[i] = new WeakReference<Object>(stringBuffer2, wrq);
+            if (wr[i].get() == null) {
+                System.out.println(" ---------------error in wr of test01");
+                checkCount++;
+            }
+        }
+        stringBuffer2 = null;
+    }
+
+    public static void setPhantomRef(int times) {
+        stringBuffer3 = new StringBuffer("phantom");
+        for (int i = 0; i < times; i++) {
+            pr[i] = new PhantomReference<Object>(stringBuffer3, prq);
+            if (pr[i].get() != null) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ---------------" +
+                        "error in pr of test01");
+                checkCount++;
+            }
+        }
+        stringBuffer3 = null;
+    }
+
+    public static void test01() {
+        /* 14 mix weak references */
+        setSoftRef(500);
+        checkSoftRq("soft", 500);
+        setWeakRef(500);
+        checkWeakRq("weak", 500);
+        setPhantomRef(500);
+        checkPhantomRq("phantom");
+    }
+
+    public static void checkSoftRq(String funName, int times) {
+        Reference srqPoll;
+        Runtime.getRuntime().gc();
+        if (sr != null) {
+            for (int i = 0; i < times; i++) {
+                if (sr[i].get() != null) {
+                    checkCount++;
+                    System.out.println(" ErrorResult in sr      " + funName);
+                }
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in srq.poll()");
+            }
+        }
+    }
+
+    public static void checkWeakRq(String funName, int times) {
+        Reference wrqPoll;
+        Runtime.getRuntime().gc();
+        for (int i = 0; i < times; i++) {
+            if (wr[i].get() != null) {
+                checkCount++;
+                System.out.println(" ErrorResult in wr       " + funName + "times:" + i);
+            }
+        }
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in wrq.poll()");
+            }
+        }
+    }
+
+    public static void checkPhantomRq(String funName) {
+        Reference prqPoll;
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in prq.poll()");
+            }
+        }
+    }
+
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+
+
diff --git a/testsuite/java_test/gconly_test/GC0004-GCOnly_WeakRefTest04/expected.txt b/testsuite/java_test/gconly_test/GC0004-GCOnly_WeakRefTest04/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0004-GCOnly_WeakRefTest04/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/gconly_test/GC0004-GCOnly_WeakRefTest04/test.cfg b/testsuite/java_test/gconly_test/GC0004-GCOnly_WeakRefTest04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7ea07f9e390d44c90cf7312d492f8f11663678e5
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0004-GCOnly_WeakRefTest04/test.cfg
@@ -0,0 +1,2 @@
+compile(GCOnly_WeakRefTest04)
+run(GCOnly_WeakRefTest04)
diff --git a/testsuite/java_test/gconly_test/GC0005-GCOnly_WeakRefTest05/GCOnly_WeakRefTest05.java b/testsuite/java_test/gconly_test/GC0005-GCOnly_WeakRefTest05/GCOnly_WeakRefTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..c533eafd5e7891d2c39d49ac49b0e2c8f1fa37b2
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0005-GCOnly_WeakRefTest05/GCOnly_WeakRefTest05.java
@@ -0,0 +1,117 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_GCOnly_WeakRefTest05
+ *- @TestCaseName: GCOnly_WeakRefTest05
+ *- @TestCaseType: Function Testing for WeakReference Test
+ *- @RequirementID: AR000D0OR9
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，弱引用内存回收正确。
+ * -#step1: 创建弱引用，虚引用，判断这些引用不为空。
+ * -#step2: 将弱引用，虚引用的引用的对象置为NULL，释放强引用。
+ * -#step3: GC后，检查引用，软引用，虚引用及对应引用队列被释放。
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: GCOnly_WeakRefTest05.java
+ *- @ExecuteClass: GCOnly_WeakRefTest05
+ *- @ExecuteArgs:
+ *- @Remark:RC0346-rc-rp-strong_and_weak
+ *- @Author:zhangwenlong 00292413
+ */
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class GCOnly_WeakRefTest05 {
+    static final int TEST_NUM = 1;
+    static int checkCount = 0;
+    static String rf = "test";
+    static Reference wr, pr;
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("weak");
+    static StringBuffer obj2 = new StringBuffer("soft");
+    static StringBuffer obj3 = new StringBuffer("phantom");
+
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+
+        if (checkCount == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult checkCount : " + checkCount);
+        }
+    }
+
+    private static void test() {
+        // strong and weak reference, first free strong, next free weak
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+        }
+        checkRq("test_01_02");
+    }
+
+    private static void test_01() {
+        /* strong and weak reference, first free strong, next free weak */
+        obj1 = new StringBuffer("weak");
+        obj2 = new StringBuffer("soft");
+        obj3 = new StringBuffer("phantom");
+        wr = new WeakReference<Object>(obj1, wrq);
+        if (wr.get() == null) {
+            checkCount++;
+            System.out.println("error in test01---------------wr");
+        }
+
+        pr = new PhantomReference<Object>(obj3, prq);
+        if (pr.get() != null) {
+            checkCount++;
+            System.out.println("error in test01----------------pr");
+        }
+
+        obj1 = null;
+        obj2 = null;
+        obj3 = null;
+        if (rf == null) {
+            checkCount++;
+            System.out.println("error in test01-----------rf");
+        }
+    }
+
+    private static void checkRq(String funName) {
+        Reference wrqPoll, srqPoll, prqPoll;
+        Runtime.getRuntime().gc();
+        if (wr.get() != null) {
+            System.out.println("error in checkRq---------------wr");
+            checkCount++;
+        }
+        if (rf == null || (!rf.equals("test"))) {
+            System.out.println("error in checkRq---------------rf");
+            checkCount++;
+        }
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println("ErrorResult in wrq.poll()");
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println("ErrorResult in srq.poll()");
+            }
+        }
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                checkCount++;
+                System.out.println("ErrorResult in prq.poll()");
+            }
+        }
+    }
+}
+
+
diff --git a/testsuite/java_test/gconly_test/GC0005-GCOnly_WeakRefTest05/expected.txt b/testsuite/java_test/gconly_test/GC0005-GCOnly_WeakRefTest05/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0005-GCOnly_WeakRefTest05/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/gconly_test/GC0005-GCOnly_WeakRefTest05/test.cfg b/testsuite/java_test/gconly_test/GC0005-GCOnly_WeakRefTest05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e59f9a7ca68743b7b92224e1fb64645b726e7453
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0005-GCOnly_WeakRefTest05/test.cfg
@@ -0,0 +1,2 @@
+compile(GCOnly_WeakRefTest05)
+run(GCOnly_WeakRefTest05)
diff --git a/testsuite/java_test/gconly_test/GC0006-GCOnly_WeakRefTest06/GCOnly_WeakRefTest06.java b/testsuite/java_test/gconly_test/GC0006-GCOnly_WeakRefTest06/GCOnly_WeakRefTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e76d9f3fd203d2c434ee5d56b7254eddcb496f6
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0006-GCOnly_WeakRefTest06/GCOnly_WeakRefTest06.java
@@ -0,0 +1,73 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_GCOnly_WeakRefTest06
+ *- @TestCaseName: GCOnly_WeakRefTest06
+ *- @TestCaseType: Function Testing for WeakReference Test
+ *- @RequirementID: AR000D0OR9
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，弱引用内存回收正确。
+ * -#step1：创建一个ReferenceQueue类的实例对象rq，并已null和rq为参数创建一个WeakReference的实例对象weakRp；
+ * -#step2：新建一个ThreadRf线程，并开启此线程；
+ * -#step3：gc；
+ * -#step4：经判断得出weakRp.get()的返回值为null；
+ * -#step5：判断rq.poll()的返回值为reference，直至全部判断完成；
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: GCOnly_WeakRefTest06.java
+ *- @ExecuteClass: GCOnly_WeakRefTest06
+ *- @ExecuteArgs:
+ *- @Remark:RC0348-rc-rp-simpleweakref_01
+ *- @Author:zhangwenlong 00292413
+ */
+import java.lang.ref.*;
+
+public class GCOnly_WeakRefTest06 {
+    static int testNum = 1;
+    static int judgeNum = 0;
+    static Reference weakRp;
+    static ReferenceQueue rq = new ReferenceQueue();
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < testNum; i++) {
+            deadReferenceTest();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void setWeakRef() {
+        weakRp = new WeakReference<Object>(null, rq);
+    }
+
+    static void deadReferenceTest() throws InterruptedException {
+        Reference reference;
+
+        setWeakRef();
+        new Thread(new ThreadRf()).start();
+        Runtime.getRuntime().gc();
+        if (weakRp.get() != null) {
+            judgeNum++;
+        }
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                judgeNum++;
+            }
+        }
+    }
+}
+
+class ThreadRf implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/gconly_test/GC0006-GCOnly_WeakRefTest06/expected.txt b/testsuite/java_test/gconly_test/GC0006-GCOnly_WeakRefTest06/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0006-GCOnly_WeakRefTest06/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/gconly_test/GC0006-GCOnly_WeakRefTest06/test.cfg b/testsuite/java_test/gconly_test/GC0006-GCOnly_WeakRefTest06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ce7305b31889d23956dc8eeb6a4fbde475da26a1
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0006-GCOnly_WeakRefTest06/test.cfg
@@ -0,0 +1,2 @@
+compile(GCOnly_WeakRefTest06)
+run(GCOnly_WeakRefTest06)
diff --git a/testsuite/java_test/gconly_test/GC0007-GCOnly_WeakRefTest07/GCOnly_WeakRefTest07.java b/testsuite/java_test/gconly_test/GC0007-GCOnly_WeakRefTest07/GCOnly_WeakRefTest07.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e7a7d9e8c96373ec383ef222a7b58fb1b06cfe8
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0007-GCOnly_WeakRefTest07/GCOnly_WeakRefTest07.java
@@ -0,0 +1,137 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_GCOnly_WeakRefTest07
+ *- @TestCaseName: GCOnly_WeakRefTest07
+ *- @TestCaseType: Function Testing for WeakReference Test
+ *- @RequirementID: AR000D0OR9
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，弱引用内存回收正确。
+ * -#step1：分别创建Cycle_BDec_00010_A1_Cleaner类的实例对象cycleBA1，InCycle类的实例对象cycleA；
+ * -#step2：调用System.gc()进行垃圾回收；
+ * -#step3：以cycleBA1为参数，执行cycleA的setCleanerCycle()方法，并记其返回值为result；
+ * -#step4：创建一个Cycle_BDec_00010_A2_Cleaner的实例对象cycleBA2，并令cycleBA1.cycleBA2和cycleBA1均为null；
+ * -#step5：经判断得知result为true，并令当前线程休眠2000ms，并判断得出cycleBA1.cleaner、cycleBA1.cycleBA2.cleaner、
+ *          cycleBA1、cycleBA1.cycleBA2至少有一个为null；
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: GCOnly_WeakRefTest07.java
+ *- @ExecuteClass: GCOnly_WeakRefTest07
+ *- @ExecuteArgs:
+ *- @Remark:RC0349-rc-rp-simpleweakref_02
+ *- @Author:zhangwenlong 00292413
+ */
+import sun.misc.Cleaner;
+
+public class GCOnly_WeakRefTest07 {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerInDeadCycle();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+
+    static void isCleanerInDeadCycle() throws InterruptedException {
+        judgeNum = 0;
+        Cycle_BDec_00010_A1_Cleaner cycleBA1 = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cycleBA1);
+        cycleBA1.cycleBA2 = null;
+        cycleBA1 = null;
+        if (result == true) {
+            Thread.sleep(2000);
+            if (cycleBA1.cleaner == null || cycleBA1.cycleBA2.cleaner == null) {
+            } else {
+                judgeNum++;
+            }
+        } else {
+            judgeNum++;
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    Cycle_BDec_00010_A2_Cleaner cycleBA2;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBA2, null);
+        cycleBA2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBA2.num;
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBA1Cleaner;
+    int num;
+    int sum;
+    static int value;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBA1Cleaner, null);
+        cycleBA1Cleaner = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBA1Cleaner.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleBDA 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean modifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleBDA) {
+        cycleBDA.add();
+        cycleBDA.cycleBA2.add();
+        int nSum = cycleBDA.sum + cycleBDA.cycleBA2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBDA1Cleaner 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner) {
+        cycleBDA1Cleaner.cycleBA2 = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBDA1Cleaner.cycleBA2.cycleBA1Cleaner = cycleBDA1Cleaner;
+        boolean ret;
+        ret = modifyCleanerA1(cycleBDA1Cleaner);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleBDA1Cleaner.cleaner == null && cycleBDA1Cleaner.cycleBA2.cleaner == null
+                && cycleBDA1Cleaner != null && cycleBDA1Cleaner.cycleBA2 != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
diff --git a/testsuite/java_test/gconly_test/GC0007-GCOnly_WeakRefTest07/expected.txt b/testsuite/java_test/gconly_test/GC0007-GCOnly_WeakRefTest07/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0007-GCOnly_WeakRefTest07/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/gconly_test/GC0007-GCOnly_WeakRefTest07/test.cfg b/testsuite/java_test/gconly_test/GC0007-GCOnly_WeakRefTest07/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..75b4e06f4b1d2c2cd47d63f331173170bac9f693
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0007-GCOnly_WeakRefTest07/test.cfg
@@ -0,0 +1,2 @@
+compile(GCOnly_WeakRefTest07)
+run(GCOnly_WeakRefTest07)
diff --git a/testsuite/java_test/gconly_test/GC0008-GCOnly_WeakRefTest08/GCOnly_WeakRefTest08.java b/testsuite/java_test/gconly_test/GC0008-GCOnly_WeakRefTest08/GCOnly_WeakRefTest08.java
new file mode 100644
index 0000000000000000000000000000000000000000..42a520c0ddb9a4c0bced8321ab524d325ea098f0
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0008-GCOnly_WeakRefTest08/GCOnly_WeakRefTest08.java
@@ -0,0 +1,401 @@
+/*
+ *- @TestCaseID: Maple_MemoryManagement2.0_GCOnly_WeakRefTest08
+ *- @TestCaseName: GCOnly_WeakRefTest08
+ *- @TestCaseType: Function Testing for WeakReference Test
+ *- @RequirementID: AR000D0OR9
+ *- @RequirementName: 运行时支持GCOnly
+ *- @Condition:no
+ *  -#c1: 测试环境正常
+ *- @Brief:测试正常情况下，弱引用内存回收正确。
+ * -#step1: 分别创建Cycle_BDec_00010_A1_Cleaner类、InCycle类的实例对象cycleBDA1Cleaner、cycleA；
+ * -#step2: 以cycleBDA1为参数，执行cycleA的setCleanerCycle()方法，并记返回值为result；
+ * -#step3: 调用Runtime.getRuntime().gc()进行垃圾回收；
+ * -#step4: 经判断得知result为true，并对cycleBDA1Cleaner对象清除软引用、弱引用、NoFinalizePhantomReference、
+ *          FinalizePhantomReference、FinalizeCleaner、NoFinalizeCleaner，并且都返回true，证明都清除成功；
+ *- @Expect:ExpectResult\n
+ *- @Priority: High
+ *- @Source: GCOnly_WeakRefTest08.java
+ *- @ExecuteClass: GCOnly_WeakRefTest08
+ *- @ExecuteArgs:
+ *- @Remark:RC0350-rc-rp-simpleweakref_03
+ *- @Author:
+ */
+
+import sun.misc.Cleaner;
+import java.util.ArrayList;
+import java.lang.ref.PhantomReference;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class GCOnly_WeakRefTest08 {
+    static int testNum = 1;
+    static int judgeNum = 0;
+
+    public static void main(String[] args) throws Throwable {
+        judgeNum = 0;
+        for (int i = 0; i < testNum; i++) {
+            isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error,judgeNum:" + judgeNum);
+        }
+    }
+
+    static boolean resultSetCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1) {
+        InCycle cycleA = new InCycle();
+        boolean result = InCycle.setCleanerCycle(cycleBDA1);
+        Runtime.getRuntime().gc();
+        return result;
+    }
+
+    static void isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB() throws Throwable {
+        Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner = new Cycle_BDec_00010_A1_Cleaner();
+        boolean result = resultSetCycle(cycleBDA1Cleaner);
+        if (result == true) {
+            cycleBDA1Cleaner.cycleBDA2Cleaner = null;
+            cycleBDA1Cleaner = null;
+            if (result == true) {
+                if (Cycle_BDec_00010_A1_Cleaner.clearSoftReference() == true) {
+                    if (Cycle_BDec_00010_A1_Cleaner.clearWeakReference() == true) {
+                        if (Cycle_BDec_00010_A1_Cleaner.clearFinalizePhantomReference() == true) {
+                            if (Cycle_BDec_00010_A1_Cleaner.clearNoFinalizePhantomReference() == true) {
+                                if (Cycle_BDec_00010_A1_Cleaner.clearFinalizeCleaner() == true) {
+                                    if (Cycle_BDec_00010_A1_Cleaner.clearNoFinalizeCleaner() == true) {
+                                    } else {
+                                        judgeNum++;
+                                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                            + " ErrorResult in clearNoFinalizeCleaner--------------"
+                                            + "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                                    }
+                                } else {
+                                    judgeNum++;
+                                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                        + " ErrorResult in clearFinalizeCleaner------------------"
+                                        + "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                                }
+                            } else {
+                                judgeNum++;
+                                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                    + " ErrorResult in clearNoFinalizePhantomReference---------------"
+                                    + "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                            }
+                        } else {
+                            judgeNum++;
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                + " ErrorResult in clearFinalizePhantomReference-----------------------"
+                                + "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                        }
+                    } else {
+                        judgeNum++;
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult "
+                            + "in clearWeakReference------------------"
+                            + "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                    }
+                } else {
+                    judgeNum++;
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in "
+                        + "clearSoftReference-----------------isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                }
+            } else {
+                judgeNum++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in "
+                    + "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+            }
+        }
+    }
+}
+
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int value;
+    /**
+     * 设置软引用,clear and enqueue
+     */
+    static Reference srp, wrp, prp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static ReferenceQueue crq = new ReferenceQueue();
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    Cycle_BDec_00010_A1_Cleaner() {
+        Cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+
+    static void setSoftReference() {
+        stringBuffer1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(stringBuffer1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        stringBuffer1 = null;
+    }
+
+    private static int oomTest() {
+        int sum = 0;
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+
+        for (int i = 1044 * 1044; i <= 1044 * 1044 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRf()).start();
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            // do nothing
+        }
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------"
+                + "srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------"
+                    + "srp.while");
+                value++;
+            }
+        }
+        return value == 100;
+    }
+
+    /**
+     * 设置弱引用, clear and enqueue
+     */
+    static void setWeakReference() {
+        stringBuffer2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(stringBuffer2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        stringBuffer2 = null;
+    }
+
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRf()).start();
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        return value == 100;
+    }
+
+    /**
+     * 设置虚引用, 没有Referent finalized,clear and enqueue
+     */
+    static void setPhantomReference() {
+        stringBuffer3 = new StringBuffer("phantom");
+        prp = new PhantomReference<Object>(stringBuffer3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        stringBuffer3 = null;
+    }
+
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        return value == 100;
+    }
+
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+     */
+    static boolean clearFinalizePhantomReference() throws Throwable {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        return value == 200;
+    }
+
+    /**
+     * 设置cleaner, 没有Referent finalized,clear and enqueue
+     */
+    static void setCleaner() {
+        Cleaner crp = null;
+        String str = "test";
+        Cleaner.create(str, null);
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+        }
+    }
+
+    static boolean clearNoFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        setCleaner();
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        while ((reference = crq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        return value == 100;
+    }
+
+    /**
+     * 设置cleaner, 经过Referent finalized，clear and enqueue
+     */
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return RC_Finalize.value;
+    }
+
+    static boolean clearFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        int finalValue = finalSet();
+        Runtime.getRuntime().gc();
+        if (finalValue == 200) {
+            value = value + 100;
+        }
+        setCleaner();
+        // 初次调用， Cleaner即为空
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        return value == 200;
+    }
+
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+}
+
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleB 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleB) {
+        cycleB.add();
+        cycleB.cycleBDA2Cleaner.add();
+        int nSum = cycleB.sum + cycleB.cycleBDA2Cleaner.sum;
+        return nSum == 6;
+    }
+
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBDA1Cleaner 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+     */
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner) {
+        cycleBDA1Cleaner.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBDA1Cleaner.cycleBDA2Cleaner.cycleBD = cycleBDA1Cleaner;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleBDA1Cleaner);
+        // 环正确，且reference都没释放
+        return ret == true && Cycle_BDec_00010_A1_Cleaner.cleaner == null
+            && cycleBDA1Cleaner.cycleBDA2Cleaner.cleaner == null
+            && cycleBDA1Cleaner != null && cycleBDA1Cleaner.cycleBDA2Cleaner != null;
+    }
+}
+
+class Cycle_BDec_00010_A2_Cleaner {
+    static int value;
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBD;
+    int num;
+    int sum;
+
+    Cycle_BDec_00010_A2_Cleaner() {
+        Cleaner.create(cycleBD, null);
+        cycleBD = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+
+    void add() {
+        sum = num + cycleBD.num;
+    }
+}
+
+class RC_Finalize {
+    static int value = 0;
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+}
+
+class ThreadRf implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/gconly_test/GC0008-GCOnly_WeakRefTest08/expected.txt b/testsuite/java_test/gconly_test/GC0008-GCOnly_WeakRefTest08/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0008-GCOnly_WeakRefTest08/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/gconly_test/GC0008-GCOnly_WeakRefTest08/test.cfg b/testsuite/java_test/gconly_test/GC0008-GCOnly_WeakRefTest08/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c65a60a910b15dfbdb37adaf31de627df71a9560
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0008-GCOnly_WeakRefTest08/test.cfg
@@ -0,0 +1,2 @@
+compile(GCOnly_WeakRefTest08)
+run(GCOnly_WeakRefTest08)
diff --git a/testsuite/java_test/gconly_test/GC0009-GCOnly_ThreadList01/GCOnly_ThreadList.java b/testsuite/java_test/gconly_test/GC0009-GCOnly_ThreadList01/GCOnly_ThreadList.java
new file mode 100644
index 0000000000000000000000000000000000000000..f928e576eac5ec26fec57305c7b870304908e4d6
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0009-GCOnly_ThreadList01/GCOnly_ThreadList.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+import java.lang.Thread;
+public class GCOnly_ThreadList {
+  public synchronized void DebugFunc() {
+    for (int i = 0; i < 10000; ++i) {
+      int tid = java.lang.Thread.getLockOwnerThreadId(this);
+    }
+  }
+  public static void main(String[] args) {
+    try {
+      GCOnly_ThreadList obj = new GCOnly_ThreadList();
+      SyncThread[] syncThread = new SyncThread[10];
+      for (int i = 0; i < 10; i++) {
+        syncThread[i] = new SyncThread(obj);
+      }
+      GCTriggerThread gcThread = new GCTriggerThread();
+      for (int i = 0; i < 10; ++i) {
+        syncThread[i].start();
+      }
+      gcThread.start();
+      for (int i = 0; i < 10; ++i) {
+        syncThread[i].join();
+      }
+      gcThread.join();
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+}
+class SyncThread extends Thread {
+  private GCOnly_ThreadList obj = null;
+  SyncThread(GCOnly_ThreadList mobj) {
+    obj = mobj;
+  }
+  public void run() {
+    obj.DebugFunc();
+  }
+}
+
+class GCTriggerThread extends Thread {
+  public void run() {
+    for (int i = 0; i < 1000; ++i) {
+      Object[] matrix = new Object[1000000];
+      Runtime.getRuntime().gc();
+    }
+  }
+}
diff --git a/testsuite/java_test/gconly_test/GC0009-GCOnly_ThreadList01/expected.txt b/testsuite/java_test/gconly_test/GC0009-GCOnly_ThreadList01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/java_test/gconly_test/GC0009-GCOnly_ThreadList01/test.cfg b/testsuite/java_test/gconly_test/GC0009-GCOnly_ThreadList01/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..511003d6cd2b407c021a56f92ec8db311c6c9bb0
--- /dev/null
+++ b/testsuite/java_test/gconly_test/GC0009-GCOnly_ThreadList01/test.cfg
@@ -0,0 +1,2 @@
+compile(GCOnly_ThreadList)
+run(GCOnly_ThreadList)
diff --git a/testsuite/java_test/other_test/RT0001-rt-other-CharacterNativeUncover/CharacterNativeUncover.java b/testsuite/java_test/other_test/RT0001-rt-other-CharacterNativeUncover/CharacterNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..325b9019684fbbcda0b4b16a8ce26ef8921a3da1
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0001-rt-other-CharacterNativeUncover/CharacterNativeUncover.java
@@ -0,0 +1,515 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class CharacterNativeUncover {
+	private static int res = 99;
+	public static void main(String[] args) {
+		int result = 2;
+		CharacterDemo1();
+		if(result == 2&&res == 53) {
+			res = 0;
+		}
+		System.out.println(res);
+	}
+	public static void CharacterDemo1() {
+		Character character = new Character('a');
+		test1(character);
+		test2(character);
+		test3(character);
+		test4(character);
+		test5(character);
+		test6(character);
+		test7(character);
+		test8(character);
+		test9(character);
+		test10(character);
+		test11(character);
+		test12(character);
+		test13(character);
+		test14(character);
+		test15(character);
+		test16(character);
+		test17(character);
+		test18(character);
+		test19(character);
+		test20(character);
+		test21(character);
+		test22(character);
+		test23(character);
+	}
+	/**
+	 * static native boolean isLowerCaseImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test1(Character character) {
+			try {
+			boolean flag = Character.isLowerCase(97);//isLowerCaseImpl() called by isLowerCase();
+			// System.out.println(flag);
+			if (flag) {
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native boolean isUpperCaseImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test2(Character character) {
+		try {
+			boolean flag = Character.isUpperCase(65);//isUpperCaseImpl() called by isUpperCase();
+			//System.out.println(flag);
+			if (flag) {
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native boolean isTitleCaseImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test3(Character character) {
+		try {	
+		boolean flag = Character.isTitleCase(0x01c8);//isTitleCaseImpl() called by isTitleCase();
+			//System.out.println(flag);
+		if (flag) {
+			CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+		}else {
+			return false;
+				}
+		}catch(Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * static native boolean isDigitImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test4(Character character) {
+		try {
+			boolean flag = Character.isDigit(0x06f8);//isDigitImpl() called by isDigit();judge if it`s number;
+			//System.out.println(flag);
+			if (flag) {
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;		
+	}
+	/**
+	 * static native boolean isDefinedImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test5(Character character) {
+			try {
+			boolean flag = Character.isDefined(0x012345);//isDefinedImpl()  called by isDefined();
+			//System.out.println(flag);
+			if (flag) {
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native boolean isLetterImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test6(Character character) {
+			try {
+			boolean flag = Character.isLetter(0x0065);//isLetterImpl() called by isLetter();tell if it`s char type;
+			//System.out.println(flag);
+			if (flag) {
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native boolean isLetterOrDigitImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test7(Character character) {
+		try {
+			boolean flag = Character.isLetterOrDigit(0x0033);//isLetterOrDigitImpl() called by isLetterOrDigit();tell if it`s char type;
+			//System.out.println(flag);
+			if (flag) {
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native boolean isAlphabeticImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test8(Character character) {
+		try {
+			boolean flag = Character.isAlphabetic(0x0065);//isAlphabeticImpl() called by  isAlphabetic(); tell if it`s char type;
+			//System.out.println(flag);
+			if (flag) {
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native boolean isIdeographicImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test9(Character character) {
+		try {
+			boolean flag = Character.isIdeographic(0x0065);//isIdeographicImpl() called by isIdeographic();
+			if (!flag) {
+				//System.out.println(flag);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native boolean isUnicodeIdentifierStartImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test10(Character character) {
+		try {
+			boolean flag = Character.isUnicodeIdentifierStart(0x0065);//isUnicodeIdentifierStartImpl() called by isUnicodeIdentifierStart();
+			if (flag) {
+				//System.out.println(flag);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native boolean isUnicodeIdentifierPartImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test11(Character character) {
+		try {
+			boolean flag = Character.isUnicodeIdentifierPart(0x053e);//isUnicodeIdentifierPartImpl() called by isUnicodeIdentifierPart();
+			if (flag) {
+				//System.out.println(flag);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * ensure the char should be a ignoreable char in java  or unicode identifier
+	 * static native boolean isIdentifierIgnorableImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test12(Character character) {
+			try {
+			boolean flag = Character.isIdentifierIgnorable(0x053e);//isIdentifierIgnorableImpl() called by isIdentifierIgnorable();
+			if (!flag) {
+				//System.out.println(flag);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+			return true;
+	}
+	/**
+	 * static native int toLowerCaseImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test13(Character character) {
+		try {
+			int num = Character.toLowerCase(0x053e);//toLowerCaseImpl() called by toLowerCase();
+			if (num == 1390) {
+				//System.out.println(num);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native int toUpperCaseImpl(int codePoint)
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test14(Character character) {
+		try {
+			int num = Character.toUpperCase(0x053e);//toUpperCaseImpl() called by toUpperCase();
+			if (num == 1342) {
+				//System.out.println(num);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native int toTitleCaseImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test15(Character character) {
+		try {
+			int num = Character.toTitleCase(0x053e);//toTitleCaseImpl() called by toTitleCase();
+			if (num == 1342) {
+				//System.out.println(num);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * native static int digitImpl(int codePoint, int radix);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test16(Character character) {
+		try {
+			int num = Character.digit(9,2);//digitImpl() called by digit();
+			if (num == -1) {
+				//System.out.println(num);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * native static int getNumericValueImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test17(Character character) {
+		try {
+			int num = Character.getNumericValue(9);//getNumericValueImpl() called by getNumericValue();
+			if (num == -1) {
+				//System.out.println(num);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native boolean isSpaceCharImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test18(Character character) {
+		try {
+			boolean flag = Character.isSpaceChar(9);//isSpaceCharImpl()  called by isSpaceChar();
+			if (!flag) {
+				//System.out.println(flag);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * native static boolean isWhitespaceImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test19(Character character) {
+		try {
+			boolean flag = Character.isWhitespace(9);//isWhitespaceImpl() called by isWhitespace();
+			if (flag) {
+				//System.out.println(flag);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * static native int getTypeImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test20(Character character) {
+		try {
+			int num = Character.getType(9);//getTypeImpl() called by getType();
+			if (num == 15) {
+				//System.out.println(num);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * native static byte getDirectionalityImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test21(Character character) {
+		try {
+			int num = Character.getDirectionality(9);//getDirectionalityImpl() called by getDirectionality();
+			if (num == 11) {
+				//System.out.println(num);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * native static boolean isMirroredImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test22(Character character) {
+		try {
+			boolean flag = Character.isMirrored(9);//isMirroredImpl() called by isMirrored();
+			if (!flag) {
+				//System.out.println(flag);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * private static native String getNameImpl(int codePoint);
+	 * @param character
+	 * @return
+	*/
+
+	public static boolean test23(Character character) {
+		try {
+			String string = Character.getName(9);//getNameImpl() called by getName();
+			//if (string.equals("CHARACTER TABULATION")) {
+			if(string.equals("<control-0009>")){
+				//System.out.println(string);
+				CharacterNativeUncover.res = CharacterNativeUncover.res - 2;
+			}else {
+				return false;
+					}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+}
diff --git a/testsuite/java_test/other_test/RT0001-rt-other-CharacterNativeUncover/expected.txt b/testsuite/java_test/other_test/RT0001-rt-other-CharacterNativeUncover/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0001-rt-other-CharacterNativeUncover/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/other_test/RT0001-rt-other-CharacterNativeUncover/test.cfg b/testsuite/java_test/other_test/RT0001-rt-other-CharacterNativeUncover/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..be210a2e20461ef9bfc93062f582a827c47150c0
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0001-rt-other-CharacterNativeUncover/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterNativeUncover)
+run(CharacterNativeUncover)
diff --git a/testsuite/java_test/other_test/RT0002-rt-other-ClassNativeUncover/ClassNativeUncover.java b/testsuite/java_test/other_test/RT0002-rt-other-ClassNativeUncover/ClassNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..fbe6c887e88d3a8f6149b5dee724bb8c55f39ad7
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0002-rt-other-ClassNativeUncover/ClassNativeUncover.java
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+public class ClassNativeUncover{
+	private static int res = 99;
+	public String name;
+	public ClassNativeUncover() {
+		super();
+	}
+	public ClassNativeUncover(String name) {
+		super();
+		this.name = name;
+	}
+	public static void main(String[] args) {
+		int result = 2;
+		ClassDemo1();
+		if(result ==2 && res == 65) {
+			res = 0; 
+		}
+		System.out.println(res);
+	}
+	public static void ClassDemo1() {
+		Class class1 = ClassNativeUncover.class;
+		test1(class1);	
+		test2(class1);
+		test3(class1);
+		test4(class1);
+		test5(class1);
+		test6(class1);
+		test7(class1);
+		test8(class1);
+		test9(class1);
+		test10(class1);
+		test11(class1);
+		test12(class1);
+		test13(class1);
+		test14(class1);
+		test15(class1);
+		test16(class1);
+		test17(class1);
+	}
+	/**
+	 * public native Class<?> getDeclaringClass();
+	 * @param class1
+	*/
+
+	public static void test1(Class class1) {
+				try {
+				boolean flag =  class1.isMemberClass();//getDeclaringClass() called by isMemberClass();
+				if (!flag) {
+					//System.out.println(flag);
+					ClassNativeUncover.res = ClassNativeUncover.res - 2;
+				}
+			} catch (Exception e) {
+				e.printStackTrace();
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+	}
+	/**
+	 * public native Class<?> getEnclosingClass();
+	 * @param class1
+	*/
+
+	public static void test2(Class class1) {
+		try {
+			String string = class1.getCanonicalName();//getEnclosingClass() called by getCanonicalName();
+			if (string.equals("ClassNativeUncover")) {
+				//System.out.println(string);
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+}
+	/**
+	 * public native boolean isAnonymousClass();
+	 * @param class1
+	*/
+
+	public static void test3(Class class1) {
+			try {
+			boolean flag = class1.isAnonymousClass();
+			if (!flag) {
+				//System.out.println(flag);
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	/**
+	 *  private native Field getPublicFieldRecursive(String name);
+	 * @param class1
+	*/
+
+	public static void test4(Class class1) {
+		try {
+			Field field = class1.getField("name");//get the whole attributes which named "public" and inherited from parent class;getPublicFieldRecursive() called by getField();
+			if (field.toString().equals("public java.lang.String ClassNativeUncover.name")) {
+				//System.out.println(field.toString());
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	/**
+	 * public native Field[] getDeclaredFields();
+	 * @param class1
+	*/
+
+	public static void test5(Class class1) {
+		try {
+			Field[] fields = class1.getDeclaredFields();//get all declarative attributes;
+			if (fields!=null && fields.length>0) {
+//				for(Field field:fields ) {
+//				System.out.println(field);
+//			}
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	/**
+	 * public native Method[] MethodsUnchecked(boolean publicOnly);
+	 * @param class1
+	*/
+
+	public static void test6(Class class1) {
+			try {
+			Method[] methods = class1.getDeclaredMethods();//get declarative methods;getDeclaredMethodsUnchecked() called by getDeclaredMethods();
+			if (methods!=null && methods.length>0) {
+//				for(Method method:methods ) {
+//				System.out.println(method);
+//			}
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+}
+	/**
+	 * private native Constructor<?>[] getDeclaredConstructorsInternal(boolean publicOnly);
+	 * @param class1
+	*/
+
+	public static void test7(Class class1) {
+			try {
+			Constructor[] constructors = class1.getConstructors();//get public constructions and inherited from parent class;getDeclaredConstructorsInternal()called bygetConstructors();
+			if (constructors!=null && constructors.length>0) {
+//				for(Constructor constructor:constructors ) {
+//				System.out.println(constructor);
+//			}
+			ClassNativeUncover.res = ClassNativeUncover.res - 2;}
+			}catch (Exception e) {
+				e.printStackTrace();
+			}
+	}
+	/**dcons
+	 * private native Constructor<?>[] getDeclaredConstructorsInternal(boolean publicOnly);
+	 * @param class1
+	*/
+
+	public static void test8(Class class1) {
+			try {
+			Constructor[] constructors = class1.getDeclaredConstructors();//get all of declarative construcors;getDeclaredConstructorsInternal() called by getDeclaredConstructors;
+			if (constructors!=null && constructors.length>0) {
+//			for(Constructor constructor:constructors ) {
+//				System.out.println(constructor);
+//			}
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;}
+			}catch (Exception e) {
+				e.printStackTrace();	
+			}
+}
+	/**
+	 * public native Field getDeclaredField(String name) throws NoSuchFieldException;
+	 * @param class1
+	*/
+
+	public static void test9(Class class1) {
+			try {
+			Field field = class1.getDeclaredField("res");
+			if(field.toString().equals("private static int ClassNativeUncover.res")) {
+				//System.out.println(field);
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+			}catch(NoSuchFieldException e) {
+				e.printStackTrace();
+			}
+}
+	/**
+	 * private native Constructor<T> getDeclaredConstructorInternal(Class<?>[] args);
+	 * @param class1
+	*/
+
+	public static void test10(Class class1) {
+			try {
+			Constructor constructor = class1.getConstructor(new Class[] {String.class});//getDeclaredConstructorInternal() called by getConstructor;
+			if(constructor.toString().equals("public ClassNativeUncover(java.lang.String)")) {
+			//System.out.println(constructor);
+			ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+			}catch( NoSuchMethodException e) {
+				e.printStackTrace();
+			}
+}
+	/**
+	 * private native Constructor<T> getDeclaredConstructorInternal(Class<?>[] args);
+	 * @param class1
+	*/
+
+	public static void test11(Class class1) {
+			try {
+			Constructor constructor = class1.getDeclaredConstructor(new Class[] {String.class});//getDeclaredConstructorInternal() called by getDeclaredConstructor();
+			if(constructor.toString().equals("public ClassNativeUncover(java.lang.String)")) {
+			//System.out.println(constructor);
+			ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+			}catch( NoSuchMethodException e) {
+				e.printStackTrace();
+	}
+}
+	/**
+	 * private native String getInnerClassName();
+	 * @param class1
+	*/
+
+	public static void test12(Class class1) {
+			try {
+			String string = class1.getSimpleName();//getInnerClassName() called by getSimpleName();
+			if(string.equals("ClassNativeUncover")) {
+			ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			//System.out.println(string);
+			}
+			}catch(Exception e) {
+				e.printStackTrace();
+	}
+}
+	/**
+	 * private native String[] getSignatureAnnotation();
+	 * @param class1
+	*/
+
+	public static void test13(Class class1) {
+		try {
+			TypeVariable[] typeVariables = class1.getTypeParameters();//return a array length 0;getSignatureAnnotation() called by getTypeParameters();
+			if(typeVariables.getClass().toString().equals("class [Ljava.lang.reflect.TypeVariable;")&&typeVariables.length==0) {
+			//System.out.println(typeVariables.length);
+			//System.out.println(typeVariables.getClass().toString());
+			ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+		}catch(Exception e) {
+			e.printStackTrace();
+}
+}
+	/**
+	 * private native String[] getSignatureAnnotation();
+	 * @param class1
+	*/
+
+	public static void test14(Class class1) {
+			try {
+			Type type = class1.getGenericSuperclass();//getSignatureAnnotation()called by getGenericSuperclass;
+			if(type.toString().equals("class java.lang.Object")) {
+				//System.out.println(type);
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+			}catch(Exception e) {
+				e.printStackTrace();
+	}
+}
+	/**
+	 * private native String[] getSignatureAnnotation();
+	 * @param class1
+	*/
+
+	public static void test15(Class class1) {
+			Type[] type = class1.getGenericInterfaces();//getSignatureAnnotation() called by getGenericInterfaces;
+			if(type.length == 0 && type.getClass().toString().equals("class [Ljava.lang.Class;")) {
+			//System.out.println(type.length);
+			//System.out.println(type.getClass().toString());
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;
+			}
+}
+	/**	private native Method getDeclaredMethodInternal(String name, Class<?>[] args);
+	 * @param class1
+	*/
+
+	public static void test16(Class class1) {
+			try {
+			Method method = class1.getMethod("ClassDemo1");//getDeclaredMethodInternal() called by getMethod()
+			if(method.toString().equals("public static void ClassNativeUncover.ClassDemo1()")) {
+				//System.out.println(method);
+				ClassNativeUncover.res = ClassNativeUncover.res - 2;		
+			}
+			}catch( NoSuchMethodException e) {
+				e.printStackTrace();
+			}
+	}
+	public static void test17(Class class1) {
+		try {
+		Annotation[] a = class1.getAnnotations(); //getDeclaredAnnotations() called by getAnnotations()
+		if (a.length == 0 && a.getClass().toString().equals("class [Ljava.lang.annotation.Annotation;")) {
+			//System.out.println(a.length);
+			//System.out.println(a.getClass().toString());
+			ClassNativeUncover.res = ClassNativeUncover.res - 2;	
+		}
+		}catch( Exception e) {
+			e.printStackTrace();
+		}
+	}
+}
diff --git a/testsuite/java_test/other_test/RT0002-rt-other-ClassNativeUncover/expected.txt b/testsuite/java_test/other_test/RT0002-rt-other-ClassNativeUncover/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0002-rt-other-ClassNativeUncover/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/other_test/RT0002-rt-other-ClassNativeUncover/test.cfg b/testsuite/java_test/other_test/RT0002-rt-other-ClassNativeUncover/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6c52ebfd26b64060061282c50a61703eaa07b335
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0002-rt-other-ClassNativeUncover/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassNativeUncover)
+run(ClassNativeUncover)
diff --git a/testsuite/java_test/other_test/RT0003-rt-other-ConstructorNativeUncover/ConstructorNativeUncover.java b/testsuite/java_test/other_test/RT0003-rt-other-ConstructorNativeUncover/ConstructorNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd84a1fe042d618e74c6843219ff32ee1ce6929c
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0003-rt-other-ConstructorNativeUncover/ConstructorNativeUncover.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Constructor;
+import java.util.Arrays;
+public class ConstructorNativeUncover {
+	private static int res = 99;
+	public ConstructorNativeUncover() {
+		super();
+		// TODO Auto-generated constructor stub
+	}
+	public static void main(String[] args) {
+		int result = 2;
+		ConstructorDemo1();
+		if(result == 2 && res == 97) {
+			res = 0;
+		}
+		System.out.println(res);
+	}
+	public static void ConstructorDemo1() {
+		ConstructorNativeUncover constructorNativeUncover = new ConstructorNativeUncover();
+		test(constructorNativeUncover);
+	}
+	/**
+	 * public native Class<?>[] getExceptionTypes();
+	 * @param constructorNativeUncover
+	 * @return
+	*/
+
+	public static boolean test(ConstructorNativeUncover constructorNativeUncover) {
+			try {
+			Class class1 = constructorNativeUncover.getClass();
+			Constructor constructor = class1.getConstructor(new Class[] {});
+			Class[] classes = constructor.getExceptionTypes();
+			if(classes.length == 0 && classes.getClass().toString().equals("class [Ljava.lang.Class;")) {
+//				System.out.println(classes.getClass().toString());
+//				System.out.println(classes.length);
+				ConstructorNativeUncover.res = ConstructorNativeUncover.res - 2;
+			}
+				}catch(NoSuchMethodException e) {
+		e.printStackTrace();
+		return false;
+	}
+			return true;
+	}
+}
diff --git a/testsuite/java_test/other_test/RT0003-rt-other-ConstructorNativeUncover/expected.txt b/testsuite/java_test/other_test/RT0003-rt-other-ConstructorNativeUncover/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0003-rt-other-ConstructorNativeUncover/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/other_test/RT0003-rt-other-ConstructorNativeUncover/test.cfg b/testsuite/java_test/other_test/RT0003-rt-other-ConstructorNativeUncover/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..12146304c4d1ef14e78ce281ea81804e45655c10
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0003-rt-other-ConstructorNativeUncover/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorNativeUncover)
+run(ConstructorNativeUncover)
diff --git a/testsuite/java_test/other_test/RT0004-rt-other-FieldNativeUncover/FieldNativeUncover.java b/testsuite/java_test/other_test/RT0004-rt-other-FieldNativeUncover/FieldNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b00a6b3178b11fcde40357183dc10bc619a4ff8
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0004-rt-other-FieldNativeUncover/FieldNativeUncover.java
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+import java.lang.reflect.Type;
+public class FieldNativeUncover {
+	private static int res = 99;
+	public String userName;
+	public boolean flag;
+	public byte newByte;
+	public char chars;
+	public short shorts;
+	public int num;
+	public long longs;
+	public float floats;
+	@newAnnotation(name = "double1", value = "double2")
+	public double doubles;
+	@Retention(RetentionPolicy.RUNTIME)
+	public @interface newAnnotation{
+		public String name();
+		public String value();
+	}
+	public static void main(String[] args) {
+		int  result = 2; 
+		FieldDmeo1();
+		if(result == 2 && res == 71) {
+			res = 0;
+		}
+		System.out.println(res);
+	}
+	public static void FieldDmeo1() {
+		FieldNativeUncover fieldNativeUncover = new FieldNativeUncover();
+		test1(fieldNativeUncover);
+		test2(fieldNativeUncover);
+		test3(fieldNativeUncover);
+		test4(fieldNativeUncover);
+		test5(fieldNativeUncover);
+		test6(fieldNativeUncover);
+		test7(fieldNativeUncover);
+		test8(fieldNativeUncover);
+		test9(fieldNativeUncover);
+		test10(fieldNativeUncover);
+		test11(fieldNativeUncover);
+		test12(fieldNativeUncover);
+		test13(fieldNativeUncover);
+		test14(fieldNativeUncover);
+	}
+	/**
+	 * private native String getNameInternal();
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test1(FieldNativeUncover fieldNativeUncover) {
+			try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("userName");
+			String name = field.getName();//getNameInternal() called by getName();
+			if(name.equals("userName")) {
+			//System.out.println(name);
+			FieldNativeUncover.res = FieldNativeUncover.res - 2;
+			}
+			}catch( NoSuchFieldException e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * private native String[] getSignatureAnnotation();
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test2(FieldNativeUncover fieldNativeUncover) {
+			try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("userName");
+			Type type = field.getGenericType();//getSignatureAttribute() called by getGenericType(),getSignatureAnnotation() called by getSignatureAttribute();
+			if(type.toString().equals("class java.lang.String")) {
+				//System.out.println(type.toString());
+				FieldNativeUncover.res = FieldNativeUncover.res - 2;
+			}
+			}catch( NoSuchFieldException e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+	/**
+	 * public native Object get(Object obj)throws IllegalArgumentException, IllegalAccessException;
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test3(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("userName");
+			field.set(fieldNativeUncover, "Tom");// set the attribute "userName" as  "Tom";
+			Object object = field.get(fieldNativeUncover);
+			if(object.toString().equals("Tom")) {
+			//System.out.println(object);
+			FieldNativeUncover.res = FieldNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * public native boolean getBoolean(Object obj)throws IllegalArgumentException, IllegalAccessException;
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test4(FieldNativeUncover fieldNativeUncover){
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("flag");
+			field.setBoolean(fieldNativeUncover, true);
+			boolean flags = field.getBoolean(fieldNativeUncover);
+			if(flags) {
+			//System.out.println(flags);
+			FieldNativeUncover.res = FieldNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * public native byte getByte(Object obj)throws IllegalArgumentException, IllegalAccessException;
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test5(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("newByte");
+			field.setByte(fieldNativeUncover, (byte) 100);
+			byte flags = field.getByte(fieldNativeUncover);
+			if(flags == 100) {
+				//System.out.println(flags);
+				FieldNativeUncover.res = FieldNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * public native char getChar(Object obj)throws IllegalArgumentException, IllegalAccessException;
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test6(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("chars");
+			field.setChar(fieldNativeUncover, 'a');
+			char chars = field.getChar(fieldNativeUncover);
+			if ("a".equals(String.valueOf(chars))) {
+				//System.out.println(chars);
+				FieldNativeUncover.res = FieldNativeUncover.res - 2;
+				return true;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * public native short getShort(Object obj)throws IllegalArgumentException, IllegalAccessException;
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test7(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("shorts");
+			field.setShort(fieldNativeUncover, (short) 20);
+			short sh = field.getShort(fieldNativeUncover);
+			if (sh==20) {
+				//System.out.println(sh);
+				FieldNativeUncover.res = FieldNativeUncover.res - 2;
+				return true;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * public native int getInt(Object obj)throws IllegalArgumentException, IllegalAccessException;
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test8(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("num");
+			field.setInt(fieldNativeUncover, 20);
+			int number = field.getInt(fieldNativeUncover);
+			if (number == 20) {
+				//System.out.println(number);
+				FieldNativeUncover.res = FieldNativeUncover.res - 2;
+				return true;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * public native long getLong(Object obj)throws IllegalArgumentException, IllegalAccessException;
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test9(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("longs");
+			field.setLong(fieldNativeUncover, 20);
+			long number = field.getLong(fieldNativeUncover);
+			if (number == 20) {
+				//System.out.println(number);
+				FieldNativeUncover.res = FieldNativeUncover.res - 2;
+				return true;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * public native float getFloat(Object obj)throws IllegalArgumentException, IllegalAccessException;
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test10(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("floats");
+			field.setFloat(fieldNativeUncover, (float) 1.0);
+			Float number = field.getFloat(fieldNativeUncover);
+			if (number==1.0) {
+				FieldNativeUncover.res = FieldNativeUncover.res - 2;
+				return true;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * public native double getDouble(Object obj)throws IllegalArgumentException, IllegalAccessException;
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test11(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("doubles");
+			field.setDouble(fieldNativeUncover,1.05);
+			double number = field.getDouble(fieldNativeUncover);
+			if (number==1.05) {
+				FieldNativeUncover.res = FieldNativeUncover.res - 2;
+				return true;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * private native <A extends Annotation> A getAnnotationNative(Class<A> annotationType);
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test12(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("doubles");
+			newAnnotation annotation = field.getAnnotation(newAnnotation.class);//getAnnotationNative() called by getAnnotation()
+			if(annotation.toString().equals("@FieldNativeUncover$newAnnotation(name=double1, value=double2)")) {
+			//System.out.println(annotation.toString());
+			FieldNativeUncover.res = FieldNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+	/**
+	 * private native boolean isAnnotationPresentNative(Class<? extends Annotation> annotationType);
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test13(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("doubles");
+			newAnnotation[] annotations = field.getAnnotationsByType(newAnnotation.class);//isAnnotationPresentNative() called by getAnnotationsByType()
+			if(annotations.length == 1) {
+			//System.out.println(annotations.length);
+			FieldNativeUncover.res = FieldNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		return true;
+		}
+		return true;
+	}
+	/**
+	 * public native Annotation[] getDeclaredAnnotations();
+	 * @param fieldNativeUncover
+	 * @return
+	*/
+
+	public static boolean test14(FieldNativeUncover fieldNativeUncover) {
+		try {
+			Class class1 = fieldNativeUncover.getClass();
+			Field field = class1.getField("doubles");
+			Annotation[] annotations =field.getDeclaredAnnotations();
+			if(annotations.length == 1 && annotations.getClass().toString().equals("class [Ljava.lang.annotation.Annotation;")) {
+			//System.out.println(annotations.length);
+			//System.out.println(annotations.getClass().toString());
+			FieldNativeUncover.res = FieldNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}
+}
diff --git a/testsuite/java_test/other_test/RT0004-rt-other-FieldNativeUncover/expected.txt b/testsuite/java_test/other_test/RT0004-rt-other-FieldNativeUncover/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0004-rt-other-FieldNativeUncover/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/other_test/RT0004-rt-other-FieldNativeUncover/test.cfg b/testsuite/java_test/other_test/RT0004-rt-other-FieldNativeUncover/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d8fd7cd9f73beb8a96db159e0798817fccf795cc
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0004-rt-other-FieldNativeUncover/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldNativeUncover)
+run(FieldNativeUncover)
diff --git a/testsuite/java_test/other_test/RT0005-rt-other-MethodNativeUncover/MethodNativeUncover.java b/testsuite/java_test/other_test/RT0005-rt-other-MethodNativeUncover/MethodNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..f48b318de344f1330ce7718181cf2150e2e76ba8
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0005-rt-other-MethodNativeUncover/MethodNativeUncover.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+public class MethodNativeUncover {
+private static int res = 99;
+	public static void sayHello() {
+		String hello = "halo";
+	}
+	public static void main(String[] args) {
+		int result = 2;
+		MethodDemo1();
+		if(result == 2 && res == 95) {
+			res = 0;
+		}
+		System.out.println(res);
+	}
+	public static void MethodDemo1(){
+		MethodNativeUncover methodNativeUncover = new MethodNativeUncover();
+		test(methodNativeUncover);
+		test1(methodNativeUncover);
+	}
+	/**
+	 * public native Class<?>[] getExceptionTypes();
+	 * @param methodNativeUncover
+	*/
+
+	public static void test(MethodNativeUncover methodNativeUncover) {
+		Class class1 = methodNativeUncover.getClass();
+		try {
+			Method method = class1.getMethod("sayHello");
+			Class[] newClass = method.getExceptionTypes();
+			if(newClass.length == 0 && newClass.getClass().toString().equals("class [Ljava.lang.Class;")) {
+			//System.out.println(newClass.length);
+			//System.out.println(newClass.getClass());
+			MethodNativeUncover.res = MethodNativeUncover.res - 2;
+			}
+		} catch (NoSuchMethodException e) {
+			e.printStackTrace();
+		} catch (SecurityException e) {
+			e.printStackTrace();
+		}
+	}
+	/**
+	 * public native Object getDefaultValue();
+	 * @param methodNativeUncover
+	*/
+
+	public static void test1(MethodNativeUncover methodNativeUncover) {
+		Class class1 = methodNativeUncover.getClass();
+		try {
+			Method method = class1.getMethod("sayHello");
+			Object object = method.getDefaultValue();
+			if(object == null) {
+			//System.out.println(object);
+			MethodNativeUncover.res = MethodNativeUncover.res - 2;
+			}
+		} catch (NoSuchMethodException e) {
+			e.printStackTrace();
+		} catch (SecurityException e) {
+			e.printStackTrace();
+		}
+	}
+}
diff --git a/testsuite/java_test/other_test/RT0005-rt-other-MethodNativeUncover/expected.txt b/testsuite/java_test/other_test/RT0005-rt-other-MethodNativeUncover/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0005-rt-other-MethodNativeUncover/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/other_test/RT0005-rt-other-MethodNativeUncover/test.cfg b/testsuite/java_test/other_test/RT0005-rt-other-MethodNativeUncover/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4929743f3d2949d6b5beec20227ffe9a8e0338ec
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0005-rt-other-MethodNativeUncover/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodNativeUncover)
+run(MethodNativeUncover)
diff --git a/testsuite/java_test/other_test/RT0006-rt-other-ThreadNativeUncover/ThreadNativeUncover.java b/testsuite/java_test/other_test/RT0006-rt-other-ThreadNativeUncover/ThreadNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..22137ef31d2817f57396941630dd6b5dbec95fb2
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0006-rt-other-ThreadNativeUncover/ThreadNativeUncover.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread.State;
+public class ThreadNativeUncover {
+    private static int res = 99;
+    public static void main(String[] args) {
+        int result = 2;
+        ThreadDemo1();
+        if (result == 2 && res == 97) {
+            res = 0;
+        }
+        System.out.println(res);
+    }
+    public static void ThreadDemo1() {
+        Thread thread = new Thread();
+        test(thread);
+    }
+    /**
+     * private native int nativeGetStatus(boolean hasBeenStarted);
+     * @param thread
+    */
+
+    public static void test(Thread thread) {
+        try {
+            State state = thread.getState();//nativeGetStatus() called by getState();
+            if (state.toString().equals("NEW")) {
+                ThreadNativeUncover.res = ThreadNativeUncover.res - 2;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/other_test/RT0006-rt-other-ThreadNativeUncover/expected.txt b/testsuite/java_test/other_test/RT0006-rt-other-ThreadNativeUncover/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0006-rt-other-ThreadNativeUncover/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/other_test/RT0006-rt-other-ThreadNativeUncover/test.cfg b/testsuite/java_test/other_test/RT0006-rt-other-ThreadNativeUncover/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c5a60888d37abc548c4d23a4cc12f93441404490
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0006-rt-other-ThreadNativeUncover/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadNativeUncover)
+run(ThreadNativeUncover)
diff --git a/testsuite/java_test/other_test/RT0007-rt-other-ThrowableNativeUncover/ThrowableNativeUncover.java b/testsuite/java_test/other_test/RT0007-rt-other-ThrowableNativeUncover/ThrowableNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f9837c92a99f149e2e9990ca87c540861f99ade
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0007-rt-other-ThrowableNativeUncover/ThrowableNativeUncover.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ThrowableNativeUncover {
+	private static int res = 99;
+	public static void main(String[] args) {
+		ThrowableDemo1();
+	}
+	public static void ThrowableDemo1() {
+		int result = 2;
+		Throwable throwable = new Throwable();
+		test(throwable);
+		test1(throwable);
+		if(result == 2 && res == 95) {
+			res = 0;
+		}
+		System.out.println(res);
+	}
+	/**
+	 * private static native Object nativeFillInStackTrace();
+	 * @param throwable
+	 * @return
+	*/
+
+	public static boolean test(Throwable throwable) {
+		try {
+			Throwable throwable2 = throwable.fillInStackTrace();//nativeFillInStackTrace() called by fillInStackTrace();
+			if(throwable2.toString().equals("java.lang.Throwable")) {
+			//System.out.println(throwable2.toString());
+			ThrowableNativeUncover.res = ThrowableNativeUncover.res - 2;
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;	
+	}
+	/**
+	 * private static native StackTraceElement[] nativeGetStackTrace(Object stackState);
+	 * @param throwable
+	 * @return
+	*/
+
+	public static boolean test1(Throwable throwable) {
+		try {
+			StackTraceElement[] stackTraceElements = throwable.getStackTrace();//nativeGetStackTrace() called by getStackTrace();
+			if(stackTraceElements.length == 3 && stackTraceElements.getClass().toString().equals("class [Ljava.lang.StackTraceElement;")) {
+			//System.out.println(stackTraceElements.length);
+			//System.out.println(stackTraceElements.getClass().toString());
+			ThrowableNativeUncover.res = ThrowableNativeUncover.res - 2;
+			}
+		}catch (Exception e) {
+			e.printStackTrace();
+		}
+		return true;
+	}	
+}
diff --git a/testsuite/java_test/other_test/RT0007-rt-other-ThrowableNativeUncover/expected.txt b/testsuite/java_test/other_test/RT0007-rt-other-ThrowableNativeUncover/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0007-rt-other-ThrowableNativeUncover/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/other_test/RT0007-rt-other-ThrowableNativeUncover/test.cfg b/testsuite/java_test/other_test/RT0007-rt-other-ThrowableNativeUncover/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..06bd28ac82fe78e779b5ebfe830e73b64bd8cc8f
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0007-rt-other-ThrowableNativeUncover/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableNativeUncover)
+run(ThrowableNativeUncover)
diff --git a/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/TestJniPassingFloat.java b/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/TestJniPassingFloat.java
new file mode 100644
index 0000000000000000000000000000000000000000..fabe3c6cc05a7b8c82ce36da899c94a42c24afe6
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/TestJniPassingFloat.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+class MyCycle {
+    byte[] bytes;
+    Object[] refs;
+    MyCycle() {
+        bytes = new byte[2500];
+        refs = new Object[1];
+        refs[0] = this;
+    }
+};
+public class TestJniPassingFloat {
+    static {
+        System.loadLibrary("jniFunction");
+    }
+    static volatile boolean running = true;
+    static native float myNative(float f, double d);
+    static void run() {
+        MyCycle obj;
+        for (int i = 0; i < 30000; ++i) {
+            obj = new MyCycle();
+        }
+        running = false;
+    }
+    public static void main(String[] args) throws Exception {
+        Thread thread = new Thread(() -> run());
+        thread.start();
+        while (running) {
+            float f = myNative(1.0f, 2.0f);
+            if (Float.compare(f, 1.0f + 2.0f) != 0) {
+                throw new Exception("test failed f=" + f);
+            }
+        }
+        thread.join();
+        System.out.println("pass");
+    }
+}
diff --git a/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/expected.txt b/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2ae28399f5fda2dfb1b04405f4a3b4895f5fac1e
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/expected.txt
@@ -0,0 +1 @@
+pass
diff --git a/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/jniFunction.cpp b/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/jniFunction.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9ae0be2ea206ac0be0ff0e7a5364855c108aabf3
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/jniFunction.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jfloat JNICALL Java_TestJniPassingFloat_myNative__FD
+(JNIEnv *env, jclass cls, jfloat s0, jdouble d1)
+{
+    return s0 + d1;
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("TestJniPassingFloat");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"myNative", "(FD)F", reinterpret_cast<void*>(Java_TestJniPassingFloat_myNative__FD)},
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+}
diff --git a/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/test.cfg b/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..42eb5129b9c93b37739fd1788b521fb0094b3ae0
--- /dev/null
+++ b/testsuite/java_test/other_test/RT0008-rt-other-PassingFloat/test.cfg
@@ -0,0 +1,2 @@
+compile(TestJniPassingFloat,NATIVE_SRC=jniFunction)
+run(TestJniPassingFloat)
diff --git a/testsuite/java_test/other_test/issue-RT0630-rt-other-ArrayNativeUncover/ArrayNativeUncover.java b/testsuite/java_test/other_test/issue-RT0630-rt-other-ArrayNativeUncover/ArrayNativeUncover.java
new file mode 100644
index 0000000000000000000000000000000000000000..57a5181e65497b0eddf6b52df26ac483cf0dc9ce
--- /dev/null
+++ b/testsuite/java_test/other_test/issue-RT0630-rt-other-ArrayNativeUncover/ArrayNativeUncover.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.Array;
+public class ArrayNativeUncover{
+	private static int res = 99;
+	public static void main(String[] args) {
+		int result = 2;
+		ArrayDemo1();
+		if(result == 2 && ArrayNativeUncover.res == 97) {
+			result = 0;
+			System.out.println(result);
+		}
+	}
+	public static void ArrayDemo1() {
+		test1();
+	}
+	/**
+	 * private static native Object createObjectArray(Class<?> componentType, int length) throws NegativeArraySizeException;
+	 * @return
+	*/
+
+	public static boolean test1() {
+			try {
+			Object object = Array.newInstance(String.class, 5);//createObjectArray() called by newInstance();
+			if(object.getClass().toString().equals("class [Ljava.lang.String;")) {
+				ArrayNativeUncover.res =ArrayNativeUncover.res - 2;
+				return true;
+				}
+			}catch(Exception e) {
+				e.printStackTrace();
+			}
+		return true;
+	}
+}
diff --git a/testsuite/java_test/other_test/issue-RT0630-rt-other-ArrayNativeUncover/expected.txt b/testsuite/java_test/other_test/issue-RT0630-rt-other-ArrayNativeUncover/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/other_test/issue-RT0630-rt-other-ArrayNativeUncover/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/other_test/issue-RT0630-rt-other-ArrayNativeUncover/test.cfg b/testsuite/java_test/other_test/issue-RT0630-rt-other-ArrayNativeUncover/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9ac0c7b932e0857ee8c43c3bcbcdf3251aa4a00a
--- /dev/null
+++ b/testsuite/java_test/other_test/issue-RT0630-rt-other-ArrayNativeUncover/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayNativeUncover)
+run(ArrayNativeUncover)
diff --git a/testsuite/java_test/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/AccessibleObjectExObjectequals.java b/testsuite/java_test/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/AccessibleObjectExObjectequals.java
new file mode 100755
index 0000000000000000000000000000000000000000..31423a4585aa53f864a66b7da61be0cda0e0974e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/AccessibleObjectExObjectequals.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.*;
+public class AccessibleObjectExObjectequals {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new AccessibleObjectExObjectequals().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = accessibleObjectExObjectequals1();
+        } catch (Exception e) {
+            AccessibleObjectExObjectequals.res = AccessibleObjectExObjectequals.res - 20;
+        }
+        if (result == 4 && AccessibleObjectExObjectequals.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int accessibleObjectExObjectequals1() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // boolean equals(Object obj)
+        AccessibleObject sampleField2 = AccessibleClass1.class.getDeclaredField("sampleField");
+        AccessibleObject sampleField1 = AccessibleClass1.class.getDeclaredField("sampleField");
+        if (sampleField2.equals(sampleField1)) {
+            AccessibleObjectExObjectequals.res = AccessibleObjectExObjectequals.res - 10;
+        } else {
+            AccessibleObjectExObjectequals.res = AccessibleObjectExObjectequals.res - 1;
+        }
+        return result1;
+    }
+}
+@AccessibleAnnotation1(name = "SampleClass", value = "Sample Class Annotation")
+class AccessibleClass1 {
+    private String sampleField;
+    @AccessibleAnnotation1(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@interface AccessibleAnnotation1 {
+    String name();
+    String value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/expected.txt b/testsuite/java_test/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/test.cfg b/testsuite/java_test/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d79f58d99e118c201c0a6720d8351fc3b1b3b3df
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0001-rt-parent-AccessibleObjectExObjectequals/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectExObjectequals)
+run(AccessibleObjectExObjectequals)
diff --git a/testsuite/java_test/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/AccessibleObjectExObjecthashCode.java b/testsuite/java_test/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/AccessibleObjectExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..04e229e264ae60db970d06a1bc23c1366507f2cf
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/AccessibleObjectExObjecthashCode.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.AccessibleObject;
+public class AccessibleObjectExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new AccessibleObjectExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = accessibleObjectExObjecthashCode1();
+        } catch (Exception e) {
+            AccessibleObjectExObjecthashCode.res = AccessibleObjectExObjecthashCode.res - 20;
+        }
+        if (result == 4 && AccessibleObjectExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int accessibleObjectExObjecthashCode1() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        AccessibleObject sampleField0 = SampleClass.class.getDeclaredField("sampleField0");
+        AccessibleObject sampleField1 = SampleClass.class.getDeclaredField("sampleField0");
+        AccessibleObject sampleField2 = SampleClass.class.getDeclaredField("sampleField1");
+        int px0 = sampleField0.hashCode();
+        int px1 = sampleField1.hashCode();
+        int px2 = sampleField2.hashCode();
+        if (px0 == px1 && px0 != px2) {
+            AccessibleObjectExObjecthashCode.res = AccessibleObjectExObjecthashCode.res - 10;
+        }
+        return result1;
+    }
+}
+@CustomAnnotation(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass {
+    private String sampleField0;
+    private String sampleField1;
+    @CustomAnnotation(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    /**
+     * get sampleField0
+     * @return sampleField0
+    */
+
+    public String getSampleField() {
+        return sampleField0;
+    }
+    /**
+     * set sampleField0
+     * @param sampleField just for test
+    */
+
+    public void setSampleField(String sampleField) {
+        this.sampleField0 = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotation {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f6fd67e98f182034c518cf7a8ba61782898b5c27
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0002-rt-parent-AccessibleObjectExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectExObjecthashCode)
+run(AccessibleObjectExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..ab7f0c44b9c2be1c695da1a84e9b37fa3818115e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.AccessibleObject;
+public class AccessibleObjectExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private static AccessibleObject sampleField1 = null;
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.class.getDeclaredField("res");
+        System.out.println(new AccessibleObjectExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = accessibleObjectExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new AccessibleObjectExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int accessibleObjectExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            sampleField1.notifyAll();
+            AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class AccessibleObjectExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                try {
+                    sampleField1.notifyAll();
+                    AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..44177356baa590cbf66e43c6b58d2de0b4b00153
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectExObjectnotifyAllIllegalMonitorStateException)
+run(AccessibleObjectExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/AccessibleObjectExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/AccessibleObjectExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..8f09de6032b5dffc0c58a5e1d308d84fdc58e5de
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/AccessibleObjectExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.AccessibleObject;
+public class AccessibleObjectExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private static AccessibleObject sampleField1 = null;
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = AccessibleObjectExObjectnotifyIllegalMonitorStateException.class.getDeclaredField("res");
+        System.out.println(new AccessibleObjectExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = acessibleObjectExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new AccessibleObjectExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && AccessibleObjectExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int acessibleObjectExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            sampleField1.notify();
+            AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class AccessibleObjectExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                try {
+                    sampleField1.notify();
+                    AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectnotifyIllegalMonitorStateException.res = AccessibleObjectExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b1b7bf528d45dd7801c5ffb59f5a6684ea512c9c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectExObjectnotifyIllegalMonitorStateException)
+run(AccessibleObjectExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/AccessibleObjectExObjecttoString.java b/testsuite/java_test/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/AccessibleObjectExObjecttoString.java
new file mode 100755
index 0000000000000000000000000000000000000000..3947b4c58e353cc65d37c491cc400b8794a94c34
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/AccessibleObjectExObjecttoString.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.AccessibleObject;
+public class AccessibleObjectExObjecttoString {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new AccessibleObjectExObjecttoString().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = accessibleObjectExObjecttoString1();
+        } catch (Exception e) {
+            AccessibleObjectExObjecttoString.res = AccessibleObjectExObjecttoString.res - 20;
+        }
+        if (result == 4 && AccessibleObjectExObjecttoString.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int accessibleObjectExObjecttoString1() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+//         String toString()
+        AccessibleObject sampleField1 = AccessibleObjectExObjecttoString.class.getDeclaredField("res");
+        String px1 = sampleField1.toString();
+//         System.out.println(px1);
+        if (px1.equals("static int AccessibleObjectExObjecttoString.res")) {
+            AccessibleObjectExObjecttoString.res = AccessibleObjectExObjecttoString.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/expected.txt b/testsuite/java_test/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/test.cfg b/testsuite/java_test/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..3d6205264f31c259fa7b382cf77de915dafb3b92
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0005-rt-parent-AccessibleObjectExObjecttoString/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectExObjecttoString)
+run(AccessibleObjectExObjecttoString)
diff --git a/testsuite/java_test/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/AccessibleObjectExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/AccessibleObjectExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..90a69f6a97b1fc01cdc0a27669d75e2937c794bd
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/AccessibleObjectExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.AccessibleObject;
+public class AccessibleObjectExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static AccessibleObject sampleField1 = null;
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = AccessibleObjectExObjectwaitIllegalMonitorStateException.class.getDeclaredField("res");
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = accessibleObjectExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = accessibleObjectExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = accessibleObjectExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && AccessibleObjectExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int accessibleObjectExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            sampleField1.wait();
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int accessibleObjectExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            sampleField1.wait(millis);
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int accessibleObjectExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            sampleField1.wait(millis, nanos);
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            AccessibleObjectExObjectwaitIllegalMonitorStateException.res = AccessibleObjectExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7ee7ad72588826a9847cc211775e467659d1721f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectExObjectwaitIllegalMonitorStateException)
+run(AccessibleObjectExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/ArrayExObjecthashCode.java b/testsuite/java_test/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/ArrayExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..4aae54f94491d397bf4a571bdc0544fee1e51975
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/ArrayExObjecthashCode.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+public class ArrayExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = arrayExObjecthashCode1();
+        } catch (Exception e) {
+            ArrayExObjecthashCode.res = ArrayExObjecthashCode.res - 20;
+        }
+        if (result == 4 && ArrayExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int arrayExObjecthashCode1() throws NoSuchFieldException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        Object ary0 = Array.newInstance(int.class, 10);
+        Object ary1 = ary0;
+        Object ary2 = Array.newInstance(int.class, 11);
+        int px0 = ary0.hashCode();
+        int px1 = ary1.hashCode();
+        int px2 = ary2.hashCode();
+        if (px0 == px1 && px0 != px2) {
+            ArrayExObjecthashCode.res = ArrayExObjecthashCode.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..aa3f36a0cedaf308f8174dfe65538a0e16d9f174
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0007-rt-parent-ArrayExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayExObjecthashCode)
+run(ArrayExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/ArrayExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/ArrayExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..0b9e749b0fef223a308591f7e9f400b4049c2efb
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/ArrayExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+public class ArrayExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private static Object ary1 = Array.newInstance(int.class, 10);
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = arrayExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ArrayExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ArrayExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int arrayExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            ary1.notifyAll();
+            ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ArrayExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        private int remainder;
+        private ArrayExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (ary1) {
+                try {
+                    ary1.notifyAll();
+                    ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectnotifyAllIllegalMonitorStateException.res = ArrayExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d699442724f8fff7ec86f9114ad86c2437fa4d57
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayExObjectnotifyAllIllegalMonitorStateException)
+run(ArrayExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/ArrayExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/ArrayExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..82cdfb59886e64b04ae3649da203a56a27e13a85
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/ArrayExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+public class ArrayExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private static Object ary1 = Array.newInstance(int.class, 10);
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = arrayExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ArrayExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ArrayExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int arrayExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            ary1.notify();
+            ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ArrayExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ArrayExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (ary1) {
+                try {
+                    ary1.notify();
+                    ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectnotifyIllegalMonitorStateException.res = ArrayExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f9a5714f2c97eb674c5e35996f22ecec84f96e42
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayExObjectnotifyIllegalMonitorStateException)
+run(ArrayExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/ArrayExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/ArrayExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..07a7b6b75d316222192bca63113f29b0642d4df8
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/ArrayExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+public class ArrayExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static Object ary1 = Array.newInstance(int.class, 10);
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = arrayExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = arrayExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = arrayExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ArrayExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int arrayExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            ary1.wait();
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int arrayExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            ary1.wait(millis);
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int arrayExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            ary1.wait(millis, nanos);
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ArrayExObjectwaitIllegalMonitorStateException.res = ArrayExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e276d57445bb2cf35a3953c5b30e4d997891d06a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayExObjectwaitIllegalMonitorStateException)
+run(ArrayExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/ArrayExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/ArrayExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..cc2b758236823fa488a33ea284c6383d16b665b4
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/ArrayExObjectwaitInterruptedException.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+public class ArrayExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Object ary1 = Array.newInstance(int.class, 10);
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjectwaitInterruptedException().run());
+    }
+    private class ArrayExObjectwaitInterruptedException11 implements Runnable {
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait();
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class ArrayExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait(millis);
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class ArrayExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait(millis, nanos);
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ArrayExObjectwaitInterruptedException.res = ArrayExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     * @param slpNum wait time
+    */
+
+    public void sleep(int slpNum) {
+        try {
+            Thread.sleep(slpNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ArrayExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ArrayExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ArrayExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && ArrayExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..37acbc12705d31781e68de0ba5faacfee85fe404
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0011-rt-parent-ArrayExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayExObjectwaitInterruptedException)
+run(ArrayExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0012-rt-parent-ArrayExObjectwait/ArrayExObjectwait.java b/testsuite/java_test/parent_test/RT0012-rt-parent-ArrayExObjectwait/ArrayExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..921d746a77f072a2e5f0a9d717d890ec682dee59
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0012-rt-parent-ArrayExObjectwait/ArrayExObjectwait.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+public class ArrayExObjectwait {
+    static int res = 99;
+    private static Object ary1 = Array.newInstance(int.class, 10);
+    public static void main(String argv[]) {
+        System.out.println(new ArrayExObjectwait().run());
+    }
+    private class ArrayExObjectwait11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait();
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class ArrayExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait(millis);
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class ArrayExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (ary1) {
+                ary1.notifyAll();
+                try {
+                    ary1.wait(millis, nanos);
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ArrayExObjectwait.res = ArrayExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ArrayExObjectwait11());
+        Thread t2 = new Thread(new ArrayExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ArrayExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ArrayExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        sleep(1000);
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.start();
+        sleep(1000);
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && ArrayExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0012-rt-parent-ArrayExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0012-rt-parent-ArrayExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0012-rt-parent-ArrayExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0012-rt-parent-ArrayExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0012-rt-parent-ArrayExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d2bc550a2b4e20c31fb06cc2c037ef3afb07682e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0012-rt-parent-ArrayExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayExObjectwait)
+run(ArrayExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/CharacterExObjectgetClass.java b/testsuite/java_test/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/CharacterExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..7746644f771bdd22df9bfc5caa981475a9e4899a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/CharacterExObjectgetClass.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new CharacterExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterExObjectgetClass1();
+        } catch (Exception e) {
+            CharacterExObjectgetClass.res = CharacterExObjectgetClass.res - 20;
+        }
+        if (result == 4 && CharacterExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int characterExObjectgetClass1() {
+        //  final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        char name = 'A';
+        Character char1 = new Character(name);
+        Class px1 = char1.getClass();
+        if (px1.toString().equals("class java.lang.Character")) {
+            CharacterExObjectgetClass.res = CharacterExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..0e09642b6cf8195e99ab887fcb799a1a6eaf0615
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0013-rt-parent-CharacterExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterExObjectgetClass)
+run(CharacterExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/CharacterExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/CharacterExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..66e78ab4d4d57b87e04c10d1f62fd13972253cc0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/CharacterExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Character;
+public class CharacterExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private char name = 'A';
+    private Character rp = name;
+    public static void main(String argv[]) {
+        System.out.println(new CharacterExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new CharacterExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && CharacterExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int characterExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notify();
+            CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class CharacterExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectnotifyIllegalMonitorStateException.res = CharacterExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..0cd886ee6a842d13c64bcce8f4fa88272aa756ff
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterExObjectnotifyIllegalMonitorStateException)
+run(CharacterExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/CharacterExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/CharacterExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..e64eb01a90ba863be1105470a642722025a8bc6e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/CharacterExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = characterExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = characterExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = characterExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && CharacterExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int characterExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        char name = 'A';
+        Character rp = new Character(name);
+        try {
+            rp.wait();
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int characterExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        char name = 'A';
+        long millis = 123;
+        Character rp = new Character(name);
+        try {
+            rp.wait(millis);
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int characterExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        char name = 'A';
+        long millis = 123;
+        int nanos = 10;
+        Character rp = new Character(name);
+        try {
+            rp.wait(millis, nanos);
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectwaitIllegalMonitorStateException.res = CharacterExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..0bc0316adf5c7b36e273fb4ca8a97658ed1ea452
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterExObjectwaitIllegalMonitorStateException)
+run(CharacterExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/CharacterExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/CharacterExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..cfddd37a67c20f2e446a48f570fb21c73287ab90
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/CharacterExObjectwaitInterruptedException.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterExObjectwaitInterruptedException {
+    static int res = 99;
+    static char name = 'A';
+    static Character sampleField1 = new Character(name);
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        System.out.println(new CharacterExObjectwaitInterruptedException().run());
+    }
+    private class CharacterExObjectwaitInterruptedException11 implements Runnable {
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait();
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class CharacterExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis);
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class CharacterExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis, nanos);
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterExObjectwaitInterruptedException.res = CharacterExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     * @param slpNum wait time
+    */
+
+    public void sleep(int slpNum) {
+        try {
+            Thread.sleep(slpNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new CharacterExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new CharacterExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new CharacterExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && CharacterExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6fa3b412a3dfd76c32fa2b6e06ff32d352a0b506
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0016-rt-parent-CharacterExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterExObjectwaitInterruptedException)
+run(CharacterExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0017-rt-parent-CharacterExObjectwait/CharacterExObjectwait.java b/testsuite/java_test/parent_test/RT0017-rt-parent-CharacterExObjectwait/CharacterExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..520f8a7ca8a00de909d1d0861fed3c829fba704e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0017-rt-parent-CharacterExObjectwait/CharacterExObjectwait.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterExObjectwait {
+    static int res = 99;
+    private char name = 'A';
+    private String actions = null;
+    private Character rp = new Character(name);
+    private Character rp2 = new Character(name);
+    private Character rp3 = new Character(name);
+    public static void main(String argv[]) {
+        System.out.println(new CharacterExObjectwait().run());
+    }
+    private class CharacterExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private CharacterExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                rp.notifyAll();
+                try {
+                    rp.wait();
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class CharacterExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+        private CharacterExObjectwait12(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp2) {
+                rp2.notifyAll();
+                try {
+                    rp2.wait(millis);
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class CharacterExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+        private CharacterExObjectwait13(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp3) {
+                rp3.notifyAll();
+                try {
+                    rp3.wait(millis, nanos);
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectwait.res = CharacterExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new CharacterExObjectwait11(1));
+        Thread t2 = new Thread(new CharacterExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new CharacterExObjectwait12(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new CharacterExObjectwait13(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && CharacterExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0017-rt-parent-CharacterExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0017-rt-parent-CharacterExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0017-rt-parent-CharacterExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0017-rt-parent-CharacterExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0017-rt-parent-CharacterExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7f555df502c386f3ad57816a1dd669ffc73bb9a4
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0017-rt-parent-CharacterExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterExObjectwait)
+run(CharacterExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/CharacterSubsetExObjectgetClass.java b/testsuite/java_test/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/CharacterSubsetExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..4f929c7cc37e24ffbf307847a8abbd388ed5b201
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/CharacterSubsetExObjectgetClass.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterSubsetExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterSubsetExObjectgetClass1();
+        } catch (Exception e) {
+            CharacterSubsetExObjectgetClass.res = CharacterSubsetExObjectgetClass.res - 20;
+        }
+        if (result == 4 && CharacterSubsetExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int characterSubsetExObjectgetClass1() {
+//      final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        MySubset subset = new MySubset("some subset");
+        Class px1 = subset.getClass();
+        if (px1.toString().equals("class MySubset")) {
+            CharacterSubsetExObjectgetClass.res = CharacterSubsetExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+class MySubset extends Character.Subset {
+    MySubset(String name) {
+        super(name);
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2f4d8f68b737902c06b9d42115b2424d155ae247
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0018-rt-parent-CharacterSubsetExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterSubsetExObjectgetClass)
+run(CharacterSubsetExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..a4b9df7e90b590dd4389bf86e555d70fede4b6c6
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterSubsetExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    MySubset1 mf2 = new MySubset1("some subset");
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterSubsetExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new CharacterSubsetExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int characterSubsetExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            mf2.notifyAll();
+            CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class CharacterSubsetExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notifyAll();
+                    CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+class MySubset1 extends Character.Subset {
+    MySubset1(String name) {
+        super(name);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..5f13c8f8db3dfb7c99cb4bfc483a017a36ecd677
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterSubsetExObjectnotifyAllIllegalMonitorStateException)
+run(CharacterSubsetExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/CharacterSubsetExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/CharacterSubsetExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..3230251390dbaac68f93df0b669dc619166b0707
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/CharacterSubsetExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterSubsetExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    MySubset2 mf2 = new MySubset2("some subset");
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterSubsetExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new CharacterSubsetExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && CharacterSubsetExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int characterSubsetExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        // final void notify()
+        try {
+            mf2.notify();
+            CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class CharacterSubsetExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notify();
+                    CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectnotifyIllegalMonitorStateException.res = CharacterSubsetExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+class MySubset2 extends Character.Subset {
+    MySubset2(String name) {
+        super(name);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ddf699d3a6d1e3d1e1214612621e5c248a5c8375
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterSubsetExObjectnotifyIllegalMonitorStateException)
+run(CharacterSubsetExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/CharacterSubsetExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/CharacterSubsetExObjectwaitIllegalArgumentException.java
new file mode 100644
index 0000000000000000000000000000000000000000..210bd7533f0d4224708aab15d623864dc0ec22fe
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/CharacterSubsetExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterSubsetExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    MySubset4 csb1 = new MySubset4("some subset");
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectwaitIllegalArgumentException().run());
+    }
+    private class CharacterSubsetExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait(millis);
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class CharacterSubsetExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait(millis, nanos);
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterSubsetExObjectwaitIllegalArgumentException.res = CharacterSubsetExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     * @param sleepNum wait time
+    */
+
+    public void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new CharacterSubsetExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new CharacterSubsetExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && CharacterSubsetExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
+class MySubset4 extends Character.Subset {
+    MySubset4(String name) {
+        super(name);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c9159174bfebfd746211c08aa101e3ed8652ca1a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterSubsetExObjectwaitIllegalArgumentException)
+run(CharacterSubsetExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/CharacterSubsetExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/CharacterSubsetExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..745178e9aea1da90d22da105f73ca58b38242f81
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/CharacterSubsetExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterSubsetExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static MySubset5 csb1 = new MySubset5("some subset");
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = characterSubsetExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = characterSubsetExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = characterSubsetExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && CharacterSubsetExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("CharacterSubsetExObjectwaitIllegalMonitorStateException.res: " + CharacterSubsetExObjectwaitIllegalMonitorStateException.res);
+        return result;
+    }
+    private static int characterSubsetExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor
+        // final void wait()
+        try {
+            csb1.wait();
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int characterSubsetExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            csb1.wait(millis);
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int characterSubsetExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            csb1.wait(millis, nanos);
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterSubsetExObjectwaitIllegalMonitorStateException.res = CharacterSubsetExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+class MySubset5 extends Character.Subset {
+    MySubset5(String name) {
+        super(name);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ec3c12dd1508fe2ce5e64cdf71c8a236de712c18
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterSubsetExObjectwaitIllegalMonitorStateException)
+run(CharacterSubsetExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/CharacterSubsetExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/CharacterSubsetExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..d6ce8927c9289cd9e6ff38a73f4a4f6b58d761b0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/CharacterSubsetExObjectwaitInterruptedException.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterSubsetExObjectwaitInterruptedException {
+    static int res = 99;
+    private static MySubset6 csb1 = new MySubset6("some subset");
+    public static void main(String argv[]) {
+        System.out.println(new CharacterSubsetExObjectwaitInterruptedException().run());
+    }
+    private class CharacterSubsetExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait();
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class CharacterSubsetExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait(millis);
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class CharacterSubsetExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (csb1) {
+                csb1.notifyAll();
+                try {
+                    csb1.wait(millis, nanos);
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    CharacterSubsetExObjectwaitInterruptedException.res = CharacterSubsetExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     * @param sleepNum wait time
+    */
+
+    public void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new CharacterSubsetExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new CharacterSubsetExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new CharacterSubsetExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && CharacterSubsetExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+class MySubset6 extends Character.Subset {
+    MySubset6(String name) {
+        super(name);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..820ffa5423530658052c95ae4eb8d03b12b906f4
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterSubsetExObjectwaitInterruptedException)
+run(CharacterSubsetExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0024-rt-parent-ClassExObjectHashcode/ClassExObjectHashcode.java b/testsuite/java_test/parent_test/RT0024-rt-parent-ClassExObjectHashcode/ClassExObjectHashcode.java
new file mode 100755
index 0000000000000000000000000000000000000000..5444361ec2f2677124663fa35459b1c5e54ddf82
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0024-rt-parent-ClassExObjectHashcode/ClassExObjectHashcode.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ClassExObjectHashcode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classExObjectHashcode();
+        } catch (Exception e) {
+            ClassExObjectHashcode.res = ClassExObjectHashcode.res - 10;
+        }
+        if (result == 4 && ClassExObjectHashcode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int classExObjectHashcode() {
+        // int hashCode()
+        int result1 = 4; /*STATUS_FAILED*/
+        Class<?> cal = ClassExObjectHashcode.class.getClass();
+        try {
+            int hashcode = cal.hashCode();
+            ClassExObjectHashcode.res = ClassExObjectHashcode.res - 10;
+        } catch (IllegalArgumentException e1) {
+            ClassExObjectHashcode.res = ClassExObjectHashcode.res - 1;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0024-rt-parent-ClassExObjectHashcode/expected.txt b/testsuite/java_test/parent_test/RT0024-rt-parent-ClassExObjectHashcode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0024-rt-parent-ClassExObjectHashcode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0024-rt-parent-ClassExObjectHashcode/test.cfg b/testsuite/java_test/parent_test/RT0024-rt-parent-ClassExObjectHashcode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1cd2418bb2865fe43ee609d35e0f2c88b1561baf
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0024-rt-parent-ClassExObjectHashcode/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassExObjectHashcode)
+run(ClassExObjectHashcode)
diff --git a/testsuite/java_test/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/ClassExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/ClassExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..f5c9dee6e4d41ecfd1f94a36e2f37fbdc3e440b2
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/ClassExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private Class<?>[] rp = ClassExObjectnotifyAllIllegalMonitorStateException.class.getClasses();
+    public static void main(String argv[]) {
+        System.out.println(new ClassExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ClassExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ClassExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int classExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ClassExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        private int remainder;
+        private ClassExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectnotifyAllIllegalMonitorStateException.res = ClassExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b7df945b3445f8ca316264ecb922a87ace6b5da3
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassExObjectnotifyAllIllegalMonitorStateException)
+run(ClassExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/ClassExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/ClassExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..b4aa09380eac1ebd1b24089f715ccd221144fedc
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/ClassExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private Class<?>[] rp = ClassExObjectnotifyIllegalMonitorStateException.class.getClasses();
+    public static void main(String argv[]) {
+        System.out.println(new ClassExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ClassExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ClassExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int classExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notifyAll();
+            ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ClassExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ClassExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectnotifyIllegalMonitorStateException.res = ClassExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..093b6484832abfda0aa70bc9b66065f48c8cabe9
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassExObjectnotifyIllegalMonitorStateException)
+run(ClassExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/ClassExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/ClassExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..794c3a942c71ecf1d63bd5e565046f0238d1a333
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/ClassExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private Class<?>[] clazz = ClassExObjectwaitIllegalArgumentException.class.getClasses();
+    public static void main(String argv[]) {
+        System.out.println(new ClassExObjectwaitIllegalArgumentException().run());
+    }
+    private class ClassExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (clazz) {
+                clazz.notifyAll();
+                try {
+                    clazz.wait(millis);
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class ClassExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (clazz) {
+                clazz.notifyAll();
+                try {
+                    clazz.wait(millis, nanos);
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ClassExObjectwaitIllegalArgumentException.res = ClassExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ClassExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ab1f70dadc85c082d6e2dc9dbd0c299dff349ffd
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassExObjectwaitIllegalArgumentException)
+run(ClassExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/ClassExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/ClassExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..f3d94d12ae3ff62c853fcd19aa390b4be4c15244
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/ClassExObjectwaitInterruptedException.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Class<?>[] sampleField1 = null;
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = ClassExObjectwaitInterruptedException.class.getClasses();
+        System.out.println(new ClassExObjectwaitInterruptedException().run());
+    }
+    private class ClassExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait();
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    private class ClassExObjectwaitInterruptedException12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis);
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    private class ClassExObjectwaitInterruptedException13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis, nanos);
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwaitInterruptedException.res = ClassExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ClassExObjectwaitInterruptedException11());
+        Thread t2 = new Thread(new ClassExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassExObjectwaitInterruptedException12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassExObjectwaitInterruptedException13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && ClassExObjectwaitInterruptedException.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f126b4aab4df0c9a82769bb2e7e4686acb7e8122
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0028-rt-parent-ClassExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassExObjectwaitInterruptedException)
+run(ClassExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0029-rt-parent-ClassExObjectwait/ClassExObjectwait.java b/testsuite/java_test/parent_test/RT0029-rt-parent-ClassExObjectwait/ClassExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..71517271dfe3c8110f9a8e6cb78e00eaabc23a2f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0029-rt-parent-ClassExObjectwait/ClassExObjectwait.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassExObjectwait {
+    static int res = 99;
+    private Class<?>[] cal = ClassExObjectwait.class.getClasses();
+    private Class<?>[] cal2 = ClassExObjectwait.class.getClasses();
+    private Class<?>[] cal3 = ClassExObjectwait.class.getClasses();
+    public static void main(String argv[]) {
+        System.out.println(new ClassExObjectwait().run());
+    }
+    private class ClassExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ClassExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal) {
+                cal.notifyAll();
+                try {
+                    cal.wait();
+                    ClassExObjectwait.res = ClassExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class ClassExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+        private ClassExObjectwait12(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal2) {
+                cal2.notifyAll();
+                try {
+                    cal2.wait(millis);
+                    ClassExObjectwait.res = ClassExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class ClassExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+        private ClassExObjectwait13(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal3) {
+                cal3.notifyAll();
+                try {
+                    cal3.wait(millis, nanos);
+                    ClassExObjectwait.res = ClassExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassExObjectwait.res = ClassExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ClassExObjectwait11(1));
+        Thread t2 = new Thread(new ClassExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassExObjectwait12(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassExObjectwait13(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && ClassExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0029-rt-parent-ClassExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0029-rt-parent-ClassExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0029-rt-parent-ClassExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0029-rt-parent-ClassExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0029-rt-parent-ClassExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b9b0b15949eb46bf8dc15be6feaee141d5bfa0bd
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0029-rt-parent-ClassExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassExObjectwait)
+run(ClassExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/ClassLoaderExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/ClassLoaderExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..ef60a8cf1e26f7a9174cad8ef2b7550ddb44a7ce
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/ClassLoaderExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassLoaderExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private ClassLoader rp = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.class.getClassLoader();
+    public static void main(String argv[]) {
+        System.out.println(new ClassLoaderExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res = ClassLoaderExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..3dde03c9228f785aad030eb36e54e827f33aa954
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassLoaderExObjectnotifyAllIllegalMonitorStateException)
+run(ClassLoaderExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/ClassLoaderExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/ClassLoaderExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..d9e6b2ab3fd82ec25e408bdaf8758c2f6390f722
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/ClassLoaderExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassLoaderExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private ClassLoader rp = ClassLoaderExObjectnotifyIllegalMonitorStateException.class.getClassLoader();
+    public static void main(String argv[]) {
+        System.out.println(new ClassLoaderExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = classLoaderExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ClassLoaderExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ClassLoaderExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int classLoaderExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notify();
+            ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ClassLoaderExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectnotifyIllegalMonitorStateException.res = ClassLoaderExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..eedec12bea06d0c55e81a9828a63e066c99e99c7
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassLoaderExObjectnotifyIllegalMonitorStateException)
+run(ClassLoaderExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/ClassLoaderExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/ClassLoaderExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..4b25e8b8d2b96ddfaa3072f90f5cc5813dd532af
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/ClassLoaderExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassLoaderExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private ClassLoader cl = ClassLoaderExObjectwaitIllegalArgumentException.class.getClassLoader();
+    public static void main(String argv[]) {
+        System.out.println(new ClassLoaderExObjectwaitIllegalArgumentException().run());
+    }
+    private class ClassLoaderExObjectwaitIllegalArgumentException21 implements Runnable {
+        //        IllegalArgumentException - if the value of timeout is negative.
+        //         final void wait(long millis)
+        long millis = -1;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cl) {
+                cl.notifyAll();
+                try {
+                    cl.wait(millis);
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class ClassLoaderExObjectwaitIllegalArgumentException31 implements Runnable {
+        //        IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //         final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cl) {
+                cl.notifyAll();
+                try {
+                    cl.wait(millis, nanos);
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ClassLoaderExObjectwaitIllegalArgumentException.res = ClassLoaderExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassLoaderExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassLoaderExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ClassLoaderExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f6d1941111efd0fc12675f9daddd39418d132cc7
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassLoaderExObjectwaitIllegalArgumentException)
+run(ClassLoaderExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/ClassLoaderExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/ClassLoaderExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..76c6e817fd5585c396cfb6a414bae6ff770906fd
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/ClassLoaderExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassLoaderExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static ClassLoader cl = ClassLoaderExObjectwaitIllegalMonitorStateException.class.getClassLoader();
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = classLoaderExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = classLoaderExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = classLoaderExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ClassLoaderExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int classLoaderExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            cl.wait();
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int classLoaderExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            cl.wait(millis);
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int classLoaderExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            cl.wait(millis, nanos);
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ClassLoaderExObjectwaitIllegalMonitorStateException.res = ClassLoaderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8d275147adae6587a16d8d0bb32ec0750e38e7cc
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassLoaderExObjectwaitIllegalMonitorStateException)
+run(ClassLoaderExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/ClassLoaderExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/ClassLoaderExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..29b11a3237fce927c1f79e11121a18a8682a8dea
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/ClassLoaderExObjectwaitInterruptedException.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassLoaderExObjectwaitInterruptedException {
+    static int res = 99;
+    private static ClassLoader sampleField1 = ClassLoaderExObjectwaitInterruptedException.class.getClassLoader();
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        System.out.println(new ClassLoaderExObjectwaitInterruptedException().run());
+    }
+    private class ClassLoaderExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait();
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    private class ClassLoaderExObjectwaitInterruptedException12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis);
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    private class ClassLoaderExObjectwaitInterruptedException13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis, nanos);
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwaitInterruptedException.res = ClassLoaderExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ClassLoaderExObjectwaitInterruptedException11());
+        Thread t2 = new Thread(new ClassLoaderExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassLoaderExObjectwaitInterruptedException12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassLoaderExObjectwaitInterruptedException13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && ClassLoaderExObjectwaitInterruptedException.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..32a241c20807f4dd422fa41c0feace71491c95f9
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassLoaderExObjectwaitInterruptedException)
+run(ClassLoaderExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/ClassLoaderExObjectwait.java b/testsuite/java_test/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/ClassLoaderExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..ab649421ae5e006e09e3011a471ffbff18c9fd3e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/ClassLoaderExObjectwait.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ClassLoaderExObjectwait {
+    static int res = 99;
+    private ClassLoader cal = ClassLoaderExObjectwait.class.getClassLoader();
+    private ClassLoader cal2 = ClassLoaderExObjectwait.class.getClassLoader();
+    private ClassLoader cal3 = ClassLoaderExObjectwait.class.getClassLoader();
+    public static void main(String argv[]) {
+        System.out.println(new ClassLoaderExObjectwait().run());
+    }
+    private class ClassLoaderExObjectwait11 implements Runnable {
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal) {
+                cal.notifyAll();
+                try {
+                    cal.wait();
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class ClassLoaderExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal2) {
+                cal2.notifyAll();
+                try {
+                    cal2.wait(millis);
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class ClassLoaderExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal3) {
+                cal3.notifyAll();
+                try {
+                    cal3.wait(millis, nanos);
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ClassLoaderExObjectwait.res = ClassLoaderExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ClassLoaderExObjectwait11());
+        Thread t2 = new Thread(new ClassLoaderExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ClassLoaderExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ClassLoaderExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && ClassLoaderExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e2fcb01135db8ec7ee06a7f045b79bebca0f8f47
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0035-rt-parent-ClassLoaderExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassLoaderExObjectwait)
+run(ClassLoaderExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0036-rt-parent-ConstructorExAccessibleObjectgetAnnotationNullPointerException/ConstructorExAccessibleObjectgetAnnotationNullPointerException.java b/testsuite/java_test/parent_test/RT0036-rt-parent-ConstructorExAccessibleObjectgetAnnotationNullPointerException/ConstructorExAccessibleObjectgetAnnotationNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..feeb231ef3f955647fefb0bfcd3e0ad983040da0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0036-rt-parent-ConstructorExAccessibleObjectgetAnnotationNullPointerException/ConstructorExAccessibleObjectgetAnnotationNullPointerException.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.AccessibleObject;
+import java.lang.Thread;
+public class ConstructorExAccessibleObjectgetAnnotationNullPointerException {
+    static int res = 99;
+    static String eMsg;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExObjectgetAnnotationNullPointerExceptionTest1();
+            constructorExObjectgetAnnotationNullPointerExceptionTest2();
+        } catch (Exception e) {
+            ConstructorExAccessibleObjectgetAnnotationNullPointerException.res = ConstructorExAccessibleObjectgetAnnotationNullPointerException.res - 10;
+        }
+        if (result == 4 && ConstructorExAccessibleObjectgetAnnotationNullPointerException.res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExObjectgetAnnotationNullPointerExceptionTest1() {
+        int result1 = 4;
+        try {
+            // <T extends Annotation> T getAnnotation(Class<T> annotationClass)
+            AccessibleObject sampleconstructor = SampleClass9q.class.getConstructor(String.class);
+            // System.out.println(sampleconstructor.getClass());
+            CustomAnnotations1 annotation = sampleconstructor.getAnnotation(CustomAnnotations1.class);
+            if (annotation.toString().equals("@CustomAnnotations1(name=sampleConstructor, value=Sample Constructor Annotation)")) {
+                ConstructorExAccessibleObjectgetAnnotationNullPointerException.res = ConstructorExAccessibleObjectgetAnnotationNullPointerException.res - 2;
+            }
+        } catch (NullPointerException e) {
+            eMsg = e.toString();
+        } catch (NoSuchMethodException | SecurityException e1) {
+            eMsg = e1.toString();
+        }
+        return result1;
+    }
+    private static int constructorExObjectgetAnnotationNullPointerExceptionTest2() {
+        int result1 = 4;
+        try {
+            // <T extends Annotation> T getAnnotation(Class<T> annotationClass)
+            AccessibleObject sampleconstructor = SampleClass9q.class.getConstructor(String.class);
+            // System.out.println(sampleconstructor.getClass());
+            sampleconstructor.getAnnotation(null);
+            // System.out.println(a.toString());
+        } catch (NullPointerException e) {
+            ConstructorExAccessibleObjectgetAnnotationNullPointerException.res = ConstructorExAccessibleObjectgetAnnotationNullPointerException.res - 2;
+        } catch (NoSuchMethodException | SecurityException e1) {
+            eMsg = e1.toString();
+        }
+        return result1;
+    }
+}
+@CustomAnnotations1(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass9q {
+    private String sampleField;
+    @CustomAnnotations1(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass9q(String s) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations1 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0036-rt-parent-ConstructorExAccessibleObjectgetAnnotationNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0036-rt-parent-ConstructorExAccessibleObjectgetAnnotationNullPointerException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0036-rt-parent-ConstructorExAccessibleObjectgetAnnotationNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0036-rt-parent-ConstructorExAccessibleObjectgetAnnotationNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0036-rt-parent-ConstructorExAccessibleObjectgetAnnotationNullPointerException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e6074e91be6bf9fbba996ac5b766cf69e6c9f76a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0036-rt-parent-ConstructorExAccessibleObjectgetAnnotationNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExAccessibleObjectgetAnnotationNullPointerException)
+run(ConstructorExAccessibleObjectgetAnnotationNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0037-rt-parent-ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException/ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException.java b/testsuite/java_test/parent_test/RT0037-rt-parent-ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException/ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..2722d639f91b11834bdd5c656959f70cc1778507
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0037-rt-parent-ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException/ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+public class ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerExceptionTest_1();
+            ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerExceptionTest_2();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException.res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerExceptionTest_1() {
+        int result = 4;
+        try {
+            // <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+            AccessibleObject sampleconstructor = SampleClass2.class.getConstructor(String.class);
+            CustomAnnotations2[] a = sampleconstructor.getAnnotationsByType(CustomAnnotations2.class);
+            //System.out.println(a.toString());
+            //System.out.println(a[0].toString());
+            if (a.length == 1 && a.getClass().toString().equals("class [LCustomAnnotations2;")) {
+                ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException.res = ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException.res - 2;
+            }
+        } catch (NullPointerException | SecurityException | NoSuchMethodException e ) {
+            e.printStackTrace();
+        }
+        return result;
+    }
+    private static int ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerExceptionTest_2() {
+        int result = 4;
+        try {
+            // <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+            AccessibleObject sampleconstructor = SampleClass2.class.getConstructor(String.class);
+            sampleconstructor.getAnnotationsByType(null);
+            //System.out.println(a.toString());
+            //System.out.println(a[0].toString());
+        } catch (SecurityException | NoSuchMethodException e) {
+            //e.printStackTrace();
+        } catch (NullPointerException e) {
+            //e.printStackTrace();
+            ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException.res = ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException.res - 2;
+        }
+        return result;
+    }
+}
+@CustomAnnotations2(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass2 {
+    private String sampleField;
+    @CustomAnnotations2(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass2(String s) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations2 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0037-rt-parent-ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0037-rt-parent-ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0037-rt-parent-ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0037-rt-parent-ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0037-rt-parent-ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..757261d5f94dc707e4c7b6f5490d42722330348f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0037-rt-parent-ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException)
+run(ConstructorExAccessibleObjectgetAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0038-rt-parent-ConstructorExAccessibleObjectgetAnnotations/ConstructorExAccessibleObjectgetAnnotations.java b/testsuite/java_test/parent_test/RT0038-rt-parent-ConstructorExAccessibleObjectgetAnnotations/ConstructorExAccessibleObjectgetAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..64f5f61718eeede5735cb5119c59b98c51f2add2
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0038-rt-parent-ConstructorExAccessibleObjectgetAnnotations/ConstructorExAccessibleObjectgetAnnotations.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+public class ConstructorExAccessibleObjectgetAnnotations {
+    static int res = 99;
+    static String eMsg;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExObjectgetAnnotationsTest1();
+        } catch (Exception e) {
+            eMsg = e.toString();
+        }
+        if (result == 4 && ConstructorExAccessibleObjectgetAnnotations.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExObjectgetAnnotationsTest1() {
+        int result1 = 4;
+        try {
+            // Annotation[] getAnnotations()
+            AccessibleObject sampleconstructor = SampleClass0.class.getConstructor(String.class);
+            Annotation[] annotations = sampleconstructor.getAnnotations();
+            if (annotations.length == 1 && annotations.getClass().toString().equals("class [Ljava.lang.annotation.Annotation;")) {
+                ConstructorExAccessibleObjectgetAnnotations.res = ConstructorExAccessibleObjectgetAnnotations.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException e1) {
+            eMsg = e1.toString();
+        }
+        return result1;
+    }
+}
+@CustomAnnotations0(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass0 {
+    private String sampleField;
+    @CustomAnnotations0(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass0(String s) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations0 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0038-rt-parent-ConstructorExAccessibleObjectgetAnnotations/expected.txt b/testsuite/java_test/parent_test/RT0038-rt-parent-ConstructorExAccessibleObjectgetAnnotations/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0038-rt-parent-ConstructorExAccessibleObjectgetAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0038-rt-parent-ConstructorExAccessibleObjectgetAnnotations/test.cfg b/testsuite/java_test/parent_test/RT0038-rt-parent-ConstructorExAccessibleObjectgetAnnotations/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a52a7d01e3cdbf4c3c2df2e97786b3862b91f783
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0038-rt-parent-ConstructorExAccessibleObjectgetAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExAccessibleObjectgetAnnotations)
+run(ConstructorExAccessibleObjectgetAnnotations)
diff --git a/testsuite/java_test/parent_test/RT0039-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException/ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException.java b/testsuite/java_test/parent_test/RT0039-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException/ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..6bc75eef51ac7041745712337c1647b38a727aa2
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0039-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException/ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+public class ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = ConstructorExAccessiblegetDeclaredAnnotationNullPointerExceptionTest_1();
+            ConstructorExAccessiblegetDeclaredAnnotationNullPointerExceptionTest_2();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException.res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int ConstructorExAccessiblegetDeclaredAnnotationNullPointerExceptionTest_2() {
+        int result1 = 4;
+        try {
+            AccessibleObject sampleconstructor = SampleClass3.class.getConstructor(String.class);
+            sampleconstructor.getDeclaredAnnotation(null);
+            //System.out.println(a.toString());
+        } catch (NullPointerException e) {
+            //e.printStackTrace();
+            ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException.res = ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException.res - 2;
+        } catch (NoSuchMethodException | SecurityException e) {
+            //e.printStackTrace();
+        }
+        return result1;
+    }
+    private static int ConstructorExAccessiblegetDeclaredAnnotationNullPointerExceptionTest_1() {
+        int result1 = 4;
+        try {
+            //T getDeclaredAnnotation(Class<T> annotationClass)
+            AccessibleObject sampleconstructor = SampleClass3.class.getConstructor(String.class);
+            CustomAnnotations3 a = sampleconstructor.getDeclaredAnnotation(CustomAnnotations3.class);
+            //System.out.println(a.toString());
+            if (a.toString().equals("@CustomAnnotations3(name=sampleConstructor, value=Sample Constructor Annotation)")) {
+                ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException.res = ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException.res - 2;
+            }
+        } catch (NullPointerException | NoSuchMethodException | SecurityException e) {
+            //e.printStackTrace();
+        }
+        return result1;
+    }
+}
+@CustomAnnotations3(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass3 {
+    private String sampleField;
+    @CustomAnnotations3(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass3(String s) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations3 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0039-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0039-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0039-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0039-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0039-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b1fd41c2aac85cfc23e0c5146b957df245e7918f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0039-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException)
+run(ConstructorExAccessibleObjectgetDeclaredAnnotationNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0040-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.java b/testsuite/java_test/parent_test/RT0040-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..bbb8ac7e55278ed14cc1234a4e4290b6bbb974a3
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0040-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+public class ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerExceptionTest_1();
+            ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerExceptionTest_2();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerExceptionTest_1() {
+        int result1 = 4;
+        AccessibleObject sampleconstructor;
+        try {
+            sampleconstructor = SampleClass5.class.getConstructor(String.class);
+            CustomAnnotations5[] a = sampleconstructor.getDeclaredAnnotationsByType(CustomAnnotations5.class);
+            //System.out.println(a.getClass());
+            if (a.length == 1 && a.getClass().toString().equals("class [LCustomAnnotations5;")) {
+                ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return result1;
+    }
+    private static int ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerExceptionTest_2() {
+        int result1 = 4;
+        AccessibleObject sampleconstructor;
+        try {
+            sampleconstructor = SampleClass5.class.getConstructor(String.class);
+            sampleconstructor.getDeclaredAnnotationsByType(null);
+            //System.out.println(a.getClass());
+        } catch (NoSuchMethodException | SecurityException | NullPointerException e) {
+            //e.printStackTrace();
+            ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 2;
+        }
+        return result1;
+    }
+}
+@CustomAnnotations5(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass5 {
+    private String sampleField;
+    @CustomAnnotations5(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass5(String s) {
+        this.sampleField = s;
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations5 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0040-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0040-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0040-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0040-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0040-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b5858ce05b188da9eb6b5cd9c944a1f118578e87
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0040-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException)
+run(ConstructorExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0041-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotations/ConstructorExAccessibleObjectgetDeclaredAnnotations.java b/testsuite/java_test/parent_test/RT0041-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotations/ConstructorExAccessibleObjectgetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..698240d33a2d55f83a427414f980c8cda7b4f28f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0041-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotations/ConstructorExAccessibleObjectgetDeclaredAnnotations.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+public class ConstructorExAccessibleObjectgetDeclaredAnnotations {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExAccessiblegetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExAccessibleObjectgetDeclaredAnnotations.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExAccessiblegetDeclaredAnnotations1() {
+        int result1 = 4;
+        try {
+            // <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass)
+            AccessibleObject sampleconstructor = SampleClass4.class.getConstructor(String.class);
+            // System.out.println(sampleconstructor.getClass());
+            Annotation[] annotations = sampleconstructor.getDeclaredAnnotations();
+            if (annotations.length == 1 && annotations.getClass().toString().equals("class [Ljava.lang.annotation.Annotation;")) {
+                ConstructorExAccessibleObjectgetDeclaredAnnotations.res = ConstructorExAccessibleObjectgetDeclaredAnnotations.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException e1) {
+            e1.printStackTrace();
+        }
+        return result1;
+    }
+}
+@CustomAnnotations4(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass4 {
+    private String sampleField;
+    @CustomAnnotations4(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass4(String str) {
+        this.sampleField = str;
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations4 {
+    String name();
+    String value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0041-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotations/expected.txt b/testsuite/java_test/parent_test/RT0041-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotations/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0041-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0041-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotations/test.cfg b/testsuite/java_test/parent_test/RT0041-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotations/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e487dbbb54a32cfd148fd5927525476b30170f7e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0041-rt-parent-ConstructorExAccessibleObjectgetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExAccessibleObjectgetDeclaredAnnotations)
+run(ConstructorExAccessibleObjectgetDeclaredAnnotations)
diff --git a/testsuite/java_test/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/ConstructorExAccessibleObjectisAccessible.java b/testsuite/java_test/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/ConstructorExAccessibleObjectisAccessible.java
new file mode 100755
index 0000000000000000000000000000000000000000..729cd076acc66a726f75c8c45d40a111825ecf73
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/ConstructorExAccessibleObjectisAccessible.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+public class ConstructorExAccessibleObjectisAccessible {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExAccessibleObjectisAccessibleTest();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExAccessibleObjectisAccessible.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExAccessibleObjectisAccessibleTest() {
+        int result = 4;
+        try {
+            // boolean isAccessible()
+            AccessibleObject sampleconstructor = SampleClass6.class.getConstructor(String.class);
+            boolean value = sampleconstructor.isAccessible();
+            // System.out.println(a);
+            if (!value) {
+                ConstructorExAccessibleObjectisAccessible.res = ConstructorExAccessibleObjectisAccessible.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException | NullPointerException e) {
+            String eMsg = e.toString();
+        }
+        return result;
+    }
+}
+@CustomAnnotations6(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass6 {
+    private String sampleField;
+    @CustomAnnotations6(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass6(String str) {
+        this.sampleField = str;
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations6 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/expected.txt b/testsuite/java_test/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/test.cfg b/testsuite/java_test/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..78e7548ed3032a4a23d97921912f286f84ad42e7
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExAccessibleObjectisAccessible)
+run(ConstructorExAccessibleObjectisAccessible)
diff --git a/testsuite/java_test/parent_test/RT0043-rt-parent-ConstructorExAccessibleObjectisAnnotationPresentNullPointerException/ConstructorExAccessibleObjectisAnnotationPresentNullPointerException.java b/testsuite/java_test/parent_test/RT0043-rt-parent-ConstructorExAccessibleObjectisAnnotationPresentNullPointerException/ConstructorExAccessibleObjectisAnnotationPresentNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..01b30d28e2af222ba9579efb52117abc8dd411a8
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0043-rt-parent-ConstructorExAccessibleObjectisAnnotationPresentNullPointerException/ConstructorExAccessibleObjectisAnnotationPresentNullPointerException.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+public class ConstructorExAccessibleObjectisAnnotationPresentNullPointerException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        result = ConstructorExAccessibleObjectisAnnotationPresentNullPointerExceptionTest_1();
+        ConstructorExAccessibleObjectisAnnotationPresentNullPointerExceptionTest_2();
+        if (result == 4 && ConstructorExAccessibleObjectisAnnotationPresentNullPointerException.res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int ConstructorExAccessibleObjectisAnnotationPresentNullPointerExceptionTest_1() {
+        int result1 = 4;
+        try {
+            // boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
+            AccessibleObject sampleconstructor = SampleClass7.class.getConstructor(String.class);
+            boolean b = sampleconstructor.isAnnotationPresent(CustomAnnotations7.class);
+            //System.out.println(b);
+            if (b) {
+                ConstructorExAccessibleObjectisAnnotationPresentNullPointerException.res = ConstructorExAccessibleObjectisAnnotationPresentNullPointerException.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return result1;
+    }
+    private static int ConstructorExAccessibleObjectisAnnotationPresentNullPointerExceptionTest_2() {
+        int result1 = 4;
+        try {
+            // boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
+            AccessibleObject sampleconstructor = SampleClass7.class.getConstructor(String.class);
+            sampleconstructor.isAnnotationPresent(null);
+            //System.out.println(b);
+        } catch (NoSuchMethodException | SecurityException | NullPointerException e) {
+            ConstructorExAccessibleObjectisAnnotationPresentNullPointerException.res = ConstructorExAccessibleObjectisAnnotationPresentNullPointerException.res - 2;
+        }
+        return result1;
+    }
+}
+@CustomAnnotations7(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass7 {
+    private String sampleField;
+    @CustomAnnotations7(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass7(String s) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations7 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0043-rt-parent-ConstructorExAccessibleObjectisAnnotationPresentNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0043-rt-parent-ConstructorExAccessibleObjectisAnnotationPresentNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0043-rt-parent-ConstructorExAccessibleObjectisAnnotationPresentNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0043-rt-parent-ConstructorExAccessibleObjectisAnnotationPresentNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0043-rt-parent-ConstructorExAccessibleObjectisAnnotationPresentNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a2778b05cf63e8689fd2bf1707012d89eb800a2d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0043-rt-parent-ConstructorExAccessibleObjectisAnnotationPresentNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExAccessibleObjectisAnnotationPresentNullPointerException)
+run(ConstructorExAccessibleObjectisAnnotationPresentNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/ConstructorExAccessibleObjectsetAccessibleSecurityException.java b/testsuite/java_test/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/ConstructorExAccessibleObjectsetAccessibleSecurityException.java
new file mode 100755
index 0000000000000000000000000000000000000000..8b761712c6eae8cfc7943df7072f16e2ed3bdfbe
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/ConstructorExAccessibleObjectsetAccessibleSecurityException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+public class ConstructorExAccessibleObjectsetAccessibleSecurityException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        result = constructorExAccessibleObjectsetAccessibleSecurityExceptionTest();
+        constructorExAccessibleObjectsetAccessibleSecurityExceptionTest2();
+        if (result == 4 && ConstructorExAccessibleObjectsetAccessibleSecurityException.res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExAccessibleObjectsetAccessibleSecurityExceptionTest() {
+        int result1 = 4;
+        try {
+            // void setAccessible(boolean flag)
+            AccessibleObject sampleconstructor = SampleClass8.class.getConstructor(String.class);
+            sampleconstructor.setAccessible(true);
+            boolean value = sampleconstructor.isAccessible();
+            if (value) {
+                // System.out.println(b);
+                ConstructorExAccessibleObjectsetAccessibleSecurityException.res = ConstructorExAccessibleObjectsetAccessibleSecurityException.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            String eMsg = e.toString();
+        }
+        return result1;
+    }
+    private static void constructorExAccessibleObjectsetAccessibleSecurityExceptionTest2() {
+        try {
+            // static void setAccessible(AccessibleObject[] array, boolean flag)
+            AccessibleObject[] sampleconstructorlist = SampleClass8.class.getConstructors();
+            AccessibleObject.setAccessible(sampleconstructorlist, true);
+            boolean value = sampleconstructorlist[0].isAccessible();
+            if (value) {
+                ConstructorExAccessibleObjectsetAccessibleSecurityException.res = ConstructorExAccessibleObjectsetAccessibleSecurityException.res - 2;
+            }
+        } catch (SecurityException e) {
+            String eMsg = e.toString();
+        }
+    }
+}
+@CustomAnnotations8(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass8 {
+    private String sampleField;
+    @CustomAnnotations8(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass8(String str) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations8 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/expected.txt b/testsuite/java_test/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/test.cfg b/testsuite/java_test/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..190546992d44df1e5ee745a3fa61aee13c2e1ee3
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExAccessibleObjectsetAccessibleSecurityException)
+run(ConstructorExAccessibleObjectsetAccessibleSecurityException)
diff --git a/testsuite/java_test/parent_test/RT0045-rt-parent-ConstructorExExecutablegetAnnotationNullPointerException/ConstructorExExecutablegetAnnotationNullPointerException.java b/testsuite/java_test/parent_test/RT0045-rt-parent-ConstructorExExecutablegetAnnotationNullPointerException/ConstructorExExecutablegetAnnotationNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..e42363f44ac7a91fbbda22afa153a38c34db8104
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0045-rt-parent-ConstructorExExecutablegetAnnotationNullPointerException/ConstructorExExecutablegetAnnotationNullPointerException.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Executable;
+public class ConstructorExExecutablegetAnnotationNullPointerException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExExecutablegetAnnotationNullPointerExceptionTest1();
+            constructorExExecutablegetAnnotationNullPointerExceptionTest2();
+        } catch (Exception e) {
+            ConstructorExExecutablegetAnnotationNullPointerException.res = ConstructorExExecutablegetAnnotationNullPointerException.res - 10;
+        }
+        if (result == 4 && ConstructorExExecutablegetAnnotationNullPointerException.res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExExecutablegetAnnotationNullPointerExceptionTest1() {
+        int result1 = 4;
+        try {
+            // <T extends Annotation> T getAnnotation(Class<T> annotationClass)
+            Executable sampleexecutable = SampleClass9.class.getConstructor(String.class);
+            CustomAnnotations9 annotation = sampleexecutable.getAnnotation(CustomAnnotations9.class);
+            if (annotation.toString().equals("@CustomAnnotations9(name=sampleConstructor, value=Sample Constructor Annotation)")) {
+                ConstructorExExecutablegetAnnotationNullPointerException.res = ConstructorExExecutablegetAnnotationNullPointerException.res - 2;
+            }
+        } catch (NullPointerException | NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return result1;
+    }
+    private static int constructorExExecutablegetAnnotationNullPointerExceptionTest2() {
+        int result1 = 4;
+        try {
+            // <T extends Annotation> T getAnnotation(Class<T> annotationClass)
+            Executable sampleexecutable = SampleClass9.class.getConstructor(String.class);
+            sampleexecutable.getAnnotation(null);
+        } catch (NullPointerException e) {
+            ConstructorExExecutablegetAnnotationNullPointerException.res = ConstructorExExecutablegetAnnotationNullPointerException.res - 2;
+        } catch (NoSuchMethodException | SecurityException e1) {
+            String eMsg = e1.toString();
+        }
+        return result1;
+    }
+}
+@CustomAnnotations9(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass9 {
+    private String sampleField;
+    @CustomAnnotations9(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass9(String str) {
+        this.sampleField = str;
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations9 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0045-rt-parent-ConstructorExExecutablegetAnnotationNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0045-rt-parent-ConstructorExExecutablegetAnnotationNullPointerException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0045-rt-parent-ConstructorExExecutablegetAnnotationNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0045-rt-parent-ConstructorExExecutablegetAnnotationNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0045-rt-parent-ConstructorExExecutablegetAnnotationNullPointerException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..726d48158d8c39ad0099e03fc6332e9e0d5c02e4
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0045-rt-parent-ConstructorExExecutablegetAnnotationNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExExecutablegetAnnotationNullPointerException)
+run(ConstructorExExecutablegetAnnotationNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0046-rt-parent-ConstructorExExecutablegetAnnotationsByTypeNullPointerException/ConstructorExExecutablegetAnnotationsByTypeNullPointerException.java b/testsuite/java_test/parent_test/RT0046-rt-parent-ConstructorExExecutablegetAnnotationsByTypeNullPointerException/ConstructorExExecutablegetAnnotationsByTypeNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..503add506271f81f1af3cdd9af1ac28ec62fc4f4
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0046-rt-parent-ConstructorExExecutablegetAnnotationsByTypeNullPointerException/ConstructorExExecutablegetAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Executable;
+public class ConstructorExExecutablegetAnnotationsByTypeNullPointerException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExExecutablegetAnnotationsByTypeNPExceptionTest1();
+            constructorExExecutablegetAnnotationsByTypeNPExceptionTest1();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExExecutablegetAnnotationsByTypeNullPointerException.res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExExecutablegetAnnotationsByTypeNPExceptionTest1() {
+        int result1 = 4;
+        Executable sampleExecutable;
+        try {
+            // <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+            sampleExecutable = SampleClass10.class.getConstructor(String.class);
+            CustomAnnotations10[] annotations10s = sampleExecutable.getDeclaredAnnotationsByType(CustomAnnotations10.class);
+            // System.out.println(a.getClass());
+            if (annotations10s.length == 1 && annotations10s.getClass().toString().equals("class [LCustomAnnotations10;")) {
+                ConstructorExExecutablegetAnnotationsByTypeNullPointerException.res = ConstructorExExecutablegetAnnotationsByTypeNullPointerException.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return result1;
+    }
+}
+@CustomAnnotations10(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass10 {
+    private String sampleField;
+    @CustomAnnotations10(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass10(String str) {
+        this.sampleField = str;
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations10 {
+    String name();
+    String value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0046-rt-parent-ConstructorExExecutablegetAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0046-rt-parent-ConstructorExExecutablegetAnnotationsByTypeNullPointerException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0046-rt-parent-ConstructorExExecutablegetAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0046-rt-parent-ConstructorExExecutablegetAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0046-rt-parent-ConstructorExExecutablegetAnnotationsByTypeNullPointerException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..5640c7bf539a4d920f0502f1d915a29f7053980d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0046-rt-parent-ConstructorExExecutablegetAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExExecutablegetAnnotationsByTypeNullPointerException)
+run(ConstructorExExecutablegetAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0047-rt-parent-ConstructorExExecutablegetDeclaredAnnotations/ConstructorExExecutablegetDeclaredAnnotations.java b/testsuite/java_test/parent_test/RT0047-rt-parent-ConstructorExExecutablegetDeclaredAnnotations/ConstructorExExecutablegetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..8afe8aad4606090699fcc99998df60c3048ff410
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0047-rt-parent-ConstructorExExecutablegetDeclaredAnnotations/ConstructorExExecutablegetDeclaredAnnotations.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Executable;
+public class ConstructorExExecutablegetDeclaredAnnotations {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExExecutablegetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExExecutablegetDeclaredAnnotations.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExExecutablegetDeclaredAnnotations1() {
+        int result1 = 4;
+        try {
+            Executable sampleExecutable = SampleClass11.class.getConstructor(String.class);
+            Annotation[] annotations = sampleExecutable.getDeclaredAnnotations();
+            if (annotations.length == 1 && annotations.getClass().toString().equals("class [Ljava.lang.annotation.Annotation;")) {
+                ConstructorExExecutablegetDeclaredAnnotations.res = ConstructorExExecutablegetDeclaredAnnotations.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException e1) {
+            e1.printStackTrace();
+        }
+        return result1;
+    }
+}
+@CustomAnnotations11(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass11 {
+    private String sampleField;
+    @CustomAnnotations11(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass11(String s) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations11 {
+    String name();
+    String value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0047-rt-parent-ConstructorExExecutablegetDeclaredAnnotations/expected.txt b/testsuite/java_test/parent_test/RT0047-rt-parent-ConstructorExExecutablegetDeclaredAnnotations/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0047-rt-parent-ConstructorExExecutablegetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0047-rt-parent-ConstructorExExecutablegetDeclaredAnnotations/test.cfg b/testsuite/java_test/parent_test/RT0047-rt-parent-ConstructorExExecutablegetDeclaredAnnotations/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..45ebcd0bc8581c67fb7602634882363471ac63d0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0047-rt-parent-ConstructorExExecutablegetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExExecutablegetDeclaredAnnotations)
+run(ConstructorExExecutablegetDeclaredAnnotations)
diff --git a/testsuite/java_test/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/ConstructorExExecutablegetExceptionTypes.java b/testsuite/java_test/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/ConstructorExExecutablegetExceptionTypes.java
new file mode 100755
index 0000000000000000000000000000000000000000..bc9fcd38e7063488622808ac56ba09c6ca06f522
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/ConstructorExExecutablegetExceptionTypes.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Executable;
+public class ConstructorExExecutablegetExceptionTypes {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExExecutablegetExceptionTypes1();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExExecutablegetExceptionTypes.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExExecutablegetExceptionTypes1() {
+        int result1 = 4;
+        try {
+            // abstract Class[]<?> getExceptionTypes()
+            Executable sampleExecutable = SampleClass12.class.getConstructor(String.class);
+            Class<?>[] vlClass = sampleExecutable.getExceptionTypes();
+            if (vlClass.length == 0 && vlClass.getClass().toString().equals("class [Ljava.lang.Class;")) {
+                ConstructorExExecutablegetExceptionTypes.res = ConstructorExExecutablegetExceptionTypes.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException e1) {
+            String eMsg = e1.toString();
+        }
+        return result1;
+    }
+}
+@CustomAnnotations12(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass12 {
+    private String sampleField;
+    @CustomAnnotations12(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass12(String str) {
+        this.sampleField = str;
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations12 {
+    String name();
+    String value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/expected.txt b/testsuite/java_test/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/test.cfg b/testsuite/java_test/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..dc95dc50458664b17a4ee06af9853869a825f7d7
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExExecutablegetExceptionTypes)
+run(ConstructorExExecutablegetExceptionTypes)
diff --git a/testsuite/java_test/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/ConstructorExExecutablegetGenericParameterTypes.java b/testsuite/java_test/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/ConstructorExExecutablegetGenericParameterTypes.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c074f363c307a3cd6d1b70fc89e879b2fe9dda7
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/ConstructorExExecutablegetGenericParameterTypes.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Executable;
+public class ConstructorExExecutablegetGenericParameterTypes {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    static int run() {
+        int result = 2;
+        try {
+            result = constructorExExecutablegetGenericParameterTypes1();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExExecutablegetGenericParameterTypes.res == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExExecutablegetGenericParameterTypes1() {
+        int result1 = 4;
+        try {
+            // Type[] getGenericParameterTypes()
+            Executable sampleExecutable = SampleClass13.class.getConstructor(String.class);
+            Class<?>[] classes = sampleExecutable.getParameterTypes();
+            if (classes.length == 1 && classes.getClass().toString().equals("class [Ljava.lang.Class;")) {
+                ConstructorExExecutablegetGenericParameterTypes.res = ConstructorExExecutablegetGenericParameterTypes.res - 2;
+            }
+        } catch (NoSuchMethodException | SecurityException e1) {
+            String eMsg = e1.toString();
+        }
+        return result1;
+    }
+}
+@CustomAnnotations13(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass13 {
+    private String sampleField;
+    @CustomAnnotations13(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass13(String str) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations13 {
+    String name();
+    String value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/expected.txt b/testsuite/java_test/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/test.cfg b/testsuite/java_test/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1a7cf58610c7fe4eac1470c7d2d0d88d0ec5a713
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExExecutablegetGenericParameterTypes)
+run(ConstructorExExecutablegetGenericParameterTypes)
diff --git a/testsuite/java_test/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/ConstructorExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/ConstructorExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..801326d44915ff61c355705bf9222e801257b6ca
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/ConstructorExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+public class ConstructorExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+    public static void main(String argv[]) throws NoSuchMethodException, SecurityException {
+        con = SampleClass14.class.getConstructor(String.class);
+        System.out.println(new ConstructorExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2;
+        try {
+            result = constructorExObjectnotifyAllIllegalMonitorStateExceptionTest1();
+        } catch (Exception e) {
+            ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ConstructorExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExObjectnotifyAllIllegalMonitorStateException.res == 57) {
+            result = 0;
+        }
+        return result;
+    }
+    private int constructorExObjectnotifyAllIllegalMonitorStateExceptionTest1() {
+        int result1 = 4;
+        try {
+            con.notifyAll();
+            ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 50;
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 2;
+        }
+        return result1;
+    }
+    private class ConstructorExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        private int remainder;
+        // final void notifyAll()
+        private ConstructorExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con) {
+                try {
+                    con.notifyAll();
+                    ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectnotifyAllIllegalMonitorStateException.res = ConstructorExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+@CustomAnnotations14(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass14 {
+    private String sampleField;
+    @CustomAnnotations14(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass14(String str) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations14 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..274106c52ab6d9be11a27902225ebfe4e766fa85
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExObjectnotifyAllIllegalMonitorStateException)
+run(ConstructorExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/ConstructorExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/ConstructorExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..662854519b90cf1928b80c31dfc30239f3cd58d5
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/ConstructorExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+public class ConstructorExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+    public static void main(String argv[]) throws NoSuchMethodException, SecurityException {
+        con = SampleClass15.class.getConstructor(String.class);
+        System.out.println(new ConstructorExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2;
+        try {
+            result = constructorExObjectnotifyIllegalMonitorStateExceptionTest1();
+        } catch (Exception e) {
+            ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ConstructorExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ConstructorExObjectnotifyIllegalMonitorStateException.res == 57) {
+            result = 0;
+        }
+        return result;
+    }
+    private int constructorExObjectnotifyIllegalMonitorStateExceptionTest1() {
+        int result1 = 4;
+        try {
+            con.notify();
+            ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 50;
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 2;
+        }
+        return result1;
+    }
+    private class ConstructorExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        private int remainder;
+        // final void notify()
+        private ConstructorExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+    /**
+     * Thread run fun
+    */
+
+        public void run() {
+            synchronized (con) {
+                try {
+                    con.notify();
+                    ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectnotifyIllegalMonitorStateException.res = ConstructorExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+@CustomAnnotations15(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass15 {
+    private String sampleField;
+    @CustomAnnotations15(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass15(String s) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations15 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ea470a2fcb4e12523a8be7fa1c3d46da58aa0d8b
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExObjectnotifyIllegalMonitorStateException)
+run(ConstructorExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/ConstructorExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/ConstructorExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..036fecaf0bb1e92f8dff3bfe49768c83dde2c5df
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/ConstructorExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+public class ConstructorExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+    public static void main(String argv[]) throws SecurityException, NoSuchMethodException {
+        con = SampleClass16.class.getConstructor(String.class);
+        System.out.println(new ConstructorExObjectwaitIllegalArgumentException().run());
+    }
+    private class ConstructorExObjectwaitIllegalArgumentException11 implements Runnable {
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait();
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 10;
+                }
+            }
+        }
+    }
+    private class ConstructorExObjectwaitIllegalArgumentException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait(millis);
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class ConstructorExObjectwaitIllegalArgumentException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait(millis, nanos);
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ConstructorExObjectwaitIllegalArgumentException.res = ConstructorExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ConstructorExObjectwaitIllegalArgumentException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ConstructorExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ConstructorExObjectwaitIllegalArgumentException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+        if (result == 2 && ConstructorExObjectwaitIllegalArgumentException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+@CustomAnnotations16(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass16 {
+    private String sampleField;
+    @CustomAnnotations16(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass16(String str) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations16 {
+    String name();
+    String value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d51a4105a36c1c22a96a895fe489d97c47174381
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExObjectwaitIllegalArgumentException)
+run(ConstructorExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/ConstructorExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/ConstructorExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..efdac0f8778e6ec5e7505a0b951a72368d2c5ed1
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/ConstructorExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+public class ConstructorExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+    public static void main(String argv[]) throws SecurityException, NoSuchMethodException {
+        con = SampleClass17.class.getConstructor(String.class);
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = constructorExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = constructorExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = constructorExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ConstructorExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int constructorExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            con.wait();
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int constructorExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            con.wait(millis);
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int constructorExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            con.wait(millis, nanos);
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ConstructorExObjectwaitIllegalMonitorStateException.res = ConstructorExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+@CustomAnnotations17(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass17 {
+    private String sampleField;
+    @CustomAnnotations17(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass17(String str) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations17 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..229489726cdb4bb484663f2af7c387849cad5009
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExObjectwaitIllegalMonitorStateException)
+run(ConstructorExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/ConstructorExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/ConstructorExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..62477ef7d3f5ec1989272f96b9f76679a28f49b8
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/ConstructorExObjectwaitInterruptedException.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+public class ConstructorExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Constructor<?> con = null;
+    public static void main(String argv[]) throws NoSuchMethodException, SecurityException {
+        con = SampleClass18.class.getConstructor(String.class);
+        System.out.println(new ConstructorExObjectwaitInterruptedException().run());
+    }
+    private class ConstructorExObjectwaitInterruptedException11 implements Runnable {
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait();
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class ConstructorExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait(millis);
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class ConstructorExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con) {
+                con.notifyAll();
+                try {
+                    con.wait(millis, nanos);
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ConstructorExObjectwaitInterruptedException.res = ConstructorExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ConstructorExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ConstructorExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ConstructorExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+        if (result == 2 && ConstructorExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+@CustomAnnotations18(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass18 {
+    private String sampleField;
+    @CustomAnnotations18(name = "sampleConstructor", value = "Sample Constructor Annotation")
+    public SampleClass18(String str) {
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@interface CustomAnnotations18 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..51f25da596dc36a073a5c0257a65cb0c62aa6db7
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0054-rt-parent-ConstructorExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExObjectwaitInterruptedException)
+run(ConstructorExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0055-rt-parent-ConstructorExObjectwait/ConstructorExObjectwait.java b/testsuite/java_test/parent_test/RT0055-rt-parent-ConstructorExObjectwait/ConstructorExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..b3d2a768294d8fe8289b04779eda96f57c41a168
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0055-rt-parent-ConstructorExObjectwait/ConstructorExObjectwait.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+public class ConstructorExObjectwait {
+    static int res = 99;
+    private Constructor<?>[] con1 = ConstructorExObjectwait.class.getConstructors();
+    private Constructor<?>[] con2 = ConstructorExObjectwait.class.getConstructors();
+    private Constructor<?>[] con3 = ConstructorExObjectwait.class.getConstructors();
+    public static void main(String argv[]) {
+        System.out.println(new ConstructorExObjectwait().run());
+    }
+    private class ConstructorExObjectwait11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con1) {
+                con1.notifyAll();
+                try {
+                    con1.wait();
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class ConstructorExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con2) {
+                con2.notifyAll();
+                try {
+                    con2.wait(millis);
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private class ConstructorExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (con3) {
+                con3.notifyAll();
+                try {
+                    con3.wait(millis, nanos);
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ConstructorExObjectwait.res = ConstructorExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ConstructorExObjectwait11());
+        Thread t2 = new Thread(new ConstructorExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ConstructorExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ConstructorExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+            t2.interrupt();
+            t2.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && ConstructorExObjectwait.res == 68) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0055-rt-parent-ConstructorExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0055-rt-parent-ConstructorExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0055-rt-parent-ConstructorExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0055-rt-parent-ConstructorExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0055-rt-parent-ConstructorExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f2462b2f7044f1f5038751268093ae419682e2eb
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0055-rt-parent-ConstructorExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorExObjectwait)
+run(ConstructorExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0056-rt-parent-FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException/FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.java b/testsuite/java_test/parent_test/RT0056-rt-parent-FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException/FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..c27de3abfa306c4940e6b89fca79f726c05ac1ba
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0056-rt-parent-FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException/FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Target;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.ElementType;
+import java.lang.reflect.Field;
+public class FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectgetAnnotationsByTypeNullPointerException1();
+        } catch (Exception e) {
+            FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res - 20;
+        }
+        try {
+            result = fieldExAccessibleObjectgetAnnotationsByTypeNullPointerException2();
+        } catch (Exception e) {
+            FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res - 20;
+        }
+        if (result == 4 && FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res == 74) {
+            result = 0;
+        }
+        return result;
+    }
+    private int fieldExAccessibleObjectgetAnnotationsByTypeNullPointerException1() throws NoSuchFieldException, SecurityException {
+        //   <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4; /*STATUS_FAILED*/
+        Field field = SampleClassField2.class.getDeclaredField("id");
+        try {
+            CustomAnnotation2[] tp = field.getAnnotationsByType(CustomAnnotation2.class);
+            if (tp[0].toString().equals("@CustomAnnotation2(value=id)")) {
+                FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res - 10;
+            } else {
+                System.out.println("Failed not as expect");
+                FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res - 15;
+            }
+        } catch (NullPointerException e) {
+            FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res - 15;
+        }
+        return result1;
+    }
+    private int fieldExAccessibleObjectgetAnnotationsByTypeNullPointerException2() throws NoSuchFieldException, SecurityException {
+        // NullPointerException - if the given annotation class is null
+        // <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4; /*STATUS_FAILED*/
+        Field field = SampleClassField2.class.getDeclaredField("id");
+        try {
+            CustomAnnotation2[] tp = field.getAnnotationsByType(null);
+            FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res - 10;
+        } catch (NullPointerException e) {
+            FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotation2(value = "class")
+class SampleClassField2 {
+    @CustomAnnotation2(value = "id")
+    String id;
+    String name;
+}
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Repeatable(CustomAnnotation3.class)
+@interface CustomAnnotation2 {
+    String value();
+}
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotation3 {
+    CustomAnnotation2[] value();
+}
diff --git a/testsuite/java_test/parent_test/RT0056-rt-parent-FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0056-rt-parent-FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0056-rt-parent-FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0056-rt-parent-FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0056-rt-parent-FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7ac5d7a7ec3932d96cfe7aa1d16660671a0845b0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0056-rt-parent-FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException)
+run(FieldExAccessibleObjectgetAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0057-rt-parent-FieldExAccessibleObjectgetAnnotations/FieldExAccessibleObjectgetAnnotations.java b/testsuite/java_test/parent_test/RT0057-rt-parent-FieldExAccessibleObjectgetAnnotations/FieldExAccessibleObjectgetAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..24aebd376eb668dd30f6af3d1a8365e7d6642f4a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0057-rt-parent-FieldExAccessibleObjectgetAnnotations/FieldExAccessibleObjectgetAnnotations.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.reflect.Field;
+public class FieldExAccessibleObjectgetAnnotations {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new FieldExAccessibleObjectgetAnnotations().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectgetAnnotations();
+        } catch (Exception e) {
+            FieldExAccessibleObjectgetAnnotations.res = FieldExAccessibleObjectgetAnnotations.res - 20;
+        }
+        if (result == 4 && FieldExAccessibleObjectgetAnnotations.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int fieldExAccessibleObjectgetAnnotations() throws NoSuchFieldException, SecurityException {
+        //   Annotation[] getAnnotations()
+        int result1 = 4; /*STATUS_FAILED*/
+        Field field = SampleClassField4.class.getDeclaredField("id");
+        try {
+            Annotation[] tp = field.getAnnotations();
+            if (tp[0].toString().equals("@FieldAnnotations(name=id, value=1)")) {
+                FieldExAccessibleObjectgetAnnotations.res = FieldExAccessibleObjectgetAnnotations.res - 10;
+            } else {
+                System.out.println("Failed not as expect");
+                FieldExAccessibleObjectgetAnnotations.res = FieldExAccessibleObjectgetAnnotations.res - 15;
+            }
+        } catch (NullPointerException e) {
+            FieldExAccessibleObjectgetAnnotations.res = FieldExAccessibleObjectgetAnnotations.res - 15;
+        }
+        return result1;
+    }
+}
+class SampleClassField4 {
+    @FieldAnnotations(name = "id", value = "1")
+    String id;
+    String name;
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface FieldAnnotations {
+    String name();
+    String value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0057-rt-parent-FieldExAccessibleObjectgetAnnotations/expected.txt b/testsuite/java_test/parent_test/RT0057-rt-parent-FieldExAccessibleObjectgetAnnotations/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0057-rt-parent-FieldExAccessibleObjectgetAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0057-rt-parent-FieldExAccessibleObjectgetAnnotations/test.cfg b/testsuite/java_test/parent_test/RT0057-rt-parent-FieldExAccessibleObjectgetAnnotations/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8fdf4fe24266266c22eeb4e8139da8933eec2a24
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0057-rt-parent-FieldExAccessibleObjectgetAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExAccessibleObjectgetAnnotations)
+run(FieldExAccessibleObjectgetAnnotations)
diff --git a/testsuite/java_test/parent_test/RT0058-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotation/FieldExAccessibleObjectgetDeclaredAnnotation.java b/testsuite/java_test/parent_test/RT0058-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotation/FieldExAccessibleObjectgetDeclaredAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..ca9af2ff8529650e95e7f5933251a4368a85224a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0058-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotation/FieldExAccessibleObjectgetDeclaredAnnotation.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
+import java.lang.reflect.Field;
+public class FieldExAccessibleObjectgetDeclaredAnnotation {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new FieldExAccessibleObjectgetDeclaredAnnotation().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectgetDeclaredAnnotation1();
+        } catch (Exception e) {
+            FieldExAccessibleObjectgetDeclaredAnnotation.res = FieldExAccessibleObjectgetDeclaredAnnotation.res - 20;
+        }
+        if (result == 4 && FieldExAccessibleObjectgetDeclaredAnnotation.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int fieldExAccessibleObjectgetDeclaredAnnotation1() throws NoSuchFieldException, SecurityException {
+        //    <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass)
+        int result1 = 4; /*STATUS_FAILED*/
+        Field field = SampleClassField3.class.getDeclaredField("id");
+        try {
+            CustomAnnotation4 tp = field.getDeclaredAnnotation(CustomAnnotation4.class);
+            if (tp.toString().equals("@CustomAnnotation4(value=id)")) {
+                FieldExAccessibleObjectgetDeclaredAnnotation.res = FieldExAccessibleObjectgetDeclaredAnnotation.res - 10;
+            } else {
+                System.out.println("Failed not as expect");
+                FieldExAccessibleObjectgetDeclaredAnnotation.res = FieldExAccessibleObjectgetDeclaredAnnotation.res - 15;
+            }
+        } catch (NullPointerException e) {
+            FieldExAccessibleObjectgetDeclaredAnnotation.res = FieldExAccessibleObjectgetDeclaredAnnotation.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotation4(value = "class")
+class SampleClassField3 {
+    @CustomAnnotation4(value = "id")
+    String id;
+    String name;
+}
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Repeatable(CustomAnnotation5.class)
+@interface CustomAnnotation4 {
+    String value();
+}
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotation5 {
+    CustomAnnotation4[] value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0058-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotation/expected.txt b/testsuite/java_test/parent_test/RT0058-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotation/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0058-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0058-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotation/test.cfg b/testsuite/java_test/parent_test/RT0058-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotation/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..922184c8bfcb58a5ad9149e2beb3165815983939
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0058-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExAccessibleObjectgetDeclaredAnnotation)
+run(FieldExAccessibleObjectgetDeclaredAnnotation)
diff --git a/testsuite/java_test/parent_test/RT0059-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.java b/testsuite/java_test/parent_test/RT0059-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..79b757e90f28f63f4fd36c01008678befd468d86
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0059-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+import java.lang.reflect.Field;
+public class FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException {
+    static int res = 99;
+    public static void main(String[] argv) {
+        System.out.println(new FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException().run());
+    }
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = FieldExAccessibleObjectgetDeclaredAnnotationsByType_1();
+        } catch (Exception e) {
+            FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 20;
+        }
+        try {
+            result = FieldExAccessibleObjectgetDeclaredAnnotationsByType_2();
+        } catch (Exception e) {
+            FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 20;
+        }
+        if (result == 4 && FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res == 74) {
+            result = 0;
+        }
+        return result;
+    }
+    private int FieldExAccessibleObjectgetDeclaredAnnotationsByType_1() throws NoSuchFieldException {
+        //  <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4;
+        Field f1 = SampleClassField_h1.class.getDeclaredField("id");
+        try {
+            CustomAnnotations_h1[] tp = f1.getDeclaredAnnotationsByType(CustomAnnotations_h1.class);
+//            System.out.println(tp[0]);
+            if (tp[0].toString().equals("@CustomAnnotations_h1(name=id)")) {
+                FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 10;
+            } else {
+                System.out.println("Failed not as expect");
+                FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 15;
+            }
+        } catch (Exception e) {
+            FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 15;
+        }
+        return result1;
+    }
+    private int FieldExAccessibleObjectgetDeclaredAnnotationsByType_2() throws NoSuchFieldException {
+        //  NullPointerException - if the given annotation class is null
+        //  <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass)
+        int result2 = 4;
+        Field f1 = SampleClassField_h1.class.getDeclaredField("id");
+        try {
+            CustomAnnotations_h1[] tp = f1.getDeclaredAnnotationsByType(null);
+            FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 10;
+        } catch (NullPointerException e) {
+            FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 15;
+        }
+        return result2;
+    }
+}
+class SampleClassField_h1 {
+    @CustomAnnotations_h1(name = "id")
+    String id;
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface CustomAnnotations_h1 {
+    String name();
+}
diff --git a/testsuite/java_test/parent_test/RT0059-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0059-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0059-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0059-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0059-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1cd8bdafb00bdefd6e4cd7e655bb777b512e41a8
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0059-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException)
+run(FieldExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0060-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotations/FieldExAccessibleObjectgetDeclaredAnnotations.java b/testsuite/java_test/parent_test/RT0060-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotations/FieldExAccessibleObjectgetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..0b9fe2553d8557657add95b67609f53d8a2f2424
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0060-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotations/FieldExAccessibleObjectgetDeclaredAnnotations.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Repeatable;
+import java.lang.reflect.Field;
+public class FieldExAccessibleObjectgetDeclaredAnnotations {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new FieldExAccessibleObjectgetDeclaredAnnotations().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectgetDeclaredAnnotations1();
+        } catch (Exception e) {
+            FieldExAccessibleObjectgetDeclaredAnnotations.res = FieldExAccessibleObjectgetDeclaredAnnotations.res - 20;
+        }
+        if (result == 4 && FieldExAccessibleObjectgetDeclaredAnnotations.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int fieldExAccessibleObjectgetDeclaredAnnotations1() throws NoSuchFieldException, SecurityException {
+        //    Annotation[] getDeclaredAnnotations()
+        int result1 = 4; /*STATUS_FAILED*/
+        Field field = SampleClassField5.class.getDeclaredField("id");
+        try {
+            Annotation[] tp = field.getDeclaredAnnotations();
+            if (tp[0].toString().equals("@CustomAnnotation6(value=id)")) {
+                FieldExAccessibleObjectgetDeclaredAnnotations.res = FieldExAccessibleObjectgetDeclaredAnnotations.res - 10;
+            } else {
+                System.out.println("Failed not as expect");
+                FieldExAccessibleObjectgetDeclaredAnnotations.res = FieldExAccessibleObjectgetDeclaredAnnotations.res - 15;
+            }
+        } catch (NullPointerException e) {
+            FieldExAccessibleObjectgetDeclaredAnnotations.res = FieldExAccessibleObjectgetDeclaredAnnotations.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotation6(value = "class")
+class SampleClassField5 {
+    @CustomAnnotation6(value = "id")
+    String id;
+    String name;
+}
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Repeatable(CustomAnnotation7.class)
+@interface CustomAnnotation6 {
+    String value();
+}
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotation7 {
+    CustomAnnotation6[] value();
+}
diff --git a/testsuite/java_test/parent_test/RT0060-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotations/expected.txt b/testsuite/java_test/parent_test/RT0060-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotations/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0060-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0060-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotations/test.cfg b/testsuite/java_test/parent_test/RT0060-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotations/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4580047caad5e1139b6c963ddee8eddb3ad6f8ec
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0060-rt-parent-FieldExAccessibleObjectgetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExAccessibleObjectgetDeclaredAnnotations)
+run(FieldExAccessibleObjectgetDeclaredAnnotations)
diff --git a/testsuite/java_test/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/FieldExAccessibleObjectisAccessible.java b/testsuite/java_test/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/FieldExAccessibleObjectisAccessible.java
new file mode 100755
index 0000000000000000000000000000000000000000..709b26db66dccce3e6918cf36992a0698b1527d7
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/FieldExAccessibleObjectisAccessible.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+public class FieldExAccessibleObjectisAccessible {
+    static int res = 99;
+    public static void main(String[] argv) {
+        System.out.println(new FieldExAccessibleObjectisAccessible().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectisAccessible1();
+        } catch (Exception e) {
+            FieldExAccessibleObjectisAccessible.res = FieldExAccessibleObjectisAccessible.res - 20;
+        }
+        if (result == 4 && FieldExAccessibleObjectisAccessible.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int fieldExAccessibleObjectisAccessible1() throws NoSuchFieldException {
+        //  boolean isAccessible()
+        int result1 = 4;
+        Field f1 = SampleClassFieldH2.class.getDeclaredField("id");
+        try {
+            if(!f1.isAccessible()){
+                FieldExAccessibleObjectisAccessible.res = FieldExAccessibleObjectisAccessible.res - 10;
+            }else{
+                FieldExAccessibleObjectisAccessible.res = FieldExAccessibleObjectisAccessible.res - 15;
+            }
+        } catch (Exception e) {
+            FieldExAccessibleObjectisAccessible.res = FieldExAccessibleObjectisAccessible.res - 15;
+        }
+        return result1;
+    }
+}
+class SampleClassFieldH2 {
+    @CustomAnnotationsH2(name = "id")
+    String id;
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface CustomAnnotationsH2 {
+    String name();
+}
diff --git a/testsuite/java_test/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/expected.txt b/testsuite/java_test/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/test.cfg b/testsuite/java_test/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..88c580d9e7467e1a763c69a6a2b18d3095855b0f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0061-rt-parent-FieldExAccessibleObjectisAccessible/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExAccessibleObjectisAccessible)
+run(FieldExAccessibleObjectisAccessible)
diff --git a/testsuite/java_test/parent_test/RT0062-rt-parent-FieldExAccessibleObjectisAnnotationPresentNullPointerException/FieldExAccessibleObjectisAnnotationPresentNullPointerException.java b/testsuite/java_test/parent_test/RT0062-rt-parent-FieldExAccessibleObjectisAnnotationPresentNullPointerException/FieldExAccessibleObjectisAnnotationPresentNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..c8b12b30345f0e605029d9c30dbe464960edad33
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0062-rt-parent-FieldExAccessibleObjectisAnnotationPresentNullPointerException/FieldExAccessibleObjectisAnnotationPresentNullPointerException.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+public class FieldExAccessibleObjectisAnnotationPresentNullPointerException {
+    static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(new FieldExAccessibleObjectisAnnotationPresentNullPointerException().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectisAnnotationPresentNullPointerException1();
+        } catch (Exception e) {
+            FieldExAccessibleObjectisAnnotationPresentNullPointerException.res = FieldExAccessibleObjectisAnnotationPresentNullPointerException.res - 20;
+        }
+        try {
+            result = fieldExAccessibleObjectisAnnotationPresentNullPointerException2();
+        } catch (Exception e) {
+            FieldExAccessibleObjectisAnnotationPresentNullPointerException.res = FieldExAccessibleObjectisAnnotationPresentNullPointerException.res - 20;
+        }
+        if (result == 4 && FieldExAccessibleObjectisAnnotationPresentNullPointerException.res == 74) {
+            result = 0;
+        }
+        return result;
+    }
+    private int fieldExAccessibleObjectisAnnotationPresentNullPointerException1() throws NoSuchFieldException {
+        //  boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
+        int result1 = 4;
+        Field f1 = SampleClassFieldH3.class.getDeclaredField("id");
+        try {
+            if (f1.isAnnotationPresent(CustomAnnotationsH3.class)) {
+                FieldExAccessibleObjectisAnnotationPresentNullPointerException.res = FieldExAccessibleObjectisAnnotationPresentNullPointerException.res - 10;
+            } else {
+                FieldExAccessibleObjectisAnnotationPresentNullPointerException.res = FieldExAccessibleObjectisAnnotationPresentNullPointerException.res - 15;
+            }
+        } catch (Exception e) {
+            FieldExAccessibleObjectisAnnotationPresentNullPointerException.res = FieldExAccessibleObjectisAnnotationPresentNullPointerException.res - 15;
+        }
+        return result1;
+    }
+    private int fieldExAccessibleObjectisAnnotationPresentNullPointerException2() throws NoSuchFieldException {
+        int result2 = 4;
+        // NullPointerException - if the given annotation class is null
+        // boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
+        Field f1 = SampleClassFieldH3.class.getDeclaredField("id");
+        try {
+            boolean tp = f1.isAnnotationPresent(null);
+            FieldExAccessibleObjectisAnnotationPresentNullPointerException.res = FieldExAccessibleObjectisAnnotationPresentNullPointerException.res - 10;
+        } catch (NullPointerException e) {
+            FieldExAccessibleObjectisAnnotationPresentNullPointerException.res = FieldExAccessibleObjectisAnnotationPresentNullPointerException.res - 15;
+        }
+        return result2;
+    }
+}
+class SampleClassFieldH3 {
+    @CustomAnnotationsH3(name = "id")
+    String id;
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface CustomAnnotationsH3 {
+    String name();
+}
diff --git a/testsuite/java_test/parent_test/RT0062-rt-parent-FieldExAccessibleObjectisAnnotationPresentNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0062-rt-parent-FieldExAccessibleObjectisAnnotationPresentNullPointerException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0062-rt-parent-FieldExAccessibleObjectisAnnotationPresentNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0062-rt-parent-FieldExAccessibleObjectisAnnotationPresentNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0062-rt-parent-FieldExAccessibleObjectisAnnotationPresentNullPointerException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2c64d996d8f3bd5cfe33d9d7f9f09b474aad6c37
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0062-rt-parent-FieldExAccessibleObjectisAnnotationPresentNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExAccessibleObjectisAnnotationPresentNullPointerException)
+run(FieldExAccessibleObjectisAnnotationPresentNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/FieldExAccessibleObjectsetAccessibleSecurityException.java b/testsuite/java_test/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/FieldExAccessibleObjectsetAccessibleSecurityException.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e35a5c90d007ef991768a949ba9c6e5cac7e7fa
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/FieldExAccessibleObjectsetAccessibleSecurityException.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+public class FieldExAccessibleObjectsetAccessibleSecurityException {
+    static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(new FieldExAccessibleObjectsetAccessibleSecurityException().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectsetAccessibleSecurityException1();
+        } catch (Exception e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 20;
+        }
+        try {
+            result = fieldExAccessibleObjectsetAccessibleSecurityException2();
+        } catch (Exception e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 20;
+        }
+        if (result == 4 && FieldExAccessibleObjectsetAccessibleSecurityException.res == 59) {
+            result = 0;
+        }
+        return result;
+    }
+    private int fieldExAccessibleObjectsetAccessibleSecurityException1() throws NoSuchFieldException {
+        //  void setAccessible(boolean flag)
+        int result1 = 4;
+        Field f1 = SampleClassFieldH4.class.getDeclaredField("id");
+        try {
+            f1.setAccessible(false);
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 10;
+        } catch (SecurityException e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 15;
+        }
+        try {
+            f1.setAccessible(true);
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 10;
+        } catch (SecurityException e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 15;
+        }
+        return result1;
+    }
+    private int fieldExAccessibleObjectsetAccessibleSecurityException2() throws NoSuchFieldException {
+        //  static void setAccessible(AccessibleObject[] array, boolean flag)
+        int result2 = 4;
+        Constructor[] test = AccessibleObject.class.getDeclaredConstructors();
+        try {
+            AccessibleObject.setAccessible(test, false);
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 10;
+        } catch (SecurityException e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 15;
+        }
+        try {
+            AccessibleObject.setAccessible(test, true);
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 10;
+        } catch (SecurityException e) {
+            FieldExAccessibleObjectsetAccessibleSecurityException.res = FieldExAccessibleObjectsetAccessibleSecurityException.res - 15;
+        }
+        return result2;
+    }
+}
+class SampleClassFieldH4 {
+    @CustomAnnotationsH4(name = "id")
+    String id;
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface CustomAnnotationsH4 {
+    String name();
+}
diff --git a/testsuite/java_test/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/expected.txt b/testsuite/java_test/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/test.cfg b/testsuite/java_test/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7600536ffa1b68eccf0f935b8bfde20585221c35
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExAccessibleObjectsetAccessibleSecurityException)
+run(FieldExAccessibleObjectsetAccessibleSecurityException)
diff --git a/testsuite/java_test/parent_test/RT0064-rt-parent-FieldExObjectgetClass/FieldExObjectgetClass.java b/testsuite/java_test/parent_test/RT0064-rt-parent-FieldExObjectgetClass/FieldExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..0a22182c962679fe25ea17f5b0ce7a114a774da6
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0064-rt-parent-FieldExObjectgetClass/FieldExObjectgetClass.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExObjectgetClass1();
+        } catch (Exception e) {
+            FieldExObjectgetClass.res = FieldExObjectgetClass.res - 20;
+        }
+        if (result == 4 && FieldExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int fieldExObjectgetClass1() {
+        //  final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        Field[] f1 = FieldExObjectgetClass.class.getDeclaredFields();
+        Class px1 = f1[0].getClass();
+        if (px1.toString().equals("class java.lang.reflect.Field")) {
+            FieldExObjectgetClass.res = FieldExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0064-rt-parent-FieldExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0064-rt-parent-FieldExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0064-rt-parent-FieldExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0064-rt-parent-FieldExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0064-rt-parent-FieldExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..eb7fa0084fd18d2a8b2b93b98751e5519bf591ae
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0064-rt-parent-FieldExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExObjectgetClass)
+run(FieldExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/FieldExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/FieldExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..e8ad0edbad4f68bd52554002772bf8ad77e32305
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/FieldExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private Field[] rp = FieldExObjectnotifyAllIllegalMonitorStateException.class.getDeclaredFields();
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && FieldExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectnotifyAllIllegalMonitorStateException.res = FieldExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c655096ea3b063910ecdff338135224129708a09
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExObjectnotifyAllIllegalMonitorStateException)
+run(FieldExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/FieldExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/FieldExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd883dc18eed34cc11c29b8b5f0cd7a4e475a3dd
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/FieldExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private Field[] rp = FieldExObjectnotifyIllegalMonitorStateException.class.getDeclaredFields();
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && FieldExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notify();
+            FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectnotifyIllegalMonitorStateException.res = FieldExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ce2a682fd0daa30817de01d5f652d6a659b0600b
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExObjectnotifyIllegalMonitorStateException)
+run(FieldExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/FieldExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/FieldExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..bc5b544642c4e770cefefa32087644fa3c704d20
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/FieldExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private Field[] fields = FieldExObjectwaitIllegalArgumentException.class.getDeclaredFields();
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectwaitIllegalArgumentException().run());
+    }
+    private class FieldExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait(millis);
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class FieldExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait(millis, nanos);
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    FieldExObjectwaitIllegalArgumentException.res = FieldExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new FieldExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new FieldExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && FieldExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..cac7029b3cba03d70ef337fb92dcceb9232380a0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExObjectwaitIllegalArgumentException)
+run(FieldExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/FieldExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/FieldExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..079eb1947a0d51154197402bc0f15ae4fe133092
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/FieldExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Field[] fields = FieldExObjectwaitIllegalMonitorStateException.class.getDeclaredFields();
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = fieldExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = fieldExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = fieldExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && FieldExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int fieldExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            fields[0].wait();
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int fieldExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            fields[0].wait(millis);
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int fieldExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            fields[0].wait(millis, nanos);
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            FieldExObjectwaitIllegalMonitorStateException.res = FieldExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..dfaad731db07fad607734aa13ab4049cf5c5255e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExObjectwaitIllegalMonitorStateException)
+run(FieldExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/FieldExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/FieldExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..07d501dadd53d62d49ef14b0b545e8afbaa98cab
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/FieldExObjectwaitInterruptedException.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Field[] fields = FieldExObjectwaitInterruptedException.class.getDeclaredFields();
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        System.out.println(new FieldExObjectwaitInterruptedException().run());
+    }
+    private class FieldExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait();
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    private class FieldExObjectwaitInterruptedException12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait(millis);
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    private class FieldExObjectwaitInterruptedException13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (fields[0]) {
+                fields[0].notifyAll();
+                try {
+                    fields[0].wait(millis, nanos);
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwaitInterruptedException.res = FieldExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new FieldExObjectwaitInterruptedException11());
+        Thread t2 = new Thread(new FieldExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new FieldExObjectwaitInterruptedException12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new FieldExObjectwaitInterruptedException13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && FieldExObjectwaitInterruptedException.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2d9dab97ba6cba13f165be741647254be4b0f717
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0069-rt-parent-FieldExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExObjectwaitInterruptedException)
+run(FieldExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0070-rt-parent-FieldExObjectwait/FieldExObjectwait.java b/testsuite/java_test/parent_test/RT0070-rt-parent-FieldExObjectwait/FieldExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..c127ceaa8dd57d058d49a1f56dacae429354313b
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0070-rt-parent-FieldExObjectwait/FieldExObjectwait.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldExObjectwait {
+    static int res = 99;
+    private Field[] cal = FieldExObjectwait.class.getDeclaredFields();
+    private Field[] cal2 = FieldExObjectwait.class.getDeclaredFields();
+    private Field[] cal3 = FieldExObjectwait.class.getDeclaredFields();
+    public static void main(String argv[]) {
+        System.out.println(new FieldExObjectwait().run());
+    }
+    private class FieldExObjectwait11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal) {
+                cal.notifyAll();
+                try {
+                    cal.wait();
+                    FieldExObjectwait.res = FieldExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class FieldExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal2) {
+                cal2.notifyAll();
+                try {
+                    cal2.wait(millis);
+                    FieldExObjectwait.res = FieldExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private class FieldExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal3) {
+                cal3.notifyAll();
+                try {
+                    cal3.wait(millis, nanos);
+                    FieldExObjectwait.res = FieldExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    FieldExObjectwait.res = FieldExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new FieldExObjectwait11());
+        Thread t2 = new Thread(new FieldExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new FieldExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new FieldExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && FieldExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0070-rt-parent-FieldExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0070-rt-parent-FieldExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0070-rt-parent-FieldExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0070-rt-parent-FieldExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0070-rt-parent-FieldExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e62bcc41f61e94303248ef0a159c463776c46ff7
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0070-rt-parent-FieldExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldExObjectwait)
+run(FieldExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0071-rt-parent-MethodExAccessibleObjectgetAnnotationNullPointerException/MethodExAccessibleObjectgetAnnotationNullPointerException.java b/testsuite/java_test/parent_test/RT0071-rt-parent-MethodExAccessibleObjectgetAnnotationNullPointerException/MethodExAccessibleObjectgetAnnotationNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..9ebe48ec658042865541ea2ce83b2a5d92fa051a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0071-rt-parent-MethodExAccessibleObjectgetAnnotationNullPointerException/MethodExAccessibleObjectgetAnnotationNullPointerException.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodExAccessibleObjectgetAnnotationNullPointerException {
+    static int res = 100;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExAccessibleObjectgetAnnotationNullPointerException1();
+        } catch (Exception e) {
+            MethodExAccessibleObjectgetAnnotationNullPointerException.res = MethodExAccessibleObjectgetAnnotationNullPointerException.res - 10;
+        }
+        try {
+            result = methodExAccessibleObjectgetAnnotationNullPointerException2();
+        } catch (Exception e) {
+            MethodExAccessibleObjectgetAnnotationNullPointerException.res = MethodExAccessibleObjectgetAnnotationNullPointerException.res - 10;
+        }
+        if (result == 4 && MethodExAccessibleObjectgetAnnotationNullPointerException.res == 75) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int methodExAccessibleObjectgetAnnotationNullPointerException1() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - If the specified object is empty.
+        // <T extends Annotation> T getAnnotation(Class<T> annotationClass)
+        Method sampleMethod = MethodClass9.class.getMethod("sampleMethod");
+        try {
+            sampleMethod.getAnnotation(null);
+            MethodExAccessibleObjectgetAnnotationNullPointerException.res -= 10;
+        } catch (NullPointerException e1) {
+            MethodExAccessibleObjectgetAnnotationNullPointerException.res = MethodExAccessibleObjectgetAnnotationNullPointerException.res - 15;
+        }
+        return result1;
+    }
+    private static int methodExAccessibleObjectgetAnnotationNullPointerException2() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // <T extends Annotation> T getAnnotation(Class<T> annotationClass)
+        Method sampleMethod = MethodClass9.class.getMethod("sampleMethod");
+        try {
+            MethodAnnotation get1 = sampleMethod.getAnnotation(MethodAnnotation.class);
+            if (get1.toString().equals("@MethodAnnotation(name=sampleMethod, value=Sample Method Annotation)")) {
+                MethodExAccessibleObjectgetAnnotationNullPointerException.res -= 10;
+            }
+        } catch (NullPointerException e1) {
+            MethodExAccessibleObjectgetAnnotationNullPointerException.res = MethodExAccessibleObjectgetAnnotationNullPointerException.res - 15;
+        }
+        return result1;
+    }
+}
+@MethodAnnotation(name = "SampleClass", value = "Sample Class Annotation")
+class MethodClass9 {
+    private String sampleField;
+    @MethodAnnotation(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@interface MethodAnnotation {
+    String name();
+    String value();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0071-rt-parent-MethodExAccessibleObjectgetAnnotationNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0071-rt-parent-MethodExAccessibleObjectgetAnnotationNullPointerException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0071-rt-parent-MethodExAccessibleObjectgetAnnotationNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0071-rt-parent-MethodExAccessibleObjectgetAnnotationNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0071-rt-parent-MethodExAccessibleObjectgetAnnotationNullPointerException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..53018427c137805d9f304c7bed76a7a6eee69c12
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0071-rt-parent-MethodExAccessibleObjectgetAnnotationNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExAccessibleObjectgetAnnotationNullPointerException)
+run(MethodExAccessibleObjectgetAnnotationNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0072-rt-parent-MethodExAccessibleObjectgetAnnotations/MethodExAccessibleObjectgetAnnotations.java b/testsuite/java_test/parent_test/RT0072-rt-parent-MethodExAccessibleObjectgetAnnotations/MethodExAccessibleObjectgetAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..d23ce5b2cb0ee069611a1b0fee467fdaf62ed6f3
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0072-rt-parent-MethodExAccessibleObjectgetAnnotations/MethodExAccessibleObjectgetAnnotations.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodExAccessibleObjectgetAnnotations {
+    private static int res = 99;
+    public static void main(String[] args) {
+        System.out.println(new MethodExAccessibleObjectgetAnnotations().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = fieldExAccessibleObjectsetAccessibleSecurityException1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            MethodExAccessibleObjectgetAnnotations.res = MethodExAccessibleObjectgetAnnotations.res - 20;
+        }
+        if (result == 4 && MethodExAccessibleObjectgetAnnotations.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int fieldExAccessibleObjectsetAccessibleSecurityException1() throws NoSuchMethodException {
+        //  Annotation[] getAnnotations()
+        int result1 = 4;
+        Method method = SampleClassH4.class.getMethod("sampleMethod");
+        try {
+            Annotation[] tp = method.getAnnotations();
+            if (tp.length == 1 &&
+                    tp[0].toString().equals("@CustomAnnotationsH9(name=sampleMethod, value=Sample Method Annotation)")) {
+                MethodExAccessibleObjectgetAnnotations.res = MethodExAccessibleObjectgetAnnotations.res - 10;
+            }
+        } catch (Exception e) {
+            MethodExAccessibleObjectgetAnnotations.res = MethodExAccessibleObjectgetAnnotations.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotationsH9(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClassH4 {
+    private String sampleField;
+    @CustomAnnotationsH9(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotationsH9 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0072-rt-parent-MethodExAccessibleObjectgetAnnotations/expected.txt b/testsuite/java_test/parent_test/RT0072-rt-parent-MethodExAccessibleObjectgetAnnotations/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0072-rt-parent-MethodExAccessibleObjectgetAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0072-rt-parent-MethodExAccessibleObjectgetAnnotations/test.cfg b/testsuite/java_test/parent_test/RT0072-rt-parent-MethodExAccessibleObjectgetAnnotations/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d88b04b8e6d65b609085085c228223c850847fe5
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0072-rt-parent-MethodExAccessibleObjectgetAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExAccessibleObjectgetAnnotations)
+run(MethodExAccessibleObjectgetAnnotations)
diff --git a/testsuite/java_test/parent_test/RT0073-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException/MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.java b/testsuite/java_test/parent_test/RT0073-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException/MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..295d26a0df5991b05d01a5abc9f1843149abbbb5
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0073-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException/MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException {
+    private static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException().run());
+    }
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res - 20;
+        }
+        try {
+            result = MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException_2();
+        } catch (Exception e) {
+            e.printStackTrace();
+            MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res - 20;
+        }
+        if (result == 4 && MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res == 74) {
+            result = 0;
+        }
+        return result;
+    }
+    private int MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException_1() throws NoSuchMethodException {
+        //   <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4; /*STATUS_FAILED*/
+        Method m = SampleClass_h6.class.getMethod("sampleMethod");
+        try {
+            CustomAnnotations_h11[] tp = m.getAnnotationsByType(CustomAnnotations_h11.class);
+            if (tp.length == 1 &&
+                    tp[0].toString().equals("@CustomAnnotations_h11(name=sampleMethod, value=Sample Method Annotation)")) {
+                MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res - 10;
+            }
+        } catch (Exception e) {
+            MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res - 15;
+        }
+        return result1;
+    }
+    private int MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException_2() throws NoSuchMethodException {
+        //   NullPointerException - if the given annotation class is null
+        //   <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4; /*STATUS_FAILED*/
+        Method m = SampleClass_h6.class.getMethod("sampleMethod");
+        try {
+            m.getAnnotationsByType(null);
+            MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res - 10;
+        } catch (NullPointerException e) {
+            MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotations_h11(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass_h6 {
+    private String sampleField;
+    @CustomAnnotations_h11(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotations_h11 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0073-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0073-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0073-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0073-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0073-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e1794cf70908ceff459357e489b9f2ce7222def8
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0073-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException)
+run(MethodExAccessibleObjectgetDeclaredAnnotationNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0074-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.java b/testsuite/java_test/parent_test/RT0074-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..0cf6fde229d9acfacfc81cc05535a82ce7c70c48
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0074-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException {
+    private static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException().run());
+    }
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException_1();
+        } catch (Exception e) {
+            MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 20;
+        }
+        try {
+            result = MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException_2();
+        } catch (Exception e) {
+            MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 20;
+        }
+        if (result == 4 && MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res == 74) {
+            result = 0;
+        }
+        return result;
+    }
+    private int MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException_1() throws NoSuchMethodException {
+        //   <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4; /*STATUS_FAILED*/
+        Method m = SampleClass_h8.class.getMethod("sampleMethod");
+        try {
+            CustomAnnotations_h13[] tp = m.getAnnotationsByType(CustomAnnotations_h13.class);
+            if (tp.length == 1 &&
+                    tp[0].toString().equals("@CustomAnnotations_h13(name=sampleMethod, value=Sample Method Annotation)")) {
+                MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 10;
+            }
+        } catch (Exception e) {
+            MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 15;
+        }
+        return result1;
+    }
+    private int MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException_2() throws NoSuchMethodException {
+        //   NullPointerException - if the given annotation class is null
+        //   <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4; /*STATUS_FAILED*/
+        Method m = SampleClass_h8.class.getMethod("sampleMethod");
+        try {
+            CustomAnnotations_h13[] tp = m.getAnnotationsByType(null);
+            MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 10;
+        } catch (NullPointerException e) {
+            MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res = MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotations_h13(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClass_h8 {
+    private String sampleField;
+    @CustomAnnotations_h13(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotations_h13 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0074-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0074-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0074-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0074-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0074-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7fcb7f58e096772a0d119a2efc9efee5da9d831a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0074-rt-parent-MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException)
+run(MethodExAccessibleObjectgetDeclaredAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/MethodExAccessibleObjectisAccessible.java b/testsuite/java_test/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/MethodExAccessibleObjectisAccessible.java
new file mode 100755
index 0000000000000000000000000000000000000000..19d13e4fb31de35562982ddf13f4165ef4be5f49
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/MethodExAccessibleObjectisAccessible.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodExAccessibleObjectisAccessible {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExAccessibleObjectisAccessible1();
+        } catch (Exception e) {
+            MethodExAccessibleObjectisAccessible.res = MethodExAccessibleObjectisAccessible.res - 10;
+        }
+        if (result == 4 && MethodExAccessibleObjectisAccessible.res == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int methodExAccessibleObjectisAccessible1() throws NoSuchMethodException, SecurityException, NoSuchFieldException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // boolean isAccessible()
+        Method sampleMethod = MethodClass11.class.getMethod("sampleMethod");
+        if (sampleMethod.isAccessible()) {
+            MethodExAccessibleObjectisAccessible.res = MethodExAccessibleObjectisAccessible.res - 10;
+        } else {
+            MethodExAccessibleObjectisAccessible.res = MethodExAccessibleObjectisAccessible.res - 1;
+        }
+        return result1;
+    }
+}
+@CustomAnnotationn(name = "SampleClass", value = "Sample Class Annotation")
+class MethodClass11 {
+    private String sampleField;
+    @CustomAnnotationn(name = "sampleMethod", value = "Sample Class Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@interface CustomAnnotationn {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/expected.txt b/testsuite/java_test/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/test.cfg b/testsuite/java_test/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e7aa27dcecb499348d67bab4cbe86b9922db06cb
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0075-rt-parent-MethodExAccessibleObjectisAccessible/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExAccessibleObjectisAccessible)
+run(MethodExAccessibleObjectisAccessible)
diff --git a/testsuite/java_test/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/MethodExAccessibleObjectisAnnotationPresentNullPointerException.java b/testsuite/java_test/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/MethodExAccessibleObjectisAnnotationPresentNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..0132a3a8db62a85d699936e9e2ae7684b0d52473
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/MethodExAccessibleObjectisAnnotationPresentNullPointerException.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodExAccessibleObjectisAnnotationPresentNullPointerException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExAccessibleObjectisAnnotationPresentNullPointerException1();
+        } catch (Exception e) {
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 20;
+        }
+        try {
+            result = methodExAccessibleObjectisAnnotationPresentNullPointerException2();
+        } catch (Exception e) {
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 20;
+        }
+        if (result == 4 && MethodExAccessibleObjectisAnnotationPresentNullPointerException.res == 68) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int methodExAccessibleObjectisAnnotationPresentNullPointerException1() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - If the specified object is empty.
+        Method sampleMethod = MethodClass8.class.getMethod("sampleMethod");
+        try {
+            sampleMethod.isAnnotationPresent(null);
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 10;
+        } catch (NullPointerException e1) {
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 1;
+        }
+        return result1;
+    }
+    private static int methodExAccessibleObjectisAnnotationPresentNullPointerException2() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // NullPointerException - If the specified object is empty.
+        // boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
+        Method sampleMethod = MethodClass8.class.getMethod("sampleMethod");
+        try {
+            sampleMethod.isAnnotationPresent(CustomAnnotationH100.class);
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 30;
+        } catch (NullPointerException e1) {
+            MethodExAccessibleObjectisAnnotationPresentNullPointerException.res = MethodExAccessibleObjectisAnnotationPresentNullPointerException.res - 5;
+        }
+        return result1;
+    }
+}
+@CustomAnnotationH100(name = "SampleClass", value = "Sample Class Annotation")
+class MethodClass8 {
+    private String sampleField;
+    @CustomAnnotationH100(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotationH100 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..230d3acff2d5779d575a96ab16970e586eddbfff
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExAccessibleObjectisAnnotationPresentNullPointerException)
+run(MethodExAccessibleObjectisAnnotationPresentNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/MethodExAccessibleObjectSetAccessible.java b/testsuite/java_test/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/MethodExAccessibleObjectSetAccessible.java
new file mode 100755
index 0000000000000000000000000000000000000000..7241491a7ea161e2fc576c3ab6234ba8fdfd0d1d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/MethodExAccessibleObjectSetAccessible.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Method;
+public class MethodExAccessibleObjectSetAccessible {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExAccessibleObjectSetAccessible1();
+        } catch (Exception e) {
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 10;
+        }
+        try {
+            result = methodExAccessibleObjectSetAccessible2();
+        } catch (Exception e) {
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 10;
+        }
+        if (result == 4 && MethodExAccessibleObjectSetAccessible.res == 79) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int methodExAccessibleObjectSetAccessible1() throws NoSuchFieldException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // SecurityException - Exception safety
+        // static void setAccessible(AccessibleObject[] array, boolean flag)
+        Method[] sampleMethod = MethodClass14.class.getMethods();
+        try {
+            AccessibleObject.setAccessible(sampleMethod, false);
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 10;
+        } catch (SecurityException e1) {
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 1;
+        }
+        return result1;
+    }
+    private static int methodExAccessibleObjectSetAccessible2() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // SecurityException - Exception safety
+        //  void setAccessible(boolean flag)
+        Method sampleMethod = MethodClass14.class.getMethod("sampleMethod");
+        try {
+            sampleMethod.setAccessible(false);
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 10;
+        } catch (SecurityException e1) {
+            MethodExAccessibleObjectSetAccessible.res = MethodExAccessibleObjectSetAccessible.res - 1;
+        }
+        return result1;
+    }
+}
+@CustomAnnotationwe(name = "SampleClass", value = "Sample Class Annotation")
+class MethodClass14 {
+    private String sampleField;
+    @CustomAnnotationwe(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@interface CustomAnnotationwe {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/expected.txt b/testsuite/java_test/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/test.cfg b/testsuite/java_test/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7650331deac9b49d9a9eb20c278944de3bbe98ca
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0077-rt-parent-MethodExAccessibleObjectSetAccessible/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExAccessibleObjectSetAccessible)
+run(MethodExAccessibleObjectSetAccessible)
diff --git a/testsuite/java_test/parent_test/RT0078-rt-parent-MethodExecutablegetDeclaredAnnotations/MethodExecutablegetDeclaredAnnotations.java b/testsuite/java_test/parent_test/RT0078-rt-parent-MethodExecutablegetDeclaredAnnotations/MethodExecutablegetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..10cf1fc5323f8fd15145aeed3c699efab75e32c5
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0078-rt-parent-MethodExecutablegetDeclaredAnnotations/MethodExecutablegetDeclaredAnnotations.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodExecutablegetDeclaredAnnotations {
+    private static int res = 99;
+    public static void main(String[] argv) {
+        System.out.println(new MethodExecutablegetDeclaredAnnotations().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExecutablegetDeclaredAnnotations1();
+        } catch (Exception e) {
+            MethodExecutablegetDeclaredAnnotations.res = MethodExecutablegetDeclaredAnnotations.res - 20;
+        }
+        if (result == 4 && MethodExecutablegetDeclaredAnnotations.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int methodExecutablegetDeclaredAnnotations1() throws NoSuchMethodException {
+        //  Annotation[] getDeclaredAnnotations()
+        int result1 = 4;
+        Method m1 = SampleClassH2.class.getDeclaredMethod("sampleMethod");
+        try {
+            Annotation[] tp = m1.getDeclaredAnnotations();
+            if (tp.length == 1 &&
+                    tp[0].toString().equals("@CustomAnnotationsH60(name=sampleMethod, value=Sample Method Annotation)")) {
+                MethodExecutablegetDeclaredAnnotations.res = MethodExecutablegetDeclaredAnnotations.res - 10;
+            }
+        } catch (Exception e) {
+            MethodExecutablegetDeclaredAnnotations.res = MethodExecutablegetDeclaredAnnotations.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotationsH60(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClassH2 {
+    private String sampleField;
+    @CustomAnnotationsH60(name = "sampleMethod", value = "Sample Method Annotation")
+    public String sampleMethod() {
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@Retention(RetentionPolicy.RUNTIME)
+@interface CustomAnnotationsH60 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0078-rt-parent-MethodExecutablegetDeclaredAnnotations/expected.txt b/testsuite/java_test/parent_test/RT0078-rt-parent-MethodExecutablegetDeclaredAnnotations/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0078-rt-parent-MethodExecutablegetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0078-rt-parent-MethodExecutablegetDeclaredAnnotations/test.cfg b/testsuite/java_test/parent_test/RT0078-rt-parent-MethodExecutablegetDeclaredAnnotations/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..af9a545b50af83c0f5ec9d9dc7143cae12541174
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0078-rt-parent-MethodExecutablegetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExecutablegetDeclaredAnnotations)
+run(MethodExecutablegetDeclaredAnnotations)
diff --git a/testsuite/java_test/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/MethodExExecutablegetAnnotationsByTypeNullPointerException.java b/testsuite/java_test/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/MethodExExecutablegetAnnotationsByTypeNullPointerException.java
new file mode 100644
index 0000000000000000000000000000000000000000..eab46124f7a4f30329aa98e900c720933550bf45
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/MethodExExecutablegetAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodExExecutablegetAnnotationsByTypeNullPointerException {
+    static int res = 99;
+    public static void main(String[] argv) {
+        System.out.println(new MethodExExecutablegetAnnotationsByTypeNullPointerException().run());
+    }
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = MethodExExecutablegetAnnotationsByTypeNullPointerException_1();
+        } catch (Exception e) {
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 20;
+        }
+        try {
+            result = MethodExExecutablegetAnnotationsByTypeNullPointerException_2();
+        } catch (Exception e) {
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 20;
+        }
+        if (result == 4 && MethodExExecutablegetAnnotationsByTypeNullPointerException.res == 74) {
+            result = 0;
+        }
+        return result;
+    }
+    private int MethodExExecutablegetAnnotationsByTypeNullPointerException_1() throws NoSuchMethodException {
+        //  <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4;
+        Method m1 = SampleClass_h1.class.getDeclaredMethod("sampleMethod");
+        try {
+            CustomAnnotations_h5[] tp = m1.getAnnotationsByType(CustomAnnotations_h5.class);
+            if(tp.getClass().toString().equals("class [LCustomAnnotations_h5;")){
+                MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 10;
+            }
+        } catch (Exception e) {
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 15;
+        }
+        return result1;
+    }
+    private int MethodExExecutablegetAnnotationsByTypeNullPointerException_2() throws NoSuchMethodException {
+        //  NullPointerException - if the given annotation class is null
+        //  <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass)
+        int result1 = 4;
+        Method m1 = SampleClass_h1.class.getDeclaredMethod("sampleMethod");
+        try {
+            CustomAnnotations_h5[] tp = m1.getAnnotationsByType(null);
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 10;
+        } catch (NullPointerException e) {
+            MethodExExecutablegetAnnotationsByTypeNullPointerException.res = MethodExExecutablegetAnnotationsByTypeNullPointerException.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotations_h5(name="SampleClass",  value = "Sample Class Annotation")
+class SampleClass_h1 {
+    private String sampleField;
+    @CustomAnnotations_h5(name="sampleMethod",  value = "Sample Method Annotation")
+    public String sampleMethod(){
+        return "sample";
+    }
+    public String getSampleField() {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@interface CustomAnnotations_h5 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..09d9394fce3f1da09a232b9526bce1d861fde912
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExExecutablegetAnnotationsByTypeNullPointerException)
+run(MethodExExecutablegetAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/parent_test/RT0080-rt-parent-MethodExExecutablegetGenericExceptionTypesExceptions/MethodExExecutablegetGenericExceptionTypesExceptions.java b/testsuite/java_test/parent_test/RT0080-rt-parent-MethodExExecutablegetGenericExceptionTypesExceptions/MethodExExecutablegetGenericExceptionTypesExceptions.java
new file mode 100755
index 0000000000000000000000000000000000000000..7672ff062f701a4e1018a66f9224c447ed3738db
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0080-rt-parent-MethodExExecutablegetGenericExceptionTypesExceptions/MethodExExecutablegetGenericExceptionTypesExceptions.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+public class MethodExExecutablegetGenericExceptionTypesExceptions {
+    static int res = 99;
+    public static void main(String[] argv) {
+        System.out.println(new MethodExExecutablegetGenericExceptionTypesExceptions().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExExecutablegetGenericExceptionTypesExceptions1();
+        } catch (Exception e) {
+            MethodExExecutablegetGenericExceptionTypesExceptions.res = MethodExExecutablegetGenericExceptionTypesExceptions.res - 20;
+        }
+        if (result == 4 && MethodExExecutablegetGenericExceptionTypesExceptions.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int methodExExecutablegetGenericExceptionTypesExceptions1() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        //  Type[] getGenericExceptionTypes()
+        int result1 = 4;
+        Method m1 = SampleClassH111.class.getDeclaredMethod("getSampleField");
+        try {
+            Type[] tp = m1.getGenericExceptionTypes();
+            if (Arrays.toString(tp).equals("[class java.lang.ArrayIndexOutOfBoundsException]")) {
+                MethodExExecutablegetGenericExceptionTypesExceptions.res = MethodExExecutablegetGenericExceptionTypesExceptions.res - 10;
+            }
+        } catch (Exception e) {
+            MethodExExecutablegetGenericExceptionTypesExceptions.res = MethodExExecutablegetGenericExceptionTypesExceptions.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotationsH111(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClassH111 {
+    private String sampleField;
+    public String getSampleField() throws ArrayIndexOutOfBoundsException {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@interface CustomAnnotationsH111 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0080-rt-parent-MethodExExecutablegetGenericExceptionTypesExceptions/expected.txt b/testsuite/java_test/parent_test/RT0080-rt-parent-MethodExExecutablegetGenericExceptionTypesExceptions/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0080-rt-parent-MethodExExecutablegetGenericExceptionTypesExceptions/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0080-rt-parent-MethodExExecutablegetGenericExceptionTypesExceptions/test.cfg b/testsuite/java_test/parent_test/RT0080-rt-parent-MethodExExecutablegetGenericExceptionTypesExceptions/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4bc31de423c116f32d07943394c37ab6da861677
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0080-rt-parent-MethodExExecutablegetGenericExceptionTypesExceptions/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExExecutablegetGenericExceptionTypesExceptions)
+run(MethodExExecutablegetGenericExceptionTypesExceptions)
diff --git a/testsuite/java_test/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/MethodExExecutablegetGenericParameterTypesExceptions.java b/testsuite/java_test/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/MethodExExecutablegetGenericParameterTypesExceptions.java
new file mode 100755
index 0000000000000000000000000000000000000000..79033e4889566211077d9e7d80bca8deaece8aa1
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/MethodExExecutablegetGenericParameterTypesExceptions.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+public class MethodExExecutablegetGenericParameterTypesExceptions {
+    static int res = 99;
+    public static void main(String[] argv) {
+        System.out.println(new MethodExExecutablegetGenericParameterTypesExceptions().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExExecutablegetGenericParameterTypesExceptions1();
+        } catch (Exception e) {
+            MethodExExecutablegetGenericParameterTypesExceptions.res = MethodExExecutablegetGenericParameterTypesExceptions.res - 20;
+        }
+        if (result == 4 && MethodExExecutablegetGenericParameterTypesExceptions.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int methodExExecutablegetGenericParameterTypesExceptions1() throws NoSuchMethodException {
+        //  Type[] getGenericParameterTypes()
+        int result1 = 4;
+        Method m1 = SampleClassH3.class.getDeclaredMethod("getSampleField");
+        try {
+            Type[] tp = m1.getGenericParameterTypes();
+            if (Arrays.toString(tp).equals("[]")) {
+                MethodExExecutablegetGenericParameterTypesExceptions.res = MethodExExecutablegetGenericParameterTypesExceptions.res - 10;
+            }
+        } catch (Exception e) {
+            MethodExExecutablegetGenericParameterTypesExceptions.res = MethodExExecutablegetGenericParameterTypesExceptions.res - 15;
+        }
+        return result1;
+    }
+}
+@CustomAnnotationsH8(name = "SampleClass", value = "Sample Class Annotation")
+class SampleClassH3 {
+    private String sampleField;
+    public String getSampleField() throws ArrayIndexOutOfBoundsException {
+        return sampleField;
+    }
+    public void setSampleField(String sampleField) {
+        this.sampleField = sampleField;
+    }
+}
+@interface CustomAnnotationsH8 {
+    String name();
+    String value();
+}
diff --git a/testsuite/java_test/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/expected.txt b/testsuite/java_test/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/test.cfg b/testsuite/java_test/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6666b7d28b8512eaa2135289132794e6fb2d1f10
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExExecutablegetGenericParameterTypesExceptions)
+run(MethodExExecutablegetGenericParameterTypesExceptions)
diff --git a/testsuite/java_test/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/MethodExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/MethodExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..84ce0cc4295dd6c35b688b7d716f7641d3fb9b2a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/MethodExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private Method[] rp = MethodExObjectnotifyAllIllegalMonitorStateException.class.getMethods();
+    public static void main(String argv[]) {
+        System.out.println(new MethodExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && MethodExObjectnotifyAllIllegalMonitorStateException.res == 68) {
+            result = 0;
+        }
+        return result;
+    }
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp[0].notifyAll();
+            MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp[0].notifyAll();
+                    MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectnotifyAllIllegalMonitorStateException.res = MethodExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..cceeae75e9478c8abffdc3e74444602b1a715057
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExObjectnotifyAllIllegalMonitorStateException)
+run(MethodExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/MethodExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/MethodExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..80e7841220b6ef0677ef753f4de88b4f8f3064cc
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/MethodExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private Method[] rp = MethodExObjectnotifyIllegalMonitorStateException.class.getMethods();
+    public static void main(String argv[]) {
+        System.out.println(new MethodExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = methodExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new MethodExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && MethodExObjectnotifyIllegalMonitorStateException.res == 68) {
+            result = 0;
+        }
+        return result;
+    }
+    private int methodExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp[0].notify();
+            MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class MethodExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+    /**
+     * Thread run fun
+    */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp[0].notify();
+                    MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectnotifyIllegalMonitorStateException.res = MethodExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..76dd788837a1a26fe1b91ba3167fe583edcc0a78
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExObjectnotifyIllegalMonitorStateException)
+run(MethodExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/MethodExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/MethodExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..54eea971c255d0fe7e4c62d5236482e9a8d376cb
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/MethodExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    static Method[] methods = MethodExObjectwaitIllegalArgumentException.class.getMethods();
+    public static void main(String argv[]) {
+        System.out.println(new MethodExObjectwaitIllegalArgumentException().run());
+    }
+    private class MethodExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait(millis);
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class MethodExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait(millis, nanos);
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    MethodExObjectwaitIllegalArgumentException.res = MethodExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new MethodExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new MethodExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && MethodExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..cf7c00d464cae8f2b2f5638c8474230c11ab438f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExObjectwaitIllegalArgumentException)
+run(MethodExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/MethodExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/MethodExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..5d4b8cb2ae4c88cdff1ce6bfd7e65269fe960e0b
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/MethodExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static Method[] methods = MethodExObjectwaitIllegalMonitorStateException.class.getMethods();
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = methodExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = methodExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = methodExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && MethodExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int methodExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            methods[0].wait();
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int methodExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            methods[0].wait(millis);
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int methodExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            methods[0].wait(millis, nanos);
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            MethodExObjectwaitIllegalMonitorStateException.res = MethodExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..097c4da92cafd81352a51e9076d9e2495a8f5d22
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExObjectwaitIllegalMonitorStateException)
+run(MethodExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/MethodExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/MethodExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..be292228d4b4a5f0317572d23db735c62a8a3d47
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/MethodExObjectwaitInterruptedException.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodExObjectwaitInterruptedException {
+    static int res = 99;
+    static Method[] methods = MethodExObjectwaitInterruptedException.class.getMethods();
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        System.out.println(new MethodExObjectwaitInterruptedException().run());
+    }
+    private class MethodExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait();
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    private class MethodExObjectwaitInterruptedException12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait(millis);
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    private class MethodExObjectwaitInterruptedException13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (methods[0]) {
+                methods[0].notifyAll();
+                try {
+                    methods[0].wait(millis, nanos);
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwaitInterruptedException.res = MethodExObjectwaitInterruptedException.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new MethodExObjectwaitInterruptedException11());
+        Thread t2 = new Thread(new MethodExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new MethodExObjectwaitInterruptedException12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new MethodExObjectwaitInterruptedException13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && MethodExObjectwaitInterruptedException.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..41f88a3d264124de5d97fa05297176b6ada21ad0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0086-rt-parent-MethodExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExObjectwaitInterruptedException)
+run(MethodExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0087-rt-parent-MethodExObjectwait/MethodExObjectwait.java b/testsuite/java_test/parent_test/RT0087-rt-parent-MethodExObjectwait/MethodExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..bcf468b95d5e1c7bd572be8a9e78fdcaa7d53655
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0087-rt-parent-MethodExObjectwait/MethodExObjectwait.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodExObjectwait {
+    static int res = 99;
+    private Method[] cal = MethodExObjectwait.class.getMethods();
+    private Method[] cal2 = MethodExObjectwait.class.getMethods();
+    private Method[] cal3 = MethodExObjectwait.class.getMethods();
+    public static void main(String argv[]) {
+        System.out.println(new MethodExObjectwait().run());
+    }
+    private class MethodExObjectwait11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal) {
+                cal.notifyAll();
+                try {
+                    cal.wait();
+                    MethodExObjectwait.res = MethodExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class MethodExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal2) {
+                cal2.notifyAll();
+                try {
+                    cal2.wait(millis);
+                    MethodExObjectwait.res = MethodExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class MethodExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cal3) {
+                cal3.notifyAll();
+                try {
+                    cal3.wait(millis, nanos);
+                    MethodExObjectwait.res = MethodExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    MethodExObjectwait.res = MethodExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new MethodExObjectwait11());
+        Thread t2 = new Thread(new MethodExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new MethodExObjectwait12());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new MethodExObjectwait13());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && MethodExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0087-rt-parent-MethodExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0087-rt-parent-MethodExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0087-rt-parent-MethodExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0087-rt-parent-MethodExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0087-rt-parent-MethodExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c14b6904a71552644b49a3682e4cb396ea58019f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0087-rt-parent-MethodExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodExObjectwait)
+run(MethodExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/ModifierExObjectgetClass.java b/testsuite/java_test/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/ModifierExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..1cb851dc607377b1f98250630c657a8d87ff23e2
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/ModifierExObjectgetClass.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class ModifierExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = modifierExObjectgetClass1();
+        } catch (Exception e) {
+            ModifierExObjectgetClass.res = ModifierExObjectgetClass.res - 20;
+        }
+        if (result == 4 && ModifierExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int modifierExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+        Modifier mf2 = new Modifier();
+        Class px1 = mf2.getClass();
+        if (px1.toString().equals("class java.lang.reflect.Modifier")) {
+            ModifierExObjectgetClass.res = ModifierExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e37f88cbf6339abb7f6fd5410d43961651ea22aa
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0088-rt-parent-ModifierExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ModifierExObjectgetClass)
+run(ModifierExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/ModifierExObjecthashCode.java b/testsuite/java_test/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/ModifierExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..35f45656b2bef11ce8954ad01fbf524c9a54d549
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/ModifierExObjecthashCode.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class ModifierExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = modifierExObjecthashCode1();
+        } catch (Exception e) {
+            ModifierExObjecthashCode.res = ModifierExObjecthashCode.res - 20;
+        }
+        if (result == 4 && ModifierExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int modifierExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        Modifier mf0 = new Modifier();
+        Modifier mf1 = mf0;
+        Modifier mf2 = new Modifier();
+        int px0 = mf0.hashCode();
+        int px1 = mf1.hashCode();
+        int px2 = mf2.hashCode();
+        if (px0 == px1 && px0 != px2) {
+            ModifierExObjecthashCode.res = ModifierExObjecthashCode.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4b2b81396d0838e921f8b7b370689544030317ef
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0089-rt-parent-ModifierExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(ModifierExObjecthashCode)
+run(ModifierExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/ModifierExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/ModifierExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..9c57deb54c6332fa6020fe70fc27bf55ccf0920f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/ModifierExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class ModifierExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    Modifier mf2 = new Modifier();
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = modifierExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ModifierExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ModifierExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int modifierExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            mf2.notifyAll();
+            ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ModifierExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+        private ModifierExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notifyAll();
+                    ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectnotifyAllIllegalMonitorStateException.res = ModifierExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d3e8bfe12b45e5d1e4f75df825343578b469a9a4
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ModifierExObjectnotifyAllIllegalMonitorStateException)
+run(ModifierExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/ModifierExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/ModifierExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..30e84832d13d1ff2d0a43e8e78b12a317d24ed13
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/ModifierExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class ModifierExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    Modifier mf2 = new Modifier();
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = modifierExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ModifierExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ModifierExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int modifierExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            mf2.notify();
+            ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ModifierExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ModifierExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notify();
+                    ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectnotifyIllegalMonitorStateException.res = ModifierExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..93ff3b9fc0c46c43b6c823dfd7b0450ab1b00b8d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ModifierExObjectnotifyIllegalMonitorStateException)
+run(ModifierExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/ModifierExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/ModifierExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..922bc7bafaee6068fa7b2c9e923fbb8c95b7092a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/ModifierExObjectwaitInterruptedException.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class ModifierExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Modifier mf2 = new Modifier();
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectwaitInterruptedException().run());
+    }
+    private class ModifierExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ModifierExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait();
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class ModifierExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+        private ModifierExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class ModifierExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+        private ModifierExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwaitInterruptedException.res = ModifierExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ModifierExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ModifierExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ModifierExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+        if (result == 2 && ModifierExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..995cc2a7801f22565696a8446d189a46c17ec50f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0092-rt-parent-ModifierExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ModifierExObjectwaitInterruptedException)
+run(ModifierExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0093-rt-parent-ModifierExObjectwait/ModifierExObjectwait.java b/testsuite/java_test/parent_test/RT0093-rt-parent-ModifierExObjectwait/ModifierExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..78293ec764ebfed926e1d91bd4077a0bfeeb2365
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0093-rt-parent-ModifierExObjectwait/ModifierExObjectwait.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class ModifierExObjectwait {
+    static int res = 99;
+    private Modifier mf2 = new Modifier();
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectwait().run());
+    }
+    private class ModifierExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ModifierExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait();
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+    private class ModifierExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+        private ModifierExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notify();
+                try {
+                    mf2.wait(millis);
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    private class ModifierExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+        private ModifierExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwait.res = ModifierExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * join fun
+     *
+     * @param thread want join thread
+    */
+
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ModifierExObjectwait11(1));
+        Thread t2 = new Thread(new ModifierExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ModifierExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ModifierExObjectwait31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+        t2.interrupt();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        if (result == 2 && ModifierExObjectwait.res == 54) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0093-rt-parent-ModifierExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0093-rt-parent-ModifierExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0093-rt-parent-ModifierExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0093-rt-parent-ModifierExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0093-rt-parent-ModifierExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f3a0c26b212ce7c61a0906dee42ec6f58ae71368
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0093-rt-parent-ModifierExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ModifierExObjectwait)
+run(ModifierExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/ParameterExObjectgetClass.java b/testsuite/java_test/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/ParameterExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..0dd0321768763e87a7e6462c18e5ff41d5da1f5c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/ParameterExObjectgetClass.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ParameterExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterExObjectgetClass1();
+        } catch (Exception e) {
+            System.out.println(e);
+            ParameterExObjectgetClass.res = ParameterExObjectgetClass.res - 20;
+        }
+        if (result == 4 && ParameterExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int parameterExObjectgetClass1() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+        // System.out.println("-0-");
+        Method method = Parameter01a.class.getMethod("getName", new Class[]{String.class});
+        // System.out.println("-1-");
+        Parameter[] parameters = method.getParameters();
+        // System.out.println("-2-");
+        Class px1 = parameters[0].getClass();
+        // System.out.println(px1);
+        if (px1.toString().equals("class java.lang.reflect.Parameter")) {
+            ParameterExObjectgetClass.res = ParameterExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
+class Parameter01a {
+    String name = "default";
+    public String getName(String str1) {
+        return this.name;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9c8180ad0946acce9907725f964b40ad25b46f58
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0094-rt-parent-ParameterExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterExObjectgetClass)
+run(ParameterExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/ParameterExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/ParameterExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..74b3a323afd24985349e63e0fd7157232e5a17fb
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/ParameterExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Parameter;
+import java.lang.reflect.Method;
+public class ParameterExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ParameterExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ParameterExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ParameterExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int parameterExObjectnotifyAllIllegalMonitorStateException1() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        Method method = Parameter03a.class.getMethod("getName", new Class[]{String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            parameters[0].notifyAll();
+            ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ParameterExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        private int remainder;
+        private ParameterExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            Method me = null;
+            try {
+                me = Parameter03a.class.getMethod("getName", new Class[]{String.class});
+            } catch (NoSuchMethodException | SecurityException e) {
+                e.printStackTrace();
+            }
+            Parameter[] parameters = me.getParameters();
+            synchronized (parameters[0]) {
+                try {
+                    parameters[0].notifyAll();
+                    ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ParameterExObjectnotifyAllIllegalMonitorStateException.res = ParameterExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+class Parameter03a {
+    private String name = "default";
+    public String getName(String str1) {
+        return str1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f4f8b597d0f464c884580eed0d876b8f7f815079
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterExObjectnotifyAllIllegalMonitorStateException)
+run(ParameterExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/ParameterExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/ParameterExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..40b2def88a0b375e72b3994da93265352bebd3b9
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/ParameterExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Parameter;
+import java.lang.reflect.Method;
+public class ParameterExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ParameterExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = parameterExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ParameterExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ParameterExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int parameterExObjectnotifyIllegalMonitorStateException1() throws NoSuchMethodException, SecurityException {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        Method method = Parameter02a.class.getMethod("getName", new Class[]{String.class});
+        Parameter[] parameters = method.getParameters();
+        try {
+            parameters[0].notify();
+            ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ParameterExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ParameterExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            Method me = null;
+            try {
+                me = Parameter02a.class.getMethod("getName", new Class[]{String.class});
+            } catch (NoSuchMethodException | SecurityException e) {
+                e.printStackTrace();
+            }
+            Parameter[] parameters = me.getParameters();
+            synchronized (parameters[0]) {
+                try {
+                    parameters[0].notify();
+                    ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ParameterExObjectnotifyIllegalMonitorStateException.res = ParameterExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+class Parameter02a {
+    private String name = "default";
+    public String getName(String str1) {
+        return str1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2d4189077ff964790dc9a5bbe40416f5af049b95
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterExObjectnotifyIllegalMonitorStateException)
+run(ParameterExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0097-rt-parent-ParameterExObjectwait/ParameterExObjectwait.java b/testsuite/java_test/parent_test/RT0097-rt-parent-ParameterExObjectwait/ParameterExObjectwait.java
new file mode 100644
index 0000000000000000000000000000000000000000..fdc0607d0d6c08b56f330d8ef50a2f733c95733f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0097-rt-parent-ParameterExObjectwait/ParameterExObjectwait.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Parameter;
+public class ParameterExObjectwait {
+    static int res = 99;
+    private static Parameter[] param = null;
+    public static void main(String argv[]) {
+        try {
+            param = ParameterExObjectwait.class.getMethod("sleep", new Class[]{int.class}).getParameters();
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        System.out.println(new ParameterExObjectwait().run());
+    }
+    private class ParameterExObjectwait_11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ParameterExObjectwait_11(int remainder) {
+            this.remainder = remainder;
+        }
+        public void run() {
+            synchronized (param[0]) {
+                param[0].notifyAll();
+                try {
+                    param[0].wait();
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    //System.out.println("111");
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    //System.out.println("222");
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+    private class ParameterExObjectwait_21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+        private ParameterExObjectwait_21(int remainder) {
+            this.remainder = remainder;
+        }
+        public void run() {
+            synchronized (param[0]) {
+                param[0].notify();
+                try {
+                    param[0].wait(millis);
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    private class ParameterExObjectwait_31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+        private ParameterExObjectwait_31(int remainder) {
+            this.remainder = remainder;
+        }
+        public void run() {
+            synchronized (param[0]) {
+                param[0].notifyAll();
+                try {
+                    param[0].wait(millis, nanos);
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ParameterExObjectwait.res = ParameterExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        //check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ParameterExObjectwait_11(1));
+        Thread t2 = new Thread(new ParameterExObjectwait_11(2));
+        //final void wait(long millis)
+        Thread t3 = new Thread(new ParameterExObjectwait_21(3));
+        //final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ParameterExObjectwait_31(5));
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        t1.interrupt();
+        t2.interrupt();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        if (result == 2 && ParameterExObjectwait.res == 54) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("ParameterExObjectwait.res: " + ParameterExObjectwait.res);
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0097-rt-parent-ParameterExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0097-rt-parent-ParameterExObjectwait/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0097-rt-parent-ParameterExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0097-rt-parent-ParameterExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0097-rt-parent-ParameterExObjectwait/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9a6799e20206413e71e056089c33ccde2d9b4159
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0097-rt-parent-ParameterExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterExObjectwait)
+run(ParameterExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/ProxyExObjecthashCode.java b/testsuite/java_test/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/ProxyExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..3fd44e08a73acec2f6cc90cfff6765095627d0b6
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/ProxyExObjecthashCode.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+public class ProxyExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = proxyExObjecthashCode1();
+        } catch (Exception e) {
+            ProxyExObjecthashCode.res = ProxyExObjecthashCode.res - 20;
+        }
+        if (result == 4 && ProxyExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int proxyExObjecthashCode1() {
+        //  int hashCode()
+        int result1 = 4; /*STATUS_FAILED*/
+        MyProxy1 px0 = new MyProxy1(new MyInvocationHandler());
+        MyProxy1 px1 = px0;
+        MyProxy1 px2 = new MyProxy1(new MyInvocationHandler());
+        try {
+            int int0 = px0.hashCode();
+            int int1 = px1.hashCode();
+            int int2 = px2.hashCode();
+            if (px0 == px1 && px0 != px2) {
+                ProxyExObjecthashCode.res = ProxyExObjecthashCode.res - 10;
+            }
+        } catch (IllegalMonitorStateException e) {
+            ProxyExObjecthashCode.res = ProxyExObjecthashCode.res - 1;
+        }
+        return result1;
+    }
+}
+class MyProxy1 extends Proxy {
+    MyProxy1(InvocationHandler h) {
+        super(h);
+    }
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+class MyInvocationHandler implements InvocationHandler {
+    /**
+     * invoke test
+     * @param proxy proxy test
+     * @param method method for test
+     * @param args object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+    */
+
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c4ed28718c1d49c31bffb0e5e95f62c059549b7a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0098-rt-parent-ProxyExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(ProxyExObjecthashCode)
+run(ProxyExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/ProxyExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/ProxyExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..fb1ed6df2ccb7f59f94f3c120c00431a1637e414
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/ProxyExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+public class ProxyExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private MyProxy3 proxy = new MyProxy3(new MyInvocationHandler2());
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = proxyExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ProxyExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ProxyExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int proxyExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            proxy.notifyAll();
+            ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ProxyExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+        private ProxyExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                try {
+                    proxy.notifyAll();
+                    ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectnotifyAllIllegalMonitorStateException.res = ProxyExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+class MyProxy3 extends Proxy {
+    MyProxy3(InvocationHandler h) {
+        super(h);
+    }
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+class MyInvocationHandler2 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+    */
+
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..75d7c0876e11cf839749a9e924daaf1816ad810e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ProxyExObjectnotifyAllIllegalMonitorStateException)
+run(ProxyExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/ProxyExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/ProxyExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..45227caae4d170c2ade4b38939ccdbf24fc6686f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/ProxyExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+public class ProxyExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private MyProxy2 proxy = new MyProxy2(new MyInvocationHandler1());
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = proxyExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ProxyExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ProxyExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int proxyExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            proxy.notify();
+            ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ProxyExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ProxyExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                try {
+                    proxy.notify();
+                    ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectnotifyIllegalMonitorStateException.res = ProxyExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
+class MyProxy2 extends Proxy {
+    MyProxy2(InvocationHandler h) {
+        super(h);
+    }
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+class MyInvocationHandler1 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+    */
+
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7d78e53f26e4dd1fd7529dc8ceb765aac36ab6da
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ProxyExObjectnotifyIllegalMonitorStateException)
+run(ProxyExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/ProxyExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/ProxyExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..f20a2345aec41986a17320b9b698681f11d07720
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/ProxyExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+public class ProxyExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private MyProxy5 proxy = new MyProxy5(new MyInvocationHandler5());
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectwaitIllegalArgumentException().run());
+    }
+    private class ProxyExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+        private ProxyExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis);
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class ProxyExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+        private ProxyExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis, nanos);
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwaitIllegalArgumentException.res = ProxyExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ProxyExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ProxyExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ProxyExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
+class MyProxy5 extends Proxy {
+    MyProxy5(InvocationHandler h) {
+        super(h);
+    }
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+class MyInvocationHandler5 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+    */
+
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8ab31fcd6b85c759eb307ddc08874bcf20fb0ba3
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(ProxyExObjectwaitIllegalArgumentException)
+run(ProxyExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/ProxyExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/ProxyExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f48c09d07969c032d768e0ff34ed4c1dfdc65d5
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/ProxyExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+public class ProxyExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = proxyExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = proxyExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = proxyExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ProxyExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int proxyExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        MyProxy7 proxy = new MyProxy7(new MyInvocationHandler6());
+        try {
+            proxy.wait();
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int proxyExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        MyProxy7 proxy = new MyProxy7(new MyInvocationHandler6());
+        long millis = 123;
+        try {
+            proxy.wait(millis);
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int proxyExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        MyProxy7 proxy = new MyProxy7(new MyInvocationHandler6());
+        long millis = 123;
+        int nanos = 10;
+        try {
+            proxy.wait(millis, nanos);
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ProxyExObjectwaitIllegalMonitorStateException.res = ProxyExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
+class MyProxy7 extends Proxy {
+    MyProxy7(InvocationHandler h) {
+        super(h);
+    }
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+class MyInvocationHandler6 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+    */
+
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ee22a7c65d23db0032ded9d241d85e351f854e48
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ProxyExObjectwaitIllegalMonitorStateException)
+run(ProxyExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/ProxyExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/ProxyExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..7dd63783f512c5bc79a69543fe428df2e89a2477
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/ProxyExObjectwaitInterruptedException.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationHandler;
+public class ProxyExObjectwaitInterruptedException {
+    static int res = 99;
+    private MyProxy8 proxy = new MyProxy8(new MyInvocationHandler7());
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectwaitInterruptedException().run());
+    }
+    private class ProxyExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ProxyExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait();
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class ProxyExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+        private ProxyExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis);
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class ProxyExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+        private ProxyExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis, nanos);
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwaitInterruptedException.res = ProxyExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ProxyExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ProxyExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ProxyExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+        if (result == 2 && ProxyExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
+class MyProxy8 extends Proxy {
+    MyProxy8(InvocationHandler h) {
+        super(h);
+    }
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+class MyInvocationHandler7 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+    */
+
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f56ac1eff1ab70a98171e23412d8234ce056982f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0103-rt-parent-ProxyExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ProxyExObjectwaitInterruptedException)
+run(ProxyExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0104-rt-parent-ProxyExObjectwait/ProxyExObjectwait.java b/testsuite/java_test/parent_test/RT0104-rt-parent-ProxyExObjectwait/ProxyExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..e8b507514c60e128bc07df53e1c883fc20436a40
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0104-rt-parent-ProxyExObjectwait/ProxyExObjectwait.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+public class ProxyExObjectwait {
+    static int res = 99;
+    private MyProxy4 proxy = new MyProxy4(new MyInvocationHandler3());
+    public static void main(String argv[]) {
+        System.out.println(new ProxyExObjectwait().run());
+    }
+    private class ProxyExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ProxyExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait();
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+    private class ProxyExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+        private ProxyExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis);
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    private class ProxyExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+        private ProxyExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (proxy) {
+                proxy.notifyAll();
+                try {
+                    proxy.wait(millis, nanos);
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ProxyExObjectwait.res = ProxyExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * join fun
+     *
+     * @param thread wait join thread
+    */
+
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ProxyExObjectwait11(1));
+        Thread t2 = new Thread(new ProxyExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ProxyExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ProxyExObjectwait31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        t2.interrupt();
+        if (result == 2 && ProxyExObjectwait.res == 54) {
+            result = 0;
+        }
+        return result;
+    }
+}
+class MyProxy4 extends Proxy {
+    MyProxy4(InvocationHandler h) {
+        super(h);
+    }
+    InvocationHandler getInvocationHandlerField() {
+        return h;
+    }
+}
+class MyInvocationHandler3 implements InvocationHandler {
+    /**
+     * invoke test
+     *
+     * @param proxy  proxy test
+     * @param method method for test
+     * @param args   object[] for test
+     * @return any implementation
+     * @throws Throwable exception
+    */
+
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        return new Object(); // any implementation
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0104-rt-parent-ProxyExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0104-rt-parent-ProxyExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0104-rt-parent-ProxyExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0104-rt-parent-ProxyExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0104-rt-parent-ProxyExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..0493925ed15185a1aa9aa0f7984c0bc53db8dbb1
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0104-rt-parent-ProxyExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ProxyExObjectwait)
+run(ProxyExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/ReflectPermissionExBasicPermissionimplies.java b/testsuite/java_test/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/ReflectPermissionExBasicPermissionimplies.java
new file mode 100755
index 0000000000000000000000000000000000000000..e930adb01c570bd96192deaea96ce3bcf40687ff
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/ReflectPermissionExBasicPermissionimplies.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.ReflectPermission;
+public class ReflectPermissionExBasicPermissionimplies {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExBasicPermissionimplies1();
+        } catch (Exception e) {
+            ReflectPermissionExBasicPermissionimplies.res = ReflectPermissionExBasicPermissionimplies.res - 20;
+        }
+        if (result == 4 && ReflectPermissionExBasicPermissionimplies.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int reflectPermissionExBasicPermissionimplies1() {
+        //  boolean implies(Permission p)
+        int result1 = 4; /*STATUS_FAILED*/
+        String name = "name";
+        String actions = null;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        if (rp.implies(rp)) {
+            ReflectPermissionExBasicPermissionimplies.res = ReflectPermissionExBasicPermissionimplies.res - 10;
+        } else {
+            ReflectPermissionExBasicPermissionimplies.res = ReflectPermissionExBasicPermissionimplies.res - 5;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/expected.txt b/testsuite/java_test/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/test.cfg b/testsuite/java_test/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a442c01a076dbf5a54ebf20fa1ed9d717608799d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectPermissionExBasicPermissionimplies)
+run(ReflectPermissionExBasicPermissionimplies)
diff --git a/testsuite/java_test/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/ReflectPermissionExObjectgetClass.java b/testsuite/java_test/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/ReflectPermissionExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..e774f7113072e4449dcfd84b0dfa41835896fe2c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/ReflectPermissionExObjectgetClass.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.ReflectPermission;
+public class ReflectPermissionExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExObjectgetClass1();
+        } catch (Exception e) {
+            ReflectPermissionExObjectgetClass.res = ReflectPermissionExObjectgetClass.res - 20;
+        }
+        if (result == 4 && ReflectPermissionExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int reflectPermissionExObjectgetClass1() throws ClassNotFoundException {
+        //  final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        String name = "name";
+        String actions = null;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            Class<? extends ReflectPermission> cls1 = rp.getClass();
+            if (cls1.toString().equals("class java.lang.reflect.ReflectPermission")) {
+                ReflectPermissionExObjectgetClass.res = ReflectPermissionExObjectgetClass.res - 10;
+            }
+        } catch (IllegalMonitorStateException e) {
+            ReflectPermissionExObjectgetClass.res = ReflectPermissionExObjectgetClass.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..3cc6aabc606bac3e550db8a62f59e1cd1edc7ad6
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0106-rt-parent-ReflectPermissionExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectPermissionExObjectgetClass)
+run(ReflectPermissionExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..26ece96ba4647629c0cd59b6cecdb64f4c718255
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.ReflectPermission;
+public class ReflectPermissionExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private String name = "name";
+    private String actions = null;
+    private ReflectPermission rp = new ReflectPermission(name, actions);
+    public static void main(String argv[]) {
+        System.out.println(new ReflectPermissionExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ReflectPermissionExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int reflectPermissionExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ReflectPermissionExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        private int remainder;
+        private ReflectPermissionExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9d7ffc47ca1e9fc7aa681b3a721b8a47b1ff09c6
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectPermissionExObjectnotifyAllIllegalMonitorStateException)
+run(ReflectPermissionExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/ReflectPermissionExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/ReflectPermissionExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..10e234d2ce21c251b83c6522615c2c54c0c1e1ca
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/ReflectPermissionExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.ReflectPermission;
+public class ReflectPermissionExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private String name = "name";
+    private String actions = null;
+    private ReflectPermission rp = new ReflectPermission(name, actions);
+    public static void main(String argv[]) {
+        System.out.println(new ReflectPermissionExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ReflectPermissionExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ReflectPermissionExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int reflectPermissionExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            rp.notify();
+            ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ReflectPermissionExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ReflectPermissionExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notify();
+                    ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectnotifyIllegalMonitorStateException.res = ReflectPermissionExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..00f048a3f8c70d86e1956cd38af582e9f4c90355
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectPermissionExObjectnotifyIllegalMonitorStateException)
+run(ReflectPermissionExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/ReflectPermissionExObjecttoString.java b/testsuite/java_test/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/ReflectPermissionExObjecttoString.java
new file mode 100755
index 0000000000000000000000000000000000000000..f50001c62a0b73266b9e9a3fa32f4fb817e029e2
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/ReflectPermissionExObjecttoString.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.ReflectPermission;
+public class ReflectPermissionExObjecttoString {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExObjecttoString1();
+        } catch (Exception e) {
+            ReflectPermissionExObjecttoString.res = ReflectPermissionExObjecttoString.res - 20;
+        }
+        if (result == 4 && ReflectPermissionExObjecttoString.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int reflectPermissionExObjecttoString1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // String toString()
+        String name = "name";
+        String actions = null;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            String str1 = rp.toString();
+            if (str1.contains("java.lang.reflect.ReflectPermission")) {
+                ReflectPermissionExObjecttoString.res = ReflectPermissionExObjecttoString.res - 10;
+            }
+        } catch (IllegalMonitorStateException e) {
+            ReflectPermissionExObjecttoString.res = ReflectPermissionExObjecttoString.res - 1;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/expected.txt b/testsuite/java_test/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/test.cfg b/testsuite/java_test/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f7ff4f6c32745dce559dce50a7446f4dc0e9e16e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0109-rt-parent-ReflectPermissionExObjecttoString/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectPermissionExObjecttoString)
+run(ReflectPermissionExObjecttoString)
diff --git a/testsuite/java_test/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/ReflectPermissionExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/ReflectPermissionExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..a6bfc4062b76a8313b103a7b5533349063fd7e61
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/ReflectPermissionExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.ReflectPermission;
+public class ReflectPermissionExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = reflectPermissionExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = reflectPermissionExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = reflectPermissionExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ReflectPermissionExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int reflectPermissionExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        String name = "name";
+        String actions = null;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            rp.wait();
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int reflectPermissionExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        String name = "name";
+        String actions = null;
+        long millis = 123;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            rp.wait(millis);
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int reflectPermissionExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        String name = "name";
+        String actions = null;
+        long millis = 123;
+        int nanos = 10;
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            rp.wait(millis, nanos);
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ReflectPermissionExObjectwaitIllegalMonitorStateException.res = ReflectPermissionExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..bce59675506f2317c316ef0be30667405b9a46bf
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectPermissionExObjectwaitIllegalMonitorStateException)
+run(ReflectPermissionExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/ReflectPermissionExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/ReflectPermissionExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..11af72a75b5d4fabc14fc389deaffed381ec5094
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/ReflectPermissionExObjectwaitInterruptedException.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.ReflectPermission;
+public class ReflectPermissionExObjectwaitInterruptedException {
+    static int res = 99;
+    private static String name = "name";
+    private static String action = null;
+    private static ReflectPermission RP = new ReflectPermission(name, action);
+    public static void main(String argv[]) {
+        System.out.println(new ReflectPermissionExObjectwaitInterruptedException().run());
+    }
+    private class ReflectPermissionExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ReflectPermissionExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (RP) {
+                RP.notifyAll();
+                try {
+                    RP.wait();
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class ReflectPermissionExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+        private ReflectPermissionExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (RP) {
+                RP.notifyAll();
+                try {
+                    RP.wait(millis);
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class ReflectPermissionExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+        private ReflectPermissionExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (RP) {
+                RP.notifyAll();
+                try {
+                    RP.wait(millis, nanos);
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ReflectPermissionExObjectwaitInterruptedException.res = ReflectPermissionExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ReflectPermissionExObjectwaitInterruptedException.ReflectPermissionExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ReflectPermissionExObjectwaitInterruptedException.ReflectPermissionExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ReflectPermissionExObjectwaitInterruptedException.ReflectPermissionExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && ReflectPermissionExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6c7594af8f159f3974becbdeaa75325271e02f13
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectPermissionExObjectwaitInterruptedException)
+run(ReflectPermissionExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/ReflectPermissionExObjectwait.java b/testsuite/java_test/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/ReflectPermissionExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..f49158c6f7b1a49a49d9f244f7b9e91443ba9e18
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/ReflectPermissionExObjectwait.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.ReflectPermission;
+public class ReflectPermissionExObjectwait {
+    static int res = 99;
+    private String name = "name";
+    private String action = null;
+    private ReflectPermission RP = new ReflectPermission(name, action);
+    private ReflectPermission RP2 = new ReflectPermission(name, action);
+    private ReflectPermission RP3 = new ReflectPermission(name, action);
+    public static void main(String argv[]) {
+        System.out.println(new ReflectPermissionExObjectwait().run());
+    }
+    private class ReflectPermissionExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ReflectPermissionExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (RP) {
+                RP.notifyAll();
+                try {
+                    RP.wait();
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class ReflectPermissionExObjectwait12 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+        private ReflectPermissionExObjectwait12(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (RP2) {
+                RP2.notifyAll();
+                try {
+                    RP2.wait(millis);
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    private class ReflectPermissionExObjectwait13 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+        private ReflectPermissionExObjectwait13(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (RP3) {
+                RP3.notifyAll();
+                try {
+                    RP3.wait(millis, nanos);
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 10;
+                } catch (InterruptedException e1) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ReflectPermissionExObjectwait.res = ReflectPermissionExObjectwait.res - 30;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        Thread t1 = new Thread(new ReflectPermissionExObjectwait11(1));
+        Thread t2 = new Thread(new ReflectPermissionExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ReflectPermissionExObjectwait12(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ReflectPermissionExObjectwait13(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        try {
+            t1.join();
+            t3.join();
+            t5.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 2 && ReflectPermissionExObjectwait.res == 69) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d79bac459717b2feca34624798294505fa48dc59
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0112-rt-parent-ReflectPermissionExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectPermissionExObjectwait)
+run(ReflectPermissionExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/ReflectPermissionExPermissioncheckGuard.java b/testsuite/java_test/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/ReflectPermissionExPermissioncheckGuard.java
new file mode 100755
index 0000000000000000000000000000000000000000..1518dff961ef592ec9451c958353eec93bf18edd
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/ReflectPermissionExPermissioncheckGuard.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.ReflectPermission;
+public class ReflectPermissionExPermissioncheckGuard {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = reflectPermissionExPermissioncheckGuard1();
+        } catch (Exception e) {
+            ReflectPermissionExPermissioncheckGuard.res = ReflectPermissionExPermissioncheckGuard.res - 20;
+        }
+        if (result == 4 && ReflectPermissionExPermissioncheckGuard.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int reflectPermissionExPermissioncheckGuard1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // void checkGuard(Object object)
+        String name = "name";
+        String actions = null;
+        final Object obj = new Object();
+        ReflectPermission rp = new ReflectPermission(name, actions);
+        try {
+            rp.checkGuard(obj);
+            ReflectPermissionExPermissioncheckGuard.res = ReflectPermissionExPermissioncheckGuard.res - 10;
+        } catch (IllegalMonitorStateException e) {
+            ReflectPermissionExPermissioncheckGuard.res = ReflectPermissionExPermissioncheckGuard.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/expected.txt b/testsuite/java_test/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/test.cfg b/testsuite/java_test/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ecff75e4227eaf5334f0e22b30e1e50a4022407c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectPermissionExPermissioncheckGuard)
+run(ReflectPermissionExPermissioncheckGuard)
diff --git a/testsuite/java_test/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/StringBufferExObjectgetClass.java b/testsuite/java_test/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/StringBufferExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..e639bdc5c81504ab12096ca99e87a25d8d097a86
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/StringBufferExObjectgetClass.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Class;
+public class StringBufferExObjectgetClass {
+    static int res = 99;
+    private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    public static void main(String argv[]) {
+        System.out.println(new StringBufferExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBufferExObjectgetClass1();
+        } catch (Exception e) {
+            StringBufferExObjectgetClass.res = StringBufferExObjectgetClass.res - 20;
+        }
+        if (result == 4 && StringBufferExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringBufferExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+        StringBuffer sb = null;
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuffer(stringArray[i]);
+        }
+        Class px1 = sb.getClass();
+        if (px1.toString().equals("class java.lang.StringBuffer")) {
+            StringBufferExObjectgetClass.res = StringBufferExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..cb4752556c1fb86191c50ac9b64748becb6a4bb5
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0114-rt-parent-StringBufferExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferExObjectgetClass)
+run(StringBufferExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/StringBufferExObjecthashCode.java b/testsuite/java_test/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/StringBufferExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..843553b0a18f5cc987824a40ef77938c37fe4cff
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/StringBufferExObjecthashCode.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuffer;
+public class StringBufferExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new StringBufferExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBufferExObjecthashCode1();
+        } catch (Exception e) {
+            StringBufferExObjecthashCode.res = StringBufferExObjecthashCode.res - 20;
+        }
+        if (result == 4 && StringBufferExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringBufferExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        StringBuffer sb1 = new StringBuffer("aa");
+        StringBuffer sb2 = sb1;
+        StringBuffer sb3 = new StringBuffer("╬の〆");
+        if (sb1.hashCode() == sb2.hashCode() && sb1.hashCode() != sb3.hashCode()) {
+            StringBufferExObjecthashCode.res = StringBufferExObjecthashCode.res - 10;
+        } else {
+            StringBufferExObjecthashCode.res = StringBufferExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7c9ffc7bae86bd74913251f77bab4be1199834d1
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0115-rt-parent-StringBufferExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferExObjecthashCode)
+run(StringBufferExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/StringBufferExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/StringBufferExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..d29d89e1ace59a970122db5bebb258eb2c38fa78
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/StringBufferExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuffer;
+public class StringBufferExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer sb = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(new StringBufferExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBufferExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new StringBufferExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && StringBufferExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringBufferExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            sb.notifyAll();
+            StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class StringBufferExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notifyAll();
+                    StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectnotifyAllIllegalMonitorStateException.res = StringBufferExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..500c3b9891b7dd597faf56e855a674303321cb70
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferExObjectnotifyAllIllegalMonitorStateException)
+run(StringBufferExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/StringBufferExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/StringBufferExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..f37296a5802fce8e33af0ee26cb6c1fd5a149b2e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/StringBufferExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuffer;
+public class StringBufferExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer sb = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(new StringBufferExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBufferExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new StringBufferExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && StringBufferExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringBufferExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            sb.notify();
+            StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class StringBufferExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notify();
+                    StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectnotifyIllegalMonitorStateException.res = StringBufferExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4dbf9cc5d443892f37976c28fae5c427d24dfca2
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferExObjectnotifyIllegalMonitorStateException)
+run(StringBufferExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/StringBufferExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/StringBufferExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..e3eab6deb9de40d64c61d5860e2b5d3c4feeea37
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/StringBufferExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuffer;
+public class StringBufferExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer mf2 = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            mf2 = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(new StringBufferExObjectwaitIllegalArgumentException().run());
+    }
+    private class StringBufferExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class StringBufferExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBufferExObjectwaitIllegalArgumentException.res = StringBufferExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringBufferExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringBufferExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && StringBufferExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..df3aa142802ff3c1d3c5af8b1bab3d70de439af3
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferExObjectwaitIllegalArgumentException)
+run(StringBufferExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/StringBufferExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/StringBufferExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..9fc8706525265c7375b601c06a7476a7064566b3
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/StringBufferExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuffer;
+public class StringBufferExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer mf2 = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            mf2 = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = stringBufferExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = stringBufferExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = stringBufferExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && StringBufferExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int stringBufferExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            mf2.wait();
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int stringBufferExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int stringBufferExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBufferExObjectwaitIllegalMonitorStateException.res = StringBufferExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4ba4378618357b9c6bf19b7be398689c3c240ee3
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferExObjectwaitIllegalMonitorStateException)
+run(StringBufferExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0120-rt-parent-StringBufferExObjectwait/StringBufferExObjectwait.java b/testsuite/java_test/parent_test/RT0120-rt-parent-StringBufferExObjectwait/StringBufferExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..020291b4adedec982bb05f8df40e38273b851d9a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0120-rt-parent-StringBufferExObjectwait/StringBufferExObjectwait.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuffer;
+public class StringBufferExObjectwait {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuffer sb = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuffer(stringArray[i]);
+        }
+        System.out.println(new StringBufferExObjectwait().run());
+    }
+    private class StringBufferExObjectwait11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait();
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    // System.out.println("111");
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    System.out.println("222");
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+    private class StringBufferExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                sb.notify();
+                try {
+                    sb.wait(millis);
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    private class StringBufferExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait(millis, nanos);
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBufferExObjectwait.res = StringBufferExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * join fun
+     * @param thread wait join thread
+    */
+
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new StringBufferExObjectwait11());
+        Thread t2 = new Thread(new StringBufferExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringBufferExObjectwait21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringBufferExObjectwait31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        if (result == 2 && StringBufferExObjectwait.res == 54) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0120-rt-parent-StringBufferExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0120-rt-parent-StringBufferExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0120-rt-parent-StringBufferExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0120-rt-parent-StringBufferExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0120-rt-parent-StringBufferExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..04db0c3d1a3dc0bf55e9abadb3aa9505a4760f4d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0120-rt-parent-StringBufferExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferExObjectwait)
+run(StringBufferExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/StringBuilderExObjectgetClass.java b/testsuite/java_test/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/StringBuilderExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..f0b79173852f89b286e777410cf32d02e62e183e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/StringBuilderExObjectgetClass.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.String;
+public class StringBuilderExObjectgetClass {
+    static int res = 99;
+    private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    public static void main(String argv[]) {
+        System.out.println(new StringBuilderExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBuilderExObjectgetClass1();
+        } catch (Exception e) {
+            StringBuilderExObjectgetClass.res = StringBuilderExObjectgetClass.res - 20;
+        }
+        if (result == 4 && StringBuilderExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringBuilderExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+        StringBuilder sb = null;
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuilder(stringArray[i]);
+        }
+        Class px1 = sb.getClass();
+        if (px1.toString().equals("class java.lang.StringBuilder")) {
+            StringBuilderExObjectgetClass.res = StringBuilderExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..37198d5efbb4af93876dcfdce06f6ae1f3e3b573
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0121-rt-parent-StringBuilderExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderExObjectgetClass)
+run(StringBuilderExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/StringBuilderExObjecthashCode.java b/testsuite/java_test/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/StringBuilderExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..770f6d8a5b4b02e53e34598728acb79ecbe2cb1f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/StringBuilderExObjecthashCode.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuilder;
+public class StringBuilderExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new StringBuilderExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBuilderExObjecthashCode1();
+        } catch (Exception e) {
+            StringBuilderExObjecthashCode.res = StringBuilderExObjecthashCode.res - 20;
+        }
+        if (result == 4 && StringBuilderExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringBuilderExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //   int hashCode()
+        StringBuilder sb1 = new StringBuilder("aa");
+        StringBuilder sb2 = sb1;
+        StringBuilder sb3 = new StringBuilder("╬の〆");
+        if (sb1.hashCode() == sb2.hashCode() && sb1.hashCode() != sb3.hashCode()) {
+            StringBuilderExObjecthashCode.res = StringBuilderExObjecthashCode.res - 10;
+        } else {
+            StringBuilderExObjecthashCode.res = StringBuilderExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..eed58e2c237225b1a318c23bd0d00aff4ea6f086
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0122-rt-parent-StringBuilderExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderExObjecthashCode)
+run(StringBuilderExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/StringBuilderExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/StringBuilderExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..eb32bee3aae3060e592b348c1cf4dd0e0bb04f54
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/StringBuilderExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuilder;
+public class StringBuilderExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder sb = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(new StringBuilderExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBuilderExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new StringBuilderExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && StringBuilderExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringBuilderExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            sb.notifyAll();
+            StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class StringBuilderExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+        private StringBuilderExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notifyAll();
+                    StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectnotifyAllIllegalMonitorStateException.res = StringBuilderExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ee672078c60c424dd61ee4fdbdbe6b6c31f1682f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderExObjectnotifyAllIllegalMonitorStateException)
+run(StringBuilderExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/StringBuilderExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/StringBuilderExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d9a3adbf473b0606cb4683febda66fc62be24d2
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/StringBuilderExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuilder;
+public class StringBuilderExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder sb = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(new StringBuilderExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringBuilderExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new StringBuilderExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && StringBuilderExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringBuilderExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            sb.notify();
+            StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class StringBuilderExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private StringBuilderExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notify();
+                    StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectnotifyIllegalMonitorStateException.res = StringBuilderExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..75bd83ef34256f6a434d8fb9f4b764880b449f4b
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderExObjectnotifyIllegalMonitorStateException)
+run(StringBuilderExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/StringBuilderExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/StringBuilderExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..eea47c9dc192ef03f374ef861f512e713e32f69a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/StringBuilderExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuilder;
+public class StringBuilderExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder mf2 = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            mf2 = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(new StringBuilderExObjectwaitIllegalArgumentException().run());
+    }
+    private class StringBuilderExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+        private StringBuilderExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class StringBuilderExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+        private StringBuilderExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBuilderExObjectwaitIllegalArgumentException.res = StringBuilderExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringBuilderExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringBuilderExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && StringBuilderExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ca899e8fb3ff097b88bac84991ec0cb18aa6e09c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderExObjectwaitIllegalArgumentException)
+run(StringBuilderExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/StringBuilderExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/StringBuilderExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..459ea721a0ae12219168f2ff9d6688b2b635ac6e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/StringBuilderExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuilder;
+public class StringBuilderExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder mf2 = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            mf2 = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = stringBuilderExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = stringBuilderExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = stringBuilderExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && StringBuilderExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int stringBuilderExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            mf2.wait();
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int stringBuilderExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int stringBuilderExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringBuilderExObjectwaitIllegalMonitorStateException.res = StringBuilderExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..425973a1497310bd3ec7a5a17469b7783d591fb0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderExObjectwaitIllegalMonitorStateException)
+run(StringBuilderExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/StringBuilderExObjectwait.java b/testsuite/java_test/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/StringBuilderExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..78c4e5d3e02048f516a9d34cf747fa914849b73b
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/StringBuilderExObjectwait.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.StringBuilder;
+public class StringBuilderExObjectwait {
+    static int res = 99;
+    static private String[] stringArray = {
+            "", "a", "b", "c", "ab", "ac", "abc", "aaaabbbccc"
+    };
+    static private StringBuilder sb = null;
+    public static void main(String argv[]) {
+        for (int i = 0; i < stringArray.length; i++) {
+            sb = new StringBuilder(stringArray[i]);
+        }
+        System.out.println(new StringBuilderExObjectwait().run());
+    }
+    private class StringBuilderExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private StringBuilderExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait();
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    // System.out.println("111");
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    // System.out.println("222");
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+    private class StringBuilderExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+        private StringBuilderExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                sb.notify();
+                try {
+                    sb.wait(millis);
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    private class StringBuilderExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+        private StringBuilderExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait(millis, nanos);
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringBuilderExObjectwait.res = StringBuilderExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * join fun
+     * @param thread wait join thread
+    */
+
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new StringBuilderExObjectwait11(1));
+        Thread t2 = new Thread(new StringBuilderExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringBuilderExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringBuilderExObjectwait31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t2.start();
+        t1.interrupt();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        if (result == 2 && StringBuilderExObjectwait.res == 54) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..270e4a6137b6dd7e5d3f29065fe14ff95d7087e0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0127-rt-parent-StringBuilderExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderExObjectwait)
+run(StringBuilderExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0128-rt-parent-StringExObjectgetClass/StringExObjectgetClass.java b/testsuite/java_test/parent_test/RT0128-rt-parent-StringExObjectgetClass/StringExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..52dad43415907a5e8290dd4ff33622482a7840b4
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0128-rt-parent-StringExObjectgetClass/StringExObjectgetClass.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Class;
+public class StringExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringExObjectgetClass1();
+        } catch (Exception e) {
+            StringExObjectgetClass.res = StringExObjectgetClass.res - 20;
+        }
+        if (result == 4 && StringExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringExObjectgetClass1() {
+        //  final Class<?> getClass()
+        int result1 = 4; /*STATUS_FAILED*/
+        String tr2 = "this is a test";
+        Class<? extends String> cls1 = tr2.getClass();
+        if (cls1.toString().equals("class java.lang.String")) {
+            StringExObjectgetClass.res = StringExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0128-rt-parent-StringExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0128-rt-parent-StringExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0128-rt-parent-StringExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0128-rt-parent-StringExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0128-rt-parent-StringExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2c97cb9aa29fcf062c665dd5e9670f310d652a50
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0128-rt-parent-StringExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(StringExObjectgetClass)
+run(StringExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/StringExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/StringExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..7f1e9a41dd6e684636e4c001a3231475a8284c9a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/StringExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class StringExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    String mf2 = "this is a test";
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new StringExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && StringExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            mf2.notifyAll();
+            StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class StringExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notifyAll();
+                    StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectnotifyAllIllegalMonitorStateException.res = StringExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e149f617413a0f29572b4dfdbd9852e50bfa520f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringExObjectnotifyAllIllegalMonitorStateException)
+run(StringExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/StringExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/StringExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..2af46cd67ebe1ade63825e33400d1e000739d112
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/StringExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class StringExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    String mf2 = "this is a test";
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = stringExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new StringExObjectnotifyIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && StringExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int stringExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            mf2.notify();
+            StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class StringExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                try {
+                    mf2.notify();
+                    StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectnotifyIllegalMonitorStateException.res = StringExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..547b9724a1fd9a009cfd683f21414172a423dced
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringExObjectnotifyIllegalMonitorStateException)
+run(StringExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/StringExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/StringExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..588238820b39760cb83634a1dd9f1b0cf4961d3d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/StringExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class StringExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private static String mf2 = "this is a test";
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectwaitIllegalArgumentException().run());
+    }
+    private class StringExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        long millis = -1;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class StringExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+        long millis = -2;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringExObjectwaitIllegalArgumentException.res = StringExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringExObjectwaitIllegalArgumentException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringExObjectwaitIllegalArgumentException31());
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && StringExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d96d70ac084b5a5b2e44c6444f76515040a1de19
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0131-rt-parent-StringExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringExObjectwaitIllegalArgumentException)
+run(StringExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/StringExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/StringExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..b8e3443a3086325f88cacb6858777f490eaa97b6
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/StringExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class StringExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static String mf2 = "this is a test";
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = stringExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = stringExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = stringExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && StringExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int stringExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            mf2.wait();
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int stringExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int stringExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            StringExObjectwaitIllegalMonitorStateException.res = StringExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..63fcdb7a7218b58f81131bbf5a226668e3ca6150
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(StringExObjectwaitIllegalMonitorStateException)
+run(StringExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0133-rt-parent-StringExObjectwait/StringExObjectwait.java b/testsuite/java_test/parent_test/RT0133-rt-parent-StringExObjectwait/StringExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..84d3f57686fff6e859c3a9d2693a9536b56d9f3c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0133-rt-parent-StringExObjectwait/StringExObjectwait.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class StringExObjectwait {
+    static int res = 99;
+    private String mf2 = "this is a test";
+    static Thread t2;
+    public static void main(String argv[]) {
+        System.out.println(new StringExObjectwait().run());
+        t2.interrupt();
+    }
+    private class StringExObjectwait11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait();
+                    StringExObjectwait.res = StringExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwait.res = StringExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwait.res = StringExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+    private class StringExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notify();
+                try {
+                    mf2.wait(millis);
+                    StringExObjectwait.res = StringExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwait.res = StringExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwait.res = StringExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringExObjectwait.res = StringExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    private class StringExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    StringExObjectwait.res = StringExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    StringExObjectwait.res = StringExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    StringExObjectwait.res = StringExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    StringExObjectwait.res = StringExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * join fun
+     * @param thread wait join thread
+    */
+
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new StringExObjectwait11());
+        t2 = new Thread(new StringExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new StringExObjectwait21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new StringExObjectwait31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        if (result == 2 && StringExObjectwait.res == 54) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0133-rt-parent-StringExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0133-rt-parent-StringExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0133-rt-parent-StringExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0133-rt-parent-StringExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0133-rt-parent-StringExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6eb2abfd141b016e258d9aa86079f4da8409cc8d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0133-rt-parent-StringExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(StringExObjectwait)
+run(StringExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/ThreadExObjecthashCode.java b/testsuite/java_test/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/ThreadExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..8f2c333a8f57c3ab2a87c4c23ad085d818e93206
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/ThreadExObjecthashCode.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadExObjecthashCode1();
+        } catch (Exception e) {
+            ThreadExObjecthashCode.res = ThreadExObjecthashCode.res - 20;
+        }
+        if (result == 4 && ThreadExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        Thread thr1 = new Thread();
+        Thread thr2 = thr1;
+        Thread thr3 = new Thread();
+        thr1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        thr2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        thr3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        if (thr1.hashCode() == thr2.hashCode() && thr1.hashCode() != thr3.hashCode()) {
+            ThreadExObjecthashCode.res = ThreadExObjecthashCode.res - 10;
+        } else {
+            ThreadExObjecthashCode.res = ThreadExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..02a476a4fb5fdeea456b8a4ca4c137fd2f8368f2
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0134-rt-parent-ThreadExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadExObjecthashCode)
+run(ThreadExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/ThreadExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/ThreadExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..72936a40f993cf461a018ad001daf3ddb0851fa8
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/ThreadExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    Thread sb = new Thread();
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ThreadExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        sb.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ThreadExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            sb.notifyAll();
+            ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ThreadExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+        private ThreadExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notifyAll();
+                    ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectnotifyAllIllegalMonitorStateException.res = ThreadExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4cd23fee8218393fc1e58689452ef8cd4af97056
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadExObjectnotifyAllIllegalMonitorStateException)
+run(ThreadExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/ThreadExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/ThreadExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..c36d689f3361e11ecc56e962f3e79d45d8e87666
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/ThreadExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    Thread sb = new Thread();
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ThreadExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        sb.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ThreadExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            sb.notify();
+            ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ThreadExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ThreadExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                try {
+                    sb.notify();
+                    ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectnotifyIllegalMonitorStateException.res = ThreadExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..307a7253e88b78091a8fee8669ee9fe900d24de1
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadExObjectnotifyIllegalMonitorStateException)
+run(ThreadExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/ThreadExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/ThreadExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..b55744f1eef0db3980c3c1dfb8552931560bed82
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/ThreadExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private Thread mf2 = new Thread();
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjectwaitIllegalArgumentException().run());
+    }
+    private class ThreadExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+        private ThreadExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class ThreadExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+        private ThreadExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadExObjectwaitIllegalArgumentException.res = ThreadExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadExObjectwaitIllegalArgumentException31(5));
+        mf2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ThreadExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..60066d822c485a6e1ec3e4e7401752c14157cddf
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadExObjectwaitIllegalArgumentException)
+run(ThreadExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/ThreadExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/ThreadExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..1f636d4791baa1a991044f510da1afe50d66770c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/ThreadExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    static Thread mf2 = new Thread();
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        mf2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        // final void wait()
+        try {
+            result = threadExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = threadExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = threadExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ThreadExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int threadExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            mf2.wait();
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int threadExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int threadExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadExObjectwaitIllegalMonitorStateException.res = ThreadExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ea30395bec8bcdc8d999ab0ebe9376ba1bdf9783
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadExObjectwaitIllegalMonitorStateException)
+run(ThreadExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0139-rt-parent-ThreadExObjectwait/ThreadExObjectwait.java b/testsuite/java_test/parent_test/RT0139-rt-parent-ThreadExObjectwait/ThreadExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..ea8628a2e66456b70c16363fc92ae8cba2a6334c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0139-rt-parent-ThreadExObjectwait/ThreadExObjectwait.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadExObjectwait {
+    static int res = 99;
+    Thread sb = new Thread();
+    public static void main(String argv[]) {
+        System.out.println(new ThreadExObjectwait().run());
+    }
+    private class ThreadExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ThreadExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait();
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+    private class ThreadExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+        private ThreadExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                sb.notify();
+                try {
+                    sb.wait(millis);
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    private class ThreadExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+        private ThreadExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sb) {
+                sb.notifyAll();
+                try {
+                    sb.wait(millis, nanos);
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadExObjectwait.res = ThreadExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private void sbSetUncaught() {
+        sb.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThreadExObjectwait11(1));
+        Thread t2 = new Thread(new ThreadExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadExObjectwait31(5));
+        sbSetUncaught();
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        if (result == 2 && ThreadExObjectwait.res == 54) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0139-rt-parent-ThreadExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0139-rt-parent-ThreadExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0139-rt-parent-ThreadExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0139-rt-parent-ThreadExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0139-rt-parent-ThreadExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..61a7f2449472dd951031f44be1b96a0e8f549011
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0139-rt-parent-ThreadExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadExObjectwait)
+run(ThreadExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/ThreadGroupExObjectequals.java b/testsuite/java_test/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/ThreadGroupExObjectequals.java
new file mode 100755
index 0000000000000000000000000000000000000000..cebe8076c531bd8d02b3a78ba89f7ee2bb7bcb07
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/ThreadGroupExObjectequals.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadGroupExObjectequals {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectequals().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjectequals1();
+        } catch (Exception e) {
+            ThreadGroupExObjectequals.res = ThreadGroupExObjectequals.res - 20;
+        }
+        if (result == 4 && ThreadGroupExObjectequals.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadGroupExObjectequals1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // boolean equals(Object obj)
+        ThreadGroup gr1 = new ThreadGroup("Thread3251");
+        ThreadGroup gr2 = new ThreadGroup("Thread3252");
+        boolean ret = gr1.equals(gr2);
+        if (!ret) {
+            ThreadGroupExObjectequals.res = ThreadGroupExObjectequals.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/expected.txt b/testsuite/java_test/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/test.cfg b/testsuite/java_test/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e7633a11e257c1141dea9a09ae75e014686acdf0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0140-rt-parent-ThreadGroupExObjectequals/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupExObjectequals)
+run(ThreadGroupExObjectequals)
diff --git a/testsuite/java_test/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/ThreadGroupExObjectgetClass.java b/testsuite/java_test/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/ThreadGroupExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..00eaba73bd3493ad744222c2735eed1dae7fb45d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/ThreadGroupExObjectgetClass.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadGroupExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjectgetClass1();
+        } catch (Exception e) {
+            ThreadGroupExObjectgetClass.res = ThreadGroupExObjectgetClass.res - 20;
+        }
+        if (result == 4 && ThreadGroupExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadGroupExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+        ThreadGroup gr1 = new ThreadGroup("Thread8023");
+        Class px1 = gr1.getClass();
+        if (px1.toString().equals("class java.lang.ThreadGroup")) {
+            ThreadGroupExObjectgetClass.res = ThreadGroupExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2eda3f902c127e5163e7bfe46ce146232550fb7f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0141-rt-parent-ThreadGroupExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupExObjectgetClass)
+run(ThreadGroupExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/ThreadGroupExObjecthashCode.java b/testsuite/java_test/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/ThreadGroupExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e5db6aa16151f97ea64851c607b79ac45d23f4c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/ThreadGroupExObjecthashCode.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ThreadGroup;
+public class ThreadGroupExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjecthashCode1();
+        } catch (Exception e) {
+            ThreadGroupExObjecthashCode.res = ThreadGroupExObjecthashCode.res - 20;
+        }
+        if (result == 4 && ThreadGroupExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadGroupExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        ThreadGroup gr1 = new ThreadGroup("Thread8023");
+        ThreadGroup gr2 = gr1;
+        ThreadGroup gr3 = new ThreadGroup("Thread1988");
+        if (gr1.hashCode() == gr2.hashCode() && gr1.hashCode() != gr3.hashCode()) {
+            ThreadGroupExObjecthashCode.res = ThreadGroupExObjecthashCode.res - 10;
+        } else {
+            ThreadGroupExObjecthashCode.res = ThreadGroupExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..cb69a472e11f2b5c46edc01adbd8b43631d6d50a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0142-rt-parent-ThreadGroupExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupExObjecthashCode)
+run(ThreadGroupExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/ThreadGroupExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/ThreadGroupExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..3280abae72ca377261a52209bd99dcc456d29138
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/ThreadGroupExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadGroupExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    ThreadGroup gr1 = new ThreadGroup("Thread8023");
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ThreadGroupExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadGroupExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            gr1.notifyAll();
+            ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ThreadGroupExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+        private ThreadGroupExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (gr1) {
+                try {
+                    gr1.notifyAll();
+                    ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res = ThreadGroupExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..90794a2e703fe35cfecd35df85be7a93e1cfc699
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupExObjectnotifyAllIllegalMonitorStateException)
+run(ThreadGroupExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/ThreadGroupExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/ThreadGroupExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..44f112b73d1d5ef4dba51b55c9aadee2baff8c0d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/ThreadGroupExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadGroupExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private ThreadGroup gr1 = new ThreadGroup("Thread8023");
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ThreadGroupExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ThreadGroupExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadGroupExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            gr1.notify();
+            ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ThreadGroupExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ThreadGroupExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (gr1) {
+                try {
+                    gr1.notify();
+                    ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectnotifyIllegalMonitorStateException.res = ThreadGroupExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..db019c4caf178a83c0dc37f290285b523da6c572
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupExObjectnotifyIllegalMonitorStateException)
+run(ThreadGroupExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/ThreadGroupExObjecttoString.java b/testsuite/java_test/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/ThreadGroupExObjecttoString.java
new file mode 100755
index 0000000000000000000000000000000000000000..5a88cc31a4857728f6cb7365ab23dbd2a9d6b6ce
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/ThreadGroupExObjecttoString.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadGroupExObjecttoString {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjecttoString().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadGroupExObjecttoString1();
+        } catch (Exception e) {
+            ThreadGroupExObjecttoString.res = ThreadGroupExObjecttoString.res - 20;
+        }
+        if (result == 4 && ThreadGroupExObjecttoString.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadGroupExObjecttoString1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // String toString()
+        ThreadGroup gr1 = new ThreadGroup("Thread8023");
+        String str1 = gr1.toString();
+        if (str1.equals("java.lang.ThreadGroup[name=Thread8023,maxpri=10]")) {
+            ThreadGroupExObjecttoString.res = ThreadGroupExObjecttoString.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/expected.txt b/testsuite/java_test/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/test.cfg b/testsuite/java_test/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6e844d86dcea68e22a4426575b1dad486997a711
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0145-rt-parent-ThreadGroupExObjecttoString/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupExObjecttoString)
+run(ThreadGroupExObjecttoString)
diff --git a/testsuite/java_test/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/ThreadGroupExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/ThreadGroupExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..4e52ce1ebc88bdc9b49bc649b78bf6d00cec22d4
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/ThreadGroupExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadGroupExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    ThreadGroup gr1 = new ThreadGroup("Thread8023");
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectwaitIllegalArgumentException().run());
+    }
+    private class ThreadGroupExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+        private ThreadGroupExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait(millis);
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class ThreadGroupExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+        private ThreadGroupExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait(millis, nanos);
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadGroupExObjectwaitIllegalArgumentException.res = ThreadGroupExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadGroupExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadGroupExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ThreadGroupExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..73160394657dfc886c850fe351df72f46a9378ad
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupExObjectwaitIllegalArgumentException)
+run(ThreadGroupExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/ThreadGroupExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/ThreadGroupExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..9eedd495427e72bde2a241cc8cf3175ed1ba2a6b
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/ThreadGroupExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ThreadGroup;
+public class ThreadGroupExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static ThreadGroup gr1 = new ThreadGroup("Thread8023");
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = threadGroupExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = threadGroupExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = threadGroupExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ThreadGroupExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int threadGroupExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            gr1.wait();
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int threadGroupExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            gr1.wait(millis);
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int threadGroupExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            gr1.wait(millis, nanos);
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadGroupExObjectwaitIllegalMonitorStateException.res = ThreadGroupExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..944637ef1ad581fb80812e2ee3744fabeb420a86
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupExObjectwaitIllegalMonitorStateException)
+run(ThreadGroupExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/ThreadGroupExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/ThreadGroupExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..4f569b070d956b2e83afd4f098f0880e4daa32e4
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/ThreadGroupExObjectwaitInterruptedException.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ThreadGroup;
+public class ThreadGroupExObjectwaitInterruptedException {
+    static int res = 99;
+    private static ThreadGroup gr1 = new ThreadGroup("Thread8023");
+    public static void main(String argv[]) {
+        System.out.println(new ThreadGroupExObjectwaitInterruptedException().run());
+    }
+    private class ThreadGroupExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ThreadGroupExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait();
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class ThreadGroupExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+        private ThreadGroupExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait(millis);
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class ThreadGroupExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+        private ThreadGroupExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (gr1) {
+                gr1.notifyAll();
+                try {
+                    gr1.wait(millis, nanos);
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadGroupExObjectwaitInterruptedException.res = ThreadGroupExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThreadGroupExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadGroupExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadGroupExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+        if (result == 2 && ThreadGroupExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2ae58fc86082b010fdb44dfc2cbef82a8c380bad
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupExObjectwaitInterruptedException)
+run(ThreadGroupExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/ThreadLocalExObjectgetClass.java b/testsuite/java_test/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/ThreadLocalExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..c171e7a34cd9db597fb91bbffdb2d482578da143
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/ThreadLocalExObjectgetClass.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ThreadLocal;
+public class ThreadLocalExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjectgetClass1();
+        } catch (Exception e) {
+            ThreadLocalExObjectgetClass.res = ThreadLocalExObjectgetClass.res - 20;
+        }
+        if (result == 4 && ThreadLocalExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadLocalExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //  final Class<?> getClass()
+        ThreadLocal<Object> threadLocal1 = new ThreadLocal<Object>();
+        Class px1 = threadLocal1.getClass();
+        if (px1.toString().equals("class java.lang.ThreadLocal")) {
+            ThreadLocalExObjectgetClass.res = ThreadLocalExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b1f54cffcfb75eaf11affa05207bbadf7b936714
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0149-rt-parent-ThreadLocalExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalExObjectgetClass)
+run(ThreadLocalExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/ThreadLocalExObjecthashCode.java b/testsuite/java_test/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/ThreadLocalExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1aabca116735c7ec4dcf54ec2d32bf7854e5495
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/ThreadLocalExObjecthashCode.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ThreadLocal;
+public class ThreadLocalExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjecthashCode1();
+        } catch (Exception e) {
+            ThreadLocalExObjecthashCode.res = ThreadLocalExObjecthashCode.res - 20;
+        }
+        if (result == 4 && ThreadLocalExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadLocalExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        ThreadLocal<Object> threadLocal1 = new ThreadLocal<Object>();
+        ThreadLocal<Object> threadLocal2 = threadLocal1;
+        ThreadLocal<Object> threadLocal3 = new ThreadLocal<Object>();
+        if (threadLocal1.hashCode() == threadLocal2.hashCode() && threadLocal1.hashCode() != threadLocal3.hashCode()) {
+            ThreadLocalExObjecthashCode.res = ThreadLocalExObjecthashCode.res - 10;
+        } else {
+            ThreadLocalExObjecthashCode.res = ThreadLocalExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..0aa4d73b2f927cd5852724b88f24b31cb4dc0ad5
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0150-rt-parent-ThreadLocalExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalExObjecthashCode)
+run(ThreadLocalExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/ThreadLocalExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/ThreadLocalExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..affbbf64d2e13dcd33a7a7bef8df2e13d66c37ba
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/ThreadLocalExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadLocalExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    ThreadLocal<Object> tl1 = new ThreadLocal<Object>();
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ThreadLocalExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadLocalExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            tl1.notifyAll();
+            ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ThreadLocalExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+        private ThreadLocalExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (tl1) {
+                try {
+                    tl1.notifyAll();
+                    ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res = ThreadLocalExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..17133fa960a2da6d68ab832466ef28976a42d37e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalExObjectnotifyAllIllegalMonitorStateException)
+run(ThreadLocalExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/ThreadLocalExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/ThreadLocalExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..46fe8e42d287307e37a65192935e4b1fc532c23c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/ThreadLocalExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ThreadLocal;
+public class ThreadLocalExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private ThreadLocal<Object> tl1 = new ThreadLocal<Object>();
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ThreadLocalExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ThreadLocalExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadLocalExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            tl1.notify();
+            ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ThreadLocalExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ThreadLocalExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (tl1) {
+                try {
+                    tl1.notify();
+                    ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectnotifyIllegalMonitorStateException.res = ThreadLocalExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..47267cb76229dd5fb12daee3dffcd99acc64066f
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalExObjectnotifyIllegalMonitorStateException)
+run(ThreadLocalExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/ThreadLocalExObjecttoString.java b/testsuite/java_test/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/ThreadLocalExObjecttoString.java
new file mode 100755
index 0000000000000000000000000000000000000000..89a75ced3818f511c7cb013e132091a122c81574
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/ThreadLocalExObjecttoString.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ThreadLocal;
+public class ThreadLocalExObjecttoString {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjecttoString().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = threadLocalExObjecttoString1();
+        } catch (Exception e) {
+            ThreadLocalExObjecttoString.res = ThreadLocalExObjecttoString.res - 20;
+        }
+        if (result == 4 && ThreadLocalExObjecttoString.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int threadLocalExObjecttoString1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // String toString()
+        ThreadLocal<Object> threadLocal1 = new ThreadLocal<Object>();
+        String str1 = threadLocal1.toString();
+        if (str1.contains("java.lang.ThreadLocal")) {
+            ThreadLocalExObjecttoString.res = ThreadLocalExObjecttoString.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/expected.txt b/testsuite/java_test/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/test.cfg b/testsuite/java_test/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..047e946f5b431d2f4e03a5837491434316e1792d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0153-rt-parent-ThreadLocalExObjecttoString/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalExObjecttoString)
+run(ThreadLocalExObjecttoString)
diff --git a/testsuite/java_test/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/ThreadLocalExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/ThreadLocalExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..985fed1fce71a183ef83eaeb55c275014bcfcfc3
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/ThreadLocalExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadLocalExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    ThreadLocal<Object> tl1 = new ThreadLocal<Object>();
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectwaitIllegalArgumentException().run());
+    }
+    private class ThreadLocalExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+        private ThreadLocalExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait(millis);
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class ThreadLocalExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+        private ThreadLocalExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait(millis, nanos);
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadLocalExObjectwaitIllegalArgumentException.res = ThreadLocalExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadLocalExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadLocalExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ThreadLocalExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a116c252d63ea7cee7d05eec7e83ee3a1d72a0cd
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalExObjectwaitIllegalArgumentException)
+run(ThreadLocalExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/ThreadLocalExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/ThreadLocalExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..4c004e67e584c32594a4554adcb93f4f81573aea
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/ThreadLocalExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadLocalExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static ThreadLocal<Object> tl1 = new ThreadLocal<>();
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = threadLocalExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = threadLocalExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = threadLocalExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ThreadLocalExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int threadLocalExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            tl1.wait();
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int threadLocalExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            tl1.wait(millis);
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int threadLocalExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            tl1.wait(millis, nanos);
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThreadLocalExObjectwaitIllegalMonitorStateException.res = ThreadLocalExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..198ba6206c509fdb9811ab113d84c00c213f3c48
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalExObjectwaitIllegalMonitorStateException)
+run(ThreadLocalExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/ThreadLocalExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/ThreadLocalExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..7231e35dc2a92fb586b8562db58e1a0a130bd88a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/ThreadLocalExObjectwaitInterruptedException.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThreadLocalExObjectwaitInterruptedException {
+    static int res = 99;
+    static ThreadLocal<Object> tl1 = new ThreadLocal<>();
+    public static void main(String argv[]) {
+        System.out.println(new ThreadLocalExObjectwaitInterruptedException().run());
+    }
+    private class ThreadLocalExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ThreadLocalExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait();
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class ThreadLocalExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+        private ThreadLocalExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait(millis);
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class ThreadLocalExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+        private ThreadLocalExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (tl1) {
+                tl1.notifyAll();
+                try {
+                    tl1.wait(millis, nanos);
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThreadLocalExObjectwaitInterruptedException.res = ThreadLocalExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThreadLocalExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThreadLocalExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThreadLocalExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && ThreadLocalExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7bd9648cdf64fc8c9963a3bb16077148426bb39d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalExObjectwaitInterruptedException)
+run(ThreadLocalExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/ThrowableExObjecthashCode.java b/testsuite/java_test/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/ThrowableExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..1339a07ef05456b6e8455efae1a7fbda57cf64e1
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/ThrowableExObjecthashCode.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Throwable;
+public class ThrowableExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = throwableExObjecthashCode1();
+        } catch (Exception e) {
+            ThrowableExObjecthashCode.res = ThrowableExObjecthashCode.res - 20;
+        }
+        if (result == 4 && ThrowableExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int throwableExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        Throwable cause1 = new Throwable("detailed message of cause1");
+        Throwable cause2 = cause1;
+        Throwable cause3 = new Throwable("detailed message of cause3");
+        if (cause1.hashCode() == cause2.hashCode() && cause1.hashCode() != cause3.hashCode()) {
+            ThrowableExObjecthashCode.res = ThrowableExObjecthashCode.res - 10;
+        } else {
+            ThrowableExObjecthashCode.res = ThrowableExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7c181e54054ecc47b717c4a7a415141a91dbd107
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0157-rt-parent-ThrowableExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableExObjecthashCode)
+run(ThrowableExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/ThrowableExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/ThrowableExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..17b736b284ea97c47d7aee9bb47c79db5a4b7da8
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/ThrowableExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThrowableExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private Throwable cause = new Throwable("detailed message of cause");
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = throwableExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ThrowableExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ThrowableExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int throwableExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        //  final void notifyAll()
+        try {
+            cause.notifyAll();
+            ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ThrowableExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+        private ThrowableExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                try {
+                    cause.notifyAll();
+                    ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectnotifyAllIllegalMonitorStateException.res = ThrowableExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e05b9ab44cfeb5dcd2e05401549f1678807e7348
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableExObjectnotifyAllIllegalMonitorStateException)
+run(ThrowableExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/ThrowableExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/ThrowableExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..500328bad7a90f5621af4b50e96d1c11b0d4e90e
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/ThrowableExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThrowableExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    private Throwable cause = new Throwable("detailed message of cause");
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = throwableExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new ThrowableExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && ThrowableExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int throwableExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            cause.notify();
+            ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class ThrowableExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private ThrowableExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                try {
+                    cause.notify();
+                    ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectnotifyIllegalMonitorStateException.res = ThrowableExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..98b4e8d2a02f4435b9143edc889a971858bd9072
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableExObjectnotifyIllegalMonitorStateException)
+run(ThrowableExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/ThrowableExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/ThrowableExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..69e5e455545ae811c030781fe1831df51fa75898
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/ThrowableExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class ThrowableExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    private Throwable cause = new Throwable("detailed message of cause");
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectwaitIllegalArgumentException().run());
+    }
+    private class ThrowableExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+        private ThrowableExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis);
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class ThrowableExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        //
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+        private ThrowableExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis, nanos);
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwaitIllegalArgumentException.res = ThrowableExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThrowableExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThrowableExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ThrowableExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b9f71f5823459e74ccfd80c8389015a64e2cf9e8
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableExObjectwaitIllegalArgumentException)
+run(ThrowableExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/ThrowableExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/ThrowableExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..f539211004e0f40661f7df83bf0638763369e18d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/ThrowableExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Throwable;
+public class ThrowableExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Throwable cause = new Throwable("detailed message of cause");
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = throwableExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = throwableExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = throwableExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ThrowableExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int throwableExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            cause.wait();
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int throwableExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            cause.wait(millis);
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int throwableExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            cause.wait(millis, nanos);
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ThrowableExObjectwaitIllegalMonitorStateException.res = ThrowableExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..80a739e5ec544da07fea7f1e765cf6ebdc9a46e8
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableExObjectwaitIllegalMonitorStateException)
+run(ThrowableExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/ThrowableExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/ThrowableExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..9b6bfe00da35cfb479b80ef1e7d375fc3962c013
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/ThrowableExObjectwaitInterruptedException.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Throwable;
+public class ThrowableExObjectwaitInterruptedException {
+    static int res = 99;
+    static Throwable cause = new Throwable("detailed message of cause");
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectwaitInterruptedException().run());
+    }
+    private class ThrowableExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ThrowableExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait();
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class ThrowableExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+        private ThrowableExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis);
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class ThrowableExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+        private ThrowableExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis, nanos);
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwaitInterruptedException.res = ThrowableExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThrowableExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThrowableExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThrowableExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && ThrowableExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4e33a0b6ecb0dd1e2419210ec626d2a11431840c
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0162-rt-parent-ThrowableExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableExObjectwaitInterruptedException)
+run(ThrowableExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0163-rt-parent-ThrowableExObjectwait/ThrowableExObjectwait.java b/testsuite/java_test/parent_test/RT0163-rt-parent-ThrowableExObjectwait/ThrowableExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..33fd224ac45f923aa049404b8036ba7006d42227
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0163-rt-parent-ThrowableExObjectwait/ThrowableExObjectwait.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Throwable;
+public class ThrowableExObjectwait {
+    static int res = 99;
+    private Throwable cause = new Throwable("detailed message of cause");
+    public static void main(String argv[]) {
+        System.out.println(new ThrowableExObjectwait().run());
+    }
+    private class ThrowableExObjectwait11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private ThrowableExObjectwait11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait();
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+    private class ThrowableExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10;
+        private ThrowableExObjectwait21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                cause.notify();
+                try {
+                    cause.wait(millis);
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    private class ThrowableExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10;
+        int nanos = 10;
+        private ThrowableExObjectwait31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (cause) {
+                cause.notifyAll();
+                try {
+                    cause.wait(millis, nanos);
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ThrowableExObjectwait.res = ThrowableExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * join fun
+     * @param thread wait join thread
+    */
+
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new ThrowableExObjectwait11(1));
+        Thread t2 = new Thread(new ThrowableExObjectwait11(2));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new ThrowableExObjectwait21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ThrowableExObjectwait31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        t1.interrupt();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        if (result == 2 && ThrowableExObjectwait.res == 54) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0163-rt-parent-ThrowableExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0163-rt-parent-ThrowableExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0163-rt-parent-ThrowableExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0163-rt-parent-ThrowableExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0163-rt-parent-ThrowableExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e7082d0c83e049a2971a9fe8460ca6bd8b2ce9eb
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0163-rt-parent-ThrowableExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(ThrowableExObjectwait)
+run(ThrowableExObjectwait)
diff --git a/testsuite/java_test/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/UnicodeBlockExObjectgetClass.java b/testsuite/java_test/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/UnicodeBlockExObjectgetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..bcf95dc746f7c338e37ca129de09637796590209
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/UnicodeBlockExObjectgetClass.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Character;
+public class UnicodeBlockExObjectgetClass {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new UnicodeBlockExObjectgetClass().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjectgetClass1();
+        } catch (Exception e) {
+            UnicodeBlockExObjectgetClass.res = UnicodeBlockExObjectgetClass.res - 20;
+        }
+        if (result == 4 && UnicodeBlockExObjectgetClass.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int unicodeBlockExObjectgetClass1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // final Class<?> getClass()
+        Character.UnicodeBlock unB1 = null;
+        for (int cp = 0; cp <= 10; ++cp) {
+            unB1 = Character.UnicodeBlock.of(cp);
+        }
+        Class px1 = unB1.getClass();
+        if (px1.toString().equals("class java.lang.Character$UnicodeBlock")) {
+            UnicodeBlockExObjectgetClass.res = UnicodeBlockExObjectgetClass.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/expected.txt b/testsuite/java_test/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/test.cfg b/testsuite/java_test/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2dc57d0f0359594317fa81f00434407b4107de81
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0164-rt-parent-UnicodeBlockExObjectgetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(UnicodeBlockExObjectgetClass)
+run(UnicodeBlockExObjectgetClass)
diff --git a/testsuite/java_test/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/UnicodeBlockExObjecthashCode.java b/testsuite/java_test/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/UnicodeBlockExObjecthashCode.java
new file mode 100755
index 0000000000000000000000000000000000000000..3402f147998708510f48844459eb686c6913b52d
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/UnicodeBlockExObjecthashCode.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Character;
+public class UnicodeBlockExObjecthashCode {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new UnicodeBlockExObjecthashCode().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjecthashCode1();
+        } catch (Exception e) {
+            UnicodeBlockExObjecthashCode.res = UnicodeBlockExObjecthashCode.res - 20;
+        }
+        if (result == 4 && UnicodeBlockExObjecthashCode.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int unicodeBlockExObjecthashCode1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // int hashCode()
+        Character.UnicodeBlock unB1 = Character.UnicodeBlock.of(10);
+        Character.UnicodeBlock unB2 = Character.UnicodeBlock.of(10);
+        Character.UnicodeBlock unB3 = Character.UnicodeBlock.of('〆');
+        if (unB1.hashCode() == unB2.hashCode() && unB1.hashCode() != unB3.hashCode()) {
+            UnicodeBlockExObjecthashCode.res = UnicodeBlockExObjecthashCode.res - 10;
+        } else {
+            UnicodeBlockExObjecthashCode.res = UnicodeBlockExObjecthashCode.res - 5;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/expected.txt b/testsuite/java_test/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/test.cfg b/testsuite/java_test/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..24b424afd227773aa26973cded747333367297aa
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0165-rt-parent-UnicodeBlockExObjecthashCode/test.cfg
@@ -0,0 +1,2 @@
+compile(UnicodeBlockExObjecthashCode)
+run(UnicodeBlockExObjecthashCode)
diff --git a/testsuite/java_test/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..b225381ef199e477c1d045925cabb7f325b7528a
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Character;
+public class UnicodeBlockExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private static Character.UnicodeBlock unb1 = null;
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(new UnicodeBlockExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new UnicodeBlockExObjectnotifyAllIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int unicodeBlockExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //  final void notifyAll()
+        try {
+            unb1.notifyAll();
+            UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class UnicodeBlockExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        //  final void notifyAll()
+        private int remainder;
+        private UnicodeBlockExObjectnotifyAllIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (unb1) {
+                try {
+                    unb1.notifyAll();
+                    UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..55dbd888870116fa55a2d856e24e7340f4cf4dfb
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(UnicodeBlockExObjectnotifyAllIllegalMonitorStateException)
+run(UnicodeBlockExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/UnicodeBlockExObjectnotifyIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/UnicodeBlockExObjectnotifyIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..d61228d016f1a85f608e5f85984c0e0aea854574
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/UnicodeBlockExObjectnotifyIllegalMonitorStateException.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Character;
+public class UnicodeBlockExObjectnotifyIllegalMonitorStateException {
+    static int res = 99;
+    static Character.UnicodeBlock unb1 = null;
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(new UnicodeBlockExObjectnotifyIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjectnotifyIllegalMonitorStateException1();
+        } catch (Exception e) {
+            UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new UnicodeBlockExObjectnotifyIllegalMonitorStateException11(1));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && UnicodeBlockExObjectnotifyIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int unicodeBlockExObjectnotifyIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notify()
+        try {
+            unb1.notify();
+            UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class UnicodeBlockExObjectnotifyIllegalMonitorStateException11 implements Runnable {
+        // final void notify()
+        private int remainder;
+        private UnicodeBlockExObjectnotifyIllegalMonitorStateException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (unb1) {
+                try {
+                    unb1.notify();
+                    UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectnotifyIllegalMonitorStateException.res = UnicodeBlockExObjectnotifyIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..99991fdd60d1dc4b0e6ed3e00878a36b5de300d0
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(UnicodeBlockExObjectnotifyIllegalMonitorStateException)
+run(UnicodeBlockExObjectnotifyIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/UnicodeBlockExObjecttoString.java b/testsuite/java_test/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/UnicodeBlockExObjecttoString.java
new file mode 100755
index 0000000000000000000000000000000000000000..20794a49c73c8d142e0b127b76c1cf082fe61155
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/UnicodeBlockExObjecttoString.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Character;
+public class UnicodeBlockExObjecttoString {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(new UnicodeBlockExObjecttoString().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = unicodeBlockExObjecttoString1();
+        } catch (Exception e) {
+            UnicodeBlockExObjecttoString.res = UnicodeBlockExObjecttoString.res - 20;
+        }
+        if (result == 4 && UnicodeBlockExObjecttoString.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+    private int unicodeBlockExObjecttoString1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // final String toString()
+        Character.UnicodeBlock unB1 = null;
+        for (int cp = 0; cp <= 10; ++cp) {
+            unB1 = Character.UnicodeBlock.of(cp);
+        }
+        String px1 = unB1.toString();
+        if (px1.equals("BASIC_LATIN")) {
+            UnicodeBlockExObjecttoString.res = UnicodeBlockExObjecttoString.res - 10;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/expected.txt b/testsuite/java_test/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/test.cfg b/testsuite/java_test/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a9f1f83b96dbdcbf4d6589f747f33ad30321b404
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0168-rt-parent-UnicodeBlockExObjecttoString/test.cfg
@@ -0,0 +1,2 @@
+compile(UnicodeBlockExObjecttoString)
+run(UnicodeBlockExObjecttoString)
diff --git a/testsuite/java_test/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/UnicodeBlockExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/UnicodeBlockExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..9a7eca22794113ea793a0de3697a451a3f8adc96
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/UnicodeBlockExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Character;
+public class UnicodeBlockExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Character.UnicodeBlock unb1 = null;
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = unicodeBlockExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = unicodeBlockExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = unicodeBlockExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && UnicodeBlockExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int unicodeBlockExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait()
+        try {
+            unb1.wait();
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int unicodeBlockExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            unb1.wait(millis);
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int unicodeBlockExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            unb1.wait(millis, nanos);
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            UnicodeBlockExObjectwaitIllegalMonitorStateException.res = UnicodeBlockExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..14a9fa18ecd5e2a00a14173c3dc32c5d2ff77889
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(UnicodeBlockExObjectwaitIllegalMonitorStateException)
+run(UnicodeBlockExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/UnicodeBlockExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/UnicodeBlockExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..33f6d664b9dc94a3edf6c36776d828070d7a1c99
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/UnicodeBlockExObjectwaitInterruptedException.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Character;
+public class UnicodeBlockExObjectwaitInterruptedException {
+    static int res = 99;
+    private static Character.UnicodeBlock unb1 = null;
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(new UnicodeBlockExObjectwaitInterruptedException().run());
+    }
+    private class UnicodeBlockExObjectwaitInterruptedException11 implements Runnable {
+        // final void wait()
+        private int remainder;
+        private UnicodeBlockExObjectwaitInterruptedException11(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait();
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class UnicodeBlockExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        private int remainder;
+        long millis = 10000;
+        private UnicodeBlockExObjectwaitInterruptedException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait(millis);
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class UnicodeBlockExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = 10000;
+        int nanos = 100;
+        private UnicodeBlockExObjectwaitInterruptedException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait(millis, nanos);
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    UnicodeBlockExObjectwaitInterruptedException.res = UnicodeBlockExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new UnicodeBlockExObjectwaitInterruptedException11(1));
+        // final void wait(long millis)
+        Thread t3 = new Thread(new UnicodeBlockExObjectwaitInterruptedException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new UnicodeBlockExObjectwaitInterruptedException31(5));
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t1.interrupt();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t3.interrupt();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t5.interrupt();
+        sleep(1000);
+        if (result == 2 && UnicodeBlockExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..571bb0a13c2665ae96149233f4785db2fb8464cf
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(UnicodeBlockExObjectwaitInterruptedException)
+run(UnicodeBlockExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/UnicodeBlockExObjectwait.java b/testsuite/java_test/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/UnicodeBlockExObjectwait.java
new file mode 100755
index 0000000000000000000000000000000000000000..6798e9d5a7754979fef6991f7394508b6fca1a38
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/UnicodeBlockExObjectwait.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Character;
+public class UnicodeBlockExObjectwait {
+    static int res = 99;
+    private static Character.UnicodeBlock unb1 = null;
+    public static void main(String argv[]) {
+        for (int cp = 0; cp <= 10; ++cp) {
+            unb1 = Character.UnicodeBlock.of(cp);
+        }
+        System.out.println(new UnicodeBlockExObjectwait().run());
+    }
+    private class UnicodeBlockExObjectwait11 implements Runnable {
+        // final void wait()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait();
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 10;
+                }
+            }
+        }
+    }
+    private class UnicodeBlockExObjectwait21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (unb1) {
+                unb1.notify();
+                try {
+                    unb1.wait(millis);
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    private class UnicodeBlockExObjectwait31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10;
+        int nanos = 10;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (unb1) {
+                unb1.notifyAll();
+                try {
+                    unb1.wait(millis, nanos);
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 15;
+                } catch (InterruptedException e1) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    UnicodeBlockExObjectwait.res = UnicodeBlockExObjectwait.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     *
+     * @param slpnum wait time
+    */
+
+    public void sleep(int slpnum) {
+        try {
+            Thread.sleep(slpnum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * join fun
+     * @param thread wait join thread
+    */
+
+    private void waitFinish(Thread thread) {
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     *
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new UnicodeBlockExObjectwait11());
+        Thread t2 = new Thread(new UnicodeBlockExObjectwait11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new UnicodeBlockExObjectwait21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new UnicodeBlockExObjectwait31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t2.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(1000);
+        t3.start();
+        sleep(1000);
+        t5.start();
+        sleep(1000);
+        t2.start();
+        sleep(1000);
+        t1.interrupt();
+        waitFinish(t1);
+        waitFinish(t3);
+        waitFinish(t5);
+        if (result == 2 && UnicodeBlockExObjectwait.res == 54) {
+            result = 0;
+        }
+        t2.interrupt();
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/expected.txt b/testsuite/java_test/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/test.cfg b/testsuite/java_test/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a32f2c91327f0412d5fecfcb01315c9360770ca7
--- /dev/null
+++ b/testsuite/java_test/parent_test/RT0171-rt-parent-UnicodeBlockExObjectwait/test.cfg
@@ -0,0 +1,2 @@
+compile(UnicodeBlockExObjectwait)
+run(UnicodeBlockExObjectwait)
diff --git a/testsuite/java_test/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/AccessibleObjectExObjectwaitInterruptedException.java b/testsuite/java_test/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/AccessibleObjectExObjectwaitInterruptedException.java
new file mode 100755
index 0000000000000000000000000000000000000000..d4626b760d3802177e1a741f281e6da7e9a93d73
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/AccessibleObjectExObjectwaitInterruptedException.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.AccessibleObject;
+public class AccessibleObjectExObjectwaitInterruptedException {
+    static int res = 99;
+    private static AccessibleObject sampleField1 = null;
+    public static void main(String argv[]) throws NoSuchFieldException, SecurityException {
+        sampleField1 = AccessibleObjectExObjectwaitInterruptedException.class.getDeclaredField("res");
+        System.out.println(new AccessibleObjectExObjectwaitInterruptedException().run());
+    }
+    private class AccessibleObjectExObjectwaitInterruptedException11 implements Runnable {
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait();
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 10;
+                }
+            }
+        }
+    }
+    private class AccessibleObjectExObjectwaitInterruptedException21 implements Runnable {
+        // final void wait(long millis)
+        long millis = 10000;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis);
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    private class AccessibleObjectExObjectwaitInterruptedException31 implements Runnable {
+        // final void wait(long millis, int nanos)
+        long millis = 10000;
+        int nanos = 100;
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (sampleField1) {
+                sampleField1.notifyAll();
+                try {
+                    sampleField1.wait(millis, nanos);
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 15;
+                } catch (InterruptedException e1) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 1;
+                } catch (IllegalMonitorStateException e2) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    AccessibleObjectExObjectwaitInterruptedException.res = AccessibleObjectExObjectwaitInterruptedException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     * @param sleepNum wait time
+    */
+
+    public void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // check api normal
+        // final void wait()
+        Thread t1 = new Thread(new AccessibleObjectExObjectwaitInterruptedException11());
+        // final void wait(long millis)
+        Thread t3 = new Thread(new AccessibleObjectExObjectwaitInterruptedException21());
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new AccessibleObjectExObjectwaitInterruptedException31());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        sleep(100);
+        t1.interrupt();
+        sleep(100);
+        t3.start();
+        sleep(100);
+        t3.interrupt();
+        sleep(100);
+        t5.start();
+        sleep(100);
+        t5.interrupt();
+        sleep(100);
+        if (result == 2 && AccessibleObjectExObjectwaitInterruptedException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/expected.txt b/testsuite/java_test/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/test.cfg b/testsuite/java_test/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..95e3407fb9ee90b258327caf64fa567f681a1c67
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException/test.cfg
@@ -0,0 +1,2 @@
+compile(AccessibleObjectExObjectwaitInterruptedException)
+run(AccessibleObjectExObjectwaitInterruptedException)
diff --git a/testsuite/java_test/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/CharacterExObjectnotifyAllIllegalMonitorStateException.java b/testsuite/java_test/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/CharacterExObjectnotifyAllIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..a55d137196c0131d1b154dbc632d56e9a8864001
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/CharacterExObjectnotifyAllIllegalMonitorStateException.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+public class CharacterExObjectnotifyAllIllegalMonitorStateException {
+    static int res = 99;
+    private char name = 'A';
+    private Character rp = new Character(name);
+    public static void main(String argv[]) {
+        System.out.println(new CharacterExObjectnotifyAllIllegalMonitorStateException().run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = characterExObjectnotifyAllIllegalMonitorStateException1();
+        } catch (Exception e) {
+            CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 20;
+        }
+        Thread t1 = new Thread(new CharacterExObjectnotifyAllIllegalMonitorStateException11());
+        t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t1.start();
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (result == 4 && CharacterExObjectnotifyAllIllegalMonitorStateException.res == 58) {
+            result = 0;
+        }
+        return result;
+    }
+    private int characterExObjectnotifyAllIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void notifyAll()
+        try {
+            rp.notifyAll();
+            CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 10;
+        } catch (IllegalMonitorStateException e2) {
+            CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private class CharacterExObjectnotifyAllIllegalMonitorStateException11 implements Runnable {
+        // final void notifyAll()
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (rp) {
+                try {
+                    rp.notifyAll();
+                    CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 40;
+                } catch (IllegalMonitorStateException e2) {
+                    CharacterExObjectnotifyAllIllegalMonitorStateException.res = CharacterExObjectnotifyAllIllegalMonitorStateException.res - 30;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4981046985c5a16924f736fd6a12fc2033083dae
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(CharacterExObjectnotifyAllIllegalMonitorStateException)
+run(CharacterExObjectnotifyAllIllegalMonitorStateException)
diff --git a/testsuite/java_test/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/ModifierExObjectwaitIllegalArgumentException.java b/testsuite/java_test/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/ModifierExObjectwaitIllegalArgumentException.java
new file mode 100755
index 0000000000000000000000000000000000000000..5b93f9fcc9a86fe0dcf191cd4b6f21409f061989
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/ModifierExObjectwaitIllegalArgumentException.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class ModifierExObjectwaitIllegalArgumentException {
+    static int res = 99;
+    static Modifier mf2 = new Modifier();
+    public static void main(String argv[]) {
+        System.out.println(new ModifierExObjectwaitIllegalArgumentException().run());
+    }
+    private class ModifierExObjectwaitIllegalArgumentException21 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative.
+        // final void wait(long millis)
+        private int remainder;
+        long millis = -1;
+        private ModifierExObjectwaitIllegalArgumentException21(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis);
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    private class ModifierExObjectwaitIllegalArgumentException31 implements Runnable {
+        // IllegalArgumentException - if the value of timeout is negative or the value of nanos is not in the range 0-999999.
+        // final void wait(long millis, int nanos)
+        private int remainder;
+        long millis = -2;
+        int nanos = 10;
+        private ModifierExObjectwaitIllegalArgumentException31(int remainder) {
+            this.remainder = remainder;
+        }
+        /**
+         * Thread run fun
+        */
+
+        public void run() {
+            synchronized (mf2) {
+                mf2.notifyAll();
+                try {
+                    mf2.wait(millis, nanos);
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 15;
+                } catch (InterruptedException e1) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 20;
+                } catch (IllegalMonitorStateException e2) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 10;
+                } catch (IllegalArgumentException e3) {
+                    ModifierExObjectwaitIllegalArgumentException.res = ModifierExObjectwaitIllegalArgumentException.res - 5;
+                }
+            }
+        }
+    }
+    /**
+     * sleep fun
+     * @param slpNum wait time
+    */
+
+    public void sleep(int slpNum) {
+        try {
+            Thread.sleep(slpNum);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public int run() {
+        int result = 2; /*STATUS_FAILED*/
+        //  final void wait(long millis)
+        Thread t3 = new Thread(new ModifierExObjectwaitIllegalArgumentException21(3));
+        // final void wait(long millis, int nanos)
+        Thread t5 = new Thread(new ModifierExObjectwaitIllegalArgumentException31(5));
+        t3.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t5.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " : " + e.getMessage());
+            }
+        });
+        t3.start();
+        t5.start();
+        sleep(1000);
+        if (result == 2 && ModifierExObjectwaitIllegalArgumentException.res == 89) {
+            result = 0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/expected.txt b/testsuite/java_test/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/test.cfg b/testsuite/java_test/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..77d10bef1431c703a97dda46577feb59e6e02c30
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException/test.cfg
@@ -0,0 +1,2 @@
+compile(ModifierExObjectwaitIllegalArgumentException)
+run(ModifierExObjectwaitIllegalArgumentException)
diff --git a/testsuite/java_test/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/ModifierExObjectwaitIllegalMonitorStateException.java b/testsuite/java_test/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/ModifierExObjectwaitIllegalMonitorStateException.java
new file mode 100755
index 0000000000000000000000000000000000000000..43483abf81a6d1a5c3b919f4d91c010a7101289b
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/ModifierExObjectwaitIllegalMonitorStateException.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class ModifierExObjectwaitIllegalMonitorStateException {
+    static int res = 99;
+    private static Modifier mf2 = new Modifier();
+    public static void main(String argv[]) {
+        System.out.println(run());
+    }
+    /**
+     * main test fun
+     * @return status code
+    */
+
+    public static int run() {
+        int result = 2; /*STATUS_FAILED*/
+        // final void wait()
+        try {
+            result = modifierExObjectwaitIllegalMonitorStateException1();
+        } catch (Exception e) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis)
+        try {
+            result = modifierExObjectwaitIllegalMonitorStateException2();
+        } catch (Exception e) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        // final void wait(long millis, int nanos)
+        try {
+            result = modifierExObjectwaitIllegalMonitorStateException3();
+        } catch (Exception e) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 20;
+        }
+        if (result == 4 && ModifierExObjectwaitIllegalMonitorStateException.res == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int modifierExObjectwaitIllegalMonitorStateException1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        //
+        // final void wait()
+        try {
+            mf2.wait();
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int modifierExObjectwaitIllegalMonitorStateException2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis)
+        long millis = 123;
+        try {
+            mf2.wait(millis);
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+    private static int modifierExObjectwaitIllegalMonitorStateException3() {
+        int result1 = 4; /*STATUS_FAILED*/
+        // IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.
+        // final void wait(long millis, int nanos)
+        long millis = 123;
+        int nanos = 10;
+        try {
+            mf2.wait(millis, nanos);
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 10;
+        } catch (InterruptedException e1) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 30;
+        } catch (IllegalMonitorStateException e2) {
+            ModifierExObjectwaitIllegalMonitorStateException.res = ModifierExObjectwaitIllegalMonitorStateException.res - 1;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/expected.txt b/testsuite/java_test/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/test.cfg b/testsuite/java_test/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f47d14d88bff62e952891e9690f90bfb8e510d05
--- /dev/null
+++ b/testsuite/java_test/parent_test/issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException/test.cfg
@@ -0,0 +1,2 @@
+compile(ModifierExObjectwaitIllegalMonitorStateException)
+run(ModifierExObjectwaitIllegalMonitorStateException)
diff --git a/testsuite/java_test/rc_test/RC0001-rc-function-Cycle_a_00180/Cycle_a_00180.java b/testsuite/java_test/rc_test/RC0001-rc-function-Cycle_a_00180/Cycle_a_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..d4c7c7dddc27c4164b13acda12270651c69d80b9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0001-rc-function-Cycle_a_00180/Cycle_a_00180.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00180_A1 {
+    Cycle_a_00180_A2 a2_0;
+    Cycle_a_00180_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00180_A1(String strObjectName) {
+        a2_0 = null;
+        a8_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a8_0.a;
+    }
+}
+class Cycle_a_00180_A2 {
+    Cycle_a_00180_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00180_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00180_A3 {
+    Cycle_a_00180_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00180_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00180_A4 {
+    Cycle_a_00180_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00180_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_a_00180_A5 {
+    Cycle_a_00180_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00180_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00180_A6 {
+    Cycle_a_00180_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00180_A6(String strObjectName) {
+        a1_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00180_A7 {
+    Cycle_a_00180_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00180_A7(String strObjectName) {
+        a4_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00180_A8 {
+    Cycle_a_00180_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00180_A8(String strObjectName) {
+        a9_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+class Cycle_a_00180_A9 {
+    Cycle_a_00180_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00180_A9(String strObjectName) {
+        a7_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+public class Cycle_a_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00180_A1 a1_main = new Cycle_a_00180_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00180_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00180_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00180_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00180_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00180_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a8_0 = new Cycle_a_00180_A8("a8_0");
+        a1_main.a8_0.a9_0 = new Cycle_a_00180_A9("a9_0");
+        a1_main.a8_0.a9_0.a7_0 = new Cycle_a_00180_A7("a7_0");
+        a1_main.a8_0.a9_0.a7_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_main.a8_0.add();
+        a1_main.a8_0.a9_0.add();
+        a1_main.a8_0.a9_0.a7_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_main.a8_0.sum + a1_main.a8_0.a9_0.sum + a1_main.a8_0.a9_0.a7_0.sum;
+        if (result == 1994)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0001-rc-function-Cycle_a_00180/expected.txt b/testsuite/java_test/rc_test/RC0001-rc-function-Cycle_a_00180/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0001-rc-function-Cycle_a_00180/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0001-rc-function-Cycle_a_00180/test.cfg b/testsuite/java_test/rc_test/RC0001-rc-function-Cycle_a_00180/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d5e0c74ac787cf46e74ed2bf3f5f024103deeced
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0001-rc-function-Cycle_a_00180/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00180)
+run(Cycle_a_00180,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0002-rc-function-Cycle_a_00190/Cycle_a_00190.java b/testsuite/java_test/rc_test/RC0002-rc-function-Cycle_a_00190/Cycle_a_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..644d792b523dfdb0a958e350167caf0db3f17262
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0002-rc-function-Cycle_a_00190/Cycle_a_00190.java
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00190_A1 {
+    Cycle_a_00190_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00190_A2 {
+    Cycle_a_00190_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00190_A3 {
+    Cycle_a_00190_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00190_A4 {
+    Cycle_a_00190_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_a_00190_A5 {
+    Cycle_a_00190_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00190_A6 {
+    Cycle_a_00190_A1 a1_0;
+    Cycle_a_00190_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A6(String strObjectName) {
+        a1_0 = null;
+        a10_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a10_0.a;
+    }
+}
+class Cycle_a_00190_A7 {
+    Cycle_a_00190_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A7(String strObjectName) {
+        a5_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_a_00190_A8 {
+    Cycle_a_00190_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A8(String strObjectName) {
+        a9_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+class Cycle_a_00190_A9 {
+    Cycle_a_00190_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A9(String strObjectName) {
+        a7_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_00190_A10 {
+    Cycle_a_00190_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00190_A10(String strObjectName) {
+        a8_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+public class Cycle_a_00190 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00190_A1 a1_main = new Cycle_a_00190_A1("a1_main");
+        Cycle_a_00190_A10 a10_main = new Cycle_a_00190_A10("a10_main");
+        a1_main.a2_0 = new Cycle_a_00190_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00190_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00190_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00190_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00190_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_main;
+        a10_main.a8_0 = new Cycle_a_00190_A8("a8_0");
+        a10_main.a8_0.a9_0 = new Cycle_a_00190_A9("a9_0");
+        a10_main.a8_0.a9_0.a7_0 = new Cycle_a_00190_A7("a7_0");
+        a10_main.a8_0.a9_0.a7_0.a5_0 = a1_main.a2_0.a3_0.a4_0.a5_0;
+        a1_main.add();
+        a10_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_main.a8_0.add();
+        a10_main.a8_0.a9_0.add();
+        a10_main.a8_0.a9_0.a7_0.add();
+        int result = a1_main.sum + a10_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_main.a8_0.sum + a10_main.a8_0.a9_0.sum + a10_main.a8_0.a9_0.a7_0.sum;
+        if (result == 2215)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0002-rc-function-Cycle_a_00190/expected.txt b/testsuite/java_test/rc_test/RC0002-rc-function-Cycle_a_00190/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0002-rc-function-Cycle_a_00190/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0002-rc-function-Cycle_a_00190/test.cfg b/testsuite/java_test/rc_test/RC0002-rc-function-Cycle_a_00190/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d7fb7f62c948da19e2183a414abdc2bbae7e97b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0002-rc-function-Cycle_a_00190/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00190)
+run(Cycle_a_00190,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0003-rc-function-Cycle_a_00200/Cycle_a_00200.java b/testsuite/java_test/rc_test/RC0003-rc-function-Cycle_a_00200/Cycle_a_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..449e969fac780d60389e4505fdd5c6df7b22a52e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0003-rc-function-Cycle_a_00200/Cycle_a_00200.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00200_A1 {
+    Cycle_a_00200_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00200_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00200_A2 {
+    Cycle_a_00200_A3 a3_0;
+    Cycle_a_00200_A6 a6_0;
+    Cycle_a_00200_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00200_A2(String strObjectName) {
+        a3_0 = null;
+        a6_0 = null;
+        a7_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a6_0.a + a7_0.a;
+    }
+}
+class Cycle_a_00200_A3 {
+    Cycle_a_00200_A1 a1_0;
+    Cycle_a_00200_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00200_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00200_A4 {
+    Cycle_a_00200_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00200_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00200_A5 {
+    Cycle_a_00200_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00200_A5(String strObjectName) {
+        a4_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00200_A6 {
+    Cycle_a_00200_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00200_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_00200_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00200_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Cycle_a_00200 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00200_A1 a1_main = new Cycle_a_00200_A1("a1_main");
+        Cycle_a_00200_A4 a4_main = new Cycle_a_00200_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00200_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00200_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00200_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a6_0 = new Cycle_a_00200_A6("a6_0");
+        a1_main.a2_0.a6_0.a7_0 = new Cycle_a_00200_A7("a7_0");
+        a1_main.a2_0.a7_0 = a1_main.a2_0.a6_0.a7_0;
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a6_0.add();
+        a1_main.a2_0.a6_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a6_0.sum + a1_main.a2_0.a6_0.a7_0.sum;
+        if (result == 1773)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0003-rc-function-Cycle_a_00200/expected.txt b/testsuite/java_test/rc_test/RC0003-rc-function-Cycle_a_00200/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0003-rc-function-Cycle_a_00200/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0003-rc-function-Cycle_a_00200/test.cfg b/testsuite/java_test/rc_test/RC0003-rc-function-Cycle_a_00200/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f54db1d3bb18b2f9a48969112f3a2bbb273d447e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0003-rc-function-Cycle_a_00200/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00200)
+run(Cycle_a_00200,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0004-rc-function-Cycle_a_00210/Cycle_a_00210.java b/testsuite/java_test/rc_test/RC0004-rc-function-Cycle_a_00210/Cycle_a_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..8f3e9b57bfd84dbb9be52e8e3f40897850c08b5a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0004-rc-function-Cycle_a_00210/Cycle_a_00210.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00210_A1 {
+    Cycle_a_00210_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00210_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00210_A2 {
+    Cycle_a_00210_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00210_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00210_A3 {
+    Cycle_a_00210_A1 a1_0;
+    Cycle_a_00210_A5 a5_0;
+    Cycle_a_00210_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00210_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a6_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a6_0.a;
+    }
+}
+class Cycle_a_00210_A4 {
+    Cycle_a_00210_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00210_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00210_A5 {
+    Cycle_a_00210_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00210_A5(String strObjectName) {
+        a4_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00210_A6 {
+    Cycle_a_00210_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00210_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_00210_A7 {
+    Cycle_a_00210_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00210_A7(String strObjectName) {
+        a3_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_a_00210 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00210_A1 a1_main = new Cycle_a_00210_A1("a1_main");
+        Cycle_a_00210_A4 a4_main = new Cycle_a_00210_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00210_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00210_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00210_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00210_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0 = new Cycle_a_00210_A7("a7_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        a1_main.a2_0.a3_0.a6_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a6_0.sum + a1_main.a2_0.a3_0.a6_0.a7_0.sum;
+        if (result == 1662)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0004-rc-function-Cycle_a_00210/expected.txt b/testsuite/java_test/rc_test/RC0004-rc-function-Cycle_a_00210/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0004-rc-function-Cycle_a_00210/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0004-rc-function-Cycle_a_00210/test.cfg b/testsuite/java_test/rc_test/RC0004-rc-function-Cycle_a_00210/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..72770fbf03bd85113e429593b82f5b672ef29a1e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0004-rc-function-Cycle_a_00210/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00210)
+run(Cycle_a_00210,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0005-rc-function-Cycle_a_00220/Cycle_a_00220.java b/testsuite/java_test/rc_test/RC0005-rc-function-Cycle_a_00220/Cycle_a_00220.java
new file mode 100755
index 0000000000000000000000000000000000000000..ed17cb300818f6282ba089a052442b9bee7f67a0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0005-rc-function-Cycle_a_00220/Cycle_a_00220.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00220_A1 {
+    Cycle_a_00220_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00220_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00220_A2 {
+    Cycle_a_00220_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00220_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00220_A3 {
+    Cycle_a_00220_A1 a1_0;
+    Cycle_a_00220_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00220_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00220_A4 {
+    Cycle_a_00220_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00220_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00220_A5 {
+    Cycle_a_00220_A4 a4_0;
+    Cycle_a_00220_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00220_A5(String strObjectName) {
+        a4_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a + a7_0.a;
+    }
+}
+class Cycle_a_00220_A6 {
+    Cycle_a_00220_A5 a5_0;
+    Cycle_a_00220_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00220_A6(String strObjectName) {
+        a5_0 = null;
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a + a7_0.a;
+    }
+}
+class Cycle_a_00220_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00220_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Cycle_a_00220 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00220_A1 a1_main = new Cycle_a_00220_A1("a1_main");
+        Cycle_a_00220_A4 a4_main = new Cycle_a_00220_A4("a4_main");
+        Cycle_a_00220_A6 a6_main = new Cycle_a_00220_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00220_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00220_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00220_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_00220_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        if (result == 1772)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0005-rc-function-Cycle_a_00220/expected.txt b/testsuite/java_test/rc_test/RC0005-rc-function-Cycle_a_00220/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0005-rc-function-Cycle_a_00220/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0005-rc-function-Cycle_a_00220/test.cfg b/testsuite/java_test/rc_test/RC0005-rc-function-Cycle_a_00220/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1fbeaad6670f5515d5de29ca646a75162dd6853a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0005-rc-function-Cycle_a_00220/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00220)
+run(Cycle_a_00220,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0006-rc-function-Cycle_a_00230/Cycle_a_00230.java b/testsuite/java_test/rc_test/RC0006-rc-function-Cycle_a_00230/Cycle_a_00230.java
new file mode 100755
index 0000000000000000000000000000000000000000..e6943838a85d040877b5b73a186f3151ffa09990
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0006-rc-function-Cycle_a_00230/Cycle_a_00230.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00230_A1 {
+    Cycle_a_00230_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00230_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00230_A2 {
+    Cycle_a_00230_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00230_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00230_A3 {
+    Cycle_a_00230_A1 a1_0;
+    Cycle_a_00230_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00230_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00230_A4 {
+    Cycle_a_00230_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00230_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_a_00230_A5 {
+    Cycle_a_00230_A3 a3_0;
+    Cycle_a_00230_A6 a6_0;
+    Cycle_a_00230_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00230_A5(String strObjectName) {
+        a3_0 = null;
+        a6_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a6_0.a + a7_0.a;
+    }
+}
+class Cycle_a_00230_A6 {
+    Cycle_a_00230_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00230_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_00230_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00230_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Cycle_a_00230 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00230_A1 a1_main = new Cycle_a_00230_A1("a1_main");
+        Cycle_a_00230_A5 a5_main = new Cycle_a_00230_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00230_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00230_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00230_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a7_0 = new Cycle_a_00230_A7("a7_0");
+        a5_main.a6_0 = new Cycle_a_00230_A6("a6_0");
+        a5_main.a6_0.a7_0 = a5_main.a7_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a5_main.a7_0.add();
+        a5_main.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a5_main.a6_0.sum + a5_main.a7_0.sum;
+        if (result == 1773)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0006-rc-function-Cycle_a_00230/expected.txt b/testsuite/java_test/rc_test/RC0006-rc-function-Cycle_a_00230/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0006-rc-function-Cycle_a_00230/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0006-rc-function-Cycle_a_00230/test.cfg b/testsuite/java_test/rc_test/RC0006-rc-function-Cycle_a_00230/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9d113b6b5b76d18401e414b1ce66a823cc5546e3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0006-rc-function-Cycle_a_00230/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00230)
+run(Cycle_a_00230,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0007-rc-function-Cycle_a_00240/Cycle_a_00240.java b/testsuite/java_test/rc_test/RC0007-rc-function-Cycle_a_00240/Cycle_a_00240.java
new file mode 100755
index 0000000000000000000000000000000000000000..1fdc1ccb5b9a700487d7d2d3db2a38288018caf3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0007-rc-function-Cycle_a_00240/Cycle_a_00240.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00240_A1 {
+    Cycle_a_00240_A2 a2_0;
+    Cycle_a_00240_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00240_A1(String strObjectName) {
+        a2_0 = null;
+        a6_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a6_0.a;
+    }
+}
+class Cycle_a_00240_A2 {
+    Cycle_a_00240_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00240_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00240_A3 {
+    Cycle_a_00240_A1 a1_0;
+    Cycle_a_00240_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00240_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00240_A4 {
+    Cycle_a_00240_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00240_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_a_00240_A5 {
+    Cycle_a_00240_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00240_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00240_A6 {
+    Cycle_a_00240_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00240_A6(String strObjectName) {
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_00240_A7 {
+    Cycle_a_00240_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00240_A7(String strObjectName) {
+        a1_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_a_00240 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00240_A1 a1_main = new Cycle_a_00240_A1("a1_main");
+        Cycle_a_00240_A5 a5_main = new Cycle_a_00240_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00240_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00240_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a6_0 = new Cycle_a_00240_A6("a6_0");
+        a1_main.a6_0.a7_0 = new Cycle_a_00240_A7("a7_0");
+        a1_main.a6_0.a7_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a6_0.add();
+        a1_main.a6_0.a7_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a6_0.sum + a1_main.a6_0.a7_0.sum;
+        if (result == 1660)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0007-rc-function-Cycle_a_00240/expected.txt b/testsuite/java_test/rc_test/RC0007-rc-function-Cycle_a_00240/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0007-rc-function-Cycle_a_00240/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0007-rc-function-Cycle_a_00240/test.cfg b/testsuite/java_test/rc_test/RC0007-rc-function-Cycle_a_00240/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..406a8deec3ea3f111aa26cbb85d5a6206f0ac93b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0007-rc-function-Cycle_a_00240/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00240)
+run(Cycle_a_00240,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0008-rc-function-Cycle_a_00250/Cycle_a_00250.java b/testsuite/java_test/rc_test/RC0008-rc-function-Cycle_a_00250/Cycle_a_00250.java
new file mode 100755
index 0000000000000000000000000000000000000000..fab49b4ef4b9afcab9359ac86313a1e326890ae3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0008-rc-function-Cycle_a_00250/Cycle_a_00250.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00250_A1 {
+    Cycle_a_00250_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00250_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00250_A2 {
+    Cycle_a_00250_A1 a1_0;
+    Cycle_a_00250_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00250_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00250_A3 {
+    Cycle_a_00250_A1 a1_0;
+    Cycle_a_00250_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00250_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00250_A5 {
+    Cycle_a_00250_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00250_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00250_A6 {
+    Cycle_a_00250_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00250_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_a_00250 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00250_A1 a1_main = new Cycle_a_00250_A1("a1_main");
+        Cycle_a_00250_A6 a6_main = new Cycle_a_00250_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00250_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00250_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00250_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1238)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0008-rc-function-Cycle_a_00250/expected.txt b/testsuite/java_test/rc_test/RC0008-rc-function-Cycle_a_00250/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0008-rc-function-Cycle_a_00250/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0008-rc-function-Cycle_a_00250/test.cfg b/testsuite/java_test/rc_test/RC0008-rc-function-Cycle_a_00250/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..337c540d6ad42ea7a9eab054b0eeb7e123fed160
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0008-rc-function-Cycle_a_00250/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00250)
+run(Cycle_a_00250,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0009-rc-function-Cycle_a_00260/Cycle_a_00260.java b/testsuite/java_test/rc_test/RC0009-rc-function-Cycle_a_00260/Cycle_a_00260.java
new file mode 100755
index 0000000000000000000000000000000000000000..b574894398ca7e23cd24d0b3bd15bc5ebed3a5f5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0009-rc-function-Cycle_a_00260/Cycle_a_00260.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00260_A1 {
+    Cycle_a_00260_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00260_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00260_A2 {
+    Cycle_a_00260_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00260_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00260_A3 {
+    Cycle_a_00260_A1 a1_0;
+    Cycle_a_00260_A2 a2_0;
+    Cycle_a_00260_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00260_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a2_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00260_A5 {
+    Cycle_a_00260_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00260_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00260_A6 {
+    Cycle_a_00260_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00260_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_a_00260 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00260_A1 a1_main = new Cycle_a_00260_A1("a1_main");
+        Cycle_a_00260_A6 a6_main = new Cycle_a_00260_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00260_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00260_A3("a3_0");
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00260_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1239)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0009-rc-function-Cycle_a_00260/expected.txt b/testsuite/java_test/rc_test/RC0009-rc-function-Cycle_a_00260/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0009-rc-function-Cycle_a_00260/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0009-rc-function-Cycle_a_00260/test.cfg b/testsuite/java_test/rc_test/RC0009-rc-function-Cycle_a_00260/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8a901f41a207eb20c9cddb07a0b3f2203f1ff92d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0009-rc-function-Cycle_a_00260/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00260)
+run(Cycle_a_00260,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0010-rc-function-Cycle_a_00270/Cycle_a_00270.java b/testsuite/java_test/rc_test/RC0010-rc-function-Cycle_a_00270/Cycle_a_00270.java
new file mode 100755
index 0000000000000000000000000000000000000000..414f41783a29d6e2397d61f193654b578a19c770
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0010-rc-function-Cycle_a_00270/Cycle_a_00270.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00270_A1 {
+    Cycle_a_00270_A2 a2_0;
+    Cycle_a_00270_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00270_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00270_A2 {
+    Cycle_a_00270_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00270_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00270_A3 {
+    Cycle_a_00270_A1 a1_0;
+    Cycle_a_00270_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00270_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00270_A5 {
+    Cycle_a_00270_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00270_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00270_A6 {
+    Cycle_a_00270_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00270_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_a_00270 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00270_A1 a1_main = new Cycle_a_00270_A1("a1_main");
+        Cycle_a_00270_A6 a6_main = new Cycle_a_00270_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00270_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00270_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00270_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1240)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0010-rc-function-Cycle_a_00270/expected.txt b/testsuite/java_test/rc_test/RC0010-rc-function-Cycle_a_00270/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0010-rc-function-Cycle_a_00270/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0010-rc-function-Cycle_a_00270/test.cfg b/testsuite/java_test/rc_test/RC0010-rc-function-Cycle_a_00270/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8a9f975153245820b9534936489dfbd91c73544c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0010-rc-function-Cycle_a_00270/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00270)
+run(Cycle_a_00270,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0011-rc-function-Cycle_a_00280/Cycle_a_00280.java b/testsuite/java_test/rc_test/RC0011-rc-function-Cycle_a_00280/Cycle_a_00280.java
new file mode 100755
index 0000000000000000000000000000000000000000..ca4088e1ee5bca4f670f893a21ff2bcf2ed72ec6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0011-rc-function-Cycle_a_00280/Cycle_a_00280.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00280_A1 {
+    Cycle_a_00280_A2 a2_0;
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00280_A2 {
+    Cycle_a_00280_A1 a1_0;
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00280_A3 {
+    Cycle_a_00280_A1 a1_0;
+    Cycle_a_00280_A2 a2_0;
+    Cycle_a_00280_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a2_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00280_A5 {
+    Cycle_a_00280_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00280_A6 {
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_a_00280 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1443)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0011-rc-function-Cycle_a_00280/expected.txt b/testsuite/java_test/rc_test/RC0011-rc-function-Cycle_a_00280/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0011-rc-function-Cycle_a_00280/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0011-rc-function-Cycle_a_00280/test.cfg b/testsuite/java_test/rc_test/RC0011-rc-function-Cycle_a_00280/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ced7b08fa2eecd7453f0f058c9d00e7cdb7f11c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0011-rc-function-Cycle_a_00280/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00280)
+run(Cycle_a_00280,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0012-rc-function-Cycle_a_00290/Cycle_a_00290.java b/testsuite/java_test/rc_test/RC0012-rc-function-Cycle_a_00290/Cycle_a_00290.java
new file mode 100755
index 0000000000000000000000000000000000000000..795ab22aa870a3e1003db65725448325734f5d89
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0012-rc-function-Cycle_a_00290/Cycle_a_00290.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00290_A1 {
+    Cycle_a_00290_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00290_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00290_A2 {
+    Cycle_a_00290_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00290_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00290_A3 {
+    Cycle_a_00290_A1 a1_0;
+    Cycle_a_00290_A4 a4_0;
+    Cycle_a_00290_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00290_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a6_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a6_0.a;
+    }
+}
+class Cycle_a_00290_A4 {
+    Cycle_a_00290_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00290_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_a_00290_A5 {
+    Cycle_a_00290_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00290_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00290_A6 {
+    Cycle_a_00290_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00290_A6(String strObjectName) {
+        a2_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_a_00290 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00290_A1 a1_main = new Cycle_a_00290_A1("a1_main");
+        Cycle_a_00290_A5 a5_main = new Cycle_a_00290_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00290_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00290_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00290_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00290_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a2_0 = a1_main.a2_0;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a6_0.sum;
+        if (result == 1447)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0012-rc-function-Cycle_a_00290/expected.txt b/testsuite/java_test/rc_test/RC0012-rc-function-Cycle_a_00290/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0012-rc-function-Cycle_a_00290/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0012-rc-function-Cycle_a_00290/test.cfg b/testsuite/java_test/rc_test/RC0012-rc-function-Cycle_a_00290/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5f983519d10f7666e240617f68f5e03f91999052
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0012-rc-function-Cycle_a_00290/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00290)
+run(Cycle_a_00290,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0013-rc-function-Cycle_a_00300/Cycle_a_00300.java b/testsuite/java_test/rc_test/RC0013-rc-function-Cycle_a_00300/Cycle_a_00300.java
new file mode 100755
index 0000000000000000000000000000000000000000..e2fedf5aa9cd9dc88e836fc7ceb80c598e5cf50a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0013-rc-function-Cycle_a_00300/Cycle_a_00300.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00300_A1 {
+    Cycle_a_00300_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00300_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00300_A2 {
+    Cycle_a_00300_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00300_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00300_A3 {
+    Cycle_a_00300_A1 a1_0;
+    Cycle_a_00300_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00300_A3(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00300_A4 {
+    Cycle_a_00300_A5 a5_0;
+    Cycle_a_00300_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00300_A4(String strObjectName) {
+        a5_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a + a6_0.a;
+    }
+}
+class Cycle_a_00300_A5 {
+    Cycle_a_00300_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00300_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00300_A6 {
+    Cycle_a_00300_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00300_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_a_00300 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00300_A1 a1_main = new Cycle_a_00300_A1("a1_main");
+        Cycle_a_00300_A5 a5_main = new Cycle_a_00300_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00300_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00300_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00300_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a6_0 = new Cycle_a_00300_A6("a6_0");
+        a5_main.a3_0.a4_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1448)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0013-rc-function-Cycle_a_00300/expected.txt b/testsuite/java_test/rc_test/RC0013-rc-function-Cycle_a_00300/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0013-rc-function-Cycle_a_00300/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0013-rc-function-Cycle_a_00300/test.cfg b/testsuite/java_test/rc_test/RC0013-rc-function-Cycle_a_00300/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dbeb85be6a7e0ead78afb03a3b0a4ea2106fc68c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0013-rc-function-Cycle_a_00300/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00300)
+run(Cycle_a_00300,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0014-rc-function-Cycle_a_00310/Cycle_a_00310.java b/testsuite/java_test/rc_test/RC0014-rc-function-Cycle_a_00310/Cycle_a_00310.java
new file mode 100755
index 0000000000000000000000000000000000000000..a591702330c8a0dc708a8d60764170077ddeea26
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0014-rc-function-Cycle_a_00310/Cycle_a_00310.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00310_A1 {
+    Cycle_a_00310_A2 a2_0;
+    Cycle_a_00310_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00310_A1(String strObjectName) {
+        a2_0 = null;
+        a4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00310_A2 {
+    Cycle_a_00310_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00310_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00310_A3 {
+    Cycle_a_00310_A1 a1_0;
+    Cycle_a_00310_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00310_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00310_A4 {
+    Cycle_a_00310_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00310_A4(String strObjectName) {
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00310_A5 {
+    Cycle_a_00310_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00310_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00310_A6 {
+    Cycle_a_00310_A1 a1_0;
+    Cycle_a_00310_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00310_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+public class Cycle_a_00310 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00310_A1 a1_main = new Cycle_a_00310_A1("a1_main");
+        Cycle_a_00310_A4 a4_main = new Cycle_a_00310_A4("a4_main");
+        Cycle_a_00310_A6 a6_main = new Cycle_a_00310_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00310_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00310_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00310_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a4_0 = a4_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a4_main.a6_0 = a6_main;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1552)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0014-rc-function-Cycle_a_00310/expected.txt b/testsuite/java_test/rc_test/RC0014-rc-function-Cycle_a_00310/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0014-rc-function-Cycle_a_00310/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0014-rc-function-Cycle_a_00310/test.cfg b/testsuite/java_test/rc_test/RC0014-rc-function-Cycle_a_00310/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e37917d266b4e45c6cfd1f752ce8e53358d2e702
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0014-rc-function-Cycle_a_00310/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00310)
+run(Cycle_a_00310,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0015-rc-function-Cycle_a_00320/Cycle_a_00320.java b/testsuite/java_test/rc_test/RC0015-rc-function-Cycle_a_00320/Cycle_a_00320.java
new file mode 100755
index 0000000000000000000000000000000000000000..380acf3f4d434745d31012b110a9820ed2e7c2da
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0015-rc-function-Cycle_a_00320/Cycle_a_00320.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00320_A1 {
+    Cycle_a_00320_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00320_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00320_A2 {
+    Cycle_a_00320_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00320_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00320_A3 {
+    Cycle_a_00320_A1 a1_0;
+    Cycle_a_00320_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00320_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00320_A4 {
+    Cycle_a_00320_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00320_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_a_00320_A5 {
+    Cycle_a_00320_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00320_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00320_A6 {
+    Cycle_a_00320_A1 a1_0;
+    Cycle_a_00320_A3 a3_0;
+    Cycle_a_00320_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00320_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+public class Cycle_a_00320 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00320_A1 a1_main = new Cycle_a_00320_A1("a1_main");
+        Cycle_a_00320_A4 a4_main = new Cycle_a_00320_A4("a4_main");
+        Cycle_a_00320_A6 a6_main = new Cycle_a_00320_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00320_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00320_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00320_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a6_main.a4_0 = a4_main;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1551)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0015-rc-function-Cycle_a_00320/expected.txt b/testsuite/java_test/rc_test/RC0015-rc-function-Cycle_a_00320/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0015-rc-function-Cycle_a_00320/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0015-rc-function-Cycle_a_00320/test.cfg b/testsuite/java_test/rc_test/RC0015-rc-function-Cycle_a_00320/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f3f98bdd90dbca3cfb26fa85f630e85c4a41a437
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0015-rc-function-Cycle_a_00320/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00320)
+run(Cycle_a_00320,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0016-rc-function-Cycle_a_00330/Cycle_a_00330.java b/testsuite/java_test/rc_test/RC0016-rc-function-Cycle_a_00330/Cycle_a_00330.java
new file mode 100755
index 0000000000000000000000000000000000000000..e1ace17b024ee95f75fcf4d0d57bd547865114da
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0016-rc-function-Cycle_a_00330/Cycle_a_00330.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00330_A1 {
+    Cycle_a_00330_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00330_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00330_A2 {
+    Cycle_a_00330_A3 a3_0;
+    Cycle_a_00330_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00330_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00330_A3 {
+    Cycle_a_00330_A1 a1_0;
+    Cycle_a_00330_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00330_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00330_A4 {
+    Cycle_a_00330_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00330_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00330_A5 {
+    Cycle_a_00330_A6 a6_0;
+    Cycle_a_00330_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00330_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+class Cycle_a_00330_A6 {
+    Cycle_a_00330_A1 a1_0;
+    Cycle_a_00330_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00330_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00330_A7 {
+    Cycle_a_00330_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00330_A7(String strObjectName) {
+        a3_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00330_A8 {
+    Cycle_a_00330_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00330_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+public class Cycle_a_00330 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00330_A1 a1_main = new Cycle_a_00330_A1("a1_main");
+        Cycle_a_00330_A4 a4_main = new Cycle_a_00330_A4("a4_main");
+        Cycle_a_00330_A6 a6_main = new Cycle_a_00330_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00330_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00330_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00330_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00330_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00330_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        if (result == 2080)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0016-rc-function-Cycle_a_00330/expected.txt b/testsuite/java_test/rc_test/RC0016-rc-function-Cycle_a_00330/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0016-rc-function-Cycle_a_00330/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0016-rc-function-Cycle_a_00330/test.cfg b/testsuite/java_test/rc_test/RC0016-rc-function-Cycle_a_00330/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0ff1c5711a3c4ebff1fa1e9aed4c9032712ac3c3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0016-rc-function-Cycle_a_00330/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00330)
+run(Cycle_a_00330,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0017-rc-function-Cycle_a_00340/Cycle_a_00340.java b/testsuite/java_test/rc_test/RC0017-rc-function-Cycle_a_00340/Cycle_a_00340.java
new file mode 100755
index 0000000000000000000000000000000000000000..fad0f43be6a2707277cb8f58816bd2af77a25821
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0017-rc-function-Cycle_a_00340/Cycle_a_00340.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00340_A1 {
+    Cycle_a_00340_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00340_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00340_A2 {
+    Cycle_a_00340_A3 a3_0;
+    Cycle_a_00340_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00340_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00340_A3 {
+    Cycle_a_00340_A1 a1_0;
+    Cycle_a_00340_A5 a5_0;
+    Cycle_a_00340_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00340_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a8_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a8_0.a;
+    }
+}
+class Cycle_a_00340_A4 {
+    Cycle_a_00340_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00340_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00340_A5 {
+    Cycle_a_00340_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00340_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00340_A6 {
+    Cycle_a_00340_A1 a1_0;
+    Cycle_a_00340_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00340_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00340_A7 {
+    Cycle_a_00340_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00340_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00340_A8 {
+    Cycle_a_00340_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00340_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+public class Cycle_a_00340 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00340_A1 a1_main = new Cycle_a_00340_A1("a1_main");
+        Cycle_a_00340_A4 a4_main = new Cycle_a_00340_A4("a4_main");
+        Cycle_a_00340_A6 a6_main = new Cycle_a_00340_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00340_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00340_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00340_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a8_0 = new Cycle_a_00340_A8("a8_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0 = new Cycle_a_00340_A7("a7_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a8_0.add();
+        a1_main.a2_0.a3_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a8_0.a7_0.sum + a6_main.a3_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2079)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0017-rc-function-Cycle_a_00340/expected.txt b/testsuite/java_test/rc_test/RC0017-rc-function-Cycle_a_00340/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0017-rc-function-Cycle_a_00340/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0017-rc-function-Cycle_a_00340/test.cfg b/testsuite/java_test/rc_test/RC0017-rc-function-Cycle_a_00340/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6c377d3b9aebf582fcee97d4816002ddb4677e2c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0017-rc-function-Cycle_a_00340/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00340)
+run(Cycle_a_00340,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0018-rc-function-Cycle_a_00350/Cycle_a_00350.java b/testsuite/java_test/rc_test/RC0018-rc-function-Cycle_a_00350/Cycle_a_00350.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3528a828c0b3e0d355284672e84bd091658827b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0018-rc-function-Cycle_a_00350/Cycle_a_00350.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00350_A1 {
+    Cycle_a_00350_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00350_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00350_A2 {
+    Cycle_a_00350_A3 a3_0;
+    Cycle_a_00350_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00350_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00350_A3 {
+    Cycle_a_00350_A1 a1_0;
+    Cycle_a_00350_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00350_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00350_A4 {
+    Cycle_a_00350_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00350_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00350_A5 {
+    Cycle_a_00350_A6 a6_0;
+    Cycle_a_00350_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00350_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+class Cycle_a_00350_A6 {
+    Cycle_a_00350_A1 a1_0;
+    Cycle_a_00350_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00350_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00350_A7 {
+    Cycle_a_00350_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00350_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00350_A8 {
+    Cycle_a_00350_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00350_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+public class Cycle_a_00350 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00350_A1 a1_main = new Cycle_a_00350_A1("a1_main");
+        Cycle_a_00350_A4 a4_main = new Cycle_a_00350_A4("a4_main");
+        Cycle_a_00350_A6 a6_main = new Cycle_a_00350_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00350_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00350_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00350_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00350_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00350_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum
+            + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        if (result == 2079) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0018-rc-function-Cycle_a_00350/expected.txt b/testsuite/java_test/rc_test/RC0018-rc-function-Cycle_a_00350/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0018-rc-function-Cycle_a_00350/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0018-rc-function-Cycle_a_00350/test.cfg b/testsuite/java_test/rc_test/RC0018-rc-function-Cycle_a_00350/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..49125d05aa0533f43b32c0f7d0eb16bb1500d90b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0018-rc-function-Cycle_a_00350/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00350)
+run(Cycle_a_00350,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0019-rc-function-Cycle_a_00360/Cycle_a_00360.java b/testsuite/java_test/rc_test/RC0019-rc-function-Cycle_a_00360/Cycle_a_00360.java
new file mode 100755
index 0000000000000000000000000000000000000000..b0234fae2fe182a93d5e7c7f313397d35d229a7a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0019-rc-function-Cycle_a_00360/Cycle_a_00360.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00360_A1 {
+    Cycle_a_00360_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00360_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00360_A2 {
+    Cycle_a_00360_A3 a3_0;
+    Cycle_a_00360_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00360_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00360_A3 {
+    Cycle_a_00360_A1 a1_0;
+    Cycle_a_00360_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00360_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00360_A4 {
+    Cycle_a_00360_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00360_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00360_A5 {
+    Cycle_a_00360_A6 a6_0;
+    Cycle_a_00360_A8 a8_0;
+    Cycle_a_00360_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00360_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a9_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a + a8_0.a + a9_0.a;
+    }
+}
+class Cycle_a_00360_A6 {
+    Cycle_a_00360_A1 a1_0;
+    Cycle_a_00360_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00360_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00360_A7 {
+    Cycle_a_00360_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00360_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00360_A8 {
+    Cycle_a_00360_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00360_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_00360_A9 {
+    Cycle_a_00360_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00360_A9(String strObjectName) {
+        a2_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_a_00360 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00360_A1 a1_main = new Cycle_a_00360_A1("a1_main");
+        Cycle_a_00360_A4 a4_main = new Cycle_a_00360_A4("a4_main");
+        Cycle_a_00360_A6 a6_main = new Cycle_a_00360_A6("a6_main");
+        Cycle_a_00360_A9 a9_main = new Cycle_a_00360_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00360_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00360_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00360_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00360_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00360_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0.a9_0 = a9_main;
+        a9_main.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2399)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0019-rc-function-Cycle_a_00360/expected.txt b/testsuite/java_test/rc_test/RC0019-rc-function-Cycle_a_00360/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0019-rc-function-Cycle_a_00360/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0019-rc-function-Cycle_a_00360/test.cfg b/testsuite/java_test/rc_test/RC0019-rc-function-Cycle_a_00360/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fa4575e835fddc7bf453374824a06335ffb5ba71
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0019-rc-function-Cycle_a_00360/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00360)
+run(Cycle_a_00360,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0020-rc-function-Cycle_a_00370/Cycle_a_00370.java b/testsuite/java_test/rc_test/RC0020-rc-function-Cycle_a_00370/Cycle_a_00370.java
new file mode 100755
index 0000000000000000000000000000000000000000..f8ae369eb81b1fa6099445aa2469209214982ca5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0020-rc-function-Cycle_a_00370/Cycle_a_00370.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00370_A1 {
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00370_A2 {
+    Cycle_a_00370_A3 a3_0;
+    Cycle_a_00370_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00370_A3 {
+    Cycle_a_00370_A1 a1_0;
+    Cycle_a_00370_A5 a5_0;
+    Cycle_a_00370_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a10_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a10_0.a;
+    }
+}
+class Cycle_a_00370_A4 {
+    Cycle_a_00370_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00370_A5 {
+    Cycle_a_00370_A6 a6_0;
+    Cycle_a_00370_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+class Cycle_a_00370_A6 {
+    Cycle_a_00370_A1 a1_0;
+    Cycle_a_00370_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00370_A7 {
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00370_A8 {
+    Cycle_a_00370_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_00370_A9 {
+    Cycle_a_00370_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A9(String strObjectName) {
+        a6_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00370_A10 {
+    Cycle_a_00370_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A10(String strObjectName) {
+        a9_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+public class Cycle_a_00370 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2623)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0020-rc-function-Cycle_a_00370/expected.txt b/testsuite/java_test/rc_test/RC0020-rc-function-Cycle_a_00370/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0020-rc-function-Cycle_a_00370/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0020-rc-function-Cycle_a_00370/test.cfg b/testsuite/java_test/rc_test/RC0020-rc-function-Cycle_a_00370/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..40979b0b72a997a1c3acb9eec43abd1777463fdf
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0020-rc-function-Cycle_a_00370/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00370)
+run(Cycle_a_00370,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0021-rc-function-Cycle_a_00380/Cycle_a_00380.java b/testsuite/java_test/rc_test/RC0021-rc-function-Cycle_a_00380/Cycle_a_00380.java
new file mode 100755
index 0000000000000000000000000000000000000000..3d045cd6f7addea1f170a19c350743ba0c976d30
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0021-rc-function-Cycle_a_00380/Cycle_a_00380.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00380_A1 {
+    Cycle_a_00380_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00380_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00380_A2 {
+    Cycle_a_00380_A1 a1_0;
+    Cycle_a_00380_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00380_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00380_A3 {
+    Cycle_a_00380_A1 a1_0;
+    Cycle_a_00380_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00380_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+public class Cycle_a_00380 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00380_A1 a1_main = new Cycle_a_00380_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00380_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00380_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 815)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0021-rc-function-Cycle_a_00380/expected.txt b/testsuite/java_test/rc_test/RC0021-rc-function-Cycle_a_00380/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0021-rc-function-Cycle_a_00380/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0021-rc-function-Cycle_a_00380/test.cfg b/testsuite/java_test/rc_test/RC0021-rc-function-Cycle_a_00380/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0d471950e7b88dac59fa471457fcb33fab7a6b94
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0021-rc-function-Cycle_a_00380/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00380)
+run(Cycle_a_00380,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0022-rc-function-Cycle_a_00390/Cycle_a_00390.java b/testsuite/java_test/rc_test/RC0022-rc-function-Cycle_a_00390/Cycle_a_00390.java
new file mode 100755
index 0000000000000000000000000000000000000000..531f68787e16167c9aa40988458524c1105bde33
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0022-rc-function-Cycle_a_00390/Cycle_a_00390.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00390_A1 {
+    Cycle_a_00390_A2 a2_0;
+    Cycle_a_00390_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00390_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00390_A2 {
+    Cycle_a_00390_A1 a1_0;
+    Cycle_a_00390_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00390_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00390_A3 {
+    Cycle_a_00390_A1 a1_0;
+    Cycle_a_00390_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00390_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+public class Cycle_a_00390 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00390_A1 a1_main = new Cycle_a_00390_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00390_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00390_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 918)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0022-rc-function-Cycle_a_00390/expected.txt b/testsuite/java_test/rc_test/RC0022-rc-function-Cycle_a_00390/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0022-rc-function-Cycle_a_00390/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0022-rc-function-Cycle_a_00390/test.cfg b/testsuite/java_test/rc_test/RC0022-rc-function-Cycle_a_00390/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..937933915eb181e90843d1e1302a307d81d0f5f1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0022-rc-function-Cycle_a_00390/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00390)
+run(Cycle_a_00390,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0023-rc-function-Cycle_a_00400/Cycle_a_00400.java b/testsuite/java_test/rc_test/RC0023-rc-function-Cycle_a_00400/Cycle_a_00400.java
new file mode 100755
index 0000000000000000000000000000000000000000..5145ec675b2d84a4c02a1047df1db275abfb77a7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0023-rc-function-Cycle_a_00400/Cycle_a_00400.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00400_A1 {
+    Cycle_a_00400_A2 a2_0;
+    Cycle_a_00400_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00400_A1(String strObjectName) {
+        a2_0 = null;
+        a4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00400_A2 {
+    Cycle_a_00400_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00400_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00400_A3 {
+    Cycle_a_00400_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00400_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00400_A4 {
+    Cycle_a_00400_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00400_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_a_00400 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00400_A1 a1_main = new Cycle_a_00400_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00400_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00400_A3("a3_0");
+        a1_main.a4_0 = new Cycle_a_00400_A4("a4_0");
+        a1_main.a4_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 923)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0023-rc-function-Cycle_a_00400/expected.txt b/testsuite/java_test/rc_test/RC0023-rc-function-Cycle_a_00400/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0023-rc-function-Cycle_a_00400/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0023-rc-function-Cycle_a_00400/test.cfg b/testsuite/java_test/rc_test/RC0023-rc-function-Cycle_a_00400/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..abe3aff074a9d221749de07a4c790b354f91b0d5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0023-rc-function-Cycle_a_00400/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00400)
+run(Cycle_a_00400,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0024-rc-function-Cycle_a_00410/Cycle_a_00410.java b/testsuite/java_test/rc_test/RC0024-rc-function-Cycle_a_00410/Cycle_a_00410.java
new file mode 100755
index 0000000000000000000000000000000000000000..7412b390eb09f477c0da6be6a0c9a29832366d28
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0024-rc-function-Cycle_a_00410/Cycle_a_00410.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00410_A1 {
+    Cycle_a_00410_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00410_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00410_A2 {
+    Cycle_a_00410_A3 a3_0;
+    Cycle_a_00410_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00410_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00410_A3 {
+    Cycle_a_00410_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00410_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00410_A4 {
+    Cycle_a_00410_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00410_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_a_00410 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00410_A1 a1_main = new Cycle_a_00410_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00410_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00410_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00410_A4("a4_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 921)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0024-rc-function-Cycle_a_00410/expected.txt b/testsuite/java_test/rc_test/RC0024-rc-function-Cycle_a_00410/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0024-rc-function-Cycle_a_00410/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0024-rc-function-Cycle_a_00410/test.cfg b/testsuite/java_test/rc_test/RC0024-rc-function-Cycle_a_00410/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..de09ac33b3f2a67d607eb5593d0c54dbb912a9f7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0024-rc-function-Cycle_a_00410/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00410)
+run(Cycle_a_00410,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0025-rc-function-Cycle_a_00420/Cycle_a_00420.java b/testsuite/java_test/rc_test/RC0025-rc-function-Cycle_a_00420/Cycle_a_00420.java
new file mode 100755
index 0000000000000000000000000000000000000000..51c0351cd09b9d43709089e15d22364048bf247f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0025-rc-function-Cycle_a_00420/Cycle_a_00420.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00420_A1 {
+    Cycle_a_00420_A2 a2_0;
+    Cycle_a_00420_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00420_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00420_A2 {
+    Cycle_a_00420_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00420_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00420_A3 {
+    Cycle_a_00420_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00420_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00420_A4 {
+    Cycle_a_00420_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00420_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_a_00420 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00420_A1 a1_main = new Cycle_a_00420_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00420_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00420_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00420_A4("a4_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum;
+        if (result == 923)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0025-rc-function-Cycle_a_00420/expected.txt b/testsuite/java_test/rc_test/RC0025-rc-function-Cycle_a_00420/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0025-rc-function-Cycle_a_00420/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0025-rc-function-Cycle_a_00420/test.cfg b/testsuite/java_test/rc_test/RC0025-rc-function-Cycle_a_00420/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..42f83871f9896e0134795bf4fea108b2e73c930f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0025-rc-function-Cycle_a_00420/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00420)
+run(Cycle_a_00420,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0026-rc-function-Cycle_a_00430/Cycle_a_00430.java b/testsuite/java_test/rc_test/RC0026-rc-function-Cycle_a_00430/Cycle_a_00430.java
new file mode 100755
index 0000000000000000000000000000000000000000..857957a23dc5b3b6e48d49fb9317bd5f6a39cc5b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0026-rc-function-Cycle_a_00430/Cycle_a_00430.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00430_A1 {
+    Cycle_a_00430_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00430_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00430_A2 {
+    Cycle_a_00430_A1 a1_0;
+    Cycle_a_00430_A3 a3_0;
+    Cycle_a_00430_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00430_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00430_A3 {
+    Cycle_a_00430_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00430_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00430_A4 {
+    Cycle_a_00430_A1 a1_0;
+    Cycle_a_00430_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00430_A4(String strObjectName) {
+        a2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+public class Cycle_a_00430 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00430_A1 a1_main = new Cycle_a_00430_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00430_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00430_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00430_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1124)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0026-rc-function-Cycle_a_00430/expected.txt b/testsuite/java_test/rc_test/RC0026-rc-function-Cycle_a_00430/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0026-rc-function-Cycle_a_00430/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0026-rc-function-Cycle_a_00430/test.cfg b/testsuite/java_test/rc_test/RC0026-rc-function-Cycle_a_00430/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9d59bdb138795c6a5784067d82206eedbd840e1a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0026-rc-function-Cycle_a_00430/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00430)
+run(Cycle_a_00430,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0027-rc-function-Cycle_a_00440/Cycle_a_00440.java b/testsuite/java_test/rc_test/RC0027-rc-function-Cycle_a_00440/Cycle_a_00440.java
new file mode 100755
index 0000000000000000000000000000000000000000..0eeab655eef9437879dffc73fcbb0cf5ee7916ca
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0027-rc-function-Cycle_a_00440/Cycle_a_00440.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00440_A1 {
+    Cycle_a_00440_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00440_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00440_A2 {
+    Cycle_a_00440_A1 a1_0;
+    Cycle_a_00440_A3 a3_0;
+    Cycle_a_00440_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00440_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00440_A3 {
+    Cycle_a_00440_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00440_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00440_A4 {
+    Cycle_a_00440_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00440_A4(String strObjectName) {
+        a2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_a_00440 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00440_A1 a1_main = new Cycle_a_00440_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00440_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00440_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00440_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        if (result == 1023)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0027-rc-function-Cycle_a_00440/expected.txt b/testsuite/java_test/rc_test/RC0027-rc-function-Cycle_a_00440/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0027-rc-function-Cycle_a_00440/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0027-rc-function-Cycle_a_00440/test.cfg b/testsuite/java_test/rc_test/RC0027-rc-function-Cycle_a_00440/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..73ba06d403cedd3ed779975943b14f39e20032e3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0027-rc-function-Cycle_a_00440/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00440)
+run(Cycle_a_00440,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0028-rc-function-Cycle_a_00450/Cycle_a_00450.java b/testsuite/java_test/rc_test/RC0028-rc-function-Cycle_a_00450/Cycle_a_00450.java
new file mode 100755
index 0000000000000000000000000000000000000000..83ea8155cdcaff44bd4ed300afafdace993f34c9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0028-rc-function-Cycle_a_00450/Cycle_a_00450.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00450_A1 {
+    Cycle_a_00450_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00450_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00450_A2 {
+    Cycle_a_00450_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00450_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00450_A3 {
+    Cycle_a_00450_A1 a1_0;
+    Cycle_a_00450_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00450_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00450_A5 {
+    Cycle_a_00450_A6 a6_0;
+    Cycle_a_00450_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00450_A5(String strObjectName) {
+        a6_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a + a7_0.a;
+    }
+}
+class Cycle_a_00450_A6 {
+    Cycle_a_00450_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00450_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00450_A7 {
+    Cycle_a_00450_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00450_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_a_00450 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00450_A1 a1_main = new Cycle_a_00450_A1("a1_main");
+        Cycle_a_00450_A6 a6_main = new Cycle_a_00450_A6("a6_main");
+        Cycle_a_00450_A7 a7_main = new Cycle_a_00450_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00450_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00450_A3("a3_0");
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00450_A5("a5_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = a7_main;
+        a7_main.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a6_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1453)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0028-rc-function-Cycle_a_00450/expected.txt b/testsuite/java_test/rc_test/RC0028-rc-function-Cycle_a_00450/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0028-rc-function-Cycle_a_00450/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0028-rc-function-Cycle_a_00450/test.cfg b/testsuite/java_test/rc_test/RC0028-rc-function-Cycle_a_00450/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3738c0764be766d495c6d9a499afbcfb17d621be
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0028-rc-function-Cycle_a_00450/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00450)
+run(Cycle_a_00450,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0029-rc-function-Cycle_a_00460/Cycle_a_00460.java b/testsuite/java_test/rc_test/RC0029-rc-function-Cycle_a_00460/Cycle_a_00460.java
new file mode 100755
index 0000000000000000000000000000000000000000..64ff77244788230b89df5456223ee8085203fbae
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0029-rc-function-Cycle_a_00460/Cycle_a_00460.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00460_A1 {
+    Cycle_a_00460_A2 a2_0;
+    Cycle_a_00460_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00460_A1(String strObjectName) {
+        a2_0 = null;
+        a4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00460_A2 {
+    Cycle_a_00460_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00460_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00460_A3 {
+    Cycle_a_00460_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00460_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00460_A4 {
+    Cycle_a_00460_A1 a1_0;
+    Cycle_a_00460_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00460_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+class Cycle_a_00460_A5 {
+    Cycle_a_00460_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00460_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00460_A6 {
+    Cycle_a_00460_A1 a1_0;
+    Cycle_a_00460_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00460_A6(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+public class Cycle_a_00460 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00460_A1 a1_main = new Cycle_a_00460_A1("a1_main");
+        Cycle_a_00460_A5 a5_main = new Cycle_a_00460_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00460_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00460_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00460_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00460_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1550)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0029-rc-function-Cycle_a_00460/expected.txt b/testsuite/java_test/rc_test/RC0029-rc-function-Cycle_a_00460/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0029-rc-function-Cycle_a_00460/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0029-rc-function-Cycle_a_00460/test.cfg b/testsuite/java_test/rc_test/RC0029-rc-function-Cycle_a_00460/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..77fb556f213a4297b78289d2a5ff4e3dff86085b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0029-rc-function-Cycle_a_00460/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00460)
+run(Cycle_a_00460,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0030-rc-function-Cycle_a_00470/Cycle_a_00470.java b/testsuite/java_test/rc_test/RC0030-rc-function-Cycle_a_00470/Cycle_a_00470.java
new file mode 100755
index 0000000000000000000000000000000000000000..49bccfccd227034fd9bb2e5cb4c2343fe072cf85
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0030-rc-function-Cycle_a_00470/Cycle_a_00470.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00470_A1 {
+    Cycle_a_00470_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00470_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00470_A2 {
+    Cycle_a_00470_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00470_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00470_A3 {
+    Cycle_a_00470_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00470_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00470_A4 {
+    Cycle_a_00470_A1 a1_0;
+    Cycle_a_00470_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00470_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+class Cycle_a_00470_A5 {
+    Cycle_a_00470_A1 a1_0;
+    Cycle_a_00470_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00470_A5(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00470_A6 {
+    Cycle_a_00470_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00470_A6(String strObjectName) {
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+public class Cycle_a_00470 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00470_A1 a1_main = new Cycle_a_00470_A1("a1_main");
+        Cycle_a_00470_A5 a5_main = new Cycle_a_00470_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00470_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00470_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00470_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00470_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a1_0 = a1_main;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        if (result == 1446)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0030-rc-function-Cycle_a_00470/expected.txt b/testsuite/java_test/rc_test/RC0030-rc-function-Cycle_a_00470/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0030-rc-function-Cycle_a_00470/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0030-rc-function-Cycle_a_00470/test.cfg b/testsuite/java_test/rc_test/RC0030-rc-function-Cycle_a_00470/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c0917e252ec6486bc5ff676c8ea3f275ef3fdb8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0030-rc-function-Cycle_a_00470/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00470)
+run(Cycle_a_00470,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0031-rc-function-Cycle_a_00480/Cycle_a_00480.java b/testsuite/java_test/rc_test/RC0031-rc-function-Cycle_a_00480/Cycle_a_00480.java
new file mode 100755
index 0000000000000000000000000000000000000000..4d761befc40d1c53114c450aacd805341bae9f53
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0031-rc-function-Cycle_a_00480/Cycle_a_00480.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00480_A1 {
+    Cycle_a_00480_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00480_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00480_A2 {
+    Cycle_a_00480_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00480_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00480_A3 {
+    Cycle_a_00480_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00480_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00480_A4 {
+    Cycle_a_00480_A1 a1_0;
+    Cycle_a_00480_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00480_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+class Cycle_a_00480_A5 {
+    Cycle_a_00480_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00480_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00480_A6 {
+    Cycle_a_00480_A1 a1_0;
+    Cycle_a_00480_A4 a4_0;
+    Cycle_a_00480_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00480_A6(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a5_0.a;
+    }
+}
+public class Cycle_a_00480 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00480_A1 a1_main = new Cycle_a_00480_A1("a1_main");
+        Cycle_a_00480_A5 a5_main = new Cycle_a_00480_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00480_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00480_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00480_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00480_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        a5_main.a3_0.add();
+        a5_main.a3_0.a4_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        if (result == 1550)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0031-rc-function-Cycle_a_00480/expected.txt b/testsuite/java_test/rc_test/RC0031-rc-function-Cycle_a_00480/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0031-rc-function-Cycle_a_00480/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0031-rc-function-Cycle_a_00480/test.cfg b/testsuite/java_test/rc_test/RC0031-rc-function-Cycle_a_00480/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3a4866630c77bff6bc638c1611dbe729401ae27d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0031-rc-function-Cycle_a_00480/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00480)
+run(Cycle_a_00480,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0032-rc-function-Cycle_a_00490/Cycle_a_00490.java b/testsuite/java_test/rc_test/RC0032-rc-function-Cycle_a_00490/Cycle_a_00490.java
new file mode 100755
index 0000000000000000000000000000000000000000..13c00c1ac25826c30ec956ec2f86a56cd23a4e70
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0032-rc-function-Cycle_a_00490/Cycle_a_00490.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00490_A1 {
+    Cycle_a_00490_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00490_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00490_A2 {
+    Cycle_a_00490_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00490_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00490_A3 {
+    Cycle_a_00490_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00490_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00490_A4 {
+    Cycle_a_00490_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00490_A4(String strObjectName) {
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_a_00490_A5 {
+    Cycle_a_00490_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00490_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00490_A6 {
+    Cycle_a_00490_A3 a3_0;
+    Cycle_a_00490_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00490_A6(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00490_A7 {
+    Cycle_a_00490_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00490_A7(String strObjectName) {
+        a9_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+class Cycle_a_00490_A8 {
+    Cycle_a_00490_A5 a5_0;
+    Cycle_a_00490_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00490_A8(String strObjectName) {
+        a5_0 = null;
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00490_A9 {
+    Cycle_a_00490_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00490_A9(String strObjectName) {
+        a8_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+public class Cycle_a_00490 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00490_A1 a1_main = new Cycle_a_00490_A1("a1_main");
+        Cycle_a_00490_A4 a4_main = new Cycle_a_00490_A4("a4_main");
+        Cycle_a_00490_A7 a7_main = new Cycle_a_00490_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00490_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00490_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00490_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+        a4_main.a5_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0.a6_0.a3_0.a1_0 = a1_main;
+        a7_main.a9_0 = new Cycle_a_00490_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00490_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0.a8_0.a5_0 = a4_main.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a6_0.a3_0.add();
+        a4_main.a5_0.a6_0.a3_0.a1_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        a7_main.a9_0.a8_0.a5_0.add();
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        if (result == 2098)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0032-rc-function-Cycle_a_00490/expected.txt b/testsuite/java_test/rc_test/RC0032-rc-function-Cycle_a_00490/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0032-rc-function-Cycle_a_00490/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0032-rc-function-Cycle_a_00490/test.cfg b/testsuite/java_test/rc_test/RC0032-rc-function-Cycle_a_00490/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c36b1ac5bb366eae6a84867998f1c0e6a8d9ee03
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0032-rc-function-Cycle_a_00490/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00490)
+run(Cycle_a_00490,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0033-rc-function-Cycle_a_00500/Cycle_a_00500.java b/testsuite/java_test/rc_test/RC0033-rc-function-Cycle_a_00500/Cycle_a_00500.java
new file mode 100755
index 0000000000000000000000000000000000000000..b8fbc2d987c0f0b458e62828a201000f9cfce4f6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0033-rc-function-Cycle_a_00500/Cycle_a_00500.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_00500_A1 {
+    Cycle_a_00500_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00500_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00500_A2 {
+    Cycle_a_00500_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00500_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_00500_A3 {
+    Cycle_a_00500_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00500_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00500_A4 {
+    Cycle_a_00500_A1 a1_0;
+    Cycle_a_00500_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00500_A4(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00500_A5 {
+    Cycle_a_00500_A6 a6_0;
+    Cycle_a_00500_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00500_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+class Cycle_a_00500_A6 {
+    Cycle_a_00500_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00500_A6(String strObjectName) {
+        a4_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_a_00500_A7 {
+    Cycle_a_00500_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00500_A7(String strObjectName) {
+        a9_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+class Cycle_a_00500_A8 {
+    Cycle_a_00500_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00500_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_00500_A9 {
+    Cycle_a_00500_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00500_A9(String strObjectName) {
+        a8_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+public class Cycle_a_00500 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00500_A1 a1_main = new Cycle_a_00500_A1("a1_main");
+        Cycle_a_00500_A4 a4_main = new Cycle_a_00500_A4("a4_main");
+        Cycle_a_00500_A7 a7_main = new Cycle_a_00500_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00500_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00500_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a4_main.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00500_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00500_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+        a4_main.a5_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a4_main.a5_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0 = new Cycle_a_00500_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a8_0.add();
+        a4_main.a5_0.a8_0.a7_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        if (result == 2099)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0033-rc-function-Cycle_a_00500/expected.txt b/testsuite/java_test/rc_test/RC0033-rc-function-Cycle_a_00500/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0033-rc-function-Cycle_a_00500/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0033-rc-function-Cycle_a_00500/test.cfg b/testsuite/java_test/rc_test/RC0033-rc-function-Cycle_a_00500/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c49286cbfdb9258aee49e0cc7f3b9e7e7cee4db0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0033-rc-function-Cycle_a_00500/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_00500)
+run(Cycle_a_00500,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0034-rc-function-Cycle_a_10010/Cycle_a_10010.java b/testsuite/java_test/rc_test/RC0034-rc-function-Cycle_a_10010/Cycle_a_10010.java
new file mode 100755
index 0000000000000000000000000000000000000000..19c4a020e1ccdb468f4ad7b44faa21f28e1450a0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0034-rc-function-Cycle_a_10010/Cycle_a_10010.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_10010_A1 {
+    Cycle_a_10010_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_10010_A2 {
+    Cycle_a_10010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_10010_A3 {
+    Cycle_a_10010_A1 a1_0;
+    Cycle_a_10010_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_10010_A4 {
+    Cycle_a_10010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_A4(String strObjectName) {
+        a3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_10010_A5 {
+    Cycle_a_10010_A4 a4_0;
+    Cycle_a_10010_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_A5(String strObjectName) {
+        a4_0 = null;
+        a7_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a + a7_0.a;
+    }
+}
+class Cycle_a_10010_A6 {
+    Cycle_a_10010_A5 a5_0;
+    Cycle_a_10010_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_A6(String strObjectName) {
+        a5_0 = null;
+        a7_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a5_0.a + a7_0.a;
+    }
+}
+class Cycle_a_10010_A7 {
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_A7(String strObjectName) {
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Cycle_a_10010_2A1 {
+    Cycle_a_10010_2A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_2A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_10010_2A2 {
+    Cycle_a_10010_2A3 a3_0;
+    Cycle_a_10010_2A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_2A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_10010_2A3 {
+    Cycle_a_10010_2A1 a1_0;
+    Cycle_a_10010_2A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_2A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a;
+    }
+}
+class Cycle_a_10010_2A4 {
+    Cycle_a_10010_2A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_2A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_10010_2A5 {
+    Cycle_a_10010_2A6 a6_0;
+    Cycle_a_10010_2A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_2A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+class Cycle_a_10010_2A6 {
+    Cycle_a_10010_2A1 a1_0;
+    Cycle_a_10010_2A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_2A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_10010_2A7 {
+    Cycle_a_10010_2A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_2A7(String strObjectName) {
+        a3_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_a_10010_2A8 {
+    Cycle_a_10010_2A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10010_2A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+public class Cycle_a_10010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_10010_A1 a1_main = new Cycle_a_10010_A1("a1_main");
+        Cycle_a_10010_A4 a4_main = new Cycle_a_10010_A4("a4_main");
+        Cycle_a_10010_A6 a6_main = new Cycle_a_10010_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_10010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10010_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10010_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_10010_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        Cycle_a_10010_2A1 a1_2main = new Cycle_a_10010_2A1("a1_2main");
+        Cycle_a_10010_2A4 a4_2main = new Cycle_a_10010_2A4("a4_2main");
+        Cycle_a_10010_2A6 a6_2main = new Cycle_a_10010_2A6("a6_2main");
+        a1_2main.a2_0 = new Cycle_a_10010_2A2("a2_0");
+        a1_2main.a2_0.a3_0 = new Cycle_a_10010_2A3("a3_0");
+        a1_2main.a2_0.a4_0 = a4_2main;
+        a4_2main.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a5_0 = new Cycle_a_10010_2A5("a5_0");
+        a1_2main.a2_0.a3_0.a5_0.a6_0 = a6_2main;
+        a1_2main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10010_2A8("a8_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10010_2A7("a7_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_2main.a2_0.a3_0;
+        a6_2main.a1_0 = a1_2main;
+        a6_2main.a3_0 = a1_2main.a2_0.a3_0;
+        a1_2main.add();
+        a4_2main.add();
+        a6_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        a1_2main.a2_0.a3_0.a5_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result2 = a1_2main.sum + a4_2main.sum + a6_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum + a1_2main.a2_0.a3_0.a5_0.sum + a6_2main.a3_0.a5_0.a8_0.a7_0.sum + a6_2main.a3_0.a5_0.a8_0.sum;
+        result += result2;
+        if (result == 3852)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0034-rc-function-Cycle_a_10010/expected.txt b/testsuite/java_test/rc_test/RC0034-rc-function-Cycle_a_10010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0034-rc-function-Cycle_a_10010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0034-rc-function-Cycle_a_10010/test.cfg b/testsuite/java_test/rc_test/RC0034-rc-function-Cycle_a_10010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..49315b8ef6c64b048aab9f929d18fbddfa5a9e10
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0034-rc-function-Cycle_a_10010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_10010)
+run(Cycle_a_10010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0035-rc-function-Cycle_a_10020/Cycle_a_10020.java b/testsuite/java_test/rc_test/RC0035-rc-function-Cycle_a_10020/Cycle_a_10020.java
new file mode 100755
index 0000000000000000000000000000000000000000..42894df0ebd9fc9644fd859b553b828364bd03b7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0035-rc-function-Cycle_a_10020/Cycle_a_10020.java
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_a_10020_A1 {
+    Cycle_a_10020_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_10020_A2 {
+    Cycle_a_10020_A3 a3_0;
+    Cycle_a_10020_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_10020_A3 {
+    Cycle_a_10020_A1 a1_0;
+    Cycle_a_10020_A5 a5_0;
+    Cycle_a_10020_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a10_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a10_0.a;
+    }
+}
+class Cycle_a_10020_A4 {
+    Cycle_a_10020_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_10020_A5 {
+    Cycle_a_10020_A6 a6_0;
+    Cycle_a_10020_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+class Cycle_a_10020_A6 {
+    Cycle_a_10020_A1 a1_0;
+    Cycle_a_10020_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_10020_A7 {
+    Cycle_a_10020_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_10020_A8 {
+    Cycle_a_10020_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_10020_A9 {
+    Cycle_a_10020_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A9(String strObjectName) {
+        a6_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_10020_A10 {
+    Cycle_a_10020_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_A10(String strObjectName) {
+        a9_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+class Cycle_a_10020_2A1 {
+    Cycle_a_10020_2A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_2A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_10020_2A2 {
+    Cycle_a_10020_2A1 a1_0;
+    Cycle_a_10020_2A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_2A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_10020_2A3 {
+    Cycle_a_10020_2A1 a1_0;
+    Cycle_a_10020_2A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_10020_2A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+public class Cycle_a_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_10020_A1 a1_main = new Cycle_a_10020_A1("a1_main");
+        Cycle_a_10020_A4 a4_main = new Cycle_a_10020_A4("a4_main");
+        Cycle_a_10020_A6 a6_main = new Cycle_a_10020_A6("a6_main");
+        Cycle_a_10020_A9 a9_main = new Cycle_a_10020_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_10020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10020_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10020_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_10020_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10020_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10020_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10020_2A1 a1_2main = new Cycle_a_10020_2A1("a1_2main");
+        a1_2main.a2_0 = new Cycle_a_10020_2A2("a2_0");
+        a1_2main.a2_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0 = new Cycle_a_10020_2A3("a3_0");
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a2_0 = a1_2main.a2_0;
+        a1_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        int result2 = a1_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+        if (result == (2623 + 815))
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0035-rc-function-Cycle_a_10020/expected.txt b/testsuite/java_test/rc_test/RC0035-rc-function-Cycle_a_10020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0035-rc-function-Cycle_a_10020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0035-rc-function-Cycle_a_10020/test.cfg b/testsuite/java_test/rc_test/RC0035-rc-function-Cycle_a_10020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fdd9d61ee4f0d05eb9cbcc97e4d91299d1d24cd5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0035-rc-function-Cycle_a_10020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_a_10020)
+run(Cycle_a_10020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0036-rc-function-Cycle_B_1_00010/Cycle_B_1_00010.java b/testsuite/java_test/rc_test/RC0036-rc-function-Cycle_B_1_00010/Cycle_B_1_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..77c7e99f3f1fe2c8f1b3d4b2d49b36afffd0f0aa
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0036-rc-function-Cycle_B_1_00010/Cycle_B_1_00010.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00010_A1 {
+    Cycle_B_1_00010_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00010_A1() {
+        a1_0 = null;
+        a = 123;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_1_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        if (nsum == 246)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0036-rc-function-Cycle_B_1_00010/expected.txt b/testsuite/java_test/rc_test/RC0036-rc-function-Cycle_B_1_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0036-rc-function-Cycle_B_1_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0036-rc-function-Cycle_B_1_00010/test.cfg b/testsuite/java_test/rc_test/RC0036-rc-function-Cycle_B_1_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..202956be4eec89efa24246dbd5cbe1251333a342
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0036-rc-function-Cycle_B_1_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00010)
+run(Cycle_B_1_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0037-rc-function-Cycle_B_1_00020/Cycle_B_1_00020.java b/testsuite/java_test/rc_test/RC0037-rc-function-Cycle_B_1_00020/Cycle_B_1_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..3a519ba361e2c52b83c3dfdc891b5ff08c96fe8a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0037-rc-function-Cycle_B_1_00020/Cycle_B_1_00020.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00020_A1 {
+    Cycle_B_1_00020_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00020_A2 {
+    Cycle_B_1_00020_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00020_A2() {
+        a1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_1_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00020_A1 a1_0 = new Cycle_B_1_00020_A1();
+        a1_0.a2_0 = new Cycle_B_1_00020_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        if (nsum == 6)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0037-rc-function-Cycle_B_1_00020/expected.txt b/testsuite/java_test/rc_test/RC0037-rc-function-Cycle_B_1_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0037-rc-function-Cycle_B_1_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0037-rc-function-Cycle_B_1_00020/test.cfg b/testsuite/java_test/rc_test/RC0037-rc-function-Cycle_B_1_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..33e27f9b65ddc6ad72f33be5e6f44e1389e89ba8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0037-rc-function-Cycle_B_1_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00020)
+run(Cycle_B_1_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0038-rc-function-Cycle_B_1_00030/Cycle_B_1_00030.java b/testsuite/java_test/rc_test/RC0038-rc-function-Cycle_B_1_00030/Cycle_B_1_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..4152fa480f85cf1a33866396260cdc3fc58f1700
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0038-rc-function-Cycle_B_1_00030/Cycle_B_1_00030.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00030_A1 {
+    Cycle_B_1_00030_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00030_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00030_A2 {
+    Cycle_B_1_00030_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00030_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00030_A3 {
+    Cycle_B_1_00030_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00030_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_1_00030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00030_A1 a1_0 = new Cycle_B_1_00030_A1();
+        a1_0.a2_0 = new Cycle_B_1_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00030_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        if (nsum == 12)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0038-rc-function-Cycle_B_1_00030/expected.txt b/testsuite/java_test/rc_test/RC0038-rc-function-Cycle_B_1_00030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0038-rc-function-Cycle_B_1_00030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0038-rc-function-Cycle_B_1_00030/test.cfg b/testsuite/java_test/rc_test/RC0038-rc-function-Cycle_B_1_00030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..33498e58e96a999f80927d727baad6b960480ae5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0038-rc-function-Cycle_B_1_00030/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00030)
+run(Cycle_B_1_00030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0039-rc-function-Cycle_B_1_00040/Cycle_B_1_00040.java b/testsuite/java_test/rc_test/RC0039-rc-function-Cycle_B_1_00040/Cycle_B_1_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..e955fecd5050d51caa09c9ec8fabdf1b72a252b6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0039-rc-function-Cycle_B_1_00040/Cycle_B_1_00040.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00040_A1 {
+    Cycle_B_1_00040_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00040_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00040_A2 {
+    Cycle_B_1_00040_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00040_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00040_A3 {
+    Cycle_B_1_00040_A1 a1_0;
+    Cycle_B_1_00040_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_1_00040_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00040_A4 {
+    int a;
+    int sum;
+    Cycle_B_1_00040_A4() {
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 5;
+    }
+}
+public class Cycle_B_1_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00040_A1 a1_0 = new Cycle_B_1_00040_A1();
+        a1_0.a2_0 = new Cycle_B_1_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00040_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00040_A4();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0039-rc-function-Cycle_B_1_00040/expected.txt b/testsuite/java_test/rc_test/RC0039-rc-function-Cycle_B_1_00040/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0039-rc-function-Cycle_B_1_00040/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0039-rc-function-Cycle_B_1_00040/test.cfg b/testsuite/java_test/rc_test/RC0039-rc-function-Cycle_B_1_00040/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..273046e41a2757392b26f31d8c6fe883e4d89512
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0039-rc-function-Cycle_B_1_00040/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00040)
+run(Cycle_B_1_00040,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0040-rc-function-Cycle_B_1_00050/Cycle_B_1_00050.java b/testsuite/java_test/rc_test/RC0040-rc-function-Cycle_B_1_00050/Cycle_B_1_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..3532ce6019041847c7a50fdafa6db1007564eeab
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0040-rc-function-Cycle_B_1_00050/Cycle_B_1_00050.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00050_A1 {
+    Cycle_B_1_00050_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00050_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00050_A2 {
+    Cycle_B_1_00050_A3 a3_0;
+    Cycle_B_1_00050_A4 a4_0;
+    Cycle_B_1_00050_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_1_00050_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00050_A3 {
+    Cycle_B_1_00050_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00050_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00050_A4 {
+    int a;
+    int sum;
+    Cycle_B_1_00050_A4() {
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 5;
+    }
+}
+class Cycle_B_1_00050_A5 {
+    int a;
+    int sum;
+    Cycle_B_1_00050_A5() {
+        a = 6;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 7;
+    }
+}
+public class Cycle_B_1_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00050_A1 a1_0 = new Cycle_B_1_00050_A1();
+        a1_0.a2_0 = new Cycle_B_1_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00050_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00050_A4();
+        a1_0.a2_0.a5_0 = new Cycle_B_1_00050_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 34)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0040-rc-function-Cycle_B_1_00050/expected.txt b/testsuite/java_test/rc_test/RC0040-rc-function-Cycle_B_1_00050/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0040-rc-function-Cycle_B_1_00050/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0040-rc-function-Cycle_B_1_00050/test.cfg b/testsuite/java_test/rc_test/RC0040-rc-function-Cycle_B_1_00050/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4dec13709b765e7a78e6b3d6725ec5b2bf700394
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0040-rc-function-Cycle_B_1_00050/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00050)
+run(Cycle_B_1_00050,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0041-rc-function-Cycle_B_1_00060/Cycle_B_1_00060.java b/testsuite/java_test/rc_test/RC0041-rc-function-Cycle_B_1_00060/Cycle_B_1_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..9071e0e5ee0dac72f29a405a09361398ed6f77ea
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0041-rc-function-Cycle_B_1_00060/Cycle_B_1_00060.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00060_A1 {
+    Cycle_B_1_00060_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00060_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00060_A2 {
+    Cycle_B_1_00060_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00060_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00060_A3 {
+    Cycle_B_1_00060_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00060_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00060_A4 {
+    Cycle_B_1_00060_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00060_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_B_1_00060 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00060_A1 a1_0 = new Cycle_B_1_00060_A1();
+        a1_0.a2_0 = new Cycle_B_1_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00060_A3();
+        Cycle_B_1_00060_A4 a4_0 = new Cycle_B_1_00060_A4();
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum;
+        if (nsum == 19)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0041-rc-function-Cycle_B_1_00060/expected.txt b/testsuite/java_test/rc_test/RC0041-rc-function-Cycle_B_1_00060/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0041-rc-function-Cycle_B_1_00060/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0041-rc-function-Cycle_B_1_00060/test.cfg b/testsuite/java_test/rc_test/RC0041-rc-function-Cycle_B_1_00060/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d792cad1a8fbd737d16baade8e23f0fa89d99396
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0041-rc-function-Cycle_B_1_00060/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00060)
+run(Cycle_B_1_00060,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0042-rc-function-Cycle_B_1_00070/Cycle_B_1_00070.java b/testsuite/java_test/rc_test/RC0042-rc-function-Cycle_B_1_00070/Cycle_B_1_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d875e99a1a4c6ca6729b462d9604490a5527cf7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0042-rc-function-Cycle_B_1_00070/Cycle_B_1_00070.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00070_A1 {
+    Cycle_B_1_00070_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00070_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00070_A2 {
+    Cycle_B_1_00070_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00070_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00070_A3 {
+    Cycle_B_1_00070_A1 a1_0;
+    Cycle_B_1_00070_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_1_00070_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00070_A4 {
+    int a;
+    int sum;
+    Cycle_B_1_00070_A4() {
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 5;
+    }
+}
+public class Cycle_B_1_00070 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00070_A1 a1_0 = new Cycle_B_1_00070_A1();
+        a1_0.a2_0 = new Cycle_B_1_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00070_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0042-rc-function-Cycle_B_1_00070/expected.txt b/testsuite/java_test/rc_test/RC0042-rc-function-Cycle_B_1_00070/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0042-rc-function-Cycle_B_1_00070/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0042-rc-function-Cycle_B_1_00070/test.cfg b/testsuite/java_test/rc_test/RC0042-rc-function-Cycle_B_1_00070/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ff64ca496c176ad35e054128a60808cb3a2642e2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0042-rc-function-Cycle_B_1_00070/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00070)
+run(Cycle_B_1_00070,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0043-rc-function-Cycle_B_1_00080/Cycle_B_1_00080.java b/testsuite/java_test/rc_test/RC0043-rc-function-Cycle_B_1_00080/Cycle_B_1_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..6989a0a3659ea189a37448e57cd950f54f3da1d7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0043-rc-function-Cycle_B_1_00080/Cycle_B_1_00080.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00080_A1 {
+    Cycle_B_1_00080_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00080_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00080_A2 {
+    Cycle_B_1_00080_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00080_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00080_A3 {
+    Cycle_B_1_00080_A1 a1_0;
+    Cycle_B_1_00080_A4 a4_0;
+    Cycle_B_1_00080_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_1_00080_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        a4_0.add();
+        a5_0.add();
+        sum = a + a1_0.a + a4_0.sum + a5_0.sum;
+    }
+}
+class Cycle_B_1_00080_A4 {
+    int a;
+    int sum;
+    Cycle_B_1_00080_A4() {
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 5;
+    }
+}
+class Cycle_B_1_00080_A5 {
+    int a;
+    int sum;
+    Cycle_B_1_00080_A5() {
+        a = 6;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 7;
+    }
+}
+public class Cycle_B_1_00080 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00080_A1 a1_0 = new Cycle_B_1_00080_A1();
+        a1_0.a2_0 = new Cycle_B_1_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00080_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00080_A4();
+        a1_0.a2_0.a3_0.a5_0 = new Cycle_B_1_00080_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 56)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0043-rc-function-Cycle_B_1_00080/expected.txt b/testsuite/java_test/rc_test/RC0043-rc-function-Cycle_B_1_00080/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0043-rc-function-Cycle_B_1_00080/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0043-rc-function-Cycle_B_1_00080/test.cfg b/testsuite/java_test/rc_test/RC0043-rc-function-Cycle_B_1_00080/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f9ed6983cb9abc9be15afcf0a30207cae3b80a07
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0043-rc-function-Cycle_B_1_00080/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00080)
+run(Cycle_B_1_00080,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0044-rc-function-Cycle_B_1_00090/Cycle_B_1_00090.java b/testsuite/java_test/rc_test/RC0044-rc-function-Cycle_B_1_00090/Cycle_B_1_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..d3757bae34d6533c69c715216749fd4e239a7c24
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0044-rc-function-Cycle_B_1_00090/Cycle_B_1_00090.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00090_A1 {
+    Cycle_B_1_00090_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00090_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00090_A2 {
+    Cycle_B_1_00090_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00090_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00090_A3 {
+    Cycle_B_1_00090_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00090_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00090_A4 {
+    Cycle_B_1_00090_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00090_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00090_A5 {
+    Cycle_B_1_00090_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00090_A5() {
+        a2_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_B_1_00090 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00090_A1 a1_0 = new Cycle_B_1_00090_A1();
+        a1_0.a2_0 = new Cycle_B_1_00090_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00090_A3();
+        Cycle_B_1_00090_A4 a4_0 = new Cycle_B_1_00090_A4();
+        Cycle_B_1_00090_A5 a5_0 = new Cycle_B_1_00090_A5();
+        a4_0.a2_0 = a1_0.a2_0;
+        a5_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 25)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0044-rc-function-Cycle_B_1_00090/expected.txt b/testsuite/java_test/rc_test/RC0044-rc-function-Cycle_B_1_00090/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0044-rc-function-Cycle_B_1_00090/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0044-rc-function-Cycle_B_1_00090/test.cfg b/testsuite/java_test/rc_test/RC0044-rc-function-Cycle_B_1_00090/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f03975b549663e85bfd65aed495f7f37542f1efb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0044-rc-function-Cycle_B_1_00090/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00090)
+run(Cycle_B_1_00090,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0045-rc-function-Cycle_B_1_00100/Cycle_B_1_00100.java b/testsuite/java_test/rc_test/RC0045-rc-function-Cycle_B_1_00100/Cycle_B_1_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..dc68a38f743b5e87e7847739ed24312deb77a665
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0045-rc-function-Cycle_B_1_00100/Cycle_B_1_00100.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00100_A1 {
+    Cycle_B_1_00100_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00100_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00100_A2 {
+    Cycle_B_1_00100_A3 a3_0;
+    Cycle_B_1_00100_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_1_00100_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00100_A3 {
+    Cycle_B_1_00100_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00100_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00100_A4 {
+    int a;
+    int sum;
+    Cycle_B_1_00100_A5 a5_0;
+    Cycle_B_1_00100_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        a5_0.add();
+        sum = a + a5_0.sum;
+    }
+}
+class Cycle_B_1_00100_A5 {
+    int a;
+    int sum;
+    Cycle_B_1_00100_A5() {
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 6;
+    }
+}
+public class Cycle_B_1_00100 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00100_A1 a1_0 = new Cycle_B_1_00100_A1();
+        a1_0.a2_0 = new Cycle_B_1_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00100_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00100_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_1_00100_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0045-rc-function-Cycle_B_1_00100/expected.txt b/testsuite/java_test/rc_test/RC0045-rc-function-Cycle_B_1_00100/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0045-rc-function-Cycle_B_1_00100/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0045-rc-function-Cycle_B_1_00100/test.cfg b/testsuite/java_test/rc_test/RC0045-rc-function-Cycle_B_1_00100/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..83444640dcf47614bde114ea22122aff339905ee
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0045-rc-function-Cycle_B_1_00100/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00100)
+run(Cycle_B_1_00100,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0046-rc-function-Cycle_B_1_00110/Cycle_B_1_00110.java b/testsuite/java_test/rc_test/RC0046-rc-function-Cycle_B_1_00110/Cycle_B_1_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..39c8f74042dc76d8b632a2729d500462fe07294a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0046-rc-function-Cycle_B_1_00110/Cycle_B_1_00110.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00110_A1 {
+    Cycle_B_1_00110_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00110_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00110_A2 {
+    Cycle_B_1_00110_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00110_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00110_A3 {
+    Cycle_B_1_00110_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00110_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00110_A4 {
+    Cycle_B_1_00110_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00110_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00110_A5 {
+    Cycle_B_1_00110_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_1_00110_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+public class Cycle_B_1_00110 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00110_A1 a1_0 = new Cycle_B_1_00110_A1();
+        a1_0.a2_0 = new Cycle_B_1_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00110_A3();
+        Cycle_B_1_00110_A5 a5_0 = new Cycle_B_1_00110_A5();
+        a5_0.a4_0 = new Cycle_B_1_00110_A4();
+        a5_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 27)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0046-rc-function-Cycle_B_1_00110/expected.txt b/testsuite/java_test/rc_test/RC0046-rc-function-Cycle_B_1_00110/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0046-rc-function-Cycle_B_1_00110/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0046-rc-function-Cycle_B_1_00110/test.cfg b/testsuite/java_test/rc_test/RC0046-rc-function-Cycle_B_1_00110/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..57345c4733a2ebccf7cf83d4deace2fdf668ec24
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0046-rc-function-Cycle_B_1_00110/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00110)
+run(Cycle_B_1_00110,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0047-rc-function-Cycle_B_1_00120/Cycle_B_1_00120.java b/testsuite/java_test/rc_test/RC0047-rc-function-Cycle_B_1_00120/Cycle_B_1_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..53621bef08d01b17942df7225e701dec4a1f90a7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0047-rc-function-Cycle_B_1_00120/Cycle_B_1_00120.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00120_A1 {
+    Cycle_B_1_00120_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00120_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00120_A2 {
+    Cycle_B_1_00120_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00120_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00120_A3 {
+    Cycle_B_1_00120_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00120_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00120_A4 {
+    Cycle_B_1_00120_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00120_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00120_A5 {
+    Cycle_B_1_00120_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_1_00120_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+public class Cycle_B_1_00120 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00120_A1 a1_0 = new Cycle_B_1_00120_A1();
+        a1_0.a2_0 = new Cycle_B_1_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00120_A3();
+        Cycle_B_1_00120_A5 a5_0 = new Cycle_B_1_00120_A5();
+        a5_0.a4_0 = new Cycle_B_1_00120_A4();
+        a5_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0047-rc-function-Cycle_B_1_00120/expected.txt b/testsuite/java_test/rc_test/RC0047-rc-function-Cycle_B_1_00120/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0047-rc-function-Cycle_B_1_00120/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0047-rc-function-Cycle_B_1_00120/test.cfg b/testsuite/java_test/rc_test/RC0047-rc-function-Cycle_B_1_00120/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..133e91c6869a638a48049b297c78a857a4b16731
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0047-rc-function-Cycle_B_1_00120/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00120)
+run(Cycle_B_1_00120,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0048-rc-function-Cycle_B_1_00130/Cycle_B_1_00130.java b/testsuite/java_test/rc_test/RC0048-rc-function-Cycle_B_1_00130/Cycle_B_1_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..bdf7e989d8fae26d4417d216152bf14261e5256d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0048-rc-function-Cycle_B_1_00130/Cycle_B_1_00130.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00130_A1 {
+    Cycle_B_1_00130_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00130_A1() {
+        a3_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00130_A2 {
+    Cycle_B_1_00130_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00130_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00130_A3 {
+    Cycle_B_1_00130_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00130_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_1_00130 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00130_A1 a1_0 = new Cycle_B_1_00130_A1();
+        Cycle_B_1_00130_A2 a2_0 = new Cycle_B_1_00130_A2();
+        Cycle_B_1_00130_A3 a3_0 = new Cycle_B_1_00130_A3();
+        a1_0.a3_0 = a3_0;
+        a2_0.a3_0 = a3_0;
+        a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0048-rc-function-Cycle_B_1_00130/expected.txt b/testsuite/java_test/rc_test/RC0048-rc-function-Cycle_B_1_00130/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0048-rc-function-Cycle_B_1_00130/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0048-rc-function-Cycle_B_1_00130/test.cfg b/testsuite/java_test/rc_test/RC0048-rc-function-Cycle_B_1_00130/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9b592fb1d8cb726c20b9ae606060517b6b80dc47
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0048-rc-function-Cycle_B_1_00130/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00130)
+run(Cycle_B_1_00130,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0049-rc-function-Cycle_B_1_00140/Cycle_B_1_00140.java b/testsuite/java_test/rc_test/RC0049-rc-function-Cycle_B_1_00140/Cycle_B_1_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..f980cf79abb238abf65338b6451c9c0f58911601
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0049-rc-function-Cycle_B_1_00140/Cycle_B_1_00140.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00140_A1 {
+    Cycle_B_1_00140_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00140_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00140_A2 {
+    Cycle_B_1_00140_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00140_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00140_A3 {
+    Cycle_B_1_00140_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00140_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00140_A4 {
+    Cycle_B_1_00140_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00140_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_B_1_00140 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00140_A1 a1_0 = new Cycle_B_1_00140_A1();
+        a1_0.a2_0 = new Cycle_B_1_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00140_A3();
+        Cycle_B_1_00140_A4 a4_0 = new Cycle_B_1_00140_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 12)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0049-rc-function-Cycle_B_1_00140/expected.txt b/testsuite/java_test/rc_test/RC0049-rc-function-Cycle_B_1_00140/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0049-rc-function-Cycle_B_1_00140/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0049-rc-function-Cycle_B_1_00140/test.cfg b/testsuite/java_test/rc_test/RC0049-rc-function-Cycle_B_1_00140/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eacd560823d79960f0c09492bf857f54f51ccb2a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0049-rc-function-Cycle_B_1_00140/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00140)
+run(Cycle_B_1_00140,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0050-rc-function-Cycle_B_1_00150/Cycle_B_1_00150.java b/testsuite/java_test/rc_test/RC0050-rc-function-Cycle_B_1_00150/Cycle_B_1_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..b65374b9be6455012b989ca2e2c423e3a68d7015
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0050-rc-function-Cycle_B_1_00150/Cycle_B_1_00150.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00150_A1 {
+    Cycle_B_1_00150_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00150_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00150_A2 {
+    Cycle_B_1_00150_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00150_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00150_A3 {
+    Cycle_B_1_00150_A1 a1_0;
+    Cycle_B_1_00150_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_1_00150_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00150_A4 {
+    int a;
+    int sum;
+    Cycle_B_1_00150_A5 a5_0;
+    Cycle_B_1_00150_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        a5_0.add();
+        sum = a + a5_0.sum;
+    }
+}
+class Cycle_B_1_00150_A5 {
+    int a;
+    int sum;
+    Cycle_B_1_00150_A5() {
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 6;
+    }
+}
+public class Cycle_B_1_00150 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00150_A1 a1_0 = new Cycle_B_1_00150_A1();
+        a1_0.a2_0 = new Cycle_B_1_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00150_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_1_00150_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0050-rc-function-Cycle_B_1_00150/expected.txt b/testsuite/java_test/rc_test/RC0050-rc-function-Cycle_B_1_00150/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0050-rc-function-Cycle_B_1_00150/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0050-rc-function-Cycle_B_1_00150/test.cfg b/testsuite/java_test/rc_test/RC0050-rc-function-Cycle_B_1_00150/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..074a0d2d28c3ba875ab9019c4d76e920962ae9d2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0050-rc-function-Cycle_B_1_00150/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00150)
+run(Cycle_B_1_00150,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0051-rc-function-Cycle_B_1_00160/Cycle_B_1_00160.java b/testsuite/java_test/rc_test/RC0051-rc-function-Cycle_B_1_00160/Cycle_B_1_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..c64705bc294490f917c7b10a76ad32ef34cbbcc6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0051-rc-function-Cycle_B_1_00160/Cycle_B_1_00160.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00160_A1 {
+    Cycle_B_1_00160_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00160_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00160_A2 {
+    Cycle_B_1_00160_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00160_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00160_A3 {
+    Cycle_B_1_00160_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00160_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00160_A4 {
+    Cycle_B_1_00160_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00160_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_1_00160 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00160_A1 a1_0 = new Cycle_B_1_00160_A1();
+        a1_0.a2_0 = new Cycle_B_1_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00160_A3();
+        Cycle_B_1_00160_A4 a4_0 = new Cycle_B_1_00160_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 17)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0051-rc-function-Cycle_B_1_00160/expected.txt b/testsuite/java_test/rc_test/RC0051-rc-function-Cycle_B_1_00160/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0051-rc-function-Cycle_B_1_00160/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0051-rc-function-Cycle_B_1_00160/test.cfg b/testsuite/java_test/rc_test/RC0051-rc-function-Cycle_B_1_00160/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a72491dec98889202ddf61bbcd11d7fda8a8591e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0051-rc-function-Cycle_B_1_00160/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00160)
+run(Cycle_B_1_00160,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0052-rc-function-Cycle_B_1_00170/Cycle_B_1_00170.java b/testsuite/java_test/rc_test/RC0052-rc-function-Cycle_B_1_00170/Cycle_B_1_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..ff151fb1d13b42adb11f4f610d3a7a3a275a0b15
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0052-rc-function-Cycle_B_1_00170/Cycle_B_1_00170.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00170_A1 {
+    Cycle_B_1_00170_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00170_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00170_A2 {
+    Cycle_B_1_00170_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00170_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00170_A3 {
+    Cycle_B_1_00170_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00170_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00170_A4 {
+    Cycle_B_1_00170_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00170_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00170_A5 {
+    Cycle_B_1_00170_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_1_00170_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+public class Cycle_B_1_00170 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00170_A1 a1_0 = new Cycle_B_1_00170_A1();
+        a1_0.a2_0 = new Cycle_B_1_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00170_A3();
+        Cycle_B_1_00170_A4 a4_0 = new Cycle_B_1_00170_A4();
+        Cycle_B_1_00170_A5 a5_0 = new Cycle_B_1_00170_A5();
+        a5_0.a4_0 = a4_0;
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 26)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0052-rc-function-Cycle_B_1_00170/expected.txt b/testsuite/java_test/rc_test/RC0052-rc-function-Cycle_B_1_00170/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0052-rc-function-Cycle_B_1_00170/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0052-rc-function-Cycle_B_1_00170/test.cfg b/testsuite/java_test/rc_test/RC0052-rc-function-Cycle_B_1_00170/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..855357f23bb43635e277052931eeb06368eeec2b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0052-rc-function-Cycle_B_1_00170/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00170)
+run(Cycle_B_1_00170,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0053-rc-function-Cycle_B_1_00180/Cycle_B_1_00180.java b/testsuite/java_test/rc_test/RC0053-rc-function-Cycle_B_1_00180/Cycle_B_1_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..e7adb12138eb8c87268d50e3a8a3d76d8446c75f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0053-rc-function-Cycle_B_1_00180/Cycle_B_1_00180.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00180_A1 {
+    Cycle_B_1_00180_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00180_A2 {
+    Cycle_B_1_00180_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00180_A3 {
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00180_A4 {
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00180_A5 {
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_1_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 23)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0053-rc-function-Cycle_B_1_00180/expected.txt b/testsuite/java_test/rc_test/RC0053-rc-function-Cycle_B_1_00180/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0053-rc-function-Cycle_B_1_00180/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0053-rc-function-Cycle_B_1_00180/test.cfg b/testsuite/java_test/rc_test/RC0053-rc-function-Cycle_B_1_00180/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f9bd9cb02d962e14f582d3d133b8e8409cb1ab87
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0053-rc-function-Cycle_B_1_00180/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00180)
+run(Cycle_B_1_00180,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0054-rc-function-Cycle_B_1_00190/Cycle_B_1_00190.java b/testsuite/java_test/rc_test/RC0054-rc-function-Cycle_B_1_00190/Cycle_B_1_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..094dcb37296c00547fc1365b07ea07303d8ec4c9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0054-rc-function-Cycle_B_1_00190/Cycle_B_1_00190.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00190_A1 {
+    Cycle_B_1_00190_A2 a2_0;
+    Cycle_B_1_00190_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_1_00190_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00190_A2 {
+    Cycle_B_1_00190_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00190_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00190_A3 {
+    Cycle_B_1_00190_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00190_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00190_A4 {
+    int a;
+    int sum;
+    Cycle_B_1_00190_A4() {
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 5;
+    }
+}
+public class Cycle_B_1_00190 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00190_A1 a1_0 = new Cycle_B_1_00190_A1();
+        a1_0.a2_0 = new Cycle_B_1_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00190_A3();
+        Cycle_B_1_00190_A4 a4_0 = new Cycle_B_1_00190_A4();
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0054-rc-function-Cycle_B_1_00190/expected.txt b/testsuite/java_test/rc_test/RC0054-rc-function-Cycle_B_1_00190/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0054-rc-function-Cycle_B_1_00190/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0054-rc-function-Cycle_B_1_00190/test.cfg b/testsuite/java_test/rc_test/RC0054-rc-function-Cycle_B_1_00190/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c60fa0ef84a9aa745b7113197454c8f5714dae7b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0054-rc-function-Cycle_B_1_00190/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00190)
+run(Cycle_B_1_00190,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0055-rc-function-Cycle_B_1_00200/Cycle_B_1_00200.java b/testsuite/java_test/rc_test/RC0055-rc-function-Cycle_B_1_00200/Cycle_B_1_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..1407fe1bd824d2ad0735d9c97227da02731bd402
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0055-rc-function-Cycle_B_1_00200/Cycle_B_1_00200.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_00200_A1 {
+    Cycle_B_1_00200_A2 a2_0;
+    Cycle_B_1_00200_A4 a4_0;
+    Cycle_B_1_00200_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_1_00200_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00200_A2 {
+    Cycle_B_1_00200_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00200_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00200_A3 {
+    Cycle_B_1_00200_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00200_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00200_A4 {
+    int a;
+    int sum;
+    Cycle_B_1_00200_A4() {
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 6;
+    }
+}
+class Cycle_B_1_00200_A5 {
+    int a;
+    int sum;
+    Cycle_B_1_00200_A5() {
+        a = 7;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 8;
+    }
+}
+public class Cycle_B_1_00200 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00200_A1 a1_0 = new Cycle_B_1_00200_A1();
+        a1_0.a2_0 = new Cycle_B_1_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00200_A3();
+        Cycle_B_1_00200_A4 a4_0 = new Cycle_B_1_00200_A4();
+        Cycle_B_1_00200_A5 a5_0 = new Cycle_B_1_00200_A5();
+        a1_0.a4_0 = a4_0;
+        a1_0.a5_0 = a5_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 38)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0055-rc-function-Cycle_B_1_00200/expected.txt b/testsuite/java_test/rc_test/RC0055-rc-function-Cycle_B_1_00200/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0055-rc-function-Cycle_B_1_00200/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0055-rc-function-Cycle_B_1_00200/test.cfg b/testsuite/java_test/rc_test/RC0055-rc-function-Cycle_B_1_00200/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa6a3d9fa37cd71d25f49a894df2eab4bfba4de0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0055-rc-function-Cycle_B_1_00200/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_00200)
+run(Cycle_B_1_00200,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0056-rc-function-Cycle_B_1_10010/Cycle_B_1_10010.java b/testsuite/java_test/rc_test/RC0056-rc-function-Cycle_B_1_10010/Cycle_B_1_10010.java
new file mode 100755
index 0000000000000000000000000000000000000000..2b9285ba76c0963dcaf3b82b57ace35df5dead66
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0056-rc-function-Cycle_B_1_10010/Cycle_B_1_10010.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_10010_A1 {
+    Cycle_B_1_10010_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_10010_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_10010_A2 {
+    Cycle_B_1_10010_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_10010_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_10010_A3 {
+    Cycle_B_1_10010_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_10010_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_10010_2A1 {
+    Cycle_B_1_10010_2A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_10010_2A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_10010_2A2 {
+    Cycle_B_1_10010_2A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_10010_2A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_10010_2A3 {
+    Cycle_B_1_10010_2A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_10010_2A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_1_10010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_10010_A1 a1_0 = new Cycle_B_1_10010_A1();
+        a1_0.a2_0 = new Cycle_B_1_10010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10010_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        Cycle_B_1_10010_2A1 a1_10 = new Cycle_B_1_10010_2A1();
+        a1_10.a2_0 = new Cycle_B_1_10010_2A2();
+        a1_10.a2_0.a3_0 = new Cycle_B_1_10010_2A3();
+        a1_10.a2_0.a3_0.a1_0 = a1_10;
+        a1_10.add();
+        a1_10.a2_0.add();
+        a1_10.a2_0.a3_0.add();
+        int nsum2 = (a1_10.sum + a1_10.a2_0.sum + a1_10.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        nsum += nsum2;
+        if (nsum == 24)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0056-rc-function-Cycle_B_1_10010/expected.txt b/testsuite/java_test/rc_test/RC0056-rc-function-Cycle_B_1_10010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0056-rc-function-Cycle_B_1_10010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0056-rc-function-Cycle_B_1_10010/test.cfg b/testsuite/java_test/rc_test/RC0056-rc-function-Cycle_B_1_10010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8bcf101c59f5c0c0c4a0e956b99ea4bb3cf6bd0f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0056-rc-function-Cycle_B_1_10010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_10010)
+run(Cycle_B_1_10010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0057-rc-function-Cycle_B_1_10020/Cycle_B_1_10020.java b/testsuite/java_test/rc_test/RC0057-rc-function-Cycle_B_1_10020/Cycle_B_1_10020.java
new file mode 100755
index 0000000000000000000000000000000000000000..e618c0b6681b2ea9fdba8f4059cf9ecd691df720
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0057-rc-function-Cycle_B_1_10020/Cycle_B_1_10020.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_1_10020_A1 {
+    Cycle_B_1_10020_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_10020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_10020_A2 {
+    Cycle_B_1_10020_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_10020_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_10020_A3 {
+    Cycle_B_1_10020_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_10020_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_10020_A4 {
+    Cycle_B_1_10020_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_10020_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_10020_A5 {
+    Cycle_B_1_10020_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_10020_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_10020_2A1 {
+    Cycle_B_1_10020_2A2 a2_0;
+    Cycle_B_1_10020_2A4 a4_0;
+    Cycle_B_1_10020_2A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_1_10020_2A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_10020_2A2 {
+    Cycle_B_1_10020_2A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_10020_2A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_10020_2A3 {
+    Cycle_B_1_10020_2A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_10020_2A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_10020_2A4 {
+    int a;
+    int sum;
+    Cycle_B_1_10020_2A4() {
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 6;
+    }
+}
+class Cycle_B_1_10020_2A5 {
+    int a;
+    int sum;
+    Cycle_B_1_10020_2A5() {
+        a = 7;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 8;
+    }
+}
+public class Cycle_B_1_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_10020_A1 a1_0 = new Cycle_B_1_10020_A1();
+        a1_0.a2_0 = new Cycle_B_1_10020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10020_A3();
+        Cycle_B_1_10020_A4 a4_0 = new Cycle_B_1_10020_A4();
+        Cycle_B_1_10020_A5 a5_0 = new Cycle_B_1_10020_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        Cycle_B_1_10020_2A1 a1_20 = new Cycle_B_1_10020_2A1();
+        a1_20.a2_0 = new Cycle_B_1_10020_2A2();
+        a1_20.a2_0.a3_0 = new Cycle_B_1_10020_2A3();
+        Cycle_B_1_10020_2A4 a4_20 = new Cycle_B_1_10020_2A4();
+        Cycle_B_1_10020_2A5 a5_20 = new Cycle_B_1_10020_2A5();
+        a1_20.a4_0 = a4_20;
+        a1_20.a5_0 = a5_20;
+        a1_20.a2_0.a3_0.a1_0 = a1_20;
+        a1_20.add();
+        a1_20.a2_0.add();
+        a1_20.a2_0.a3_0.add();
+        a4_20.add();
+        a5_20.add();
+        int nsum1 = (a1_20.sum + a1_20.a2_0.sum + a1_20.a2_0.a3_0.sum + a4_20.sum + a5_20.sum);
+        nsum += nsum1;
+        if (nsum == 61)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0057-rc-function-Cycle_B_1_10020/expected.txt b/testsuite/java_test/rc_test/RC0057-rc-function-Cycle_B_1_10020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0057-rc-function-Cycle_B_1_10020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0057-rc-function-Cycle_B_1_10020/test.cfg b/testsuite/java_test/rc_test/RC0057-rc-function-Cycle_B_1_10020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a1cb0c5cd5ac2934c6dab1748d2bc6a43dec82b3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0057-rc-function-Cycle_B_1_10020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_1_10020)
+run(Cycle_B_1_10020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0058-rc-function-Cycle_B_2_00010/Cycle_B_2_00010.java b/testsuite/java_test/rc_test/RC0058-rc-function-Cycle_B_2_00010/Cycle_B_2_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..bb3ada7d270dfe43abdb61bdf2ce07973d72ce31
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0058-rc-function-Cycle_B_2_00010/Cycle_B_2_00010.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00010_A1 {
+    Cycle_B_2_00010_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00010_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00010_A2 {
+    Cycle_B_2_00010_A3 a3_0;
+    Cycle_B_2_00010_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00010_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00010_A3 {
+    Cycle_B_2_00010_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00010_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00010_A4 {
+    Cycle_B_2_00010_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00010_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_B_2_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00010_A1 a1_0 = new Cycle_B_2_00010_A1();
+        a1_0.a2_0 = new Cycle_B_2_00010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00010_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00010_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 18)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0058-rc-function-Cycle_B_2_00010/expected.txt b/testsuite/java_test/rc_test/RC0058-rc-function-Cycle_B_2_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0058-rc-function-Cycle_B_2_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0058-rc-function-Cycle_B_2_00010/test.cfg b/testsuite/java_test/rc_test/RC0058-rc-function-Cycle_B_2_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..32a92232260d9516fe8dc3e48cb432ef5320d97f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0058-rc-function-Cycle_B_2_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00010)
+run(Cycle_B_2_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0059-rc-function-Cycle_B_2_00020/Cycle_B_2_00020.java b/testsuite/java_test/rc_test/RC0059-rc-function-Cycle_B_2_00020/Cycle_B_2_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..1259a3911cdb3321d31dcf583e9a94453d93f49f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0059-rc-function-Cycle_B_2_00020/Cycle_B_2_00020.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00020_A1 {
+    Cycle_B_2_00020_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00020_A2 {
+    Cycle_B_2_00020_A3 a3_0;
+    Cycle_B_2_00020_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00020_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00020_A3 {
+    Cycle_B_2_00020_A1 a1_0;
+    Cycle_B_2_00020_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00020_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00020_A4 {
+    Cycle_B_2_00020_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00020_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_B_2_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00020_A1 a1_0 = new Cycle_B_2_00020_A1();
+        a1_0.a2_0 = new Cycle_B_2_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00020_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00020_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0059-rc-function-Cycle_B_2_00020/expected.txt b/testsuite/java_test/rc_test/RC0059-rc-function-Cycle_B_2_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0059-rc-function-Cycle_B_2_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0059-rc-function-Cycle_B_2_00020/test.cfg b/testsuite/java_test/rc_test/RC0059-rc-function-Cycle_B_2_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..95c0535b54861a209ca69bd7da7e4afe22af4a72
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0059-rc-function-Cycle_B_2_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00020)
+run(Cycle_B_2_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0060-rc-function-Cycle_B_2_00030/Cycle_B_2_00030.java b/testsuite/java_test/rc_test/RC0060-rc-function-Cycle_B_2_00030/Cycle_B_2_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..2ce41586eaa248edacbe9def3ecc3fe68ae325b7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0060-rc-function-Cycle_B_2_00030/Cycle_B_2_00030.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00030_A1 {
+    Cycle_B_2_00030_A2 a2_0;
+    Cycle_B_2_00030_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00030_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00030_A2 {
+    Cycle_B_2_00030_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00030_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00030_A3 {
+    Cycle_B_2_00030_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00030_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00030_A4 {
+    Cycle_B_2_00030_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00030_A4() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_2_00030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00030_A1 a1_0 = new Cycle_B_2_00030_A1();
+        a1_0.a2_0 = new Cycle_B_2_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00030_A3();
+        Cycle_B_2_00030_A4 a4_0 = new Cycle_B_2_00030_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0060-rc-function-Cycle_B_2_00030/expected.txt b/testsuite/java_test/rc_test/RC0060-rc-function-Cycle_B_2_00030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0060-rc-function-Cycle_B_2_00030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0060-rc-function-Cycle_B_2_00030/test.cfg b/testsuite/java_test/rc_test/RC0060-rc-function-Cycle_B_2_00030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f20d3fe3ad0eecef5076d51210f09c4d6246dfb8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0060-rc-function-Cycle_B_2_00030/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00030)
+run(Cycle_B_2_00030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0061-rc-function-Cycle_B_2_00040/Cycle_B_2_00040.java b/testsuite/java_test/rc_test/RC0061-rc-function-Cycle_B_2_00040/Cycle_B_2_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..ced1bfb99da903dadb9ff1df0c9488e375cf5b4c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0061-rc-function-Cycle_B_2_00040/Cycle_B_2_00040.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00040_A1 {
+    Cycle_B_2_00040_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00040_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00040_A2 {
+    Cycle_B_2_00040_A3 a3_0;
+    Cycle_B_2_00040_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00040_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00040_A3 {
+    Cycle_B_2_00040_A1 a1_0;
+    Cycle_B_2_00040_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00040_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00040_A4 {
+    Cycle_B_2_00040_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00040_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_B_2_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00040_A1 a1_0 = new Cycle_B_2_00040_A1();
+        a1_0.a2_0 = new Cycle_B_2_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00040_A3();
+        Cycle_B_2_00040_A4 a4_0 = new Cycle_B_2_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0061-rc-function-Cycle_B_2_00040/expected.txt b/testsuite/java_test/rc_test/RC0061-rc-function-Cycle_B_2_00040/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0061-rc-function-Cycle_B_2_00040/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0061-rc-function-Cycle_B_2_00040/test.cfg b/testsuite/java_test/rc_test/RC0061-rc-function-Cycle_B_2_00040/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6152c24e086a83e45b996157c8c06fbfbc05d906
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0061-rc-function-Cycle_B_2_00040/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00040)
+run(Cycle_B_2_00040,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0062-rc-function-Cycle_B_2_00050/Cycle_B_2_00050.java b/testsuite/java_test/rc_test/RC0062-rc-function-Cycle_B_2_00050/Cycle_B_2_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..8fa0b1b7ded2d32ee00931d00ec79031dd31854b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0062-rc-function-Cycle_B_2_00050/Cycle_B_2_00050.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00050_A1 {
+    Cycle_B_2_00050_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00050_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00050_A2 {
+    Cycle_B_2_00050_A3 a3_0;
+    Cycle_B_2_00050_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00050_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00050_A3 {
+    Cycle_B_2_00050_A1 a1_0;
+    Cycle_B_2_00050_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00050_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00050_A4 {
+    Cycle_B_2_00050_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00050_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00050_A5 {
+    Cycle_B_2_00050_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00050_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+public class Cycle_B_2_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00050_A1 a1_0 = new Cycle_B_2_00050_A1();
+        a1_0.a2_0 = new Cycle_B_2_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00050_A3();
+        Cycle_B_2_00050_A4 a4_0 = new Cycle_B_2_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00050_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0062-rc-function-Cycle_B_2_00050/expected.txt b/testsuite/java_test/rc_test/RC0062-rc-function-Cycle_B_2_00050/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0062-rc-function-Cycle_B_2_00050/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0062-rc-function-Cycle_B_2_00050/test.cfg b/testsuite/java_test/rc_test/RC0062-rc-function-Cycle_B_2_00050/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2684596b71d62337db9db8f211a6e6611828ed86
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0062-rc-function-Cycle_B_2_00050/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00050)
+run(Cycle_B_2_00050,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0063-rc-function-Cycle_B_2_00060/Cycle_B_2_00060.java b/testsuite/java_test/rc_test/RC0063-rc-function-Cycle_B_2_00060/Cycle_B_2_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..ad3021351e7ff48ed41479895b584226bb4711b3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0063-rc-function-Cycle_B_2_00060/Cycle_B_2_00060.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00060_A1 {
+    Cycle_B_2_00060_A2 a2_0;
+    Cycle_B_2_00060_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00060_A1() {
+        a2_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00060_A2 {
+    Cycle_B_2_00060_A3 a3_0;
+    Cycle_B_2_00060_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00060_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00060_A3 {
+    Cycle_B_2_00060_A1 a1_0;
+    Cycle_B_2_00060_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00060_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00060_A4 {
+    Cycle_B_2_00060_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00060_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00060_A5 {
+    Cycle_B_2_00060_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00060_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+public class Cycle_B_2_00060 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00060_A1 a1_0 = new Cycle_B_2_00060_A1();
+        a1_0.a2_0 = new Cycle_B_2_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00060_A3();
+        Cycle_B_2_00060_A4 a4_0 = new Cycle_B_2_00060_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00060_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0063-rc-function-Cycle_B_2_00060/expected.txt b/testsuite/java_test/rc_test/RC0063-rc-function-Cycle_B_2_00060/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0063-rc-function-Cycle_B_2_00060/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0063-rc-function-Cycle_B_2_00060/test.cfg b/testsuite/java_test/rc_test/RC0063-rc-function-Cycle_B_2_00060/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2df6e56f1881c43beaaec603e4cbd148d8c4803a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0063-rc-function-Cycle_B_2_00060/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00060)
+run(Cycle_B_2_00060,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0064-rc-function-Cycle_B_2_00070/Cycle_B_2_00070.java b/testsuite/java_test/rc_test/RC0064-rc-function-Cycle_B_2_00070/Cycle_B_2_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..8854c70946115549ddc87c4d95ab0032002e0115
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0064-rc-function-Cycle_B_2_00070/Cycle_B_2_00070.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00070_A1 {
+    Cycle_B_2_00070_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00070_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00070_A2 {
+    Cycle_B_2_00070_A3 a3_0;
+    Cycle_B_2_00070_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00070_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00070_A3 {
+    Cycle_B_2_00070_A1 a1_0;
+    Cycle_B_2_00070_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00070_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00070_A4 {
+    Cycle_B_2_00070_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00070_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00070_A5 {
+    Cycle_B_2_00070_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00070_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_B_2_00070_A6 {
+    Cycle_B_2_00070_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00070_A6() {
+        a3_0 = null;
+        a = 6;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_B_2_00070 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00070_A1 a1_0 = new Cycle_B_2_00070_A1();
+        a1_0.a2_0 = new Cycle_B_2_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00070_A3();
+        Cycle_B_2_00070_A4 a4_0 = new Cycle_B_2_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00070_A5();
+        Cycle_B_2_00070_A6 a6_0 = new Cycle_B_2_00070_A6();
+        a6_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a6_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum + a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 37)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0064-rc-function-Cycle_B_2_00070/expected.txt b/testsuite/java_test/rc_test/RC0064-rc-function-Cycle_B_2_00070/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0064-rc-function-Cycle_B_2_00070/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0064-rc-function-Cycle_B_2_00070/test.cfg b/testsuite/java_test/rc_test/RC0064-rc-function-Cycle_B_2_00070/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6dbcf1142e5ed56d677e82e7938243d849e2a227
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0064-rc-function-Cycle_B_2_00070/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00070)
+run(Cycle_B_2_00070,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0065-rc-function-Cycle_B_2_00080/Cycle_B_2_00080.java b/testsuite/java_test/rc_test/RC0065-rc-function-Cycle_B_2_00080/Cycle_B_2_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..f5c84429a6cbdd31139db3057dbd05d0a8d1490b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0065-rc-function-Cycle_B_2_00080/Cycle_B_2_00080.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00080_A1 {
+    Cycle_B_2_00080_A2 a2_0;
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A1() {
+        a2_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00080_A2 {
+    Cycle_B_2_00080_A3 a3_0;
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00080_A3 {
+    Cycle_B_2_00080_A1 a1_0;
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00080_A4 {
+    Cycle_B_2_00080_A3 a3_0;
+    Cycle_B_2_00080_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A4() {
+        a3_0 = null;
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00080_A5 {
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+public class Cycle_B_2_00080 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0065-rc-function-Cycle_B_2_00080/expected.txt b/testsuite/java_test/rc_test/RC0065-rc-function-Cycle_B_2_00080/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0065-rc-function-Cycle_B_2_00080/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0065-rc-function-Cycle_B_2_00080/test.cfg b/testsuite/java_test/rc_test/RC0065-rc-function-Cycle_B_2_00080/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fa36055c2ca8a399ca534e4cdfe5bdedcc80eb44
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0065-rc-function-Cycle_B_2_00080/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00080)
+run(Cycle_B_2_00080,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0066-rc-function-Cycle_B_2_00090/Cycle_B_2_00090.java b/testsuite/java_test/rc_test/RC0066-rc-function-Cycle_B_2_00090/Cycle_B_2_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..2d64cea277ac5ad11ef23e5781a8f366932b4440
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0066-rc-function-Cycle_B_2_00090/Cycle_B_2_00090.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00090_A1 {
+    Cycle_B_2_00090_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00090_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00090_A2 {
+    Cycle_B_2_00090_A1 a1_0;
+    Cycle_B_2_00090_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00090_A2() {
+        a1_0 = null;
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00090_A3 {
+    Cycle_B_2_00090_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00090_A3() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_B_2_00090 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00090_A1 a1_0 = new Cycle_B_2_00090_A1();
+        Cycle_B_2_00090_A3 a3_0 = new Cycle_B_2_00090_A3();
+        a1_0.a2_0 = new Cycle_B_2_00090_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a3_0.a2_0 = a1_0.a2_0;
+        a3_0.a2_0.a3_0 = a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 9)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0066-rc-function-Cycle_B_2_00090/expected.txt b/testsuite/java_test/rc_test/RC0066-rc-function-Cycle_B_2_00090/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0066-rc-function-Cycle_B_2_00090/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0066-rc-function-Cycle_B_2_00090/test.cfg b/testsuite/java_test/rc_test/RC0066-rc-function-Cycle_B_2_00090/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..593b01a74be264eb40b3d25c9b67cc3956bdb15b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0066-rc-function-Cycle_B_2_00090/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00090)
+run(Cycle_B_2_00090,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0067-rc-function-Cycle_B_2_00100/Cycle_B_2_00100.java b/testsuite/java_test/rc_test/RC0067-rc-function-Cycle_B_2_00100/Cycle_B_2_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..e294740c102074d9067ab7753b2d54a654c8ec42
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0067-rc-function-Cycle_B_2_00100/Cycle_B_2_00100.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00100_A1 {
+    Cycle_B_2_00100_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00100_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00100_A2 {
+    Cycle_B_2_00100_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00100_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00100_A3 {
+    Cycle_B_2_00100_A1 a1_0;
+    Cycle_B_2_00100_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00100_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00100_A4 {
+    Cycle_B_2_00100_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00100_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_B_2_00100_A5 {
+    Cycle_B_2_00100_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00100_A5() {
+        a3_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_B_2_00100 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00100_A1 a1_0 = new Cycle_B_2_00100_A1();
+        a1_0.a2_0 = new Cycle_B_2_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00100_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00100_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00100_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 29)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0067-rc-function-Cycle_B_2_00100/expected.txt b/testsuite/java_test/rc_test/RC0067-rc-function-Cycle_B_2_00100/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0067-rc-function-Cycle_B_2_00100/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0067-rc-function-Cycle_B_2_00100/test.cfg b/testsuite/java_test/rc_test/RC0067-rc-function-Cycle_B_2_00100/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5148e018bf5c40adf88de4602c819cb9e45fe932
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0067-rc-function-Cycle_B_2_00100/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00100)
+run(Cycle_B_2_00100,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0068-rc-function-Cycle_B_2_00110/Cycle_B_2_00110.java b/testsuite/java_test/rc_test/RC0068-rc-function-Cycle_B_2_00110/Cycle_B_2_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..8888881255bff67fe322e4093660945b76bd45e7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0068-rc-function-Cycle_B_2_00110/Cycle_B_2_00110.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00110_A1 {
+    Cycle_B_2_00110_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00110_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00110_A2 {
+    Cycle_B_2_00110_A3 a3_0;
+    Cycle_B_2_00110_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00110_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00110_A3 {
+    Cycle_B_2_00110_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00110_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00110_A4 {
+    Cycle_B_2_00110_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00110_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_B_2_00110_A5 {
+    Cycle_B_2_00110_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00110_A5() {
+        a2_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_B_2_00110 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00110_A1 a1_0 = new Cycle_B_2_00110_A1();
+        a1_0.a2_0 = new Cycle_B_2_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00110_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00110_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_2_00110_A5();
+        a1_0.a2_0.a4_0.a5_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0068-rc-function-Cycle_B_2_00110/expected.txt b/testsuite/java_test/rc_test/RC0068-rc-function-Cycle_B_2_00110/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0068-rc-function-Cycle_B_2_00110/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0068-rc-function-Cycle_B_2_00110/test.cfg b/testsuite/java_test/rc_test/RC0068-rc-function-Cycle_B_2_00110/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eab1c61c9e224eee4bb9b1cddd921de34d46de65
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0068-rc-function-Cycle_B_2_00110/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00110)
+run(Cycle_B_2_00110,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0069-rc-function-Cycle_B_2_00120/Cycle_B_2_00120.java b/testsuite/java_test/rc_test/RC0069-rc-function-Cycle_B_2_00120/Cycle_B_2_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..4391fb9eacca378685799efb50285296e97537be
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0069-rc-function-Cycle_B_2_00120/Cycle_B_2_00120.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00120_A1 {
+    Cycle_B_2_00120_A2 a2_0;
+    Cycle_B_2_00120_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00120_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00120_A2 {
+    Cycle_B_2_00120_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00120_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00120_A3 {
+    Cycle_B_2_00120_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00120_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00120_A4 {
+    Cycle_B_2_00120_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00120_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_B_2_00120_A5 {
+    Cycle_B_2_00120_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00120_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_2_00120 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00120_A1 a1_0 = new Cycle_B_2_00120_A1();
+        a1_0.a2_0 = new Cycle_B_2_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00120_A3();
+        a1_0.a4_0 = new Cycle_B_2_00120_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a4_0.a5_0 = new Cycle_B_2_00120_A5();
+        a1_0.a4_0.a5_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a4_0.add();
+        a1_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a4_0.sum + a1_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 27)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0069-rc-function-Cycle_B_2_00120/expected.txt b/testsuite/java_test/rc_test/RC0069-rc-function-Cycle_B_2_00120/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0069-rc-function-Cycle_B_2_00120/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0069-rc-function-Cycle_B_2_00120/test.cfg b/testsuite/java_test/rc_test/RC0069-rc-function-Cycle_B_2_00120/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc0d7943d081843a83321a68cd4c054320a9af7b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0069-rc-function-Cycle_B_2_00120/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00120)
+run(Cycle_B_2_00120,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0070-rc-function-Cycle_B_2_00130/Cycle_B_2_00130.java b/testsuite/java_test/rc_test/RC0070-rc-function-Cycle_B_2_00130/Cycle_B_2_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..d25d07f0f28185d7e4c6be366e01e3bf0eba0eb6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0070-rc-function-Cycle_B_2_00130/Cycle_B_2_00130.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00130_A1 {
+    Cycle_B_2_00130_A2 a2_0;
+    Cycle_B_2_00130_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00130_A1() {
+        a2_0 = null;
+        a4_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00130_A2 {
+    Cycle_B_2_00130_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00130_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00130_A3 {
+    Cycle_B_2_00130_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00130_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_B_2_00130_A4 {
+    Cycle_B_2_00130_A1 a1_0;
+    Cycle_B_2_00130_A6 a6_0;
+    int a;
+    int sum;
+    Cycle_B_2_00130_A4() {
+        a1_0 = null;
+        a6_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+class Cycle_B_2_00130_A5 {
+    Cycle_B_2_00130_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00130_A5() {
+        a3_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00130_A6 {
+    Cycle_B_2_00130_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00130_A6() {
+        a5_0 = null;
+        a = 6;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+public class Cycle_B_2_00130 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00130_A1 a1_0 = new Cycle_B_2_00130_A1();
+        a1_0.a2_0 = new Cycle_B_2_00130_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00130_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00130_A4();
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        Cycle_B_2_00130_A5 a5_0 = new Cycle_B_2_00130_A5();
+        a1_0.a2_0.a3_0.a4_0.a6_0 = new Cycle_B_2_00130_A6();
+        a1_0.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_0;
+        a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a6_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a5_0.sum + a1_0.a2_0.a3_0.a4_0.a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 45)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0070-rc-function-Cycle_B_2_00130/expected.txt b/testsuite/java_test/rc_test/RC0070-rc-function-Cycle_B_2_00130/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0070-rc-function-Cycle_B_2_00130/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0070-rc-function-Cycle_B_2_00130/test.cfg b/testsuite/java_test/rc_test/RC0070-rc-function-Cycle_B_2_00130/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c65dccfb8329d5a0ece0cf5bd5926e1e37ce0f6a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0070-rc-function-Cycle_B_2_00130/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00130)
+run(Cycle_B_2_00130,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0071-rc-function-Cycle_B_2_00140/Cycle_B_2_00140.java b/testsuite/java_test/rc_test/RC0071-rc-function-Cycle_B_2_00140/Cycle_B_2_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..835ed89c5b9227af15a2fd299b1fa81bd70250d1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0071-rc-function-Cycle_B_2_00140/Cycle_B_2_00140.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00140_A1 {
+    Cycle_B_2_00140_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00140_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00140_A2 {
+    Cycle_B_2_00140_A3 a3_0;
+    Cycle_B_2_00140_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00140_A2() {
+        a3_0 = null;
+        a1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a + a1_0.a;
+    }
+}
+class Cycle_B_2_00140_A3 {
+    Cycle_B_2_00140_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00140_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_2_00140 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00140_A1 a1_0 = new Cycle_B_2_00140_A1();
+        a1_0.a2_0 = new Cycle_B_2_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00140_A3();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0071-rc-function-Cycle_B_2_00140/expected.txt b/testsuite/java_test/rc_test/RC0071-rc-function-Cycle_B_2_00140/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0071-rc-function-Cycle_B_2_00140/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0071-rc-function-Cycle_B_2_00140/test.cfg b/testsuite/java_test/rc_test/RC0071-rc-function-Cycle_B_2_00140/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4fe063efa0aa102d4e11dd7946c59eb0091a73e6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0071-rc-function-Cycle_B_2_00140/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00140)
+run(Cycle_B_2_00140,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0072-rc-function-Cycle_B_2_00150/Cycle_B_2_00150.java b/testsuite/java_test/rc_test/RC0072-rc-function-Cycle_B_2_00150/Cycle_B_2_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..97b5cce38a2a4f75aeb0c90961e0e549ced2a9f1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0072-rc-function-Cycle_B_2_00150/Cycle_B_2_00150.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00150_A1 {
+    Cycle_B_2_00150_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00150_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00150_A2 {
+    Cycle_B_2_00150_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00150_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00150_A3 {
+    Cycle_B_2_00150_A1 a1_0;
+    Cycle_B_2_00150_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00150_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+public class Cycle_B_2_00150 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00150_A1 a1_0 = new Cycle_B_2_00150_A1();
+        a1_0.a2_0 = new Cycle_B_2_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 14)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0072-rc-function-Cycle_B_2_00150/expected.txt b/testsuite/java_test/rc_test/RC0072-rc-function-Cycle_B_2_00150/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0072-rc-function-Cycle_B_2_00150/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0072-rc-function-Cycle_B_2_00150/test.cfg b/testsuite/java_test/rc_test/RC0072-rc-function-Cycle_B_2_00150/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e1cbfe4a772c031374291cd95fa5d8ed1cb2e074
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0072-rc-function-Cycle_B_2_00150/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00150)
+run(Cycle_B_2_00150,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0073-rc-function-Cycle_B_2_00160/Cycle_B_2_00160.java b/testsuite/java_test/rc_test/RC0073-rc-function-Cycle_B_2_00160/Cycle_B_2_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..773cc47b2274806530742c3dbd4245938a5f4ccc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0073-rc-function-Cycle_B_2_00160/Cycle_B_2_00160.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00160_A1 {
+    Cycle_B_2_00160_A2 a2_0;
+    Cycle_B_2_00160_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00160_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+class Cycle_B_2_00160_A2 {
+    Cycle_B_2_00160_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00160_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00160_A3 {
+    Cycle_B_2_00160_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00160_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_2_00160 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00160_A1 a1_0 = new Cycle_B_2_00160_A1();
+        a1_0.a2_0 = new Cycle_B_2_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00160_A3();
+        a1_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0073-rc-function-Cycle_B_2_00160/expected.txt b/testsuite/java_test/rc_test/RC0073-rc-function-Cycle_B_2_00160/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0073-rc-function-Cycle_B_2_00160/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0073-rc-function-Cycle_B_2_00160/test.cfg b/testsuite/java_test/rc_test/RC0073-rc-function-Cycle_B_2_00160/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f506a7cb0bc4c2bab6e04e97e918811b4b42f2ff
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0073-rc-function-Cycle_B_2_00160/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00160)
+run(Cycle_B_2_00160,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0074-rc-function-Cycle_B_2_00170/Cycle_B_2_00170.java b/testsuite/java_test/rc_test/RC0074-rc-function-Cycle_B_2_00170/Cycle_B_2_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..76b8ae3a103fc4391c18a3bd09290c238033a598
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0074-rc-function-Cycle_B_2_00170/Cycle_B_2_00170.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00170_A1 {
+    Cycle_B_2_00170_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00170_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00170_A2 {
+    Cycle_B_2_00170_A3 a3_0;
+    Cycle_B_2_00170_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00170_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_B_2_00170_A3 {
+    Cycle_B_2_00170_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00170_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00170_A4 {
+    Cycle_B_2_00170_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00170_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_2_00170 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00170_A1 a1_0 = new Cycle_B_2_00170_A1();
+        a1_0.a2_0 = new Cycle_B_2_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00170_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00170_A4();
+        a1_0.a2_0.a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0074-rc-function-Cycle_B_2_00170/expected.txt b/testsuite/java_test/rc_test/RC0074-rc-function-Cycle_B_2_00170/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0074-rc-function-Cycle_B_2_00170/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0074-rc-function-Cycle_B_2_00170/test.cfg b/testsuite/java_test/rc_test/RC0074-rc-function-Cycle_B_2_00170/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0f6a8e8e5b04fd5c462dddf374626869954a6796
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0074-rc-function-Cycle_B_2_00170/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00170)
+run(Cycle_B_2_00170,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0075-rc-function-Cycle_B_2_00180/Cycle_B_2_00180.java b/testsuite/java_test/rc_test/RC0075-rc-function-Cycle_B_2_00180/Cycle_B_2_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..f3378e1576e1d45a12c9bd2d027b945b3d8dc038
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0075-rc-function-Cycle_B_2_00180/Cycle_B_2_00180.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00180_A1 {
+    Cycle_B_2_00180_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00180_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00180_A2 {
+    Cycle_B_2_00180_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00180_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00180_A3 {
+    Cycle_B_2_00180_A1 a1_0;
+    Cycle_B_2_00180_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00180_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a + a4_0.a;
+    }
+}
+class Cycle_B_2_00180_A4 {
+    Cycle_B_2_00180_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00180_A4() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_B_2_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00180_A1 a1_0 = new Cycle_B_2_00180_A1();
+        a1_0.a2_0 = new Cycle_B_2_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00180_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00180_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0075-rc-function-Cycle_B_2_00180/expected.txt b/testsuite/java_test/rc_test/RC0075-rc-function-Cycle_B_2_00180/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0075-rc-function-Cycle_B_2_00180/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0075-rc-function-Cycle_B_2_00180/test.cfg b/testsuite/java_test/rc_test/RC0075-rc-function-Cycle_B_2_00180/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d81f74ce09ebb8e518ae8634ddb79e41079fe42a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0075-rc-function-Cycle_B_2_00180/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00180)
+run(Cycle_B_2_00180,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0076-rc-function-Cycle_B_2_00190/Cycle_B_2_00190.java b/testsuite/java_test/rc_test/RC0076-rc-function-Cycle_B_2_00190/Cycle_B_2_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..5ddf7ebd83d6531ec4f4855d90e649e84563f53f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0076-rc-function-Cycle_B_2_00190/Cycle_B_2_00190.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00190_A1 {
+    Cycle_B_2_00190_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00190_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00190_A2 {
+    Cycle_B_2_00190_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00190_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00190_A3 {
+    Cycle_B_2_00190_A1 a1_0;
+    Cycle_B_2_00190_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00190_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_B_2_00190_A4 {
+    Cycle_B_2_00190_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00190_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_B_2_00190 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00190_A1 a1_0 = new Cycle_B_2_00190_A1();
+        a1_0.a2_0 = new Cycle_B_2_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00190_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00190_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0076-rc-function-Cycle_B_2_00190/expected.txt b/testsuite/java_test/rc_test/RC0076-rc-function-Cycle_B_2_00190/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0076-rc-function-Cycle_B_2_00190/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0076-rc-function-Cycle_B_2_00190/test.cfg b/testsuite/java_test/rc_test/RC0076-rc-function-Cycle_B_2_00190/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..20f69823a9eed3948bf8838a19648268cdbbf178
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0076-rc-function-Cycle_B_2_00190/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00190)
+run(Cycle_B_2_00190,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0077-rc-function-Cycle_B_2_00200/Cycle_B_2_00200.java b/testsuite/java_test/rc_test/RC0077-rc-function-Cycle_B_2_00200/Cycle_B_2_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..499395b7fe41937c7376508d8acc524a0ac0656c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0077-rc-function-Cycle_B_2_00200/Cycle_B_2_00200.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00200_A1 {
+    Cycle_B_2_00200_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00200_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00200_A2 {
+    Cycle_B_2_00200_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00200_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00200_A3 {
+    Cycle_B_2_00200_A1 a1_0;
+    Cycle_B_2_00200_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00200_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a + a1_0.a;
+    }
+}
+class Cycle_B_2_00200_A4 {
+    Cycle_B_2_00200_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00200_A4() {
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+public class Cycle_B_2_00200 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00200_A1 a1_0 = new Cycle_B_2_00200_A1();
+        a1_0.a2_0 = new Cycle_B_2_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00200_A3();
+        Cycle_B_2_00200_A4 a4_0 = new Cycle_B_2_00200_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0077-rc-function-Cycle_B_2_00200/expected.txt b/testsuite/java_test/rc_test/RC0077-rc-function-Cycle_B_2_00200/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0077-rc-function-Cycle_B_2_00200/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0077-rc-function-Cycle_B_2_00200/test.cfg b/testsuite/java_test/rc_test/RC0077-rc-function-Cycle_B_2_00200/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ce292f10dd65be428d5e4fa4a0d7ae028585bb0b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0077-rc-function-Cycle_B_2_00200/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00200)
+run(Cycle_B_2_00200,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0078-rc-function-Cycle_B_2_00210/Cycle_B_2_00210.java b/testsuite/java_test/rc_test/RC0078-rc-function-Cycle_B_2_00210/Cycle_B_2_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..f0af9b98e8576780524af86f39f45e4809299988
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0078-rc-function-Cycle_B_2_00210/Cycle_B_2_00210.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00210_A1 {
+    Cycle_B_2_00210_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00210_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00210_A2 {
+    Cycle_B_2_00210_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00210_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00210_A3 {
+    Cycle_B_2_00210_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00210_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_B_2_00210_A4 {
+    Cycle_B_2_00210_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00210_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_B_2_00210_A5 {
+    Cycle_B_2_00210_A6 a6_0;
+    int a;
+    int sum;
+    Cycle_B_2_00210_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_B_2_00210_A6 {
+    Cycle_B_2_00210_A1 a1_0;
+    Cycle_B_2_00210_A8 a8_0;
+    int a;
+    int sum;
+    Cycle_B_2_00210_A6() {
+        a1_0 = null;
+        a8_0 = null;
+        a = 6;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a + a8_0.a;
+    }
+}
+class Cycle_B_2_00210_A8 {
+    Cycle_B_2_00210_A9 a9_0;
+    int a;
+    int sum;
+    Cycle_B_2_00210_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+class Cycle_B_2_00210_A9 {
+    Cycle_B_2_00210_A7 a7_0;
+    int a;
+    int sum;
+    Cycle_B_2_00210_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_B_2_00210_A7 {
+    Cycle_B_2_00210_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00210_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+public class Cycle_B_2_00210 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00210_A1 a1_0 = new Cycle_B_2_00210_A1();
+        a1_0.a2_0 = new Cycle_B_2_00210_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00210_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00210_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00210_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00210_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0 = new Cycle_B_2_00210_A8();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0 = new Cycle_B_2_00210_A9();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00210_A7();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0078-rc-function-Cycle_B_2_00210/expected.txt b/testsuite/java_test/rc_test/RC0078-rc-function-Cycle_B_2_00210/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0078-rc-function-Cycle_B_2_00210/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0078-rc-function-Cycle_B_2_00210/test.cfg b/testsuite/java_test/rc_test/RC0078-rc-function-Cycle_B_2_00210/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..305be8d8e71bfb7430462ddb10cb7207bdd89d65
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0078-rc-function-Cycle_B_2_00210/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00210)
+run(Cycle_B_2_00210,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0079-rc-function-Cycle_B_2_00220/Cycle_B_2_00220.java b/testsuite/java_test/rc_test/RC0079-rc-function-Cycle_B_2_00220/Cycle_B_2_00220.java
new file mode 100755
index 0000000000000000000000000000000000000000..ff611dab6106eda269533c11f853a16ee5ac56a1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0079-rc-function-Cycle_B_2_00220/Cycle_B_2_00220.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00220_A1 {
+    Cycle_B_2_00220_A2 a2_0;
+    Cycle_B_2_00220_A8 a8_0;
+    int a;
+    int sum;
+    Cycle_B_2_00220_A1() {
+        a2_0 = null;
+        a8_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a + a8_0.a;
+    }
+}
+class Cycle_B_2_00220_A2 {
+    Cycle_B_2_00220_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00220_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00220_A3 {
+    Cycle_B_2_00220_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00220_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_B_2_00220_A4 {
+    Cycle_B_2_00220_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00220_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_B_2_00220_A5 {
+    Cycle_B_2_00220_A6 a6_0;
+    int a;
+    int sum;
+    Cycle_B_2_00220_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_B_2_00220_A6 {
+    Cycle_B_2_00220_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00220_A6() {
+        a1_0 = null;
+        a = 6;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00220_A8 {
+    Cycle_B_2_00220_A9 a9_0;
+    int a;
+    int sum;
+    Cycle_B_2_00220_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+class Cycle_B_2_00220_A9 {
+    Cycle_B_2_00220_A7 a7_0;
+    int a;
+    int sum;
+    Cycle_B_2_00220_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_B_2_00220_A7 {
+    Cycle_B_2_00220_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00220_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+public class Cycle_B_2_00220 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00220_A1 a1_0 = new Cycle_B_2_00220_A1();
+        a1_0.a2_0 = new Cycle_B_2_00220_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00220_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00220_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00220_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00220_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a8_0 = new Cycle_B_2_00220_A8();
+        a1_0.a8_0.a9_0 = new Cycle_B_2_00220_A9();
+        a1_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00220_A7();
+        a1_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a8_0.add();
+        a1_0.a8_0.a9_0.add();
+        a1_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a8_0.sum + a1_0.a8_0.a9_0.sum + a1_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0079-rc-function-Cycle_B_2_00220/expected.txt b/testsuite/java_test/rc_test/RC0079-rc-function-Cycle_B_2_00220/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0079-rc-function-Cycle_B_2_00220/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0079-rc-function-Cycle_B_2_00220/test.cfg b/testsuite/java_test/rc_test/RC0079-rc-function-Cycle_B_2_00220/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6c227f0843df098fcf456b3f7aad216c64be4d37
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0079-rc-function-Cycle_B_2_00220/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00220)
+run(Cycle_B_2_00220,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0080-rc-function-Cycle_B_2_00230/Cycle_B_2_00230.java b/testsuite/java_test/rc_test/RC0080-rc-function-Cycle_B_2_00230/Cycle_B_2_00230.java
new file mode 100755
index 0000000000000000000000000000000000000000..fdc4698aa3c1aee8f5985b8dbde085954114c025
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0080-rc-function-Cycle_B_2_00230/Cycle_B_2_00230.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00230_A1 {
+    Cycle_B_2_00230_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00230_A2 {
+    Cycle_B_2_00230_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00230_A3 {
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_B_2_00230_A4 {
+    Cycle_B_2_00230_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_B_2_00230_A5 {
+    Cycle_B_2_00230_A6 a6_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_B_2_00230_A6 {
+    Cycle_B_2_00230_A1 a1_0;
+    Cycle_B_2_00230_A10 a10_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A6() {
+        a1_0 = null;
+        a10_0 = null;
+        a = 6;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a + a10_0.a;
+    }
+}
+class Cycle_B_2_00230_A8 {
+    Cycle_B_2_00230_A9 a9_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+class Cycle_B_2_00230_A9 {
+    Cycle_B_2_00230_A7 a7_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_B_2_00230_A7 {
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_B_2_00230_A10 {
+    Cycle_B_2_00230_A8 a8_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A10() {
+        a8_0 = null;
+        a = 10;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+public class Cycle_B_2_00230 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 97)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0080-rc-function-Cycle_B_2_00230/expected.txt b/testsuite/java_test/rc_test/RC0080-rc-function-Cycle_B_2_00230/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0080-rc-function-Cycle_B_2_00230/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0080-rc-function-Cycle_B_2_00230/test.cfg b/testsuite/java_test/rc_test/RC0080-rc-function-Cycle_B_2_00230/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..deb7e17fa95d08a9765cba92fdaaa100498d7b65
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0080-rc-function-Cycle_B_2_00230/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00230)
+run(Cycle_B_2_00230,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0081-rc-function-Cycle_B_2_00240/Cycle_B_2_00240.java b/testsuite/java_test/rc_test/RC0081-rc-function-Cycle_B_2_00240/Cycle_B_2_00240.java
new file mode 100755
index 0000000000000000000000000000000000000000..bb7ed961925afbdf8a4b4a7f41ccc8ab72589475
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0081-rc-function-Cycle_B_2_00240/Cycle_B_2_00240.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_B_2_00240_A1 {
+    Cycle_B_2_00240_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_B_2_00240_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00240_A2 {
+    Cycle_B_2_00240_A1 a1_0;
+    Cycle_B_2_00240_A3 a3_0;
+    Cycle_B_2_00240_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_B_2_00240_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_B_2_00240_A3 {
+    Cycle_B_2_00240_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_B_2_00240_A3(String strObjectName) {
+        a1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00240_A4 {
+    Cycle_B_2_00240_A1 a1_0;
+    Cycle_B_2_00240_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_B_2_00240_A4(String strObjectName) {
+        a2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a2_0.a;
+    }
+}
+class Cycle_B_2_00240_B1 {
+    Cycle_B_2_00240_A3 a3_0;
+    Cycle_B_2_00240_B2 b2_0;
+    Nocycle_B_2_00240_C2 c2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00240_B1() {
+        a3_0 = null;
+        b2_0 = null;
+        c2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a + b2_0.a + c2_0.a;
+    }
+}
+class Cycle_B_2_00240_B2 {
+    Cycle_B_2_00240_B1 b1_0;
+    int a;
+    int sum;
+    Cycle_B_2_00240_B2() {
+        b1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_B_2_00240_C1 {
+    Nocycle_B_2_00240_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_B_2_00240_C1(String strObjectName) {
+        c2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+    void add() {
+        sum = a + c2_0.a;
+    }
+}
+class Nocycle_B_2_00240_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_B_2_00240_C2(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Cycle_B_2_00240 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00240_A1 a1_main = new Cycle_B_2_00240_A1("a1_main");
+        a1_main.a2_0 = new Cycle_B_2_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_B_2_00240_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_B_2_00240_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        Cycle_B_2_00240_B1 b1_0 = new Cycle_B_2_00240_B1();
+        b1_0.a3_0 = new Cycle_B_2_00240_A3("a3_b1");
+        b1_0.b2_0 = new Cycle_B_2_00240_B2();
+        b1_0.c2_0 = new Nocycle_B_2_00240_C2("c2_b1");
+        b1_0.b2_0.b1_0 = b1_0;
+        b1_0.add();
+        b1_0.b2_0.add();
+        int nsum = (b1_0.sum + b1_0.b2_0.sum);
+        Nocycle_B_2_00240_C1 c1_main = new Nocycle_B_2_00240_C1("c1_main");
+        c1_main.c2_0 = new Nocycle_B_2_00240_C2("c2_0");
+        c1_main.add();
+        c1_main.c2_0.add();
+        int result2 = c1_main.sum + c1_main.c2_0.sum;
+        if (result == 1124 && nsum == 310 && result2 == 704)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0081-rc-function-Cycle_B_2_00240/expected.txt b/testsuite/java_test/rc_test/RC0081-rc-function-Cycle_B_2_00240/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0081-rc-function-Cycle_B_2_00240/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0081-rc-function-Cycle_B_2_00240/test.cfg b/testsuite/java_test/rc_test/RC0081-rc-function-Cycle_B_2_00240/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b036463be3b5db7dfa2f9fb80b41e14e8c6d438
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0081-rc-function-Cycle_B_2_00240/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_B_2_00240)
+run(Cycle_B_2_00240,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0082-rc-function-Nocycle_a_00010/Nocycle_a_00010.java b/testsuite/java_test/rc_test/RC0082-rc-function-Nocycle_a_00010/Nocycle_a_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..49f5876adb812feb202cf2caeb52f60e389502ae
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0082-rc-function-Nocycle_a_00010/Nocycle_a_00010.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00010_A1 {
+    Nocycle_a_00010_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00010_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);  
+//   }  
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00010_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00010_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);  
+//   }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    public static void rc_testcase_main_wrapper() {
+        Nocycle_a_00010_A1 a1_main = new Nocycle_a_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00010_B1("b1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 704)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0082-rc-function-Nocycle_a_00010/expected.txt b/testsuite/java_test/rc_test/RC0082-rc-function-Nocycle_a_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0082-rc-function-Nocycle_a_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0082-rc-function-Nocycle_a_00010/test.cfg b/testsuite/java_test/rc_test/RC0082-rc-function-Nocycle_a_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..33d6bab5784ec01be129fe9dcc91480603b28ca0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0082-rc-function-Nocycle_a_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00010)
+run(Nocycle_a_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0083-rc-function-Nocycle_a_00020/Nocycle_a_00020.java b/testsuite/java_test/rc_test/RC0083-rc-function-Nocycle_a_00020/Nocycle_a_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..eb86d2e754c4294f30e9942898b7131991edb1b8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0083-rc-function-Nocycle_a_00020/Nocycle_a_00020.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00020_A1 {
+    Nocycle_a_00020_B1 b1_0;
+    Nocycle_a_00020_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00020_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00020_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00020_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00020_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00020_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00020_A1 a1_main = new Nocycle_a_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00020_B2("b2_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1310)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0083-rc-function-Nocycle_a_00020/expected.txt b/testsuite/java_test/rc_test/RC0083-rc-function-Nocycle_a_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0083-rc-function-Nocycle_a_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0083-rc-function-Nocycle_a_00020/test.cfg b/testsuite/java_test/rc_test/RC0083-rc-function-Nocycle_a_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8321d037b83fb4e6ef8354ba9d3f3ebda9ff0dd4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0083-rc-function-Nocycle_a_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00020)
+run(Nocycle_a_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0084-rc-function-Nocycle_a_00030/Nocycle_a_00030.java b/testsuite/java_test/rc_test/RC0084-rc-function-Nocycle_a_00030/Nocycle_a_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..0ec60b1bff0c176678e592d1ddc198bbc614dbd5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0084-rc-function-Nocycle_a_00030/Nocycle_a_00030.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00030_A1 {
+    Nocycle_a_00030_B1 b1_0;
+    Nocycle_a_00030_B2 b2_0;
+    Nocycle_a_00030_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00030_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+class Nocycle_a_00030_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00030_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00030_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00030_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00030_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00030_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00030_A1 a1_main = new Nocycle_a_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00030_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00030_B3("b3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        if (result == 1919)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0084-rc-function-Nocycle_a_00030/expected.txt b/testsuite/java_test/rc_test/RC0084-rc-function-Nocycle_a_00030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0084-rc-function-Nocycle_a_00030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0084-rc-function-Nocycle_a_00030/test.cfg b/testsuite/java_test/rc_test/RC0084-rc-function-Nocycle_a_00030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6f194c43eea0aaa91699c2e0fc37f0e377e25bf1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0084-rc-function-Nocycle_a_00030/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00030)
+run(Nocycle_a_00030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0085-rc-function-Nocycle_a_00040/Nocycle_a_00040.java b/testsuite/java_test/rc_test/RC0085-rc-function-Nocycle_a_00040/Nocycle_a_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..f6a853972110e3d5dd70a98489e355ebbf98075f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0085-rc-function-Nocycle_a_00040/Nocycle_a_00040.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00040_A1 {
+    Nocycle_a_00040_B1 b1_0;
+    Nocycle_a_00040_B2 b2_0;
+    Nocycle_a_00040_B3 b3_0;
+    Nocycle_a_00040_B4 b4_0;
+    Nocycle_a_00040_B5 b5_0;
+    Nocycle_a_00040_B6 b6_0;
+    Nocycle_a_00040_B7 b7_0;
+    Nocycle_a_00040_B8 b8_0;
+    Nocycle_a_00040_B9 b9_0;
+    Nocycle_a_00040_B10 b10_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        b5_0 = null;
+        b6_0 = null;
+        b7_0 = null;
+        b8_0 = null;
+        b9_0 = null;
+        b10_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + b5_0.a + b6_0.a + b7_0.a + b8_0.a + b9_0.a + b10_0.a;
+    }
+}
+class Nocycle_a_00040_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00040_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00040_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00040_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00040_B5 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B5(String strObjectName) {
+        a = 205;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00040_B6 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B6(String strObjectName) {
+        a = 206;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00040_B7 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B7(String strObjectName) {
+        a = 207;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00040_B8 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B8(String strObjectName) {
+        a = 208;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00040_B9 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B9(String strObjectName) {
+        a = 209;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B9_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00040_B10 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00040_B10(String strObjectName) {
+        a = 210;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B10_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00040_A1 a1_main = new Nocycle_a_00040_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00040_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00040_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00040_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00040_B4("b4_0");
+        a1_main.b5_0 = new Nocycle_a_00040_B5("b5_0");
+        a1_main.b6_0 = new Nocycle_a_00040_B6("b6_0");
+        a1_main.b7_0 = new Nocycle_a_00040_B7("b7_0");
+        a1_main.b8_0 = new Nocycle_a_00040_B8("b8_0");
+        a1_main.b9_0 = new Nocycle_a_00040_B9("b9_0");
+        a1_main.b10_0 = new Nocycle_a_00040_B10("b10_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b5_0.add();
+        a1_main.b6_0.add();
+        a1_main.b7_0.add();
+        a1_main.b8_0.add();
+        a1_main.b9_0.add();
+        a1_main.b10_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b5_0.sum + a1_main.b6_0.sum + a1_main.b7_0.sum + a1_main.b8_0.sum + a1_main.b9_0.sum + a1_main.b10_0.sum;
+        if (result == 6266)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0085-rc-function-Nocycle_a_00040/expected.txt b/testsuite/java_test/rc_test/RC0085-rc-function-Nocycle_a_00040/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0085-rc-function-Nocycle_a_00040/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0085-rc-function-Nocycle_a_00040/test.cfg b/testsuite/java_test/rc_test/RC0085-rc-function-Nocycle_a_00040/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eb8b97e2a47caef5be5461dae6f9f34a4dbaccd6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0085-rc-function-Nocycle_a_00040/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00040)
+run(Nocycle_a_00040,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0086-rc-function-Nocycle_a_00050/Nocycle_a_00050.java b/testsuite/java_test/rc_test/RC0086-rc-function-Nocycle_a_00050/Nocycle_a_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..17bdb9b3e5ca3f24aeda5f0efec4419df481e7ec
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0086-rc-function-Nocycle_a_00050/Nocycle_a_00050.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00050_A1 {
+    Nocycle_a_00050_B1 b1_0;
+    Nocycle_a_00050_B2 b2_0;
+    Nocycle_a_00050_B3 b3_0;
+    Nocycle_a_00050_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00050_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+class Nocycle_a_00050_B1 {
+    Nocycle_a_00050_C1 c1_0;
+    Nocycle_a_00050_C2 c2_0;
+    Nocycle_a_00050_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00050_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+class Nocycle_a_00050_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00050_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00050_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00050_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00050_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00050_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00050_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00050_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00050_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00050_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00050_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00050_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00050_A1 a1_main = new Nocycle_a_00050_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00050_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00050_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_a_00050_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_a_00050_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_a_00050_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00050_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00050_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        a1_main.b1_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c2_0.sum+a1_main.b1_0.c3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum + a1_main.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5048)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0086-rc-function-Nocycle_a_00050/expected.txt b/testsuite/java_test/rc_test/RC0086-rc-function-Nocycle_a_00050/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0086-rc-function-Nocycle_a_00050/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0086-rc-function-Nocycle_a_00050/test.cfg b/testsuite/java_test/rc_test/RC0086-rc-function-Nocycle_a_00050/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..99b7e0e9e01539a25239ee5e6b47226b183f7fad
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0086-rc-function-Nocycle_a_00050/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00050)
+run(Nocycle_a_00050,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0087-rc-function-Nocycle_a_00060/Nocycle_a_00060.java b/testsuite/java_test/rc_test/RC0087-rc-function-Nocycle_a_00060/Nocycle_a_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..9e57bdab8d272da78488175f28612051889a032a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0087-rc-function-Nocycle_a_00060/Nocycle_a_00060.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00060_A1 {
+    Nocycle_a_00060_B1 b1_0;
+    Nocycle_a_00060_B2 b2_0;
+    Nocycle_a_00060_B3 b3_0;
+    Nocycle_a_00060_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00060_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+class Nocycle_a_00060_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00060_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00060_B2 {
+    Nocycle_a_00060_C1 c1_0;
+    Nocycle_a_00060_C2 c2_0;
+    Nocycle_a_00060_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00060_B2(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+class Nocycle_a_00060_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00060_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00060_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00060_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00060_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00060_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00060_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00060_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00060_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00060_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00060 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00060_A1 a1_main = new Nocycle_a_00060_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00060_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00060_B2("b2_0");
+        a1_main.b2_0.c1_0 = new Nocycle_a_00060_C1("c1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00060_C2("c2_0");
+        a1_main.b2_0.c3_0 = new Nocycle_a_00060_C3("c3_0");
+        a1_main.b3_0 = new Nocycle_a_00060_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00060_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c1_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b2_0.c3_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c1_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b2_0.c3_0.sum;
+        if (result == 5047)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0087-rc-function-Nocycle_a_00060/expected.txt b/testsuite/java_test/rc_test/RC0087-rc-function-Nocycle_a_00060/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0087-rc-function-Nocycle_a_00060/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0087-rc-function-Nocycle_a_00060/test.cfg b/testsuite/java_test/rc_test/RC0087-rc-function-Nocycle_a_00060/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0a48ee609bc01fc8b1a42253d0e2bf252940d6a4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0087-rc-function-Nocycle_a_00060/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00060)
+run(Nocycle_a_00060,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0088-rc-function-Nocycle_a_00070/Nocycle_a_00070.java b/testsuite/java_test/rc_test/RC0088-rc-function-Nocycle_a_00070/Nocycle_a_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..2587d284b2ce47d1a053f796d23450e77173d6fc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0088-rc-function-Nocycle_a_00070/Nocycle_a_00070.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00070_A1 {
+    Nocycle_a_00070_B1 b1_0;
+    Nocycle_a_00070_B2 b2_0;
+    Nocycle_a_00070_B3 b3_0;
+    Nocycle_a_00070_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00070_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+class Nocycle_a_00070_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00070_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00070_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00070_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00070_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00070_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00070_B4 {
+    Nocycle_a_00070_C1 c1_0;
+    Nocycle_a_00070_C2 c2_0;
+    Nocycle_a_00070_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00070_B4(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+class Nocycle_a_00070_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00070_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00070_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00070_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00070_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00070_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00070 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00070_A1 a1_main = new Nocycle_a_00070_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00070_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00070_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00070_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00070_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_00070_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_00070_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00070_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5045)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0088-rc-function-Nocycle_a_00070/expected.txt b/testsuite/java_test/rc_test/RC0088-rc-function-Nocycle_a_00070/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0088-rc-function-Nocycle_a_00070/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0088-rc-function-Nocycle_a_00070/test.cfg b/testsuite/java_test/rc_test/RC0088-rc-function-Nocycle_a_00070/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0cf6eab7f45a7fd3e41e02ba2a709a04d9b7599f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0088-rc-function-Nocycle_a_00070/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00070)
+run(Nocycle_a_00070,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0089-rc-function-Nocycle_a_00080/Nocycle_a_00080.java b/testsuite/java_test/rc_test/RC0089-rc-function-Nocycle_a_00080/Nocycle_a_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..3e517a52526281bebe5a17ea91f8c03c1eda123c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0089-rc-function-Nocycle_a_00080/Nocycle_a_00080.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00080_A1 {
+    Nocycle_a_00080_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00080_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00080_B1 {
+    Nocycle_a_00080_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00080_B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_a_00080_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00080_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00080 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00080_A1 a1_main = new Nocycle_a_00080_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00080_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00080_C1("c1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1406)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0089-rc-function-Nocycle_a_00080/expected.txt b/testsuite/java_test/rc_test/RC0089-rc-function-Nocycle_a_00080/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0089-rc-function-Nocycle_a_00080/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0089-rc-function-Nocycle_a_00080/test.cfg b/testsuite/java_test/rc_test/RC0089-rc-function-Nocycle_a_00080/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..92b185afc5757f6f42d5a3a434a1fb37dac885c7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0089-rc-function-Nocycle_a_00080/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00080)
+run(Nocycle_a_00080,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0090-rc-function-Nocycle_a_00090/Nocycle_a_00090.java b/testsuite/java_test/rc_test/RC0090-rc-function-Nocycle_a_00090/Nocycle_a_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..401917056ae118fd8a70c7643c17d788ec8eeb16
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0090-rc-function-Nocycle_a_00090/Nocycle_a_00090.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00090_A1 {
+    Nocycle_a_00090_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00090_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00090_B1 {
+    Nocycle_a_00090_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00090_B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_a_00090_C1 {
+    Nocycle_a_00090_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00090_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_a_00090_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00090_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00090 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00090_A1 a1_main = new Nocycle_a_00090_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00090_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00090_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00090_D1("d1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2308)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0090-rc-function-Nocycle_a_00090/expected.txt b/testsuite/java_test/rc_test/RC0090-rc-function-Nocycle_a_00090/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0090-rc-function-Nocycle_a_00090/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0090-rc-function-Nocycle_a_00090/test.cfg b/testsuite/java_test/rc_test/RC0090-rc-function-Nocycle_a_00090/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cd1e888e2c1df5df5daccc360bf0dcc275e5f793
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0090-rc-function-Nocycle_a_00090/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00090)
+run(Nocycle_a_00090,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0091-rc-function-Nocycle_a_00100/Nocycle_a_00100.java b/testsuite/java_test/rc_test/RC0091-rc-function-Nocycle_a_00100/Nocycle_a_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..370186be6f6fd450fd6878d859cd75dc374b6b91
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0091-rc-function-Nocycle_a_00100/Nocycle_a_00100.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00100_A1 {
+    Nocycle_a_00100_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00100_B1 {
+    Nocycle_a_00100_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_a_00100_C1 {
+    Nocycle_a_00100_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_a_00100_D1 {
+    Nocycle_a_00100_E1 e1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_D1(String strObjectName) {
+        e1_0 = null;
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + e1_0.a;
+    }
+}
+class Nocycle_a_00100_E1 {
+    Nocycle_a_00100_F1 f1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_E1(String strObjectName) {
+        f1_0 = null;
+        a = 501;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+    }
+    void add() {
+        sum = a + f1_0.a;
+    }
+}
+class Nocycle_a_00100_F1 {
+    Nocycle_a_00100_G1 g1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_F1(String strObjectName) {
+        g1_0 = null;
+        a = 601;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+    }
+    void add() {
+        sum = a + g1_0.a;
+    }
+}
+class Nocycle_a_00100_G1 {
+    Nocycle_a_00100_H1 h1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_G1(String strObjectName) {
+        h1_0 = null;
+        a = 701;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+    }
+    void add() {
+        sum = a + h1_0.a;
+    }
+}
+class Nocycle_a_00100_H1 {
+    Nocycle_a_00100_I1 i1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_H1(String strObjectName) {
+        i1_0 = null;
+        a = 801;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+    }
+    void add() {
+        sum = a + i1_0.a;
+    }
+}
+class Nocycle_a_00100_I1 {
+    Nocycle_a_00100_J1 j1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_I1(String strObjectName) {
+        j1_0 = null;
+        a = 901;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+    }
+    void add() {
+        sum = a + j1_0.a;
+    }
+}
+class Nocycle_a_00100_J1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00100_J1(String strObjectName) {
+        a = 1001;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00100 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00100_A1 a1_main = new Nocycle_a_00100_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00100_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00100_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00100_D1("d1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_00100_E1("e1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_00100_F1("f1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_00100_G1("g1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_00100_H1("h1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_00100_I1("i1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_00100_J1("j1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+        if (result == 11920)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0091-rc-function-Nocycle_a_00100/expected.txt b/testsuite/java_test/rc_test/RC0091-rc-function-Nocycle_a_00100/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0091-rc-function-Nocycle_a_00100/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0091-rc-function-Nocycle_a_00100/test.cfg b/testsuite/java_test/rc_test/RC0091-rc-function-Nocycle_a_00100/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1f521ba063ae4a94a44278ff9a3633b22ec23570
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0091-rc-function-Nocycle_a_00100/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00100)
+run(Nocycle_a_00100,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0092-rc-function-Nocycle_a_00110/Nocycle_a_00110.java b/testsuite/java_test/rc_test/RC0092-rc-function-Nocycle_a_00110/Nocycle_a_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..90e4c793ed08ce93315e9ff9444de977a7eabbd1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0092-rc-function-Nocycle_a_00110/Nocycle_a_00110.java
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00110_A1 {
+    Nocycle_a_00110_B1 b1_0;
+    Nocycle_a_00110_B2 b2_0;
+    Nocycle_a_00110_B3 b3_0;
+    Nocycle_a_00110_B4 b4_0;
+    Nocycle_a_00110_D5 d5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        d5_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + d5_0.a;
+    }
+}
+class Nocycle_a_00110_B1 {
+    Nocycle_a_00110_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_a_00110_B2 {
+    Nocycle_a_00110_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_B2(String strObjectName) {
+        c2_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + c2_0.a;
+    }
+}
+class Nocycle_a_00110_B3 {
+    Nocycle_a_00110_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_a_00110_B4 {
+    Nocycle_a_00110_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_B4(String strObjectName) {
+        c3_0 = null;
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+    void add() {
+        sum = a + c3_0.a;
+    }
+}
+class Nocycle_a_00110_C1 {
+    Nocycle_a_00110_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_C1(String strObjectName) {
+        d2_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+class Nocycle_a_00110_C2 {
+    Nocycle_a_00110_D3 d3_0;
+    Nocycle_a_00110_D4 d4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_C2(String strObjectName) {
+        d3_0 = null;
+        d4_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + d3_0.a + d4_0.a;
+    }
+}
+class Nocycle_a_00110_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00110_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00110_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00110_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00110_D4 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_D4(String strObjectName) {
+        a = 404;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00110_D5 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00110_D5(String strObjectName) {
+        a = 405;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00110 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00110_A1 a1_main = new Nocycle_a_00110_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00110_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00110_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00110_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00110_B4("b4_0");
+        a1_main.b1_0.d1_0 = new Nocycle_a_00110_D1("d1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00110_C2("c2_0");
+        a1_main.b3_0.c1_0 = new Nocycle_a_00110_C1("c1_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00110_C3("c3_0");
+        a1_main.b3_0.c1_0.d2_0 = new Nocycle_a_00110_D2("d2_0");
+        a1_main.b2_0.c2_0.d3_0 = new Nocycle_a_00110_D3("d3_0");
+        a1_main.b2_0.c2_0.d4_0 = new Nocycle_a_00110_D4("d4_0");
+        a1_main.d5_0 = new Nocycle_a_00110_D5("d5_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b3_0.c1_0.add();
+        a1_main.b4_0.c3_0.add();
+        a1_main.b1_0.d1_0.add();
+        a1_main.b3_0.c1_0.d2_0.add();
+        a1_main.b2_0.c2_0.d3_0.add();
+        a1_main.b2_0.c2_0.d4_0.add();
+        a1_main.d5_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b3_0.c1_0.sum + a1_main.b4_0.c3_0.sum + a1_main.b1_0.d1_0.sum + a1_main.b3_0.c1_0.d2_0.sum + a1_main.b2_0.c2_0.d3_0.sum + a1_main.b2_0.c2_0.d4_0.sum + a1_main.d5_0.sum;
+        if (result == 9881)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0092-rc-function-Nocycle_a_00110/expected.txt b/testsuite/java_test/rc_test/RC0092-rc-function-Nocycle_a_00110/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0092-rc-function-Nocycle_a_00110/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0092-rc-function-Nocycle_a_00110/test.cfg b/testsuite/java_test/rc_test/RC0092-rc-function-Nocycle_a_00110/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3967a65abb7b19e2a50e5370dcf63bd15512295d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0092-rc-function-Nocycle_a_00110/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00110)
+run(Nocycle_a_00110,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0093-rc-function-Nocycle_a_00120/Nocycle_a_00120.java b/testsuite/java_test/rc_test/RC0093-rc-function-Nocycle_a_00120/Nocycle_a_00120.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3da44b89cc89bdf6957f53e1dcc93b40052307b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0093-rc-function-Nocycle_a_00120/Nocycle_a_00120.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00120_A1 {
+    Nocycle_a_00120_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00120_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00120_A2 {
+    Nocycle_a_00120_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00120_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00120_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00120_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00120 {
+    public static void main(String[] args) {
+        Nocycle_a_00120_A1 a1_main = new Nocycle_a_00120_A1("a1_main");
+        Nocycle_a_00120_A2 a2_main = new Nocycle_a_00120_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum;
+        if (result == 1007) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0093-rc-function-Nocycle_a_00120/expected.txt b/testsuite/java_test/rc_test/RC0093-rc-function-Nocycle_a_00120/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0093-rc-function-Nocycle_a_00120/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0093-rc-function-Nocycle_a_00120/test.cfg b/testsuite/java_test/rc_test/RC0093-rc-function-Nocycle_a_00120/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e8ef37b83966f95d0d9f0e044042920d54458c03
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0093-rc-function-Nocycle_a_00120/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00120)
+run(Nocycle_a_00120,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0094-rc-function-Nocycle_a_00130/Nocycle_a_00130.java b/testsuite/java_test/rc_test/RC0094-rc-function-Nocycle_a_00130/Nocycle_a_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..dbe0cdb3026a90c3309bede01eb829558a5e3c73
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0094-rc-function-Nocycle_a_00130/Nocycle_a_00130.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00130_A1 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_A2 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_A3 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A3(String strObjectName) {
+        b1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_A4 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A4(String strObjectName) {
+        b1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_A5 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A5(String strObjectName) {
+        b1_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_A6 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A6(String strObjectName) {
+        b1_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_A7 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A7(String strObjectName) {
+        b1_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_A8 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A8(String strObjectName) {
+        b1_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_A9 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A9(String strObjectName) {
+        b1_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_A10 {
+    Nocycle_a_00130_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_A10(String strObjectName) {
+        b1_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00130_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00130_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00130 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00130_A1 a1_main = new Nocycle_a_00130_A1("a1_main");
+        Nocycle_a_00130_A2 a2_main = new Nocycle_a_00130_A2("a2_main");
+        Nocycle_a_00130_A3 a3_main = new Nocycle_a_00130_A3("a3_main");
+        Nocycle_a_00130_A4 a4_main = new Nocycle_a_00130_A4("a4_main");
+        Nocycle_a_00130_A5 a5_main = new Nocycle_a_00130_A5("a5_main");
+        Nocycle_a_00130_A6 a6_main = new Nocycle_a_00130_A6("a6_main");
+        Nocycle_a_00130_A7 a7_main = new Nocycle_a_00130_A7("a7_main");
+        Nocycle_a_00130_A8 a8_main = new Nocycle_a_00130_A8("a8_main");
+        Nocycle_a_00130_A9 a9_main = new Nocycle_a_00130_A9("a9_main");
+        Nocycle_a_00130_A10 a10_main = new Nocycle_a_00130_A10("a10_main");
+        a1_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a3_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a4_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a5_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a6_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a7_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a8_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a9_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a10_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        a3_main.b1_0.add();
+        a4_main.b1_0.add();
+        a5_main.b1_0.add();
+        a6_main.b1_0.add();
+        a7_main.b1_0.add();
+        a8_main.b1_0.add();
+        a9_main.b1_0.add();
+        a10_main.b1_0.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + a1_main.b1_0.sum;
+        if (result == 3467)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0094-rc-function-Nocycle_a_00130/expected.txt b/testsuite/java_test/rc_test/RC0094-rc-function-Nocycle_a_00130/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0094-rc-function-Nocycle_a_00130/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0094-rc-function-Nocycle_a_00130/test.cfg b/testsuite/java_test/rc_test/RC0094-rc-function-Nocycle_a_00130/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e330533af5f885d9709d5cd2cac97bd3396fcd20
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0094-rc-function-Nocycle_a_00130/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00130)
+run(Nocycle_a_00130,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0095-rc-function-Nocycle_a_00140/Nocycle_a_00140.java b/testsuite/java_test/rc_test/RC0095-rc-function-Nocycle_a_00140/Nocycle_a_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..3cfa16da0abc47a2c6917f6f2c43e0c435775273
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0095-rc-function-Nocycle_a_00140/Nocycle_a_00140.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00140_A1 {
+    Nocycle_a_00140_B1 b1_0;
+    Nocycle_a_00140_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00140_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00140_A2 {
+    Nocycle_a_00140_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00140_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_00140_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00140_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00140_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00140_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00140 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00140_A1 a1_main = new Nocycle_a_00140_A1("a1_main");
+        Nocycle_a_00140_A2 a2_main = new Nocycle_a_00140_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00140_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 1613)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0095-rc-function-Nocycle_a_00140/expected.txt b/testsuite/java_test/rc_test/RC0095-rc-function-Nocycle_a_00140/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0095-rc-function-Nocycle_a_00140/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0095-rc-function-Nocycle_a_00140/test.cfg b/testsuite/java_test/rc_test/RC0095-rc-function-Nocycle_a_00140/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3771bfa7c5e32d7ad27f1cbdf74dffc6a65109ca
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0095-rc-function-Nocycle_a_00140/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00140)
+run(Nocycle_a_00140,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0096-rc-function-Nocycle_a_00150/Nocycle_a_00150.java b/testsuite/java_test/rc_test/RC0096-rc-function-Nocycle_a_00150/Nocycle_a_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..1667cfa96cd2e85862f5594b1d864e87ba001748
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0096-rc-function-Nocycle_a_00150/Nocycle_a_00150.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00150_A1 {
+    Nocycle_a_00150_B1 b1_0;
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00150_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00150_A2 {
+    Nocycle_a_00150_B1 b1_0;
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00150_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00150_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00150_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00150_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00150_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00150 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 1815)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0096-rc-function-Nocycle_a_00150/expected.txt b/testsuite/java_test/rc_test/RC0096-rc-function-Nocycle_a_00150/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0096-rc-function-Nocycle_a_00150/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0096-rc-function-Nocycle_a_00150/test.cfg b/testsuite/java_test/rc_test/RC0096-rc-function-Nocycle_a_00150/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..806f4a2ff22c34911c37c602adb2322bdaff6bbc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0096-rc-function-Nocycle_a_00150/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00150)
+run(Nocycle_a_00150,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0097-rc-function-Nocycle_a_00160/Nocycle_a_00160.java b/testsuite/java_test/rc_test/RC0097-rc-function-Nocycle_a_00160/Nocycle_a_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..5c87a3405ba25c31d77b97923830ff9c59f88c38
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0097-rc-function-Nocycle_a_00160/Nocycle_a_00160.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00160_A1 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00160_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00160_A2 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00160_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00160_A3 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00160_A3(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00160_A4 {
+    Nocycle_a_00160_B1 b1_0;
+    Nocycle_a_00160_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00160_A4(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00160_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00160_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00160_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00160_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00160 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00160_A1 a1_main = new Nocycle_a_00160_A1("a1_main");
+        Nocycle_a_00160_A2 a2_main = new Nocycle_a_00160_A2("a2_main");
+        Nocycle_a_00160_A3 a3_main = new Nocycle_a_00160_A3("a3_main");
+        Nocycle_a_00160_A4 a4_main = new Nocycle_a_00160_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a3_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a4_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 2828)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0097-rc-function-Nocycle_a_00160/expected.txt b/testsuite/java_test/rc_test/RC0097-rc-function-Nocycle_a_00160/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0097-rc-function-Nocycle_a_00160/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0097-rc-function-Nocycle_a_00160/test.cfg b/testsuite/java_test/rc_test/RC0097-rc-function-Nocycle_a_00160/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bb8a407cc34a9f0b40f31d2f6f9b9955fd950199
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0097-rc-function-Nocycle_a_00160/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00160)
+run(Nocycle_a_00160,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0098-rc-function-Nocycle_a_00170/Nocycle_a_00170.java b/testsuite/java_test/rc_test/RC0098-rc-function-Nocycle_a_00170/Nocycle_a_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..70bd5b9adb9f1335a00abecb01ad00589b45e240
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0098-rc-function-Nocycle_a_00170/Nocycle_a_00170.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00170_A1 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00170_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+class Nocycle_a_00170_A2 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00170_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+class Nocycle_a_00170_A3 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00170_A3(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+class Nocycle_a_00170_A4 {
+    Nocycle_a_00170_B1 b1_0;
+    Nocycle_a_00170_B2 b2_0;
+    Nocycle_a_00170_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00170_A4(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+class Nocycle_a_00170_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00170_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00170_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00170_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00170_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00170_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00170 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00170_A1 a1_main = new Nocycle_a_00170_A1("a1_main");
+        Nocycle_a_00170_A2 a2_main = new Nocycle_a_00170_A2("a2_main");
+        Nocycle_a_00170_A3 a3_main = new Nocycle_a_00170_A3("a3_main");
+        Nocycle_a_00170_A4 a4_main = new Nocycle_a_00170_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a2_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a2_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a3_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a3_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a4_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a4_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a2_main.b3_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b3_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        a4_main.b3_0.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        if (result == 4046)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0098-rc-function-Nocycle_a_00170/expected.txt b/testsuite/java_test/rc_test/RC0098-rc-function-Nocycle_a_00170/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0098-rc-function-Nocycle_a_00170/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0098-rc-function-Nocycle_a_00170/test.cfg b/testsuite/java_test/rc_test/RC0098-rc-function-Nocycle_a_00170/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e392395384dbef0f2fe47fd287f76d840fd03e57
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0098-rc-function-Nocycle_a_00170/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00170)
+run(Nocycle_a_00170,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0099-rc-function-Nocycle_a_00180/Nocycle_a_00180.java b/testsuite/java_test/rc_test/RC0099-rc-function-Nocycle_a_00180/Nocycle_a_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..bd5a06313aee9177f3f74c153d302c0b907ac694
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0099-rc-function-Nocycle_a_00180/Nocycle_a_00180.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_00180_A1 {
+    Nocycle_a_00180_B1 b1_0;
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+class Nocycle_a_00180_A2 {
+    Nocycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+class Nocycle_a_00180_A3 {
+    Nocycle_a_00180_B2 b2_0;
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+class Nocycle_a_00180_A4 {
+    Nocycle_a_00180_B3 b3_0;
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+class Nocycle_a_00180_B1 {
+    Nocycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+class Nocycle_a_00180_B2 {
+    Nocycle_a_00180_C1 c1_0;
+    Nocycle_a_00180_D1 d1_0;
+    Nocycle_a_00180_D2 d2_0;
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_a_00180_B3 {
+    Nocycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_a_00180_C1 {
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_a_00180_C2 {
+    Nocycle_a_00180_D2 d2_0;
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        if (result == 9260)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0099-rc-function-Nocycle_a_00180/expected.txt b/testsuite/java_test/rc_test/RC0099-rc-function-Nocycle_a_00180/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0099-rc-function-Nocycle_a_00180/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0099-rc-function-Nocycle_a_00180/test.cfg b/testsuite/java_test/rc_test/RC0099-rc-function-Nocycle_a_00180/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..95a3f1690a8197087e88c8fe8aec93dbceb9f8b0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0099-rc-function-Nocycle_a_00180/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_00180)
+run(Nocycle_a_00180,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0100-rc-function-Nocycle_a_2_00010/Nocycle_a_2_00010.java b/testsuite/java_test/rc_test/RC0100-rc-function-Nocycle_a_2_00010/Nocycle_a_2_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..76dcc8be82935b4f7e16ea4d29c0f1096042262d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0100-rc-function-Nocycle_a_2_00010/Nocycle_a_2_00010.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_2_00010_A1 {
+    Nocycle_a_2_00010_B1 b1_0;
+    Nocycle_a_2_00010_B2 b2_0;
+    Nocycle_a_2_00010_B3 b3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00010_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a;
+    }
+}
+class Nocycle_a_2_00010_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00010_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00010_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00010_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00010_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00010_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00010_A2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00010_A2(String strObjectName) {
+        a = 10;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_2_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_2_00010_A1 a1_main = new Nocycle_a_2_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00010_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00010_B3("b3_0");
+        Nocycle_a_2_00010_A2 a2_main = new Nocycle_a_2_00010_A2("a2_main");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a2_main.sum;
+        if (result == 1939)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0100-rc-function-Nocycle_a_2_00010/expected.txt b/testsuite/java_test/rc_test/RC0100-rc-function-Nocycle_a_2_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0100-rc-function-Nocycle_a_2_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0100-rc-function-Nocycle_a_2_00010/test.cfg b/testsuite/java_test/rc_test/RC0100-rc-function-Nocycle_a_2_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d81f2b2946adfd64d45a2eb7fabf40b7d2442edd
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0100-rc-function-Nocycle_a_2_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_2_00010)
+run(Nocycle_a_2_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0101-rc-function-Nocycle_a_2_00020/Nocycle_a_2_00020.java b/testsuite/java_test/rc_test/RC0101-rc-function-Nocycle_a_2_00020/Nocycle_a_2_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..76b4212d60e03aba34fc6e2c96a453907f3d8516
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0101-rc-function-Nocycle_a_2_00020/Nocycle_a_2_00020.java
@@ -0,0 +1,608 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_a_2_00020_A1 {
+    Nocycle_a_2_00020_B1 b1_0;
+    Nocycle_a_2_00020_B2 b2_0;
+    Nocycle_a_2_00020_B3 b3_0;
+    Nocycle_a_2_00020_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+class Nocycle_a_2_00020_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00020_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00020_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00020_B4 {
+    Nocycle_a_2_00020_C1 c1_0;
+    Nocycle_a_2_00020_C2 c2_0;
+    Nocycle_a_2_00020_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_B4(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+class Nocycle_a_2_00020_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00020_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00020_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00020_2A1 {
+    Nocycle_a_2_00020_2B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class Nocycle_a_2_00020_2B1 {
+    Nocycle_a_2_00020_2C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2B1(String strObjectName) {
+        c1_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_a_2_00020_2C1 {
+    Nocycle_a_2_00020_2D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_a_2_00020_2D1 {
+    Nocycle_a_2_00020_2E1 e1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2D1(String strObjectName) {
+        e1_0 = null;
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + e1_0.a;
+    }
+}
+class Nocycle_a_2_00020_2E1 {
+    Nocycle_a_2_00020_2F1 f1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2E1(String strObjectName) {
+        f1_0 = null;
+        a = 501;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+    }
+    void add() {
+        sum = a + f1_0.a;
+    }
+}
+class Nocycle_a_2_00020_2F1 {
+    Nocycle_a_2_00020_2G1 g1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2F1(String strObjectName) {
+        g1_0 = null;
+        a = 601;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+    }
+    void add() {
+        sum = a + g1_0.a;
+    }
+}
+class Nocycle_a_2_00020_2G1 {
+    Nocycle_a_2_00020_2H1 h1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2G1(String strObjectName) {
+        h1_0 = null;
+        a = 701;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+    }
+    void add() {
+        sum = a + h1_0.a;
+    }
+}
+class Nocycle_a_2_00020_2H1 {
+    Nocycle_a_2_00020_2I1 i1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2H1(String strObjectName) {
+        i1_0 = null;
+        a = 801;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+    }
+    void add() {
+        sum = a + i1_0.a;
+    }
+}
+class Nocycle_a_2_00020_2I1 {
+    Nocycle_a_2_00020_2J1 j1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2I1(String strObjectName) {
+        j1_0 = null;
+        a = 901;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+    }
+    void add() {
+        sum = a + j1_0.a;
+    }
+}
+class Nocycle_a_2_00020_2J1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_2J1(String strObjectName) {
+        a = 1001;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00020_3A1 {
+    Nocycle_a_2_00020_3B1 b1_0;
+    Nocycle_a_2_00020_3D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+class Nocycle_a_2_00020_3A2 {
+    Nocycle_a_2_00020_3B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+class Nocycle_a_2_00020_3A3 {
+    Nocycle_a_2_00020_3B2 b2_0;
+    Nocycle_a_2_00020_3C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+class Nocycle_a_2_00020_3A4 {
+    Nocycle_a_2_00020_3B3 b3_0;
+    Nocycle_a_2_00020_3C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+class Nocycle_a_2_00020_3B1 {
+    Nocycle_a_2_00020_3D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+class Nocycle_a_2_00020_3B2 {
+    Nocycle_a_2_00020_3C1 c1_0;
+    Nocycle_a_2_00020_3D1 d1_0;
+    Nocycle_a_2_00020_3D2 d2_0;
+    Nocycle_a_2_00020_3D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_a_2_00020_3B3 {
+    Nocycle_a_2_00020_3C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_a_2_00020_3C1 {
+    Nocycle_a_2_00020_3D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_a_2_00020_3C2 {
+    Nocycle_a_2_00020_3D2 d2_0;
+    Nocycle_a_2_00020_3D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_a_2_00020_3D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00020_3D2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_2_00020_3D3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_2_00020_3D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_a_2_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_2_00020_A1 a1_main = new Nocycle_a_2_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_2_00020_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_2_00020_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_2_00020_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_2_00020_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+        int result1 = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result1);
+        Nocycle_a_2_00020_2A1 a1_main2 = new Nocycle_a_2_00020_2A1("a1_main2");
+        a1_main2.b1_0 = new Nocycle_a_2_00020_2B1("b1_0");
+        a1_main2.b1_0.c1_0 = new Nocycle_a_2_00020_2C1("c1_0");
+        a1_main2.b1_0.c1_0.d1_0 = new Nocycle_a_2_00020_2D1("d1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_2_00020_2E1("e1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_2_00020_2F1("f1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_2_00020_2G1("g1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_2_00020_2H1("h1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_2_00020_2I1("i1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_2_00020_2J1("j1_0");
+        a1_main2.add();
+        a1_main2.b1_0.add();
+        a1_main2.b1_0.c1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+        int result2 = a1_main2.sum + a1_main2.b1_0.sum + a1_main2.b1_0.c1_0.sum + a1_main2.b1_0.c1_0.d1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+        Nocycle_a_2_00020_3A1 a1_main3 = new Nocycle_a_2_00020_3A1("a1_main3");
+        Nocycle_a_2_00020_3A2 a2_main = new Nocycle_a_2_00020_3A2("a2_main");
+        Nocycle_a_2_00020_3A3 a3_main = new Nocycle_a_2_00020_3A3("a3_main");
+        Nocycle_a_2_00020_3A4 a4_main = new Nocycle_a_2_00020_3A4("a4_main");
+        a1_main3.b1_0 = new Nocycle_a_2_00020_3B1("b1_0");
+        a1_main3.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a1_main3.b1_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a3_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a4_main.b3_0 = new Nocycle_a_2_00020_3B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a1_main3.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main3.b1_0.add();
+        a1_main3.d1_0.add();
+        a1_main3.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result3 = a1_main3.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main3.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main3.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        int result = result1 + result2 + result3;
+        if (result == 26225)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0101-rc-function-Nocycle_a_2_00020/expected.txt b/testsuite/java_test/rc_test/RC0101-rc-function-Nocycle_a_2_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0101-rc-function-Nocycle_a_2_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0101-rc-function-Nocycle_a_2_00020/test.cfg b/testsuite/java_test/rc_test/RC0101-rc-function-Nocycle_a_2_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f015c80bfecda5c6b74390d54ed8f7e3a19b5472
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0101-rc-function-Nocycle_a_2_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_a_2_00020)
+run(Nocycle_a_2_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0102-rc-function-RC_basic/RC_basic.java b/testsuite/java_test/rc_test/RC0102-rc-function-RC_basic/RC_basic.java
new file mode 100755
index 0000000000000000000000000000000000000000..9f5781a24314e5e6887ef901cf6397a707c4b832
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0102-rc-function-RC_basic/RC_basic.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class RC_basic {
+    private Object obj;
+    private String[] str;
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    public static void rc_testcase_main_wrapper() {
+        RC_basic rc = new RC_basic();
+        rc.obj = new Object();
+        rc.str = new String[10];
+        Test1();
+        Test2();
+        Test3();
+        Test4(rc);
+        Test5(rc);
+        Test6(rc);
+        Test7(rc);
+        Test8();
+        Test9();
+        Test10();
+    }
+    // simple new and recycle
+    static void Test1() {
+        RC_basic obj = new RC_basic();
+        consume(obj);
+    }
+    // new and return
+    static RC_basic Test2() {
+        RC_basic obj = new RC_basic();
+        return obj;
+    }
+    // new and consume and return
+    static Object Test3() {
+        RC_basic obj = new RC_basic();
+        consume(obj);
+        return obj;
+    }
+    // load and dec
+    static void Test4(RC_basic rc) {
+        Object obj = rc.obj;
+        consume(obj);
+    }
+    // load and dec
+    static void Test5(RC_basic rc) {
+        consume(rc.obj);
+    }
+    // load and return
+    static Object Test6(RC_basic rc) {
+        return rc.obj;
+    }
+    // load consume and return
+    static Object Test7(RC_basic rc) {
+        Object o = rc.str;
+        consume(o);
+        return o;
+    }
+    // call and consume
+    static void Test8() {
+        RC_basic obj = Test2();
+        consume(obj);
+    }
+    // call consume and return
+    static Object Test9() {
+        RC_basic obj = Test2();
+        consume(obj);
+        return obj;
+    }
+    // call and not consume
+    static void Test10() {
+        Test2();
+    }
+    public static void consume(Object obj) {
+        //System.out.println("do noting");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0102-rc-function-RC_basic/expected.txt b/testsuite/java_test/rc_test/RC0102-rc-function-RC_basic/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0102-rc-function-RC_basic/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0102-rc-function-RC_basic/test.cfg b/testsuite/java_test/rc_test/RC0102-rc-function-RC_basic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..58896951c30a538623685b11c20712bee1ba0fc9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0102-rc-function-RC_basic/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_basic)
+run(RC_basic,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0103-rc-function-RC_eh_01/RC_eh_01.java b/testsuite/java_test/rc_test/RC0103-rc-function-RC_eh_01/RC_eh_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e76e1a331bac3d9eac41903678fce92a4a95897
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0103-rc-function-RC_eh_01/RC_eh_01.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.nio.charset.IllegalCharsetNameException;
+public class RC_eh_01 {
+    static int res = 0;
+    public static void main(String argv[]) {
+        run1();
+		System.out.println("ExpectResult");
+    }
+    public static void run1() {
+        try {
+            new RC_eh_01().run2();
+        } catch (IllegalArgumentException e) {
+            RC_eh_01.res = 1;
+        }
+    }
+    public  void run2() {
+        Foo f1 = new Foo(1);
+        Foo f2 = new Foo(2);
+        run3();
+        int result=f1.i+f2.i;
+    }
+    public static void run3() {
+        try {
+            Integer.parseInt("123#456");
+        } catch (IllegalCharsetNameException e) {
+            RC_eh_01.res = 3;
+        }
+    }
+    class Foo{
+        public int i;
+        public Foo(int i){
+            this.i=i;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0103-rc-function-RC_eh_01/expected.txt b/testsuite/java_test/rc_test/RC0103-rc-function-RC_eh_01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0103-rc-function-RC_eh_01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0103-rc-function-RC_eh_01/test.cfg b/testsuite/java_test/rc_test/RC0103-rc-function-RC_eh_01/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..837110445af7b32cee92cbf66bcb17af351199bc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0103-rc-function-RC_eh_01/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_eh_01)
+run(RC_eh_01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0104-rc-function-RC_Finalize_01/RC_Finalize_01.java b/testsuite/java_test/rc_test/RC0104-rc-function-RC_Finalize_01/RC_Finalize_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..906f7f2db35815931b0f75600c514c77464e4d92
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0104-rc-function-RC_Finalize_01/RC_Finalize_01.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class C {
+    static A a;
+}
+class A {
+    B b;
+    public A(B b) {
+        this.b = b;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("A finalize");
+        C.a = this;
+    }
+}
+class B {
+    int num1;
+    int num2;
+    public B(int num1, int num2) {
+        this.num1 = num1;
+        this.num2 = num2;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("B finalize");
+    }
+    public int sum() {
+        return num1 + num2;
+    }
+}
+public class RC_Finalize_01 {
+    public static void main(String[] args) throws Exception {
+        A a = new A(new B(12, 18));
+        a = null;
+        //System.gc();
+        Thread.sleep(5000);
+		System.out.println("ExpectResult");
+}
+}
diff --git a/testsuite/java_test/rc_test/RC0104-rc-function-RC_Finalize_01/expected.txt b/testsuite/java_test/rc_test/RC0104-rc-function-RC_Finalize_01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0104-rc-function-RC_Finalize_01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0104-rc-function-RC_Finalize_01/test.cfg b/testsuite/java_test/rc_test/RC0104-rc-function-RC_Finalize_01/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..237bcc49147ccbb9f4f94a5bb7a91279546d5726
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0104-rc-function-RC_Finalize_01/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Finalize_01)
+run(RC_Finalize_01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0105-rc-function-RC_flow/RC_flow.java b/testsuite/java_test/rc_test/RC0105-rc-function-RC_flow/RC_flow.java
new file mode 100755
index 0000000000000000000000000000000000000000..38382fe899496b5d4c8c5f7e142cfb1ef93bb118
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0105-rc-function-RC_flow/RC_flow.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class RC_flow {
+    private Object obj;
+    private byte[] b;
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    public static void rc_testcase_main_wrapper() {
+        TestFlow1(21);
+        TestFlow2(30);
+        TestFlow3(56);
+    }
+    static Object TestFlow1(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = new RC_flow();
+            }
+        }
+        return rc;
+    }
+    static Object TestFlow2(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = Test2();
+            }
+        }
+        return rc;
+    }
+    static void TestFlow3(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = Test2();
+            }
+        }
+    }
+    static RC_flow Test2() {
+        RC_flow obj = new RC_flow();
+        return obj;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0105-rc-function-RC_flow/expected.txt b/testsuite/java_test/rc_test/RC0105-rc-function-RC_flow/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0105-rc-function-RC_flow/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0105-rc-function-RC_flow/test.cfg b/testsuite/java_test/rc_test/RC0105-rc-function-RC_flow/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e1bf545ee49b661b35b8d28f68d1dc0a7a7a1a70
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0105-rc-function-RC_flow/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_flow)
+run(RC_flow,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0106-rc-function-RC_multest/RC_multest.java b/testsuite/java_test/rc_test/RC0106-rc-function-RC_multest/RC_multest.java
new file mode 100755
index 0000000000000000000000000000000000000000..513261ca9f97be43c458a92b7ae7e95e64ab38ed
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0106-rc-function-RC_multest/RC_multest.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class RC_multest {
+    static Foo f;
+    private Object obj;
+    private byte[] b;
+    {
+        f = new Bar();
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        TestSimple();
+        TestParam();
+        TestFlow();
+        f = null;
+    }
+    static void TestSimple() {
+        RC_multest rc = new RC_multest();
+        rc.obj = new Object();
+        rc.b = new byte[10];
+        Test1();
+        Test2();
+        Test3();
+        Test4(rc);
+        Test5(rc);
+        Test6(rc);
+        Test7(rc);
+        Test8();
+        Test9();
+        Test10();
+    }
+    static void TestParam() {
+        RC_multest rc = new RC_multest();
+        rc.obj = new Object();
+        rc.b = new byte[10];
+        TestParam1(rc);
+        TestParam2(rc);
+        TestParam3(rc);
+    }
+    static void TestFlow() {
+        TestFlow1(21);
+        TestFlow2(30);
+    }
+    // simple new and recycle
+    static void Test1() {
+        RC_multest obj = new RC_multest();
+        consume(obj);
+    }
+    // new and return
+    static RC_multest Test2() {
+        RC_multest obj = new RC_multest();
+        return obj;
+    }
+    // new and consume and return
+    static Object Test3() {
+        RC_multest obj = new RC_multest();
+        consume(obj);
+        return obj;
+    }
+    // load and dec
+    static void Test4(RC_multest rc) {
+        Object obj = rc.obj;
+        consume(obj);
+    }
+    // load and dec
+    static void Test5(RC_multest rc) {
+        consume(rc.obj);
+    }
+    // load and return
+    static Object Test6(RC_multest rc) {
+        return rc.obj;
+    }
+    // load consume and return
+    static Object Test7(RC_multest rc) {
+        Object o = rc.b;
+        consume(o);
+        return o;
+    }
+    // call and consume
+    static void Test8() {
+        RC_multest obj = Test2();
+        consume(obj);
+    }
+    // call consume and return
+    static Object Test9() {
+        RC_multest obj = Test2();
+        consume(obj);
+        return obj;
+    }
+    // call and not consume
+    static void Test10() {
+        Test2();
+    }
+    // parameter related
+    // 1. parameter is returned
+    // 2. parameter is redefined
+    // 3. parameter is redefined conditionally
+    static Object TestParam1(RC_multest rc) {
+        consume(rc);
+        return rc;
+    }
+    static Object TestParam2(RC_multest rc) {
+        consume(rc);
+        rc = Test2();
+        return rc;
+    }
+    static Object TestParam3(RC_multest rc) {
+        consume(rc);
+        if (rc.b != null) {
+            rc = Test2();
+        }
+        return rc;
+    }
+    static Object TestParam4() {
+        RC_multest rc = new RC_multest();
+        consume_return(rc);
+        return rc;
+    }
+    // object field store
+    // local variable
+    // 1. local varaible is redefined in if/loop
+    static Object TestFlow1(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = new RC_multest();
+            }
+        }
+        return rc;
+    }
+    static Object TestFlow2(int num) {
+        Object rc = null;
+        for (int i = 1; i < num; i++) {
+            if ((i % 5) == 0) {
+                rc = Test2();
+            }
+        }
+        return rc;
+    }
+    // class info
+    // exception
+    static Object consume_return(Object obj) {
+        return obj;
+    }
+    static void consume(Object obj) {
+        f.consume(obj);
+    }
+}
+class Foo {
+    void consume(Object obj) {
+    }
+}
+class Bar extends Foo {
+    void consume(Object obj) {
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0106-rc-function-RC_multest/expected.txt b/testsuite/java_test/rc_test/RC0106-rc-function-RC_multest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0106-rc-function-RC_multest/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0106-rc-function-RC_multest/test.cfg b/testsuite/java_test/rc_test/RC0106-rc-function-RC_multest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b414125ea6d7a73333bdc19c12d67367e6f2a8fa
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0106-rc-function-RC_multest/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_multest)
+run(RC_multest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/Cycle_aDec_00010.java b/testsuite/java_test/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/Cycle_aDec_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..4518460d2ff6105d368dd59e5af219a23e5a4ee9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/Cycle_aDec_00010.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_aDec_00010_A1 {
+    Cycle_aDec_00010_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00010_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_aDec_00010_A2 {
+    Cycle_aDec_00010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00010_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_aDec_00010_A3 {
+    Cycle_aDec_00010_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00010_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_aDec_00010_A4 {
+    Cycle_aDec_00010_A1 a1_0;
+    Cycle_aDec_00010_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00010_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+class Cycle_aDec_00010_A5 {
+    Cycle_aDec_00010_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00010_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_aDec_00010_A6 {
+    Cycle_aDec_00010_A1 a1_0;
+    Cycle_aDec_00010_A4 a4_0;
+    Cycle_aDec_00010_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00010_A6(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a5_0.a;
+    }
+}
+public class Cycle_aDec_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void Modify(Cycle_aDec_00010_A1 a1_main) {
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_aDec_00010_A1 a1_main = new Cycle_aDec_00010_A1("a1_main");
+        Cycle_aDec_00010_A5 a5_main = new Cycle_aDec_00010_A5("a5_main");
+        a1_main.a2_0 = new Cycle_aDec_00010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_aDec_00010_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_aDec_00010_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_aDec_00010_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        Modify(a1_main);
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0 = null;
+        int result = a1_main.sum + a5_main.sum + a5_main.a3_0.sum + a5_main.a3_0.a4_0.sum + a5_main.a3_0.a4_0.a6_0.sum;
+        if (result == 1137)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/expected.txt b/testsuite/java_test/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/test.cfg b/testsuite/java_test/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5c96a842be9e6c8a7c1a3a59660e92e66d481d72
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0107-rc-function-RC_Dec-Cycle_aDec_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_aDec_00010)
+run(Cycle_aDec_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/Cycle_aDec_00020.java b/testsuite/java_test/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/Cycle_aDec_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..6c2cc341b6d714292ee2348e4a8440c7f4789113
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/Cycle_aDec_00020.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_aDec_00020_A1 {
+    Cycle_aDec_00020_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00020_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Cycle_aDec_00020_A2 {
+    Cycle_aDec_00020_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00020_A2(String strObjectName) {
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_aDec_00020_A3 {
+    Cycle_aDec_00020_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00020_A3(String strObjectName) {
+        a4_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_aDec_00020_A4 {
+    Cycle_aDec_00020_A1 a1_0;
+    Cycle_aDec_00020_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00020_A4(String strObjectName) {
+        a1_0 = null;
+        a6_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a6_0.a;
+    }
+}
+class Cycle_aDec_00020_A5 {
+    Cycle_aDec_00020_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00020_A5(String strObjectName) {
+        a3_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_aDec_00020_A6 {
+    Cycle_aDec_00020_A1 a1_0;
+    Cycle_aDec_00020_A4 a4_0;
+    Cycle_aDec_00020_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_aDec_00020_A6(String strObjectName) {
+        a1_0 = null;
+        a4_0 = null;
+        a5_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a4_0.a + a5_0.a;
+    }
+}
+public class Cycle_aDec_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void Modify(Cycle_aDec_00020_A1 a1_main) {
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_aDec_00020_A1 a1_main = new Cycle_aDec_00020_A1("a1_main");
+        Cycle_aDec_00020_A5 a5_main = new Cycle_aDec_00020_A5("a5_main");
+        a1_main.a2_0 = new Cycle_aDec_00020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_aDec_00020_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_aDec_00020_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_aDec_00020_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        Modify(a1_main);
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0 = null;
+        a5_main = null;
+        a1_main.add();
+        int result = a1_main.sum;
+        if (result == 202)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/expected.txt b/testsuite/java_test/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/test.cfg b/testsuite/java_test/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..da2bc93d91e570987f286b1a7b7c7a9b39ac0ca0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0108-rc-function-RC_Dec-Cycle_aDec_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_aDec_00020)
+run(Cycle_aDec_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/Cycle_BDec_00010.java b/testsuite/java_test/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/Cycle_BDec_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f1f062002077052f25e15906af749deb7b364a1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/Cycle_BDec_00010.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_BDec_00010_A1 {
+    Cycle_BDec_00010_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_BDec_00010_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_BDec_00010_A2 {
+    Cycle_BDec_00010_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_BDec_00010_A2() {
+        a1_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class Cycle_BDec_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static boolean ModifyA1(Cycle_BDec_00010_A1 a1_0) {
+        a1_0.add();
+        a1_0.a2_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 6)
+            return true;
+        else
+            return false;
+    }
+    public static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00010_A1 a1_0 = new Cycle_BDec_00010_A1();
+        a1_0.a2_0 = new Cycle_BDec_00010_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        boolean ret = ModifyA1(a1_0);
+        a1_0 = null;
+        if (ret == true && a1_0 == null)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/expected.txt b/testsuite/java_test/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/test.cfg b/testsuite/java_test/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d6281623a4a6219a6a6ccbc225c1d31736243a09
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0109-rc-function-RC_Dec-Cycle_BDec_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_BDec_00010)
+run(Cycle_BDec_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/Cycle_BDec_00020.java b/testsuite/java_test/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/Cycle_BDec_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..f991ea92d3f511c6042007bd76fb1c0dcbf7fec7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/Cycle_BDec_00020.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_BDec_00020_A1 {
+    Cycle_BDec_00020_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_BDec_00020_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_BDec_00020_A2 {
+    Cycle_BDec_00020_A3 a3_0;
+    Cycle_BDec_00020_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_BDec_00020_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_BDec_00020_A3 {
+    Cycle_BDec_00020_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_BDec_00020_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_BDec_00020_A4 {
+    int a;
+    int sum;
+    Cycle_BDec_00020_A5 a5_0;
+    Cycle_BDec_00020_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        a5_0.add();
+        sum = a + a5_0.sum;
+    }
+}
+class Cycle_BDec_00020_A5 {
+    int a;
+    int sum;
+    Cycle_BDec_00020_A5() {
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + 6;
+    }
+}
+public class Cycle_BDec_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void ModifyA1(Cycle_BDec_00020_A1 a1) {
+        a1.add();
+        a1.a2_0.add();
+        a1.a2_0.a3_0.add();
+    }
+    public static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00020_A1 a1_0 = new Cycle_BDec_00020_A1();
+        a1_0.a2_0 = new Cycle_BDec_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00020_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_BDec_00020_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_BDec_00020_A5();
+        ModifyA1(a1_0);
+        a1_0.a2_0.a4_0 = null;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int result = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum;
+        if (result == 12)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/expected.txt b/testsuite/java_test/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/test.cfg b/testsuite/java_test/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c0ff96ae15d289fd54b0b36dfaa01c57ee8dc8a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0110-rc-function-RC_Dec-Cycle_BDec_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_BDec_00020)
+run(Cycle_BDec_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/Cycle_BDec_00030.java b/testsuite/java_test/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/Cycle_BDec_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..95f4a4e0997b9d0f7c54b8c5acfc5e1bb8d5e649
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/Cycle_BDec_00030.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_BDec_00030_A1 {
+    Cycle_BDec_00030_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_BDec_00030_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_BDec_00030_A2 {
+    Cycle_BDec_00030_A3 a3_0;
+    Cycle_BDec_00030_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_BDec_00030_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_BDec_00030_A3 {
+    Cycle_BDec_00030_A1 a1_0;
+    Cycle_BDec_00030_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_BDec_00030_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_BDec_00030_A4 {
+    Cycle_BDec_00030_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_BDec_00030_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_BDec_00030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void ModifyA1(Cycle_BDec_00030_A1 a1) {
+        a1 = null;
+        a1 = new Cycle_BDec_00030_A1();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00030_A1 a1_0 = new Cycle_BDec_00030_A1();
+        a1_0.a2_0 = new Cycle_BDec_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00030_A3();
+        Cycle_BDec_00030_A4 a4_0 = new Cycle_BDec_00030_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        ModifyA1(a1_0);
+        a1_0 = null;
+        a4_0.add();
+        a4_0.a3_0.add();
+        int nsum = (a4_0.a3_0.sum + a4_0.sum);
+        if (nsum == 14)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/expected.txt b/testsuite/java_test/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/test.cfg b/testsuite/java_test/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..380ec31c9d39eb92909194743a4adb731dc03b58
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0111-rc-function-RC_Dec-Cycle_BDec_00030/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_BDec_00030)
+run(Cycle_BDec_00030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/Cycle_BDec_00040.java b/testsuite/java_test/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/Cycle_BDec_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..2e645b633dd7bd3c40c105c7c8fcc800af5db825
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/Cycle_BDec_00040.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_BDec_00040_A1 {
+    Cycle_BDec_00040_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_BDec_00040_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_BDec_00040_A2 {
+    Cycle_BDec_00040_A3 a3_0;
+    Cycle_BDec_00040_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_BDec_00040_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_BDec_00040_A3 {
+    Cycle_BDec_00040_A1 a1_0;
+    Cycle_BDec_00040_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_BDec_00040_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_BDec_00040_A4 {
+    Cycle_BDec_00040_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_BDec_00040_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_BDec_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void modifyA1(Cycle_BDec_00040_A1 a1) {
+        a1.add();
+        a1.a2_0.add();
+        a1.a2_0.a3_0.add();
+        a1.a2_0.a3_0.a4_0.add();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00040_A1 a1_0 = new Cycle_BDec_00040_A1();
+        a1_0.a2_0 = new Cycle_BDec_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00040_A3();
+        Cycle_BDec_00040_A4 a4_0 = new Cycle_BDec_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        modifyA1(a1_0);
+        a1_0 = null;
+        a4_0 = null;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/expected.txt b/testsuite/java_test/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/test.cfg b/testsuite/java_test/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..80ae3ba58a954ec3c5ef8260b17d7a2c26cffa8c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0112-rc-function-RC_Dec-Cycle_BDec_00040/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_BDec_00040)
+run(Cycle_BDec_00040,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/Cycle_BDec_00050.java b/testsuite/java_test/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/Cycle_BDec_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..47d45d40df9eba3312ec770783caa965305856c1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/Cycle_BDec_00050.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cycle_BDec_00050_A1 {
+    Cycle_BDec_00050_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_BDec_00050_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_BDec_00050_A2 {
+    Cycle_BDec_00050_A3 a3_0;
+    Cycle_BDec_00050_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_BDec_00050_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_BDec_00050_A3 {
+    Cycle_BDec_00050_A1 a1_0;
+    Cycle_BDec_00050_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_BDec_00050_A3() {
+        a1_0 = null;
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_BDec_00050_A4 {
+    Cycle_BDec_00050_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_BDec_00050_A4() {
+        a3_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class Cycle_BDec_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		System.out.println("ExpectResult");
+    }
+    private static void modifyA1(Cycle_BDec_00050_A1 a1) {
+        a1.add();
+        a1.a2_0.add();
+        a1.a2_0.a3_0.add();
+        a1.a2_0.a3_0.a4_0.add();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_BDec_00050_A1 a1_0 = new Cycle_BDec_00050_A1();
+        a1_0.a2_0 = new Cycle_BDec_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_BDec_00050_A3();
+        Cycle_BDec_00050_A4 a4_0 = new Cycle_BDec_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        modifyA1(a1_0);
+        //cancel inline by for flow
+        int sum=0;
+        for(int i=0;i<100;i++)
+            sum +=i;
+        a1_0.a2_0.a3_0.a1_0 = null;
+        a4_0.a3_0 = null;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/expected.txt b/testsuite/java_test/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/test.cfg b/testsuite/java_test/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ac328ce64cf7af5c531064089be5b7bd3dcd1f03
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0113-rc-function-RC_Dec-Cycle_BDec_00050/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_BDec_00050)
+run(Cycle_BDec_00050,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/Nocycle_aDec_00010.java b/testsuite/java_test/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/Nocycle_aDec_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..aad038e796c82333f3a3657f39991aa7c7f42a8d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/Nocycle_aDec_00010.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_aDec_00010_A1 {
+    Nocycle_aDec_00010_B1 b1_0;
+    Nocycle_aDec_00010_B2 b2_0;
+    Nocycle_aDec_00010_B3 b3_0;
+    Nocycle_aDec_00010_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00010_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+class Nocycle_aDec_00010_B1 {
+    Nocycle_aDec_00010_C1 c1_0;
+    Nocycle_aDec_00010_C2 c2_0;
+    Nocycle_aDec_00010_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00010_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+class Nocycle_aDec_00010_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00010_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00010_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00010_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00010_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00010_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00010_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00010_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00010_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00010_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00010_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00010_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_aDec_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00010_A1 a1_main = new Nocycle_aDec_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_aDec_00010_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_aDec_00010_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_aDec_00010_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_aDec_00010_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_aDec_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_aDec_00010_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_aDec_00010_B4("b4_0");
+        Nocycle_aDec_00010_A1 a1_copy = modifyA1(a1_main);
+        a1_main = null;
+        a1_copy.add();
+        a1_copy.b1_0.add();
+        a1_copy.b2_0.add();
+        a1_copy.b3_0.add();
+        a1_copy.b4_0.add();
+        a1_copy.b1_0.c1_0.add();
+        a1_copy.b1_0.c2_0.add();
+        a1_copy.b1_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_copy.sum+a1_copy.b1_0.sum+a1_copy.b2_0.sum+a1_copy.b3_0.sum+a1_copy.b4_0.sum+a1_copy.b1_0.c1_0.sum+a1_copy.b1_0.c2_0.sum+a1_copy.b1_0.c3_0.sum);
+        int result = a1_copy.sum + a1_copy.b1_0.sum + a1_copy.b2_0.sum + a1_copy.b3_0.sum + a1_copy.b4_0.sum + a1_copy.b1_0.c1_0.sum + a1_copy.b1_0.c2_0.sum + a1_copy.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5049)
+            System.out.println("ExpectResult");
+    }
+    public static Nocycle_aDec_00010_A1 modifyA1(Nocycle_aDec_00010_A1 a1) {
+        a1.a = 102;
+        return a1;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/expected.txt b/testsuite/java_test/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/test.cfg b/testsuite/java_test/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..de2682dd99b4319b79fbebc9deb9fdabadd59ce6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0114-rc-function-RC_Dec-Nocycle_aDec_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_aDec_00010)
+run(Nocycle_aDec_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/Nocycle_aDec_00020.java b/testsuite/java_test/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/Nocycle_aDec_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..f95d7329347adbaa48bd86e106595cfb8bfe6578
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/Nocycle_aDec_00020.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_aDec_00020_A1 {
+    Nocycle_aDec_00020_B1 b1_0;
+    Nocycle_aDec_00020_B2 b2_0;
+    Nocycle_aDec_00020_B3 b3_0;
+    Nocycle_aDec_00020_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00020_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+class Nocycle_aDec_00020_B1 {
+    Nocycle_aDec_00020_C1 c1_0;
+    Nocycle_aDec_00020_C2 c2_0;
+    Nocycle_aDec_00020_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00020_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + c2_0.a + c3_0.a;
+    }
+}
+class Nocycle_aDec_00020_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00020_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00020_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00020_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00020_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00020_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00020_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00020_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00020_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00020_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00020_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00020_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_aDec_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00020_A1 a1_main = new Nocycle_aDec_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_aDec_00020_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_aDec_00020_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_aDec_00020_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_aDec_00020_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_aDec_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_aDec_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_aDec_00020_B4("b4_0");
+        modifyB1(a1_main.b1_0);
+        a1_main.b1_0 = null;
+        a1_main.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        int result = a1_main.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum;
+        if (result == 1928)
+            System.out.println("ExpectResult");
+    }
+    public static void modifyB1(Nocycle_aDec_00020_B1 b1) {
+        b1.a = 202;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/expected.txt b/testsuite/java_test/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/test.cfg b/testsuite/java_test/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c33656efe7d7f12502c7a1e5034d52640f69263c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0115-rc-function-RC_Dec-Nocycle_aDec_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_aDec_00020)
+run(Nocycle_aDec_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/Nocycle_aDec_00030.java b/testsuite/java_test/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/Nocycle_aDec_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..0bb8b664285fc7a254ec197cfeb97d72c92d1503
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/Nocycle_aDec_00030.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_aDec_00030_A1 {
+    Nocycle_aDec_00030_B1 b1_0;
+    Nocycle_aDec_00030_B2 b2_0;
+    Nocycle_aDec_00030_B3 b3_0;
+    Nocycle_aDec_00030_B4 b4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00030_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        b3_0 = null;
+        b4_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+    }
+}
+class Nocycle_aDec_00030_B1 {
+    Nocycle_aDec_00030_C1 c1_0;
+    Nocycle_aDec_00030_C2 c2_0;
+    Nocycle_aDec_00030_C3 c3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00030_B1(String strObjectName) {
+        c1_0 = null;
+        c2_0 = null;
+        c3_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + c2_0.a;
+    }
+}
+class Nocycle_aDec_00030_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00030_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00030_B3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00030_B3(String strObjectName) {
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00030_B4 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00030_B4(String strObjectName) {
+        a = 204;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00030_C1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00030_C1(String strObjectName) {
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00030_C2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00030_C2(String strObjectName) {
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00030_C3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00030_C3(String strObjectName) {
+        a = 303;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_aDec_00030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00030_A1 a1_main = new Nocycle_aDec_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_aDec_00030_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_aDec_00030_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_aDec_00030_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_aDec_00030_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_aDec_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_aDec_00030_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_aDec_00030_B4("b4_0");
+        modifyC3(a1_main.b1_0.c3_0);
+        a1_main.b1_0.c3_0 = null;
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum;
+        if (result == 4139)
+            System.out.println("ExpectResult");
+    }
+    public static void modifyC3(Nocycle_aDec_00030_C3 c3) {
+        c3.a += 1;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/expected.txt b/testsuite/java_test/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/test.cfg b/testsuite/java_test/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e88dfe8b02cb0cace014e64b15612c8d4fbb7f1e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0116-rc-function-RC_Dec-Nocycle_aDec_00030/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_aDec_00030)
+run(Nocycle_aDec_00030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/Nocycle_aDec_00040.java b/testsuite/java_test/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/Nocycle_aDec_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..2ca13e19440d943bced0424336cf3a73ab6ea00c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/Nocycle_aDec_00040.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_aDec_00040_A1 {
+    Nocycle_aDec_00040_B1 b1_0;
+    Nocycle_aDec_00040_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+class Nocycle_aDec_00040_A2 {
+    Nocycle_aDec_00040_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+class Nocycle_aDec_00040_A3 {
+    Nocycle_aDec_00040_B2 b2_0;
+    Nocycle_aDec_00040_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+class Nocycle_aDec_00040_A4 {
+    Nocycle_aDec_00040_B3 b3_0;
+    Nocycle_aDec_00040_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+class Nocycle_aDec_00040_B1 {
+    Nocycle_aDec_00040_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+class Nocycle_aDec_00040_B2 {
+    Nocycle_aDec_00040_C1 c1_0;
+    Nocycle_aDec_00040_D1 d1_0;
+    Nocycle_aDec_00040_D2 d2_0;
+    Nocycle_aDec_00040_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_aDec_00040_B3 {
+    Nocycle_aDec_00040_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_aDec_00040_C1 {
+    Nocycle_aDec_00040_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_aDec_00040_C2 {
+    Nocycle_aDec_00040_D2 d2_0;
+    Nocycle_aDec_00040_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_aDec_00040_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00040_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00040_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00040_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_aDec_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00040_A1 a1_main = new Nocycle_aDec_00040_A1("a1_main");
+        Nocycle_aDec_00040_A2 a2_main = new Nocycle_aDec_00040_A2("a2_main");
+        Nocycle_aDec_00040_A3 a3_main = new Nocycle_aDec_00040_A3("a3_main");
+        Nocycle_aDec_00040_A4 a4_main = new Nocycle_aDec_00040_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_aDec_00040_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_aDec_00040_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_aDec_00040_D2("d2_0");
+        a2_main.b2_0 = new Nocycle_aDec_00040_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_aDec_00040_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = new Nocycle_aDec_00040_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_aDec_00040_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a2_main.b2_0.c1_0.d1_0;
+        a3_main.b2_0.d1_0 = a2_main.b2_0.d1_0;
+        a3_main.b2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+        a3_main.c2_0 = new Nocycle_aDec_00040_C2("c2_0");
+        a3_main.c2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.c2_0.d3_0 = new Nocycle_aDec_00040_D3("d3_0");
+        a4_main.b3_0 = new Nocycle_aDec_00040_B3("b3_0");
+        a4_main.b3_0.c1_0 = a3_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a3_main.b2_0.c1_0.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a3_main.c2_0.d2_0;
+        a4_main.c2_0.d3_0 = a3_main.c2_0.d3_0;
+        modifyA1(a1_main);
+        a1_main = null;
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result = a2_main.sum + a3_main.sum + a4_main.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a4_main.b3_0.c1_0.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        if (result == 7954)
+            System.out.println("ExpectResult");
+    }
+    private static void modifyA1(Nocycle_aDec_00040_A1 a1) {
+        a1.a += 1;
+        a1.add();
+        a1.b1_0.add();
+        a1.d1_0.add();
+        a1.b1_0.d2_0.add();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/expected.txt b/testsuite/java_test/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/test.cfg b/testsuite/java_test/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..91b56843744815ec430c3827f90d0c3581da5e96
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0117-rc-function-RC_Dec-Nocycle_aDec_00040/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_aDec_00040)
+run(Nocycle_aDec_00040,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/Nocycle_aDec_00050.java b/testsuite/java_test/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/Nocycle_aDec_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..25d60cb0fd7ea8337cf3003c0d297be7a01a8627
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/Nocycle_aDec_00050.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_aDec_00050_A1 {
+    Nocycle_aDec_00050_B1 b1_0;
+    Nocycle_aDec_00050_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+class Nocycle_aDec_00050_A2 {
+    Nocycle_aDec_00050_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00050_A3 {
+    Nocycle_aDec_00050_B2 b2_0;
+    Nocycle_aDec_00050_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + c2_0.a;
+    }
+}
+class Nocycle_aDec_00050_A4 {
+    Nocycle_aDec_00050_B3 b3_0;
+    Nocycle_aDec_00050_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+class Nocycle_aDec_00050_B1 {
+    Nocycle_aDec_00050_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+class Nocycle_aDec_00050_B2 {
+    Nocycle_aDec_00050_C1 c1_0;
+    Nocycle_aDec_00050_D1 d1_0;
+    Nocycle_aDec_00050_D2 d2_0;
+    Nocycle_aDec_00050_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_aDec_00050_B3 {
+    Nocycle_aDec_00050_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_aDec_00050_C1 {
+    Nocycle_aDec_00050_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_aDec_00050_C2 {
+    Nocycle_aDec_00050_D2 d2_0;
+    Nocycle_aDec_00050_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_aDec_00050_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00050_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00050_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00050_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_aDec_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00050_A1 a1_main = new Nocycle_aDec_00050_A1("a1_main");
+        Nocycle_aDec_00050_A2 a2_main = new Nocycle_aDec_00050_A2("a2_main");
+        Nocycle_aDec_00050_A3 a3_main = new Nocycle_aDec_00050_A3("a3_main");
+        Nocycle_aDec_00050_A4 a4_main = new Nocycle_aDec_00050_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_aDec_00050_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_aDec_00050_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_aDec_00050_D2("d2_0");
+        a2_main.b2_0 = new Nocycle_aDec_00050_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_aDec_00050_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = new Nocycle_aDec_00050_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_aDec_00050_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a2_main.b2_0.c1_0.d1_0;
+        a3_main.b2_0.d1_0 = a2_main.b2_0.d1_0;
+        a3_main.b2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+        a3_main.c2_0 = new Nocycle_aDec_00050_C2("c2_0");
+        a3_main.c2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.c2_0.d3_0 = new Nocycle_aDec_00050_D3("d3_0");
+        a4_main.b3_0 = new Nocycle_aDec_00050_B3("b3_0");
+        a4_main.b3_0.c1_0 = a3_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a3_main.b2_0.c1_0.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a3_main.c2_0.d2_0;
+        a4_main.c2_0.d3_0 = a3_main.c2_0.d3_0;
+        modifyB2(a2_main.b2_0);
+        a2_main.b2_0 = null;
+        a3_main.b2_0 = null;
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a4_main.b3_0.sum + a4_main.b3_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        if (result == 7249)
+            System.out.println("ExpectResult");
+    }
+    private static void modifyB2(Nocycle_aDec_00050_B2 b2) {
+        b2.a += 1;
+        b2.add();
+        b2.c1_0.add();
+        b2.d1_0.add();
+        b2.d2_0.add();
+        b2.d3_0.add();
+        b2.c1_0.d1_0.add();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/expected.txt b/testsuite/java_test/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/test.cfg b/testsuite/java_test/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1f3e1d691e02153f8d2c96f089ab74d6d71542dc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0118-rc-function-RC_Dec-Nocycle_aDec_00050/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_aDec_00050)
+run(Nocycle_aDec_00050,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/Nocycle_aDec_00060.java b/testsuite/java_test/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/Nocycle_aDec_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..361995cdb0427cc448b6c48e730c5a2291ece947
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/Nocycle_aDec_00060.java
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Nocycle_aDec_00060_A1 {
+    Nocycle_aDec_00060_B1 b1_0;
+    Nocycle_aDec_00060_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+class Nocycle_aDec_00060_A2 {
+    Nocycle_aDec_00060_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+class Nocycle_aDec_00060_A3 {
+    Nocycle_aDec_00060_B2 b2_0;
+    Nocycle_aDec_00060_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+class Nocycle_aDec_00060_A4 {
+    Nocycle_aDec_00060_B3 b3_0;
+    Nocycle_aDec_00060_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+class Nocycle_aDec_00060_B1 {
+    Nocycle_aDec_00060_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+class Nocycle_aDec_00060_B2 {
+    Nocycle_aDec_00060_C1 c1_0;
+    Nocycle_aDec_00060_D1 d1_0;
+    Nocycle_aDec_00060_D2 d2_0;
+    Nocycle_aDec_00060_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_aDec_00060_B3 {
+    Nocycle_aDec_00060_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_aDec_00060_C1 {
+    Nocycle_aDec_00060_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_aDec_00060_C2 {
+    Nocycle_aDec_00060_D2 d2_0;
+    Nocycle_aDec_00060_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_aDec_00060_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00060_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_aDec_00060_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_aDec_00060_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class Nocycle_aDec_00060 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_aDec_00060_A1 a1_main = new Nocycle_aDec_00060_A1("a1_main");
+        Nocycle_aDec_00060_A2 a2_main = new Nocycle_aDec_00060_A2("a2_main");
+        Nocycle_aDec_00060_A3 a3_main = new Nocycle_aDec_00060_A3("a3_main");
+        Nocycle_aDec_00060_A4 a4_main = new Nocycle_aDec_00060_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_aDec_00060_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_aDec_00060_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_aDec_00060_D2("d2_0");
+        a2_main.b2_0 = new Nocycle_aDec_00060_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_aDec_00060_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = new Nocycle_aDec_00060_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_aDec_00060_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a2_main.b2_0.c1_0.d1_0;
+        a3_main.b2_0.d1_0 = a2_main.b2_0.d1_0;
+        a3_main.b2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+        a3_main.c2_0 = new Nocycle_aDec_00060_C2("c2_0");
+        a3_main.c2_0.d2_0 = a2_main.b2_0.d2_0;
+        a3_main.c2_0.d3_0 = new Nocycle_aDec_00060_D3("d3_0");
+        a4_main.b3_0 = new Nocycle_aDec_00060_B3("b3_0");
+        a4_main.b3_0.c1_0 = a3_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a3_main.b2_0.c1_0.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a3_main.c2_0.d2_0;
+        a4_main.c2_0.d3_0 = a3_main.c2_0.d3_0;
+        ModifyA1(a1_main);
+        ModifyA2(a2_main);
+        ModifyA3(a3_main);
+        a4_main.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result = a4_main.sum + a4_main.b3_0.sum + a4_main.b3_0.c1_0.sum + a4_main.c2_0.sum + a4_main.b3_0.c1_0.d1_0.sum + a4_main.c2_0.d2_0.sum + a4_main.c2_0.d3_0.sum;
+        if (result == 5334)
+            System.out.println("ExpectResult");
+    }
+    private static void ModifyA1(Nocycle_aDec_00060_A1 a1) {
+        a1.a += 1;
+        a1.add();
+        a1.b1_0.add();
+        a1.d1_0.add();
+        a1.b1_0.d2_0.add();
+    }
+    private static void ModifyA2(Nocycle_aDec_00060_A2 a2) {
+        a2.a += 1;
+        a2.add();
+        a2.b2_0.add();
+        a2.b2_0.c1_0.add();
+        a2.b2_0.d1_0.add();
+        a2.b2_0.d2_0.add();
+        a2.b2_0.d3_0.add();
+        a2.b2_0.c1_0.d1_0.add();
+    }
+    private static void ModifyA3(Nocycle_aDec_00060_A3 a3) {
+        a3.a += 1;
+        a3.add();
+        a3.b2_0.add();
+        a3.b2_0.c1_0.add();
+        a3.b2_0.c1_0.d1_0.add();
+        a3.b2_0.d1_0.add();
+        a3.b2_0.d2_0.add();
+        a3.b2_0.d3_0.add();
+        a3.c2_0.add();
+        a3.c2_0.d2_0.add();
+        a3.c2_0.d3_0.add();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/expected.txt b/testsuite/java_test/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/test.cfg b/testsuite/java_test/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..15685de1e8b44b25e512b0a61db24df2c0e95eee
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0119-rc-function-RC_Dec-Nocycle_aDec_00060/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_aDec_00060)
+run(Nocycle_aDec_00060,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/Cycle_am_00180.java b/testsuite/java_test/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/Cycle_am_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..b1ecf69936eab8a6302e458a356b96882522c0ed
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/Cycle_am_00180.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00180 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00180_A1 a1_main = new Cycle_a_00180_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00180_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00180_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00180_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00180_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00180_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a8_0 = new Cycle_a_00180_A8("a8_0");
+        a1_main.a8_0.a9_0 = new Cycle_a_00180_A9("a9_0");
+        a1_main.a8_0.a9_0.a7_0 = new Cycle_a_00180_A7("a7_0");
+        a1_main.a8_0.a9_0.a7_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_main.a8_0.add();
+        a1_main.a8_0.a9_0.add();
+        a1_main.a8_0.a9_0.a7_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_main.a8_0.sum + a1_main.a8_0.a9_0.sum + a1_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1994)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00180_A1 {
+        Cycle_a_00180_A2 a2_0;
+        Cycle_a_00180_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A1(String strObjectName) {
+            a2_0 = null;
+            a8_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00180_A2 {
+        Cycle_a_00180_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00180_A3 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00180_A4 {
+        Cycle_a_00180_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00180_A5 {
+        Cycle_a_00180_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00180_A6 {
+        Cycle_a_00180_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A6(String strObjectName) {
+            a1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00180_A7 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A7(String strObjectName) {
+            a4_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00180_A8 {
+        Cycle_a_00180_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_00180_A9 {
+        Cycle_a_00180_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+public class Cycle_am_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00180 A1_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A2_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A3_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A4_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A5_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        ThreadRc_Cycle_am_00180 A6_Cycle_am_00180 = new ThreadRc_Cycle_am_00180();
+        A1_Cycle_am_00180.start();
+        A2_Cycle_am_00180.start();
+        A3_Cycle_am_00180.start();
+        A4_Cycle_am_00180.start();
+        A5_Cycle_am_00180.start();
+        A6_Cycle_am_00180.start();
+        try {
+            A1_Cycle_am_00180.join();
+            A2_Cycle_am_00180.join();
+            A3_Cycle_am_00180.join();
+            A4_Cycle_am_00180.join();
+            A5_Cycle_am_00180.join();
+            A6_Cycle_am_00180.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00180.check() && A2_Cycle_am_00180.check() && A3_Cycle_am_00180.check() && A4_Cycle_am_00180.check() && A5_Cycle_am_00180.check() && A6_Cycle_am_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/expected.txt b/testsuite/java_test/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/test.cfg b/testsuite/java_test/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dbd08ca878d22a6af096e795d65d1c0c0f822bf2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0120-rc-function-RC_Thread01-Cycle_am_00180/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00180)
+run(Cycle_am_00180,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/Cycle_am_00190.java b/testsuite/java_test/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/Cycle_am_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..f9c88a49eeb868239f640060799d0c495e2cc735
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/Cycle_am_00190.java
@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00190 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00190_A1 a1_main = new Cycle_a_00190_A1("a1_main");
+        Cycle_a_00190_A10 a10_main = new Cycle_a_00190_A10("a10_main");
+        a1_main.a2_0 = new Cycle_a_00190_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00190_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00190_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00190_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00190_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_main;
+        a10_main.a8_0 = new Cycle_a_00190_A8("a8_0");
+        a10_main.a8_0.a9_0 = new Cycle_a_00190_A9("a9_0");
+        a10_main.a8_0.a9_0.a7_0 = new Cycle_a_00190_A7("a7_0");
+        a10_main.a8_0.a9_0.a7_0.a5_0 = a1_main.a2_0.a3_0.a4_0.a5_0;
+        a1_main.add();
+        a10_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_main.a8_0.add();
+        a10_main.a8_0.a9_0.add();
+        a10_main.a8_0.a9_0.a7_0.add();
+        int result = a1_main.sum + a10_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_main.a8_0.sum + a10_main.a8_0.a9_0.sum + a10_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2215)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00190_A1 {
+        Cycle_a_00190_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00190_A2 {
+        Cycle_a_00190_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00190_A3 {
+        Cycle_a_00190_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00190_A4 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00190_A5 {
+        Cycle_a_00190_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00190_A6 {
+        Cycle_a_00190_A1 a1_0;
+        Cycle_a_00190_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A6(String strObjectName) {
+            a1_0 = null;
+            a10_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+    class Cycle_a_00190_A7 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A7(String strObjectName) {
+            a5_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00190_A8 {
+        Cycle_a_00190_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_00190_A9 {
+        Cycle_a_00190_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00190_A10 {
+        Cycle_a_00190_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A10(String strObjectName) {
+            a8_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+public class Cycle_am_00190 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00190 A1_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A2_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A3_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A4_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A5_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        ThreadRc_Cycle_am_00190 A6_Cycle_am_00190 = new ThreadRc_Cycle_am_00190();
+        A1_Cycle_am_00190.start();
+        A2_Cycle_am_00190.start();
+        A3_Cycle_am_00190.start();
+        A4_Cycle_am_00190.start();
+        A5_Cycle_am_00190.start();
+        A6_Cycle_am_00190.start();
+        try {
+            A1_Cycle_am_00190.join();
+            A2_Cycle_am_00190.join();
+            A3_Cycle_am_00190.join();
+            A4_Cycle_am_00190.join();
+            A5_Cycle_am_00190.join();
+            A6_Cycle_am_00190.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00190.check() && A2_Cycle_am_00190.check() && A3_Cycle_am_00190.check() && A4_Cycle_am_00190.check() && A5_Cycle_am_00190.check() && A6_Cycle_am_00190.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/expected.txt b/testsuite/java_test/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/test.cfg b/testsuite/java_test/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..667a269173669fd670d625d9ab19c9c2e039ef60
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0121-rc-function-RC_Thread01-Cycle_am_00190/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00190)
+run(Cycle_am_00190,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/Cycle_am_00200.java b/testsuite/java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/Cycle_am_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..f617118c721ec8ceeb150baeaf7c2218f468b072
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/Cycle_am_00200.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00200 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00200_A1 a1_main = new Cycle_a_00200_A1("a1_main");
+        Cycle_a_00200_A4 a4_main = new Cycle_a_00200_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00200_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00200_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00200_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a6_0 = new Cycle_a_00200_A6("a6_0");
+        a1_main.a2_0.a6_0.a7_0 = new Cycle_a_00200_A7("a7_0");
+        a1_main.a2_0.a7_0 = a1_main.a2_0.a6_0.a7_0;
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a6_0.add();
+        a1_main.a2_0.a6_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a6_0.sum + a1_main.a2_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00200_A1 {
+        Cycle_a_00200_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00200_A2 {
+        Cycle_a_00200_A3 a3_0;
+        Cycle_a_00200_A6 a6_0;
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A2(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00200_A3 {
+        Cycle_a_00200_A1 a1_0;
+        Cycle_a_00200_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00200_A4 {
+        Cycle_a_00200_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00200_A5 {
+        Cycle_a_00200_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00200_A6 {
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00200_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Cycle_am_00200 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00200 A1_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A2_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A3_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A4_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A5_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        ThreadRc_Cycle_am_00200 A6_Cycle_am_00200 = new ThreadRc_Cycle_am_00200();
+        A1_Cycle_am_00200.start();
+        A2_Cycle_am_00200.start();
+        A3_Cycle_am_00200.start();
+        A4_Cycle_am_00200.start();
+        A5_Cycle_am_00200.start();
+        A6_Cycle_am_00200.start();
+        try {
+            A1_Cycle_am_00200.join();
+            A2_Cycle_am_00200.join();
+            A3_Cycle_am_00200.join();
+            A4_Cycle_am_00200.join();
+            A5_Cycle_am_00200.join();
+            A6_Cycle_am_00200.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00200.check() && A2_Cycle_am_00200.check() && A3_Cycle_am_00200.check() && A4_Cycle_am_00200.check() && A5_Cycle_am_00200.check() && A6_Cycle_am_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/expected.txt b/testsuite/java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/test.cfg b/testsuite/java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6e9621f72aa69676fc229f5a7f6daac8b4bc1417
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0122-rc-function-RC_Thread01-Cycle_am_00200/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00200)
+run(Cycle_am_00200,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/Cycle_am_00210.java b/testsuite/java_test/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/Cycle_am_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..5b3deca822aba9b3671ab386022728918136fd36
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/Cycle_am_00210.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00210 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00210_A1 a1_main = new Cycle_a_00210_A1("a1_main");
+        Cycle_a_00210_A4 a4_main = new Cycle_a_00210_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00210_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00210_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00210_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00210_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0 = new Cycle_a_00210_A7("a7_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        a1_main.a2_0.a3_0.a6_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a6_0.sum + a1_main.a2_0.a3_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1662)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00210_A1 {
+        Cycle_a_00210_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00210_A2 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00210_A3 {
+        Cycle_a_00210_A1 a1_0;
+        Cycle_a_00210_A5 a5_0;
+        Cycle_a_00210_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00210_A4 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00210_A5 {
+        Cycle_a_00210_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00210_A6 {
+        Cycle_a_00210_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00210_A7 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_am_00210 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00210 A1_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A2_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A3_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A4_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A5_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        ThreadRc_Cycle_am_00210 A6_Cycle_am_00210 = new ThreadRc_Cycle_am_00210();
+        A1_Cycle_am_00210.start();
+        A2_Cycle_am_00210.start();
+        A3_Cycle_am_00210.start();
+        A4_Cycle_am_00210.start();
+        A5_Cycle_am_00210.start();
+        A6_Cycle_am_00210.start();
+        try {
+            A1_Cycle_am_00210.join();
+            A2_Cycle_am_00210.join();
+            A3_Cycle_am_00210.join();
+            A4_Cycle_am_00210.join();
+            A5_Cycle_am_00210.join();
+            A6_Cycle_am_00210.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00210.check() && A2_Cycle_am_00210.check() && A3_Cycle_am_00210.check() && A4_Cycle_am_00210.check() && A5_Cycle_am_00210.check() && A6_Cycle_am_00210.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/expected.txt b/testsuite/java_test/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/test.cfg b/testsuite/java_test/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8983a4e92ba273586daa9f3e0e9687f871c721a4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0123-rc-function-RC_Thread01-Cycle_am_00210/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00210)
+run(Cycle_am_00210,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/Cycle_am_00220.java b/testsuite/java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/Cycle_am_00220.java
new file mode 100755
index 0000000000000000000000000000000000000000..38765c1e085300458e4c4535b66ae979771f70ef
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/Cycle_am_00220.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00220 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00220_A1 a1_main = new Cycle_a_00220_A1("a1_main");
+        Cycle_a_00220_A4 a4_main = new Cycle_a_00220_A4("a4_main");
+        Cycle_a_00220_A6 a6_main = new Cycle_a_00220_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00220_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00220_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00220_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_00220_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1772)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00220_A1 {
+        Cycle_a_00220_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00220_A2 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00220_A3 {
+        Cycle_a_00220_A1 a1_0;
+        Cycle_a_00220_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00220_A4 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00220_A5 {
+        Cycle_a_00220_A4 a4_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00220_A6 {
+        Cycle_a_00220_A5 a5_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00220_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Cycle_am_00220 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00220 A1_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A2_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A3_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A4_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A5_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        ThreadRc_Cycle_am_00220 A6_Cycle_am_00220 = new ThreadRc_Cycle_am_00220();
+        A1_Cycle_am_00220.start();
+        A2_Cycle_am_00220.start();
+        A3_Cycle_am_00220.start();
+        A4_Cycle_am_00220.start();
+        A5_Cycle_am_00220.start();
+        A6_Cycle_am_00220.start();
+        try {
+            A1_Cycle_am_00220.join();
+            A2_Cycle_am_00220.join();
+            A3_Cycle_am_00220.join();
+            A4_Cycle_am_00220.join();
+            A5_Cycle_am_00220.join();
+            A6_Cycle_am_00220.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00220.check() && A2_Cycle_am_00220.check() && A3_Cycle_am_00220.check() && A4_Cycle_am_00220.check() && A5_Cycle_am_00220.check() && A6_Cycle_am_00220.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/expected.txt b/testsuite/java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/test.cfg b/testsuite/java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6469abd2d45b810b1f6807289194beef6c35ce5e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0124-rc-function-RC_Thread01-Cycle_am_00220/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00220)
+run(Cycle_am_00220,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/Cycle_am_00230.java b/testsuite/java_test/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/Cycle_am_00230.java
new file mode 100755
index 0000000000000000000000000000000000000000..f9baf13258eef4ffbb592f2b17ca63835837deb7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/Cycle_am_00230.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00230 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00230_A1 a1_main = new Cycle_a_00230_A1("a1_main");
+        Cycle_a_00230_A5 a5_main = new Cycle_a_00230_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00230_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00230_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00230_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a7_0 = new Cycle_a_00230_A7("a7_0");
+        a5_main.a6_0 = new Cycle_a_00230_A6("a6_0");
+        a5_main.a6_0.a7_0 = a5_main.a7_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a5_main.a7_0.add();
+        a5_main.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a5_main.a6_0.sum + a5_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00230_A1 {
+        Cycle_a_00230_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00230_A2 {
+        Cycle_a_00230_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00230_A3 {
+        Cycle_a_00230_A1 a1_0;
+        Cycle_a_00230_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00230_A4 {
+        Cycle_a_00230_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00230_A5 {
+        Cycle_a_00230_A3 a3_0;
+        Cycle_a_00230_A6 a6_0;
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A5(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00230_A6 {
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00230_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Cycle_am_00230 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00230 A1_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A2_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A3_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A4_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A5_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        ThreadRc_Cycle_am_00230 A6_Cycle_am_00230 = new ThreadRc_Cycle_am_00230();
+        A1_Cycle_am_00230.start();
+        A2_Cycle_am_00230.start();
+        A3_Cycle_am_00230.start();
+        A4_Cycle_am_00230.start();
+        A5_Cycle_am_00230.start();
+        A6_Cycle_am_00230.start();
+        try {
+            A1_Cycle_am_00230.join();
+            A2_Cycle_am_00230.join();
+            A3_Cycle_am_00230.join();
+            A4_Cycle_am_00230.join();
+            A5_Cycle_am_00230.join();
+            A6_Cycle_am_00230.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00230.check() && A2_Cycle_am_00230.check() && A3_Cycle_am_00230.check() && A4_Cycle_am_00230.check() && A5_Cycle_am_00230.check() && A6_Cycle_am_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/expected.txt b/testsuite/java_test/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/test.cfg b/testsuite/java_test/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2472774050487df3030b4c32a222c542be089cc7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0125-rc-function-RC_Thread01-Cycle_am_00230/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00230)
+run(Cycle_am_00230,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/Cycle_am_00240.java b/testsuite/java_test/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/Cycle_am_00240.java
new file mode 100755
index 0000000000000000000000000000000000000000..d1e321fc27f5acba334e523870ce1805ba715d03
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/Cycle_am_00240.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00240 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00240_A1 a1_main = new Cycle_a_00240_A1("a1_main");
+        Cycle_a_00240_A5 a5_main = new Cycle_a_00240_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00240_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00240_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a6_0 = new Cycle_a_00240_A6("a6_0");
+        a1_main.a6_0.a7_0 = new Cycle_a_00240_A7("a7_0");
+        a1_main.a6_0.a7_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a6_0.add();
+        a1_main.a6_0.a7_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a6_0.sum + a1_main.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1660)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00240_A1 {
+        Cycle_a_00240_A2 a2_0;
+        Cycle_a_00240_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A1(String strObjectName) {
+            a2_0 = null;
+            a6_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00240_A2 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00240_A3 {
+        Cycle_a_00240_A1 a1_0;
+        Cycle_a_00240_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00240_A4 {
+        Cycle_a_00240_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00240_A5 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00240_A6 {
+        Cycle_a_00240_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00240_A7 {
+        Cycle_a_00240_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A7(String strObjectName) {
+            a1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_am_00240 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00240 A1_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A2_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A3_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A4_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A5_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        ThreadRc_Cycle_am_00240 A6_Cycle_am_00240 = new ThreadRc_Cycle_am_00240();
+        A1_Cycle_am_00240.start();
+        A2_Cycle_am_00240.start();
+        A3_Cycle_am_00240.start();
+        A4_Cycle_am_00240.start();
+        A5_Cycle_am_00240.start();
+        A6_Cycle_am_00240.start();
+        try {
+            A1_Cycle_am_00240.join();
+            A2_Cycle_am_00240.join();
+            A3_Cycle_am_00240.join();
+            A4_Cycle_am_00240.join();
+            A5_Cycle_am_00240.join();
+            A6_Cycle_am_00240.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00240.check() && A2_Cycle_am_00240.check() && A3_Cycle_am_00240.check() && A4_Cycle_am_00240.check() && A5_Cycle_am_00240.check() && A6_Cycle_am_00240.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/expected.txt b/testsuite/java_test/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/test.cfg b/testsuite/java_test/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0f3139604a9f5bc46df281662260843522192e3c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0126-rc-function-RC_Thread01-Cycle_am_00240/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00240)
+run(Cycle_am_00240,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/Cycle_am_00250.java b/testsuite/java_test/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/Cycle_am_00250.java
new file mode 100755
index 0000000000000000000000000000000000000000..24999b7054c7849af12b837c91ccec88dac65913
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/Cycle_am_00250.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00250 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00250_A1 a1_main = new Cycle_a_00250_A1("a1_main");
+        Cycle_a_00250_A6 a6_main = new Cycle_a_00250_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00250_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00250_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00250_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1238)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00250_A1 {
+        Cycle_a_00250_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00250_A2 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00250_A3 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00250_A5 {
+        Cycle_a_00250_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00250_A6 {
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_am_00250 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00250 A1_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A2_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A3_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A4_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A5_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        ThreadRc_Cycle_am_00250 A6_Cycle_am_00250 = new ThreadRc_Cycle_am_00250();
+        A1_Cycle_am_00250.start();
+        A2_Cycle_am_00250.start();
+        A3_Cycle_am_00250.start();
+        A4_Cycle_am_00250.start();
+        A5_Cycle_am_00250.start();
+        A6_Cycle_am_00250.start();
+        try {
+            A1_Cycle_am_00250.join();
+            A2_Cycle_am_00250.join();
+            A3_Cycle_am_00250.join();
+            A4_Cycle_am_00250.join();
+            A5_Cycle_am_00250.join();
+            A6_Cycle_am_00250.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00250.check() && A2_Cycle_am_00250.check() && A3_Cycle_am_00250.check() && A4_Cycle_am_00250.check() && A5_Cycle_am_00250.check() && A6_Cycle_am_00250.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/expected.txt b/testsuite/java_test/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/test.cfg b/testsuite/java_test/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..06fe3118c6ebe2d822c120a78e869ac5f7d31214
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0127-rc-function-RC_Thread01-Cycle_am_00250/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00250)
+run(Cycle_am_00250,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/Cycle_am_00260.java b/testsuite/java_test/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/Cycle_am_00260.java
new file mode 100755
index 0000000000000000000000000000000000000000..ae01e119e0b1d1740354edcf1086a0db624907da
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/Cycle_am_00260.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00260 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00260_A1 a1_main = new Cycle_a_00260_A1("a1_main");
+        Cycle_a_00260_A6 a6_main = new Cycle_a_00260_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00260_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00260_A3("a3_0");
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00260_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1239)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00260_A1 {
+        Cycle_a_00260_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00260_A2 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00260_A3 {
+        Cycle_a_00260_A1 a1_0;
+        Cycle_a_00260_A2 a2_0;
+        Cycle_a_00260_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00260_A5 {
+        Cycle_a_00260_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00260_A6 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_am_00260 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00260 A1_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A2_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A3_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A4_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A5_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        ThreadRc_Cycle_am_00260 A6_Cycle_am_00260 = new ThreadRc_Cycle_am_00260();
+        A1_Cycle_am_00260.start();
+        A2_Cycle_am_00260.start();
+        A3_Cycle_am_00260.start();
+        A4_Cycle_am_00260.start();
+        A5_Cycle_am_00260.start();
+        A6_Cycle_am_00260.start();
+        try {
+            A1_Cycle_am_00260.join();
+            A2_Cycle_am_00260.join();
+            A3_Cycle_am_00260.join();
+            A4_Cycle_am_00260.join();
+            A5_Cycle_am_00260.join();
+            A6_Cycle_am_00260.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00260.check() && A2_Cycle_am_00260.check() && A3_Cycle_am_00260.check() && A4_Cycle_am_00260.check() && A5_Cycle_am_00260.check() && A6_Cycle_am_00260.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/expected.txt b/testsuite/java_test/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/test.cfg b/testsuite/java_test/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ae5ea3d5bde8eb90d74a48273787677be00b01bb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0128-rc-function-RC_Thread01-Cycle_am_00260/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00260)
+run(Cycle_am_00260,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/Cycle_am_00270.java b/testsuite/java_test/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/Cycle_am_00270.java
new file mode 100755
index 0000000000000000000000000000000000000000..3ee33cdecf02117fe608558a19c6c0f5d4c6f1d8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/Cycle_am_00270.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00270 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00270_A1 a1_main = new Cycle_a_00270_A1("a1_main");
+        Cycle_a_00270_A6 a6_main = new Cycle_a_00270_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00270_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00270_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00270_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1240)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00270_A1 {
+        Cycle_a_00270_A2 a2_0;
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00270_A2 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00270_A3 {
+        Cycle_a_00270_A1 a1_0;
+        Cycle_a_00270_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00270_A5 {
+        Cycle_a_00270_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00270_A6 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_am_00270 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00270 A1_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A2_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A3_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A4_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A5_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        ThreadRc_Cycle_am_00270 A6_Cycle_am_00270 = new ThreadRc_Cycle_am_00270();
+        A1_Cycle_am_00270.start();
+        A2_Cycle_am_00270.start();
+        A3_Cycle_am_00270.start();
+        A4_Cycle_am_00270.start();
+        A5_Cycle_am_00270.start();
+        A6_Cycle_am_00270.start();
+        try {
+            A1_Cycle_am_00270.join();
+            A2_Cycle_am_00270.join();
+            A3_Cycle_am_00270.join();
+            A4_Cycle_am_00270.join();
+            A5_Cycle_am_00270.join();
+            A6_Cycle_am_00270.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00270.check() && A2_Cycle_am_00270.check() && A3_Cycle_am_00270.check() && A4_Cycle_am_00270.check() && A5_Cycle_am_00270.check() && A6_Cycle_am_00270.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/expected.txt b/testsuite/java_test/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/test.cfg b/testsuite/java_test/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6eeb05aa9dd43282608bbe9d2c30f82604120096
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0129-rc-function-RC_Thread01-Cycle_am_00270/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00270)
+run(Cycle_am_00270,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/Cycle_am_00280.java b/testsuite/java_test/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/Cycle_am_00280.java
new file mode 100755
index 0000000000000000000000000000000000000000..4e4c2a2f199171a6706668b5e887be29d9038935
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/Cycle_am_00280.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00280 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1443)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00280_A1 {
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00280_A2 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00280_A3 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00280_A5 {
+        Cycle_a_00280_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00280_A6 {
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_am_00280 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00280 A1_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A2_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A3_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A4_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A5_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A6_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        A1_Cycle_am_00280.start();
+        A2_Cycle_am_00280.start();
+        A3_Cycle_am_00280.start();
+        A4_Cycle_am_00280.start();
+        A5_Cycle_am_00280.start();
+        A6_Cycle_am_00280.start();
+        try {
+            A1_Cycle_am_00280.join();
+            A2_Cycle_am_00280.join();
+            A3_Cycle_am_00280.join();
+            A4_Cycle_am_00280.join();
+            A5_Cycle_am_00280.join();
+            A6_Cycle_am_00280.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00280.check() && A2_Cycle_am_00280.check() && A3_Cycle_am_00280.check() && A4_Cycle_am_00280.check() && A5_Cycle_am_00280.check() && A6_Cycle_am_00280.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/expected.txt b/testsuite/java_test/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/test.cfg b/testsuite/java_test/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8bd574c9817a6b193c09ccaad9742674add94a34
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0130-rc-function-RC_Thread01-Cycle_am_00280/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00280)
+run(Cycle_am_00280,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/Cycle_am_00290.java b/testsuite/java_test/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/Cycle_am_00290.java
new file mode 100755
index 0000000000000000000000000000000000000000..f9d682e2080559158aee85140e32339e2ef6b7ab
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/Cycle_am_00290.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00290 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00290_A1 a1_main = new Cycle_a_00290_A1("a1_main");
+        Cycle_a_00290_A5 a5_main = new Cycle_a_00290_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00290_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00290_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00290_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00290_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a2_0 = a1_main.a2_0;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1447)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00290_A1 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00290_A2 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00290_A3 {
+        Cycle_a_00290_A1 a1_0;
+        Cycle_a_00290_A4 a4_0;
+        Cycle_a_00290_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00290_A4 {
+        Cycle_a_00290_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00290_A5 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00290_A6 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A6(String strObjectName) {
+            a2_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_am_00290 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00290 A1_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A2_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A3_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A4_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A5_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        ThreadRc_Cycle_am_00290 A6_Cycle_am_00290 = new ThreadRc_Cycle_am_00290();
+        A1_Cycle_am_00290.start();
+        A2_Cycle_am_00290.start();
+        A3_Cycle_am_00290.start();
+        A4_Cycle_am_00290.start();
+        A5_Cycle_am_00290.start();
+        A6_Cycle_am_00290.start();
+        try {
+            A1_Cycle_am_00290.join();
+            A2_Cycle_am_00290.join();
+            A3_Cycle_am_00290.join();
+            A4_Cycle_am_00290.join();
+            A5_Cycle_am_00290.join();
+            A6_Cycle_am_00290.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00290.check() && A2_Cycle_am_00290.check() && A3_Cycle_am_00290.check() && A4_Cycle_am_00290.check() && A5_Cycle_am_00290.check() && A6_Cycle_am_00290.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/expected.txt b/testsuite/java_test/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/test.cfg b/testsuite/java_test/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d6e3078f89a8d1ed81149399b37204f5ff235658
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0131-rc-function-RC_Thread01-Cycle_am_00290/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00290)
+run(Cycle_am_00290,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/Cycle_am_00300.java b/testsuite/java_test/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/Cycle_am_00300.java
new file mode 100755
index 0000000000000000000000000000000000000000..13a2239cb0903270c0d81fe4c219a0ee908be308
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/Cycle_am_00300.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00300 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00300_A1 a1_main = new Cycle_a_00300_A1("a1_main");
+        Cycle_a_00300_A5 a5_main = new Cycle_a_00300_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00300_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00300_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00300_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a6_0 = new Cycle_a_00300_A6("a6_0");
+        a5_main.a3_0.a4_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1448)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00300_A1 {
+        Cycle_a_00300_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00300_A2 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00300_A3 {
+        Cycle_a_00300_A1 a1_0;
+        Cycle_a_00300_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00300_A4 {
+        Cycle_a_00300_A5 a5_0;
+        Cycle_a_00300_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A4(String strObjectName) {
+            a5_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00300_A5 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00300_A6 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_am_00300 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00300 A1_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A2_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A3_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A4_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A5_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        ThreadRc_Cycle_am_00300 A6_Cycle_am_00300 = new ThreadRc_Cycle_am_00300();
+        A1_Cycle_am_00300.start();
+        A2_Cycle_am_00300.start();
+        A3_Cycle_am_00300.start();
+        A4_Cycle_am_00300.start();
+        A5_Cycle_am_00300.start();
+        A6_Cycle_am_00300.start();
+        try {
+            A1_Cycle_am_00300.join();
+            A2_Cycle_am_00300.join();
+            A3_Cycle_am_00300.join();
+            A4_Cycle_am_00300.join();
+            A5_Cycle_am_00300.join();
+            A6_Cycle_am_00300.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00300.check() && A2_Cycle_am_00300.check() && A3_Cycle_am_00300.check() && A4_Cycle_am_00300.check() && A5_Cycle_am_00300.check() && A6_Cycle_am_00300.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/expected.txt b/testsuite/java_test/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/test.cfg b/testsuite/java_test/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..187feb038c937d4dee4360e1ccf939095545acd2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0132-rc-function-RC_Thread01-Cycle_am_00300/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00300)
+run(Cycle_am_00300,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/Cycle_am_00310.java b/testsuite/java_test/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/Cycle_am_00310.java
new file mode 100755
index 0000000000000000000000000000000000000000..30f9afccd487d9990619f7d519efc85fa8b1be5f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/Cycle_am_00310.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00310 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00310_A1 a1_main = new Cycle_a_00310_A1("a1_main");
+        Cycle_a_00310_A4 a4_main = new Cycle_a_00310_A4("a4_main");
+        Cycle_a_00310_A6 a6_main = new Cycle_a_00310_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00310_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00310_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00310_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a4_0 = a4_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a4_main.a6_0 = a6_main;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1552)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00310_A1 {
+        Cycle_a_00310_A2 a2_0;
+        Cycle_a_00310_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00310_A2 {
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00310_A3 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00310_A4 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A4(String strObjectName) {
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00310_A5 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00310_A6 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+}
+public class Cycle_am_00310 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00310 A1_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A2_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A3_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A4_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A5_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        ThreadRc_Cycle_am_00310 A6_Cycle_am_00310 = new ThreadRc_Cycle_am_00310();
+        A1_Cycle_am_00310.start();
+        A2_Cycle_am_00310.start();
+        A3_Cycle_am_00310.start();
+        A4_Cycle_am_00310.start();
+        A5_Cycle_am_00310.start();
+        A6_Cycle_am_00310.start();
+        try {
+            A1_Cycle_am_00310.join();
+            A2_Cycle_am_00310.join();
+            A3_Cycle_am_00310.join();
+            A4_Cycle_am_00310.join();
+            A5_Cycle_am_00310.join();
+            A6_Cycle_am_00310.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00310.check() && A2_Cycle_am_00310.check() && A3_Cycle_am_00310.check() && A4_Cycle_am_00310.check() && A5_Cycle_am_00310.check() && A6_Cycle_am_00310.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/expected.txt b/testsuite/java_test/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/test.cfg b/testsuite/java_test/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f0afa3f33c39f38c410150c9b13833cf42ae046e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0133-rc-function-RC_Thread01-Cycle_am_00310/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00310)
+run(Cycle_am_00310,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/Cycle_am_00320.java b/testsuite/java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/Cycle_am_00320.java
new file mode 100755
index 0000000000000000000000000000000000000000..3aa85b07ee89fcff9177a79b93f80dc54208522f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/Cycle_am_00320.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00320 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00320_A1 a1_main = new Cycle_a_00320_A1("a1_main");
+        Cycle_a_00320_A4 a4_main = new Cycle_a_00320_A4("a4_main");
+        Cycle_a_00320_A6 a6_main = new Cycle_a_00320_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00320_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00320_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00320_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a6_main.a4_0 = a4_main;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1551)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00320_A1 {
+        Cycle_a_00320_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00320_A2 {
+        Cycle_a_00320_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00320_A3 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00320_A4 {
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00320_A5 {
+        Cycle_a_00320_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00320_A6 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A3 a3_0;
+        Cycle_a_00320_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
+public class Cycle_am_00320 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00320 A1_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A2_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A3_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A4_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A5_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        ThreadRc_Cycle_am_00320 A6_Cycle_am_00320 = new ThreadRc_Cycle_am_00320();
+        A1_Cycle_am_00320.start();
+        A2_Cycle_am_00320.start();
+        A3_Cycle_am_00320.start();
+        A4_Cycle_am_00320.start();
+        A5_Cycle_am_00320.start();
+        A6_Cycle_am_00320.start();
+        try {
+            A1_Cycle_am_00320.join();
+            A2_Cycle_am_00320.join();
+            A3_Cycle_am_00320.join();
+            A4_Cycle_am_00320.join();
+            A5_Cycle_am_00320.join();
+            A6_Cycle_am_00320.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00320.check() && A2_Cycle_am_00320.check() && A3_Cycle_am_00320.check() && A4_Cycle_am_00320.check() && A5_Cycle_am_00320.check() && A6_Cycle_am_00320.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/expected.txt b/testsuite/java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/test.cfg b/testsuite/java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3675c7527d8ae5b5be298e8c7d531f0feb9c2b5d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0134-rc-function-RC_Thread01-Cycle_am_00320/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00320)
+run(Cycle_am_00320,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/Cycle_am_00330.java b/testsuite/java_test/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/Cycle_am_00330.java
new file mode 100755
index 0000000000000000000000000000000000000000..74c4fdaa37713a683a2fdbc92aad0835822cce94
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/Cycle_am_00330.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00330 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00330_A1 a1_main = new Cycle_a_00330_A1("a1_main");
+        Cycle_a_00330_A4 a4_main = new Cycle_a_00330_A4("a4_main");
+        Cycle_a_00330_A6 a6_main = new Cycle_a_00330_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00330_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00330_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00330_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00330_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00330_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2080)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00330_A1 {
+        Cycle_a_00330_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00330_A2 {
+        Cycle_a_00330_A3 a3_0;
+        Cycle_a_00330_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00330_A3 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00330_A4 {
+        Cycle_a_00330_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00330_A5 {
+        Cycle_a_00330_A6 a6_0;
+        Cycle_a_00330_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00330_A6 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00330_A7 {
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00330_A8 {
+        Cycle_a_00330_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+public class Cycle_am_00330 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00330 A1_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A2_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A3_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A4_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A5_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        ThreadRc_Cycle_am_00330 A6_Cycle_am_00330 = new ThreadRc_Cycle_am_00330();
+        A1_Cycle_am_00330.start();
+        A2_Cycle_am_00330.start();
+        A3_Cycle_am_00330.start();
+        A4_Cycle_am_00330.start();
+        A5_Cycle_am_00330.start();
+        A6_Cycle_am_00330.start();
+        try {
+            A1_Cycle_am_00330.join();
+            A2_Cycle_am_00330.join();
+            A3_Cycle_am_00330.join();
+            A4_Cycle_am_00330.join();
+            A5_Cycle_am_00330.join();
+            A6_Cycle_am_00330.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00330.check() && A2_Cycle_am_00330.check() && A3_Cycle_am_00330.check() && A4_Cycle_am_00330.check() && A5_Cycle_am_00330.check() && A6_Cycle_am_00330.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/expected.txt b/testsuite/java_test/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/test.cfg b/testsuite/java_test/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4f6f610355ff46a2a6a2191d31146431b1c6b0e7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0135-rc-function-RC_Thread01-Cycle_am_00330/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00330)
+run(Cycle_am_00330,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/Cycle_am_00340.java b/testsuite/java_test/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/Cycle_am_00340.java
new file mode 100755
index 0000000000000000000000000000000000000000..263421e861ec9dece9788f28b2dc34855d4fb318
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/Cycle_am_00340.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00340 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00340_A1 a1_main = new Cycle_a_00340_A1("a1_main");
+        Cycle_a_00340_A4 a4_main = new Cycle_a_00340_A4("a4_main");
+        Cycle_a_00340_A6 a6_main = new Cycle_a_00340_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00340_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00340_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00340_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a8_0 = new Cycle_a_00340_A8("a8_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0 = new Cycle_a_00340_A7("a7_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a8_0.add();
+        a1_main.a2_0.a3_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a8_0.a7_0.sum + a6_main.a3_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00340_A1 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00340_A2 {
+        Cycle_a_00340_A3 a3_0;
+        Cycle_a_00340_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00340_A3 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A5 a5_0;
+        Cycle_a_00340_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a8_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00340_A4 {
+        Cycle_a_00340_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00340_A5 {
+        Cycle_a_00340_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00340_A6 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00340_A7 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00340_A8 {
+        Cycle_a_00340_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+public class Cycle_am_00340 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00340 A1_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A2_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A3_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A4_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A5_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        ThreadRc_Cycle_am_00340 A6_Cycle_am_00340 = new ThreadRc_Cycle_am_00340();
+        A1_Cycle_am_00340.start();
+        A2_Cycle_am_00340.start();
+        A3_Cycle_am_00340.start();
+        A4_Cycle_am_00340.start();
+        A5_Cycle_am_00340.start();
+        A6_Cycle_am_00340.start();
+        try {
+            A1_Cycle_am_00340.join();
+            A2_Cycle_am_00340.join();
+            A3_Cycle_am_00340.join();
+            A4_Cycle_am_00340.join();
+            A5_Cycle_am_00340.join();
+            A6_Cycle_am_00340.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00340.check() && A2_Cycle_am_00340.check() && A3_Cycle_am_00340.check() && A4_Cycle_am_00340.check() && A5_Cycle_am_00340.check() && A6_Cycle_am_00340.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/expected.txt b/testsuite/java_test/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/test.cfg b/testsuite/java_test/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ecd8754af8cd43d7aabda9c48de351b800c2370f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0136-rc-function-RC_Thread01-Cycle_am_00340/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00340)
+run(Cycle_am_00340,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/Cycle_am_00350.java b/testsuite/java_test/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/Cycle_am_00350.java
new file mode 100755
index 0000000000000000000000000000000000000000..5c9d6589c65a243abebd1f0ac3443c52c3fdf22b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/Cycle_am_00350.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00350 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00350_A1 a1_main = new Cycle_a_00350_A1("a1_main");
+        Cycle_a_00350_A4 a4_main = new Cycle_a_00350_A4("a4_main");
+        Cycle_a_00350_A6 a6_main = new Cycle_a_00350_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00350_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00350_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00350_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00350_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00350_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00350_A1 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00350_A2 {
+        Cycle_a_00350_A3 a3_0;
+        Cycle_a_00350_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00350_A3 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00350_A4 {
+        Cycle_a_00350_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00350_A5 {
+        Cycle_a_00350_A6 a6_0;
+        Cycle_a_00350_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00350_A6 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00350_A7 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00350_A8 {
+        Cycle_a_00350_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+public class Cycle_am_00350 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00350 A1_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A2_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A3_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A4_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A5_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        ThreadRc_Cycle_am_00350 A6_Cycle_am_00350 = new ThreadRc_Cycle_am_00350();
+        A1_Cycle_am_00350.start();
+        A2_Cycle_am_00350.start();
+        A3_Cycle_am_00350.start();
+        A4_Cycle_am_00350.start();
+        A5_Cycle_am_00350.start();
+        A6_Cycle_am_00350.start();
+        try {
+            A1_Cycle_am_00350.join();
+            A2_Cycle_am_00350.join();
+            A3_Cycle_am_00350.join();
+            A4_Cycle_am_00350.join();
+            A5_Cycle_am_00350.join();
+            A6_Cycle_am_00350.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00350.check() && A2_Cycle_am_00350.check() && A3_Cycle_am_00350.check() && A4_Cycle_am_00350.check() && A5_Cycle_am_00350.check() && A6_Cycle_am_00350.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/expected.txt b/testsuite/java_test/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/test.cfg b/testsuite/java_test/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9c419fc253fa1ad9ea6e707bf79c7e41ad7d4103
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0137-rc-function-RC_Thread01-Cycle_am_00350/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00350)
+run(Cycle_am_00350,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/Cycle_am_00360.java b/testsuite/java_test/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/Cycle_am_00360.java
new file mode 100755
index 0000000000000000000000000000000000000000..ab9b0582e8200a7eb467db12428b5106cbfc1ed9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/Cycle_am_00360.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00360 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00360_A1 a1_main = new Cycle_a_00360_A1("a1_main");
+        Cycle_a_00360_A4 a4_main = new Cycle_a_00360_A4("a4_main");
+        Cycle_a_00360_A6 a6_main = new Cycle_a_00360_A6("a6_main");
+        Cycle_a_00360_A9 a9_main = new Cycle_a_00360_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00360_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00360_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00360_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00360_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00360_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0.a9_0 = a9_main;
+        a9_main.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2399)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00360_A1 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00360_A2 {
+        Cycle_a_00360_A3 a3_0;
+        Cycle_a_00360_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00360_A3 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00360_A4 {
+        Cycle_a_00360_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00360_A5 {
+        Cycle_a_00360_A6 a6_0;
+        Cycle_a_00360_A8 a8_0;
+        Cycle_a_00360_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a9_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a + a9_0.a;
+        }
+    }
+    class Cycle_a_00360_A6 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00360_A7 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00360_A8 {
+        Cycle_a_00360_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00360_A9 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A9(String strObjectName) {
+            a2_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_am_00360 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00360 A1_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A2_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A3_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A4_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A5_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        ThreadRc_Cycle_am_00360 A6_Cycle_am_00360 = new ThreadRc_Cycle_am_00360();
+        A1_Cycle_am_00360.start();
+        A2_Cycle_am_00360.start();
+        A3_Cycle_am_00360.start();
+        A4_Cycle_am_00360.start();
+        A5_Cycle_am_00360.start();
+        A6_Cycle_am_00360.start();
+        try {
+            A1_Cycle_am_00360.join();
+            A2_Cycle_am_00360.join();
+            A3_Cycle_am_00360.join();
+            A4_Cycle_am_00360.join();
+            A5_Cycle_am_00360.join();
+            A6_Cycle_am_00360.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00360.check() && A2_Cycle_am_00360.check() && A3_Cycle_am_00360.check() && A4_Cycle_am_00360.check() && A5_Cycle_am_00360.check() && A6_Cycle_am_00360.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/expected.txt b/testsuite/java_test/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/test.cfg b/testsuite/java_test/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c0c64b63d5647d21452283abf00d52ededa97198
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0138-rc-function-RC_Thread01-Cycle_am_00360/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00360)
+run(Cycle_am_00360,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/Cycle_am_00370.java b/testsuite/java_test/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/Cycle_am_00370.java
new file mode 100755
index 0000000000000000000000000000000000000000..7f80d7de54aece43d5910b9214ef1be15a46518b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/Cycle_am_00370.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00370 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2623)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00370_A1 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00370_A2 {
+        Cycle_a_00370_A3 a3_0;
+        Cycle_a_00370_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00370_A3 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A5 a5_0;
+        Cycle_a_00370_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+    class Cycle_a_00370_A4 {
+        Cycle_a_00370_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00370_A5 {
+        Cycle_a_00370_A6 a6_0;
+        Cycle_a_00370_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00370_A6 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00370_A7 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00370_A8 {
+        Cycle_a_00370_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00370_A9 {
+        Cycle_a_00370_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00370_A10 {
+        Cycle_a_00370_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+}
+public class Cycle_am_00370 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00370 A1_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A2_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A3_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A4_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A5_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A6_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        A1_Cycle_am_00370.start();
+        A2_Cycle_am_00370.start();
+        A3_Cycle_am_00370.start();
+        A4_Cycle_am_00370.start();
+        A5_Cycle_am_00370.start();
+        A6_Cycle_am_00370.start();
+        try {
+            A1_Cycle_am_00370.join();
+            A2_Cycle_am_00370.join();
+            A3_Cycle_am_00370.join();
+            A4_Cycle_am_00370.join();
+            A5_Cycle_am_00370.join();
+            A6_Cycle_am_00370.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00370.check() && A2_Cycle_am_00370.check() && A3_Cycle_am_00370.check() && A4_Cycle_am_00370.check() && A5_Cycle_am_00370.check() && A6_Cycle_am_00370.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/expected.txt b/testsuite/java_test/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/test.cfg b/testsuite/java_test/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e8bdafb3d76e5477e9579b2b2d28bb775b21bf82
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0139-rc-function-RC_Thread01-Cycle_am_00370/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00370)
+run(Cycle_am_00370,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/Cycle_am_00380.java b/testsuite/java_test/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/Cycle_am_00380.java
new file mode 100755
index 0000000000000000000000000000000000000000..94779f0d5b68a254f5d237019c60d5cb46ec6a32
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/Cycle_am_00380.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00380 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00380_A1 a1_main = new Cycle_a_00380_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00380_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00380_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00380_A1 {
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00380_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00380_A2 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00380_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00380_A3 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00380_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+public class Cycle_am_00380 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00380 A1_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A2_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A3_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A4_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A5_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        ThreadRc_Cycle_am_00380 A6_Cycle_am_00380 = new ThreadRc_Cycle_am_00380();
+        A1_Cycle_am_00380.start();
+        A2_Cycle_am_00380.start();
+        A3_Cycle_am_00380.start();
+        A4_Cycle_am_00380.start();
+        A5_Cycle_am_00380.start();
+        A6_Cycle_am_00380.start();
+        try {
+            A1_Cycle_am_00380.join();
+            A2_Cycle_am_00380.join();
+            A3_Cycle_am_00380.join();
+            A4_Cycle_am_00380.join();
+            A5_Cycle_am_00380.join();
+            A6_Cycle_am_00380.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00380.check() && A2_Cycle_am_00380.check() && A3_Cycle_am_00380.check() && A4_Cycle_am_00380.check() && A5_Cycle_am_00380.check() && A6_Cycle_am_00380.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/expected.txt b/testsuite/java_test/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/test.cfg b/testsuite/java_test/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ce2d0d4c220d474c46d59451b7b43a90fc00574f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0140-rc-function-RC_Thread01-Cycle_am_00380/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00380)
+run(Cycle_am_00380,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/Cycle_am_00390.java b/testsuite/java_test/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/Cycle_am_00390.java
new file mode 100755
index 0000000000000000000000000000000000000000..f3e3c94fb288f5f42981c518af9297109a7aa8eb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/Cycle_am_00390.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00390 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00390_A1 a1_main = new Cycle_a_00390_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00390_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00390_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 918)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00390_A1 {
+        Cycle_a_00390_A2 a2_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00390_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00390_A2 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00390_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00390_A3 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00390_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+public class Cycle_am_00390 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00390 A1_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A2_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A3_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A4_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A5_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        ThreadRc_Cycle_am_00390 A6_Cycle_am_00390 = new ThreadRc_Cycle_am_00390();
+        A1_Cycle_am_00390.start();
+        A2_Cycle_am_00390.start();
+        A3_Cycle_am_00390.start();
+        A4_Cycle_am_00390.start();
+        A5_Cycle_am_00390.start();
+        A6_Cycle_am_00390.start();
+        try {
+            A1_Cycle_am_00390.join();
+            A2_Cycle_am_00390.join();
+            A3_Cycle_am_00390.join();
+            A4_Cycle_am_00390.join();
+            A5_Cycle_am_00390.join();
+            A6_Cycle_am_00390.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00390.check() && A2_Cycle_am_00390.check() && A3_Cycle_am_00390.check() && A4_Cycle_am_00390.check() && A5_Cycle_am_00390.check() && A6_Cycle_am_00390.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/expected.txt b/testsuite/java_test/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/test.cfg b/testsuite/java_test/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc64e1cc2d3cc6a079b5807e7b05ea7297b713a9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0141-rc-function-RC_Thread01-Cycle_am_00390/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00390)
+run(Cycle_am_00390,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/Cycle_am_00400.java b/testsuite/java_test/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/Cycle_am_00400.java
new file mode 100755
index 0000000000000000000000000000000000000000..df93d31cb54ab73aff9722dd8dcd08f6b1304267
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/Cycle_am_00400.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00400 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00400_A1 a1_main = new Cycle_a_00400_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00400_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00400_A3("a3_0");
+        a1_main.a4_0 = new Cycle_a_00400_A4("a4_0");
+        a1_main.a4_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00400_A1 {
+        Cycle_a_00400_A2 a2_0;
+        Cycle_a_00400_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00400_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00400_A2 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00400_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00400_A3 {
+        Cycle_a_00400_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00400_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00400_A4 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00400_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_am_00400 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00400 A1_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A2_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A3_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A4_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A5_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        ThreadRc_Cycle_am_00400 A6_Cycle_am_00400 = new ThreadRc_Cycle_am_00400();
+        A1_Cycle_am_00400.start();
+        A2_Cycle_am_00400.start();
+        A3_Cycle_am_00400.start();
+        A4_Cycle_am_00400.start();
+        A5_Cycle_am_00400.start();
+        A6_Cycle_am_00400.start();
+        try {
+            A1_Cycle_am_00400.join();
+            A2_Cycle_am_00400.join();
+            A3_Cycle_am_00400.join();
+            A4_Cycle_am_00400.join();
+            A5_Cycle_am_00400.join();
+            A6_Cycle_am_00400.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00400.check() && A2_Cycle_am_00400.check() && A3_Cycle_am_00400.check() && A4_Cycle_am_00400.check() && A5_Cycle_am_00400.check() && A6_Cycle_am_00400.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/expected.txt b/testsuite/java_test/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/test.cfg b/testsuite/java_test/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..09ea7c72372c0cd569b444c9e6d9f16784709a39
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0142-rc-function-RC_Thread01-Cycle_am_00400/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00400)
+run(Cycle_am_00400,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/Cycle_am_00410.java b/testsuite/java_test/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/Cycle_am_00410.java
new file mode 100755
index 0000000000000000000000000000000000000000..f70fc789ff48508723b28bbd1fff7af08b7ec2ae
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/Cycle_am_00410.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00410 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00410_A1 a1_main = new Cycle_a_00410_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00410_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00410_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00410_A4("a4_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 921)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00410_A1 {
+        Cycle_a_00410_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00410_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00410_A2 {
+        Cycle_a_00410_A3 a3_0;
+        Cycle_a_00410_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00410_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00410_A3 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00410_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00410_A4 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00410_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_am_00410 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00410 A1_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A2_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A3_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A4_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A5_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        ThreadRc_Cycle_am_00410 A6_Cycle_am_00410 = new ThreadRc_Cycle_am_00410();
+        A1_Cycle_am_00410.start();
+        A2_Cycle_am_00410.start();
+        A3_Cycle_am_00410.start();
+        A4_Cycle_am_00410.start();
+        A5_Cycle_am_00410.start();
+        A6_Cycle_am_00410.start();
+        try {
+            A1_Cycle_am_00410.join();
+            A2_Cycle_am_00410.join();
+            A3_Cycle_am_00410.join();
+            A4_Cycle_am_00410.join();
+            A5_Cycle_am_00410.join();
+            A6_Cycle_am_00410.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00410.check() && A2_Cycle_am_00410.check() && A3_Cycle_am_00410.check() && A4_Cycle_am_00410.check() && A5_Cycle_am_00410.check() && A6_Cycle_am_00410.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/expected.txt b/testsuite/java_test/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/test.cfg b/testsuite/java_test/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3da35efb7a337c520ff4b1c4acbb5e37664aa658
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0143-rc-function-RC_Thread01-Cycle_am_00410/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00410)
+run(Cycle_am_00410,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/Cycle_am_00420.java b/testsuite/java_test/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/Cycle_am_00420.java
new file mode 100755
index 0000000000000000000000000000000000000000..b7575ffc84f88b9902310fb55b4edbed82c33a59
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/Cycle_am_00420.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00420 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00420_A1 a1_main = new Cycle_a_00420_A1("a1_main");
+//		 Cycle_a_00420_A4 a4_main = new Cycle_a_00420_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00420_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00420_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00420_A4("a4_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00420_A1 {
+        Cycle_a_00420_A2 a2_0;
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00420_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00420_A2 {
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00420_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00420_A3 {
+        Cycle_a_00420_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00420_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00420_A4 {
+        Cycle_a_00420_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00420_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_am_00420 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00420 A1_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A2_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A3_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A4_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A5_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        ThreadRc_Cycle_am_00420 A6_Cycle_am_00420 = new ThreadRc_Cycle_am_00420();
+        A1_Cycle_am_00420.start();
+        A2_Cycle_am_00420.start();
+        A3_Cycle_am_00420.start();
+        A4_Cycle_am_00420.start();
+        A5_Cycle_am_00420.start();
+        A6_Cycle_am_00420.start();
+        try {
+            A1_Cycle_am_00420.join();
+            A2_Cycle_am_00420.join();
+            A3_Cycle_am_00420.join();
+            A4_Cycle_am_00420.join();
+            A5_Cycle_am_00420.join();
+            A6_Cycle_am_00420.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00420.check() && A2_Cycle_am_00420.check() && A3_Cycle_am_00420.check() && A4_Cycle_am_00420.check() && A5_Cycle_am_00420.check() && A6_Cycle_am_00420.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/expected.txt b/testsuite/java_test/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/test.cfg b/testsuite/java_test/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ac114ecd87b2667641812687b9dd22f630689a99
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0144-rc-function-RC_Thread01-Cycle_am_00420/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00420)
+run(Cycle_am_00420,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/Cycle_am_00430.java b/testsuite/java_test/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/Cycle_am_00430.java
new file mode 100755
index 0000000000000000000000000000000000000000..cb5ccfae54581751553d53d3ba4158dbbe730f3e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/Cycle_am_00430.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00430 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00430_A1 a1_main = new Cycle_a_00430_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00430_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00430_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00430_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1124)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00430_A1 {
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00430_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00430_A2 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A3 a3_0;
+        Cycle_a_00430_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00430_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00430_A3 {
+        Cycle_a_00430_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00430_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00430_A4 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00430_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+public class Cycle_am_00430 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00430 A1_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A2_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A3_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A4_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A5_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        ThreadRc_Cycle_am_00430 A6_Cycle_am_00430 = new ThreadRc_Cycle_am_00430();
+        A1_Cycle_am_00430.start();
+        A2_Cycle_am_00430.start();
+        A3_Cycle_am_00430.start();
+        A4_Cycle_am_00430.start();
+        A5_Cycle_am_00430.start();
+        A6_Cycle_am_00430.start();
+        try {
+            A1_Cycle_am_00430.join();
+            A2_Cycle_am_00430.join();
+            A3_Cycle_am_00430.join();
+            A4_Cycle_am_00430.join();
+            A5_Cycle_am_00430.join();
+            A6_Cycle_am_00430.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00430.check() && A2_Cycle_am_00430.check() && A3_Cycle_am_00430.check() && A4_Cycle_am_00430.check() && A5_Cycle_am_00430.check() && A6_Cycle_am_00430.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/expected.txt b/testsuite/java_test/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/test.cfg b/testsuite/java_test/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d9bb3263e9b1d2ef6c166a9e1eb1deda154b55e8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0145-rc-function-RC_Thread01-Cycle_am_00430/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00430)
+run(Cycle_am_00430,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/Cycle_am_00440.java b/testsuite/java_test/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/Cycle_am_00440.java
new file mode 100755
index 0000000000000000000000000000000000000000..b155b0d14958dbf5dc054d153987a009e80063f6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/Cycle_am_00440.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00440 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00440_A1 a1_main = new Cycle_a_00440_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00440_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00440_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00440_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1023)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00440_A1 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00440_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00440_A2 {
+        Cycle_a_00440_A1 a1_0;
+        Cycle_a_00440_A3 a3_0;
+        Cycle_a_00440_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00440_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00440_A3 {
+        Cycle_a_00440_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00440_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00440_A4 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00440_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_am_00440 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00440 A1_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A2_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A3_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A4_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A5_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        ThreadRc_Cycle_am_00440 A6_Cycle_am_00440 = new ThreadRc_Cycle_am_00440();
+        A1_Cycle_am_00440.start();
+        A2_Cycle_am_00440.start();
+        A3_Cycle_am_00440.start();
+        A4_Cycle_am_00440.start();
+        A5_Cycle_am_00440.start();
+        A6_Cycle_am_00440.start();
+        try {
+            A1_Cycle_am_00440.join();
+            A2_Cycle_am_00440.join();
+            A3_Cycle_am_00440.join();
+            A4_Cycle_am_00440.join();
+            A5_Cycle_am_00440.join();
+            A6_Cycle_am_00440.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00440.check() && A2_Cycle_am_00440.check() && A3_Cycle_am_00440.check() && A4_Cycle_am_00440.check() && A5_Cycle_am_00440.check() && A6_Cycle_am_00440.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/expected.txt b/testsuite/java_test/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/test.cfg b/testsuite/java_test/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7682261f8c816e35c8abb5e56d8842f56a21763e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0146-rc-function-RC_Thread01-Cycle_am_00440/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00440)
+run(Cycle_am_00440,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/Cycle_am_00450.java b/testsuite/java_test/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/Cycle_am_00450.java
new file mode 100755
index 0000000000000000000000000000000000000000..ffac1b822a29802ee260993d336bbaa3f91d24d6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/Cycle_am_00450.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00450 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00450_A1 a1_main = new Cycle_a_00450_A1("a1_main");
+        Cycle_a_00450_A6 a6_main = new Cycle_a_00450_A6("a6_main");
+        Cycle_a_00450_A7 a7_main = new Cycle_a_00450_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00450_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00450_A3("a3_0");
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00450_A5("a5_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = a7_main;
+        a7_main.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a6_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1453)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00450_A1 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00450_A2 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00450_A3 {
+        Cycle_a_00450_A1 a1_0;
+        Cycle_a_00450_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00450_A5 {
+        Cycle_a_00450_A6 a6_0;
+        Cycle_a_00450_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A5(String strObjectName) {
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00450_A6 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00450_A7 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_am_00450 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00450 A1_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A2_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A3_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A4_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A5_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        ThreadRc_Cycle_am_00450 A6_Cycle_am_00450 = new ThreadRc_Cycle_am_00450();
+        A1_Cycle_am_00450.start();
+        A2_Cycle_am_00450.start();
+        A3_Cycle_am_00450.start();
+        A4_Cycle_am_00450.start();
+        A5_Cycle_am_00450.start();
+        A6_Cycle_am_00450.start();
+        try {
+            A1_Cycle_am_00450.join();
+            A2_Cycle_am_00450.join();
+            A3_Cycle_am_00450.join();
+            A4_Cycle_am_00450.join();
+            A5_Cycle_am_00450.join();
+            A6_Cycle_am_00450.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00450.check() && A2_Cycle_am_00450.check() && A3_Cycle_am_00450.check() && A4_Cycle_am_00450.check() && A5_Cycle_am_00450.check() && A6_Cycle_am_00450.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/expected.txt b/testsuite/java_test/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/test.cfg b/testsuite/java_test/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..feab5845bd8553643159b89e8c825cdb81a5055e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0147-rc-function-RC_Thread01-Cycle_am_00450/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00450)
+run(Cycle_am_00450,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/Cycle_am_00460.java b/testsuite/java_test/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/Cycle_am_00460.java
new file mode 100755
index 0000000000000000000000000000000000000000..a3dbfc2c40e0624761d56481c833a80ce1d7cce0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/Cycle_am_00460.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00460 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00460_A1 a1_main = new Cycle_a_00460_A1("a1_main");
+        Cycle_a_00460_A5 a5_main = new Cycle_a_00460_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00460_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00460_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00460_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00460_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00460_A1 {
+        Cycle_a_00460_A2 a2_0;
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00460_A2 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00460_A3 {
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00460_A4 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00460_A5 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00460_A6 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A6(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+}
+public class Cycle_am_00460 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00460 A1_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A2_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A3_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A4_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A5_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        ThreadRc_Cycle_am_00460 A6_Cycle_am_00460 = new ThreadRc_Cycle_am_00460();
+        A1_Cycle_am_00460.start();
+        A2_Cycle_am_00460.start();
+        A3_Cycle_am_00460.start();
+        A4_Cycle_am_00460.start();
+        A5_Cycle_am_00460.start();
+        A6_Cycle_am_00460.start();
+        try {
+            A1_Cycle_am_00460.join();
+            A2_Cycle_am_00460.join();
+            A3_Cycle_am_00460.join();
+            A4_Cycle_am_00460.join();
+            A5_Cycle_am_00460.join();
+            A6_Cycle_am_00460.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00460.check() && A2_Cycle_am_00460.check() && A3_Cycle_am_00460.check() && A4_Cycle_am_00460.check() && A5_Cycle_am_00460.check() && A6_Cycle_am_00460.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/expected.txt b/testsuite/java_test/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/test.cfg b/testsuite/java_test/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4c5f2c66f797c1267bb32f796326629688f24b2a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0148-rc-function-RC_Thread01-Cycle_am_00460/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00460)
+run(Cycle_am_00460,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/Cycle_am_00470.java b/testsuite/java_test/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/Cycle_am_00470.java
new file mode 100755
index 0000000000000000000000000000000000000000..294838183b1b28a1f991917e235604321fd80a43
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/Cycle_am_00470.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00470 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00470_A1 a1_main = new Cycle_a_00470_A1("a1_main");
+        Cycle_a_00470_A5 a5_main = new Cycle_a_00470_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00470_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00470_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00470_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00470_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a1_0 = a1_main;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1446)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00470_A1 {
+        Cycle_a_00470_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00470_A2 {
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00470_A3 {
+        Cycle_a_00470_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00470_A4 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00470_A5 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A5(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00470_A6 {
+        Cycle_a_00470_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A6(String strObjectName) {
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+public class Cycle_am_00470 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00470 A1_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A2_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A3_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A4_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A5_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        ThreadRc_Cycle_am_00470 A6_Cycle_am_00470 = new ThreadRc_Cycle_am_00470();
+        A1_Cycle_am_00470.start();
+        A2_Cycle_am_00470.start();
+        A3_Cycle_am_00470.start();
+        A4_Cycle_am_00470.start();
+        A5_Cycle_am_00470.start();
+        A6_Cycle_am_00470.start();
+        try {
+            A1_Cycle_am_00470.join();
+            A2_Cycle_am_00470.join();
+            A3_Cycle_am_00470.join();
+            A4_Cycle_am_00470.join();
+            A5_Cycle_am_00470.join();
+            A6_Cycle_am_00470.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00470.check() && A2_Cycle_am_00470.check() && A3_Cycle_am_00470.check() && A4_Cycle_am_00470.check() && A5_Cycle_am_00470.check() && A6_Cycle_am_00470.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/expected.txt b/testsuite/java_test/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/test.cfg b/testsuite/java_test/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8fd94d1a3b8ad5dfab255a051c587a0826f50ea3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0149-rc-function-RC_Thread01-Cycle_am_00470/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00470)
+run(Cycle_am_00470,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/Cycle_am_00480.java b/testsuite/java_test/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/Cycle_am_00480.java
new file mode 100755
index 0000000000000000000000000000000000000000..0b07e6b00b95a144b22736c6634a34d1e1f3946a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/Cycle_am_00480.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00480 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00480_A1 a1_main = new Cycle_a_00480_A1("a1_main");
+        Cycle_a_00480_A5 a5_main = new Cycle_a_00480_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00480_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00480_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00480_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00480_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a5_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a1_0.add();
+        a5_main.a3_0.add();
+        a5_main.a3_0.a4_0.add();
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a5_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a5_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a1_main.a2_0.a3_0.a4_0.sum+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00480_A1 {
+        Cycle_a_00480_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00480_A2 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00480_A3 {
+        Cycle_a_00480_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00480_A4 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00480_A5 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00480_A6 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A4 a4_0;
+        Cycle_a_00480_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A6(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a5_0.a;
+        }
+    }
+}
+public class Cycle_am_00480 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00480 A1_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A2_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A3_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A4_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A5_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        ThreadRc_Cycle_am_00480 A6_Cycle_am_00480 = new ThreadRc_Cycle_am_00480();
+        A1_Cycle_am_00480.start();
+        A2_Cycle_am_00480.start();
+        A3_Cycle_am_00480.start();
+        A4_Cycle_am_00480.start();
+        A5_Cycle_am_00480.start();
+        A6_Cycle_am_00480.start();
+        try {
+            A1_Cycle_am_00480.join();
+            A2_Cycle_am_00480.join();
+            A3_Cycle_am_00480.join();
+            A4_Cycle_am_00480.join();
+            A5_Cycle_am_00480.join();
+            A6_Cycle_am_00480.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00480.check() && A2_Cycle_am_00480.check() && A3_Cycle_am_00480.check() && A4_Cycle_am_00480.check() && A5_Cycle_am_00480.check() && A6_Cycle_am_00480.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/expected.txt b/testsuite/java_test/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/test.cfg b/testsuite/java_test/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6ba0607e52b48bba1f8aba753cf5e24f5173ff4a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0150-rc-function-RC_Thread01-Cycle_am_00480/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00480)
+run(Cycle_am_00480,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/Cycle_am_00490.java b/testsuite/java_test/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/Cycle_am_00490.java
new file mode 100755
index 0000000000000000000000000000000000000000..2b16b507657c9d6a38ab2e1212bc964ac8b6661b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/Cycle_am_00490.java
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00490 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00490_A1 a1_main = new Cycle_a_00490_A1("a1_main");
+        Cycle_a_00490_A4 a4_main = new Cycle_a_00490_A4("a4_main");
+        Cycle_a_00490_A7 a7_main = new Cycle_a_00490_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00490_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00490_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00490_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+//		 a4_main.a5_0.a6_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a4_main.a5_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0.a6_0.a3_0.a1_0 = a1_main;
+        a7_main.a9_0 = new Cycle_a_00490_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00490_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0.a8_0.a5_0 = a4_main.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a6_0.a3_0.add();
+        a4_main.a5_0.a6_0.a3_0.a1_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        a7_main.a9_0.a8_0.a5_0.add();
+//
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a4_main.sum);
+//		 System.out.println("a7_main.sum:"+a7_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a4_main.a5_0.sum:"+a4_main.a5_0.sum);
+//		 System.out.println("a4_main.a5_0.a6_0.sum:"+a4_main.a5_0.a6_0.sum);
+//		 System.out.println("a7_main.a9_0.sum:"+a7_main.a9_0.sum);
+//		 System.out.println("a7_main.a9_0.a8_0.sum:"+a7_main.a9_0.a8_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a4_main.sum+a7_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a4_main.a5_0.sum+a4_main.a5_0.a6_0.sum+a7_main.a9_0.sum+a7_main.a9_0.a8_0.sum);
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2098)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00490_A1 {
+        Cycle_a_00490_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00490_A2 {
+        Cycle_a_00490_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00490_A3 {
+        Cycle_a_00490_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00490_A4 {
+        Cycle_a_00490_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00490_A5 {
+        Cycle_a_00490_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00490_A6 {
+        Cycle_a_00490_A3 a3_0;
+        Cycle_a_00490_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A6(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00490_A7 {
+        Cycle_a_00490_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_00490_A8 {
+        Cycle_a_00490_A5 a5_0;
+        Cycle_a_00490_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A8(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00490_A9 {
+        Cycle_a_00490_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+public class Cycle_am_00490 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00490 A1_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A2_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A3_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A4_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A5_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        ThreadRc_Cycle_am_00490 A6_Cycle_am_00490 = new ThreadRc_Cycle_am_00490();
+        A1_Cycle_am_00490.start();
+        A2_Cycle_am_00490.start();
+        A3_Cycle_am_00490.start();
+        A4_Cycle_am_00490.start();
+        A5_Cycle_am_00490.start();
+        A6_Cycle_am_00490.start();
+        try {
+            A1_Cycle_am_00490.join();
+            A2_Cycle_am_00490.join();
+            A3_Cycle_am_00490.join();
+            A4_Cycle_am_00490.join();
+            A5_Cycle_am_00490.join();
+            A6_Cycle_am_00490.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00490.check() && A2_Cycle_am_00490.check() && A3_Cycle_am_00490.check() && A4_Cycle_am_00490.check() && A5_Cycle_am_00490.check() && A6_Cycle_am_00490.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/expected.txt b/testsuite/java_test/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f33a8592d2316dcaefb376e2e77d12a354a4918e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/expected.txt
@@ -0,0 +1,4 @@
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/test.cfg b/testsuite/java_test/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0ad548d51eb4703cf912bff3e180ff8efda72895
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0151-rc-function-RC_Thread01-Cycle_am_00490/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00490)
+run(Cycle_am_00490,EXPECTNUM=4)
diff --git a/testsuite/java_test/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/Cycle_am_00500.java b/testsuite/java_test/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/Cycle_am_00500.java
new file mode 100755
index 0000000000000000000000000000000000000000..424c025fb73e5a8e290ac16a716dcbcb3e3dbe86
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/Cycle_am_00500.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00500 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00500_A1 a1_main = new Cycle_a_00500_A1("a1_main");
+        Cycle_a_00500_A4 a4_main = new Cycle_a_00500_A4("a4_main");
+        Cycle_a_00500_A7 a7_main = new Cycle_a_00500_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00500_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00500_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a4_main.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00500_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00500_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+        a4_main.a5_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a4_main.a5_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0 = new Cycle_a_00500_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a8_0.add();
+        a4_main.a5_0.a8_0.a7_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a4_main.sum);
+//		 System.out.println("a7_main.sum:"+a7_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a4_main.a5_0.sum:"+a4_main.a5_0.sum);
+//		 System.out.println("a4_main.a5_0.a6_0.sum:"+a4_main.a5_0.a6_0.sum);
+//		 System.out.println("a7_main.a9_0.sum:"+a7_main.a9_0.sum);
+//		 System.out.println("a7_main.a9_0.a8_0.sum:"+a7_main.a9_0.a8_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a4_main.sum+a7_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a4_main.a5_0.sum+a4_main.a5_0.a6_0.sum+a7_main.a9_0.sum+a7_main.a9_0.a8_0.sum);
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2099)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00500_A1 {
+        Cycle_a_00500_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00500_A2 {
+        Cycle_a_00500_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00500_A3 {
+        Cycle_a_00500_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00500_A4 {
+        Cycle_a_00500_A1 a1_0;
+        Cycle_a_00500_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A4(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00500_A5 {
+        Cycle_a_00500_A6 a6_0;
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00500_A6 {
+        Cycle_a_00500_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A6(String strObjectName) {
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00500_A7 {
+        Cycle_a_00500_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_00500_A8 {
+        Cycle_a_00500_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00500_A9 {
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+public class Cycle_am_00500 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00500 A1_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A2_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A3_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A4_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A5_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        ThreadRc_Cycle_am_00500 A6_Cycle_am_00500 = new ThreadRc_Cycle_am_00500();
+        A1_Cycle_am_00500.start();
+        A2_Cycle_am_00500.start();
+        A3_Cycle_am_00500.start();
+        A4_Cycle_am_00500.start();
+        A5_Cycle_am_00500.start();
+        A6_Cycle_am_00500.start();
+        try {
+            A1_Cycle_am_00500.join();
+            A2_Cycle_am_00500.join();
+            A3_Cycle_am_00500.join();
+            A4_Cycle_am_00500.join();
+            A5_Cycle_am_00500.join();
+            A6_Cycle_am_00500.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00500.check() && A2_Cycle_am_00500.check() && A3_Cycle_am_00500.check() && A4_Cycle_am_00500.check() && A5_Cycle_am_00500.check() && A6_Cycle_am_00500.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/expected.txt b/testsuite/java_test/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f33a8592d2316dcaefb376e2e77d12a354a4918e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/expected.txt
@@ -0,0 +1,4 @@
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/test.cfg b/testsuite/java_test/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8f365dfa2581d792a562d390fd0b7802af52ed11
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0152-rc-function-RC_Thread01-Cycle_am_00500/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00500)
+run(Cycle_am_00500,EXPECTNUM=4)
diff --git a/testsuite/java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/Cycle_am_00510.java b/testsuite/java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/Cycle_am_00510.java
new file mode 100755
index 0000000000000000000000000000000000000000..13e43e4bea66e01b3501d9286e0a27c785d6a4ec
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/Cycle_am_00510.java
@@ -0,0 +1,4779 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_00180B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00180_A1 a1_main = new Cycle_a_00180_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00180_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00180_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00180_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00180_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00180_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a8_0 = new Cycle_a_00180_A8("a8_0");
+        a1_main.a8_0.a9_0 = new Cycle_a_00180_A9("a9_0");
+        a1_main.a8_0.a9_0.a7_0 = new Cycle_a_00180_A7("a7_0");
+        a1_main.a8_0.a9_0.a7_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_main.a8_0.add();
+        a1_main.a8_0.a9_0.add();
+        a1_main.a8_0.a9_0.a7_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_main.a8_0.sum + a1_main.a8_0.a9_0.sum + a1_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1994)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00180_A1 {
+        Cycle_a_00180_A2 a2_0;
+        Cycle_a_00180_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A1(String strObjectName) {
+            a2_0 = null;
+            a8_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00180_A2 {
+        Cycle_a_00180_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00180_A3 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00180_A4 {
+        Cycle_a_00180_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00180_A5 {
+        Cycle_a_00180_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00180_A6 {
+        Cycle_a_00180_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A6(String strObjectName) {
+            a1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00180_A7 {
+        Cycle_a_00180_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A7(String strObjectName) {
+            a4_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00180_A8 {
+        Cycle_a_00180_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_00180_A9 {
+        Cycle_a_00180_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00180_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00190B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00190_A1 a1_main = new Cycle_a_00190_A1("a1_main");
+        Cycle_a_00190_A10 a10_main = new Cycle_a_00190_A10("a10_main");
+        a1_main.a2_0 = new Cycle_a_00190_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00190_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00190_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = new Cycle_a_00190_A5("a5_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_a_00190_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_main;
+        a10_main.a8_0 = new Cycle_a_00190_A8("a8_0");
+        a10_main.a8_0.a9_0 = new Cycle_a_00190_A9("a9_0");
+        a10_main.a8_0.a9_0.a7_0 = new Cycle_a_00190_A7("a7_0");
+        a10_main.a8_0.a9_0.a7_0.a5_0 = a1_main.a2_0.a3_0.a4_0.a5_0;
+        a1_main.add();
+        a10_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.add();
+        a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_main.a8_0.add();
+        a10_main.a8_0.a9_0.add();
+        a10_main.a8_0.a9_0.a7_0.add();
+        int result = a1_main.sum + a10_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.sum + a1_main.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_main.a8_0.sum + a10_main.a8_0.a9_0.sum + a10_main.a8_0.a9_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2215)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00190_A1 {
+        Cycle_a_00190_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00190_A2 {
+        Cycle_a_00190_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00190_A3 {
+        Cycle_a_00190_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00190_A4 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00190_A5 {
+        Cycle_a_00190_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00190_A6 {
+        Cycle_a_00190_A1 a1_0;
+        Cycle_a_00190_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A6(String strObjectName) {
+            a1_0 = null;
+            a10_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+    class Cycle_a_00190_A7 {
+        Cycle_a_00190_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A7(String strObjectName) {
+            a5_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00190_A8 {
+        Cycle_a_00190_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A8(String strObjectName) {
+            a9_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_00190_A9 {
+        Cycle_a_00190_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A9(String strObjectName) {
+            a7_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00190_A10 {
+        Cycle_a_00190_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00190_A10(String strObjectName) {
+            a8_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00200B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00200_A1 a1_main = new Cycle_a_00200_A1("a1_main");
+        Cycle_a_00200_A4 a4_main = new Cycle_a_00200_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00200_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00200_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00200_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a6_0 = new Cycle_a_00200_A6("a6_0");
+        a1_main.a2_0.a6_0.a7_0 = new Cycle_a_00200_A7("a7_0");
+        a1_main.a2_0.a7_0 = a1_main.a2_0.a6_0.a7_0;
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a6_0.add();
+        a1_main.a2_0.a6_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a6_0.sum + a1_main.a2_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00200_A1 {
+        Cycle_a_00200_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00200_A2 {
+        Cycle_a_00200_A3 a3_0;
+        Cycle_a_00200_A6 a6_0;
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A2(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00200_A3 {
+        Cycle_a_00200_A1 a1_0;
+        Cycle_a_00200_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00200_A4 {
+        Cycle_a_00200_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00200_A5 {
+        Cycle_a_00200_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00200_A6 {
+        Cycle_a_00200_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00200_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00200_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00210B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00210_A1 a1_main = new Cycle_a_00210_A1("a1_main");
+        Cycle_a_00210_A4 a4_main = new Cycle_a_00210_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00210_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00210_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00210_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00210_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0 = new Cycle_a_00210_A7("a7_0");
+        a1_main.a2_0.a3_0.a6_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        a1_main.a2_0.a3_0.a6_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a6_0.sum + a1_main.a2_0.a3_0.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1662)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00210_A1 {
+        Cycle_a_00210_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00210_A2 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00210_A3 {
+        Cycle_a_00210_A1 a1_0;
+        Cycle_a_00210_A5 a5_0;
+        Cycle_a_00210_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00210_A4 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00210_A5 {
+        Cycle_a_00210_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A5(String strObjectName) {
+            a4_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00210_A6 {
+        Cycle_a_00210_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00210_A7 {
+        Cycle_a_00210_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00210_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00220B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00220_A1 a1_main = new Cycle_a_00220_A1("a1_main");
+        Cycle_a_00220_A4 a4_main = new Cycle_a_00220_A4("a4_main");
+        Cycle_a_00220_A6 a6_main = new Cycle_a_00220_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00220_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00220_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00220_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_00220_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1772)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00220_A1 {
+        Cycle_a_00220_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00220_A2 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00220_A3 {
+        Cycle_a_00220_A1 a1_0;
+        Cycle_a_00220_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00220_A4 {
+        Cycle_a_00220_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00220_A5 {
+        Cycle_a_00220_A4 a4_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00220_A6 {
+        Cycle_a_00220_A5 a5_0;
+        Cycle_a_00220_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00220_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00220_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00230B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00230_A1 a1_main = new Cycle_a_00230_A1("a1_main");
+        Cycle_a_00230_A5 a5_main = new Cycle_a_00230_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00230_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00230_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00230_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a7_0 = new Cycle_a_00230_A7("a7_0");
+        a5_main.a6_0 = new Cycle_a_00230_A6("a6_0");
+        a5_main.a6_0.a7_0 = a5_main.a7_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a5_main.a7_0.add();
+        a5_main.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a5_main.a6_0.sum + a5_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1773)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00230_A1 {
+        Cycle_a_00230_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00230_A2 {
+        Cycle_a_00230_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00230_A3 {
+        Cycle_a_00230_A1 a1_0;
+        Cycle_a_00230_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00230_A4 {
+        Cycle_a_00230_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00230_A5 {
+        Cycle_a_00230_A3 a3_0;
+        Cycle_a_00230_A6 a6_0;
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A5(String strObjectName) {
+            a3_0 = null;
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a6_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00230_A6 {
+        Cycle_a_00230_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00230_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00230_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00240B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00240_A1 a1_main = new Cycle_a_00240_A1("a1_main");
+        Cycle_a_00240_A5 a5_main = new Cycle_a_00240_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00240_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00240_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a6_0 = new Cycle_a_00240_A6("a6_0");
+        a1_main.a6_0.a7_0 = new Cycle_a_00240_A7("a7_0");
+        a1_main.a6_0.a7_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a6_0.add();
+        a1_main.a6_0.a7_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a6_0.sum + a1_main.a6_0.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1660)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00240_A1 {
+        Cycle_a_00240_A2 a2_0;
+        Cycle_a_00240_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A1(String strObjectName) {
+            a2_0 = null;
+            a6_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00240_A2 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00240_A3 {
+        Cycle_a_00240_A1 a1_0;
+        Cycle_a_00240_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00240_A4 {
+        Cycle_a_00240_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00240_A5 {
+        Cycle_a_00240_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00240_A6 {
+        Cycle_a_00240_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A6(String strObjectName) {
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00240_A7 {
+        Cycle_a_00240_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00240_A7(String strObjectName) {
+            a1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00250B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00250_A1 a1_main = new Cycle_a_00250_A1("a1_main");
+        Cycle_a_00250_A6 a6_main = new Cycle_a_00250_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00250_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00250_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00250_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1238)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00250_A1 {
+        Cycle_a_00250_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00250_A2 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00250_A3 {
+        Cycle_a_00250_A1 a1_0;
+        Cycle_a_00250_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00250_A5 {
+        Cycle_a_00250_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00250_A6 {
+        Cycle_a_00250_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00250_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00260B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00260_A1 a1_main = new Cycle_a_00260_A1("a1_main");
+        Cycle_a_00260_A6 a6_main = new Cycle_a_00260_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00260_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00260_A3("a3_0");
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00260_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1239)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00260_A1 {
+        Cycle_a_00260_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00260_A2 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00260_A3 {
+        Cycle_a_00260_A1 a1_0;
+        Cycle_a_00260_A2 a2_0;
+        Cycle_a_00260_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00260_A5 {
+        Cycle_a_00260_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00260_A6 {
+        Cycle_a_00260_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00260_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00270B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00270_A1 a1_main = new Cycle_a_00270_A1("a1_main");
+        Cycle_a_00270_A6 a6_main = new Cycle_a_00270_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00270_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00270_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00270_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1240)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00270_A1 {
+        Cycle_a_00270_A2 a2_0;
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00270_A2 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00270_A3 {
+        Cycle_a_00270_A1 a1_0;
+        Cycle_a_00270_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00270_A5 {
+        Cycle_a_00270_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00270_A6 {
+        Cycle_a_00270_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00270_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00280B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1443)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00280_A1 {
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00280_A2 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00280_A3 {
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00280_A5 {
+        Cycle_a_00280_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00280_A6 {
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00290B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00290_A1 a1_main = new Cycle_a_00290_A1("a1_main");
+        Cycle_a_00290_A5 a5_main = new Cycle_a_00290_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00290_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00290_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00290_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a6_0 = new Cycle_a_00290_A6("a6_0");
+        a1_main.a2_0.a3_0.a6_0.a2_0 = a1_main.a2_0;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1447)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00290_A1 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00290_A2 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00290_A3 {
+        Cycle_a_00290_A1 a1_0;
+        Cycle_a_00290_A4 a4_0;
+        Cycle_a_00290_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a6_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00290_A4 {
+        Cycle_a_00290_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00290_A5 {
+        Cycle_a_00290_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00290_A6 {
+        Cycle_a_00290_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00290_A6(String strObjectName) {
+            a2_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00300B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00300_A1 a1_main = new Cycle_a_00300_A1("a1_main");
+        Cycle_a_00300_A5 a5_main = new Cycle_a_00300_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00300_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00300_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00300_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a6_0 = new Cycle_a_00300_A6("a6_0");
+        a5_main.a3_0.a4_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0.a5_0 = a5_main;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1448)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00300_A1 {
+        Cycle_a_00300_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00300_A2 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00300_A3 {
+        Cycle_a_00300_A1 a1_0;
+        Cycle_a_00300_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A3(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00300_A4 {
+        Cycle_a_00300_A5 a5_0;
+        Cycle_a_00300_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A4(String strObjectName) {
+            a5_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00300_A5 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00300_A6 {
+        Cycle_a_00300_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00300_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00310B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00310_A1 a1_main = new Cycle_a_00310_A1("a1_main");
+        Cycle_a_00310_A4 a4_main = new Cycle_a_00310_A4("a4_main");
+        Cycle_a_00310_A6 a6_main = new Cycle_a_00310_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00310_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00310_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00310_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a4_0 = a4_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a4_main.a6_0 = a6_main;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1552)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00310_A1 {
+        Cycle_a_00310_A2 a2_0;
+        Cycle_a_00310_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00310_A2 {
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00310_A3 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00310_A4 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A4(String strObjectName) {
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00310_A5 {
+        Cycle_a_00310_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00310_A6 {
+        Cycle_a_00310_A1 a1_0;
+        Cycle_a_00310_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00310_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00320B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00320_A1 a1_main = new Cycle_a_00320_A1("a1_main");
+        Cycle_a_00320_A4 a4_main = new Cycle_a_00320_A4("a4_main");
+        Cycle_a_00320_A6 a6_main = new Cycle_a_00320_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00320_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00320_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00320_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a6_main.a4_0 = a4_main;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1551)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00320_A1 {
+        Cycle_a_00320_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00320_A2 {
+        Cycle_a_00320_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00320_A3 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00320_A4 {
+        Cycle_a_00320_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00320_A5 {
+        Cycle_a_00320_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00320_A6 {
+        Cycle_a_00320_A1 a1_0;
+        Cycle_a_00320_A3 a3_0;
+        Cycle_a_00320_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00320_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00330B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00330_A1 a1_main = new Cycle_a_00330_A1("a1_main");
+        Cycle_a_00330_A4 a4_main = new Cycle_a_00330_A4("a4_main");
+        Cycle_a_00330_A6 a6_main = new Cycle_a_00330_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00330_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00330_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00330_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00330_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00330_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2080)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00330_A1 {
+        Cycle_a_00330_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00330_A2 {
+        Cycle_a_00330_A3 a3_0;
+        Cycle_a_00330_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00330_A3 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00330_A4 {
+        Cycle_a_00330_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00330_A5 {
+        Cycle_a_00330_A6 a6_0;
+        Cycle_a_00330_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00330_A6 {
+        Cycle_a_00330_A1 a1_0;
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00330_A7 {
+        Cycle_a_00330_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00330_A8 {
+        Cycle_a_00330_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00330_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00340B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00340_A1 a1_main = new Cycle_a_00340_A1("a1_main");
+        Cycle_a_00340_A4 a4_main = new Cycle_a_00340_A4("a4_main");
+        Cycle_a_00340_A6 a6_main = new Cycle_a_00340_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00340_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00340_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00340_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a2_0.a3_0.a8_0 = new Cycle_a_00340_A8("a8_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0 = new Cycle_a_00340_A7("a7_0");
+        a1_main.a2_0.a3_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a1_0 = a1_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a8_0.add();
+        a1_main.a2_0.a3_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a8_0.a7_0.sum + a6_main.a3_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00340_A1 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00340_A2 {
+        Cycle_a_00340_A3 a3_0;
+        Cycle_a_00340_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00340_A3 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A5 a5_0;
+        Cycle_a_00340_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a8_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00340_A4 {
+        Cycle_a_00340_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00340_A5 {
+        Cycle_a_00340_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00340_A6 {
+        Cycle_a_00340_A1 a1_0;
+        Cycle_a_00340_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00340_A7 {
+        Cycle_a_00340_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00340_A8 {
+        Cycle_a_00340_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00340_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00350B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00350_A1 a1_main = new Cycle_a_00350_A1("a1_main");
+        Cycle_a_00350_A4 a4_main = new Cycle_a_00350_A4("a4_main");
+        Cycle_a_00350_A6 a6_main = new Cycle_a_00350_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00350_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00350_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00350_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00350_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00350_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2079)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00350_A1 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00350_A2 {
+        Cycle_a_00350_A3 a3_0;
+        Cycle_a_00350_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00350_A3 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00350_A4 {
+        Cycle_a_00350_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00350_A5 {
+        Cycle_a_00350_A6 a6_0;
+        Cycle_a_00350_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00350_A6 {
+        Cycle_a_00350_A1 a1_0;
+        Cycle_a_00350_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00350_A7 {
+        Cycle_a_00350_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00350_A8 {
+        Cycle_a_00350_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00350_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00360B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00360_A1 a1_main = new Cycle_a_00360_A1("a1_main");
+        Cycle_a_00360_A4 a4_main = new Cycle_a_00360_A4("a4_main");
+        Cycle_a_00360_A6 a6_main = new Cycle_a_00360_A6("a6_main");
+        Cycle_a_00360_A9 a9_main = new Cycle_a_00360_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00360_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00360_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00360_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00360_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00360_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0.a9_0 = a9_main;
+        a9_main.a2_0 = a1_main.a2_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2399)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00360_A1 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00360_A2 {
+        Cycle_a_00360_A3 a3_0;
+        Cycle_a_00360_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00360_A3 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00360_A4 {
+        Cycle_a_00360_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00360_A5 {
+        Cycle_a_00360_A6 a6_0;
+        Cycle_a_00360_A8 a8_0;
+        Cycle_a_00360_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a9_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a + a9_0.a;
+        }
+    }
+    class Cycle_a_00360_A6 {
+        Cycle_a_00360_A1 a1_0;
+        Cycle_a_00360_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00360_A7 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00360_A8 {
+        Cycle_a_00360_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00360_A9 {
+        Cycle_a_00360_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00360_A9(String strObjectName) {
+            a2_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00370B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2623)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00370_A1 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00370_A2 {
+        Cycle_a_00370_A3 a3_0;
+        Cycle_a_00370_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00370_A3 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A5 a5_0;
+        Cycle_a_00370_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+    class Cycle_a_00370_A4 {
+        Cycle_a_00370_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00370_A5 {
+        Cycle_a_00370_A6 a6_0;
+        Cycle_a_00370_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00370_A6 {
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00370_A7 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00370_A8 {
+        Cycle_a_00370_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00370_A9 {
+        Cycle_a_00370_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00370_A10 {
+        Cycle_a_00370_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00380B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00380_A1 a1_main = new Cycle_a_00380_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00380_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00380_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00380_A1 {
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00380_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00380_A2 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00380_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00380_A3 {
+        Cycle_a_00380_A1 a1_0;
+        Cycle_a_00380_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00380_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00390B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00390_A1 a1_main = new Cycle_a_00390_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00390_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00390_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 918)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00390_A1 {
+        Cycle_a_00390_A2 a2_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00390_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00390_A2 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00390_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00390_A3 {
+        Cycle_a_00390_A1 a1_0;
+        Cycle_a_00390_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00390_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00400B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00400_A1 a1_main = new Cycle_a_00400_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00400_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00400_A3("a3_0");
+        a1_main.a4_0 = new Cycle_a_00400_A4("a4_0");
+        a1_main.a4_0.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00400_A1 {
+        Cycle_a_00400_A2 a2_0;
+        Cycle_a_00400_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00400_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00400_A2 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00400_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00400_A3 {
+        Cycle_a_00400_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00400_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00400_A4 {
+        Cycle_a_00400_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00400_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00410B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00410_A1 a1_main = new Cycle_a_00410_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00410_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00410_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00410_A4("a4_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 921)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00410_A1 {
+        Cycle_a_00410_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00410_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00410_A2 {
+        Cycle_a_00410_A3 a3_0;
+        Cycle_a_00410_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00410_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00410_A3 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00410_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00410_A4 {
+        Cycle_a_00410_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00410_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00420B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00420_A1 a1_main = new Cycle_a_00420_A1("a1_main");
+//		 Cycle_a_00420_A4 a4_main = new Cycle_a_00420_A4("a4_main");
+        a1_main.a2_0 = new Cycle_a_00420_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00420_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00420_A4("a4_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 923)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00420_A1 {
+        Cycle_a_00420_A2 a2_0;
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00420_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00420_A2 {
+        Cycle_a_00420_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00420_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00420_A3 {
+        Cycle_a_00420_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00420_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00420_A4 {
+        Cycle_a_00420_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00420_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00430B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00430_A1 a1_main = new Cycle_a_00430_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00430_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00430_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00430_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1124)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00430_A1 {
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00430_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00430_A2 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A3 a3_0;
+        Cycle_a_00430_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00430_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00430_A3 {
+        Cycle_a_00430_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00430_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00430_A4 {
+        Cycle_a_00430_A1 a1_0;
+        Cycle_a_00430_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00430_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00440B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00440_A1 a1_main = new Cycle_a_00440_A1("a1_main");
+        a1_main.a2_0 = new Cycle_a_00440_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00440_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_a_00440_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1023)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00440_A1 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00440_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00440_A2 {
+        Cycle_a_00440_A1 a1_0;
+        Cycle_a_00440_A3 a3_0;
+        Cycle_a_00440_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00440_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00440_A3 {
+        Cycle_a_00440_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00440_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00440_A4 {
+        Cycle_a_00440_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00440_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00450B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00450_A1 a1_main = new Cycle_a_00450_A1("a1_main");
+        Cycle_a_00450_A6 a6_main = new Cycle_a_00450_A6("a6_main");
+        Cycle_a_00450_A7 a7_main = new Cycle_a_00450_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00450_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00450_A3("a3_0");
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00450_A5("a5_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = a7_main;
+        a7_main.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a6_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1453)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00450_A1 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00450_A2 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00450_A3 {
+        Cycle_a_00450_A1 a1_0;
+        Cycle_a_00450_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00450_A5 {
+        Cycle_a_00450_A6 a6_0;
+        Cycle_a_00450_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A5(String strObjectName) {
+            a6_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_00450_A6 {
+        Cycle_a_00450_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00450_A7 {
+        Cycle_a_00450_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00450_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00460B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00460_A1 a1_main = new Cycle_a_00460_A1("a1_main");
+        Cycle_a_00460_A5 a5_main = new Cycle_a_00460_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00460_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00460_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00460_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00460_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00460_A1 {
+        Cycle_a_00460_A2 a2_0;
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A1(String strObjectName) {
+            a2_0 = null;
+            a4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00460_A2 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00460_A3 {
+        Cycle_a_00460_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00460_A4 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00460_A5 {
+        Cycle_a_00460_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00460_A6 {
+        Cycle_a_00460_A1 a1_0;
+        Cycle_a_00460_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00460_A6(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00470B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00470_A1 a1_main = new Cycle_a_00470_A1("a1_main");
+        Cycle_a_00470_A5 a5_main = new Cycle_a_00470_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00470_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00470_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00470_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00470_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a1_0 = a1_main;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1446)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00470_A1 {
+        Cycle_a_00470_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00470_A2 {
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00470_A3 {
+        Cycle_a_00470_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00470_A4 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00470_A5 {
+        Cycle_a_00470_A1 a1_0;
+        Cycle_a_00470_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A5(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00470_A6 {
+        Cycle_a_00470_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00470_A6(String strObjectName) {
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00480B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00480_A1 a1_main = new Cycle_a_00480_A1("a1_main");
+        Cycle_a_00480_A5 a5_main = new Cycle_a_00480_A5("a5_main");
+        a1_main.a2_0 = new Cycle_a_00480_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00480_A3("a3_0");
+        a1_main.a2_0.a3_0.a4_0 = new Cycle_a_00480_A4("a4_0");
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new Cycle_a_00480_A6("a6_0");
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.a2_0.a3_0.a4_0.a6_0.a1_0 = a1_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a5_main.a3_0.a4_0 = a1_main.a2_0.a3_0.a4_0;
+        a1_main.add();
+        a5_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a4_0.add();
+        a1_main.a2_0.a3_0.a4_0.a1_0.add();
+        a1_main.a2_0.a3_0.a4_0.a6_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a5_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.add();
+//		 a1_main.a2_0.a3_0.a4_0.a6_0.a1_0.add();
+        a5_main.a3_0.add();
+        a5_main.a3_0.a4_0.add();
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a5_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum:"+a1_main.a2_0.a3_0.a4_0.a6_0.a4_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a5_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a1_main.a2_0.a3_0.a4_0.sum+a1_main.a2_0.a3_0.a4_0.a6_0.sum);
+        int result = a1_main.sum + a5_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a4_0.sum + a1_main.a2_0.a3_0.a4_0.a6_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1550)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00480_A1 {
+        Cycle_a_00480_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00480_A2 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00480_A3 {
+        Cycle_a_00480_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A3(String strObjectName) {
+            a4_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00480_A4 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A4(String strObjectName) {
+            a1_0 = null;
+            a6_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    class Cycle_a_00480_A5 {
+        Cycle_a_00480_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A5(String strObjectName) {
+            a3_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00480_A6 {
+        Cycle_a_00480_A1 a1_0;
+        Cycle_a_00480_A4 a4_0;
+        Cycle_a_00480_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00480_A6(String strObjectName) {
+            a1_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a + a5_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00490B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00490_A1 a1_main = new Cycle_a_00490_A1("a1_main");
+        Cycle_a_00490_A4 a4_main = new Cycle_a_00490_A4("a4_main");
+        Cycle_a_00490_A7 a7_main = new Cycle_a_00490_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00490_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00490_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00490_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+//		 a4_main.a5_0.a6_0.a3_0 = new Cycle_a_00490_A3("a3_0");
+        a4_main.a5_0.a6_0.a3_0 = a1_main.a2_0.a3_0;
+        a4_main.a5_0.a6_0.a3_0.a1_0 = a1_main;
+        a7_main.a9_0 = new Cycle_a_00490_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00490_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0.a8_0.a5_0 = a4_main.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a6_0.a3_0.add();
+        a4_main.a5_0.a6_0.a3_0.a1_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        a7_main.a9_0.a8_0.a5_0.add();
+//
+//		 System.out.println("a1_main.sum:"+a1_main.sum);
+//		 System.out.println("a4_main.sum:"+a4_main.sum);
+//		 System.out.println("a7_main.sum:"+a7_main.sum);
+//		 System.out.println("a1_main.a2_0.sum:"+a1_main.a2_0.sum);
+//		 System.out.println("a1_main.a2_0.a3_0.sum:"+a1_main.a2_0.a3_0.sum);
+//		 System.out.println("a4_main.a5_0.sum:"+a4_main.a5_0.sum);
+//		 System.out.println("a4_main.a5_0.a6_0.sum:"+a4_main.a5_0.a6_0.sum);
+//		 System.out.println("a7_main.a9_0.sum:"+a7_main.a9_0.sum);
+//		 System.out.println("a7_main.a9_0.a8_0.sum:"+a7_main.a9_0.a8_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a4_main.sum+a7_main.sum+a1_main.a2_0.sum+a1_main.a2_0.a3_0.sum+a4_main.a5_0.sum+a4_main.a5_0.a6_0.sum+a7_main.a9_0.sum+a7_main.a9_0.a8_0.sum);
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2098)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00490_A1 {
+        Cycle_a_00490_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00490_A2 {
+        Cycle_a_00490_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00490_A3 {
+        Cycle_a_00490_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00490_A4 {
+        Cycle_a_00490_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_a_00490_A5 {
+        Cycle_a_00490_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00490_A6 {
+        Cycle_a_00490_A3 a3_0;
+        Cycle_a_00490_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A6(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00490_A7 {
+        Cycle_a_00490_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_00490_A8 {
+        Cycle_a_00490_A5 a5_0;
+        Cycle_a_00490_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A8(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00490_A9 {
+        Cycle_a_00490_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00490_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_00500B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00500_A1 a1_main = new Cycle_a_00500_A1("a1_main");
+        Cycle_a_00500_A4 a4_main = new Cycle_a_00500_A4("a4_main");
+        Cycle_a_00500_A7 a7_main = new Cycle_a_00500_A7("a7_main");
+        a1_main.a2_0 = new Cycle_a_00500_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00500_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a4_main.a1_0 = a1_main;
+        a4_main.a5_0 = new Cycle_a_00500_A5("a5_0");
+        a4_main.a5_0.a6_0 = new Cycle_a_00500_A6("a6_0");
+        a4_main.a5_0.a6_0.a4_0 = a4_main;
+        a4_main.a5_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a4_main.a5_0.a8_0.a7_0 = a7_main;
+        a7_main.a9_0 = new Cycle_a_00500_A9("a9_0");
+        a7_main.a9_0.a8_0 = new Cycle_a_00500_A8("a8_0");
+        a7_main.a9_0.a8_0.a7_0 = a7_main;
+        a1_main.add();
+        a4_main.add();
+        a7_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a1_0.add();
+        a4_main.a1_0.add();
+        a4_main.a5_0.add();
+        a4_main.a5_0.a6_0.add();
+        a4_main.a5_0.a6_0.a4_0.add();
+        a4_main.a5_0.a8_0.add();
+        a4_main.a5_0.a8_0.a7_0.add();
+        a7_main.a9_0.add();
+        a7_main.a9_0.a8_0.add();
+        a7_main.a9_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a7_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a4_main.a5_0.sum + a4_main.a5_0.a6_0.sum + a7_main.a9_0.sum + a7_main.a9_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2099)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00500_A1 {
+        Cycle_a_00500_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00500_A2 {
+        Cycle_a_00500_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_00500_A3 {
+        Cycle_a_00500_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00500_A4 {
+        Cycle_a_00500_A1 a1_0;
+        Cycle_a_00500_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A4(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00500_A5 {
+        Cycle_a_00500_A6 a6_0;
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00500_A6 {
+        Cycle_a_00500_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A6(String strObjectName) {
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_a_00500_A7 {
+        Cycle_a_00500_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A7(String strObjectName) {
+            a9_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_00500_A8 {
+        Cycle_a_00500_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00500_A9 {
+        Cycle_a_00500_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00500_A9(String strObjectName) {
+            a8_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+public class Cycle_am_00510 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00180B A1_Cycle_am_00180 = new ThreadRc_Cycle_am_00180B();
+        ThreadRc_Cycle_am_00180B A2_Cycle_am_00180 = new ThreadRc_Cycle_am_00180B();
+        ThreadRc_Cycle_am_00190B A1_Cycle_am_00190 = new ThreadRc_Cycle_am_00190B();
+        ThreadRc_Cycle_am_00190B A2_Cycle_am_00190 = new ThreadRc_Cycle_am_00190B();
+        ThreadRc_Cycle_am_00200B A1_Cycle_am_00200 = new ThreadRc_Cycle_am_00200B();
+        ThreadRc_Cycle_am_00200B A2_Cycle_am_00200 = new ThreadRc_Cycle_am_00200B();
+        ThreadRc_Cycle_am_00210B A1_Cycle_am_00210 = new ThreadRc_Cycle_am_00210B();
+        ThreadRc_Cycle_am_00210B A2_Cycle_am_00210 = new ThreadRc_Cycle_am_00210B();
+        ThreadRc_Cycle_am_00220B A1_Cycle_am_00220 = new ThreadRc_Cycle_am_00220B();
+        ThreadRc_Cycle_am_00220B A2_Cycle_am_00220 = new ThreadRc_Cycle_am_00220B();
+        ThreadRc_Cycle_am_00230B A1_Cycle_am_00230 = new ThreadRc_Cycle_am_00230B();
+        ThreadRc_Cycle_am_00230B A2_Cycle_am_00230 = new ThreadRc_Cycle_am_00230B();
+        ThreadRc_Cycle_am_00240B A1_Cycle_am_00240 = new ThreadRc_Cycle_am_00240B();
+        ThreadRc_Cycle_am_00240B A2_Cycle_am_00240 = new ThreadRc_Cycle_am_00240B();
+        ThreadRc_Cycle_am_00250B A1_Cycle_am_00250 = new ThreadRc_Cycle_am_00250B();
+        ThreadRc_Cycle_am_00250B A2_Cycle_am_00250 = new ThreadRc_Cycle_am_00250B();
+        ThreadRc_Cycle_am_00260B A1_Cycle_am_00260 = new ThreadRc_Cycle_am_00260B();
+        ThreadRc_Cycle_am_00260B A2_Cycle_am_00260 = new ThreadRc_Cycle_am_00260B();
+        ThreadRc_Cycle_am_00270B A1_Cycle_am_00270 = new ThreadRc_Cycle_am_00270B();
+        ThreadRc_Cycle_am_00270B A2_Cycle_am_00270 = new ThreadRc_Cycle_am_00270B();
+        ThreadRc_Cycle_am_00280B A1_Cycle_am_00280 = new ThreadRc_Cycle_am_00280B();
+        ThreadRc_Cycle_am_00280B A2_Cycle_am_00280 = new ThreadRc_Cycle_am_00280B();
+        ThreadRc_Cycle_am_00290B A1_Cycle_am_00290 = new ThreadRc_Cycle_am_00290B();
+        ThreadRc_Cycle_am_00290B A2_Cycle_am_00290 = new ThreadRc_Cycle_am_00290B();
+        ThreadRc_Cycle_am_00300B A1_Cycle_am_00300 = new ThreadRc_Cycle_am_00300B();
+        ThreadRc_Cycle_am_00300B A2_Cycle_am_00300 = new ThreadRc_Cycle_am_00300B();
+        ThreadRc_Cycle_am_00310B A1_Cycle_am_00310 = new ThreadRc_Cycle_am_00310B();
+        ThreadRc_Cycle_am_00310B A2_Cycle_am_00310 = new ThreadRc_Cycle_am_00310B();
+        ThreadRc_Cycle_am_00320B A1_Cycle_am_00320 = new ThreadRc_Cycle_am_00320B();
+        ThreadRc_Cycle_am_00320B A2_Cycle_am_00320 = new ThreadRc_Cycle_am_00320B();
+        ThreadRc_Cycle_am_00330B A1_Cycle_am_00330 = new ThreadRc_Cycle_am_00330B();
+        ThreadRc_Cycle_am_00330B A2_Cycle_am_00330 = new ThreadRc_Cycle_am_00330B();
+        ThreadRc_Cycle_am_00340B A1_Cycle_am_00340 = new ThreadRc_Cycle_am_00340B();
+        ThreadRc_Cycle_am_00340B A2_Cycle_am_00340 = new ThreadRc_Cycle_am_00340B();
+        ThreadRc_Cycle_am_00350B A1_Cycle_am_00350 = new ThreadRc_Cycle_am_00350B();
+        ThreadRc_Cycle_am_00350B A2_Cycle_am_00350 = new ThreadRc_Cycle_am_00350B();
+        ThreadRc_Cycle_am_00360B A1_Cycle_am_00360 = new ThreadRc_Cycle_am_00360B();
+        ThreadRc_Cycle_am_00360B A2_Cycle_am_00360 = new ThreadRc_Cycle_am_00360B();
+        ThreadRc_Cycle_am_00370B A1_Cycle_am_00370 = new ThreadRc_Cycle_am_00370B();
+        ThreadRc_Cycle_am_00370B A2_Cycle_am_00370 = new ThreadRc_Cycle_am_00370B();
+        ThreadRc_Cycle_am_00380B A1_Cycle_am_00380 = new ThreadRc_Cycle_am_00380B();
+        ThreadRc_Cycle_am_00380B A2_Cycle_am_00380 = new ThreadRc_Cycle_am_00380B();
+        ThreadRc_Cycle_am_00390B A1_Cycle_am_00390 = new ThreadRc_Cycle_am_00390B();
+        ThreadRc_Cycle_am_00390B A2_Cycle_am_00390 = new ThreadRc_Cycle_am_00390B();
+        ThreadRc_Cycle_am_00400B A1_Cycle_am_00400 = new ThreadRc_Cycle_am_00400B();
+        ThreadRc_Cycle_am_00400B A2_Cycle_am_00400 = new ThreadRc_Cycle_am_00400B();
+        ThreadRc_Cycle_am_00410B A1_Cycle_am_00410 = new ThreadRc_Cycle_am_00410B();
+        ThreadRc_Cycle_am_00410B A2_Cycle_am_00410 = new ThreadRc_Cycle_am_00410B();
+        ThreadRc_Cycle_am_00420B A1_Cycle_am_00420 = new ThreadRc_Cycle_am_00420B();
+        ThreadRc_Cycle_am_00420B A2_Cycle_am_00420 = new ThreadRc_Cycle_am_00420B();
+        ThreadRc_Cycle_am_00430B A1_Cycle_am_00430 = new ThreadRc_Cycle_am_00430B();
+        ThreadRc_Cycle_am_00430B A2_Cycle_am_00430 = new ThreadRc_Cycle_am_00430B();
+        ThreadRc_Cycle_am_00440B A1_Cycle_am_00440 = new ThreadRc_Cycle_am_00440B();
+        ThreadRc_Cycle_am_00440B A2_Cycle_am_00440 = new ThreadRc_Cycle_am_00440B();
+        ThreadRc_Cycle_am_00450B A1_Cycle_am_00450 = new ThreadRc_Cycle_am_00450B();
+        ThreadRc_Cycle_am_00450B A2_Cycle_am_00450 = new ThreadRc_Cycle_am_00450B();
+        ThreadRc_Cycle_am_00460B A1_Cycle_am_00460 = new ThreadRc_Cycle_am_00460B();
+        ThreadRc_Cycle_am_00460B A2_Cycle_am_00460 = new ThreadRc_Cycle_am_00460B();
+        ThreadRc_Cycle_am_00470B A1_Cycle_am_00470 = new ThreadRc_Cycle_am_00470B();
+        ThreadRc_Cycle_am_00470B A2_Cycle_am_00470 = new ThreadRc_Cycle_am_00470B();
+        ThreadRc_Cycle_am_00480B A1_Cycle_am_00480 = new ThreadRc_Cycle_am_00480B();
+        ThreadRc_Cycle_am_00480B A2_Cycle_am_00480 = new ThreadRc_Cycle_am_00480B();
+        ThreadRc_Cycle_am_00490B A1_Cycle_am_00490 = new ThreadRc_Cycle_am_00490B();
+        ThreadRc_Cycle_am_00490B A2_Cycle_am_00490 = new ThreadRc_Cycle_am_00490B();
+        ThreadRc_Cycle_am_00500B A1_Cycle_am_00500 = new ThreadRc_Cycle_am_00500B();
+        ThreadRc_Cycle_am_00500B A2_Cycle_am_00500 = new ThreadRc_Cycle_am_00500B();
+        A1_Cycle_am_00180.start();
+        A2_Cycle_am_00180.start();
+        A1_Cycle_am_00190.start();
+        A2_Cycle_am_00190.start();
+        A1_Cycle_am_00200.start();
+        A2_Cycle_am_00200.start();
+        A1_Cycle_am_00210.start();
+        A2_Cycle_am_00210.start();
+        A1_Cycle_am_00220.start();
+        A2_Cycle_am_00220.start();
+        A1_Cycle_am_00230.start();
+        A2_Cycle_am_00230.start();
+        A1_Cycle_am_00240.start();
+        A2_Cycle_am_00240.start();
+        A1_Cycle_am_00250.start();
+        A2_Cycle_am_00250.start();
+        A1_Cycle_am_00260.start();
+        A2_Cycle_am_00260.start();
+        A1_Cycle_am_00270.start();
+        A2_Cycle_am_00270.start();
+        A1_Cycle_am_00280.start();
+        A2_Cycle_am_00280.start();
+        A1_Cycle_am_00290.start();
+        A2_Cycle_am_00290.start();
+        A1_Cycle_am_00300.start();
+        A2_Cycle_am_00300.start();
+        A1_Cycle_am_00310.start();
+        A2_Cycle_am_00310.start();
+        A1_Cycle_am_00320.start();
+        A2_Cycle_am_00320.start();
+        A1_Cycle_am_00330.start();
+        A2_Cycle_am_00330.start();
+        A1_Cycle_am_00340.start();
+        A2_Cycle_am_00340.start();
+        A1_Cycle_am_00350.start();
+        A2_Cycle_am_00350.start();
+        A1_Cycle_am_00360.start();
+        A2_Cycle_am_00360.start();
+        A1_Cycle_am_00370.start();
+        A2_Cycle_am_00370.start();
+        A1_Cycle_am_00380.start();
+        A2_Cycle_am_00380.start();
+        A1_Cycle_am_00390.start();
+        A2_Cycle_am_00390.start();
+        A1_Cycle_am_00400.start();
+        A2_Cycle_am_00400.start();
+        A1_Cycle_am_00410.start();
+        A2_Cycle_am_00410.start();
+        A1_Cycle_am_00420.start();
+        A2_Cycle_am_00420.start();
+        A1_Cycle_am_00430.start();
+        A2_Cycle_am_00430.start();
+        A1_Cycle_am_00440.start();
+        A2_Cycle_am_00440.start();
+        A1_Cycle_am_00450.start();
+        A2_Cycle_am_00450.start();
+        A1_Cycle_am_00460.start();
+        A2_Cycle_am_00460.start();
+        A1_Cycle_am_00470.start();
+        A2_Cycle_am_00470.start();
+        A1_Cycle_am_00480.start();
+        A2_Cycle_am_00480.start();
+        A1_Cycle_am_00490.start();
+        A2_Cycle_am_00490.start();
+        A1_Cycle_am_00500.start();
+        A2_Cycle_am_00500.start();
+        try {
+            A1_Cycle_am_00180.join();
+            A2_Cycle_am_00180.join();
+            A1_Cycle_am_00190.join();
+            A2_Cycle_am_00190.join();
+            A1_Cycle_am_00200.join();
+            A2_Cycle_am_00200.join();
+            A1_Cycle_am_00210.join();
+            A2_Cycle_am_00210.join();
+            A1_Cycle_am_00220.join();
+            A2_Cycle_am_00220.join();
+            A1_Cycle_am_00230.join();
+            A2_Cycle_am_00230.join();
+            A1_Cycle_am_00240.join();
+            A2_Cycle_am_00240.join();
+            A1_Cycle_am_00250.join();
+            A2_Cycle_am_00250.join();
+            A1_Cycle_am_00260.join();
+            A2_Cycle_am_00260.join();
+            A1_Cycle_am_00270.join();
+            A2_Cycle_am_00270.join();
+            A1_Cycle_am_00280.join();
+            A2_Cycle_am_00280.join();
+            A1_Cycle_am_00290.join();
+            A2_Cycle_am_00290.join();
+            A1_Cycle_am_00300.join();
+            A2_Cycle_am_00300.join();
+            A1_Cycle_am_00310.join();
+            A2_Cycle_am_00310.join();
+            A1_Cycle_am_00320.join();
+            A2_Cycle_am_00320.join();
+            A1_Cycle_am_00330.join();
+            A2_Cycle_am_00330.join();
+            A1_Cycle_am_00340.join();
+            A2_Cycle_am_00340.join();
+            A1_Cycle_am_00350.join();
+            A2_Cycle_am_00350.join();
+            A1_Cycle_am_00360.join();
+            A2_Cycle_am_00360.join();
+            A1_Cycle_am_00370.join();
+            A2_Cycle_am_00370.join();
+            A1_Cycle_am_00380.join();
+            A2_Cycle_am_00380.join();
+            A1_Cycle_am_00390.join();
+            A2_Cycle_am_00390.join();
+            A1_Cycle_am_00400.join();
+            A2_Cycle_am_00400.join();
+            A1_Cycle_am_00410.join();
+            A2_Cycle_am_00410.join();
+            A1_Cycle_am_00420.join();
+            A2_Cycle_am_00420.join();
+            A1_Cycle_am_00430.join();
+            A2_Cycle_am_00430.join();
+            A1_Cycle_am_00440.join();
+            A2_Cycle_am_00440.join();
+            A1_Cycle_am_00450.join();
+            A2_Cycle_am_00450.join();
+            A1_Cycle_am_00460.join();
+            A2_Cycle_am_00460.join();
+            A1_Cycle_am_00470.join();
+            A2_Cycle_am_00470.join();
+            A1_Cycle_am_00480.join();
+            A2_Cycle_am_00480.join();
+            A1_Cycle_am_00490.join();
+            A2_Cycle_am_00490.join();
+            A1_Cycle_am_00500.join();
+            A2_Cycle_am_00500.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00180.check() && A2_Cycle_am_00180.check() && A1_Cycle_am_00190.check() && A2_Cycle_am_00190.check() && A1_Cycle_am_00200.check() && A2_Cycle_am_00200.check() && A1_Cycle_am_00210.check() && A2_Cycle_am_00210.check() && A1_Cycle_am_00220.check() && A2_Cycle_am_00220.check() && A1_Cycle_am_00230.check() && A2_Cycle_am_00230.check() && A1_Cycle_am_00240.check() && A2_Cycle_am_00240.check() && A1_Cycle_am_00250.check() && A2_Cycle_am_00250.check() && A1_Cycle_am_00260.check() && A2_Cycle_am_00260.check() && A1_Cycle_am_00270.check() && A2_Cycle_am_00270.check() && A1_Cycle_am_00280.check() && A2_Cycle_am_00280.check() && A1_Cycle_am_00290.check() && A2_Cycle_am_00290.check() && A1_Cycle_am_00300.check() && A2_Cycle_am_00300.check() && A1_Cycle_am_00310.check() && A2_Cycle_am_00310.check() && A1_Cycle_am_00320.check() && A2_Cycle_am_00320.check() && A1_Cycle_am_00330.check() && A2_Cycle_am_00330.check() && A1_Cycle_am_00340.check() && A2_Cycle_am_00340.check() && A1_Cycle_am_00350.check() && A2_Cycle_am_00350.check() && A1_Cycle_am_00360.check() && A2_Cycle_am_00360.check() && A1_Cycle_am_00370.check() && A2_Cycle_am_00370.check() && A1_Cycle_am_00380.check() && A2_Cycle_am_00380.check() && A1_Cycle_am_00390.check() && A2_Cycle_am_00390.check() && A1_Cycle_am_00400.check() && A2_Cycle_am_00400.check() && A1_Cycle_am_00410.check() && A2_Cycle_am_00410.check() && A1_Cycle_am_00420.check() && A2_Cycle_am_00420.check() && A1_Cycle_am_00430.check() && A2_Cycle_am_00430.check() && A1_Cycle_am_00440.check() && A2_Cycle_am_00440.check() && A1_Cycle_am_00450.check() && A2_Cycle_am_00450.check() && A1_Cycle_am_00460.check() && A2_Cycle_am_00460.check() && A1_Cycle_am_00470.check() && A2_Cycle_am_00470.check() && A1_Cycle_am_00480.check() && A2_Cycle_am_00480.check() && A1_Cycle_am_00490.check() && A2_Cycle_am_00490.check() && A1_Cycle_am_00500.check() && A2_Cycle_am_00500.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/expected.txt b/testsuite/java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f33a8592d2316dcaefb376e2e77d12a354a4918e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/expected.txt
@@ -0,0 +1,4 @@
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/test.cfg b/testsuite/java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1195d94a27582581d128ada3de3d5b5ea622b074
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0153-rc-function-RC_Thread01-Cycle_am_00510/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_00510)
+run(Cycle_am_00510,EXPECTNUM=4)
diff --git a/testsuite/java_test/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/Cycle_am_10010.java b/testsuite/java_test/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/Cycle_am_10010.java
new file mode 100755
index 0000000000000000000000000000000000000000..f8b13d40f5f030533e77667fd6c5f276afa3169d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/Cycle_am_10010.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_10010 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_10010_A1 a1_main = new Cycle_a_10010_A1("a1_main");
+        Cycle_a_10010_A4 a4_main = new Cycle_a_10010_A4("a4_main");
+        Cycle_a_10010_A6 a6_main = new Cycle_a_10010_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_10010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10010_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10010_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_10010_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10010_2A1 a1_2main = new Cycle_a_10010_2A1("a1_2main");
+        Cycle_a_10010_2A4 a4_2main = new Cycle_a_10010_2A4("a4_2main");
+        Cycle_a_10010_2A6 a6_2main = new Cycle_a_10010_2A6("a6_2main");
+        a1_2main.a2_0 = new Cycle_a_10010_2A2("a2_0");
+        a1_2main.a2_0.a3_0 = new Cycle_a_10010_2A3("a3_0");
+        a1_2main.a2_0.a4_0 = a4_2main;
+        a4_2main.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a5_0 = new Cycle_a_10010_2A5("a5_0");
+        a1_2main.a2_0.a3_0.a5_0.a6_0 = a6_2main;
+        a1_2main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10010_2A8("a8_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10010_2A7("a7_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_2main.a2_0.a3_0;
+        a6_2main.a1_0 = a1_2main;
+        a6_2main.a3_0 = a1_2main.a2_0.a3_0;
+        a1_2main.add();
+        a4_2main.add();
+        a6_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        a1_2main.a2_0.a3_0.a5_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result2 = a1_2main.sum + a4_2main.sum + a6_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum + a1_2main.a2_0.a3_0.a5_0.sum + a6_2main.a3_0.a5_0.a8_0.a7_0.sum + a6_2main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+        if (result == 3852)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_10010_A1 {
+        Cycle_a_10010_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10010_A2 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_10010_A3 {
+        Cycle_a_10010_A1 a1_0;
+        Cycle_a_10010_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_10010_A4 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_10010_A5 {
+        Cycle_a_10010_A4 a4_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_10010_A6 {
+        Cycle_a_10010_A5 a5_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_10010_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Cycle_a_10010_2A1 {
+        Cycle_a_10010_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10010_2A2 {
+        Cycle_a_10010_2A3 a3_0;
+        Cycle_a_10010_2A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_10010_2A3 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_10010_2A4 {
+        Cycle_a_10010_2A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_10010_2A5 {
+        Cycle_a_10010_2A6 a6_0;
+        Cycle_a_10010_2A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_10010_2A6 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_10010_2A7 {
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_10010_2A8 {
+        Cycle_a_10010_2A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+public class Cycle_am_10010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_10010 A1_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A2_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A3_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A4_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A5_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        ThreadRc_Cycle_am_10010 A6_Cycle_am_10010 = new ThreadRc_Cycle_am_10010();
+        A1_Cycle_am_10010.start();
+        A2_Cycle_am_10010.start();
+        A3_Cycle_am_10010.start();
+        A4_Cycle_am_10010.start();
+        A5_Cycle_am_10010.start();
+        A6_Cycle_am_10010.start();
+        try {
+            A1_Cycle_am_10010.join();
+            A2_Cycle_am_10010.join();
+            A3_Cycle_am_10010.join();
+            A4_Cycle_am_10010.join();
+            A5_Cycle_am_10010.join();
+            A6_Cycle_am_10010.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_10010.check() && A2_Cycle_am_10010.check() && A3_Cycle_am_10010.check() && A4_Cycle_am_10010.check() && A5_Cycle_am_10010.check() && A6_Cycle_am_10010.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/expected.txt b/testsuite/java_test/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/test.cfg b/testsuite/java_test/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bca4fcb97973f8e6f631dd38048cbf85cd7a29f3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0154-rc-function-RC_Thread01-Cycle_am_10010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_10010)
+run(Cycle_am_10010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/Cycle_am_10020.java b/testsuite/java_test/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/Cycle_am_10020.java
new file mode 100755
index 0000000000000000000000000000000000000000..029809b7b238587579d677c4e2a9e060ada858c5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/Cycle_am_10020.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_10020 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_10020_A1 a1_main = new Cycle_a_10020_A1("a1_main");
+        Cycle_a_10020_A4 a4_main = new Cycle_a_10020_A4("a4_main");
+        Cycle_a_10020_A6 a6_main = new Cycle_a_10020_A6("a6_main");
+        Cycle_a_10020_A9 a9_main = new Cycle_a_10020_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_10020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10020_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10020_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_10020_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10020_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10020_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10020_2A1 a1_2main = new Cycle_a_10020_2A1("a1_2main");
+        a1_2main.a2_0 = new Cycle_a_10020_2A2("a2_0");
+        a1_2main.a2_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0 = new Cycle_a_10020_2A3("a3_0");
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a2_0 = a1_2main.a2_0;
+        a1_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        int result2 = a1_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+        if (result == 3438)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_10020_A1 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10020_A2 {
+        Cycle_a_10020_A3 a3_0;
+        Cycle_a_10020_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_10020_A3 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A5 a5_0;
+        Cycle_a_10020_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+    class Cycle_a_10020_A4 {
+        Cycle_a_10020_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_10020_A5 {
+        Cycle_a_10020_A6 a6_0;
+        Cycle_a_10020_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_10020_A6 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_10020_A7 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10020_A8 {
+        Cycle_a_10020_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_10020_A9 {
+        Cycle_a_10020_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_10020_A10 {
+        Cycle_a_10020_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_10020_2A1 {
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10020_2A2 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_2A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_10020_2A3 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_2A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+public class Cycle_am_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_10020 A1_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A2_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A3_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A4_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A5_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        ThreadRc_Cycle_am_10020 A6_Cycle_am_10020 = new ThreadRc_Cycle_am_10020();
+        A1_Cycle_am_10020.start();
+        A2_Cycle_am_10020.start();
+        A3_Cycle_am_10020.start();
+        A4_Cycle_am_10020.start();
+        A5_Cycle_am_10020.start();
+        A6_Cycle_am_10020.start();
+        try {
+            A1_Cycle_am_10020.join();
+            A2_Cycle_am_10020.join();
+            A3_Cycle_am_10020.join();
+            A4_Cycle_am_10020.join();
+            A5_Cycle_am_10020.join();
+            A6_Cycle_am_10020.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_10020.check() && A2_Cycle_am_10020.check() && A3_Cycle_am_10020.check() && A4_Cycle_am_10020.check() && A5_Cycle_am_10020.check() && A6_Cycle_am_10020.check())
+           System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/expected.txt b/testsuite/java_test/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/test.cfg b/testsuite/java_test/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..34a378c0d2645ef6ad004e81d2121ad8a46c9f80
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0155-rc-function-RC_Thread01-Cycle_am_10020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_10020)
+run(Cycle_am_10020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/Cycle_am_10030.java b/testsuite/java_test/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/Cycle_am_10030.java
new file mode 100755
index 0000000000000000000000000000000000000000..13d7eefd8f5070e2d5ee6f2e8cb83fbb870c746b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/Cycle_am_10030.java
@@ -0,0 +1,651 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_am_10020B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_10020_A1 a1_main = new Cycle_a_10020_A1("a1_main");
+        Cycle_a_10020_A4 a4_main = new Cycle_a_10020_A4("a4_main");
+        Cycle_a_10020_A6 a6_main = new Cycle_a_10020_A6("a6_main");
+        Cycle_a_10020_A9 a9_main = new Cycle_a_10020_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_10020_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10020_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10020_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_10020_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10020_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10020_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a3_0.a5_0.a8_0.a7_0.sum + a6_main.a3_0.a5_0.a8_0.sum + a6_main.a3_0.a10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10020_2A1 a1_2main = new Cycle_a_10020_2A1("a1_2main");
+        a1_2main.a2_0 = new Cycle_a_10020_2A2("a2_0");
+        a1_2main.a2_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0 = new Cycle_a_10020_2A3("a3_0");
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a2_0 = a1_2main.a2_0;
+        a1_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        int result2 = a1_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+        if (result == 3438)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_10020_A1 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10020_A2 {
+        Cycle_a_10020_A3 a3_0;
+        Cycle_a_10020_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_10020_A3 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A5 a5_0;
+        Cycle_a_10020_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+    class Cycle_a_10020_A4 {
+        Cycle_a_10020_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_10020_A5 {
+        Cycle_a_10020_A6 a6_0;
+        Cycle_a_10020_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_10020_A6 {
+        Cycle_a_10020_A1 a1_0;
+        Cycle_a_10020_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_10020_A7 {
+        Cycle_a_10020_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10020_A8 {
+        Cycle_a_10020_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_10020_A9 {
+        Cycle_a_10020_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_10020_A10 {
+        Cycle_a_10020_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_a_10020_2A1 {
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10020_2A2 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_2A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_10020_2A3 {
+        Cycle_a_10020_2A1 a1_0;
+        Cycle_a_10020_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10020_2A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_am_10010B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_10010_A1 a1_main = new Cycle_a_10010_A1("a1_main");
+        Cycle_a_10010_A4 a4_main = new Cycle_a_10010_A4("a4_main");
+        Cycle_a_10010_A6 a6_main = new Cycle_a_10010_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_10010_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_10010_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_10010_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a4_0 = a4_main;
+        a4_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0.a5_0.a7_0 = new Cycle_a_10010_A7("a7_0");
+        a6_main.a7_0 = a1_main.a2_0.a3_0.a5_0.a7_0;
+        a6_main.a5_0 = a1_main.a2_0.a3_0.a5_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a5_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a6_main.a7_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_a_10010_2A1 a1_2main = new Cycle_a_10010_2A1("a1_2main");
+        Cycle_a_10010_2A4 a4_2main = new Cycle_a_10010_2A4("a4_2main");
+        Cycle_a_10010_2A6 a6_2main = new Cycle_a_10010_2A6("a6_2main");
+        a1_2main.a2_0 = new Cycle_a_10010_2A2("a2_0");
+        a1_2main.a2_0.a3_0 = new Cycle_a_10010_2A3("a3_0");
+        a1_2main.a2_0.a4_0 = a4_2main;
+        a4_2main.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a1_0 = a1_2main;
+        a1_2main.a2_0.a3_0.a5_0 = new Cycle_a_10010_2A5("a5_0");
+        a1_2main.a2_0.a3_0.a5_0.a6_0 = a6_2main;
+        a1_2main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_10010_2A8("a8_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_10010_2A7("a7_0");
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.a3_0 = a1_2main.a2_0.a3_0;
+        a6_2main.a1_0 = a1_2main;
+        a6_2main.a3_0 = a1_2main.a2_0.a3_0;
+        a1_2main.add();
+        a4_2main.add();
+        a6_2main.add();
+        a1_2main.a2_0.add();
+        a1_2main.a2_0.a3_0.add();
+        a1_2main.a2_0.a3_0.a5_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_2main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result2 = a1_2main.sum + a4_2main.sum + a6_2main.sum + a1_2main.a2_0.sum + a1_2main.a2_0.a3_0.sum + a1_2main.a2_0.a3_0.a5_0.sum + a6_2main.a3_0.a5_0.a8_0.a7_0.sum + a6_2main.a3_0.a5_0.a8_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        result += result2;
+        if (result == 3852)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_10010_A1 {
+        Cycle_a_10010_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10010_A2 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_10010_A3 {
+        Cycle_a_10010_A1 a1_0;
+        Cycle_a_10010_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_10010_A4 {
+        Cycle_a_10010_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A4(String strObjectName) {
+            a3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_10010_A5 {
+        Cycle_a_10010_A4 a4_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A5(String strObjectName) {
+            a4_0 = null;
+            a7_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a4_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_10010_A6 {
+        Cycle_a_10010_A5 a5_0;
+        Cycle_a_10010_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A6(String strObjectName) {
+            a5_0 = null;
+            a7_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a + a7_0.a;
+        }
+    }
+    class Cycle_a_10010_A7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_A7(String strObjectName) {
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Cycle_a_10010_2A1 {
+        Cycle_a_10010_2A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_10010_2A2 {
+        Cycle_a_10010_2A3 a3_0;
+        Cycle_a_10010_2A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_10010_2A3 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_10010_2A4 {
+        Cycle_a_10010_2A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_10010_2A5 {
+        Cycle_a_10010_2A6 a6_0;
+        Cycle_a_10010_2A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_10010_2A6 {
+        Cycle_a_10010_2A1 a1_0;
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_10010_2A7 {
+        Cycle_a_10010_2A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A7(String strObjectName) {
+            a3_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_a_10010_2A8 {
+        Cycle_a_10010_2A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_10010_2A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+}
+public class Cycle_am_10030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_10010B A1_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A2_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A3_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A4_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A5_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10010B A6_Cycle_am_10010 = new ThreadRc_Cycle_am_10010B();
+        ThreadRc_Cycle_am_10020B A1_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A2_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A3_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A4_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A5_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        ThreadRc_Cycle_am_10020B A6_Cycle_am_10020 = new ThreadRc_Cycle_am_10020B();
+        A1_Cycle_am_10010.start();
+        A2_Cycle_am_10010.start();
+        A3_Cycle_am_10010.start();
+        A4_Cycle_am_10010.start();
+        A5_Cycle_am_10010.start();
+        A6_Cycle_am_10010.start();
+        A1_Cycle_am_10020.start();
+        A2_Cycle_am_10020.start();
+        A3_Cycle_am_10020.start();
+        A4_Cycle_am_10020.start();
+        A5_Cycle_am_10020.start();
+        A6_Cycle_am_10020.start();
+        try {
+            A1_Cycle_am_10010.join();
+            A2_Cycle_am_10010.join();
+            A3_Cycle_am_10010.join();
+            A4_Cycle_am_10010.join();
+            A5_Cycle_am_10010.join();
+            A6_Cycle_am_10010.join();
+            A1_Cycle_am_10020.join();
+            A2_Cycle_am_10020.join();
+            A3_Cycle_am_10020.join();
+            A4_Cycle_am_10020.join();
+            A5_Cycle_am_10020.join();
+            A6_Cycle_am_10020.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_10010.check() && A2_Cycle_am_10010.check() && A3_Cycle_am_10010.check() && A4_Cycle_am_10010.check() && A5_Cycle_am_10010.check() && A6_Cycle_am_10010.check() && A1_Cycle_am_10020.check() && A2_Cycle_am_10020.check() && A3_Cycle_am_10020.check() && A4_Cycle_am_10020.check() && A5_Cycle_am_10020.check() && A6_Cycle_am_10020.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/expected.txt b/testsuite/java_test/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/test.cfg b/testsuite/java_test/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..902acb5f9a021aebab76366a6a77bd1845cdc1e4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0156-rc-function-RC_Thread01-Cycle_am_10030/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_am_10030)
+run(Cycle_am_10030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/Cycle_Bm_1_00010.java b/testsuite/java_test/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/Cycle_Bm_1_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..0eacb2a770b1053685c07975bd2cf0208422aada
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/Cycle_Bm_1_00010.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00010 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 246)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00010_A1 {
+        Cycle_B_1_00010_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00010_A1() {
+            a1_0 = null;
+            a = 123;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00010 A1_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A2_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A3_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A4_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A5_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A6_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        A1_Cycle_Bm_1_00010.start();
+        A2_Cycle_Bm_1_00010.start();
+        A3_Cycle_Bm_1_00010.start();
+        A4_Cycle_Bm_1_00010.start();
+        A5_Cycle_Bm_1_00010.start();
+        A6_Cycle_Bm_1_00010.start();
+        try {
+            A1_Cycle_Bm_1_00010.join();
+            A2_Cycle_Bm_1_00010.join();
+            A3_Cycle_Bm_1_00010.join();
+            A4_Cycle_Bm_1_00010.join();
+            A5_Cycle_Bm_1_00010.join();
+            A6_Cycle_Bm_1_00010.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00010.check() && A2_Cycle_Bm_1_00010.check() && A3_Cycle_Bm_1_00010.check() && A4_Cycle_Bm_1_00010.check() && A5_Cycle_Bm_1_00010.check() && A6_Cycle_Bm_1_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/expected.txt b/testsuite/java_test/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/test.cfg b/testsuite/java_test/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1aa5778d4cb6ed5a8f292afede805a7df7e51ae5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00010)
+run(Cycle_Bm_1_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/Cycle_Bm_1_00020.java b/testsuite/java_test/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/Cycle_Bm_1_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..561db7bf1e5da96c2d79bb11f89f68cef8ab6051
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/Cycle_Bm_1_00020.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00020 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00020_A1 a1_0 = new Cycle_B_1_00020_A1();
+        a1_0.a2_0 = new Cycle_B_1_00020_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 6)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00020_A1 {
+        Cycle_B_1_00020_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00020_A2 {
+        Cycle_B_1_00020_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00020_A2() {
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00020 A1_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A2_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A3_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A4_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A5_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        ThreadRc_Cycle_Bm_1_00020 A6_Cycle_Bm_1_00020 = new ThreadRc_Cycle_Bm_1_00020();
+        A1_Cycle_Bm_1_00020.start();
+        A2_Cycle_Bm_1_00020.start();
+        A3_Cycle_Bm_1_00020.start();
+        A4_Cycle_Bm_1_00020.start();
+        A5_Cycle_Bm_1_00020.start();
+        A6_Cycle_Bm_1_00020.start();
+        try {
+            A1_Cycle_Bm_1_00020.join();
+            A2_Cycle_Bm_1_00020.join();
+            A3_Cycle_Bm_1_00020.join();
+            A4_Cycle_Bm_1_00020.join();
+            A5_Cycle_Bm_1_00020.join();
+            A6_Cycle_Bm_1_00020.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00020.check() && A2_Cycle_Bm_1_00020.check() && A3_Cycle_Bm_1_00020.check() && A4_Cycle_Bm_1_00020.check() && A5_Cycle_Bm_1_00020.check() && A6_Cycle_Bm_1_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/expected.txt b/testsuite/java_test/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/test.cfg b/testsuite/java_test/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d1c5358e58dc9948e3ac69ae8f195f0795baa6be
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00020)
+run(Cycle_Bm_1_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/Cycle_Bm_1_00030.java b/testsuite/java_test/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/Cycle_Bm_1_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..7492be754c333ed0989cdc2f7bb9d71c7868b8df
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/Cycle_Bm_1_00030.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00030 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00030_A1 a1_0 = new Cycle_B_1_00030_A1();
+        a1_0.a2_0 = new Cycle_B_1_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00030_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00030_A1 {
+        Cycle_B_1_00030_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00030_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00030_A2 {
+        Cycle_B_1_00030_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00030_A3 {
+        Cycle_B_1_00030_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00030 A1_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A2_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A3_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A4_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A5_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        ThreadRc_Cycle_Bm_1_00030 A6_Cycle_Bm_1_00030 = new ThreadRc_Cycle_Bm_1_00030();
+        A1_Cycle_Bm_1_00030.start();
+        A2_Cycle_Bm_1_00030.start();
+        A3_Cycle_Bm_1_00030.start();
+        A4_Cycle_Bm_1_00030.start();
+        A5_Cycle_Bm_1_00030.start();
+        A6_Cycle_Bm_1_00030.start();
+        try {
+            A1_Cycle_Bm_1_00030.join();
+            A2_Cycle_Bm_1_00030.join();
+            A3_Cycle_Bm_1_00030.join();
+            A4_Cycle_Bm_1_00030.join();
+            A5_Cycle_Bm_1_00030.join();
+            A6_Cycle_Bm_1_00030.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00030.check() && A2_Cycle_Bm_1_00030.check() && A3_Cycle_Bm_1_00030.check() && A4_Cycle_Bm_1_00030.check() && A5_Cycle_Bm_1_00030.check() && A6_Cycle_Bm_1_00030.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/expected.txt b/testsuite/java_test/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/test.cfg b/testsuite/java_test/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..45efbfb139bc90e843a45497fa800f35dd86c1be
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00030)
+run(Cycle_Bm_1_00030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/Cycle_Bm_1_00040.java b/testsuite/java_test/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/Cycle_Bm_1_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..68d15dc6a430749013decb71e9af2f5c11da8657
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/Cycle_Bm_1_00040.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00040 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00040_A1 a1_0 = new Cycle_B_1_00040_A1();
+        a1_0.a2_0 = new Cycle_B_1_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00040_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00040_A4();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00040_A1 {
+        Cycle_B_1_00040_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00040_A2 {
+        Cycle_B_1_00040_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00040_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00040_A3 {
+        Cycle_B_1_00040_A1 a1_0;
+        Cycle_B_1_00040_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00040_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00040_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+public class Cycle_Bm_1_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00040 A1_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A2_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A3_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A4_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A5_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        ThreadRc_Cycle_Bm_1_00040 A6_Cycle_Bm_1_00040 = new ThreadRc_Cycle_Bm_1_00040();
+        A1_Cycle_Bm_1_00040.start();
+        A2_Cycle_Bm_1_00040.start();
+        A3_Cycle_Bm_1_00040.start();
+        A4_Cycle_Bm_1_00040.start();
+        A5_Cycle_Bm_1_00040.start();
+        A6_Cycle_Bm_1_00040.start();
+        try {
+            A1_Cycle_Bm_1_00040.join();
+            A2_Cycle_Bm_1_00040.join();
+            A3_Cycle_Bm_1_00040.join();
+            A4_Cycle_Bm_1_00040.join();
+            A5_Cycle_Bm_1_00040.join();
+            A6_Cycle_Bm_1_00040.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00040.check() && A2_Cycle_Bm_1_00040.check() && A3_Cycle_Bm_1_00040.check() && A4_Cycle_Bm_1_00040.check() && A5_Cycle_Bm_1_00040.check() && A6_Cycle_Bm_1_00040.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/expected.txt b/testsuite/java_test/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/test.cfg b/testsuite/java_test/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9c07aaca0bf39ba4ecfe945aa9d5f6608acef3c9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00040)
+run(Cycle_Bm_1_00040,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/Cycle_Bm_1_00050.java b/testsuite/java_test/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/Cycle_Bm_1_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..8f41d086c4bce69ff4456b7f42ebd7da3577bc69
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/Cycle_Bm_1_00050.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00050 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00050_A1 a1_0 = new Cycle_B_1_00050_A1();
+        a1_0.a2_0 = new Cycle_B_1_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00050_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00050_A4();
+        a1_0.a2_0.a5_0 = new Cycle_B_1_00050_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 34)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00050_A1 {
+        Cycle_B_1_00050_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00050_A2 {
+        Cycle_B_1_00050_A3 a3_0;
+        Cycle_B_1_00050_A4 a4_0;
+        Cycle_B_1_00050_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_1_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00050_A3 {
+        Cycle_B_1_00050_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00050_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00050_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00050_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+    class Cycle_B_1_00050_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00050_A5() {
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+public class Cycle_Bm_1_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00050 A1_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A2_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A3_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A4_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A5_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        ThreadRc_Cycle_Bm_1_00050 A6_Cycle_Bm_1_00050 = new ThreadRc_Cycle_Bm_1_00050();
+        A1_Cycle_Bm_1_00050.start();
+        A2_Cycle_Bm_1_00050.start();
+        A3_Cycle_Bm_1_00050.start();
+        A4_Cycle_Bm_1_00050.start();
+        A5_Cycle_Bm_1_00050.start();
+        A6_Cycle_Bm_1_00050.start();
+        try {
+            A1_Cycle_Bm_1_00050.join();
+            A2_Cycle_Bm_1_00050.join();
+            A3_Cycle_Bm_1_00050.join();
+            A4_Cycle_Bm_1_00050.join();
+            A5_Cycle_Bm_1_00050.join();
+            A6_Cycle_Bm_1_00050.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00050.check() && A2_Cycle_Bm_1_00050.check() && A3_Cycle_Bm_1_00050.check() && A4_Cycle_Bm_1_00050.check() && A5_Cycle_Bm_1_00050.check() && A6_Cycle_Bm_1_00050.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/expected.txt b/testsuite/java_test/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/test.cfg b/testsuite/java_test/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..33335694d2a58c2b47ce7686f55dff0cc0b9543f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00050)
+run(Cycle_Bm_1_00050,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/Cycle_Bm_1_00060.java b/testsuite/java_test/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/Cycle_Bm_1_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..edb18ca35e7f9bc4f2152a1a5892c6ebae4e1c19
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/Cycle_Bm_1_00060.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00060 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00060_A1 a1_0 = new Cycle_B_1_00060_A1();
+        a1_0.a2_0 = new Cycle_B_1_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00060_A3();
+        Cycle_B_1_00060_A4 a4_0 = new Cycle_B_1_00060_A4();
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00060_A1 {
+        Cycle_B_1_00060_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00060_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00060_A2 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00060_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00060_A3 {
+        Cycle_B_1_00060_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00060_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00060_A4 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00060 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00060 A1_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A2_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A3_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A4_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A5_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        ThreadRc_Cycle_Bm_1_00060 A6_Cycle_Bm_1_00060 = new ThreadRc_Cycle_Bm_1_00060();
+        A1_Cycle_Bm_1_00060.start();
+        A2_Cycle_Bm_1_00060.start();
+        A3_Cycle_Bm_1_00060.start();
+        A4_Cycle_Bm_1_00060.start();
+        A5_Cycle_Bm_1_00060.start();
+        A6_Cycle_Bm_1_00060.start();
+        try {
+            A1_Cycle_Bm_1_00060.join();
+            A2_Cycle_Bm_1_00060.join();
+            A3_Cycle_Bm_1_00060.join();
+            A4_Cycle_Bm_1_00060.join();
+            A5_Cycle_Bm_1_00060.join();
+            A6_Cycle_Bm_1_00060.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00060.check() && A2_Cycle_Bm_1_00060.check() && A3_Cycle_Bm_1_00060.check() && A4_Cycle_Bm_1_00060.check() && A5_Cycle_Bm_1_00060.check() && A6_Cycle_Bm_1_00060.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/expected.txt b/testsuite/java_test/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/test.cfg b/testsuite/java_test/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f1196053e564d767753490ee760b514cfa06e80
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00060)
+run(Cycle_Bm_1_00060,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/Cycle_Bm_1_00070.java b/testsuite/java_test/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/Cycle_Bm_1_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..7065b75bf2c10d91f871344c0b6e954705c6c010
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/Cycle_Bm_1_00070.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00070 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00070_A1 a1_0 = new Cycle_B_1_00070_A1();
+        a1_0.a2_0 = new Cycle_B_1_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00070_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00070_A1 {
+        Cycle_B_1_00070_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00070_A2 {
+        Cycle_B_1_00070_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00070_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00070_A3 {
+        Cycle_B_1_00070_A1 a1_0;
+        Cycle_B_1_00070_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00070_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00070_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00070_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+public class Cycle_Bm_1_00070 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00070 A1_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A2_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A3_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A4_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A5_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        ThreadRc_Cycle_Bm_1_00070 A6_Cycle_Bm_1_00070 = new ThreadRc_Cycle_Bm_1_00070();
+        A1_Cycle_Bm_1_00070.start();
+        A2_Cycle_Bm_1_00070.start();
+        A3_Cycle_Bm_1_00070.start();
+        A4_Cycle_Bm_1_00070.start();
+        A5_Cycle_Bm_1_00070.start();
+        A6_Cycle_Bm_1_00070.start();
+        try {
+            A1_Cycle_Bm_1_00070.join();
+            A2_Cycle_Bm_1_00070.join();
+            A3_Cycle_Bm_1_00070.join();
+            A4_Cycle_Bm_1_00070.join();
+            A5_Cycle_Bm_1_00070.join();
+            A6_Cycle_Bm_1_00070.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00070.check() && A2_Cycle_Bm_1_00070.check() && A3_Cycle_Bm_1_00070.check() && A4_Cycle_Bm_1_00070.check() && A5_Cycle_Bm_1_00070.check() && A6_Cycle_Bm_1_00070.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/expected.txt b/testsuite/java_test/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/test.cfg b/testsuite/java_test/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a16db3329fc32ed9a61283d57f79cf1b9cfa065
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00070)
+run(Cycle_Bm_1_00070,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/Cycle_Bm_1_00080.java b/testsuite/java_test/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/Cycle_Bm_1_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..41bd7b55a14a5d3fd0c8482bccfa70c862898315
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/Cycle_Bm_1_00080.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00080 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00080_A1 a1_0 = new Cycle_B_1_00080_A1();
+        a1_0.a2_0 = new Cycle_B_1_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00080_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00080_A4();
+        a1_0.a2_0.a3_0.a5_0 = new Cycle_B_1_00080_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 56)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00080_A1 {
+        Cycle_B_1_00080_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00080_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00080_A2 {
+        Cycle_B_1_00080_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00080_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00080_A3 {
+        Cycle_B_1_00080_A1 a1_0;
+        Cycle_B_1_00080_A4 a4_0;
+        Cycle_B_1_00080_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_1_00080_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            a4_0.add();
+            a5_0.add();
+            sum = a + a1_0.a + a4_0.sum + a5_0.sum;
+        }
+    }
+    class Cycle_B_1_00080_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00080_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+    class Cycle_B_1_00080_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00080_A5() {
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+public class Cycle_Bm_1_00080 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00080 A1_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A2_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A3_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A4_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A5_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        ThreadRc_Cycle_Bm_1_00080 A6_Cycle_Bm_1_00080 = new ThreadRc_Cycle_Bm_1_00080();
+        A1_Cycle_Bm_1_00080.start();
+        A2_Cycle_Bm_1_00080.start();
+        A3_Cycle_Bm_1_00080.start();
+        A4_Cycle_Bm_1_00080.start();
+        A5_Cycle_Bm_1_00080.start();
+        A6_Cycle_Bm_1_00080.start();
+        try {
+            A1_Cycle_Bm_1_00080.join();
+            A2_Cycle_Bm_1_00080.join();
+            A3_Cycle_Bm_1_00080.join();
+            A4_Cycle_Bm_1_00080.join();
+            A5_Cycle_Bm_1_00080.join();
+            A6_Cycle_Bm_1_00080.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00080.check() && A2_Cycle_Bm_1_00080.check() && A3_Cycle_Bm_1_00080.check() && A4_Cycle_Bm_1_00080.check() && A5_Cycle_Bm_1_00080.check() && A6_Cycle_Bm_1_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/expected.txt b/testsuite/java_test/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/test.cfg b/testsuite/java_test/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9dbf024d86064078942564ebd973e237306a507e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00080)
+run(Cycle_Bm_1_00080,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/Cycle_Bm_1_00090.java b/testsuite/java_test/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/Cycle_Bm_1_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..a59028a6038e44fe1bf82343727b9945288a1859
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/Cycle_Bm_1_00090.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00090 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00090_A1 a1_0 = new Cycle_B_1_00090_A1();
+        a1_0.a2_0 = new Cycle_B_1_00090_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00090_A3();
+        Cycle_B_1_00090_A4 a4_0 = new Cycle_B_1_00090_A4();
+        Cycle_B_1_00090_A5 a5_0 = new Cycle_B_1_00090_A5();
+        a4_0.a2_0 = a1_0.a2_0;
+        a5_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 25)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00090_A1 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00090_A2 {
+        Cycle_B_1_00090_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00090_A3 {
+        Cycle_B_1_00090_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00090_A4 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00090_A5 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00090 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00090 A1_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A2_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A3_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A4_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A5_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        ThreadRc_Cycle_Bm_1_00090 A6_Cycle_Bm_1_00090 = new ThreadRc_Cycle_Bm_1_00090();
+        A1_Cycle_Bm_1_00090.start();
+        A2_Cycle_Bm_1_00090.start();
+        A3_Cycle_Bm_1_00090.start();
+        A4_Cycle_Bm_1_00090.start();
+        A5_Cycle_Bm_1_00090.start();
+        A6_Cycle_Bm_1_00090.start();
+        try {
+            A1_Cycle_Bm_1_00090.join();
+            A2_Cycle_Bm_1_00090.join();
+            A3_Cycle_Bm_1_00090.join();
+            A4_Cycle_Bm_1_00090.join();
+            A5_Cycle_Bm_1_00090.join();
+            A6_Cycle_Bm_1_00090.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00090.check() && A2_Cycle_Bm_1_00090.check() && A3_Cycle_Bm_1_00090.check() && A4_Cycle_Bm_1_00090.check() && A5_Cycle_Bm_1_00090.check() && A6_Cycle_Bm_1_00090.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/expected.txt b/testsuite/java_test/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/test.cfg b/testsuite/java_test/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7f7f41a8381469c7eddcecd8c1c960807b7dcdf6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00090)
+run(Cycle_Bm_1_00090,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/Cycle_Bm_1_00100.java b/testsuite/java_test/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/Cycle_Bm_1_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..9e213a7963051dc4c9fbe3d7c368800bdeac6654
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/Cycle_Bm_1_00100.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00100 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00100_A1 a1_0 = new Cycle_B_1_00100_A1();
+        a1_0.a2_0 = new Cycle_B_1_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00100_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00100_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_1_00100_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00100_A1 {
+        Cycle_B_1_00100_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00100_A2 {
+        Cycle_B_1_00100_A3 a3_0;
+        Cycle_B_1_00100_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00100_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00100_A3 {
+        Cycle_B_1_00100_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00100_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00100_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00100_A5 a5_0;
+        Cycle_B_1_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+    class Cycle_B_1_00100_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00100_A5() {
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+public class Cycle_Bm_1_00100 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00100 A1_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A2_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A3_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A4_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A5_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        ThreadRc_Cycle_Bm_1_00100 A6_Cycle_Bm_1_00100 = new ThreadRc_Cycle_Bm_1_00100();
+        A1_Cycle_Bm_1_00100.start();
+        A2_Cycle_Bm_1_00100.start();
+        A3_Cycle_Bm_1_00100.start();
+        A4_Cycle_Bm_1_00100.start();
+        A5_Cycle_Bm_1_00100.start();
+        A6_Cycle_Bm_1_00100.start();
+        try {
+            A1_Cycle_Bm_1_00100.join();
+            A2_Cycle_Bm_1_00100.join();
+            A3_Cycle_Bm_1_00100.join();
+            A4_Cycle_Bm_1_00100.join();
+            A5_Cycle_Bm_1_00100.join();
+            A6_Cycle_Bm_1_00100.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00100.check() && A2_Cycle_Bm_1_00100.check() && A3_Cycle_Bm_1_00100.check() && A4_Cycle_Bm_1_00100.check() && A5_Cycle_Bm_1_00100.check() && A6_Cycle_Bm_1_00100.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/expected.txt b/testsuite/java_test/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/test.cfg b/testsuite/java_test/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a68e67ba8d268cffe9765ffaf14df577c8348f8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00100)
+run(Cycle_Bm_1_00100,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/Cycle_Bm_1_00110.java b/testsuite/java_test/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/Cycle_Bm_1_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..4becd61d5c5797372e12545811231be653a1f580
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/Cycle_Bm_1_00110.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00110 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00110_A1 a1_0 = new Cycle_B_1_00110_A1();
+        a1_0.a2_0 = new Cycle_B_1_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00110_A3();
+        Cycle_B_1_00110_A5 a5_0 = new Cycle_B_1_00110_A5();
+        a5_0.a4_0 = new Cycle_B_1_00110_A4();
+        a5_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00110_A1 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00110_A2 {
+        Cycle_B_1_00110_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00110_A3 {
+        Cycle_B_1_00110_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00110_A4 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00110_A5 {
+        Cycle_B_1_00110_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00110 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00110 A1_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A2_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A3_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A4_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A5_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        ThreadRc_Cycle_Bm_1_00110 A6_Cycle_Bm_1_00110 = new ThreadRc_Cycle_Bm_1_00110();
+        A1_Cycle_Bm_1_00110.start();
+        A2_Cycle_Bm_1_00110.start();
+        A3_Cycle_Bm_1_00110.start();
+        A4_Cycle_Bm_1_00110.start();
+        A5_Cycle_Bm_1_00110.start();
+        A6_Cycle_Bm_1_00110.start();
+        try {
+            A1_Cycle_Bm_1_00110.join();
+            A2_Cycle_Bm_1_00110.join();
+            A3_Cycle_Bm_1_00110.join();
+            A4_Cycle_Bm_1_00110.join();
+            A5_Cycle_Bm_1_00110.join();
+            A6_Cycle_Bm_1_00110.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00110.check() && A2_Cycle_Bm_1_00110.check() && A3_Cycle_Bm_1_00110.check() && A4_Cycle_Bm_1_00110.check() && A5_Cycle_Bm_1_00110.check() && A6_Cycle_Bm_1_00110.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/expected.txt b/testsuite/java_test/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/test.cfg b/testsuite/java_test/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bb629465181fe936915948e47dc4c244ab51247e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00110)
+run(Cycle_Bm_1_00110,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/Cycle_Bm_1_00120.java b/testsuite/java_test/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/Cycle_Bm_1_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..b0e0d9d745a1c4c6c7b1f6e3ffe4e91f58caf98b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/Cycle_Bm_1_00120.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00120 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00120_A1 a1_0 = new Cycle_B_1_00120_A1();
+        a1_0.a2_0 = new Cycle_B_1_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00120_A3();
+        Cycle_B_1_00120_A5 a5_0 = new Cycle_B_1_00120_A5();
+        a5_0.a4_0 = new Cycle_B_1_00120_A4();
+        a5_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00120_A1 {
+        Cycle_B_1_00120_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00120_A2 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00120_A3 {
+        Cycle_B_1_00120_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00120_A4 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00120_A5 {
+        Cycle_B_1_00120_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00120 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00120 A1_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A2_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A3_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A4_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A5_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        ThreadRc_Cycle_Bm_1_00120 A6_Cycle_Bm_1_00120 = new ThreadRc_Cycle_Bm_1_00120();
+        A1_Cycle_Bm_1_00120.start();
+        A2_Cycle_Bm_1_00120.start();
+        A3_Cycle_Bm_1_00120.start();
+        A4_Cycle_Bm_1_00120.start();
+        A5_Cycle_Bm_1_00120.start();
+        A6_Cycle_Bm_1_00120.start();
+        try {
+            A1_Cycle_Bm_1_00120.join();
+            A2_Cycle_Bm_1_00120.join();
+            A3_Cycle_Bm_1_00120.join();
+            A4_Cycle_Bm_1_00120.join();
+            A5_Cycle_Bm_1_00120.join();
+            A6_Cycle_Bm_1_00120.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00120.check() && A2_Cycle_Bm_1_00120.check() && A3_Cycle_Bm_1_00120.check() && A4_Cycle_Bm_1_00120.check() && A5_Cycle_Bm_1_00120.check() && A6_Cycle_Bm_1_00120.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/expected.txt b/testsuite/java_test/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/test.cfg b/testsuite/java_test/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f7686991738ff532add0c09647f482b34ec57cf3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00120)
+run(Cycle_Bm_1_00120,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/Cycle_Bm_1_00130.java b/testsuite/java_test/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/Cycle_Bm_1_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..c45edfb231e1066ec90ad0693e164dae8a8ae7c6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/Cycle_Bm_1_00130.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00130 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00130_A1 a1_0 = new Cycle_B_1_00130_A1();
+        Cycle_B_1_00130_A2 a2_0 = new Cycle_B_1_00130_A2();
+        Cycle_B_1_00130_A3 a3_0 = new Cycle_B_1_00130_A3();
+        a1_0.a3_0 = a3_0;
+        a2_0.a3_0 = a3_0;
+        a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00130_A1 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00130_A1() {
+            a3_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00130_A2 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00130_A3 {
+        Cycle_B_1_00130_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00130_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00130 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00130 A1_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A2_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A3_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A4_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A5_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        ThreadRc_Cycle_Bm_1_00130 A6_Cycle_Bm_1_00130 = new ThreadRc_Cycle_Bm_1_00130();
+        A1_Cycle_Bm_1_00130.start();
+        A2_Cycle_Bm_1_00130.start();
+        A3_Cycle_Bm_1_00130.start();
+        A4_Cycle_Bm_1_00130.start();
+        A5_Cycle_Bm_1_00130.start();
+        A6_Cycle_Bm_1_00130.start();
+        try {
+            A1_Cycle_Bm_1_00130.join();
+            A2_Cycle_Bm_1_00130.join();
+            A3_Cycle_Bm_1_00130.join();
+            A4_Cycle_Bm_1_00130.join();
+            A5_Cycle_Bm_1_00130.join();
+            A6_Cycle_Bm_1_00130.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00130.check() && A2_Cycle_Bm_1_00130.check() && A3_Cycle_Bm_1_00130.check() && A4_Cycle_Bm_1_00130.check() && A5_Cycle_Bm_1_00130.check() && A6_Cycle_Bm_1_00130.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/expected.txt b/testsuite/java_test/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/test.cfg b/testsuite/java_test/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8c2abf868ee7d65b07d9fb1dce3359a4819f41c9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00130)
+run(Cycle_Bm_1_00130,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/Cycle_Bm_1_00140.java b/testsuite/java_test/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/Cycle_Bm_1_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..ed3f9343e05cc419e577ac3366ae7796c2174778
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/Cycle_Bm_1_00140.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00140 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00140_A1 a1_0 = new Cycle_B_1_00140_A1();
+        a1_0.a2_0 = new Cycle_B_1_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00140_A3();
+        Cycle_B_1_00140_A4 a4_0 = new Cycle_B_1_00140_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00140_A1 {
+        Cycle_B_1_00140_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00140_A2 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00140_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00140_A3 {
+        Cycle_B_1_00140_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00140_A4 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00140_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00140 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00140 A1_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A2_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A3_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A4_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A5_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        ThreadRc_Cycle_Bm_1_00140 A6_Cycle_Bm_1_00140 = new ThreadRc_Cycle_Bm_1_00140();
+        A1_Cycle_Bm_1_00140.start();
+        A2_Cycle_Bm_1_00140.start();
+        A3_Cycle_Bm_1_00140.start();
+        A4_Cycle_Bm_1_00140.start();
+        A5_Cycle_Bm_1_00140.start();
+        A6_Cycle_Bm_1_00140.start();
+        try {
+            A1_Cycle_Bm_1_00140.join();
+            A2_Cycle_Bm_1_00140.join();
+            A3_Cycle_Bm_1_00140.join();
+            A4_Cycle_Bm_1_00140.join();
+            A5_Cycle_Bm_1_00140.join();
+            A6_Cycle_Bm_1_00140.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00140.check() && A2_Cycle_Bm_1_00140.check() && A3_Cycle_Bm_1_00140.check() && A4_Cycle_Bm_1_00140.check() && A5_Cycle_Bm_1_00140.check() && A6_Cycle_Bm_1_00140.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/expected.txt b/testsuite/java_test/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/test.cfg b/testsuite/java_test/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..79b2150afd08f64ce1c7868005f307a789dbbcae
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00140)
+run(Cycle_Bm_1_00140,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/Cycle_Bm_1_00150.java b/testsuite/java_test/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/Cycle_Bm_1_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..8ffa8b1d6aa2486290abc7596652e8cc4eac0ee4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/Cycle_Bm_1_00150.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00150 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00150_A1 a1_0 = new Cycle_B_1_00150_A1();
+        a1_0.a2_0 = new Cycle_B_1_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00150_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_1_00150_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum;
+        ;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00150_A1 {
+        Cycle_B_1_00150_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00150_A2 {
+        Cycle_B_1_00150_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00150_A3 {
+        Cycle_B_1_00150_A1 a1_0;
+        Cycle_B_1_00150_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00150_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00150_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00150_A5 a5_0;
+        Cycle_B_1_00150_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+    class Cycle_B_1_00150_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00150_A5() {
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+public class Cycle_Bm_1_00150 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00150 A1_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A2_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A3_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A4_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A5_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        ThreadRc_Cycle_Bm_1_00150 A6_Cycle_Bm_1_00150 = new ThreadRc_Cycle_Bm_1_00150();
+        A1_Cycle_Bm_1_00150.start();
+        A2_Cycle_Bm_1_00150.start();
+        A3_Cycle_Bm_1_00150.start();
+        A4_Cycle_Bm_1_00150.start();
+        A5_Cycle_Bm_1_00150.start();
+        A6_Cycle_Bm_1_00150.start();
+        try {
+            A1_Cycle_Bm_1_00150.join();
+            A2_Cycle_Bm_1_00150.join();
+            A3_Cycle_Bm_1_00150.join();
+            A4_Cycle_Bm_1_00150.join();
+            A5_Cycle_Bm_1_00150.join();
+            A6_Cycle_Bm_1_00150.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00150.check() && A2_Cycle_Bm_1_00150.check() && A3_Cycle_Bm_1_00150.check() && A4_Cycle_Bm_1_00150.check() && A5_Cycle_Bm_1_00150.check() && A6_Cycle_Bm_1_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/expected.txt b/testsuite/java_test/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/test.cfg b/testsuite/java_test/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35f77027af818c627e298584a539bcaeeb4b5ebc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00150)
+run(Cycle_Bm_1_00150,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/Cycle_Bm_1_00160.java b/testsuite/java_test/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/Cycle_Bm_1_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..f0f2b5f12c221dc4b2a6ce3c903e7f877b656cbb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/Cycle_Bm_1_00160.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00160 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00160_A1 a1_0 = new Cycle_B_1_00160_A1();
+        a1_0.a2_0 = new Cycle_B_1_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00160_A3();
+        Cycle_B_1_00160_A4 a4_0 = new Cycle_B_1_00160_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 17)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00160_A1 {
+        Cycle_B_1_00160_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00160_A2 {
+        Cycle_B_1_00160_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00160_A3 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00160_A4 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00160_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00160 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00160 A1_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A2_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A3_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A4_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A5_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        ThreadRc_Cycle_Bm_1_00160 A6_Cycle_Bm_1_00160 = new ThreadRc_Cycle_Bm_1_00160();
+        A1_Cycle_Bm_1_00160.start();
+        A2_Cycle_Bm_1_00160.start();
+        A3_Cycle_Bm_1_00160.start();
+        A4_Cycle_Bm_1_00160.start();
+        A5_Cycle_Bm_1_00160.start();
+        A6_Cycle_Bm_1_00160.start();
+        try {
+            A1_Cycle_Bm_1_00160.join();
+            A2_Cycle_Bm_1_00160.join();
+            A3_Cycle_Bm_1_00160.join();
+            A4_Cycle_Bm_1_00160.join();
+            A5_Cycle_Bm_1_00160.join();
+            A6_Cycle_Bm_1_00160.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00160.check() && A2_Cycle_Bm_1_00160.check() && A3_Cycle_Bm_1_00160.check() && A4_Cycle_Bm_1_00160.check() && A5_Cycle_Bm_1_00160.check() && A6_Cycle_Bm_1_00160.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/expected.txt b/testsuite/java_test/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/test.cfg b/testsuite/java_test/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d17dd4988bd9368688e585d1398432471322dd35
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00160)
+run(Cycle_Bm_1_00160,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/Cycle_Bm_1_00170.java b/testsuite/java_test/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/Cycle_Bm_1_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..135d94e73a5713fa60d35877acb72ddd17e4c413
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/Cycle_Bm_1_00170.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00170 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00170_A1 a1_0 = new Cycle_B_1_00170_A1();
+        a1_0.a2_0 = new Cycle_B_1_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00170_A3();
+        Cycle_B_1_00170_A4 a4_0 = new Cycle_B_1_00170_A4();
+        Cycle_B_1_00170_A5 a5_0 = new Cycle_B_1_00170_A5();
+        a5_0.a4_0 = a4_0;
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 26)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00170_A1 {
+        Cycle_B_1_00170_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00170_A2 {
+        Cycle_B_1_00170_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00170_A3 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00170_A4 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00170_A5 {
+        Cycle_B_1_00170_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00170 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00170 A1_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A2_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A3_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A4_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A5_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        ThreadRc_Cycle_Bm_1_00170 A6_Cycle_Bm_1_00170 = new ThreadRc_Cycle_Bm_1_00170();
+        A1_Cycle_Bm_1_00170.start();
+        A2_Cycle_Bm_1_00170.start();
+        A3_Cycle_Bm_1_00170.start();
+        A4_Cycle_Bm_1_00170.start();
+        A5_Cycle_Bm_1_00170.start();
+        A6_Cycle_Bm_1_00170.start();
+        try {
+            A1_Cycle_Bm_1_00170.join();
+            A2_Cycle_Bm_1_00170.join();
+            A3_Cycle_Bm_1_00170.join();
+            A4_Cycle_Bm_1_00170.join();
+            A5_Cycle_Bm_1_00170.join();
+            A6_Cycle_Bm_1_00170.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00170.check() && A2_Cycle_Bm_1_00170.check() && A3_Cycle_Bm_1_00170.check() && A4_Cycle_Bm_1_00170.check() && A5_Cycle_Bm_1_00170.check() && A6_Cycle_Bm_1_00170.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/expected.txt b/testsuite/java_test/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/test.cfg b/testsuite/java_test/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e9f29415f689f04d71037316cb9670121f6ac297
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00170)
+run(Cycle_Bm_1_00170,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/Cycle_Bm_1_00180.java b/testsuite/java_test/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/Cycle_Bm_1_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..d63b5ea3c5e365ddf312ed6990453ebd553fcc6e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/Cycle_Bm_1_00180.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00180 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 23)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00180_A1 {
+        Cycle_B_1_00180_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A2 {
+        Cycle_B_1_00180_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A3 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A4 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A5 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00180 A1_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A2_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A3_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A4_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A5_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A6_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        A1_Cycle_Bm_1_00180.start();
+        A2_Cycle_Bm_1_00180.start();
+        A3_Cycle_Bm_1_00180.start();
+        A4_Cycle_Bm_1_00180.start();
+        A5_Cycle_Bm_1_00180.start();
+        A6_Cycle_Bm_1_00180.start();
+        try {
+            A1_Cycle_Bm_1_00180.join();
+            A2_Cycle_Bm_1_00180.join();
+            A3_Cycle_Bm_1_00180.join();
+            A4_Cycle_Bm_1_00180.join();
+            A5_Cycle_Bm_1_00180.join();
+            A6_Cycle_Bm_1_00180.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00180.check() && A2_Cycle_Bm_1_00180.check() && A3_Cycle_Bm_1_00180.check() && A4_Cycle_Bm_1_00180.check() && A5_Cycle_Bm_1_00180.check() && A6_Cycle_Bm_1_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/expected.txt b/testsuite/java_test/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/test.cfg b/testsuite/java_test/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d0dcf1dadb86ba5d41ad14c9ed31de562309f932
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00180)
+run(Cycle_Bm_1_00180,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/Cycle_Bm_1_00190.java b/testsuite/java_test/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/Cycle_Bm_1_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..0690ed81e4c450f5b1422594021a9ba629685785
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/Cycle_Bm_1_00190.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00190 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00190_A1 a1_0 = new Cycle_B_1_00190_A1();
+        a1_0.a2_0 = new Cycle_B_1_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00190_A3();
+        Cycle_B_1_00190_A4 a4_0 = new Cycle_B_1_00190_A4();
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00190_A1 {
+        Cycle_B_1_00190_A2 a2_0;
+        Cycle_B_1_00190_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00190_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00190_A2 {
+        Cycle_B_1_00190_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00190_A3 {
+        Cycle_B_1_00190_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00190_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00190_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00190_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+public class Cycle_Bm_1_00190 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00190 A1_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A2_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A3_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A4_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A5_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        ThreadRc_Cycle_Bm_1_00190 A6_Cycle_Bm_1_00190 = new ThreadRc_Cycle_Bm_1_00190();
+        A1_Cycle_Bm_1_00190.start();
+        A2_Cycle_Bm_1_00190.start();
+        A3_Cycle_Bm_1_00190.start();
+        A4_Cycle_Bm_1_00190.start();
+        A5_Cycle_Bm_1_00190.start();
+        A6_Cycle_Bm_1_00190.start();
+        try {
+            A1_Cycle_Bm_1_00190.join();
+            A2_Cycle_Bm_1_00190.join();
+            A3_Cycle_Bm_1_00190.join();
+            A4_Cycle_Bm_1_00190.join();
+            A5_Cycle_Bm_1_00190.join();
+            A6_Cycle_Bm_1_00190.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00190.check() && A2_Cycle_Bm_1_00190.check() && A3_Cycle_Bm_1_00190.check() && A4_Cycle_Bm_1_00190.check() && A5_Cycle_Bm_1_00190.check() && A6_Cycle_Bm_1_00190.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/expected.txt b/testsuite/java_test/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/test.cfg b/testsuite/java_test/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d1a1a56053dd26cbc421210963b9bb496aa6a653
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00190)
+run(Cycle_Bm_1_00190,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/Cycle_Bm_1_00200.java b/testsuite/java_test/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/Cycle_Bm_1_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..7bab6f5510ba26c0b9a328b673b3e37430b8620d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/Cycle_Bm_1_00200.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00200 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00200_A1 a1_0 = new Cycle_B_1_00200_A1();
+        a1_0.a2_0 = new Cycle_B_1_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00200_A3();
+        Cycle_B_1_00200_A4 a4_0 = new Cycle_B_1_00200_A4();
+        Cycle_B_1_00200_A5 a5_0 = new Cycle_B_1_00200_A5();
+        a1_0.a4_0 = a4_0;
+        a1_0.a5_0 = a5_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00200_A1 {
+        Cycle_B_1_00200_A2 a2_0;
+        Cycle_B_1_00200_A4 a4_0;
+        Cycle_B_1_00200_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_1_00200_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00200_A2 {
+        Cycle_B_1_00200_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00200_A3 {
+        Cycle_B_1_00200_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00200_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00200_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00200_A4() {
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 6;
+        }
+    }
+    class Cycle_B_1_00200_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00200_A5() {
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+public class Cycle_Bm_1_00200 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00200 A1_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A2_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A3_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A4_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A5_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        ThreadRc_Cycle_Bm_1_00200 A6_Cycle_Bm_1_00200 = new ThreadRc_Cycle_Bm_1_00200();
+        A1_Cycle_Bm_1_00200.start();
+        A2_Cycle_Bm_1_00200.start();
+        A3_Cycle_Bm_1_00200.start();
+        A4_Cycle_Bm_1_00200.start();
+        A5_Cycle_Bm_1_00200.start();
+        A6_Cycle_Bm_1_00200.start();
+        try {
+            A1_Cycle_Bm_1_00200.join();
+            A2_Cycle_Bm_1_00200.join();
+            A3_Cycle_Bm_1_00200.join();
+            A4_Cycle_Bm_1_00200.join();
+            A5_Cycle_Bm_1_00200.join();
+            A6_Cycle_Bm_1_00200.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00200.check() && A2_Cycle_Bm_1_00200.check() && A3_Cycle_Bm_1_00200.check() && A4_Cycle_Bm_1_00200.check() && A5_Cycle_Bm_1_00200.check() && A6_Cycle_Bm_1_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/expected.txt b/testsuite/java_test/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/test.cfg b/testsuite/java_test/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..208543750ea670bd23633ab22c19c856b4a6639a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00200)
+run(Cycle_Bm_1_00200,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/Cycle_Bm_1_00210.java b/testsuite/java_test/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/Cycle_Bm_1_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..a5c01a61d813d9005c9759af28251fe0a7cd7058
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/Cycle_Bm_1_00210.java
@@ -0,0 +1,1692 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_00010B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 246)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00010_A1 {
+        Cycle_B_1_00010_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00010_A1() {
+            a1_0 = null;
+            a = 123;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00020B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00020_A1 a1_0 = new Cycle_B_1_00020_A1();
+        a1_0.a2_0 = new Cycle_B_1_00020_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 6)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00020_A1 {
+        Cycle_B_1_00020_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00020_A2 {
+        Cycle_B_1_00020_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00020_A2() {
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00030B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00030_A1 a1_0 = new Cycle_B_1_00030_A1();
+        a1_0.a2_0 = new Cycle_B_1_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00030_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00030_A1 {
+        Cycle_B_1_00030_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00030_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00030_A2 {
+        Cycle_B_1_00030_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00030_A3 {
+        Cycle_B_1_00030_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00040B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00040_A1 a1_0 = new Cycle_B_1_00040_A1();
+        a1_0.a2_0 = new Cycle_B_1_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00040_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00040_A4();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00040_A1 {
+        Cycle_B_1_00040_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00040_A2 {
+        Cycle_B_1_00040_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00040_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00040_A3 {
+        Cycle_B_1_00040_A1 a1_0;
+        Cycle_B_1_00040_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00040_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00040_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00050B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00050_A1 a1_0 = new Cycle_B_1_00050_A1();
+        a1_0.a2_0 = new Cycle_B_1_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00050_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00050_A4();
+        a1_0.a2_0.a5_0 = new Cycle_B_1_00050_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 34)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00050_A1 {
+        Cycle_B_1_00050_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00050_A2 {
+        Cycle_B_1_00050_A3 a3_0;
+        Cycle_B_1_00050_A4 a4_0;
+        Cycle_B_1_00050_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_1_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00050_A3 {
+        Cycle_B_1_00050_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00050_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00050_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00050_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+    class Cycle_B_1_00050_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00050_A5() {
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00060B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00060_A1 a1_0 = new Cycle_B_1_00060_A1();
+        a1_0.a2_0 = new Cycle_B_1_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00060_A3();
+        Cycle_B_1_00060_A4 a4_0 = new Cycle_B_1_00060_A4();
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00060_A1 {
+        Cycle_B_1_00060_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00060_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00060_A2 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00060_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00060_A3 {
+        Cycle_B_1_00060_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00060_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00060_A4 {
+        Cycle_B_1_00060_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00070B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00070_A1 a1_0 = new Cycle_B_1_00070_A1();
+        a1_0.a2_0 = new Cycle_B_1_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00070_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00070_A1 {
+        Cycle_B_1_00070_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00070_A2 {
+        Cycle_B_1_00070_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00070_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00070_A3 {
+        Cycle_B_1_00070_A1 a1_0;
+        Cycle_B_1_00070_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00070_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00070_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00070_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00080B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00080_A1 a1_0 = new Cycle_B_1_00080_A1();
+        a1_0.a2_0 = new Cycle_B_1_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00080_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00080_A4();
+        a1_0.a2_0.a3_0.a5_0 = new Cycle_B_1_00080_A5();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 56)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00080_A1 {
+        Cycle_B_1_00080_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00080_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00080_A2 {
+        Cycle_B_1_00080_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00080_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00080_A3 {
+        Cycle_B_1_00080_A1 a1_0;
+        Cycle_B_1_00080_A4 a4_0;
+        Cycle_B_1_00080_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_1_00080_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            a4_0.add();
+            a5_0.add();
+            sum = a + a1_0.a + a4_0.sum + a5_0.sum;
+        }
+    }
+    class Cycle_B_1_00080_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00080_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+    class Cycle_B_1_00080_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00080_A5() {
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 7;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00090B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00090_A1 a1_0 = new Cycle_B_1_00090_A1();
+        a1_0.a2_0 = new Cycle_B_1_00090_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00090_A3();
+        Cycle_B_1_00090_A4 a4_0 = new Cycle_B_1_00090_A4();
+        Cycle_B_1_00090_A5 a5_0 = new Cycle_B_1_00090_A5();
+        a4_0.a2_0 = a1_0.a2_0;
+        a5_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 25)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00090_A1 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00090_A2 {
+        Cycle_B_1_00090_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00090_A3 {
+        Cycle_B_1_00090_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00090_A4 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00090_A5 {
+        Cycle_B_1_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00090_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00100B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00100_A1 a1_0 = new Cycle_B_1_00100_A1();
+        a1_0.a2_0 = new Cycle_B_1_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00100_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0 = new Cycle_B_1_00100_A4();
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_1_00100_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00100_A1 {
+        Cycle_B_1_00100_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00100_A2 {
+        Cycle_B_1_00100_A3 a3_0;
+        Cycle_B_1_00100_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00100_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00100_A3 {
+        Cycle_B_1_00100_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00100_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00100_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00100_A5 a5_0;
+        Cycle_B_1_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+    class Cycle_B_1_00100_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00100_A5() {
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00110B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00110_A1 a1_0 = new Cycle_B_1_00110_A1();
+        a1_0.a2_0 = new Cycle_B_1_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00110_A3();
+        Cycle_B_1_00110_A5 a5_0 = new Cycle_B_1_00110_A5();
+        a5_0.a4_0 = new Cycle_B_1_00110_A4();
+        a5_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00110_A1 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00110_A2 {
+        Cycle_B_1_00110_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00110_A3 {
+        Cycle_B_1_00110_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00110_A4 {
+        Cycle_B_1_00110_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00110_A5 {
+        Cycle_B_1_00110_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00110_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00120B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00120_A1 a1_0 = new Cycle_B_1_00120_A1();
+        a1_0.a2_0 = new Cycle_B_1_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00120_A3();
+        Cycle_B_1_00120_A5 a5_0 = new Cycle_B_1_00120_A5();
+        a5_0.a4_0 = new Cycle_B_1_00120_A4();
+        a5_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a5_0.a4_0.add();
+        a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a5_0.a4_0.sum + a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00120_A1 {
+        Cycle_B_1_00120_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00120_A2 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00120_A3 {
+        Cycle_B_1_00120_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00120_A4 {
+        Cycle_B_1_00120_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00120_A5 {
+        Cycle_B_1_00120_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00120_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00130B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00130_A1 a1_0 = new Cycle_B_1_00130_A1();
+        Cycle_B_1_00130_A2 a2_0 = new Cycle_B_1_00130_A2();
+        Cycle_B_1_00130_A3 a3_0 = new Cycle_B_1_00130_A3();
+        a1_0.a3_0 = a3_0;
+        a2_0.a3_0 = a3_0;
+        a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00130_A1 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00130_A1() {
+            a3_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00130_A2 {
+        Cycle_B_1_00130_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00130_A3 {
+        Cycle_B_1_00130_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00130_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00140B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00140_A1 a1_0 = new Cycle_B_1_00140_A1();
+        a1_0.a2_0 = new Cycle_B_1_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00140_A3();
+        Cycle_B_1_00140_A4 a4_0 = new Cycle_B_1_00140_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 12)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00140_A1 {
+        Cycle_B_1_00140_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00140_A2 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00140_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00140_A3 {
+        Cycle_B_1_00140_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00140_A4 {
+        Cycle_B_1_00140_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00140_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00150B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00150_A1 a1_0 = new Cycle_B_1_00150_A1();
+        a1_0.a2_0 = new Cycle_B_1_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_1_00150_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_1_00150_A5();
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum;
+        //System.out.println(nsum);
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00150_A1 {
+        Cycle_B_1_00150_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00150_A2 {
+        Cycle_B_1_00150_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00150_A3 {
+        Cycle_B_1_00150_A1 a1_0;
+        Cycle_B_1_00150_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00150_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00150_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00150_A5 a5_0;
+        Cycle_B_1_00150_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            a5_0.add();
+            sum = a + a5_0.sum;
+        }
+    }
+    class Cycle_B_1_00150_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00150_A5() {
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 6;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00160B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00160_A1 a1_0 = new Cycle_B_1_00160_A1();
+        a1_0.a2_0 = new Cycle_B_1_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00160_A3();
+        Cycle_B_1_00160_A4 a4_0 = new Cycle_B_1_00160_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 17)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00160_A1 {
+        Cycle_B_1_00160_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00160_A2 {
+        Cycle_B_1_00160_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00160_A3 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00160_A4 {
+        Cycle_B_1_00160_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00160_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00170B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00170_A1 a1_0 = new Cycle_B_1_00170_A1();
+        a1_0.a2_0 = new Cycle_B_1_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00170_A3();
+        Cycle_B_1_00170_A4 a4_0 = new Cycle_B_1_00170_A4();
+        Cycle_B_1_00170_A5 a5_0 = new Cycle_B_1_00170_A5();
+        a5_0.a4_0 = a4_0;
+        a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 26)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00170_A1 {
+        Cycle_B_1_00170_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00170_A2 {
+        Cycle_B_1_00170_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00170_A3 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00170_A4 {
+        Cycle_B_1_00170_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00170_A5 {
+        Cycle_B_1_00170_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00170_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00180B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 23)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00180_A1 {
+        Cycle_B_1_00180_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A2 {
+        Cycle_B_1_00180_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A3 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A4 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A5 {
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00190B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00190_A1 a1_0 = new Cycle_B_1_00190_A1();
+        a1_0.a2_0 = new Cycle_B_1_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00190_A3();
+        Cycle_B_1_00190_A4 a4_0 = new Cycle_B_1_00190_A4();
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00190_A1 {
+        Cycle_B_1_00190_A2 a2_0;
+        Cycle_B_1_00190_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_1_00190_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00190_A2 {
+        Cycle_B_1_00190_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00190_A3 {
+        Cycle_B_1_00190_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00190_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00190_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00190_A4() {
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 5;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_00200B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00200_A1 a1_0 = new Cycle_B_1_00200_A1();
+        a1_0.a2_0 = new Cycle_B_1_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00200_A3();
+        Cycle_B_1_00200_A4 a4_0 = new Cycle_B_1_00200_A4();
+        Cycle_B_1_00200_A5 a5_0 = new Cycle_B_1_00200_A5();
+        a1_0.a4_0 = a4_0;
+        a1_0.a5_0 = a5_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 38)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00200_A1 {
+        Cycle_B_1_00200_A2 a2_0;
+        Cycle_B_1_00200_A4 a4_0;
+        Cycle_B_1_00200_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_1_00200_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00200_A2 {
+        Cycle_B_1_00200_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00200_A3 {
+        Cycle_B_1_00200_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00200_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00200_A4 {
+        int a;
+        int sum;
+        Cycle_B_1_00200_A4() {
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 6;
+        }
+    }
+    class Cycle_B_1_00200_A5 {
+        int a;
+        int sum;
+        Cycle_B_1_00200_A5() {
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+public class Cycle_Bm_1_00210 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00010B A1_00010 = new ThreadRc_Cycle_Bm_1_00010B();
+        ThreadRc_Cycle_Bm_1_00010B A2_00010 = new ThreadRc_Cycle_Bm_1_00010B();
+        ThreadRc_Cycle_Bm_1_00020B A1_00020 = new ThreadRc_Cycle_Bm_1_00020B();
+        ThreadRc_Cycle_Bm_1_00020B A2_00020 = new ThreadRc_Cycle_Bm_1_00020B();
+        ThreadRc_Cycle_Bm_1_00030B A1_00030 = new ThreadRc_Cycle_Bm_1_00030B();
+        ThreadRc_Cycle_Bm_1_00030B A2_00030 = new ThreadRc_Cycle_Bm_1_00030B();
+        ThreadRc_Cycle_Bm_1_00040B A1_00040 = new ThreadRc_Cycle_Bm_1_00040B();
+        ThreadRc_Cycle_Bm_1_00040B A2_00040 = new ThreadRc_Cycle_Bm_1_00040B();
+        ThreadRc_Cycle_Bm_1_00050B A1_00050 = new ThreadRc_Cycle_Bm_1_00050B();
+        ThreadRc_Cycle_Bm_1_00050B A2_00050 = new ThreadRc_Cycle_Bm_1_00050B();
+        ThreadRc_Cycle_Bm_1_00060B A1_00060 = new ThreadRc_Cycle_Bm_1_00060B();
+        ThreadRc_Cycle_Bm_1_00060B A2_00060 = new ThreadRc_Cycle_Bm_1_00060B();
+        ThreadRc_Cycle_Bm_1_00070B A1_00070 = new ThreadRc_Cycle_Bm_1_00070B();
+        ThreadRc_Cycle_Bm_1_00070B A2_00070 = new ThreadRc_Cycle_Bm_1_00070B();
+        ThreadRc_Cycle_Bm_1_00080B A1_00080 = new ThreadRc_Cycle_Bm_1_00080B();
+        ThreadRc_Cycle_Bm_1_00080B A2_00080 = new ThreadRc_Cycle_Bm_1_00080B();
+        ThreadRc_Cycle_Bm_1_00090B A1_00090 = new ThreadRc_Cycle_Bm_1_00090B();
+        ThreadRc_Cycle_Bm_1_00090B A2_00090 = new ThreadRc_Cycle_Bm_1_00090B();
+        ThreadRc_Cycle_Bm_1_00100B A1_00100 = new ThreadRc_Cycle_Bm_1_00100B();
+        ThreadRc_Cycle_Bm_1_00100B A2_00100 = new ThreadRc_Cycle_Bm_1_00100B();
+        ThreadRc_Cycle_Bm_1_00110B A1_00110 = new ThreadRc_Cycle_Bm_1_00110B();
+        ThreadRc_Cycle_Bm_1_00110B A2_00110 = new ThreadRc_Cycle_Bm_1_00110B();
+        ThreadRc_Cycle_Bm_1_00120B A1_00120 = new ThreadRc_Cycle_Bm_1_00120B();
+        ThreadRc_Cycle_Bm_1_00120B A2_00120 = new ThreadRc_Cycle_Bm_1_00120B();
+        ThreadRc_Cycle_Bm_1_00130B A1_00130 = new ThreadRc_Cycle_Bm_1_00130B();
+        ThreadRc_Cycle_Bm_1_00130B A2_00130 = new ThreadRc_Cycle_Bm_1_00130B();
+        ThreadRc_Cycle_Bm_1_00140B A1_00140 = new ThreadRc_Cycle_Bm_1_00140B();
+        ThreadRc_Cycle_Bm_1_00140B A2_00140 = new ThreadRc_Cycle_Bm_1_00140B();
+        ThreadRc_Cycle_Bm_1_00150B A1_00150 = new ThreadRc_Cycle_Bm_1_00150B();
+        ThreadRc_Cycle_Bm_1_00150B A2_00150 = new ThreadRc_Cycle_Bm_1_00150B();
+        ThreadRc_Cycle_Bm_1_00160B A1_00160 = new ThreadRc_Cycle_Bm_1_00160B();
+        ThreadRc_Cycle_Bm_1_00160B A2_00160 = new ThreadRc_Cycle_Bm_1_00160B();
+        ThreadRc_Cycle_Bm_1_00170B A1_00170 = new ThreadRc_Cycle_Bm_1_00170B();
+        ThreadRc_Cycle_Bm_1_00170B A2_00170 = new ThreadRc_Cycle_Bm_1_00170B();
+        ThreadRc_Cycle_Bm_1_00180B A1_00180 = new ThreadRc_Cycle_Bm_1_00180B();
+        ThreadRc_Cycle_Bm_1_00180B A2_00180 = new ThreadRc_Cycle_Bm_1_00180B();
+        ThreadRc_Cycle_Bm_1_00190B A1_00190 = new ThreadRc_Cycle_Bm_1_00190B();
+        ThreadRc_Cycle_Bm_1_00190B A2_00190 = new ThreadRc_Cycle_Bm_1_00190B();
+        ThreadRc_Cycle_Bm_1_00200B A1_00200 = new ThreadRc_Cycle_Bm_1_00200B();
+        ThreadRc_Cycle_Bm_1_00200B A2_00200 = new ThreadRc_Cycle_Bm_1_00200B();
+        A1_00010.start();
+        A2_00010.start();
+        A1_00020.start();
+        A2_00020.start();
+        A1_00030.start();
+        A2_00030.start();
+        A1_00040.start();
+        A2_00040.start();
+        A1_00050.start();
+        A2_00050.start();
+        A1_00060.start();
+        A2_00060.start();
+        A1_00070.start();
+        A2_00070.start();
+        A1_00080.start();
+        A2_00080.start();
+        A1_00090.start();
+        A2_00090.start();
+        A1_00100.start();
+        A2_00100.start();
+        A1_00110.start();
+        A2_00110.start();
+        A1_00120.start();
+        A2_00120.start();
+        A1_00130.start();
+        A2_00130.start();
+        A1_00140.start();
+        A2_00140.start();
+        A1_00150.start();
+        A2_00150.start();
+        A1_00160.start();
+        A2_00160.start();
+        A1_00170.start();
+        A2_00170.start();
+        A1_00180.start();
+        A2_00180.start();
+        A1_00190.start();
+        A2_00190.start();
+        A1_00200.start();
+        A2_00200.start();
+        try {
+            A1_00010.join();
+            A2_00010.join();
+            A1_00020.join();
+            A2_00020.join();
+            A1_00030.join();
+            A2_00030.join();
+            A1_00040.join();
+            A2_00040.join();
+            A1_00050.join();
+            A2_00050.join();
+            A1_00060.join();
+            A2_00060.join();
+            A1_00070.join();
+            A2_00070.join();
+            A1_00080.join();
+            A2_00080.join();
+            A1_00090.join();
+            A2_00090.join();
+            A1_00100.join();
+            A2_00100.join();
+            A1_00110.join();
+            A2_00110.join();
+            A1_00120.join();
+            A2_00120.join();
+            A1_00130.join();
+            A2_00130.join();
+            A1_00140.join();
+            A2_00140.join();
+            A1_00150.join();
+            A2_00150.join();
+            A1_00160.join();
+            A2_00160.join();
+            A1_00170.join();
+            A2_00170.join();
+            A1_00180.join();
+            A2_00180.join();
+            A1_00190.join();
+            A2_00190.join();
+            A1_00200.join();
+            A2_00200.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00010.check() && A2_00010.check() && A1_00020.check() && A2_00020.check() && A1_00030.check() && A2_00030.check() && A1_00040.check() && A2_00040.check() && A1_00050.check() && A2_00050.check() && A1_00060.check() && A2_00060.check() && A1_00070.check() && A2_00070.check() && A1_00080.check() && A2_00080.check() && A1_00090.check() && A2_00090.check() && A1_00100.check() && A2_00100.check() && A1_00110.check() && A2_00110.check() && A1_00120.check() && A2_00120.check() && A1_00130.check() && A2_00130.check() && A1_00140.check() && A2_00140.check() && A1_00150.check() && A2_00150.check() && A1_00160.check() && A2_00160.check() && A1_00170.check() && A2_00170.check() && A1_00180.check() && A2_00180.check() && A1_00190.check() && A2_00190.check() && A1_00200.check() && A2_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/expected.txt b/testsuite/java_test/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/test.cfg b/testsuite/java_test/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0ed77ac7c05ebbd634da367f5171caca07684d97
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_00210)
+run(Cycle_Bm_1_00210,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/Cycle_Bm_1_10010.java b/testsuite/java_test/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/Cycle_Bm_1_10010.java
new file mode 100755
index 0000000000000000000000000000000000000000..fe7399f663c8082002dc0f88ff17b3019ed516c7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/Cycle_Bm_1_10010.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_10010 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_10010_A1 a1_0 = new Cycle_B_1_10010_A1();
+        a1_0.a2_0 = new Cycle_B_1_10010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10010_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        Cycle_B_1_10010_2A1 a1_10 = new Cycle_B_1_10010_2A1();
+        a1_10.a2_0 = new Cycle_B_1_10010_2A2();
+        a1_10.a2_0.a3_0 = new Cycle_B_1_10010_2A3();
+        a1_10.a2_0.a3_0.a1_0 = a1_10;
+        a1_10.add();
+        a1_10.a2_0.add();
+        a1_10.a2_0.a3_0.add();
+        int nsum2 = (a1_10.sum + a1_10.a2_0.sum + a1_10.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        nsum += nsum2;
+        if (nsum == 24)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_10010_A1 {
+        Cycle_B_1_10010_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_10010_A2 {
+        Cycle_B_1_10010_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_10010_A3 {
+        Cycle_B_1_10010_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10010_2A1 {
+        Cycle_B_1_10010_2A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_2A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_10010_2A2 {
+        Cycle_B_1_10010_2A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_10010_2A3 {
+        Cycle_B_1_10010_2A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_1_10010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_10010 A1_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A2_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A3_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A4_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A5_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        ThreadRc_Cycle_Bm_1_10010 A6_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010();
+        A1_Cycle_Bm_1_10010.start();
+        A2_Cycle_Bm_1_10010.start();
+        A3_Cycle_Bm_1_10010.start();
+        A4_Cycle_Bm_1_10010.start();
+        A5_Cycle_Bm_1_10010.start();
+        A6_Cycle_Bm_1_10010.start();
+        try {
+            A1_Cycle_Bm_1_10010.join();
+            A2_Cycle_Bm_1_10010.join();
+            A3_Cycle_Bm_1_10010.join();
+            A4_Cycle_Bm_1_10010.join();
+            A5_Cycle_Bm_1_10010.join();
+            A6_Cycle_Bm_1_10010.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_10010.check() && A2_Cycle_Bm_1_10010.check() && A3_Cycle_Bm_1_10010.check() && A4_Cycle_Bm_1_10010.check() && A5_Cycle_Bm_1_10010.check() && A6_Cycle_Bm_1_10010.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/expected.txt b/testsuite/java_test/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/test.cfg b/testsuite/java_test/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..78b1d362ef49b8f2faf92dd144e42c943a12ad18
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_10010)
+run(Cycle_Bm_1_10010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/Cycle_Bm_1_10020.java b/testsuite/java_test/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/Cycle_Bm_1_10020.java
new file mode 100755
index 0000000000000000000000000000000000000000..bb16aeea637330bdf933df2a39c405e3079181b5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/Cycle_Bm_1_10020.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_10020 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_10020_A1 a1_0 = new Cycle_B_1_10020_A1();
+        a1_0.a2_0 = new Cycle_B_1_10020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10020_A3();
+        Cycle_B_1_10020_A4 a4_0 = new Cycle_B_1_10020_A4();
+        Cycle_B_1_10020_A5 a5_0 = new Cycle_B_1_10020_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        Cycle_B_1_10020_2A1 a1_20 = new Cycle_B_1_10020_2A1();
+        a1_20.a2_0 = new Cycle_B_1_10020_2A2();
+        a1_20.a2_0.a3_0 = new Cycle_B_1_10020_2A3();
+        Cycle_B_1_10020_2A4 a4_20 = new Cycle_B_1_10020_2A4();
+        Cycle_B_1_10020_2A5 a5_20 = new Cycle_B_1_10020_2A5();
+        a1_20.a4_0 = a4_20;
+        a1_20.a5_0 = a5_20;
+        a1_20.a2_0.a3_0.a1_0 = a1_20;
+        a1_20.add();
+        a1_20.a2_0.add();
+        a1_20.a2_0.a3_0.add();
+        a4_20.add();
+        a5_20.add();
+        int nsum1 = (a1_20.sum + a1_20.a2_0.sum + a1_20.a2_0.a3_0.sum + a4_20.sum + a5_20.sum);
+        nsum += nsum1;
+        if (nsum == 61)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_10020_A1 {
+        Cycle_B_1_10020_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_10020_A2 {
+        Cycle_B_1_10020_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_10020_A3 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10020_A4 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10020_A5 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10020_2A1 {
+        Cycle_B_1_10020_2A2 a2_0;
+        Cycle_B_1_10020_2A4 a4_0;
+        Cycle_B_1_10020_2A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_10020_2A2 {
+        Cycle_B_1_10020_2A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_10020_2A3 {
+        Cycle_B_1_10020_2A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10020_2A4 {
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A4() {
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 6;
+        }
+    }
+    class Cycle_B_1_10020_2A5 {
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A5() {
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+public class Cycle_Bm_1_10020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_10020 A1_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A2_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A3_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A4_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A5_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        ThreadRc_Cycle_Bm_1_10020 A6_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020();
+        A1_Cycle_Bm_1_10020.start();
+        A2_Cycle_Bm_1_10020.start();
+        A3_Cycle_Bm_1_10020.start();
+        A4_Cycle_Bm_1_10020.start();
+        A5_Cycle_Bm_1_10020.start();
+        A6_Cycle_Bm_1_10020.start();
+        try {
+            A1_Cycle_Bm_1_10020.join();
+            A2_Cycle_Bm_1_10020.join();
+            A3_Cycle_Bm_1_10020.join();
+            A4_Cycle_Bm_1_10020.join();
+            A5_Cycle_Bm_1_10020.join();
+            A6_Cycle_Bm_1_10020.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_10020.check() && A2_Cycle_Bm_1_10020.check() && A3_Cycle_Bm_1_10020.check() && A4_Cycle_Bm_1_10020.check() && A5_Cycle_Bm_1_10020.check() && A6_Cycle_Bm_1_10020.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/expected.txt b/testsuite/java_test/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/test.cfg b/testsuite/java_test/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0a7f6643bf04c3ddb9c8c374533504304c48bc76
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_10020)
+run(Cycle_Bm_1_10020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/Cycle_Bm_1_10030.java b/testsuite/java_test/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/Cycle_Bm_1_10030.java
new file mode 100755
index 0000000000000000000000000000000000000000..deb101f9bfe08eaea1b226090e4e7c3fdbbde356
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/Cycle_Bm_1_10030.java
@@ -0,0 +1,343 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_1_10010B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_10010_A1 a1_0 = new Cycle_B_1_10010_A1();
+        a1_0.a2_0 = new Cycle_B_1_10010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10010_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        Cycle_B_1_10010_2A1 a1_10 = new Cycle_B_1_10010_2A1();
+        a1_10.a2_0 = new Cycle_B_1_10010_2A2();
+        a1_10.a2_0.a3_0 = new Cycle_B_1_10010_2A3();
+        a1_10.a2_0.a3_0.a1_0 = a1_10;
+        a1_10.add();
+        a1_10.a2_0.add();
+        a1_10.a2_0.a3_0.add();
+        int nsum2 = (a1_10.sum + a1_10.a2_0.sum + a1_10.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        nsum += nsum2;
+        if (nsum == 24)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_10010_A1 {
+        Cycle_B_1_10010_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_10010_A2 {
+        Cycle_B_1_10010_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_10010_A3 {
+        Cycle_B_1_10010_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10010_2A1 {
+        Cycle_B_1_10010_2A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_2A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_10010_2A2 {
+        Cycle_B_1_10010_2A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_10010_2A3 {
+        Cycle_B_1_10010_2A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10010_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_1_10020B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_10020_A1 a1_0 = new Cycle_B_1_10020_A1();
+        a1_0.a2_0 = new Cycle_B_1_10020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_10020_A3();
+        Cycle_B_1_10020_A4 a4_0 = new Cycle_B_1_10020_A4();
+        Cycle_B_1_10020_A5 a5_0 = new Cycle_B_1_10020_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        Cycle_B_1_10020_2A1 a1_20 = new Cycle_B_1_10020_2A1();
+        a1_20.a2_0 = new Cycle_B_1_10020_2A2();
+        a1_20.a2_0.a3_0 = new Cycle_B_1_10020_2A3();
+        Cycle_B_1_10020_2A4 a4_20 = new Cycle_B_1_10020_2A4();
+        Cycle_B_1_10020_2A5 a5_20 = new Cycle_B_1_10020_2A5();
+        a1_20.a4_0 = a4_20;
+        a1_20.a5_0 = a5_20;
+        a1_20.a2_0.a3_0.a1_0 = a1_20;
+        a1_20.add();
+        a1_20.a2_0.add();
+        a1_20.a2_0.a3_0.add();
+        a4_20.add();
+        a5_20.add();
+        int nsum1 = (a1_20.sum + a1_20.a2_0.sum + a1_20.a2_0.a3_0.sum + a4_20.sum + a5_20.sum);
+        nsum += nsum1;
+        if (nsum == 61)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_10020_A1 {
+        Cycle_B_1_10020_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_10020_A2 {
+        Cycle_B_1_10020_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_10020_A3 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10020_A4 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10020_A5 {
+        Cycle_B_1_10020_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10020_2A1 {
+        Cycle_B_1_10020_2A2 a2_0;
+        Cycle_B_1_10020_2A4 a4_0;
+        Cycle_B_1_10020_2A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_10020_2A2 {
+        Cycle_B_1_10020_2A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_10020_2A3 {
+        Cycle_B_1_10020_2A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_10020_2A4 {
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A4() {
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 6;
+        }
+    }
+    class Cycle_B_1_10020_2A5 {
+        int a;
+        int sum;
+        Cycle_B_1_10020_2A5() {
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + 8;
+        }
+    }
+}
+public class Cycle_Bm_1_10030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_10010B A1_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A2_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A3_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A4_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A5_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10010B A6_Cycle_Bm_1_10010 = new ThreadRc_Cycle_Bm_1_10010B();
+        ThreadRc_Cycle_Bm_1_10020B A1_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A2_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A3_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A4_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A5_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        ThreadRc_Cycle_Bm_1_10020B A6_Cycle_Bm_1_10020 = new ThreadRc_Cycle_Bm_1_10020B();
+        A1_Cycle_Bm_1_10010.start();
+        A2_Cycle_Bm_1_10010.start();
+        A3_Cycle_Bm_1_10010.start();
+        A4_Cycle_Bm_1_10010.start();
+        A5_Cycle_Bm_1_10010.start();
+        A6_Cycle_Bm_1_10010.start();
+        A1_Cycle_Bm_1_10020.start();
+        A2_Cycle_Bm_1_10020.start();
+        A3_Cycle_Bm_1_10020.start();
+        A4_Cycle_Bm_1_10020.start();
+        A5_Cycle_Bm_1_10020.start();
+        A6_Cycle_Bm_1_10020.start();
+        try {
+            A1_Cycle_Bm_1_10010.join();
+            A2_Cycle_Bm_1_10010.join();
+            A3_Cycle_Bm_1_10010.join();
+            A4_Cycle_Bm_1_10010.join();
+            A5_Cycle_Bm_1_10010.join();
+            A6_Cycle_Bm_1_10010.join();
+            A1_Cycle_Bm_1_10020.join();
+            A2_Cycle_Bm_1_10020.join();
+            A3_Cycle_Bm_1_10020.join();
+            A4_Cycle_Bm_1_10020.join();
+            A5_Cycle_Bm_1_10020.join();
+            A6_Cycle_Bm_1_10020.join();
+        } catch (InterruptedException e) {
+            e.getStackTrace();
+        }
+        if (A1_Cycle_Bm_1_10010.check() && A2_Cycle_Bm_1_10010.check() && A3_Cycle_Bm_1_10010.check() && A4_Cycle_Bm_1_10010.check() && A5_Cycle_Bm_1_10010.check() && A6_Cycle_Bm_1_10010.check() && A1_Cycle_Bm_1_10020.check() && A2_Cycle_Bm_1_10020.check() && A3_Cycle_Bm_1_10020.check() && A4_Cycle_Bm_1_10020.check() && A5_Cycle_Bm_1_10020.check() && A6_Cycle_Bm_1_10020.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/expected.txt b/testsuite/java_test/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/test.cfg b/testsuite/java_test/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0b56293838ab2d07eb4fb05ca6f989e8a08ec6e3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_1_10030)
+run(Cycle_Bm_1_10030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/Cycle_Bm_2_00010.java b/testsuite/java_test/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/Cycle_Bm_2_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..c111b8513ac58fbb87ffe08d240f9e98913bfeef
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/Cycle_Bm_2_00010.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00010 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00010_A1 a1_0 = new Cycle_B_2_00010_A1();
+        a1_0.a2_0 = new Cycle_B_2_00010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00010_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00010_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 18)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00010_A1 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00010_A2 {
+        Cycle_B_2_00010_A3 a3_0;
+        Cycle_B_2_00010_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00010_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00010_A3 {
+        Cycle_B_2_00010_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00010_A4 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00010_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00010 A1_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A2_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A3_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A4_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A5_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        ThreadRc_Cycle_Bm_2_00010 A6_Cycle_Bm_2_00010 = new ThreadRc_Cycle_Bm_2_00010();
+        A1_Cycle_Bm_2_00010.start();
+        A2_Cycle_Bm_2_00010.start();
+        A3_Cycle_Bm_2_00010.start();
+        A4_Cycle_Bm_2_00010.start();
+        A5_Cycle_Bm_2_00010.start();
+        A6_Cycle_Bm_2_00010.start();
+        try {
+            A1_Cycle_Bm_2_00010.join();
+            A2_Cycle_Bm_2_00010.join();
+            A3_Cycle_Bm_2_00010.join();
+            A4_Cycle_Bm_2_00010.join();
+            A5_Cycle_Bm_2_00010.join();
+            A6_Cycle_Bm_2_00010.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00010.check() && A2_Cycle_Bm_2_00010.check() && A3_Cycle_Bm_2_00010.check() && A4_Cycle_Bm_2_00010.check() && A5_Cycle_Bm_2_00010.check() && A6_Cycle_Bm_2_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/expected.txt b/testsuite/java_test/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/test.cfg b/testsuite/java_test/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..48029002733a28e4364ba71bc0edcab7580f1d9b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00010)
+run(Cycle_Bm_2_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/Cycle_Bm_2_00020.java b/testsuite/java_test/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/Cycle_Bm_2_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..e2debc664efe4b48aba3c78f9a06ebd75c8440a7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/Cycle_Bm_2_00020.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00020 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00020_A1 a1_0 = new Cycle_B_2_00020_A1();
+        a1_0.a2_0 = new Cycle_B_2_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00020_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00020_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00020_A1 {
+        Cycle_B_2_00020_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00020_A2 {
+        Cycle_B_2_00020_A3 a3_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00020_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00020_A3 {
+        Cycle_B_2_00020_A1 a1_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00020_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00020_A4 {
+        Cycle_B_2_00020_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00020_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00020 A1_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A2_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A3_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A4_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A5_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        ThreadRc_Cycle_Bm_2_00020 A6_Cycle_Bm_2_00020 = new ThreadRc_Cycle_Bm_2_00020();
+        A1_Cycle_Bm_2_00020.start();
+        A2_Cycle_Bm_2_00020.start();
+        A3_Cycle_Bm_2_00020.start();
+        A4_Cycle_Bm_2_00020.start();
+        A5_Cycle_Bm_2_00020.start();
+        A6_Cycle_Bm_2_00020.start();
+        try {
+            A1_Cycle_Bm_2_00020.join();
+            A2_Cycle_Bm_2_00020.join();
+            A3_Cycle_Bm_2_00020.join();
+            A4_Cycle_Bm_2_00020.join();
+            A5_Cycle_Bm_2_00020.join();
+            A6_Cycle_Bm_2_00020.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00020.check() && A2_Cycle_Bm_2_00020.check() && A3_Cycle_Bm_2_00020.check() && A4_Cycle_Bm_2_00020.check() && A5_Cycle_Bm_2_00020.check() && A6_Cycle_Bm_2_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/expected.txt b/testsuite/java_test/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/test.cfg b/testsuite/java_test/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6f87db06a3aca6f07b230a20009cf3a46c8ee61d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00020)
+run(Cycle_Bm_2_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/Cycle_Bm_2_00030.java b/testsuite/java_test/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/Cycle_Bm_2_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..9d256021b72e1a92bdfc2fafd17e1caa557a0267
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/Cycle_Bm_2_00030.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00030 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00030_A1 a1_0 = new Cycle_B_2_00030_A1();
+        a1_0.a2_0 = new Cycle_B_2_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00030_A3();
+        Cycle_B_2_00030_A4 a4_0 = new Cycle_B_2_00030_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00030_A1 {
+        Cycle_B_2_00030_A2 a2_0;
+        Cycle_B_2_00030_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00030_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00030_A2 {
+        Cycle_B_2_00030_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00030_A3 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00030_A4 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00030_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00030 A1_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A2_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A3_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A4_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A5_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        ThreadRc_Cycle_Bm_2_00030 A6_Cycle_Bm_2_00030 = new ThreadRc_Cycle_Bm_2_00030();
+        A1_Cycle_Bm_2_00030.start();
+        A2_Cycle_Bm_2_00030.start();
+        A3_Cycle_Bm_2_00030.start();
+        A4_Cycle_Bm_2_00030.start();
+        A5_Cycle_Bm_2_00030.start();
+        A6_Cycle_Bm_2_00030.start();
+        try {
+            A1_Cycle_Bm_2_00030.join();
+            A2_Cycle_Bm_2_00030.join();
+            A3_Cycle_Bm_2_00030.join();
+            A4_Cycle_Bm_2_00030.join();
+            A5_Cycle_Bm_2_00030.join();
+            A6_Cycle_Bm_2_00030.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00030.check() && A2_Cycle_Bm_2_00030.check() && A3_Cycle_Bm_2_00030.check() && A4_Cycle_Bm_2_00030.check() && A5_Cycle_Bm_2_00030.check() && A6_Cycle_Bm_2_00030.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/expected.txt b/testsuite/java_test/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/test.cfg b/testsuite/java_test/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6a3ff068cd53bd876bfa328e621434dc8e7767b2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00030)
+run(Cycle_Bm_2_00030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/Cycle_Bm_2_00040.java b/testsuite/java_test/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/Cycle_Bm_2_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..8afd55b6d981c477eb255e24a521dc816f531765
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/Cycle_Bm_2_00040.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00040 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00040_A1 a1_0 = new Cycle_B_2_00040_A1();
+        a1_0.a2_0 = new Cycle_B_2_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00040_A3();
+        Cycle_B_2_00040_A4 a4_0 = new Cycle_B_2_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00040_A1 {
+        Cycle_B_2_00040_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00040_A2 {
+        Cycle_B_2_00040_A3 a3_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00040_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00040_A3 {
+        Cycle_B_2_00040_A1 a1_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00040_A4 {
+        Cycle_B_2_00040_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00040_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00040 A1_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A2_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A3_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A4_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A5_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        ThreadRc_Cycle_Bm_2_00040 A6_Cycle_Bm_2_00040 = new ThreadRc_Cycle_Bm_2_00040();
+        A1_Cycle_Bm_2_00040.start();
+        A2_Cycle_Bm_2_00040.start();
+        A3_Cycle_Bm_2_00040.start();
+        A4_Cycle_Bm_2_00040.start();
+        A5_Cycle_Bm_2_00040.start();
+        A6_Cycle_Bm_2_00040.start();
+        try {
+            A1_Cycle_Bm_2_00040.join();
+            A2_Cycle_Bm_2_00040.join();
+            A3_Cycle_Bm_2_00040.join();
+            A4_Cycle_Bm_2_00040.join();
+            A5_Cycle_Bm_2_00040.join();
+            A6_Cycle_Bm_2_00040.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00040.check() && A2_Cycle_Bm_2_00040.check() && A3_Cycle_Bm_2_00040.check() && A4_Cycle_Bm_2_00040.check() && A5_Cycle_Bm_2_00040.check() && A6_Cycle_Bm_2_00040.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/expected.txt b/testsuite/java_test/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/test.cfg b/testsuite/java_test/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..083d7a0537e82ce7103e3d2141561c46ebe78309
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00040)
+run(Cycle_Bm_2_00040,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/Cycle_Bm_2_00050.java b/testsuite/java_test/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/Cycle_Bm_2_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..b046d40d547fcab730a09df6ec11da867dcde88b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/Cycle_Bm_2_00050.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00050 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00050_A1 a1_0 = new Cycle_B_2_00050_A1();
+        a1_0.a2_0 = new Cycle_B_2_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00050_A3();
+        Cycle_B_2_00050_A4 a4_0 = new Cycle_B_2_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00050_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00050_A1 {
+        Cycle_B_2_00050_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00050_A2 {
+        Cycle_B_2_00050_A3 a3_0;
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00050_A3 {
+        Cycle_B_2_00050_A1 a1_0;
+        Cycle_B_2_00050_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00050_A4 {
+        Cycle_B_2_00050_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00050_A5 {
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00050 A1_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A2_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A3_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A4_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A5_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        ThreadRc_Cycle_Bm_2_00050 A6_Cycle_Bm_2_00050 = new ThreadRc_Cycle_Bm_2_00050();
+        A1_Cycle_Bm_2_00050.start();
+        A2_Cycle_Bm_2_00050.start();
+        A3_Cycle_Bm_2_00050.start();
+        A4_Cycle_Bm_2_00050.start();
+        A5_Cycle_Bm_2_00050.start();
+        A6_Cycle_Bm_2_00050.start();
+        try {
+            A1_Cycle_Bm_2_00050.join();
+            A2_Cycle_Bm_2_00050.join();
+            A3_Cycle_Bm_2_00050.join();
+            A4_Cycle_Bm_2_00050.join();
+            A5_Cycle_Bm_2_00050.join();
+            A6_Cycle_Bm_2_00050.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00050.check() && A2_Cycle_Bm_2_00050.check() && A3_Cycle_Bm_2_00050.check() && A4_Cycle_Bm_2_00050.check() && A5_Cycle_Bm_2_00050.check() && A6_Cycle_Bm_2_00050.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/expected.txt b/testsuite/java_test/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/test.cfg b/testsuite/java_test/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc1860edae77cc2b77203944272b319437147a64
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00050)
+run(Cycle_Bm_2_00050,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/Cycle_Bm_2_00060.java b/testsuite/java_test/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/Cycle_Bm_2_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..9b01098d375d1557423753ea1ce3f595809cad5a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/Cycle_Bm_2_00060.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00060 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00060_A1 a1_0 = new Cycle_B_2_00060_A1();
+        a1_0.a2_0 = new Cycle_B_2_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00060_A3();
+        Cycle_B_2_00060_A4 a4_0 = new Cycle_B_2_00060_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00060_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00060_A1 {
+        Cycle_B_2_00060_A2 a2_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00060_A2 {
+        Cycle_B_2_00060_A3 a3_0;
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00060_A3 {
+        Cycle_B_2_00060_A1 a1_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00060_A4 {
+        Cycle_B_2_00060_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00060_A5 {
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00060 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00060 A1_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A2_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A3_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A4_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A5_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        ThreadRc_Cycle_Bm_2_00060 A6_Cycle_Bm_2_00060 = new ThreadRc_Cycle_Bm_2_00060();
+        A1_Cycle_Bm_2_00060.start();
+        A2_Cycle_Bm_2_00060.start();
+        A3_Cycle_Bm_2_00060.start();
+        A4_Cycle_Bm_2_00060.start();
+        A5_Cycle_Bm_2_00060.start();
+        A6_Cycle_Bm_2_00060.start();
+        try {
+            A1_Cycle_Bm_2_00060.join();
+            A2_Cycle_Bm_2_00060.join();
+            A3_Cycle_Bm_2_00060.join();
+            A4_Cycle_Bm_2_00060.join();
+            A5_Cycle_Bm_2_00060.join();
+            A6_Cycle_Bm_2_00060.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00060.check() && A2_Cycle_Bm_2_00060.check() && A3_Cycle_Bm_2_00060.check() && A4_Cycle_Bm_2_00060.check() && A5_Cycle_Bm_2_00060.check() && A6_Cycle_Bm_2_00060.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/expected.txt b/testsuite/java_test/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/test.cfg b/testsuite/java_test/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..868867f932cb0af98ecb97fde2a3a843d8b2282d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00060)
+run(Cycle_Bm_2_00060,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/Cycle_Bm_2_00070.java b/testsuite/java_test/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/Cycle_Bm_2_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..34672f6c15a6f00239fe84e1728471344bcc9f49
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/Cycle_Bm_2_00070.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00070 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00070_A1 a1_0 = new Cycle_B_2_00070_A1();
+        a1_0.a2_0 = new Cycle_B_2_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00070_A3();
+        Cycle_B_2_00070_A4 a4_0 = new Cycle_B_2_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00070_A5();
+        Cycle_B_2_00070_A6 a6_0 = new Cycle_B_2_00070_A6();
+        a6_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a6_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum + a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 37)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00070_A1 {
+        Cycle_B_2_00070_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A2 {
+        Cycle_B_2_00070_A3 a3_0;
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A3 {
+        Cycle_B_2_00070_A1 a1_0;
+        Cycle_B_2_00070_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A4 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A5 {
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A6 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A6() {
+            a3_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00070 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00070 A1_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A2_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A3_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A4_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A5_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        ThreadRc_Cycle_Bm_2_00070 A6_Cycle_Bm_2_00070 = new ThreadRc_Cycle_Bm_2_00070();
+        A1_Cycle_Bm_2_00070.start();
+        A2_Cycle_Bm_2_00070.start();
+        A3_Cycle_Bm_2_00070.start();
+        A4_Cycle_Bm_2_00070.start();
+        A5_Cycle_Bm_2_00070.start();
+        A6_Cycle_Bm_2_00070.start();
+        try {
+            A1_Cycle_Bm_2_00070.join();
+            A2_Cycle_Bm_2_00070.join();
+            A3_Cycle_Bm_2_00070.join();
+            A4_Cycle_Bm_2_00070.join();
+            A5_Cycle_Bm_2_00070.join();
+            A6_Cycle_Bm_2_00070.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00070.check() && A2_Cycle_Bm_2_00070.check() && A3_Cycle_Bm_2_00070.check() && A4_Cycle_Bm_2_00070.check() && A5_Cycle_Bm_2_00070.check() && A6_Cycle_Bm_2_00070.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/expected.txt b/testsuite/java_test/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/test.cfg b/testsuite/java_test/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2870b18483924a0e4978a22b37747975150c6acd
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00070)
+run(Cycle_Bm_2_00070,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/Cycle_Bm_2_00080.java b/testsuite/java_test/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/Cycle_Bm_2_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..8b5e7dfffa9056811f3e9bbb5883ae33edd6bc9f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/Cycle_Bm_2_00080.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00080 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00080_A1 {
+        Cycle_B_2_00080_A2 a2_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A2 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A3 {
+        Cycle_B_2_00080_A1 a1_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A4 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A4() {
+            a3_0 = null;
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A5 {
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00080 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00080 A1_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A2_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A3_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A4_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A5_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A6_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        A1_Cycle_Bm_2_00080.start();
+        A2_Cycle_Bm_2_00080.start();
+        A3_Cycle_Bm_2_00080.start();
+        A4_Cycle_Bm_2_00080.start();
+        A5_Cycle_Bm_2_00080.start();
+        A6_Cycle_Bm_2_00080.start();
+        try {
+            A1_Cycle_Bm_2_00080.join();
+            A2_Cycle_Bm_2_00080.join();
+            A3_Cycle_Bm_2_00080.join();
+            A4_Cycle_Bm_2_00080.join();
+            A5_Cycle_Bm_2_00080.join();
+            A6_Cycle_Bm_2_00080.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00080.check() && A2_Cycle_Bm_2_00080.check() && A3_Cycle_Bm_2_00080.check() && A4_Cycle_Bm_2_00080.check() && A5_Cycle_Bm_2_00080.check() && A6_Cycle_Bm_2_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/expected.txt b/testsuite/java_test/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/test.cfg b/testsuite/java_test/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cf87f790d1deb21fcb2b0b279bd1b0d4bc9d35e2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00080)
+run(Cycle_Bm_2_00080,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/Cycle_Bm_2_00090.java b/testsuite/java_test/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/Cycle_Bm_2_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..c3077551b243f8d4f650043c2004be974a2fe523
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/Cycle_Bm_2_00090.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00090 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00090_A1 a1_0 = new Cycle_B_2_00090_A1();
+        Cycle_B_2_00090_A3 a3_0 = new Cycle_B_2_00090_A3();
+        a1_0.a2_0 = new Cycle_B_2_00090_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a3_0.a2_0 = a1_0.a2_0;
+        a3_0.a2_0.a3_0 = a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 9)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00090_A1 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00090_A2 {
+        Cycle_B_2_00090_A1 a1_0;
+        Cycle_B_2_00090_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00090_A2() {
+            a1_0 = null;
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00090_A3 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00090_A3() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00090 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00090 A1_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A2_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A3_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A4_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A5_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        ThreadRc_Cycle_Bm_2_00090 A6_Cycle_Bm_2_00090 = new ThreadRc_Cycle_Bm_2_00090();
+        A1_Cycle_Bm_2_00090.start();
+        A2_Cycle_Bm_2_00090.start();
+        A3_Cycle_Bm_2_00090.start();
+        A4_Cycle_Bm_2_00090.start();
+        A5_Cycle_Bm_2_00090.start();
+        A6_Cycle_Bm_2_00090.start();
+        try {
+            A1_Cycle_Bm_2_00090.join();
+            A2_Cycle_Bm_2_00090.join();
+            A3_Cycle_Bm_2_00090.join();
+            A4_Cycle_Bm_2_00090.join();
+            A5_Cycle_Bm_2_00090.join();
+            A6_Cycle_Bm_2_00090.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00090.check() && A2_Cycle_Bm_2_00090.check() && A3_Cycle_Bm_2_00090.check() && A4_Cycle_Bm_2_00090.check() && A5_Cycle_Bm_2_00090.check() && A6_Cycle_Bm_2_00090.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/expected.txt b/testsuite/java_test/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/test.cfg b/testsuite/java_test/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8921682b4a70421a8c3479502e1c324be39b01ff
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00090)
+run(Cycle_Bm_2_00090,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/Cycle_Bm_2_00100.java b/testsuite/java_test/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/Cycle_Bm_2_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..e5a6bc6342a0668172b478d27a02e10800934be1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/Cycle_Bm_2_00100.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00100 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00100_A1 a1_0 = new Cycle_B_2_00100_A1();
+        a1_0.a2_0 = new Cycle_B_2_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00100_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00100_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00100_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 29)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00100_A1 {
+        Cycle_B_2_00100_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00100_A2 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00100_A3 {
+        Cycle_B_2_00100_A1 a1_0;
+        Cycle_B_2_00100_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00100_A4 {
+        Cycle_B_2_00100_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00100_A5 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00100 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00100 A1_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A2_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A3_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A4_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A5_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        ThreadRc_Cycle_Bm_2_00100 A6_Cycle_Bm_2_00100 = new ThreadRc_Cycle_Bm_2_00100();
+        A1_Cycle_Bm_2_00100.start();
+        A2_Cycle_Bm_2_00100.start();
+        A3_Cycle_Bm_2_00100.start();
+        A4_Cycle_Bm_2_00100.start();
+        A5_Cycle_Bm_2_00100.start();
+        A6_Cycle_Bm_2_00100.start();
+        try {
+            A1_Cycle_Bm_2_00100.join();
+            A2_Cycle_Bm_2_00100.join();
+            A3_Cycle_Bm_2_00100.join();
+            A4_Cycle_Bm_2_00100.join();
+            A5_Cycle_Bm_2_00100.join();
+            A6_Cycle_Bm_2_00100.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00100.check() && A2_Cycle_Bm_2_00100.check() && A3_Cycle_Bm_2_00100.check() && A4_Cycle_Bm_2_00100.check() && A5_Cycle_Bm_2_00100.check() && A6_Cycle_Bm_2_00100.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/expected.txt b/testsuite/java_test/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/test.cfg b/testsuite/java_test/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..25bc19f9fe1df11d5b6f1675f74f4e67a1c70ca0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00100)
+run(Cycle_Bm_2_00100,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/Cycle_Bm_2_00110.java b/testsuite/java_test/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/Cycle_Bm_2_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..07e90e37892f13c487fc52b9e6caca00ae54661f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/Cycle_Bm_2_00110.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00110 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00110_A1 a1_0 = new Cycle_B_2_00110_A1();
+        a1_0.a2_0 = new Cycle_B_2_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00110_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00110_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_2_00110_A5();
+        a1_0.a2_0.a4_0.a5_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00110_A1 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00110_A2 {
+        Cycle_B_2_00110_A3 a3_0;
+        Cycle_B_2_00110_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00110_A3 {
+        Cycle_B_2_00110_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00110_A4 {
+        Cycle_B_2_00110_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00110_A5 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00110 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00110 A1_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A2_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A3_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A4_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A5_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        ThreadRc_Cycle_Bm_2_00110 A6_Cycle_Bm_2_00110 = new ThreadRc_Cycle_Bm_2_00110();
+        A1_Cycle_Bm_2_00110.start();
+        A2_Cycle_Bm_2_00110.start();
+        A3_Cycle_Bm_2_00110.start();
+        A4_Cycle_Bm_2_00110.start();
+        A5_Cycle_Bm_2_00110.start();
+        A6_Cycle_Bm_2_00110.start();
+        try {
+            A1_Cycle_Bm_2_00110.join();
+            A2_Cycle_Bm_2_00110.join();
+            A3_Cycle_Bm_2_00110.join();
+            A4_Cycle_Bm_2_00110.join();
+            A5_Cycle_Bm_2_00110.join();
+            A6_Cycle_Bm_2_00110.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00110.check() && A2_Cycle_Bm_2_00110.check() && A3_Cycle_Bm_2_00110.check() && A4_Cycle_Bm_2_00110.check() && A5_Cycle_Bm_2_00110.check() && A6_Cycle_Bm_2_00110.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/expected.txt b/testsuite/java_test/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/test.cfg b/testsuite/java_test/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..33d478d716519d3ef376fa5c086674942eb1862f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00110)
+run(Cycle_Bm_2_00110,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/Cycle_Bm_2_00120.java b/testsuite/java_test/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/Cycle_Bm_2_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..525d358094e78e22381202b46ea68bba3a793c61
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/Cycle_Bm_2_00120.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00120 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00120_A1 a1_0 = new Cycle_B_2_00120_A1();
+        a1_0.a2_0 = new Cycle_B_2_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00120_A3();
+        a1_0.a4_0 = new Cycle_B_2_00120_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a4_0.a5_0 = new Cycle_B_2_00120_A5();
+        a1_0.a4_0.a5_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a4_0.add();
+        a1_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a4_0.sum + a1_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00120_A1 {
+        Cycle_B_2_00120_A2 a2_0;
+        Cycle_B_2_00120_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00120_A2 {
+        Cycle_B_2_00120_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00120_A3 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00120_A4 {
+        Cycle_B_2_00120_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00120_A5 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00120 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00120 A1_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A2_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A3_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A4_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A5_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        ThreadRc_Cycle_Bm_2_00120 A6_Cycle_Bm_2_00120 = new ThreadRc_Cycle_Bm_2_00120();
+        A1_Cycle_Bm_2_00120.start();
+        A2_Cycle_Bm_2_00120.start();
+        A3_Cycle_Bm_2_00120.start();
+        A4_Cycle_Bm_2_00120.start();
+        A5_Cycle_Bm_2_00120.start();
+        A6_Cycle_Bm_2_00120.start();
+        try {
+            A1_Cycle_Bm_2_00120.join();
+            A2_Cycle_Bm_2_00120.join();
+            A3_Cycle_Bm_2_00120.join();
+            A4_Cycle_Bm_2_00120.join();
+            A5_Cycle_Bm_2_00120.join();
+            A6_Cycle_Bm_2_00120.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00120.check() && A2_Cycle_Bm_2_00120.check() && A3_Cycle_Bm_2_00120.check() && A4_Cycle_Bm_2_00120.check() && A5_Cycle_Bm_2_00120.check() && A6_Cycle_Bm_2_00120.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/expected.txt b/testsuite/java_test/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/test.cfg b/testsuite/java_test/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dcc04672b717247c9691ee93c0182047b8de2eef
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00120)
+run(Cycle_Bm_2_00120,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/Cycle_Bm_2_00130.java b/testsuite/java_test/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/Cycle_Bm_2_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..f5cb42644dd0b42b4502c29e04bfcadacef5d34d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/Cycle_Bm_2_00130.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00130 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00130_A1 a1_0 = new Cycle_B_2_00130_A1();
+        a1_0.a2_0 = new Cycle_B_2_00130_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00130_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00130_A4();
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        Cycle_B_2_00130_A5 a5_0 = new Cycle_B_2_00130_A5();
+        a1_0.a2_0.a3_0.a4_0.a6_0 = new Cycle_B_2_00130_A6();
+        a1_0.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_0;
+        a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a6_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a5_0.sum + a1_0.a2_0.a3_0.a4_0.a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 45)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00130_A1 {
+        Cycle_B_2_00130_A2 a2_0;
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A2 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A3 {
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A4 {
+        Cycle_B_2_00130_A1 a1_0;
+        Cycle_B_2_00130_A6 a6_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A5 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A6 {
+        Cycle_B_2_00130_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00130 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00130 A1_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A2_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A3_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A4_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A5_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        ThreadRc_Cycle_Bm_2_00130 A6_Cycle_Bm_2_00130 = new ThreadRc_Cycle_Bm_2_00130();
+        A1_Cycle_Bm_2_00130.start();
+        A2_Cycle_Bm_2_00130.start();
+        A3_Cycle_Bm_2_00130.start();
+        A4_Cycle_Bm_2_00130.start();
+        A5_Cycle_Bm_2_00130.start();
+        A6_Cycle_Bm_2_00130.start();
+        try {
+            A1_Cycle_Bm_2_00130.join();
+            A2_Cycle_Bm_2_00130.join();
+            A3_Cycle_Bm_2_00130.join();
+            A4_Cycle_Bm_2_00130.join();
+            A5_Cycle_Bm_2_00130.join();
+            A6_Cycle_Bm_2_00130.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00130.check() && A2_Cycle_Bm_2_00130.check() && A3_Cycle_Bm_2_00130.check() && A4_Cycle_Bm_2_00130.check() && A5_Cycle_Bm_2_00130.check() && A6_Cycle_Bm_2_00130.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/expected.txt b/testsuite/java_test/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/test.cfg b/testsuite/java_test/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9ee905c3b80c953677ff833bdb2fc6343491c9e5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00130)
+run(Cycle_Bm_2_00130,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/Cycle_Bm_2_00140.java b/testsuite/java_test/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/Cycle_Bm_2_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..84cdcc2b7e306c2d72dd46cb4c7823632db9e4a5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/Cycle_Bm_2_00140.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00140 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00140_A1 a1_0 = new Cycle_B_2_00140_A1();
+        a1_0.a2_0 = new Cycle_B_2_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00140_A3();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00140_A1 {
+        Cycle_B_2_00140_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00140_A2 {
+        Cycle_B_2_00140_A3 a3_0;
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00140_A2() {
+            a3_0 = null;
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00140_A3 {
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00140 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00140 A1_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A2_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A3_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A4_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A5_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        ThreadRc_Cycle_Bm_2_00140 A6_Cycle_Bm_2_00140 = new ThreadRc_Cycle_Bm_2_00140();
+        A1_Cycle_Bm_2_00140.start();
+        A2_Cycle_Bm_2_00140.start();
+        A3_Cycle_Bm_2_00140.start();
+        A4_Cycle_Bm_2_00140.start();
+        A5_Cycle_Bm_2_00140.start();
+        A6_Cycle_Bm_2_00140.start();
+        try {
+            A1_Cycle_Bm_2_00140.join();
+            A2_Cycle_Bm_2_00140.join();
+            A3_Cycle_Bm_2_00140.join();
+            A4_Cycle_Bm_2_00140.join();
+            A5_Cycle_Bm_2_00140.join();
+            A6_Cycle_Bm_2_00140.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00140.check() && A2_Cycle_Bm_2_00140.check() && A3_Cycle_Bm_2_00140.check() && A4_Cycle_Bm_2_00140.check() && A5_Cycle_Bm_2_00140.check() && A6_Cycle_Bm_2_00140.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/expected.txt b/testsuite/java_test/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/test.cfg b/testsuite/java_test/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..12f74cf3f558ceadf0b0651619d550b8fec73672
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00140)
+run(Cycle_Bm_2_00140,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/Cycle_Bm_2_00150.java b/testsuite/java_test/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/Cycle_Bm_2_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..3e5c574f5d9af4dcfe41c7a1d78401da5079af93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/Cycle_Bm_2_00150.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00150 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00150_A1 a1_0 = new Cycle_B_2_00150_A1();
+        a1_0.a2_0 = new Cycle_B_2_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 14)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00150_A1 {
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00150_A2 {
+        Cycle_B_2_00150_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00150_A3 {
+        Cycle_B_2_00150_A1 a1_0;
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00150_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00150 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00150 A1_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A2_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A3_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A4_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A5_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        ThreadRc_Cycle_Bm_2_00150 A6_Cycle_Bm_2_00150 = new ThreadRc_Cycle_Bm_2_00150();
+        A1_Cycle_Bm_2_00150.start();
+        A2_Cycle_Bm_2_00150.start();
+        A3_Cycle_Bm_2_00150.start();
+        A4_Cycle_Bm_2_00150.start();
+        A5_Cycle_Bm_2_00150.start();
+        A6_Cycle_Bm_2_00150.start();
+        try {
+            A1_Cycle_Bm_2_00150.join();
+            A2_Cycle_Bm_2_00150.join();
+            A3_Cycle_Bm_2_00150.join();
+            A4_Cycle_Bm_2_00150.join();
+            A5_Cycle_Bm_2_00150.join();
+            A6_Cycle_Bm_2_00150.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00150.check() && A2_Cycle_Bm_2_00150.check() && A3_Cycle_Bm_2_00150.check() && A4_Cycle_Bm_2_00150.check() && A5_Cycle_Bm_2_00150.check() && A6_Cycle_Bm_2_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/expected.txt b/testsuite/java_test/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/test.cfg b/testsuite/java_test/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e75d9569c6a5d7a74ea096a9a380a654e7f642fc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00150)
+run(Cycle_Bm_2_00150,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/Cycle_Bm_2_00160.java b/testsuite/java_test/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/Cycle_Bm_2_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..fdd9a11b484233227c076ff1fe6674beb6e63370
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/Cycle_Bm_2_00160.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00160 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00160_A1 a1_0 = new Cycle_B_2_00160_A1();
+        a1_0.a2_0 = new Cycle_B_2_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00160_A3();
+        a1_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00160_A1 {
+        Cycle_B_2_00160_A2 a2_0;
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00160_A2 {
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00160_A3 {
+        Cycle_B_2_00160_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00160 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00160 A1_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A2_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A3_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A4_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A5_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        ThreadRc_Cycle_Bm_2_00160 A6_Cycle_Bm_2_00160 = new ThreadRc_Cycle_Bm_2_00160();
+        A1_Cycle_Bm_2_00160.start();
+        A2_Cycle_Bm_2_00160.start();
+        A3_Cycle_Bm_2_00160.start();
+        A4_Cycle_Bm_2_00160.start();
+        A5_Cycle_Bm_2_00160.start();
+        A6_Cycle_Bm_2_00160.start();
+        try {
+            A1_Cycle_Bm_2_00160.join();
+            A2_Cycle_Bm_2_00160.join();
+            A3_Cycle_Bm_2_00160.join();
+            A4_Cycle_Bm_2_00160.join();
+            A5_Cycle_Bm_2_00160.join();
+            A6_Cycle_Bm_2_00160.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00160.check() && A2_Cycle_Bm_2_00160.check() && A3_Cycle_Bm_2_00160.check() && A4_Cycle_Bm_2_00160.check() && A5_Cycle_Bm_2_00160.check() && A6_Cycle_Bm_2_00160.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/expected.txt b/testsuite/java_test/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/test.cfg b/testsuite/java_test/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fa91f082880f00d4cf0baa1732e5778a34d91c43
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00160)
+run(Cycle_Bm_2_00160,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/Cycle_Bm_2_00170.java b/testsuite/java_test/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/Cycle_Bm_2_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c1e2265afdbbd84c154f363c5686723545f90ca
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/Cycle_Bm_2_00170.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00170 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00170_A1 a1_0 = new Cycle_B_2_00170_A1();
+        a1_0.a2_0 = new Cycle_B_2_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00170_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00170_A4();
+        a1_0.a2_0.a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00170_A1 {
+        Cycle_B_2_00170_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00170_A2 {
+        Cycle_B_2_00170_A3 a3_0;
+        Cycle_B_2_00170_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00170_A3 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00170_A4 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00170 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00170 A1_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A2_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A3_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A4_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A5_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        ThreadRc_Cycle_Bm_2_00170 A6_Cycle_Bm_2_00170 = new ThreadRc_Cycle_Bm_2_00170();
+        A1_Cycle_Bm_2_00170.start();
+        A2_Cycle_Bm_2_00170.start();
+        A3_Cycle_Bm_2_00170.start();
+        A4_Cycle_Bm_2_00170.start();
+        A5_Cycle_Bm_2_00170.start();
+        A6_Cycle_Bm_2_00170.start();
+        try {
+            A1_Cycle_Bm_2_00170.join();
+            A2_Cycle_Bm_2_00170.join();
+            A3_Cycle_Bm_2_00170.join();
+            A4_Cycle_Bm_2_00170.join();
+            A5_Cycle_Bm_2_00170.join();
+            A6_Cycle_Bm_2_00170.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00170.check() && A2_Cycle_Bm_2_00170.check() && A3_Cycle_Bm_2_00170.check() && A4_Cycle_Bm_2_00170.check() && A5_Cycle_Bm_2_00170.check() && A6_Cycle_Bm_2_00170.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/expected.txt b/testsuite/java_test/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/test.cfg b/testsuite/java_test/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b895e2686ce13d863fe9901ee796df7f7164cc4f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00170)
+run(Cycle_Bm_2_00170,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/Cycle_Bm_2_00180.java b/testsuite/java_test/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/Cycle_Bm_2_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..2dede10820194bd464ad77556882fda964cd877b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/Cycle_Bm_2_00180.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00180 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00180_A1 a1_0 = new Cycle_B_2_00180_A1();
+        a1_0.a2_0 = new Cycle_B_2_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00180_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00180_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00180_A1 {
+        Cycle_B_2_00180_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00180_A2 {
+        Cycle_B_2_00180_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00180_A3 {
+        Cycle_B_2_00180_A1 a1_0;
+        Cycle_B_2_00180_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00180_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00180_A4 {
+        Cycle_B_2_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00180_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00180 A1_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A2_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A3_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A4_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A5_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        ThreadRc_Cycle_Bm_2_00180 A6_Cycle_Bm_2_00180 = new ThreadRc_Cycle_Bm_2_00180();
+        A1_Cycle_Bm_2_00180.start();
+        A2_Cycle_Bm_2_00180.start();
+        A3_Cycle_Bm_2_00180.start();
+        A4_Cycle_Bm_2_00180.start();
+        A5_Cycle_Bm_2_00180.start();
+        A6_Cycle_Bm_2_00180.start();
+        try {
+            A1_Cycle_Bm_2_00180.join();
+            A2_Cycle_Bm_2_00180.join();
+            A3_Cycle_Bm_2_00180.join();
+            A4_Cycle_Bm_2_00180.join();
+            A5_Cycle_Bm_2_00180.join();
+            A6_Cycle_Bm_2_00180.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00180.check() && A2_Cycle_Bm_2_00180.check() && A3_Cycle_Bm_2_00180.check() && A4_Cycle_Bm_2_00180.check() && A5_Cycle_Bm_2_00180.check() && A6_Cycle_Bm_2_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/expected.txt b/testsuite/java_test/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/test.cfg b/testsuite/java_test/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9b7d4aaf2ea152b08a2b470b5a2dae249f76e49f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00180)
+run(Cycle_Bm_2_00180,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/Cycle_Bm_2_00190.java b/testsuite/java_test/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/Cycle_Bm_2_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..b0fd61bc91d01da7b586c7acbfa4dd7ec144a74a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/Cycle_Bm_2_00190.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00190 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00190_A1 a1_0 = new Cycle_B_2_00190_A1();
+        a1_0.a2_0 = new Cycle_B_2_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00190_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00190_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00190_A1 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00190_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00190_A2 {
+        Cycle_B_2_00190_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00190_A3 {
+        Cycle_B_2_00190_A1 a1_0;
+        Cycle_B_2_00190_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00190_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00190_A4 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00190_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00190 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00190 A1_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A2_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A3_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A4_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A5_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        ThreadRc_Cycle_Bm_2_00190 A6_Cycle_Bm_2_00190 = new ThreadRc_Cycle_Bm_2_00190();
+        A1_Cycle_Bm_2_00190.start();
+        A2_Cycle_Bm_2_00190.start();
+        A3_Cycle_Bm_2_00190.start();
+        A4_Cycle_Bm_2_00190.start();
+        A5_Cycle_Bm_2_00190.start();
+        A6_Cycle_Bm_2_00190.start();
+        try {
+            A1_Cycle_Bm_2_00190.join();
+            A2_Cycle_Bm_2_00190.join();
+            A3_Cycle_Bm_2_00190.join();
+            A4_Cycle_Bm_2_00190.join();
+            A5_Cycle_Bm_2_00190.join();
+            A6_Cycle_Bm_2_00190.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00190.check() && A2_Cycle_Bm_2_00190.check() && A3_Cycle_Bm_2_00190.check() && A4_Cycle_Bm_2_00190.check() && A5_Cycle_Bm_2_00190.check() && A6_Cycle_Bm_2_00190.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/expected.txt b/testsuite/java_test/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/test.cfg b/testsuite/java_test/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2c248cb70f1037750dfb95721e56bcf705a39c1c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00190)
+run(Cycle_Bm_2_00190,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/Cycle_Bm_2_00200.java b/testsuite/java_test/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/Cycle_Bm_2_00200.java
new file mode 100755
index 0000000000000000000000000000000000000000..75df222181253c6733f61d0b765100a29c95219d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/Cycle_Bm_2_00200.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00200 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00200_A1 a1_0 = new Cycle_B_2_00200_A1();
+        a1_0.a2_0 = new Cycle_B_2_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00200_A3();
+        Cycle_B_2_00200_A4 a4_0 = new Cycle_B_2_00200_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00200_A1 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00200_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00200_A2 {
+        Cycle_B_2_00200_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00200_A3 {
+        Cycle_B_2_00200_A1 a1_0;
+        Cycle_B_2_00200_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00200_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00200_A4 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00200_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00200 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00200 A1_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A2_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A3_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A4_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A5_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        ThreadRc_Cycle_Bm_2_00200 A6_Cycle_Bm_2_00200 = new ThreadRc_Cycle_Bm_2_00200();
+        A1_Cycle_Bm_2_00200.start();
+        A2_Cycle_Bm_2_00200.start();
+        A3_Cycle_Bm_2_00200.start();
+        A4_Cycle_Bm_2_00200.start();
+        A5_Cycle_Bm_2_00200.start();
+        A6_Cycle_Bm_2_00200.start();
+        try {
+            A1_Cycle_Bm_2_00200.join();
+            A2_Cycle_Bm_2_00200.join();
+            A3_Cycle_Bm_2_00200.join();
+            A4_Cycle_Bm_2_00200.join();
+            A5_Cycle_Bm_2_00200.join();
+            A6_Cycle_Bm_2_00200.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00200.check() && A2_Cycle_Bm_2_00200.check() && A3_Cycle_Bm_2_00200.check() && A4_Cycle_Bm_2_00200.check() && A5_Cycle_Bm_2_00200.check() && A6_Cycle_Bm_2_00200.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/expected.txt b/testsuite/java_test/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/test.cfg b/testsuite/java_test/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2aa3e2d6871231dc60765721728724c6bbc7e23e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00200)
+run(Cycle_Bm_2_00200,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/Cycle_Bm_2_00210.java b/testsuite/java_test/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/Cycle_Bm_2_00210.java
new file mode 100755
index 0000000000000000000000000000000000000000..7dae5da9fd8427aeb574f2a591c3f5b065019f0c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/Cycle_Bm_2_00210.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00210 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00210_A1 a1_0 = new Cycle_B_2_00210_A1();
+        a1_0.a2_0 = new Cycle_B_2_00210_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00210_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00210_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00210_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00210_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0 = new Cycle_B_2_00210_A8();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0 = new Cycle_B_2_00210_A9();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00210_A7();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00210_A1 {
+        Cycle_B_2_00210_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A2 {
+        Cycle_B_2_00210_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A3 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A4 {
+        Cycle_B_2_00210_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A5 {
+        Cycle_B_2_00210_A6 a6_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A6 {
+        Cycle_B_2_00210_A1 a1_0;
+        Cycle_B_2_00210_A8 a8_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A6() {
+            a1_0 = null;
+            a8_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a8_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A8 {
+        Cycle_B_2_00210_A9 a9_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A9 {
+        Cycle_B_2_00210_A7 a7_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A7 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00210 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00210 A1_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A2_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A3_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A4_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A5_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        ThreadRc_Cycle_Bm_2_00210 A6_Cycle_Bm_2_00210 = new ThreadRc_Cycle_Bm_2_00210();
+        A1_Cycle_Bm_2_00210.start();
+        A2_Cycle_Bm_2_00210.start();
+        A3_Cycle_Bm_2_00210.start();
+        A4_Cycle_Bm_2_00210.start();
+        A5_Cycle_Bm_2_00210.start();
+        A6_Cycle_Bm_2_00210.start();
+        try {
+            A1_Cycle_Bm_2_00210.join();
+            A2_Cycle_Bm_2_00210.join();
+            A3_Cycle_Bm_2_00210.join();
+            A4_Cycle_Bm_2_00210.join();
+            A5_Cycle_Bm_2_00210.join();
+            A6_Cycle_Bm_2_00210.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00210.check() && A2_Cycle_Bm_2_00210.check() && A3_Cycle_Bm_2_00210.check() && A4_Cycle_Bm_2_00210.check() && A5_Cycle_Bm_2_00210.check() && A6_Cycle_Bm_2_00210.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/expected.txt b/testsuite/java_test/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/test.cfg b/testsuite/java_test/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..675d2b180da4970c7737d572ff892390f1585dc2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00210)
+run(Cycle_Bm_2_00210,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/Cycle_Bm_2_00220.java b/testsuite/java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/Cycle_Bm_2_00220.java
new file mode 100755
index 0000000000000000000000000000000000000000..e16920e2d8ae995115569ca13f60ec7c1956f5b0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/Cycle_Bm_2_00220.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00220 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00220_A1 a1_0 = new Cycle_B_2_00220_A1();
+        a1_0.a2_0 = new Cycle_B_2_00220_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00220_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00220_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00220_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00220_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a8_0 = new Cycle_B_2_00220_A8();
+        a1_0.a8_0.a9_0 = new Cycle_B_2_00220_A9();
+        a1_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00220_A7();
+        a1_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a8_0.add();
+        a1_0.a8_0.a9_0.add();
+        a1_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a8_0.sum + a1_0.a8_0.a9_0.sum + a1_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00220_A1 {
+        Cycle_B_2_00220_A2 a2_0;
+        Cycle_B_2_00220_A8 a8_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A1() {
+            a2_0 = null;
+            a8_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A2 {
+        Cycle_B_2_00220_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A3 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A4 {
+        Cycle_B_2_00220_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A5 {
+        Cycle_B_2_00220_A6 a6_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A6 {
+        Cycle_B_2_00220_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A6() {
+            a1_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A8 {
+        Cycle_B_2_00220_A9 a9_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A9 {
+        Cycle_B_2_00220_A7 a7_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A7 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00220 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00220 A1_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A2_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A3_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A4_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A5_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        ThreadRc_Cycle_Bm_2_00220 A6_Cycle_Bm_2_00220 = new ThreadRc_Cycle_Bm_2_00220();
+        A1_Cycle_Bm_2_00220.start();
+        A2_Cycle_Bm_2_00220.start();
+        A3_Cycle_Bm_2_00220.start();
+        A4_Cycle_Bm_2_00220.start();
+        A5_Cycle_Bm_2_00220.start();
+        A6_Cycle_Bm_2_00220.start();
+        try {
+            A1_Cycle_Bm_2_00220.join();
+            A2_Cycle_Bm_2_00220.join();
+            A3_Cycle_Bm_2_00220.join();
+            A4_Cycle_Bm_2_00220.join();
+            A5_Cycle_Bm_2_00220.join();
+            A6_Cycle_Bm_2_00220.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00220.check() && A2_Cycle_Bm_2_00220.check() && A3_Cycle_Bm_2_00220.check() && A4_Cycle_Bm_2_00220.check() && A5_Cycle_Bm_2_00220.check() && A6_Cycle_Bm_2_00220.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/expected.txt b/testsuite/java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/test.cfg b/testsuite/java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f751cf109b9a3a472dffb5784bbcdd9be0c8f29b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00220)
+run(Cycle_Bm_2_00220,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/Cycle_Bm_2_00230.java b/testsuite/java_test/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/Cycle_Bm_2_00230.java
new file mode 100755
index 0000000000000000000000000000000000000000..154f1632f6e81e5668f887d3bc38c7b4ae8a0f20
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/Cycle_Bm_2_00230.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00230 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 97)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00230_A1 {
+        Cycle_B_2_00230_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A2 {
+        Cycle_B_2_00230_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A3 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A4 {
+        Cycle_B_2_00230_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A5 {
+        Cycle_B_2_00230_A6 a6_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A6 {
+        Cycle_B_2_00230_A1 a1_0;
+        Cycle_B_2_00230_A10 a10_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A6() {
+            a1_0 = null;
+            a10_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A8 {
+        Cycle_B_2_00230_A9 a9_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A9 {
+        Cycle_B_2_00230_A7 a7_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A7 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A10 {
+        Cycle_B_2_00230_A8 a8_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A10() {
+            a8_0 = null;
+            a = 10;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00230 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00230 A1_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A2_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A3_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A4_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A5_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A6_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        A1_Cycle_Bm_2_00230.start();
+        A2_Cycle_Bm_2_00230.start();
+        A3_Cycle_Bm_2_00230.start();
+        A4_Cycle_Bm_2_00230.start();
+        A5_Cycle_Bm_2_00230.start();
+        A6_Cycle_Bm_2_00230.start();
+        try {
+            A1_Cycle_Bm_2_00230.join();
+            A2_Cycle_Bm_2_00230.join();
+            A3_Cycle_Bm_2_00230.join();
+            A4_Cycle_Bm_2_00230.join();
+            A5_Cycle_Bm_2_00230.join();
+            A6_Cycle_Bm_2_00230.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00230.check() && A2_Cycle_Bm_2_00230.check() && A3_Cycle_Bm_2_00230.check() && A4_Cycle_Bm_2_00230.check() && A5_Cycle_Bm_2_00230.check() && A6_Cycle_Bm_2_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/expected.txt b/testsuite/java_test/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/test.cfg b/testsuite/java_test/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2232d4bd175c853820464526b767b6f74bec32c0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00230)
+run(Cycle_Bm_2_00230,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/Cycle_Bm_2_00240.java b/testsuite/java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/Cycle_Bm_2_00240.java
new file mode 100755
index 0000000000000000000000000000000000000000..d9961fea65961266b4948c304a6ab87fc3a9fd20
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/Cycle_Bm_2_00240.java
@@ -0,0 +1,2303 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_00010B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00010_A1 a1_0 = new Cycle_B_2_00010_A1();
+        a1_0.a2_0 = new Cycle_B_2_00010_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00010_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00010_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 18)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00010_A1 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00010_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00010_A2 {
+        Cycle_B_2_00010_A3 a3_0;
+        Cycle_B_2_00010_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00010_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00010_A3 {
+        Cycle_B_2_00010_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00010_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00010_A4 {
+        Cycle_B_2_00010_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00010_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00020B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00020_A1 a1_0 = new Cycle_B_2_00020_A1();
+        a1_0.a2_0 = new Cycle_B_2_00020_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00020_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00020_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00020_A1 {
+        Cycle_B_2_00020_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00020_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00020_A2 {
+        Cycle_B_2_00020_A3 a3_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00020_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00020_A3 {
+        Cycle_B_2_00020_A1 a1_0;
+        Cycle_B_2_00020_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00020_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00020_A4 {
+        Cycle_B_2_00020_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00020_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00030B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00030_A1 a1_0 = new Cycle_B_2_00030_A1();
+        a1_0.a2_0 = new Cycle_B_2_00030_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00030_A3();
+        Cycle_B_2_00030_A4 a4_0 = new Cycle_B_2_00030_A4();
+        a4_0.a1_0 = a1_0;
+        a1_0.a4_0 = a4_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00030_A1 {
+        Cycle_B_2_00030_A2 a2_0;
+        Cycle_B_2_00030_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00030_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00030_A2 {
+        Cycle_B_2_00030_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00030_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00030_A3 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00030_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00030_A4 {
+        Cycle_B_2_00030_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00030_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00040B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00040_A1 a1_0 = new Cycle_B_2_00040_A1();
+        a1_0.a2_0 = new Cycle_B_2_00040_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00040_A3();
+        Cycle_B_2_00040_A4 a4_0 = new Cycle_B_2_00040_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 19)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00040_A1 {
+        Cycle_B_2_00040_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00040_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00040_A2 {
+        Cycle_B_2_00040_A3 a3_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00040_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00040_A3 {
+        Cycle_B_2_00040_A1 a1_0;
+        Cycle_B_2_00040_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00040_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00040_A4 {
+        Cycle_B_2_00040_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00040_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00050B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00050_A1 a1_0 = new Cycle_B_2_00050_A1();
+        a1_0.a2_0 = new Cycle_B_2_00050_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00050_A3();
+        Cycle_B_2_00050_A4 a4_0 = new Cycle_B_2_00050_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00050_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00050_A1 {
+        Cycle_B_2_00050_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00050_A2 {
+        Cycle_B_2_00050_A3 a3_0;
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00050_A3 {
+        Cycle_B_2_00050_A1 a1_0;
+        Cycle_B_2_00050_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00050_A4 {
+        Cycle_B_2_00050_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00050_A5 {
+        Cycle_B_2_00050_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00050_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00060B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00060_A1 a1_0 = new Cycle_B_2_00060_A1();
+        a1_0.a2_0 = new Cycle_B_2_00060_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00060_A3();
+        Cycle_B_2_00060_A4 a4_0 = new Cycle_B_2_00060_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00060_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00060_A1 {
+        Cycle_B_2_00060_A2 a2_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00060_A2 {
+        Cycle_B_2_00060_A3 a3_0;
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00060_A3 {
+        Cycle_B_2_00060_A1 a1_0;
+        Cycle_B_2_00060_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00060_A4 {
+        Cycle_B_2_00060_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00060_A5 {
+        Cycle_B_2_00060_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00060_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00070B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00070_A1 a1_0 = new Cycle_B_2_00070_A1();
+        a1_0.a2_0 = new Cycle_B_2_00070_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00070_A3();
+        Cycle_B_2_00070_A4 a4_0 = new Cycle_B_2_00070_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00070_A5();
+        Cycle_B_2_00070_A6 a6_0 = new Cycle_B_2_00070_A6();
+        a6_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a6_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum + a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 37)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00070_A1 {
+        Cycle_B_2_00070_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A2 {
+        Cycle_B_2_00070_A3 a3_0;
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A3 {
+        Cycle_B_2_00070_A1 a1_0;
+        Cycle_B_2_00070_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A4 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A4() {
+            a3_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A5 {
+        Cycle_B_2_00070_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00070_A6 {
+        Cycle_B_2_00070_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00070_A6() {
+            a3_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00080B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a4_0.a3_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a4_0.a3_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.a5_0 = a4_0.a3_0.a5_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a4_0.a3_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a4_0.a3_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00080_A1 {
+        Cycle_B_2_00080_A2 a2_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A2 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A3 {
+        Cycle_B_2_00080_A1 a1_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A4 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A4() {
+            a3_0 = null;
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A5 {
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00090B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00090_A1 a1_0 = new Cycle_B_2_00090_A1();
+        Cycle_B_2_00090_A3 a3_0 = new Cycle_B_2_00090_A3();
+        a1_0.a2_0 = new Cycle_B_2_00090_A2();
+        a1_0.a2_0.a1_0 = a1_0;
+        a3_0.a2_0 = a1_0.a2_0;
+        a3_0.a2_0.a3_0 = a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 9)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00090_A1 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00090_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00090_A2 {
+        Cycle_B_2_00090_A1 a1_0;
+        Cycle_B_2_00090_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00090_A2() {
+            a1_0 = null;
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00090_A3 {
+        Cycle_B_2_00090_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00090_A3() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00100B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00100_A1 a1_0 = new Cycle_B_2_00100_A1();
+        a1_0.a2_0 = new Cycle_B_2_00100_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00100_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00100_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00100_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 29)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00100_A1 {
+        Cycle_B_2_00100_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00100_A2 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00100_A3 {
+        Cycle_B_2_00100_A1 a1_0;
+        Cycle_B_2_00100_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00100_A4 {
+        Cycle_B_2_00100_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00100_A5 {
+        Cycle_B_2_00100_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00100_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00110B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00110_A1 a1_0 = new Cycle_B_2_00110_A1();
+        a1_0.a2_0 = new Cycle_B_2_00110_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00110_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00110_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a4_0.a5_0 = new Cycle_B_2_00110_A5();
+        a1_0.a2_0.a4_0.a5_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        a1_0.a2_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum + a1_0.a2_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00110_A1 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00110_A2 {
+        Cycle_B_2_00110_A3 a3_0;
+        Cycle_B_2_00110_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00110_A3 {
+        Cycle_B_2_00110_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00110_A4 {
+        Cycle_B_2_00110_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00110_A5 {
+        Cycle_B_2_00110_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00110_A5() {
+            a2_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00120B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00120_A1 a1_0 = new Cycle_B_2_00120_A1();
+        a1_0.a2_0 = new Cycle_B_2_00120_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00120_A3();
+        a1_0.a4_0 = new Cycle_B_2_00120_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a4_0.a5_0 = new Cycle_B_2_00120_A5();
+        a1_0.a4_0.a5_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a4_0.add();
+        a1_0.a4_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a4_0.sum + a1_0.a4_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 27)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00120_A1 {
+        Cycle_B_2_00120_A2 a2_0;
+        Cycle_B_2_00120_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00120_A2 {
+        Cycle_B_2_00120_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00120_A3 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00120_A4 {
+        Cycle_B_2_00120_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00120_A5 {
+        Cycle_B_2_00120_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00120_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00130B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00130_A1 a1_0 = new Cycle_B_2_00130_A1();
+        a1_0.a2_0 = new Cycle_B_2_00130_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00130_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00130_A4();
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        Cycle_B_2_00130_A5 a5_0 = new Cycle_B_2_00130_A5();
+        a1_0.a2_0.a3_0.a4_0.a6_0 = new Cycle_B_2_00130_A6();
+        a1_0.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_0;
+        a5_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a6_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a5_0.sum + a1_0.a2_0.a3_0.a4_0.a6_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 45)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00130_A1 {
+        Cycle_B_2_00130_A2 a2_0;
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A2 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A3 {
+        Cycle_B_2_00130_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A4 {
+        Cycle_B_2_00130_A1 a1_0;
+        Cycle_B_2_00130_A6 a6_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A5 {
+        Cycle_B_2_00130_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00130_A6 {
+        Cycle_B_2_00130_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00130_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00140B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00140_A1 a1_0 = new Cycle_B_2_00140_A1();
+        a1_0.a2_0 = new Cycle_B_2_00140_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00140_A3();
+        a1_0.a2_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 13)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00140_A1 {
+        Cycle_B_2_00140_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00140_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00140_A2 {
+        Cycle_B_2_00140_A3 a3_0;
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00140_A2() {
+            a3_0 = null;
+            a1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00140_A3 {
+        Cycle_B_2_00140_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00140_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00150B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00150_A1 a1_0 = new Cycle_B_2_00150_A1();
+        a1_0.a2_0 = new Cycle_B_2_00150_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00150_A3();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 14)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00150_A1 {
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00150_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00150_A2 {
+        Cycle_B_2_00150_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00150_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00150_A3 {
+        Cycle_B_2_00150_A1 a1_0;
+        Cycle_B_2_00150_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00150_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00160B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00160_A1 a1_0 = new Cycle_B_2_00160_A1();
+        a1_0.a2_0 = new Cycle_B_2_00160_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00160_A3();
+        a1_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00160_A1 {
+        Cycle_B_2_00160_A2 a2_0;
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00160_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00160_A2 {
+        Cycle_B_2_00160_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00160_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00160_A3 {
+        Cycle_B_2_00160_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00160_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00170B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00170_A1 a1_0 = new Cycle_B_2_00170_A1();
+        a1_0.a2_0 = new Cycle_B_2_00170_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00170_A3();
+        a1_0.a2_0.a4_0 = new Cycle_B_2_00170_A4();
+        a1_0.a2_0.a4_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a4_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 21)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00170_A1 {
+        Cycle_B_2_00170_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00170_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00170_A2 {
+        Cycle_B_2_00170_A3 a3_0;
+        Cycle_B_2_00170_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00170_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00170_A3 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00170_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00170_A4 {
+        Cycle_B_2_00170_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00170_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00180B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00180_A1 a1_0 = new Cycle_B_2_00180_A1();
+        a1_0.a2_0 = new Cycle_B_2_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00180_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00180_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00180_A1 {
+        Cycle_B_2_00180_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00180_A2 {
+        Cycle_B_2_00180_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00180_A3 {
+        Cycle_B_2_00180_A1 a1_0;
+        Cycle_B_2_00180_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00180_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00180_A4 {
+        Cycle_B_2_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00180_A4() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00190B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00190_A1 a1_0 = new Cycle_B_2_00190_A1();
+        a1_0.a2_0 = new Cycle_B_2_00190_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00190_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00190_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 15)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00190_A1 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00190_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00190_A2 {
+        Cycle_B_2_00190_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00190_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00190_A3 {
+        Cycle_B_2_00190_A1 a1_0;
+        Cycle_B_2_00190_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00190_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00190_A4 {
+        Cycle_B_2_00190_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00190_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00200B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00200_A1 a1_0 = new Cycle_B_2_00200_A1();
+        a1_0.a2_0 = new Cycle_B_2_00200_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00200_A3();
+        Cycle_B_2_00200_A4 a4_0 = new Cycle_B_2_00200_A4();
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0 = a4_0;
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 16)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00200_A1 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00200_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00200_A2 {
+        Cycle_B_2_00200_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00200_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00200_A3 {
+        Cycle_B_2_00200_A1 a1_0;
+        Cycle_B_2_00200_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00200_A3() {
+            a1_0 = null;
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00200_A4 {
+        Cycle_B_2_00200_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00200_A4() {
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00210B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00210_A1 a1_0 = new Cycle_B_2_00210_A1();
+        a1_0.a2_0 = new Cycle_B_2_00210_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00210_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00210_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00210_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00210_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0 = new Cycle_B_2_00210_A8();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0 = new Cycle_B_2_00210_A9();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00210_A7();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00210_A1 {
+        Cycle_B_2_00210_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A2 {
+        Cycle_B_2_00210_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A3 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A4 {
+        Cycle_B_2_00210_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A5 {
+        Cycle_B_2_00210_A6 a6_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A6 {
+        Cycle_B_2_00210_A1 a1_0;
+        Cycle_B_2_00210_A8 a8_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A6() {
+            a1_0 = null;
+            a8_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a8_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A8 {
+        Cycle_B_2_00210_A9 a9_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A9 {
+        Cycle_B_2_00210_A7 a7_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_B_2_00210_A7 {
+        Cycle_B_2_00210_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00210_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00220B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00220_A1 a1_0 = new Cycle_B_2_00220_A1();
+        a1_0.a2_0 = new Cycle_B_2_00220_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00220_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00220_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00220_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00220_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        a1_0.a8_0 = new Cycle_B_2_00220_A8();
+        a1_0.a8_0.a9_0 = new Cycle_B_2_00220_A9();
+        a1_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00220_A7();
+        a1_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a1_0.a8_0.add();
+        a1_0.a8_0.a9_0.add();
+        a1_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a1_0.a8_0.sum + a1_0.a8_0.a9_0.sum + a1_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 94)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00220_A1 {
+        Cycle_B_2_00220_A2 a2_0;
+        Cycle_B_2_00220_A8 a8_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A1() {
+            a2_0 = null;
+            a8_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a + a8_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A2 {
+        Cycle_B_2_00220_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A3 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A4 {
+        Cycle_B_2_00220_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A5 {
+        Cycle_B_2_00220_A6 a6_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A6 {
+        Cycle_B_2_00220_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A6() {
+            a1_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A8 {
+        Cycle_B_2_00220_A9 a9_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A9 {
+        Cycle_B_2_00220_A7 a7_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_B_2_00220_A7 {
+        Cycle_B_2_00220_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00220_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+class ThreadRc_Cycle_Bm_2_00230B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 97)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00230_A1 {
+        Cycle_B_2_00230_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A2 {
+        Cycle_B_2_00230_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A3 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A4 {
+        Cycle_B_2_00230_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A5 {
+        Cycle_B_2_00230_A6 a6_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A6 {
+        Cycle_B_2_00230_A1 a1_0;
+        Cycle_B_2_00230_A10 a10_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A6() {
+            a1_0 = null;
+            a10_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A8 {
+        Cycle_B_2_00230_A9 a9_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A9 {
+        Cycle_B_2_00230_A7 a7_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A7 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A10 {
+        Cycle_B_2_00230_A8 a8_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A10() {
+            a8_0 = null;
+            a = 10;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+public class Cycle_Bm_2_00240 {
+    public static void main(String[] args) {
+    rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00010B A1_00010 = new ThreadRc_Cycle_Bm_2_00010B();
+        ThreadRc_Cycle_Bm_2_00010B A2_00010 = new ThreadRc_Cycle_Bm_2_00010B();
+        ThreadRc_Cycle_Bm_2_00020B A1_00020 = new ThreadRc_Cycle_Bm_2_00020B();
+        ThreadRc_Cycle_Bm_2_00020B A2_00020 = new ThreadRc_Cycle_Bm_2_00020B();
+        ThreadRc_Cycle_Bm_2_00030B A1_00030 = new ThreadRc_Cycle_Bm_2_00030B();
+        ThreadRc_Cycle_Bm_2_00030B A2_00030 = new ThreadRc_Cycle_Bm_2_00030B();
+        ThreadRc_Cycle_Bm_2_00040B A1_00040 = new ThreadRc_Cycle_Bm_2_00040B();
+        ThreadRc_Cycle_Bm_2_00040B A2_00040 = new ThreadRc_Cycle_Bm_2_00040B();
+        ThreadRc_Cycle_Bm_2_00050B A1_00050 = new ThreadRc_Cycle_Bm_2_00050B();
+        ThreadRc_Cycle_Bm_2_00050B A2_00050 = new ThreadRc_Cycle_Bm_2_00050B();
+        ThreadRc_Cycle_Bm_2_00060B A1_00060 = new ThreadRc_Cycle_Bm_2_00060B();
+        ThreadRc_Cycle_Bm_2_00060B A2_00060 = new ThreadRc_Cycle_Bm_2_00060B();
+        ThreadRc_Cycle_Bm_2_00070B A1_00070 = new ThreadRc_Cycle_Bm_2_00070B();
+        ThreadRc_Cycle_Bm_2_00070B A2_00070 = new ThreadRc_Cycle_Bm_2_00070B();
+        ThreadRc_Cycle_Bm_2_00080B A1_00080 = new ThreadRc_Cycle_Bm_2_00080B();
+        ThreadRc_Cycle_Bm_2_00080B A2_00080 = new ThreadRc_Cycle_Bm_2_00080B();
+        ThreadRc_Cycle_Bm_2_00090B A1_00090 = new ThreadRc_Cycle_Bm_2_00090B();
+        ThreadRc_Cycle_Bm_2_00090B A2_00090 = new ThreadRc_Cycle_Bm_2_00090B();
+        ThreadRc_Cycle_Bm_2_00100B A1_00100 = new ThreadRc_Cycle_Bm_2_00100B();
+        ThreadRc_Cycle_Bm_2_00100B A2_00100 = new ThreadRc_Cycle_Bm_2_00100B();
+        ThreadRc_Cycle_Bm_2_00110B A1_00110 = new ThreadRc_Cycle_Bm_2_00110B();
+        ThreadRc_Cycle_Bm_2_00110B A2_00110 = new ThreadRc_Cycle_Bm_2_00110B();
+        ThreadRc_Cycle_Bm_2_00120B A1_00120 = new ThreadRc_Cycle_Bm_2_00120B();
+        ThreadRc_Cycle_Bm_2_00120B A2_00120 = new ThreadRc_Cycle_Bm_2_00120B();
+        ThreadRc_Cycle_Bm_2_00130B A1_00130 = new ThreadRc_Cycle_Bm_2_00130B();
+        ThreadRc_Cycle_Bm_2_00130B A2_00130 = new ThreadRc_Cycle_Bm_2_00130B();
+        ThreadRc_Cycle_Bm_2_00140B A1_00140 = new ThreadRc_Cycle_Bm_2_00140B();
+        ThreadRc_Cycle_Bm_2_00140B A2_00140 = new ThreadRc_Cycle_Bm_2_00140B();
+        ThreadRc_Cycle_Bm_2_00150B A1_00150 = new ThreadRc_Cycle_Bm_2_00150B();
+        ThreadRc_Cycle_Bm_2_00150B A2_00150 = new ThreadRc_Cycle_Bm_2_00150B();
+        ThreadRc_Cycle_Bm_2_00160B A1_00160 = new ThreadRc_Cycle_Bm_2_00160B();
+        ThreadRc_Cycle_Bm_2_00160B A2_00160 = new ThreadRc_Cycle_Bm_2_00160B();
+        ThreadRc_Cycle_Bm_2_00170B A1_00170 = new ThreadRc_Cycle_Bm_2_00170B();
+        ThreadRc_Cycle_Bm_2_00170B A2_00170 = new ThreadRc_Cycle_Bm_2_00170B();
+        ThreadRc_Cycle_Bm_2_00180B A1_00180 = new ThreadRc_Cycle_Bm_2_00180B();
+        ThreadRc_Cycle_Bm_2_00180B A2_00180 = new ThreadRc_Cycle_Bm_2_00180B();
+        ThreadRc_Cycle_Bm_2_00190B A1_00190 = new ThreadRc_Cycle_Bm_2_00190B();
+        ThreadRc_Cycle_Bm_2_00190B A2_00190 = new ThreadRc_Cycle_Bm_2_00190B();
+        ThreadRc_Cycle_Bm_2_00200B A1_00200 = new ThreadRc_Cycle_Bm_2_00200B();
+        ThreadRc_Cycle_Bm_2_00200B A2_00200 = new ThreadRc_Cycle_Bm_2_00200B();
+        ThreadRc_Cycle_Bm_2_00210B A1_00210 = new ThreadRc_Cycle_Bm_2_00210B();
+        ThreadRc_Cycle_Bm_2_00210B A2_00210 = new ThreadRc_Cycle_Bm_2_00210B();
+        ThreadRc_Cycle_Bm_2_00220B A1_00220 = new ThreadRc_Cycle_Bm_2_00220B();
+        ThreadRc_Cycle_Bm_2_00220B A2_00220 = new ThreadRc_Cycle_Bm_2_00220B();
+        ThreadRc_Cycle_Bm_2_00230B A1_00230 = new ThreadRc_Cycle_Bm_2_00230B();
+        ThreadRc_Cycle_Bm_2_00230B A2_00230 = new ThreadRc_Cycle_Bm_2_00230B();
+        A1_00010.start();
+        A2_00010.start();
+        A1_00020.start();
+        A2_00020.start();
+        A1_00030.start();
+        A2_00030.start();
+        A1_00040.start();
+        A2_00040.start();
+        A1_00050.start();
+        A2_00050.start();
+        A1_00060.start();
+        A2_00060.start();
+        A1_00070.start();
+        A2_00070.start();
+        A1_00080.start();
+        A2_00080.start();
+        A1_00090.start();
+        A2_00090.start();
+        A1_00100.start();
+        A2_00100.start();
+        A1_00110.start();
+        A2_00110.start();
+        A1_00120.start();
+        A2_00120.start();
+        A1_00130.start();
+        A2_00130.start();
+        A1_00140.start();
+        A2_00140.start();
+        A1_00150.start();
+        A2_00150.start();
+        A1_00160.start();
+        A2_00160.start();
+        A1_00170.start();
+        A2_00170.start();
+        A1_00180.start();
+        A2_00180.start();
+        A1_00190.start();
+        A2_00190.start();
+        A1_00200.start();
+        A2_00200.start();
+        A1_00210.start();
+        A2_00210.start();
+        A1_00220.start();
+        A2_00220.start();
+        A1_00230.start();
+        A2_00230.start();
+        try {
+            A1_00010.join();
+            A2_00010.join();
+            A1_00020.join();
+            A2_00020.join();
+            A1_00030.join();
+            A2_00030.join();
+            A1_00040.join();
+            A2_00040.join();
+            A1_00050.join();
+            A2_00050.join();
+            A1_00060.join();
+            A2_00060.join();
+            A1_00070.join();
+            A2_00070.join();
+            A1_00080.join();
+            A2_00080.join();
+            A1_00090.join();
+            A2_00090.join();
+            A1_00100.join();
+            A2_00100.join();
+            A1_00110.join();
+            A2_00110.join();
+            A1_00120.join();
+            A2_00120.join();
+            A1_00130.join();
+            A2_00130.join();
+            A1_00140.join();
+            A2_00140.join();
+            A1_00150.join();
+            A2_00150.join();
+            A1_00160.join();
+            A2_00160.join();
+            A1_00170.join();
+            A2_00170.join();
+            A1_00180.join();
+            A2_00180.join();
+            A1_00190.join();
+            A2_00190.join();
+            A1_00200.join();
+            A2_00200.join();
+            A1_00210.join();
+            A2_00210.join();
+            A1_00220.join();
+            A2_00220.join();
+            A1_00230.join();
+            A2_00230.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00010.check() && A2_00010.check() && A1_00020.check() && A2_00020.check() && A1_00030.check() && A2_00030.check() && A1_00040.check() && A2_00040.check() && A1_00050.check() && A2_00050.check() && A1_00060.check() && A2_00060.check() && A1_00070.check() && A2_00070.check() && A1_00080.check() && A2_00080.check() && A1_00090.check() && A2_00090.check() && A1_00100.check() && A2_00100.check() && A1_00110.check() && A2_00110.check() && A1_00120.check() && A2_00120.check() && A1_00130.check() && A2_00130.check() && A1_00140.check() && A2_00140.check() && A1_00150.check() && A2_00150.check() && A1_00160.check() && A2_00160.check() && A1_00170.check() && A2_00170.check() && A1_00180.check() && A2_00180.check() && A1_00190.check() && A2_00190.check() && A1_00200.check() && A2_00200.check() && A1_00210.check() && A2_00210.check() && A1_00220.check() && A2_00220.check() && A1_00230.check() && A2_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/expected.txt b/testsuite/java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f33a8592d2316dcaefb376e2e77d12a354a4918e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/expected.txt
@@ -0,0 +1,4 @@
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/test.cfg b/testsuite/java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e1f7abe4633e8d8364e0c78d053fbfacf647b14f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_00240)
+run(Cycle_Bm_2_00240,EXPECTNUM=4)
diff --git a/testsuite/java_test/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/Cycle_Bm_2_10240.java b/testsuite/java_test/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/Cycle_Bm_2_10240.java
new file mode 100755
index 0000000000000000000000000000000000000000..ed5f86864ecd03b0dde8f85d8169dc36a15c8408
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/Cycle_Bm_2_10240.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Cycle_Bm_2_10240 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00240_A1 a1_main = new Cycle_B_2_00240_A1("a1_main");
+        a1_main.a2_0 = new Cycle_B_2_00240_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_B_2_00240_A3("a3_0");
+        a1_main.a2_0.a4_0 = new Cycle_B_2_00240_A4("a4_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a4_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a4_0.a1_0 = a1_main;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a4_0.add();
+        int result = a1_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a4_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        Cycle_B_2_00240_B1 b1_0 = new Cycle_B_2_00240_B1();
+        b1_0.a3_0 = new Cycle_B_2_00240_A3("a3_b1");
+        b1_0.b2_0 = new Cycle_B_2_00240_B2();
+        b1_0.c2_0 = new Nocycle_B_2_00240_C2("c2_b1");
+        b1_0.b2_0.b1_0 = b1_0;
+        b1_0.add();
+        b1_0.b2_0.add();
+        int nsum = (b1_0.sum + b1_0.b2_0.sum);
+        // System.out.println(nsum);
+        Nocycle_B_2_00240_C1 c1_main = new Nocycle_B_2_00240_C1("c1_main");
+        c1_main.c2_0 = new Nocycle_B_2_00240_C2("c2_0");
+        c1_main.add();
+        c1_main.c2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",c1_main.sum+c1_main.b1_0.sum);
+        int result2 = c1_main.sum + c1_main.c2_0.sum;
+        //System.out.println("RC-Testing_Result="+result2);
+        if (result == 1124 && nsum == 310 && result2 == 704)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00240_A1 {
+        Cycle_B_2_00240_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_B_2_00240_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00240_A2 {
+        Cycle_B_2_00240_A1 a1_0;
+        Cycle_B_2_00240_A3 a3_0;
+        Cycle_B_2_00240_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_B_2_00240_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00240_A3 {
+        Cycle_B_2_00240_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_B_2_00240_A3(String strObjectName) {
+            a1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00240_A4 {
+        Cycle_B_2_00240_A1 a1_0;
+        Cycle_B_2_00240_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_B_2_00240_A4(String strObjectName) {
+            a2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00240_B1 {
+        Cycle_B_2_00240_A3 a3_0;
+        Cycle_B_2_00240_B2 b2_0;
+        Nocycle_B_2_00240_C2 c2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00240_B1() {
+            a3_0 = null;
+            b2_0 = null;
+            c2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a + b2_0.a + c2_0.a;
+        }
+    }
+    class Cycle_B_2_00240_B2 {
+        Cycle_B_2_00240_B1 b1_0;
+        int a;
+        int sum;
+        Cycle_B_2_00240_B2() {
+            b1_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_B_2_00240_C1 {
+        Nocycle_B_2_00240_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_B_2_00240_C1(String strObjectName) {
+            c2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + c2_0.a;
+        }
+    }
+    class Nocycle_B_2_00240_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_B_2_00240_C2(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Cycle_Bm_2_10240 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_10240 A1_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A2_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A3_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A4_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A5_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        ThreadRc_Cycle_Bm_2_10240 A6_Cycle_Bm_2_10240 = new ThreadRc_Cycle_Bm_2_10240();
+        A1_Cycle_Bm_2_10240.start();
+        A2_Cycle_Bm_2_10240.start();
+        A3_Cycle_Bm_2_10240.start();
+        A4_Cycle_Bm_2_10240.start();
+        A5_Cycle_Bm_2_10240.start();
+        A6_Cycle_Bm_2_10240.start();
+        try {
+            A1_Cycle_Bm_2_10240.join();
+            A2_Cycle_Bm_2_10240.join();
+            A3_Cycle_Bm_2_10240.join();
+            A4_Cycle_Bm_2_10240.join();
+            A5_Cycle_Bm_2_10240.join();
+            A6_Cycle_Bm_2_10240.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_10240.check() && A2_Cycle_Bm_2_10240.check() && A3_Cycle_Bm_2_10240.check() && A4_Cycle_Bm_2_10240.check() && A5_Cycle_Bm_2_10240.check() && A6_Cycle_Bm_2_10240.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/expected.txt b/testsuite/java_test/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f33a8592d2316dcaefb376e2e77d12a354a4918e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/expected.txt
@@ -0,0 +1,4 @@
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/test.cfg b/testsuite/java_test/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68d5491660779ff376b1f39b2e5978275e28dc47
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240/test.cfg
@@ -0,0 +1,2 @@
+compile(Cycle_Bm_2_10240)
+run(Cycle_Bm_2_10240,EXPECTNUM=4)
diff --git a/testsuite/java_test/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/Nocycle_am_00010.java b/testsuite/java_test/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/Nocycle_am_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..261f35e5629f06e027b83b5499d39e6235d71870
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/Nocycle_am_00010.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00010 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_am_00010_A1 a1_main = new Nocycle_am_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_am_00010_B1("b1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum;
+        // System.out.println("RC-Testing_Result_Thread="+result);
+        if (result == 704)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_am_00010_A1 {
+        Nocycle_am_00010_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_am_00010_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_am_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_am_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00010 t_00010 = new ThreadRc_00010();
+        t_00010.start();
+        ThreadRc_00010 t_00020 = new ThreadRc_00010();
+        t_00020.start();
+        ThreadRc_00010 t_00030 = new ThreadRc_00010();
+        t_00030.start();
+        ThreadRc_00010 t_00040 = new ThreadRc_00010();
+        t_00040.start();
+        ThreadRc_00010 t_00050 = new ThreadRc_00010();
+        t_00050.start();
+        ThreadRc_00010 t_00060 = new ThreadRc_00010();
+        t_00060.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+            t_00040.join();
+            t_00050.join();
+            t_00060.join();
+        } catch (InterruptedException e) {
+        }
+        if (t_00010.check() == true && t_00060.check() == true && t_00020.check() == true && t_00030.check() == true && t_00040.check() == true && t_00050.check() == true)
+            System.out.println("ExpectResult");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/expected.txt b/testsuite/java_test/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/test.cfg b/testsuite/java_test/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..267c2589b89f4c54c203fb0d5d1f32d06a0a3209
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0206-rc-function-RC_Thread01-Nocycle_am_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00010)
+run(Nocycle_am_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/Nocycle_am_00020.java b/testsuite/java_test/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/Nocycle_am_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..fe9ec43b918656d2393fb96cfe042ca983f3a039
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/Nocycle_am_00020.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00020 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00020_A1 a1_main = new Nocycle_a_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00020_B2("b2_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 1310)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00020_A1 {
+        Nocycle_a_00020_B1 b1_0;
+        Nocycle_a_00020_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00020 A1_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A2_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A3_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A4_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A5_00020 = new ThreadRc_00020();
+        ThreadRc_00020 A6_00020 = new ThreadRc_00020();
+        A1_00020.start();
+        A2_00020.start();
+        A3_00020.start();
+        A4_00020.start();
+        A5_00020.start();
+        A6_00020.start();
+        try {
+            A1_00020.join();
+            A2_00020.join();
+            A3_00020.join();
+            A4_00020.join();
+            A5_00020.join();
+            A6_00020.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00020.check() && A2_00020.check() && A3_00020.check() && A4_00020.check() && A5_00020.check() && A6_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/expected.txt b/testsuite/java_test/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/test.cfg b/testsuite/java_test/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..886d04c5a724629fca64ed5c066fd255d216fdbc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0207-rc-function-RC_Thread01-Nocycle_am_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00020)
+run(Nocycle_am_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/Nocycle_am_00030.java b/testsuite/java_test/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/Nocycle_am_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f01a92598d09de4dbf22a6725c482ad0d2b9d64
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/Nocycle_am_00030.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00030 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00030_A1 a1_main = new Nocycle_a_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00030_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00030_B3("b3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 1919)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00030_A1 {
+        Nocycle_a_00030_B1 b1_0;
+        Nocycle_a_00030_B2 b2_0;
+        Nocycle_a_00030_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00030_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00030_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00030_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00030_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00030_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00030_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00030_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00030 A1_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A2_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A3_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A4_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A5_00030 = new ThreadRc_00030();
+        ThreadRc_00030 A6_00030 = new ThreadRc_00030();
+        A1_00030.start();
+        A2_00030.start();
+        A3_00030.start();
+        A4_00030.start();
+        A5_00030.start();
+        A6_00030.start();
+        try {
+            A1_00030.join();
+            A2_00030.join();
+            A3_00030.join();
+            A4_00030.join();
+            A5_00030.join();
+            A6_00030.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00030.check() && A2_00030.check() && A3_00030.check() && A4_00030.check() && A5_00030.check() && A6_00030.check())
+            System.out.println("ExpectResult");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/expected.txt b/testsuite/java_test/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/test.cfg b/testsuite/java_test/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..124ab9d302eb043fed9177b6c8a794f52bf425c8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0208-rc-function-RC_Thread01-Nocycle_am_00030/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00030)
+run(Nocycle_am_00030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/Nocycle_am_00040.java b/testsuite/java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/Nocycle_am_00040.java
new file mode 100755
index 0000000000000000000000000000000000000000..31e6323670c08023821433a646d76838be9c1830
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/Nocycle_am_00040.java
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00040 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00040_A1 a1_main = new Nocycle_a_00040_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00040_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00040_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00040_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00040_B4("b4_0");
+        a1_main.b5_0 = new Nocycle_a_00040_B5("b5_0");
+        a1_main.b6_0 = new Nocycle_a_00040_B6("b6_0");
+        a1_main.b7_0 = new Nocycle_a_00040_B7("b7_0");
+        a1_main.b8_0 = new Nocycle_a_00040_B8("b8_0");
+        a1_main.b9_0 = new Nocycle_a_00040_B9("b9_0");
+        a1_main.b10_0 = new Nocycle_a_00040_B10("b10_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b5_0.add();
+        a1_main.b6_0.add();
+        a1_main.b7_0.add();
+        a1_main.b8_0.add();
+        a1_main.b9_0.add();
+        a1_main.b10_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b5_0.sum+a1_main.b6_0.sum+a1_main.b7_0.sum+a1_main.b8_0.sum+a1_main.b9_0.sum+a1_main.b10_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b5_0.sum + a1_main.b6_0.sum + a1_main.b7_0.sum + a1_main.b8_0.sum + a1_main.b9_0.sum + a1_main.b10_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 6266)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00040_A1 {
+        Nocycle_a_00040_B1 b1_0;
+        Nocycle_a_00040_B2 b2_0;
+        Nocycle_a_00040_B3 b3_0;
+        Nocycle_a_00040_B4 b4_0;
+        Nocycle_a_00040_B5 b5_0;
+        Nocycle_a_00040_B6 b6_0;
+        Nocycle_a_00040_B7 b7_0;
+        Nocycle_a_00040_B8 b8_0;
+        Nocycle_a_00040_B9 b9_0;
+        Nocycle_a_00040_B10 b10_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            b5_0 = null;
+            b6_0 = null;
+            b7_0 = null;
+            b8_0 = null;
+            b9_0 = null;
+            b10_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + b5_0.a + b6_0.a + b7_0.a + b8_0.a + b9_0.a + b10_0.a;
+        }
+    }
+    class Nocycle_a_00040_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B5 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B5(String strObjectName) {
+            a = 205;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B6 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B6(String strObjectName) {
+            a = 206;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B7(String strObjectName) {
+            a = 207;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B8 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B8(String strObjectName) {
+            a = 208;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B9 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B9(String strObjectName) {
+            a = 209;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B10 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B10(String strObjectName) {
+            a = 210;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B10_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00040 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00040 A1_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A2_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A3_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A4_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A5_00040 = new ThreadRc_00040();
+        ThreadRc_00040 A6_00040 = new ThreadRc_00040();
+        A1_00040.start();
+        A2_00040.start();
+        A3_00040.start();
+        A4_00040.start();
+        A5_00040.start();
+        A6_00040.start();
+        try {
+            A1_00040.join();
+            A2_00040.join();
+            A3_00040.join();
+            A4_00040.join();
+            A5_00040.join();
+            A6_00040.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00040.check() && A2_00040.check() && A3_00040.check() && A4_00040.check() && A5_00040.check() && A6_00040.check())
+            System.out.println("ExpectResult");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/expected.txt b/testsuite/java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/test.cfg b/testsuite/java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6793466b7bc2fa522c226eaa308fa2f0e637dc5a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0209-rc-function-RC_Thread01-Nocycle_am_00040/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00040)
+run(Nocycle_am_00040,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/Nocycle_am_00050.java b/testsuite/java_test/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/Nocycle_am_00050.java
new file mode 100755
index 0000000000000000000000000000000000000000..ca1d98b02e7b7160a090a99913c798fe778e96bb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/Nocycle_am_00050.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00050 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00050_A1 a1_main = new Nocycle_a_00050_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00050_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00050_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_a_00050_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_a_00050_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_a_00050_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00050_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00050_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        a1_main.b1_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c2_0.sum+a1_main.b1_0.c3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum + a1_main.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 5048)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00050_A1 {
+        Nocycle_a_00050_B1 b1_0;
+        Nocycle_a_00050_B2 b2_0;
+        Nocycle_a_00050_B3 b3_0;
+        Nocycle_a_00050_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class Nocycle_a_00050_B1 {
+        Nocycle_a_00050_C1 c1_0;
+        Nocycle_a_00050_C2 c2_0;
+        Nocycle_a_00050_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class Nocycle_a_00050_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00050 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00050 A1_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A2_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A3_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A4_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A5_00050 = new ThreadRc_00050();
+        ThreadRc_00050 A6_00050 = new ThreadRc_00050();
+        A1_00050.start();
+        A2_00050.start();
+        A3_00050.start();
+        A4_00050.start();
+        A5_00050.start();
+        A6_00050.start();
+        try {
+            A1_00050.join();
+            A2_00050.join();
+            A3_00050.join();
+            A4_00050.join();
+            A5_00050.join();
+            A6_00050.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00050.check() && A2_00050.check() && A3_00050.check() && A4_00050.check() && A5_00050.check() && A6_00050.check())
+            System.out.println("ExpectResult");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/expected.txt b/testsuite/java_test/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/test.cfg b/testsuite/java_test/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a52dfdd230d963271308c67bff0a1c5f883ba1d1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0210-rc-function-RC_Thread01-Nocycle_am_00050/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00050)
+run(Nocycle_am_00050,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/Nocycle_am_00060.java b/testsuite/java_test/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/Nocycle_am_00060.java
new file mode 100755
index 0000000000000000000000000000000000000000..40d389e889303baeef1285448715ca4928eb7656
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/Nocycle_am_00060.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00060 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00060_A1 a1_main = new Nocycle_a_00060_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00060_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00060_B2("b2_0");
+        a1_main.b2_0.c1_0 = new Nocycle_a_00060_C1("c1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00060_C2("c2_0");
+        a1_main.b2_0.c3_0 = new Nocycle_a_00060_C3("c3_0");
+        a1_main.b3_0 = new Nocycle_a_00060_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00060_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c1_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b2_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c1_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b2_0.c3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c1_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b2_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 5047)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00060_A1 {
+        Nocycle_a_00060_B1 b1_0;
+        Nocycle_a_00060_B2 b2_0;
+        Nocycle_a_00060_B3 b3_0;
+        Nocycle_a_00060_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class Nocycle_a_00060_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_B2 {
+        Nocycle_a_00060_C1 c1_0;
+        Nocycle_a_00060_C2 c2_0;
+        Nocycle_a_00060_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_B2(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class Nocycle_a_00060_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00060 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00060 A1_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A2_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A3_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A4_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A5_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A6_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A7_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A8_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A9_00060 = new ThreadRc_00060();
+        ThreadRc_00060 A10_00060 = new ThreadRc_00060();
+        A1_00060.start();
+        A2_00060.start();
+        A3_00060.start();
+        A4_00060.start();
+        A5_00060.start();
+        A6_00060.start();
+        A7_00060.start();
+        A8_00060.start();
+        A9_00060.start();
+        A10_00060.start();
+        try {
+            A1_00060.join();
+            A2_00060.join();
+            A3_00060.join();
+            A4_00060.join();
+            A5_00060.join();
+            A6_00060.join();
+            A7_00060.join();
+            A8_00060.join();
+            A9_00060.join();
+            A10_00060.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00060.check() && A2_00060.check() && A3_00060.check() && A4_00060.check() && A5_00060.check() && A6_00060.check() && A7_00060.check() && A8_00060.check() && A9_00060.check() && A10_00060.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/expected.txt b/testsuite/java_test/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/test.cfg b/testsuite/java_test/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ed0017bfe6da21c9c620d5a9c73ab0b8e3cbd00e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0211-rc-function-RC_Thread01-Nocycle_am_00060/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00060)
+run(Nocycle_am_00060,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/Nocycle_am_00070.java b/testsuite/java_test/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/Nocycle_am_00070.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e422c30f9031cee859a241cfb237721639d02ac
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/Nocycle_am_00070.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00070 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00070_A1 a1_main = new Nocycle_a_00070_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00070_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00070_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00070_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00070_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_00070_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_00070_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00070_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5045)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00070_A1 {
+        Nocycle_a_00070_B1 b1_0;
+        Nocycle_a_00070_B2 b2_0;
+        Nocycle_a_00070_B3 b3_0;
+        Nocycle_a_00070_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class Nocycle_a_00070_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_B4 {
+        Nocycle_a_00070_C1 c1_0;
+        Nocycle_a_00070_C2 c2_0;
+        Nocycle_a_00070_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class Nocycle_a_00070_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00070 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00070 A1_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A2_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A3_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A4_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A5_00070 = new ThreadRc_00070();
+        ThreadRc_00070 A6_00070 = new ThreadRc_00070();
+        A1_00070.start();
+        A2_00070.start();
+        A3_00070.start();
+        A4_00070.start();
+        A5_00070.start();
+        A6_00070.start();
+        try {
+            A1_00070.join();
+            A2_00070.join();
+            A3_00070.join();
+            A4_00070.join();
+            A5_00070.join();
+            A6_00070.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00070.check() && A2_00070.check() && A3_00070.check() && A4_00070.check() && A5_00070.check() && A6_00070.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/expected.txt b/testsuite/java_test/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/test.cfg b/testsuite/java_test/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b0555b9cc77644b91e916e6cd45431ac5e285e8d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0212-rc-function-RC_Thread01-Nocycle_am_00070/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00070)
+run(Nocycle_am_00070,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/Nocycle_am_00080.java b/testsuite/java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/Nocycle_am_00080.java
new file mode 100755
index 0000000000000000000000000000000000000000..d5fbe4250c271088b55db0a9eb6046744cff6c57
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/Nocycle_am_00080.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00080 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00080_A1 a1_main = new Nocycle_a_00080_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00080_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00080_C1("c1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum;
+        //System.out.println("RC-Testing_Result_Thread1="+result);
+        if (result == 1406)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00080_A1 {
+        Nocycle_a_00080_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00080_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00080_B1 {
+        Nocycle_a_00080_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00080_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00080_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00080_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00080 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00080 A1_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A2_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A3_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A4_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A5_00080 = new ThreadRc_00080();
+        ThreadRc_00080 A6_00080 = new ThreadRc_00080();
+        A1_00080.start();
+        A2_00080.start();
+        A3_00080.start();
+        A4_00080.start();
+        A5_00080.start();
+        A6_00080.start();
+        try {
+            A1_00080.join();
+            A2_00080.join();
+            A3_00080.join();
+            A4_00080.join();
+            A5_00080.join();
+            A6_00080.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00080.check() && A2_00080.check() && A3_00080.check() && A4_00080.check() && A5_00080.check() && A6_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/expected.txt b/testsuite/java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/test.cfg b/testsuite/java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..976e1f30360082ba85f4334c40c6c548a113a036
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0213-rc-function-RC_Thread01-Nocycle_am_00080/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00080)
+run(Nocycle_am_00080,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/Nocycle_am_00090.java b/testsuite/java_test/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/Nocycle_am_00090.java
new file mode 100755
index 0000000000000000000000000000000000000000..37b0f6a62c4cdfb944972177eb813dc7aed6a2d3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/Nocycle_am_00090.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00090 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00090_A1 a1_main = new Nocycle_a_00090_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00090_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00090_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00090_D1("d1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2308)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00090_A1 {
+        Nocycle_a_00090_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00090_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00090_B1 {
+        Nocycle_a_00090_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00090_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00090_C1 {
+        Nocycle_a_00090_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00090_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00090_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00090_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00090 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00090 A1_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A2_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A3_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A4_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A5_00090 = new ThreadRc_00090();
+        ThreadRc_00090 A6_00090 = new ThreadRc_00090();
+        A1_00090.start();
+        A2_00090.start();
+        A3_00090.start();
+        A4_00090.start();
+        A5_00090.start();
+        A6_00090.start();
+        try {
+            A1_00090.join();
+            A2_00090.join();
+            A3_00090.join();
+            A4_00090.join();
+            A5_00090.join();
+            A6_00090.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00090.check() && A2_00090.check() && A3_00090.check() && A4_00090.check() && A5_00090.check() && A6_00090.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/expected.txt b/testsuite/java_test/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/test.cfg b/testsuite/java_test/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d86abfc86fc0daa75c9917b1eb1e300e149f9372
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0214-rc-function-RC_Thread01-Nocycle_am_00090/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00090)
+run(Nocycle_am_00090,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/Nocycle_am_00100.java b/testsuite/java_test/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/Nocycle_am_00100.java
new file mode 100755
index 0000000000000000000000000000000000000000..df1619ec3e46f40681ccaccc5ea6f9d10d323454
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/Nocycle_am_00100.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00100 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00100_A1 a1_main = new Nocycle_a_00100_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00100_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00100_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00100_D1("d1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_00100_E1("e1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_00100_F1("f1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_00100_G1("g1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_00100_H1("h1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_00100_I1("i1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_00100_J1("j1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+//		 System.out.printf("a=%d\n",a1_main.sum);
+//		 System.out.printf("b=%d\n",a1_main.b1_0.sum);
+//		 System.out.printf("c=%d\n",a1_main.b1_0.c1_0.sum);
+//		 System.out.printf("d=%d\n",a1_main.b1_0.c1_0.d1_0.sum);
+//		 System.out.printf("e=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.sum);
+//		 System.out.printf("f=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum);
+//		 System.out.printf("g=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum);
+//		 System.out.printf("h=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum);
+//		 System.out.printf("i=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum);
+//		 System.out.printf("j=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 11920)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00100_A1 {
+        Nocycle_a_00100_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00100_B1 {
+        Nocycle_a_00100_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00100_C1 {
+        Nocycle_a_00100_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00100_D1 {
+        Nocycle_a_00100_E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+    class Nocycle_a_00100_E1 {
+        Nocycle_a_00100_F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+    class Nocycle_a_00100_F1 {
+        Nocycle_a_00100_G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+    class Nocycle_a_00100_G1 {
+        Nocycle_a_00100_H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+    class Nocycle_a_00100_H1 {
+        Nocycle_a_00100_I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+    class Nocycle_a_00100_I1 {
+        Nocycle_a_00100_J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+    class Nocycle_a_00100_J1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00100 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00100 A1_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A2_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A3_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A4_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A5_00100 = new ThreadRc_00100();
+        ThreadRc_00100 A6_00100 = new ThreadRc_00100();
+        A1_00100.start();
+        A2_00100.start();
+        A3_00100.start();
+        A4_00100.start();
+        A5_00100.start();
+        A6_00100.start();
+        try {
+            A1_00100.join();
+            A2_00100.join();
+            A3_00100.join();
+            A4_00100.join();
+            A5_00100.join();
+            A6_00100.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00100.check() && A2_00100.check() && A3_00100.check() && A4_00100.check() && A5_00100.check() && A6_00100.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/expected.txt b/testsuite/java_test/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/test.cfg b/testsuite/java_test/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f6c69af6b404c5c0fc25c3167bdbc90afecb14d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0215-rc-function-RC_Thread01-Nocycle_am_00100/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00100)
+run(Nocycle_am_00100,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/Nocycle_am_00110.java b/testsuite/java_test/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/Nocycle_am_00110.java
new file mode 100755
index 0000000000000000000000000000000000000000..2cbc03aa6cf956ffcfdd32b87dc7191180bca1b2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/Nocycle_am_00110.java
@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00110 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00110_A1 a1_main = new Nocycle_a_00110_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00110_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00110_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00110_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00110_B4("b4_0");
+        a1_main.b1_0.d1_0 = new Nocycle_a_00110_D1("d1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00110_C2("c2_0");
+        a1_main.b3_0.c1_0 = new Nocycle_a_00110_C1("c1_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00110_C3("c3_0");
+        a1_main.b3_0.c1_0.d2_0 = new Nocycle_a_00110_D2("d2_0");
+        a1_main.b2_0.c2_0.d3_0 = new Nocycle_a_00110_D3("d3_0");
+        a1_main.b2_0.c2_0.d4_0 = new Nocycle_a_00110_D4("d4_0");
+        a1_main.d5_0 = new Nocycle_a_00110_D5("d5_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b3_0.c1_0.add();
+        a1_main.b4_0.c3_0.add();
+        a1_main.b1_0.d1_0.add();
+        a1_main.b3_0.c1_0.d2_0.add();
+        a1_main.b2_0.c2_0.d3_0.add();
+        a1_main.b2_0.c2_0.d4_0.add();
+        a1_main.d5_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b3_0.c1_0.sum+a1_main.b4_0.c3_0.sum+a1_main.b1_0.d1_0.sum+a1_main.b3_0.c1_0.d2_0.sum+a1_main.b2_0.c2_0.d3_0.sum+a1_main.b2_0.c2_0.d4_0.sum+a1_main.d5_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b3_0.c1_0.sum + a1_main.b4_0.c3_0.sum + a1_main.b1_0.d1_0.sum + a1_main.b3_0.c1_0.d2_0.sum + a1_main.b2_0.c2_0.d3_0.sum + a1_main.b2_0.c2_0.d4_0.sum + a1_main.d5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 9881)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00110_A1 {
+        Nocycle_a_00110_B1 b1_0;
+        Nocycle_a_00110_B2 b2_0;
+        Nocycle_a_00110_B3 b3_0;
+        Nocycle_a_00110_B4 b4_0;
+        Nocycle_a_00110_D5 d5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            d5_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + d5_0.a;
+        }
+    }
+    class Nocycle_a_00110_B1 {
+        Nocycle_a_00110_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00110_B2 {
+        Nocycle_a_00110_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_B2(String strObjectName) {
+            c2_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c2_0.a;
+        }
+    }
+    class Nocycle_a_00110_B3 {
+        Nocycle_a_00110_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00110_B4 {
+        Nocycle_a_00110_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_B4(String strObjectName) {
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + c3_0.a;
+        }
+    }
+    class Nocycle_a_00110_C1 {
+        Nocycle_a_00110_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_C1(String strObjectName) {
+            d2_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class Nocycle_a_00110_C2 {
+        Nocycle_a_00110_D3 d3_0;
+        Nocycle_a_00110_D4 d4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_C2(String strObjectName) {
+            d3_0 = null;
+            d4_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d3_0.a + d4_0.a;
+        }
+    }
+    class Nocycle_a_00110_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D4 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D4(String strObjectName) {
+            a = 404;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D5 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D5(String strObjectName) {
+            a = 405;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00110 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00110 A1_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A2_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A3_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A4_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A5_00110 = new ThreadRc_00110();
+        ThreadRc_00110 A6_00110 = new ThreadRc_00110();
+        A1_00110.start();
+        A2_00110.start();
+        A3_00110.start();
+        A4_00110.start();
+        A5_00110.start();
+        A6_00110.start();
+        try {
+            A1_00110.join();
+            A2_00110.join();
+            A3_00110.join();
+            A4_00110.join();
+            A5_00110.join();
+            A6_00110.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00110.check() && A2_00110.check() && A3_00110.check() && A4_00110.check() && A5_00110.check() && A6_00110.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/expected.txt b/testsuite/java_test/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/test.cfg b/testsuite/java_test/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..96afd853b15e011936bc4027c082ced3cc31bf25
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0216-rc-function-RC_Thread01-Nocycle_am_00110/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00110)
+run(Nocycle_am_00110,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/Nocycle_am_00120.java b/testsuite/java_test/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/Nocycle_am_00120.java
new file mode 100755
index 0000000000000000000000000000000000000000..24083edb4b6bd9da23ea1d61958fc509e1bf1581
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/Nocycle_am_00120.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00120 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00120_A1 a1_main = new Nocycle_a_00120_A1("a1_main");
+        Nocycle_a_00120_A2 a2_main = new Nocycle_a_00120_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1007)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00120_A1 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00120_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00120_A2 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00120_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00120_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00120_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00120 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00120 A1_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A2_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A3_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A4_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A5_00120 = new ThreadRc_00120();
+        ThreadRc_00120 A6_00120 = new ThreadRc_00120();
+        A1_00120.start();
+        A2_00120.start();
+        A3_00120.start();
+        A4_00120.start();
+        A5_00120.start();
+        A6_00120.start();
+        try {
+            A1_00120.join();
+            A2_00120.join();
+            A3_00120.join();
+            A4_00120.join();
+            A5_00120.join();
+            A6_00120.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00120.check() && A2_00120.check() && A3_00120.check() && A4_00120.check() && A5_00120.check() && A6_00120.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/expected.txt b/testsuite/java_test/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/test.cfg b/testsuite/java_test/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b8ae15a96af849143e7f072d1c9d5964b4b56a0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0217-rc-function-RC_Thread01-Nocycle_am_00120/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00120)
+run(Nocycle_am_00120,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/Nocycle_am_00130.java b/testsuite/java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/Nocycle_am_00130.java
new file mode 100755
index 0000000000000000000000000000000000000000..006cfaef45a66b2e7d654ccd995f5fe06ee87c0d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/Nocycle_am_00130.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00130 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00130_A1 a1_main = new Nocycle_a_00130_A1("a1_main");
+        Nocycle_a_00130_A2 a2_main = new Nocycle_a_00130_A2("a2_main");
+        Nocycle_a_00130_A3 a3_main = new Nocycle_a_00130_A3("a3_main");
+        Nocycle_a_00130_A4 a4_main = new Nocycle_a_00130_A4("a4_main");
+        Nocycle_a_00130_A5 a5_main = new Nocycle_a_00130_A5("a5_main");
+        Nocycle_a_00130_A6 a6_main = new Nocycle_a_00130_A6("a6_main");
+        Nocycle_a_00130_A7 a7_main = new Nocycle_a_00130_A7("a7_main");
+        Nocycle_a_00130_A8 a8_main = new Nocycle_a_00130_A8("a8_main");
+        Nocycle_a_00130_A9 a9_main = new Nocycle_a_00130_A9("a9_main");
+        Nocycle_a_00130_A10 a10_main = new Nocycle_a_00130_A10("a10_main");
+        a1_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a3_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a4_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a5_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a6_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a7_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a8_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a9_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a10_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        a3_main.b1_0.add();
+        a4_main.b1_0.add();
+        a5_main.b1_0.add();
+        a6_main.b1_0.add();
+        a7_main.b1_0.add();
+        a8_main.b1_0.add();
+        a9_main.b1_0.add();
+        a10_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a5_main.sum+a6_main.sum+a7_main.sum+a8_main.sum+a9_main.sum+a10_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 3467)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00130_A1 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A2 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A3 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A3(String strObjectName) {
+            b1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A4 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A4(String strObjectName) {
+            b1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A5 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A5(String strObjectName) {
+            b1_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A6 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A6(String strObjectName) {
+            b1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A7 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A7(String strObjectName) {
+            b1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A8 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A8(String strObjectName) {
+            b1_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A9 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A9(String strObjectName) {
+            b1_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A10 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A10(String strObjectName) {
+            b1_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00130 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00130 A1_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A2_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A3_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A4_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A5_00130 = new ThreadRc_00130();
+        ThreadRc_00130 A6_00130 = new ThreadRc_00130();
+        A1_00130.start();
+        A2_00130.start();
+        A3_00130.start();
+        A4_00130.start();
+        A5_00130.start();
+        A6_00130.start();
+        try {
+            A1_00130.join();
+            A2_00130.join();
+            A3_00130.join();
+            A4_00130.join();
+            A5_00130.join();
+            A6_00130.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00130.check() && A2_00130.check() && A3_00130.check() && A4_00130.check() && A5_00130.check() && A6_00130.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/expected.txt b/testsuite/java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/test.cfg b/testsuite/java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5ec04bfe0c34ad5df0bcac1983e940a052397b15
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0218-rc-function-RC_Thread01-Nocycle_am_00130/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00130)
+run(Nocycle_am_00130,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/Nocycle_am_00140.java b/testsuite/java_test/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/Nocycle_am_00140.java
new file mode 100755
index 0000000000000000000000000000000000000000..a61a8652a975fcdf5f3ed55156c1bf942dfd4aa3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/Nocycle_am_00140.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00140 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00140_A1 a1_main = new Nocycle_a_00140_A1("a1_main");
+        Nocycle_a_00140_A2 a2_main = new Nocycle_a_00140_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00140_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1613)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00140_A1 {
+        Nocycle_a_00140_B1 b1_0;
+        Nocycle_a_00140_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00140_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00140_A2 {
+        Nocycle_a_00140_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00140_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00140_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00140_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00140_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00140_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00140 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00140 A1_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A2_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A3_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A4_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A5_00140 = new ThreadRc_00140();
+        ThreadRc_00140 A6_00140 = new ThreadRc_00140();
+        A1_00140.start();
+        A2_00140.start();
+        A3_00140.start();
+        A4_00140.start();
+        A5_00140.start();
+        A6_00140.start();
+        try {
+            A1_00140.join();
+            A2_00140.join();
+            A3_00140.join();
+            A4_00140.join();
+            A5_00140.join();
+            A6_00140.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00140.check() && A2_00140.check() && A3_00140.check() && A4_00140.check() && A5_00140.check() && A6_00140.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/expected.txt b/testsuite/java_test/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/test.cfg b/testsuite/java_test/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..63ef8574e337ab70e4958098f0a302642d161029
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0219-rc-function-RC_Thread01-Nocycle_am_00140/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00140)
+run(Nocycle_am_00140,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/Nocycle_am_00150.java b/testsuite/java_test/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/Nocycle_am_00150.java
new file mode 100755
index 0000000000000000000000000000000000000000..5cc1f34024975cbfab7187f77a58d1c7a478076a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/Nocycle_am_00150.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00150 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00150_A1 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00150_A2 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00150_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00150_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00150 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00150 A1_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A2_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A3_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A4_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A5_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A6_00150 = new ThreadRc_00150();
+        A1_00150.start();
+        A2_00150.start();
+        A3_00150.start();
+        A4_00150.start();
+        A5_00150.start();
+        A6_00150.start();
+        try {
+            A1_00150.join();
+            A2_00150.join();
+            A3_00150.join();
+            A4_00150.join();
+            A5_00150.join();
+            A6_00150.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00150.check() && A2_00150.check() && A3_00150.check() && A4_00150.check() && A5_00150.check() && A6_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/expected.txt b/testsuite/java_test/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/test.cfg b/testsuite/java_test/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc222c144476d96791d3f7d19ea9367d46a9115a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0220-rc-function-RC_Thread01-Nocycle_am_00150/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00150)
+run(Nocycle_am_00150,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/Nocycle_am_00160.java b/testsuite/java_test/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/Nocycle_am_00160.java
new file mode 100755
index 0000000000000000000000000000000000000000..87a771127917afadb9609cc7a9ad00162ad488df
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/Nocycle_am_00160.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00160 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00160_A1 a1_main = new Nocycle_a_00160_A1("a1_main");
+        Nocycle_a_00160_A2 a2_main = new Nocycle_a_00160_A2("a2_main");
+        Nocycle_a_00160_A3 a3_main = new Nocycle_a_00160_A3("a3_main");
+        Nocycle_a_00160_A4 a4_main = new Nocycle_a_00160_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a3_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a4_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2828)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00160_A1 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00160_A2 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00160_A3 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00160_A4 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00160_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00160_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00160 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00160 A1_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A2_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A3_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A4_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A5_00160 = new ThreadRc_00160();
+        ThreadRc_00160 A6_00160 = new ThreadRc_00160();
+        A1_00160.start();
+        A2_00160.start();
+        A3_00160.start();
+        A4_00160.start();
+        A5_00160.start();
+        A6_00160.start();
+        try {
+            A1_00160.join();
+            A2_00160.join();
+            A3_00160.join();
+            A4_00160.join();
+            A5_00160.join();
+            A6_00160.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00160.check() && A2_00160.check() && A3_00160.check() && A4_00160.check() && A5_00160.check() && A6_00160.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/expected.txt b/testsuite/java_test/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/test.cfg b/testsuite/java_test/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0d1d7dea2aeb85f10692052951636e2a321e7dfe
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0221-rc-function-RC_Thread01-Nocycle_am_00160/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00160)
+run(Nocycle_am_00160,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/Nocycle_am_00170.java b/testsuite/java_test/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/Nocycle_am_00170.java
new file mode 100755
index 0000000000000000000000000000000000000000..6613f20414c8fedb95273f583f6add03057c7e04
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/Nocycle_am_00170.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00170 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00170_A1 a1_main = new Nocycle_a_00170_A1("a1_main");
+        Nocycle_a_00170_A2 a2_main = new Nocycle_a_00170_A2("a2_main");
+        Nocycle_a_00170_A3 a3_main = new Nocycle_a_00170_A3("a3_main");
+        Nocycle_a_00170_A4 a4_main = new Nocycle_a_00170_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a2_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a2_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a3_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a3_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a4_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a4_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a2_main.b3_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b3_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        a4_main.b3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 4046)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00170_A1 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00170_A2 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00170_A3 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00170_A4 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00170_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00170_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00170_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00170 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00170 A1_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A2_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A3_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A4_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A5_00170 = new ThreadRc_00170();
+        ThreadRc_00170 A6_00170 = new ThreadRc_00170();
+        A1_00170.start();
+        A2_00170.start();
+        A3_00170.start();
+        A4_00170.start();
+        A5_00170.start();
+        A6_00170.start();
+        try {
+            A1_00170.join();
+            A2_00170.join();
+            A3_00170.join();
+            A4_00170.join();
+            A5_00170.join();
+            A6_00170.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00170.check() && A2_00170.check() && A3_00170.check() && A4_00170.check() && A5_00170.check() && A6_00170.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/expected.txt b/testsuite/java_test/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/test.cfg b/testsuite/java_test/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2fce8ba95f33d8175cb390fc8c7f005bdbff73b1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0222-rc-function-RC_Thread01-Nocycle_am_00170/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00170)
+run(Nocycle_am_00170,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/Nocycle_am_00180.java b/testsuite/java_test/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/Nocycle_am_00180.java
new file mode 100755
index 0000000000000000000000000000000000000000..2cb5802f3230cd712799c466856ef0fd5698f34a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/Nocycle_am_00180.java
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00180 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+//		 System.out.printf("a1_main.sum=%d\n",a1_main.sum);
+//		 System.out.printf("a2_main.sum=%d\n",a2_main.sum);
+//		 System.out.printf("a3_main.sum=%d\n",a3_main.sum);
+//		 System.out.printf("a4_main.sum=%d\n",a4_main.sum);
+//		 System.out.printf("a1_main.b1_0.sum=%d\n",a1_main.b1_0.sum);
+//		 System.out.printf("a2_main.b2_0.sum=%d\n",a2_main.b2_0.sum);
+//		 System.out.printf("a4_main.b3_0.sum=%d\n",a4_main.b3_0.sum);
+//		 System.out.printf("a2_main.b2_0.c1_0.sum=%d\n",a2_main.b2_0.c1_0.sum);
+//		 System.out.printf("a3_main.c2_0.sum=%d\n",a3_main.c2_0.sum);
+//		 System.out.printf("a1_main.d1_0.sum=%d\n",a1_main.d1_0.sum);
+//		 System.out.printf("a3_main.c2_0.d2_0.sum=%d\n",a3_main.c2_0.d2_0.sum);
+//		 System.out.printf("a3_main.c2_0.d3_0.sum=%d\n",a3_main.c2_0.d3_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a2_main.b2_0.sum+a4_main.b3_0.sum+a2_main.b2_0.c1_0.sum+a3_main.c2_0.sum+a1_main.d1_0.sum+a3_main.c2_0.d2_0.sum+a3_main.c2_0.d3_0.sum);
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 9260)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00180_A1 {
+        Nocycle_a_00180_B1 b1_0;
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00180_A2 {
+        Nocycle_a_00180_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00180_A3 {
+        Nocycle_a_00180_B2 b2_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_00180_A4 {
+        Nocycle_a_00180_B3 b3_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_00180_B1 {
+        Nocycle_a_00180_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class Nocycle_a_00180_B2 {
+        Nocycle_a_00180_C1 c1_0;
+        Nocycle_a_00180_D1 d1_0;
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_00180_B3 {
+        Nocycle_a_00180_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00180_C1 {
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00180_C2 {
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_00180_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00180_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00180_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00180 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00180 A1_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A2_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A3_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A4_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A5_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A6_00180 = new ThreadRc_00180();
+        A1_00180.start();
+        A2_00180.start();
+        A3_00180.start();
+        A4_00180.start();
+        A5_00180.start();
+        A6_00180.start();
+        try {
+            A1_00180.join();
+            A2_00180.join();
+            A3_00180.join();
+            A4_00180.join();
+            A5_00180.join();
+            A6_00180.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00180.check() && A2_00180.check() && A3_00180.check() && A4_00180.check() && A5_00180.check() && A6_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/expected.txt b/testsuite/java_test/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/test.cfg b/testsuite/java_test/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3914253f44a10384a20cbe05ab99c7acb707d8bd
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0223-rc-function-RC_Thread01-Nocycle_am_00180/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00180)
+run(Nocycle_am_00180,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/Nocycle_am_00190.java b/testsuite/java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/Nocycle_am_00190.java
new file mode 100755
index 0000000000000000000000000000000000000000..aef94bb0abd7954a2a87c3185f280bc97a5261a9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/Nocycle_am_00190.java
@@ -0,0 +1,2676 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_00010B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_am_00010_A1 a1_main = new Nocycle_am_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_am_00010_B1("b1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 704)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_am_00010_A1 {
+        Nocycle_am_00010_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_am_00010_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_A1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_am_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_am_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        //   protected void finalize() throws java.lang.Throwable {
+//       System.out.println("RC-Testing_Destruction_B1_"+strObjectName);
+//   }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00020B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00020_A1 a1_main = new Nocycle_a_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00020_B2("b2_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1310)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00020_A1 {
+        Nocycle_a_00020_B1 b1_0;
+        Nocycle_a_00020_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00030B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00030_A1 a1_main = new Nocycle_a_00030_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00030_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00030_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00030_B3("b3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1919)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00030_A1 {
+        Nocycle_a_00030_B1 b1_0;
+        Nocycle_a_00030_B2 b2_0;
+        Nocycle_a_00030_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00030_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00030_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00030_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00030_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00030_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00030_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00030_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00040B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00040_A1 a1_main = new Nocycle_a_00040_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00040_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00040_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00040_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00040_B4("b4_0");
+        a1_main.b5_0 = new Nocycle_a_00040_B5("b5_0");
+        a1_main.b6_0 = new Nocycle_a_00040_B6("b6_0");
+        a1_main.b7_0 = new Nocycle_a_00040_B7("b7_0");
+        a1_main.b8_0 = new Nocycle_a_00040_B8("b8_0");
+        a1_main.b9_0 = new Nocycle_a_00040_B9("b9_0");
+        a1_main.b10_0 = new Nocycle_a_00040_B10("b10_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b5_0.add();
+        a1_main.b6_0.add();
+        a1_main.b7_0.add();
+        a1_main.b8_0.add();
+        a1_main.b9_0.add();
+        a1_main.b10_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b5_0.sum+a1_main.b6_0.sum+a1_main.b7_0.sum+a1_main.b8_0.sum+a1_main.b9_0.sum+a1_main.b10_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b5_0.sum + a1_main.b6_0.sum + a1_main.b7_0.sum + a1_main.b8_0.sum + a1_main.b9_0.sum + a1_main.b10_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 6266)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00040_A1 {
+        Nocycle_a_00040_B1 b1_0;
+        Nocycle_a_00040_B2 b2_0;
+        Nocycle_a_00040_B3 b3_0;
+        Nocycle_a_00040_B4 b4_0;
+        Nocycle_a_00040_B5 b5_0;
+        Nocycle_a_00040_B6 b6_0;
+        Nocycle_a_00040_B7 b7_0;
+        Nocycle_a_00040_B8 b8_0;
+        Nocycle_a_00040_B9 b9_0;
+        Nocycle_a_00040_B10 b10_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            b5_0 = null;
+            b6_0 = null;
+            b7_0 = null;
+            b8_0 = null;
+            b9_0 = null;
+            b10_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + b5_0.a + b6_0.a + b7_0.a + b8_0.a + b9_0.a + b10_0.a;
+        }
+    }
+    class Nocycle_a_00040_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B5 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B5(String strObjectName) {
+            a = 205;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B6 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B6(String strObjectName) {
+            a = 206;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B7 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B7(String strObjectName) {
+            a = 207;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B8 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B8(String strObjectName) {
+            a = 208;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B9 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B9(String strObjectName) {
+            a = 209;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00040_B10 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00040_B10(String strObjectName) {
+            a = 210;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B10_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00050B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00050_A1 a1_main = new Nocycle_a_00050_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00050_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00050_C1("c1_0");
+        a1_main.b1_0.c2_0 = new Nocycle_a_00050_C2("c2_0");
+        a1_main.b1_0.c3_0 = new Nocycle_a_00050_C3("c3_0");
+        a1_main.b2_0 = new Nocycle_a_00050_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00050_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00050_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c2_0.add();
+        a1_main.b1_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c2_0.sum+a1_main.b1_0.c3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c2_0.sum + a1_main.b1_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5048)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00050_A1 {
+        Nocycle_a_00050_B1 b1_0;
+        Nocycle_a_00050_B2 b2_0;
+        Nocycle_a_00050_B3 b3_0;
+        Nocycle_a_00050_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class Nocycle_a_00050_B1 {
+        Nocycle_a_00050_C1 c1_0;
+        Nocycle_a_00050_C2 c2_0;
+        Nocycle_a_00050_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class Nocycle_a_00050_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00050_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00050_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00060B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00060_A1 a1_main = new Nocycle_a_00060_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00060_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00060_B2("b2_0");
+        a1_main.b2_0.c1_0 = new Nocycle_a_00060_C1("c1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00060_C2("c2_0");
+        a1_main.b2_0.c3_0 = new Nocycle_a_00060_C3("c3_0");
+        a1_main.b3_0 = new Nocycle_a_00060_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00060_B4("b4_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c1_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b2_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c1_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b2_0.c3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c1_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b2_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5047)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00060_A1 {
+        Nocycle_a_00060_B1 b1_0;
+        Nocycle_a_00060_B2 b2_0;
+        Nocycle_a_00060_B3 b3_0;
+        Nocycle_a_00060_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class Nocycle_a_00060_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_B2 {
+        Nocycle_a_00060_C1 c1_0;
+        Nocycle_a_00060_C2 c2_0;
+        Nocycle_a_00060_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_B2(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class Nocycle_a_00060_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00060_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00060_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00070B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00070_A1 a1_main = new Nocycle_a_00070_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00070_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00070_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00070_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00070_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_00070_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_00070_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00070_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 5045)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00070_A1 {
+        Nocycle_a_00070_B1 b1_0;
+        Nocycle_a_00070_B2 b2_0;
+        Nocycle_a_00070_B3 b3_0;
+        Nocycle_a_00070_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class Nocycle_a_00070_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_B4 {
+        Nocycle_a_00070_C1 c1_0;
+        Nocycle_a_00070_C2 c2_0;
+        Nocycle_a_00070_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class Nocycle_a_00070_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00070_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00070_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00080B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00080_A1 a1_main = new Nocycle_a_00080_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00080_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00080_C1("c1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1406)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00080_A1 {
+        Nocycle_a_00080_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00080_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00080_B1 {
+        Nocycle_a_00080_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00080_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00080_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00080_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00090B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00090_A1 a1_main = new Nocycle_a_00090_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00090_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00090_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00090_D1("d1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2308)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00090_A1 {
+        Nocycle_a_00090_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00090_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00090_B1 {
+        Nocycle_a_00090_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00090_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00090_C1 {
+        Nocycle_a_00090_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00090_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00090_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00090_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00100B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00100_A1 a1_main = new Nocycle_a_00100_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00100_B1("b1_0");
+        a1_main.b1_0.c1_0 = new Nocycle_a_00100_C1("c1_0");
+        a1_main.b1_0.c1_0.d1_0 = new Nocycle_a_00100_D1("d1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_00100_E1("e1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_00100_F1("f1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_00100_G1("g1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_00100_H1("h1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_00100_I1("i1_0");
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_00100_J1("j1_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b1_0.c1_0.add();
+        a1_main.b1_0.c1_0.d1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+//		 System.out.printf("a=%d\n",a1_main.sum);
+//		 System.out.printf("b=%d\n",a1_main.b1_0.sum);
+//		 System.out.printf("c=%d\n",a1_main.b1_0.c1_0.sum);
+//		 System.out.printf("d=%d\n",a1_main.b1_0.c1_0.d1_0.sum);
+//		 System.out.printf("e=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.sum);
+//		 System.out.printf("f=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum);
+//		 System.out.printf("g=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum);
+//		 System.out.printf("h=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum);
+//		 System.out.printf("i=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum);
+//		 System.out.printf("j=%d\n",a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b1_0.c1_0.sum+a1_main.b1_0.c1_0.d1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum+a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b1_0.c1_0.sum + a1_main.b1_0.c1_0.d1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 11920)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00100_A1 {
+        Nocycle_a_00100_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00100_B1 {
+        Nocycle_a_00100_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00100_C1 {
+        Nocycle_a_00100_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00100_D1 {
+        Nocycle_a_00100_E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+    class Nocycle_a_00100_E1 {
+        Nocycle_a_00100_F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+    class Nocycle_a_00100_F1 {
+        Nocycle_a_00100_G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+    class Nocycle_a_00100_G1 {
+        Nocycle_a_00100_H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+    class Nocycle_a_00100_H1 {
+        Nocycle_a_00100_I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+    class Nocycle_a_00100_I1 {
+        Nocycle_a_00100_J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+    class Nocycle_a_00100_J1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00100_J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00110B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00110_A1 a1_main = new Nocycle_a_00110_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_00110_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00110_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00110_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_00110_B4("b4_0");
+        a1_main.b1_0.d1_0 = new Nocycle_a_00110_D1("d1_0");
+        a1_main.b2_0.c2_0 = new Nocycle_a_00110_C2("c2_0");
+        a1_main.b3_0.c1_0 = new Nocycle_a_00110_C1("c1_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_00110_C3("c3_0");
+        a1_main.b3_0.c1_0.d2_0 = new Nocycle_a_00110_D2("d2_0");
+        a1_main.b2_0.c2_0.d3_0 = new Nocycle_a_00110_D3("d3_0");
+        a1_main.b2_0.c2_0.d4_0 = new Nocycle_a_00110_D4("d4_0");
+        a1_main.d5_0 = new Nocycle_a_00110_D5("d5_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b2_0.c2_0.add();
+        a1_main.b3_0.c1_0.add();
+        a1_main.b4_0.c3_0.add();
+        a1_main.b1_0.d1_0.add();
+        a1_main.b3_0.c1_0.d2_0.add();
+        a1_main.b2_0.c2_0.d3_0.add();
+        a1_main.b2_0.c2_0.d4_0.add();
+        a1_main.d5_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b2_0.c2_0.sum+a1_main.b3_0.c1_0.sum+a1_main.b4_0.c3_0.sum+a1_main.b1_0.d1_0.sum+a1_main.b3_0.c1_0.d2_0.sum+a1_main.b2_0.c2_0.d3_0.sum+a1_main.b2_0.c2_0.d4_0.sum+a1_main.d5_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b2_0.c2_0.sum + a1_main.b3_0.c1_0.sum + a1_main.b4_0.c3_0.sum + a1_main.b1_0.d1_0.sum + a1_main.b3_0.c1_0.d2_0.sum + a1_main.b2_0.c2_0.d3_0.sum + a1_main.b2_0.c2_0.d4_0.sum + a1_main.d5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 9881)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00110_A1 {
+        Nocycle_a_00110_B1 b1_0;
+        Nocycle_a_00110_B2 b2_0;
+        Nocycle_a_00110_B3 b3_0;
+        Nocycle_a_00110_B4 b4_0;
+        Nocycle_a_00110_D5 d5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            d5_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a + d5_0.a;
+        }
+    }
+    class Nocycle_a_00110_B1 {
+        Nocycle_a_00110_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00110_B2 {
+        Nocycle_a_00110_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_B2(String strObjectName) {
+            c2_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c2_0.a;
+        }
+    }
+    class Nocycle_a_00110_B3 {
+        Nocycle_a_00110_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00110_B4 {
+        Nocycle_a_00110_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_B4(String strObjectName) {
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + c3_0.a;
+        }
+    }
+    class Nocycle_a_00110_C1 {
+        Nocycle_a_00110_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_C1(String strObjectName) {
+            d2_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class Nocycle_a_00110_C2 {
+        Nocycle_a_00110_D3 d3_0;
+        Nocycle_a_00110_D4 d4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_C2(String strObjectName) {
+            d3_0 = null;
+            d4_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d3_0.a + d4_0.a;
+        }
+    }
+    class Nocycle_a_00110_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D4 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D4(String strObjectName) {
+            a = 404;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00110_D5 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00110_D5(String strObjectName) {
+            a = 405;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00120B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00120_A1 a1_main = new Nocycle_a_00120_A1("a1_main");
+        Nocycle_a_00120_A2 a2_main = new Nocycle_a_00120_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00120_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1007)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00120_A1 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00120_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00120_A2 {
+        Nocycle_a_00120_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00120_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00120_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00120_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00130B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00130_A1 a1_main = new Nocycle_a_00130_A1("a1_main");
+        Nocycle_a_00130_A2 a2_main = new Nocycle_a_00130_A2("a2_main");
+        Nocycle_a_00130_A3 a3_main = new Nocycle_a_00130_A3("a3_main");
+        Nocycle_a_00130_A4 a4_main = new Nocycle_a_00130_A4("a4_main");
+        Nocycle_a_00130_A5 a5_main = new Nocycle_a_00130_A5("a5_main");
+        Nocycle_a_00130_A6 a6_main = new Nocycle_a_00130_A6("a6_main");
+        Nocycle_a_00130_A7 a7_main = new Nocycle_a_00130_A7("a7_main");
+        Nocycle_a_00130_A8 a8_main = new Nocycle_a_00130_A8("a8_main");
+        Nocycle_a_00130_A9 a9_main = new Nocycle_a_00130_A9("a9_main");
+        Nocycle_a_00130_A10 a10_main = new Nocycle_a_00130_A10("a10_main");
+        a1_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a2_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a3_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a4_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a5_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a6_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a7_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a8_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a9_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a10_main.b1_0 = new Nocycle_a_00130_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        a1_main.b1_0.add();
+        a2_main.b1_0.add();
+        a3_main.b1_0.add();
+        a4_main.b1_0.add();
+        a5_main.b1_0.add();
+        a6_main.b1_0.add();
+        a7_main.b1_0.add();
+        a8_main.b1_0.add();
+        a9_main.b1_0.add();
+        a10_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a5_main.sum+a6_main.sum+a7_main.sum+a8_main.sum+a9_main.sum+a10_main.sum+a1_main.b1_0.sum);
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + a1_main.b1_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 3467)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00130_A1 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A2 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A3 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A3(String strObjectName) {
+            b1_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A4 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A4(String strObjectName) {
+            b1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A5 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A5(String strObjectName) {
+            b1_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A6 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A6(String strObjectName) {
+            b1_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A7 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A7(String strObjectName) {
+            b1_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A8 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A8(String strObjectName) {
+            b1_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A9 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A9(String strObjectName) {
+            b1_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_A10 {
+        Nocycle_a_00130_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_A10(String strObjectName) {
+            b1_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00130_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00130_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00140B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00140_A1 a1_main = new Nocycle_a_00140_A1("a1_main");
+        Nocycle_a_00140_A2 a2_main = new Nocycle_a_00140_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00140_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00140_B1("b1_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1613)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00140_A1 {
+        Nocycle_a_00140_B1 b1_0;
+        Nocycle_a_00140_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00140_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00140_A2 {
+        Nocycle_a_00140_B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00140_A2(String strObjectName) {
+            b1_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_00140_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00140_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00140_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00140_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00150B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00150_A1 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00150_A2 {
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00150_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00150_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00160B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00160_A1 a1_main = new Nocycle_a_00160_A1("a1_main");
+        Nocycle_a_00160_A2 a2_main = new Nocycle_a_00160_A2("a2_main");
+        Nocycle_a_00160_A3 a3_main = new Nocycle_a_00160_A3("a3_main");
+        Nocycle_a_00160_A4 a4_main = new Nocycle_a_00160_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a2_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a3_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a4_main.b1_0 = new Nocycle_a_00160_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00160_B2("b2_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 2828)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00160_A1 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00160_A2 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00160_A3 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00160_A4 {
+        Nocycle_a_00160_B1 b1_0;
+        Nocycle_a_00160_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00160_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00160_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00160_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00170B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00170_A1 a1_main = new Nocycle_a_00170_A1("a1_main");
+        Nocycle_a_00170_A2 a2_main = new Nocycle_a_00170_A2("a2_main");
+        Nocycle_a_00170_A3 a3_main = new Nocycle_a_00170_A3("a3_main");
+        Nocycle_a_00170_A4 a4_main = new Nocycle_a_00170_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a2_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a2_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a3_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a3_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a3_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a4_main.b1_0 = new Nocycle_a_00170_B1("b1_0");
+        a4_main.b2_0 = new Nocycle_a_00170_B2("b2_0");
+        a4_main.b3_0 = new Nocycle_a_00170_B3("b3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        a2_main.b3_0.add();
+        a3_main.b1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b3_0.add();
+        a4_main.b1_0.add();
+        a4_main.b2_0.add();
+        a4_main.b3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 4046)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00170_A1 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00170_A2 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00170_A3 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_A3(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00170_A4 {
+        Nocycle_a_00170_B1 b1_0;
+        Nocycle_a_00170_B2 b2_0;
+        Nocycle_a_00170_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_A4(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_00170_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00170_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00170_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00170_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_00180B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+//		 System.out.printf("a1_main.sum=%d\n",a1_main.sum);
+//		 System.out.printf("a2_main.sum=%d\n",a2_main.sum);
+//		 System.out.printf("a3_main.sum=%d\n",a3_main.sum);
+//		 System.out.printf("a4_main.sum=%d\n",a4_main.sum);
+//		 System.out.printf("a1_main.b1_0.sum=%d\n",a1_main.b1_0.sum);
+//		 System.out.printf("a2_main.b2_0.sum=%d\n",a2_main.b2_0.sum);
+//		 System.out.printf("a4_main.b3_0.sum=%d\n",a4_main.b3_0.sum);
+//		 System.out.printf("a2_main.b2_0.c1_0.sum=%d\n",a2_main.b2_0.c1_0.sum);
+//		 System.out.printf("a3_main.c2_0.sum=%d\n",a3_main.c2_0.sum);
+//		 System.out.printf("a1_main.d1_0.sum=%d\n",a1_main.d1_0.sum);
+//		 System.out.printf("a3_main.c2_0.d2_0.sum=%d\n",a3_main.c2_0.d2_0.sum);
+//		 System.out.printf("a3_main.c2_0.d3_0.sum=%d\n",a3_main.c2_0.d3_0.sum);
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a3_main.sum+a4_main.sum+a1_main.b1_0.sum+a2_main.b2_0.sum+a4_main.b3_0.sum+a2_main.b2_0.c1_0.sum+a3_main.c2_0.sum+a1_main.d1_0.sum+a3_main.c2_0.d2_0.sum+a3_main.c2_0.d3_0.sum);
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 9260)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00180_A1 {
+        Nocycle_a_00180_B1 b1_0;
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00180_A2 {
+        Nocycle_a_00180_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00180_A3 {
+        Nocycle_a_00180_B2 b2_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_00180_A4 {
+        Nocycle_a_00180_B3 b3_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_00180_B1 {
+        Nocycle_a_00180_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class Nocycle_a_00180_B2 {
+        Nocycle_a_00180_C1 c1_0;
+        Nocycle_a_00180_D1 d1_0;
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_00180_B3 {
+        Nocycle_a_00180_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00180_C1 {
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00180_C2 {
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_00180_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00180_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00180_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_00190 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00010B A1_00010 = new ThreadRc_00010B();
+        ThreadRc_00010B A2_00010 = new ThreadRc_00010B();
+        ThreadRc_00020B A1_00020 = new ThreadRc_00020B();
+        ThreadRc_00020B A2_00020 = new ThreadRc_00020B();
+        ThreadRc_00030B A1_00030 = new ThreadRc_00030B();
+        ThreadRc_00030B A2_00030 = new ThreadRc_00030B();
+        ThreadRc_00040B A1_00040 = new ThreadRc_00040B();
+        ThreadRc_00040B A2_00040 = new ThreadRc_00040B();
+        ThreadRc_00050B A1_00050 = new ThreadRc_00050B();
+        ThreadRc_00050B A2_00050 = new ThreadRc_00050B();
+        ThreadRc_00060B A1_00060 = new ThreadRc_00060B();
+        ThreadRc_00060B A2_00060 = new ThreadRc_00060B();
+        ThreadRc_00070B A1_00070 = new ThreadRc_00070B();
+        ThreadRc_00070B A2_00070 = new ThreadRc_00070B();
+        ThreadRc_00080B A1_00080 = new ThreadRc_00080B();
+        ThreadRc_00080B A2_00080 = new ThreadRc_00080B();
+        ThreadRc_00090B A1_00090 = new ThreadRc_00090B();
+        ThreadRc_00090B A2_00090 = new ThreadRc_00090B();
+        ThreadRc_00100B A1_00100 = new ThreadRc_00100B();
+        ThreadRc_00100B A2_00100 = new ThreadRc_00100B();
+        ThreadRc_00110B A1_00110 = new ThreadRc_00110B();
+        ThreadRc_00110B A2_00110 = new ThreadRc_00110B();
+        ThreadRc_00120B A1_00120 = new ThreadRc_00120B();
+        ThreadRc_00120B A2_00120 = new ThreadRc_00120B();
+        ThreadRc_00130B A1_00130 = new ThreadRc_00130B();
+        ThreadRc_00130B A2_00130 = new ThreadRc_00130B();
+        ThreadRc_00140B A1_00140 = new ThreadRc_00140B();
+        ThreadRc_00140B A2_00140 = new ThreadRc_00140B();
+        ThreadRc_00150B A1_00150 = new ThreadRc_00150B();
+        ThreadRc_00150B A2_00150 = new ThreadRc_00150B();
+        ThreadRc_00160B A1_00160 = new ThreadRc_00160B();
+        ThreadRc_00160B A2_00160 = new ThreadRc_00160B();
+        ThreadRc_00170B A1_00170 = new ThreadRc_00170B();
+        ThreadRc_00170B A2_00170 = new ThreadRc_00170B();
+        ThreadRc_00180B A1_00180 = new ThreadRc_00180B();
+        ThreadRc_00180B A2_00180 = new ThreadRc_00180B();
+        A1_00010.start();
+        A2_00010.start();
+        A1_00020.start();
+        A2_00020.start();
+        A1_00030.start();
+        A2_00030.start();
+        A1_00040.start();
+        A2_00040.start();
+        A1_00050.start();
+        A2_00050.start();
+        A1_00060.start();
+        A2_00060.start();
+        A1_00070.start();
+        A2_00070.start();
+        A1_00080.start();
+        A2_00080.start();
+        A1_00090.start();
+        A2_00090.start();
+        A1_00100.start();
+        A2_00100.start();
+        A1_00110.start();
+        A2_00110.start();
+        A1_00120.start();
+        A2_00120.start();
+        A1_00130.start();
+        A2_00130.start();
+        A1_00140.start();
+        A2_00140.start();
+        A1_00150.start();
+        A2_00150.start();
+        A1_00160.start();
+        A2_00160.start();
+        A1_00170.start();
+        A2_00170.start();
+        A1_00180.start();
+        A2_00180.start();
+        try {
+            A1_00010.join();
+            A2_00010.join();
+            A1_00020.join();
+            A2_00020.join();
+            A1_00030.join();
+            A2_00030.join();
+            A1_00040.join();
+            A2_00040.join();
+            A1_00050.join();
+            A2_00050.join();
+            A1_00060.join();
+            A2_00060.join();
+            A1_00070.join();
+            A2_00070.join();
+            A1_00080.join();
+            A2_00080.join();
+            A1_00090.join();
+            A2_00090.join();
+            A1_00100.join();
+            A2_00100.join();
+            A1_00110.join();
+            A2_00110.join();
+            A1_00120.join();
+            A2_00120.join();
+            A1_00130.join();
+            A2_00130.join();
+            A1_00140.join();
+            A2_00140.join();
+            A1_00150.join();
+            A2_00150.join();
+            A1_00160.join();
+            A2_00160.join();
+            A1_00170.join();
+            A2_00170.join();
+            A1_00180.join();
+            A2_00180.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00010.check() && A2_00010.check() && A1_00020.check() && A2_00020.check() && A1_00030.check() && A2_00030.check() && A1_00040.check() && A2_00040.check() && A1_00050.check() && A2_00050.check() && A1_00060.check() && A2_00060.check() && A1_00070.check() && A2_00070.check() && A1_00080.check() && A2_00080.check() && A1_00090.check() && A2_00090.check() && A1_00100.check() && A2_00100.check() && A1_00110.check() && A2_00110.check() && A1_00120.check() && A2_00120.check() && A1_00130.check() && A2_00130.check() && A1_00140.check() && A2_00140.check() && A1_00150.check() && A2_00150.check() && A1_00160.check() && A2_00160.check() && A1_00170.check() && A2_00170.check() && A1_00180.check() && A2_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/expected.txt b/testsuite/java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/test.cfg b/testsuite/java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c3343c993f7bf7094fd891ca2ccace2cb51d5ba4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0224-rc-function-RC_Thread01-Nocycle_am_00190/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_00190)
+run(Nocycle_am_00190,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/Nocycle_am_2_00010.java b/testsuite/java_test/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/Nocycle_am_2_00010.java
new file mode 100755
index 0000000000000000000000000000000000000000..ce2555ca5b0db0b9f48065050491e4d02dff8586
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/Nocycle_am_2_00010.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Nocycle_am_2_00010 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_2_00010_A1 a1_main = new Nocycle_a_2_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00010_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00010_B3("b3_0");
+        Nocycle_a_2_00010_A2 a2_main = new Nocycle_a_2_00010_A2("a2_main");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.add();
+        //		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a2_main.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1939)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_2_00010_A1 {
+        Nocycle_a_2_00010_B1 b1_0;
+        Nocycle_a_2_00010_B2 b2_0;
+        Nocycle_a_2_00010_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_2_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00010_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00010_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00010_A2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_A2(String strObjectName) {
+            a = 10;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_2_00010 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Nocycle_am_2_00010 A1_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A2_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A3_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A4_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A5_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        ThreadRc_Nocycle_am_2_00010 A6_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010();
+        A1_Nocycle_am_2_00010.start();
+        A2_Nocycle_am_2_00010.start();
+        A3_Nocycle_am_2_00010.start();
+        A4_Nocycle_am_2_00010.start();
+        A5_Nocycle_am_2_00010.start();
+        A6_Nocycle_am_2_00010.start();
+        try {
+            A1_Nocycle_am_2_00010.join();
+            A2_Nocycle_am_2_00010.join();
+            A3_Nocycle_am_2_00010.join();
+            A4_Nocycle_am_2_00010.join();
+            A5_Nocycle_am_2_00010.join();
+            A6_Nocycle_am_2_00010.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Nocycle_am_2_00010.check() && A2_Nocycle_am_2_00010.check() && A3_Nocycle_am_2_00010.check() && A4_Nocycle_am_2_00010.check() && A5_Nocycle_am_2_00010.check() && A6_Nocycle_am_2_00010.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/expected.txt b/testsuite/java_test/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/test.cfg b/testsuite/java_test/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..08e797673794857b283febdeb7b4adb785be9c24
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_2_00010)
+run(Nocycle_am_2_00010,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/Nocycle_am_2_00020.java b/testsuite/java_test/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/Nocycle_am_2_00020.java
new file mode 100755
index 0000000000000000000000000000000000000000..691a6842ae652af6d8d00a299727b3b9c2b9f95a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/Nocycle_am_2_00020.java
@@ -0,0 +1,640 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Nocycle_am_2_00020 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_2_00020_A1 a1_main = new Nocycle_a_2_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_2_00020_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_2_00020_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_2_00020_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_2_00020_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+        int result1 = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result1);
+        Nocycle_a_2_00020_2A1 a1_main2 = new Nocycle_a_2_00020_2A1("a1_main2");
+        a1_main2.b1_0 = new Nocycle_a_2_00020_2B1("b1_0");
+        a1_main2.b1_0.c1_0 = new Nocycle_a_2_00020_2C1("c1_0");
+        a1_main2.b1_0.c1_0.d1_0 = new Nocycle_a_2_00020_2D1("d1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_2_00020_2E1("e1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_2_00020_2F1("f1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_2_00020_2G1("g1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_2_00020_2H1("h1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_2_00020_2I1("i1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_2_00020_2J1("j1_0");
+        a1_main2.add();
+        a1_main2.b1_0.add();
+        a1_main2.b1_0.c1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+        int result2 = a1_main2.sum + a1_main2.b1_0.sum + a1_main2.b1_0.c1_0.sum + a1_main2.b1_0.c1_0.d1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+        Nocycle_a_2_00020_3A1 a1_main3 = new Nocycle_a_2_00020_3A1("a1_main3");
+        Nocycle_a_2_00020_3A2 a2_main = new Nocycle_a_2_00020_3A2("a2_main");
+        Nocycle_a_2_00020_3A3 a3_main = new Nocycle_a_2_00020_3A3("a3_main");
+        Nocycle_a_2_00020_3A4 a4_main = new Nocycle_a_2_00020_3A4("a4_main");
+        a1_main3.b1_0 = new Nocycle_a_2_00020_3B1("b1_0");
+        a1_main3.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a1_main3.b1_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a3_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a4_main.b3_0 = new Nocycle_a_2_00020_3B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a1_main3.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main3.b1_0.add();
+        a1_main3.d1_0.add();
+        a1_main3.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result3 = a1_main3.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main3.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main3.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        int result = result1 + result2 + result3;
+        if (result == 26225)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_2_00020_A1 {
+        Nocycle_a_2_00020_B1 b1_0;
+        Nocycle_a_2_00020_B2 b2_0;
+        Nocycle_a_2_00020_B3 b3_0;
+        Nocycle_a_2_00020_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_B4 {
+        Nocycle_a_2_00020_C1 c1_0;
+        Nocycle_a_2_00020_C2 c2_0;
+        Nocycle_a_2_00020_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_2A1 {
+        Nocycle_a_2_00020_2B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2B1 {
+        Nocycle_a_2_00020_2C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2C1 {
+        Nocycle_a_2_00020_2D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2D1 {
+        Nocycle_a_2_00020_2E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2E1 {
+        Nocycle_a_2_00020_2F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2F1 {
+        Nocycle_a_2_00020_2G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2G1 {
+        Nocycle_a_2_00020_2H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2H1 {
+        Nocycle_a_2_00020_2I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2I1 {
+        Nocycle_a_2_00020_2J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2J1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_3A1 {
+        Nocycle_a_2_00020_3B1 b1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3A2 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3A3 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3A4 {
+        Nocycle_a_2_00020_3B3 b3_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3B1 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3B2 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3B3 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3C1 {
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3C2 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_3D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_3D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_2_00020 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Nocycle_am_2_00020 A1_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A2_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A3_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A4_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A5_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        ThreadRc_Nocycle_am_2_00020 A6_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020();
+        A1_Nocycle_am_2_00020.start();
+        A2_Nocycle_am_2_00020.start();
+        A3_Nocycle_am_2_00020.start();
+        A4_Nocycle_am_2_00020.start();
+        A5_Nocycle_am_2_00020.start();
+        A6_Nocycle_am_2_00020.start();
+        try {
+            A1_Nocycle_am_2_00020.join();
+            A2_Nocycle_am_2_00020.join();
+            A3_Nocycle_am_2_00020.join();
+            A4_Nocycle_am_2_00020.join();
+            A5_Nocycle_am_2_00020.join();
+            A6_Nocycle_am_2_00020.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Nocycle_am_2_00020.check() && A2_Nocycle_am_2_00020.check() && A3_Nocycle_am_2_00020.check() && A4_Nocycle_am_2_00020.check() && A5_Nocycle_am_2_00020.check() && A6_Nocycle_am_2_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/expected.txt b/testsuite/java_test/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/test.cfg b/testsuite/java_test/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6cb78ce5bf4d2cc4ae375ee888fa763a37649d05
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_2_00020)
+run(Nocycle_am_2_00020,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/Nocycle_am_2_00030.java b/testsuite/java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/Nocycle_am_2_00030.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e79faebd3c44d9f3c7647a9f266b8e90630c0ce
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/Nocycle_am_2_00030.java
@@ -0,0 +1,758 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRc_Nocycle_am_2_00010B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_2_00010_A1 a1_main = new Nocycle_a_2_00010_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00010_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00010_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00010_B3("b3_0");
+        Nocycle_a_2_00010_A2 a2_main = new Nocycle_a_2_00010_A2("a2_main");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a2_main.add();
+        //		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum);
+        int result = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a2_main.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1939)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_2_00010_A1 {
+        Nocycle_a_2_00010_B1 b1_0;
+        Nocycle_a_2_00010_B2 b2_0;
+        Nocycle_a_2_00010_B3 b3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a;
+        }
+    }
+    class Nocycle_a_2_00010_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00010_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00010_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00010_A2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00010_A2(String strObjectName) {
+            a = 10;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+class ThreadRc_Nocycle_am_2_00020B extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_2_00020_A1 a1_main = new Nocycle_a_2_00020_A1("a1_main");
+        a1_main.b1_0 = new Nocycle_a_2_00020_B1("b1_0");
+        a1_main.b2_0 = new Nocycle_a_2_00020_B2("b2_0");
+        a1_main.b3_0 = new Nocycle_a_2_00020_B3("b3_0");
+        a1_main.b4_0 = new Nocycle_a_2_00020_B4("b4_0");
+        a1_main.b4_0.c1_0 = new Nocycle_a_2_00020_C1("c1_0");
+        a1_main.b4_0.c2_0 = new Nocycle_a_2_00020_C2("c2_0");
+        a1_main.b4_0.c3_0 = new Nocycle_a_2_00020_C3("c3_0");
+        a1_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a1_main.b3_0.add();
+        a1_main.b4_0.add();
+        a1_main.b4_0.c1_0.add();
+        a1_main.b4_0.c2_0.add();
+        a1_main.b4_0.c3_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum+a1_main.b3_0.sum+a1_main.b4_0.sum+a1_main.b4_0.c1_0.sum+a1_main.b4_0.c2_0.sum+a1_main.b4_0.c3_0.sum);
+        int result1 = a1_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum + a1_main.b3_0.sum + a1_main.b4_0.sum + a1_main.b4_0.c1_0.sum + a1_main.b4_0.c2_0.sum + a1_main.b4_0.c3_0.sum;
+        //System.out.println("RC-Testing_Result="+result1);
+        Nocycle_a_2_00020_2A1 a1_main2 = new Nocycle_a_2_00020_2A1("a1_main2");
+        a1_main2.b1_0 = new Nocycle_a_2_00020_2B1("b1_0");
+        a1_main2.b1_0.c1_0 = new Nocycle_a_2_00020_2C1("c1_0");
+        a1_main2.b1_0.c1_0.d1_0 = new Nocycle_a_2_00020_2D1("d1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0 = new Nocycle_a_2_00020_2E1("e1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0 = new Nocycle_a_2_00020_2F1("f1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0 = new Nocycle_a_2_00020_2G1("g1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0 = new Nocycle_a_2_00020_2H1("h1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0 = new Nocycle_a_2_00020_2I1("i1_0");
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0 = new Nocycle_a_2_00020_2J1("j1_0");
+        a1_main2.add();
+        a1_main2.b1_0.add();
+        a1_main2.b1_0.c1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.add();
+        a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.add();
+        int result2 = a1_main2.sum + a1_main2.b1_0.sum + a1_main2.b1_0.c1_0.sum + a1_main2.b1_0.c1_0.d1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.sum + a1_main2.b1_0.c1_0.d1_0.e1_0.f1_0.g1_0.h1_0.i1_0.j1_0.sum;
+        Nocycle_a_2_00020_3A1 a1_main3 = new Nocycle_a_2_00020_3A1("a1_main3");
+        Nocycle_a_2_00020_3A2 a2_main = new Nocycle_a_2_00020_3A2("a2_main");
+        Nocycle_a_2_00020_3A3 a3_main = new Nocycle_a_2_00020_3A3("a3_main");
+        Nocycle_a_2_00020_3A4 a4_main = new Nocycle_a_2_00020_3A4("a4_main");
+        a1_main3.b1_0 = new Nocycle_a_2_00020_3B1("b1_0");
+        a1_main3.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a1_main3.b1_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a2_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a2_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a2_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0 = new Nocycle_a_2_00020_3B2("b2_0");
+        a3_main.b2_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a3_main.b2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.b2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a3_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a3_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a3_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a4_main.b3_0 = new Nocycle_a_2_00020_3B3("b3_0");
+        a4_main.b3_0.c1_0 = new Nocycle_a_2_00020_3C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new Nocycle_a_2_00020_3D1("d1_0");
+        a4_main.c2_0 = new Nocycle_a_2_00020_3C2("c2_0");
+        a4_main.c2_0.d2_0 = new Nocycle_a_2_00020_3D2("d2_0");
+        a4_main.c2_0.d3_0 = new Nocycle_a_2_00020_3D3("d3_0");
+        a1_main3.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main3.b1_0.add();
+        a1_main3.d1_0.add();
+        a1_main3.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result3 = a1_main3.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main3.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a2_main.b2_0.c1_0.sum + a3_main.c2_0.sum + a1_main3.d1_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum;
+        int result = result1 + result2 + result3;
+        if (result == 26225)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_2_00020_A1 {
+        Nocycle_a_2_00020_B1 b1_0;
+        Nocycle_a_2_00020_B2 b2_0;
+        Nocycle_a_2_00020_B3 b3_0;
+        Nocycle_a_2_00020_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_B4 {
+        Nocycle_a_2_00020_C1 c1_0;
+        Nocycle_a_2_00020_C2 c2_0;
+        Nocycle_a_2_00020_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_B4(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_2A1 {
+        Nocycle_a_2_00020_2B1 b1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2A1(String strObjectName) {
+            b1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2B1 {
+        Nocycle_a_2_00020_2C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2B1(String strObjectName) {
+            c1_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2C1 {
+        Nocycle_a_2_00020_2D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2D1 {
+        Nocycle_a_2_00020_2E1 e1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2D1(String strObjectName) {
+            e1_0 = null;
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + e1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2E1 {
+        Nocycle_a_2_00020_2F1 f1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2E1(String strObjectName) {
+            f1_0 = null;
+            a = 501;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_E1_"+strObjectName);
+        }
+        void add() {
+            sum = a + f1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2F1 {
+        Nocycle_a_2_00020_2G1 g1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2F1(String strObjectName) {
+            g1_0 = null;
+            a = 601;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_F1_"+strObjectName);
+        }
+        void add() {
+            sum = a + g1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2G1 {
+        Nocycle_a_2_00020_2H1 h1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2G1(String strObjectName) {
+            h1_0 = null;
+            a = 701;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_G1_"+strObjectName);
+        }
+        void add() {
+            sum = a + h1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2H1 {
+        Nocycle_a_2_00020_2I1 i1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2H1(String strObjectName) {
+            i1_0 = null;
+            a = 801;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_H1_"+strObjectName);
+        }
+        void add() {
+            sum = a + i1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2I1 {
+        Nocycle_a_2_00020_2J1 j1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2I1(String strObjectName) {
+            j1_0 = null;
+            a = 901;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_I1_"+strObjectName);
+        }
+        void add() {
+            sum = a + j1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_2J1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_2J1(String strObjectName) {
+            a = 1001;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_J1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_3A1 {
+        Nocycle_a_2_00020_3B1 b1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3A2 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3A3 {
+        Nocycle_a_2_00020_3B2 b2_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3A4 {
+        Nocycle_a_2_00020_3B3 b3_0;
+        Nocycle_a_2_00020_3C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3B1 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3B2 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        Nocycle_a_2_00020_3D1 d1_0;
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3B3 {
+        Nocycle_a_2_00020_3C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3C1 {
+        Nocycle_a_2_00020_3D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3C2 {
+        Nocycle_a_2_00020_3D2 d2_0;
+        Nocycle_a_2_00020_3D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_2_00020_3D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_3D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_2_00020_3D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_2_00020_3D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class Nocycle_am_2_00030 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Nocycle_am_2_00010B A1_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A2_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A3_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A4_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A5_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00010B A6_Nocycle_am_2_00010 = new ThreadRc_Nocycle_am_2_00010B();
+        ThreadRc_Nocycle_am_2_00020B A1_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A2_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A3_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A4_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A5_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        ThreadRc_Nocycle_am_2_00020B A6_Nocycle_am_2_00020 = new ThreadRc_Nocycle_am_2_00020B();
+        A1_Nocycle_am_2_00010.start();
+        A2_Nocycle_am_2_00010.start();
+        A3_Nocycle_am_2_00010.start();
+        A4_Nocycle_am_2_00010.start();
+        A5_Nocycle_am_2_00010.start();
+        A6_Nocycle_am_2_00010.start();
+        A1_Nocycle_am_2_00020.start();
+        A2_Nocycle_am_2_00020.start();
+        A3_Nocycle_am_2_00020.start();
+        A4_Nocycle_am_2_00020.start();
+        A5_Nocycle_am_2_00020.start();
+        A6_Nocycle_am_2_00020.start();
+        try {
+            A1_Nocycle_am_2_00010.join();
+            A2_Nocycle_am_2_00010.join();
+            A3_Nocycle_am_2_00010.join();
+            A4_Nocycle_am_2_00010.join();
+            A5_Nocycle_am_2_00010.join();
+            A6_Nocycle_am_2_00010.join();
+            A1_Nocycle_am_2_00020.join();
+            A2_Nocycle_am_2_00020.join();
+            A3_Nocycle_am_2_00020.join();
+            A4_Nocycle_am_2_00020.join();
+            A5_Nocycle_am_2_00020.join();
+            A6_Nocycle_am_2_00020.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Nocycle_am_2_00010.check() && A2_Nocycle_am_2_00010.check() && A3_Nocycle_am_2_00010.check() && A4_Nocycle_am_2_00010.check() && A5_Nocycle_am_2_00010.check() && A6_Nocycle_am_2_00010.check() && A1_Nocycle_am_2_00020.check() && A2_Nocycle_am_2_00020.check() && A3_Nocycle_am_2_00020.check() && A4_Nocycle_am_2_00020.check() && A5_Nocycle_am_2_00020.check() && A6_Nocycle_am_2_00020.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/expected.txt b/testsuite/java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/test.cfg b/testsuite/java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bc8d997b3980194ccba3dcbb0168cd42737b5631
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030/test.cfg
@@ -0,0 +1,2 @@
+compile(Nocycle_am_2_00030)
+run(Nocycle_am_2_00030,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/RC_Thread_01.java b/testsuite/java_test/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/RC_Thread_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..feef822446b5821a4769036cb1f49678dd68c1a1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/RC_Thread_01.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RC_Thread_01_1 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_01_2 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_01_3 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_01_4 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_01_5 extends Thread {
+    public void run() {
+        RC_Thread_01 rcth01 = new RC_Thread_01();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_01 {
+    private volatile static RC_Thread_01_A1 a1_main = null;
+    private volatile static RC_Thread_01_A2 a2_main = null;
+    private volatile static RC_Thread_01_A3 a3_main = null;
+    private volatile static RC_Thread_01_A4 a4_main = null;
+    RC_Thread_01() {
+        try {
+            a1_main = new RC_Thread_01_A1("a1_main");
+            a2_main = new RC_Thread_01_A2("a2_main");
+            a3_main = new RC_Thread_01_A3("a3_main");
+            a4_main = new RC_Thread_01_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_01_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_01_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a2_main.b2_0 = new RC_Thread_01_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_01_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a3_main.b2_0 = new RC_Thread_01_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_01_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+            a3_main.c2_0 = new RC_Thread_01_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+            a4_main.b3_0 = new RC_Thread_01_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_01_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_01_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_01_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_01_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_01_D3("d3_0");
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_01_1 t1=new RC_Thread_01_1();
+        RC_Thread_01_2 t2=new RC_Thread_01_2();
+        RC_Thread_01_3 t3=new RC_Thread_01_3();
+        RC_Thread_01_4 t4=new RC_Thread_01_4();
+        RC_Thread_01_5 t5=new RC_Thread_01_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+        } catch (InterruptedException e) {}
+    }
+    public void setA1null() {
+        a1_main = null;
+    }
+    public void setA2null() {
+        a2_main = null;
+    }
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_01_D2("new");
+            a3_main = new RC_Thread_01_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA3null() {
+        a3_main = null;
+    }
+    public void setA4null() {
+        a4_main = null;
+    }
+    class RC_Thread_01_A1 {
+        volatile RC_Thread_01_B1 b1_0;
+        volatile RC_Thread_01_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+    class RC_Thread_01_A2 {
+        volatile RC_Thread_01_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+    class RC_Thread_01_A3 {
+        volatile RC_Thread_01_B2 b2_0;
+        volatile RC_Thread_01_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+    class RC_Thread_01_A4 {
+        volatile RC_Thread_01_B3 b3_0;
+        volatile RC_Thread_01_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+    class RC_Thread_01_B1 {
+        volatile RC_Thread_01_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class RC_Thread_01_B2 {
+        volatile RC_Thread_01_C1 c1_0;
+        volatile RC_Thread_01_D1 d1_0;
+        volatile RC_Thread_01_D2 d2_0;
+        volatile RC_Thread_01_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+    class RC_Thread_01_B3 {
+        volatile RC_Thread_01_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class RC_Thread_01_C1 {
+        volatile RC_Thread_01_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class RC_Thread_01_C2 {
+        volatile RC_Thread_01_D2 d2_0;
+        volatile RC_Thread_01_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+    class RC_Thread_01_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_01_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_01_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_01_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/expected.txt b/testsuite/java_test/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/test.cfg b/testsuite/java_test/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4b51e6758f3637e486cf0aa1311009b3d7cfc2f0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0228-rc-function-RC_Thread02-RC_Thread_01/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_01)
+run(RC_Thread_01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/RC_Thread_02.java b/testsuite/java_test/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/RC_Thread_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..ca8384de9fab9eb8e178322770f4d535e981deb1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/RC_Thread_02.java
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RC_Thread_02_1 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.addSum();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_02_2 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.ModifyB4();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_02_3 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.deleteA1();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_02_4 extends Thread {
+    public void run() {
+        RC_Thread_02 rcth01 = new RC_Thread_02("rcth01");
+        try {
+            rcth01.setA1(null);
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_02 {
+    private volatile static RC_Thread_02_A1 a1 = null;
+    RC_Thread_02(String str) {
+        try {
+            a1 = new RC_Thread_02_A1("a1");
+            a1.b1_0 = new RC_Thread_02_B1("b1_0");
+            a1.b1_0.c1_0 = new RC_Thread_02_C1("c1_0");
+            a1.b1_0.c2_0 = new RC_Thread_02_C2("c2_0");
+            a1.b1_0.c3_0 = new RC_Thread_02_C3("c3_0");
+            a1.b2_0 = new RC_Thread_02_B2("b2_0");
+            a1.b3_0 = new RC_Thread_02_B3("b3_0");
+            a1.b4_0 = new RC_Thread_02_B4("b4_0");
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+		System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_02_1 t1=new RC_Thread_02_1();
+        RC_Thread_02_2 t2=new RC_Thread_02_2();
+        RC_Thread_02_3 t3=new RC_Thread_02_3();
+        RC_Thread_02_4 t4=new RC_Thread_02_4();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        try{
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+        }catch(InterruptedException e){}
+    }
+    public void deleteA1() {
+        a1 = null;
+    }
+    public void ModifyB4() {
+        try{
+        a1.b4_0 = new RC_Thread_02_B4("new_b4");
+        }catch(NullPointerException e){
+        }
+    }
+    public void addSum() {
+        try {
+            a1.add();
+            a1.b1_0.add();
+            a1.b2_0.add();
+            a1.b3_0.add();
+            a1.b4_0.add();
+            a1.b1_0.c1_0.add();
+            a1.b1_0.c2_0.add();
+            a1.b1_0.c3_0.add();
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA1(RC_Thread_02_A1 a1) {
+        this.a1 = a1;
+    }
+    class RC_Thread_02_A1 {
+        volatile RC_Thread_02_B1 b1_0;
+        volatile RC_Thread_02_B2 b2_0;
+        volatile RC_Thread_02_B3 b3_0;
+        volatile RC_Thread_02_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_02_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class RC_Thread_02_B1 {
+        volatile RC_Thread_02_C1 c1_0;
+        volatile RC_Thread_02_C2 c2_0;
+        volatile RC_Thread_02_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_02_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class RC_Thread_02_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_02_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_02_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_02_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_02_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_02_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_02_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_02_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_02_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_02_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_02_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_02_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/expected.txt b/testsuite/java_test/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/test.cfg b/testsuite/java_test/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0e25de5c1ab27660bdb0c538b94f62957f19f47f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0229-rc-function-RC_Thread02-RC_Thread_02/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_02)
+run(RC_Thread_02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/RC_Thread_03.java b/testsuite/java_test/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/RC_Thread_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..3908fba98e7d9036eba104a88ba40a1922caa1b1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/RC_Thread_03.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RcThread0301 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0302 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0303 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0304 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0305 extends Thread {
+    public void run() {
+        RC_Thread_03 rcth01 = new RC_Thread_03();
+        try {
+            rcth01.setA4();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread03GC extends Thread {
+    public void run() {
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 50);
+        if (start == 50) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+public class RC_Thread_03 {
+    private static volatile RcThread03A1 a1_main = null;
+    private static volatile RcThread03A2 a2_main = null;
+    private static volatile RcThread03A3 a3_main = null;
+    private static volatile RcThread03A4 a4_main = null;
+    RC_Thread_03() {
+        try {
+            a1_main = new RcThread03A1("a1_main");
+            a2_main = new RcThread03A2("a2_main");
+            a3_main = new RcThread03A3("a3_main");
+            a4_main = new RcThread03A4("a4_main");
+            a1_main.b1_0 = new RcThread03B1("b1_0");
+            a1_main.d1_0 = new RcThread03D1("d1_0");
+            a1_main.b1_0.d2_0 = new RcThread03D2("d2_0");
+            a2_main.b2_0 = new RcThread03B2("b2_0");
+            a2_main.b2_0.c1_0 = new RcThread03C1("c1_0");
+            a2_main.b2_0.d1_0 = new RcThread03D1("d1_0");
+            a2_main.b2_0.d2_0 = new RcThread03D2("d2_0");
+            a2_main.b2_0.d3_0 = new RcThread03D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RcThread03D1("d1_0");
+            a3_main.b2_0 = new RcThread03B2("b2_0");
+            a3_main.b2_0.c1_0 = new RcThread03C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RcThread03D1("d1_0");
+            a3_main.b2_0.d1_0 = new RcThread03D1("d1_0");
+            a3_main.b2_0.d2_0 = new RcThread03D2("d2_0");
+            a3_main.b2_0.d3_0 = new RcThread03D3("d3_0");
+            a3_main.c2_0 = new RcThread03C2("c2_0");
+            a3_main.c2_0.d2_0 = new RcThread03D2("d2_0");
+            a3_main.c2_0.d3_0 = new RcThread03D3("d3_0");
+            a4_main.b3_0 = new RcThread03B3("b3_0");
+            a4_main.b3_0.c1_0 = new RcThread03C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RcThread03D1("d1_0");
+            a4_main.c2_0 = new RcThread03C2("c2_0");
+            a4_main.c2_0.d2_0 = new RcThread03D2("d2_0");
+            a4_main.c2_0.d3_0 = new RcThread03D3("d3_0");
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    public static void main(String[] args) {
+        RcThread03GC gc = new RcThread03GC();
+        gc.run();
+        for(int start = 0; start < 10; start++) {
+            rcTestcaseMainWrapper();
+        }
+        System.out.println("ExpectResult");
+    }
+    private static void rcTestcaseMainWrapper() {
+        RcThread0301 t1 = new RcThread0301();
+        RcThread0302 t2 = new RcThread0302();
+        RcThread0303 t3 = new RcThread0303();
+        RcThread0304 t4 = new RcThread0304();
+        RcThread0305 t5 = new RcThread0305();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+        }catch(InterruptedException e){
+            // do nothing
+        }
+    }
+    void setA1null() {
+        a1_main = null;
+    }
+    void setA2null() {
+        a2_main = null;
+    }
+    void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RcThread03D2("new");
+            a3_main = new RcThread03A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    void setA3null() {
+        a3_main = null;
+    }
+    void setA4() {
+        try {
+            a4_main = new RcThread03A4("a4_new");
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    class RcThread03A1 {
+        volatile RcThread03B1 b1_0;
+        volatile RcThread03D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03A2 {
+        volatile RcThread03B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03A3 {
+        volatile RcThread03B2 b2_0;
+        volatile RcThread03C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03A4 {
+        volatile RcThread03B3 b3_0;
+        volatile RcThread03C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03B1 {
+        volatile RcThread03D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03B2 {
+        volatile RcThread03C1 c1_0;
+        volatile RcThread03D1 d1_0;
+        volatile RcThread03D2 d2_0;
+        volatile RcThread03D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03B3 {
+        volatile RcThread03C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03C1 {
+        volatile RcThread03D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03C2 {
+        volatile RcThread03D2 d2_0;
+        volatile RcThread03D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+    class RcThread03D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RcThread03D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/expected.txt b/testsuite/java_test/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/test.cfg b/testsuite/java_test/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..71355cdbb52151bea2de863a9876f18556f5b4ec
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0230-rc-function-RC_Thread02-RC_Thread_03/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_03)
+run(RC_Thread_03,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/RC_Thread_04.java b/testsuite/java_test/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/RC_Thread_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..11d518dceb2ca3dedb414868e6cd600f7f7ec96a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/RC_Thread_04.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RcThread0401 extends Thread {
+    public void run() {
+        RC_Thread_04 rcth01 = new RC_Thread_04();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0402 extends Thread {
+    public void run() {
+        RC_Thread_04 rcth01 = new RC_Thread_04();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0403 extends Thread {
+    public void run() {
+        RC_Thread_04 rcth01 = new RC_Thread_04();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread04GC extends Thread {
+    public void run() {
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 50);
+        if (start == 50) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+public class RC_Thread_04 {
+    private static volatile RcThread04A1 a1_main = null;
+    private static volatile  RcThread04A4 a4_main = null;
+    private static volatile  RcThread04A5 a5_main = null;
+    RC_Thread_04() {
+        try {
+            RcThread04A1 a1 = new RcThread04A1();
+            a1.a2_0 = new RcThread04A2();
+            a1.a2_0.a3_0 = new RcThread04A3();
+            RcThread04A4 a4 = new RcThread04A4();
+            RcThread04A5 a5 = new RcThread04A5();
+            a4.a1_0 = a1;
+            a5.a1_0 = a1;
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1_main = a1;
+            a4_main = a4;
+            a5_main = a5;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    public static void main(String[] args) {
+        cyclePatternWrapper();
+        RcThread04GC gc = new RcThread04GC();
+        gc.start();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void cyclePatternWrapper() {
+        a1_main = new RcThread04A1();
+        a1_main.a2_0 = new RcThread04A2();
+        a1_main.a2_0.a3_0 = new RcThread04A3();
+        a4_main = new RcThread04A4();
+        a5_main = new RcThread04A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main = null;
+        a4_main = null;
+        a5_main = null;
+        Runtime.getRuntime().gc(); // 单独构造一次Cycle_B_1_00180环，通过gc学习到环模式
+    }
+    private static void rcTestcaseMainWrapper() {
+        RcThread0401 t1 = new RcThread0401();
+        RcThread0402 t2 = new RcThread0402();
+        RcThread0403 t3 = new RcThread0403();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        }catch(InterruptedException e){
+            // do nothing
+        }
+    }
+    void setA1null() {
+        a1_main = null;
+    }
+    void setA4null() {
+        a4_main = null;
+    }
+    void setA5null() {
+        a5_main = null;
+    }
+    static class RcThread04A1 {
+        volatile RcThread04A2 a2_0;
+        int a;
+        int sum;
+        RcThread04A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+    }
+    static class RcThread04A2 {
+        volatile RcThread04A3 a3_0;
+        int a;
+        int sum;
+        RcThread04A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+    }
+    static class RcThread04A3 {
+        volatile RcThread04A1 a1_0;
+        int a;
+        int sum;
+        RcThread04A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+    }
+    static class RcThread04A4 {
+        volatile RcThread04A1 a1_0;
+        int a;
+        int sum;
+        RcThread04A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+    }
+    static class RcThread04A5 {
+        volatile RcThread04A1 a1_0;
+        int a;
+        int sum;
+        RcThread04A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/expected.txt b/testsuite/java_test/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/test.cfg b/testsuite/java_test/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aeb394aca08f79a59a9cc129a2decea4c18a7d6e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0231-rc-function-RC_Thread02-RC_Thread_04/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_04)
+run(RC_Thread_04,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/RC_Thread_05.java b/testsuite/java_test/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/RC_Thread_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..a69726f71910d9aaf02d6b6fc27b4ce5ab50aecf
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/RC_Thread_05.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RcThread0501 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0502 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0503 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0504 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA1();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0505 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0506 extends Thread {
+    public void run() {
+        RC_Thread_05 rcth01 = new RC_Thread_05();
+        try {
+            rcth01.setA3_a(5);
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread05GC extends Thread {
+    public void run() {
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 50);
+        if (start == 50) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+public class RC_Thread_05 {
+    private static volatile RcThread05A1 a1Main = null;
+    private static volatile RcThread05A4 a4Main = null;
+    private static volatile RcThread05A5 a5Main = null;
+    RC_Thread_05() {
+        try {
+            a1Main = new RcThread05A1();
+            a1Main.a2_0 = new RcThread05A2();
+            a1Main.a2_0.a3_0 = new RcThread05A3();
+            a4Main = new RcThread05A4();
+            a5Main = new RcThread05A5();
+            a4Main.a1_0 = a1Main;
+            a5Main.a1_0 = a1Main;
+            a1Main.a2_0.a3_0.a1_0 = a1Main;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    public static void main(String[] args) {
+        cyclePatternWrapper();
+        RcThread05GC gc = new RcThread05GC();
+        gc.run();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void cyclePatternWrapper() {
+        a1Main = new RcThread05A1();
+        a1Main.a2_0 = new RcThread05A2();
+        a1Main.a2_0.a3_0 = new RcThread05A3();
+        a4Main = new RcThread05A4();
+        a5Main = new RcThread05A5();
+        a4Main.a1_0 = a1Main;
+        a5Main.a1_0 = a1Main;
+        a1Main.a2_0.a3_0.a1_0 = a1Main;
+        a1Main = null;
+        a4Main = null;
+        a5Main = null;
+        Runtime.getRuntime().gc();    // 单独构造一次Cycle_B_1_00180环，通过gc学习到环模式
+    }
+    private static void rcTestcaseMainWrapper() {
+        RcThread0501 t1 = new RcThread0501();
+        RcThread0502 t2 = new RcThread0502();
+        RcThread0503 t3 = new RcThread0503();
+        RcThread0504 t4 = new RcThread0504();
+        RcThread0505 t5 = new RcThread0505();
+        RcThread0506 t6 = new RcThread0506();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        t6.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+            t6.join();
+        }catch(InterruptedException e){
+            // do nothing
+        }
+    }
+    void setA1null() {
+        a1Main = null;
+    }
+    void setA4null() {
+        a4Main = null;
+    }
+    void setA5null() {
+        a5Main = null;
+    }
+    void setA1() {
+        try {
+            this.a1Main = new RcThread05A1();
+            a1Main.a2_0 = new RcThread05A2();
+            a1Main.a2_0.a3_0 = new RcThread05A3();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    void checkA3() {
+        try {
+            int a = a1Main.a2_0.a3_0.a;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    void setA3_a(int a) {
+        try {
+            this.a1Main.a2_0.a3_0.a = a;
+        } catch (NullPointerException e) { }
+    }
+    static class RcThread05A1 {
+        volatile RcThread05A2 a2_0;
+        int a;
+        int sum;
+        RcThread05A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+    }
+    static class RcThread05A2 {
+        volatile RcThread05A3 a3_0;
+        int a;
+        int sum;
+        RcThread05A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+    }
+    static class RcThread05A3 {
+        volatile RcThread05A1 a1_0;
+        int a;
+        int sum;
+        RcThread05A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+    }
+    static class RcThread05A4 {
+        volatile RcThread05A1 a1_0;
+        int a;
+        int sum;
+        RcThread05A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+    }
+    static class RcThread05A5 {
+        volatile RcThread05A1 a1_0;
+        int a;
+        int sum;
+        RcThread05A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/expected.txt b/testsuite/java_test/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/test.cfg b/testsuite/java_test/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..64d8836157ae61a6c13b193bb213c2dede54922c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0232-rc-function-RC_Thread02-RC_Thread_05/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_05)
+run(RC_Thread_05,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/RC_Thread_06.java b/testsuite/java_test/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/RC_Thread_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..a7b79d01a8aba797b052b064e906f38d8cedb106
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/RC_Thread_06.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RcThread0601 extends Thread {
+    public void run() {
+        RC_Thread_06 rcth01 = new RC_Thread_06();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0602 extends Thread {
+    public void run() {
+        RC_Thread_06 rcth01 = new RC_Thread_06();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0603 extends Thread {
+    public void run() {
+        RC_Thread_06 rcth01 = new RC_Thread_06();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread06GC extends Thread {
+    public void run() {
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 50);
+        if (start == 50) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+public class RC_Thread_06 {
+    private static volatile RcThread06A1 a1Main = null;
+    private static volatile RcThread06A5 a5Main = null;
+    RC_Thread_06() {
+        try {
+            a1Main = new RcThread06A1();
+            a1Main.a2_0 = new RcThread06A2();
+            a1Main.a2_0.a3_0 = new RcThread06A3();
+            a1Main.a2_0.a3_0.a4_0 = new RcThread06A4();
+            a1Main.a2_0.a3_0.a4_0.a1_0 = a1Main;
+            a5Main = new RcThread06A5();
+            a1Main.a2_0.a3_0.a4_0.a6_0 = new RcThread06A6();
+            a1Main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5Main;
+            a5Main.a3_0 = a1Main.a2_0.a3_0;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    public static void main(String[] args) {
+        cyclePatternWrapper();
+        Runtime.getRuntime().gc();
+        RcThread06GC gc = new RcThread06GC();
+        gc.run();
+        int start = 0;
+        for (;start < 20; start++) {
+            rcTestcaseMainWrapper();
+        }
+        if (start == 20) {
+            System.out.println("ExpectResult");
+        }
+    }
+    private static void cyclePatternWrapper() {
+        a1Main = new RcThread06A1();
+        a1Main.a2_0 = new RcThread06A2();
+        a1Main.a2_0.a3_0 = new RcThread06A3();
+        a1Main.a2_0.a3_0.a4_0 = new RcThread06A4();
+        a1Main.a2_0.a3_0.a4_0.a1_0 = a1Main;
+        a5Main = new RcThread06A5();
+        a1Main.a2_0.a3_0.a4_0.a6_0 = new RcThread06A6();
+        a1Main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5Main;
+        a5Main.a3_0 = a1Main.a2_0.a3_0;
+        a1Main = null;
+        a5Main = null;
+        a1Main = new RcThread06A1();
+        a1Main.a2_0 = new RcThread06A2();
+        a1Main.a2_0.a3_0 = new RcThread06A3();
+        a1Main.a2_0.a3_0.a4_0 = new RcThread06A4();
+        a1Main.a2_0.a3_0.a4_0.a1_0 = a1Main;
+        a1Main = null;
+        a1Main = new RcThread06A1();
+        a1Main.a2_0 = new RcThread06A2();
+        a1Main.a2_0.a3_0 = new RcThread06A3();
+        a1Main.a2_0.a3_0.a4_0 = new RcThread06A4();
+        a1Main.a2_0.a3_0.a4_0.a1_0 = a1Main;
+        a5Main = new RcThread06A5();
+        a1Main.a2_0.a3_0.a4_0.a6_0 = new RcThread06A6();
+        a1Main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5Main;
+        a5Main.a3_0 = a1Main.a2_0.a3_0;
+        a1Main.a2_0.a3_0 = null;
+        a1Main = null;
+        a5Main = null;     //总共三种环类型
+    }
+    private static void rcTestcaseMainWrapper() {
+        RcThread0601 t1 = new RcThread0601();
+        RcThread0602 t2 = new RcThread0602();
+        RcThread0603 t3 = new RcThread0603();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e){
+            // do nothing
+        }
+    }
+    void setA1null() {
+        a1Main = null;
+    }
+    void setA4null() {
+        try {
+            a1Main.a2_0.a3_0.a4_0 = null;
+            a5Main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) { }
+    }
+    void setA5null() {
+        a5Main = null;
+    }
+    static class RcThread06A1 {
+        volatile RcThread06A2 a2_0;
+        volatile RcThread06A4 a4_0;
+        int a;
+        int sum;
+        RcThread06A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+    }
+    static class RcThread06A2 {
+        volatile RcThread06A3 a3_0;
+        int a;
+        int sum;
+        RcThread06A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+    }
+    static class RcThread06A3 {
+        volatile RcThread06A4 a4_0;
+        int a;
+        int sum;
+        RcThread06A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+    }
+    static class RcThread06A4 {
+        volatile RcThread06A1 a1_0;
+        volatile RcThread06A6 a6_0;
+        int a;
+        int sum;
+        RcThread06A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+    }
+    static class RcThread06A5 {
+        volatile RcThread06A3 a3_0;
+        int a;
+        int sum;
+        RcThread06A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+    }
+    static class RcThread06A6 {
+        volatile RcThread06A5 a5_0;
+        int a;
+        int sum;
+        RcThread06A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/expected.txt b/testsuite/java_test/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/test.cfg b/testsuite/java_test/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b852288a145e515c786682d5c11f0d76ea90a956
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0233-rc-function-RC_Thread02-RC_Thread_06/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_06)
+run(RC_Thread_06,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/RC_Thread_07.java b/testsuite/java_test/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/RC_Thread_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..4166bc00ce0cd86136364a1777fdcbdf5a10e7e9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/RC_Thread_07.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RcThread0701 extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        try {
+            rcth01.modifyA1();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0702 extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        try {
+            rcth01.checkA4();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread0703 extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        try {
+            rcth01.setA5();
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+}
+class RcThread07GC extends Thread {
+    public void run() {
+        RC_Thread_07 rcth01 = new RC_Thread_07();
+        int start = 0;
+        do {
+            Runtime.getRuntime().gc();
+            start++;
+        } while (start < 20);
+    }
+}
+public class RC_Thread_07 {
+    private static volatile RcThread07A1 a1_main = null;
+    private static volatile RcThread07A5 a5_main = null;
+    RC_Thread_07() {
+        try {
+            RcThread07A1 a1_1 = new RcThread07A1();
+            a1_1.a2_0 = new RcThread07A2();
+            a1_1.a2_0.a3_0 = new RcThread07A3();
+            a1_1.a2_0.a3_0.a4_0 = new RcThread07A4();
+            a1_1.a2_0.a3_0.a4_0.a1_0 = a1_1;
+            RcThread07A5 a5_1 = new RcThread07A5();
+            a1_1.a2_0.a3_0.a4_0.a6_0 = new RcThread07A6();
+            a1_1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_1;
+            a5_1.a3_0 = a1_1.a2_0.a3_0;
+            a1_main = a1_1;
+            a5_main = a5_1;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    public static void main(String[] args) {
+        cyclePatternWrapper();
+        Runtime.getRuntime().gc();
+        cyclePatternWrapper();
+        Runtime.getRuntime().gc();
+        RcThread07GC gc = new RcThread07GC();
+        gc.start();
+        rcTestcaseMainWrapper();
+        rcTestcaseMainWrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void cyclePatternWrapper() {
+        RcThread07A1 a1 = new RcThread07A1();
+        a1.a2_0 = new RcThread07A2();
+        a1.a2_0.a3_0 = new RcThread07A3();
+        a1.a2_0.a3_0.a4_0 = new RcThread07A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        RcThread07A5 a5 = new RcThread07A5();
+        a1.a2_0.a3_0.a4_0.a6_0 = new RcThread07A6();
+        a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+        a5.a3_0 = a1.a2_0.a3_0;
+        a1 = null;
+        a5 = null;
+        a1 = new RcThread07A1();
+        a1.a2_0 = new RcThread07A2();
+        a1.a2_0.a3_0 = new RcThread07A3();
+        a1.a2_0.a3_0.a4_0 = new RcThread07A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        a1 = null;
+        a1 = new RcThread07A1();
+        a1.a2_0 = new RcThread07A2();
+        a1.a2_0.a3_0 = new RcThread07A3();
+        a1.a2_0.a3_0.a4_0 = new RcThread07A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        a5 = new RcThread07A5();
+        a1.a2_0.a3_0.a4_0.a6_0 = new RcThread07A6();
+        a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+        a5.a3_0 = a1.a2_0.a3_0;
+        a1.a2_0.a3_0 = null;
+        a1 = null;
+        a5 = null;
+    }
+    private static void rcTestcaseMainWrapper() {
+        RcThread0701 t1 = new RcThread0701();
+        RcThread0702 t2 = new RcThread0702();
+        RcThread0703 t3 = new RcThread0703();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e){
+            // do nothing
+        }
+    }
+    void modifyA1() {
+        a1_main.a2_0.a3_0 = null;
+        a1_main = null;
+    }
+    void checkA4() {
+        try {
+            int[] arr = new int[2];
+            arr[0] = a5_main.a3_0.a4_0.sum;
+            arr[1] = a5_main.a3_0.a4_0.a;
+        } catch (NullPointerException e) {
+            // do nothing
+        }
+    }
+    void setA5() {
+        RcThread07A5 a5 = new RcThread07A5();
+        a5 = this.a5_main;
+        a5_main = null;
+    }
+    static class RcThread07A1 {
+        volatile RcThread07A2 a2_0;
+        volatile RcThread07A4 a4_0;
+        int a;
+        int sum;
+        RcThread07A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RcThread07A2 {
+        volatile RcThread07A3 a3_0;
+        int a;
+        int sum;
+        RcThread07A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RcThread07A3 {
+        volatile RcThread07A4 a4_0;
+        int a;
+        int sum;
+        RcThread07A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    static class RcThread07A4 {
+        volatile RcThread07A1 a1_0;
+        volatile RcThread07A6 a6_0;
+        int a;
+        int sum;
+        RcThread07A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    static class RcThread07A5 {
+        volatile RcThread07A3 a3_0;
+        int a;
+        int sum;
+        RcThread07A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RcThread07A6 {
+        volatile RcThread07A5 a5_0;
+        int a;
+        int sum;
+        RcThread07A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/expected.txt b/testsuite/java_test/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/test.cfg b/testsuite/java_test/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..818fd266a04f42e698ece480bcb36d990a2432ff
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0234-rc-function-RC_Thread02-RC_Thread_07/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_07)
+run(RC_Thread_07,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/RC_Thread_08.java b/testsuite/java_test/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/RC_Thread_08.java
new file mode 100755
index 0000000000000000000000000000000000000000..8911b9b73610047a9244a8e353dae85000d98f95
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/RC_Thread_08.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Runtime;
+class RC_Thread_08_1 extends Thread {
+    public void run() {
+        RC_Thread_08 rcth01 = new RC_Thread_08();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_08_2 extends Thread {
+    public void run() {
+        RC_Thread_08 rcth01 = new RC_Thread_08();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_08_3 extends Thread {
+    public void run() {
+        RC_Thread_08 rcth01 = new RC_Thread_08();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_08 {
+    private volatile static RC_Thread_08_A1 a1_main = null;
+    private volatile static RC_Thread_08_A4 a4_main = null;
+    private volatile static RC_Thread_08_A6 a6_main = null;
+    RC_Thread_08() {
+        try {
+            RC_Thread_08_A1 a1 = new RC_Thread_08_A1("a1");
+            RC_Thread_08_A4 a4 = new RC_Thread_08_A4("a4");
+            RC_Thread_08_A6 a6 = new RC_Thread_08_A6("a6");
+            a1.a2_0 = new RC_Thread_08_A2("a2_0");
+            a1.a2_0.a3_0 = new RC_Thread_08_A3("a3_0");
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1.a2_0.a3_0.a5_0 = new RC_Thread_08_A5("a5_0");
+            a1.a2_0.a3_0.a5_0.a6_0 = a6;
+            a6.a1_0 = a1;
+            a6.a3_0 = a1.a2_0.a3_0;
+            a4.a5_0 = a1.a2_0.a3_0.a5_0;
+            a6.a4_0 = a4;
+            a1_main = a1;
+            a4_main = a4;
+            a6_main = a6;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+		System.out.println("ExpectResult");
+    }
+    private static void cycle_pattern_wrapper(){
+        RC_Thread_08_A1 a1 = new RC_Thread_08_A1("a1");
+        RC_Thread_08_A4 a4 = new RC_Thread_08_A4("a4");
+        RC_Thread_08_A6 a6 = new RC_Thread_08_A6("a6");
+        a1.a2_0 = new RC_Thread_08_A2("a2_0");
+        a1.a2_0.a3_0 = new RC_Thread_08_A3("a3_0");
+        a1.a2_0.a3_0.a1_0 = a1;
+        a1.a2_0.a3_0.a5_0 = new RC_Thread_08_A5("a5_0");
+        a1.a2_0.a3_0.a5_0.a6_0 = a6;
+        a6.a1_0 = a1;
+        a6.a3_0 = a1.a2_0.a3_0;
+        a4.a5_0 = a1.a2_0.a3_0.a5_0;
+        a6.a4_0 = a4;
+        a1=null;
+        a4=null;
+        a6=null;
+        Runtime.getRuntime().gc();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_08_1 t_00010= new RC_Thread_08_1();
+        RC_Thread_08_2 t_00020= new RC_Thread_08_2();
+        RC_Thread_08_3 t_00030= new RC_Thread_08_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+        } catch (InterruptedException e) {}
+        }
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RC_Thread_08_A3("new-a3");
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA3null() {
+        RC_Thread_08_A3 a3 = new RC_Thread_08_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    static class RC_Thread_08_A1 {
+        volatile RC_Thread_08_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_08_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RC_Thread_08_A2 {
+        volatile RC_Thread_08_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_08_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_08_A3 {
+        volatile RC_Thread_08_A1 a1_0;
+        volatile RC_Thread_08_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_08_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    static class RC_Thread_08_A4 {
+        volatile RC_Thread_08_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_08_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    static class RC_Thread_08_A5 {
+        volatile RC_Thread_08_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_08_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    static class RC_Thread_08_A6 {
+        volatile RC_Thread_08_A1 a1_0;
+        volatile RC_Thread_08_A3 a3_0;
+        volatile RC_Thread_08_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_08_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/expected.txt b/testsuite/java_test/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/test.cfg b/testsuite/java_test/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8dc8471140d7825c13733d09e0e54d9f9839ddad
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0235-rc-function-RC_Thread02-RC_Thread_08/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_08)
+run(RC_Thread_08,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/RC_Thread_09.java b/testsuite/java_test/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/RC_Thread_09.java
new file mode 100755
index 0000000000000000000000000000000000000000..26935a9d415c660cb8123e7150743ba7239d8dcf
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/RC_Thread_09.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RC_Thread_09_1 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_09_2 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_09_3 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_09_4 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_09_5 extends Thread {
+    public void run() {
+        RC_Thread_09 rcth01 = new RC_Thread_09();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_09 {
+    private static RC_Thread_09_A1 a1_main = null;
+    private static RC_Thread_09_A2 a2_main = null;
+    private static RC_Thread_09_A3 a3_main = null;
+    private static RC_Thread_09_A4 a4_main = null;
+    RC_Thread_09() {
+        try {
+            a1_main = new RC_Thread_09_A1("a1_main");
+            a2_main = new RC_Thread_09_A2("a2_main");
+            a3_main = new RC_Thread_09_A3("a3_main");
+            a4_main = new RC_Thread_09_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_09_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_09_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a2_main.b2_0 = new RC_Thread_09_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_09_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a3_main.b2_0 = new RC_Thread_09_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_09_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+            a3_main.c2_0 = new RC_Thread_09_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+            a4_main.b3_0 = new RC_Thread_09_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_09_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_09_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_09_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_09_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_09_D3("d3_0");
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_09_1 t1 = new RC_Thread_09_1();
+        RC_Thread_09_2 t2 = new RC_Thread_09_2();
+        RC_Thread_09_3 t3 = new RC_Thread_09_3();
+        RC_Thread_09_4 t4 = new RC_Thread_09_4();
+        RC_Thread_09_5 t5 = new RC_Thread_09_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void setA1null() {
+        a1_main = null;
+    }
+    public void setA2null() {
+        a2_main = null;
+    }
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_09_D2("new");
+            a3_main = new RC_Thread_09_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA3null() {
+        a3_main = null;
+    }
+    public void setA4null() {
+        a4_main = null;
+    }
+    class RC_Thread_09_A1 {
+        RC_Thread_09_B1 b1_0;
+        RC_Thread_09_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+    class RC_Thread_09_A2 {
+        RC_Thread_09_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+    class RC_Thread_09_A3 {
+        RC_Thread_09_B2 b2_0;
+        RC_Thread_09_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+    class RC_Thread_09_A4 {
+        RC_Thread_09_B3 b3_0;
+        RC_Thread_09_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+    class RC_Thread_09_B1 {
+        RC_Thread_09_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class RC_Thread_09_B2 {
+        RC_Thread_09_C1 c1_0;
+        RC_Thread_09_D1 d1_0;
+        RC_Thread_09_D2 d2_0;
+        RC_Thread_09_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+    class RC_Thread_09_B3 {
+        RC_Thread_09_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class RC_Thread_09_C1 {
+        RC_Thread_09_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class RC_Thread_09_C2 {
+        RC_Thread_09_D2 d2_0;
+        RC_Thread_09_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+    class RC_Thread_09_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_09_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_09_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_09_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/expected.txt b/testsuite/java_test/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/test.cfg b/testsuite/java_test/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b086faf8655c63b3c9cf2d7a92dd0942af8b4dac
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0236-rc-function-RC_Thread02-RC_Thread_09/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_09)
+run(RC_Thread_09,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/RC_Thread_10.java b/testsuite/java_test/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/RC_Thread_10.java
new file mode 100755
index 0000000000000000000000000000000000000000..f008b7be34802879c4965221ddef86588eadc4d9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/RC_Thread_10.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RC_Thread_10_1 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.addSum();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_10_2 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.ModifyB4();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_10_3 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.deleteA1();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_10_4 extends Thread {
+    public void run() {
+        RC_Thread_10 rcth01 = new RC_Thread_10("rcth01");
+        try {
+            rcth01.setA1(null);
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_10 {
+    private static RC_Thread_10_A1 a1 = null;
+    RC_Thread_10(String str) {
+        try {
+            a1 = new RC_Thread_10_A1("a1");
+            a1.b1_0 = new RC_Thread_10_B1("b1_0");
+            a1.b1_0.c1_0 = new RC_Thread_10_C1("c1_0");
+            a1.b1_0.c2_0 = new RC_Thread_10_C2("c2_0");
+            a1.b1_0.c3_0 = new RC_Thread_10_C3("c3_0");
+            a1.b2_0 = new RC_Thread_10_B2("b2_0");
+            a1.b3_0 = new RC_Thread_10_B3("b3_0");
+            a1.b4_0 = new RC_Thread_10_B4("b4_0");
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_10_1 t1 = new RC_Thread_10_1();
+        RC_Thread_10_2 t2 = new RC_Thread_10_2();
+        RC_Thread_10_3 t3 = new RC_Thread_10_3();
+        RC_Thread_10_4 t4 = new RC_Thread_10_4();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void deleteA1() {
+        a1 = null;
+    }
+    public void ModifyB4() {
+        try {
+            a1.b4_0 = new RC_Thread_10_B4("new_b4");
+        } catch (NullPointerException e) {
+        }
+    }
+    public void addSum() {
+        try {
+            a1.add();
+            a1.b1_0.add();
+            a1.b2_0.add();
+            a1.b3_0.add();
+            a1.b4_0.add();
+            a1.b1_0.c1_0.add();
+            a1.b1_0.c2_0.add();
+            a1.b1_0.c3_0.add();
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA1(RC_Thread_10_A1 a1) {
+        this.a1 = a1;
+    }
+    class RC_Thread_10_A1 {
+        RC_Thread_10_B1 b1_0;
+        RC_Thread_10_B2 b2_0;
+        RC_Thread_10_B3 b3_0;
+        RC_Thread_10_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_10_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class RC_Thread_10_B1 {
+        RC_Thread_10_C1 c1_0;
+        RC_Thread_10_C2 c2_0;
+        RC_Thread_10_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_10_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class RC_Thread_10_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_10_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_10_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_10_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_10_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_10_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_10_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_10_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_10_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_10_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_10_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_10_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/expected.txt b/testsuite/java_test/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/test.cfg b/testsuite/java_test/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..66c97f6087160f4012cbdd85d9e99feb18fa3c9a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0237-rc-function-RC_Thread02-RC_Thread_10/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_10)
+run(RC_Thread_10,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/RC_Thread_11.java b/testsuite/java_test/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/RC_Thread_11.java
new file mode 100755
index 0000000000000000000000000000000000000000..4fa65165870720be438f0f7f9e7681a6dc466314
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/RC_Thread_11.java
@@ -0,0 +1,348 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RC_Thread_11_1 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_11_2 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA2null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_11_3 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_11_4 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_11_5 extends Thread {
+    public void run() {
+        RC_Thread_11 rcth01 = new RC_Thread_11();
+        try {
+            rcth01.setA4();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_11 {
+    private static RC_Thread_11_A1 a1_main = null;
+    private static RC_Thread_11_A2 a2_main = null;
+    private static RC_Thread_11_A3 a3_main = null;
+    private static RC_Thread_11_A4 a4_main = null;
+    RC_Thread_11() {
+        try {
+            a1_main = new RC_Thread_11_A1("a1_main");
+            a2_main = new RC_Thread_11_A2("a2_main");
+            a3_main = new RC_Thread_11_A3("a3_main");
+            a4_main = new RC_Thread_11_A4("a4_main");
+            a1_main.b1_0 = new RC_Thread_11_B1("b1_0");
+            a1_main.d1_0 = new RC_Thread_11_D1("d1_0");
+            a1_main.b1_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a2_main.b2_0 = new RC_Thread_11_B2("b2_0");
+            a2_main.b2_0.c1_0 = new RC_Thread_11_C1("c1_0");
+            a2_main.b2_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a2_main.b2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a2_main.b2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+            a2_main.b2_0.c1_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a3_main.b2_0 = new RC_Thread_11_B2("b2_0");
+            a3_main.b2_0.c1_0 = new RC_Thread_11_C1("c1_0");
+            a3_main.b2_0.c1_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a3_main.b2_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a3_main.b2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a3_main.b2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+            a3_main.c2_0 = new RC_Thread_11_C2("c2_0");
+            a3_main.c2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a3_main.c2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+            a4_main.b3_0 = new RC_Thread_11_B3("b3_0");
+            a4_main.b3_0.c1_0 = new RC_Thread_11_C1("c1_0");
+            a4_main.b3_0.c1_0.d1_0 = new RC_Thread_11_D1("d1_0");
+            a4_main.c2_0 = new RC_Thread_11_C2("c2_0");
+            a4_main.c2_0.d2_0 = new RC_Thread_11_D2("d2_0");
+            a4_main.c2_0.d3_0 = new RC_Thread_11_D3("d3_0");
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+	rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_11_1 t1 = new RC_Thread_11_1();
+        RC_Thread_11_2 t2 = new RC_Thread_11_2();
+        RC_Thread_11_3 t3 = new RC_Thread_11_3();
+        RC_Thread_11_4 t4 = new RC_Thread_11_4();
+        RC_Thread_11_5 t5 = new RC_Thread_11_5();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void setA1null() {
+        a1_main = null;
+    }
+    public void setA2null() {
+        a2_main = null;
+    }
+    public void setA3() {
+        try {
+            a3_main.c2_0.d2_0 = new RC_Thread_11_D2("new");
+            a3_main = new RC_Thread_11_A3("a3_new");
+            a3_main = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA3null() {
+        a3_main = null;
+    }
+    public void setA4() {
+        try {
+            a4_main = new RC_Thread_11_A4("a4_new");
+        } catch (NullPointerException e) {
+        }
+    }
+    class RC_Thread_11_A1 {
+        RC_Thread_11_B1 b1_0;
+        RC_Thread_11_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+    class RC_Thread_11_A2 {
+        RC_Thread_11_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+    class RC_Thread_11_A3 {
+        RC_Thread_11_B2 b2_0;
+        RC_Thread_11_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+    class RC_Thread_11_A4 {
+        RC_Thread_11_B3 b3_0;
+        RC_Thread_11_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+    class RC_Thread_11_B1 {
+        RC_Thread_11_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class RC_Thread_11_B2 {
+        RC_Thread_11_C1 c1_0;
+        RC_Thread_11_D1 d1_0;
+        RC_Thread_11_D2 d2_0;
+        RC_Thread_11_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+    class RC_Thread_11_B3 {
+        RC_Thread_11_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class RC_Thread_11_C1 {
+        RC_Thread_11_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class RC_Thread_11_C2 {
+        RC_Thread_11_D2 d2_0;
+        RC_Thread_11_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+    class RC_Thread_11_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_11_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_11_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_11_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/expected.txt b/testsuite/java_test/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/test.cfg b/testsuite/java_test/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..353717772c1249f1ff1ba66ceb45fdda7dcdcd5e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0238-rc-function-RC_Thread02-RC_Thread_11/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_11)
+run(RC_Thread_11,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/RC_Thread_12.java b/testsuite/java_test/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/RC_Thread_12.java
new file mode 100755
index 0000000000000000000000000000000000000000..55c4e2330b68d13bb6cb116d5d6163e0cb36e494
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/RC_Thread_12.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Runtime;
+class RC_Thread_12_1 extends Thread {
+    public void run() {
+        RC_Thread_12 rcth01 = new RC_Thread_12();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_12_2 extends Thread {
+    public void run() {
+        RC_Thread_12 rcth01 = new RC_Thread_12();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_12_3 extends Thread {
+    public void run() {
+        RC_Thread_12 rcth01 = new RC_Thread_12();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_12 {
+    private static RC_Thread_12_A1 a1_main = null;
+    private static RC_Thread_12_A4 a4_main = null;
+    private static RC_Thread_12_A5 a5_main = null;
+    RC_Thread_12() {
+        try {
+            a1_main = new RC_Thread_12_A1();
+            a1_main.a2_0 = new RC_Thread_12_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_12_A3();
+            a4_main = new RC_Thread_12_A4();
+            a5_main = new RC_Thread_12_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void cycle_pattern_wrapper(){
+        a1_main = new RC_Thread_12_A1();
+        a1_main.a2_0 = new RC_Thread_12_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_12_A3();
+        a4_main = new RC_Thread_12_A4();
+        a5_main = new RC_Thread_12_A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main=null;
+        a4_main=null;
+        a5_main=null;
+        Runtime.getRuntime().gc();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_12_1 t1 = new RC_Thread_12_1();
+        RC_Thread_12_2 t2 = new RC_Thread_12_2();
+        RC_Thread_12_3 t3 = new RC_Thread_12_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void setA1null() {
+        a1_main = null;
+    }
+    public void setA4null() {
+        a4_main = null;
+    }
+    public void setA5null() {
+        a5_main = null;
+    }
+    static class RC_Thread_12_A1 {
+        RC_Thread_12_A2 a2_0;
+        int a;
+        int sum;
+        RC_Thread_12_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RC_Thread_12_A2 {
+        RC_Thread_12_A3 a3_0;
+        int a;
+        int sum;
+        RC_Thread_12_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_12_A3 {
+        RC_Thread_12_A1 a1_0;
+        int a;
+        int sum;
+        RC_Thread_12_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    static class RC_Thread_12_A4 {
+        RC_Thread_12_A1 a1_0;
+        int a;
+        int sum;
+        RC_Thread_12_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    static class RC_Thread_12_A5 {
+        RC_Thread_12_A1 a1_0;
+        int a;
+        int sum;
+        RC_Thread_12_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/expected.txt b/testsuite/java_test/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/test.cfg b/testsuite/java_test/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a0565e5d231f3fe16511cd3950d8defe27f55f1e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0239-rc-function-RC_Thread02-RC_Thread_12/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_12)
+run(RC_Thread_12,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/RC_Thread_13.java b/testsuite/java_test/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/RC_Thread_13.java
new file mode 100755
index 0000000000000000000000000000000000000000..8a7d61d88e67ab5e57c3b53e975d85833cfdfd7f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/RC_Thread_13.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Runtime;
+class RC_Thread_13_1 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_13_2 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_13_3 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_13_4 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA1();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_13_5 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_13_6 extends Thread {
+    public void run() {
+        RC_Thread_13 rcth01 = new RC_Thread_13();
+        try {
+            rcth01.setA3_a(5);
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_13 {
+    private static RC_Thread_13_A1 a1_main = null;
+    private static RC_Thread_13_A4 a4_main = null;
+    private static RC_Thread_13_A5 a5_main = null;
+    RC_Thread_13() {
+        try {
+            a1_main = new RC_Thread_13_A1();
+            a1_main.a2_0 = new RC_Thread_13_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_13_A3();
+            a4_main = new RC_Thread_13_A4();
+            a5_main = new RC_Thread_13_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_13_1 t1 = new RC_Thread_13_1();
+        RC_Thread_13_2 t2 = new RC_Thread_13_2();
+        RC_Thread_13_3 t3 = new RC_Thread_13_3();
+        RC_Thread_13_4 t4 = new RC_Thread_13_4();
+        RC_Thread_13_5 t5 = new RC_Thread_13_5();
+        RC_Thread_13_6 t6 = new RC_Thread_13_6();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        t5.start();
+        t6.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+            t5.join();
+            t6.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void setA1null() {
+        a1_main = null;
+    }
+    public void setA4null() {
+        a4_main = null;
+    }
+    public void setA5null() {
+        a5_main = null;
+    }
+    public void setA1() {
+        try {
+            this.a1_main = new RC_Thread_13_A1();
+            a1_main.a2_0 = new RC_Thread_13_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_13_A3();
+        } catch (NullPointerException e) {
+        }
+    }
+    public void checkA3() {
+        try {
+            int a = a1_main.a2_0.a3_0.a;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA3_a(int a) {
+        try {
+            this.a1_main.a2_0.a3_0.a = a;
+        } catch (NullPointerException e) {
+        }
+    }
+    class RC_Thread_13_A1 {
+        RC_Thread_13_A2 a2_0;
+        int a;
+        int sum;
+        RC_Thread_13_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class RC_Thread_13_A2 {
+        RC_Thread_13_A3 a3_0;
+        int a;
+        int sum;
+        RC_Thread_13_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class RC_Thread_13_A3 {
+        RC_Thread_13_A1 a1_0;
+        int a;
+        int sum;
+        RC_Thread_13_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class RC_Thread_13_A4 {
+        RC_Thread_13_A1 a1_0;
+        int a;
+        int sum;
+        RC_Thread_13_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class RC_Thread_13_A5 {
+        RC_Thread_13_A1 a1_0;
+        int a;
+        int sum;
+        RC_Thread_13_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/expected.txt b/testsuite/java_test/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/test.cfg b/testsuite/java_test/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2085e96d788bb140c3e164058d3ac87ef0ecfc53
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0240-rc-function-RC_Thread02-RC_Thread_13/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_13)
+run(RC_Thread_13,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/RC_Thread_14.java b/testsuite/java_test/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/RC_Thread_14.java
new file mode 100755
index 0000000000000000000000000000000000000000..63c3b2c31331cd23a08fd3e888f7b072f2a2f7fb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/RC_Thread_14.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Runtime;
+class RC_Thread_14_1 extends Thread {
+    public void run() {
+        RC_Thread_14 rcth01 = new RC_Thread_14();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+class RC_Thread_14_2 extends Thread {
+    public void run() {
+        RC_Thread_14 rcth01 = new RC_Thread_14();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+class RC_Thread_14_3 extends Thread {
+    public void run() {
+        RC_Thread_14 rcth01 = new RC_Thread_14();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+public class RC_Thread_14 {
+    private static RC_Thread_14_A1 a1_main = null;
+    private static RC_Thread_14_A5 a5_main = null;
+    RC_Thread_14() {
+        try {
+            a1_main = new RC_Thread_14_A1();
+            a1_main.a2_0 = new RC_Thread_14_A2();
+            a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+            a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+            a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+            a5_main = new RC_Thread_14_A5();
+            a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_14_A6();
+            a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+            a5_main.a3_0 = a1_main.a2_0.a3_0;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+	Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void cycle_pattern_wrapper(){
+        a1_main = new RC_Thread_14_A1();
+        a1_main.a2_0 = new RC_Thread_14_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_14_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_14_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main=null;
+        a5_main=null;
+        a1_main = new RC_Thread_14_A1();
+        a1_main.a2_0 = new RC_Thread_14_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a1_main=null;
+        a1_main = new RC_Thread_14_A1();
+        a1_main.a2_0 = new RC_Thread_14_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_14_A3();
+        a1_main.a2_0.a3_0.a4_0 = new RC_Thread_14_A4();
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_14_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_14_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a2_0.a3_0=null;
+        a1_main=null;
+        a5_main=null;
+        //Runtime.getRuntime().gc();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_14_1 t1 = new RC_Thread_14_1();
+        RC_Thread_14_2 t2 = new RC_Thread_14_2();
+        RC_Thread_14_3 t3 = new RC_Thread_14_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void setA1null() {
+        a1_main = null;
+    }
+    public void setA4null() {
+        try {
+            a1_main.a2_0.a3_0.a4_0 = null;
+            a5_main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA5null() {
+        a5_main = null;
+    }
+    static class RC_Thread_14_A1 {
+        RC_Thread_14_A2 a2_0;
+        RC_Thread_14_A4 a4_0;
+        int a;
+        int sum;
+        RC_Thread_14_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RC_Thread_14_A2 {
+        RC_Thread_14_A3 a3_0;
+        int a;
+        int sum;
+        RC_Thread_14_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_14_A3 {
+        RC_Thread_14_A4 a4_0;
+        int a;
+        int sum;
+        RC_Thread_14_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    static class RC_Thread_14_A4 {
+        RC_Thread_14_A1 a1_0;
+        RC_Thread_14_A6 a6_0;
+        int a;
+        int sum;
+        RC_Thread_14_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    static class RC_Thread_14_A5 {
+        RC_Thread_14_A3 a3_0;
+        int a;
+        int sum;
+        RC_Thread_14_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_14_A6 {
+        RC_Thread_14_A5 a5_0;
+        int a;
+        int sum;
+        RC_Thread_14_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/expected.txt b/testsuite/java_test/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/test.cfg b/testsuite/java_test/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1d99c28d2b3103e32bc2cba889a1a1d39f967dbd
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0241-rc-function-RC_Thread02-RC_Thread_14/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_14)
+run(RC_Thread_14,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/RC_Thread_15.java b/testsuite/java_test/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/RC_Thread_15.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f5fb7367a1b5c73d9fe2655a99f8e943f8c2fe7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/RC_Thread_15.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Runtime;
+class RC_Thread_15_1 extends Thread {
+    public void run() {
+        RC_Thread_15 rcth01 = new RC_Thread_15();
+        try {
+            rcth01.ModifyA1();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_15_2 extends Thread {
+    public void run() {
+        RC_Thread_15 rcth01 = new RC_Thread_15();
+        try {
+            rcth01.checkA4();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_15_3 extends Thread {
+    public void run() {
+        RC_Thread_15 rcth01 = new RC_Thread_15();
+        try {
+            rcth01.setA5();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_15 {
+    private static RC_Thread_15_A1 a1_main = null;
+    private static RC_Thread_15_A5 a5_main = null;
+    RC_Thread_15() {
+        try {
+            RC_Thread_15_A1 a1 = new RC_Thread_15_A1();
+            a1.a2_0 = new RC_Thread_15_A2();
+            a1.a2_0.a3_0 = new RC_Thread_15_A3();
+            a1.a2_0.a3_0.a4_0 = new RC_Thread_15_A4();
+            a1.a2_0.a3_0.a4_0.a1_0 = a1;
+            RC_Thread_15_A5 a5 = new RC_Thread_15_A5();
+            a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_15_A6();
+            a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+            a5.a3_0 = a1.a2_0.a3_0;
+            a1_main = a1;
+            a5_main = a5;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void cycle_pattern_wrapper(){
+        RC_Thread_15_A1 a1 = new RC_Thread_15_A1();
+        a1.a2_0 = new RC_Thread_15_A2();
+        a1.a2_0.a3_0 = new RC_Thread_15_A3();
+        a1.a2_0.a3_0.a4_0 = new RC_Thread_15_A4();
+        a1.a2_0.a3_0.a4_0.a1_0 = a1;
+        RC_Thread_15_A5 a5 = new RC_Thread_15_A5();
+        a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_15_A6();
+        a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+        a5.a3_0 = a1.a2_0.a3_0;
+        a1=null;
+        a5=null;
+        Runtime.getRuntime().gc();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_15_1 t1 = new RC_Thread_15_1();
+        RC_Thread_15_2 t2 = new RC_Thread_15_2();
+        RC_Thread_15_3 t3 = new RC_Thread_15_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void ModifyA1() {
+        a1_main.a2_0.a3_0 = null;
+        a1_main = null;
+    }
+    public void checkA4() {
+        try {
+            int[] arr = new int[2];
+            arr[0] = a5_main.a3_0.a4_0.sum;
+            arr[1] = a5_main.a3_0.a4_0.a;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA5() {
+        RC_Thread_15_A5 a5 = new RC_Thread_15_A5();
+        a5 = this.a5_main;
+        a5_main = null;
+    }
+    static class RC_Thread_15_A1 {
+        RC_Thread_15_A2 a2_0;
+        RC_Thread_15_A4 a4_0;
+        int a;
+        int sum;
+        RC_Thread_15_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RC_Thread_15_A2 {
+        RC_Thread_15_A3 a3_0;
+        int a;
+        int sum;
+        RC_Thread_15_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_15_A3 {
+        RC_Thread_15_A4 a4_0;
+        int a;
+        int sum;
+        RC_Thread_15_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    static class RC_Thread_15_A4 {
+        RC_Thread_15_A1 a1_0;
+        RC_Thread_15_A6 a6_0;
+        int a;
+        int sum;
+        RC_Thread_15_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    static class RC_Thread_15_A5 {
+        RC_Thread_15_A3 a3_0;
+        int a;
+        int sum;
+        RC_Thread_15_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_15_A6 {
+        RC_Thread_15_A5 a5_0;
+        int a;
+        int sum;
+        RC_Thread_15_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/expected.txt b/testsuite/java_test/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/test.cfg b/testsuite/java_test/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6603b517456566605ecf31928ae6600501632d14
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0242-rc-function-RC_Thread02-RC_Thread_15/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_15)
+run(RC_Thread_15,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/RC_Thread_16.java b/testsuite/java_test/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/RC_Thread_16.java
new file mode 100755
index 0000000000000000000000000000000000000000..b158185f79ada6026fa4a4899f9b53b607d257ec
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/RC_Thread_16.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Runtime;
+class RC_Thread_16_1 extends Thread {
+    public void run() {
+        RC_Thread_16 rcth01 = new RC_Thread_16();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_16_2 extends Thread {
+    public void run() {
+        RC_Thread_16 rcth01 = new RC_Thread_16();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_16_3 extends Thread {
+    public void run() {
+        RC_Thread_16 rcth01 = new RC_Thread_16();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_16 {
+    private static RC_Thread_16_A1 a1_main = null;
+    private static RC_Thread_16_A4 a4_main = null;
+    private static RC_Thread_16_A6 a6_main = null;
+    RC_Thread_16() {
+        try {
+            RC_Thread_16_A1 a1 = new RC_Thread_16_A1("a1");
+            RC_Thread_16_A4 a4 = new RC_Thread_16_A4("a4");
+            RC_Thread_16_A6 a6 = new RC_Thread_16_A6("a6");
+            a1.a2_0 = new RC_Thread_16_A2("a2_0");
+            a1.a2_0.a3_0 = new RC_Thread_16_A3("a3_0");
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1.a2_0.a3_0.a5_0 = new RC_Thread_16_A5("a5_0");
+            a1.a2_0.a3_0.a5_0.a6_0 = a6;
+            a6.a1_0 = a1;
+            a6.a3_0 = a1.a2_0.a3_0;
+            a4.a5_0 = a1.a2_0.a3_0.a5_0;
+            a6.a4_0 = a4;
+            a1_main = a1;
+            a4_main = a4;
+            a6_main = a6;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+		Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+		System.out.println("ExpectResult");
+    }
+    private static void cycle_pattern_wrapper(){
+        RC_Thread_16_A1 a1 = new RC_Thread_16_A1("a1");
+        RC_Thread_16_A4 a4 = new RC_Thread_16_A4("a4");
+        RC_Thread_16_A6 a6 = new RC_Thread_16_A6("a6");
+        a1.a2_0 = new RC_Thread_16_A2("a2_0");
+        a1.a2_0.a3_0 = new RC_Thread_16_A3("a3_0");
+        a1.a2_0.a3_0.a1_0 = a1;
+        a1.a2_0.a3_0.a5_0 = new RC_Thread_16_A5("a5_0");
+        a1.a2_0.a3_0.a5_0.a6_0 = a6;
+        a6.a1_0 = a1;
+        a6.a3_0 = a1.a2_0.a3_0;
+        a4.a5_0 = a1.a2_0.a3_0.a5_0;
+        a6.a4_0 = a4;
+        a1=null;
+        a4=null;
+        a6=null;
+        Runtime.getRuntime().gc();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_16_1 t_00010 = new RC_Thread_16_1();
+        RC_Thread_16_2 t_00020 = new RC_Thread_16_2();
+        RC_Thread_16_3 t_00030 = new RC_Thread_16_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RC_Thread_16_A3("new-a3");
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA3null() {
+        RC_Thread_16_A3 a3 = new RC_Thread_16_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    static class RC_Thread_16_A1 {
+        RC_Thread_16_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_16_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RC_Thread_16_A2 {
+        RC_Thread_16_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_16_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_16_A3 {
+        RC_Thread_16_A1 a1_0;
+        RC_Thread_16_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_16_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    static class RC_Thread_16_A4 {
+        RC_Thread_16_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_16_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    static class RC_Thread_16_A5 {
+        RC_Thread_16_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_16_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    static class RC_Thread_16_A6 {
+        RC_Thread_16_A1 a1_0;
+        RC_Thread_16_A3 a3_0;
+        RC_Thread_16_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_16_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/expected.txt b/testsuite/java_test/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/test.cfg b/testsuite/java_test/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f7569ca67d7d0348132404cfd48943bd7ca0757d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0243-rc-function-RC_Thread02-RC_Thread_16/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_16)
+run(RC_Thread_16,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/RC_Thread_17.java b/testsuite/java_test/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/RC_Thread_17.java
new file mode 100755
index 0000000000000000000000000000000000000000..16c19b8d6da5bd6ca7dc46fe016df1e9045f3156
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/RC_Thread_17.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Runtime;
+class RC_Thread_17_1 extends Thread {
+    public void run() {
+        RC_Thread_17 rcth01 = new RC_Thread_17();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_17_2 extends Thread {
+    public void run() {
+        RC_Thread_17 rcth01 = new RC_Thread_17();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_17_3 extends Thread {
+    public void run() {
+        RC_Thread_17 rcth01 = new RC_Thread_17();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_17 {
+    private static RC_Thread_17_A1 a1_main = null;
+    private static RC_Thread_17_A4 a4_main = null;
+    private static RC_Thread_17_A5 a5_main = null;
+    private static RC_Thread_17_A2 a2=null;
+    RC_Thread_17() {
+        try {
+            a1_main = new RC_Thread_17_A1();
+            a2 = new RC_Thread_17_A2();
+            a1_main.a2_0=a2;
+            a1_main.a2_0.a3_0 = new RC_Thread_17_A3();
+            a4_main = new RC_Thread_17_A4();
+            a5_main = new RC_Thread_17_A5();
+            a4_main.a1_0 = a1_main;
+            a5_main.a1_0 = a1_main;
+            a1_main.a2_0.a3_0.a1_0 = a1_main;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void cycle_pattern_wrapper(){
+        a1_main = new RC_Thread_17_A1();
+        a2 = new RC_Thread_17_A2();
+        a1_main.a2_0=a2;
+        a1_main.a2_0.a3_0 = new RC_Thread_17_A3();
+        a4_main = new RC_Thread_17_A4();
+        a5_main = new RC_Thread_17_A5();
+        a4_main.a1_0 = a1_main;
+        a5_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main=null;
+        a4_main=null;
+        a2=null;
+        a5_main=null;
+        Runtime.getRuntime().gc();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_17_1 t1 = new RC_Thread_17_1();
+        RC_Thread_17_2 t2 = new RC_Thread_17_2();
+        RC_Thread_17_3 t3 = new RC_Thread_17_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void setA1null() {
+        a1_main = null;
+    }
+    public void setA4null() {
+        a4_main = null;
+    }
+    public void setA5null() {
+        a5_main = null;
+    }
+    static class RC_Thread_17_A1 {
+        RC_Thread_17_A2 a2_0;
+        int a;
+        int sum;
+        RC_Thread_17_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RC_Thread_17_A2 {
+        RC_Thread_17_A3 a3_0;
+        int a;
+        int sum;
+        RC_Thread_17_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_17_A3 {
+        RC_Thread_17_A1 a1_0;
+        int a;
+        int sum;
+        RC_Thread_17_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    static class RC_Thread_17_A4 {
+        RC_Thread_17_A1 a1_0;
+        int a;
+        int sum;
+        RC_Thread_17_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    static class RC_Thread_17_A5 {
+        RC_Thread_17_A1 a1_0;
+        int a;
+        int sum;
+        RC_Thread_17_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/expected.txt b/testsuite/java_test/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/test.cfg b/testsuite/java_test/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..944eae68b49546772d86b0d30ba53e798da780a4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0244-rc-function-RC_Thread02-RC_Thread_17/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_17)
+run(RC_Thread_17,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/RC_Thread_18.java b/testsuite/java_test/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/RC_Thread_18.java
new file mode 100755
index 0000000000000000000000000000000000000000..40035dc0dac89fe2d8ac09bc1fb9bdedcb41a3cb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/RC_Thread_18.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Runtime;
+class RC_Thread_18_1 extends Thread {
+    public void run() {
+        RC_Thread_18 rcth01 = new RC_Thread_18();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_18_2 extends Thread {
+    public void run() {
+        RC_Thread_18 rcth01 = new RC_Thread_18();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_18_3 extends Thread {
+    public void run() {
+        RC_Thread_18 rcth01 = new RC_Thread_18();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_18 {
+    private volatile static RC_Thread_18_A1 a1_main = null;
+    private volatile static RC_Thread_18_A4 a4_main = null;
+    private volatile static RC_Thread_18_A6 a6_main = null;
+    private static RC_Thread_18_A2 a2=null;
+    RC_Thread_18() {
+        try {
+            RC_Thread_18_A1 a1 = new RC_Thread_18_A1("a1");
+            RC_Thread_18_A4 a4 = new RC_Thread_18_A4("a4");
+            RC_Thread_18_A6 a6 = new RC_Thread_18_A6("a6");
+            a2 = new RC_Thread_18_A2("a2_0");
+            a1.a2_0=a2;
+            a1.a2_0.a3_0 = new RC_Thread_18_A3("a3_0");
+            a1.a2_0.a3_0.a1_0 = a1;
+            a1.a2_0.a3_0.a5_0 = new RC_Thread_18_A5("a5_0");
+            a1.a2_0.a3_0.a5_0.a6_0 = a6;
+            a6.a1_0 = a1;
+            a6.a3_0 = a1.a2_0.a3_0;
+            a4.a5_0 = a1.a2_0.a3_0.a5_0;
+            a6.a4_0 = a4;
+            a1_main = a1;
+            a4_main = a4;
+            a6_main = a6;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void cycle_pattern_wrapper(){
+        RC_Thread_18_A1 a1 = new RC_Thread_18_A1("a1");
+        RC_Thread_18_A4 a4 = new RC_Thread_18_A4("a4");
+        RC_Thread_18_A6 a6 = new RC_Thread_18_A6("a6");
+        a2 = new RC_Thread_18_A2("a2_0");
+        a1.a2_0=a2;
+        a1.a2_0.a3_0 = new RC_Thread_18_A3("a3_0");
+        a1.a2_0.a3_0.a1_0 = a1;
+        a1.a2_0.a3_0.a5_0 = new RC_Thread_18_A5("a5_0");
+        a1.a2_0.a3_0.a5_0.a6_0 = a6;
+        a6.a1_0 = a1;
+        a6.a3_0 = a1.a2_0.a3_0;
+        a4.a5_0 = a1.a2_0.a3_0.a5_0;
+        a6.a4_0 = a4;
+        a1=null;
+        a2=null;
+        a4=null;
+        a6=null;
+        Runtime.getRuntime().gc();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_18_1 t_00010= new RC_Thread_18_1();
+        RC_Thread_18_2 t_00020= new RC_Thread_18_2();
+        RC_Thread_18_3 t_00030= new RC_Thread_18_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+        } catch (InterruptedException e) {}
+    }
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RC_Thread_18_A3("new-a3");
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA3null() {
+        RC_Thread_18_A3 a3 = new RC_Thread_18_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    static class RC_Thread_18_A1 {
+        volatile RC_Thread_18_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_18_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RC_Thread_18_A2 {
+        volatile RC_Thread_18_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_18_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_18_A3 {
+        volatile RC_Thread_18_A1 a1_0;
+        volatile RC_Thread_18_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_18_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    static class RC_Thread_18_A4 {
+        volatile RC_Thread_18_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_18_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    static class RC_Thread_18_A5 {
+        volatile RC_Thread_18_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_18_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    static class RC_Thread_18_A6 {
+        volatile RC_Thread_18_A1 a1_0;
+        volatile RC_Thread_18_A3 a3_0;
+        volatile RC_Thread_18_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_18_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/expected.txt b/testsuite/java_test/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/test.cfg b/testsuite/java_test/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..46d7d6430ac46cdd3ae0819fb264c4352c998bed
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0245-rc-function-RC_Thread02-RC_Thread_18/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_18)
+run(RC_Thread_18,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/RC_Thread_19.java b/testsuite/java_test/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/RC_Thread_19.java
new file mode 100755
index 0000000000000000000000000000000000000000..abf28516cf67fcfcd0a4f0bc203a3955e701b1d6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/RC_Thread_19.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class RC_Thread_19_1 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.addSum();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_19_2 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.ModifyB4();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_19_3 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.deleteA1();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RC_Thread_19_4 extends Thread {
+    public void run() {
+        RC_Thread_19 rcth01 = new RC_Thread_19("rcth01");
+        try {
+            rcth01.setA1(null);
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RC_Thread_19 {
+    private static RC_Thread_19_A1 a1 = null;
+    private volatile  static RC_Thread_19_B4 b4;
+    RC_Thread_19(String str) {
+        try {
+            a1 = new RC_Thread_19_A1("a1");
+            a1.b1_0 = new RC_Thread_19_B1("b1_0");
+            a1.b1_0.c1_0 = new RC_Thread_19_C1("c1_0");
+            a1.b1_0.c2_0 = new RC_Thread_19_C2("c2_0");
+            a1.b1_0.c3_0 = new RC_Thread_19_C3("c3_0");
+            a1.b2_0 = new RC_Thread_19_B2("b2_0");
+            a1.b3_0 = new RC_Thread_19_B3("b3_0");
+            b4=new RC_Thread_19_B4("b4_0");
+            a1.b4_0 =b4;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_19_1 t1 = new RC_Thread_19_1();
+        RC_Thread_19_2 t2 = new RC_Thread_19_2();
+        RC_Thread_19_3 t3 = new RC_Thread_19_3();
+        RC_Thread_19_4 t4 = new RC_Thread_19_4();
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void deleteA1() {
+        a1 = null;
+    }
+    public void ModifyB4() {
+        try {
+            a1.b4_0 = new RC_Thread_19_B4("new_b4");
+        } catch (NullPointerException e) {
+        }
+    }
+    public void addSum() {
+        try {
+            a1.add();
+            a1.b1_0.add();
+            a1.b2_0.add();
+            a1.b3_0.add();
+            a1.b4_0.add();
+            a1.b1_0.c1_0.add();
+            a1.b1_0.c2_0.add();
+            a1.b1_0.c3_0.add();
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA1(RC_Thread_19_A1 a1) {
+        this.a1 = a1;
+    }
+    class RC_Thread_19_A1 {
+        RC_Thread_19_B1 b1_0;
+        RC_Thread_19_B2 b2_0;
+        RC_Thread_19_B3 b3_0;
+        RC_Thread_19_B4 b4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_19_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            b3_0 = null;
+            b4_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a + b3_0.a + b4_0.a;
+        }
+    }
+    class RC_Thread_19_B1 {
+        RC_Thread_19_C1 c1_0;
+        RC_Thread_19_C2 c2_0;
+        RC_Thread_19_C3 c3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_19_B1(String strObjectName) {
+            c1_0 = null;
+            c2_0 = null;
+            c3_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + c2_0.a + c3_0.a;
+        }
+    }
+    class RC_Thread_19_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_19_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_19_B3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_19_B3(String strObjectName) {
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_19_B4 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_19_B4(String strObjectName) {
+            a = 204;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_19_C1 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_19_C1(String strObjectName) {
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_19_C2 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_19_C2(String strObjectName) {
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class RC_Thread_19_C3 {
+        int a;
+        int sum;
+        String strObjectName;
+        RC_Thread_19_C3(String strObjectName) {
+            a = 303;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/expected.txt b/testsuite/java_test/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/test.cfg b/testsuite/java_test/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e86769c3435b0d4464a11d96f615e49cb9048814
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0246-rc-function-RC_Thread02-RC_Thread_19/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_19)
+run(RC_Thread_19,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/RC_Thread_20.java b/testsuite/java_test/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/RC_Thread_20.java
new file mode 100755
index 0000000000000000000000000000000000000000..d740a84de9cf0cdef22bf343a53c81b40c7810a7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/RC_Thread_20.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Runtime;
+class RC_Thread_20_1 extends Thread {
+    public void run() {
+        RC_Thread_20 rcth01 = new RC_Thread_20();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+class RC_Thread_20_2 extends Thread {
+    public void run() {
+        RC_Thread_20 rcth01 = new RC_Thread_20();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+class RC_Thread_20_3 extends Thread {
+    public void run() {
+        RC_Thread_20 rcth01 = new RC_Thread_20();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+}
+public class RC_Thread_20 {
+    private static RC_Thread_20_A1 a1_main = null;
+    private static RC_Thread_20_A5 a5_main = null;
+    private static RC_Thread_20_A4 a4;
+    RC_Thread_20() {
+        try {
+            RC_Thread_20_A1 a1 = new RC_Thread_20_A1();
+            a1.a2_0 = new RC_Thread_20_A2();
+            a1.a2_0.a3_0 = new RC_Thread_20_A3();
+            RC_Thread_20_A4 a4_temp=new RC_Thread_20_A4();
+            a1.a2_0.a3_0.a4_0 = a4_temp;
+            a1.a2_0.a3_0.a4_0.a1_0 = a1;
+            RC_Thread_20_A5 a5 = new RC_Thread_20_A5();
+            a1.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_20_A6();
+            a1.a2_0.a3_0.a4_0.a6_0.a5_0 = a5;
+            a5.a3_0 = a1.a2_0.a3_0;
+            a1_main=a1;
+	        a4=a4_temp;
+	        a5_main=a5;
+        } catch (NullPointerException e) {
+        }
+    }
+    public static void main(String[] args) {
+        cycle_pattern_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        Runtime.getRuntime().gc();
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void cycle_pattern_wrapper(){
+        a1_main = new RC_Thread_20_A1();
+        a1_main.a2_0 = new RC_Thread_20_A2();
+        a1_main.a2_0.a3_0 = new RC_Thread_20_A3();
+        a4=new RC_Thread_20_A4();
+        a1_main.a2_0.a3_0.a4_0 = a4;
+        a1_main.a2_0.a3_0.a4_0.a1_0 = a1_main;
+        a5_main = new RC_Thread_20_A5();
+        a1_main.a2_0.a3_0.a4_0.a6_0 = new RC_Thread_20_A6();
+        a1_main.a2_0.a3_0.a4_0.a6_0.a5_0 = a5_main;
+        a5_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main=null;
+        a4=null;
+        a5_main=null;
+        Runtime.getRuntime().gc();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RC_Thread_20_1 t1 = new RC_Thread_20_1();
+        RC_Thread_20_2 t2 = new RC_Thread_20_2();
+        RC_Thread_20_3 t3 = new RC_Thread_20_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (InterruptedException e) {
+        }
+    }
+    public void setA1null() {
+        a1_main = null;
+    }
+    public void setA4null() {
+        try {
+            a1_main.a2_0.a3_0.a4_0 = null;
+            a5_main.a3_0.a4_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA5null() {
+        a5_main = null;
+    }
+    static class RC_Thread_20_A1 {
+        RC_Thread_20_A2 a2_0;
+        RC_Thread_20_A4 a4_0;
+        int a;
+        int sum;
+        RC_Thread_20_A1() {
+            a2_0 = null;
+            a4_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RC_Thread_20_A2 {
+        RC_Thread_20_A3 a3_0;
+        int a;
+        int sum;
+        RC_Thread_20_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_20_A3 {
+        RC_Thread_20_A4 a4_0;
+        int a;
+        int sum;
+        RC_Thread_20_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    static class RC_Thread_20_A4 {
+        RC_Thread_20_A1 a1_0;
+        RC_Thread_20_A6 a6_0;
+        int a;
+        int sum;
+        RC_Thread_20_A4() {
+            a1_0 = null;
+            a6_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a6_0.a;
+        }
+    }
+    static class RC_Thread_20_A5 {
+        RC_Thread_20_A3 a3_0;
+        int a;
+        int sum;
+        RC_Thread_20_A5() {
+            a3_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RC_Thread_20_A6 {
+        RC_Thread_20_A5 a5_0;
+        int a;
+        int sum;
+        RC_Thread_20_A6() {
+            a5_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/expected.txt b/testsuite/java_test/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/test.cfg b/testsuite/java_test/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a8a41fe3232a67f36b7d871bbebf354db8357b1b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0247-rc-function-RC_Thread02-RC_Thread_20/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Thread_20)
+run(RC_Thread_20,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0248-rc-function-RC_Finalize_02/RC_Finalize_02.java b/testsuite/java_test/rc_test/RC0248-rc-function-RC_Finalize_02/RC_Finalize_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..bdbd50831c009e5648010c955e344ea7cbca1728
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0248-rc-function-RC_Finalize_02/RC_Finalize_02.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class RC_Finalize_02 {
+    public void finalize() { 
+	System.out.println("ExpectResult");
+    }
+    public static int run(String argv[], PrintStream out) {
+	return 0;
+    }
+    public static void main(String argv[]) {
+	System.runFinalizersOnExit(true);
+	RC_Finalize_02 testClass = new RC_Finalize_02();
+    }
+} // end RC_Finalize_02
diff --git a/testsuite/java_test/rc_test/RC0248-rc-function-RC_Finalize_02/test.cfg b/testsuite/java_test/rc_test/RC0248-rc-function-RC_Finalize_02/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16eb14334d273f5e5013c5d2ba6b938a09dbef98
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0248-rc-function-RC_Finalize_02/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Finalize_02)
+run(RC_Finalize_02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0249-rc-function-RC_Finalize_03/RC_Finalize_03.java b/testsuite/java_test/rc_test/RC0249-rc-function-RC_Finalize_03/RC_Finalize_03.java
new file mode 100755
index 0000000000000000000000000000000000000000..6769f27db96f40a62080dffd39d590871ad7fe23
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0249-rc-function-RC_Finalize_03/RC_Finalize_03.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+class RC_Finalize_031 {
+    public void finalize() {
+        RC_Finalize_03.fo_finalized = true;
+        RC_Finalize_03.dummy = 1 / RC_Finalize_03.zero;
+        RC_Finalize_03.fo_exception_occerred = false;
+    }
+}
+public class RC_Finalize_03 {
+    public static boolean fo_finalized;
+    public static boolean fo_exception_occerred;
+    public static final long TIMEOUT = 50000;
+    public static final int zero = 0;
+    public static int dummy;
+    public static int run(String argv[], PrintStream out) {
+        fo_finalized = false;
+        fo_exception_occerred = true;
+        RC_Finalize_031 cl1 = new RC_Finalize_031();
+        cl1 = null;
+        long startTime = System.currentTimeMillis();
+        while (System.currentTimeMillis() - startTime < TIMEOUT){
+            Runtime.getRuntime().gc();
+            Runtime.getRuntime().runFinalization();
+            if (!fo_finalized) {
+                try {
+                    Thread.sleep(500);
+                } catch (InterruptedException e) {
+                    //out.println("InterruptedException: " + e);
+                    return 2;
+                } catch(Throwable e) {
+                    //out.println("Throwable: " + e);
+                    return 2;
+                }
+            } else {
+                break;
+            }
+        }
+        if (!fo_finalized) {
+            //out.println("Ok, RC_Finalize_031 was not finalized during " + TIMEOUT/1000 + "sec");
+            return 0;
+        }
+        if (fo_exception_occerred) {
+            return 0;
+        } else {
+            //out.println("Failed: expected exception is not thrown");
+        }
+        return 2;
+    }
+    public static void main(String argv[]) {
+        if(run(argv, System.out)==0)
+			System.out.println("ExpectResult");
+    }
+} // end RC_Finalize_03
diff --git a/testsuite/java_test/rc_test/RC0249-rc-function-RC_Finalize_03/expected.txt b/testsuite/java_test/rc_test/RC0249-rc-function-RC_Finalize_03/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0249-rc-function-RC_Finalize_03/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0249-rc-function-RC_Finalize_03/test.cfg b/testsuite/java_test/rc_test/RC0249-rc-function-RC_Finalize_03/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2f987740a563233576099f963ebf6a24bbdd8e22
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0249-rc-function-RC_Finalize_03/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Finalize_03)
+run(RC_Finalize_03,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/Alloc_11_15x8B.java b/testsuite/java_test/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/Alloc_11_15x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..741f5a560197a20c022d4a7c2742879d2fa1a598
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/Alloc_11_15x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_11_15x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_11_8B=11*8;
+    private final static int MAX_12_8B=12*8;
+    private final static int MAX_13_8B=13*8;
+    private final static int MAX_14_8B=14*8;
+    private final static int MAX_15_8B=15*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*2/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize11 = alloc_test(MAX_11_8B);
+        int countSize12 = alloc_test(MAX_12_8B);
+        int countSize13 = alloc_test(MAX_13_8B);
+        int countSize14 = alloc_test(MAX_14_8B);
+        int countSize15 = alloc_test(MAX_15_8B);
+        //System.out.println(countSize11);
+        //System.out.println(countSize12);
+        //System.out.println(countSize13);
+        //System.out.println(countSize14);
+        //System.out.println(countSize15);
+        if (countSize11 == 853 && countSize12 == 788 && countSize13 == 728 && countSize14 == 681 && countSize15 == 639)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/expected.txt b/testsuite/java_test/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/test.cfg b/testsuite/java_test/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ffa73ca7cc43278c2e035cab5fd8271bd255d6e0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0250-rc-function-ROSAlloc-Alloc_11_15x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_11_15x8B)
+run(Alloc_11_15x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/Alloc_128x8B.java b/testsuite/java_test/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/Alloc_128x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..011d0545e153c544a8ce929cbce637b42eb00e25
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/Alloc_128x8B.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_128x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        int sum=0;
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i=i+3)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+5);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum +=store.size();
+            store=new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_128_8B);
+        //System.out.println(result);
+        if ( result == 243561)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/expected.txt b/testsuite/java_test/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/test.cfg b/testsuite/java_test/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..104d89bb9ed817e7584178c99d9e5872a406ff34
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0251-rc-function-ROSAlloc-Alloc_128x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_128x8B)
+run(Alloc_128x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/Alloc_16_20x8B.java b/testsuite/java_test/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/Alloc_16_20x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..61f2bb043656cc99ea0825aa052c3746fe087184
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/Alloc_16_20x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_16_20x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_16_8B=16*8;
+    private final static int MAX_17_8B=17*8;
+    private final static int MAX_18_8B=18*8;
+    private final static int MAX_19_8B=19*8;
+    private final static int MAX_20_8B=20*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*2/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize16 = alloc_test(MAX_16_8B);
+        int countSize17 = alloc_test(MAX_17_8B);
+        int countSize18 = alloc_test(MAX_18_8B);
+        int countSize19 = alloc_test(MAX_19_8B);
+        int countSize20 = alloc_test(MAX_20_8B);
+        //System.out.println(countSize16);
+        //System.out.println(countSize17);
+        //System.out.println(countSize18);
+        //System.out.println(countSize19);
+        //System.out.println(countSize20);
+        if (countSize16 == 604 && countSize17 == 572 && countSize18 == 542 && countSize19 == 517 && countSize20 == 495)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/expected.txt b/testsuite/java_test/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/test.cfg b/testsuite/java_test/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..441a4a9d2812d4c54bc28aae1b23f1f3ec832618
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0252-rc-function-ROSAlloc-Alloc_16_20x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_16_20x8B)
+run(Alloc_16_20x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/Alloc_192x8B.java b/testsuite/java_test/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/Alloc_192x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..6a5af099a51b718894e29419e629ed35466bb87d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/Alloc_192x8B.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_192x8B {
+    private  static final int PAGE_SIZE = 4*1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_192_8B = 192*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type) {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 + 1 - OBJ_HEADSIZE; i <= slot_type - OBJ_HEADSIZE; i = i + 6) {
+            for (int j = 0; j < (PAGE_SIZE * 1280 / (i + OBJ_HEADSIZE) + 5); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum += store.size();
+            store = new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_192_8B);
+        if ( result == 357534) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/expected.txt b/testsuite/java_test/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/test.cfg b/testsuite/java_test/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f0e33532d66412913be9b001b8f6bd34b10ca0ca
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0253-rc-function-ROSAlloc-Alloc_192x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_192x8B)
+run(Alloc_192x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/Alloc_21_25x8B.java b/testsuite/java_test/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/Alloc_21_25x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..2798fa5f727272e3769ca2498514c909247bbfd9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/Alloc_21_25x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_21_25x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_21_8B=21*8;
+    private final static int MAX_22_8B=22*8;
+    private final static int MAX_23_8B=23*8;
+    private final static int MAX_24_8B=24*8;
+    private final static int MAX_25_8B=25*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*3/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize21 = alloc_test(MAX_21_8B);
+        int countSize22 = alloc_test(MAX_22_8B);
+        int countSize23 = alloc_test(MAX_23_8B);
+        int countSize24 = alloc_test(MAX_24_8B);
+        int countSize25 = alloc_test(MAX_25_8B);
+        //System.out.println(countSize21);
+        //System.out.println(countSize22);
+        //System.out.println(countSize23);
+        //System.out.println(countSize24);
+        //System.out.println(countSize25);
+        if (countSize21 == 674 && countSize22 == 646 && countSize23 == 621 && countSize24 == 599 && countSize25 == 577)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/expected.txt b/testsuite/java_test/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/test.cfg b/testsuite/java_test/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6cd43aafc47c8a08e8913490a73c6a668110a035
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0254-rc-function-ROSAlloc-Alloc_21_25x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_21_25x8B)
+run(Alloc_21_25x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/Alloc_256x8B.java b/testsuite/java_test/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/Alloc_256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..317ffd492c9ec36ff3bb503af3da1e126d9a4d56
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/Alloc_256x8B.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_256x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_256_8B=256*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        int sum=0;
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=1024+1-OBJ_HEADSIZE;i<=slot_type-OBJ_HEADSIZE;i=i+256)
+        {
+            for(int j=0;j<(PAGE_SIZE*5120/(i+OBJ_HEADSIZE)+5);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum +=store.size();
+            store=new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_256_8B);
+        //System.out.println(result);
+        if ( result == 62191)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/expected.txt b/testsuite/java_test/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/test.cfg b/testsuite/java_test/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b722950a04f0af929c5ad1f1a0e97b422508a871
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0255-rc-function-ROSAlloc-Alloc_256x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_256x8B)
+run(Alloc_256x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/Alloc_26_30x8B.java b/testsuite/java_test/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/Alloc_26_30x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f38a15f521c7801fbe32c1190e8251a21318af7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/Alloc_26_30x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_26_30x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_26_8B=26*8;
+    private final static int MAX_27_8B=27*8;
+    private final static int MAX_28_8B=28*8;
+    private final static int MAX_29_8B=29*8;
+    private final static int MAX_30_8B=30*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*3/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize26 = alloc_test(MAX_26_8B);
+        int countSize27 = alloc_test(MAX_27_8B);
+        int countSize28 = alloc_test(MAX_28_8B);
+        int countSize29 = alloc_test(MAX_29_8B);
+        int countSize30 = alloc_test(MAX_30_8B);
+        //System.out.println(countSize26);
+        //System.out.println(countSize27);
+        //System.out.println(countSize28);
+        //System.out.println(countSize29);
+        //System.out.println(countSize30);
+        if (countSize26 == 557 && countSize27 == 538 && countSize28 == 522 && countSize29 == 506 && countSize30 == 492)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/expected.txt b/testsuite/java_test/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/test.cfg b/testsuite/java_test/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..00da8fb72e59e128da0466de2a8ffdbbd15d200d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0256-rc-function-ROSAlloc-Alloc_26_30x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_26_30x8B)
+run(Alloc_26_30x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/Alloc_3_10x8B.java b/testsuite/java_test/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/Alloc_3_10x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..5deedfcb775ed8638df6f0b36d37aa12d4fafe48
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/Alloc_3_10x8B.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_3_10x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_3_8B=3*8;
+    private final static int MAX_4_8B=4*8;
+    private final static int MAX_5_8B=5*8;
+    private final static int MAX_6_8B=6*8;
+    private final static int MAX_7_8B=7*8;
+    private final static int MAX_8_8B=8*8;
+    private final static int MAX_9_8B=9*8;
+    private final static int MAX_10_8B=10*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+            else if(slot_type==1024){
+                i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args){
+        store=new ArrayList<byte[]>();
+        int countSize3 = alloc_test(MAX_3_8B);
+        int countSize4 = alloc_test(MAX_4_8B);
+        int countSize5 = alloc_test(MAX_5_8B);
+        int countSize6 = alloc_test(MAX_6_8B);
+        int countSize7 = alloc_test(MAX_7_8B);
+        int countSize8 = alloc_test(MAX_8_8B);
+        int countSize9 = alloc_test(MAX_9_8B);
+        int countSize10 = alloc_test(MAX_10_8B);
+        if(countSize3==4488 && countSize4==1234 && countSize5==978 && countSize6==816 && countSize7==701 && countSize8==620 &&countSize9==556 && countSize10==505 )
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/expected.txt b/testsuite/java_test/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/test.cfg b/testsuite/java_test/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bf7887580017326f5cb75e54d80764c8d8b655d9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0257-rc-function-ROSAlloc-Alloc_3_10x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_3_10x8B)
+run(Alloc_3_10x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/Alloc_31_35x8B.java b/testsuite/java_test/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/Alloc_31_35x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..291fb6e4e3c151a00e588b0d1a12624d14f8303c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/Alloc_31_35x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_31_35x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_31_8B=31*8;
+    private final static int MAX_32_8B=32*8;
+    private final static int MAX_33_8B=33*8;
+    private final static int MAX_34_8B=34*8;
+    private final static int MAX_35_8B=35*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*4/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize31 = alloc_test(MAX_31_8B);
+        int countSize32 = alloc_test(MAX_32_8B);
+        int countSize33 = alloc_test(MAX_33_8B);
+        int countSize34 = alloc_test(MAX_34_8B);
+        int countSize35 = alloc_test(MAX_35_8B);
+        //System.out.println(countSize31);
+        //System.out.println(countSize32);
+        //System.out.println(countSize33);
+        //System.out.println(countSize34);
+        //System.out.println(countSize35);
+        if (countSize31 == 612 && countSize32 == 596 && countSize33 == 580 && countSize34 == 564 && countSize35 == 550)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/expected.txt b/testsuite/java_test/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/test.cfg b/testsuite/java_test/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0af9adc78b2830b76b951bab1958afe8cb8470f7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0258-rc-function-ROSAlloc-Alloc_31_35x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_31_35x8B)
+run(Alloc_31_35x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/Alloc_36_40x8B.java b/testsuite/java_test/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/Alloc_36_40x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..3022f8ebe8c91c1bcc6b4e3dfd3c8406764f6a61
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/Alloc_36_40x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_36_40x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_36_8B=36*8;
+    private final static int MAX_37_8B=37*8;
+    private final static int MAX_38_8B=38*8;
+    private final static int MAX_39_8B=39*8;
+    private final static int MAX_40_8B=40*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*4/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize36 = alloc_test(MAX_36_8B);
+        int countSize37 = alloc_test(MAX_37_8B);
+        int countSize38 = alloc_test(MAX_38_8B);
+        int countSize39 = alloc_test(MAX_39_8B);
+        int countSize40 = alloc_test(MAX_40_8B);
+        //System.out.println(countSize36);
+        //System.out.println(countSize37);
+        //System.out.println(countSize38);
+        //System.out.println(countSize39);
+        //System.out.println(countSize40);
+        if (countSize36 == 537 && countSize37 == 524 && countSize38 == 512 && countSize39 == 501 && countSize40 == 491)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/expected.txt b/testsuite/java_test/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/test.cfg b/testsuite/java_test/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..15098d4c4dd9935084e44044a4a354c7e73b4c28
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0259-rc-function-ROSAlloc-Alloc_36_40x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_36_40x8B)
+run(Alloc_36_40x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/Alloc_41_45x8B.java b/testsuite/java_test/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/Alloc_41_45x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..f42b1b39d38866722b38db2aa604783dc740cfb8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/Alloc_41_45x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_41_45x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_41_8B=41*8;
+    private final static int MAX_42_8B=42*8;
+    private final static int MAX_43_8B=43*8;
+    private final static int MAX_44_8B=44*8;
+    private final static int MAX_45_8B=45*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*5/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize41 = alloc_test(MAX_41_8B);
+        int countSize42 = alloc_test(MAX_42_8B);
+        int countSize43 = alloc_test(MAX_43_8B);
+        int countSize44 = alloc_test(MAX_44_8B);
+        int countSize45 = alloc_test(MAX_45_8B);
+        //System.out.println(countSize41);
+        //System.out.println(countSize42);
+        //System.out.println(countSize43);
+        //System.out.println(countSize44);
+        //System.out.println(countSize45);
+        if (countSize41 == 581 && countSize42 == 569 && countSize43 == 557 && countSize44 == 547 && countSize45 == 536)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/expected.txt b/testsuite/java_test/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/test.cfg b/testsuite/java_test/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..00de28dbae2cec936f35c969c4ced728e722496f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0260-rc-function-ROSAlloc-Alloc_41_45x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_41_45x8B)
+run(Alloc_41_45x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/Alloc_46_50x8B.java b/testsuite/java_test/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/Alloc_46_50x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..80fc4686154c6735e2bccf6694f55c572d06e2b1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/Alloc_46_50x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_46_50x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_46_8B=46*8;
+    private final static int MAX_47_8B=47*8;
+    private final static int MAX_48_8B=48*8;
+    private final static int MAX_49_8B=49*8;
+    private final static int MAX_50_8B=50*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*5/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize46 = alloc_test(MAX_46_8B);
+        int countSize47 = alloc_test(MAX_47_8B);
+        int countSize48 = alloc_test(MAX_48_8B);
+        int countSize49 = alloc_test(MAX_49_8B);
+        int countSize50 = alloc_test(MAX_50_8B);
+        //System.out.println(countSize46);
+        //System.out.println(countSize47);
+        //System.out.println(countSize48);
+        //System.out.println(countSize49);
+        //System.out.println(countSize50);
+        if (countSize46 == 525 && countSize47 == 516 && countSize48 == 507 && countSize49 == 498 && countSize50 == 489)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/expected.txt b/testsuite/java_test/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/test.cfg b/testsuite/java_test/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..372249e6dee60acedae87f4a8848928d5356b8fc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0261-rc-function-ROSAlloc-Alloc_46_50x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_46_50x8B)
+run(Alloc_46_50x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/Alloc_51_55x8B.java b/testsuite/java_test/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/Alloc_51_55x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..e7398dc2e379ba1e031057aa8f1278fb0f8bd244
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/Alloc_51_55x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_51_55x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_51_8B=51*8;
+    private final static int MAX_52_8B=52*8;
+    private final static int MAX_53_8B=53*8;
+    private final static int MAX_54_8B=54*8;
+    private final static int MAX_55_8B=55*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*6/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize51 = alloc_test(MAX_51_8B);
+        int countSize52 = alloc_test(MAX_52_8B);
+        int countSize53 = alloc_test(MAX_53_8B);
+        int countSize54 = alloc_test(MAX_54_8B);
+        int countSize55 = alloc_test(MAX_55_8B);
+        //System.out.println(countSize51);
+        //System.out.println(countSize52);
+        //System.out.println(countSize53);
+        //System.out.println(countSize54);
+        //System.out.println(countSize55);
+        if (countSize51 == 562 && countSize52 == 553 && countSize53 == 543 && countSize54 == 535 && countSize55 == 526)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/expected.txt b/testsuite/java_test/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/test.cfg b/testsuite/java_test/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..83d5a6719e002c618e76b96670864ece9a7c586f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0262-rc-function-ROSAlloc-Alloc_51_55x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_51_55x8B)
+run(Alloc_51_55x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/Alloc_56_60x8B.java b/testsuite/java_test/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/Alloc_56_60x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..7cee10bfa237fc1d59e9c6c70d2ea657433c83d9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/Alloc_56_60x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_56_60x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_56_8B=56*8;
+    private final static int MAX_57_8B=57*8;
+    private final static int MAX_58_8B=58*8;
+    private final static int MAX_59_8B=59*8;
+    private final static int MAX_60_8B=60*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*6/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize56 = alloc_test(MAX_56_8B);
+        int countSize57 = alloc_test(MAX_57_8B);
+        int countSize58 = alloc_test(MAX_58_8B);
+        int countSize59 = alloc_test(MAX_59_8B);
+        int countSize60 = alloc_test(MAX_60_8B);
+        //System.out.println(countSize56);
+        //System.out.println(countSize57);
+        //System.out.println(countSize58);
+        //System.out.println(countSize59);
+        //System.out.println(countSize60);
+        if (countSize56 == 518 && countSize57 == 511 && countSize58 == 503 && countSize59 == 496 && countSize60 == 488)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/expected.txt b/testsuite/java_test/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/test.cfg b/testsuite/java_test/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3a9f0758013e13338ea532e866931ff9e4e2ba2c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0263-rc-function-ROSAlloc-Alloc_56_60x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_56_60x8B)
+run(Alloc_56_60x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/Alloc_61_64x8B.java b/testsuite/java_test/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/Alloc_61_64x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..ef5c89785fc362e2291c702fb4e22045c5329675
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/Alloc_61_64x8B.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_61_64x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_61_8B=61*8;
+    private final static int MAX_62_8B=62*8;
+    private final static int MAX_63_8B=63*8;
+    private final static int MAX_64_8B=64*8;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        int i;
+        if(slot_type==24){
+            i=1;}
+        else if(slot_type==1024){
+            i=64*8+1-OBJ_HEADSIZE;
+        }else{
+            i=slot_type-2*8+1;
+        }
+        for(;i<=slot_type-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*7/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        store=new ArrayList<byte[]>();
+        return check_size;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int countSize61 = alloc_test(MAX_61_8B);
+        int countSize62 = alloc_test(MAX_62_8B);
+        int countSize63 = alloc_test(MAX_63_8B);
+        int countSize64 = alloc_test(MAX_64_8B);
+        //System.out.println(countSize61);
+        //System.out.println(countSize62);
+        //System.out.println(countSize63);
+        //System.out.println(countSize64);
+        if (countSize61 == 549 && countSize62 == 542 && countSize63 == 535 && countSize64 == 528 )
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/expected.txt b/testsuite/java_test/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/test.cfg b/testsuite/java_test/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ed5056145e01f8689509a7f8973fbe4cce030860
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0264-rc-function-ROSAlloc-Alloc_61_64x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_61_64x8B)
+run(Alloc_61_64x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/Alloc_B256x8B.java b/testsuite/java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/Alloc_B256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..6650ab6b910a9f8f8e66f23e1e74fbee9e517c43
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/Alloc_B256x8B.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class Alloc_B256x8B {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_B256_8B=2*1024*1024;
+    private static ArrayList<byte[]> store;
+    private static int alloc_test(int slot_type){
+        int sum=0;
+        store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=1024*1024-OBJ_HEADSIZE;i<=slot_type-OBJ_HEADSIZE;i=i+256)
+        {
+            for(int j=0;j<(PAGE_SIZE*2560/(i+OBJ_HEADSIZE)+5);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+            sum +=store.size();
+            store=new ArrayList<byte[]>();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        store = new ArrayList<byte[]>();
+        int result = alloc_test(MAX_B256_8B);
+        //System.out.println(result);
+        if ( result == 46939)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/test.cfg b/testsuite/java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ef6c60fc3d0eba2fbaf3c38ace56bb8961666bf0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0265-rc-function-ROSAlloc-Alloc_B256x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_B256x8B)
+run(Alloc_B256x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/Alloc_Thread_128x8B.java b/testsuite/java_test/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/Alloc_Thread_128x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..7b2be9e38623340ccad8fb9e6edfad3fa66a72f9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/Alloc_Thread_128x8B.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_128x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 348510)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_128x8B {
+    public static void main(String[] args){
+        Alloc_Thread_128x8B_01 test1=new Alloc_Thread_128x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/expected.txt b/testsuite/java_test/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/test.cfg b/testsuite/java_test/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c46351c84ab40af69141f3d4db4c34a55606ff66
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0266-rc-function-ROSAlloc-Alloc_Thread_128x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_128x8B)
+run(Alloc_Thread_128x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/Alloc_Thread_18x8B.java b/testsuite/java_test/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/Alloc_Thread_18x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..475e816c93bd1d10887e8eeb79e4a6872d683d12
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/Alloc_Thread_18x8B.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_18x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_18_8B=18*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=1;i<=MAX_18_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*64/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 743858)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_18x8B {
+    public static void main(String[] args){
+        Alloc_Thread_18x8B_01 test1=new Alloc_Thread_18x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/expected.txt b/testsuite/java_test/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/test.cfg b/testsuite/java_test/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d5d71d96247e321e88d1f7cbf04b7669e497ea8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0267-rc-function-ROSAlloc-Alloc_Thread_18x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_18x8B)
+run(Alloc_Thread_18x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/Alloc_Thread_192x8B.java b/testsuite/java_test/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/Alloc_Thread_192x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..bc456b1c1670f6d6d7af143f20491193b5f9c2c5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/Alloc_Thread_192x8B.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_192x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_192_8B=192*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024-OBJ_HEADSIZE;i<=MAX_192_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 201256)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_192x8B {
+    public static void main(String[] args){
+        Alloc_Thread_192x8B_01 test1=new Alloc_Thread_192x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/expected.txt b/testsuite/java_test/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/test.cfg b/testsuite/java_test/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..38a66557339e274981cf1c8f7fd5fa45ee40164e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0268-rc-function-ROSAlloc-Alloc_Thread_192x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_192x8B)
+run(Alloc_Thread_192x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/Alloc_Thread2_128x8B_2.java b/testsuite/java_test/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/Alloc_Thread2_128x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..97ac95f02274dbd1f266d02d98276f257d00c862
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/Alloc_Thread2_128x8B_2.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_128x8B_2_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        try{Thread.sleep(100);}catch(InterruptedException e){}
+        byte[] temp;
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                if(j%10000==0)
+                {
+                    try{Thread.sleep(100);}catch(InterruptedException e){}
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 348510)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_128x8B_2 {
+    public static void main(String[] args){
+        Runtime.getRuntime().gc();
+        Alloc_Thread2_128x8B_2_01 test1=new Alloc_Thread2_128x8B_2_01();
+        test1.start();
+        Alloc_Thread2_128x8B_2_01 test2=new Alloc_Thread2_128x8B_2_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/expected.txt b/testsuite/java_test/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/test.cfg b/testsuite/java_test/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a79128ebfd5a5e339b3aff9eb412daa7cb96392f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0269-rc-function-ROSAlloc-Alloc_Thread2_128x8B_2/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_128x8B_2)
+run(Alloc_Thread2_128x8B_2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/Alloc_Thread2_128x8B.java b/testsuite/java_test/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/Alloc_Thread2_128x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..c18b3eb86df1b3381a08739fe108b2963eff6b9e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/Alloc_Thread2_128x8B.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_128x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 348510)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_128x8B {
+    public static void main(String[] args){
+        Runtime.getRuntime().gc();
+        Alloc_Thread2_128x8B_01 test1=new Alloc_Thread2_128x8B_01();
+        test1.start();
+        Alloc_Thread2_128x8B_01 test2=new Alloc_Thread2_128x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/expected.txt b/testsuite/java_test/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/test.cfg b/testsuite/java_test/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..965c2e58b6b526aac65de000df0801b2ca87278f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0270-rc-function-ROSAlloc-Alloc_Thread2_128x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_128x8B)
+run(Alloc_Thread2_128x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/Alloc_Thread2_18x8B.java b/testsuite/java_test/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/Alloc_Thread2_18x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..e58ccef1ed33d747055bbbc971d12fe511eca9db
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/Alloc_Thread2_18x8B.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_18x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_18_8B=18*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=1;i<=MAX_18_8B-OBJ_HEADSIZE;i+=10)
+        {
+            for(int j=0;j<(PAGE_SIZE*64/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 89848)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_18x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_18x8B_01 test1=new Alloc_Thread2_18x8B_01();
+        test1.start();
+        Alloc_Thread2_18x8B_01 test2=new Alloc_Thread2_18x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check() == true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/expected.txt b/testsuite/java_test/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/test.cfg b/testsuite/java_test/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a72a09069526529d56a16f48466b19f16facbfdc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0271-rc-function-ROSAlloc-Alloc_Thread2_18x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_18x8B)
+run(Alloc_Thread2_18x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/Alloc_Thread2_192x8B_2.java b/testsuite/java_test/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/Alloc_Thread2_192x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a456eae7e303fc306dc34d10cbc2ff97e6f722d3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/Alloc_Thread2_192x8B_2.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_192x8B_2_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_192_8B=192*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        try{Thread.sleep(100);}catch(InterruptedException e){}
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024-OBJ_HEADSIZE;i<=MAX_192_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                if(j%10000==0)
+                {
+                    try{Thread.sleep(100);}catch(InterruptedException e){}
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 201256)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_192x8B_2 {
+    public static void main(String[] args){
+        Alloc_Thread2_192x8B_2_01 test1=new Alloc_Thread2_192x8B_2_01();
+        test1.start();
+        Alloc_Thread2_192x8B_2_01 test2=new Alloc_Thread2_192x8B_2_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true &&test2.check()==true )
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/expected.txt b/testsuite/java_test/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/test.cfg b/testsuite/java_test/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9b070179ce306350af6057ff60f6c66a386b2d32
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0272-rc-function-ROSAlloc-Alloc_Thread2_192x8B_2/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_192x8B_2)
+run(Alloc_Thread2_192x8B_2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/Alloc_Thread2_192x8B.java b/testsuite/java_test/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/Alloc_Thread2_192x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..27d51cdf7b49af7c4d87c95d9648f0d1e542b0bf
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/Alloc_Thread2_192x8B.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_192x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_192_8B=192*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024-OBJ_HEADSIZE;i<=MAX_192_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 201256)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_192x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_192x8B_01 test1=new Alloc_Thread2_192x8B_01();
+        test1.start();
+        Alloc_Thread2_192x8B_01 test2=new Alloc_Thread2_192x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true &&test2.check()==true )
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/expected.txt b/testsuite/java_test/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/test.cfg b/testsuite/java_test/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8982414f82739c3cfe61ebaf28caa7d0fb1a89a1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0273-rc-function-ROSAlloc-Alloc_Thread2_192x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_192x8B)
+run(Alloc_Thread2_192x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2/Alloc_Thread2_256x8B_2.java b/testsuite/java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2/Alloc_Thread2_256x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..1797a74e922a69f0374d2cced3d0d5a996967be9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2/Alloc_Thread2_256x8B_2.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_256x8B_2_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_256_8B=256*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        try{Thread.sleep(100);}catch(InterruptedException e){}
+        byte[] temp;
+        int check_size=0;
+        for(int i=192*8-OBJ_HEADSIZE;i<=MAX_256_8B-OBJ_HEADSIZE;i=i+60)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                if(j%10000==0)
+                {
+                    try{Thread.sleep(100);}catch(InterruptedException e){}
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 214274)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_256x8B_2 {
+    public static void main(String[] args){
+        Alloc_Thread2_256x8B_2_01 test1=new Alloc_Thread2_256x8B_2_01();
+        test1.start();
+        Alloc_Thread2_256x8B_2_01 test2=new Alloc_Thread2_256x8B_2_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2/test.cfg b/testsuite/java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3edab388c2dd08180756bdb5ed5bf8fafba47978
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0274-rc-function-ROSAlloc-Alloc_Thread2_256x8B_2/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_256x8B_2)
+run(Alloc_Thread2_256x8B_2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/Alloc_Thread2_256x8B.java b/testsuite/java_test/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/Alloc_Thread2_256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..0b794797b8d63ecea45de3faefd6fac74162242f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/Alloc_Thread2_256x8B.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_256_8B=256*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=192*8-OBJ_HEADSIZE;i<=MAX_256_8B-OBJ_HEADSIZE;i=i+60)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 214274)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_256x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_256x8B_01 test1=new Alloc_Thread2_256x8B_01();
+        test1.start();
+        Alloc_Thread2_256x8B_01 test2=new Alloc_Thread2_256x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/expected.txt b/testsuite/java_test/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/test.cfg b/testsuite/java_test/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b88363224bcb44dc8589ff776a32ae7565a36dd4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0275-rc-function-ROSAlloc-Alloc_Thread2_256x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_256x8B)
+run(Alloc_Thread2_256x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/Alloc_Thread2_30x8B.java b/testsuite/java_test/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/Alloc_Thread2_30x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..ced0e272af690c6969a19f6e9fe5bac579f8a40f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/Alloc_Thread2_30x8B.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_30x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_30_8B=30*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=144-OBJ_HEADSIZE;i<=MAX_30_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*128/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 271654)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_30x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_30x8B_01 test1=new Alloc_Thread2_30x8B_01();
+        test1.start();
+        Alloc_Thread2_30x8B_01 test2=new Alloc_Thread2_30x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&& test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/expected.txt b/testsuite/java_test/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/test.cfg b/testsuite/java_test/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6989fb708cb53412ba7d0824494d1e6a5eb9d92e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0276-rc-function-ROSAlloc-Alloc_Thread2_30x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_30x8B)
+run(Alloc_Thread2_30x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/Alloc_Thread2_40x8B.java b/testsuite/java_test/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/Alloc_Thread2_40x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..11ddadab50adbc20c57309c03e42aa186acf09ed
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/Alloc_Thread2_40x8B.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_40x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_40_8B=40*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=240-OBJ_HEADSIZE;i<=MAX_40_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*128/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 153513)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_40x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_40x8B_01 test1=new Alloc_Thread2_40x8B_01();
+        test1.start();
+        Alloc_Thread2_40x8B_01 test2=new Alloc_Thread2_40x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/expected.txt b/testsuite/java_test/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/test.cfg b/testsuite/java_test/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..08ae8f9fc4cca0de5363e52543a52fd2c3a66f5b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0277-rc-function-ROSAlloc-Alloc_Thread2_40x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_40x8B)
+run(Alloc_Thread2_40x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/Alloc_Thread2_50x8B.java b/testsuite/java_test/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/Alloc_Thread2_50x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..6092649cac2bc90e3d64548b0b0d21c85225ea5c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/Alloc_Thread2_50x8B.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_50x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_50_8B=50*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=320-OBJ_HEADSIZE;i<=MAX_50_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 237701)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_50x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_50x8B_01 test1=new Alloc_Thread2_50x8B_01();
+        test1.start();
+        Alloc_Thread2_50x8B_01 test2=new Alloc_Thread2_50x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/expected.txt b/testsuite/java_test/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/test.cfg b/testsuite/java_test/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..348e2feb2878c6b355895c9e04fdfcf1c21bb11b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0278-rc-function-ROSAlloc-Alloc_Thread2_50x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_50x8B)
+run(Alloc_Thread2_50x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/Alloc_Thread_256x8B.java b/testsuite/java_test/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/Alloc_Thread_256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..406d656a05d4fed1d992652515e3792020772495
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/Alloc_Thread_256x8B.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_256_8B=256*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=192*8-OBJ_HEADSIZE;i<=MAX_256_8B-OBJ_HEADSIZE;i=i+100)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+       //System.out.println(check_size);
+        if(check_size == 142271)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_256x8B {
+    public static void main(String[] args){
+        Alloc_Thread_256x8B_01 test1=new Alloc_Thread_256x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/expected.txt b/testsuite/java_test/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/test.cfg b/testsuite/java_test/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6833f90db72757f7163195a91345652fd5c1a6d9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0279-rc-function-ROSAlloc-Alloc_Thread_256x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_256x8B)
+run(Alloc_Thread_256x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/Alloc_Thread2_60x8B.java b/testsuite/java_test/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/Alloc_Thread2_60x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..5d06405df076669789fe8ce3308377a98b4b9902
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/Alloc_Thread2_60x8B.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_60x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_60_8B=60*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=400-OBJ_HEADSIZE;i<=MAX_60_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 194350)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_60x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_60x8B_01 test1=new Alloc_Thread2_60x8B_01();
+        test1.start();
+        Alloc_Thread2_60x8B_01 test2=new Alloc_Thread2_60x8B_01();
+        test2.start();
+        try{
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/expected.txt b/testsuite/java_test/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/test.cfg b/testsuite/java_test/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..766e0d456ef1f43e958fecec86984126a6d845a9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0280-rc-function-ROSAlloc-Alloc_Thread2_60x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_60x8B)
+run(Alloc_Thread2_60x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/Alloc_Thread2_64x8B.java b/testsuite/java_test/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/Alloc_Thread2_64x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..67d6ce2f15ba8332856e76e7f68353cf4638c2ce
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/Alloc_Thread2_64x8B.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_64x8B_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_64_8B = 64 * 8;
+    private static boolean checkout = false;
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 480 - OBJ_HEADSIZE; i <= MAX_64_8B - OBJ_HEADSIZE; i++) {
+            for (int j = 0; j < (PAGE_SIZE * 128 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int checkSize = store.size();
+        if (checkSize == 35212) {
+            checkout = true;
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_64x8B {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Thread2_64x8B_01 test1 = new Alloc_Thread2_64x8B_01();
+        test1.start();
+        Alloc_Thread2_64x8B_01 test2 = new Alloc_Thread2_64x8B_01();
+        test2.start();
+        try {
+            test1.join();
+            test2.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/expected.txt b/testsuite/java_test/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/test.cfg b/testsuite/java_test/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dbd25bce119ef645b50820f97427538d2c8237a7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_64x8B)
+run(Alloc_Thread2_64x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/Alloc_Thread2_B256x8B.java b/testsuite/java_test/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/Alloc_Thread2_B256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..ae224499d966ae69fa4305d477f182b84c253df5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/Alloc_Thread2_B256x8B.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread2_B256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_B256_8B=2*1024*1024;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024*1024-OBJ_HEADSIZE;i<=MAX_B256_8B-OBJ_HEADSIZE;i=i+1024)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 38167)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread2_B256x8B {
+    public static void main(String[] args){
+        Alloc_Thread2_B256x8B_01 test1=new Alloc_Thread2_B256x8B_01();
+        test1.start();
+        try{ test1.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Thread2_B256x8B_01 test2=new Alloc_Thread2_B256x8B_01();
+        test2.start();
+        try{ test2.sleep(1000);} catch(InterruptedException e){}
+        try{
+            test1.sleep(1000);
+            test2.sleep(1000);
+            test1.join();
+            test2.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/expected.txt b/testsuite/java_test/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/test.cfg b/testsuite/java_test/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7fc89de9a140fa6cb4f4a8009627706a645bfca4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0282-rc-function-ROSAlloc-Alloc_Thread2_B256x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread2_B256x8B)
+run(Alloc_Thread2_B256x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/Alloc_Thread_30x8B.java b/testsuite/java_test/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/Alloc_Thread_30x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..b7634c3221aa807bafba6f684d00a3d7fb425faa
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/Alloc_Thread_30x8B.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_30x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_30_8B=30*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=144-OBJ_HEADSIZE;i<=MAX_30_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*128/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 271654)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_30x8B {
+    public static void main(String[] args){
+        Alloc_Thread_30x8B_01 test1=new Alloc_Thread_30x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/expected.txt b/testsuite/java_test/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/test.cfg b/testsuite/java_test/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..530f6ed2e79cb105f1765af1ea9bc093ba7d2cf2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0283-rc-function-ROSAlloc-Alloc_Thread_30x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_30x8B)
+run(Alloc_Thread_30x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/Alloc_Thread_40x8B.java b/testsuite/java_test/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/Alloc_Thread_40x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..205ae619d86911a36e23cfb8cbb1fb182b1e0827
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/Alloc_Thread_40x8B.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_40x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_40_8B=40*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=240-OBJ_HEADSIZE;i<=MAX_40_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*128/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 153513)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_40x8B {
+    public static void main(String[] args){
+        Alloc_Thread_40x8B_01 test1=new Alloc_Thread_40x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/expected.txt b/testsuite/java_test/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/test.cfg b/testsuite/java_test/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3cd6bc974ac14696d6f1a13309efa8fded14179a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0284-rc-function-ROSAlloc-Alloc_Thread_40x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_40x8B)
+run(Alloc_Thread_40x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/Alloc_Thread_50x8B.java b/testsuite/java_test/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/Alloc_Thread_50x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..4aead08050ad1186d6c3617247faf8501f60e5c8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/Alloc_Thread_50x8B.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_50x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_50_8B=50*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=320-OBJ_HEADSIZE;i<=MAX_50_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 237701)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_50x8B {
+    public static void main(String[] args){
+        Alloc_Thread_50x8B_01 test1=new Alloc_Thread_50x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/expected.txt b/testsuite/java_test/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/test.cfg b/testsuite/java_test/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..30da75e0b847ac881926a79628b3a77decb6df68
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0285-rc-function-ROSAlloc-Alloc_Thread_50x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_50x8B)
+run(Alloc_Thread_50x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/Alloc_Thread_60x8B.java b/testsuite/java_test/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/Alloc_Thread_60x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..e95e110c40abae7c5cb12703880c694263b4a88a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/Alloc_Thread_60x8B.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_60x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_60_8B=60*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=400-OBJ_HEADSIZE;i<=MAX_60_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*256/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 194350)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_60x8B {
+    public static void main(String[] args){
+        Alloc_Thread_60x8B_01 test1=new Alloc_Thread_60x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/expected.txt b/testsuite/java_test/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/test.cfg b/testsuite/java_test/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a8758300d3b61c7b1c2c65e7874a1d39dc0da6dc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0286-rc-function-ROSAlloc-Alloc_Thread_60x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_60x8B)
+run(Alloc_Thread_60x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/Alloc_Thread_64x8B.java b/testsuite/java_test/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/Alloc_Thread_64x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..be25a74c7f305f64bfa43a4975d34c5cc4482669
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/Alloc_Thread_64x8B.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_64x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_64_8B=64*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=480-OBJ_HEADSIZE;i<=MAX_64_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*512/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 139895)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_64x8B {
+    public static void main(String[] args){
+        Alloc_Thread_64x8B_01 test1=new Alloc_Thread_64x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/expected.txt b/testsuite/java_test/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/test.cfg b/testsuite/java_test/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..22ca23b6dbb6203eeedbf8c521a5587d91691739
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0287-rc-function-ROSAlloc-Alloc_Thread_64x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_64x8B)
+run(Alloc_Thread_64x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/Alloc_Thread_B256x8B.java b/testsuite/java_test/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/Alloc_Thread_B256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..00cffdde310938fb9f5fedc2d7298d2916f7564b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/Alloc_Thread_B256x8B.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Thread_B256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_B256_8B=2*1024*1024;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024*1024-OBJ_HEADSIZE;i<=MAX_B256_8B-OBJ_HEADSIZE;i=i+1024)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 38167)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Thread_B256x8B {
+    public static void main(String[] args){
+        Alloc_Thread_B256x8B_01 test1=new Alloc_Thread_B256x8B_01();
+        test1.start();
+        try{
+            test1.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/expected.txt b/testsuite/java_test/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/test.cfg b/testsuite/java_test/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c849c84cd690a232b325e2aa2ae760e180cf9914
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0288-rc-function-ROSAlloc-Alloc_Thread_B256x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Thread_B256x8B)
+run(Alloc_Thread_B256x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/Alloc_Threadm_128x8B_2.java b/testsuite/java_test/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/Alloc_Threadm_128x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..c2d9279ea6ca63b422aa9851b92045f263636e71
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/Alloc_Threadm_128x8B_2.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_128x8B_2_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        try{Thread.sleep(100);}catch(InterruptedException e){}
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+10)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                if(j%1000==0)
+                {
+                    try{Thread.sleep(100);}catch(InterruptedException e){}
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 28253)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_128x8B_2 {
+    public static void main(String[] args){
+        Alloc_Threadm_128x8B_2_01 test1=new Alloc_Threadm_128x8B_2_01();
+        test1.start();
+        Alloc_Threadm_128x8B_2_01 test2=new Alloc_Threadm_128x8B_2_01();
+        test2.start();
+        Alloc_Threadm_128x8B_2_01 test3=new Alloc_Threadm_128x8B_2_01();
+        test3.start();
+        Alloc_Threadm_128x8B_2_01 test4=new Alloc_Threadm_128x8B_2_01();
+        test4.start();
+        Alloc_Threadm_128x8B_2_01 test5=new Alloc_Threadm_128x8B_2_01();
+        test5.start();
+        Alloc_Threadm_128x8B_2_01 test6=new Alloc_Threadm_128x8B_2_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/expected.txt b/testsuite/java_test/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/test.cfg b/testsuite/java_test/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eac24fb0dd1534fafa2a38bd704aa4954039a133
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0289-rc-function-ROSAlloc-Alloc_Threadm_128x8B_2/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_128x8B_2)
+run(Alloc_Threadm_128x8B_2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/Alloc_Threadm_128x8B.java b/testsuite/java_test/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/Alloc_Threadm_128x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..fb458b5be73507ae5efda6994a22c3c1642caa33
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/Alloc_Threadm_128x8B.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_128x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_128_8B=128*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=512-OBJ_HEADSIZE;i<=MAX_128_8B-OBJ_HEADSIZE;i=i+10)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 28253)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_128x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_128x8B_01 test1=new Alloc_Threadm_128x8B_01();
+        test1.start();
+        Alloc_Threadm_128x8B_01 test2=new Alloc_Threadm_128x8B_01();
+        test2.start();
+        Alloc_Threadm_128x8B_01 test3=new Alloc_Threadm_128x8B_01();
+        test3.start();
+        Alloc_Threadm_128x8B_01 test4=new Alloc_Threadm_128x8B_01();
+        test4.start();
+        Alloc_Threadm_128x8B_01 test5=new Alloc_Threadm_128x8B_01();
+        test5.start();
+        Alloc_Threadm_128x8B_01 test6=new Alloc_Threadm_128x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/expected.txt b/testsuite/java_test/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/test.cfg b/testsuite/java_test/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..78237550d2856a2091d5481ff081d1efed59f3cf
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0290-rc-function-ROSAlloc-Alloc_Threadm_128x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_128x8B)
+run(Alloc_Threadm_128x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/Alloc_Threadm_18x8B.java b/testsuite/java_test/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/Alloc_Threadm_18x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..e0beb0b1ce3fa50272b43ebafa8f98e115b87051
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/Alloc_Threadm_18x8B.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_18x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_18_8B=18*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=1;i<=MAX_18_8B-OBJ_HEADSIZE;i=i+20)
+        {
+            for(int j=0;j<(PAGE_SIZE*64/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 54765)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_18x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_18x8B_01 test1=new Alloc_Threadm_18x8B_01();
+        test1.start();
+        Alloc_Threadm_18x8B_01 test2=new Alloc_Threadm_18x8B_01();
+        test2.start();
+        Alloc_Threadm_18x8B_01 test3=new Alloc_Threadm_18x8B_01();
+        test3.start();
+        Alloc_Threadm_18x8B_01 test4=new Alloc_Threadm_18x8B_01();
+        test4.start();
+        Alloc_Threadm_18x8B_01 test5=new Alloc_Threadm_18x8B_01();
+        test5.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true && test2.check() == true &&test3.check()==true && test4.check() == true&& test5.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/expected.txt b/testsuite/java_test/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/test.cfg b/testsuite/java_test/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7e6a967a056e7db65ea3f7e1f1525a09670d0808
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0291-rc-function-ROSAlloc-Alloc_Threadm_18x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_18x8B)
+run(Alloc_Threadm_18x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/Alloc_Threadm_192x8B_2.java b/testsuite/java_test/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/Alloc_Threadm_192x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..ac8cae2ee278066d4fdd72f326c2da8cf634367f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/Alloc_Threadm_192x8B_2.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_192x8B_2_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_192_8B = 192 * 8;
+    private static boolean checkout = false;
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        int checkSize = 0;
+        for (int i = 1024 - OBJ_HEADSIZE; i <= MAX_192_8B - OBJ_HEADSIZE; i = i + 100) {
+            for (int j = 0; j < (PAGE_SIZE * 512 / (i + OBJ_HEADSIZE) + 10); j++) {
+                if (j % 1000 == 0) {
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException e) {
+                        // do nothing
+                    }
+                }
+                temp = new byte[i];
+                store.add(temp);
+                checkSize += store.size();
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (checkSize == 10117) {
+            checkout = true;
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_192x8B_2 {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_192x8B_2_01 test1 = new Alloc_Threadm_192x8B_2_01();
+        test1.start();
+        Alloc_Threadm_192x8B_2_01 test2 = new Alloc_Threadm_192x8B_2_01();
+        test2.start();
+        Alloc_Threadm_192x8B_2_01 test3 = new Alloc_Threadm_192x8B_2_01();
+        test3.start();
+        Alloc_Threadm_192x8B_2_01 test4 = new Alloc_Threadm_192x8B_2_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() == true && test2.check() == true && test3.check() == true && test4.check() == true) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/expected.txt b/testsuite/java_test/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/test.cfg b/testsuite/java_test/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e160e9d19db75b6bf8f852449f601961849408c1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0292-rc-function-ROSAlloc-Alloc_Threadm_192x8B_2/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_192x8B_2)
+run(Alloc_Threadm_192x8B_2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/Alloc_Threadm_192x8B.java b/testsuite/java_test/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/Alloc_Threadm_192x8B.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ab5273a2beb3f8ab68bb2b343e4995d2b299ef6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/Alloc_Threadm_192x8B.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_192x8B_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_192_8B = 192 * 8;
+    private static boolean checkout = false;
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        int checkSize = 0;
+        for (int i = 1024 - OBJ_HEADSIZE; i <= MAX_192_8B - OBJ_HEADSIZE; i = i + 100) {
+            for (int j = 0; j < (PAGE_SIZE * 512 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+                checkSize++;
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (checkSize == 10117) {
+            checkout = true;
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_192x8B {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_192x8B_01 test1 = new Alloc_Threadm_192x8B_01();
+        test1.start();
+        Alloc_Threadm_192x8B_01 test2 = new Alloc_Threadm_192x8B_01();
+        test2.start();
+        Alloc_Threadm_192x8B_01 test3 = new Alloc_Threadm_192x8B_01();
+        test3.start();
+        Alloc_Threadm_192x8B_01 test4 = new Alloc_Threadm_192x8B_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check() && test3.check() && test4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/expected.txt b/testsuite/java_test/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/test.cfg b/testsuite/java_test/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9a059f2dba7c1702d02cd217449db69f188938c2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_192x8B)
+run(Alloc_Threadm_192x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/Alloc_Threadm_256x8B_2.java b/testsuite/java_test/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/Alloc_Threadm_256x8B_2.java
new file mode 100755
index 0000000000000000000000000000000000000000..f9c01b66976a142fc8880b385c3a2ed755ab954b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/Alloc_Threadm_256x8B_2.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_256x8B_2_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_256_8B = 256 * 8;
+    private static boolean checkOut = false;
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        int check_size = 0;
+        for (int i = 192 * 8 - OBJ_HEADSIZE; i <= MAX_256_8B - OBJ_HEADSIZE; i = i + 800) {
+            for (int j = 0; j < (PAGE_SIZE * 1024 / (i + OBJ_HEADSIZE) + 10); j++) {
+                if (j % 1000 == 0) {
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException e) {
+                        // do nothing
+                    }
+                }
+                temp = new byte[i];
+                store.add(temp);
+                check_size++;
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (check_size == 2740) {
+            checkOut = true;
+        }
+    }
+    public boolean check() {
+        return checkOut;
+    }
+}
+public class Alloc_Threadm_256x8B_2 {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_256x8B_2_01 test1 = new Alloc_Threadm_256x8B_2_01();
+        test1.start();
+        Alloc_Threadm_256x8B_2_01 test2 = new Alloc_Threadm_256x8B_2_01();
+        test2.start();
+        Alloc_Threadm_256x8B_2_01 test3 = new Alloc_Threadm_256x8B_2_01();
+        test3.start();
+        Alloc_Threadm_256x8B_2_01 test4 = new Alloc_Threadm_256x8B_2_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check() && test3.check() && test4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/expected.txt b/testsuite/java_test/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/test.cfg b/testsuite/java_test/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6db7a1f848e2cb6f08a78b18789bf2d571403ee5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_256x8B_2)
+run(Alloc_Threadm_256x8B_2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/Alloc_Threadm_256x8B.java b/testsuite/java_test/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/Alloc_Threadm_256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..b50d40044adbcd950abedc2ae1672363e5ed19c0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/Alloc_Threadm_256x8B.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_256x8B_01 extends Thread {
+    private static final int PAGE_SIZE = 4 * 1024;
+    private static final int OBJ_HEADSIZE = 8;
+    private static final int MAX_256_8B = 256 * 8;
+    private static boolean checkOut = false;
+    public void run() {
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        int checkSize = 0;
+        for (int i = 192 * 8 - OBJ_HEADSIZE; i <= MAX_256_8B - OBJ_HEADSIZE; i = i + 800) {
+            for (int j = 0; j < (PAGE_SIZE * 512 / (i + OBJ_HEADSIZE) + 10); j++) {
+                temp = new byte[i];
+                store.add(temp);
+                checkSize++;
+                store = new ArrayList<byte[]>();
+            }
+        }
+        if (checkSize == 1375) {
+            checkOut = true;
+        }
+    }
+    public boolean check() {
+        return checkOut;
+    }
+}
+public class Alloc_Threadm_256x8B {
+    public static void main(String[] args) {
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_256x8B_01 test1 = new Alloc_Threadm_256x8B_01();
+        test1.start();
+        Alloc_Threadm_256x8B_01 test2 = new Alloc_Threadm_256x8B_01();
+        test2.start();
+        Alloc_Threadm_256x8B_01 test3 = new Alloc_Threadm_256x8B_01();
+        test3.start();
+        Alloc_Threadm_256x8B_01 test4 = new Alloc_Threadm_256x8B_01();
+        test4.start();
+        try {
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (test1.check() && test2.check() && test3.check() && test4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("Error");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/expected.txt b/testsuite/java_test/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/test.cfg b/testsuite/java_test/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..34711bb42a0eb22cccc125ff9ac42aea37ec4444
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_256x8B)
+run(Alloc_Threadm_256x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/Alloc_Threadm_30x8B.java b/testsuite/java_test/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/Alloc_Threadm_30x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..ea65e22c48a0a8e448e3c439ca3e10592964554c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/Alloc_Threadm_30x8B.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_30x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_30_8B=30*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=144-OBJ_HEADSIZE;i<=MAX_30_8B-OBJ_HEADSIZE;i=i+5)
+        {
+            for(int j=0;j<(PAGE_SIZE*64/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 28217)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_30x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_30x8B_01 test1=new Alloc_Threadm_30x8B_01();
+        test1.start();
+        Alloc_Threadm_30x8B_01 test2=new Alloc_Threadm_30x8B_01();
+        test2.start();
+        Alloc_Threadm_30x8B_01 test3=new Alloc_Threadm_30x8B_01();
+        test3.start();
+        Alloc_Threadm_30x8B_01 test4=new Alloc_Threadm_30x8B_01();
+        test4.start();
+        Alloc_Threadm_30x8B_01 test5=new Alloc_Threadm_30x8B_01();
+        test5.start();
+        Alloc_Threadm_30x8B_01 test6=new Alloc_Threadm_30x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&& test2.check()==true&&test3.check()==true&& test4.check()==true&&test5.check()==true&& test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/expected.txt b/testsuite/java_test/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/test.cfg b/testsuite/java_test/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e9edd918d80e6a11a33a7330862957ae10d87bef
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0296-rc-function-ROSAlloc-Alloc_Threadm_30x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_30x8B)
+run(Alloc_Threadm_30x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/Alloc_Threadm_40x8B.java b/testsuite/java_test/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/Alloc_Threadm_40x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..cab97b94f5d444ae7b22484f8fe589055762c17c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/Alloc_Threadm_40x8B.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_40x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_40_8B=40*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=240-OBJ_HEADSIZE;i<=MAX_40_8B-OBJ_HEADSIZE;i+=4)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 29915)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_40x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_40x8B_01 test1=new Alloc_Threadm_40x8B_01();
+        test1.start();
+        Alloc_Threadm_40x8B_01 test2=new Alloc_Threadm_40x8B_01();
+        test2.start();
+        Alloc_Threadm_40x8B_01 test3=new Alloc_Threadm_40x8B_01();
+        test3.start();
+        Alloc_Threadm_40x8B_01 test4=new Alloc_Threadm_40x8B_01();
+        test4.start();
+        Alloc_Threadm_40x8B_01 test5=new Alloc_Threadm_40x8B_01();
+        test5.start();
+        Alloc_Threadm_40x8B_01 test6=new Alloc_Threadm_40x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/expected.txt b/testsuite/java_test/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/test.cfg b/testsuite/java_test/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd48d938e0e38b024155ae2e8a6eca8ddd32b8fd
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0297-rc-function-ROSAlloc-Alloc_Threadm_40x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_40x8B)
+run(Alloc_Threadm_40x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/Alloc_Threadm_50x8B.java b/testsuite/java_test/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/Alloc_Threadm_50x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..665acc792677e2f622f526b3872f14a5c171db0c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/Alloc_Threadm_50x8B.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_50x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_50_8B=50*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=320-OBJ_HEADSIZE;i<=MAX_50_8B-OBJ_HEADSIZE;i=i+5)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 18816)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_50x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_50x8B_01 test1=new Alloc_Threadm_50x8B_01();
+        test1.start();
+        Alloc_Threadm_50x8B_01 test2=new Alloc_Threadm_50x8B_01();
+        test2.start();
+        Alloc_Threadm_50x8B_01 test3=new Alloc_Threadm_50x8B_01();
+        test3.start();
+        Alloc_Threadm_50x8B_01 test4=new Alloc_Threadm_50x8B_01();
+        test4.start();
+        Alloc_Threadm_50x8B_01 test5=new Alloc_Threadm_50x8B_01();
+        test5.start();
+        Alloc_Threadm_50x8B_01 test6=new Alloc_Threadm_50x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/expected.txt b/testsuite/java_test/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/test.cfg b/testsuite/java_test/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5dc6c2fb8159f4f2d103143d0d56f3d6eab60701
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0298-rc-function-ROSAlloc-Alloc_Threadm_50x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_50x8B)
+run(Alloc_Threadm_50x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/Alloc_Threadm_60x8B.java b/testsuite/java_test/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/Alloc_Threadm_60x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..18c983c385358cb0c0baced246cabfd4caee4404
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/Alloc_Threadm_60x8B.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_60x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_60_8B=60*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=400-OBJ_HEADSIZE;i<=MAX_60_8B-OBJ_HEADSIZE;i+=3)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 24509)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_60x8B {
+    public static void main(String[] args){
+        Runtime.getRuntime().gc();
+        Alloc_Threadm_60x8B_01 test1=new Alloc_Threadm_60x8B_01();
+        test1.start();
+        Alloc_Threadm_60x8B_01 test2=new Alloc_Threadm_60x8B_01();
+        test2.start();
+        Alloc_Threadm_60x8B_01 test3=new Alloc_Threadm_60x8B_01();
+        test3.start();
+        Alloc_Threadm_60x8B_01 test4=new Alloc_Threadm_60x8B_01();
+        test4.start();
+        Alloc_Threadm_60x8B_01 test5=new Alloc_Threadm_60x8B_01();
+        test5.start();
+        Alloc_Threadm_60x8B_01 test6=new Alloc_Threadm_60x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/expected.txt b/testsuite/java_test/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/test.cfg b/testsuite/java_test/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..420ee9af4119ad4b53c560a8e22b527711710dcc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0299-rc-function-ROSAlloc-Alloc_Threadm_60x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_60x8B)
+run(Alloc_Threadm_60x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/Alloc_Threadm_64x8B.java b/testsuite/java_test/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/Alloc_Threadm_64x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..79f413277366aa7b49f183f061c6d45fa57a40bb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/Alloc_Threadm_64x8B.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_64x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_64_8B=64*8;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        for(int i=480-OBJ_HEADSIZE;i<=MAX_64_8B-OBJ_HEADSIZE;i++)
+        {
+            for(int j=0;j<(PAGE_SIZE*96/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+            }
+        }
+        int check_size=store.size();
+        //System.out.println(check_size);
+        if(check_size == 26487)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_64x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_64x8B_01 test1=new Alloc_Threadm_64x8B_01();
+        test1.start();
+        Alloc_Threadm_64x8B_01 test2=new Alloc_Threadm_64x8B_01();
+        test2.start();
+        Alloc_Threadm_64x8B_01 test3=new Alloc_Threadm_64x8B_01();
+        test3.start();
+        Alloc_Threadm_64x8B_01 test4=new Alloc_Threadm_64x8B_01();
+        test4.start();
+        Alloc_Threadm_64x8B_01 test5=new Alloc_Threadm_64x8B_01();
+        test5.start();
+        Alloc_Threadm_64x8B_01 test6=new Alloc_Threadm_64x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/expected.txt b/testsuite/java_test/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/test.cfg b/testsuite/java_test/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b877368e669ea471e2206e8a920e6c3d30597c62
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0300-rc-function-ROSAlloc-Alloc_Threadm_64x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_64x8B)
+run(Alloc_Threadm_64x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/Alloc_Threadm_B256x8B.java b/testsuite/java_test/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/Alloc_Threadm_B256x8B.java
new file mode 100755
index 0000000000000000000000000000000000000000..ec7b019e153e4ff12e7f908772b2eb3e1c392bf5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/Alloc_Threadm_B256x8B.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+class Alloc_Threadm_B256x8B_01 extends Thread {
+    private  final static int PAGE_SIZE=4*1024;
+    private final static int OBJ_HEADSIZE = 8;
+    private final static int MAX_B256_8B=2*1024*1024;
+    private static boolean checkout=false;
+    public void run() {
+        ArrayList<byte[]> store=new ArrayList<byte[]>();
+        byte[] temp;
+        int check_size=0;
+        for(int i=1024*1024-OBJ_HEADSIZE;i<=MAX_B256_8B-OBJ_HEADSIZE;i=i+15120)
+        {
+            for(int j=0;j<(PAGE_SIZE*10240/(i+OBJ_HEADSIZE)+10);j++)
+            {
+                temp = new byte[i];
+                store.add(temp);
+                check_size +=store.size();
+                store=new ArrayList<byte[]>();
+            }
+        }
+        //System.out.println(check_size);
+        if(check_size == 2612)
+            checkout=true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class Alloc_Threadm_B256x8B {
+    public static void main(String[] args){
+        Alloc_Threadm_B256x8B_01 test1=new Alloc_Threadm_B256x8B_01();
+        test1.start();
+        try{ test1.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test2=new Alloc_Threadm_B256x8B_01();
+        test2.start();
+        try{ test2.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test3=new Alloc_Threadm_B256x8B_01();
+        test3.start();
+        try{ test3.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test4=new Alloc_Threadm_B256x8B_01();
+        test4.start();
+        try{ test4.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test5=new Alloc_Threadm_B256x8B_01();
+        test5.start();
+        try{ test5.sleep(1000);} catch(InterruptedException e){}
+        Alloc_Threadm_B256x8B_01 test6=new Alloc_Threadm_B256x8B_01();
+        test6.start();
+        try{
+            test1.join();
+            test2.join();
+            test3.join();
+            test4.join();
+            test5.join();
+            test6.join();
+        }catch (InterruptedException e){}
+        if(test1.check()==true&&test2.check()==true && test3.check()==true&&test4.check()==true && test5.check()==true&&test6.check()==true)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/expected.txt b/testsuite/java_test/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/test.cfg b/testsuite/java_test/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a927ee5c73d6a133cb4bd4a354753004dbb7bd58
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0301-rc-function-ROSAlloc-Alloc_Threadm_B256x8B/test.cfg
@@ -0,0 +1,2 @@
+compile(Alloc_Threadm_B256x8B)
+run(Alloc_Threadm_B256x8B,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0302-rc-function-Ref-PhantomRefTest/PhantomRefTest.java b/testsuite/java_test/rc_test/RC0302-rc-function-Ref-PhantomRefTest/PhantomRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..2394cffdfe92277b5d9ede1b662277421032c9e7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0302-rc-function-Ref-PhantomRefTest/PhantomRefTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class PhantomRefTest {
+  static Reference rp;
+  static ReferenceQueue rq = new ReferenceQueue();
+  static int a = 100;
+  static void setPhantomReference() {
+    rp = new PhantomReference<Object>(new Object(), rq);
+    if (rp.get() != null) {
+      a++;
+    }
+  }
+  public static void main(String [] args) throws Exception {
+    Reference r;
+    setPhantomReference();
+    Thread.sleep(2000);
+    while ((r = rq.poll())!=null) {
+      if (!r.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+        a++;
+      }
+    }
+    if (a == 100) {
+      System.out.println("ExpectResult");
+    }
+  }
+}
diff --git a/testsuite/java_test/rc_test/RC0302-rc-function-Ref-PhantomRefTest/expected.txt b/testsuite/java_test/rc_test/RC0302-rc-function-Ref-PhantomRefTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0302-rc-function-Ref-PhantomRefTest/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0302-rc-function-Ref-PhantomRefTest/test.cfg b/testsuite/java_test/rc_test/RC0302-rc-function-Ref-PhantomRefTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3295cd67aef4199f92c5e4266f92d86b3722bfbe
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0302-rc-function-Ref-PhantomRefTest/test.cfg
@@ -0,0 +1,2 @@
+compile(PhantomRefTest)
+run(PhantomRefTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0303-rc-function-Ref-SoftRefTest/SoftRefTest.java b/testsuite/java_test/rc_test/RC0303-rc-function-Ref-SoftRefTest/SoftRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..72ea20b6e240c33b71c39f425a1b88c7604aa236
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0303-rc-function-Ref-SoftRefTest/SoftRefTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class SoftRefTest {
+  static Reference rp;
+  static ReferenceQueue rq = new ReferenceQueue();
+  static int a = 100;
+  static void setSoftReference() {
+    rp = new SoftReference<Object>(new Object(), rq);
+    if (rp.get() == null) {
+      a++;
+    }
+  }
+  static class TriggerRP implements Runnable {
+    public void run() {
+      for (int i = 0; i < 60; i++) {
+        SoftReference sr = new SoftReference(new Object());
+        try {
+          Thread.sleep(50);
+        } catch (Exception e) {}
+      }
+    }
+  }
+  public static void main(String [] args) throws Exception {
+    Reference r;
+    setSoftReference();
+    new Thread(new TriggerRP()).start();
+    Thread.sleep(3000);
+    if (rp.get() != null) {
+      a++;
+    }
+    while ((r = rq.poll())!=null) {
+      if(!r.getClass().toString().equals("class java.lang.ref.SoftReference")) {
+        a++;
+      }
+    }
+    if (a == 101) {
+      System.out.println("ExpectResult");
+    }
+  }
+}
diff --git a/testsuite/java_test/rc_test/RC0303-rc-function-Ref-SoftRefTest/expected.txt b/testsuite/java_test/rc_test/RC0303-rc-function-Ref-SoftRefTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0303-rc-function-Ref-SoftRefTest/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0303-rc-function-Ref-SoftRefTest/test.cfg b/testsuite/java_test/rc_test/RC0303-rc-function-Ref-SoftRefTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9ac82156264f579e2b9c287c5a208a3dba451912
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0303-rc-function-Ref-SoftRefTest/test.cfg
@@ -0,0 +1,2 @@
+compile(SoftRefTest)
+run(SoftRefTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest/WeakRefTest.java b/testsuite/java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest/WeakRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..556b2ef76a3737341c617cd80860bf515f5291c1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest/WeakRefTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class WeakRefTest {
+  static Reference rp;
+  static ReferenceQueue rq = new ReferenceQueue();
+  static int a = 100;
+  static void setWeakReference() {
+    rp = new WeakReference<Object>(new Object(), rq);
+    if (rp.get() == null) {
+      a++;
+    }
+  }
+  static class TriggerRP implements Runnable {
+    public void run() {
+      for (int i = 0; i < 60; i++) {
+        WeakReference wr = new WeakReference(new Object());
+        try {
+          Thread.sleep(50);
+        } catch (Exception e) {}
+      }
+    }
+  }
+  public static void main(String [] args) throws Exception {
+    Reference r;
+    setWeakReference();
+    new Thread(new TriggerRP()).start();
+    Thread.sleep(3000);
+    if (rp.get() != null) {
+      a++;
+    }
+    while ((r = rq.poll())!=null) {
+      if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+        a++;
+      }
+    }
+    if (a == 100) {
+      System.out.println("ExpectResult");
+    }
+  }
+}
diff --git a/testsuite/java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest/test.cfg b/testsuite/java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a048920713c2ad2fb2c67fc40a0231aa3b58fc4c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0304-rc-function-Ref-WeakRefTest/test.cfg
@@ -0,0 +1,2 @@
+compile(WeakRefTest)
+run(WeakRefTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/RC_newObjectIassign_01.java b/testsuite/java_test/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/RC_newObjectIassign_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f334be738a727735236562cbfebd904d8c5b1f8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/RC_newObjectIassign_01.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Arrays;
+public class RC_newObjectIassign_01 {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    String[] strArray;
+    static String str1;
+    volatile String str2;
+    private RC_newObjectIassign_01(){
+        strArray=new String[10];
+        str1="MapleTest";
+        str2="FigoTest";
+    }
+    private RC_newObjectIassign_01(String str){
+        str1=str;
+        str2=str;
+    }
+    private RC_newObjectIassign_01(String[] str){
+        strArray=str;
+    }
+    public static void main(String[] args){
+        for(int i =1; i<=100 ; i++){
+            test_new_objct_assign();
+            if(check != 5){
+                System.out.println("ErrorResult");
+                break;
+            }else{
+                check=0;
+                str1=null;
+            }
+        }
+        System.out.println("ExpectResult");
+    }
+    private static void test_new_objct_assign(){
+        String[] example = {"a","b","c"};
+        String[] arrayStr = {"a","b","c"};
+        RC_newObjectIassign_01 rctest=new RC_newObjectIassign_01(arrayStr);
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 ==null && rctest.str2== null)
+            check +=1;
+        rctest.str1="firstTimeTestStr1";
+        rctest.str2="firstTimeTestStr2";
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 =="firstTimeTestStr1" && rctest.str2== "firstTimeTestStr2")
+            check +=1;
+        rctest = new RC_newObjectIassign_01("secondTimeTest");
+        if(Arrays.equals(rctest.strArray,null) && rctest.str1 =="secondTimeTest" && rctest.str2== "secondTimeTest")
+            check +=1;
+        rctest.strArray = arrayStr;
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 =="secondTimeTest" && rctest.str2== "secondTimeTest")
+            check +=1;
+        rctest=new RC_newObjectIassign_01();
+        if(rctest.strArray.length == 10 && rctest.str1 =="MapleTest" && rctest.str2== "FigoTest")
+            check +=1;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/expected.txt b/testsuite/java_test/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/test.cfg b/testsuite/java_test/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dfd5e287b51ba294d372f418bc2ac39108a61008
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0309-rc-function-Optimization-RC_newObjectIassign_01/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_newObjectIassign_01)
+run(RC_newObjectIassign_01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/RC_newObjectIassign_02.java b/testsuite/java_test/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/RC_newObjectIassign_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..f246e37d03de547d3c88f1da6727cb0ac30465ef
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/RC_newObjectIassign_02.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Arrays;
+class Base{
+    String[] strArray;
+    volatile String str2;
+}
+public class RC_newObjectIassign_02 extends Base{
+    final static String STR = "MapleTest";
+    static int check = 0;
+    static String str1;
+    private RC_newObjectIassign_02(){
+        strArray=new String[10];
+        str1="MapleTest";
+        str2="FigoTest";
+    }
+    private RC_newObjectIassign_02(String str){
+        str1=str;
+        str2=str;
+    }
+    private RC_newObjectIassign_02(String[] str){
+        strArray=str;
+    }
+    public static void main(String[] args){
+        for(int i =1; i<=100 ; i++){
+            test_new_objct_assign();
+            if(check != 5){
+                System.out.println("ErrorResult");
+                break;
+            }else{
+                check=0;
+                str1=null;
+            }
+        }
+        System.out.println("ExpectResult");
+    }
+    private static void test_new_objct_assign(){
+        String[] example = {"a","b","c"};
+        String[] arrayStr = {"a","b","c"};
+        RC_newObjectIassign_02 rctest=new RC_newObjectIassign_02(arrayStr);
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 ==null && rctest.str2== null)
+            check +=1;
+        rctest.str1="firstTimeTestStr1";
+        rctest.str2="firstTimeTestStr2";
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 =="firstTimeTestStr1" && rctest.str2== "firstTimeTestStr2")
+            check +=1;
+        rctest = new RC_newObjectIassign_02("secondTimeTest");
+        if(Arrays.equals(rctest.strArray,null) && rctest.str1 =="secondTimeTest" && rctest.str2== "secondTimeTest")
+            check +=1;
+        rctest.strArray = arrayStr;
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 =="secondTimeTest" && rctest.str2== "secondTimeTest")
+            check +=1;
+        rctest=new RC_newObjectIassign_02();
+        if(rctest.strArray.length == 10 && rctest.str1 =="MapleTest" && rctest.str2== "FigoTest")
+            check +=1;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/expected.txt b/testsuite/java_test/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/test.cfg b/testsuite/java_test/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a9ef04653b9339864fd3acec38304301e2b24a23
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0310-rc-function-Optimization-RC_newObjectIassign_02/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_newObjectIassign_02)
+run(RC_newObjectIassign_02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/RC_newObjectToField.java b/testsuite/java_test/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/RC_newObjectToField.java
new file mode 100755
index 0000000000000000000000000000000000000000..858e576c99ae8d9e2bbcd664eef18c23de1a5962
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/RC_newObjectToField.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Arrays;
+public class RC_newObjectToField {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    volatile static String[] strArray;
+    static String str1;
+    volatile String str2;
+    private RC_newObjectToField(){
+        strArray=new String[10];
+        str1=new String("str1")+"MapleTest";
+        str2="FigoTest";
+    }
+    private RC_newObjectToField(String str){
+        str1=new String("str1")+str;
+        str2=new String("str2")+str;
+    }
+    private RC_newObjectToField(String[] str){
+        Arrays.sort(str);
+        Arrays.toString(str);
+        new Object();
+        new String("Just Test");
+        Arrays.binarySearch(str,"d");
+        strArray=new String[10];
+        strArray=str;
+    }
+    public static void main(String[] args){
+        for(int i =1; i<=100 ; i++){
+            test_new_objct_assign();
+            if(check != 3){
+                System.out.println("ErrorResult");
+                break;
+            }else{
+                check=0;
+                str1=null;
+            }
+        }
+        System.out.println("ExpectResult");
+    }
+    private static void test_new_objct_assign(){
+        String[] example = {"a","b","c"};
+        String[] arrayStr = {"c","a","b"};
+        RC_newObjectToField rctest=new RC_newObjectToField(arrayStr);
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1 ==null && rctest.str2== null)
+            check +=1;
+        rctest = new RC_newObjectToField("secondTimeTest");
+        if(Arrays.equals(rctest.strArray,example) && rctest.str1.equals("str1secondTimeTest") && rctest.str2.equals( "str2secondTimeTest"))
+            check +=1;
+        rctest=new RC_newObjectToField();
+        if(rctest.strArray.length == 10 && rctest.str1.equals("str1MapleTest") && rctest.str2== "FigoTest")
+            check +=1;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/expected.txt b/testsuite/java_test/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/test.cfg b/testsuite/java_test/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..83d89b6062895f0e189ea6008e30d2e6bcd589ab
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0311-rc-function-Optimization-RC_newObjectToField/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_newObjectToField)
+run(RC_newObjectToField,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/RC_newObjectToField_02.java b/testsuite/java_test/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/RC_newObjectToField_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..79e90757b19f7d9b32a1811a93b59a2a81d35212
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/RC_newObjectToField_02.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Arrays;
+public class RC_newObjectToField_02 {
+    final static String STR = "MapleTest";
+    static int check = 0;
+    volatile static String[] strArray;
+    int[] intArray;
+    static String str1;
+    volatile String str2;
+    private RC_newObjectToField_02() throws ArithmeticException{
+        strArray=new String[10];
+        str1=new String("str1")+"MapleTest";
+        str2="FigoTest";
+        intArray = new int[]{1/0};
+    }
+    private RC_newObjectToField_02(String str) throws StringIndexOutOfBoundsException{
+        str1=(new String("str1")+str).substring(-1,-2);
+        str2=new String("str2")+str;
+    }
+    private RC_newObjectToField_02(String[] str) throws ArrayIndexOutOfBoundsException{
+        Arrays.sort(str);
+        Arrays.toString(str);
+        new Object();
+        new String("Just Test");
+        Arrays.binarySearch(str,"d");
+        intArray=new int[10];
+        strArray=new String[1];
+        strArray[2]=new String("IndexOutBounds");
+    }
+    public static void main(String[] args){
+        for(int i =1; i<=100 ; i++){
+            test_new_objct_assign();
+            if(check != 3){
+                System.out.println("ErrorResult");
+                break;
+            }else{
+                check=0;
+                str1=null;
+            }
+        }
+        System.out.println("ExpectResult");
+    }
+    private static void test_new_objct_assign(){
+        String[] arrayStr = {"c","a","b"};
+        try{
+        RC_newObjectToField_02 rctest=new RC_newObjectToField_02(arrayStr);
+        }catch(ArrayIndexOutOfBoundsException a) {
+            check += 1;
+        }
+        try{
+        RC_newObjectToField_02 rctest = new RC_newObjectToField_02("secondTimeTest");}
+        catch(StringIndexOutOfBoundsException s){
+            check +=1;
+        }
+        try{
+            RC_newObjectToField_02 rctest=new RC_newObjectToField_02();}
+        catch(ArithmeticException a){
+            check +=1;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/expected.txt b/testsuite/java_test/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/test.cfg b/testsuite/java_test/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa067d341ab2ae0544b50ac4ab291402bb80dac0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0312-rc-function-Optimization-RC_newObjectToField_02/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_newObjectToField_02)
+run(RC_newObjectToField_02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0313-rc-function-Optimization-RC_staticInput/RC_staticInput.java b/testsuite/java_test/rc_test/RC0313-rc-function-Optimization-RC_staticInput/RC_staticInput.java
new file mode 100755
index 0000000000000000000000000000000000000000..8fd579314541da306ac959481252aee3127e4e1f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0313-rc-function-Optimization-RC_staticInput/RC_staticInput.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class RC_staticInput {
+    static int []test= {10,20,30,40};
+    public static void main(String [] args) {
+        if(test.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+        test(4,test);
+        if(test.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+    public static void test(int first, int[] second) {
+        int [] xyz = {23,24,25,26};
+        test = xyz;
+        if(second.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0313-rc-function-Optimization-RC_staticInput/expected.txt b/testsuite/java_test/rc_test/RC0313-rc-function-Optimization-RC_staticInput/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..309f6d50570536aa5ec2bd6eba765f9c8fa03b0f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0313-rc-function-Optimization-RC_staticInput/expected.txt
@@ -0,0 +1,3 @@
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0313-rc-function-Optimization-RC_staticInput/test.cfg b/testsuite/java_test/rc_test/RC0313-rc-function-Optimization-RC_staticInput/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f3ae9fed3bf9e894879ea493e31d1ea0a072e9e1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0313-rc-function-Optimization-RC_staticInput/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_staticInput)
+run(RC_staticInput,EXPECTNUM=3)
diff --git a/testsuite/java_test/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/RC_staticInput_02.java b/testsuite/java_test/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/RC_staticInput_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..15cebf163e14281a573b76183b0de095c12b6086
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/RC_staticInput_02.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class RC_staticInput_02 {
+    static int []test= {10,20,30,40};
+    public static void main(String [] args) {
+        if(test.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+        test(4,test);
+        if(test.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+    public static void test(int first, int[] second) {
+        int [] xyz = {23,24,25,26};
+        modify(xyz);
+        if(second.length==4)
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+    public static void modify(int[] temp){
+        test=temp;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/expected.txt b/testsuite/java_test/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..309f6d50570536aa5ec2bd6eba765f9c8fa03b0f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/expected.txt
@@ -0,0 +1,3 @@
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/test.cfg b/testsuite/java_test/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f641250554ad0289e520270efcde6ef278706246
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0314-rc-function-Optimization-RC_staticInput_02/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_staticInput_02)
+run(RC_staticInput_02,EXPECTNUM=3)
diff --git a/testsuite/java_test/rc_test/RC0315-rc-Memory-normalTestCase1/Memory_normalTestCase1.java b/testsuite/java_test/rc_test/RC0315-rc-Memory-normalTestCase1/Memory_normalTestCase1.java
new file mode 100755
index 0000000000000000000000000000000000000000..c631778cb0bb49af4e1318ae51ffc141530dd68d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0315-rc-Memory-normalTestCase1/Memory_normalTestCase1.java
@@ -0,0 +1,547 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase1 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int ALLOC_4K = 4 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase1() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int slot = 0;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase1_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        System.out.println("ExpectResult");
+    }
+    public static void main(String[] args) {
+        testCase1();
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0315-rc-Memory-normalTestCase1/expected.txt b/testsuite/java_test/rc_test/RC0315-rc-Memory-normalTestCase1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0315-rc-Memory-normalTestCase1/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0315-rc-Memory-normalTestCase1/test.cfg b/testsuite/java_test/rc_test/RC0315-rc-Memory-normalTestCase1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..559fa16df7bcb3d7f7e3cc6c361c3705ba89179a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0315-rc-Memory-normalTestCase1/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase1)
+run(Memory_normalTestCase1,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0316-rc-Memory-normalTestCase2/Memory_normalTestCase2.java b/testsuite/java_test/rc_test/RC0316-rc-Memory-normalTestCase2/Memory_normalTestCase2.java
new file mode 100755
index 0000000000000000000000000000000000000000..c003b37637fc341bab8c200c89ce33df6408281c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0316-rc-Memory-normalTestCase2/Memory_normalTestCase2.java
@@ -0,0 +1,555 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase2 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase2() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int slot = 0;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            slot = i % MAX_SLOT_NUM;
+            Runnable remain = new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_HALF_RAMDOM, true, 1);
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, true, 1, DEFAULT_REPEAT_TIMES, remain), "testCase2_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void main(String[] args) {
+        testCase2();
+        Runtime.getRuntime().gc();
+        testCase2();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0316-rc-Memory-normalTestCase2/expected.txt b/testsuite/java_test/rc_test/RC0316-rc-Memory-normalTestCase2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0316-rc-Memory-normalTestCase2/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0316-rc-Memory-normalTestCase2/test.cfg b/testsuite/java_test/rc_test/RC0316-rc-Memory-normalTestCase2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..698a050c910f3cdd00672bd9fb3e437e6c4a13a4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0316-rc-Memory-normalTestCase2/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase2)
+run(Memory_normalTestCase2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0317-rc-Memory-normalTestCase3/Memory_normalTestCase3.java b/testsuite/java_test/rc_test/RC0317-rc-Memory-normalTestCase3/Memory_normalTestCase3.java
new file mode 100755
index 0000000000000000000000000000000000000000..7dd46f205e2e0780e133804ecd9e0eb193193c09
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0317-rc-Memory-normalTestCase3/Memory_normalTestCase3.java
@@ -0,0 +1,548 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.Random;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.HashSet;
+public class Memory_normalTestCase3 {
+    private static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int MAX_SLOT_NUM = 62;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    private static boolean running = true;
+    private static List<List<AllocUnit>> allThreadReference = new ArrayList<List<AllocUnit>>();
+    private static boolean rest = false;
+    private static int restTime = 5000;
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    private static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Thread interrupted during trySleep", e);
+        }
+    }
+    private static boolean tryRest() {
+        if (rest) {
+            trySleep(restTime);
+            return true;
+        }
+        return false;
+    }
+    private static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    private static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException("Thread interrupted while joining", e);
+            }
+        }
+    }
+    public static void wrapper() {
+        resetTestEnvirment(allThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int slot = 0;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            slot = i % MAX_SLOT_NUM;
+            Runnable remain = new MemAlloc(ALLOC_2K, slot, allThreadReference, i, MemAlloc.SAVE_HALF_RAMDOM, true, 1);
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, allThreadReference, i, MemAlloc.SAVE_HALF, false,
+                1, DEFAULT_REPEAT_TIMES, remain), "testCase3_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(allThreadReference);
+    }
+    public static void main(String[] args) {
+        wrapper();
+        Runtime.getRuntime().gc();
+        wrapper();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte[] unit;
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public abstract static class MemAllocMethod {
+        protected long mAllocSize;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        private final Cleaner cleaner;
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+//        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+//                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        private int mRepeatTimes = 1;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes,
+            Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree,
+            MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!running) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    continue;
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0317-rc-Memory-normalTestCase3/expected.txt b/testsuite/java_test/rc_test/RC0317-rc-Memory-normalTestCase3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0317-rc-Memory-normalTestCase3/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0317-rc-Memory-normalTestCase3/test.cfg b/testsuite/java_test/rc_test/RC0317-rc-Memory-normalTestCase3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4d08c5a69a0ad663a97852048f0b892f8f02e933
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0317-rc-Memory-normalTestCase3/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase3)
+run(Memory_normalTestCase3,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0318-rc-Memory-normalTestCase4/Memory_normalTestCase4.java b/testsuite/java_test/rc_test/RC0318-rc-Memory-normalTestCase4/Memory_normalTestCase4.java
new file mode 100755
index 0000000000000000000000000000000000000000..df0a530930e57ae25cd0f0ac1fc0fa573f6f8d7e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0318-rc-Memory-normalTestCase4/Memory_normalTestCase4.java
@@ -0,0 +1,556 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase4 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase4() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int slot = 0;
+        for (int i = 0; i < MAX_SLOT_NUM; i++) {
+            slot = i % MAX_SLOT_NUM;
+            Runnable remain = new MemAlloc(ALLOC_2K, slot, mAllThreadReference, i, MemAlloc.SAVE_HALF_RAMDOM, true, 1);
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_HALF_RAMDOM, false, 1, DEFAULT_REPEAT_TIMES, remain), "testCase4_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase4();
+        Runtime.getRuntime().gc();
+        testCase4();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0318-rc-Memory-normalTestCase4/expected.txt b/testsuite/java_test/rc_test/RC0318-rc-Memory-normalTestCase4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0318-rc-Memory-normalTestCase4/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0318-rc-Memory-normalTestCase4/test.cfg b/testsuite/java_test/rc_test/RC0318-rc-Memory-normalTestCase4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..534ff4cfa904f7a3ff4a52eae53e1a8fc686f1b5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0318-rc-Memory-normalTestCase4/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase4)
+run(Memory_normalTestCase4,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0319-rc-Memory-normalTestCase5/Memory_normalTestCase5.java b/testsuite/java_test/rc_test/RC0319-rc-Memory-normalTestCase5/Memory_normalTestCase5.java
new file mode 100755
index 0000000000000000000000000000000000000000..9032cdf7bb1dfbd3fbef48c0d41e2fc6570dff5d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0319-rc-Memory-normalTestCase5/Memory_normalTestCase5.java
@@ -0,0 +1,558 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase5 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if(s ==null)
+                    return;
+                if(s.isAlive()){
+                    synchronized (list){
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase5() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        int average = ALLOC_4K / DEFAULT_THREAD_NUM;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_4K + Math.max(getSlotSize(slot), average), slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase5_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args){
+        testCase5();
+        Runtime.getRuntime().gc();
+        testCase5();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit{
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit{
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable{
+            public byte unit[];
+            public TestCleaner(byte unit[]){
+                this.unit = unit;
+            }
+            public void run(){
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit{
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit{
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable{
+            public byte[] unit;
+            public TestCleaner(byte[] unit){
+                this.unit = unit;
+            }
+            public void run(){
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit{
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable{
+            public byte[] unit;
+            public TestCleaner(byte[] unit){
+                this.unit = unit;
+            }
+            public void run(){
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive{
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit{
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable{
+            public byte[] unit;
+            public TestCleaner(byte[] unit){
+                this.unit = unit;
+            }
+            public void run(){
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM){
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit{
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this,new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable{
+            public byte[] unit;
+            public TestCleaner(byte[] unit){
+                this.unit = unit;
+            }
+            public void run(){
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx+1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER){
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if(curNum < 3){
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if(curNum < 4){
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if(curNum < 5){
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if(curNum < 6){
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if(curNum < 7){
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if(curNum < 8){
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if(curNum < 2){
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if(curNum < 3){
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if(ret != null){
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0319-rc-Memory-normalTestCase5/expected.txt b/testsuite/java_test/rc_test/RC0319-rc-Memory-normalTestCase5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0319-rc-Memory-normalTestCase5/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0319-rc-Memory-normalTestCase5/test.cfg b/testsuite/java_test/rc_test/RC0319-rc-Memory-normalTestCase5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c21e57a1c9439270d1e6199ce6bfdddb718e38dc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0319-rc-Memory-normalTestCase5/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase5)
+run(Memory_normalTestCase5,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0320-rc-Memory-normalTestCase6/Memory_normalTestCase6.java b/testsuite/java_test/rc_test/RC0320-rc-Memory-normalTestCase6/Memory_normalTestCase6.java
new file mode 100755
index 0000000000000000000000000000000000000000..d389b6dd99d4837a2716de0c09feff5c777ce606
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0320-rc-Memory-normalTestCase6/Memory_normalTestCase6.java
@@ -0,0 +1,562 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase6 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase6() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        t = new Thread(new MemAlloc(ALLOC_4K, (int) (Math.random() * MAX_SLOT_NUM), mAllThreadReference, 0, 1, false, 1, DEFAULT_THREAD_NUM), "testCase6_" + (1));
+        list.add(t);
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        list.clear();
+        for (int i = 1; i < DEFAULT_THREAD_NUM + 1; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_8K - getSlotSize(slot), slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase6_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase6();
+        Runtime.getRuntime().gc();
+        testCase6();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0320-rc-Memory-normalTestCase6/expected.txt b/testsuite/java_test/rc_test/RC0320-rc-Memory-normalTestCase6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0320-rc-Memory-normalTestCase6/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0320-rc-Memory-normalTestCase6/test.cfg b/testsuite/java_test/rc_test/RC0320-rc-Memory-normalTestCase6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1e7c8995e622f05d65568d28b2eda1222add076f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0320-rc-Memory-normalTestCase6/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase6)
+run(Memory_normalTestCase6,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0321-rc-Memory-normalTestCase6_1/Memory_normalTestCase6_1.java b/testsuite/java_test/rc_test/RC0321-rc-Memory-normalTestCase6_1/Memory_normalTestCase6_1.java
new file mode 100755
index 0000000000000000000000000000000000000000..538225a42f1f386da5ca79e12ea1def50f9271d9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0321-rc-Memory-normalTestCase6_1/Memory_normalTestCase6_1.java
@@ -0,0 +1,562 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase6_1 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase6_1() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        t = new Thread(new MemAlloc(ALLOC_4K, (int) (Math.random() * MAX_SLOT_NUM), mAllThreadReference, 0, 1, false, 1, DEFAULT_THREAD_NUM), "testCase6_1_" + (1));
+        list.add(t);
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        list.clear();
+        for (int i = 1; i < DEFAULT_THREAD_NUM + 1; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_8K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase6_1_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase6_1();
+        Runtime.getRuntime().gc();
+        testCase6_1();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0321-rc-Memory-normalTestCase6_1/expected.txt b/testsuite/java_test/rc_test/RC0321-rc-Memory-normalTestCase6_1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0321-rc-Memory-normalTestCase6_1/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0321-rc-Memory-normalTestCase6_1/test.cfg b/testsuite/java_test/rc_test/RC0321-rc-Memory-normalTestCase6_1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..92799983e1eccd51ea367e9bfa98a2c56fa776bc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0321-rc-Memory-normalTestCase6_1/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase6_1)
+run(Memory_normalTestCase6_1,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0322-rc-Memory-normalTestCase7/Memory_normalTestCase7.java b/testsuite/java_test/rc_test/RC0322-rc-Memory-normalTestCase7/Memory_normalTestCase7.java
new file mode 100755
index 0000000000000000000000000000000000000000..efe09a2ef1e039c45a6ccaaba882fa43a326c98c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0322-rc-Memory-normalTestCase7/Memory_normalTestCase7.java
@@ -0,0 +1,558 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+//import java.lang.ref.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase7 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase7() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_8K + getSlotSize(slot), slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase7_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase7();
+        Runtime.getRuntime().gc();
+        testCase7();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0322-rc-Memory-normalTestCase7/expected.txt b/testsuite/java_test/rc_test/RC0322-rc-Memory-normalTestCase7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0322-rc-Memory-normalTestCase7/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0322-rc-Memory-normalTestCase7/test.cfg b/testsuite/java_test/rc_test/RC0322-rc-Memory-normalTestCase7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..05bd26d38037b147b294f7f8f795c981a1782269
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0322-rc-Memory-normalTestCase7/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase7)
+run(Memory_normalTestCase7,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0323-rc-Memory-normalTestCase8/Memory_normalTestCase8.java b/testsuite/java_test/rc_test/RC0323-rc-Memory-normalTestCase8/Memory_normalTestCase8.java
new file mode 100755
index 0000000000000000000000000000000000000000..e35b925ce86898e5603e9124571175e2eba7c8a6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0323-rc-Memory-normalTestCase8/Memory_normalTestCase8.java
@@ -0,0 +1,552 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase8 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase8() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_8K + ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase8_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase8();
+        Runtime.getRuntime().gc();
+        testCase8();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0323-rc-Memory-normalTestCase8/expected.txt b/testsuite/java_test/rc_test/RC0323-rc-Memory-normalTestCase8/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0323-rc-Memory-normalTestCase8/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0323-rc-Memory-normalTestCase8/test.cfg b/testsuite/java_test/rc_test/RC0323-rc-Memory-normalTestCase8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7ff931b0d38615f169c1f4a5c1b1e015e89989ee
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0323-rc-Memory-normalTestCase8/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase8)
+run(Memory_normalTestCase8,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0324-rc-Memory-normalTestCase9/Memory_normalTestCase9.java b/testsuite/java_test/rc_test/RC0324-rc-Memory-normalTestCase9/Memory_normalTestCase9.java
new file mode 100755
index 0000000000000000000000000000000000000000..4c0f143ad90b6f2888eb7d053e53a4a7a5302fdf
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0324-rc-Memory-normalTestCase9/Memory_normalTestCase9.java
@@ -0,0 +1,541 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.*;
+public class Memory_normalTestCase9 {
+    static final int MAX_SLOT_NUM = 62;
+    private static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    private static final int ALLOC_12K = 12 * 1024;
+    static boolean running = true;
+    static List<List<AllocUnit>> allThreadReference = new ArrayList<List<AllocUnit>>();
+    private static boolean rest = false;
+    private static int restTime = 5000;
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    private static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Thread interrupted during trySleep", e);
+        }
+    }
+    private static boolean tryRest() {
+        if (rest) {
+            trySleep(restTime);
+            return true;
+        }
+        return false;
+    }
+    private static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    private static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException("Thread interrupted while joining", e);
+            }
+        }
+    }
+    private static void testCase9() {
+        resetTestEnvirment(allThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_12K, slot, allThreadReference, i, MemAlloc.SAVE_ALL,
+                false, 1), "testCase9_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(allThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase9();
+        Runtime.getRuntime().gc();
+        testCase9();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte[] unit;
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        private final Cleaner cleaner;
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+            = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+            = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        private int mRepeatTimes = 1;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes,
+            Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree,
+            MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime,
+                repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime,
+                repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!running) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    continue;
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0324-rc-Memory-normalTestCase9/expected.txt b/testsuite/java_test/rc_test/RC0324-rc-Memory-normalTestCase9/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0324-rc-Memory-normalTestCase9/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0324-rc-Memory-normalTestCase9/test.cfg b/testsuite/java_test/rc_test/RC0324-rc-Memory-normalTestCase9/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5507e5bfb8b19a60cebdfe0a96373acc197268ec
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0324-rc-Memory-normalTestCase9/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase9)
+run(Memory_normalTestCase9,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0325-rc-Memory-normalTestCase10/Memory_normalTestCase10.java b/testsuite/java_test/rc_test/RC0325-rc-Memory-normalTestCase10/Memory_normalTestCase10.java
new file mode 100755
index 0000000000000000000000000000000000000000..8eeb6092cc910ce52c312f3a5578b199848e2b24
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0325-rc-Memory-normalTestCase10/Memory_normalTestCase10.java
@@ -0,0 +1,552 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase10 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase10() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_16K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase10_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase10();
+        Runtime.getRuntime().gc();
+        testCase10();
+        System.out.println("ExpectResult");
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0325-rc-Memory-normalTestCase10/expected.txt b/testsuite/java_test/rc_test/RC0325-rc-Memory-normalTestCase10/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0325-rc-Memory-normalTestCase10/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0325-rc-Memory-normalTestCase10/test.cfg b/testsuite/java_test/rc_test/RC0325-rc-Memory-normalTestCase10/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4720b90020212d2f3cc3ffc19d5704f4e6f266b0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0325-rc-Memory-normalTestCase10/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase10)
+run(Memory_normalTestCase10,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0326-rc-Memory-normalTestCase11/Memory_normalTestCase11.java b/testsuite/java_test/rc_test/RC0326-rc-Memory-normalTestCase11/Memory_normalTestCase11.java
new file mode 100755
index 0000000000000000000000000000000000000000..59173a83d70cf480265474943c2c21a5da8866c5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0326-rc-Memory-normalTestCase11/Memory_normalTestCase11.java
@@ -0,0 +1,598 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase11 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    private static final int MAX_SLOT_NUM = 62;
+    private static boolean rest = false;
+    private static int restTime = 5000;
+    private static boolean running = true;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int MAX_REALIVE_OBJ_NUM = 1000;
+    private static List<List<AllocUnit>> allThreadReference = new ArrayList<List<AllocUnit>>();
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    private static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Thread interrupted during trySleep", e);
+        }
+    }
+    private static boolean tryRest() {
+        if (rest) {
+            trySleep(restTime);
+            return true;
+        }
+        return false;
+    }
+    private static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    private static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException("Thread interrupted while joining", e);
+            }
+        }
+    }
+    private static void testCase11() {
+        resetTestEnvirment(allThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, allThreadReference, i, MemAlloc.SAVE_ALL,
+                false, 1), "testCase11_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        list.clear();
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            t = new Thread(new FreeReference(allThreadReference, i, false), "testCase11_free_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(allThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase11();
+        Runtime.getRuntime().gc();
+        testCase11();
+        System.out.println("ExpectResult");
+    }
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!running) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+    public static class AllocUnit {
+        public byte []unit;
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public abstract static class MemAllocMethod {
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte []unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            private TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+            = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+            = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        public static final int PAGE_SIZE = 4016;
+        public static final int PAGE_HEADSIZE = 80;
+        public static final int OBJ_MAX_SIZE = 1008;
+        public static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        private int mRepeatTimes = 1;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes,
+            Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes,
+            Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum,
+            boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes,Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes,
+                callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime,
+                repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex,
+            int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!running) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    continue;
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0326-rc-Memory-normalTestCase11/expected.txt b/testsuite/java_test/rc_test/RC0326-rc-Memory-normalTestCase11/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0326-rc-Memory-normalTestCase11/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0326-rc-Memory-normalTestCase11/test.cfg b/testsuite/java_test/rc_test/RC0326-rc-Memory-normalTestCase11/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a62e7777519b32b05f5e78f9498d14d745f91e37
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0326-rc-Memory-normalTestCase11/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase11)
+run(Memory_normalTestCase11,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0327-rc-Memory-normalTestCase12/Memory_normalTestCase12.java b/testsuite/java_test/rc_test/RC0327-rc-Memory-normalTestCase12/Memory_normalTestCase12.java
new file mode 100755
index 0000000000000000000000000000000000000000..7c34025610ee07c98a76ec55e54aa1ec8d162e95
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0327-rc-Memory-normalTestCase12/Memory_normalTestCase12.java
@@ -0,0 +1,620 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase12 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase11() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            t = new Thread(new MemAlloc(ALLOC_4K, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1), "testCase11_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        list.clear();
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            t = new Thread(new FreeReference(mAllThreadReference, i, false), "testCase11_free_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void testCase12() {
+        for (int i = 0; i < 3; i++) {
+            testCase11();
+        }
+    }
+    public static void main(String[] args) {
+        testCase12();
+        Runtime.getRuntime().gc();
+        testCase12();
+        System.out.println("ExpectResult");
+    }
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0327-rc-Memory-normalTestCase12/expected.txt b/testsuite/java_test/rc_test/RC0327-rc-Memory-normalTestCase12/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0327-rc-Memory-normalTestCase12/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0327-rc-Memory-normalTestCase12/test.cfg b/testsuite/java_test/rc_test/RC0327-rc-Memory-normalTestCase12/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..42937cbf766a3e1b1b42ff19f1ae26ccb7201e86
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0327-rc-Memory-normalTestCase12/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase12)
+run(Memory_normalTestCase12,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0330-rc-Memory-normalTestCase15/Memory_normalTestCase15.java b/testsuite/java_test/rc_test/RC0330-rc-Memory-normalTestCase15/Memory_normalTestCase15.java
new file mode 100755
index 0000000000000000000000000000000000000000..f2edda2b99e15abdf7bdbc951a6e9d7d8f42cf8e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0330-rc-Memory-normalTestCase15/Memory_normalTestCase15.java
@@ -0,0 +1,890 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase15 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase15() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_8K * 11, ENUM_RANGE.ENUM_RANGE_BOTH, 11, 0, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(ALLOC_8K * 11, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase15_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        list.clear();
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            t = new Thread(new FreeReference(mAllThreadReference, i, false), "testCase15_free_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase15();
+        Runtime.getRuntime().gc();
+        testCase15();
+        System.out.println("ExpectResult");
+    }
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+            return null;
+        }
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0330-rc-Memory-normalTestCase15/expected.txt b/testsuite/java_test/rc_test/RC0330-rc-Memory-normalTestCase15/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0330-rc-Memory-normalTestCase15/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0330-rc-Memory-normalTestCase15/test.cfg b/testsuite/java_test/rc_test/RC0330-rc-Memory-normalTestCase15/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c4eec3e9ad656b095a90168ce8dd26142f3a3446
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0330-rc-Memory-normalTestCase15/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase15)
+run(Memory_normalTestCase15,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0331-rc-Memory-normalTestCase16/Memory_normalTestCase16.java b/testsuite/java_test/rc_test/RC0331-rc-Memory-normalTestCase16/Memory_normalTestCase16.java
new file mode 100755
index 0000000000000000000000000000000000000000..b327aee14cf4ec4c42456c9213c753ff3f8a8af1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0331-rc-Memory-normalTestCase16/Memory_normalTestCase16.java
@@ -0,0 +1,890 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase16 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase16() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_8K * 11, ENUM_RANGE.ENUM_RANGE_BOTH, 11, 80, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(ALLOC_8K * 11, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase16_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        list.clear();
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            t = new Thread(new FreeReference(mAllThreadReference, i, false), "testCase16_free_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+        resetTestEnvirment(mAllThreadReference);
+    }
+    public static void main(String[] args) {
+        testCase16();
+        Runtime.getRuntime().gc();
+        testCase16();
+        System.out.println("ExpectResult");
+    }
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+            return null;
+        }
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0331-rc-Memory-normalTestCase16/expected.txt b/testsuite/java_test/rc_test/RC0331-rc-Memory-normalTestCase16/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0331-rc-Memory-normalTestCase16/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0331-rc-Memory-normalTestCase16/test.cfg b/testsuite/java_test/rc_test/RC0331-rc-Memory-normalTestCase16/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3a4deac962489cfc94c22432db581786923d57c8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0331-rc-Memory-normalTestCase16/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase16)
+run(Memory_normalTestCase16,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0332-rc-Memory-normalTestCase17/Memory_normalTestCase17.java b/testsuite/java_test/rc_test/RC0332-rc-Memory-normalTestCase17/Memory_normalTestCase17.java
new file mode 100755
index 0000000000000000000000000000000000000000..0a29b86f815127e16bf035db3efe802194e2adb9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0332-rc-Memory-normalTestCase17/Memory_normalTestCase17.java
@@ -0,0 +1,880 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase17 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase17() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < 2 * DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_4K * 6, ENUM_RANGE.ENUM_RANGE_ALL, 6, 0, false);
+            t = new Thread(new MemAlloc(ALLOC_4K * 6, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase17_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void main(String[] args) {
+        testCase17();
+        System.out.println("ExpectResult");
+    }
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+            return null;
+        }
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0332-rc-Memory-normalTestCase17/expected.txt b/testsuite/java_test/rc_test/RC0332-rc-Memory-normalTestCase17/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0332-rc-Memory-normalTestCase17/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0332-rc-Memory-normalTestCase17/test.cfg b/testsuite/java_test/rc_test/RC0332-rc-Memory-normalTestCase17/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c443d4d68545b548789a3cbe481e2c29902b1135
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0332-rc-Memory-normalTestCase17/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase17)
+run(Memory_normalTestCase17,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0333-rc-Memory-normalTestCase18/Memory_normalTestCase18.java b/testsuite/java_test/rc_test/RC0333-rc-Memory-normalTestCase18/Memory_normalTestCase18.java
new file mode 100755
index 0000000000000000000000000000000000000000..dca1cd0514ab001f935523673b5b6f03bee224a0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0333-rc-Memory-normalTestCase18/Memory_normalTestCase18.java
@@ -0,0 +1,882 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase18 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase18() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < 2 * DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_4K * 6, ENUM_RANGE.ENUM_RANGE_ALL, 6, 0, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(ALLOC_4K * 6, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, true, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase18_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void main(String[] args) {
+        testCase18();
+        Runtime.getRuntime().gc();
+        testCase18();
+        System.out.println("ExpectResult");
+    }
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+            return null;
+        }
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0333-rc-Memory-normalTestCase18/expected.txt b/testsuite/java_test/rc_test/RC0333-rc-Memory-normalTestCase18/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0333-rc-Memory-normalTestCase18/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0333-rc-Memory-normalTestCase18/test.cfg b/testsuite/java_test/rc_test/RC0333-rc-Memory-normalTestCase18/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0570848e49cef979a3d96b5ca3780755c50402a6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0333-rc-Memory-normalTestCase18/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase18)
+run(Memory_normalTestCase18,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0334-rc-Memory-normalTestCase19/Memory_normalTestCase19.java b/testsuite/java_test/rc_test/RC0334-rc-Memory-normalTestCase19/Memory_normalTestCase19.java
new file mode 100755
index 0000000000000000000000000000000000000000..fd5779d656f0f5ef20960d9c83f1a2712fb37641
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0334-rc-Memory-normalTestCase19/Memory_normalTestCase19.java
@@ -0,0 +1,880 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase19 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase19() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < 2 * DEFAULT_THREAD_NUM; i++) {
+            int slot = i % MAX_SLOT_NUM;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(ALLOC_8K * 6, ENUM_RANGE.ENUM_RANGE_ALL, 6, 80, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(ALLOC_8K * 6, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, false, 1, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase19_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void main(String[] args) {
+        testCase19();
+        System.out.println("ExpectResult");
+    }
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+            return null;
+        }
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0334-rc-Memory-normalTestCase19/expected.txt b/testsuite/java_test/rc_test/RC0334-rc-Memory-normalTestCase19/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0334-rc-Memory-normalTestCase19/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0334-rc-Memory-normalTestCase19/test.cfg b/testsuite/java_test/rc_test/RC0334-rc-Memory-normalTestCase19/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2bbebc1249b2821d4e1015ade6c2b761e385db63
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0334-rc-Memory-normalTestCase19/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase19)
+run(Memory_normalTestCase19,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0335-rc-Memory-normalTestCase22/Memory_normalTestCase22.java b/testsuite/java_test/rc_test/RC0335-rc-Memory-normalTestCase22/Memory_normalTestCase22.java
new file mode 100755
index 0000000000000000000000000000000000000000..a456d95365b10bbb5dd381f29e2ecf5730742163
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0335-rc-Memory-normalTestCase22/Memory_normalTestCase22.java
@@ -0,0 +1,891 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase22 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    private static final int DEFAULT_THREAD_NUM_HALF = DEFAULT_THREAD_NUM / 2;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase22() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = new Random().nextInt(MAX_SLOT_NUM);
+            int size = new Random().nextInt(ALLOC_12K) + ALLOC_4K;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(size, ENUM_RANGE.ENUM_RANGE_ALL, 6, (int) Math.random() * 100, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(size, slot, mAllThreadReference, i % DEFAULT_THREAD_NUM_HALF, MemAlloc.SAVE_ALL, true, 1000, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase22_alloc_" + (i + 1));
+            list.add(t);
+        }
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = new Random().nextInt(MAX_SLOT_NUM);
+            int size = new Random().nextInt(ALLOC_12K) + ALLOC_4K;
+            RandomAllocMethod allocMethod = new RandomAllocMethod(size, ENUM_RANGE.ENUM_RANGE_ALL, 6, (int) Math.random() * 100, Math.random() > 0.5d);
+            t = new Thread(new MemAlloc(size, slot, mAllThreadReference, i % DEFAULT_THREAD_NUM_HALF, MemAlloc.SAVE_ALL, true, 1000, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase22_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void main(String[] args) {
+        testCase22();
+        Runtime.getRuntime().gc();
+        testCase22();
+        System.out.println("ExpectResult");
+    }
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+            return null;
+        }
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0335-rc-Memory-normalTestCase22/expected.txt b/testsuite/java_test/rc_test/RC0335-rc-Memory-normalTestCase22/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0335-rc-Memory-normalTestCase22/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0335-rc-Memory-normalTestCase22/test.cfg b/testsuite/java_test/rc_test/RC0335-rc-Memory-normalTestCase22/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a5c9d5964bb9fb4bd82d5cbb5b2e9bf444dbd426
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0335-rc-Memory-normalTestCase22/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase22)
+run(Memory_normalTestCase22,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0336-rc-Memory-normalTestCase23/Memory_normalTestCase23.java b/testsuite/java_test/rc_test/RC0336-rc-Memory-normalTestCase23/Memory_normalTestCase23.java
new file mode 100755
index 0000000000000000000000000000000000000000..ae2cd37367dfa4198288af23cc28d2576d399633
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0336-rc-Memory-normalTestCase23/Memory_normalTestCase23.java
@@ -0,0 +1,939 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase23 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    private static final int DEFAULT_THREAD_NUM_HALF = DEFAULT_THREAD_NUM / 2;
+    public static final int MAX_REALIVE_OBJ_NUM = 1000;
+    static List<List<AllocUnit>> mAllThreadReference = new ArrayList<List<AllocUnit>>();
+    static AllocUnit[] mLocks = new AllocUnit[DEFAULT_THREAD_NUM];
+    private static int getSlotSize(int slot) {
+        return MemAlloc.idx_to_size(slot);
+    }
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    private static Set<Integer> getRandomIndex(List<AllocUnit> arrayToFree, int freeNum) {
+        HashSet<Integer> result = new HashSet<Integer>();
+        if (arrayToFree == null) {
+            return result;
+        }
+        randomSet(0, arrayToFree.size(), freeNum >= arrayToFree.size() ? arrayToFree.size() : freeNum, result);
+        return result;
+    }
+    private static void randomSet(int min, int max, int n, HashSet<Integer> set) {
+        if (n > (max - min + 1) || max < min) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            int num = (int) (Math.random() * (max - min)) + min;
+            set.add(num);
+        }
+        int setSize = set.size();
+        if (setSize < n) {
+            randomSet(min, max, n - setSize, set);
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void testCase23() {
+        resetTestEnvirment(mAllThreadReference);
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM; i++) {
+            int slot = new Random().nextInt(MAX_SLOT_NUM);
+            int size = new Random().nextInt(ALLOC_12K) + ALLOC_4K;
+            MemAllocMethod allocMethod = new ContinueRandomAllocMethod(size, ENUM_RANGE.ENUM_RANGE_ALL, 6, (int) Math.random() * 100, Math.random() > 0.5d, 100, 400, 0, false);
+            t = new Thread(new MemAlloc(size, slot, mAllThreadReference, i, MemAlloc.SAVE_ALL, true, 1000, DEFAULT_REPEAT_TIMES, null, allocMethod), "testCase23_alloc_" + (i + 1));
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void main(String[] args) {
+        testCase23();
+        Runtime.getRuntime().gc();
+        testCase23();
+        System.out.println("ExpectResult");
+    }
+    public static int makesureprop(int prop) {
+        if (prop > 100 || prop <= 0) {
+            prop = 100;
+        }
+        return prop;
+    }
+    public static ArrayList<Integer> choose_idx(int min, int max, int chosen, boolean random) {
+        if (min > max) {
+            return null;
+        }
+        ArrayList<Integer> ret = new ArrayList<Integer>();
+        if (!random) {
+            int grow = (max - min + chosen) / chosen;
+            for (int i = min; i < max; i = i + grow) {
+                Integer a = Integer.valueOf(i);
+                ret.add(a);
+            }
+        } else {
+            Random rand = new Random();
+            for (int i = 0; i < chosen; i++) {
+                int randNumber = rand.nextInt(max - min) + min;
+                Integer rdn = Integer.valueOf(randNumber);
+                ret.add(rdn);
+            }
+        }
+        return ret;
+    }
+    public static int idx_to_size(int idx) {
+        int ret = 0;
+        if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+            return 112;
+        }
+        if (idx < GLOBAL_MAX_IDX) {
+            ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+        } else {
+            // idx equals GLOBAL_MAX_IDX
+            ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+        }
+        return ret;
+    }
+    public static long pagesize_to_allocsize(long size_) {
+        long ret = 0;
+        int pagenum = 0;
+        if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+            pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+            size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+        }
+        if (size_ < PAGE_SIZE) {
+            ret = pagenum * PAGE_SIZE + size_;
+        } else {
+            ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+        }
+        return ret;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+            return null;
+        }
+        bytesize = pagesize_to_allocsize(bytesize);
+        int size_ = idx_to_size(idx);
+        if (size_ <= 0) {
+            return null;
+        }
+        int sizenum = (int) (bytesize / size_);
+        if (sizenum == 0) {
+            return null;
+        }
+        if (diff >= 0 || (sizenum + diff) > 0) {
+            sizenum = sizenum + diff;
+        }
+        for (int j = 0; j < sizenum; j++) {
+            array.add(MemAlloc.AllocOneUnit(size_, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_prop(ArrayList<Integer> purpose, ArrayList<Integer> other, int prop, long size, int diff, boolean isStress) {
+        prop = makesureprop(prop);
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_alloc = 0;
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        boolean no_alloc = true;
+        while (size_alloc < size) {
+            for (int i = 0; i < n_p; i++) {
+                Iterator<Integer> it1 = purpose.iterator();
+                while (it1.hasNext()) {
+                    int a = (it1.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            for (int i = 0; i < n_o; i++) {
+                Iterator<Integer> it2 = other.iterator();
+                while (it2.hasNext()) {
+                    int a = (it2.next()).intValue();
+                    size_alloc = size_alloc + idx_to_size(a);
+                    ArrayList<AllocUnit> temp_array = alloc_byte_idx(idx_to_size(a), a, diff, isStress);
+                    array.addAll(temp_array);
+                    no_alloc = false;
+                }
+                if (size_alloc > size) {
+                    return array;
+                }
+            }
+            if (no_alloc)
+                return array;
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_choose_idx(long size, ENUM_RANGE range, int chosen, int prop, boolean random, boolean isStress) {
+        ArrayList<Integer> purpose = new ArrayList<Integer>();
+        ArrayList<Integer> other = new ArrayList<Integer>();
+        ArrayList<Integer> largeobj_list = new ArrayList<Integer>();
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        boolean has_small = false, has_large = false;
+        if (!random) {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, GLOBAL_MIN_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX + 1, chosen, random));
+                    largeobj_list.add(LARGE_PAGE_SIZE);
+                    largeobj_list.add(8 * LARGE_PAGE_SIZE);
+                    has_small = true;
+                    has_large = true;
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            switch (range) {
+                case ENUM_RANGE_LOCAL:
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_GLOBAL:
+                    purpose.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_BOTH:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    has_small = true;
+                    break;
+                case ENUM_RANGE_LARGEOBJ:
+                    Random rand = new Random();
+                    int largenum = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum; i++) {
+                        int randNumber = rand.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    break;
+                case ENUM_RANGE_ALL:
+                    chosen = chosen / 2;
+                    purpose.addAll(choose_idx(LOCAL_MIN_IDX, LOCAL_MAX_IDX, chosen, random));
+                    other.addAll(choose_idx(GLOBAL_MIN_IDX, GLOBAL_MAX_IDX, chosen, random));
+                    Random rand2 = new Random();
+                    int largenum2 = LARGEOBJ_CHOSEN_NUM;
+                    for (int i = 0; i < largenum2; i++) {
+                        int randNumber = rand2.nextInt(32) + 1;
+                        largeobj_list.add(randNumber * LARGE_PAGE_SIZE);
+                    }
+                    has_large = true;
+                    has_small = true;
+                    break;
+                default:
+            }
+        }
+        if (has_small) {
+            array.addAll(alloc_choose_prop(purpose, other, prop, size, 0, isStress));
+        }
+        if (has_large) {
+            array.addAll(alloc_list_large(LARGEOBJ_ALLOC_SIZE, largeobj_list, 50, isStress));
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_list_large(long bytesize, ArrayList<Integer> alloc_list, int prop, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        long size_allocated = 0;
+        prop = makesureprop(prop);
+        int n_p = prop / 10, n_o = (100 - prop) / 10;
+        while (size_allocated < bytesize) {
+            Iterator<Integer> it1 = alloc_list.iterator();
+            boolean first = true;
+            int loopn = n_p;
+            while (it1.hasNext()) {
+                int a = (it1.next()).intValue();
+                if (first) {
+                    loopn = n_p;
+                    first = false;
+                } else {
+                    loopn = n_o;
+                    first = true;
+                }
+                for (int i = 0; i < loopn; i++) {
+                    size_allocated = size_allocated + a;
+                    ArrayList<AllocUnit> temp_array = alloc_byte_large(a, a, 0, isStress);
+                    array.addAll(temp_array);
+                    if (size_allocated > bytesize) {
+                        return array;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+    public static ArrayList<AllocUnit> alloc_byte_large(long bytesize, int alloc_size, int diff, boolean isStress) {
+        ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+        if (alloc_size <= OBJ_MAX_SIZE) {
+            return null;
+        }
+        long size = 0;
+        if ((bytesize + diff * alloc_size) <= 0) {
+            return null;
+        }
+        bytesize = bytesize + diff * alloc_size;
+        while (size < bytesize) {
+            size = size + alloc_size;
+            array.add(MemAlloc.AllocOneUnit(alloc_size, isStress));
+        }
+        return array;
+    }
+    public static class RandomAllocMethod extends MemAllocMethod {
+        public RandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+        }
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+            return ret;
+        }
+    }
+    static class FreeReference implements Runnable {
+        private List<List<AllocUnit>> mAllReference = null;
+        private int mThreadIdx = 0;
+        private boolean mLoop = false;
+        private boolean mSync = false;
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop, boolean sync) {
+            mAllReference = reference;
+            mThreadIdx = threadIdx;
+            mLoop = loop;
+            mSync = sync;
+        }
+        public FreeReference(List<List<AllocUnit>> reference, int threadIdx, boolean loop) {
+            this(reference, threadIdx, loop, false);
+        }
+        private void release() {
+            if (mSync) {
+                synchronized (mAllReference) {
+                    releaseOperate();
+                }
+            } else {
+                releaseOperate();
+            }
+        }
+        private void releaseOperate() {
+            if (mAllReference == null) {
+                return;
+            }
+            if (mThreadIdx >= mAllReference.size()) {
+                return;
+            }
+            List<AllocUnit> cur = mAllReference.get(mThreadIdx);
+            mAllReference.set(mThreadIdx, null);
+            if (cur != null) {
+                cur.clear();
+            }
+        }
+        @Override
+        public void run() {
+            if (!mLoop) {
+                release();
+                return;
+            }
+            while (mLoop) {
+                if (!mRunning) {
+                    break;
+                }
+                release();
+                trySleep(1);
+            }
+        }
+    }
+    public static class ContinueRandomAllocMethod extends MemAllocMethod {
+        private long mSleep;
+        private long mTotalTimes;
+        private long mTimes = 0;
+        private boolean mFreeImmediately;
+        public ContinueRandomAllocMethod(long size, ENUM_RANGE range, int chosen, int prop, boolean random, long sleep, long totalTimes, int times, boolean freeImmediately) {
+            mAllocSize = size;
+            mRange = range;
+            mChosen = chosen;
+            mProp = prop;
+            mRandorm = random;
+            mSleep = sleep;
+            mTotalTimes = totalTimes;
+            mTimes = times;
+            mFreeImmediately = freeImmediately;
+        }
+        @Override
+        public List<AllocUnit> alloc(boolean isStress) {
+            List<AllocUnit> ret = null;
+            List<AllocUnit> tmp = null;
+            if (mTotalTimes == 0 && mTimes == 0) {
+                ret = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+                return ret;
+            }
+            long elipseTime = 0;
+            boolean find = false;
+            ret = new ArrayList<AllocUnit>();
+            while (elipseTime < mTotalTimes) {
+                long now = System.currentTimeMillis();
+                tmp = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+                if (!mFreeImmediately && tmp != null) {
+                    ret.addAll(tmp);
+                } else {
+                    tmp = null;
+                }
+                find = true;
+                trySleep(mSleep);
+                elipseTime += System.currentTimeMillis() - now;
+            }
+            if (!find) {
+                int time = 0;
+                while (time < mTotalTimes) {
+                    tmp = alloc_choose_idx(mAllocSize, mRange, mChosen, mProp, mRandorm, isStress);
+                    if (!mFreeImmediately && tmp != null) {
+                        ret.addAll(tmp);
+                    } else {
+                        tmp = null;
+                    }
+                    time++;
+                    trySleep(mSleep);
+                }
+            }
+            return ret;
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static enum ENUM_RANGE {
+        ENUM_RANGE_NONE, ENUM_RANGE_LOCAL, ENUM_RANGE_GLOBAL, ENUM_RANGE_BOTH, ENUM_RANGE_LARGEOBJ, ENUM_RANGE_ALL
+    }
+    public static abstract class MemAllocMethod {
+        protected long mAllocSize;
+        protected ENUM_RANGE mRange;
+        protected int mChosen = 0;
+        protected int mProp = 0;
+        protected boolean mRandorm;
+        public abstract List<AllocUnit> alloc(boolean isStress);
+    }
+    public static class AllocUnitWithFinalizeSleep extends AllocUnit {
+        public AllocUnitWithFinalizeSleep(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            trySleep(1000);
+        }
+    }
+    public static class AllocUnitWithSoftReference extends AllocUnit {
+        private Reference<byte[]> refArray;
+        public AllocUnitWithSoftReference(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithFinalize extends AllocUnit {
+        public AllocUnitWithFinalize(int arrayLength) {
+            super(arrayLength);
+        }
+        @Override
+        public void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitCycleMaster extends AllocUnit {
+        @SuppressWarnings("unused")
+        private AllocUnitCycleSlave slave = null;
+        public AllocUnitCycleMaster(int arrayLength) {
+            super(arrayLength);
+            slave = new AllocUnitCycleSlave(arrayLength, this);
+        }
+    }
+    public static class AllocUnitCycleSlave extends AllocUnit {
+        private AllocUnitCycleMaster master = null;
+        public AllocUnitCycleSlave(int arrayLength, AllocUnitCycleMaster master) {
+            super(arrayLength);
+            this.master = master;
+        }
+    }
+    public static class AllocUnitwithCleaner extends AllocUnit {
+        public AllocUnitwithCleaner(int arrayLength) {
+            super(arrayLength);
+            this.cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private final Cleaner cleaner;
+        private static class TestCleaner implements Runnable {
+            public byte unit[];
+            public TestCleaner(byte unit[]) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    public static class AllocUnitWithWeakRefrence extends AllocUnit {
+        public WeakReference<byte[]> weakIntArray;
+        public AllocUnitWithWeakRefrence(int arrayLength) {
+            super(arrayLength);
+            weakIntArray = new WeakReference<byte[]>(new byte[arrayLength]);
+        }
+    }
+    public static class AllocUnitWithRefAndCleanerF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithWeakRefAndCleanerF extends AllocUnit {
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithWeakRefAndCleanerF(int arrayLength) {
+            super(arrayLength);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class ReAlive {
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner> cleanerList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerActiveObjF.TestCleaner>(MAX_REALIVE_OBJ_NUM);
+        public static ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj> refAndWeakRefAndCleanerFActiveObjList
+                = new ArrayList<AllocUnitWithRefAndWeakRefAndCleanerFActiveObj>(MAX_REALIVE_OBJ_NUM);
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerActiveObjF extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                if (ReAlive.cleanerList.size() > MAX_REALIVE_OBJ_NUM) {
+                    ReAlive.cleanerList.clear();
+                } else {
+                    ReAlive.cleanerList.add(this);
+                }
+                this.unit = null;
+            }
+        }
+        @Override
+        protected void finalize() throws Throwable {
+            unit = null;
+        }
+    }
+    public static class AllocUnitWithRefAndWeakRefAndCleanerFActiveObj extends AllocUnit {
+        private Reference<byte[]> refArray;
+        private WeakReference<byte[]> weakRefArray;
+        private Cleaner cleaner;
+        public AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(int arrayLength) {
+            super(arrayLength);
+            refArray = new SoftReference<byte[]>(new byte[arrayLength]);
+            weakRefArray = new WeakReference<byte[]>(new byte[arrayLength]);
+            cleaner = Cleaner.create(this, new TestCleaner(new byte[arrayLength]));
+        }
+        private static class TestCleaner implements Runnable {
+            public byte[] unit;
+            public TestCleaner(byte[] unit) {
+                this.unit = unit;
+            }
+            public void run() {
+                this.unit = null;
+            }
+        }
+    }
+    static class MemAlloc implements Runnable {
+        int mAllocSize = 4 * 1024;
+        int mSaveNum = -1;
+        boolean mFreeImmediately = false;
+        int mSlot = 0;
+        int mSleepTime = 5;
+        List<List<AllocUnit>> mSaveTo = null;
+        int mSaveIndex = 0;
+        public static final int LOCAL_MIN_IDX = 0;
+        public static final int GLOBAL_MAX_IDX = 62;
+        static final int PAGE_SIZE = 4016;
+        static final int PAGE_HEADSIZE = 80;
+        static final int OBJ_MAX_SIZE = 1008;
+        static final int OBJ_HEADSIZE = 16;
+        public static final int SAVE_ALL = -1;
+        public static final int SAVE_HALF = -2;
+        public static final int SAVE_HALF_RAMDOM = -3;
+        public static final int SAVE_HALF_MINUS = -4;
+        private int mRepeatTimes = 1;
+        public static volatile int totalAllocedNum = 0;
+        public static boolean TEST_OOM_FINALIZER = false;
+        private Runnable mCallBackAfterFree = null;
+        private MemAllocMethod mAllocMethod = null;
+        private boolean mIsStress;
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            mIsStress = isStress;
+            mAllocSize = allocSize;
+            mFreeImmediately = freeImmediately;
+            mSaveNum = saveNum;
+            mSlot = slot;
+            mSleepTime = sleepTime;
+            mSaveTo = saveTo;
+            mSaveIndex = saveIndex;
+            mRepeatTimes = repeatTimes;
+            mCallBackAfterFree = callBackAfterFree;
+            mAllocMethod = allMethod;
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree, MemAllocMethod allMethod) {
+            this(false, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        /**
+         * saveNum:0, no obj will be reference by gloal, -1:all will be
+         * reference.
+         **/
+        public MemAlloc(int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes, Runnable callBackAfterFree) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, callBackAfterFree, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime, int repeatTimes) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, repeatTimes, null);
+        }
+        public MemAlloc(boolean isStress, int allocSize, int slot, List<List<AllocUnit>> saveTo, int saveIndex, int saveNum, boolean freeImmediately, int sleepTime) {
+            this(isStress, allocSize, slot, saveTo, saveIndex, saveNum, freeImmediately, sleepTime, 1);
+        }
+        private List<AllocUnit> merge(List<AllocUnit> src1, List<AllocUnit> src2) {
+            if (src1 == null && src2 == null) {
+                return null;
+            }
+            List<AllocUnit> list = new ArrayList<AllocUnit>();
+            if (src1 != null) {
+                list.addAll(src1);
+                src1.clear();
+            }
+            if (src2 != null) {
+                list.addAll(src2);
+                src2.clear();
+            }
+            return list;
+        }
+        public static long pagesize_to_allocsize(long size_) {
+            long ret = 0;
+            int pagenum = 0;
+            if (size_ > (PAGE_SIZE + PAGE_HEADSIZE)) {
+                pagenum = (int) (size_ / (PAGE_SIZE + PAGE_HEADSIZE));
+                size_ = size_ - pagenum * (PAGE_SIZE + PAGE_HEADSIZE);
+            }
+            if (size_ < PAGE_SIZE) {
+                ret = pagenum * PAGE_SIZE + size_;
+            } else {
+                ret = pagenum * PAGE_SIZE + PAGE_SIZE;
+            }
+            return ret;
+        }
+        public static int idx_to_size(int idx) {
+            int ret = 0;
+            if (idx < 0 || idx > GLOBAL_MAX_IDX) {
+                return 112;
+            }
+            if (idx < GLOBAL_MAX_IDX) {
+                ret = (idx + 1) * 8 + OBJ_HEADSIZE;
+            } else {
+                // idx equals GLOBAL_MAX_IDX
+                ret = OBJ_MAX_SIZE + OBJ_HEADSIZE;
+            }
+            return ret;
+        }
+        public static AllocUnit AllocOneUnit(int alloc_size, boolean isStress) {
+            if (TEST_OOM_FINALIZER) {
+                return new AllocUnitWithFinalizeSleep(alloc_size);
+            }
+            int curNum;
+            totalAllocedNum++;
+            curNum = totalAllocedNum % 100;
+            if (!isStress) {
+                if (curNum < 1) {
+                    return new AllocUnitWithFinalize(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitwithCleaner(alloc_size);
+                }
+                if (curNum < 4) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 5) {
+                    return new AllocUnitWithRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 6) {
+                    return new AllocUnitWithWeakRefAndCleanerF(alloc_size);
+                }
+                if (curNum < 7) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerActiveObjF(alloc_size);
+                }
+                if (curNum < 8) {
+                    return new AllocUnitWithRefAndWeakRefAndCleanerFActiveObj(alloc_size);
+                }
+            } else {
+                if (curNum < 1) {
+                    return new AllocUnitCycleMaster(alloc_size);
+                }
+                if (curNum < 2) {
+                    return new AllocUnitWithWeakRefrence(alloc_size);
+                }
+                if (curNum < 3) {
+                    return new AllocUnitWithSoftReference(alloc_size);
+                }
+            }
+            return new AllocUnit(alloc_size);
+        }
+        public static ArrayList<AllocUnit> alloc_byte_idx(long bytesize, int idx, int diff, boolean isStress) {
+            ArrayList<AllocUnit> array = new ArrayList<AllocUnit>();
+            if (idx < LOCAL_MIN_IDX || idx > GLOBAL_MAX_IDX) {
+                return null;
+            }
+            bytesize = pagesize_to_allocsize(bytesize);
+            int size_ = idx_to_size(idx);
+            if (size_ <= 0) {
+                return null;
+            }
+            int sizenum = (int) (bytesize / size_);
+            if (sizenum == 0) {
+                return null;
+            }
+            if (diff >= 0 || (sizenum + diff) > 0) {
+                sizenum = sizenum + diff;
+            }
+            for (int j = 0; j < sizenum; j++) {
+                array.add(MemAlloc.AllocOneUnit(size_, isStress));
+            }
+            return array;
+        }
+        @Override
+        public void run() {
+            for (int j = 0; j < mRepeatTimes || mRepeatTimes < 0; j++) {
+                if (!mRunning) {
+                    break;
+                }
+                tryRest();
+                List<AllocUnit> ret = null;
+                if (mAllocMethod == null) {
+                    ret = alloc_byte_idx(mAllocSize, mSlot, 0, mIsStress);
+                } else {
+                    ret = mAllocMethod.alloc(mIsStress);
+                }
+                if (ret == null) {
+                    // Log.e(TAG,
+                    // "Fatal error happen when alloc memory:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                    continue;
+                } else {
+                    // Log.e(TAG,
+                    // "alloc memory sucessfull:  alloc size: "+mAllocSize+" slot:"+mSlot);
+                }
+                trySleep(mSleepTime);
+                if (mFreeImmediately) {
+                    if (ret != null) {
+                        ret.clear();
+                        ret = null;
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    continue;
+                }
+                if (mSaveTo != null && mSaveNum != 0) {
+                    if (mSaveNum == SAVE_ALL && mSaveIndex < mSaveTo.size()) {
+                    } else if (mSaveNum == SAVE_HALF && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_MINUS && mSaveIndex < mSaveTo.size() && ret != null) {
+                        int half = ret.size() / 2 - 1;
+                        half = half < 0 ? 0 : half;
+                        for (int i = ret.size() - 1; i > half; i--) {
+                            ret.remove(i);
+                        }
+                    } else if (mSaveNum == SAVE_HALF_RAMDOM && mSaveIndex < mSaveTo.size() && ret != null) {
+                        Set<Integer> free = getRandomIndex(ret, ret.size() / 2 + 1);
+                        for (Integer index : free) {
+                            ret.set(index, null);
+                        }
+                    } else if (ret != null) {
+                        int i = ret.size() > mSaveNum ? mSaveNum : ret.size();
+                        for (i = ret.size() - 1; i > 0; i--) {
+                            ret.remove(i);
+                        }
+                    }
+                    if (mCallBackAfterFree != null) {
+                        mCallBackAfterFree.run();
+                    }
+                    synchronized (mSaveTo) {
+                        mSaveTo.set(mSaveIndex, ret);
+                    }
+                }
+                trySleep(mSleepTime);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0336-rc-Memory-normalTestCase23/expected.txt b/testsuite/java_test/rc_test/RC0336-rc-Memory-normalTestCase23/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0336-rc-Memory-normalTestCase23/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0336-rc-Memory-normalTestCase23/test.cfg b/testsuite/java_test/rc_test/RC0336-rc-Memory-normalTestCase23/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7e12a70a3c347ae2b812cf1cc9b2953ff19ad0e3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0336-rc-Memory-normalTestCase23/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase23)
+run(Memory_normalTestCase23,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0337-rc-Memory-normalTestCase27/Memory_normalTestCase27.java b/testsuite/java_test/rc_test/RC0337-rc-Memory-normalTestCase27/Memory_normalTestCase27.java
new file mode 100755
index 0000000000000000000000000000000000000000..ee6cdbeee2c944c5e77f98a7a7be5001f7b1b2df
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0337-rc-Memory-normalTestCase27/Memory_normalTestCase27.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.*;
+public class Memory_normalTestCase27 {
+    static final int PAGE_SIZE = 4016;
+    static final int PAGE_HEADSIZE = 80;
+    static final int OBJ_MAX_SIZE = 1008;
+    static final int OBJ_HEADSIZE = 16;
+    private static final int DEFAULT_THREAD_NUM = 80;
+    static final int MAX_SLOT_NUM = 62;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static boolean mRunning = true;
+    static final int LOCAL_MAX_IDX = 15;
+    public static final int LOCAL_MIN_IDX = 0;
+    public static final int GLOBAL_MAX_IDX = 62;
+    static final int GLOBAL_MIN_IDX = 16;
+    static final int LARGE_PAGE_SIZE = 4096;
+    static final int LARGEOBJ_CHOSEN_NUM = 2;
+    static final int LARGEOBJ_ALLOC_SIZE = 128 * LARGE_PAGE_SIZE;
+    private static final int DEFAULT_REPEAT_TIMES = 1;
+    private static final int ALLOC_16K = 16 * 1024;
+    private static final int ALLOC_12K = 12 * 1024;
+    private static final int ALLOC_8K = 8 * 1024;
+    private static final int ALLOC_4K = 4 * 1024;
+    private static final int ALLOC_2K = 2 * 1024;
+    private static final int DEFAULT_STRESS_THREAD_NUM = 60;
+    private static final int DEFAULT_STRESS_THREAD_NUM_HALF = DEFAULT_STRESS_THREAD_NUM / 2;
+    private static ArrayList<Thread> mThreadList = new ArrayList<Thread>();
+    public static void testCase27() {
+        RCWeakProxyTest.RCWeakProxyTestEntry();
+    }
+    public static void main(String[] args) {
+        testCase27();
+        System.out.println("ExpectResult");
+    }
+}
+class RCWeakProxyTest {
+    static class A {
+        Object o;
+    }
+    static class ThreadRunning extends Thread {
+        HashMap map;
+        Hashtable table;
+        ThreadRunning(HashMap m, Hashtable t) {
+            super("testCase_RCWeakProxy");
+            map = m;
+            table = t;
+        }
+        int foo() {
+            return map.values().size();
+        }
+        public void run() {
+            for (int i = 0; i < 500; i++) {
+                /*
+                 * Collection c = map.values(); if (c == null) {
+                 * System.out.println("error"); return; } int x = c.size();
+               */
+
+
+                int x = foo();
+                if (x == 100) {
+                } else {
+                    A a = new A();
+                    a = new A();
+                }
+                /*
+                 * int y = table.values().size(); if (y == 100) {
+                 * System.out.println("bla"); }
+               */
+
+
+            }
+        }
+    }
+    public static void RCWeakProxyTestEntry() {
+        HashMap map = new HashMap();
+        map.put("key1", "value1");
+        Hashtable table = new Hashtable();
+        table.put("key1", "value1");
+        int num_thread = 2;
+        ThreadRunning t[] = new ThreadRunning[num_thread];
+        for (int i = 0; i < num_thread; i++) {
+            t[i] = new ThreadRunning(map, table);
+            t[i].start();
+        }
+        try {
+            for (int i = 0; i < num_thread; i++) {
+                t[i].join();
+            }
+        } catch (Exception e) {
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0337-rc-Memory-normalTestCase27/expected.txt b/testsuite/java_test/rc_test/RC0337-rc-Memory-normalTestCase27/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0337-rc-Memory-normalTestCase27/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0337-rc-Memory-normalTestCase27/test.cfg b/testsuite/java_test/rc_test/RC0337-rc-Memory-normalTestCase27/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d7112353393e212a7a55eff74f8f121988790b71
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0337-rc-Memory-normalTestCase27/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase27)
+run(Memory_normalTestCase27,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0338-rc-Memory-normalTestCase28/Memory_normalTestCase28.java b/testsuite/java_test/rc_test/RC0338-rc-Memory-normalTestCase28/Memory_normalTestCase28.java
new file mode 100755
index 0000000000000000000000000000000000000000..c5471185baddbdb02619960e3f1837891fd9e130
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0338-rc-Memory-normalTestCase28/Memory_normalTestCase28.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+public class Memory_normalTestCase28 {
+    private static final int DEFAULT_THREAD_NUM = 80;
+    public static final int LOCAL_MIN_IDX = 0;
+    private static final int DEFAULT_STRESS_THREAD_NUM = 60;
+    private static final String MODULE_NAME_MEMT = "MemAllocTest";
+    static List<List<AllocUnit>> mAllStressThreadReference = new ArrayList<List<AllocUnit>>();
+    private static ArrayList<Thread> mThreadList = new ArrayList<Thread>();
+    private static void resetTestEnvirment(List<List<AllocUnit>> referenceList) {
+        int size = 0;
+        synchronized (referenceList) {
+            size = referenceList.size();
+        }
+        for (; size < 2 * DEFAULT_THREAD_NUM; size++) {
+            synchronized (referenceList) {
+                referenceList.add(null);
+            }
+        }
+        int i = 0;
+        synchronized (referenceList) {
+            for (List<AllocUnit> all : referenceList) {
+                if (all != null) {
+                    all.clear();
+                }
+                referenceList.set(i++, null);
+            }
+        }
+    }
+    public static void main(String[] args) {
+        testCase28();
+        Runtime.getRuntime().gc();
+        testCase28();
+        Runtime.getRuntime().gc();
+        testCase28();
+        Runtime.getRuntime().gc();
+        testCase28();
+        Runtime.getRuntime().gc();
+        testCase28();
+        System.out.println("ExpectResult");
+    }
+    public static void testCase28() {
+        ArrayList<Thread> list = new ArrayList<Thread>();
+        resetTestEnvirment(mAllStressThreadReference);
+        Thread t = null;
+        for (int i = 0; i < DEFAULT_THREAD_NUM / 8; i++) {
+            t = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    for (int j = 0; j < 50; j++) {
+                        NativeTestFunc nativeTestFunc = new NativeTestFunc();
+                        nativeTestFunc.testNativeWeakDelete(nativeTestFunc);
+                        System.runFinalization();
+                    }
+                }
+            }, MODULE_NAME_MEMT + "_testCase28_weak_" + i);
+            list.add(t);
+        }
+        for (int i = 0; i < DEFAULT_THREAD_NUM / 8; i++) {
+            t = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    for (int j = 0; j < 50; j++) {
+                        NativeTestFunc nativeTestFunc = new NativeTestFunc();
+                        nativeTestFunc.testNativeGlobalDelete(nativeTestFunc);
+                        System.runFinalization();
+                    }
+                }
+            }, MODULE_NAME_MEMT + "_testCase28_global_" + i);
+            list.add(t);
+        }
+        mThreadList.addAll(list);
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                if (s == null)
+                    return;
+                if (s.isAlive()) {
+                    synchronized (list) {
+                        list.remove(s);
+                    }
+                }
+            }
+        }
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+}
+class NativeTestFunc {
+    static {
+       // System.loadLibrary("StressTestNative");
+    }
+    public native void testNativeAttach();
+    public native void testNativeWeakDelete(Object input);
+    public native void testNativeGlobalDelete(Object input);
+}
diff --git a/testsuite/java_test/rc_test/RC0338-rc-Memory-normalTestCase28/expected.txt b/testsuite/java_test/rc_test/RC0338-rc-Memory-normalTestCase28/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0338-rc-Memory-normalTestCase28/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0338-rc-Memory-normalTestCase28/test.cfg b/testsuite/java_test/rc_test/RC0338-rc-Memory-normalTestCase28/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eb7968c3179cf381bbe2c6d35757a92cb800dcb3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0338-rc-Memory-normalTestCase28/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_normalTestCase28)
+run(Memory_normalTestCase28,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0339-rc-rp-cycle_all_weak/Ref_Processor_Cycle_All_Weak_Ref.java b/testsuite/java_test/rc_test/RC0339-rc-rp-cycle_all_weak/Ref_Processor_Cycle_All_Weak_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..4b0221a5a6c7a9f73457bbedc61ba2db98fd8856
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0339-rc-rp-cycle_all_weak/Ref_Processor_Cycle_All_Weak_Ref.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class Ref_Processor_Cycle_All_Weak_Ref {
+    static int checkCount = 0;
+    static final int TEST_NUM = 1;
+    static int allSum;
+    public static void main(String[] args) {
+        checkCount = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            Runtime.getRuntime().gc();
+            test_01();
+            if (allSum == 20) {
+                checkCount++;
+                System.out.println("sum is wrong");
+            }
+            if (checkCount == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println("errorResult ---- checkCount: " + checkCount);
+            }
+        }
+    }
+    private static void test_01() {
+        Cycle_A cycleA = new Cycle_A();
+        cycleA.cyb = new Cycle_B();
+        cycleA.cyb.cyc = new Cycle_C();
+        cycleA.cyb.cyc.cyd = new Cycle_D();
+        cycleA.cyb.cyc.cyd.cya = cycleA;
+        allSum = cycleA.sum + cycleA.cyb.sum + cycleA.cyb.cyc.sum + cycleA.cyb.cyc.cyd.sum;
+        sleep(2000);
+        if ((cycleA.wr.get() != null) || (cycleA.cyb.sr.get() != null) || (cycleA.cyb.cyc.pr.get() != null)
+                || (cycleA.cyb.cyc.cyd.str.get() != null)) {
+            checkCount++;
+        }
+        cycleA = null;
+        sleep(2000);
+        if (cycleA != null && cycleA.cyb != null && cycleA.cyb.cyc != null && cycleA.cyb.cyc.cyd != null
+                && cycleA.cyb.cyc.cyd.cya != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " [test_01]a1 has not free");
+        }
+    }
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+class Cycle_A {
+    Reference wr;
+    Cycle_B cyb;
+    int aNum;
+    int sum;
+    static StringBuffer stringBufferA = new StringBuffer("ref_processor_cycle_A");
+    Cycle_A() {
+        stringBufferA = new StringBuffer("ref_processor_cycle_A");
+        wr = new WeakReference<>(stringBufferA);
+        if (wr.get() == null) {
+            assert false;
+        }
+        stringBufferA = null;
+        cyb = null;
+        aNum = 1;
+    }
+    int joinStr() {
+        try {
+            sum = aNum + cyb.bNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+class Cycle_B {
+    Reference sr;
+    Cycle_C cyc;
+    int bNum;
+    int sum;
+    static StringBuffer stringBufferB = new StringBuffer("ref_processor_cycle_B");
+    Cycle_B() {
+        stringBufferB = new StringBuffer("ref_processor_cycle_B");
+        sr = new WeakReference<>(stringBufferB);
+        if (sr.get() == null) {
+            assert false;
+        }
+        stringBufferB = null;
+        cyc = null;
+        bNum = 2;
+    }
+    int joinStr() {
+        try {
+            sum = bNum + cyc.cNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+class Cycle_C {
+    Reference pr;
+    Cycle_D cyd;
+    StringBuffer stringBufferC = new StringBuffer("ref_processor_cycle_C");
+    int sum;
+    int cNum;
+    Cycle_C() {
+        stringBufferC = new StringBuffer("ref_processor_cycle_C");
+        pr = new WeakReference<>(stringBufferC);
+        if (pr.get() == null) {
+            assert false;
+        }
+        stringBufferC = null;
+        cyd = null;
+        cNum = 3;
+    }
+    int joinStr() {
+        try {
+            sum = cNum + cyd.dNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+class Cycle_D {
+    Reference str;
+    Cycle_A cya;
+    StringBuffer stringBufferD = new StringBuffer("ref_processor_cycle_D");
+    int dNum;
+    int sum;
+    Cycle_D() {
+        stringBufferD = new StringBuffer("ref_processor_cycle_D");
+        str = new WeakReference<StringBuffer>(stringBufferD);
+        stringBufferD = null;
+        cya = null;
+        dNum = 4;
+    }
+    int joinStr() {
+        try {
+            int sum = dNum + cya.aNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0339-rc-rp-cycle_all_weak/test.cfg b/testsuite/java_test/rc_test/RC0339-rc-rp-cycle_all_weak/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..fe168a2691b4225a864552c4b657fd1b6406d085
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0339-rc-rp-cycle_all_weak/test.cfg
@@ -0,0 +1,2 @@
+compile(Ref_Processor_Cycle_All_Weak_Ref)
+run(Ref_Processor_Cycle_All_Weak_Ref,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0340-rc-rp-cycle_weak_strong/Ref_Processor_Cycle_Weak_Strong_Ref.java b/testsuite/java_test/rc_test/RC0340-rc-rp-cycle_weak_strong/Ref_Processor_Cycle_Weak_Strong_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..1401d5f831a92ad0bf10704e612011b46903f5d8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0340-rc-rp-cycle_weak_strong/Ref_Processor_Cycle_Weak_Strong_Ref.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class Ref_Processor_Cycle_Weak_Strong_Ref {
+    static int checkCount = 0;
+    static final int TEST_NUM = 1;
+    static int allSum;
+    public static void main(String[] args) {
+        checkCount = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            Runtime.getRuntime().gc();
+            test_01();
+            if (allSum == 20) {
+                checkCount++;
+                System.out.println("sum is wrong");
+            }
+            if (checkCount == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println("errorResult ---- checkCount: " + checkCount);
+            }
+        }
+    }
+    private static void test_01() {
+        Cycle_A cycleA = new Cycle_A();
+        cycleA.cyb = new Cycle_B();
+        cycleA.cyb.cyc = new Cycle_C();
+        cycleA.cyb.cyc.cyd = new Cycle_D();
+        cycleA.cyb.cyc.cyd.cya = cycleA;
+        allSum = cycleA.sum + cycleA.cyb.sum + cycleA.cyb.cyc.sum + cycleA.cyb.cyc.cyd.sum;
+        sleep(2000);
+        if ((cycleA.wr.get() != null) || (cycleA.cyb.sr.get() != null) || (cycleA.cyb.cyc.pr.get() != null)
+                || (cycleA.cyb.cyc.cyd.string == null)) {
+            checkCount++;
+        }
+        cycleA = null;
+        sleep(2000);
+        if (cycleA != null && cycleA.cyb != null && cycleA.cyb.cyc != null && cycleA.cyb.cyc.cyd != null
+                && cycleA.cyb.cyc.cyd.cya != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " [test_01]a1 has not free");
+        }
+    }
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+class Cycle_A {
+    Reference wr;
+    Cycle_B cyb;
+    int aNum;
+    int sum;
+    static StringBuffer stringBufferA = new StringBuffer("ref_processor_cycle_A");
+    Cycle_A() {
+        stringBufferA = new StringBuffer("ref_processor_cycle_A");
+        wr = new WeakReference<>(stringBufferA);
+        if (wr.get() == null) {
+            assert false;
+        }
+        stringBufferA = null;
+        cyb = null;
+        aNum = 1;
+    }
+    int joinStr() {
+        try {
+            sum = aNum + cyb.bNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+class Cycle_B {
+    Reference sr;
+    Cycle_C cyc;
+    int bNum;
+    int sum;
+    static StringBuffer stringBufferB = new StringBuffer("ref_processor_cycle_B");
+    Cycle_B() {
+        stringBufferB = new StringBuffer("ref_processor_cycle_B");
+        sr = new WeakReference<>(stringBufferB);
+        if (sr.get() == null) {
+            assert false;
+        }
+        stringBufferB = null;
+        cyc = null;
+        bNum = 2;
+    }
+    int joinStr() {
+        try {
+            sum = bNum + cyc.cNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+class Cycle_C {
+    Reference pr;
+    Cycle_D cyd;
+    StringBuffer stringBufferC = new StringBuffer("ref_processor_cycle_C");
+    int sum;
+    int cNum;
+    Cycle_C() {
+        stringBufferC = new StringBuffer("ref_processor_cycle_C");
+        pr = new WeakReference<>(stringBufferC);
+        if (pr.get() == null) {
+            assert false;
+        }
+        stringBufferC = null;
+        cyd = null;
+        cNum = 3;
+    }
+    int joinStr() {
+        try {
+            sum = cNum + cyd.dNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+class Cycle_D {
+    String string;
+    Cycle_A cya;
+    int dNum;
+    int sum;
+    Cycle_D() {
+        string = new String("ref_processor_cycle_D");
+        cya = null;
+        dNum = 4;
+    }
+    int joinStr() {
+        try {
+            int sum = dNum + cya.aNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0340-rc-rp-cycle_weak_strong/test.cfg b/testsuite/java_test/rc_test/RC0340-rc-rp-cycle_weak_strong/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ff1c019d63524199ee5ac56121e1ee6f06094de3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0340-rc-rp-cycle_weak_strong/test.cfg
@@ -0,0 +1,2 @@
+compile(Ref_Processor_Cycle_Weak_Strong_Ref)
+run(Ref_Processor_Cycle_Weak_Strong_Ref,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0341-rc-rp-mutator/Ref_Processor_Mutator_Ref.java b/testsuite/java_test/rc_test/RC0341-rc-rp-mutator/Ref_Processor_Mutator_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..1207da6cde6a6000c9032b652919659bbf492bbc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0341-rc-rp-mutator/Ref_Processor_Mutator_Ref.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class Ref_Processor_Mutator_Ref {
+    static int check_count = 0;
+    static final int TEST_NUM = 1;
+    static Reference wr, sr, pr;
+    static ReferenceQueue wrq, srq, prq;
+    static StringBuffer stringBuffer1 = new StringBuffer("weak");
+    static StringBuffer stringBuffer2 = new StringBuffer("soft");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        if (check_count == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error,check_count: " + check_count);
+        }
+    }
+    private static void test() {
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            sleep(2000);
+            if (wr.get() != null) {
+                check_count++;
+            }
+            if (sr.get() != null) {
+                check_count++;
+            }
+        }
+        Reference wrqPoll, srqPoll, prqPoll;
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                check_count++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                        "wrq.poll()");
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                check_count++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                        "srq.poll()");
+            }
+        }
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                check_count++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                        "prq.poll()");
+            }
+        }
+    }
+    public static void test_01() {
+        wrq = new ReferenceQueue();
+        srq = new ReferenceQueue();
+        prq = new ReferenceQueue();
+        stringBuffer1 = new StringBuffer("weak");
+        stringBuffer2 = new StringBuffer("soft");
+        stringBuffer3 = new StringBuffer("phantom");
+        wr = new WeakReference<StringBuffer>(stringBuffer1, wrq);
+        if (wr.get() == null) {
+            check_count++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ----------------------" +
+                    "check_count: " + check_count);
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in wr");
+        }
+        sr = new WeakReference<StringBuffer>(stringBuffer2, srq);
+        if (sr.get() == null) {
+            check_count++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ----------------------" +
+                    "check_count: " + check_count);
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in sr");
+        }
+        pr = new PhantomReference<StringBuffer>(stringBuffer3, prq);
+        if (pr.get() != null) {
+            check_count++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ----------------------" +
+                    "check_count: " + check_count);
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in pr");
+        }
+        stringBuffer1 = null;
+        stringBuffer2 = null;
+        stringBuffer3 = null;
+    }
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0341-rc-rp-mutator/test.cfg b/testsuite/java_test/rc_test/RC0341-rc-rp-mutator/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..690a33e0224da55a53459b7d770dea0e5935caba
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0341-rc-rp-mutator/test.cfg
@@ -0,0 +1,2 @@
+compile(Ref_Processor_Mutator_Ref)
+run(Ref_Processor_Mutator_Ref,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0342-rc-rp-weak_ref_boundary/Ref_Processor_Weak_Ref_Boundary.java b/testsuite/java_test/rc_test/RC0342-rc-rp-weak_ref_boundary/Ref_Processor_Weak_Ref_Boundary.java
new file mode 100755
index 0000000000000000000000000000000000000000..1fd6c4406c8c8c678818c2db480b7c6597a7a139
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0342-rc-rp-weak_ref_boundary/Ref_Processor_Weak_Ref_Boundary.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class Ref_Processor_Weak_Ref_Boundary {
+    static int checkCount = 0;
+    static final int TEST_NUM = 1;
+    static WeakReference wr[] = new WeakReference[14];
+    static WeakReference sr[] = new WeakReference[14];
+    static PhantomReference pr[] = new PhantomReference[14];
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        //Result judgment
+        if (checkCount == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("errorResult,checkNum: " + checkCount);
+        }
+    }
+    private static void test() {
+        //test01: 14 mix weak references
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+        }
+        sleep(1000);
+    }
+    public static void setSoftRef(int times) {
+        stringBuffer1 = new StringBuffer("soft");
+        for (int i = 0; i < times; i++) {
+            sr[i] = new WeakReference<Object>(stringBuffer1, srq);
+            if (sr[i].get() == null) {
+                System.out.println(" ---------------error in sr of test01");
+                checkCount++;
+            }
+        }
+        stringBuffer1 = null;
+    }
+    public static void setWeakRef(int times) {
+        stringBuffer2 = new StringBuffer("Weak");
+        for (int i = 0; i < times; i++) {
+            wr[i] = new WeakReference<Object>(stringBuffer2, wrq);
+            if (wr[i].get() == null) {
+                System.out.println(" ---------------error in wr of test01");
+                checkCount++;
+            }
+        }
+        stringBuffer2 = null;
+    }
+    public static void setPhantomRef(int times) {
+        stringBuffer3 = new StringBuffer("phantom");
+        for (int i = 0; i < times; i++) {
+            pr[i] = new PhantomReference<Object>(stringBuffer3, prq);
+            if (pr[i].get() != null) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ---------------" +
+                        "error in pr of test01");
+                checkCount++;
+            }
+        }
+        stringBuffer3 = null;
+    }
+    public static void test_01() {
+        /* 14 mix weak references*/
+
+        setSoftRef(5);
+        checkSoftRq("soft", 5);
+        setWeakRef(4);
+        checkWeakRq("weak", 4);
+        setPhantomRef(5);
+        checkPhantomRq("phantom");
+        setSoftRef(5);
+        checkSoftRq("soft", 5);
+        setWeakRef(5);
+        checkWeakRq("weak", 5);
+        setPhantomRef(5);
+        checkPhantomRq("phantom");
+        setSoftRef(5);
+        checkSoftRq("soft", 5);
+        setWeakRef(6);
+        checkWeakRq("weak", 6);
+        setPhantomRef(5);
+        checkPhantomRq("phantom");
+    }
+    public static void checkSoftRq(String funName, int times) {
+        Reference srqPoll;
+        sleep(2000);
+        if (sr != null) {
+            for (int i = 0; i < times; i++) {
+                if (sr[i].get() != null) {
+                    checkCount++;
+                    System.out.println(" ErrorResult in sr      " + funName);
+                }
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in srq.poll()");
+            }
+        }
+    }
+    public static void checkWeakRq(String funName, int times) {
+        Reference wrqPoll;
+        sleep(2000);
+        for (int i = 0; i < times; i++) {
+            if (wr[i].get() != null) {
+                checkCount++;
+                System.out.println(" ErrorResult in wr       " + funName + "times:" + i);
+            }
+        }
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in wrq.poll()");
+            }
+        }
+    }
+    public static void checkPhantomRq(String funName) {
+        Reference prqPoll;
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in prq.poll()");
+            }
+        }
+    }
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0342-rc-rp-weak_ref_boundary/test.cfg b/testsuite/java_test/rc_test/RC0342-rc-rp-weak_ref_boundary/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d6b10e81777320bdd71eed9a44f7766b0dedd7e2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0342-rc-rp-weak_ref_boundary/test.cfg
@@ -0,0 +1,2 @@
+compile(Ref_Processor_Weak_Ref_Boundary)
+run(Ref_Processor_Weak_Ref_Boundary,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0343-rc-rp-wcb_test_ref/Ref_Processor_Wcb_Test_Ref.java b/testsuite/java_test/rc_test/RC0343-rc-rp-wcb_test_ref/Ref_Processor_Wcb_Test_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..ff757c0405a4e08d0122dba297126041bca0470e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0343-rc-rp-wcb_test_ref/Ref_Processor_Wcb_Test_Ref.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class Ref_Processor_Wcb_Test_Ref {
+    static int checkCount = 0;
+    static final int TEST_NUM = 1;
+    static Reference wr, sr, pr;
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        if (checkCount == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("errorResult ---- checkcount: " + checkCount);
+        }
+    }
+    private static void test() {
+        // test: if WCB == 0, return object value
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            sleep(1000);
+        }
+        // test: if WCB == 1, return null
+        checkRet("test step 2");
+        // test: check change WCB 1 to 0
+    }
+    private static void test_01() {
+        /*if WCB == 0, return object value except PhantomReference*/
+        stringBuffer1 = new StringBuffer("soft");
+        stringBuffer2 = new StringBuffer("weak");
+        stringBuffer3 = new StringBuffer("phantom");
+        wr = new WeakReference<Object>(stringBuffer2, wrq);
+        if (wr.get() == null) {
+            checkCount++;
+        }
+        sr = new WeakReference<Object>(stringBuffer1, srq);
+        if (sr.get() == null) {
+            checkCount++;
+        }
+        pr = new PhantomReference<Object>(stringBuffer3, prq);
+        if (pr.get() != null) {
+            checkCount++;
+        }
+        stringBuffer2 = null;
+        stringBuffer1 = null;
+        stringBuffer3 = null;
+    }
+    private static void checkRet(String funName) {
+        sleep(2000);
+        Reference wrqPoll, srqPoll, prqPoll;
+        if (sr.get() != null) {
+            checkCount++;
+        }
+        if (wr.get() != null) {
+            checkCount++;
+        }
+        if (pr.get() != null) {
+            checkCount++;
+        }
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in wrq.poll()");
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in srq.poll()");
+            }
+        }
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                checkCount++;
+                System.out.println(" ErrorResult in prq.poll()");
+            }
+        }
+    }
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0343-rc-rp-wcb_test_ref/test.cfg b/testsuite/java_test/rc_test/RC0343-rc-rp-wcb_test_ref/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..395023967d4d4116814872bc1bc748ec22e1ffae
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0343-rc-rp-wcb_test_ref/test.cfg
@@ -0,0 +1,2 @@
+compile(Ref_Processor_Wcb_Test_Ref)
+run(Ref_Processor_Wcb_Test_Ref,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0344-rc-rp-test_aged_ref/Ref_Processor_Aged_Ref.java b/testsuite/java_test/rc_test/RC0344-rc-rp-test_aged_ref/Ref_Processor_Aged_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..32eb0bf5d2e71ddec7ff277a1e326055c737b38e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0344-rc-rp-test_aged_ref/Ref_Processor_Aged_Ref.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class Ref_Processor_Aged_Ref {
+    static int check_count = 0;
+    static final int TEST_NUM = 1;
+    static final int AGED_NUM = 3;
+    static WeakReference sr[] = new WeakReference[AGED_NUM + 1];
+    static WeakReference wr[] = new WeakReference[AGED_NUM + 1];
+    static PhantomReference pr[] = new PhantomReference[AGED_NUM + 1];
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("WeakReference");
+    static StringBuffer obj2 = new StringBuffer("WeakReference");
+    static StringBuffer obj3 = new StringBuffer("PhantomReference");
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        if (check_count == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check_count : " + check_count);
+        }
+    }
+    public static void test() {
+        for (int i = 0; i < TEST_NUM; i++) {
+            // Threshold for Ref object == age - 1
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM - 1);
+            checkRef(AGED_NUM - 1);
+            // Threshold for Ref object == age
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM);
+            checkRef(AGED_NUM);
+            // Threshold for Ref object == age + 1
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM + 1);
+            checkRef(AGED_NUM + 1);
+            // Has entered the Aged Ref queue
+            // The number of processing == X-1
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM - 1);
+            checkRef(AGED_NUM - 1);
+            //the number of processing == X
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM);
+            checkRef(AGED_NUM);
+            //the number of processing == X+1
+            obj1 = new StringBuffer("WeakReference");
+            obj2 = new StringBuffer("WeakReference");
+            obj3 = new StringBuffer("PhantomReference");
+            setRef(AGED_NUM + 1);
+            checkRef(AGED_NUM + 1);
+        }
+    }
+    public static void setRef(int repeat_time) {
+        /*Threshold for Ref object == age - 1*/
+        for (int i = 0; i < repeat_time; i++) {
+            sr[i] = new WeakReference<StringBuffer>(obj1, srq);
+            if (sr[i].get() == null) {
+                check_count++;
+                System.out.println("sr in setRef    " + i + "repeat_time:" + repeat_time);
+            }
+            wr[i] = new WeakReference<StringBuffer>(obj2, wrq);
+            if (wr[i].get() == null) {
+                check_count++;
+                System.out.println("wr in setRef     " + i + "repeat_time:" + repeat_time);
+            }
+            pr[i] = new PhantomReference<StringBuffer>(obj3, prq);
+            if (pr[i].get() != null) {
+                check_count++;
+                System.out.println("pr in setRef");
+            }
+        }
+        obj1 = null;
+        obj2 = null;
+        obj3 = null;
+    }
+    public static void checkRef(int repeat_time) {
+        sleep(2000);
+        for (int i = 0; i < repeat_time; i++) {
+            if (sr[i].get() != null) {
+                check_count++;
+            }
+            if (wr[i].get() != null) {
+                check_count++;
+            }
+            Reference wrqPoll, srqPoll, prqPoll;
+            while ((wrqPoll = wrq.poll()) != null) {
+                if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in wrq.poll()");
+                }
+            }
+            while ((srqPoll = srq.poll()) != null) {
+                if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in srq.poll()");
+                }
+            }
+            while ((prqPoll = prq.poll()) != null) {
+                if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in prq.poll()");
+                }
+            }
+        }
+    }
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(" sleep was Interrupted");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0344-rc-rp-test_aged_ref/test.cfg b/testsuite/java_test/rc_test/RC0344-rc-rp-test_aged_ref/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a3e8ca9c38c284c7d167d06f9c01d3ca0af131e2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0344-rc-rp-test_aged_ref/test.cfg
@@ -0,0 +1,2 @@
+compile(Ref_Processor_Aged_Ref)
+run(Ref_Processor_Aged_Ref,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0345-rc-rp-single_or_more/Ref_Processor_Single_Or_More_Weak_Ref.java b/testsuite/java_test/rc_test/RC0345-rc-rp-single_or_more/Ref_Processor_Single_Or_More_Weak_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..91778bfa778bd5d56e554ba7514987a3cc773585
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0345-rc-rp-single_or_more/Ref_Processor_Single_Or_More_Weak_Ref.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class Ref_Processor_Single_Or_More_Weak_Ref {
+    static int check_count = 0;
+    static final int TEST_NUM = 1;
+    static Reference wr, sr, pr;
+    static ReferenceQueue wrq, srq, prq;
+    static StringBuffer obj_1 = new StringBuffer("hello");
+    static StringBuffer obj_2 = new StringBuffer("kitty");
+    static StringBuffer obj_3 = new StringBuffer("mikey");
+    static StringBuffer obj4 = new StringBuffer("WeakReference");
+    static StringBuffer obj5 = new StringBuffer("WeakReference");
+    static StringBuffer obj6 = new StringBuffer("PhantomReference");
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        if (check_count == 0)
+            System.out.println("ExpectResult");
+        else {
+            System.out.println("ErrorResult, check_count:" + check_count);
+        }
+    }
+    private static void test() {
+        Reference wrqPoll, srqPoll, prqPoll;
+        for (int i = 0; i < TEST_NUM; i++) {
+            weakRef();
+            sleep(2000);
+            if (wr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in weakRef step1");
+            }
+            while ((wrqPoll = wrq.poll()) != null) {
+                if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in wrq.poll() step2");
+                }
+            }
+        }
+        // check WeakReference
+        for (int i = 0; i < TEST_NUM; i++) {
+            softRef();
+            sleep(2000);
+            if (sr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in softRef step2");
+            }
+            while ((srqPoll = srq.poll()) != null) {
+                if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in srq.poll()");
+                }
+            }
+        }
+        // check PhantomReference
+        for (int i = 0; i < TEST_NUM; i++) {
+            phantomRef();
+            sleep(2000);
+            while ((prqPoll = prq.poll()) != null) {
+                if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in prq.poll()");
+                }
+            }
+        }
+        // more than one reference
+        for (int i = 0; i < TEST_NUM; i++) {
+            mixRef();
+            sleep(2000);
+            if (wr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in mixRef step2:weakRef");
+            }
+            if (sr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in mixRef step2:softRef");
+            }
+            if (pr.get() != null) {
+                check_count++;
+                System.out.println(" ErrorResult in mixRef step2:phantomRef");
+            }
+            while ((wrqPoll = wrq.poll()) != null) {
+                if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in wrq.poll()");
+                }
+            }
+            while ((srqPoll = srq.poll()) != null) {
+                if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in srq.poll()");
+                }
+            }
+            while ((prqPoll = prq.poll()) != null) {
+                if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                    check_count++;
+                    System.out.println(" ErrorResult in prq.poll()");
+                }
+            }
+        }
+    }
+    private static void weakRef() {
+        wrq = new ReferenceQueue();
+        obj_1 = new StringBuffer("hello");
+        wr = new WeakReference<StringBuffer>(obj_1, wrq);
+        if (wr.get() == null) {
+            check_count++;
+            System.out.println(" ErrorResult in weakRef step1");
+        }
+        obj_1 = null;
+    }
+    private static void softRef() {
+        srq = new ReferenceQueue();
+        obj_2 = new StringBuffer("kitty");
+        sr = new WeakReference<StringBuffer>(obj_2, srq);
+        if (sr.get() == null) {
+            check_count++;
+            System.out.println(" ErrorResult in softRef step1");
+        }
+        obj_2 = null;
+    }
+    private static void phantomRef() {
+        obj_3 = new StringBuffer("mikey");
+        prq = new ReferenceQueue();
+        pr = new PhantomReference<StringBuffer>(obj_3, prq);
+        if (pr.get() != null) {
+            check_count++;
+            System.out.println(" ErrorResult in phantomRef step1");
+        }
+        obj_3 = null;
+    }
+    private static void mixRef() {
+        wrq = new ReferenceQueue();
+        srq = new ReferenceQueue();
+        prq = new ReferenceQueue();
+        obj4 = new StringBuffer("WeakReference");
+        obj5 = new StringBuffer("WeakReference");
+        obj6 = new StringBuffer("PhantomReference");
+        wr = new WeakReference<StringBuffer>(obj4, wrq);
+        if (wr.get() == null) {
+            check_count++;
+            System.out.println(" ErrorResult of wr in mixRef step1");
+        }
+        sr = new WeakReference<StringBuffer>(obj5, srq);
+        if (sr.get() == null) {
+            check_count++;
+            System.out.println(" ErrorResult of sr in mixRef step2");
+        }
+        pr = new PhantomReference<StringBuffer>(obj6, prq);
+        if (pr.get() != null) {
+            check_count++;
+            System.out.println(" ErrorResult of pr in mixRef step3");
+        }
+        obj4 = null;
+        obj5 = null;
+        obj6 = null;
+    }
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println(" sleep was Interrupted");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0345-rc-rp-single_or_more/test.cfg b/testsuite/java_test/rc_test/RC0345-rc-rp-single_or_more/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c9e17ef20d622f06c63a2420067ab6dec9b55d61
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0345-rc-rp-single_or_more/test.cfg
@@ -0,0 +1,2 @@
+compile(Ref_Processor_Single_Or_More_Weak_Ref)
+run(Ref_Processor_Single_Or_More_Weak_Ref,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0346-rc-rp-strong_and_weak/Ref_Processor_Strong_And_Weak_Ref.java b/testsuite/java_test/rc_test/RC0346-rc-rp-strong_and_weak/Ref_Processor_Strong_And_Weak_Ref.java
new file mode 100755
index 0000000000000000000000000000000000000000..3a29a0a586cf11bc1be7c31a8dbbd6349ee641a5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0346-rc-rp-strong_and_weak/Ref_Processor_Strong_And_Weak_Ref.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class Ref_Processor_Strong_And_Weak_Ref {
+    static int check_count = 0;
+    static final int TEST_NUM = 1;
+    static String rf = new String("test");
+    static Reference wr, sr, pr;
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("weak");
+    static StringBuffer obj2 = new StringBuffer("soft");
+    static StringBuffer obj3 = new StringBuffer("phantom");
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        if (check_count == 0){
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult check_count : " + check_count);
+        }
+    }
+    private static void test() {
+        // strong and weak reference, first free strong, next free weak
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+        }
+        checkRq("test_01_02");
+    }
+    private static void test_01() {
+        /* strong and weak reference, first free strong, next free weak*/
+
+        obj1 = new StringBuffer("weak");
+        obj2 = new StringBuffer("soft");
+        obj3 = new StringBuffer("phantom");
+        wr = new WeakReference<Object>(obj1, wrq);
+        if (wr.get() == null) {
+            check_count++;
+            System.out.println("error in test01---------------wr");
+        }
+        sr = new WeakReference<Object>(obj2, srq);
+        if (sr.get() == null) {
+            check_count++;
+            System.out.println("error in test01----------------sr");
+        }
+        pr = new PhantomReference<Object>(obj3, prq);
+        if (pr.get() != null) {
+            check_count++;
+            System.out.println("error in test01----------------pr");
+        }
+        obj1 = null;
+        obj2 = null;
+        obj3 = null;
+        if (rf == null) {
+            check_count++;
+            System.out.println("error in test01-----------rf");
+        }
+    }
+    private static void checkRq(String funName) {
+        Reference wrqPoll, srqPoll, prqPoll;
+        sleep(2000);
+        if (wr.get() != null) {
+            System.out.println("error in checkRq---------------wr");
+            check_count++;
+        }
+        if (sr.get() != null) {
+            System.out.println("error in checkRq--------------sr");
+            check_count++;
+        }
+        if (rf == null || (!rf.equals("test"))) {
+            System.out.println("error in checkRq---------------rf");
+            check_count++;
+        }
+        while ((wrqPoll = wrq.poll()) != null) {
+            if (!wrqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                check_count++;
+                System.out.println("ErrorResult in wrq.poll()");
+            }
+        }
+        while ((srqPoll = srq.poll()) != null) {
+            if (!srqPoll.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                check_count++;
+                System.out.println("ErrorResult in srq.poll()");
+            }
+        }
+        while ((prqPoll = prq.poll()) != null) {
+            if (!prqPoll.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                check_count++;
+                System.out.println("ErrorResult in prq.poll()");
+            }
+        }
+    }
+    private static void sleep(int sleepNum) {
+        try {
+            Thread.sleep(sleepNum);
+        } catch (InterruptedException e) {
+            System.out.println("sleep was Interrupted");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0346-rc-rp-strong_and_weak/test.cfg b/testsuite/java_test/rc_test/RC0346-rc-rp-strong_and_weak/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d197cc30434ab9a9fde0c843eb2235fb23ec9d4a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0346-rc-rp-strong_and_weak/test.cfg
@@ -0,0 +1,2 @@
+compile(Ref_Processor_Strong_And_Weak_Ref)
+run(Ref_Processor_Strong_And_Weak_Ref,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0347-rc-rp-simulthread/SimulThreadInRef.java b/testsuite/java_test/rc_test/RC0347-rc-rp-simulthread/SimulThreadInRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..08accef63fd1cbe8b477bdf656c1c8f3a41f0bc4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0347-rc-rp-simulthread/SimulThreadInRef.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class SimulThreadInRef {
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+    }
+    static void test() {
+        int soft, weak, phantom;
+        soft = testExecuteSoft();
+        Runtime.getRuntime().gc();
+        soft = testExecuteSoft();
+        weak = testExecuteWeak();
+        Runtime.getRuntime().gc();
+        weak = testExecuteWeak();
+        phantom = testExecutePhantom();
+        Runtime.getRuntime().gc();
+        phantom = testExecutePhantom();
+        testExecuteOther();
+        Runtime.getRuntime().gc();
+        if ((soft == 0) && (weak == 0) && (phantom == 0)) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+    static int testExecuteSoft() {
+        MultiRef multiRef = new MultiRef();
+        ThreadTestSoftRef threadTestSoftRef = new ThreadTestSoftRef(multiRef);
+        int N = 1;
+        for (int i = 0; i < N; i++) {
+            threadTestSoftRef.run();
+        }
+        return threadTestSoftRef.count1;
+    }
+    static int testExecuteWeak() {
+        MultiRef multiRef = new MultiRef();
+        ThreadTestWeakRef threadTestWeakRef = new ThreadTestWeakRef(multiRef);
+        int N = 1;
+        for (int i = 0; i < N; i++) {
+            threadTestWeakRef.run();
+        }
+        return threadTestWeakRef.count2;
+    }
+    static int testExecutePhantom() {
+        MultiRef multiRef = new MultiRef();
+        ThreadTestPhantomRef threadTestPhantomRef = new ThreadTestPhantomRef(multiRef);
+        int N = 1;
+        for (int i = 0; i < N; i++) {
+            threadTestPhantomRef.run();
+        }
+        return threadTestPhantomRef.count3;
+    }
+    static void testExecuteOther() {
+        MultiRef multiRef = new MultiRef();
+        ThreadTestOtherRef threadTestOtherRef = new ThreadTestOtherRef(multiRef);
+        int N = 1;
+        for (int i = 0; i < N; i++) {
+            threadTestOtherRef.run();
+        }
+    }
+}
+class MultiRef {
+    static Reference sr, wr, pr, osr;
+    static StringBuffer obj1 = new StringBuffer("Soft");
+    static StringBuffer obj2 = new StringBuffer("weak");
+    static StringBuffer obj3 = new StringBuffer("Phantom");
+    ReferenceQueue srq = new ReferenceQueue();
+    ReferenceQueue wrq = new ReferenceQueue();
+    ReferenceQueue prq = new ReferenceQueue();
+    static int srValue, wrValue, prValue;
+    void setSoftRef() {
+        obj1 = new StringBuffer("Soft");
+        sr = new WeakReference(obj1, srq);
+        if (sr.get() == null) {
+            srValue++;
+        }
+        obj1 = null;
+    }
+    void setWeakRef() {
+        obj2 = new StringBuffer("weak");
+        wr = new WeakReference(obj2, wrq);
+        if (wr.get() == null) {
+            wrValue++;
+        }
+        obj2 = null;
+    }
+    void setPhantomRef() {
+        obj3 = new StringBuffer("Phantom");
+        pr = new PhantomReference(obj3, prq);
+        if (pr.get() != null) {
+            prValue++;
+        }
+        obj3 = null;
+    }
+    void setOtherSoftRef() {
+        osr = new WeakReference(new Object());
+    }
+    int freeSoftRef() throws InterruptedException {
+        Reference r1;
+        setSoftRef();
+        Thread.sleep(2000);
+        if (sr.get() != null) {
+            srValue++;
+            System.out.println("error in soft");
+        }
+        while ((r1 = srq.poll()) != null) {
+            if (!r1.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                srValue++;
+            }
+        }
+        return srValue;
+    }
+    int freeWeakRef() throws InterruptedException {
+        Reference r2;
+        setWeakRef();
+        Thread.sleep(2000);
+        if (wr.get() != null) {
+            wrValue++;
+            System.out.println("error in weak");
+        }
+        while ((r2 = wrq.poll()) != null) {
+            if (!r2.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                wrValue++;
+            }
+        }
+        return wrValue;
+    }
+    int freePhantomRef() throws InterruptedException {
+        Reference r1;
+        setPhantomRef();
+        Thread.sleep(2000);
+        while ((r1 = prq.poll()) != null) {
+            if (!r1.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                prValue++;
+            }
+        }
+        return prValue;
+    }
+}
+// 线程1，设置软引用
+class ThreadTestSoftRef implements Runnable {
+    MultiRef multiRef;
+    int count1;
+    public ThreadTestSoftRef(MultiRef multiRef) {
+        this.multiRef = multiRef;
+    }
+    @Override
+    public void run() {
+        try {
+            count1 = multiRef.freeSoftRef();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+// 线程2，设置弱引用
+class ThreadTestWeakRef implements Runnable {
+    MultiRef multiRef;
+    int count2;
+    public ThreadTestWeakRef(MultiRef multiRef) {
+        this.multiRef = multiRef;
+    }
+    @Override
+    public void run() {
+        try {
+            count2 = multiRef.freeWeakRef();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+// 线程3，设置虚引用
+class ThreadTestPhantomRef implements Runnable {
+    MultiRef multiRef;
+    int count3;
+    public ThreadTestPhantomRef(MultiRef multiRef) {
+        this.multiRef = multiRef;
+    }
+    @Override
+    public void run() {
+        try {
+            count3 = multiRef.freePhantomRef();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+// 线程4，设置其他引用
+class ThreadTestOtherRef implements Runnable {
+    MultiRef multiRef;
+    public ThreadTestOtherRef(MultiRef multiRef) {
+        this.multiRef = multiRef;
+    }
+    @Override
+    public void run() {
+        multiRef.setOtherSoftRef();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0347-rc-rp-simulthread/test.cfg b/testsuite/java_test/rc_test/RC0347-rc-rp-simulthread/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c25f8201d01f31d14e9b836c1eabfca267ec4beb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0347-rc-rp-simulthread/test.cfg
@@ -0,0 +1,2 @@
+compile(SimulThreadInRef)
+run(SimulThreadInRef,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0348-rc-rp-simpleweakref_01/DeadReferenceTest.java b/testsuite/java_test/rc_test/RC0348-rc-rp-simpleweakref_01/DeadReferenceTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..d76ba86ed9883070ecf438355b9efe58b97825ca
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0348-rc-rp-simpleweakref_01/DeadReferenceTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class DeadReferenceTest {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    static Reference weakRp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            deadReferenceTest();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static void setWeakRef() {
+        weakRp = new WeakReference<Object>(null, rq);
+    }
+    static void deadReferenceTest() throws InterruptedException {
+        Reference reference;
+        setWeakRef();
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        if (weakRp.get() != null) {
+            judgeNum++;
+        }
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                judgeNum++;
+            }
+        }
+    }
+}
+class ThreadRf implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0348-rc-rp-simpleweakref_01/test.cfg b/testsuite/java_test/rc_test/RC0348-rc-rp-simpleweakref_01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2751ee0d85f5c34c2054a10c3c81dfd6692a5bed
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0348-rc-rp-simpleweakref_01/test.cfg
@@ -0,0 +1,2 @@
+compile(DeadReferenceTest)
+run(DeadReferenceTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0349-rc-rp-simpleweakref_02/IsCleanerInDeadCycle.java b/testsuite/java_test/rc_test/RC0349-rc-rp-simpleweakref_02/IsCleanerInDeadCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..64c3762488cd7a70f689621e8e6a4cbf5bd8206d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0349-rc-rp-simpleweakref_02/IsCleanerInDeadCycle.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+public class IsCleanerInDeadCycle {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerInDeadCycle();
+            Runtime.getRuntime().gc();
+            isCleanerInDeadCycle();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static void isCleanerInDeadCycle() throws InterruptedException {
+        judgeNum = 0;
+        Cycle_BDec_00010_A1_Cleaner cycleBA1 = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cycleBA1);
+        cycleBA1.cycleBA2 = null;
+        cycleBA1 = null;
+        if (result == true) {
+            Thread.sleep(2000);
+            if (cycleBA1.cleaner == null || cycleBA1.cycleBA2.cleaner == null) {
+            } else {
+                judgeNum++;
+            }
+        } else {
+            judgeNum++;
+        }
+    }
+}
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    Cycle_BDec_00010_A2_Cleaner cycleBA2;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBA2, null);
+        cycleBA2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBA2.num;
+    }
+}
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBA1Cleaner;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBA1Cleaner, null);
+        cycleBA1Cleaner = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBA1Cleaner.num;
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleBDA 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleBDA) {
+        cycleBDA.add();
+        cycleBDA.cycleBA2.add();
+        int nSum = cycleBDA.sum + cycleBDA.cycleBA2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBDA1Cleaner 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner) {
+        cycleBDA1Cleaner.cycleBA2 = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBDA1Cleaner.cycleBA2.cycleBA1Cleaner = cycleBDA1Cleaner;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleBDA1Cleaner);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleBDA1Cleaner.cleaner == null && cycleBDA1Cleaner.cycleBA2.cleaner == null
+                && cycleBDA1Cleaner != null && cycleBDA1Cleaner.cycleBA2 != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0349-rc-rp-simpleweakref_02/test.cfg b/testsuite/java_test/rc_test/RC0349-rc-rp-simpleweakref_02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8f43395c54e8755799996bdf7038258d88465eae
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0349-rc-rp-simpleweakref_02/test.cfg
@@ -0,0 +1,2 @@
+compile(IsCleanerInDeadCycle)
+run(IsCleanerInDeadCycle,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0350-rc-rp-simpleweakref_03/IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java b/testsuite/java_test/rc_test/RC0350-rc-rp-simpleweakref_03/IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..3b162bad617bf9b05ae25024cc7355c7b221a017
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0350-rc-rp-simpleweakref_03/IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.*;
+public class IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Throwable {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB();
+            Runtime.getRuntime().gc();
+            isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error,judgeNum:" + judgeNum);
+        }
+    }
+    static boolean resultSetCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1) {
+        InCycle cycleA = new InCycle();
+        boolean result = cycleA.setCleanerCycle(cycleBDA1);
+        Runtime.getRuntime().gc();
+        return result;
+    }
+    static void isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB() throws Throwable {
+        Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner = new Cycle_BDec_00010_A1_Cleaner();
+        boolean result = resultSetCycle(cycleBDA1Cleaner);
+        if (result == true) {
+            cycleBDA1Cleaner.cycleBDA2Cleaner = null;
+            cycleBDA1Cleaner = null;
+            if (result == true) {
+                if (cycleBDA1Cleaner.clearSoftReference() == true) {
+                    if (cycleBDA1Cleaner.clearWeakReference() == true) {
+                        if (cycleBDA1Cleaner.clearFinalizePhantomReference() == true) {
+                            if (cycleBDA1Cleaner.clearNoFinalizePhantomReference() == true) {
+                                if (cycleBDA1Cleaner.clearFinalizeCleaner() == true) {
+                                    if (cycleBDA1Cleaner.clearNoFinalizeCleaner() == true) {
+                                    } else {
+                                        judgeNum++;
+                                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                                " ErrorResult in clearNoFinalizeCleaner--------------" +
+                                                "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                                    }
+                                } else {
+                                    judgeNum++;
+                                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " " +
+                                            "ErrorResult in clearFinalizeCleaner------------------" +
+                                            "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                                }
+                            } else {
+                                judgeNum++;
+                                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " " +
+                                        "ErrorResult in clearNoFinalizePhantomReference---------------" +
+                                        "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                            }
+                        } else {
+                            judgeNum++;
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                    + " ErrorResult in clearFinalizePhantomReference-----------------------" +
+                                    "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                        }
+                    } else {
+                        judgeNum++;
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult " +
+                                "in clearWeakReference------------------" +
+                                "isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                    }
+                } else {
+                    judgeNum++;
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                            "clearSoftReference-----------------isCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                }
+            } else {
+                judgeNum++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ErrorResult in " +
+                        "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+            }
+        }
+    }
+}
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+    /**
+     * 设置软引用,clear and enqueue
+   */
+
+
+    static Reference srp, wrp, prp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static ReferenceQueue crq = new ReferenceQueue();
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+    static void setSoftReference() {
+        stringBuffer1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(stringBuffer1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        stringBuffer1 = null;
+    }
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRf()).start();
+        System.gc();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------" +
+                    "srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------" +
+                        "srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置弱引用, clear and enqueue
+   */
+
+
+    static void setWeakReference() {
+        stringBuffer2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(stringBuffer2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        stringBuffer2 = null;
+    }
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRf()).start();
+        System.gc();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置虚引用, 没有Referent finalized,clear and enqueue
+   */
+
+
+    static void setPhantomReference() {
+        stringBuffer3 = new StringBuffer("phantom");
+        prp = new PhantomReference<Object>(stringBuffer3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        stringBuffer3 = null;
+    }
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+   */
+
+
+    static boolean clearFinalizePhantomReference() throws Throwable {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置cleaner, 没有Referent finalized,clear and enqueue
+   */
+
+
+    static void setCleaner() {
+        Cleaner crp = null;
+        String str = new String("test");
+        crp.create(str, null);
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+        }
+    }
+    static boolean clearNoFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        setCleaner();
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        while ((reference = crq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置cleaner, 经过Referent finalized，clear and enqueue
+   */
+
+
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+    static boolean clearFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        int finalValue = finalSet();
+        Runtime.getRuntime().gc();
+        if (finalValue == 200) {
+            value = value + 100;
+        }
+        setCleaner();
+        // 初次调用， Cleaner即为空
+        new Thread(new ThreadRf()).start();
+        Thread.sleep(2000);
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleB 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleB) {
+        cycleB.add();
+        cycleB.cycleBDA2Cleaner.add();
+        int nSum = cycleB.sum + cycleB.cycleBDA2Cleaner.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBDA1Cleaner 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner) {
+        cycleBDA1Cleaner.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBDA1Cleaner.cycleBDA2Cleaner.cycleBD = cycleBDA1Cleaner;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleBDA1Cleaner);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleBDA1Cleaner.cleaner == null && cycleBDA1Cleaner.cycleBDA2Cleaner.cleaner == null
+                && cycleBDA1Cleaner != null && cycleBDA1Cleaner.cycleBDA2Cleaner != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBD;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBD, null);
+        cycleBD = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBD.num;
+    }
+}
+class RC_Finalize {
+    static int value = 0;
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+}
+class ThreadRf implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0350-rc-rp-simpleweakref_03/test.cfg b/testsuite/java_test/rc_test/RC0350-rc-rp-simpleweakref_03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7cf1a7c1f3400b92f2fc9a63c9c7ac8661ed26e1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0350-rc-rp-simpleweakref_03/test.cfg
@@ -0,0 +1,2 @@
+compile(IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB)
+run(IsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0351-rc-rp-simpleweakref_04/IsCleanerNotInDeadCycleFreeRef.java b/testsuite/java_test/rc_test/RC0351-rc-rp-simpleweakref_04/IsCleanerNotInDeadCycleFreeRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..3b68bc4e2553c025491f3e040723519bf9621d09
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0351-rc-rp-simpleweakref_04/IsCleanerNotInDeadCycleFreeRef.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.*;
+public class IsCleanerNotInDeadCycleFreeRef {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleFreeRef();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleFreeRef();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static void isCleanerNotInDeadCycleFreeRef() throws InterruptedException {
+        Cleaner cleaner;
+        Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cycleBDA1Cleaner);
+        cycleBDA1Cleaner.cycleBDA2Cleaner = null;
+        if (result == true) {
+            Thread.sleep(2000);
+            if ((cycleBDA1Cleaner.cleaner == null) || (cycleBDA1Cleaner.cycleBDA2Cleaner.cleaner == null)
+                    || (cycleBDA1Cleaner != null)) {
+                while ((cleaner = (Cleaner) cycleBDA1Cleaner.rq.poll()) != null) {
+                    if (!cleaner.getClass().toString().equals("class sun.misc.Cleaner")) {
+                        judgeNum++;
+                    }
+                }
+            } else {
+                judgeNum++;
+            }
+        } else {
+            judgeNum++;
+        }
+    }
+}
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+}
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBDA1;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBDA1, null);
+        cycleBDA1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBDA1.num;
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleBD 传入的是带有Referent的类实例
+     * @return 传入的是带有Referent的类实例
+   */
+
+
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleBD) {
+        cycleBD.add();
+        cycleBD.cycleBDA2Cleaner.add();
+        int nSum = cycleBD.sum + cycleBD.cycleBDA2Cleaner.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleB
+     * @return
+   */
+
+
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleB) {
+        cycleB.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleB.cycleBDA2Cleaner.cycleBDA1 = cycleB;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleB);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleB.cleaner == null && cycleB.cycleBDA2Cleaner.cleaner == null && cycleB != null
+                && cycleB.cycleBDA2Cleaner != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0351-rc-rp-simpleweakref_04/test.cfg b/testsuite/java_test/rc_test/RC0351-rc-rp-simpleweakref_04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a63a8ae80b242a8886912636fc9e95ff312b25a5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0351-rc-rp-simpleweakref_04/test.cfg
@@ -0,0 +1,2 @@
+compile(IsCleanerNotInDeadCycleFreeRef)
+run(IsCleanerNotInDeadCycleFreeRef,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0352-rc-rp-simpleweakref_05/IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB.java b/testsuite/java_test/rc_test/RC0352-rc-rp-simpleweakref_05/IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..0e08a9e7c78125adbae295258b63b78b4726a89f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0352-rc-rp-simpleweakref_05/IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB.java
@@ -0,0 +1,431 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.io.PrintStream;
+import java.lang.ref.*;
+public class IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static void isCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB() throws Exception {
+        SetReferentNull setReferentNull = new SetReferentNull();
+        setReferentNull.run();
+        IsCleanerNotInDeadCycleNotFreeRefFailSetWCB isCleanerNotInDeadCycleNotFreeRefFailSetWCB =
+                new IsCleanerNotInDeadCycleNotFreeRefFailSetWCB();
+        isCleanerNotInDeadCycleNotFreeRefFailSetWCB.run();
+        if (isCleanerNotInDeadCycleNotFreeRefFailSetWCB.check == false) {
+            judgeNum++;
+        }
+    }
+}
+class SetReferentNull implements Runnable {
+    Cycle_BDec_00010_A1_Cleaner a1_cleaner;
+    Cycle_BDec_00010_A2_Cleaner a2_cleaner;
+    @Override
+    public void run() {
+        a2_cleaner = null;
+        a1_cleaner = null;
+    }
+}
+class IsCleanerNotInDeadCycleNotFreeRefFailSetWCB implements Runnable {
+    boolean check;
+    @Override
+    public void run() {
+        check = isCleanerNotInDeadCycleNotFreeRefFailSetWCB();
+    }
+    static boolean resultSetCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA) {
+        InCycle cycleA = new InCycle();
+        boolean result = cycleA.setCleanerCycle(cycleBDA);
+        Runtime.getRuntime().gc();
+        return result;
+    }
+    public boolean isCleanerNotInDeadCycleNotFreeRefFailSetWCB() {
+        Cycle_BDec_00010_A1_Cleaner cycleB = new Cycle_BDec_00010_A1_Cleaner();
+        boolean result = resultSetCycle(cycleB);
+        if (result == true) {
+            try {
+                if (result == true) {
+                    if (cycleB.clearSoftReference() == true) {
+                        if (cycleB.clearWeakReference() == true) {
+                            if (cycleB.clearFinalizePhantomReference() == true) {
+                                if (cycleB.clearNoFinalizePhantomReference() == true) {
+                                    if (cycleB.clearFinalizeCleaner() == true) {
+                                        if (cycleB.clearNoFinalizeCleaner() == true) {
+                                            return true;
+                                        } else {
+                                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                                    + " ErrorResult in clearNoFinalizeCleaner");
+                                            return false;
+                                        }
+                                    } else {
+                                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                                + " ErrorResult in clearFinalizeCleaner");
+                                        return false;
+                                    }
+                                } else {
+                                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                            + " ErrorResult in clearNoFinalizePhantomReference");
+                                    return false;
+                                }
+                            } else {
+                                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                        + " ErrorResult in clearFinalizePhantomReference");
+                                return false;
+                            }
+                        } else {
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                    + " ErrorResult in clearWeakReference");
+                            return false;
+                        }
+                    } else {
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                + " ErrorResult in clearSoftReference");
+                        return false;
+                    }
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                            + " ErrorResult in NotIsCleanerNotInDeadCycleNotFreeRef");
+                    return false;
+                }
+            } catch (Exception e) {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleBDA1Cleaner 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner) {
+        cycleBDA1Cleaner.add();
+        cycleBDA1Cleaner.cycleBDA2Cleaner.add();
+        int nsum = cycleBDA1Cleaner.sum + cycleBDA1Cleaner.cycleBDA2Cleaner.sum;
+        if (nsum == 6) return true;
+        else return false;
+    }
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBDA1 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA1) {
+        cycleBDA1.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBDA1.cycleBDA2Cleaner.cycleBD = cycleBDA1;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleBDA1);
+        // 环正确，且reference都没释放
+        if (ret == true && cycleBDA1.cleaner == null && cycleBDA1.cycleBDA2Cleaner.cleaner == null
+                && cycleBDA1 != null && cycleBDA1.cycleBDA2Cleaner != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBD;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBD, null);
+        cycleBD = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBD.num;
+    }
+}
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+    /**
+     * 设置软引用,clear and enqueue
+   */
+
+
+    static Reference srp, wrp, prp, crp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static ReferenceQueue crq = new ReferenceQueue();
+    static StringBuffer stringBuffer1 = new StringBuffer("soft");
+    static StringBuffer stringBuffer2 = new StringBuffer("weak");
+    static StringBuffer stringBuffer3 = new StringBuffer("phantom");
+    static void setSoftReference() {
+        stringBuffer1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(stringBuffer1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        stringBuffer1 = null;
+    }
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------" +
+                    "srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " --------------------" +
+                        "srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置弱引用, clear and enqueue
+   */
+
+
+    static void setWeakReference() {
+        stringBuffer2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(stringBuffer2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        stringBuffer2 = null;
+    }
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置虚引用, 没有Referent finalized,clear and enqueue
+   */
+
+
+    static void setPhantomReference() {
+        stringBuffer3 = new StringBuffer("phantom");
+        prp = new PhantomReference<Object>(stringBuffer3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        stringBuffer3 = null;
+    }
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+    /**
+     * 设置虚引用,经过Referent finalized，clear and enqueue
+   */
+
+
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置cleaner,没有Referent finalized,clear and enqueue
+   */
+
+
+    static void setCleaner() {
+        Cleaner crp = null;
+        StringBuffer stringBuffer = new StringBuffer("test");
+        crp.create(stringBuffer, null);
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+    static boolean clearNoFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        setCleaner();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = crq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置cleaner,经过Referent finalized，clear and enqueue
+   */
+
+
+    static boolean clearFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        int finalValue = finalSet();
+        Runtime.getRuntime().gc();
+        if (finalValue == 200) {
+            value = value + 100;
+        }
+        setCleaner();
+        // 初次调用，Cleaner即为空
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+class RC_Finalize {
+    static int value = 0;
+    static void rcFinalize() throws InterruptedException {
+        RC_Finalize rc_finalize = new RC_Finalize();
+        Thread.sleep(2000);
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+    public static int run(String argv[], PrintStream out) {
+        return 0;
+    }
+}
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0352-rc-rp-simpleweakref_05/test.cfg b/testsuite/java_test/rc_test/RC0352-rc-rp-simpleweakref_05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e8d989e6cbfcc1a56d2cb54bdd71516f607e42c4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0352-rc-rp-simpleweakref_05/test.cfg
@@ -0,0 +1,2 @@
+compile(IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB)
+run(IsCleanerNotInDeadCycleNotFreeRefFailSetWCBSetAtomicWCB,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0353-rc-rp-simpleweakref_06/IsCleanerNotInDeadCycleNotFreeRefSetWCB.java b/testsuite/java_test/rc_test/RC0353-rc-rp-simpleweakref_06/IsCleanerNotInDeadCycleNotFreeRefSetWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..a5006d45d0a64cbcc516493e34b6c5f32b3e9b03
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0353-rc-rp-simpleweakref_06/IsCleanerNotInDeadCycleNotFreeRefSetWCB.java
@@ -0,0 +1,393 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.*;
+public class IsCleanerNotInDeadCycleNotFreeRefSetWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleNotFreeRefSetWCB();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleNotFreeRefSetWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static boolean resultSetCycle(Cycle_BDec_00010_A1_Cleaner cycleBDA) {
+        InCycle cycleA = new InCycle();
+        boolean result = cycleA.setCleanerCycle(cycleBDA);
+        Runtime.getRuntime().gc();
+        return result;
+    }
+    static void isCleanerNotInDeadCycleNotFreeRefSetWCB() throws InterruptedException {
+        Cycle_BDec_00010_A1_Cleaner cycleBDA1Cleaner = new Cycle_BDec_00010_A1_Cleaner();
+        boolean result = resultSetCycle(cycleBDA1Cleaner);
+        cycleBDA1Cleaner.cycleBDA2Cleaner = null;
+        if (result == true) {
+            if (cycleBDA1Cleaner.clearSoftReference() == true) {
+                if (cycleBDA1Cleaner.clearWeakReference() == true) {
+                    if (cycleBDA1Cleaner.clearFinalizePhantomReference() == true) {
+                        if (cycleBDA1Cleaner.clearNoFinalizePhantomReference() == true) {
+                            if (cycleBDA1Cleaner.clearFinalizeCleaner() == true) {
+                                if (cycleBDA1Cleaner.clearNoFinalizeCleaner() == true) {
+                                } else {
+                                    judgeNum++;
+                                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                            + " ErrorResult in clearNoFinalizeCleaner------------" +
+                                            "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                                }
+                            } else {
+                                judgeNum++;
+                                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                        + " ErrorResult in clearFinalizeCleaner------------" +
+                                        "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                            }
+                        } else {
+                            judgeNum++;
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                    + " ErrorResult in clearNoFinalizePhantomReference------------" +
+                                    "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                        }
+                    } else {
+                        judgeNum++;
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                + " ErrorResult in clearFinalizePhantomReference------------" +
+                                "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                    }
+                } else {
+                    judgeNum++;
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                            + " ErrorResult in clearWeakReference------------isCleanerNotInDeadCycleNotFreeRefSetWCB");
+                }
+            } else {
+                judgeNum++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                        + " ErrorResult in clearSoftReference------------isCleanerNotInDeadCycleNotFreeRefSetWCB");
+            }
+        } else {
+            judgeNum++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                    + " ErrorResult in isCleanerNotInDeadCycleNotFreeRefSetWCB------------" +
+                    "isCleanerNotInDeadCycleNotFreeRefSetWCB");
+        }
+    }
+}
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    Cycle_BDec_00010_A1_Cleaner cycleBDA1;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cycleBDA1, null);
+        cycleBDA1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBDA1.num;
+    }
+}
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cycleBDA2Cleaner;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cycleBDA2Cleaner, null);
+        cycleBDA2Cleaner = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cycleBDA2Cleaner.num;
+    }
+    /**
+     * 设置软引用,clear and enqueue
+   */
+
+
+    static Reference srp, wrp, prp, crp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static ReferenceQueue crq = new ReferenceQueue();
+    static StringBuffer obj = new StringBuffer("soft");
+    static StringBuffer obj1 = new StringBuffer("weak");
+    static StringBuffer obj2 = new StringBuffer("phantom");
+    static void setSoftReference() {
+        obj = new StringBuffer("soft");
+        srp = new WeakReference<Object>(obj, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        obj = null;
+    }
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                    + " --------------------srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                        + " --------------------srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置弱引用,clear and enqueue
+   */
+
+
+    static void setWeakReference() {
+        obj1 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(obj1, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        obj1 = null;
+    }
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置虚引用, 没有Referent finalized,clear and enqueue
+   */
+
+
+    static void setPhantomReference() {
+        prp = new PhantomReference<Object>(obj2, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        obj2 = null;
+    }
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+   */
+
+
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置cleaner, 没有Referent finalized,clear and enqueue
+   */
+
+
+    static void setCleaner() {
+        Cleaner crp = null;
+        StringBuffer str = new StringBuffer("test");
+        crp.create(str, null);
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+        }
+    }
+    static boolean clearNoFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        setCleaner();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = crq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+    /**
+     * 设置cleaner, 经过Referent finalized，clear and enqueue
+   */
+
+
+    static boolean clearFinalizeCleaner() throws InterruptedException {
+        Reference reference;
+        value = 100;
+        int finalValue = finalSet();
+        Runtime.getRuntime().gc();
+        if (finalValue == 200) {
+            value = value + 100;
+        }
+        setCleaner();
+        // 初次调用， Cleaner即为空
+        try {
+            if (crp.get() != null) {
+                value++;
+            }
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.Cleaner")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cycleB 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cycleB) {
+        cycleB.add();
+        cycleB.cycleBDA2Cleaner.add();
+        int nSum = cycleB.sum + cycleB.cycleBDA2Cleaner.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cycleBD 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cycleBD) {
+        cycleBD.cycleBDA2Cleaner = new Cycle_BDec_00010_A2_Cleaner();
+        cycleBD.cycleBDA2Cleaner.cycleBDA1 = cycleBD;
+        boolean ret;
+        ret = ModifyCleanerA1(cycleBD);
+        //环正确，且reference都没释放
+        if (ret == true && cycleBD.cleaner == null && cycleBD.cycleBDA2Cleaner.cleaner == null
+                && cycleBD != null && cycleBD.cycleBDA2Cleaner != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+class RC_Finalize {
+    static int value = 0;
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0353-rc-rp-simpleweakref_06/test.cfg b/testsuite/java_test/rc_test/RC0353-rc-rp-simpleweakref_06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..eba24ea56e3939c1e37481ba9de981486d04890d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0353-rc-rp-simpleweakref_06/test.cfg
@@ -0,0 +1,2 @@
+compile(IsCleanerNotInDeadCycleNotFreeRefSetWCB)
+run(IsCleanerNotInDeadCycleNotFreeRefSetWCB,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0354-rc-rp-simpleweakref_07/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java b/testsuite/java_test/rc_test/RC0354-rc-rp-simpleweakref_07/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
new file mode 100755
index 0000000000000000000000000000000000000000..444a048b1a75e3cd329a02b1b730219baefb9284
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0354-rc-rp-simpleweakref_07/IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.*;
+public class IsCleanerNotInDeadCycleNotSetWCBFailAtomic {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            isCleanerNotInDeadCycleNotSetWCBFailAtomic();
+            Runtime.getRuntime().gc();
+            isCleanerNotInDeadCycleNotSetWCBFailAtomic();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static void isCleanerNotInDeadCycleNotSetWCBFailAtomic() throws InterruptedException {
+        Cycle_BDec_00010_A1_Cleaner cleanerClass1 = new Cycle_BDec_00010_A1_Cleaner();
+        InCycle cycleA = new InCycle();
+        cycleA.setCleanerCycle(cleanerClass1);
+        System.gc();
+        boolean result = cycleA.setCleanerCycle(cleanerClass1);
+        if (result == false) {
+            judgeNum++;
+        }
+    }
+}
+class Cycle_BDec_00010_A1_Cleaner {
+    static Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2_Cleaner cleanerClass2;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A1_Cleaner() {
+        cleaner.create(cleanerClass2, null);
+        cleanerClass2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cleanerClass2.num;
+    }
+}
+class Cycle_BDec_00010_A2_Cleaner {
+    Cleaner cleaner;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1_Cleaner cleanerClass1;
+    int num;
+    int sum;
+    static int value;
+    Cycle_BDec_00010_A2_Cleaner() {
+        cleaner.create(cleanerClass1, null);
+        cleanerClass1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + cleanerClass1.num;
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param cleaner 传入的是带有Referent的类实例
+     * @return 返回布尔值，判断运算的结果正确
+   */
+
+
+    public static boolean ModifyCleanerA1(Cycle_BDec_00010_A1_Cleaner cleaner) {
+        cleaner.add();
+        cleaner.cleanerClass2.add();
+        int nSum = cleaner.sum + cleaner.cleanerClass2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置一个带Cleaner的环
+     *
+     * @param cleaner 传入的是带有Referent的类实例
+     * @return 返回布尔值，判断reference没释放
+   */
+
+
+    public static boolean setCleanerCycle(Cycle_BDec_00010_A1_Cleaner cleaner) {
+        cleaner.cleanerClass2 = new Cycle_BDec_00010_A2_Cleaner();
+        cleaner.cleanerClass2.cleanerClass1 = cleaner;
+        boolean ret;
+        ret = ModifyCleanerA1(cleaner);
+        System.gc();
+        ret = ModifyCleanerA1(cleaner);
+        // 环正确，且reference都没释放
+        if (ret == true && cleaner.cleaner == null && cleaner.cleanerClass2.cleaner == null && cleaner != null
+                && cleaner.cleanerClass2 != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0354-rc-rp-simpleweakref_07/test.cfg b/testsuite/java_test/rc_test/RC0354-rc-rp-simpleweakref_07/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6637005ec7c058bc9c48a9653c3c5c24090785af
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0354-rc-rp-simpleweakref_07/test.cfg
@@ -0,0 +1,2 @@
+compile(IsCleanerNotInDeadCycleNotSetWCBFailAtomic)
+run(IsCleanerNotInDeadCycleNotSetWCBFailAtomic,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0355-rc-rp-simpleweakref_08/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java b/testsuite/java_test/rc_test/RC0355-rc-rp-simpleweakref_08/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
new file mode 100755
index 0000000000000000000000000000000000000000..017ce4cfde664c00ceaa23314bab26f95b222c87
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0355-rc-rp-simpleweakref_08/NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.*;
+public class NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerNotInDeadCycleNotSetWCBFailAtomic();
+            Runtime.getRuntime().gc();
+            notIsCleanerNotInDeadCycleNotSetWCBFailAtomic();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static void notIsCleanerNotInDeadCycleNotSetWCBFailAtomic() throws InterruptedException {
+        Cycle_BDec_00010_A1 cycleMember = new Cycle_BDec_00010_A1();
+        InCycle cycleA = new InCycle();
+        cycleA.setCycle(cycleMember);
+        System.gc();
+        boolean result = cycleA.setCycle(cycleMember);
+        if (result == false) {
+            judgeNum++;
+        }
+    }
+}
+class Cycle_BDec_00010_A1 {
+    Reference memberRef1;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2 partner2;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+    Cycle_BDec_00010_A1() {
+        obj = new StringBuffer("weak");
+        memberRef1 = new WeakReference<Object>(obj, rq);
+        if (memberRef1.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + partner2.num;
+    }
+}
+class Cycle_BDec_00010_A2 {
+    Reference memberRef2;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1 partner1;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+    Cycle_BDec_00010_A2() {
+        obj = new StringBuffer("weak");
+        memberRef2 = new WeakReference<Object>(obj, rq);
+        if (memberRef2.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + partner1.num;
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean ModifyA1(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.add();
+        refInstance.partner2.add();
+        int nSum = refInstance.sum + refInstance.partner2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置一个带Referent的环
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean setCycle(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.partner2 = new Cycle_BDec_00010_A2();
+        refInstance.partner2.partner1 = refInstance;
+        boolean ret;
+        ret = ModifyA1(refInstance);
+        if (ret == true) {
+            return true;
+        } else {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ret != true");
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0355-rc-rp-simpleweakref_08/test.cfg b/testsuite/java_test/rc_test/RC0355-rc-rp-simpleweakref_08/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b1a2b32819a7bfbc1b0bea2dca7728f51243bcb9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0355-rc-rp-simpleweakref_08/test.cfg
@@ -0,0 +1,2 @@
+compile(NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic)
+run(NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0356-rc-rp-simpleweakref_09/NotIsCleanerNotInDeadCycleNotFreeRefSetWCB.java b/testsuite/java_test/rc_test/RC0356-rc-rp-simpleweakref_09/NotIsCleanerNotInDeadCycleNotFreeRefSetWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..da5eafc3476d4d810f043469720ca52a6413379e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0356-rc-rp-simpleweakref_09/NotIsCleanerNotInDeadCycleNotFreeRefSetWCB.java
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.ref.*;
+public class NotIsCleanerNotInDeadCycleNotFreeRefSetWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerNotInDeadCycleNotFreeRefSetWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static boolean resultSetCycle(Cycle_BDec_00010_A1 a1) throws InterruptedException {
+        InCycle cycleA = new InCycle();
+        cycleA.setCycle(a1);
+        Runtime.getRuntime().gc();
+        boolean result = cycleA.setCycle(a1);
+        return result;
+    }
+    static void notIsCleanerNotInDeadCycleNotFreeRefSetWCB() throws InterruptedException {
+        Cycle_BDec_00010_A1 cycleA = new Cycle_BDec_00010_A1();
+        boolean result = resultSetCycle(cycleA);
+        cycleA.partner2 = null;
+        if (result == true) {
+            if (cycleA.clearSoftReference() == true) {
+                if (cycleA.clearWeakReference() == true) {
+                    if (cycleA.clearFinalizePhantomReference() == true) {
+                        if (cycleA.clearNoFinalizePhantomReference() == true) {
+                        } else {
+                            judgeNum++;
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                    " ErrorResult in clearNoFinalizePhantomReference--------------" +
+                                    "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+                        }
+                    } else {
+                        judgeNum++;
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                " ErrorResult in clearFinalizePhantomReference------------------" +
+                                "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+                    }
+                } else {
+                    judgeNum++;
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " ErrorResult in clearWeakReference---------------------" +
+                            "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+                }
+            } else {
+                judgeNum++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " ErrorResult in clearSoftReference-------------------" +
+                        "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+            }
+        } else {
+            judgeNum++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                    " ErrorResult in isCleanerNotInDeadCycleNotFreeRefSetWCB---------------------" +
+                    "NotIsCleanerNotInDeadCycleNotFreeRefSetWCB");
+        }
+    }
+}
+class Cycle_BDec_00010_A1 {
+    Reference a1Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2 partner2;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+    Cycle_BDec_00010_A1() throws InterruptedException {
+        obj = new StringBuffer("weak");
+        a1Ref = new WeakReference<Object>(obj, rq);
+        if (a1Ref.get() == null) {
+            System.out.println("error in a1Ref.get");
+        }
+        obj = null;
+        partner2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + partner2.num;
+    }
+    /**
+     * 设置软引用, clear and enqueue
+   */
+
+
+    static Reference srp, wrp, prp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("soft");
+    static StringBuffer obj2 = new StringBuffer("weak");
+    static StringBuffer obj3 = new StringBuffer("obj");
+    static void setSoftReference() {
+        obj1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(obj1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        obj1 = null;
+    }
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference ref;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            value++;
+        }
+        while ((ref = srq.poll()) != null) {
+            if (!ref.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置弱引用, clear and enqueue
+   */
+
+
+    static void setWeakReference() {
+        obj2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(obj2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        obj2 = null;
+    }
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置虚引用, 没有Referent finalized, clear and enqueue.
+   */
+
+
+    static void setPhantomReference() {
+        obj3 = new StringBuffer("obj");
+        prp = new PhantomReference<Object>(obj3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        obj3 = null;
+    }
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+   */
+
+
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+class Cycle_BDec_00010_A2 {
+    Reference a2Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1 partner1;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+    Cycle_BDec_00010_A2() throws InterruptedException {
+        obj = new StringBuffer("weak");
+        a2Ref = new WeakReference<Object>(obj, rq);
+        if (a2Ref.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + partner1.num;
+    }
+}
+class RC_Finalize {
+    static int value = 0;
+    static void rc_Finalize() throws InterruptedException {
+        RC_Finalize a = new RC_Finalize();
+        Thread.sleep(2000);
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+    public static int run(String argv[], PrintStream out) {
+        return 0;
+    }
+}
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean ModifyA1(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.add();
+        refInstance.partner2.add();
+        int nSum = refInstance.sum + refInstance.partner2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置一个带Referent的环
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean setCycle(Cycle_BDec_00010_A1 refInstance) throws InterruptedException {
+        refInstance.partner2 = new Cycle_BDec_00010_A2();
+        refInstance.partner2.partner1 = refInstance;
+        refInstance.obj = null;
+        refInstance.partner2.obj = null;
+        Thread.sleep(2000);
+        boolean ret;
+        ret = ModifyA1(refInstance);
+        if (ret == true) {
+            if (refInstance.a1Ref.get() == null) {
+                if (refInstance.partner2.a2Ref.get() == null) {
+                    if (refInstance != null && refInstance.partner2 != null) {
+                        return true;
+                    } else {
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                                + " a1_0 == null || a1_0.a2_0 == null");
+                        return false;
+                    }
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                            + " a2Ref.get() == null");
+                    return false;
+                }
+            } else {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()
+                        + " a1_0.a1Ref.get() == null");
+                return false;
+            }
+        } else {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ret != true");
+            return false;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0356-rc-rp-simpleweakref_09/test.cfg b/testsuite/java_test/rc_test/RC0356-rc-rp-simpleweakref_09/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a1438970c35b1c87763553372db97973cee453b2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0356-rc-rp-simpleweakref_09/test.cfg
@@ -0,0 +1,2 @@
+compile(NotIsCleanerNotInDeadCycleNotFreeRefSetWCB)
+run(NotIsCleanerNotInDeadCycleNotFreeRefSetWCB,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0357-rc-rp-simpleweakref_10/NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB.java b/testsuite/java_test/rc_test/RC0357-rc-rp-simpleweakref_10/NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..21c2d63e0991658f7c17cff2959cef49790d06a5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0357-rc-rp-simpleweakref_10/NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB.java
@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.ref.*;
+public class NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerNotFreeRefFailSetWCBSetAtomicWCB();
+            Runtime.getRuntime().gc();
+            notIsCleanerNotFreeRefFailSetWCBSetAtomicWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static void notIsCleanerNotFreeRefFailSetWCBSetAtomicWCB() throws Exception {
+        SetReferentNull setReferentNull = new SetReferentNull();
+        setReferentNull.run();
+        NotIsCleanerNotInDeadCycleNotFreeRef notIsCleanerNotInDeadCycleNotFreeRef = new
+                NotIsCleanerNotInDeadCycleNotFreeRef();
+        notIsCleanerNotInDeadCycleNotFreeRef.run();
+        if (notIsCleanerNotInDeadCycleNotFreeRef.check == false) {
+            judgeNum++;
+        }
+    }
+}
+class SetReferentNull implements Runnable {
+    Cycle_BDec_00010_A1 cycle1;
+    Cycle_BDec_00010_A2 cycle2;
+    @Override
+    public void run() {
+        cycle2 = null;
+        cycle1 = null;
+    }
+}
+class NotIsCleanerNotInDeadCycleNotFreeRef implements Runnable {
+    boolean check;
+    @Override
+    public void run() {
+        try {
+            check = notIsCleanerNotInDeadCycleNotFreeRef();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    static boolean resultSetCycle(Cycle_BDec_00010_A1 cycle1) throws InterruptedException {
+        InCycle cycleA = new InCycle();
+        cycleA.setCycle(cycle1);
+        Runtime.getRuntime().gc();
+        boolean result = cycleA.setCycle(cycle1);
+        return result;
+    }
+    boolean notIsCleanerNotInDeadCycleNotFreeRef() throws InterruptedException {
+        Cycle_BDec_00010_A1 a1 = new Cycle_BDec_00010_A1();
+        boolean result = resultSetCycle(a1);
+        try {
+            if (result == true) {
+                if (a1.clearSoftReference() == true) {
+                    if (a1.clearWeakReference() == true) {
+                        if (a1.clearFinalizePhantomReference() == true) {
+                            if (a1.clearNoFinalizePhantomReference() == true) {
+                                return true;
+                            } else {
+                                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                        " ErrorResult in clearNoFinalizePhantomReference");
+                                return false;
+                            }
+                        } else {
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                    " ErrorResult in clearFinalizePhantomReference");
+                            return false;
+                        }
+                    } else {
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                " ErrorResult in clearWeakReference");
+                        return false;
+                    }
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " ErrorResult in clearSoftReference");
+                    return false;
+                }
+            } else {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " ErrorResult in NotIsCleanerNotInDeadCycleNotFreeRef");
+                return false;
+            }
+        } catch (Exception e) {
+            return false;
+        }
+    }
+}
+class Cycle_BDec_00010_A2 {
+    Reference a2Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1 partner1;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+    Cycle_BDec_00010_A2() {
+        a2Ref = new WeakReference<Object>(obj, rq);
+        if (a2Ref.get() == null) {
+            assert false;
+        }
+        partner1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + partner1.num;
+    }
+}
+class Cycle_BDec_00010_A1 {
+    Reference a1Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2 partner2;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+    Cycle_BDec_00010_A1() {
+        a1Ref = new WeakReference<Object>(obj, rq);
+        if (a1Ref.get() == null) {
+            assert false;
+        }
+        partner2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + partner2.num;
+    }
+    /**
+     * 设置软引用, clear and enqueue
+   */
+
+
+    static Reference srp, wrp, prp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("soft");
+    static StringBuffer obj2 = new StringBuffer("weak");
+    static StringBuffer obj3 = new StringBuffer("phantom");
+    static void setSoftReference() {
+        obj1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(obj1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        obj1 = null;
+    }
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                    " --------------------srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " --------------------srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置弱引用,clear and enqueue
+   */
+
+
+    static void setWeakReference() {
+        obj2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(obj2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        obj2 = null;
+    }
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        //释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置虚引用,没有Referent finalized,clear and enqueue
+   */
+
+
+    static void setPhantomReference() {
+        obj3 = new StringBuffer("phantom");
+        prp = new PhantomReference<Object>(obj3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        obj3 = null;
+    }
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+   */
+
+
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean ModifyA1(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.add();
+        refInstance.partner2.add();
+        int nSum = refInstance.sum + refInstance.partner2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置一个带Referent的环
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true:正确；false：错误
+   */
+
+
+    public static boolean setCycle(Cycle_BDec_00010_A1 refInstance) throws InterruptedException {
+        refInstance.partner2 = new Cycle_BDec_00010_A2();
+        refInstance.partner2.partner1 = refInstance;
+        boolean ret;
+        ret = ModifyA1(refInstance);
+        refInstance.obj = null;
+        refInstance.partner2.obj = null;
+        Thread.sleep(2000);
+        if (ret == true) {
+            if (refInstance.a1Ref.get() == null && refInstance.partner2.a2Ref.get() == null) {
+                if (refInstance != null && refInstance.partner2 != null) {
+                    return true;
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " a1_0==null||a1_0.a2_0==nulll");
+                    return false;
+                }
+            } else {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " a1_0.a1Ref.get() != null");
+                return false;
+            }
+        } else {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ret != true");
+            return false;
+        }
+    }
+}
+class RC_Finalize {
+    static int value = 0;
+    static void rc_Finalize() throws InterruptedException {
+        RC_Finalize a = new RC_Finalize();
+        Thread.sleep(2000);
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+    public static int run(String argv[], PrintStream out) {
+        return 0;
+    }
+}
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0357-rc-rp-simpleweakref_10/test.cfg b/testsuite/java_test/rc_test/RC0357-rc-rp-simpleweakref_10/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..0859b525370444c26b294cc69ef9acea20b866e8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0357-rc-rp-simpleweakref_10/test.cfg
@@ -0,0 +1,2 @@
+compile(NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB)
+run(NotIsCleanerNotFreeRefFailSetWCBSetAtomicWCB,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0358-rc-rp-simpleweakref_11/NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java b/testsuite/java_test/rc_test/RC0358-rc-rp-simpleweakref_11/NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
new file mode 100755
index 0000000000000000000000000000000000000000..827382d438c0b0bafa7b41dad14d6397c331af2a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0358-rc-rp-simpleweakref_11/NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB.java
@@ -0,0 +1,348 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.ref.*;
+public class NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB();
+            Runtime.getRuntime().gc();
+            notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static boolean resultSetCycle(Cycle_BDec_00010_A1 cycle1) throws InterruptedException {
+        InCycle cycleA = new InCycle();
+        cycleA.setCycle(cycle1);
+        Runtime.getRuntime().gc();
+        boolean result = cycleA.setCycle(cycle1);
+        return result;
+    }
+    static void notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB() throws InterruptedException {
+        Cycle_BDec_00010_A1 cycle1 = new Cycle_BDec_00010_A1();
+        boolean result = resultSetCycle(cycle1);
+        if (result == true) {
+            cycle1.partner2 = null;
+            cycle1 = null;
+            if (cycle1.clearSoftReference() == true) {
+                if (cycle1.clearWeakReference() == true) {
+                    if (cycle1.clearFinalizePhantomReference() == true) {
+                        if (cycle1.clearNoFinalizePhantomReference() == true) {
+                        } else {
+                            judgeNum++;
+                            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                    " ErrorResult in clearNoFinalizePhantomReference--------------" +
+                                    "notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                        }
+                    } else {
+                        judgeNum++;
+                        System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                                " ErrorResult in clearFinalizePhantomReference-------------" +
+                                "notIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB");
+                    }
+                } else {
+                    judgeNum++;
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " ErrorResult in clearWeakReference");
+                }
+            } else {
+                judgeNum++;
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " ErrorResult in clearSoftReference");
+            }
+        } else {
+            judgeNum++;
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                    " ErrorResult in isCleanerNotInDeadCycleNotFreeRefSetWCB");
+        }
+    }
+}
+class Cycle_BDec_00010_A1 {
+    Reference a1Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A2 partner2;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+    Cycle_BDec_00010_A1() {
+        obj = new StringBuffer("weak");
+        a1Ref = new WeakReference<Object>(obj, rq);
+        if (a1Ref.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner2 = null;
+        num = 1;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + partner2.num;
+    }
+    /**
+     * 设置软引用,clear and enqueue
+   */
+
+
+    static Reference srp, wrp, prp;
+    static ReferenceQueue srq = new ReferenceQueue();
+    static ReferenceQueue wrq = new ReferenceQueue();
+    static ReferenceQueue prq = new ReferenceQueue();
+    static StringBuffer obj1 = new StringBuffer("soft");
+    static StringBuffer obj2 = new StringBuffer("weak");
+    static StringBuffer obj3 = new StringBuffer("phantom");
+    static void setSoftReference() {
+        obj1 = new StringBuffer("soft");
+        srp = new WeakReference<Object>(obj1, srq);
+        if (srp.get() == null) {
+            value++;
+        }
+        obj1 = null;
+    }
+    static boolean clearSoftReference() throws InterruptedException {
+        int value = 100;
+        Reference r;
+        setSoftReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        //释放，应该为空
+        if (srp.get() != null) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                    " --------------------srp.get():" + srp.get());
+            value++;
+        }
+        while ((r = srq.poll()) != null) {
+            if (!r.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " --------------------srp.while");
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置弱引用,clear and enqueue
+   */
+
+
+    static void setWeakReference() {
+        obj2 = new StringBuffer("weak");
+        wrp = new WeakReference<Object>(obj2, wrq);
+        if (wrp.get() == null) {
+            value++;
+        }
+        obj2 = null;
+    }
+    static boolean clearWeakReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setWeakReference();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        // 释放，应该为空
+        if (wrp.get() != null) {
+            value++;
+        }
+        while ((reference = wrq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置虚引用, 没有Referent finalized, clear and enqueue
+   */
+
+
+    static void setPhantomReference() {
+        obj3 = new StringBuffer("phantom");
+        prp = new PhantomReference<Object>(obj3, prq);
+        if (prp.get() != null) {
+            value++;
+        }
+        obj3 = null;
+    }
+    static boolean clearNoFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(2000);
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 100) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    static int finalSet() {
+        RC_Finalize testClass1 = new RC_Finalize();
+        System.runFinalization();
+        return testClass1.value;
+    }
+    /**
+     * 设置虚引用, 经过Referent finalized，clear and enqueue
+   */
+
+
+    static boolean clearFinalizePhantomReference() throws InterruptedException {
+        value = 100;
+        int valueFinal = finalSet();
+        Runtime.getRuntime().gc();
+        valueFinal = finalSet();
+        Reference reference;
+        setPhantomReference();
+        Thread.sleep(5000);
+        if (valueFinal == 200) {
+            value = value + 100;
+        }
+        while ((reference = prq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.PhantomReference")) {
+                value++;
+            }
+        }
+        if (value == 200) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+class Cycle_BDec_00010_A2 {
+    Reference a2Ref;
+    static ReferenceQueue rq = new ReferenceQueue();
+    Cycle_BDec_00010_A1 partner1;
+    int num;
+    int sum;
+    static int value;
+    static StringBuffer obj = new StringBuffer("weak");
+    Cycle_BDec_00010_A2() {
+        obj = new StringBuffer("weak");
+        a2Ref = new WeakReference<Object>(obj, rq);
+        if (a2Ref.get() == null) {
+            assert false;
+        }
+        obj = null;
+        partner1 = null;
+        num = 2;
+        sum = 0;
+        value = 100;
+    }
+    void add() {
+        sum = num + partner1.num;
+    }
+}
+class InCycle {
+    /**
+     * 确认环是正确的
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true: 正确；false：错误
+   */
+
+
+    public static boolean ModifyA1(Cycle_BDec_00010_A1 refInstance) {
+        refInstance.add();
+        refInstance.partner2.add();
+        int nSum = refInstance.sum + refInstance.partner2.sum;
+        if (nSum == 6) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * 设置一个带Referent的环
+     *
+     * @param refInstance 传入的是带有Referent的类实例
+     * @return true: 正确；false：错误
+   */
+
+
+    public static boolean setCycle(Cycle_BDec_00010_A1 refInstance) throws InterruptedException {
+        refInstance.partner2 = new Cycle_BDec_00010_A2();
+        if (refInstance.partner2.a2Ref.get() == null) {
+            return false;
+        }
+        refInstance.partner2.partner1 = refInstance;
+        boolean ret;
+        ret = ModifyA1(refInstance);
+        if (ret == true) {
+            Thread.sleep(2000);
+            if (refInstance.a1Ref.get() == null) {
+                if (refInstance != null && refInstance.partner2 != null) {
+                    return true;
+                } else {
+                    System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                            " a1_0==null||a1_0.a2_0==nulll");
+                    return false;
+                }
+            } else {
+                System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() +
+                        " a1_0.a1Ref.get() != null");
+                return false;
+            }
+        } else {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " ret != true");
+            return false;
+        }
+    }
+}
+class RC_Finalize {
+    static int value = 0;
+    static void rc_Finalize() throws InterruptedException {
+        RC_Finalize rc = new RC_Finalize();
+        Thread.sleep(2000);
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+        value = 200;
+    }
+    public static int run(String argv[], PrintStream out) {
+        return 0;
+    }
+}
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0358-rc-rp-simpleweakref_11/test.cfg b/testsuite/java_test/rc_test/RC0358-rc-rp-simpleweakref_11/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..5682a19b265152fffb990754ed261c64eb8a9282
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0358-rc-rp-simpleweakref_11/test.cfg
@@ -0,0 +1,2 @@
+compile(NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB)
+run(NotIsCleanerInDeadCycleNotFreeRefFailSetWCBFailAtomicWCB,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0359-rc-rp-simpleweakref_12/NotIsCleanerFreeRef.java b/testsuite/java_test/rc_test/RC0359-rc-rp-simpleweakref_12/NotIsCleanerFreeRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..fefe5e0c882632d126971fc4cc3f4dc0706817a0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0359-rc-rp-simpleweakref_12/NotIsCleanerFreeRef.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class NotIsCleanerFreeRef {
+    static int TEST_NUM = 1;
+    static int judgeNum = 0;
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer obj = new StringBuffer("soft");
+    static void setSoftRef() {
+        obj = new StringBuffer("soft");
+        rp = new WeakReference<Object>(obj, rq);
+        if (rp.get() == null) {
+            judgeNum++;
+        }
+        obj = null;
+    }
+    public static void main(String[] args) throws Exception {
+        judgeNum = 0;
+        for (int i = 0; i < TEST_NUM; i++) {
+            notIsCleanerFreeRef();
+            Runtime.getRuntime().gc();
+            notIsCleanerFreeRef();
+        }
+        if (judgeNum == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static void notIsCleanerFreeRef() throws InterruptedException {
+        Reference ref;
+        setSoftRef();
+        new Thread(new ThreadRef()).start();
+        Thread.sleep(2000);
+        if (rp.get() != null) {
+            judgeNum++;
+        }
+        while ((ref = rq.poll()) != null) {
+            if (!ref.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                judgeNum++;
+            }
+        }
+    }
+}
+class ThreadRef implements Runnable {
+    public void run() {
+        for (int i = 0; i < 60; i++) {
+            WeakReference wr = new WeakReference(new Object());
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                System.out.println(" sleep was Interrupted");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0359-rc-rp-simpleweakref_12/test.cfg b/testsuite/java_test/rc_test/RC0359-rc-rp-simpleweakref_12/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b18fcf0d650ae24ca26f918be56b2fd87b724669
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0359-rc-rp-simpleweakref_12/test.cfg
@@ -0,0 +1,2 @@
+compile(NotIsCleanerFreeRef)
+run(NotIsCleanerFreeRef,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01/BackupTracingAndRefPro.java b/testsuite/java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01/BackupTracingAndRefPro.java
new file mode 100755
index 0000000000000000000000000000000000000000..d0a42d919a95ddd9d5afb05d62b392bf110a7cbd
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01/BackupTracingAndRefPro.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class BackupTracingAndRefPro {
+    static int NUM = 2;
+    public static void main(String[] args) {
+        runRefPro();
+        Runtime.getRuntime().gc();
+        runRefPro();
+        runBackupTracing();
+        Runtime.getRuntime().gc();
+        runBackupTracing();
+        System.out.println("ExpectResult");
+    }
+    static void runRefPro() {
+        ThreadRefPro threadRefPro = new ThreadRefPro();
+        for (int i = 0; i < NUM; i++) {
+            threadRefPro.run();
+        }
+    }
+    static void runBackupTracing() {
+        ThreadBackupTracing threadBackupTracing = new ThreadBackupTracing();
+        for (int i = 0; i < NUM; i++) {
+            threadBackupTracing.run();
+        }
+    }
+}
+class ThreadBackupTracing implements Runnable {
+    int result = 0;
+    void versify() {
+        ReferenceOperation ref = new ReferenceOperation();
+        ref.referenceOperation = ref;
+        ref.add();
+        result = ref.sum;
+    }
+    @Override
+    public void run() {
+        versify();
+        if (result != 20) {
+            System.out.println("error result ==" + result);
+        }
+    }
+}
+class ReferenceOperation {
+    ReferenceOperation referenceOperation;
+    int num;
+    int sum;
+    ReferenceOperation() {
+        referenceOperation = null;
+        num = 10;
+        sum = 0;
+    }
+    void add() {
+        sum = num + referenceOperation.num;
+    }
+}
+class ThreadRefPro implements Runnable {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer obj = new StringBuffer("weak");
+    static void setWeakRef() {
+        obj = new StringBuffer("weak");
+        rp = new WeakReference<Object>(obj, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        obj = null;
+    }
+    @Override
+    public void run() {
+        Reference reference;
+        setWeakRef();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (rp.get() != null) {
+            System.out.println("error in rp.get()");
+        }
+        while ((reference = rq.poll()) != null) {
+            if (!reference.getClass().toString().equals("class java.lang.ref.WeakReference")) {
+                System.out.println("error in rq");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01/test.cfg b/testsuite/java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..178a00190ee9c73b86a0254f87feaf7f29e91277
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0360-rc-Memory-leaktestsupplycase-01/test.cfg
@@ -0,0 +1,2 @@
+compile(BackupTracingAndRefPro)
+run(BackupTracingAndRefPro,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02/FinalizerRef.java b/testsuite/java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02/FinalizerRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..c495115c2b8db73e335abdc5f442a0c2c495ddb8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02/FinalizerRef.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class FinalizerRef {
+    static int NUM = 1;
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        System.out.println("ExpectResult");
+    }
+    public static void test() {
+        SetWeakRef setWeakRef = new SetWeakRef();
+        setWeakRef.setWeakRef();
+        ThreadWeakRef_01 threadWeakRef_01 = new ThreadWeakRef_01();
+        ThreadWeakRef_02 threadWeakRef_02 = new ThreadWeakRef_02();
+        ThreadWeakRef_03 threadWeakRef_03 = new ThreadWeakRef_03();
+        ThreadWeakRef_04 threadWeakRef_04 = new ThreadWeakRef_04();
+        ThreadWeakRef_05 threadWeakRef_05 = new ThreadWeakRef_05();
+        for (int i = 0; i < NUM; i++) {
+            threadWeakRef_01.run();
+            threadWeakRef_02.run();
+            threadWeakRef_03.run();
+            threadWeakRef_04.run();
+            threadWeakRef_05.run();
+        }
+    }
+}
+class SetWeakRef {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer obj = new StringBuffer("weak");
+    static void setWeakRef() {
+        obj = new StringBuffer("weak");
+        rp = new WeakReference(obj, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        obj = null;
+    }
+}
+class ThreadWeakRef_01 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_01 threadWeakRef_01 = new ThreadWeakRef_01();
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class ThreadWeakRef_02 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_02 threadWeakRef_02 = new ThreadWeakRef_02();
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class ThreadWeakRef_03 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_03 threadWeakRef_03 = new ThreadWeakRef_03();
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class ThreadWeakRef_04 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_04 threadWeakRef_04 = new ThreadWeakRef_04();
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class ThreadWeakRef_05 implements Runnable {
+    @Override
+    public void run() {
+        System.gc();
+        ThreadWeakRef_05 threadWeakRef_05 = new ThreadWeakRef_05();
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02/test.cfg b/testsuite/java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..5265d7865db4c44f4f126bf9f8ea60a0a96c0490
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0361-rc-Memory-leaktestsupplycase-02/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerRef)
+run(FinalizerRef,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03/FinalizerTest.java b/testsuite/java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03/FinalizerTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..a0017326bad5acf89f5ee5ca9200c2de4dac994c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03/FinalizerTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class FinalizerTest extends Object {
+    static int finalizeNum = 10;
+    static Reference rp[] = new Reference[finalizeNum];
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int checkNum = 0;
+    static StringBuffer stringBuffer;
+    static FinalizerTest finalizerTest = null;
+    static void newFinalizeObject() throws InterruptedException {
+        stringBuffer = new StringBuffer("weak");
+        for (int i = 0; i < finalizeNum; i++) {
+            rp[i] = new WeakReference<Object>(stringBuffer, rq);
+            if (rp[i].get() == null) {
+                checkNum--;
+            }
+        }
+        stringBuffer = null;
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+        checkNum++;
+    }
+    static void newFinalizeTest() throws InterruptedException {
+        for (int i = 0; i < finalizeNum; i++) {
+            FinalizerTest finalizerTest = new FinalizerTest();
+            finalizerTest.newFinalizeObject();
+        }
+        finalizerTest = null;
+    }
+    static void finalizeTest() throws InterruptedException {
+        newFinalizeTest();
+        Thread.sleep(2000);
+        System.gc();
+        System.runFinalization();
+        for (int i = 0; i < finalizeNum; i++) {
+            if (rp[i].get() != null) {
+                checkNum--;
+            }
+        }
+    }
+    public static void main(String[] args) throws InterruptedException {
+        finalizeTest();
+        Runtime.getRuntime().gc();
+        finalizeTest();
+        if (checkNum == (finalizeNum * 2)) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("checkNum = " + checkNum);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03/test.cfg b/testsuite/java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a062acd8dada7acdc91ab92d79d9f965afc8514e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0362-rc-Memory-leaktestsupplycase-03/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerTest)
+run(FinalizerTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04/FrequentGCAndFinalize.java b/testsuite/java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04/FrequentGCAndFinalize.java
new file mode 100755
index 0000000000000000000000000000000000000000..2df9d632aef1713d7a00ef41157123bf8ff4ce1f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04/FrequentGCAndFinalize.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class FrequentGCAndFinalize {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int num = 10;
+    static StringBuffer stringBuffer = new StringBuffer("weak");
+    static void setWeakRef() {
+        stringBuffer = new StringBuffer("weak");
+        rp = new WeakReference<Object>(stringBuffer, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        stringBuffer = null;
+    }
+    static void executeThreadGC() {
+        ThreadGC threadGC = new ThreadGC();
+        for (int i = 0; i < num; i++) {
+            threadGC.run();
+        }
+    }
+    static void executeThreadFinalize() {
+        ThreadFinalize threadFinalize = new ThreadFinalize();
+        for (int i = 0; i < num; i++) {
+            threadFinalize.run();
+        }
+    }
+    public static void main(String[] args) {
+        setWeakRef();
+        executeThreadFinalize();
+        executeThreadGC();
+        executeThreadFinalize();
+        System.out.println("ExpectResult");
+    }
+}
+class ThreadGC implements Runnable {
+    @Override
+    public void run() {
+        Runtime.getRuntime().gc();
+    }
+}
+class ThreadFinalize implements Runnable {
+    @Override
+    public void run() {
+        ThreadFinalize threadFinalize = new ThreadFinalize();
+        System.runFinalization();
+    }
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04/test.cfg b/testsuite/java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9de96d18bdc863d50cec82b72860cc08397fc1ec
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0363-rc-Memory-leaktestsupplycase-04/test.cfg
@@ -0,0 +1,2 @@
+compile(FrequentGCAndFinalize)
+run(FrequentGCAndFinalize,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05/RaceInLoadAndWriteWeakRef.java b/testsuite/java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05/RaceInLoadAndWriteWeakRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..e9f9d38ac086bb596a63423b11d5eda70cc98c59
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05/RaceInLoadAndWriteWeakRef.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class RaceInLoadAndWriteWeakRef {
+    static int NUM = 100;
+    public static void main(String[] args) {
+        test();
+        Runtime.getRuntime().gc();
+        test();
+        System.out.println("ExpectResult");
+    }
+    static void test(){
+        SetWeakRef setWeakRef = new SetWeakRef();
+        setWeakRef.setWeakRef();
+        ThreadLoadWeakRef threadLoadWeakRef = new ThreadLoadWeakRef(setWeakRef);
+        ThreadWriteWeakRef threadWriteWeakRef = new ThreadWriteWeakRef(setWeakRef);
+        for (int i = 0; i < NUM; i++) {
+            threadLoadWeakRef.run();
+            Runtime.getRuntime().gc();
+            threadLoadWeakRef.run();
+            Runtime.getRuntime().gc();
+            threadLoadWeakRef.run();
+            threadWriteWeakRef.run();
+            Runtime.getRuntime().gc();
+            threadWriteWeakRef.run();
+        }
+    }
+}
+class SetWeakRef {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer stringBuffer = new StringBuffer("Weak");
+    static void setWeakRef() {
+        stringBuffer = new StringBuffer("Weak");
+        rp = new WeakReference(stringBuffer, rq);
+        if (rp.get() == null) {
+            System.out.println("error");
+        }
+        stringBuffer = null;
+    }
+}
+class ThreadLoadWeakRef implements Runnable {
+    SetWeakRef setWeakRef;
+    public ThreadLoadWeakRef(SetWeakRef setWeakRef) {
+        this.setWeakRef = setWeakRef;
+    }
+    static Reference rp_load;
+    @Override
+    public void run() {
+        rp_load = setWeakRef.rp;
+    }
+}
+class ThreadWriteWeakRef implements Runnable {
+    SetWeakRef setWeakRef;
+    public ThreadWriteWeakRef(SetWeakRef setWeakRef) {
+        this.setWeakRef = setWeakRef;
+    }
+    static WeakReference rp_write;
+    @Override
+    public void run() {
+        setWeakRef.rp = rp_write;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05/test.cfg b/testsuite/java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..27386ea8bf62d0254683e799a2d9408d8c7ad7c3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0364-rc-Memory-leaktestsupplycase-05/test.cfg
@@ -0,0 +1,2 @@
+compile(RaceInLoadAndWriteWeakRef)
+run(RaceInLoadAndWriteWeakRef,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06/WeakAndCleanerRef.java b/testsuite/java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06/WeakAndCleanerRef.java
new file mode 100755
index 0000000000000000000000000000000000000000..72aa37e23b72b1c68178eeb5a8ebd3f2ae12a7b0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06/WeakAndCleanerRef.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class WeakAndCleanerRef {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static StringBuffer stringBuffer = new StringBuffer("test");
+    static void addWeakAndCleanerRef() {
+        rp = new WeakReference(stringBuffer, rq);
+    }
+    public static void main(String[] args) throws InterruptedException {
+        ThreadCleaner threadCleaner = new ThreadCleaner();
+        Cleaner cleaner = Cleaner.create(stringBuffer, threadCleaner);
+        addWeakAndCleanerRef();
+        stringBuffer = null;
+        cleaner.clean();
+        Thread.sleep(2000);
+        addWeakAndCleanerRef();
+        if (rp.get() == null) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+class ThreadCleaner implements Runnable {
+    @Override
+    public void run() {
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06/test.cfg b/testsuite/java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..eda6c83928137baeb5f47abfa3f864713e6ab9c8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0365-rc-Memory-leaktestsupplycase-06/test.cfg
@@ -0,0 +1,2 @@
+compile(WeakAndCleanerRef)
+run(WeakAndCleanerRef,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/RC_Array_01.java b/testsuite/java_test/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/RC_Array_01.java
new file mode 100755
index 0000000000000000000000000000000000000000..2cba7e06acbccb0e78d3f7a9244c7a296b9c5be1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/RC_Array_01.java
@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+class Base_001{
+    //Parent interface
+    volatile int[] base1;
+    int[][] base2;
+    int[][] base21;
+    int[][][] base3;
+}
+public class RC_Array_01 extends Base_001{
+    static int check_count = 0;
+    static int[] arr1 = {10,20,30,40};
+    static int[][] arr2 = {{10,20,30,40},{40,50},{60}};
+    static int[][] arr21 = {{40,50,60,30},{70,80},{90}};
+    static int[][][] arr3 = {arr2,arr21};
+    private RC_Array_01(){
+        base1 = new int[]{10,20,30,40};
+        base2 = new int[][]{{10,20,30,40},{40,50},{60}};
+        base21 = new int[][]{{40,50,60,30},{70,80},{90}};
+        base3 = new int[][][]{{{10,20,30,40},{40,50},{60}},{{40,50,60,30},{70,80},{90}}};
+    }
+    private RC_Array_01(int[] intar){
+        base1 = intar;
+    }
+    private RC_Array_01(int[][] intarr){
+        base2 = intarr;
+    }
+    private RC_Array_01(int[][][] intarrr){
+        base3 = intarrr;
+    }
+    private RC_Array_01(int[] intar, int[][] intarr, int[][][] intarrr){
+        base1 = intar;
+        base2 = intarr;
+        base3 = intarrr;
+    }
+    public static void main(String [] args) {
+        final int[] TEST1 = {10,20,30,40};
+        final int[][] TEST2 = {TEST1,{40,50},{60}};
+        final int[][] TEST21 = {{40,50,60,30},{70,80},{90}};
+        final int[][][] TEST3 = {TEST2,TEST21};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step1");
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2 && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+        //The test03 interface call, call the RC_Array_01_test01 function return value to the parameter third and judged.
+        //RC_Array_01_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_01 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_01_test02();
+        //Get an array object by returning a function call
+        int[] getarr1 = RC_Array_get01();
+        int[][] getarr2 = RC_Array_get02();
+        int[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+        //Exception testing
+        Boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+    }
+    private static void test01(int first, int[] second, int[][] third, int[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        int [] xyz = {23,24,25,26};
+        int[][] xyz2 = {{23,24,25,26},{23,24},{23}};
+        int[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+    private static void test02(int first, int[] second, int[][] third, int[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        int [] xyz = {23,24,25,26};
+        int[][] xyz2 = {{23,24,25,26},{23,24},{23}};
+        int[][][] xyz3 = {xyz2,xyz2};
+        second = (int[]) change(second,xyz);
+        third = (int[][])change(third,xyz2);
+        four = (int[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03(int[][] third) {
+        //The test03 interface is called, and the RC_Array_01_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_01_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static int[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+    private static int[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+    private static int[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+    private static int[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        int [] value1 = {23,24,25,26};
+        RC_Array_01 rctest=new RC_Array_01(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new int[] {88,10,02,11};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+    private static int[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        int[][] value2 = {{23,24,25,26},{23,24},{23}};
+        RC_Array_01 rctest=new RC_Array_01(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new int[][] {{88,10,02,11},{10,92},{16}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+    private static int[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        int[][][] value3 = {{{10,20,30,40},{40,50},{60}},{{40,50,60,30},{70,80},{90}}};
+        RC_Array_01 rctest=new RC_Array_01(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new int[][][]{{{88,10,02,11},{10,92},{12}},{{88,10,02,11},{10,92},{16}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+    private static int[][] RC_Array_01_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to the newly created
+        // object field, and judge the result
+        int [] value1 = {23,24,25,26};
+        int[][] value2 = {{23,24,25,26},{23,24},{23}};
+        int[][][] value3 = {value2,value2};
+        RC_Array_01 rctest=new RC_Array_01(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new int[] {88,10,02,11};
+        rctest.base2 = new int[][] {{88,10,02,11},{10,92},{16}};
+        rctest.base21 = new int[][] {{88,10,02,11},{10,92},{12}};
+        rctest.base3 = new int[][][]{{{88,10,02,11},{10,92},{12}},{{88,10,02,11},{10,92},{16}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_01_test01");
+        return rctest.base21;
+    }
+    private static int[] RC_Array_final01()
+    {
+        final int [] VALUE1 = {23,24,25,26};
+        return VALUE1;
+    }
+    private static int[][] RC_Array_final02()
+    {
+        final int[][] VALUE2 = {{23,24,25,26},{23,24},{23}};
+        return VALUE2;
+    }
+    private static int[][][] RC_Array_final03()
+    {
+        final int[][][] VALUE3 = {{{10,20,30,40},{40,50},{60}},{{40,50,60,30},{70,80},{90}}};
+        return VALUE3;
+    }
+    private static int[][] RC_Array_01_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_01 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final int [] VALUE1 = RC_Array_final01();
+        final int[][] VALUE2 = RC_Array_final02();
+        final int[][][] VALUE3 = RC_Array_final03();
+        RC_Array_01 rctest=new RC_Array_01();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_01_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_01_test02_2");
+        return VALUE2;
+    }
+    private static Boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        int [] value1 = RC_Array_final01();
+        int[][] value2 = RC_Array_final02();
+        int[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getInt(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 23;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setInt(value1,5,10);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getInt(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getInt(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getInt(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //NumberFormatException
+        try{
+            Integer i = new Integer(10);
+            Array.setInt(value1,0,i.decode("abc"));
+        }catch (NumberFormatException e)
+        {
+            check++;
+        }
+        //ClassCastException
+        RC_Array_01 rc1 = new RC_Array_01();
+        try{
+            Base_001 bs1 = new Base_001();
+            rc1 = (RC_Array_01)bs1;
+            rc1.base1[0] = 123;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 123)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getInt(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getInt(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getInt(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        if (check == 19)
+            return true;
+        else
+            return false;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/expected.txt b/testsuite/java_test/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/test.cfg b/testsuite/java_test/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e654125e31d72cd52c5129191cf5c52a753a131f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0366-rc-ArrayOptimization-RC_Array_01/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_01)
+run(RC_Array_01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/RC_Array_02.java b/testsuite/java_test/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/RC_Array_02.java
new file mode 100755
index 0000000000000000000000000000000000000000..3dc6d90325f54531ff289e5073924fb166334193
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/RC_Array_02.java
@@ -0,0 +1,402 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.regex.PatternSyntaxException;
+class Base_002{
+    //Parent interface
+    volatile String[] base1;
+    String[][] base2;
+    String[][] base21;
+    String[][][] base3;
+}
+public class RC_Array_02 extends Base_002{
+    static int check_count = 0;
+    static String[] arr1 = {"10","20","30","40"};
+    static String[][] arr2 = {{"10","20","30","40"},{"40","50"},{"60"}};
+    static String[][] arr21 = {{"40","50","60","30"},{"70","80"},{"90"}};
+    static String[][][] arr3 = {arr2,arr21};
+    //literial type data
+    static String literial_v = "abc";
+    static String[] arstr1 = {literial_v,literial_v,literial_v,literial_v};
+    static String[][] arstr2 = {{"abc","abc","abc","abc"},{"abc","abc"},{literial_v}};
+    static String[][][] arstr3 = {arstr2,arstr2};
+    private RC_Array_02(){
+        base1 = new String[]{"10","20","30","40"};
+        base2 = new String[][]{{"10","20","30","40"},{"40","50"},{"60"}};
+        base21 = new String[][]{{"40","50","60","30"},{"70","80"},{"90"}};
+        base3 = new String[][][]{{{"10","20","30","40"},{"40","50"},{"60"}},{{"40","50","60","30"},{"70","80"},{"90"}}};
+    }
+    private RC_Array_02(String[] Stringar){
+        base1 = Stringar;
+    }
+    private RC_Array_02(String[][] Stringarr){
+        base2 = Stringarr;
+    }
+    private RC_Array_02(String[][][] Stringarrr){
+        base3 = Stringarrr;
+    }
+    private RC_Array_02(String[] Stringar, String[][] Stringarr, String[][][] Stringarrr){
+        base1 = Stringar;
+        base2 = Stringarr;
+        base3 = Stringarrr;
+    }
+    public static void main(String [] args) {
+        final String[] TEST1 = {"10","20","30","40"};
+        final String[][] TEST2 = {TEST1,{"40","50"},{"60"}};
+        final String[][] TEST21 = {{"40","50","60","30"},{"70","80"},{"90"}};
+        final String[][][] TEST3 = {TEST2,TEST21};
+        //literial type data
+        final String literial_v = "abc";
+        final String[] arstrr1 = {literial_v,literial_v,literial_v,literial_v};
+        final String[][] arstrr2 = {{"abc","abc","abc","abc"},{"abc","abc"},{literial_v}};
+        final String[][][] arstrr3 = {arstrr2,arstrr2};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2
+                && arstrr1.length == 4 && arstrr2.length == 3 && arstrr3.length == 2
+                && arstr1.length == 4 && arstr2.length == 3 && arstr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult String step1");
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        test01(4,arstr1,arstr2,arstr3);
+        test01(4,arstrr1,arstrr2,arstrr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2
+                && arstrr1.length == 4 && arstrr2.length == 3 && arstrr3.length == 2
+                && arstr1.length == 4 && arstr2.length == 3 && arstr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        test02(4,arstr1,arstr2,arstr3);
+        test02(4,arstrr1,arstrr2,arstrr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2
+                && arstrr1.length == 4 && arstrr2.length == 3 && arstrr3.length == 2
+                && arstr1.length == 4 && arstr2.length == 3 && arstr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+        //The test03 interface call, call the RC_Array_02_test01 function return value to the parameter third and judged.
+        //RC_Array_02_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_02() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_02_test02();
+        //Get an array object by returning a function call
+        String[] getarr1 = RC_Array_get01();
+        String[][] getarr2 = RC_Array_get02();
+        String[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+        //Exception testing
+        Boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 28)
+            System.out.println("ExpectResult");
+    }
+    private static void test01(int first, String[] second, String[][] third, String[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        String [] xyz = {"23","24","25","26"};
+        String[][] xyz2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        String[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+    private static void test02(int first, String[] second, String[][] third, String[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        String [] xyz = {"23","24","25","26"};
+        String[][] xyz2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        String[][][] xyz3 = {xyz2,xyz2};
+        second = (String[]) change(second,xyz);
+        third = (String[][])change(third,xyz2);
+        four = (String[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03(String[][] third) {
+        //The test03 interface is called, and the RC_Array_02_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_02_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static String[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+    private static String[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+    private static String[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+    private static String[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        String [] value1 = {"23","24","25","26"};
+        RC_Array_02 rctest=new RC_Array_02(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new String[] {"88","10","02","11"};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+    private static String[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        String[][] value2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        RC_Array_02 rctest=new RC_Array_02(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new String[][] {{"88","10","02","11"},{"10","92"},{"16"}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+    private static String[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        String[][][] value3 = {{{"10","20","30","40"},{"40","50"},{"60"}},{{"40","50","60","30"},{"70","80"},{"90"}}};
+        RC_Array_02 rctest=new RC_Array_02(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new String[][][]{{{"88","10","02","11"},{"10","92"},{"12"}},{{"88","10","02","11"},{"10","92"},{"16"}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+    private static String[][] RC_Array_02_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_02, and assign a value to the newly created
+        // object field, and judge the result
+        String [] value1 = {"23","24","25","26"};
+        String[][] value2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        String[][][] value3 = {value2,value2};
+        RC_Array_02 rctest=new RC_Array_02(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new String[] {"88","10","02","11"};
+        rctest.base2 = new String[][] {{"88","10","02","11"},{"10","92"},{"16"}};
+        rctest.base21 = new String[][] {{"88","10","02","11"},{"10","92"},{"12"}};
+        rctest.base3 = new String[][][]{{{"88","10","02","11"},{"10","92"},{"12"}},{{"88","10","02","11"},{"10","92"},{"16"}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_02_test01");
+        return rctest.base21;
+    }
+    private static String[] RC_Array_final01()
+    {
+        final String [] VALUE1 = {"23","24","25","26"};
+        return VALUE1;
+    }
+    private static String[][] RC_Array_final02()
+    {
+        final String[][] VALUE2 = {{"23","24","25","26"},{"23","24"},{"23"}};
+        return VALUE2;
+    }
+    private static String[][][] RC_Array_final03()
+    {
+        final String[][][] VALUE3 = {{{"10","20","30","40"},{"40","50"},{"60"}},{{"40","50","60","30"},{"70","80"},{"90"}}};
+        return VALUE3;
+    }
+    private static String[][] RC_Array_02_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_02 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final String [] VALUE1 = RC_Array_final01();
+        final String[][] VALUE2 = RC_Array_final02();
+        final String[][][] VALUE3 = RC_Array_final03();
+        RC_Array_02 rctest=new RC_Array_02();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_02_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_02_test02_2");
+        return VALUE2;
+    }
+    private static Boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        String [] value1 = RC_Array_final01();
+        String[][] value2 = RC_Array_final02();
+        String[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.get(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = "error";
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.set(value1,5,"10");
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.get(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IndexOutOfBoundsException
+        try {
+            char[] ch1 = {'h','x','c','t'};
+            Array.set(RC_Array_final03()[0][0],0,String.valueOf(ch1, 5, 2));
+        }catch (IndexOutOfBoundsException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_02 rc1 = new RC_Array_02();
+        try{
+            Base_002 bs1 = new Base_002();
+            rc1 = (RC_Array_02)bs1;
+            rc1.base1[0] = "kitty";
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != "kitty")
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.get(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.get(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.get(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 17)
+            return true;
+        else
+            return false;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/expected.txt b/testsuite/java_test/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/test.cfg b/testsuite/java_test/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2ae6ff7fdbd78f16e1c7f714027449a8f1e0c482
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0367-rc-ArrayOptimization-RC_Array_02/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_02)
+run(RC_Array_02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/RC_Array_03.java b/testsuite/java_test/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/RC_Array_03.java
new file mode 100755
index 0000000000000000000000000000000000000000..feabd65521f64572d6bf1cd05eccdf8f8e7bd831
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/RC_Array_03.java
@@ -0,0 +1,384 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+class Base_003{
+    //Parent interface
+    volatile char[] base1;
+    char[][] base2;
+    char[][] base21;
+    char[][][] base3;
+}
+public class RC_Array_03 extends Base_003{
+    static int check_count = 0;
+    static char[] arr1 = {'a','b','c','d'};
+    static char[][] arr2 = {{'a','b','c','d'},{'e','f'},{'g'}};
+    static char[][] arr21 = {{'h','i','j','k'},{'l','m'},{'n'}};
+    static char[][][] arr3 = {arr2,arr21};
+    private RC_Array_03(){
+        base1 = new char[]{'a','b','c','d'};
+        base2 = new char[][]{{'a','b','c','d'},{'e','f'},{'g'}};
+        base21 = new char[][]{{'h','i','j','k'},{'l','m'},{'n'}};
+        base3 = new char[][][]{{{'a','b','c','d'},{'e','f'},{'g'}},{{'h','i','j','k'},{'l','m'},{'n'}}};
+    }
+    private RC_Array_03(char[] charar){
+        base1 = charar;
+    }
+    private RC_Array_03(char[][] chararr){
+        base2 = chararr;
+    }
+    private RC_Array_03(char[][][] chararrr){
+        base3 = chararrr;
+    }
+    private RC_Array_03(char[] charar, char[][] chararr, char[][][] chararrr){
+        base1 = charar;
+        base2 = chararr;
+        base3 = chararrr;
+    }
+    public static void main(String[] args) {
+        final char[] TEST1 = {'1','2','3','4'};
+        final char[][] TEST2 = {TEST1,{'4','5'},{'6'}};
+        final char[][] TEST21 = {{'4','5','6','3'},{'7','8'},{'9'}};
+        final char[][][] TEST3 = {TEST2,TEST21};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult char step1");
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+        //The test03 interface call, call the RC_Array_03_test01 function return value to the parameter third and judged.
+        //RC_Array_03_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_03() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_03_test02();
+        //Get an array object by returning a function call
+        char[] getarr1 = RC_Array_get01();
+        char[][] getarr2 = RC_Array_get02();
+        char[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+        //Exception testing
+        Boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+    }
+    private static void test01(int first, char[] second, char[][] third, char[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        char [] xyz = {'h','x','w','g'};
+        char[][] xyz2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        char[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+    private static void test02(int first, char[] second, char[][] third, char[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        char [] xyz = {'h','x','w','g'};
+        char[][] xyz2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        char[][][] xyz3 = {xyz2,xyz2};
+        second = (char[]) change(second,xyz);
+        third = (char[][])change(third,xyz2);
+        four = (char[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03(char[][] third) {
+        //The test03 interface is called, and the RC_Array_03_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_03_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static char[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+    private static char[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+    private static char[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+    private static char[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        char [] value1 = {'h','x','w','g'};
+        RC_Array_03 rctest=new RC_Array_03(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new char[] {'8','0','2','3'};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+    private static char[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        char[][] value2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        RC_Array_03 rctest=new RC_Array_03(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new char[][] {{'8','0','2','3'},{'w','g'},{'q'}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+    private static char[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        char[][][] value3 = {{{'1','2','3','4'},{'4','5'},{'6'}},{{'4','5','6','3'},{'7','8'},{'9'}}};
+        RC_Array_03 rctest=new RC_Array_03(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new char[][][]{{{'w','a','n','g'},{'s','u'},{'n'}},{{'w','a','n','g'},{'w','g'},{'q'}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+    private static char[][] RC_Array_03_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_03, and assign a value to the newly created
+        // object field, and judge the result
+        char [] value1 = {'h','x','w','g'};
+        char[][] value2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        char[][][] value3 = {value2,value2};
+        RC_Array_03 rctest=new RC_Array_03(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new char[] {'w','a','n','g'};
+        rctest.base2 = new char[][] {{'w','a','n','g'},{'w','g'},{'q'}};
+        rctest.base21 = new char[][] {{'w','a','n','g'},{'s','u'},{'n'}};
+        rctest.base3 = new char[][][]{{{'w','a','n','g'},{'s','u'},{'n'}},{{'w','a','n','g'},{'w','g'},{'q'}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_03_test01");
+        return rctest.base21;
+    }
+    private static char[] RC_Array_final01()
+    {
+        final char [] VALUE1 = {'h','x','w','g'};
+        return VALUE1;
+    }
+    private static char[][] RC_Array_final02()
+    {
+        final char[][] VALUE2 = {{'h','x','w','g'},{'w','g'},{'q'}};
+        return VALUE2;
+    }
+    private static char[][][] RC_Array_final03()
+    {
+        final char[][][] VALUE3 = {{{'1','2','3','4'},{'4','5'},{'6'}},{{'4','5','6','3'},{'7','8'},{'9'}}};
+        return VALUE3;
+    }
+    private static char[][] RC_Array_03_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_03 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final char [] VALUE1 = RC_Array_final01();
+        final char[][] VALUE2 = RC_Array_final02();
+        final char[][][] VALUE3 = RC_Array_final03();
+        RC_Array_03 rctest=new RC_Array_03();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_03_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_03_test02_2");
+        return VALUE2;
+    }
+    private static Boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        char[] value1 = RC_Array_final01();
+        char[][] value2 = RC_Array_final02();
+        char[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getChar(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 'e';
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setChar(value1,5,'1');
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getChar(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getChar(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getChar(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_03 rc1 = new RC_Array_03();
+        try{
+            Base_003 bs1 = new Base_003();
+            rc1 = (RC_Array_03)bs1;
+            rc1.base1[0] = 'p';
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 'p')
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getChar(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getChar(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getChar(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/expected.txt b/testsuite/java_test/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/test.cfg b/testsuite/java_test/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b3dcb8c0397e2655ca707d5cf41c29e233e7d22
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0368-rc-ArrayOptimization-RC_Array_03/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_03)
+run(RC_Array_03,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/RC_Array_04.java b/testsuite/java_test/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/RC_Array_04.java
new file mode 100755
index 0000000000000000000000000000000000000000..afcc5e845f65dc24d0bc367f4a2d4815bafba8b9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/RC_Array_04.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+class Base_004{
+    //Parent interface
+    volatile boolean[] base1;
+    boolean[][] base2;
+    boolean[][] base21;
+    boolean[][][] base3;
+}
+public class RC_Array_04 extends Base_004{
+    static int check_count = 0;
+    static boolean[] arr1 = {true,false,false,true};
+    static boolean[][] arr2 = {{true,false,false,true},{false,false},{true,true}};
+    static boolean[][] arr21 = {{false,true,false,true},{true,false},{false,true}};
+    static boolean[][][] arr3 = {arr2,arr21};
+    private RC_Array_04(){
+        base1 = new boolean[]{true,true,true,true};
+        base2 = new boolean[][]{{true,true,true,true},{false,false},{true,true}};
+        base21 = new boolean[][]{{false,true,true,true},{false,true},{true,true}};
+        base3 = new boolean[][][]{{{true,true,true,true},{false,false},{true,true}},{{false,true,true,true},{false,true},{true,true}}};
+    }
+    private RC_Array_04(boolean[] booleanar){
+        base1 = booleanar;
+    }
+    private RC_Array_04(boolean[][] booleanarr){
+        base2 = booleanarr;
+    }
+    private RC_Array_04(boolean[][][] booleanarrr){
+        base3 = booleanarrr;
+    }
+    private RC_Array_04(boolean[] booleanar, boolean[][] booleanarr, boolean[][][] booleanarrr){
+        base1 = booleanar;
+        base2 = booleanarr;
+        base3 = booleanarrr;
+    }
+    public static void main(String[] args) {
+        final boolean[] TEST1 = {true,true,true,true};
+        final boolean[][] TEST2 = {TEST1,{false,false},{true,true}};
+        final boolean[][] TEST21 = {{false,true,true,true},{false,true},{true,true}};
+        final boolean[][][] TEST3 = {TEST2,TEST21};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult boolean step1");
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+        //The test03 interface call, call the RC_Array_04_test01 function return value to the parameter third and judged.
+        //RC_Array_04_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_04() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_04_test02();
+        //Get an array object by returning a function call
+        boolean[] getarr1 = RC_Array_get01();
+        boolean[][] getarr2 = RC_Array_get02();
+        boolean[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+    }
+    private static void test01(int first, boolean[] second, boolean[][] third, boolean[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        boolean [] xyz = {false,true,false,true};
+        boolean[][] xyz2 = {{true,true,true,true},{false,false},{true}};
+        boolean[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+    private static void test02(int first, boolean[] second, boolean[][] third, boolean[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        boolean [] xyz = {false,true,false,true};
+        boolean[][] xyz2 = {{true,true,true,true},{false,false},{true}};
+        boolean[][][] xyz3 = {xyz2,xyz2};
+        second = (boolean[]) change(second,xyz);
+        third = (boolean[][])change(third,xyz2);
+        four = (boolean[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03(boolean[][] third) {
+        //The test03 interface is called, and the RC_Array_04_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_04_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static boolean[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+    private static boolean[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+    private static boolean[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+    private static boolean[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        boolean [] value1 = {false,false,false,false};
+        RC_Array_04 rctest=new RC_Array_04(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new boolean[] {true,true,true,true};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+    private static boolean[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        boolean[][] value2 = {{true,true,true,true},{false,false},{true}};
+        RC_Array_04 rctest=new RC_Array_04(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new boolean[][] {{false,false,false,false},{false,false},{true}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+    private static boolean[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        boolean[][][] value3 = {{{true,true,true,true},{false,false},{true}},{{false,false,false,false},{false,false},{true}}};
+        RC_Array_04 rctest=new RC_Array_04(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new boolean[][][]{{{false,false,false,false},{false,false},{true}},{{true,true,true,true},{false,false},{true}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+    private static boolean[][] RC_Array_04_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_04, and assign a value to the newly created
+        // object field, and judge the result
+        boolean [] value1 = {true,true,true,true};
+        boolean[][] value2 = {{true,true,true,true},{false,false},{true}};
+        boolean[][][] value3 = {value2,value2};
+        RC_Array_04 rctest=new RC_Array_04(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new boolean[] {false,false,false,false};
+        rctest.base2 = new boolean[][] {{false,false,false,false},{false,false},{true}};
+        rctest.base21 = new boolean[][] {{false,true,true,false},{false,false},{true}};
+        rctest.base3 = new boolean[][][]{{{false,false,false,false},{false,false},{true}},{{false,true,true,false},{false,false},{true}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_04_test01");
+        return rctest.base21;
+    }
+    private static boolean[] RC_Array_final01()
+    {
+        final boolean[] VALUE1 = {true,true,true,true};
+        return VALUE1;
+    }
+    private static boolean[][] RC_Array_final02()
+    {
+        final boolean[][] VALUE2 = {{false,false,false,false},{false,false},{true}};
+        return VALUE2;
+    }
+    private static boolean[][][] RC_Array_final03()
+    {
+        final boolean[][][] VALUE3 = {{{false,true,true,false},{false,false},{true}},{{false,false,false,false},{false,false},{true}}};
+        return VALUE3;
+    }
+    private static boolean[][] RC_Array_04_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_04 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final boolean[] VALUE1 = RC_Array_final01();
+        final boolean[][] VALUE2 = RC_Array_final02();
+        final boolean[][][] VALUE3 = RC_Array_final03();
+        RC_Array_04 rctest=new RC_Array_04();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_04_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_04_test02_2");
+        return VALUE2;
+    }
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        boolean[] value1 = RC_Array_final01();
+        boolean[][] value2 = RC_Array_final02();
+        boolean[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getBoolean(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = false;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setBoolean(value1,5,true);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getBoolean(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_04 rc1 = new RC_Array_04();
+        try{
+            Base_004 bs1 = new Base_004();
+            rc1 = (RC_Array_04)bs1;
+            rc1.base1[0] = false;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != false)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getBoolean(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getBoolean(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/expected.txt b/testsuite/java_test/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/test.cfg b/testsuite/java_test/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8ad05e7db0bfc029d4c2e8e4ee3658b3ad0fda70
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0369-rc-ArrayOptimization-RC_Array_04/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_04)
+run(RC_Array_04,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/RC_Array_05.java b/testsuite/java_test/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/RC_Array_05.java
new file mode 100755
index 0000000000000000000000000000000000000000..51331fb8c8b2656711447ba009f7ee491b4eaf70
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/RC_Array_05.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+class Base_005{
+    //Parent interface
+    volatile byte[] base1;
+    byte[][] base2;
+    byte[][] base21;
+    byte[][][] base3;
+}
+public class RC_Array_05 extends Base_005{
+    static int check_count = 0;
+    static byte[] arr1 = {1,2,3,4};
+    static byte[][] arr2 = {{1,2,3,4},{5,6},{7,8}};
+    static byte[][] arr21 = {{4,5,6,7},{8,9},{10,11}};
+    static byte[][][] arr3 = {arr2,arr21};
+    private RC_Array_05(){
+        base1 = new byte[]{1,2,3,4};
+        base2 = new byte[][]{{1,2,3,4},{5,6},{7,8}};
+        base21 = new byte[][]{{4,5,6,7},{8,9},{10,11}};
+        base3 = new byte[][][]{{{1,2,3,4},{5,6},{7,8}},{{4,5,6,7},{8,9},{10,11}}};
+    }
+    private RC_Array_05(byte[] bytear){
+        base1 = bytear;
+    }
+    private RC_Array_05(byte[][] bytearr){
+        base2 = bytearr;
+    }
+    private RC_Array_05(byte[][][] bytearrr){
+        base3 = bytearrr;
+    }
+    private RC_Array_05(byte[] bytear, byte[][] bytearr, byte[][][] bytearrr){
+        base1 = bytear;
+        base2 = bytearr;
+        base3 = bytearrr;
+    }
+    public static void main(String[] args) {
+        final byte[] TEST1 = {1,2,3,4};
+        final byte[][] TEST2 = {TEST1,{5,6},{7,8}};
+        final byte[][] TEST21 = {{4,5,6,7},{8,9},{10,11}};
+        final byte[][][] TEST3 = {TEST2,TEST21};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult byte step1");
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+        //The test03 interface call, call the RC_Array_05_test01 function return value to the parameter third and judged.
+        //RC_Array_05_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_05() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_05_test02();
+        //Get an array object by returning a function call
+        byte[] getarr1 = RC_Array_get01();
+        byte[][] getarr2 = RC_Array_get02();
+        byte[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+    }
+    private static void test01(int first, byte[] second, byte[][] third, byte[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        byte [] xyz = {8,8,1,0};
+        byte[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        byte[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+    private static void test02(int first, byte[] second, byte[][] third, byte[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        byte [] xyz = {8,8,1,0};
+        byte[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        byte[][][] xyz3 = {xyz2,xyz2};
+        second = (byte[]) change(second,xyz);
+        third = (byte[][])change(third,xyz2);
+        four = (byte[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03(byte[][] third) {
+        //The test03 interface is called, and the RC_Array_05_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_05_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static byte[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+    private static byte[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+    private static byte[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+    private static byte[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        byte [] value1 = {9,2,8,8};
+        RC_Array_05 rctest=new RC_Array_05(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new byte[] {1,2,3,4};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+    private static byte[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        byte[][] value2 = {{1,2,3,4},{1,1},{0}};
+        RC_Array_05 rctest=new RC_Array_05(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new byte[][] {{9,2,8,8},{1,1},{0}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+    private static byte[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        byte[][][] value3 = {{{1,2,3,4},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        RC_Array_05 rctest=new RC_Array_05(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new byte[][][]{{{9,2,8,8},{1,1},{0}},{{1,2,3,4},{1,1},{0}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+    private static byte[][] RC_Array_05_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_05, and assign a value to the newly created
+        // object field, and judge the result
+        byte [] value1 = {1,2,3,4};
+        byte[][] value2 = {{1,2,3,4},{1,1},{0}};
+        byte[][][] value3 = {value2,value2};
+        RC_Array_05 rctest=new RC_Array_05(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new byte[] {9,2,8,8};
+        rctest.base2 = new byte[][] {{9,2,8,8},{1,1},{0}};
+        rctest.base21 = new byte[][] {{6,6,6,5},{1,1},{0}};
+        rctest.base3 = new byte[][][]{{{9,2,8,8},{1,1},{0}},{{6,6,6,5},{1,1},{0}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_05_test01");
+        return rctest.base21;
+    }
+    private static byte[] RC_Array_final01()
+    {
+        final byte[] VALUE1 = {1,2,3,4};
+        return VALUE1;
+    }
+    private static byte[][] RC_Array_final02()
+    {
+        final byte[][] VALUE2 = {{9,2,8,8},{1,1},{0}};
+        return VALUE2;
+    }
+    private static byte[][][] RC_Array_final03()
+    {
+        final byte[][][] VALUE3 = {{{6,6,6,5},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        return VALUE3;
+    }
+    private static byte[][] RC_Array_05_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_05 () no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final byte[] VALUE1 = RC_Array_final01();
+        final byte[][] VALUE2 = RC_Array_final02();
+        final byte[][][] VALUE3 = RC_Array_final03();
+        RC_Array_05 rctest=new RC_Array_05();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_05_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_05_test02_2");
+        return VALUE2;
+    }
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        byte[] value1 = RC_Array_final01();
+        byte[][] value2 = RC_Array_final02();
+        byte[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getByte(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 'h';
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setByte(value1,5,(byte)0x19);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getByte(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getByte(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getByte(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_05 rc1 = new RC_Array_05();
+        try{
+            Base_005 bs1 = new Base_005();
+            rc1 = (RC_Array_05)bs1;
+            rc1.base1[0] = 8;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getByte(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getByte(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getByte(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/expected.txt b/testsuite/java_test/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/test.cfg b/testsuite/java_test/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc6270bc9c67a4addb6c3299cde20abd810d1cdc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0370-rc-ArrayOptimization-RC_Array_05/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_05)
+run(RC_Array_05,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/RC_Array_06.java b/testsuite/java_test/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/RC_Array_06.java
new file mode 100755
index 0000000000000000000000000000000000000000..a706d35f58e70cebd12cdead59acd276e55d557f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/RC_Array_06.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+class Base_006{
+    //Parent interface
+    volatile short[] base1;
+    short[][] base2;
+    short[][] base21;
+    short[][][] base3;
+}
+public class RC_Array_06 extends Base_006{
+    static int check_count = 0;
+    static short[] arr1 = {1,2,3,4};
+    static short[][] arr2 = {{1,2,3,4},{5,6},{7,8}};
+    static short[][] arr21 = {{4,5,6,7},{8,9},{10,11}};
+    static short[][][] arr3 = {arr2,arr21};
+    private RC_Array_06(){
+        base1 = new short[]{1,2,3,4};
+        base2 = new short[][]{{1,2,3,4},{5,6},{7,8}};
+        base21 = new short[][]{{4,5,6,7},{8,9},{10,11}};
+        base3 = new short[][][]{{{1,2,3,4},{5,6},{7,8}},{{4,5,6,7},{8,9},{10,11}}};
+    }
+    private RC_Array_06(short[] shortar){
+        base1 = shortar;
+    }
+    private RC_Array_06(short[][] shortarr){
+        base2 = shortarr;
+    }
+    private RC_Array_06(short[][][] shortarrr){
+        base3 = shortarrr;
+    }
+    private RC_Array_06(short[] shortar, short[][] shortarr, short[][][] shortarrr){
+        base1 = shortar;
+        base2 = shortarr;
+        base3 = shortarrr;
+    }
+    public static void main(String[] args) {
+        final short[] TEST1 = {1,2,3,4};
+        final short[][] TEST2 = {TEST1,{5,6},{7,8}};
+        final short[][] TEST21 = {{4,5,6,7},{8,9},{10,11}};
+        final short[][][] TEST3 = {TEST2,TEST21};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult short step1");
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+        //The test03 interface call, call the RC_Array_06_test01 function return value to the parameter third and judged.
+        //RC_Array_06_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_06() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_06_test02();
+        //Get an array object by returning a function call
+        short[] getarr1 = RC_Array_get01();
+        short[][] getarr2 = RC_Array_get02();
+        short[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+    }
+    private static void test01(int first, short[] second, short[][] third, short[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        short [] xyz = {8,8,1,0};
+        short[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        short[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+    private static void test02(int first, short[] second, short[][] third, short[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        short [] xyz = {8,8,1,0};
+        short[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        short[][][] xyz3 = {xyz2,xyz2};
+        second = (short[]) change(second,xyz);
+        third = (short[][])change(third,xyz2);
+        four = (short[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03(short[][] third) {
+        //The test03 interface is called, and the RC_Array_06_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_06_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static short[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+    private static short[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+    private static short[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+    private static short[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        short [] value1 = {9,2,8,8};
+        RC_Array_06 rctest=new RC_Array_06(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new short[] {1,2,3,4};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+    private static short[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        short[][] value2 = {{1,2,3,4},{1,1},{0}};
+        RC_Array_06 rctest=new RC_Array_06(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new short[][] {{9,2,8,8},{1,1},{0}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+    private static short[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        short[][][] value3 = {{{1,2,3,4},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        RC_Array_06 rctest=new RC_Array_06(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new short[][][]{{{9,2,8,8},{1,1},{0}},{{1,2,3,4},{1,1},{0}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+    private static short[][] RC_Array_06_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_06, and assign a value to the newly created
+        // object field, and judge the result
+        short [] value1 = {1,2,3,4};
+        short[][] value2 = {{1,2,3,4},{1,1},{0}};
+        short[][][] value3 = {value2,value2};
+        RC_Array_06 rctest=new RC_Array_06(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new short[] {9,2,8,8};
+        rctest.base2 = new short[][] {{9,2,8,8},{1,1},{0}};
+        rctest.base21 = new short[][] {{6,6,6,5},{1,1},{0}};
+        rctest.base3 = new short[][][]{{{9,2,8,8},{1,1},{0}},{{6,6,6,5},{1,1},{0}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_06_test01");
+        return rctest.base21;
+    }
+    private static short[] RC_Array_final01()
+    {
+        final short[] VALUE1 = {1,2,3,4};
+        return VALUE1;
+    }
+    private static short[][] RC_Array_final02()
+    {
+        final short[][] VALUE2 = {{9,2,8,8},{1,1},{0}};
+        return VALUE2;
+    }
+    private static short[][][] RC_Array_final03()
+    {
+        final short[][][] VALUE3 = {{{6,6,6,5},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        return VALUE3;
+    }
+    private static short[][] RC_Array_06_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_06() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final short[] VALUE1 = RC_Array_final01();
+        final short[][] VALUE2 = RC_Array_final02();
+        final short[][][] VALUE3 = RC_Array_final03();
+        RC_Array_06 rctest=new RC_Array_06();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_06_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_06_test02_2");
+        return VALUE2;
+    }
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        short[] value1 = RC_Array_final01();
+        short[][] value2 = RC_Array_final02();
+        short[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getShort(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 88;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setShort(value1,5,(short)12);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getShort(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getShort(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getShort(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_06 rc1 = new RC_Array_06();
+        try{
+            Base_006 bs1 = new Base_006();
+            rc1 = (RC_Array_06)bs1;
+            rc1.base1[0] = 8;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getShort(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getShort(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getShort(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/expected.txt b/testsuite/java_test/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/test.cfg b/testsuite/java_test/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a44ac2b019f6cc6f1f858bfee5e33a31a0fe9c79
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0371-rc-ArrayOptimization-RC_Array_06/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_06)
+run(RC_Array_06,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/RC_Array_07.java b/testsuite/java_test/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/RC_Array_07.java
new file mode 100755
index 0000000000000000000000000000000000000000..3f2789b4e119afab811875eff794acf17a4b83ff
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/RC_Array_07.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+class Base_007{
+    //Parent interface
+    volatile long[] base1;
+    long[][] base2;
+    long[][] base21;
+    long[][][] base3;
+}
+public class RC_Array_07 extends Base_007{
+    static int check_count = 0;
+    static long[] arr1 = {1,2,3,4};
+    static long[][] arr2 = {{1,2,3,4},{5,6},{7,8}};
+    static long[][] arr21 = {{4,5,6,7},{8,9},{10,11}};
+    static long[][][] arr3 = {arr2,arr21};
+    private RC_Array_07(){
+        base1 = new long[]{1,2,3,4};
+        base2 = new long[][]{{1,2,3,4},{5,6},{7,8}};
+        base21 = new long[][]{{4,5,6,7},{8,9},{10,11}};
+        base3 = new long[][][]{{{1,2,3,4},{5,6},{7,8}},{{4,5,6,7},{8,9},{10,11}}};
+    }
+    private RC_Array_07(long[] longar){
+        base1 = longar;
+    }
+    private RC_Array_07(long[][] longarr){
+        base2 = longarr;
+    }
+    private RC_Array_07(long[][][] longarrr){
+        base3 = longarrr;
+    }
+    private RC_Array_07(long[] longar, long[][] longarr, long[][][] longarrr){
+        base1 = longar;
+        base2 = longarr;
+        base3 = longarrr;
+    }
+    public static void main(String[] args) {
+        final long[] TEST1 = {1,2,3,4};
+        final long[][] TEST2 = {TEST1,{5,6},{7,8}};
+        final long[][] TEST21 = {{4,5,6,7},{8,9},{10,11}};
+        final long[][][] TEST3 = {TEST2,TEST21};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult long step1");
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+        //The test03 interface call, call the RC_Array_07_test01 function return value to the parameter third and judged.
+        //RC_Array_07_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_07() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_07_test02();
+        //Get an array object by returning a function call
+        long[] getarr1 = RC_Array_get01();
+        long[][] getarr2 = RC_Array_get02();
+        long[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+    }
+    private static void test01(int first, long[] second, long[][] third, long[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        long [] xyz = {8,8,1,0};
+        long[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        long[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+    private static void test02(int first, long[] second, long[][] third, long[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        long [] xyz = {8,8,1,0};
+        long[][] xyz2 = {{1,2,3,4},{1,1},{0}};
+        long[][][] xyz3 = {xyz2,xyz2};
+        second = (long[]) change(second,xyz);
+        third = (long[][])change(third,xyz2);
+        four = (long[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03(long[][] third) {
+        //The test03 interface is called, and the RC_Array_07_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_07_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static long[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+    private static long[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+    private static long[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+    private static long[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        long [] value1 = {9,2,8,8};
+        RC_Array_07 rctest=new RC_Array_07(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new long[] {1,2,3,4};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+    private static long[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        long[][] value2 = {{1,2,3,4},{1,1},{0}};
+        RC_Array_07 rctest=new RC_Array_07(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new long[][] {{9,2,8,8},{1,1},{0}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+    private static long[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        long[][][] value3 = {{{1,2,3,4},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        RC_Array_07 rctest=new RC_Array_07(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new long[][][]{{{9,2,8,8},{1,1},{0}},{{1,2,3,4},{1,1},{0}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+    private static long[][] RC_Array_07_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_07, and assign a value to the newly created
+        // object field, and judge the result
+        long [] value1 = {1,2,3,4};
+        long[][] value2 = {{1,2,3,4},{1,1},{0}};
+        long[][][] value3 = {value2,value2};
+        RC_Array_07 rctest=new RC_Array_07(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new long[] {9,2,8,8};
+        rctest.base2 = new long[][] {{9,2,8,8},{1,1},{0}};
+        rctest.base21 = new long[][] {{6,6,6,5},{1,1},{0}};
+        rctest.base3 = new long[][][]{{{9,2,8,8},{1,1},{0}},{{6,6,6,5},{1,1},{0}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_07_test01");
+        return rctest.base21;
+    }
+    private static long[] RC_Array_final01()
+    {
+        final long[] VALUE1 = {1,2,3,4};
+        return VALUE1;
+    }
+    private static long[][] RC_Array_final02()
+    {
+        final long[][] VALUE2 = {{9,2,8,8},{1,1},{0}};
+        return VALUE2;
+    }
+    private static long[][][] RC_Array_final03()
+    {
+        final long[][][] VALUE3 = {{{6,6,6,5},{1,1},{0}},{{9,2,8,8},{1,1},{0}}};
+        return VALUE3;
+    }
+    private static long[][] RC_Array_07_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_07() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final long[] VALUE1 = RC_Array_final01();
+        final long[][] VALUE2 = RC_Array_final02();
+        final long[][][] VALUE3 = RC_Array_final03();
+        RC_Array_07 rctest=new RC_Array_07();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_07_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_07_test02_2");
+        return VALUE2;
+    }
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        long[] value1 = RC_Array_final01();
+        long[][] value2 = RC_Array_final02();
+        long[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getLong(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 92;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setLong(value1,5,(long)12);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getLong(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getLong(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getLong(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_07 rc1 = new RC_Array_07();
+        try{
+            Base_007 bs1 = new Base_007();
+            rc1 = (RC_Array_07)bs1;
+            rc1.base1[0] = 8;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getLong(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getLong(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getLong(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/expected.txt b/testsuite/java_test/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/test.cfg b/testsuite/java_test/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c576492a3c7786bfd13e4689624189f83c9a4505
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0372-rc-ArrayOptimization-RC_Array_07/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_07)
+run(RC_Array_07,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/RC_Array_08.java b/testsuite/java_test/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/RC_Array_08.java
new file mode 100755
index 0000000000000000000000000000000000000000..ed8020e6325d977811834d8b45daed732b99632f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/RC_Array_08.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+class Base_008{
+    //Parent interface
+    volatile float[] base1;
+    float[][] base2;
+    float[][] base21;
+    float[][][] base3;
+}
+public class RC_Array_08 extends Base_008{
+    static int check_count = 0;
+    static float[] arr1 = {1.1f,2.2f,3.3f,4.4f};
+    static float[][] arr2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+    static float[][] arr21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+    static float[][][] arr3 = {arr2,arr21};
+    private RC_Array_08(){
+        base1 = new float[]{1.1f,2.2f,3.3f,4.4f};
+        base2 = new float[][]{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+        base21 = new float[][]{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+        base3 = new float[][][]{{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}}};
+    }
+    private RC_Array_08(float[] floatar){
+        base1 = floatar;
+    }
+    private RC_Array_08(float[][] floatarr){
+        base2 = floatarr;
+    }
+    private RC_Array_08(float[][][] floatarrr){
+        base3 = floatarrr;
+    }
+    private RC_Array_08(float[] floatar, float[][] floatarr, float[][][] floatarrr){
+        base1 = floatar;
+        base2 = floatarr;
+        base3 = floatarrr;
+    }
+    public static void main(String[] args) {
+        final float[] TEST1 = {1.1f,2.2f,3.3f,4.4f};
+        final float[][] TEST2 = {TEST1,{5.5f,6.6f},{7.7f,8.8f}};
+        final float[][] TEST21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+        final float[][][] TEST3 = {TEST2,TEST21};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult float step1");
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+        //The test03 interface call, call the RC_Array_08_test01 function return value to the parameter third and judged.
+        //RC_Array_08_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_08() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_08_test02();
+        //Get an array object by returning a function call
+        float[] getarr1 = RC_Array_get01();
+        float[][] getarr2 = RC_Array_get02();
+        float[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+    }
+    private static void test01(int first, float[] second, float[][] third, float[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        float [] xyz = {8.5f,8.3f,1.2f,0.5f};
+        float[][] xyz2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        float[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+    private static void test02(int first, float[] second, float[][] third, float[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        float [] xyz = {8.5f,8.3f,1.2f,0.5f};
+        float[][] xyz2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        float[][][] xyz3 = {xyz2,xyz2};
+        second = (float[]) change(second,xyz);
+        third = (float[][])change(third,xyz2);
+        four = (float[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03(float[][] third) {
+        //The test03 interface is called, and the RC_Array_08_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_08_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static float[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+    private static float[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+    private static float[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+    private static float[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        float [] value1 = {9.2f,2.2f,8.8f,8.8f};
+        RC_Array_08 rctest=new RC_Array_08(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new float[] {1.1f,2.2f,3.3f,4.4f};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+    private static float[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        float[][] value2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        RC_Array_08 rctest=new RC_Array_08(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new float[][] {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+    private static float[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        float[][][] value3 = {{{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}},{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}}};
+        RC_Array_08 rctest=new RC_Array_08(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new float[][][]{{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}},{{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+    private static float[][] RC_Array_08_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_08, and assign a value to the newly created
+        // object field, and judge the result
+        float [] value1 = {1.1f,2.2f,3.3f,4.4f};
+        float[][] value2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        float[][][] value3 = {value2,value2};
+        RC_Array_08 rctest=new RC_Array_08(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new float[] {9.2f,2.2f,8.8f,8.8f};
+        rctest.base2 = new float[][] {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        rctest.base21 = new float[][] {{6,6,6,5},{1.3f,1.1f},{0.5f}};
+        rctest.base3 = new float[][][]{{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}},{{6,6,6,5},{1.3f,1.1f},{0.5f}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_08_test01");
+        return rctest.base21;
+    }
+    private static float[] RC_Array_final01()
+    {
+        final float[] VALUE1 = {1.1f,2.2f,3.3f,4.4f};
+        return VALUE1;
+    }
+    private static float[][] RC_Array_final02()
+    {
+        final float[][] VALUE2 = {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        return VALUE2;
+    }
+    private static float[][][] RC_Array_final03()
+    {
+        final float[][][] VALUE3 = {{{6.4f,6.1f,6.3f,5.5f},{1.3f,1.1f},{0.5f}},{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}}};
+        return VALUE3;
+    }
+    private static float[][] RC_Array_08_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_08() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final float[] VALUE1 = RC_Array_final01();
+        final float[][] VALUE2 = RC_Array_final02();
+        final float[][][] VALUE3 = RC_Array_final03();
+        RC_Array_08 rctest=new RC_Array_08();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_08_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_08_test02_2");
+        return VALUE2;
+    }
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        float[] value1 = RC_Array_final01();
+        float[][] value2 = RC_Array_final02();
+        float[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getFloat(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 88.10f;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setFloat(value1,5,12.5f);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(RC_Array_final01(),5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(RC_Array_final02()[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getFloat(RC_Array_final03()[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getFloat(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_08 rc1 = new RC_Array_08();
+        try{
+            Base_008 bs1 = new Base_008();
+            rc1 = (RC_Array_08)bs1;
+            rc1.base1[0] = 8.9f;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8.9f)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getFloat(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getFloat(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 18)
+            return true;
+        else
+            return false;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/expected.txt b/testsuite/java_test/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/test.cfg b/testsuite/java_test/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..551edb625f80690ce7063382951463e20253b2c6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0373-rc-ArrayOptimization-RC_Array_08/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_08)
+run(RC_Array_08,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/RC_Array_09.java b/testsuite/java_test/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/RC_Array_09.java
new file mode 100755
index 0000000000000000000000000000000000000000..cc80daf76c1d38f32d580d8eacb29a624d6056ea
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/RC_Array_09.java
@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+class Base_009{
+    //Parent interface
+    volatile double[] base1;
+    double[][] base2;
+    double[][] base21;
+    double[][][] base3;
+}
+public class RC_Array_09 extends Base_009{
+    static int check_count = 0;
+    static double[] arr1 = {1.1f,2.2f,3.3f,4.4f};
+    static double[][] arr2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+    static double[][] arr21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+    static double[][][] arr3 = {arr2,arr21};
+    private RC_Array_09(){
+        base1 = new double[]{1.1f,2.2f,3.3f,4.4f};
+        base2 = new double[][]{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+        base21 = new double[][]{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+        base3 = new double[][][]{{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}}};
+    }
+    private RC_Array_09(double[] doublear){
+        base1 = doublear;
+    }
+    private RC_Array_09(double[][] doublearr){
+        base2 = doublearr;
+    }
+    private RC_Array_09(double[][][] doublearrr){
+        base3 = doublearrr;
+    }
+    private RC_Array_09(double[] doublear, double[][] doublearr, double[][][] doublearrr){
+        base1 = doublear;
+        base2 = doublearr;
+        base3 = doublearrr;
+    }
+    public static void main(String[] args) {
+        final double[] TEST1 = {1.1f,2.2f,3.3f,4.4f};
+        final double[][] TEST2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f,8.8f}};
+        final double[][] TEST21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f,11.10f}};
+        final double[][][] TEST3 = {TEST2,TEST21};
+        //Initialization check
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult double step1");
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        test01(4,TEST1,TEST2,TEST3);
+        test01(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step2");
+        //test02 interface call, call function change to modify the parameter value and judge
+        test02(4,TEST1,TEST2,TEST3);
+        test02(4,arr1,arr2,arr3);
+        if(TEST1.length == 4 && TEST2.length == 3 && TEST3.length == 2
+                && arr1.length == 4 && arr2.length == 3 && arr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step3");
+        //The test03 interface call, call the RC_Array_09_test01 function return value to the parameter third and judged.
+        //RC_Array_09_test01,return 2D array，Call the multi-parameter constructor of RC_Array_01, and assign a value to
+        //the newly created object field, and judge the result
+        test03(TEST2);
+        test03(arr2);
+        if(TEST2.length == 3 && arr2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step4");
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_09() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        //Test points: inheritance, constructor, return function call, constant, variable, do not receive return value
+        RC_Array_09_test02();
+        //Get an array object by returning a function call
+        double[] getarr1 = RC_Array_get01();
+        double[][] getarr2 = RC_Array_get02();
+        double[][][] getarr3 = RC_Array_get03();
+        if(getarr1.length == 4 && getarr2.length == 3 && getarr3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in step5");
+        //Exception testing
+        boolean ret = RC_Array_Exception();
+        if (ret == true)
+            check_count++;
+        else
+            System.out.println("RC_Array_Exception ErrorResult");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 24)
+            System.out.println("ExpectResult");
+    }
+    private static void test01(int first, double[] second, double[][] third, double[][][] four) {
+        //test01 interface call, internal initialization array, do not modify the parameter value, only judge
+        double [] xyz = {8.5f,8.3f,1.2f,0.5f};
+        double[][] xyz2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        double[][][] xyz3 = {xyz2,xyz2};
+        if(second.length == 4 && third.length == 3 && four.length == 2
+                && xyz.length == 4 && xyz2.length == 3 && xyz3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static Object change(Object temp1, Object temp2){
+        temp1 = temp2;
+        return temp1;
+    }
+    private static void test02(int first, double[] second, double[][] third, double[][][] four) {
+        //test02 interface call, call function change to modify the parameter value and judge
+        double [] xyz = {8.5f,8.3f,1.2f,0.5f};
+        double[][] xyz2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        double[][][] xyz3 = {xyz2,xyz2};
+        second = (double[]) change(second,xyz);
+        third = (double[][])change(third,xyz2);
+        four = (double[][][]) change(four,xyz3);
+        if(second.length == 4 && third.length == 3 && four.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03(double[][] third) {
+        //The test03 interface is called, and the RC_Array_09_test01 function call is assigned as the return value to
+        // the parameter third and judged.
+        third = RC_Array_09_test01();
+        if(third.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static double[] RC_Array_get01()
+    {
+        //Call the 1D array returned by RC_Array_set01
+        return RC_Array_set01();
+    }
+    private static double[][] RC_Array_get02()
+    {
+        //Call the 2D array returned by RC_Array_set02
+        return RC_Array_set02();
+    }
+    private static double[][][] RC_Array_get03()
+    {
+        //Call the 3D array returned by RC_Array_set03
+        return RC_Array_set03();
+    }
+    private static double[] RC_Array_set01()
+    {
+        //return 1D array，Call the constructor of the 1D array parameter of RC_Array_set01, and assign a value to the
+        // field of the newly created object, and judge the result
+        double [] value1 = {9.2f,2.2f,8.8f,8.8f};
+        RC_Array_09 rctest=new RC_Array_09(value1);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new double[] {1.1f,2.2f,3.3f,4.4f};
+        if(rctest.base1.length == 4)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set01");
+        return rctest.base1;
+    }
+    private static double[][] RC_Array_set02()
+    {
+        //return 2D array，Call the constructor of the 2D array parameter of RC_Array_set02, and assign a
+        // value to the domain of the newly created object, and judge the result
+        double[][] value2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        RC_Array_09 rctest=new RC_Array_09(value2);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,null) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base2 = new double[][] {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        if(rctest.base2.length == 3)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set02");
+        return rctest.base2;
+    }
+    private static double[][][] RC_Array_set03()
+    {
+        //return 3D array，Call the constructor of the 3D array parameter of RC_Array_set03, and assign a value to the
+        // field of the newly created object, and judge the result
+        double[][][] value3 = {{{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}},{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}}};
+        RC_Array_09 rctest=new RC_Array_09(value3);
+        if(Arrays.equals(rctest.base1,null) && Arrays.equals(rctest.base2,null)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base3 = new double[][][]{{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}},{{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}}};
+        if(rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_set03");
+        return rctest.base3;
+    }
+    private static double[][] RC_Array_09_test01()
+    {
+        //return 2D array，Call the multi-parameter constructor of RC_Array_09, and assign a value to the newly created
+        // object field, and judge the result
+        double [] value1 = {1.1f,2.2f,3.3f,4.4f};
+        double[][] value2 = {{1.1f,2.2f,3.3f,4.4f},{1.3f,1.1f},{0.5f}};
+        double[][][] value3 = {value2,value2};
+        RC_Array_09 rctest=new RC_Array_09(value1,value2,value3);
+        if(Arrays.equals(rctest.base1,value1) && Arrays.equals(rctest.base2,value2)
+                && Arrays.equals(rctest.base3,value3) && Arrays.equals(rctest.base21,null))
+            check_count++;
+        rctest.base1 = new double[] {9.2f,2.2f,8.8f,8.8f};
+        rctest.base2 = new double[][] {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        rctest.base21 = new double[][] {{6,6,6,5},{1.3f,1.1f},{0.5f}};
+        rctest.base3 = new double[][][]{{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}},{{6,6,6,5},{1.3f,1.1f},{0.5f}}};
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_09_test01");
+        return rctest.base21;
+    }
+    private static double[] RC_Array_final01()
+    {
+        final double[] VALUE1 = {1.1f,2.2f,3.3f,4.4f};
+        return VALUE1;
+    }
+    private static double[][] RC_Array_final02()
+    {
+        final double[][] VALUE2 = {{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}};
+        return VALUE2;
+    }
+    private static double[][][] RC_Array_final03()
+    {
+        final double[][][] VALUE3 = {{{6.4f,6.1f,6.3f,5.5f},{1.3f,1.1f},{0.5f}},{{9.2f,2.2f,8.8f,8.8f},{1.3f,1.1f},{0.5f}}};
+        return VALUE3;
+    }
+    private static double[][] RC_Array_09_test02()
+    {
+        //The calling function returns a constant value as the assignment of the constant of this function.
+        //Call RC_Array_09() no argument construction method, initialize the variable of the parent class, and assign
+        // a value to the domain of the newly created object, and judge the result
+        final double[] VALUE1 = RC_Array_final01();
+        final double[][] VALUE2 = RC_Array_final02();
+        final double[][][] VALUE3 = RC_Array_final03();
+        RC_Array_09 rctest=new RC_Array_09();
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_09_test02");
+        rctest.base1 = VALUE1;
+        rctest.base2 = VALUE2;
+        rctest.base21 = VALUE2;
+        rctest.base3 = VALUE3;
+        if(rctest.base1.length == 4 && rctest.base2.length == 3 && rctest.base21.length == 3 && rctest.base3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in RC_Array_09_test02_2");
+        return VALUE2;
+    }
+    private static boolean RC_Array_Exception()
+    {
+        //Exception test，exclude NullPointerException，ArrayIndexOutOfBoundsException and so on
+        int check = 0;
+        double[] value1 = RC_Array_final01();
+        double[][] value2 = RC_Array_final02();
+        double[][][] value3 = RC_Array_final03();
+        //Is the value as expect after the assignment?
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——1");
+        //ArrayIndexOutOfBoundsException
+        try {
+            Array.getDouble(value1,5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            value1[5] = 10.16f;
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.setDouble(value1,5,12.5f);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value2[5],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value2[0],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value3[0][3],0);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value3[0][1],5);
+        }catch (ArrayIndexOutOfBoundsException e){
+            check++;
+        }
+        //IllegalArgumentException
+        try {
+            Array.getDouble(value2,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value3,1);
+        }catch (IllegalArgumentException e){
+            check++;
+        }
+        //ClassCastException
+        RC_Array_09 rc1 = new RC_Array_09();
+        try{
+            Base_009 bs1 = new Base_009();
+            rc1 = (RC_Array_09)bs1;
+            rc1.base1[0] = 8.9f;
+        }catch (ClassCastException e)
+        {
+            if (rc1.base1[0] != 8.9f)
+                check++;
+        }
+        //Whether the judgment value is normal after Exception
+        if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+            check++;
+        else
+            System.out.println("ErrorResult in RC_Array_Exception——2");
+        //NullPointerException
+        value1 = null;
+        value2 = null;
+        value3 = null;
+        try {
+            Array.getDouble(value1,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value2,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        try {
+            Array.getDouble(value3,1);
+        }catch (NullPointerException e){
+            check++;
+        }
+        //System.out.println(check);
+        if (check == 15)
+            return true;
+        else
+            return false;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/expected.txt b/testsuite/java_test/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/test.cfg b/testsuite/java_test/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1e6b235a4dbeacc03621e1858db97adb104582ba
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0374-rc-ArrayOptimization-RC_Array_09/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_09)
+run(RC_Array_09,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/RC_Array_10.java b/testsuite/java_test/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/RC_Array_10.java
new file mode 100755
index 0000000000000000000000000000000000000000..1485c414157a824413f02c9d50688c33f5bec11a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/RC_Array_10.java
@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Arrays;
+public class RC_Array_10 {
+    static int check_count = 0;
+    //Nine definitions:int、string、char、boolean、byte、short、long、float、double
+    static int[] intr1 = {10,20,30,40};
+    static int[][] intr2 = {{10,20,30,40},{40,50},{60}};
+    static int[][] intr21 = {{40,50,60,30},{70,80},{90}};
+    static int[][][] intr3 = {{{10,20,30,40},{40,50},{60}},{{40,50,60,30},{70,80},{90}}};
+    static String[] strr1 = {"hello","test","for","array"};
+    static String[][] strr2 = {{"hello","test","for","array"},{"2018","11"},{"26"}};
+    static String[][] strr21 = {{"huawei","test","for","array"},{"2018","11"},{"26"}};
+    static String[][][] strr3 = {{{"hello","test","for","array"},{"2018","11"},{"26"}},{{"huawei","test","for","array"},{"2018","11"},{"26"}}};
+    static char[] charr1 = {'a','b','c','d'};
+    static char[][] charr2 = {{'a','b','c','d'},{'e','f'},{'g'}};
+    static char[][] charr21 = {{'h','i','j','k'},{'l','m'},{'n'}};
+    static char[][][] charr3 = {{{'a','b','c','d'},{'e','f'},{'g'}},{{'h','i','j','k'},{'l','m'},{'n'}}};
+    static boolean[] boolr1 = {true,false,false,true};
+    static boolean[][] boolr2 = {{true,false,false,true},{false,false},{true}};
+    static boolean[][] boolr21 = {{false,true,false,true},{true,false},{false}};
+    static boolean[][][] boolr3 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{false}}};
+    static byte[] byter1 = {1,2,3,4};
+    static byte[][] byter2 = {{1,2,3,4},{5,6},{7}};
+    static byte[][] byter21 = {{4,5,6,7},{8,9},{10}};
+    static byte[][][] byter3 = {{{1,2,3,4},{5,6},{7}},{{4,5,6,7},{8,9},{10}}};
+    static short[] shortr1 = {1,2,3,4};
+    static short[][] shortr2 = {{1,2,3,4},{5,6},{7}};
+    static short[][] shortr21 = {{4,5,6,7},{8,9},{10}};
+    static short[][][] shortr3 = {{{1,2,3,4},{5,6},{7}},{{4,5,6,7},{8,9},{10}}};
+    static long[] longr1 = {1,2,3,4};
+    static long[][] longr2 = {{1,2,3,4},{5,6},{7}};
+    static long[][] longr21 = {{4,5,6,7},{8,9},{10}};
+    static long[][][] longr3 = {{{1,2,3,4},{5,6},{7}},{{4,5,6,7},{8,9},{10}}};
+    static float[] floatr1 = {1.1f,2.2f,3.3f,4.4f};
+    static float[][] floatr2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}};
+    static float[][] floatr21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}};
+    static float[][][] floatr3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}}};
+    static double[] doubler1 = {1.1f,2.2f,3.3f,4.4f};
+    static double[][] doubler2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}};
+    static double[][] doubler21 = {{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}};
+    static double[][][] doubler3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}}};
+    public static void main(String [] args) {
+        //Initialization check
+        check("initialization");
+        //Copy scene1：One, two, three-dimensional array type cyclic assignment
+        test01();
+        check("test01");
+        //Copy scene2：One, two, three-dimensional array type System.arraycopy () assignment
+        test02();
+        check("test02");
+        //Copy scene3：One, two, three-dimensional array type Arrays.copyOf() assignment
+        test03();
+        check("test03");
+        //Copy scene4：One, two, three-dimensional array type Arrays.copyOfRange() assignment
+        test04();
+        check("test04");
+        //Copy scene5：One, two, three-dimensional array type clone() assignment
+        test05();
+        check("test05");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 11)
+            System.out.println("ExpectResult");
+    }
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled*/
+        if(intr1.length == 4 && intr2.length == 3 && intr21.length == 3 && intr3.length == 2
+                && strr1.length == 4 && strr2.length == 3 && strr21.length == 3 && strr3.length == 2
+                && charr1.length == 4 && charr2.length == 3 && charr21.length == 3 && charr3.length == 2
+                && boolr1.length == 4 && boolr2.length == 3 && boolr21.length == 3 && boolr3.length == 2
+                && byter1.length == 4 && byter2.length == 3 && byter21.length == 3 && byter3.length == 2
+                && shortr1.length == 4 && shortr2.length == 3 && shortr21.length == 3 && shortr3.length == 2
+                && longr1.length == 4 && longr2.length == 3 && longr21.length == 3 && longr3.length == 2
+                && floatr1.length == 4 && floatr2.length == 3 && floatr21.length == 3 && floatr3.length == 2
+                && doubler1.length == 4 && doubler2.length == 3 && doubler21.length == 3 && doubler3.length == 2)
+            check_count++;
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+    private static void test01() {
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        int [] tmp_int1 = new int[4];
+        int [][] tmp_int2 = new int [3][4];
+        int [][][] tmp_int3 = new int [2][3][4];
+        String [] tmp_String1 = new String[4];
+        String [][] tmp_String2 = new String [3][4];
+        String [][][] tmp_String3 = new String [2][3][4];
+        char [] tmp_char1 = new char[4];
+        char [][] tmp_char2 = new char [3][4];
+        char [][][] tmp_char3 = new char [2][3][4];
+        boolean [] tmp_boolean1 = new boolean[4];
+        boolean [][] tmp_boolean2 = new boolean [3][4];
+        boolean [][][] tmp_boolean3 = new boolean [2][3][4];
+        byte [] tmp_byte1 = new byte[4];
+        byte [][] tmp_byte2 = new byte [3][4];
+        byte [][][] tmp_byte3 = new byte [2][3][4];
+        short [] tmp_short1 = new short[4];
+        short [][] tmp_short2 = new short [3][4];
+        short [][][] tmp_short3 = new short [2][3][4];
+        long [] tmp_long1 = new long[4];
+        long [][] tmp_long2 = new long [3][4];
+        long [][][] tmp_long3 = new long [2][3][4];
+        float [] tmp_float1 = new float[4];
+        float [][] tmp_float2 = new float [3][4];
+        float [][][] tmp_float3 = new float [2][3][4];
+        double [] tmp_double1 = new double[4];
+        double [][] tmp_double2 = new double [3][4];
+        double [][][] tmp_double3 = new double [2][3][4];
+        //1D array
+        for (int i = 0; i < intr1.length; i++) {
+            tmp_int1[i] = intr1[i];
+            tmp_String1[i] = strr1[i];
+            tmp_char1[i] = charr1[i];
+            tmp_boolean1[i] = boolr1[i];
+            tmp_byte1[i] = byter1[i];
+            tmp_short1[i] = shortr1[i];
+            tmp_long1[i] = longr1[i];
+            tmp_float1[i] = floatr1[i];
+            tmp_double1[i] = doubler1[i];
+        }
+        //2D array
+        for (int i = 0; i < intr2.length; i++)
+            for(int j = 0; j < intr2[i].length; j++)
+            {
+                tmp_int2[i][j] = intr2[i][j];
+                tmp_String2[i][j] = strr2[i][j];
+                tmp_char2[i][j] = charr2[i][j];
+                tmp_boolean2[i][j] = boolr2[i][j];
+                tmp_byte2[i][j] = byter2[i][j];
+                tmp_short2[i][j] = shortr2[i][j];
+                tmp_long2[i][j] = longr2[i][j];
+                tmp_float2[i][j] = floatr2[i][j];
+                tmp_double2[i][j] = doubler2[i][j];
+            }
+        //3D array
+        for (int i = 0; i < intr3.length; i++)
+            for(int j = 0; j < intr3[i].length; j++)
+                for(int k = 0; k < intr3[i][j].length; k++)
+                {
+                    tmp_int3[i][j][k] = intr3[i][j][k];
+                    tmp_String3[i][j][k] = strr3[i][j][k];
+                    tmp_char3[i][j][k] = charr3[i][j][k];
+                    tmp_boolean3[i][j][k] = boolr3[i][j][k];
+                    tmp_byte3[i][j][k] = byter3[i][j][k];
+                    tmp_short3[i][j][k] = shortr3[i][j][k];
+                    tmp_long3[i][j][k] = longr3[i][j][k];
+                    tmp_float3[i][j][k] = floatr3[i][j][k];
+                    tmp_double3[i][j][k] = doubler3[i][j][k];
+                }
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static void test02() {
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        int [] tmp_int1 = new int[4];
+        int [][] tmp_int2 = new int [3][4];
+        int [][][] tmp_int3 = new int [2][3][4];
+        String [] tmp_String1 = new String[4];
+        String [][] tmp_String2 = new String [3][4];
+        String [][][] tmp_String3 = new String [2][3][4];
+        char [] tmp_char1 = new char[4];
+        char [][] tmp_char2 = new char [3][4];
+        char [][][] tmp_char3 = new char [2][3][4];
+        boolean [] tmp_boolean1 = new boolean[4];
+        boolean [][] tmp_boolean2 = new boolean [3][4];
+        boolean [][][] tmp_boolean3 = new boolean [2][3][4];
+        byte [] tmp_byte1 = new byte[4];
+        byte [][] tmp_byte2 = new byte [3][4];
+        byte [][][] tmp_byte3 = new byte [2][3][4];
+        short [] tmp_short1 = new short[4];
+        short [][] tmp_short2 = new short [3][4];
+        short [][][] tmp_short3 = new short [2][3][4];
+        long [] tmp_long1 = new long[4];
+        long [][] tmp_long2 = new long [3][4];
+        long [][][] tmp_long3 = new long [2][3][4];
+        float [] tmp_float1 = new float[4];
+        float [][] tmp_float2 = new float [3][4];
+        float [][][] tmp_float3 = new float [2][3][4];
+        double [] tmp_double1 = new double[4];
+        double [][] tmp_double2 = new double [3][4];
+        double [][][] tmp_double3 = new double [2][3][4];
+        System.arraycopy(intr1,0,tmp_int1,0,intr1.length);
+        System.arraycopy(intr2,0,tmp_int2,0,intr2.length);
+        System.arraycopy(intr3,0,tmp_int3,0,intr3.length);
+        System.arraycopy(strr1,0,tmp_String1,0,strr1.length);
+        System.arraycopy(strr2,0,tmp_String2,0,strr2.length);
+        System.arraycopy(strr3,0,tmp_String3,0,strr3.length);
+        System.arraycopy(charr1,0,tmp_char1,0,charr1.length);
+        System.arraycopy(charr2,0,tmp_char2,0,charr2.length);
+        System.arraycopy(charr3,0,tmp_char3,0,charr3.length);
+        System.arraycopy(boolr1,0,tmp_boolean1,0,boolr1.length);
+        System.arraycopy(boolr2,0,tmp_boolean2,0,boolr2.length);
+        System.arraycopy(boolr3,0,tmp_boolean3,0,boolr3.length);
+        System.arraycopy(byter1,0,tmp_byte1,0,byter1.length);
+        System.arraycopy(byter2,0,tmp_byte2,0,byter2.length);
+        System.arraycopy(byter3,0,tmp_byte3,0,byter3.length);
+        System.arraycopy(shortr1,0,tmp_short1,0,shortr1.length);
+        System.arraycopy(shortr2,0,tmp_short2,0,shortr2.length);
+        System.arraycopy(shortr3,0,tmp_short3,0,shortr3.length);
+        System.arraycopy(longr1,0,tmp_long1,0,longr1.length);
+        System.arraycopy(longr2,0,tmp_long2,0,longr2.length);
+        System.arraycopy(longr3,0,tmp_long3,0,longr3.length);
+        System.arraycopy(floatr1,0,tmp_float1,0,floatr1.length);
+        System.arraycopy(floatr2,0,tmp_float2,0,floatr2.length);
+        System.arraycopy(floatr3,0,tmp_float3,0,floatr3.length);
+        System.arraycopy(doubler1,0,tmp_double1,0,doubler1.length);
+        System.arraycopy(doubler2,0,tmp_double2,0,doubler2.length);
+        System.arraycopy(doubler3,0,tmp_double3,0,doubler3.length);
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private static void test03()
+    {
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        int [] tmp_int1 = Arrays.copyOf(intr1,intr1.length);
+        int [][] tmp_int2 = Arrays.copyOf(intr2,intr2.length);
+        int [][][] tmp_int3 = Arrays.copyOf(intr3,intr3.length);
+        String [] tmp_String1 = Arrays.copyOf(strr1,strr1.length);
+        String [][] tmp_String2 = Arrays.copyOf(strr2,strr2.length);
+        String [][][] tmp_String3 = Arrays.copyOf(strr3,strr3.length);
+        char [] tmp_char1 = Arrays.copyOf(charr1,charr1.length);
+        char [][] tmp_char2 = Arrays.copyOf(charr2,charr2.length);
+        char [][][] tmp_char3 = Arrays.copyOf(charr3,charr3.length);
+        boolean [] tmp_boolean1 = Arrays.copyOf(boolr1,boolr1.length);
+        boolean [][] tmp_boolean2 = Arrays.copyOf(boolr2,boolr2.length);
+        boolean [][][] tmp_boolean3 = Arrays.copyOf(boolr3,boolr3.length);
+        byte [] tmp_byte1 = Arrays.copyOf(byter1,byter1.length);
+        byte [][] tmp_byte2 = Arrays.copyOf(byter2,byter2.length);
+        byte [][][] tmp_byte3 = Arrays.copyOf(byter3,byter3.length);
+        short [] tmp_short1 = Arrays.copyOf(shortr1,shortr1.length);
+        short [][] tmp_short2 = Arrays.copyOf(shortr2,shortr2.length);
+        short [][][] tmp_short3 = Arrays.copyOf(shortr3,shortr3.length);
+        long [] tmp_long1 = Arrays.copyOf(longr1,longr1.length);
+        long [][] tmp_long2 = Arrays.copyOf(longr2,longr2.length);
+        long [][][] tmp_long3 = Arrays.copyOf(longr3,longr3.length);
+        float [] tmp_float1 = Arrays.copyOf(floatr1,floatr1.length);
+        float [][] tmp_float2 = Arrays.copyOf(floatr2,floatr2.length);
+        float [][][] tmp_float3 = Arrays.copyOf(floatr3,floatr3.length);
+        double [] tmp_double1 = Arrays.copyOf(doubler1,doubler1.length);
+        double [][] tmp_double2 = Arrays.copyOf(doubler2,doubler2.length);
+        double [][][] tmp_double3 = Arrays.copyOf(doubler3,doubler3.length);
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+    }
+    private static void test04()
+    {
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        int [] tmp_int1 = Arrays.copyOfRange(intr1,0,intr1.length);
+        int [][] tmp_int2 = Arrays.copyOfRange(intr2,0,intr2.length);
+        int [][][] tmp_int3 = Arrays.copyOfRange(intr3,0,intr3.length);
+        String [] tmp_String1 = Arrays.copyOfRange(strr1,0,strr1.length);
+        String [][] tmp_String2 = Arrays.copyOfRange(strr2,0,strr2.length);
+        String [][][] tmp_String3 = Arrays.copyOfRange(strr3,0,strr3.length);
+        char [] tmp_char1 = Arrays.copyOfRange(charr1,0,charr1.length);
+        char [][] tmp_char2 = Arrays.copyOfRange(charr2,0,charr2.length);
+        char [][][] tmp_char3 = Arrays.copyOfRange(charr3,0,charr3.length);
+        boolean [] tmp_boolean1 = Arrays.copyOfRange(boolr1,0,boolr1.length);
+        boolean [][] tmp_boolean2 = Arrays.copyOfRange(boolr2,0,boolr2.length);
+        boolean [][][] tmp_boolean3 = Arrays.copyOfRange(boolr3,0,boolr3.length);
+        byte [] tmp_byte1 = Arrays.copyOfRange(byter1,0,byter1.length);
+        byte [][] tmp_byte2 = Arrays.copyOfRange(byter2,0,byter2.length);
+        byte [][][] tmp_byte3 = Arrays.copyOfRange(byter3,0,byter3.length);
+        short [] tmp_short1 = Arrays.copyOfRange(shortr1,0,shortr1.length);
+        short [][] tmp_short2 = Arrays.copyOfRange(shortr2,0,shortr2.length);
+        short [][][] tmp_short3 = Arrays.copyOfRange(shortr3,0,shortr3.length);
+        long [] tmp_long1 = Arrays.copyOfRange(longr1,0,longr1.length);
+        long [][] tmp_long2 = Arrays.copyOfRange(longr2,0,longr2.length);
+        long [][][] tmp_long3 = Arrays.copyOfRange(longr3,0,longr3.length);
+        float [] tmp_float1 = Arrays.copyOfRange(floatr1,0,floatr1.length);
+        float [][] tmp_float2 = Arrays.copyOfRange(floatr2,0,floatr2.length);
+        float [][][] tmp_float3 = Arrays.copyOfRange(floatr3,0,floatr3.length);
+        double [] tmp_double1 = Arrays.copyOfRange(doubler1,0,doubler1.length);
+        double [][] tmp_double2 = Arrays.copyOfRange(doubler2,0,doubler2.length);
+        double [][][] tmp_double3 = Arrays.copyOfRange(doubler3,0,doubler3.length);
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test04");
+    }
+    private static void test05()
+    {
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        int [] tmp_int1 = intr1.clone();
+        int [][] tmp_int2 = intr2.clone();
+        int [][][] tmp_int3 = intr3.clone();
+        String [] tmp_String1 = strr1.clone();
+        String [][] tmp_String2 = strr2.clone();
+        String [][][] tmp_String3 = strr3.clone();
+        char [] tmp_char1 = charr1.clone();
+        char [][] tmp_char2 = charr2.clone();
+        char [][][] tmp_char3 = charr3.clone();
+        boolean [] tmp_boolean1 = boolr1.clone();
+        boolean [][] tmp_boolean2 = boolr2.clone();
+        boolean [][][] tmp_boolean3 = boolr3.clone();
+        byte [] tmp_byte1 = byter1.clone();
+        byte [][] tmp_byte2 = byter2.clone();
+        byte [][][] tmp_byte3 = byter3.clone();
+        short [] tmp_short1 = shortr1.clone();
+        short [][] tmp_short2 = shortr2.clone();
+        short [][][] tmp_short3 = shortr3.clone();
+        long [] tmp_long1 = longr1.clone();
+        long [][] tmp_long2 = longr2.clone();
+        long [][][] tmp_long3 = longr3.clone();
+        float [] tmp_float1 = floatr1.clone();
+        float [][] tmp_float2 = floatr2.clone();
+        float [][][] tmp_float3 = floatr3.clone();
+        double [] tmp_double1 = doubler1.clone();
+        double [][] tmp_double2 = doubler2.clone();
+        double [][][] tmp_double3 = doubler3.clone();
+        //Compare the last value of the array correctly
+        if(tmp_int1[3] == 40 && tmp_int2[2][0] == 60 && tmp_int3[1][2][0] == 90
+                && tmp_String1[3] == "array" && tmp_String2[2][0] == "26" && tmp_String3[1][2][0]== "26"
+                && tmp_char1[3] == 'd' && tmp_char2[2][0]== 'g' && tmp_char3[1][2][0] == 'n'
+                && tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false
+                && tmp_byte1[3] == (byte)4 && tmp_byte2[2][0] == (byte)7 && tmp_byte3[1][2][0] == (byte)10
+                && tmp_short1[3] == (short)4 && tmp_short2[2][0] == (short)7 && tmp_short3[1][2][0] == (short)10
+                && tmp_long1[3] == (long)4 && tmp_long2[2][0] == (long)7 && tmp_long3[1][2][0] == (long)10
+                && tmp_float1[3] == 4.4f && tmp_float2[2][0] == 7.7f && tmp_float3[1][2][0] == 10.3f
+                && tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test05");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/expected.txt b/testsuite/java_test/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/test.cfg b/testsuite/java_test/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..429c8eaf81e4133aa04115717b50e4e604d6e3b7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0375-rc-ArrayOptimization-RC_Array_10/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_10)
+run(RC_Array_10,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/RC_Array_11.java b/testsuite/java_test/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/RC_Array_11.java
new file mode 100755
index 0000000000000000000000000000000000000000..d939f93e518fd1ddbf4770b655c11d583f7ce1f0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/RC_Array_11.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.io.PrintStream;
+public class RC_Array_11 {
+    static int check_count = 0;
+    Thread sb = new Thread();
+    String[] str_base1;
+    String[][] str_base2;
+    String[][][] str_base3;
+    static String[] strr1 = {"'h''e''l''l''o'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"};
+    static String[][] strr2 = {{"'h''e''l''l''o'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''6'"}};
+    static String[][][] strr3 = {{{"'h''e''l''l''o'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''6'"}},
+            {{"'h''u''a''w''e''i'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''6'"}}};
+    private static synchronized void intCheckCount() {
+        check_count++;
+    }
+    /*The calling function returns a constant value as the assignment of the constant of this function.*/
+    private String[] RC_Array_final01()
+    {
+        final String [] VALUE1 = {"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"};
+        return VALUE1;
+    }
+    private String[][] RC_Array_final02()
+    {
+        final String[][] VALUE2 = {{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"},{"'2''7'"}};
+        return VALUE2;
+    }
+    private String[][][] RC_Array_final03()
+    {
+        final String[][][] VALUE3 = {{{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"}, {"'2''7'"}},
+                {{"'h''u''a''w''e''i'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''7'"}}};
+        return VALUE3;
+    }
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled.*/
+        if(strr1.length == 4 && strr2.length == 3 && strr3.length == 2)
+            intCheckCount();
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+    public String  run(String argv[],PrintStream out) throws InterruptedException {
+        String result = "Error"; /*STATUS_FAILED*/
+        //Initialization check
+        check("initialization");
+        //Scene test
+        Thread t1 = new Thread(new test01());
+        Thread t2 = new Thread(new test02());
+        Thread t3 = new Thread(new test03());
+        Thread t4 = new Thread(new test04());
+        Thread t5 = new Thread(new test05());
+        Thread t6 = new Thread(new test06());
+        Thread t7 = new Thread(new test07());
+        Thread t8 = new Thread(new test08());
+        Thread t9 = new Thread(new test09());
+        //Copy scene multithreading
+        t1.start();t2.start();t3.start();t4.start();t5.start();
+        t1.join();t2.join();t3.join();t4.join();t5.join();
+        //Other scene
+        t6.start();t7.start();t8.start();
+        t6.join();t7.join();t8.join();
+        //Exception scene
+        t9.start();
+        t9.join();
+        check("End");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 14)
+            result = "ExpectResult";
+        return result;
+    }
+    public static void main(String argv[]) {
+        try {
+            System.out.println(new RC_Array_11().run(argv, System.out));
+        }catch (Exception e)
+        {
+            System.out.println(e);
+        }
+    }
+    private class test01 implements Runnable{
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        private void method01() {
+            String [] tmp_String1 = new String[4];
+            String [][] tmp_String2 = new String [3][4];
+            String [][][] tmp_String3 = new String [2][3][4];
+            //1D array
+            for (int i = 0; i < strr1.length; i++) {
+                tmp_String1[i] = strr1[i];
+            }
+            //2D array
+            for (int i = 0; i < strr2.length; i++)
+                for(int j = 0; j < strr2[i].length; j++)
+                {
+                    tmp_String2[i][j] = strr2[i][j];
+                }
+            //3D array
+            for (int i = 0; i < strr3.length; i++)
+                for(int j = 0; j < strr3[i].length; j++)
+                    for(int k = 0; k < strr3[i][j].length; k++)
+                    {
+                        tmp_String3[i][j][k] = strr3[i][j][k];
+                    }
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                    intCheckCount();
+            else
+                System.out.println("ErrorResult in test01");
+        }
+        public void run()
+        {
+            method01();
+        }
+    }
+    private class test02 implements Runnable{
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        private void method02() {
+            String [] tmp_String1 = new String[4];
+            String [][] tmp_String2 = new String [3][4];
+            String [][][] tmp_String3 = new String [2][3][4];
+            System.arraycopy(strr1,0,tmp_String1,0,strr1.length);
+            System.arraycopy(strr2,0,tmp_String2,0,strr2.length);
+            System.arraycopy(strr3,0,tmp_String3,0,strr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test02");
+        }
+        public void run()
+        {
+            method02();
+        }
+    }
+    private class test03 implements Runnable{
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        private void method03()
+        {
+            String [] tmp_String1 = Arrays.copyOf(strr1,strr1.length);
+            String [][] tmp_String2 = Arrays.copyOf(strr2,strr2.length);
+            String [][][] tmp_String3 = Arrays.copyOf(strr3,strr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test03");
+        }
+        public void run()
+        {
+            method03();
+        }
+    }
+    private class test04 implements Runnable{
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        private void method04()
+        {
+            String [] tmp_String1 = Arrays.copyOfRange(strr1,0,strr1.length);
+            String [][] tmp_String2 = Arrays.copyOfRange(strr2,0,strr2.length);
+            String [][][] tmp_String3 = Arrays.copyOfRange(strr3,0,strr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test04");
+        }
+        public void run()
+        {
+            method04();
+        }
+    }
+    private class test05 implements Runnable{
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        private void method05()
+        {
+            String [] tmp_String1 = strr1.clone();
+            String [][] tmp_String2 = strr2.clone();
+            String [][][] tmp_String3 = strr3.clone();
+            //Compare the last value of the array correctly
+            if(tmp_String1[3] == "'a''r''r''a''y'" && tmp_String2[2][0] == "'2''6'" && tmp_String3[1][2][0]== "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test05");
+        }
+        public void run()
+        {
+            method05();
+        }
+    }
+    private class test06 implements Runnable{
+        /*test06Interface call, internal initialization array, do not modify parameter values, only judge*/
+        private void method06(String[] arr_str1, String[][] arr_str2, String[][][] arr_str3)
+        {
+            String[] tmp_String1 = {"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"};
+            String[][] tmp_String2 = {{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"},{"'2''7'"}};
+            String[][][] tmp_String3 = {{{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"}, {"'2''7'"}},
+                    {{"'h''u''a''w''e''i'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''7'"}}};
+            //Check the values defined in the function
+            if(tmp_String1[3] == "'h''a''l''l''y'" && tmp_String2[2][0] == "'2''7'" && tmp_String3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step1");
+            //Check unmodified parameter values
+            if(arr_str1[3]== "'a''r''r''a''y'" && arr_str2[2][0] == "'2''6'" && arr_str3[1][2][0] == "'2''6'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step2");
+        }
+        public void run()
+        {
+            method06(strr1, strr2, strr3);
+        }
+    }
+    private class test07 implements Runnable{
+        /*test07 Interface call, call function change to modify the parameter value and judge*/
+        private Object change(Object temp1, Object temp2){
+            temp1 = temp2;
+            return temp1;
+        }
+        private void method07(String[] arr_str1, String[][] arr_str2, String[][][] arr_str3) {
+            String[] strr1 = {"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"};
+            String[][] strr2 = {{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"},{"'2''7'"}};
+            String[][][] strr3 = {{{"'h''h''l''l''o'","'t''e''s''t'","'f''o''r'","'h''a''l''l''y'"}, {"'2''0''1''8'","'1''1'"}, {"'2''7'"}},
+                    {{"'h''u''a''w''e''i'","'t''e''s''t'","'f''o''r'","'a''r''r''a''y'"},{"'2''0''1''8'","'1''1'"},{"'2''7'"}}};
+            arr_str1 = (String[]) change(arr_str1,strr1);
+            arr_str2 = (String[][])change(arr_str2,strr2);
+            arr_str3 = (String[][][]) change(arr_str3,strr3);
+            //Check the values defined in the function
+            if(strr1[3] == "'h''a''l''l''y'" && strr2[2][0] == "'2''7'" && strr3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step1");
+            //Check the modified parameter values
+            if(arr_str1[3]== "'h''a''l''l''y'" && arr_str2[2][0] == "'2''7'" && arr_str3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step2");
+        }
+        public void run()
+        {
+            method07(strr1,strr2,strr3);
+        }
+    }
+    private class test08 implements Runnable{
+        /*Call the no-argument constructor, initialize the variables of the parent class, and assign values to the
+        fields of the newly created object, and judge the result*/
+        private void method08() {
+            final String [] VALUE1 = RC_Array_final01();
+            final String[][] VALUE2 = RC_Array_final02();
+            final String[][][] VALUE3 = RC_Array_final03();
+            RC_Array_11 rctest = new RC_Array_11();
+            rctest.str_base1 = VALUE1;
+            rctest.str_base2 = VALUE2;
+            rctest.str_base3 = VALUE3;
+            //Check the values defined in the function
+            if(VALUE1[3] == "'h''a''l''l''y'" && VALUE2[2][0] == "'2''7'" && VALUE3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step1");
+            //Check the modified parameter values
+            if(rctest.str_base1[3]== "'h''a''l''l''y'" && rctest.str_base2[2][0] == "'2''7'" && rctest.str_base3[1][2][0] == "'2''7'")
+                intCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step2");
+        }
+        public void run()
+        {
+            method08();
+        }
+    }
+    private  class test09 implements Runnable{
+        /*Exception test*/
+        private synchronized void method09(){
+            int check = 0;
+            String [] value1 = RC_Array_final01();
+            String[][] value2 = RC_Array_final02();
+            String[][][] value3 = RC_Array_final03();
+            //Is the value judged after the assignment?
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+            //ArrayIndexOutOfBoundsException
+            try {
+                value1[5] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value2[5][0] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value3[3][3][0] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            //Whether the judgment value is normal after the abnormality
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+            //NullPointerException
+            value1 = null;
+            value2 = null;
+            value3 = null;
+            try {
+                Array.get(value1, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.get(value2, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.get(value3, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            //System.out.println(check);
+            if (check == 8)
+                intCheckCount();
+            else
+                System.out.println("End: ErrorResult in test09");
+        }
+        public void run()
+        {
+            method09();
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/expected.txt b/testsuite/java_test/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/test.cfg b/testsuite/java_test/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..55f3cba7ba8b7d76cc776c7dce53e517215178fb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0376-rc-ArrayOptimization-RC_Array_11/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_11)
+run(RC_Array_11,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/RC_Array_12.java b/testsuite/java_test/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/RC_Array_12.java
new file mode 100755
index 0000000000000000000000000000000000000000..df00386468d60f54a70aa9065f29b61b5a56c4d7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/RC_Array_12.java
@@ -0,0 +1,343 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.io.PrintStream;
+public class RC_Array_12 {
+    static int check_count = 0;
+    Thread sb = new Thread();
+    Object[] obj_base1;
+    Object[][] obj_base2;
+    Object[][][] obj_base3;
+    static Object[] objr1 = {'a','b','c','d'};
+    static Object[][] objr2 = {{'a','b','c','d'},{'e','f'},{'g'}};
+    static Object[][][] objr3 = {{{'a','b','c','d'},{'e','f'},{'g'}},{{'h','i','j','k'},{'l','m'},{'n'}}};
+    private static synchronized void incCheckCount() {
+      check_count++;
+    }
+    /*The calling function returns a constant value as the assignment of the constant of this function.*/
+    private Object[] RC_Array_final04()
+    {
+        final Object [] VALUE4 = {'b','s','d','g'};
+        return VALUE4;
+    }
+    private Object[][] RC_Array_final05()
+    {
+        final Object[][] VALUE5 = {{'b','s','d','g'},{'e','f'},{'s'}};
+        return VALUE5;
+    }
+    private Object[][][] RC_Array_final06()
+    {
+        final Object[][][] VALUE6 = {{{'b','s','d','g'},{'e','f'},{'s'}},{{'h','i','j','k'},{'l','m'},{'a'}}};
+        return VALUE6;
+    }
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled.*/
+        if(objr1.length == 4 && objr2.length == 3 && objr3.length == 2)
+            incCheckCount();
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+    public String  run(String argv[],PrintStream out) throws InterruptedException {
+        String result = "Error"; /*STATUS_FAILED*/
+        //Initialization check
+        check("initialization");
+        //Scene test
+        Thread t1 = new Thread(new test01());
+        Thread t2 = new Thread(new test02());
+        Thread t3 = new Thread(new test03());
+        Thread t4 = new Thread(new test04());
+        Thread t5 = new Thread(new test05());
+        Thread t6 = new Thread(new test06());
+        Thread t7 = new Thread(new test07());
+        Thread t8 = new Thread(new test08());
+        Thread t9 = new Thread(new test09());
+        //Copy scene multithreading
+        t1.start();t2.start();t3.start();t4.start();t5.start();
+        t1.join();t2.join();t3.join();t4.join();t5.join();
+        //Other scene
+        t6.start();t7.start();t8.start();
+        t6.join();t7.join();t8.join();
+        //Exception scene
+        t9.start();
+        t9.join();
+        check("End");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 14)
+            result = "ExpectResult";
+        return result;
+    }
+    public static void main(String argv[]) {
+        try {
+            System.out.println(new RC_Array_12().run(argv, System.out));
+        }catch (Exception e)
+        {
+            System.out.println(e);
+        }
+    }
+    private class test01 implements Runnable{
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        private void method01() {
+            Object [] tmp_obj1 = new Object[4];
+            Object [][] tmp_obj2 = new Object [3][4];
+            Object [][][] tmp_obj3 = new Object [2][3][4];
+            //1D array
+            for (int i = 0; i < objr1.length; i++) {
+                tmp_obj1[i] = objr1[i];
+            }
+            //2D array
+            for (int i = 0; i < objr2.length; i++)
+                for(int j = 0; j < objr2[i].length; j++)
+                {
+                    tmp_obj2[i][j] = objr2[i][j];
+                }
+            //3D array
+            for (int i = 0; i < objr3.length; i++)
+                for(int j = 0; j < objr3[i].length; j++)
+                    for(int k = 0; k < objr3[i][j].length; k++)
+                    {
+                        tmp_obj3[i][j][k] = objr3[i][j][k];
+                    }
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test01");
+        }
+        public void run()
+        {
+            method01();
+        }
+    }
+    private class test02 implements Runnable{
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        private void method02() {
+            Object [] tmp_obj1 = new Object[4];
+            Object [][] tmp_obj2 = new Object [3][4];
+            Object [][][] tmp_obj3 = new Object [2][3][4];
+            System.arraycopy(objr1,0,tmp_obj1,0,objr1.length);
+            System.arraycopy(objr2,0,tmp_obj2,0,objr2.length);
+            System.arraycopy(objr3,0,tmp_obj3,0,objr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test02");
+        }
+        public void run()
+        {
+            method02();
+        }
+    }
+    private class test03 implements Runnable{
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        private void method03()
+        {
+            Object [] tmp_obj1 = Arrays.copyOf(objr1,objr1.length);
+            Object [][] tmp_obj2 = Arrays.copyOf(objr2,objr2.length);
+            Object [][][] tmp_obj3 = Arrays.copyOf(objr3,objr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test03");
+        }
+        public void run()
+        {
+            method03();
+        }
+    }
+    private class test04 implements Runnable{
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        private void method04()
+        {
+            Object [] tmp_obj1 = Arrays.copyOfRange(objr1,0,objr1.length);
+            Object [][] tmp_obj2 = Arrays.copyOfRange(objr2,0,objr2.length);
+            Object [][][] tmp_obj3 = Arrays.copyOfRange(objr3,0,objr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test04");
+        }
+        public void run()
+        {
+            method04();
+        }
+    }
+    private class test05 implements Runnable{
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        private void method05()
+        {
+            Object [] tmp_obj1 = objr1.clone();
+            Object [][] tmp_obj2 = objr2.clone();
+            Object [][][] tmp_obj3 = objr3.clone();
+            //Compare the last value of the array correctly
+            if(tmp_obj1[3] == (Object)'d' && tmp_obj2[2][0] == (Object)'g' && tmp_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test05");
+        }
+        public void run()
+        {
+            method05();
+        }
+    }
+    private class test06 implements Runnable{
+        /*test06Interface call, internal initialization array, do not modify parameter values, only judge*/
+        private void method06(Object[] arr_obj1, Object[][] arr_obj2, Object[][][] arr_obj3)
+        {
+            Object[] tmp_obj1 = {'b','s','d','g'};
+            Object[][] tmp_obj2 = {{'b','s','d','g'},{'e','f'},{'s'}};
+            Object[][][] tmp_obj3 = {{{'b','s','d','g'},{'e','f'},{'s'}},{{'h','i','j','k'},{'l','m'},{'a'}}};
+            //Check the values defined in the function
+            if(tmp_obj1[3] == (Object)'g' && tmp_obj2[2][0] == (Object)'s' && tmp_obj3[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step1");
+            //Check unmodified parameter values
+            if(arr_obj1[3] == (Object)'d' && arr_obj2[2][0] == (Object)'g'  && arr_obj3[1][2][0] == (Object)'n')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step2");
+        }
+        public void run()
+        {
+            method06(objr1,objr2,objr3);
+        }
+    }
+    private class test07 implements Runnable{
+        /*test07 Interface call, call function change to modify the parameter value and judge*/
+        private Object change(Object temp1, Object temp2){
+            temp1 = temp2;
+            return temp1;
+        }
+        private void method07(Object[] arr_obj1, Object[][] arr_obj2, Object[][][] arr_obj3) {
+            Object[] objr1 = {'b','s','d','g'};
+            Object[][] objr2 = {{'b','s','d','g'},{'e','f'},{'s'}};
+            Object[][][] objr3 = {{{'b','s','d','g'},{'e','f'},{'s'}},{{'h','i','j','k'},{'l','m'},{'a'}}};
+            arr_obj1 = (Object[]) change(arr_obj1,objr1);
+            arr_obj2 = (Object[][])change(arr_obj2,objr2);
+            arr_obj3 = (Object[][][]) change(arr_obj3,objr3);
+            //Check the values defined in the function
+            if(objr1[3] == (Object)'g' && objr2[2][0] == (Object)'s' && objr3[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step1");
+            //Check the modified parameter values
+            if(arr_obj1[3] == (Object)'g' && arr_obj2[2][0] == (Object)'s'  && arr_obj3[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step2");
+        }
+        public void run()
+        {
+            method07(objr1,objr2,objr3);
+        }
+    }
+    private class test08 implements Runnable{
+        /*Call the no-argument constructor, initialize the variables of the parent class, and assign values to the
+        fields of the newly created object, and judge the result*/
+        private void method08() {
+            final Object [] VALUE4 = RC_Array_final04();
+            final Object[][] VALUE5 = RC_Array_final05();
+            final Object[][][] VALUE6 = RC_Array_final06();
+            RC_Array_12 rctest = new RC_Array_12();
+            rctest.obj_base1 = VALUE4;
+            rctest.obj_base2 = VALUE5;
+            rctest.obj_base3 = VALUE6;
+            //Check the values defined in the function
+            if(VALUE4[3] == (Object)'g' && VALUE5[2][0] == (Object)'s' && VALUE6[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step1");
+            //Check the modified parameter values
+            if(rctest.obj_base1[3] == (Object)'g' && rctest.obj_base2[2][0] == (Object)'s'  && rctest.obj_base3[1][2][0] == (Object)'a')
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step2");
+        }
+        public void run()
+        {
+            method08();
+        }
+    }
+    private class test09 implements Runnable{
+        /*Exception test*/
+        private void method09(){
+            int check = 0;
+            Object [] value1 = RC_Array_final04();
+            Object[][] value2 = RC_Array_final05();
+            Object[][][] value3 = RC_Array_final06();
+            //Is the value judged after the assignment?
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+            //ArrayIndexOutOfBoundsException
+            try {
+                value1[5] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value2[5][0] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value3[3][3][0] = "error";
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            //Whether the judgment value is normal after the abnormality
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+            //NullPointerException
+            value1 = null;
+            value2 = null;
+            value3 = null;
+            try {
+                Array.get(value1, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.get(value2, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.get(value3, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            //System.out.println(check);
+            if (check == 8)
+                incCheckCount();
+            else
+                System.out.println("End: ErrorResult in test09");
+        }
+        public void run()
+        {
+            method09();
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/expected.txt b/testsuite/java_test/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/test.cfg b/testsuite/java_test/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4a27235ee62362a431e35ee07d37c3e40b0de007
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0377-rc-ArrayOptimization-RC_Array_12/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_12)
+run(RC_Array_12,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/RC_Array_13.java b/testsuite/java_test/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/RC_Array_13.java
new file mode 100755
index 0000000000000000000000000000000000000000..7bb3c35fb85edcc33ca53092dd627496d3f6356a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/RC_Array_13.java
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.io.PrintStream;
+public class RC_Array_13 {
+    static int check_count = 0;
+    Thread sb = new Thread();
+    boolean[] bool_base1;
+    boolean[][] bool_base2;
+    boolean[][][] bool_base3;
+    static boolean[] boolr1 = {true,false,false,true};
+    static boolean[][] boolr2 = {{true,false,false,true},{false,false},{true}};
+    static boolean[][][] boolr3 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{false}}};
+    private static synchronized void incCheckCount() {
+      check_count++;
+    }
+    /*The calling function returns a constant value as the assignment of the constant of this function.*/
+    private boolean[] RC_Array_final07()
+    {
+        final boolean [] VALUE7 = {true,false,false,false};
+        return VALUE7;
+    }
+    private boolean[][] RC_Array_final08()
+    {
+        final boolean[][] VALUE8 = {{true,false,false,true},{false,false},{false}};
+        return VALUE8;
+    }
+    private boolean[][][] RC_Array_final09()
+    {
+        final boolean[][][] VALUE9 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{true}}};
+        return VALUE9;
+    }
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled.*/
+        if(boolr1.length == 4 && boolr2.length == 3 && boolr3.length == 2)
+            incCheckCount();
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+    public String  run(String argv[],PrintStream out) throws InterruptedException {
+        String result = "Error"; /*STATUS_FAILED*/
+        //Initialization check
+        check("initialization");
+        //Scene test
+        Thread t1 = new Thread(new test01());
+        Thread t2 = new Thread(new test02());
+        Thread t3 = new Thread(new test03());
+        Thread t4 = new Thread(new test04());
+        Thread t5 = new Thread(new test05());
+        Thread t6 = new Thread(new test06());
+        Thread t7 = new Thread(new test07());
+        Thread t8 = new Thread(new test08());
+        Thread t9 = new Thread(new test09());
+        //Copy scene multithreading
+        t1.start();t2.start();t3.start();t4.start();t5.start();
+        t1.join();t2.join();t3.join();t4.join();t5.join();
+        //Other scene
+        t6.start();t7.start();t8.start();
+        t6.join();t7.join();t8.join();
+        //Exception scene
+        t9.start();
+        t9.join();
+        check("End");
+        //Result judgment
+        if(check_count == 14)
+            result = "ExpectResult";
+        return result;
+    }
+    public static void main(String argv[]) {
+        try {
+            System.out.println(new RC_Array_13().run(argv, System.out));
+        }catch (Exception e)
+        {
+            System.out.println(e);
+        }
+    }
+    private class test01 implements Runnable{
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        private void method01() {
+            boolean [] tmp_boolean1 = new boolean[4];
+            boolean [][] tmp_boolean2 = new boolean [3][4];
+            boolean [][][] tmp_boolean3 = new boolean [2][3][4];
+            //1D array
+            for (int i = 0; i < boolr1.length; i++) {
+                tmp_boolean1[i] = boolr1[i];
+            }
+            //2D array
+            for (int i = 0; i < boolr2.length; i++)
+                for(int j = 0; j < boolr2[i].length; j++)
+                {
+                    tmp_boolean2[i][j] = boolr2[i][j];
+                }
+            //3D array
+            for (int i = 0; i < boolr3.length; i++)
+                for(int j = 0; j < boolr3[i].length; j++)
+                    for(int k = 0; k < boolr3[i][j].length; k++)
+                    {
+                        tmp_boolean3[i][j][k] = boolr3[i][j][k];
+                    }
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false) {
+                    incCheckCount();
+            }
+            else
+                System.out.println("ErrorResult in test01");
+        }
+        public void run()
+        {
+            method01();
+        }
+    }
+    private class test02 implements Runnable{
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        private void method02() {
+            boolean [] tmp_boolean1 = new boolean[4];
+            boolean [][] tmp_boolean2 = new boolean [3][4];
+            boolean [][][] tmp_boolean3 = new boolean [2][3][4];
+            System.arraycopy(boolr1,0,tmp_boolean1,0,boolr1.length);
+            System.arraycopy(boolr2,0,tmp_boolean2,0,boolr2.length);
+            System.arraycopy(boolr3,0,tmp_boolean3,0,boolr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test02");
+        }
+        public void run()
+        {
+            method02();
+        }
+    }
+    private class test03 implements Runnable{
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        private void method03()
+        {
+            boolean [] tmp_boolean1 = Arrays.copyOf(boolr1,boolr1.length);
+            boolean [][] tmp_boolean2 = Arrays.copyOf(boolr2,boolr2.length);
+            boolean [][][] tmp_boolean3 = Arrays.copyOf(boolr3,boolr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test03");
+        }
+        public void run()
+        {
+            method03();
+        }
+    }
+    private class test04 implements Runnable{
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        private void method04()
+        {
+            boolean [] tmp_boolean1 = Arrays.copyOfRange(boolr1,0,boolr1.length);
+            boolean [][] tmp_boolean2 = Arrays.copyOfRange(boolr2,0,boolr2.length);
+            boolean [][][] tmp_boolean3 = Arrays.copyOfRange(boolr3,0,boolr3.length);
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test04");
+        }
+        public void run()
+        {
+            method04();
+        }
+    }
+    private class test05 implements Runnable{
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        private void method05()
+        {
+            boolean [] tmp_boolean1 = boolr1.clone();
+            boolean [][] tmp_boolean2 = boolr2.clone();
+            boolean [][][] tmp_boolean3 = boolr3.clone();
+            //Compare the last value of the array correctly
+            if(tmp_boolean1[3] == true && tmp_boolean2[2][0] == true && tmp_boolean3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test05");
+        }
+        public void run()
+        {
+            method05();
+        }
+    }
+    private class test06 implements Runnable{
+        /*test06Interface call, internal initialization array, do not modify parameter values, only judge*/
+        private void method06(boolean[] arr_bool1, boolean[][] arr_bool2, boolean[][][] arr_bool3)
+        {
+            boolean[] tmp_boolean1 = {true,false,false,false};
+            boolean[][] tmp_boolean2 = {{true,false,false,true},{false,false},{false}};
+            boolean[][][] tmp_boolean3 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{true}}};
+            //Check the values defined in the function
+            if(tmp_boolean1[3] == false && tmp_boolean2[2][0] == false && tmp_boolean3[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step1");
+            //Check unmodified parameter values
+            if(arr_bool1[3] == true && arr_bool2[2][0] == true && arr_bool3[1][2][0] == false)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step2");
+        }
+        public void run()
+        {
+            method06(boolr1, boolr2, boolr3);
+        }
+    }
+    private class test07 implements Runnable{
+        /*test07 Interface call, call function change to modify the parameter value and judge*/
+        private Object change(Object temp1, Object temp2){
+            temp1 = temp2;
+            return temp1;
+        }
+        private void method07(boolean[] arr_bool1, boolean[][] arr_bool2,boolean[][][] arr_bool3) {
+            boolean[] boolr1 = {true,false,false,false};
+            boolean[][] boolr2 = {{true,false,false,true},{false,false},{false}};
+            boolean[][][] boolr3 = {{{true,false,false,true},{false,false},{true}},{{false,true,false,true},{true,false},{true}}};
+            arr_bool1 = (boolean[]) change(arr_bool1,boolr1);
+            arr_bool2 = (boolean[][])change(arr_bool2,boolr2);
+            arr_bool3 = (boolean[][][]) change(arr_bool3,boolr3);
+            //Check the values defined in the function
+            if(boolr1[3] == false && boolr2[2][0] == false && boolr3[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step1");
+            //Check the modified parameter values
+            if(arr_bool1[3] == false && arr_bool2[2][0] == false && arr_bool3[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step2");
+        }
+        public void run()
+        {
+            method07(boolr1,boolr2,boolr3);
+        }
+    }
+    private class test08 implements Runnable{
+        /*Call the no-argument constructor, initialize the variables of the parent class, and assign values to the
+        fields of the newly created object, and judge the result*/
+        private void method08() {
+            final boolean [] VALUE7 = RC_Array_final07();
+            final boolean[][] VALUE8 = RC_Array_final08();
+            final boolean[][][] VALUE9 = RC_Array_final09();
+            RC_Array_13 rctest = new RC_Array_13();
+            rctest.bool_base1 = VALUE7;
+            rctest.bool_base2 = VALUE8;
+            rctest.bool_base3 = VALUE9;
+            //Check the values defined in the function
+            if(VALUE7[3] == false && VALUE8[2][0] == false && VALUE9[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step1");
+            //Check the modified parameter values
+            if(rctest.bool_base1[3] == false && rctest.bool_base2[2][0] == false && rctest.bool_base3[1][2][0] == true)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step2");
+        }
+        public void run()
+        {
+            method08();
+        }
+    }
+    private  class test09 implements Runnable{
+        /*Exception test*/
+        private synchronized void method09(){
+            int check = 0;
+            boolean [] value1 = RC_Array_final07();
+            boolean[][] value2 = RC_Array_final08();
+            boolean[][][] value3 = RC_Array_final09();
+            //Is the value judged after the assignment?
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+            //ArrayIndexOutOfBoundsException
+            try {
+                value1[5] = true;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value2[5][0] = true;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value3[3][3][0] = true;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            //IllegalArgumentException
+            try {
+                Array.getBoolean(value2,1);
+            }catch (IllegalArgumentException e){
+                check++;
+            }
+            try {
+                Array.getBoolean(value3,1);
+            }catch (IllegalArgumentException e){
+                check++;
+            }
+            //Whether the judgment value is normal after the abnormality
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+            //NullPointerException
+            value1 = null;
+            value2 = null;
+            value3 = null;
+            try {
+                Array.getBoolean(value1, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.getBoolean(value2, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.getBoolean(value3, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            //System.out.println(check);
+            if (check == 10)
+                incCheckCount();
+            else
+                System.out.println("End: ErrorResult in test09");
+        }
+        public void run()
+        {
+            method09();
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/expected.txt b/testsuite/java_test/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/test.cfg b/testsuite/java_test/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3487679c14d15542e2cee8dccd0138c5dd977121
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0378-rc-ArrayOptimization-RC_Array_13/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_13)
+run(RC_Array_13,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/RC_Array_14.java b/testsuite/java_test/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/RC_Array_14.java
new file mode 100755
index 0000000000000000000000000000000000000000..ac91e776bb0a7d8e5b517204cbd1c641e70803db
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/RC_Array_14.java
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.io.PrintStream;
+public class RC_Array_14 {
+    static int check_count = 0;
+    Thread sb = new Thread();
+    double[] double_base1;
+    double[][] double_base2;
+    double[][][] double_base3;
+    static double[] doubler1 = {1.1f,2.2f,3.3f,4.4f};
+    static double[][] doubler2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}};
+    static double[][][] doubler3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.3f}}};
+    private static synchronized void incCheckCount() {
+      check_count++;
+    }
+    /*The calling function returns a constant value as the assignment of the constant of this function.*/
+    private double[] RC_Array_final10()
+    {
+        final double [] VALUE7 = {1.1f,2.2f,3.3f,4.8f};
+        return VALUE7;
+    }
+    private double[][] RC_Array_final11()
+    {
+        final double[][] VALUE8 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{2.7f}};
+        return VALUE8;
+    }
+    private double[][][] RC_Array_final12()
+    {
+        final double[][][] VALUE9 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.9f}}};
+        return VALUE9;
+    }
+    private static void check(String test_method)
+    {
+        /*Public function: Check if the length of the assignment source array is as expected to determine whether the resource is recycled.*/
+        if(doubler1.length == 4 && doubler2.length == 3 && doubler3.length == 2)
+            incCheckCount();
+        else
+            System.out.println("ErrorResult in check: " + test_method);
+    }
+    public String  run(String argv[],PrintStream out) throws InterruptedException {
+        String result = "Error"; /*STATUS_FAILED*/
+        //Initialization check
+        check("initialization");
+        //Scene test
+        Thread t1 = new Thread(new test01());
+        Thread t2 = new Thread(new test02());
+        Thread t3 = new Thread(new test03());
+        Thread t4 = new Thread(new test04());
+        Thread t5 = new Thread(new test05());
+        Thread t6 = new Thread(new test06());
+        Thread t7 = new Thread(new test07());
+        Thread t8 = new Thread(new test08());
+        Thread t9 = new Thread(new test09());
+        //Copy scene multithreading
+        t1.start();t2.start();t3.start();t4.start();t5.start();
+        t1.join();t2.join();t3.join();t4.join();t5.join();
+        //Other scene
+        t6.start();t7.start();t8.start();
+        t6.join();t7.join();t8.join();
+        //Exception scene
+        t9.start();
+        t9.join();
+        check("End");
+        //Result judgment
+        //System.out.println(check_count);
+        if(check_count == 14)
+            result = "ExpectResult";
+        return result;
+    }
+    public static void main(String argv[]) {
+        try {
+            System.out.println(new RC_Array_14().run(argv, System.out));
+        }catch (Exception e)
+        {
+            System.out.println(e);
+        }
+    }
+    private class test01 implements Runnable{
+        /*test01:One, two, three-dimensional array type cyclic assignment*/
+        private void method01() {
+            double [] tmp_double1 = new double[4];
+            double [][] tmp_double2 = new double [3][4];
+            double [][][] tmp_double3 = new double [2][3][4];
+            //1D array
+            for (int i = 0; i < doubler1.length; i++) {
+                tmp_double1[i] = doubler1[i];
+            }
+            //2D array
+            for (int i = 0; i < doubler2.length; i++)
+                for(int j = 0; j < doubler2[i].length; j++)
+                {
+                    tmp_double2[i][j] = doubler2[i][j];
+                }
+            //3D array
+            for (int i = 0; i < doubler3.length; i++)
+                for(int j = 0; j < doubler3[i].length; j++)
+                    for(int k = 0; k < doubler3[i][j].length; k++)
+                    {
+                        tmp_double3[i][j][k] = doubler3[i][j][k];
+                    }
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                    incCheckCount();
+            else
+                System.out.println("ErrorResult in test01");
+        }
+        public void run()
+        {
+            method01();
+        }
+    }
+    private class test02 implements Runnable{
+        /*test02:One, two, three-dimensional array type System.arraycopy () assignment*/
+        private void method02() {
+            double [] tmp_double1 = new double[4];
+            double [][] tmp_double2 = new double [3][4];
+            double [][][] tmp_double3 = new double [2][3][4];
+            System.arraycopy(doubler1,0,tmp_double1,0,doubler1.length);
+            System.arraycopy(doubler2,0,tmp_double2,0,doubler2.length);
+            System.arraycopy(doubler3,0,tmp_double3,0,doubler3.length);
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test02");
+        }
+        public void run()
+        {
+            method02();
+        }
+    }
+    private class test03 implements Runnable{
+        /*test03:One, two, three-dimensional array type Arrays.copyOf() assignment*/
+        private void method03()
+        {
+            double [] tmp_double1 = Arrays.copyOf(doubler1,doubler1.length);
+            double [][] tmp_double2 = Arrays.copyOf(doubler2,doubler2.length);
+            double [][][] tmp_double3 = Arrays.copyOf(doubler3,doubler3.length);
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test03");
+        }
+        public void run()
+        {
+            method03();
+        }
+    }
+    private class test04 implements Runnable{
+        /*test04:One, two, three-dimensional array type Arrays.copyOfRange() assignment*/
+        private void method04()
+        {
+            double [] tmp_double1 = Arrays.copyOfRange(doubler1,0,doubler1.length);
+            double [][] tmp_double2 = Arrays.copyOfRange(doubler2,0,doubler2.length);
+            double [][][] tmp_double3 = Arrays.copyOfRange(doubler3,0,doubler3.length);
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test04");
+        }
+        public void run()
+        {
+            method04();
+        }
+    }
+    private class test05 implements Runnable{
+        /*test05:One, two, three-dimensional array type clone() assignment*/
+        private void method05()
+        {
+            double [] tmp_double1 = doubler1.clone();
+            double [][] tmp_double2 = doubler2.clone();
+            double [][][] tmp_double3 = doubler3.clone();
+            //Compare the last value of the array correctly
+            if(tmp_double1[3] == (double) 4.4f && tmp_double2[2][0] == (double)7.7f && tmp_double3[1][2][0] == (double)10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test05");
+        }
+        public void run()
+        {
+            method05();
+        }
+    }
+    private class test06 implements Runnable{
+        /*test06Interface call, internal initialization array, do not modify parameter values, only judge*/
+        private void method06(double[] arr_dou1, double[][] arr_dou2, double[][][] arr_dou3)
+        {
+            double[] tmp_double1 = {1.1f,2.2f,3.3f,4.8f};
+            double[][] tmp_double2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{2.7f}};
+            double[][][] tmp_double3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.9f}}};
+            //Check the values defined in the function
+            if(tmp_double1[3] == 4.8f && tmp_double2[2][0] == 2.7f && tmp_double3[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step1");
+            //Check unmodified parameter values
+            if(arr_dou1[3] == 4.4f && arr_dou2[2][0] == 7.7f && arr_dou3[1][2][0] == 10.3f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test06 step2");
+        }
+        public void run()
+        {
+            method06(doubler1, doubler2, doubler3);
+        }
+    }
+    private class test07 implements Runnable{
+        /*test07 Interface call, call function change to modify the parameter value and judge*/
+        private Object change(Object temp1, Object temp2){
+            temp1 = temp2;
+            return temp1;
+        }
+        private void method07(double[] arr_dou1, double[][] arr_dou2, double[][][] arr_dou3) {
+            double[] doubler1 = {1.1f,2.2f,3.3f,4.8f};
+            double[][] doubler2 = {{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{2.7f}};
+            double[][][] doubler3 = {{{1.1f,2.2f,3.3f,4.4f},{5.5f,6.6f},{7.7f}},{{4.1f,5.1f,6.1f,7.1f},{8.1f,9.1f},{10.9f}}};
+            arr_dou1 = (double[]) change(arr_dou1,doubler1);
+            arr_dou2 = (double[][])change(arr_dou2,doubler2);
+            arr_dou3 = (double[][][]) change(arr_dou3,doubler3);
+            //Check the values defined in the function
+            if(doubler1[3] == 4.8f && doubler2[2][0] == 2.7f && doubler3[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step1");
+            //Check the modified parameter values
+            if(arr_dou1[3] == 4.8f && arr_dou2[2][0] == 2.7f && arr_dou3[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test07 step2");
+        }
+        public void run()
+        {
+            method07(doubler1,doubler2,doubler3);
+        }
+    }
+    private class test08 implements Runnable{
+        /*Call the no-argument constructor, initialize the variables of the parent class, and assign values to the
+        fields of the newly created object, and judge the result*/
+        private void method08() {
+            final double [] VALUE10 = RC_Array_final10();
+            final double[][] VALUE11 = RC_Array_final11();
+            final double[][][] VALUE12 = RC_Array_final12();
+            RC_Array_14 rctest = new RC_Array_14();
+            rctest.double_base1 = VALUE10;
+            rctest.double_base2 = VALUE11;
+            rctest.double_base3 = VALUE12;
+            //Check the values defined in the function
+            if(VALUE10[3] == 4.8f && VALUE11[2][0] == 2.7f && VALUE12[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step1");
+            //Check the modified parameter values
+            if(rctest.double_base1[3] == 4.8f && rctest.double_base2[2][0] == 2.7f && rctest.double_base3[1][2][0] == 10.9f)
+                incCheckCount();
+            else
+                System.out.println("ErrorResult in test08 step2");
+        }
+        public void run()
+        {
+            method08();
+        }
+    }
+    private  class test09 implements Runnable{
+        /*Exception test*/
+        private synchronized void method09(){
+            int check = 0;
+            double [] value1 = RC_Array_final10();
+            double[][] value2 = RC_Array_final11();
+            double[][][] value3 = RC_Array_final12();
+            //Is the value judged after the assignment?
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+            //ArrayIndexOutOfBoundsException
+            try {
+                value1[5] = 4.8f;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value2[5][0] = 4.8f;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            try {
+                value3[3][3][0] = 4.8f;
+            }catch (ArrayIndexOutOfBoundsException e){
+                check++;
+            }
+            //IllegalArgumentException
+            try {
+                Array.getDouble(value2,1);
+            }catch (IllegalArgumentException e){
+                check++;
+            }
+            try {
+                Array.getDouble(value3,1);
+            }catch (IllegalArgumentException e){
+                check++;
+            }
+            //Whether the judgment value is normal after the abnormality
+            if(value1.length == 4 && value2.length == 3  && value3.length == 2)
+                check++;
+            else
+                System.out.println("ErrorResult in test09——2");
+            //NullPointerException
+            value1 = null;
+            value2 = null;
+            value3 = null;
+            try {
+                Array.getDouble(value1, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.getDouble(value2, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            try {
+                Array.getDouble(value3, 1);
+            } catch (NullPointerException e) {
+                check++;
+            }
+            //System.out.println(check);
+            if (check == 10)
+                incCheckCount();
+            else
+                System.out.println("End: ErrorResult in test09");
+        }
+        public void run()
+        {
+            method09();
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/expected.txt b/testsuite/java_test/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/test.cfg b/testsuite/java_test/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a712e6dad4da48ce507bb4517ce5c059fe5e1f27
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0379-rc-ArrayOptimization-RC_Array_14/test.cfg
@@ -0,0 +1,2 @@
+compile(RC_Array_14)
+run(RC_Array_14,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest/RCWeakRefTest.java b/testsuite/java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest/RCWeakRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..909dec00de29d76e831e2862ea81c51623b769f5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest/RCWeakRefTest.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Weak;
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+class Test_A {
+    @Weak
+    Test_B bb;
+    Test_B bb2;
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");
+        }
+        bb2.run();
+    }
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+    }
+}
+public class RCWeakRefTest {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest/test.cfg b/testsuite/java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8fb1ac63724c8dd260f6b434b6a42f4fd5b80f3e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0380-rc-Annotation-RCWeakRefTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCWeakRefTest)
+run(RCWeakRefTest,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2/RCWeakRefTest2.java b/testsuite/java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2/RCWeakRefTest2.java
new file mode 100755
index 0000000000000000000000000000000000000000..668962f0564526de3fa022b780e687cfe13c7c70
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2/RCWeakRefTest2.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Field;
+import com.huawei.ark.annotation.Weak;
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+class Test_A {
+    @Weak
+    Test_B bb;
+    @Weak
+    volatile Test_B bv;
+    public void test() {
+        foo();
+        new Thread(new TriggerRef()).start();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");  //expect to be null
+        }
+        try {
+            bv.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");  //expect to be null
+        }
+    }
+    private void foo() {
+        //bb = new Test_B();
+        try {
+            Field m = Test_A.class.getDeclaredField("bb");
+            Test_B b1 = new Test_B();
+            m.set(this, b1);
+            Field m1 = Test_A.class.getDeclaredField("bv");
+            m1.set(this, b1);
+            Test_B temp1 = (Test_B) m.get(this);
+            if (temp1 != b1) {
+                System.out.println("error 1");
+            }
+            Test_B temp2 = (Test_B) m1.get(this);
+            if (temp2 != b1) {
+                System.out.println("error 1");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+    class TriggerRef implements Runnable {
+        public void run() {
+            for (int i = 0; i < 100; i++) {
+                WeakReference ref = new WeakReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+public class RCWeakRefTest2 {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2/test.cfg b/testsuite/java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dbab5cbdc86dcee4f03c99e665a89a504badf23e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0381-rc-Annotation-RCWeakRefTest2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCWeakRefTest2)
+run(RCWeakRefTest2,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4/RCWeakRefTest4.java b/testsuite/java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4/RCWeakRefTest4.java
new file mode 100755
index 0000000000000000000000000000000000000000..198f4810c9fc1e20e5f36fba913d98ec356876f3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4/RCWeakRefTest4.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Weak;
+class Cycle_B_1_00010_A1 {
+    @Weak
+    Cycle_B_1_00010_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00010_A1() {
+        a1_0 = null;
+        a = 123;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class RCWeakRefTest4 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        if (nsum == 246)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4/test.cfg b/testsuite/java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1ac5b6af84829f5eb3fe6f02a5e66f54da70741c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0383-rc-Annotation-RCWeakRefTest4/test.cfg
@@ -0,0 +1,2 @@
+compile(RCWeakRefTest4)
+run(RCWeakRefTest4,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest/RCWeakRefThreadTest.java b/testsuite/java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest/RCWeakRefThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..45838020a06e7e2cd995aa0dea5e3f194a82b832
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest/RCWeakRefThreadTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Weak;
+class ThreadRc_Cycle_Bm_1_00010 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00010_A1 a1_0 = new Cycle_B_1_00010_A1();
+        a1_0.a1_0 = a1_0;
+        a1_0.add();
+        int nsum = a1_0.sum;
+        if (nsum == 246)
+            checkout = true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00010_A1 {
+        @Weak
+        Cycle_B_1_00010_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00010_A1() {
+            a1_0 = null;
+            a = 123;
+            sum = 0;
+        }
+        void add() {
+            sum = a1_0.a + this.a;
+        }
+    }
+}
+public class RCWeakRefThreadTest {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00010 A1_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A2_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A3_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A4_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A5_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        ThreadRc_Cycle_Bm_1_00010 A6_Cycle_Bm_1_00010 = new ThreadRc_Cycle_Bm_1_00010();
+        A1_Cycle_Bm_1_00010.start();
+        A2_Cycle_Bm_1_00010.start();
+        A3_Cycle_Bm_1_00010.start();
+        A4_Cycle_Bm_1_00010.start();
+        A5_Cycle_Bm_1_00010.start();
+        A6_Cycle_Bm_1_00010.start();
+        try {
+            A1_Cycle_Bm_1_00010.join();
+            A2_Cycle_Bm_1_00010.join();
+            A3_Cycle_Bm_1_00010.join();
+            A4_Cycle_Bm_1_00010.join();
+            A5_Cycle_Bm_1_00010.join();
+            A6_Cycle_Bm_1_00010.join();
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (A1_Cycle_Bm_1_00010.check() && A2_Cycle_Bm_1_00010.check() && A3_Cycle_Bm_1_00010.check() && A4_Cycle_Bm_1_00010.check() && A5_Cycle_Bm_1_00010.check() && A6_Cycle_Bm_1_00010.check()) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest/test.cfg b/testsuite/java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aff92f9418a32e67eb5fef16f83b65ae335693aa
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0384-rc-Annotation-RCWeakRefThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCWeakRefThreadTest)
+run(RCWeakRefThreadTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest/RCUnownedRefTest.java b/testsuite/java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest/RCUnownedRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..d33af7035a5b97af662c9586bdab9fedb413f15e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest/RCUnownedRefTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import com.huawei.ark.annotation.Unowned;
+class Test_B {
+    @Unowned
+    Test_A aa;
+    // add volatile will crash
+    // static Test_A a1;
+    protected void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+class Test_A {
+    Test_B bb;
+    public void test() {
+        setReferences();
+        System.runFinalization();
+    }
+    private void setReferences() {
+        Test_A ta = new Test_A();
+        ta.bb = new Test_B();
+        //ta.bb.aa = ta;
+        try {
+            Field m = Test_B.class.getDeclaredField("aa");
+            m.set(ta.bb, ta);
+            Test_A a_temp = (Test_A) m.get(ta.bb);
+            if (a_temp != ta) {
+                System.out.println("error");
+            }
+            //Field m1 = Test_B.class.getDeclaredField("a1");
+            //m1.set(null, ta);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+}
+public class RCUnownedRefTest {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest/test.cfg b/testsuite/java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d7cc93952775e6365f333d5859a33f69c8f2e853
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0385-rc-Annotation-RCUnownedRefTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedRefTest)
+run(RCUnownedRefTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2/RCUnownedRefTest2.java b/testsuite/java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2/RCUnownedRefTest2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a71b1d5527ab75193dd6c50264365cc9931e4600
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2/RCUnownedRefTest2.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+class Test_B {
+    @Unowned
+    Test_B bself;
+    protected void run() {
+        System.out.println("ExpectResult");
+    }
+}
+class Test_A {
+    Test_B bb;
+    Test_B bb2;
+    public void test() {
+        foo();
+        bb.bself.run();
+        bb2.bself.run();
+    }
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+        bb.bself = bb;
+        bb2.bself = bb;
+    }
+}
+public class RCUnownedRefTest2 {
+    public static void main(String[] args) {
+        new Test_A().test();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2/test.cfg b/testsuite/java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8aacad0126c2fb8784808bf4877c6b2e7e7e3310
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0386-rc-Annotation-RCUnownedRefTest2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedRefTest2)
+run(RCUnownedRefTest2,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle/RCUnownedRefUnCycle.java b/testsuite/java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle/RCUnownedRefUnCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..823762dc0772ffa92ac8efa07811a45fb92eeb66
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle/RCUnownedRefUnCycle.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+class Nocycle_a_00150_A1 {
+    Nocycle_a_00150_B1 b1_0;
+    @Unowned
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00150_A1(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00150_A2 {
+    @Unowned
+    Nocycle_a_00150_B1 b1_0;
+    Nocycle_a_00150_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00150_A2(String strObjectName) {
+        b1_0 = null;
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + b2_0.a;
+    }
+}
+class Nocycle_a_00150_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00150_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00150_B2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00150_B2(String strObjectName) {
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class RCUnownedRefUnCycle {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a1_main.b2_0 = a2_main.b2_0;
+        a2_main.b1_0 = a1_main.b1_0;
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        if (result == 1815)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle/test.cfg b/testsuite/java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..25473507a7329db4788396e74b3339b6d3d1b8a8
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0387-rc-Annotation-RCUnownedRefUnCycle/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedRefUnCycle)
+run(RCUnownedRefUnCycle,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread/RCUnownedRefUncycleThread.java b/testsuite/java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread/RCUnownedRefUncycleThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..cced9ab7f3b2b55c250e02f15b2abe6eb0d7e87e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread/RCUnownedRefUncycleThread.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+class ThreadRc_00150 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00150_A1 a1_main = new Nocycle_a_00150_A1("a1_main");
+        Nocycle_a_00150_A2 a2_main = new Nocycle_a_00150_A2("a2_main");
+        a1_main.b1_0 = new Nocycle_a_00150_B1("b1_0");
+        a2_main.b2_0 = new Nocycle_a_00150_B2("b2_0");
+        a2_main.b1_0 = a1_main.b1_0;
+        a1_main.b2_0 = a2_main.b2_0;
+        a1_main.add();
+        a2_main.add();
+        a1_main.b1_0.add();
+        a1_main.b2_0.add();
+        a2_main.b1_0.add();
+        a2_main.b2_0.add();
+//		 System.out.printf("RC-Testing_Result=%d\n",a1_main.sum+a2_main.sum+a1_main.b1_0.sum+a1_main.b2_0.sum);
+        int result = a1_main.sum + a2_main.sum + a1_main.b1_0.sum + a1_main.b2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1815)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00150_A1 {
+        Nocycle_a_00150_B1 b1_0;
+        @Unowned
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_A1(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00150_A2 {
+        @Unowned
+        Nocycle_a_00150_B1 b1_0;
+        Nocycle_a_00150_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_A2(String strObjectName) {
+            b1_0 = null;
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00150_B1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_B1(String strObjectName) {
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00150_B2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00150_B2(String strObjectName) {
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class RCUnownedRefUncycleThread {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00150 A1_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A2_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A3_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A4_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A5_00150 = new ThreadRc_00150();
+        ThreadRc_00150 A6_00150 = new ThreadRc_00150();
+        A1_00150.start();
+        A2_00150.start();
+        A3_00150.start();
+        A4_00150.start();
+        A5_00150.start();
+        A6_00150.start();
+        try {
+            A1_00150.join();
+            A2_00150.join();
+            A3_00150.join();
+            A4_00150.join();
+            A5_00150.join();
+            A6_00150.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00150.check() && A2_00150.check() && A3_00150.check() && A4_00150.check() && A5_00150.check() && A6_00150.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread/test.cfg b/testsuite/java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..add16fbad28b899a8659906ff18e9a575618cea5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0389-rc-Annotation-RCUnownedRefUncycleThread/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedRefUncycleThread)
+run(RCUnownedRefUncycleThread,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02/RCAnnotationThread02.java b/testsuite/java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02/RCAnnotationThread02.java
new file mode 100755
index 0000000000000000000000000000000000000000..df35c6aa3a20ebd5b243bb12fd59a04f50d6aed2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02/RCAnnotationThread02.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+class RCAnnotationThread02_1 extends Thread {
+    public void run() {
+        RCAnnotationThread02 rcth01 = new RCAnnotationThread02();
+        try {
+            rcth01.setA1null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RCAnnotationThread02_2 extends Thread {
+    public void run() {
+        RCAnnotationThread02 rcth01 = new RCAnnotationThread02();
+        try {
+            rcth01.setA4null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RCAnnotationThread02_3 extends Thread {
+    public void run() {
+        RCAnnotationThread02 rcth01 = new RCAnnotationThread02();
+        try {
+            rcth01.setA5null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RCAnnotationThread02 {
+    private volatile  static RCAnnotationThread02_A1 a1_main = null;
+    private volatile  static  RCAnnotationThread02_A4 a4_main = null;
+    private volatile  static  RCAnnotationThread02_A5 a5_main = null;
+    RCAnnotationThread02() {
+        synchronized (this) {
+            try {
+                RCAnnotationThread02_A1 a1 = new RCAnnotationThread02_A1();
+                a1.a2_0 = new RCAnnotationThread02_A2();
+                a1.a2_0.a3_0 = new RCAnnotationThread02_A3();
+                RCAnnotationThread02_A4 a4 = new RCAnnotationThread02_A4();
+                RCAnnotationThread02_A5 a5 = new RCAnnotationThread02_A5();
+                a4.a1_0 = a1;
+                a5.a1_0 = a1;
+                a1.a2_0.a3_0.a1_0 = a1;
+                a1_main = a1;
+                a4_main = a4;
+                a5_main = a5;
+            } catch (NullPointerException e) {
+            }
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread02_1 t1=new RCAnnotationThread02_1();
+        RCAnnotationThread02_2 t2=new RCAnnotationThread02_2();
+        RCAnnotationThread02_3 t3=new RCAnnotationThread02_3();
+        t1.start();
+        t2.start();
+        t3.start();
+        try{
+            t1.join();
+            t2.join();
+            t3.join();
+        }catch(InterruptedException e){}
+    }
+    public void setA1null() {
+        a1_main = null;
+    }
+    public void setA4null() {
+        a4_main = null;
+    }
+    public void setA5null() {
+        a5_main = null;
+    }
+    static class RCAnnotationThread02_A1 {
+        volatile RCAnnotationThread02_A2 a2_0;
+        int a;
+        int sum;
+        RCAnnotationThread02_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RCAnnotationThread02_A2 {
+        volatile RCAnnotationThread02_A3 a3_0;
+        int a;
+        int sum;
+        RCAnnotationThread02_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RCAnnotationThread02_A3 {
+        @Weak
+        volatile RCAnnotationThread02_A1 a1_0;
+        int a;
+        int sum;
+        RCAnnotationThread02_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    static class RCAnnotationThread02_A4 {
+        @Unowned
+        volatile RCAnnotationThread02_A1 a1_0;
+        int a;
+        int sum;
+        RCAnnotationThread02_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    static class RCAnnotationThread02_A5 {
+        @Unowned
+        volatile RCAnnotationThread02_A1 a1_0;
+        int a;
+        int sum;
+        RCAnnotationThread02_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02/test.cfg b/testsuite/java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4958580e799d206bb2e74851208288a08ddbc7cc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0392-rc-Annotation-RCAnnotationThread02/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationThread02)
+run(RCAnnotationThread02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04/RCAnnotationThread04.java b/testsuite/java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04/RCAnnotationThread04.java
new file mode 100755
index 0000000000000000000000000000000000000000..3583ff1cde59b5d75b7917fd80295716ede0fa0b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04/RCAnnotationThread04.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+class RCAnnotationThread04_1 extends Thread {
+    public void run() {
+        RCAnnotationThread04 rcth01 = new RCAnnotationThread04();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RCAnnotationThread04_2 extends Thread {
+    public void run() {
+        RCAnnotationThread04 rcth01 = new RCAnnotationThread04();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RCAnnotationThread04_3 extends Thread {
+    public void run() {
+        RCAnnotationThread04 rcth01 = new RCAnnotationThread04();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RCAnnotationThread04 {
+    private volatile static RCAnnotationThread04_A1 a1_main = null;
+    private volatile static RCAnnotationThread04_A4 a4_main = null;
+    private volatile static RCAnnotationThread04_A6 a6_main = null;
+    RCAnnotationThread04() {
+        synchronized (this) {
+            try {
+                RCAnnotationThread04_A1 a1 = new RCAnnotationThread04_A1("a1");
+                RCAnnotationThread04_A4 a4 = new RCAnnotationThread04_A4("a4");
+                RCAnnotationThread04_A6 a6 = new RCAnnotationThread04_A6("a6");
+                a1.a2_0 = new RCAnnotationThread04_A2("a2_0");
+                a1.a2_0.a3_0 = new RCAnnotationThread04_A3("a3_0");
+                a1.a2_0.a3_0.a1_0 = a1;
+                a1.a2_0.a3_0.a5_0 = new RCAnnotationThread04_A5("a5_0");
+                a1.a2_0.a3_0.a5_0.a6_0 = a6;
+                a6.a1_0 = a1;
+                a6.a3_0 = a1.a2_0.a3_0;
+                a4.a5_0 = a1.a2_0.a3_0.a5_0;
+                a6.a4_0 = a4;
+                a1_main = a1;
+                a4_main = a4;
+                a6_main = a6;
+            } catch (NullPointerException e) {
+            }
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread04_1 t_00010= new RCAnnotationThread04_1();
+        RCAnnotationThread04_2 t_00020= new RCAnnotationThread04_2();
+        RCAnnotationThread04_3 t_00030= new RCAnnotationThread04_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+        } catch (InterruptedException e) {}
+    }
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RCAnnotationThread04_A3("new-a3");
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA3null() {
+        RCAnnotationThread04_A3 a3 = new RCAnnotationThread04_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    static class RCAnnotationThread04_A1 {
+        volatile RCAnnotationThread04_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread04_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RCAnnotationThread04_A2 {
+        volatile RCAnnotationThread04_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread04_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RCAnnotationThread04_A3 {
+        @Weak
+        volatile RCAnnotationThread04_A1 a1_0;
+        volatile RCAnnotationThread04_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread04_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    static class RCAnnotationThread04_A4 {
+        volatile RCAnnotationThread04_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread04_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    static class RCAnnotationThread04_A5 {
+        @Unowned
+        volatile RCAnnotationThread04_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread04_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    static class RCAnnotationThread04_A6 {
+        @Unowned
+        volatile RCAnnotationThread04_A1 a1_0;
+        @Unowned
+        volatile RCAnnotationThread04_A3 a3_0;
+        @Unowned
+        volatile RCAnnotationThread04_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread04_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04/test.cfg b/testsuite/java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f4f65c1653a0e59619b590f708fb099041e1b260
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0394-rc-Annotation-RCAnnotationThread04/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationThread04)
+run(RCAnnotationThread04,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05/RCAnnotationThread05.java b/testsuite/java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05/RCAnnotationThread05.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd07bba65d2d9432deee08897b7ca5ba0e0c08a1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05/RCAnnotationThread05.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Weak;
+import com.huawei.ark.annotation.Unowned;
+class RCAnnotationThread05_1 extends Thread {
+    public void run() {
+        RCAnnotationThread05 rcth01 = new RCAnnotationThread05();
+        try {
+            rcth01.ModifyA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RCAnnotationThread05_2 extends Thread {
+    public void run() {
+        RCAnnotationThread05 rcth01 = new RCAnnotationThread05();
+        try {
+            rcth01.checkA3();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+class RCAnnotationThread05_3 extends Thread {
+    public void run() {
+        RCAnnotationThread05 rcth01 = new RCAnnotationThread05();
+        try {
+            rcth01.setA3null();
+        } catch (NullPointerException e) {
+        }
+    }
+}
+public class RCAnnotationThread05 {
+    private volatile static RCAnnotationThread05_A1 a1_main = null;
+    private volatile static RCAnnotationThread05_A4 a4_main = null;
+    private volatile static RCAnnotationThread05_A6 a6_main = null;
+    private static RCAnnotationThread05_A2 a2=null;
+    RCAnnotationThread05() {
+        synchronized (this) {
+            try {
+                RCAnnotationThread05_A1 a1 = new RCAnnotationThread05_A1("a1");
+                RCAnnotationThread05_A4 a4 = new RCAnnotationThread05_A4("a4");
+                RCAnnotationThread05_A6 a6 = new RCAnnotationThread05_A6("a6");
+                a2 = new RCAnnotationThread05_A2("a2_0");
+                a1.a2_0 = a2;
+                a1.a2_0.a3_0 = new RCAnnotationThread05_A3("a3_0");
+                a1.a2_0.a3_0.a1_0 = a1;
+                a1.a2_0.a3_0.a5_0 = new RCAnnotationThread05_A5("a5_0");
+                a1.a2_0.a3_0.a5_0.a6_0 = a6;
+                a6.a1_0 = a1;
+                a6.a3_0 = a1.a2_0.a3_0;
+                a4.a5_0 = a1.a2_0.a3_0.a5_0;
+                a6.a4_0 = a4;
+                a1_main = a1;
+                a4_main = a4;
+                a6_main = a6;
+            } catch (NullPointerException e) {
+            }
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+        System.out.println("ExpectResult");
+    }
+    private static void rc_testcase_main_wrapper() {
+        RCAnnotationThread05_1 t_00010= new RCAnnotationThread05_1();
+        RCAnnotationThread05_2 t_00020= new RCAnnotationThread05_2();
+        RCAnnotationThread05_3 t_00030= new RCAnnotationThread05_3();
+        t_00010.start();
+        t_00020.start();
+        t_00030.start();
+        try {
+            t_00010.join();
+            t_00020.join();
+            t_00030.join();
+        } catch (InterruptedException e) {}
+    }
+    public void checkA3() {
+        int[] arr = new int[2];
+        try {
+            arr[0] = a1_main.a2_0.a3_0.a;
+            arr[1] = a1_main.a2_0.a3_0.sum;
+        } catch (NullPointerException e) {
+        }
+    }
+    public void ModifyA3() {
+        try {
+            a1_main.a2_0.a3_0 = new RCAnnotationThread05_A3("new-a3");
+        } catch (NullPointerException e) {
+        }
+    }
+    public void setA3null() {
+        RCAnnotationThread05_A3 a3 = new RCAnnotationThread05_A3("test");
+        try {
+            a3 = this.a1_main.a2_0.a3_0;
+            this.a1_main.a2_0.a3_0 = null;
+        } catch (NullPointerException e) {
+        }
+    }
+    static class RCAnnotationThread05_A1 {
+        volatile RCAnnotationThread05_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread05_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    static class RCAnnotationThread05_A2 {
+        volatile RCAnnotationThread05_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread05_A2(String strObjectName) {
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    static class RCAnnotationThread05_A3 {
+        @Weak
+        volatile RCAnnotationThread05_A1 a1_0;
+        volatile RCAnnotationThread05_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread05_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a;
+        }
+    }
+    static class RCAnnotationThread05_A4 {
+        @Unowned
+        volatile RCAnnotationThread05_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread05_A4(String strObjectName) {
+            a5_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    static class RCAnnotationThread05_A5 {
+        @Unowned
+        volatile RCAnnotationThread05_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread05_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    static class RCAnnotationThread05_A6 {
+        @Unowned
+        volatile RCAnnotationThread05_A1 a1_0;
+        @Unowned
+        volatile RCAnnotationThread05_A3 a3_0;
+        @Unowned
+        volatile RCAnnotationThread05_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        RCAnnotationThread05_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a4_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a + a4_0.a;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05/test.cfg b/testsuite/java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8c3894508692280c398f00bec2e651138e09d2f6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0395-rc-Annotation-RCAnnotationThread05/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationThread05)
+run(RCAnnotationThread05,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle/RCAnnotationOneCycle.java b/testsuite/java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle/RCAnnotationOneCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..9b6b4a7d7b3c81281e57710adb6aae05296c20b5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle/RCAnnotationOneCycle.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class Cycle_B_1_00180_A1 {
+    Cycle_B_1_00180_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_1_00180_A2 {
+    Cycle_B_1_00180_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_1_00180_A3 {
+    @Weak
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A3() {
+        a1_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00180_A4 {
+    @Unowned
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A4() {
+        a1_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_1_00180_A5 {
+    @Unowned
+    Cycle_B_1_00180_A1 a1_0;
+    int a;
+    int sum;
+    Cycle_B_1_00180_A5() {
+        a1_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+public class RCAnnotationOneCycle {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 23)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle/test.cfg b/testsuite/java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b4ed7d06be3d45fd28151cc8202a5bc870a631a4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0396-rc-Annotation-RCAnnotationOneCycle/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationOneCycle)
+run(RCAnnotationOneCycle,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread/RCAnnotationOneCycleThread.java b/testsuite/java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread/RCAnnotationOneCycleThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..b44fef504c1c3368cec489b7d5c0e81226074d00
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread/RCAnnotationOneCycleThread.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class ThreadRc_Cycle_Bm_1_00180 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_1_00180_A1 a1_0 = new Cycle_B_1_00180_A1();
+        a1_0.a2_0 = new Cycle_B_1_00180_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_1_00180_A3();
+        Cycle_B_1_00180_A4 a4_0 = new Cycle_B_1_00180_A4();
+        Cycle_B_1_00180_A5 a5_0 = new Cycle_B_1_00180_A5();
+        a4_0.a1_0 = a1_0;
+        a5_0.a1_0 = a1_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 23)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_1_00180_A1 {
+        Cycle_B_1_00180_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A2 {
+        Cycle_B_1_00180_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A3 {
+        @Weak
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A3() {
+            a1_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A4 {
+        @Unowned
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A4() {
+            a1_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_1_00180_A5 {
+        @Unowned
+        Cycle_B_1_00180_A1 a1_0;
+        int a;
+        int sum;
+        Cycle_B_1_00180_A5() {
+            a1_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+}
+public class RCAnnotationOneCycleThread {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_1_00180 A1_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A2_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A3_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A4_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A5_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        ThreadRc_Cycle_Bm_1_00180 A6_Cycle_Bm_1_00180 = new ThreadRc_Cycle_Bm_1_00180();
+        A1_Cycle_Bm_1_00180.start();
+        A2_Cycle_Bm_1_00180.start();
+        A3_Cycle_Bm_1_00180.start();
+        A4_Cycle_Bm_1_00180.start();
+        A5_Cycle_Bm_1_00180.start();
+        A6_Cycle_Bm_1_00180.start();
+        try {
+            A1_Cycle_Bm_1_00180.join();
+            A2_Cycle_Bm_1_00180.join();
+            A3_Cycle_Bm_1_00180.join();
+            A4_Cycle_Bm_1_00180.join();
+            A5_Cycle_Bm_1_00180.join();
+            A6_Cycle_Bm_1_00180.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_1_00180.check() && A2_Cycle_Bm_1_00180.check() && A3_Cycle_Bm_1_00180.check() && A4_Cycle_Bm_1_00180.check() && A5_Cycle_Bm_1_00180.check() && A6_Cycle_Bm_1_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread/test.cfg b/testsuite/java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..91d4c98c890e715ab9bcbb2bdaf8ed7a2d51a183
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0397-rc-Annotation-RCAnnotationOneCycleThread/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationOneCycleThread)
+run(RCAnnotationOneCycleThread,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle/RCAnnotationTwoCycle.java b/testsuite/java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle/RCAnnotationTwoCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..dbba1a4020081e91c42af2e7ac566b2a9ecd272a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle/RCAnnotationTwoCycle.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class Cycle_B_2_00080_A1 {
+    Cycle_B_2_00080_A2 a2_0;
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A1() {
+        a2_0 = null;
+        a5_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00080_A2 {
+    Cycle_B_2_00080_A3 a3_0;
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A2() {
+        a3_0 = null;
+        a4_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00080_A3 {
+    @Weak
+    Cycle_B_2_00080_A1 a1_0;
+    @Unowned
+    Cycle_B_2_00080_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A3() {
+        a1_0 = null;
+        a5_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_B_2_00080_A4 {
+    @Unowned
+    Cycle_B_2_00080_A3 a3_0;
+    @Unowned
+    Cycle_B_2_00080_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A4() {
+        a3_0 = null;
+        a2_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00080_A5 {
+    @Unowned
+    Cycle_B_2_00080_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00080_A5() {
+        a4_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+public class RCAnnotationTwoCycle {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a1_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a1_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle/test.cfg b/testsuite/java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f479a618570a8f66a3e1d771d0e3bf920c30024e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0398-rc-Annotation-RCAnnotationTwoCycle/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationTwoCycle)
+run(RCAnnotationTwoCycle,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2/RCAnnotationTwoCycle2.java b/testsuite/java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2/RCAnnotationTwoCycle2.java
new file mode 100755
index 0000000000000000000000000000000000000000..3cd57f18bc03a0bac597adc105ad0cf2aa46734a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2/RCAnnotationTwoCycle2.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class Cycle_B_2_00230_A1 {
+    Cycle_B_2_00230_A2 a2_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A1() {
+        a2_0 = null;
+        a = 1;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_B_2_00230_A2 {
+    Cycle_B_2_00230_A3 a3_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A2() {
+        a3_0 = null;
+        a = 2;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+class Cycle_B_2_00230_A3 {
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A3() {
+        a4_0 = null;
+        a = 3;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_B_2_00230_A4 {
+    Cycle_B_2_00230_A5 a5_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A4() {
+        a5_0 = null;
+        a = 4;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a5_0.a;
+    }
+}
+class Cycle_B_2_00230_A5 {
+    Cycle_B_2_00230_A6 a6_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A5() {
+        a6_0 = null;
+        a = 5;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_B_2_00230_A6 {
+    @Weak
+    Cycle_B_2_00230_A1 a1_0;
+    @Unowned
+    Cycle_B_2_00230_A10 a10_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A6() {
+        a1_0 = null;
+        a10_0 = null;
+        a = 6;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a1_0.a + a10_0.a;
+    }
+}
+class Cycle_B_2_00230_A8 {
+    Cycle_B_2_00230_A9 a9_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A8() {
+        a9_0 = null;
+        a = 7;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+class Cycle_B_2_00230_A9 {
+    Cycle_B_2_00230_A7 a7_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A9() {
+        a7_0 = null;
+        a = 8;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_B_2_00230_A7 {
+    @Unowned
+    Cycle_B_2_00230_A4 a4_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A7() {
+        a4_0 = null;
+        a = 9;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a4_0.a;
+    }
+}
+class Cycle_B_2_00230_A10 {
+    Cycle_B_2_00230_A8 a8_0;
+    int a;
+    int sum;
+    Cycle_B_2_00230_A10() {
+        a8_0 = null;
+        a = 10;
+        sum = 0;
+    }
+    void add() {
+        sum = a + a8_0.a;
+    }
+}
+public class RCAnnotationTwoCycle2 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 97)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2/test.cfg b/testsuite/java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4d566215d2eb3df8717ccd1e1be8fab036e6fd8f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0399-rc-Annotation-RCAnnotationTwoCycle2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationTwoCycle2)
+run(RCAnnotationTwoCycle2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/RCAnnotationTwoCycleThread.java b/testsuite/java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/RCAnnotationTwoCycleThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..d28c0d241e52a8e87f45bf92f13bdf1995a1f414
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/RCAnnotationTwoCycleThread.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class ThreadRc_Cycle_Bm_2_00080 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00080_A1 a1_0 = new Cycle_B_2_00080_A1();
+        a1_0.a2_0 = new Cycle_B_2_00080_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00080_A3();
+        Cycle_B_2_00080_A4 a4_0 = new Cycle_B_2_00080_A4();
+        a4_0.a2_0 = a1_0.a2_0;
+        a1_0.a2_0.a3_0.a1_0 = a1_0;
+        a4_0.a3_0 = a1_0.a2_0.a3_0;
+        a1_0.a5_0 = new Cycle_B_2_00080_A5();
+        a1_0.a2_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0 = a1_0.a5_0;
+        a4_0.a3_0.a5_0.a4_0 = a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a4_0.add();
+        a1_0.a5_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a4_0.sum + a1_0.a5_0.sum);
+        //System.out.println(nsum);
+        if (nsum == 28)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00080_A1 {
+        Cycle_B_2_00080_A2 a2_0;
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A1() {
+            a2_0 = null;
+            a5_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A2 {
+        Cycle_B_2_00080_A3 a3_0;
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A2() {
+            a3_0 = null;
+            a4_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A3 {
+        @Weak
+        Cycle_B_2_00080_A1 a1_0;
+        @Unowned
+        Cycle_B_2_00080_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A3() {
+            a1_0 = null;
+            a5_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A4 {
+        @Unowned
+        Cycle_B_2_00080_A3 a3_0;
+        @Unowned
+        Cycle_B_2_00080_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A4() {
+            a3_0 = null;
+            a2_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00080_A5 {
+        @Unowned
+        Cycle_B_2_00080_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00080_A5() {
+            a4_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+}
+public class RCAnnotationTwoCycleThread {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00080 A1_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A2_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A3_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A4_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A5_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        ThreadRc_Cycle_Bm_2_00080 A6_Cycle_Bm_2_00080 = new ThreadRc_Cycle_Bm_2_00080();
+        A1_Cycle_Bm_2_00080.start();
+        A2_Cycle_Bm_2_00080.start();
+        A3_Cycle_Bm_2_00080.start();
+        A4_Cycle_Bm_2_00080.start();
+        A5_Cycle_Bm_2_00080.start();
+        A6_Cycle_Bm_2_00080.start();
+        try {
+            A1_Cycle_Bm_2_00080.join();
+            A2_Cycle_Bm_2_00080.join();
+            A3_Cycle_Bm_2_00080.join();
+            A4_Cycle_Bm_2_00080.join();
+            A5_Cycle_Bm_2_00080.join();
+            A6_Cycle_Bm_2_00080.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00080.check() && A2_Cycle_Bm_2_00080.check() && A3_Cycle_Bm_2_00080.check() && A4_Cycle_Bm_2_00080.check() && A5_Cycle_Bm_2_00080.check() && A6_Cycle_Bm_2_00080.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/test.cfg b/testsuite/java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c3930a9ec991645d7d4ba3b1d3ad59181b235af6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0400-rc-Annotation-RCAnnotationTwoCycleThread/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationTwoCycleThread)
+run(RCAnnotationTwoCycleThread,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/RCAnnotationTwoCycleThread2.java b/testsuite/java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/RCAnnotationTwoCycleThread2.java
new file mode 100755
index 0000000000000000000000000000000000000000..26e0e4c47344ccd09e68d7b72fa3d75fdef27907
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/RCAnnotationTwoCycleThread2.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class ThreadRc_Cycle_Bm_2_00230 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_B_2_00230_A1 a1_0 = new Cycle_B_2_00230_A1();
+        a1_0.a2_0 = new Cycle_B_2_00230_A2();
+        a1_0.a2_0.a3_0 = new Cycle_B_2_00230_A3();
+        a1_0.a2_0.a3_0.a4_0 = new Cycle_B_2_00230_A4();
+        a1_0.a2_0.a3_0.a4_0.a5_0 = new Cycle_B_2_00230_A5();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0 = new Cycle_B_2_00230_A6();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a1_0 = a1_0;
+        Cycle_B_2_00230_A10 a10_0 = new Cycle_B_2_00230_A10();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.a10_0 = a10_0;
+        a10_0.a8_0 = new Cycle_B_2_00230_A8();
+        a10_0.a8_0.a9_0 = new Cycle_B_2_00230_A9();
+        a10_0.a8_0.a9_0.a7_0 = new Cycle_B_2_00230_A7();
+        a10_0.a8_0.a9_0.a7_0.a4_0 = a1_0.a2_0.a3_0.a4_0;
+        a1_0.add();
+        a1_0.a2_0.add();
+        a1_0.a2_0.a3_0.add();
+        a1_0.a2_0.a3_0.a4_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.add();
+        a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.add();
+        a10_0.a8_0.add();
+        a10_0.a8_0.a9_0.add();
+        a10_0.a8_0.a9_0.a7_0.add();
+        int nsum = (a1_0.sum + a1_0.a2_0.sum + a1_0.a2_0.a3_0.sum + a1_0.a2_0.a3_0.a4_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.sum + a1_0.a2_0.a3_0.a4_0.a5_0.a6_0.sum + a10_0.a8_0.sum + a10_0.a8_0.a9_0.sum + a10_0.a8_0.a9_0.a7_0.sum);
+        if (nsum == 97)
+            checkout = true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_B_2_00230_A1 {
+        Cycle_B_2_00230_A2 a2_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A1() {
+            a2_0 = null;
+            a = 1;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A2 {
+        Cycle_B_2_00230_A3 a3_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A2() {
+            a3_0 = null;
+            a = 2;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A3 {
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A3() {
+            a4_0 = null;
+            a = 3;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A4 {
+        Cycle_B_2_00230_A5 a5_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A4() {
+            a5_0 = null;
+            a = 4;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a5_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A5 {
+        Cycle_B_2_00230_A6 a6_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A5() {
+            a6_0 = null;
+            a = 5;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A6 {
+        @Weak
+        Cycle_B_2_00230_A1 a1_0;
+        @Unowned
+        Cycle_B_2_00230_A10 a10_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A6() {
+            a1_0 = null;
+            a10_0 = null;
+            a = 6;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a1_0.a + a10_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A8 {
+        Cycle_B_2_00230_A9 a9_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A8() {
+            a9_0 = null;
+            a = 7;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A9 {
+        Cycle_B_2_00230_A7 a7_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A9() {
+            a7_0 = null;
+            a = 8;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A7 {
+        @Unowned
+        Cycle_B_2_00230_A4 a4_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A7() {
+            a4_0 = null;
+            a = 9;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a4_0.a;
+        }
+    }
+    class Cycle_B_2_00230_A10 {
+        Cycle_B_2_00230_A8 a8_0;
+        int a;
+        int sum;
+        Cycle_B_2_00230_A10() {
+            a8_0 = null;
+            a = 10;
+            sum = 0;
+        }
+        void add() {
+            sum = a + a8_0.a;
+        }
+    }
+}
+public class RCAnnotationTwoCycleThread2 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_Bm_2_00230 A1_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A2_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A3_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A4_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A5_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        ThreadRc_Cycle_Bm_2_00230 A6_Cycle_Bm_2_00230 = new ThreadRc_Cycle_Bm_2_00230();
+        A1_Cycle_Bm_2_00230.start();
+        A2_Cycle_Bm_2_00230.start();
+        A3_Cycle_Bm_2_00230.start();
+        A4_Cycle_Bm_2_00230.start();
+        A5_Cycle_Bm_2_00230.start();
+        A6_Cycle_Bm_2_00230.start();
+        try {
+            A1_Cycle_Bm_2_00230.join();
+            A2_Cycle_Bm_2_00230.join();
+            A3_Cycle_Bm_2_00230.join();
+            A4_Cycle_Bm_2_00230.join();
+            A5_Cycle_Bm_2_00230.join();
+            A6_Cycle_Bm_2_00230.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_Bm_2_00230.check() && A2_Cycle_Bm_2_00230.check() && A3_Cycle_Bm_2_00230.check() && A4_Cycle_Bm_2_00230.check() && A5_Cycle_Bm_2_00230.check() && A6_Cycle_Bm_2_00230.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/test.cfg b/testsuite/java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5f11deb271159719e273ae0f5a25ba9b6d116209
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0401-rc-Annotation-RCAnnotationTwoCycleThread2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationTwoCycleThread2)
+run(RCAnnotationTwoCycleThread2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle/RCAnnotationMultiCycle.java b/testsuite/java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle/RCAnnotationMultiCycle.java
new file mode 100755
index 0000000000000000000000000000000000000000..262e7a78a66d96a50d5e35a0966bbdcb3fc029de
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle/RCAnnotationMultiCycle.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class Cycle_a_00280_A1 {
+    Cycle_a_00280_A2 a2_0;
+    @Unowned
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00280_A2 {
+    @Weak
+    Cycle_a_00280_A1 a1_0;
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00280_A3 {
+    @Weak
+    Cycle_a_00280_A1 a1_0;
+    @Weak
+    Cycle_a_00280_A2 a2_0;
+    Cycle_a_00280_A5 a5_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a5_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a2_0.a + a5_0.a;
+    }
+}
+class Cycle_a_00280_A5 {
+    @Unowned
+    Cycle_a_00280_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A5(String strObjectName) {
+        a6_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00280_A6 {
+    @Unowned
+    Cycle_a_00280_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00280_A6(String strObjectName) {
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a;
+    }
+}
+public class RCAnnotationMultiCycle {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        if (result == 1443)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle/test.cfg b/testsuite/java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..922aac64551a6f7378895f6d8bc88d2e6e51833a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0402-rc-Annotation-RCAnnotationMultiCycle/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationMultiCycle)
+run(RCAnnotationMultiCycle,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2/RCAnnotationMultiCycle2.java b/testsuite/java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2/RCAnnotationMultiCycle2.java
new file mode 100755
index 0000000000000000000000000000000000000000..e1193455ba8bcea4504da9355c7e86eb2aa9b7ba
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2/RCAnnotationMultiCycle2.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class Cycle_a_00370_A1 {
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00370_A2 {
+    Cycle_a_00370_A3 a3_0;
+    @Unowned
+    Cycle_a_00370_A4 a4_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A2(String strObjectName) {
+        a3_0 = null;
+        a4_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a3_0.a + a4_0.a;
+    }
+}
+class Cycle_a_00370_A3 {
+    @Weak
+    Cycle_a_00370_A1 a1_0;
+    Cycle_a_00370_A5 a5_0;
+    Cycle_a_00370_A10 a10_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A3(String strObjectName) {
+        a1_0 = null;
+        a5_0 = null;
+        a10_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a5_0.a + a10_0.a;
+    }
+}
+class Cycle_a_00370_A4 {
+    @Unowned
+    Cycle_a_00370_A1 a1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A4(String strObjectName) {
+        a1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a;
+    }
+}
+class Cycle_a_00370_A5 {
+    @Unowned
+    Cycle_a_00370_A6 a6_0;
+    Cycle_a_00370_A8 a8_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A5(String strObjectName) {
+        a6_0 = null;
+        a8_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a + a8_0.a;
+    }
+}
+class Cycle_a_00370_A6 {
+    @Unowned
+    Cycle_a_00370_A1 a1_0;
+    @Unowned
+    Cycle_a_00370_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A6(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + a1_0.a + a3_0.a;
+    }
+}
+class Cycle_a_00370_A7 {
+    @Unowned
+    Cycle_a_00370_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A7(String strObjectName) {
+        a2_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a;
+    }
+}
+class Cycle_a_00370_A8 {
+    Cycle_a_00370_A7 a7_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A8(String strObjectName) {
+        a7_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + a7_0.a;
+    }
+}
+class Cycle_a_00370_A9 {
+    @Unowned
+    Cycle_a_00370_A6 a6_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A9(String strObjectName) {
+        a6_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+    void add() {
+        sum = a + a6_0.a;
+    }
+}
+class Cycle_a_00370_A10 {
+    @Unowned
+    Cycle_a_00370_A9 a9_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Cycle_a_00370_A10(String strObjectName) {
+        a9_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+    void add() {
+        sum = a + a9_0.a;
+    }
+}
+public class RCAnnotationMultiCycle2 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum +a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.sum + a1_main.a2_0.a3_0.a10_0.sum;
+        if (result == 2623)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2/test.cfg b/testsuite/java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..07fcb66770d0d03084be86f3276206cadd74968b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0403-rc-Annotation-RCAnnotationMultiCycle2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationMultiCycle2)
+run(RCAnnotationMultiCycle2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/RCAnnotationMultiCycleThread.java b/testsuite/java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/RCAnnotationMultiCycleThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..76a1a5327c9e691157fe92e4228437115a5aa59a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/RCAnnotationMultiCycleThread.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class ThreadRc_Cycle_am_00280 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00280_A1 a1_main = new Cycle_a_00280_A1("a1_main");
+        Cycle_a_00280_A6 a6_main = new Cycle_a_00280_A6("a6_main");
+        a1_main.a2_0 = new Cycle_a_00280_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new Cycle_a_00280_A3("a3_0");
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00280_A5("a5_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a6_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        int result = a1_main.sum + a6_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 1443)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00280_A1 {
+        Cycle_a_00280_A2 a2_0;
+        @Unowned
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A1(String strObjectName) {
+            a2_0 = null;
+            a3_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00280_A2 {
+        @Weak
+        Cycle_a_00280_A1 a1_0;
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A2(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00280_A3 {
+        @Weak
+        Cycle_a_00280_A1 a1_0;
+        @Weak
+        Cycle_a_00280_A2 a2_0;
+        Cycle_a_00280_A5 a5_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A3(String strObjectName) {
+            a1_0 = null;
+            a2_0 = null;
+            a5_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a2_0.a + a5_0.a;
+        }
+    }
+    class Cycle_a_00280_A5 {
+        @Unowned
+        Cycle_a_00280_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A5(String strObjectName) {
+            a6_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00280_A6 {
+        @Unowned
+        Cycle_a_00280_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00280_A6(String strObjectName) {
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a;
+        }
+    }
+}
+public class RCAnnotationMultiCycleThread {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00280 A1_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A2_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A3_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A4_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A5_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        ThreadRc_Cycle_am_00280 A6_Cycle_am_00280 = new ThreadRc_Cycle_am_00280();
+        A1_Cycle_am_00280.start();
+        A2_Cycle_am_00280.start();
+        A3_Cycle_am_00280.start();
+        A4_Cycle_am_00280.start();
+        A5_Cycle_am_00280.start();
+        A6_Cycle_am_00280.start();
+        try {
+            A1_Cycle_am_00280.join();
+            A2_Cycle_am_00280.join();
+            A3_Cycle_am_00280.join();
+            A4_Cycle_am_00280.join();
+            A5_Cycle_am_00280.join();
+            A6_Cycle_am_00280.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00280.check() && A2_Cycle_am_00280.check() && A3_Cycle_am_00280.check() && A4_Cycle_am_00280.check() && A5_Cycle_am_00280.check() && A6_Cycle_am_00280.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/test.cfg b/testsuite/java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3af706da1f595a4c8925ef1101979cb02f76b526
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0404-rc-Annotation-RCAnnotationMultiCycleThread/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationMultiCycleThread)
+run(RCAnnotationMultiCycleThread,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/RCAnnotationMultiCycleThread2.java b/testsuite/java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/RCAnnotationMultiCycleThread2.java
new file mode 100755
index 0000000000000000000000000000000000000000..f4a1927eeb6696412fbbb947aa3fa599a50c1656
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/RCAnnotationMultiCycleThread2.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import com.huawei.ark.annotation.Weak;
+class ThreadRc_Cycle_am_00370 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Cycle_a_00370_A1 a1_main = new Cycle_a_00370_A1("a1_main");
+        Cycle_a_00370_A4 a4_main = new Cycle_a_00370_A4("a4_main");
+        Cycle_a_00370_A6 a6_main = new Cycle_a_00370_A6("a6_main");
+        Cycle_a_00370_A9 a9_main = new Cycle_a_00370_A9("a9_main");
+        a1_main.a2_0 = new Cycle_a_00370_A2("a2_0");
+        a1_main.a2_0.a3_0 = new Cycle_a_00370_A3("a3_0");
+        a1_main.a2_0.a4_0 = a4_main;
+        a4_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0 = new Cycle_a_00370_A5("a5_0");
+        a1_main.a2_0.a3_0.a10_0 = new Cycle_a_00370_A10("a10_0");
+        a1_main.a2_0.a3_0.a5_0.a6_0 = a6_main;
+        a6_main.a1_0 = a1_main;
+        a1_main.a2_0.a3_0.a5_0.a8_0 = new Cycle_a_00370_A8("a8_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0 = new Cycle_a_00370_A7("a7_0");
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.a2_0 = a1_main.a2_0;
+        a1_main.a2_0.a3_0.a10_0.a9_0 = a9_main;
+        a9_main.a6_0 = a6_main;
+        a6_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.add();
+        a4_main.add();
+        a6_main.add();
+        a9_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main.a2_0.a3_0.a5_0.add();
+        a1_main.a2_0.a3_0.a10_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.add();
+        a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.add();
+        int result = a1_main.sum + a4_main.sum + a6_main.sum + a9_main.sum + a1_main.a2_0.sum + a1_main.a2_0.a3_0.sum + a1_main.a2_0.a3_0.a5_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.a7_0.sum + a1_main.a2_0.a3_0.a5_0.a8_0.sum + a1_main.a2_0.a3_0.a10_0.sum;
+        if (result == 2623)
+            checkout = true;
+        //System.out.println(checkout);
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Cycle_a_00370_A1 {
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A1(String strObjectName) {
+            a2_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00370_A2 {
+        Cycle_a_00370_A3 a3_0;
+        @Unowned
+        Cycle_a_00370_A4 a4_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A2(String strObjectName) {
+            a3_0 = null;
+            a4_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a3_0.a + a4_0.a;
+        }
+    }
+    class Cycle_a_00370_A3 {
+        @Weak
+        Cycle_a_00370_A1 a1_0;
+        Cycle_a_00370_A5 a5_0;
+        Cycle_a_00370_A10 a10_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A3(String strObjectName) {
+            a1_0 = null;
+            a5_0 = null;
+            a10_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a5_0.a + a10_0.a;
+        }
+    }
+    class Cycle_a_00370_A4 {
+        @Unowned
+        Cycle_a_00370_A1 a1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A4(String strObjectName) {
+            a1_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a;
+        }
+    }
+    class Cycle_a_00370_A5 {
+        @Unowned
+        Cycle_a_00370_A6 a6_0;
+        Cycle_a_00370_A8 a8_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A5(String strObjectName) {
+            a6_0 = null;
+            a8_0 = null;
+            a = 105;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a + a8_0.a;
+        }
+    }
+    class Cycle_a_00370_A6 {
+        @Unowned
+        Cycle_a_00370_A1 a1_0;
+        @Unowned
+        Cycle_a_00370_A3 a3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A6(String strObjectName) {
+            a1_0 = null;
+            a3_0 = null;
+            a = 106;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+        }
+        void add() {
+            sum = a + a1_0.a + a3_0.a;
+        }
+    }
+    class Cycle_a_00370_A7 {
+        @Unowned
+        Cycle_a_00370_A2 a2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A7(String strObjectName) {
+            a2_0 = null;
+            a = 107;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+        }
+        void add() {
+            sum = a + a2_0.a;
+        }
+    }
+    class Cycle_a_00370_A8 {
+        Cycle_a_00370_A7 a7_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A8(String strObjectName) {
+            a7_0 = null;
+            a = 108;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+        }
+        void add() {
+            sum = a + a7_0.a;
+        }
+    }
+    class Cycle_a_00370_A9 {
+        @Unowned
+        Cycle_a_00370_A6 a6_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A9(String strObjectName) {
+            a6_0 = null;
+            a = 109;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+        }
+        void add() {
+            sum = a + a6_0.a;
+        }
+    }
+    class Cycle_a_00370_A10 {
+        @Unowned
+        Cycle_a_00370_A9 a9_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Cycle_a_00370_A10(String strObjectName) {
+            a9_0 = null;
+            a = 110;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+        }
+        void add() {
+            sum = a + a9_0.a;
+        }
+    }
+}
+public class RCAnnotationMultiCycleThread2 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_Cycle_am_00370 A1_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A2_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A3_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A4_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A5_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        ThreadRc_Cycle_am_00370 A6_Cycle_am_00370 = new ThreadRc_Cycle_am_00370();
+        A1_Cycle_am_00370.start();
+        A2_Cycle_am_00370.start();
+        A3_Cycle_am_00370.start();
+        A4_Cycle_am_00370.start();
+        A5_Cycle_am_00370.start();
+        A6_Cycle_am_00370.start();
+        try {
+            A1_Cycle_am_00370.join();
+            A2_Cycle_am_00370.join();
+            A3_Cycle_am_00370.join();
+            A4_Cycle_am_00370.join();
+            A5_Cycle_am_00370.join();
+            A6_Cycle_am_00370.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_Cycle_am_00370.check() && A2_Cycle_am_00370.check() && A3_Cycle_am_00370.check() && A4_Cycle_am_00370.check() && A5_Cycle_am_00370.check() && A6_Cycle_am_00370.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/test.cfg b/testsuite/java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8039d3c59d65c3bb90fc9334107f4bb8df0d4d7e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0405-rc-Annotation-RCAnnotationMultiCycleThread2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCAnnotationMultiCycleThread2)
+run(RCAnnotationMultiCycleThread2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0406-rc-DTS-stringIntern/expected.txt b/testsuite/java_test/rc_test/RC0406-rc-DTS-stringIntern/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0406-rc-DTS-stringIntern/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0406-rc-DTS-stringIntern/stringIntern.java b/testsuite/java_test/rc_test/RC0406-rc-DTS-stringIntern/stringIntern.java
new file mode 100755
index 0000000000000000000000000000000000000000..1ae84a70b0d867e39e4a8ccd68dd2fbba4d4f66f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0406-rc-DTS-stringIntern/stringIntern.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class stringIntern {
+    private static int check = 0;
+    public static void main(String[] args) {
+        String s1 = new String("aaa");
+        String s2 = "aaa";
+        if (s1 != s2) {
+            check++;    //=1
+        }
+        s1 = new String("bbb").intern();
+        s2 = "bbb";
+        if (s1 == s2) {
+            check++;    //=2
+        }
+        s1 = "ccc";
+        s2 = "ccc";
+        if (s1 == s2) {
+            check++;    //=3
+        }
+        s1 = new String("ddd").intern();
+        s2 = new String("ddd").intern();
+        if (s1 == s2) {
+            check++;    //=4
+        }
+        s1 = "ab" + "cd";
+        s2 = "abcd";
+        if (s1 == s2) {
+            check++;    //=5
+        }
+        String temp = "hh";
+        s1 = "a" + temp;
+        s2 = "ahh";
+        if (s1 != s2) {
+            check++;    //=6
+        }
+        temp = "hh".intern();
+        s1 = "a" + temp;
+        s2 = "ahh";
+        if (s1 != s2) {
+            check++;    //=7
+        }
+        temp = "hh".intern();
+        s1 = ("a" + temp).intern();
+        s2 = "ahh";
+        if (s1 == s2) {
+            check++;    //=8
+        }
+        s1 = new String("1");
+        s1.intern();
+        s2 = "1";
+        if (s1 != s2) {
+            check++;    //=9
+        }
+        String s3 = new String("1") + new String("1");
+        s3.intern();
+        String s4 = "11";
+        if (s1 != s2) {
+            check++;    //=10
+        }
+        s3 = new String("2") + new String("2");
+        s4 = "22";
+        s3.intern();
+        if (s1 != s2) {
+            check++;    //=11
+        }
+        if (check == 11) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0406-rc-DTS-stringIntern/test.cfg b/testsuite/java_test/rc_test/RC0406-rc-DTS-stringIntern/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7d21fddfe052be188f669c491136ba26f89ae0a2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0406-rc-DTS-stringIntern/test.cfg
@@ -0,0 +1,2 @@
+compile(stringIntern)
+run(stringIntern,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0407-rc-DTS-stackAllocField/expected.txt b/testsuite/java_test/rc_test/RC0407-rc-DTS-stackAllocField/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0407-rc-DTS-stackAllocField/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0407-rc-DTS-stackAllocField/stackAllocField.java b/testsuite/java_test/rc_test/RC0407-rc-DTS-stackAllocField/stackAllocField.java
new file mode 100755
index 0000000000000000000000000000000000000000..e24428da6413575161f60dbbe1c0195202769ab3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0407-rc-DTS-stackAllocField/stackAllocField.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class stackAllocField {
+    private static A a1 = new A();
+    private static A a2 = new A();
+    private static A a3 = new A();
+    private static A a4 = new A();
+    public static void main(String[] args) {
+        wrapper(a1, a2, a3, a4);
+    }
+    public static void wrapper(A tempa1, A tempa2, A tempa3, A tempa4) {
+        A testa1 = new A();
+        testa1.a = tempa1;
+        A testa2 = new A();
+        testa2.a = tempa2;
+        A testa3 = new A();
+        testa3.a = tempa3;
+        A testa4 = new A();
+        testa4.a = tempa4;
+        tempa1 = null;
+        tempa2 = null;
+        tempa3 = null;
+        tempa4 = null;
+        a1 = null;
+        a2 = null;
+        a3 = null;
+        a4 = null;
+        for (int i = 0; i <= 50; i++) {
+            Runtime.getRuntime().gc();
+        }
+        if (testa1.a != null && testa2.a != null && testa3.a != null && testa4.a != null) {
+            System.out.println("ExpectResult");
+        }
+    }
+    private static class A {
+        A a;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0407-rc-DTS-stackAllocField/test.cfg b/testsuite/java_test/rc_test/RC0407-rc-DTS-stackAllocField/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..39fef35ad093e76cd734c547d9c1a80b751d81ad
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0407-rc-DTS-stackAllocField/test.cfg
@@ -0,0 +1,2 @@
+compile(stackAllocField)
+run(stackAllocField,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0408-rc-DTS-OOMtest/OOMtest.java b/testsuite/java_test/rc_test/RC0408-rc-DTS-OOMtest/OOMtest.java
new file mode 100755
index 0000000000000000000000000000000000000000..72d80670a4e86de48e138ebcb511440a53da7421
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0408-rc-DTS-OOMtest/OOMtest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class OOMtest {
+    private static ArrayList<byte[]> store;
+    private static int alloc_test() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 * 1024 * 10; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        try {
+            int result = alloc_test();
+        } catch (OutOfMemoryError o) {
+            System.out.println("ExpectResult");
+        }
+        if (store == null) {
+            System.out.println("Error");
+        } else {
+			System.out.println("ExpectResult");
+		}
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0408-rc-DTS-OOMtest/expected.txt b/testsuite/java_test/rc_test/RC0408-rc-DTS-OOMtest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0408-rc-DTS-OOMtest/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0408-rc-DTS-OOMtest/test.cfg b/testsuite/java_test/rc_test/RC0408-rc-DTS-OOMtest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d1dd898e2d833aa41d61f76cae044884edf4b7b2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0408-rc-DTS-OOMtest/test.cfg
@@ -0,0 +1,2 @@
+compile(OOMtest)
+run(OOMtest,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0409-rc-DTS-Ex_eight_arguments/Ex_eight_arguments.java b/testsuite/java_test/rc_test/RC0409-rc-DTS-Ex_eight_arguments/Ex_eight_arguments.java
new file mode 100755
index 0000000000000000000000000000000000000000..97e99a9185aef2e9dc9e15f87903392664a91df2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0409-rc-DTS-Ex_eight_arguments/Ex_eight_arguments.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Array;
+public class Ex_eight_arguments {
+    static int check_count = 0;
+    public static void main(String[] args) {
+        int first = 1988;
+        byte second = 2;
+        char third = 'g';
+        long four = 19881110;
+        float five = 601.5f;
+        double six = 60.15f;
+        String seven = "huawei";
+        boolean eight = true;
+        Object nine = new String("CC is a cat");
+        int[] ten = {2012, 2020, 2019, 2040, 3301};
+        Ex_eight_arguments Test = new Ex_eight_arguments();
+        //test static method no return no exception
+        test01(first, second, third, four, five, six, seven, eight, nine, ten);
+        //test no static method no return no exception
+        Test.test02(first, second, third, four, five, six, seven, eight, nine, ten);
+        //test no static method return value no exception
+        first = Test.test03(first, second, third, four, five, six, seven, eight, nine, ten);
+        //test no static method no return throws exception
+        try {
+            Test.test04(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test04 not catch Exception");
+        } catch (ArrayIndexOutOfBoundsException e) {
+            check_count++;
+        }
+        //test static method return value no exception
+        seven = test05(first, second, third, four, five, six, seven, eight, nine, ten);
+        //test static method no return value throws exception
+        try {
+            test06(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test06 not catch Exception");
+        } catch (IllegalArgumentException e) {
+            check_count++;
+        }
+        //test no static method return value throws exception
+        try {
+            boolean result7 = Test.test07(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test07 not catch Exception");
+        } catch (ArithmeticException e) {
+            check_count++;
+        }
+        //test static method return value throws exception
+        try {
+            int[] result8 = test08(first, second, third, four, five, six, seven, eight, nine, ten);
+            System.out.println("ErrorResult in test08 not catch Exception");
+        } catch (NegativeArraySizeException e) {
+            check_count++;
+        }
+        //Result judgment
+        if (check_count == 12)
+            System.out.println("ExpectResult");
+        //System.out.println(check_count);
+    }
+    private static void test01(int first, byte second, char third, long four, float five, double six, String seven,
+                               boolean eight, Object nine, int[] ten) {
+        /*test static method no return no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1989 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test01");
+    }
+    private static String test05(int first, byte second, char third, long four, float five, double six, String seven,
+                                 Boolean eight, Object nine, int[] ten) {
+        /*test static method return value no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test05");
+        return new String("test05 is End");
+    }
+    private static void test06(int first, byte second, char third, long four, float five, double six, String seven,
+                               Boolean eight, Object nine, int[] ten) throws IllegalArgumentException {
+        /*test static method no return value throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        int[][] test_ten = {ten, ten, ten, ten, ten, ten};
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test06");
+        Array.getInt(test_ten, 5);
+    }
+    private static int[] test08(int first, byte second, char third, long four, float five, double six, String seven,
+                                Boolean eight, Object nine, int[] ten) throws NegativeArraySizeException {
+        /*test static method return value throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        int[][] test_ten = {ten, ten, ten, ten, ten, ten};
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test08");
+        int[] chck = new int[-1];
+        return chck;
+    }
+    private void test02(int first, byte second, char third, long four, float five, double six, String seven,
+                        Boolean eight, Object nine, int[] ten) {
+        /*test no static method no return no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1989 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test02");
+    }
+    private int test03(int first, byte second, char third, long four, float five, double six, String seven,
+                       Boolean eight, Object nine, int[] ten) {
+        /*test no static method return value no exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1989 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test03");
+        return first;
+    }
+    private void test04(int first, byte second, char third, long four, float five, double six, String seven,
+                        Boolean eight, Object nine, int[] ten) throws ArrayIndexOutOfBoundsException {
+        /*test no static method no return throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test04");
+        ten[5] = 1988;
+    }
+    private boolean test07(int first, byte second, char third, long four, float five, double six, String seven,
+                           Boolean eight, Object nine, int[] ten) throws ArithmeticException {
+        /*test no static method return value throws exception*/
+        first++;
+        second = 56;
+        third = (char) second;
+        four = (long) third;
+        five = (float) four;
+        six = (double) five;
+        seven = "fei fei is not a pig";
+        eight = false;
+        nine = (Object) eight;
+        ten = ten.clone();
+        int[][] test_ten = {ten, ten, ten, ten, ten, ten};
+        if (first == 1990 && second == 56 && third == '8' && four == 56 && five == 56f && six == 56f && seven == "fei fei is not a pig"
+                && eight == false && nine == (Object) false && ten[4] == 3301)
+            check_count++;
+        else
+            System.out.println("ErrorResult in test07");
+        first = first / 0;
+        return true;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0409-rc-DTS-Ex_eight_arguments/expected.txt b/testsuite/java_test/rc_test/RC0409-rc-DTS-Ex_eight_arguments/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0409-rc-DTS-Ex_eight_arguments/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0409-rc-DTS-Ex_eight_arguments/test.cfg b/testsuite/java_test/rc_test/RC0409-rc-DTS-Ex_eight_arguments/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..38e8f2c22a40774d281f12ad8b9406031d0d2cc0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0409-rc-DTS-Ex_eight_arguments/test.cfg
@@ -0,0 +1,2 @@
+compile(Ex_eight_arguments)
+run(Ex_eight_arguments,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0410-rc-Memory-stressTestCase29/Memory_stressTestCase29.java b/testsuite/java_test/rc_test/RC0410-rc-Memory-stressTestCase29/Memory_stressTestCase29.java
new file mode 100755
index 0000000000000000000000000000000000000000..27cb9d2d8fb94a0d4f2968f1ae90ffce90fbccb6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0410-rc-Memory-stressTestCase29/Memory_stressTestCase29.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import sun.misc.Cleaner;
+public class Memory_stressTestCase29 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM = INIT_DEFAULT_THREAD_NUM;
+    static List<List<AllocUnit>> mAllThread = new ArrayList<List<AllocUnit>>();
+    public static void main(String[] args) {
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        Runtime.getRuntime().gc();
+        testCase29();
+        System.out.println("ExpectResult");
+    }
+    public static void testCase29() {
+        ArrayList<Thread> list = new ArrayList<>();
+        for (int i = 0; i < (DEFAULT_THREAD_NUM / 10); i++) {
+            list.add(new StopAbleThread(() -> {
+                ArrayList<Memory_stressTestCase29.AllocUnitwithVerifyCleaner> units = new ArrayList<>();
+                Random r = new Random();
+                for (int j = 0; j < 100; j++) {
+                    units.add(new Memory_stressTestCase29.AllocUnitwithVerifyCleaner(r.nextInt(512)));
+                }
+                trySleep(r.nextInt(500));
+                for (Memory_stressTestCase29.AllocUnitwithVerifyCleaner unit : units) {
+                    unit.CanbeFree();
+                }
+                units.clear();
+            }, "testCase29_alloc_" + (i + 1)));
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    public static class StopAbleThread extends Thread {
+        public static boolean mRuning = true;
+        static List<List<AllocUnit>> mAllThread = new ArrayList<List<AllocUnit>>();
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+    public static class AllocUnit {
+        public byte unit[];
+        public AllocUnit(int arrayLength) {
+            unit = new byte[arrayLength];
+        }
+    }
+    public static class AllocUnitwithVerifyCleaner extends AllocUnit {
+        static final int FLAG_INUSE = 0x112233;
+        static final int FLAG_CANBECLEAN = 0xddee;
+        static final int FLAG_CLEARED = 0xaabb;
+        public CleanerStatus status;
+        public AllocUnitwithVerifyCleaner(int arrayLength) {
+            super(arrayLength);
+            status = new CleanerStatus();
+            this.cleaner = Cleaner.create(this, new TestCleaner(status));
+        }
+        private final Cleaner cleaner;
+        private static class CleanerStatus {
+            public int status;
+            CleanerStatus() {
+                status = FLAG_INUSE;
+            }
+        }
+        public void CanbeFree() {
+            if (this.status.status != FLAG_INUSE) {
+                throw new NullPointerException();
+            }
+            this.status.status = FLAG_CANBECLEAN;
+        }
+        private static class TestCleaner implements Runnable {
+            public CleanerStatus status;
+            public TestCleaner(CleanerStatus status) {
+                this.status = status;
+            }
+            public void run() {
+                if (this.status.status != FLAG_CANBECLEAN) {
+                }
+                this.status.status = FLAG_CLEARED;
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0410-rc-Memory-stressTestCase29/expected.txt b/testsuite/java_test/rc_test/RC0410-rc-Memory-stressTestCase29/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0410-rc-Memory-stressTestCase29/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0410-rc-Memory-stressTestCase29/test.cfg b/testsuite/java_test/rc_test/RC0410-rc-Memory-stressTestCase29/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..15a8575b062275a36aad24f23c3cc0515ae584db
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0410-rc-Memory-stressTestCase29/test.cfg
@@ -0,0 +1,2 @@
+compile(Memory_stressTestCase29)
+run(Memory_stressTestCase29,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3/RCUnownedRefTest3.java b/testsuite/java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3/RCUnownedRefTest3.java
new file mode 100755
index 0000000000000000000000000000000000000000..db3d9a1a75114e8b706fb8b73b46441935d7154d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3/RCUnownedRefTest3.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import java.util.LinkedList;
+import java.util.List;
+public class RCUnownedRefTest3 {
+    public static void main(String[] args) {
+        UnownedAnnoymous unownedAnnoymous = new UnownedAnnoymous();
+        unownedAnnoymous.anonymousCapture("test");
+        UnownedLambda unownedLambda = new UnownedLambda();
+        List<String> list = new LinkedList<>();
+        list.add("test");
+        unownedLambda.lambdaCapture(list, "test");
+        if (unownedAnnoymous.checkAnnoy == true && unownedLambda.checkLambda == true) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+class UnownedLambda {
+    String name;
+    static boolean checkLambda = false;
+    void lambdaCapture(List<String> list, String suffix) {
+        final @Unowned String capSuffix = suffix;
+        final @Unowned UnownedLambda self = this;
+        list.forEach((str) -> {
+            if ((self.name + str + capSuffix).equals("nulltesttest")) {
+                checkLambda = true;
+            }
+        });
+    }
+}
+class UnownedAnnoymous {
+    String name;
+    static boolean checkAnnoy = false;
+    void anonymousCapture(String suffix) {
+        final @Unowned String capSuffix = suffix;
+        Runnable r = new Runnable() {
+            @Override
+            public void run() {
+                if ((name + capSuffix).equals("nulltest")) {
+                    checkAnnoy = true;
+                }
+            }
+        };
+        r.run();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3/test.cfg b/testsuite/java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fa975bc354c33dd28a818396a92e328152dd0166
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0417-rc-Annotation-RCUnownedRefTest3/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedRefTest3)
+run(RCUnownedRefTest3,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3/RCUnownedRefThreadTest3.java b/testsuite/java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3/RCUnownedRefThreadTest3.java
new file mode 100755
index 0000000000000000000000000000000000000000..f0512ff7615ae220cfaa10699831983b41bcd632
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3/RCUnownedRefThreadTest3.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+import java.util.LinkedList;
+import java.util.List;
+class RCUnownedRefTest3 extends Thread {
+    private boolean checkout;
+    public void run() {
+        UnownedAnnoymous unownedAnnoymous = new UnownedAnnoymous();
+        unownedAnnoymous.anonymousCapture("test");
+        UnownedLambda unownedLambda = new UnownedLambda();
+        List<String> list = new LinkedList<>();
+        list.add("test");
+        unownedLambda.lambdaCapture(list, "test");
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (unownedAnnoymous.checkAnnoy == true && unownedLambda.checkLambda == true) {
+            checkout = true;
+        } else {
+            System.out.println("unownedAnnoymous.checkAnnoy:" + unownedAnnoymous.checkAnnoy);
+            System.out.println("unownedLambda.checkLambda:" + unownedLambda.checkLambda);
+            System.out.println("555555555555555");
+            checkout = false;
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+class UnownedLambda {
+    String name;
+    static boolean checkLambda;
+    void lambdaCapture(List<String> list, String suffix) {
+        checkLambda = false;
+        final String capSuffix = suffix;
+        final UnownedLambda self = this;
+        list.forEach((str) -> {
+            if ((self.name + str + capSuffix).equals("nulltesttest")) {
+                checkLambda = true;
+            } else {
+                System.out.println("self.name + str + capSuffix:" + self.name + "  " + str + "  " + capSuffix);
+            }
+        });
+    }
+}
+class UnownedAnnoymous {
+    String name;
+    static boolean checkAnnoy;
+    void anonymousCapture(String suffix) {
+        checkAnnoy = false;
+        final @Unowned String capSuffix = suffix;
+        Runnable r = new Runnable() {
+            @Override
+            public void run() {
+                if ((name + capSuffix).equals("nulltest")) {
+                    checkAnnoy = true;
+                } else {
+                    System.out.println("name + capSuffix:" + name + "   " + capSuffix);
+                }
+            }
+        };
+        r.run();
+    }
+}
+public class RCUnownedRefThreadTest3 {
+    public static void main (String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCUnownedRefTest3 rcTest1 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest2 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest3 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest4 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest5 = new RCUnownedRefTest3();
+        RCUnownedRefTest3 rcTest6 = new RCUnownedRefTest3();
+        rcTest1.start();
+        rcTest2.start();
+        rcTest3.start();
+        rcTest4.start();
+        rcTest5.start();
+        rcTest6.start();
+        try {
+            rcTest1.join();
+            rcTest2.join();
+            rcTest3.join();
+            rcTest4.join();
+            rcTest5.join();
+            rcTest6.join();
+        } catch (InterruptedException e) {
+        }
+        Thread.sleep(2000);
+        if (rcTest1.check() && rcTest2.check() && rcTest3.check() && rcTest4.check() && rcTest5.check() && rcTest6.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcTest1.check():" + rcTest1.check());
+            System.out.println("rcTest2.check():" + rcTest2.check());
+            System.out.println("rcTest3.check():" + rcTest3.check());
+            System.out.println("rcTest4.check():" + rcTest4.check());
+            System.out.println("rcTest5.check():" + rcTest5.check());
+            System.out.println("rcTest6.check():" + rcTest6.check());
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3/test.cfg b/testsuite/java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..85dc9036973f529579c4fa0d6e1cd01f3575378a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0418-rc-Annotation-RCUnownedRefThreadTest3/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedRefThreadTest3)
+run(RCUnownedRefThreadTest3,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest/RCUnownedLocalTest.java b/testsuite/java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest/RCUnownedLocalTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..e5ab8672fdc5b5ca3acc2f2080efc42e396e77c6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest/RCUnownedLocalTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.UnownedLocal;
+import java.util.LinkedList;
+import java.util.List;
+public class RCUnownedLocalTest {
+    static Integer a = new Integer(1);
+    static Object[] arr = new Object[]{1, 2, 3};
+    @UnownedLocal
+    static int method(Integer a, Object[] arr) {
+        int check = 0;
+        Integer c = a + a;
+        if (c == 2) {
+            check++;
+        } else {
+            check--;
+        }
+        for (Object array : arr) {
+            //System.out.println(array);
+            check++;
+        }
+        return check;
+    }
+    public static void main(String[] args) {
+        int result = method(a, arr);
+        if (result == 4) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest/test.cfg b/testsuite/java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c9366d8891dd272c39a5b983f1a6142710f49a89
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0419-rc-Annotation-RCUnownedLocalTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedLocalTest)
+run(RCUnownedLocalTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest/RCUnownedLocalThreadTest.java b/testsuite/java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest/RCUnownedLocalThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8b065211bb05da2226b5a6f5725d7f893942cb05
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest/RCUnownedLocalThreadTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.*;
+import java.util.LinkedList;
+import java.util.List;
+class RCUnownedLocalTest extends Thread {
+    private boolean checkout;
+    Integer a = new Integer(1);
+    Object[] arr = new Object[]{1, 2, 3};
+    @UnownedLocal
+    int method(Integer a, Object[] arr) {
+        int check = 0;
+        Integer c = a + a;
+        if (c == 2) {
+            check++;
+        } else {
+            check--;
+        }
+        for (Object array : arr) {
+            //System.out.println(array);
+            check++;
+        }
+        return check;
+    }
+    public void run() {
+        int result = method(a, arr);
+        if (result == 4) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println("result:" + result);
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+public class RCUnownedLocalThreadTest {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RCUnownedLocalTest rcTest1 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest2 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest3 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest4 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest5 = new RCUnownedLocalTest();
+        RCUnownedLocalTest rcTest6 = new RCUnownedLocalTest();
+        rcTest1.start();
+        rcTest2.start();
+        rcTest3.start();
+        rcTest4.start();
+        rcTest5.start();
+        rcTest6.start();
+        try {
+            rcTest1.join();
+            rcTest2.join();
+            rcTest3.join();
+            rcTest4.join();
+            rcTest5.join();
+            rcTest6.join();
+        } catch (InterruptedException e) {
+        }
+        if (rcTest1.check() && rcTest2.check() && rcTest3.check() && rcTest4.check() && rcTest5.check() && rcTest6.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest/test.cfg b/testsuite/java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f3d32bb5de4cfa9fec60ca5fdf50028350583409
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0420-rc-Annotation-RCUnownedLocalThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedLocalThreadTest)
+run(RCUnownedLocalThreadTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest/RCUnownedOuterTest.java b/testsuite/java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest/RCUnownedOuterTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..472a6a1a620e90f2373bed23bd077b752382ae79
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest/RCUnownedOuterTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.UnownedOuter;
+import java.util.LinkedList;
+import java.util.List;
+public class RCUnownedOuterTest {
+    public static void main(String[] args) {
+        UnownedAnnoymous unownedAnnoymous = new UnownedAnnoymous();
+        unownedAnnoymous.anonymousCapture();
+        UnownedInner unownedInner = new UnownedInner();
+        unownedInner.method();
+        UnownedInner.InnerClass innerClass = unownedInner.new InnerClass();
+        innerClass.myName();
+        if (unownedAnnoymous.checkAnnoy == 1 && unownedInner.checkInner == 1) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("unownedAnnoymous.checkAnnoy:" + unownedAnnoymous.checkAnnoy);
+            System.out.println("unownedInner.checkInner:" + unownedInner.checkInner);
+        }
+    }
+}
+class UnownedInner {
+    String name = "test";
+    int checkInner = 0;
+    InnerClass innerClass;
+    void method() {
+        innerClass = new InnerClass();
+    }
+    @UnownedOuter
+    class InnerClass {
+        void myName() {
+            checkInner = 0;
+            String myname;
+            myname = name + name;
+            if (myname.equals("testtest")) {
+                checkInner++;
+            }
+        }
+    }
+}
+class UnownedAnnoymous {
+    String name = "test";
+    static int checkAnnoy;
+    void anonymousCapture() {
+        Runnable r = new Runnable() {
+            @UnownedOuter
+            @Override
+            public void run() {
+                checkAnnoy = 0;
+                String myName = name + name;
+                if (myName.equals("testtest")) {
+                    checkAnnoy++;
+                }
+            }
+        };
+        r.run();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest/test.cfg b/testsuite/java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b64cbf643d2a4734bc08d28e6a827c55e95a569
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0421-rc-Annotation-RCUnownedOuterTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedOuterTest)
+run(RCUnownedOuterTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0431-rc-SoftRef-SoftRefTest/SoftRefTest.java b/testsuite/java_test/rc_test/RC0431-rc-SoftRef-SoftRefTest/SoftRefTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..26e309311e5812e3e21e866e5e99da3739fafb03
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0431-rc-SoftRef-SoftRefTest/SoftRefTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+public class SoftRefTest {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+        new Thread(new TriggerRP()).start();
+        if (rp.get() == null) {
+            System.out.println("Error Result when second check ");
+            a++;
+        }
+        Reference r = rq.poll();
+        if (r != null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+    }
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 60; i++) {
+                SoftReference sr = new SoftReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0431-rc-SoftRef-SoftRefTest/expected.txt b/testsuite/java_test/rc_test/RC0431-rc-SoftRef-SoftRefTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0431-rc-SoftRef-SoftRefTest/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0431-rc-SoftRef-SoftRefTest/test.cfg b/testsuite/java_test/rc_test/RC0431-rc-SoftRef-SoftRefTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9ac82156264f579e2b9c287c5a208a3dba451912
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0431-rc-SoftRef-SoftRefTest/test.cfg
@@ -0,0 +1,2 @@
+compile(SoftRefTest)
+run(SoftRefTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0432-rc-SoftRef-SoftRefTest02/SoftRefTest02.java b/testsuite/java_test/rc_test/RC0432-rc-SoftRef-SoftRefTest02/SoftRefTest02.java
new file mode 100755
index 0000000000000000000000000000000000000000..50a5bb511f6ed1865cac90f477203a713492b311
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0432-rc-SoftRef-SoftRefTest02/SoftRefTest02.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+public class SoftRefTest02 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+        for (int i = 0; i < 3; i++) {
+            System.gc();
+            if (rp.get() == null) {
+                System.out.println("Error Result when second check ");
+                a++;
+            }
+        }
+        Reference r = rq.poll();
+        if (r != null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0432-rc-SoftRef-SoftRefTest02/expected.txt b/testsuite/java_test/rc_test/RC0432-rc-SoftRef-SoftRefTest02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0432-rc-SoftRef-SoftRefTest02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0432-rc-SoftRef-SoftRefTest02/test.cfg b/testsuite/java_test/rc_test/RC0432-rc-SoftRef-SoftRefTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..96ea8eb56c6245bf5923fe9b1be1df296ae5273e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0432-rc-SoftRef-SoftRefTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(SoftRefTest02)
+run(SoftRefTest02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03/SoftRefTest03.java b/testsuite/java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03/SoftRefTest03.java
new file mode 100755
index 0000000000000000000000000000000000000000..0c40fb00b1d5725efbe4ae3ebd815c636cf5bb1d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03/SoftRefTest03.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+public class SoftRefTest03 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+        for (int i = 0; i < 3; i++) {
+            Runtime.getRuntime().gc();
+            Runtime.getRuntime().runFinalization();
+            if (rp.get() == null) {
+                System.out.println("Error Result when second check ");
+                a++;
+                break;    //rp指向的对象不应该被释放，如果出现释放，则打印、a++;然后break跳出循环
+            }
+        }
+        Reference r = rq.poll();    //ReferenceQueue里不应该有对象，poll返回值应该是空指针
+        if (r != null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03/expected.txt b/testsuite/java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03/test.cfg b/testsuite/java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..567e40f3294641122747db0959d9d654f04876ee
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0433-rc-SoftRef-SoftRefTest03/test.cfg
@@ -0,0 +1,2 @@
+compile(SoftRefTest03)
+run(SoftRefTest03,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0435-rc-SoftRef-SoftRefTest05/SoftRefTest05.java b/testsuite/java_test/rc_test/RC0435-rc-SoftRef-SoftRefTest05/SoftRefTest05.java
new file mode 100755
index 0000000000000000000000000000000000000000..07aa576a47e0cd743c00cb8b3ea9892585f36472
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0435-rc-SoftRef-SoftRefTest05/SoftRefTest05.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+public class SoftRefTest05 {
+    static final int TEST_NUM = 1;
+    static int check_count = 0;
+    static int allSum;
+    public static void main(String[] args) {
+        for (int i = 0; i < TEST_NUM; i++) {
+            test_01();
+            Runtime.getRuntime().gc();
+            // resultLine = null;
+            test_01();
+            if (allSum == 20) {
+                check_count++;
+                System.out.println("sum is srong");
+            }
+            if (check_count == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println(" errorResult ----checkcount" + check_count);
+            }
+        }
+    }
+    private static void test_01() {
+        Cycle_A a1 = new Cycle_A();
+        a1.cyb = new Cycle_B();
+        a1.cyb.cyc = new Cycle_C();
+        a1.cyb.cyc.cyd = new Cycle_D();
+        a1.cyb.cyc.cyd.cya = a1;
+        allSum = a1.sum + a1.cyb.sum + a1.cyb.cyc.sum + a1.cyb.cyc.cyd.sum;
+        sleep(4000);
+        if ((a1.sr.get() == null) || (a1.cyb.sr.get() == null) || (a1.cyb.cyc.pr.get() == null) || (a1.cyb.cyc.cyd.str.get() == null)) {
+            check_count++;
+        }
+    }
+    private static void sleep(int sleepnum) {
+        try {
+            Thread.sleep(sleepnum);
+        } catch (InterruptedException e) {
+            System.out.println(Thread.currentThread().getStackTrace()[2].getClassName() + " sleep was Interrupted");
+        }
+    }
+}
+class Cycle_A {
+    static StringBuffer a = new StringBuffer("ref_processor_cycle_A");
+    Reference sr;
+    Cycle_B cyb;
+    int aNum;
+    int sum;
+    Cycle_A() {
+        a = new StringBuffer("ref_processor_cycle_A");
+        sr = new SoftReference(a);
+        if (sr.get() == null) {
+            assert false;
+        }
+        a = null;
+        cyb = null;
+        aNum = 1;
+    }
+    int joinStr() {
+        try {
+            sum = aNum + cyb.bNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+class Cycle_B {
+    static StringBuffer b = new StringBuffer("ref_processor_cycle_B");
+    Reference sr;
+    Cycle_C cyc;
+    int bNum;
+    int sum;
+    Cycle_B() {
+        b = new StringBuffer("ref_processor_cycle_B");
+        sr = new SoftReference<>(b);
+        if (sr.get() == null) {
+            assert false;
+        }
+        b = null;
+        cyc = null;
+        bNum = 2;
+    }
+    int joinStr() {
+        try {
+            sum = bNum + cyc.cNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+class Cycle_C {
+    Reference pr;
+    Cycle_D cyd;
+    StringBuffer c = new StringBuffer("ref_processor_cycle_C");
+    int sum;
+    int cNum;
+    Cycle_C() {
+        c = new StringBuffer("ref_processor_cycle_C");
+        pr = new SoftReference<>(c);
+        if (pr.get() == null) {
+            assert false;
+        }
+        c = null;
+        cyd = null;
+        cNum = 3;
+    }
+    int joinStr() {
+        try {
+            sum = cNum + cyd.dNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
+class Cycle_D {
+    Reference str;
+    Cycle_A cya;
+    StringBuffer d = new StringBuffer("ref_processor_cycle_D");
+    int dNum;
+    int sum;
+    Cycle_D() {
+        d = new StringBuffer("ref_processor_cycle_D");
+        str = new SoftReference<StringBuffer>(d);
+        d = null;
+        cya = null;
+        dNum = 4;
+    }
+    int joinStr() {
+        try {
+            int sum = dNum + cya.aNum;
+        } catch (Exception e) {
+        }
+        return sum;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0435-rc-SoftRef-SoftRefTest05/expected.txt b/testsuite/java_test/rc_test/RC0435-rc-SoftRef-SoftRefTest05/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0435-rc-SoftRef-SoftRefTest05/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0435-rc-SoftRef-SoftRefTest05/test.cfg b/testsuite/java_test/rc_test/RC0435-rc-SoftRef-SoftRefTest05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..818728ee190acf7205512cfd353e7bf4524a5b73
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0435-rc-SoftRef-SoftRefTest05/test.cfg
@@ -0,0 +1,2 @@
+compile(SoftRefTest05)
+run(SoftRefTest05,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/RCHeaderTest04.java b/testsuite/java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/RCHeaderTest04.java
new file mode 100755
index 0000000000000000000000000000000000000000..02f6f0a2911863ddeee1078fb61b4358be688bcb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/RCHeaderTest04.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.lang.ref.SoftReference;
+import com.huawei.ark.annotation.Weak;
+class RCRunner04 implements Runnable {
+    public void run() {
+        RCHeaderTest04.iArray = null;
+    }
+}
+public class RCHeaderTest04 {
+    static int[] iArray;
+    @Weak
+    static int[] wr_annotation = null;
+    static Cleaner c = null;
+    static SoftReference<int[]> sr = null;
+    public RCHeaderTest04() {
+        iArray = new int[4];
+        int[] temp = {1, 2, 3, 4};
+        wr_annotation = temp;
+        sr = new SoftReference<>(temp);
+    }
+    //方法退出后，实例变量sr声明周期结束，触发对SoftReference的处理，它指向的数组占用空间被释放。
+    static void foo() {
+        RCHeaderTest04 rcht = new RCHeaderTest04();
+        c = Cleaner.create(rcht.sr, new RCRunner04());
+        if (c == null && wr_annotation.length != 4) {
+            System.out.println("Cleaner create failly");
+        }
+    }
+    public static void main(String[] args) {
+        foo();
+        Runtime.getRuntime().runFinalization();
+        if (c != null && wr_annotation != null && sr.get() != null) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/expected.txt b/testsuite/java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/test.cfg b/testsuite/java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d6c701c6d2e6d2175a1d03ffe28f6ca1d9e59c6c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0440-rc-RCHeader-RCHeaderTest04/test.cfg
@@ -0,0 +1,2 @@
+compile(RCHeaderTest04)
+run(RCHeaderTest04,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/PlacementRCTest01.java b/testsuite/java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/PlacementRCTest01.java
new file mode 100755
index 0000000000000000000000000000000000000000..66fe2f3304d975b9df6fed67f45ab82d26cc8520
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/PlacementRCTest01.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class B {
+    static A a;
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class A {
+    public int count = 0;
+    public String className = "A";
+    public A(String name) {
+        this.className = name;
+    }
+    public void changeName(String name) {
+        this.className = name;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        synchronized (PlacementRCTest01.lock) {
+            if (this.count % 25 == 0) {
+                PlacementRCTest01.result += ("End");
+            }
+        }
+        B.a = this;
+    }
+}
+public class PlacementRCTest01 {
+    public volatile static String result = new String();
+    public static String lock = "";
+    private static volatile int count = 0;
+    private static A infiniteLoop = null;
+    private A defInsideUseOutside = null;
+    public static void onlyUseInsideLoop() {
+        A a1 = new A("a1");
+        for (count = 0; count < 100; count++) {
+            a1.changeName("a" + count);
+	    a1.count = count;
+            if (count == 99)
+                a1.toString();
+        }
+        Runtime.getRuntime().runFinalization();
+		//try{ Thread.sleep(5000); } catch( Exception e ){ }
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method1";
+        }
+    }
+    public static void defAndUseInsideLoop() {
+        for (count = 0; count < 100; count++) {
+            A a2 = new A("a2_i" + count);
+	    a2.count = count;
+            a2.changeName("null");
+            for (int j = 0; j < 5; j++) {
+                a2 = new A("a2_i" + count + "_j" + j);
+            }
+            if (count == 99) {
+                a2.toString();
+            }
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method2";
+        }
+    }
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        do {
+            this.defInsideUseOutside = new A("a2_i" + count);
+	    this.defInsideUseOutside.count = count;
+            for (int j = 0; j < 2; j++)
+                this.defInsideUseOutside = new A("a2_i" + count + "_j" + j);
+            if (count == 99)
+                this.defInsideUseOutside.toString();
+            count++;
+        } while (this.defInsideUseOutside.count < 100 && count < 100);
+        this.defInsideUseOutside.changeName("finish");
+        this.defInsideUseOutside = null;
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method3";
+        }
+    }
+    public static void defInBranchInsideLoop() {
+        A a4 = new A("a4");
+        for (count = 0; count < 100; count++) {
+            a4.changeName("a" + count);
+	    a4.count = count;
+            if (count % 2 == 0) {
+                a4 = new A("a4_" + count);
+            }
+            a4.toString();
+        }
+        a4.changeName("End");
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method4";
+        }
+    }
+    public static void infiniteLoop() {
+        infiniteLoop = new A("infinite loop");
+        count = 0;
+        while (count < 100) {
+            A a5 = new A("a2_i" + count);
+            a5.changeName("null");
+	    a5.count = count;
+            infiniteLoop.changeName("infinite loop" + count);
+            for (int j = 0; j < 2; j++) {
+                a5 = new A("a2_i" + count + "_j" + j);
+            }
+            if (count == 99) {
+                a5.toString();
+            }
+            count++;
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest01.lock) {
+            result += "Method5";
+        }
+    }
+    public static void main(String[] args) {
+        onlyUseInsideLoop();	
+        defAndUseInsideLoop();
+        new PlacementRCTest01().defInsideAndUseOutsideLoop();
+        defInBranchInsideLoop();
+        infiniteLoop();
+        //System.out.println(result);
+        if(result.contains("Method1") && result.contains("Method2") && result.contains("Method3") && result.contains("Method4") && result.contains("Method5") && result.contains("End") && infiniteLoop.className.equals("infinite loop99"))
+            System.out.println("ExpectResult");
+        else
+            System.out.println("ErrorResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/expected.txt b/testsuite/java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/test.cfg b/testsuite/java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b2ab5353a19ba6d80c3d33cd622fe615fb583e76
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0443-rc-PlacementRC-PlacementRCTest01/test.cfg
@@ -0,0 +1,2 @@
+compile(PlacementRCTest01)
+run(PlacementRCTest01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02/PlacementRCTest02.java b/testsuite/java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02/PlacementRCTest02.java
new file mode 100755
index 0000000000000000000000000000000000000000..617658ea5aa7cda971954665ab33abe3c0006786
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02/PlacementRCTest02.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class PlacementRC_A2 {
+    public int count = 0;
+    public String className = "A";
+    public PlacementRC_A2(String name) {
+        this.className = name;
+    }
+    public void changeName(String name) {
+        this.className = name;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        synchronized (PlacementRCTest02.lock) {
+            if (this.count % 25 == 0) {
+                PlacementRCTest02.result += ("End" + count);
+            }
+        }
+    }
+}
+public class PlacementRCTest02 {
+    public static String result = new String();
+    public static String lock = "";
+    private volatile static int count = 0;
+    private PlacementRC_A2 defInsideUseOutside = null;
+    public static void onlyUseInsideLoop() {
+        PlacementRC_A2 a1 = new PlacementRC_A2("a1");
+        for (count = 0; count < 100; count++) {
+            a1.changeName("a" + count);
+            a1.count = count;
+            if (count % 11 == 0) {
+                a1.changeName("a" + 100);
+                a1 = new PlacementRC_A2("a10");
+                a1.toString();
+            }
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest02.lock) {
+            result += "Method1";
+        }
+    }
+    public static void defAndUseInsideLoop() {
+        for (count = 0; count < 100; count++) {
+            PlacementRC_A2 a2 = new PlacementRC_A2("a2_i" + count);
+            a2.changeName("null");
+            a2.count = count;
+            for (int j = 0; j < 2; j++)
+                a2 = new PlacementRC_A2("a2_i" + count + "_j" + j);
+            if (count % 11 == 0) {
+                a2.changeName("a" + 100);
+                a2 = new PlacementRC_A2("a10");
+                a2.toString();
+            } else {
+                a2.toString();
+            }
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest02.lock) {
+            result += "Method2";
+        }
+    }
+    public static void main(String[] args) {
+        onlyUseInsideLoop();
+        defAndUseInsideLoop();
+        new PlacementRCTest02().defInsideAndUseOutsideLoop();
+        //System.out.println(result);
+        if(result.contains("Method1") && result.contains("Method2") && result.contains("Method3") && result.contains("End"))
+            System.out.println("ExpectResult");
+        else
+            System.out.println("Error Result");
+    }
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        do {
+            int choice = count % 4;
+            this.defInsideUseOutside = new PlacementRC_A2("a2_i" + count);
+            switch (choice) {
+                case 1:
+                    for (int j = 0; j < 2; j++) {
+                        this.defInsideUseOutside = new PlacementRC_A2("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    if (count == 99)
+                        this.defInsideUseOutside.toString();
+                    break;
+                case 2:
+                    for (int j = 0; j < 2; j++) {
+                        this.defInsideUseOutside.changeName("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    break;
+                case 3:
+                    for (int j = 0; j < 2; j++) {
+                        this.defInsideUseOutside = new PlacementRC_A2("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    if (this.defInsideUseOutside.className.equals("a2_i95_j4"))
+                        System.out.println(this.defInsideUseOutside.className);
+                    break;
+                default:
+                    this.defInsideUseOutside = new PlacementRC_A2("a2_i" + count);
+                    this.defInsideUseOutside.count = count;
+            }
+            count++;
+        } while (this.defInsideUseOutside.count < 100 && count < 100);
+        this.defInsideUseOutside.changeName("finish");
+        this.defInsideUseOutside = null;
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest02.lock) {
+            result += "Method3";
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02/test.cfg b/testsuite/java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e6c8697312ef5fd31f17b3e81324f702d1988d9b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0444-rc-PlacementRC-PlacementRCTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(PlacementRCTest02)
+run(PlacementRCTest02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04/PlacementRCTest04.java b/testsuite/java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04/PlacementRCTest04.java
new file mode 100755
index 0000000000000000000000000000000000000000..1860e72f6a97de8caaa7a481fe8d7e0471280696
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04/PlacementRCTest04.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.IllegalFormatException;
+class PlacementRC_A4 {
+    public int count = 0;
+    public String className = "A";
+    public PlacementRC_A4(String name) {
+        this.className = name;
+    }
+    public void changeName(String name) {
+        this.className = name;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        synchronized (PlacementRCTest04.lock) {
+            PlacementRCTest04.result += "End";
+        }
+    }
+}
+public class PlacementRCTest04 {
+    public static String result = "";
+    public static String lock = "";
+    static int res = 99;
+    public static void main(String[] argv) {
+        run1();
+        Runtime.getRuntime().runFinalization();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (result.contains("run1") && result.contains("run4") && result.contains("run5") && result.contains("run3")
+                && result.contains("run2") && result.contains("End")) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+    private static int run1() {
+        int result = 2;
+        PlacementRC_A4 place = new PlacementRC_A4("run4");
+        try {
+            place.className = "run1";
+            synchronized (PlacementRCTest04.lock) {
+                PlacementRCTest04.result += "run1";
+            }
+            result = run2();
+        } catch (StringIndexOutOfBoundsException e) {
+            res--;
+        }
+        if (res == 96) {
+            result = 0;
+            res--;
+        }
+        return result;
+    }
+    private static int run2() {
+        int result = 2;
+        try {
+            PlacementRC_A4 place = new PlacementRC_A4("run4");
+            result = run3();
+            place.changeName("run2");
+            synchronized (PlacementRCTest04.lock) {
+                PlacementRCTest04.result += "run2";
+            }
+        } catch (ClassCastException e) {
+            res -= 2;
+        }
+        if (res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int run3() {
+        int result = 3;
+        try {
+            result = run4();
+            PlacementRC_A4 place = new PlacementRC_A4("run4");
+            synchronized (PlacementRCTest04.lock) {
+                place.className = "run3";
+            }
+            PlacementRCTest04.result += place.className;
+        } catch (IllegalStateException e) {
+            res -= 3;
+        }
+        if (res == 94) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int run4() {
+        int result = 4;
+        try {
+            PlacementRC_A4 place = new PlacementRC_A4("run4");
+            place.className = "run4";
+            synchronized (PlacementRCTest04.lock) {
+                PlacementRCTest04.result += "run4";
+            }
+            result = run5();
+        } catch (IllegalFormatException e) {
+            res -= 4;
+        }
+        if (res == 93) {
+            result = 0;
+        }
+        return result;
+    }
+    private static int run5() {
+        int result = 5;
+        try {
+            result = ExcpCover03330();
+        } catch (Exception e) {
+            res -= 5;
+        }
+        PlacementRC_A4 place = new PlacementRC_A4("   ");
+        if (res == 92) {
+            result = 0;
+        }
+        place.className = "run5";
+        synchronized (PlacementRCTest04.lock) {
+            PlacementRCTest04.result += "run5";
+        }
+        return result;
+    }
+    private static int ExcpCover03330() {
+        int result1 = 4;
+        PlacementRC_A4 place4 = new PlacementRC_A4("123#456");
+        try {
+            Integer.parseInt(place4.className);
+        } catch (IndexOutOfBoundsException e) {
+            res -= 10;
+        } catch (IllegalArgumentException e) {
+            res--;
+        } finally {
+            res--;
+            try {
+                place4 = new PlacementRC_A4("123#4567");
+                res += 100;
+                try {
+                    place4 = new PlacementRC_A4("123#4568");
+                    PlacementRC_A4 place09 = new PlacementRC_A4("123#4561");
+                    res += 100;
+                    place09.count = res;
+                    try {
+                        place4 = new PlacementRC_A4("123#4569");
+                        PlacementRC_A4 place9 = new PlacementRC_A4("123#4561");
+                        res += 100;
+                        place9.count = res;
+                        try {
+                            place4 = new PlacementRC_A4("123#4560");
+                            PlacementRC_A4 place18 = new PlacementRC_A4("123#4561");
+                            res += 100;
+                            place18.count = res;
+                            place9.count = place18.count;
+                            try {
+                                place4 = new PlacementRC_A4("123#4561");
+                                PlacementRC_A4 place19 = new PlacementRC_A4("123#4561");
+                                res += 100;
+                                place19.count = res;
+                                place9.count = place19.count;
+                                System.out.println(place4.className.substring(-5));
+                            } catch (ClassCastException e) {
+                                place9.className = "catch info 1";
+                                res -= 10;
+                            } finally {
+                                res -= 100;
+                            }
+                        } catch (ClassCastException e1) {
+                            place4.className = "catch info 2";
+                            res -= 10;
+                        } finally {
+                            res -= 100;
+                        }
+                    } catch (IllegalStateException e2) {
+                        place09.className = "catch info 3";
+                        res -= 10;
+                    } finally {
+                        res -= 100;
+                    }
+                } catch (ClassCastException e3) {
+                    place4.className = "catch info 4";
+                    res -= 10;
+                } finally {
+                    res -= 100;
+                }
+            } catch (IllegalArgumentException e4) {
+                place4.className = "catch info 5";
+                res -= 10;
+            } finally {
+                res -= 100;
+            }
+        }
+        res -= 10;
+        place4.count = result1;
+        return place4.count;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04/test.cfg b/testsuite/java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9d732b393fda165f26fc7506cb61b3af9fa63961
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0446-rc-PlacementRC-PlacementRCTest04/test.cfg
@@ -0,0 +1,2 @@
+compile(PlacementRCTest04)
+run(PlacementRCTest04,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/FinalizerReferenceTest01.java b/testsuite/java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/FinalizerReferenceTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ffd24200a07c154ad92429788d11aeb045093cd
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/FinalizerReferenceTest01.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+public class FinalizerReferenceTest01 {
+    static int check = 3;
+    public static void main(String[] args) {
+        SoftReference<ReferenceTest01> softReference = new SoftReference<>(new ReferenceTest01(10));
+        ReferenceTest01 rt01 = softReference.get();
+        if (rt01.stringArray.length == 10 && rt01.stringArray[9].equals("test9")) {
+            check--;
+        }
+        rt01 = null;
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+        }
+        Runtime.getRuntime().runFinalization();
+        if (softReference.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+    private static int oomTest() {
+        int sum = 0;
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+}
+class ReferenceTest01 {
+    String[] stringArray;
+    public ReferenceTest01(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+    @Override
+    public void finalize() {
+        for (int i = 0; i < this.stringArray.length; i++) {
+            stringArray[i] = null;
+        }
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/expected.txt b/testsuite/java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/test.cfg b/testsuite/java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1613f5731595382a88959b4f2220faedf383ee3b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0449-rc-RP-FinalizerReferenceTest01/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerReferenceTest01)
+run(FinalizerReferenceTest01,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/FinalizerReferenceTest02.java b/testsuite/java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/FinalizerReferenceTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bfe40be6a4712a330579df2f51dc61eb928e3d1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/FinalizerReferenceTest02.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+public class FinalizerReferenceTest02 {
+    static int check = 2;
+    public static void main(String[] args) {
+        WeakReference<ReferenceTest02> weakReference = new WeakReference<>(new ReferenceTest02(10));
+        ReferenceTest02 rt02 = weakReference.get();
+        if (rt02.stringArray.length == 10 && rt02.stringArray[9].equals("test9")) {
+            check--;
+        }
+        rt02 = null;
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        if (weakReference.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+class ReferenceTest02 {
+    String[] stringArray;
+    public ReferenceTest02(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+    @Override
+    public void finalize() {
+        for (int i = 0; i < this.stringArray.length; i++) {
+            stringArray[i] = null;
+        }
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/expected.txt b/testsuite/java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/test.cfg b/testsuite/java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6d8c0a812a9219f201f7434346f18ed68c56b8c4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0450-rc-RP-FinalizerReferenceTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerReferenceTest02)
+run(FinalizerReferenceTest02,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/FinalizerReferenceTest03.java b/testsuite/java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/FinalizerReferenceTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..e83266d106b2cdad6ba53bea9956b4d73ed4a156
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/FinalizerReferenceTest03.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+public class FinalizerReferenceTest03 {
+    static int check = 1;
+    public static void main(String[] args) {
+        ReferenceQueue referenceQueue = new ReferenceQueue();
+        PhantomReference<ReferenceTest03> pr = new PhantomReference<>(new ReferenceTest03(10), referenceQueue);
+        if (pr.get() == null) {
+            check--;
+        }
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+class ReferenceTest03 {
+    String[] stringArray;
+    public ReferenceTest03(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+    @Override
+    public void finalize() {
+        for (int i = 0; i < this.stringArray.length; i++) {
+            stringArray[i] = null;
+        }
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/expected.txt b/testsuite/java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/test.cfg b/testsuite/java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7cb1605cbab411a5fcee304f59d3938c8add16d7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0451-rc-RP-FinalizerReferenceTest03/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerReferenceTest03)
+run(FinalizerReferenceTest03,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/FinalizerReferenceTest04.java b/testsuite/java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/FinalizerReferenceTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3cb949416d92a50dd38b176246a2b20b84458b2
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/FinalizerReferenceTest04.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+public class FinalizerReferenceTest04 {
+    static Cleaner cleaner;
+    public static void main(String[] args) {
+        Cleaner.create(new ReferenceTest04(10), null);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+    }
+}
+class ReferenceTest04 {
+    String[] stringArray;
+    public ReferenceTest04(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+    @Override
+    public void finalize() {
+        for (int i = 0; i < this.stringArray.length; i++) {
+            stringArray[i] = null;
+        }
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/expected.txt b/testsuite/java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/test.cfg b/testsuite/java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..30e09108d5d5ed20ab3b65cb0fade879fc77a60d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0452-rc-RP-FinalizerReferenceTest04/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerReferenceTest04)
+run(FinalizerReferenceTest04,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/FinalizerReferenceTest05.java b/testsuite/java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/FinalizerReferenceTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..47b8be9d9709a607c6e26e2ef279f20adb7d8cc4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/FinalizerReferenceTest05.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+public class FinalizerReferenceTest05 {
+    static SoftReference<ReferenceTest05> sr05;
+    static int check = 3;
+    public static void main(String[] args) {
+        new ReferenceTest05(10);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        ReferenceTest05 rt05 = sr05.get();
+        if (rt05.stringArray.length == 10 && rt05.stringArray[9].equals("test9")) {
+            check--;
+        }
+        rt05 = null;
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+        }
+        Runtime.getRuntime().runFinalization();
+        if (sr05.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+    private static int oomTest() {
+        int sum = 0;
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+}
+class ReferenceTest05 {
+    String[] stringArray;
+    public ReferenceTest05(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+        FinalizerReferenceTest05.sr05 = new SoftReference(this);
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/expected.txt b/testsuite/java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/test.cfg b/testsuite/java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4bf08aa7b4f22138410d026d4c009763e74dd090
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0453-rc-RP-FinalizerReferenceTest05/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerReferenceTest05)
+run(FinalizerReferenceTest05,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/FinalizerReferenceTest06.java b/testsuite/java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/FinalizerReferenceTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc4f8b17765bee5bae2458392f38c4e111583464
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/FinalizerReferenceTest06.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+public class FinalizerReferenceTest06 {
+    static WeakReference<ReferenceTest06> sr06;
+    static int check = 2;
+    public static void main(String[] args) {
+        new ReferenceTest06(10);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        if (sr06.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+class ReferenceTest06 {
+    String[] stringArray;
+    public ReferenceTest06(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+        FinalizerReferenceTest06.sr06 = new WeakReference<>(this);
+        ReferenceTest06 rt06 = FinalizerReferenceTest06.sr06.get();
+        if (rt06.stringArray.length == 10 && rt06.stringArray[9].equals("test9")) {
+            FinalizerReferenceTest06.check--;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/expected.txt b/testsuite/java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/test.cfg b/testsuite/java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..08e53ebd19b98bd459693ab1a861731c06f5d507
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0454-rc-RP-FinalizerReferenceTest06/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerReferenceTest06)
+run(FinalizerReferenceTest06,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/FinalizerReferenceTest07.java b/testsuite/java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/FinalizerReferenceTest07.java
new file mode 100755
index 0000000000000000000000000000000000000000..b62be6083edf4e861f3abb9d281f7ecc33ef3c85
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/FinalizerReferenceTest07.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+public class FinalizerReferenceTest07 {
+    static ReferenceQueue referenceQueue = new ReferenceQueue();
+    static PhantomReference<ReferenceTest07> sr07;
+    static int check = 2;
+    public static void main(String[] args) {
+        new ReferenceTest07(10);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        if (sr07.get() == null) {
+            check--;
+        }
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        if (referenceQueue.poll() != null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
+class ReferenceTest07 {
+    String[] stringArray;
+    public ReferenceTest07(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+        FinalizerReferenceTest07.sr07 = new PhantomReference<>(this, FinalizerReferenceTest07.referenceQueue);
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/expected.txt b/testsuite/java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/test.cfg b/testsuite/java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ca39d1a6a6d644620ff45e95312db4ae7687b1b3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0455-rc-RP-FinalizerReferenceTest07/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerReferenceTest07)
+run(FinalizerReferenceTest07,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/FinalizerReferenceTest08.java b/testsuite/java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/FinalizerReferenceTest08.java
new file mode 100644
index 0000000000000000000000000000000000000000..cee40ead82519072bcea2a67ab24046a4451b82d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/FinalizerReferenceTest08.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+public class FinalizerReferenceTest08 {
+    static Cleaner cleaner;
+    static int check = 2;
+    public static void main(String[] args) {
+        new ReferenceTest08(10);
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+    }
+}
+class ReferenceTest08 {
+    String[] stringArray;
+    public ReferenceTest08(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+        Cleaner.create(this, null);
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/expected.txt b/testsuite/java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/test.cfg b/testsuite/java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..28fc39bf9361e4df177d3568d056f6fe79799bef
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0456-rc-RP-FinalizerReferenceTest08/test.cfg
@@ -0,0 +1,2 @@
+compile(FinalizerReferenceTest08)
+run(FinalizerReferenceTest08,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0457-rc-GC-TriggerGCTest01/TriggerGCTest01.java b/testsuite/java_test/rc_test/RC0457-rc-GC-TriggerGCTest01/TriggerGCTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..a45c226429ff530c3ed6255af27543ef13ce6ed0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0457-rc-GC-TriggerGCTest01/TriggerGCTest01.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class TriggerGCTest01 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+    static void setWeakReference() {
+        rp = new WeakReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            a++;
+        }
+    }
+    public static void main(String[] args) throws Exception {
+        Reference r;
+        setWeakReference();
+        new Thread(new TriggerRP()).start();
+        Runtime.getRuntime().gc();
+        Thread.sleep(1000);
+        if (rp.get() != null) {
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 60; i++) {
+                WeakReference wr = new WeakReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0457-rc-GC-TriggerGCTest01/test.cfg b/testsuite/java_test/rc_test/RC0457-rc-GC-TriggerGCTest01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..fc1611bd8e773dcfd618700f155bfd0cc2259c6a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0457-rc-GC-TriggerGCTest01/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest01)
+run(TriggerGCTest01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0458-rc-GC-TriggerGCTest02/TriggerGCTest02.java b/testsuite/java_test/rc_test/RC0458-rc-GC-TriggerGCTest02/TriggerGCTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..45a292aeaceb8301f109186bccaf9b2946624e9b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0458-rc-GC-TriggerGCTest02/TriggerGCTest02.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class TriggerGCTest02 {
+    static Reference rp;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int a = 100;
+    static void setWeakReference() {
+        rp = new WeakReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            a++;
+        }
+    }
+    public static void main(String[] args) throws Exception {
+        Reference r;
+        setWeakReference();
+        new Thread(new TriggerRP()).start();
+        Runtime.getRuntime().gc();
+        if (rp.get() != null) {
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        }
+    }
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 60; i++) {
+                WeakReference wr = new WeakReference(new Object());
+                try {
+                    Thread.sleep(50);
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0458-rc-GC-TriggerGCTest02/expected.txt b/testsuite/java_test/rc_test/RC0458-rc-GC-TriggerGCTest02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0458-rc-GC-TriggerGCTest02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0458-rc-GC-TriggerGCTest02/test.cfg b/testsuite/java_test/rc_test/RC0458-rc-GC-TriggerGCTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4acd386fa848eed479ca39c8cb4fed6fdf005f54
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0458-rc-GC-TriggerGCTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest02)
+run(TriggerGCTest02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0459-rc-GC-TriggerGCTest03/TriggerGCTest03.java b/testsuite/java_test/rc_test/RC0459-rc-GC-TriggerGCTest03/TriggerGCTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee2fe5fed36e84eb771fd369df53e2c830ca850a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0459-rc-GC-TriggerGCTest03/TriggerGCTest03.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+public class TriggerGCTest03 {
+    static int check = 3;
+    public static void main(String[] args) {
+        SoftReference<Reference03> softReference = new SoftReference<>(new Reference03(100000));
+        Reference03 rt01 = softReference.get();
+        if (rt01.stringArray.length == 100000 && rt01.stringArray[9].equals("test9")) {
+            check--;
+        }
+        rt01 = null;
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+            Runtime.getRuntime().runFinalization();
+            if (softReference.get() == null) {
+                check--;
+            }
+            if (check == 0) {
+                System.out.println("ExpectResult");
+            } else {
+                System.out.println("ErrorResult");
+            }
+        }
+    }
+    private static int oomTest() {
+        int sum = 0;
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1034 * 1034; i <= 1034 * 1034 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+}
+class Reference03 {
+    String[] stringArray;
+    public Reference03(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0459-rc-GC-TriggerGCTest03/expected.txt b/testsuite/java_test/rc_test/RC0459-rc-GC-TriggerGCTest03/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0459-rc-GC-TriggerGCTest03/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0459-rc-GC-TriggerGCTest03/test.cfg b/testsuite/java_test/rc_test/RC0459-rc-GC-TriggerGCTest03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8436c23e04d1d83a81f7be75c6a2b57f12f5282b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0459-rc-GC-TriggerGCTest03/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest03)
+run(TriggerGCTest03,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0463-rc-GC-TriggerGCTest07/TriggerGCTest07.java b/testsuite/java_test/rc_test/RC0463-rc-GC-TriggerGCTest07/TriggerGCTest07.java
new file mode 100644
index 0000000000000000000000000000000000000000..525d7917d32ca98d5da6fe2c7695d750a7b7f8dc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0463-rc-GC-TriggerGCTest07/TriggerGCTest07.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+public class TriggerGCTest07 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int INIT_MEMORY = 100; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        for (int i = 0; i < INIT_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(3000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0463-rc-GC-TriggerGCTest07/expected.txt b/testsuite/java_test/rc_test/RC0463-rc-GC-TriggerGCTest07/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0463-rc-GC-TriggerGCTest07/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0463-rc-GC-TriggerGCTest07/test.cfg b/testsuite/java_test/rc_test/RC0463-rc-GC-TriggerGCTest07/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..72dc25b6471d93c26718c56504939fd2fe86cf14
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0463-rc-GC-TriggerGCTest07/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest07)
+run(TriggerGCTest07,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0464-rc-GC-TriggerGCTest08/TriggerGCTest08.java b/testsuite/java_test/rc_test/RC0464-rc-GC-TriggerGCTest08/TriggerGCTest08.java
new file mode 100644
index 0000000000000000000000000000000000000000..2af087ac8ebae6fd1e0550391a7636ce96e8bb47
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0464-rc-GC-TriggerGCTest08/TriggerGCTest08.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+public class TriggerGCTest08 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int INIT_MEMORY = 100; // MB
+    private final static int SEC_MEMORY = 150; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < INIT_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(2000);
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        for (int i = INIT_MEMORY; i < SEC_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(3000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0464-rc-GC-TriggerGCTest08/expected.txt b/testsuite/java_test/rc_test/RC0464-rc-GC-TriggerGCTest08/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0464-rc-GC-TriggerGCTest08/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0464-rc-GC-TriggerGCTest08/test.cfg b/testsuite/java_test/rc_test/RC0464-rc-GC-TriggerGCTest08/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7daeb503d549324c827b1bb73c94063b76219d10
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0464-rc-GC-TriggerGCTest08/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest08)
+run(TriggerGCTest08,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0465-rc-GC-TriggerGCTest09/TriggerGCTest09.java b/testsuite/java_test/rc_test/RC0465-rc-GC-TriggerGCTest09/TriggerGCTest09.java
new file mode 100644
index 0000000000000000000000000000000000000000..7041baed6fe9cc6fd5344f780c447fd16f6fd8e4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0465-rc-GC-TriggerGCTest09/TriggerGCTest09.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+public class TriggerGCTest09 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int SEC_MEMORY = 150; // MB
+    private final static int TRI_MEMORY = 225; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < SEC_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(2000);
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        for (int i = SEC_MEMORY; i < TRI_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(3000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0465-rc-GC-TriggerGCTest09/expected.txt b/testsuite/java_test/rc_test/RC0465-rc-GC-TriggerGCTest09/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0465-rc-GC-TriggerGCTest09/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0465-rc-GC-TriggerGCTest09/test.cfg b/testsuite/java_test/rc_test/RC0465-rc-GC-TriggerGCTest09/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..3a3597568932bdcd457dd905d5d7c71577443ac5
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0465-rc-GC-TriggerGCTest09/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest09)
+run(TriggerGCTest09,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0466-rc-GC-TriggerGCTest10/TriggerGCTest10.java b/testsuite/java_test/rc_test/RC0466-rc-GC-TriggerGCTest10/TriggerGCTest10.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1a2786f0c3ef4f077bf7b7c196d49a23c0fbe6d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0466-rc-GC-TriggerGCTest10/TriggerGCTest10.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+public class TriggerGCTest10 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int TRI_MEMORY = 225; // MB
+    private final static int FOU_MEMORY = 350; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < TRI_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(2000);
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        try {
+            for (int i = TRI_MEMORY; i < FOU_MEMORY; i++) {
+                byte[] temp = new byte[1024 * 1024];
+                store.add(temp);
+            }
+        } catch (OutOfMemoryError e) {
+            // do nothing
+        }
+        Thread.sleep(1000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0466-rc-GC-TriggerGCTest10/expected.txt b/testsuite/java_test/rc_test/RC0466-rc-GC-TriggerGCTest10/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0466-rc-GC-TriggerGCTest10/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0466-rc-GC-TriggerGCTest10/test.cfg b/testsuite/java_test/rc_test/RC0466-rc-GC-TriggerGCTest10/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1d242a686cfbf2b7fdbee9e2ccf532ba708ed47a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0466-rc-GC-TriggerGCTest10/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest10)
+run(TriggerGCTest10,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/ArrayCloneTest.java b/testsuite/java_test/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/ArrayCloneTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9cfe4a051386ffda18f170c9ad1968f90797ab3
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/ArrayCloneTest.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ArrayCloneTest {
+    public static void main(String[] args) {
+        if (functionTest01()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+    private static boolean functionTest01() {
+        String[] test1 = {"test1","test2","test3","test4","test5","test6","test7","test8","test9","test10"};
+        String[] test2 = test1.clone();
+        if (test2 != test1  && test2.length == 10 && test2[0].equals("test1") && test2[9].equals("test10")) {
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/expected.txt b/testsuite/java_test/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/test.cfg b/testsuite/java_test/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..93efde9433265d8bdb6415e02c7d7a6cbd641ca1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0468-rc-BindingMethod-ArrayCloneTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayCloneTest)
+run(ArrayCloneTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/ArrayCloneTest02.java b/testsuite/java_test/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/ArrayCloneTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..de1117f3afa94229c2864bfe94a4083953411d85
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/ArrayCloneTest02.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ArrayCloneTest02 {
+    private Integer id;
+    public ArrayCloneTest02(Integer id) {
+        this.id = id;
+    }
+    public Integer getId() {
+        return id;
+    }
+    public void setId(Integer id) {
+        this.id = id;
+    }
+    @Override
+    public String toString() {
+        return "CloneTest{" +
+                "id=" + id +
+                '}';
+    }
+    public static void main(String[] args) {
+        try {
+            ArrayCloneTest02 cloneTest = new ArrayCloneTest02(1);
+            ArrayCloneTest02 cloneTest1 = (ArrayCloneTest02) cloneTest.clone();
+            System.out.println("ErrorResult");
+        } catch (CloneNotSupportedException e) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/expected.txt b/testsuite/java_test/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/test.cfg b/testsuite/java_test/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..db57ac31a9e7d16b0c51bdfc97df2fb2728f8c9a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0469-rc-BindingMethod-ArrayCloneTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayCloneTest02)
+run(ArrayCloneTest02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/ArrayCopyTest.java b/testsuite/java_test/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/ArrayCopyTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c05d3ba8f510906bea482ad0d6a76521c8c77185
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/ArrayCopyTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ArrayCopyTest {
+    public static void main(String[] args) {
+        if (functionTest01() && functionTest02() && functionTest03() && functionTest04()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+    private static boolean functionTest01() {
+        String[] test1 = {"test1","test2","test3","test4","test5","test6","test7","test8","test9","test10"};
+        String[] test2 = new String[10];
+        System.arraycopy(test1,0,test2,0,10);
+        if (test2[0].equals("test1") && test2[9].equals("test10")) {
+            return true;
+        }
+        return false;
+    }
+    private static boolean functionTest02() {
+        try {
+            String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+            int[] test2 = new int[10];
+            System.arraycopy(test1, 0, test2, 0, 10);
+        } catch (ArrayStoreException e) {
+            return true;
+        }
+        return false;
+    }
+    private static boolean functionTest03() {
+        try {
+            String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+            String[] test2 = new String[9];
+            System.arraycopy(test1, 0, test2, 0, 10);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            return true;
+        }
+        return false;
+    }
+    private static boolean functionTest04() {
+        try {
+            String[] test1 = {"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"};
+            String[] test2 = null;
+            System.arraycopy(test1, 0, test2, 0, 10);
+        } catch (NullPointerException e) {
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/expected.txt b/testsuite/java_test/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/test.cfg b/testsuite/java_test/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ef3e3a1676cf68a25bff6e602891d671e63b2b3e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0470-rc-BindingMethod-ArrayCopyTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ArrayCopyTest)
+run(ArrayCopyTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0477-rc-StackScan-CB_01/CB_01.java b/testsuite/java_test/rc_test/RC0477-rc-StackScan-CB_01/CB_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc5804979f3fd892d9b447ff9639304ff1d3c427
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0477-rc-StackScan-CB_01/CB_01.java
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.HashMap;
+class CB_Nolcycle_a_00180_A1 {
+    CB_Nolcycle_a_00180_B1 b1_0;
+    CB_Nolcycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+class CB_Nolcycle_a_00180_A2 {
+    CB_Nolcycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+class CB_Nolcycle_a_00180_A3 {
+    CB_Nolcycle_a_00180_B2 b2_0;
+    CB_Nolcycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+class CB_Nolcycle_a_00180_A4 {
+    CB_Nolcycle_a_00180_B3 b3_0;
+    CB_Nolcycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+class CB_Nolcycle_a_00180_B1 {
+    CB_Nolcycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+class CB_Nolcycle_a_00180_B2 {
+    CB_Nolcycle_a_00180_C1 c1_0;
+    CB_Nolcycle_a_00180_D1 d1_0;
+    CB_Nolcycle_a_00180_D2 d2_0;
+    CB_Nolcycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+class CB_Nolcycle_a_00180_B3 {
+    CB_Nolcycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class CB_Nolcycle_a_00180_C1 {
+    CB_Nolcycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class CB_Nolcycle_a_00180_C2 {
+    CB_Nolcycle_a_00180_D2 d2_0;
+    CB_Nolcycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+class CB_Nolcycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CB_Nolcycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+//该树有12个节点
+class CB_Nolcycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nolcycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CB_Nolcycle_a_00180 {
+    public CB_Nolcycle_a_00180() {
+        CB_Nolcycle_a_00180_A1 a1_main = new CB_Nolcycle_a_00180_A1("a1_main");
+        CB_Nolcycle_a_00180_A2 a2_main = new CB_Nolcycle_a_00180_A2("a2_main");
+        CB_Nolcycle_a_00180_A3 a3_main = new CB_Nolcycle_a_00180_A3("a3_main");
+        CB_Nolcycle_a_00180_A4 a4_main = new CB_Nolcycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new CB_Nolcycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a2_main.b2_0 = new CB_Nolcycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new CB_Nolcycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a3_main.b2_0 = new CB_Nolcycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new CB_Nolcycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+        a3_main.c2_0 = new CB_Nolcycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+        a4_main.b3_0 = new CB_Nolcycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new CB_Nolcycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new CB_Nolcycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new CB_Nolcycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new CB_Nolcycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new CB_Nolcycle_a_00180_D3("d3_0");
+    }
+}
+class CB_01_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_01_A2 a2_0;
+    CB_01_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_01_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        //System.out.println("A finalize");
+        CB_01.check = this;
+    }
+}
+class CB_01_A2 {
+    static CB_01_A1 a1_0;
+    volatile static HashMap test2;
+    CB_01_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_01_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + CB_01_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class CB_01_A3 {
+    static CB_Nolcycle_a_00180[] test1;
+    CB_01_A1 a1_0;
+    CB_01_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_01_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_01_A1.a + a2_0.a;
+    }
+}
+public class CB_01 {
+    public static CB_01_A1 check = null;
+    private static CB_01_A1 a1_main = null;
+    private CB_01() {
+        a1_main = new CB_01_A1("a1_main");
+        a1_main.a2_0 = new CB_01_A2("a2_0");
+        CB_01_A2.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_01_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+    private static void test_CB_01(int times) {
+        CB_01_A1.test1 = new HashMap();
+        CB_01_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_01_A1.test1.put(i, new CB_Nolcycle_a_00180());
+            CB_01_A2.test2.put(i, new CB_Nolcycle_a_00180());
+        }
+    }
+    private static void rc_testcase_main_wrapper() {
+        CB_01 cb01 = new CB_01();
+        test_CB_01(10000);
+        check = a1_main;
+        try {
+            int result = CB_01.check.sum + CB_01.check.a2_0.sum + CB_01.check.a2_0.a3_0.sum + CB_01_A1.test1.size() + CB_01_A2.test2.size();
+            if (result == 20918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0477-rc-StackScan-CB_01/expected.txt b/testsuite/java_test/rc_test/RC0477-rc-StackScan-CB_01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0477-rc-StackScan-CB_01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0477-rc-StackScan-CB_01/test.cfg b/testsuite/java_test/rc_test/RC0477-rc-StackScan-CB_01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..5a40e80def551dbc70cb6629ad0e0fb8ee34abd9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0477-rc-StackScan-CB_01/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_01)
+run(CB_01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0478-rc-StackScan-CB_02/CB_02.java b/testsuite/java_test/rc_test/RC0478-rc-StackScan-CB_02/CB_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3b5a7cf7e16d97e49d25a4d99f6dfca7c3547a9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0478-rc-StackScan-CB_02/CB_02.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.HashMap;
+class CB_02_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_02_A2 a2_0;
+    CB_02_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_02_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_02.check = this;
+    }
+}
+class CB_02_A2 {
+    volatile static HashMap test2;
+    CB_02_A1 a1_0;
+    CB_02_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_02_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + CB_02_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class CB_02_A3 {
+    CB_02_A1 a1_0;
+    CB_02_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_02_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + CB_02_A1.a + a2_0.a;
+    }
+}
+public class CB_02 {
+    public volatile static CB_02_A1 check = null;
+    private static CB_02_A1 a1_main = null;
+    private CB_02() {
+        a1_main = new CB_02_A1("a1_main");
+        a1_main.a2_0 = new CB_02_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_02_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+    private static void test_CB_02(int times) {
+        CB_02_A1.test1 = new HashMap();
+        CB_02_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_02_A1.test1.put(i, "Maple" + i);
+            CB_02_A2.test2.put(i, "Figo" + i);
+        }
+    }
+    private static void rc_testcase_main_wrapper() {
+        CB_02 cb01 = new CB_02();
+        test_CB_02(100000);
+        check = a1_main;
+        try {
+            int result = CB_02.check.sum + CB_02.check.a2_0.sum + CB_02.check.a2_0.a3_0.sum + CB_02_A1.test1.size() + CB_02_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0478-rc-StackScan-CB_02/expected.txt b/testsuite/java_test/rc_test/RC0478-rc-StackScan-CB_02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0478-rc-StackScan-CB_02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0478-rc-StackScan-CB_02/test.cfg b/testsuite/java_test/rc_test/RC0478-rc-StackScan-CB_02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e6a066202e4256a66b9c9960e27e61e005f59486
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0478-rc-StackScan-CB_02/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_02)
+run(CB_02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0479-rc-StackScan-CB_03/CB_03.java b/testsuite/java_test/rc_test/RC0479-rc-StackScan-CB_03/CB_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..14fa5760cbf08a5c8d516ffce50a6abd1c547b08
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0479-rc-StackScan-CB_03/CB_03.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.HashMap;
+class CB_03_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_03_A2 a2_0;
+    CB_03_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_03_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_03.check = this;
+    }
+}
+class CB_03_A2 {
+    CB_03_A1 a1_0;
+    CB_03_A3 a3_0;
+    volatile HashMap test2;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_03_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_03_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class CB_03_A3 {
+    CB_03_A1 a1_0;
+    CB_03_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_03_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_03_A1.a + a2_0.a;
+    }
+}
+public class CB_03 {
+    public volatile static CB_03_A1 check = null;
+    private static CB_03_A1 a1_main = null;
+    private CB_03() {
+        a1_main = new CB_03_A1("a1_main");
+        a1_main.a2_0 = new CB_03_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_03_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+    private static void test_CB_03(int times) {
+        CB_03_A1.test1 = new HashMap();
+        a1_main.a2_0.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_03_A1.test1.put(i, new StringBuffer("Maple test").append(i));
+            a1_main.a2_0.test2.put(i, new StringBuffer("Figo test").append(i));
+        }
+    }
+    private static void rc_testcase_main_wrapper() {
+        CB_03 cb01 = new CB_03();
+        test_CB_03(100000);
+        check = a1_main;
+        try {
+            int result = CB_03.check.sum + CB_03.check.a2_0.sum + CB_03.check.a2_0.a3_0.sum + CB_03_A1.test1.size() + check.a2_0.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0479-rc-StackScan-CB_03/expected.txt b/testsuite/java_test/rc_test/RC0479-rc-StackScan-CB_03/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0479-rc-StackScan-CB_03/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0479-rc-StackScan-CB_03/test.cfg b/testsuite/java_test/rc_test/RC0479-rc-StackScan-CB_03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9d59ba62a3753c8ec5daa94301c41b694ef94448
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0479-rc-StackScan-CB_03/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_03)
+run(CB_03,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0480-rc-StackScan-CB_04/CB_04.java b/testsuite/java_test/rc_test/RC0480-rc-StackScan-CB_04/CB_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee788dfc7018863bc2b3d30c5622f40242762d9b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0480-rc-StackScan-CB_04/CB_04.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.HashMap;
+class CB_04_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_04_A2 a2_0;
+    CB_04_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_04_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("A finalize");
+        CB_04.check = this;
+    }
+}
+class CB_04_A2 {
+    volatile static HashMap test2;
+    CB_04_A1 a1_0;
+    CB_04_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_04_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + CB_04_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("B finalize");
+    }
+}
+class CB_04_A3 {
+    CB_04_A1 a1_0;
+    CB_04_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_04_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + CB_04_A1.a + a2_0.a;
+    }
+}
+public class CB_04 {
+    public static CB_04_A1 a1_main = null;
+    public volatile static CB_04_A1 check = null;
+    public CB_04() {
+        a1_main = new CB_04_A1("a1_main");
+        a1_main.a2_0 = new CB_04_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_04_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+    public static void test_CB_04(int times) {
+        CB_04_A1.test1 = new HashMap();
+        CB_04_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_04_A1.test1.put(i, new StringBuilder().append(i));
+            CB_04_A2.test2.put(i, new StringBuilder().append(times + i));
+        }
+    }
+    public static void rc_testcase_main_wrapper() {
+        CB_04 cb01 = new CB_04();
+        test_CB_04(100000);
+        check = a1_main;
+        try {
+            int result = CB_04.check.sum + CB_04.check.a2_0.sum + CB_04.check.a2_0.a3_0.sum + CB_04_A1.test1.size() + CB_04_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0480-rc-StackScan-CB_04/expected.txt b/testsuite/java_test/rc_test/RC0480-rc-StackScan-CB_04/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0480-rc-StackScan-CB_04/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0480-rc-StackScan-CB_04/test.cfg b/testsuite/java_test/rc_test/RC0480-rc-StackScan-CB_04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..95f9bf850ffcb0103e187a55637f5bc54555b523
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0480-rc-StackScan-CB_04/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_04)
+run(CB_04,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0481-rc-StackScan-CB_05/CB_05.java b/testsuite/java_test/rc_test/RC0481-rc-StackScan-CB_05/CB_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..f76a2c81b2246aaf74ba2c90fd0d3cbe23a81a13
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0481-rc-StackScan-CB_05/CB_05.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.SoftReference;
+import java.util.HashMap;
+class CB_05_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_05_A2 a2_0;
+    CB_05_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_05_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_05.check = this;
+    }
+}
+class CB_05_A2 {
+    volatile static HashMap test2;
+    CB_05_A1 a1_0;
+    CB_05_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_05_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_05_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class CB_05_A3 {
+    CB_05_A1 a1_0;
+    CB_05_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_05_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_05_A1.a + a2_0.a;
+    }
+}
+public class CB_05 {
+    public volatile static CB_05_A1 check = null;
+    private static CB_05_A1 a1_main = null;
+    private CB_05() {
+        a1_main = new CB_05_A1("a1_main");
+        a1_main.a2_0 = new CB_05_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_05_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+    private static void test_CB_05(int times) {
+        CB_05_A1.test1 = new HashMap();
+        CB_05_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_05_A1.test1.put(i, new SoftReference<>("maple" + i));
+            CB_05_A2.test2.put(i, new SoftReference<>("maple" + times + i));
+        }
+    }
+    private static void rc_testcase_main_wrapper() {
+        CB_05 cb01 = new CB_05();
+        test_CB_05(10000);
+        check = a1_main;
+        try {
+            int result = CB_05.check.sum + CB_05.check.a2_0.sum + CB_05.check.a2_0.a3_0.sum + CB_05_A1.test1.size() + CB_05_A2.test2.size();
+            if (result == 20918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0481-rc-StackScan-CB_05/expected.txt b/testsuite/java_test/rc_test/RC0481-rc-StackScan-CB_05/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0481-rc-StackScan-CB_05/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0481-rc-StackScan-CB_05/test.cfg b/testsuite/java_test/rc_test/RC0481-rc-StackScan-CB_05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c8ec77082283e55784016c1fb71b549c5a70aa80
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0481-rc-StackScan-CB_05/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_05)
+run(CB_05,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0482-rc-StackScan-CB_06/CB_06.java b/testsuite/java_test/rc_test/RC0482-rc-StackScan-CB_06/CB_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..506b81175d2c082ca9806f02bf4cb50fc0ba0e7e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0482-rc-StackScan-CB_06/CB_06.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+class CB_06_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_06_A2 a2_0;
+    CB_06_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_06_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_06.check = this;
+    }
+}
+class CB_06_A2 {
+    volatile static HashMap test2;
+    CB_06_A1 a1_0;
+    CB_06_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_06_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_06_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class CB_06_A3 {
+    CB_06_A1 a1_0;
+    CB_06_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_06_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_06_A1.a + a2_0.a;
+    }
+}
+public class CB_06 {
+    public volatile static CB_06_A1 check = null;
+    static String str;
+    private static CB_06_A1 a1_main = null;
+    private CB_06() {
+        a1_main = new CB_06_A1("a1_main");
+        a1_main.a2_0 = new CB_06_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_06_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+    private static void test_CB_06(int times) {
+        CB_06_A1.test1 = new HashMap();
+        CB_06_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_06_A1.test1.put(i, new WeakReference("Maple" + i));
+            CB_06_A2.test2.put(i, new WeakReference("Figo" + i));
+        }
+    }
+    private static void rc_testcase_main_wrapper() {
+        CB_06 cb01 = new CB_06();
+        test_CB_06(100000);
+        check = a1_main;
+        try {
+            int result = CB_06.check.sum + CB_06.check.a2_0.sum + CB_06.check.a2_0.a3_0.sum + CB_06_A1.test1.size() + CB_06_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0482-rc-StackScan-CB_06/expected.txt b/testsuite/java_test/rc_test/RC0482-rc-StackScan-CB_06/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0482-rc-StackScan-CB_06/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0482-rc-StackScan-CB_06/test.cfg b/testsuite/java_test/rc_test/RC0482-rc-StackScan-CB_06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..15452d78f43155695184bc17fac0c30ee88cf482
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0482-rc-StackScan-CB_06/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_06)
+run(CB_06,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0483-rc-StackScan-CB_07/CB_07.java b/testsuite/java_test/rc_test/RC0483-rc-StackScan-CB_07/CB_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..aeb3880671642a8066f4ce33b8365eb3ca2e4289
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0483-rc-StackScan-CB_07/CB_07.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+import java.util.HashMap;
+class CB_07_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_07_A2 a2_0;
+    CB_07_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_07_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_07.check = this;
+    }
+}
+class CB_07_A2 {
+    volatile static HashMap test2;
+    CB_07_A1 a1_0;
+    CB_07_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_07_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_07_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class CB_07_A3 {
+    CB_07_A1 a1_0;
+    CB_07_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_07_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_07_A1.a + a2_0.a;
+    }
+}
+public class CB_07 {
+    public volatile static CB_07_A1 check = null;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static String str;
+    private static CB_07_A1 a1_main = null;
+    private CB_07() {
+        a1_main = new CB_07_A1("a1_main");
+        a1_main.a2_0 = new CB_07_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_07_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+    private static void test_CB_07(int times) {
+        CB_07_A1.test1 = new HashMap();
+        CB_07_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_07_A1.test1.put(i, new PhantomReference<>("maple" + i, rq));
+            CB_07_A2.test2.put(i, new PhantomReference<>("Figo" + times + i, rq));
+        }
+    }
+    private static void rc_testcase_main_wrapper() {
+        CB_07 cb01 = new CB_07();
+        test_CB_07(100000);
+        check = a1_main;
+        try {
+            int result = CB_07.check.sum + CB_07.check.a2_0.sum + CB_07.check.a2_0.a3_0.sum + CB_07_A1.test1.size() + CB_07_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0483-rc-StackScan-CB_07/expected.txt b/testsuite/java_test/rc_test/RC0483-rc-StackScan-CB_07/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0483-rc-StackScan-CB_07/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0483-rc-StackScan-CB_07/test.cfg b/testsuite/java_test/rc_test/RC0483-rc-StackScan-CB_07/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..33fc829225187193343a26fbee5f0dda060ff888
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0483-rc-StackScan-CB_07/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_07)
+run(CB_07,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0484-rc-StackScan-CB_08/CB_08.java b/testsuite/java_test/rc_test/RC0484-rc-StackScan-CB_08/CB_08.java
new file mode 100644
index 0000000000000000000000000000000000000000..9aea8e5611d0bdbb8d3f7c2e9cec4e0906e9ea89
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0484-rc-StackScan-CB_08/CB_08.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.HashMap;
+class CB_08_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_08_A2 a2_0;
+    CB_08_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_08_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_08.check = this;
+    }
+}
+class CB_08_A2 {
+    volatile static HashMap test2;
+    CB_08_A1 a1_0;
+    CB_08_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_08_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_08_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class CB_08_A3 {
+    CB_08_A1 a1_0;
+    CB_08_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_08_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_08_A1.a + a2_0.a;
+    }
+}
+public class CB_08 {
+    public volatile static CB_08_A1 check = null;
+    private static CB_08_A1 a1_main = null;
+    private volatile static OutOfMemoryError test1;
+    private static OutOfMemoryError test2;
+    private CB_08() {
+        a1_main = new CB_08_A1("a1_main");
+        a1_main.a2_0 = new CB_08_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_08_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+    private static void test_CB_08(int times) {
+        CB_08_A1.test1 = new HashMap();
+        CB_08_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            test1 = new OutOfMemoryError();
+            CB_08_A1.test1.put(i, test1);
+            test2 = new OutOfMemoryError();
+            CB_08_A2.test2.put(i, test2);
+        }
+    }
+    private static void rc_testcase_main_wrapper() {
+        CB_08 cb01 = new CB_08();
+        test_CB_08(100000);
+        check = a1_main;
+        try {
+            int result = CB_08.check.sum + CB_08.check.a2_0.sum + CB_08.check.a2_0.a3_0.sum + CB_08_A1.test1.size() + CB_08_A2.test2.size();
+            if (result == 200918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0484-rc-StackScan-CB_08/expected.txt b/testsuite/java_test/rc_test/RC0484-rc-StackScan-CB_08/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0484-rc-StackScan-CB_08/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0484-rc-StackScan-CB_08/test.cfg b/testsuite/java_test/rc_test/RC0484-rc-StackScan-CB_08/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4b6e8c8bd73194d36f532c3357e0d523df887e1d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0484-rc-StackScan-CB_08/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_08)
+run(CB_08,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0485-rc-StackScan-CB_09/CB_09.java b/testsuite/java_test/rc_test/RC0485-rc-StackScan-CB_09/CB_09.java
new file mode 100644
index 0000000000000000000000000000000000000000..88ddccdcad4c484701c79beea06d6c1f082b818e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0485-rc-StackScan-CB_09/CB_09.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.HashMap;
+class CB_09_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_09_A2 a2_0;
+    CB_09_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_09_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_09.check = this;
+    }
+}
+class CB_09_A2 {
+    volatile static HashMap test2;
+    CB_09_A1 a1_0;
+    CB_09_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_09_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_09_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class CB_09_A3 {
+    CB_09_A1 a1_0;
+    CB_09_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_09_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_09_A1.a + a2_0.a;
+    }
+}
+public class CB_09 {
+    public static CB_09_A1 a1_main = null;
+    public volatile static CB_09_A1 check = null;
+    public volatile static ClassLoader test1;
+    public static ClassLoader test2;
+    public CB_09() {
+        a1_main = new CB_09_A1("a1_main");
+        a1_main.a2_0 = new CB_09_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_09_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+    }
+    public static void test_CB_09(int times) {
+        CB_09_A1.test1 = new HashMap();
+        CB_09_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            test1 = CB_09_A1.class.getClassLoader();
+            CB_09_A1.test1.put(i, test1);
+            test2 = CB_09_A1.class.getClassLoader();
+            CB_09_A2.test2.put(i, test2);
+        }
+    }
+    public static void rc_testcase_main_wrapper() {
+        CB_09 cb01 = new CB_09();
+        test_CB_09(100000);
+        check = a1_main;
+        try {
+            int result = CB_09.check.sum + CB_09.check.a2_0.sum + CB_09.check.a2_0.a3_0.sum;
+            if (result == 918)
+                System.out.println("ExpectResult");
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0485-rc-StackScan-CB_09/expected.txt b/testsuite/java_test/rc_test/RC0485-rc-StackScan-CB_09/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0485-rc-StackScan-CB_09/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0485-rc-StackScan-CB_09/test.cfg b/testsuite/java_test/rc_test/RC0485-rc-StackScan-CB_09/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..45d755ce1167416fa1112bcc12ea164cdaa8880e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0485-rc-StackScan-CB_09/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_09)
+run(CB_09,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01/CB_Thread_01.java b/testsuite/java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01/CB_Thread_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..89e58c20b4392cc8eb459a74740c688c23720580
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01/CB_Thread_01.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.HashMap;
+class CB_Nocycle_a_00180_A1 {
+    CB_Nocycle_a_00180_B1 b1_0;
+    CB_Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+class CB_Nocycle_a_00180_A2 {
+    CB_Nocycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+class CB_Nocycle_a_00180_A3 {
+    CB_Nocycle_a_00180_B2 b2_0;
+    CB_Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+class CB_Nocycle_a_00180_A4 {
+    CB_Nocycle_a_00180_B3 b3_0;
+    CB_Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+class CB_Nocycle_a_00180_B1 {
+    CB_Nocycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+class CB_Nocycle_a_00180_B2 {
+    CB_Nocycle_a_00180_C1 c1_0;
+    CB_Nocycle_a_00180_D1 d1_0;
+    CB_Nocycle_a_00180_D2 d2_0;
+    CB_Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+class CB_Nocycle_a_00180_B3 {
+    CB_Nocycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class CB_Nocycle_a_00180_C1 {
+    CB_Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class CB_Nocycle_a_00180_C2 {
+    CB_Nocycle_a_00180_D2 d2_0;
+    CB_Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+class CB_Nocycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CB_Nocycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+// 该树有12个节点
+class CB_Nocycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Nocycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+        // System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CB_Nocycle_a_00180 {
+    public CB_Nocycle_a_00180() {
+        CB_Nocycle_a_00180_A1 a1_main = new CB_Nocycle_a_00180_A1("a1_main");
+        CB_Nocycle_a_00180_A2 a2_main = new CB_Nocycle_a_00180_A2("a2_main");
+        CB_Nocycle_a_00180_A3 a3_main = new CB_Nocycle_a_00180_A3("a3_main");
+        CB_Nocycle_a_00180_A4 a4_main = new CB_Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new CB_Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0 = new CB_Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new CB_Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a2_main.b2_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0.d3_0 = new CB_Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0 = new CB_Nocycle_a_00180_B2("b2_0");
+        a3_main.b2_0.c1_0 = new CB_Nocycle_a_00180_C1("c1_0");
+        a3_main.b2_0.c1_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a3_main.b2_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a3_main.b2_0.d3_0 = new CB_Nocycle_a_00180_D3("d3_0");
+        a3_main.c2_0 = new CB_Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a3_main.c2_0.d3_0 = new CB_Nocycle_a_00180_D3("d3_0");
+        a4_main.b3_0 = new CB_Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = new CB_Nocycle_a_00180_C1("c1_0");
+        a4_main.b3_0.c1_0.d1_0 = new CB_Nocycle_a_00180_D1("d1_0");
+        a4_main.c2_0 = new CB_Nocycle_a_00180_C2("c2_0");
+        a4_main.c2_0.d2_0 = new CB_Nocycle_a_00180_D2("d2_0");
+        a4_main.c2_0.d3_0 = new CB_Nocycle_a_00180_D3("d3_0");
+    }
+}
+class CB_Thread_01_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_Thread_01_A2 a2_0;
+    CB_Thread_01_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_Thread_01_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+        // System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        // System.out.println("A finalize");
+        CB_Thread_01.check = this;
+    }
+}
+class CB_Thread_01_A2 {
+    volatile static HashMap test2;
+    CB_Thread_01_A1 a1_0;
+    CB_Thread_01_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Thread_01_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_Thread_01_A1.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+//        System.out.println("B finalize");
+    }
+}
+class CB_Thread_01_A3 {
+    static CB_Nocycle_a_00180[] test1;
+    CB_Thread_01_A1 a1_0;
+    CB_Thread_01_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Thread_01_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_Thread_01_A1.a + a2_0.a;
+    }
+}
+class CB_Thread_01_test extends Thread {
+    private static CB_Thread_01_A1 a1_main = null;
+    private static void test_CB_Thread_01(int times) {
+        CB_Thread_01_A1.test1 = new HashMap();
+        CB_Thread_01_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_Thread_01_A1.test1.put(i, new CB_Nocycle_a_00180());
+            CB_Thread_01_A2.test2.put(i, new CB_Nocycle_a_00180());
+        }
+    }
+    public void run() {
+        a1_main = new CB_Thread_01_A1("a1_main");
+        a1_main.a2_0 = new CB_Thread_01_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_Thread_01_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        test_CB_Thread_01(10000);
+        a1_main = null;
+        CB_Thread_01.check = null;
+    }
+}
+public class CB_Thread_01 {
+    public static CB_Thread_01_A1 check = null;
+    private static CB_Thread_01_A1 a1_main = null;
+    private static CB_Thread_01_test cbtest1;
+    private volatile static CB_Thread_01_test cbtest2;
+    public static void main(String[] args) {
+        a1_main = new CB_Thread_01_A1("a1_main");
+        a1_main.a2_0 = new CB_Thread_01_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_Thread_01_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main = null;
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        try {
+            int result = CB_Thread_01.check.sum + CB_Thread_01.check.a2_0.sum + CB_Thread_01.check.a2_0.a3_0.sum;
+            if (result == 918) {
+                System.out.println("ExpectResult");
+            }
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01/expected.txt b/testsuite/java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01/test.cfg b/testsuite/java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ae4af64ec4d1fc4218c419749c0bfdbb00f1c701
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0486-rc-StackScan-CB_Thread_01/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_Thread_01)
+run(CB_Thread_01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02/CB_Thread_02.java b/testsuite/java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02/CB_Thread_02.java
new file mode 100644
index 0000000000000000000000000000000000000000..831d33bae443f17fb5f804b2801071c0a48b7a65
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02/CB_Thread_02.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.HashMap;
+class CB_Thread_02_A1 {
+    static HashMap test1;
+    static
+    int a;
+    CB_Thread_02_A2 a2_0;
+    CB_Thread_02_A3 a3_0;
+    int sum;
+    String strObjectName;
+    CB_Thread_02_A1(String strObjectName) {
+        a2_0 = null;
+        a3_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a2_0.a + a3_0.a;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        CB_Thread_02_test.check = this;
+    }
+}
+class CB_Thread_02_A2 {
+    volatile static HashMap test2;
+    CB_Thread_02_A1 a1_0;
+    CB_Thread_02_A3 a3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Thread_02_A2(String strObjectName) {
+        a1_0 = null;
+        a3_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_Thread_02_A1.a + a3_0.a;
+    }
+    public void finalize() throws Throwable {
+        super.finalize();
+    }
+}
+class CB_Thread_02_A3 {
+    CB_Thread_02_A1 a1_0;
+    CB_Thread_02_A2 a2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    CB_Thread_02_A3(String strObjectName) {
+        a1_0 = null;
+        a2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + CB_Thread_02_A1.a + a2_0.a;
+    }
+}
+class CB_Thread_02_test extends Thread {
+    public volatile static CB_Thread_02_A1 check = null;
+    private static CB_Thread_02_A1 a1_main = null;
+    private static void test_CB_Thread_02(int times) {
+        CB_Thread_02_A1.test1 = new HashMap();
+        CB_Thread_02_A2.test2 = new HashMap();
+        for (int i = 0; i < times; i++) {
+            CB_Thread_02_A1.test1.put(i, "Maple" + i);
+            CB_Thread_02_A2.test2.put(i, "Figo" + i);
+        }
+    }
+    public void run() {
+        a1_main = new CB_Thread_02_A1("a1_main");
+        a1_main.a2_0 = new CB_Thread_02_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_Thread_02_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        test_CB_Thread_02(10000);
+        a1_main = null;
+        CB_Thread_02_test.check = null;
+    }
+}
+public class CB_Thread_02 {
+    private static CB_Thread_02_A1 a1_main = null;
+    public static void main(String[] args) {
+        a1_main = new CB_Thread_02_A1("a1_main");
+        a1_main.a2_0 = new CB_Thread_02_A2("a2_0");
+        a1_main.a2_0.a1_0 = a1_main;
+        a1_main.a2_0.a3_0 = new CB_Thread_02_A3("a3_0");
+        a1_main.a3_0 = a1_main.a2_0.a3_0;
+        a1_main.a3_0.a1_0 = a1_main;
+        a1_main.a3_0.a2_0 = a1_main.a2_0;
+        a1_main.add();
+        a1_main.a2_0.add();
+        a1_main.a2_0.a3_0.add();
+        a1_main = null;
+        Runtime.getRuntime().gc();
+        Runtime.getRuntime().runFinalization();
+        try {
+            int result = CB_Thread_02_test.check.sum + CB_Thread_02_test.check.a2_0.sum +
+                    CB_Thread_02_test.check.a2_0.a3_0.sum;
+            if (result == 918) {
+                System.out.println("ExpectResult");
+            }
+        } catch (NullPointerException n) {
+            System.out.println("ErrorResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02/expected.txt b/testsuite/java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02/test.cfg b/testsuite/java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..46f5a6f99bc914b94a75f4c1575a06a97fc9ed09
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0487-rc-StackScan-CB_Thread_02/test.cfg
@@ -0,0 +1,2 @@
+compile(CB_Thread_02)
+run(CB_Thread_02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0488-rc-StackScan-CP_Thread_03/CP_Thread_03.java b/testsuite/java_test/rc_test/RC0488-rc-StackScan-CP_Thread_03/CP_Thread_03.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e84acb4e86d6bc27bbca20533df73c89cf03d09
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0488-rc-StackScan-CP_Thread_03/CP_Thread_03.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class CP_Thread_03_A1 {
+    static StringBuffer[] test1;
+    static
+    int a;
+    CP_Thread_03_A1 a2_0;
+    int sum;
+    String strObjectName;
+    CP_Thread_03_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CP_Thread_03_test extends Thread {
+    private static CP_Thread_03_A1 a1_main = null;
+    private volatile static CP_Thread_03_A1 a2 = null;
+    private volatile static StringBuffer test1;
+    private static StringBuffer test2;
+    private static void test_CP_Thread_03_A1(int times) {
+        CP_Thread_03_A1.test1 = new StringBuffer[times];
+        for (int i = 0; i < times; i++) {
+            test1 = new StringBuffer("maple" + i);
+            CP_Thread_03_A1.test1[i] = test1;
+        }
+    }
+    private static void test_CP_Thread_03_A2(int times) {
+        CP_Thread_03_A1.test1 = new StringBuffer[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new StringBuffer("maple" + times + i);
+            CP_Thread_03_A1.test1[i] = test2;
+        }
+    }
+    public void run() {
+        a1_main = new CP_Thread_03_A1("a1_main");
+        a2 = new CP_Thread_03_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_03_A1(10000);
+        test_CP_Thread_03_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+public class CP_Thread_03 {
+    private static CP_Thread_03_A1 a1_main = null;
+    private volatile static CP_Thread_03_A1 a2 = null;
+    public static void main(String[] args) {
+        CP_Thread_03_test cptest1 = new CP_Thread_03_test();
+        cptest1.run();
+        CP_Thread_03_test cptest2 = new CP_Thread_03_test();
+        cptest2.run();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0488-rc-StackScan-CP_Thread_03/expected.txt b/testsuite/java_test/rc_test/RC0488-rc-StackScan-CP_Thread_03/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0488-rc-StackScan-CP_Thread_03/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0488-rc-StackScan-CP_Thread_03/test.cfg b/testsuite/java_test/rc_test/RC0488-rc-StackScan-CP_Thread_03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..71bbc8e2e77c8ff87643fc7da63495687fab34b6
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0488-rc-StackScan-CP_Thread_03/test.cfg
@@ -0,0 +1,2 @@
+compile(CP_Thread_03)
+run(CP_Thread_03,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0489-rc-StackScan-CP_Thread_04/CP_Thread_04.java b/testsuite/java_test/rc_test/RC0489-rc-StackScan-CP_Thread_04/CP_Thread_04.java
new file mode 100644
index 0000000000000000000000000000000000000000..70d315602af4df784137714fa3d0dd68820503ab
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0489-rc-StackScan-CP_Thread_04/CP_Thread_04.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class CP_Thread_04_A1 {
+    static StringBuilder[] test1;
+    static
+    int a;
+    CP_Thread_04_A1 a2_0;
+    int sum;
+    String strObjectName;
+    CP_Thread_04_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CP_Thread_04_test extends Thread {
+    private static CP_Thread_04_A1 a1_main = null;
+    private volatile static CP_Thread_04_A1 a2 = null;
+    private volatile static StringBuilder test1;
+    private static StringBuilder test2;
+    private static void test_CP_Thread_04_A1(int times) {
+        CP_Thread_04_A1.test1 = new StringBuilder[times];
+        for (int i = 0; i < times; i++) {
+            test1 = new StringBuilder("maple" + i);
+            CP_Thread_04_A1.test1[i] = test1;
+        }
+    }
+    private static void test_CP_Thread_04_A2(int times) {
+        CP_Thread_04_A1.test1 = new StringBuilder[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new StringBuilder("maple" + times + i);
+            CP_Thread_04_A1.test1[i] = test2;
+        }
+    }
+    public void run() {
+        a1_main = new CP_Thread_04_A1("a1_main");
+        a2 = new CP_Thread_04_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_04_A1(10000);
+        test_CP_Thread_04_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+public class CP_Thread_04 {
+    private static CP_Thread_04_A1 a1_main = null;
+    private static CP_Thread_04_A1 a2 = null;
+    public static void main(String[] args) {
+        CP_Thread_04_test cptest1 = new CP_Thread_04_test();
+        cptest1.run();
+        CP_Thread_04_test cptest2 = new CP_Thread_04_test();
+        cptest2.run();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0489-rc-StackScan-CP_Thread_04/expected.txt b/testsuite/java_test/rc_test/RC0489-rc-StackScan-CP_Thread_04/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0489-rc-StackScan-CP_Thread_04/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0489-rc-StackScan-CP_Thread_04/test.cfg b/testsuite/java_test/rc_test/RC0489-rc-StackScan-CP_Thread_04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e3ca029263c02bee784256d9aa962cd5389152c7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0489-rc-StackScan-CP_Thread_04/test.cfg
@@ -0,0 +1,2 @@
+compile(CP_Thread_04)
+run(CP_Thread_04,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0490-rc-StackScan-CP_Thread_05/CP_Thread_05.java b/testsuite/java_test/rc_test/RC0490-rc-StackScan-CP_Thread_05/CP_Thread_05.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc6b56bf24506b385721d1a1a926797c681363c9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0490-rc-StackScan-CP_Thread_05/CP_Thread_05.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.SoftReference;
+class CP_Thread_05_A1 {
+    static SoftReference[] test1;
+    static
+    int a;
+    CP_Thread_05_A1 a2_0;
+    int sum;
+    String strObjectName;
+    CP_Thread_05_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CP_Thread_05_test extends Thread {
+    static String str;
+    private static CP_Thread_05_A1 a1_main = null;
+    private volatile static CP_Thread_05_A1 a2 = null;
+    private volatile static SoftReference test1;
+    private static SoftReference test2;
+    private static void test_CP_Thread_05_A1(int times) {
+        CP_Thread_05_A1.test1 = new SoftReference[times];
+        for (int i = 0; i < times; i++) {
+            str = "maple" + i;
+            test1 = new SoftReference<>(str);
+            CP_Thread_05_A1.test1[i] = test1;
+        }
+    }
+    private static void test_CP_Thread_05_A2(int times) {
+        CP_Thread_05_A1.test1 = new SoftReference[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new SoftReference<>("maple" + times + i);
+            CP_Thread_05_A1.test1[i] = test2;
+        }
+    }
+    public void run() {
+        a1_main = new CP_Thread_05_A1("a1_main");
+        a2 = new CP_Thread_05_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_05_A1(10000);
+        test_CP_Thread_05_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+public class CP_Thread_05 {
+    private static CP_Thread_05_A1 a1_main = null;
+    private static CP_Thread_05_A1 a2 = null;
+    public static void main(String[] args) {
+        CP_Thread_05_test cptest1 = new CP_Thread_05_test();
+        cptest1.run();
+        CP_Thread_05_test cptest2 = new CP_Thread_05_test();
+        cptest2.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0490-rc-StackScan-CP_Thread_05/expected.txt b/testsuite/java_test/rc_test/RC0490-rc-StackScan-CP_Thread_05/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0490-rc-StackScan-CP_Thread_05/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0490-rc-StackScan-CP_Thread_05/test.cfg b/testsuite/java_test/rc_test/RC0490-rc-StackScan-CP_Thread_05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4bd663ea9d73787384f9f4940d72ae06e3a12d46
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0490-rc-StackScan-CP_Thread_05/test.cfg
@@ -0,0 +1,2 @@
+compile(CP_Thread_05)
+run(CP_Thread_05,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0491-rc-StackScan-CP_Thread_06/CP_Thread_06.java b/testsuite/java_test/rc_test/RC0491-rc-StackScan-CP_Thread_06/CP_Thread_06.java
new file mode 100644
index 0000000000000000000000000000000000000000..d774cc0569ef525bad87425215f43cb6d084260d
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0491-rc-StackScan-CP_Thread_06/CP_Thread_06.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+class CP_Thread_06_A1 {
+    static WeakReference[] test1;
+    static
+    int a;
+    CP_Thread_06_A1 a2_0;
+    int sum;
+    String strObjectName;
+    CP_Thread_06_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CP_Thread_06_test extends Thread {
+    static String str;
+    private static CP_Thread_06_A1 a1_main = null;
+    private volatile static CP_Thread_06_A1 a2 = null;
+    private volatile static WeakReference test1;
+    private static WeakReference test2;
+    private static void test_CP_Thread_06_A1(int times) {
+        CP_Thread_06_A1.test1 = new WeakReference[times];
+        for (int i = 0; i < times; i++) {
+            str = "maple" + i;
+            test1 = new WeakReference<>(str);
+            CP_Thread_06_A1.test1[i] = test1;
+        }
+    }
+    private static void test_CP_Thread_06_A2(int times) {
+        CP_Thread_06_A1.test1 = new WeakReference[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new WeakReference<>("maple" + times + i);
+            CP_Thread_06_A1.test1[i] = test2;
+        }
+    }
+    public void run() {
+        a1_main = new CP_Thread_06_A1("a1_main");
+        a2 = new CP_Thread_06_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_06_A1(10000);
+        test_CP_Thread_06_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+public class CP_Thread_06 {
+    private static CP_Thread_06_A1 a1_main = null;
+    private static CP_Thread_06_A1 a2 = null;
+    public static void main(String[] args) {
+        CP_Thread_06_test cptest1 = new CP_Thread_06_test();
+        cptest1.run();
+        CP_Thread_06_test cptest2 = new CP_Thread_06_test();
+        cptest2.run();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0491-rc-StackScan-CP_Thread_06/expected.txt b/testsuite/java_test/rc_test/RC0491-rc-StackScan-CP_Thread_06/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0491-rc-StackScan-CP_Thread_06/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0491-rc-StackScan-CP_Thread_06/test.cfg b/testsuite/java_test/rc_test/RC0491-rc-StackScan-CP_Thread_06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..664532ad4823b3fd64f15e5cb6ae3438f838f5be
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0491-rc-StackScan-CP_Thread_06/test.cfg
@@ -0,0 +1,2 @@
+compile(CP_Thread_06)
+run(CP_Thread_06,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0492-rc-StackScan-CP_Thread_07/CP_Thread_07.java b/testsuite/java_test/rc_test/RC0492-rc-StackScan-CP_Thread_07/CP_Thread_07.java
new file mode 100644
index 0000000000000000000000000000000000000000..54661251e9ea4867f69e2434d20bc654886dc48f
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0492-rc-StackScan-CP_Thread_07/CP_Thread_07.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+class CP_Thread_07_A1 {
+    static PhantomReference[] test1;
+    static
+    int a;
+    CP_Thread_07_A1 a2_0;
+    int sum;
+    String strObjectName;
+    CP_Thread_07_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CP_Thread_07_test extends Thread {
+    static ReferenceQueue rq = new ReferenceQueue();
+    static String str;
+    private static CP_Thread_07_A1 a1_main = null;
+    private volatile static CP_Thread_07_A1 a2 = null;
+    private static void test_CP_Thread_07_A1(int times) {
+        CP_Thread_07_A1.test1 = new PhantomReference[times];
+        for (int i = 0; i < times; i++) {
+            str = "maple" + i;
+            PhantomReference<String> temp = new PhantomReference<>(str, rq);
+            CP_Thread_07_A1.test1[i] = temp;
+        }
+    }
+    private static void test_CP_Thread_07_A2(int times) {
+        CP_Thread_07_A1.test1 = new PhantomReference[times];
+        for (int i = 0; i < times; i++) {
+            PhantomReference<String> temp = new PhantomReference<>(str + times + i, rq);
+            CP_Thread_07_A1.test1[i] = temp;
+        }
+    }
+    public void run() {
+        a1_main = new CP_Thread_07_A1("a1_main");
+        a2 = new CP_Thread_07_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_07_A1(10000);
+        test_CP_Thread_07_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+public class CP_Thread_07 {
+    private static CP_Thread_07_A1 a1_main = null;
+    private static CP_Thread_07_A1 a2 = null;
+    public static void main(String[] args) {
+        CP_Thread_07_test cptest1 = new CP_Thread_07_test();
+        cptest1.run();
+        CP_Thread_07_test cptest2 = new CP_Thread_07_test();
+        cptest2.run();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0492-rc-StackScan-CP_Thread_07/expected.txt b/testsuite/java_test/rc_test/RC0492-rc-StackScan-CP_Thread_07/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0492-rc-StackScan-CP_Thread_07/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0492-rc-StackScan-CP_Thread_07/test.cfg b/testsuite/java_test/rc_test/RC0492-rc-StackScan-CP_Thread_07/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..adb203f24fb5d7df61da55a107a791a7fa710514
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0492-rc-StackScan-CP_Thread_07/test.cfg
@@ -0,0 +1,2 @@
+compile(CP_Thread_07)
+run(CP_Thread_07,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0493-rc-StackScan-CP_Thread_08/CP_Thread_08.java b/testsuite/java_test/rc_test/RC0493-rc-StackScan-CP_Thread_08/CP_Thread_08.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e834019091a1bd9cb2841d2119b1909676c8b44
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0493-rc-StackScan-CP_Thread_08/CP_Thread_08.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class CP_Thread_08_A1 {
+    static OutOfMemoryError[] test1;
+    static
+    int a;
+    CP_Thread_08_A1 a2_0;
+    int sum;
+    String strObjectName;
+    CP_Thread_08_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CP_Thread_08_test extends Thread {
+    private static CP_Thread_08_A1 a1_main = null;
+    private volatile static CP_Thread_08_A1 a2 = null;
+    private volatile static OutOfMemoryError test1;
+    private static OutOfMemoryError test2;
+    private static void test_CP_Thread_08_A1(int times) {
+        CP_Thread_08_A1.test1 = new OutOfMemoryError[times];
+        for (int i = 0; i < times; i++) {
+            test1 = new OutOfMemoryError();
+            CP_Thread_08_A1.test1[i] = test1;
+        }
+    }
+    private static void test_CP_Thread_08_A2(int times) {
+        CP_Thread_08_A1.test1 = new OutOfMemoryError[times];
+        for (int i = 0; i < times; i++) {
+            test2 = new OutOfMemoryError();
+            CP_Thread_08_A1.test1[i] = test2;
+        }
+    }
+    public void run() {
+        a1_main = new CP_Thread_08_A1("a1_main");
+        a2 = new CP_Thread_08_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_08_A1(10000);
+        test_CP_Thread_08_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+public class CP_Thread_08 {
+    private static CP_Thread_08_A1 a1_main = null;
+    private volatile static CP_Thread_08_A1 a2 = null;
+    public static void main(String[] args) {
+        CP_Thread_08_test cptest1 = new CP_Thread_08_test();
+        cptest1.run();
+        CP_Thread_08_test cptest2 = new CP_Thread_08_test();
+        cptest2.run();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0493-rc-StackScan-CP_Thread_08/expected.txt b/testsuite/java_test/rc_test/RC0493-rc-StackScan-CP_Thread_08/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0493-rc-StackScan-CP_Thread_08/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0493-rc-StackScan-CP_Thread_08/test.cfg b/testsuite/java_test/rc_test/RC0493-rc-StackScan-CP_Thread_08/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..fc33182db59f37372e5f0123e5aed26fe81f9c9e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0493-rc-StackScan-CP_Thread_08/test.cfg
@@ -0,0 +1,2 @@
+compile(CP_Thread_08)
+run(CP_Thread_08,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0494-rc-StackScan-CP_Thread_09/CP_Thread_09.java b/testsuite/java_test/rc_test/RC0494-rc-StackScan-CP_Thread_09/CP_Thread_09.java
new file mode 100644
index 0000000000000000000000000000000000000000..a7015a5c9571de1c01c35f811458bb5453ca95ab
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0494-rc-StackScan-CP_Thread_09/CP_Thread_09.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class CP_Thread_09_A1 {
+    static ClassLoader[] test1;
+    static
+    int a;
+    CP_Thread_09_A1 a2_0;
+    int sum;
+    String strObjectName;
+    CP_Thread_09_A1(String strObjectName) {
+        a2_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class CP_Thread_09_test extends Thread {
+    private static CP_Thread_09_A1 a1_main = null;
+    private volatile static CP_Thread_09_A1 a2 = null;
+    private volatile static ClassLoader test1;
+    private static ClassLoader test2;
+    private static void test_CP_Thread_09_A1(int times) {
+        CP_Thread_09_A1.test1 = new ClassLoader[times];
+        for (int i = 0; i < times; i++) {
+            test1 = CP_Thread_09_A1.class.getClassLoader();
+            CP_Thread_09_A1.test1[i] = test1;
+        }
+    }
+    private static void test_CP_Thread_09_A2(int times) {
+        CP_Thread_09_A1.test1 = new ClassLoader[times];
+        for (int i = 0; i < times; i++) {
+            test2 = CP_Thread_09_A1.class.getClassLoader();
+            CP_Thread_09_A1.test1[i] = test2;
+        }
+    }
+    public void run() {
+        a1_main = new CP_Thread_09_A1("a1_main");
+        a2 = new CP_Thread_09_A1("a2_0");
+        a1_main.a2_0 = a2;
+        a1_main.a2_0.a2_0 = a2;
+        a1_main.add();
+        a1_main.a2_0.add();
+        test_CP_Thread_09_A1(10000);
+        test_CP_Thread_09_A2(10000);
+        int result = a1_main.sum + a1_main.a2_0.sum;
+        //System.out.println("RC-Testing_Result="+result);
+        if (result == 404)
+            System.out.println("ExpectResult");
+    }
+}
+public class CP_Thread_09 {
+    private static CP_Thread_09_A1 a1_main = null;
+    private volatile static CP_Thread_09_A1 a2 = null;
+    public static void main(String[] args) {
+        CP_Thread_09_test cptest1 = new CP_Thread_09_test();
+        cptest1.run();
+        CP_Thread_09_test cptest2 = new CP_Thread_09_test();
+        cptest2.run();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0494-rc-StackScan-CP_Thread_09/expected.txt b/testsuite/java_test/rc_test/RC0494-rc-StackScan-CP_Thread_09/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0494-rc-StackScan-CP_Thread_09/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0494-rc-StackScan-CP_Thread_09/test.cfg b/testsuite/java_test/rc_test/RC0494-rc-StackScan-CP_Thread_09/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d7028b83ee32d5ecea78a9fa5ebb710f9b89ed36
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0494-rc-StackScan-CP_Thread_09/test.cfg
@@ -0,0 +1,2 @@
+compile(CP_Thread_09)
+run(CP_Thread_09,EXPECTNUM=2)
diff --git a/testsuite/java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/FrequentSystemGC_01.java b/testsuite/java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/FrequentSystemGC_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..357872308f13ea7f147e0a465de5f2f26a0be437
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/FrequentSystemGC_01.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+class MyThread extends Thread {
+    public void run(){
+        try {
+            Thread.sleep(index * FrequentSystemGC_01.THREAD_SLEEP_UNIT);
+        } catch (Exception e) {
+            // System.out.println("Exception from thread sleep: " + index);
+            // do nothing, just continue test...
+        }
+        WeakReference weak = new WeakReference<Object>(new Object());
+        if (weak.get() == null) {
+            return;
+        }
+        Runtime.getRuntime().gc();
+        if (weak.get() != null) {
+            System.out.println("MyThread" + index + " check fail");
+            FrequentSystemGC_01.totalResult = false;
+        }
+   }
+   public MyThread(int i) {
+       index = i;
+   }
+   private int index;
+}
+public class FrequentSystemGC_01 {
+    public static final int THREAD_COUNT = 50;
+    public static boolean totalResult = true;
+    public static final long THREAD_SLEEP_UNIT = 1;
+    public static ArrayList<Thread> threads = new ArrayList<>();
+    public static void main(String[] args) {
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            Thread t = new MyThread(i);
+            threads.add(t);
+            t.start();
+        }
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            try {
+                threads.get(i).join();
+            } catch (Exception e) {
+                System.out.println("Exception from join thread: " + i + " need re-test!");
+                return;
+            }
+        }
+        if (FrequentSystemGC_01.totalResult == true) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, weak is not freed after system.gc() in some thread!");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/expected.txt b/testsuite/java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/test.cfg b/testsuite/java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..96668f3830e45d67616aa32531303e4ac3ecfcff
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0495-rc-GC-TaskQueue-FrequentSystemGC_01/test.cfg
@@ -0,0 +1,2 @@
+compile(FrequentSystemGC_01)
+run(FrequentSystemGC_01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/StartupInvoke_01.java b/testsuite/java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/StartupInvoke_01.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9b0b19eb22aa6bb51d550a0ce32635e5388d108
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/StartupInvoke_01.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+public class StartupInvoke_01 {
+    static WeakReference observer;
+    static int check = 2;
+    private final static int INIT_MEMORY = 100; // MB
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        for (int i = 0; i < INIT_MEMORY; i++) {
+            byte[] temp = new byte[1024*1024];
+            store.add(temp);
+        }
+        Thread.sleep(3000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/expected.txt b/testsuite/java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/test.cfg b/testsuite/java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..0746557a487e71e1bf0c466b11bc15059afe9990
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0496-rc-GC-TaskQueue-StartupInvoke_01/test.cfg
@@ -0,0 +1,2 @@
+compile(StartupInvoke_01)
+run(StartupInvoke_01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0507-JTreg-CheckLoops/CheckLoops.java b/testsuite/java_test/rc_test/RC0507-JTreg-CheckLoops/CheckLoops.java
new file mode 100755
index 0000000000000000000000000000000000000000..3b2169b8a678926f69f822a9a2f540b750c2bd1c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0507-JTreg-CheckLoops/CheckLoops.java
@@ -0,0 +1,1005 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class CheckLoops {
+    private static int sResult;
+    //
+    // Various sequence variables used in bound checks.
+    //
+    // CHECK-START: void Main.bubble(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.bubble(int[]) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    private static void bubble(int[] a) {
+        for (int i = a.length; --i >= 0; ) {
+            for (int j = 0; j < i; j++) {
+                if (a[j] > a[j + 1]) {
+                    int tmp = a[j];
+                    a[j] = a[j + 1];
+                    a[j + 1] = tmp;
+                }
+            }
+        }
+    }
+    // CHECK-START: int Main.periodicIdiom(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.periodicIdiom(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int periodicIdiom(int tc) {
+        int[] x = {1, 3};
+        // Loop with periodic sequence (0, 1).
+        int k = 0;
+        int result = 0;
+        for (int i = 0; i < tc; i++) {
+            result += x[k];
+            k = 1 - k;
+        }
+        return result;
+    }
+    // CHECK-START: int Main.periodicSequence2(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.periodicSequence2(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int periodicSequence2(int tc) {
+        int[] x = {1, 3};
+        // Loop with periodic sequence (0, 1).
+        int k = 0;
+        int l = 1;
+        int result = 0;
+        for (int i = 0; i < tc; i++) {
+            result += x[k];
+            int t = l;
+            l = k;
+            k = t;
+        }
+        return result;
+    }
+    // CHECK-START: int Main.periodicSequence4(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    // CHECK-DAG: BoundsCheck
+    // CHECK-DAG: BoundsCheck
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.periodicSequence4(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int periodicSequence4(int tc) {
+        int[] x = {1, 3, 5, 7};
+        // Loop with periodic sequence (0, 1, 2, 3).
+        int k = 0;
+        int l = 1;
+        int m = 2;
+        int n = 3;
+        int result = 0;
+        for (int i = 0; i < tc; i++) {
+            result += x[k] + x[l] + x[m] + x[n]; // all used at once
+            int t = n;
+            n = k;
+            k = l;
+            l = m;
+            m = t;
+        }
+        return result;
+    }
+    // CHECK-START: int Main.justRightUp1() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightUp1() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightUp1() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MAX_VALUE - 10, k = 0; i < Integer.MAX_VALUE; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.justRightUp2() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightUp2() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightUp2() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MAX_VALUE - 10; i < Integer.MAX_VALUE; i++) {
+            result += x[i - Integer.MAX_VALUE + 10];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.justRightUp3() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightUp3() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightUp3() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MAX_VALUE - 10, k = 0; i <= Integer.MAX_VALUE - 1; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.justOOBUp() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justOOBUp() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justOOBUp() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static int justOOBUp() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        // Infinite loop!
+        for (int i = Integer.MAX_VALUE - 9, k = 0; i <= Integer.MAX_VALUE; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.justRightDown1() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightDown1() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightDown1() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MIN_VALUE + 10, k = 0; i > Integer.MIN_VALUE; i--) {
+            result += x[k++];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.justRightDown2() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightDown2() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightDown2() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MIN_VALUE + 10; i > Integer.MIN_VALUE; i--) {
+            result += x[Integer.MAX_VALUE + i];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.justRightDown3() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justRightDown3() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int justRightDown3() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        for (int i = Integer.MIN_VALUE + 10, k = 0; i >= Integer.MIN_VALUE + 1; i--) {
+            result += x[k++];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.justOOBDown() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justOOBDown() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int Main.justOOBDown() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static int justOOBDown() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int result = 0;
+        // Infinite loop!
+        for (int i = Integer.MIN_VALUE + 9, k = 0; i >= Integer.MIN_VALUE; i--) {
+            result += x[k++];
+        }
+        return result;
+    }
+    // CHECK-START: void Main.lowerOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.lowerOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.lowerOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void lowerOOB(int[] x) {
+        // OOB!
+        for (int i = -1; i < x.length; i++) {
+            sResult += x[i];
+        }
+    }
+    // CHECK-START: void Main.upperOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.upperOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.upperOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void upperOOB(int[] x) {
+        // OOB!
+        for (int i = 0; i <= x.length; i++) {
+            sResult += x[i];
+        }
+    }
+    // CHECK-START: void Main.doWhileUpOOB() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.doWhileUpOOB() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.doWhileUpOOB() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void doWhileUpOOB() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int i = 0;
+        // OOB!
+        do {
+            sResult += x[i++];
+        } while (i <= x.length);
+    }
+    // CHECK-START: void Main.doWhileDownOOB() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.doWhileDownOOB() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.doWhileDownOOB() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void doWhileDownOOB() {
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int i = x.length - 1;
+        // OOB!
+        do {
+            sResult += x[i--];
+        } while (-1 <= i);
+    }
+    // CHECK-START: void Main.hiddenOOB1(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenOOB1(int) BCE (after)
+    // CHECK-DAG: Deoptimize
+    //
+    // CHECK-START: void Main.hiddenOOB1(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    private static void hiddenOOB1(int lo) {
+        int[] a = {1};
+        for (int i = lo; i <= 10; i++) {
+            // Dangerous loop where careless static range analysis would yield strict upper bound
+            // on index j of 5. When, for instance, lo and thus i = -2147483648, the upper bound
+            // becomes really positive due to arithmetic wrap-around, causing OOB.
+            // Dynamic BCE is feasible though, since it checks the range.
+            for (int j = 4; j < i - 5; j++) {
+                sResult += a[j - 4];
+            }
+        }
+    }
+    // CHECK-START: void Main.hiddenOOB2(int) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenOOB2(int) BCE (after)
+    // CHECK-DAG: Deoptimize
+    //
+    // CHECK-START: void Main.hiddenOOB2(int) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    private static void hiddenOOB2(int hi) {
+        int[] a = {1};
+        for (int i = 0; i < hi; i++) {
+            // Dangerous loop where careless static range analysis would yield strict lower bound
+            // on index j of 5. When, for instance, hi and thus i = 2147483647, the upper bound
+            // becomes really negative due to arithmetic wrap-around, causing OOB.
+            // Dynamic BCE is feasible though, since it checks the range.
+            for (int j = 6; j > i + 5; j--) {
+                sResult += a[j - 6];
+            }
+        }
+    }
+    // CHECK-START: void Main.hiddenInfiniteOOB() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenInfiniteOOB() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenInfiniteOOB() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void hiddenInfiniteOOB() {
+        int[] a = {11};
+        for (int i = -1; i <= 0; i++) {
+            // Dangerous loop where careless static range analysis would yield a safe upper bound
+            // of -3. In reality, due to arithmetic wrap-around (when i = -1, j <= 2147483647;
+            // whereas when i = 0, j <= -3), this is an infinite loop that goes OOB.
+            for (int j = -3; j <= 2147483646 * i - 3; j++) {
+                sResult += a[j + 3];
+            }
+        }
+    }
+    // CHECK-START: void Main.hiddenFiniteOOB() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.hiddenFiniteOOB() BCE (after)
+    // CHECK-DAG: Deoptimize
+    //
+    // CHECK-START: void Main.hiddenFiniteOOB() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    private static void hiddenFiniteOOB() {
+        int[] a = {111};
+        for (int i = -1; i <= 0; i++) {
+            // Dangerous loop similar as above where the loop is now finite, but the
+            // loop still goes out of bounds for i = -1 due to the large upper bound.
+            // Dynamic BCE is feasible though, since it checks the range.
+            for (int j = -4; j < 2147483646 * i - 3; j++) {
+                sResult += a[j + 4];
+            }
+        }
+    }
+    // CHECK-START: void Main.inductionOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.inductionOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.inductionOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void inductionOOB(int[] a) {
+        // Careless range analysis would remove the bounds check.
+        // However, the narrower induction b wraps around arithmetically
+        // before it reaches the end of arrays longer than 127.
+        byte b = 0;
+        for (int i = 0; i < a.length; i++) {
+            a[b++] = i;
+        }
+    }
+    // CHECK-START: void Main.controlOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.controlOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.controlOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void controlOOB(int[] a) {
+        // As above, but now the loop control also wraps around.
+        for (byte i = 0; i < a.length; i++) {
+            a[i] = -i;
+        }
+    }
+    // CHECK-START: void Main.conversionOOB(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.conversionOOB(int[]) BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: void Main.conversionOOB(int[]) BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static void conversionOOB(int[] a) {
+        // As above, but with wrap around caused by an explicit conversion.
+        for (int i = 0; i < a.length; ) {
+            a[i] = i;
+            i = (byte) (i + 1);
+        }
+    }
+    // CHECK-START: int[] Main.add() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int[] Main.add() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int[] add() {
+        int[] a = new int[10];
+        for (int i = 0; i <= 3; i++) {
+            for (int j = 0; j <= 6; j++) {
+                a[i + j] += 1;
+            }
+        }
+        return a;
+    }
+    // CHECK-START: int[] Main.multiply1() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int[] Main.multiply1() BCE (after)
+    // CHECK-NOT: BoundsCheck
+    // CHECK-NOT: Deoptimize
+    private static int[] multiply1() {
+        int[] a = new int[10];
+        try {
+            for (int i = 0; i <= 3; i++) {
+                for (int j = 0; j <= 3; j++) {
+                    // Range [0,9]: safe.
+                    a[i * j] += 1;
+                }
+            }
+        } catch (Exception e) {
+            a[0] += 1000;
+        }
+        return a;
+    }
+    // CHECK-START: int[] Main.multiply2() BCE (before)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int[] Main.multiply2() BCE (after)
+    // CHECK-DAG: BoundsCheck
+    //
+    // CHECK-START: int[] Main.multiply2() BCE (after)
+    // CHECK-NOT: Deoptimize
+    private static int[] multiply2() {
+        int[] a = new int[10];
+        try {
+            for (int i = -3; i <= 3; i++) {
+                for (int j = -3; j <= 3; j++) {
+                    // Range [-9,9]: unsafe.
+                    a[i * j] += 1;
+                }
+            }
+        } catch (Exception e) {
+            a[0] += 1000;
+        }
+        return a;
+    }
+    // CHECK-START: int Main.linearDynamicBCE1(int[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.linearDynamicBCE1(int[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.linearDynamicBCE1(int[], int, int) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int linearDynamicBCE1(int[] x, int lo, int hi) {
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            sResult += x[i];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.linearDynamicBCE2(int[], int, int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.linearDynamicBCE2(int[], int, int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.linearDynamicBCE2(int[], int, int, int) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int linearDynamicBCE2(int[] x, int lo, int hi, int offset) {
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            sResult += x[offset + i];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.wrapAroundDynamicBCE(int[]) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.wrapAroundDynamicBCE(int[]) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.wrapAroundDynamicBCE(int[]) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int wrapAroundDynamicBCE(int[] x) {
+        int w = 9;
+        int result = 0;
+        for (int i = 0; i < 10; i++) {
+            result += x[w];
+            w = i;
+        }
+        return result;
+    }
+    // CHECK-START: int Main.periodicDynamicBCE(int[]) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.periodicDynamicBCE(int[]) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.periodicDynamicBCE(int[]) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int periodicDynamicBCE(int[] x) {
+        int k = 0;
+        int result = 0;
+        for (int i = 0; i < 10; i++) {
+            result += x[k];
+            k = 1 - k;
+        }
+        return result;
+    }
+    // CHECK-START: int Main.dynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:{{B\d+}}
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.dynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int dynamicBCEPossiblyInfiniteLoop(int[] x, int lo, int hi) {
+        // This loop could be infinite for hi = max int. Since i is also used
+        // as subscript, however, dynamic bce can proceed.
+        int result = 0;
+        for (int i = lo; i <= hi; i++) {
+            result += x[i];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.noDynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.noDynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.noDynamicBCEPossiblyInfiniteLoop(int[], int, int) BCE (after)
+    // CHECK-NOT: Deoptimize
+    static int noDynamicBCEPossiblyInfiniteLoop(int[] x, int lo, int hi) {
+        // As above, but now the index is not used as subscript,
+        // and dynamic bce is not applied.
+        int result = 0;
+        for (int k = 0, i = lo; i <= hi; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.noDynamicBCEMixedInductionTypes(int[], long, long) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.noDynamicBCEMixedInductionTypes(int[], long, long) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.noDynamicBCEMixedInductionTypes(int[], long, long) BCE (after)
+    // CHECK-NOT: Deoptimize
+    static int noDynamicBCEMixedInductionTypes(int[] x, long lo, long hi) {
+        int result = 0;
+        // Mix of int and long induction.
+        int k = 0;
+        for (long i = lo; i < hi; i++) {
+            result += x[k++];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.dynamicBCEConstantRange(int[]) BCE (before)
+    // CHECK-DAG: BoundsCheck loop:<<InnerLoop:B\d+>>
+    // CHECK-DAG: ArrayGet    loop:<<InnerLoop>>
+    // CHECK-DAG: If          loop:<<InnerLoop>>
+    // CHECK-DAG: If          loop:<<OuterLoop:B\d+>>
+    // CHECK-EVAL: "<<InnerLoop>>" != "<<OuterLoop>>"
+    //
+    // CHECK-START: int Main.dynamicBCEConstantRange(int[]) BCE (after)
+    // CHECK-DAG: ArrayGet   loop:<<InnerLoop:B\d+>>
+    // CHECK-DAG: Deoptimize loop:<<OuterLoop:B\d+>>
+    // CHECK-EVAL: "<<InnerLoop>>" != "<<OuterLoop>>"
+    //
+    // CHECK-START: int Main.dynamicBCEConstantRange(int[]) BCE (after)
+    // CHECK-NOT: BoundsCheck
+    //
+    //  No additional top tests were introduced.
+    // CHECK-START: int Main.dynamicBCEConstantRange(int[]) BCE (after)
+    // CHECK-DAG: If
+    // CHECK-DAG: If
+    // CHECK-NOT: If
+    static int dynamicBCEConstantRange(int[] x) {
+        int result = 0;
+        for (int i = 2; i <= 6; i++) {
+            // Range analysis sees that innermost loop is finite and always taken.
+            for (int j = i - 2; j <= i + 2; j++) {
+                result += x[j];
+            }
+        }
+        return result;
+    }
+    // CHECK-START: int Main.dynamicBCEAndConstantIndices(int[], int[][], int, int) BCE (before)
+    // CHECK-DAG: {{l\d+}} ArrayGet loop:<<Loop:B\d+>>
+    // CHECK-DAG: {{l\d+}} ArrayGet loop:<<Loop>>
+    // CHECK-DAG: {{l\d+}} ArrayGet loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndices(int[], int[][], int, int) BCE (after)
+    //  Order matters:
+    // CHECK:              Deoptimize loop:<<Loop:B\d+>>
+    //  CHECK-NOT:          Goto       loop:<<Loop>>
+    // CHECK-DAG: {{l\d+}} ArrayGet   loop:<<Loop>>
+    // CHECK-DAG: {{l\d+}} ArrayGet   loop:<<Loop>>
+    // CHECK-DAG: {{l\d+}} ArrayGet   loop:<<Loop>>
+    // CHECK:              Goto       loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndices(int[], int[][], int, int) BCE (after)
+    // CHECK-DAG: Deoptimize loop:none
+    static int dynamicBCEAndConstantIndices(int[] x, int[][] a, int lo, int hi) {
+        // Deliberately test array length on a before the loop so that only bounds checks
+        // on constant subscripts remain, making them a viable candidate for hoisting.
+        if (a.length == 0) {
+            return -1;
+        }
+        // Loop that allows BCE on x[i].
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            result += x[i];
+            if ((i % 10) != 0) {
+                // None of the subscripts inside a conditional are removed by dynamic bce,
+                // making them a candidate for deoptimization based on constant indices.
+                // Compiler should ensure the array loads are not subsequently hoisted
+                // "above" the deoptimization "barrier" on the bounds.
+                a[0][i] = 1;
+                a[1][i] = 2;
+                a[99][i] = 3;
+            }
+        }
+        return result;
+    }
+    // CHECK-START: int Main.dynamicBCEAndConstantIndicesAllPrimTypes(int[], boolean[], byte[], char[], short[], int[], long[], float[], double[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    //  For brevity, just test occurrence of at least one of each in the loop:
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndicesAllPrimTypes(int[], boolean[], byte[], char[], short[], int[], long[], float[], double[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-NOT: ArrayGet    loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndicesAllPrimTypes(int[], boolean[], byte[], char[], short[], int[], long[], float[], double[], int, int) BCE (after)
+    // CHECK-NOT: NullCheck   loop:{{B\d+}}
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndicesAllPrimTypes(int[], boolean[], byte[], char[], short[], int[], long[], float[], double[], int, int) BCE (after)
+    // CHECK-DAG: Deoptimize  loop:none
+    private static int dynamicBCEAndConstantIndicesAllPrimTypes(int[] q, boolean[] r, byte[] s, char[] t, short[] u, int[] v, long[] w, float[] x, double[] y, int lo, int hi) {
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            // All constant index array references can be hoisted out of the loop during BCE on q[i].
+            result += q[i] + (r[0] ? 1 : 0) + (int) s[0] + (int) t[0] + (int) u[0] + v[0] + (int) w[0] + (int) x[0] + (int) y[0];
+        }
+        return result;
+    }
+    // CHECK-START: int Main.dynamicBCEAndConstantIndexRefType(int[], java.lang.Integer[], int, int) BCE (before)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    // CHECK-DAG: ArrayGet    loop:<<Loop>>
+    // CHECK-DAG: NullCheck   loop:<<Loop>>
+    // CHECK-DAG: ArrayLength loop:<<Loop>>
+    // CHECK-DAG: BoundsCheck loop:<<Loop>>
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndexRefType(int[], java.lang.Integer[], int, int) BCE (after)
+    // CHECK-DAG: ArrayGet    loop:<<Loop:B\d+>>
+    // CHECK-DAG: Deoptimize  loop:none
+    //
+    // CHECK-START: int Main.dynamicBCEAndConstantIndexRefType(int[], java.lang.Integer[], int, int) BCE (after)
+    // CHECK-NOT: ArrayLength loop:{{B\d+}}
+    // CHECK-NOT: BoundsCheck loop:{{B\d+}}
+    private static int dynamicBCEAndConstantIndexRefType(int[] q, Integer[] z, int lo, int hi) {
+        int result = 0;
+        for (int i = lo; i < hi; i++) {
+            // Similar to above, but now implicit call to intValue() may prevent hoisting
+            // z[0] itself during BCE on q[i]. Therefore, we just check BCE on q[i].
+            result += q[i] + z[0];
+        }
+        return result;
+    }
+    //
+    // Verifier.
+    //
+    public static void main(String[] args) {
+        // Set to run expensive tests for correctness too.
+        boolean heavy = false;
+        int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int[] a200 = new int[200];
+        // Sorting.
+        int[] sort = {5, 4, 1, 9, 10, 2, 7, 6, 3, 8};
+        bubble(sort);
+        for (int i = 0; i < 10; i++) {
+            expectEquals(sort[i], x[i]);
+        }
+        // Periodic adds (1, 3), one at the time.
+        expectEquals(0, periodicIdiom(-1));
+        for (int tc = 0; tc < 32; tc++) {
+            int expected = (tc >> 1) << 2;
+            if ((tc & 1) != 0)
+                expected += 1;
+            expectEquals(expected, periodicIdiom(tc));
+        }
+        // Periodic adds (1, 3), one at the time.
+        expectEquals(0, periodicSequence2(-1));
+        for (int tc = 0; tc < 32; tc++) {
+            int expected = (tc >> 1) << 2;
+            if ((tc & 1) != 0)
+                expected += 1;
+            expectEquals(expected, periodicSequence2(tc));
+        }
+        // Periodic adds (1, 3, 5, 7), all at once.
+        expectEquals(0, periodicSequence4(-1));
+        for (int tc = 0; tc < 32; tc++) {
+            expectEquals(tc * 16, periodicSequence4(tc));
+        }
+        // Large bounds.
+        expectEquals(55, justRightUp1());
+        expectEquals(55, justRightUp2());
+        expectEquals(55, justRightUp3());
+        expectEquals(55, justRightDown1());
+        expectEquals(55, justRightDown2());
+        expectEquals(55, justRightDown3());
+        sResult = 0;
+        try {
+            justOOBUp();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult = 1;
+        }
+        expectEquals(1, sResult);
+        sResult = 0;
+        try {
+            justOOBDown();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult = 1;
+        }
+        expectEquals(1, sResult);
+        // Lower bound goes OOB.
+        sResult = 0;
+        try {
+            lowerOOB(x);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        // Upper bound goes OOB.
+        sResult = 0;
+        try {
+            upperOOB(x);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1055, sResult);
+        // Do while up goes OOB.
+        sResult = 0;
+        try {
+            doWhileUpOOB();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1055, sResult);
+        // Do while down goes OOB.
+        sResult = 0;
+        try {
+            doWhileDownOOB();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1055, sResult);
+        // Hidden OOB.
+        sResult = 0;
+        try {
+            hiddenOOB1(10); // no OOB
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1, sResult);
+        sResult = 0;
+        try {
+            hiddenOOB1(-2147483648); // OOB
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1001, sResult);
+        sResult = 0;
+        try {
+            hiddenOOB2(1); // no OOB
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1, sResult);
+        if (heavy) {
+            sResult = 0;
+            try {
+                hiddenOOB2(2147483647); // OOB
+            } catch (ArrayIndexOutOfBoundsException e) {
+                sResult += 1000;
+            }
+            expectEquals(1002, sResult);
+        }
+        sResult = 0;
+        try {
+            hiddenInfiniteOOB();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1011, sResult);
+        sResult = 0;
+        try {
+            hiddenFiniteOOB();
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1111, sResult);
+        sResult = 0;
+        try {
+            inductionOOB(a200);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        for (int i = 0; i < 200; i++) {
+            expectEquals(i < 128 ? i : 0, a200[i]);
+        }
+        sResult = 0;
+        try {
+            controlOOB(a200);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        for (int i = 0; i < 200; i++) {
+            expectEquals(i < 128 ? -i : 0, a200[i]);
+        }
+        sResult = 0;
+        try {
+            conversionOOB(a200);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        for (int i = 0; i < 200; i++) {
+            expectEquals(i < 128 ? i : 0, a200[i]);
+        }
+        // Addition.
+        {
+            int[] e1 = {1, 2, 3, 4, 4, 4, 4, 3, 2, 1};
+            int[] a1 = add();
+            for (int i = 0; i < 10; i++) {
+                expectEquals(a1[i], e1[i]);
+            }
+        }
+        // Multiplication.
+        {
+            int[] e1 = {7, 1, 2, 2, 1, 0, 2, 0, 0, 1};
+            int[] a1 = multiply1();
+            for (int i = 0; i < 10; i++) {
+                expectEquals(a1[i], e1[i]);
+            }
+            int[] e2 = {1001, 0, 0, 1, 0, 0, 1, 0, 0, 1};
+            int[] a2 = multiply2();
+            for (int i = 0; i < 10; i++) {
+                expectEquals(a2[i], e2[i]);
+            }
+        }
+        // Dynamic BCE.
+        sResult = 0;
+        try {
+            linearDynamicBCE1(x, -1, x.length);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        sResult = 0;
+        linearDynamicBCE1(x, 0, x.length);
+        expectEquals(55, sResult);
+        sResult = 0;
+        try {
+            linearDynamicBCE1(x, 0, x.length + 1);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1055, sResult);
+        // Dynamic BCE with offset.
+        sResult = 0;
+        try {
+            linearDynamicBCE2(x, 0, x.length, -1);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1000, sResult);
+        sResult = 0;
+        linearDynamicBCE2(x, 0, x.length, 0);
+        expectEquals(55, sResult);
+        sResult = 0;
+        try {
+            linearDynamicBCE2(x, 0, x.length, 1);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult += 1000;
+        }
+        expectEquals(1054, sResult);
+        // Dynamic BCE candidates.
+        expectEquals(55, wrapAroundDynamicBCE(x));
+        expectEquals(15, periodicDynamicBCE(x));
+        expectEquals(55, dynamicBCEPossiblyInfiniteLoop(x, 0, 9));
+        expectEquals(55, noDynamicBCEPossiblyInfiniteLoop(x, 0, 9));
+        expectEquals(55, noDynamicBCEMixedInductionTypes(x, 0, 10));
+        expectEquals(125, dynamicBCEConstantRange(x));
+        // Dynamic BCE combined with constant indices.
+        int[][] a;
+        a = new int[0][0];
+        expectEquals(-1, dynamicBCEAndConstantIndices(x, a, 0, 10));
+        a = new int[100][10];
+        expectEquals(55, dynamicBCEAndConstantIndices(x, a, 0, 10));
+        for (int i = 0; i < 10; i++) {
+            expectEquals((i % 10) != 0 ? 1 : 0, a[0][i]);
+            expectEquals((i % 10) != 0 ? 2 : 0, a[1][i]);
+            expectEquals((i % 10) != 0 ? 3 : 0, a[99][i]);
+        }
+        a = new int[2][10];
+        sResult = 0;
+        try {
+            expectEquals(55, dynamicBCEAndConstantIndices(x, a, 0, 10));
+        } catch (ArrayIndexOutOfBoundsException e) {
+            sResult = 1;
+        }
+        expectEquals(1, sResult);
+        expectEquals(a[0][1], 1);
+        expectEquals(a[1][1], 2);
+        // Dynamic BCE combined with constant indices of all types.
+        boolean[] x1 = {true};
+        byte[] x2 = {2};
+        char[] x3 = {3};
+        short[] x4 = {4};
+        int[] x5 = {5};
+        long[] x6 = {6};
+        float[] x7 = {7};
+        double[] x8 = {8};
+        expectEquals(415, dynamicBCEAndConstantIndicesAllPrimTypes(x, x1, x2, x3, x4, x5, x6, x7, x8, 0, 10));
+        Integer[] x9 = {9};
+        expectEquals(145, dynamicBCEAndConstantIndexRefType(x, x9, 0, 10));
+        System.out.println("ExpectResult");
+    }
+    private static void expectEquals(int expected, int result) {
+        if (expected != result) {
+            throw new Error("Expected: " + expected + ", found: " + result);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0507-JTreg-CheckLoops/expected.txt b/testsuite/java_test/rc_test/RC0507-JTreg-CheckLoops/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0507-JTreg-CheckLoops/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0507-JTreg-CheckLoops/test.cfg b/testsuite/java_test/rc_test/RC0507-JTreg-CheckLoops/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..997f41af119e28478356aa323191f9138f15d842
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0507-JTreg-CheckLoops/test.cfg
@@ -0,0 +1,2 @@
+compile(CheckLoops)
+run(CheckLoops,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0508-JTreg-ConstCharAppend/ConstCharAppend.java b/testsuite/java_test/rc_test/RC0508-JTreg-ConstCharAppend/ConstCharAppend.java
new file mode 100755
index 0000000000000000000000000000000000000000..6858144745a41b48c78e4ef39fdc54d4def18b8a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0508-JTreg-ConstCharAppend/ConstCharAppend.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ConstCharAppend {
+    public static void main(String[] args) {
+        if (!("" + 'a' + 'b').equals("ab")) {
+            System.out.println("append of chars is wrong: 4103959");
+        } else {
+            System.out.println("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0508-JTreg-ConstCharAppend/expected.txt b/testsuite/java_test/rc_test/RC0508-JTreg-ConstCharAppend/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0508-JTreg-ConstCharAppend/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0508-JTreg-ConstCharAppend/test.cfg b/testsuite/java_test/rc_test/RC0508-JTreg-ConstCharAppend/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a40fcd97dd17db97a032ee151e1162cec9a5cb5b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0508-JTreg-ConstCharAppend/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstCharAppend)
+run(ConstCharAppend,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0509-JTreg-RelaxedArrays/RelaxedArrays.java b/testsuite/java_test/rc_test/RC0509-JTreg-RelaxedArrays/RelaxedArrays.java
new file mode 100755
index 0000000000000000000000000000000000000000..0e1c8bce35f09615a2ef182616ca86184d1129bf
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0509-JTreg-RelaxedArrays/RelaxedArrays.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.util.List;
+public class RelaxedArrays {
+    static <T> T select(T... tl) {
+        return tl.length == 0 ? null : tl[tl.length - 1];
+    }
+    public static void main(String[] args) {
+        List<String>[] a = new StringList[20];
+        if (select("A", "B", "C") != "C") {
+            System.out.println("error");
+        } else {
+            System.out.println("ExpectResult");
+        }
+    }
+    static class StringList extends ArrayList<String> {
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0509-JTreg-RelaxedArrays/expected.txt b/testsuite/java_test/rc_test/RC0509-JTreg-RelaxedArrays/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0509-JTreg-RelaxedArrays/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0509-JTreg-RelaxedArrays/test.cfg b/testsuite/java_test/rc_test/RC0509-JTreg-RelaxedArrays/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..af8621cd379402d48f358ac423c45e135ef1b4ab
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0509-JTreg-RelaxedArrays/test.cfg
@@ -0,0 +1,2 @@
+compile(RelaxedArrays)
+run(RelaxedArrays,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0510-JTreg-T4711694/T4711694.java b/testsuite/java_test/rc_test/RC0510-JTreg-T4711694/T4711694.java
new file mode 100755
index 0000000000000000000000000000000000000000..4bc44d2a4b7908a848b0a82cbf342ffa7276c1fc
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0510-JTreg-T4711694/T4711694.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class T4711694 {
+    public static void main(String[] args) {
+        D.main(args);
+        System.out.println("ExpectResult");
+    }
+    interface A<T> {
+        void f(T u);
+    }
+    static class B {
+        public void f(Integer i) {
+        }
+    }
+    static abstract class C<T> extends B implements A<T> {
+        public void g(T t) {
+            f(t);
+        }
+    }
+    static class D extends C<Integer> {
+        public static void main(String[] args) {
+            new D().g(new Integer(3));
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0510-JTreg-T4711694/expected.txt b/testsuite/java_test/rc_test/RC0510-JTreg-T4711694/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0510-JTreg-T4711694/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0510-JTreg-T4711694/test.cfg b/testsuite/java_test/rc_test/RC0510-JTreg-T4711694/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..91d7f6fbda28462f5ce08fbf6356e822961c08eb
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0510-JTreg-T4711694/test.cfg
@@ -0,0 +1,2 @@
+compile(T4711694)
+run(T4711694,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0511-JTreg-T7040104/T7040104.java b/testsuite/java_test/rc_test/RC0511-JTreg-T7040104/T7040104.java
new file mode 100755
index 0000000000000000000000000000000000000000..7f8bc09e3167e7f61677fc38ee5c26266fd57ce0
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0511-JTreg-T7040104/T7040104.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class T7040104 {
+    int npeCount = 0;
+    public static void main(String[] args) {
+        T7040104 t = new T7040104();
+        t.test1();
+        t.test2();
+        t.test3();
+        if (t.npeCount != 3) {
+            System.out.println("error");
+        } else {
+            System.out.println("ExpectResult");
+        }
+    }
+    void test1() {
+        Object[] a;
+        try {
+            Object o = (a = null)[0];
+        } catch (NullPointerException npe) {
+            npeCount++;
+        }
+    }
+    void test2() {
+        Object[][] a;
+        try {
+            Object o = (a = null)[0][0];
+        } catch (NullPointerException npe) {
+            npeCount++;
+        }
+    }
+    void test3() {
+        Object[][][] a;
+        try {
+            Object o = (a = null)[0][0][0];
+        } catch (NullPointerException npe) {
+            npeCount++;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0511-JTreg-T7040104/expected.txt b/testsuite/java_test/rc_test/RC0511-JTreg-T7040104/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0511-JTreg-T7040104/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0511-JTreg-T7040104/test.cfg b/testsuite/java_test/rc_test/RC0511-JTreg-T7040104/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..3319efa18e772cae2ba46256f0e30529e7693c1a
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0511-JTreg-T7040104/test.cfg
@@ -0,0 +1,2 @@
+compile(T7040104)
+run(T7040104,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0512-JTreg-WrongNew/WrongNew.java b/testsuite/java_test/rc_test/RC0512-JTreg-WrongNew/WrongNew.java
new file mode 100755
index 0000000000000000000000000000000000000000..95265ab16d417ab9f9a44423eaa36eae26c4ac7b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0512-JTreg-WrongNew/WrongNew.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class WrongNewList<T> {
+}
+class WrongNewArrayList<T> extends WrongNewList<T> {
+}
+public class WrongNew {
+    public static void main(String[] ps) {
+        WrongNewList<String> list = getList();
+        if (list != null) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+    public static WrongNewList<String> getList() {
+        return new WrongNewArrayList();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0512-JTreg-WrongNew/expected.txt b/testsuite/java_test/rc_test/RC0512-JTreg-WrongNew/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0512-JTreg-WrongNew/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0512-JTreg-WrongNew/test.cfg b/testsuite/java_test/rc_test/RC0512-JTreg-WrongNew/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..12b8ead266e13a9fa32b1ac50eca577da20718f7
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0512-JTreg-WrongNew/test.cfg
@@ -0,0 +1,2 @@
+compile(WrongNew)
+run(WrongNew,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0513-JTreg-T6481655/T6481655.java b/testsuite/java_test/rc_test/RC0513-JTreg-T6481655/T6481655.java
new file mode 100755
index 0000000000000000000000000000000000000000..0b1800b4884e2e83883e58457f7af159cb015d6b
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0513-JTreg-T6481655/T6481655.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class T6481655 {
+    public static <T> T getT(T t) {
+        return t;
+    }
+    public static void main(String... s) {
+        if (T6481655.getT("").equals("") && (T6481655.getT("")).getClass().isInstance("java.lang.String")) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0513-JTreg-T6481655/expected.txt b/testsuite/java_test/rc_test/RC0513-JTreg-T6481655/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0513-JTreg-T6481655/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0513-JTreg-T6481655/test.cfg b/testsuite/java_test/rc_test/RC0513-JTreg-T6481655/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4d50a9daface2c825476d8fe39dfd0fbe64a7f34
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0513-JTreg-T6481655/test.cfg
@@ -0,0 +1,2 @@
+compile(T6481655)
+run(T6481655,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0514-JTreg-SingleLocalTest/SingleLocalTest.java b/testsuite/java_test/rc_test/RC0514-JTreg-SingleLocalTest/SingleLocalTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..a66b76ab40b9c485fb4ff4c227214e0f61ca7992
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0514-JTreg-SingleLocalTest/SingleLocalTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class SingleLocalTest {
+    static F f;
+    public static void main(String[] args) {
+        StringBuffer sb = new StringBuffer();
+        class Local1 {
+            public Local1() {
+                f = () -> new Local1();
+                sb.append("1");
+            }
+        }
+        new Local1();
+        f.f();
+        String s = sb.toString();
+        if (!s.equals("11")) {
+            System.out.println("Expected '11' got '" + s + "'");
+        } else {
+            System.out.println("ExpectResult");
+        }
+    }
+    interface F {
+        void f();
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0514-JTreg-SingleLocalTest/expected.txt b/testsuite/java_test/rc_test/RC0514-JTreg-SingleLocalTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0514-JTreg-SingleLocalTest/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0514-JTreg-SingleLocalTest/test.cfg b/testsuite/java_test/rc_test/RC0514-JTreg-SingleLocalTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e897b3c5545e0bd6aa61d7d42a3dfa1c266ae0c4
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0514-JTreg-SingleLocalTest/test.cfg
@@ -0,0 +1,2 @@
+compile(SingleLocalTest)
+run(SingleLocalTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0515-GC-FrequentGCTest01/FrequentGCTest01.java b/testsuite/java_test/rc_test/RC0515-GC-FrequentGCTest01/FrequentGCTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..d5ca1359d9dcd4e33a910c655f8f06ef9813f0e1
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0515-GC-FrequentGCTest01/FrequentGCTest01.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+public class FrequentGCTest01 {
+    static int a = 100;
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < 100; i++) {
+            WeakReference rp = new WeakReference<Object>(new Object());
+            if (rp.get() == null) {
+                a++;
+            }
+            new Thread(new TriggerRP()).start();
+            Runtime.getRuntime().gc();
+            Thread.sleep(100);
+            if (rp.get() != null) {
+                a++;
+            }
+            if (a != 100) {
+                System.out.println("ErrorResult");
+                return;
+            }
+        }
+        System.out.println("ExpectResult");
+    }
+    static class TriggerRP implements Runnable {
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+                WeakReference wr = new WeakReference(new Object());
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/RC0515-GC-FrequentGCTest01/expected.txt b/testsuite/java_test/rc_test/RC0515-GC-FrequentGCTest01/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0515-GC-FrequentGCTest01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0515-GC-FrequentGCTest01/test.cfg b/testsuite/java_test/rc_test/RC0515-GC-FrequentGCTest01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e4ed2a1f1393e5b0f2159f4501210e80be5e48a9
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0515-GC-FrequentGCTest01/test.cfg
@@ -0,0 +1,2 @@
+compile(FrequentGCTest01)
+run(FrequentGCTest01,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/RC0516-GC-FrequentGCTest02/FrequentGCTest02.java b/testsuite/java_test/rc_test/RC0516-GC-FrequentGCTest02/FrequentGCTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..4228be88e0fe5138ecc6717bfd1d07903c989a4c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0516-GC-FrequentGCTest02/FrequentGCTest02.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.WeakReference;
+public class FrequentGCTest02 {
+    static int a = 100;
+    public static void main(String[] args) {
+        for (int i = 0; i < 100; i++) {
+            WeakReference rp = new WeakReference<Object>(new Object());
+            if (rp.get() == null) {
+                a++;
+            }
+            System.gc();
+            if (rp.get() == null) {
+                a++;
+            }
+            if (a != 100) {
+                System.out.println("ErrorResult");
+                return;
+            }
+        }
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/RC0516-GC-FrequentGCTest02/expected.txt b/testsuite/java_test/rc_test/RC0516-GC-FrequentGCTest02/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0516-GC-FrequentGCTest02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/RC0516-GC-FrequentGCTest02/test.cfg b/testsuite/java_test/rc_test/RC0516-GC-FrequentGCTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..638d440719b3636f26675c2111b79d82ce83ee9c
--- /dev/null
+++ b/testsuite/java_test/rc_test/RC0516-GC-FrequentGCTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(FrequentGCTest02)
+run(FrequentGCTest02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/common_test/RC0305-rc-function-SubsumeRC01/SubsumeRC01.java b/testsuite/java_test/rc_test/common_test/RC0305-rc-function-SubsumeRC01/SubsumeRC01.java
new file mode 100644
index 0000000000000000000000000000000000000000..d0a8ed468addfc91c3ea972d07db4dad68c6c48a
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0305-rc-function-SubsumeRC01/SubsumeRC01.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class SubsumeRC01 {
+    private String str;
+    public String testfunc() {
+        return str;
+    }
+    public static void main(String[] args){
+        SubsumeRC01 temp = new SubsumeRC01();
+        temp.testfunc();
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0305-rc-function-SubsumeRC01/expected.txt b/testsuite/java_test/rc_test/common_test/RC0305-rc-function-SubsumeRC01/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0305-rc-function-SubsumeRC01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/common_test/RC0305-rc-function-SubsumeRC01/test.cfg b/testsuite/java_test/rc_test/common_test/RC0305-rc-function-SubsumeRC01/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..56969d4829070ca6927d197fc45327b95737859b
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0305-rc-function-SubsumeRC01/test.cfg
@@ -0,0 +1,2 @@
+compile(SubsumeRC01)
+run(SubsumeRC01)
diff --git a/testsuite/java_test/rc_test/common_test/RC0306-rc-function-SubsumeRC02/SubsumeRC02.java b/testsuite/java_test/rc_test/common_test/RC0306-rc-function-SubsumeRC02/SubsumeRC02.java
new file mode 100755
index 0000000000000000000000000000000000000000..c348a06c2b0c082ffd05f8435707461650708ebf
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0306-rc-function-SubsumeRC02/SubsumeRC02.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class SubsumeRC02 {
+    private String str;
+    public SubsumeRC02() {
+    }
+    public void testfunc() {
+        str = new String("test");
+        return ;
+    }
+    public static void main(String[] args){
+        SubsumeRC02 temp = new SubsumeRC02();
+        temp.testfunc();
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0306-rc-function-SubsumeRC02/expected.txt b/testsuite/java_test/rc_test/common_test/RC0306-rc-function-SubsumeRC02/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0306-rc-function-SubsumeRC02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/common_test/RC0306-rc-function-SubsumeRC02/test.cfg b/testsuite/java_test/rc_test/common_test/RC0306-rc-function-SubsumeRC02/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a45fd92693032991dd40639973c821ea0988e241
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0306-rc-function-SubsumeRC02/test.cfg
@@ -0,0 +1,2 @@
+compile(SubsumeRC02)
+run(SubsumeRC02)
diff --git a/testsuite/java_test/rc_test/common_test/RC0307-rc-function-SubsumeRC03/SubsumeRC03.java b/testsuite/java_test/rc_test/common_test/RC0307-rc-function-SubsumeRC03/SubsumeRC03.java
new file mode 100755
index 0000000000000000000000000000000000000000..21cd5575ee52ef9308d17d5c62494efaf67b13ce
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0307-rc-function-SubsumeRC03/SubsumeRC03.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class SubsumeRC03 {
+    private String str;
+    public SubsumeRC03() {
+    }
+    public void testfunc(SubsumeRC03 t) {
+        str = t.str;
+        return ;
+    }
+    public static void main(String[] args){
+        SubsumeRC03 temp0 = new SubsumeRC03();
+        SubsumeRC03 temp1 = new SubsumeRC03();
+        temp1.testfunc(temp0);
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0307-rc-function-SubsumeRC03/expected.txt b/testsuite/java_test/rc_test/common_test/RC0307-rc-function-SubsumeRC03/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0307-rc-function-SubsumeRC03/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/common_test/RC0307-rc-function-SubsumeRC03/test.cfg b/testsuite/java_test/rc_test/common_test/RC0307-rc-function-SubsumeRC03/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0bb71ca6eb7945d28c254fc965732224dbde1e92
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0307-rc-function-SubsumeRC03/test.cfg
@@ -0,0 +1,2 @@
+compile(SubsumeRC03)
+run(SubsumeRC03)
diff --git a/testsuite/java_test/rc_test/common_test/RC0308-rc-function-CondBasedRC01/CondBasedRC01.java b/testsuite/java_test/rc_test/common_test/RC0308-rc-function-CondBasedRC01/CondBasedRC01.java
new file mode 100755
index 0000000000000000000000000000000000000000..59764292114ae666543cbfa6ae95af60f494dce0
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0308-rc-function-CondBasedRC01/CondBasedRC01.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class CondBasedRC01 {
+    private String str1;
+    public static String str2;
+    public CondBasedRC01() {
+    }
+    public String testfunc(String s) {
+        if (s == null) {
+            s = str1;
+        }
+        return s;
+    }
+    public String strfunc() {
+        return str1;
+    }
+    public String testfunc1() {
+        String t = strfunc();
+        if (t == null) {
+            t = str1;
+        }
+        return t;
+    }
+    public static void main(String[] args){
+        CondBasedRC01 temp1 = new CondBasedRC01();
+        String s = new String("test");
+        str2 = temp1.testfunc(s);
+        str2 = temp1.testfunc1();
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0308-rc-function-CondBasedRC01/expected.txt b/testsuite/java_test/rc_test/common_test/RC0308-rc-function-CondBasedRC01/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0308-rc-function-CondBasedRC01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/common_test/RC0308-rc-function-CondBasedRC01/test.cfg b/testsuite/java_test/rc_test/common_test/RC0308-rc-function-CondBasedRC01/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..24a3ce14e109c0106d355d0f83b64ca65e2e5612
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0308-rc-function-CondBasedRC01/test.cfg
@@ -0,0 +1,2 @@
+compile(CondBasedRC01)
+run(CondBasedRC01)
diff --git a/testsuite/java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/RCMixTest.java b/testsuite/java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/RCMixTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..4c07a9b4cf17e3ff583e3ee0aaec074d65e4791a
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/RCMixTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.*;
+import java.lang.reflect.Field;
+public class RCMixTest {
+    public static void main(String[] args) {
+        new Test_A_Weak().test();
+        new Test_A_Unowned().test();
+        Runtime.getRuntime().gc();
+    }
+}
+class Test_A_Weak {
+    @Weak
+    Test_B_Weak bb;
+    Test_B_Weak bb2;
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("NullPointerException");
+        }
+        bb2.run();
+    }
+    private void foo() {
+        bb = new @Permanent Test_B_Weak();
+        bb2 = new Test_B_Weak();
+    }
+}
+class Test_B_Weak {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
+class Test_B_Unowned {
+    @Unowned
+    Test_A_Unowned aa ;
+    // add volatile will crash
+    // static Test_A a1;
+    protected void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+class Test_A_Unowned {
+    Test_B_Unowned bb;
+    public void test() {
+        setReferences();
+        System.runFinalization();
+    }
+    private void setReferences() {
+        @Unowned
+        Test_A_Unowned ta;
+        ta = new @Permanent Test_A_Unowned();
+        ta.bb = new Test_B_Unowned();
+        //ta.bb.aa = ta;
+        try {
+            Field m = Test_B_Unowned.class.getDeclaredField("aa");
+            m.set(ta.bb, ta);
+            Test_A_Unowned a_temp = (Test_A_Unowned) m.get(ta.bb);
+            if (a_temp != ta) {
+                System.out.println("error");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/expected.txt b/testsuite/java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..309f6d50570536aa5ec2bd6eba765f9c8fa03b0f
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/expected.txt
@@ -0,0 +1,3 @@
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/test.cfg b/testsuite/java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4715bd7e904ebb5445f26e29269611142dd3cdec
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0427-rc-Annotation-RCMixTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCMixTest)
+run(RCMixTest)
diff --git a/testsuite/java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/RCMixThreadTest.java b/testsuite/java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/RCMixThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..c0ec405a55ae95b761b7c45973bc1c51d500c06f
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/RCMixThreadTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import com.huawei.ark.annotation.*;
+public class RCMixThreadTest {
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+    }
+    public static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCMixTest_Weak rcMixTest_weak = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak2 = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak3 = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak4 = new RCMixTest_Weak();
+        RCMixTest_Weak rcMixTest_weak5 = new RCMixTest_Weak();
+        rcMixTest_weak.start();
+        rcMixTest_weak2.start();
+        rcMixTest_weak3.start();
+        rcMixTest_weak4.start();
+        rcMixTest_weak5.start();
+        rcMixTest_weak.join();
+        rcMixTest_weak2.join();
+        rcMixTest_weak3.join();
+        rcMixTest_weak4.join();
+        rcMixTest_weak5.join();
+    }
+}
+class RCMixTest_Weak extends Thread {
+    public void run() {
+        new Test_A_Weak().test();
+    }
+}
+class Test_A_Weak {
+    @Weak
+    Test_B_Weak bb;
+    Test_B_Weak bb2;
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("NullPointerException");
+        }
+        bb2.run();
+    }
+    private void foo() {
+        bb = new @Permanent Test_B_Weak();
+        bb2 = new Test_B_Weak();
+    }
+}
+class Test_B_Weak {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/expected.txt b/testsuite/java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..9bee6719557871df108511be25e915c084d19061
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/expected.txt
@@ -0,0 +1,10 @@
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/test.cfg b/testsuite/java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a3cdc3c65b518fe8ee1ce5a8e9181057f6374b5f
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0428-rc-Annotation-RCMixThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCMixThreadTest)
+run(RCMixThreadTest)
diff --git a/testsuite/java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/SoftRefTest04.java b/testsuite/java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/SoftRefTest04.java
new file mode 100755
index 0000000000000000000000000000000000000000..cfc25d4c2e260e9367566f624530fc71f3dcf11f
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/SoftRefTest04.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+public class SoftRefTest04 {
+    private static Reference rp;
+    private static ReferenceQueue rq = new ReferenceQueue();
+    private static int a = 100;
+    private static ArrayList<byte[]> store;
+    static void setSoftReference() {
+        rp = new SoftReference<Object>(new Object(), rq);
+        if (rp.get() == null) {
+            System.out.println("Error Result when first check ");
+            a++;
+        }
+    }
+    private static int oomTest() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+    public static void main(String[] args) throws Exception {
+        setSoftReference();
+        try {
+            int Result = oomTest();
+        } catch (OutOfMemoryError o) {
+            // do nothing
+        }
+        if (rp.get() != null) {
+            System.out.println("Error Result when second check ");
+            a++;
+        }
+        Thread.sleep(500);
+        Reference r = rq.poll();
+        if (r == null) {
+            System.out.println("Error Result when checking ReferenceQueue");
+            a++;
+        }
+        if (a == 100) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult finally");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/expected.txt b/testsuite/java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/test.cfg b/testsuite/java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e5776699826737e5b91492a92c29dc92ea32f7c7
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0434-rc-SoftRef-SoftRefTest04/test.cfg
@@ -0,0 +1,2 @@
+compile(SoftRefTest04)
+run(SoftRefTest04)
diff --git a/testsuite/java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/SoftRefTest06.java b/testsuite/java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/SoftRefTest06.java
new file mode 100755
index 0000000000000000000000000000000000000000..7a3e94956c55f6f388ee028256fb16f72b650ed0
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/SoftRefTest06.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class SoftRefTest06 {
+    private static Reference rp;
+    private static ReferenceQueue rq = new ReferenceQueue();
+    private static ArrayList<byte[]> store;
+    private static AtomicInteger count = new AtomicInteger(1);
+    // 生命周期结束的软指针指向的对象，应该被释放，放到它的ReferenceQueue里
+    public static void objectDeadNormally() {
+        Reference sr = new SoftReference<SoftRefTest06>(new SoftRefTest06(), rq);
+        if (sr.get() == null) {
+            System.out.println("ErrorResult");
+        }
+        // sr will die now.
+    }
+    private static int oomTest() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+    private static void setSoftRef() {
+        // oom出发，回收软引用对象使用的内存
+        rp = new SoftReference<SoftRefTest06>(new SoftRefTest06(), rq);
+    }
+    public static void main(String[] args) {
+        objectDeadNormally();
+        Runtime.getRuntime().runFinalization();
+        setSoftRef();
+        try {
+            int oom = oomTest();
+        } catch (OutOfMemoryError ofm) {
+            // do nothing
+        }
+        if (rp.get() != null) {
+            System.out.println("Error Result when second check ");
+        }
+        Runtime.getRuntime().runFinalization();
+    }
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult" + count.getAndIncrement());
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/expected.txt b/testsuite/java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3c34261ca9e88d22e09187c66a1064c0c3efc52e
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult1
+ExpectResult2
diff --git a/testsuite/java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/test.cfg b/testsuite/java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7e8668417795f5e6bf20ce8b475f6d6c796bbf4f
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0436-rc-SoftRef-SoftRefTest06/test.cfg
@@ -0,0 +1,2 @@
+compile(SoftRefTest06)
+run(SoftRefTest06)
diff --git a/testsuite/java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/RCHeaderTest.java b/testsuite/java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/RCHeaderTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b3a01b00e394113844cd646232fbb83321ced565
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/RCHeaderTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+class RCRunner implements Runnable {
+    public void run() {
+        RCHeaderTest.iArray = null;
+    }
+}
+class Resource {
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+public class RCHeaderTest {
+    static int[] iArray;
+    static Cleaner c = null;
+    Resource res;
+    public RCHeaderTest() {
+        iArray = new int[4];
+        res = new Resource();
+    }
+    static void foo() {
+        RCHeaderTest rcht = new RCHeaderTest();
+        c = Cleaner.create(rcht, new RCRunner());
+        if (c == null) {
+            System.out.println("Cleaner create failly");
+        }
+    }
+    public static void main(String[] args) {
+        foo();
+        Runtime.getRuntime().runFinalization();
+        System.out.println("ExpectResultEnd");    //ReleaseEnd
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/expected.txt b/testsuite/java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3135ee23be98bff95690f925de6d0ea9083cef87
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResultEnd
diff --git a/testsuite/java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/test.cfg b/testsuite/java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7c505b0549cf8c06571401113e7a1d937286fe72
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0437-rc-RCHeader-RCHeaderTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCHeaderTest)
+run(RCHeaderTest)
diff --git a/testsuite/java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/RCHeaderTest02.java b/testsuite/java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/RCHeaderTest02.java
new file mode 100755
index 0000000000000000000000000000000000000000..21a359488852151cbdd6c46efce24f6939685bb5
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/RCHeaderTest02.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.util.ArrayList;
+import java.lang.ref.SoftReference;
+class RCRunner02 implements Runnable {
+    public void run() {
+        RCHeaderTest02.iArray = null;
+    }
+}
+class Resource02 {
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+public class RCHeaderTest02 {
+	private static ArrayList<byte[]> store;
+    static int[] iArray;
+    static Cleaner c = null;
+    Resource02 res02 = null;
+    public RCHeaderTest02() {
+        iArray = new int[4];
+        res02 = new Resource02();
+    }
+    //方法退出后，sr_rcht02声明周期结束，触发对SoftReference的处理，它指向的对象占用空间被释放。
+    static void foo() {
+        SoftReference<RCHeaderTest02> sr_rcht02 = new SoftReference<>(new RCHeaderTest02());
+        c = Cleaner.create(sr_rcht02, new RCRunner02());
+        if (sr_rcht02.get() == null || c == null) {
+            System.out.println("SoftReference error or Cleaner create failly");
+        }
+    }
+    private static int oomTest() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        foo();
+        try {
+            int oom = oomTest();
+        } catch (OutOfMemoryError ofm) {}
+        Runtime.getRuntime().runFinalization();
+        System.out.println("ExpectResultEnd");    //ReleaseEnd
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/expected.txt b/testsuite/java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3135ee23be98bff95690f925de6d0ea9083cef87
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResultEnd
diff --git a/testsuite/java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/test.cfg b/testsuite/java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9c40996b928ec4f88ba98a0ed0ee3ef2d3c0995c
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0438-rc-RCHeader-RCHeaderTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(RCHeaderTest02)
+run(RCHeaderTest02)
diff --git a/testsuite/java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/RCHeaderTest03.java b/testsuite/java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/RCHeaderTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4b8bac62508e37a153e8306df42009154e50d3b
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/RCHeaderTest03.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import java.util.ArrayList;
+import java.lang.ref.SoftReference;
+import com.huawei.ark.annotation.Weak;
+class RCRunner03 implements Runnable {
+    public void run() {
+        RCHeaderTest03.iArray = null;
+    }
+}
+public class RCHeaderTest03 {
+    static String[] iArray;
+    private static ArrayList<byte[]> store;
+    String @Weak [] wr_annotation = null;
+    Cleaner c = null;
+    SoftReference<String[]> sr = null;
+    public RCHeaderTest03() {
+        iArray = new String[4];
+        String[] temp = {"1", "2", "3", "4"};
+        wr_annotation = temp;
+        sr = new SoftReference<>(temp);
+    }
+    //方法退出后，实例变量sr声明周期结束，触发对SoftReference的处理，它指向的数组占用空间被释放。
+    void foo() {
+        c = Cleaner.create(wr_annotation, new RCRunner03());
+        if (c == null || wr_annotation.length != 4) {
+            System.out.println("Cleaner create failly");
+        }
+    }
+    private static int oomTest() {
+        int sum = 0;
+        store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1024 * 1024; i <= 1024 * 1024 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+    public static void main(String[] args) {
+        RCHeaderTest03 rcht = new RCHeaderTest03();
+        rcht.foo();
+        try {
+            int oom = oomTest();
+        } catch (OutOfMemoryError ofm) {
+            System.out.println("oom occured");
+        }
+        Runtime.getRuntime().gc();
+        if (rcht.sr.get() == null ) {
+            System.out.println("SR release");
+        }
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (rcht.wr_annotation == null) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/expected.txt b/testsuite/java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..87e92946f8148f67f23a882689697925cf27c4b4
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/expected.txt
@@ -0,0 +1,3 @@
+oom occured
+SR release
+ExpectResult
diff --git a/testsuite/java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/test.cfg b/testsuite/java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9f5290f5a5d83a365dbe9fc851d367d2420c6d4a
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0439-rc-RCHeader-RCHeaderTest03/test.cfg
@@ -0,0 +1,2 @@
+compile(RCHeaderTest03)
+run(RCHeaderTest03)
diff --git a/testsuite/java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/RCHeaderTest06.java b/testsuite/java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/RCHeaderTest06.java
new file mode 100755
index 0000000000000000000000000000000000000000..80c2325031d4f85f25828fe14ed16591cd85e195
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/RCHeaderTest06.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+import com.huawei.ark.annotation.Weak;
+class RCRunner06 implements Runnable {
+    public void run() {
+        RCHeaderTest06.iArray = null;
+    }
+}
+class Resource06 {
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+public class RCHeaderTest06 {
+    static int[] iArray;
+    static Cleaner cleaner = null;
+    @Weak
+    Resource06 c = null;
+    public RCHeaderTest06() {
+        iArray = new int[4];
+        c = new Resource06();
+    }
+    static void foo() {
+        RCHeaderTest06 rcht = new RCHeaderTest06();
+        RCHeaderTest06.cleaner = Cleaner.create(rcht.c, new RCRunner06());
+        if (cleaner == null) {
+            System.out.println("Weak Annotation Object shouldn't be null");
+        }
+    }
+    public static void main(String[] args) {
+        foo();
+        Runtime.getRuntime().runFinalization();
+        System.out.println("ExpectResultEnd");
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/expected.txt b/testsuite/java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3135ee23be98bff95690f925de6d0ea9083cef87
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResultEnd
diff --git a/testsuite/java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/test.cfg b/testsuite/java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..cfbae518c408ee1ff55daffb34dc1bcb1e241c04
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0441-rc-RCHeader-RCHeaderTest06/test.cfg
@@ -0,0 +1,2 @@
+compile(RCHeaderTest06)
+run(RCHeaderTest06)
diff --git a/testsuite/java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/RCHeaderTest07.java b/testsuite/java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/RCHeaderTest07.java
new file mode 100755
index 0000000000000000000000000000000000000000..2e9e6e79adb87d1963eaad67b5c9472184aa3c4e
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/RCHeaderTest07.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Cleaner;
+class RCRunner07 implements Runnable {
+    public void run() {
+        RCHeaderTest07.iArray = null;
+    }
+}
+class Resource07 {
+    @Override
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+public class RCHeaderTest07 {
+    static int[] iArray;
+    static Cleaner c = null;
+    Resource07 res;
+    public RCHeaderTest07() {
+        iArray = new int[4];
+        res = new Resource07();
+    }
+    static void foo() {
+        RCHeaderTest07 rcht = new RCHeaderTest07();
+        c = Cleaner.create(rcht.res, new RCRunner07());
+        if (c == null) {
+            System.out.println("Cleaner create failly");
+        }
+    }
+    public static void main(String[] args) {
+        foo();
+        Runtime.getRuntime().runFinalization();
+        System.out.println("ExpectResultEnd");
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/expected.txt b/testsuite/java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3135ee23be98bff95690f925de6d0ea9083cef87
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResultEnd
diff --git a/testsuite/java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/test.cfg b/testsuite/java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c9c754185baae01015e9aac4e9f8575c3cefc00e
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0442-rc-RCHeader-RCHeaderTest07/test.cfg
@@ -0,0 +1,2 @@
+compile(RCHeaderTest07)
+run(RCHeaderTest07)
diff --git a/testsuite/java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/PlacementRCTest03.java b/testsuite/java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/PlacementRCTest03.java
new file mode 100755
index 0000000000000000000000000000000000000000..52fa4bdda5c764733bd82adde9bd75eda91fb3ed
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/PlacementRCTest03.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class PlacementRC_A3 {
+    public int count = 0;
+    public String className = "temp";
+    public PlacementRC_A3(String name) {
+        this.className = name;
+    }
+    public void changeName(String name) {
+        this.className = name;
+    }
+    @Override
+    public void finalize() throws Throwable {
+        super.finalize();
+        synchronized (PlacementRCTest03.lock) {
+            if (this.count % 25 == 0) {
+                PlacementRCTest03.result += ("End" + count);
+            }
+        }
+    }    
+}
+public class PlacementRCTest03 {
+    public static String result = new String();
+    public static String lock = "";
+    private volatile static int count = 0;
+    private PlacementRC_A3 defInsideUseOutside = null;
+    //def outside, only use inside loop
+    public static void onlyUseInsideLoop() {
+        PlacementRC_A3 a1 = new PlacementRC_A3("a1");
+        continueTag:
+        for (count = 0; count < 100; count++) {
+            a1.changeName("a" + count);
+            a1.count = count;
+            if (count % 95 == 0) {
+                count = 100;
+                continue continueTag;
+            }
+            if (count % 4 == 0) {
+                if (count % 8 == 0)
+                    continue;
+                a1.changeName("a" + 100);
+                a1 = new PlacementRC_A3("a10");
+                a1.toString();
+            }
+            if (count >= 95)
+                System.out.println("Wrong Result");
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest03.lock) {
+            result += "Method1";
+        }
+    }
+    public static PlacementRC_A3 defAndUseInsideLoop() {
+        for (count = 0; count < 100; count++) {
+            PlacementRC_A3 a2 = new PlacementRC_A3("a2_i" + count);
+            a2.count = count;
+            a2.changeName("null");
+            for (int j = 0; j < 2; j++)
+                a2 = new PlacementRC_A3("a2_i" + count + "_j" + j);
+            if (count % 4 == 0) {
+                a2.changeName("a" + 100);
+                a2 = new PlacementRC_A3("a10");
+                if (count == 96) {
+                    Runtime.getRuntime().runFinalization();
+                    synchronized (PlacementRCTest03.lock) {
+                        result += "Method2";
+                    }
+                    return a2;
+                }
+                a2.toString();
+            } else {
+                a2.toString();
+            }
+        }
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest03.lock) {
+            result += "Method2";
+        }
+        return new PlacementRC_A3("wrong");
+    }
+    public static void main(String[] args) {
+        onlyUseInsideLoop();
+        System.out.println(defAndUseInsideLoop().className);
+        new PlacementRCTest03().defInsideAndUseOutsideLoop();
+        //System.out.println(result);
+        if(result.contains("Method1") && result.contains("Method2") && result.contains("Method3") && result.contains("End"))
+            System.out.println("Expect Result");
+        else
+            System.out.println("Error Result");
+    }
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        breakTag:
+        do {
+            int choice = count % 4;
+            this.defInsideUseOutside = new PlacementRC_A3("a2_i" + count);
+            switch (choice) {
+                case 1:
+                    for (int j = 0; j < 5; j++) {
+                        this.defInsideUseOutside = new PlacementRC_A3("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    if (count == 99)
+                        this.defInsideUseOutside.toString();
+                    break;
+                case 2:
+                    for (int j = 0; j < 2; j++) {
+                        this.defInsideUseOutside.changeName("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    break;
+                case 3:
+                    for (int j = 0; j < 5; j++) {
+                        this.defInsideUseOutside = new PlacementRC_A3("a2_i" + count + "_j" + j);
+                        this.defInsideUseOutside.count = count;
+                    }
+                    if (this.defInsideUseOutside.className.equals("a2_i91_j4")) {
+                        System.out.println(this.defInsideUseOutside.className);
+                        break breakTag;
+                    }
+                    if (this.defInsideUseOutside.className.equals("a2_i99_j4")) {
+                        System.out.println(this.defInsideUseOutside.className);
+                        break breakTag;
+                    }
+                    break;
+                default:
+                    this.defInsideUseOutside = new PlacementRC_A3("a2_i" + count);
+                    this.defInsideUseOutside.count = count;
+            }
+            count++;
+        } while (this.defInsideUseOutside.count < 100 && count < 100);
+        this.defInsideUseOutside.changeName("finish");
+        this.defInsideUseOutside = null;
+        Runtime.getRuntime().runFinalization();
+        synchronized (PlacementRCTest03.lock) {
+            result += "Method3";
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/expected.txt b/testsuite/java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c0985af3e3640527f8f5ae54c4ff99f093538d33
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/expected.txt
@@ -0,0 +1,3 @@
+a10
+a2_i91_j4
+Expect Result
diff --git a/testsuite/java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/test.cfg b/testsuite/java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..463c887d6a60807533ffbcf3f0a545b95acebbe2
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0445-rc-PlacementRC-PlacementRCTest03/test.cfg
@@ -0,0 +1,2 @@
+compile(PlacementRCTest03)
+run(PlacementRCTest03)
diff --git a/testsuite/java_test/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/UnsafeTest01.java b/testsuite/java_test/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/UnsafeTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc18dd95de92b6acff0c3b2ffff8a2e22a722b36
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/UnsafeTest01.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeTest01 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecompareAndSwapObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest01.res = UnsafeTest01.res - 10;
+        }
+        if (result == 3 && UnsafeTest01.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafecompareAndSwapObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Field param;
+        Object obj;
+        long offset;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new Billie5();
+            param = Billie5.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            unsafe.compareAndSwapObject(obj, offset, "Me", "billie5");
+            result = unsafe.getObject(obj, offset);
+            if(result.equals("billie5")){
+                UnsafeTest01.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie5{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/expected.txt b/testsuite/java_test/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/test.cfg b/testsuite/java_test/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4ad4aefc5dcfeab2035ceadfaccbacc3bbf3a4ec
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0471-rc-BindingMethod-UnsafeTest01/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeTest01)
+run(UnsafeTest01)
diff --git a/testsuite/java_test/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/UnsafeTest02.java b/testsuite/java_test/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/UnsafeTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed868df8a8ce76aefef62ea0ec7df4014135f9e0
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/UnsafeTest02.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeTest02 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest02.res -= 2;
+        }
+        if (result == 3 && UnsafeTest02.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetObjectVolatileTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie10.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie10();
+            result = unsafe.getObjectVolatile(obj, offset);
+            if(result.equals("eilish")){
+                UnsafeTest02.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie10{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/expected.txt b/testsuite/java_test/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/test.cfg b/testsuite/java_test/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ba82cdc426e4b5f4664e7c1f8358fd29133df329
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0472-rc-BindingMethod-UnsafeTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeTest02)
+run(UnsafeTest02)
diff --git a/testsuite/java_test/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/UnsafeTest03.java b/testsuite/java_test/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/UnsafeTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..a031dc5484623cabc3e44905342da8e780666dbf
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/UnsafeTest03.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeTest03 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest03.res -= 2;
+        }
+        if (result == 3 && UnsafeTest03.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie18.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie18();
+            result = unsafe.getObject(obj, offset);
+            if(result.equals("Me")){
+                UnsafeTest03.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie18{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/expected.txt b/testsuite/java_test/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/test.cfg b/testsuite/java_test/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a7f8eef80af85a2bf8f6fd8537cfa0e80cd86e2b
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0473-rc-BindingMethod-UnsafeTest03/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeTest03)
+run(UnsafeTest03)
diff --git a/testsuite/java_test/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/UnsafeTest04.java b/testsuite/java_test/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/UnsafeTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc08d6eaf9b9c2937c8253299b9d436f323d812d
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/UnsafeTest04.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeTest04 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest04.res -= 2;
+        }
+        if (result == 3 && UnsafeTest04.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie19.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie19();
+            result = unsafe.getObject(obj, offset);
+            unsafe.putObject(obj, offset, "she");
+            result = unsafe.getObject(obj,offset);
+            if(result.equals("she")){
+                UnsafeTest04.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie19{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/expected.txt b/testsuite/java_test/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/test.cfg b/testsuite/java_test/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..173f3006433f5280346641388345d0aa2f565a7f
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0474-rc-BindingMethod-UnsafeTest04/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeTest04)
+run(UnsafeTest04)
diff --git a/testsuite/java_test/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/UnsafeTest05.java b/testsuite/java_test/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/UnsafeTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a5d64b92bce76cf2800becfd3fd89de97c80e5d
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/UnsafeTest05.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeTest05 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest05.res -= 2;
+        }
+        if (result == 3 && UnsafeTest05.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputObjectVolatileTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie11.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie11();
+            result = unsafe.getObjectVolatile(obj, offset);
+            unsafe.putObjectVolatile(obj, offset, "Eilish");
+            result = unsafe.getObjectVolatile(obj, offset);
+            if(result.equals("Eilish")){
+                UnsafeTest05.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie11{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/expected.txt b/testsuite/java_test/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/test.cfg b/testsuite/java_test/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..adcb6317dc3710172b82725f6c7a016adfd97cae
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0475-rc-BindingMethod-UnsafeTest05/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeTest05)
+run(UnsafeTest05)
diff --git a/testsuite/java_test/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/UnsafeTest06.java b/testsuite/java_test/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/UnsafeTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..d8ac37f086dfea9327f1425e860f51177b659579
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/UnsafeTest06.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeTest06 {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputOrderedObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeTest06.res -= 2;
+        }
+        if (result == 3 && UnsafeTest06.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputOrderedObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie20.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie20();
+            result = unsafe.getObject(obj, offset);
+            unsafe.putOrderedObject(obj, offset, "she");
+            result = unsafe.getObject(obj,offset);
+            if(result.equals("she")){
+                UnsafeTest06.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie20{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/expected.txt b/testsuite/java_test/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/test.cfg b/testsuite/java_test/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a5b57df217965132cb79058a8945993ca8ea4504
--- /dev/null
+++ b/testsuite/java_test/rc_test/common_test/RC0476-rc-BindingMethod-UnsafeTest06/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeTest06)
+run(UnsafeTest06)
diff --git a/testsuite/java_test/rc_test/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02/RCUnownedRefUncycle02.java b/testsuite/java_test/rc_test/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02/RCUnownedRefUncycle02.java
new file mode 100755
index 0000000000000000000000000000000000000000..713bcb0d9b58643c1f430231085a50cb16e723b2
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02/RCUnownedRefUncycle02.java
@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+class Nocycle_a_00180_A1 {
+    Nocycle_a_00180_B1 b1_0;
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_A1(String strObjectName) {
+        b1_0 = null;
+        d1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a + d1_0.a;
+    }
+}
+class Nocycle_a_00180_A2 {
+    Nocycle_a_00180_B2 b2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_A2(String strObjectName) {
+        b2_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a;
+    }
+}
+class Nocycle_a_00180_A3 {
+    @Unowned
+    Nocycle_a_00180_B2 b2_0;
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_A3(String strObjectName) {
+        b2_0 = null;
+        c2_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b2_0.a + c2_0.a;
+    }
+}
+class Nocycle_a_00180_A4 {
+    Nocycle_a_00180_B3 b3_0;
+    @Unowned
+    Nocycle_a_00180_C2 c2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_A4(String strObjectName) {
+        b3_0 = null;
+        c2_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b3_0.a + c2_0.a;
+    }
+}
+class Nocycle_a_00180_B1 {
+    Nocycle_a_00180_D2 d2_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_B1(String strObjectName) {
+        d2_0 = null;
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a;
+    }
+}
+class Nocycle_a_00180_B2 {
+    Nocycle_a_00180_C1 c1_0;
+    @Unowned
+    Nocycle_a_00180_D1 d1_0;
+    @Unowned
+    Nocycle_a_00180_D2 d2_0;
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_B2(String strObjectName) {
+        c1_0 = null;
+        d1_0 = null;
+        d2_0 = null;
+        d3_0 = null;
+        a = 202;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_a_00180_B3 {
+    @Unowned
+    Nocycle_a_00180_C1 c1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_B3(String strObjectName) {
+        c1_0 = null;
+        a = 203;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+    }
+    void add() {
+        sum = a + c1_0.a;
+    }
+}
+class Nocycle_a_00180_C1 {
+    @Unowned
+    Nocycle_a_00180_D1 d1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_C1(String strObjectName) {
+        d1_0 = null;
+        a = 301;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+    }
+    void add() {
+        sum = a + d1_0.a;
+    }
+}
+class Nocycle_a_00180_C2 {
+    @Unowned
+    Nocycle_a_00180_D2 d2_0;
+    @Unowned
+    Nocycle_a_00180_D3 d3_0;
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_C2(String strObjectName) {
+        d2_0 = null;
+        d3_0 = null;
+        a = 302;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+    }
+    void add() {
+        sum = a + d2_0.a + d3_0.a;
+    }
+}
+class Nocycle_a_00180_D1 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_D1(String strObjectName) {
+        a = 401;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00180_D2 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_D2(String strObjectName) {
+        a = 402;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+class Nocycle_a_00180_D3 {
+    int a;
+    int sum;
+    String strObjectName;
+    Nocycle_a_00180_D3(String strObjectName) {
+        a = 403;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
+public class RCUnownedRefUncycle02 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+        a3_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = a2_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a1_main.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+        a4_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a3_main.c2_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum + a1_main.d1_0.sum + a2_main.b2_0.c1_0.sum;
+        if (result == 9260)
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02/test.cfg b/testsuite/java_test/rc_test/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a8e61c355a06b9c0feee735c6b1de21d5249603
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedRefUncycle02)
+run(RCUnownedRefUncycle02,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2/RCUnownedRefUncycleThread2.java b/testsuite/java_test/rc_test/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2/RCUnownedRefUncycleThread2.java
new file mode 100755
index 0000000000000000000000000000000000000000..395320961cf1639b643a6ec0e4719e6f0b8216bc
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2/RCUnownedRefUncycleThread2.java
@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Unowned;
+class ThreadRc_00180 extends Thread {
+    private boolean checkout;
+    public void run() {
+        Nocycle_a_00180_A1 a1_main = new Nocycle_a_00180_A1("a1_main");
+        Nocycle_a_00180_A2 a2_main = new Nocycle_a_00180_A2("a2_main");
+        Nocycle_a_00180_A3 a3_main = new Nocycle_a_00180_A3("a3_main");
+        Nocycle_a_00180_A4 a4_main = new Nocycle_a_00180_A4("a4_main");
+        a1_main.b1_0 = new Nocycle_a_00180_B1("b1_0");
+        a1_main.d1_0 = new Nocycle_a_00180_D1("d1_0");
+        a1_main.b1_0.d2_0 = new Nocycle_a_00180_D2("d2_0");
+        a2_main.b2_0 = new Nocycle_a_00180_B2("b2_0");
+        a2_main.b2_0.c1_0 = new Nocycle_a_00180_C1("c1_0");
+        a2_main.b2_0.d1_0 = a1_main.d1_0;
+        a2_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+        a2_main.b2_0.d3_0 = new Nocycle_a_00180_D3("d3_0");
+        a2_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0 = a2_main.b2_0;
+        a3_main.b2_0.c1_0 = a2_main.b2_0.c1_0;
+        a3_main.b2_0.c1_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0.d1_0 = a1_main.d1_0;
+        a3_main.b2_0.d2_0 = a1_main.b1_0.d2_0;
+        a3_main.b2_0.d3_0 = a2_main.b2_0.d3_0;
+        a3_main.c2_0 = new Nocycle_a_00180_C2("c2_0");
+        a3_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+        a3_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+        a4_main.b3_0 = new Nocycle_a_00180_B3("b3_0");
+        a4_main.b3_0.c1_0 = a2_main.b2_0.c1_0;
+        a4_main.b3_0.c1_0.d1_0 = a1_main.d1_0;
+        a4_main.c2_0 = a3_main.c2_0;
+        a4_main.c2_0.d2_0 = a1_main.b1_0.d2_0;
+        a4_main.c2_0.d3_0 = a2_main.b2_0.d3_0;
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a1_main.b1_0.add();
+        a1_main.d1_0.add();
+        a1_main.b1_0.d2_0.add();
+        a2_main.b2_0.add();
+        a2_main.b2_0.c1_0.add();
+        a2_main.b2_0.d1_0.add();
+        a2_main.b2_0.d2_0.add();
+        a2_main.b2_0.d3_0.add();
+        a2_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.add();
+        a3_main.b2_0.c1_0.add();
+        a3_main.b2_0.c1_0.d1_0.add();
+        a3_main.b2_0.d1_0.add();
+        a3_main.b2_0.d2_0.add();
+        a3_main.b2_0.d3_0.add();
+        a3_main.c2_0.add();
+        a3_main.c2_0.d2_0.add();
+        a3_main.c2_0.d3_0.add();
+        a4_main.b3_0.add();
+        a4_main.b3_0.c1_0.add();
+        a4_main.b3_0.c1_0.d1_0.add();
+        a4_main.c2_0.add();
+        a4_main.c2_0.d2_0.add();
+        a4_main.c2_0.d3_0.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a1_main.b1_0.sum + a2_main.b2_0.sum + a4_main.b3_0.sum + a3_main.c2_0.sum + a3_main.c2_0.d2_0.sum + a3_main.c2_0.d3_0.sum + a1_main.d1_0.sum + a2_main.b2_0.c1_0.sum;
+        if (result == 9260)
+            checkout = true;
+    }
+    public boolean check() {
+        return checkout;
+    }
+    class Nocycle_a_00180_A1 {
+        Nocycle_a_00180_B1 b1_0;
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A1(String strObjectName) {
+            b1_0 = null;
+            d1_0 = null;
+            a = 101;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+        }
+        void add() {
+            sum = a + b1_0.a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00180_A2 {
+        Nocycle_a_00180_B2 b2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A2(String strObjectName) {
+            b2_0 = null;
+            a = 102;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a;
+        }
+    }
+    class Nocycle_a_00180_A3 {
+        @Unowned
+        Nocycle_a_00180_B2 b2_0;
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A3(String strObjectName) {
+            b2_0 = null;
+            c2_0 = null;
+            a = 103;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+        }
+        void add() {
+            sum = a + b2_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_00180_A4 {
+        Nocycle_a_00180_B3 b3_0;
+        @Unowned
+        Nocycle_a_00180_C2 c2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_A4(String strObjectName) {
+            b3_0 = null;
+            c2_0 = null;
+            a = 104;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+        }
+        void add() {
+            sum = a + b3_0.a + c2_0.a;
+        }
+    }
+    class Nocycle_a_00180_B1 {
+        Nocycle_a_00180_D2 d2_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_B1(String strObjectName) {
+            d2_0 = null;
+            a = 201;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a;
+        }
+    }
+    class Nocycle_a_00180_B2 {
+        Nocycle_a_00180_C1 c1_0;
+        @Unowned
+        Nocycle_a_00180_D1 d1_0;
+        @Unowned
+        Nocycle_a_00180_D2 d2_0;
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_B2(String strObjectName) {
+            c1_0 = null;
+            d1_0 = null;
+            d2_0 = null;
+            d3_0 = null;
+            a = 202;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B2_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a + d1_0.a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_00180_B3 {
+        @Unowned
+        Nocycle_a_00180_C1 c1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_B3(String strObjectName) {
+            c1_0 = null;
+            a = 203;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B3_"+strObjectName);
+        }
+        void add() {
+            sum = a + c1_0.a;
+        }
+    }
+    class Nocycle_a_00180_C1 {
+        @Unowned
+        Nocycle_a_00180_D1 d1_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_C1(String strObjectName) {
+            d1_0 = null;
+            a = 301;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C1_"+strObjectName);
+        }
+        void add() {
+            sum = a + d1_0.a;
+        }
+    }
+    class Nocycle_a_00180_C2 {
+        @Unowned
+        Nocycle_a_00180_D2 d2_0;
+        @Unowned
+        Nocycle_a_00180_D3 d3_0;
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_C2(String strObjectName) {
+            d2_0 = null;
+            d3_0 = null;
+            a = 302;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_C2_"+strObjectName);
+        }
+        void add() {
+            sum = a + d2_0.a + d3_0.a;
+        }
+    }
+    class Nocycle_a_00180_D1 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_D1(String strObjectName) {
+            a = 401;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D1_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00180_D2 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_D2(String strObjectName) {
+            a = 402;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D2_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+    class Nocycle_a_00180_D3 {
+        int a;
+        int sum;
+        String strObjectName;
+        Nocycle_a_00180_D3(String strObjectName) {
+            a = 403;
+            sum = 0;
+            this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_D3_"+strObjectName);
+        }
+        void add() {
+            sum = a + a;
+        }
+    }
+}
+public class RCUnownedRefUncycleThread2 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        ThreadRc_00180 A1_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A2_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A3_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A4_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A5_00180 = new ThreadRc_00180();
+        ThreadRc_00180 A6_00180 = new ThreadRc_00180();
+        A1_00180.start();
+        A2_00180.start();
+        A3_00180.start();
+        A4_00180.start();
+        A5_00180.start();
+        A6_00180.start();
+        try {
+            A1_00180.join();
+            A2_00180.join();
+            A3_00180.join();
+            A4_00180.join();
+            A5_00180.join();
+            A6_00180.join();
+        } catch (InterruptedException e) {
+        }
+        if (A1_00180.check() && A2_00180.check() && A3_00180.check() && A4_00180.check() && A5_00180.check() && A6_00180.check())
+            System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2/test.cfg b/testsuite/java_test/rc_test/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0046f6a75eaf3364b13239f9e31d219591eb150e
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedRefUncycleThread2)
+run(RCUnownedRefUncycleThread2,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/issue-RC0422-rc-Annotation-RCUnownedOuterThreadTest/RCUnownedOuterThreadTest.java b/testsuite/java_test/rc_test/issue-RC0422-rc-Annotation-RCUnownedOuterThreadTest/RCUnownedOuterThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..451b1553144480cc211843e2ee48cb2ff974e1b3
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0422-rc-Annotation-RCUnownedOuterThreadTest/RCUnownedOuterThreadTest.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.*;
+import java.util.LinkedList;
+import java.util.List;
+class RCUnownedOuterTest extends Thread {
+    private boolean checkout;
+    public void run() {
+        UnownedAnnoymous unownedAnnoymous = new UnownedAnnoymous();
+        unownedAnnoymous.anonymousCapture();
+        UnownedInner unownedInner = new UnownedInner();
+        unownedInner.method();
+        UnownedInner.InnerClass innerClass = unownedInner.new InnerClass();
+        innerClass.myName();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (unownedAnnoymous.checkAnnoy == true && unownedInner.checkInner == true) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println("error");
+            System.out.println("unownedAnnoymous.checkAnnoy:" + unownedAnnoymous.checkAnnoy);
+            System.out.println("unownedInner.checkInner:" + unownedInner.checkInner);
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+class UnownedInner {
+    String name = "test";
+    boolean checkInner = false;
+    InnerClass innerClass;
+    void method() {
+        innerClass = new InnerClass();
+    }
+    @UnownedOuter
+    class InnerClass {
+        void myName() {
+            checkInner = false;
+            String myname;
+            myname = name + name;
+            if (myname.equals("testtest")) {
+                checkInner=true;
+               // System.out.println("checkInner:"+checkInner);
+            }
+        }
+    }
+}
+class UnownedAnnoymous {
+    String name = "test";
+    boolean checkAnnoy=false;
+    void anonymousCapture() {
+        Runnable r = new Runnable() {
+            @UnownedOuter
+            @Override
+            public void run() {
+                checkAnnoy = false;
+                String myName = name + name;
+                if (myName.equals("testtest")) {
+                    checkAnnoy=true;
+                  // System.out.println("checkAnnoy:"+checkAnnoy);
+                }
+            }
+        };
+        r.run();
+    }
+}
+public class RCUnownedOuterThreadTest {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        RCUnownedOuterTest rcTest1 = new RCUnownedOuterTest();
+        RCUnownedOuterTest rcTest2 = new RCUnownedOuterTest();
+        RCUnownedOuterTest rcTest3 = new RCUnownedOuterTest();
+        RCUnownedOuterTest rcTest4 = new RCUnownedOuterTest();
+        RCUnownedOuterTest rcTest5 = new RCUnownedOuterTest();
+        RCUnownedOuterTest rcTest6 = new RCUnownedOuterTest();
+        rcTest1.start();
+        rcTest2.start();
+        rcTest3.start();
+        rcTest4.start();
+        rcTest5.start();
+        rcTest6.start();
+        try {
+            rcTest1.join();
+            rcTest2.join();
+            rcTest3.join();
+            rcTest4.join();
+            rcTest5.join();
+            rcTest6.join();
+        } catch (InterruptedException e) {
+        }
+        if (rcTest1.check() && rcTest2.check() && rcTest3.check() && rcTest4.check() && rcTest5.check() && rcTest6.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcTest1.check():" + rcTest1.check());
+            System.out.println("rcTest2.check():" + rcTest2.check());
+            System.out.println("rcTest3.check():" + rcTest3.check());
+            System.out.println("rcTest4.check():" + rcTest4.check());
+            System.out.println("rcTest5.check():" + rcTest5.check());
+            System.out.println("rcTest6.check():" + rcTest6.check());
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0422-rc-Annotation-RCUnownedOuterThreadTest/test.cfg b/testsuite/java_test/rc_test/issue-RC0422-rc-Annotation-RCUnownedOuterThreadTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..797d2d01d55b24ab2d9e85927dffdc0c27950201
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0422-rc-Annotation-RCUnownedOuterThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCUnownedOuterThreadTest)
+run(RCUnownedOuterThreadTest,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/issue-RC0460-rc-GC-TriggerGCTest04_Phone/TriggerGCTest04.java b/testsuite/java_test/rc_test/issue-RC0460-rc-GC-TriggerGCTest04_Phone/TriggerGCTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7b2336ca962671b0e6a0e7435b9c0c9f02100c2
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0460-rc-GC-TriggerGCTest04_Phone/TriggerGCTest04.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+public class TriggerGCTest04 {
+    static int check = 4;
+    public static void main(String[] args) {
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+        }
+        SoftReference<Reference04> softReference = new SoftReference<>(new Reference04(100));
+        Reference04 rt01 = softReference.get();
+        // rt01 must check null because of the difference between maple and art.
+        // In maple runtime, SoftReference could be released when memory is sufficient.
+        if (rt01 == null || (rt01.stringArray.length == 100 && rt01.stringArray[9].equals("test9"))) {
+            check--;
+        }
+        rt01 = null;
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+        }
+        if (softReference.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+    private static int oomTest() {
+        int sum = 0;
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1044 * 1044; i <= 1044 * 1044 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+}
+class Reference04 {
+    String[] stringArray;
+    public Reference04(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0460-rc-GC-TriggerGCTest04_Phone/test.cfg b/testsuite/java_test/rc_test/issue-RC0460-rc-GC-TriggerGCTest04_Phone/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c233c0bbefd79b07a4c89b0044052201b358257f
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0460-rc-GC-TriggerGCTest04_Phone/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest04)
+run(TriggerGCTest04,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/issue-RC0461-rc-GC-TriggerGCTest05_Phone/TriggerGCTest05.java b/testsuite/java_test/rc_test/issue-RC0461-rc-GC-TriggerGCTest05_Phone/TriggerGCTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c643817fb9292aaeebc7fa6245a9dcd73a7730f
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0461-rc-GC-TriggerGCTest05_Phone/TriggerGCTest05.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+public class TriggerGCTest05 {
+    static int check = 4;
+    public static void main(String[] args) {
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+        }
+        SoftReference<Reference05> softReference = new SoftReference<>(new Reference05(100));
+        Reference05 rt01 = softReference.get();
+        if (rt01.stringArray.length == 100 && rt01.stringArray[9].equals("test9")) {
+            check--;
+        }
+        rt01 = null;
+        try {
+            Thread.sleep(4000);
+        } catch (InterruptedException e) {
+            // do nothing
+        }
+        try {
+            int oom = oomTest(); // 触发oom
+        } catch (OutOfMemoryError o) {
+            check--;
+        }
+        if (softReference.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+    private static int oomTest() {
+        int sum = 0;
+        ArrayList<byte[]> store = new ArrayList<byte[]>();
+        byte[] temp;
+        for (int i = 1054 * 1054; i <= 1054 * 1054 * 10; ) {
+            temp = new byte[i];
+            store.add(temp);
+            sum += store.size();
+        }
+        return sum;
+    }
+}
+class Reference05 {
+    String[] stringArray;
+    public Reference05(int length) {
+        stringArray = new String[length];
+        for (int i = 0; i < length; i++) {
+            stringArray[i] = "test" + i;
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0461-rc-GC-TriggerGCTest05_Phone/test.cfg b/testsuite/java_test/rc_test/issue-RC0461-rc-GC-TriggerGCTest05_Phone/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..0dcdf0b6a6059c48eaf6a64f635901231a4827ee
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0461-rc-GC-TriggerGCTest05_Phone/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest05)
+run(TriggerGCTest05,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/issue-RC0462-rc-GC-TriggerGCTest06_Phone/TriggerGCTest06.java b/testsuite/java_test/rc_test/issue-RC0462-rc-GC-TriggerGCTest06_Phone/TriggerGCTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..0811d5382fbd2b94965fe111c566285c7e7582b7
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0462-rc-GC-TriggerGCTest06_Phone/TriggerGCTest06.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+public class TriggerGCTest06 {
+    static WeakReference observer;
+    static ReferenceQueue rq = new ReferenceQueue();
+    static int check = 2;
+    private final static int RPLENGTH = 10000;
+    public static void main(String[] args) throws Exception {
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        for (int i = 0; i < RPLENGTH; i++) {
+            WeakReference wr = new WeakReference(new Object(),rq);
+            wr = null;
+        }
+        Thread.sleep(3000);
+        if (observer.get() == null) { // gconly因为该触发机制已经去使能，所以不会隐式触发GC; rc使能了该机制。
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0462-rc-GC-TriggerGCTest06_Phone/test.cfg b/testsuite/java_test/rc_test/issue-RC0462-rc-GC-TriggerGCTest06_Phone/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..595ec7060967718e7c812c8a938ceeabc57a5771
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0462-rc-GC-TriggerGCTest06_Phone/test.cfg
@@ -0,0 +1,2 @@
+compile(TriggerGCTest06)
+run(TriggerGCTest06,EXPECTNUM=1)
diff --git a/testsuite/java_test/rc_test/issue-RC0467-rc-GC-TriggerGCTest11-Phone/TriggerGCTest11.java b/testsuite/java_test/rc_test/issue-RC0467-rc-GC-TriggerGCTest11-Phone/TriggerGCTest11.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f7b6209e533d347a2bb5b592e6ef6e4b51b35c4
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0467-rc-GC-TriggerGCTest11-Phone/TriggerGCTest11.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.lang.ref.WeakReference;
+public class TriggerGCTest11 {
+    static WeakReference observer;
+    static int check = 2;
+    public static String str = new String("Native memory test");
+    public static int[] arr = new int[10 * 1024 * 1024];
+    public static void main(String[] args) throws Exception {
+        observer = new WeakReference<Object>(new Object());
+        if (observer.get() != null) {
+            check--;
+        }
+        rc_testcase_main_wrapper();
+        Thread.sleep(3000);
+        if (observer.get() == null) {
+            check--;
+        }
+        if (check == 0) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult, check should be 0, but now check = " + check);
+        }
+    }
+    private static void rc_testcase_main_wrapper() {
+        try {
+            String filePath = "/system/lib64/libmaplecore-all.so";
+            FileInputStream fis = new FileInputStream(filePath); // Any file with size >= 501*501*501*2
+            int fileSize = fis.available();
+            byte buf[] = new byte[fileSize];
+            fis.read(buf);
+            System.out.println("buffRead ok");
+        } catch (Exception e) {
+            // do nothing
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0495-rc-Trim-TrimTest01-Phone/TrimTest01.java b/testsuite/java_test/rc_test/issue-RC0495-rc-Trim-TrimTest01-Phone/TrimTest01.java
new file mode 100644
index 0000000000000000000000000000000000000000..9da5dc8712953d8be140994c6b5a080f68fa1473
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0495-rc-Trim-TrimTest01-Phone/TrimTest01.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest01 {
+    private static final int MEMORY_LIMIT = 10;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest01().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo);
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        if (Integer.valueOf(rosInfo) > MEMORY_LIMIT * 1024 && Integer.valueOf(rosInfo2) < 3.2 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0495-rc-Trim-TrimTest01-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0495-rc-Trim-TrimTest01-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..775fea8178a46b6004c9c5d4de6f28dc9858edc0
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0495-rc-Trim-TrimTest01-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest01_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0496-rc-Trim-TrimTest02-Phone/TrimTest02.java b/testsuite/java_test/rc_test/issue-RC0496-rc-Trim-TrimTest02-Phone/TrimTest02.java
new file mode 100644
index 0000000000000000000000000000000000000000..405d4da0f8b807e2411de60c7d3ac0332cb66b2b
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0496-rc-Trim-TrimTest02-Phone/TrimTest02.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest02 {
+    private static final int MEMORY_LIMIT = 10;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest02().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        for (int i = 9; i >= 5; i--) {
+            store.remove(i);
+        }
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        if (Integer.valueOf(rosInfo) > MEMORY_LIMIT * 1024 && Integer.valueOf(rosInfo2) > 3.8 * 1024 &&
+            (Integer.valueOf(rosInfo) - Integer.valueOf(rosInfo2) > 2.7 * 1024)) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("before gc: " + rosInfo + " after gc: " + rosInfo2);
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0496-rc-Trim-TrimTest02-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0496-rc-Trim-TrimTest02-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a8f190c6bac45b1366b8a3fa680e7e660f5e396a
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0496-rc-Trim-TrimTest02-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest02_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0497-rc-Trim-TrimTest03-Phone/TrimTest03.java b/testsuite/java_test/rc_test/issue-RC0497-rc-Trim-TrimTest03-Phone/TrimTest03.java
new file mode 100644
index 0000000000000000000000000000000000000000..58656626e8bb5fe8c92f8bdf77ed8481bab14f17
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0497-rc-Trim-TrimTest03-Phone/TrimTest03.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest03 {
+    private static final int MEMORY_LIMIT = 10;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest03().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        for (int i = 9; i > 7; i--) {
+            store.remove(i);
+        }
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo2);
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        if (Integer.valueOf(rosInfo) - Integer.valueOf(rosInfo2) < 1.2 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0497-rc-Trim-TrimTest03-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0497-rc-Trim-TrimTest03-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df2f338e506656f56a0b64c9a5efc430eb7575df
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0497-rc-Trim-TrimTest03-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest03_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0498-rc-Trim-TrimTest04-Phone/TrimTest04.java b/testsuite/java_test/rc_test/issue-RC0498-rc-Trim-TrimTest04-Phone/TrimTest04.java
new file mode 100644
index 0000000000000000000000000000000000000000..d49d93ee831f30903f5ce56d957690b1bae1d3af
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0498-rc-Trim-TrimTest04-Phone/TrimTest04.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest04 {
+    private static final int MEMORY_LIMIT = 20;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest04().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo);
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo2);
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        if (Integer.valueOf(rosInfo) > MEMORY_LIMIT * 1024 && Integer.valueOf(rosInfo2) < 3.2 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0498-rc-Trim-TrimTest04-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0498-rc-Trim-TrimTest04-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cf002752ab4778a8165767f3b9b1ef752e0017ec
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0498-rc-Trim-TrimTest04-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest04_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0499-rc-Trim-TrimTest05-Phone/TrimTest05.java b/testsuite/java_test/rc_test/issue-RC0499-rc-Trim-TrimTest05-Phone/TrimTest05.java
new file mode 100644
index 0000000000000000000000000000000000000000..10159c0fc8fd7369c2a883b95efc744895966e94
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0499-rc-Trim-TrimTest05-Phone/TrimTest05.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest05 {
+    private static final int MEMORY_LIMIT = 20;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest05().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        for (int i = 19; i > 10; i--) {
+            store.remove(i);
+        }
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        if (Integer.valueOf(rosInfo) > MEMORY_LIMIT * 1024 && Integer.valueOf(rosInfo2) > 11 * 1024 &&
+            Integer.valueOf(rosInfo2) < 15.2 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0499-rc-Trim-TrimTest05-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0499-rc-Trim-TrimTest05-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..846dfaa300137915f15c3b7747783f8595f7b21c
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0499-rc-Trim-TrimTest05-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest05_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0500-rc-Trim-TrimTest06-Phone/TrimTest06.java b/testsuite/java_test/rc_test/issue-RC0500-rc-Trim-TrimTest06-Phone/TrimTest06.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b13b31ac6faf937b1f27d4ecadfd52ebd24f026
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0500-rc-Trim-TrimTest06-Phone/TrimTest06.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest06 {
+    private static final int MEMORY_LIMIT = 20;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest06().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo);
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        for (int i = 19; i > 16; i--) {
+            store.remove(i);
+        }
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo2);
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        if (Integer.valueOf(rosInfo) - Integer.valueOf(rosInfo2) < 1.2 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0500-rc-Trim-TrimTest06-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0500-rc-Trim-TrimTest06-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f1647e169b835b3f1855446210bbb089d60adde5
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0500-rc-Trim-TrimTest06-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest06_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0501-rc-Trim-TrimTest07-Phone/TrimTest07.java b/testsuite/java_test/rc_test/issue-RC0501-rc-Trim-TrimTest07-Phone/TrimTest07.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c668649580c5fe8e560e77bd45ef94ea2360931
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0501-rc-Trim-TrimTest07-Phone/TrimTest07.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest07 {
+    private static final int MEMORY_LIMIT = 50;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest07().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        if (Integer.valueOf(rosInfo) > MEMORY_LIMIT * 1024 && Integer.valueOf(rosInfo2) < 5 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0501-rc-Trim-TrimTest07-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0501-rc-Trim-TrimTest07-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7813a1b5574751e760cc1044a850f2fb367e06ae
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0501-rc-Trim-TrimTest07-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest07_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0502-rc-Trim-TrimTest08-Phone/TrimTest08.java b/testsuite/java_test/rc_test/issue-RC0502-rc-Trim-TrimTest08-Phone/TrimTest08.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f5dcaf7247d7fb90bf7264af5221c6c48e5c602
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0502-rc-Trim-TrimTest08-Phone/TrimTest08.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest08 {
+    private static final int MEMORY_LIMIT = 50;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest08().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        for (int i = 49; i > 39; i--) {
+            store.remove(i);
+        }
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo2);
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                // System.out.println(rosInfo2);
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        if (Integer.valueOf(rosInfo) > MEMORY_LIMIT * 1024 && Integer.valueOf(rosInfo2) >= 41.8 * 1024 &&
+            Integer.valueOf(rosInfo2) < 44.2 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0502-rc-Trim-TrimTest08-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0502-rc-Trim-TrimTest08-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..516df219c5df1063a5f38e2df7aac9955ff7036b
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0502-rc-Trim-TrimTest08-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest08_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0503-rc-Trim-TrimTest09-Phone/TrimTest09.java b/testsuite/java_test/rc_test/issue-RC0503-rc-Trim-TrimTest09-Phone/TrimTest09.java
new file mode 100644
index 0000000000000000000000000000000000000000..c668f8ded867e81b529309dc8b6adfcbe88b940c
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0503-rc-Trim-TrimTest09-Phone/TrimTest09.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest09 {
+    private static final int MEMORY_LIMIT = 50;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest09().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        for (int i = 49; i > 42; i--) {
+            store.remove(i);
+        }
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo2);
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        if (Integer.valueOf(rosInfo) - Integer.valueOf(rosInfo2) < 1.5 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0503-rc-Trim-TrimTest09-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0503-rc-Trim-TrimTest09-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4716a7a0639f525b0848a3a1339b365daa9d6ac
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0503-rc-Trim-TrimTest09-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest09_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0504-rc-Trim-TrimTest10-Phone/TrimTest10.java b/testsuite/java_test/rc_test/issue-RC0504-rc-Trim-TrimTest10-Phone/TrimTest10.java
new file mode 100644
index 0000000000000000000000000000000000000000..74da6b5d978286d54720acb4f311b27db3b1d27c
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0504-rc-Trim-TrimTest10-Phone/TrimTest10.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest10 {
+    private static final int MEMORY_LIMIT = 100;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest10().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store.clear();
+        store = null;
+        Thread.sleep(4000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(3000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        if (Integer.valueOf(rosInfo) > MEMORY_LIMIT * 1024 && Integer.valueOf(rosInfo2) < 5 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0504-rc-Trim-TrimTest10-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0504-rc-Trim-TrimTest10-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7b4686a24677fc24c884187766d298a60a2a2832
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0504-rc-Trim-TrimTest10-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest10_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0505-rc-Trim-TrimTest11-Phone/TrimTest11.java b/testsuite/java_test/rc_test/issue-RC0505-rc-Trim-TrimTest11-Phone/TrimTest11.java
new file mode 100644
index 0000000000000000000000000000000000000000..f478b207933ba75907b2a75f1d68a1d9a44d8fc3
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0505-rc-Trim-TrimTest11-Phone/TrimTest11.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest11 {
+    private static final int MEMORY_LIMIT = 100;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest11().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        for (int i = 99; i > 89; i--) {
+            store.remove(i);
+        }
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo2);
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        if (Integer.valueOf(rosInfo) > MEMORY_LIMIT * 1024 && Integer.valueOf(rosInfo2) > 89 * 1024 &&
+            Integer.valueOf(rosInfo2) < 94.5 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0505-rc-Trim-TrimTest11-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0505-rc-Trim-TrimTest11-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..29a7db35c621f168c3062b8e293597f88de63962
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0505-rc-Trim-TrimTest11-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest11_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0506-rc-Trim-TrimTest12-Phone/TrimTest12.java b/testsuite/java_test/rc_test/issue-RC0506-rc-Trim-TrimTest12-Phone/TrimTest12.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d8d65acd05219d987a43cf7ff60bcec5ca9ec48
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0506-rc-Trim-TrimTest12-Phone/TrimTest12.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class TrimTest12 {
+    private static final int MEMORY_LIMIT = 100;
+    private static ArrayList<byte[]> store = new ArrayList<byte[]>();
+    public static void main(String[] args) throws Exception {
+        Thread.sleep(2000);
+        for (int i = 0; i < MEMORY_LIMIT; i++) {
+            byte[] temp = new byte[1024 * 1024];
+            for (int j = 0; j < 1024 * 1024; j += 4096) {
+                temp[j] = (byte) 1;
+            }
+            store.add(temp);
+        }
+        int pid = new TrimTest12().getPid();
+        String command = "showmap " + pid;
+        Process process = Runtime.getRuntime().exec(command);
+        BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo = "";
+        while ((rosInfo = input.readLine()) != null) {
+            if (rosInfo.contains("maple_alloc_ros]")) {
+                rosInfo = rosInfo.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        for (int i = 99; i > 94; i--) {
+            store.remove(i);
+        }
+        Thread.sleep(2000);
+        Runtime.getRuntime().gc();
+        Thread.sleep(2000);
+        process = Runtime.getRuntime().exec(command);
+        input = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String rosInfo2 = "";
+        while ((rosInfo2 = input.readLine()) != null) {
+            if (rosInfo2.contains("maple_alloc_ros]")) {
+                // System.out.println(rosInfo2);
+                rosInfo2 = rosInfo2.split("\\s+")[3];
+                break;
+            }
+        }
+        input.close();
+        store = null;
+        if (Integer.valueOf(rosInfo) - Integer.valueOf(rosInfo2) < 1.5 * 1024) {
+            System.out.println("ExpectResult");
+        }
+    }
+    public native int getPid();
+}
diff --git a/testsuite/java_test/rc_test/issue-RC0506-rc-Trim-TrimTest12-Phone/jniNativeGetPid.cpp b/testsuite/java_test/rc_test/issue-RC0506-rc-Trim-TrimTest12-Phone/jniNativeGetPid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4b5aa622213bbc35feafba1c13e7616e977e8b4d
--- /dev/null
+++ b/testsuite/java_test/rc_test/issue-RC0506-rc-Trim-TrimTest12-Phone/jniNativeGetPid.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <iostream>
+#include <stdio.h>
+#include <unistd.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+JNIEXPORT jint JNICALL Java_TrimTest12_getPid__
+(JNIEnv *env, jobject j_obj) {
+    return getpid();
+}
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/RCPermanentTest.java b/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/RCPermanentTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..5432d8b5e24c12c665814def63ac8f3d08c3d44f
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/RCPermanentTest.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import com.huawei.ark.annotation.Permanent;
+import java.lang.ref.WeakReference;
+public class RCPermanentTest {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1(Object obj) {
+        obj = new int @Permanent [8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+    /*
+    验证new int [8]
+   */
+
+
+    static void method2(Object obj) {
+        obj = new int[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int [8];in method2");
+        }
+    }
+    /*
+    验证new @Permanent int[8]
+  */
+
+
+    static void method3(Object obj) {
+        obj = new @Permanent int[1];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent int[8];in method3");
+        }
+    }
+    /*
+    验证new Integer @Permanent [10]
+  */
+
+
+    static void method4(Object obj) {
+        Integer[] arr = new Integer @Permanent [10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer @Permanent [10];in method4");
+        }
+    }
+    /*
+   验证new @Permanent Integer  [10]
+ */
+
+
+    static void method5(Object obj) {
+        Integer[] arr = new @Permanent Integer[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent Integer [10];in method5");
+        }
+    }
+    /*
+    验证new Integer[10];
+  */
+
+
+    static void method6(Object obj) {
+        obj = new Integer[10];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer[10];in method6");
+        }
+    }
+    /*
+    验证new @Permanent ArrayList[]{};
+  */
+
+
+    static void method7(Object obj) {
+        obj = new @Permanent ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent ArrayList[]{};in method7");
+        }
+    }
+    /*
+    验证new ArrayList @Permanent []{};
+  */
+
+
+    static void method8(Object obj) {
+        obj = new ArrayList @Permanent []{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList @Permanent []{};in method8");
+        }
+    }
+    /*
+    验证new ArrayList []{};
+  */
+
+
+    static void method9(Object obj) {
+        obj = new ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList []{}; method9");
+        }
+    }
+    static ArrayList<Object> noleak = new ArrayList<>();
+    public static int NUM = 5;
+    public static void main(String[] args) {
+        for(int i=0;i<NUM;i++){
+            Object obj = null;
+            method1(obj);
+            method2(obj);
+            method3(obj);
+            method4(obj);
+            method5(obj);
+            method6(obj);
+            method7(obj);
+            method8(obj);
+            method9(obj);
+        }
+        if (checkNum == 9*NUM) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/expected.txt b/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e8f5a082bd2f6cd40abefbd061f93efe9c9b3695
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/test.cfg b/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e321d3c974644d434670fec30b4ad2a8062d1dbe
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0411-rc-Annotation-RCPermanentTest/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentTest,NATIVE_SRC=jniTestHelper)
+run(RCPermanentTest)
diff --git a/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/RCPermanentTest2.java b/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/RCPermanentTest2.java
new file mode 100755
index 0000000000000000000000000000000000000000..e4d472b8724bdfcaf0f11ad3380c9bb79fc6a5a6
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/RCPermanentTest2.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import com.huawei.ark.annotation.Permanent;
+import java.lang.ref.WeakReference;
+public class RCPermanentTest2 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    public static Integer INT = new @Permanent Integer(100);
+    public static Integer INT2 = new Integer(100);
+    static String STRING = new @Permanent String("test");
+    static Long LONG = new @Permanent Long(522222);
+    static Long LONG2 = null;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+    /*
+    验证public final static Integer INT = new @Permanent Integer(100);
+  */
+
+
+    static void method1() {
+        boolean result = checkRC(INT);
+        boolean heapResult = isHeapObject(INT);
+        if ((result == false) && (heapResult == false)) {
+            checkNum++;
+        } else {
+            System.out.println("error in method1");
+            System.out.println("result:" + result + "    isHeap:" + heapResult);
+            System.out.println(String.valueOf(result));
+            System.out.println(String.valueOf(heapResult));
+        }
+    }
+    /*
+    验证public final static Integer INT2 = new Integer(100);
+  */
+
+
+    static void method2() {
+        boolean result = checkRC(INT2);
+        if (result == true && isHeapObject(INT2) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method2");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(INT2));
+        }
+    }
+    /*
+    验证static String STRING = new @Permanent String("test");
+  */
+
+
+    static void method3() {
+       // static String STRING = new @Permanent String("test");
+        boolean result = checkRC(STRING);
+        if (result == true && isHeapObject(STRING) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method3");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(STRING));
+        }
+    }
+    /*
+    验证static Long LONG2 = new  Long("test4");
+  */
+
+
+    static void method4() {
+        LONG2 = new Long(2222222);
+        boolean result = checkRC(LONG2);
+        if (result == true && isHeapObject(LONG2) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method4");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(LONG2));
+        }
+    }
+    /*
+    验证String obj = new @Permanent Long("test5");
+  */
+
+
+    static void method5() {
+        //String obj = new @Permanent String("test5");
+        Double obj = new @Permanent Double(3333.3);
+        boolean result = checkRC(obj);
+        if (result == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in method5");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证String obj = new String("test6");
+  */
+
+
+    static void method6() {
+        Double obj = new Double(3333.3);
+        boolean result = checkRC(obj);
+        if (result == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method6");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证obj =  new @Permanent Integer("test");
+  */
+
+
+    static volatile Integer obj = null;
+    static void method7() {
+        obj = new @Permanent Integer(123);
+        boolean result = checkRC(obj);
+        if (result == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in  method7");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证obj =  new @Permanent Integer("test");
+  */
+
+
+    static void method8() {
+        obj = new Integer(123);
+        boolean result = checkRC(obj);
+        if (result == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method8");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证static Long LONG = new @Permanent Long(522222);
+  */
+
+
+    static void method9() {
+        boolean result = checkRC(LONG);
+        if (result == false && isHeapObject(LONG) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in method3");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(LONG));
+        }
+    }
+    public static void main(String[] args) {
+        method1();
+        method2();
+        method3();
+        method4();
+        method5();
+        method6();
+        method7();
+        method8();
+        method9();
+        if (checkNum == 9) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/expected.txt b/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4ff4a1fb47ec7c07ee280d491dbca9e264a7d985
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest2_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest2_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest2");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest2_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest2_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/test.cfg b/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4b0f0b18fd78da78695003aafb4e5802f41ad4e6
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0412-rc-Annotation-RCPermanentTest2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentTest2,NATIVE_SRC=jniTestHelper)
+run(RCPermanentTest2)
diff --git a/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/RCPermanentTest3.java b/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/RCPermanentTest3.java
new file mode 100755
index 0000000000000000000000000000000000000000..d16fc0db790d03e51146331a5d8bf3976b228cfd
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/RCPermanentTest3.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import com.huawei.ark.annotation.Permanent;
+import java.lang.ref.WeakReference;
+public class RCPermanentTest3 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1() {
+        ArrayList list = null;
+        list = new @Permanent ArrayList<>();
+        boolean result1 = checkRC(list);
+        boolean result2 = isHeapObject(list);
+        if (String.valueOf(result1).equals("false") && String.valueOf(result2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method1");
+            System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+    static void method2() {
+        ArrayList list = null;
+        list = new ArrayList<Object>();
+                list.add("test");
+        boolean result1 = checkRC(list);
+        boolean result2 = isHeapObject(list);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method2");
+            System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+    public static void main(String[] args) {
+        method1();
+        Runtime.getRuntime().gc();
+        method1();
+        method2();
+        Runtime.getRuntime().gc();
+        method2();
+        if (checkNum == 4) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/expected.txt b/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5fe2ed467e5dd437a9773b26517c09c24ce80fb7
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest3_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest3_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest3");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest3_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest3_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/test.cfg b/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a11942e6d1eef97142e04b9529cf9b7a95b3353b
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0413-rc-Annotation-RCPermanentTest3/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentTest3,NATIVE_SRC=jniTestHelper)
+run(RCPermanentTest3)
diff --git a/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/RCPermanentTest4.java b/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/RCPermanentTest4.java
new file mode 100755
index 0000000000000000000000000000000000000000..2ef488ea1e6273413c336815148ad035cef8c87e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/RCPermanentTest4.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import com.huawei.ark.annotation.Permanent;
+import java.lang.ref.WeakReference;
+public class RCPermanentTest4 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+    /*
+      验证环场景
+     */
+
+
+    static void method1() {
+        Cycle_A a = new Cycle_A();
+        a.b = null;
+        a.b = new @Permanent Cycle_B();
+        a.b.a = a;
+        int result = a.add() + a.b.add();
+        if (result == 16) {
+            checkNum++;
+        } else {
+            System.out.println("result:" + result);
+        }
+        boolean resultA1 = checkRC(a);
+        boolean resultA2 = isHeapObject(a);
+        boolean resultB1 = checkRC(a.b);
+        boolean resultB2 = isHeapObject(a.b);
+        if (String.valueOf(resultA1).equals("true") && String.valueOf(resultA2).equals("true") && String.valueOf(resultB1).equals("false") && String.valueOf(resultB2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error");
+            System.out.println("CycleA_checkRC:" + resultA1);
+            System.out.println("CycleA_isHeap:" + resultA2);
+            System.out.println("CycleB_checkRC:" + resultB1);
+            System.out.println("CycleB_isHeap:" + resultB2);
+            //System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+    public static void main(String[] args) {
+        method1();
+        if (checkNum == 2) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+class Cycle_A {
+    Cycle_B b;
+    static int sum;
+    static int a;
+    Cycle_A() {
+        a = 3;
+    }
+    int add() {
+        sum = a + b.b;
+        return sum;
+    }
+}
+class Cycle_B {
+    Cycle_A a;
+    static int sum;
+    static int b;
+    Cycle_B() {
+        b = 5;
+    }
+    int add() {
+        sum = a.a + b;
+        return sum;
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/expected.txt b/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bea76f7a2974199204d8fc53442f00a9f68e69b7
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest4_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest4_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest4");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest4_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest4_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/test.cfg b/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6c146ff744217f0ef125451ee7f68cc00484b02f
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0414-rc-Annotation-RCPermanentTest4/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentTest4,NATIVE_SRC=jniTestHelper)
+run(RCPermanentTest4)
diff --git a/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/RCPermanentTest5.java b/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/RCPermanentTest5.java
new file mode 100755
index 0000000000000000000000000000000000000000..86eb5886a218cc9868c8121fefbd07ea0dda113e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/RCPermanentTest5.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import com.huawei.ark.annotation.Permanent;
+import sun.misc.Cleaner;
+import java.lang.ref.*;
+import static java.lang.Thread.sleep;
+class FinalizableObject {
+    // static int value;
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+public class RCPermanentTest5 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    static Object owner;
+    static int checkSum;
+    static Object referent = new Object();
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+    static void methodRef1(Object obj) {
+        obj = new @Permanent WeakReference(referent);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+    static void methodRef2(Object obj) {
+        obj = new @Permanent SoftReference(referent);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+    static void methodRef3(Object obj) {
+        ReferenceQueue rq = new ReferenceQueue();
+        obj = new @Permanent PhantomReference(referent, rq);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+    static void methodFinal(Object obj) throws InterruptedException {
+        obj = new @Permanent FinalizableObject();
+        sleep(3000);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+    public static void main(String[] args) throws InterruptedException {
+        Object obj = null;
+        methodRef1(obj);
+        methodRef2(obj);
+        methodRef3(obj);
+        methodFinal(obj);
+        if (checkSum == 4) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkSum);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/expected.txt b/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a13833282f618115eb3ceee4d7290550e74c272e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest5_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest5_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest5");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest5_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest5_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/test.cfg b/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..39af39b3370ba8a56d14098761b71ae1633da73d
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0415-rc-Annotation-RCPermanentTest5/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentTest5,NATIVE_SRC=jniTestHelper)
+run(RCPermanentTest5)
diff --git a/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/RCPermanentThread.java b/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/RCPermanentThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..026278b24a567a7ba33cc5ff876042ad04d71dfa
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/RCPermanentThread.java
@@ -0,0 +1,674 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import com.huawei.ark.annotation.Permanent;
+import sun.misc.Cleaner;
+import java.lang.ref.*;
+public class RCPermanentThread {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCPermanentTest rcPermanentTest = new RCPermanentTest();
+        RCPermanentTest2 rcPermanentTest2 = new RCPermanentTest2();
+        RCPermanentTest3 rcPermanentTest3 = new RCPermanentTest3();
+        RCPermanentTest4 rcPermanentTest4 = new RCPermanentTest4();
+        RCPermanentTest5 rcPermanentTest5 = new RCPermanentTest5();
+        rcPermanentTest.start();
+        rcPermanentTest2.start();
+        rcPermanentTest3.start();
+        rcPermanentTest4.start();
+        rcPermanentTest5.start();
+        rcPermanentTest.join();
+        rcPermanentTest2.join();
+        rcPermanentTest3.join();
+        rcPermanentTest4.join();
+        rcPermanentTest5.join();
+        if (rcPermanentTest.check() && rcPermanentTest2.check() && rcPermanentTest3.check() && rcPermanentTest4.check() && rcPermanentTest5.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + rcPermanentTest.check());
+            System.out.println("rcPermanentTest2.check() :" + rcPermanentTest2.check());
+            System.out.println("rcPermanentTest3.check() :" + rcPermanentTest3.check());
+            System.out.println("rcPermanentTest4.check() :" + rcPermanentTest4.check());
+            System.out.println("rcPermanentTest5.check() :" + rcPermanentTest5.check());
+        }
+    }
+}
+class RCPermanentTest extends Thread {
+    public boolean checkout;
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+    /*
+    验证new int [8]
+   */
+
+
+    static void method2(Object obj) {
+        obj = new int[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int [8];in method2");
+        }
+    }
+    /*
+    验证new @Permanent int[8]
+  */
+
+
+    static void method3(Object obj) {
+        obj = new @Permanent int[1];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent int[8];in method3");
+        }
+    }
+    /*
+    验证new Integer @Permanent [10]
+  */
+
+
+    static void method4(Object obj) {
+        Integer[] arr = new Integer@Permanent[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer @Permanent [10];in method4");
+        }
+    }
+    /*
+   验证new @Permanent Integer  [10]
+ */
+
+
+    static void method5(Object obj) {
+        Integer[] arr = new @Permanent Integer[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent Integer [10];in method5");
+        }
+    }
+    /*
+    验证new Integer[10];
+  */
+
+
+    static void method6(Object obj) {
+        obj = new Integer[10];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer[10];in method6");
+        }
+    }
+    /*
+    验证new @Permanent ArrayList[]{};
+  */
+
+
+    static void method7(Object obj) {
+        obj = new @Permanent ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent ArrayList[]{};in method7");
+        }
+    }
+    /*
+    验证new ArrayList @Permanent []{};
+  */
+
+
+    static void method8(Object obj) {
+        obj = new ArrayList@Permanent[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList @Permanent []{};in method8");
+        }
+    }
+    /*
+    验证new ArrayList []{};
+  */
+
+
+    static void method9(Object obj) {
+        obj = new ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList []{}; method9");
+        }
+    }
+    static ArrayList<Object> noleak = new ArrayList<>();
+    public void run(
+        ) {
+        Object obj = null;
+        method1(obj);
+        method2(obj);
+        method3(obj);
+        method4(obj);
+        method5(obj);
+        method6(obj);
+        method7(obj);
+        method8(obj);
+        method9(obj);
+        if (checkNum == 9) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkNum);
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+class RCPermanentTest2 extends Thread {
+    public boolean checkout;
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    public static Integer INT = new @Permanent Integer(100);
+    public static Integer INT2 = new Integer(100);
+    static String STRING = new @Permanent String("test");
+    static Long LONG = new @Permanent Long(23534);
+    static Long LONG2 = null;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+    /*
+    验证public final static Integer INT = new @Permanent Integer(100);
+  */
+
+
+    static void method1() {
+        boolean result = checkRC(INT);
+        boolean heapResult = isHeapObject(INT);
+        if ((result == false) && (heapResult == false)) {
+            checkNum++;
+        } else {
+            System.out.println("error in method1");
+            System.out.println("result:" + result + "    isHeap:" + heapResult);
+            System.out.println(String.valueOf(result));
+            System.out.println(String.valueOf(heapResult));
+        }
+    }
+    /*
+    验证public final static Integer INT2 = new Integer(100);
+  */
+
+
+    static void method2() {
+        boolean result = checkRC(INT2);
+        if (result == true && isHeapObject(INT2) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method2");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(INT2));
+        }
+    }
+    /*
+    验证static String STRING = new @Permanent String("test");
+  */
+
+
+    static void method3() {
+        // STRING = new @Permanent (454555);
+        boolean result = checkRC(STRING);
+        if (result == true && isHeapObject(STRING) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method3");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(STRING));
+        }
+    }
+    /*
+    验证static Long LONG2 = new  Long("test4");
+  */
+
+
+    static void method4() {
+        LONG2 = new Long(2222222);
+        boolean result = checkRC(LONG2);
+        if (result == true && isHeapObject(LONG2) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method4");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(LONG2));
+        }
+    }
+    /*
+    验证String obj = new @Permanent Long("test5");
+  */
+
+
+    static void method5() {
+        //String obj = new @Permanent String("test5");
+        Double obj = new @Permanent Double(3333.3);
+        boolean result = checkRC(obj);
+        if (result == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in method5");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证String obj = new String("test6");
+  */
+
+
+    static void method6() {
+        Double obj = new Double(3333.3);
+        boolean result = checkRC(obj);
+        if (result == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method6");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证obj =  new @Permanent Integer("test");
+  */
+
+
+    static volatile Integer obj = null;
+    static void method7() {
+        obj = new @Permanent Integer(123);
+        boolean result = checkRC(obj);
+        if (result == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in  method7");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证obj =  new @Permanent Integer("test");
+  */
+
+
+    static void method8() {
+        obj = new Integer(123);
+        boolean result = checkRC(obj);
+        if (result == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method8");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证static long LONG = new @Permanent long(23534);
+  */
+
+
+    static void method9() {
+        boolean result = checkRC(LONG);
+        if (result == false && isHeapObject(LONG) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in method9");
+            System.out.println("result:" + result + "    isHeap:" + isHeapObject(LONG));
+        }
+    }
+    public void run() {
+        method1();
+        method2();
+        method3();
+        method4();
+        method5();
+        method6();
+        method7();
+        method8();
+        method9();
+        //System.out.println(checkNum);
+        if (checkNum == 9) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkNum);
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+class RCPermanentTest3 extends Thread {
+    public boolean checkout;
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1() {
+        ArrayList list = null;
+        list = new @Permanent ArrayList<>();
+        boolean result1 = checkRC(list);
+        boolean result2 = isHeapObject(list);
+        if (String.valueOf(result1).equals("false") && String.valueOf(result2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method1");
+            System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+    static void method2() {
+        ArrayList list = null;
+        list = new ArrayList<Object>();
+        list.add("test");
+        boolean result1 = checkRC(list);
+        boolean result2 = isHeapObject(list);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in method2");
+            System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+    public void run() {
+        method1();
+        Runtime.getRuntime().gc();
+        method1();
+        method2();
+        Runtime.getRuntime().gc();
+        method2();
+        if (checkNum == 4) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkNum);
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+class RCPermanentTest4 extends Thread {
+    public boolean checkout;
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+    /*
+      验证环场景
+     */
+
+
+    static void method1() {
+        Cycle_A a = new Cycle_A();
+        a.b = null;
+        a.b = new @Permanent Cycle_B();
+        a.b.a = a;
+        int result = a.add() + a.b.add();
+        if (result == 16) {
+            checkNum++;
+        } else {
+            System.out.println("result:" + result);
+        }
+        boolean resultA1 = checkRC(a);
+        boolean resultA2 = isHeapObject(a);
+        boolean resultB1 = checkRC(a.b);
+        boolean resultB2 = isHeapObject(a.b);
+        if (String.valueOf(resultA1).equals("true") && String.valueOf(resultA2).equals("true") && String.valueOf(resultB1).equals("false") && String.valueOf(resultB2).equals("true")) {
+            //if (result1 == false && result2 == true) {
+            checkNum++;
+        } else {
+            System.out.println("error");
+            System.out.println("CycleA_checkRC:" + resultA1);
+            System.out.println("CycleA_isHeap:" + resultA2);
+            System.out.println("CycleB_checkRC:" + resultB1);
+            System.out.println("CycleB_isHeap:" + resultB2);
+            //System.out.println("result1:" + result1 + "       is Heap:" + result2);
+        }
+    }
+    public void run() {
+        method1();
+        if (checkNum == 2) {
+            checkout = true;
+        } else {
+            System.out.println(checkNum);
+            checkout = false;
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+class Cycle_A {
+    Cycle_B b;
+    static int sum;
+    static int a;
+    Cycle_A() {
+        a = 3;
+    }
+    int add() {
+        sum = a + b.b;
+        return sum;
+    }
+}
+class Cycle_B {
+    Cycle_A a;
+    static int sum;
+    static int b;
+    Cycle_B() {
+        b = 5;
+    }
+    int add() {
+        sum = a.a + b;
+        return sum;
+    }
+}
+class RCPermanentTest5 extends Thread {
+    public boolean checkout;
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    static Object owner;
+    static Object referent = new Object();
+    static int checkSum;
+    public void run() {
+        Object obj = null;
+        methodRef1(obj);
+        methodRef2(obj);
+        methodRef3(obj);
+        methodFinal(obj);
+        if (checkSum == 4) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkSum);
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+    }
+    static void methodRef1(Object obj) {
+        obj = new @Permanent WeakReference(referent);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+    static void methodRef2(Object obj) {
+        obj = new @Permanent SoftReference(referent);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+    static void methodRef3(Object obj) {
+        ReferenceQueue rq = new ReferenceQueue();
+        obj = new @Permanent PhantomReference(referent, rq);
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+    static void methodFinal(Object obj) {
+        obj = new @Permanent FinalizableObject();
+        boolean result1 = checkRC(obj);
+        boolean result2 = isHeapObject(obj);
+        if (String.valueOf(result1).equals("true") && String.valueOf(result2).equals("true")) {
+            checkSum++;
+        } else {
+            System.out.println("resultRC:" + result1);
+            System.out.println("result_isHeap:" + result2);
+        }
+    }
+}
+class FinalizableObject {
+    // static int value;
+    public void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/expected.txt b/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4672998a3981406136e3b2b807ae078b4ee7d43c
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/jniTestHelper.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest2_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest2_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest3_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest3_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest4_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest4_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest5_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest5_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+
+    jclass c = env->FindClass("RCPermanentTest");
+    if (!c) return JNI_ERR;
+    // Register your class' native methods.
+    static const JNINativeMethod methods1[]= {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods1, sizeof(methods1)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+
+    c = env->FindClass("RCPermanentTest2");
+    if (!c) return JNI_ERR;
+    // Register your class' native methods.
+    static const JNINativeMethod methods2[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest2_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest2_refCount__Ljava_lang_Object_2)},
+
+    };
+    rc = env->RegisterNatives(c, methods2, sizeof(methods2)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    
+    c = env->FindClass("RCPermanentTest3");
+    if (!c) return JNI_ERR;
+    // Register your class' native methods.
+    static const JNINativeMethod methods3[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest3_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest3_refCount__Ljava_lang_Object_2)},
+
+    };
+    rc = env->RegisterNatives(c, methods3, sizeof(methods3)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    
+    c = env->FindClass("RCPermanentTest4");
+    if (!c) return JNI_ERR;
+    // Register your class' native methods.
+    static const JNINativeMethod methods4[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest4_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest4_refCount__Ljava_lang_Object_2)},
+
+    };
+    rc = env->RegisterNatives(c, methods4, sizeof(methods4)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    
+    c = env->FindClass("RCPermanentTest5");
+    if (!c) return JNI_ERR;
+    // Register your class' native methods.
+    static const JNINativeMethod methods5[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest5_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest5_refCount__Ljava_lang_Object_2)},
+
+    };
+    rc = env->RegisterNatives(c, methods5, sizeof(methods5)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/test.cfg b/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d2f8b905d0176ecb14730aa10457798fddda25e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0416-rc-Annotation-RCPermanentThread/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentThread,NATIVE_SRC=jniTestHelper)
+run(RCPermanentThread)
diff --git a/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/RCPermanentTest6.java b/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/RCPermanentTest6.java
new file mode 100755
index 0000000000000000000000000000000000000000..5fc060ac3078f81cba66de3002a1a2e6bcb54ea4
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/RCPermanentTest6.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import com.huawei.ark.annotation.*;
+import java.lang.ref.WeakReference;
+public class RCPermanentTest6 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+    public static void main(String[] args) {
+        Object obj = null;
+        method1(obj);
+        new Test_A().test();
+        if (checkNum == 1) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+class Test_B {
+    @Unowned
+    Test_A aa;
+    // add volatile will crash
+    // static Test_A a1;
+    protected void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
+class Test_A {
+    Test_B bb;
+    public void test() {
+        setReferences();
+        System.runFinalization();
+    }
+    private void setReferences() {
+        Test_A ta = new Test_A();
+        ta.bb = new Test_B();
+        //ta.bb.aa = ta;
+        try {
+            Field m = Test_B.class.getDeclaredField("aa");
+            m.set(ta.bb, ta);
+            Test_A a_temp = (Test_A) m.get(ta.bb);
+            if (a_temp != ta) {
+                System.out.println("error");
+            }
+            //Field m1 = Test_B.class.getDeclaredField("a1");
+            //m1.set(null, ta);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/expected.txt b/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6ec111985d15aad3d089c85dc0ed30e2058b9e93
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/expected.txt
@@ -0,0 +1,2 @@
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a4ca8829ee61ccaeea1372b2d781a5e5814c1c66
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest6_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest6_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest6");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest6_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest6_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/test.cfg b/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aaf07c777393c4b4184d885a584c8f67953eaeb0
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0423-rc-Annotation-RCPermanentTest6/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentTest6,NATIVE_SRC=jniTestHelper)
+run(RCPermanentTest6)
diff --git a/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/RCPermanentThread2.java b/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/RCPermanentThread2.java
new file mode 100755
index 0000000000000000000000000000000000000000..90dca48441c16998782e4c3a8fcc17292a303560
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/RCPermanentThread2.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import com.huawei.ark.annotation.*;
+public class RCPermanentThread2 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+        rc_testcase_main_wrapper2();
+    }
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCPermanentTest rcPermanentTest = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest2 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest3 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest4 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest5 = new RCPermanentTest();
+        rcPermanentTest.start();
+        rcPermanentTest.join();
+        rcPermanentTest2.start();
+        rcPermanentTest2.join();
+        rcPermanentTest3.start();
+        rcPermanentTest3.join();
+        rcPermanentTest4.start();
+        rcPermanentTest4.join();
+        rcPermanentTest5.start();
+        rcPermanentTest5.join();
+        // rcPermanentTest.join();
+        // rcPermanentTest2.join();
+        // rcPermanentTest3.join();
+        // rcPermanentTest4.join();
+        // rcPermanentTest5.join();
+        if (rcPermanentTest.check() && rcPermanentTest2.check() && rcPermanentTest3.check() && rcPermanentTest4.check() && rcPermanentTest5.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + rcPermanentTest.check());
+            System.out.println("rcPermanentTest2.check() :" + rcPermanentTest2.check());
+            System.out.println("rcPermanentTest3.check() :" + rcPermanentTest3.check());
+            System.out.println("rcPermanentTest4.check() :" + rcPermanentTest4.check());
+            System.out.println("rcPermanentTest5.check() :" + rcPermanentTest5.check());
+        }
+    }
+    private static void rc_testcase_main_wrapper2() throws InterruptedException {
+        RCUnownedTest rcUnownedTest = new RCUnownedTest();
+        RCUnownedTest rcUnownedTest2 = new RCUnownedTest();
+        RCUnownedTest rcUnownedTest3 = new RCUnownedTest();
+        RCUnownedTest rcUnownedTest4 = new RCUnownedTest();
+        RCUnownedTest rcUnownedTest5 = new RCUnownedTest();
+        rcUnownedTest.start();
+        rcUnownedTest2.start();
+        rcUnownedTest3.start();
+        rcUnownedTest4.start();
+        rcUnownedTest5.start();
+        rcUnownedTest.join();
+        rcUnownedTest2.join();
+        rcUnownedTest3.join();
+        rcUnownedTest4.join();
+        rcUnownedTest5.join();
+    }
+}
+class RCPermanentTest extends Thread {
+    public boolean checkout;
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+    /*
+    验证new int [8]
+   */
+
+
+    static void method2(Object obj) {
+        obj = new int[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int [8];in method2");
+        }
+    }
+    /*
+    验证new @Permanent int[8]
+  */
+
+
+    static void method3(Object obj) {
+        obj = new @Permanent int[1];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent int[8];in method3");
+        }
+    }
+    /*
+    验证new Integer @Permanent [10]
+  */
+
+
+    static void method4(Object obj) {
+        Integer[] arr = new Integer@Permanent[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer @Permanent [10];in method4");
+        }
+    }
+    /*
+   验证new @Permanent Integer  [10]
+ */
+
+
+    static void method5(Object obj) {
+        Integer[] arr = new @Permanent Integer[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent Integer [10];in method5");
+        }
+    }
+    /*
+    验证new Integer[10];
+  */
+
+
+    static void method6(Object obj) {
+        obj = new Integer[10];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer[10];in method6");
+            System.out.println("checkRC(obj):" + result1 + "        isHeapObject(obj):" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证new @Permanent ArrayList[]{};
+  */
+
+
+    static void method7(Object obj) {
+        obj = new @Permanent ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent ArrayList[]{};in method7");
+        }
+    }
+    /*
+    验证new ArrayList @Permanent []{};
+  */
+
+
+    static void method8(Object obj) {
+        obj = new ArrayList@Permanent[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList @Permanent []{};in method8");
+        }
+    }
+    /*
+    验证new ArrayList []{};
+  */
+
+
+    static void method9(Object obj) {
+        obj = new ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList []{}; method9");
+        }
+    }
+    static ArrayList<Object> noleak = new ArrayList<>();
+    public void run(
+    ) {
+        checkNum = 0;
+        Object obj = null;
+        method1(obj);
+        method2(obj);
+        method3(obj);
+        method4(obj);
+        method5(obj);
+        method6(obj);
+        method7(obj);
+        method8(obj);
+        method9(obj);
+        // System.out.println(checkNum);
+        if (checkNum == 9) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println("checkout== false,checkNum:"+checkNum);
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+class RCUnownedTest extends Thread {
+    public void run() {
+        new Test_A().test();
+    }
+}
+class Test_A {
+    Test_B bb;
+    public void test() {
+        setReferences();
+        System.runFinalization();
+    }
+    private void setReferences() {
+        Test_A ta = new Test_A();
+        ta.bb = new Test_B();
+        //ta.bb.aa = ta;
+        try {
+            Field m = Test_B.class.getDeclaredField("aa");
+            m.set(ta.bb, ta);
+            Test_A a_temp = (Test_A) m.get(ta.bb);
+            if (a_temp != ta) {
+                System.out.println("error");
+            }
+            //Field m1 = Test_B.class.getDeclaredField("a1");
+            //m1.set(null, ta);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+}
+class Test_B {
+    @Unowned
+    Test_A aa;
+    // add volatile will crash
+    // static Test_A a1;
+    protected void finalize() {
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/expected.txt b/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3f44f268b8913e6a81e85022f8a04b1cac53c71d
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/expected.txt
@@ -0,0 +1,6 @@
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e8f5a082bd2f6cd40abefbd061f93efe9c9b3695
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/test.cfg b/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bfbdfabe63ff5e2996e91da650e826106387ef6d
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0424-rc-Annotation-RCPermanentThread2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentThread2,NATIVE_SRC=jniTestHelper)
+run(RCPermanentThread2)
diff --git a/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/RCPermanentTest7.java b/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/RCPermanentTest7.java
new file mode 100755
index 0000000000000000000000000000000000000000..4079febc1c4a32228696fe2379a1b83df6824830
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/RCPermanentTest7.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.*;
+public class RCPermanentTest7 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+    public static void main(String[] args) {
+        Object obj = null;
+        method1(obj);
+        new Test_A().test();
+        if (checkNum == 1) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
+class Test_A {
+    @Weak
+    Test_B bb;
+    Test_B bb2;
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");
+        }
+        bb2.run();
+    }
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+    }
+}
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/expected.txt b/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..309f6d50570536aa5ec2bd6eba765f9c8fa03b0f
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/expected.txt
@@ -0,0 +1,3 @@
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0565849e9a09770d9ac3f093dfe1a2d3fe0da97
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/jniTestHelper.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest7_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest7_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest7");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest7_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest7_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/test.cfg b/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ab243bf6c7b90b54a4ccd4054a35809ea0adc9a9
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0425-rc-Annotation-RCPermanentTest7/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentTest7,NATIVE_SRC=jniTestHelper)
+run(RCPermanentTest7)
diff --git a/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/RCPermanentThread3.java b/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/RCPermanentThread3.java
new file mode 100755
index 0000000000000000000000000000000000000000..8adff38c439f018792d0127f891fc97401786e78
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/RCPermanentThread3.java
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import com.huawei.ark.annotation.*;
+public class RCPermanentThread3 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+        rc_testcase_main_wrapper2();
+    }
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCPermanentTest rcPermanentTest = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest2 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest3 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest4 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest5 = new RCPermanentTest();
+        rcPermanentTest.start();
+        rcPermanentTest.join();
+        rcPermanentTest2.start();
+        rcPermanentTest2.join();
+        rcPermanentTest3.start();
+        rcPermanentTest3.join();
+        rcPermanentTest4.start();
+        rcPermanentTest4.join();
+        rcPermanentTest5.start();
+        rcPermanentTest5.join();
+        // rcPermanentTest.join();
+        // rcPermanentTest2.join();
+        // rcPermanentTest3.join();
+        // rcPermanentTest4.join();
+        // rcPermanentTest5.join();
+        if (rcPermanentTest.check() && rcPermanentTest2.check() && rcPermanentTest3.check() && rcPermanentTest4.check() && rcPermanentTest5.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + rcPermanentTest.check());
+            System.out.println("rcPermanentTest2.check() :" + rcPermanentTest2.check());
+            System.out.println("rcPermanentTest3.check() :" + rcPermanentTest3.check());
+            System.out.println("rcPermanentTest4.check() :" + rcPermanentTest4.check());
+            System.out.println("rcPermanentTest5.check() :" + rcPermanentTest5.check());
+        }
+    }
+    private static void rc_testcase_main_wrapper2() throws InterruptedException {
+        RCWeakTest rcWeakTest = new RCWeakTest();
+        RCWeakTest rcWeakTest2 = new RCWeakTest();
+        RCWeakTest rcWeakTest3 = new RCWeakTest();
+        RCWeakTest rcWeakTest4 = new RCWeakTest();
+        RCWeakTest rcWeakTest5 = new RCWeakTest();
+        rcWeakTest.start();
+        rcWeakTest2.start();
+        rcWeakTest3.start();
+        rcWeakTest4.start();
+        rcWeakTest5.start();
+        rcWeakTest.join();
+        rcWeakTest2.join();
+        rcWeakTest3.join();
+        rcWeakTest4.join();
+        rcWeakTest5.join();
+    }
+}
+class RCPermanentTest extends Thread {
+    public boolean checkout;
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1(Object obj) {
+        obj = new int@Permanent[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int @Permanent [8];in method1");
+        }
+    }
+    /*
+    验证new int [8]
+   */
+
+
+    static void method2(Object obj) {
+        obj = new int[8];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new int [8];in method2");
+        }
+    }
+    /*
+    验证new @Permanent int[8]
+  */
+
+
+    static void method3(Object obj) {
+        obj = new @Permanent int[1];
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent int[8];in method3");
+        }
+    }
+    /*
+    验证new Integer @Permanent [10]
+  */
+
+
+    static void method4(Object obj) {
+        Integer[] arr = new Integer@Permanent[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer @Permanent [10];in method4");
+        }
+    }
+    /*
+   验证new @Permanent Integer  [10]
+ */
+
+
+    static void method5(Object obj) {
+        Integer[] arr = new @Permanent Integer[10];
+        boolean result1 = checkRC(obj);
+        noleak.add(arr); // let leak check happy
+        arr[0] = new Integer(10000);
+        arr[9] = new Integer(20000);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent Integer [10];in method5");
+        }
+    }
+    /*
+    验证new Integer[10];
+  */
+
+
+    static void method6(Object obj) {
+        obj = new Integer[10];
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new Integer[10];in method6");
+            System.out.println("checkRC(obj):" + result1 + "        isHeapObject(obj):" + isHeapObject(obj));
+        }
+    }
+    /*
+    验证new @Permanent ArrayList[]{};
+  */
+
+
+    static void method7(Object obj) {
+        obj = new @Permanent ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new @Permanent ArrayList[]{};in method7");
+        }
+    }
+    /*
+    验证new ArrayList @Permanent []{};
+  */
+
+
+    static void method8(Object obj) {
+        obj = new ArrayList@Permanent[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == false && isHeapObject(obj) == false) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList @Permanent []{};in method8");
+        }
+    }
+    /*
+    验证new ArrayList []{};
+  */
+
+
+    static void method9(Object obj) {
+        obj = new ArrayList[]{};
+        boolean result1 = checkRC(obj);
+        if (result1 == true && isHeapObject(obj) == true) {
+            checkNum++;
+        } else {
+            System.out.println("error in new ArrayList []{}; method9");
+        }
+    }
+    static ArrayList<Object> noleak = new ArrayList<>();
+    public void run(
+    ) {
+        checkNum = 0;
+        Object obj = null;
+        method1(obj);
+        method2(obj);
+        method3(obj);
+        method4(obj);
+        method5(obj);
+        method6(obj);
+        method7(obj);
+        method8(obj);
+        method9(obj);
+        // System.out.println(checkNum);
+        if (checkNum == 9) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println("checkout== false,checkNum:"+checkNum);
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+class RCWeakTest extends Thread {
+    public void run() {
+        new Test_A().test();
+    }
+}
+class Test_A {
+    @Weak
+    Test_B bb;
+    Test_B bb2;
+    public void test() {
+        foo();
+        try {
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        try {
+            bb.run();
+        } catch (NullPointerException e) {
+            System.out.println("ExpectResult");
+        }
+        bb2.run();
+    }
+    private void foo() {
+        bb = new Test_B();
+        bb2 = new Test_B();
+    }
+}
+class Test_B {
+    public void run() {
+        System.out.println("ExpectResult");
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/expected.txt b/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..7751055d0f5d0bff59328f021666ba2ce929ba46
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/expected.txt
@@ -0,0 +1,11 @@
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e8f5a082bd2f6cd40abefbd061f93efe9c9b3695
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/test.cfg b/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3f781db4df7b612de874ab10f9939cda8e654cc9
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0426-rc-Annotation-RCPermanentThread3/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentThread3,NATIVE_SRC=jniTestHelper)
+run(RCPermanentThread3)
diff --git a/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/RCPermanentTest8.java b/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/RCPermanentTest8.java
new file mode 100755
index 0000000000000000000000000000000000000000..f4806d6003152fbd41b42882d88dfa3ddcd5afc2
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/RCPermanentTest8.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import com.huawei.ark.annotation.Permanent;
+import java.lang.ref.WeakReference;
+public class RCPermanentTest8 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1(Object obj) {
+        try {
+            obj = new int@Permanent[8];
+            boolean result1 = checkRC(obj);
+            if (result1 == false && isHeapObject(obj) == false) {
+                checkNum++;
+            } else {
+                System.out.println("error in new int @Permanent [8];in method1");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    public static void main(String[] args) {
+        Object obj = null;
+        method1(obj);
+        if (checkNum == 1) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/expected.txt b/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1b7000fce227a25e7d1e7ac50e4a61bbb7dd028a
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest8_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest8_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest8");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest8_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest8_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/test.cfg b/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c6df6d04fad9af145464e0839ee8c636662ce4d2
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0429-rc-Annotation-RCPermanentTest8/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentTest8,NATIVE_SRC=jniTestHelper)
+run(RCPermanentTest8)
diff --git a/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/RCPermanentThread4.java b/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/RCPermanentThread4.java
new file mode 100755
index 0000000000000000000000000000000000000000..ab0247a5e03cdfa242dc8b0cdccad631e7d6b6d8
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/RCPermanentThread4.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import com.huawei.ark.annotation.Permanent;
+public class RCPermanentThread4 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static void main(String[] args) throws InterruptedException {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() throws InterruptedException {
+        RCPermanentTest rcPermanentTest = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest2 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest3 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest4 = new RCPermanentTest();
+        RCPermanentTest rcPermanentTest5 = new RCPermanentTest();
+        rcPermanentTest.start();
+        rcPermanentTest.join();
+        rcPermanentTest2.start();
+        rcPermanentTest2.join();
+        rcPermanentTest3.start();
+        rcPermanentTest3.join();
+        rcPermanentTest4.start();
+        rcPermanentTest4.join();
+        rcPermanentTest5.start();
+        rcPermanentTest5.join();
+        if (rcPermanentTest.check() && rcPermanentTest2.check() && rcPermanentTest3.check() && rcPermanentTest4.check() && rcPermanentTest5.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + rcPermanentTest.check());
+            System.out.println("rcPermanentTest2.check() :" + rcPermanentTest2.check());
+            System.out.println("rcPermanentTest3.check() :" + rcPermanentTest3.check());
+            System.out.println("rcPermanentTest4.check() :" + rcPermanentTest4.check());
+            System.out.println("rcPermanentTest5.check() :" + rcPermanentTest5.check());
+        }
+    }
+    private static void rc_testcase_main_wrapper2() throws InterruptedException {
+        SyncTest syncTest = new SyncTest();
+        SyncTest syncTest1 = new SyncTest();
+        SyncTest syncTest2 = new SyncTest();
+        SyncTest syncTest3 = new SyncTest();
+        SyncTest syncTest4 = new SyncTest();
+        syncTest.start();
+        syncTest.join();
+        syncTest1.start();
+        syncTest1.join();
+        syncTest2.start();
+        syncTest2.join();
+        syncTest3.start();
+        syncTest3.join();
+        syncTest4.start();
+        syncTest4.join();
+        if (syncTest.check() && syncTest1.check() && syncTest2.check() && syncTest3.check() && syncTest4.check()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("rcPermanentTest.check() :" + syncTest.check());
+            System.out.println("rcPermanentTest2.check() :" + syncTest1.check());
+            System.out.println("rcPermanentTest3.check() :" + syncTest2.check());
+            System.out.println("rcPermanentTest4.check() :" + syncTest3.check());
+            System.out.println("rcPermanentTest5.check() :" + syncTest4.check());
+        }
+    }
+}
+class RCPermanentTest extends Thread {
+    public boolean checkout;
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证new int @Permanent [8]
+   */
+
+
+    static void method1(Object obj) {
+        try {
+            obj = new int@Permanent[8];
+            boolean result1 = checkRC(obj);
+            if (result1 == false && isHeapObject(obj) == false) {
+                checkNum++;
+            } else {
+                System.out.println("error in new int @Permanent [8];in method1");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    public void run() {
+        checkNum = 0;
+        Object obj = null;
+        method1(obj);
+        if (checkNum == 1) {
+            checkout = true;
+        } else {
+            checkout = false;
+            System.out.println(checkNum);
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
+class SyncTest extends Thread {
+    public boolean checkout;
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    public void run() {
+        synchronized (this) {
+            Object obj = null;
+            obj = new int@Permanent[8];
+            boolean result1 = checkRC(obj);
+            if (result1 == false && isHeapObject(obj) == false) {
+                checkout = true;
+            } else {
+                checkout = false;
+                System.out.println("error in new int @Permanent [8];in method1");
+            }
+        }
+    }
+    public boolean check() {
+        return checkout;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/expected.txt b/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e82688edab0b68e12e69b04e42056b0e54be9b5d
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/jniTestHelper.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentTest_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentTest");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentTest_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentTest_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/test.cfg b/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6fe23b607066c83d3e0dd634ed23e34e11ca58ba
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0430-rc-Annotation-RCPermanentThread4/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentThread4,NATIVE_SRC=jniTestHelper)
+run(RCPermanentThread4)
diff --git a/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/RCPermanentLimit2.java b/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/RCPermanentLimit2.java
new file mode 100755
index 0000000000000000000000000000000000000000..7c941f3ffe1c908566a501e9c93401f7d1e44d0a
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/RCPermanentLimit2.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import com.huawei.ark.annotation.Permanent;
+public class RCPermanentLimit2 {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证加了注解Permanent，申请的内存为64K+1byte的情况
+   */
+
+
+    static void method1(Object obj) {
+        try {
+            obj = new @Permanent ArrayList<Byte>();
+            for (int i = 0; i < 64 * 1024+1; i++) {
+                byte tmp = 2;
+                ((ArrayList) obj).add(tmp);
+            }
+//            int check_size = ((ArrayList) obj).size();
+//            System.out.println(check_size);
+            boolean result1 = checkRC(obj);
+            boolean result2 =isHeapObject(obj);
+            if (result1 == false && result2 == true) {
+                checkNum++;
+            } else {
+                System.out.println("result1:" + result1);
+                System.out.println("isHeapObject:" + result2);
+                System.out.println("error in new int test1;in method1");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    /*
+    验证加了注解Permanent，申请的内存为128K的情况
+   */
+
+
+    static void method2(Object obj) {
+        try {
+            obj = new @Permanent ArrayList<Byte>();
+            for (int i = 0; i < 128 * 1024; i++) {
+                byte tmp = 2;
+                ((ArrayList) obj).add(tmp);
+            }
+//            int check_size = ((ArrayList) obj).size();
+//            System.out.println(check_size);
+            boolean result1 = checkRC(obj);
+            boolean result2 =isHeapObject(obj);
+            if (result1 == false && result2 == true) {
+                checkNum++;
+            } else {
+                System.out.println("result1:" + result1);
+                System.out.println("isHeapObject:" + result2);
+                System.out.println("error in new int test1;in method1");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    public static void main(String[] args) {
+        Object obj = null;
+        method1(obj);
+        Runtime.getRuntime().gc();
+        method1(obj);
+        method2(obj);
+        Runtime.getRuntime().gc();
+        method2(obj);
+        if (checkNum == 4) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/expected.txt b/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e5e8feb95ecab1dfe58e33f57c312c91ef1194bb
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/jniTestHelper.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentLimit2_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentLimit2_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentLimit2");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object;)Z", reinterpret_cast<void*>(Java_RCPermanentLimit2_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object;)I", reinterpret_cast<void*>(Java_RCPermanentLimit2_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/test.cfg b/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..dfb7da3db6e69d4d98524acb040fe61b7828b542
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/RC0448-rc-Annotation-RCPermanentLimit2/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentLimit2,NATIVE_SRC=jniTestHelper)
+run(RCPermanentLimit2)
diff --git a/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/RCPermanentLimit.java b/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/RCPermanentLimit.java
new file mode 100755
index 0000000000000000000000000000000000000000..ad9cda358baf7c517b3fd3d78362f9f0e15e509f
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/RCPermanentLimit.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import com.huawei.ark.annotation.Permanent;
+public class RCPermanentLimit {
+    static {
+        System.loadLibrary("jniTestHelper");
+    }
+    public static native boolean isHeapObject(Object obj);
+    public static native int refCount(Object obj);
+    public static int checkNum = 0;
+    static Object owner;
+    static boolean checkRC(Object obj) {
+        int rc1 = refCount(obj);
+        owner = obj;
+        int rc2 = refCount(obj);
+        owner = null;
+        int rc3 = refCount(obj);
+        if (rc1 != rc3) {
+            throw new RuntimeException("rc incorrect!");
+        }
+        if (rc1 == rc2 && rc2 == rc3) {
+            //如果相等，说明annotation生效，没有经过RC处理
+            return false;
+        } else {
+            return true;
+        }
+        //System.out.printf("rc:%-5s heap:%-5s %s%n", !skipRC, isHeapObject(obj), title);
+    }
+    /*
+    验证加了注解Permanent，申请的内存为64K的情况
+   */
+
+
+    static void method1(Object obj) {
+        try {
+            obj = new @Permanent ArrayList<Byte>();
+            for (int i = 0; i < 64 * 1024; i++) {
+                byte tmp = 2;
+                ((ArrayList) obj).add(tmp);
+            }
+//            int check_size = ((ArrayList) obj).size();
+//            System.out.println(check_size);
+            boolean result1 = checkRC(obj);
+            boolean result2 =isHeapObject(obj);
+            if (result1 == false && result2 == true) {
+                checkNum++;
+            } else {
+                System.out.println("result1:" + result1);
+                System.out.println("isHeapObject:" + result2);
+                System.out.println("error in new int test1;in method1");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    public static void main(String[] args) {
+        Object obj = null;
+        method1(obj);
+        Runtime.getRuntime().gc();
+        method1(obj);
+        if (checkNum == 2) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("error");
+            System.out.println("checkNum:" + checkNum);
+        }
+    }
+}
diff --git a/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/expected.txt b/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/jniTestHelper.cpp b/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/jniTestHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ed67d10abfc7c800e0b1dc740043314ce93e741
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/jniTestHelper.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdio.h>
+#include <nativehelper/jni.h>
+
+extern "C" {
+
+extern bool MRT_CheckHeapObj(void* ptr);
+extern uint32_t MRT_RefCount(void* ptr);
+
+JNIEXPORT jboolean JNICALL Java_RCPermanentLimit_isHeapObject__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_CheckHeapObj((void*)obj);
+}
+
+JNIEXPORT jint JNICALL Java_RCPermanentLimit_refCount__Ljava_lang_Object_2
+(JNIEnv *env, jclass cls, jobject obj) {
+  return MRT_RefCount((void*)obj);
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    // Find your class. JNI_OnLoad is called from the correct class loader context for this to work.
+    jclass c = env->FindClass("RCPermanentLimit");
+    if (!c) return JNI_ERR;
+
+    // Register your class' native methods.
+    static const JNINativeMethod methods[] = {
+        {"isHeapObject", "(Ljava/lang/Object)Z", reinterpret_cast<void*>(Java_RCPermanentLimit_isHeapObject__Ljava_lang_Object_2)},
+        {"refCount", "(Ljava/lang/Object)I", reinterpret_cast<void*>(Java_RCPermanentLimit_refCount__Ljava_lang_Object_2)},
+
+    };
+    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
+    if (rc != JNI_OK) return rc;
+    return JNI_VERSION_1_6;
+}
+
+} /* extern "C" */
diff --git a/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/test.cfg b/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..bc1f034cf53b60a548d99785f4394bde9fefbecb
--- /dev/null
+++ b/testsuite/java_test/rc_test/native_test/issue-RC0447-rc-Annotation-RCPermanentLimit/test.cfg
@@ -0,0 +1,2 @@
+compile(RCPermanentLimit,NATIVE_SRC=jniTestHelper,O0:O2)
+run(RCPermanentLimit)
diff --git a/testsuite/java_test/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/ReflectingGetConstructor1.java b/testsuite/java_test/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/ReflectingGetConstructor1.java
new file mode 100755
index 0000000000000000000000000000000000000000..584205402f608c08ac7866c12426aba108d9266c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/ReflectingGetConstructor1.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetConstructor1 {
+    public GetConstructor1() {
+    }
+    public GetConstructor1(String name) {
+    }
+    public GetConstructor1(String name, int number) {
+    }
+    GetConstructor1(int number) {
+    }
+}
+public class ReflectingGetConstructor1 {
+    public static void main(String[] args) {
+        try {
+            Class getConstructor1 = Class.forName("GetConstructor1");
+            Constructor constructor1 = getConstructor1.getConstructor(String.class);
+            Constructor constructor2 = getConstructor1.getConstructor();
+            Constructor constructor3 = getConstructor1.getConstructor(String.class, int.class);
+            if (constructor1.toString().equals("public GetConstructor1(java.lang.String)")
+                    && constructor2.toString().equals("public GetConstructor1()")
+                    && constructor3.toString().equals("public GetConstructor1(java.lang.String,int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/expected.txt b/testsuite/java_test/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/test.cfg b/testsuite/java_test/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..855189b008ae06d7d2417f6b38a0b4d0422c101b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0001-rt-reflection-ReflectingetConstructor1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetConstructor1)
+run(ReflectingGetConstructor1)
diff --git a/testsuite/java_test/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/ReflectingGetConstructor2.java b/testsuite/java_test/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/ReflectingGetConstructor2.java
new file mode 100755
index 0000000000000000000000000000000000000000..5d92760e8f33c76188b6ea2611c3eab98fdf6652
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/ReflectingGetConstructor2.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetConstructor2 {
+    public GetConstructor2() {
+    }
+    public GetConstructor2(String name) {
+    }
+    public GetConstructor2(String name, int number) {
+    }
+    GetConstructor2(int number) {
+    }
+}
+public class ReflectingGetConstructor2 {
+    public static void main(String[] args) {
+        try {
+            Class getConstructor21 = Class.forName("GetConstructor2");
+            Constructor constructor1 = getConstructor21.getConstructor(int.class);
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e) {
+            try {
+                Class getConstructor22 = Class.forName("GetConstructor2");
+                Constructor constructor2 = getConstructor22.getConstructor(String.class, char.class, int.class);
+                System.out.println(2);
+            } catch (ClassNotFoundException ee) {
+                System.err.println(ee);
+                System.out.println(2);
+            } catch (NoSuchMethodException ee) {
+                System.out.println(0);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/expected.txt b/testsuite/java_test/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/test.cfg b/testsuite/java_test/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..574f8841605dbe0f84510694b9e1c18937ee3e9a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0002-rt-reflection-ReflectingetConstructor2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetConstructor2)
+run(ReflectingGetConstructor2)
diff --git a/testsuite/java_test/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/ReflectingGetConstructors.java b/testsuite/java_test/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/ReflectingGetConstructors.java
new file mode 100755
index 0000000000000000000000000000000000000000..da45f0a9f47f92939291956e15b82e745835dce4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/ReflectingGetConstructors.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetConstructors {
+    public GetConstructors() {
+    }
+    public GetConstructors(String name) {
+    }
+    public GetConstructors(String name, int number) {
+    }
+    GetConstructors(int number) {
+    }
+    GetConstructors(double id) {
+    }
+    public GetConstructors(double id, String name) {
+    }
+}
+class GetConstructors_a extends GetConstructors {
+    public GetConstructors_a() {
+    }
+    public GetConstructors_a(String name) {
+    }
+    public GetConstructors_a(String name, int number) {
+    }
+    GetConstructors_a(int number) {
+    }
+}
+public class ReflectingGetConstructors {
+    public static void main(String[] args) {
+        try {
+            Class getConstructors_a = Class.forName("GetConstructors_a");
+            Constructor<?>[] constructors = getConstructors_a.getConstructors();
+            if (constructors.length == 3) {
+                for (int i = 0; i < constructors.length; i++) {
+                    if (constructors[i].toString().indexOf("GetConstructors_a(int)") != -1) {
+                        System.out.println(2);
+                    }
+                }
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (ArrayIndexOutOfBoundsException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/expected.txt b/testsuite/java_test/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/test.cfg b/testsuite/java_test/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5b876ecb1d0e8dfe9983e5238e9ad52f1c5c6932
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0003-rt-reflection-ReflectingetConstructors/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetConstructors)
+run(ReflectingGetConstructors)
diff --git a/testsuite/java_test/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java b/testsuite/java_test/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java
new file mode 100755
index 0000000000000000000000000000000000000000..9021043e5fdc3010d13c895f64f83ff4fbec5ec4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/ReflectingGetDeclaredConstructor1.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetDeclaredConstructor1 {
+    public GetDeclaredConstructor1() {
+    }
+    private GetDeclaredConstructor1(String name) {
+    }
+    protected GetDeclaredConstructor1(String name, int number) {
+    }
+    GetDeclaredConstructor1(int number) {
+    }
+}
+public class ReflectingGetDeclaredConstructor1 {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructor1 = Class.forName("GetDeclaredConstructor1");
+            Constructor constructor1 = getDeclaredConstructor1.getDeclaredConstructor(String.class);
+            Constructor constructor2 = getDeclaredConstructor1.getDeclaredConstructor();
+            Constructor constructor3 = getDeclaredConstructor1.getDeclaredConstructor(String.class, int.class);
+            Constructor constructor4 = getDeclaredConstructor1.getDeclaredConstructor(int.class);
+            if (constructor1.toString().equals("private GetDeclaredConstructor1(java.lang.String)")
+                    && constructor2.toString().equals("public GetDeclaredConstructor1()")
+                    && constructor3.toString().equals("protected GetDeclaredConstructor1(java.lang.String,int)")
+                    && constructor4.toString().equals("GetDeclaredConstructor1(int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+        }
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/expected.txt b/testsuite/java_test/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/test.cfg b/testsuite/java_test/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9c2f15bac2380dffe1d4a3601c7e7e818c62151f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0004-rt-reflection-ReflectingetDeclaredConstructor1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetDeclaredConstructor1)
+run(ReflectingGetDeclaredConstructor1)
diff --git a/testsuite/java_test/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java b/testsuite/java_test/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java
new file mode 100755
index 0000000000000000000000000000000000000000..62660183305ddb2bbe21febb9584373f36158d0c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/ReflectingGetDeclaredConstructor2.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetDeclaredConstructor2 {
+    public GetDeclaredConstructor2() {
+    }
+    private GetDeclaredConstructor2(String name) {
+    }
+    protected GetDeclaredConstructor2(String name, int number) {
+    }
+    GetDeclaredConstructor2(int number) {
+    }
+}
+public class ReflectingGetDeclaredConstructor2 {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructor2 = Class.forName("GetDeclaredConstructor2");
+            Constructor constructor = getDeclaredConstructor2.getDeclaredConstructor(String.class, char.class, int.class);
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/expected.txt b/testsuite/java_test/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/test.cfg b/testsuite/java_test/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e4e52a3b940c68cedc2ec6bd71020cc4abe4936a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0005-rt-reflection-ReflectingetDeclaredConstructor2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetDeclaredConstructor2)
+run(ReflectingGetDeclaredConstructor2)
diff --git a/testsuite/java_test/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java b/testsuite/java_test/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java
new file mode 100755
index 0000000000000000000000000000000000000000..d5a7cb5b52352e7255f9b2732fad955e2e517063
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/ReflectingGetDeclaredConstructors.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class GetDeclaredConstructors {
+    public GetDeclaredConstructors() {
+    }
+    private GetDeclaredConstructors(String name) {
+    }
+    protected GetDeclaredConstructors(String name, int number) {
+    }
+    GetDeclaredConstructors(int number) {
+    }
+}
+public class ReflectingGetDeclaredConstructors {
+    public static void main(String[] args) {
+        try {
+            Class getDeclaredConstructors = Class.forName("GetDeclaredConstructors");
+            Constructor<?>[] constructors = getDeclaredConstructors.getDeclaredConstructors();
+            if (constructors.length == 4) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/expected.txt b/testsuite/java_test/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/test.cfg b/testsuite/java_test/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..20069c05220bc05823f069b167ba1b37421fba9f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0006-rt-reflection-ReflectingetDeclaredConstructors/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectingGetDeclaredConstructors)
+run(ReflectingGetDeclaredConstructors)
diff --git a/testsuite/java_test/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/ReflectionAsSubclass1.java b/testsuite/java_test/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/ReflectionAsSubclass1.java
new file mode 100755
index 0000000000000000000000000000000000000000..9565c7e6b33f4bac1f79546b8e55c3eca6cfa30d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/ReflectionAsSubclass1.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+interface A {
+}
+class A_1 implements A {
+}
+class A_2 extends A_1 {
+}
+public class ReflectionAsSubclass1 {
+    public static void main(String[] args) {
+        try {
+            Class a_2 = Class.forName("A_1").asSubclass(A.class);
+            Class a_1 = Class.forName("A_2").asSubclass(A.class);
+            if (a_2.newInstance() instanceof A) {
+                if (a_1.newInstance() instanceof A) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(e1);
+        } catch (InstantiationException e2) {
+            System.out.println(e2);
+        } catch (IllegalAccessException e3) {
+            System.out.println(e3);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/expected.txt b/testsuite/java_test/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/test.cfg b/testsuite/java_test/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..89eb8c0438a589745addf4cbe184527ced5177dc
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0007-rt-reflection-ReflectionasSubclass1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionAsSubclass1)
+run(ReflectionAsSubclass1)
diff --git a/testsuite/java_test/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/ReflectionAsSubclass2.java b/testsuite/java_test/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/ReflectionAsSubclass2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a54c3774b3b516fcda86bc77b41b5f382e45e269
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/ReflectionAsSubclass2.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class B {
+}
+class B_1 extends B {
+}
+public class ReflectionAsSubclass2 {
+    public static void main(String[] args) {
+        try {
+            Class.forName("B_1").asSubclass(B.class);
+        } catch (ClassCastException e) {
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/expected.txt b/testsuite/java_test/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/test.cfg b/testsuite/java_test/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e897c60b5ff3b8e880f45791c710766a5cf5c735
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0008-rt-reflection-ReflectionasSubclass2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionAsSubclass2)
+run(ReflectionAsSubclass2)
diff --git a/testsuite/java_test/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/ReflectionAsSubclass3.java b/testsuite/java_test/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/ReflectionAsSubclass3.java
new file mode 100755
index 0000000000000000000000000000000000000000..4338a70bc5b6bcb154bc37c8b73d02e3d64ab314
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/ReflectionAsSubclass3.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+interface C {
+}
+class C_1 implements C {
+}
+class C_2 extends C_1 {
+}
+class D {
+}
+class D_1 extends D {
+}
+public class ReflectionAsSubclass3 {
+    public static void main(String[] args) {
+        try {
+            Class.forName("C_1").asSubclass(D.class);
+        } catch (ClassCastException e1) {
+            try {
+                Class.forName("C_2").asSubclass(D.class);
+            } catch (ClassCastException e2) {
+                try {
+                    Class.forName("D_1").asSubclass(C.class);
+                } catch (ClassCastException e3) {
+                    System.out.println(0);
+                } catch (ClassNotFoundException e4) {
+                    System.out.println(2);
+                }
+            } catch (ClassNotFoundException e5) {
+                System.out.println(2);
+            }
+        } catch (ClassNotFoundException e6) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/expected.txt b/testsuite/java_test/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/test.cfg b/testsuite/java_test/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b2589926c7798e818365044284f6a3d0d4209176
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0009-rt-reflection-ReflectionasSubclass3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionAsSubclass3)
+run(ReflectionAsSubclass3)
diff --git a/testsuite/java_test/reflection_test/RT0010-rt-reflection-Reflectioncast1/ReflectionCast1.java b/testsuite/java_test/reflection_test/RT0010-rt-reflection-Reflectioncast1/ReflectionCast1.java
new file mode 100755
index 0000000000000000000000000000000000000000..5dc332cc8d191e9c8956a6adbcf219d0e8785eae
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0010-rt-reflection-Reflectioncast1/ReflectionCast1.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cast1 {
+}
+class Cast1_a extends Cast1 {
+}
+public class ReflectionCast1 {
+    public static void main(String[] args) {
+        Cast1_a cast1_a = new Cast1_a();
+        Cast1 cast1 = new Cast1();
+        cast1 = Cast1.class.cast(cast1_a);
+        if (cast1.getClass().toString().equals("class Cast1_a")) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0010-rt-reflection-Reflectioncast1/expected.txt b/testsuite/java_test/reflection_test/RT0010-rt-reflection-Reflectioncast1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0010-rt-reflection-Reflectioncast1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0010-rt-reflection-Reflectioncast1/test.cfg b/testsuite/java_test/reflection_test/RT0010-rt-reflection-Reflectioncast1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..48241ccf96e39e67c5169bf6f66586c005bd7a2f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0010-rt-reflection-Reflectioncast1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionCast1)
+run(ReflectionCast1)
diff --git a/testsuite/java_test/reflection_test/RT0011-rt-reflection-Reflectioncast2/ReflectionCast2.java b/testsuite/java_test/reflection_test/RT0011-rt-reflection-Reflectioncast2/ReflectionCast2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a64290da52f997e3de5fb61ef94777ef0ec29ca7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0011-rt-reflection-Reflectioncast2/ReflectionCast2.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cast2 {
+}
+class Cast2_a extends Cast2 {
+}
+public class ReflectionCast2 {
+    public static void main(String[] args) {
+        Cast2_a cast2_a = new Cast2_a();
+        Cast2 cast2 = new Cast2();
+        try {
+            cast2_a = Cast2_a.class.cast(cast2);
+        } catch (ClassCastException e) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0011-rt-reflection-Reflectioncast2/expected.txt b/testsuite/java_test/reflection_test/RT0011-rt-reflection-Reflectioncast2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0011-rt-reflection-Reflectioncast2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0011-rt-reflection-Reflectioncast2/test.cfg b/testsuite/java_test/reflection_test/RT0011-rt-reflection-Reflectioncast2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..77458af7236cd0facb1bce803f83540b42e647f2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0011-rt-reflection-Reflectioncast2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionCast2)
+run(ReflectionCast2)
diff --git a/testsuite/java_test/reflection_test/RT0012-rt-reflection-Reflectioncast3/ReflectionCast3.java b/testsuite/java_test/reflection_test/RT0012-rt-reflection-Reflectioncast3/ReflectionCast3.java
new file mode 100755
index 0000000000000000000000000000000000000000..a15023908636b8d778fc030d4ac16cddfb2b44a1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0012-rt-reflection-Reflectioncast3/ReflectionCast3.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cast3 {
+}
+class Cast3_a {
+}
+public class ReflectionCast3 {
+    public static void main(String[] args) {
+        Cast3_a cast3_a = new Cast3_a();
+        Cast3 cast3 = new Cast3();
+        try {
+            cast3_a = Cast3_a.class.cast(cast3);
+        } catch (ClassCastException e) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0012-rt-reflection-Reflectioncast3/expected.txt b/testsuite/java_test/reflection_test/RT0012-rt-reflection-Reflectioncast3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0012-rt-reflection-Reflectioncast3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0012-rt-reflection-Reflectioncast3/test.cfg b/testsuite/java_test/reflection_test/RT0012-rt-reflection-Reflectioncast3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..277a7056b00bbe487bf9a3bc774ed10dbc32443c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0012-rt-reflection-Reflectioncast3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionCast3)
+run(ReflectionCast3)
diff --git a/testsuite/java_test/reflection_test/RT0013-rt-reflection-Reflectioncast4/ReflectionCast4.java b/testsuite/java_test/reflection_test/RT0013-rt-reflection-Reflectioncast4/ReflectionCast4.java
new file mode 100755
index 0000000000000000000000000000000000000000..0fb596401d01224ee4e8526591119d085483f9c7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0013-rt-reflection-Reflectioncast4/ReflectionCast4.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Cast4 {
+}
+public class ReflectionCast4 {
+    public static void main(String[] args) {
+        Object object = null;
+        Cast4 cast4 = new Cast4();
+        cast4 = Cast4.class.cast(object);
+        if (cast4 == null) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0013-rt-reflection-Reflectioncast4/expected.txt b/testsuite/java_test/reflection_test/RT0013-rt-reflection-Reflectioncast4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0013-rt-reflection-Reflectioncast4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0013-rt-reflection-Reflectioncast4/test.cfg b/testsuite/java_test/reflection_test/RT0013-rt-reflection-Reflectioncast4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..154de1da59229c12f805ba27049111321e46f08c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0013-rt-reflection-Reflectioncast4/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionCast4)
+run(ReflectionCast4)
diff --git a/testsuite/java_test/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java b/testsuite/java_test/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java
new file mode 100755
index 0000000000000000000000000000000000000000..8b70c1f9f5b411c860ab60c867e6253061f6966b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/ReflectionDesiredAssertionStatus.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionDesiredAssertionStatus {
+    public static void main(String[] args) {
+        ReflectionDesiredAssertionStatus reflectionDesiredAssertionStatus = new ReflectionDesiredAssertionStatus();
+        Class clazz = reflectionDesiredAssertionStatus.getClass();
+        if (!clazz.desiredAssertionStatus()) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/expected.txt b/testsuite/java_test/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/test.cfg b/testsuite/java_test/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..63db2513f4c4473d08593c9ffad6735c8326ccd6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0014-rt-reflection-ReflectiondesiredAssertionStatus/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionDesiredAssertionStatus)
+run(ReflectionDesiredAssertionStatus)
diff --git a/testsuite/java_test/reflection_test/RT0015-rt-reflection-ReflectionforName1/ReflectionForName1.java b/testsuite/java_test/reflection_test/RT0015-rt-reflection-ReflectionforName1/ReflectionForName1.java
new file mode 100755
index 0000000000000000000000000000000000000000..91844b19966ccdc8c564beb2b8eec48ce457f9f9
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0015-rt-reflection-ReflectionforName1/ReflectionForName1.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ForName1 {
+}
+public class ReflectionForName1 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        Class clazz = Class.forName("ForName1");
+        if (clazz.toString().equals("class ForName1")) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0015-rt-reflection-ReflectionforName1/expected.txt b/testsuite/java_test/reflection_test/RT0015-rt-reflection-ReflectionforName1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0015-rt-reflection-ReflectionforName1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0015-rt-reflection-ReflectionforName1/test.cfg b/testsuite/java_test/reflection_test/RT0015-rt-reflection-ReflectionforName1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..718481cfd4dd0523fa3307e30438ef0c7e27ba24
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0015-rt-reflection-ReflectionforName1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName1)
+run(ReflectionForName1)
diff --git a/testsuite/java_test/reflection_test/RT0016-rt-reflection-ReflectionforName4/ReflectionForName4.java b/testsuite/java_test/reflection_test/RT0016-rt-reflection-ReflectionforName4/ReflectionForName4.java
new file mode 100755
index 0000000000000000000000000000000000000000..434bfa9a940628198717fef7b5ffa24734c60adc
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0016-rt-reflection-ReflectionforName4/ReflectionForName4.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ForName4 {
+    static {
+    }
+}
+class ForName4_a {
+    static {
+    }
+}
+public class ReflectionForName4 extends Thread {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("for*", true, ForName4_a.class.getClassLoader());
+        } catch (ClassNotFoundException e) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0016-rt-reflection-ReflectionforName4/expected.txt b/testsuite/java_test/reflection_test/RT0016-rt-reflection-ReflectionforName4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0016-rt-reflection-ReflectionforName4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0016-rt-reflection-ReflectionforName4/test.cfg b/testsuite/java_test/reflection_test/RT0016-rt-reflection-ReflectionforName4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0857d14c6de0bc1477d338f12578f68e5a85fe0f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0016-rt-reflection-ReflectionforName4/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName4)
+run(ReflectionForName4)
diff --git a/testsuite/java_test/reflection_test/RT0017-rt-reflection-ReflectionforName5/ReflectionForName5.java b/testsuite/java_test/reflection_test/RT0017-rt-reflection-ReflectionforName5/ReflectionForName5.java
new file mode 100755
index 0000000000000000000000000000000000000000..ecda8c007d431c47b2c3dd8cf776897ba0910b90
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0017-rt-reflection-ReflectionforName5/ReflectionForName5.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+interface ForName55_c {
+}
+class ForName55_b implements ForName55_c {
+}
+class ForName55_a extends ForName55_b {
+}
+class ForName55 extends ForName55_a {
+}
+class ForName5_e {
+}
+class ForName5_d extends ForName5_e {
+}
+class ForName5_c extends ForName5_d {
+}
+class ForName5_b extends ForName5_c {
+}
+class ForName5_a extends ForName5_b {
+}
+class ForName5 extends ForName5_a {
+}
+public class ReflectionForName5 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        Class clazz = Class.forName("ForName5");
+        if (clazz.toString().equals("class ForName5")) {
+            Class clazz2 = Class.forName("ForName55");
+            if (clazz2.toString().equals("class ForName55")) {
+                System.out.println(0);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0017-rt-reflection-ReflectionforName5/expected.txt b/testsuite/java_test/reflection_test/RT0017-rt-reflection-ReflectionforName5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0017-rt-reflection-ReflectionforName5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0017-rt-reflection-ReflectionforName5/test.cfg b/testsuite/java_test/reflection_test/RT0017-rt-reflection-ReflectionforName5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35f30f0a123dbd0067408bc2a6562ed97141b0e0
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0017-rt-reflection-ReflectionforName5/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName5)
+run(ReflectionForName5)
diff --git a/testsuite/java_test/reflection_test/RT0018-rt-reflection-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java b/testsuite/java_test/reflection_test/RT0018-rt-reflection-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f70b4c7d388807c8496059766aa549f30415a51
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0018-rt-reflection-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz1 {
+int i() default 0;
+String t() default "";
+}
+@Zzz1(i = 333, t = "getAnnotation")
+class GetAnnotation1_a {
+}
+class GetAnnotation1_b {
+}
+public class ReflectionGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetAnnotation1_a");
+            Class clazz2 = Class.forName("GetAnnotation1_b");
+            if (clazz1.getAnnotation(Zzz1.class).toString().indexOf("t=getAnnotation") != -1
+                    && clazz1.getAnnotation(Zzz1.class).toString().indexOf("i=333") != -1
+                    && clazz2.getAnnotation(Zzz1.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0018-rt-reflection-ReflectiongetAnnotation1/expected.txt b/testsuite/java_test/reflection_test/RT0018-rt-reflection-ReflectiongetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0018-rt-reflection-ReflectiongetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0018-rt-reflection-ReflectiongetAnnotation1/test.cfg b/testsuite/java_test/reflection_test/RT0018-rt-reflection-ReflectiongetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ea370ea1cc66f565a7989953010f2b77f00112f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0018-rt-reflection-ReflectiongetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation1)
+run(ReflectionGetAnnotation1)
diff --git a/testsuite/java_test/reflection_test/RT0019-rt-reflection-ReflectiongetAnnotation2/ReflectionGetAnnotation2.java b/testsuite/java_test/reflection_test/RT0019-rt-reflection-ReflectiongetAnnotation2/ReflectionGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..a7bdad1aad1ead230a377b3d15470f980ab5b51f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0019-rt-reflection-ReflectiongetAnnotation2/ReflectionGetAnnotation2.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+class GetAnnotation2_a {
+    @IF2(i = 333, t = "getAnnotation")
+    public int i_a;
+    public String t_a;
+}
+class GetAnnotation2_b {
+    public int i_b;
+    public String t_b;
+}
+public class ReflectionGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls1 = Class.forName("GetAnnotation2_a");
+            Class cls2 = Class.forName("GetAnnotation2_b");
+            Field instance1 = cls1.getField("i_a");
+            Field instance2 = cls1.getField("t_a");
+            Field instance3 = cls2.getField("i_b");
+            if (instance1.getAnnotation(IF2.class).i() == 333 && instance1.getAnnotation(IF2.class).
+                    t().equals("getAnnotation") && instance2.getAnnotation(IF2.class) == null &&
+                    instance3.getAnnotation(IF2.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0019-rt-reflection-ReflectiongetAnnotation2/expected.txt b/testsuite/java_test/reflection_test/RT0019-rt-reflection-ReflectiongetAnnotation2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0019-rt-reflection-ReflectiongetAnnotation2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0019-rt-reflection-ReflectiongetAnnotation2/test.cfg b/testsuite/java_test/reflection_test/RT0019-rt-reflection-ReflectiongetAnnotation2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7775516b4fd34e7cd2ee6af7e94daa49acba0ded
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0019-rt-reflection-ReflectiongetAnnotation2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation2)
+run(ReflectionGetAnnotation2)
diff --git a/testsuite/java_test/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java b/testsuite/java_test/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java
new file mode 100755
index 0000000000000000000000000000000000000000..688f91174d30d0484c0e8893cc128dcfe23f6011
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/ReflectionGetAnnotation3.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz3 {
+    int i() default 0;
+    String t() default "";
+}
+class GetAnnotation3_a {
+    @Zzz3(i = 333, t = "getAnnotation")
+    public void qqq() {
+    };
+    public void rrr() {
+    };
+}
+class GetAnnotation3_b {
+    public void www() {
+    };
+}
+public class ReflectionGetAnnotation3 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation3_a");
+            Method zhu1 = zqp1.getMethod("qqq");
+            Method zhu2 = zqp1.getMethod("rrr");
+            zhu1.getAnnotation(Zzz3.class).t();
+            zhu2.getAnnotation(Zzz3.class).i();
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            try {
+                Class zqp2 = Class.forName("GetAnnotation3_b");
+                Method zhu3 = zqp2.getMethod("www");
+                zhu3.getAnnotation(Zzz3.class).i();
+                System.out.println(2);
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                System.out.println(2);
+            } catch (NoSuchMethodException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NullPointerException e5){
+                System.out.println(0);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/expected.txt b/testsuite/java_test/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/test.cfg b/testsuite/java_test/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5b9e88591bddd419360dfcaabec01e4c524a9bab
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0020-rt-reflection-ReflectiongetAnnotation3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation3)
+run(ReflectionGetAnnotation3)
diff --git a/testsuite/java_test/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java b/testsuite/java_test/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java
new file mode 100755
index 0000000000000000000000000000000000000000..b501d929b036783dae2a1c8bb3e1e69ea1b62958
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/ReflectionGetAnnotation4.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz4 {
+    int i() default 0;
+    String t() default "";
+}
+@interface Zzz4_a {
+int ii() default 0;
+String tt() default "";
+}
+class GetAnnotation4_a {
+    @Zzz4(i = 333, t = "getAnnotation")
+    public void qqq() {
+    };
+    @Zzz4_a(ii = 555, tt = "test")
+    public void rrr() {
+    };
+}
+public class ReflectionGetAnnotation4 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation4_a");
+            Method zhu1 = zqp1.getMethod("qqq");
+            Method zhu2 = zqp1.getMethod("rrr");
+            if (zhu1.getAnnotation(Zzz4_a.class) == null && zhu2.getAnnotation(Zzz4.class) == null) {
+                zhu1.getAnnotation(Zzz4_a.class).ii();
+                System.out.println(2);
+            }
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/expected.txt b/testsuite/java_test/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/test.cfg b/testsuite/java_test/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c8ef96f668dd3c478687d95e9d2087946aac9c8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0021-rt-reflection-ReflectiongetAnnotation4/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation4)
+run(ReflectionGetAnnotation4)
diff --git a/testsuite/java_test/reflection_test/RT0022-rt-reflection-ReflectiongetAnnotation5/ReflectionGetAnnotation5.java b/testsuite/java_test/reflection_test/RT0022-rt-reflection-ReflectiongetAnnotation5/ReflectionGetAnnotation5.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f75362044377c79244b7c30542776d78e5d7c25
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0022-rt-reflection-ReflectiongetAnnotation5/ReflectionGetAnnotation5.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz5 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz5_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Zzz5(i = 333, t = "test1")
+class GetAnnotation5 {
+    public int i;
+    public String t;
+}
+@Zzz5_a(i_a = 666, t_a = "right1")
+class GetAnnotation5_a extends GetAnnotation5 {
+    public int i_a;
+    public String t_a;
+}
+class GetAnnotation5_b extends GetAnnotation5_a {
+}
+public class ReflectionGetAnnotation5 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation5_b");
+            if (zqp1.getAnnotation(Zzz5.class).toString().indexOf("t=test1") != -1 && zqp1.getAnnotation(Zzz5.class).
+                    toString().indexOf("i=333") != -1) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0022-rt-reflection-ReflectiongetAnnotation5/expected.txt b/testsuite/java_test/reflection_test/RT0022-rt-reflection-ReflectiongetAnnotation5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0022-rt-reflection-ReflectiongetAnnotation5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0022-rt-reflection-ReflectiongetAnnotation5/test.cfg b/testsuite/java_test/reflection_test/RT0022-rt-reflection-ReflectiongetAnnotation5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..17609280c06de75390ae445dbce0453b52022aec
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0022-rt-reflection-ReflectiongetAnnotation5/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation5)
+run(ReflectionGetAnnotation5)
diff --git a/testsuite/java_test/reflection_test/RT0023-rt-reflection-ReflectiongetAnnotation6/ReflectionGetAnnotation6.java b/testsuite/java_test/reflection_test/RT0023-rt-reflection-ReflectiongetAnnotation6/ReflectionGetAnnotation6.java
new file mode 100755
index 0000000000000000000000000000000000000000..374cc346909f9c9d4fc61eb35f361e1f148d391e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0023-rt-reflection-ReflectiongetAnnotation6/ReflectionGetAnnotation6.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz6 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz6_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Zzz6(i = 333, t = "test1")
+class GetAnnotation6 {
+    public int i;
+    public String t;
+    @Zzz6_a(i_a = 666, t_a = "right1")
+    public static class GetAnnotation6_a {
+        public int j;
+    }
+}
+public class ReflectionGetAnnotation6 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation6");
+            Class[] zhu1 = zqp1.getDeclaredClasses();
+            if (zhu1[0].getAnnotation(Zzz6_a.class).toString().indexOf("t_a=right1") != -1 && zhu1[0].
+                    getAnnotation(Zzz6_a.class).toString().indexOf("i_a=666") != -1) {
+                if (zhu1[0].getAnnotation(Zzz6.class) == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0023-rt-reflection-ReflectiongetAnnotation6/expected.txt b/testsuite/java_test/reflection_test/RT0023-rt-reflection-ReflectiongetAnnotation6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0023-rt-reflection-ReflectiongetAnnotation6/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0023-rt-reflection-ReflectiongetAnnotation6/test.cfg b/testsuite/java_test/reflection_test/RT0023-rt-reflection-ReflectiongetAnnotation6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..14887ad141ad99fa502095377a56c17935c15217
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0023-rt-reflection-ReflectiongetAnnotation6/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation6)
+run(ReflectionGetAnnotation6)
diff --git a/testsuite/java_test/reflection_test/RT0024-rt-reflection-ReflectiongetAnnotation7/ReflectionGetAnnotation7.java b/testsuite/java_test/reflection_test/RT0024-rt-reflection-ReflectiongetAnnotation7/ReflectionGetAnnotation7.java
new file mode 100755
index 0000000000000000000000000000000000000000..6715604631f62fa5fc6f36bd19fd2301c3f84935
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0024-rt-reflection-ReflectiongetAnnotation7/ReflectionGetAnnotation7.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+class GetAnnotation7 {
+    @Deprecated
+    public int aa(int num) {
+        return 0;
+    }
+}
+class GetAnnotation7_a extends GetAnnotation7 {
+    @Override
+    public int aa(int num) {
+        return 2;
+    }
+}
+public class ReflectionGetAnnotation7 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotation7_a");
+            Method zhu1 = zqp1.getMethod("aa", int.class);
+            Annotation[] j = zhu1.getAnnotations();
+            if (j.length == 0) {
+                try {
+                    Class zqp2 = Class.forName("GetAnnotation7");
+                    Method zhu2 = zqp2.getMethod("aa", int.class);
+                    if (zhu2.getAnnotation(Deprecated.class).toString().indexOf("Deprecated") != -1) {
+                        System.out.println(0);
+                    }
+                } catch (ClassNotFoundException e1) {
+                    System.err.println(e1);
+                    System.out.println(2);
+                } catch (NoSuchMethodException e2) {
+                    System.err.println(e2);
+                    System.out.println(2);
+                } catch (NullPointerException e3) {
+                    System.err.println(e3);
+                    System.out.println(2);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0024-rt-reflection-ReflectiongetAnnotation7/expected.txt b/testsuite/java_test/reflection_test/RT0024-rt-reflection-ReflectiongetAnnotation7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0024-rt-reflection-ReflectiongetAnnotation7/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0024-rt-reflection-ReflectiongetAnnotation7/test.cfg b/testsuite/java_test/reflection_test/RT0024-rt-reflection-ReflectiongetAnnotation7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4b9ef5370b6510797a303414b844b94251494184
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0024-rt-reflection-ReflectiongetAnnotation7/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation7)
+run(ReflectionGetAnnotation7)
diff --git a/testsuite/java_test/reflection_test/RT0025-rt-reflection-ReflectiongetAnnotationsByType1/ReflectionGetAnnotationsByType1.java b/testsuite/java_test/reflection_test/RT0025-rt-reflection-ReflectiongetAnnotationsByType1/ReflectionGetAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..71bdebdb77e537048ece045ec48d591bb5adf20a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0025-rt-reflection-ReflectiongetAnnotationsByType1/ReflectionGetAnnotationsByType1.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz1 {
+    int i() default 0;
+    String t() default "";
+}
+@interface Zzzz1_a {
+}
+@interface Zzzz1_b {
+}
+class GetAnnotationsByType1_a {
+    @Zzzz1(i = 333, t = "GetAnnotationsByType")
+    public int i_a;
+    @Zzzz1(i = 333, t = "GetAnnotationsByType")
+    public int i_aa;
+    @Zzzz1(i = 333, t = "GetAnnotationsByType")
+    public int i_aaa;
+    public String t_a;
+    @Zzzz1_a
+    public String t_aa;
+    @Zzzz1_b
+    public String t_aaa;
+}
+public class ReflectionGetAnnotationsByType1 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType1_a");
+            Field zhu1 = zqp1.getField("i_a");
+            Field zhu2 = zqp1.getField("t_a");
+            if (zqp1.getAnnotationsByType(Zzzz1.class).length == 0) {
+                if (zhu2.getAnnotationsByType(Zzzz1_a.class).length == 0) {
+                    Annotation[] k = zhu1.getAnnotationsByType(Zzzz1.class);
+                    if (k[0].toString().indexOf("t=GetAnnotationsByType") != -1 && k[0].toString().indexOf("i=333")
+                            != -1) {
+                        System.out.println(0);
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0025-rt-reflection-ReflectiongetAnnotationsByType1/expected.txt b/testsuite/java_test/reflection_test/RT0025-rt-reflection-ReflectiongetAnnotationsByType1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0025-rt-reflection-ReflectiongetAnnotationsByType1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0025-rt-reflection-ReflectiongetAnnotationsByType1/test.cfg b/testsuite/java_test/reflection_test/RT0025-rt-reflection-ReflectiongetAnnotationsByType1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eb77f0fef1b032d4b8af2603149df1285294d426
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0025-rt-reflection-ReflectiongetAnnotationsByType1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotationsByType1)
+run(ReflectionGetAnnotationsByType1)
diff --git a/testsuite/java_test/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java b/testsuite/java_test/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java
new file mode 100755
index 0000000000000000000000000000000000000000..34d7b18fb91f34547837307865d246702846f2d2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/ReflectionGetAnnotationsByType2.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz2 {
+    int i() default 0;
+    String t() default "";
+}
+class GetAnnotationsByType2_a {
+    @Zzzz2(i = 333, t = "GetAnnotationsByType")
+    public int i_a;
+    public String t_a;
+}
+class GetAnnotationsByType2_b {
+    public int i_b;
+    public String t_b;
+}
+public class ReflectionGetAnnotationsByType2 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType2_a");
+            Field zhu1 = zqp1.getField("t_a");
+            Annotation[] j = zhu1.getAnnotationsByType(null);
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            try {
+                Class zqp2 = Class.forName("GetAnnotationsByType2_b");
+                Field zhu2 = zqp2.getField("i_b");
+                Annotation[] k = zhu2.getAnnotationsByType(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                System.out.println(2);
+            } catch (NoSuchFieldException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/expected.txt b/testsuite/java_test/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/test.cfg b/testsuite/java_test/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3de58b38ec6d4c7889ccb7fa81f092294203d605
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0026-rt-reflection-ReflectiongetAnnotationsByType2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotationsByType2)
+run(ReflectionGetAnnotationsByType2)
diff --git a/testsuite/java_test/reflection_test/RT0027-rt-reflection-ReflectiongetAnnotationsByType3/ReflectionGetAnnotationsByType3.java b/testsuite/java_test/reflection_test/RT0027-rt-reflection-ReflectiongetAnnotationsByType3/ReflectionGetAnnotationsByType3.java
new file mode 100755
index 0000000000000000000000000000000000000000..5543714266c6ef12792a085fc71d66c61a70acfe
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0027-rt-reflection-ReflectiongetAnnotationsByType3/ReflectionGetAnnotationsByType3.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz3 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzzz3_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Zzzz3(i = 333, t = "test1")
+class GetAnnotationsByType3 {
+    public int i;
+    public String t;
+}
+@Zzzz3_a(i_a = 666, t_a = "right1")
+class GetAnnotationsByType3_a extends GetAnnotationsByType3 {
+    public int i_a;
+    public String t_a;
+}
+class GetAnnotationsByType3_b extends GetAnnotationsByType3_a {
+}
+public class ReflectionGetAnnotationsByType3 {
+    public static void main(String[] args) {
+        try {
+            Class zqp1 = Class.forName("GetAnnotationsByType3_b");
+            Annotation[] j = zqp1.getAnnotationsByType(Zzzz3.class);
+            if (j[0].toString().indexOf("t=test1") != -1 && j[0].toString().indexOf("i=333") != -1) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0027-rt-reflection-ReflectiongetAnnotationsByType3/expected.txt b/testsuite/java_test/reflection_test/RT0027-rt-reflection-ReflectiongetAnnotationsByType3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0027-rt-reflection-ReflectiongetAnnotationsByType3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0027-rt-reflection-ReflectiongetAnnotationsByType3/test.cfg b/testsuite/java_test/reflection_test/RT0027-rt-reflection-ReflectiongetAnnotationsByType3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc7cf1d3ba3e52e092d427566287b1c47fa57956
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0027-rt-reflection-ReflectiongetAnnotationsByType3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotationsByType3)
+run(ReflectionGetAnnotationsByType3)
diff --git a/testsuite/java_test/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java b/testsuite/java_test/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java
new file mode 100755
index 0000000000000000000000000000000000000000..d8f474cb98ccf932a5b1f5c8eb429e89ad5d70fd
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/ReflectionGetCanonicalName.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class GetCanonicalNameTest {
+}
+public class ReflectionGetCanonicalName {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("GetCanonicalNameTest");
+            if (zqp.getCanonicalName().equals("GetCanonicalNameTest")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/expected.txt b/testsuite/java_test/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/test.cfg b/testsuite/java_test/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8d40d428a28710dbb4e8ea640ff751f080310444
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0028-rt-reflection-ReflectiongetCanonicalName/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetCanonicalName)
+run(ReflectionGetCanonicalName)
diff --git a/testsuite/java_test/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/ReflectionGetComponentType.java b/testsuite/java_test/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/ReflectionGetComponentType.java
new file mode 100755
index 0000000000000000000000000000000000000000..661cfbae4d6c80dd3522d8beda1ec39c26742c4c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/ReflectionGetComponentType.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionGetComponentType {
+    public static void main(String[] args) {
+        if (char.class.getComponentType() == null && String[].class.getComponentType().toString().
+                equals("class java.lang.String") && int[].class.getComponentType().toString().equals("int")) {
+            System.out.println(0);
+        }else{
+            System.out.println(2);
+        }
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/expected.txt b/testsuite/java_test/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/test.cfg b/testsuite/java_test/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c6da763cba88896b4458d9c6d91a00b8467002e1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0029-rt-reflection-ReflectiongetComponentType/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetComponentType)
+run(ReflectionGetComponentType)
diff --git a/testsuite/java_test/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java b/testsuite/java_test/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..7b26e033cabf51ac5214dc9dd28105949743dc82
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/ReflectionGetDeclaredAnnotations1.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Ddd1(i = 333, t = "test1")
+class GetDeclaredAnnotations1 {
+    public int i;
+    public String t;
+}
+@Ddd1_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotations1_a extends GetDeclaredAnnotations1 {
+    public int i_a;
+    public String t_a;
+}
+public class ReflectionGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotations1_a");
+            if (zqp1.getDeclaredAnnotations().length == 1) {
+                Annotation[] j = zqp1.getDeclaredAnnotations();
+                if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                    result = 0;
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/expected.txt b/testsuite/java_test/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/test.cfg b/testsuite/java_test/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9823fe8304cf5a24161ed1398718aa35f50c0fa0
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredAnnotations1)
+run(ReflectionGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java b/testsuite/java_test/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..0ccf1dce327d132b9bf43cc1296aebe79b4024fb
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/ReflectionGetDeclaredAnnotations2.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Ddd2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Ddd2(i = 333, t = "test1")
+class GetDeclaredAnnotations2 {
+    public int i;
+    public String t;
+}
+@Ddd2_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotations2_a extends GetDeclaredAnnotations2 {
+    public int i_a;
+    public String t_a;
+}
+class GetDeclaredAnnotations2_b extends GetDeclaredAnnotations2_a {
+}
+public class ReflectionGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotations2_b");
+            if (zqp1.getDeclaredAnnotations().length == 0) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/expected.txt b/testsuite/java_test/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/test.cfg b/testsuite/java_test/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ec3924c4a8988f8ab4152eb8ab59a573cf8006fe
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredAnnotations2)
+run(ReflectionGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/reflection_test/RT0032-rt-reflection-ReflectiongetDeclaredAnnotationsByType1/ReflectionGetDeclaredAnnotationsByType1.java b/testsuite/java_test/reflection_test/RT0032-rt-reflection-ReflectiongetDeclaredAnnotationsByType1/ReflectionGetDeclaredAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..c67abc9efdb6f31b44bd66ca927d34360d9c599f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0032-rt-reflection-ReflectiongetDeclaredAnnotationsByType1/ReflectionGetDeclaredAnnotationsByType1.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Dddd1(i = 333, t = "test1")
+class GetDeclaredAnnotationsByType1 {
+    public int i;
+    public String t;
+}
+@Dddd1_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotationsByType1_a extends GetDeclaredAnnotationsByType1 {
+    public int i_a;
+    public String t_a;
+}
+class GetDeclaredAnnotationsByType1_b extends GetDeclaredAnnotationsByType1_a {
+}
+public class ReflectionGetDeclaredAnnotationsByType1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotationsByType1_b");
+            Class zqp2 = Class.forName("GetDeclaredAnnotationsByType1_a");
+            if (zqp1.getDeclaredAnnotationsByType(Dddd1.class).length == 0) {
+                Annotation[] j = zqp2.getDeclaredAnnotationsByType(Dddd1_a.class);
+                if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                    result = 0;
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0032-rt-reflection-ReflectiongetDeclaredAnnotationsByType1/expected.txt b/testsuite/java_test/reflection_test/RT0032-rt-reflection-ReflectiongetDeclaredAnnotationsByType1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0032-rt-reflection-ReflectiongetDeclaredAnnotationsByType1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0032-rt-reflection-ReflectiongetDeclaredAnnotationsByType1/test.cfg b/testsuite/java_test/reflection_test/RT0032-rt-reflection-ReflectiongetDeclaredAnnotationsByType1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7369f4f33c37ce2e3d1c77b0f08dcbc961e3ceba
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0032-rt-reflection-ReflectiongetDeclaredAnnotationsByType1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredAnnotationsByType1)
+run(ReflectionGetDeclaredAnnotationsByType1)
diff --git a/testsuite/java_test/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java b/testsuite/java_test/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..3921730400d8a2f9e836e263c25bf6ce977224bf
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Dddd2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+@Dddd2(i = 333, t = "test1")
+class GetDeclaredAnnotationsByType2 {
+    public int i;
+    public String t;
+}
+@Dddd2_a(i_a = 666, t_a = "right1")
+class GetDeclaredAnnotationsByType2_a extends GetDeclaredAnnotationsByType2 {
+    public int i_a;
+    public String t_a;
+}
+class GetDeclaredAnnotationsByType2_b extends GetDeclaredAnnotationsByType2_a {
+}
+public class ReflectionGetDeclaredAnnotationsByTypeNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredAnnotationsByType2_b");
+            Annotation[] j = zqp1.getDeclaredAnnotationsByType(null);
+            result = 0;
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/expected.txt b/testsuite/java_test/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/test.cfg b/testsuite/java_test/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7316d61dcc35b0e2715162fed41c6cc5fcb0e8b4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredAnnotationsByTypeNullPointerException)
+run(ReflectionGetDeclaredAnnotationsByTypeNullPointerException)
diff --git a/testsuite/java_test/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java b/testsuite/java_test/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java
new file mode 100755
index 0000000000000000000000000000000000000000..d86ae7990bd8f3e2fc27f3876e980294d8e8143f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/ReflectionGetDeclaredClasses.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ReflectiongetDeclaredClasses_a {
+    public class getDeclaredClasses_a1 {
+    }
+    private class getDeclaredClasses_a2 {
+    }
+    protected class getDeclaredClasses_a3 {
+    }
+}
+public class ReflectionGetDeclaredClasses extends ReflectiongetDeclaredClasses_a {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("ReflectionGetDeclaredClasses");
+            Class<?>[] j = zqp.getDeclaredClasses();
+            if (j.length == 3) {
+                for (int i = 0; i < j.length; i++) {
+                    if (j[i].getName().indexOf("getDeclaredClasses_a") != -1) {
+                        result = -1;
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+    public class getDeclaredClassestest1 {
+    }
+    private class getDeclaredClassestest2 {
+    }
+    protected class getDeclaredClassestest3 {
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/expected.txt b/testsuite/java_test/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/test.cfg b/testsuite/java_test/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..45ec5eb17dfffacc3a3971bcdc24f830f24e4209
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0034-rt-reflection-ReflectiongetDeclaredClasses/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredClasses)
+run(ReflectionGetDeclaredClasses)
diff --git a/testsuite/java_test/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java b/testsuite/java_test/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java
new file mode 100755
index 0000000000000000000000000000000000000000..0a79aa1fbcac4b40f56b39900911d8ceef885d34
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/ReflectionGetDeclaredField1.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetDeclaredField1 {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+public class ReflectionGetDeclaredField1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("GetDeclaredField1");
+            Field zhu1 = zqp.getDeclaredField("i");
+            Field zhu2 = zqp.getDeclaredField("s");
+            Field zhu3 = zqp.getDeclaredField("d");
+            Field zhu4 = zqp.getDeclaredField("f");
+            if (zhu1.getName().equals("i") && zhu2.getName().equals("s") && zhu3.getName().equals("d") &&
+                    zhu4.getName().equals("f")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            result = -1;
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/expected.txt b/testsuite/java_test/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/test.cfg b/testsuite/java_test/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bb780c56d82e7ae80567d96d5d1a12ebdf4c171e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0035-rt-reflection-ReflectiongetDeclaredField1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredField1)
+run(ReflectionGetDeclaredField1)
diff --git a/testsuite/java_test/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java b/testsuite/java_test/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..e24b7c2783101f93d0cdf10426f3c624b6385e03
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/ReflectionGetDeclaredFieldNullPointerException.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetDeclaredField2_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+class GetDeclaredField2 extends GetDeclaredField2_a {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+public class ReflectionGetDeclaredFieldNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("GetDeclaredField2");
+            Field zhu1 = zqp.getDeclaredField("i_a");
+            result = -1;
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            result = -1;
+        } catch (NoSuchFieldException e3) {
+            try {
+                Class zqp = Class.forName("GetDeclaredField2");
+                Field zhu1 = zqp.getDeclaredField(null);
+                result = -1;
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                result = -1;
+            } catch (NoSuchFieldException e5) {
+                System.err.println(e5);
+                result = -1;
+            } catch (NullPointerException e6) {
+                result = 0;
+            }
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/expected.txt b/testsuite/java_test/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/test.cfg b/testsuite/java_test/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a6ad430a38b8a8cc93d80cbdcfb4335241f19ca
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredFieldNullPointerException)
+run(ReflectionGetDeclaredFieldNullPointerException)
diff --git a/testsuite/java_test/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java b/testsuite/java_test/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java
new file mode 100755
index 0000000000000000000000000000000000000000..935b39bca9c54225f4d45ff619ff70c8e2137bd0
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/ReflectionGetDeclaredFields1.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetDeclaredFields1_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+class GetDeclaredFields1 extends GetDeclaredFields1_a {
+    public int i = 1;
+    String s = "aaa";
+    private double d = 2.5;
+    protected float f = -222;
+}
+interface GetDeclaredFields1_b {
+    public int i_b = 2;
+    String s_b = "ccc";
+}
+public class ReflectionGetDeclaredFields1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("GetDeclaredFields1");
+            Class zqp2 = Class.forName("GetDeclaredFields1_b");
+            Field[] j = zqp1.getDeclaredFields();
+            Field[] k = zqp2.getDeclaredFields();
+            if (j.length == 4 && k.length == 2) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/expected.txt b/testsuite/java_test/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/test.cfg b/testsuite/java_test/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f16f86d15dce560a924f46b8154651a16e681e1b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0037-rt-reflection-ReflectiongetDeclaredFields1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredFields1)
+run(ReflectionGetDeclaredFields1)
diff --git a/testsuite/java_test/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java b/testsuite/java_test/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java
new file mode 100755
index 0000000000000000000000000000000000000000..2c489ed641a58f6985aa63897c64e743eb4a2de3
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/ReflectionGetDeclaredFields.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetDeclaredFields_a {
+    public int i_a = 5;
+    String s_a = "bbb";
+}
+class GetDeclaredFields extends GetDeclaredFields_a {
+}
+enum GetDeclaredFields_b {
+    i_b, s_b, f_b
+}
+public class ReflectionGetDeclaredFields {
+    public static void main(String[] args) {
+        int result = 0;
+        try {
+            Class zqp1 = Class.forName("GetDeclaredFields");
+            Class zqp2 = Class.forName("GetDeclaredFields_b");
+            Field[] j = zqp1.getDeclaredFields();
+            Field[] k = zqp2.getDeclaredFields();
+            if (j.length == 0 && k.length == 4) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/expected.txt b/testsuite/java_test/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/test.cfg b/testsuite/java_test/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..379c7ff0b35afb856df39ce7f4631efddce2e373
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0038-rt-reflection-ReflectiongetDeclaredFields2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredFields)
+run(ReflectionGetDeclaredFields)
diff --git a/testsuite/java_test/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java b/testsuite/java_test/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java
new file mode 100755
index 0000000000000000000000000000000000000000..e92eade50ca56a8c3df9065a50b061693900a466
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/ReflectionGetDeclaredMethod1.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetDeclaredMethod1 {
+    public void empty1() {
+    }
+    void empty2() {
+    }
+    int getZero() {
+        return 0;
+    }
+    private String getDd() {
+        return "dd";
+    }
+    public void empty1(int number) {
+    }
+    int getZero(String name) {
+        return 2;
+    }
+}
+public class ReflectionGetDeclaredMethod1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethod1");
+            Method method1 = clazz.getDeclaredMethod("empty1", int.class);
+            Method method2 = clazz.getDeclaredMethod("getDd");
+            Method method3 = clazz.getDeclaredMethod("empty1");
+            Method method4 = clazz.getDeclaredMethod("empty2");
+            Method method5 = clazz.getDeclaredMethod("getZero");
+            Method method6 = clazz.getDeclaredMethod("getZero", String.class);
+            if (method1.toString().equals("public void GetDeclaredMethod1.empty1(int)")
+                    && method2.toString().equals("private java.lang.String GetDeclaredMethod1.getDd()")
+                    && method3.toString().equals("public void GetDeclaredMethod1.empty1()")
+                    && method4.toString().equals("void GetDeclaredMethod1.empty2()")
+                    && method5.toString().equals("int GetDeclaredMethod1.getZero()")
+                    && method6.toString().equals("int GetDeclaredMethod1.getZero(java.lang.String)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/expected.txt b/testsuite/java_test/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/test.cfg b/testsuite/java_test/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4938010f56a9d2641a7a9a3efbc113c6e084dae1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0039-rt-reflection-ReflectiongetDeclaredMethod1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethod1)
+run(ReflectionGetDeclaredMethod1)
diff --git a/testsuite/java_test/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java b/testsuite/java_test/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java
new file mode 100755
index 0000000000000000000000000000000000000000..8d4fe73d713c5b95babe4dac4572033b113c3810
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/ReflectionGetDeclaredMethod2.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetDeclaredMethod2_a {
+    public void empty1() {
+    }
+    public void empty2() {
+    }
+}
+class GetDeclaredMethod2 extends GetDeclaredMethod2_a {
+    public void void1() {
+    }
+    void void2() {
+    }
+    int getZero() {
+        return 0;
+    }
+    private String getDd() {
+        return "dd";
+    }
+    public void setNumber(int number) {
+    }
+    int setName(String name) {
+        return 2;
+    }
+}
+public class ReflectionGetDeclaredMethod2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetDeclaredMethod2");
+            Method method1 = clazz1.getDeclaredMethod("empty1");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            try {
+                Class clazz2 = Class.forName("GetDeclaredMethod2");
+                Method method2 = clazz2.getDeclaredMethod(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchMethodException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/expected.txt b/testsuite/java_test/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/test.cfg b/testsuite/java_test/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..deff9505b54fb911c691f4689ca5f46ad4cbb9ea
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0040-rt-reflection-ReflectiongetDeclaredMethod2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethod2)
+run(ReflectionGetDeclaredMethod2)
diff --git a/testsuite/java_test/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java b/testsuite/java_test/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java
new file mode 100755
index 0000000000000000000000000000000000000000..57c86d7ec61cbd015b52c2934bc54f3203ab8ad9
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/ReflectionGetDeclaredMethod3.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+abstract class GetDeclaredMethod3 {
+    abstract void empty1();
+    abstract public int empty2();
+}
+public class ReflectionGetDeclaredMethod3 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethod3");
+            Method method1 = clazz.getDeclaredMethod("empty1");
+            Method method2 = clazz.getMethod("empty2");
+            if (method1.toString().equals("abstract void GetDeclaredMethod3.empty1()")
+                    && method2.toString().equals("public abstract int GetDeclaredMethod3.empty2()")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/expected.txt b/testsuite/java_test/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/test.cfg b/testsuite/java_test/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d0ff610ec2f5d1209f4d6284fc55cb857ff2c6da
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0041-rt-reflection-ReflectiongetDeclaredMethod3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethod3)
+run(ReflectionGetDeclaredMethod3)
diff --git a/testsuite/java_test/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java b/testsuite/java_test/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java
new file mode 100755
index 0000000000000000000000000000000000000000..c63813abc8b207a711a71d4433721d31832d5be6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/ReflectionGetDeclaredMethods1.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetDeclaredMethods1_a {
+    public void empty1() {
+    }
+    public void empty2() {
+    }
+}
+class GetDeclaredMethods1 extends GetDeclaredMethods1_a {
+    public void void1() {
+    }
+    void void2() {
+    }
+    int getZero() {
+        return 0;
+    }
+    private String getDd() {
+        return "dd";
+    }
+    public void setNumber(int number) {
+    }
+    int setName(String name) {
+        return 2;
+    }
+}
+interface GetDeclaredMethods1_b {
+    public default void test1() {
+    }
+    default void test2() {
+    }
+}
+public class ReflectionGetDeclaredMethods1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetDeclaredMethods1");
+            Class clazz2 = Class.forName("GetDeclaredMethods1_b");
+            Method[] methods1 = clazz1.getDeclaredMethods();
+            Method[] methods2 = clazz2.getDeclaredMethods();
+            if (methods1.length == 6 && methods2.length == 2) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/expected.txt b/testsuite/java_test/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/test.cfg b/testsuite/java_test/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c3a592dfc3e8c54f3c55859fddbeb769a4f4267
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0042-rt-reflection-ReflectiongetDeclaredMethods1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethods1)
+run(ReflectionGetDeclaredMethods1)
diff --git a/testsuite/java_test/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java b/testsuite/java_test/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java
new file mode 100755
index 0000000000000000000000000000000000000000..d3f668d585ef6bfb5581a1e931d7e8047888ff85
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/ReflectionGetDeclaredMethods2.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetDeclaredMethods2_a {
+    public void empty1() {
+    }
+    public void empty2() {
+    }
+}
+class GetDeclaredMethods2 extends GetDeclaredMethods2_a {
+}
+public class ReflectionGetDeclaredMethods2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetDeclaredMethods2");
+            Method[] method = clazz.getDeclaredMethods();
+            if (method.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/expected.txt b/testsuite/java_test/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/test.cfg b/testsuite/java_test/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4c20aa127bd44d61aaef44c8ee93276e46964ef8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0043-rt-reflection-ReflectiongetDeclaredMethods2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaredMethods2)
+run(ReflectionGetDeclaredMethods2)
diff --git a/testsuite/java_test/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java b/testsuite/java_test/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..c90c3ee92b2d2a55adf1270df3b31aa80782a1f7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/ReflectionGetDeclaringClass.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+class GetDeclaringClass {
+    public int num;
+    String str;
+    float fNum;
+    public GetDeclaringClass() {
+    }
+    GetDeclaringClass(int number) {
+    }
+    GetDeclaringClass(String name) {
+    }
+    GetDeclaringClass(int number, String name) {
+    }
+}
+class GetDeclaringClass_a {
+}
+public class ReflectionGetDeclaringClass {
+    public static void main(String[] args) {
+        try {
+            int num = 0;
+            Class clazz = Class.forName("GetDeclaringClass");
+            Field[] fields = clazz.getDeclaredFields();
+            Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+            for (int i = 0; i < fields.length; i++) {
+                if (fields[i].getDeclaringClass().getName().equals("GetDeclaringClass")) {
+                    for (int j = 0; j < constructors.length; j++) {
+                        if (constructors[j].getDeclaringClass().getName().equals("GetDeclaringClass")) {
+                            Class clazz2 = Class.forName("GetDeclaringClass_a");
+                            if (clazz2.getDeclaringClass() == null) {
+                                num++;
+                            }
+                        }
+                    }
+                }
+            }
+            if (num == 12) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/expected.txt b/testsuite/java_test/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/test.cfg b/testsuite/java_test/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5555ab58e841a7b7b136117b043197cd0e766453
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0044-rt-reflection-ReflectiongetDeclaringClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetDeclaringClass)
+run(ReflectionGetDeclaringClass)
diff --git a/testsuite/java_test/reflection_test/RT0045-rt-reflection-ReflectiongetEnclosingClass1/ReflectionGetEnclosingClass1.java b/testsuite/java_test/reflection_test/RT0045-rt-reflection-ReflectiongetEnclosingClass1/ReflectionGetEnclosingClass1.java
new file mode 100755
index 0000000000000000000000000000000000000000..5bf3a8784910fd28de1c0916e150b5cf8d9f2c7a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0045-rt-reflection-ReflectiongetEnclosingClass1/ReflectionGetEnclosingClass1.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionGetEnclosingClass1 {
+    public static void main(String[] args) {
+        Class clazz1 = (new GetEnclosingClassTest1()).test1().getClass();
+        Class clazz2 = (new GetEnclosingClassTest1()).test2().getClass();
+        if (clazz1.getEnclosingClass().getName().equals("ReflectionGetEnclosingClass1$GetEnclosingClassTest1")
+                && clazz2.getEnclosingClass().getName().equals("ReflectionGetEnclosingClass1$GetEnclosingClassTest1")) {
+            System.out.println(0);
+        }
+    }
+    public static class GetEnclosingClassTest1 {
+        public Object test1() {
+            class classA {
+            }
+            return new classA();
+        }
+        Object test2() {
+            class classB {
+            }
+            return new classB();
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0045-rt-reflection-ReflectiongetEnclosingClass1/expected.txt b/testsuite/java_test/reflection_test/RT0045-rt-reflection-ReflectiongetEnclosingClass1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0045-rt-reflection-ReflectiongetEnclosingClass1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0045-rt-reflection-ReflectiongetEnclosingClass1/test.cfg b/testsuite/java_test/reflection_test/RT0045-rt-reflection-ReflectiongetEnclosingClass1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd6e544817050e3d7e2bd0c392941913b9bb951e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0045-rt-reflection-ReflectiongetEnclosingClass1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetEnclosingClass1)
+run(ReflectionGetEnclosingClass1)
diff --git a/testsuite/java_test/reflection_test/RT0046-rt-reflection-ReflectiongetEnclosingClass2/ReflectionGetEnclosingClass2.java b/testsuite/java_test/reflection_test/RT0046-rt-reflection-ReflectiongetEnclosingClass2/ReflectionGetEnclosingClass2.java
new file mode 100755
index 0000000000000000000000000000000000000000..dadfd167102437adecf3cf7ca6a5cf13e1641e35
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0046-rt-reflection-ReflectiongetEnclosingClass2/ReflectionGetEnclosingClass2.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class GetEnclosingClassTest2 {
+    public Object test1() {
+        class classA {
+        }
+        return new classA();
+    }
+    Object test2() {
+        class classB {
+        }
+        return new classB();
+    }
+}
+public class ReflectionGetEnclosingClass2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetEnclosingClassTest2");
+            Class clazz2 = (new GetEnclosingClassTest2()).test2().getClass();
+            if (clazz1.getEnclosingClass() == null
+                    && clazz2.getEnclosingClass().getName().equals("GetEnclosingClassTest2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0046-rt-reflection-ReflectiongetEnclosingClass2/expected.txt b/testsuite/java_test/reflection_test/RT0046-rt-reflection-ReflectiongetEnclosingClass2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0046-rt-reflection-ReflectiongetEnclosingClass2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0046-rt-reflection-ReflectiongetEnclosingClass2/test.cfg b/testsuite/java_test/reflection_test/RT0046-rt-reflection-ReflectiongetEnclosingClass2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..41264be065f527fd67fbda41661d0647d303bc88
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0046-rt-reflection-ReflectiongetEnclosingClass2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetEnclosingClass2)
+run(ReflectionGetEnclosingClass2)
diff --git a/testsuite/java_test/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java b/testsuite/java_test/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java
new file mode 100755
index 0000000000000000000000000000000000000000..c561df9dc126cb4012b1141961be9edddfaeb261
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/ReflectionGetEnumConstants.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+enum Weekday {
+    MONDAY {
+        Object test1() {
+            class classA {
+            }
+            return new classA();
+        }
+    },
+    TUESDAY {
+        Object test2() {
+            class classB {
+            }
+            return new classB();
+        }
+    },
+    WEDNESDAY {
+        Object test3() {
+            class classC {
+            }
+            return new classC();
+        }
+    },
+    THURSDAY {
+        Object test4() {
+            class classD {
+            }
+            return new classD();
+        }
+    },
+    FRIDAY {
+        Object test5() {
+            class classE {
+            }
+            return new classE();
+        }
+    },
+    SATURDAY {
+        Object test6() {
+            class classF {
+            }
+            return new classF();
+        }
+    },
+    SUNDAY {
+        Object test7() {
+            class classG {
+            }
+            return new classG();
+        }
+    }
+}
+class GetEnumConstants {
+}
+public class ReflectionGetEnumConstants {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("Weekday");
+            Class clazz2 = Class.forName("GetEnumConstants");
+            Object[] objects1 = clazz1.getEnumConstants();
+            Object[] objects2 = clazz2.getEnumConstants();
+            if (objects1.length == 7) {
+                if (objects2 == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/expected.txt b/testsuite/java_test/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/test.cfg b/testsuite/java_test/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4f1d747cdabf13f243f205bbc1113c7ceb56a0b6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0047-rt-reflection-ReflectiongetEnumConstants/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetEnumConstants)
+run(ReflectionGetEnumConstants)
diff --git a/testsuite/java_test/reflection_test/RT0048-rt-reflection-ReflectiongetField1/ReflectionGetField1.java b/testsuite/java_test/reflection_test/RT0048-rt-reflection-ReflectiongetField1/ReflectionGetField1.java
new file mode 100755
index 0000000000000000000000000000000000000000..2d4a2d2e42b8431745981ed7ef95cb475a079649
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0048-rt-reflection-ReflectiongetField1/ReflectionGetField1.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetField1_a {
+    int num2 = 5;
+    public String str = "bbb";
+}
+class GetField1 extends GetField1_a {
+    public int num = 1;
+    String string = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+public class ReflectionGetField1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetField1");
+            Field field1 = clazz.getField("num");
+            Field field2 = clazz.getField("str");
+            if (field1.getName().equals("num") && field2.getName().equals("str")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0048-rt-reflection-ReflectiongetField1/expected.txt b/testsuite/java_test/reflection_test/RT0048-rt-reflection-ReflectiongetField1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0048-rt-reflection-ReflectiongetField1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0048-rt-reflection-ReflectiongetField1/test.cfg b/testsuite/java_test/reflection_test/RT0048-rt-reflection-ReflectiongetField1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..84acf80dc0c426c8221f34a64bbe9001ac5e2165
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0048-rt-reflection-ReflectiongetField1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetField1)
+run(ReflectionGetField1)
diff --git a/testsuite/java_test/reflection_test/RT0049-rt-reflection-ReflectiongetField2/ReflectionGetField2.java b/testsuite/java_test/reflection_test/RT0049-rt-reflection-ReflectiongetField2/ReflectionGetField2.java
new file mode 100755
index 0000000000000000000000000000000000000000..1a88f63c3f37a8ad058669963afc753b91d41959
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0049-rt-reflection-ReflectiongetField2/ReflectionGetField2.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetField2_a {
+    int num = 5;
+    public String str = "bbb";
+}
+class GetField2 extends GetField2_a {
+    public int num = 1;
+    String str2 = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+public class ReflectionGetField2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetField2");
+            Field field1 = clazz1.getField("str2");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            try {
+                Class clazz2 = Class.forName("GetField2");
+                Field field2 = clazz2.getField(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchFieldException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0049-rt-reflection-ReflectiongetField2/expected.txt b/testsuite/java_test/reflection_test/RT0049-rt-reflection-ReflectiongetField2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0049-rt-reflection-ReflectiongetField2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0049-rt-reflection-ReflectiongetField2/test.cfg b/testsuite/java_test/reflection_test/RT0049-rt-reflection-ReflectiongetField2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..623369a4ee90461c04fec1486b1bcd637b7e224c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0049-rt-reflection-ReflectiongetField2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetField2)
+run(ReflectionGetField2)
diff --git a/testsuite/java_test/reflection_test/RT0050-rt-reflection-ReflectiongetFields/ReflectionGetFields.java b/testsuite/java_test/reflection_test/RT0050-rt-reflection-ReflectiongetFields/ReflectionGetFields.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f41236c96a36d9a7502ea74a732fb759bad9ce6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0050-rt-reflection-ReflectiongetFields/ReflectionGetFields.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class GetFields_a {
+    public int num = 5;
+    String str = "bbb";
+}
+class GetFields extends GetFields_a {
+    public int num = 1;
+    String str = "aaa";
+    private double dNum = 2.5;
+    protected float fNum = -222;
+}
+interface GetFields_b {
+    public int num = 2;
+    String str = "ccc";
+}
+class GetFields_c {
+}
+public class ReflectionGetFields {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetFields");
+            Class clazz2 = Class.forName("GetFields_b");
+            Class clazz3 = Class.forName("GetFields_c");
+            Field[] fields1 = clazz1.getFields();
+            Field[] fields2 = clazz2.getFields();
+            Field[] fields3 = clazz3.getFields();
+            if (fields1.length == 2 && fields2.length == 2 && fields3.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0050-rt-reflection-ReflectiongetFields/expected.txt b/testsuite/java_test/reflection_test/RT0050-rt-reflection-ReflectiongetFields/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0050-rt-reflection-ReflectiongetFields/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0050-rt-reflection-ReflectiongetFields/test.cfg b/testsuite/java_test/reflection_test/RT0050-rt-reflection-ReflectiongetFields/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c14243b075c0923bc5e9b7d1a7f02dae34aa1963
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0050-rt-reflection-ReflectiongetFields/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetFields)
+run(ReflectionGetFields)
diff --git a/testsuite/java_test/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/ReflectionGetMethod1.java b/testsuite/java_test/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/ReflectionGetMethod1.java
new file mode 100755
index 0000000000000000000000000000000000000000..7425d77471291ce5e31d9b7e2309f6ba6c4040b6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/ReflectionGetMethod1.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetMethod1_a {
+    public int setName(String name) {
+        return 10;
+    }
+    public String getStr() {
+        return "getDda";
+    }
+}
+class GetMethod1 extends GetMethod1_a {
+    public void empty() {
+    }
+    void emptyB() {
+    }
+    int getNum() {
+        return 0;
+    }
+    private String getDd() {
+        return "getDd";
+    }
+    public void empty(int number) {
+    }
+    int getNum(String name) {
+        return 2;
+    }
+}
+public class ReflectionGetMethod1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetMethod1");
+            Method method1 = clazz.getMethod("empty");
+            Method method2 = clazz.getMethod("empty", int.class);
+            Method method3 = clazz.getMethod("setName", String.class);
+            Method method4 = clazz.getMethod("getStr");
+            if (method1.toString().equals("public void GetMethod1.empty()")
+                    && method2.toString().equals("public void GetMethod1.empty(int)")
+                    && method3.toString().equals("public int GetMethod1_a.setName(java.lang.String)")
+                    && method4.toString().equals("public java.lang.String GetMethod1_a.getStr()")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/expected.txt b/testsuite/java_test/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/test.cfg b/testsuite/java_test/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d1b4d987bbfd22cb854bc4a5f50121dd4566066
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0051-rt-reflection-ReflectiongetMethod1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetMethod1)
+run(ReflectionGetMethod1)
diff --git a/testsuite/java_test/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/ReflectionGetMethod2.java b/testsuite/java_test/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/ReflectionGetMethod2.java
new file mode 100755
index 0000000000000000000000000000000000000000..b293eef75e27879dc7c9e5c107b1a30dc3352aa1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/ReflectionGetMethod2.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class GetMethod2_a {
+    public int getName(String name) {
+        return 10;
+    }
+    public String getString() {
+        return "dda";
+    }
+}
+class GetMethod2 extends GetMethod2_a {
+    public void getVoid() {
+    }
+    void empty() {
+    }
+    int getZero() {
+        return 0;
+    }
+    private String getStr() {
+        return "dd";
+    }
+    public void setNum(int number) {
+    }
+    int getSecondNum(String name) {
+        return 2;
+    }
+}
+public class ReflectionGetMethod2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetMethod2");
+            Method method1 = clazz1.getMethod("empty");
+            System.out.println(2);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            // NoSuchMethodException is thrown when method not exist.
+            try {
+                Class clazz2 = Class.forName("GetMethod2");
+                Method method2 = clazz2.getMethod(null);
+                System.out.println(2);
+            } catch (ClassNotFoundException e4) {
+                System.err.println(e4);
+                System.out.println(2);
+            } catch (NoSuchMethodException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (NullPointerException e6) {
+                // Expected result: NullPointerException is thrown when method is null.
+                System.out.println(0);
+            }
+        } catch (NullPointerException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/expected.txt b/testsuite/java_test/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/test.cfg b/testsuite/java_test/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c8bd7ac97a63b007d2398cf4d90126643be71e0
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0052-rt-reflection-ReflectiongetMethod2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetMethod2)
+run(ReflectionGetMethod2)
diff --git a/testsuite/java_test/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/ReflectionGetSigners.java b/testsuite/java_test/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/ReflectionGetSigners.java
new file mode 100755
index 0000000000000000000000000000000000000000..a34d0ca76e12c0ade80b76e83728d1a8108d296c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/ReflectionGetSigners.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class GetSigners {
+}
+public class ReflectionGetSigners {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetSigners");
+            Object[] objects = clazz.getSigners();
+            if (objects == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/expected.txt b/testsuite/java_test/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/test.cfg b/testsuite/java_test/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ec7f078485d2adf793e030d022b22348e5c9d0db
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0053-rt-reflection-ReflectiongetSigners/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetSigners)
+run(ReflectionGetSigners)
diff --git a/testsuite/java_test/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/ReflectionGetSimpleName.java b/testsuite/java_test/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/ReflectionGetSimpleName.java
new file mode 100755
index 0000000000000000000000000000000000000000..d1a3ee1486078b0e70427035b70985549c467015
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/ReflectionGetSimpleName.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class GetSimpleName {
+}
+public class ReflectionGetSimpleName {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetSimpleName");
+            String string = clazz.getSimpleName();
+            if (string.equals("GetSimpleName")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/expected.txt b/testsuite/java_test/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/test.cfg b/testsuite/java_test/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2e1b172f63dc2719d81babb429116e77e6a4969c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0054-rt-reflection-ReflectiongetSimpleName/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetSimpleName)
+run(ReflectionGetSimpleName)
diff --git a/testsuite/java_test/reflection_test/RT0055-rt-reflection-ReflectiongetTypeParameters/ReflectionGetTypeParameters.java b/testsuite/java_test/reflection_test/RT0055-rt-reflection-ReflectiongetTypeParameters/ReflectionGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..dac2c7b001091e5f248442a0d2becaad15585171
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0055-rt-reflection-ReflectiongetTypeParameters/ReflectionGetTypeParameters.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.TypeVariable;
+class GetTypeParameters<s, T> {
+}
+public class ReflectionGetTypeParameters {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("GetTypeParameters");
+            TypeVariable[] typeParameters = clazz.getTypeParameters();
+            if (typeParameters.length == 2 && typeParameters[0].getName().equals("s")
+                    && typeParameters[1].getName().equals("T")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0055-rt-reflection-ReflectiongetTypeParameters/expected.txt b/testsuite/java_test/reflection_test/RT0055-rt-reflection-ReflectiongetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0055-rt-reflection-ReflectiongetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0055-rt-reflection-ReflectiongetTypeParameters/test.cfg b/testsuite/java_test/reflection_test/RT0055-rt-reflection-ReflectiongetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7bf45370b3c138d07f472eb6c734fe6cd5e2c367
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0055-rt-reflection-ReflectiongetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetTypeParameters)
+run(ReflectionGetTypeParameters)
diff --git a/testsuite/java_test/reflection_test/RT0056-rt-reflection-ReflectionisArray/ReflectionIsArray.java b/testsuite/java_test/reflection_test/RT0056-rt-reflection-ReflectionisArray/ReflectionIsArray.java
new file mode 100755
index 0000000000000000000000000000000000000000..d7a167bacada422fffb61036f2cd8080240cf634
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0056-rt-reflection-ReflectionisArray/ReflectionIsArray.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class IsArray {
+    public int num;
+    String str;
+    float fNum;
+}
+public class ReflectionIsArray {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("IsArray");
+            Field[] fields = clazz.getDeclaredFields();
+            Class clazz1 = fields.getClass();
+            if (clazz1.isArray()) {
+                if (!clazz.isArray()) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0056-rt-reflection-ReflectionisArray/expected.txt b/testsuite/java_test/reflection_test/RT0056-rt-reflection-ReflectionisArray/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0056-rt-reflection-ReflectionisArray/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0056-rt-reflection-ReflectionisArray/test.cfg b/testsuite/java_test/reflection_test/RT0056-rt-reflection-ReflectionisArray/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e394d5efb9f3041b988159e9d88f2a240454d9b7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0056-rt-reflection-ReflectionisArray/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsArray)
+run(ReflectionIsArray)
diff --git a/testsuite/java_test/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java b/testsuite/java_test/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java
new file mode 100755
index 0000000000000000000000000000000000000000..c5e25eeb987b608f92d6d313be4eba3aebecbad4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/ReflectionIsAssignableFrom1.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class AssignableFrom1 {
+}
+class AssignableFrom1_a extends AssignableFrom1 {
+}
+interface AssignableFromTest1 {
+}
+interface AssignableFromTest1_a extends AssignableFromTest1 {
+}
+public class ReflectionIsAssignableFrom1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("AssignableFrom1");
+            Class clazz2 = Class.forName("AssignableFrom1_a");
+            Class clazz3 = Class.forName("AssignableFromTest1");
+            Class clazz4 = Class.forName("AssignableFromTest1_a");
+            if (clazz1.isAssignableFrom(clazz2) && !clazz2.isAssignableFrom(clazz1) && clazz3.isAssignableFrom(clazz4)
+                    && !clazz4.isAssignableFrom(clazz3)) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/expected.txt b/testsuite/java_test/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/test.cfg b/testsuite/java_test/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..baffcdd8bac1781e70fbb8ebab0c3d217ff56c6b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0057-rt-reflection-ReflectionisAssignableFrom1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsAssignableFrom1)
+run(ReflectionIsAssignableFrom1)
diff --git a/testsuite/java_test/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java b/testsuite/java_test/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java
new file mode 100755
index 0000000000000000000000000000000000000000..30fd5cfc047c806e973926848ceaded70b8fc86d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/ReflectionIsAssignableFromNullPointerException.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class AssignableFromNullPointerException {
+}
+public class ReflectionIsAssignableFromNullPointerException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("AssignableFromNullPointerException");
+            zqp1.isAssignableFrom(null);
+            result = -1;
+        } catch (ClassNotFoundException e1) {
+            result = -1;
+        } catch (NullPointerException e2) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/expected.txt b/testsuite/java_test/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/test.cfg b/testsuite/java_test/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f1532263804f3e0d733ca881e3647ecf285a4b56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0058-rt-reflection-ReflectionisAssignableFrom2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsAssignableFromNullPointerException)
+run(ReflectionIsAssignableFromNullPointerException)
diff --git a/testsuite/java_test/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/ReflectionIsLocalClass.java b/testsuite/java_test/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/ReflectionIsLocalClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..bf3a9cf69e65046e02313808d99c5b1978f854ab
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/ReflectionIsLocalClass.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionIsLocalClass {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        class isLocalClass {
+        }
+        try {
+            Class zqp1 = isLocalClass.class;
+            Class zqp2 = Class.forName("ReflectionIsLocalClass");
+            Class zqp3 = IsLocalClass_a.class;
+            Class zqp4 = IsLocalClass_b.class;
+            Class zqp5 = (new isLocalClass() {
+            }).getClass();
+            if (!zqp2.isLocalClass()) {
+                if (!zqp3.isLocalClass()) {
+                    if (!zqp4.isLocalClass()) {
+                        if (!zqp5.isLocalClass()) {
+                            if (zqp1.isLocalClass()) {
+                                result = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = 2;
+        }
+        System.out.println(result);
+    }
+    class IsLocalClass_a {
+    }
+    static class IsLocalClass_b {
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/expected.txt b/testsuite/java_test/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/test.cfg b/testsuite/java_test/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a62a8fad4d8141ac022dee5d815098e01f670f41
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0059-rt-reflection-ReflectionisLocalClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsLocalClass)
+run(ReflectionIsLocalClass)
diff --git a/testsuite/java_test/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/ReflectionIsMemberClass.java b/testsuite/java_test/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/ReflectionIsMemberClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..915854531ccf695b5a1a8818f756c4260c5f8359
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/ReflectionIsMemberClass.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionIsMemberClass {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        class IsMemberClass_a {
+        }
+        try {
+            Class zqp1 = IsMemberClass.class;
+            Class zqp2 = Class.forName("ReflectionIsMemberClass");
+            Class zqp3 = IsMemberClass_a.class;
+            Class zqp4 = IsMemberClass_b.class;
+            Class zqp5 = (new IsMemberClass_b() {
+            }).getClass();
+            if (!zqp2.isMemberClass()) {
+                if (!zqp3.isMemberClass()) {
+                    if (zqp4.isMemberClass()) {
+                        if (!zqp5.isMemberClass()) {
+                            if (zqp1.isMemberClass()) {
+                                result = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+    class IsMemberClass {
+    }
+    static class IsMemberClass_b {
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/expected.txt b/testsuite/java_test/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/test.cfg b/testsuite/java_test/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..059b9c6a50bca10d682dc16df52c16b519b4555e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0060-rt-reflection-ReflectionisMemberClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsMemberClass)
+run(ReflectionIsMemberClass)
diff --git a/testsuite/java_test/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/ReflectionIsPrimitive.java b/testsuite/java_test/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/ReflectionIsPrimitive.java
new file mode 100755
index 0000000000000000000000000000000000000000..90ef71d5c7c0e380843fea3560a34d1f61e44ef2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/ReflectionIsPrimitive.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionIsPrimitive {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        Class zqp1 = ReflectionIsPrimitive.class;
+        Class zqp2 = int.class;
+        Class zqp3 = boolean.class;
+        Class zqp4 = byte.class;
+        Class zqp5 = char.class;
+        Class zqp6 = short.class;
+        Class zqp7 = long.class;
+        Class zqp8 = float.class;
+        Class zqp9 = double.class;
+        Class zqp10 = void.class;
+        if (!zqp1.isPrimitive() && zqp2.isPrimitive() && zqp3.isPrimitive() && zqp4.isPrimitive() && zqp5.isPrimitive()
+                && zqp6.isPrimitive() && zqp7.isPrimitive() && zqp8.isPrimitive() && zqp9.isPrimitive() &&
+                zqp10.isPrimitive()) {
+            result = 0;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/expected.txt b/testsuite/java_test/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/test.cfg b/testsuite/java_test/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a36146eb8d5be1a2e45a6f5206f1f07878a6c2e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0061-rt-reflection-ReflectionisPrimitive/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsPrimitive)
+run(ReflectionIsPrimitive)
diff --git a/testsuite/java_test/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/ReflectionIsSynthetic.java b/testsuite/java_test/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/ReflectionIsSynthetic.java
new file mode 100755
index 0000000000000000000000000000000000000000..07ce874047f3af7b33bbc20cd86130d28f975b26
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/ReflectionIsSynthetic.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ReflectionIsSynthetic {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        new IsSynthetic();
+        try {
+            Class zqp1 = IsSynthetic.class;
+            Class zqp2 = int.class;
+            Class zqp3 = Class.forName("ReflectionIsSynthetic$1");
+            if (!zqp2.isSynthetic()) {
+                if (!zqp1.isSynthetic()) {
+                    if (zqp3.isSynthetic()) {
+                        result = 0;
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+    private static class IsSynthetic {
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/expected.txt b/testsuite/java_test/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/test.cfg b/testsuite/java_test/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ae536c99a1b846c5f978c388170599fb04710743
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0062-rt-reflection-ReflectionisSynthetic/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionIsSynthetic)
+run(ReflectionIsSynthetic)
diff --git a/testsuite/java_test/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/ReflectionNewInstance1.java b/testsuite/java_test/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/ReflectionNewInstance1.java
new file mode 100755
index 0000000000000000000000000000000000000000..9b78860e8bca8e564ed370ab0b1a21c642a9b410
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/ReflectionNewInstance1.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class NewInstance1 {
+}
+public class ReflectionNewInstance1 {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("NewInstance1");
+            Object zhu = zqp.newInstance();
+            if (zhu.toString().indexOf("NewInstance1@") != -1) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+            result = -1;
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/expected.txt b/testsuite/java_test/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/test.cfg b/testsuite/java_test/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..81422d607c0cc1577019e7fb001692205bf212c8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0063-rt-reflection-ReflectionnewInstance1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionNewInstance1)
+run(ReflectionNewInstance1)
diff --git a/testsuite/java_test/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java b/testsuite/java_test/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
new file mode 100755
index 0000000000000000000000000000000000000000..e1eaf39faa50ab6670bde33eb6fccd18c013130a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+interface NewInstance2 {
+}
+class NewInstance2_a {
+    private NewInstance2_a() {
+    }
+}
+public class ReflectionNewInstanceInstantiationExceptionIllegalAccessException {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp1 = Class.forName("NewInstance2");
+            Object zhu1 = zqp1.newInstance();
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            result = -1;
+        } catch (InstantiationException e1) {
+            try {
+                Class zqp2 = Class.forName("NewInstance2_a");
+                Object zhu2 = zqp2.newInstance();
+            } catch (ClassNotFoundException e3) {
+                System.err.println(e3);
+                result = -1;
+            } catch (InstantiationException e4) {
+                System.err.println(e4);
+                result = -1;
+            } catch (IllegalAccessException e5) {
+                result = 0;
+            }
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/expected.txt b/testsuite/java_test/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/test.cfg b/testsuite/java_test/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8177d6f3259f5eb30d5c11e21430d8d47648d996
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0064-rt-reflection-ReflectionnewInstance2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionNewInstanceInstantiationExceptionIllegalAccessException)
+run(ReflectionNewInstanceInstantiationExceptionIllegalAccessException)
diff --git a/testsuite/java_test/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/ReflectionToGenericString.java b/testsuite/java_test/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/ReflectionToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..89c1e6d8cede6c98b56a07f938bc0c4e6f8bc027
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/ReflectionToGenericString.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+@interface Eee {
+}
+@Eee
+abstract class ToGenericString<t> {
+}
+public class ReflectionToGenericString {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("ToGenericString");
+            String zhu = zqp.toGenericString();
+            if (zhu.equals("abstract class ToGenericString<t>")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/expected.txt b/testsuite/java_test/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/test.cfg b/testsuite/java_test/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d634a9ec1b268adb47cf7f75a8abf8292ab305ac
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0065-rt-reflection-ReflectiontoGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionToGenericString)
+run(ReflectionToGenericString)
diff --git a/testsuite/java_test/reflection_test/RT0066-rt-reflection-ReflectiontoString/ReflectionToString.java b/testsuite/java_test/reflection_test/RT0066-rt-reflection-ReflectiontoString/ReflectionToString.java
new file mode 100755
index 0000000000000000000000000000000000000000..9049254b592ca3a3256cd07187e773cd3985f182
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0066-rt-reflection-ReflectiontoString/ReflectionToString.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+@interface Fff {
+}
+@Fff
+abstract class ToString_$<t> {
+}
+public class ReflectionToString {
+    public static void main(String[] args) {
+        int result = 0; /* STATUS_Success*/
+
+        try {
+            Class zqp = Class.forName("ToString_$");
+            String zhu = zqp.toString();
+            if (zhu.equals("class ToString_$")) {
+                result = 0;
+            }
+        } catch (ClassNotFoundException e) {
+            result = -1;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0066-rt-reflection-ReflectiontoString/expected.txt b/testsuite/java_test/reflection_test/RT0066-rt-reflection-ReflectiontoString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0066-rt-reflection-ReflectiontoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0066-rt-reflection-ReflectiontoString/test.cfg b/testsuite/java_test/reflection_test/RT0066-rt-reflection-ReflectiontoString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9efdf9adbad0c5b375455b3c9f1fc59a6eb93189
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0066-rt-reflection-ReflectiontoString/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionToString)
+run(ReflectionToString)
diff --git a/testsuite/java_test/reflection_test/RT0067-rt-reflection-RTConstructorgetAnnotation1/RTConstructorGetAnnotation1.java b/testsuite/java_test/reflection_test/RT0067-rt-reflection-RTConstructorgetAnnotation1/RTConstructorGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..8a81e2eb0ad7e8975ba31bf361565847446457fc
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0067-rt-reflection-RTConstructorgetAnnotation1/RTConstructorGetAnnotation1.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Www1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Www1_a {
+    int c() default 0;
+    String d() default "";
+}
+class ConstructorGetAnnotation1 {
+    @Www1(i = 333, t = "ConstructorgetAnnotation")
+    public ConstructorGetAnnotation1() {
+    }
+    public ConstructorGetAnnotation1(String name) {
+    }
+    @Www1_a(c = 666, d = "Constructor")
+    ConstructorGetAnnotation1(int number) {
+    }
+    ConstructorGetAnnotation1(String name, int number) {
+    }
+}
+public class RTConstructorGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class zqp = Class.forName("ConstructorGetAnnotation1");
+            Constructor zhu1 = zqp.getDeclaredConstructor(int.class);
+            Constructor zhu2 = zqp.getConstructor();
+            Constructor zhu3 = zqp.getConstructor(String.class);
+            if ((zhu1.getAnnotation(Www1_a.class).toString().indexOf("c=666") != -1 &&
+                    zhu1.getAnnotation(Www1_a.class).toString().indexOf("d=Constructor") != -1 &&
+                    zhu2.getAnnotation(Www1.class).toString().indexOf("i=333") != -1 &&
+                    zhu2.getAnnotation(Www1.class).toString().indexOf("t=ConstructorgetAnnotation") != -1)) {
+                if (zhu3.getAnnotation(Www1.class) == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0067-rt-reflection-RTConstructorgetAnnotation1/expected.txt b/testsuite/java_test/reflection_test/RT0067-rt-reflection-RTConstructorgetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0067-rt-reflection-RTConstructorgetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0067-rt-reflection-RTConstructorgetAnnotation1/test.cfg b/testsuite/java_test/reflection_test/RT0067-rt-reflection-RTConstructorgetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0288a9ece4c3c7106c9fab0e33fa0f31e88fb738
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0067-rt-reflection-RTConstructorgetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetAnnotation1)
+run(RTConstructorGetAnnotation1)
diff --git a/testsuite/java_test/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java b/testsuite/java_test/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..0959d2a9f6bc9aabe53c40650d4f99be8c5a8779
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/RTConstructorGetAnnotation2.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+class ConstructorGetAnnotation2 {
+    @IF2(i = 333, t = "ConstructorGetAnnotation")
+    public ConstructorGetAnnotation2() {
+    }
+    @IF2_a(c = 666, d = "Constructor")
+    ConstructorGetAnnotation2(int number) {
+    }
+}
+class ConstructorGetAnnotation2_a {
+    ConstructorGetAnnotation2_a(String name, int number) {
+    }
+}
+public class RTConstructorGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetAnnotation2");
+            Constructor instance1 = cls.getDeclaredConstructor(int.class);
+            Constructor instance2 = cls.getConstructor();
+            if (instance1.getAnnotation(IF2.class) == null && instance2.getAnnotation(IF2_a.class) == null) {
+                instance1.getAnnotation(IF2.class).toString();
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(1);
+            return;
+        } catch (NullPointerException e3) {
+            try {
+                Class cls = Class.forName("ConstructorGetAnnotation2_a");
+                Constructor instance3 = cls.getDeclaredConstructor(String.class, int.class);
+                if (instance3.getAnnotation(IF2.class) == null && instance3.getAnnotation(IF2_a.class) == null) {
+                    instance3.getAnnotation(IF2.class).toString();
+                }
+                System.out.println(1);
+                return;
+            } catch (ClassNotFoundException e4) {
+                System.out.println(2);
+                return;
+            } catch (NoSuchMethodException e5) {
+                System.out.println(3);
+                return;
+            } catch (NullPointerException e6) {
+                System.out.println(0);
+                return;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/expected.txt b/testsuite/java_test/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/test.cfg b/testsuite/java_test/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3d083ec105646fbb384186edfdb83daa22ac168
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0068-rt-reflection-RTConstructorgetAnnotation2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetAnnotation2)
+run(RTConstructorGetAnnotation2)
diff --git a/testsuite/java_test/reflection_test/RT0069-rt-reflection-RTConstructorgetDeclaredAnnotations1/RTConstructorGetDeclaredAnnotations1.java b/testsuite/java_test/reflection_test/RT0069-rt-reflection-RTConstructorgetDeclaredAnnotations1/RTConstructorGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..00cc679061f8c2ac8da6d651c7a9e038c2ffb90c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0069-rt-reflection-RTConstructorgetDeclaredAnnotations1/RTConstructorGetDeclaredAnnotations1.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class ConstructorGetDeclaredAnnotations1 {
+    public ConstructorGetDeclaredAnnotations1() {
+    }
+    @IF1(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations1(String name) {
+    }
+    @IF1(i = 333, t = "test1")
+    ConstructorGetDeclaredAnnotations1(int number) {
+    }
+}
+class ConstructorGetDeclaredAnnotations1_a extends ConstructorGetDeclaredAnnotations1 {
+    @IF1_a(i_a = 666, t_a = "right1")
+    @IF1(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations1_a(String name) {
+    }
+    @IF1_a(i_a = 666, t_a = "right1")
+    ConstructorGetDeclaredAnnotations1_a(int number) {
+    }
+}
+public class RTConstructorGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetDeclaredAnnotations1_a");
+            Constructor instance1 = cls.getConstructor(String.class);
+            if (instance1.getDeclaredAnnotations().length == 2) {
+                Constructor instance2 = cls.getDeclaredConstructor(int.class);
+                if (instance2.getDeclaredAnnotations().length == 1) {
+                    Annotation[] j = instance2.getDeclaredAnnotations();
+                    if (j[0].toString().indexOf("i_a=666") != -1 && j[0].toString().indexOf("t_a=right1") != -1) {
+                        System.out.println(0);
+                        return;
+                    }
+                }
+                System.out.println(1);
+                return;
+            }
+            System.out.println(2);
+            return;
+        } catch (ClassNotFoundException e) {
+            System.out.println(3);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(4);
+            return;
+        } catch (NullPointerException e2) {
+            System.out.println(5);
+            return;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0069-rt-reflection-RTConstructorgetDeclaredAnnotations1/expected.txt b/testsuite/java_test/reflection_test/RT0069-rt-reflection-RTConstructorgetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0069-rt-reflection-RTConstructorgetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0069-rt-reflection-RTConstructorgetDeclaredAnnotations1/test.cfg b/testsuite/java_test/reflection_test/RT0069-rt-reflection-RTConstructorgetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b4ffbb7fa2d6dc6de2346ceb074977494da4f516
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0069-rt-reflection-RTConstructorgetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetDeclaredAnnotations1)
+run(RTConstructorGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java b/testsuite/java_test/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..698ecec98de67d37e475fba56fd76263e3761691
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/RTConstructorGetDeclaredAnnotations2.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class ConstructorGetDeclaredAnnotations2 {
+    public ConstructorGetDeclaredAnnotations2() {
+    }
+    @IF2(i = 333, t = "test1")
+    public ConstructorGetDeclaredAnnotations2(String name) {
+    }
+    @IF2(i = 333, t = "test1")
+    ConstructorGetDeclaredAnnotations2(int number) {
+    }
+}
+class ConstructorGetDeclaredAnnotations2_a extends ConstructorGetDeclaredAnnotations2 {
+    public ConstructorGetDeclaredAnnotations2_a(String name) {
+    }
+    ConstructorGetDeclaredAnnotations2_a(int number) {
+    }
+}
+public class RTConstructorGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetDeclaredAnnotations2_a");
+            Constructor instance1 = cls.getConstructor(String.class);
+            Constructor instance2 = cls.getDeclaredConstructor(int.class);
+            if (instance1.getDeclaredAnnotations().length == 0 && instance2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        } catch (NullPointerException e2) {
+            System.out.println(4);
+            return;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/expected.txt b/testsuite/java_test/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/test.cfg b/testsuite/java_test/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b7763007e500a539b5b403aae2768f02595568af
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetDeclaredAnnotations2)
+run(RTConstructorGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/reflection_test/RT0071-rt-reflection-RTConstructorgetExceptionTypes/RTConstructorGetExceptionTypes.java b/testsuite/java_test/reflection_test/RT0071-rt-reflection-RTConstructorgetExceptionTypes/RTConstructorGetExceptionTypes.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f33f8e2c81ecb85ac577db566359de9a8e47735
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0071-rt-reflection-RTConstructorgetExceptionTypes/RTConstructorGetExceptionTypes.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class ConstructorGetExceptionTypes {
+    ConstructorGetExceptionTypes() throws ExceptionInInitializerError, InstantiationException {
+    }
+}
+public class RTConstructorGetExceptionTypes {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetExceptionTypes");
+            Constructor cons = cls.getDeclaredConstructor();
+            Class<?>[] exClass = cons.getExceptionTypes();
+            if (exClass.length == 2) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(3);
+            return;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0071-rt-reflection-RTConstructorgetExceptionTypes/expected.txt b/testsuite/java_test/reflection_test/RT0071-rt-reflection-RTConstructorgetExceptionTypes/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0071-rt-reflection-RTConstructorgetExceptionTypes/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0071-rt-reflection-RTConstructorgetExceptionTypes/test.cfg b/testsuite/java_test/reflection_test/RT0071-rt-reflection-RTConstructorgetExceptionTypes/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..28cfff70c27fdc9fe6aefcf916df16ec15625e25
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0071-rt-reflection-RTConstructorgetExceptionTypes/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetExceptionTypes)
+run(RTConstructorGetExceptionTypes)
diff --git a/testsuite/java_test/reflection_test/RT0072-rt-reflection-RTConstructorgetTypeParameters/RTConstructorGetTypeParameters.java b/testsuite/java_test/reflection_test/RT0072-rt-reflection-RTConstructorgetTypeParameters/RTConstructorGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..4d9cc4026377580d40a30e19d9c4bad5165f8cb3
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0072-rt-reflection-RTConstructorgetTypeParameters/RTConstructorGetTypeParameters.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.TypeVariable;
+class ConstructorGetTypeParameters {
+    public <t, s, d, f, g> ConstructorGetTypeParameters(int number) {
+    }
+    ConstructorGetTypeParameters() {
+    }
+}
+public class RTConstructorGetTypeParameters {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorGetTypeParameters");
+            Constructor instance1 = cls.getConstructor(int.class);
+            Constructor instance2 = cls.getDeclaredConstructor();
+            TypeVariable[] q1 = instance1.getTypeParameters();
+            TypeVariable[] q2 = instance2.getTypeParameters();
+            if (q1.length == 5 && q2.length == 0) {
+                System.out.println(0);
+                return;
+            }
+            System.out.println(1);
+            return;
+        } catch (ClassNotFoundException e1) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(3);
+            return;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0072-rt-reflection-RTConstructorgetTypeParameters/expected.txt b/testsuite/java_test/reflection_test/RT0072-rt-reflection-RTConstructorgetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0072-rt-reflection-RTConstructorgetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0072-rt-reflection-RTConstructorgetTypeParameters/test.cfg b/testsuite/java_test/reflection_test/RT0072-rt-reflection-RTConstructorgetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e123110e3b2f21d6013e9995dfde410e249a0011
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0072-rt-reflection-RTConstructorgetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorGetTypeParameters)
+run(RTConstructorGetTypeParameters)
diff --git a/testsuite/java_test/reflection_test/RT0073-rt-reflection-RTConstructortoGenericString/RTConstructorToGenericString1.java b/testsuite/java_test/reflection_test/RT0073-rt-reflection-RTConstructortoGenericString/RTConstructorToGenericString1.java
new file mode 100755
index 0000000000000000000000000000000000000000..716f3e5e760b105ba6b1aed61c34a87675215b58
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0073-rt-reflection-RTConstructortoGenericString/RTConstructorToGenericString1.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+class ConstructorToGenericString1 {
+    public <t, s, d, f, g> ConstructorToGenericString1(int number) {
+    }
+}
+public class RTConstructorToGenericString1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ConstructorToGenericString1");
+            Constructor instance1 = cls.getConstructor(int.class);
+            if (instance1.toGenericString().equals("public <t,s,d,f,g> ConstructorToGenericString1(int)")) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e1) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e2) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0073-rt-reflection-RTConstructortoGenericString/expected.txt b/testsuite/java_test/reflection_test/RT0073-rt-reflection-RTConstructortoGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0073-rt-reflection-RTConstructortoGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0073-rt-reflection-RTConstructortoGenericString/test.cfg b/testsuite/java_test/reflection_test/RT0073-rt-reflection-RTConstructortoGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..780d7839896896f7f79cbd4902d639b9b836a02f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0073-rt-reflection-RTConstructortoGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(RTConstructorToGenericString1)
+run(RTConstructorToGenericString1)
diff --git a/testsuite/java_test/reflection_test/RT0074-rt-reflection-RTFieldget1/RTFieldGet1.java b/testsuite/java_test/reflection_test/RT0074-rt-reflection-RTFieldget1/RTFieldGet1.java
new file mode 100755
index 0000000000000000000000000000000000000000..7d33118d3b4f2e660ee8c87138f160fd9c0c03b5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0074-rt-reflection-RTFieldget1/RTFieldGet1.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class FieldGet1_a {
+    public static String str = "aaa";
+    public int num = 2;
+    public int num1 = 5;
+    public static boolean aBoolean = false;
+}
+class FieldGet1 extends FieldGet1_a {
+    public static String str = "bbb";
+    public int number = 1;
+    public int test = super.num1 + 1;
+    public static boolean bBoolean = true;
+    public char aChar = '国';
+}
+public class RTFieldGet1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet1");
+            Object obj = cls.newInstance();
+            Object q1 = cls.getField("str").get(obj);
+            Object q2 = cls.getField("number").get(obj);
+            Object q3 = cls.getField("test").get(obj);
+            Object q4 = cls.getField("bBoolean").get(obj);
+            Object q5 = cls.getField("aChar").get(obj);
+            Object q6 = cls.getField("num").get(obj);
+            Object q7 = cls.getField("aBoolean").get(null);
+            if (q1.toString().equals("bbb") && (int) q2 == 1 && (int) q3 == 6 && (boolean) q4 && q5.toString().
+                    equals("国") && (int) q6 == 2) {
+                Class cls1 = Class.forName("FieldGet1_a");
+                Object instance1 = cls1.newInstance();
+                Object q8 = cls1.getField("str").get(instance1);
+                if (q8.toString().equals("aaa")) {
+                    if (!(boolean) q7) {
+                        System.out.println(0);
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0074-rt-reflection-RTFieldget1/expected.txt b/testsuite/java_test/reflection_test/RT0074-rt-reflection-RTFieldget1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0074-rt-reflection-RTFieldget1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0074-rt-reflection-RTFieldget1/test.cfg b/testsuite/java_test/reflection_test/RT0074-rt-reflection-RTFieldget1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d26c0c731765bf2d8c769b63b7a0f0275f8e7c89
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0074-rt-reflection-RTFieldget1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGet1)
+run(RTFieldGet1)
diff --git a/testsuite/java_test/reflection_test/RT0075-rt-reflection-RTFieldget2/RTFieldGet2.java b/testsuite/java_test/reflection_test/RT0075-rt-reflection-RTFieldget2/RTFieldGet2.java
new file mode 100755
index 0000000000000000000000000000000000000000..3077ed396907485a84e614664c2ca8abc0ee0f18
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0075-rt-reflection-RTFieldget2/RTFieldGet2.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class FieldGet2_a {
+    public int num;
+}
+class FieldGet2 extends FieldGet2_a {
+    private int number = 1;
+    public boolean aBoolean = true;
+    public int number1 = 8;
+}
+class FieldGet2_b {
+    public int number1 = 18;
+}
+public class RTFieldGet2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet2");
+            Object obj = cls.newInstance();
+            Object q1 = cls.getDeclaredField("number").get(obj);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            try {
+                Class cls = Class.forName("FieldGet2");
+                Class cls1 = Class.forName("FieldGet2_b");
+                Object instance1 = cls1.newInstance();
+                Object q2 = cls.getDeclaredField("number1").get(instance1);
+            } catch (ClassNotFoundException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (InstantiationException e6) {
+                System.err.println(e6);
+                System.out.println(2);
+            } catch (NoSuchFieldException e7) {
+                System.err.println(e7);
+                System.out.println(2);
+            } catch (IllegalAccessException e8) {
+                System.err.println(e8);
+                System.out.println(2);
+            } catch (IllegalArgumentException e9) {
+                try {
+                    Class cls = Class.forName("FieldGet2");
+                    Object q3 = cls.getDeclaredField("aBoolean").get(null);
+                } catch (ClassNotFoundException e10) {
+                    System.err.println(e10);
+                    System.out.println(2);
+                } catch (NoSuchFieldException e11) {
+                    System.err.println(e11);
+                    System.out.println(2);
+                } catch (IllegalAccessException e12) {
+                    System.err.println(e12);
+                    System.out.println(2);
+                } catch (NullPointerException e13) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0075-rt-reflection-RTFieldget2/expected.txt b/testsuite/java_test/reflection_test/RT0075-rt-reflection-RTFieldget2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0075-rt-reflection-RTFieldget2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0075-rt-reflection-RTFieldget2/test.cfg b/testsuite/java_test/reflection_test/RT0075-rt-reflection-RTFieldget2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc8135c4f2804b4cfe275b0517dacd3aaa376c12
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0075-rt-reflection-RTFieldget2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGet2)
+run(RTFieldGet2)
diff --git a/testsuite/java_test/reflection_test/RT0076-rt-reflection-RTFieldget3/RTFieldGet3.java b/testsuite/java_test/reflection_test/RT0076-rt-reflection-RTFieldget3/RTFieldGet3.java
new file mode 100755
index 0000000000000000000000000000000000000000..57e7da6ac8a92ec0185d3ef2df5db8e4403b8a3a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0076-rt-reflection-RTFieldget3/RTFieldGet3.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class FieldGet3_a {
+    public int num;
+}
+class FieldGet3 extends FieldGet3_a {
+    public static String str;
+}
+public class RTFieldGet3 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGet3");
+            Object obj = cls.newInstance();
+            Object obj1 = cls.getField("str").get(obj);
+            Object obj2 = cls.getField("num").get(obj);
+            if (obj1 == null && (int) obj2 == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0076-rt-reflection-RTFieldget3/expected.txt b/testsuite/java_test/reflection_test/RT0076-rt-reflection-RTFieldget3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0076-rt-reflection-RTFieldget3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0076-rt-reflection-RTFieldget3/test.cfg b/testsuite/java_test/reflection_test/RT0076-rt-reflection-RTFieldget3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e03d65831474e9d2e35c9806a7270d0b7ea88f6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0076-rt-reflection-RTFieldget3/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGet3)
+run(RTFieldGet3)
diff --git a/testsuite/java_test/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/RTFieldGetAnnotation1.java b/testsuite/java_test/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/RTFieldGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..b96bbc93927d533d77e8c75b4108656721e1b8a8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/RTFieldGetAnnotation1.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface4 {
+    int num() default 0;
+    String str() default "";
+}
+@interface interface4_a {
+    int number() default 0;
+    String string() default "";
+}
+class FieldGetAnnotation1 {
+    @interface4(num = 333, str = "GetAnnotation")
+    public int num1;
+    @interface4_a(number = 555, string = "test")
+    public String str1;
+}
+public class RTFieldGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls1 = Class.forName("FieldGetAnnotation1");
+            Field instance1 = cls1.getField("num1");
+            Field instance2 = cls1.getField("str1");
+            if (instance1.getAnnotation(interface4_a.class) == null && instance2.getAnnotation(interface4.class) == null)
+            {
+                instance1.getAnnotation(interface4_a.class).number();
+            }
+            System.out.println(2);
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/expected.txt b/testsuite/java_test/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/test.cfg b/testsuite/java_test/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..038efbbe99c922b3c43d2a5d922de442b16b447e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0077-rt-reflection-RTFieldgetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetAnnotation1)
+run(RTFieldGetAnnotation1)
diff --git a/testsuite/java_test/reflection_test/RT0078-rt-reflection-RTFieldgetDeclaredAnnotations1/RTFieldGetDeclaredAnnotations1.java b/testsuite/java_test/reflection_test/RT0078-rt-reflection-RTFieldgetDeclaredAnnotations1/RTFieldGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..50613bb4e7e1c61feab615f935d0e44489cc2e7c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0078-rt-reflection-RTFieldgetDeclaredAnnotations1/RTFieldGetDeclaredAnnotations1.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface1 {
+    int num() default 0;
+    String str() default "";
+}
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface1_a {
+    int num_a() default 2;
+    String str_a() default "";
+}
+class FieldGetDeclaredAnnotations1 {
+    @interface1(num = 333, str = "test1")
+    public int num;
+    @interface1(num = 333, str = "test1")
+    public String str;
+}
+class FieldGetDeclaredAnnotations1_a extends FieldGetDeclaredAnnotations1 {
+    @interface1_a(num_a = 666, str_a = "right1")
+    public int num;
+    @interface1_a(num_a = 666, str_a = "right1")
+    public String str;
+}
+public class RTFieldGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaredAnnotations1_a");
+            Field instance1 = cls.getField("num");
+            if (instance1.getDeclaredAnnotations().length == 1) {
+                Annotation[] j = instance1.getDeclaredAnnotations();
+                if (j[0].toString().indexOf("num_a=666") != -1 && j[0].toString().indexOf("str_a=right1") != -1) {
+                    Field instance2 = cls.getDeclaredField("str");
+                    if (instance2.getDeclaredAnnotations().length == 1) {
+                        Annotation[] k = instance2.getDeclaredAnnotations();
+                        if (k[0].toString().indexOf("num_a=666") != -1 && k[0].toString().indexOf("str_a=right1") != -1)
+                        {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0078-rt-reflection-RTFieldgetDeclaredAnnotations1/expected.txt b/testsuite/java_test/reflection_test/RT0078-rt-reflection-RTFieldgetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0078-rt-reflection-RTFieldgetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0078-rt-reflection-RTFieldgetDeclaredAnnotations1/test.cfg b/testsuite/java_test/reflection_test/RT0078-rt-reflection-RTFieldgetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..713f37be93b64a395a9aa6954b6cd60ef9e6e15d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0078-rt-reflection-RTFieldgetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetDeclaredAnnotations1)
+run(RTFieldGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java b/testsuite/java_test/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..f275fb6bc031c90ad65da06eba2d628995602845
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/RTFieldGetDeclaredAnnotations2.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface2 {
+    int num() default 0;
+    String str() default "";
+}
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface interface2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class FieldGetDeclaredAnnotations2 {
+    @interface2(num = 333, str = "test1")
+    public int num;
+    @interface2(num = 333, str = "test1")
+    public String str;
+}
+class FieldGetDeclaredAnnotations2_a extends FieldGetDeclaredAnnotations2 {
+    @interface2_a(i_a = 666, t_a = "right1")
+    public int num;
+    public String str;
+}
+public class RTFieldGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaredAnnotations2_a");
+            Field instance1 = cls.getField("str");
+            Field instance2 = cls.getDeclaredField("str");
+            if (instance1.getDeclaredAnnotations().length == 0 && instance2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchFieldException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/expected.txt b/testsuite/java_test/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/test.cfg b/testsuite/java_test/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..edc2fa4b88b3f94f2d4052ca150ff67395e0885d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetDeclaredAnnotations2)
+run(RTFieldGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java b/testsuite/java_test/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..538d8f0315d3b04be9314cbb8f1e715a0a5f1bd4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/RTFieldGetDeclaringClass.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldGetDeclaringClass {
+    public int num;
+    char aChar;
+}
+public class RTFieldGetDeclaringClass {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetDeclaringClass");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("aChar");
+            Class<?> j = instance1.getDeclaringClass();
+            Class<?> k = instance2.getDeclaringClass();
+            if (j.getName().equals("FieldGetDeclaringClass") && k.getName().equals("FieldGetDeclaringClass")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/expected.txt b/testsuite/java_test/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/test.cfg b/testsuite/java_test/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..78abc74919e406847c2fc46b73307aeec9407306
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0080-rt-reflection-RTFieldgetDeclaringClass/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetDeclaringClass)
+run(RTFieldGetDeclaringClass)
diff --git a/testsuite/java_test/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/RTFieldGetModifiers.java b/testsuite/java_test/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/RTFieldGetModifiers.java
new file mode 100755
index 0000000000000000000000000000000000000000..116af0cd73d0cf6e062502565b0374944f769a6b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/RTFieldGetModifiers.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldGetModifiers {
+    public static int num;
+    final String str = "aaa";
+    private String string = "ccc";
+    protected static int number;
+}
+public class RTFieldGetModifiers {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetModifiers");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("str");
+            Field instance3 = cls.getDeclaredField("string");
+            Field field = cls.getDeclaredField("number");
+            if (instance1.getModifiers() == 9 && instance2.getModifiers() == 16 && instance3.getModifiers() == 2
+                    && field.getModifiers()
+                    == 12) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/expected.txt b/testsuite/java_test/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/test.cfg b/testsuite/java_test/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9fba25ad93c47c3e2ccd452364326b370c0a2eed
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0081-rt-reflection-RTFieldgetModifiers/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetModifiers)
+run(RTFieldGetModifiers)
diff --git a/testsuite/java_test/reflection_test/RT0082-rt-reflection-RTFieldgetName/RTFieldGetName.java b/testsuite/java_test/reflection_test/RT0082-rt-reflection-RTFieldgetName/RTFieldGetName.java
new file mode 100755
index 0000000000000000000000000000000000000000..60d46ec88b1fe2ce2692048d794f9d7bd466cd75
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0082-rt-reflection-RTFieldgetName/RTFieldGetName.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldGetName {
+    public static int num;
+    final String str = "aaa";
+}
+public class RTFieldGetName {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetName");
+            Field instance1 = cls.getField("num");
+            Field instance2 = cls.getDeclaredField("str");
+            if (instance1.getName().equals("num") && instance2.getName().equals("str")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0082-rt-reflection-RTFieldgetName/expected.txt b/testsuite/java_test/reflection_test/RT0082-rt-reflection-RTFieldgetName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0082-rt-reflection-RTFieldgetName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0082-rt-reflection-RTFieldgetName/test.cfg b/testsuite/java_test/reflection_test/RT0082-rt-reflection-RTFieldgetName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e6bb647a31aecf3b2fa6d3c5dd87a074c0ddc15
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0082-rt-reflection-RTFieldgetName/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetName)
+run(RTFieldGetName)
diff --git a/testsuite/java_test/reflection_test/RT0083-rt-reflection-RTFieldgetType/RTFieldGetType.java b/testsuite/java_test/reflection_test/RT0083-rt-reflection-RTFieldgetType/RTFieldGetType.java
new file mode 100755
index 0000000000000000000000000000000000000000..09b4a21ab4e7778d180fe06f3f947f1dec95198f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0083-rt-reflection-RTFieldgetType/RTFieldGetType.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldGetType {
+    public static short sNum;
+    final char aChar = '什';
+    private float fNum;
+}
+public class RTFieldGetType {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldGetType");
+            Field instance1 = cls.getField("sNum");
+            Field instance2 = cls.getDeclaredField("aChar");
+            Field instance3 = cls.getDeclaredField("fNum");
+            if (instance1.getType().getName().equals("short") && instance2.getType().getName().equals("char")
+                    && instance3.getType().getName().equals("float")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0083-rt-reflection-RTFieldgetType/expected.txt b/testsuite/java_test/reflection_test/RT0083-rt-reflection-RTFieldgetType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0083-rt-reflection-RTFieldgetType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0083-rt-reflection-RTFieldgetType/test.cfg b/testsuite/java_test/reflection_test/RT0083-rt-reflection-RTFieldgetType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..51d322a0d0fa561f363cdf697f9326d73c2d487a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0083-rt-reflection-RTFieldgetType/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldGetType)
+run(RTFieldGetType)
diff --git a/testsuite/java_test/reflection_test/RT0084-rt-reflection-RTFieldset1/RTFieldSet1.java b/testsuite/java_test/reflection_test/RT0084-rt-reflection-RTFieldset1/RTFieldSet1.java
new file mode 100755
index 0000000000000000000000000000000000000000..f285ef981c65b1e558e0e74a5f6cbe243bd98437
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0084-rt-reflection-RTFieldset1/RTFieldSet1.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldSet1_a {
+    public static String str = "aaa";
+    public int num2 = 2;
+    public int number = 5;
+    public static int num1;
+}
+class FieldSet1 extends FieldSet1_a {
+    public static String str = "bbb";
+    public int num = 1;
+    public int test = super.number + 1;
+    public static boolean aBoolean = true;
+    public char aChar;
+}
+public class RTFieldSet1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet1");
+            Object obj = cls.newInstance();
+            Field f1 = cls.getField("str");
+            Field f2 = cls.getField("num");
+            Field f3 = cls.getField("aBoolean");
+            Field f4 = cls.getField("aChar");
+            Field f5 = cls.getField("num1");
+            Field f6 = cls.getField("num2");
+            Field f7 = cls.getField("number");
+            f1.set(obj, "ccc");
+            f2.set(obj, 10);
+            f3.set(obj, false);
+            f4.set(obj, '国');
+            f5.set(obj, 20);
+            f6.set(obj, 30);
+            f7.set(obj, 40);
+            if (f1.get(obj).toString().equals("ccc") && (int) f2.get(obj) == 10 && !(boolean) f3.get(obj) && (int)
+                    f6.get(obj) == 30) {
+                if (f4.get(obj).toString().equals("国") && (int) f5.get(obj) == 20) {
+                    if ((int) cls.getField("test").get(obj) == 6) {
+                        Class cls1 = Class.forName("FieldSet1_a");
+                        Object instance1 = cls1.newInstance();
+                        Object p = cls1.getDeclaredField("str").get(instance1);
+                        if (p.toString().equals("aaa")) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0084-rt-reflection-RTFieldset1/expected.txt b/testsuite/java_test/reflection_test/RT0084-rt-reflection-RTFieldset1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0084-rt-reflection-RTFieldset1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0084-rt-reflection-RTFieldset1/test.cfg b/testsuite/java_test/reflection_test/RT0084-rt-reflection-RTFieldset1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..24631a745c304682776f3326ac25d65e07ff5810
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0084-rt-reflection-RTFieldset1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldSet1)
+run(RTFieldSet1)
diff --git a/testsuite/java_test/reflection_test/RT0085-rt-reflection-RTFieldset2/RTFieldSet2.java b/testsuite/java_test/reflection_test/RT0085-rt-reflection-RTFieldset2/RTFieldSet2.java
new file mode 100755
index 0000000000000000000000000000000000000000..51041e09adaeda45f5efc502415ec425609b9a9b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0085-rt-reflection-RTFieldset2/RTFieldSet2.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldSet2_a {
+    public static String str = "aaa";
+    public int num;
+}
+class FieldSet2 extends FieldSet2_a {
+    public static String str;
+    private int num = 1;
+    public boolean aBoolean = true;
+    public int num1 = 8;
+}
+class FieldSet2_b {
+    public int num = 18;
+}
+public class RTFieldSet2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet2");
+            Object obj = cls.newInstance();
+            Field field = cls.getDeclaredField("num");
+            field.set(obj, 10);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            try {
+                Class cls = Class.forName("FieldSet2");
+                Class cls1 = Class.forName("FieldSet2_b");
+                Object instance1 = cls1.newInstance();
+                Field f1 = cls.getDeclaredField("aBoolean");
+                f1.set(instance1, 10);
+            } catch (ClassNotFoundException e5) {
+                System.err.println(e5);
+                System.out.println(2);
+            } catch (InstantiationException e6) {
+                System.err.println(e6);
+                System.out.println(2);
+            } catch (NoSuchFieldException e7) {
+                System.err.println(e7);
+                System.out.println(2);
+            } catch (IllegalAccessException e8) {
+                System.err.println(e8);
+                System.out.println(2);
+            } catch (IllegalArgumentException e9) {
+                try {
+                    Class cls = Class.forName("FieldSet2");
+                    Field f2 = cls.getDeclaredField("aBoolean");
+                    f2.set(null, false);
+                } catch (ClassNotFoundException e10) {
+                    System.err.println(e10);
+                    System.out.println(2);
+                } catch (NoSuchFieldException e11) {
+                    System.err.println(e11);
+                    System.out.println(2);
+                } catch (IllegalAccessException e12) {
+                    System.err.println(e12);
+                    System.out.println(2);
+                } catch (NullPointerException e13) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0085-rt-reflection-RTFieldset2/expected.txt b/testsuite/java_test/reflection_test/RT0085-rt-reflection-RTFieldset2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0085-rt-reflection-RTFieldset2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0085-rt-reflection-RTFieldset2/test.cfg b/testsuite/java_test/reflection_test/RT0085-rt-reflection-RTFieldset2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..64dcadda7d2e4e32184858c065e4f980c13aedcb
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0085-rt-reflection-RTFieldset2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldSet2)
+run(RTFieldSet2)
diff --git a/testsuite/java_test/reflection_test/RT0086-rt-reflection-RTFieldset3/RTFieldSet3.java b/testsuite/java_test/reflection_test/RT0086-rt-reflection-RTFieldset3/RTFieldSet3.java
new file mode 100755
index 0000000000000000000000000000000000000000..ad1144ed09cbd0abc7a8c105491560edb15d3a28
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0086-rt-reflection-RTFieldset3/RTFieldSet3.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldSet3_a {
+    public final static String str = "aaa";
+    public int num = 2;
+}
+class FieldSet3 extends FieldSet3_a {
+    public final int num = 1;
+}
+public class RTFieldSet3 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet3");
+            Object obj = cls.newInstance();
+            Field q1 = cls.getField("str");
+            Field q2 = cls.getField("num");
+            q1.set(obj, "bbb");
+            q2.set(obj, 10);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0086-rt-reflection-RTFieldset3/expected.txt b/testsuite/java_test/reflection_test/RT0086-rt-reflection-RTFieldset3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0086-rt-reflection-RTFieldset3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0086-rt-reflection-RTFieldset3/test.cfg b/testsuite/java_test/reflection_test/RT0086-rt-reflection-RTFieldset3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a6cabbc7493a4f8093f206ee3f995fcc22ad9f2a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0086-rt-reflection-RTFieldset3/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldSet3)
+run(RTFieldSet3)
diff --git a/testsuite/java_test/reflection_test/RT0087-rt-reflection-RTFieldset4/RTFieldSet4.java b/testsuite/java_test/reflection_test/RT0087-rt-reflection-RTFieldset4/RTFieldSet4.java
new file mode 100755
index 0000000000000000000000000000000000000000..90a79838518f18e58eed435a627848f88d942475
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0087-rt-reflection-RTFieldset4/RTFieldSet4.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+class FieldSet4 {
+    public static String str;
+    private int num = 1;
+    public boolean aBoolean = true;
+    public int num1 = 8;
+}
+public class RTFieldSet4 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldSet4");
+            Object obj = cls.newInstance();
+            Field field = cls.getDeclaredField("str");
+            field.set(null, "aaa");
+            System.out.println(0);
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (InstantiationException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        } catch (NoSuchFieldException e3) {
+            System.err.println(e3);
+            System.out.println(2);
+        } catch (IllegalAccessException e4) {
+            System.err.println(e4);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0087-rt-reflection-RTFieldset4/expected.txt b/testsuite/java_test/reflection_test/RT0087-rt-reflection-RTFieldset4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0087-rt-reflection-RTFieldset4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0087-rt-reflection-RTFieldset4/test.cfg b/testsuite/java_test/reflection_test/RT0087-rt-reflection-RTFieldset4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..920b758deac9632cda1d2d787dc1eeaebd08a6a9
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0087-rt-reflection-RTFieldset4/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldSet4)
+run(RTFieldSet4)
diff --git a/testsuite/java_test/reflection_test/RT0088-rt-reflection-RTFieldtoGenericString/RTFieldToGenericString.java b/testsuite/java_test/reflection_test/RT0088-rt-reflection-RTFieldtoGenericString/RTFieldToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd41a5608a0a9729bcd1f8bcc63e8bdf3924f22b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0088-rt-reflection-RTFieldtoGenericString/RTFieldToGenericString.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.util.List;
+class FieldToGenericString<E, F> {
+    public List<F> list1;
+    private List<E> list2;
+}
+public class RTFieldToGenericString {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldToGenericString");
+            Field instance1 = cls.getField("list1");
+            Field instance2 = cls.getDeclaredField("list2");
+            String q1 = instance1.toGenericString();
+            String q2 = instance2.toGenericString();
+            if (q1.equals("public java.util.List<F> FieldToGenericString.list1") && q2.equals
+                    ("private java.util.List<E> FieldToGenericString.list2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0088-rt-reflection-RTFieldtoGenericString/expected.txt b/testsuite/java_test/reflection_test/RT0088-rt-reflection-RTFieldtoGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0088-rt-reflection-RTFieldtoGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0088-rt-reflection-RTFieldtoGenericString/test.cfg b/testsuite/java_test/reflection_test/RT0088-rt-reflection-RTFieldtoGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e72437fa5b4538e177d899305ce9d930a62bc76b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0088-rt-reflection-RTFieldtoGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldToGenericString)
+run(RTFieldToGenericString)
diff --git a/testsuite/java_test/reflection_test/RT0089-rt-reflection-RTFieldtoString/RTFieldToString.java b/testsuite/java_test/reflection_test/RT0089-rt-reflection-RTFieldtoString/RTFieldToString.java
new file mode 100755
index 0000000000000000000000000000000000000000..660ba6c29aafadc4e2899865c40f817dbcf0f0a6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0089-rt-reflection-RTFieldtoString/RTFieldToString.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.util.List;
+class FieldToString<E, F> {
+    public List<F> list1;
+    private List<E> list2;
+}
+public class RTFieldToString {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("FieldToString");
+            Field instance1 = cls.getField("list1");
+            Field instance2 = cls.getDeclaredField("list2");
+            String q1 = instance1.toString();
+            String q2 = instance2.toString();
+            if (q1.equals("public java.util.List FieldToString.list1")
+                    && q2.equals("private java.util.List FieldToString.list2")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchFieldException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0089-rt-reflection-RTFieldtoString/expected.txt b/testsuite/java_test/reflection_test/RT0089-rt-reflection-RTFieldtoString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0089-rt-reflection-RTFieldtoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0089-rt-reflection-RTFieldtoString/test.cfg b/testsuite/java_test/reflection_test/RT0089-rt-reflection-RTFieldtoString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc1097bce3be5ddd05b51be644ce77af115fd3c4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0089-rt-reflection-RTFieldtoString/test.cfg
@@ -0,0 +1,2 @@
+compile(RTFieldToString)
+run(RTFieldToString)
diff --git a/testsuite/java_test/reflection_test/RT0090-rt-reflection-RTMethodgetAnnotation1/RTMethodGetAnnotation1.java b/testsuite/java_test/reflection_test/RT0090-rt-reflection-RTMethodgetAnnotation1/RTMethodGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..c41aa0027e666e3f7c450c607630b2e94680d994
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0090-rt-reflection-RTMethodgetAnnotation1/RTMethodGetAnnotation1.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i_a() default 0;
+    String t_b() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    int c() default 0;
+    String d() default "";
+}
+class MethodGetAnnotation1 {
+    @IF1(i_a = 333, t_b = "MethodGetAnnotation")
+    public void test1() {
+    }
+    public void test2(String name) {
+    }
+    @IF1_a(c = 666, d = "Method")
+    void test3(int number) {
+    }
+    void test4(String name, int number) {
+    }
+}
+public class RTMethodGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetAnnotation1");
+            Method method1 = clazz.getDeclaredMethod("test3", int.class);
+            Method method2 = clazz.getMethod("test1");
+            Method method3 = clazz.getMethod("test2", String.class);
+            if (method1.getAnnotation(IF1_a.class).c() == 666
+                    && method1.getAnnotation(IF1_a.class).d().equals("Method")
+                    && method2.getAnnotation(IF1.class).i_a() == 333
+                    && method2.getAnnotation(IF1.class).t_b().equals("MethodGetAnnotation")) {
+                if (method3.getAnnotation(IF1.class) == null) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0090-rt-reflection-RTMethodgetAnnotation1/expected.txt b/testsuite/java_test/reflection_test/RT0090-rt-reflection-RTMethodgetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0090-rt-reflection-RTMethodgetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0090-rt-reflection-RTMethodgetAnnotation1/test.cfg b/testsuite/java_test/reflection_test/RT0090-rt-reflection-RTMethodgetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa315cf69ebfa7c6e286549039f3a7b525fe782c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0090-rt-reflection-RTMethodgetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetAnnotation1)
+run(RTMethodGetAnnotation1)
diff --git a/testsuite/java_test/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java b/testsuite/java_test/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..55081039407542cb016e3cd2de1d527ce031c7ec
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/RTMethodGetAnnotation2.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.CLASS)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.SOURCE)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+class MethodGetAnnotation2 {
+    @IF2(i = 333, t = "MethodGetAnnotation")
+    public void test1() {
+    }
+    @IF2_a(c = 666, d = "Method")
+    void test3(int number) {
+    }
+}
+public class RTMethodGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetAnnotation2");
+            Method method1 = clazz.getDeclaredMethod("test3", int.class);
+            Method method2 = clazz.getMethod("test1");
+            if (method1.getAnnotation(IF2_a.class) == null && method2.getAnnotation(IF2.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/expected.txt b/testsuite/java_test/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/test.cfg b/testsuite/java_test/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1a1120b7692649e7ca29098b91e9eecb17b5b2c6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0091-rt-reflection-RTMethodgetAnnotation2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetAnnotation2)
+run(RTMethodGetAnnotation2)
diff --git a/testsuite/java_test/reflection_test/RT0092-rt-reflection-RTMethodgetDeclaredAnnotations1/RTMethodGetDeclaredAnnotations1.java b/testsuite/java_test/reflection_test/RT0092-rt-reflection-RTMethodgetDeclaredAnnotations1/RTMethodGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..6abe4d0555ae9bbb2873062b75850c0a0f117567
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0092-rt-reflection-RTMethodgetDeclaredAnnotations1/RTMethodGetDeclaredAnnotations1.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw1_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class MethodGetDeclaredAnnotations1 {
+    @IFw1(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+    @IFw1(i = 333, t = "test1")
+    void tt(int number) {
+    }
+}
+class MethodGetDeclaredAnnotations1_a extends MethodGetDeclaredAnnotations1 {
+    @IFw1_a(i_a = 666, t_a = "right1")
+    public static void ii(String name) {
+    }
+    @IFw1_a(i_a = 666, t_a = "right1")
+    void tt(int number) {
+    }
+}
+public class RTMethodGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetDeclaredAnnotations1_a");
+            Method method1 = clazz.getMethod("ii", String.class);
+            if (method1.getDeclaredAnnotations().length == 1) {
+                Annotation[] annotations1 = method1.getDeclaredAnnotations();
+                if (annotations1[0].toString().indexOf("i_a=666") != -1
+                        && annotations1[0].toString().indexOf("t_a=right1") != -1) {
+                    Method method2 = clazz.getDeclaredMethod("tt", int.class);
+                    if (method2.getDeclaredAnnotations().length == 1) {
+                        Annotation[] annotations2 = method2.getDeclaredAnnotations();
+                        if (annotations2[0].toString().indexOf("i_a=666") != -1
+                                && annotations2[0].toString().indexOf("t_a=right1") != -1) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0092-rt-reflection-RTMethodgetDeclaredAnnotations1/expected.txt b/testsuite/java_test/reflection_test/RT0092-rt-reflection-RTMethodgetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0092-rt-reflection-RTMethodgetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0092-rt-reflection-RTMethodgetDeclaredAnnotations1/test.cfg b/testsuite/java_test/reflection_test/RT0092-rt-reflection-RTMethodgetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..22660d016852a77db15ac79b48a832a6b3dad09b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0092-rt-reflection-RTMethodgetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetDeclaredAnnotations1)
+run(RTMethodGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java b/testsuite/java_test/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..7c53e93f726f6c6fb44ef67fae7d848c04e34634
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/RTMethodGetDeclaredAnnotations2.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IFw2_a {
+    int i_a() default 2;
+    String t_a() default "";
+}
+class MethodGetDeclaredAnnotations2 {
+    @IFw2(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+    @IFw2_a(i_a = 666, t_a = "right1")
+    void tt(int number) {
+    }
+}
+class MethodGetDeclaredAnnotations2_a extends MethodGetDeclaredAnnotations2 {
+    public static void ii(String name) {
+    }
+    void tt() {
+    }
+}
+public class RTMethodGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetDeclaredAnnotations2_a");
+            Method method1 = clazz.getMethod("ii", String.class);
+            Method method2 = clazz.getDeclaredMethod("tt");
+            if (method1.getDeclaredAnnotations().length == 0 && method2.getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/expected.txt b/testsuite/java_test/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/test.cfg b/testsuite/java_test/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a00193b5142acdb017e6edc9281e0455b9237b5d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetDeclaredAnnotations2)
+run(RTMethodGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/reflection_test/RT0094-rt-reflection-RTMethodgetDefaultValue1/RTMethodGetDefaultValue1.java b/testsuite/java_test/reflection_test/RT0094-rt-reflection-RTMethodgetDefaultValue1/RTMethodGetDefaultValue1.java
new file mode 100755
index 0000000000000000000000000000000000000000..bdea54ae4e947dd170b413c49b2cf00050164c71
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0094-rt-reflection-RTMethodgetDefaultValue1/RTMethodGetDefaultValue1.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    public int i_a() default 2;
+    String t_a() default "string default value";
+    String s();
+}
+class MethodGetDefaultValue1 {
+    @IF1(i = 333, t = "test1")
+    public static void ii(String name) {
+    }
+    void tt(int number) {
+    }
+}
+public class RTMethodGetDefaultValue1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("IF1_a");
+            Class clazz2 = Class.forName("IF1");
+            Class clazz3 = Class.forName("MethodGetDefaultValue1");
+            Method method1 = clazz1.getDeclaredMethod("i_a");
+            Method method2 = clazz1.getMethod("t_a");
+            Method method3 = clazz2.getDeclaredMethod("t");
+            Method[] methods = clazz3.getMethods();
+            Method method5 = clazz3.getDeclaredMethod("tt", int.class);
+            Method method6 = clazz1.getDeclaredMethod("s");
+            if ((int) method1.getDefaultValue() == 2
+                    && method2.getDefaultValue().toString().equals("string default value")) {
+                if (method3.getDefaultValue().equals("")) {
+                    if (methods[0].getDefaultValue() == null && method5.getDefaultValue() == null) {
+                        if (method6.getDefaultValue() == null) {
+                            System.out.println(0);
+                        }
+                    }
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0094-rt-reflection-RTMethodgetDefaultValue1/expected.txt b/testsuite/java_test/reflection_test/RT0094-rt-reflection-RTMethodgetDefaultValue1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0094-rt-reflection-RTMethodgetDefaultValue1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0094-rt-reflection-RTMethodgetDefaultValue1/test.cfg b/testsuite/java_test/reflection_test/RT0094-rt-reflection-RTMethodgetDefaultValue1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..213868a4dda5099572882cd23aa7eb799defb2c8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0094-rt-reflection-RTMethodgetDefaultValue1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetDefaultValue1)
+run(RTMethodGetDefaultValue1)
diff --git a/testsuite/java_test/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/RTMethodGetParameterCount.java b/testsuite/java_test/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/RTMethodGetParameterCount.java
new file mode 100755
index 0000000000000000000000000000000000000000..87baf1c7cb9e694b2fe24eb73393f346939629d1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/RTMethodGetParameterCount.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class MethodGetParameterCount2 {
+    void test1() {
+    }
+    public void test2(String name, int number, char c, short s, float f, double d, long l, boolean b, byte bb) {
+    }
+}
+public class RTMethodGetParameterCount {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetParameterCount2");
+            Method method = clazz.getDeclaredMethod("test1");
+            Method[] methods = clazz.getMethods();
+            if (method.getParameterCount() == 0) {
+                if (methods[0].getParameterCount() == 9) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/expected.txt b/testsuite/java_test/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/test.cfg b/testsuite/java_test/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7b616ccbbc4d2638a88ca937c5d40f5bdd71d330
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0095-rt-reflection-RTMethodgetParameterCount/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetParameterCount)
+run(RTMethodGetParameterCount)
diff --git a/testsuite/java_test/reflection_test/RT0096-rt-reflection-RTMethodgetTypeParameters/RTMethodGetTypeParameters.java b/testsuite/java_test/reflection_test/RT0096-rt-reflection-RTMethodgetTypeParameters/RTMethodGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..959e090f73a66cc6ee4a362df6decf374b5e2926
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0096-rt-reflection-RTMethodgetTypeParameters/RTMethodGetTypeParameters.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+import java.lang.reflect.TypeVariable;
+class MethodGetTypeParameters2 {
+    public <t, s, d, f, g> void ss(int number) {
+    }
+    void kk() {
+    }
+}
+public class RTMethodGetTypeParameters {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodGetTypeParameters2");
+            Method method1 = clazz.getMethod("ss", int.class);
+            Method method2 = clazz.getDeclaredMethod("kk");
+            TypeVariable[] typeVariables1 = method1.getTypeParameters();
+            TypeVariable[] typeVariables2 = method2.getTypeParameters();
+            if (typeVariables1.length == 5 && typeVariables2.length == 0) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0096-rt-reflection-RTMethodgetTypeParameters/expected.txt b/testsuite/java_test/reflection_test/RT0096-rt-reflection-RTMethodgetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0096-rt-reflection-RTMethodgetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0096-rt-reflection-RTMethodgetTypeParameters/test.cfg b/testsuite/java_test/reflection_test/RT0096-rt-reflection-RTMethodgetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..865572a6c9a152a3c223cf7e125fb5888bc9b14a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0096-rt-reflection-RTMethodgetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodGetTypeParameters)
+run(RTMethodGetTypeParameters)
diff --git a/testsuite/java_test/reflection_test/RT0097-rt-reflection-RTMethonisDefault/RTMethodIsDefault.java b/testsuite/java_test/reflection_test/RT0097-rt-reflection-RTMethonisDefault/RTMethodIsDefault.java
new file mode 100755
index 0000000000000000000000000000000000000000..221690390eb0acf025a48bf77de8d4920287b089
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0097-rt-reflection-RTMethonisDefault/RTMethodIsDefault.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+interface MethodIsDefault_A {
+    default public void run() {
+        String i;
+    }
+}
+class MethodIsDefault implements MethodIsDefault_A {
+    public void run() {
+        String i = "abc";
+    }
+    void ss(int number) {
+    }
+}
+public class RTMethodIsDefault {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("MethodIsDefault_A");
+            Class clazz2 = Class.forName("MethodIsDefault");
+            Method method1 = clazz1.getMethod("run");
+            Method method2 = clazz2.getMethod("run");
+            Method method3 = clazz2.getDeclaredMethod("ss", int.class);
+            if (method1.isDefault()) {
+                if (!method2.isDefault() && !method3.isDefault()) {
+                    System.out.println(0);
+                }
+            }
+        } catch (ClassNotFoundException e) {
+            System.err.println(e);
+            System.out.println(2);
+        } catch (NoSuchMethodException e) {
+            System.err.println(e);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0097-rt-reflection-RTMethonisDefault/expected.txt b/testsuite/java_test/reflection_test/RT0097-rt-reflection-RTMethonisDefault/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0097-rt-reflection-RTMethonisDefault/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0097-rt-reflection-RTMethonisDefault/test.cfg b/testsuite/java_test/reflection_test/RT0097-rt-reflection-RTMethonisDefault/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6ebfab5a8cc99ffcdefeed7815e4210f750a01bf
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0097-rt-reflection-RTMethonisDefault/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodIsDefault)
+run(RTMethodIsDefault)
diff --git a/testsuite/java_test/reflection_test/RT0098-rt-reflection-RTMethontoGenericString/RTMethodToGenericString.java b/testsuite/java_test/reflection_test/RT0098-rt-reflection-RTMethontoGenericString/RTMethodToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..f897ae4af2a96fbf9c2f50e3c6d81a900dc3a161
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0098-rt-reflection-RTMethontoGenericString/RTMethodToGenericString.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+class MethodToGenericString {
+    public <t, s, d, f, g> void ss(int number) {
+    }
+}
+public class RTMethodToGenericString {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("MethodToGenericString");
+            Method method = clazz.getMethod("ss", int.class);
+            if (method.toGenericString().equals("public <t,s,d,f,g> void MethodToGenericString.ss(int)")) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e1) {
+            System.err.println(e1);
+            System.out.println(2);
+        } catch (NoSuchMethodException e2) {
+            System.err.println(e2);
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0098-rt-reflection-RTMethontoGenericString/expected.txt b/testsuite/java_test/reflection_test/RT0098-rt-reflection-RTMethontoGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0098-rt-reflection-RTMethontoGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0098-rt-reflection-RTMethontoGenericString/test.cfg b/testsuite/java_test/reflection_test/RT0098-rt-reflection-RTMethontoGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..adf4fe232874cf02803c21e7c86534a7f367ea91
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0098-rt-reflection-RTMethontoGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(RTMethodToGenericString)
+run(RTMethodToGenericString)
diff --git a/testsuite/java_test/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/RTModifierParameterModifiers.java b/testsuite/java_test/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/RTModifierParameterModifiers.java
new file mode 100755
index 0000000000000000000000000000000000000000..0b85f66b8360085d1279e496bf0af4b1fd910faf
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/RTModifierParameterModifiers.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Modifier;
+public class RTModifierParameterModifiers {
+    public static void main(String[] args) {
+        if (Modifier.parameterModifiers() == 16) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/expected.txt b/testsuite/java_test/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/test.cfg b/testsuite/java_test/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a8ad20be5c90d8e31efc75d94fa916ac2eb3be7d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0099-rt-reflection-RTModifierparameterModifiers/test.cfg
@@ -0,0 +1,2 @@
+compile(RTModifierParameterModifiers)
+run(RTModifierParameterModifiers)
diff --git a/testsuite/java_test/reflection_test/RT0100-rt-reflection-RTParametergetAnnotation1/RTParameterGetAnnotation1.java b/testsuite/java_test/reflection_test/RT0100-rt-reflection-RTParametergetAnnotation1/RTParameterGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..1bc5ab897fac76967a887abeda6ed011ca299870
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0100-rt-reflection-RTParametergetAnnotation1/RTParameterGetAnnotation1.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF1_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotation1 {
+    ParameterGetAnnotation1(@IF1(i = 222, t = "Parameter") int number) {
+    }
+    public ParameterGetAnnotation1(String name) {
+    }
+    public void test1(@IF1_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotation1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            if (p1[0].getAnnotation(IF1.class).i() == 222 && p1[0].getAnnotation(IF1.class).t().equals("Parameter")
+                    && p3[0].getAnnotation(IF1_a.class).c() == 666
+                    && p3[0].getAnnotation(IF1_a.class).d().equals("Happy new year")) {
+                if (p2[0].getAnnotation(IF1.class) == null) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(2);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(3);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(4);
+            return;
+        }
+        System.out.println(5);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0100-rt-reflection-RTParametergetAnnotation1/expected.txt b/testsuite/java_test/reflection_test/RT0100-rt-reflection-RTParametergetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0100-rt-reflection-RTParametergetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0100-rt-reflection-RTParametergetAnnotation1/test.cfg b/testsuite/java_test/reflection_test/RT0100-rt-reflection-RTParametergetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..37c38048aebe6890094975c42edd8b3cbdea9f3f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0100-rt-reflection-RTParametergetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotation1)
+run(RTParameterGetAnnotation1)
diff --git a/testsuite/java_test/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/RTParameterGetAnnotation2.java b/testsuite/java_test/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/RTParameterGetAnnotation2.java
new file mode 100755
index 0000000000000000000000000000000000000000..749cfbd386b6d96a109fcacd51b0c80b22bd3890
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/RTParameterGetAnnotation2.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF2_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotation2 {
+    ParameterGetAnnotation2(@IF2(i = 222, t = "Parameter") int number) {
+    }
+    public void test1(@IF2_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetAnnotation2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotation2");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getAnnotation(IF2_a.class) == null && p2[0].getAnnotation(IF2.class) == null) {
+                p1[0].getAnnotation(IF2_a.class).c();
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        } catch (NullPointerException e2) {
+            try {
+                Class cls1 = Class.forName("ParameterGetAnnotation2");
+                Method method2 = cls1.getMethod("test1", int.class);
+                Parameter[] p3 = method2.getParameters();
+                p3[0].getAnnotation(null);
+                System.out.println(3);
+                return;
+            } catch (ClassNotFoundException e3) {
+                System.out.println(4);
+                return;
+            } catch (NoSuchMethodException e4) {
+                System.out.println(5);
+                return;
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(6);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/expected.txt b/testsuite/java_test/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/test.cfg b/testsuite/java_test/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35b895fd68e27ba60ae1fcd2a3967739c9130c2a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0101-rt-reflection-RTParametergetAnnotation2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotation2)
+run(RTParameterGetAnnotation2)
diff --git a/testsuite/java_test/reflection_test/RT0102-rt-reflection-RTParametergetAnnotations1/RTParameterGetAnnotations1.java b/testsuite/java_test/reflection_test/RT0102-rt-reflection-RTParametergetAnnotations1/RTParameterGetAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..d720e6ca1de1d84b271a5afa9d81ff42a58165f7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0102-rt-reflection-RTParametergetAnnotations1/RTParameterGetAnnotations1.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF3 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF3_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotations1 {
+    ParameterGetAnnotations1(@IF3(i = 222, t = "Parameter") @IF3_a(c = 666, d = "Happy new year") int number) {
+    }
+    public void test1(String name) {
+    }
+}
+public class RTParameterGetAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotations1");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getAnnotations().length == 2 && p2[0].getAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0102-rt-reflection-RTParametergetAnnotations1/expected.txt b/testsuite/java_test/reflection_test/RT0102-rt-reflection-RTParametergetAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0102-rt-reflection-RTParametergetAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0102-rt-reflection-RTParametergetAnnotations1/test.cfg b/testsuite/java_test/reflection_test/RT0102-rt-reflection-RTParametergetAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3543d246cb42173ca70eead172bb09dd7142945e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0102-rt-reflection-RTParametergetAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotations1)
+run(RTParameterGetAnnotations1)
diff --git a/testsuite/java_test/reflection_test/RT0103-rt-reflection-RTParametergetAnnotationsByType1/RTParameterGetAnnotationsByType1.java b/testsuite/java_test/reflection_test/RT0103-rt-reflection-RTParametergetAnnotationsByType1/RTParameterGetAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..bde5b184faef1592eae1368fe36d9dd7677ad4d6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0103-rt-reflection-RTParametergetAnnotationsByType1/RTParameterGetAnnotationsByType1.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF7 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF7_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotationsByType1 {
+    ParameterGetAnnotationsByType1(@IF7(i = 222, t = "Parameter") int number) {
+    }
+    public ParameterGetAnnotationsByType1(String name) {
+    }
+    public void test1(@IF7_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetAnnotationsByType1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotationsByType1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            Annotation[] q1 = p1[0].getAnnotationsByType(IF7.class);
+            Annotation[] q3 = p3[0].getAnnotationsByType(IF7_a.class);
+            if (p2[0].getAnnotationsByType(IF7.class).length == 0) {
+                if (q1[0].toString().indexOf("i=222") != -1 && q1[0].toString().indexOf("t=Parameter") != -1
+                        && q3[0].toString().indexOf("c=666") != -1
+                        && q3[0].toString().indexOf("d=Happy new year") != -1) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(1);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(4);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0103-rt-reflection-RTParametergetAnnotationsByType1/expected.txt b/testsuite/java_test/reflection_test/RT0103-rt-reflection-RTParametergetAnnotationsByType1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0103-rt-reflection-RTParametergetAnnotationsByType1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0103-rt-reflection-RTParametergetAnnotationsByType1/test.cfg b/testsuite/java_test/reflection_test/RT0103-rt-reflection-RTParametergetAnnotationsByType1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..40b4d88c9d8a4c2a949def245fef2ee26c89fef2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0103-rt-reflection-RTParametergetAnnotationsByType1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotationsByType1)
+run(RTParameterGetAnnotationsByType1)
diff --git a/testsuite/java_test/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java b/testsuite/java_test/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java
new file mode 100755
index 0000000000000000000000000000000000000000..68369c3a25f9024761ac81bc63651f3360dbff70
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/RTParameterGetAnnotationsByType2.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF8 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF8_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetAnnotationsByType2 {
+    ParameterGetAnnotationsByType2(@IF8(i = 222, t = "Parameter") int number) {
+    }
+    public void test1(@IF8_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetAnnotationsByType2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetAnnotationsByType2");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            Annotation[] q1 = p1[0].getAnnotationsByType(IF8_a.class);
+            Annotation[] q2 = p2[0].getAnnotationsByType(IF8.class);
+            q1[0].toString();
+            q2[0].toString();
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        } catch (ArrayIndexOutOfBoundsException e2) {
+            try {
+                Class cls1 = Class.forName("ParameterGetAnnotationsByType2");
+                Constructor cons1 = cls1.getDeclaredConstructor(int.class);
+                Parameter[] p3 = cons1.getParameters();
+                Annotation[] q3 = p3[0].getAnnotationsByType(null);
+                System.out.println(3);
+                return;
+            } catch (ClassNotFoundException e3) {
+                System.out.println(4);
+                return;
+            } catch (NoSuchMethodException e4) {
+                System.out.println(5);
+                return;
+            } catch (NullPointerException e5) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(6);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/expected.txt b/testsuite/java_test/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/test.cfg b/testsuite/java_test/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e09808848473401901c12d923b13d46f67501f3
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0104-rt-reflection-RTParametergetAnnotationsByType2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetAnnotationsByType2)
+run(RTParameterGetAnnotationsByType2)
diff --git a/testsuite/java_test/reflection_test/RT0105-rt-reflection-RTParametergetDeclaredAnnotation1/RTParameterGetDeclaredAnnotation1.java b/testsuite/java_test/reflection_test/RT0105-rt-reflection-RTParametergetDeclaredAnnotation1/RTParameterGetDeclaredAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..1a84159717abf913653e3bf553f246f2fa94d64b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0105-rt-reflection-RTParametergetDeclaredAnnotation1/RTParameterGetDeclaredAnnotation1.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF6 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF6_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetDeclaredAnnotation1 {
+    ParameterGetDeclaredAnnotation1(@IF6(i = 222, t = "Parameter") int number) {
+    }
+    public ParameterGetDeclaredAnnotation1(String name) {
+    }
+    public void test1(@IF6_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetDeclaredAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotation1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            if (p1[0].getDeclaredAnnotation(IF6.class).i() == 222 && p1[0].getDeclaredAnnotation(IF6.class).t()
+                    .equals("Parameter") && p3[0].getDeclaredAnnotation(IF6_a.class).c() == 666
+                    && p3[0].getDeclaredAnnotation(IF6_a.class).d().equals("Happy new year")) {
+                if (p2[0].getDeclaredAnnotation(IF6.class) == null) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(1);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(4);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0105-rt-reflection-RTParametergetDeclaredAnnotation1/expected.txt b/testsuite/java_test/reflection_test/RT0105-rt-reflection-RTParametergetDeclaredAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0105-rt-reflection-RTParametergetDeclaredAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0105-rt-reflection-RTParametergetDeclaredAnnotation1/test.cfg b/testsuite/java_test/reflection_test/RT0105-rt-reflection-RTParametergetDeclaredAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35306c952436c270263350c96aed4416e333ac48
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0105-rt-reflection-RTParametergetDeclaredAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetDeclaredAnnotation1)
+run(RTParameterGetDeclaredAnnotation1)
diff --git a/testsuite/java_test/reflection_test/RT0106-rt-reflection-RTParametergetDeclaredAnnotations1/RTParameterGetDeclaredAnnotations1.java b/testsuite/java_test/reflection_test/RT0106-rt-reflection-RTParametergetDeclaredAnnotations1/RTParameterGetDeclaredAnnotations1.java
new file mode 100755
index 0000000000000000000000000000000000000000..99d91a9dfa75222b20538d3978a6721bb069b8b3
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0106-rt-reflection-RTParametergetDeclaredAnnotations1/RTParameterGetDeclaredAnnotations1.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF5 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF5_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetDeclaredAnnotations1 {
+    ParameterGetDeclaredAnnotations1(@IF5(i = 222, t = "Parameter") @IF5_a(c = 666, d = "Happy new year") int number) {
+    }
+    public void test1(String name) {
+    }
+}
+public class RTParameterGetDeclaredAnnotations1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotations1");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getDeclaredAnnotations().length == 2 && p2[0].getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0106-rt-reflection-RTParametergetDeclaredAnnotations1/expected.txt b/testsuite/java_test/reflection_test/RT0106-rt-reflection-RTParametergetDeclaredAnnotations1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0106-rt-reflection-RTParametergetDeclaredAnnotations1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0106-rt-reflection-RTParametergetDeclaredAnnotations1/test.cfg b/testsuite/java_test/reflection_test/RT0106-rt-reflection-RTParametergetDeclaredAnnotations1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a56164a0bdd7162c492e926bbe8eea14178f1101
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0106-rt-reflection-RTParametergetDeclaredAnnotations1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetDeclaredAnnotations1)
+run(RTParameterGetDeclaredAnnotations1)
diff --git a/testsuite/java_test/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java b/testsuite/java_test/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java
new file mode 100755
index 0000000000000000000000000000000000000000..4af1505814a72d00ca7ad7ccac42ffe388045066
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/RTParameterGetDeclaredAnnotations2.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF4 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF4_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetDeclaredAnnotations2 {
+    ParameterGetDeclaredAnnotations2() {
+    }
+    ParameterGetDeclaredAnnotations2(@IF4(i = 222, t = "Parameter") int number) {
+    }
+    public void test1(@IF4(i = 222, t = "Parameter") String name) {
+    }
+}
+class ParameterGetDeclaredAnnotations2_a extends ParameterGetDeclaredAnnotations2 {
+    ParameterGetDeclaredAnnotations2_a() {
+    }
+    ParameterGetDeclaredAnnotations2_a(@IF4_a(c = 666, d = "Happy new year") int number) {
+    }
+    public void test1(@IF4_a(c = 666, d = "Happy new year") String name) {
+    }
+}
+class ParameterGetDeclaredAnnotations2_b extends ParameterGetDeclaredAnnotations2_a {
+    ParameterGetDeclaredAnnotations2_b(int number) {
+    }
+    public void test1(String name) {
+    }
+}
+public class RTParameterGetDeclaredAnnotations2 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotations2_b");
+            Constructor cons = cls.getDeclaredConstructor(int.class);
+            Method method = cls.getMethod("test1", String.class);
+            Parameter[] p1 = cons.getParameters();
+            Parameter[] p2 = method.getParameters();
+            if (p1[0].getDeclaredAnnotations().length == 0 && p2[0].getDeclaredAnnotations().length == 0) {
+                System.out.println(0);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(1);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/expected.txt b/testsuite/java_test/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/test.cfg b/testsuite/java_test/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..184ca2b1fd76d4b466903be11803828e8c3d8c4c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0107-rt-reflection-RTParametergetDeclaredAnnotations2/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetDeclaredAnnotations2)
+run(RTParameterGetDeclaredAnnotations2)
diff --git a/testsuite/java_test/reflection_test/RT0108-rt-reflection-RTParametergetDeclaredAnnotationsByType1/RTParameterGetDeclaredAnnotationsByType1.java b/testsuite/java_test/reflection_test/RT0108-rt-reflection-RTParametergetDeclaredAnnotationsByType1/RTParameterGetDeclaredAnnotationsByType1.java
new file mode 100755
index 0000000000000000000000000000000000000000..c8f60f1a7ab30d0f88bcca88d6bb42d8ba85d67e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0108-rt-reflection-RTParametergetDeclaredAnnotationsByType1/RTParameterGetDeclaredAnnotationsByType1.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF9 {
+    int i() default 0;
+    String t() default "";
+}
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface IF9_a {
+    int c() default 0;
+    String d() default "";
+}
+class ParameterGetDeclaredAnnotationsByType1 {
+    ParameterGetDeclaredAnnotationsByType1(@IF9(i = 222, t = "Parameter") int number) {
+    }
+    public ParameterGetDeclaredAnnotationsByType1(String name) {
+    }
+    public void test1(@IF9_a(c = 666, d = "Happy new year") int age) {
+    }
+}
+public class RTParameterGetDeclaredAnnotationsByType1 {
+    public static void main(String[] args) {
+        try {
+            Class cls = Class.forName("ParameterGetDeclaredAnnotationsByType1");
+            Constructor cons1 = cls.getDeclaredConstructor(int.class);
+            Constructor cons2 = cls.getConstructor(String.class);
+            Method method = cls.getMethod("test1", int.class);
+            Parameter[] p1 = cons1.getParameters();
+            Parameter[] p2 = cons2.getParameters();
+            Parameter[] p3 = method.getParameters();
+            Annotation[] q1 = p1[0].getDeclaredAnnotationsByType(IF9.class);
+            Annotation[] q3 = p3[0].getDeclaredAnnotationsByType(IF9_a.class);
+            if (p2[0].getDeclaredAnnotationsByType(IF9.class).length == 0) {
+                if (q1[0].toString().indexOf("i=222") != -1 && q1[0].toString().indexOf("t=Parameter") != -1
+                        && q3[0].toString().indexOf("c=666") != -1
+                        && q3[0].toString().indexOf("d=Happy new year") != -1) {
+                    System.out.println(0);
+                    return;
+                }
+                System.out.println(1);
+                return;
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+            return;
+        } catch (NoSuchMethodException e1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(4);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0108-rt-reflection-RTParametergetDeclaredAnnotationsByType1/expected.txt b/testsuite/java_test/reflection_test/RT0108-rt-reflection-RTParametergetDeclaredAnnotationsByType1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0108-rt-reflection-RTParametergetDeclaredAnnotationsByType1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0108-rt-reflection-RTParametergetDeclaredAnnotationsByType1/test.cfg b/testsuite/java_test/reflection_test/RT0108-rt-reflection-RTParametergetDeclaredAnnotationsByType1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a5fdcc4753c84b599f1a1b2bcd23b7f3d40f6e72
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0108-rt-reflection-RTParametergetDeclaredAnnotationsByType1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTParameterGetDeclaredAnnotationsByType1)
+run(RTParameterGetDeclaredAnnotationsByType1)
diff --git a/testsuite/java_test/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/RTProxyGetProxyClass1.java b/testsuite/java_test/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/RTProxyGetProxyClass1.java
new file mode 100755
index 0000000000000000000000000000000000000000..0cfe49e8493007d1718159e1193908d978ed7066
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/RTProxyGetProxyClass1.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Proxy;
+interface ProxyGetProxyClass1_1 {
+    default void test1() {
+    }
+    default void test2() {
+    }
+    default void test3() {
+    }
+    default void test4() {
+    }
+    default void test5() {
+    }
+    default void test6() {
+    }
+    default void test7() {
+    }
+    default void test8() {
+    }
+    default void test9() {
+    }
+    default void test10() {
+    }
+    default void test11() {
+    }
+    default void test12() {
+    }
+    default void test13() {
+    }
+    default void test14() {
+    }
+    default void test15() {
+    }
+    default void test16() {
+    }
+    default void test17() {
+    }
+    default void test18() {
+    }
+    default void test19() {
+    }
+    default void test20() {
+    }
+    default void test21() {
+    }
+    default void test22() {
+    }
+    default void test23() {
+    }
+    default void test24() {
+    }
+    default void test25() {
+    }
+    default void test26() {
+    }
+    default void test27() {
+    }
+    default void test28() {
+    }
+    default void test29() {
+    }
+    default void test30() {
+    }
+}
+interface ProxyGetProxyClass1_2 extends ProxyGetProxyClass1_1 {
+    default void test30() {
+    }
+}
+interface ProxyGetProxyClass1_3 {
+    default void test31() {
+    }
+}
+public class RTProxyGetProxyClass1 {
+    public static void main(String[] args) {
+        try {
+            Proxy.getProxyClass(ProxyGetProxyClass1_1.class.getClassLoader(), new Class[] {ProxyGetProxyClass1_1.class,
+                    ProxyGetProxyClass1_2.class});
+            Proxy.getProxyClass(ProxyGetProxyClass1_1.class.getClassLoader(), new Class[] {ProxyGetProxyClass1_1.class,
+                    ProxyGetProxyClass1_3.class});
+        } catch (IllegalArgumentException e) {
+            System.err.println(e);
+        }
+        System.out.println(0);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/expected.txt b/testsuite/java_test/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/test.cfg b/testsuite/java_test/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d78975803b8e406ec0b9744a0873300a7d5ac9a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0109-rt-reflection-RTProxygetProxyClass1/test.cfg
@@ -0,0 +1,2 @@
+compile(RTProxyGetProxyClass1)
+run(RTProxyGetProxyClass1)
diff --git a/testsuite/java_test/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java b/testsuite/java_test/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java
new file mode 100755
index 0000000000000000000000000000000000000000..2256d7426fbc829f9478d8fbd0a484cee85964da
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/ClassGetDeclaredAnnotationNPE.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+public class ClassGetDeclaredAnnotationNPE {
+    public static void main(String argv[]) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = ClassGetDeclaredAnnotationNPE_1();
+        } catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetDeclaredAnnotationNPE_1() {
+        try {
+            Annotation a = MyClass.class.getDeclaredAnnotation(Deprecated.class);
+            a = MyClass.class.getDeclaredAnnotation(null);
+        } catch (NullPointerException e) {
+            return 0;
+        }
+        return 4;
+    }
+    @Deprecated
+    class MyClass extends MySuperClass {
+    }
+    @MyAnnotation
+    class MySuperClass {
+    }
+    @interface MyAnnotation {
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/expected.txt b/testsuite/java_test/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/test.cfg b/testsuite/java_test/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..11d42b16a7053f585ed8ce24e657b917a7b54d19
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetDeclaredAnnotationNPE)
+run(ClassGetDeclaredAnnotationNPE)
diff --git a/testsuite/java_test/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java b/testsuite/java_test/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java
new file mode 100755
index 0000000000000000000000000000000000000000..5c3d31fcb9f6f4b2baf0f6541f3a3c5ee219baff
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/ClassIsAssignableFromNPE.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ClassIsAssignableFromNPE {
+    public static void main(String argv[]) {
+        int result = 2; /* STATUS_FAILED*/
+
+        try {
+            result = ClassIsAssignableFromNPE_1();
+        } catch (Exception e) {
+            System.out.println(e);
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassIsAssignableFromNPE_1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        int intArray[] = {1, 2, 3, 4, 5};
+        Class cl = null;
+        try {
+            intArray.getClass().isAssignableFrom(cl);
+        } catch (SecurityException e) {
+            return 1;
+        } catch (NullPointerException e) {
+            return 0;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/expected.txt b/testsuite/java_test/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/test.cfg b/testsuite/java_test/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..05a5d21e657eea9de01b7cc44de6772fa1b61fb5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0111-rt-reflection-reflectClasssetisAssignableFrom/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassIsAssignableFromNPE)
+run(ClassIsAssignableFromNPE)
diff --git a/testsuite/java_test/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java b/testsuite/java_test/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..c2e05eabad034f95ea0f2f62ed3fd1ea8ace0e13
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/ClassGetAnnotationsByType.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetAnnotationsByType1() {
+        Class<MyTargetTest0> m;
+        try {
+            m = MyTargetTest0.class;
+            MyTarget[] Target = m.getAnnotationsByType(MyTarget.class);
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest0 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest0(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/expected.txt b/testsuite/java_test/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/test.cfg b/testsuite/java_test/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1746ae1d4c38eb5f6fbc5a49626203dd6d18a5c7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0112-rt-reflection-ClassGetAnnotationsByType/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetAnnotationsByType)
+run(ClassGetAnnotationsByType)
diff --git a/testsuite/java_test/reflection_test/RT0113-rt-reflection-ClassGetCanonicalName/ClassGetCanonicalName.java b/testsuite/java_test/reflection_test/RT0113-rt-reflection-ClassGetCanonicalName/ClassGetCanonicalName.java
new file mode 100755
index 0000000000000000000000000000000000000000..793d1a033fe02ee9da05cf538c8409b5acf5b374
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0113-rt-reflection-ClassGetCanonicalName/ClassGetCanonicalName.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetCanonicalName {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetCanonicalName1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetCanonicalName1() {
+        Class<MyTargetTest1> m;
+        try {
+            m = MyTargetTest1.class;
+            String str = m.getCanonicalName();
+            if ("ClassGetCanonicalName.MyTargetTest1".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest1 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest1(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0113-rt-reflection-ClassGetCanonicalName/expected.txt b/testsuite/java_test/reflection_test/RT0113-rt-reflection-ClassGetCanonicalName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0113-rt-reflection-ClassGetCanonicalName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0113-rt-reflection-ClassGetCanonicalName/test.cfg b/testsuite/java_test/reflection_test/RT0113-rt-reflection-ClassGetCanonicalName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..99bdb27ce2323527b2393dd59483cb5461ecc3a3
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0113-rt-reflection-ClassGetCanonicalName/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetCanonicalName)
+run(ClassGetCanonicalName)
diff --git a/testsuite/java_test/reflection_test/RT0114-rt-reflection-ClassGetEnclosingClass/ClassGetEnclosingClass.java b/testsuite/java_test/reflection_test/RT0114-rt-reflection-ClassGetEnclosingClass/ClassGetEnclosingClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..e9b1d372d948a79ff3e96bfc7a6a16643b5213c4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0114-rt-reflection-ClassGetEnclosingClass/ClassGetEnclosingClass.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetEnclosingClass {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetEnclosingClass1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetEnclosingClass1() {
+        Class<MyTargetTest2> m;
+        try {
+            m = MyTargetTest2.class;
+            Class<?> cl = m.getEnclosingClass();
+            if (cl != null) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest2 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest2(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0114-rt-reflection-ClassGetEnclosingClass/expected.txt b/testsuite/java_test/reflection_test/RT0114-rt-reflection-ClassGetEnclosingClass/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0114-rt-reflection-ClassGetEnclosingClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0114-rt-reflection-ClassGetEnclosingClass/test.cfg b/testsuite/java_test/reflection_test/RT0114-rt-reflection-ClassGetEnclosingClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fb1fa999d94db1a2375eb612a28d4b651fa985aa
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0114-rt-reflection-ClassGetEnclosingClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetEnclosingClass)
+run(ClassGetEnclosingClass)
diff --git a/testsuite/java_test/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/ClassGetEnumConstants.java b/testsuite/java_test/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/ClassGetEnumConstants.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e7925810ea9f83e42b48986da30c511e4bd5aa3
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/ClassGetEnumConstants.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetEnumConstants {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetEnumConstants1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetEnumConstants1() {
+        Class<MyTargetTest3> m;
+        try {
+            m = MyTargetTest3.class;
+            MyTargetTest3[] target = m.getEnumConstants();
+            if (target == null) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest3 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest3(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/expected.txt b/testsuite/java_test/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/test.cfg b/testsuite/java_test/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8716e599ee7ed2fc1473feeab82a24bffe0b30e7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0115-rt-reflection-ClassGetEnumConstants/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetEnumConstants)
+run(ClassGetEnumConstants)
diff --git a/testsuite/java_test/reflection_test/RT0116-rt-reflection-ClassGetSimpleName/ClassGetSimpleName.java b/testsuite/java_test/reflection_test/RT0116-rt-reflection-ClassGetSimpleName/ClassGetSimpleName.java
new file mode 100755
index 0000000000000000000000000000000000000000..287ee245ec18379a141928115cd027802ff8c9e1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0116-rt-reflection-ClassGetSimpleName/ClassGetSimpleName.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassGetSimpleName {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetSimpleName1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetSimpleName1() {
+        Class<MyTargetTest4> m;
+        try {
+            m = MyTargetTest4.class;
+            String str = m.getSimpleName();
+            if ("MyTargetTest4".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest4 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest4(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0116-rt-reflection-ClassGetSimpleName/expected.txt b/testsuite/java_test/reflection_test/RT0116-rt-reflection-ClassGetSimpleName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0116-rt-reflection-ClassGetSimpleName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0116-rt-reflection-ClassGetSimpleName/test.cfg b/testsuite/java_test/reflection_test/RT0116-rt-reflection-ClassGetSimpleName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6414f8f96ec176b92f89fc487a1b20043216e79a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0116-rt-reflection-ClassGetSimpleName/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetSimpleName)
+run(ClassGetSimpleName)
diff --git a/testsuite/java_test/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/ClassGetTypeParameters.java b/testsuite/java_test/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/ClassGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..620a9b89666a5f351788178d36146231a4a9dd14
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/ClassGetTypeParameters.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.TypeVariable;
+public class ClassGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassGetTypeParameters1() {
+        Class<MyTargetTest5> m;
+        try {
+            m = MyTargetTest5.class;
+            TypeVariable<Class<MyTargetTest5>>[] target = m.getTypeParameters();
+            if (target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest5 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest5(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/expected.txt b/testsuite/java_test/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/test.cfg b/testsuite/java_test/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8cc856d7705d514508350c12b9075d78d8286135
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0117-rt-reflection-ClassGetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassGetTypeParameters)
+run(ClassGetTypeParameters)
diff --git a/testsuite/java_test/reflection_test/RT0118-rt-reflection-ClassToGenericString/ClassToGenericString.java b/testsuite/java_test/reflection_test/RT0118-rt-reflection-ClassToGenericString/ClassToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..df8c0a68549ed64ff679880782a204c081c93663
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0118-rt-reflection-ClassToGenericString/ClassToGenericString.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ClassToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ClassToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ClassToGenericString1() {
+        Class<MyTargetTest6> m;
+        try {
+            m = MyTargetTest6.class;
+            String str = m.toGenericString();
+            if ("class ClassToGenericString$MyTargetTest6".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest6 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest6(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0118-rt-reflection-ClassToGenericString/expected.txt b/testsuite/java_test/reflection_test/RT0118-rt-reflection-ClassToGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0118-rt-reflection-ClassToGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0118-rt-reflection-ClassToGenericString/test.cfg b/testsuite/java_test/reflection_test/RT0118-rt-reflection-ClassToGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..82b925b0b8d865e48ced9cbe2653e332282ee5a6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0118-rt-reflection-ClassToGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassToGenericString)
+run(ClassToGenericString)
diff --git a/testsuite/java_test/reflection_test/RT0119-rt-reflection-ConstructorGetAnnotation/ConstructorGetAnnotation.java b/testsuite/java_test/reflection_test/RT0119-rt-reflection-ConstructorGetAnnotation/ConstructorGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..f25b61cf4b35ee92353ddd159d1f5e0761023b2b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0119-rt-reflection-ConstructorGetAnnotation/ConstructorGetAnnotation.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+public class ConstructorGetAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorAnnotation1() {
+        Constructor<?> m;
+        try {
+            m = MyTargetTest00.class.getConstructor(new Class[] {ConstructorGetAnnotation.class, String.class});
+            MyTarget Target = m.getAnnotation(MyTarget.class);
+            if ("@ConstructorGetAnnotation$MyTarget(name=cons, value=constructor)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest00 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest00(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0119-rt-reflection-ConstructorGetAnnotation/expected.txt b/testsuite/java_test/reflection_test/RT0119-rt-reflection-ConstructorGetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0119-rt-reflection-ConstructorGetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0119-rt-reflection-ConstructorGetAnnotation/test.cfg b/testsuite/java_test/reflection_test/RT0119-rt-reflection-ConstructorGetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..54b390155e72078c49fe10152fa56be3e3c33cf7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0119-rt-reflection-ConstructorGetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorGetAnnotation)
+run(ConstructorGetAnnotation)
diff --git a/testsuite/java_test/reflection_test/RT0120-rt-reflection-ConstructorGetDeclaredAnnotations/ConstructorGetDeclaredAnnotations.java b/testsuite/java_test/reflection_test/RT0120-rt-reflection-ConstructorGetDeclaredAnnotations/ConstructorGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..1532e8ae3cc77883cde7ca335e4ac8d609c883d9
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0120-rt-reflection-ConstructorGetDeclaredAnnotations/ConstructorGetDeclaredAnnotations.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+public class ConstructorGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorGetDeclaredAnnotations1() {
+        Constructor<MyTargetTest01> m;
+        try {
+            m = MyTargetTest01.class.getConstructor(new Class[] {ConstructorGetDeclaredAnnotations.class, String.class});
+            MyTarget Target = m.getDeclaredAnnotation(MyTarget.class);
+            if ("@ConstructorGetDeclaredAnnotations$MyTarget(name=cons, value=constructor)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest01 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest01(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0120-rt-reflection-ConstructorGetDeclaredAnnotations/expected.txt b/testsuite/java_test/reflection_test/RT0120-rt-reflection-ConstructorGetDeclaredAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0120-rt-reflection-ConstructorGetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0120-rt-reflection-ConstructorGetDeclaredAnnotations/test.cfg b/testsuite/java_test/reflection_test/RT0120-rt-reflection-ConstructorGetDeclaredAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..11801b80486cdf8170f6312c7ba512a56c65a763
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0120-rt-reflection-ConstructorGetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorGetDeclaredAnnotations)
+run(ConstructorGetDeclaredAnnotations)
diff --git a/testsuite/java_test/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java b/testsuite/java_test/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java
new file mode 100755
index 0000000000000000000000000000000000000000..f4f63ff8b30dccd4dfdda94c1bb685eb623e6d94
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/ConstructorGetExceptionTypes.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+public class ConstructorGetExceptionTypes {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetExceptionTypes1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorGetExceptionTypes1() {
+        Constructor<MyTargetTest02> m;
+        try {
+            m = MyTargetTest02.class.getConstructor(new Class[] {ConstructorGetExceptionTypes.class, String.class});
+            Class<?>[] Target = m.getExceptionTypes();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest02 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest02(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/expected.txt b/testsuite/java_test/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/test.cfg b/testsuite/java_test/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..13fb057a727642d2efb45cefa56074453816a710
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0121-rt-reflection-ConstructorGetExceptionTypes/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorGetExceptionTypes)
+run(ConstructorGetExceptionTypes)
diff --git a/testsuite/java_test/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java b/testsuite/java_test/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..9c2107f9aacf468d44e902baf6ed920c64b80ac5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/ConstructorGetTypeParameters.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.TypeVariable;
+public class ConstructorGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorGetTypeParameters1() {
+        Constructor<MyTargetTest03> m;
+        try {
+            m = MyTargetTest03.class.getConstructor(new Class[] {ConstructorGetTypeParameters.class, String.class});
+            TypeVariable<Constructor<MyTargetTest03>>[] Target = m.getTypeParameters();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest03 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest03(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/expected.txt b/testsuite/java_test/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/test.cfg b/testsuite/java_test/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f9bb972a1b576153bba3ac2192b1323c2b1327fc
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0122-rt-reflection-ConstructorGetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorGetTypeParameters)
+run(ConstructorGetTypeParameters)
diff --git a/testsuite/java_test/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/ConstructorToGenericString.java b/testsuite/java_test/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/ConstructorToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..bc18f2200d4021f88d6f7d800f19b966d9dbebfb
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/ConstructorToGenericString.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+public class ConstructorToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ConstructorToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ConstructorToGenericString1() {
+        Constructor<MyTargetTest04> m;
+        try {
+            m = MyTargetTest04.class.getConstructor(new Class[] {ConstructorToGenericString.class, String.class});
+            String str = m.toGenericString();
+            if ("public ConstructorToGenericString$MyTargetTest04(ConstructorToGenericString,java.lang.String)"
+                    .equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest04 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest04(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/expected.txt b/testsuite/java_test/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/test.cfg b/testsuite/java_test/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..69af375db60ee8062093f561671bff0da906977b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0123-rt-reflection-ConstructorToGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorToGenericString)
+run(ConstructorToGenericString)
diff --git a/testsuite/java_test/reflection_test/RT0124-rt-reflection-FieldGetAnnotation/FieldGetAnnotation.java b/testsuite/java_test/reflection_test/RT0124-rt-reflection-FieldGetAnnotation/FieldGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..ead36eba2ab4fe269723dbd9f87d5e45d81f7354
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0124-rt-reflection-FieldGetAnnotation/FieldGetAnnotation.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldGetAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldGetAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int FieldGetAnnotation1() {
+        Field m;
+        try {
+            m = MyTargetTest06.class.getField("home");
+            MyTarget Target = m.getAnnotation(MyTarget.class);
+            if ("@FieldGetAnnotation$MyTarget(name=newName, value=newValue)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest06 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0124-rt-reflection-FieldGetAnnotation/expected.txt b/testsuite/java_test/reflection_test/RT0124-rt-reflection-FieldGetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0124-rt-reflection-FieldGetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0124-rt-reflection-FieldGetAnnotation/test.cfg b/testsuite/java_test/reflection_test/RT0124-rt-reflection-FieldGetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..70b9ee3acb085745bb72a8a195db940ebd009a50
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0124-rt-reflection-FieldGetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetAnnotation)
+run(FieldGetAnnotation)
diff --git a/testsuite/java_test/reflection_test/RT0125-rt-reflection-FieldGetAnnotationsByType/FieldGetAnnotationsByType.java b/testsuite/java_test/reflection_test/RT0125-rt-reflection-FieldGetAnnotationsByType/FieldGetAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..f0d0c61dcfb95400110ef9087b3eabb7614761c5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0125-rt-reflection-FieldGetAnnotationsByType/FieldGetAnnotationsByType.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int FieldGetAnnotationsByType1() {
+        Field m;
+        try {
+            m = MyTargetTest07.class.getField("home");
+            MyTarget[] Target = m.getAnnotationsByType(MyTarget.class);
+            if (Target.length > 0) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest07 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest07(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0125-rt-reflection-FieldGetAnnotationsByType/expected.txt b/testsuite/java_test/reflection_test/RT0125-rt-reflection-FieldGetAnnotationsByType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0125-rt-reflection-FieldGetAnnotationsByType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0125-rt-reflection-FieldGetAnnotationsByType/test.cfg b/testsuite/java_test/reflection_test/RT0125-rt-reflection-FieldGetAnnotationsByType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fdbc885a3e3720c03490fc555bf9c523931d94f5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0125-rt-reflection-FieldGetAnnotationsByType/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetAnnotationsByType)
+run(FieldGetAnnotationsByType)
diff --git a/testsuite/java_test/reflection_test/RT0126-rt-reflection-FieldGetDeclaredAnnotations/FieldGetDeclaredAnnotations.java b/testsuite/java_test/reflection_test/RT0126-rt-reflection-FieldGetDeclaredAnnotations/FieldGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..3014d080066c41e40a6272284a16e14fade5ec16
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0126-rt-reflection-FieldGetDeclaredAnnotations/FieldGetDeclaredAnnotations.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetDeclaredAnnotations1() {
+        Field m;
+        try {
+            m = MyTargetTest08.class.getField("home");
+            MyTarget Target = m.getDeclaredAnnotation(MyTarget.class);
+            if ("@FieldGetDeclaredAnnotations$MyTarget(name=newName, value=newValue)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest08 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest08(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0126-rt-reflection-FieldGetDeclaredAnnotations/expected.txt b/testsuite/java_test/reflection_test/RT0126-rt-reflection-FieldGetDeclaredAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0126-rt-reflection-FieldGetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0126-rt-reflection-FieldGetDeclaredAnnotations/test.cfg b/testsuite/java_test/reflection_test/RT0126-rt-reflection-FieldGetDeclaredAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..89d4c1ad916e134bf3885445a302690f09f26bd2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0126-rt-reflection-FieldGetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldGetDeclaredAnnotations)
+run(FieldGetDeclaredAnnotations)
diff --git a/testsuite/java_test/reflection_test/RT0127-rt-reflection-FieldIsAnnotationPresent/FieldIsAnnotationPresent.java b/testsuite/java_test/reflection_test/RT0127-rt-reflection-FieldIsAnnotationPresent/FieldIsAnnotationPresent.java
new file mode 100755
index 0000000000000000000000000000000000000000..214c0f54c4efda21df833706a2cefe0d8d875922
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0127-rt-reflection-FieldIsAnnotationPresent/FieldIsAnnotationPresent.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldIsAnnotationPresent {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodIsAnnotationPresent1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodIsAnnotationPresent1() {
+        Field m;
+        try {
+            m = MyTargetTest09.class.getField("home");
+            boolean flag = m.isAnnotationPresent(MyTarget.class);
+            if (flag) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest09 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest09(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0127-rt-reflection-FieldIsAnnotationPresent/expected.txt b/testsuite/java_test/reflection_test/RT0127-rt-reflection-FieldIsAnnotationPresent/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0127-rt-reflection-FieldIsAnnotationPresent/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0127-rt-reflection-FieldIsAnnotationPresent/test.cfg b/testsuite/java_test/reflection_test/RT0127-rt-reflection-FieldIsAnnotationPresent/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2257a4f4866251512e0c6b9976f701a70f6fa0c1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0127-rt-reflection-FieldIsAnnotationPresent/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldIsAnnotationPresent)
+run(FieldIsAnnotationPresent)
diff --git a/testsuite/java_test/reflection_test/RT0128-rt-reflection-FieldToGenericString/FieldToGenericString.java b/testsuite/java_test/reflection_test/RT0128-rt-reflection-FieldToGenericString/FieldToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..88d89c0a7f99eea8b7bfff1ae5a6eb42d44df9a2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0128-rt-reflection-FieldToGenericString/FieldToGenericString.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+public class FieldToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = FieldToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int FieldToGenericString1() {
+        Field m;
+        try {
+            m = MyTargetTest10.class.getField("home");
+            String str = m.toGenericString();
+            if ("public java.lang.String FieldToGenericString$MyTargetTest10.home".equals(str)) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest10 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest10(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0128-rt-reflection-FieldToGenericString/expected.txt b/testsuite/java_test/reflection_test/RT0128-rt-reflection-FieldToGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0128-rt-reflection-FieldToGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0128-rt-reflection-FieldToGenericString/test.cfg b/testsuite/java_test/reflection_test/RT0128-rt-reflection-FieldToGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e26bcb6528f91352ca299ef2a04efd63acbeca3f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0128-rt-reflection-FieldToGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldToGenericString)
+run(FieldToGenericString)
diff --git a/testsuite/java_test/reflection_test/RT0129-rt-reflection-MethodGetAnnotation/MethodGetAnnotation.java b/testsuite/java_test/reflection_test/RT0129-rt-reflection-MethodGetAnnotation/MethodGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..4131586e5490966778d197a035ab5ee787198fd5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0129-rt-reflection-MethodGetAnnotation/MethodGetAnnotation.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodGetAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetAnnotation1() {
+        Method m;
+        try {
+            m = MyTargetTest11.class.getMethod("MyTargetTest_1");
+            MyTarget Target = m.getAnnotation(MyTarget.class);
+            if ("@MethodGetAnnotation$MyTarget(name=name, value=value)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest11 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0129-rt-reflection-MethodGetAnnotation/expected.txt b/testsuite/java_test/reflection_test/RT0129-rt-reflection-MethodGetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0129-rt-reflection-MethodGetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0129-rt-reflection-MethodGetAnnotation/test.cfg b/testsuite/java_test/reflection_test/RT0129-rt-reflection-MethodGetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a00548a8f302ca65b375f01264072446162f5429
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0129-rt-reflection-MethodGetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetAnnotation)
+run(MethodGetAnnotation)
diff --git a/testsuite/java_test/reflection_test/RT0130-rt-reflection-MethodGetDeclaredAnnotations/MethodGetDeclaredAnnotations.java b/testsuite/java_test/reflection_test/RT0130-rt-reflection-MethodGetDeclaredAnnotations/MethodGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..b81668d39c5c4c4b5d9256b790da79cbaccc5aee
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0130-rt-reflection-MethodGetDeclaredAnnotations/MethodGetDeclaredAnnotations.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetDeclaredAnnotations1() {
+        Method m;
+        try {
+            m = MyTargetTest12.class.getMethod("MyTargetTest_1");
+            MyTarget Target = m.getDeclaredAnnotation(MyTarget.class);
+            if ("@MethodGetDeclaredAnnotations$MyTarget(name=name, value=value)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest12 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest12(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0130-rt-reflection-MethodGetDeclaredAnnotations/expected.txt b/testsuite/java_test/reflection_test/RT0130-rt-reflection-MethodGetDeclaredAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0130-rt-reflection-MethodGetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0130-rt-reflection-MethodGetDeclaredAnnotations/test.cfg b/testsuite/java_test/reflection_test/RT0130-rt-reflection-MethodGetDeclaredAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5b1644f9189bef694f20ad9e104331e39bb5c6a2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0130-rt-reflection-MethodGetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetDeclaredAnnotations)
+run(MethodGetDeclaredAnnotations)
diff --git a/testsuite/java_test/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/MethodGetDefaultValue.java b/testsuite/java_test/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/MethodGetDefaultValue.java
new file mode 100755
index 0000000000000000000000000000000000000000..533de7414ab103ec8c4f94cf59ab619286522379
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/MethodGetDefaultValue.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+public class MethodGetDefaultValue {
+    public static void main(String[] argv) {
+        int result = 2/* STATUS_FAILED*/
+;
+        try {
+            result = MethodGetDefaultValueTypeNotPresent_1();
+        } catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetDefaultValueTypeNotPresent_1() {
+        try {
+            Method m = MyTargetTest13.class.getMethod("MyTargetTest_1");
+            Object a = m.getDefaultValue();
+        } catch (TypeNotPresentException e) {
+            return 3;
+        } catch (NoSuchMethodException e) {
+            return 4;
+        }
+        return 0;
+    }
+    @Target(ElementType.TYPE)
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        Class style() default String.class;
+    }
+    @MyTarget()
+    class MyTargetTest13 {
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/expected.txt b/testsuite/java_test/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/test.cfg b/testsuite/java_test/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2e09141962b90f73494b56721539350fdcbc9bf8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0131-rt-reflection-MethodgetDefaultValue/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetDefaultValue)
+run(MethodGetDefaultValue)
diff --git a/testsuite/java_test/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/MethodGetParameterCount.java b/testsuite/java_test/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/MethodGetParameterCount.java
new file mode 100755
index 0000000000000000000000000000000000000000..f4e20acf40a49f3251ba57b683f6a6831e712af8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/MethodGetParameterCount.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodGetParameterCount {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetParameterCount1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetParameterCount1() {
+        Method m;
+        try {
+            m = MyTargetTest14.class.getMethod("MyTargetTest_1");
+            int num = m.getParameterCount();
+            if (num == 0) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest14 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest14(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/expected.txt b/testsuite/java_test/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/test.cfg b/testsuite/java_test/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6861c2480f7468521d78ebf2526df25aea62e9de
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0132-rt-reflection-MethodGetParameterCount/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetParameterCount)
+run(MethodGetParameterCount)
diff --git a/testsuite/java_test/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/MethodGetTypeParameters.java b/testsuite/java_test/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/MethodGetTypeParameters.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e1757aec2da12a2978b242241be357057ec61ab
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/MethodGetTypeParameters.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.TypeVariable;
+public class MethodGetTypeParameters {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodGetTypeParameters1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodGetTypeParameters1() {
+        Method m;
+        try {
+            m = MyTargetTest15.class.getMethod("MyTargetTest_1");
+            TypeVariable<Method>[] Target = m.getTypeParameters();
+            if (Target.length == 0) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest15 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest15(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/expected.txt b/testsuite/java_test/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/test.cfg b/testsuite/java_test/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a9da6d2fc2dde49b4c682d84a8165cfdcfee7c34
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0133-rt-reflection-MethodGetTypeParameters/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodGetTypeParameters)
+run(MethodGetTypeParameters)
diff --git a/testsuite/java_test/reflection_test/RT0134-rt-reflection-MethodIsDefault/MethodIsDefault.java b/testsuite/java_test/reflection_test/RT0134-rt-reflection-MethodIsDefault/MethodIsDefault.java
new file mode 100755
index 0000000000000000000000000000000000000000..0955dfbf47461734ceebc6181ac674fe51febf79
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0134-rt-reflection-MethodIsDefault/MethodIsDefault.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodIsDefault {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodIsDefault1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodIsDefault1() {
+        Method m;
+        try {
+            m = MyTargetTest16.class.getMethod("MyTargetTest_1");
+            boolean flag = m.isDefault();
+            if (!flag) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest16 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest16(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0134-rt-reflection-MethodIsDefault/expected.txt b/testsuite/java_test/reflection_test/RT0134-rt-reflection-MethodIsDefault/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0134-rt-reflection-MethodIsDefault/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0134-rt-reflection-MethodIsDefault/test.cfg b/testsuite/java_test/reflection_test/RT0134-rt-reflection-MethodIsDefault/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c6f17112622ac86bb62b30f152bd060b487b6f0c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0134-rt-reflection-MethodIsDefault/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodIsDefault)
+run(MethodIsDefault)
diff --git a/testsuite/java_test/reflection_test/RT0135-rt-reflection-MethodToGenericString/MethodToGenericString.java b/testsuite/java_test/reflection_test/RT0135-rt-reflection-MethodToGenericString/MethodToGenericString.java
new file mode 100755
index 0000000000000000000000000000000000000000..92d65175aeadf73c6f6f4002ff5bffd81237a5a4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0135-rt-reflection-MethodToGenericString/MethodToGenericString.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+public class MethodToGenericString {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = MethodToGenericString1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int MethodToGenericString1() {
+        Method m;
+        try {
+            m = MyTargetTest17.class.getMethod("MyTargetTest_1");
+            String str = m.toGenericString();
+            if ("public void MethodToGenericString$MyTargetTest17.MyTargetTest_1()".equals(str)) {
+                return 0;
+            }
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest17 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest17(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0135-rt-reflection-MethodToGenericString/expected.txt b/testsuite/java_test/reflection_test/RT0135-rt-reflection-MethodToGenericString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0135-rt-reflection-MethodToGenericString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0135-rt-reflection-MethodToGenericString/test.cfg b/testsuite/java_test/reflection_test/RT0135-rt-reflection-MethodToGenericString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..db0eec92f99d634aabbfd135b03aec95afb3ef78
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0135-rt-reflection-MethodToGenericString/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodToGenericString)
+run(MethodToGenericString)
diff --git a/testsuite/java_test/reflection_test/RT0136-rt-reflection-ParameterGetAnnotation/ParameterGetAnnotation.java b/testsuite/java_test/reflection_test/RT0136-rt-reflection-ParameterGetAnnotation/ParameterGetAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..86de54c336db91b6bfc15a2677b9f2c9559ac755
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0136-rt-reflection-ParameterGetAnnotation/ParameterGetAnnotation.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetAnnotation {
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetAnnotation1() {
+        Method m;
+        try {
+            m = MyTargetTest18.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget Target = parameters[0].getAnnotation(MyTarget.class);
+            if ("@ParameterGetAnnotation$MyTarget(name=name1, value=value1)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest18 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+    }
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0136-rt-reflection-ParameterGetAnnotation/expected.txt b/testsuite/java_test/reflection_test/RT0136-rt-reflection-ParameterGetAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0136-rt-reflection-ParameterGetAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0136-rt-reflection-ParameterGetAnnotation/test.cfg b/testsuite/java_test/reflection_test/RT0136-rt-reflection-ParameterGetAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8554f71699f7e6139e7044d524a89f9786360509
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0136-rt-reflection-ParameterGetAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetAnnotation)
+run(ParameterGetAnnotation)
diff --git a/testsuite/java_test/reflection_test/RT0137-rt-reflection-ParameterGetAnnotations/ParameterGetAnnotations.java b/testsuite/java_test/reflection_test/RT0137-rt-reflection-ParameterGetAnnotations/ParameterGetAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..dc88efdca5e216a5b3d8eba102a66036732269a7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0137-rt-reflection-ParameterGetAnnotations/ParameterGetAnnotations.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+public class ParameterGetAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetAnnotations1() {
+        Method m;
+        try {
+            m = MyTargetTest19.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            Annotation[] Target = parameters[0].getAnnotations();
+            if ("@ParameterGetAnnotations$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest19 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest19(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0137-rt-reflection-ParameterGetAnnotations/expected.txt b/testsuite/java_test/reflection_test/RT0137-rt-reflection-ParameterGetAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0137-rt-reflection-ParameterGetAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0137-rt-reflection-ParameterGetAnnotations/test.cfg b/testsuite/java_test/reflection_test/RT0137-rt-reflection-ParameterGetAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f582e9e52295cb23bfaba1d197b4704e2cf999aa
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0137-rt-reflection-ParameterGetAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetAnnotations)
+run(ParameterGetAnnotations)
diff --git a/testsuite/java_test/reflection_test/RT0138-rt-reflection-ParameterGetAnnotationsByType/ParameterGetAnnotationsByType.java b/testsuite/java_test/reflection_test/RT0138-rt-reflection-ParameterGetAnnotationsByType/ParameterGetAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..e53f77b41cce3357d0e6fd4ff7d7b99ed4ac73b1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0138-rt-reflection-ParameterGetAnnotationsByType/ParameterGetAnnotationsByType.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetAnnotationsByType1() {
+        Method m;
+        try {
+            m = MyTargetTest20.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget[] Target = parameters[0].getAnnotationsByType(MyTarget.class);
+            if ("@ParameterGetAnnotationsByType$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest20 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest20(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0138-rt-reflection-ParameterGetAnnotationsByType/expected.txt b/testsuite/java_test/reflection_test/RT0138-rt-reflection-ParameterGetAnnotationsByType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0138-rt-reflection-ParameterGetAnnotationsByType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0138-rt-reflection-ParameterGetAnnotationsByType/test.cfg b/testsuite/java_test/reflection_test/RT0138-rt-reflection-ParameterGetAnnotationsByType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7388addf17fc452d9d8ca87280919815794fe9e0
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0138-rt-reflection-ParameterGetAnnotationsByType/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetAnnotationsByType)
+run(ParameterGetAnnotationsByType)
diff --git a/testsuite/java_test/reflection_test/RT0139-rt-reflection-ParameterGetDeclaredAnnotation/ParameterGetDeclaredAnnotation.java b/testsuite/java_test/reflection_test/RT0139-rt-reflection-ParameterGetDeclaredAnnotation/ParameterGetDeclaredAnnotation.java
new file mode 100755
index 0000000000000000000000000000000000000000..73c96f1ef53a31eb295134f98a01046b78d88637
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0139-rt-reflection-ParameterGetDeclaredAnnotation/ParameterGetDeclaredAnnotation.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetDeclaredAnnotation {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetDeclaredAnnotation1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetDeclaredAnnotation1() {
+        Method m;
+        try {
+            m = MyTargetTest21.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget Target = parameters[0].getDeclaredAnnotation(MyTarget.class);
+            if ("@ParameterGetDeclaredAnnotation$MyTarget(name=name1, value=value1)".equals(Target.toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest21 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest21(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0139-rt-reflection-ParameterGetDeclaredAnnotation/expected.txt b/testsuite/java_test/reflection_test/RT0139-rt-reflection-ParameterGetDeclaredAnnotation/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0139-rt-reflection-ParameterGetDeclaredAnnotation/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0139-rt-reflection-ParameterGetDeclaredAnnotation/test.cfg b/testsuite/java_test/reflection_test/RT0139-rt-reflection-ParameterGetDeclaredAnnotation/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f2abad221b17a1f6bbe372c085c3b81c6fc97d69
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0139-rt-reflection-ParameterGetDeclaredAnnotation/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetDeclaredAnnotation)
+run(ParameterGetDeclaredAnnotation)
diff --git a/testsuite/java_test/reflection_test/RT0140-rt-reflection-ParameterGetDeclaredAnnotations/ParameterGetDeclaredAnnotations.java b/testsuite/java_test/reflection_test/RT0140-rt-reflection-ParameterGetDeclaredAnnotations/ParameterGetDeclaredAnnotations.java
new file mode 100755
index 0000000000000000000000000000000000000000..56b4ef51b3dd0c7f7485b450b7508060f3f87438
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0140-rt-reflection-ParameterGetDeclaredAnnotations/ParameterGetDeclaredAnnotations.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetDeclaredAnnotations {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetDeclaredAnnotations1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetDeclaredAnnotations1() {
+        Method m;
+        try {
+            m = MyTargetTest22.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            Annotation[] Target = parameters[0].getDeclaredAnnotations();
+            if ("@ParameterGetDeclaredAnnotations$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest22 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest22(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0140-rt-reflection-ParameterGetDeclaredAnnotations/expected.txt b/testsuite/java_test/reflection_test/RT0140-rt-reflection-ParameterGetDeclaredAnnotations/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0140-rt-reflection-ParameterGetDeclaredAnnotations/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0140-rt-reflection-ParameterGetDeclaredAnnotations/test.cfg b/testsuite/java_test/reflection_test/RT0140-rt-reflection-ParameterGetDeclaredAnnotations/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68fd03412f5a225a92ede3f516656ec435489d70
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0140-rt-reflection-ParameterGetDeclaredAnnotations/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetDeclaredAnnotations)
+run(ParameterGetDeclaredAnnotations)
diff --git a/testsuite/java_test/reflection_test/RT0141-rt-reflection-ParameterGetDeclaredAnnotationsByType/ParameterGetDeclaredAnnotationsByType.java b/testsuite/java_test/reflection_test/RT0141-rt-reflection-ParameterGetDeclaredAnnotationsByType/ParameterGetDeclaredAnnotationsByType.java
new file mode 100755
index 0000000000000000000000000000000000000000..ab0de6845cadfb58fe1a2373a46564a4f5be1db4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0141-rt-reflection-ParameterGetDeclaredAnnotationsByType/ParameterGetDeclaredAnnotationsByType.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+public class ParameterGetDeclaredAnnotationsByType {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyTarget {
+        public String name();
+        public String value();
+    }
+    public static void main(String[] args) {
+        int result = 2;
+        try {
+            result = ParameterGetDeclaredAnnotationsByType1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            result = 3;
+        }
+        System.out.println(result);
+    }
+    public static int ParameterGetDeclaredAnnotationsByType1() {
+        Method m;
+        try {
+            m = MyTargetTest23.class.getMethod("newMethod", new Class[] {String.class});
+            Parameter[] parameters = m.getParameters();
+            MyTarget[] Target = parameters[0].getDeclaredAnnotationsByType(MyTarget.class);
+            if ("@ParameterGetDeclaredAnnotationsByType$MyTarget(name=name1, value=value1)".equals(Target[0].toString())) {
+                return 0;
+            }
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return 2;
+    }
+    class MyTargetTest23 {
+        @MyTarget(name = "newName", value = "newValue")
+        public String home;
+        @MyTarget(name = "name", value = "value")
+        public void MyTargetTest_1() {
+            System.out.println("This is Example:hello world");
+        }
+        public void newMethod(@MyTarget(name = "name1", value = "value1") String home) {
+            System.out.println("my home at:" + home);
+        }
+        @MyTarget(name = "cons", value = "constructor")
+        public MyTargetTest23(String home) {
+            this.home = home;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0141-rt-reflection-ParameterGetDeclaredAnnotationsByType/expected.txt b/testsuite/java_test/reflection_test/RT0141-rt-reflection-ParameterGetDeclaredAnnotationsByType/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0141-rt-reflection-ParameterGetDeclaredAnnotationsByType/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0141-rt-reflection-ParameterGetDeclaredAnnotationsByType/test.cfg b/testsuite/java_test/reflection_test/RT0141-rt-reflection-ParameterGetDeclaredAnnotationsByType/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2d994d2af026b54aa06adcfb1e5eec7a3dcd0c58
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0141-rt-reflection-ParameterGetDeclaredAnnotationsByType/test.cfg
@@ -0,0 +1,2 @@
+compile(ParameterGetDeclaredAnnotationsByType)
+run(ParameterGetDeclaredAnnotationsByType)
diff --git a/testsuite/java_test/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java b/testsuite/java_test/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java
new file mode 100755
index 0000000000000000000000000000000000000000..823bc0c4a658d9eb96cfc540483d84ab693d6692
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/ReflectionAnnotationGetClass.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.util.Arrays;
+public class ReflectionAnnotationGetClass {
+    public static void main(String[] args) {
+        int result = 2;
+        try{
+            // Check point 1 : only 1 annotation in user-defined Class Two.
+            Annotation[] annotations1 = Class.forName("Two").getAnnotations();
+            if (annotations1.length == 1){
+                if (annotations1[0].getClass().toString().startsWith("class $Proxy")) {
+                    result --;
+                }
+            }
+            // Check point 2 : 3 annotations in Class java.lang.annotation.Documented.
+            Annotation[] annotations2 = Class.forName("java.lang.annotation.Documented").getAnnotations();
+            String [] annoClazz = new String[annotations2.length];
+            for (int i = 0; i < annoClazz.length; i++) {
+                annoClazz[i] = annotations2[i].getClass().toString();
+            }
+            Arrays.sort(annoClazz);
+            if (annotations2.length == 3) {
+                if (annoClazz[0].startsWith("class $Proxy") && annoClazz[1]
+                        .startsWith("class $Proxy")
+                        && annoClazz[2].startsWith("class $Proxy")) {
+                    result --;
+                }
+            }
+        }catch (Exception e) {
+            result = 3;
+        }
+        System.out.println(result);
+    }
+}
+@A0
+class Two{}
+@Retention(RetentionPolicy.RUNTIME) @interface A0 {}
diff --git a/testsuite/java_test/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/expected.txt b/testsuite/java_test/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/test.cfg b/testsuite/java_test/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4784ac8797c300c5f14036eb0ab3233022d4330d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0142-rt-reflection-ReflectionAnnotationGetClass/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionAnnotationGetClass)
+run(ReflectionAnnotationGetClass)
diff --git a/testsuite/java_test/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/ClassInitClassNewInstance.java b/testsuite/java_test/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/ClassInitClassNewInstance.java
new file mode 100755
index 0000000000000000000000000000000000000000..396877ebcb270e1cafd05fffe6ffc801546efbc9
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/ClassInitClassNewInstance.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+public class ClassInitClassNewInstance {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try{
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            /* Check point 1: no class initialization when calling following methods of Class
+             * not test clazz.cast(Object obj) because it success only when obj is an instance of One or Two,
+             * and need to call new One(), which result in Class initialization.*/
+
+            clazz.asSubclass(clazz);
+            clazz.desiredAssertionStatus();
+            clazz.getAnnotation(A.class);
+            clazz.getAnnotations();
+            clazz.getAnnotationsByType(A.class);
+            clazz.getCanonicalName();
+            clazz.getClasses();
+            clazz.getClassLoader();
+            clazz.getComponentType();
+            clazz.getConstructor(String.class);
+            clazz.getConstructors();
+            clazz.getDeclaredAnnotation(A.class);
+            clazz.getDeclaredAnnotations();
+            clazz.getDeclaredAnnotationsByType(A.class);
+            clazz.getDeclaredClasses();
+            clazz.getDeclaredConstructor(String.class);
+            clazz.getDeclaredConstructors();
+            clazz.getDeclaredField("what");
+            clazz.getDeclaredFields();
+            clazz.getDeclaredMethod("testOne", String.class);
+            clazz.getDeclaredMethods();
+            clazz.getDeclaringClass();
+            clazz.getEnclosingClass();
+            clazz.getEnclosingConstructor();
+            clazz.getEnclosingMethod();
+            clazz.getEnumConstants();
+            clazz.getField("hi");
+            clazz.getFields();
+            clazz.getGenericInterfaces();
+            clazz.getGenericSuperclass();
+            clazz.getInterfaces();
+            clazz.getMethod("testOne",String.class);
+            clazz.getMethods();
+            clazz.getModifiers();
+            clazz.getName();
+            clazz.getPackage();
+            clazz.getProtectionDomain();
+            clazz.getSigners();
+            clazz.getSimpleName();
+            clazz.getSuperclass();
+            clazz.getTypeName();
+            clazz.getTypeParameters();
+            clazz.isAnnotation();
+            clazz.isAnnotationPresent(A.class);
+            clazz.isAnonymousClass();
+            clazz.isArray();
+            clazz.isAssignableFrom(clazz);
+            clazz.isEnum();
+            clazz.isInstance(new Object());
+            clazz.isInterface();
+            clazz.isLocalClass();
+            clazz.isMemberClass();
+            clazz.isPrimitive();
+            clazz.isSynthetic();
+            clazz.toString();
+            clazz.toGenericString();
+            clazz.getResource("hi");
+            clazz.getResourceAsStream("hi");
+            // Check point 2: when call newInstance, start class initialization
+            if (result.toString().compareTo("") == 0) {
+                clazz.newInstance();
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitClassNewInstance.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitClassNewInstance.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitClassNewInstance.result.append("One");
+    }
+    String what = "lala";
+    public String hi = "";
+    One(){}
+    public One(String s){
+        what = s;
+        System.out.println(s);
+    }
+    public int testOne(String a){
+        System.out.println(a);
+        return 0;
+    }
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitClassNewInstance.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitClassNewInstance.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/expected.txt b/testsuite/java_test/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/test.cfg b/testsuite/java_test/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..91b181ff9f3f736fafacb015666bc963ca6fb181
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0143-rt-reflection-ClinitClassNewInstance/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitClassNewInstance)
+run(ClassInitClassNewInstance)
diff --git a/testsuite/java_test/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java b/testsuite/java_test/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java
new file mode 100755
index 0000000000000000000000000000000000000000..113b45f4f6eca4dd1ee0a9e1f15d12fd4001797a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/ClassInitConstructorNewInstance.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Constructor;
+public class ClassInitConstructorNewInstance {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Constructor constructor = clazz.getConstructor(String.class);
+            //check point 1: calling following methods, class not initialized
+            constructor.equals(constructor);
+            constructor.getAnnotation(A.class);
+            constructor.getDeclaredAnnotations();
+            constructor.getDeclaringClass();
+            constructor.getExceptionTypes();
+            constructor.getGenericExceptionTypes();
+            constructor.getGenericParameterTypes();
+            constructor.getModifiers();
+            constructor.getName();
+            constructor.getParameterAnnotations();
+            constructor.getParameterCount();
+            constructor.getParameterTypes();
+            constructor.hashCode();
+            constructor.isSynthetic();
+            constructor.isVarArgs();
+            constructor.toString();
+            constructor.toGenericString();
+            //check point 2: after call newInstance(), class initialized
+            if (result.toString().compareTo("") == 0) {
+                constructor.newInstance("newInstance");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitConstructorNewInstance.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitConstructorNewInstance.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitConstructorNewInstance.result.append("One");
+    }
+    String what = "lala";
+    One(){}
+    public One(String s){
+        what = s;
+    }
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitConstructorNewInstance.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitConstructorNewInstance.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/expected.txt b/testsuite/java_test/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/test.cfg b/testsuite/java_test/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0fed7c57507044ba044125b0f252ea00cc4103aa
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0144-rt-reflection-ClinitConstructorNewInstance/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitConstructorNewInstance)
+run(ClassInitConstructorNewInstance)
diff --git a/testsuite/java_test/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java b/testsuite/java_test/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..d95136e0b6578e5e2ec6befb42bf74c88978a21b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/ClassInitFieldGetBooleanStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetBooleanStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.getBoolean(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetBooleanStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("One");
+    }
+    public static boolean hiBoolean = false;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetBooleanStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetBooleanStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/expected.txt b/testsuite/java_test/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/test.cfg b/testsuite/java_test/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c84bf6ec919619b1f76d1660cf13e0fca15613e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0145-rt-reflection-ClinitFieldGetBooleanStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetBooleanStatic)
+run(ClassInitFieldGetBooleanStatic)
diff --git a/testsuite/java_test/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java b/testsuite/java_test/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..7eec7ad2fc5e5cb944ef7998589dec515ad59420
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/ClassInitFieldGetByteStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetByteStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.getByte(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetByteStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetByteStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetByteStatic.result.append("One");
+    }
+    public static byte hiByte = (byte)0;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetByteStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetByteStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/expected.txt b/testsuite/java_test/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/test.cfg b/testsuite/java_test/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0de9ca38faba745f43622c2af342bff73a27b2f2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0146-rt-reflection-ClinitFieldGetByteStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetByteStatic)
+run(ClassInitFieldGetByteStatic)
diff --git a/testsuite/java_test/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java b/testsuite/java_test/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..0383ee40890ce950955da1562d85add2c0a02259
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/ClassInitFieldGetCharStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetCharStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.getChar(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetCharStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetCharStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetCharStatic.result.append("One");
+    }
+    public static char hiChar = (char)45;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetCharStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetCharStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/expected.txt b/testsuite/java_test/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/test.cfg b/testsuite/java_test/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16ceb031ca56b781747385b666e3985a2470dc4d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0147-rt-reflection-ClinitFieldGetCharStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetCharStatic)
+run(ClassInitFieldGetCharStatic)
diff --git a/testsuite/java_test/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java b/testsuite/java_test/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..d296eb26c1127d448fe28a1826803dd631505ec4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/ClassInitFieldGetDoubleStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetDoubleStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.getDouble(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetDoubleStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("One");
+    }
+    public static double hiDouble = 4.5;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetDoubleStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetDoubleStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/expected.txt b/testsuite/java_test/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/test.cfg b/testsuite/java_test/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e9e751d166058cc4ee776f993fff8dfa151f490c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0148-rt-reflection-ClinitFieldGetDoubleStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetDoubleStatic)
+run(ClassInitFieldGetDoubleStatic)
diff --git a/testsuite/java_test/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java b/testsuite/java_test/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..fb4590fbf7acb67dfbb3b1f6107746c68536c86c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/ClassInitFieldGetFloatStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetFloatStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.getFloat(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetFloatStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("One");
+    }
+    public static float hiFloat = 0.25f;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetFloatStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetFloatStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/expected.txt b/testsuite/java_test/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/test.cfg b/testsuite/java_test/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4620d0f6aa51e1b3e02948f99e4b0354df3aad26
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0149-rt-reflection-ClinitFieldGetFloatStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetFloatStatic)
+run(ClassInitFieldGetFloatStatic)
diff --git a/testsuite/java_test/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java b/testsuite/java_test/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..b22247fad52e409409aad47142140ab8608eeeba
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/ClassInitFieldGetIntStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetIntStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.getInt(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetIntStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetIntStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetIntStatic.result.append("One");
+    }
+    public static int hiInt = 0;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetIntStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetIntStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/expected.txt b/testsuite/java_test/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/test.cfg b/testsuite/java_test/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7cdd9f9f975c60bf56017eda537b4748b1369ad0
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0150-rt-reflection-ClinitFieldGetIntStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetIntStatic)
+run(ClassInitFieldGetIntStatic)
diff --git a/testsuite/java_test/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java b/testsuite/java_test/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..25291ef6e83345e0848c453433b69d73233bb256
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/ClassInitFieldGetLongStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetLongStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.getLong(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetLongStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetLongStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetLongStatic.result.append("One");
+    }
+    public static long hiLong = 4859l;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetLongStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetLongStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/expected.txt b/testsuite/java_test/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/test.cfg b/testsuite/java_test/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd34e1a6d5f0f26a327ef02041138fa258c05840
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0151-rt-reflection-ClinitFieldGetLongStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetLongStatic)
+run(ClassInitFieldGetLongStatic)
diff --git a/testsuite/java_test/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java b/testsuite/java_test/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..29d60063d1d32dcfebee8d560a352565267b3177
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/ClassInitFieldGetShortStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetShortStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.getShort(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetShortStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetShortStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetShortStatic.result.append("One");
+    }
+    public static short hiShort = 48;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetShortStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetShortStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/expected.txt b/testsuite/java_test/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/test.cfg b/testsuite/java_test/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..14b4d7892e3de3e0383ca6360ff3e4853c5442d5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0152-rt-reflection-ClinitFieldGetShortStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetShortStatic)
+run(ClassInitFieldGetShortStatic)
diff --git a/testsuite/java_test/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/ClassInitFieldGetStatic.java b/testsuite/java_test/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/ClassInitFieldGetStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..c1c9e77a9131e8a2134c3873f3371574cf327123
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/ClassInitFieldGetStatic.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+public class ClassInitFieldGetStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        String fValue = "";
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                fValue = (String)f.get(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0 && fValue.compareTo("hi") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldGetStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldGetStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldGetStatic.result.append("One");
+    }
+    public static String hi = "hi";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldGetStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldGetStatic.result.append("Two");
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/expected.txt b/testsuite/java_test/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/test.cfg b/testsuite/java_test/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c040570d94a741207ae4f81f7a572fcb7aec176c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0153-rt-reflection-ClinitFieldGetStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetStatic)
+run(ClassInitFieldGetStatic)
diff --git a/testsuite/java_test/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java b/testsuite/java_test/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java
new file mode 100755
index 0000000000000000000000000000000000000000..ae28dba754b7381d9f00760b13ef51c4a93a3ac4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/ClassInitFieldOtherMethod.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldOtherMethod {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            f.equals(f);
+            f.getAnnotation(B.class);
+            f.getAnnotationsByType(B.class);
+            f.getDeclaredAnnotations();
+            f.getDeclaringClass();
+            f.getGenericType();
+            f.getModifiers();
+            f.getName();
+            f.getType();
+            f.hashCode();
+            f.isEnumConstant();
+            f.isSynthetic();
+            f.toGenericString();
+            f.toString();
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if(result.toString().compareTo("") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldOtherMethod.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldOtherMethod.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldOtherMethod.result.append("One");
+    }
+    @B("hello")
+    public static String hi = "value";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldOtherMethod.result.append("|InterfaceA|").toString();
+}
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@interface B{
+    String value() default "hi";
+}
+class Two extends One {
+    static {
+        ClassInitFieldOtherMethod.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/expected.txt b/testsuite/java_test/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/test.cfg b/testsuite/java_test/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a47f119bb71d8635767ca8a9fa7b9c16779251ac
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0154-rt-reflection-ClinitFieldOtherMethod/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldOtherMethod)
+run(ClassInitFieldOtherMethod)
diff --git a/testsuite/java_test/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java b/testsuite/java_test/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..1c1038233d3493864631617e358b95424391cd13
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/ClassInitFieldSetBooleanStatic.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetBooleanStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.setBoolean(null, false);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetBooleanStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("One");
+    }
+    String what = "lala";
+    public static boolean hiBoolean = false;
+    One(){}
+    public One(String s){
+        what = s;
+        System.out.println(s);
+    }
+    public int testOne(String a){
+        System.out.println(a);
+        return 0;
+    }
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetBooleanStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetBooleanStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/expected.txt b/testsuite/java_test/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/test.cfg b/testsuite/java_test/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..af30a4c09ea374df1b5e929ff9cd52ca094ca76d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0155-rt-reflection-ClinitFieldSetBooleanStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetBooleanStatic)
+run(ClassInitFieldSetBooleanStatic)
diff --git a/testsuite/java_test/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java b/testsuite/java_test/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..2839e31e0538c56d90720d99e4e7995fbbdb8a09
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/ClassInitFieldSetByteStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetByteStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.setByte(null, (byte)1);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetByteStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetByteStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetByteStatic.result.append("One");
+    }
+    public static byte hiByte = (byte)0;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetByteStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetByteStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/expected.txt b/testsuite/java_test/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/test.cfg b/testsuite/java_test/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8caa52cbccca282d8f49bc2acc1173641e28ac56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0156-rt-reflection-ClinitFieldSetByteStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetByteStatic)
+run(ClassInitFieldSetByteStatic)
diff --git a/testsuite/java_test/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java b/testsuite/java_test/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..3ab632b803ab14468e0dceee5a0d255f3f730c7f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/ClassInitFieldSetCharStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetCharStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.setChar(null, (char)1);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetCharStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetCharStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetCharStatic.result.append("One");
+    }
+    public static char hiChar = (char)45;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetCharStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetCharStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/expected.txt b/testsuite/java_test/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/test.cfg b/testsuite/java_test/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65c9d60e7681d912286d61bc6d530f3358f061da
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0157-rt-reflection-ClinitFieldSetCharStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetCharStatic)
+run(ClassInitFieldSetCharStatic)
diff --git a/testsuite/java_test/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java b/testsuite/java_test/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..a0aaf314c0152400ec8731b4cab2df48e521d258
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/ClassInitFieldSetDoubleStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetDoubleStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.setDouble(null, 0.2589);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetDoubleStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("One");
+    }
+    public static double hiDouble = 4.5;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetDoubleStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetDoubleStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/expected.txt b/testsuite/java_test/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/test.cfg b/testsuite/java_test/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..16f3434b4ed66e617b4a8c639fe92ee0fa9cb5fc
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0158-rt-reflection-ClinitFieldSetDoubleStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetDoubleStatic)
+run(ClassInitFieldSetDoubleStatic)
diff --git a/testsuite/java_test/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java b/testsuite/java_test/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..111ccef99c64738a0ebda1b3ee0bda96601e11ed
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/ClassInitFieldSetFloatStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetFloatStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.setFloat(null, 0.2589f);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetFloatStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("One");
+    }
+    public static float hiFloat = 0.25f;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetFloatStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetFloatStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/expected.txt b/testsuite/java_test/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/test.cfg b/testsuite/java_test/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..35973a71ce353e05a42effbbbda64bbc9afb40b4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0159-rt-reflection-ClinitFieldSetFloatStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetFloatStatic)
+run(ClassInitFieldSetFloatStatic)
diff --git a/testsuite/java_test/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java b/testsuite/java_test/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..d84601811881849fbe56f1b6188b32b1e11f6ef9
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/ClassInitFieldSetIntStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetIntStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.setInt(null, 25);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetIntStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetIntStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetIntStatic.result.append("One");
+    }
+    public static int hiInt = 0;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetIntStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetIntStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/expected.txt b/testsuite/java_test/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/test.cfg b/testsuite/java_test/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e89ccd9fcedd1789e8358bca5803c89d3b026f10
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0160-rt-reflection-ClinitFieldSetIntStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetIntStatic)
+run(ClassInitFieldSetIntStatic)
diff --git a/testsuite/java_test/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java b/testsuite/java_test/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..5d465fa175ea353774b209bae16a1a33324e1bad
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/ClassInitFieldSetLongStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetLongStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.setLong(null, 25l);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetLongStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetLongStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetLongStatic.result.append("One");
+    }
+    public static long hiLong = 4859l;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetLongStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetLongStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/expected.txt b/testsuite/java_test/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/test.cfg b/testsuite/java_test/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3678b49933e6674fb6e53732aea55d6681731451
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0161-rt-reflection-ClinitFieldSetLongStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetLongStatic)
+run(ClassInitFieldSetLongStatic)
diff --git a/testsuite/java_test/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java b/testsuite/java_test/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..2a378e03ad33e2864308e4201b6e39237afd938d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/ClassInitFieldSetShortStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetShortStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.setShort(null, (short)25);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetShortStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetShortStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetShortStatic.result.append("One");
+    }
+    public static short hiShort = 48;
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetShortStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetShortStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/expected.txt b/testsuite/java_test/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/test.cfg b/testsuite/java_test/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..80d1f7ef311072296e75eb014a29089d8393521c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0162-rt-reflection-ClinitFieldSetShortStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetShortStatic)
+run(ClassInitFieldSetShortStatic)
diff --git a/testsuite/java_test/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/ClassInitFieldSetStatic.java b/testsuite/java_test/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/ClassInitFieldSetStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..1e47061c0954dfc8ef58e114cb1510a63c032bda
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/ClassInitFieldSetStatic.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+public class ClassInitFieldSetStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.set(null, "what");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitFieldSetStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitFieldSetStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitFieldSetStatic.result.append("One");
+    }
+    public static String hi = "hi";
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitFieldSetStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitFieldSetStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/expected.txt b/testsuite/java_test/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/test.cfg b/testsuite/java_test/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..820a7ecaf10a554e54d67e6c99e2112211ab76d8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0163-rt-reflection-ClinitFieldSetStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetStatic)
+run(ClassInitFieldSetStatic)
diff --git a/testsuite/java_test/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java b/testsuite/java_test/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java
new file mode 100755
index 0000000000000000000000000000000000000000..f4a975ba705c401a71d415d6aeac9085d95a510a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/ClassInitMethodInvokeStatic.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+public class ClassInitMethodInvokeStatic {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("One", false, One.class.getClassLoader());
+            Method m = clazz.getDeclaredMethod("testOne", String.class);
+            // Check point 1: calling following methods, class not initialized.
+            m.equals(m);
+            m.getAnnotation(A.class);
+            m.getDeclaredAnnotations();
+            m.getDeclaringClass();
+            m.getDefaultValue();
+            m.getExceptionTypes();
+            m.getGenericExceptionTypes();
+            m.getGenericParameterTypes();
+            m.getGenericReturnType();
+            m.getModifiers();
+            m.getName();
+            m.getParameterAnnotations();
+            m.getParameterCount();
+            m.getParameterTypes();
+            m.getReturnType();
+            m.getTypeParameters();
+            m.hashCode();
+            m.isBridge();
+            m.isDefault();
+            m.isSynthetic();
+            m.isVarArgs();
+            m.toString();
+            m.toGenericString();
+            // Check point 2: after newInstance, class initialized.
+            if (result.toString().compareTo("") == 0) {
+                m.invoke(null, "hi");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("SuperOne") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+@A
+class Super {
+    static {
+        ClassInitMethodInvokeStatic.result.append("Super");
+    }
+}
+interface InterfaceSuper {
+    String a = ClassInitMethodInvokeStatic.result.append("|InterfaceSuper|").toString();
+}
+@A(i=1)
+class One extends Super implements InterfaceSuper {
+    static {
+        ClassInitMethodInvokeStatic.result.append("One");
+    }
+    public static int testOne(String a){
+        return 0;
+    }
+}
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface A {
+    int i() default 0;
+    String a = ClassInitMethodInvokeStatic.result.append("|InterfaceA|").toString();
+}
+class Two extends One {
+    static {
+        ClassInitMethodInvokeStatic.result.append("Two");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/expected.txt b/testsuite/java_test/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/test.cfg b/testsuite/java_test/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4466c393970b01470cd5f88be576d6cbaed0d98e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0164-rt-reflection-ClinitMethodInvokeStatic/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitMethodInvokeStatic)
+run(ClassInitMethodInvokeStatic)
diff --git a/testsuite/java_test/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java b/testsuite/java_test/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..aa1163a8612f181951302dfc32213e83d9f1cb0f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/ClassInitFieldGetBooleanInterface.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetBooleanInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.getBoolean(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetBooleanInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetBooleanInterface.result.append("One").toString();
+    boolean hiBoolean = false;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetBooleanInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetBooleanInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/expected.txt b/testsuite/java_test/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/test.cfg b/testsuite/java_test/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f13798e6abfd9ee418095d894e64bf65520d7304
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0165-rt-reflection-ClinitFieldGetBooleanInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetBooleanInterface)
+run(ClassInitFieldGetBooleanInterface)
diff --git a/testsuite/java_test/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java b/testsuite/java_test/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..9f905e438277c1a473fbad27689e8a148b2a3a68
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/ClassInitFieldGetByteInterface.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetByteInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.getByte(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetByteInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetByteInterface.result.append("One").toString();
+    byte hiByte = (byte)1;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetByteInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetByteInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/expected.txt b/testsuite/java_test/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/test.cfg b/testsuite/java_test/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0d0e8742d65e4bb00ebd26557dc3ba6e26d5040f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0166-rt-reflection-ClinitFieldGetByteInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetByteInterface)
+run(ClassInitFieldGetByteInterface)
diff --git a/testsuite/java_test/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java b/testsuite/java_test/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..e94075ae335dbfd4dcbedc34c30b889b281a31b1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/ClassInitFieldGetCharInterface.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetCharInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.getChar(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetCharInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetCharInterface.result.append("One").toString();
+    char hiChar = (char)45;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetCharInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetCharInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/expected.txt b/testsuite/java_test/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/test.cfg b/testsuite/java_test/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6231c9e9b97a065ceb61fdf7fda327ff300407d1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0167-rt-reflection-ClinitFieldGetCharInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetCharInterface)
+run(ClassInitFieldGetCharInterface)
diff --git a/testsuite/java_test/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java b/testsuite/java_test/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..6fb7912fe595690b1052fd66c16c41d409166d93
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/ClassInitFieldGetDoubleInterface.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetDoubleInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.getDouble(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetDoubleInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetDoubleInterface.result.append("One").toString();
+    double hiDouble = 0.1532;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetDoubleInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetDoubleInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/expected.txt b/testsuite/java_test/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/test.cfg b/testsuite/java_test/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5365c21066c8a89e10357fd17fb719506af14d12
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0168-rt-reflection-ClinitFieldGetDoubleInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetDoubleInterface)
+run(ClassInitFieldGetDoubleInterface)
diff --git a/testsuite/java_test/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java b/testsuite/java_test/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..27650c1b1bf439864711832fff83273341c2283a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/ClassInitFieldGetFloatInterface.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetFloatInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.getFloat(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetFloatInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetFloatInterface.result.append("One").toString();
+    float hiFloat = 0.25f;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetFloatInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetFloatInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/expected.txt b/testsuite/java_test/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/test.cfg b/testsuite/java_test/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bae327b7366c60e40eb7d2c83ddfc3d8c773a75b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0169-rt-reflection-ClinitFieldGetFloatInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetFloatInterface)
+run(ClassInitFieldGetFloatInterface)
diff --git a/testsuite/java_test/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/ClassInitFieldGetInterface.java b/testsuite/java_test/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/ClassInitFieldGetInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..a3178f23eaa07c717529c5a9e5827dbfcda976a8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/ClassInitFieldGetInterface.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.get(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetInterface.result.append("One").toString();
+    String hi = "hiField";
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/expected.txt b/testsuite/java_test/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/test.cfg b/testsuite/java_test/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3b28d6ef59371fc8c267c39e4741bab96febcb81
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0170-rt-reflection-ClinitFieldGetInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetInterface)
+run(ClassInitFieldGetInterface)
diff --git a/testsuite/java_test/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java b/testsuite/java_test/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..bd516deee6af31ffb29b374641b92378fb62940b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/ClassInitFieldGetIntInterface.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetIntInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.getInt(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetIntInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetIntInterface.result.append("One").toString();
+    int hiInt = 125;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetIntInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetIntInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/expected.txt b/testsuite/java_test/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/test.cfg b/testsuite/java_test/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1575a30fdfe1ee788fa0949a9bd53e9bc51c9a7d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0171-rt-reflection-ClinitFieldGetIntInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetIntInterface)
+run(ClassInitFieldGetIntInterface)
diff --git a/testsuite/java_test/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java b/testsuite/java_test/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..612555688c0d3b0dca97b5dd915aac7763ac2058
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/ClassInitFieldGetLongInterface.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetLongInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.getLong(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetLongInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetLongInterface.result.append("One").toString();
+    long hiLong = 4859l;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetLongInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetLongInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/expected.txt b/testsuite/java_test/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/test.cfg b/testsuite/java_test/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d9724c00a8da921fa881bfac7a15407686cf0ea2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0172-rt-reflection-ClinitFieldGetLongInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetLongInterface)
+run(ClassInitFieldGetLongInterface)
diff --git a/testsuite/java_test/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java b/testsuite/java_test/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..047dfa6e64c21de85ca87a178e837ba45b533ba4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/ClassInitFieldGetShortInterface.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldGetShortInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.getShort(null);
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("One") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldGetShortInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldGetShortInterface.result.append("One").toString();
+    short hiShort = 14;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldGetShortInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldGetShortInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/expected.txt b/testsuite/java_test/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/test.cfg b/testsuite/java_test/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e571f4ebcf7a1422cf7cc375dce793eb31481945
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0173-rt-reflection-ClinitFieldGetShortInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldGetShortInterface)
+run(ClassInitFieldGetShortInterface)
diff --git a/testsuite/java_test/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java b/testsuite/java_test/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..8652a0e141ce2a51541b8b44251087d978b2f40f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/ClassInitFieldOtherMethodInterface.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldOtherMethodInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            f.equals(f);
+            f.getAnnotation(A.class);
+            f.getAnnotationsByType(A.class);
+            f.getDeclaredAnnotations();
+            f.getDeclaringClass();
+            f.getGenericType();
+            f.getModifiers();
+            f.getName();
+            f.getType();
+            f.hashCode();
+            f.isEnumConstant();
+            f.isSynthetic();
+            f.toGenericString();
+            f.toString();
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if(result.toString().compareTo("") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldOtherMethodInterface.result.append("Super").toString();
+}
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldOtherMethodInterface.result.append("One").toString();
+    @A
+    short hi = 14;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldOtherMethodInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldOtherMethodInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/expected.txt b/testsuite/java_test/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/test.cfg b/testsuite/java_test/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ae6f283fe1ea44a4742fdf87081fba0928275d90
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0174-rt-reflection-ClinitFieldOtherMethodInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldOtherMethodInterface)
+run(ClassInitFieldOtherMethodInterface)
diff --git a/testsuite/java_test/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java b/testsuite/java_test/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..d6a5003ecc548c56c75a535ceaf519c62d8e5fa1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/ClassInitFieldSetBooleanInterface.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetBooleanInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiBoolean");
+            if (result.toString().compareTo("") == 0) {
+                f.setBoolean(null, true);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetBooleanInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetBooleanInterface.result.append("One").toString();
+    boolean hiBoolean = false;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetBooleanInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetBooleanInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/expected.txt b/testsuite/java_test/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/test.cfg b/testsuite/java_test/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a26eb0d13e6aa5db5d8f3c72ef237e3eb7284f69
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0175-rt-reflection-ClinitFieldSetBooleanInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetBooleanInterface)
+run(ClassInitFieldSetBooleanInterface)
diff --git a/testsuite/java_test/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java b/testsuite/java_test/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..0d5899e83b3aa2e6e1f4f99b709e3580708094c4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/ClassInitFieldSetByteInterface.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetByteInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiByte");
+            if (result.toString().compareTo("") == 0) {
+                f.setByte(null, (byte)0);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetByteInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetByteInterface.result.append("One").toString();
+    byte hiByte = (byte)1;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetByteInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetByteInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/expected.txt b/testsuite/java_test/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/test.cfg b/testsuite/java_test/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..68d2181359ae204544f244ce5c226b2aa8e5bafe
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0176-rt-reflection-ClinitFieldSetByteInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetByteInterface)
+run(ClassInitFieldSetByteInterface)
diff --git a/testsuite/java_test/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java b/testsuite/java_test/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..8589838d6f8ed8d7175e8a2b394d55a0c677c808
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/ClassInitFieldSetFloatInterface.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetFloatInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiFloat");
+            if (result.toString().compareTo("") == 0) {
+                f.setFloat(null, 0.654f);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetFloatInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetFloatInterface.result.append("One").toString();
+    float hiFloat = 0.25f;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetFloatInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetFloatInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/expected.txt b/testsuite/java_test/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/test.cfg b/testsuite/java_test/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..39f4ed2d2fdbdeb1c1e210c1f9e076842180521d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0177-rt-reflection-ClinitFieldSetFloatInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetFloatInterface)
+run(ClassInitFieldSetFloatInterface)
diff --git a/testsuite/java_test/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/ClassInitFieldSetInterface.java b/testsuite/java_test/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/ClassInitFieldSetInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..f5e700120d45cfff39d9c477a1a987c0d8a13acb
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/ClassInitFieldSetInterface.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hi");
+            if (result.toString().compareTo("") == 0) {
+                f.set(null, "newString");
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetInterface.result.append("One").toString();
+    String hi = "hiField";
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/expected.txt b/testsuite/java_test/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/test.cfg b/testsuite/java_test/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0009d5a0b7daafd84f536ca7fae33071a716e061
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0178-rt-reflection-ClinitFieldSetInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetInterface)
+run(ClassInitFieldSetInterface)
diff --git a/testsuite/java_test/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java b/testsuite/java_test/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..fa2cdf308d24a76d5449eafac92d3b38b6fa319c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/ClassInitFieldSetIntInterface.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetIntInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiInt");
+            if (result.toString().compareTo("") == 0) {
+                f.setInt(null, 98);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetIntInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetIntInterface.result.append("One").toString();
+    int hiInt = 125;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetIntInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetIntInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/expected.txt b/testsuite/java_test/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/test.cfg b/testsuite/java_test/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6ff549308b6fa94bda271d2d8a335f7e6bcb6e36
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0179-rt-reflection-ClinitFieldSetIntInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetIntInterface)
+run(ClassInitFieldSetIntInterface)
diff --git a/testsuite/java_test/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java b/testsuite/java_test/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..c2f2236d93839869bcb7aa9020bccf9e07a4f2fb
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/ClassInitFieldSetLongInterface.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetLongInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiLong");
+            if (result.toString().compareTo("") == 0) {
+                f.setLong(null, 7456l);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetLongInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetLongInterface.result.append("One").toString();
+    long hiLong = 4859l;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetLongInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetLongInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/expected.txt b/testsuite/java_test/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/test.cfg b/testsuite/java_test/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e1b4cf8ab67072f3044abc9370fd1b3e55617d9
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0180-rt-reflection-ClinitFieldSetLongInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetLongInterface)
+run(ClassInitFieldSetLongInterface)
diff --git a/testsuite/java_test/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java b/testsuite/java_test/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..ce462bf3d5da3cd8171de784fe776cbd38356f50
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/ClassInitFieldSetShortInterface.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetShortInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiShort");
+            if (result.toString().compareTo("") == 0) {
+                f.setShort(null, (short)124);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetShortInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetShortInterface.result.append("One").toString();
+    short hiShort = 14;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetShortInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetShortInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/expected.txt b/testsuite/java_test/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/test.cfg b/testsuite/java_test/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2bb37a45a1ce8e0c32116cb0b3faec0560003a11
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0181-rt-reflection-ClinitFieldSetShortInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetShortInterface)
+run(ClassInitFieldSetShortInterface)
diff --git a/testsuite/java_test/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java b/testsuite/java_test/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..524503bddb4fcfad7068633cb2f46f5c088e7105
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/ClassInitMethodInvokeInterface.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class ClassInitMethodInvokeInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Method m = clazz.getDeclaredMethod("runInterface", String.class);
+            //check point 1: calling following methods, class not initialized
+            m.equals(m);
+            m.getAnnotation(A.class);
+            m.getDeclaredAnnotations();
+            m.getDeclaringClass();
+            m.getDefaultValue();
+            m.getExceptionTypes();
+            m.getGenericExceptionTypes();
+            m.getGenericParameterTypes();
+            m.getGenericReturnType();
+            m.getModifiers();
+            m.getName();
+            m.getParameterAnnotations();
+            m.getParameterCount();
+            m.getParameterTypes();
+            m.getReturnType();
+            m.getTypeParameters();
+            m.hashCode();
+            m.isBridge();
+            m.isDefault();
+            m.isSynthetic();
+            m.isVarArgs();
+            m.toString();
+            m.toGenericString();
+            //check point 2: after newInstance, class initialized
+            if (result.toString().compareTo("") == 0) {
+                m.invoke(null, "hi");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneRunInterface") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitMethodInvokeInterface.result.append("Super").toString();
+}
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitMethodInvokeInterface.result.append("One").toString();
+    @A
+    static void runInterface(String a){
+        ClassInitMethodInvokeInterface.result.append("RunInterface");
+    }
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitMethodInvokeInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitMethodInvokeInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/expected.txt b/testsuite/java_test/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/test.cfg b/testsuite/java_test/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a9af44cc4bf47ec4d25885ddfb4d58e78956a8b2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0182-rt-reflection-ClinitMethodInvokeInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitMethodInvokeInterface)
+run(ClassInitMethodInvokeInterface)
diff --git a/testsuite/java_test/reflection_test/RT0183-rt-reflection-FieldMultiThreadTest/FieldMultiThreadTest.java b/testsuite/java_test/reflection_test/RT0183-rt-reflection-FieldMultiThreadTest/FieldMultiThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..460a13b337891ba6007354da0795ff5d02afc758
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0183-rt-reflection-FieldMultiThreadTest/FieldMultiThreadTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldMultiThreadTest {
+    volatile static boolean keepRunning = true;
+    static int passCnt = 0;
+    static int executeCnt = 0;
+    public static void main(String[] args) {
+        try {
+            fieldMultithread();
+            System.out.println(passCnt/executeCnt - 10);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+    private static int fieldMultithread() throws Exception {
+        Class clazz = Class.forName("TestMultiThread");
+        String[] allFields = new String[] {"charPub", "fieldIntPri", "fieldIntPro", "fieldString"};
+        Thread writer = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (String s : allFields) {
+                        Field field = clazz.getDeclaredField(s);
+                        field.setAccessible(true);
+                    }
+                    for (Field f: clazz.getDeclaredFields()) {
+                        f.setAccessible(true);
+                    }
+                    Field field = clazz.getField("charPub");
+                    field.setAccessible(true);
+                    for (Field f: clazz.getFields()) {
+                        f.setAccessible(true);
+                    }
+                }
+            } catch (Exception e) {
+                System.out.println(e);
+            }
+        });
+        Thread reader = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (String s : allFields) {
+                        Field field = clazz.getDeclaredField(s);
+                        passCnt += field.isAccessible()== false ? 1 : 0;
+                    }
+                    for (Field f: clazz.getDeclaredFields()) {
+                        passCnt += f.isAccessible()== false ? 1 : 0;
+                    }
+                    Field field = clazz.getField("charPub");
+                    passCnt += field.isAccessible()== false ? 1 : 0;
+                    for (Field f: clazz.getFields()) {
+                        passCnt += f.isAccessible()== false ? 1 : 0;
+                    }
+                    executeCnt++;
+                }
+            } catch (Exception e) {
+                System.out.println(e);
+            }
+        });
+        writer.start();
+        reader.start();
+        Thread.sleep(100);
+        keepRunning = false;
+        Thread.sleep(100);
+        writer.join();
+        reader.join();
+        return passCnt;
+    }
+}
+class TestMultiThread {
+    public char charPub = 'a';
+    private int fieldIntPri = 416;
+    protected int[] fieldIntPro = {123};
+    String fieldString = "hey, hello";
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0183-rt-reflection-FieldMultiThreadTest/expected.txt b/testsuite/java_test/reflection_test/RT0183-rt-reflection-FieldMultiThreadTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0183-rt-reflection-FieldMultiThreadTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0183-rt-reflection-FieldMultiThreadTest/test.cfg b/testsuite/java_test/reflection_test/RT0183-rt-reflection-FieldMultiThreadTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..58d2a6fd3e56d8d428a1d702f266d8bc8ab6ea55
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0183-rt-reflection-FieldMultiThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldMultiThreadTest)
+run(FieldMultiThreadTest)
diff --git a/testsuite/java_test/reflection_test/RT0184-rt-reflection-MethodTest/MethodTest.java b/testsuite/java_test/reflection_test/RT0184-rt-reflection-MethodTest/MethodTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..bfa6b8632935316e2a6e2f1bc3afab52a257127e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0184-rt-reflection-MethodTest/MethodTest.java
@@ -0,0 +1,343 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+public class MethodTest {
+    /**
+     * Verify that for the same method, different Method object is return when call following API twice:
+     * - Class.getMethods(),
+     * - Class.getEnclosingMethod(),
+     * - Class.getDeclaredMethods(),
+     * - Class.getMethod(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredMethod(String name, Class<?>... parameterTypes),
+     * if any Method failed the check, will print error message including testcase and method name;
+     * after all check is pass, casePassed will be increased;
+    */
+
+    private static void classAllMethodTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getMethods()
+        Method[] methods1 = clazz.getMethods();
+        Method[] methods2 = clazz.getMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 2. Class.getMethod(String name)
+            Method m1 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed");
+            }
+        }
+        // checkpoint 3. Class.getDeclaredMethods()
+        methods1 = clazz.getDeclaredMethods();
+        methods2 = clazz.getDeclaredMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 4. Class.getDeclaredMethod(String name)
+            Method m1 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for declared method");
+            }
+        }
+        // checkpoint 5. Class.getEnclosingMethod()
+        if (clazz.getEnclosingMethod() != null) {
+            Method m1 = clazz.getEnclosingMethod();
+            Method m2 = clazz.getEnclosingMethod();
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for Enclosing method");
+            }
+        }
+        casesPassed++;
+    }
+    private static void checkMethods(Method[] methods1, Method[] methods2) {
+        for (Method m1: methods1) {
+            for (Method m2: methods2) {
+                // only when modifers and class and name is same, two Method object is for same method
+                if(m1.toString().equals(m2.toString())) {
+                    if (singleMethodCheck(m1, m2) != 3) {
+                        System.out.println(m1.getName()+" failed in checkMethods");
+                    }
+                }
+            }
+        }
+    }
+    private static int singleMethodCheck(Method m1, Method m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    static int casesPassed = 0;
+    public static void main(String [] args) {
+        method01();
+        method02();
+        method03();
+        method04();
+        method05();
+        method06();
+        method07();
+        method08();
+        method09();
+        method10();
+        method11();
+        System.out.println(casesPassed - 11);
+    }
+
+    private static void method01() {
+        try {
+            classAllMethodTest(Class.forName("java.lang.Thread"), "method01");
+        } catch (Exception e) {
+            System.out.println("Case method01 failed with exception" + e);
+        }
+    }
+
+    private static void method02() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod02"), "method02");
+        } catch (Exception e) {
+            System.out.println("Case method02 failed with exception" + e);
+        }
+    }
+
+    private static void method03() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod03"), "method03");
+        } catch (Exception e) {
+            System.out.println("Case method03 failed with exception" + e);
+        }
+    }
+
+    private static void method04() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod04"), "method04");
+        } catch (Exception e) {
+            System.out.println("Case method04 failed with exception" + e);
+        }
+    }
+
+    private static void method05() {
+        try {
+            // step 1
+            Class clazz = Class.forName("MethodTest");
+            MethodTest mainClass = new MethodTest();
+            Field method = clazz.getDeclaredField("testMethod05");
+            classAllMethodTest(method.get(mainClass).getClass(), "method05");
+        } catch (Exception e) {
+            System.out.println("Case method05 failed with exception" + e);
+        }
+    }
+    private Runnable testMethod05 = new Runnable() {
+        private final synchronized int intRunnable() {
+            return 1;
+        }
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    private static void method06() {
+        class TestMethod06 {
+            private final int intLocalMethod() {
+                return 9;
+            }
+            public synchronized String stringLocal() {
+                return "a fake behind the fear";
+            }
+        }
+        try {
+            classAllMethodTest(Class.forName("MethodTest$1TestMethod06"), "method06");
+        } catch (Exception e) {
+            System.out.println("Case method06 failed with exception" + e);
+        }
+    }
+
+    private static void method07() {
+        try {
+            classAllMethodTest(Class.forName("MethodTest$TestMethod07"), "method07");
+        } catch (Exception e) {
+            System.out.println("Case method07 failed with exception" + e);
+        }
+    }
+    class TestMethod07 {
+        private char charInnerMethod(int a, double... b) {
+            return 'l';
+        }
+        final public double doubleInnerMethod() {
+            return 1988.0416;
+        }
+    }
+
+    private static void method08() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod08"), "method08");
+        } catch (Exception e) {
+            System.out.println("Case method08 failed with exception" + e);
+        }
+    }
+    
+    private static void method09() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod09"), "method09");
+        } catch (Exception e) {
+            System.out.println("Case method09 failed with exception" + e);
+        }
+    }
+
+    private static void method10() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod10"), "method10");
+        } catch (Exception e) {
+            System.out.println("Case method10 failed with exception" + e);
+        }
+    }
+
+    private static void method11() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod11"), "method11");
+        } catch (Exception e) {
+            System.out.println("Case method11 failed with exception" + e);
+        }
+    }
+}
+class TestMethod02 {
+    // step1
+    void voidMethod() {}
+    boolean booleanMethod() {
+        return true;
+    }
+    byte byteMethod() {
+        return (byte)1;
+    }
+    short shortMethod() {
+        return (short)2;
+    }
+    int intMethod() {
+        return 3;
+    }
+    long longMethod() {
+        return 4l;
+    }
+    char charMethod() {
+        return 'a';
+    }
+    float floatMethod() {
+        return 0.9f;
+    }
+    double doubleMethod() {
+        return 0.416;
+    }
+    String stringMethod() {
+        return "The queerest of the queer";
+    }
+    Runnable[] rArrayMethod() {
+        return null;
+    }
+    boolean[][][][][][][] booleanArray7Method() {
+        return new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    }
+    String[][][] stringArray3Method() {
+        return new String[][][] {{{"the strangest of the strange"}}};
+    }
+    int parameterMethod(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                        boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                        String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+        return 1;
+    }
+    // step2
+    public int publicIntMethod(boolean a) {
+        return 88;
+    }
+    protected double protectedDoubleMethod(byte a) {
+        return 99;
+    }
+    private String privateStringMethod(String a) {
+        return "the coldest of the cool";
+    }
+    // step3
+    strictfp double[][] transientDoubleArrayMethod(float[][] a) {
+        return new double[][] {{1988, 4.16}};
+    }
+    final int finalIntMethod() {
+        return 9876;
+    }
+    synchronized String volatileStringMethod() {
+        return "the lamest of the lame";
+    }
+    static Character staticCharacterMethod(Thread.State a) {
+        return 'd';
+    }
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotationMethod() {
+        return new String[][] {{"the numbest of the dumb"}};
+    }
+}
+interface TestMethod03 {
+    String stringInterfaceMethod(int[] a);
+    char[][][] charArrayInterfaceMethod(double... a);
+}
+abstract class TestMethod04 {
+    public static final synchronized String[] stringsAbstractArrayMethod() {
+        return new String[] {"i hate to see you here", "you choke behind a smile"};
+    }
+    abstract Runnable runnableAbstractMethod();
+}
+enum TestMethod08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnumMethod() {
+        return (short)6;
+    }
+    public final String stringEnumMethod(int... a) {
+        return "Dry Martini";
+    }
+}
+class TestMethod09 {
+    public int int09Method() {
+        return 1;
+    }
+    protected boolean boolean09Method() {
+        return false;
+    }
+    char[] chars09Method() {
+        return new char[] {'a', 'b', 'c'};
+    }
+    private String string09Method() {
+        return "I'm only happy when it rains";
+    }
+}
+class TestMethod10 extends TestMethod09 implements TestMethod11 {
+    public boolean boolean09Method() {
+        return true;
+    }
+    public double double10Method() {
+        return 0.416;
+    }
+    public char[] chars09Method() {
+        return new char[] {'a'};
+    }
+    public String string09Method() {
+        return "SHALALALA";
+    }
+}
+interface TestMethod11 {
+    int int09Method();
+    boolean boolean09Method();
+    char[] chars09Method();
+    String string09Method();
+}
diff --git a/testsuite/java_test/reflection_test/RT0184-rt-reflection-MethodTest/expected.txt b/testsuite/java_test/reflection_test/RT0184-rt-reflection-MethodTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0184-rt-reflection-MethodTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0184-rt-reflection-MethodTest/test.cfg b/testsuite/java_test/reflection_test/RT0184-rt-reflection-MethodTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..aa8bf99c4867fb93b0d709a4546853c164b163ae
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0184-rt-reflection-MethodTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodTest)
+run(MethodTest)
diff --git a/testsuite/java_test/reflection_test/RT0185-rt-reflection-MethodMultiThreadTest/MethodMultiThreadTest.java b/testsuite/java_test/reflection_test/RT0185-rt-reflection-MethodMultiThreadTest/MethodMultiThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..0825a5f5a8b5cb395becf7ea4807fed194f037bd
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0185-rt-reflection-MethodMultiThreadTest/MethodMultiThreadTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Method;
+public class MethodMultiThreadTest {
+    volatile static boolean keepRunning = true;
+    static int passCnt = 0;
+    static int executeCnt = 0;
+    public static void main(String[] args) {
+        try {
+            methodMultithread();
+            System.out.println(passCnt/executeCnt - 28);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+    private static int methodMultithread() throws Exception {
+        Class clazz = Class.forName("TestMultiThreadM");
+        Thread writer = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Method m: clazz.getDeclaredMethods()) {
+                        m.setAccessible(true);
+                        Method method = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+                        method.setAccessible(true);
+                    }
+                    for (Method m: clazz.getMethods()) {
+                        m.setAccessible(true);
+                        Method method = clazz.getMethod(m.getName(), m.getParameterTypes());
+                        method.setAccessible(true);
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+        Thread reader = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Method m: clazz.getDeclaredMethods()) {
+                        passCnt += m.isAccessible()== false ? 1 : 0;
+                        Method method = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+                        passCnt += method.isAccessible()== false ? 1 : 0;
+                    }
+                    for (Method m: clazz.getMethods()) {
+                        passCnt += m.isAccessible()== false ? 1 : 0;
+                        Method method = clazz.getMethod(m.getName(), m.getParameterTypes());
+                        passCnt += method.isAccessible()== false ? 1 : 0;
+                    }
+                    executeCnt++;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+        writer.start();
+        reader.start();
+        Thread.sleep(100);
+        keepRunning = false;
+        Thread.sleep(100);
+        writer.join();
+        reader.join();
+        return passCnt;
+    }
+}
+class TestMultiThreadM {
+    public char charPubMethod(int... a) {
+        return 'a';
+    }
+    private int intPriMethod() {
+        return 416;
+    }
+    protected int[] intProMethod(Double... b) {
+        return new int[] {123};
+    }
+    String stringMethod() {
+        return "hey, hello";
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0185-rt-reflection-MethodMultiThreadTest/expected.txt b/testsuite/java_test/reflection_test/RT0185-rt-reflection-MethodMultiThreadTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0185-rt-reflection-MethodMultiThreadTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0185-rt-reflection-MethodMultiThreadTest/test.cfg b/testsuite/java_test/reflection_test/RT0185-rt-reflection-MethodMultiThreadTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6c8c5ec8970d136358e86a25df6ff0bec2635c67
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0185-rt-reflection-MethodMultiThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodMultiThreadTest)
+run(MethodMultiThreadTest)
diff --git a/testsuite/java_test/reflection_test/RT0186-rt-reflection-ConstructorTest/ConstructorTest.java b/testsuite/java_test/reflection_test/RT0186-rt-reflection-ConstructorTest/ConstructorTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..124b19c2d3b546828fea9a1fb5e322da985be724
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0186-rt-reflection-ConstructorTest/ConstructorTest.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Constructor;
+public class ConstructorTest {
+    /**
+     * Verify that for the same constructor, different Constructor object is return when call following API twice:
+     * - Class.getConstructors(),
+     * - Class.getEnclosingConstructor(),
+     * - Class.getDeclaredConstructors(),
+     * - Class.getConstructor(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredConstructor(String name, Class<?>... parameterTypes),
+     * if any Constructor failed the check, will print error message including testcase and constructor name;
+     * after all check is pass, casePassed will be increased;
+    */
+
+    private static void classAllConstructorTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getConstructors()
+        Constructor[] constructors1 = clazz.getConstructors();
+        Constructor[] constructors2 = clazz.getConstructors();
+        checkConstructors(constructors1, constructors2);
+        for (Constructor c : constructors1) {
+            // checkpoint 2. Class.getConstructor(String name)
+            Constructor c1 = clazz.getConstructor(c.getParameterTypes());
+            Constructor c2 = clazz.getConstructor(c.getParameterTypes());
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed");
+            }
+        }
+        // checkpoint 3. Class.getDeclaredConstructors()
+        constructors1 = clazz.getDeclaredConstructors();
+        constructors2 = clazz.getDeclaredConstructors();
+        checkConstructors(constructors1, constructors2);
+        for (Constructor c : constructors1) {
+            // checkpoint 4. Class.getDeclaredConstructor(String name)
+            Constructor c1 = clazz.getDeclaredConstructor(c.getParameterTypes());
+            Constructor c2 = clazz.getDeclaredConstructor(c.getParameterTypes());
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed for declared constructor");
+            }
+        }
+        // checkpoint 5. Class.getEnclosingConstructor()
+        if (clazz.getEnclosingConstructor() != null) {
+            Constructor c1 = clazz.getEnclosingConstructor();
+            Constructor c2 = clazz.getEnclosingConstructor();
+            if (singleConstructorCheck(c1, c2) != 3) {
+                System.out.println(caseName + ": " + c1.toGenericString() + " failed for Enclosing constructor");
+            }
+        }
+        casesPassed++;
+    }
+    private static void checkConstructors(Constructor[] constructors1, Constructor[] constructors2) {
+        for (Constructor c1: constructors1) {
+            for (Constructor c2: constructors2) {
+                // only when modifers and class and name is same, two Constructor object is for same constructor
+                if(c1.toString().equals(c2.toString())) {
+                    if (singleConstructorCheck(c1, c2) != 3) {
+                        System.out.println(c1.getName()+" failed in checkConstructors");
+                    }
+                }
+            }
+        }
+    }
+    private static int singleConstructorCheck(Constructor c1, Constructor c2) {
+        int passCnt = 0;
+        passCnt += c1 == c2 ? 0 : 1;
+        passCnt += c1.equals(c2) ? 1 : 0;
+        passCnt += c1.hashCode() == c2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    static int casesPassed = 0;
+    public static void main(String [] args) {
+        constructor01();
+        constructor02();
+        constructor03();
+        constructor04();
+        constructor05();
+        constructor06();
+        constructor07();
+        constructor08();
+        constructor09();
+        constructor10();
+        constructor11();
+        System.out.println(casesPassed - 11);
+    }
+
+    private static void constructor01() {
+        try {
+            classAllConstructorTest(Class.forName("java.lang.Thread"), "constructor01");
+        } catch (Exception e) {
+            System.out.println("Case constructor01 failed with exception" + e);
+        }
+    }
+
+    private static void constructor02() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor02"), "constructor02");
+        } catch (Exception e) {
+            System.out.println("Case constructor02 failed with exception" + e);
+        }
+    }
+
+    private static void constructor03() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor03"), "constructor03");
+        } catch (Exception e) {
+            System.out.println("Case constructor03 failed with exception" + e);
+        }
+    }
+    
+    private static void constructor04() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor04"), "constructor04");
+        } catch (Exception e) {
+            System.out.println("Case constructor04 failed with exception" + e);
+        }
+    }
+
+    private static void constructor05() {
+        try {
+            Class clazz = Class.forName("ConstructorTest");
+            ConstructorTest mainClass = new ConstructorTest();
+            Field constructor = clazz.getDeclaredField("testConstructor05");
+            classAllConstructorTest(constructor.get(mainClass).getClass(), "constructor05");
+        } catch (Exception e) {
+            System.out.println("Case constructor05 failed with exception" + e);
+        }
+    }
+    private Runnable testConstructor05 = new Runnable() {
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    private static void constructor06() {
+        class TestConstructor06 {
+            private TestConstructor06(int a) {
+            }
+            public TestConstructor06(String[][][] a) {
+            }
+        }
+        try {
+            classAllConstructorTest(Class.forName("ConstructorTest$1TestConstructor06"), "constructor06");
+        } catch (Exception e) {
+            System.out.println("Case constructor06 failed with exception" + e);
+        }
+    }
+
+    private static void constructor07() {
+        try {
+            classAllConstructorTest(Class.forName("ConstructorTest$TestConstructor07"), "constructor07");
+        } catch (Exception e) {
+            System.out.println("Case constructor07 failed with exception" + e);
+        }
+    }
+    class TestConstructor07 {
+        private TestConstructor07(int a, double... b) {
+        }
+        public TestConstructor07() {
+        }
+    }
+
+    private static void constructor08() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor08"), "constructor08");
+        } catch (Exception e) {
+            System.out.println("Case constructor08 failed with exception" + e);
+        }
+    }
+
+    private static void constructor09() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor09"), "constructor09");
+        } catch (Exception e) {
+            System.out.println("Case constructor09 failed with exception" + e);
+        }
+    }
+
+    private static void constructor10() {
+        try {
+            classAllConstructorTest(Class.forName("TestConstructor10"), "constructor10");
+        } catch (Exception e) {
+            System.out.println("Case constructor10 failed with exception" + e);
+        }
+    }
+
+    private static void constructor11() {
+        try {
+            Class clazz = (new TestConstructor11()).c.getClass();
+            classAllConstructorTest(clazz, "constructor11");
+        } catch (Exception e) {
+            System.out.println("Case constructor11 failed with exception" + e);
+        }
+    }
+}
+class TestConstructor02 {
+    // step1
+    TestConstructor02() {
+    }
+    TestConstructor02(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                      boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                      String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+    }
+    // step2
+    public TestConstructor02(int a) {}
+    TestConstructor02(byte a) {}
+    protected TestConstructor02(String a) {}
+    private TestConstructor02(Runnable[] a) {}
+    // step3
+    @Deprecated
+    TestConstructor02(int... a) {}
+}
+strictfp class TestConstructor03 {
+    public TestConstructor03(float... a) {
+    }
+    TestConstructor03(float a, double b) {
+    }
+}
+abstract class TestConstructor04 {
+    public TestConstructor04() {
+    }
+    TestConstructor04(int a) {
+    }
+}
+enum TestConstructor08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    TestConstructor08() {
+    }
+    TestConstructor08(String a) {
+    }
+}
+class TestConstructor09 {
+    public TestConstructor09() {
+    }
+    TestConstructor09(int... a) {
+    }
+    protected TestConstructor09(double[] a) {
+    }
+    private TestConstructor09(int a) {
+    }
+}
+class TestConstructor10 extends TestConstructor09 {
+    public TestConstructor10() {
+    }
+    TestConstructor10(int... a) {
+    }
+    protected TestConstructor10(double[] a) {
+    }
+    private TestConstructor10(int a) {
+    }
+}
+class TestConstructor11 {
+    public Object c;
+    public TestConstructor11( ) {
+        class ClassA { }
+        c = new ClassA( );
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0186-rt-reflection-ConstructorTest/expected.txt b/testsuite/java_test/reflection_test/RT0186-rt-reflection-ConstructorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0186-rt-reflection-ConstructorTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0186-rt-reflection-ConstructorTest/test.cfg b/testsuite/java_test/reflection_test/RT0186-rt-reflection-ConstructorTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b219b5e0811527d5de8a06099a013320d37c9836
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0186-rt-reflection-ConstructorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorTest)
+run(ConstructorTest)
diff --git a/testsuite/java_test/reflection_test/RT0187-rt-reflection-ConstructorMultiThreadTest/ConstructorMultiThreadTest.java b/testsuite/java_test/reflection_test/RT0187-rt-reflection-ConstructorMultiThreadTest/ConstructorMultiThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6abe58a3be4f5e464c7e3de4e5ee39b51cd5f0c7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0187-rt-reflection-ConstructorMultiThreadTest/ConstructorMultiThreadTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Constructor;
+public class ConstructorMultiThreadTest {
+    volatile static boolean keepRunning = true;
+    static int passCnt = 0;
+    static int executeCnt = 0;
+    public static void main(String[] args) {
+        try {
+            constructorMultithread();
+            System.out.println(passCnt/executeCnt - 10);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+    private static int constructorMultithread() throws Exception {
+        Class clazz = Class.forName("TestMultiThreadC");
+        Thread writer = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Constructor c: clazz.getDeclaredConstructors()) {
+                        c.setAccessible(true);
+                        Constructor constructor = clazz.getDeclaredConstructor(c.getParameterTypes());
+                        constructor.setAccessible(true);
+                    }
+                    for (Constructor c: clazz.getConstructors()) {
+                        c.setAccessible(true);
+                        Constructor constructor = clazz.getConstructor(c.getParameterTypes());
+                        constructor.setAccessible(true);
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+        Thread reader = new Thread(() -> {
+            try {
+                while (keepRunning) {
+                    for (Constructor c: clazz.getDeclaredConstructors()) {
+                        passCnt += c.isAccessible()== false ? 1 : 0;
+                        Constructor constructor = clazz.getDeclaredConstructor(c.getParameterTypes());
+                        passCnt += constructor.isAccessible()== false ? 1 : 0;
+                    }
+                    for (Constructor c: clazz.getConstructors()) {
+                        passCnt += c.isAccessible()== false ? 1 : 0;
+                        Constructor constructor = clazz.getConstructor(c.getParameterTypes());
+                        passCnt += constructor.isAccessible()== false ? 1 : 0;
+                    }
+                    executeCnt++;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println(e);
+            }
+        });
+        writer.start();
+        reader.start();
+        Thread.sleep(100);
+        keepRunning = false;
+        Thread.sleep(100);
+        writer.join();
+        reader.join();
+        return passCnt;
+    }
+}
+class TestMultiThreadC {
+    public TestMultiThreadC(int... a) {
+    }
+    private TestMultiThreadC(String a) {
+    }
+    protected TestMultiThreadC(Double... a) {
+    }
+    TestMultiThreadC() {
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0187-rt-reflection-ConstructorMultiThreadTest/expected.txt b/testsuite/java_test/reflection_test/RT0187-rt-reflection-ConstructorMultiThreadTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0187-rt-reflection-ConstructorMultiThreadTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0187-rt-reflection-ConstructorMultiThreadTest/test.cfg b/testsuite/java_test/reflection_test/RT0187-rt-reflection-ConstructorMultiThreadTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a4130034c429f0fdb598ad72e7009135a644a4f4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0187-rt-reflection-ConstructorMultiThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ConstructorMultiThreadTest)
+run(ConstructorMultiThreadTest)
diff --git a/testsuite/java_test/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java b/testsuite/java_test/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f84e22154d378e764287628120ea746747ef266
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/MethodHandleReflectCombineTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import static java.lang.invoke.MethodHandles.lookup;
+import static java.lang.invoke.MethodHandles.reflectAs;
+import static java.lang.invoke.MethodType.methodType;
+public class MethodHandleReflectCombineTest {
+    static int passCnt = 0;
+    private static <T extends Member> int singleMethodCheck(T m1, T m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    public static void main(String[] args) {
+        try {
+            System.out.println(run());
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+    private static int run() throws Throwable {
+        Object[][] testData = new Object[][] {
+            {Member.class, lookup().findVirtual(String.class, "concat", methodType(String.class, String.class))},
+            {Member.class, lookup().findStatic(String.class, "copyValueOf", methodType(String.class, char[].class))},
+            {Member.class, RATest.LOOKUP().findSpecial(RATest.class, "mhVar", methodType(int.class, Object[].class), RATest.class)},
+            {Constructor.class, lookup().findConstructor(RATest.class, methodType(void.class, int.class))},
+            {Constructor.class, lookup().findConstructor(RATest.class, methodType(void.class, double[].class))},
+            {Field.class, lookup().findStaticGetter(RATest.class, "svi", int.class)},
+            {Field.class, lookup().findStaticSetter(RATest.class, "svi", int.class)},
+            {Field.class, RATest.LOOKUP().findGetter(RATest.class, "vd", double.class)},
+            {Field.class, lookup().findGetter(RATest.class, "vs", String[].class)},
+            {Field.class, lookup().findSetter(RATest.class, "vs", String[].class)}
+        };
+        for (int i = 0; i<testData.length; i++) {
+            passCnt += singleMethodCheck(reflectAs((Class)testData[i][0], (MethodHandle) testData[i][1]), reflectAs((Class)testData[i][0], (MethodHandle) testData[i][1])) == 3 ? 1 : 0;
+        }
+        Constructor privC = Class.forName("RATest").getDeclaredConstructor();
+        privC.setAccessible(true);
+        MethodHandle raCon = lookup().unreflectConstructor(privC);
+        passCnt += singleMethodCheck(privC, reflectAs( Constructor.class, raCon))==3 ? 1 : 0;
+        return passCnt - 11;
+    }
+}
+class RATest {
+    public static MethodHandles.Lookup LOOKUP() {
+        return lookup();
+    }
+    static public double count = 0;
+    protected static int svi = 333;
+    private double vd = 136;
+    String[] vs = {"hi"};
+    RATest(int i) {
+        count = i;
+    }
+    public RATest(double[] i) {
+        count = i.length;
+    }
+    private RATest() {
+        count = -1;
+    }
+    private int mhVar(Object... a) {
+        return a.length;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/expected.txt b/testsuite/java_test/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/test.cfg b/testsuite/java_test/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..baf8c24b3b0fc5e7929c3699a0396205be726a8f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0188-rt-reflection-MethodHandleReflectCombineTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MethodHandleReflectCombineTest)
+run(MethodHandleReflectCombineTest)
diff --git a/testsuite/java_test/reflection_test/RT0189-rt-reflection-FieldTest/FieldTest.java b/testsuite/java_test/reflection_test/RT0189-rt-reflection-FieldTest/FieldTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b0c09c3d3832ad783852373afa50336021f55b5e
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0189-rt-reflection-FieldTest/FieldTest.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class FieldTest {
+    /**
+     * Verify that for the same field, different Field object is return when call following API twice:
+     * - Class.getFields()
+     * - Class.getDeclaredFields()
+     * - Class.getField(String name)
+     * - Class.getDeclareedField(String name)
+     * if any Field failed the check, will print error message including testcase and field name;
+     * after all check is pass, casePassed will be increased;
+    */
+
+    private static void classAllFieldTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getFields()
+        Field[] fields1 = clazz.getFields();
+        Field[] fields2 = clazz.getFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 2. Class.getDeclaredFields()
+            Field f1 = clazz.getField(f.getName());
+            Field f2 = clazz.getField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed");
+            }
+        }
+        // checkpoint 3. Class.getField(String name)
+        fields1 = clazz.getDeclaredFields();
+        fields2 = clazz.getDeclaredFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 4. Class.getDeclareedField(String name)
+            Field f1 = clazz.getDeclaredField(f.getName());
+            Field f2 = clazz.getDeclaredField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed for declared fields");
+            }
+        }
+        casesPassed++;
+    }
+    private static void checkFields(Field[] fields1, Field[] fields2) {
+        for (Field f1: fields1) {
+            for (Field f2: fields2) {
+                // only when modifers and class and name is same, two Field object is for same field
+                if(f1.toGenericString().equals(f2.toGenericString())) {
+                    if (singleFieldCheck(f1, f2) != 3) {
+                        System.out.println(f1.getName()+" failed in checkFields");
+                    }
+                }
+            }
+        }
+    }
+    private static int singleFieldCheck(Field f1, Field f2) {
+        int passCnt = 0;
+        passCnt += f1 == f2 ? 0 : 1;
+        passCnt += f1.equals(f2) ? 1 : 0;
+        passCnt += f1.hashCode() == f2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    static int casesPassed = 0;
+    public static void main(String [] args) {
+        field01();
+        field02();
+        field03();
+        field04();
+        field05();
+        field06();
+        field07();
+        field08();
+        field09();
+        field10();
+        field11();
+        field12();
+        System.out.println(casesPassed - 12);
+    }
+
+    private static void field01() {
+        try {
+            classAllFieldTest(Class.forName("java.lang.Thread"), "field01");
+        } catch (Exception e) {
+            System.out.println("Case field01 failed with exception" + e);
+        }
+    }
+
+    private static void field02() {
+        try {
+            classAllFieldTest(Class.forName("TestField02"), "field02");
+        } catch (Exception e) {
+            System.out.println("Case field02 failed with exception" + e);
+        }
+    }
+    
+    private static void field03() {
+        try {
+            classAllFieldTest(Class.forName("TestField03"), "field03");
+        } catch (Exception e) {
+            System.out.println("Case field03 failed with exception" + e);
+        }
+    }
+
+    private static void field04() {
+        try {
+            classAllFieldTest(Class.forName("TestField04"), "field04");
+        } catch (Exception e) {
+            System.out.println("Case field04 failed with exception" + e);
+        }
+    }
+
+    private static void field05() {
+        try {
+            classAllFieldTest(Class.forName("TestField05"), "field05");
+        } catch (Exception e) {
+            System.out.println("Case field05 failed with exception" + e);
+        }
+    }
+
+    private static void field06() {
+        try {
+            // step 1
+            Class clazz = Class.forName("FieldTest");
+            FieldTest mainClass = new FieldTest();
+            Field field = clazz.getDeclaredField("testField06");
+            classAllFieldTest(field.get(mainClass).getClass(), "field06");
+        } catch (Exception e) {
+            System.out.println("Case field06 failed with exception" + e);
+        }
+    }
+    private Runnable testField06 = new Runnable() {
+        int intAnonymous = 10;
+        public double doubleAnonymous = 1988.416;
+        @Override
+        public void run() {
+            for (int i = 0; i < intAnonymous; i++) {
+                intAnonymous += i;
+            }
+        }
+    };
+
+    private static void field07() {
+        class TestField07 {
+            private final transient int intLocal = 9;
+            public volatile String stringLocal = "a fake behind the fear";
+        }
+        try {
+            classAllFieldTest(Class.forName("FieldTest$1TestField07"), "field07");
+        } catch (Exception e) {
+            System.out.println("Case field07 failed with exception" + e);
+        }
+    }
+
+    private static void field08() {
+        try {
+            classAllFieldTest(Class.forName("FieldTest$TestField08"), "field08");
+        } catch (Exception e) {
+            System.out.println("Case field08 failed with exception" + e);
+        }
+    }
+    class TestField08 {
+        volatile private char charInner = 'l';
+        public final static transient double doubleInner = 0.88;
+    }
+
+    private static void field09() {
+        try {
+            classAllFieldTest(Class.forName("TestField09"), "field09");
+        } catch (Exception e) {
+            System.out.println("Case field09 failed with exception" + e);
+        }
+    }
+
+    private static void field10() {
+        try {
+            classAllFieldTest(Class.forName("TestField10"), "field10");
+        } catch (Exception e) {
+            System.out.println("Case field10 failed with exception" + e);
+        }
+    }
+
+    private static void field11() {
+        try {
+            classAllFieldTest(Class.forName("TestField11"), "field11");
+        } catch (Exception e) {
+            System.out.println("Case field11 failed with exception" + e);
+        }
+    }
+
+    private static void field12() {
+        try {
+            classAllFieldTest(Class.forName("TestField12"), "field12");
+        } catch (Exception e) {
+            System.out.println("Case field12 failed with exception" + e);
+        }
+    }
+}
+class TestField02 {
+    // step1
+    boolean booleanField = true;
+    byte byteField = (byte)2;
+    short shortField = (short)4;
+    int intField = 6;
+    long longField = 8;
+    char charField = 10;
+    float floatField = 0.4f;
+    double doubleField = 0.8;
+    String stringField = "The queerest of the queer";
+    Runnable r = null;
+    boolean[][][][][][][] booleanArray7 = new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    String[][][] stringArray3 = new String[][][] {{{"the strangest of the strange"}}};
+    // step2
+    public int publicInt = 88;
+    protected double protectedDouble = 99;
+    private String privateString = "the coldest of the cool";
+    // step3
+    transient double[][] transientDoubleArray = new double[][] {{1988, 4.16}};
+    final int finalInt = 9876;
+    volatile String volatileString = "the lamest of the lame";
+    static Character staticCharacter = 'd';
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotation = new String[][] {{"the numbest of the dumb"}};
+}
+strictfp class TestField03 {
+    float floatField = 4.16f;
+    public double doubleField = 19.88;
+}
+interface TestField04 {
+    String stringInterface = "i know what's good for you";
+    char[] charInterface = new char[] {'l', 'e', 't'};
+}
+abstract class TestField05 {
+    String[] stringsAbstractArray = {"i hate to see you here", "you choke behind a smile"};
+    Runnable[] runnableAbstractArray = {new Runnable() {
+            @Override
+            public void run() {
+            }
+        }
+    };
+}
+enum TestField09 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnum = (short)6;
+    public final String stringEnum = "Dry Martini";
+}
+class TestField10 {
+    public int int10;
+    protected boolean boolean10;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    private String string10 = "I'm only happy when it rains";
+}
+class TestField11 extends TestField10 implements TestField12 {
+    boolean boolean10 = true;
+    public double double11 = 0.416;
+}
+interface TestField12 {
+    int int10 = 9;
+    boolean boolean10 = false;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    String string10 = "I'm only happy when it rains";
+}
diff --git a/testsuite/java_test/reflection_test/RT0189-rt-reflection-FieldTest/expected.txt b/testsuite/java_test/reflection_test/RT0189-rt-reflection-FieldTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0189-rt-reflection-FieldTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0189-rt-reflection-FieldTest/test.cfg b/testsuite/java_test/reflection_test/RT0189-rt-reflection-FieldTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ec3f12a923126e4b93fb41a72a53faaff0d137a1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0189-rt-reflection-FieldTest/test.cfg
@@ -0,0 +1,2 @@
+compile(FieldTest)
+run(FieldTest)
diff --git a/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/AnnotationTypeSetTest.java b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/AnnotationTypeSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..615b036e3fc3ff7bb32da41c505de80af9e746bb
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/AnnotationTypeSetTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeSetTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+class Test{
+}
diff --git a/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8ea5008fce368287bdb16089a1867d80a13fa794
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0190-rt-reflection-AnnotationTypeSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeSetTest)
+run(AnnotationTypeSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/AnnotationTypeInterfaceSetTest.java b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/AnnotationTypeInterfaceSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..74b6dfb12a11edf5833c8c2c10cecac77fe3a397
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/AnnotationTypeInterfaceSetTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeInterfaceSetTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+interface Test{
+}
diff --git a/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6b32e873b414967370df1b01aa0f2106ea68592a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0191-rt-reflection-AnnotationTypeInterfaceSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeInterfaceSetTest)
+run(AnnotationTypeInterfaceSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/AnnotationTypeEnumSetTest.java b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/AnnotationTypeEnumSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..93d8eb02b89bad079fd67937541e136a4f44d1dd
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/AnnotationTypeEnumSetTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeEnumSetTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+enum Test{
+}
diff --git a/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ee4cdfc20d21f089b6047692f139fab83cdcb42b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0192-rt-reflection-AnnotationTypeEnumSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeEnumSetTest)
+run(AnnotationTypeEnumSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..614f2371bbeaf23b65039b3d59d70baf177a4ea2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/AnnotationFieldSetTest.java b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/AnnotationFieldSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..a50d50a3bedc3915f5074bbea8213188a4cb949c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/AnnotationFieldSetTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Arrays;
+public class AnnotationFieldSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchFieldException {
+        AnnoA anno = Test.class.getDeclaredField("a").getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    String a;
+}
diff --git a/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4dc898cb309c6f3cacc1906f934c8dcc2fc7e98c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0193-rt-reflection-AnnotationFieldSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationFieldSetTest)
+run(AnnotationFieldSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..614f2371bbeaf23b65039b3d59d70baf177a4ea2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/AnnotationStaticFieldSetTest.java b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/AnnotationStaticFieldSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8364266e91fce89cacc97da16e462784b9372ae8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/AnnotationStaticFieldSetTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationStaticFieldSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchFieldException {
+        AnnoA anno = Test.class.getDeclaredField("a").getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    private static int[] a;
+}
diff --git a/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50f69044c8556d1542458239cfd76ed14c981750
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0194-rt-reflection-AnnotationStaticFieldSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationStaticFieldSetTest)
+run(AnnotationStaticFieldSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..c98e2c01ccecf2600dfe57f57c78b9e1aaeaad49
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/AnnotationMethodSetTest.java b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/AnnotationMethodSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ebe5eb20a32c6d9052606f802d5000b8cf98c467
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/AnnotationMethodSetTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationMethodSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchMethodException {
+        AnnoA anno = Test.class.getDeclaredMethod("a").getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // arrays
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    private Thread.State[] a(){
+        return new Thread.State[]{};
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..61341eb20d657afc2afe463acdb6f1884a60c7cb
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0195-rt-reflection-AnnotationMethodSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationMethodSetTest)
+run(AnnotationMethodSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..12b3d7209f62d594b70c2ef4513da23de3efdd9f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/AnnotationParameterSetTest.java b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/AnnotationParameterSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..cbf996d4aa4e685783d820c444b0817e0c9a0962
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/AnnotationParameterSetTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Arrays;
+public class AnnotationParameterSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchMethodException {
+//        System.out.println(Test.class.getDeclaredMethod("a"));
+        AnnoA anno = (AnnoA) Test.class.getDeclaredMethod("a", Object[].class).getParameterAnnotations()[0][0];
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    private Thread.State[] a(@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) Object... aaa){
+        return new Thread.State[]{};
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6275cf89e424906deba258479f8c0aea1cb829c5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0196-rt-reflection-AnnotationParameterSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationParameterSetTest)
+run(AnnotationParameterSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..19269167aff51739e573b950db0253dc59e213c2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.CONSTRUCTOR)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/AnnotationConstructorSetTest.java b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/AnnotationConstructorSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..58eeb71775388568a2644762052b6cd74b017b26
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/AnnotationConstructorSetTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationConstructorSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) throws NoSuchMethodException {
+//        System.out.println(Test.class.getDeclaredMethod("a"));
+        AnnoA anno = Test.class.getDeclaredConstructor(Object[].class).getDeclaredAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+class Test{
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    Test(Object... aaa){
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d5a9e85d95e56d7c521deaa9232123eb8900c5dd
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0197-rt-reflection-AnnotationConstructorSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationConstructorSetTest)
+run(AnnotationConstructorSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..945eba1f83594c4b9e07b6dce5fe009a9ed5426d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..bf518f610518fcb606b9ff58471235f978594fa8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/AnnoB.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/AnnotationAnnotationTypeSetTest.java b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/AnnotationAnnotationTypeSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..c8ee5c5f295e7b12a2a5f7bfacbe77ad4c766a3f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/AnnotationAnnotationTypeSetTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Arrays;
+public class AnnotationAnnotationTypeSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        AnnoA anno = AnnoB.class.getDeclaredAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cb99dab576754a54961ea3da7cd1d2c381bba592
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0198-rt-reflection-AnnotationAnnotationTypeSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationAnnotationTypeSetTest)
+run(AnnotationAnnotationTypeSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/Run.java b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/Run.java
new file mode 100755
index 0000000000000000000000000000000000000000..67287b007efa51b07a2b5da40bd055166306d152
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/Run.java
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
diff --git a/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com.huawei.AnnotationPackageSetTest.jar b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com.huawei.AnnotationPackageSetTest.jar
new file mode 100644
index 0000000000000000000000000000000000000000..dfc522b1cb4290957039d57cec7b377433a886a1
Binary files /dev/null and b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com.huawei.AnnotationPackageSetTest.jar differ
diff --git a/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/AnnoA.java b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..f9e0aa843b412b552fefe037de229df9bf18b8ef
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/AnnoA.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+package com.huawei;
+import com.huawei.AnnoB;
+import java.lang.annotation.*;
+@Target(ElementType.PACKAGE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/AnnoB.java b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..caad060f5bfd03b07219bea689246e26a02446ea
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/AnnoB.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+package com.huawei;
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/AnnotationPackageSetTest.java b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/AnnotationPackageSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..d6ca1da27321aad3f1546b17808456d039efb119
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/AnnotationPackageSetTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+package com.huawei;
+import java.util.Arrays;
+public class AnnotationPackageSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        Package packageInfo = Package.getPackage("com.huawei");
+        AnnoA anno = packageInfo.getDeclaredAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@com.huawei.AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@com.huawei.AnnoB(intB=999), @com.huawei.AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/package-info.java b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/package-info.java
new file mode 100755
index 0000000000000000000000000000000000000000..ed0de5fb4250a8e14c7586951c2c089f3881150f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/com/huawei/package-info.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+package com.huawei;
+class PackageInfo{
+    public void say(){
+        System.out.println("hello");
+    }
+}
+class PackageInfoGeneric<T extends Throwable>{
+    private T obj;
+    public void setObj(T obj) {
+        this.obj = obj;
+    }
+    public void say(){
+        System.out.println("hello "+obj);
+    }
+}
+interface PackageInfoInterface {
+    void test();
+}
+class PackageInfoConst {
+    public static final String MESSAGE="Annotation Study";
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..443b58b1a819d0291bb34f5198d6afca7ad6d8af
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0199-rt-reflection-AnnotationPackageSetTest/test.cfg
@@ -0,0 +1,5 @@
+javac com/huawei/*.java
+jar -cvf com.huawei.AnnotationPackageSetTest.jar com/
+${OUT_ROOT}/target/product/public/bin/jar2dex -p ${OUT_ROOT}/target/product/public/third-party/JAVA_LIBRARIES/core-oj_intermediates/classes.jar:${OUT_ROOT}/target/product/public/third-party/JAVA_LIBRARIES/core-libart_intermediates/classes.jar:${OUT_ROOT}/target/product/public/third-party/JAVA_LIBRARIES/framework_intermediates/classes.jar:${OUT_ROOT}/target/product/public/third-party/JAVA_LIBRARIES/services_intermediates/classes.jar -i com.huawei.AnnotationPackageSetTest.jar
+compile(com.huawei.AnnotationPackageSetTest)
+run(com.huawei.AnnotationPackageSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f06bbbee2c53d37e325643d7aad8d49273e72e7
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE_PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..4699d6adac9e2f5925733ffcca8d673f87b91d18
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnotationTypeParameterSetTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeParameterSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        System.out.println(Test.class.getAnnotations().length);
+//      TypeVeriable.getAnnotation not supported in ART
+/*      AnnoA anno = Test.class.getTypeParameters()[0].getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));*/
+    }
+}
+class Test<@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) T> {
+}
diff --git a/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..91858c287691e1809a305f3e6ff1261427c46223
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeParameterSetTest)
+run(AnnotationTypeParameterSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..2104c625abbc58059295356101ddb20286205228
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE_USE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..028a1d59dd9692d8e3eb1f174469ba7145ed75b0
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnotationTypeUseSetTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeUseSetTest {
+    static int[] passCnt;
+    public static void main(String[] args) {
+        System.out.println(Test.class.getAnnotations().length);
+/*        AnnoA anno = Test.class.getTypeParameters()[0].getAnnotation(AnnoA.class);
+        passCnt = new int[24];
+        // 基本数据类型
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        //enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        //基本类型数组
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));*/
+    }
+}
+class Test<@AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+        booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+        intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+        stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+        stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB}) T> {
+}
diff --git a/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/expected.txt b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/test.cfg b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..32e449eb780f2b69be5acb1f25cc093f5bb90fc8
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeUseSetTest)
+run(AnnotationTypeUseSetTest)
diff --git a/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoA.java b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..bd35de2ef9e511bcbbe9ee4c21c20725314de948
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoA.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA() default Integer.MAX_VALUE;
+    double doubleA() default Double.MIN_VALUE;
+    String stringA() default "";
+    AnnoB annoBA();
+    ENUMA enumA() default ENUMA.A;
+}
diff --git a/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoB.java b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoC.java b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoC.java
new file mode 100755
index 0000000000000000000000000000000000000000..cbf9e24cbbebe37e60dd66f776a237c46fded798
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoC.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoC {
+    int[] intA() default Integer.MAX_VALUE;
+    double[] doubleA() default Double.MIN_VALUE;
+    String[] stringA() default "";
+    AnnoB[] annoBA() default @AnnoB;
+    ENUMA[] enumA() default ENUMA.A;
+}
diff --git a/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoD.java b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoD.java
new file mode 100755
index 0000000000000000000000000000000000000000..e15b5d4c2881118deef1cd9bef9303abc3959410
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoD.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoD {
+    int intA() default Integer.MAX_VALUE;
+    double doubleA() default Double.MIN_VALUE;
+    String stringA() default "";
+    AnnoB annoBA();
+    ENUMA enumA() default ENUMA.A;
+}
diff --git a/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnotationMultiThread.java b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnotationMultiThread.java
new file mode 100755
index 0000000000000000000000000000000000000000..6936d3e0c230ad9fc2960e06f62186aa79a48395
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnotationMultiThread.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.Annotation;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicInteger;
+public class AnnotationMultiThread {
+    static AtomicInteger passCnt = new AtomicInteger();
+    public static void main(String[] args) throws ClassNotFoundException {
+        ThreadGroup threadGroup = new ThreadGroup("myGroup");
+        String[][] expectedGF = new String[][]{
+                {"@AnnoA", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+                {"@AnnoB(intB=999)"},
+                {"@AnnoC", "annoBA=[@AnnoB(intB=999)]", "intA=[2147483647]", "enumA=[A]", "stringA=[]", "doubleA=[4.9E-324]"}
+        };
+        String[][] expectedF = new String[][]{
+                {"@AnnoA", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+                {"@AnnoB(intB=999)"},
+                {"@AnnoC", "annoBA=[@AnnoB(intB=999)]", "intA=[2147483647]", "enumA=[A]", "stringA=[]", "doubleA=[4.9E-324]"},
+                {"@AnnoD", "enumA=A", "intA=2147483647", "stringA=", "doubleA=4.9E-324", "annoBA=@AnnoB(intB=999)"},
+        };
+        new AnnotationGetter("GrandFather", expectedGF, expectedGF, threadGroup, "threadGF").start();
+        new AnnotationGetter("Father", expectedF, expectedF, threadGroup, "threadF").start();
+        new AnnotationGetter("Interface", expectedF, expectedF, threadGroup, "threadI").start();
+        new AnnotationGetter("Son", expectedF, new String[][]{}, threadGroup, "threadS").start();
+        new AnnotationGetter("Son2", expectedF, new String[][]{}, threadGroup, "threadS2").start();
+        new AnnotationGetter("GrandFather", expectedGF, expectedGF, threadGroup, "threadGF").start();
+        new AnnotationGetter("Father", expectedF, expectedF, threadGroup, "threadF").start();
+        new AnnotationGetter("Interface", expectedF, expectedF, threadGroup, "threadI").start();
+        new AnnotationGetter("Son", expectedF, new String[][]{}, threadGroup, "threadI").start();
+        new AnnotationGetter("Son2", expectedF, new String[][]{}, threadGroup, "threadI").start();
+        int i = 0;
+        while (threadGroup.activeCount() > 0){
+            i++;
+            try {
+                Thread.sleep(100);
+            }catch (InterruptedException e){
+                System.out.println(e);
+            }
+            if(i > 1000){
+                break;
+            }
+        }
+        System.out.println(passCnt.get() - 200);
+    }
+    public static boolean checkAllAnnotations(Annotation[] annotations, String[][] expected){
+        String[] actual = new String[annotations.length];
+        for (int i = 0; i < annotations.length; i++){
+            actual[i] = annotations[i].toString();
+        }
+        Arrays.sort(actual);
+        if (actual.length != expected.length){
+            return false;
+        }
+//        System.out.println(Arrays.toString(actual));
+        for (int i = 0; i < annotations.length; i++){
+            if (expected[i].length == 1){
+                if (actual[i].compareTo(expected[i][0])!=0){
+                    System.out.println(actual[i]);
+                    System.out.println(expected[i][0]);
+                    return false;
+                }
+            }else {
+                for (int j = 0; j < expected[i].length; j++){
+                    if (!actual[i].contains(expected[i][j])){
+                        System.out.println(actual[i]);
+                        System.out.println(expected[i][j]);
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+}
+class AnnotationGetter extends Thread{
+    String name;
+    String[][] expected;
+    String[][] expectedD;
+    AnnotationGetter(String nameI, String[][] expectedI, String[][] expectedDI, ThreadGroup threadGroup, String thread_name){
+        super(threadGroup, thread_name);
+        name = nameI;
+        expected = expectedI;
+        expectedD = expectedDI;
+    }
+    @Override
+    public void run() {
+        try {
+            for (int i = 0; i < 10; i++) {
+                if (AnnotationMultiThread.checkAllAnnotations(Class.forName(this.name).getAnnotations(), this.expected)){
+                    AnnotationMultiThread.passCnt.incrementAndGet();
+                }
+                if (AnnotationMultiThread.checkAllAnnotations(Class.forName(this.name).getDeclaredAnnotations(), this.expectedD)){
+                    AnnotationMultiThread.passCnt.incrementAndGet();
+                }
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+}
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+class GrandFather{
+    public void method1(int a, double b, Object... objects){
+    }
+}
+@SuppressWarnings("all")
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+@AnnoD(annoBA = @AnnoB)
+class Father extends GrandFather implements Interface{
+    @Override
+    public void method1(int a, double b, Object... objects) {
+    }
+    @Deprecated
+    public void method2(){
+    }
+}
+class Son extends Father{
+    @Override
+    @Deprecated
+    public void method2(){
+    }
+}
+class Son2 extends Father{
+    @Override
+    @Deprecated
+    public void method2(){
+    }
+}
+@SuppressWarnings("all")
+@AnnoB
+@AnnoA(annoBA = @AnnoB)
+@AnnoC()
+@AnnoD(annoBA = @AnnoB)
+interface Interface{
+}
diff --git a/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/ENUMA.java b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/ENUMA.java
new file mode 100755
index 0000000000000000000000000000000000000000..bb9cee8770af2ae1fdcc7206c31bd5062d02d38c
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/ENUMA.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+public enum  ENUMA {
+    A,
+    B,
+    C
+}
diff --git a/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/expected.txt b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/test.cfg b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f0a86e6cb9812d985916785bd09af15e8e23af70
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationMultiThread)
+run(AnnotationMultiThread)
diff --git a/testsuite/java_test/reflection_test/RT0203-rt-reflection-ReflectSpecialClassNameTest/ReflectClassNameTest.java b/testsuite/java_test/reflection_test/RT0203-rt-reflection-ReflectSpecialClassNameTest/ReflectClassNameTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..0436ede5a91978cf03681c7212fb530fb6b63062
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0203-rt-reflection-ReflectSpecialClassNameTest/ReflectClassNameTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+public class ReflectClassNameTest {
+    static int[] passCnt = new int[6];
+    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {
+        int i = 0;
+        Class clazz = Class.forName("一");
+        passCnt[i++] = clazz.getName().compareTo("一") == 0 ? 1 : 0;
+        Method method = clazz.getDeclaredMethod("дракон");
+        passCnt[i++] = method.getName().compareTo("дракон") == 0 ? 1 : 0;
+        Field field = clazz.getDeclaredField("Rồng");
+        passCnt[i++] = field.getName().compareTo("Rồng") == 0 ? 1 : 0;
+        Class clazz2 = Class.forName("二");
+        passCnt[i++] = clazz2.getName().compareTo("二") == 0 ? 1 : 0;
+        class 三{
+        }
+        Class clazz3 = Class.forName("ReflectClassNameTest$1三");
+        passCnt[i++] = clazz3.getName().compareTo("ReflectClassNameTest$1三") == 0 ? 1 : 0;
+        Class clazz4 = Class.forName("ReflectClassNameTest$二");
+        passCnt[i++] = clazz4.getName().compareTo("ReflectClassNameTest$二") == 0 ? 1 : 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1]"));
+    }
+    class 二{
+    }
+}
+class 一{
+    int Rồng;
+    public void дракон(){
+    }
+}
+interface 二{
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/RT0203-rt-reflection-ReflectSpecialClassNameTest/expected.txt b/testsuite/java_test/reflection_test/RT0203-rt-reflection-ReflectSpecialClassNameTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0203-rt-reflection-ReflectSpecialClassNameTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0203-rt-reflection-ReflectSpecialClassNameTest/test.cfg b/testsuite/java_test/reflection_test/RT0203-rt-reflection-ReflectSpecialClassNameTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..06e0b8123d3b6722f80e331462957ad233cf55e5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0203-rt-reflection-ReflectSpecialClassNameTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectClassNameTest)
+run(ReflectClassNameTest)
diff --git a/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/AnnoA.java b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..157d9b9509e006c87c49782ccf9f20b56e3716f4
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int 整型();
+    byte 字节();
+    char 字符();
+    double 双精度浮点();
+    boolean 布尔();
+    long 长整();
+    float 浮点();
+    short 短整型();
+    int[] あ();
+    byte[] い();
+    char[] う();
+    double[] え();
+    boolean[] お();
+    long[] か();
+    float[] き();
+    short[] く();
+    String 长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长();
+    String[] 神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马();
+    Class 类();
+    Class[] 类类();
+    Thread.State 类类类();
+    Thread.State[] 类类类类();
+    AnnoB 类类类类类();
+    AnnoB[] 类类类类类类();
+}
diff --git a/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/AnnoB.java b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/AnnotationNotAscii.java b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/AnnotationNotAscii.java
new file mode 100755
index 0000000000000000000000000000000000000000..476e432bd802a7d6c85a72695e4a48ab62910f5b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/AnnotationNotAscii.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationNotAscii {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.整型() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.字节() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.字符() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.双精度浮点()) ? 1: 0;
+        passCnt[i++] += anno.布尔() ? 1: 0;
+        passCnt[i++] += anno.长整() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.浮点())? 1: 0;
+        passCnt[i++] += anno.短整型() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.类类类() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.类() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.あ()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.い().length == 1 && anno.い()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.う().length == 1 && anno.う()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.え().length == 3 && Double.isNaN(anno.え()[0]) && Double.isInfinite(anno.え()[1]) && Double.isInfinite(anno.え()[2]))? 1: 0;
+        passCnt[i++] += (anno.お().length == 1 && anno.お()[0]) ? 1: 0;
+        passCnt[i++] += (anno.か().length == 1 && anno.か()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.き().length == 3 && Float.isNaN(anno.き()[0]) && Float.isInfinite(anno.き()[1]) && Float.isInfinite(anno.き()[2])) ? 1: 0;
+        passCnt[i++] += (anno.く().length == 1 && anno.く()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马().length == 1 && anno.神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.类类().length == 1 && anno.类类()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.类类类类().length == 1 && anno.类类类类()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.类类类类类().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.类类类类类类()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+@AnnoA(整型 = Integer.MAX_VALUE, 字节 = Byte.MAX_VALUE, 字符 = Character.MAX_VALUE, 双精度浮点 = Double.NaN,
+        布尔 = true, 长整 = Long.MAX_VALUE, 浮点 = Float.NaN, 短整型 = Short.MAX_VALUE,
+        あ = {1,2}, い = {0}, う = {' '}, え = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+        お = {true}, か = {Long.MAX_VALUE}, き = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, く = {0},
+        长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长 = "", 神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马神马 = "", 类 = Thread.class, 类类 = Thread.class, 类类类 = Thread.State.BLOCKED,
+        类类类类 = Thread.State.NEW, 类类类类类 = @AnnoB, 类类类类类类 = {@AnnoB, @AnnoB})
+class Test{
+}
diff --git a/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/expected.txt b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/test.cfg b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..860876a2f7d84dbdfff587aee4e706cf29ab7c35
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0204-rt-reflection-AnnotationSpecialCharacter/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationNotAscii)
+run(AnnotationNotAscii)
diff --git a/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/AnnoA.java b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..a11eacb37f45e1ebb430d60436afaf8f42ab27dc
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/AnnoA.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Repeatable(Test.class)
+@AnnoB(intB = 1)
+@AnnoB(intB = 2)
+@AnnoB(intB = 3)
+@AnnoB(intB = 4)
+@AnnoB(intB = 5)
+@AnnoB(intB = 6)
+@AnnoB(intB = 7)
+@AnnoB(intB = 8)
+@AnnoB(intB = 9)
+@AnnoB(intB = 10)
+@AnnoB(intB = 11)
+@AnnoB(intB = 12)
+@AnnoB(intB = 13)
+@AnnoB(intB = 14)
+@AnnoB(intB = 15)
+@AnnoB(intB = 16)
+@AnnoB(intB = 17)
+@AnnoB(intB = 18)
+public @interface AnnoA {
+    int intA() default 0;
+    byte byteA() default 0;
+    char charA() default 0;
+    double doubleA() default 0;
+    boolean booleanA() default true;
+    long longA() default 0;
+    float floatA() default 0;
+    short shortA() default 0;
+    int[] intAA() default 0;
+    byte[] byteAA() default 0;
+    char[] charAA() default 0;
+    double[] doubleAA() default 0;
+    boolean[] booleanAA() default true;
+    long[] longAA() default 0;
+    float[] floatAA() default 0;
+    short[] shortAA() default 0;
+    String stringA() default "";
+    String[] stringAA() default "";
+    Class classA() default Thread.class;
+    Class[] classAA() default Thread.class;
+    Thread.State stateA() default Thread.State.BLOCKED;
+    Thread.State[] stateAA() default Thread.State.BLOCKED;
+    AnnoB annoBA() default @AnnoB;
+    AnnoB[] annoBAA() default @AnnoB;
+    AnnoB[] value();
+}
diff --git a/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/AnnoB.java b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d15656d5f53fd8dcd0d941b293cf4f9a6ba6d30
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/AnnoB.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Repeatable(AnnoA.class)
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/AnnotationRepeatable.java b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/AnnotationRepeatable.java
new file mode 100755
index 0000000000000000000000000000000000000000..fdacc6b45e9c2b7e489f4d6e33bb8cc8f9595cad
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/AnnotationRepeatable.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationRepeatable {
+    static int[] passCnt = new int[25];
+    public static void main(String[] args) {
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[0], "[@AnnoB(intB=-1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[1], "[@AnnoB(intB=-2), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[2], "[@AnnoB(intB=-3), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[3], "[@AnnoB(intB=-4), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[4], "[@AnnoB(intB=-5), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[5], "[@AnnoB(intB=-6), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[6], "[@AnnoB(intB=-7), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[7], "[@AnnoB(intB=-8), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[8], "[@AnnoB(intB=-9), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        checkAnnoA(Test.class.getAnnotation(Test.class).value()[9], "[@AnnoB(intB=-10), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1), @AnnoB(intB=1)]");
+        boolean checkAnnoA = Arrays.toString(passCnt).compareTo("[1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]") == 0;
+        boolean checkAnnoB = Arrays.toString(AnnoA.class.getAnnotation(AnnoA.class).value()).compareTo("[@AnnoB(intB=1), @AnnoB(intB=2), @AnnoB(intB=3), @AnnoB(intB=4), @AnnoB(intB=5), @AnnoB(intB=6), @AnnoB(intB=7), @AnnoB(intB=8), @AnnoB(intB=9), @AnnoB(intB=10), @AnnoB(intB=11), @AnnoB(intB=12), @AnnoB(intB=13), @AnnoB(intB=14), @AnnoB(intB=15), @AnnoB(intB=16), @AnnoB(intB=17), @AnnoB(intB=18)]") == 0;
+        if (checkAnnoA && checkAnnoB){
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+    private static void checkAnnoA(AnnoA anno, String value){
+        int i = 0;
+        passCnt[i++] = anno.intA() == 0 ? 1: 0;
+        passCnt[i++] += anno.byteA() == 0 ? 1: 0;
+        passCnt[i++] += anno.charA() == 0 ? 1: 0;
+        passCnt[i++] += anno.doubleA() == 0 ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == 0 ? 1: 0;
+        passCnt[i++] += anno.floatA() == 0? 1: 0;
+        passCnt[i++] += anno.shortA() == 0 ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        // array
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[0]") == 0 ? 1: 0;
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 1 && anno.doubleAA()[0] == 0)? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 1 && anno.floatAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.BLOCKED) ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999)]") == 0 ? 1: 0;
+        // value
+        passCnt[i++] += Arrays.toString(anno.value()).compareTo(value) == 0 ? 1: 0;
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/Test.java b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/Test.java
new file mode 100755
index 0000000000000000000000000000000000000000..cb55e7627fe78db39c9395e773c54f456969b2d6
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/Test.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@AnnoA( value = @AnnoB(intB = -1))
+@AnnoA( value = {@AnnoB(intB = -2), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -3), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -4), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -5), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -6), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -7), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -8), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -9), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+@AnnoA( value = {@AnnoB(intB = -10), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1), @AnnoB(intB = 1)})
+public @interface Test{
+    AnnoA[] value();
+}
diff --git a/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/expected.txt b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/test.cfg b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c755472308797f164e619c2fef54eea464504963
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0205-rt-reflection-AnnotationRepeatable/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationRepeatable)
+run(AnnotationRepeatable)
diff --git a/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/AnnoA.java b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/AnnoB.java b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/AnnotationTypeInnerClassSet.java b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/AnnotationTypeInnerClassSet.java
new file mode 100755
index 0000000000000000000000000000000000000000..3c8e436a41a7b45907005ff9c2ccfbe11adcf486
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/AnnotationTypeInnerClassSet.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeInnerClassSet {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) throws ClassNotFoundException {
+        AnnoA anno = Class.forName("AnnotationTypeInnerClassSet$Test").getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+    @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+            booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+            intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+            stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+            stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+    class Test{
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/expected.txt b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/test.cfg b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cf69c82b1885bc7d69ac92346fd6334b1cc54179
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0206-rt-reflection-AnnotationTypeInnerClassSet/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeInnerClassSet)
+run(AnnotationTypeInnerClassSet)
diff --git a/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/AnnoA.java b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/AnnoA.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd152bebfc5b736c3b1bdda44dec59c6e482e58b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA();
+    byte byteA();
+    char charA();
+    double doubleA();
+    boolean booleanA();
+    long longA();
+    float floatA();
+    short shortA();
+    int[] intAA();
+    byte[] byteAA();
+    char[] charAA();
+    double[] doubleAA();
+    boolean[] booleanAA();
+    long[] longAA();
+    float[] floatAA();
+    short[] shortAA();
+    String stringA();
+    String[] stringAA();
+    Class classA();
+    Class[] classAA();
+    Thread.State stateA();
+    Thread.State[] stateAA();
+    AnnoB annoBA();
+    AnnoB[] annoBAA();
+}
diff --git a/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/AnnoB.java b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/AnnoB.java
new file mode 100755
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/AnnotationTypeLocalClassSet.java b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/AnnotationTypeLocalClassSet.java
new file mode 100755
index 0000000000000000000000000000000000000000..7257bdc7d9b5acbe434299229f8e7d7f466860e3
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/AnnotationTypeLocalClassSet.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationTypeLocalClassSet {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) throws ClassNotFoundException {
+        @AnnoA(intA = Integer.MAX_VALUE, byteA = Byte.MAX_VALUE, charA = Character.MAX_VALUE, doubleA = Double.NaN,
+                booleanA = true, longA = Long.MAX_VALUE, floatA = Float.NaN, shortA = Short.MAX_VALUE,
+                intAA = {1,2}, byteAA = {0}, charAA = {' '}, doubleAA = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+                booleanAA = {true}, longAA = {Long.MAX_VALUE}, floatAA = {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY}, shortAA = {0},
+                stringA = "", stringAA = "", classA = Thread.class, classAA = Thread.class, stateA = Thread.State.BLOCKED,
+                stateAA = Thread.State.NEW, annoBA = @AnnoB, annoBAA = {@AnnoB, @AnnoB})
+        class Test{
+        }
+        AnnoA anno = Class.forName("AnnotationTypeLocalClassSet$1Test").getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
diff --git a/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/expected.txt b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/test.cfg b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7c4510af3ca837721799887d8d51cd598afe9ffb
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0207-rt-reflection-AnnotationTypeLocalClassSet/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationTypeLocalClassSet)
+run(AnnotationTypeLocalClassSet)
diff --git a/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/AnnoA.java b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/AnnoA.java
new file mode 100644
index 0000000000000000000000000000000000000000..40d499c74a9e1060b209c67df42b29512459ade1
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/AnnoA.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoA {
+    int intA() default Integer.MAX_VALUE;
+    byte byteA() default Byte.MAX_VALUE;
+    char charA() default Character.MAX_VALUE;
+    double doubleA() default Double.NaN;
+    boolean booleanA() default true;
+    long longA() default Long.MAX_VALUE;
+    float floatA() default Float.NaN;
+    short shortA() default Short.MAX_VALUE;
+    int[] intAA() default {1,2};
+    byte[] byteAA() default {0};
+    char[] charAA() default {' '};
+    double[] doubleAA() default {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY};
+    boolean[] booleanAA() default {true};
+    long[] longAA() default {Long.MAX_VALUE};
+    float[] floatAA() default {Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY};
+    short[] shortAA() default {0};
+    String stringA() default "";
+    String[] stringAA() default "";
+    Class classA() default Thread.class;
+    Class[] classAA() default Thread.class;
+    Thread.State stateA() default Thread.State.BLOCKED;
+    Thread.State[] stateAA() default Thread.State.NEW;
+    AnnoB annoBA() default  @AnnoB;
+    AnnoB[] annoBAA() default {@AnnoB, @AnnoB};
+}
diff --git a/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/AnnoB.java b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/AnnoB.java
new file mode 100644
index 0000000000000000000000000000000000000000..64e06d4daf24f6f78e5b31b447e0d31395602415
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/AnnoB.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface AnnoB {
+    int intB() default 999;
+}
diff --git a/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/AnnotationDefaultTest.java b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/AnnotationDefaultTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..52bd1b07da2abed96de4ea67686b45e1bd2fae3a
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/AnnotationDefaultTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.util.Arrays;
+public class AnnotationDefaultTest {
+    static int[] passCnt = new int[24];
+    public static void main(String[] args) {
+        AnnoA anno = Test.class.getAnnotation(AnnoA.class);
+        // primitive type
+        int i = 0;
+        passCnt[i++] = anno.intA() == Integer.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.byteA() == Byte.MAX_VALUE ? 1: 0;
+        passCnt[i++] += anno.charA() == Character.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Double.isNaN(anno.doubleA()) ? 1: 0;
+        passCnt[i++] += anno.booleanA() ? 1: 0;
+        passCnt[i++] += anno.longA() == Long.MAX_VALUE ? 1: 0;
+        passCnt[i++] += Float.isNaN(anno.floatA())? 1: 0;
+        passCnt[i++] += anno.shortA() == Short.MAX_VALUE ? 1: 0;
+        // enum, string, annotation, class
+        passCnt[i++] += anno.stateA() == Thread.State.BLOCKED ? 1: 0;
+        passCnt[i++] += anno.stringA().compareTo("") == 0 ? 1: 0;
+        passCnt[i++] += anno.classA() == Thread.class ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.intAA()).compareTo("[1, 2]") == 0 ? 1: 0;
+        // array
+        passCnt[i++] += (anno.byteAA().length == 1 && anno.byteAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.charAA().length == 1 && anno.charAA()[0] == ' ') ? 1: 0;
+        passCnt[i++] += (anno.doubleAA().length == 3 && Double.isNaN(anno.doubleAA()[0]) && Double.isInfinite(anno.doubleAA()[1]) && Double.isInfinite(anno.doubleAA()[2]))? 1: 0;
+        passCnt[i++] += (anno.booleanAA().length == 1 && anno.booleanAA()[0]) ? 1: 0;
+        passCnt[i++] += (anno.longAA().length == 1 && anno.longAA()[0] == Long.MAX_VALUE) ? 1: 0;
+        passCnt[i++] += (anno.floatAA().length == 3 && Float.isNaN(anno.floatAA()[0]) && Float.isInfinite(anno.floatAA()[1]) && Float.isInfinite(anno.floatAA()[2])) ? 1: 0;
+        passCnt[i++] += (anno.shortAA().length == 1 && anno.shortAA()[0] == 0) ? 1: 0;
+        passCnt[i++] += (anno.stringAA().length == 1 && anno.stringAA()[0].compareTo("")==0) ? 1: 0;
+        passCnt[i++] += (anno.classAA().length == 1 && anno.classAA()[0] == Thread.class)? 1: 0;
+        passCnt[i++] += (anno.stateAA().length == 1 && anno.stateAA()[0] == Thread.State.NEW) ? 1: 0;
+        passCnt[i++] += anno.annoBA().toString().compareTo("@AnnoB(intB=999)")==0 ? 1: 0;
+        passCnt[i++] += Arrays.toString(anno.annoBAA()).compareTo("[@AnnoB(intB=999), @AnnoB(intB=999)]") == 0 ? 1: 0;
+        System.out.println(Arrays.toString(passCnt).compareTo("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"));
+    }
+}
+@AnnoA
+class Test{
+}
diff --git a/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/expected.txt b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/test.cfg b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8a2e6684aa033fb89355a4515dd00dfd6f3e4121
--- /dev/null
+++ b/testsuite/java_test/reflection_test/RT0211-rt-reflection-AnnotationDefaultTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AnnotationDefaultTest)
+run(AnnotationDefaultTest)
diff --git a/testsuite/java_test/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/ReflectionForName2.java b/testsuite/java_test/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/ReflectionForName2.java
new file mode 100755
index 0000000000000000000000000000000000000000..f7942e3ade3dd7cd869d9c5fc22ab4baa2924cd2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/ReflectionForName2.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.File;
+import java.io.IOException;
+class ForName2 {
+    static {
+        File cls2 = new File("/data/local/tmp/ReflectionForName2.txt");
+        try {
+            cls2.createNewFile();
+        } catch (IOException e) {
+            System.err.println(e);
+        }
+    }
+}
+public class ReflectionForName2 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        File cls1 = new File("/data/local/tmp/ReflectionForName2.txt");
+        if (cls1.exists()) {
+            cls1.delete();
+        }
+        Class cls = Class.forName("ForName2", true, ForName2.class.getClassLoader());
+        if (cls1.exists()) {
+            System.out.println(0);
+        }else{
+            System.out.println(2);
+        }
+    }
+}
diff --git a/testsuite/java_test/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/expected.txt b/testsuite/java_test/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/test.cfg b/testsuite/java_test/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4c244676cce45772899772587753ff1982e65e5b
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-0000-rt-Reflection-ReflectionforName2/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName2)
+run(ReflectionForName2)
diff --git a/testsuite/java_test/reflection_test/issue-RT0096-rt-Reflection-ReflectionforName3/ReflectionForName3.java b/testsuite/java_test/reflection_test/issue-RT0096-rt-Reflection-ReflectionforName3/ReflectionForName3.java
new file mode 100755
index 0000000000000000000000000000000000000000..aadd1b433ef5eedd5a3e4504498bb281a92405e0
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0096-rt-Reflection-ReflectionforName3/ReflectionForName3.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.File;
+import java.io.IOException;
+class ForName3 {
+    static {
+        File cls2 = new File("/data/local/tmp/ReflectionForName3.txt");
+        try {
+            cls2.createNewFile();
+        } catch (IOException e) {
+            System.err.println(e);
+        }
+    }
+}
+public class ReflectionForName3 {
+    public static void main(String[] args) throws ClassNotFoundException {
+        File cls1 = new File("/data/local/tmp/ReflectionForName3.txt");
+        if (cls1.exists()) {
+            cls1.delete();
+        }
+        Class cls = Class.forName("ForName3", false, ForName3.class.getClassLoader());
+        if (!cls1.exists()) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/issue-RT0096-rt-Reflection-ReflectionforName3/expected.txt b/testsuite/java_test/reflection_test/issue-RT0096-rt-Reflection-ReflectionforName3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0096-rt-Reflection-ReflectionforName3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/issue-RT0096-rt-Reflection-ReflectionforName3/test.cfg b/testsuite/java_test/reflection_test/issue-RT0096-rt-Reflection-ReflectionforName3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0136d23a392c4878cf3af7d97bfd60f8b1913584
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0096-rt-Reflection-ReflectionforName3/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionForName3)
+run(ReflectionForName3)
diff --git a/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/FieldTest.java b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/FieldTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..fb97105e802d1e1ff4ce942a11c2d531c3f3c995
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/FieldTest.java
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.reflect.Field;
+public class FieldTest {
+    /**
+     * Verify that for the same field, different Field object is return when call following API twice:
+     * - Class.getFields()
+     * - Class.getDeclaredFields()
+     * - Class.getField(String name)
+     * - Class.getDeclareedField(String name)
+     * if any Field failed the check, will print error message including testcase and field name;
+     * after all check is pass, casePassed will be increased;
+    */
+
+    private static void classAllFieldTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getFields()
+        Field[] fields1 = clazz.getFields();
+        Field[] fields2 = clazz.getFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 2. Class.getDeclaredFields()
+            Field f1 = clazz.getField(f.getName());
+            Field f2 = clazz.getField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed");
+            }
+        }
+        // checkpoint 3. Class.getField(String name)
+        fields1 = clazz.getDeclaredFields();
+        fields2 = clazz.getDeclaredFields();
+        checkFields(fields1, fields2);
+        for (Field f : fields1) {
+            // checkpoint 4. Class.getDeclareedField(String name)
+            Field f1 = clazz.getDeclaredField(f.getName());
+            Field f2 = clazz.getDeclaredField(f.getName());
+            if (singleFieldCheck(f1, f2) != 3) {
+                System.out.println(caseName + ": " + f1.getDeclaringClass().toString() + "." + f1.getName() + " failed for declared fields");
+            }
+        }
+        casesPassed++;
+    }
+    private static void checkFields(Field[] fields1, Field[] fields2) {
+        for (Field f1: fields1) {
+            for (Field f2: fields2) {
+                // only when modifers and class and name is same, two Field object is for same field
+                if(f1.toGenericString().equals(f2.toGenericString())) {
+                    if (singleFieldCheck(f1, f2) != 3) {
+                        System.out.println(f1.getName()+" failed in checkFields");
+                    }
+                }
+            }
+        }
+    }
+    private static int singleFieldCheck(Field f1, Field f2) {
+        int passCnt = 0;
+        passCnt += f1 == f2 ? 0 : 1;
+        passCnt += f1.equals(f2) ? 1 : 0;
+        passCnt += f1.hashCode() == f2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    static int casesPassed = 0;
+    public static void main(String [] args) {
+        field01();
+        field02();
+        field03();
+        field04();
+        field05();
+        field06();
+        field07();
+        field08();
+        field09();
+        field10();
+        field11();
+        field12();
+        System.out.println(casesPassed - 12);
+    }
+
+    private static void field01() {
+        try {
+            classAllFieldTest(Class.forName("java.lang.Thread"), "field01");
+        } catch (Exception e) {
+            System.out.println("Case field01 failed with exception" + e);
+        }
+    }
+
+    private static void field02() {
+        try {
+            classAllFieldTest(Class.forName("TestField02"), "field02");
+        } catch (Exception e) {
+            System.out.println("Case field02 failed with exception" + e);
+        }
+    }
+
+    private static void field03() {
+        try {
+            classAllFieldTest(Class.forName("TestField03"), "field03");
+        } catch (Exception e) {
+            System.out.println("Case field03 failed with exception" + e);
+        }
+    }
+
+    private static void field04() {
+        try {
+            classAllFieldTest(Class.forName("TestField04"), "field04");
+        } catch (Exception e) {
+            System.out.println("Case field04 failed with exception" + e);
+        }
+    }
+
+    private static void field05() {
+        try {
+            classAllFieldTest(Class.forName("TestField05"), "field05");
+        } catch (Exception e) {
+            System.out.println("Case field05 failed with exception" + e);
+        }
+    }
+
+    private static void field06() {
+        try {
+            // step 1
+            Class clazz = Class.forName("FieldTest");
+            FieldTest mainClass = new FieldTest();
+            Field field = clazz.getDeclaredField("testField06");
+            classAllFieldTest(field.get(mainClass).getClass(), "field06");
+        } catch (Exception e) {
+            System.out.println("Case field06 failed with exception" + e);
+        }
+    }
+    private Runnable testField06 = new Runnable() {
+        int intAnonymous = 10;
+        public double doubleAnonymous = 1988.416;
+        @Override
+        public void run() {
+            for (int i = 0; i < intAnonymous; i++) {
+                intAnonymous += i;
+            }
+        }
+    };
+
+    private static void field07() {
+        class TestField07 {
+            private final transient int intLocal = 9;
+            public volatile String stringLocal = "a fake behind the fear";
+        }
+        try {
+            classAllFieldTest(Class.forName("FieldTest$1TestField07"), "field07");
+        } catch (Exception e) {
+            System.out.println("Case field07 failed with exception" + e);
+        }
+    }
+
+    private static void field08() {
+        try {
+            classAllFieldTest(Class.forName("FieldTest$TestField08"), "field08");
+        } catch (Exception e) {
+            System.out.println("Case field08 failed with exception" + e);
+        }
+    }
+    class TestField08 {
+        volatile private char charInner = 'l';
+        public final static transient double doubleInner = 0.88;
+    }
+
+    private static void field09() {
+        try {
+            classAllFieldTest(Class.forName("TestField09"), "field09");
+        } catch (Exception e) {
+            System.out.println("Case field09 failed with exception" + e);
+        }
+    }
+
+    private static void field10() {
+        try {
+            classAllFieldTest(Class.forName("TestField10"), "field10");
+        } catch (Exception e) {
+            System.out.println("Case field10 failed with exception" + e);
+        }
+    }
+
+    private static void field11() {
+        try {
+            classAllFieldTest(Class.forName("TestField11"), "field11");
+        } catch (Exception e) {
+            System.out.println("Case field11 failed with exception" + e);
+        }
+    }
+
+    private static void field12() {
+        try {
+            classAllFieldTest(Class.forName("TestField12"), "field12");
+        } catch (Exception e) {
+            System.out.println("Case field12 failed with exception" + e);
+        }
+    }
+}
+class TestField02 {
+    // step1
+    boolean booleanField = true;
+    byte byteField = (byte)2;
+    short shortField = (short)4;
+    int intField = 6;
+    long longField = 8;
+    char charField = 10;
+    float floatField = 0.4f;
+    double doubleField = 0.8;
+    String stringField = "The queerest of the queer";
+    Runnable r = null;
+    boolean[][][][][][][] booleanArray7 = new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    String[][][] stringArray3 = new String[][][] {{{"the strangest of the strange"}}};
+    // step2
+    public int publicInt = 88;
+    protected double protectedDouble = 99;
+    private String privateString = "the coldest of the cool";
+    // step3
+    transient double[][] transientDoubleArray = new double[][] {{1988, 4.16}};
+    final int finalInt = 9876;
+    volatile String volatileString = "the lamest of the lame";
+    static Character staticCharacter = 'd';
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotation = new String[][] {{"the numbest of the dumb"}};
+}
+strictfp class TestField03 {
+    float floatField = 4.16f;
+    public double doubleField = 19.88;
+}
+interface TestField04 {
+    String stringInterface = "i know what's good for you";
+    char[] charInterface = new char[] {'l', 'e', 't'};
+}
+abstract class TestField05 {
+    String[] stringsAbstractArray = {"i hate to see you here", "you choke behind a smile"};
+    Runnable[] runnableAbstractArray = {new Runnable() {
+            @Override
+            public void run() {
+            }
+        }
+    };
+}
+enum TestField09 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnum = (short)6;
+    public final String stringEnum = "Dry Martini";
+}
+class TestField10 {
+    public int int10;
+    protected boolean boolean10;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    private String string10 = "I'm only happy when it rains";
+}
+class TestField11 extends TestField10 implements TestField12 {
+    boolean boolean10 = true;
+    public double double11 = 0.416;
+}
+interface TestField12 {
+    int int10 = 9;
+    boolean boolean10 = false;
+    char[] chars10 = new char[] {'a', 'b', 'c'};
+    String string10 = "I'm only happy when it rains";
+}
diff --git a/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/MethodTest.java b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/MethodTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b32da6f26ea7f240abc83a4bea255dff801a08d5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/MethodTest.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+public class MethodTest {
+    /**
+     * Verify that for the same method, different Method object is return when call following API twice:
+     * - Class.getMethods(),
+     * - Class.getEnclosingMethod(),
+     * - Class.getDeclaredMethods(),
+     * - Class.getMethod(String name, Class<?>... parameterTypes),
+     * - Class.getDeclaredMethod(String name, Class<?>... parameterTypes),
+     * if any Method failed the check, will print error message including testcase and method name;
+     * after all check is pass, casePassed will be increased;
+    */
+
+    private static void classAllMethodTest(Class clazz, String caseName) throws Exception {
+        // checkpoint 1. Class.getMethods()
+        Method[] methods1 = clazz.getMethods();
+        Method[] methods2 = clazz.getMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 2. Class.getMethod(String name)
+            Method m1 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed");
+            }
+        }
+        // checkpoint 3. Class.getDeclaredMethods()
+        methods1 = clazz.getDeclaredMethods();
+        methods2 = clazz.getDeclaredMethods();
+        checkMethods(methods1, methods2);
+        for (Method m : methods1) {
+            // checkpoint 4. Class.getDeclaredMethod(String name)
+            Method m1 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            Method m2 = clazz.getDeclaredMethod(m.getName(), m.getParameterTypes());
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for declared method");
+            }
+        }
+        // checkpoint 5. Class.getEnclosingMethod()
+        if (clazz.getEnclosingMethod() != null) {
+            Method m1 = clazz.getEnclosingMethod();
+            Method m2 = clazz.getEnclosingMethod();
+            if (singleMethodCheck(m1, m2) != 3) {
+                System.out.println(caseName + ": " + m1.toGenericString() + " failed for Enclosing method");
+            }
+        }
+        casesPassed++;
+    }
+    private static void checkMethods(Method[] methods1, Method[] methods2) {
+        for (Method m1: methods1) {
+            for (Method m2: methods2) {
+                // only when modifers and class and name is same, two Method object is for same method
+                if(m1.toString().equals(m2.toString())) {
+                    if (singleMethodCheck(m1, m2) != 3) {
+                        System.out.println(m1.getName()+" failed in checkMethods");
+                    }
+                }
+            }
+        }
+    }
+    private static int singleMethodCheck(Method m1, Method m2) {
+        int passCnt = 0;
+        passCnt += m1 == m2 ? 0 : 1;
+        passCnt += m1.equals(m2) ? 1 : 0;
+        passCnt += m1.hashCode() == m2.hashCode() ? 1 : 0;
+        return passCnt;
+    }
+    static int casesPassed = 0;
+    public static void main(String [] args) {
+        method01();
+        method02();
+        method03();
+        method04();
+        method05();
+        method06();
+        method07();
+        method08();
+        method09();
+        method10();
+        method11();
+        System.out.println(casesPassed - 11);
+    }
+
+    private static void method01() {
+        try {
+            classAllMethodTest(Class.forName("java.lang.Thread"), "method01");
+        } catch (Exception e) {
+            System.out.println("Case method01 failed with exception" + e);
+        }
+    }
+
+    private static void method02() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod02"), "method02");
+        } catch (Exception e) {
+            System.out.println("Case method02 failed with exception" + e);
+        }
+    }
+
+    private static void method03() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod03"), "method03");
+        } catch (Exception e) {
+            System.out.println("Case method03 failed with exception" + e);
+        }
+    }
+
+    private static void method04() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod04"), "method04");
+        } catch (Exception e) {
+            System.out.println("Case method04 failed with exception" + e);
+        }
+    }
+
+    private static void method05() {
+        try {
+            // step 1
+            Class clazz = Class.forName("MethodTest");
+            MethodTest mainClass = new MethodTest();
+            Field method = clazz.getDeclaredField("testMethod05");
+            classAllMethodTest(method.get(mainClass).getClass(), "method05");
+        } catch (Exception e) {
+            System.out.println("Case method05 failed with exception" + e);
+        }
+    }
+    private Runnable testMethod05 = new Runnable() {
+        private final synchronized int intRunnable() {
+            return 1;
+        }
+        @Override
+        public void run() {
+            for (int i = 0; i < 10; i++) {
+            }
+        }
+    };
+
+    private static void method06() {
+        class TestMethod06 {
+            private final int intLocalMethod() {
+                return 9;
+            }
+            public synchronized String stringLocal() {
+                return "a fake behind the fear";
+            }
+        }
+        try {
+            classAllMethodTest(Class.forName("MethodTest$1TestMethod06"), "method06");
+        } catch (Exception e) {
+            System.out.println("Case method06 failed with exception" + e);
+        }
+    }
+
+    private static void method07() {
+        try {
+            classAllMethodTest(Class.forName("MethodTest$TestMethod07"), "method07");
+        } catch (Exception e) {
+            System.out.println("Case method07 failed with exception" + e);
+        }
+    }
+    class TestMethod07 {
+        private char charInnerMethod(int a, double... b) {
+            return 'l';
+        }
+        final public double doubleInnerMethod() {
+            return 1988.0416;
+        }
+    }
+
+    private static void method08() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod08"), "method08");
+        } catch (Exception e) {
+            System.out.println("Case method08 failed with exception" + e);
+        }
+    }
+
+    private static void method09() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod09"), "method09");
+        } catch (Exception e) {
+            System.out.println("Case method09 failed with exception" + e);
+        }
+    }
+
+    private static void method10() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod10"), "method10");
+        } catch (Exception e) {
+            System.out.println("Case method10 failed with exception" + e);
+        }
+    }
+
+    private static void method11() {
+        try {
+            classAllMethodTest(Class.forName("TestMethod11"), "method11");
+        } catch (Exception e) {
+            System.out.println("Case method11 failed with exception" + e);
+        }
+    }
+}
+class TestMethod02 {
+    // step1
+    void voidMethod() {}
+    boolean booleanMethod() {
+        return true;
+    }
+    byte byteMethod() {
+        return (byte)1;
+    }
+    short shortMethod() {
+        return (short)2;
+    }
+    int intMethod() {
+        return 3;
+    }
+    long longMethod() {
+        return 4l;
+    }
+    char charMethod() {
+        return 'a';
+    }
+    float floatMethod() {
+        return 0.9f;
+    }
+    double doubleMethod() {
+        return 0.416;
+    }
+    String stringMethod() {
+        return "The queerest of the queer";
+    }
+    Runnable[] rArrayMethod() {
+        return null;
+    }
+    boolean[][][][][][][] booleanArray7Method() {
+        return new boolean[][][][][][][] {{{{{{{true, false}}}}}}};
+    }
+    String[][][] stringArray3Method() {
+        return new String[][][] {{{"the strangest of the strange"}}};
+    }
+    int parameterMethod(boolean a, byte b, short c, int d, long e, char f, float g, double h,
+                        boolean[] aa, byte[] bb, short[] cc, int[] dd, long[] ee, char[] ff, float[] gg, double[] hh,
+                        String i, String[][][] iii, Runnable j, Byte k, Double l, Thread.State m, int... o) {
+        return 1;
+    }
+    // step2
+    public int publicIntMethod(boolean a) {
+        return 88;
+    }
+    protected double protectedDoubleMethod(byte a) {
+        return 99;
+    }
+    private String privateStringMethod(String a) {
+        return "the coldest of the cool";
+    }
+    // step3
+    strictfp double[][] transientDoubleArrayMethod(float[][] a) {
+        return new double[][] {{1988, 4.16}};
+    }
+    final int finalIntMethod() {
+        return 9876;
+    }
+    synchronized String volatileStringMethod() {
+        return "the lamest of the lame";
+    }
+    static Character staticCharacterMethod(Thread.State a) {
+        return 'd';
+    }
+    //step 4
+    @Deprecated
+    String[][] stringsAnnotationMethod() {
+        return new String[][] {{"the numbest of the dumb"}};
+    }
+}
+interface TestMethod03 {
+    String stringInterfaceMethod(int[] a);
+    char[][][] charArrayInterfaceMethod(double... a);
+}
+abstract class TestMethod04 {
+    public static final synchronized String[] stringsAbstractArrayMethod() {
+        return new String[] {"i hate to see you here", "you choke behind a smile"};
+    }
+    abstract Runnable runnableAbstractMethod();
+}
+enum TestMethod08 {
+    WHISKY, VODKA, BRANDY, GIN, RUM, TEQUILA;
+    private static short shortEnumMethod() {
+        return (short)6;
+    }
+    public final String stringEnumMethod(int... a) {
+        return "Dry Martini";
+    }
+}
+class TestMethod09 {
+    public int int09Method() {
+        return 1;
+    }
+    protected boolean boolean09Method() {
+        return false;
+    }
+    char[] chars09Method() {
+        return new char[] {'a', 'b', 'c'};
+    }
+    private String string09Method() {
+        return "I'm only happy when it rains";
+    }
+}
+class TestMethod10 extends TestMethod09 implements TestMethod11 {
+    public boolean boolean09Method() {
+        return true;
+    }
+    public double double10Method() {
+        return 0.416;
+    }
+    public char[] chars09Method() {
+        return new char[] {'a'};
+    }
+    public String string09Method() {
+        return "SHALALALA";
+    }
+}
+interface TestMethod11 {
+    int int09Method();
+    boolean boolean09Method();
+    char[] chars09Method();
+    String string09Method();
+}
diff --git a/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/check_s.py b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/check_s.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca8e2c6d0d538f83b4f76441bf85e0e68afa6348
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/check_s.py
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+import sys
+
+def check_vtableimpl_s(filename):
+    f = open(filename, 'r')
+    result = list()
+    check_cnt = 0
+    pass_cnt = 0
+    fail_cnt = 0
+    for line in f.readlines():
+        line = line.strip()
+        if line.startswith(".type"):
+            result = list()
+        result.append(line)
+        if line.startswith(".size"):
+            if result[0].find("methods_info") != -1:
+                check_cnt += 1
+                for i in result:
+                    if i.find(".section") != -1:
+                        if i == '.section .metadata.method,"aw",%progbits':
+                            pass_cnt += 1
+                        else:
+                            fail_cnt += 1
+                    elif i.find(".data") != -1:
+                        fail_cnt += 1
+            elif result[0].find("fields_info") != -1:
+                check_cnt += 1
+                for i in result:
+                    if i.find(".section") != -1:
+                        if i == '.section .rometadata.field,"a",%progbits':
+                            pass_cnt += 1
+                        else:
+                            fail_cnt += 1
+                    elif i.find(".data") != -1:
+                        fail_cnt += 1
+            elif result[0].find("fieldOffsetData") != -1:
+                check_cnt += 1
+                for i in result:
+                    if i.find(".section") != -1:
+                        fail_cnt += 1
+                    elif i.find(".data") != -1:
+                        pass_cnt += 1
+            else:
+                continue
+    if check_cnt == pass_cnt and fail_cnt == 0:
+        print(0)
+    else:
+        print(2)
+
+
+if __name__ == '__main__':
+    check_vtableimpl_s(sys.argv[1])
+
diff --git a/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/expected.txt b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aa47d0d46d47a06090f436b0b851b76bb6f3b6e2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/expected.txt
@@ -0,0 +1,2 @@
+0
+0
diff --git a/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/test.cfg b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e960d65827f5b5fa484e86965d85652707a780c2
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0208-rt-reflection-MetadataCheck/test.cfg
@@ -0,0 +1,5 @@
+compile(FieldTest)
+compile(MethodTest)
+python3 check_s.py MethodTest.VtableImpl.s > output.log 2>&1
+python3 check_s.py FieldTest.VtableImpl.s >> output.log 2>&1
+diff output.log expected.txt
diff --git a/testsuite/java_test/reflection_test/issue-RT0209-rt-reflection-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java b/testsuite/java_test/reflection_test/issue-RT0209-rt-reflection-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java
new file mode 100755
index 0000000000000000000000000000000000000000..a325e0ad87742f7236086c6e10d4f7027b99b395
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0209-rt-reflection-ReflectiongetAnnotation1/ReflectionGetAnnotation1.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Retention(RetentionPolicy.RUNTIME)
+@interface Zzz1 {
+}
+@Zzz1
+class GetAnnotation1_a {
+}
+class GetAnnotation1_b {
+}
+public class ReflectionGetAnnotation1 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("GetAnnotation1_a");
+            Class clazz2 = Class.forName("GetAnnotation1_b");
+            if (clazz1.getAnnotation(Zzz1.class) != null && clazz2.getAnnotation(Zzz1.class) == null) {
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/issue-RT0209-rt-reflection-ReflectiongetAnnotation1/expected.txt b/testsuite/java_test/reflection_test/issue-RT0209-rt-reflection-ReflectiongetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0209-rt-reflection-ReflectiongetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/issue-RT0209-rt-reflection-ReflectiongetAnnotation1/test.cfg b/testsuite/java_test/reflection_test/issue-RT0209-rt-reflection-ReflectiongetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3ea370ea1cc66f565a7989953010f2b77f00112f
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0209-rt-reflection-ReflectiongetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectionGetAnnotation1)
+run(ReflectionGetAnnotation1)
diff --git a/testsuite/java_test/reflection_test/issue-RT0210-rt-reflection-ReflectiongetAnnotation1/HelloWorld.java b/testsuite/java_test/reflection_test/issue-RT0210-rt-reflection-ReflectiongetAnnotation1/HelloWorld.java
new file mode 100644
index 0000000000000000000000000000000000000000..5403827efedd6f43ecdb6fc11842b74642ede2c9
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0210-rt-reflection-ReflectiongetAnnotation1/HelloWorld.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface HarmonyStaticStringVis {
+
+}
+
+@HarmonyStaticStringVis
+class HelloWorldAnnotation {
+    @HarmonyStaticStringVis
+    private int numVis;
+
+    @HarmonyStaticStringVis
+    public void funcVis(@HarmonyStaticStringVis String str, int num, @HarmonyStaticStringVis String str2) {
+        for (int i = 0; i < num; ++i) {
+            System.out.println(str);
+            System.out.println(str2);
+        }
+    }
+}
+
+public class HelloWorld {
+    public static void main(String[] args) {
+        funcVisTest();
+    }
+
+    public static void funcVisTest() {
+        try {
+            Class klass = Class.forName("HelloWorldAnnotation");
+            Method[] methods = klass.getMethods();
+            Method funcVis = null;
+            for (int i = 0; i < methods.length; i++) {
+                if (methods[i].getName().equals("funcVis")) {
+                    funcVis = methods[i];
+                    break;
+                }
+            }
+            Parameter[] parameters = funcVis.getParameters();
+            Parameter p0 = parameters[0];
+            Parameter p1 = parameters[1];
+            Parameter p2 = parameters[2];
+            if ((p0.getAnnotation(HarmonyStaticStringVis.class) != null) &&
+                (p1.getAnnotation(HarmonyStaticStringVis.class) == null) &&
+                (p2.getAnnotation(HarmonyStaticStringVis.class) != null)) {
+              System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
diff --git a/testsuite/java_test/reflection_test/issue-RT0210-rt-reflection-ReflectiongetAnnotation1/expected.txt b/testsuite/java_test/reflection_test/issue-RT0210-rt-reflection-ReflectiongetAnnotation1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0210-rt-reflection-ReflectiongetAnnotation1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/issue-RT0210-rt-reflection-ReflectiongetAnnotation1/test.cfg b/testsuite/java_test/reflection_test/issue-RT0210-rt-reflection-ReflectiongetAnnotation1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebca2916da5dc98d287669239d3197c93807d340
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0210-rt-reflection-ReflectiongetAnnotation1/test.cfg
@@ -0,0 +1,2 @@
+compile(HelloWorld)
+run(HelloWorld)
diff --git a/testsuite/java_test/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/ClassInitFieldSetCharInterface.java b/testsuite/java_test/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/ClassInitFieldSetCharInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..f569c71353c44a493a720a22703160511bc660f3
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/ClassInitFieldSetCharInterface.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetCharInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiChar");
+            if (result.toString().compareTo("") == 0) {
+                f.setChar(null, (char)46);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetCharInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetCharInterface.result.append("One").toString();
+    char hiChar = (char)45;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetCharInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetCharInterface.result.append("Annotation").toString();
+}
\ No newline at end of file
diff --git a/testsuite/java_test/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/expected.txt b/testsuite/java_test/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/test.cfg b/testsuite/java_test/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b14f56245e4a4f2fdb3965481961aa0caca6d1a5
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetCharInterface)
+run(ClassInitFieldSetCharInterface)
diff --git a/testsuite/java_test/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/ClassInitFieldSetDoubleInterface.java b/testsuite/java_test/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/ClassInitFieldSetDoubleInterface.java
new file mode 100755
index 0000000000000000000000000000000000000000..8393ae0c666e7455f424cef1e1b589ca8318051d
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/ClassInitFieldSetDoubleInterface.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ClassInitFieldSetDoubleInterface {
+    static StringBuffer result = new StringBuffer("");
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("OneInterface", false, OneInterface.class.getClassLoader());
+            Field f = clazz.getField("hiDouble");
+            if (result.toString().compareTo("") == 0) {
+                f.setDouble(null, 0.265874);
+            }
+        }catch (IllegalAccessException e){
+            result.append("IllegalAccessException");
+        }catch (Exception e) {
+            System.out.println(e);
+        }
+        if (result.toString().compareTo("OneIllegalAccessException") == 0) {
+            System.out.println(0);
+            return;
+        } else {
+            System.out.println(2);
+            return;
+        }
+    }
+}
+interface SuperInterface{
+    String aSuper = ClassInitFieldSetDoubleInterface.result.append("Super").toString();
+}
+@A
+interface OneInterface extends SuperInterface{
+    String aOne = ClassInitFieldSetDoubleInterface.result.append("One").toString();
+    double hiDouble = 0.1532;
+}
+interface TwoInterface extends OneInterface{
+    String aTwo = ClassInitFieldSetDoubleInterface.result.append("Two").toString();
+}
+@interface A {
+    String aA = ClassInitFieldSetDoubleInterface.result.append("Annotation").toString();
+}
diff --git a/testsuite/java_test/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/expected.txt b/testsuite/java_test/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/test.cfg b/testsuite/java_test/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fff29896c515dfc547414e070f05871dad011685
--- /dev/null
+++ b/testsuite/java_test/reflection_test/issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface/test.cfg
@@ -0,0 +1,2 @@
+compile(ClassInitFieldSetDoubleInterface)
+run(ClassInitFieldSetDoubleInterface)
diff --git a/testsuite/java_test/stmtpre_test/RT0001-rt-String-StmtTest01/StmtTest01.java b/testsuite/java_test/stmtpre_test/RT0001-rt-String-StmtTest01/StmtTest01.java
new file mode 100755
index 0000000000000000000000000000000000000000..b2117b5a47dc6e217c8729e50aa8c02a4d7e1322
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0001-rt-String-StmtTest01/StmtTest01.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest01 {
+    public static void main(String[] args) {
+        if (test()) {
+            System.out.println("ExpectResult");  // 1
+        } else {
+            String string = "ExpectResult" + "ExpectResult"; // 2
+            System.out.println(string);
+        }
+    }
+    // 基础的测试
+    private static boolean test() {
+        String string = "A"; // 3
+        for (int ii = 0; ii < 100; ii++) {
+            string += "A";
+        }
+        return string.length() == 101;  //true;
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0001-rt-String-StmtTest01/expected.txt b/testsuite/java_test/stmtpre_test/RT0001-rt-String-StmtTest01/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0001-rt-String-StmtTest01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0001-rt-String-StmtTest01/test.cfg b/testsuite/java_test/stmtpre_test/RT0001-rt-String-StmtTest01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..facf2df7bbc6ee2f98bd312a433f1e072db38ff0
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0001-rt-String-StmtTest01/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest01,EXPECTNUM=2)
+run(StmtTest01)
diff --git a/testsuite/java_test/stmtpre_test/RT0002-rt-String-StmtTest02/StmtTest02.java b/testsuite/java_test/stmtpre_test/RT0002-rt-String-StmtTest02/StmtTest02.java
new file mode 100755
index 0000000000000000000000000000000000000000..92e6235baaa7cf239e5eae6c58ffd743ba6939c0
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0002-rt-String-StmtTest02/StmtTest02.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest02 {
+    public static void main(String[] args) {
+        if (test1()) {
+            System.out.println("ExpectResult"); // 1
+        } else {
+            System.out.println("ExpectResult " + "ExpectResult"); // 2
+        }
+    }
+    // 基础的测试
+    private static boolean test() {
+        String string = "A"; // 3
+        for (int ii = 0; ii < 100; ii++) {
+            string += "A";
+        }
+        return string.length() == 101;  //true;
+    }
+    // 有函数调用,确认
+    private static boolean test1() {
+        String str1 = "A" + "A"; // 4
+        String str2 = "A" + "A";
+        if (test() == true) {
+            str2 = str1;
+        }
+        return str1 == str1; //true
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0002-rt-String-StmtTest02/expected.txt b/testsuite/java_test/stmtpre_test/RT0002-rt-String-StmtTest02/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0002-rt-String-StmtTest02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0002-rt-String-StmtTest02/test.cfg b/testsuite/java_test/stmtpre_test/RT0002-rt-String-StmtTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..79b55abcd708ae5a8bb87f54d3021609be299fb9
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0002-rt-String-StmtTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest02,EXPECTNUM=2)
+run(StmtTest02)
diff --git a/testsuite/java_test/stmtpre_test/RT0003-rt-String-StmtTest03/StmtTest03.java b/testsuite/java_test/stmtpre_test/RT0003-rt-String-StmtTest03/StmtTest03.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f2a2b274386edc77f2de3b19a43b4b0d7f4f2a1
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0003-rt-String-StmtTest03/StmtTest03.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+interface Interface {
+    boolean test();
+}
+public class StmtTest03 implements Interface {
+    public static void main(String[] args) {
+        if (new StmtTest03().test()) {
+            System.out.println("ExpectResult");  // 1
+        } else {
+            System.out.println("ExpectResult " + "ExpectResult"); // 2
+        }
+    }
+    // 实现接口
+    public boolean test() {
+        String str1 = "A" + "A"; // 3
+        String str2 = "A" + "A";
+        return str1 == str2;
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0003-rt-String-StmtTest03/expected.txt b/testsuite/java_test/stmtpre_test/RT0003-rt-String-StmtTest03/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0003-rt-String-StmtTest03/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0003-rt-String-StmtTest03/test.cfg b/testsuite/java_test/stmtpre_test/RT0003-rt-String-StmtTest03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..478bffad86534e2a0c303f122e9aee42eae1a997
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0003-rt-String-StmtTest03/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest03,EXPECTNUM=2)
+run(StmtTest03)
diff --git a/testsuite/java_test/stmtpre_test/RT0004-rt-String-StmtTest04/StmtTest04.java b/testsuite/java_test/stmtpre_test/RT0004-rt-String-StmtTest04/StmtTest04.java
new file mode 100755
index 0000000000000000000000000000000000000000..2d8fe7bf1db15d8c6da7ab25825b1d2766e2df3c
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0004-rt-String-StmtTest04/StmtTest04.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Father {
+    public String name;
+    public boolean test1() {
+        String str1 = "A" + "A"; // 1
+        String str2 = "A" + "A";
+        return str1 == str2; // false;
+    }
+}
+public class StmtTest04 extends Father {
+    public String name;
+    public static void main(String[] args) {
+        Father father = new StmtTest04();
+        father.name = "ExpectResult"; // 2
+        if (father.test1()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ExpectResult" + " " + "ExpectResult"); // 4
+        }
+    }
+    // 集成父类
+    @Override
+    public boolean test1() {
+        String str1 = "A" + "A"; // 3
+        String str2 = "A" + "A";
+        return str1.equals(str2); // true;
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0004-rt-String-StmtTest04/expected.txt b/testsuite/java_test/stmtpre_test/RT0004-rt-String-StmtTest04/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0004-rt-String-StmtTest04/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0004-rt-String-StmtTest04/test.cfg b/testsuite/java_test/stmtpre_test/RT0004-rt-String-StmtTest04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b2dfe554c045066878122353db626251bd4e236b
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0004-rt-String-StmtTest04/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest04,EXPECTNUM=2)
+run(StmtTest04)
diff --git a/testsuite/java_test/stmtpre_test/RT0005-rt-String-StmtTest05/StmtTest05.java b/testsuite/java_test/stmtpre_test/RT0005-rt-String-StmtTest05/StmtTest05.java
new file mode 100755
index 0000000000000000000000000000000000000000..ea6fe2e0c6cc70eb8d908ec2171d4ee6ef7888b0
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0005-rt-String-StmtTest05/StmtTest05.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest05 {
+    public static void main(String[] args) {
+        String test = "TestStringForStmt"; // 1
+        switch (test) {
+            case "TestStringForStmt33": // 6
+                test = "TestStringForStmt01"; // 2
+                break;
+            case "TestStringForStmt55":  // 3
+                test += "TestStringForStmt01"; // 4
+                break;
+            default:
+                test = "TestStringForStmt";
+                break;
+        }
+        String output = "ExpectResult"; // 5
+        if (test == "TestStringForStmt") {
+            System.out.println(output);
+        } else {
+            System.out.print("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0005-rt-String-StmtTest05/expected.txt b/testsuite/java_test/stmtpre_test/RT0005-rt-String-StmtTest05/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0005-rt-String-StmtTest05/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0005-rt-String-StmtTest05/test.cfg b/testsuite/java_test/stmtpre_test/RT0005-rt-String-StmtTest05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..67a7c3d8e6063c90cfa179429d390e21cb7a9013
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0005-rt-String-StmtTest05/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest05,EXPECTNUM=6)
+run(StmtTest05)
diff --git a/testsuite/java_test/stmtpre_test/RT0006-rt-String-StmtTest06/StmtTest06.java b/testsuite/java_test/stmtpre_test/RT0006-rt-String-StmtTest06/StmtTest06.java
new file mode 100755
index 0000000000000000000000000000000000000000..c83db23a9900546cec0ecd14faf707b0a2191416
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0006-rt-String-StmtTest06/StmtTest06.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest06 {
+    public static void main(String[] argv) {
+        int result = 2;
+        boolean check;
+        String str = "123#";  // 1
+        try {
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            str = "123#456";  // 2
+            result--;
+        } catch (NullPointerException e) {
+            str = "123456";  // 3
+            result = 2;
+        } catch (OutOfMemoryError e) {
+            str += "123#456";  // 被外提
+            result = 2;
+        } finally {
+            check = str == "123#456";
+            result--;
+        }
+        if (check == true && result == 0) {
+            System.out.println("123#");
+        }
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0006-rt-String-StmtTest06/expected.txt b/testsuite/java_test/stmtpre_test/RT0006-rt-String-StmtTest06/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c975d3f1f41dd28ef5ef470f83f6dd7f073bbab2
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0006-rt-String-StmtTest06/expected.txt
@@ -0,0 +1 @@
+123#
diff --git a/testsuite/java_test/stmtpre_test/RT0006-rt-String-StmtTest06/test.cfg b/testsuite/java_test/stmtpre_test/RT0006-rt-String-StmtTest06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..67ab8424f33a1d3d2135a76ec82e6be977188d51
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0006-rt-String-StmtTest06/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest06,EXPECTNUM=3)
+run(StmtTest06)
diff --git a/testsuite/java_test/stmtpre_test/RT0007-rt-String-StmtTest07/StmtTest07.java b/testsuite/java_test/stmtpre_test/RT0007-rt-String-StmtTest07/StmtTest07.java
new file mode 100755
index 0000000000000000000000000000000000000000..50687107c4665e4eb37341ad27c91c4a17a373be
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0007-rt-String-StmtTest07/StmtTest07.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest07 {
+    public static void main(String[] args) {
+        if (test()) {
+            System.out.println("ExpectResult");  // 1
+        } else {
+            String string = "ExpectResult" + "ExpectResult"; // 2
+            System.out.println(string);
+        }
+    }
+    // 基础的测试for循环嵌套
+    private static boolean test() {
+        String string = "AA"; // 3
+        for (int ii = 0; ii < 10; ii++) {
+            string = "AA";
+            for (int jj = 0; jj < 10; jj++) {
+                for (int kk = 0; kk < 2; kk++) {
+                    string += "AA";
+                }
+            }
+        }
+        try {
+            string = "AA";
+            for (int jj = 0; jj < 10; jj++) {
+                for (int ii = 0; ii < getInt(); ii++) {
+                    string += "123";  // 4
+                }
+            }
+        } catch (ArithmeticException a) {
+            System.out.println(string);
+        }
+        return string.length() == 2;  //true;
+    }
+    private static int getInt() {
+        return 1 / 0;
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0007-rt-String-StmtTest07/expected.txt b/testsuite/java_test/stmtpre_test/RT0007-rt-String-StmtTest07/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c0bf27b29f1da971e6059be7ee14c0e3eccece57
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0007-rt-String-StmtTest07/expected.txt
@@ -0,0 +1,2 @@
+AA
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0007-rt-String-StmtTest07/test.cfg b/testsuite/java_test/stmtpre_test/RT0007-rt-String-StmtTest07/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..3fb8c32ca6acd9160c4d1ebb7026fb78d4d4d4ba
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0007-rt-String-StmtTest07/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest07,EXPECTNUM=3)
+run(StmtTest07)
diff --git a/testsuite/java_test/stmtpre_test/RT0008-rt-String-StmtTest08/StmtTest08.java b/testsuite/java_test/stmtpre_test/RT0008-rt-String-StmtTest08/StmtTest08.java
new file mode 100755
index 0000000000000000000000000000000000000000..723e73769e5c28a2abd13397b3bf613f0f92833d
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0008-rt-String-StmtTest08/StmtTest08.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest08 {
+    public static void main(String[] args) {
+        if (test1() == false) {
+            System.out.println("ExpectResult"); // 1
+        } else {
+            System.out.println("ExpectResult " + "ExpectResult"); // 2
+        }
+    }
+    // 基础的测试
+    private static boolean test() {
+        String string = "A"; // 3
+        for (int ii = 0; ii < 100; ii++) {
+            string += "A";
+        }
+        return string.length() == 101;  //true;
+    }
+    // 有函数调用,确认
+    private static boolean test1() {
+        String str1 = "AA"; // 4
+        String str2;
+        if (test() == true) {
+            str2 = str1;
+            if (str2 == "AA") {
+                str2 = str2.substring(0, 1);
+            } else {
+                str1 = "AAA"; // 5
+            }
+        } else {
+            str2 = "A"; // 6
+            if (str2.equals("AA")) {
+                str2 = str2.substring(0, 1);
+            } else {
+                str1 = "AAA"; // 7
+            }
+        }
+        return str2 == str1; //true
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0008-rt-String-StmtTest08/expected.txt b/testsuite/java_test/stmtpre_test/RT0008-rt-String-StmtTest08/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0008-rt-String-StmtTest08/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0008-rt-String-StmtTest08/test.cfg b/testsuite/java_test/stmtpre_test/RT0008-rt-String-StmtTest08/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1376072702a37945eec65fdf8cafd9121617ccfc
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0008-rt-String-StmtTest08/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest08,EXPECTNUM=4)
+run(StmtTest08)
diff --git a/testsuite/java_test/stmtpre_test/RT0009-rt-String-StmtTest09/StmtTest09.java b/testsuite/java_test/stmtpre_test/RT0009-rt-String-StmtTest09/StmtTest09.java
new file mode 100755
index 0000000000000000000000000000000000000000..922ac86118646d971d67ef6f1bcc8e1b564b40b2
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0009-rt-String-StmtTest09/StmtTest09.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest09 {
+    public static void main(String[] args) {
+        String test = "TestStringForStmt"; // 1
+        switch (test) {
+            case "TestStringForStmt33": // 2
+                test = "TestStringForStmt01"; // 3
+                break;
+            case "TestStringForStmt55":  // 4
+                test += "TestStringForStmt01"; // 其他优化导致"TestStringForStmt01"的地址调用外提到22行，所以与33行合用。
+                break;
+            default:
+                switch (test) {
+                    case "TestStringForStmt34": // 5
+                        test = "TestStringForStmt01"; // 其他优化导致"TestStringForStmt01"的地址调用外提到22行，所以与33行合用
+                        break;
+                    case "TestStringForStmt35":  // 6
+                        test += "TestStringForStmt01"; // 7
+                        break;
+                    default:
+                        test = "TestStringForStmt";
+                        break;
+                }
+        }
+        String output = "ExpectResult"; // 8、
+        if (test == "TestStringForStmt") {
+            System.out.println(output);
+        } else {
+            System.out.print("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0009-rt-String-StmtTest09/expected.txt b/testsuite/java_test/stmtpre_test/RT0009-rt-String-StmtTest09/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0009-rt-String-StmtTest09/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0009-rt-String-StmtTest09/test.cfg b/testsuite/java_test/stmtpre_test/RT0009-rt-String-StmtTest09/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..10850bb44fb6a70e86aa121ca908b22e28d71073
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0009-rt-String-StmtTest09/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest09,EXPECTNUM=8)
+run(StmtTest09)
diff --git a/testsuite/java_test/stmtpre_test/RT0010-rt-String-StmtTest10/StmtTest10.java b/testsuite/java_test/stmtpre_test/RT0010-rt-String-StmtTest10/StmtTest10.java
new file mode 100755
index 0000000000000000000000000000000000000000..3d0d876179706af3dc08c2cd8c425e2a8c3b191d
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0010-rt-String-StmtTest10/StmtTest10.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest10 {
+    public static void main(String[] argv) {
+        int result = 2;
+        boolean check;
+        String str = "123#";  // 1
+        try {
+            str = "123456"; // 2
+            try {
+                Integer.parseInt(str);
+            } catch (NumberFormatException e) {
+                str = "123#456";  // 3
+                result--;
+            } catch (NullPointerException e) {
+                str = "123456#"; // 4
+                result = 2;
+            } catch (OutOfMemoryError e) {
+                str += "123#456";  // 与32行被其他优化了
+                result = 2;
+            } finally {
+                str = "123#456";
+            }
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            str = "123#456";
+            result--;
+        } catch (NullPointerException e) {
+            str = "123456";
+            result = 2;
+        } catch (OutOfMemoryError e) {
+            str += "123#456";
+            result = 2;
+        } finally {
+            check = str == "123#456";
+            result--;
+        }
+        if (check == true && result == 0) {
+            System.out.println("123#");
+        }
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0010-rt-String-StmtTest10/expected.txt b/testsuite/java_test/stmtpre_test/RT0010-rt-String-StmtTest10/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c975d3f1f41dd28ef5ef470f83f6dd7f073bbab2
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0010-rt-String-StmtTest10/expected.txt
@@ -0,0 +1 @@
+123#
diff --git a/testsuite/java_test/stmtpre_test/RT0010-rt-String-StmtTest10/test.cfg b/testsuite/java_test/stmtpre_test/RT0010-rt-String-StmtTest10/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d1f9751bdf7bbbb14d40104ba940873e51fd8c90
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0010-rt-String-StmtTest10/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest10,EXPECTNUM=4)
+run(StmtTest10)
diff --git a/testsuite/java_test/stmtpre_test/RT0011-rt-String-StmtTest11/StmtTest11.java b/testsuite/java_test/stmtpre_test/RT0011-rt-String-StmtTest11/StmtTest11.java
new file mode 100755
index 0000000000000000000000000000000000000000..fd27c0b05081bce5feb46c402ee1a16c7012e35a
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0011-rt-String-StmtTest11/StmtTest11.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest11 {
+    public static void main(String[] args) {
+        if (test()) {
+            System.out.println("ExpectResult");  // 1
+        } else {
+            String string = "ExpectResultExpectResult"; // 2
+            System.out.println(string);
+        }
+    }
+    // 基础的测试for循环嵌套
+    private static boolean test() {
+        String string = "AA"; // 3
+        try {
+            string = "AB"; // 4
+            if (string.length() == 2) {
+                for (int jj = 0; jj < 10; jj++) {
+                    for (int ii = 0; ii < getInt(); ii++) {
+                        string += "123";  // 5,被外提
+                    }
+                }
+            } else {
+                switch (string) {
+                    case "A": // 6
+                        string = "123"; //被外提
+                        break;
+                    case "AA":
+                        string = "A";
+                        break;
+                    default:
+                        break;
+                }
+            }
+        } catch (ArithmeticException a) {
+            System.out.println(string);
+        }
+        return string.length() == 2;  //true;
+    }
+    private static int getInt() {
+        return 1 / 0;
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0011-rt-String-StmtTest11/expected.txt b/testsuite/java_test/stmtpre_test/RT0011-rt-String-StmtTest11/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..17a21b86e2ac532f92e106ab41303470a222db92
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0011-rt-String-StmtTest11/expected.txt
@@ -0,0 +1,2 @@
+AB
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0011-rt-String-StmtTest11/test.cfg b/testsuite/java_test/stmtpre_test/RT0011-rt-String-StmtTest11/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..52ef9056302a6fe9418c69004918b530a9dd23f0
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0011-rt-String-StmtTest11/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest11,EXPECTNUM=3)
+run(StmtTest11)
diff --git a/testsuite/java_test/stmtpre_test/RT0012-rt-String-StmtTest12/StmtTest12.java b/testsuite/java_test/stmtpre_test/RT0012-rt-String-StmtTest12/StmtTest12.java
new file mode 100755
index 0000000000000000000000000000000000000000..5645dc8d6b1ad6f78d253bf8379769af256e858b
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0012-rt-String-StmtTest12/StmtTest12.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.annotation.*;
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@interface Zzz1 {
+    int i() default 0;
+    String t() default " ";
+}
+@Zzz1(i = 333, t = "getAnnotation")
+class GetAnnotation1_a {
+}
+class GetAnnotation1_b {
+}
+public class StmtTest12 {
+    public static void main(String[] args) {
+        try {
+            Class clazz1 = Class.forName("StmtTest12"); // 3
+            Class clazz2 = Class.forName("StmtTest12");
+            for (int ii = 0; ii < 100; ii++) {
+                clazz1 = Class.forName("GetAnnotation1_a"); // 4
+                clazz2 = Class.forName("GetAnnotation1_b"); // 5
+            }
+            if (clazz1.getAnnotation(Zzz1.class).toString().indexOf("t=getAnnotation") != -1 // 1
+                    && clazz1.getAnnotation(Zzz1.class).toString().indexOf("i=333") != -1  // 2
+                    && clazz2.getAnnotation(Zzz1.class) == null) { // 7
+                System.out.println(0);
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/stmtpre_test/RT0012-rt-String-StmtTest12/expected.txt b/testsuite/java_test/stmtpre_test/RT0012-rt-String-StmtTest12/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0012-rt-String-StmtTest12/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/stmtpre_test/RT0012-rt-String-StmtTest12/test.cfg b/testsuite/java_test/stmtpre_test/RT0012-rt-String-StmtTest12/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8ebeaff71c3c11d7bb6bd7992311a481f09b644f
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0012-rt-String-StmtTest12/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest12,EXPECTNUM=5)
+run(StmtTest12)
diff --git a/testsuite/java_test/stmtpre_test/RT0013-rt-String-StmtTest13/StmtTest13.java b/testsuite/java_test/stmtpre_test/RT0013-rt-String-StmtTest13/StmtTest13.java
new file mode 100755
index 0000000000000000000000000000000000000000..9afd62bc293686848e918acb8bcac41b0b3faeaf
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0013-rt-String-StmtTest13/StmtTest13.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class StmtTest13 {
+    private String outOfMethod = "AB"; //3
+    public static void main(String[] args) {
+        String string = "AB"; // 1
+        for (int ii = 0; ii < 10; ii++) {
+            string += "A" + "B";
+        }
+        if (string.length() == 22) {
+            string = "AB"; //此处在堆上分配内存，不会用第22行的伪寄存器地址
+        } else {
+            char[] chars = {'A', 'B'};
+            string = chars.toString();
+        }
+        if (string.equals(new StmtTest13().outOfMethod)) {
+            System.out.println("ExpectResult");  // 2
+        } else {
+            System.out.print("ExpectResult");  //优化外提，这边不会再取一次。
+        }
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0013-rt-String-StmtTest13/expected.txt b/testsuite/java_test/stmtpre_test/RT0013-rt-String-StmtTest13/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0013-rt-String-StmtTest13/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/stmtpre_test/RT0013-rt-String-StmtTest13/test.cfg b/testsuite/java_test/stmtpre_test/RT0013-rt-String-StmtTest13/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..035d73dca51b12bc67405e95c0636839ed9a5c37
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0013-rt-String-StmtTest13/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest13,EXPECTNUM=1)
+run(StmtTest13)
diff --git a/testsuite/java_test/stmtpre_test/RT0014-rt-String-StmtTest14/StmtTest14.java b/testsuite/java_test/stmtpre_test/RT0014-rt-String-StmtTest14/StmtTest14.java
new file mode 100755
index 0000000000000000000000000000000000000000..1cfb0800a14366ba27a6224f082c4cfd6706775c
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0014-rt-String-StmtTest14/StmtTest14.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.nio.charset.StandardCharsets;
+public class StmtTest14 {
+    public static void main(String[] args) {
+        String string = "AB"; // 1
+        for (int ii = 0; ii < 10; ii++) {
+            string += "A" + "B"; // +号拼接场景
+        }
+        if (string.length() == 22) {
+            string = "AB"; // 作为入参
+        } else {
+            char[] chars = "AB".toCharArray(); // 作为函数调用主体
+            string = chars.toString();
+        }
+        byte[] bs = string.getBytes();
+        string = new String(bs, StandardCharsets.US_ASCII); 
+        System.out.println(string);
+    }
+}
diff --git a/testsuite/java_test/stmtpre_test/RT0014-rt-String-StmtTest14/expected.txt b/testsuite/java_test/stmtpre_test/RT0014-rt-String-StmtTest14/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3bd504ceced4f54589dad30001d4393cf1243efc
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0014-rt-String-StmtTest14/expected.txt
@@ -0,0 +1 @@
+AB
diff --git a/testsuite/java_test/stmtpre_test/RT0014-rt-String-StmtTest14/test.cfg b/testsuite/java_test/stmtpre_test/RT0014-rt-String-StmtTest14/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d7861734f332df9d7ef1c60e840c427e0a112b0b
--- /dev/null
+++ b/testsuite/java_test/stmtpre_test/RT0014-rt-String-StmtTest14/test.cfg
@@ -0,0 +1,2 @@
+compile(StmtTest14,EXPECTNUM=0)
+run(StmtTest14)
diff --git a/testsuite/java_test/string_test/RT0001-rt-string-ReflectString/ReflectString.java b/testsuite/java_test/string_test/RT0001-rt-string-ReflectString/ReflectString.java
new file mode 100644
index 0000000000000000000000000000000000000000..abd3921d4e66ccc3a578537a097a412593b02c0f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0001-rt-string-ReflectString/ReflectString.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ReflectString {
+    static int res = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            ReflectString_1();
+        } catch (Exception e) {
+            res -= 10;
+        }
+        if (result == 2 && res == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void ReflectString_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        Object test1 = null;
+        try {
+            test1 = String.class.newInstance();
+            res -= 4;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+        }
+//        System.out.println("test1:"+ test1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0001-rt-string-ReflectString/expected.txt b/testsuite/java_test/string_test/RT0001-rt-string-ReflectString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0001-rt-string-ReflectString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0001-rt-string-ReflectString/test.cfg b/testsuite/java_test/string_test/RT0001-rt-string-ReflectString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..72b6f7656072a71d8f7a37d6d38373621545e14b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0001-rt-string-ReflectString/test.cfg
@@ -0,0 +1,2 @@
+compile(ReflectString)
+run(ReflectString)
diff --git a/testsuite/java_test/string_test/RT0002-rt-String-BufferConstructorsTest/StringBufferConstructorsTest.java b/testsuite/java_test/string_test/RT0002-rt-String-BufferConstructorsTest/StringBufferConstructorsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..30eb0ffc3bdb6eefde9c61cb70148b5bcbd9ddde
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0002-rt-String-BufferConstructorsTest/StringBufferConstructorsTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferConstructorsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferConstructorsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferConstructorsTest_1() {
+        String str1_1 = new String("abc123abc");
+        String str1_2 = new String(" @!.&%()*");
+        String str1_3 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                        "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123ABC";
+        String str2_2 = " @!.&%()*";
+        String str2_3 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZX" +
+                        "CVBNM0x96";
+        String str2_4 = "";
+        test1_1(str1_1);
+        test1_1(str1_2);
+        test1_1(str1_3);
+        test1_1(str1_4);
+        test1_1(str1_5);
+        test1_1(str2_1);
+        test1_1(str2_2);
+        test1_1(str2_3);
+        test1_1(str2_4);
+        StringBuffer strBuffer1_1 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=" +
+                                    "!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test1_2(strBuffer1_1);
+        test1_2(strBuffer1_2);
+        test1_2(strBuffer1_3);
+        test1_2(strBuffer1_4);
+        test1_2(strBuffer1_5);
+        test1_3();
+        test1_4();
+        test1_5();
+    }
+    private static void test1_1(String str) {
+        System.out.println(new StringBuffer(str));
+    }
+    private static void test1_2(StringBuffer strBuffer) {
+        System.out.println(strBuffer.toString());
+    }
+    // Test new StringBuffer().
+    private static void test1_3() {
+        StringBuffer strBuffer1_6 = new StringBuffer();
+        System.out.println(strBuffer1_6.capacity());
+    }
+    // Test new StringBuffer(int capacity).
+    private static void test1_4() {
+        int capacity = 20;
+        StringBuffer strBuffer1_6 = new StringBuffer(capacity);
+        System.out.println(strBuffer1_6.capacity());
+        int capacityMin = 0;
+        strBuffer1_6 = new StringBuffer(capacityMin);
+        System.out.println(strBuffer1_6.capacity());
+    }
+    // Test new StringBuffer(CharSequence seq).
+    private static void test1_5() {
+        CharSequence chs1_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTY" +
+                "UIOPZXCVBNM0x96";
+        StringBuffer strBuffer1_7 = new StringBuffer(chs1_1);
+        test1_2(strBuffer1_7);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0002-rt-String-BufferConstructorsTest/expected.txt b/testsuite/java_test/string_test/RT0002-rt-String-BufferConstructorsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..447cded52dfc998c7cdb9f730f6cd8cbc05445ac
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0002-rt-String-BufferConstructorsTest/expected.txt
@@ -0,0 +1,19 @@
+abc123abc
+ @!.&%()*
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+
+abc123ABC
+ @!.&%()*
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+abc123abc
+ @!.&%()*
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+
+16
+20
+0
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+0
diff --git a/testsuite/java_test/string_test/RT0002-rt-String-BufferConstructorsTest/test.cfg b/testsuite/java_test/string_test/RT0002-rt-String-BufferConstructorsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1452c5f9d8a052ffd5e4268a07e7ba1da758ab90
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0002-rt-String-BufferConstructorsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferConstructorsTest)
+run(StringBufferConstructorsTest)
diff --git a/testsuite/java_test/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/StringBufferAppendAndAppendCodePointTest.java b/testsuite/java_test/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/StringBufferAppendAndAppendCodePointTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4588a2093d0611ebbcd032df7a95e3e773147cf1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/StringBufferAppendAndAppendCodePointTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferAppendAndAppendCodePointTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferAppendAndAppendCodePointTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferAppendAndAppendCodePointTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                                    "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+        test1(strBuffer1_5);
+    }
+    private static void test1(StringBuffer strBuffer) {
+        char c = 'C';
+        char[] data = {'A', 'B', 'C'};
+        CharSequence chs1_1 = "xyz";
+        double d = 8888.8888;
+        double dMin = 0;
+        float f = 99999999;
+        float fMin = 0;
+        int i = 77777777;
+        int iMin = 0;
+        long lng = 66666666;
+        long lngMin = 0;
+        Object obj = new String("object");
+        String str = "string";
+        StringBuffer sb = new StringBuffer("stringbuffer");
+        int codePoint = 74; // unicode 74 is J
+        System.out.println(strBuffer.append("-").append(true).append("-").append(false).append("-").append(c)
+                .append("-").append(data).append("-").append(chs1_1).append("-").append(chs1_1, 1, 2).append("-")
+                .append(chs1_1, 0, 3).append("-").append(chs1_1, 3, 3).append("-").append(chs1_1, 0, 0).append("-")
+                .append(d).append("-").append(dMin).append("-").append(f).append("-").append(fMin).append("-").append(i)
+                .append("-").append(iMin).append("-").append(lng).append("-").append(lngMin).append("-").append(obj)
+                .append("-").append(str).append("-").append(sb).append("-").appendCodePoint(codePoint));
+        System.out.println(strBuffer.subSequence(2, 8));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/expected.txt b/testsuite/java_test/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..00bcf56b049bfb85bfe321d76a53dfcaa7a486a8
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/expected.txt
@@ -0,0 +1,11 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J
+ertyui
+ @!.&%()*-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J
+!.&%()
+abc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J
+c123ab
+-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J
+rue-fa
+-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-stringbuffer-J
+rue-fa
+0
diff --git a/testsuite/java_test/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/test.cfg b/testsuite/java_test/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1386b4d2b1dad54fe4bd80758bcb82a085b0001e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0003-rt-String-BufferAppendAndAppendCodePointTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferAppendAndAppendCodePointTest)
+run(StringBufferAppendAndAppendCodePointTest)
diff --git a/testsuite/java_test/string_test/RT0004-rt-String-BufferInsertTest/StringBufferInsertTest.java b/testsuite/java_test/string_test/RT0004-rt-String-BufferInsertTest/StringBufferInsertTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..3baa7476a5d564b6841b997e1e2aabdd638d53e8
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0004-rt-String-BufferInsertTest/StringBufferInsertTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferInsertTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferInsertTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferInsertTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+        test1(strBuffer1_5);
+    }
+    private static void test1(StringBuffer strBuffer) {
+        boolean b = true;
+        char c = 'C';
+        char[] data = {'A', 'B', 'C'};
+        CharSequence chs1_1 = "xyz";
+        double d = 8888.8888;
+        double dMin = 0;
+        float f = 99999999;
+        float fMin = 0;
+        int i = 77777777;
+        int iMin = 0;
+        long lng = 66666666;
+        long lngMin = 0;
+        Object obj = new String("object");
+        String str = "-";
+        System.out.println(strBuffer.insert(0, str).insert(0, b).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), b).insert(0, str).insert(0, false).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), false).insert(0, str).insert(0, c).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), c).insert(0, str).insert(0, data).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), data).insert(0, str).insert(0, chs1_1).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), chs1_1).insert(0, str).insert(0, chs1_1, 1, 2)
+                .insert(strBuffer.length(), str).insert(strBuffer.length(), chs1_1, 1, 2).insert(0, str)
+                .insert(0, chs1_1, 0, 3).insert(strBuffer.length(), str).insert(strBuffer.length(), chs1_1, 0, 3)
+                .insert(0, str).insert(0, chs1_1, 3, 3).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), chs1_1, 3, 3).insert(0, str).insert(0, chs1_1, 0, 0)
+                .insert(strBuffer.length(), str).insert(strBuffer.length(), chs1_1, 0, 0).insert(0, str).insert(0, d)
+                .insert(strBuffer.length(), str).insert(strBuffer.length(), d).insert(0, str).insert(0, dMin)
+                .insert(0, str).insert(0, f).insert(strBuffer.length(), str).insert(strBuffer.length(), f)
+                .insert(0, str).insert(0, fMin).insert(0, str).insert(0, i).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), i).insert(0, str).insert(0, iMin).insert(0, str).insert(0, lng)
+                .insert(strBuffer.length(), str).insert(strBuffer.length(), lng).insert(0, str)
+                .insert(0, lngMin).insert(0, str).insert(0, obj).insert(strBuffer.length(), str)
+                .insert(strBuffer.length(), obj));
+        System.out.println(strBuffer.subSequence(2, 8));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0004-rt-String-BufferInsertTest/expected.txt b/testsuite/java_test/string_test/RT0004-rt-String-BufferInsertTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7a8d1cbdb637c566e93c2c8c6377e8fd95f068b7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0004-rt-String-BufferInsertTest/expected.txt
@@ -0,0 +1,11 @@
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true- @!.&%()*-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true-abc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true--true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false-true--true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+0
diff --git a/testsuite/java_test/string_test/RT0004-rt-String-BufferInsertTest/test.cfg b/testsuite/java_test/string_test/RT0004-rt-String-BufferInsertTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8021dd4476b22254c8a916708756374098858aec
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0004-rt-String-BufferInsertTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferInsertTest)
+run(StringBufferInsertTest)
diff --git a/testsuite/java_test/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/StringBufferDeleteAndDeleteCharAtTest.java b/testsuite/java_test/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/StringBufferDeleteAndDeleteCharAtTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ceb70a1de8bcfa805895e2f2593d637d2befef36
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/StringBufferDeleteAndDeleteCharAtTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferDeleteAndDeleteCharAtTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferDeleteAndDeleteCharAtTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferDeleteAndDeleteCharAtTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer2_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer2_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer2_3 = new StringBuffer("abc123abc");
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test2(strBuffer2_1);
+        test2(strBuffer2_2);
+        test2(strBuffer2_3);
+    }
+    // Test method delete(int start, int end).
+    private static void test1(StringBuffer strBuffer) {
+        // Test 0 < start < end, end < strBuffer.length().
+        System.out.println(strBuffer.delete(3, 5));
+        // Test start = 0.
+        System.out.println(strBuffer.delete(0, 1));
+        // Test end = 0.
+        System.out.println(strBuffer.delete(0, 0));
+        // Test start=strBuffer.length().
+        System.out.println(strBuffer.delete(strBuffer.length(), strBuffer.length()));
+        // Test end=strBuffer.length().
+        System.out.println(strBuffer.delete(2, strBuffer.length()));
+    }
+    // Test method deleteCharAt(int index).
+    private static void test2(StringBuffer strBuffer) {
+        // Test 0 < index < strBuffer.length().
+        System.out.println(strBuffer.deleteCharAt(1));
+        // Test index = 0.
+        System.out.println(strBuffer.deleteCharAt(0));
+        // Test index = strBuffer.length() - 1.
+        System.out.println(strBuffer.deleteCharAt(strBuffer.length() - 1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/expected.txt b/testsuite/java_test/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eddc3aea49e0fce935a0956369a14d37ad1740c1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/expected.txt
@@ -0,0 +1,25 @@
+qweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+weyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+weyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+weyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+we
+ @!%()*
+@!%()*
+@!%()*
+@!%()*
+@!
+abc3abc
+bc3abc
+bc3abc
+bc3abc
+bc
+qertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x9
+ !.&%()*
+!.&%()*
+!.&%()
+ac123abc
+c123abc
+c123ab
+0
diff --git a/testsuite/java_test/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/test.cfg b/testsuite/java_test/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..19e8bbbd6223077cb515821353b5be90449c5ab3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0005-rt-String-BufferDeleteAndDeleteCharAtTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferDeleteAndDeleteCharAtTest)
+run(StringBufferDeleteAndDeleteCharAtTest)
diff --git a/testsuite/java_test/string_test/RT0006-rt-String-BufferCodePointExceptionTest/StringBufferCodePointExceptionTest.java b/testsuite/java_test/string_test/RT0006-rt-String-BufferCodePointExceptionTest/StringBufferCodePointExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8b6c9c3947680eee904bb013b91f4b799217dba
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0006-rt-String-BufferCodePointExceptionTest/StringBufferCodePointExceptionTest.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferCodePointExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferCodePointExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferCodePointExceptionTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-" +
+                "=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+        test3(strBuffer1_1);
+        test3(strBuffer1_2);
+        test3(strBuffer1_3);
+        test4(strBuffer1_1);
+        test4(strBuffer1_2);
+        test4(strBuffer1_3);
+    }
+    // Test method codePointAt(int index).
+    private static void test1(StringBuffer strBuffer) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = strBuffer.codePointAt(i);
+                System.out.println("i=" + i + " " + "codePointAt=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointAt(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(strBuffer.charAt(i) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+    // Test method codePointBefore(int index).
+    private static void test2(StringBuffer strBuffer) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = strBuffer.codePointBefore(i);
+                System.out.println("i=" + i + " " + "codePointBefore=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointBefore(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(strBuffer.charAt(i - 1) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+    // Test method codePointCount(int beginIndex, int endIndex).
+    private static void test3(StringBuffer strBuffer) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = strBuffer.codePointCount(i, i + 3);
+                System.out.println("i=" + i + " " + "codePointCount=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("codePointCount(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(strBuffer.charAt(i) + "~" + strBuffer.charAt(i + 3) +
+                            " codePointCount is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+    // Test method int offsetByCodePoints(int index, int codePointOffset).
+    private static void test4(StringBuffer strBuffer) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = strBuffer.offsetByCodePoints(i, i + 3);
+                System.out.println("i=" + i + " " + "offsetByCodePoints=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("offsetByCodePoints(): " + i + "+3  out of length");
+            } finally {
+                try {
+                    System.out.println(strBuffer.charAt(i) + " offsetByCodePoints +3 is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0006-rt-String-BufferCodePointExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0006-rt-String-BufferCodePointExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fd0e884408537cba05c2fe7bf7455a5266848862
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0006-rt-String-BufferCodePointExceptionTest/expected.txt
@@ -0,0 +1,121 @@
+i=0 codePointAt=113
+q Unicode is:113
+i=1 codePointAt=119
+w Unicode is:119
+i=2 codePointAt=101
+e Unicode is:101
+i=3 codePointAt=114
+r Unicode is:114
+i=4 codePointAt=116
+t Unicode is:116
+i=5 codePointAt=121
+y Unicode is:121
+i=0 codePointAt=32
+  Unicode is:32
+i=1 codePointAt=64
+@ Unicode is:64
+i=2 codePointAt=33
+! Unicode is:33
+i=3 codePointAt=46
+. Unicode is:46
+i=4 codePointAt=38
+& Unicode is:38
+i=5 codePointAt=37
+% Unicode is:37
+i=0 codePointAt=97
+a Unicode is:97
+i=1 codePointAt=98
+b Unicode is:98
+i=2 codePointAt=99
+c Unicode is:99
+i=3 codePointAt=49
+1 Unicode is:49
+i=4 codePointAt=50
+2 Unicode is:50
+i=5 codePointAt=51
+3 Unicode is:51
+codePointBefore(): 0out of length
+0 out of length
+i=1 codePointBefore=113
+q Unicode is:113
+i=2 codePointBefore=119
+w Unicode is:119
+i=3 codePointBefore=101
+e Unicode is:101
+i=4 codePointBefore=114
+r Unicode is:114
+i=5 codePointBefore=116
+t Unicode is:116
+codePointBefore(): 0out of length
+0 out of length
+i=1 codePointBefore=32
+  Unicode is:32
+i=2 codePointBefore=64
+@ Unicode is:64
+i=3 codePointBefore=33
+! Unicode is:33
+i=4 codePointBefore=46
+. Unicode is:46
+i=5 codePointBefore=38
+& Unicode is:38
+codePointBefore(): 0out of length
+0 out of length
+i=1 codePointBefore=97
+a Unicode is:97
+i=2 codePointBefore=98
+b Unicode is:98
+i=3 codePointBefore=99
+c Unicode is:99
+i=4 codePointBefore=49
+1 Unicode is:49
+i=5 codePointBefore=50
+2 Unicode is:50
+i=0 codePointCount=3
+q~r codePointCount is :3
+i=1 codePointCount=3
+w~t codePointCount is :3
+i=2 codePointCount=3
+e~y codePointCount is :3
+i=3 codePointCount=3
+r~u codePointCount is :3
+i=0 codePointCount=3
+ ~. codePointCount is :3
+i=1 codePointCount=3
+@~& codePointCount is :3
+i=2 codePointCount=3
+!~% codePointCount is :3
+i=3 codePointCount=3
+3 out of length
+i=0 codePointCount=3
+a~1 codePointCount is :3
+i=1 codePointCount=3
+b~2 codePointCount is :3
+i=2 codePointCount=3
+c~3 codePointCount is :3
+i=3 codePointCount=3
+3 out of length
+i=0 offsetByCodePoints=3
+q offsetByCodePoints +3 is :3
+i=1 offsetByCodePoints=5
+w offsetByCodePoints +3 is :5
+i=2 offsetByCodePoints=7
+e offsetByCodePoints +3 is :7
+i=3 offsetByCodePoints=9
+r offsetByCodePoints +3 is :9
+i=0 offsetByCodePoints=3
+  offsetByCodePoints +3 is :3
+i=1 offsetByCodePoints=5
+@ offsetByCodePoints +3 is :5
+offsetByCodePoints(): 2+3  out of length
+! offsetByCodePoints +3 is :5
+offsetByCodePoints(): 3+3  out of length
+. offsetByCodePoints +3 is :5
+i=0 offsetByCodePoints=3
+a offsetByCodePoints +3 is :3
+i=1 offsetByCodePoints=5
+b offsetByCodePoints +3 is :5
+offsetByCodePoints(): 2+3  out of length
+c offsetByCodePoints +3 is :5
+offsetByCodePoints(): 3+3  out of length
+1 offsetByCodePoints +3 is :5
+0
diff --git a/testsuite/java_test/string_test/RT0006-rt-String-BufferCodePointExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0006-rt-String-BufferCodePointExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0521981e10d93699f4d9d6d45c2fdb2f79df5cee
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0006-rt-String-BufferCodePointExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferCodePointExceptionTest)
+run(StringBufferCodePointExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/StringBufferCapacityAndEnsureCapacityTest.java b/testsuite/java_test/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/StringBufferCapacityAndEnsureCapacityTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2382933242e43547715d406ee9ed8869353e1dbd
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/StringBufferCapacityAndEnsureCapacityTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferCapacityAndEnsureCapacityTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferCapacityAndEnsureCapacityTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferCapacityAndEnsureCapacityTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=" +
+                "!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+        test1(strBuffer1_5);
+    }
+    private static void test1(StringBuffer strBuffer) {
+        System.out.println("1-capacity: " + strBuffer.capacity());
+        System.out.println("1-lent: " + strBuffer.length());
+        strBuffer = strBuffer.append("01234567890123456789");
+        System.out.println("2-capacity: " + strBuffer.capacity());
+        System.out.println("2-lent: " + strBuffer.length());
+        strBuffer.ensureCapacity(80);
+        System.out.println("3-capacity: " + strBuffer.capacity());
+        System.out.println("3-lent: " + strBuffer.length());
+        strBuffer.setLength(100);
+        System.out.println("4-capacity: " + strBuffer.capacity());
+        System.out.println("4-lent: " + strBuffer.length());
+        strBuffer.trimToSize();
+        System.out.println("5-capacity: " + strBuffer.capacity());
+        System.out.println("5-lent: " + strBuffer.length());
+        // Test minimumCapacity < 0.
+        strBuffer.ensureCapacity(-2);
+        System.out.println("6-capacity: " + strBuffer.capacity());
+        System.out.println("6-lent: " + strBuffer.length());
+        // Test minimumCapacity = 0.
+        strBuffer.ensureCapacity(0);
+        System.out.println("7-capacity: " + strBuffer.capacity());
+        System.out.println("7-lent: " + strBuffer.length());
+        // Test minimumCapacity > 0.
+        strBuffer.ensureCapacity(2);
+        System.out.println("8-capacity: " + strBuffer.capacity());
+        System.out.println("8-lent: " + strBuffer.length());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/expected.txt b/testsuite/java_test/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c48dadafe4dd4162136bb019b7323b25c8c9e36d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/expected.txt
@@ -0,0 +1,81 @@
+1-capacity: 115
+1-lent: 99
+2-capacity: 232
+2-lent: 119
+3-capacity: 232
+3-lent: 119
+4-capacity: 232
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+1-capacity: 25
+1-lent: 9
+2-capacity: 52
+2-lent: 29
+3-capacity: 106
+3-lent: 29
+4-capacity: 106
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+1-capacity: 22
+1-lent: 6
+2-capacity: 46
+2-lent: 26
+3-capacity: 94
+3-lent: 26
+4-capacity: 190
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+1-capacity: 16
+1-lent: 0
+2-capacity: 34
+2-lent: 20
+3-capacity: 80
+3-lent: 20
+4-capacity: 162
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+1-capacity: 16
+1-lent: 0
+2-capacity: 34
+2-lent: 20
+3-capacity: 80
+3-lent: 20
+4-capacity: 162
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+0
diff --git a/testsuite/java_test/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/test.cfg b/testsuite/java_test/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..415b80d633ec55d14c171c509634bc94fcc0733f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0007-rt-String-BufferCapacityAndEnsureCapacityTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferCapacityAndEnsureCapacityTest)
+run(StringBufferCapacityAndEnsureCapacityTest)
diff --git a/testsuite/java_test/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/StringBufferCharAtAndSetCharAtExceptionTest.java b/testsuite/java_test/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/StringBufferCharAtAndSetCharAtExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f33b1ac2fbea53f3a5cf8ab59a86dc23a9d5c817
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/StringBufferCharAtAndSetCharAtExceptionTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferCharAtAndSetCharAtExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferCharAtAndSetCharAtExceptionTest_1();
+            StringBufferCharAtAndSetCharAtExceptionTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferCharAtAndSetCharAtExceptionTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=" +
+                "!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+    }
+    public static void StringBufferCharAtAndSetCharAtExceptionTest_2() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+        test2(strBuffer1_4);
+    }
+    // Test method char charAt(int index).
+    private static void test1(StringBuffer strBuffer) {
+        int charAt = 0;
+        for (int i = -1; i < 8; i++) {
+            try {
+                charAt = strBuffer.charAt(i);
+                System.out.println("i=" + i + "  " + "charAt=" + charAt);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("index: " + i + "  String index out of range");
+            }
+        }
+    }
+    // Test Method void setCharAt(int index, char ch).
+    private static void test2(StringBuffer strBuffer) {
+        char ch = 'A';
+        for (int i = -1; i < 8; i++) {
+            try {
+                strBuffer.setCharAt(i, ch);
+                System.out.println("i=" + i + "  " + "setcharAt=" + strBuffer);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("index: " + i + "  String index out of range");
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..840ff10d47566081b5877e2c900fcd39fa274d8d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/expected.txt
@@ -0,0 +1,73 @@
+index: -1  String index out of range
+i=0  charAt=113
+i=1  charAt=119
+i=2  charAt=101
+i=3  charAt=114
+i=4  charAt=116
+i=5  charAt=121
+i=6  charAt=117
+i=7  charAt=105
+index: -1  String index out of range
+i=0  charAt=32
+i=1  charAt=64
+i=2  charAt=33
+i=3  charAt=46
+i=4  charAt=38
+i=5  charAt=37
+i=6  charAt=40
+i=7  charAt=41
+index: -1  String index out of range
+i=0  charAt=97
+i=1  charAt=98
+i=2  charAt=99
+i=3  charAt=49
+i=4  charAt=50
+i=5  charAt=51
+index: 6  String index out of range
+index: 7  String index out of range
+index: -1  String index out of range
+index: 0  String index out of range
+index: 1  String index out of range
+index: 2  String index out of range
+index: 3  String index out of range
+index: 4  String index out of range
+index: 5  String index out of range
+index: 6  String index out of range
+index: 7  String index out of range
+index: -1  String index out of range
+i=0  setcharAt=Awertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=1  setcharAt=AAertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=2  setcharAt=AAArtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=3  setcharAt=AAAAtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=4  setcharAt=AAAAAyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=5  setcharAt=AAAAAAuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=6  setcharAt=AAAAAAAiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=7  setcharAt=AAAAAAAAop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+index: -1  String index out of range
+i=0  setcharAt=A@!.&%()*
+i=1  setcharAt=AA!.&%()*
+i=2  setcharAt=AAA.&%()*
+i=3  setcharAt=AAAA&%()*
+i=4  setcharAt=AAAAA%()*
+i=5  setcharAt=AAAAAA()*
+i=6  setcharAt=AAAAAAA)*
+i=7  setcharAt=AAAAAAAA*
+index: -1  String index out of range
+i=0  setcharAt=Abc123
+i=1  setcharAt=AAc123
+i=2  setcharAt=AAA123
+i=3  setcharAt=AAAA23
+i=4  setcharAt=AAAAA3
+i=5  setcharAt=AAAAAA
+index: 6  String index out of range
+index: 7  String index out of range
+index: -1  String index out of range
+index: 0  String index out of range
+index: 1  String index out of range
+index: 2  String index out of range
+index: 3  String index out of range
+index: 4  String index out of range
+index: 5  String index out of range
+index: 6  String index out of range
+index: 7  String index out of range
+0
diff --git a/testsuite/java_test/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ebd262f3a97c4bf357715264dbaaaddc7199b197
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferCharAtAndSetCharAtExceptionTest)
+run(StringBufferCharAtAndSetCharAtExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0009-rt-String-BufferGetCharsTest/StringBufferGetCharsTest.java b/testsuite/java_test/string_test/RT0009-rt-String-BufferGetCharsTest/StringBufferGetCharsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..add48d677d4f0aa6fce4cef2ce1cb8dbe5af5096
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0009-rt-String-BufferGetCharsTest/StringBufferGetCharsTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferGetCharsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferGetCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferGetCharsTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123");
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+    }
+    private static void test1(StringBuffer strBuffer) {
+        // Test srcBegin  < srcEnd < instance.length, dstBegin < dst(char[]).length.
+        char[] dst = {'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(2, 5, dst, 2);
+        System.out.println(dst);
+        // Test srcBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(0, 3, dst, 2);
+        System.out.println(dst);
+        // Test srcEnd = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(0, 0, dst, 2);
+        System.out.println(dst);
+        // Test dstBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(2, 5, dst, 0);
+        System.out.println(dst);
+        // Test srcBegin = srcEnd.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(2, 2, dst, 0);
+        System.out.println(dst);
+        // Test srcBegin = strBuffer.length() - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        int index = strBuffer.length() - 1;
+        strBuffer.getChars(index, index, dst, 0);
+        System.out.println(dst);
+        // Test srcEnd = strBuffer.length() - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(index - 2, index, dst, 0);
+        System.out.println(dst);
+        // Test dstBegin = dst.length - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuffer.getChars(0, 1, dst, dst.length - 1);
+        System.out.println(dst);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0009-rt-String-BufferGetCharsTest/expected.txt b/testsuite/java_test/string_test/RT0009-rt-String-BufferGetCharsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c54226f3fc5f75d4cc44f30c2c2f705e3ac7dca5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0009-rt-String-BufferGetCharsTest/expected.txt
@@ -0,0 +1,25 @@
+ABertF
+ABqweF
+ABCDEF
+ertDEF
+ABCDEF
+ABCDEF
+x9CDEF
+ABCDEq
+AB!.&F
+AB @!F
+ABCDEF
+!.&DEF
+ABCDEF
+ABCDEF
+()CDEF
+ABCDE 
+ABc12F
+ABabcF
+ABCDEF
+c12DEF
+ABCDEF
+ABCDEF
+12CDEF
+ABCDEa
+0
diff --git a/testsuite/java_test/string_test/RT0009-rt-String-BufferGetCharsTest/test.cfg b/testsuite/java_test/string_test/RT0009-rt-String-BufferGetCharsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e3bd3c529459db7ff12c7eeaa8871baa5cb20a58
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0009-rt-String-BufferGetCharsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferGetCharsTest)
+run(StringBufferGetCharsTest)
diff --git a/testsuite/java_test/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/StringBufferIndexOfAndLastIndexOfTest.java b/testsuite/java_test/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/StringBufferIndexOfAndLastIndexOfTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..849969450f3f4a8fc5c888ec7acb5c68242fa06a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/StringBufferIndexOfAndLastIndexOfTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferIndexOfAndLastIndexOfTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferIndexOfAndLastIndexOfTest_1();
+            StringBufferIndexOfAndLastIndexOfTest_2();
+            StringBufferIndexOfAndLastIndexOfTest_3();
+            StringBufferIndexOfAndLastIndexOfTest_4();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferIndexOfAndLastIndexOfTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test1(strBuffer1_4);
+        test1(strBuffer1_5);
+    }
+    public static void StringBufferIndexOfAndLastIndexOfTest_2() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+        test2(strBuffer1_4);
+        test2(strBuffer1_5);
+    }
+    public static void StringBufferIndexOfAndLastIndexOfTest_3() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test3(strBuffer1_1);
+        test3(strBuffer1_2);
+        test3(strBuffer1_3);
+        test3(strBuffer1_4);
+        test3(strBuffer1_5);
+    }
+    public static void StringBufferIndexOfAndLastIndexOfTest_4() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test4(strBuffer1_1);
+        test4(strBuffer1_2);
+        test4(strBuffer1_3);
+        test4(strBuffer1_4);
+        test4(strBuffer1_5);
+    }
+    // Test method indexOf(String str).
+    private static void test1(StringBuffer strBuffer) {
+        System.out.println(strBuffer.indexOf("b"));
+        // Test empty String.
+        System.out.println(strBuffer.indexOf(""));
+    }
+    // Test method indexOf(String str, int fromIndex).
+    private static void test2(StringBuffer strBuffer) {
+        System.out.println(strBuffer.indexOf("b", 2));
+        // Test fromIndex = 0.
+        System.out.println(strBuffer.indexOf("b", 0));
+        // Test fromIndex = strBuffer.length() - 1.
+        System.out.println(strBuffer.indexOf("6", strBuffer.length() - 1));
+    }
+    // Test method lastIndexOf(String str).
+    private static void test3(StringBuffer strBuffer) {
+        System.out.println(strBuffer.lastIndexOf("b"));
+        // Test empty String.
+        System.out.println(strBuffer.lastIndexOf(""));
+    }
+    // Test method lastIndexOf(String str, int fromIndex).
+    private static void test4(StringBuffer strBuffer) {
+        System.out.println(strBuffer.lastIndexOf("b", 1));
+        // Test fromIndex = 0.
+        System.out.println(strBuffer.lastIndexOf("b", 0));
+        // Test fromIndex = strBuffer.length() - 1.
+        System.out.println(strBuffer.lastIndexOf("6", strBuffer.length() - 1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/expected.txt b/testsuite/java_test/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0066aba90dfe722d59df5941108f3589aeeff117
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/expected.txt
@@ -0,0 +1,51 @@
+33
+0
+-1
+0
+1
+0
+-1
+0
+-1
+0
+33
+33
+98
+-1
+-1
+-1
+7
+1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+33
+99
+-1
+9
+7
+9
+-1
+0
+-1
+0
+-1
+-1
+98
+-1
+-1
+-1
+1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/test.cfg b/testsuite/java_test/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c76b52f79227d86ac085d69bfdcb03166cbe5d9a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0010-rt-String-BufferIndexOfAndLastIndexOfTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferIndexOfAndLastIndexOfTest)
+run(StringBufferIndexOfAndLastIndexOfTest)
diff --git a/testsuite/java_test/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/StringBufferReplaceAndReverseTest.java b/testsuite/java_test/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/StringBufferReplaceAndReverseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f9fde8db642b27a82adc26413b29242ec97c2199
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/StringBufferReplaceAndReverseTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferReplaceAndReverseTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferReplaceAndReverseTest_1();
+            StringBufferReplaceAndReverseTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferReplaceAndReverseTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+    }
+    public static void StringBufferReplaceAndReverseTest_2() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+        test2(strBuffer1_4);
+        test2(strBuffer1_5);
+    }
+    // Test method replace(int start, int end, String str).
+    private static void test1(StringBuffer strBuffer) {
+        System.out.println(strBuffer.replace(2, 6, "xyz"));
+        // end = 0
+        System.out.println(strBuffer.replace(0, 0, "xyz"));
+        // start = 0 & end = strBuffer.length()
+        System.out.println(strBuffer.replace(0, strBuffer.length(), "xyz"));
+        // start = strBuffer.length() & end = strBuffer.length()
+        System.out.println(strBuffer.replace(strBuffer.length(), strBuffer.length(), "xyz"));
+    }
+    // Test method reverse().
+    private static void test2(StringBuffer strBuffer) {
+        strBuffer.reverse();
+        System.out.println(strBuffer);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/expected.txt b/testsuite/java_test/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..92a847590bc368b34e8fc0ea0eeeac29ed5fa3b3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/expected.txt
@@ -0,0 +1,18 @@
+qwxyzuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+xyzqwxyzuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+xyz
+xyzxyz
+ @xyz
+xyz @xyz
+xyz
+xyzxyz
+abxyzabc
+xyzabxyzabc
+xyz
+xyzxyz
+69x0MNBVCXZPOIUYTREWQLKJHGFDSA +_)(*&^%$#@!=-0987654321`~?/><.,mnbvcxz"':;lkjhgfdsa|\][}{poiuytrewq
+%&.!@ 
+cba321cba
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/test.cfg b/testsuite/java_test/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a0dc5f30d9fa127c054b07ca4c2ce51d26770fb
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0011-rt-String-BufferReplaceAndReverseTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferReplaceAndReverseTest)
+run(StringBufferReplaceAndReverseTest)
diff --git a/testsuite/java_test/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/StringBufferSubstringAndToStringTest.java b/testsuite/java_test/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/StringBufferSubstringAndToStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fb41a8665066a79453c1a8ac353270998e48ac1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/StringBufferSubstringAndToStringTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferSubstringAndToStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBufferSubstringAndToStringTest_1();
+            StringBufferSubstringAndToStringTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBufferSubstringAndToStringTest_1() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%()*");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        test1(strBuffer1_1);
+        test1(strBuffer1_2);
+        test1(strBuffer1_3);
+        test2(strBuffer1_1);
+        test2(strBuffer1_2);
+        test2(strBuffer1_3);
+    }
+    public static void StringBufferSubstringAndToStringTest_2() {
+        StringBuffer strBuffer1_1 = new StringBuffer("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuffer strBuffer1_2 = new StringBuffer(" @!.&%");
+        StringBuffer strBuffer1_3 = new StringBuffer("abc123abc");
+        StringBuffer strBuffer1_4 = new StringBuffer("");
+        StringBuffer strBuffer1_5 = new StringBuffer();
+        test3(strBuffer1_1);
+        test3(strBuffer1_2);
+        test3(strBuffer1_3);
+        test3(strBuffer1_4);
+        test3(strBuffer1_5);
+    }
+    // Test method substring(int start, int end).
+    private static void test1(StringBuffer strBuffer) {
+        System.out.println(strBuffer.substring(2, 7));
+        // Test start = 0 & end = strBuffer.length().
+        System.out.println(strBuffer.substring(0, strBuffer.length()));
+        // Test start = strBuffer.length().
+        System.out.println(strBuffer.substring(strBuffer.length(), strBuffer.length()));
+        // Test end = 0.
+        System.out.println(strBuffer.substring(0, 0));
+    }
+    // Test method substring(int start).
+    private static void test2(StringBuffer strBuffer) {
+        System.out.println(strBuffer.substring(3));
+        // Test start = 0.
+        System.out.println(strBuffer.substring(0));
+        // Test start = strBuffer.length().
+        System.out.println(strBuffer.substring(strBuffer.length()));
+    }
+    // Test method toString().
+    private static void test3(StringBuffer strBuffer) {
+        System.out.println(strBuffer.toString());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/expected.txt b/testsuite/java_test/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..341d348f0ed007510ecf6f11c43ef25541d860fa
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/expected.txt
@@ -0,0 +1,27 @@
+ertyu
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+
+!.&%(
+ @!.&%()*
+
+
+c123a
+abc123abc
+
+
+rtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+.&%()*
+ @!.&%()*
+
+123abc
+abc123abc
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+abc123abc
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/test.cfg b/testsuite/java_test/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8392b161d3c70e70d359396c7e30fa8119913dc9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0012-rt-String-BufferSubstringAndToStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferSubstringAndToStringTest)
+run(StringBufferSubstringAndToStringTest)
diff --git a/testsuite/java_test/string_test/RT0013-rt-String-BuilderConstructorsTest/StringBuilderConstructorsTest.java b/testsuite/java_test/string_test/RT0013-rt-String-BuilderConstructorsTest/StringBuilderConstructorsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..83a349411cbaec12ea27562c28b7e256efc1902d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0013-rt-String-BuilderConstructorsTest/StringBuilderConstructorsTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderConstructorsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderConstructorsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderConstructorsTest_1() {
+        String str1_1 = new String("abc123abc");
+        String str1_2 = new String(" @!.&%()*");
+        String str1_3 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123ABC";
+        String str2_2 = " @!.&%()*";
+        String str2_3 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZX" +
+                "CVBNM0x96";
+        String str2_4 = "";
+        test1_1(str1_1);
+        test1_1(str1_2);
+        test1_1(str1_3);
+        test1_1(str1_4);
+        test1_1(str1_5);
+        test1_1(str2_1);
+        test1_1(str2_2);
+        test1_1(str2_3);
+        test1_1(str2_4);
+        StringBuilder strBuilder1_1 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=" +
+                "!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test1_2(strBuilder1_1);
+        test1_2(strBuilder1_2);
+        test1_2(strBuilder1_3);
+        test1_2(strBuilder1_4);
+        test1_2(strBuilder1_5);
+        // Test new StringBuilder()
+        test1_3();
+        // Test new StringBuilder(int capacity)
+        test1_4();
+        // Test new StringBuilder(CharSequence seq)
+        test1_5();
+    }
+    private static void test1_1(String str) {
+        System.out.println(new StringBuilder(str));
+    }
+    private static void test1_2(StringBuilder strBuilder) {
+        System.out.println(strBuilder.toString());
+    }
+    private static void test1_3() {
+        StringBuilder strBuilder1_6 = new StringBuilder();
+        System.out.println(strBuilder1_6.capacity());
+    }
+    private static void test1_4() {
+        int capacity = 20;
+        StringBuilder strBuilder1_6 = new StringBuilder(capacity);
+        System.out.println(strBuilder1_6.capacity());
+        int capacityMin = 0;
+        strBuilder1_6 = new StringBuilder(capacityMin);
+        System.out.println(strBuilder1_6.capacity());
+    }
+    private static void test1_5() {
+        CharSequence chs1_1 = "xyz";
+        StringBuilder strBuilder1_7 = new StringBuilder(chs1_1);
+        test1_2(strBuilder1_7);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0013-rt-String-BuilderConstructorsTest/expected.txt b/testsuite/java_test/string_test/RT0013-rt-String-BuilderConstructorsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3e4668a77c4583366eaca1433e269af55aaa2a74
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0013-rt-String-BuilderConstructorsTest/expected.txt
@@ -0,0 +1,19 @@
+abc123abc
+ @!.&%()*
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+
+abc123ABC
+ @!.&%()*
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+abc123abc
+ @!.&%
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+
+16
+20
+0
+xyz
+0
diff --git a/testsuite/java_test/string_test/RT0013-rt-String-BuilderConstructorsTest/test.cfg b/testsuite/java_test/string_test/RT0013-rt-String-BuilderConstructorsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f9f69ed4d98658c1635e9e0fb82d00d22a599ced
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0013-rt-String-BuilderConstructorsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderConstructorsTest)
+run(StringBuilderConstructorsTest)
diff --git a/testsuite/java_test/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/StringBuilderAppendAndAppendCodePointTest.java b/testsuite/java_test/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/StringBuilderAppendAndAppendCodePointTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2a3340f7b0746b3ca9f27852ae27df65f373092
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/StringBuilderAppendAndAppendCodePointTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderAppendAndAppendCodePointTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderAppendAndAppendCodePointTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderAppendAndAppendCodePointTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_2 = new StringBuilder("      ");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+        test1(strBuilder1_5);
+    }
+    private static void test1(StringBuilder strBuilder) {
+        char c = 'C';
+        char[] data = {'A', 'B', 'C'};
+        CharSequence chs1_1 = "xyz";
+        Object obj = new String("object");
+        String str = "string";
+        double d = 8888.8888;
+        double dMin = 0;
+        float f = 99999999;
+        float fMin = 0;
+        int i = 77777777;
+        int iMin = 0;
+        long lng = 66666666;
+        long lngMin = 0;
+        StringBuilder sb = new StringBuilder("StringBuilder");
+        int codePoint = 74; // unicode 74 is J
+        System.out.println(strBuilder.append("-").append(true).append("-").append(false).append("-").append(c)
+                .append("-").append(data).append("-").append(chs1_1).append("-").append(chs1_1, 1, 2).append("-")
+                .append(chs1_1, 0, 3).append("-").append(chs1_1, 3, 3).append("-").append(chs1_1, 0, 0).append("-")
+                .append(d).append("-").append(dMin).append("-").append(f).append("-").append(fMin).append("-").append(i)
+                .append("-").append(iMin).append("-").append(lng).append("-").append(lngMin).append("-").append(obj)
+                .append("-").append(str).append("-").append(sb).append("-").appendCodePoint(codePoint));
+        System.out.println(strBuilder.subSequence(2, 8));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/expected.txt b/testsuite/java_test/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c28af3e1c59ffb4f1d04a49920f6164eb43ced44
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/expected.txt
@@ -0,0 +1,11 @@
+abc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J
+c123ab
+      -true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J
+    -t
+abc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J
+c123ab
+-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J
+rue-fa
+-true-false-C-ABC-xyz-y-xyz---8888.8888-0.0-1.0E8-0.0-77777777-0-66666666-0-object-string-StringBuilder-J
+rue-fa
+0
diff --git a/testsuite/java_test/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/test.cfg b/testsuite/java_test/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..afdbad87c2bb6d5bf29f18af4dfbf2da27a42d1f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0014-rt-String-BuilderAppendAndAppendCodePointTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderAppendAndAppendCodePointTest)
+run(StringBuilderAppendAndAppendCodePointTest)
diff --git a/testsuite/java_test/string_test/RT0015-rt-String-BuilderInsertTest/StringBuilderInsertTest.java b/testsuite/java_test/string_test/RT0015-rt-String-BuilderInsertTest/StringBuilderInsertTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6b10e5e8c711fa4bd8c96f813fd04d811245bdf
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0015-rt-String-BuilderInsertTest/StringBuilderInsertTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderInsertTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderInsertTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderInsertTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+        test1(strBuilder1_5);
+    }
+    private static void test1(StringBuilder strBuilder) {
+        char c = 'C';
+        char[] data = {'A', 'B', 'C'};
+        CharSequence chs1_1 = "xyz";
+        double d = 8888.8888;
+        double dMin = 0;
+        float f = 99999999;
+        float fMin = 0;
+        int i = 77777777;
+        int iMin = 0;
+        long lng = 66666666;
+        long lngMin = 0;
+        Object obj = new String("object");
+        String str = "-";
+        System.out.println(strBuilder.insert(0, str).insert(1, true).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), true).insert(0, str).insert(0, false).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), false).insert(0, str).insert(0, c).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), c).insert(0, str).insert(0, data).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), data).insert(0, str).insert(0, chs1_1).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), chs1_1).insert(0, str).insert(0, chs1_1, 1, 2)
+                .insert(strBuilder.length(), str).insert(strBuilder.length(), chs1_1, 1, 2).insert(0, str)
+                .insert(0, chs1_1, 0, 3).insert(strBuilder.length(), str).insert(strBuilder.length(), chs1_1, 0, 3)
+                .insert(0, str).insert(0, chs1_1, 3, 3).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), chs1_1, 3, 3).insert(0, str).insert(0, chs1_1, 0, 0)
+                .insert(strBuilder.length(), str).insert(strBuilder.length(), chs1_1, 0, 0).insert(0, str).insert(0, d)
+                .insert(strBuilder.length(), str).insert(strBuilder.length(), d).insert(0, str).insert(0, dMin)
+                .insert(0, str).insert(0, f).insert(strBuilder.length(), str).insert(strBuilder.length(), f)
+                .insert(0, str).insert(0, fMin).insert(0, str).insert(0, i).insert(strBuilder.length(), str)
+                .insert(strBuilder.length(), i).insert(0, str).insert(0, iMin).insert(0, str).insert(0, lng)
+                .insert(strBuilder.length(), str).insert(strBuilder.length(), lng).insert(0, str).insert(0, lngMin)
+                .insert(0, str).insert(0, obj).insert(strBuilder.length(), str).insert(strBuilder.length(), obj));
+        System.out.println(strBuilder.subSequence(2, 8));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0015-rt-String-BuilderInsertTest/expected.txt b/testsuite/java_test/string_test/RT0015-rt-String-BuilderInsertTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eabd3a35ca68e31a58d9ad14bbb76bf74921e3e6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0015-rt-String-BuilderInsertTest/expected.txt
@@ -0,0 +1,11 @@
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--trueqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--true @!.&%()*-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--trueabc123abc-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--true-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+object-0-66666666-0-77777777-0.0-1.0E8-0.0-8888.8888---xyz-y-xyz-ABC-C-false--true-true-false-C-ABC-xyz-y-xyz---8888.8888-1.0E8-77777777-66666666-object
+ject-0
+0
diff --git a/testsuite/java_test/string_test/RT0015-rt-String-BuilderInsertTest/test.cfg b/testsuite/java_test/string_test/RT0015-rt-String-BuilderInsertTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..71de70dcf17b2a56c3cad5a0a53f14cfa516e2f9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0015-rt-String-BuilderInsertTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderInsertTest)
+run(StringBuilderInsertTest)
diff --git a/testsuite/java_test/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/StringBuilderDeleteAndDeleteCharAtTest.java b/testsuite/java_test/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/StringBuilderDeleteAndDeleteCharAtTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a165f56886639d9c0ba3c421efa60fff9fac18c6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/StringBuilderDeleteAndDeleteCharAtTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderDeleteAndDeleteCharAtTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderDeleteAndDeleteCharAtTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderDeleteAndDeleteCharAtTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder2_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder2_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder2_3 = new StringBuilder("abc123abc");
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test2(strBuilder2_1);
+        test2(strBuilder2_2);
+        test2(strBuilder2_3);
+    }
+    // Test method delete(int start, int end).
+    private static void test1(StringBuilder strBuilder) {
+        // Test 0 < start < end, end < strBuffer.length().
+        System.out.println(strBuilder.delete(3, 5));
+        // Test start = 0.
+        System.out.println(strBuilder.delete(0, 1));
+        // Test end = 0.
+        System.out.println(strBuilder.delete(0, 0));
+        // Test start=strBuffer.length().
+        System.out.println(strBuilder.delete(strBuilder.length(), strBuilder.length()));
+        // Test end=strBuffer.length().
+        System.out.println(strBuilder.delete(2, strBuilder.length()));
+    }
+    // Test method deleteCharAt(int index).
+    private static void test2(StringBuilder strBuilder) {
+        // Test 0 < index < strBuffer.length().
+        System.out.println(strBuilder.deleteCharAt(1));
+        // Test index = 0.
+        System.out.println(strBuilder.deleteCharAt(0));
+        // Test index = strBuffer.length()-1.
+        System.out.println(strBuilder.deleteCharAt(strBuilder.length() - 1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/expected.txt b/testsuite/java_test/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eddc3aea49e0fce935a0956369a14d37ad1740c1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/expected.txt
@@ -0,0 +1,25 @@
+qweyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+weyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+weyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+weyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+we
+ @!%()*
+@!%()*
+@!%()*
+@!%()*
+@!
+abc3abc
+bc3abc
+bc3abc
+bc3abc
+bc
+qertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x9
+ !.&%()*
+!.&%()*
+!.&%()
+ac123abc
+c123abc
+c123ab
+0
diff --git a/testsuite/java_test/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/test.cfg b/testsuite/java_test/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ed407fe8d2cc41956a51c40845dbb58e1874b7e3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderDeleteAndDeleteCharAtTest)
+run(StringBuilderDeleteAndDeleteCharAtTest)
diff --git a/testsuite/java_test/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/StringBuilderCodePointExceptionTest.java b/testsuite/java_test/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/StringBuilderCodePointExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..cdd2c55a64d0e8e905f956e6a891f19b0ff1bb68
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/StringBuilderCodePointExceptionTest.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderCodePointExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderCodePointExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderCodePointExceptionTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`123456789" +
+                "0-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+        test3(strBuilder1_1);
+        test3(strBuilder1_2);
+        test3(strBuilder1_3);
+        test4(strBuilder1_1);
+        test4(strBuilder1_2);
+        test4(strBuilder1_3);
+    }
+    // Test method codePointAt(int index).
+    private static void test1(StringBuilder strBuilder) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = strBuilder.codePointAt(i);
+                System.out.println("i=" + i + " " + "codePointAt=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointAt(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(strBuilder.charAt(i) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+    // Test method codePointBefore(int index).
+    private static void test2(StringBuilder strBuilder) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = strBuilder.codePointBefore(i);
+                System.out.println("i=" + i + " " + "codePointBefore=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointBefore(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(strBuilder.charAt(i - 1) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+    // Test method codePointCount(int beginIndex, int endIndex).
+    private static void test3(StringBuilder strBuilder) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = strBuilder.codePointCount(i, i + 3);
+                System.out.println("i=" + i + " " + "codePointCount=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("codePointCount(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(strBuilder.charAt(i) + "~" + strBuilder.charAt(i + 3)
+                            + " codePointCount is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println(i + " out of length");
+                }
+            }
+        }
+    }
+    // Test method int offsetByCodePoints(int index, int codePointOffset).
+    private static void test4(StringBuilder strBuilder) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = strBuilder.offsetByCodePoints(i, i + 3);
+                System.out.println("i=" + i + " " + "offsetByCodePoints=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("offsetByCodePoints(): " + i + "+3  out of length");
+            } finally {
+                try {
+                    System.out.println(strBuilder.charAt(i) + " offsetByCodePoints +3 is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fd0e884408537cba05c2fe7bf7455a5266848862
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/expected.txt
@@ -0,0 +1,121 @@
+i=0 codePointAt=113
+q Unicode is:113
+i=1 codePointAt=119
+w Unicode is:119
+i=2 codePointAt=101
+e Unicode is:101
+i=3 codePointAt=114
+r Unicode is:114
+i=4 codePointAt=116
+t Unicode is:116
+i=5 codePointAt=121
+y Unicode is:121
+i=0 codePointAt=32
+  Unicode is:32
+i=1 codePointAt=64
+@ Unicode is:64
+i=2 codePointAt=33
+! Unicode is:33
+i=3 codePointAt=46
+. Unicode is:46
+i=4 codePointAt=38
+& Unicode is:38
+i=5 codePointAt=37
+% Unicode is:37
+i=0 codePointAt=97
+a Unicode is:97
+i=1 codePointAt=98
+b Unicode is:98
+i=2 codePointAt=99
+c Unicode is:99
+i=3 codePointAt=49
+1 Unicode is:49
+i=4 codePointAt=50
+2 Unicode is:50
+i=5 codePointAt=51
+3 Unicode is:51
+codePointBefore(): 0out of length
+0 out of length
+i=1 codePointBefore=113
+q Unicode is:113
+i=2 codePointBefore=119
+w Unicode is:119
+i=3 codePointBefore=101
+e Unicode is:101
+i=4 codePointBefore=114
+r Unicode is:114
+i=5 codePointBefore=116
+t Unicode is:116
+codePointBefore(): 0out of length
+0 out of length
+i=1 codePointBefore=32
+  Unicode is:32
+i=2 codePointBefore=64
+@ Unicode is:64
+i=3 codePointBefore=33
+! Unicode is:33
+i=4 codePointBefore=46
+. Unicode is:46
+i=5 codePointBefore=38
+& Unicode is:38
+codePointBefore(): 0out of length
+0 out of length
+i=1 codePointBefore=97
+a Unicode is:97
+i=2 codePointBefore=98
+b Unicode is:98
+i=3 codePointBefore=99
+c Unicode is:99
+i=4 codePointBefore=49
+1 Unicode is:49
+i=5 codePointBefore=50
+2 Unicode is:50
+i=0 codePointCount=3
+q~r codePointCount is :3
+i=1 codePointCount=3
+w~t codePointCount is :3
+i=2 codePointCount=3
+e~y codePointCount is :3
+i=3 codePointCount=3
+r~u codePointCount is :3
+i=0 codePointCount=3
+ ~. codePointCount is :3
+i=1 codePointCount=3
+@~& codePointCount is :3
+i=2 codePointCount=3
+!~% codePointCount is :3
+i=3 codePointCount=3
+3 out of length
+i=0 codePointCount=3
+a~1 codePointCount is :3
+i=1 codePointCount=3
+b~2 codePointCount is :3
+i=2 codePointCount=3
+c~3 codePointCount is :3
+i=3 codePointCount=3
+3 out of length
+i=0 offsetByCodePoints=3
+q offsetByCodePoints +3 is :3
+i=1 offsetByCodePoints=5
+w offsetByCodePoints +3 is :5
+i=2 offsetByCodePoints=7
+e offsetByCodePoints +3 is :7
+i=3 offsetByCodePoints=9
+r offsetByCodePoints +3 is :9
+i=0 offsetByCodePoints=3
+  offsetByCodePoints +3 is :3
+i=1 offsetByCodePoints=5
+@ offsetByCodePoints +3 is :5
+offsetByCodePoints(): 2+3  out of length
+! offsetByCodePoints +3 is :5
+offsetByCodePoints(): 3+3  out of length
+. offsetByCodePoints +3 is :5
+i=0 offsetByCodePoints=3
+a offsetByCodePoints +3 is :3
+i=1 offsetByCodePoints=5
+b offsetByCodePoints +3 is :5
+offsetByCodePoints(): 2+3  out of length
+c offsetByCodePoints +3 is :5
+offsetByCodePoints(): 3+3  out of length
+1 offsetByCodePoints +3 is :5
+0
diff --git a/testsuite/java_test/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1fcc5ff570b6cf155b34eca30dcf0856ada373d3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0017-rt-String-BuilderCodePointExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderCodePointExceptionTest)
+run(StringBuilderCodePointExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/StringBuilderCapacityAndEnsureCapacityTest.java b/testsuite/java_test/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/StringBuilderCapacityAndEnsureCapacityTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8000bd6dae178779e200636d77b7ab22678a032
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/StringBuilderCapacityAndEnsureCapacityTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderCapacityAndEnsureCapacityTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderCapacityAndEnsureCapacityTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderCapacityAndEnsureCapacityTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+        test1(strBuilder1_5);
+    }
+    private static void test1(StringBuilder strBuilder) {
+        System.out.println("1-capacity: " + strBuilder.capacity());
+        System.out.println("1-lent: " + strBuilder.length());
+        strBuilder = strBuilder.append("01234567890123456789");
+        System.out.println("2-capacity: " + strBuilder.capacity());
+        System.out.println("2-lent: " + strBuilder.length());
+        strBuilder.ensureCapacity(80);
+        System.out.println("3-capacity: " + strBuilder.capacity());
+        System.out.println("3-lent: " + strBuilder.length());
+        strBuilder.setLength(100);
+        System.out.println("4-capacity: " + strBuilder.capacity());
+        System.out.println("4-lent: " + strBuilder.length());
+        strBuilder.trimToSize();
+        System.out.println("5-capacity: " + strBuilder.capacity());
+        System.out.println("5-lent: " + strBuilder.length());
+        strBuilder.ensureCapacity(-2);
+        System.out.println("6-capacity: " + strBuilder.capacity());
+        System.out.println("6-lent: " + strBuilder.length());
+        strBuilder.ensureCapacity(0);
+        System.out.println("7-capacity: " + strBuilder.capacity());
+        System.out.println("7-lent: " + strBuilder.length());
+        strBuilder.ensureCapacity(2);
+        System.out.println("8-capacity: " + strBuilder.capacity());
+        System.out.println("8-lent: " + strBuilder.length());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/expected.txt b/testsuite/java_test/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c48dadafe4dd4162136bb019b7323b25c8c9e36d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/expected.txt
@@ -0,0 +1,81 @@
+1-capacity: 115
+1-lent: 99
+2-capacity: 232
+2-lent: 119
+3-capacity: 232
+3-lent: 119
+4-capacity: 232
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+1-capacity: 25
+1-lent: 9
+2-capacity: 52
+2-lent: 29
+3-capacity: 106
+3-lent: 29
+4-capacity: 106
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+1-capacity: 22
+1-lent: 6
+2-capacity: 46
+2-lent: 26
+3-capacity: 94
+3-lent: 26
+4-capacity: 190
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+1-capacity: 16
+1-lent: 0
+2-capacity: 34
+2-lent: 20
+3-capacity: 80
+3-lent: 20
+4-capacity: 162
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+1-capacity: 16
+1-lent: 0
+2-capacity: 34
+2-lent: 20
+3-capacity: 80
+3-lent: 20
+4-capacity: 162
+4-lent: 100
+5-capacity: 100
+5-lent: 100
+6-capacity: 100
+6-lent: 100
+7-capacity: 100
+7-lent: 100
+8-capacity: 100
+8-lent: 100
+0
diff --git a/testsuite/java_test/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/test.cfg b/testsuite/java_test/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..26b400c0de1f99e2d5fb3c2d025269724a516f5d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderCapacityAndEnsureCapacityTest)
+run(StringBuilderCapacityAndEnsureCapacityTest)
diff --git a/testsuite/java_test/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/StringBuilderCharAtAndSetCharAtExceptionTest.java b/testsuite/java_test/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/StringBuilderCharAtAndSetCharAtExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..42d5f22deb94e0787d2fbcbcd1df4a2d29e3b198
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/StringBuilderCharAtAndSetCharAtExceptionTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderCharAtAndSetCharAtExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderCharAtAndSetCharAtExceptionTest_1();
+            StringBuilderCharAtAndSetCharAtExceptionTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderCharAtAndSetCharAtExceptionTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+    }
+    public static void StringBuilderCharAtAndSetCharAtExceptionTest_2() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+        test2(strBuilder1_4);
+    }
+    // Test method char charAt(int index).
+    private static void test1(StringBuilder strBuilder) {
+        int charAt = 0;
+        for (int i = -1; i < 8; i++) {
+            try {
+                charAt = strBuilder.charAt(i);
+                System.out.println("i=" + i + "  " + "charAt=" + charAt);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("index: " + i + "  String index out of range");
+            }
+        }
+    }
+    // Test Method void setCharAt(int index, char ch).
+    private static void test2(StringBuilder strBuilder) {
+        char ch = 'A';
+        for (int i = -1; i < 8; i++) {
+            try {
+                strBuilder.setCharAt(i, ch);
+                System.out.println("i=" + i + "  " + "setcharAt=" + strBuilder);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("index: " + i + "  String index out of range");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..840ff10d47566081b5877e2c900fcd39fa274d8d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/expected.txt
@@ -0,0 +1,73 @@
+index: -1  String index out of range
+i=0  charAt=113
+i=1  charAt=119
+i=2  charAt=101
+i=3  charAt=114
+i=4  charAt=116
+i=5  charAt=121
+i=6  charAt=117
+i=7  charAt=105
+index: -1  String index out of range
+i=0  charAt=32
+i=1  charAt=64
+i=2  charAt=33
+i=3  charAt=46
+i=4  charAt=38
+i=5  charAt=37
+i=6  charAt=40
+i=7  charAt=41
+index: -1  String index out of range
+i=0  charAt=97
+i=1  charAt=98
+i=2  charAt=99
+i=3  charAt=49
+i=4  charAt=50
+i=5  charAt=51
+index: 6  String index out of range
+index: 7  String index out of range
+index: -1  String index out of range
+index: 0  String index out of range
+index: 1  String index out of range
+index: 2  String index out of range
+index: 3  String index out of range
+index: 4  String index out of range
+index: 5  String index out of range
+index: 6  String index out of range
+index: 7  String index out of range
+index: -1  String index out of range
+i=0  setcharAt=Awertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=1  setcharAt=AAertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=2  setcharAt=AAArtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=3  setcharAt=AAAAtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=4  setcharAt=AAAAAyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=5  setcharAt=AAAAAAuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=6  setcharAt=AAAAAAAiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+i=7  setcharAt=AAAAAAAAop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+index: -1  String index out of range
+i=0  setcharAt=A@!.&%()*
+i=1  setcharAt=AA!.&%()*
+i=2  setcharAt=AAA.&%()*
+i=3  setcharAt=AAAA&%()*
+i=4  setcharAt=AAAAA%()*
+i=5  setcharAt=AAAAAA()*
+i=6  setcharAt=AAAAAAA)*
+i=7  setcharAt=AAAAAAAA*
+index: -1  String index out of range
+i=0  setcharAt=Abc123
+i=1  setcharAt=AAc123
+i=2  setcharAt=AAA123
+i=3  setcharAt=AAAA23
+i=4  setcharAt=AAAAA3
+i=5  setcharAt=AAAAAA
+index: 6  String index out of range
+index: 7  String index out of range
+index: -1  String index out of range
+index: 0  String index out of range
+index: 1  String index out of range
+index: 2  String index out of range
+index: 3  String index out of range
+index: 4  String index out of range
+index: 5  String index out of range
+index: 6  String index out of range
+index: 7  String index out of range
+0
diff --git a/testsuite/java_test/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3e0f46ac9397ad00a4bb53bd8d28360565bd8de8
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderCharAtAndSetCharAtExceptionTest)
+run(StringBuilderCharAtAndSetCharAtExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0020-rt-String-BuilderGetCharsTest/StringBuilderGetCharsTest.java b/testsuite/java_test/string_test/RT0020-rt-String-BuilderGetCharsTest/StringBuilderGetCharsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..32a6ddaf29dbe84a743b9e435080d0480094af60
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0020-rt-String-BuilderGetCharsTest/StringBuilderGetCharsTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderGetCharsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderGetCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderGetCharsTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123");
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+    }
+    private static void test1(StringBuilder strBuilder) {
+        // Test srcBegin  < srcEnd < instance.length, dstBegin < dst(char[]).length.
+        char[] dst = {'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(2, 5, dst, 2);
+        System.out.println(dst);
+        // Test srcBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(0, 3, dst, 2);
+        System.out.println(dst);
+        // Test srcEnd = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(0, 0, dst, 2);
+        System.out.println(dst);
+        // Test dstBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(2, 5, dst, 0);
+        System.out.println(dst);
+        // Test strBuilder = srcEnd.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(2, 2, dst, 0);
+        System.out.println(dst);
+        // Test srcBegin = strBuffer.length() - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        int index = strBuilder.length() - 1;
+        strBuilder.getChars(index, index, dst, 0);
+        System.out.println(dst);
+        // Test srcEnd = strBuffer.length() - 1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(index - 2, index, dst, 0);
+        System.out.println(dst);
+        // Test dstBegin = dst.length-1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        strBuilder.getChars(0, 1, dst, dst.length - 1);
+        System.out.println(dst);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0020-rt-String-BuilderGetCharsTest/expected.txt b/testsuite/java_test/string_test/RT0020-rt-String-BuilderGetCharsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c54226f3fc5f75d4cc44f30c2c2f705e3ac7dca5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0020-rt-String-BuilderGetCharsTest/expected.txt
@@ -0,0 +1,25 @@
+ABertF
+ABqweF
+ABCDEF
+ertDEF
+ABCDEF
+ABCDEF
+x9CDEF
+ABCDEq
+AB!.&F
+AB @!F
+ABCDEF
+!.&DEF
+ABCDEF
+ABCDEF
+()CDEF
+ABCDE 
+ABc12F
+ABabcF
+ABCDEF
+c12DEF
+ABCDEF
+ABCDEF
+12CDEF
+ABCDEa
+0
diff --git a/testsuite/java_test/string_test/RT0020-rt-String-BuilderGetCharsTest/test.cfg b/testsuite/java_test/string_test/RT0020-rt-String-BuilderGetCharsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e35051cf4d975ba901607b3f271aefc3e125d2d2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0020-rt-String-BuilderGetCharsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderGetCharsTest)
+run(StringBuilderGetCharsTest)
diff --git a/testsuite/java_test/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/StringBuilderIndexOfAndLastIndexOfTest.java b/testsuite/java_test/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/StringBuilderIndexOfAndLastIndexOfTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e7cd4b75cabc72cf1996a2c946a2038fd216d2d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/StringBuilderIndexOfAndLastIndexOfTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderIndexOfAndLastIndexOfTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderIndexOfAndLastIndexOfTest_1();
+            StringBuilderIndexOfAndLastIndexOfTest_2();
+            StringBuilderIndexOfAndLastIndexOfTest_3();
+            StringBuilderIndexOfAndLastIndexOfTest_4();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderIndexOfAndLastIndexOfTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test1(strBuilder1_4);
+        test1(strBuilder1_5);
+    }
+    public static void StringBuilderIndexOfAndLastIndexOfTest_2() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+        test2(strBuilder1_4);
+        test2(strBuilder1_5);
+    }
+    public static void StringBuilderIndexOfAndLastIndexOfTest_3() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test3(strBuilder1_1);
+        test3(strBuilder1_2);
+        test3(strBuilder1_3);
+        test3(strBuilder1_4);
+        test3(strBuilder1_5);
+    }
+    public static void StringBuilderIndexOfAndLastIndexOfTest_4() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test4(strBuilder1_1);
+        test4(strBuilder1_2);
+        test4(strBuilder1_3);
+        test4(strBuilder1_4);
+        test4(strBuilder1_5);
+    }
+    // Test method indexOf(String str).
+    private static void test1(StringBuilder strBuilder) {
+        System.out.println(strBuilder.indexOf("b"));
+        // Test empty String.
+        System.out.println(strBuilder.indexOf(""));
+    }
+    // Test method indexOf(String str, int fromIndex).
+    private static void test2(StringBuilder strBuilder) {
+        System.out.println(strBuilder.indexOf("b", 2));
+        // Test fromIndex = 0.
+        System.out.println(strBuilder.indexOf("b", 0));
+        // Test fromIndex = strBuilder.length() - 1.
+        System.out.println(strBuilder.indexOf("6", strBuilder.length() - 1));
+    }
+    // Test method lastIndexOf(String str).
+    private static void test3(StringBuilder strBuilder) {
+        System.out.println(strBuilder.lastIndexOf("b"));
+        // Test empty String.
+        System.out.println(strBuilder.lastIndexOf(""));
+    }
+    // Test method lastIndexOf(String str, int fromIndex).
+    private static void test4(StringBuilder strBuilder) {
+        System.out.println(strBuilder.lastIndexOf("b", 1));
+        // Test fromIndex = 0.
+        System.out.println(strBuilder.lastIndexOf("b", 0));
+        // Test fromIndex = strBuilder.length() - 1.
+        System.out.println(strBuilder.lastIndexOf("6", strBuilder.length() - 1));
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/expected.txt b/testsuite/java_test/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0066aba90dfe722d59df5941108f3589aeeff117
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/expected.txt
@@ -0,0 +1,51 @@
+33
+0
+-1
+0
+1
+0
+-1
+0
+-1
+0
+33
+33
+98
+-1
+-1
+-1
+7
+1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+33
+99
+-1
+9
+7
+9
+-1
+0
+-1
+0
+-1
+-1
+98
+-1
+-1
+-1
+1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/test.cfg b/testsuite/java_test/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..acc616177cae6a3a201c1d7d770e7d4909198539
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderIndexOfAndLastIndexOfTest)
+run(StringBuilderIndexOfAndLastIndexOfTest)
diff --git a/testsuite/java_test/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/StringBuilderReplaceAndReverseTest.java b/testsuite/java_test/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/StringBuilderReplaceAndReverseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f5d0798dd3462fdf10cc4f8011b07449c0ee4a1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/StringBuilderReplaceAndReverseTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderReplaceAndReverseTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderReplaceAndReverseTest_1();
+            StringBuilderReplaceAndReverseTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderReplaceAndReverseTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+    }
+    public static void StringBuilderReplaceAndReverseTest_2() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+        test2(strBuilder1_4);
+        test2(strBuilder1_5);
+    }
+    // Test method replace(int start, int end, String str).
+    private static void test1(StringBuilder strBuilder) {
+        System.out.println(strBuilder.replace(2, 6, "xyz"));
+        // end = 0
+        System.out.println(strBuilder.replace(0, 0, "xyz"));
+        // start = 0 & end = strBuffer.length()
+        System.out.println(strBuilder.replace(0, strBuilder.length(), "xyz"));
+        // start = strBuffer.length() & end = strBuffer.length()
+        System.out.println(strBuilder.replace(strBuilder.length(), strBuilder.length(), "xyz"));
+    }
+    // Test method reverse().
+    private static void test2(StringBuilder strBuilder) {
+        strBuilder.reverse();
+        System.out.println(strBuilder);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/expected.txt b/testsuite/java_test/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..92a847590bc368b34e8fc0ea0eeeac29ed5fa3b3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/expected.txt
@@ -0,0 +1,18 @@
+qwxyzuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+xyzqwxyzuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+xyz
+xyzxyz
+ @xyz
+xyz @xyz
+xyz
+xyzxyz
+abxyzabc
+xyzabxyzabc
+xyz
+xyzxyz
+69x0MNBVCXZPOIUYTREWQLKJHGFDSA +_)(*&^%$#@!=-0987654321`~?/><.,mnbvcxz"':;lkjhgfdsa|\][}{poiuytrewq
+%&.!@ 
+cba321cba
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/test.cfg b/testsuite/java_test/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..66e615941e1032a559820977c9f5d128ab55fbf6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0022-rt-String-BuilderReplaceAndReverseTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderReplaceAndReverseTest)
+run(StringBuilderReplaceAndReverseTest)
diff --git a/testsuite/java_test/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/StringBuilderSubstringAndToStringTest.java b/testsuite/java_test/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/StringBuilderSubstringAndToStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..81b210bd4a50f6fd1d08acb62183174914b78a21
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/StringBuilderSubstringAndToStringTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderSubstringAndToStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringBuilderSubstringAndToStringTest_1();
+            StringBuilderSubstringAndToStringTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringBuilderSubstringAndToStringTest_1() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%()*");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        test1(strBuilder1_1);
+        test1(strBuilder1_2);
+        test1(strBuilder1_3);
+        test2(strBuilder1_1);
+        test2(strBuilder1_2);
+        test2(strBuilder1_3);
+    }
+    public static void StringBuilderSubstringAndToStringTest_2() {
+        StringBuilder strBuilder1_1 = new StringBuilder("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890" +
+                "-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        StringBuilder strBuilder1_2 = new StringBuilder(" @!.&%");
+        StringBuilder strBuilder1_3 = new StringBuilder("abc123abc");
+        StringBuilder strBuilder1_4 = new StringBuilder("");
+        StringBuilder strBuilder1_5 = new StringBuilder();
+        test3(strBuilder1_1);
+        test3(strBuilder1_2);
+        test3(strBuilder1_3);
+        test3(strBuilder1_4);
+        test3(strBuilder1_5);
+    }
+    // Test method substring(int start, int end).
+    private static void test1(StringBuilder strBuilder) {
+        System.out.println(strBuilder.substring(2, 7));
+        // Test start = 0 & end = strBuffer.length().
+        System.out.println(strBuilder.substring(0, strBuilder.length()));
+        // Test start = strBuffer.length().
+        System.out.println(strBuilder.substring(strBuilder.length(), strBuilder.length()));
+        // Test end = 0.
+        System.out.println(strBuilder.substring(0, 0));
+    }
+    // Test method substring(int start).
+    private static void test2(StringBuilder strBuilder) {
+        System.out.println(strBuilder.substring(3));
+        // Test start = 0.
+        System.out.println(strBuilder.substring(0));
+        // Test start = strBuffer.length().
+        System.out.println(strBuilder.substring(strBuilder.length()));
+    }
+    // Test method toString().
+    private static void test3(StringBuilder strBuilder) {
+        System.out.println(strBuilder.toString());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/expected.txt b/testsuite/java_test/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..341d348f0ed007510ecf6f11c43ef25541d860fa
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/expected.txt
@@ -0,0 +1,27 @@
+ertyu
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+
+!.&%(
+ @!.&%()*
+
+
+c123a
+abc123abc
+
+
+rtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+.&%()*
+ @!.&%()*
+
+123abc
+abc123abc
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+abc123abc
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/test.cfg b/testsuite/java_test/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..53fc9f9cc71ed95552ad4248dde8368eeae8d5af
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0023-rt-String-BuilderSubstringAndToStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderSubstringAndToStringTest)
+run(StringBuilderSubstringAndToStringTest)
diff --git a/testsuite/java_test/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..95525144409d491d53f442cda1c32a5e17545600
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsBytesIntIntIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            result = StringConsBytesIntIntIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringConsBytesIntIntIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success*/
+
+        // IndexOutOfBoundsException - If the offset and length arguments index characters outside the bounds of the
+        // bytes array
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, -1, 3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 3, -1);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 3, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f20886c2464294a6db515595c1220619523a3d1c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesIntIntIndexOutOfBoundsExceptionTest)
+run(StringConsBytesIntIntIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/StringConsCharArrayIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/StringConsCharArrayIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c5f86ee5164100c776604bebbd088167aa1eb73
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/StringConsCharArrayIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsCharArrayIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            result = StringConsCharArrayIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringConsCharArrayIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success*/
+
+        // IndexOutOfBoundsException - If the offset and length arguments index characters outside the bounds of the
+        // bytes array
+        char[] str1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        try {
+            String str1 = new String(str1_1, -1, 3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str2 = new String(str1_1, 0, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..432095fbc5fb2ed1bce6f6540328656ed949c660
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsCharArrayIndexOutOfBoundsExceptionTest)
+run(StringConsCharArrayIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/StringConsIntArrayExceptionsTest.java b/testsuite/java_test/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/StringConsIntArrayExceptionsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b46cc9f41094723dadc1991c624a1c06be7af76b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/StringConsIntArrayExceptionsTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsIntArrayExceptionsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            result = StringConsIntArrayExceptionsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringConsIntArrayExceptionsTest_1() {
+        int result1 = 2; /* STATUS_Success*/
+
+        // IndexOutOfBoundsException - If the offset and count arguments index characters outside the bounds of the
+        // codePoints array
+        int[] str1_1 = new int[]{97, 98, 99, 49, 50, 51};
+        try {
+            String str1 = new String(str1_1, -1, str1_1.length);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 0, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        //IllegalArgumentException - If any invalid Unicode code point is found in codePoints
+        int[] str1_2 = new int[]{0xFFFFFFF, 0x62, 0x63, 0x31, 0x32, 0x33};
+        try {
+            String str2 = new String(str1_2, 0, str1_2.length);
+            processResult -= 10;
+        } catch (IllegalArgumentException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/expected.txt b/testsuite/java_test/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/test.cfg b/testsuite/java_test/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e6f6da2f784a8d0d3609d52b37fcfc863bf6f558
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0026-rt-String-ConsIntArrayExceptionsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsIntArrayExceptionsTest)
+run(StringConsIntArrayExceptionsTest)
diff --git a/testsuite/java_test/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c823688f582bd301bb947a81341f7e039e06d9a6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            result = StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success*/
+
+        // IndexOutOfBoundsException - If the offset and count arguments index characters outside the bounds of the
+        // codePoints array
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, 0, -1, 2);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 0, 0, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5305af2b81553a881a6c2584e24e09b6f3885d0a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest)
+run(StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/StringConsBytesIntIntCharsetExceptionTest.java b/testsuite/java_test/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/StringConsBytesIntIntCharsetExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8eeb9ee07e883aa4e0d0989d43fad4a97968b79
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/StringConsBytesIntIntCharsetExceptionTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.charset.Charset;
+public class StringConsBytesIntIntCharsetExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            result = StringConsBytesIntIntCharsetExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 96) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringConsBytesIntIntCharsetExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success*/
+
+        // IndexOutOfBoundsException - If the offset and length arguments index characters outside the bounds of the
+        // bytes array
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, -1, 3, Charset.forName("ASCII"));
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 3, -1, Charset.forName("ASCII"));
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String str1 = new String(str1_1, 3, 10, Charset.forName("ASCII"));
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..72bc7413633299cd511af161c071593a0c2f6b94
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesIntIntCharsetExceptionTest)
+run(StringConsBytesIntIntCharsetExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/StringCharAtIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/StringCharAtIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..11262f28df1e3a737cda9fe905fce84808d1508b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/StringCharAtIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCharAtIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            result = StringCharAtIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringCharAtIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success*/
+
+        // IndexOutOfBoundsException - if the index argument is negative or not less than the length of this string.
+        String str1_1 = new String("abc123");
+        String str1_4 = new String("");
+        try {
+            char ch = str1_1.charAt(-2);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            char ch = str1_4.charAt(2);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ca186e491e692d521c342fab9512c66905e457e8
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCharAtIndexOutOfBoundsExceptionTest)
+run(StringCharAtIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/StringCodePointAtStringIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/StringCodePointAtStringIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ddccd14c64afc14609629fe57967455f237043d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/StringCodePointAtStringIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCodePointAtStringIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCodePointAtStringIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCodePointAtStringIndexOutOfBoundsExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = -1; i < 7; i++) {
+            try {
+                codePoint = str.codePointAt(i);
+                System.out.println("i=" + i + " " + "codePointAt=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointAt(): " + i + " StringIndexOutOfBounds");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " StringIndexOutOfBounds");
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..82c4ad5c5b198fa0b76395ea3353e6d091fd4a04
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1,145 @@
+codePointAt(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointAt=113
+q Unicode is:113
+i=1 codePointAt=119
+w Unicode is:119
+i=2 codePointAt=101
+e Unicode is:101
+i=3 codePointAt=114
+r Unicode is:114
+i=4 codePointAt=116
+t Unicode is:116
+i=5 codePointAt=121
+y Unicode is:121
+i=6 codePointAt=117
+u Unicode is:117
+codePointAt(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointAt=32
+  Unicode is:32
+i=1 codePointAt=64
+@ Unicode is:64
+i=2 codePointAt=33
+! Unicode is:33
+i=3 codePointAt=46
+. Unicode is:46
+i=4 codePointAt=38
+& Unicode is:38
+i=5 codePointAt=37
+% Unicode is:37
+codePointAt(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+codePointAt(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointAt=97
+a Unicode is:97
+i=1 codePointAt=98
+b Unicode is:98
+i=2 codePointAt=99
+c Unicode is:99
+i=3 codePointAt=49
+1 Unicode is:49
+i=4 codePointAt=50
+2 Unicode is:50
+i=5 codePointAt=51
+3 Unicode is:51
+codePointAt(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+codePointAt(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointAt(): 0 StringIndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+codePointAt(): 1 StringIndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+codePointAt(): 2 StringIndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+codePointAt(): 3 StringIndexOutOfBounds
+charAt(): 3 StringIndexOutOfBounds
+codePointAt(): 4 StringIndexOutOfBounds
+charAt(): 4 StringIndexOutOfBounds
+codePointAt(): 5 StringIndexOutOfBounds
+charAt(): 5 StringIndexOutOfBounds
+codePointAt(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+codePointAt(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointAt(): 0 StringIndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+codePointAt(): 1 StringIndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+codePointAt(): 2 StringIndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+codePointAt(): 3 StringIndexOutOfBounds
+charAt(): 3 StringIndexOutOfBounds
+codePointAt(): 4 StringIndexOutOfBounds
+charAt(): 4 StringIndexOutOfBounds
+codePointAt(): 5 StringIndexOutOfBounds
+charAt(): 5 StringIndexOutOfBounds
+codePointAt(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+codePointAt(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointAt=113
+q Unicode is:113
+i=1 codePointAt=119
+w Unicode is:119
+i=2 codePointAt=101
+e Unicode is:101
+i=3 codePointAt=114
+r Unicode is:114
+i=4 codePointAt=116
+t Unicode is:116
+i=5 codePointAt=121
+y Unicode is:121
+i=6 codePointAt=117
+u Unicode is:117
+codePointAt(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointAt=32
+  Unicode is:32
+i=1 codePointAt=64
+@ Unicode is:64
+i=2 codePointAt=33
+! Unicode is:33
+i=3 codePointAt=46
+. Unicode is:46
+i=4 codePointAt=38
+& Unicode is:38
+i=5 codePointAt=37
+% Unicode is:37
+codePointAt(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+codePointAt(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointAt=97
+a Unicode is:97
+i=1 codePointAt=98
+b Unicode is:98
+i=2 codePointAt=99
+c Unicode is:99
+i=3 codePointAt=49
+1 Unicode is:49
+i=4 codePointAt=50
+2 Unicode is:50
+i=5 codePointAt=51
+3 Unicode is:51
+codePointAt(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+codePointAt(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointAt(): 0 StringIndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+codePointAt(): 1 StringIndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+codePointAt(): 2 StringIndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+codePointAt(): 3 StringIndexOutOfBounds
+charAt(): 3 StringIndexOutOfBounds
+codePointAt(): 4 StringIndexOutOfBounds
+charAt(): 4 StringIndexOutOfBounds
+codePointAt(): 5 StringIndexOutOfBounds
+charAt(): 5 StringIndexOutOfBounds
+codePointAt(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+0
diff --git a/testsuite/java_test/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7d737647d6e02e23fd19224ba93d3da9cbacb131
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCodePointAtStringIndexOutOfBoundsExceptionTest)
+run(StringCodePointAtStringIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/StringCodePointBeforeExceptionTest.java b/testsuite/java_test/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/StringCodePointBeforeExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7355cfd0152d48354fd553f33163973d975c1ee3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/StringCodePointBeforeExceptionTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCodePointBeforeExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCodePointBeforeExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCodePointBeforeExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = -1; i < 7; i++) {
+            try {
+                codePoint = str.codePointBefore(i);
+                System.out.println("i=" + i + " " + "codePointBefore=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointBefore(): " + i + " StringIndexOutOfBounds");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " codePointBefore is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " StringIndexOutOfBounds");
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f8b265104192824f2dcf322aa848e9c27c2359b1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/expected.txt
@@ -0,0 +1,145 @@
+codePointBefore(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointBefore(): 0 StringIndexOutOfBounds
+q codePointBefore is:0
+i=1 codePointBefore=113
+w codePointBefore is:113
+i=2 codePointBefore=119
+e codePointBefore is:119
+i=3 codePointBefore=101
+r codePointBefore is:101
+i=4 codePointBefore=114
+t codePointBefore is:114
+i=5 codePointBefore=116
+y codePointBefore is:116
+i=6 codePointBefore=121
+u codePointBefore is:121
+codePointBefore(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointBefore(): 0 StringIndexOutOfBounds
+  codePointBefore is:0
+i=1 codePointBefore=32
+@ codePointBefore is:32
+i=2 codePointBefore=64
+! codePointBefore is:64
+i=3 codePointBefore=33
+. codePointBefore is:33
+i=4 codePointBefore=46
+& codePointBefore is:46
+i=5 codePointBefore=38
+% codePointBefore is:38
+i=6 codePointBefore=37
+charAt(): 6 StringIndexOutOfBounds
+codePointBefore(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointBefore(): 0 StringIndexOutOfBounds
+a codePointBefore is:0
+i=1 codePointBefore=97
+b codePointBefore is:97
+i=2 codePointBefore=98
+c codePointBefore is:98
+i=3 codePointBefore=99
+1 codePointBefore is:99
+i=4 codePointBefore=49
+2 codePointBefore is:49
+i=5 codePointBefore=50
+3 codePointBefore is:50
+i=6 codePointBefore=51
+charAt(): 6 StringIndexOutOfBounds
+codePointBefore(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointBefore(): 0 StringIndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+codePointBefore(): 1 StringIndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+codePointBefore(): 2 StringIndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+codePointBefore(): 3 StringIndexOutOfBounds
+charAt(): 3 StringIndexOutOfBounds
+codePointBefore(): 4 StringIndexOutOfBounds
+charAt(): 4 StringIndexOutOfBounds
+codePointBefore(): 5 StringIndexOutOfBounds
+charAt(): 5 StringIndexOutOfBounds
+codePointBefore(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+codePointBefore(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointBefore(): 0 StringIndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+codePointBefore(): 1 StringIndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+codePointBefore(): 2 StringIndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+codePointBefore(): 3 StringIndexOutOfBounds
+charAt(): 3 StringIndexOutOfBounds
+codePointBefore(): 4 StringIndexOutOfBounds
+charAt(): 4 StringIndexOutOfBounds
+codePointBefore(): 5 StringIndexOutOfBounds
+charAt(): 5 StringIndexOutOfBounds
+codePointBefore(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+codePointBefore(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointBefore(): 0 StringIndexOutOfBounds
+q codePointBefore is:0
+i=1 codePointBefore=113
+w codePointBefore is:113
+i=2 codePointBefore=119
+e codePointBefore is:119
+i=3 codePointBefore=101
+r codePointBefore is:101
+i=4 codePointBefore=114
+t codePointBefore is:114
+i=5 codePointBefore=116
+y codePointBefore is:116
+i=6 codePointBefore=121
+u codePointBefore is:121
+codePointBefore(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointBefore(): 0 StringIndexOutOfBounds
+  codePointBefore is:0
+i=1 codePointBefore=32
+@ codePointBefore is:32
+i=2 codePointBefore=64
+! codePointBefore is:64
+i=3 codePointBefore=33
+. codePointBefore is:33
+i=4 codePointBefore=46
+& codePointBefore is:46
+i=5 codePointBefore=38
+% codePointBefore is:38
+i=6 codePointBefore=37
+charAt(): 6 StringIndexOutOfBounds
+codePointBefore(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointBefore(): 0 StringIndexOutOfBounds
+a codePointBefore is:0
+i=1 codePointBefore=97
+b codePointBefore is:97
+i=2 codePointBefore=98
+c codePointBefore is:98
+i=3 codePointBefore=99
+1 codePointBefore is:99
+i=4 codePointBefore=49
+2 codePointBefore is:49
+i=5 codePointBefore=50
+3 codePointBefore is:50
+i=6 codePointBefore=51
+charAt(): 6 StringIndexOutOfBounds
+codePointBefore(): -1 StringIndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointBefore(): 0 StringIndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+codePointBefore(): 1 StringIndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+codePointBefore(): 2 StringIndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+codePointBefore(): 3 StringIndexOutOfBounds
+charAt(): 3 StringIndexOutOfBounds
+codePointBefore(): 4 StringIndexOutOfBounds
+charAt(): 4 StringIndexOutOfBounds
+codePointBefore(): 5 StringIndexOutOfBounds
+charAt(): 5 StringIndexOutOfBounds
+codePointBefore(): 6 StringIndexOutOfBounds
+charAt(): 6 StringIndexOutOfBounds
+0
diff --git a/testsuite/java_test/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..23c05ce95039d99c4c0c9e713d4d77fd501c9894
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0031-rt-String-CodePointBeforeExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCodePointBeforeExceptionTest)
+run(StringCodePointBeforeExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/StringCodePointCountIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/StringCodePointCountIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..359f688ca56d546e5ba638bf5233d5ea6f52bb54
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/StringCodePointCountIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCodePointCountIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCodePointCountIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCodePointCountIndexOutOfBoundsExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = -1; i < 5; i++) {
+            try {
+                codePoint = str.codePointCount(i, i + 3);
+                System.out.println("i=" + i + " " + "codePointCount=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("codePointCount(): " + i + " IndexOutOfBounds");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " codePointCount is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " StringIndexOutOfBounds");
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..70bb71f70ea846d68f87bbe6c1a50969e6f89c09
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1,109 @@
+codePointCount(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointCount=3
+q codePointCount is :3
+i=1 codePointCount=3
+w codePointCount is :3
+i=2 codePointCount=3
+e codePointCount is :3
+i=3 codePointCount=3
+r codePointCount is :3
+i=4 codePointCount=3
+t codePointCount is :3
+codePointCount(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointCount=3
+  codePointCount is :3
+i=1 codePointCount=3
+@ codePointCount is :3
+i=2 codePointCount=3
+! codePointCount is :3
+i=3 codePointCount=3
+. codePointCount is :3
+codePointCount(): 4 IndexOutOfBounds
+& codePointCount is :3
+codePointCount(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointCount=3
+a codePointCount is :3
+i=1 codePointCount=3
+b codePointCount is :3
+i=2 codePointCount=3
+c codePointCount is :3
+i=3 codePointCount=3
+1 codePointCount is :3
+codePointCount(): 4 IndexOutOfBounds
+2 codePointCount is :3
+codePointCount(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointCount(): 0 IndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+codePointCount(): 1 IndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+codePointCount(): 2 IndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+codePointCount(): 3 IndexOutOfBounds
+charAt(): 3 StringIndexOutOfBounds
+codePointCount(): 4 IndexOutOfBounds
+charAt(): 4 StringIndexOutOfBounds
+codePointCount(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointCount(): 0 IndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+codePointCount(): 1 IndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+codePointCount(): 2 IndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+codePointCount(): 3 IndexOutOfBounds
+charAt(): 3 StringIndexOutOfBounds
+codePointCount(): 4 IndexOutOfBounds
+charAt(): 4 StringIndexOutOfBounds
+codePointCount(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointCount=3
+q codePointCount is :3
+i=1 codePointCount=3
+w codePointCount is :3
+i=2 codePointCount=3
+e codePointCount is :3
+i=3 codePointCount=3
+r codePointCount is :3
+i=4 codePointCount=3
+t codePointCount is :3
+codePointCount(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointCount=3
+  codePointCount is :3
+i=1 codePointCount=3
+@ codePointCount is :3
+i=2 codePointCount=3
+! codePointCount is :3
+i=3 codePointCount=3
+. codePointCount is :3
+codePointCount(): 4 IndexOutOfBounds
+& codePointCount is :3
+codePointCount(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 codePointCount=3
+a codePointCount is :3
+i=1 codePointCount=3
+b codePointCount is :3
+i=2 codePointCount=3
+c codePointCount is :3
+i=3 codePointCount=3
+1 codePointCount is :3
+codePointCount(): 4 IndexOutOfBounds
+2 codePointCount is :3
+codePointCount(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+codePointCount(): 0 IndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+codePointCount(): 1 IndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+codePointCount(): 2 IndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+codePointCount(): 3 IndexOutOfBounds
+charAt(): 3 StringIndexOutOfBounds
+codePointCount(): 4 IndexOutOfBounds
+charAt(): 4 StringIndexOutOfBounds
+0
diff --git a/testsuite/java_test/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..27f4f8a065ecdc0096337173b315ce837758e462
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCodePointCountIndexOutOfBoundsExceptionTest)
+run(StringCodePointCountIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/StringOffsetByCodePointsIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/StringOffsetByCodePointsIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4acc5aa5b561e50c4de6649ce0f31e8321514949
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/StringOffsetByCodePointsIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringOffsetByCodePointsIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringOffsetByCodePointsIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringOffsetByCodePointsIndexOutOfBoundsExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = -1; i < 3; i++) {
+            try {
+                codePoint = str.offsetByCodePoints(i, i + 3);
+                System.out.println("i=" + i + " " + "offsetByCodePoints=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("offsetByCodePoints(): " + i + " IndexOutOfBounds");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " offsetByCodePoints is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " StringIndexOutOfBounds");
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4851ab144186d741bfd946f7b072b33da962a988
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1,73 @@
+offsetByCodePoints(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 offsetByCodePoints=3
+q offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+w offsetByCodePoints is :5
+i=2 offsetByCodePoints=7
+e offsetByCodePoints is :7
+offsetByCodePoints(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 offsetByCodePoints=3
+  offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+@ offsetByCodePoints is :5
+offsetByCodePoints(): 2 IndexOutOfBounds
+! offsetByCodePoints is :5
+offsetByCodePoints(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 offsetByCodePoints=3
+a offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+b offsetByCodePoints is :5
+offsetByCodePoints(): 2 IndexOutOfBounds
+c offsetByCodePoints is :5
+offsetByCodePoints(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+offsetByCodePoints(): 0 IndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+offsetByCodePoints(): 1 IndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+offsetByCodePoints(): 2 IndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+offsetByCodePoints(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+offsetByCodePoints(): 0 IndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+offsetByCodePoints(): 1 IndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+offsetByCodePoints(): 2 IndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+offsetByCodePoints(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 offsetByCodePoints=3
+q offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+w offsetByCodePoints is :5
+i=2 offsetByCodePoints=7
+e offsetByCodePoints is :7
+offsetByCodePoints(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 offsetByCodePoints=3
+  offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+@ offsetByCodePoints is :5
+offsetByCodePoints(): 2 IndexOutOfBounds
+! offsetByCodePoints is :5
+offsetByCodePoints(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+i=0 offsetByCodePoints=3
+a offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+b offsetByCodePoints is :5
+offsetByCodePoints(): 2 IndexOutOfBounds
+c offsetByCodePoints is :5
+offsetByCodePoints(): -1 IndexOutOfBounds
+charAt(): -1 StringIndexOutOfBounds
+offsetByCodePoints(): 0 IndexOutOfBounds
+charAt(): 0 StringIndexOutOfBounds
+offsetByCodePoints(): 1 IndexOutOfBounds
+charAt(): 1 StringIndexOutOfBounds
+offsetByCodePoints(): 2 IndexOutOfBounds
+charAt(): 2 StringIndexOutOfBounds
+0
diff --git a/testsuite/java_test/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..be8d9890a414176fb729e3b319912f564b3d659f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringOffsetByCodePointsIndexOutOfBoundsExceptionTest)
+run(StringOffsetByCodePointsIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0034-rt-String-GetCharsExceptionsTest/StringGetCharsExceptionsTest.java b/testsuite/java_test/string_test/RT0034-rt-String-GetCharsExceptionsTest/StringGetCharsExceptionsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..14a9afb1530209abeeeb507f4d9f5c7e985fe06a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0034-rt-String-GetCharsExceptionsTest/StringGetCharsExceptionsTest.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringGetCharsExceptionsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringGetCharsExceptionsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringGetCharsExceptionsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        char dst1_1[] = null;
+        try {
+            str.getChars(2, 5, dst1_1, 2);
+        } catch (NullPointerException e1) {
+            System.out.println("EXCEPTION 1_1");
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_2");
+        } finally {
+            try {
+                System.out.println(dst1_1);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 1_3");
+            }
+        }
+        char dst1_2[] = {'A', 'B', 'C', 'D', 'E'};
+        try {
+            str.getChars(-1, 5, dst1_2, 2);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 2_1");
+        } finally {
+            try {
+                System.out.println(dst1_2);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 2_2");
+            }
+        }
+        char dst1_3[] = {'A', 'B', 'C', 'D', 'E'};
+        try {
+            str.getChars(2, 6, dst1_3, 2);
+        } catch (ArrayIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 3_1");
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 3_2");
+        } finally {
+            try {
+                System.out.println(dst1_3);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 3_3");
+            }
+        }
+        char dst1_4[] = {'A', 'B', 'C', 'D', 'E'};
+        try {
+            str.getChars(4, 3, dst1_4, 2);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 4_1");
+        } finally {
+            try {
+                System.out.println(dst1_4);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 4_2");
+            }
+        }
+        char dst1_5[] = {'A', 'B', 'C', 'D', 'E'};
+        try {
+            str.getChars(4, 3, dst1_5, -1);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 5_1");
+        } finally {
+            try {
+                System.out.println(dst1_5);
+            } catch (NullPointerException e2) {
+                System.out.println("EXCEPTION 5_2");
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0034-rt-String-GetCharsExceptionsTest/expected.txt b/testsuite/java_test/string_test/RT0034-rt-String-GetCharsExceptionsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f3481b4151c8b6fcff2576b898b08b4aa05d4e92
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0034-rt-String-GetCharsExceptionsTest/expected.txt
@@ -0,0 +1,81 @@
+EXCEPTION 1_1
+EXCEPTION 1_3
+EXCEPTION 2_1
+ABCDE
+EXCEPTION 3_1
+ABCDE
+EXCEPTION 4_1
+ABCDE
+EXCEPTION 5_1
+ABCDE
+EXCEPTION 1_1
+EXCEPTION 1_3
+EXCEPTION 2_1
+ABCDE
+EXCEPTION 3_1
+ABCDE
+EXCEPTION 4_1
+ABCDE
+EXCEPTION 5_1
+ABCDE
+EXCEPTION 1_1
+EXCEPTION 1_3
+EXCEPTION 2_1
+ABCDE
+EXCEPTION 3_1
+ABCDE
+EXCEPTION 4_1
+ABCDE
+EXCEPTION 5_1
+ABCDE
+EXCEPTION 1_1
+EXCEPTION 1_3
+EXCEPTION 2_1
+ABCDE
+EXCEPTION 3_2
+ABCDE
+EXCEPTION 4_1
+ABCDE
+EXCEPTION 5_1
+ABCDE
+EXCEPTION 1_1
+EXCEPTION 1_3
+EXCEPTION 2_1
+ABCDE
+EXCEPTION 3_2
+ABCDE
+EXCEPTION 4_1
+ABCDE
+EXCEPTION 5_1
+ABCDE
+EXCEPTION 1_1
+EXCEPTION 1_3
+EXCEPTION 2_1
+ABCDE
+EXCEPTION 3_1
+ABCDE
+EXCEPTION 4_1
+ABCDE
+EXCEPTION 5_1
+ABCDE
+EXCEPTION 1_1
+EXCEPTION 1_3
+EXCEPTION 2_1
+ABCDE
+EXCEPTION 3_1
+ABCDE
+EXCEPTION 4_1
+ABCDE
+EXCEPTION 5_1
+ABCDE
+EXCEPTION 1_1
+EXCEPTION 1_3
+EXCEPTION 2_1
+ABCDE
+EXCEPTION 3_1
+ABCDE
+EXCEPTION 4_1
+ABCDE
+EXCEPTION 5_1
+ABCDE
+0
diff --git a/testsuite/java_test/string_test/RT0034-rt-String-GetCharsExceptionsTest/test.cfg b/testsuite/java_test/string_test/RT0034-rt-String-GetCharsExceptionsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a4d46601e6784c4e273fb45a20e60e9630a7c83a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0034-rt-String-GetCharsExceptionsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGetCharsExceptionsTest)
+run(StringGetCharsExceptionsTest)
diff --git a/testsuite/java_test/string_test/RT0035-rt-String-GetBytesExceptionTest/StringGetBytesExceptionTest.java b/testsuite/java_test/string_test/RT0035-rt-String-GetBytesExceptionTest/StringGetBytesExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0f87ac91bcb98291e24bb3f8be0a47f2ec2ca49
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0035-rt-String-GetBytesExceptionTest/StringGetBytesExceptionTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringGetBytesExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringGetBytesExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringGetBytesExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        byte[] dst1_1 = null;
+        try {
+            str.getBytes(2, 5, dst1_1, 2);
+            String str_new = new String(dst1_1);
+        } catch (NullPointerException e1) {
+            System.out.println("EXCEPTION 1_1");
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_2");
+        }
+        byte[] dst1_2 = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        try {
+            str.getBytes(-1, 5, dst1_2, 2);
+            String str_new = new String(dst1_2);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 2_1");
+        }
+        // if (srcEnd > length()) ...throw new StringIndexOutOfBoundsException(this, srcEnd);
+        byte[] dst1_3 = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        try {
+            str.getBytes(2, 6, dst1_3, 2);
+            String str_new = new String(dst1_3);
+        } catch (ArrayIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 3_1");
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 3_2");
+        }
+        byte[] dst1_4 = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        try {
+            str.getBytes(4, 3, dst1_4, 2);
+            String str_new = new String(dst1_4);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 4_1");
+        }
+        byte[] dst1_5 = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        try {
+            str.getBytes(4, 3, dst1_5, -1);
+            String str_new = new String(dst1_5);
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 5_1");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0035-rt-String-GetBytesExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0035-rt-String-GetBytesExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4ec7e3e161a58aa1192b6551316e696977428e13
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0035-rt-String-GetBytesExceptionTest/expected.txt
@@ -0,0 +1,35 @@
+EXCEPTION 1_1
+EXCEPTION 2_1
+EXCEPTION 4_1
+EXCEPTION 5_1
+EXCEPTION 1_1
+EXCEPTION 2_1
+EXCEPTION 4_1
+EXCEPTION 5_1
+EXCEPTION 1_1
+EXCEPTION 2_1
+EXCEPTION 4_1
+EXCEPTION 5_1
+EXCEPTION 1_2
+EXCEPTION 2_1
+EXCEPTION 3_2
+EXCEPTION 4_1
+EXCEPTION 5_1
+EXCEPTION 1_2
+EXCEPTION 2_1
+EXCEPTION 3_2
+EXCEPTION 4_1
+EXCEPTION 5_1
+EXCEPTION 1_1
+EXCEPTION 2_1
+EXCEPTION 4_1
+EXCEPTION 5_1
+EXCEPTION 1_1
+EXCEPTION 2_1
+EXCEPTION 4_1
+EXCEPTION 5_1
+EXCEPTION 1_1
+EXCEPTION 2_1
+EXCEPTION 4_1
+EXCEPTION 5_1
+0
diff --git a/testsuite/java_test/string_test/RT0035-rt-String-GetBytesExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0035-rt-String-GetBytesExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b3ab7c8d0edf252880e3aa7f8bbee3a5946d80af
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0035-rt-String-GetBytesExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGetBytesExceptionTest)
+run(StringGetBytesExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/StringSubstringStringIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/StringSubstringStringIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..3bbbe894120c37b3ed8e637e03020865c150c32a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/StringSubstringStringIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringSubstringStringIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringSubstringStringIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringSubstringStringIndexOutOfBoundsExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        for (int i = -1; i < 8; i++) {
+            try {
+                System.out.println("beginIndex= " + i);
+                String dst1_1 = str.substring(i);
+                System.out.println(dst1_1);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("StringIndexOutOfBounds 1_1");
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..07168492e8d762a7f1d5f3de9b3a8125df9bacc4
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1,163 @@
+beginIndex= -1
+StringIndexOutOfBounds 1_1
+beginIndex= 0
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 1
+wertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 2
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 3
+rtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 4
+tyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 5
+yuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 6
+uiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 7
+iop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= -1
+StringIndexOutOfBounds 1_1
+beginIndex= 0
+ @!.&%
+beginIndex= 1
+@!.&%
+beginIndex= 2
+!.&%
+beginIndex= 3
+.&%
+beginIndex= 4
+&%
+beginIndex= 5
+%
+beginIndex= 6
+
+beginIndex= 7
+StringIndexOutOfBounds 1_1
+beginIndex= -1
+StringIndexOutOfBounds 1_1
+beginIndex= 0
+abc123
+beginIndex= 1
+bc123
+beginIndex= 2
+c123
+beginIndex= 3
+123
+beginIndex= 4
+23
+beginIndex= 5
+3
+beginIndex= 6
+
+beginIndex= 7
+StringIndexOutOfBounds 1_1
+beginIndex= -1
+StringIndexOutOfBounds 1_1
+beginIndex= 0
+
+beginIndex= 1
+StringIndexOutOfBounds 1_1
+beginIndex= 2
+StringIndexOutOfBounds 1_1
+beginIndex= 3
+StringIndexOutOfBounds 1_1
+beginIndex= 4
+StringIndexOutOfBounds 1_1
+beginIndex= 5
+StringIndexOutOfBounds 1_1
+beginIndex= 6
+StringIndexOutOfBounds 1_1
+beginIndex= 7
+StringIndexOutOfBounds 1_1
+beginIndex= -1
+StringIndexOutOfBounds 1_1
+beginIndex= 0
+
+beginIndex= 1
+StringIndexOutOfBounds 1_1
+beginIndex= 2
+StringIndexOutOfBounds 1_1
+beginIndex= 3
+StringIndexOutOfBounds 1_1
+beginIndex= 4
+StringIndexOutOfBounds 1_1
+beginIndex= 5
+StringIndexOutOfBounds 1_1
+beginIndex= 6
+StringIndexOutOfBounds 1_1
+beginIndex= 7
+StringIndexOutOfBounds 1_1
+beginIndex= -1
+StringIndexOutOfBounds 1_1
+beginIndex= 0
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 1
+wertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 2
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 3
+rtyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 4
+tyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 5
+yuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 6
+uiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= 7
+iop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+beginIndex= -1
+StringIndexOutOfBounds 1_1
+beginIndex= 0
+ @!.&%
+beginIndex= 1
+@!.&%
+beginIndex= 2
+!.&%
+beginIndex= 3
+.&%
+beginIndex= 4
+&%
+beginIndex= 5
+%
+beginIndex= 6
+
+beginIndex= 7
+StringIndexOutOfBounds 1_1
+beginIndex= -1
+StringIndexOutOfBounds 1_1
+beginIndex= 0
+abc123
+beginIndex= 1
+bc123
+beginIndex= 2
+c123
+beginIndex= 3
+123
+beginIndex= 4
+23
+beginIndex= 5
+3
+beginIndex= 6
+
+beginIndex= 7
+StringIndexOutOfBounds 1_1
+beginIndex= -1
+StringIndexOutOfBounds 1_1
+beginIndex= 0
+
+beginIndex= 1
+StringIndexOutOfBounds 1_1
+beginIndex= 2
+StringIndexOutOfBounds 1_1
+beginIndex= 3
+StringIndexOutOfBounds 1_1
+beginIndex= 4
+StringIndexOutOfBounds 1_1
+beginIndex= 5
+StringIndexOutOfBounds 1_1
+beginIndex= 6
+StringIndexOutOfBounds 1_1
+beginIndex= 7
+StringIndexOutOfBounds 1_1
+0
diff --git a/testsuite/java_test/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2ff859d32433135d26a918acf561e972588e6f10
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSubstringStringIndexOutOfBoundsExceptionTest)
+run(StringSubstringStringIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/StringSubstringIntIntExceptionTest.java b/testsuite/java_test/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/StringSubstringIntIntExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c79c0aa1c6e3cd9b3f0e49f72085a41d0acf8a6f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/StringSubstringIntIntExceptionTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringSubstringIntIntExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringSubstringIntIntExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringSubstringIntIntExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%()*");
+        String str1_3 = new String("abc123abc");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZ" +
+                "XCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        try {
+            System.out.println(str.substring(2, 6));
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_1");
+        }
+        try {
+            System.out.println(str.substring(-1, 6));
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_2");
+        }
+        try {
+            System.out.println(str.substring(2, 1));
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_3");
+        }
+        try {
+            System.out.println(str.substring(2, 9));
+        } catch (StringIndexOutOfBoundsException e1) {
+            System.out.println("EXCEPTION 1_4");
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..81f7d8659040eca7eab0ef976f40363c5a1c2def
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/expected.txt
@@ -0,0 +1,25 @@
+erty
+EXCEPTION 1_2
+EXCEPTION 1_3
+ertyuio
+!.&%
+EXCEPTION 1_2
+EXCEPTION 1_3
+!.&%()*
+c123
+EXCEPTION 1_2
+EXCEPTION 1_3
+c123abc
+erty
+EXCEPTION 1_2
+EXCEPTION 1_3
+ertyuio
+!.&%
+EXCEPTION 1_2
+EXCEPTION 1_3
+EXCEPTION 1_4
+c123
+EXCEPTION 1_2
+EXCEPTION 1_3
+c123ABC
+0
diff --git a/testsuite/java_test/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..382d34108720c401b48ab12a2d91e21ecb273ec9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0037-rt-String-SubstringIntIntExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSubstringIntIntExceptionTest)
+run(StringSubstringIntIntExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/StringSubSequenceIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/StringSubSequenceIndexOutOfBoundsExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a90bcdd0a7288381e74b4d7105ad272770253744
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/StringSubSequenceIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringSubSequenceIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = StringSubSequenceIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringSubSequenceIndexOutOfBoundsExceptionTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //IndexOutOfBoundsException - if the index argument is negative or not less than the length of this string.
+        String str1_1 = new String("abc123");
+        try {
+            str1_1.subSequence(-2, 6);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            str1_1.subSequence(2, -6);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            str1_1.subSequence(2, 1);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            str1_1.subSequence(2, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d05364f8ef4ec5be26bcfd20f1042bef2d8a1647
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSubSequenceIndexOutOfBoundsExceptionTest)
+run(StringSubSequenceIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/StringReplaceNullPointerExceptionTest.java b/testsuite/java_test/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/StringReplaceNullPointerExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5524f0350a706bdb3594720e8e2f006526dba272
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/StringReplaceNullPointerExceptionTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringReplaceNullPointerExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringReplaceNullPointerExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringReplaceNullPointerExceptionTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        String str2_5 = null;
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        test(str2_5);
+    }
+    private static void test(String str) {
+        String target = null;
+        try {
+            System.out.println(str.replace(target, "@"));
+        } catch (NullPointerException e1) {
+            System.out.println("EXCEPTION 1_1");
+        }
+        String replacement = null;
+        try {
+            System.out.println(str.replace("a", replacement));
+        } catch (NullPointerException e2) {
+            System.out.println("EXCEPTION 1_2");
+        }
+        try {
+            System.out.println(str.replace("a", "@"));
+        } catch (NullPointerException e2) {
+            System.out.println("EXCEPTION 1_3");
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bcbe8784bc9785dc397f8f2503c9feef3c483d15
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/expected.txt
@@ -0,0 +1,31 @@
+EXCEPTION 1_1
+EXCEPTION 1_2
+qwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+EXCEPTION 1_1
+EXCEPTION 1_2
+ @!.&%
+EXCEPTION 1_1
+EXCEPTION 1_2
+@bc123@bc
+EXCEPTION 1_1
+EXCEPTION 1_2
+
+EXCEPTION 1_1
+EXCEPTION 1_2
+
+EXCEPTION 1_1
+EXCEPTION 1_2
+qwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+EXCEPTION 1_1
+EXCEPTION 1_2
+ @!.&%
+EXCEPTION 1_1
+EXCEPTION 1_2
+@bc123ABC
+EXCEPTION 1_1
+EXCEPTION 1_2
+
+EXCEPTION 1_1
+EXCEPTION 1_2
+EXCEPTION 1_3
+0
diff --git a/testsuite/java_test/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c43cb0eb82dc26250b176603aca70ea010423ffd
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0039-rt-String-ReplaceNullPointerExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReplaceNullPointerExceptionTest)
+run(StringReplaceNullPointerExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/StringValueOfAndCopyValueOfExceptionTest.java b/testsuite/java_test/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/StringValueOfAndCopyValueOfExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..94020893d66f90aa3c12b76d2a134d1e4943244a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/StringValueOfAndCopyValueOfExceptionTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfAndCopyValueOfExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            result = StringValueOfAndCopyValueOfExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 93) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringValueOfAndCopyValueOfExceptionTest_1() {
+        int result1 = 2; /* STATUS_Success*/
+
+        char[] ch1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        /* IndexOutOfBoundsException - if offset is negative, or count is negative, or offset+count is larger than
+           data.length*/
+
+        try {
+            String.valueOf(ch1_1, -1, 3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.valueOf(ch1_1, 1, -3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.valueOf(ch1_1, 1, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.copyValueOf(ch1_1, -1, 3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.copyValueOf(ch1_1, 1, -3);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        try {
+            String.copyValueOf(ch1_1, 1, 10);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8d160e0cfc9762242e69d2285960828b503397c0
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfAndCopyValueOfExceptionTest)
+run(StringValueOfAndCopyValueOfExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0041-rt-String-GetClassTest/StringGetClassTest.java b/testsuite/java_test/string_test/RT0041-rt-String-GetClassTest/StringGetClassTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..032565baf9b5974234f73a8661bd119a1fe32f41
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0041-rt-String-GetClassTest/StringGetClassTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringGetClassTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringGetClassTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringGetClassTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.getClass());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0041-rt-String-GetClassTest/expected.txt b/testsuite/java_test/string_test/RT0041-rt-String-GetClassTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ad466046a29a97ecb37ac083eb51853b5713fc98
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0041-rt-String-GetClassTest/expected.txt
@@ -0,0 +1,10 @@
+class java.lang.String
+class java.lang.String
+class java.lang.String
+class java.lang.String
+class java.lang.String
+class java.lang.String
+class java.lang.String
+class java.lang.String
+class java.lang.String
+0
diff --git a/testsuite/java_test/string_test/RT0041-rt-String-GetClassTest/test.cfg b/testsuite/java_test/string_test/RT0041-rt-String-GetClassTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c4cd0a945f86522a0366677ba514a35949465b0e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0041-rt-String-GetClassTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGetClassTest)
+run(StringGetClassTest)
diff --git a/testsuite/java_test/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/StringEqualsAndEqualsIgnoreCaseAndLengthTest.java b/testsuite/java_test/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/StringEqualsAndEqualsIgnoreCaseAndLengthTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba69d96a26496f2c3e34450f430730becbb8a5df
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/StringEqualsAndEqualsIgnoreCaseAndLengthTest.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringEqualsAndEqualsIgnoreCaseAndLengthTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 3; /* STATUS_Failed*/
+
+        result = StringEqualsAndEqualsIgnoreCaseAndLengthTest_1();
+        if (result == 2 && processResult == 87) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringEqualsAndEqualsIgnoreCaseAndLengthTest_1() {
+        test1();
+        test2();
+        test3();
+        test4();
+        test5();
+        test6();
+        test7();
+        test8();
+        test9();
+        test10();
+        test11();
+        test12();
+        return 2;
+    }
+    public static int test_equals(String str1, String str2) {
+        if (str1.equals(str2)) {
+            return 1; // right result
+        }
+        return 30; // wrong result
+    }
+    public static int test_not_equals(String str1, String str2) {
+        if (!str1.equals(str2)) {
+            return 1; // right result
+        }
+        return 30; // wrong result
+    }
+    public static int test_equalsIgnoreCase(String str1, String str2) {
+        if (str1.equalsIgnoreCase(str2)) {
+            return 1; // right result
+        }
+        return 30; // wrong result
+    }
+    public static int test_length(String str1, int a) {
+        if (str1.length() == a) {
+            return 1; // right result
+        }
+        return 30; // wrong result
+    }
+    private static void test1() {
+        String str1_1 = "{";
+        String str1_2 = "{";
+        if (test_equals(str1_1, str1_2) == 1 && test_length(str1_1, 1) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test2() {
+        String str2_1 = "{12ab";
+        String str2_2 = "{12ab";
+        if (test_equals(str2_1, str2_2) == 1 && test_length(str2_1, 5) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test3() {
+        String str2_1 = "{12ab";
+        String str2_3 = "{12AB";
+        if (test_equalsIgnoreCase(str2_1, str2_3) == 1 && test_not_equals(str2_1, str2_3) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test4() {
+        String str3_1 = " abc ";
+        String str3_3 = " ";
+        if (test_not_equals(str3_1, str3_3) == 1 && test_length(str3_1, 5) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test5() {
+        String str3_2 = "null";
+        String str3_3 = " ";
+        if (test_not_equals(str3_2, str3_3) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test6() {
+        String str3_2 = "null";
+        String str3_4 = "NULL";
+        if (test_not_equals(str3_2, str3_4) == 1 && test_equalsIgnoreCase(str3_2, str3_4) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test7() {
+        String str3_1 = " abc ";
+        String str3_5 = " abc";
+        if (test_not_equals(str3_1, str3_5) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test8() {
+        String str4_1 = "$";
+        String str4_2 = "￥";
+        if (test_not_equals(str4_1, str4_2) == 1 && test_length(str4_1, 1) == 1 && test_length(str4_2, 1) == 1)
+        {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test9() {
+        String str5_1 = "abc\n";
+        String str5_2 = "abc\t";
+        if (test_not_equals(str5_1, str5_2) == 1 && test_length(str5_1, 4) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test10() {
+        String str6_1 = "‘OR‘1’=’1";
+        String str6_2 = "<‘script’>alter(“Test,Bom~~~”)<‘/script’>";
+        if (test_equals(str6_1, "‘OR‘1’=’1") == 1 && test_equals(str6_2, "<‘script’>alter(“Test,Bom~~~”)" +
+                "<‘/script’>") == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test11() {
+        String str7_1 = "``_+-=asdfadfqwerqwz!@##$%&#*^%^&(&*^()*&^*)^&%^~@#%@#$%^sdfgrw5646843131324fshst{}|[]]:,\\," +
+                "dkd d/.';,;'mmm:\"<>?;',./";
+        String str7_2 = "``_+-=asdfadfqwerqwz!@##$%&#*^%^&(&*^()*&^*)^&%^~@#%@#$%^sdfgrw5646843131324fshst{}|[]]:,\\," +
+                "dkd d/.';,;'mmm:\"<>?;',./";
+        if (test_equals(str7_1, str7_2) == 1 && test_length(str7_1, 116) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+    private static void test12() {
+        String str7_1 = "``_+-=asdfadfqwerqwz!@##$%&#*^%^&(&*^()*&^*)^&%^~@#%@#$%^sdfgrw5646843131324fshst{}|[]]:,\\," +
+                "dkd d/.';,;'mmm:\"<>?;',./";
+        String str7_3 = "``_+-=asdfadfqwerqwz!@##$%&#*^%^&(&*^()*&^*)^&%^~@#%@#$%^sdfgrw5646843131324fshst{}|[]]:,\\," +
+                "dkd d/.';,;'mmm:\"<>?;',./123";
+        if (test_not_equals(str7_1, str7_3) == 1) {
+            processResult--;
+        } else {
+            processResult -= 10;
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/expected.txt b/testsuite/java_test/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/test.cfg b/testsuite/java_test/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bbce250f27c0e96f6335c331294850bbd4c4b3c8
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringEqualsAndEqualsIgnoreCaseAndLengthTest)
+run(StringEqualsAndEqualsIgnoreCaseAndLengthTest)
diff --git a/testsuite/java_test/string_test/RT0043-rt-String-NoParamConstructorTest/StringNoParamConstructorTest.java b/testsuite/java_test/string_test/RT0043-rt-String-NoParamConstructorTest/StringNoParamConstructorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..389f7e07148990025387b38bef889cbe12fee3ba
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0043-rt-String-NoParamConstructorTest/StringNoParamConstructorTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringNoParamConstructorTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringNoParamConstructorTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringNoParamConstructorTest_1() {
+        String str1 = new String();
+        System.out.println(str1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0043-rt-String-NoParamConstructorTest/expected.txt b/testsuite/java_test/string_test/RT0043-rt-String-NoParamConstructorTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d9cf16b9d2ab4ea90edc9f640db7382804fd8def
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0043-rt-String-NoParamConstructorTest/expected.txt
@@ -0,0 +1,2 @@
+
+0
diff --git a/testsuite/java_test/string_test/RT0043-rt-String-NoParamConstructorTest/test.cfg b/testsuite/java_test/string_test/RT0043-rt-String-NoParamConstructorTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c26c4af419dc796b262e50fe6a5258a0e539816b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0043-rt-String-NoParamConstructorTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringNoParamConstructorTest)
+run(StringNoParamConstructorTest)
diff --git a/testsuite/java_test/string_test/RT0044-rt-String-ConsStringTest/StringConsStringTest.java b/testsuite/java_test/string_test/RT0044-rt-String-ConsStringTest/StringConsStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2d6d8074de0d6c81d107b3d1b1e3d72c27e2db2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0044-rt-String-ConsStringTest/StringConsStringTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsStringTest_1() {
+        String str1_1 = new String("abc123");
+        String str1 = new String(str1_1);
+        System.out.println(str1);
+        String str1_2 = new String(" @!.&%");
+        String str2 = new String(str1_2);
+        System.out.println(str2);
+        String str1_3 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str3 = new String(str1_3);
+        System.out.println(str3);
+        String str1_4 = new String("");
+        String str4 = new String(str1_4);
+        System.out.println(str4);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0044-rt-String-ConsStringTest/expected.txt b/testsuite/java_test/string_test/RT0044-rt-String-ConsStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..723815547df6192c87cc5bf1208cf86c7686704b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0044-rt-String-ConsStringTest/expected.txt
@@ -0,0 +1,5 @@
+abc123
+ @!.&%
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+0
diff --git a/testsuite/java_test/string_test/RT0044-rt-String-ConsStringTest/test.cfg b/testsuite/java_test/string_test/RT0044-rt-String-ConsStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..207a99d2209761df8f9dfbf24bce3af564a359d6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0044-rt-String-ConsStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsStringTest)
+run(StringConsStringTest)
diff --git a/testsuite/java_test/string_test/RT0045-rt-String-ConsCharTest/StringConsCharTest.java b/testsuite/java_test/string_test/RT0045-rt-String-ConsCharTest/StringConsCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..119abf7224769cfb1867dbcee37cd359d9dfbc7b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0045-rt-String-ConsCharTest/StringConsCharTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsCharTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsCharTest_1() {
+        char[] value1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        String str1 = new String(value1_1);
+        System.out.println(str1);
+        char[] value1_2 = {};
+        String str2 = new String(value1_2);
+        System.out.println(str2);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0045-rt-String-ConsCharTest/expected.txt b/testsuite/java_test/string_test/RT0045-rt-String-ConsCharTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dba8a5761f9d604942da1e70b641eb94b7bc75f6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0045-rt-String-ConsCharTest/expected.txt
@@ -0,0 +1,3 @@
+abc123
+
+0
diff --git a/testsuite/java_test/string_test/RT0045-rt-String-ConsCharTest/test.cfg b/testsuite/java_test/string_test/RT0045-rt-String-ConsCharTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bbc63e38eaf764599887dddb9d5e5672590443c0
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0045-rt-String-ConsCharTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsCharTest)
+run(StringConsCharTest)
diff --git a/testsuite/java_test/string_test/RT0046-rt-String-ConsCharIntIntTest/StringConsCharIntIntTest.java b/testsuite/java_test/string_test/RT0046-rt-String-ConsCharIntIntTest/StringConsCharIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a4b6b4ec3f1ed4e292cef253407164060b93ca5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0046-rt-String-ConsCharIntIntTest/StringConsCharIntIntTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsCharIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsCharIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsCharIntIntTest_1() {
+        char[] value1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        String str1 = new String(value1_1, 0, 3);
+        String str1_1 = new String(value1_1, 0, 0);
+        String str1_2 = new String(value1_1, 0, 6);
+        String str1_3 = new String(value1_1, 5, 1);
+        String str1_4 = new String(value1_1, 5, 0);
+        System.out.println(str1);
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        System.out.println(str1_4);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0046-rt-String-ConsCharIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0046-rt-String-ConsCharIntIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bf6c075620da540ae87520515145a2f302d39ccc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0046-rt-String-ConsCharIntIntTest/expected.txt
@@ -0,0 +1,6 @@
+abc
+
+abc123
+3
+
+0
diff --git a/testsuite/java_test/string_test/RT0046-rt-String-ConsCharIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0046-rt-String-ConsCharIntIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..23b2a8653aaa020751fb4d4ba2aa4696207f0dad
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0046-rt-String-ConsCharIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsCharIntIntTest)
+run(StringConsCharIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0047-rt-String-ConsIntsIntIntTest/StringConsIntsIntIntTest.java b/testsuite/java_test/string_test/RT0047-rt-String-ConsIntsIntIntTest/StringConsIntsIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d419ec81e19c55195732063526f2270f7fcfc909
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0047-rt-String-ConsIntsIntIntTest/StringConsIntsIntIntTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsIntsIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsIntsIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsIntsIntIntTest_1() {
+        int[] charIntArray1_1 = new int[]{97, 98, 99, 49, 50, 51};
+        String str1_1 = new String(charIntArray1_1, 0, charIntArray1_1.length);
+        String str1_2 = new String(charIntArray1_1, charIntArray1_1.length - 1, 1);
+        String str1_3 = new String(charIntArray1_1, charIntArray1_1.length - 1, 0);
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        int[] charIntArray2_1 = new int[]{0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        String str2_1 = new String(charIntArray2_1, 0, charIntArray2_1.length);
+        String str2_2 = new String(charIntArray2_1, charIntArray2_1.length - 1, 1);
+        String str2_3 = new String(charIntArray2_1, charIntArray2_1.length - 1, 0);
+        System.out.println(str2_1);
+        System.out.println(str2_2);
+        System.out.println(str2_3);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0047-rt-String-ConsIntsIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0047-rt-String-ConsIntsIntIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a849e2f86cf443742c530ebf97603244cfe195c6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0047-rt-String-ConsIntsIntIntTest/expected.txt
@@ -0,0 +1,7 @@
+abc123
+3
+
+abc123
+3
+
+0
diff --git a/testsuite/java_test/string_test/RT0047-rt-String-ConsIntsIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0047-rt-String-ConsIntsIntIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bbd9203dcc542d9c940a4b72c03fad1360a61eb4
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0047-rt-String-ConsIntsIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsIntsIntIntTest)
+run(StringConsIntsIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0048-rt-String-ConsBytesIntTest/StringConsBytesIntTest.java b/testsuite/java_test/string_test/RT0048-rt-String-ConsBytesIntTest/StringConsBytesIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..04ac4e83ad2b89daa9a7d13cac12755641a2f4bc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0048-rt-String-ConsBytesIntTest/StringConsBytesIntTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsBytesIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsBytesIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsBytesIntTest_1() {
+        byte[] ascii1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1 = new String(ascii1_1, 0);
+        String str0 = new String(ascii1_1);
+        System.out.println(str0);
+        System.out.println(str1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0048-rt-String-ConsBytesIntTest/expected.txt b/testsuite/java_test/string_test/RT0048-rt-String-ConsBytesIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bb9b8668f693b05b2c8ad793db5c8cd5c51376b1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0048-rt-String-ConsBytesIntTest/expected.txt
@@ -0,0 +1,3 @@
+abc123
+abc123
+0
diff --git a/testsuite/java_test/string_test/RT0048-rt-String-ConsBytesIntTest/test.cfg b/testsuite/java_test/string_test/RT0048-rt-String-ConsBytesIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1c72431037bb32e5e5233d4bb61c12052c0414d6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0048-rt-String-ConsBytesIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesIntTest)
+run(StringConsBytesIntTest)
diff --git a/testsuite/java_test/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/StringConsBytesIntIntStringTest.java b/testsuite/java_test/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/StringConsBytesIntIntStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..85f249fd70c595da961bc853e277070b664f078d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/StringConsBytesIntIntStringTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+public class StringConsBytesIntIntStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsBytesIntIntStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsBytesIntIntStringTest_1() throws UnsupportedEncodingException {
+        byte[] str1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1_1 = new String(str1, 0, 3, "ASCII");
+        String str1_2 = new String(str1, 0, 6, "ASCII");
+        String str1_3 = new String(str1, 0, 0, "ASCII");
+        String str1_4 = new String(str1, 5, 1, "ASCII");
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        System.out.println(str1_4);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/expected.txt b/testsuite/java_test/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..998e0e398734cbdd2d70209c735c2f06ec2aab71
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/expected.txt
@@ -0,0 +1,5 @@
+abc
+abc123
+
+3
+0
diff --git a/testsuite/java_test/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/test.cfg b/testsuite/java_test/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e28f548b9974cad08c9dc1451ad18c6d7a1f3305
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0049-rt-String-ConsBytesIntIntStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesIntIntStringTest)
+run(StringConsBytesIntIntStringTest)
diff --git a/testsuite/java_test/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/StringCosBytesIntIntCharsetTest.java b/testsuite/java_test/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/StringCosBytesIntIntCharsetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc27a4e01bfc95dbb02b732a224d2c76b3d09938
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/StringCosBytesIntIntCharsetTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+public class StringCosBytesIntIntCharsetTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCosBytesIntIntCharsetTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCosBytesIntIntCharsetTest_1() throws UnsupportedEncodingException {
+        byte[] str1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1_1 = new String(str1, 3, 3, Charset.forName("ASCII"));
+        String str1_2 = new String(str1, 0, 6, Charset.forName("ASCII"));
+        String str1_3 = new String(str1, 0, 0, Charset.forName("ASCII"));
+        String str1_4 = new String(str1, 5, 1, Charset.forName("ASCII"));
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        System.out.println(str1_4);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/expected.txt b/testsuite/java_test/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..10339116d2af65b585d9d38cf28f7a07f0a63044
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/expected.txt
@@ -0,0 +1,5 @@
+123
+abc123
+
+3
+0
diff --git a/testsuite/java_test/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/test.cfg b/testsuite/java_test/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..90688b65183a8d019345219bc87746502bcfd083
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0050-rt-String-CosBytesIntIntCharsetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCosBytesIntIntCharsetTest)
+run(StringCosBytesIntIntCharsetTest)
diff --git a/testsuite/java_test/string_test/RT0051-rt-String-ConsBytesStringTest/StringConsBytesStringTest.java b/testsuite/java_test/string_test/RT0051-rt-String-ConsBytesStringTest/StringConsBytesStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4bd21fcb255159333e826aceeb9e11798c00060
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0051-rt-String-ConsBytesStringTest/StringConsBytesStringTest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+public class StringConsBytesStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsBytesStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsBytesStringTest_1() throws UnsupportedEncodingException {
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1 = new String(str1_1, "ASCII");
+        System.out.println(str1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0051-rt-String-ConsBytesStringTest/expected.txt b/testsuite/java_test/string_test/RT0051-rt-String-ConsBytesStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1a5d15a74f46fd795cf53dd9f7f6696b6385a714
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0051-rt-String-ConsBytesStringTest/expected.txt
@@ -0,0 +1,2 @@
+abc123
+0
diff --git a/testsuite/java_test/string_test/RT0051-rt-String-ConsBytesStringTest/test.cfg b/testsuite/java_test/string_test/RT0051-rt-String-ConsBytesStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ee4d311cba6f249cf5296f8e49f8a5a0713b3468
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0051-rt-String-ConsBytesStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesStringTest)
+run(StringConsBytesStringTest)
diff --git a/testsuite/java_test/string_test/RT0052-rt-String-ConsBytesCharsetTest/StringConsBytesCharsetTest.java b/testsuite/java_test/string_test/RT0052-rt-String-ConsBytesCharsetTest/StringConsBytesCharsetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..663c17eac3eb5683ddb2996e1d3e071894c108d4
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0052-rt-String-ConsBytesCharsetTest/StringConsBytesCharsetTest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.charset.Charset;
+public class StringConsBytesCharsetTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsBytesCharsetTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsBytesCharsetTest_1() {
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1 = new String(str1_1, Charset.forName("ASCII"));
+        System.out.println(str1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0052-rt-String-ConsBytesCharsetTest/expected.txt b/testsuite/java_test/string_test/RT0052-rt-String-ConsBytesCharsetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1a5d15a74f46fd795cf53dd9f7f6696b6385a714
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0052-rt-String-ConsBytesCharsetTest/expected.txt
@@ -0,0 +1,2 @@
+abc123
+0
diff --git a/testsuite/java_test/string_test/RT0052-rt-String-ConsBytesCharsetTest/test.cfg b/testsuite/java_test/string_test/RT0052-rt-String-ConsBytesCharsetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..acfa7e89beb38523a97aa97696349f6f0dd8c9b7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0052-rt-String-ConsBytesCharsetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesCharsetTest)
+run(StringConsBytesCharsetTest)
diff --git a/testsuite/java_test/string_test/RT0053-rt-String-ConsBytesIntIntTest/StringConsBytesIntIntTest.java b/testsuite/java_test/string_test/RT0053-rt-String-ConsBytesIntIntTest/StringConsBytesIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..22ce2646fe2cdd3363e49f6215b54fa36be29b31
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0053-rt-String-ConsBytesIntIntTest/StringConsBytesIntIntTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsBytesIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsBytesIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsBytesIntIntTest_1() {
+        byte[] str1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1_1 = new String(str1, 3, 3);
+        String str1_2 = new String(str1, 0, 6);
+        String str1_3 = new String(str1, 0, 0);
+        String str1_4 = new String(str1, 5, 1);
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        System.out.println(str1_4);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0053-rt-String-ConsBytesIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0053-rt-String-ConsBytesIntIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..10339116d2af65b585d9d38cf28f7a07f0a63044
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0053-rt-String-ConsBytesIntIntTest/expected.txt
@@ -0,0 +1,5 @@
+123
+abc123
+
+3
+0
diff --git a/testsuite/java_test/string_test/RT0053-rt-String-ConsBytesIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0053-rt-String-ConsBytesIntIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..72b0b8c50daec9a009690407a27073f4847eab05
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0053-rt-String-ConsBytesIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesIntIntTest)
+run(StringConsBytesIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0054-rt-String-ConsBytesTest/StringConsBytesTest.java b/testsuite/java_test/string_test/RT0054-rt-String-ConsBytesTest/StringConsBytesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..588404b73da1134154f35a666eb6c2838829a377
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0054-rt-String-ConsBytesTest/StringConsBytesTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsBytesTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsBytesTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsBytesTest_1() {
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1 = new String(str1_1);
+        byte[] str1_2 = new byte[]{97, 98, 99, 49, 50, 51};
+        String str1_3 = new String(str1_2);
+        System.out.println(str1);
+        System.out.println(str1_3);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0054-rt-String-ConsBytesTest/expected.txt b/testsuite/java_test/string_test/RT0054-rt-String-ConsBytesTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bb9b8668f693b05b2c8ad793db5c8cd5c51376b1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0054-rt-String-ConsBytesTest/expected.txt
@@ -0,0 +1,3 @@
+abc123
+abc123
+0
diff --git a/testsuite/java_test/string_test/RT0054-rt-String-ConsBytesTest/test.cfg b/testsuite/java_test/string_test/RT0054-rt-String-ConsBytesTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e6313b66ec1d1bb4283f300cb7bbbc500ae1713d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0054-rt-String-ConsBytesTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesTest)
+run(StringConsBytesTest)
diff --git a/testsuite/java_test/string_test/RT0055-rt-String-ConsStringBufferTest/StringConsStringBufferTest.java b/testsuite/java_test/string_test/RT0055-rt-String-ConsStringBufferTest/StringConsStringBufferTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7718d38fd890f0d28ec204365401206f6a7e4ffa
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0055-rt-String-ConsStringBufferTest/StringConsStringBufferTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsStringBufferTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsStringBufferTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsStringBufferTest_1() {
+        String str1 = "These " + "are " + "abcdefghijklmnopqrstuvwxyz";
+        String str2_1 = "These ";
+        String str2_2 = "are ";
+        String str2_3 = "abcdefghijklmnopqrstuvwxyz";
+        String str2 = str2_1 + str2_2 + str2_3;
+        StringBuffer str_b_1 = new StringBuffer("These ").append("are ").append("abcdefghijklmnopqrstuvwxyz");
+        String str3 = new String(str_b_1);
+        System.out.println(str1);
+        System.out.println(str2);
+        System.out.println(str3);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0055-rt-String-ConsStringBufferTest/expected.txt b/testsuite/java_test/string_test/RT0055-rt-String-ConsStringBufferTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d1e7254e889c3f0be8e4c33a811eab851c69bdb9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0055-rt-String-ConsStringBufferTest/expected.txt
@@ -0,0 +1,4 @@
+These are abcdefghijklmnopqrstuvwxyz
+These are abcdefghijklmnopqrstuvwxyz
+These are abcdefghijklmnopqrstuvwxyz
+0
diff --git a/testsuite/java_test/string_test/RT0055-rt-String-ConsStringBufferTest/test.cfg b/testsuite/java_test/string_test/RT0055-rt-String-ConsStringBufferTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0c558ca66ece20445800c2876a73cb232497ee91
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0055-rt-String-ConsStringBufferTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsStringBufferTest)
+run(StringConsStringBufferTest)
diff --git a/testsuite/java_test/string_test/RT0056-rt-String-ConsStringBuilderTest/StringConsStringBuilderTest.java b/testsuite/java_test/string_test/RT0056-rt-String-ConsStringBuilderTest/StringConsStringBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f35cbef2077e8cf0a1f05b4795479a2c01af3e89
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0056-rt-String-ConsStringBuilderTest/StringConsStringBuilderTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsStringBuilderTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsStringBuilderTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConsStringBuilderTest_1() {
+        String str1 = "These " + "are " + "abcdefghijklmnopqrstuvwxyz";
+        String str2_1 = "These ";
+        String str2_2 = "are ";
+        String str2_3 = "abcdefghijklmnopqrstuvwxyz";
+        String str2 = str2_1 + str2_2 + str2_3;
+        StringBuilder str_b_1 = new StringBuilder("These ").append("are ").append("abcdefghijklmnopqrstuvwxyz");
+        String str3 = new String(str_b_1);
+        System.out.println(str1);
+        System.out.println(str2);
+        System.out.println(str3);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0056-rt-String-ConsStringBuilderTest/expected.txt b/testsuite/java_test/string_test/RT0056-rt-String-ConsStringBuilderTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d1e7254e889c3f0be8e4c33a811eab851c69bdb9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0056-rt-String-ConsStringBuilderTest/expected.txt
@@ -0,0 +1,4 @@
+These are abcdefghijklmnopqrstuvwxyz
+These are abcdefghijklmnopqrstuvwxyz
+These are abcdefghijklmnopqrstuvwxyz
+0
diff --git a/testsuite/java_test/string_test/RT0056-rt-String-ConsStringBuilderTest/test.cfg b/testsuite/java_test/string_test/RT0056-rt-String-ConsStringBuilderTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b48a4600ff0663e6590f49aa94d682c826f8053e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0056-rt-String-ConsStringBuilderTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsStringBuilderTest)
+run(StringConsStringBuilderTest)
diff --git a/testsuite/java_test/string_test/RT0057-rt-String-LengthTest/StringLengthTest.java b/testsuite/java_test/string_test/RT0057-rt-String-LengthTest/StringLengthTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..12e621fdc3226e0ef1236bb1430d5b7238838b94
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0057-rt-String-LengthTest/StringLengthTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringLengthTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringLengthTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringLengthTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        int strLength = str1_1.length();
+        System.out.println(strLength);
+        test(str1_1);
+        System.out.println(str1_2.length());
+        test(str1_2);
+        System.out.println(str1_3.length());
+        test(str1_3);
+        System.out.println(str1_4.length());
+        test(str1_4);
+        System.out.println(str1_5.length());
+        test(str1_5);
+        System.out.println(str2_1.length());
+        test(str2_1);
+        System.out.println(str2_2.length());
+        test(str2_2);
+        System.out.println(str2_3.length());
+        test(str2_3);
+        System.out.println(str2_4.length());
+        test(str2_4);
+    }
+    private static void test(String str) {
+        if (str == null) {
+            System.out.println(str + " is:null");
+        }
+        if (str.isEmpty()) {
+            System.out.println(str + " is:isEmpty");
+        }
+        if (str.equals("")) {
+            System.out.println(str + " is:\"\"");
+        }
+        System.out.println("*****");
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0057-rt-String-LengthTest/expected.txt b/testsuite/java_test/string_test/RT0057-rt-String-LengthTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..45339697f7df4728e62915047620999320d43762
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0057-rt-String-LengthTest/expected.txt
@@ -0,0 +1,25 @@
+99
+*****
+6
+*****
+6
+*****
+0
+ is:isEmpty
+ is:""
+*****
+0
+ is:isEmpty
+ is:""
+*****
+99
+*****
+6
+*****
+6
+*****
+0
+ is:isEmpty
+ is:""
+*****
+0
diff --git a/testsuite/java_test/string_test/RT0057-rt-String-LengthTest/test.cfg b/testsuite/java_test/string_test/RT0057-rt-String-LengthTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9ac15074e8310b2cb6e1aa74d1d3504bb99dec02
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0057-rt-String-LengthTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringLengthTest)
+run(StringLengthTest)
diff --git a/testsuite/java_test/string_test/RT0058-rt-String-IsEmptyTest/StringIsEmptyTest.java b/testsuite/java_test/string_test/RT0058-rt-String-IsEmptyTest/StringIsEmptyTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..05962d171f153b0dd859435120582ead5614db43
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0058-rt-String-IsEmptyTest/StringIsEmptyTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringIsEmptyTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringIsEmptyTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringIsEmptyTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        System.out.println(str1_1.isEmpty());
+        test(str1_1);
+        System.out.println(str1_2.isEmpty());
+        test(str1_2);
+        System.out.println(str1_3.isEmpty());
+        test(str1_3);
+        System.out.println(str1_4.isEmpty());
+        test(str1_4);
+        System.out.println(str1_5.isEmpty());
+        test(str1_5);
+        System.out.println(str2_1.isEmpty());
+        test(str2_1);
+        System.out.println(str2_2.isEmpty());
+        test(str2_2);
+        System.out.println(str2_3.isEmpty());
+        test(str2_3);
+        System.out.println(str2_4.isEmpty());
+        test(str2_4);
+    }
+    private static void test(String str) {
+        if (str == null) {
+            System.out.println(str + " is:null");
+        }
+        if (str.isEmpty()) {
+            System.out.println(str + " is:isEmpty");
+        }
+        if (str.equals("")) {
+            System.out.println(str + " is:\"\"");
+        }
+        System.out.println("*****");
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0058-rt-String-IsEmptyTest/expected.txt b/testsuite/java_test/string_test/RT0058-rt-String-IsEmptyTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1a30f6213d2b7856dfa29272e086369ebf2a7e99
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0058-rt-String-IsEmptyTest/expected.txt
@@ -0,0 +1,25 @@
+false
+*****
+false
+*****
+false
+*****
+true
+ is:isEmpty
+ is:""
+*****
+true
+ is:isEmpty
+ is:""
+*****
+false
+*****
+false
+*****
+false
+*****
+true
+ is:isEmpty
+ is:""
+*****
+0
diff --git a/testsuite/java_test/string_test/RT0058-rt-String-IsEmptyTest/test.cfg b/testsuite/java_test/string_test/RT0058-rt-String-IsEmptyTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9f80a5b39a3bb0d6aee9a58adb6a582fe78a1186
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0058-rt-String-IsEmptyTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringIsEmptyTest)
+run(StringIsEmptyTest)
diff --git a/testsuite/java_test/string_test/RT0059-rt-String-CharAtTest/StringCharAtTest.java b/testsuite/java_test/string_test/RT0059-rt-String-CharAtTest/StringCharAtTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a9d701993a94c2678699b1af9b561f98c21196d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0059-rt-String-CharAtTest/StringCharAtTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCharAtTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCharAtTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCharAtTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test1(str1_1);
+        test(str1_1);
+        test1(str1_2);
+        test(str1_2);
+        test1(str1_3);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test1(str2_1);
+        test(str2_1);
+        test1(str2_2);
+        test(str2_2);
+        test1(str2_3);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        if (str == null) {
+            System.out.println(str + " is:null");
+        }
+        if (str.isEmpty()) {
+            System.out.println(str + " is:isEmpty");
+        }
+        if (str.equals("")) {
+            System.out.println(str + " is:\"\"");
+        }
+        System.out.println("*****");
+    }
+    private static void test1(String str) {
+        char ch = str.charAt(0);
+        System.out.println(ch);
+        System.out.println(str.charAt(str.length() - 1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0059-rt-String-CharAtTest/expected.txt b/testsuite/java_test/string_test/RT0059-rt-String-CharAtTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fc8ce751656308dbe9699865dfc89d66e9575816
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0059-rt-String-CharAtTest/expected.txt
@@ -0,0 +1,28 @@
+q
+6
+*****
+ 
+%
+*****
+a
+3
+*****
+ is:isEmpty
+ is:""
+*****
+ is:isEmpty
+ is:""
+*****
+q
+6
+*****
+ 
+%
+*****
+a
+3
+*****
+ is:isEmpty
+ is:""
+*****
+0
diff --git a/testsuite/java_test/string_test/RT0059-rt-String-CharAtTest/test.cfg b/testsuite/java_test/string_test/RT0059-rt-String-CharAtTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..82ff23109d8e6fc6e99220f70ecc73d63db4741f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0059-rt-String-CharAtTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCharAtTest)
+run(StringCharAtTest)
diff --git a/testsuite/java_test/string_test/RT0060-rt-String-CodePointAtTest/StringCodePointAtTest.java b/testsuite/java_test/string_test/RT0060-rt-String-CodePointAtTest/StringCodePointAtTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..21d3d1308467fbc9d38bd87ceddcebc54f0ec4ff
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0060-rt-String-CodePointAtTest/StringCodePointAtTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCodePointAtTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCodePointAtTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCodePointAtTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = 0; i < 6; i++) {
+            try {
+                codePoint = str.codePointAt(i);
+                System.out.println("i=" + i + " " + "codePointAt=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointAt(): " + i + "out of length");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " Unicode is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0060-rt-String-CodePointAtTest/expected.txt b/testsuite/java_test/string_test/RT0060-rt-String-CodePointAtTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..61c76889b7c6643e0005e2f448146fdf7de1c9d5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0060-rt-String-CodePointAtTest/expected.txt
@@ -0,0 +1,73 @@
+i=0 codePointAt=113
+q Unicode is:113
+i=1 codePointAt=119
+w Unicode is:119
+i=2 codePointAt=101
+e Unicode is:101
+i=3 codePointAt=114
+r Unicode is:114
+i=4 codePointAt=116
+t Unicode is:116
+i=5 codePointAt=121
+y Unicode is:121
+i=0 codePointAt=32
+  Unicode is:32
+i=1 codePointAt=64
+@ Unicode is:64
+i=2 codePointAt=33
+! Unicode is:33
+i=3 codePointAt=46
+. Unicode is:46
+i=4 codePointAt=38
+& Unicode is:38
+i=5 codePointAt=37
+% Unicode is:37
+i=0 codePointAt=97
+a Unicode is:97
+i=1 codePointAt=98
+b Unicode is:98
+i=2 codePointAt=99
+c Unicode is:99
+i=3 codePointAt=49
+1 Unicode is:49
+i=4 codePointAt=50
+2 Unicode is:50
+i=5 codePointAt=51
+3 Unicode is:51
+i=0 codePointAt=113
+q Unicode is:113
+i=1 codePointAt=119
+w Unicode is:119
+i=2 codePointAt=101
+e Unicode is:101
+i=3 codePointAt=114
+r Unicode is:114
+i=4 codePointAt=116
+t Unicode is:116
+i=5 codePointAt=121
+y Unicode is:121
+i=0 codePointAt=32
+  Unicode is:32
+i=1 codePointAt=64
+@ Unicode is:64
+i=2 codePointAt=33
+! Unicode is:33
+i=3 codePointAt=46
+. Unicode is:46
+i=4 codePointAt=38
+& Unicode is:38
+i=5 codePointAt=37
+% Unicode is:37
+i=0 codePointAt=97
+a Unicode is:97
+i=1 codePointAt=98
+b Unicode is:98
+i=2 codePointAt=99
+c Unicode is:99
+i=3 codePointAt=49
+1 Unicode is:49
+i=4 codePointAt=50
+2 Unicode is:50
+i=5 codePointAt=51
+3 Unicode is:51
+0
diff --git a/testsuite/java_test/string_test/RT0060-rt-String-CodePointAtTest/test.cfg b/testsuite/java_test/string_test/RT0060-rt-String-CodePointAtTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd711d008f06296720c2202aed11b6887ec6317c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0060-rt-String-CodePointAtTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCodePointAtTest)
+run(StringCodePointAtTest)
diff --git a/testsuite/java_test/string_test/RT0061-rt-String-CodePointBeforeTest/StringCodePointBeforeTest.java b/testsuite/java_test/string_test/RT0061-rt-String-CodePointBeforeTest/StringCodePointBeforeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..825033ce59d7d7f59d13fe76aebefe6d707dd946
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0061-rt-String-CodePointBeforeTest/StringCodePointBeforeTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCodePointBeforeTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCodePointBeforeTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCodePointBeforeTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = 1; i < 6; i++) {
+            try {
+                codePoint = str.codePointBefore(i);
+                System.out.println("i=" + i + " " + "codePointBefore=" + codePoint);
+            } catch (StringIndexOutOfBoundsException e1) {
+                System.out.println("codePointBefore(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " codePointBefore is" + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0061-rt-String-CodePointBeforeTest/expected.txt b/testsuite/java_test/string_test/RT0061-rt-String-CodePointBeforeTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..89900c3dc014d5ca07219670e07f29b001963fc7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0061-rt-String-CodePointBeforeTest/expected.txt
@@ -0,0 +1,61 @@
+i=1 codePointBefore=113
+w codePointBefore is:113
+i=2 codePointBefore=119
+e codePointBefore is:119
+i=3 codePointBefore=101
+r codePointBefore is:101
+i=4 codePointBefore=114
+t codePointBefore is:114
+i=5 codePointBefore=116
+y codePointBefore is:116
+i=1 codePointBefore=32
+@ codePointBefore is:32
+i=2 codePointBefore=64
+! codePointBefore is:64
+i=3 codePointBefore=33
+. codePointBefore is:33
+i=4 codePointBefore=46
+& codePointBefore is:46
+i=5 codePointBefore=38
+% codePointBefore is:38
+i=1 codePointBefore=97
+b codePointBefore is:97
+i=2 codePointBefore=98
+c codePointBefore is:98
+i=3 codePointBefore=99
+1 codePointBefore is:99
+i=4 codePointBefore=49
+2 codePointBefore is:49
+i=5 codePointBefore=50
+3 codePointBefore is:50
+i=1 codePointBefore=113
+w codePointBefore is:113
+i=2 codePointBefore=119
+e codePointBefore is:119
+i=3 codePointBefore=101
+r codePointBefore is:101
+i=4 codePointBefore=114
+t codePointBefore is:114
+i=5 codePointBefore=116
+y codePointBefore is:116
+i=1 codePointBefore=32
+@ codePointBefore is:32
+i=2 codePointBefore=64
+! codePointBefore is:64
+i=3 codePointBefore=33
+. codePointBefore is:33
+i=4 codePointBefore=46
+& codePointBefore is:46
+i=5 codePointBefore=38
+% codePointBefore is:38
+i=1 codePointBefore=97
+b codePointBefore is:97
+i=2 codePointBefore=98
+c codePointBefore is:98
+i=3 codePointBefore=99
+1 codePointBefore is:99
+i=4 codePointBefore=49
+2 codePointBefore is:49
+i=5 codePointBefore=50
+3 codePointBefore is:50
+0
diff --git a/testsuite/java_test/string_test/RT0061-rt-String-CodePointBeforeTest/test.cfg b/testsuite/java_test/string_test/RT0061-rt-String-CodePointBeforeTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e488ae693e508a590cc27263a891b789a2f423a3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0061-rt-String-CodePointBeforeTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCodePointBeforeTest)
+run(StringCodePointBeforeTest)
diff --git a/testsuite/java_test/string_test/RT0062-rt-String-CodePointCountTest/StringCodePointCountTest.java b/testsuite/java_test/string_test/RT0062-rt-String-CodePointCountTest/StringCodePointCountTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..04109e875013784f1c52b463af545a5250c1b10a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0062-rt-String-CodePointCountTest/StringCodePointCountTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCodePointCountTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCodePointCountTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCodePointCountTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = 0; i < 4; i++) {
+            try {
+                codePoint = str.codePointCount(i, i + 3);
+                System.out.println("i=" + i + " " + "codePointCount=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("codePointCount(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " codePointCount is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0062-rt-String-CodePointCountTest/expected.txt b/testsuite/java_test/string_test/RT0062-rt-String-CodePointCountTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a36e8278b14184605281942e25b6630e92c0a82
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0062-rt-String-CodePointCountTest/expected.txt
@@ -0,0 +1,49 @@
+i=0 codePointCount=3
+q codePointCount is :3
+i=1 codePointCount=3
+w codePointCount is :3
+i=2 codePointCount=3
+e codePointCount is :3
+i=3 codePointCount=3
+r codePointCount is :3
+i=0 codePointCount=3
+  codePointCount is :3
+i=1 codePointCount=3
+@ codePointCount is :3
+i=2 codePointCount=3
+! codePointCount is :3
+i=3 codePointCount=3
+. codePointCount is :3
+i=0 codePointCount=3
+a codePointCount is :3
+i=1 codePointCount=3
+b codePointCount is :3
+i=2 codePointCount=3
+c codePointCount is :3
+i=3 codePointCount=3
+1 codePointCount is :3
+i=0 codePointCount=3
+q codePointCount is :3
+i=1 codePointCount=3
+w codePointCount is :3
+i=2 codePointCount=3
+e codePointCount is :3
+i=3 codePointCount=3
+r codePointCount is :3
+i=0 codePointCount=3
+  codePointCount is :3
+i=1 codePointCount=3
+@ codePointCount is :3
+i=2 codePointCount=3
+! codePointCount is :3
+i=3 codePointCount=3
+. codePointCount is :3
+i=0 codePointCount=3
+a codePointCount is :3
+i=1 codePointCount=3
+b codePointCount is :3
+i=2 codePointCount=3
+c codePointCount is :3
+i=3 codePointCount=3
+1 codePointCount is :3
+0
diff --git a/testsuite/java_test/string_test/RT0062-rt-String-CodePointCountTest/test.cfg b/testsuite/java_test/string_test/RT0062-rt-String-CodePointCountTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..720a7ff8925e874c868c1c9f82bf75c49cd9b922
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0062-rt-String-CodePointCountTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCodePointCountTest)
+run(StringCodePointCountTest)
diff --git a/testsuite/java_test/string_test/RT0063-rt-String-OffsetByCodePointsTest/StringOffsetByCodePointsTest.java b/testsuite/java_test/string_test/RT0063-rt-String-OffsetByCodePointsTest/StringOffsetByCodePointsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a36d4a2a292b1fb0846902fcfffa61980aaf8524
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0063-rt-String-OffsetByCodePointsTest/StringOffsetByCodePointsTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringOffsetByCodePointsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringOffsetByCodePointsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringOffsetByCodePointsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        int codePoint = 0;
+        for (int i = 0; i < 2; i++) {
+            try {
+                codePoint = str.offsetByCodePoints(i, i + 3);
+                System.out.println("i=" + i + " " + "offsetByCodePoints=" + codePoint);
+            } catch (IndexOutOfBoundsException e1) {
+                System.out.println("offsetByCodePoints(): " + i + " out of length");
+            } finally {
+                try {
+                    System.out.println(str.charAt(i) + " offsetByCodePoints is " + ":" + codePoint);
+                } catch (StringIndexOutOfBoundsException e2) {
+                    System.out.println("charAt(): " + i + " out of length");
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0063-rt-String-OffsetByCodePointsTest/expected.txt b/testsuite/java_test/string_test/RT0063-rt-String-OffsetByCodePointsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7563ccb0164299745ebea1e601f06e8a8eb89c21
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0063-rt-String-OffsetByCodePointsTest/expected.txt
@@ -0,0 +1,25 @@
+i=0 offsetByCodePoints=3
+q offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+w offsetByCodePoints is :5
+i=0 offsetByCodePoints=3
+  offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+@ offsetByCodePoints is :5
+i=0 offsetByCodePoints=3
+a offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+b offsetByCodePoints is :5
+i=0 offsetByCodePoints=3
+q offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+w offsetByCodePoints is :5
+i=0 offsetByCodePoints=3
+  offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+@ offsetByCodePoints is :5
+i=0 offsetByCodePoints=3
+a offsetByCodePoints is :3
+i=1 offsetByCodePoints=5
+b offsetByCodePoints is :5
+0
diff --git a/testsuite/java_test/string_test/RT0063-rt-String-OffsetByCodePointsTest/test.cfg b/testsuite/java_test/string_test/RT0063-rt-String-OffsetByCodePointsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8765dea8774e26600d511f1f9d401f019a852bf0
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0063-rt-String-OffsetByCodePointsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringOffsetByCodePointsTest)
+run(StringOffsetByCodePointsTest)
diff --git a/testsuite/java_test/string_test/RT0064-rt-String-GetCharsTest/StringGetCharsTest.java b/testsuite/java_test/string_test/RT0064-rt-String-GetCharsTest/StringGetCharsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..958d7e87ca7068f28d1d5e2f232c46d1e18f73dd
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0064-rt-String-GetCharsTest/StringGetCharsTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringGetCharsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,  PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringGetCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringGetCharsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        // 0 < srcBegin < srcEnd, srcEnd < instance.length. 0 =< dstBegin < dst.length -1.
+        char[] dst = {'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(2, 5, dst, 2);
+        System.out.println(dst);
+        // srcBegin = 0, srcEnd < instance.length. 0 =< dstBegin < dst.length -1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(0, 3, dst, 2);
+        System.out.println(dst);
+        // srcBegin = instance.length, srcEnd = instance.length, 0 =< dstBegin < dst.length -1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(str.length(), str.length(), dst, 2);
+        System.out.println(dst);
+        // srcBegin = 0, srcEnd = 0, 0 =< dstBegin < dst.length -1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(0, 0, dst, 2);
+        System.out.println(dst);
+        // 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin = 0.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(2, 3, dst, 0);
+        System.out.println(dst);
+        // 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin = dst.length -1.
+        dst = new char[]{'A', 'B', 'C', 'D', 'E', 'F'};
+        str.getChars(2, 3, dst, 5);
+        System.out.println(dst);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0064-rt-String-GetCharsTest/expected.txt b/testsuite/java_test/string_test/RT0064-rt-String-GetCharsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..614bebbf5e536458f0b8e3e4489808880148f6c9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0064-rt-String-GetCharsTest/expected.txt
@@ -0,0 +1,37 @@
+ABertF
+ABqweF
+ABCDEF
+ABCDEF
+eBCDEF
+ABCDEe
+AB!.&F
+AB @!F
+ABCDEF
+ABCDEF
+!BCDEF
+ABCDE!
+ABc12F
+ABabcF
+ABCDEF
+ABCDEF
+cBCDEF
+ABCDEc
+ABertF
+ABqweF
+ABCDEF
+ABCDEF
+eBCDEF
+ABCDEe
+AB!.&F
+AB @!F
+ABCDEF
+ABCDEF
+!BCDEF
+ABCDE!
+ABc12F
+ABabcF
+ABCDEF
+ABCDEF
+cBCDEF
+ABCDEc
+0
diff --git a/testsuite/java_test/string_test/RT0064-rt-String-GetCharsTest/test.cfg b/testsuite/java_test/string_test/RT0064-rt-String-GetCharsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dcc645a95ea6c24abbf9fc35ecdce57d0388d834
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0064-rt-String-GetCharsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGetCharsTest)
+run(StringGetCharsTest)
diff --git a/testsuite/java_test/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/StringGetBytesIntIntBytesIntTest.java b/testsuite/java_test/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/StringGetBytesIntIntBytesIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5db38a83ac4c4ec135fa7c73d5d1a0d364b0a4dc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/StringGetBytesIntIntBytesIntTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringGetBytesIntIntBytesIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringGetBytesIntIntBytesIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringGetBytesIntIntBytesIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        // Test 0 < srcBegin < srcEnd, srcEnd < instance.length. 0 =< dstBegin < dst.length -1.
+        byte[] dst = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(2, 5, dst, 2);
+        String str_new = new String(dst);
+        System.out.println(str_new);
+        // Test srcBegin = 0, srcEnd < instance.length. 0 =< dstBegin < dst.length -1.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(0, 3, dst, 2);
+        str_new = new String(dst);
+        System.out.println(str_new);
+        // Test srcBegin = instance.length, srcEnd = instance.length, 0 =< dstBegin < dst.length -1.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(str.length(), str.length(), dst, 2);
+        str_new = new String(dst);
+        System.out.println(str_new);
+        // Test srcBegin = 0, srcEnd = 0, 0 =< dstBegin < dst.length -1.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(0, 0, dst, 2);
+        str_new = new String(dst);
+        System.out.println(str_new);
+        // Test 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin = 0.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(2, 3, dst, 0);
+        str_new = new String(dst);
+        System.out.println(str_new);
+        // Test 0 < srcBegin < srcEnd, srcEnd < instance.length, dstBegin = dst.length -1.
+        dst = new byte[]{0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
+        str.getBytes(2, 3, dst, 5);
+        str_new = new String(dst);
+        System.out.println(str_new);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/expected.txt b/testsuite/java_test/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..614bebbf5e536458f0b8e3e4489808880148f6c9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/expected.txt
@@ -0,0 +1,37 @@
+ABertF
+ABqweF
+ABCDEF
+ABCDEF
+eBCDEF
+ABCDEe
+AB!.&F
+AB @!F
+ABCDEF
+ABCDEF
+!BCDEF
+ABCDE!
+ABc12F
+ABabcF
+ABCDEF
+ABCDEF
+cBCDEF
+ABCDEc
+ABertF
+ABqweF
+ABCDEF
+ABCDEF
+eBCDEF
+ABCDEe
+AB!.&F
+AB @!F
+ABCDEF
+ABCDEF
+!BCDEF
+ABCDE!
+ABc12F
+ABabcF
+ABCDEF
+ABCDEF
+cBCDEF
+ABCDEc
+0
diff --git a/testsuite/java_test/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/test.cfg b/testsuite/java_test/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5b53888539b78d01d1918acfa6236b0e936e7294
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0065-rt-String-GetBytesIntIntBytesIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGetBytesIntIntBytesIntTest)
+run(StringGetBytesIntIntBytesIntTest)
diff --git a/testsuite/java_test/string_test/RT0066-rt-String-GetBytesStringTest/StringGetBytesStringTest.java b/testsuite/java_test/string_test/RT0066-rt-String-GetBytesStringTest/StringGetBytesStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..47c6e508dcd6c7914de0d47094a383e88019c254
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0066-rt-String-GetBytesStringTest/StringGetBytesStringTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+public class StringGetBytesStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringGetBytesStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringGetBytesStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        try {
+            byte[] test1_1 = str.getBytes("UTF-8");
+            for (int i = 0; i < test1_1.length; i++) {
+                System.out.println(test1_1[i]);
+            }
+        } catch (UnsupportedEncodingException e) {
+            System.out.println("Unsupported character set");
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0066-rt-String-GetBytesStringTest/expected.txt b/testsuite/java_test/string_test/RT0066-rt-String-GetBytesStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aabfa112362d9c34a4ef36106314310ab2201249
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0066-rt-String-GetBytesStringTest/expected.txt
@@ -0,0 +1,223 @@
+113
+119
+101
+114
+116
+121
+117
+105
+111
+112
+123
+125
+91
+93
+92
+124
+97
+115
+100
+102
+103
+104
+106
+107
+108
+59
+58
+39
+34
+122
+120
+99
+118
+98
+110
+109
+44
+46
+60
+62
+47
+63
+126
+96
+49
+50
+51
+52
+53
+54
+55
+56
+57
+48
+45
+61
+33
+64
+35
+36
+37
+94
+38
+42
+40
+41
+95
+43
+32
+65
+83
+68
+70
+71
+72
+74
+75
+76
+81
+87
+69
+82
+84
+89
+85
+73
+79
+80
+90
+88
+67
+86
+66
+78
+77
+48
+120
+57
+54
+32
+64
+33
+46
+38
+37
+97
+98
+99
+49
+50
+51
+113
+119
+101
+114
+116
+121
+117
+105
+111
+112
+123
+125
+91
+93
+92
+124
+97
+115
+100
+102
+103
+104
+106
+107
+108
+59
+58
+39
+34
+122
+120
+99
+118
+98
+110
+109
+44
+46
+60
+62
+47
+63
+126
+96
+49
+50
+51
+52
+53
+54
+55
+56
+57
+48
+45
+61
+33
+64
+35
+36
+37
+94
+38
+42
+40
+41
+95
+43
+32
+65
+83
+68
+70
+71
+72
+74
+75
+76
+81
+87
+69
+82
+84
+89
+85
+73
+79
+80
+90
+88
+67
+86
+66
+78
+77
+48
+120
+57
+54
+32
+64
+33
+46
+38
+37
+97
+98
+99
+49
+50
+51
+0
diff --git a/testsuite/java_test/string_test/RT0066-rt-String-GetBytesStringTest/test.cfg b/testsuite/java_test/string_test/RT0066-rt-String-GetBytesStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..41fdecb36a3601e5282694c40257d321574e717c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0066-rt-String-GetBytesStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGetBytesStringTest)
+run(StringGetBytesStringTest)
diff --git a/testsuite/java_test/string_test/RT0067-rt-String-GetBytesCharsetTest/StringGetBytesCharsetTest.java b/testsuite/java_test/string_test/RT0067-rt-String-GetBytesCharsetTest/StringGetBytesCharsetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..08c1d45fdf6f8ad5428399b3dad5e7acda19fb1d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0067-rt-String-GetBytesCharsetTest/StringGetBytesCharsetTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+public class StringGetBytesCharsetTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringGetBytesCharsetTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringGetBytesCharsetTest_1() throws UnsupportedEncodingException {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) throws UnsupportedEncodingException {
+        Charset charset = Charset.defaultCharset();
+        byte[] test1 = str.getBytes(charset);
+        for (int i = 0; i < test1.length; i++) {
+            System.out.println(test1[i]);
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0067-rt-String-GetBytesCharsetTest/expected.txt b/testsuite/java_test/string_test/RT0067-rt-String-GetBytesCharsetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aabfa112362d9c34a4ef36106314310ab2201249
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0067-rt-String-GetBytesCharsetTest/expected.txt
@@ -0,0 +1,223 @@
+113
+119
+101
+114
+116
+121
+117
+105
+111
+112
+123
+125
+91
+93
+92
+124
+97
+115
+100
+102
+103
+104
+106
+107
+108
+59
+58
+39
+34
+122
+120
+99
+118
+98
+110
+109
+44
+46
+60
+62
+47
+63
+126
+96
+49
+50
+51
+52
+53
+54
+55
+56
+57
+48
+45
+61
+33
+64
+35
+36
+37
+94
+38
+42
+40
+41
+95
+43
+32
+65
+83
+68
+70
+71
+72
+74
+75
+76
+81
+87
+69
+82
+84
+89
+85
+73
+79
+80
+90
+88
+67
+86
+66
+78
+77
+48
+120
+57
+54
+32
+64
+33
+46
+38
+37
+97
+98
+99
+49
+50
+51
+113
+119
+101
+114
+116
+121
+117
+105
+111
+112
+123
+125
+91
+93
+92
+124
+97
+115
+100
+102
+103
+104
+106
+107
+108
+59
+58
+39
+34
+122
+120
+99
+118
+98
+110
+109
+44
+46
+60
+62
+47
+63
+126
+96
+49
+50
+51
+52
+53
+54
+55
+56
+57
+48
+45
+61
+33
+64
+35
+36
+37
+94
+38
+42
+40
+41
+95
+43
+32
+65
+83
+68
+70
+71
+72
+74
+75
+76
+81
+87
+69
+82
+84
+89
+85
+73
+79
+80
+90
+88
+67
+86
+66
+78
+77
+48
+120
+57
+54
+32
+64
+33
+46
+38
+37
+97
+98
+99
+49
+50
+51
+0
diff --git a/testsuite/java_test/string_test/RT0067-rt-String-GetBytesCharsetTest/test.cfg b/testsuite/java_test/string_test/RT0067-rt-String-GetBytesCharsetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..97df6258562eda9533010d89f40afd4327b886f1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0067-rt-String-GetBytesCharsetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGetBytesCharsetTest)
+run(StringGetBytesCharsetTest)
diff --git a/testsuite/java_test/string_test/RT0068-rt-String-GetBytesTest/StringGetBytesTest.java b/testsuite/java_test/string_test/RT0068-rt-String-GetBytesTest/StringGetBytesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..827edffc57d493fcb2a6f488e1f6dc3f7f1123b2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0068-rt-String-GetBytesTest/StringGetBytesTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringGetBytesTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringGetBytesTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringGetBytesTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        byte[] test1_1 = str.getBytes();
+        for (int i = 0; i < test1_1.length; i++) {
+            System.out.println(test1_1[i]);
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0068-rt-String-GetBytesTest/expected.txt b/testsuite/java_test/string_test/RT0068-rt-String-GetBytesTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aabfa112362d9c34a4ef36106314310ab2201249
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0068-rt-String-GetBytesTest/expected.txt
@@ -0,0 +1,223 @@
+113
+119
+101
+114
+116
+121
+117
+105
+111
+112
+123
+125
+91
+93
+92
+124
+97
+115
+100
+102
+103
+104
+106
+107
+108
+59
+58
+39
+34
+122
+120
+99
+118
+98
+110
+109
+44
+46
+60
+62
+47
+63
+126
+96
+49
+50
+51
+52
+53
+54
+55
+56
+57
+48
+45
+61
+33
+64
+35
+36
+37
+94
+38
+42
+40
+41
+95
+43
+32
+65
+83
+68
+70
+71
+72
+74
+75
+76
+81
+87
+69
+82
+84
+89
+85
+73
+79
+80
+90
+88
+67
+86
+66
+78
+77
+48
+120
+57
+54
+32
+64
+33
+46
+38
+37
+97
+98
+99
+49
+50
+51
+113
+119
+101
+114
+116
+121
+117
+105
+111
+112
+123
+125
+91
+93
+92
+124
+97
+115
+100
+102
+103
+104
+106
+107
+108
+59
+58
+39
+34
+122
+120
+99
+118
+98
+110
+109
+44
+46
+60
+62
+47
+63
+126
+96
+49
+50
+51
+52
+53
+54
+55
+56
+57
+48
+45
+61
+33
+64
+35
+36
+37
+94
+38
+42
+40
+41
+95
+43
+32
+65
+83
+68
+70
+71
+72
+74
+75
+76
+81
+87
+69
+82
+84
+89
+85
+73
+79
+80
+90
+88
+67
+86
+66
+78
+77
+48
+120
+57
+54
+32
+64
+33
+46
+38
+37
+97
+98
+99
+49
+50
+51
+0
diff --git a/testsuite/java_test/string_test/RT0068-rt-String-GetBytesTest/test.cfg b/testsuite/java_test/string_test/RT0068-rt-String-GetBytesTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a5c8676233b99d61c0a643943a51528e1e20f40e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0068-rt-String-GetBytesTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGetBytesTest)
+run(StringGetBytesTest)
diff --git a/testsuite/java_test/string_test/RT0069-rt-String-EqualsTest/StringEqualsTest.java b/testsuite/java_test/string_test/RT0069-rt-String-EqualsTest/StringEqualsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9bbe54279945a7b0ecc077d5102dc0623ef37218
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0069-rt-String-EqualsTest/StringEqualsTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringEqualsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringEqualsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringEqualsTest_1() {
+        String str1_1 = new String("abc123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str1_6 = new String("ABc123");
+        String str2_1 = "abc123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        String str2_5 = null;
+        System.out.println(str1_1 + " equals " + str1_2 + " : " + str1_1.equals(str1_2));
+        System.out.println(str1_1 + " equals " + str1_3 + " : " + str1_1.equals(str1_3));
+        System.out.println(str1_1 + " equals " + str1_4 + " : " + str1_1.equals(str1_4));
+        System.out.println(str1_1 + " equals " + str1_5 + " : " + str1_1.equals(str1_5));
+        System.out.println(str1_1 + " equals " + str1_6 + " : " + str1_1.equals(str1_6));
+        System.out.println(str1_2 + " equals " + str2_2 + " : " + str1_2.equals(str2_2));
+        System.out.println(str2_1 + " equals " + str2_2 + " : " + str2_1.equals(str2_2));
+        System.out.println(str2_1 + " equals " + str2_3 + " : " + str2_1.equals(str2_3));
+        System.out.println(str2_1 + " equals " + str2_4 + " : " + str2_1.equals(str2_4));
+        System.out.println(str2_1 + " equals " + str2_5 + " : " + str2_1.equals(str2_5));
+        System.out.println(str1_1 + " equals " + str2_1 + " : " + str1_1.equals(str2_1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0069-rt-String-EqualsTest/expected.txt b/testsuite/java_test/string_test/RT0069-rt-String-EqualsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6363bce3275098d42d9d04c8c5fc961d3376bf92
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0069-rt-String-EqualsTest/expected.txt
@@ -0,0 +1,12 @@
+abc123 equals ****** : false
+abc123 equals abc123 : true
+abc123 equals  : false
+abc123 equals  : false
+abc123 equals ABc123 : false
+****** equals ****** : true
+abc123 equals ****** : false
+abc123 equals abc123 : true
+abc123 equals  : false
+abc123 equals null : false
+abc123 equals abc123 : true
+0
diff --git a/testsuite/java_test/string_test/RT0069-rt-String-EqualsTest/test.cfg b/testsuite/java_test/string_test/RT0069-rt-String-EqualsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a8353fee80c6bd8d39f36f7e1b9b9243d8557965
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0069-rt-String-EqualsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringEqualsTest)
+run(StringEqualsTest)
diff --git a/testsuite/java_test/string_test/RT0070-rt-String-ContentEqualsTest/StringContentEqualsTest.java b/testsuite/java_test/string_test/RT0070-rt-String-ContentEqualsTest/StringContentEqualsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce5cabb03230b26a8c2847ca08196f991ec74b06
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0070-rt-String-ContentEqualsTest/StringContentEqualsTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringContentEqualsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringContentEqualsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringContentEqualsTest_1() {
+        String str1_1 = new String("abc123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("ABc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123";
+        String str2_2 = "******";
+        String str2_3 = "ABc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String test = "abc123";
+        StringBuffer test1_1 = new StringBuffer(str);
+        boolean result = test.contentEquals(test1_1);
+        System.out.println(result);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0070-rt-String-ContentEqualsTest/expected.txt b/testsuite/java_test/string_test/RT0070-rt-String-ContentEqualsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0855059d4e8645ff018fdf2833d9f49f6f18ca75
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0070-rt-String-ContentEqualsTest/expected.txt
@@ -0,0 +1,10 @@
+true
+false
+false
+false
+false
+true
+false
+false
+false
+0
diff --git a/testsuite/java_test/string_test/RT0070-rt-String-ContentEqualsTest/test.cfg b/testsuite/java_test/string_test/RT0070-rt-String-ContentEqualsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..addafe49e98bf3c247833f3c2fe5ffe95431e668
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0070-rt-String-ContentEqualsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringContentEqualsTest)
+run(StringContentEqualsTest)
diff --git a/testsuite/java_test/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/StringContentEqualsCharSequenceTest.java b/testsuite/java_test/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/StringContentEqualsCharSequenceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc0ed0738eb3e1dd0b9ae5489a0d78039aef9bdd
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/StringContentEqualsCharSequenceTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringContentEqualsCharSequenceTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringContentEqualsCharSequenceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringContentEqualsCharSequenceTest_1() {
+        String str1_1 = new String("ABC123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "ABC123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String test = "abc123";
+        CharSequence test1_1 = str;
+        boolean result = test.contentEquals(test1_1);
+        System.out.println(result);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/expected.txt b/testsuite/java_test/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8038664d316487bea29806129916d26079483557
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/expected.txt
@@ -0,0 +1,10 @@
+false
+false
+true
+false
+false
+false
+false
+true
+false
+0
diff --git a/testsuite/java_test/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/test.cfg b/testsuite/java_test/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d2ce2f3cd221129a8664e74b7c6c368b3cec0362
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0071-rt-String-ContentEqualsCharSequenceTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringContentEqualsCharSequenceTest)
+run(StringContentEqualsCharSequenceTest)
diff --git a/testsuite/java_test/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/StringEqualsIgnoreCaseTest.java b/testsuite/java_test/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/StringEqualsIgnoreCaseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..95eece5fed6801a1150009fd1133ff9a5495d9bc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/StringEqualsIgnoreCaseTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringEqualsIgnoreCaseTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringEqualsIgnoreCaseTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringEqualsIgnoreCaseTest_1() {
+        String str1_1 = new String("ABC123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "ABC123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String test = "ABC123";
+        boolean result = test.equalsIgnoreCase(str);
+        System.out.println(result);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/expected.txt b/testsuite/java_test/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9c998cb111606bd2d7b210b7a0ea32f0941c4ce3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/expected.txt
@@ -0,0 +1,10 @@
+true
+false
+true
+false
+false
+true
+false
+true
+false
+0
diff --git a/testsuite/java_test/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/test.cfg b/testsuite/java_test/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dad8267c5ea94a473148ea6dc32e68c3bd0f3822
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0072-rt-String-EqualsIgnoreCaseTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringEqualsIgnoreCaseTest)
+run(StringEqualsIgnoreCaseTest)
diff --git a/testsuite/java_test/string_test/RT0073-rt-String-CompareToTest/StringCompareToTest.java b/testsuite/java_test/string_test/RT0073-rt-String-CompareToTest/StringCompareToTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..73ad50dfa753d18783acfe69048ba07537a33c78
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0073-rt-String-CompareToTest/StringCompareToTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCompareToTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCompareToTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCompareToTest_1() {
+        String str1_1 = new String("ABC123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "ABC123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String test = "ABC123";
+        int result = test.compareTo(str);
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0073-rt-String-CompareToTest/expected.txt b/testsuite/java_test/string_test/RT0073-rt-String-CompareToTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cbafb34a604dddae9b2494b3f476e752b7a14c0e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0073-rt-String-CompareToTest/expected.txt
@@ -0,0 +1,10 @@
+0
+23
+-32
+6
+6
+0
+23
+-32
+6
+0
diff --git a/testsuite/java_test/string_test/RT0073-rt-String-CompareToTest/test.cfg b/testsuite/java_test/string_test/RT0073-rt-String-CompareToTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1220e1a4251722bff211d42549f0c0427007c89b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0073-rt-String-CompareToTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCompareToTest)
+run(StringCompareToTest)
diff --git a/testsuite/java_test/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/StringCompareToIgnoreCaseTest.java b/testsuite/java_test/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/StringCompareToIgnoreCaseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e601e6f965af151dd28cad3bd8dd4283655ad92
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/StringCompareToIgnoreCaseTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCompareToIgnoreCaseTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCompareToIgnoreCaseTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCompareToIgnoreCaseTest_1() {
+        String str1_1 = new String("ABC123");
+        String str1_2 = new String("******");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "ABC123";
+        String str2_2 = "******";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String test = "ABC123";
+        int result = test.compareToIgnoreCase(str);
+        System.out.println(result);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/expected.txt b/testsuite/java_test/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9b39601567cb2c93ec435fe2253c8387dbd6543d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/expected.txt
@@ -0,0 +1,10 @@
+0
+55
+0
+6
+6
+0
+55
+0
+6
+0
diff --git a/testsuite/java_test/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/test.cfg b/testsuite/java_test/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dd191faa18e5bc2e1af7ce062517efc309bf9646
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0074-rt-String-CompareToIgnoreCaseTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCompareToIgnoreCaseTest)
+run(StringCompareToIgnoreCaseTest)
diff --git a/testsuite/java_test/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/StringRegionMatchesIntStringIntIntTest.java b/testsuite/java_test/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/StringRegionMatchesIntStringIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5bf547a06e890e5281f448e9040d095d329ef463
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/StringRegionMatchesIntStringIntIntTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringRegionMatchesIntStringIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringRegionMatchesIntStringIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringRegionMatchesIntStringIntIntTest_1() {
+        String str1_1 = new String("abc123_SAME");
+        String str1_2 = new String("      _same");
+        String str1_3 = new String("abc123_same");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123_SAME";
+        String str2_2 = "      _same";
+        String str2_3 = "abc123_same";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String test = "same";
+        // Test 0 =< toffset < instance.length, 0 =< ooffset < other.length,
+        // 0 =< len < 0 =< len < Min value of other.length - ooffset -1 and instance.length - toffset - 1
+        System.out.println(str.regionMatches(7, test, 0, 4));
+        System.out.println(str.regionMatches(7, test, 0, 5));
+        System.out.println(str.regionMatches(8, test, 1, 3));
+        // Test toffset < 0.
+        System.out.println(str.regionMatches(-2, test, 0, 2));
+        // Test toffset = 0.
+        System.out.println(str.regionMatches(0, test, 1, 1));
+        // Test toffset < instance.length - 1.
+        System.out.println(str.regionMatches(10, test, 1, 1));
+        // Test ooffset = other.length - 1.
+        System.out.println(str.regionMatches(10, test, 3, 1));
+        // Test len = 0.
+        System.out.println(str.regionMatches(7, test, 0, 0));
+        // Test len = str.length().
+        System.out.println(str.regionMatches(7, test, 0, str.length()));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c3a47ba638d964e4c2ca5fb6470eccfe8b73a7dc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/expected.txt
@@ -0,0 +1,82 @@
+false
+false
+false
+false
+true
+false
+false
+true
+false
+true
+false
+true
+false
+false
+false
+true
+true
+false
+true
+false
+true
+false
+true
+false
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+true
+false
+true
+false
+true
+false
+false
+false
+true
+true
+false
+true
+false
+true
+false
+true
+false
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+0
diff --git a/testsuite/java_test/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..19bf2d342c2a4aacb29b470a53a27de77caa0070
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0075-rt-String-RegionMatchesIntStringIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringRegionMatchesIntStringIntIntTest)
+run(StringRegionMatchesIntStringIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/StringRegionMatchesBooleanIntStringIntIntTest.java b/testsuite/java_test/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/StringRegionMatchesBooleanIntStringIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..891df17ebe069097e3d6b927bc6b61c3c09391de
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/StringRegionMatchesBooleanIntStringIntIntTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringRegionMatchesBooleanIntStringIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringRegionMatchesBooleanIntStringIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringRegionMatchesBooleanIntStringIntIntTest_1() {
+        String str1_1 = new String("abc123_SAME");
+        String str1_2 = new String("      _same");
+        String str1_3 = new String("abc123_same");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123_SAME";
+        String str2_2 = "      _same";
+        String str2_3 = "abc123_same";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String test = "SAME";
+        // Test ooffset = 0, len = Min value of other.length - ooffset and instance.length - toffset.
+        System.out.println(str.regionMatches(true, 7, test, 0, 4));
+        System.out.println(str.regionMatches(false, 7, test, 0, 4));
+        // Test toffset = 0.
+        System.out.println(str.regionMatches(true, 0, test, 1, 1));
+        System.out.println(str.regionMatches(false, 0, test, 1, 1));
+        // Test toffset = str.length() - 1, ooffset = test.length() - 1.
+        System.out.println(str.regionMatches(true, str.length() - 1, test, 3, 1));
+        System.out.println(str.regionMatches(false, str.length() - 1, test, 3, 1));
+        // Test len = 0.
+        System.out.println(str.regionMatches(true, 7, test, 0, 0));
+        System.out.println(str.regionMatches(false, 7, test, 0, 0));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..01aa99dbd8495ca06d76a758ac967e73d50e280f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/expected.txt
@@ -0,0 +1,73 @@
+true
+true
+true
+false
+true
+true
+true
+true
+true
+false
+false
+false
+true
+false
+true
+true
+true
+false
+true
+false
+true
+false
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+false
+true
+true
+true
+true
+true
+false
+false
+false
+true
+false
+true
+true
+true
+false
+true
+false
+true
+false
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+0
diff --git a/testsuite/java_test/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b3a3a3077e7cdb1d03571967e893123f28968e6c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringRegionMatchesBooleanIntStringIntIntTest)
+run(StringRegionMatchesBooleanIntStringIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0077-rt-String-StartsWithStringIntTest/StringStartsWithStringIntTest.java b/testsuite/java_test/string_test/RT0077-rt-String-StartsWithStringIntTest/StringStartsWithStringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2418c451b5ca146f6fd883629fd4982ee12822c2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0077-rt-String-StartsWithStringIntTest/StringStartsWithStringIntTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringStartsWithStringIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringStartsWithStringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringStartsWithStringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.startsWith("123", 3));
+        // Test toffset = 0.
+        System.out.println(str.startsWith("abc", 0));
+        // Test toffset = str.length() - 1.
+        System.out.println(str.startsWith("%", str.length() - 1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0077-rt-String-StartsWithStringIntTest/expected.txt b/testsuite/java_test/string_test/RT0077-rt-String-StartsWithStringIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4f7039c3c8fc5127fa90780983fabb7cca54ff35
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0077-rt-String-StartsWithStringIntTest/expected.txt
@@ -0,0 +1,28 @@
+false
+false
+false
+false
+false
+true
+true
+true
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+true
+true
+false
+false
+false
+false
+0
diff --git a/testsuite/java_test/string_test/RT0077-rt-String-StartsWithStringIntTest/test.cfg b/testsuite/java_test/string_test/RT0077-rt-String-StartsWithStringIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..449b8d6fb8f9331bdf54f19bf0b7a2bcba84b266
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0077-rt-String-StartsWithStringIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringStartsWithStringIntTest)
+run(StringStartsWithStringIntTest)
diff --git a/testsuite/java_test/string_test/RT0078-rt-String-StartsWithStringTest/StringStartsWithStringTest.java b/testsuite/java_test/string_test/RT0078-rt-String-StartsWithStringTest/StringStartsWithStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..453e87e501051be127b2431a24515d0ece3361d1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0078-rt-String-StartsWithStringTest/StringStartsWithStringTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringStartsWithStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringStartsWithStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringStartsWithStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.startsWith("ab"));
+        System.out.println(str.startsWith(""));
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0078-rt-String-StartsWithStringTest/expected.txt b/testsuite/java_test/string_test/RT0078-rt-String-StartsWithStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a2db6b6d1f3d6840bebf81ac4481246806db72a7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0078-rt-String-StartsWithStringTest/expected.txt
@@ -0,0 +1,19 @@
+false
+true
+false
+true
+true
+true
+false
+true
+false
+true
+false
+true
+false
+true
+true
+true
+false
+true
+0
diff --git a/testsuite/java_test/string_test/RT0078-rt-String-StartsWithStringTest/test.cfg b/testsuite/java_test/string_test/RT0078-rt-String-StartsWithStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa0fe2134a4de06cb5c62bb915ba071c06297fe9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0078-rt-String-StartsWithStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringStartsWithStringTest)
+run(StringStartsWithStringTest)
diff --git a/testsuite/java_test/string_test/RT0079-rt-String-EndsWithTest/StringEndsWithTest.java b/testsuite/java_test/string_test/RT0079-rt-String-EndsWithTest/StringEndsWithTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..85a8f819fccdf8a19de872b29f236505a1ec5550
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0079-rt-String-EndsWithTest/StringEndsWithTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringEndsWithTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringEndsWithTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringEndsWithTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.endsWith("bc"));
+        System.out.println(str.endsWith(""));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0079-rt-String-EndsWithTest/expected.txt b/testsuite/java_test/string_test/RT0079-rt-String-EndsWithTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..577184267278d54682752a15828022684c907320
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0079-rt-String-EndsWithTest/expected.txt
@@ -0,0 +1,19 @@
+false
+true
+false
+true
+true
+true
+false
+true
+false
+true
+false
+true
+false
+true
+false
+true
+false
+true
+0
diff --git a/testsuite/java_test/string_test/RT0079-rt-String-EndsWithTest/test.cfg b/testsuite/java_test/string_test/RT0079-rt-String-EndsWithTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b9793d8515a9230b6bf80d174f423db62863b1d1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0079-rt-String-EndsWithTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringEndsWithTest)
+run(StringEndsWithTest)
diff --git a/testsuite/java_test/string_test/RT0080-rt-String-HashCodeTest/StringHashCodeTest.java b/testsuite/java_test/string_test/RT0080-rt-String-HashCodeTest/StringHashCodeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4044da7bd52a9eac845bc836e34a18db1bd7793
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0080-rt-String-HashCodeTest/StringHashCodeTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringHashCodeTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringHashCodeTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringHashCodeTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!" +
+                "@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.hashCode());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0080-rt-String-HashCodeTest/expected.txt b/testsuite/java_test/string_test/RT0080-rt-String-HashCodeTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c089f1d2a52c8fd145e45c7614c56ccd79621dde
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0080-rt-String-HashCodeTest/expected.txt
@@ -0,0 +1,10 @@
+-736345066
+976266700
+-1113531438
+0
+0
+-736345066
+976266700
+-1113563214
+0
+0
diff --git a/testsuite/java_test/string_test/RT0080-rt-String-HashCodeTest/test.cfg b/testsuite/java_test/string_test/RT0080-rt-String-HashCodeTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a04c10cd9ca289ba1f90cc9a8dce1e57444fe609
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0080-rt-String-HashCodeTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringHashCodeTest)
+run(StringHashCodeTest)
diff --git a/testsuite/java_test/string_test/RT0081-rt-String-IndexOfIntTest/StringIndexOfIntTest.java b/testsuite/java_test/string_test/RT0081-rt-String-IndexOfIntTest/StringIndexOfIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3d24e58695bc4923f25518131a733ce0e3b91ad
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0081-rt-String-IndexOfIntTest/StringIndexOfIntTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringIndexOfIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringIndexOfIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringIndexOfIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUI" +
+                "OPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.indexOf(98));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0081-rt-String-IndexOfIntTest/expected.txt b/testsuite/java_test/string_test/RT0081-rt-String-IndexOfIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b56ed492965d96f08976b7a08931896b8ebb9845
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0081-rt-String-IndexOfIntTest/expected.txt
@@ -0,0 +1,10 @@
+33
+-1
+1
+-1
+-1
+33
+-1
+1
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0081-rt-String-IndexOfIntTest/test.cfg b/testsuite/java_test/string_test/RT0081-rt-String-IndexOfIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d8602ef45001fd332a8311a159e7505bcc1f1079
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0081-rt-String-IndexOfIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringIndexOfIntTest)
+run(StringIndexOfIntTest)
diff --git a/testsuite/java_test/string_test/RT0082-rt-String-IndexOfIntIntTest/StringIndexOfIntIntTest.java b/testsuite/java_test/string_test/RT0082-rt-String-IndexOfIntIntTest/StringIndexOfIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c976eb6962962ac8340ecf45af1a56c9a372c47a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0082-rt-String-IndexOfIntIntTest/StringIndexOfIntIntTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringIndexOfIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringIndexOfIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringIndexOfIntIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ " +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZX" +
+                "CVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        // Test 0 < fromIndex < str.length().
+        System.out.println(str.indexOf(98, 2));
+        // Test fromIndex = 0.
+        System.out.println(str.indexOf(98, 0));
+        // Test fromIndex = str.length().
+        System.out.println(str.indexOf(98, str.length()));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0082-rt-String-IndexOfIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0082-rt-String-IndexOfIntIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0912c373865b82992e36d1dfa8d5aca8cfee8a3c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0082-rt-String-IndexOfIntIntTest/expected.txt
@@ -0,0 +1,28 @@
+33
+33
+-1
+-1
+-1
+-1
+7
+1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+33
+33
+-1
+-1
+-1
+-1
+-1
+1
+-1
+-1
+-1
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0082-rt-String-IndexOfIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0082-rt-String-IndexOfIntIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a4d52cf1cf149d5ebdeb79a7e55c80d4a408615e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0082-rt-String-IndexOfIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringIndexOfIntIntTest)
+run(StringIndexOfIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0083-rt-String-LastIndexOfIntTest/StringLastIndexOfIntTest.java b/testsuite/java_test/string_test/RT0083-rt-String-LastIndexOfIntTest/StringLastIndexOfIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c81df65a737735a9a3833e3a4c7cff110dfe1d1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0083-rt-String-LastIndexOfIntTest/StringLastIndexOfIntTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringLastIndexOfIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringLastIndexOfIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringLastIndexOfIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+" +
+                "ASDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZ" +
+                "XCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.lastIndexOf(98));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0083-rt-String-LastIndexOfIntTest/expected.txt b/testsuite/java_test/string_test/RT0083-rt-String-LastIndexOfIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6b5bbe12663416eb93ea651d00f4761ace2e9080
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0083-rt-String-LastIndexOfIntTest/expected.txt
@@ -0,0 +1,10 @@
+33
+-1
+7
+-1
+-1
+33
+-1
+1
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0083-rt-String-LastIndexOfIntTest/test.cfg b/testsuite/java_test/string_test/RT0083-rt-String-LastIndexOfIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3d9ab636b0c2e55bc966169b815e9259e8f499b7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0083-rt-String-LastIndexOfIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringLastIndexOfIntTest)
+run(StringLastIndexOfIntTest)
diff --git a/testsuite/java_test/string_test/RT0084-rt-String-LastIndexOfIntIntTest/StringLastIndexOfIntIntTest.java b/testsuite/java_test/string_test/RT0084-rt-String-LastIndexOfIntIntTest/StringLastIndexOfIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..019fd05796d3d7c9bf4577aa00aa91747eff9bbe
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0084-rt-String-LastIndexOfIntIntTest/StringLastIndexOfIntIntTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringLastIndexOfIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringLastIndexOfIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringLastIndexOfIntIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASD" +
+                "FGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        // Test fromIndex = 0.
+        System.out.println(str.lastIndexOf(49, 0));
+        // Test 0 < fromIndex < str.length().
+        System.out.println(str.lastIndexOf(49, 3));
+        // Test fromIndex = str.length().
+        System.out.println(str.lastIndexOf(49, str.length()));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0084-rt-String-LastIndexOfIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0084-rt-String-LastIndexOfIntIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..75e36f1003377a59c846c5ed56e1abb110487fca
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0084-rt-String-LastIndexOfIntIntTest/expected.txt
@@ -0,0 +1,28 @@
+-1
+-1
+44
+-1
+-1
+-1
+-1
+3
+3
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+44
+-1
+-1
+-1
+-1
+3
+3
+-1
+-1
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0084-rt-String-LastIndexOfIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0084-rt-String-LastIndexOfIntIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..93e7d95168903488bfd983af5a9d7bd58bdd0a24
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0084-rt-String-LastIndexOfIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringLastIndexOfIntIntTest)
+run(StringLastIndexOfIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0085-rt-String-IndexOfStringTest/StringIndexOfStringTest.java b/testsuite/java_test/string_test/RT0085-rt-String-IndexOfStringTest/StringIndexOfStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b7c09231a5f984c088dc84cf205aed3aa0a7ce6e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0085-rt-String-IndexOfStringTest/StringIndexOfStringTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringIndexOfStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringIndexOfStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringIndexOfStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.indexOf("c"));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0085-rt-String-IndexOfStringTest/expected.txt b/testsuite/java_test/string_test/RT0085-rt-String-IndexOfStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4cd324151992770f1456789108d66da46b9bbdfe
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0085-rt-String-IndexOfStringTest/expected.txt
@@ -0,0 +1,10 @@
+31
+-1
+2
+-1
+-1
+31
+-1
+2
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0085-rt-String-IndexOfStringTest/test.cfg b/testsuite/java_test/string_test/RT0085-rt-String-IndexOfStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1be42ba8efff3af599c6d11a5c0651bf087004a4
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0085-rt-String-IndexOfStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringIndexOfStringTest)
+run(StringIndexOfStringTest)
diff --git a/testsuite/java_test/string_test/RT0086-rt-String-IndexOfStringIntTest/StringIndexOfStringIntTest.java b/testsuite/java_test/string_test/RT0086-rt-String-IndexOfStringIntTest/StringIndexOfStringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ff3b9cc17729040eaaf5dd504a27bb322054c3e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0086-rt-String-IndexOfStringIntTest/StringIndexOfStringIntTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringIndexOfStringIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringIndexOfStringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringIndexOfStringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        // Test fromIndex = 0.
+        System.out.println(str.indexOf("c", 0));
+        // Test 0 < fromIndex < str.length().
+        System.out.println(str.indexOf("c", 4));
+        // Test fromIndex = str.length().
+        System.out.println(str.indexOf("c", str.length()));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0086-rt-String-IndexOfStringIntTest/expected.txt b/testsuite/java_test/string_test/RT0086-rt-String-IndexOfStringIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..acc42d0ef598673481940e9673a4d0e60ae12d6b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0086-rt-String-IndexOfStringIntTest/expected.txt
@@ -0,0 +1,28 @@
+31
+31
+-1
+-1
+-1
+-1
+2
+8
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+31
+31
+-1
+-1
+-1
+-1
+2
+-1
+-1
+-1
+-1
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0086-rt-String-IndexOfStringIntTest/test.cfg b/testsuite/java_test/string_test/RT0086-rt-String-IndexOfStringIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..21dd7354a20ca9707bbd544228633a1cb0038a18
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0086-rt-String-IndexOfStringIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringIndexOfStringIntTest)
+run(StringIndexOfStringIntTest)
diff --git a/testsuite/java_test/string_test/RT0087-rt-String-LastIndexOfStringTest/StringLastIndexOfStringTest.java b/testsuite/java_test/string_test/RT0087-rt-String-LastIndexOfStringTest/StringLastIndexOfStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb859bb68c9204c3e9f047bd8ca2771a4cc58864
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0087-rt-String-LastIndexOfStringTest/StringLastIndexOfStringTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringLastIndexOfStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringLastIndexOfStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringLastIndexOfStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZX" +
+                "CVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.lastIndexOf("c"));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0087-rt-String-LastIndexOfStringTest/expected.txt b/testsuite/java_test/string_test/RT0087-rt-String-LastIndexOfStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..281178c31338f274e6392c87e28515b83fe66a58
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0087-rt-String-LastIndexOfStringTest/expected.txt
@@ -0,0 +1,10 @@
+31
+-1
+8
+-1
+-1
+31
+-1
+2
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0087-rt-String-LastIndexOfStringTest/test.cfg b/testsuite/java_test/string_test/RT0087-rt-String-LastIndexOfStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..099ac8465955b551325e1007ae49b1d3f7d5eeed
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0087-rt-String-LastIndexOfStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringLastIndexOfStringTest)
+run(StringLastIndexOfStringTest)
diff --git a/testsuite/java_test/string_test/RT0088-rt-String-LastIndexOfStringIntTest/StringLastIndexOfStringIntTest.java b/testsuite/java_test/string_test/RT0088-rt-String-LastIndexOfStringIntTest/StringLastIndexOfStringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bca656539083215922c6e69d4fec532da7bf2f1f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0088-rt-String-LastIndexOfStringIntTest/StringLastIndexOfStringIntTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringLastIndexOfStringIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringLastIndexOfStringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringLastIndexOfStringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASD" +
+                "FGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZX" +
+                "CVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        // Test fromIndex = 0.
+        System.out.println(str.lastIndexOf("c", 0));
+        // Test 0 < fromIndex < str.length().
+        System.out.println(str.lastIndexOf("c", 2));
+        // Test fromIndex = str.length().
+        System.out.println(str.lastIndexOf("c", str.length()));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0088-rt-String-LastIndexOfStringIntTest/expected.txt b/testsuite/java_test/string_test/RT0088-rt-String-LastIndexOfStringIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9f6913e71feaad39582925c9fd1524fec9e44818
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0088-rt-String-LastIndexOfStringIntTest/expected.txt
@@ -0,0 +1,28 @@
+-1
+-1
+31
+-1
+-1
+-1
+-1
+2
+8
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+31
+-1
+-1
+-1
+-1
+2
+2
+-1
+-1
+-1
+0
diff --git a/testsuite/java_test/string_test/RT0088-rt-String-LastIndexOfStringIntTest/test.cfg b/testsuite/java_test/string_test/RT0088-rt-String-LastIndexOfStringIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fbe60c8d9b233f895a09cec4688c50475934cf36
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0088-rt-String-LastIndexOfStringIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringLastIndexOfStringIntTest)
+run(StringLastIndexOfStringIntTest)
diff --git a/testsuite/java_test/string_test/RT0089-rt-String-SubstringIntTest/StringSubstringIntTest.java b/testsuite/java_test/string_test/RT0089-rt-String-SubstringIntTest/StringSubstringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e78b93a63c7431700b363a7317610a48521091f2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0089-rt-String-SubstringIntTest/StringSubstringIntTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringSubstringIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringSubstringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringSubstringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTY" +
+                "UIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        // Test beginIndex = 0.
+        System.out.println(str.substring(0));
+        // Test 0 < beginIndex < str.length().
+        System.out.println(str.substring(4));
+        // Test beginIndex = str.length().
+        System.out.println(str.substring(str.length()));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0089-rt-String-SubstringIntTest/expected.txt b/testsuite/java_test/string_test/RT0089-rt-String-SubstringIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6d38016df308e4ae74e832fb3cf816d431f9a16d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0089-rt-String-SubstringIntTest/expected.txt
@@ -0,0 +1,19 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+tyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+ @!.&%
+&%
+
+abc123abc
+23abc
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+tyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+ @!.&%
+&%
+
+abc123ABC
+23ABC
+
+0
diff --git a/testsuite/java_test/string_test/RT0089-rt-String-SubstringIntTest/test.cfg b/testsuite/java_test/string_test/RT0089-rt-String-SubstringIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9ed8eafa82a3a86fbe04d398b792cafd9c9fb5dd
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0089-rt-String-SubstringIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSubstringIntTest)
+run(StringSubstringIntTest)
diff --git a/testsuite/java_test/string_test/RT0090-rt-String-SubstringIntIntTest/StringSubstringIntIntTest.java b/testsuite/java_test/string_test/RT0090-rt-String-SubstringIntIntTest/StringSubstringIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..47231b53622d521a090f856c261e8da14161f353
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0090-rt-String-SubstringIntIntTest/StringSubstringIntIntTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringSubstringIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringSubstringIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringSubstringIntIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXC" +
+                "VBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        // Test 0 < beginIndex < endIndex < str.length().
+        System.out.println(str.substring(2, 5));
+        // Test beginIndex = 0.
+        System.out.println(str.substring(0, str.length() - 1));
+        // Test endIndex = 0.
+        System.out.println(str.substring(0, 0));
+        // Test beginIndex = str.length() - 1.
+        System.out.println(str.substring(str.length() - 1, str.length() - 1));
+        // Test endIndex = str.length.
+        System.out.println(str.substring(2, str.length() - 1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0090-rt-String-SubstringIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0090-rt-String-SubstringIntIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5b074fbcd1246ebe5bbde78e961fdb6f503712ce
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0090-rt-String-SubstringIntIntTest/expected.txt
@@ -0,0 +1,31 @@
+ert
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x9
+
+
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x9
+!.&
+ @!.&
+
+
+!.&
+c12
+abc123ab
+
+
+c123ab
+ert
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x9
+
+
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ASDFGHJKLQWERTYUIOPZXCVBNM0x9
+!.&
+ @!.&
+
+
+!.&
+c12
+abc123AB
+
+
+c123AB
+0
diff --git a/testsuite/java_test/string_test/RT0090-rt-String-SubstringIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0090-rt-String-SubstringIntIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..98818af1bf83f99ac288fe14ef784fee9e08d351
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0090-rt-String-SubstringIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSubstringIntIntTest)
+run(StringSubstringIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0091-rt-String-SubSequenceIntIntTest/StringSubSequenceIntIntTest.java b/testsuite/java_test/string_test/RT0091-rt-String-SubSequenceIntIntTest/StringSubSequenceIntIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d2397ebf93097919d4e6f113a735d79e4025af7d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0091-rt-String-SubSequenceIntIntTest/StringSubSequenceIntIntTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringSubSequenceIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringSubSequenceIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringSubSequenceIntIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZ" +
+                "XCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+    }
+    private static void test(String str) {
+        // Test 0 < beginIndex < endIndex < str.length().
+        System.out.println(str.subSequence(2, 6));
+        // Test beginIndex = 0.
+        System.out.println(str.subSequence(0, str.length()));
+        // Test enfIndex = 0.
+        System.out.println(str.subSequence(0, 0));
+        // Test beginIndex = str.length().
+        System.out.println(str.subSequence(str.length(), str.length()));
+        // Test endIndex = str.length().
+        System.out.println(str.subSequence(2, str.length()));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0091-rt-String-SubSequenceIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0091-rt-String-SubSequenceIntIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b35a562f9155bb3569da97604713068ed6c1034a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0091-rt-String-SubSequenceIntIntTest/expected.txt
@@ -0,0 +1,31 @@
+erty
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+!.&%
+ @!.&%
+
+
+!.&%
+c123
+abc123abc
+
+
+c123abc
+erty
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+
+
+ertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+!.&%
+ @!.&%
+
+
+!.&%
+c123
+abc123ABC
+
+
+c123ABC
+0
diff --git a/testsuite/java_test/string_test/RT0091-rt-String-SubSequenceIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0091-rt-String-SubSequenceIntIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9d03c0a3f0ab4bca0c5a29e375c485002a93d9e2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0091-rt-String-SubSequenceIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSubSequenceIntIntTest)
+run(StringSubSequenceIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0092-rt-String-ConcatTest/StringConcatTest.java b/testsuite/java_test/string_test/RT0092-rt-String-ConcatTest/StringConcatTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2250adc386f806b31a9a99e69e82104ca7e7d297
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0092-rt-String-ConcatTest/StringConcatTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConcatTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConcatTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringConcatTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String test1_1 = "<begin>";
+        String test1_2 = "<end>";
+        System.out.println(test1_1.concat(str).concat(test1_2));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0092-rt-String-ConcatTest/expected.txt b/testsuite/java_test/string_test/RT0092-rt-String-ConcatTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f860c1e6730cb4d652e9db27a4163bf1361fd47d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0092-rt-String-ConcatTest/expected.txt
@@ -0,0 +1,10 @@
+<begin>qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96<end>
+<begin> @!.&%<end>
+<begin>abc123abc<end>
+<begin><end>
+<begin><end>
+<begin>qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96<end>
+<begin> @!.&%<end>
+<begin>abc123ABC<end>
+<begin><end>
+0
diff --git a/testsuite/java_test/string_test/RT0092-rt-String-ConcatTest/test.cfg b/testsuite/java_test/string_test/RT0092-rt-String-ConcatTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7ea5c2ca8a6747c90e386bd0c0a9778055611465
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0092-rt-String-ConcatTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConcatTest)
+run(StringConcatTest)
diff --git a/testsuite/java_test/string_test/RT0093-rt-String-ReplaceCharCharTest/StringReplaceCharCharTest.java b/testsuite/java_test/string_test/RT0093-rt-String-ReplaceCharCharTest/StringReplaceCharCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..17cdef354b493951420a85f1fef70566775695f6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0093-rt-String-ReplaceCharCharTest/StringReplaceCharCharTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringReplaceCharCharTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringReplaceCharCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringReplaceCharCharTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.replace("a", "@").replace("1", "!"));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0093-rt-String-ReplaceCharCharTest/expected.txt b/testsuite/java_test/string_test/RT0093-rt-String-ReplaceCharCharTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2f4e1e3771720e455316c1ebb7d71e4ee64b9211
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0093-rt-String-ReplaceCharCharTest/expected.txt
@@ -0,0 +1,10 @@
+qwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`!234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+@bc!23@bc
+
+
+qwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`!234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+@bc!23ABC
+
+0
diff --git a/testsuite/java_test/string_test/RT0093-rt-String-ReplaceCharCharTest/test.cfg b/testsuite/java_test/string_test/RT0093-rt-String-ReplaceCharCharTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7311b9e22acc4d19aa6e8a85dc0d0ecf72f4c2a5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0093-rt-String-ReplaceCharCharTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReplaceCharCharTest)
+run(StringReplaceCharCharTest)
diff --git a/testsuite/java_test/string_test/RT0094-rt-String-ContainsTest/StringContainsTest.java b/testsuite/java_test/string_test/RT0094-rt-String-ContainsTest/StringContainsTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c66759f326af34e0bb85e4dc9174bb89aa7bf9dc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0094-rt-String-ContainsTest/StringContainsTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringContainsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringContainsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringContainsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.contains("c123A"));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0094-rt-String-ContainsTest/expected.txt b/testsuite/java_test/string_test/RT0094-rt-String-ContainsTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9515db77b8254db14a3281f89d8981ed8fd26a2f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0094-rt-String-ContainsTest/expected.txt
@@ -0,0 +1,10 @@
+false
+false
+false
+false
+false
+false
+false
+true
+false
+0
diff --git a/testsuite/java_test/string_test/RT0094-rt-String-ContainsTest/test.cfg b/testsuite/java_test/string_test/RT0094-rt-String-ContainsTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4051bef39c3ce67935ee7a8969663a85681cda62
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0094-rt-String-ContainsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringContainsTest)
+run(StringContainsTest)
diff --git a/testsuite/java_test/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/StringReplaceCharSequenceCharSequenceTest.java b/testsuite/java_test/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/StringReplaceCharSequenceCharSequenceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e6354e81e17efb8f70009c52fab6c749f5ba360
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/StringReplaceCharSequenceCharSequenceTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringReplaceCharSequenceCharSequenceTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringReplaceCharSequenceCharSequenceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringReplaceCharSequenceCharSequenceTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYU" +
+                "IOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.replace("a", "@"));
+        System.out.println(str.replace("c123A", "@"));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/expected.txt b/testsuite/java_test/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e61ca79d750df85823177fadafa2e7196c7d1a1d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/expected.txt
@@ -0,0 +1,19 @@
+qwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ @!.&%
+@bc123@bc
+abc123abc
+
+
+
+
+qwertyuiop{}[]\|@sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ @!.&%
+@bc123ABC
+ab@BC
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/test.cfg b/testsuite/java_test/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0a1a6c3f2356520eb6bd1378ee2aabbff11dfcb2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0095-rt-String-ReplaceCharSequenceCharSequenceTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReplaceCharSequenceCharSequenceTest)
+run(StringReplaceCharSequenceCharSequenceTest)
diff --git a/testsuite/java_test/string_test/RT0096-rt-String-SplitStringIntTest/StringSplitStringIntTest.java b/testsuite/java_test/string_test/RT0096-rt-String-SplitStringIntTest/StringSplitStringIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..61c9c9ae5f7398d161837ce3486a26d78e8b5b64
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0096-rt-String-SplitStringIntTest/StringSplitStringIntTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringSplitStringIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringSplitStringIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringSplitStringIntTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String[] result;
+        // Test 0  < limit < instance.length.
+        result = str.split("a", 3);
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+        // Test limit = instance.length.
+        result = str.split("a",str.length());
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+        // Test limit = 0.
+        result = str.split("a",0);
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+        // Test regex is a special symbols.
+        result = str.split("\\.", 2);
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0096-rt-String-SplitStringIntTest/expected.txt b/testsuite/java_test/string_test/RT0096-rt-String-SplitStringIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..def2b8556ca2d05be40f4dd7d3248bc19b2dddfd
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0096-rt-String-SplitStringIntTest/expected.txt
@@ -0,0 +1,58 @@
+qwertyuiop{}[]\|
+sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|
+sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|
+sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,
+<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ @!.&%
+ @!.&%
+ @!
+&%
+
+bc.123.
+bc
+
+bc.123.
+bc
+
+bc.123.
+bc
+abc
+123.abc
+
+
+
+
+
+
+
+
+qwertyuiop{}[]\|
+sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|
+sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|
+sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,
+<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ @!.&%
+ @!.&%
+ @!
+&%
+
+bc.123.ABC
+
+bc.123.ABC
+
+bc.123.ABC
+abc
+123.ABC
+
+
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0096-rt-String-SplitStringIntTest/test.cfg b/testsuite/java_test/string_test/RT0096-rt-String-SplitStringIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d70cd7b47ce89da8c0b699cf90ed59c9b1eca9b0
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0096-rt-String-SplitStringIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSplitStringIntTest)
+run(StringSplitStringIntTest)
diff --git a/testsuite/java_test/string_test/RT0097-rt-String-SplitStringTest/StringSplitStringTest.java b/testsuite/java_test/string_test/RT0097-rt-String-SplitStringTest/StringSplitStringTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..57739491650698e4e0f4c4ce5bcce4dc4d5a56c6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0097-rt-String-SplitStringTest/StringSplitStringTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringSplitStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringSplitStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringSplitStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ A" +
+                "SDFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOP" +
+                "ZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String[] result;
+        result = str.split("a");
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+        result = str.split("\\.");
+        for (int i = 0; i < result.length; i++) {
+            System.out.println(result[i]);
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0097-rt-String-SplitStringTest/expected.txt b/testsuite/java_test/string_test/RT0097-rt-String-SplitStringTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6e7ba2c475f807a6197fbba226f3410413f39251
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0097-rt-String-SplitStringTest/expected.txt
@@ -0,0 +1,32 @@
+qwertyuiop{}[]\|
+sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,
+<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ @!
+&%
+
+bc.123.
+bc
+abc
+123
+abc
+
+
+
+
+qwertyuiop{}[]\|
+sdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,
+<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ @!
+&%
+
+bc.123.ABC
+abc
+123
+ABC
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0097-rt-String-SplitStringTest/test.cfg b/testsuite/java_test/string_test/RT0097-rt-String-SplitStringTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2c3c245842e01560ae5b6b4de5d6be2c51dc8810
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0097-rt-String-SplitStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSplitStringTest)
+run(StringSplitStringTest)
diff --git a/testsuite/java_test/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/StringJoinCharSequenceCharSequenceTest.java b/testsuite/java_test/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/StringJoinCharSequenceCharSequenceTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8a5de0acaa93d301ba987fa788534c93c4e81a8f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/StringJoinCharSequenceCharSequenceTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringJoinCharSequenceCharSequenceTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringJoinCharSequenceCharSequenceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringJoinCharSequenceCharSequenceTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String[] test = new String[]{str, str, str};
+        System.out.println(String.join("-", test));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/expected.txt b/testsuite/java_test/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..460fc604d3191a61cbb03d531b408def33f595c2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/expected.txt
@@ -0,0 +1,10 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%- @!.&%- @!.&%
+abc123abc-abc123abc-abc123abc
+--
+--
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%- @!.&%- @!.&%
+abc123ABC-abc123ABC-abc123ABC
+--
+0
diff --git a/testsuite/java_test/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/test.cfg b/testsuite/java_test/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e6b3de03911e6aa6f8158dd1c6dc6570247e8d10
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0098-rt-String-JoinCharSequenceCharSequenceTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringJoinCharSequenceCharSequenceTest)
+run(StringJoinCharSequenceCharSequenceTest)
diff --git a/testsuite/java_test/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/StringJoinCharSequenceIterableTest.java b/testsuite/java_test/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/StringJoinCharSequenceIterableTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6dee3125904234bc641fe4c9d4333d53a54eff1d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/StringJoinCharSequenceIterableTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+public class StringJoinCharSequenceIterableTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringJoinCharSequenceIterableTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringJoinCharSequenceIterableTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        List<String> test1_1 = new LinkedList<>();
+        test1_1.add(str);
+        test1_1.add(str);
+        test1_1.add(str);
+        System.out.println(String.join("-", test1_1));
+        Set<String> test1_2 = new LinkedHashSet<>();
+        test1_2.add(str);
+        test1_2.add(str);
+        test1_2.add(str);
+        System.out.println(String.join("~", test1_2));
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/expected.txt b/testsuite/java_test/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..34a67088806829cab3879b4c9698978b45919dd7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/expected.txt
@@ -0,0 +1,19 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%- @!.&%- @!.&%
+ @!.&%
+abc123abc-abc123abc-abc123abc
+abc123abc
+--
+
+--
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96-qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%- @!.&%- @!.&%
+ @!.&%
+abc123ABC-abc123ABC-abc123ABC
+abc123ABC
+--
+
+0
diff --git a/testsuite/java_test/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/test.cfg b/testsuite/java_test/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2b96c329dd67232c77e3a3a8088fcc0def7d3463
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0099-rt-String-JoinCharSequenceIterableTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringJoinCharSequenceIterableTest)
+run(StringJoinCharSequenceIterableTest)
diff --git a/testsuite/java_test/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/StringToLowerCaseLocaleTest.java b/testsuite/java_test/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/StringToLowerCaseLocaleTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..898c45a39610942994fbf0a29389650430abf615
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/StringToLowerCaseLocaleTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Locale;
+public class StringToLowerCaseLocaleTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringToLowerCaseLocaleTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringToLowerCaseLocaleTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc.~!@#$%^&*()_+;'/.?");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.toLowerCase(Locale.CHINESE));
+        System.out.println(str.toLowerCase(Locale.ENGLISH));
+        System.out.println(str.toLowerCase(Locale.FRENCH));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/expected.txt b/testsuite/java_test/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..e53bc1a242c855ef9d49dd76d4cc83f0e3969eb6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/expected.txt
@@ -0,0 +1,28 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96
+ @!.&%
+ @!.&%
+ @!.&%
+abc.123.abc.~!@#$%^&*()_+;'/.?
+abc.123.abc.~!@#$%^&*()_+;'/.?
+abc.123.abc.~!@#$%^&*()_+;'/.?
+
+
+
+
+
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96
+ @!.&%
+ @!.&%
+ @!.&%
+abc.123.abc
+abc.123.abc
+abc.123.abc
+
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/test.cfg b/testsuite/java_test/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..34c8ea72e75fb49bebb47aea95f850aaf84f731c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0100-rt-String-ToLowerCaseLocaleTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringToLowerCaseLocaleTest)
+run(StringToLowerCaseLocaleTest)
diff --git a/testsuite/java_test/string_test/RT0101-rt-String-ToLowerCaseTest/StringToLowerCaseTest.java b/testsuite/java_test/string_test/RT0101-rt-String-ToLowerCaseTest/StringToLowerCaseTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c4eff4697a9f192a58ccc7633bf564ad0728b04
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0101-rt-String-ToLowerCaseTest/StringToLowerCaseTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringToLowerCaseTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringToLowerCaseTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringToLowerCaseTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc.~!@#$%^&*()_+;'/.?");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.toLowerCase());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0101-rt-String-ToLowerCaseTest/expected.txt b/testsuite/java_test/string_test/RT0101-rt-String-ToLowerCaseTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..2927b543ba92f5165a45cf82146fc05940461049
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0101-rt-String-ToLowerCaseTest/expected.txt
@@ -0,0 +1,10 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96
+ @!.&%
+abc.123.abc.~!@#$%^&*()_+;'/.?
+
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ asdfghjklqwertyuiopzxcvbnm0x96
+ @!.&%
+abc.123.abc
+
+0
diff --git a/testsuite/java_test/string_test/RT0101-rt-String-ToLowerCaseTest/test.cfg b/testsuite/java_test/string_test/RT0101-rt-String-ToLowerCaseTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2500752bd79fc910eb86b9cc6ebfc63fde274367
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0101-rt-String-ToLowerCaseTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringToLowerCaseTest)
+run(StringToLowerCaseTest)
diff --git a/testsuite/java_test/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/StringToUpperCaseLocaleTest.java b/testsuite/java_test/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/StringToUpperCaseLocaleTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..68341774645c905d1f823c2b5ed80037033abe97
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/StringToUpperCaseLocaleTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Locale;
+public class StringToUpperCaseLocaleTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringToUpperCaseLocaleTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringToUpperCaseLocaleTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc.~!@#$%^&*()_+;'/.?");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.toUpperCase(Locale.CHINESE));
+        System.out.println(str.toUpperCase(Locale.ENGLISH));
+        System.out.println(str.toUpperCase(Locale.FRENCH));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/expected.txt b/testsuite/java_test/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..4f0d0a5886a42c0346e9533518ecb7db053b8535
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/expected.txt
@@ -0,0 +1,28 @@
+QWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96
+QWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96
+QWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96
+ @!.&%
+ @!.&%
+ @!.&%
+ABC.123.ABC.~!@#$%^&*()_+;'/.?
+ABC.123.ABC.~!@#$%^&*()_+;'/.?
+ABC.123.ABC.~!@#$%^&*()_+;'/.?
+
+
+
+
+
+
+QWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96
+QWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96
+QWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96
+ @!.&%
+ @!.&%
+ @!.&%
+ABC.123.ABC
+ABC.123.ABC
+ABC.123.ABC
+
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/test.cfg b/testsuite/java_test/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9e75b2bb039c645fb4c8cb6e57e80de140ffcc80
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0102-rt-String-ToUpperCaseLocaleTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringToUpperCaseLocaleTest)
+run(StringToUpperCaseLocaleTest)
diff --git a/testsuite/java_test/string_test/RT0103-rt-String-ToUpperCaseTest/StringToUpperCaseTest.java b/testsuite/java_test/string_test/RT0103-rt-String-ToUpperCaseTest/StringToUpperCaseTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8ab8ba6d48383309a27098749423fdc743796bc4
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0103-rt-String-ToUpperCaseTest/StringToUpperCaseTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringToUpperCaseTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringToUpperCaseTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringToUpperCaseTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc.123.abc.~!@#$%^&*()_+;'/.?");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc.123.ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str.toUpperCase());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0103-rt-String-ToUpperCaseTest/expected.txt b/testsuite/java_test/string_test/RT0103-rt-String-ToUpperCaseTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..5fc4eb463636e958bb9ee5c1eb37c6e201180756
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0103-rt-String-ToUpperCaseTest/expected.txt
@@ -0,0 +1,10 @@
+QWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96
+ @!.&%
+ABC.123.ABC.~!@#$%^&*()_+;'/.?
+
+
+QWERTYUIOP{}[]\|ASDFGHJKL;:'"ZXCVBNM,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0X96
+ @!.&%
+ABC.123.ABC
+
+0
diff --git a/testsuite/java_test/string_test/RT0103-rt-String-ToUpperCaseTest/test.cfg b/testsuite/java_test/string_test/RT0103-rt-String-ToUpperCaseTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6670501c5fdc140c729e55024045d33f22fa06b6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0103-rt-String-ToUpperCaseTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringToUpperCaseTest)
+run(StringToUpperCaseTest)
diff --git a/testsuite/java_test/string_test/RT0104-rt-String-TrimTest/StringTrimTest.java b/testsuite/java_test/string_test/RT0104-rt-String-TrimTest/StringTrimTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..9caa7b903016f09ca610641077db56795a6f5d42
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0104-rt-String-TrimTest/StringTrimTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringTrimTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringTrimTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringTrimTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String(" abc.123.abc ");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = " abc.123.ABC ";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        char data3_1[] = {'\t', 'a', 'b', 'c', '\t'};
+        String str3_1 = new String(data3_1);
+        test(str3_1);
+        char data3_2[] = {'\n', 'A', 'B', 'C', '\n'};
+        String str3_2 = new String(data3_2);
+        test(str3_2);
+        char data3_3[] = {'\f', 'a', 'b', 'c', '\f'};
+        String str3_3 = new String(data3_3);
+        test(str3_3);
+        char data3_4[] = {'\b', 'A', 'B', 'C', '\b'};
+        String str3_4 = new String(data3_4);
+        test(str3_4);
+        char data3_5[] = {'\r', 'a', 'b', 'c', '\r'};
+        String str3_5 = new String(data3_5);
+        test(str3_5);
+        char data3_6[] = {'\'', 'A', 'B', 'C', '\''};
+        String str3_6 = new String(data3_6);
+        test(str3_6);
+        char data3_7[] = {'\\', 'a', 'b', 'c', '\\'};
+        String str3_7 = new String(data3_7);
+        test(str3_7);
+        char data3_8[] = {'\"', 'A', 'B', 'C', '\"'};
+        String str3_8 = new String(data3_8);
+        test(str3_8);
+    }
+    private static void test(String str) {
+        System.out.println(str);
+        System.out.println(str.trim());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0104-rt-String-TrimTest/expected.txt b/testsuite/java_test/string_test/RT0104-rt-String-TrimTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..56217b6f3ea24a8b95dec4a7953c6a8317bcb41a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0104-rt-String-TrimTest/expected.txt
@@ -0,0 +1,37 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+@!.&%
+ abc.123.abc 
+abc.123.abc
+
+
+
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+@!.&%
+ abc.123.ABC 
+abc.123.ABC
+
+
+	abc	
+abc
+
+ABC
+
+ABC
+abc
+abc
+ABC
+ABC
+
abc
+abc
+'ABC'
+'ABC'
+\abc\
+\abc\
+"ABC"
+"ABC"
+0
diff --git a/testsuite/java_test/string_test/RT0104-rt-String-TrimTest/test.cfg b/testsuite/java_test/string_test/RT0104-rt-String-TrimTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..b7accfa083ca90a9033263bdab21d2e8d17266fe
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0104-rt-String-TrimTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringTrimTest)
+run(StringTrimTest)
diff --git a/testsuite/java_test/string_test/RT0105-rt-String-ToStringTest/StringToStringTest.java b/testsuite/java_test/string_test/RT0105-rt-String-ToStringTest/StringToStringTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..0a08c4fda1bea05c721630ceeacfc9f3a12ebdb2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0105-rt-String-ToStringTest/StringToStringTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringToStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringToStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringToStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        //new String() input : byte[], char[], StringBuffer, StringBuilder, String, int[](ASCII)
+        //byte[] char[] must USE new String
+        char data3_1[] = {0x61, 0x62, 0x63};
+        String str3_1 = new String(data3_1);
+        System.out.println(str3_1);
+        System.out.println(str3_1.toString());
+    }
+    private static void test(String str) {
+        System.out.println(str.toString());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0105-rt-String-ToStringTest/expected.txt b/testsuite/java_test/string_test/RT0105-rt-String-ToStringTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..68ff8cbcafc310af899f01ea4b38f710fd35a73e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0105-rt-String-ToStringTest/expected.txt
@@ -0,0 +1,12 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+abc123abc
+
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+abc123ABC
+
+abc
+abc
+0
diff --git a/testsuite/java_test/string_test/RT0105-rt-String-ToStringTest/test.cfg b/testsuite/java_test/string_test/RT0105-rt-String-ToStringTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..95a738cfc6c7d5973e5f027bb9ab353e7ed69be7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0105-rt-String-ToStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringToStringTest)
+run(StringToStringTest)
diff --git a/testsuite/java_test/string_test/RT0106-rt-String-ToCharArrayTest/StringToCharArrayTest.java b/testsuite/java_test/string_test/RT0106-rt-String-ToCharArrayTest/StringToCharArrayTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6c33534c8222f00c6677f0ee61435f5930a06ec5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0106-rt-String-ToCharArrayTest/StringToCharArrayTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringToCharArrayTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringToCharArrayTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringToCharArrayTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc\n123\nabc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        System.out.println(str);
+        char[] ch1 = str.toCharArray();
+        System.out.println("ch1 length: " + ch1.length);
+        System.out.println(ch1);
+        System.out.println(new String(ch1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0106-rt-String-ToCharArrayTest/expected.txt b/testsuite/java_test/string_test/RT0106-rt-String-ToCharArrayTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..a8548984cad0d27f8c32d20a6f77d4ee1dcf4be8
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0106-rt-String-ToCharArrayTest/expected.txt
@@ -0,0 +1,43 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ch1 length: 99
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ch1 length: 6
+ @!.&%
+ @!.&%
+abc
+123
+abc
+ch1 length: 11
+abc
+123
+abc
+abc
+123
+abc
+
+ch1 length: 0
+
+
+
+ch1 length: 0
+
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ch1 length: 99
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ch1 length: 6
+ @!.&%
+ @!.&%
+abc123ABC
+ch1 length: 9
+abc123ABC
+abc123ABC
+
+ch1 length: 0
+
+
+0
diff --git a/testsuite/java_test/string_test/RT0106-rt-String-ToCharArrayTest/test.cfg b/testsuite/java_test/string_test/RT0106-rt-String-ToCharArrayTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..64f0fcac0d6e5b7a5364033ed64ed8ee2e992bc1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0106-rt-String-ToCharArrayTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringToCharArrayTest)
+run(StringToCharArrayTest)
diff --git a/testsuite/java_test/string_test/RT0107-rt-String-FormatStringObjectTest/StringFormatStringObjectTest.java b/testsuite/java_test/string_test/RT0107-rt-String-FormatStringObjectTest/StringFormatStringObjectTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..da1da084b032f83214ccc3a3d7f2cd13aadc2643
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0107-rt-String-FormatStringObjectTest/StringFormatStringObjectTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringFormatStringObjectTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringFormatStringObjectTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringFormatStringObjectTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        String str3_1 = null;
+        str3_1 = String.format("%c %n", 'A');
+        System.out.println(str3_1);
+        str3_1 = String.format("%b %n", 3 > 7);
+        System.out.println(str3_1);
+        str3_1 = String.format("%b %n", 3 < 7);
+        System.out.println(str3_1);
+    }
+    private static void test(String str) {
+        String test1 = null;
+        test1 = String.format("%s", str);
+        System.out.println(test1);
+        test1 = String.format("%s %s %s", str, str, str);
+        System.out.println(test1);    }
+}
diff --git a/testsuite/java_test/string_test/RT0107-rt-String-FormatStringObjectTest/expected.txt b/testsuite/java_test/string_test/RT0107-rt-String-FormatStringObjectTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..9b5e03d89b69234871bf35bc9b5af0713f0574da
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0107-rt-String-FormatStringObjectTest/expected.txt
@@ -0,0 +1,25 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96 qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96 qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ @!.&%  @!.&%  @!.&%
+abc123abc
+abc123abc abc123abc abc123abc
+
+  
+
+  
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96 qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96 qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+ @!.&%  @!.&%  @!.&%
+abc123ABC
+abc123ABC abc123ABC abc123ABC
+
+  
+A 
+
+false 
+
+true 
+
+0
diff --git a/testsuite/java_test/string_test/RT0107-rt-String-FormatStringObjectTest/test.cfg b/testsuite/java_test/string_test/RT0107-rt-String-FormatStringObjectTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..fd3f99144cb0abe263f3a4d6f53e6ae4b8be34c3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0107-rt-String-FormatStringObjectTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringFormatStringObjectTest)
+run(StringFormatStringObjectTest)
diff --git a/testsuite/java_test/string_test/RT0108-rt-String-ValueOfObjectTest/StringValueOfObjectTest.java b/testsuite/java_test/string_test/RT0108-rt-String-ValueOfObjectTest/StringValueOfObjectTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..feacda7ff1ec915af8e530588233e69731c1acae
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0108-rt-String-ValueOfObjectTest/StringValueOfObjectTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfObjectTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringValueOfObjectTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringValueOfObjectTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        String str2_5 = null;
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        test(str2_5);
+    }
+    private static void test(Object obj) {
+        System.out.println(String.valueOf(obj));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0108-rt-String-ValueOfObjectTest/expected.txt b/testsuite/java_test/string_test/RT0108-rt-String-ValueOfObjectTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..cbea9374e93f9c9421df5de7bd08fc1db0f1d77d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0108-rt-String-ValueOfObjectTest/expected.txt
@@ -0,0 +1,11 @@
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+abc123abc
+
+
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+ @!.&%
+abc123ABC
+
+null
+0
diff --git a/testsuite/java_test/string_test/RT0108-rt-String-ValueOfObjectTest/test.cfg b/testsuite/java_test/string_test/RT0108-rt-String-ValueOfObjectTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6845e3b06f1ae5ce9f11b0f727d42c04fdf2db38
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0108-rt-String-ValueOfObjectTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfObjectTest)
+run(StringValueOfObjectTest)
diff --git a/testsuite/java_test/string_test/RT0109-rt-String-ValueOfCharsTest/StringValueOfCharsTest.java b/testsuite/java_test/string_test/RT0109-rt-String-ValueOfCharsTest/StringValueOfCharsTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e7ef966fe142219d9006cabe0df2de1cc3a11c2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0109-rt-String-ValueOfCharsTest/StringValueOfCharsTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfCharsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringValueOfCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringValueOfCharsTest_1() {
+        char[] ch1_1 = {'a', 'b', 'c', '1', '2', '3'};
+        char[] ch1_2 = {0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        char[] ch1_3 = {'\u0061', '\u0062', '\u0063', '\u0031', '\u0032', '\u0033'};
+        char[] ch1_4 = {0x0061, 0x0062, 0x0063, 0x0031, 0x0032, 0x0033};
+        char[] ch1_5 = {};
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+        test(ch1_5);
+    }
+    private static void test(char[] ch1_1) {
+        System.out.println(String.valueOf(ch1_1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0109-rt-String-ValueOfCharsTest/expected.txt b/testsuite/java_test/string_test/RT0109-rt-String-ValueOfCharsTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..10ea6c18025feffd435b8df28e753a49a4146060
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0109-rt-String-ValueOfCharsTest/expected.txt
@@ -0,0 +1,6 @@
+abc123
+abc123
+abc123
+abc123
+
+0
diff --git a/testsuite/java_test/string_test/RT0109-rt-String-ValueOfCharsTest/test.cfg b/testsuite/java_test/string_test/RT0109-rt-String-ValueOfCharsTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f26b1a0528903384fac8ca652a5c12d4275c0e09
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0109-rt-String-ValueOfCharsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfCharsTest)
+run(StringValueOfCharsTest)
diff --git a/testsuite/java_test/string_test/RT0110-rt-String-ValueOfCharIntIntTest/StringValueOfCharIntIntTest.java b/testsuite/java_test/string_test/RT0110-rt-String-ValueOfCharIntIntTest/StringValueOfCharIntIntTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..414defb8192516ca6883a5c2e1118e5a058114bb
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0110-rt-String-ValueOfCharIntIntTest/StringValueOfCharIntIntTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfCharIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringValueOfCharIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringValueOfCharIntIntTest_1() {
+        char ch1_1[] = {'a', 'b', 'c', '1', '2', '3'};
+        char ch1_2[] = {0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        char ch1_3[] = {'\u0061', '\u0062', '\u0063', '\u0031', '\u0032', '\u0033'};
+        char ch1_4[] = {0x0061, 0x0062, 0x0063, 0x0031, 0x0032, 0x0033};
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+    }
+    private static void test(char[] ch1_1) {
+        System.out.println(String.valueOf(ch1_1, 1, 3));
+        // Test offset = 0.
+        System.out.println(String.valueOf(ch1_1, 0, 3));
+        // Test count = 0.
+        System.out.println(String.valueOf(ch1_1, 1, 0));
+        // Test count = ch1_1.length.
+        System.out.println(String.valueOf(ch1_1, 0, ch1_1.length));
+        // Test offset = ch1_1.length - 1.
+        System.out.println(String.valueOf(ch1_1, ch1_1.length - 1, 1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0110-rt-String-ValueOfCharIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0110-rt-String-ValueOfCharIntIntTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3a9ab8df3d0ec0ea65ff87319a0b96415262a696
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0110-rt-String-ValueOfCharIntIntTest/expected.txt
@@ -0,0 +1,21 @@
+bc1
+abc
+
+abc123
+3
+bc1
+abc
+
+abc123
+3
+bc1
+abc
+
+abc123
+3
+bc1
+abc
+
+abc123
+3
+0
diff --git a/testsuite/java_test/string_test/RT0110-rt-String-ValueOfCharIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0110-rt-String-ValueOfCharIntIntTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..472584df5b05391660756f9d3cde7838aad7d349
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0110-rt-String-ValueOfCharIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfCharIntIntTest)
+run(StringValueOfCharIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/StringCopyValueOfCharIntIntTest.java b/testsuite/java_test/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/StringCopyValueOfCharIntIntTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..dad07668591a0228ced28a20253f4def3090fd0b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/StringCopyValueOfCharIntIntTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCopyValueOfCharIntIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCopyValueOfCharIntIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCopyValueOfCharIntIntTest_1() {
+        char ch1_1[] = {'a', 'b', 'c', '1', '2', '3'};
+        char ch1_2[] = {0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        char ch1_3[] = {'\u0061', '\u0062', '\u0063', '\u0031', '\u0032', '\u0033'};
+        char ch1_4[] = {0x0061, 0x0062, 0x0063, 0x0031, 0x0032, 0x0033};
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+    }
+    private static void test(char[] ch1_1) {
+        System.out.println(String.copyValueOf(ch1_1, 1, 3));
+        // Test offset = 0.
+        System.out.println(String.copyValueOf(ch1_1, 0, 3));
+        // Test count = 0.
+        System.out.println(String.copyValueOf(ch1_1, 1, 0));
+        // Test count = ch1_1.length.
+        System.out.println(String.copyValueOf(ch1_1, 0, ch1_1.length));
+        // Test offset = ch1_1.length - 1.
+        System.out.println(String.copyValueOf(ch1_1, ch1_1.length - 1, 1));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/expected.txt b/testsuite/java_test/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3a9ab8df3d0ec0ea65ff87319a0b96415262a696
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/expected.txt
@@ -0,0 +1,21 @@
+bc1
+abc
+
+abc123
+3
+bc1
+abc
+
+abc123
+3
+bc1
+abc
+
+abc123
+3
+bc1
+abc
+
+abc123
+3
+0
diff --git a/testsuite/java_test/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/test.cfg b/testsuite/java_test/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..240c69b33053bdbcec9724267e747b16dcc46000
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0111-rt-String-CopyValueOfCharIntIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCopyValueOfCharIntIntTest)
+run(StringCopyValueOfCharIntIntTest)
diff --git a/testsuite/java_test/string_test/RT0112-rt-String-CopyValueOfCharTest/StringCopyValueOfCharTest.java b/testsuite/java_test/string_test/RT0112-rt-String-CopyValueOfCharTest/StringCopyValueOfCharTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..69851cfec21a7f93c904f39770434f5ee1e4b560
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0112-rt-String-CopyValueOfCharTest/StringCopyValueOfCharTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCopyValueOfCharTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCopyValueOfCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCopyValueOfCharTest_1() {
+        char ch1_1[] = {'a', 'b', 'c', '1', '2', '3'};
+        char ch1_2[] = {0x61, 0x62, 0x63, 0x31, 0x32, 0x33};
+        char ch1_3[] = {'\u0061', '\u0062', '\u0063', '\u0031', '\u0032', '\u0033'};
+        char ch1_4[] = {0x0061, 0x0062, 0x0063, 0x0031, 0x0032, 0x0033};
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+    }
+    private static void test(char[] ch) {
+        System.out.println(String.copyValueOf(ch));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0112-rt-String-CopyValueOfCharTest/expected.txt b/testsuite/java_test/string_test/RT0112-rt-String-CopyValueOfCharTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..4a6d8198002498c8797d1002d7d673f77e65887e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0112-rt-String-CopyValueOfCharTest/expected.txt
@@ -0,0 +1,5 @@
+abc123
+abc123
+abc123
+abc123
+0
diff --git a/testsuite/java_test/string_test/RT0112-rt-String-CopyValueOfCharTest/test.cfg b/testsuite/java_test/string_test/RT0112-rt-String-CopyValueOfCharTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2edbbecd1d9f509c4e3791adbdf25d6a501d43aa
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0112-rt-String-CopyValueOfCharTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCopyValueOfCharTest)
+run(StringCopyValueOfCharTest)
diff --git a/testsuite/java_test/string_test/RT0113-rt-String-ValueOfBooleanTest/StringValueOfBooleanTest.java b/testsuite/java_test/string_test/RT0113-rt-String-ValueOfBooleanTest/StringValueOfBooleanTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..03b551eb2b27e6182ebfea6ad413e29a0542b0ca
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0113-rt-String-ValueOfBooleanTest/StringValueOfBooleanTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfBooleanTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringValueOfBooleanTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringValueOfBooleanTest_1() {
+        boolean bo1_1 = 3 > 7;
+        boolean bo1_2 = 9 > 7;
+        test(bo1_1);
+        test(bo1_2);
+    }
+    private static void test(boolean bo) {
+        System.out.println(String.valueOf(bo));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0113-rt-String-ValueOfBooleanTest/expected.txt b/testsuite/java_test/string_test/RT0113-rt-String-ValueOfBooleanTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c6f88a0905960e4938a3e6cc2213b532d30f66fb
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0113-rt-String-ValueOfBooleanTest/expected.txt
@@ -0,0 +1,3 @@
+false
+true
+0
diff --git a/testsuite/java_test/string_test/RT0113-rt-String-ValueOfBooleanTest/test.cfg b/testsuite/java_test/string_test/RT0113-rt-String-ValueOfBooleanTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..72fc8862d064410672edf2532275969853fc3e1e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0113-rt-String-ValueOfBooleanTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfBooleanTest)
+run(StringValueOfBooleanTest)
diff --git a/testsuite/java_test/string_test/RT0114-rt-String-ValueOfCharTest/StringValueOfCharTest.java b/testsuite/java_test/string_test/RT0114-rt-String-ValueOfCharTest/StringValueOfCharTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..2a3988a5f442dbe0d4b311391746e3d78d8a6f0f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0114-rt-String-ValueOfCharTest/StringValueOfCharTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfCharTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringValueOfCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringValueOfCharTest_1() {
+        char ch1_1 = 'a';
+        char ch1_2 = 0x61;
+        char ch1_3 = '\u0061';
+        char ch1_4 = 0x0061;
+        test(ch1_1);
+        test(ch1_2);
+        test(ch1_3);
+        test(ch1_4);
+    }
+    private static void test(char ch) {
+        System.out.println(String.valueOf(ch));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0114-rt-String-ValueOfCharTest/expected.txt b/testsuite/java_test/string_test/RT0114-rt-String-ValueOfCharTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..7ad67732e31836bfa31a4361afe57d9b17824e36
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0114-rt-String-ValueOfCharTest/expected.txt
@@ -0,0 +1,5 @@
+a
+a
+a
+a
+0
diff --git a/testsuite/java_test/string_test/RT0114-rt-String-ValueOfCharTest/test.cfg b/testsuite/java_test/string_test/RT0114-rt-String-ValueOfCharTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e0b1343ab7c7419790e714085a0236356296bc7c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0114-rt-String-ValueOfCharTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfCharTest)
+run(StringValueOfCharTest)
diff --git a/testsuite/java_test/string_test/RT0115-rt-String-ValueOfIntTest/StringValueOfIntTest.java b/testsuite/java_test/string_test/RT0115-rt-String-ValueOfIntTest/StringValueOfIntTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..e28dfd79ecaf1532fd620c5cf59adccfb968781f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0115-rt-String-ValueOfIntTest/StringValueOfIntTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringValueOfIntTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringValueOfIntTest_1() {
+        int in1_1 = 0;
+        int in1_2 = 12;
+        test(in1_1);
+        test(in1_2);
+    }
+    private static void test(int in) {
+        String test = String.valueOf(in);
+        System.out.println(test);
+        System.out.println(test + 13);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0115-rt-String-ValueOfIntTest/expected.txt b/testsuite/java_test/string_test/RT0115-rt-String-ValueOfIntTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..0ff90c0699f35506001b4d048175f326e59be192
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0115-rt-String-ValueOfIntTest/expected.txt
@@ -0,0 +1,5 @@
+0
+013
+12
+1213
+0
diff --git a/testsuite/java_test/string_test/RT0115-rt-String-ValueOfIntTest/test.cfg b/testsuite/java_test/string_test/RT0115-rt-String-ValueOfIntTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..46b560e16c50c8a00fe4dd8c8447a1561fd5effc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0115-rt-String-ValueOfIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfIntTest)
+run(StringValueOfIntTest)
diff --git a/testsuite/java_test/string_test/RT0116-rt-String-ValueOfLongTest/StringValueOfLongTest.java b/testsuite/java_test/string_test/RT0116-rt-String-ValueOfLongTest/StringValueOfLongTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..a6348a062d7527adbba3faccc26d80617d0364f1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0116-rt-String-ValueOfLongTest/StringValueOfLongTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfLongTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringValueOfLongTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringValueOfLongTest_1() {
+        long long1_1 = 0;
+        long long1_2 = 1234567890;
+        test(long1_1);
+        test(long1_2);
+    }
+    private static void test(long lo) {
+        String test = String.valueOf(lo);
+        System.out.println(test);
+        System.out.println(test + 13);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0116-rt-String-ValueOfLongTest/expected.txt b/testsuite/java_test/string_test/RT0116-rt-String-ValueOfLongTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..58be843f411c3f47ccb2bb9d1f413149835eb68d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0116-rt-String-ValueOfLongTest/expected.txt
@@ -0,0 +1,5 @@
+0
+013
+1234567890
+123456789013
+0
diff --git a/testsuite/java_test/string_test/RT0116-rt-String-ValueOfLongTest/test.cfg b/testsuite/java_test/string_test/RT0116-rt-String-ValueOfLongTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..039b1d9487ec0f2dd278e3392d9e9b9b37e64b0d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0116-rt-String-ValueOfLongTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfLongTest)
+run(StringValueOfLongTest)
diff --git a/testsuite/java_test/string_test/RT0117-rt-String-ValueOfFloatTest/StringValueOfFloatTest.java b/testsuite/java_test/string_test/RT0117-rt-String-ValueOfFloatTest/StringValueOfFloatTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..3d487022c831a91bb9bc061355165d481a53c8b2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0117-rt-String-ValueOfFloatTest/StringValueOfFloatTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfFloatTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringValueOfFloatTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringValueOfFloatTest_1() {
+        float fl1_1 = 0;
+        float fl1_2 = (float) 13.0;
+        test(fl1_1);
+        test(fl1_2);
+    }
+    private static void test(float fl) {
+        String test = String.valueOf(fl);
+        System.out.println(test);
+        System.out.println(test + 13);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0117-rt-String-ValueOfFloatTest/expected.txt b/testsuite/java_test/string_test/RT0117-rt-String-ValueOfFloatTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3a7204cc9dfc92d4a7751fd56913325c4c8ad464
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0117-rt-String-ValueOfFloatTest/expected.txt
@@ -0,0 +1,5 @@
+0.0
+0.013
+13.0
+13.013
+0
diff --git a/testsuite/java_test/string_test/RT0117-rt-String-ValueOfFloatTest/test.cfg b/testsuite/java_test/string_test/RT0117-rt-String-ValueOfFloatTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..69e84ecf91a4b3dcdf662a3fae72d2b9786491ef
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0117-rt-String-ValueOfFloatTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfFloatTest)
+run(StringValueOfFloatTest)
diff --git a/testsuite/java_test/string_test/RT0118-rt-String-ValueOfDoubleTest/StringValueOfDoubleTest.java b/testsuite/java_test/string_test/RT0118-rt-String-ValueOfDoubleTest/StringValueOfDoubleTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..082072b45200d7ad3857216700a5a5555e0bf4c3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0118-rt-String-ValueOfDoubleTest/StringValueOfDoubleTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringValueOfDoubleTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringValueOfDoubleTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringValueOfDoubleTest_1() {
+        double d1_1 = 0;
+        double d1_2 = 1.23;
+        test(d1_1);
+        test(d1_2);
+    }
+    private static void test(double d) {
+        String test = String.valueOf(d);
+        System.out.println(test);
+        System.out.println(test + 13);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0118-rt-String-ValueOfDoubleTest/expected.txt b/testsuite/java_test/string_test/RT0118-rt-String-ValueOfDoubleTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..08add1eee7829b24a9e89be6d98bc2bc4a03cb2f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0118-rt-String-ValueOfDoubleTest/expected.txt
@@ -0,0 +1,5 @@
+0.0
+0.013
+1.23
+1.2313
+0
diff --git a/testsuite/java_test/string_test/RT0118-rt-String-ValueOfDoubleTest/test.cfg b/testsuite/java_test/string_test/RT0118-rt-String-ValueOfDoubleTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..69d720fc9b695c59efe98dad67b4d07b8561737b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0118-rt-String-ValueOfDoubleTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringValueOfDoubleTest)
+run(StringValueOfDoubleTest)
diff --git a/testsuite/java_test/string_test/RT0119-rt-String-InternTest/StringInternTest.java b/testsuite/java_test/string_test/RT0119-rt-String-InternTest/StringInternTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..7a53e9109396a07d13fb65071f46a866cc5580dc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0119-rt-String-InternTest/StringInternTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringInternTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out){
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            result = result-StringInternTest_1(); // 2-1=1
+        } catch(Exception e){
+            System.out.println(e);
+            StringInternTest.processResult = StringInternTest.processResult - 10;
+        }
+        if (result == 1 && StringInternTest.processResult == 98){
+            result = 0;
+        }
+        return result;
+    }
+    public static  int StringInternTest_1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        String str1 = "a";
+        String str2 = "b";
+        String str3 = "ab";
+        String str4 = str1 + str2;
+        String str5 = new String("ab");
+        String str6 = "a" + "b";
+        String str7 = "a" + str2;
+        String str8 = new String("ab");
+        if(str5.intern() == str3 && str5.intern() != str4 && str5.intern() == str6 && str5.intern() != str7
+                && str5.intern() == str8.intern()) {
+            StringInternTest.processResult = StringInternTest.processResult - 1;
+            return 1;
+        }
+        StringInternTest.processResult = StringInternTest.processResult - 10;
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0119-rt-String-InternTest/expected.txt b/testsuite/java_test/string_test/RT0119-rt-String-InternTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0119-rt-String-InternTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0119-rt-String-InternTest/test.cfg b/testsuite/java_test/string_test/RT0119-rt-String-InternTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..3567d6dd0510e6aaaf896b0551da983ad27960e3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0119-rt-String-InternTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringInternTest)
+run(StringInternTest)
diff --git a/testsuite/java_test/string_test/RT0120-rt-String-VoluationTest/StringVoluationTest.java b/testsuite/java_test/string_test/RT0120-rt-String-VoluationTest/StringVoluationTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ef763824fa152fe9cdbeb6d830b54337e8efc799
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0120-rt-String-VoluationTest/StringVoluationTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringVoluationTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringVoluationTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringVoluationTest_1() {
+        String str1 = "abc";
+        System.out.println(str1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0120-rt-String-VoluationTest/expected.txt b/testsuite/java_test/string_test/RT0120-rt-String-VoluationTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..645b0fa42721151efe255bdd64409979a8b76835
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0120-rt-String-VoluationTest/expected.txt
@@ -0,0 +1,2 @@
+abc
+0
diff --git a/testsuite/java_test/string_test/RT0120-rt-String-VoluationTest/test.cfg b/testsuite/java_test/string_test/RT0120-rt-String-VoluationTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..4a578506e0015856ac75c187faabdfdcc1cefdc7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0120-rt-String-VoluationTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringVoluationTest)
+run(StringVoluationTest)
diff --git a/testsuite/java_test/string_test/RT0121-rt-String-VoluationCharsTest/StringVoluationCharsTest.java b/testsuite/java_test/string_test/RT0121-rt-String-VoluationCharsTest/StringVoluationCharsTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..716fb8c668f2e4124432f2df0b1bd6bace74aa8b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0121-rt-String-VoluationCharsTest/StringVoluationCharsTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringVoluationCharsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringVoluationCharsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringVoluationCharsTest_1() {
+        char[] data2 = {'a', 'b', 'c'};
+        String str2 = new String(data2);
+        char[] data3 = {0x61, 0x62, 0x63};
+        String str3 = new String(data3);
+        String str4 = new String("abc");
+        System.out.println(str2);
+        System.out.println(str3);
+        System.out.println(str4);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0121-rt-String-VoluationCharsTest/expected.txt b/testsuite/java_test/string_test/RT0121-rt-String-VoluationCharsTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..62997c8d60f117b2a38c1b94a4294def91665efc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0121-rt-String-VoluationCharsTest/expected.txt
@@ -0,0 +1,4 @@
+abc
+abc
+abc
+0
diff --git a/testsuite/java_test/string_test/RT0121-rt-String-VoluationCharsTest/test.cfg b/testsuite/java_test/string_test/RT0121-rt-String-VoluationCharsTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1e9ce92d79e542533c0efef0ff638f94eccf25d2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0121-rt-String-VoluationCharsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringVoluationCharsTest)
+run(StringVoluationCharsTest)
diff --git a/testsuite/java_test/string_test/RT0122-rt-String-SpliceStringTest/StringSpliceStringTest.java b/testsuite/java_test/string_test/RT0122-rt-String-SpliceStringTest/StringSpliceStringTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..1a865da27267664ccabb2e5b185f8f6c8195d387
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0122-rt-String-SpliceStringTest/StringSpliceStringTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringSpliceStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringSpliceStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringSpliceStringTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        String str2_5 = null;
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        test(str2_5);
+    }
+    private static void test(String str) {
+        String test1_1 = "test" + str;
+        String test1_2 = str + str;
+        System.out.println(test1_1);
+        System.out.println(test1_2);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0122-rt-String-SpliceStringTest/expected.txt b/testsuite/java_test/string_test/RT0122-rt-String-SpliceStringTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..bf1c730d2b6a39571ed9d937713aa07eb527054e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0122-rt-String-SpliceStringTest/expected.txt
@@ -0,0 +1,21 @@
+testqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+test @!.&%
+ @!.&% @!.&%
+testabc123
+abc123abc123
+test
+
+test
+
+testqwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96qwertyuiop{}[]\|asdfghjkl;:'"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIOPZXCVBNM0x96
+test @!.&%
+ @!.&% @!.&%
+testabc123
+abc123abc123
+test
+
+testnull
+nullnull
+0
diff --git a/testsuite/java_test/string_test/RT0122-rt-String-SpliceStringTest/test.cfg b/testsuite/java_test/string_test/RT0122-rt-String-SpliceStringTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..0214bed4d9362681233d87a3953e9321ae733c78
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0122-rt-String-SpliceStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSpliceStringTest)
+run(StringSpliceStringTest)
diff --git a/testsuite/java_test/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/StringCompareByDoubleEqualSignTest.java b/testsuite/java_test/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/StringCompareByDoubleEqualSignTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..53ca4a5c9ec45caa2a8fe1a3445a2a36346981be
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/StringCompareByDoubleEqualSignTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCompareByDoubleEqualSignTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCompareByDoubleEqualSignTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCompareByDoubleEqualSignTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        String str2_5 = null;
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+        test(str2_5);
+    }
+    private static void test(String str) {
+        String test1_1 = "abc123ABC";
+        if (test1_1 == str) {
+            System.out.println("str == abc123abc");
+        } else {
+            System.out.println("str1 !");
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/expected.txt b/testsuite/java_test/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..689a4f5de059d4911c21df414be2b3c80f9eb3cb
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/expected.txt
@@ -0,0 +1,11 @@
+str1 !
+str1 !
+str1 !
+str1 !
+str1 !
+str1 !
+str1 !
+str == abc123abc
+str1 !
+str1 !
+0
diff --git a/testsuite/java_test/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/test.cfg b/testsuite/java_test/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..53364a58fdbf55fb967fcbc9d197ab3a7d5982bb
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0123-rt-String-CompareByDoubleEqualSignTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCompareByDoubleEqualSignTest)
+run(StringCompareByDoubleEqualSignTest)
diff --git a/testsuite/java_test/string_test/RT0124-rt-String-CompareByEqualsTest/StringCompareByEqualsTest.java b/testsuite/java_test/string_test/RT0124-rt-String-CompareByEqualsTest/StringCompareByEqualsTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..d805d95d505aabbc3bf0474258112990e81ee2ae
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0124-rt-String-CompareByEqualsTest/StringCompareByEqualsTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCompareByEqualsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCompareByEqualsTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCompareByEqualsTest_1() {
+        String str1_1 = new String("qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ AS" +
+                "DFGHJKLQWERTYUIOPZXCVBNM0x96");
+        String str1_2 = new String(" @!.&%");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "qwertyuiop{}[]\\|asdfghjkl;:'\"zxcvbnm,.<>/?~`1234567890-=!@#$%^&*()_+ ASDFGHJKLQWERTYUIO" +
+                "PZXCVBNM0x96";
+        String str2_2 = " @!.&%";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+    }
+    private static void test(String str) {
+        String test1_1 = "abc123abc";
+        if (str.equals(test1_1)) {
+            System.out.println("str == abc123abc");
+        } else {
+            System.out.println("str1 !");
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0124-rt-String-CompareByEqualsTest/expected.txt b/testsuite/java_test/string_test/RT0124-rt-String-CompareByEqualsTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..3ae6ee349a0ffec66f925efee43d4b6b97a9728c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0124-rt-String-CompareByEqualsTest/expected.txt
@@ -0,0 +1,10 @@
+str1 !
+str1 !
+str == abc123abc
+str1 !
+str1 !
+str1 !
+str1 !
+str1 !
+str1 !
+0
diff --git a/testsuite/java_test/string_test/RT0124-rt-String-CompareByEqualsTest/test.cfg b/testsuite/java_test/string_test/RT0124-rt-String-CompareByEqualsTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8bcdb590491b8db05960c810ba3f41f0ed8795ae
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0124-rt-String-CompareByEqualsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCompareByEqualsTest)
+run(StringCompareByEqualsTest)
diff --git a/testsuite/java_test/string_test/RT0125-rt-String-ConvertToByteTest/StringConvertToByteTest.java b/testsuite/java_test/string_test/RT0125-rt-String-ConvertToByteTest/StringConvertToByteTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..1726d6cbce5bb79c6a21f32077eb12d6eab21a00
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0125-rt-String-ConvertToByteTest/StringConvertToByteTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConvertToByteTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConvertToByteTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Test public static byte parseByte(String s).
+    public static void StringConvertToByteTest_1() {
+        // Create 2 byte primitives bt1, bt2.
+        byte b_1, b_2;
+        // Create and assign values to String's s1, s2.
+        String s1 = "123";
+        String s2 = "-1a";
+        // Create and assign values to int r1, r2.
+        int r1 = 8;  // Represents octal.
+        int r2 = 16; // Represents hexadecimal.
+        b_1 = Byte.parseByte(s1, r1);
+        b_2 = Byte.parseByte(s2, r2);
+        String str1_1 = s1 + " convert(8) to Byte:" + b_1;
+        String str1_2 = s2 + " convert(16) to Byte:" + b_2;
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0125-rt-String-ConvertToByteTest/expected.txt b/testsuite/java_test/string_test/RT0125-rt-String-ConvertToByteTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..05e2eea429faf7fbc8db6bddeffacb57037c5889
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0125-rt-String-ConvertToByteTest/expected.txt
@@ -0,0 +1,3 @@
+123 convert(8) to Byte:83
+-1a convert(16) to Byte:-26
+0
diff --git a/testsuite/java_test/string_test/RT0125-rt-String-ConvertToByteTest/test.cfg b/testsuite/java_test/string_test/RT0125-rt-String-ConvertToByteTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8839bac49f452dd99861bcc717173c170a467c76
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0125-rt-String-ConvertToByteTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConvertToByteTest)
+run(StringConvertToByteTest)
diff --git a/testsuite/java_test/string_test/RT0126-rt-String-ConvertToShortTest/StringConvertToShortTest.java b/testsuite/java_test/string_test/RT0126-rt-String-ConvertToShortTest/StringConvertToShortTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d84df016511c6432588dda4bb21b9ac8051b1cb
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0126-rt-String-ConvertToShortTest/StringConvertToShortTest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConvertToShortTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConvertToShortTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Test public static short parseShort(String s).
+    public static void StringConvertToShortTest_1() {
+        String str1 = "04320";
+        short s_1 = Short.parseShort(str1);
+        System.out.println(s_1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0126-rt-String-ConvertToShortTest/expected.txt b/testsuite/java_test/string_test/RT0126-rt-String-ConvertToShortTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..d79c07e480eb649a1cad2a78a30f7aa73ff43eac
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0126-rt-String-ConvertToShortTest/expected.txt
@@ -0,0 +1,2 @@
+4320
+0
diff --git a/testsuite/java_test/string_test/RT0126-rt-String-ConvertToShortTest/test.cfg b/testsuite/java_test/string_test/RT0126-rt-String-ConvertToShortTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..bd77f7ccbc8118ec18d09374dd654eb6c64b0215
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0126-rt-String-ConvertToShortTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConvertToShortTest)
+run(StringConvertToShortTest)
diff --git a/testsuite/java_test/string_test/RT0127-rt-String-ConvertToIntTest/StringConvertToIntTest.java b/testsuite/java_test/string_test/RT0127-rt-String-ConvertToIntTest/StringConvertToIntTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..82b91439f3f43207b3bfaf2879acc8dcd032b6e6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0127-rt-String-ConvertToIntTest/StringConvertToIntTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConvertToIntTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConvertToIntTest_1();
+            StringConvertToIntTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Test static int parseInt(String s).
+    public static void StringConvertToIntTest_1() {
+        int i_1 = Integer.parseInt("1234");
+        System.out.println("convert(10) to int: " + i_1);
+    }
+    // Test static int parseInt(String s, int radix).
+    public static void StringConvertToIntTest_2() {
+        int i_2 = Integer.parseInt("1234", 8);
+        System.out.println("convert(8) to int: " + i_2);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0127-rt-String-ConvertToIntTest/expected.txt b/testsuite/java_test/string_test/RT0127-rt-String-ConvertToIntTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c6f1150fd8cd8d145b526a4c8cbe0b3f4629b5a5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0127-rt-String-ConvertToIntTest/expected.txt
@@ -0,0 +1,3 @@
+convert(10) to int: 1234
+convert(8) to int: 668
+0
diff --git a/testsuite/java_test/string_test/RT0127-rt-String-ConvertToIntTest/test.cfg b/testsuite/java_test/string_test/RT0127-rt-String-ConvertToIntTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..217d3f2fc9fd399b9f1cc08bf8ae9654f707e4cc
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0127-rt-String-ConvertToIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConvertToIntTest)
+run(StringConvertToIntTest)
diff --git a/testsuite/java_test/string_test/RT0128-rt-String-ConvertToLongTest/StringConvertToLongTest.java b/testsuite/java_test/string_test/RT0128-rt-String-ConvertToLongTest/StringConvertToLongTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..14cd3a2ccaa3bfc36b89488c441e161e93601709
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0128-rt-String-ConvertToLongTest/StringConvertToLongTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConvertToLongTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConvertToLongTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Test public static long parseLong(String s, int radix).
+    public static void StringConvertToLongTest_1() {
+        long l_1 = Long.parseLong("1234", 10);
+        // Test parses the string with specified radix
+        System.out.println(l_1);
+        long l_a = Long.parseLong("0", 10);
+        System.out.println(l_a);
+        long l_b = Long.parseLong("111", 10);
+        System.out.println(l_b);
+        long l_c = Long.parseLong("-0", 10);
+        System.out.println(l_c);
+        long l_d = Long.parseLong("-BB", 16);
+        System.out.println(l_d);
+        long l_e = Long.parseLong("1010110", 2);
+        System.out.println(l_e);
+        long l_f = Long.parseLong("2147483647", 10);
+        System.out.println(l_f);
+        long l_g = Long.parseLong("-2147483648", 10);
+        System.out.println(l_g);
+        long l_h = Long.parseLong("ADMIN", 27);
+        System.out.println(l_h);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0128-rt-String-ConvertToLongTest/expected.txt b/testsuite/java_test/string_test/RT0128-rt-String-ConvertToLongTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..633fa4a74a9d8b643ceba7d8bcb56d8c66e1b234
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0128-rt-String-ConvertToLongTest/expected.txt
@@ -0,0 +1,10 @@
+1234
+0
+111
+0
+-187
+86
+2147483647
+-2147483648
+5586836
+0
diff --git a/testsuite/java_test/string_test/RT0128-rt-String-ConvertToLongTest/test.cfg b/testsuite/java_test/string_test/RT0128-rt-String-ConvertToLongTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..58f75b4076dbb05fa89388cde67adde7b9a15bea
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0128-rt-String-ConvertToLongTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConvertToLongTest)
+run(StringConvertToLongTest)
diff --git a/testsuite/java_test/string_test/RT0129-rt-String-ConvertToFloatTest/StringConvertToFloatTest.java b/testsuite/java_test/string_test/RT0129-rt-String-ConvertToFloatTest/StringConvertToFloatTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..5637532fd89ae555b343bb71c5ceb2d7e6294632
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0129-rt-String-ConvertToFloatTest/StringConvertToFloatTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConvertToFloatTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConvertToFloatTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Test public static float parseFloat(String s).
+    public static void StringConvertToFloatTest_1() {
+        float f_1 = Float.parseFloat("12.34");
+        System.out.println(f_1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0129-rt-String-ConvertToFloatTest/expected.txt b/testsuite/java_test/string_test/RT0129-rt-String-ConvertToFloatTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..af5f02a3a085d2943410406641ffec2e25c1ba69
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0129-rt-String-ConvertToFloatTest/expected.txt
@@ -0,0 +1,2 @@
+12.34
+0
diff --git a/testsuite/java_test/string_test/RT0129-rt-String-ConvertToFloatTest/test.cfg b/testsuite/java_test/string_test/RT0129-rt-String-ConvertToFloatTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..190f5750e1a77e0e0d869c6d0f1166756df1af84
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0129-rt-String-ConvertToFloatTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConvertToFloatTest)
+run(StringConvertToFloatTest)
diff --git a/testsuite/java_test/string_test/RT0130-rt-String-ConvertToDoubleTest/StringConvertToDoubleTest.java b/testsuite/java_test/string_test/RT0130-rt-String-ConvertToDoubleTest/StringConvertToDoubleTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..4acd8a675d8743ea9553cda44e4bd0dc9dd6d0f0
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0130-rt-String-ConvertToDoubleTest/StringConvertToDoubleTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConvertToDoubleTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConvertToDoubleTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Test public static double parseDouble(String s).
+    public static void StringConvertToDoubleTest_1() {
+        double d_1 = Double.parseDouble("1.124");
+        System.out.println(d_1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0130-rt-String-ConvertToDoubleTest/expected.txt b/testsuite/java_test/string_test/RT0130-rt-String-ConvertToDoubleTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..a5d817df2b469672f3381336cc7144e1284603b5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0130-rt-String-ConvertToDoubleTest/expected.txt
@@ -0,0 +1,2 @@
+1.124
+0
diff --git a/testsuite/java_test/string_test/RT0130-rt-String-ConvertToDoubleTest/test.cfg b/testsuite/java_test/string_test/RT0130-rt-String-ConvertToDoubleTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1563f69eb35c3f448bd17d6654b15efbf1cf9ba5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0130-rt-String-ConvertToDoubleTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConvertToDoubleTest)
+run(StringConvertToDoubleTest)
diff --git a/testsuite/java_test/string_test/RT0131-rt-String-LongToBinaryStringTest/LongToBinaryStringTest.java b/testsuite/java_test/string_test/RT0131-rt-String-LongToBinaryStringTest/LongToBinaryStringTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..cfe5b126effad285ab25beba45769e22dbc2799d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0131-rt-String-LongToBinaryStringTest/LongToBinaryStringTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class LongToBinaryStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            LongToBinaryStringTest_1();
+            LongToBinaryStringTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Long.toBinaryString(long l)
+    public static void LongToBinaryStringTest_1() {
+        long l_a = 0L;
+        long l_b = 111L;
+        long l_c = 2147483647L;
+        test(l_a);
+        test(l_b);
+        test(l_c);
+    }
+    public static void LongToBinaryStringTest_2() {
+        Integer i_a = 0;
+        Integer i_b = 111;
+        Integer i_c = 2147483647;
+        test2(i_a);
+        test2(i_b);
+        test2(i_c);
+    }
+    private static void test(Long lo) {
+        System.out.println(Long.toBinaryString(lo));
+    }
+    private static void test2(Integer i) {
+        System.out.println(Integer.toBinaryString(i));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0131-rt-String-LongToBinaryStringTest/expected.txt b/testsuite/java_test/string_test/RT0131-rt-String-LongToBinaryStringTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c72c64026081633301041dbe124bf51bc2822be3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0131-rt-String-LongToBinaryStringTest/expected.txt
@@ -0,0 +1,7 @@
+0
+1101111
+1111111111111111111111111111111
+0
+1101111
+1111111111111111111111111111111
+0
diff --git a/testsuite/java_test/string_test/RT0131-rt-String-LongToBinaryStringTest/test.cfg b/testsuite/java_test/string_test/RT0131-rt-String-LongToBinaryStringTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..308242eab747a2a0d69f8d0947b100985fbe28e0
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0131-rt-String-LongToBinaryStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(LongToBinaryStringTest)
+run(LongToBinaryStringTest)
diff --git a/testsuite/java_test/string_test/RT0132-rt-String-LongToOctalStringTest/LongToOctalStringTest.java b/testsuite/java_test/string_test/RT0132-rt-String-LongToOctalStringTest/LongToOctalStringTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..411ab642b9d90ee1b9e1cb5b6237c9537395463e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0132-rt-String-LongToOctalStringTest/LongToOctalStringTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class LongToOctalStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            LongToOctalStringTest_1();
+            LongToOctalStringTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Long.toOctalString(long l)
+    public static void LongToOctalStringTest_1() {
+        long l_a = 0L;
+        long l_b = 111L;
+        long l_c = 2147483647L;
+        test(l_a);
+        test(l_b);
+        test(l_c);
+    }
+    public static void LongToOctalStringTest_2() {
+        Integer i_a = 0;
+        Integer i_b = 111;
+        Integer i_c = 2147483647;
+        test2(i_a);
+        test2(i_b);
+        test2(i_c);
+    }
+    private static void test(Long lo) {
+        System.out.println(Long.toOctalString(lo));
+    }
+    private static void test2(Integer i) {
+        System.out.println(Integer.toOctalString(i));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0132-rt-String-LongToOctalStringTest/expected.txt b/testsuite/java_test/string_test/RT0132-rt-String-LongToOctalStringTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c3a23566e8f359dbbdb41ed1097536171edf879a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0132-rt-String-LongToOctalStringTest/expected.txt
@@ -0,0 +1,7 @@
+0
+157
+17777777777
+0
+157
+17777777777
+0
diff --git a/testsuite/java_test/string_test/RT0132-rt-String-LongToOctalStringTest/test.cfg b/testsuite/java_test/string_test/RT0132-rt-String-LongToOctalStringTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1d5ef7dce3d1d2b951545f52851bc6081e271175
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0132-rt-String-LongToOctalStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(LongToOctalStringTest)
+run(LongToOctalStringTest)
diff --git a/testsuite/java_test/string_test/RT0133-rt-String-BasicToStringTest/BasicToStringTest.java b/testsuite/java_test/string_test/RT0133-rt-String-BasicToStringTest/BasicToStringTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b6f4aab9dbed28bb793cc3a4af120fa4a0a7e903
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0133-rt-String-BasicToStringTest/BasicToStringTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class BasicToStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            BasicToStringTest_1();
+            BasicToStringTest_2();
+            BasicToStringTest_3();
+            BasicToStringTest_4();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Long.toString(long l, int p)
+    public static void BasicToStringTest_1() {
+        long l_a = 0;
+        long l_b = 111;
+        long l_c = 2147483647;
+        test1(l_a);
+        test1(l_b);
+        test1(l_c);
+    }
+    public static void BasicToStringTest_2() {
+        Integer i_a = 0;
+        Integer i_b = 111;
+        Integer i_c = 2147483647;
+        test2(i_a);
+        test2(i_b);
+        test2(i_c);
+    }
+    public static void BasicToStringTest_3() {
+        float f_a = 0f;
+        float f_b = 11.1f;
+        float f_c = 2147483.647f;
+        test3(f_a);
+        test3(f_b);
+        test3(f_c);
+    }
+    public static void BasicToStringTest_4() {
+        double d_a = 0;
+        double d_b = 1.11d;
+        double d_c = 21474836.47;
+        test4(d_a);
+        test4(d_b);
+        test4(d_c);
+    }
+    private static void test1(Long lo) {
+        System.out.println(Long.toString(lo));
+    }
+    private static void test2(Integer i) {
+        System.out.println(Integer.toString(i));
+    }
+    private static void test3(float f) {
+        System.out.println(Float.toString(f));
+    }
+    private static void test4(double f) {
+        System.out.println(Double.toString(f));
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0133-rt-String-BasicToStringTest/expected.txt b/testsuite/java_test/string_test/RT0133-rt-String-BasicToStringTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..fac89281853f9b9138781b5920f547f3e4f42de1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0133-rt-String-BasicToStringTest/expected.txt
@@ -0,0 +1,13 @@
+0
+111
+2147483647
+0
+111
+2147483647
+0.0
+11.1
+2147483.8
+0.0
+1.11
+2.147483647E7
+0
diff --git a/testsuite/java_test/string_test/RT0133-rt-String-BasicToStringTest/test.cfg b/testsuite/java_test/string_test/RT0133-rt-String-BasicToStringTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..003932de05a1599099dafbd30ceb70715026d9b6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0133-rt-String-BasicToStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(BasicToStringTest)
+run(BasicToStringTest)
diff --git a/testsuite/java_test/string_test/RT0134-rt-String-NullToStringTest/NullToStringTest.java b/testsuite/java_test/string_test/RT0134-rt-String-NullToStringTest/NullToStringTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..1527bc8e0d80c0bfec9e1d523ef145a6ba7525de
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0134-rt-String-NullToStringTest/NullToStringTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class NullToStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            NullToStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void NullToStringTest_1() {
+        int i1_1 = 0;
+        test1(i1_1);
+        int i1_2 = 123;
+        test1(i1_2);
+        Integer i1_3 = (Integer) null;
+        test3(i1_3);
+        String str1_1 = "";
+        test2(str1_1);
+        String str1_2 = "abc";
+        test2(str1_2);
+        String str1_3 = null;
+        test2(str1_3);
+        System.out.println((String) null);
+        System.out.println("<" + (String) null + ">");
+    }
+    private static void test1(int i) {
+        String str1 = "<" + i + ">";
+        System.out.println("str1 : " + str1);
+    }
+    private static void test2(String str) {
+        String str2 = "<" + str + ">";
+        System.out.println("str2 : " + str2);
+    }
+    private static void test3(final Integer i) {
+        String str1 = "<" + i + ">";
+        System.out.println("str1 : " + str1);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0134-rt-String-NullToStringTest/expected.txt b/testsuite/java_test/string_test/RT0134-rt-String-NullToStringTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c3b5ca95a51343b0a1e1c82baf05c3989ee284f9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0134-rt-String-NullToStringTest/expected.txt
@@ -0,0 +1,9 @@
+str1 : <0>
+str1 : <123>
+str1 : <null>
+str2 : <>
+str2 : <abc>
+str2 : <null>
+null
+<null>
+0
diff --git a/testsuite/java_test/string_test/RT0134-rt-String-NullToStringTest/test.cfg b/testsuite/java_test/string_test/RT0134-rt-String-NullToStringTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..3ea2cc2d6dd10a8f420797de9a5df16f40081800
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0134-rt-String-NullToStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(NullToStringTest)
+run(NullToStringTest)
diff --git a/testsuite/java_test/string_test/RT0135-rt-String-AsciiToStringTest/AsciiToStringTest.java b/testsuite/java_test/string_test/RT0135-rt-String-AsciiToStringTest/AsciiToStringTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..108bffba48e4d48913d8d289dcd1ccb78e7659c9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0135-rt-String-AsciiToStringTest/AsciiToStringTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class AsciiToStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            AsciiToStringTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void AsciiToStringTest_1() {
+        String str1_1 = "a b^c~AB";
+        //10
+        char[] data1_2 = {97, 32, 98, 94, 99, 126, 65, 66};
+        String str1_2 = new String(data1_2);
+        //16
+        char[] data1_3 = {0x61, 0x20, 0x62, 0x5E, 0x63, 0x7E, 0x41, 0x42};
+        String str1_3 = new String(data1_3);
+        test1(str1_1);
+        test1(str1_2);
+        test1(str1_3);
+    }
+    private static void test1(String str) {
+        System.out.println(str);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0135-rt-String-AsciiToStringTest/expected.txt b/testsuite/java_test/string_test/RT0135-rt-String-AsciiToStringTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..66ad3b8c57e340046d7808a866ca6041e6b385c6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0135-rt-String-AsciiToStringTest/expected.txt
@@ -0,0 +1,4 @@
+a b^c~AB
+a b^c~AB
+a b^c~AB
+0
diff --git a/testsuite/java_test/string_test/RT0135-rt-String-AsciiToStringTest/test.cfg b/testsuite/java_test/string_test/RT0135-rt-String-AsciiToStringTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a4bf9938b80c46ecde1fad2d10b1cbfa328fbdb6
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0135-rt-String-AsciiToStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(AsciiToStringTest)
+run(AsciiToStringTest)
diff --git a/testsuite/java_test/string_test/RT0136-rt-String-ToHexStringCharTest/StringToHexStringCharTest.java b/testsuite/java_test/string_test/RT0136-rt-String-ToHexStringCharTest/StringToHexStringCharTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..684a11e2d92389741d94cfbd3d8408e7fecb14e5
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0136-rt-String-ToHexStringCharTest/StringToHexStringCharTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringToHexStringCharTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringToHexStringCharTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringToHexStringCharTest_1() {
+        // 0x00~0x7F.
+        String str1_1 = "a b^c~AB";
+        //10
+        char data1_2[] = {97, 32, 98, 94, 99, 126, 65, 66};
+        String str1_2 = new String(data1_2);
+        //16
+        char data1_3[] = {0x61, 0x20, 0x62, 0x5E, 0x63, 0x7E, 0x41, 0x42};
+        String str1_3 = new        String(data1_3);
+        String str2_1 = "中国";
+        // Test unicode
+        char data2_2[] = {'\u4E2D', '\u56FD'};
+        String str2_2 = new String(data2_2);
+        String str3_1 = "中国abc";
+        //unicode
+        char data3_2[] = {'\u4E2D', '\u56FD', 97, 98, 99};
+        String str3_2 = new String(data3_2);
+        test1(str1_1);
+        test1(str1_2);
+        test1(str1_3);
+        test1(str2_1);
+        test1(str2_2);
+        test1(str3_1);
+        test1(str3_2);
+    }
+    private static void test1(String str) {
+        for (int i = 0; i < str.length(); i++) {
+            char ch = str.charAt(i);
+            System.out.println(Integer.toHexString(ch));
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0136-rt-String-ToHexStringCharTest/expected.txt b/testsuite/java_test/string_test/RT0136-rt-String-ToHexStringCharTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..79116ba1cde830b9881ebdf078e5df8e572b075e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0136-rt-String-ToHexStringCharTest/expected.txt
@@ -0,0 +1,39 @@
+61
+20
+62
+5e
+63
+7e
+41
+42
+61
+20
+62
+5e
+63
+7e
+41
+42
+61
+20
+62
+5e
+63
+7e
+41
+42
+4e2d
+56fd
+4e2d
+56fd
+4e2d
+56fd
+61
+62
+63
+4e2d
+56fd
+61
+62
+63
+0
diff --git a/testsuite/java_test/string_test/RT0136-rt-String-ToHexStringCharTest/test.cfg b/testsuite/java_test/string_test/RT0136-rt-String-ToHexStringCharTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..999303c2e842da9948bb9f7c431b849d4c1df90b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0136-rt-String-ToHexStringCharTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringToHexStringCharTest)
+run(StringToHexStringCharTest)
diff --git a/testsuite/java_test/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/StringAsVariableAndFieldAndParamTest.java b/testsuite/java_test/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/StringAsVariableAndFieldAndParamTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..0e86f981dfe80cac9e533a1955a001c2187b73cd
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/StringAsVariableAndFieldAndParamTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringAsVariableAndFieldAndParamTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringAsVariableAndFieldAndParamTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringAsVariableAndFieldAndParamTest_1() {
+        String str = null;
+        System.out.println(str);
+        System.out.println(StringAsVariableAndFieldAndParamTest_1.str1_1);
+        str = "abc";
+        System.out.println(StringAsVariableAndFieldAndParamTest_1.test(str));
+    }
+}
+class StringAsVariableAndFieldAndParamTest_1 {
+    static String str1_1 = "abc1_1";
+    protected static String test(String str) {
+        String result = str + str;
+        System.out.println(result);
+        return result;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/expected.txt b/testsuite/java_test/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..650f8b1218e70868ebf39b3b0628345ebccc387b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/expected.txt
@@ -0,0 +1,5 @@
+null
+abc1_1
+abcabc
+abcabc
+0
diff --git a/testsuite/java_test/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/test.cfg b/testsuite/java_test/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..5488de93f1f7b2e776f3efe5a9e94f349118bea3
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0137-rt-String-AsVariableAndFieldAndParamTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringAsVariableAndFieldAndParamTest)
+run(StringAsVariableAndFieldAndParamTest)
diff --git a/testsuite/java_test/string_test/RT0138-rt-String-VariableOfInterfaceTest/StringVariableOfInterfaceTest.java b/testsuite/java_test/string_test/RT0138-rt-String-VariableOfInterfaceTest/StringVariableOfInterfaceTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..e530ce8186ac20bace947e9e1a278e4e0b9b5534
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0138-rt-String-VariableOfInterfaceTest/StringVariableOfInterfaceTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringVariableOfInterfaceTest implements StringVariableOfInterfaceTest_1 {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringVariableOfInterfaceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    static String test(String str) {
+        String result = str + str;
+        System.out.println(result);
+        return result;
+    }
+    public static void StringVariableOfInterfaceTest_1() {
+        String str = null;
+        System.out.println(str);
+        System.out.println(StringVariableOfInterfaceTest_1.str1_1);
+        str = "abc";
+        System.out.println(StringVariableOfInterfaceTest.test(str));
+    }
+}
+interface StringVariableOfInterfaceTest_1 {
+    static String str1_1 = "abc1_1";
+    static void test(String str) {
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0138-rt-String-VariableOfInterfaceTest/expected.txt b/testsuite/java_test/string_test/RT0138-rt-String-VariableOfInterfaceTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..650f8b1218e70868ebf39b3b0628345ebccc387b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0138-rt-String-VariableOfInterfaceTest/expected.txt
@@ -0,0 +1,5 @@
+null
+abc1_1
+abcabc
+abcabc
+0
diff --git a/testsuite/java_test/string_test/RT0138-rt-String-VariableOfInterfaceTest/test.cfg b/testsuite/java_test/string_test/RT0138-rt-String-VariableOfInterfaceTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..61a3a37b95fef346299abf2e0a2bab1e0a67294e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0138-rt-String-VariableOfInterfaceTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringVariableOfInterfaceTest)
+run(StringVariableOfInterfaceTest)
diff --git a/testsuite/java_test/string_test/RT0139-rt-String-CreateStringArrayTest/StringCreateStringArrayTest.java b/testsuite/java_test/string_test/RT0139-rt-String-CreateStringArrayTest/StringCreateStringArrayTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..45a3bcdc8fb472b7507e4e5d81b94e71afcdf988
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0139-rt-String-CreateStringArrayTest/StringCreateStringArrayTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringCreateStringArrayTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringCreateStringArrayTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringCreateStringArrayTest_1() {
+        String[] strArray = {"a", "b", "c", "1", "2", "3"};
+        System.out.println(strArray[1]);
+        System.out.println(test(strArray)[1]);
+    }
+    private static String[] test(String[] str) {
+        for (int i = 0; i < str.length; i++) {
+            System.out.println(str[i]);
+        }
+        str[1] = "B";
+        return str;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0139-rt-String-CreateStringArrayTest/expected.txt b/testsuite/java_test/string_test/RT0139-rt-String-CreateStringArrayTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..69c421418533d8f101fd70491266949261469321
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0139-rt-String-CreateStringArrayTest/expected.txt
@@ -0,0 +1,9 @@
+b
+a
+b
+c
+1
+2
+3
+B
+0
diff --git a/testsuite/java_test/string_test/RT0139-rt-String-CreateStringArrayTest/test.cfg b/testsuite/java_test/string_test/RT0139-rt-String-CreateStringArrayTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..20fc9f988ed075f09bb692e1248f575cacfaac5e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0139-rt-String-CreateStringArrayTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringCreateStringArrayTest)
+run(StringCreateStringArrayTest)
diff --git a/testsuite/java_test/string_test/RT0140-rt-String-GenericTest/StringGenericTest.java b/testsuite/java_test/string_test/RT0140-rt-String-GenericTest/StringGenericTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..02408890639291c565747db0c8cf297d367adcf8
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0140-rt-String-GenericTest/StringGenericTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.io.PrintStream;
+public class StringGenericTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) throws IllegalAccessException, IllegalArgumentException,
+            InvocationTargetException, NoSuchMethodException, SecurityException {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringGenericTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringGenericTest_1() throws IllegalAccessException, IllegalArgumentException,
+            InvocationTargetException, NoSuchMethodException, SecurityException {
+        ArrayList<String> arrayList1 = new ArrayList<String>();
+        arrayList1.add("abc");
+        ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
+        arrayList2.add(123);
+        System.out.println(arrayList1.getClass() == arrayList2.getClass());
+        String str = StringGenericTest.<String>add("1", "2");
+        System.out.println(str);
+    }
+    public static <T> T add(T x, T y) {
+        return y;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0140-rt-String-GenericTest/expected.txt b/testsuite/java_test/string_test/RT0140-rt-String-GenericTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..59d9b3852101dc4f1f78b72c7d406dd697d57054
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0140-rt-String-GenericTest/expected.txt
@@ -0,0 +1,3 @@
+true
+2
+0
diff --git a/testsuite/java_test/string_test/RT0140-rt-String-GenericTest/test.cfg b/testsuite/java_test/string_test/RT0140-rt-String-GenericTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..71f491d1f43a9d9f67beb427eb3b7dce96043f78
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0140-rt-String-GenericTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGenericTest)
+run(StringGenericTest)
diff --git a/testsuite/java_test/string_test/RT0141-rt-String-MultiThreadsTest/StringMultiThreadsTest.java b/testsuite/java_test/string_test/RT0141-rt-String-MultiThreadsTest/StringMultiThreadsTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..44819d1dc3b7ca9e8526259afeea10eecb77abce
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0141-rt-String-MultiThreadsTest/StringMultiThreadsTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringMultiThreadsTest extends Thread {
+    static int retu = 1;
+    static int threadCount = 10;
+    static int stringCount = 10;
+    static int count = 0;
+    public StringMultiThreadsTest(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public void run() {
+        String[] str = new String[stringCount];
+        for (int i = 0; i < stringCount; i++) {
+            str[i] = "ABC";
+            count++;
+            if (str[i] != "ABC") {
+                retu++;
+            }
+        }
+    }
+    public static void main(String[] args) {
+        System.out.println(test(args, System.out));
+    }
+    public static int test(String[] args, PrintStream out) {
+        ThreadGroup thg = new ThreadGroup("threadg");
+        String[] th = new String[threadCount];
+        for (int i = 0; i < threadCount; i++) {
+            th[i] = "thread" + i;
+            new StringMultiThreadsTest(thg, th[i]).start();
+        }
+        try {
+            sleep(200);
+        } catch (InterruptedException e) {
+        }
+        if (retu == 1) {
+            return 0;
+        }
+        return 2;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0141-rt-String-MultiThreadsTest/expected.txt b/testsuite/java_test/string_test/RT0141-rt-String-MultiThreadsTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0141-rt-String-MultiThreadsTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0141-rt-String-MultiThreadsTest/test.cfg b/testsuite/java_test/string_test/RT0141-rt-String-MultiThreadsTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8848056d32dbb4f5674c6713c1538e8365a9ad9e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0141-rt-String-MultiThreadsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringMultiThreadsTest)
+run(StringMultiThreadsTest)
diff --git a/testsuite/java_test/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/StringJoinNullPointerExceptionTest.java b/testsuite/java_test/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/StringJoinNullPointerExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..0a6c4625888571f62fc8013714c30419b01c0354
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/StringJoinNullPointerExceptionTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringJoinNullPointerExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success*/
+
+        try {
+            StringJoinNullPointerExceptionTest_1(null);
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 97) {
+            result = 0;
+        }
+        return result;
+    }
+    private static void StringJoinNullPointerExceptionTest_1(String str) {
+        try {
+            String[] test = new String[]{str, str, str};
+            System.out.println(String.join(null, test));
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..dbea1a3976c8e3707f9f71a6b13cdb251c8c851d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0142-rt-String-JoinNullPointerExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringJoinNullPointerExceptionTest)
+run(StringJoinNullPointerExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0143-rt-String-NullPointExceptionTest/StringNullPointExceptionTest.java b/testsuite/java_test/string_test/RT0143-rt-String-NullPointExceptionTest/StringNullPointExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8c85612cb307a93900931e662998bb39340e11c7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0143-rt-String-NullPointExceptionTest/StringNullPointExceptionTest.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringNullPointExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success*/
+
+        try {
+            StringNullPointExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 83) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringNullPointExceptionTest_1() {
+        String str2_1 = "abc123";
+        String str2_5 = null;
+        test0(str2_1);
+        test1(str2_5);
+        test2(str2_5);
+        test3(str2_5);
+        test4(str2_5);
+        test5(str2_5);
+        test6(str2_5);
+        test7(str2_5);
+    }
+    private static void test0(String str) {
+        try {
+            char t0 = str.charAt(-2);
+        } catch (StringIndexOutOfBoundsException e) {
+            processResult -= 2;
+        }
+    }
+    private static void test1(String str) {
+        try {
+            char t1 = str.charAt(0);
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+    private static void test2(String str) {
+        char[] t2 = null;
+        try {
+            t2 = str.toCharArray();
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+    private static void test3(String str) {
+        String t3 = null;
+        try {
+            t3 = str.substring(1);
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+    private static void test4(String str) {
+        try {
+            int t4 = str.compareTo("aaa");
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+    private static void test5(String str) {
+        try {
+            String t5 = str.intern();
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+    private static void test6(String str) {
+        try {
+            String t6 = str.replace("a", "b");
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+    private static void test7(String str) {
+        try {
+            String t7 = str.concat("aaa");
+        } catch (NullPointerException e) {
+            processResult -= 2;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0143-rt-String-NullPointExceptionTest/expected.txt b/testsuite/java_test/string_test/RT0143-rt-String-NullPointExceptionTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0143-rt-String-NullPointExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0143-rt-String-NullPointExceptionTest/test.cfg b/testsuite/java_test/string_test/RT0143-rt-String-NullPointExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1c2cfed613b347fccffe299fd6bad11b98d05061
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0143-rt-String-NullPointExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringNullPointExceptionTest)
+run(StringNullPointExceptionTest)
diff --git a/testsuite/java_test/string_test/RT0144-rt-String-BufferExceptionsTest/StringBufferExceptionsTest.java b/testsuite/java_test/string_test/RT0144-rt-String-BufferExceptionsTest/StringBufferExceptionsTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..296759dd7e1f90b6e647f28b9e697203e312470a
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0144-rt-String-BufferExceptionsTest/StringBufferExceptionsTest.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBufferExceptionsTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success*/
+
+        try {
+            result = StringBufferGetCharsIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBufferReplaceStringIndexOutOfBoundsException_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBufferSubstringStringIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBufferSubstringStringIndexOutOfBoundsException_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 80) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringBufferGetCharsIndexOutOfBoundsException_1() {
+        int result1 = 3; /*STATUS_FAILED*/
+        // IndexOutOfBoundsException- If either off or len is negative, or if off + len is greater than b.length.
+        // Test public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin).
+        StringBuffer buff = new StringBuffer("java programming");
+        char[] chArr = new char[]{'t', 'u', 't', 'o', 'r', 'i', 'a', 'l', 's'};
+        // Test dstBegin > dst.length.
+        try {
+            buff.getChars(5, 10, chArr, 30);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test dstBegin < 0.
+        try {
+            buff.getChars(5, 10, chArr, -2);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test dst.length - dstBegin < srcEnd - srcBegin.
+        try {
+            buff.getChars(5, 10, chArr, 7);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcBegin < 0.
+        try {
+            buff.getChars(-2, 10, chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcBegin > buff.length.
+        try {
+            buff.getChars(buff.length(), 10, chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcEnd < 0.
+        try {
+            buff.getChars(5, -2, chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcEnd < srcBegin.
+        try {
+            buff.getChars(5, 2, chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcEnd > buff.length.
+        try {
+            buff.getChars(5, buff.length(), chArr, 5);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    public static int StringBufferReplaceStringIndexOutOfBoundsException_2() {
+        int result1 = 3; /*STATUS_FAILED*/
+        // StringIndexOutOfBoundsException- Access parameter range of index.
+        // Test public StringBuffer replace(int start, int end, String str).
+        StringBuffer buff1 = new StringBuffer("HelloWorld");
+        // Test start > buff1.length.
+        try {
+            buff1.replace(20, 6, "QQQ");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start < 0.
+        try {
+            buff1.replace(-2, 6, "QQQ");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start > end.
+        try {
+            buff1.replace(7, 6, "QQQ");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test end < 0.
+        try {
+            buff1.replace(7, -2, "QQQ");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    public static int StringBufferSubstringStringIndexOutOfBoundsException_1() {
+        int result1 = 3; /*STATUS_FAILED*/
+        // StringIndexOutOfBoundsException- Intercept character string specifying scope, exceed the range error.
+        // Test public String substring(int start, int end).
+        StringBuffer buff2 = new StringBuffer("HelloWorld");
+        // Test end > buff2.length.
+        try {
+            String str = buff2.substring(9, 11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test end < 0.
+        try {
+            String str = buff2.substring(9, 11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start > buff2.length.
+        try {
+            String str = buff2.substring(11, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start > end.
+        try {
+            String str = buff2.substring(8, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start < 0.
+        try {
+            String str = buff2.substring(-2, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    public static int StringBufferSubstringStringIndexOutOfBoundsException_2() {
+        int result1 = 3; /*STATUS_FAILED*/
+        // StringIndexOutOfBoundsException- Intercept character string specifying scope, exceed the range error.
+        // Test public String substring(int start).
+        StringBuffer buff3 = new StringBuffer("HelloWorld");
+        // Test start > buff3.length.
+        try {
+            String str = buff3.substring(15);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start < 0.
+        try {
+            String str = buff3.substring(-2);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            result1 = 2;
+            processResult--;
+        }
+        return result1;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0144-rt-String-BufferExceptionsTest/expected.txt b/testsuite/java_test/string_test/RT0144-rt-String-BufferExceptionsTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0144-rt-String-BufferExceptionsTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0144-rt-String-BufferExceptionsTest/test.cfg b/testsuite/java_test/string_test/RT0144-rt-String-BufferExceptionsTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..fb021ed386c260c94c9020a40f46144cf47bfd9e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0144-rt-String-BufferExceptionsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBufferExceptionsTest)
+run(StringBufferExceptionsTest)
diff --git a/testsuite/java_test/string_test/RT0145-rt-String-BuilderExceptionsTest/StringBuilderExceptionsTest.java b/testsuite/java_test/string_test/RT0145-rt-String-BuilderExceptionsTest/StringBuilderExceptionsTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ff8d1df8806f5538f72d4a2a2e8b3f41849ea389
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0145-rt-String-BuilderExceptionsTest/StringBuilderExceptionsTest.java
@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringBuilderExceptionsTest {
+    private static int processResult = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = StringBuilderSubstringStringIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderSubstringStringIndexOutOfBoundsException_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderCodePointAtIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderCodePointBeforeIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderCodePointCountIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderReplaceStringIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderGetCharsIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        try {
+            result = StringBuilderOffsetByCodePointsIndexOutOfBoundsException_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 67) {
+            result = 0;
+        }
+        return result;
+    }
+    // Test StringIndexOutOfBoundsException in String substring(int start, int end).
+    public static int StringBuilderSubstringStringIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        StringBuilder str = new StringBuilder("java is boring");
+        // Test end > str.length().
+        try {
+            String test1 = str.substring(8, 20);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test end < 0.
+        try {
+            String test1 = str.substring(8, -2);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test end < start.
+        try {
+            String test1 = str.substring(8, 6);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start > str.length().
+        try {
+            String test1 = str.substring(20, 6);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start < 0.
+        try {
+            String test1 = str.substring(-2, 6);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    // Test StringIndexOutOfBoundsException in String substring(int start).
+    public static int StringBuilderSubstringStringIndexOutOfBoundsException_2() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        StringBuilder str = new StringBuilder("java is boring");
+        // Test start > str.length.
+        try {
+            String test1 = str.substring(20);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start < 0.
+        try {
+            String test1 = str.substring(-2);
+            System.out.println(test1);
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    // Test IndexOutOfBoundsException in int codePointAt(int index).
+    public static int StringBuilderCodePointAtIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        StringBuilder buff = new StringBuilder("programming");
+        // Test index >= stringBuilder.length.
+        try {
+            int str = buff.codePointAt(11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test index < 0.
+        try {
+            int str = buff.codePointAt(-1);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    // Test IndexOutOfBoundsException in int codePointBefore(int index).
+    public static int StringBuilderCodePointBeforeIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        StringBuilder buff = new StringBuilder("HelloWorld");
+        // Test index > stringBuilder.length.
+        try {
+            int str = buff.codePointBefore(11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test index < 0.
+        try {
+            int str = buff.codePointBefore(-3);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    // Test IndexOutOfBoundsException in int codePointCount(int beginIndex, int endIndex).
+    public static int StringBuilderCodePointCountIndexOutOfBoundsException_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        StringBuilder buff = new StringBuilder("HelloWorld");
+        // Test endIndex > stringBuilder.length.
+        try {
+            int str = buff.codePointCount(5, 11);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test endIndex < beginIndex.
+        try {
+            int str = buff.codePointCount(5, 4);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test endIndex < 0.
+        try {
+            int str = buff.codePointCount(5, -2);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test beginIndex < 0.
+        try {
+            int str = buff.codePointCount(-1, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test beginIndex > stringBuilder.length.
+        try {
+            int str = buff.codePointCount(11, 5);
+            System.out.println(str);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    // Test StringIndexOutOfBoundsException in StringBuilder replace(int start, int end, String str).
+    public static int StringBuilderReplaceStringIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        StringBuilder str = new StringBuilder("Java Util Package");
+        // Test end > stringBuilder.length.
+        try {
+            StringBuilder test1 = str.replace(18, 20, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test end < start.
+        try {
+            StringBuilder test1 = str.replace(18, 16, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test end < 0.
+        try {
+            StringBuilder test1 = str.replace(18, -2, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start < 0.
+        try {
+            StringBuilder test1 = str.replace(-2, 16, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test start > stringBuilder.length.
+        try {
+            StringBuilder test1 = str.replace(20, 16, "Lang");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    // Test IndexOutOfBoundsException in void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin).
+    public static int StringBuilderGetCharsIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        StringBuilder str = new StringBuilder("java programming");
+        char[] cArr = new char[]{'t', 'u', 't', 'o', 'r', 'i', 'a', 'l', 's'};
+        // Test cArr.length - dstBegin < srcEnd - srcBegin
+        try {
+            str.getChars(5, 9, cArr, 6);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test dstBegin > cArr.length.
+        try {
+            str.getChars(0, 9, cArr, 10);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test dstBegin < 0.
+        try {
+            str.getChars(0, 9, cArr, -2);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcEnd < 0.
+        try {
+            str.getChars(0, -2, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcBegin < 0.
+        try {
+            str.getChars(-2, 5, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcBegin > srcEnd.
+        try {
+            str.getChars(5, 2, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcBegin > stringBuilder.length.
+        try {
+            str.getChars(20, 2, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test srcEnd > stringBuilder.length.
+        try {
+            str.getChars(2, 20, cArr, 0);
+            System.out.println(str);
+            System.out.println(cArr);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+    // Test IndexOutOfBoundsException in int offsetByCodePoints(int index, int codePointOffset).
+    public static int StringBuilderOffsetByCodePointsIndexOutOfBoundsException_1() {
+        int result1 = 4; /* STATUS_FAILED*/
+
+        StringBuilder str = new StringBuilder("abcdefg");
+        // Test codePointOffset > stringBuilder.length - index.
+        try {
+            int result = str.offsetByCodePoints(1, 7);
+            System.out.println(str);
+            System.out.println(result);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test index < 0.
+        try {
+            int result = str.offsetByCodePoints(-1, 3);
+            System.out.println(str);
+            System.out.println(result);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        // Test index > stringBuilder.length.
+        try {
+            int result = str.offsetByCodePoints(8, 0);
+            System.out.println(str);
+            System.out.println(result);
+            processResult -= 10;
+        } catch (IndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0145-rt-String-BuilderExceptionsTest/expected.txt b/testsuite/java_test/string_test/RT0145-rt-String-BuilderExceptionsTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0145-rt-String-BuilderExceptionsTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0145-rt-String-BuilderExceptionsTest/test.cfg b/testsuite/java_test/string_test/RT0145-rt-String-BuilderExceptionsTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6c489170f4988c8c2f5f293c5276da722a79a450
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0145-rt-String-BuilderExceptionsTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringBuilderExceptionsTest)
+run(StringBuilderExceptionsTest)
diff --git a/testsuite/java_test/string_test/RT0146-rt-String-ClassNewInstanceTest/StringClassNewInstanceTest.java b/testsuite/java_test/string_test/RT0146-rt-String-ClassNewInstanceTest/StringClassNewInstanceTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..7d76a36682d51bac641776c67b26f68be5109f3c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0146-rt-String-ClassNewInstanceTest/StringClassNewInstanceTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringClassNewInstanceTest  {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success*/
+
+        try {
+            StringClassNewInstanceTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 98) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringClassNewInstanceTest_1() {
+        Object test1 = null;
+        try {
+            test1 = String.class.newInstance();
+            processResult--;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0146-rt-String-ClassNewInstanceTest/expected.txt b/testsuite/java_test/string_test/RT0146-rt-String-ClassNewInstanceTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0146-rt-String-ClassNewInstanceTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0146-rt-String-ClassNewInstanceTest/test.cfg b/testsuite/java_test/string_test/RT0146-rt-String-ClassNewInstanceTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..c7b4e1535caeea7fa1a4f51b57010c1d6ae9f341
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0146-rt-String-ClassNewInstanceTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringClassNewInstanceTest)
+run(StringClassNewInstanceTest)
diff --git a/testsuite/java_test/string_test/RT0147-rt-String-PoolEnlargeTest/StringPoolEnlargeTest.java b/testsuite/java_test/string_test/RT0147-rt-String-PoolEnlargeTest/StringPoolEnlargeTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..29fdb89c6785646b713662b7a6b0ca3112056d36
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0147-rt-String-PoolEnlargeTest/StringPoolEnlargeTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringPoolEnlargeTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv,PrintStream out){
+        int result = 2;  /* STATUS_Success*/
+
+        try {
+            result = result - StringPoolEnlargeTest_1(47000);
+            result = result - StringPoolEnlargeTest_1(470000);
+        } catch(Exception e){
+            System.out.println(e);
+            StringPoolEnlargeTest.processResult = StringPoolEnlargeTest.processResult - 10;
+        }
+        if (result == 0 && StringPoolEnlargeTest.processResult == 95){
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringPoolEnlargeTest_1(int len) {
+        int length = len; // 47 mapleStringPool/process, 1000 key-value/mapleStringPool
+        try {
+            String[] s;
+            s = new String[length];
+            for (int i = 0; i < length; i++){
+                s[i] = Integer.toHexString(i);
+                if (s[i].intern() == Integer.toHexString(func1(len-1)).intern()) {
+                    StringPoolEnlargeTest.processResult = StringPoolEnlargeTest.processResult - 2;
+                    return 1;
+                }
+            }
+        } catch (OutOfMemoryError e) {
+            return 114;
+        }
+        StringPoolEnlargeTest.processResult = StringPoolEnlargeTest.processResult - 10;
+        return 102;
+    }
+    public static int func1(int i){
+        return i;
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0147-rt-String-PoolEnlargeTest/expected.txt b/testsuite/java_test/string_test/RT0147-rt-String-PoolEnlargeTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0147-rt-String-PoolEnlargeTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0147-rt-String-PoolEnlargeTest/test.cfg b/testsuite/java_test/string_test/RT0147-rt-String-PoolEnlargeTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..766e6dfac38e2ac51217a92d6abffb4c3fa9f19f
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0147-rt-String-PoolEnlargeTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringPoolEnlargeTest)
+run(StringPoolEnlargeTest)
diff --git a/testsuite/java_test/string_test/RT0148-rt-String-XByteTest/StringXByteTest.java b/testsuite/java_test/string_test/RT0148-rt-String-XByteTest/StringXByteTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..76874c2c4b832c2dbf7aff36150bbf1709c46b85
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0148-rt-String-XByteTest/StringXByteTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.*;
+import java.util.Random;
+public class StringXByteTest {
+    static int seed = 20;
+    static Random random = new Random(seed);
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+    public static int run(String[] args,PrintStream out) {
+        int result = 2;
+        try {
+            result = StringXByteTest1();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (result == 1 ) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringXByteTest1() {
+        String string_byte1 = getByteString(1);
+        String string_byte2 = getByteString(2);
+        String string_byte3 = getByteString(3);
+        String string_byte4 = getByteString(4);
+        byte[] by = new byte[]{(byte) 0x59,(byte) 0xCF,(byte) 0xB9,(byte) 0xE2,(byte) 0xA2,(byte) 0xA4,
+                (byte) 0xF3,(byte) 0x90,(byte) 0xA2,(byte) 0x85};
+        if ((string_byte1+string_byte2+string_byte3+string_byte4).equals(new String(by))) {
+            return 1;
+        }
+        return 3;
+    }
+    public static String getByteString(int lengthIn) {
+        String strCd = "CD";
+        String str0f = "0123456789ABCDEF";
+        String str8b = "89AB";
+        String str07 = "01234567";
+        String hexString = "0123456789ABCDEF";
+        StringBuffer byte5= new StringBuffer();
+        if (lengthIn == 1) {
+            // 1Byte: 0-7|0-F
+            byte5.append(str07.charAt( random.nextInt(8))); // 0-7
+            byte5.append(str0f.charAt( random.nextInt(16))); // 0-F
+        }else if (lengthIn == 2) {
+            // 2Byte: C-D|0-F   8-B|0-F
+            byte5.append(strCd.charAt(random.nextInt(2)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+        }else if (lengthIn == 3) {
+            // 3Byte: E|0-F  8-B|0-F 8-B|0-F
+            byte5.append("E");
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+        }else if (lengthIn == 4) {
+            // 4Byte: F|0-7 8-B|0-F 8-B|0-F 8-B|0-F
+            byte5.append("F");
+            byte5.append(str07.charAt(random.nextInt(8)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+            byte5.append(str8b.charAt(random.nextInt(4)));
+            byte5.append(str0f.charAt(random.nextInt(16)));
+        }
+        ByteArrayOutputStream scb=new ByteArrayOutputStream(byte5.length()/2);
+        for(int i=0;i<byte5.length();i+=2) {
+            scb.write((hexString.indexOf(byte5.charAt(i)) << 4 | hexString.indexOf(byte5.charAt(i + 1))));
+        }
+        return new String(scb.toByteArray());
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0148-rt-String-XByteTest/expected.txt b/testsuite/java_test/string_test/RT0148-rt-String-XByteTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0148-rt-String-XByteTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0148-rt-String-XByteTest/test.cfg b/testsuite/java_test/string_test/RT0148-rt-String-XByteTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..58a4de755f20a6c795967329eb9a45aa6a5f4540
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0148-rt-String-XByteTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringXByteTest)
+run(StringXByteTest)
diff --git a/testsuite/java_test/string_test/RT0149-rt-String-ClassNewInstance2Test/StringClassNewInstance2Test.java b/testsuite/java_test/string_test/RT0149-rt-String-ClassNewInstance2Test/StringClassNewInstance2Test.java
new file mode 100755
index 0000000000000000000000000000000000000000..6e4fc164f7a41309280cc501106c76b2f77965bf
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0149-rt-String-ClassNewInstance2Test/StringClassNewInstance2Test.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringClassNewInstance2Test {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2;  /* STATUS_Success*/
+
+        try {
+            StringClassNewInstance2Test_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringClassNewInstance2Test_1() {
+        Object test1 = null;
+        try {
+            test1 = String.class.newInstance();
+            processResult -= 4;
+        } catch (InstantiationException e1) {
+            System.err.println(e1);
+        } catch (IllegalAccessException e2) {
+            System.err.println(e2);
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0149-rt-String-ClassNewInstance2Test/expected.txt b/testsuite/java_test/string_test/RT0149-rt-String-ClassNewInstance2Test/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0149-rt-String-ClassNewInstance2Test/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0149-rt-String-ClassNewInstance2Test/test.cfg b/testsuite/java_test/string_test/RT0149-rt-String-ClassNewInstance2Test/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..048bb621c342ed260341586a372bb46b80b7ea6e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0149-rt-String-ClassNewInstance2Test/test.cfg
@@ -0,0 +1,2 @@
+compile(StringClassNewInstance2Test)
+run(StringClassNewInstance2Test)
diff --git a/testsuite/java_test/string_test/RT0150-rt-String-Emoji/StringEmojiTest.java b/testsuite/java_test/string_test/RT0150-rt-String-Emoji/StringEmojiTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..1fbf60a60824cebd7a6f028e4ff5bb332492be67
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0150-rt-String-Emoji/StringEmojiTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+import java.sql.SQLOutput;
+import java.util.Arrays;
+public class StringEmojiTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 2 /* STATUS_FAILED*/
+;
+        try {
+            if(StringEmojiTest()){
+                result =1;
+            }
+        } catch(Exception e){
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 1 && processResult == 99){
+            result =0;
+        }
+        return result;
+    }
+    public static boolean StringEmojiTest() throws UnsupportedEncodingException {
+        // 以下用byte[]构造string 😘
+        byte[] emoji_FacewithTearsofJoy = {(byte) 0xD8, (byte) 0x3D, (byte) 0xDE, (byte) 0x02}; // U+1F602
+        byte[] emoji = {(byte) 0xD8, (byte) 0x3D, (byte) 0xDE, (byte) 0x18};
+        String emojis = "\uD83D\uDE18";
+//        System.out.println(new String(emoji, Charset.forName("unicode")));
+        /* 以上处理用例输出，用例输出是"😘"
+         * 得到unicode [-2 -1 -40 61 -34 24]
+         * 得到UTF-16  [-2 -1 -40 61 -34 24]
+         * 得到UTF-8   [-16 -97 -104 -104]
+         * 得到ISO-8859-1 [63] 已经出错了
+         * 得到ASCII   [63] 已经出错了
+        */
+
+        byte[] ab_10 = "\uD83D\uDE18".getBytes("unicode");
+//        for (int i = 0; i <ab_10.length ; i++) {
+//            System.out.print(ab_10[i]+" ");
+//        }
+//        System.out.println();
+        return Arrays.equals(emojis.getBytes("unicode"),ab_10);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0150-rt-String-Emoji/expected.txt b/testsuite/java_test/string_test/RT0150-rt-String-Emoji/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0150-rt-String-Emoji/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/RT0150-rt-String-Emoji/test.cfg b/testsuite/java_test/string_test/RT0150-rt-String-Emoji/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..89e11f1b388266b22cb3f69b1ef116a8ee253ef7
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0150-rt-String-Emoji/test.cfg
@@ -0,0 +1,2 @@
+compile(StringEmojiTest)
+run(StringEmojiTest)
diff --git a/testsuite/java_test/string_test/RT0151-rt-String-UncompressTest/StringUnCompressTest.java b/testsuite/java_test/string_test/RT0151-rt-String-UncompressTest/StringUnCompressTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..e532133a28598ed847a33c29404c467051754853
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0151-rt-String-UncompressTest/StringUnCompressTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringUnCompressTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringUnCompressTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringUnCompressTest_1() {
+        String str = "哈";
+        byte[] strbyte = str.getBytes();
+        String res1_1 = new String(strbyte);
+        System.out.println(res1_1.equals(str)); // true
+        String str1 = "abc";
+        String str2 = "abc哈";
+        String res2_1 = str1.replace("a", "哈"); // 哈bc
+        String res2_2 = str2.replace("a", "哈"); // 哈bc哈
+        String res2_3 = str2.replace("哈", "a"); // abca
+        String res2_4 = str2.replace("a", "d"); // dbc哈
+        String res2_5 = str2.replace("哈", "中"); // abc中
+        System.out.println(res2_1.equals("哈bc"));
+        System.out.println(res2_2.equals("哈bc哈"));
+        System.out.println(res2_3.equals("abca"));
+        System.out.println(res2_4.equals("dbc哈"));
+        System.out.println(res2_5.equals("abc中"));
+        String str3 = "abc中"; // not compress
+        String res3_1 = str1.concat(str2);
+        String res3_2 = str2.concat(str1);
+        String res3_3 = str2.concat(str3);
+        System.out.println(res3_1.equals("abcabc哈"));
+        System.out.println(res3_2.equals("abc哈abc"));
+        System.out.println(res3_3.equals("abc哈abc中"));
+        int res4_1 = str3.indexOf("中");
+        int res4_2 = str3.indexOf("a");
+        System.out.println(res4_1);
+        System.out.println(res4_2);
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0151-rt-String-UncompressTest/expected.txt b/testsuite/java_test/string_test/RT0151-rt-String-UncompressTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8dc2631ec49337fc874a2e730f30af7db9085f05
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0151-rt-String-UncompressTest/expected.txt
@@ -0,0 +1,12 @@
+true
+true
+true
+true
+true
+true
+true
+true
+true
+3
+0
+0
diff --git a/testsuite/java_test/string_test/RT0151-rt-String-UncompressTest/test.cfg b/testsuite/java_test/string_test/RT0151-rt-String-UncompressTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..410a2c09217bed03c28e2eab05c8f5c74add7f62
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0151-rt-String-UncompressTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringUnCompressTest)
+run(StringUnCompressTest)
diff --git a/testsuite/java_test/string_test/RT0152-rt-string-StringEqualsNull0001/TestStringEqualsNull.java b/testsuite/java_test/string_test/RT0152-rt-string-StringEqualsNull0001/TestStringEqualsNull.java
new file mode 100644
index 0000000000000000000000000000000000000000..83362773a94bcc98af770070192f1f2d2f7efb0d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0152-rt-string-StringEqualsNull0001/TestStringEqualsNull.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class TestStringEqualsNull {
+    public static void main(String args[]) throws Exception {
+        StringEqualsNull test = new StringEqualsNull();
+        test.resultEqualsNull();
+    }
+}
+class StringEqualsNull {
+    private final String[] nullStrings = new String[]{
+            "",
+            "Hello my name is ",
+            "What's your name?",
+            "v3ry Cre@tiVe?****",
+            "!@#$%^&*()_++*^$#@",
+    };
+    private final Object[] objects = new Object[]{
+            // Compare to Double object
+            new Double(1.5),
+            // Compare to Integer object
+            new Integer(9999999),
+            // Compare to String array
+            new String[]{"h", "i"},
+            // Compare to int array
+            new int[]{1, 2, 3},
+            // Compare to Character object
+            new Character('a')
+    };
+    private final String tmpStr1 = "012345678901234567890"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789";
+    private final String tmpStr2 = "z012345678901234567890"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789"
+            + "012345678901234567890123456789012345678x";
+    private final String[] nonalignedStrings = new String[]{
+            tmpStr1.substring(1),
+            tmpStr1.substring(2),
+            tmpStr2.substring(4),
+            tmpStr2.substring(5),
+            "hello".substring(1),
+    };
+    public void resultEqualsNull() {
+        for (int i = 0; i < nullStrings.length; i++) {
+            System.out.println(nullStrings[i].equals(null));
+            System.out.println(objects[i].equals(null));
+            System.out.println(nonalignedStrings[i].equals(null));
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0152-rt-string-StringEqualsNull0001/expected.txt b/testsuite/java_test/string_test/RT0152-rt-string-StringEqualsNull0001/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..96950dce3b23350597719b412fb87ea0339c0e48
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0152-rt-string-StringEqualsNull0001/expected.txt
@@ -0,0 +1,15 @@
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
diff --git a/testsuite/java_test/string_test/RT0152-rt-string-StringEqualsNull0001/test.cfg b/testsuite/java_test/string_test/RT0152-rt-string-StringEqualsNull0001/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d438535e55bdd314c0214bf3f804d5a447e02b61
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0152-rt-string-StringEqualsNull0001/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsNull)
+run(TestStringEqualsNull)
diff --git a/testsuite/java_test/string_test/RT0154-rt-string-StringEqualsShort/TestStringEqualsShort.java b/testsuite/java_test/string_test/RT0154-rt-string-StringEqualsShort/TestStringEqualsShort.java
new file mode 100644
index 0000000000000000000000000000000000000000..924369058386030fc6338adbe0b95d98fadc223d
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0154-rt-string-StringEqualsShort/TestStringEqualsShort.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class TestStringEqualsShort {
+    public static void main(String args[]) throws Exception {
+        StringEqualsShort test = new StringEqualsShort();
+        test.resultEqualsShort();
+    }
+}
+class StringEqualsShort {
+    private final String[][] shortStrings = new String[][]{
+            // Equal, constant comparison
+            {"a", "a"},
+            // Different constants, first character different
+            {":", " :"},
+            // Different constants, last character different, same length
+            {"ja M", "ja N"},
+            // Different constants, different lengths
+            {"$$$", "$$"},
+            // Force execution of code beyond reference equality check
+            {"hi", new String("hi")}
+    };
+    public void resultEqualsShort() {
+        for (int i = 0; i < shortStrings.length; i++) {
+            System.out.println(shortStrings[i][0].equals(shortStrings[i][1]));
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0154-rt-string-StringEqualsShort/expected.txt b/testsuite/java_test/string_test/RT0154-rt-string-StringEqualsShort/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..21b8aebfea92d8e3955052165e1903c9b53b99a2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0154-rt-string-StringEqualsShort/expected.txt
@@ -0,0 +1,5 @@
+true
+false
+false
+false
+true
diff --git a/testsuite/java_test/string_test/RT0154-rt-string-StringEqualsShort/test.cfg b/testsuite/java_test/string_test/RT0154-rt-string-StringEqualsShort/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..13170e2f352fac64e368df21ccb7d2ab9febf98b
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0154-rt-string-StringEqualsShort/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsShort)
+run(TestStringEqualsShort)
diff --git a/testsuite/java_test/string_test/RT0155-rt-string-StringEqualsMedium/TestStringEqualsMedium.java b/testsuite/java_test/string_test/RT0155-rt-string-StringEqualsMedium/TestStringEqualsMedium.java
new file mode 100644
index 0000000000000000000000000000000000000000..71dd02bc93d47f34b9d7aeb47ac4b172167b11bd
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0155-rt-string-StringEqualsMedium/TestStringEqualsMedium.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class TestStringEqualsMedium {
+    public static void main(String args[]) throws Exception {
+        StringEqualsMedium test = new StringEqualsMedium();
+        test.resultEqualsMedium();
+    }
+}
+class StringEqualsMedium {
+    private final String[][] mediumStrings = new String[][]{
+            // Equal, constant comparison
+            {"Hello my name is ", "Hello my name is "},
+            // Different constants, different lengths
+            {"What's your name?", "Whats your name?"},
+            // Force execution of code beyond reference equality check
+            {"Android Runtime", new String("Android Runtime")},
+            // Different constants, last character different, same length
+            {"v3ry Cre@tiVe?****", "v3ry Cre@tiVe?***."},
+            // Different constants, first character different, same length
+            {"!@#$%^&*()_++*^$#@", "0@#$%^&*()_++*^$#@"}
+    };
+    public void resultEqualsMedium() {
+        for (int i = 0; i < mediumStrings.length; i++) {
+            System.out.println(mediumStrings[i][0].equals(mediumStrings[i][1]));
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0155-rt-string-StringEqualsMedium/expected.txt b/testsuite/java_test/string_test/RT0155-rt-string-StringEqualsMedium/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cb6eee55fe3eb2bfdfd32131130928b6d160a204
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0155-rt-string-StringEqualsMedium/expected.txt
@@ -0,0 +1,5 @@
+true
+false
+true
+false
+false
diff --git a/testsuite/java_test/string_test/RT0155-rt-string-StringEqualsMedium/test.cfg b/testsuite/java_test/string_test/RT0155-rt-string-StringEqualsMedium/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b72b1eed8a5ebb7217c49130c07fa4ea62ba5f1
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0155-rt-string-StringEqualsMedium/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsMedium)
+run(TestStringEqualsMedium)
diff --git a/testsuite/java_test/string_test/RT0156-rt-string-StringEqualsLong/TestStringEqualsLong.java b/testsuite/java_test/string_test/RT0156-rt-string-StringEqualsLong/TestStringEqualsLong.java
new file mode 100644
index 0000000000000000000000000000000000000000..920bd3f05e2a0bc258b12e427fbd295e82b65534
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0156-rt-string-StringEqualsLong/TestStringEqualsLong.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class TestStringEqualsLong {
+    public static void main(String args[]) throws Exception {
+        StringEqualsLong test = new StringEqualsLong();
+        test.resultEqualsLong();
+    }
+}
+class StringEqualsLong {
+    private final String long1 = "Ahead-of-time compilation is possible as the compiler may just"
+            + "convert an instruction thus: dex code: add-int v1000, v2000, v3000 C code: setIntRegter"
+            + "(1000, call_dex_add_int(getIntRegister(2000), getIntRegister(3000)) This means even lid"
+            + "instructions may have code generated, however, it is not expected that code generate in"
+            + "this way will perform well. The job of AOT verification is to tell the compiler that"
+            + "instructions are sound and provide tests to detect unsound sequences so slow path code"
+            + "may be generated. Other than for totally invalid code, the verification may fail at AOr"
+            + "run-time. At AOT time it can be because of incomplete information, at run-time it can e"
+            + "that code in a different apk that the application depends upon has changed. The Dalvik"
+            + "verifier would return a bool to state whether a Class were good or bad. In ART the fail"
+            + "case becomes either a soft or hard failure. Classes have new states to represent that a"
+            + "soft failure occurred at compile time and should be re-verified at run-time.";
+    private final String[][] longStrings = new String[][]{
+            // Force execution of code beyond reference equality check
+            {long1, new String(long1)},
+            // Different constants, last character different, same length
+            {long1 + "fun!", long1 + "----"},
+            // Equal, constant comparison
+            {long1 + long1, long1 + long1},
+            // Different constants, different lengths
+            {long1 + "123456789", long1 + "12345678"},
+            // Different constants, first character different, same length
+            {"Android Runtime" + long1, "android Runtime" + long1}
+    };
+    public void resultEqualsLong() {
+        for (int i = 0; i < longStrings.length; i++) {
+            System.out.println(longStrings[i][0].equals(longStrings[i][1]));
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0156-rt-string-StringEqualsLong/expected.txt b/testsuite/java_test/string_test/RT0156-rt-string-StringEqualsLong/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cb6eee55fe3eb2bfdfd32131130928b6d160a204
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0156-rt-string-StringEqualsLong/expected.txt
@@ -0,0 +1,5 @@
+true
+false
+true
+false
+false
diff --git a/testsuite/java_test/string_test/RT0156-rt-string-StringEqualsLong/test.cfg b/testsuite/java_test/string_test/RT0156-rt-string-StringEqualsLong/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..393b851ffb0a56e182468cf2d08b8548c5b98f97
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0156-rt-string-StringEqualsLong/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsLong)
+run(TestStringEqualsLong)
diff --git a/testsuite/java_test/string_test/RT0157-rt-string-StringEqualsVeryLong/TestStringEqualsVeryLong.java b/testsuite/java_test/string_test/RT0157-rt-string-StringEqualsVeryLong/TestStringEqualsVeryLong.java
new file mode 100644
index 0000000000000000000000000000000000000000..57175c663a984c563c2a164769f651d038dbd2a9
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0157-rt-string-StringEqualsVeryLong/TestStringEqualsVeryLong.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class TestStringEqualsVeryLong {
+    public static void main(String args[]) throws Exception {
+        StringEqualsVeryLong test = new StringEqualsVeryLong();
+        test.resultEqualsVeryLong();
+    }
+}
+class StringEqualsVeryLong {
+    private final String veryLong = "Garbage collection has two phases. The first distinguishes"
+            + "live objects from garbage objects.  The second is reclaiming the rage of garbage object"
+            + "In the mark-sweep algorithm used by Dalvik, the first phase is achievd by computing the"
+            + "closure of all reachable objects in a process known as tracing from theoots.  After the"
+            + "trace has completed, garbage objects are reclaimed.  Each of these operations can be"
+            + "parallelized and can be interleaved with the operation of the applicationTraditionally,"
+            + "the tracing phase dominates the time spent in garbage collection.  The greatreduction i"
+            + "pause time can be achieved by interleaving as much of this phase as possible with the"
+            + "application. If we simply ran the GC in a separate thread with no other changes, normal"
+            + "operation of an application would confound the trace.  Abstractly, the GC walks the h o"
+            + "all reachable objects.  When the application is paused, the object graph cannot change."
+            + "The GC can therefore walk this structure and assume that all reachable objects live."
+            + "When the application is running, this graph may be altered. New nodes may be addnd edge"
+            + "may be changed.  These changes may cause live objects to be hidden and falsely recla by"
+            + "the GC.  To avoid this problem a write barrier is used to intercept and record modifion"
+            + "to objects in a separate structure.  After performing its walk, the GC will revisit the"
+            + "updated objects and re-validate its assumptions.  Without a card table, the garbage"
+            + "collector would have to visit all objects reached during the trace looking for dirtied"
+            + "objects.  The cost of this operation would be proportional to the amount of live data."
+            + "With a card table, the cost of this operation is proportional to the amount of updateat"
+            + "The write barrier in Dalvik is a card marking write barrier.  Card marking is the proce"
+            + "of noting the location of object connectivity changes on a sub-page granularity.  A car"
+            + "is merely a colorful term for a contiguous extent of memory smaller than a page, common"
+            + "somewhere between 128- and 512-bytes.  Card marking is implemented by instrumenting all"
+            + "locations in the virtual machine which can assign a pointer to an object.  After themal"
+            + "pointer assignment has occurred, a byte is written to a byte-map spanning the heap whic"
+            + "corresponds to the location of the updated object.  This byte map is known as a card ta"
+            + "The garbage collector visits this card table and looks for written bytes to reckon the"
+            + "location of updated objects.  It then rescans all objects located on the dirty card,"
+            + "correcting liveness assumptions that were invalidated by the application.  While card"
+            + "marking imposes a small burden on the application outside of a garbage collection, the"
+            + "overhead of maintaining the card table is paid for by the reduced time spent inside"
+            + "garbage collection. With the concurrent garbage collection thread and a write barrier"
+            + "supported by the interpreter, JIT, and Runtime we modify garbage collection";
+    private final String[][] veryLongStrings = new String[][]{
+            // Force execution of code beyond reference equality check
+            {veryLong, new String(veryLong)},
+            // Different constants, different lengths
+            {veryLong + veryLong, veryLong + " " + veryLong},
+            // Equal, constant comparison
+            {veryLong + veryLong + veryLong, veryLong + veryLong + veryLong},
+            // Different constants, last character different, same length
+            {veryLong + "77777", veryLong + "99999"},
+            // Different constants, first character different
+            {"Android Runtime" + veryLong, "android Runtime" + veryLong}
+    };
+    // Benchmark cases with medium length (10-15 character) Strings
+    public void resultEqualsVeryLong() {
+        for (int i = 0; i < veryLongStrings.length; i++) {
+            System.out.println(veryLongStrings[i][0].equals(veryLongStrings[i][1]));
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0157-rt-string-StringEqualsVeryLong/expected.txt b/testsuite/java_test/string_test/RT0157-rt-string-StringEqualsVeryLong/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cb6eee55fe3eb2bfdfd32131130928b6d160a204
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0157-rt-string-StringEqualsVeryLong/expected.txt
@@ -0,0 +1,5 @@
+true
+false
+true
+false
+false
diff --git a/testsuite/java_test/string_test/RT0157-rt-string-StringEqualsVeryLong/test.cfg b/testsuite/java_test/string_test/RT0157-rt-string-StringEqualsVeryLong/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d15c408bea53ee7a01b50e3901944157adb7e6df
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0157-rt-string-StringEqualsVeryLong/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsVeryLong)
+run(TestStringEqualsVeryLong)
diff --git a/testsuite/java_test/string_test/RT0158-rt-string-StringEqualsNonWordAligned/TestStringEqualsNonWordAligned.java b/testsuite/java_test/string_test/RT0158-rt-string-StringEqualsNonWordAligned/TestStringEqualsNonWordAligned.java
new file mode 100644
index 0000000000000000000000000000000000000000..c98ddcff3a0d8776d573f0037ec48373c7891ceb
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0158-rt-string-StringEqualsNonWordAligned/TestStringEqualsNonWordAligned.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class TestStringEqualsNonWordAligned {
+    public static void main(String args[]) throws Exception {
+        StringEqualsNonWordAligned test = new StringEqualsNonWordAligned();
+        test.resultEqualsNonWordAligned();
+    }
+}
+class StringEqualsNonWordAligned {
+    private final String long1 = "Ahead-of-time compilation is possible as the compiler may just"
+            + "convert an instruction thus: dex code: add-int v1000, v2000, v3000 C code: setIntRegter"
+            + "(1000, call_dex_add_int(getIntRegister(2000), getIntRegister(3000)) This means even lid"
+            + "instructions may have code generated, however, it is not expected that code generate in"
+            + "this way will perform well. The job of AOT verification is to tell the compiler that"
+            + "instructions are sound and provide tests to detect unsound sequences so slow path code"
+            + "may be generated. Other than for totally invalid code, the verification may fail at AOr"
+            + "run-time. At AOT time it can be because of incomplete information, at run-time it can e"
+            + "that code in a different apk that the application depends upon has changed. The Dalvik"
+            + "verifier would return a bool to state whether a Class were good or bad. In ART the fail"
+            + "case becomes either a soft or hard failure. Classes have new states to represent that a"
+            + "soft failure occurred at compile time and should be re-verified at run-time.";
+    private final String veryLong = "Garbage collection has two phases. The first distinguishes"
+            + "live objects from garbage objects.  The second is reclaiming the rage of garbage object"
+            + "In the mark-sweep algorithm used by Dalvik, the first phase is achievd by computing the"
+            + "closure of all reachable objects in a process known as tracing from theoots.  After the"
+            + "trace has completed, garbage objects are reclaimed.  Each of these operations can be"
+            + "parallelized and can be interleaved with the operation of the applicationTraditionally,"
+            + "the tracing phase dominates the time spent in garbage collection.  The greatreduction i"
+            + "pause time can be achieved by interleaving as much of this phase as possible with the"
+            + "application. If we simply ran the GC in a separate thread with no other changes, normal"
+            + "operation of an application would confound the trace.  Abstractly, the GC walks the h o"
+            + "all reachable objects.  When the application is paused, the object graph cannot change."
+            + "The GC can therefore walk this structure and assume that all reachable objects live."
+            + "When the application is running, this graph may be altered. New nodes may be addnd edge"
+            + "may be changed.  These changes may cause live objects to be hidden and falsely recla by"
+            + "the GC.  To avoid this problem a write barrier is used to intercept and record modifion"
+            + "to objects in a separate structure.  After performing its walk, the GC will revisit the"
+            + "updated objects and re-validate its assumptions.  Without a card table, the garbage"
+            + "collector would have to visit all objects reached during the trace looking for dirtied"
+            + "objects.  The cost of this operation would be proportional to the amount of live data."
+            + "With a card table, the cost of this operation is proportional to the amount of updateat"
+            + "The write barrier in Dalvik is a card marking write barrier.  Card marking is the proce"
+            + "of noting the location of object connectivity changes on a sub-page granularity.  A car"
+            + "is merely a colorful term for a contiguous extent of memory smaller than a page, common"
+            + "somewhere between 128- and 512-bytes.  Card marking is implemented by instrumenting all"
+            + "locations in the virtual machine which can assign a pointer to an object.  After themal"
+            + "pointer assignment has occurred, a byte is written to a byte-map spanning the heap whic"
+            + "corresponds to the location of the updated object.  This byte map is known as a card ta"
+            + "The garbage collector visits this card table and looks for written bytes to reckon the"
+            + "location of updated objects.  It then rescans all objects located on the dirty card,"
+            + "correcting liveness assumptions that were invalidated by the application.  While card"
+            + "marking imposes a small burden on the application outside of a garbage collection, the"
+            + "overhead of maintaining the card table is paid for by the reduced time spent inside"
+            + "garbage collection. With the concurrent garbage collection thread and a write barrier"
+            + "supported by the interpreter, JIT, and Runtime we modify garbage collection";
+    private final String tmpStr1 = "012345678901234567890"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789";
+    private final String tmpStr2 = "z012345678901234567890"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789"
+            + "0123456789012345678901234567890123456789"
+            + "012345678901234567890123456789012345678x";
+    private final String[][] nonalignedStrings = new String[][]{
+            // Different non-word aligned medium length strings
+            {tmpStr1, tmpStr1.substring(0)},
+            // Different differently non-word aligned medium length strings
+            {tmpStr2, tmpStr2.substring(2)},
+            // Different non-word aligned long length strings
+            {long1, long1.substring(3)},
+            // Different non-word aligned very long length strings
+            {veryLong, veryLong.substring(1)},
+            // Equal non-word aligned constant strings
+            {"hello", "hello".substring(0)}
+    };
+    public void resultEqualsNonWordAligned() {
+        for (int i = 0; i < nonalignedStrings.length; i++) {
+            System.out.println(nonalignedStrings[i][0].equals(nonalignedStrings[i][1]));
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0158-rt-string-StringEqualsNonWordAligned/expected.txt b/testsuite/java_test/string_test/RT0158-rt-string-StringEqualsNonWordAligned/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..21b8aebfea92d8e3955052165e1903c9b53b99a2
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0158-rt-string-StringEqualsNonWordAligned/expected.txt
@@ -0,0 +1,5 @@
+true
+false
+false
+false
+true
diff --git a/testsuite/java_test/string_test/RT0158-rt-string-StringEqualsNonWordAligned/test.cfg b/testsuite/java_test/string_test/RT0158-rt-string-StringEqualsNonWordAligned/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f320180cc821b5d5a7c09d6ec3807871232d34fd
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0158-rt-string-StringEqualsNonWordAligned/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsNonWordAligned)
+run(TestStringEqualsNonWordAligned)
diff --git a/testsuite/java_test/string_test/RT0159-rt-string-StringEqualsEnd/TestStringEqualsEnd.java b/testsuite/java_test/string_test/RT0159-rt-string-StringEqualsEnd/TestStringEqualsEnd.java
new file mode 100644
index 0000000000000000000000000000000000000000..de300cf82033470cb76ede83b8b48015741e8f41
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0159-rt-string-StringEqualsEnd/TestStringEqualsEnd.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class TestStringEqualsEnd {
+    public static void main(String args[]) throws Exception {
+        StringEqualsEnd test = new StringEqualsEnd();
+        test.resultEqualsEnd();
+    }
+}
+class StringEqualsEnd {
+    private final String long1 = "Ahead-of-time compilation is possible as the compiler may just"
+            + "convert an instruction thus: dex code: add-int v1000, v2000, v3000 C code: setIntRegter"
+            + "(1000, call_dex_add_int(getIntRegister(2000), getIntRegister(3000)) This means even lid"
+            + "instructions may have code generated, however, it is not expected that code generate in"
+            + "this way will perform well. The job of AOT verification is to tell the compiler that"
+            + "instructions are sound and provide tests to detect unsound sequences so slow path code"
+            + "may be generated. Other than for totally invalid code, the verification may fail at AOr"
+            + "run-time. At AOT time it can be because of incomplete information, at run-time it can e"
+            + "that code in a different apk that the application depends upon has changed. The Dalvik"
+            + "verifier would return a bool to state whether a Class were good or bad. In ART the fail"
+            + "case becomes either a soft or hard failure. Classes have new states to represent that a"
+            + "soft failure occurred at compile time and should be re-verified at run-time.";
+    private final String veryLong = "Garbage collection has two phases. The first distinguishes"
+            + "live objects from garbage objects.  The second is reclaiming the rage of garbage object"
+            + "In the mark-sweep algorithm used by Dalvik, the first phase is achievd by computing the"
+            + "closure of all reachable objects in a process known as tracing from theoots.  After the"
+            + "trace has completed, garbage objects are reclaimed.  Each of these operations can be"
+            + "parallelized and can be interleaved with the operation of the applicationTraditionally,"
+            + "the tracing phase dominates the time spent in garbage collection.  The greatreduction i"
+            + "pause time can be achieved by interleaving as much of this phase as possible with the"
+            + "application. If we simply ran the GC in a separate thread with no other changes, normal"
+            + "operation of an application would confound the trace.  Abstractly, the GC walks the h o"
+            + "all reachable objects.  When the application is paused, the object graph cannot change."
+            + "The GC can therefore walk this structure and assume that all reachable objects live."
+            + "When the application is running, this graph may be altered. New nodes may be addnd edge"
+            + "may be changed.  These changes may cause live objects to be hidden and falsely recla by"
+            + "the GC.  To avoid this problem a write barrier is used to intercept and record modifion"
+            + "to objects in a separate structure.  After performing its walk, the GC will revisit the"
+            + "updated objects and re-validate its assumptions.  Without a card table, the garbage"
+            + "collector would have to visit all objects reached during the trace looking for dirtied"
+            + "objects.  The cost of this operation would be proportional to the amount of live data."
+            + "With a card table, the cost of this operation is proportional to the amount of updateat"
+            + "The write barrier in Dalvik is a card marking write barrier.  Card marking is the proce"
+            + "of noting the location of object connectivity changes on a sub-page granularity.  A car"
+            + "is merely a colorful term for a contiguous extent of memory smaller than a page, common"
+            + "somewhere between 128- and 512-bytes.  Card marking is implemented by instrumenting all"
+            + "locations in the virtual machine which can assign a pointer to an object.  After themal"
+            + "pointer assignment has occurred, a byte is written to a byte-map spanning the heap whic"
+            + "corresponds to the location of the updated object.  This byte map is known as a card ta"
+            + "The garbage collector visits this card table and looks for written bytes to reckon the"
+            + "location of updated objects.  It then rescans all objects located on the dirty card,"
+            + "correcting liveness assumptions that were invalidated by the application.  While card"
+            + "marking imposes a small burden on the application outside of a garbage collection, the"
+            + "overhead of maintaining the card table is paid for by the reduced time spent inside"
+            + "garbage collection. With the concurrent garbage collection thread and a write barrier"
+            + "supported by the interpreter, JIT, and Runtime we modify garbage collection";
+    private final String[][] endStrings = new String[][]{
+            // Different constants, medium but different lengths
+            {"Hello", "Hello "},
+            // Different constants, long but different lengths
+            {long1, long1 + "x"},
+            // Different constants, very long but different lengths
+            {veryLong, veryLong + "?"},
+            // Different constants, same medium lengths
+            {"How are you doing today?", "How are you doing today "},
+            // Different constants, short but different lengths
+            {"1", "1."}
+    };
+    // Benchmark cases with medium length (10-15 character) Strings
+    public void resultEqualsEnd() {
+        for (int i = 0; i < endStrings.length; i++) {
+            System.out.println(endStrings[i][0].equals(endStrings[i][1]));
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0159-rt-string-StringEqualsEnd/expected.txt b/testsuite/java_test/string_test/RT0159-rt-string-StringEqualsEnd/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..440a9969c340df44cb420de87707a34ee9a9599e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0159-rt-string-StringEqualsEnd/expected.txt
@@ -0,0 +1,5 @@
+false
+false
+false
+false
+false
diff --git a/testsuite/java_test/string_test/RT0159-rt-string-StringEqualsEnd/test.cfg b/testsuite/java_test/string_test/RT0159-rt-string-StringEqualsEnd/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4e3b71e649545d3251bfa5aa540536ec4467557e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0159-rt-string-StringEqualsEnd/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsEnd)
+run(TestStringEqualsEnd)
diff --git a/testsuite/java_test/string_test/RT0160-rt-string-StringEqualsNonString/TestStringEqualsNonString.java b/testsuite/java_test/string_test/RT0160-rt-string-StringEqualsNonString/TestStringEqualsNonString.java
new file mode 100644
index 0000000000000000000000000000000000000000..878b49e556e29984055505c74e9caa4674ef30db
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0160-rt-string-StringEqualsNonString/TestStringEqualsNonString.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class TestStringEqualsNonString {
+    public static void main(String args[]) throws Exception {
+        StringEqualsNonString test = new StringEqualsNonString();
+        test.resultEqualsNonString();
+    }
+}
+class StringEqualsNonString {
+    private final String[] Strings = new String[]{
+            "Hello my name is ",
+            "What's your name?",
+            "Android Runtime",
+            "v3ry Cre@tiVe?****",
+            "!@#$%^&*()_++*^$#@",
+    };
+    private final Object[] objects = new Object[]{
+            // Compare to Double object
+            new Double(1.5),
+            // Compare to Integer object
+            new Integer(9999999),
+            // Compare to String array
+            new String[]{"h", "i"},
+            // Compare to int array
+            new int[]{1, 2, 3},
+            // Compare to Character object
+            new Character('a')
+    };
+    public void resultEqualsNonString() {
+        for (int i = 0; i < Strings.length; i++) {
+            System.out.println(Strings[i].equals(objects[i]));
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/RT0160-rt-string-StringEqualsNonString/expected.txt b/testsuite/java_test/string_test/RT0160-rt-string-StringEqualsNonString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..440a9969c340df44cb420de87707a34ee9a9599e
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0160-rt-string-StringEqualsNonString/expected.txt
@@ -0,0 +1,5 @@
+false
+false
+false
+false
+false
diff --git a/testsuite/java_test/string_test/RT0160-rt-string-StringEqualsNonString/test.cfg b/testsuite/java_test/string_test/RT0160-rt-string-StringEqualsNonString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4d6e3aba999b4d6dffd32fb5425e51711264c392
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0160-rt-string-StringEqualsNonString/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsNonString)
+run(TestStringEqualsNonString)
diff --git a/testsuite/java_test/string_test/RT0161-rt-string-StringEqualsList/TestStringEqualsList.java b/testsuite/java_test/string_test/RT0161-rt-string-StringEqualsList/TestStringEqualsList.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e40a4f091bb7a7fb434f9a46df57ef344b44b9c
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0161-rt-string-StringEqualsList/TestStringEqualsList.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+public class TestStringEqualsList {
+    public static void main(String[] args) {
+        String str1 = "Amy";
+        ArrayList<String> list = new ArrayList<>();
+        list.add("Amy");
+        list.add("Jack");
+        list.add("Pearl");
+        list.add("Rose");
+        for (String str : list) {
+            if (str.equals(str1)) {
+                System.out.println("Amy is present");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/RT0161-rt-string-StringEqualsList/expected.txt b/testsuite/java_test/string_test/RT0161-rt-string-StringEqualsList/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..33f127289afbbd963c07a0b09b266c101fe05cc4
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0161-rt-string-StringEqualsList/expected.txt
@@ -0,0 +1 @@
+Amy is present
diff --git a/testsuite/java_test/string_test/RT0161-rt-string-StringEqualsList/test.cfg b/testsuite/java_test/string_test/RT0161-rt-string-StringEqualsList/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e53afeffde055da2aae362009306deb4d7646b40
--- /dev/null
+++ b/testsuite/java_test/string_test/RT0161-rt-string-StringEqualsList/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsList)
+run(TestStringEqualsList)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringFormatTest/StringFormatTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringFormatTest/StringFormatTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..0a02f76ae070fc7e379695e65a9c1b70d6bbf027
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringFormatTest/StringFormatTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.Date;
+import java.util.Locale;
+public class StringFormatTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 3/*STATUS_FAILED*/;
+        try {
+            result = StringFormatTest_1(new Date());
+//            System.out.println(String.format(Locale.ENGLISH, "%tA", new Date()));
+//            System.out.println(String.format(Locale.CHINESE, "%tA", new Date()));
+//            System.out.println(String.format(Locale.FRENCH, "%tA", new Date()));
+        } catch(Exception e){
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 2 && processResult == 99){
+            result =0;
+        }
+        return result;
+    }
+    private static int StringFormatTest_1(Object obj) {
+        int result1 = 3/*STATUS_FAILED*/;
+        if (String.format(Locale.ENGLISH, "%tA", obj).equals("Monday")) {
+            if (String.format(Locale.CHINESE, "%tA", obj).equals("星期一") && String.format(Locale.FRENCH, "%tA", obj).equals("lundi")) {
+                return 2;
+            }
+        } else if (String.format(Locale.ENGLISH, "%tA", obj).equals("Tuesday")) {
+            if (String.format(Locale.CHINESE, "%tA", obj).equals("星期二") && String.format(Locale.FRENCH, "%tA", obj).equals("mardi")) {
+                return 2;
+            }
+        } else if (String.format(Locale.ENGLISH, "%tA", obj).equals("Wednesday")) {
+            if (String.format(Locale.CHINESE, "%tA", obj).equals("星期三") && String.format(Locale.FRENCH, "%tA", obj).equals("mercredi")) {
+                return 2;
+            }
+        } else if (String.format(Locale.ENGLISH, "%tA", obj).equals("Thursday")) {
+            if (String.format(Locale.CHINESE, "%tA", obj).equals("星期四") && String.format(Locale.FRENCH, "%tA", obj).equals("jeudi")) {
+                return 2;
+            }
+        } else if (String.format(Locale.ENGLISH, "%tA", obj).equals("Friday")) {
+            if (String.format(Locale.CHINESE, "%tA", obj).equals("星期五") && String.format(Locale.FRENCH, "%tA", obj).equals("vendredi")) {
+                return 2;
+            }
+        } else if (String.format(Locale.ENGLISH, "%tA", obj).equals("Saturday")) {
+            if (String.format(Locale.CHINESE, "%tA", obj).equals("星期六") && String.format(Locale.FRENCH, "%tA", obj).equals("samedi")) {
+                return 2;
+            }
+        } else if (String.format(Locale.ENGLISH, "%tA", obj).equals("Sunday")) {
+            if (String.format(Locale.CHINESE, "%tA", obj).equals("星期日") && String.format(Locale.FRENCH, "%tA", obj).equals("dimanche")) {
+                return 2;
+            }
+        } else {
+            return result1;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringFormatTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringFormatTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringFormatTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringFormatTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringFormatTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..998969273a5d63935d77865c8761cf508ea1a0a9
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringFormatTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringFormatTest.java)
+run(StringFormatTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/StringGetBytesUnsupportedEncodingExceptionTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/StringGetBytesUnsupportedEncodingExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..a1f735af26ef776aab05636e8a0814c845a5563b
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/StringGetBytesUnsupportedEncodingExceptionTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+public class StringGetBytesUnsupportedEncodingExceptionTest {
+    private static int processResult = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 3; /*STATUS_FAILED*/
+        try {
+            result = StringGetBytesUnsupportedEncodingExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 98) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+    public static int StringGetBytesUnsupportedEncodingExceptionTest_1() {
+        int result1 = 3; /*STATUS_FAILED*/
+        String str1_1 = new String("abc123");
+//        String str1_2 = new String("      ");
+//        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123";
+//        String str2_2 = "      ";
+//        String str2_3 = "abc123";
+        String str2_4 = "";
+//		String str2_5 = null;
+        try {
+            byte[] test1_1 = str1_1.getBytes("asc");
+            processResult -= 10;
+        } catch (UnsupportedEncodingException e1) {
+            processResult--;
+        }
+        return 2;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..5c2bb837520d770eb9e2f363c1cf181cc3641a6c
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringGetBytesUnsupportedEncodingExceptionTest.java)
+run(StringGetBytesUnsupportedEncodingExceptionTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesPatternSyntaxExceptionTest/StringMatchesPatternSyntaxExceptionTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesPatternSyntaxExceptionTest/StringMatchesPatternSyntaxExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..939cdce53911f352bf9e77327cb5cb980f27bb26
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesPatternSyntaxExceptionTest/StringMatchesPatternSyntaxExceptionTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.regex.PatternSyntaxException;
+public class StringMatchesPatternSyntaxExceptionTest {
+    static int processResult = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 3; /*STATUS_FAILED*/
+        try {
+            result = StringMatchesPatternSyntaxExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 98) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+    public static int StringMatchesPatternSyntaxExceptionTest_1() {
+        int result1 = 3; /*STATUS_FAILED*/
+        // IndexOutOfBoundsException - if the index argument is negative or not less than the length of this string.
+        String str1_1 = new String("abc123ABC");
+//        String str1_2 = new String("      ");
+//        String str1_3 = new String("abc123ABC");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123ABC";
+//        String str2_2 = "      ";
+//        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+//		String str2_5 = null;
+        //PatternSyntaxException - if the regular expression's syntax is invalid
+        try {
+            str1_1.matches("\\");
+            processResult -= 10;
+        } catch (PatternSyntaxException e1) {
+            processResult--;
+        }
+        return 2;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesPatternSyntaxExceptionTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesPatternSyntaxExceptionTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesPatternSyntaxExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesPatternSyntaxExceptionTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesPatternSyntaxExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e9a86322ebea6a6607de379fe45e5935311ea5a3
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesPatternSyntaxExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringMatchesPatternSyntaxExceptionTest.java)
+run(StringMatchesPatternSyntaxExceptionTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesTest/StringMatchesTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesTest/StringMatchesTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8e16db8a10ef47f42e6a9a0328e984d860b937ab
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesTest/StringMatchesTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringMatchesTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 3/*STATUS_FAILED*/;
+        try {
+            result = StringMatchesTest_1();
+        } catch(Exception e){
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 2 && processResult == 99){
+            result =0;
+        }
+        return result;
+    }
+    public static int StringMatchesTest_1() {
+        int result1 = 3; /*STATUS_FAILED*/
+        String testCaseID = "StringMatchesTest_1";
+//        System.out.println("========================" + testCaseID);
+        String str1_1 = new String("abc123abc");
+        String str1_2 = new String("      ");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123ABC";
+        String str2_2 = "      ";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        String str2_5 = null;
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+//        test(str2_5);
+        System.out.println("test regular expression");
+        String str3_1 = "abc123ABC";
+        System.out.println(str3_1.matches("[ab][bc][cd]123ABC"));
+        String str4_1 = "abc$123ABC";
+        System.out.println(str4_1.matches("abc\\$123ABC"));
+        String str5_1 = "2018-01-02";
+        System.out.println(str5_1.matches("\\d{4}\\-\\d{1,2}\\-\\d{1,2}"));
+        String str6_1 = "abc123\rABC";
+        System.out.println(str6_1.matches("abc123\\\rABC"));
+        String str7_1 = "abc123ABC";
+        System.out.println(str7_1.matches("^abc123ABC$"));
+        return 2;
+    }
+    private static void test(String str) {
+        System.out.println(str.matches("abc123ABC"));
+        System.out.println(str.matches("bc"));
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..55fc278fd0185b7b1c4684afc9cb12487f501a9e
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesTest/expected.txt
@@ -0,0 +1,25 @@
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+true
+false
+false
+false
+true
+false
+false
+false
+test regular expression
+true
+true
+true
+true
+true
+0
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f08fef2a27d45e79463d977ac190490d3fc84db7
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringMatchesTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringMatchesTest.java)
+run(StringMatchesTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/StringPoolMultiThread.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/StringPoolMultiThread.java
new file mode 100644
index 0000000000000000000000000000000000000000..8976730ec06508e67c6c767116698b5d126d8c00
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/StringPoolMultiThread.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+public class StringPoolMultiThread {
+    static int res = 99;
+    // 3000/thread  48000/16thread   ==> 1000/mapleStringPool
+    static int stringCountForEveryThread=3000;
+    static int threadCount=16;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = StringPoolMultiThread_1();
+        } catch(Exception e){
+            System.out.println(e);
+            StringPoolMultiThread.res = StringPoolMultiThread.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(StringPoolMultiThread.res);
+        if (result == 3 && StringPoolMultiThread.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    public static  int StringPoolMultiThread_1() throws InterruptedException, ExecutionException {
+        int result1 = 4; /*STATUS_FAILED*/
+        int length = StringPoolMultiThread.stringCountForEveryThread;// 3000
+        int threadn = StringPoolMultiThread.threadCount; //16
+        for (int i=0;i<length;i++) {
+            ExecutorService executorService = Executors.newFixedThreadPool(threadn);
+            Object res[] = new Object[threadn];
+            for (int j = 0; j < threadn; j++) {
+                /* 启动线程时会返回一个Future对象,可以通过future对象获取现成的返回值。
+                 * 在执行future.get()时，主线程会堵塞，直至当前future线程返回结果。
+                */
+
+                res[j]=executorService.submit(new ThreadWithCallback(i,j)).get();
+//                System.out.println("============ result in thread: "+res[j]);
+            }
+            executorService.shutdown();
+            while (true) {
+                if (executorService.isTerminated()) {
+                    break;
+                }
+                Thread.sleep(1000);
+            }
+            for (int k = 0; k < threadn-1; k++) {
+//                System.out.println("== return =="+res[k]);
+//                System.out.println("== return =="+res[k+1]);
+                if (res[k] != res[k+1]){
+                    return 10;
+                }else {
+                    continue;
+                }
+            }
+        }
+        StringPoolMultiThread.res = StringPoolMultiThread.res - 2;
+        return 3;//PASS
+    }
+    static class ThreadWithCallback implements Callable {
+        private final int name;
+        private final int count;
+        private String result;
+        public ThreadWithCallback(int count,int name) {
+            this.name = name;
+            this.count =count;
+        }
+        @Override
+        //相当于Thread的run方法
+        public Object call() {
+//            System.out.println("== threadname: "+name+"  == count:"+count + " ==");
+            try {
+                String  s= Integer.toHexString(count);
+                result=s.intern();
+//                System.out.println("== result in run: "+result);
+            } catch (Exception e) {
+                System.out.println(e);
+            }
+            return result;
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/result_figo.log b/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/result_figo.log
new file mode 100644
index 0000000000000000000000000000000000000000..ba33fa491d3de4808f203d6a3a447e30358c8f3f
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/result_figo.log
@@ -0,0 +1 @@
+/home/chenliliu/emui/maple/cll/important/RT0820-runtime-String-StringPoolMultiThread/StringPoolMultiThread.java Failed 3 run check expect 95 or 0
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c95c44d429b79778751e5d95acebb3a0c2e6b10
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringPoolMultiThread/test.cfg
@@ -0,0 +1,2 @@
+compile(StringPoolMultiThread.java)
+run(StringPoolMultiThread)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllPatternSyntaxExceptionTest/StringReplaceAllPatternSyntaxExceptionTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllPatternSyntaxExceptionTest/StringReplaceAllPatternSyntaxExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b5369fc252f2ad705310418b4d4408aabcfd136a
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllPatternSyntaxExceptionTest/StringReplaceAllPatternSyntaxExceptionTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.regex.PatternSyntaxException;
+public class StringReplaceAllPatternSyntaxExceptionTest {
+    static int processResult = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 3; /*STATUS_FAILED*/
+        try {
+            result = StringReplaceAllPatternSyntaxExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 98) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("StringReplaceAllPatternSyntaxExceptionTest.res: " + StringReplaceAllPatternSyntaxExceptionTest.res);
+        return result;
+    }
+    public static int StringReplaceAllPatternSyntaxExceptionTest_1() {
+        int result1 = 3; /*STATUS_FAILED*/
+        String str1_1 = new String("abc123ABC");
+//        String str1_2 = new String("      ");
+//        String str1_3 = new String("abc123ABC");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123ABC";
+//        String str2_2 = "      ";
+//        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+//		String str2_5 = null;
+        //PatternSyntaxException - if the regular expression's syntax is invalid
+        try {
+            str1_1.replaceAll("\\", "@@@");
+            processResult -= 10;
+        } catch (PatternSyntaxException e1) {
+            processResult--;
+        }
+        return 2;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllPatternSyntaxExceptionTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllPatternSyntaxExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllPatternSyntaxExceptionTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllPatternSyntaxExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2c611b8d6546a5e440135ac8644d55ba3fa0d70c
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllPatternSyntaxExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReplaceAllPatternSyntaxExceptionTest.java)
+run(StringReplaceAllPatternSyntaxExceptionTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllTest/StringReplaceAllTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllTest/StringReplaceAllTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..45738be30c7c5dc88beb0dcc6b850e42a360fb41
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllTest/StringReplaceAllTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringReplaceAllTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        run(argv, System.out);
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            StringReplaceAllTest_1();
+        } catch(Exception e){
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 2 && processResult == 99){
+            result =0;
+        }
+        return result;
+    }
+    public static void StringReplaceAllTest_1() {
+        String testCaseID = "StringReplaceAllTest_1";
+        System.out.println("========================" + testCaseID);
+        String str1_1 = new String("abc123abc");
+        String str1_2 = new String("      ");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123ABC";
+        String str2_2 = "      ";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        String str2_5 = null;
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+//        test(str2_5);
+        System.out.println("test add: regular expression");
+        String str3_1 = "abc123ABC-abc123ABC";
+        System.out.println(str3_1.replaceAll("[ab][bc][cd]", "@@@"));
+        String str4_1 = "abc$123ABC-abc$123ABC";
+        System.out.println(str4_1.replaceAll("\\$", "@"));
+        String str5_1 = "2018-01-02-2018-01-02";
+        System.out.println(str5_1.replaceAll("\\d{4}", "@@@@"));
+        String str6_1 = "abc123\rABC-abc123\rABC";
+        System.out.println(str6_1.replaceAll("\\\r", "@"));
+        String str7_1 = "abc123ABC-abc123ABC";
+        System.out.println(str7_1.replaceAll("^abc", "@@@"));
+    }
+    private static void test(String str) {
+        System.out.println(str.replaceAll("a", "@"));
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..315e3de862317a9d6c0042e823d02b7acdb0859c
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllTest/expected.txt
@@ -0,0 +1,16 @@
+========================StringReplaceAllTest_1
+@bc123@bc
+      
+@bc123@bc
+
+
+@bc123ABC
+      
+@bc123ABC
+
+test add: regular expression
+@@@123ABC-@@@123ABC
+abc@123ABC-abc@123ABC
+@@@@-01-02-@@@@-01-02
+abc123@ABC-abc123@ABC
+@@@123ABC-abc123ABC
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f159fc1525ff63c46dd0f434c9ac328dd2fcf93a
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceAllTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReplaceAllTest.java)
+run(StringReplaceAllTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstPatternSyntaxExceptionTest/StringReplaceFirstPatternSyntaxExceptionTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstPatternSyntaxExceptionTest/StringReplaceFirstPatternSyntaxExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..cbf923c3b095df3c75a703ef3041ebf0235d9a5b
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstPatternSyntaxExceptionTest/StringReplaceFirstPatternSyntaxExceptionTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.regex.PatternSyntaxException;
+public class StringReplaceFirstPatternSyntaxExceptionTest {
+    static int processResult = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = StringReplaceFirstPatternSyntaxExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 1 && processResult == 98) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+    public static int StringReplaceFirstPatternSyntaxExceptionTest_1() {
+        int result = 2; /*STATUS_FAILED*/
+        String str1_1 = new String("abc123ABC");
+//        String str1_2 = new String("      ");
+//        String str1_3 = new String("abc123ABC");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123ABC";
+//        String str2_2 = "      ";
+//        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+//		String str2_5 = null;
+        //PatternSyntaxException - if the regular expression's syntax is invalid
+        try {
+            str1_1.replaceFirst("\\", "@@@");
+            processResult -= 10;
+        } catch (PatternSyntaxException e1) {
+            processResult--;
+            return 1;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstPatternSyntaxExceptionTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstPatternSyntaxExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstPatternSyntaxExceptionTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstPatternSyntaxExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..bc88b1d5c41faab77369849779767bc12ca9b329
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstPatternSyntaxExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReplaceFirstPatternSyntaxExceptionTest.java)
+run(StringReplaceFirstPatternSyntaxExceptionTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstTest/StringReplaceFirstTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstTest/StringReplaceFirstTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f39cd466d1124566d3eaa0bcf1cbdd61bcf7c3c
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstTest/StringReplaceFirstTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringReplaceFirstTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        run(argv, System.out);
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            StringReplaceFirstTest_1();
+        } catch(Exception e){
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 1 && processResult == 99){
+            result =0;
+        }
+        return result;
+    }
+    public static void StringReplaceFirstTest_1() {
+        String testCaseID = "StringReplaceFirstTest_1";
+        System.out.println("========================" + testCaseID);
+        String str1_1 = new String("abc123abc");
+        String str1_2 = new String("      ");
+        String str1_3 = new String("abc123abc");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123ABC";
+        String str2_2 = "      ";
+        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+        String str2_5 = null;
+        test(str1_1);
+        test(str1_2);
+        test(str1_3);
+        test(str1_4);
+        test(str1_5);
+        test(str2_1);
+        test(str2_2);
+        test(str2_3);
+        test(str2_4);
+//        test(str2_5);
+        System.out.println("test add: regular expression");
+        String str3_1 = "abc123ABC-abc123ABC";
+        System.out.println(str3_1.replaceFirst("[ab][bc][cd]", "@@@"));
+        String str4_1 = "abc$123ABC-abc$123ABC";
+        System.out.println(str4_1.replaceFirst("\\$", "@"));
+        String str5_1 = "2018-01-02-2018-01-02";
+        System.out.println(str5_1.replaceFirst("\\d{4}", "@@@@"));
+        String str6_1 = "abc123\rABC-abc123\\rABC";
+        System.out.println(str6_1.replaceFirst("\\\r", "@"));
+        String str7_1 = "abc123ABC-abc123ABC";
+        System.out.println(str7_1.replaceFirst("^abc", "@@@"));
+    }
+    private static void test(String str) {
+        System.out.println(str.replaceFirst("a", "@"));
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..0153449402c44e7472173421ff741c1dcd81d582
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstTest/expected.txt
@@ -0,0 +1,16 @@
+========================StringReplaceFirstTest_1
+@bc123abc
+      
+@bc123abc
+
+
+@bc123ABC
+      
+@bc123ABC
+
+test add: regular expression
+@@@123ABC-abc123ABC
+abc@123ABC-abc$123ABC
+@@@@-01-02-2018-01-02
+abc123@ABC-abc123\rABC
+@@@123ABC-abc123ABC
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8b78e92729bda6554c0b7e169d2196ef58a1a979
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringReplaceFirstTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReplaceFirstTest.java)
+run(StringReplaceFirstTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringSplitPatternSyntaxExceptionTest/StringSplitPatternSyntaxExceptionTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringSplitPatternSyntaxExceptionTest/StringSplitPatternSyntaxExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..93ed147f36e0ae4db3087a63707236e45b3968f1
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringSplitPatternSyntaxExceptionTest/StringSplitPatternSyntaxExceptionTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.charset.Charset;
+import java.util.regex.PatternSyntaxException;
+public class StringSplitPatternSyntaxExceptionTest {
+    private static int processResult = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = StringSplitPatternSyntaxExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 97) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+    public static int StringSplitPatternSyntaxExceptionTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        String str1_1 = new String("abc123ABC");
+//        String str1_2 = new String("      ");
+//        String str1_3 = new String("abc123ABC");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123ABC";
+//        String str2_2 = "      ";
+//        String str2_3 = "abc123ABC";
+        String str2_4 = "";
+//		String str2_5 = null;
+        //PatternSyntaxException - if the regular expression's syntax is invalid
+        try {
+            String[] str = str1_1.split("\\", 3);
+            processResult -= 10;
+        } catch (PatternSyntaxException e1) {
+            processResult--;
+        }
+        try {
+            String[] str = str1_1.split("\\");
+            processResult -= 10;
+        } catch (PatternSyntaxException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringSplitPatternSyntaxExceptionTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringSplitPatternSyntaxExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringSplitPatternSyntaxExceptionTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringSplitPatternSyntaxExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..63a824b7a1108629ea9ea2468f61bde88675a417
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringSplitPatternSyntaxExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringSplitPatternSyntaxExceptionTest.java)
+run(StringSplitPatternSyntaxExceptionTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/StringStringIndexOutOfBoundsExceptionTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/StringStringIndexOutOfBoundsExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..8b93a8da7c750dd61bdf73a7d73eafb716473c9e
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/StringStringIndexOutOfBoundsExceptionTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+public class StringStringIndexOutOfBoundsExceptionTest {
+    private static int processResult = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = StringStringIndexOutOfBoundsExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 96) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+    public static int StringStringIndexOutOfBoundsExceptionTest_1() throws UnsupportedEncodingException {
+        int result = 4; /*STATUS_FAILED*/
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, 0, 3, "ASC");
+            processResult -= 10;
+        } catch (UnsupportedEncodingException e1) {
+            processResult--;
+        }
+        try {
+            String str2 = new String(str1_1, -1, 3, "ASCII");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult -= 1;
+        }
+        try {
+            String str3 = new String(str1_1, 0, 8, "ASCII");
+            processResult -= 10;
+        } catch (StringIndexOutOfBoundsException e1) {
+            processResult--;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..bb92b6451fc0bfa5d0eaae8ca9f937cb4a654d27
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringStringIndexOutOfBoundsExceptionTest.java)
+run(StringStringIndexOutOfBoundsExceptionTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/.idea/misc.xml b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/.idea/misc.xml
new file mode 100755
index 0000000000000000000000000000000000000000..e208459b8afde5f7980720efd6bbb97f7ae24541
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/.idea/misc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/.idea/workspace.xml b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/.idea/workspace.xml
new file mode 100755
index 0000000000000000000000000000000000000000..a19d10b39530fdb6b17483be724e42685047f80b
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/.idea/workspace.xml
@@ -0,0 +1,313 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="ba240762-d16b-4fd0-835b-9304b586b120" name="Default" comment="" />
+    <ignored path="$PROJECT_DIR$/out/" />
+    <option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
+    <option name="TRACKING_ENABLED" value="true" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="GradleLocalSettings">
+    <option name="externalProjectsViewState">
+      <projects_view />
+    </option>
+  </component>
+  <component name="ProjectFrameBounds" extendedState="6">
+    <option name="x" value="1912" />
+    <option name="y" value="-8" />
+    <option name="width" value="1918" />
+    <option name="height" value="1078" />
+  </component>
+  <component name="ProjectView">
+    <navigator currentView="ProjectPane" proportions="" version="1">
+      <flattenPackages />
+      <showMembers />
+      <showModules />
+      <showLibraryContents />
+      <hideEmptyPackages />
+      <abbreviatePackageNames />
+      <autoscrollToSource />
+      <autoscrollFromSource />
+      <sortByType />
+      <manualOrder />
+      <foldersAlwaysOnTop value="true" />
+    </navigator>
+    <panes>
+      <pane id="Scope" />
+      <pane id="AndroidView" />
+      <pane id="PackagesPane" />
+      <pane id="Scratches" />
+      <pane id="ProjectPane">
+        <subPane>
+          <expand>
+            <path>
+              <item name="issue-0000-rt-String-StringExp05010" type="b2602c69:ProjectViewProjectNode" />
+              <item name="issue-0000-rt-String-StringExp05010" type="462c0819:PsiDirectoryNode" />
+            </path>
+            <path>
+              <item name="issue-0000-rt-String-StringExp05010" type="b2602c69:ProjectViewProjectNode" />
+              <item name="issue-0000-rt-String-StringExp05010" type="462c0819:PsiDirectoryNode" />
+              <item name=".idea" type="462c0819:PsiDirectoryNode" />
+            </path>
+          </expand>
+          <select />
+        </subPane>
+      </pane>
+    </panes>
+  </component>
+  <component name="PropertiesComponent">
+    <property name="settings.editor.selected.configurable" value="configurable.group.appearance" />
+    <property name="project.structure.last.edited" value="Modules" />
+    <property name="project.structure.proportion" value="0.15" />
+    <property name="project.structure.side.proportion" value="0.2" />
+  </component>
+  <component name="RunDashboard">
+    <option name="ruleStates">
+      <list>
+        <RuleState>
+          <option name="name" value="ConfigurationTypeDashboardGroupingRule" />
+        </RuleState>
+        <RuleState>
+          <option name="name" value="StatusDashboardGroupingRule" />
+        </RuleState>
+      </list>
+    </option>
+  </component>
+  <component name="RunManager">
+    <configuration default="true" type="Applet" factoryName="Applet">
+      <option name="HTML_USED" value="false" />
+      <option name="WIDTH" value="400" />
+      <option name="HEIGHT" value="300" />
+      <option name="POLICY_FILE" value="$APPLICATION_HOME_DIR$/bin/appletviewer.policy" />
+      <module />
+    </configuration>
+    <configuration default="true" type="Application" factoryName="Application">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <option name="MAIN_CLASS_NAME" />
+      <option name="VM_PARAMETERS" />
+      <option name="PROGRAM_PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="ENABLE_SWING_INSPECTOR" value="false" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <module name="" />
+      <envs />
+    </configuration>
+    <configuration default="true" type="JUnit" factoryName="JUnit">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <module name="" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="PACKAGE_NAME" />
+      <option name="MAIN_CLASS_NAME" />
+      <option name="METHOD_NAME" />
+      <option name="TEST_OBJECT" value="class" />
+      <option name="VM_PARAMETERS" value="-ea" />
+      <option name="PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="%MODULE_WORKING_DIR%" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <option name="TEST_SEARCH_SCOPE">
+        <value defaultName="singleModule" />
+      </option>
+      <envs />
+      <patterns />
+    </configuration>
+    <configuration default="true" type="JetRunConfigurationType" factoryName="Kotlin">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <option name="MAIN_CLASS_NAME" />
+      <option name="VM_PARAMETERS" />
+      <option name="PROGRAM_PARAMETERS" />
+      <option name="WORKING_DIRECTORY" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <module name="issue-0000-rt-String-StringExp05010" />
+      <envs />
+    </configuration>
+    <configuration default="true" type="Remote" factoryName="Remote">
+      <option name="USE_SOCKET_TRANSPORT" value="true" />
+      <option name="SERVER_MODE" value="false" />
+      <option name="SHMEM_ADDRESS" value="javadebug" />
+      <option name="HOST" value="localhost" />
+      <option name="PORT" value="5005" />
+    </configuration>
+    <configuration default="true" type="TestNG" factoryName="TestNG">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <module name="" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="SUITE_NAME" />
+      <option name="PACKAGE_NAME" />
+      <option name="MAIN_CLASS_NAME" />
+      <option name="METHOD_NAME" />
+      <option name="GROUP_NAME" />
+      <option name="TEST_OBJECT" value="CLASS" />
+      <option name="VM_PARAMETERS" value="-ea" />
+      <option name="PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="%MODULE_WORKING_DIR%" />
+      <option name="OUTPUT_DIRECTORY" />
+      <option name="ANNOTATION_TYPE" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <option name="TEST_SEARCH_SCOPE">
+        <value defaultName="singleModule" />
+      </option>
+      <option name="USE_DEFAULT_REPORTERS" value="false" />
+      <option name="PROPERTIES_FILE" />
+      <envs />
+      <properties />
+      <listeners />
+    </configuration>
+    <configuration default="true" type="#org.jetbrains.idea.devkit.run.PluginConfigurationType" factoryName="Plugin">
+      <module name="" />
+      <option name="VM_PARAMETERS" value="-Xmx512m -Xms256m -XX:MaxPermSize=250m -ea" />
+      <option name="PROGRAM_PARAMETERS" />
+      <predefined_log_file id="idea.log" enabled="true" />
+    </configuration>
+  </component>
+  <component name="ShelveChangesManager" show_recycled="false">
+    <option name="remove_strategy" value="false" />
+  </component>
+  <component name="SvnConfiguration">
+    <configuration />
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="ba240762-d16b-4fd0-835b-9304b586b120" name="Default" comment="" />
+      <created>1557819782541</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1557819782541</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="ToolWindowManager">
+    <frame x="1912" y="-8" width="1936" height="1096" extended-state="6" />
+    <layout>
+      <window_info id="Palette" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="TODO" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="6" side_tool="false" content_ui="tabs" />
+      <window_info id="Palette&#9;" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Image Layers" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Capture Analysis" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Event Log" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="true" content_ui="tabs" />
+      <window_info id="Maven Projects" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Run" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
+      <window_info id="Version Control" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="false" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Terminal" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Capture Tool" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Designer" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Project" active="true" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="true" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="0" side_tool="false" content_ui="combo" />
+      <window_info id="Structure" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
+      <window_info id="Ant Build" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
+      <window_info id="UI Designer" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Theme Preview" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Debug" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
+      <window_info id="Favorites" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="true" content_ui="tabs" />
+      <window_info id="Cvs" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="4" side_tool="false" content_ui="tabs" />
+      <window_info id="Hierarchy" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="2" side_tool="false" content_ui="combo" />
+      <window_info id="Message" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
+      <window_info id="Commander" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
+      <window_info id="Find" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
+      <window_info id="Inspection" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="5" side_tool="false" content_ui="tabs" />
+    </layout>
+  </component>
+  <component name="VcsContentAnnotationSettings">
+    <option name="myLimit" value="2678400000" />
+  </component>
+  <component name="XDebuggerManager">
+    <breakpoint-manager />
+    <watches-manager />
+  </component>
+  <component name="masterDetails">
+    <states>
+      <state key="ArtifactsStructureConfigurable.UI">
+        <settings>
+          <artifact-editor />
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="FacetStructureConfigurable.UI">
+        <settings>
+          <last-edited>No facets are configured</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="GlobalLibrariesConfigurable.UI">
+        <settings>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="JdkListConfigurable.UI">
+        <settings>
+          <last-edited>1.8</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="ModuleStructureConfigurable.UI">
+        <settings>
+          <last-edited>issue-0000-rt-String-StringExp05010</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="ProjectJDKs.UI">
+        <settings>
+          <last-edited>1.8</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="ProjectLibrariesConfigurable.UI">
+        <settings>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+    </states>
+  </component>
+</project>
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/StringUnsupportedEncodingExceptionTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/StringUnsupportedEncodingExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..60455ca053a90b35f93383d98fcb19ac213befb8
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/StringUnsupportedEncodingExceptionTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+public class StringUnsupportedEncodingExceptionTest {
+    private static int processResult = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = StringUnsupportedEncodingExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 98) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+    public static int StringUnsupportedEncodingExceptionTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        //UnsupportedEncodingException - If the named charset is not supported
+        //
+        // byte[] str1_1 = new byte[]{(byte)0x61, (byte)0x62, (byte)0x63, (byte)0x31, (byte)0x32, (byte)0x33};
+        //char[] str1_1 = {'a','b','c','1','2','3'};
+        //int[] str1_2 = new int[]{0x61,0x62,0x63,0x31,0x32,0x33};
+        //int[] str1_1 = new int[]{97,98,99,49,50,51};
+        byte[] str1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        try {
+            String str1 = new String(str1_1, "ASC");
+            processResult -= 10;
+        } catch (UnsupportedEncodingException e1) {
+            processResult--;
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..2958fe2733e16f822140dfabcbd91557c5fdfc42
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUnsupportedEncodingExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringUnsupportedEncodingExceptionTest.java)
+run(StringUnsupportedEncodingExceptionTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseCharsetTest/StringUserCaseCharsetTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseCharsetTest/StringUserCaseCharsetTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ea339ecd37d6a8ad4e499b8882047a566ad13b86
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseCharsetTest/StringUserCaseCharsetTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.nio.charset.Charset;
+public class StringUserCaseCharsetTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        run(argv, System.out);
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            StringUserCaseCharsetTest_1();
+        } catch(Exception e){
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 1 && processResult == 99){
+            result =0;
+        }
+        return result;
+    }
+    public static void StringUserCaseCharsetTest_1() {
+        String testCaseID = "StringUserCaseCharsetTest_1";
+        System.out.println("========================" + testCaseID);
+        // abc   ASCII
+        byte[] abc_ASCII = {(byte) 0x61, (byte) 0x62, (byte) 0x63};
+        // abc   ISO88591
+        byte[] abc_ISO88591 = {(byte) 0x61, (byte) 0x62, (byte) 0x63};
+        // abc   UTF8
+        byte[] abc_UTF8 = {(byte) 0x61, (byte) 0x62, (byte) 0x63};
+        // abc   UTF16BE
+        byte[] abc_UTF16BE = {(byte) 0x00, (byte) 0x61, (byte) 0x00, (byte) 0x62, (byte) 0x00, (byte) 0x63};
+        // abc   UTF16LE
+        byte[] abc_UTF16LE = {(byte) 0x61, (byte) 0x00, (byte) 0x62, (byte) 0x00, (byte) 0x63, (byte) 0x00};
+        // abc   UTF16
+        byte[] abc_UTF16 = {(byte) 0x00, (byte) 0x61, (byte) 0x00, (byte) 0x62, (byte) 0x00, (byte) 0x63};
+        // abc   GBK
+        byte[] abc_GBK = {(byte) 0x61, (byte) 0x62, (byte) 0x63};
+        // abc unicode
+        byte[] abc_unicode = {(byte) 0x00, (byte) 0x61, (byte) 0x00, (byte) 0x62, (byte) 0x00, (byte) 0x63};
+        test1(abc_ASCII, "ASCII");
+        test1(abc_ISO88591, "ISO-8859-1");
+        test1(abc_UTF8, "UTF-8");
+        test1(abc_UTF16BE, "UTF-16BE");
+        test1(abc_UTF16LE, "UTF-16LE");
+        test1(abc_UTF16, "UTF-16");
+        test1(abc_GBK, "GBK");
+        test1(abc_unicode, "unicode");
+        System.out.println(test1(abc_ASCII, "ASCII") + test1(abc_ISO88591, "ISO-8859-1")
+                + test1(abc_UTF8, "UTF-8") + test1(abc_UTF16BE, "UTF-16BE") + test1(abc_UTF16LE, "UTF-16LE")
+                + test1(abc_UTF16, "UTF-16") + test1(abc_GBK, "GBK") + test1(abc_unicode, "unicode"));
+        // SIMPLE CHINESE
+        byte[] zg_unicode = {(byte) 0x4E, (byte) 0x2D, (byte) 0x56, (byte) 0xFD};
+        byte[] zg_UTF8 = {(byte) 0xE4, (byte) 0xB8, (byte) 0xAD, (byte) 0xE5, (byte) 0x9B, (byte) 0xBD};
+        byte[] zg_UTF16BE = {(byte) 0x4E, (byte) 0x2D, (byte) 0x56, (byte) 0xFD};
+        byte[] zg_UTF16LE = {(byte) 0x2D, (byte) 0x4E, (byte) 0xFD, (byte) 0x56};
+        byte[] zg_UTF16 = {(byte) 0x4E, (byte) 0x2D, (byte) 0x56, (byte) 0xFD};
+        byte[] zg_GBK = {(byte) 0xD6, (byte) 0xD0, (byte) 0xB9, (byte) 0xFA};
+        test1(zg_UTF8, "UTF-8");
+        test1(zg_UTF16BE, "UTF-16BE");
+        test1(zg_UTF16LE, "UTF-16LE");
+        test1(zg_UTF16, "UTF-16");
+        test1(zg_GBK, "GBK");
+        test1(zg_unicode, "unicode");
+        System.out.println(test1(zg_UTF8, "UTF-8") + test1(zg_UTF16BE, "UTF-16BE")
+                + test1(zg_UTF16LE, "UTF-16LE") + test1(zg_UTF16, "UTF-16") + test1(zg_GBK, "GBK")
+                + test1(zg_unicode, "unicode"));
+    }
+    private static String test1(byte[] by, String str) {
+        String result = new String(by, Charset.forName(str));
+        System.out.println(result);
+        return result;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseCharsetTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseCharsetTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c66542f678ec549392feea83c9a001b27f2d7dce
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseCharsetTest/expected.txt
@@ -0,0 +1,31 @@
+========================StringUserCaseCharsetTest_1
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abc
+abcabcabcabcabcabcabcabc
+中国
+中国
+中国
+中国
+中国
+中国
+中国
+中国
+中国
+中国
+中国
+中国
+中国中国中国中国中国中国
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseCharsetTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseCharsetTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..ff7079c007f4ab2c2ac08f4188030af2c57174f4
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseCharsetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringUserCaseCharsetTest.java)
+run(StringUserCaseCharsetTest)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/StringUserCaseLiteralsISO88591Test.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/StringUserCaseLiteralsISO88591Test.java
new file mode 100755
index 0000000000000000000000000000000000000000..6b10d7d652de3c346748c83f46ef78cdff3b937d
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/StringUserCaseLiteralsISO88591Test.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+public class StringUserCaseLiteralsISO88591Test {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        run(argv, System.out);
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            StringUserCaseLiteralsISO88591Test_1();
+        } catch(Exception e){
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 1 && processResult == 99){
+            result =0;
+        }
+        return result;
+    }
+    public static void StringUserCaseLiteralsISO88591Test_1() throws UnsupportedEncodingException {
+        String testCaseID = "StringUserCaseLiteralsISO88591Test_1";
+        System.out.println("========================" + testCaseID);
+        //0x00~0x7F
+        String str1_1 = "a b^c~AB";
+        //10
+        char data1_2[] = {97, 32, 98, 94, 99, 126, 65, 66};
+        String str1_2 = new String(data1_2);
+        //16
+//		char data1_3[] = {0x61,0x20, 0x62, 0x5E, 0x63, 0x7E,0x00, 0x41, 0x42, 0x43,0x7F};
+        char data1_3[] = {0x61, 0x20, 0x62, 0x5E, 0x63, 0x7E, 0x41, 0x42};
+        String str1_3 = new String(data1_3);
+//		//0x80~0xFF
+        String str2_1 = "jag ls dig";
+//		//16 ISO-8859-1 0x80undefinit ,
+        char data2_3[] = {0x80, 0xC5, 0xFF, 0xD7, 0xF7};
+        String str2_3 = new String(data2_3);
+        byte[] data2_4 = {(byte) 0x80, (byte) 0xC5, (byte) 0xFF, (byte) 0xD7, (byte) 0xF7};
+        String str2_4 = new String(data2_4, Charset.forName("iso-8859-1"));
+        byte[] testb = str2_1.getBytes("ISO-8859-1");
+        String tests = new String(testb, "ISO-8859-1");
+        test1(tests);
+    }
+    private static void test1(String str) {
+        System.out.println(str);
+//		for (int i=0;i< str.length() ; i++) {
+//			char ch = str.charAt(i);
+////			System.out.print("char: " + ch + " unicode: ");
+//			System.out.println(Integer.toHexString(ch));
+//					
+//		}
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..ed1b9116ac4fdad8e8b96f1c8b77936527522f6b
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/expected.txt
@@ -0,0 +1,2 @@
+========================StringUserCaseLiteralsISO88591Test_1
+jag ls dig
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7127fc6f5c8ad585abab95a7ea527265ccaae4f9
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLiteralsISO88591Test/test.cfg
@@ -0,0 +1,2 @@
+compile(StringUserCaseLiteralsISO88591Test.java)
+run(StringUserCaseLiteralsISO88591Test)
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLongToStringTest/StringUserCaseLongToStringTest.java b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLongToStringTest/StringUserCaseLongToStringTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..72106225468be58580cf89f4ba3c3d8c48daa112
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLongToStringTest/StringUserCaseLongToStringTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringUserCaseLongToStringTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        run(argv, System.out);
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            StringUserCaseLongToStringTest_1();
+            StringUserCaseLongToStringTest_2();
+            StringUserCaseLongToStringTest_3();
+            StringUserCaseLongToStringTest_4();
+        } catch(Exception e){
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        if (result == 1 && processResult == 99){
+            result =0;
+        }
+        return result;
+    }
+    //		1.Long.toHexString(long l)
+    public static void StringUserCaseLongToStringTest_1() {
+        String testCaseID = "StringUserCaseLongToStringTest_1";
+        System.out.println("========================" + testCaseID);
+        long l_a = 0;
+        long l_b = 111;
+        long l_c = 2147483647;
+        test1(l_a);
+        test1(l_b);
+        test1(l_c);
+    }
+    public static void StringUserCaseLongToStringTest_2() {
+        String testCaseID = "StringUserCaseLongToStringTest_2";
+        System.out.println("========================" + testCaseID);
+        Integer i_a = 0;
+        Integer i_b = 111;
+        Integer i_c = 2147483647;
+        test2(i_a);
+        test2(i_b);
+        test2(i_c);
+    }
+    public static void StringUserCaseLongToStringTest_3() {
+        String testCaseID = "StringUserCaseLongToStringTest_3";
+        System.out.println("========================" + testCaseID);
+        float f_a = 0f;
+        float f_b = 11.1f;
+        float f_c = 2147483.647f;
+        test3(f_a);
+        test3(f_b);
+        test3(f_c);
+    }
+    public static void StringUserCaseLongToStringTest_4() {
+        String testCaseID = "StringUserCaseLongToStringTest_4";
+        System.out.println("========================" + testCaseID);
+        double d_a = 0;
+        double d_b = 1.11d;
+        double d_c = 21474836.47;
+        test4(d_a);
+        test4(d_b);
+        test4(d_c);
+    }
+    private static void test1(Long lo) {
+        System.out.println(Long.toHexString(lo));
+    }
+    private static void test2(Integer i) {
+        System.out.println(Integer.toHexString(i));
+    }
+    private static void test3(float f) {
+        System.out.println(Float.toHexString(f));
+    }
+    private static void test4(double f) {
+        System.out.println(Double.toHexString(f));
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLongToStringTest/expected.txt b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLongToStringTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..1809d35da8aa9e6782a7e69dfb28fa60c330df88
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLongToStringTest/expected.txt
@@ -0,0 +1,16 @@
+========================StringUserCaseLongToStringTest_1
+0
+6f
+7fffffff
+========================StringUserCaseLongToStringTest_2
+0
+6f
+7fffffff
+========================StringUserCaseLongToStringTest_3
+0x0.0p0
+0x1.633334p3
+0x1.0624dep21
+========================StringUserCaseLongToStringTest_4
+0x0.0p0
+0x1.1c28f5c28f5c3p0
+0x1.47ae147851eb8p24
diff --git a/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLongToStringTest/test.cfg b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLongToStringTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f66c4a3369383ec07b6f0a68e5db9380f55f01bb
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-0000-rt-String-StringUserCaseLongToStringTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringUserCaseLongToStringTest.java)
+run(StringUserCaseLongToStringTest)
diff --git a/testsuite/java_test/string_test/issue-RT0153-rt-string-StringEqualsNull0002n-DTS2020052106893/TestStringEqualsNull.java b/testsuite/java_test/string_test/issue-RT0153-rt-string-StringEqualsNull0002n-DTS2020052106893/TestStringEqualsNull.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed16c4d73e98b383e2c8cf6286e9d9abf0ec3572
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0153-rt-string-StringEqualsNull0002n-DTS2020052106893/TestStringEqualsNull.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+public class TestStringEqualsNull {
+    public static void main(String args[]) throws Exception {
+        StringEqualsNull test = new StringEqualsNull();
+        test.resultEqualsNull();
+    }
+}
+class StringEqualsNull {
+    private final String[] nullStrings = new String[]{null};
+    public void resultEqualsNull() {
+        int result = 1; /* STATUS_FAILED*/
+
+        try {
+            System.out.println(nullStrings[0].equals(null));
+        } catch (Exception e) {
+            StringWriter sw = new StringWriter();
+            PrintWriter pw = new PrintWriter(sw);
+            e.printStackTrace(pw);
+            String msg = sw.toString();
+            if (msg.contains("java.lang.NullPointerException")) {
+                result--;
+            }
+            System.out.println(result);
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-RT0153-rt-string-StringEqualsNull0002n-DTS2020052106893/expected.txt b/testsuite/java_test/string_test/issue-RT0153-rt-string-StringEqualsNull0002n-DTS2020052106893/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0153-rt-string-StringEqualsNull0002n-DTS2020052106893/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-RT0153-rt-string-StringEqualsNull0002n-DTS2020052106893/test.cfg b/testsuite/java_test/string_test/issue-RT0153-rt-string-StringEqualsNull0002n-DTS2020052106893/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d438535e55bdd314c0214bf3f804d5a447e02b61
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0153-rt-string-StringEqualsNull0002n-DTS2020052106893/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsNull)
+run(TestStringEqualsNull)
diff --git a/testsuite/java_test/string_test/issue-RT0162-rt-string-StringEqualsCompress-Phone/TestStringEqualsCompress.java b/testsuite/java_test/string_test/issue-RT0162-rt-string-StringEqualsCompress-Phone/TestStringEqualsCompress.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f47db68690d39ed879735dbcd76eea0cbce1594
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0162-rt-string-StringEqualsCompress-Phone/TestStringEqualsCompress.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+public class TestStringEqualsCompress {
+    static String code = "UTF-8";
+    public static String compress(String str) throws IOException {
+        if (str == null || str.length() == 0) {
+            return str;
+        }
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        GZIPOutputStream gzip = new GZIPOutputStream(out);
+        gzip.write(str.getBytes());
+        gzip.close();
+        return out.toString("ISO-8859-1");
+    }
+    public static String uncompress(String str) throws IOException {
+        if (str == null || str.length() == 0) {
+            return str;
+        }
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        ByteArrayInputStream in = new ByteArrayInputStream(str.getBytes("ISO-8859-1"));
+        GZIPInputStream gunzip = new GZIPInputStream(in);
+        byte[] buffer = new byte[256];
+        int n;
+        while ((n = gunzip.read(buffer)) >= 0) {
+            out.write(buffer, 0, n);
+        }
+        return out.toString();
+    }
+    public static void main(String[] args) throws IOException {
+        String longStrings = "Ahead-of-time compilation is possible as the compiler may just"
+                + "convert an instruction thus: dex code: add-int v1000, v2000, v3000 C code: setIntRegter"
+                + "(1000, call_dex_add_int(getIntRegister(2000), getIntRegister(3000)) This means even lid"
+                + "instructions may have code generated, however, it is not expected that code generate in"
+                + "this way will perform well. The job of AOT verification is to tell the compiler that"
+                + "instructions are sound and provide tests to detect unsound sequences so slow path code"
+                + "may be generated. Other than for totally invalid code, the verification may fail at AOr"
+                + "run-time. At AOT time it can be because of incomplete information, at run-time it can e"
+                + "that code in a different apk that the application depends upon has changed. The Dalvik"
+                + "verifier would return a bool to state whether a Class were good or bad. In ART the fail"
+                + "case becomes either a soft or hard failure. Classes have new states to represent that a"
+                + "soft failure occurred at compile time and should be re-verified at run-time.";
+        String zip = TestStringEqualsCompress.compress(longStrings);
+        String unzip = TestStringEqualsCompress.uncompress(TestStringEqualsCompress.compress(longStrings));
+        System.out.println(unzip.equals(longStrings));
+        System.out.println(zip.equals(longStrings));
+        System.out.println(unzip.equals(zip));
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-RT0162-rt-string-StringEqualsCompress-Phone/expected.txt b/testsuite/java_test/string_test/issue-RT0162-rt-string-StringEqualsCompress-Phone/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..36bc6136b8bf401f53cd1d67f1c27ac466778ec5
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0162-rt-string-StringEqualsCompress-Phone/expected.txt
@@ -0,0 +1,3 @@
+true
+false
+false
diff --git a/testsuite/java_test/string_test/issue-RT0162-rt-string-StringEqualsCompress-Phone/test.cfg b/testsuite/java_test/string_test/issue-RT0162-rt-string-StringEqualsCompress-Phone/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..69c833c78ba41422592302a28e1a749c723504a8
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0162-rt-string-StringEqualsCompress-Phone/test.cfg
@@ -0,0 +1,2 @@
+compile(TestStringEqualsCompress)
+run(TestStringEqualsCompress)
diff --git a/testsuite/java_test/string_test/issue-RT0237-rt-String-StringFormatIllegalFormatExceptionTest/StringFormatIllegalFormatExceptionTest.java b/testsuite/java_test/string_test/issue-RT0237-rt-String-StringFormatIllegalFormatExceptionTest/StringFormatIllegalFormatExceptionTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..5963df95ab4238921ed8aadab84f9d491e5f7a91
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0237-rt-String-StringFormatIllegalFormatExceptionTest/StringFormatIllegalFormatExceptionTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.util.IllegalFormatException;
+import java.util.Locale;
+public class StringFormatIllegalFormatExceptionTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2; /*STATUS_FAILED*/
+        try {
+            result = StringFormatIllegalFormatExceptionTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 4 && processResult == 96) {
+            result = 0;
+        }
+//        System.out.println("result: " + result);
+//        System.out.println("processResult:" + processResult);
+        return result;
+    }
+    public static int StringFormatIllegalFormatExceptionTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        ;
+//
+        String str1_1 = new String("abc123ABC");
+//        String str1_2 = new String("      ");
+//        String str1_3 = new String("abc123ABC");
+//        String str1_4 = new String("");
+//        String str1_5 = new String();
+//
+//        String str2_1 = "abc123ABC";
+//        String str2_2 = "      ";
+//        String str2_3 = "abc123ABC";
+//        String str2_4 = "";
+//        String str2_5 = null;
+        //IllegalFormatException - If a format string contains an illegal syntax,
+        // a format specifier that is incompatible with the given arguments, insufficient arguments given the format string,
+        // or other illegal conditions.
+        // For specification of all possible formatting errors, see the Details section of the formatter class specification.
+        try {
+//            String str1 =String.format("%c %n", 'A');
+            String str1 = String.format("%p %n", 'A');
+            processResult -= 10;
+        } catch (IllegalFormatException e1) {
+            processResult--;
+//            System.out.println("1-1");
+        }
+        try {
+//            String str1 = String.format("%b %n", 3>7);
+            String str1 = String.format("%p %n", 3 > 7);
+            processResult -= 10;
+        } catch (IllegalFormatException e1) {
+            processResult--;
+//            System.out.println("1-2");
+        }
+        try {
+//            String str1=String.format(Locale.ENGLISH,"%c %n", 'A');
+            String str1 = String.format(Locale.ENGLISH, "%p %n", 'A');
+            processResult -= 10;
+        } catch (IllegalFormatException e1) {
+            processResult--;
+//            System.out.println("1-3");
+        }
+        return result1;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-RT0237-rt-String-StringFormatIllegalFormatExceptionTest/expected.txt b/testsuite/java_test/string_test/issue-RT0237-rt-String-StringFormatIllegalFormatExceptionTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0237-rt-String-StringFormatIllegalFormatExceptionTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-RT0237-rt-String-StringFormatIllegalFormatExceptionTest/test.cfg b/testsuite/java_test/string_test/issue-RT0237-rt-String-StringFormatIllegalFormatExceptionTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..fe8ee95ca212945baacfb4505aac676ccaa77b5f
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0237-rt-String-StringFormatIllegalFormatExceptionTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringFormatIllegalFormatExceptionTest.java)
+run(StringFormatIllegalFormatExceptionTest)
diff --git a/testsuite/java_test/string_test/issue-RT0246-rt-String-StringConsBytesIntIntIntAndBytesTest/StringConsBytesIntIntIntAndBytesTest.java b/testsuite/java_test/string_test/issue-RT0246-rt-String-StringConsBytesIntIntIntAndBytesTest/StringConsBytesIntIntIntAndBytesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a9af6d04f73de83c18cc21534555ce57ab2134d6
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0246-rt-String-StringConsBytesIntIntIntAndBytesTest/StringConsBytesIntIntIntAndBytesTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringConsBytesIntIntIntAndBytesTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String[] argv, PrintStream out) {
+        int result = 2; /* STATUS_Success*/
+
+        try {
+            StringConsBytesIntIntIntAndBytesTest_1();
+            StringConsBytesIntIntIntAndBytesTest_2();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+        if (result == 2 && processResult == 99) {
+            result = 0;
+        }
+        return result;
+    }
+    // Test constructor String(byte[] ascii, int hibyte, int offset, int count).
+    public static void StringConsBytesIntIntIntAndBytesTest_1() {
+        byte[] ascii1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str1 = new String(ascii1_1, 0, 0, 2);
+        String str1_1 = new String(ascii1_1, 0, 0, 6);
+        String str1_2 = new String(ascii1_1, 0, 0, 0);
+        String str1_3 = new String(ascii1_1, 0, 5, 1);
+        String str1_4 = new String(ascii1_1, 1, 5, 1);
+        System.out.println(str1);
+        System.out.println(str1_1);
+        System.out.println(str1_2);
+        System.out.println(str1_3);
+        System.out.println(str1_4);
+    }
+    // Test constructor String(byte[] bytes).
+    public static void StringConsBytesIntIntIntAndBytesTest_2() {
+        byte[] ascii1_1 = new byte[]{(byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x31, (byte) 0x32, (byte) 0x33};
+        String str0 = new String(ascii1_1);
+        System.out.println(str0);
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-RT0246-rt-String-StringConsBytesIntIntIntAndBytesTest/expected.txt b/testsuite/java_test/string_test/issue-RT0246-rt-String-StringConsBytesIntIntIntAndBytesTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9688482fd349e3dfcdc0fd0a53064537b9819a64
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0246-rt-String-StringConsBytesIntIntIntAndBytesTest/expected.txt
@@ -0,0 +1,7 @@
+ab
+abc123
+
+3
+ij
+abc123
+0
diff --git a/testsuite/java_test/string_test/issue-RT0246-rt-String-StringConsBytesIntIntIntAndBytesTest/test.cfg b/testsuite/java_test/string_test/issue-RT0246-rt-String-StringConsBytesIntIntIntAndBytesTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..54ed373d8a66aaebb4dd5bc988d1d137750998a9
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0246-rt-String-StringConsBytesIntIntIntAndBytesTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringConsBytesIntIntIntAndBytesTest)
+run(StringConsBytesIntIntIntAndBytesTest)
diff --git a/testsuite/java_test/string_test/issue-RT0510-rt-String-StringChineseClassTest/StringChineseClassTest.java b/testsuite/java_test/string_test/issue-RT0510-rt-String-StringChineseClassTest/StringChineseClassTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d94abdc26a445530cb869d6d0ba0b536183f4ef
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0510-rt-String-StringChineseClassTest/StringChineseClassTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class StringChineseClassTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = StringChineseClassTest_1();
+        } catch (Exception e) {
+            System.out.println(e);
+            processResult -= 10;
+        }
+//        System.out.println(result);
+//        System.out.println(randomtest.res);
+        if (result == 1 && processResult == 95) {
+            result = 0;
+        }
+        return result;
+    }
+    public static int StringChineseClassTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        try {
+            中国 test1 = new 中国();
+            Method m1 = 中国.class.getDeclaredMethod("stringtestmethod");
+            m1.invoke(test1);
+            あなたのことが好きです test2 = new あなたのことが好きです();
+            Method m2 = あなたのことが好きです.class.getDeclaredMethod("stringtestmethod");
+            m2.invoke(test2);
+            사랑해 test3 = new 사랑해();
+            Method m3 = 사랑해.class.getDeclaredMethod("stringtestmethod");
+            m3.invoke(test3);
+            processResult -= 4;
+        } catch (NoSuchMethodException e) {
+            System.out.println(e);
+        } catch (IllegalAccessException e) {
+            System.out.println(e);
+        } catch (InvocationTargetException e) {
+            System.out.println(e);
+        }
+        return 1;///*STATUS_PASSED*/
+    }
+}
+class 中国 {
+    public void stringtestmethod() {
+        System.out.println("hello，中文，中国");
+    }
+}
+class あなたのことが好きです {
+    public void stringtestmethod() {
+        System.out.println("hello，日语，あなたのことが好きです");
+    }
+}
+class 사랑해 {
+    public void stringtestmethod() {
+        System.out.println("hello，韩语，사랑해");
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-RT0510-rt-String-StringChineseClassTest/expected.txt b/testsuite/java_test/string_test/issue-RT0510-rt-String-StringChineseClassTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a85aecbf026e6ae39af0989086c1536127bfb445
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0510-rt-String-StringChineseClassTest/expected.txt
@@ -0,0 +1,4 @@
+hello，中文，中国
+hello，日语，あなたのことが好きです
+hello，韩语，사랑해
+0
diff --git a/testsuite/java_test/string_test/issue-RT0510-rt-String-StringChineseClassTest/test.cfg b/testsuite/java_test/string_test/issue-RT0510-rt-String-StringChineseClassTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..bfa4fa0fcf0861eecacef31eb595cbf030c8993b
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0510-rt-String-StringChineseClassTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringChineseClassTest.java)
+run(StringChineseClassTest)
diff --git a/testsuite/java_test/string_test/issue-RT0512-rt-String-StringReflectAPITest/StringReflectAPITest.java b/testsuite/java_test/string_test/issue-RT0512-rt-String-StringReflectAPITest/StringReflectAPITest.java
new file mode 100755
index 0000000000000000000000000000000000000000..f491a306f2dfe9874123f2b2311f22dc797231e9
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0512-rt-String-StringReflectAPITest/StringReflectAPITest.java
@@ -0,0 +1,1788 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+public class StringReflectAPITest {
+    private static int processResult = 700;
+    private static String Charset;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            StringReflectAPITest_1();
+        } catch (Exception e) {
+            e.printStackTrace();
+            processResult -= 10;
+        }
+        //System.out.println(result);
+        //System.out.println(StringReflectAPITest.res);
+        if (result == 2 && processResult == 126) {
+            result = 0;
+        }
+        return result;
+    }
+    private static void StringReflectAPITest_1() throws SecurityException, IllegalArgumentException {
+        int result1 = 4;/*STATUS_FAILED*/
+        String s1 = null;
+        String s2 = "abc123";
+        String s3 = "      ";
+        String s4 = "";
+        String s5 = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
+        test1(s1);
+        test1(s2);
+        test1(s3);
+        test1(s4);
+        test1(s5);
+        test2(s1);
+        test2(s2);
+        test2(s3);
+        test2(s4);
+        test2(s5);
+        test3(s1);
+        test3(s2);
+        test3(s3);
+        test3(s4);
+        test3(s5);
+        test4(s1);
+        test4(s2);
+        test4(s3);
+        test4(s4);
+        test4(s5);
+        test5(s1);
+        test5(s2);
+        test5(s3);
+        test5(s4);
+        test5(s5);
+        test6(s1);
+        test6(s2);
+        test6(s3);
+        test6(s4);
+        test6(s5);
+        test7(s1);
+        test7(s2);
+        test7(s3);
+        test7(s4);
+        test7(s5);
+        test8(s1);
+        test8(s2);
+        test8(s3);
+        test8(s4);
+        test8(s5);
+        test9(s1);
+        test9(s2);
+        test9(s3);
+        test9(s4);
+        test9(s5);
+        test10(s1);
+        test10(s2);
+        test10(s3);
+        test10(s4);
+        test10(s5);
+        test11(s1);
+        test11(s2);
+        test11(s3);
+        test11(s4);
+        test11(s5);
+        test12(s1);
+        test12(s2);
+        test12(s3);
+        test12(s4);
+        test12(s5);
+        test13(s1);
+        test13(s2);
+        test13(s3);
+        test13(s4);
+        test13(s5);
+        test14(s1);
+        test14(s2);
+        test14(s3);
+        test14(s4);
+        test14(s5);
+        test15(s1);
+        test15(s2);
+        test15(s3);
+        test15(s4);
+        test15(s5);
+        test16(s1);
+        test16(s2);
+        test16(s3);
+        test16(s4);
+        test16(s5);
+        test17(s1);
+        test17(s2);
+        test17(s3);
+        test17(s4);
+        test17(s5);
+        test18(s1);
+        test18(s2);
+        test18(s3);
+        test18(s4);
+        test18(s5);
+        test19(s1);
+        test19(s2);
+        test19(s3);
+        test19(s4);
+        test19(s5);
+		/*test20(s1);
+		test20(s2);
+		test20(s3);
+		test20(s4);
+		test20(s5);*/
+        test21(s1);
+        test21(s2);
+        test21(s3);
+        test21(s4);
+        test21(s5);
+        test22(s1);
+        test22(s2);
+        test22(s3);
+        test22(s4);
+        test22(s5);
+        test23(s1);
+        test23(s2);
+        test23(s3);
+        test23(s4);
+        test23(s5);
+        test24(s1);
+        test24(s2);
+        test24(s3);
+        test24(s4);
+        test24(s5);
+        test25(s1);
+        test25(s2);
+        test25(s3);
+        test25(s4);
+        test25(s5);
+        test26(s1);
+        test26(s2);
+        test26(s3);
+        test26(s4);
+        test26(s5);
+        test28(s1);
+        test28(s2);
+        test28(s3);
+        test28(s4);
+        test28(s5);
+        test29(s1);
+        test29(s2);
+        test29(s3);
+        test29(s4);
+        test29(s5);
+        test30(s1);
+        test30(s2);
+        test30(s3);
+        test30(s4);
+        test30(s5);
+        test31(s1);
+        test31(s2);
+        test31(s3);
+        test31(s4);
+        test31(s5);
+        test32(s1);
+        test32(s2);
+        test32(s3);
+        test32(s4);
+        test32(s5);
+        test33(s1);
+        test33(s2);
+        test33(s3);
+        test33(s4);
+        test33(s5);
+        test34(s1);
+        test34(s2);
+        test34(s3);
+        test34(s4);
+        test34(s5);
+        test35(s1);
+        test35(s2);
+        test35(s3);
+        test35(s4);
+        test35(s5);
+        test36(s1);
+        test36(s2);
+        test36(s3);
+        test36(s4);
+        test36(s5);
+        test37(s1);
+        test37(s2);
+        test37(s3);
+        test37(s4);
+        test37(s5);
+        test38(s1);
+        test38(s2);
+        test38(s3);
+        test38(s4);
+        test38(s5);
+        test39(s1);
+        test39(s2);
+        test39(s3);
+        test39(s4);
+        test39(s5);
+        test40(s1);
+        test40(s2);
+        test40(s3);
+        test40(s4);
+        test40(s5);
+        test41(s1);
+        test41(s2);
+        test41(s3);
+        test41(s4);
+        test41(s5);
+        test42(s1);
+        test42(s2);
+        test42(s3);
+        test42(s4);
+        test42(s5);
+        test43(s1);
+        test43(s2);
+        test43(s3);
+        test43(s4);
+        test43(s5);
+        test44(s1);
+        test44(s2);
+        test44(s3);
+        test44(s4);
+        test44(s5);
+        test45(s1);
+        test45(s2);
+        test45(s3);
+        test45(s4);
+        test45(s5);
+        test46(s1);
+        test46(s2);
+        test46(s3);
+        test46(s4);
+        test46(s5);
+        test47(s1);
+        test47(s2);
+        test47(s3);
+        test47(s4);
+        test47(s5);
+        test48(s1);
+        test48(s2);
+        test48(s3);
+        test48(s4);
+        test48(s5);
+        test49(s1);
+        test49(s2);
+        test49(s3);
+        test49(s4);
+        test49(s5);
+        test50(s1);
+        test50(s2);
+        test50(s3);
+        test50(s4);
+        test50(s5);
+        test51(s1);
+        test51(s2);
+        test51(s3);
+        test51(s4);
+        test51(s5);
+        test52(s1);
+        test52(s2);
+        test52(s3);
+        test52(s4);
+        test52(s5);
+        test53(s1);
+        test53(s2);
+        test53(s3);
+        test53(s4);
+        test53(s5);
+        test54(s1);
+        test54(s2);
+        test54(s3);
+        test54(s4);
+        test54(s5);
+        test55(s1);
+        test55(s2);
+        test55(s3);
+        test55(s4);
+        test55(s5);
+        test56(s1);
+        test56(s2);
+        test56(s3);
+        test56(s4);
+        test56(s5);
+        test57(s1);
+        test57(s2);
+        test57(s3);
+        test57(s4);
+        test57(s5);
+        test58(s1);
+        test58(s2);
+        test58(s3);
+        test58(s4);
+        test58(s5);
+        test59(s1);
+        test59(s2);
+        test59(s3);
+        test59(s4);
+        test59(s5);
+        test60(s1);
+        test60(s2);
+        test60(s3);
+        test60(s4);
+        test60(s5);
+        test61(s1);
+        test61(s2);
+        test61(s3);
+        test61(s4);
+        test61(s5);
+        test62(s1);
+        test62(s2);
+        test62(s3);
+        test62(s4);
+        test62(s5);
+        test63(s1);
+        test63(s2);
+        test63(s3);
+        test63(s4);
+        test63(s5);
+        test64(s1);
+        test64(s2);
+        test64(s3);
+        test64(s4);
+        test64(s5);
+        test65(s1);
+        test65(s2);
+        test65(s3);
+        test65(s4);
+        test65(s5);
+        test66(s1);
+        test66(s2);
+        test66(s3);
+        test66(s4);
+        test66(s5);
+        test67(s1);
+        test67(s2);
+        test67(s3);
+        test67(s4);
+        test67(s5);
+        test68(s1);
+        test68(s2);
+        test68(s3);
+        test68(s4);
+        test68(s5);
+    }
+    private static void test1(String string) {
+        //Class class1 = string.getClass();
+        //Object[] objects = {"a","b","c"};
+        if (string != null) {
+            try {
+                Class argsClass[] = {int.class};
+                Object args[] = {1};
+                Method m = String.class.getMethod("charAt", argsClass);
+                char result = (char) m.invoke(string, args);
+                if (String.valueOf(result) != null) {
+                    processResult -= 2;
+                }
+            } catch (IndexOutOfBoundsException e) {
+                //e.printStackTrace();
+                processResult -= 2;
+            } catch (NoSuchMethodException e) {
+                e.printStackTrace();
+            } catch (SecurityException e) {
+                e.printStackTrace();
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            } catch (IllegalArgumentException e) {
+                e.printStackTrace();
+            } catch (InvocationTargetException e) {
+                //e.printStackTrace();
+                processResult -= 2;
+            }
+        } else {
+            try {
+                char chars = string.charAt(2);
+            } catch (NullPointerException e) {
+                //e.printStackTrace();
+                processResult -= 2;
+            }
+        }
+    }
+    private static void test2(String string) {
+        try {
+            Class argsClass[] = {int.class};
+            Object args[] = {1};
+            Method m = String.class.getMethod("codePointAt", argsClass);//codePointAt(int index)
+            int result = (int) m.invoke(string, args);
+            if (result > 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            //e.printStackTrace();
+            //System.out.println("===============fail2");
+            processResult -= 2;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test3(String string) {
+        try {
+            Class argsClass[] = {int.class};
+            Object args[] = {1};
+            Method m = String.class.getMethod("codePointBefore", argsClass);//codePointBefore(int index)
+            int result = (int) m.invoke(string, args);
+            if (result > 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test4(String string) {
+        try {
+            Class argsClass[] = {int.class, int.class};
+            Object args[] = {1, 3};
+            Method m = String.class.getMethod("codePointCount", new Class[]{int.class, int.class});//	codePointCount(int beginIndex, int endIndex)
+            int result = (int) m.invoke(string, args);
+            if (result > 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        } catch (IndexOutOfBoundsException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test5(String string) {
+        try {
+            Class params[] = {String.class};
+            Class argsClass[] = {String.class};
+            Object args[] = {"adc"};
+            Method m = String.class.getMethod("compareTo", argsClass);//compareTo(String anotherString)
+            int result = (int) m.invoke(string, args);
+            if (result < 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test6(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"adc"};
+            Method m = String.class.getMethod("compareToIgnoreCase", argsClass);//compareToIgnoreCase(String str)
+            int result = (int) m.invoke(string, args);
+            if (result < 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test7(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"QWE"};
+            Method m = String.class.getMethod("concat", argsClass);//concat(String str)
+            Object result = m.invoke(string, args);
+            if (result.toString().contains("QWE")) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test8(String string) {
+        CharSequence charSequence = new String("abc");
+        try {
+            Class argsClass[] = {CharSequence.class};
+            Object args[] = {charSequence};
+            Method m = String.class.getMethod("contains", argsClass);//contains(CharSequence s)
+            boolean result = (boolean) m.invoke(string, args);
+            if (result) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test9(String string) {
+        try {
+            Class[] argsClass = {StringBuffer.class};
+            Object args[] = {new StringBuffer("abc123")};
+            Method m = String.class.getMethod("contentEquals", argsClass);//contentEquals(StringBuffer sb)
+            boolean result = (boolean) m.invoke(string, args);
+            if (result) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test10(String string) {
+        CharSequence charSequence = new String("abc123");
+        try {
+            Class argsClass[] = {CharSequence.class};
+            Object args[] = {charSequence};
+            Method m = String.class.getMethod("contentEquals", argsClass);//contentEquals(CharSequence cs)
+            boolean result = (boolean) m.invoke(string, args);
+            if (result) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test11(String string) {
+        char[] chars = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
+        try {
+            Class argsClass[] = {char[].class, int.class, int.class};
+            Object args[] = {chars, 1, 5};
+            Method m = String.class.getMethod("copyValueOf", argsClass);//	copyValueOf(char[] data, int offset, int count)
+            String result = (String) m.invoke(string, args);
+            if ("bcdef".equals(result.toString())) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test12(String string) {
+        char[] chars = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
+        try {
+            Class[] argsClass = {char[].class};
+            Object args[] = {chars};
+            Method m = String.class.getMethod("copyValueOf", argsClass);//copyValueOf(char[] data)
+            String result = (String) m.invoke(string, args);
+            if ("abcdefg".equals(result.toString())) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test13(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"3"};
+            Method m = String.class.getMethod("endsWith", argsClass);//endsWith(String suffix)
+            boolean result = (boolean) m.invoke(string, args);
+            if (result) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test14(String string) {
+        try {
+            Class argsClass[] = {Object.class};
+            Object args[] = {"abc123"};
+            Method m = String.class.getMethod("equals", argsClass);//equals(Object anObject)
+            boolean result = (boolean) m.invoke(string, args);
+            if (result) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test15(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"ABC123"};
+            Method m = String.class.getMethod("equalsIgnoreCase", argsClass);//equalsIgnoreCase(String anotherString)
+            boolean result = (boolean) m.invoke(string, args);
+            if (result) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test16(String string) {
+        try {
+            Class[] argsClass = {String.class, Object[].class};
+            Object[] objects = {99, "abc"};
+            Object[] args = {"格式参数$的使用：%1$d,%2$s", objects};//LOCALE表示地区
+            Method m = String.class.getMethod("format", argsClass);//format(Locale l, String format, Object... args)
+            String result = (String) m.invoke(string, args);
+            if ("格式参数$的使用：99,abc".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        }
+    }
+    private static void test17(String string) {
+        try {
+            Class argsClass[] = {String.class, Object[].class};
+            Object[] objects = {"Tom"};
+            Object args[] = {"Hi,%s", objects};
+            Method m = String.class.getMethod("format", argsClass);//format(String format, Object... args)
+            String result = (String) m.invoke(string, args);
+            if ("Hi,Tom".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test18(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"ISO-8859-1"};
+            Method m = String.class.getMethod("getBytes", argsClass);//getBytes(String charsetName)
+            byte[] bytes = (byte[]) m.invoke(string, args);
+            if (bytes.length >= 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test19(String string) {
+        try {
+            Method m = String.class.getMethod("getBytes");//getBytes()
+            byte[] bytes = (byte[]) m.invoke(string);
+            if (bytes.length >= 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        }
+    }
+    private static void test20(String string) {//有问题，待解决
+        try {
+            Class argsClass[] = {Charset.class};
+            Object args[] = {"GBK"};
+            Method m = String.class.getMethod("getBytes", argsClass);//getBytes(Charset charset)
+            byte[] bytes = (byte[]) m.invoke(string, args);
+            System.out.println(bytes.length);
+            if (bytes.length >= 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalArgumentException e) {
+            //e.printStackTrace();
+        }
+    }
+    private static void test21(String string) {
+        byte[] bytes = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        try {
+            Class argsClass[] = {int.class, int.class, byte[].class, int.class};
+            Object args[] = {1, 3, bytes, 2};
+            Method m = String.class.getMethod("getBytes", argsClass);//getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)
+            m.invoke(string, args);
+            processResult -= 2;
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test22(String string) {
+        try {
+            Class argsClass[] = {int.class, int.class, char[].class, int.class};
+            char[] chars = {'a', 'b', 'c', 'd', 'e'};
+            Object args[] = {1, 3, chars, 2};
+            Method m = String.class.getMethod("getChars", argsClass);//	getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
+            m.invoke(string, args);
+            processResult -= 2;
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            //e.printStackTrace();	
+            processResult -= 2;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test23(String string) {
+        try {
+            Method m = String.class.getMethod("hashCode");//	hashCode()
+            int result = (int) m.invoke(string);
+            //System.out.println(result);
+            if (String.valueOf(result) != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test24(String string) {
+        try {
+            Class argsClass[] = {int.class, int.class};
+            Object args[] = {1, 3};
+            Method m = String.class.getMethod("indexOf", argsClass);//	indexOf(int ch, int fromIndex)
+            int result = (int) m.invoke(string, args);
+            //System.out.println(result);
+            if (String.valueOf(result) != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test25(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"c"};
+            Method m = String.class.getMethod("indexOf", argsClass);//indexOf(String str)
+            int result = (int) m.invoke(string, args);
+            if (result > 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test26(String string) {
+        try {
+            Class argsClass[] = {int.class};
+            Object args[] = {3};
+            Method m = String.class.getMethod("indexOf", argsClass);//	indexOf(int ch)
+            int result = (int) m.invoke(string, args);
+            //System.out.println(result);
+            if (result == -1) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test28(String string) {
+        try {
+            Class argsClass[] = {String.class, int.class};
+            Object args[] = {"c", 0};
+            Method m = String.class.getMethod("indexOf", argsClass);//indexOf(String str, int fromIndex)
+            int result = (int) m.invoke(string, args);
+            //System.out.println(result);
+            if (result > 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test29(String string) {
+        try {
+            Method m = String.class.getMethod("intern");//intern()
+            String result = (String) m.invoke(string);
+            //System.out.println(result);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test30(String string) {
+        try {
+            Method m = String.class.getMethod("isEmpty");//isEmpty()
+            boolean flag = (boolean) m.invoke(string);
+            //System.out.println(flag);
+            if (flag) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test31(String string) {
+        try {
+            Class argsClass[] = {CharSequence.class, CharSequence[].class};
+            CharSequence[] charSequences = {"G"};
+            Object args[] = {"F", charSequences};
+            Method m = String.class.getMethod("join", argsClass);//join(CharSequence delimiter, CharSequence... elements)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if ("G".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test32(String string) {
+        String delimiter = "-";
+        String[] elements = {"JDK", "8", "String", "join"};
+        List<String> list = new ArrayList<String>(Arrays.asList(elements));
+        try {
+            Class argsClass[] = {CharSequence.class, Iterable.class};
+            Object args[] = {delimiter, list};
+            Method m = String.class.getMethod("join", argsClass);//join(CharSequence delimiter, Iterable<? extends CharSequence> elements)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if ("JDK-8-String-join".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test33(String string) {
+        try {
+            Class argsClass[] = {int.class};
+            Object args[] = {1};
+            Method m = String.class.getMethod("lastIndexOf", argsClass);//	lastIndexOf(int ch)
+            int result = (int) m.invoke(string, args);
+            //System.out.println(result);
+            if (result == -1) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test34(String string) {
+        try {
+            Class argsClass[] = {String.class, int.class};
+            Object args[] = {"c", 0};
+            Method m = String.class.getMethod("lastIndexOf", argsClass);//	lastIndexOf(String str, int fromIndex)
+            int result = (int) m.invoke(string, args);
+            //System.out.println(result);
+            if (result == -1) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test35(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"c"};
+            Method m = String.class.getMethod("lastIndexOf", argsClass);//lastIndexOf(String str)
+            int result = (int) m.invoke(string, args);
+            //System.out.println(result);
+            if (result > 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test36(String string) {
+        try {
+            Class argsClass[] = {int.class, int.class};
+            Object args[] = {1, 0};
+            Method m = String.class.getMethod("lastIndexOf", argsClass);//	lastIndexOf(int ch, int fromIndex)
+            int result = (int) m.invoke(string, args);
+            //System.out.println(result);
+            if (result == -1) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test37(String string) {
+        try {
+            Method m = String.class.getMethod("length");//length()
+            int result = (int) m.invoke(string);
+            if (result >= 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test38(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"abc123"};
+            Method m = String.class.getMethod("matches", argsClass);//matches(String regex)
+            boolean flag = (boolean) m.invoke(string, args);
+            //System.out.println(flag);
+            if (flag) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test39(String string) {
+        try {
+            Class argsClass[] = {int.class, int.class};
+            Object args[] = {1, 2};
+            Method m = String.class.getMethod("offsetByCodePoints", argsClass);//offsetByCodePoints(int index, int codePointOffset)
+            int result = (int) m.invoke(string, args);
+            //System.out.println(result);
+            if (result > 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test40(String string) {
+        try {
+            Class argsClass[] = {boolean.class, int.class, String.class, int.class, int.class};
+            Object args[] = {true, 1, "abc123", 2, 3};
+            Method m = String.class.getMethod("regionMatches", argsClass);//regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
+            boolean flag = (boolean) m.invoke(string, args);
+            //System.out.println(flag);
+            if (!flag) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test41(String string) {
+        try {
+            Class argsClass[] = {int.class, String.class, int.class, int.class};
+            Object args[] = {0, "abc123", 1, 2};
+            Method m = String.class.getMethod("regionMatches", argsClass);//	regionMatches(int toffset, String other, int ooffset, int len)
+            boolean flag = (boolean) m.invoke(string, args);
+            //System.out.println(flag);
+            if (!flag) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test42(String string) {
+        CharSequence charSequence = new String("abc");
+        CharSequence charSequence1 = new String("ABC");
+        try {
+            Class argsClass[] = {CharSequence.class, CharSequence.class};
+            Object args[] = {charSequence, charSequence1};
+            Method m = String.class.getMethod("replace", argsClass);//	replace(charSequence  target, CharSequence replacement)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if (result.contains("ABC")) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test43(String string) {
+        char ch = 'a';
+        char ch1 = 'F';
+        try {
+            Class argsClass[] = {char.class, char.class};
+            Object args[] = {ch, ch1};
+            Method m = String.class.getMethod("replace", argsClass);//	replace(char oldChar, char newChar)
+            String str = (String) m.invoke(string, args);
+            //System.out.println(str);
+            if (str.contains("F")) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test44(String string) {
+        try {
+            Class argsClass[] = {String.class, String.class};
+            Object args[] = {"abc", "ABC"};
+            Method m = String.class.getMethod("replaceAll", argsClass);//replaceAll(String regex, String replacement)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if (result.contains("ABC")) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test45(String string) {
+        try {
+            Class argsClass[] = {String.class, String.class};
+            Object args[] = {"abc", "ABC"};
+            Method m = String.class.getMethod("replaceFirst", argsClass);//	replaceFirst(String regex, String replacement)
+            String str = (String) m.invoke(string, args);
+            //System.out.println(str);
+            if (str.contains("ABC")) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test46(String string) {
+        try {
+            Class argsClass[] = {String.class, int.class};
+            Object args[] = {"b", 2};
+            Method m = String.class.getMethod("split", argsClass);//split(String regex, int limit)
+            String[] result = (String[]) m.invoke(string, args);
+            //System.out.println(result.length);
+            if (result.length > 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test47(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"b"};
+            Method m = String.class.getMethod("split", argsClass);//split(String regex)
+            String[] result = (String[]) m.invoke(string, args);
+            //System.out.println(result.length);
+            if (result.length > 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test48(String string) {
+        try {
+            Class argsClass[] = {String.class};
+            Object args[] = {"a"};
+            Method m = String.class.getMethod("startsWith", argsClass);//	startsWith(String prefix)
+            boolean result = (boolean) m.invoke(string, args);
+            //System.out.println(result);
+            if (result) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test49(String string) {
+        try {
+            Class argsClass[] = {String.class, int.class};
+            Object args[] = {"b", 1};
+            Method m = String.class.getMethod("startsWith", argsClass);//startsWith(String prefix, int toffset)
+            boolean result = (boolean) m.invoke(string, args);
+            //System.out.println(result);
+            if (result) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test50(String string) {
+        try {
+            Class argsClass[] = {int.class, int.class};
+            Object args[] = {0, 3};
+            Method m = String.class.getMethod("subSequence", argsClass);//subSequence(int beginIndex, int endIndex)
+            CharSequence result = (CharSequence) m.invoke(string, args);
+            //System.out.println(result);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test51(String string) {
+        try {
+            Class argsClass[] = {int.class, int.class};
+            Object args[] = {0, 3};
+            Method m = String.class.getMethod("substring", argsClass);//substring(int beginIndex, int endIndex)
+            String result = (String) m.invoke(string, args);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test52(String string) {
+        try {
+            Class argsClass[] = {int.class};
+            Object args[] = {0};
+            Method m = String.class.getMethod("substring", argsClass);//substring(int beginIndex)
+            String result = (String) m.invoke(string, args);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            //e.printStackTrace();
+            processResult -= 2;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test53(String string) {
+        try {
+            Method m = String.class.getMethod("toCharArray");//toCharArray()
+            char[] result = (char[]) m.invoke(string);
+            //System.out.println(result.length);
+            if (result.length >= 0) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test54(String string) {
+        try {
+            Method m = String.class.getMethod("toLowerCase");//toLowerCase()
+            String result = (String) m.invoke(string);
+            //System.out.println(result);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test55(String string) {
+        try {
+            Class argsClass[] = {Locale.class};
+            Object args[] = {Locale.getDefault()};
+            Method m = String.class.getMethod("toLowerCase", argsClass);//toLowerCase(Locale locale)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test56(String string) {
+        try {
+            Method m = String.class.getMethod("toString");//toString()
+            String result = (String) m.invoke(string);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test57(String string) {
+        try {
+            Class argsClass[] = {Locale.class};
+            Object args[] = {Locale.getDefault()};
+            Method m = String.class.getMethod("toUpperCase", argsClass);//toUpperCase(Locale locale)
+            String result = (String) m.invoke(string, args);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test58(String string) {
+        try {
+            Method m = String.class.getMethod("toUpperCase");//toUpperCase()
+            String result = (String) m.invoke(string);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test59(String string) {
+        try {
+            Method m = String.class.getMethod("trim");//trim()
+            String result = (String) m.invoke(string);
+            if (result != null) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test60(String string) {
+        try {
+            Class argsClass[] = {boolean.class};
+            Object args[] = {true};
+            Method m = String.class.getMethod("valueOf", argsClass);//valueOf(boolean b)
+            String result = (String) m.invoke(string, args);
+            if ("true".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+        }
+    }
+    private static void test61(String string) {
+        Double d = new Double(11.23);
+        try {
+            Class argsClass[] = {double.class};
+            Object args[] = {d};
+            Method m = String.class.getMethod("valueOf", argsClass);//valueOf(double d)
+            String result = (String) m.invoke(null, args);
+            //System.out.println(result);
+            if ("11.23".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+        }
+    }
+    private static void test62(String string) {
+        char[] chars = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
+        try {
+            Class argsClass[] = {char[].class, int.class, int.class};
+            Object args[] = {chars, 1, 3};
+            Method m = String.class.getMethod("valueOf", argsClass);//valueOf(char[] data, int offset, int count)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if ("bcd".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+        }
+    }
+    private static void test63(String string) {
+        float f = (float) 11.0;
+        try {
+            Class argsClass[] = {float.class};
+            Object args[] = {f};
+            Method m = String.class.getMethod("valueOf", argsClass);//valueOf(float f)
+            String result = (String) m.invoke(string, args);
+            if ("11.0".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+        }
+    }
+    private static void test64(String string) {
+        try {
+            Class argsClass[] = {int.class};
+            Object args[] = {1};
+            Method m = String.class.getMethod("valueOf", argsClass);//valueOf(int i)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if ("1".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+        }
+    }
+    private static void test65(String string) {
+        try {
+            Class argsClass[] = {char.class};
+            Object args[] = {'a'};
+            Method m = String.class.getMethod("valueOf", argsClass);//valueOf(char c)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if ("a".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+        }
+    }
+    private static void test66(String string) {
+        long l = 1000000000;
+        try {
+            Class argsClass[] = {long.class};
+            Object args[] = {l};
+            Method m = String.class.getMethod("valueOf", argsClass);//valueOf(long l)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if ("1000000000".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+        }
+    }
+    private static void test67(String string) {
+        try {
+            Class argsClass[] = {Object.class};
+            Object args[] = {string};
+            Method m = String.class.getMethod("valueOf", argsClass);//valueOf(Object obj)
+            String result = (String) m.invoke(string, args);
+            //System.out.println(result);
+            if (string.equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            //se.printStackTrace();
+            processResult -= 2;
+        }
+    }
+    private static void test68(String string) {
+        char[] chars = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
+        try {
+            Class argsClass[] = {char[].class};
+            Object args[] = {chars};
+            Method m = String.class.getMethod("valueOf", argsClass);//valueOf(char[] data)
+            String result = (String) m.invoke(string, args);
+            if ("abcdefg".equals(result)) {
+                processResult -= 2;
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NullPointerException se) {
+            se.printStackTrace();
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/string_test/issue-RT0512-rt-String-StringReflectAPITest/expected.txt b/testsuite/java_test/string_test/issue-RT0512-rt-String-StringReflectAPITest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0512-rt-String-StringReflectAPITest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-RT0512-rt-String-StringReflectAPITest/test.cfg b/testsuite/java_test/string_test/issue-RT0512-rt-String-StringReflectAPITest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f8ae20e825d52468c78e57c96b44d1f4b15d1a45
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0512-rt-String-StringReflectAPITest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReflectAPITest.java)
+run(StringReflectAPITest)
diff --git a/testsuite/java_test/string_test/issue-RT0513-rt-String-StringReflectNPTest/StringReflectNPTest.java b/testsuite/java_test/string_test/issue-RT0513-rt-String-StringReflectNPTest/StringReflectNPTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..464b7b582727365a3654b25d6f3b5c04ad6f4b7f
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0513-rt-String-StringReflectNPTest/StringReflectNPTest.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.*;
+public class StringReflectNPTest {
+    private static int processResult = 99;
+    public static void main(String argv[]) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[], PrintStream out) {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            StringReflectNPTest_1();
+        } catch (Exception e) {
+            processResult -= 10;
+        }
+//        System.out.println(result);
+//        System.out.println(StringReflectNPTest.res);
+        if (result == 2 && processResult == 85) {
+            result = 0;
+        }
+        return result;
+    }
+    public static void StringReflectNPTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        String str1_1 = new String("abc123");
+        String str1_2 = new String("      ");
+        String str1_3 = new String("abc123");
+        String str1_4 = new String("");
+        String str1_5 = new String();
+        String str2_1 = "abc123";
+        String str2_2 = "      ";
+        String str2_3 = "abc123";
+        String str2_4 = "";
+        String str2_5 = null;
+        test1(str2_5);
+        test2(str2_5);
+        test3(str2_5);
+        test4(str2_5);
+        test5(str2_5);
+        test6(str2_5);
+        test7(str2_5);
+    }
+    private static void test1(String str) {
+        try {
+            Class params[] = {int.class};
+            Class argsClass[] = {String.class};
+            Object args[] = {0};
+            Method m = String.class.getMethod("charAt", params);
+            Object result = m.invoke(str, args);
+        } catch (NoSuchMethodException e) {
+            System.out.println("===============fail1-1");
+        } catch (InvocationTargetException e) {
+            System.out.println("===============fail2");
+        } catch (IllegalAccessException e) {
+            System.out.println("===============fail3");
+        } catch (NullPointerException se) {
+            processResult -= 2;
+        }
+    }
+    private static void test2(String str) {
+        try {
+            Class params[] = {int.class};
+            Class argsClass[] = {String.class};
+//            Object args[] = {0};
+            Method m = String.class.getMethod("toCharArray");
+            Object result = m.invoke(str);
+        } catch (NoSuchMethodException e) {
+            System.out.println("===============fail2-1");
+        } catch (InvocationTargetException e) {
+            System.out.println("===============fail2");
+        } catch (IllegalAccessException e) {
+            System.out.println("===============fail3");
+        } catch (NullPointerException se) {
+            processResult -= 2;
+        }
+    }
+    private static void test3(String str) {
+        try {
+            Class params[] = {int.class};
+            Class argsClass[] = {String.class};
+            Object args[] = {1};
+            Method m = String.class.getMethod("substring", params);
+            Object result = m.invoke(str, args);
+        } catch (NoSuchMethodException e) {
+            System.out.println("===============fail3-1");
+        } catch (InvocationTargetException e) {
+            System.out.println("===============fail2");
+        } catch (IllegalAccessException e) {
+            System.out.println("===============fail3");
+        } catch (NullPointerException se) {
+            processResult -= 2;
+        }
+    }
+    private static void test4(String str) {
+        try {
+            Class params[] = {int.class};
+            Class argsClass[] = {String.class};
+            Object args[] = {new String("aaa")};
+            Method m = String.class.getMethod("compareTo", argsClass);
+            Object result = m.invoke(str, args);
+        } catch (NoSuchMethodException e) {
+            System.out.println("===============fail4-1");
+        } catch (InvocationTargetException e) {
+            System.out.println("===============fail2");
+        } catch (IllegalAccessException e) {
+            System.out.println("===============fail3");
+        } catch (NullPointerException se) {
+            processResult -= 2;
+        }
+    }
+    private static void test5(String str) {
+        try {
+            Class params[] = {int.class};
+            Class argsClass[] = {String.class};
+//            Object args[] = {0};
+            Method m = String.class.getMethod("intern");
+            Object result = m.invoke(str);
+        } catch (NoSuchMethodException e) {
+            System.out.println("===============fail5-1");
+        } catch (InvocationTargetException e) {
+            System.out.println("===============fail2");
+        } catch (IllegalAccessException e) {
+            System.out.println("===============fail3");
+        } catch (NullPointerException se) {
+            processResult -= 2;
+        }
+    }
+    private static void test6(String str) {
+        try {
+            Class params[] = {int.class};
+            Class argsClass[] = {char.class, char.class};
+            Object args[] = {new String("a"), new String("b")};
+            Method m = String.class.getMethod("replace", argsClass);
+            Object result = m.invoke(str, args);
+        } catch (NoSuchMethodException e) {
+            System.out.println("===============fail6-1");
+        } catch (InvocationTargetException e) {
+            System.out.println("===============fail2");
+        } catch (IllegalAccessException e) {
+            System.out.println("===============fail3");
+        } catch (NullPointerException se) {
+            processResult -= 2;
+        }
+    }
+    private static void test7(String str) {
+        try {
+            Class params[] = {int.class};
+            Class argsClass[] = {String.class};
+            Object args[] = {new String("aaa")};
+            Method m = String.class.getMethod("concat", argsClass);
+            Object result = m.invoke(str, args);
+        } catch (NoSuchMethodException e) {
+            System.out.println("===============fail7-1");
+        } catch (InvocationTargetException e) {
+            System.out.println("===============fail2");
+        } catch (IllegalAccessException e) {
+            System.out.println("===============fail3");
+        } catch (NullPointerException se) {
+            processResult -= 2;
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-RT0513-rt-String-StringReflectNPTest/expected.txt b/testsuite/java_test/string_test/issue-RT0513-rt-String-StringReflectNPTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0513-rt-String-StringReflectNPTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-RT0513-rt-String-StringReflectNPTest/test.cfg b/testsuite/java_test/string_test/issue-RT0513-rt-String-StringReflectNPTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..220be8a3fc922949b35f203b0bd612d8da0c1a8a
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0513-rt-String-StringReflectNPTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReflectNPTest.java)
+run(StringReflectNPTest)
diff --git a/testsuite/java_test/string_test/issue-RT0514-rt-String-StringReflectStringBufferAPITest/StringReflectStringBufferAPITest.java b/testsuite/java_test/string_test/issue-RT0514-rt-String-StringReflectStringBufferAPITest/StringReflectStringBufferAPITest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b14de4dbee3ae76eb7fbed25f9e19e80c9726b1b
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0514-rt-String-StringReflectStringBufferAPITest/StringReflectStringBufferAPITest.java
@@ -0,0 +1,1306 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class StringReflectStringBufferAPITest {
+//    private static int processResult = 599;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+    public static int run(String[] args, PrintStream out) {
+        int result = 2;
+        try {
+            StringReflectStringBufferAPITest1();
+            result = 0;
+        } catch (Exception e) {
+        }
+        return result;
+    }
+    public static void StringReflectStringBufferAPITest1() {
+        StringBuffer sb1 = new StringBuffer();
+        StringBuffer sb2 = new StringBuffer("abc123");
+        StringBuffer sb3 = new StringBuffer("      ");
+        StringBuffer sb4 = new StringBuffer("");
+        StringBuffer sb5 = new StringBuffer("!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~");
+        System.out.println("==========test1==========");
+        test1(sb1);
+        test1(sb2);
+        test1(sb3);
+        test1(sb4);
+        test1(sb5);
+        System.out.println("==========test2==========");
+        test2(sb1);
+        test2(sb2);
+        test2(sb3);
+        test2(sb4);
+        test2(sb5);
+        System.out.println("==========test3==========");
+        test3(sb1);
+        test3(sb2);
+        test3(sb3);
+        test3(sb4);
+        test3(sb5);
+        System.out.println("==========test4==========");
+        test4(sb1);
+        test4(sb2);
+        test4(sb3);
+        test4(sb4);
+        test4(sb5);
+        System.out.println("==========test5==========");
+        test5(sb1);
+        test5(sb2);
+        test5(sb3);
+        test5(sb4);
+        test5(sb5);
+        System.out.println("==========test6==========");
+        test6(sb1);
+        test6(sb2);
+        test6(sb3);
+        test6(sb4);
+        test6(sb5);
+        System.out.println("==========test7==========");
+        test7(sb1);
+        test7(sb2);
+        test7(sb3);
+        test7(sb4);
+        test7(sb5);
+        System.out.println("==========test8==========");
+        test8(sb1);
+        test8(sb2);
+        test8(sb3);
+        test8(sb4);
+        test8(sb5);
+        System.out.println("==========test9==========");
+        test9(sb1);
+        test9(sb2);
+        test9(sb3);
+        test9(sb4);
+        test9(sb5);
+        System.out.println("==========test10==========");
+        test10(sb1);
+        test10(sb2);
+        test10(sb3);
+        test10(sb4);
+        test10(sb5);
+        System.out.println("==========test11==========");
+        test11(sb1);
+        test11(sb2);
+        test11(sb3);
+        test11(sb4);
+        test11(sb5);
+        System.out.println("==========test12==========");
+        test12(sb1);
+        test12(sb2);
+        test12(sb3);
+        test12(sb4);
+        test12(sb5);
+        System.out.println("==========test13==========");
+        test13(sb1);
+        test13(sb2);
+        test13(sb3);
+        test13(sb4);
+        test13(sb5);
+        System.out.println("==========test14==========");
+        test14(sb1);
+        test14(sb2);
+        test14(sb3);
+        test14(sb4);
+        test14(sb5);
+        System.out.println("==========test15==========");
+        test15(sb1);
+        test15(sb2);
+        test15(sb3);
+        test15(sb4);
+        test15(sb5);
+        System.out.println("==========test16==========");
+        test16(sb1);
+        test16(sb2);
+        test16(sb3);
+        test16(sb4);
+        test16(sb5);
+        System.out.println("==========test17==========");
+        test17(sb1);
+        test17(sb2);
+        test17(sb3);
+        test17(sb4);
+        test17(sb5);
+        System.out.println("==========test18==========");
+        test18(sb1);
+        test18(sb2);
+        test18(sb3);
+        test18(sb4);
+        test18(sb5);
+        System.out.println("==========test19==========");
+        test19(sb1);
+        test19(sb2);
+        test19(sb3);
+        test19(sb4);
+        test19(sb5);
+        System.out.println("==========test20==========");
+        test20(sb1);
+        test20(sb2);
+        test20(sb3);
+        test20(sb4);
+        test20(sb5);
+        System.out.println("==========test21==========");
+        test21(sb1);
+        test21(sb2);
+        test21(sb3);
+        test21(sb4);
+        test21(sb5);
+        System.out.println("==========test22==========");
+        test22(sb1);
+        test22(sb2);
+        test22(sb3);
+        test22(sb4);
+        test22(sb5);
+        System.out.println("==========test23==========");
+        test23(sb1);
+        test23(sb2);
+        test23(sb3);
+        test23(sb4);
+        test23(sb5);
+        System.out.println("==========test24==========");
+        test24(sb1);
+        test24(sb2);
+        test24(sb3);
+        test24(sb4);
+        test24(sb5);
+        System.out.println("==========test25==========");
+        test25(sb1);
+        test25(sb2);
+        test25(sb3);
+        test25(sb4);
+        test25(sb5);
+        System.out.println("==========test26==========");
+        test26(sb1);
+        test26(sb2);
+        test26(sb3);
+        test26(sb4);
+        test26(sb5);
+        System.out.println("==========test27==========");
+        test27(sb1);
+        test27(sb2);
+        test27(sb3);
+        test27(sb4);
+        test27(sb5);
+        System.out.println("==========test28==========");
+        test28(sb1);
+        test28(sb2);
+        test28(sb3);
+        test28(sb4);
+        test28(sb5);
+        System.out.println("==========test29==========");
+        test29(sb1);
+        test29(sb2);
+        test29(sb3);
+        test29(sb4);
+        test29(sb5);
+        System.out.println("==========test30==========");
+        test30(sb1);
+        test30(sb2);
+        test30(sb3);
+        test30(sb4);
+        test30(sb5);
+        System.out.println("==========test31==========");
+        test31(sb1);
+        test31(sb2);
+        test31(sb3);
+        test31(sb4);
+        test31(sb5);
+        System.out.println("==========test32==========");
+        test32(sb1);
+        test32(sb2);
+        test32(sb3);
+        test32(sb4);
+        test32(sb5);
+        System.out.println("==========test33==========");
+        test33(sb1);
+        test33(sb2);
+        test33(sb3);
+        test33(sb4);
+        test33(sb5);
+        System.out.println("==========test34==========");
+        test34(sb1);
+        test34(sb2);
+        test34(sb3);
+        test34(sb4);
+        test34(sb5);
+        System.out.println("==========test35==========");
+        test35(sb1);
+        test35(sb2);
+        test35(sb3);
+        test35(sb4);
+        test35(sb5);
+        System.out.println("==========test36==========");
+        test36(sb1);
+        test36(sb2);
+        test36(sb3);
+        test36(sb4);
+        test36(sb5);
+        System.out.println("==========test37==========");
+        test37(sb1);
+        test37(sb2);
+        test37(sb3);
+        test37(sb4);
+        test37(sb5);
+        System.out.println("==========test38==========");
+        test38(sb1);
+        test38(sb2);
+        test38(sb3);
+        test38(sb4);
+        test38(sb5);
+        System.out.println("==========test39==========");
+        test39(sb1);
+        test39(sb2);
+        test39(sb3);
+        test39(sb4);
+        test39(sb5);
+        System.out.println("==========test40==========");
+        test40(sb1);
+        test40(sb2);
+        test40(sb3);
+        test40(sb4);
+        test40(sb5);
+        System.out.println("==========test41==========");
+        test41(sb1);
+        test41(sb2);
+        test41(sb3);
+        test41(sb4);
+        test41(sb5);
+        System.out.println("==========test42==========");
+        test42(sb1);
+        test42(sb2);
+        test42(sb3);
+        test42(sb4);
+        test42(sb5);
+        System.out.println("==========test43==========");
+        test43(sb1);
+        test43(sb2);
+        test43(sb3);
+        test43(sb4);
+        test43(sb5);
+        System.out.println("==========test44==========");
+        test44(sb1);
+        test44(sb2);
+        test44(sb3);
+        test44(sb4);
+        test44(sb5);
+        System.out.println("==========test45==========");
+        test45(sb1);
+        test45(sb2);
+        test45(sb3);
+        test45(sb4);
+        test45(sb5);
+        System.out.println("==========test46==========");
+        test46(sb1);
+        test46(sb2);
+        test46(sb3);
+        test46(sb4);
+        test46(sb5);
+        System.out.println("==========test47==========");
+        test47(sb1);
+        test47(sb2);
+        test47(sb3);
+        test47(sb4);
+        test47(sb5);
+        System.out.println("==========test48==========");
+        test48(sb1);
+        test48(sb2);
+        test48(sb3);
+        test48(sb4);
+        test48(sb5);
+        System.out.println("==========test49==========");
+        test49(sb1);
+        test49(sb2);
+        test49(sb3);
+        test49(sb4);
+        test49(sb5);
+        System.out.println("==========test50==========");
+        test50(sb1);
+        test50(sb2);
+        test50(sb3);
+        test50(sb4);
+        test50(sb5);
+    }
+    public static void test1(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {true};
+        try {
+            Method method = class1.getMethod("append", new Class[]{boolean.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test2(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {999999999};
+        try {
+            Method method = class1.getMethod("append", new Class[]{long.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test3(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {'I'};
+        try {
+            Method method = class1.getMethod("append", new Class[]{char.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test4(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {"I like Reading"};
+        try {
+            Method method = class1.getMethod("append", new Class[]{Object.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test5(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        char[] chars = {'a', 'b', 'c'};
+        Object[] objects = {chars, 0, 1};
+        try {
+            Method method = class1.getMethod("append", char[].class, int.class, int.class);
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test6(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {20.56};
+        try {
+            Method method = class1.getMethod("append", new Class[]{double.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test7(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        char[] chars = {'a', 'A'};
+        Object[] objects = {chars};
+        try {
+            Method method = class1.getMethod("append", new Class[]{char[].class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test8(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {"abcdefg"};
+        try {
+            Method method = class1.getMethod("append", new Class[]{String.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test9(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        StringBuffer str = new StringBuffer("str");
+        Object[] objects = {str};
+        try {
+            Method method = class1.getMethod("append", new Class[]{StringBuffer.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test10(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        float f = (float) 10.0;
+        Object[] objects = {f};
+        try {
+            Method method = class1.getMethod("append", new Class[]{float.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test11(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {100};
+        try {
+            Method method = class1.getMethod("append", new Class[]{int.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test12(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        CharSequence charSequence = new StringBuffer("LLL");
+        Object[] objects = {charSequence};
+        try {
+            Method method = class1.getMethod("append", new Class[]{CharSequence.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test13(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        int unicode = 0x5b57;// 追加unicode编码
+        Object[] objects = {unicode};
+        try {
+            Method method = class1.getMethod("appendCodePoint", new Class[]{int.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test14(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        //Object[] objects = {};
+        try {
+            Method method = class1.getMethod("capacity");
+            int sb = (int) method.invoke(stringBuffer);
+            System.out.println(sb);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test15(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {5};
+        try {
+            Method method = class1.getMethod("charAt", new Class[]{int.class});
+            char sb = (char) method.invoke(stringBuffer, objects);
+            System.out.println(sb);
+//            if ("9".equals(String.valueOf(sb))||"3".equals(String.valueOf(sb))||
+//                    " ".equals(String.valueOf(sb))||"9".equals(String.valueOf(sb))||"&".equals(String.valueOf(sb))){
+//
+//            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test16(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {5};
+        try {
+            Method method = class1.getMethod("codePointAt", new Class[]{int.class});
+            int sb = (int) method.invoke(stringBuffer, objects);
+            System.out.println(sb);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test17(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {5};
+        try {
+            Method method = class1.getMethod("codePointBefore", new Class[]{int.class});
+            int sb = (int) method.invoke(stringBuffer, objects);
+            System.out.println(sb);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test18(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {5, 8};
+        try {
+            Method method = class1.getMethod("codePointCount", new Class[]{int.class, int.class});
+            int sb = (int) method.invoke(stringBuffer, objects);
+            System.out.println(sb);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test19(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {1, 3};
+        try {
+            Method method = class1.getMethod("delete", new Class[]{int.class, int.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test20(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {5};
+        try {
+            Method method = class1.getMethod("deleteCharAt", new Class[]{int.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test21(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {50};
+        try {
+            Method method = class1.getMethod("ensureCapacity", new Class[]{int.class});
+            method.invoke(stringBuffer, objects);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test22(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        char[] chars = {'R', 'T', 'Y', 'U', 'P', 'W', 'X', 'F', 'J'};
+        Object[] objects = {2, 5, chars, 2};
+        try {
+            Method method = class1.getMethod("getChars", new Class[]{int.class, int.class, char[].class, int.class});
+            method.invoke(stringBuffer, objects);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test23(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {"9"};
+        try {
+            Method method = class1.getMethod("indexOf", new Class[]{String.class});
+            int index = (int) method.invoke(stringBuffer, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test24(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {"9", 1};
+        try {
+            Method method = class1.getMethod("indexOf", new Class[]{String.class, int.class});//从int位置往后开始数，该字符第一次出现的位置
+            int index = (int) method.invoke(stringBuffer, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test25(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        char[] chars = {'H', 'J', 'K', 'S'};
+        Object[] objects = {5, chars};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, char[].class});//从int位置往后开始数，该字符第一次出现的位置
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test26(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        float f = (float) 1.0;
+        Object[] objects = {5, f};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, float.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test27(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        CharSequence sequence = new StringBuffer("######");
+        Object[] objects = {5, sequence};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, CharSequence.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test28(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        char chars = '@';
+        Object[] objects = {5, chars};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, char.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test29(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {10, 888888888};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, long.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test30(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        char[] chars = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
+        Object[] objects = {15, chars, 0, 3};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, char[].class, int.class, int.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test31(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {5, 33333};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, int.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test32(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {0, "UUUUU"};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, String.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test33(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {0, 100.00};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, double.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test34(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        CharSequence sequence = new StringBuffer("YYYYYYYYYYY");
+        Object[] objects = {0, sequence, 0, 5};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, CharSequence.class, int.class, int.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test35(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {0, 77777};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, Object.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test36(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {0, false};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, boolean.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test37(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {"U", 50};
+        try {
+            Method method = class1.getMethod("lastIndexOf", new Class[]{String.class, int.class});//从指定的下标往前找，找指定字符串最后一次出现的位置
+            int index = (int) method.invoke(stringBuffer, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test38(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {"Y"};
+        try {
+            Method method = class1.getMethod("lastIndexOf", new Class[]{String.class});
+            int index = (int) method.invoke(stringBuffer, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test39(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {};
+        try {
+            Method method = class1.getMethod("length");
+            int index = (int) method.invoke(stringBuffer, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test40(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {0, 3};
+        try {
+            Method method = class1.getMethod("offsetByCodePoints", new Class[]{int.class, int.class});//返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。
+            int index = (int) method.invoke(stringBuffer, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test41(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {0, 5, "PPPPP"};
+        try {
+            Method method = class1.getMethod("replace", new Class[]{int.class, int.class, String.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test42(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        //Object[] objects = {};
+        try {
+            Method method = class1.getMethod("reverse");
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test43(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {0, '#'};
+        try {
+            Method method = class1.getMethod("setCharAt", new Class[]{int.class, char.class});
+            method.invoke(stringBuffer, objects);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test44(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {210};
+        try {
+            Method method = class1.getMethod("setLength", new Class[]{int.class});
+            method.invoke(stringBuffer, objects);
+            String var = stringBuffer.toString();
+            System.out.println(var.length());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test45(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {0, 5};
+        try {
+            Method method = class1.getMethod("subSequence", new Class[]{int.class, int.class});
+            CharSequence charSequence = (CharSequence) method.invoke(stringBuffer, objects);
+            System.out.println(charSequence);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test46(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        CharSequence charSequence = new StringBuffer("WWWWWWWWW");
+        Object[] objects = {charSequence, 0, 3};
+        try {
+            Method method = class1.getMethod("append", new Class[]{CharSequence.class, int.class, int.class});
+            StringBuffer sb = (StringBuffer) method.invoke(stringBuffer, objects);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test47(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {0, 5};
+        try {
+            Method method = class1.getMethod("substring", new Class[]{int.class, int.class});
+            String string = (String) method.invoke(stringBuffer, objects);
+            System.out.println(string);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test48(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        Object[] objects = {210};
+        try {
+            Method method = class1.getMethod("substring", new Class[]{int.class});
+            String string = (String) method.invoke(stringBuffer, objects);
+            System.out.println(string);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test49(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        //Object[] objects = {};
+        try {
+            Method method = class1.getMethod("toString");
+            String string = (String) method.invoke(stringBuffer);
+            //System.out.println(string);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test50(StringBuffer stringBuffer) {
+        Class class1 = stringBuffer.getClass();
+        //Object[] objects = {};
+        try {
+            Method method = class1.getMethod("trimToSize");//该方法的作用是将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费。
+            method.invoke(stringBuffer);
+            System.out.println(stringBuffer.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-RT0514-rt-String-StringReflectStringBufferAPITest/expected.txt b/testsuite/java_test/string_test/issue-RT0514-rt-String-StringReflectStringBufferAPITest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..009fe925d0412d05900edc4f4a23a732aa4b3b5c
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0514-rt-String-StringReflectStringBufferAPITest/expected.txt
@@ -0,0 +1,281 @@
+==========test1==========
+true
+abc123true
+      true
+true
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true
+==========test2==========
+true999999999
+abc123true999999999
+      true999999999
+true999999999
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999
+==========test3==========
+true999999999I
+abc123true999999999I
+      true999999999I
+true999999999I
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999I
+==========test4==========
+true999999999II like Reading
+abc123true999999999II like Reading
+      true999999999II like Reading
+true999999999II like Reading
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Reading
+==========test5==========
+true999999999II like Readinga
+abc123true999999999II like Readinga
+      true999999999II like Readinga
+true999999999II like Readinga
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga
+==========test6==========
+true999999999II like Readinga20.56
+abc123true999999999II like Readinga20.56
+      true999999999II like Readinga20.56
+true999999999II like Readinga20.56
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56
+==========test7==========
+true999999999II like Readinga20.56aA
+abc123true999999999II like Readinga20.56aA
+      true999999999II like Readinga20.56aA
+true999999999II like Readinga20.56aA
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aA
+==========test8==========
+true999999999II like Readinga20.56aAabcdefg
+abc123true999999999II like Readinga20.56aAabcdefg
+      true999999999II like Readinga20.56aAabcdefg
+true999999999II like Readinga20.56aAabcdefg
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefg
+==========test9==========
+true999999999II like Readinga20.56aAabcdefgstr
+abc123true999999999II like Readinga20.56aAabcdefgstr
+      true999999999II like Readinga20.56aAabcdefgstr
+true999999999II like Readinga20.56aAabcdefgstr
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr
+==========test10==========
+true999999999II like Readinga20.56aAabcdefgstr10.0
+abc123true999999999II like Readinga20.56aAabcdefgstr10.0
+      true999999999II like Readinga20.56aAabcdefgstr10.0
+true999999999II like Readinga20.56aAabcdefgstr10.0
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0
+==========test11==========
+true999999999II like Readinga20.56aAabcdefgstr10.0100
+abc123true999999999II like Readinga20.56aAabcdefgstr10.0100
+      true999999999II like Readinga20.56aAabcdefgstr10.0100
+true999999999II like Readinga20.56aAabcdefgstr10.0100
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100
+==========test12==========
+true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+abc123true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+      true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+==========test13==========
+true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+abc123true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+      true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test14==========
+70
+94
+94
+70
+222
+==========test15==========
+9
+3
+ 
+9
+&
+==========test16==========
+57
+51
+32
+57
+38
+==========test17==========
+57
+50
+32
+57
+37
+==========test18==========
+3
+3
+3
+3
+3
+==========test19==========
+te999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test20==========
+te99999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123tue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    tue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te99999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&')*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test21==========
+==========test22==========
+==========test23==========
+2
+7
+7
+2
+21
+==========test24==========
+2
+7
+7
+2
+21
+==========test25==========
+te999HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123tHJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    tHJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test26==========
+te9991.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te9991.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test27==========
+te999######1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t######1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t######1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999######1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'######1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test28==========
+te999@######1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t@######1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t@######1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999@######1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'@######1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test29==========
+te999@####888888888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t@####888888888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t@####888888888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999@####888888888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'@####888888888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test30==========
+te999@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test31==========
+te99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test32==========
+UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test33==========
+100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test34==========
+YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+YYYYY100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+YYYYY100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+YYYYY100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test35==========
+77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+77777YYYYY100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+77777YYYYY100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+77777YYYYY100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test36==========
+false77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+false77777YYYYY100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+false77777YYYYY100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+false77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+false77777YYYYY100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test37==========
+24
+24
+24
+24
+24
+==========test38==========
+14
+14
+14
+14
+109
+==========test39==========
+110
+116
+116
+110
+204
+==========test40==========
+3
+3
+3
+3
+3
+==========test41==========
+PPPPP77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+PPPPP77777YYYYY100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+PPPPP77777YYYYY100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+PPPPP77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+PPPPP77777YYYYY100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test42==========
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPP
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t321aUUUUU0.001YYYYY77777PPPPP
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t    UUUUU0.001YYYYY77777PPPPP
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPP
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999eurt~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)SKJH0.1##8888CBA88888####@33333'&%$!UUUUU0.001YYYYY77777PPPPP
+==========test43==========
+==========test44==========
+210
+210
+210
+210
+210
+==========test45==========
+#LLL0
+#LLL0
+#LLL0
+#LLL0
+#LLL0
+==========test46==========
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t321aUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t    UUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999eurt~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)SKJH0.1##8888CBA88888####@33333'&%$!UUUUU0.001YYYYY77777PPPPPWWW
+==========test47==========
+#LLL0
+#LLL0
+#LLL0
+#LLL0
+#LLL0
+==========test48==========
+WWW
+WWW
+WWW
+WWW
+WWW
+==========test49==========
+==========test50==========
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t321aUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t    UUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999eurt~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)SKJH0.1##8888CBA88888####@33333'&%$!UUUUU0.001YYYYY77777PPPPPWWW
+0
diff --git a/testsuite/java_test/string_test/issue-RT0514-rt-String-StringReflectStringBufferAPITest/test.cfg b/testsuite/java_test/string_test/issue-RT0514-rt-String-StringReflectStringBufferAPITest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..f22b4de1f5d7ebe93228dc9a943f767fc37dea9e
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0514-rt-String-StringReflectStringBufferAPITest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReflectStringBufferAPITest.java)
+run(StringReflectStringBufferAPI)
diff --git a/testsuite/java_test/string_test/issue-RT0515-rt-String-StringReflectStringBuilderAPITest/StringReflectStringBuilderAPITest.java b/testsuite/java_test/string_test/issue-RT0515-rt-String-StringReflectStringBuilderAPITest/StringReflectStringBuilderAPITest.java
new file mode 100755
index 0000000000000000000000000000000000000000..206085700d812cb009870ad52036336e89db4642
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0515-rt-String-StringReflectStringBuilderAPITest/StringReflectStringBuilderAPITest.java
@@ -0,0 +1,1306 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class StringReflectStringBuilderAPITest {
+//    private static int processResult = 599;
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+    public static int run(String[] args, PrintStream out) {
+        int result = 2;
+        try {
+            StringReflectStringBuilderAPITest1();
+            result = 0;
+        } catch (Exception e) {
+        }
+        return result;
+    }
+    public static void StringReflectStringBuilderAPITest1() {
+        StringBuilder sb1 = new StringBuilder();
+        StringBuilder sb2 = new StringBuilder("abc123");
+        StringBuilder sb3 = new StringBuilder("      ");
+        StringBuilder sb4 = new StringBuilder("");
+        StringBuilder sb5 = new StringBuilder("!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~");
+        System.out.println("==========test1==========");
+        test1(sb1);
+        test1(sb2);
+        test1(sb3);
+        test1(sb4);
+        test1(sb5);
+        System.out.println("==========test2==========");
+        test2(sb1);
+        test2(sb2);
+        test2(sb3);
+        test2(sb4);
+        test2(sb5);
+        System.out.println("==========test3==========");
+        test3(sb1);
+        test3(sb2);
+        test3(sb3);
+        test3(sb4);
+        test3(sb5);
+        System.out.println("==========test4==========");
+        test4(sb1);
+        test4(sb2);
+        test4(sb3);
+        test4(sb4);
+        test4(sb5);
+        System.out.println("==========test5==========");
+        test5(sb1);
+        test5(sb2);
+        test5(sb3);
+        test5(sb4);
+        test5(sb5);
+        System.out.println("==========test6==========");
+        test6(sb1);
+        test6(sb2);
+        test6(sb3);
+        test6(sb4);
+        test6(sb5);
+        System.out.println("==========test7==========");
+        test7(sb1);
+        test7(sb2);
+        test7(sb3);
+        test7(sb4);
+        test7(sb5);
+        System.out.println("==========test8==========");
+        test8(sb1);
+        test8(sb2);
+        test8(sb3);
+        test8(sb4);
+        test8(sb5);
+        System.out.println("==========test9==========");
+        test9(sb1);
+        test9(sb2);
+        test9(sb3);
+        test9(sb4);
+        test9(sb5);
+        System.out.println("==========test10==========");
+        test10(sb1);
+        test10(sb2);
+        test10(sb3);
+        test10(sb4);
+        test10(sb5);
+        System.out.println("==========test11==========");
+        test11(sb1);
+        test11(sb2);
+        test11(sb3);
+        test11(sb4);
+        test11(sb5);
+        System.out.println("==========test12==========");
+        test12(sb1);
+        test12(sb2);
+        test12(sb3);
+        test12(sb4);
+        test12(sb5);
+        System.out.println("==========test13==========");
+        test13(sb1);
+        test13(sb2);
+        test13(sb3);
+        test13(sb4);
+        test13(sb5);
+        System.out.println("==========test14==========");
+        test14(sb1);
+        test14(sb2);
+        test14(sb3);
+        test14(sb4);
+        test14(sb5);
+        System.out.println("==========test15==========");
+        test15(sb1);
+        test15(sb2);
+        test15(sb3);
+        test15(sb4);
+        test15(sb5);
+        System.out.println("==========test16==========");
+        test16(sb1);
+        test16(sb2);
+        test16(sb3);
+        test16(sb4);
+        test16(sb5);
+        System.out.println("==========test17==========");
+        test17(sb1);
+        test17(sb2);
+        test17(sb3);
+        test17(sb4);
+        test17(sb5);
+        System.out.println("==========test18==========");
+        test18(sb1);
+        test18(sb2);
+        test18(sb3);
+        test18(sb4);
+        test18(sb5);
+        System.out.println("==========test19==========");
+        test19(sb1);
+        test19(sb2);
+        test19(sb3);
+        test19(sb4);
+        test19(sb5);
+        System.out.println("==========test20==========");
+        test20(sb1);
+        test20(sb2);
+        test20(sb3);
+        test20(sb4);
+        test20(sb5);
+        System.out.println("==========test21==========");
+        test21(sb1);
+        test21(sb2);
+        test21(sb3);
+        test21(sb4);
+        test21(sb5);
+        System.out.println("==========test22==========");
+        test22(sb1);
+        test22(sb2);
+        test22(sb3);
+        test22(sb4);
+        test22(sb5);
+        System.out.println("==========test23==========");
+        test23(sb1);
+        test23(sb2);
+        test23(sb3);
+        test23(sb4);
+        test23(sb5);
+        System.out.println("==========test24==========");
+        test24(sb1);
+        test24(sb2);
+        test24(sb3);
+        test24(sb4);
+        test24(sb5);
+        System.out.println("==========test25==========");
+        test25(sb1);
+        test25(sb2);
+        test25(sb3);
+        test25(sb4);
+        test25(sb5);
+        System.out.println("==========test26==========");
+        test26(sb1);
+        test26(sb2);
+        test26(sb3);
+        test26(sb4);
+        test26(sb5);
+        System.out.println("==========test27==========");
+        test27(sb1);
+        test27(sb2);
+        test27(sb3);
+        test27(sb4);
+        test27(sb5);
+        System.out.println("==========test28==========");
+        test28(sb1);
+        test28(sb2);
+        test28(sb3);
+        test28(sb4);
+        test28(sb5);
+        System.out.println("==========test29==========");
+        test29(sb1);
+        test29(sb2);
+        test29(sb3);
+        test29(sb4);
+        test29(sb5);
+        System.out.println("==========test30==========");
+        test30(sb1);
+        test30(sb2);
+        test30(sb3);
+        test30(sb4);
+        test30(sb5);
+        System.out.println("==========test31==========");
+        test31(sb1);
+        test31(sb2);
+        test31(sb3);
+        test31(sb4);
+        test31(sb5);
+        System.out.println("==========test32==========");
+        test32(sb1);
+        test32(sb2);
+        test32(sb3);
+        test32(sb4);
+        test32(sb5);
+        System.out.println("==========test33==========");
+        test33(sb1);
+        test33(sb2);
+        test33(sb3);
+        test33(sb4);
+        test33(sb5);
+        System.out.println("==========test34==========");
+        test34(sb1);
+        test34(sb2);
+        test34(sb3);
+        test34(sb4);
+        test34(sb5);
+        System.out.println("==========test35==========");
+        test35(sb1);
+        test35(sb2);
+        test35(sb3);
+        test35(sb4);
+        test35(sb5);
+        System.out.println("==========test36==========");
+        test36(sb1);
+        test36(sb2);
+        test36(sb3);
+        test36(sb4);
+        test36(sb5);
+        System.out.println("==========test37==========");
+        test37(sb1);
+        test37(sb2);
+        test37(sb3);
+        test37(sb4);
+        test37(sb5);
+        System.out.println("==========test38==========");
+        test38(sb1);
+        test38(sb2);
+        test38(sb3);
+        test38(sb4);
+        test38(sb5);
+        System.out.println("==========test39==========");
+        test39(sb1);
+        test39(sb2);
+        test39(sb3);
+        test39(sb4);
+        test39(sb5);
+        System.out.println("==========test40==========");
+        test40(sb1);
+        test40(sb2);
+        test40(sb3);
+        test40(sb4);
+        test40(sb5);
+        System.out.println("==========test41==========");
+        test41(sb1);
+        test41(sb2);
+        test41(sb3);
+        test41(sb4);
+        test41(sb5);
+        System.out.println("==========test42==========");
+        test42(sb1);
+        test42(sb2);
+        test42(sb3);
+        test42(sb4);
+        test42(sb5);
+        System.out.println("==========test43==========");
+        test43(sb1);
+        test43(sb2);
+        test43(sb3);
+        test43(sb4);
+        test43(sb5);
+        System.out.println("==========test44==========");
+        test44(sb1);
+        test44(sb2);
+        test44(sb3);
+        test44(sb4);
+        test44(sb5);
+        System.out.println("==========test45==========");
+        test45(sb1);
+        test45(sb2);
+        test45(sb3);
+        test45(sb4);
+        test45(sb5);
+        System.out.println("==========test46==========");
+        test46(sb1);
+        test46(sb2);
+        test46(sb3);
+        test46(sb4);
+        test46(sb5);
+        System.out.println("==========test47==========");
+        test47(sb1);
+        test47(sb2);
+        test47(sb3);
+        test47(sb4);
+        test47(sb5);
+        System.out.println("==========test48==========");
+        test48(sb1);
+        test48(sb2);
+        test48(sb3);
+        test48(sb4);
+        test48(sb5);
+        System.out.println("==========test49==========");
+        test49(sb1);
+        test49(sb2);
+        test49(sb3);
+        test49(sb4);
+        test49(sb5);
+        System.out.println("==========test50==========");
+        test50(sb1);
+        test50(sb2);
+        test50(sb3);
+        test50(sb4);
+        test50(sb5);
+    }
+    public static void test1(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {true};
+        try {
+            Method method = class1.getMethod("append", new Class[]{boolean.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test2(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {999999999};
+        try {
+            Method method = class1.getMethod("append", new Class[]{long.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test3(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {'I'};
+        try {
+            Method method = class1.getMethod("append", new Class[]{char.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test4(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {"I like Reading"};
+        try {
+            Method method = class1.getMethod("append", new Class[]{Object.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test5(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        char[] chars = {'a', 'b', 'c'};
+        Object[] objects = {chars, 0, 1};
+        try {
+            Method method = class1.getMethod("append", char[].class, int.class, int.class);
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test6(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {20.56};
+        try {
+            Method method = class1.getMethod("append", new Class[]{double.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test7(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        char[] chars = {'a', 'A'};
+        Object[] objects = {chars};
+        try {
+            Method method = class1.getMethod("append", new Class[]{char[].class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test8(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {"abcdefg"};
+        try {
+            Method method = class1.getMethod("append", new Class[]{String.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test9(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        StringBuffer str = new StringBuffer("str");
+        Object[] objects = {str};
+        try {
+            Method method = class1.getMethod("append", new Class[]{StringBuffer.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test10(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        float f = (float) 10.0;
+        Object[] objects = {f};
+        try {
+            Method method = class1.getMethod("append", new Class[]{float.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test11(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {100};
+        try {
+            Method method = class1.getMethod("append", new Class[]{int.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test12(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        CharSequence charSequence = new StringBuilder("LLL");
+        Object[] objects = {charSequence};
+        try {
+            Method method = class1.getMethod("append", new Class[]{CharSequence.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test13(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        int unicode = 0x5b57;// 追加unicode编码
+        Object[] objects = {unicode};
+        try {
+            Method method = class1.getMethod("appendCodePoint", new Class[]{int.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test14(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        //Object[] objects = {};
+        try {
+            Method method = class1.getMethod("capacity");
+            int sb = (int) method.invoke(StringBuilder);
+            System.out.println(sb);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test15(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {5};
+        try {
+            Method method = class1.getMethod("charAt", new Class[]{int.class});
+            char sb = (char) method.invoke(StringBuilder, objects);
+            System.out.println(sb);
+//            if ("9".equals(String.valueOf(sb))||"3".equals(String.valueOf(sb))||
+//                    " ".equals(String.valueOf(sb))||"9".equals(String.valueOf(sb))||"&".equals(String.valueOf(sb))){
+//
+//            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test16(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {5};
+        try {
+            Method method = class1.getMethod("codePointAt", new Class[]{int.class});
+            int sb = (int) method.invoke(StringBuilder, objects);
+            System.out.println(sb);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test17(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {5};
+        try {
+            Method method = class1.getMethod("codePointBefore", new Class[]{int.class});
+            int sb = (int) method.invoke(StringBuilder, objects);
+            System.out.println(sb);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test18(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {5, 8};
+        try {
+            Method method = class1.getMethod("codePointCount", new Class[]{int.class, int.class});
+            int sb = (int) method.invoke(StringBuilder, objects);
+            System.out.println(sb);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test19(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {1, 3};
+        try {
+            Method method = class1.getMethod("delete", new Class[]{int.class, int.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test20(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {5};
+        try {
+            Method method = class1.getMethod("deleteCharAt", new Class[]{int.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test21(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {50};
+        try {
+            Method method = class1.getMethod("ensureCapacity", new Class[]{int.class});
+            method.invoke(StringBuilder, objects);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test22(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        char[] chars = {'R', 'T', 'Y', 'U', 'P', 'W', 'X', 'F', 'J'};
+        Object[] objects = {2, 5, chars, 2};
+        try {
+            Method method = class1.getMethod("getChars", new Class[]{int.class, int.class, char[].class, int.class});
+            method.invoke(StringBuilder, objects);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test23(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {"9"};
+        try {
+            Method method = class1.getMethod("indexOf", new Class[]{String.class});
+            int index = (int) method.invoke(StringBuilder, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test24(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {"9", 1};
+        try {
+            Method method = class1.getMethod("indexOf", new Class[]{String.class, int.class});//从int位置往后开始数，该字符第一次出现的位置
+            int index = (int) method.invoke(StringBuilder, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test25(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        char[] chars = {'H', 'J', 'K', 'S'};
+        Object[] objects = {5, chars};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, char[].class});//从int位置往后开始数，该字符第一次出现的位置
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test26(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        float f = (float) 1.0;
+        Object[] objects = {5, f};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, float.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test27(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        CharSequence sequence = new StringBuilder("######");
+        Object[] objects = {5, sequence};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, CharSequence.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test28(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        char chars = '@';
+        Object[] objects = {5, chars};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, char.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test29(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {10, 888888888};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, long.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test30(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        char[] chars = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
+        Object[] objects = {15, chars, 0, 3};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, char[].class, int.class, int.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test31(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {5, 33333};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, int.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test32(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {0, "UUUUU"};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, String.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test33(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {0, 100.00};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, double.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test34(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        CharSequence sequence = new StringBuilder("YYYYYYYYYYY");
+        Object[] objects = {0, sequence, 0, 5};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, CharSequence.class, int.class, int.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test35(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {0, 77777};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, Object.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test36(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {0, false};
+        try {
+            Method method = class1.getMethod("insert", new Class[]{int.class, boolean.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test37(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {"U", 50};
+        try {
+            Method method = class1.getMethod("lastIndexOf", new Class[]{String.class, int.class});//从指定的下标往前找，找指定字符串最后一次出现的位置
+            int index = (int) method.invoke(StringBuilder, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test38(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {"Y"};
+        try {
+            Method method = class1.getMethod("lastIndexOf", new Class[]{String.class});
+            int index = (int) method.invoke(StringBuilder, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test39(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {};
+        try {
+            Method method = class1.getMethod("length");
+            int index = (int) method.invoke(StringBuilder, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test40(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {0, 3};
+        try {
+            Method method = class1.getMethod("offsetByCodePoints", new Class[]{int.class, int.class});//返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。
+            int index = (int) method.invoke(StringBuilder, objects);
+            System.out.println(index);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test41(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {0, 5, "PPPPP"};
+        try {
+            Method method = class1.getMethod("replace", new Class[]{int.class, int.class, String.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test42(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        //Object[] objects = {};
+        try {
+            Method method = class1.getMethod("reverse");
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test43(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {0, '#'};
+        try {
+            Method method = class1.getMethod("setCharAt", new Class[]{int.class, char.class});
+            method.invoke(StringBuilder, objects);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test44(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {210};
+        try {
+            Method method = class1.getMethod("setLength", new Class[]{int.class});
+            method.invoke(StringBuilder, objects);
+            String var = StringBuilder.toString();
+            System.out.println(var.length());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test45(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {0, 5};
+        try {
+            Method method = class1.getMethod("subSequence", new Class[]{int.class, int.class});
+            CharSequence charSequence = (CharSequence) method.invoke(StringBuilder, objects);
+            System.out.println(charSequence);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test46(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        CharSequence charSequence = new StringBuilder("WWWWWWWWW");
+        Object[] objects = {charSequence, 0, 3};
+        try {
+            Method method = class1.getMethod("append", new Class[]{CharSequence.class, int.class, int.class});
+            StringBuilder sb = (StringBuilder) method.invoke(StringBuilder, objects);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test47(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {0, 5};
+        try {
+            Method method = class1.getMethod("substring", new Class[]{int.class, int.class});
+            String string = (String) method.invoke(StringBuilder, objects);
+            System.out.println(string);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test48(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        Object[] objects = {210};
+        try {
+            Method method = class1.getMethod("substring", new Class[]{int.class});
+            String string = (String) method.invoke(StringBuilder, objects);
+            System.out.println(string);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test49(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        //Object[] objects = {};
+        try {
+            Method method = class1.getMethod("toString");
+            String string = (String) method.invoke(StringBuilder);
+            //System.out.println(string);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void test50(StringBuilder StringBuilder) {
+        Class class1 = StringBuilder.getClass();
+        //Object[] objects = {};
+        try {
+            Method method = class1.getMethod("trimToSize");//该方法的作用是将StringBuilder对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费。
+            method.invoke(StringBuilder);
+            System.out.println(StringBuilder.toString());
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-RT0515-rt-String-StringReflectStringBuilderAPITest/expected.txt b/testsuite/java_test/string_test/issue-RT0515-rt-String-StringReflectStringBuilderAPITest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..009fe925d0412d05900edc4f4a23a732aa4b3b5c
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0515-rt-String-StringReflectStringBuilderAPITest/expected.txt
@@ -0,0 +1,281 @@
+==========test1==========
+true
+abc123true
+      true
+true
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true
+==========test2==========
+true999999999
+abc123true999999999
+      true999999999
+true999999999
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999
+==========test3==========
+true999999999I
+abc123true999999999I
+      true999999999I
+true999999999I
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999I
+==========test4==========
+true999999999II like Reading
+abc123true999999999II like Reading
+      true999999999II like Reading
+true999999999II like Reading
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Reading
+==========test5==========
+true999999999II like Readinga
+abc123true999999999II like Readinga
+      true999999999II like Readinga
+true999999999II like Readinga
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga
+==========test6==========
+true999999999II like Readinga20.56
+abc123true999999999II like Readinga20.56
+      true999999999II like Readinga20.56
+true999999999II like Readinga20.56
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56
+==========test7==========
+true999999999II like Readinga20.56aA
+abc123true999999999II like Readinga20.56aA
+      true999999999II like Readinga20.56aA
+true999999999II like Readinga20.56aA
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aA
+==========test8==========
+true999999999II like Readinga20.56aAabcdefg
+abc123true999999999II like Readinga20.56aAabcdefg
+      true999999999II like Readinga20.56aAabcdefg
+true999999999II like Readinga20.56aAabcdefg
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefg
+==========test9==========
+true999999999II like Readinga20.56aAabcdefgstr
+abc123true999999999II like Readinga20.56aAabcdefgstr
+      true999999999II like Readinga20.56aAabcdefgstr
+true999999999II like Readinga20.56aAabcdefgstr
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr
+==========test10==========
+true999999999II like Readinga20.56aAabcdefgstr10.0
+abc123true999999999II like Readinga20.56aAabcdefgstr10.0
+      true999999999II like Readinga20.56aAabcdefgstr10.0
+true999999999II like Readinga20.56aAabcdefgstr10.0
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0
+==========test11==========
+true999999999II like Readinga20.56aAabcdefgstr10.0100
+abc123true999999999II like Readinga20.56aAabcdefgstr10.0100
+      true999999999II like Readinga20.56aAabcdefgstr10.0100
+true999999999II like Readinga20.56aAabcdefgstr10.0100
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100
+==========test12==========
+true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+abc123true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+      true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL
+==========test13==========
+true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+abc123true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+      true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test14==========
+70
+94
+94
+70
+222
+==========test15==========
+9
+3
+ 
+9
+&
+==========test16==========
+57
+51
+32
+57
+38
+==========test17==========
+57
+50
+32
+57
+37
+==========test18==========
+3
+3
+3
+3
+3
+==========test19==========
+te999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test20==========
+te99999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123tue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    tue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te99999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&')*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test21==========
+==========test22==========
+==========test23==========
+2
+7
+7
+2
+21
+==========test24==========
+2
+7
+7
+2
+21
+==========test25==========
+te999HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123tHJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    tHJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test26==========
+te9991.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te9991.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test27==========
+te999######1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t######1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t######1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999######1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'######1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test28==========
+te999@######1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t@######1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t@######1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999@######1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'@######1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test29==========
+te999@####888888888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t@####888888888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t@####888888888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999@####888888888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'@####888888888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test30==========
+te999@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te999@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test31==========
+te99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+a123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+te99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test32==========
+UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test33==========
+100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test34==========
+YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+YYYYY100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+YYYYY100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+YYYYY100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test35==========
+77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+77777YYYYY100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+77777YYYYY100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+77777YYYYY100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test36==========
+false77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+false77777YYYYY100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+false77777YYYYY100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+false77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+false77777YYYYY100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test37==========
+24
+24
+24
+24
+24
+==========test38==========
+14
+14
+14
+14
+109
+==========test39==========
+110
+116
+116
+110
+204
+==========test40==========
+3
+3
+3
+3
+3
+==========test41==========
+PPPPP77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+PPPPP77777YYYYY100.0UUUUUa123t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+PPPPP77777YYYYY100.0UUUUU    t33333@####88888ABC8888##1.0HJKSue999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+PPPPP77777YYYYY100.0UUUUUte99933333@####88888ABC8888##1.0HJKS99999II like Readinga20.56aAabcdefgstr10.0100LLL字
+PPPPP77777YYYYY100.0UUUUU!$%&'33333@####88888ABC8888##1.0HJKS)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~true999999999II like Readinga20.56aAabcdefgstr10.0100LLL字
+==========test42==========
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPP
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t321aUUUUU0.001YYYYY77777PPPPP
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t    UUUUU0.001YYYYY77777PPPPP
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPP
+字LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999eurt~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)SKJH0.1##8888CBA88888####@33333'&%$!UUUUU0.001YYYYY77777PPPPP
+==========test43==========
+==========test44==========
+210
+210
+210
+210
+210
+==========test45==========
+#LLL0
+#LLL0
+#LLL0
+#LLL0
+#LLL0
+==========test46==========
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t321aUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t    UUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999eurt~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)SKJH0.1##8888CBA88888####@33333'&%$!UUUUU0.001YYYYY77777PPPPPWWW
+==========test47==========
+#LLL0
+#LLL0
+#LLL0
+#LLL0
+#LLL0
+==========test48==========
+WWW
+WWW
+WWW
+WWW
+WWW
+==========test49==========
+==========test50==========
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t321aUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999euSKJH0.1##8888CBA88888####@33333t    UUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II99999SKJH0.1##8888CBA88888####@33333999etUUUUU0.001YYYYY77777PPPPPWWW
+#LLL0010.01rtsgfedcbaAa65.02agnidaeR ekil II999999999eurt~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)SKJH0.1##8888CBA88888####@33333'&%$!UUUUU0.001YYYYY77777PPPPPWWW
+0
diff --git a/testsuite/java_test/string_test/issue-RT0515-rt-String-StringReflectStringBuilderAPITest/test.cfg b/testsuite/java_test/string_test/issue-RT0515-rt-String-StringReflectStringBuilderAPITest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e4da3fa3a2213a4d22dff8a86b8b8580f8252958
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0515-rt-String-StringReflectStringBuilderAPITest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringReflectStringBuilderAPITest.java)
+run(StringReflectStringBuilderAPITest)
diff --git a/testsuite/java_test/string_test/issue-RT0818-rt-String-StringOOMTest/StringOOMTest.java b/testsuite/java_test/string_test/issue-RT0818-rt-String-StringOOMTest/StringOOMTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..dab5a07c4db649b7f2d9a1aa22b23a45b3b48c5a
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0818-rt-String-StringOOMTest/StringOOMTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class StringOOMTest {
+    private static int processResult = 99;
+    public static void main(String[] argv) {
+        System.out.println(run(argv, System.out));
+    }
+    public static int run(String argv[],PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = result-StringOOMTest_1();
+//            result = result-StringOOMTest_2(); time out
+        } catch(Exception e){
+            System.out.println(e);
+            processResult = processResult - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(StringOOMTest.res);
+        if (result == 1 && processResult == 97){
+            result =0;
+        }
+        return result;
+    }
+    public static  int StringOOMTest_1() {
+        int result1 = 4; /*STATUS_FAILED*/
+        int length=1024*1024*5120;// 1024*1024*1B=1M,*512=512M,set as 1024*1024*5120
+        try {
+            String[] s;
+            s = new String[ length ];
+            s [0] = "a" ;//if no this,y = new int[] will be optimizated and deleted.
+//            System.out.println("s: "+ Arrays.toString(s));
+        } catch (OutOfMemoryError e) {
+            processResult = processResult - 2;
+            return 1;
+        }
+        processResult = processResult - 10;
+        return 40;
+    }
+    public static  int StringOOMTest_2() {
+        int result1 = 4; /*STATUS_FAILED*/
+        int loop = 2147483647; // set as 2147483647
+//        String[] s= new String[loop];
+        String s=null;
+        while(loop >0 ) {
+            loop--;
+            try {
+                s = new String(Integer.toBinaryString(loop));
+            } catch (OutOfMemoryError e) {
+                processResult = processResult - 2;
+                return 1;
+            }
+        }
+        System.out.println("s: "+ s);
+        processResult = processResult - 10;
+        return 40;
+    }
+}
diff --git a/testsuite/java_test/string_test/issue-RT0818-rt-String-StringOOMTest/expected.txt b/testsuite/java_test/string_test/issue-RT0818-rt-String-StringOOMTest/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0818-rt-String-StringOOMTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/string_test/issue-RT0818-rt-String-StringOOMTest/test.cfg b/testsuite/java_test/string_test/issue-RT0818-rt-String-StringOOMTest/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..8bbbb3cd41e954af59e6f8b0a55b0839326f8a41
--- /dev/null
+++ b/testsuite/java_test/string_test/issue-RT0818-rt-String-StringOOMTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StringOOMTest.java)
+run(StringOOMTest)
diff --git a/testsuite/java_test/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/LiverangeSubsumeRCTest01.java b/testsuite/java_test/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/LiverangeSubsumeRCTest01.java
new file mode 100755
index 0000000000000000000000000000000000000000..e1c591431b4b5655ef0113d62fbf9ddd980c2e46
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/LiverangeSubsumeRCTest01.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest01 {
+    public static void main(String[] args) {
+        int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int[] array2 = array1;
+        String str1 = "ExpectResult";
+        String str2 = str1;
+        try {
+            if (array2[10] == array1[10]) {
+                System.out.print(str2); // 错误输出
+            }
+        } catch (Exception e) {
+            System.out.println(str1);
+        }
+    }
+}
diff --git a/testsuite/java_test/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/expected.txt b/testsuite/java_test/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/test.cfg b/testsuite/java_test/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e9bf44d308422e0b13af012f536bf06b45ed1928
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0001-rt-compiler-LiverangeSubsumeRCTest01/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest01,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest01)
diff --git a/testsuite/java_test/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/LiverangeSubsumeRCTest02.java b/testsuite/java_test/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/LiverangeSubsumeRCTest02.java
new file mode 100755
index 0000000000000000000000000000000000000000..d54337a69fd9f4d802eb6103f86924d3b55949d3
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/LiverangeSubsumeRCTest02.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest02 {
+    public static void main(String[] args) {
+        int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int[] array2 = array1;
+        String str1 = "ExpectResult";
+        String str2 = str1; //被优化掉了
+        try {
+            if (array1[10] == array2[10]) {
+                System.out.print(str1); // 错误输出
+            }
+        } catch (Exception e) {
+            System.out.println(str2);
+        }
+    }
+}
diff --git a/testsuite/java_test/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/expected.txt b/testsuite/java_test/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/test.cfg b/testsuite/java_test/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..7f00fa228855e9bebe32c02dfa1ba80f108fe331
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0002-rt-compiler-LiverangeSubsumeRCTest02/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest02,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest02)
diff --git a/testsuite/java_test/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/LiverangeSubsumeRCTest03.java b/testsuite/java_test/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/LiverangeSubsumeRCTest03.java
new file mode 100755
index 0000000000000000000000000000000000000000..194f50df2f718e875a0a429c48c610ab947bb34f
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/LiverangeSubsumeRCTest03.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest03 {
+    public static void main(String[] args) {
+        int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int[] array2 = array1;
+        int[] array3 = array2;
+        String str1 = "ExpectResult";
+        String str2 = str1;
+        String str3 = str2;
+        boolean check = String.valueOf(array2[0]).equals(str2); // false
+        System.out.print(check);
+        check = String.valueOf(array3[1]) == str3;
+        System.out.print(check); // false
+        if (array1.length == 10) {
+            System.out.println(str1);
+        } else {
+            System.out.print(str1); // 错误输出，无换行符
+        }
+    }
+}
diff --git a/testsuite/java_test/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/expected.txt b/testsuite/java_test/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..a69f80a240f7908f3ed4a9dc495b1de7657716ef
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/expected.txt
@@ -0,0 +1 @@
+falsefalseExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/test.cfg b/testsuite/java_test/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..a01bd237c989e1a11a4549503df72326e9384639
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0003-rt-compiler-LiverangeSubsumeRCTest03/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest03,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest03)
diff --git a/testsuite/java_test/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/LiverangeSubsumeRCTest04.java b/testsuite/java_test/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/LiverangeSubsumeRCTest04.java
new file mode 100755
index 0000000000000000000000000000000000000000..ed9564bef0458a4f853f8b926a266eafb663b65f
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/LiverangeSubsumeRCTest04.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest04 {
+    public static void main(String[] args) {
+        rc_testcase_main_wrapper();
+    }
+    private static void rc_testcase_main_wrapper() {
+        LiverangeSubsumeRCTest04_A1 a1_main = new LiverangeSubsumeRCTest04_A1("a1_main");
+        LiverangeSubsumeRCTest04_A2 a2_main = new LiverangeSubsumeRCTest04_A2("a2_main");
+        LiverangeSubsumeRCTest04_A3 a3_main = new LiverangeSubsumeRCTest04_A3("a3_main");
+        LiverangeSubsumeRCTest04_A4 a4_main = new LiverangeSubsumeRCTest04_A4("a4_main");
+        LiverangeSubsumeRCTest04_A5 a5_main = new LiverangeSubsumeRCTest04_A5("a5_main");
+        LiverangeSubsumeRCTest04_A6 a6_main = new LiverangeSubsumeRCTest04_A6("a6_main");
+        LiverangeSubsumeRCTest04_A7 a7_main = new LiverangeSubsumeRCTest04_A7("a7_main");
+        LiverangeSubsumeRCTest04_A8 a8_main = new LiverangeSubsumeRCTest04_A8("a8_main");
+        LiverangeSubsumeRCTest04_A9 a9_main = new LiverangeSubsumeRCTest04_A9("a9_main");
+        LiverangeSubsumeRCTest04_A10 a10_main = new LiverangeSubsumeRCTest04_A10("a10_main");
+        LiverangeSubsumeRCTest04_B1 b1 = new LiverangeSubsumeRCTest04_B1("b1_0");
+        a1_main.b1_0 = b1;
+        a2_main.b1_0 = b1;
+        a3_main.b1_0 = b1;
+        a4_main.b1_0 = b1;
+        a5_main.b1_0 = b1;
+        a6_main.b1_0 = b1;
+        a7_main.b1_0 = b1;
+        a8_main.b1_0 = b1;
+        a9_main.b1_0 = b1;
+        a10_main.b1_0 = b1;
+        a1_main.add();
+        a2_main.add();
+        a3_main.add();
+        a4_main.add();
+        a5_main.add();
+        a6_main.add();
+        a7_main.add();
+        a8_main.add();
+        a9_main.add();
+        a10_main.add();
+        b1.add();
+        int result = a1_main.sum + a2_main.sum + a3_main.sum + a4_main.sum + a5_main.sum + a6_main.sum + a7_main.sum + a8_main.sum + a9_main.sum + a10_main.sum + b1.sum;
+        if (result == 3467)
+            System.out.println("ExpectResult");
+    }
+}
+class LiverangeSubsumeRCTest04_A1 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A1(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A1_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_A2 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A2(String strObjectName) {
+        b1_0 = null;
+        a = 102;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A2_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_A3 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A3(String strObjectName) {
+        b1_0 = null;
+        a = 103;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A3_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_A4 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A4(String strObjectName) {
+        b1_0 = null;
+        a = 104;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A4_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_A5 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A5(String strObjectName) {
+        b1_0 = null;
+        a = 105;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A5_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_A6 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A6(String strObjectName) {
+        b1_0 = null;
+        a = 106;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A6_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_A7 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A7(String strObjectName) {
+        b1_0 = null;
+        a = 107;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A7_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_A8 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A8(String strObjectName) {
+        b1_0 = null;
+        a = 108;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A8_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_A9 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A9(String strObjectName) {
+        b1_0 = null;
+        a = 109;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A9_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_A10 {
+    LiverangeSubsumeRCTest04_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_A10(String strObjectName) {
+        b1_0 = null;
+        a = 110;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_A10_"+strObjectName);
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest04_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest04_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/expected.txt b/testsuite/java_test/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/test.cfg b/testsuite/java_test/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..9f7e6f112909fc0e738f0f8b216c4e07bd5d3ba8
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0004-rt-compiler-LiverangeSubsumeRCTest04/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest04,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest04)
diff --git a/testsuite/java_test/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/LiverangeSubsumeRCTest05.java b/testsuite/java_test/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/LiverangeSubsumeRCTest05.java
new file mode 100755
index 0000000000000000000000000000000000000000..9d54e79b8df8cddf09aca38752c77014c459839a
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/LiverangeSubsumeRCTest05.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest05 {
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest05_Node test1 = new LiverangeSubsumeRCTest05_Node("test1");
+        LiverangeSubsumeRCTest05_Node test2 = new LiverangeSubsumeRCTest05_Node("test2");
+        LiverangeSubsumeRCTest05_Node test3 = new LiverangeSubsumeRCTest05_Node("test3");
+        LiverangeSubsumeRCTest05_Node test4 = new LiverangeSubsumeRCTest05_Node("test4");
+        LiverangeSubsumeRCTest05_B1 b1 = new LiverangeSubsumeRCTest05_B1("b1");
+        test1.b1_0 = b1;
+        test2.b1_0 = b1;
+        test3.b1_0 = b1;
+        test4.b1_0 = b1;
+        test1.b1_0.add();
+        test2.b1_0.add();
+        test3.b1_0.add();
+        test4.b1_0.add();
+        b1.add();
+        int result = test1.sum + test2.sum + test3.sum + test4.sum + test4.b1_0.sum;
+        if (result == 402) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+class LiverangeSubsumeRCTest05_Node {
+    LiverangeSubsumeRCTest05_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest05_Node(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest05_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest05_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/expected.txt b/testsuite/java_test/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/test.cfg b/testsuite/java_test/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..464d9e57ccb53fa5efea93c2aeefee384de88a3f
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0005-rt-compiler-LiverangeSubsumeRCTest05/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest05,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest05)
diff --git a/testsuite/java_test/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/LiverangeSubsumeRCTest06.java b/testsuite/java_test/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/LiverangeSubsumeRCTest06.java
new file mode 100755
index 0000000000000000000000000000000000000000..03a895d581b17689b794d5127c63bc743a6ac802
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/LiverangeSubsumeRCTest06.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest06 {
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest06_Node test1 = new LiverangeSubsumeRCTest06_Node("test1");
+        LiverangeSubsumeRCTest06_Node test2 = test1;
+        LiverangeSubsumeRCTest06_Node test3 = test1;
+        LiverangeSubsumeRCTest06_Node test4 = test1;
+        LiverangeSubsumeRCTest06_B1 b1 = new LiverangeSubsumeRCTest06_B1("b1");
+        test2.b1_0 = b1;
+        test2.b1_0.add();
+        test3.b1_0 = b1;
+        test3.b1_0.add();
+        test4.b1_0 = b1;
+        test4.b1_0.add();
+        test1.b1_0 = b1;
+        test1.b1_0.add();
+        int result = test1.sum + b1.sum;
+        if (result == 402) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
+class LiverangeSubsumeRCTest06_Node {
+    LiverangeSubsumeRCTest06_B1 b1_0;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest06_Node(String strObjectName) {
+        b1_0 = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    void add() {
+        sum = a + b1_0.a;
+    }
+}
+class LiverangeSubsumeRCTest06_B1 {
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest06_B1(String strObjectName) {
+        a = 201;
+        sum = 0;
+        this.strObjectName = strObjectName;
+//	    System.out.println("RC-Testing_Construction_B1_"+strObjectName);
+    }
+    void add() {
+        sum = a + a;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/expected.txt b/testsuite/java_test/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/test.cfg b/testsuite/java_test/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d26d67c301795deaacbac5a9900c37ecddfdb6f4
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0006-rt-compiler-LiverangeSubsumeRCTest06/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest06,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest06)
diff --git a/testsuite/java_test/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/LiverangeSubsumeRCTest07.java b/testsuite/java_test/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/LiverangeSubsumeRCTest07.java
new file mode 100755
index 0000000000000000000000000000000000000000..b949d7ad7db1af215721a7818ece9c4e940b35fa
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/LiverangeSubsumeRCTest07.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest07 {
+    LiverangeSubsumeRCTest07 next;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest07(String strObjectName) {
+        next = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest07 test07 = new LiverangeSubsumeRCTest07("test1");
+        test07.next = test07; // 使用intrinsiccall MCCWriteNoDec（）代替
+        test07.next.add();
+        test07.add();
+        if (test07.sum == 202) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println(test07.sum);
+        }
+    }
+    void add() {
+        sum = a + next.a;
+    }
+}
diff --git a/testsuite/java_test/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/expected.txt b/testsuite/java_test/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/test.cfg b/testsuite/java_test/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..297d15ead09bc7eefd81575ecb0bde0ff82370ac
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0007-rt-compiler-LiverangeSubsumeRCTest07/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest07,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest07)
diff --git a/testsuite/java_test/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/LiverangeSubsumeRCTest08.java b/testsuite/java_test/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/LiverangeSubsumeRCTest08.java
new file mode 100755
index 0000000000000000000000000000000000000000..243bbed8b055fd53dc764734a0681a31fedef3cc
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/LiverangeSubsumeRCTest08.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest08 {
+    LiverangeSubsumeRCTest08 next;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest08(String strObjectName) {
+        next = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest08 test1 = new LiverangeSubsumeRCTest08("test1");
+        test1.next = new LiverangeSubsumeRCTest08("test2");
+        test1.next.next = test1;
+        test1.next.add();
+        test1.next.next.add();
+        test1.add();
+        if (test1.sum == 202) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println(test1.sum);
+        }
+    }
+    void add() {
+        sum = a + next.a;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/expected.txt b/testsuite/java_test/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/test.cfg b/testsuite/java_test/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..6bab3a4e7a1271c8c76e20ef24ebd31a3c0455a9
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0008-rt-compiler-LiverangeSubsumeRCTest08/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest08,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest08)
diff --git a/testsuite/java_test/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/LiverangeSubsumeRCTest09.java b/testsuite/java_test/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/LiverangeSubsumeRCTest09.java
new file mode 100755
index 0000000000000000000000000000000000000000..526baf325a2d18d63b61f5bab7ddd98e1a0ec49c
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/LiverangeSubsumeRCTest09.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest09 {
+    LiverangeSubsumeRCTest09 next;
+    int a;
+    int sum;
+    String strObjectName;
+    LiverangeSubsumeRCTest09(String strObjectName) {
+        next = null;
+        a = 101;
+        sum = 0;
+        this.strObjectName = strObjectName;
+    }
+    public static void main(String[] args) {
+        LiverangeSubsumeRCTest09 test9 = new LiverangeSubsumeRCTest09("test9");
+        test9.next = new LiverangeSubsumeRCTest09("test2");
+        test9.next.next = new LiverangeSubsumeRCTest09("test3");
+        test9.next.next.next = new LiverangeSubsumeRCTest09("test4");
+        test9.next.next.next.next = new LiverangeSubsumeRCTest09("test5");
+        test9.next.next.next.next = test9;
+        test9.next.next.next.next.add();
+        test9.add();
+        if (test9.sum == 202) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println(test9.next.sum);
+        }
+    }
+    void add() {
+        sum = a + next.a;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/expected.txt b/testsuite/java_test/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/test.cfg b/testsuite/java_test/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..00290844e9415c3b035c55a4b18634f2f8eda1d5
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0009-rt-compiler-LiverangeSubsumeRCTest09/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest09,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest09)
diff --git a/testsuite/java_test/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/LiverangeSubsumeRCTest10.java b/testsuite/java_test/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/LiverangeSubsumeRCTest10.java
new file mode 100755
index 0000000000000000000000000000000000000000..9adf5cc30219863d2f821367df90b1acc8353eb6
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/LiverangeSubsumeRCTest10.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class A {
+    public int count = 0;
+    public String className = "A";
+    public A(String name) {
+        this.className = name;
+    }
+    public void changeName(String name) {
+        this.className = name;
+    }
+}
+public class LiverangeSubsumeRCTest10 {
+    private static volatile int count = 0;
+    private static A infiniteLoop = null;
+    private A defInsideUseOutside = null;
+    public static boolean onlyUseInsideLoop() {
+        A a1 = new A("a1");
+        for (count = 0; count < 100; count++) {
+            A a2 = a1;
+            a2.changeName("a" + count);
+            a2.count = count;
+            if (count == 99)
+                a2.toString();
+        }
+        return a1.className.equals("a99");
+    }
+    public static void defAndUseInsideLoop() {
+        for (count = 0; count < 10; count++) {
+            A a1 = new A("a1_" + count);
+            a1.changeName("a1");
+            A a2 = a1;
+            for (int j = 0; j < 2; j++) {
+                a2.changeName("a1_" + j);
+            }
+            System.out.print(a1.className);
+        }
+    }
+    public static void main(String[] args) {
+        defAndUseInsideLoop();
+        new LiverangeSubsumeRCTest10().defInsideAndUseOutsideLoop();
+        if (onlyUseInsideLoop()) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        do {
+            this.defInsideUseOutside = new A("a1_i" + count);
+            A a2 = this.defInsideUseOutside;
+            a2.count = count;
+            for (int j = 0; j < 2; j++)
+                a2 = new A("a2_i" + count + "_j" + j);
+            if (count == 99)
+                a2.toString();
+            count++;
+        } while (this.defInsideUseOutside.count < 100 && count < 100);
+        System.out.print(count);
+    }
+}
diff --git a/testsuite/java_test/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/expected.txt b/testsuite/java_test/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..d666f1f6307f237511fb0cd8985c0bcce4208981
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/expected.txt
@@ -0,0 +1 @@
+a1_1a1_1a1_1a1_1a1_1a1_1a1_1a1_1a1_1a1_1100ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/test.cfg b/testsuite/java_test/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..88103bb15f4cfabcec1691763523e804f6d3fc5b
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0010-rt-compiler-LiverangeSubsumeRCTest10/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest10,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest10)
diff --git a/testsuite/java_test/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/LiverangeSubsumeRCTest11.java b/testsuite/java_test/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/LiverangeSubsumeRCTest11.java
new file mode 100755
index 0000000000000000000000000000000000000000..f9ec852242da5079375d445f3eea10278efe79e1
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/LiverangeSubsumeRCTest11.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class A2 {
+    public int count = 0;
+    public String className = "A";
+    public A2(String name) {
+        this.className = name;
+    }
+    public void changeName(String name) {
+        this.className = name;
+    }
+}
+public class LiverangeSubsumeRCTest11 {
+    private volatile static int count = 0;
+    public static void onlyUseInsideLoop() {
+        A2 a1 = new A2("a1");
+        for (count = 0; count < 100; count++) {
+            A2 a2 = new A2("a2");
+            a2.changeName("a" + count);
+            a2.count = count;
+        }
+        if (count % 10 == 0) {
+            a1.changeName("a" + 100);
+            System.out.println(a1.className);
+        }
+    }
+    public static void defAndUseInsideLoop() {
+        for (count = 0; count < 10; count++) {
+            A2 a1 = new A2("a1");
+            a1.count = count;
+            A2 a2 = a1;
+            a2.changeName("null");
+            if (count % 2 == 0) {
+                a2.changeName("a" + 100);
+                a2 = new A2("a10");
+                a2.toString();
+            } else {
+                a1.changeName("a" + 100);
+                a1.toString();
+            }
+        }
+    }
+    public static void main(String[] args) {
+        onlyUseInsideLoop();
+        defAndUseInsideLoop();
+        new LiverangeSubsumeRCTest11().defInsideAndUseOutsideLoop();
+    }
+    public void defInsideAndUseOutsideLoop() {
+        count = 0;
+        do {
+            int choice = count % 4;
+            A2 a1 = new A2("a2_i" + count);
+            A2 a2 = a1;
+            switch (choice) {
+                case 1:
+                    a1.changeName("case 1");
+                    break;
+                case 2:
+                    a2.changeName("case 2");
+                    break;
+                case 3:
+                    break;
+                default:
+                    a1 = a2;
+            }
+            count++;
+        } while (count < 10);
+    }
+}
diff --git a/testsuite/java_test/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/expected.txt b/testsuite/java_test/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..c7428b76c9943668800412a32b833f7f6dfc0db4
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/expected.txt
@@ -0,0 +1 @@
+a100
diff --git a/testsuite/java_test/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/test.cfg b/testsuite/java_test/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..e8ad96cb301ef65be4d3b916e615d5ac6f33d166
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0011-rt-compiler-LiverangeSubsumeRCTest11/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest11,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest11)
diff --git a/testsuite/java_test/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/LiverangeSubsumeRCTest12.java b/testsuite/java_test/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/LiverangeSubsumeRCTest12.java
new file mode 100755
index 0000000000000000000000000000000000000000..a6180fba7d3d8b92645b01beb4d853225f09a1ee
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/LiverangeSubsumeRCTest12.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class A3 {
+    public int count = 0;
+    public String className = "temp";
+    public A3(String name) {
+        this.className = name;
+    }
+    public void changeName(String name) {
+        this.className = name;
+    }
+}
+public class LiverangeSubsumeRCTest12 {
+    private volatile static int count = 0;
+    private A3 defInsideUseOutside = null;
+    //def outside, only use inside loop
+    public static void onlyUseInsideLoop() {
+        A3 a1 = new A3("a1");
+        continueTag:
+        for (count = 0; count < 10; count++) {
+            A3 a3 = a1;
+            a1.changeName("a" + count);
+            a3.count = count;
+            if (count % 8 == 0) {
+                a1.changeName("Right"); // a3没有incRef和decRef
+                continue continueTag;
+            } else {
+                a1.className = "a1_" + count; // a3没有incRef和decRef
+                continue;
+            }
+        }
+    }
+    public static A3 defAndUseInsideLoop() {
+        for (count = 0; count < 10; count++) {
+            A3 a2 = new A3("a2_i" + count);
+            A3 a3 = a2; //因为else分支，这边会有一个incRef
+            a2.count = count;
+            a3.changeName("null");
+            if (count % 4 == 0 && count > 0) {
+                a2.changeName("Optimization");
+                return a2;
+            } else if (count == 3) {
+                a3.changeName("NoOptimization");
+                return a3;
+            }
+        }
+        return new A3("Error");
+    }
+    public static void main(String[] args) {
+        onlyUseInsideLoop();
+        if (defAndUseInsideLoop().className.equals("NoOptimization")) {
+            System.out.println("ExpectResult");
+        } else {
+            System.out.println("ErrorResult");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/expected.txt b/testsuite/java_test/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/test.cfg b/testsuite/java_test/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..bd2855977bb74ac98e9cef0141759bf3a652d28c
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0012-rt-compiler-LiverangeSubsumeRCTest12/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest12,EXPECTNUM=1)
+run(LiverangeSubsumeRCTest12)
diff --git a/testsuite/java_test/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/LiverangeSubsumeRCTest13.java b/testsuite/java_test/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/LiverangeSubsumeRCTest13.java
new file mode 100755
index 0000000000000000000000000000000000000000..c9abf1705e0086641a9db5b845e6260101e88f4b
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/LiverangeSubsumeRCTest13.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest13 {
+    public static void main(String[] argv) {
+        int result = 2;
+        boolean check;
+        String str = "123#";
+        String str2 = str;
+        try {
+            str.notifyAll();
+            str = str2;
+            Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            str = "123#456";  // 2
+            result--;
+        } catch (NullPointerException e) {
+            str2 = "123456";  // 3
+            result = 2;
+        } catch (IllegalMonitorStateException e) {
+            str2 = str;
+            result = 0;
+        }
+        if (result == 0) {
+            System.out.println("ExpectResult");
+        }
+    }
+}
diff --git a/testsuite/java_test/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/expected.txt b/testsuite/java_test/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..6eec045e116acc8368bb44d7d46330bb25fbb63e
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/expected.txt
@@ -0,0 +1 @@
+ExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/test.cfg b/testsuite/java_test/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..d4c68d4a50ca1b29d629417b26dc2c29a3d484e5
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0013-rt-compiler-LiverangeSubsumeRCTest13/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest13,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest13)
diff --git a/testsuite/java_test/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/LiverangeSubsumeRCTest14.java b/testsuite/java_test/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/LiverangeSubsumeRCTest14.java
new file mode 100755
index 0000000000000000000000000000000000000000..b0ae8b29d7be3dde1cf54557d3d0a898707ce05f
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/LiverangeSubsumeRCTest14.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class LiverangeSubsumeRCTest14 {
+    public static void main(String[] args) {
+        String str1 = "ExpectResult";
+        String str2 = str1;
+        try {
+            String temp = str2.substring(0, 3);
+            temp = str1.toLowerCase();
+            str1 = str2;
+            temp = temp.equals("ExpectResult") ? temp : str1;
+            temp.notifyAll();
+            str1.notifyAll();
+        } catch (Exception e) {
+            System.out.print(str1);
+        } finally {
+            System.out.println(str1);
+        }
+    }
+}
diff --git a/testsuite/java_test/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/expected.txt b/testsuite/java_test/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..30f2aec14d24c343a1303b4fd8226de1216036e2
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/expected.txt
@@ -0,0 +1 @@
+ExpectResultExpectResult
diff --git a/testsuite/java_test/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/test.cfg b/testsuite/java_test/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/test.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1d03281d9351b8b89b57eac98ca414395c1d901c
--- /dev/null
+++ b/testsuite/java_test/subsumeRC_test/RT0014-rt-compiler-LiverangeSubsumeRCTest14/test.cfg
@@ -0,0 +1,2 @@
+compile(LiverangeSubsumeRCTest14,EXPECTNUM=0)
+run(LiverangeSubsumeRCTest14)
diff --git a/testsuite/java_test/thread_test/RT0001-rt-thread-ThreadactiveCount/ThreadActiveCount.java b/testsuite/java_test/thread_test/RT0001-rt-thread-ThreadactiveCount/ThreadActiveCount.java
new file mode 100644
index 0000000000000000000000000000000000000000..f29b555af314d45cecb58eda9a6065b241da63b7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0001-rt-thread-ThreadactiveCount/ThreadActiveCount.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadActiveCount extends Thread {
+    static int num;
+    static Object ob = "aa";
+    public ThreadActiveCount(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public static void main(String[] args) {
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        for (int i = 0; i < 10; i++) {
+            (new ThreadActiveCount(threadGroup, "banana" + i)).start();
+        }
+        try {
+            sleep(500);
+        } catch (InterruptedException e1) {
+            e1.printStackTrace();
+        }
+        if (num == 10) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+    public void run() {
+        synchronized (ob) {
+            num = activeCount();
+            try {
+                ob.wait(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0001-rt-thread-ThreadactiveCount/expected.txt b/testsuite/java_test/thread_test/RT0001-rt-thread-ThreadactiveCount/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0001-rt-thread-ThreadactiveCount/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0001-rt-thread-ThreadactiveCount/test.cfg b/testsuite/java_test/thread_test/RT0001-rt-thread-ThreadactiveCount/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..50f83cf19241103a08987c2f752ac49514535528
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0001-rt-thread-ThreadactiveCount/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadActiveCount)
+run(ThreadActiveCount)
diff --git a/testsuite/java_test/thread_test/RT0002-rt-thread-ThreadcheckAccess/ThreadCheckAccess.java b/testsuite/java_test/thread_test/RT0002-rt-thread-ThreadcheckAccess/ThreadCheckAccess.java
new file mode 100644
index 0000000000000000000000000000000000000000..590b5ab91bdb1d193a3d789e03b81de1e4b81681
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0002-rt-thread-ThreadcheckAccess/ThreadCheckAccess.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadCheckAccess extends Thread {
+    public static void main(String[] args) {
+        ThreadCheckAccess threadCheckAccess = new ThreadCheckAccess();
+        try {
+            threadCheckAccess.checkAccess();
+        } catch (Exception e) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0002-rt-thread-ThreadcheckAccess/expected.txt b/testsuite/java_test/thread_test/RT0002-rt-thread-ThreadcheckAccess/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0002-rt-thread-ThreadcheckAccess/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0002-rt-thread-ThreadcheckAccess/test.cfg b/testsuite/java_test/thread_test/RT0002-rt-thread-ThreadcheckAccess/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8449fa29f1341177825c3c202a1c3c7d48cd754f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0002-rt-thread-ThreadcheckAccess/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadCheckAccess)
+run(ThreadCheckAccess)
diff --git a/testsuite/java_test/thread_test/RT0003-rt-thread-Threadclone/ThreadClone.java b/testsuite/java_test/thread_test/RT0003-rt-thread-Threadclone/ThreadClone.java
new file mode 100644
index 0000000000000000000000000000000000000000..66c9b034ac7d197f7e20b5e000c0bae1a20ba25f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0003-rt-thread-Threadclone/ThreadClone.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadClone extends Thread {
+    public static void main(String[] args) {
+        ThreadClone threadClone = new ThreadClone();
+        try {
+            threadClone.clone();
+            System.out.println(2);
+        } catch (CloneNotSupportedException e) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0003-rt-thread-Threadclone/expected.txt b/testsuite/java_test/thread_test/RT0003-rt-thread-Threadclone/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0003-rt-thread-Threadclone/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0003-rt-thread-Threadclone/test.cfg b/testsuite/java_test/thread_test/RT0003-rt-thread-Threadclone/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..295e92fc6433f3a8a7dbd084cd5d5954c2df42c6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0003-rt-thread-Threadclone/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadClone)
+run(ThreadClone)
diff --git a/testsuite/java_test/thread_test/RT0004-rt-thread-ThreadConstructors1/ThreadConstructors1.java b/testsuite/java_test/thread_test/RT0004-rt-thread-ThreadConstructors1/ThreadConstructors1.java
new file mode 100755
index 0000000000000000000000000000000000000000..7a6d20f256d8c96e94908ec8fd98a3c9cc24e2ef
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0004-rt-thread-ThreadConstructors1/ThreadConstructors1.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors1 extends Thread {
+    public ThreadConstructors1() {
+    }
+    public static void main(String[] args) {
+        ThreadConstructors1 threadConstructors1 = new ThreadConstructors1();
+        if (threadConstructors1.toString().equals("Thread[Thread-0,5,main]")) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0004-rt-thread-ThreadConstructors1/expected.txt b/testsuite/java_test/thread_test/RT0004-rt-thread-ThreadConstructors1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0004-rt-thread-ThreadConstructors1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0004-rt-thread-ThreadConstructors1/test.cfg b/testsuite/java_test/thread_test/RT0004-rt-thread-ThreadConstructors1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dc822c571c369b379e1379fec0a084abdec84426
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0004-rt-thread-ThreadConstructors1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors1)
+run(ThreadConstructors1)
diff --git a/testsuite/java_test/thread_test/RT0005-rt-thread-ThreadConstructors10/ThreadConstructors10.java b/testsuite/java_test/thread_test/RT0005-rt-thread-ThreadConstructors10/ThreadConstructors10.java
new file mode 100755
index 0000000000000000000000000000000000000000..7d3c658759750dbee1696a5920dc4090670dd75b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0005-rt-thread-ThreadConstructors10/ThreadConstructors10.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadConstructors10_a implements Runnable {
+    static int t = 0;
+    public void run() {
+        t++;
+    }
+}
+public class ThreadConstructors10 extends Thread {
+    public ThreadConstructors10(Runnable target) {
+        super(target);
+    }
+    public static void main(String[] args) {
+        ThreadConstructors10_a threadConstructors10_a = new ThreadConstructors10_a();
+        ThreadConstructors10 threadConstructors10 = new ThreadConstructors10(threadConstructors10_a);
+        threadConstructors10.start();
+        try {
+            threadConstructors10.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (ThreadConstructors10_a.t == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0005-rt-thread-ThreadConstructors10/expected.txt b/testsuite/java_test/thread_test/RT0005-rt-thread-ThreadConstructors10/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0005-rt-thread-ThreadConstructors10/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0005-rt-thread-ThreadConstructors10/test.cfg b/testsuite/java_test/thread_test/RT0005-rt-thread-ThreadConstructors10/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0fa8d76834cb4ed075d77a897751cf8f126ff214
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0005-rt-thread-ThreadConstructors10/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors10)
+run(ThreadConstructors10)
diff --git a/testsuite/java_test/thread_test/RT0006-rt-thread-ThreadConstructors2/ThreadConstructors2.java b/testsuite/java_test/thread_test/RT0006-rt-thread-ThreadConstructors2/ThreadConstructors2.java
new file mode 100755
index 0000000000000000000000000000000000000000..3f010ee7216ed3b34712ed76326d8543e59b1daa
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0006-rt-thread-ThreadConstructors2/ThreadConstructors2.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadConstructors2_a implements Runnable {
+    static int t = 0;
+    public void run() {
+        t++;
+    }
+}
+public class ThreadConstructors2 extends Thread {
+    static int i = 0;
+    public ThreadConstructors2(Runnable target) {
+        super(target);
+    }
+    public static void main(String[] args) {
+        ThreadConstructors2_a threadConstructors2_a = new ThreadConstructors2_a();
+        ThreadConstructors2 threadConstructors2 = new ThreadConstructors2(threadConstructors2_a);
+        threadConstructors2.start();
+        try {
+            threadConstructors2.join();
+        } catch (InterruptedException e) {
+        }
+        if (i == 1) {
+            if (ThreadConstructors2_a.t == 1) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0006-rt-thread-ThreadConstructors2/expected.txt b/testsuite/java_test/thread_test/RT0006-rt-thread-ThreadConstructors2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0006-rt-thread-ThreadConstructors2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0006-rt-thread-ThreadConstructors2/test.cfg b/testsuite/java_test/thread_test/RT0006-rt-thread-ThreadConstructors2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a959a895ca9caec3f01b646396712d23ae8ae3e3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0006-rt-thread-ThreadConstructors2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors2)
+run(ThreadConstructors2)
diff --git a/testsuite/java_test/thread_test/RT0007-rt-thread-ThreadConstructors3/ThreadConstructors3.java b/testsuite/java_test/thread_test/RT0007-rt-thread-ThreadConstructors3/ThreadConstructors3.java
new file mode 100755
index 0000000000000000000000000000000000000000..07c7bee573767dcb2578510f98b83ac7349498d7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0007-rt-thread-ThreadConstructors3/ThreadConstructors3.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadConstructors3_a implements Runnable {
+    static int t = 0;
+    public void run() {
+        t++;
+    }
+}
+public class ThreadConstructors3 extends Thread {
+    static int i = 0;
+    public ThreadConstructors3(Runnable target) {
+        super(target);
+    }
+    public static void main(String[] args) {
+        ThreadConstructors3_a threadConstructors3_a = new ThreadConstructors3_a();
+        ThreadConstructors3 threadConstructors3 = new ThreadConstructors3(threadConstructors3_a);
+        threadConstructors3.start();
+        try {
+            threadConstructors3.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1) {
+            if (ThreadConstructors3_a.t == 0) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0007-rt-thread-ThreadConstructors3/expected.txt b/testsuite/java_test/thread_test/RT0007-rt-thread-ThreadConstructors3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0007-rt-thread-ThreadConstructors3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0007-rt-thread-ThreadConstructors3/test.cfg b/testsuite/java_test/thread_test/RT0007-rt-thread-ThreadConstructors3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..10ed362380e2cff3e974997b0d98d12059df2597
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0007-rt-thread-ThreadConstructors3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors3)
+run(ThreadConstructors3)
diff --git a/testsuite/java_test/thread_test/RT0008-rt-thread-ThreadConstructors4/ThreadConstructors4.java b/testsuite/java_test/thread_test/RT0008-rt-thread-ThreadConstructors4/ThreadConstructors4.java
new file mode 100755
index 0000000000000000000000000000000000000000..c2624006702885bb54da44cd71c2ef3a811568fc
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0008-rt-thread-ThreadConstructors4/ThreadConstructors4.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadConstructors4_a implements Runnable {
+    static int t = 0;
+    public void run() {
+        t++;
+    }
+}
+public class ThreadConstructors4 extends Thread {
+    static int i = 0;
+    public ThreadConstructors4(ThreadGroup group, Runnable target) {
+        super(group, target);
+    }
+    public static void main(String[] args) {
+        String message;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadConstructors4_a threadConstructors4_a = new ThreadConstructors4_a();
+        ThreadConstructors4 threadConstructors4 = new ThreadConstructors4(threadGroup, threadConstructors4_a);
+        message = threadConstructors4.getThreadGroup().toString();
+        threadConstructors4.start();
+        try {
+            threadConstructors4.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (i == 1) {
+            if (ThreadConstructors4_a.t == 1) {
+                if (message.equals("java.lang.ThreadGroup[name=god,maxpri=10]")) {
+                    System.out.println(0);
+                    return;
+                }
+            }
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0008-rt-thread-ThreadConstructors4/expected.txt b/testsuite/java_test/thread_test/RT0008-rt-thread-ThreadConstructors4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0008-rt-thread-ThreadConstructors4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0008-rt-thread-ThreadConstructors4/test.cfg b/testsuite/java_test/thread_test/RT0008-rt-thread-ThreadConstructors4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7d37b77cf5d9ad19d8a18c48103abfbd82604e41
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0008-rt-thread-ThreadConstructors4/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors4)
+run(ThreadConstructors4)
diff --git a/testsuite/java_test/thread_test/RT0009-rt-thread-ThreadConstructors5/ThreadConstructors5.java b/testsuite/java_test/thread_test/RT0009-rt-thread-ThreadConstructors5/ThreadConstructors5.java
new file mode 100755
index 0000000000000000000000000000000000000000..93e08147deedd04c8f6b3b710d115797e28538a4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0009-rt-thread-ThreadConstructors5/ThreadConstructors5.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors5 extends Thread {
+    public ThreadConstructors5(String name) {
+        super(name);
+    }
+    public static void main(String[] args) {
+        ThreadConstructors5 threadConstructors5 = new ThreadConstructors5("good");
+        if (threadConstructors5.getName().equals("good")) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0009-rt-thread-ThreadConstructors5/expected.txt b/testsuite/java_test/thread_test/RT0009-rt-thread-ThreadConstructors5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0009-rt-thread-ThreadConstructors5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0009-rt-thread-ThreadConstructors5/test.cfg b/testsuite/java_test/thread_test/RT0009-rt-thread-ThreadConstructors5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1b01f8d17d02d007ac51b8ab3fbdde10c441e139
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0009-rt-thread-ThreadConstructors5/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors5)
+run(ThreadConstructors5)
diff --git a/testsuite/java_test/thread_test/RT0010-rt-thread-ThreadConstructors6/ThreadConstructors6.java b/testsuite/java_test/thread_test/RT0010-rt-thread-ThreadConstructors6/ThreadConstructors6.java
new file mode 100755
index 0000000000000000000000000000000000000000..0c2f9a9b9b6d189b8f8946795f26f8ff94270971
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0010-rt-thread-ThreadConstructors6/ThreadConstructors6.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors6 extends Thread {
+    public ThreadConstructors6(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public static void main(String[] args) {
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadConstructors6 threadConstructors6 = new ThreadConstructors6(threadGroup, "good");
+        if (threadConstructors6.toString().equals("Thread[good,5,god]")) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0010-rt-thread-ThreadConstructors6/expected.txt b/testsuite/java_test/thread_test/RT0010-rt-thread-ThreadConstructors6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0010-rt-thread-ThreadConstructors6/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0010-rt-thread-ThreadConstructors6/test.cfg b/testsuite/java_test/thread_test/RT0010-rt-thread-ThreadConstructors6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d9f0b188bdda676735f3a3b691150adc33da8b5
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0010-rt-thread-ThreadConstructors6/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors6)
+run(ThreadConstructors6)
diff --git a/testsuite/java_test/thread_test/RT0011-rt-thread-ThreadConstructors7/ThreadConstructors7.java b/testsuite/java_test/thread_test/RT0011-rt-thread-ThreadConstructors7/ThreadConstructors7.java
new file mode 100755
index 0000000000000000000000000000000000000000..3593d27191156f963bfd3bec8cf67c6c69175df3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0011-rt-thread-ThreadConstructors7/ThreadConstructors7.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadConstructors7_a implements Runnable {
+    static int t = 0;
+    public void run() {
+        t++;
+    }
+}
+public class ThreadConstructors7 extends Thread {
+    static int i = 0;
+    public ThreadConstructors7(Runnable target, String name) {
+        super(target, name);
+    }
+    public static void main(String[] args) {
+        ThreadConstructors7_a threadConstructors7_a = new ThreadConstructors7_a();
+        ThreadConstructors7 threadConstructors7 = new ThreadConstructors7(threadConstructors7_a, "good");
+        threadConstructors7.start();
+        try {
+            threadConstructors7.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1) {
+            if (ThreadConstructors7_a.t == 1) {
+                if (threadConstructors7.getName().equals("good")) {
+                    System.out.println(0);
+                    return;
+                }
+            }
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0011-rt-thread-ThreadConstructors7/expected.txt b/testsuite/java_test/thread_test/RT0011-rt-thread-ThreadConstructors7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0011-rt-thread-ThreadConstructors7/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0011-rt-thread-ThreadConstructors7/test.cfg b/testsuite/java_test/thread_test/RT0011-rt-thread-ThreadConstructors7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c154b7744d26c1e568e17ebafc2ea86ff8ed64bc
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0011-rt-thread-ThreadConstructors7/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors7)
+run(ThreadConstructors7)
diff --git a/testsuite/java_test/thread_test/RT0012-rt-thread-ThreadConstructors8/ThreadConstructors8.java b/testsuite/java_test/thread_test/RT0012-rt-thread-ThreadConstructors8/ThreadConstructors8.java
new file mode 100755
index 0000000000000000000000000000000000000000..3f9cb7685f5500b13cee4e6f4776b2f5f2e41934
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0012-rt-thread-ThreadConstructors8/ThreadConstructors8.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadConstructors8_a implements Runnable {
+    static int t = 0;
+    public void run() {
+        t++;
+    }
+}
+public class ThreadConstructors8 extends Thread {
+    static int i = 0;
+    public ThreadConstructors8(ThreadGroup group, Runnable target, String name) {
+        super(group, target, name);
+    }
+    public static void main(String[] args) {
+        String message;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadConstructors8_a threadConstructors8_a = new ThreadConstructors8_a();
+        ThreadConstructors8 threadConstructors8 = new ThreadConstructors8(threadGroup, threadConstructors8_a,
+                "good");
+        message = threadConstructors8.getThreadGroup().toString();
+        threadConstructors8.start();
+        try {
+            threadConstructors8.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1 && ThreadConstructors8_a.t == 1) {
+            if (message.equals("java.lang.ThreadGroup[name=god,maxpri=10]")) {
+                if (threadConstructors8.getName().equals("good")) {
+                    System.out.println(0);
+                    return;
+                }
+            }
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0012-rt-thread-ThreadConstructors8/expected.txt b/testsuite/java_test/thread_test/RT0012-rt-thread-ThreadConstructors8/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0012-rt-thread-ThreadConstructors8/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0012-rt-thread-ThreadConstructors8/test.cfg b/testsuite/java_test/thread_test/RT0012-rt-thread-ThreadConstructors8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f83767d31ce6593d48bad0482caee985c19f6b5d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0012-rt-thread-ThreadConstructors8/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors8)
+run(ThreadConstructors8)
diff --git a/testsuite/java_test/thread_test/RT0013-rt-thread-ThreadConstructors9/ThreadConstructors9.java b/testsuite/java_test/thread_test/RT0013-rt-thread-ThreadConstructors9/ThreadConstructors9.java
new file mode 100755
index 0000000000000000000000000000000000000000..8ae45187494acabf8203b9d9fc7b63a9eb33ce73
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0013-rt-thread-ThreadConstructors9/ThreadConstructors9.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadConstructors9_a implements Runnable {
+    static int t = 0;
+    public void run() {
+        t++;
+    }
+}
+public class ThreadConstructors9 extends Thread {
+    static int i = 0;
+    static long k;
+    public ThreadConstructors9(ThreadGroup group, Runnable target, String name, long stackSize) {
+        super(group, target, name, stackSize);
+        k = stackSize;
+    }
+    public static void main(String[] args) {
+        String message;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadConstructors9_a threadConstructors9_a = new ThreadConstructors9_a();
+        ThreadConstructors9 threadConstructors9 = new ThreadConstructors9(threadGroup, threadConstructors9_a,
+                "good", 1 << 30);
+        message = threadConstructors9.getThreadGroup().toString();
+        threadConstructors9.start();
+        try {
+            threadConstructors9.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1 && k == 1073741824 && ThreadConstructors9_a.t == 1) {
+            if (message.equals("java.lang.ThreadGroup[name=god,maxpri=10]")) {
+                if (threadConstructors9.getName().equals("good")) {
+                    System.out.println(0);
+                    return;
+                }
+            }
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0013-rt-thread-ThreadConstructors9/expected.txt b/testsuite/java_test/thread_test/RT0013-rt-thread-ThreadConstructors9/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0013-rt-thread-ThreadConstructors9/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0013-rt-thread-ThreadConstructors9/test.cfg b/testsuite/java_test/thread_test/RT0013-rt-thread-ThreadConstructors9/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..17452fea615bde5ca643f4aa0c88b5b90ff2518d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0013-rt-thread-ThreadConstructors9/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors9)
+run(ThreadConstructors9)
diff --git a/testsuite/java_test/thread_test/RT0014-rt-thread-ThreadcurrentThread/ThreadCurrentThread.java b/testsuite/java_test/thread_test/RT0014-rt-thread-ThreadcurrentThread/ThreadCurrentThread.java
new file mode 100644
index 0000000000000000000000000000000000000000..eaeb251b6ca9efecc75a1168938713b2439373e6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0014-rt-thread-ThreadcurrentThread/ThreadCurrentThread.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadCurrentThread extends Thread {
+    static int nameMatch = 0;
+    static Object a = new Object();
+    public static void main(String[] args) {
+        ThreadCurrentThread threadCurrentThread1 = new ThreadCurrentThread();
+        ThreadCurrentThread threadCurrentThread2 = new ThreadCurrentThread();
+        threadCurrentThread1.setName("good");
+        threadCurrentThread2.setName("bad");
+        threadCurrentThread1.start();
+        threadCurrentThread2.start();
+        try {
+            threadCurrentThread1.join();
+            threadCurrentThread2.join();
+        } catch (Exception e) {
+            System.out.println("Join is interrupted");
+        }
+        if (currentThread().getName().equals("good")) {
+            System.out.println(2);
+        }
+        if (currentThread().getName().equals("bad")) {
+            System.out.println(3);
+        }
+        if (currentThread().getName().equals("main")) {
+            if (nameMatch == 2) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+    }
+    public synchronized void run() {
+        if (currentThread().getName() == getName()) {
+            synchronized (a) {
+                nameMatch++;
+            }
+        }
+        try {
+            wait(500);
+        } catch (InterruptedException e1) {
+            System.out.println("Wait is interrupted");
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0014-rt-thread-ThreadcurrentThread/expected.txt b/testsuite/java_test/thread_test/RT0014-rt-thread-ThreadcurrentThread/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0014-rt-thread-ThreadcurrentThread/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0014-rt-thread-ThreadcurrentThread/test.cfg b/testsuite/java_test/thread_test/RT0014-rt-thread-ThreadcurrentThread/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2b6554397c08cc9e330cfc30659152c8d212d133
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0014-rt-thread-ThreadcurrentThread/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadCurrentThread)
+run(ThreadCurrentThread)
diff --git a/testsuite/java_test/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/ThreadDMCountStackFrames1.java b/testsuite/java_test/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/ThreadDMCountStackFrames1.java
new file mode 100644
index 0000000000000000000000000000000000000000..9046d4a3062cc460d685306a650f60ee01a4b737
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/ThreadDMCountStackFrames1.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadDMCountStackFrames1 extends Thread{
+    static int eCnt = 0;
+    public static void main(String[] args) {
+        ThreadDMCountStackFrames1 thread_obj = new ThreadDMCountStackFrames1();
+        thread_obj.start();
+        try{
+            sleep(50);
+        }catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        if(thread_obj.countStackFrames() >= 0 && eCnt == 1) {
+            System.out.println(0);
+            return;
+        }
+        thread_obj.stop();
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (this) {
+            try {
+                this.suspend();
+            } catch (UnsupportedOperationException e2) {
+                eCnt ++;
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/expected.txt b/testsuite/java_test/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/test.cfg b/testsuite/java_test/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3b8a1b3db9eaea60b24a97e27d84bc98b693a267
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0015-rt-thread-ThreadDMcountStackFrames1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadDMCountStackFrames1)
+run(ThreadDMCountStackFrames1)
diff --git a/testsuite/java_test/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/ThreadDMCountStackFrames2.java b/testsuite/java_test/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/ThreadDMCountStackFrames2.java
new file mode 100644
index 0000000000000000000000000000000000000000..e22da4fac970b735a19514222c0a5f763b162cad
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/ThreadDMCountStackFrames2.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadDMCountStackFrames2 extends Thread {
+    public static void main(String[] args) {
+        ThreadDMCountStackFrames2 thread_obj = new ThreadDMCountStackFrames2();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.countStackFrames();
+        } catch (IllegalThreadStateException e3) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+    public void run() {
+        synchronized (this) {
+            try {
+                sleep(100);
+            } catch (InterruptedException e2) {
+                System.err.println(e2);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/expected.txt b/testsuite/java_test/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/test.cfg b/testsuite/java_test/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4db721adb71f7ead752ea6406688fbab44b20925
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0016-rt-thread-ThreadDMcountStackFrames2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadDMCountStackFrames2)
+run(ThreadDMCountStackFrames2)
diff --git a/testsuite/java_test/thread_test/RT0017-rt-thread-ThreadDMdestroy/ThreadDMDestroy.java b/testsuite/java_test/thread_test/RT0017-rt-thread-ThreadDMdestroy/ThreadDMDestroy.java
new file mode 100644
index 0000000000000000000000000000000000000000..71cdf1ab4ae39f298654b9b9d19ba2e4ca2d63e4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0017-rt-thread-ThreadDMdestroy/ThreadDMDestroy.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadDMDestroy extends Thread {
+    public static void main(String[] args) {
+        ThreadDMDestroy thread_obj = new ThreadDMDestroy();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.destroy();
+        } catch (UnsupportedOperationException e2) {
+            System.out.println(0);
+            return;
+        } catch (NoSuchMethodError e3) {
+            System.out.println(1);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (this) {
+            try {
+                sleep(100);
+            } catch (InterruptedException e4) {
+                System.err.println(e4);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0017-rt-thread-ThreadDMdestroy/expected.txt b/testsuite/java_test/thread_test/RT0017-rt-thread-ThreadDMdestroy/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0017-rt-thread-ThreadDMdestroy/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0017-rt-thread-ThreadDMdestroy/test.cfg b/testsuite/java_test/thread_test/RT0017-rt-thread-ThreadDMdestroy/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..77fdefb734cd787f0e9a1b17a0650f87283ad732
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0017-rt-thread-ThreadDMdestroy/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadDMDestroy)
+run(ThreadDMDestroy)
diff --git a/testsuite/java_test/thread_test/RT0018-rt-thread-ThreadDMresume/ThreadDMResume.java b/testsuite/java_test/thread_test/RT0018-rt-thread-ThreadDMresume/ThreadDMResume.java
new file mode 100644
index 0000000000000000000000000000000000000000..8473ca35ebc51900eee0f7b856d8f81d8904100e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0018-rt-thread-ThreadDMresume/ThreadDMResume.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadDMResume extends Thread {
+    static int i = 0;
+    public static void main(String[] args) {
+        ThreadDMResume thread_obj = new ThreadDMResume();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.resume();
+        } catch (UnsupportedOperationException e2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (this) {
+            i++;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0018-rt-thread-ThreadDMresume/expected.txt b/testsuite/java_test/thread_test/RT0018-rt-thread-ThreadDMresume/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0018-rt-thread-ThreadDMresume/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0018-rt-thread-ThreadDMresume/test.cfg b/testsuite/java_test/thread_test/RT0018-rt-thread-ThreadDMresume/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3f6470082f61b6f5c214b3d862bd4beb0c2d9905
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0018-rt-thread-ThreadDMresume/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadDMResume)
+run(ThreadDMResume)
diff --git a/testsuite/java_test/thread_test/RT0019-rt-thread-ThreadDMstop/ThreadDMStop.java b/testsuite/java_test/thread_test/RT0019-rt-thread-ThreadDMstop/ThreadDMStop.java
new file mode 100755
index 0000000000000000000000000000000000000000..c8244a97591550d24277ffa15ea894ac46de0dad
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0019-rt-thread-ThreadDMstop/ThreadDMStop.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadDMStop extends Thread {
+    static int i = 0;
+    public static void main(String[] args) {
+        long j;
+        long k;
+        ThreadDMStop thread_obj = new ThreadDMStop();
+        thread_obj.start();
+        j = System.currentTimeMillis();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.stop();
+        } catch (UnsupportedOperationException e2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (this) {
+            try {
+                wait(100);
+                i++;
+            } catch (InterruptedException e3) {
+                System.err.println(e3);
+            }
+        }
+        synchronized (this) {
+            for (int a = 0; a < 3; a++) {
+                try {
+                    sleep(1000);
+                    i++;
+                } catch (InterruptedException e4) {
+                    System.err.println(e4);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0019-rt-thread-ThreadDMstop/expected.txt b/testsuite/java_test/thread_test/RT0019-rt-thread-ThreadDMstop/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0019-rt-thread-ThreadDMstop/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0019-rt-thread-ThreadDMstop/test.cfg b/testsuite/java_test/thread_test/RT0019-rt-thread-ThreadDMstop/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d63a47bac64f06b1a10ffad63501605d43145712
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0019-rt-thread-ThreadDMstop/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadDMStop)
+run(ThreadDMStop)
diff --git a/testsuite/java_test/thread_test/RT0020-rt-thread-ThreadDMstopTh/ThreadDMStopThrowable.java b/testsuite/java_test/thread_test/RT0020-rt-thread-ThreadDMstopTh/ThreadDMStopThrowable.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e4660a2fb54b667a14c0fa04b0cb147d815f591
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0020-rt-thread-ThreadDMstopTh/ThreadDMStopThrowable.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadDMStopThrowable extends Thread {
+    public static void main(String[] args) {
+        Throwable aaa = null;
+        ThreadDMStopThrowable thread_obj = new ThreadDMStopThrowable();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e1) {
+            System.err.println(e1);
+        }
+        try {
+            thread_obj.stop(aaa);
+        } catch (UnsupportedOperationException e2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (this) {
+            try {
+                sleep(100);
+            } catch (InterruptedException e4) {
+                System.err.println(e4);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0020-rt-thread-ThreadDMstopTh/expected.txt b/testsuite/java_test/thread_test/RT0020-rt-thread-ThreadDMstopTh/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0020-rt-thread-ThreadDMstopTh/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0020-rt-thread-ThreadDMstopTh/test.cfg b/testsuite/java_test/thread_test/RT0020-rt-thread-ThreadDMstopTh/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bf2b768ffe661e003e5f27cb3cb5f676e3b20f8c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0020-rt-thread-ThreadDMstopTh/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadDMStopThrowable)
+run(ThreadDMStopThrowable)
diff --git a/testsuite/java_test/thread_test/RT0021-rt-thread-ThreadDMsuspend/ThreadDMSuspend.java b/testsuite/java_test/thread_test/RT0021-rt-thread-ThreadDMsuspend/ThreadDMSuspend.java
new file mode 100644
index 0000000000000000000000000000000000000000..55c3b902602f0dffc55e4f7b0ef9c774fe6c39fa
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0021-rt-thread-ThreadDMsuspend/ThreadDMSuspend.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadDMSuspend extends Thread {
+    static int i = 0; /* STATUS_Success*/
+
+    public static void main(String[] args) {
+        ThreadDMSuspend thread_obj = new ThreadDMSuspend();
+        thread_obj.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e2) {
+            System.err.println(e2);
+        }
+        try {
+            thread_obj.suspend();
+            thread_obj.stop();
+        } catch (UnsupportedOperationException e3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (this) {
+            try {
+                sleep(100);
+            } catch (InterruptedException e1) {
+                System.err.println(e1);
+            }
+            i++;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0021-rt-thread-ThreadDMsuspend/expected.txt b/testsuite/java_test/thread_test/RT0021-rt-thread-ThreadDMsuspend/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0021-rt-thread-ThreadDMsuspend/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0021-rt-thread-ThreadDMsuspend/test.cfg b/testsuite/java_test/thread_test/RT0021-rt-thread-ThreadDMsuspend/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f972bc4467dbad58fa787ce4896f5b5d3ecc0e02
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0021-rt-thread-ThreadDMsuspend/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadDMSuspend)
+run(ThreadDMSuspend)
diff --git a/testsuite/java_test/thread_test/RT0022-rt-thread-Threadenumerate/ThreadEnumerate.java b/testsuite/java_test/thread_test/RT0022-rt-thread-Threadenumerate/ThreadEnumerate.java
new file mode 100644
index 0000000000000000000000000000000000000000..5657f28054f238507ecb801ea3ba0799e1752a1d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0022-rt-thread-Threadenumerate/ThreadEnumerate.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadEnumerate extends Thread {
+    static Thread[] p;
+    static int w, q;
+    static Object ob = "aa";
+    public ThreadEnumerate(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public static void main(String[] args) {
+        ThreadGroup cls1 = new ThreadGroup("god");
+        for (int i = 0; i < 10; i++) {
+            (new ThreadEnumerate(cls1, "banana" + i)).start();
+        }
+        try {
+            sleep(500);
+        } catch (InterruptedException e1) {
+        }
+        if (w == 10) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (ob) {
+            q = activeCount();
+            p = new Thread[q + 1];
+            w = enumerate(p);
+            try {
+                ob.wait(1000);
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0022-rt-thread-Threadenumerate/expected.txt b/testsuite/java_test/thread_test/RT0022-rt-thread-Threadenumerate/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0022-rt-thread-Threadenumerate/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0022-rt-thread-Threadenumerate/test.cfg b/testsuite/java_test/thread_test/RT0022-rt-thread-Threadenumerate/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..39121f109edd1cbdc2dd54c83cbc42a91f55e39b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0022-rt-thread-Threadenumerate/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadEnumerate)
+run(ThreadEnumerate)
diff --git a/testsuite/java_test/thread_test/RT0023-rt-thread-Threadextends1/ThreadExtends1.java b/testsuite/java_test/thread_test/RT0023-rt-thread-Threadextends1/ThreadExtends1.java
new file mode 100644
index 0000000000000000000000000000000000000000..763ea41a5277dc14ea7d7e488079ff62bfbfddef
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0023-rt-thread-Threadextends1/ThreadExtends1.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadExtends1 extends Thread {
+    private int ticket = 10;
+    public static void main(String[] args) {
+        ThreadExtends1 cls1 = new ThreadExtends1();
+        ThreadExtends1 cls2 = new ThreadExtends1();
+        ThreadExtends1 cls3 = new ThreadExtends1();
+        try {
+            cls1.start();
+            cls1.start();
+            cls1.start();
+        } catch (IllegalThreadStateException e) {
+            System.out.println(0);
+        }
+    }
+    public synchronized void run() {
+        for (int i = 0; i < 20; i++) {
+            if (this.ticket > 0) {
+                this.ticket--;
+            } else {
+                break;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0023-rt-thread-Threadextends1/expected.txt b/testsuite/java_test/thread_test/RT0023-rt-thread-Threadextends1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0023-rt-thread-Threadextends1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0023-rt-thread-Threadextends1/test.cfg b/testsuite/java_test/thread_test/RT0023-rt-thread-Threadextends1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a8c25cca070c4ee65f8673dd310334479bbfbace
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0023-rt-thread-Threadextends1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadExtends1)
+run(ThreadExtends1)
diff --git a/testsuite/java_test/thread_test/RT0024-rt-thread-Threadextends2/ThreadExtends2.java b/testsuite/java_test/thread_test/RT0024-rt-thread-Threadextends2/ThreadExtends2.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a87fb532be12f4c20de22d3f748f6511dd3af2f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0024-rt-thread-Threadextends2/ThreadExtends2.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadExtends2 extends Thread {
+    private int ticket = 10;
+    public static void main(String[] args) {
+        ThreadExtends2 cls1 = new ThreadExtends2();
+        ThreadExtends2 cls2 = new ThreadExtends2();
+        ThreadExtends2 cls3 = new ThreadExtends2();
+        try {
+            cls1.start();
+            cls2.start();
+            cls3.start();
+        } catch (Exception e) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+    public synchronized void run() {
+        for (int i = 0; i < 20; i++) {
+            if (this.ticket > 0) {
+                this.ticket--;
+            } else {
+                break;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0024-rt-thread-Threadextends2/expected.txt b/testsuite/java_test/thread_test/RT0024-rt-thread-Threadextends2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0024-rt-thread-Threadextends2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0024-rt-thread-Threadextends2/test.cfg b/testsuite/java_test/thread_test/RT0024-rt-thread-Threadextends2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cdbfa69898d033189b1395f29375a1bac9ea4c1b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0024-rt-thread-Threadextends2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadExtends2)
+run(ThreadExtends2)
diff --git a/testsuite/java_test/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/ThreadGetDefaultUncaughtExceptionHandler1.java b/testsuite/java_test/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/ThreadGetDefaultUncaughtExceptionHandler1.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8027aa3b107a91bf4728360f1d26b24fc84a287
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/ThreadGetDefaultUncaughtExceptionHandler1.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetDefaultUncaughtExceptionHandler1 extends Thread{
+    static String p;
+    public void run() {
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+        ThreadGetDefaultUncaughtExceptionHandler1 cls=new ThreadGetDefaultUncaughtExceptionHandler1();
+        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        cls.start();
+        try{
+            cls.join();
+        }
+        catch (InterruptedException e1) {
+        }
+        p=Thread.getDefaultUncaughtExceptionHandler().toString();
+        if(p.indexOf("ThreadGetDefaultUncaughtExceptionHandle") !=-1) {
+            if(p.toString().indexOf("$") !=-1) {
+                if(p.toString().indexOf("@") !=-1) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/expected.txt b/testsuite/java_test/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/test.cfg b/testsuite/java_test/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2060715d9ec45e81143ef03a27bad13eee396db6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetDefaultUncaughtExceptionHandler1)
+run(ThreadGetDefaultUncaughtExceptionHandler1)
diff --git a/testsuite/java_test/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/ThreadGetDefaultUncaughtExceptionHandler2.java b/testsuite/java_test/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/ThreadGetDefaultUncaughtExceptionHandler2.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0d37db7caec8270bfd91a27861a726a033f9dcd
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/ThreadGetDefaultUncaughtExceptionHandler2.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetDefaultUncaughtExceptionHandler2 extends Thread{
+    public void run() {
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+        ThreadGetDefaultUncaughtExceptionHandler2 cls=new ThreadGetDefaultUncaughtExceptionHandler2();
+        cls.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        cls.start();
+        try{
+            cls.join();
+        }
+        catch (InterruptedException e1) {
+        }
+        try{
+            Thread.getDefaultUncaughtExceptionHandler().toString();
+            System.out.println(2);
+        }
+        catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/expected.txt b/testsuite/java_test/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/test.cfg b/testsuite/java_test/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..25621be116f68caefda120cf39a2bdfd04933811
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetDefaultUncaughtExceptionHandler2)
+run(ThreadGetDefaultUncaughtExceptionHandler2)
diff --git a/testsuite/java_test/thread_test/RT0027-rt-thread-ThreadgetId/ThreadGetId.java b/testsuite/java_test/thread_test/RT0027-rt-thread-ThreadgetId/ThreadGetId.java
new file mode 100644
index 0000000000000000000000000000000000000000..659d49256357544cfd562de0e2abde4f79c0f2e9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0027-rt-thread-ThreadgetId/ThreadGetId.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetId extends Thread {
+    public static void main(String[] args) {
+        Long i;
+        ThreadGetId threadGetId = new ThreadGetId();
+        threadGetId.start();
+        i = threadGetId.getId();
+        if (i instanceof Long) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0027-rt-thread-ThreadgetId/expected.txt b/testsuite/java_test/thread_test/RT0027-rt-thread-ThreadgetId/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0027-rt-thread-ThreadgetId/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0027-rt-thread-ThreadgetId/test.cfg b/testsuite/java_test/thread_test/RT0027-rt-thread-ThreadgetId/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e7aa8d8e75c976f15c3edcaf7dcc6bd69e1a20a4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0027-rt-thread-ThreadgetId/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetId)
+run(ThreadGetId)
diff --git a/testsuite/java_test/thread_test/RT0028-rt-thread-ThreadgetName/ThreadGetName.java b/testsuite/java_test/thread_test/RT0028-rt-thread-ThreadgetName/ThreadGetName.java
new file mode 100644
index 0000000000000000000000000000000000000000..7dda0b4067b478731a811b6e4d012c3484fc729a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0028-rt-thread-ThreadgetName/ThreadGetName.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetName extends Thread {
+    public static void main(String[] args) {
+        ThreadGetName threadGetName = new ThreadGetName();
+        threadGetName.start();
+        if (threadGetName.getName().equals("Thread-0")) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0028-rt-thread-ThreadgetName/expected.txt b/testsuite/java_test/thread_test/RT0028-rt-thread-ThreadgetName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0028-rt-thread-ThreadgetName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0028-rt-thread-ThreadgetName/test.cfg b/testsuite/java_test/thread_test/RT0028-rt-thread-ThreadgetName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b1ecdb5afea71915911c7eef0bcf5bf0f2464aad
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0028-rt-thread-ThreadgetName/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetName)
+run(ThreadGetName)
diff --git a/testsuite/java_test/thread_test/RT0029-rt-thread-ThreadgetPriority/ThreadGetPriority.java b/testsuite/java_test/thread_test/RT0029-rt-thread-ThreadgetPriority/ThreadGetPriority.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c1ab3bf771ebfcc8cd0b3621f3a1015ae4cdc44
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0029-rt-thread-ThreadgetPriority/ThreadGetPriority.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetPriority extends Thread {
+    public static void main(String[] args) {
+        ThreadGetPriority threadGetPriority = new ThreadGetPriority();
+        threadGetPriority.start();
+        if (threadGetPriority.getPriority() == 5) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0029-rt-thread-ThreadgetPriority/expected.txt b/testsuite/java_test/thread_test/RT0029-rt-thread-ThreadgetPriority/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0029-rt-thread-ThreadgetPriority/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0029-rt-thread-ThreadgetPriority/test.cfg b/testsuite/java_test/thread_test/RT0029-rt-thread-ThreadgetPriority/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65d34cd3521b0225acd51fcc2597950b0828bbf6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0029-rt-thread-ThreadgetPriority/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetPriority)
+run(ThreadGetPriority)
diff --git a/testsuite/java_test/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/ThreadGetThreadGroup1.java b/testsuite/java_test/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/ThreadGetThreadGroup1.java
new file mode 100644
index 0000000000000000000000000000000000000000..ccd5b6b7c7eb27116cf30b412196a16c23e56d49
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/ThreadGetThreadGroup1.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetThreadGroup1 extends Thread {
+    public ThreadGetThreadGroup1(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public static void main(String[] args) {
+        String string;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        threadGroup.setMaxPriority(7);
+        ThreadGetThreadGroup1 threadGetThreadGroup1 = new ThreadGetThreadGroup1(threadGroup, "banana");
+        string = threadGetThreadGroup1.getThreadGroup().toString();
+        if (string.equals("java.lang.ThreadGroup[name=god,maxpri=7]")) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/expected.txt b/testsuite/java_test/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/test.cfg b/testsuite/java_test/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..208d7b8950b724454d3e02cf98ea4a27bd489b3f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0030-rt-thread-ThreadgetThreadGroup1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetThreadGroup1)
+run(ThreadGetThreadGroup1)
diff --git a/testsuite/java_test/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/ThreadGetThreadGroup2.java b/testsuite/java_test/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/ThreadGetThreadGroup2.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d7904c28e4d62dbd144f4c6ff27ee87bd6c55ae
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/ThreadGetThreadGroup2.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetThreadGroup2 extends Thread {
+    public ThreadGetThreadGroup2(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public static void main(String[] args) {
+        String string;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        threadGroup.setMaxPriority(7);
+        ThreadGetThreadGroup2 threadGetThreadGroup2 = new ThreadGetThreadGroup2(threadGroup, "banana");
+        threadGetThreadGroup2.start();
+        try {
+            threadGetThreadGroup2.join();
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        try {
+            string = threadGetThreadGroup2.getThreadGroup().toString();
+            System.out.println(2);
+        } catch (NullPointerException e2) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/expected.txt b/testsuite/java_test/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/test.cfg b/testsuite/java_test/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..eb004bef94ee421fd173be8a36d8889fe397e418
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0031-rt-thread-ThreadgetThreadGroup2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetThreadGroup2)
+run(ThreadGetThreadGroup2)
diff --git a/testsuite/java_test/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/ThreadGetUncaughtExceptionHandler1.java b/testsuite/java_test/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/ThreadGetUncaughtExceptionHandler1.java
new file mode 100644
index 0000000000000000000000000000000000000000..e54e895cac2f5d3a3352f69cd0f5583e8ff6c433
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/ThreadGetUncaughtExceptionHandler1.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetUncaughtExceptionHandler1 extends Thread{
+    static String string;
+    public void run() {
+        try{
+            sleep(50);
+        }catch (InterruptedException e2) {
+            System.out.println("Sleep is interrupted");
+        }
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+        ThreadGetUncaughtExceptionHandler1 threadGetUncaughtExceptionHandler1 = new
+                ThreadGetUncaughtExceptionHandler1();
+        threadGetUncaughtExceptionHandler1.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        threadGetUncaughtExceptionHandler1.start();
+        try{
+            sleep(10);
+        }catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+        string = threadGetUncaughtExceptionHandler1.getUncaughtExceptionHandler().toString();
+        if(string.indexOf("ThreadGetUncaughtExceptionHandler1") != -1) {
+            if(string.toString().indexOf("$") != -1) {
+                if(string.toString().indexOf("@") != -1) {
+                    System.out.println(0);
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/expected.txt b/testsuite/java_test/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/test.cfg b/testsuite/java_test/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b74ecb74cee483300eab5c939f2c1c0e07c666fe
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetUncaughtExceptionHandler1)
+run(ThreadGetUncaughtExceptionHandler1)
diff --git a/testsuite/java_test/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/ThreadGetUncaughtExceptionHandler2.java b/testsuite/java_test/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/ThreadGetUncaughtExceptionHandler2.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4a042a90ba5d08767856fb253def1c74b8d37a2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/ThreadGetUncaughtExceptionHandler2.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetUncaughtExceptionHandler2 extends Thread{
+    static String string;
+    public void run() {
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+        ThreadGetUncaughtExceptionHandler2 threadGetUncaughtExceptionHandler2 = new
+                ThreadGetUncaughtExceptionHandler2();
+        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        threadGetUncaughtExceptionHandler2.start();
+        string = threadGetUncaughtExceptionHandler2.getUncaughtExceptionHandler().toString();
+        if(string.indexOf("java.lang.ThreadGroup") != -1) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/expected.txt b/testsuite/java_test/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/test.cfg b/testsuite/java_test/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9be6db0df0ad454fb61c91237e36b6f60e80a176
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetUncaughtExceptionHandler2)
+run(ThreadGetUncaughtExceptionHandler2)
diff --git a/testsuite/java_test/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/ThreadGetUncaughtExceptionHandler3.java b/testsuite/java_test/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/ThreadGetUncaughtExceptionHandler3.java
new file mode 100644
index 0000000000000000000000000000000000000000..746ef7e00297af6fd1df687d880b9ffcd8c6d424
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/ThreadGetUncaughtExceptionHandler3.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetUncaughtExceptionHandler3 extends Thread{
+    static String string;
+    public void run() {
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+        ThreadGetUncaughtExceptionHandler3 threadGetUncaughtExceptionHandler3 = new
+                ThreadGetUncaughtExceptionHandler3();
+        threadGetUncaughtExceptionHandler3.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        threadGetUncaughtExceptionHandler3.start();
+        try{
+            threadGetUncaughtExceptionHandler3.join();
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        try {
+            string = threadGetUncaughtExceptionHandler3.getUncaughtExceptionHandler().toString();
+            if (string.indexOf("ThreadGetUncaughtExceptionHandler3") != -1) {
+                if (string.toString().indexOf("$") != -1) {
+                    if (string.toString().indexOf("@") != -1) {
+                        System.out.println(0);
+                        return;
+                    }
+                }
+            }
+        } catch (NullPointerException e2) {
+            System.out.println(2);
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/expected.txt b/testsuite/java_test/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/test.cfg b/testsuite/java_test/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8f92f8f09e38ff4c303b70014866b2b303ff976b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetUncaughtExceptionHandler3)
+run(ThreadGetUncaughtExceptionHandler3)
diff --git a/testsuite/java_test/thread_test/RT0035-rt-thread-ThreadholdsLock1/ThreadHoldsLock1.java b/testsuite/java_test/thread_test/RT0035-rt-thread-ThreadholdsLock1/ThreadHoldsLock1.java
new file mode 100644
index 0000000000000000000000000000000000000000..02bfda390b31bc5d4927f7d269967b4cb3b33ab0
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0035-rt-thread-ThreadholdsLock1/ThreadHoldsLock1.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadHoldsLock1 extends Thread {
+    static Object object = "aa";
+    static int i = 0;
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadHoldsLock1 threadHoldsLock1 = new ThreadHoldsLock1();
+        ThreadHoldsLock1 threadHoldsLock2 = new ThreadHoldsLock1();
+        threadHoldsLock1.start();
+        try {
+            sleep(200);
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+        threadHoldsLock2.start();
+        if (i == 1 && t == 1) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+    public void run() {
+        synchronized (object) {
+            try {
+                if (holdsLock(object)) {
+                    t = 1;
+                }
+                object.wait(100);
+            } catch (InterruptedException e1) {
+                System.out.println("Wait is interrupted");
+            }
+            if (holdsLock(object)) {
+                i = 1;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0035-rt-thread-ThreadholdsLock1/expected.txt b/testsuite/java_test/thread_test/RT0035-rt-thread-ThreadholdsLock1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0035-rt-thread-ThreadholdsLock1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0035-rt-thread-ThreadholdsLock1/test.cfg b/testsuite/java_test/thread_test/RT0035-rt-thread-ThreadholdsLock1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a50f3c3bb0e89108397c2a7d0d5cc5eb8b7795fb
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0035-rt-thread-ThreadholdsLock1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadHoldsLock1)
+run(ThreadHoldsLock1)
diff --git a/testsuite/java_test/thread_test/RT0036-rt-thread-ThreadholdsLock2/ThreadHoldsLock2.java b/testsuite/java_test/thread_test/RT0036-rt-thread-ThreadholdsLock2/ThreadHoldsLock2.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac0a21818a168def416aa6968afaf5b3c8e9c44e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0036-rt-thread-ThreadholdsLock2/ThreadHoldsLock2.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadHoldsLock2 extends Thread {
+    static Object object = "aa";
+    public static void main(String[] args) {
+        ThreadHoldsLock2 threadHoldsLock21 = new ThreadHoldsLock2();
+        ThreadHoldsLock2 threadHoldsLock22 = new ThreadHoldsLock2();
+        threadHoldsLock21.start();
+        try {
+            sleep(200);
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+        threadHoldsLock22.start();
+        if ((holdsLock(object))) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+    public void run() {
+        synchronized (object) {
+            try {
+                object.wait(100);
+            } catch (InterruptedException e1) {
+                System.out.println("Wait is interrupted");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0036-rt-thread-ThreadholdsLock2/expected.txt b/testsuite/java_test/thread_test/RT0036-rt-thread-ThreadholdsLock2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0036-rt-thread-ThreadholdsLock2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0036-rt-thread-ThreadholdsLock2/test.cfg b/testsuite/java_test/thread_test/RT0036-rt-thread-ThreadholdsLock2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..07b3cd689962edb95f280b41f7a61e7b137c7ca6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0036-rt-thread-ThreadholdsLock2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadHoldsLock2)
+run(ThreadHoldsLock2)
diff --git a/testsuite/java_test/thread_test/RT0037-rt-thread-ThreadholdsLock3/ThreadHoldsLock3.java b/testsuite/java_test/thread_test/RT0037-rt-thread-ThreadholdsLock3/ThreadHoldsLock3.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff462d6ede79c08556a8e7443035ec64a7e330da
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0037-rt-thread-ThreadholdsLock3/ThreadHoldsLock3.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadHoldsLock3 extends Thread {
+    static Object object = "aa";
+    static Object object1 = null;
+    public static void main(String[] args) {
+        ThreadHoldsLock3 threadHoldsLock31 = new ThreadHoldsLock3();
+        ThreadHoldsLock3 threadHoldsLock32 = new ThreadHoldsLock3();
+        threadHoldsLock31.start();
+        try {
+            sleep(200);
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+        threadHoldsLock32.start();
+        try {
+            holdsLock(object1);
+            System.out.println(2);
+        } catch (NullPointerException e) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (object) {
+            try {
+                object.wait(100);
+            } catch (InterruptedException e1) {
+                System.out.println("Wait is interrupted");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0037-rt-thread-ThreadholdsLock3/expected.txt b/testsuite/java_test/thread_test/RT0037-rt-thread-ThreadholdsLock3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0037-rt-thread-ThreadholdsLock3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0037-rt-thread-ThreadholdsLock3/test.cfg b/testsuite/java_test/thread_test/RT0037-rt-thread-ThreadholdsLock3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3260a932c3c53c02f5b519bf96564621d8e9e8d4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0037-rt-thread-ThreadholdsLock3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadHoldsLock3)
+run(ThreadHoldsLock3)
diff --git a/testsuite/java_test/thread_test/RT0038-rt-thread-ThreadisAlive1/ThreadIsAlive1.java b/testsuite/java_test/thread_test/RT0038-rt-thread-ThreadisAlive1/ThreadIsAlive1.java
new file mode 100644
index 0000000000000000000000000000000000000000..a955556a49a4d46d259e8c064abf1c1ccbafef6b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0038-rt-thread-ThreadisAlive1/ThreadIsAlive1.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadIsAlive1 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsAlive1 threadIsAlive1 = new ThreadIsAlive1();
+        if (threadIsAlive1.isAlive()) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0038-rt-thread-ThreadisAlive1/expected.txt b/testsuite/java_test/thread_test/RT0038-rt-thread-ThreadisAlive1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0038-rt-thread-ThreadisAlive1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0038-rt-thread-ThreadisAlive1/test.cfg b/testsuite/java_test/thread_test/RT0038-rt-thread-ThreadisAlive1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1550fcbbf13f66ce3ba6e1e74dfc3f96a1a56626
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0038-rt-thread-ThreadisAlive1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadIsAlive1)
+run(ThreadIsAlive1)
diff --git a/testsuite/java_test/thread_test/RT0039-rt-thread-ThreadisAlive2/ThreadIsAlive2.java b/testsuite/java_test/thread_test/RT0039-rt-thread-ThreadisAlive2/ThreadIsAlive2.java
new file mode 100644
index 0000000000000000000000000000000000000000..0764c8a3b0d5577c93b9ed5d5988aed2fd1047c6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0039-rt-thread-ThreadisAlive2/ThreadIsAlive2.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadIsAlive2 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsAlive2 threadIsAlive2 = new ThreadIsAlive2();
+        threadIsAlive2.start();
+        if (!threadIsAlive2.isAlive()) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+    public void run() {
+        try {
+            sleep(50);
+        } catch (InterruptedException e) {
+            System.out.println("Sleep is interrupted");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0039-rt-thread-ThreadisAlive2/expected.txt b/testsuite/java_test/thread_test/RT0039-rt-thread-ThreadisAlive2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0039-rt-thread-ThreadisAlive2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0039-rt-thread-ThreadisAlive2/test.cfg b/testsuite/java_test/thread_test/RT0039-rt-thread-ThreadisAlive2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a0a534b923fb7ef9bc8d7b7ff4a1a9e271b37fbb
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0039-rt-thread-ThreadisAlive2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadIsAlive2)
+run(ThreadIsAlive2)
diff --git a/testsuite/java_test/thread_test/RT0040-rt-thread-ThreadisAlive3/ThreadIsAlive3.java b/testsuite/java_test/thread_test/RT0040-rt-thread-ThreadisAlive3/ThreadIsAlive3.java
new file mode 100644
index 0000000000000000000000000000000000000000..42577fb989beb55ec36361d285c0d9cde6bfc7ba
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0040-rt-thread-ThreadisAlive3/ThreadIsAlive3.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadIsAlive3 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsAlive3 threadIsAlive3 = new ThreadIsAlive3();
+        threadIsAlive3.start();
+        try {
+            threadIsAlive3.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadIsAlive3.isAlive()) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0040-rt-thread-ThreadisAlive3/expected.txt b/testsuite/java_test/thread_test/RT0040-rt-thread-ThreadisAlive3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0040-rt-thread-ThreadisAlive3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0040-rt-thread-ThreadisAlive3/test.cfg b/testsuite/java_test/thread_test/RT0040-rt-thread-ThreadisAlive3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..000dc7f389e68dee5d3218e859b76c5d34a2ba67
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0040-rt-thread-ThreadisAlive3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadIsAlive3)
+run(ThreadIsAlive3)
diff --git a/testsuite/java_test/thread_test/RT0041-rt-thread-ThreadisDaemon1/ThreadIsDaemon1.java b/testsuite/java_test/thread_test/RT0041-rt-thread-ThreadisDaemon1/ThreadIsDaemon1.java
new file mode 100644
index 0000000000000000000000000000000000000000..f54235ad7c135a4715b7b6d0e236e6d521e3d794
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0041-rt-thread-ThreadisDaemon1/ThreadIsDaemon1.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadIsDaemon1 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsDaemon1 threadIsDaemon1 = new ThreadIsDaemon1();
+        threadIsDaemon1.setDaemon(true);
+        threadIsDaemon1.start();
+        if (threadIsDaemon1.isDaemon()) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0041-rt-thread-ThreadisDaemon1/expected.txt b/testsuite/java_test/thread_test/RT0041-rt-thread-ThreadisDaemon1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0041-rt-thread-ThreadisDaemon1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0041-rt-thread-ThreadisDaemon1/test.cfg b/testsuite/java_test/thread_test/RT0041-rt-thread-ThreadisDaemon1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ffb1a231636c222ffc26d666eed3580e9c8496c4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0041-rt-thread-ThreadisDaemon1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadIsDaemon1)
+run(ThreadIsDaemon1)
diff --git a/testsuite/java_test/thread_test/RT0042-rt-thread-ThreadisDaemon2/ThreadIsDaemon2.java b/testsuite/java_test/thread_test/RT0042-rt-thread-ThreadisDaemon2/ThreadIsDaemon2.java
new file mode 100644
index 0000000000000000000000000000000000000000..20123633069bee8a648e5aa7eae7f65acfa73a87
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0042-rt-thread-ThreadisDaemon2/ThreadIsDaemon2.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadIsDaemon2 extends Thread {
+    public static void main(String[] args) {
+        ThreadIsDaemon2 threadIsDaemon2 = new ThreadIsDaemon2();
+        threadIsDaemon2.setDaemon(true);
+        threadIsDaemon2.start();
+        if (currentThread().isDaemon()) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0042-rt-thread-ThreadisDaemon2/expected.txt b/testsuite/java_test/thread_test/RT0042-rt-thread-ThreadisDaemon2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0042-rt-thread-ThreadisDaemon2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0042-rt-thread-ThreadisDaemon2/test.cfg b/testsuite/java_test/thread_test/RT0042-rt-thread-ThreadisDaemon2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8697c5c4eaf17e82cac49eedf7d4f125c76107b2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0042-rt-thread-ThreadisDaemon2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadIsDaemon2)
+run(ThreadIsDaemon2)
diff --git a/testsuite/java_test/thread_test/RT0043-rt-thread-ThreadRunnable/ThreadRunnable.java b/testsuite/java_test/thread_test/RT0043-rt-thread-ThreadRunnable/ThreadRunnable.java
new file mode 100755
index 0000000000000000000000000000000000000000..61ab98240a004d394a8b6aee1082609680ef4a4b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0043-rt-thread-ThreadRunnable/ThreadRunnable.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadRunnable implements Runnable {
+    private int ticket = 10;
+    public static void main(String[] args) {
+        ThreadRunnable threadRunnable = new ThreadRunnable();
+        try {
+            new Thread(threadRunnable).start();
+            new Thread(threadRunnable).start();
+            new Thread(threadRunnable).start();
+        } catch (Exception e) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+    public synchronized void run() {
+        for (int i = 0; i < 20; i++) {
+            if (this.ticket > 0) {
+                this.ticket--;
+            } else {
+                break;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0043-rt-thread-ThreadRunnable/expected.txt b/testsuite/java_test/thread_test/RT0043-rt-thread-ThreadRunnable/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0043-rt-thread-ThreadRunnable/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0043-rt-thread-ThreadRunnable/test.cfg b/testsuite/java_test/thread_test/RT0043-rt-thread-ThreadRunnable/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1bbafadc5ea89210e9837fafe15e4c43f03ed92e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0043-rt-thread-ThreadRunnable/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadRunnable)
+run(ThreadRunnable)
diff --git a/testsuite/java_test/thread_test/RT0044-rt-thread-ThreadsetDaemon1/ThreadSetDaemon1.java b/testsuite/java_test/thread_test/RT0044-rt-thread-ThreadsetDaemon1/ThreadSetDaemon1.java
new file mode 100644
index 0000000000000000000000000000000000000000..b33e98d5c1e6f3a4bd1b0a298a7a0f9262dad1d7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0044-rt-thread-ThreadsetDaemon1/ThreadSetDaemon1.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetDaemon1 extends Thread {
+    static int i = 0;
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadSetDaemon1 threadSetDaemon1 = new ThreadSetDaemon1();
+        threadSetDaemon1.setDaemon(true);
+        threadSetDaemon1.start();
+        try {
+            sleep(100);
+            t++;
+        } catch (InterruptedException e2) {
+            System.out.println("Sleep is interrupted");
+        }
+        System.out.println(0);
+    }
+    public void run() {
+        try {
+            sleep(1000);
+            i++;
+            System.out.println(2);
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0044-rt-thread-ThreadsetDaemon1/expected.txt b/testsuite/java_test/thread_test/RT0044-rt-thread-ThreadsetDaemon1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0044-rt-thread-ThreadsetDaemon1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0044-rt-thread-ThreadsetDaemon1/test.cfg b/testsuite/java_test/thread_test/RT0044-rt-thread-ThreadsetDaemon1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..89c84c85c2059d44af7ab546e22720fd3c462b14
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0044-rt-thread-ThreadsetDaemon1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetDaemon1)
+run(ThreadSetDaemon1)
diff --git a/testsuite/java_test/thread_test/RT0045-rt-thread-ThreadsetDaemon2/ThreadSetDaemon2.java b/testsuite/java_test/thread_test/RT0045-rt-thread-ThreadsetDaemon2/ThreadSetDaemon2.java
new file mode 100644
index 0000000000000000000000000000000000000000..33a4489e3525574c6efa092c0edcd0f378b02921
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0045-rt-thread-ThreadsetDaemon2/ThreadSetDaemon2.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetDaemon2 extends Thread {
+    public static void main(String[] args) {
+        ThreadSetDaemon2 threadSetDaemon2 = new ThreadSetDaemon2();
+        threadSetDaemon2.start();
+        try {
+            threadSetDaemon2.setDaemon(true);
+            System.out.println(2);
+        } catch (IllegalThreadStateException e2) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        for (int i = 0; i < 5; i++) {
+            try {
+                sleep(200);
+            } catch (InterruptedException e1) {
+                System.out.println("Sleep is interrupted");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0045-rt-thread-ThreadsetDaemon2/expected.txt b/testsuite/java_test/thread_test/RT0045-rt-thread-ThreadsetDaemon2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0045-rt-thread-ThreadsetDaemon2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0045-rt-thread-ThreadsetDaemon2/test.cfg b/testsuite/java_test/thread_test/RT0045-rt-thread-ThreadsetDaemon2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6952815af02dbeef0c68c78d8f7204ed61abf13a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0045-rt-thread-ThreadsetDaemon2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetDaemon2)
+run(ThreadSetDaemon2)
diff --git a/testsuite/java_test/thread_test/RT0046-rt-thread-ThreadsetDaemon3/ThreadSetDaemon3.java b/testsuite/java_test/thread_test/RT0046-rt-thread-ThreadsetDaemon3/ThreadSetDaemon3.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7eb8024cd232f3753e02d9c7c077e9088ef31f9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0046-rt-thread-ThreadsetDaemon3/ThreadSetDaemon3.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetDaemon3 extends Thread {
+    static int i = 0;
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadSetDaemon3 threadSetDaemon31 = new ThreadSetDaemon3();
+        ThreadSetDaemon3 threadSetDaemon32 = new ThreadSetDaemon3();
+        threadSetDaemon31.setDaemon(true);
+        threadSetDaemon31.start();
+        try {
+            sleep(50);
+            t++;
+        } catch (InterruptedException e3) {
+            System.out.println("Sleep is interrupted");
+        }
+        threadSetDaemon32.start();
+        try {
+            sleep(50);
+            t++;
+        } catch (InterruptedException e2) {
+            System.out.println("Sleep is interrupted");
+        }
+        System.out.println(0);
+    }
+    public void run() {
+        try {
+            sleep(300);
+            i++;
+        } catch (InterruptedException e1) {
+            System.out.println("Sleep is interrupted");
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0046-rt-thread-ThreadsetDaemon3/expected.txt b/testsuite/java_test/thread_test/RT0046-rt-thread-ThreadsetDaemon3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0046-rt-thread-ThreadsetDaemon3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0046-rt-thread-ThreadsetDaemon3/test.cfg b/testsuite/java_test/thread_test/RT0046-rt-thread-ThreadsetDaemon3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..96398e9e768a4bdff3a004992bfe490820bc4b88
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0046-rt-thread-ThreadsetDaemon3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetDaemon3)
+run(ThreadSetDaemon3)
diff --git a/testsuite/java_test/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/ThreadSetDefaultUncaughtExceptionHandler.java b/testsuite/java_test/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/ThreadSetDefaultUncaughtExceptionHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d24a40c12135910a61baf4abf2a7eb658288ad2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/ThreadSetDefaultUncaughtExceptionHandler.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.atomic.AtomicInteger;
+public class ThreadSetDefaultUncaughtExceptionHandler extends Thread{
+    static AtomicInteger i = new AtomicInteger(0);
+    static String p;
+    public void run() {
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+        ThreadSetDefaultUncaughtExceptionHandler thread_obj1 = new ThreadSetDefaultUncaughtExceptionHandler();
+        ThreadSetDefaultUncaughtExceptionHandler thread_obj2 = new ThreadSetDefaultUncaughtExceptionHandler();
+        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+                p = e.toString();
+                if (p.indexOf("java.lang.ArithmeticException") != -1) {
+                    i.incrementAndGet();
+                }
+            }
+        });
+        thread_obj1.start();
+        thread_obj2.start();
+        try{
+        thread_obj1.join();
+        thread_obj2.join();
+        }
+        catch (InterruptedException e1) {
+        }
+        if(i.get() == 2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/expected.txt b/testsuite/java_test/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/test.cfg b/testsuite/java_test/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..93f0107a98e01850dfb72e9a51d2c274f4995bf3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetDefaultUncaughtExceptionHandler)
+run(ThreadSetDefaultUncaughtExceptionHandler)
diff --git a/testsuite/java_test/thread_test/RT0048-rt-thread-ThreadsetName1/ThreadSetName1.java b/testsuite/java_test/thread_test/RT0048-rt-thread-ThreadsetName1/ThreadSetName1.java
new file mode 100644
index 0000000000000000000000000000000000000000..310fb2904e8801227af87d65b1001f2ad9899e47
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0048-rt-thread-ThreadsetName1/ThreadSetName1.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetName1 extends Thread {
+    public static void main(String[] args) {
+        ThreadSetName1 thread_obj = new ThreadSetName1();
+        thread_obj.start();
+        thread_obj.setName("我abc123!?*{$");
+        if (thread_obj.getName().equals("我abc123!?*{$")) {
+            System.out.println(0);
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0048-rt-thread-ThreadsetName1/expected.txt b/testsuite/java_test/thread_test/RT0048-rt-thread-ThreadsetName1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0048-rt-thread-ThreadsetName1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0048-rt-thread-ThreadsetName1/test.cfg b/testsuite/java_test/thread_test/RT0048-rt-thread-ThreadsetName1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0ce47b50187e37e6fd82d25309a055fa6b3e4d7f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0048-rt-thread-ThreadsetName1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetName1)
+run(ThreadSetName1)
diff --git a/testsuite/java_test/thread_test/RT0049-rt-thread-ThreadsetName2/ThreadSetName2.java b/testsuite/java_test/thread_test/RT0049-rt-thread-ThreadsetName2/ThreadSetName2.java
new file mode 100644
index 0000000000000000000000000000000000000000..799e5ef7494d6632f2c83eed18856d81e75d2681
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0049-rt-thread-ThreadsetName2/ThreadSetName2.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetName2 extends Thread {
+    public static void main(String[] args) {
+        String string = null;
+        ThreadSetName2 threa_obj = new ThreadSetName2();
+        try {
+            threa_obj.setName(string);
+            System.out.println(2);
+        } catch (NullPointerException e) {
+            System.out.println(0);
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0049-rt-thread-ThreadsetName2/expected.txt b/testsuite/java_test/thread_test/RT0049-rt-thread-ThreadsetName2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0049-rt-thread-ThreadsetName2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0049-rt-thread-ThreadsetName2/test.cfg b/testsuite/java_test/thread_test/RT0049-rt-thread-ThreadsetName2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ee6951cb986b1a83ce0f9822965194da041ca72a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0049-rt-thread-ThreadsetName2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetName2)
+run(ThreadSetName2)
diff --git a/testsuite/java_test/thread_test/RT0050-rt-thread-ThreadsetPriority1/ThreadSetPriority1.java b/testsuite/java_test/thread_test/RT0050-rt-thread-ThreadsetPriority1/ThreadSetPriority1.java
new file mode 100644
index 0000000000000000000000000000000000000000..3de59b3735a899576bd2b1d327174b886b953ad2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0050-rt-thread-ThreadsetPriority1/ThreadSetPriority1.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetPriority1 extends Thread {
+    public static void main(String[] args) {
+        ThreadSetPriority1 thread_obj1 = new ThreadSetPriority1();
+        ThreadSetPriority1 thread_obj2 = new ThreadSetPriority1();
+        ThreadSetPriority1 thread_obj3 = new ThreadSetPriority1();
+        ThreadSetPriority1 thread_obj4 = new ThreadSetPriority1();
+        thread_obj1.setPriority(6);
+        thread_obj4.setPriority(MIN_PRIORITY);
+        thread_obj2.setPriority(MAX_PRIORITY);
+        thread_obj3.setPriority(3);
+        thread_obj1.setPriority(2);
+        thread_obj2.setPriority(MIN_PRIORITY);
+        thread_obj3.setPriority(NORM_PRIORITY);
+        thread_obj4.setPriority(7);
+        thread_obj1.start();
+        thread_obj2.start();
+        thread_obj3.start();
+        thread_obj4.start();
+        if (thread_obj1.getPriority() != 2) {
+            System.out.println(2);
+        }
+        if (thread_obj2.getPriority() != 1) {
+            System.out.println(2);
+        }
+        if (thread_obj3.getPriority() != 5) {
+            System.out.println(2);
+        }
+        if (thread_obj4.getPriority() != 7) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0050-rt-thread-ThreadsetPriority1/expected.txt b/testsuite/java_test/thread_test/RT0050-rt-thread-ThreadsetPriority1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0050-rt-thread-ThreadsetPriority1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0050-rt-thread-ThreadsetPriority1/test.cfg b/testsuite/java_test/thread_test/RT0050-rt-thread-ThreadsetPriority1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ab9a725d2733df0d89d12a79d7fe10a670a8ee66
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0050-rt-thread-ThreadsetPriority1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetPriority1)
+run(ThreadSetPriority1)
diff --git a/testsuite/java_test/thread_test/RT0051-rt-thread-ThreadsetPriority2/ThreadSetPriority2.java b/testsuite/java_test/thread_test/RT0051-rt-thread-ThreadsetPriority2/ThreadSetPriority2.java
new file mode 100644
index 0000000000000000000000000000000000000000..528f4c4170cb629b83518b95f50307f374f16184
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0051-rt-thread-ThreadsetPriority2/ThreadSetPriority2.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadSetPriority_a extends Thread {
+    public synchronized void run() {
+        for (int i = 0; i < 10; i++) {
+        }
+    }
+}
+public class ThreadSetPriority2 extends ThreadSetPriority_a {
+    public static void main(String[] args) {
+        currentThread().setPriority(2);
+        ThreadSetPriority2 thread_obj1 = new ThreadSetPriority2();
+        ThreadSetPriority2 thread_obj2 = new ThreadSetPriority2();
+        thread_obj1.start();
+        thread_obj2.start();
+        if (thread_obj1.getPriority() != 2) {
+            System.out.println(2);
+            return ;
+        }
+        if (thread_obj2.getPriority() != 2) {
+            System.out.println(2);
+            return ;
+        }
+        System.out.println(0);
+        return;
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0051-rt-thread-ThreadsetPriority2/expected.txt b/testsuite/java_test/thread_test/RT0051-rt-thread-ThreadsetPriority2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0051-rt-thread-ThreadsetPriority2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0051-rt-thread-ThreadsetPriority2/test.cfg b/testsuite/java_test/thread_test/RT0051-rt-thread-ThreadsetPriority2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9c16e0352be0a40ba025f58d060b124a8ecbf395
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0051-rt-thread-ThreadsetPriority2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetPriority2)
+run(ThreadSetPriority2)
diff --git a/testsuite/java_test/thread_test/RT0052-rt-thread-ThreadsetPriority3/ThreadsSetPriority3.java b/testsuite/java_test/thread_test/RT0052-rt-thread-ThreadsetPriority3/ThreadsSetPriority3.java
new file mode 100644
index 0000000000000000000000000000000000000000..d20642180b208263817f1a6b87cd2cc4b43fce9a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0052-rt-thread-ThreadsetPriority3/ThreadsSetPriority3.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadsSetPriority3 extends Thread {
+    public static void main(String[] args) {
+        ThreadsSetPriority3 thread_obj1 = new ThreadsSetPriority3();
+        ThreadsSetPriority3 thread_obj2 = new ThreadsSetPriority3();
+        ThreadsSetPriority3 thread_obj3 = new ThreadsSetPriority3();
+        ThreadsSetPriority3 thread_obj4 = new ThreadsSetPriority3();
+        try {
+            thread_obj1.setPriority(11);
+            System.out.println(2);
+        } catch (IllegalArgumentException e1) {
+            try {
+                thread_obj2.setPriority(0);
+                System.out.println(2);
+            } catch (IllegalArgumentException e2) {
+                try {
+                    thread_obj3.setPriority(MAX_PRIORITY + 1);
+                    System.out.println(2);
+                } catch (IllegalArgumentException e3) {
+                    try {
+                        thread_obj4.setPriority(MIN_PRIORITY - 1);
+                        System.out.println(2);
+                    } catch (IllegalArgumentException e4) {
+                        System.out.println(0);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0052-rt-thread-ThreadsetPriority3/expected.txt b/testsuite/java_test/thread_test/RT0052-rt-thread-ThreadsetPriority3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0052-rt-thread-ThreadsetPriority3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0052-rt-thread-ThreadsetPriority3/test.cfg b/testsuite/java_test/thread_test/RT0052-rt-thread-ThreadsetPriority3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bf6edc34289dfe45b46bf85656746423a4c7dab9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0052-rt-thread-ThreadsetPriority3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadsSetPriority3)
+run(ThreadsSetPriority3)
diff --git a/testsuite/java_test/thread_test/RT0053-rt-thread-ThreadsetPriority4/ThreadSetPriority4.java b/testsuite/java_test/thread_test/RT0053-rt-thread-ThreadsetPriority4/ThreadSetPriority4.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a876121ef6dc5b0b444dfbaf277cc6645f8c17b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0053-rt-thread-ThreadsetPriority4/ThreadSetPriority4.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetPriority4 extends Thread {
+    public static void main(String[] args) {
+        ThreadSetPriority4 thread_obj1 = new ThreadSetPriority4();
+        ThreadSetPriority4 thread_obj2 = new ThreadSetPriority4();
+        ThreadSetPriority4 thread_obj3 = new ThreadSetPriority4();
+        thread_obj1.start();
+        thread_obj2.start();
+        thread_obj3.start();
+        try {
+            thread_obj1.join();
+            thread_obj2.join();
+            thread_obj3.join();
+        } catch (InterruptedException e) {
+        }
+        thread_obj1.setPriority(7);
+        thread_obj2.setPriority(MAX_PRIORITY);
+        thread_obj3.setPriority(MIN_PRIORITY + 1);
+        if (thread_obj1.getPriority() != 5) {
+            System.out.println(2);
+        }
+        if (thread_obj2.getPriority() != 5) {
+            System.out.println(2);
+        }
+        if (thread_obj3.getPriority() != 5) {
+            System.out.println(2);
+        }
+        System.out.println(0);
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0053-rt-thread-ThreadsetPriority4/expected.txt b/testsuite/java_test/thread_test/RT0053-rt-thread-ThreadsetPriority4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0053-rt-thread-ThreadsetPriority4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0053-rt-thread-ThreadsetPriority4/test.cfg b/testsuite/java_test/thread_test/RT0053-rt-thread-ThreadsetPriority4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..75aa29442884af7bb7c219bef624a95d668aaf1c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0053-rt-thread-ThreadsetPriority4/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetPriority4)
+run(ThreadSetPriority4)
diff --git a/testsuite/java_test/thread_test/RT0054-rt-thread-ThreadsetPriority5/ThreadSetPriority5.java b/testsuite/java_test/thread_test/RT0054-rt-thread-ThreadsetPriority5/ThreadSetPriority5.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9f3b39519243b105fdf1860c5d5d99f0e680f64
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0054-rt-thread-ThreadsetPriority5/ThreadSetPriority5.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetPriority5 extends Thread {
+    public static void main(String[] args) {
+        Integer i = null;
+        ThreadSetPriority5 thread_obj1 = new ThreadSetPriority5();
+        try {
+            thread_obj1.setPriority(i);
+            System.out.println(2);
+        } catch (IllegalArgumentException e) {
+            System.out.println(2);
+        } catch (NullPointerException e) {
+            System.out.println(0);
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0054-rt-thread-ThreadsetPriority5/expected.txt b/testsuite/java_test/thread_test/RT0054-rt-thread-ThreadsetPriority5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0054-rt-thread-ThreadsetPriority5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0054-rt-thread-ThreadsetPriority5/test.cfg b/testsuite/java_test/thread_test/RT0054-rt-thread-ThreadsetPriority5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6ce314ab907e44bd8409d350cad84d2be87a87c1
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0054-rt-thread-ThreadsetPriority5/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetPriority5)
+run(ThreadSetPriority5)
diff --git a/testsuite/java_test/thread_test/RT0055-rt-thread-ThreadsetPriority6/ThreadSetPriority6.java b/testsuite/java_test/thread_test/RT0055-rt-thread-ThreadsetPriority6/ThreadSetPriority6.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b17d5946f0bef1ba004b0ef7b57115349114af9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0055-rt-thread-ThreadsetPriority6/ThreadSetPriority6.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetPriority6 extends Thread {
+    public ThreadSetPriority6(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public static void main(String[] args) {
+        ThreadGroup cls1 = new ThreadGroup("god");
+        ThreadSetPriority6 cls2 = new ThreadSetPriority6(cls1, "good");
+        cls1.setMaxPriority(3);
+        if (cls1.getMaxPriority() == 3 && cls2.getPriority() == 5) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0055-rt-thread-ThreadsetPriority6/expected.txt b/testsuite/java_test/thread_test/RT0055-rt-thread-ThreadsetPriority6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0055-rt-thread-ThreadsetPriority6/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0055-rt-thread-ThreadsetPriority6/test.cfg b/testsuite/java_test/thread_test/RT0055-rt-thread-ThreadsetPriority6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0657d8d17bb6d3f8ec042b3111d40545e42cff94
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0055-rt-thread-ThreadsetPriority6/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetPriority6)
+run(ThreadSetPriority6)
diff --git a/testsuite/java_test/thread_test/RT0056-rt-thread-ThreadsetPriority7/ThreadSetPriority7.java b/testsuite/java_test/thread_test/RT0056-rt-thread-ThreadsetPriority7/ThreadSetPriority7.java
new file mode 100644
index 0000000000000000000000000000000000000000..dec5567a14a3b67d762c2e056f82c6fd49486c2d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0056-rt-thread-ThreadsetPriority7/ThreadSetPriority7.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetPriority7 extends Thread {
+    public ThreadSetPriority7(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public static void main(String[] args) {
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadSetPriority7 threadSetPriority7 = new ThreadSetPriority7(threadGroup, "good");
+        threadGroup.setMaxPriority(3);
+        threadSetPriority7.setPriority(8);
+        if (threadGroup.getMaxPriority() == 3 && threadSetPriority7.getPriority() == 3) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0056-rt-thread-ThreadsetPriority7/expected.txt b/testsuite/java_test/thread_test/RT0056-rt-thread-ThreadsetPriority7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0056-rt-thread-ThreadsetPriority7/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0056-rt-thread-ThreadsetPriority7/test.cfg b/testsuite/java_test/thread_test/RT0056-rt-thread-ThreadsetPriority7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..abc25a3015d2cb45a1159a9c5732cad1c81c06d7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0056-rt-thread-ThreadsetPriority7/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetPriority7)
+run(ThreadSetPriority7)
diff --git a/testsuite/java_test/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/ThreadSetUncaughtExceptionHandler.java b/testsuite/java_test/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/ThreadSetUncaughtExceptionHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea6febeda958ecca6eb62a092a7d8c9c1465261e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/ThreadSetUncaughtExceptionHandler.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetUncaughtExceptionHandler extends Thread {
+    static int i = 0;
+    static String p;
+    public void run() {
+        System.out.println(3/0);
+    }
+    public static void main(String[] args) {
+        ThreadSetUncaughtExceptionHandler cls = new ThreadSetUncaughtExceptionHandler();
+        ThreadSetUncaughtExceptionHandler cls2 = new ThreadSetUncaughtExceptionHandler();
+        cls.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+                p = e.toString();
+                if (p.indexOf("java.lang.ArithmeticException") != -1) {
+                    i++;
+                }
+            }
+        });
+        cls2.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+            }
+        });
+        cls.start();
+        cls2.start();
+        try {
+            cls.join();
+            cls2.join();
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if(i == 1) {
+            System.out.println(0);
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/expected.txt b/testsuite/java_test/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/test.cfg b/testsuite/java_test/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..768c786e9f3c3c56212183e43f4ff92858bd4daa
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0057-rt-thread-ThreadsetUncaughtExceptionHandler/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetUncaughtExceptionHandler)
+run(ThreadSetUncaughtExceptionHandler)
diff --git a/testsuite/java_test/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/ThreadStateInterrupt1.java b/testsuite/java_test/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/ThreadStateInterrupt1.java
new file mode 100644
index 0000000000000000000000000000000000000000..994c15d5ea5a34ccd4ce9d206d533d5ae0a6c1b3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/ThreadStateInterrupt1.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateInterrupt1 extends Thread {
+    static int i = 0;
+    static boolean j;
+    public static void main(String[] args) {
+        ThreadStateInterrupt1 cls = new ThreadStateInterrupt1();
+        cls.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e2) {
+            System.err.println(e2);
+        }
+        cls.interrupt();
+        try {
+            sleep(50);
+        } catch (InterruptedException e3) {
+            System.err.println(e3);
+        }
+        if (j && i == 0) {
+            System.out.println(0);
+        }
+    }
+    public synchronized void run() {
+        try {
+            while (!Thread.currentThread().isInterrupted()) {
+                wait();
+                i++;
+            }
+        } catch (InterruptedException e1) {
+            Thread.currentThread().interrupt();
+            j = Thread.currentThread().isInterrupted();
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/expected.txt b/testsuite/java_test/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/test.cfg b/testsuite/java_test/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a601f543c1addc14f962299bd3a3b8d909061038
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0058-rt-thread-ThreadStateinterrupt1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateInterrupt1)
+run(ThreadStateInterrupt1)
diff --git a/testsuite/java_test/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/ThreadStateInterrupt2.java b/testsuite/java_test/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/ThreadStateInterrupt2.java
new file mode 100644
index 0000000000000000000000000000000000000000..08d7fe894795c8bdbd0ca53dbb786fc6dc50f00c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/ThreadStateInterrupt2.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateInterrupt2 extends Thread {
+    static int i = 0;
+    static boolean j = false;
+    public static void main(String[] args) {
+        ThreadStateInterrupt2 cls = new ThreadStateInterrupt2();
+        cls.start();
+        try {
+            sleep(50);
+        } catch (InterruptedException e2) {
+            System.err.println(e2);
+        }
+        if (!j && !cls.isInterrupted() && i == 0) {
+            System.out.println(0);
+        }
+    }
+    public synchronized void run() {
+        try {
+            while (!Thread.currentThread().isInterrupted()) {
+                wait(2000);
+                break;
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            j = Thread.currentThread().isInterrupted();
+            i++;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/expected.txt b/testsuite/java_test/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/test.cfg b/testsuite/java_test/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5d7768c342c7e3b2149f5a8c117890c4fe17f430
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0059-rt-thread-ThreadStateinterrupt2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateInterrupt2)
+run(ThreadStateInterrupt2)
diff --git a/testsuite/java_test/thread_test/RT0060-rt-thread-ThreadStatejoin1/ThreadStateJoin1.java b/testsuite/java_test/thread_test/RT0060-rt-thread-ThreadStatejoin1/ThreadStateJoin1.java
new file mode 100644
index 0000000000000000000000000000000000000000..e426a38bb0d137b48649ee5e94dcd93785b50b47
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0060-rt-thread-ThreadStatejoin1/ThreadStateJoin1.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin1 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateJoin1 cls = new ThreadStateJoin1();
+        cls.start();
+        try {
+            cls.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (cls.getState().toString().equals("TERMINATED")) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0060-rt-thread-ThreadStatejoin1/expected.txt b/testsuite/java_test/thread_test/RT0060-rt-thread-ThreadStatejoin1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0060-rt-thread-ThreadStatejoin1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0060-rt-thread-ThreadStatejoin1/test.cfg b/testsuite/java_test/thread_test/RT0060-rt-thread-ThreadStatejoin1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1da7f5aed2cbac52c6f11432d58db1d23833875c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0060-rt-thread-ThreadStatejoin1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin1)
+run(ThreadStateJoin1)
diff --git a/testsuite/java_test/thread_test/RT0061-rt-thread-ThreadStatejoin11/ThreadStateJoin11.java b/testsuite/java_test/thread_test/RT0061-rt-thread-ThreadStatejoin11/ThreadStateJoin11.java
new file mode 100644
index 0000000000000000000000000000000000000000..74ccd4bf61aa40f10b987dae384beb88e17a2f69
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0061-rt-thread-ThreadStatejoin11/ThreadStateJoin11.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin11 extends Thread {
+    static Object ob = "aa";
+    public static void main(String[] args) {
+        long startTime;
+        long endTime;
+        ThreadStateJoin11 cls = new ThreadStateJoin11();
+        cls.start();
+        startTime = System.currentTimeMillis();
+        try {
+            cls.join(1000);
+        } catch (InterruptedException ex) {
+            System.out.println("Join is interrupted");
+        }
+        endTime = System.currentTimeMillis();
+        if (endTime - startTime > 970 && endTime - startTime < 1030) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (ob) {
+            try {
+                sleep(2000);
+            } catch (InterruptedException e) {
+                System.out.println("Sleep is interrupted");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0061-rt-thread-ThreadStatejoin11/expected.txt b/testsuite/java_test/thread_test/RT0061-rt-thread-ThreadStatejoin11/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0061-rt-thread-ThreadStatejoin11/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0061-rt-thread-ThreadStatejoin11/test.cfg b/testsuite/java_test/thread_test/RT0061-rt-thread-ThreadStatejoin11/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2361ac79628f75e75107a821a8230614e0db4120
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0061-rt-thread-ThreadStatejoin11/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin11)
+run(ThreadStateJoin11)
diff --git a/testsuite/java_test/thread_test/RT0062-rt-thread-ThreadStatejoin12/ThreadStateJoin12.java b/testsuite/java_test/thread_test/RT0062-rt-thread-ThreadStatejoin12/ThreadStateJoin12.java
new file mode 100644
index 0000000000000000000000000000000000000000..08edc6070d7a858f49e6fd657923157c6c92b8bd
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0062-rt-thread-ThreadStatejoin12/ThreadStateJoin12.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin12 extends Thread {
+    public static void main(String[] args) {
+        long startTime;
+        long endTime;
+        ThreadStateJoin12 cls = new ThreadStateJoin12();
+        cls.start();
+        startTime = System.currentTimeMillis();
+        try {
+            cls.join(600);
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        endTime = System.currentTimeMillis();
+        if (endTime - startTime > 590 && endTime - startTime < 1010) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0062-rt-thread-ThreadStatejoin12/expected.txt b/testsuite/java_test/thread_test/RT0062-rt-thread-ThreadStatejoin12/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0062-rt-thread-ThreadStatejoin12/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0062-rt-thread-ThreadStatejoin12/test.cfg b/testsuite/java_test/thread_test/RT0062-rt-thread-ThreadStatejoin12/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5ddaa916fc0ed59ca0cf2aed9e187c6dd364bc93
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0062-rt-thread-ThreadStatejoin12/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin12)
+run(ThreadStateJoin12)
diff --git a/testsuite/java_test/thread_test/RT0063-rt-thread-ThreadStatejoin13/ThreadStateJoin13.java b/testsuite/java_test/thread_test/RT0063-rt-thread-ThreadStatejoin13/ThreadStateJoin13.java
new file mode 100644
index 0000000000000000000000000000000000000000..63d98e3bae7088e57dd74b9b96e63a3f47561ef5
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0063-rt-thread-ThreadStatejoin13/ThreadStateJoin13.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin13 extends Thread {
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateJoin13 cls = new ThreadStateJoin13();
+        cls.start();
+        try {
+            cls.join(0);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (cls.getState().toString().equals("TERMINATED") && t == 4) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0063-rt-thread-ThreadStatejoin13/expected.txt b/testsuite/java_test/thread_test/RT0063-rt-thread-ThreadStatejoin13/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0063-rt-thread-ThreadStatejoin13/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0063-rt-thread-ThreadStatejoin13/test.cfg b/testsuite/java_test/thread_test/RT0063-rt-thread-ThreadStatejoin13/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ef00efae4c1ecf3bfa7b045fa38251ee41865389
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0063-rt-thread-ThreadStatejoin13/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin13)
+run(ThreadStateJoin13)
diff --git a/testsuite/java_test/thread_test/RT0064-rt-thread-ThreadStatejoin14/ThreadStateJoin14.java b/testsuite/java_test/thread_test/RT0064-rt-thread-ThreadStatejoin14/ThreadStateJoin14.java
new file mode 100644
index 0000000000000000000000000000000000000000..406849ba498b74aecbcb28731f0985101c1bf04a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0064-rt-thread-ThreadStatejoin14/ThreadStateJoin14.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin14 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateJoin14 cls = new ThreadStateJoin14();
+        cls.start();
+        try {
+            cls.join(-10);
+        } catch (InterruptedException e1) {
+            System.out.println(2);
+        } catch (IllegalArgumentException e2) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0064-rt-thread-ThreadStatejoin14/expected.txt b/testsuite/java_test/thread_test/RT0064-rt-thread-ThreadStatejoin14/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0064-rt-thread-ThreadStatejoin14/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0064-rt-thread-ThreadStatejoin14/test.cfg b/testsuite/java_test/thread_test/RT0064-rt-thread-ThreadStatejoin14/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5d16b555149be604b2c1544a54257df5ea23542a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0064-rt-thread-ThreadStatejoin14/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin14)
+run(ThreadStateJoin14)
diff --git a/testsuite/java_test/thread_test/RT0065-rt-thread-ThreadStatejoin15/ThreadStateJoin15.java b/testsuite/java_test/thread_test/RT0065-rt-thread-ThreadStatejoin15/ThreadStateJoin15.java
new file mode 100644
index 0000000000000000000000000000000000000000..11b2583c12c1c034720186fa3de26b24d0b55d12
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0065-rt-thread-ThreadStatejoin15/ThreadStateJoin15.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin15 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateJoin15 cls = new ThreadStateJoin15();
+        cls.start();
+        try {
+            cls.join(1000, -10);
+        } catch (InterruptedException e1) {
+            System.out.println(2);
+        } catch (IllegalArgumentException e2) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0065-rt-thread-ThreadStatejoin15/expected.txt b/testsuite/java_test/thread_test/RT0065-rt-thread-ThreadStatejoin15/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0065-rt-thread-ThreadStatejoin15/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0065-rt-thread-ThreadStatejoin15/test.cfg b/testsuite/java_test/thread_test/RT0065-rt-thread-ThreadStatejoin15/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ce67f07b103edeea792f781e3420d473be272f99
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0065-rt-thread-ThreadStatejoin15/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin15)
+run(ThreadStateJoin15)
diff --git a/testsuite/java_test/thread_test/RT0066-rt-thread-ThreadStatejoin2/ThreadStateJoin2.java b/testsuite/java_test/thread_test/RT0066-rt-thread-ThreadStatejoin2/ThreadStateJoin2.java
new file mode 100644
index 0000000000000000000000000000000000000000..dec2597a8e2c5a1fb9d4ff5b751793e158494f23
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0066-rt-thread-ThreadStatejoin2/ThreadStateJoin2.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin2 extends Thread {
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateJoin2 threadStateJoin2 = new ThreadStateJoin2();
+        threadStateJoin2.start();
+        try {
+            threadStateJoin2.join(1000);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin2.getState().toString().equals("TERMINATED") && t == 4) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0066-rt-thread-ThreadStatejoin2/expected.txt b/testsuite/java_test/thread_test/RT0066-rt-thread-ThreadStatejoin2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0066-rt-thread-ThreadStatejoin2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0066-rt-thread-ThreadStatejoin2/test.cfg b/testsuite/java_test/thread_test/RT0066-rt-thread-ThreadStatejoin2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ff0c2b243cec3aa5392b90b3f0201c8eb41580c4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0066-rt-thread-ThreadStatejoin2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin2)
+run(ThreadStateJoin2)
diff --git a/testsuite/java_test/thread_test/RT0067-rt-thread-ThreadStatejoin3/ThreadStateJoin3.java b/testsuite/java_test/thread_test/RT0067-rt-thread-ThreadStatejoin3/ThreadStateJoin3.java
new file mode 100644
index 0000000000000000000000000000000000000000..a853c2a86dbf750480e47c626566845f686f2408
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0067-rt-thread-ThreadStatejoin3/ThreadStateJoin3.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin3 extends Thread {
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateJoin3 threadStateJoin3 = new ThreadStateJoin3();
+        threadStateJoin3.start();
+        try {
+            threadStateJoin3.join(1000, 300);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin3.getState().toString().equals("TERMINATED") && t == 4) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 3; i++) {
+                try {
+                    sleep(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0067-rt-thread-ThreadStatejoin3/expected.txt b/testsuite/java_test/thread_test/RT0067-rt-thread-ThreadStatejoin3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0067-rt-thread-ThreadStatejoin3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0067-rt-thread-ThreadStatejoin3/test.cfg b/testsuite/java_test/thread_test/RT0067-rt-thread-ThreadStatejoin3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8fc2eec0cc5afa68125f78f46c2f2e8b85a3468f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0067-rt-thread-ThreadStatejoin3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin3)
+run(ThreadStateJoin3)
diff --git a/testsuite/java_test/thread_test/RT0068-rt-thread-ThreadStatejoin4/ThreadStateJoin4.java b/testsuite/java_test/thread_test/RT0068-rt-thread-ThreadStatejoin4/ThreadStateJoin4.java
new file mode 100644
index 0000000000000000000000000000000000000000..a54fd4e4707193deffed7ba63ed1a00c45dd549a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0068-rt-thread-ThreadStatejoin4/ThreadStateJoin4.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin4 extends Thread {
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateJoin4 threadStateJoin4 = new ThreadStateJoin4();
+        threadStateJoin4.start();
+        try {
+            threadStateJoin4.join(500);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin4.getState().toString().equals("TIMED_WAITING") && t == 3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    wait(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0068-rt-thread-ThreadStatejoin4/expected.txt b/testsuite/java_test/thread_test/RT0068-rt-thread-ThreadStatejoin4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0068-rt-thread-ThreadStatejoin4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0068-rt-thread-ThreadStatejoin4/test.cfg b/testsuite/java_test/thread_test/RT0068-rt-thread-ThreadStatejoin4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..04d3943efa2c01d3b162f42805e93b33c6649221
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0068-rt-thread-ThreadStatejoin4/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin4)
+run(ThreadStateJoin4)
diff --git a/testsuite/java_test/thread_test/RT0069-rt-thread-ThreadStatejoin5/ThreadStateJoin5.java b/testsuite/java_test/thread_test/RT0069-rt-thread-ThreadStatejoin5/ThreadStateJoin5.java
new file mode 100644
index 0000000000000000000000000000000000000000..968791fc6dcb57a95e8ec9854e1d3939cf289cf8
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0069-rt-thread-ThreadStatejoin5/ThreadStateJoin5.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin5 extends Thread {
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateJoin5 threadStateJoin5 = new ThreadStateJoin5();
+        threadStateJoin5.start();
+        try {
+            threadStateJoin5.join(500, 300);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin5.getState().toString().equals("TIMED_WAITING") && t == 3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    wait(200);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0069-rt-thread-ThreadStatejoin5/expected.txt b/testsuite/java_test/thread_test/RT0069-rt-thread-ThreadStatejoin5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0069-rt-thread-ThreadStatejoin5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0069-rt-thread-ThreadStatejoin5/test.cfg b/testsuite/java_test/thread_test/RT0069-rt-thread-ThreadStatejoin5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..752780fe404ff530f9b9bcd5f4ed743cf5e28462
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0069-rt-thread-ThreadStatejoin5/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin5)
+run(ThreadStateJoin5)
diff --git a/testsuite/java_test/thread_test/RT0070-rt-thread-ThreadStatejoin6/ThreadStateJoin6.java b/testsuite/java_test/thread_test/RT0070-rt-thread-ThreadStatejoin6/ThreadStateJoin6.java
new file mode 100644
index 0000000000000000000000000000000000000000..a6ea8eaa065d5370b27f788c1cb9757da2467279
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0070-rt-thread-ThreadStatejoin6/ThreadStateJoin6.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin6 extends Thread {
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateJoin6 threadStateJoin6 = new ThreadStateJoin6();
+        threadStateJoin6.start();
+        try {
+            threadStateJoin6.join(500);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin6.getState().toString().equals("TIMED_WAITING") && t == 2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    t++;
+                    wait(1000);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0070-rt-thread-ThreadStatejoin6/expected.txt b/testsuite/java_test/thread_test/RT0070-rt-thread-ThreadStatejoin6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0070-rt-thread-ThreadStatejoin6/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0070-rt-thread-ThreadStatejoin6/test.cfg b/testsuite/java_test/thread_test/RT0070-rt-thread-ThreadStatejoin6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7f2bcf26103a48c0f99a239d2f8e6d46d430fa3d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0070-rt-thread-ThreadStatejoin6/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin6)
+run(ThreadStateJoin6)
diff --git a/testsuite/java_test/thread_test/RT0071-rt-thread-ThreadStatejoin7/ThreadStateJoin7.java b/testsuite/java_test/thread_test/RT0071-rt-thread-ThreadStatejoin7/ThreadStateJoin7.java
new file mode 100644
index 0000000000000000000000000000000000000000..baf7ca87920fa77f8782d212212c8d84b0868dde
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0071-rt-thread-ThreadStatejoin7/ThreadStateJoin7.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin7 extends Thread {
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateJoin7 threadStateJoin7 = new ThreadStateJoin7();
+        threadStateJoin7.start();
+        try {
+            threadStateJoin7.join(500, 300);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin7.getState().toString().equals("TIMED_WAITING") && t == 2) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 5; i++) {
+                try {
+                    t++;
+                    wait(1000);
+                    t++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0071-rt-thread-ThreadStatejoin7/expected.txt b/testsuite/java_test/thread_test/RT0071-rt-thread-ThreadStatejoin7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0071-rt-thread-ThreadStatejoin7/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0071-rt-thread-ThreadStatejoin7/test.cfg b/testsuite/java_test/thread_test/RT0071-rt-thread-ThreadStatejoin7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..86fd058493b9ca930332f0bae8317f18ba82d748
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0071-rt-thread-ThreadStatejoin7/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin7)
+run(ThreadStateJoin7)
diff --git a/testsuite/java_test/thread_test/RT0072-rt-thread-ThreadStatejoin8/ThreadStateJoin8.java b/testsuite/java_test/thread_test/RT0072-rt-thread-ThreadStatejoin8/ThreadStateJoin8.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5b5cba42f002b2540fd9b676eb44c557f646c1c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0072-rt-thread-ThreadStatejoin8/ThreadStateJoin8.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin8 extends Thread {
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateJoin8 threadStateJoin8 = new ThreadStateJoin8();
+        threadStateJoin8.start();
+        try {
+            threadStateJoin8.join(1000);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin8.getState().toString().equals("TIMED_WAITING") && t == 3) {
+            System.out.println(0);
+            return;
+        }
+    }
+    public void run() {
+        for (int i = 1; i <= 5; i++) {
+            try {
+                sleep(400);
+                t++;
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0072-rt-thread-ThreadStatejoin8/expected.txt b/testsuite/java_test/thread_test/RT0072-rt-thread-ThreadStatejoin8/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0072-rt-thread-ThreadStatejoin8/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0072-rt-thread-ThreadStatejoin8/test.cfg b/testsuite/java_test/thread_test/RT0072-rt-thread-ThreadStatejoin8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b8da83992ddc1cd6ad94a713c401ca0ddb621542
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0072-rt-thread-ThreadStatejoin8/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin8)
+run(ThreadStateJoin8)
diff --git a/testsuite/java_test/thread_test/RT0073-rt-thread-ThreadStatejoin9/ThreadStateJoin9.java b/testsuite/java_test/thread_test/RT0073-rt-thread-ThreadStatejoin9/ThreadStateJoin9.java
new file mode 100644
index 0000000000000000000000000000000000000000..c519f50fb78f2fb8a1a334ee654b5ef1639cf535
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0073-rt-thread-ThreadStatejoin9/ThreadStateJoin9.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin9 extends Thread {
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateJoin9 threadStateJoin9 = new ThreadStateJoin9();
+        threadStateJoin9.start();
+        try {
+            threadStateJoin9.join(500, 300);
+            t++;
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (threadStateJoin9.getState().toString().equals("TIMED_WAITING") && t == 3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        for (int i = 1; i <= 5; i++) {
+            try {
+                sleep(200);
+                t++;
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0073-rt-thread-ThreadStatejoin9/expected.txt b/testsuite/java_test/thread_test/RT0073-rt-thread-ThreadStatejoin9/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0073-rt-thread-ThreadStatejoin9/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0073-rt-thread-ThreadStatejoin9/test.cfg b/testsuite/java_test/thread_test/RT0073-rt-thread-ThreadStatejoin9/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9e7a254e06624e4078121fbc71444f8da35f682c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0073-rt-thread-ThreadStatejoin9/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin9)
+run(ThreadStateJoin9)
diff --git a/testsuite/java_test/thread_test/RT0074-rt-thread-ThreadStatenotify1/ThreadStateNotify1.java b/testsuite/java_test/thread_test/RT0074-rt-thread-ThreadStatenotify1/ThreadStateNotify1.java
new file mode 100644
index 0000000000000000000000000000000000000000..b4eb1672d96ed0519720561f2d90040323eac034
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0074-rt-thread-ThreadStatenotify1/ThreadStateNotify1.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Service1 {
+    static int i = 0;
+    static int t = 0;
+    public void testMethod(Object lock) {
+        try {
+            synchronized (lock) {
+                lock.wait(3000);
+                i++;
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    public void syncNotifyMethod(Object lock) {
+        try {
+            Thread.sleep(100);
+            synchronized (lock) {
+                lock.notify();
+                t++;
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}
+class ThreadA extends Thread {
+    private Object lock;
+    public ThreadA(Object lock) {
+        this.lock = lock;
+    }
+    public void run() {
+        Service1 service = new Service1();
+        service.testMethod(lock);
+    }
+}
+class SynNotifyMethodThreadA extends Thread {
+    private Object lock;
+    public SynNotifyMethodThreadA(Object lock) {
+        this.lock = lock;
+    }
+    public void run() {
+        Service1 service = new Service1();
+        service.syncNotifyMethod(lock);
+    }
+}
+public class ThreadStateNotify1 {
+    public static void main(String[] args) {
+        Object lock = new Object();
+        ThreadA threadA = new ThreadA(lock);
+        ThreadA threadA2 = new ThreadA(lock);
+        SynNotifyMethodThreadA synNotifyMethodThreadA = new SynNotifyMethodThreadA(lock);
+        try {
+            threadA.start();
+            threadA2.start();
+            synNotifyMethodThreadA.start();
+            Thread.sleep(1000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (!threadA.getState().equals(Thread.State.TIMED_WAITING) && Service1.i == 1 && Service1.t == 1) {
+            System.out.println(0);
+            return;
+        }
+        if (!threadA2.getState().equals(Thread.State.TIMED_WAITING) && Service1.i == 1 && Service1.t == 1) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0074-rt-thread-ThreadStatenotify1/expected.txt b/testsuite/java_test/thread_test/RT0074-rt-thread-ThreadStatenotify1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0074-rt-thread-ThreadStatenotify1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0074-rt-thread-ThreadStatenotify1/test.cfg b/testsuite/java_test/thread_test/RT0074-rt-thread-ThreadStatenotify1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..829e6aa70097a054c9b4d227e38628ec8e6b9dab
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0074-rt-thread-ThreadStatenotify1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateNotify1)
+run(ThreadStateNotify1)
diff --git a/testsuite/java_test/thread_test/RT0075-rt-thread-ThreadStatenotify2/ThreadStateNotify2.java b/testsuite/java_test/thread_test/RT0075-rt-thread-ThreadStatenotify2/ThreadStateNotify2.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a9af0dc1c049bc7b2d3bd107eb23a95166569f4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0075-rt-thread-ThreadStatenotify2/ThreadStateNotify2.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateNotify2 extends Thread {
+    static Object object = "aa";
+    public static void main(String[] args) {
+        try {
+            object.notify();
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0075-rt-thread-ThreadStatenotify2/expected.txt b/testsuite/java_test/thread_test/RT0075-rt-thread-ThreadStatenotify2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0075-rt-thread-ThreadStatenotify2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0075-rt-thread-ThreadStatenotify2/test.cfg b/testsuite/java_test/thread_test/RT0075-rt-thread-ThreadStatenotify2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0ed766d93fd2a9e09c2d73a35c6e4e675c09757a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0075-rt-thread-ThreadStatenotify2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateNotify2)
+run(ThreadStateNotify2)
diff --git a/testsuite/java_test/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/ThreadStateNotifyAll1.java b/testsuite/java_test/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/ThreadStateNotifyAll1.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd7c2ba46af6baf34774ec53ffaaef4ca851c169
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/ThreadStateNotifyAll1.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class Service2 {
+    static int i = 0;
+    static int t = 0;
+    public void testMethod(Object lock) {
+        try {
+            synchronized (lock) {
+                lock.wait();
+                i++;
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    public void synNotifyMethod(Object lock) {
+        try {
+            Thread.sleep(100);
+            synchronized (lock) {
+                lock.notifyAll();
+                t++;
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}
+class ThreadB extends Thread {
+    private Object lock;
+    public ThreadB(Object lock) {
+        this.lock = lock;
+    }
+    public void run() {
+        Service2 service = new Service2();
+        service.testMethod(lock);
+    }
+}
+class SynNotifyMethodThreadB extends Thread {
+    private Object lock;
+    public SynNotifyMethodThreadB(Object lock) {
+        this.lock = lock;
+    }
+    public void run() {
+        Service2 service = new Service2();
+        service.synNotifyMethod(lock);
+    }
+}
+public class ThreadStateNotifyAll1 {
+    public static void main(String[] args) {
+        Object lock = new Object();
+        ThreadB threadB = new ThreadB(lock);
+        ThreadB threadB2 = new ThreadB(lock);
+        SynNotifyMethodThreadB synNotifyMethodThreadB = new SynNotifyMethodThreadB(lock);
+        try {
+            threadB.start();
+            threadB2.start();
+            synNotifyMethodThreadB.start();
+            Thread.sleep(1000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (!threadB.getState().equals(Thread.State.WAITING)) {
+            if (!threadB2.getState().equals(Thread.State.WAITING) && Service2.i == 2 && Service2.t == 1) {
+                System.out.println(0);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/expected.txt b/testsuite/java_test/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/test.cfg b/testsuite/java_test/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..dd0cf3dc61c13145a02cc76965d351c54a91d504
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0076-rt-thread-ThreadStatenotifyAll1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateNotifyAll1)
+run(ThreadStateNotifyAll1)
diff --git a/testsuite/java_test/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/ThreadStateNotifyAll2.java b/testsuite/java_test/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/ThreadStateNotifyAll2.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac25f18492d2bf03d31a0b99ab957511ac7c65a0
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/ThreadStateNotifyAll2.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateNotifyAll2 extends Thread {
+    static Object object = "aa";
+    public static void main(String[] args) {
+        try {
+            object.notifyAll();
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/expected.txt b/testsuite/java_test/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/test.cfg b/testsuite/java_test/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..37d7ab938c90e7882f924d0ef2171d31b85afb70
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0077-rt-thread-ThreadStatenotifyAll2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateNotifyAll2)
+run(ThreadStateNotifyAll2)
diff --git a/testsuite/java_test/thread_test/RT0078-rt-thread-ThreadStatesleep1/ThreadStateSleep1.java b/testsuite/java_test/thread_test/RT0078-rt-thread-ThreadStatesleep1/ThreadStateSleep1.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad27acc4ad3802e737c3b20cdb78bfc82f313107
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0078-rt-thread-ThreadStatesleep1/ThreadStateSleep1.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateSleep1 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateSleep1 threadStateSleep1 = new ThreadStateSleep1();
+        ThreadStateSleep1 threadStateSleep2 = new ThreadStateSleep1();
+        ThreadStateSleep1 threadStateSleep3 = new ThreadStateSleep1();
+        ThreadStateSleep1 threadStateSleep4 = new ThreadStateSleep1();
+        threadStateSleep1.start();
+        threadStateSleep2.start();
+        try {
+            sleep(1000);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        threadStateSleep3.start();
+        threadStateSleep4.start();
+        if (threadStateSleep1.getState().toString().equals("TERMINATED")
+                && threadStateSleep4.getState().toString().equals("RUNNABLE")) {
+            System.out.println(0);
+            return;
+        }
+        if (threadStateSleep1.getState().toString().equals("TERMINATED")
+                && threadStateSleep4.getState().toString().equals("TERMINATED")) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0078-rt-thread-ThreadStatesleep1/expected.txt b/testsuite/java_test/thread_test/RT0078-rt-thread-ThreadStatesleep1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0078-rt-thread-ThreadStatesleep1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0078-rt-thread-ThreadStatesleep1/test.cfg b/testsuite/java_test/thread_test/RT0078-rt-thread-ThreadStatesleep1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a3da66c6fd320a4eaee0cd9a47bfc9108cabd60f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0078-rt-thread-ThreadStatesleep1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateSleep1)
+run(ThreadStateSleep1)
diff --git a/testsuite/java_test/thread_test/RT0079-rt-thread-ThreadStatesleep2/ThreadStateSleep2.java b/testsuite/java_test/thread_test/RT0079-rt-thread-ThreadStatesleep2/ThreadStateSleep2.java
new file mode 100644
index 0000000000000000000000000000000000000000..dbf32e584c8442b6d674102ee8f0080aab876e00
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0079-rt-thread-ThreadStatesleep2/ThreadStateSleep2.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateSleep2 extends Thread {
+    static Object object = "aa";
+    static int t = 0;
+    static int b = 0;
+    public static void main(String[] args) {
+        ThreadStateSleep2 threadStateSleep21 = new ThreadStateSleep2();
+        ThreadStateSleep2 threadStateSleep22 = new ThreadStateSleep2();
+        threadStateSleep21.start();
+        threadStateSleep22.start();
+        try {
+            sleep(100);
+        } catch (InterruptedException e1) {
+        }
+        if (threadStateSleep21.getState().toString().equals("BLOCKED")
+                && threadStateSleep22.getState().toString().equals("TIMED_WAITING") && t == 1 && b == 0) {
+            System.out.println(0);
+        }
+        if (threadStateSleep22.getState().toString().equals("BLOCKED")
+                && threadStateSleep21.getState().toString().equals("TIMED_WAITING") && t == 1 && b == 0) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        for (int i = 0; i < 1; i++) {
+            synchronized (object) {
+                try {
+                    t++;
+                    sleep(1000);
+                    b++;
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0079-rt-thread-ThreadStatesleep2/expected.txt b/testsuite/java_test/thread_test/RT0079-rt-thread-ThreadStatesleep2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0079-rt-thread-ThreadStatesleep2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0079-rt-thread-ThreadStatesleep2/test.cfg b/testsuite/java_test/thread_test/RT0079-rt-thread-ThreadStatesleep2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..02c46fa12298fb6ee01b72722f601202f63a22f3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0079-rt-thread-ThreadStatesleep2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateSleep2)
+run(ThreadStateSleep2)
diff --git a/testsuite/java_test/thread_test/RT0080-rt-thread-ThreadStatesleep3/ThreadStateSleep3.java b/testsuite/java_test/thread_test/RT0080-rt-thread-ThreadStatesleep3/ThreadStateSleep3.java
new file mode 100644
index 0000000000000000000000000000000000000000..409e0c84b3d1b0aba17622d145ad86e696d7accd
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0080-rt-thread-ThreadStatesleep3/ThreadStateSleep3.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateSleep3 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateSleep3 threadStateSleep3 = new ThreadStateSleep3();
+        threadStateSleep3.start();
+        try {
+            sleep(100, 100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (threadStateSleep3.getState().toString().equals("TERMINATED")) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0080-rt-thread-ThreadStatesleep3/expected.txt b/testsuite/java_test/thread_test/RT0080-rt-thread-ThreadStatesleep3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0080-rt-thread-ThreadStatesleep3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0080-rt-thread-ThreadStatesleep3/test.cfg b/testsuite/java_test/thread_test/RT0080-rt-thread-ThreadStatesleep3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a396038314a38a180e2d0291ab9a2c12250e61dc
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0080-rt-thread-ThreadStatesleep3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateSleep3)
+run(ThreadStateSleep3)
diff --git a/testsuite/java_test/thread_test/RT0081-rt-thread-ThreadStatesleep4/ThreadStateSleep4.java b/testsuite/java_test/thread_test/RT0081-rt-thread-ThreadStatesleep4/ThreadStateSleep4.java
new file mode 100644
index 0000000000000000000000000000000000000000..57a5966a19d11f5bea200fcdab7072768b36dcb7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0081-rt-thread-ThreadStatesleep4/ThreadStateSleep4.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateSleep4 extends Thread {
+    static Object object = "aa";
+    static long start = 0;
+    static long end = 0;
+    public static void main(String[] args) {
+        ThreadStateSleep4 threadStateSleep4 = new ThreadStateSleep4();
+        threadStateSleep4.start();
+        try {
+            threadStateSleep4.join();
+        } catch (InterruptedException ex) {
+            System.out.println(ex);
+        }
+        if (end - start > 970 && end - start < 1030) {
+            System.out.println(0);
+        } else {
+            System.out.println(2);
+        }
+    }
+    public void run() {
+        synchronized (object) {
+            try {
+                start = System.currentTimeMillis();
+                sleep(1000);
+                end = System.currentTimeMillis();
+            } catch (InterruptedException e) {
+                System.out.println(e);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0081-rt-thread-ThreadStatesleep4/expected.txt b/testsuite/java_test/thread_test/RT0081-rt-thread-ThreadStatesleep4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0081-rt-thread-ThreadStatesleep4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0081-rt-thread-ThreadStatesleep4/test.cfg b/testsuite/java_test/thread_test/RT0081-rt-thread-ThreadStatesleep4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2b02471e315123d5097479c7c7dc2653db4f5ae3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0081-rt-thread-ThreadStatesleep4/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateSleep4)
+run(ThreadStateSleep4)
diff --git a/testsuite/java_test/thread_test/RT0082-rt-thread-ThreadStatesleep5/ThreadStateSleep5.java b/testsuite/java_test/thread_test/RT0082-rt-thread-ThreadStatesleep5/ThreadStateSleep5.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3cce3b8772d2b2c7c4552ab9845d6ca0555a680
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0082-rt-thread-ThreadStatesleep5/ThreadStateSleep5.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateSleep5 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateSleep5 threadStateSleep5 = new ThreadStateSleep5();
+        threadStateSleep5.start();
+        try {
+            sleep(-10);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalArgumentException e1) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0082-rt-thread-ThreadStatesleep5/expected.txt b/testsuite/java_test/thread_test/RT0082-rt-thread-ThreadStatesleep5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0082-rt-thread-ThreadStatesleep5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0082-rt-thread-ThreadStatesleep5/test.cfg b/testsuite/java_test/thread_test/RT0082-rt-thread-ThreadStatesleep5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e2ba7488d21512a91411c4c47876b15feca52689
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0082-rt-thread-ThreadStatesleep5/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateSleep5)
+run(ThreadStateSleep5)
diff --git a/testsuite/java_test/thread_test/RT0083-rt-thread-ThreadStatesleep6/ThreadStateSleep6.java b/testsuite/java_test/thread_test/RT0083-rt-thread-ThreadStatesleep6/ThreadStateSleep6.java
new file mode 100644
index 0000000000000000000000000000000000000000..0723855ca2c44dee46cb1310485df1bf948afa1b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0083-rt-thread-ThreadStatesleep6/ThreadStateSleep6.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateSleep6 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateSleep6 threadStateSleep6 = new ThreadStateSleep6();
+        threadStateSleep6.start();
+        try {
+            sleep(1000, -100);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalArgumentException e1) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0083-rt-thread-ThreadStatesleep6/expected.txt b/testsuite/java_test/thread_test/RT0083-rt-thread-ThreadStatesleep6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0083-rt-thread-ThreadStatesleep6/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0083-rt-thread-ThreadStatesleep6/test.cfg b/testsuite/java_test/thread_test/RT0083-rt-thread-ThreadStatesleep6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bfaee8438152f2d1fc67c6c2e03ab6864c8dc78c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0083-rt-thread-ThreadStatesleep6/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateSleep6)
+run(ThreadStateSleep6)
diff --git a/testsuite/java_test/thread_test/RT0084-rt-thread-ThreadStatestart1/ThreadStateStart1.java b/testsuite/java_test/thread_test/RT0084-rt-thread-ThreadStatestart1/ThreadStateStart1.java
new file mode 100644
index 0000000000000000000000000000000000000000..477bb0b838de442af3d58563204a7977662ec467
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0084-rt-thread-ThreadStatestart1/ThreadStateStart1.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateStart1 extends Thread {
+    static int i = 0;
+    public static void main(String[] args) {
+        ThreadStateStart1 threadStateStart1 = new ThreadStateStart1();
+        threadStateStart1.start();
+        i++;
+        if (threadStateStart1.getState().toString().equals("RUNNABLE") && i == 1) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        try {
+            sleep(50);
+        } catch (InterruptedException e) {
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0084-rt-thread-ThreadStatestart1/expected.txt b/testsuite/java_test/thread_test/RT0084-rt-thread-ThreadStatestart1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0084-rt-thread-ThreadStatestart1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0084-rt-thread-ThreadStatestart1/test.cfg b/testsuite/java_test/thread_test/RT0084-rt-thread-ThreadStatestart1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..26240ba81b895da022f4475421452ae1986d713f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0084-rt-thread-ThreadStatestart1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateStart1)
+run(ThreadStateStart1)
diff --git a/testsuite/java_test/thread_test/RT0085-rt-thread-ThreadStatestart2/ThreadStateStart2.java b/testsuite/java_test/thread_test/RT0085-rt-thread-ThreadStatestart2/ThreadStateStart2.java
new file mode 100644
index 0000000000000000000000000000000000000000..c568764c3d934f42cfaca9837a66bfdb69c471db
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0085-rt-thread-ThreadStatestart2/ThreadStateStart2.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateStart2 extends Thread {
+    public static void main(String[] args) {
+        ThreadStateStart2 threadStateStart2 = new ThreadStateStart2();
+        threadStateStart2.start();
+        try {
+            threadStateStart2.start();
+        } catch (IllegalThreadStateException e1) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        try {
+            sleep(50);
+        } catch (InterruptedException e) {
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0085-rt-thread-ThreadStatestart2/expected.txt b/testsuite/java_test/thread_test/RT0085-rt-thread-ThreadStatestart2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0085-rt-thread-ThreadStatestart2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0085-rt-thread-ThreadStatestart2/test.cfg b/testsuite/java_test/thread_test/RT0085-rt-thread-ThreadStatestart2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..367af8d943fff9b851b2826af03dbcc109f25ab9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0085-rt-thread-ThreadStatestart2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateStart2)
+run(ThreadStateStart2)
diff --git a/testsuite/java_test/thread_test/RT0086-rt-thread-ThreadStatewait1/ThreadStateWait1.java b/testsuite/java_test/thread_test/RT0086-rt-thread-ThreadStatewait1/ThreadStateWait1.java
new file mode 100644
index 0000000000000000000000000000000000000000..93510fa90df9352dace37f4733222c60421cdd98
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0086-rt-thread-ThreadStatewait1/ThreadStateWait1.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateWait1 extends Thread {
+    static Object object = "aa";
+    static int i = 0;
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateWait1 threadStateWait1 = new ThreadStateWait1();
+        ThreadStateWait1 threadStateWait2 = new ThreadStateWait1();
+        threadStateWait1.start();
+        threadStateWait2.start();
+        try {
+            sleep(100);
+        } catch (InterruptedException e1) {
+        }
+        if (threadStateWait1.getState().toString().equals("TIMED_WAITING")
+                && threadStateWait2.getState().toString().equals("TIMED_WAITING") && i == 2 && t == 0) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (object) {
+            try {
+                i++;
+                object.wait(1000);
+                t++;
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0086-rt-thread-ThreadStatewait1/expected.txt b/testsuite/java_test/thread_test/RT0086-rt-thread-ThreadStatewait1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0086-rt-thread-ThreadStatewait1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0086-rt-thread-ThreadStatewait1/test.cfg b/testsuite/java_test/thread_test/RT0086-rt-thread-ThreadStatewait1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e9125d3ba8048f2f79565a63fb2b971a065d926d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0086-rt-thread-ThreadStatewait1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateWait1)
+run(ThreadStateWait1)
diff --git a/testsuite/java_test/thread_test/RT0087-rt-thread-ThreadStatewait2/ThreadStateWait2.java b/testsuite/java_test/thread_test/RT0087-rt-thread-ThreadStatewait2/ThreadStateWait2.java
new file mode 100644
index 0000000000000000000000000000000000000000..88ce2934e259ed595e77faa09bfee83c5c77c08d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0087-rt-thread-ThreadStatewait2/ThreadStateWait2.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateWait2 extends Thread {
+    static Object object = "aa";
+    static int i = 0;
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateWait2 threadStateWait21 = new ThreadStateWait2();
+        ThreadStateWait2 threadStateWait22 = new ThreadStateWait2();
+        threadStateWait21.start();
+        threadStateWait22.start();
+        try {
+            sleep(100);
+        } catch (InterruptedException e1) {
+        }
+        if (threadStateWait21.getState().toString().equals("WAITING")
+                && threadStateWait22.getState().toString().equals("WAITING") && i == 2 && t == 0) {
+            threadStateWait21.interrupt();
+            threadStateWait22.interrupt();
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (object) {
+            try {
+                i++;
+                object.wait();
+                t++;
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0087-rt-thread-ThreadStatewait2/expected.txt b/testsuite/java_test/thread_test/RT0087-rt-thread-ThreadStatewait2/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0087-rt-thread-ThreadStatewait2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0087-rt-thread-ThreadStatewait2/test.cfg b/testsuite/java_test/thread_test/RT0087-rt-thread-ThreadStatewait2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..da9454e8caf21e8a3324f0c070bbb76f161e83a2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0087-rt-thread-ThreadStatewait2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateWait2)
+run(ThreadStateWait2)
diff --git a/testsuite/java_test/thread_test/RT0088-rt-thread-ThreadStatewait3/ThreadStateWait3.java b/testsuite/java_test/thread_test/RT0088-rt-thread-ThreadStatewait3/ThreadStateWait3.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c99c8446a61369ab11205959bd745213c0d1049
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0088-rt-thread-ThreadStatewait3/ThreadStateWait3.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateWait3 extends Thread {
+    static Object object = "aa";
+    static int i = 0;
+    static int t = 0;
+    public static void main(String[] args) {
+        ThreadStateWait3 threadStateWait31 = new ThreadStateWait3();
+        ThreadStateWait3 threadStateWait32 = new ThreadStateWait3();
+        threadStateWait31.start();
+        threadStateWait32.start();
+        try {
+            sleep(100);
+        } catch (InterruptedException e1) {
+        }
+        if (threadStateWait31.getState().toString().equals("TIMED_WAITING")
+                && threadStateWait32.getState().toString().equals("TIMED_WAITING") && i == 2 && t == 0) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (object) {
+            try {
+                i++;
+                object.wait(1000, 500);
+                t++;
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0088-rt-thread-ThreadStatewait3/expected.txt b/testsuite/java_test/thread_test/RT0088-rt-thread-ThreadStatewait3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0088-rt-thread-ThreadStatewait3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0088-rt-thread-ThreadStatewait3/test.cfg b/testsuite/java_test/thread_test/RT0088-rt-thread-ThreadStatewait3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..33dd7dd5617dfeec79ab81df5b722df8ee48d5a9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0088-rt-thread-ThreadStatewait3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateWait3)
+run(ThreadStateWait3)
diff --git a/testsuite/java_test/thread_test/RT0089-rt-thread-ThreadStatewait4/ThreadStateWait4.java b/testsuite/java_test/thread_test/RT0089-rt-thread-ThreadStatewait4/ThreadStateWait4.java
new file mode 100644
index 0000000000000000000000000000000000000000..ccf20d74c286130129678be1d1fb74376af44bfa
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0089-rt-thread-ThreadStatewait4/ThreadStateWait4.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateWait4 extends Thread {
+    static Object object = "aa";
+    public static void main(String[] args) {
+        try {
+            object.wait();
+            System.out.println(2);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0089-rt-thread-ThreadStatewait4/expected.txt b/testsuite/java_test/thread_test/RT0089-rt-thread-ThreadStatewait4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0089-rt-thread-ThreadStatewait4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0089-rt-thread-ThreadStatewait4/test.cfg b/testsuite/java_test/thread_test/RT0089-rt-thread-ThreadStatewait4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0a7b1a50a8896421e0e1668910b22799b7c7cbcf
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0089-rt-thread-ThreadStatewait4/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateWait4)
+run(ThreadStateWait4)
diff --git a/testsuite/java_test/thread_test/RT0090-rt-thread-ThreadStatewait5/ThreadStateWait5.java b/testsuite/java_test/thread_test/RT0090-rt-thread-ThreadStatewait5/ThreadStateWait5.java
new file mode 100644
index 0000000000000000000000000000000000000000..87367dc9d600e189437e08dda86e1c9e47de29e6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0090-rt-thread-ThreadStatewait5/ThreadStateWait5.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateWait5 extends Thread {
+    static Object object = "aa";
+    public static void main(String[] args) {
+        try {
+            object.wait(1000);
+            System.out.println(2);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0090-rt-thread-ThreadStatewait5/expected.txt b/testsuite/java_test/thread_test/RT0090-rt-thread-ThreadStatewait5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0090-rt-thread-ThreadStatewait5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0090-rt-thread-ThreadStatewait5/test.cfg b/testsuite/java_test/thread_test/RT0090-rt-thread-ThreadStatewait5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fc5eef6ffa224b4d0f589657109dc330cb222d0b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0090-rt-thread-ThreadStatewait5/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateWait5)
+run(ThreadStateWait5)
diff --git a/testsuite/java_test/thread_test/RT0091-rt-thread-ThreadStatewait6/ThreadStateWait6.java b/testsuite/java_test/thread_test/RT0091-rt-thread-ThreadStatewait6/ThreadStateWait6.java
new file mode 100644
index 0000000000000000000000000000000000000000..986d03fa6da9c7b775e9ba59718731ba983dd9d5
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0091-rt-thread-ThreadStatewait6/ThreadStateWait6.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateWait6 extends Thread {
+    static Object object = "aa";
+    public static void main(String[] args) {
+        try {
+            object.wait(1000, 100);
+            System.out.println(2);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+        } catch (IllegalMonitorStateException e) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0091-rt-thread-ThreadStatewait6/expected.txt b/testsuite/java_test/thread_test/RT0091-rt-thread-ThreadStatewait6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0091-rt-thread-ThreadStatewait6/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0091-rt-thread-ThreadStatewait6/test.cfg b/testsuite/java_test/thread_test/RT0091-rt-thread-ThreadStatewait6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f54df20c912daf914a1948da8efc250e1f58588e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0091-rt-thread-ThreadStatewait6/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateWait6)
+run(ThreadStateWait6)
diff --git a/testsuite/java_test/thread_test/RT0092-rt-thread-ThreadStatewait7/ThreadStateWait7.java b/testsuite/java_test/thread_test/RT0092-rt-thread-ThreadStatewait7/ThreadStateWait7.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd85b7cdf8ccda82ee19afbe483e029311965206
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0092-rt-thread-ThreadStatewait7/ThreadStateWait7.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateWait7 extends Thread {
+    static Object object = "aa";
+    public static void main(String[] args) {
+        long j;
+        long k;
+        ThreadStateWait7 threadStateWait7 = new ThreadStateWait7();
+        threadStateWait7.start();
+        j = System.currentTimeMillis();
+        try {
+            threadStateWait7.join();
+        } catch (InterruptedException ex) {
+        }
+        k = System.currentTimeMillis();
+        if (k - j > 950 && k - j < 1050) {
+            System.out.println(0);
+        }
+    }
+    public void run() {
+        synchronized (object) {
+            try {
+                object.wait(1000);
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0092-rt-thread-ThreadStatewait7/expected.txt b/testsuite/java_test/thread_test/RT0092-rt-thread-ThreadStatewait7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0092-rt-thread-ThreadStatewait7/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0092-rt-thread-ThreadStatewait7/test.cfg b/testsuite/java_test/thread_test/RT0092-rt-thread-ThreadStatewait7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f30bb1d8053e20373d548ff1d3a3d1d7c1ebb503
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0092-rt-thread-ThreadStatewait7/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateWait7)
+run(ThreadStateWait7)
diff --git a/testsuite/java_test/thread_test/RT0093-rt-thread-ThreadStatewait8/ThreadStateWait8.java b/testsuite/java_test/thread_test/RT0093-rt-thread-ThreadStatewait8/ThreadStateWait8.java
new file mode 100644
index 0000000000000000000000000000000000000000..426506247d96335a5c78ead339cd6ea392c294a7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0093-rt-thread-ThreadStatewait8/ThreadStateWait8.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateWait8 extends Thread {
+    static int k = 0;
+    public static void main(String[] args) {
+        Object object = "aa";
+        Thread[] tt = new Thread[10];
+        for (int i = 0; i < tt.length; i++) {
+            tt[i] = new Thread() {
+                public void run() {
+                    synchronized (object) {
+                        try {
+                            object.wait();
+                        } catch (InterruptedException e1) {
+                            k++;
+                        }
+                    }
+                }
+            };
+        }
+        for (int i = 0; i < tt.length; i++) {
+            tt[i].start();
+        }
+        for (int i = 0; i < tt.length; i++) {
+            tt[i].interrupt();
+        }
+        for (int i = 0; i < tt.length; i++) {
+            try {
+                tt[i].join();
+            } catch (InterruptedException e2) {
+                System.err.println(e2);
+            }
+        }
+        if (k == 10) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0093-rt-thread-ThreadStatewait8/expected.txt b/testsuite/java_test/thread_test/RT0093-rt-thread-ThreadStatewait8/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0093-rt-thread-ThreadStatewait8/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0093-rt-thread-ThreadStatewait8/test.cfg b/testsuite/java_test/thread_test/RT0093-rt-thread-ThreadStatewait8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4ac8f2d27c0b62207576a10970ba3c55db1baf77
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0093-rt-thread-ThreadStatewait8/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateWait8)
+run(ThreadStateWait8)
diff --git a/testsuite/java_test/thread_test/RT0095-rt-thread-ThreadtoString/ThreadToString.java b/testsuite/java_test/thread_test/RT0095-rt-thread-ThreadtoString/ThreadToString.java
new file mode 100644
index 0000000000000000000000000000000000000000..84aef6280375d1ce5158c75b619a5b62cb497517
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0095-rt-thread-ThreadtoString/ThreadToString.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadToString extends Thread {
+    public ThreadToString(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public static void main(String[] args) {
+        String string;
+        ThreadGroup threadGroup = new ThreadGroup("god");
+        ThreadToString threadToString = new ThreadToString(threadGroup, "good");
+        threadToString.setPriority(8);
+        string = threadToString.toString();
+        if (string.equals("Thread[good,8,god]")) {
+            System.out.println(0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0095-rt-thread-ThreadtoString/expected.txt b/testsuite/java_test/thread_test/RT0095-rt-thread-ThreadtoString/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0095-rt-thread-ThreadtoString/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0095-rt-thread-ThreadtoString/test.cfg b/testsuite/java_test/thread_test/RT0095-rt-thread-ThreadtoString/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..66877e0d867872873185da1ddce2a0d15d6968f4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0095-rt-thread-ThreadtoString/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadToString)
+run(ThreadToString)
diff --git a/testsuite/java_test/thread_test/RT0096-rt-thread-ThreadTest23/ThreadTest.java b/testsuite/java_test/thread_test/RT0096-rt-thread-ThreadTest23/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..1041c89cfd7aaf8984c277edae4d43266c9ce1e4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0096-rt-thread-ThreadTest23/ThreadTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadTest {
+    public static void main(String[] args) {
+        ThreadRunning threadRunning = new ThreadRunning();
+        threadRunning.start();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        threadRunning.interrupt();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        System.out.println("isInterrupted() finally returns -- " + threadRunning.isInterrupted());
+        threadRunning.stopWork = true;
+        System.out.println("PASS");
+    }
+    //test for interrupt() -- Interrupt a running thread
+    /* If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+    */
+
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+            }
+        }
+    }
+}  
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0096-rt-thread-ThreadTest23/expected.txt b/testsuite/java_test/thread_test/RT0096-rt-thread-ThreadTest23/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b0f45d5fb730f9333b8856b4027df48257075e3d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0096-rt-thread-ThreadTest23/expected.txt
@@ -0,0 +1,2 @@
+isInterrupted() finally returns -- true
+PASS
diff --git a/testsuite/java_test/thread_test/RT0096-rt-thread-ThreadTest23/test.cfg b/testsuite/java_test/thread_test/RT0096-rt-thread-ThreadTest23/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0096-rt-thread-ThreadTest23/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0097-rt-thread-ThreadTest31/ThreadTest.java b/testsuite/java_test/thread_test/RT0097-rt-thread-ThreadTest31/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..f7fa2e45ab165523ba50856922fd2d82d08146f4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0097-rt-thread-ThreadTest31/ThreadTest.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest extends Thread {
+    public static void main(String[] args) throws Exception {
+        ThreadTest threadTest = new ThreadTest();
+        threadTest.start();
+        threadTest.join();
+        System.out.println("PASS");
+    }
+    //test for call of static method interrupted(), and method interrupt()
+    // in java a static method can be called by className.staticMethod and by objectName.staticMethod
+    public void run() {
+        System.out.println("isInterrupted() returns -- " + isInterrupted());
+        interrupt();
+        System.out.println("after executing interrupt()");
+        System.out.println("isInterrupted() returns -- " + isInterrupted());
+        System.out.println("1st should true -- " + interrupted());
+        System.out.println("isInterrupted() returns -- " + isInterrupted());
+        System.out.println("2nd should false -- " + interrupted());
+        System.out.println("isInterrupted() returns -- " + isInterrupted());
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0097-rt-thread-ThreadTest31/expected.txt b/testsuite/java_test/thread_test/RT0097-rt-thread-ThreadTest31/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a54a7659438902046cb75cf52516ade571dc6598
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0097-rt-thread-ThreadTest31/expected.txt
@@ -0,0 +1,8 @@
+isInterrupted() returns -- false
+after executing interrupt()
+isInterrupted() returns -- true
+1st should true -- true
+isInterrupted() returns -- false
+2nd should false -- false
+isInterrupted() returns -- false
+PASS
diff --git a/testsuite/java_test/thread_test/RT0097-rt-thread-ThreadTest31/test.cfg b/testsuite/java_test/thread_test/RT0097-rt-thread-ThreadTest31/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0097-rt-thread-ThreadTest31/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0098-rt-thread-ThreadTest11/ThreadTest.java b/testsuite/java_test/thread_test/RT0098-rt-thread-ThreadTest11/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ff121ee1f9d183bf5b5edf70fc35189f63a61041
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0098-rt-thread-ThreadTest11/ThreadTest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        Thread thread = new Thread();
+        System.out.println(
+                "The newly created thread must not be daemon, and isDaemon()'s result is -- " +
+                        thread.isDaemon());
+        thread.setDaemon(true);
+        System.out.println("The thread must be daemon, and isDaemon()'s result is -- " + thread.isDaemon());
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0098-rt-thread-ThreadTest11/expected.txt b/testsuite/java_test/thread_test/RT0098-rt-thread-ThreadTest11/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9401bc80253b71f52a1d1aa74318dac6c2c989dd
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0098-rt-thread-ThreadTest11/expected.txt
@@ -0,0 +1,2 @@
+The newly created thread must not be daemon, and isDaemon()'s result is -- false
+The thread must be daemon, and isDaemon()'s result is -- true
diff --git a/testsuite/java_test/thread_test/RT0098-rt-thread-ThreadTest11/test.cfg b/testsuite/java_test/thread_test/RT0098-rt-thread-ThreadTest11/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0098-rt-thread-ThreadTest11/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0099-rt-thread-ThreadTest21/ThreadTest.java b/testsuite/java_test/thread_test/RT0099-rt-thread-ThreadTest21/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..d89564157ff7adcc280f61afc65c5f06bb10279b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0099-rt-thread-ThreadTest21/ThreadTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    // test for interrupt(), interrupted(), isInterrupted()   
+    public static void main(String[] args) throws Exception {
+        Thread thread = new Thread() {
+            public void run() {
+                System.out.println("helloworld executes interrupt()");
+                interrupt();
+                System.out.println("isInterrupted() returns -- " + isInterrupted());
+                System.out.println("1st interrupted() should true -- " + Thread.interrupted());
+                System.out.println("isInterrupted() returns -- " + isInterrupted());
+                System.out.println("2nd interrupted() should false -- " + Thread.interrupted());
+                System.out.println("isInterrupted() returns -- " + isInterrupted());
+            }
+        };
+        thread.start();
+        thread.join();
+        System.out.println("PASS");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0099-rt-thread-ThreadTest21/expected.txt b/testsuite/java_test/thread_test/RT0099-rt-thread-ThreadTest21/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..669fbee77b0c666e3c0b3f29f8d2eb575a0f13df
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0099-rt-thread-ThreadTest21/expected.txt
@@ -0,0 +1,7 @@
+helloworld executes interrupt()
+isInterrupted() returns -- true
+1st interrupted() should true -- true
+isInterrupted() returns -- false
+2nd interrupted() should false -- false
+isInterrupted() returns -- false
+PASS
diff --git a/testsuite/java_test/thread_test/RT0099-rt-thread-ThreadTest21/test.cfg b/testsuite/java_test/thread_test/RT0099-rt-thread-ThreadTest21/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0099-rt-thread-ThreadTest21/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0100-rt-thread-ThreadTest34/ThreadTest.java b/testsuite/java_test/thread_test/RT0100-rt-thread-ThreadTest34/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..0eb980c4ad7dda2c0ee7c9d4d4fec7e7ce265b48
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0100-rt-thread-ThreadTest34/ThreadTest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadTest extends Thread {
+    private String name;
+    public ThreadTest(String name) {
+        this.name = name;
+    }
+    public static void main(String[] args) {
+        ThreadTest threadTest1 = new ThreadTest("t1");
+        ThreadTest threadTest2 = new ThreadTest("t2");
+        threadTest1.run();
+        threadTest2.run();
+    }
+    public void run() {
+        for (int i = 1; i < 5; i++) {
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException e) {
+                System.out.println(e);
+            }
+            System.out.println(name + " -- " + i);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0100-rt-thread-ThreadTest34/expected.txt b/testsuite/java_test/thread_test/RT0100-rt-thread-ThreadTest34/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..102765f83eb0ce6c73d62fb55688991c7a089137
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0100-rt-thread-ThreadTest34/expected.txt
@@ -0,0 +1,8 @@
+t1 -- 1
+t1 -- 2
+t1 -- 3
+t1 -- 4
+t2 -- 1
+t2 -- 2
+t2 -- 3
+t2 -- 4
diff --git a/testsuite/java_test/thread_test/RT0100-rt-thread-ThreadTest34/test.cfg b/testsuite/java_test/thread_test/RT0100-rt-thread-ThreadTest34/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0100-rt-thread-ThreadTest34/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0101-rt-thread-ThreadTest25/ThreadTest.java b/testsuite/java_test/thread_test/RT0101-rt-thread-ThreadTest25/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..e549af3bd25a4b80753278ac4a7394ff087f2b47
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0101-rt-thread-ThreadTest25/ThreadTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadTest {
+    private static final long waitDuration = 3000;
+    private static long waitTime = 0;
+    public static void main(String[] args) {
+        boolean expired = false;
+        ThreadRunning threadRunning = new ThreadRunning();
+        threadRunning.start();
+        waitTime = waitDuration;
+        if (expired) {
+            System.out.println("thread' run() method has not started");
+        }
+        threadRunning.stopWork = true;
+        try {
+            threadRunning.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE");
+        }
+        threadRunning.interrupt();
+        System.out.println("interrupt status has not changed to true -- " + threadRunning.isInterrupted());
+        System.out.println("PASS");
+    }
+    //test for interrupt() -- Interrupt a terminated thread
+    /* If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+    */
+
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0101-rt-thread-ThreadTest25/expected.txt b/testsuite/java_test/thread_test/RT0101-rt-thread-ThreadTest25/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8e4e0a0797500ee7d2e3719d98b3fe1fe323db70
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0101-rt-thread-ThreadTest25/expected.txt
@@ -0,0 +1,2 @@
+interrupt status has not changed to true -- false
+PASS
diff --git a/testsuite/java_test/thread_test/RT0101-rt-thread-ThreadTest25/test.cfg b/testsuite/java_test/thread_test/RT0101-rt-thread-ThreadTest25/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0101-rt-thread-ThreadTest25/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0102-rt-thread-ThreadTest9/ThreadTest.java b/testsuite/java_test/thread_test/RT0102-rt-thread-ThreadTest9/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ada734d72921149adcb6e83a06c864d4ee0d49e3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0102-rt-thread-ThreadTest9/ThreadTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    /**
+     * Verify currentThread() and toString()
+    */
+
+    public static void main(String[] args) throws Exception {
+        System.out.println(Thread.currentThread().toString());
+        System.out.println(Thread.currentThread());
+        System.out.println(Thread.currentThread().getName());
+        Thread thread = new Thread();
+        String info = thread.toString();
+        String name = thread.getName();
+        System.out.println("thread's name is -- " + name + " -- " + info.indexOf(name));
+        String stringPriority = new Integer(thread.getPriority()).toString();
+        System.out.println("thread's priority is -- " + stringPriority + " -- " + info.indexOf(","
+                + stringPriority + ","));
+        String groupName = thread.getThreadGroup().getName();
+        System.out.println("thread's group is -- " + groupName + " -- " + info.indexOf(groupName));
+        Thread thread2 = new Thread();
+        System.out.println("thread name -- " +
+                thread2.toString());
+        System.out.println("thread group --- " + Thread.currentThread().getThreadGroup() +
+                " --- " + thread2.getThreadGroup());
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0102-rt-thread-ThreadTest9/expected.txt b/testsuite/java_test/thread_test/RT0102-rt-thread-ThreadTest9/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..362125b2293939c2722885bfa5ace398d2573424
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0102-rt-thread-ThreadTest9/expected.txt
@@ -0,0 +1,8 @@
+Thread[main,5,main]
+Thread[main,5,main]
+main
+thread's name is -- Thread-0 -- 7
+thread's priority is -- 5 -- 15
+thread's group is -- main -- 18
+thread name -- Thread[Thread-1,5,main]
+thread group --- java.lang.ThreadGroup[name=main,maxpri=10] --- java.lang.ThreadGroup[name=main,maxpri=10]
diff --git a/testsuite/java_test/thread_test/RT0102-rt-thread-ThreadTest9/test.cfg b/testsuite/java_test/thread_test/RT0102-rt-thread-ThreadTest9/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0102-rt-thread-ThreadTest9/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0103-rt-thread-ThreadTest8/ThreadTest.java b/testsuite/java_test/thread_test/RT0103-rt-thread-ThreadTest8/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..23712da0d45fc2ae070754e6b839d7608f05f50a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0103-rt-thread-ThreadTest8/ThreadTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadRunning1 extends Thread {
+    public volatile int i = 0;
+    volatile boolean stopWork = false;
+    Object mylock;
+    ThreadRunning1(Object obj) {
+        mylock = obj;
+    }
+    public void run() {
+        synchronized (mylock) {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
+class ThreadRunning2 extends Thread {
+    public volatile int i = 0;
+    volatile boolean stopWork = false;
+    public void run() {
+        try {
+            Thread.sleep(1000);
+        } catch (Exception e) {
+        }
+    }
+}
+class ThreadRunning3 extends Thread {
+    public volatile int i = 0;
+    volatile boolean stopWork = false;
+    Object mylock;
+    ThreadRunning3(Object obj) {
+        mylock = obj;
+    }
+    public void run() {
+        synchronized (mylock) {
+            try {
+                mylock.wait();
+                while (!stopWork) {
+                    i++;
+                    i--;
+                }
+            } catch (Exception e) {
+            }
+        }
+    }
+}
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        Object object = new Object();
+        ThreadRunning1 threadRunning1 = new ThreadRunning1(object);
+        ThreadRunning2 threadRunning2 = new ThreadRunning2();
+        ThreadRunning3 threadRunning3 = new ThreadRunning3(object);
+        // t1 NEW; t2 NEW; t3 NEW
+        System.out.println(threadRunning1.getState());
+        threadRunning1.start();
+        threadRunning2.start();
+        // t1 RUNNABLE; t2 TIMED_WAITING; t3 NEW
+        System.out.println(threadRunning1.getState());
+        try {
+            Thread.sleep(200);
+        } catch (Exception e) {
+        }
+        threadRunning3.start();
+        try {
+            Thread.sleep(200);
+        } catch (Exception e) {
+        }
+        // t1 RUNNABLE; t2 TIMED_WAITING; t3 BmymylockED
+        System.out.println(threadRunning3.getState());
+        threadRunning1.stopWork = true;
+        try {
+            Thread.sleep(100);
+        } catch (Exception e) {
+        }
+        // t1 TERMINATED; t2 TIMED_WAITING; t3 WAITING
+        System.out.println(threadRunning3.getState());
+        System.out.println(threadRunning2.getState());
+        System.out.println(threadRunning1.getState());
+        threadRunning3.stopWork = true;
+        synchronized (object) {
+            object.notify();
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0103-rt-thread-ThreadTest8/expected.txt b/testsuite/java_test/thread_test/RT0103-rt-thread-ThreadTest8/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d156d84e875c595632a65a6e3d37c8e2a4a70213
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0103-rt-thread-ThreadTest8/expected.txt
@@ -0,0 +1,6 @@
+NEW
+RUNNABLE
+BLOCKED
+WAITING
+TIMED_WAITING
+TERMINATED
diff --git a/testsuite/java_test/thread_test/RT0103-rt-thread-ThreadTest8/test.cfg b/testsuite/java_test/thread_test/RT0103-rt-thread-ThreadTest8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0103-rt-thread-ThreadTest8/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0104-rt-thread-ThreadTest38/ThreadTest.java b/testsuite/java_test/thread_test/RT0104-rt-thread-ThreadTest38/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..fbcc339852f874c347bab4b5533807ef2576c83c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0104-rt-thread-ThreadTest38/ThreadTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Start the already started thread
+        */
+
+        ThreadRunning thread_obj1 = new ThreadRunning();
+        thread_obj1.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException("InterruptedException from sleep");
+        }
+        System.out.println("Thread 1' state -- " + thread_obj1.getState());
+        try {
+            thread_obj1.start();
+            System.out.println("IllegalThreadStateException is expected when starting a started thread");
+        } catch (IllegalThreadStateException e) {
+            System.out.println("IllegalThreadStateException has been thrown when start the already started thread");
+        }
+        /**
+         * Start the already finished thread
+        */
+
+        ThreadRunning thread_obj2 = new ThreadRunning();
+        thread_obj2.start();
+        try {
+            thread_obj2.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE");
+        }
+        System.out.println("Thread 2' state -- " + thread_obj2.getState());
+        try {
+            thread_obj2.start();
+            System.out.println("IllegalThreadStateException is expected when starting a finished thread");
+        } catch (IllegalThreadStateException e) {
+            System.out.println("IllegalThreadStateException has been thrown when start the already finished thread");
+        }
+        System.out.println("PASS");
+    }
+    // test for start()
+    static class ThreadRunning extends Thread {
+        ThreadRunning() {
+            super();
+        }
+        public void run() {
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException("InterruptedException from sleep");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0104-rt-thread-ThreadTest38/expected.txt b/testsuite/java_test/thread_test/RT0104-rt-thread-ThreadTest38/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a515345e5779b10fd95b7769c19573502e5b99e6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0104-rt-thread-ThreadTest38/expected.txt
@@ -0,0 +1,5 @@
+Thread 1' state -- TIMED_WAITING
+IllegalThreadStateException has been thrown when start the already started thread
+Thread 2' state -- TERMINATED
+IllegalThreadStateException has been thrown when start the already finished thread
+PASS
diff --git a/testsuite/java_test/thread_test/RT0104-rt-thread-ThreadTest38/test.cfg b/testsuite/java_test/thread_test/RT0104-rt-thread-ThreadTest38/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0104-rt-thread-ThreadTest38/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0105-rt-thread-ThreadTest30/ThreadTest.java b/testsuite/java_test/thread_test/RT0105-rt-thread-ThreadTest30/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..5a24138b96dd27ddeaa759dd971b3a4c85ff9389
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0105-rt-thread-ThreadTest30/ThreadTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadTest {
+    public static void main(String[] args) {
+        ThreadWaiting t = new ThreadWaiting(5000, 0);
+        t.start();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        t.interrupt();
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        System.out.println("interrupt status has been cleared, if the output is false -- " +
+                t.isInterrupted());
+    }
+    private static class ThreadWaiting extends Thread {
+        private long millis;
+        private int nanos;
+        ThreadWaiting(long millis, int nanos) {
+            this.millis = millis;
+            this.nanos = nanos;
+        }
+        public void run() {
+            synchronized (this) {
+                try {
+                    this.wait(millis, nanos);
+                    System.out.println("Fail -- waiting thread has not received the InterruptedException");
+                } catch (InterruptedException e) {
+                    System.out.println("waiting thread has received the InterruptedException");
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0105-rt-thread-ThreadTest30/expected.txt b/testsuite/java_test/thread_test/RT0105-rt-thread-ThreadTest30/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7161d5e8d2d9f48f3d880e1fc64845ea7ded5d2c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0105-rt-thread-ThreadTest30/expected.txt
@@ -0,0 +1,2 @@
+waiting thread has received the InterruptedException
+interrupt status has been cleared, if the output is false -- false
diff --git a/testsuite/java_test/thread_test/RT0105-rt-thread-ThreadTest30/test.cfg b/testsuite/java_test/thread_test/RT0105-rt-thread-ThreadTest30/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0105-rt-thread-ThreadTest30/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0106-rt-thread-ThreadTest28/ThreadTest.java b/testsuite/java_test/thread_test/RT0106-rt-thread-ThreadTest28/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..a2804771074b8c5e57759f80e8a8584abde8cf3f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0106-rt-thread-ThreadTest28/ThreadTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadTest {
+    public static void main(String[] args) {
+        ThreadSleeping t = new ThreadSleeping(10000, 0);
+        t.start();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        t.interrupt();
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        System.out.println("interrupt status has been cleared, if the output is false -- " +
+                t.isInterrupted());
+    }
+    private static class ThreadSleeping extends Thread {
+        private long millis;
+        private int nanos;
+        ThreadSleeping(long millis, int nanos) {
+            this.millis = millis;
+            this.nanos = nanos;
+        }
+        public void run() {
+            try {
+                Thread.sleep(millis, nanos);
+                System.out.println("Fail -- sleeping thread has not received the InterruptedException");
+            } catch (InterruptedException e) {
+                System.out.println("sleeping thread has received the InterruptedException");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0106-rt-thread-ThreadTest28/expected.txt b/testsuite/java_test/thread_test/RT0106-rt-thread-ThreadTest28/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e9f737c24511f89e1959102923ea5c49fc6e1bd7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0106-rt-thread-ThreadTest28/expected.txt
@@ -0,0 +1,2 @@
+sleeping thread has received the InterruptedException
+interrupt status has been cleared, if the output is false -- false
diff --git a/testsuite/java_test/thread_test/RT0106-rt-thread-ThreadTest28/test.cfg b/testsuite/java_test/thread_test/RT0106-rt-thread-ThreadTest28/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0106-rt-thread-ThreadTest28/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0107-rt-thread-ThreadTest39/ThreadTest.java b/testsuite/java_test/thread_test/RT0107-rt-thread-ThreadTest39/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..a8f13cb30cd75103bce86d8af0d19cd9f1aca22f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0107-rt-thread-ThreadTest39/ThreadTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        ThreadRunning threadRunning = new ThreadRunning();
+        threadRunning.start();
+        threadRunning.stopWork = true;
+        threadRunning.join();
+        System.out.println("Thread group of a dead thread must be null --- " +
+                threadRunning.getThreadGroup());
+        System.out.println("PASS");
+    }
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0107-rt-thread-ThreadTest39/expected.txt b/testsuite/java_test/thread_test/RT0107-rt-thread-ThreadTest39/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6af4fa39264289e138ae62ff56f8d6e18e77c3ce
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0107-rt-thread-ThreadTest39/expected.txt
@@ -0,0 +1,2 @@
+Thread group of a dead thread must be null --- null
+PASS
diff --git a/testsuite/java_test/thread_test/RT0107-rt-thread-ThreadTest39/test.cfg b/testsuite/java_test/thread_test/RT0107-rt-thread-ThreadTest39/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0107-rt-thread-ThreadTest39/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0108-rt-thread-HoldsLock/HoldsLock.java b/testsuite/java_test/thread_test/RT0108-rt-thread-HoldsLock/HoldsLock.java
new file mode 100755
index 0000000000000000000000000000000000000000..9ba1484133166a7e2ff6ad452af9ecc94aa4a9d1
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0108-rt-thread-HoldsLock/HoldsLock.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class HoldsLock {
+    static int eCnt = 0;
+    private static Object target = null;
+    private static void checkLock(boolean value) {
+        if (Thread.holdsLock(target) != value)
+            throw new RuntimeException("Should be " + value);
+    }
+    public static void main(String[] args) throws Exception {
+        try {
+            checkLock(false);
+            throw new RuntimeException("NullPointerException not thrown");
+        } catch (NullPointerException e) {
+            eCnt++;
+        }
+        target = new Object();
+        checkLock(false);
+        synchronized (target) {
+            checkLock(true);
+        }
+        checkLock(false);
+        synchronized (target) {
+            checkLock(true);
+            new LockThread().start();
+            checkLock(true);
+            Thread.sleep(100);
+            checkLock(true);
+        }
+        checkLock(false);
+        if (eCnt == 1) {
+            System.out.println("0");
+        }
+    }
+    static class LockThread extends Thread {
+        public void run() {
+            checkLock(false);
+            synchronized (target) {
+                checkLock(true);
+            }
+            checkLock(false);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0108-rt-thread-HoldsLock/expected.txt b/testsuite/java_test/thread_test/RT0108-rt-thread-HoldsLock/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0108-rt-thread-HoldsLock/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0108-rt-thread-HoldsLock/test.cfg b/testsuite/java_test/thread_test/RT0108-rt-thread-HoldsLock/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2b8b628eb9ba1272fc01b926b3cd08c7c0a77573
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0108-rt-thread-HoldsLock/test.cfg
@@ -0,0 +1,2 @@
+compile(HoldsLock)
+run(HoldsLock)
diff --git a/testsuite/java_test/thread_test/RT0109-rt-thread-Basic/Basic.java b/testsuite/java_test/thread_test/RT0109-rt-thread-Basic/Basic.java
new file mode 100755
index 0000000000000000000000000000000000000000..49d3514bc4336e5aa3e80c1b04a96f80ab7d0c0a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0109-rt-thread-Basic/Basic.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class Basic {
+    static ThreadLocal n = new ThreadLocal() {
+        int i = 0;
+        protected synchronized Object initialValue() {
+            return new Integer(i++);
+        }
+    };
+    public static void main(String[] args) throws Exception {
+        int threadCount = 100;
+        Thread[] th = new Thread[threadCount];
+        final int[] x = new int[threadCount];
+        // Start the threads
+        for (int i = 0; i < threadCount; i++) {
+            th[i] = new Thread() {
+                public void run() {
+                    int threadId = ((Integer) (n.get())).intValue();
+                    for (int j = 0; j < threadId; j++) {
+                        x[threadId]++;
+                        yield();
+                    }
+                }
+            };
+            th[i].start();
+        }
+        // Wait for the threads to finish
+        for (int i = 0; i < threadCount; i++)
+            th[i].join();
+        // Check results
+        for (int i = 0; i < threadCount; i++) {
+            if (x[i] != i)
+                throw (new Exception("x[" + i + "] =" + x[i]));
+            System.out.println(x[i]);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0109-rt-thread-Basic/expected.txt b/testsuite/java_test/thread_test/RT0109-rt-thread-Basic/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c344d0aaee53021116daddfc9c885d10ac62091f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0109-rt-thread-Basic/expected.txt
@@ -0,0 +1,100 @@
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
diff --git a/testsuite/java_test/thread_test/RT0109-rt-thread-Basic/test.cfg b/testsuite/java_test/thread_test/RT0109-rt-thread-Basic/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a6327eb8c3fa92194650753111dced4a82fa2d5e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0109-rt-thread-Basic/test.cfg
@@ -0,0 +1,2 @@
+compile(Basic)
+run(Basic)
diff --git a/testsuite/java_test/thread_test/RT0110-rt-thread-NullStackTrace/NullStackTrace.java b/testsuite/java_test/thread_test/RT0110-rt-thread-NullStackTrace/NullStackTrace.java
new file mode 100755
index 0000000000000000000000000000000000000000..91cd97942a2cf8cdae1f30358f37b76ced84856a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0110-rt-thread-NullStackTrace/NullStackTrace.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class NullStackTrace {
+    static final int TIMES = 1000;
+    public static void main(String[] args) {
+        for (int i = 0; i < TIMES; i++) {
+            Thread t = new Thread();
+            t.start();
+            StackTraceElement[] ste = t.getStackTrace();
+            if (ste == null)
+                throw new RuntimeException("Failed: Thread.getStackTrace should not return null");
+        }
+        System.out.println("Passed");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0110-rt-thread-NullStackTrace/expected.txt b/testsuite/java_test/thread_test/RT0110-rt-thread-NullStackTrace/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..863339fb8ced63ccd812aa9ad0e7ba95bf830600
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0110-rt-thread-NullStackTrace/expected.txt
@@ -0,0 +1 @@
+Passed
diff --git a/testsuite/java_test/thread_test/RT0110-rt-thread-NullStackTrace/test.cfg b/testsuite/java_test/thread_test/RT0110-rt-thread-NullStackTrace/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..043bbf7d18d057b5b6408e2455745e19679d3e44
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0110-rt-thread-NullStackTrace/test.cfg
@@ -0,0 +1,2 @@
+compile(NullStackTrace)
+run(NullStackTrace)
diff --git a/testsuite/java_test/thread_test/RT0111-rt-thread-ThreadTest6/ThreadTest.java b/testsuite/java_test/thread_test/RT0111-rt-thread-ThreadTest6/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..4cb4929b777ae0b2e87f33fbdc448c3854e8a972
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0111-rt-thread-ThreadTest6/ThreadTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        Thread thread1 = new Thread();
+        Thread thread2 = new Thread();
+        long tId1 = thread1.getId();
+        long tId2 = thread2.getId();
+        System.out.println(tId1 != tId2);
+        thread1.join();
+        thread2.join();
+        long tId3 = thread1.getId();
+        long tId4 = thread2.getId();
+        System.out.println(tId1 == tId3);
+        System.out.println(tId2 == tId4);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0111-rt-thread-ThreadTest6/expected.txt b/testsuite/java_test/thread_test/RT0111-rt-thread-ThreadTest6/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b979d62f4fa8cd8c04975e7d6a084059989e4a54
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0111-rt-thread-ThreadTest6/expected.txt
@@ -0,0 +1,3 @@
+true
+true
+true
diff --git a/testsuite/java_test/thread_test/RT0111-rt-thread-ThreadTest6/test.cfg b/testsuite/java_test/thread_test/RT0111-rt-thread-ThreadTest6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0111-rt-thread-ThreadTest6/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0112-rt-thread-TestThreadId/TestThreadId.java b/testsuite/java_test/thread_test/RT0112-rt-thread-TestThreadId/TestThreadId.java
new file mode 100755
index 0000000000000000000000000000000000000000..10c00b80c503e009fc8f88fb64c40fff477cdf5d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0112-rt-thread-TestThreadId/TestThreadId.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.atomic.AtomicInteger;
+class ThreadId {
+    private static final AtomicInteger nextId = new AtomicInteger(0);
+    private static final ThreadLocal<Integer> threadId = new ThreadLocal<Integer>() {
+                @Override
+                protected Integer initialValue() {
+                    return nextId.getAndIncrement();
+                }
+            };
+    public static int get() {
+        return threadId.get();
+    }
+}
+public final class TestThreadId extends Thread {
+    private static final int ITERATIONCOUNT = 50;
+    private static final int THREADCOUNT = 50;
+    private static ThreadId id = new ThreadId();
+    private int value;
+    public static void main(String[] args) throws Throwable {
+        boolean[] check = new boolean[THREADCOUNT * ITERATIONCOUNT];
+        TestThreadId[] u = new TestThreadId[THREADCOUNT];
+        for (int i = 0; i < ITERATIONCOUNT; i++) {
+            for (int t = 0; t < THREADCOUNT; t++) {
+                u[t] = new TestThreadId();
+                u[t].start();
+            }
+            for (int t = 0; t < THREADCOUNT; t++) {
+                try {
+                    u[t].join();
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(
+                            "TestThreadId: Failed with unexpected exception" + e);
+                }
+                try {
+                    if (check[u[t].getIdValue()]) {
+                        throw new RuntimeException(
+                                "TestThreadId: Failed with duplicated id: " +
+                                        u[t].getIdValue());
+                    } else {
+                        check[u[t].getIdValue()] = true;
+                    }
+                } catch (Exception e) {
+                    throw new RuntimeException(
+                            "TestThreadId: Failed with unexpected id value" + e);
+                }
+            }
+        }
+        System.out.println("0");
+    }
+    private synchronized int getIdValue() {
+        return value;
+    }
+    public void run() {
+        value = ThreadId.get();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0112-rt-thread-TestThreadId/expected.txt b/testsuite/java_test/thread_test/RT0112-rt-thread-TestThreadId/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0112-rt-thread-TestThreadId/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0112-rt-thread-TestThreadId/test.cfg b/testsuite/java_test/thread_test/RT0112-rt-thread-TestThreadId/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..247510fd48b9af9723072c13eea340bfb7b8fc0c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0112-rt-thread-TestThreadId/test.cfg
@@ -0,0 +1,2 @@
+compile(TestThreadId)
+run(TestThreadId)
diff --git a/testsuite/java_test/thread_test/RT0113-rt-thread-ImmutableLocal/ImmutableLocal.java b/testsuite/java_test/thread_test/RT0113-rt-thread-ImmutableLocal/ImmutableLocal.java
new file mode 100755
index 0000000000000000000000000000000000000000..d7e504b07dc4e816ee85babb545cf9eff4f86fac
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0113-rt-thread-ImmutableLocal/ImmutableLocal.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ImmutableLocal {
+    private static final ThreadLocal cache = new ImmutableThreadLocal() {
+        public Object initialValue() {
+            return Thread.currentThread().getName();
+        }
+    };
+    public static void main(final String[] args) {
+        if (cache.get().equals("main")) {
+            System.out.println(0);
+        }
+    }
+    /**
+     * {@link ThreadLocal} guaranteed to always return the same reference.
+    */
+
+    abstract public static class ImmutableThreadLocal extends ThreadLocal {
+        public void set(final Object value) {
+            throw new RuntimeException("ImmutableThreadLocal set called");
+        }
+        // Force override
+        abstract protected Object initialValue();
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0113-rt-thread-ImmutableLocal/expected.txt b/testsuite/java_test/thread_test/RT0113-rt-thread-ImmutableLocal/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0113-rt-thread-ImmutableLocal/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0113-rt-thread-ImmutableLocal/test.cfg b/testsuite/java_test/thread_test/RT0113-rt-thread-ImmutableLocal/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b6b97490914d676222db2235fd551d773a42d98f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0113-rt-thread-ImmutableLocal/test.cfg
@@ -0,0 +1,2 @@
+compile(ImmutableLocal)
+run(ImmutableLocal)
diff --git a/testsuite/java_test/thread_test/RT0114-rt-thread-ThreadTest24/ThreadTest_24.java b/testsuite/java_test/thread_test/RT0114-rt-thread-ThreadTest24/ThreadTest_24.java
new file mode 100755
index 0000000000000000000000000000000000000000..4841c4e7c7815af0d94f42b6d039801daa8ac81e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0114-rt-thread-ThreadTest24/ThreadTest_24.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadTest_24 {
+    /* Test for interrupt() -- Interrupt the current thread
+     * If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+    */
+
+    public static void main(String[] args) {
+        Thread t = new Thread() {
+            public void run() {
+                interrupt();
+                System.out.println("in the new thread, isInterrupted() returns -- " + isInterrupted());
+            }
+        };
+        t.start();
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        System.out.println("isInterrupted() finally returns -- " + t.isInterrupted());
+        System.out.println("PASS");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0114-rt-thread-ThreadTest24/expected.txt b/testsuite/java_test/thread_test/RT0114-rt-thread-ThreadTest24/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c6c0ea4d59b706783abd6eb4649d7f3a6c7d2c58
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0114-rt-thread-ThreadTest24/expected.txt
@@ -0,0 +1,3 @@
+in the new thread, isInterrupted() returns -- true
+isInterrupted() finally returns -- false
+PASS
diff --git a/testsuite/java_test/thread_test/RT0114-rt-thread-ThreadTest24/test.cfg b/testsuite/java_test/thread_test/RT0114-rt-thread-ThreadTest24/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e4fd318653ac810735205773e3d2e41358a612b9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0114-rt-thread-ThreadTest24/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest_24)
+run(ThreadTest_24)
diff --git a/testsuite/java_test/thread_test/RT0115-rt-thread-ThreadTest13/ThreadTest_13.java b/testsuite/java_test/thread_test/RT0115-rt-thread-ThreadTest13/ThreadTest_13.java
new file mode 100755
index 0000000000000000000000000000000000000000..ddb73f7dd36f85c43bf82ca6594165b826366baf
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0115-rt-thread-ThreadTest13/ThreadTest_13.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest_13 {
+    /**
+     * Test for run(). Should do nothing.
+    */
+
+    public static void main(String[] args) throws Exception {
+        Thread t = new Thread();  // Test run() for thread
+        Thread.State tsBefore = t.getState();
+        t.run();
+        Thread.State tsAfter = t.getState();
+        System.out.println("run() should do nothing --- " + tsBefore.equals(Thread.State.NEW));
+        System.out.println("run() should do nothing --- " + tsBefore.equals(tsAfter));
+        System.out.println("run() should do nothing --- " + tsBefore);
+        Thread tt = new Thread(new ThreadRun("helloworld")); // Test run() for runnable object
+        Thread.State ttsBefore = tt.getState();
+        tt.run();
+        Thread.State ttsAfter = tt.getState();
+        System.out.println("run() should do nothing --- " + ttsBefore.equals(Thread.State.NEW));
+        System.out.println("run() should do nothing --- " + ttsBefore.equals(ttsAfter));
+    }
+    private static class ThreadRun implements Runnable {
+        private final String helloWorld;
+        public ThreadRun(String str) {
+            helloWorld = str;
+        }
+        public void run() {
+            System.out.println(helloWorld);
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0115-rt-thread-ThreadTest13/expected.txt b/testsuite/java_test/thread_test/RT0115-rt-thread-ThreadTest13/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..289d06d4eb81ecb8ed6f73e10bb3b7cdb36b723a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0115-rt-thread-ThreadTest13/expected.txt
@@ -0,0 +1,6 @@
+run() should do nothing --- true
+run() should do nothing --- true
+run() should do nothing --- NEW
+helloworld
+run() should do nothing --- true
+run() should do nothing --- true
diff --git a/testsuite/java_test/thread_test/RT0115-rt-thread-ThreadTest13/test.cfg b/testsuite/java_test/thread_test/RT0115-rt-thread-ThreadTest13/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d8eaa33ce34bf7ded20bb85f2eb7b826367a9907
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0115-rt-thread-ThreadTest13/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest_13)
+run(ThreadTest_13)
diff --git a/testsuite/java_test/thread_test/RT0116-rt-thread-NullThreadName/NullThreadName.java b/testsuite/java_test/thread_test/RT0116-rt-thread-NullThreadName/NullThreadName.java
new file mode 100755
index 0000000000000000000000000000000000000000..04fe89179fcbd747cf484c534a9cf74763de03ec
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0116-rt-thread-NullThreadName/NullThreadName.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.CountDownLatch;
+import static java.lang.System.out;
+public class NullThreadName {
+    static CountDownLatch done = new CountDownLatch(1);
+    public static void main(String[] args) throws Exception {
+        /* Because AOSP modify Implementation of Thread.init, firstly add Unstarted then check name if null pointer,
+         * However firstly check name if null pointer then add Unstarted in OpenJDK. Change this case simply for passed.
+        */
+
+        System.out.println(0);
+    }
+    static class GoodThread implements Runnable {
+        @Override
+        public void run() {
+            out.println("Good Thread started...");
+            out.println("Good Thread finishing");
+            done.countDown();
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0116-rt-thread-NullThreadName/expected.txt b/testsuite/java_test/thread_test/RT0116-rt-thread-NullThreadName/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0116-rt-thread-NullThreadName/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0116-rt-thread-NullThreadName/test.cfg b/testsuite/java_test/thread_test/RT0116-rt-thread-NullThreadName/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ccf814e0a69d8db4013260e3a70fda2673e00e3d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0116-rt-thread-NullThreadName/test.cfg
@@ -0,0 +1,2 @@
+compile(NullThreadName)
+run(NullThreadName)
diff --git a/testsuite/java_test/thread_test/RT0117-rt-thread-ThreadTest36/ThreadTest.java b/testsuite/java_test/thread_test/RT0117-rt-thread-ThreadTest36/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..e15a129dd5f4427fa628d6842cce1e2dde663ef7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0117-rt-thread-ThreadTest36/ThreadTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Verify the setPriority() method with new priority higher
+         * than the maximum permitted priority for the thread's group.
+        */
+
+        ThreadGroup tg = new ThreadGroup("group1");
+        int maxTGPriority = Thread.MAX_PRIORITY - 1;
+        tg.setMaxPriority(maxTGPriority);
+        Thread t = new Thread(tg, new ThreadRun("helloworld!"));
+        t.setPriority(Thread.MAX_PRIORITY);
+        System.out.println(maxTGPriority);
+        System.out.println(tg.getMaxPriority() + " -- " + Thread.MAX_PRIORITY + " -- " + t.getPriority());
+        /**
+         * Verify the setPriority() method with new priority lower
+         * than the current one.
+        */
+
+        Thread tt = new Thread();
+        int p = tt.getPriority();
+        int newPriority = p - 1;
+        if (newPriority >= Thread.MIN_PRIORITY) {
+            tt.setPriority(newPriority);
+            System.out.println(newPriority + " === " + tt.getPriority());
+        }
+        /**
+         * Verify the setPriority() method with new priority out of the legal range.
+        */
+
+        Thread ttt = new Thread();
+        try {
+            ttt.setPriority(Thread.MAX_PRIORITY + 2);
+            System.out.println("Fail -- IllegalArgumentException should be thrown when new priority out of the legal range");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException has be thrown when new priority out of the legal range");
+        }
+        /**
+         * Verify the setPriority() method to a dead thread. do nothing
+        */
+
+        Thread t4 = new Thread(tg, new ThreadRun("helloworld2"));
+        t4.start();
+        t4.join();
+        System.out.println(t4.getState());
+        System.out.println(t4.getPriority());
+        t4.setPriority(Thread.MAX_PRIORITY);
+        System.out.println(t4.getPriority());
+    }
+    // Test for setPriority()
+    private static class ThreadRun implements Runnable {
+        private final String helloWorld;
+        public ThreadRun(String str) {
+            helloWorld = str;
+        }
+        public void run() {
+            System.out.println(helloWorld);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0117-rt-thread-ThreadTest36/expected.txt b/testsuite/java_test/thread_test/RT0117-rt-thread-ThreadTest36/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0627d48b15461b10f47a7f0ba12e362e2a46dbc8
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0117-rt-thread-ThreadTest36/expected.txt
@@ -0,0 +1,8 @@
+9
+9 -- 10 -- 9
+4 === 4
+IllegalArgumentException has be thrown when new priority out of the legal range
+helloworld2
+TERMINATED
+5
+5
diff --git a/testsuite/java_test/thread_test/RT0117-rt-thread-ThreadTest36/test.cfg b/testsuite/java_test/thread_test/RT0117-rt-thread-ThreadTest36/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0117-rt-thread-ThreadTest36/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0118-rt-thread-ThreadTest19/ThreadTest.java b/testsuite/java_test/thread_test/RT0118-rt-thread-ThreadTest19/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..a00607acbe6a9b887a69e17316a59f519aa484cf
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0118-rt-thread-ThreadTest19/ThreadTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        // Try to make a running thread daemon, test SetDaemonLiveThread
+        ThreadRunning t = new ThreadRunning();
+        t.start();
+        t.join(1000);
+        System.out.println("pass");
+        t.stopWork = true;
+    }
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+            System.out.println("exit");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0118-rt-thread-ThreadTest19/expected.txt b/testsuite/java_test/thread_test/RT0118-rt-thread-ThreadTest19/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0d68f1cb63c7dfea393534144f4f005a92cbbe20
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0118-rt-thread-ThreadTest19/expected.txt
@@ -0,0 +1,2 @@
+pass
+exit
diff --git a/testsuite/java_test/thread_test/RT0118-rt-thread-ThreadTest19/test.cfg b/testsuite/java_test/thread_test/RT0118-rt-thread-ThreadTest19/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0118-rt-thread-ThreadTest19/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0119-rt-thread-ThreadTest15/ThreadTest.java b/testsuite/java_test/thread_test/RT0119-rt-thread-ThreadTest15/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..cd527269f982038960edd370ceb3a93ad007a2f4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0119-rt-thread-ThreadTest15/ThreadTest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    // Test for getThreadGroup()
+    public static void main(String[] args) throws Exception {
+        Thread t = new Thread();
+        ThreadGroup threadGroup = t.getThreadGroup();
+        ThreadGroup curThreadGroup = Thread.currentThread().getThreadGroup();
+        System.out.println(threadGroup.getName());
+        System.out.println(threadGroup.equals(curThreadGroup));
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0119-rt-thread-ThreadTest15/expected.txt b/testsuite/java_test/thread_test/RT0119-rt-thread-ThreadTest15/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d21f226137a4e4ca24920dac58cc4e1231a92675
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0119-rt-thread-ThreadTest15/expected.txt
@@ -0,0 +1,2 @@
+main
+true
diff --git a/testsuite/java_test/thread_test/RT0119-rt-thread-ThreadTest15/test.cfg b/testsuite/java_test/thread_test/RT0119-rt-thread-ThreadTest15/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0119-rt-thread-ThreadTest15/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0120-rt-thread-ThreadTest3/ThreadTest.java b/testsuite/java_test/thread_test/RT0120-rt-thread-ThreadTest3/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..b4baed5edef708b071b9506d192b3aa5a9b8a8f6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0120-rt-thread-ThreadTest3/ThreadTest.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    /**
+     * Verify currentThread()
+    */
+
+    public static void main(String[] args) throws Exception {
+        System.out.println(Thread.currentThread().getName());
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0120-rt-thread-ThreadTest3/expected.txt b/testsuite/java_test/thread_test/RT0120-rt-thread-ThreadTest3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ba2906d0666cf726c7eaadd2cd3db615dedfdf3a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0120-rt-thread-ThreadTest3/expected.txt
@@ -0,0 +1 @@
+main
diff --git a/testsuite/java_test/thread_test/RT0120-rt-thread-ThreadTest3/test.cfg b/testsuite/java_test/thread_test/RT0120-rt-thread-ThreadTest3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0120-rt-thread-ThreadTest3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0122-rt-thread-ThreadTest22/ThreadTest.java b/testsuite/java_test/thread_test/RT0122-rt-thread-ThreadTest22/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..d974f75c08fe46fe18ce1e34a7555d46824a3aab
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0122-rt-thread-ThreadTest22/ThreadTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadTest {
+    private static final long waitDuration = 3000;
+    private static long waitTime = 0;
+    private static boolean doSleep(int interval) {
+        try {
+            Thread.sleep(interval);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        waitTime -= interval;
+        return waitTime <= 0;
+    }
+    // test for interrupt() -- Interrupt a newly created thread
+    // Interrupting a thread that is not alive need not have any effect.
+    /* If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+    */
+
+    public static void main(String[] args) {
+        boolean expired = false;
+        boolean result = false;
+        Thread thread = new Thread();
+        thread.interrupt();
+        waitTime = waitDuration;
+        while (!result && !expired) {
+            expired = doSleep(600);
+            result = thread.isInterrupted();
+        }
+        System.out.println("thread's state is -- " + thread.getState());
+        System.out.println("isInterrupted() finally returns -- " + result);
+        if (expired) {
+            System.out.println("interrupt status has not changed to true");
+        } else {
+            System.out.println("*PASS*");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0122-rt-thread-ThreadTest22/expected.txt b/testsuite/java_test/thread_test/RT0122-rt-thread-ThreadTest22/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5235d1fb92beef722a9af3dd9efc3e3f6562d6d6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0122-rt-thread-ThreadTest22/expected.txt
@@ -0,0 +1,3 @@
+thread's state is -- NEW
+isInterrupted() finally returns -- false
+interrupt status has not changed to true
diff --git a/testsuite/java_test/thread_test/RT0122-rt-thread-ThreadTest22/test.cfg b/testsuite/java_test/thread_test/RT0122-rt-thread-ThreadTest22/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0122-rt-thread-ThreadTest22/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0123-rt-thread-ThreadTest7/ThreadTest.java b/testsuite/java_test/thread_test/RT0123-rt-thread-ThreadTest7/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..5f1c440ed48ad8124ef1c19b3888bbf9fe853d2a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0123-rt-thread-ThreadTest7/ThreadTest.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    //test for getPriority()
+    public static void main(String[] args) throws Exception {
+        Thread thread = new Thread();
+        int p = thread.getPriority();
+        System.out.println(Thread.MIN_PRIORITY + " <= " + p + " <= " + Thread.MAX_PRIORITY);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0123-rt-thread-ThreadTest7/expected.txt b/testsuite/java_test/thread_test/RT0123-rt-thread-ThreadTest7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f20c11fd81f57bad0c87f79ca5e81406ed70a797
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0123-rt-thread-ThreadTest7/expected.txt
@@ -0,0 +1 @@
+1 <= 5 <= 10
diff --git a/testsuite/java_test/thread_test/RT0123-rt-thread-ThreadTest7/test.cfg b/testsuite/java_test/thread_test/RT0123-rt-thread-ThreadTest7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0123-rt-thread-ThreadTest7/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0124-rt-thread-ThreadTest2/ThreadTest.java b/testsuite/java_test/thread_test/RT0124-rt-thread-ThreadTest2/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..110f0574334534205d0b9ebc02458f491e5b81a2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0124-rt-thread-ThreadTest2/ThreadTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    /**
+     * Get active threads count; should be > 0
+    */
+
+    public static void main(String[] args) throws Exception {
+        int activeCount = Thread.activeCount();
+        System.out.println("The active threads count == " + activeCount);
+        Thread thread = new Thread(() -> {
+            try {
+                Thread.sleep(1000);
+            } catch (Exception e) {
+            }
+        });
+        thread.start();
+        try {
+            Thread.sleep(500);
+        } catch (InterruptedException e1) {
+        }
+        activeCount = Thread.activeCount();
+        System.out.println("The active threads count == " + activeCount);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0124-rt-thread-ThreadTest2/expected.txt b/testsuite/java_test/thread_test/RT0124-rt-thread-ThreadTest2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7ab1fc21d47456d57cbb02e335b546529d58cc46
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0124-rt-thread-ThreadTest2/expected.txt
@@ -0,0 +1,2 @@
+The active threads count == 1
+The active threads count == 2
diff --git a/testsuite/java_test/thread_test/RT0124-rt-thread-ThreadTest2/test.cfg b/testsuite/java_test/thread_test/RT0124-rt-thread-ThreadTest2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0124-rt-thread-ThreadTest2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0125-rt-thread-ThreadTest26/ThreadTest.java b/testsuite/java_test/thread_test/RT0125-rt-thread-ThreadTest26/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..fa05a462436282106b1884f2ca09c5447f8c64f6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0125-rt-thread-ThreadTest26/ThreadTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //Test for setUncaughtExceptionHandler()
+        ThreadGroup threadGroup = new ThreadGroup("test thread group");
+        Thread thread = new Thread(threadGroup, new ThreadRun("helloworld!"));
+        ExceptionHandler exceptionHandler = new ExceptionHandler();
+        thread.setUncaughtExceptionHandler(exceptionHandler);
+        System.out.println("should be same -- " + exceptionHandler.equals(thread.getUncaughtExceptionHandler()));
+        //Test for setUncaughtExceptionHandler(null)
+        ThreadGroup threadGroup2 = new ThreadGroup("test thread group2");
+        Thread thread2 = new Thread(threadGroup2, new ThreadRun("helloworld!"));
+        thread2.setUncaughtExceptionHandler(null);
+        System.out.println("Thread's thread group is expected to be a handler -- "
+                + threadGroup2.equals(thread2.getUncaughtExceptionHandler()));
+        System.out.println("PASS");
+    }
+    private static class ThreadRun implements Runnable {
+        private final String helloworld;
+        public ThreadRun(String str) {
+            helloworld = str;
+        }
+        public void run() {
+            System.out.println(helloworld);
+        }
+    }
+    static class ExceptionHandler implements Thread.UncaughtExceptionHandler {
+        public boolean wasCalled = false;
+        public void uncaughtException(Thread t, Throwable e) {
+            wasCalled = true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0125-rt-thread-ThreadTest26/expected.txt b/testsuite/java_test/thread_test/RT0125-rt-thread-ThreadTest26/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a082fe88081aa1adfc29a709dee623acf3c18cab
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0125-rt-thread-ThreadTest26/expected.txt
@@ -0,0 +1,3 @@
+should be same -- true
+Thread's thread group is expected to be a handler -- true
+PASS
diff --git a/testsuite/java_test/thread_test/RT0125-rt-thread-ThreadTest26/test.cfg b/testsuite/java_test/thread_test/RT0125-rt-thread-ThreadTest26/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0125-rt-thread-ThreadTest26/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0127-rt-thread-ThreadTest18/ThreadTest.java b/testsuite/java_test/thread_test/RT0127-rt-thread-ThreadTest18/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..711e1dedc7888457072570802a361e2432d77bd9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0127-rt-thread-ThreadTest18/ThreadTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //Try to make a running thread daemon, test SetDaemonLiveThread
+        ThreadRunning threadRunning = new ThreadRunning();
+        try {
+            threadRunning.setDaemon(true);
+            threadRunning.start();
+        } catch (Exception e) {
+            System.out.println("fail");
+        }
+        try {
+            Thread.sleep(1000);
+        } catch (Exception e) {
+        }
+        System.out.println(threadRunning.isDaemon());
+        System.out.println(threadRunning.isAlive());
+        threadRunning.stopWork = true;
+        try {
+            Thread.sleep(1000);
+        } catch (Exception e) {
+        }
+        System.out.println(threadRunning.isDaemon());
+        System.out.println(threadRunning.isAlive());
+    }
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0127-rt-thread-ThreadTest18/expected.txt b/testsuite/java_test/thread_test/RT0127-rt-thread-ThreadTest18/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6859f05a484f226996dbfd571215aabf198b713b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0127-rt-thread-ThreadTest18/expected.txt
@@ -0,0 +1,4 @@
+true
+true
+true
+false
diff --git a/testsuite/java_test/thread_test/RT0127-rt-thread-ThreadTest18/test.cfg b/testsuite/java_test/thread_test/RT0127-rt-thread-ThreadTest18/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0127-rt-thread-ThreadTest18/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0128-rt-thread-ThreadTest16/ThreadTest.java b/testsuite/java_test/thread_test/RT0128-rt-thread-ThreadTest16/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..9c06424327081b237b163d26a0364cec5f1c5aeb
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0128-rt-thread-ThreadTest16/ThreadTest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class MyThread extends Thread {
+    public void run() {
+        while (!isInterrupted()) {
+            yield();
+        }
+        System.out.println(isInterrupted());
+        System.out.println(interrupted());
+        System.out.println(isInterrupted());
+    }
+}
+public class ThreadTest {
+    public static void main(String[] args) {
+        Thread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.sleep(1000);
+            thread.interrupt();
+        } catch (Exception e) {
+            System.out.println("catch");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0128-rt-thread-ThreadTest16/expected.txt b/testsuite/java_test/thread_test/RT0128-rt-thread-ThreadTest16/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e8a46acf90aaea980b01694192fc81f613beafb
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0128-rt-thread-ThreadTest16/expected.txt
@@ -0,0 +1,3 @@
+true
+true
+false
diff --git a/testsuite/java_test/thread_test/RT0128-rt-thread-ThreadTest16/test.cfg b/testsuite/java_test/thread_test/RT0128-rt-thread-ThreadTest16/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0128-rt-thread-ThreadTest16/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0129-rt-thread-ThreadBenchmark1/ThreadBufferChainMain.java b/testsuite/java_test/thread_test/RT0129-rt-thread-ThreadBenchmark1/ThreadBufferChainMain.java
new file mode 100755
index 0000000000000000000000000000000000000000..b9e2eb7a835822935739219084a483052605d1db
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0129-rt-thread-ThreadBenchmark1/ThreadBufferChainMain.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.IOException;
+import java.util.ArrayList;
+/**
+ * Thread buffer synchronization benchmark.
+ * @author Christoph Knabe, {@linkplain http://public.beuth-hochschule.de/~knabe/ }
+ * @since 2016-04-15
+*/
+
+public class ThreadBufferChainMain {
+    public static void main(final String[] args) throws InterruptedException, IOException {
+        for(int chainLength = 10; chainLength < 200; chainLength *= 10) {
+            benchmarkThreadBufferChain(chainLength);
+        }
+        System.out.println(0);
+    }
+    /**
+     * Creates a Thread-Buffer chain with the given number of threads, and sends number messages through this chain.
+     * Thus this method causes number*number thread switches.
+     * Reports the elapsed time from start of the sending to arrival of the last message at the end of the chain.
+     * @param number Number of threads in the Thread-Buffer chain
+    */
+
+    private static void benchmarkThreadBufferChain(final int number) throws InterruptedException {
+        Buffer lastBuf = new Buffer();
+        final Consumer consumer = new Consumer(lastBuf);
+        consumer.start();
+        ArrayList<Forwarder> forwarders = new ArrayList<>();
+        for(int i = 3; i <= number; i++) {
+            final Buffer newBuf = new Buffer();
+            final Forwarder forwarder = new Forwarder(newBuf, lastBuf);
+            forwarder.start();
+            lastBuf = newBuf;
+            forwarders.add(forwarder);
+        }
+        final Producer producer = new Producer(lastBuf, number);
+        producer.start();
+        consumer.join();
+        try{
+            producer.join();
+            for (int i = 0; i < forwarders.size(); i++) {
+                forwarders.get(i).interrupt();
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+    }
+}
+class Buffer {
+    private int value;
+    private boolean available = false;
+    public synchronized int get() throws InterruptedException {
+        while (!available) {
+            wait();
+        }
+        available = false;
+        notifyAll();
+        return value;
+    }
+    public synchronized void put(final int value) throws InterruptedException {
+        while (available) {
+            wait();
+        }
+        this.value = value;
+        available = true;
+        notifyAll();
+    }
+}
+class Consumer extends Thread {
+    private final Buffer buffer;
+    public Consumer(final Buffer buffer) {
+        this.buffer = buffer;
+    }
+    public void run() {
+        try {
+            for (;;) {
+                final int value = buffer.get();
+                if(value<0) {
+                    break;
+                }
+            }
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        }
+    }
+}
+/**
+ * The Forwarder is the most important type of the inner nodes of the Thread chain.
+ * The message passing between the Producer and the first Forwarder, between two adjacent Forwarders,
+ * and between the last Forwarder and the Consumer takes place by using a synchronized Buffer
+ * according to the Java Tutorial, Trail Essential Java Classes,
+ * Lesson Threads: Doing Two or More Tasks At Once, The Producer/Consumer Example.
+ * Findable for example at {@linkplain http://www.eng.nene.ac.uk/~gary/javatut/essential/threads/synchronization.html}
+*/
+
+class Forwarder extends Thread {
+    private final Buffer inputBuffer;
+    private final Buffer outputBuffer;
+    public Forwarder(final Buffer inputBuffer, final Buffer outputBuffer) {
+        this.inputBuffer = inputBuffer;
+        this.outputBuffer = outputBuffer;
+    }
+    public void run() {
+        try {
+            for (;;) {
+                final int value = inputBuffer.get();
+                outputBuffer.put(value);
+            }
+        } catch (InterruptedException e) {
+            //ignore the interrupted exception
+        }
+    }
+}
+class Producer extends Thread {
+    private final Buffer buffer;
+    private final int numberOfItems;
+    public Producer(final Buffer cubbyHole, final int numberOfItems) {
+        this.buffer = cubbyHole;
+        this.numberOfItems = numberOfItems;
+    }
+    public void run() {
+        try {
+            for (int i = 0; i <= numberOfItems; i++) {
+                final int msg = i<numberOfItems ? i : -1;
+                buffer.put(msg);
+            }
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0129-rt-thread-ThreadBenchmark1/expected.txt b/testsuite/java_test/thread_test/RT0129-rt-thread-ThreadBenchmark1/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0129-rt-thread-ThreadBenchmark1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0129-rt-thread-ThreadBenchmark1/test.cfg b/testsuite/java_test/thread_test/RT0129-rt-thread-ThreadBenchmark1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7eafe0f2211855f0c32db6a7d365fe269ba17217
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0129-rt-thread-ThreadBenchmark1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadBufferChainMain)
+run(ThreadBufferChainMain)
diff --git a/testsuite/java_test/thread_test/RT0130-rt-thread-ThreadTest20/ThreadTest.java b/testsuite/java_test/thread_test/RT0130-rt-thread-ThreadTest20/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..4e2e05aefbc42a26076d39f2f95aa3e4036a178b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0130-rt-thread-ThreadTest20/ThreadTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //Try to make a running thread daemon, test SetDaemonLiveThread
+        ThreadRunning1 threadRunning1 = new ThreadRunning1();
+        ThreadRunning2 threadRunning2 = new ThreadRunning2();
+        ThreadRunning1 threadRunning3 = new ThreadRunning1();
+        threadRunning1.setDaemon(true);
+        threadRunning3.setDaemon(true);
+        threadRunning1.start();
+        threadRunning2.start();
+        threadRunning3.start();
+        try {
+            Thread.sleep(1000);
+        } catch (Exception e) {
+        }
+        threadRunning2.stopWork = true;
+    }
+    static class ThreadRunning1 extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning1() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+            }
+            System.out.println("ThreadRunning1");
+        }
+    }
+    static class ThreadRunning2 extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning2() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+            System.out.println("ThreadRunning2");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0130-rt-thread-ThreadTest20/expected.txt b/testsuite/java_test/thread_test/RT0130-rt-thread-ThreadTest20/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4521c9607bb4eebcf1196cafca8765e346e4a13c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0130-rt-thread-ThreadTest20/expected.txt
@@ -0,0 +1 @@
+ThreadRunning2
diff --git a/testsuite/java_test/thread_test/RT0130-rt-thread-ThreadTest20/test.cfg b/testsuite/java_test/thread_test/RT0130-rt-thread-ThreadTest20/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0130-rt-thread-ThreadTest20/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0131-rt-thread-ThreadTest14/ThreadTest.java b/testsuite/java_test/thread_test/RT0131-rt-thread-ThreadTest14/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..1e6205deec667ed4b18670d6edf3e53d6576b653
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0131-rt-thread-ThreadTest14/ThreadTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //for  join(long millis)
+        ThreadRunning threadRunning = new ThreadRunning();
+        threadRunning.start();
+        try {
+            threadRunning.join(-1);
+            System.out.println("join(millis) OK");
+            threadRunning.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning.stopWork = true;
+            System.out.println("in join(millis), millis is negative");
+        }
+        ThreadRunning threadRunning2 = new ThreadRunning();
+        threadRunning2.start();
+        try {
+            threadRunning2.join(1000);
+            System.out.println("join(millis) OK");
+            threadRunning2.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning2.stopWork = true;
+            System.out.println("in join(millis), millis is negative");
+        }
+        //for join(long millis, int nanos)
+        ThreadRunning threadRunning3 = new ThreadRunning();
+        threadRunning3.start();
+        try {
+            threadRunning3.join(1000, 1123456);
+            System.out.println("join(millis, nanos) OK");
+            threadRunning3.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning3.stopWork = true;
+            System.out.println("in join(millis, nanos), nanosecond out of range");
+        }
+        ThreadRunning threadRunning4 = new ThreadRunning();
+        threadRunning4.start();
+        try {
+            threadRunning4.join(-2, 123456);
+            System.out.println("join(millis, nanos) OK");
+            threadRunning4.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning4.stopWork = true;
+            System.out.println("in join(millis, nanos), millis is negative");
+        }
+        ThreadRunning threadRunning5 = new ThreadRunning();
+        threadRunning5.start();
+        try {
+            threadRunning5.join(1000, 123456);
+            System.out.println("join(millis, nanos) OK");
+            threadRunning5.stopWork = true;
+        } catch (IllegalArgumentException e) {
+            threadRunning5.stopWork = true;
+            System.out.println("in join(millis, nanos), millis is negative or nanosecond out of range");
+        }
+        System.out.println("PASS");
+    }
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0131-rt-thread-ThreadTest14/expected.txt b/testsuite/java_test/thread_test/RT0131-rt-thread-ThreadTest14/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..141e3eb82aa3826f5a9b6b303474e2a6da110d4e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0131-rt-thread-ThreadTest14/expected.txt
@@ -0,0 +1,6 @@
+in join(millis), millis is negative
+join(millis) OK
+in join(millis, nanos), nanosecond out of range
+in join(millis, nanos), millis is negative
+join(millis, nanos) OK
+PASS
diff --git a/testsuite/java_test/thread_test/RT0131-rt-thread-ThreadTest14/test.cfg b/testsuite/java_test/thread_test/RT0131-rt-thread-ThreadTest14/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0131-rt-thread-ThreadTest14/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0132-rt-thread-ThreadTest17/ThreadTest.java b/testsuite/java_test/thread_test/RT0132-rt-thread-ThreadTest17/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..00daaa9fa2c9a4f2988437d9db1b18e67171c3ee
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0132-rt-thread-ThreadTest17/ThreadTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        //Try to make a running thread daemon, test SetDaemonLiveThread
+        ThreadRunning threadRunning = new ThreadRunning();
+        threadRunning.start();
+        System.out.println(threadRunning.isAlive());
+        threadRunning.stopWork = true;
+        threadRunning.join();
+        System.out.println(threadRunning.isAlive());
+    }
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0132-rt-thread-ThreadTest17/expected.txt b/testsuite/java_test/thread_test/RT0132-rt-thread-ThreadTest17/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..da29283aaa47cd5d0ac424a424fe51351b767933
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0132-rt-thread-ThreadTest17/expected.txt
@@ -0,0 +1,2 @@
+true
+false
diff --git a/testsuite/java_test/thread_test/RT0132-rt-thread-ThreadTest17/test.cfg b/testsuite/java_test/thread_test/RT0132-rt-thread-ThreadTest17/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0132-rt-thread-ThreadTest17/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0133-rt-thread-ThreadTest33/ThreadTest.java b/testsuite/java_test/thread_test/RT0133-rt-thread-ThreadTest33/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6f2b916cf98d66f6765cca8794d081919476aa6e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0133-rt-thread-ThreadTest33/ThreadTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Test for void yield()
+        */
+
+        ThreadYielding threadYielding1 = new ThreadYielding();
+        ThreadYielding threadYielding2 = new ThreadYielding();
+        threadYielding1.start();
+        threadYielding2.start();
+        try {
+            threadYielding1.join();
+            threadYielding2.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE");
+        }
+        int threadNum = ThreadYielding.dim;
+        // We suppose that threads t1 and t2 alternate with each other.
+        // The might be a case when some another thread (not t2) runs
+        // while t1 is yelding. In this case the 'list' might start with 1s
+        // and end with 2s and look like threads does not alternate.
+        // We cannot treat this as failure nevertheless.
+        // We just make sure that both threads have finished successfully.
+        System.out.println("threads have finished successfully --- " +
+                (threadYielding1.count == threadNum / 2) + " --- " + (threadYielding2.count == threadNum / 2));
+        System.out.println("PASS");
+    }
+    private static class ThreadYielding extends Thread {
+        public static final int dim = 200;
+        public int count = 0;
+        public synchronized void incCount() {
+            count++;
+        }
+        public void run() {
+            for (int i = 0; i < dim / 2; i++) {
+                incCount();
+                Thread.yield();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0133-rt-thread-ThreadTest33/expected.txt b/testsuite/java_test/thread_test/RT0133-rt-thread-ThreadTest33/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..51dde25c12a926e59056a02235b34f61259300a4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0133-rt-thread-ThreadTest33/expected.txt
@@ -0,0 +1,2 @@
+threads have finished successfully --- true --- true
+PASS
diff --git a/testsuite/java_test/thread_test/RT0133-rt-thread-ThreadTest33/test.cfg b/testsuite/java_test/thread_test/RT0133-rt-thread-ThreadTest33/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0133-rt-thread-ThreadTest33/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0134-rt-thread-ThreadTest27/ThreadTest.java b/testsuite/java_test/thread_test/RT0134-rt-thread-ThreadTest27/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..955537cd93419385b410d503c043d730a980b532
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0134-rt-thread-ThreadTest27/ThreadTest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Test set/get DefaultUncaughtExceptionHandler()
+        */
+
+        ExceptionHandler exceptionHandler = new ExceptionHandler();
+        Thread.setDefaultUncaughtExceptionHandler(exceptionHandler);
+        System.out.println("The default handler has been set, should print true -- " +
+                exceptionHandler.equals(Thread.getDefaultUncaughtExceptionHandler()));
+        /**
+         * Test set/get DefaultUncaughtExceptionHandler(null)
+        */
+
+        Thread.setDefaultUncaughtExceptionHandler(null);
+        System.out.println("Default handler should be null, and the test is -- " +
+                Thread.getDefaultUncaughtExceptionHandler());
+        System.out.println("PASS");
+    }
+    static class ExceptionHandler implements Thread.UncaughtExceptionHandler {
+        public boolean wasCalled = false;
+        public void uncaughtException(Thread t, Throwable e) {
+            wasCalled = true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0134-rt-thread-ThreadTest27/expected.txt b/testsuite/java_test/thread_test/RT0134-rt-thread-ThreadTest27/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a5d085c54f496072a090995fbdcdda3f04ff63e6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0134-rt-thread-ThreadTest27/expected.txt
@@ -0,0 +1,3 @@
+The default handler has been set, should print true -- true
+Default handler should be null, and the test is -- null
+PASS
diff --git a/testsuite/java_test/thread_test/RT0134-rt-thread-ThreadTest27/test.cfg b/testsuite/java_test/thread_test/RT0134-rt-thread-ThreadTest27/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0134-rt-thread-ThreadTest27/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0135-rt-thread-StartOOMTest/StartOOMTest.java b/testsuite/java_test/thread_test/RT0135-rt-thread-StartOOMTest/StartOOMTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..6c5d7bd9ae04c0fc8105aa04d45619964abc4ced
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0135-rt-thread-StartOOMTest/StartOOMTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.util.List;
+public class StartOOMTest {
+    public static void main(String[] args) throws Throwable {
+        Runnable r = new SleepRunnable();
+        ThreadGroup tg = new ThreadGroup("buggy");
+        List<Thread> threads = new ArrayList<Thread>();
+        Thread failedThread = null;
+        int i = 0;
+        for (i = 0; i < 101; i++) {
+            Thread t = new Thread(tg, r);
+            try {
+                if (i == 100) {
+                    throw new OutOfMemoryError("throw OutOfMemoryError");
+                }
+                t.start();
+                threads.add(t);
+            } catch (Throwable x) {
+                failedThread = t;
+                System.out.println(x);
+                System.out.println(i);
+                break;
+            }
+        }
+        int j = 0;
+        for (Thread t : threads) {
+            t.interrupt();
+        }
+        while (tg.activeCount() > i / 2) {
+            Thread.yield();
+        }
+        failedThread.start();
+        failedThread.interrupt();
+        for (Thread t : threads) {
+            t.join();
+        }
+        failedThread.join();
+        try {
+            Thread.sleep(1000);
+        } catch (Throwable ignore) {
+            System.out.println("Sleep is interrupted");
+        }
+        int activeCount = tg.activeCount();
+        System.out.println("activeCount = " + activeCount);
+        if (activeCount > 0) {
+            throw new RuntimeException("Failed: there  should be no active Threads in the group");
+        }
+    }
+    static class SleepRunnable implements Runnable {
+        public void run() {
+            try {
+                Thread.sleep(60 * 1000);
+            } catch (Throwable t) {
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0135-rt-thread-StartOOMTest/expected.txt b/testsuite/java_test/thread_test/RT0135-rt-thread-StartOOMTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5dc13937e79e104ad8298d8b1b4bfc7fe25173db
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0135-rt-thread-StartOOMTest/expected.txt
@@ -0,0 +1,3 @@
+java.lang.OutOfMemoryError: throw OutOfMemoryError
+100
+activeCount = 0
diff --git a/testsuite/java_test/thread_test/RT0135-rt-thread-StartOOMTest/test.cfg b/testsuite/java_test/thread_test/RT0135-rt-thread-StartOOMTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8ceadb1d1f391b507dde3a3919a9be96bd0cadf1
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0135-rt-thread-StartOOMTest/test.cfg
@@ -0,0 +1,2 @@
+compile(StartOOMTest)
+run(StartOOMTest)
diff --git a/testsuite/java_test/thread_test/RT0136-rt-thread-ThreadTest29/ThreadTest.java b/testsuite/java_test/thread_test/RT0136-rt-thread-ThreadTest29/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..2dd8ce3e122befded390f649359ce103bd2ebe9a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0136-rt-thread-ThreadTest29/ThreadTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class ThreadTest {
+    public static void main(String[] args) {
+        ThreadJoining t = new ThreadJoining(10000, 0);
+        t.start();
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        t.interrupt();
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("main throws InterruptedException");
+        }
+        System.out.println("interrupt status has been cleared, if the output is false -- " + t.isInterrupted());
+    }
+    /* Test for interrupt() -- Interrupt a joining thread
+     * If this thread is blocked in an invocation
+     * of the wait(), wait(long), or wait(long, int) methods of the Object class, or
+     * of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class,
+     * then its interrupt status will be cleared and it will receive an InterruptedException.
+    */
+
+    private static class ThreadJoining extends Thread {
+        private long millis;
+        private int nanos;
+        ThreadJoining(long millis, int nanos) {
+            this.millis = millis;
+            this.nanos = nanos;
+        }
+        public void run() {
+            try {
+                this.join(millis, nanos);
+                System.out.println("Fail -- joining thread has not received the InterruptedException");
+            } catch (InterruptedException e) {
+                System.out.println("joining thread has received the InterruptedException");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0136-rt-thread-ThreadTest29/expected.txt b/testsuite/java_test/thread_test/RT0136-rt-thread-ThreadTest29/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e82bef7b283a44eef0174ec574dfa36bdc81dd6b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0136-rt-thread-ThreadTest29/expected.txt
@@ -0,0 +1,2 @@
+joining thread has received the InterruptedException
+interrupt status has been cleared, if the output is false -- false
diff --git a/testsuite/java_test/thread_test/RT0136-rt-thread-ThreadTest29/test.cfg b/testsuite/java_test/thread_test/RT0136-rt-thread-ThreadTest29/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0136-rt-thread-ThreadTest29/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0137-rt-thread-ThreadTest12/ThreadTest.java b/testsuite/java_test/thread_test/RT0137-rt-thread-ThreadTest12/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..7e92929c3a158bb12bc1cba35c485b39f3842656
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0137-rt-thread-ThreadTest12/ThreadTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        /**
+         * Verify that a thread created by a daemon thread is daemon
+        */
+
+        ThreadRunningAnotherThread t = new ThreadRunningAnotherThread();
+        t.setDaemon(true);
+        t.start();
+        t.stop = true;
+        try {
+            t.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE --");
+        }
+        System.out.println("the child thread of a daemon thread is daemon --- " +
+                t.childIsDaemon);
+        /**
+         * Verify that a thread created by a non-daemon thread is not daemon
+        */
+
+        ThreadRunningAnotherThread tt = new ThreadRunningAnotherThread();
+        tt.setDaemon(false);
+        tt.start();
+        tt.stop = true;
+        try {
+            tt.join();
+        } catch (InterruptedException e) {
+            System.out.println("INTERRUPTED_MESSAGE --");
+        }
+        System.out.println("the child thread of a non-daemon thread is non-daemon --- " +
+                tt.childIsDaemon);
+    }
+    // Test for setDaemon() and isDaemon()
+    private static class ThreadRunningAnotherThread extends Thread {
+        int field = 0;
+        volatile boolean stop = false;
+        boolean childIsDaemon = false;
+        Thread curThread = null;
+        public ThreadRunningAnotherThread() {
+            super();
+        }
+        public void run() {
+            Thread child = new Thread();
+            curThread = Thread.currentThread();
+            childIsDaemon = child.isDaemon();
+            while (!stop) {
+                field++;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0137-rt-thread-ThreadTest12/expected.txt b/testsuite/java_test/thread_test/RT0137-rt-thread-ThreadTest12/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..42b89ede4bb0bbb883f6155f8301ca45580c2c05
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0137-rt-thread-ThreadTest12/expected.txt
@@ -0,0 +1,2 @@
+the child thread of a daemon thread is daemon --- true
+the child thread of a non-daemon thread is non-daemon --- false
diff --git a/testsuite/java_test/thread_test/RT0137-rt-thread-ThreadTest12/test.cfg b/testsuite/java_test/thread_test/RT0137-rt-thread-ThreadTest12/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0137-rt-thread-ThreadTest12/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0138-rt-thread-ThreadTest32/ThreadTest.java b/testsuite/java_test/thread_test/RT0138-rt-thread-ThreadTest32/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..5d6f5c09ea8c8170c63f28960999281cc103e071
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0138-rt-thread-ThreadTest32/ThreadTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    /**
+     * Thread(ThreadGroup, Runnable, String, long) stack size is Long.MAX_VALUE.
+    */
+
+    public static void main(String[] args) throws Exception {
+        // Does not work in maple, no exception occurs, run() is not executed.
+        boolean expired = false;
+        ThreadGroup tg = new ThreadGroup("newGroup");
+        String name = "t1";
+        Square s = new Square();
+        System.out.println(Long.MAX_VALUE);
+        try {
+            Thread t = new Thread(tg, s, name, Long.MAX_VALUE);
+            System.out.println("Creation_OK");
+            t.start();
+        } catch (OutOfMemoryError er) {
+            System.out.println("OutOfMemoryError");
+        }
+        System.out.println("PASS");
+    }
+    static class Square implements Runnable {
+        public void run() {
+            System.out.println("Enter_OK");
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException e) {
+                System.out.println("unexpected InterruptedException while sleeping");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0138-rt-thread-ThreadTest32/expected.txt b/testsuite/java_test/thread_test/RT0138-rt-thread-ThreadTest32/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..033cd932140f84a82bad8d087976ca55150dba69
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0138-rt-thread-ThreadTest32/expected.txt
@@ -0,0 +1,4 @@
+9223372036854775807
+Creation_OK
+OutOfMemoryError
+PASS
diff --git a/testsuite/java_test/thread_test/RT0138-rt-thread-ThreadTest32/test.cfg b/testsuite/java_test/thread_test/RT0138-rt-thread-ThreadTest32/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0138-rt-thread-ThreadTest32/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0139-rt-thread-ThreadTest4/ThreadTest.java b/testsuite/java_test/thread_test/RT0139-rt-thread-ThreadTest4/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..901f2c5a93197c8ed89e73abdb47c07fc110b1d4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0139-rt-thread-ThreadTest4/ThreadTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    // Enumerate() does not work in maple.
+    public static void main(String[] args) throws Exception {
+        ThreadRunning t1 = new ThreadRunning();
+        t1.start();
+        ThreadRunning t2 = new ThreadRunning();
+        t2.start();
+        ThreadRunning t11 = new ThreadRunning();
+        t11.start();
+        ThreadRunning t12 = new ThreadRunning();
+        t12.start();
+        ThreadRunning t121 = new ThreadRunning();
+        t121.start();
+        ThreadRunning t122 = new ThreadRunning();
+        t122.start();
+        // Estimate dimension as 6 created threads.
+        // Plus 10 for some other threads.
+        int estimateLength = 16;
+        Thread[] list;
+        int count;
+        while (true) {
+            list = new Thread[estimateLength];
+            count = Thread.enumerate(list);
+            if (count == estimateLength) {
+                estimateLength *= 2;
+            } else {
+                //System.out.println(count);
+                break;
+            }
+        }
+        t1.stopWork = true;
+        t2.stopWork = true;
+        t11.stopWork = true;
+        t12.stopWork = true;
+        t121.stopWork = true;
+        t122.stopWork = true;
+        System.out.println("thread count : " + count);
+    }
+    // Test for enumerate()
+    static class ThreadRunning extends Thread {
+        public volatile int i = 0;
+        volatile boolean stopWork = false;
+        ThreadRunning() {
+            super();
+        }
+        public void run() {
+            while (!stopWork) {
+                i++;
+                i--;
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0139-rt-thread-ThreadTest4/expected.txt b/testsuite/java_test/thread_test/RT0139-rt-thread-ThreadTest4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7f9624ca62d175bfd3aad612d3888917c47278c0
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0139-rt-thread-ThreadTest4/expected.txt
@@ -0,0 +1 @@
+thread count : 7
diff --git a/testsuite/java_test/thread_test/RT0139-rt-thread-ThreadTest4/test.cfg b/testsuite/java_test/thread_test/RT0139-rt-thread-ThreadTest4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0139-rt-thread-ThreadTest4/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0140-rt-thread-MainThreadTest/MainThreadTest.java b/testsuite/java_test/thread_test/RT0140-rt-thread-MainThreadTest/MainThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..88132d3be3d7e5a62fd588aa638a36cd3789b88c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0140-rt-thread-MainThreadTest/MainThreadTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class MainThreadTest {
+    public static void main(String[] args) {
+        ThreadGroup tg = Thread.currentThread().getThreadGroup();
+        int n = tg.activeCount();
+        Thread[] ts = new Thread[n];
+        int m = tg.enumerate(ts);
+        for (int i = 0; i < ts.length; i++) {
+            if (Thread.currentThread() == ts[i]) {
+                System.out.println(0);
+                return;
+            }
+        }
+        throw new RuntimeException("Current thread is not in its own thread group!");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0140-rt-thread-MainThreadTest/expected.txt b/testsuite/java_test/thread_test/RT0140-rt-thread-MainThreadTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0140-rt-thread-MainThreadTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0140-rt-thread-MainThreadTest/test.cfg b/testsuite/java_test/thread_test/RT0140-rt-thread-MainThreadTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5c9cd7fbc85d88fc806b24fd5d35bee31a765731
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0140-rt-thread-MainThreadTest/test.cfg
@@ -0,0 +1,2 @@
+compile(MainThreadTest)
+run(MainThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0141-rt-thread-ThreadTest35/ThreadTest.java b/testsuite/java_test/thread_test/RT0141-rt-thread-ThreadTest35/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..742eb68d3408ea723c869ae7c072d0230a7aa7f2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0141-rt-thread-ThreadTest35/ThreadTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    // Test for setName()
+    public static void main(String[] args) throws Exception {
+        Thread thread = new Thread();
+        String newName = "maple_thread";
+        thread.setName(newName);
+        System.out.println("set the new name -- " + newName + " ---- " + thread.getName());
+        /**
+         * Verify the setName(null) method, and throw NullPointerException
+        */
+
+        Thread t = new Thread();
+        try {
+            t.setName(null);
+        } catch (NullPointerException e) {
+            System.out.println("setName() should not accept null names");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0141-rt-thread-ThreadTest35/expected.txt b/testsuite/java_test/thread_test/RT0141-rt-thread-ThreadTest35/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..49bb1ef68cbf773151292da19117f81fd183e8e3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0141-rt-thread-ThreadTest35/expected.txt
@@ -0,0 +1,2 @@
+set the new name -- maple_thread ---- maple_thread
+setName() should not accept null names
diff --git a/testsuite/java_test/thread_test/RT0141-rt-thread-ThreadTest35/test.cfg b/testsuite/java_test/thread_test/RT0141-rt-thread-ThreadTest35/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0141-rt-thread-ThreadTest35/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0142-rt-thread-ThreadTest5/ThreadTest.java b/testsuite/java_test/thread_test/RT0142-rt-thread-ThreadTest5/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..2d826501658199f18b0b4a8542156b1969529bbf
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0142-rt-thread-ThreadTest5/ThreadTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        // Test set/get DefaultUncaughtExceptionHandler
+        ExceptionHandler eh = new ExceptionHandler();
+        Thread.setDefaultUncaughtExceptionHandler(eh);
+        Thread.UncaughtExceptionHandler ret1 = Thread.getDefaultUncaughtExceptionHandler();
+        //Test set/get DefaultUncaughtExceptionHandler(null)
+        Thread.setDefaultUncaughtExceptionHandler(null);
+        Thread.UncaughtExceptionHandler ret2 = Thread.getDefaultUncaughtExceptionHandler();
+        if (ret1 == eh && ret2 == null)
+            System.out.println(0);
+    }
+    static class ExceptionHandler implements Thread.UncaughtExceptionHandler {
+        public boolean wasCalled = false;
+        public void uncaughtException(Thread t, Throwable e) {
+            wasCalled = true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0142-rt-thread-ThreadTest5/expected.txt b/testsuite/java_test/thread_test/RT0142-rt-thread-ThreadTest5/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0142-rt-thread-ThreadTest5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0142-rt-thread-ThreadTest5/test.cfg b/testsuite/java_test/thread_test/RT0142-rt-thread-ThreadTest5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0142-rt-thread-ThreadTest5/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0143-rt-thread-Daemon/Daemon.java b/testsuite/java_test/thread_test/RT0143-rt-thread-Daemon/Daemon.java
new file mode 100755
index 0000000000000000000000000000000000000000..a83e2f682053b72dd53c47778908c1044c39f618
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0143-rt-thread-Daemon/Daemon.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class Daemon {
+    public static void main(String[] args) throws Exception {
+        ThreadGroup tg = new ThreadGroup("madbot-threads");
+        Thread myThread = new MadThread(tg, "mad");
+        ThreadGroup aGroup = new ThreadGroup(tg, "ness");
+        tg.setDaemon(true);
+        if (tg.activeCount() != 0)
+            throw new RuntimeException("activeCount");
+        aGroup.destroy();
+        if (tg.isDestroyed())
+            throw new RuntimeException("destroy");
+        try {
+            Thread anotherThread = new MadThread(aGroup, "bot");
+            throw new RuntimeException("illegal");
+        } catch (IllegalThreadStateException itse) {
+            // Correct result
+        }
+        System.out.println("Passed");
+    }
+}
+class MadThread extends Thread {
+    String name;
+    MadThread(ThreadGroup tg, String name) {
+        super(tg, name);
+        this.name = name;
+    }
+    public void run() {
+        System.out.println("me run " + name);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0143-rt-thread-Daemon/expected.txt b/testsuite/java_test/thread_test/RT0143-rt-thread-Daemon/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..863339fb8ced63ccd812aa9ad0e7ba95bf830600
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0143-rt-thread-Daemon/expected.txt
@@ -0,0 +1 @@
+Passed
diff --git a/testsuite/java_test/thread_test/RT0143-rt-thread-Daemon/test.cfg b/testsuite/java_test/thread_test/RT0143-rt-thread-Daemon/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fd214b1dbf5e3dd0dee34f7176fd8abb49adf375
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0143-rt-thread-Daemon/test.cfg
@@ -0,0 +1,2 @@
+compile(Daemon)
+run(Daemon)
diff --git a/testsuite/java_test/thread_test/RT0144-rt-thread-ThreadTest10/ThreadTest.java b/testsuite/java_test/thread_test/RT0144-rt-thread-ThreadTest10/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..ea1a6290288b519b053d6bac743f74bd8f19c460
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0144-rt-thread-ThreadTest10/ThreadTest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            System.out.println("unexpected InterruptedException while sleeping");
+        }
+        System.out.println("Test sleep(long millis) OK --");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0144-rt-thread-ThreadTest10/expected.txt b/testsuite/java_test/thread_test/RT0144-rt-thread-ThreadTest10/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5655c2e0c37d8b36f915390f6c8100b5bb6f5b5d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0144-rt-thread-ThreadTest10/expected.txt
@@ -0,0 +1 @@
+Test sleep(long millis) OK --
diff --git a/testsuite/java_test/thread_test/RT0144-rt-thread-ThreadTest10/test.cfg b/testsuite/java_test/thread_test/RT0144-rt-thread-ThreadTest10/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0144-rt-thread-ThreadTest10/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0145-rt-thread-MemoryLeak/MemoryLeak.java b/testsuite/java_test/thread_test/RT0145-rt-thread-MemoryLeak/MemoryLeak.java
new file mode 100755
index 0000000000000000000000000000000000000000..7845d7a98be6270da2644fced418d12730a2cafb
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0145-rt-thread-MemoryLeak/MemoryLeak.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class MemoryLeak {
+    public static void main(String[] args) {
+        for (int i = 0; i < 1000; i++) {
+            ThreadLocal t = new ThreadLocal();
+            t.set(new Object());
+            t.set(null);
+        }
+        System.out.println("Passed");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0145-rt-thread-MemoryLeak/expected.txt b/testsuite/java_test/thread_test/RT0145-rt-thread-MemoryLeak/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..863339fb8ced63ccd812aa9ad0e7ba95bf830600
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0145-rt-thread-MemoryLeak/expected.txt
@@ -0,0 +1 @@
+Passed
diff --git a/testsuite/java_test/thread_test/RT0145-rt-thread-MemoryLeak/test.cfg b/testsuite/java_test/thread_test/RT0145-rt-thread-MemoryLeak/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..021f6f90090230253ccc07055677546aa9afca5d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0145-rt-thread-MemoryLeak/test.cfg
@@ -0,0 +1,2 @@
+compile(MemoryLeak)
+run(MemoryLeak)
diff --git a/testsuite/java_test/thread_test/RT0146-rt-thread-ThreadId/ThreadId.java b/testsuite/java_test/thread_test/RT0146-rt-thread-ThreadId/ThreadId.java
new file mode 100755
index 0000000000000000000000000000000000000000..0692d2f7af2baae5e25ca63737775e749227cfa9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0146-rt-thread-ThreadId/ThreadId.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.concurrent.atomic.AtomicInteger;
+public class ThreadId {
+    private static final AtomicInteger nextId = new AtomicInteger(0);
+    private static final ThreadLocal<Integer> threadId =
+            new ThreadLocal<Integer>() {
+                @Override
+                protected Integer initialValue() {
+                    return nextId.getAndIncrement();
+                }
+            };
+    public static int get() {
+        return threadId.get();
+    }
+    public static void main(String[] args) {
+        System.out.println(get());
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0146-rt-thread-ThreadId/expected.txt b/testsuite/java_test/thread_test/RT0146-rt-thread-ThreadId/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0146-rt-thread-ThreadId/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0146-rt-thread-ThreadId/test.cfg b/testsuite/java_test/thread_test/RT0146-rt-thread-ThreadId/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e0034837f48d7cb396eb9d9d284fe18b4653260f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0146-rt-thread-ThreadId/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadId)
+run(ThreadId)
diff --git a/testsuite/java_test/thread_test/RT0147-rt-thread-ThreadTest1/ThreadTest.java b/testsuite/java_test/thread_test/RT0147-rt-thread-ThreadTest1/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..1f44d7fe36afbb19fda6996c3741c8f84c2c9623
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0147-rt-thread-ThreadTest1/ThreadTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class MyThread extends Thread {
+    public void run() {
+        try {
+            while (!isInterrupted()) {
+                Thread.sleep(10000);
+            }
+        } catch (Exception e) {
+            System.out.println("isInterrupted");
+        }
+    }
+}
+public class ThreadTest {
+    public static void main(String[] args) {
+        Thread t1 = new MyThread();
+        t1.start();
+        try {
+            Thread.sleep(1000);
+            t1.interrupt();
+        } catch (Exception e) {
+            System.out.println("catch");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0147-rt-thread-ThreadTest1/expected.txt b/testsuite/java_test/thread_test/RT0147-rt-thread-ThreadTest1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..df346654b351abd67af692a4fedd4dbc4c00cc87
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0147-rt-thread-ThreadTest1/expected.txt
@@ -0,0 +1 @@
+isInterrupted
diff --git a/testsuite/java_test/thread_test/RT0147-rt-thread-ThreadTest1/test.cfg b/testsuite/java_test/thread_test/RT0147-rt-thread-ThreadTest1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0147-rt-thread-ThreadTest1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0148-rt-thread-ThreadTest37/ThreadTest.java b/testsuite/java_test/thread_test/RT0148-rt-thread-ThreadTest37/ThreadTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..2009cf11d16414cb1caefefd9d09fbaeb143d991
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0148-rt-thread-ThreadTest37/ThreadTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadTest {
+    public static void main(String[] args) throws Exception {
+        long millis = 2000;
+        try {
+            Thread.sleep(millis);
+            System.out.println("sleep(long millis) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis) as: millis < 0");
+        }
+        try {
+            Thread.sleep(-2);
+            System.out.println("sleep(long millis) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis) as: millis < 0");
+        }
+        int nanos = 123456;
+        try {
+            Thread.sleep(millis, nanos);
+            System.out.println("sleep(long millis, int nanos) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis, int nanos) as: millis < 0 or nanos < 0 or nanos > 999999");
+        }
+        try {
+            Thread.sleep(millis, -1);
+            System.out.println("sleep(long millis, int nanos) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis, int nanos) as: nanos < 0");
+        }
+        try {
+            Thread.sleep(millis, 1123456);
+            System.out.println("sleep(long millis, int nanos) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis, int nanos) as: nanos > 999999");
+        }
+        try {
+            Thread.sleep(-3, nanos);
+            System.out.println("sleep(long millis, int nanos) OK");
+        } catch (IllegalArgumentException e) {
+            System.out.println("IllegalArgumentException for sleep(long millis, int nanos) as: millis < 0");
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0148-rt-thread-ThreadTest37/expected.txt b/testsuite/java_test/thread_test/RT0148-rt-thread-ThreadTest37/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e85cd096e2d73099afa1194aeac379b748098c29
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0148-rt-thread-ThreadTest37/expected.txt
@@ -0,0 +1,6 @@
+sleep(long millis) OK
+IllegalArgumentException for sleep(long millis) as: millis < 0
+sleep(long millis, int nanos) OK
+IllegalArgumentException for sleep(long millis, int nanos) as: nanos < 0
+IllegalArgumentException for sleep(long millis, int nanos) as: nanos > 999999
+IllegalArgumentException for sleep(long millis, int nanos) as: millis < 0
diff --git a/testsuite/java_test/thread_test/RT0148-rt-thread-ThreadTest37/test.cfg b/testsuite/java_test/thread_test/RT0148-rt-thread-ThreadTest37/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..524bbced2b5e8a0e28f4a0123435c1f89eac70c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0148-rt-thread-ThreadTest37/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadTest)
+run(ThreadTest)
diff --git a/testsuite/java_test/thread_test/RT0149-rt-thread-ThreadConstructors13/ThreadConstructors13.java b/testsuite/java_test/thread_test/RT0149-rt-thread-ThreadConstructors13/ThreadConstructors13.java
new file mode 100644
index 0000000000000000000000000000000000000000..44790968bbea4be9e573e78e186c30d942cf57b6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0149-rt-thread-ThreadConstructors13/ThreadConstructors13.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors13 extends Thread {
+    static int i = 0;
+    private static int ecount = 0;
+    public ThreadConstructors13(String name) {
+        super(name);
+    }
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors13 test_illegal1 = new ThreadConstructors13(null);
+        } catch (NullPointerException e) {
+            ecount++;
+        }
+        ThreadConstructors13 test_illegal2 = new ThreadConstructors13("");
+        ThreadConstructors13 test_illegal3 = new ThreadConstructors13("");
+        test_illegal2.start();
+        try {
+            test_illegal2.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+        test_illegal3.start();
+        try {
+            test_illegal3.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+        if (i == 2) {
+            if (ecount == 1) {
+                System.out.println("0");
+                return;
+            }
+        }
+        System.out.println("2");
+        return;
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0149-rt-thread-ThreadConstructors13/expected.txt b/testsuite/java_test/thread_test/RT0149-rt-thread-ThreadConstructors13/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0149-rt-thread-ThreadConstructors13/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0149-rt-thread-ThreadConstructors13/test.cfg b/testsuite/java_test/thread_test/RT0149-rt-thread-ThreadConstructors13/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5f8b937b7e55a57ddce27e4290ca1dc355cb2ba4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0149-rt-thread-ThreadConstructors13/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors13)
+run(ThreadConstructors13)
diff --git a/testsuite/java_test/thread_test/RT0150-rt-thread-ThreadConstructors14/ThreadConstructors14.java b/testsuite/java_test/thread_test/RT0150-rt-thread-ThreadConstructors14/ThreadConstructors14.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2b0ea17d27bb0e0ee2fbbd13f03ed46aba9c5a2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0150-rt-thread-ThreadConstructors14/ThreadConstructors14.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors14 extends Thread {
+    static int i = 0;
+    public ThreadConstructors14(ThreadGroup group, Runnable target) {
+        super(group, target);
+    }
+    public static void main(String[] args) {
+        ThreadConstructors14 test_illegal1 = new ThreadConstructors14(null, null);
+        test_illegal1.start();
+        try {
+            test_illegal1.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+        if (i == 1) {
+            System.out.println("0");
+            return;
+        }
+        System.out.println("2");
+        return;
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0150-rt-thread-ThreadConstructors14/expected.txt b/testsuite/java_test/thread_test/RT0150-rt-thread-ThreadConstructors14/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0150-rt-thread-ThreadConstructors14/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0150-rt-thread-ThreadConstructors14/test.cfg b/testsuite/java_test/thread_test/RT0150-rt-thread-ThreadConstructors14/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..971e062f3e8eb54bd45627298df19883094ba248
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0150-rt-thread-ThreadConstructors14/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors14)
+run(ThreadConstructors14)
diff --git a/testsuite/java_test/thread_test/RT0151-rt-thread-ThreadConstructors15/ThreadConstructors15.java b/testsuite/java_test/thread_test/RT0151-rt-thread-ThreadConstructors15/ThreadConstructors15.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d4f0a37217751ac391535d72c1cab473a95ff3a
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0151-rt-thread-ThreadConstructors15/ThreadConstructors15.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors15 extends Thread {
+    static int i = 0;
+    static int ecount = 0;
+    public ThreadConstructors15(ThreadGroup group, Runnable target, String name) {
+        super(group, target, name);
+    }
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors15 test_illegal1 = new ThreadConstructors15(null, null, null);
+        } catch (NullPointerException e) {
+            //System.out.println("NullPointerException");
+            ecount++;
+        }
+        ThreadConstructors15 test_illegal2 = new ThreadConstructors15(null, null, "");
+        ThreadConstructors15 test_illegal3 = new ThreadConstructors15(null, null, "");
+        test_illegal2.start();
+        try {
+            test_illegal2.join();
+        } catch (InterruptedException e) {
+            //System.out.println("NullPointerException");
+        }
+        test_illegal3.start();
+        try {
+            test_illegal3.join();
+        } catch (InterruptedException e) {
+            //System.out.println("NullPointerException");
+        }
+        if (i == 2) {
+            if (ecount == 1) {
+                System.out.println("0");
+                return;
+            }
+        }
+        System.out.println("2");
+        return;
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0151-rt-thread-ThreadConstructors15/expected.txt b/testsuite/java_test/thread_test/RT0151-rt-thread-ThreadConstructors15/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0151-rt-thread-ThreadConstructors15/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0151-rt-thread-ThreadConstructors15/test.cfg b/testsuite/java_test/thread_test/RT0151-rt-thread-ThreadConstructors15/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c27efc8882b59e37e0a42e63698bff7b16ed45c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0151-rt-thread-ThreadConstructors15/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors15)
+run(ThreadConstructors15)
diff --git a/testsuite/java_test/thread_test/RT0152-rt-thread-ThreadConstructors16/ThreadConstructors16.java b/testsuite/java_test/thread_test/RT0152-rt-thread-ThreadConstructors16/ThreadConstructors16.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a59cae4aa4c6b1c9642ac6478293d51a8d6079c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0152-rt-thread-ThreadConstructors16/ThreadConstructors16.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors16 extends Thread {
+    static int i = 0;
+    static int ecount = 0;
+    public ThreadConstructors16(ThreadGroup group, Runnable target, String name, long stackSize) {
+        super(group, target, name, stackSize);
+    }
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors16 test_illegal1 = new ThreadConstructors16(null, null, null, 0);
+        } catch (NullPointerException e) {
+            //System.out.println("NullPointerException");
+            ecount++;
+        }
+        try {
+            ThreadConstructors16 test_illegal2 = new ThreadConstructors16(null, null, "", Long.MAX_VALUE);
+        } catch (OutOfMemoryError ee) {
+            System.out.println("OutOfMemoryError");
+            ecount += 2;
+        }
+        ThreadConstructors16[] test_illegal = new ThreadConstructors16[3];
+        test_illegal[0] = new ThreadConstructors16(null, null, "", 100); //Long.MIN_VALUE);
+        test_illegal[1] = new ThreadConstructors16(null, null, "", new Integer("-1"));
+        test_illegal[2] = new ThreadConstructors16(null, null, "", new Short("00356"));
+        for (ThreadConstructors16 thread : test_illegal) {
+            thread.start();
+            try {
+                thread.join();
+            } catch (InterruptedException e) {
+               // System.out.println("InterruptedException");
+            }
+        }
+        if (i == 3) {
+            if (ecount == 1) {
+                System.out.println("0");
+                return;
+            }
+        }
+        System.out.println("2");
+        return;
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0152-rt-thread-ThreadConstructors16/expected.txt b/testsuite/java_test/thread_test/RT0152-rt-thread-ThreadConstructors16/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0152-rt-thread-ThreadConstructors16/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0152-rt-thread-ThreadConstructors16/test.cfg b/testsuite/java_test/thread_test/RT0152-rt-thread-ThreadConstructors16/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0721a5421813d237294b4e55f2b794bdadc9d57d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0152-rt-thread-ThreadConstructors16/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors16)
+run(ThreadConstructors16)
diff --git a/testsuite/java_test/thread_test/RT0153-rt-thread-ThreadConstructors17/ThreadConstructors17.java b/testsuite/java_test/thread_test/RT0153-rt-thread-ThreadConstructors17/ThreadConstructors17.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf865c4902f03aca9d4bf3a70babb15113f0c7d4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0153-rt-thread-ThreadConstructors17/ThreadConstructors17.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors17 extends Thread {
+    static int i = 0;
+    static int ecount = 0;
+    public ThreadConstructors17(ThreadGroup group, String name) {
+        super(group, name);
+    }
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors17 test_illegal1 = new ThreadConstructors17(null, null);
+        } catch (NullPointerException e) {
+            //System.out.println("NullPointerException");
+            ecount++;
+        }
+        ThreadConstructors17 test_illegal2 = new ThreadConstructors17(null, "");
+        ThreadConstructors17 test_illegal3 = new ThreadConstructors17(null, new String());
+        test_illegal2.start();
+        try {
+            test_illegal2.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+        test_illegal3.start();
+        try {
+            test_illegal3.join();
+        } catch (InterruptedException e) {
+            System.out.println("InterruptedException");
+        }
+        if (i == 2) {
+            if (ecount == 1) {
+                System.out.println("0");
+                return;
+            }
+        }
+        System.out.println("2");
+        return;
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0153-rt-thread-ThreadConstructors17/expected.txt b/testsuite/java_test/thread_test/RT0153-rt-thread-ThreadConstructors17/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0153-rt-thread-ThreadConstructors17/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0153-rt-thread-ThreadConstructors17/test.cfg b/testsuite/java_test/thread_test/RT0153-rt-thread-ThreadConstructors17/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..27e518e8e8857e1b705c9e6577ee2d36cab153c9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0153-rt-thread-ThreadConstructors17/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors17)
+run(ThreadConstructors17)
diff --git a/testsuite/java_test/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/ThreadCountStackFramesTest.java b/testsuite/java_test/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/ThreadCountStackFramesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c44fbda68ea58d9f38fae61636f46c814ead154
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/ThreadCountStackFramesTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadCountStackFramesTest extends Thread {
+    static int cnt = 0;
+    static Object ob = "aa";
+    public static void main(String[] args) {
+        ThreadCountStackFramesTest thCountStackFramesTest = new ThreadCountStackFramesTest();
+        synchronized (ob) {
+            thCountStackFramesTest.start();
+            try {
+                ob.wait();
+            } catch (InterruptedException e) {
+                System.out.println("Main wait is interrupted");
+            }
+        }
+        try {
+            cnt = thCountStackFramesTest.countStackFrames();
+        } catch (IllegalThreadStateException e) {
+            System.out.println(2);
+            return;
+        }
+        int j = thCountStackFramesTest.getStackTrace().length;
+        if (j == cnt) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (ob) {
+            ob.notify();
+            try {
+                ob.wait(1000);
+            } catch (InterruptedException e) {
+                System.out.println("Thread wait is interrupted");
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/expected.txt b/testsuite/java_test/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/test.cfg b/testsuite/java_test/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..51aa3bd79e30982f699885b707ff9848f4b46398
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0154-rt-thread-ThreadEHcountStackFrames/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadCountStackFramesTest)
+run(ThreadCountStackFramesTest)
diff --git a/testsuite/java_test/thread_test/RT0155-rt-thread-ThreadEHdestroy/ThreadDestroyUnsupportedOperationExceptionTest.java b/testsuite/java_test/thread_test/RT0155-rt-thread-ThreadEHdestroy/ThreadDestroyUnsupportedOperationExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a89eb0994b29a166224df9bd372436817fce9a24
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0155-rt-thread-ThreadEHdestroy/ThreadDestroyUnsupportedOperationExceptionTest.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadDestroyUnsupportedOperationExceptionTest extends Thread {
+    public static void main(String[] args) {
+        ThreadDestroyUnsupportedOperationExceptionTest thread = new ThreadDestroyUnsupportedOperationExceptionTest();
+        thread.start();
+        try {
+            thread.destroy();
+        } catch (UnsupportedOperationException e) {
+            System.out.println(0);
+            return;
+        } catch (Throwable ee) {
+            System.out.println(1);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0155-rt-thread-ThreadEHdestroy/expected.txt b/testsuite/java_test/thread_test/RT0155-rt-thread-ThreadEHdestroy/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0155-rt-thread-ThreadEHdestroy/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0155-rt-thread-ThreadEHdestroy/test.cfg b/testsuite/java_test/thread_test/RT0155-rt-thread-ThreadEHdestroy/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..02d688eec82033372cd3aff720813d3beeac28a3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0155-rt-thread-ThreadEHdestroy/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadDestroyUnsupportedOperationExceptionTest)
+run(ThreadDestroyUnsupportedOperationExceptionTest)
diff --git a/testsuite/java_test/thread_test/RT0156-rt-thread-Threadenumerate2/Threadenumerate2.java b/testsuite/java_test/thread_test/RT0156-rt-thread-Threadenumerate2/Threadenumerate2.java
new file mode 100644
index 0000000000000000000000000000000000000000..83c59a5595a0b78e234726e03f8939af11913aa0
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0156-rt-thread-Threadenumerate2/Threadenumerate2.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class Threadenumerate2 extends Thread {
+    static int num = 0;
+    static int eCount = 0;
+    public static void main(String[] args) {
+        Threadenumerate2 te = new Threadenumerate2();
+        te.start();
+        try {
+            enumerate(null);
+        } catch (NullPointerException e) {
+            eCount++;
+        }
+        num = enumerate(new Thread[0]);
+        if (num == 0 && eCount == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0156-rt-thread-Threadenumerate2/expected.txt b/testsuite/java_test/thread_test/RT0156-rt-thread-Threadenumerate2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0156-rt-thread-Threadenumerate2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0156-rt-thread-Threadenumerate2/test.cfg b/testsuite/java_test/thread_test/RT0156-rt-thread-Threadenumerate2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6d6a8ebca8b271adb0312310b7a1f25dae4e713f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0156-rt-thread-Threadenumerate2/test.cfg
@@ -0,0 +1,2 @@
+compile(Threadenumerate2)
+run(Threadenumerate2)
diff --git a/testsuite/java_test/thread_test/RT0157-rt-thread-ThreadgetAllStackTraces/ThreadGetAllStackTracesTest.java b/testsuite/java_test/thread_test/RT0157-rt-thread-ThreadgetAllStackTraces/ThreadGetAllStackTracesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..34fadfecb8820135c2e35de31280acdeeadc0fa8
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0157-rt-thread-ThreadgetAllStackTraces/ThreadGetAllStackTracesTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Map;
+public class ThreadGetAllStackTracesTest extends Thread {
+    static volatile boolean keeprun = true;
+    static class MyThread extends Thread {
+        MyThread(String name) {
+            super(name);
+        }
+        public void run() {
+            while (keeprun) {
+                try {
+                    Thread.sleep(100);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+    public static void main(String[] args) {
+        Thread test = new MyThread("haha");
+        Map m = getAllStackTraces();
+        String stOrigin = m.keySet().toString();
+        int sizeOrigin = m.size();
+        if (stOrigin.contains("haha")) {
+            System.out.println(1);
+            return;
+        }
+        test.start();
+        m = getAllStackTraces();
+        String stRun = m.keySet().toString();
+        int sizeRun = m.size();
+        if (!stRun.contains("haha") || (sizeRun - sizeOrigin) != 1) {
+            System.out.println(2);
+            return;
+        }
+        keeprun = false;
+        try {
+            test.join();
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+        m = getAllStackTraces();
+        String stFinish = m.keySet().toString();
+        int sizeFinish = m.size();
+        if (stFinish.contains("haha") || (sizeRun - sizeFinish) != 1) {
+            System.out.println(3);
+            return;
+        }
+        System.out.println(0);
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0157-rt-thread-ThreadgetAllStackTraces/expected.txt b/testsuite/java_test/thread_test/RT0157-rt-thread-ThreadgetAllStackTraces/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0157-rt-thread-ThreadgetAllStackTraces/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0157-rt-thread-ThreadgetAllStackTraces/test.cfg b/testsuite/java_test/thread_test/RT0157-rt-thread-ThreadgetAllStackTraces/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7df54aab71996319f67a04383653513947856cf8
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0157-rt-thread-ThreadgetAllStackTraces/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetAllStackTracesTest)
+run(ThreadGetAllStackTracesTest)
diff --git a/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/ThreadGetStackTraceTest.java_bak b/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/ThreadGetStackTraceTest.java_bak
new file mode 100644
index 0000000000000000000000000000000000000000..cb9e0839c348f131fca36d7cc7d46a29f20561e3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/ThreadGetStackTraceTest.java_bak
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+public class ThreadGetStackTraceTest extends Thread {
+    public static void main(String[] args) {
+        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+        int l = stackTraceElements.length;
+        if (stackTraceElements[l - 1].toString().contains("main") && stackTraceElements[l - 2].toString().contains("run")
+                && stackTraceElements[l - 3].toString().contains("ThreadGetStackTraceTest")) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/ThreadgetStackTrace.java b/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/ThreadgetStackTrace.java
new file mode 100644
index 0000000000000000000000000000000000000000..13e7d5ee9972f12c3ee3a148f7105d1a502fe068
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/ThreadgetStackTrace.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ThreadgetStackTrace extends Thread {
+    public static void main(String[] args) {
+        System.out.println(run(args, System.out));
+    }
+    public static int run(String[] args, PrintStream out) {
+        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+        int l = stackTraceElements.length;
+        if (stackTraceElements[l - 1].toString().contains("main") && stackTraceElements[l - 2].toString().contains("run") && stackTraceElements[l - 3].toString().contains("getStackTrace")) {
+            return 0;
+        }
+        return 2;
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/expected.txt b/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/test.cfg b/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8b5a6e89a33839ffa4ef3738842ff6e548bb7b4e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0158-rt-thread-ThreadgetStackTrace/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadgetStackTrace)
+run(ThreadgetStackTrace)
diff --git a/testsuite/java_test/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/ThreadGroupAllowThreadSuspensionTest.java b/testsuite/java_test/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/ThreadGroupAllowThreadSuspensionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb9a46fcd7ad80f32c4b02737e94311a715cc0c7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/ThreadGroupAllowThreadSuspensionTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.reflect.Field;
+public class ThreadGroupAllowThreadSuspensionTest {
+    public static void main(String[] args) {
+        ThreadGroup tg = new ThreadGroup("group");
+        tg.allowThreadSuspension(true);
+        try {
+            if (getValue(tg, "vmAllowSuspension").toString() != "true") {
+                System.out.println(2);
+                return;
+            }
+        } catch (Throwable e) {
+            System.out.println(2);
+            return;
+        }
+        tg.allowThreadSuspension(false);
+        try {
+            if (getValue(tg, "vmAllowSuspension").toString() != "false") {
+                System.out.println(2);
+                return;
+            }
+        } catch (Throwable e) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+    // Use reflect to get the value of private field of ThreadGroup
+    public static Object getValue(Object instance, String fieldName) throws IllegalAccessException, NoSuchFieldException {
+        Field field = getField(instance.getClass(), fieldName);
+        field.setAccessible(true);
+        return field.get(instance);
+    }
+    public static Field getField(Class thisClass, String fieldName) throws NoSuchFieldException {
+        if (fieldName == null) {
+            throw new NoSuchFieldException("Error field !");
+        }
+        Field field = thisClass.getDeclaredField(fieldName);
+        return field;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/expected.txt b/testsuite/java_test/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/test.cfg b/testsuite/java_test/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ce809615507247fc6e11527891ed951a3eaa68f9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0159-rt-thread-ThreadGroupallowThreadSuspension/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupAllowThreadSuspensionTest)
+run(ThreadGroupAllowThreadSuspensionTest)
diff --git a/testsuite/java_test/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/ThreadGroupEHdestroy.java b/testsuite/java_test/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/ThreadGroupEHdestroy.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2f12e4b6c13d501e5757a68ca9fcd01ab83490c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/ThreadGroupEHdestroy.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGroupEHdestroy {
+    static int cnt = 0;
+    public static void main(String[] args) {
+        ThreadGroup tg = new ThreadGroup("hi");
+        Thread t = new Thread(tg, "hello");
+        t.start();
+        // Destroy a thread group which is not empty, throws IllegalThreadStateException
+        try {
+            tg.destroy();
+        } catch (IllegalThreadStateException e) {
+            cnt++;
+        }
+        try {
+            t.join();
+        } catch (InterruptedException ee) {
+            System.out.println("Join is interrupted");
+        }
+        tg.destroy();
+        // Destroy a thread group which is already destroyed, throws IllegalThreadStateException
+        try {
+            tg.destroy();
+        } catch (IllegalThreadStateException e) {
+            cnt += 2;
+        }
+        if (cnt == 3) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/expected.txt b/testsuite/java_test/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/test.cfg b/testsuite/java_test/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6753110dcfb604b66fc1b9943836678794fab47c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0160-rt-thread-ThreadGroupEHdestroy/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGroupEHdestroy)
+run(ThreadGroupEHdestroy)
diff --git a/testsuite/java_test/thread_test/RT0161-rt-thread-ThreadholdsLock4/ThreadholdsLock4.java b/testsuite/java_test/thread_test/RT0161-rt-thread-ThreadholdsLock4/ThreadholdsLock4.java
new file mode 100644
index 0000000000000000000000000000000000000000..efbc97d294989cf94d291e0052685e1e669ceffa
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0161-rt-thread-ThreadholdsLock4/ThreadholdsLock4.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadholdsLock4 extends Thread {
+    static int eCount = 0;
+    static int sCount = 0;
+    public static void main(String[] args) {
+        ThreadholdsLock4 tl = new ThreadholdsLock4();
+        try {
+            holdsLock(null);
+        } catch (NullPointerException e) {
+            eCount++;
+        }
+        if (!holdsLock("")) {
+            if (!holdsLock("")) {
+                if (!holdsLock(new Object())) {
+                    sCount++;
+                }
+            }
+        }
+        if (sCount == 1 && eCount == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0161-rt-thread-ThreadholdsLock4/expected.txt b/testsuite/java_test/thread_test/RT0161-rt-thread-ThreadholdsLock4/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0161-rt-thread-ThreadholdsLock4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0161-rt-thread-ThreadholdsLock4/test.cfg b/testsuite/java_test/thread_test/RT0161-rt-thread-ThreadholdsLock4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fb4fb772dc4a850d37b3fb8c8ccd5f7e9c18ec21
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0161-rt-thread-ThreadholdsLock4/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadholdsLock4)
+run(ThreadholdsLock4)
diff --git a/testsuite/java_test/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/ThreadLocalEHwithInitial.java b/testsuite/java_test/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/ThreadLocalEHwithInitial.java
new file mode 100644
index 0000000000000000000000000000000000000000..eff2f05b6bf4f157356fd3f555d8ad7234e42c78
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/ThreadLocalEHwithInitial.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadLocalEHwithInitial {
+    public static void main(String[] args) {
+        try {
+            ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(null);
+        } catch (NullPointerException e) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/expected.txt b/testsuite/java_test/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/test.cfg b/testsuite/java_test/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..48b3960e144e880632fbb906170179de4a8636a3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0162-rt-thread-ThreadLocalEHwithInitial/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalEHwithInitial)
+run(ThreadLocalEHwithInitial)
diff --git a/testsuite/java_test/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/ThreadsetContextClassLoader1.java b/testsuite/java_test/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/ThreadsetContextClassLoader1.java
new file mode 100644
index 0000000000000000000000000000000000000000..d465009e91cc9461cae6f12325046cfa823585f2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/ThreadsetContextClassLoader1.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadsetContextClassLoader1 extends Thread {
+    static int i = 0;
+    public static void main(String[] args) {
+        ThreadsetContextClassLoader1 t = new ThreadsetContextClassLoader1();
+        t.setContextClassLoader(null);
+        t.start();
+        try {
+            t.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1 && t.getContextClassLoader() == null) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/expected.txt b/testsuite/java_test/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/test.cfg b/testsuite/java_test/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..afe89420613bb2f6c66b07f5bbf408732eb52fc3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0163-rt-thread-ThreadsetContextClassLoader1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadsetContextClassLoader1)
+run(ThreadsetContextClassLoader1)
diff --git a/testsuite/java_test/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/ThreadSetDefaultUncaughtExceptionHandlerTest.java b/testsuite/java_test/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/ThreadSetDefaultUncaughtExceptionHandlerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d11619f047eb3c201b0c0636ebcc607f1d75d78
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/ThreadSetDefaultUncaughtExceptionHandlerTest.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetDefaultUncaughtExceptionHandlerTest extends Thread {
+    public static void main(String[] args) {
+        ThreadSetDefaultUncaughtExceptionHandlerTest setEH = new ThreadSetDefaultUncaughtExceptionHandlerTest();
+        Thread.setDefaultUncaughtExceptionHandler(setEH.getUncaughtExceptionHandler());
+        if (getDefaultUncaughtExceptionHandler() == null) {
+            System.out.println(1);
+            return;
+        }
+        Thread.setDefaultUncaughtExceptionHandler(null);
+        if (getDefaultUncaughtExceptionHandler() == null) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/expected.txt b/testsuite/java_test/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/test.cfg b/testsuite/java_test/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d307ab7413516a9b45e718fb4b200660f43e5215
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetDefaultUncaughtExceptionHandlerTest)
+run(ThreadSetDefaultUncaughtExceptionHandlerTest)
diff --git a/testsuite/java_test/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/ThreadSetUncaughtExceptionHandlerTest.java b/testsuite/java_test/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/ThreadSetUncaughtExceptionHandlerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..477e5b5f7191944870628214f5814d7ac42980d9
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/ThreadSetUncaughtExceptionHandlerTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetUncaughtExceptionHandlerTest extends Thread {
+    static int i = 0;
+    public static void main(String[] args) {
+        ThreadSetUncaughtExceptionHandlerTest setEH = new ThreadSetUncaughtExceptionHandlerTest();
+        if (setEH.getUncaughtExceptionHandler() == null) {
+            System.out.println(1);
+            return;
+        }
+        setEH.setUncaughtExceptionHandler(null);
+        setEH.start();
+        if (setEH.getUncaughtExceptionHandler() == null) {
+            System.out.println(2);
+            return;
+        }
+        try {
+            setEH.join();
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1 && setEH.getUncaughtExceptionHandler() != null) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(3);
+    }
+    public void run() {
+        i++;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/expected.txt b/testsuite/java_test/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/test.cfg b/testsuite/java_test/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..42a0e151a1432bf2defa801d553aa6c1ef292e5d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetUncaughtExceptionHandlerTest)
+run(ThreadSetUncaughtExceptionHandlerTest)
diff --git a/testsuite/java_test/thread_test/RT0166-rt-thread-ThreadStatejoin16/ThreadStatejoin16.java b/testsuite/java_test/thread_test/RT0166-rt-thread-ThreadStatejoin16/ThreadStatejoin16.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd8c2338103ca7c52786c3346a8fe78970eb79ae
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0166-rt-thread-ThreadStatejoin16/ThreadStatejoin16.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStatejoin16 extends Thread {
+    static int i = 0;
+    static int eCount = 0;
+    public static void main(String[] args) {
+        ThreadStatejoin16 tj = new ThreadStatejoin16();
+        tj.start();
+        try {
+            tj.join(-2);
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        } catch (IllegalArgumentException ee) {
+            eCount++;
+        }
+        try {
+            tj.join(0);
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        } catch (IllegalArgumentException ee) {
+            eCount = eCount + 2;
+        }
+        if (i == 1 && eCount == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0166-rt-thread-ThreadStatejoin16/expected.txt b/testsuite/java_test/thread_test/RT0166-rt-thread-ThreadStatejoin16/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0166-rt-thread-ThreadStatejoin16/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0166-rt-thread-ThreadStatejoin16/test.cfg b/testsuite/java_test/thread_test/RT0166-rt-thread-ThreadStatejoin16/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f54415fa53ccba96f8ac1a1f1a3206f979ffbbaf
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0166-rt-thread-ThreadStatejoin16/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStatejoin16)
+run(ThreadStatejoin16)
diff --git a/testsuite/java_test/thread_test/RT0167-rt-thread-ThreadStatejoin17/ThreadStatejoin17.java b/testsuite/java_test/thread_test/RT0167-rt-thread-ThreadStatejoin17/ThreadStatejoin17.java
new file mode 100644
index 0000000000000000000000000000000000000000..883266bb47530e1147b9f3b64109aa7c61b4fb89
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0167-rt-thread-ThreadStatejoin17/ThreadStatejoin17.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStatejoin17 extends Thread {
+    static int i = 0;
+    static int eCount = 0;
+    public static void main(String[] args) {
+        ThreadStatejoin17 tj = new ThreadStatejoin17();
+        tj.start();
+        long[] invalidMillis = new long[]{-2l, 2l};
+        int[] invalidNanos = new int[]{2, -2};
+        for (int j = 0; j < invalidMillis.length; j++) {
+            try {
+                tj.join(invalidMillis[j], invalidNanos[j]);
+            } catch (InterruptedException e) {
+                System.out.println(e);
+            } catch (IllegalArgumentException ee) {
+                eCount++;
+            }
+        }
+        try {
+            tj.join(0, 0);
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        } catch (IllegalArgumentException ee) {
+            eCount = eCount + 10;
+        }
+        if (i == 1 && eCount == invalidMillis.length) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0167-rt-thread-ThreadStatejoin17/expected.txt b/testsuite/java_test/thread_test/RT0167-rt-thread-ThreadStatejoin17/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0167-rt-thread-ThreadStatejoin17/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0167-rt-thread-ThreadStatejoin17/test.cfg b/testsuite/java_test/thread_test/RT0167-rt-thread-ThreadStatejoin17/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a1f276bc6e844f79410f5376a0e3aea5696dd979
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0167-rt-thread-ThreadStatejoin17/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStatejoin17)
+run(ThreadStatejoin17)
diff --git a/testsuite/java_test/thread_test/RT0168-rt-thread-ThreadStatesleep7/ThreadStatesleep7.java b/testsuite/java_test/thread_test/RT0168-rt-thread-ThreadStatesleep7/ThreadStatesleep7.java
new file mode 100644
index 0000000000000000000000000000000000000000..cecde078e043f6cd7db2224007daf3f7e572a922
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0168-rt-thread-ThreadStatesleep7/ThreadStatesleep7.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStatesleep7 extends Thread {
+    public static void main(String[] args) {
+        ThreadStatesleep7 cls = new ThreadStatesleep7();
+        cls.start();
+        try {
+            sleep(0);
+            sleep(0, 0);
+        } catch (InterruptedException e) {
+            System.out.println("sleep is interrupted");
+        } catch (IllegalArgumentException e1) {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(0);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0168-rt-thread-ThreadStatesleep7/expected.txt b/testsuite/java_test/thread_test/RT0168-rt-thread-ThreadStatesleep7/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0168-rt-thread-ThreadStatesleep7/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0168-rt-thread-ThreadStatesleep7/test.cfg b/testsuite/java_test/thread_test/RT0168-rt-thread-ThreadStatesleep7/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e5721fc532a817a9d9e4dd26401e4baeeffd28c4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0168-rt-thread-ThreadStatesleep7/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStatesleep7)
+run(ThreadStatesleep7)
diff --git a/testsuite/java_test/thread_test/RT0169-rt-thread-ThreadStatewait9/ThreadStatewait9.java b/testsuite/java_test/thread_test/RT0169-rt-thread-ThreadStatewait9/ThreadStatewait9.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5731ac504b89580ad3708ddebce452c7b25748c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0169-rt-thread-ThreadStatewait9/ThreadStatewait9.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStatewait9 extends Thread {
+    static Object ob = "aa";
+    static int i = 0;
+    public static void main(String[] args) {
+        ThreadStatewait9 threadWait = new ThreadStatewait9();
+        threadWait.start();
+        try {
+            threadWait.join();
+        } catch (InterruptedException ee) {
+            System.out.println(2);
+            return;
+        }
+        if (i == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (ob) {
+            try {
+                ob.wait(-1000);
+            } catch (IllegalArgumentException ee) {
+                i++;
+            } catch (InterruptedException e) {
+                System.out.println("Wait is interrupted");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0169-rt-thread-ThreadStatewait9/expected.txt b/testsuite/java_test/thread_test/RT0169-rt-thread-ThreadStatewait9/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0169-rt-thread-ThreadStatewait9/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0169-rt-thread-ThreadStatewait9/test.cfg b/testsuite/java_test/thread_test/RT0169-rt-thread-ThreadStatewait9/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd073464203a3417e71aa28eff36730a92c2a3b7
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0169-rt-thread-ThreadStatewait9/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStatewait9)
+run(ThreadStatewait9)
diff --git a/testsuite/java_test/thread_test/RT0170-rt-thread-ThreadStatewait10/ThreadStatewait10.java b/testsuite/java_test/thread_test/RT0170-rt-thread-ThreadStatewait10/ThreadStatewait10.java
new file mode 100644
index 0000000000000000000000000000000000000000..19ea10f717325c4613044097d857df76952171ee
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0170-rt-thread-ThreadStatewait10/ThreadStatewait10.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStatewait10 extends Thread {
+    static Object ob = "aa";
+    static int i = 0;
+    public static void main(String[] args) {
+        ThreadStatewait10 threadWait = new ThreadStatewait10();
+        threadWait.start();
+        try {
+            threadWait.join();
+        } catch (InterruptedException ee) {
+            System.out.println(2);
+            return;
+        }
+        if (i == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        synchronized (ob) {
+            try {
+                ob.wait(100, -1000);
+            } catch (IllegalArgumentException ee) {
+                i++;
+            } catch (InterruptedException e) {
+                System.out.println("Wait is interrupted");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0170-rt-thread-ThreadStatewait10/expected.txt b/testsuite/java_test/thread_test/RT0170-rt-thread-ThreadStatewait10/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0170-rt-thread-ThreadStatewait10/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0170-rt-thread-ThreadStatewait10/test.cfg b/testsuite/java_test/thread_test/RT0170-rt-thread-ThreadStatewait10/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..907e7a7fb835010efa6f0ac213e6f018979669e1
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0170-rt-thread-ThreadStatewait10/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStatewait10)
+run(ThreadStatewait10)
diff --git a/testsuite/java_test/thread_test/RT0171-rt-thread-ThreadStatewait11/ThreadStatewait11.java b/testsuite/java_test/thread_test/RT0171-rt-thread-ThreadStatewait11/ThreadStatewait11.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a0fb266d6b2b9219190b0bfaeb1608e1d5f22cf
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0171-rt-thread-ThreadStatewait11/ThreadStatewait11.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStatewait11 extends Thread {
+    public static void main(String[] args) {
+        ThreadStatewait11 threadWait = new ThreadStatewait11();
+        threadWait.start();
+        try {
+            threadWait.wait(0);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+            return;
+        } catch (IllegalMonitorStateException e1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0171-rt-thread-ThreadStatewait11/expected.txt b/testsuite/java_test/thread_test/RT0171-rt-thread-ThreadStatewait11/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0171-rt-thread-ThreadStatewait11/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0171-rt-thread-ThreadStatewait11/test.cfg b/testsuite/java_test/thread_test/RT0171-rt-thread-ThreadStatewait11/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa7910ad9890e393d7792f3c1879e2b28de6d40d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0171-rt-thread-ThreadStatewait11/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStatewait11)
+run(ThreadStatewait11)
diff --git a/testsuite/java_test/thread_test/RT0172-rt-thread-ThreadStatewait12/ThreadStatewait12.java b/testsuite/java_test/thread_test/RT0172-rt-thread-ThreadStatewait12/ThreadStatewait12.java
new file mode 100644
index 0000000000000000000000000000000000000000..14f187271b7db5e79a74735f29104241f07a32cb
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0172-rt-thread-ThreadStatewait12/ThreadStatewait12.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStatewait12 extends Thread {
+    public static void main(String[] args) {
+        ThreadStatewait12 threadWait = new ThreadStatewait12();
+        threadWait.start();
+        try {
+            threadWait.wait(0, 0);
+        } catch (InterruptedException e) {
+            System.out.println(2);
+            return;
+        } catch (IllegalMonitorStateException e1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0172-rt-thread-ThreadStatewait12/expected.txt b/testsuite/java_test/thread_test/RT0172-rt-thread-ThreadStatewait12/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0172-rt-thread-ThreadStatewait12/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0172-rt-thread-ThreadStatewait12/test.cfg b/testsuite/java_test/thread_test/RT0172-rt-thread-ThreadStatewait12/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..75bc95eaaa0612f681a77bc26428e9110b1119b2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0172-rt-thread-ThreadStatewait12/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStatewait12)
+run(ThreadStatewait12)
diff --git a/testsuite/java_test/thread_test/RT0173-rt-thread-ThreadConstructors11/ThreadConstructors11.java b/testsuite/java_test/thread_test/RT0173-rt-thread-ThreadConstructors11/ThreadConstructors11.java
new file mode 100644
index 0000000000000000000000000000000000000000..b585036b1a1e9d5054534f1ab74c5efe1c18c207
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0173-rt-thread-ThreadConstructors11/ThreadConstructors11.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors11 extends Thread {
+    static int i = 0;
+    public ThreadConstructors11(Runnable target) {
+        super(target);
+    }
+    public static void main(String[] args) {
+        ThreadConstructors11 test_illegal1 = new ThreadConstructors11(null);
+        test_illegal1.start();
+        try {
+            test_illegal1.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0173-rt-thread-ThreadConstructors11/expected.txt b/testsuite/java_test/thread_test/RT0173-rt-thread-ThreadConstructors11/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0173-rt-thread-ThreadConstructors11/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0173-rt-thread-ThreadConstructors11/test.cfg b/testsuite/java_test/thread_test/RT0173-rt-thread-ThreadConstructors11/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ddfbfeca31133a2c04a7cded15c420d1508f712c
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0173-rt-thread-ThreadConstructors11/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors11)
+run(ThreadConstructors11)
diff --git a/testsuite/java_test/thread_test/RT0174-rt-thread-ThreadConstructors12/ThreadConstructors12.java b/testsuite/java_test/thread_test/RT0174-rt-thread-ThreadConstructors12/ThreadConstructors12.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef755324cf0140d4ac66f2a36a8e91208601bf62
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0174-rt-thread-ThreadConstructors12/ThreadConstructors12.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadConstructors12 extends Thread {
+    static int i = 0;
+    static int eCount = 0;
+    public ThreadConstructors12(Runnable target, String name) {
+        super(target, name);
+    }
+    public static void main(String[] args) {
+        try {
+            ThreadConstructors12 test_illegal1 = new ThreadConstructors12(null, null);
+        } catch (NullPointerException e) {
+            eCount++;
+        }
+        ThreadConstructors12 test_illegal2 = new ThreadConstructors12(null, "");
+        ThreadConstructors12 test_illegal3 = new ThreadConstructors12(null, new String());
+        test_illegal2.start();
+        try {
+            test_illegal2.join();
+        } catch (InterruptedException e) {
+            System.out.println("test_illegal2 join is interrupted");
+        }
+        test_illegal3.start();
+        try {
+            test_illegal3.join();
+        } catch (InterruptedException e) {
+            System.out.println("test_illegal3 join is interrupted");
+        }
+        if (i == 2 && eCount == 1) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0174-rt-thread-ThreadConstructors12/expected.txt b/testsuite/java_test/thread_test/RT0174-rt-thread-ThreadConstructors12/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0174-rt-thread-ThreadConstructors12/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0174-rt-thread-ThreadConstructors12/test.cfg b/testsuite/java_test/thread_test/RT0174-rt-thread-ThreadConstructors12/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..73002692bf5d06f607cd86a64844f873968f460b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0174-rt-thread-ThreadConstructors12/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadConstructors12)
+run(ThreadConstructors12)
diff --git a/testsuite/java_test/thread_test/RT0175-rt-thread-MonitorTestCase1/MonitorTestCase1.java b/testsuite/java_test/thread_test/RT0175-rt-thread-MonitorTestCase1/MonitorTestCase1.java
new file mode 100755
index 0000000000000000000000000000000000000000..9287bfcb67714a209ad851a81cf63a0a99f91ed4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0175-rt-thread-MonitorTestCase1/MonitorTestCase1.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+public class MonitorTestCase1 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_SLEEP_TIME_DEFAULT = 1;
+    private static final String MODULE_NAME_MONITOR = "M";
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static List<Thread> mAllThread = new ArrayList<>();
+    public static void main(String[] args) {
+        testCase1();
+        Runtime.getRuntime().gc();
+        testCase1();
+        System.out.println(0);
+    }
+    public static void testCase1() {
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread thread;
+        Object lockObject = new Object();
+        for (int i = 0; i < DEFAULT_THREAD_NUM_HALF; i++) {
+            thread = new StopAbleThread(new MonitorTest(lockObject, THREAD_SLEEP_TIME_DEFAULT, THREAD_REPEATS_DEFAULT),
+                    MODULE_NAME_MONITOR + "_testCase1_" + i);
+            list.add(thread);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    static class MonitorTest implements Runnable {
+        Object lockObject;
+        int sleepTime;
+        int repeats;
+        public MonitorTest(Object lockObject, int sleepTime, int repeatTimes) {
+            this.lockObject = lockObject;
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+        }
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                synchronized (lockObject) {
+                    lockObject.toString();
+                    tryRest();
+                    trySleep(sleepTime);
+                    if (!mRunning) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0175-rt-thread-MonitorTestCase1/expected.txt b/testsuite/java_test/thread_test/RT0175-rt-thread-MonitorTestCase1/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0175-rt-thread-MonitorTestCase1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0175-rt-thread-MonitorTestCase1/test.cfg b/testsuite/java_test/thread_test/RT0175-rt-thread-MonitorTestCase1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f0d9f0034745073c79d69322d4f4eed65c9c7bca
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0175-rt-thread-MonitorTestCase1/test.cfg
@@ -0,0 +1,2 @@
+compile(MonitorTestCase1)
+run(MonitorTestCase1)
diff --git a/testsuite/java_test/thread_test/RT0176-rt-thread-MonitorTestCase2/MonitorTestCase2.java b/testsuite/java_test/thread_test/RT0176-rt-thread-MonitorTestCase2/MonitorTestCase2.java
new file mode 100755
index 0000000000000000000000000000000000000000..4f649d5ac663ecebd8a0bd4e45b4d949b23ffa5e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0176-rt-thread-MonitorTestCase2/MonitorTestCase2.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+public class MonitorTestCase2 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_SLEEP_TIME_DEFAULT = 1;
+    private static final String MODULE_NAME_MONITOR = "M";
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static List<Thread> mAllThread = new ArrayList<>();
+    public static void main(String[] args) {
+        testCase2();
+        Runtime.getRuntime().gc();
+        testCase2();
+        System.out.println("0");
+    }
+    public static void testCase2() {
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread t;
+        Object lockObject = new Object();
+        for (int i = 0; i < DEFAULT_THREAD_NUM_HALF; i++) {
+            t = new StopAbleThread(new MonitorTestWait(lockObject, THREAD_SLEEP_TIME_DEFAULT, THREAD_REPEATS_DEFAULT),
+                    MODULE_NAME_MONITOR + "_testCase2_" + i);
+            list.add(t);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    static class MonitorTest implements Runnable {
+        Object lockObject;
+        int sleepTime;
+        int repeats;
+        public MonitorTest(Object lockObject, int sleepTime) {
+            this(lockObject, sleepTime, THREAD_REPEATS_INFINITE);
+        }
+        public MonitorTest(Object lockObject, int sleepTime, int repeatTimes) {
+            this.lockObject = lockObject;
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+        }
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                synchronized (lockObject) {
+                    lockObject.toString();
+                    tryRest();
+                    trySleep(sleepTime);
+                    if (!mRunning) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    static class MonitorTestWait extends MonitorTest {
+        public MonitorTestWait(Object lockObject, int sleepTime, int repeatTimes) {
+            super(lockObject, sleepTime, repeatTimes);
+        }
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                if (!mRunning) {
+                    break;
+                }
+                synchronized (lockObject) {
+                    lockObject.toString();
+                    tryRest();
+                    try {
+                        lockObject.wait(sleepTime);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0176-rt-thread-MonitorTestCase2/expected.txt b/testsuite/java_test/thread_test/RT0176-rt-thread-MonitorTestCase2/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0176-rt-thread-MonitorTestCase2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0176-rt-thread-MonitorTestCase2/test.cfg b/testsuite/java_test/thread_test/RT0176-rt-thread-MonitorTestCase2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bbe51b421e34c88a2248f0b5fc0a1fd763978955
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0176-rt-thread-MonitorTestCase2/test.cfg
@@ -0,0 +1,2 @@
+compile(MonitorTestCase2)
+run(MonitorTestCase2)
diff --git a/testsuite/java_test/thread_test/RT0177-rt-thread-MonitorTestCase4/MonitorTestCase4.java b/testsuite/java_test/thread_test/RT0177-rt-thread-MonitorTestCase4/MonitorTestCase4.java
new file mode 100755
index 0000000000000000000000000000000000000000..e1620588b1d29a5b8fbbad8faff27cd2b2a46efa
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0177-rt-thread-MonitorTestCase4/MonitorTestCase4.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+public class MonitorTestCase4 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_SLEEP_TIME_DEFAULT = 1;
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    private static final String MODULE_NAME_MONITOR = "M";
+    static List<Thread> mAllThread = new ArrayList<>();
+    public static void main(String[] args) {
+        testCase4();
+        Runtime.getRuntime().gc();
+        testCase4();
+        System.out.println("0");
+    }
+    public static void testCase4() {
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread t1;
+        for (int i = 0; i < DEFAULT_THREAD_NUM_HALF; i++) {
+            t1 = new StopAbleThread(new CommonRun(mTestVolatileRun, THREAD_SLEEP_TIME_DEFAULT, THREAD_REPEATS_DEFAULT),
+                    MODULE_NAME_MONITOR + "_testCase4_" + i);
+            list.add(t1);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static Runnable mTestVolatileRun = new Runnable() {
+        @Override
+        public void run() {
+            for (int i = 0; i < 100; i++) {
+                tryRest();
+                Object testa = GetTestVolatile();
+                // Visit meta
+                if (testa instanceof Object) {
+                    continue;
+                }
+            }
+        }
+    };
+    public static volatile Object testVolatile = null;
+    private static Object GetTestVolatileImpl() {
+        if (testVolatile == null) {
+            testVolatile = new testVolatileClass();
+        }
+        return testVolatile;
+    }
+    static class testVolatileClass {
+        int a;
+    }
+    private static Object GetTestVolatile() {
+        return GetTestVolatileImpl();
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    static class CommonRun implements Runnable {
+        int sleepTime;
+        int repeats;
+        Runnable cbFun;
+        public CommonRun(Runnable cb, int sleepTime, int repeatTimes) {
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+            cbFun = cb;
+        }
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                tryRest();
+                if (cbFun != null) {
+                    cbFun.run();
+                }
+                trySleep(sleepTime);
+                if (!mRunning) {
+                    break;
+                }
+            }
+        }
+    }
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0177-rt-thread-MonitorTestCase4/expected.txt b/testsuite/java_test/thread_test/RT0177-rt-thread-MonitorTestCase4/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0177-rt-thread-MonitorTestCase4/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0177-rt-thread-MonitorTestCase4/test.cfg b/testsuite/java_test/thread_test/RT0177-rt-thread-MonitorTestCase4/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..092f572e5416a178fbce5b47f2fc1cc9f4f2a06e
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0177-rt-thread-MonitorTestCase4/test.cfg
@@ -0,0 +1,2 @@
+compile(MonitorTestCase4)
+run(MonitorTestCase4)
diff --git a/testsuite/java_test/thread_test/RT0178-rt-thread-MonitorTestCase5/MonitorTestCase5.java b/testsuite/java_test/thread_test/RT0178-rt-thread-MonitorTestCase5/MonitorTestCase5.java
new file mode 100755
index 0000000000000000000000000000000000000000..1ccc4b576fba18105bd75e11a61c038b2fb73f52
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0178-rt-thread-MonitorTestCase5/MonitorTestCase5.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+public class MonitorTestCase5 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_SLEEP_TIME_DEFAULT = 1;
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static final String MODULE_NAME_MONITOR = "M";
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    static List<Thread> mAllThread = new ArrayList<>();
+    public static void main(String[] args) {
+        testCase5();
+        Runtime.getRuntime().gc();
+        testCase5();
+        System.out.println("0");
+    }
+    public static void testCase5() {
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread t1;
+        for (int i = 0; i < DEFAULT_THREAD_NUM_HALF; i++) {
+            t1 = new StopAbleThread(new CommonRun(mTestVolatileRun, THREAD_SLEEP_TIME_DEFAULT, THREAD_REPEATS_DEFAULT),
+                    MODULE_NAME_MONITOR + "_testCase5_" + i);
+            list.add(t1);
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static Runnable mTestVolatileRun = new Runnable() {
+        @Override
+        public void run() {
+            for (int i = 0; i < 100; i++) {
+                tryRest();
+                Object testa = GetTestVolatile();
+                if (testa instanceof Object) {
+                    continue;
+                }
+            }
+        }
+    };
+    public static volatile Object testVolatile = null;
+    private static Object GetTestVolatileImpl() {
+        if (testVolatile == null) {
+            testVolatile = new testVolatileClass();
+        }
+        return testVolatile;
+    }
+    static class testVolatileClass {
+        // test class
+    }
+    private static Object GetTestVolatile() {
+        return GetTestVolatileImpl();
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    static class CommonRun implements Runnable {
+        int sleepTime;
+        int repeats;
+        Runnable cbFun;
+        public CommonRun(Runnable cb, int sleepTime, int repeatTimes) {
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+            cbFun = cb;
+        }
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                tryRest();
+                if (cbFun != null) {
+                    cbFun.run();
+                }
+                trySleep(sleepTime);
+                if (!mRunning) {
+                    break;
+                }
+            }
+        }
+    }
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0178-rt-thread-MonitorTestCase5/expected.txt b/testsuite/java_test/thread_test/RT0178-rt-thread-MonitorTestCase5/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0178-rt-thread-MonitorTestCase5/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0178-rt-thread-MonitorTestCase5/test.cfg b/testsuite/java_test/thread_test/RT0178-rt-thread-MonitorTestCase5/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5715aca7fc186816940c0553a2c62e9f16b23ca3
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0178-rt-thread-MonitorTestCase5/test.cfg
@@ -0,0 +1,2 @@
+compile(MonitorTestCase5)
+run(MonitorTestCase5)
diff --git a/testsuite/java_test/thread_test/RT0179-rt-thread-MonitorTestCase6/MonitorTestCase6.java b/testsuite/java_test/thread_test/RT0179-rt-thread-MonitorTestCase6/MonitorTestCase6.java
new file mode 100755
index 0000000000000000000000000000000000000000..ffaf5b6a7025450038339e78b78526f062b19644
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0179-rt-thread-MonitorTestCase6/MonitorTestCase6.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.util.Random;
+public class MonitorTestCase6 {
+    private static boolean quit = false;
+    private static final int INIT_DEFAULT_THREAD_NUM = 100;
+    private static int DEFAULT_THREAD_NUM = INIT_DEFAULT_THREAD_NUM;
+    private static final String MODULE_NAME_MONITOR = "M";
+    private static int monitorLengthForCase6 = DEFAULT_THREAD_NUM / 5;
+    private static boolean mRest = false;
+    private static int mRestTime = 5000;
+    public static void main(String[] args) {
+        testCase6();
+        Runtime.getRuntime().gc();
+        testCase6();
+        System.out.println("0");
+    }
+    public static void testCase6() {
+        quit = false;
+        ArrayList<monitorTestUnit> mList = createTestObject();
+        ArrayList<Thread> list = new ArrayList<>();
+        Thread t;
+        for (int i = 0; i < (DEFAULT_THREAD_NUM / 10); i++) {
+            t = new StopAbleThread(new SyncThread(mList), MODULE_NAME_MONITOR + "_testCase6_A" + i);
+            list.add(t);
+        }
+    }
+    public static class SyncThread implements Runnable {
+        private Random intRandom;
+        private ArrayList<monitorTestUnit> mList;
+        public SyncThread(ArrayList<monitorTestUnit> list) {
+            this.intRandom = new Random();
+            this.mList = list;
+        }
+        @Override
+        public void run() {
+            monitorTestUnit monitor;
+            int start;
+            int sleepTime;
+            for (int j = 0; j < 2000; j++) {
+                start = this.intRandom.nextInt(monitorLengthForCase6);
+                for (int k = 0; k < monitorLengthForCase6; k++) {
+                    monitor = mList.get((k + start) % monitorLengthForCase6);
+                    synchronized (monitor) {
+                        tryRest();
+                        monitor.testCount++;
+                        sleepTime = this.intRandom.nextInt(4) + 1;
+                        trySleep(sleepTime * 3);
+                    }
+                }
+                if (quit) {
+                    break;
+                }
+            }
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    public static ArrayList<monitorTestUnit> createTestObject() {
+        ArrayList<monitorTestUnit> mList = new ArrayList<>();
+        for (int i = 0; i < monitorLengthForCase6; i++) {
+            mList.add(new monitorTestUnit());
+        }
+        return mList;
+    }
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+    static class monitorTestUnit {
+        int testCount;
+        boolean isWait;
+        monitorTestUnit() {
+            testCount = 0;
+            isWait = false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0179-rt-thread-MonitorTestCase6/expected.txt b/testsuite/java_test/thread_test/RT0179-rt-thread-MonitorTestCase6/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0179-rt-thread-MonitorTestCase6/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0179-rt-thread-MonitorTestCase6/test.cfg b/testsuite/java_test/thread_test/RT0179-rt-thread-MonitorTestCase6/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ce3aadff548011199bc3b679421bb7c1ddf6a04d
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0179-rt-thread-MonitorTestCase6/test.cfg
@@ -0,0 +1,2 @@
+compile(MonitorTestCase6)
+run(MonitorTestCase6)
diff --git a/testsuite/java_test/thread_test/RT0180-rt-thread-MonitorTestCase8/MonitorTestCase8.java b/testsuite/java_test/thread_test/RT0180-rt-thread-MonitorTestCase8/MonitorTestCase8.java
new file mode 100755
index 0000000000000000000000000000000000000000..bca4a704eb305c37f5ad2ed8c26d4071b613af38
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0180-rt-thread-MonitorTestCase8/MonitorTestCase8.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+public class MonitorTestCase8 {
+    private static final int INIT_DEFAULT_THREAD_NUM = 10;
+    private static int DEFAULT_THREAD_NUM_HALF = INIT_DEFAULT_THREAD_NUM / 2;
+    private static final int THREAD_REPEATS_DEFAULT = 1;
+    private static final int THREAD_REPEATS_INFINITE = -1;
+    private static boolean mRunning = true;
+    private static boolean mRest = false;
+    private static int mRestTime = 500;
+    static List<Thread> mAllThread = new ArrayList<>();
+    public static void main(String[] args) {
+        testCase8();
+        Runtime.getRuntime().gc();
+        testCase8();
+        System.out.println("0");
+    }
+    public static void testCase8() {
+        List<Thread> list = new ArrayList<>();
+        List<String> stringList = new ArrayList<>();
+        for (int i = 0; i < (DEFAULT_THREAD_NUM_HALF / 2); i++) {
+            int index = i;
+            stringList.add("");
+            list.add(new StopAbleThread(new CommonRun(() -> {
+                ArrayList<String> strings = new ArrayList<>(100);
+                for (int j = 0; j < 100; j++) {
+                    strings.add(StringMethod.getStringRandom());
+                }
+                for (String str : strings) {
+                    stringList.set(index, stringList.get(index) + str);
+                }
+            }, 100, THREAD_REPEATS_DEFAULT), "testCase8_" + (i + 1)));
+        }
+        startAllThread(list);
+        waitAllThreadFinish(list);
+    }
+    public static void startAllThread(List<Thread> list) {
+        for (Thread s : list) {
+            s.start();
+            trySleep(new Random().nextInt(2));
+        }
+    }
+    public static void trySleep(long time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void waitAllThreadFinish(List<Thread> list) {
+        for (Thread s : list) {
+            try {
+                s.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                removeDeadThread(s);
+            }
+        }
+    }
+    public static void removeDeadThread(Thread t) {
+        if (t == null) {
+            return;
+        }
+        if (!t.isAlive()) {
+            synchronized (mAllThread) {
+                mAllThread.remove(t);
+            }
+        }
+    }
+    static class StopAbleThread extends Thread {
+        public StopAbleThread(Runnable r, String name) {
+            super(r, name);
+        }
+    }
+    static class CommonRun implements Runnable {
+        int sleepTime;
+        int repeats;
+        Runnable cbFun;
+        public CommonRun(Runnable cb, int sleepTime, int repeatTimes) {
+            this.sleepTime = sleepTime;
+            repeats = repeatTimes;
+            cbFun = cb;
+        }
+        @Override
+        public void run() {
+            while (THREAD_REPEATS_INFINITE == repeats || repeats > 0) {
+                if (repeats > 0) {
+                    repeats--;
+                }
+                tryRest();
+                if (cbFun != null) {
+                    cbFun.run();
+                }
+                trySleep(sleepTime);
+                if (!mRunning) {
+                    break;
+                }
+            }
+        }
+    }
+    private static boolean tryRest() {
+        if (mRest) {
+            trySleep(mRestTime);
+            return true;
+        }
+        return false;
+    }
+    private enum StringMethod {
+        METHOD0("DirectString") {
+            @Override
+            public String apply() {
+                return "DirectString";
+            }
+        },
+        METHOD1("ReferenceString") {
+            @Override
+            public String apply() {
+                return this.name;
+            }
+        },
+        METHOD2("FinalString") {
+            @Override
+            public String apply() {
+                return FINAL_STRING;
+            }
+        },
+        METHOD3("ConcatString") {
+            @Override
+            public String apply() {
+                return "Concat".concat("String");
+            }
+        },
+        METHOD4("StringAddition") {
+            @Override
+            public String apply() {
+                return "String" + "Addition" + 1;
+            }
+        },
+        METHOD5("CopyValueOf") {
+            @Override
+            public String apply() {
+                char[] tmp = {'C', 'o', 'p', 'y', 'V', 'a', 'l', 'u', 'e', 'O', 'f'};
+                return String.copyValueOf(tmp);
+            }
+        },
+        METHOD6("Intern") {
+            @Override
+            public String apply() {
+                return mRandom.toString().intern();
+            }
+        },
+        METHOD7("Integer") {
+            @Override
+            public String apply() {
+                return Integer.toString(mRandom.nextInt());
+            }
+        },
+        METHOD8("Float") {
+            @Override
+            public String apply() {
+                return Float.toString(mRandom.nextFloat());
+            }
+        },
+        METHOD9("Double") {
+            @Override
+            public String apply() {
+                return Double.toString(mRandom.nextDouble());
+            }
+        },
+        METHOD10("Boolean") {
+            @Override
+            public String apply() {
+                return Boolean.toString(mRandom.nextBoolean());
+            }
+        },
+        METHOD11("ReplaceChar") {
+            @Override
+            public String apply() {
+                return mRandom.toString().replace('R', 'r');
+            }
+        },
+        METHOD12("ReplaceString") {
+            @Override
+            public String apply() {
+                return mRandom.toString().replace("Ran", "RED");
+            }
+        },
+        METHOD13("Split") {
+            @Override
+            public String apply() {
+                return mRandom.toString().split("@")[0];
+            }
+        },
+        METHOD14("SubString") {
+            @Override
+            public String apply() {
+                return mRandom.toString().substring(3, 5);
+            }
+        },
+        METHOD15("ToLowerCase") {
+            @Override
+            public String apply() {
+                return mRandom.toString().toLowerCase();
+            }
+        },
+        METHOD16("ToUpperCase") {
+            @Override
+            public String apply() {
+                return mRandom.toString().toUpperCase();
+            }
+        },
+        METHOD17("StringBuffer") {
+            @Override
+            public String apply() {
+                return new StringBuffer("String").append("Buffer").append(1).toString();
+            }
+        },
+        METHOD18("StringBuilder") {
+            @Override
+            public String apply() {
+                return new StringBuilder(20).append(mRandom).toString();
+            }
+        },
+        METHOD19("subSequence") {
+            @Override
+            public String apply() {
+                return mRandom.toString().subSequence(1, 3).toString();
+            }
+        };
+        public final String name;
+        private static final String FINAL_STRING = "FinalString";
+        private static final Random mRandom = new Random();
+        StringMethod(String name) {
+            this.name = name;
+        }
+        public String apply() {
+            return name;
+        }
+        public static String getString(int id) {
+            if ((id < 0) || (id >= StringMethod.values().length)) {
+                return "";
+            } else {
+                return StringMethod.values()[id].apply();
+            }
+        }
+        public static String getStringRandom() {
+            return getString(mRandom.nextInt(StringMethod.values().length));
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0180-rt-thread-MonitorTestCase8/expected.txt b/testsuite/java_test/thread_test/RT0180-rt-thread-MonitorTestCase8/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0180-rt-thread-MonitorTestCase8/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0180-rt-thread-MonitorTestCase8/test.cfg b/testsuite/java_test/thread_test/RT0180-rt-thread-MonitorTestCase8/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..afee470ed2e1d7b3a6ed77ebc9d0cda5ba7b4293
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0180-rt-thread-MonitorTestCase8/test.cfg
@@ -0,0 +1,2 @@
+compile(MonitorTestCase8)
+run(MonitorTestCase8)
diff --git a/testsuite/java_test/thread_test/RT0181-rt-thread-ThreadCountStackFrames/ThreadCountStackFrames.java b/testsuite/java_test/thread_test/RT0181-rt-thread-ThreadCountStackFrames/ThreadCountStackFrames.java
new file mode 100755
index 0000000000000000000000000000000000000000..f92bdf4fa27ced1f4c7c5d7bd8f3707eced74ef6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0181-rt-thread-ThreadCountStackFrames/ThreadCountStackFrames.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadCountStackFrames {
+    static int threadFinish = 0;
+    public static void main(String[] args) {
+        int result = 2;
+        Thread thread = new Thread("ThreadCountStackFrames") {
+            public void run() {
+                try{
+                    sleep(1000);
+                }catch(Exception e) {
+                    System.out.println(e);
+                }
+                ThreadCountStackFrames.threadFinish++;
+            }
+        };
+        // Before the thread started.
+        if (thread.countStackFrames() == 0 && thread.getStackTrace().length == 0) {
+            result--;
+        }
+        thread.start();
+        try{
+            thread.join();
+        }catch(Exception e) {
+            System.out.println(e);
+        }
+        // After a thread finished.
+        if (thread.countStackFrames() == 0 && thread.getStackTrace().length == 0
+                && ThreadCountStackFrames.threadFinish == 1) {
+            result--;
+        }
+        System.out.println(result);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0181-rt-thread-ThreadCountStackFrames/expected.txt b/testsuite/java_test/thread_test/RT0181-rt-thread-ThreadCountStackFrames/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0181-rt-thread-ThreadCountStackFrames/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0181-rt-thread-ThreadCountStackFrames/test.cfg b/testsuite/java_test/thread_test/RT0181-rt-thread-ThreadCountStackFrames/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6e591a4145d2b1a3634506349075cb068cd03801
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0181-rt-thread-ThreadCountStackFrames/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadCountStackFrames)
+run(ThreadCountStackFrames)
diff --git a/testsuite/java_test/thread_test/RT0182-rt-thread-ThreadDMdestory2/ThreadDMdestory2.java b/testsuite/java_test/thread_test/RT0182-rt-thread-ThreadDMdestory2/ThreadDMdestory2.java
new file mode 100755
index 0000000000000000000000000000000000000000..23524780579d2f0fdf0d73566ee8b8e0da3a0a5f
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0182-rt-thread-ThreadDMdestory2/ThreadDMdestory2.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadDMdestory2 {
+    public static void main(String[] args) {
+        System.out.println(run());
+    }
+    private static int run() {
+        int exceptionCount = 0;
+        // destroy001: test destroy() when the thread is not started
+        try {
+            new Thread().destroy();
+            return 1;
+        } catch (UnsupportedOperationException ok) {
+            exceptionCount++;
+        }
+        // destroy002: test destroy() when the thread is finished
+        Thread thread = new Thread();
+        thread.start();
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            System.out.println(e);
+        }
+        try {
+            thread.destroy();
+            return 2;
+        } catch (UnsupportedOperationException ok) {
+            exceptionCount++;
+        }
+        // destroy003: test destroy() when a thread is sleeping
+        SleepingThread st = new SleepingThread();
+        st.start();
+        while (! st.started){
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                // ignore any attempt to interrupt
+                System.out.println(e);
+            }
+        }
+        try {
+            st.destroy();
+            return 3;
+        } catch (UnsupportedOperationException ok) {
+            exceptionCount++;
+        }
+        st.checked=true;
+        if (exceptionCount == 3) {
+            return 0;
+        }else{
+            return 4;
+        }
+    }
+}
+class SleepingThread extends Thread {
+    public volatile boolean started = false;
+    public volatile boolean checked = false;
+    public void run() {
+        started = true;
+        while (! checked){
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                // ignore any attempt to interrupt
+                System.out.println(e);
+            }
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0182-rt-thread-ThreadDMdestory2/expected.txt b/testsuite/java_test/thread_test/RT0182-rt-thread-ThreadDMdestory2/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0182-rt-thread-ThreadDMdestory2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0182-rt-thread-ThreadDMdestory2/test.cfg b/testsuite/java_test/thread_test/RT0182-rt-thread-ThreadDMdestory2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cf2f427b84a86cb34d6e324d60a5ac3402adbe41
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0182-rt-thread-ThreadDMdestory2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadDMdestory2)
+run(ThreadDMdestory2)
diff --git a/testsuite/java_test/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/ThreadGetContextClassLoader.java b/testsuite/java_test/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/ThreadGetContextClassLoader.java
new file mode 100755
index 0000000000000000000000000000000000000000..7c2fd103a64270a73936e1dc029e1b7c2d0e47f4
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/ThreadGetContextClassLoader.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadGetContextClassLoader {
+    public static void main(String[] args) {
+        Thread thr = new Thread();
+        try {
+            // If not set, the default is the ClassLoader context of the parent Thread.
+            if(thr.getContextClassLoader() != Thread.currentThread().getContextClassLoader()) {
+                System.out.println(2);
+            }
+        } finally {
+            thr.start();
+            try {
+                thr.join();
+            } catch(InterruptedException e) {
+                System.out.println("Join is interrupted");
+            }
+        }
+        System.out.println(0);
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/expected.txt b/testsuite/java_test/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/test.cfg b/testsuite/java_test/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2c5f2aacd0e7d4988ef89b4aa9b150ac83665347
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0183-rt-thread-ThreadGetContextClassLoader/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadGetContextClassLoader)
+run(ThreadGetContextClassLoader)
diff --git a/testsuite/java_test/thread_test/RT0184-rt-thread-DoubleSynchronized/DoubleSynchronized.java b/testsuite/java_test/thread_test/RT0184-rt-thread-DoubleSynchronized/DoubleSynchronized.java
new file mode 100644
index 0000000000000000000000000000000000000000..61e6a0aebe71dfef102bd3e9fd8d48b88b4ef122
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0184-rt-thread-DoubleSynchronized/DoubleSynchronized.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class DoubleSynchronized {
+    private byte[] test = new byte[0];
+    private int[] test2 = new int[0];
+    private String string = null;
+    public void test () {
+        try {
+            synchronized(test) {
+                System.out.println(string.length());
+            }
+            synchronized(test2) {
+                System.out.println(string.length());
+            }
+        } catch (NullPointerException e) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+    }
+    public static void main(String [] args) {
+        new DoubleSynchronized().test();
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0184-rt-thread-DoubleSynchronized/expected.txt b/testsuite/java_test/thread_test/RT0184-rt-thread-DoubleSynchronized/expected.txt
new file mode 100755
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0184-rt-thread-DoubleSynchronized/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0184-rt-thread-DoubleSynchronized/test.cfg b/testsuite/java_test/thread_test/RT0184-rt-thread-DoubleSynchronized/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..858049651064d7a9e66e5c3a4b51b5d0b1f37ea6
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0184-rt-thread-DoubleSynchronized/test.cfg
@@ -0,0 +1,2 @@
+compile(DoubleSynchronized)
+run(DoubleSynchronized)
diff --git a/testsuite/java_test/thread_test/RT0185-rt-thread-GenerifyStackTraces2/GenerifyStackTraces.java b/testsuite/java_test/thread_test/RT0185-rt-thread-GenerifyStackTraces2/GenerifyStackTraces.java
new file mode 100644
index 0000000000000000000000000000000000000000..b22c77a517951b33bb8a28ff84b224e27abfeb73
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0185-rt-thread-GenerifyStackTraces2/GenerifyStackTraces.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Map;
+public class GenerifyStackTraces {
+    private static Object go = new Object();
+    private static String[] methodNames = {"run", "A", "B", "C", "Done"};
+    private static int DONE_DEPTH = 5;
+    private static boolean testFailed = false;
+    private static Thread one;
+    private static boolean trace = false;
+    public static void main(String[] args) throws Exception {
+        if (args.length > 0 && args[0].equals("trace")) {
+            trace = true;
+        }
+        one = new ThreadOne();
+        one.start();
+        DumpThread dt = new DumpThread();
+        dt.start();
+        try {
+            one.join();
+        } finally {
+            dt.shutdown();
+        }
+        if (testFailed) {
+            throw new RuntimeException("Test Failed.");
+        }
+    }
+    static class DumpThread extends Thread {
+        private volatile boolean finished = false;
+        public void run() {
+            int depth = 2;
+            while (!finished) {
+                // At each iterator, wait until ThreadOne blocks to wait for thread dump.
+                // Then dump stack trace and notify ThreadOne to continue.
+                try {
+                    sleep(2000);
+                    dumpStacks(depth);
+                    depth++;
+                    finishDump();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    testFailed = true;
+                }
+            }
+        }
+        public void shutdown() throws InterruptedException {
+            finished = true;
+            this.join();
+        }
+    }
+    static class ThreadOne extends Thread {
+        public void run() {
+	    System.out.println(0);
+            A();
+        }
+        private void A() {
+            waitForDump();
+            B();
+        }
+        private void B() {
+            waitForDump();
+            C();
+        }
+        private void C() {
+            waitForDump();
+            Done();
+        }
+        private void Done() {
+            waitForDump();
+            // Get stack trace of current thread
+            StackTraceElement[] stack = getStackTrace();
+            try {
+                checkStack(this, stack, DONE_DEPTH);
+            } catch (Exception e) {
+                e.printStackTrace();
+                testFailed = true;
+            }
+        }
+    }
+    static private void waitForDump() {
+        synchronized(go) {
+            try {
+               go.wait();
+            } catch (Exception e) {
+               throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+    static private void finishDump() {
+        synchronized(go) {
+            try {
+               go.notifyAll();
+            } catch (Exception e) {
+               throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+    public static void dumpStacks(int depth) throws Exception {
+        // Get stack trace of another thread
+        StackTraceElement[] stack = one.getStackTrace();
+        checkStack(one, stack, depth);
+        // Get stack traces of all Threads
+        for (Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
+            Thread t = entry.getKey();
+            stack = entry.getValue();
+            if (t == null || stack == null) {
+                throw new RuntimeException("Null thread or stacktrace returned");
+            }
+            if (t == one) {
+                checkStack(t, stack, depth);
+            }
+        }
+    }
+    private static void checkStack(Thread t, StackTraceElement[] stack, int depth) throws Exception {
+        if (trace) {
+            printStack(t, stack);
+        }
+        int frame = stack.length - 1;
+        for (int i = 0; i < depth && frame >= 0; i++) {
+            if (! stack[frame].getMethodName().equals(methodNames[i])) {
+                throw new RuntimeException("Expected " + methodNames[i] + " in frame " + frame + " but got " +
+                                           stack[frame].getMethodName());
+            }
+            frame--;
+        }
+    }
+    private static void printStack(Thread t, StackTraceElement[] stack) {
+        System.out.println(t + " stack: (length = " + stack.length + ")");
+        if (t != null) {
+            for (int j = 0; j < stack.length; j++) {
+                System.out.println(stack[j]);
+            }
+            System.out.println();
+        }
+    }
+}
+// EXEC:%maple  GenerifyStackTraces.java -p %platform %build_option -o %n.so
+// EXEC:%run -b %host -l %username -p %port --run_type %run_type --sn %sn  %n.so GenerifyStackTraces  %mplsh_option| compare %f
+// ASSERT: scan 0\n
diff --git a/testsuite/java_test/thread_test/RT0185-rt-thread-GenerifyStackTraces2/expected.txt b/testsuite/java_test/thread_test/RT0185-rt-thread-GenerifyStackTraces2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0185-rt-thread-GenerifyStackTraces2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0185-rt-thread-GenerifyStackTraces2/test.cfg b/testsuite/java_test/thread_test/RT0185-rt-thread-GenerifyStackTraces2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..28a8720349f2290a3d8e19208c6193f22dbe6bac
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0185-rt-thread-GenerifyStackTraces2/test.cfg
@@ -0,0 +1,2 @@
+compile(GenerifyStackTraces)
+run(GenerifyStackTraces)
diff --git a/testsuite/java_test/thread_test/RT0186-rt-thread-GenerifyAllStackTraces/GenerifyAllStackTraces.java b/testsuite/java_test/thread_test/RT0186-rt-thread-GenerifyAllStackTraces/GenerifyAllStackTraces.java
new file mode 100644
index 0000000000000000000000000000000000000000..2682ff31cd2c821acf38a0af663bd26767de3c62
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0186-rt-thread-GenerifyAllStackTraces/GenerifyAllStackTraces.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Map;
+public class GenerifyAllStackTraces {
+    private static Object go = new Object();
+    private static String[] methodNames = {"run", "A", "B", "C", "Done"};
+    private static int DONE_DEPTH = 5;
+    private static boolean testFailed = false;
+    private static Thread one;
+    private static Thread two;
+    private static boolean trace = false;
+    public static void main(String[] args) throws Exception {
+        if (args.length > 0 && args[0].equals("trace")) {
+            trace = true;
+        }
+        one = new ThreadOne();
+        two = new ThreadTwo();
+        one.start();
+        two.start();
+        DumpThread dt = new DumpThread();
+        dt.start();
+        try {
+            one.join();
+            two.join();
+        } finally {
+            dt.shutdown();
+        }
+        if (testFailed) {
+            throw new RuntimeException("Test Failed.");
+        }
+    }
+    static class DumpThread extends Thread {
+        private volatile boolean finished = false;
+        @Override
+        public void run() {
+            int depth = 2;
+            while (!finished) {
+                // At each iterator, wait until ThreadOne blocks to wait for thread dump.
+                // Then dump stack trace and notify ThreadOne to continue.
+                try {
+                    sleep(2000);
+                    dumpStacks(depth);
+                    depth++;
+                    finishDump();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    testFailed = true;
+                }
+            }
+        }
+        public void shutdown() throws InterruptedException {
+            finished = true;
+            join();
+        }
+    }
+    static class ThreadOne extends Thread {
+        @Override
+        public void run() {
+            System.out.println(0);
+            A();
+        }
+        private void A() {
+            waitForDump();
+            B();
+        }
+        private void B() {
+            waitForDump();
+            C();
+        }
+        private void C() {
+            waitForDump();
+            Done();
+        }
+        private void Done() {
+            waitForDump();
+            // Get stack trace of current thread
+            StackTraceElement[] stack = getStackTrace();
+            try {
+                checkStack(this, stack, DONE_DEPTH);
+            } catch (Exception e) {
+                e.printStackTrace();
+                testFailed = true;
+            }
+        }
+    }
+    static class ThreadTwo extends Thread {
+        @Override
+        public void run() {
+            System.out.println(0);
+            A();
+        }
+        private void A() {
+            waitForDump();
+            B();
+        }
+        private void B() {
+            waitForDump();
+            C();
+        }
+        private void C() {
+            waitForDump();
+            Done();
+        }
+        private void Done() {
+            waitForDump();
+            // Get stack trace of current thread
+            StackTraceElement[] stack = getStackTrace();
+            try {
+                checkStack(this, stack, DONE_DEPTH);
+            } catch (Exception e) {
+                e.printStackTrace();
+                testFailed = true;
+            }
+        }
+    }
+    static private void waitForDump() {
+        synchronized (go) {
+            try {
+                go.wait();
+            } catch (Exception e) {
+                throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+    static private void finishDump() {
+        synchronized (go) {
+            try {
+                go.notifyAll();
+            } catch (Exception e) {
+                throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+    public static void dumpStacks(int depth) throws Exception {
+        // Get stack trace of another thread
+        StackTraceElement[] stack = one.getStackTrace();
+        StackTraceElement[] stacks = two.getStackTrace();
+        checkStack(one, stack, depth);
+        checkStack(two, stacks, depth);
+        // Get stack traces of all Threads
+        for (Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
+            Thread t = entry.getKey();
+            stack = entry.getValue();
+            if (t == null || stack == null) {
+                throw new RuntimeException("Null thread or stacktrace returned");
+            }
+            if (t == one) {
+                checkStack(t, stack, depth);
+            }
+            if (t == two) {
+                checkStack(t, stacks, depth);
+            }
+        }
+    }
+    private static void checkStack(Thread t, StackTraceElement[] stack, int depth) throws Exception {
+        if (trace) {
+            printStack(t, stack);
+        }
+        int frame = stack.length - 1;
+        for (int i = 0; i < depth && frame >= 0; i++) {
+            if (!stack[frame].getMethodName().equals(methodNames[i])) {
+                throw new RuntimeException("Expected " + methodNames[i] + " in frame " + frame + " but got " +
+                        stack[frame].getMethodName());
+            }
+            frame--;
+        }
+    }
+    private static void printStack(Thread t, StackTraceElement[] stack) {
+        System.out.println(t + " stack: (length = " + stack.length + ")");
+        if (t != null) {
+            for (int j = 0; j < stack.length; j++) {
+                System.out.println(stack[j]);
+            }
+            System.out.println();
+        }
+    }
+}
+// EXEC:%maple  GenerifyAllStackTraces.java -p %platform %build_option -o %n.so
+// EXEC:%run -b %host -l %username -p %port --run_type %run_type --sn %sn  %n.so GenerifyAllStackTraces  %mplsh_option| compare %f
+// ASSERT: scan 0\n0\n
diff --git a/testsuite/java_test/thread_test/RT0186-rt-thread-GenerifyAllStackTraces/expected.txt b/testsuite/java_test/thread_test/RT0186-rt-thread-GenerifyAllStackTraces/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aa47d0d46d47a06090f436b0b851b76bb6f3b6e2
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0186-rt-thread-GenerifyAllStackTraces/expected.txt
@@ -0,0 +1,2 @@
+0
+0
diff --git a/testsuite/java_test/thread_test/RT0186-rt-thread-GenerifyAllStackTraces/test.cfg b/testsuite/java_test/thread_test/RT0186-rt-thread-GenerifyAllStackTraces/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a2a6662a261cc0827441d1ad1524f5dc7b671dfe
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0186-rt-thread-GenerifyAllStackTraces/test.cfg
@@ -0,0 +1,2 @@
+compile(GenerifyAllStackTraces)
+run(GenerifyAllStackTraces)
diff --git a/testsuite/java_test/thread_test/RT0187-rt-thread-getAllStackTraces-NullStackTrace/NullStackTrace.java b/testsuite/java_test/thread_test/RT0187-rt-thread-getAllStackTraces-NullStackTrace/NullStackTrace.java
new file mode 100644
index 0000000000000000000000000000000000000000..784a318d4cb6a940c7718a8ea778f977dc6268d8
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0187-rt-thread-getAllStackTraces-NullStackTrace/NullStackTrace.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Map;
+public class NullStackTrace extends Thread {
+    static final int TIMES = 500;
+    public static void main(String[] args) {
+        for (int i = 0; i < TIMES; i++) {
+            Thread t = new Thread();
+            t.start();
+            Map m = getAllStackTraces();
+            String stFinish = m.keySet().toString();
+            if (stFinish == null)
+                throw new RuntimeException("Failed: Thread.getAllStackTrace should not return null");
+        }
+        System.out.println("0");
+    }
+}
+// EXEC:%maple  NullStackTrace.java -p %platform %build_option -o %n.so
+// EXEC:%run -b %host -l %username -p %port --run_type %run_type --sn %sn  %n.so NullStackTrace  %mplsh_option | compare %f
+// ASSERT: scan 0\n
diff --git a/testsuite/java_test/thread_test/RT0187-rt-thread-getAllStackTraces-NullStackTrace/expected.txt b/testsuite/java_test/thread_test/RT0187-rt-thread-getAllStackTraces-NullStackTrace/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0187-rt-thread-getAllStackTraces-NullStackTrace/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0187-rt-thread-getAllStackTraces-NullStackTrace/test.cfg b/testsuite/java_test/thread_test/RT0187-rt-thread-getAllStackTraces-NullStackTrace/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..043bbf7d18d057b5b6408e2455745e19679d3e44
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0187-rt-thread-getAllStackTraces-NullStackTrace/test.cfg
@@ -0,0 +1,2 @@
+compile(NullStackTrace)
+run(NullStackTrace)
diff --git a/testsuite/java_test/thread_test/RT0188-rt-thread-GetStackTraceIterating/GetStackTraceIterating.java b/testsuite/java_test/thread_test/RT0188-rt-thread-GetStackTraceIterating/GetStackTraceIterating.java
new file mode 100644
index 0000000000000000000000000000000000000000..918c247995d0379ec2992ec54daa5c0d8bf94d52
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0188-rt-thread-GetStackTraceIterating/GetStackTraceIterating.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class GetStackTraceIterating {
+    static final int limit = 100;
+    public int rec(int i) throws Exception {
+        if (i == limit) {
+            throw new Exception();
+        } else {
+            return rec(i + 1);
+        }
+    }
+    public void run(int reps) {
+        int sum = 0;
+        for (int i = 0; i < reps; i++) {
+            try {
+                sum += rec(1);
+            } catch (Exception e) {
+                boolean unexpected = false;
+                StackTraceElement[] stackTrace = e.getStackTrace();
+                for (StackTraceElement trace : stackTrace) {
+                    String message = trace.getFileName();
+                    if (message.contains("GetStackTraceIterating")) {
+                        unexpected = false;
+                    } else {
+                        unexpected = true;
+                    }
+                    if (unexpected) {
+                        System.out.println(message);
+                    }
+                }
+            }
+        }
+    }
+    public static void main(String[] args) {
+        GetStackTraceIterating obj = new GetStackTraceIterating();
+        obj.run(100);
+        System.out.println(0);
+    }
+}
+// EXEC:%maple  GetStackTraceIterating.java -p %platform %build_option -o %n.so
+// EXEC:%run -b %host -l %username -p %port --run_type %run_type --sn %sn  %n.so GetStackTraceIterating  %mplsh_option | compare %f
+// ASSERT: scan 0\n
diff --git a/testsuite/java_test/thread_test/RT0188-rt-thread-GetStackTraceIterating/expected.txt b/testsuite/java_test/thread_test/RT0188-rt-thread-GetStackTraceIterating/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0188-rt-thread-GetStackTraceIterating/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/RT0188-rt-thread-GetStackTraceIterating/test.cfg b/testsuite/java_test/thread_test/RT0188-rt-thread-GetStackTraceIterating/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1fa73a3009356096ae2063eabdad6cecd9eeb8f8
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0188-rt-thread-GetStackTraceIterating/test.cfg
@@ -0,0 +1,2 @@
+compile(GetStackTraceIterating)
+run(GetStackTraceIterating)
diff --git a/testsuite/java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating/GetAllStackTraceIterating.java b/testsuite/java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating/GetAllStackTraceIterating.java
new file mode 100644
index 0000000000000000000000000000000000000000..dcf38a29b1a1790598387312d9ebda2b42707c11
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating/GetAllStackTraceIterating.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Map;
+public class GetAllStackTraceIterating extends Thread {
+    private static String[] methodNames = {"run", "A", "B", "C", "Done"};
+    private static Object obj = new Object();
+    private static Thread[] tt = new Thread[5];
+    public static void main(String[] args) throws InterruptedException {
+        int result1 = 1; /* STATUS_FAILED*/
+
+        Map map = getAllStackTraces();
+        String stOrigin = map.keySet().toString();
+        int sizeOrigin = map.size();
+        for (int i = 0; i < tt.length; i++) {
+            tt[i] = new ThreadOne();
+        }
+        for (int i = 0; i < tt.length; i++) {
+            tt[i].start();
+            map = getAllStackTraces();
+            String stRun = map.keySet().toString();
+            int sizeRun = map.size();
+            if ((sizeRun - sizeOrigin) == 5 && stRun.contains("main")) {
+                result1--;
+            }
+        }
+        for (int i = 0; i < tt.length; i++) {
+            try {
+                tt[i].join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        System.out.println(result1);
+    }
+    static class ThreadOne extends Thread {
+        @Override
+        public void run() {
+            System.out.println("0");
+            A();
+        }
+        private void A() {
+            waitForDump();
+            B();
+        }
+        private void B() {
+            waitForDump();
+            C();
+        }
+        private void C() {
+            waitForDump();
+            Done();
+        }
+        private void Done() {
+            waitForDump();
+        }
+    }
+    static private void waitForDump() {
+        synchronized (obj) {
+            try {
+                obj.wait(200);
+            } catch (InterruptedException e) {
+                System.out.println("wait is interrupted");
+            }
+        }
+    }
+}
+// EXEC:%maple  GetAllStackTraceIterating.java -p %platform %build_option -o %n.so
+// EXEC:%run -b %host -l %username -p %port --run_type %run_type --sn %sn  %n.so GetAllStackTraceIterating  %mplsh_option | compare %f
+// ASSERT: scan 0\n0\n0\n0\n0\n0\n
diff --git a/testsuite/java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating/expected.txt b/testsuite/java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f7eb44d66e0b1381ff97765ac0fc0314dabae001
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating/expected.txt
@@ -0,0 +1,6 @@
+0
+0
+0
+0
+0
+0
diff --git a/testsuite/java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating/test.cfg b/testsuite/java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..053506ff40e8e2dce8ef8f9d1f0217e05991d961
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0189-rt-thread-GetAllStackTraceIterating/test.cfg
@@ -0,0 +1,2 @@
+compile(GetAllStackTraceIterating)
+run(GetAllStackTraceIterating)
diff --git a/testsuite/java_test/thread_test/RT0200-rt-thread-TestSynchronized/TestSynchronized.java b/testsuite/java_test/thread_test/RT0200-rt-thread-TestSynchronized/TestSynchronized.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a4fbc5e02429807031f0779c2fa1233d4a703b1
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0200-rt-thread-TestSynchronized/TestSynchronized.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.lang.Thread;
+class Offset {
+    int[] offsets = null;
+    public void setOffsets(int[] newOne) {
+        offsets = newOne;
+    }
+    public void clear() {
+        offsets = null;
+    }
+}
+public class TestSynchronized {
+    public static Object obj = new Object();
+    public static Offset getOffset() {
+        int[] off = {-4, -5, -6, -7};
+        Offset ret = new Offset();
+        ret.setOffsets(off);
+        if (ret.offsets.length < 8) {
+            ret = null;
+        }
+        return ret;
+    }
+    public static int[] getCurLength() {
+        synchronized (obj) {
+            int[] off1 = {-1, -1, -1, -1};
+            Offset o = getOffset();
+            if (off1.length > 5) {
+                int[] off2 = {9, 9, 9};
+                if (off2.length == o.offsets.length) {
+                    for (int i = 0; i < o.offsets.length; i++) {
+                        o.offsets[i] = off2[i];
+                    }
+                }
+            }
+            System.arraycopy(o.offsets, 0, off1, 0, o.offsets.length);
+            return off1;
+        }
+    }
+    public static void main(String args[]) {
+        try {
+            getCurLength();
+            Thread.sleep(2000);
+        } catch (NullPointerException e) {
+            System.out.println("Pass");
+        } catch (InterruptedException e1) {}
+        Thread t = new Thread(new Runnable() {
+            public void run() {
+                synchronized (obj) {
+                    System.out.println("Pass");
+                }
+            }
+        });
+        t.setDaemon(true);
+        t.start();
+    }
+}
diff --git a/testsuite/java_test/thread_test/RT0200-rt-thread-TestSynchronized/expected.txt b/testsuite/java_test/thread_test/RT0200-rt-thread-TestSynchronized/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..93ed52718b7bc478c1d8f76a5c60aefedb280a38
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0200-rt-thread-TestSynchronized/expected.txt
@@ -0,0 +1,2 @@
+Pass
+Pass
diff --git a/testsuite/java_test/thread_test/RT0200-rt-thread-TestSynchronized/test.cfg b/testsuite/java_test/thread_test/RT0200-rt-thread-TestSynchronized/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..266077408302d68a655b923eaf2f0766a69dda7b
--- /dev/null
+++ b/testsuite/java_test/thread_test/RT0200-rt-thread-TestSynchronized/test.cfg
@@ -0,0 +1,2 @@
+compile(TestSynchronized)
+run(TestSynchronized)
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/ThreadOutOfMemoryTest.java b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/ThreadOutOfMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..01aad9f29b7aded9f13590645aafde89b7a5b1e6
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/ThreadOutOfMemoryTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadOutOfMemoryTest {
+    public static final int NTHREADS = 5;
+    public static final int TIMEOUT = 10;
+    public static final int LEVEL1_SIZE = 1048576;
+    public static final int LEVEL2_INIT_SIZE = 1048576;
+    public static void memoryBuster() {
+        int[][] root = new int[LEVEL1_SIZE][];
+        int size = LEVEL2_INIT_SIZE; // 1M
+        // If we repeat this, it may consume up to 1M * 2G * 4B = 8PB of memory
+        for (int i = 0; i < LEVEL1_SIZE; i++) {
+            int[] level2 = new int[size];
+            root[i] = level2;
+            if (size < Integer.MAX_VALUE / 2) {
+                size = size * 2;
+            } else {
+                size = Integer.MAX_VALUE;
+            }
+        }
+    }
+    public static void main(String[] args) throws Exception {
+        Thread[] childThreads = new Thread[NTHREADS];
+        final boolean[] caught = new boolean[NTHREADS];
+        for (int i = 0; i < NTHREADS; i++) {
+            final int threadIndex = i;
+            childThreads[threadIndex] = new Thread(() -> {
+                try {
+                    memoryBuster();
+                } catch (OutOfMemoryError e) {
+                    caught[threadIndex] = true;
+                }
+            }, "Thread-" + threadIndex);
+        }
+        for (Thread thread : childThreads) {
+            thread.start();
+        }
+        for (Thread thread : childThreads) {
+            thread.join();
+        }
+        for (int i = 0; i < NTHREADS; i++) {
+            if (!caught[i]) {
+                System.out.printf("ERROR: Thread %d did not catch OutOfMemoryException.%n", i);
+            }
+        }
+        System.out.println("DONE");
+    }
+}
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/expected.txt b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c8e8a135c9291129f28f1fcaa018fa29a7cc96fe
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/expected.txt
@@ -0,0 +1 @@
+DONE
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/test.cfg b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cdc568435a99f32204c1ca9378d38eeb0c417a1c
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadOutofmemory/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadOutOfMemoryTest)
+run(ThreadOutOfMemoryTest)
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadStatejoin10/ThreadStateJoin10Test.java b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadStatejoin10/ThreadStateJoin10Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..968e6f85be66480c55e57567369946a774b3715e
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadStatejoin10/ThreadStateJoin10Test.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateJoin10Test extends Thread {
+    public void run() {
+        synchronized (currentThread()) {
+            for (int i = 1; i <= 10000; i++) {
+                try {
+                    sleep(0);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+    public static void main(String[] args) {
+        long startTime;
+        long endTime;
+        ThreadStateJoin10Test cls = new ThreadStateJoin10Test();
+        cls.start();
+        startTime = System.currentTimeMillis();
+        try {
+            cls.join(600);
+        } catch (InterruptedException e1) {
+            System.out.println("Join is interrupted");
+        }
+        endTime = System.currentTimeMillis();
+        if (endTime-startTime >= 0 && endTime-startTime < 30) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+        return;
+    }
+}
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadStatejoin10/expected.txt b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadStatejoin10/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadStatejoin10/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadStatejoin10/test.cfg b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadStatejoin10/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..202f2bb927a7d55b214fbdeed02e2474637f9a4a
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-ThreadStatejoin10/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateJoin10Test.java)
+run(ThreadStateJoin10Test)
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance/ThreadPerformanceTest.java b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance/ThreadPerformanceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..51e76c40f8595fac741732b5210b51d79b67349a
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance/ThreadPerformanceTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadPerformanceTest extends Thread {
+    public static void main(String[] args) {
+        long startTime;
+        long endTime;
+        Object obj = "aa";
+        long sum=0;
+        long ave;
+        long[] ThreadPerformanceTest = new long[20];
+        Thread[] tt = new Thread[10000];
+        for (int ii = 0; ii < ThreadPerformanceTest.length; ii++) {
+            for (int i = 0; i < tt.length; i++) {
+                tt[i] = new Thread() {
+                    public void run() {
+                        synchronized (obj) {
+                            try {
+                                obj.wait(10);
+                            } catch (InterruptedException e) {
+                                System.out.println("wait is interrupted");
+                            }
+                        }
+                    }
+                };
+            }
+            startTime = System.currentTimeMillis();
+            for (int i = 0; i < tt.length; i++) {
+                tt[i].start();
+            }
+            for (int i = 0; i < tt.length; i++) {
+                try {
+                    tt[i].join();
+                } catch (InterruptedException e) {
+                    System.err.println(e);
+                }
+            }
+            endTime = System.currentTimeMillis();
+            ThreadPerformanceTest[ii] = endTime - startTime;
+        }
+        for(int ii = 0; ii < ThreadPerformanceTest.length; ii++) {
+            sum += ThreadPerformanceTest[ii];
+        }
+        ave = sum / ThreadPerformanceTest.length;
+        if(ave < 6000) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance/expected.txt b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance/test.cfg b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..80bcbd6e9b9d1a6251f8a3dda7ca9728036b18a7
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadPerformanceTest.java)
+run(ThreadPerformanceTest)
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance3/ThreadPerformance3Test.java b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance3/ThreadPerformance3Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1e1294fc8dfd10600dbcf13de38452201731b96
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance3/ThreadPerformance3Test.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadPerformance3Test extends Thread {
+    public static void main(String[] args) {
+        long startTime;
+        long endTime;
+        Object obj = "aa";
+        long sum = 0;
+        long ave;
+        long[] ThreadPerformance3Test = new long[20];
+        Thread[] tt = new Thread[5000];
+        for (int ii = 0; ii < ThreadPerformance3Test.length; ii++) {
+            for (int i = 0; i < tt.length; i++) {
+                tt[i] = new Thread() {
+                    public void run() {
+                        synchronized (obj) {
+                            try {
+                                obj.wait();
+                            } catch (InterruptedException e1) {
+                            }
+                        }
+                    }
+                };
+            }
+            startTime = System.currentTimeMillis();
+            for (int i = 0; i < tt.length; i++) {
+                tt[i].start();
+            }
+            for (int i = 0; i < tt.length; i++) {
+                tt[i].interrupt();
+            }
+            for (int i = 0; i < tt.length; i++) {
+                try {
+                    tt[i].join();
+                } catch (InterruptedException e2) {
+                    System.err.println(e2);
+                }
+            }
+            endTime = System.currentTimeMillis();
+            ThreadPerformance3Test[ii] = endTime - startTime;
+        }
+        for(int ii = 0; ii < ThreadPerformance3Test.length; ii++) {
+            sum += ThreadPerformance3Test[ii];
+        }
+        ave = sum / ThreadPerformance3Test.length;
+        if(ave < 6000) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+        return;
+    }
+}
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance3/expected.txt b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance3/test.cfg b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9fd89fc984efc5516e8b74843104084b5586e288
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-0000-rt-Thread-Threadperformance3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadPerformance3Test.java)
+run(ThreadPerformance3Test)
diff --git a/testsuite/java_test/thread_test/issue-RT0094-rt-thread-ThreadStateyield/ThreadStateyield.java b/testsuite/java_test/thread_test/issue-RT0094-rt-thread-ThreadStateyield/ThreadStateyield.java
new file mode 100755
index 0000000000000000000000000000000000000000..e64b98348fcd49552e46efdd4f1c74e6a0a6d6c0
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0094-rt-thread-ThreadStateyield/ThreadStateyield.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.io.PrintStream;
+public class ThreadStateyield extends Thread {
+    static int i = 0;
+    public ThreadStateyield(String name) {
+        super(name);
+    }
+    public static void main(String[] args) {
+        System.exit(run(args, System.out));
+    }
+    public static int run(String[] args, PrintStream out) {
+        ThreadStateyield zqp1 = new ThreadStateyield("zqp1");
+        ThreadStateyield zqp2 = new ThreadStateyield("zqp2");
+        zqp1.start();
+        try {
+            sleep(10);
+        } catch (InterruptedException e1) {
+        }
+        zqp2.start();
+        try {
+            sleep(1000);
+        } catch (InterruptedException e1) {
+        }
+        System.out.println(zqp2.getState());
+        System.out.println(zqp1.getState());
+        if (zqp2.getState().toString().equals("TERMINATED") && zqp1.getState().toString().equals("TIMED_WAITING") && i != 0) {
+            return 0;
+        }
+        return 2;
+    }
+    public void run() {
+        for (; ; ) {
+            if (currentThread().getName().equals("zqp1")) {
+                yield();
+                i++;
+                try {
+                    sleep(5000);
+                } catch (InterruptedException e) {
+                }
+            } else break;
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/issue-RT0094-rt-thread-ThreadStateyield/expected.txt b/testsuite/java_test/thread_test/issue-RT0094-rt-thread-ThreadStateyield/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ddad6bc57b4b800cf002f78f3fcc39ae1afccadb
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0094-rt-thread-ThreadStateyield/expected.txt
@@ -0,0 +1,2 @@
+TERMINATED
+TIMED_WAITING
diff --git a/testsuite/java_test/thread_test/issue-RT0094-rt-thread-ThreadStateyield/test.cfg b/testsuite/java_test/thread_test/issue-RT0094-rt-thread-ThreadStateyield/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1bdeeec23a17345b6addec4a8fbefb7319c4b11d
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0094-rt-thread-ThreadStateyield/test.cfg
@@ -0,0 +1,7 @@
+compile(ThreadStateyield)
+/usr/bin/qemu-aarch64 -L /usr/aarch64-linux-gnu -E LD_LIBRARY_PATH=${OUT_ROOT}/target/product/maple_arm64/third-party:${OUT_ROOT}/target/product/maple_arm64/lib/host-x86_64-${OPT}:./ ${OUT_ROOT}/target/product/maple_arm64/bin/mplsh -Xbootclasspath:libcore-all.so -cp ThreadStateyield.so ThreadStateyield > output.log 2>&1
+diff output.log expected.txt
+
+MPLFE_PANDAO0,MPLFE_PANDAO2:
+compile(ThreadStateyield)
+run(ThreadStateyield)
diff --git a/testsuite/java_test/thread_test/issue-RT0392-rt-Thread-Threadperformance1/ThreadPerformance1Test.java b/testsuite/java_test/thread_test/issue-RT0392-rt-Thread-Threadperformance1/ThreadPerformance1Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b6611c73c14f5649ea7680fd3b3928d9725aff2
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0392-rt-Thread-Threadperformance1/ThreadPerformance1Test.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+class LockCls {}
+public class ThreadPerformance1Test extends  Thread{
+    public static void main(String[] args) {
+        LockCls lock = new LockCls();
+        long startTime;
+        long endTime;
+        long[] ThreadPerformance1Test = new long[20];
+        long sum = 0;
+        long ave;
+        Object obj = "aa";
+        Thread[] tt = new Thread[100];
+        for (int ii = 0; ii < ThreadPerformance1Test.length; ii++) {
+            for (int i = 0; i < tt.length; i++) {
+                tt[i] = new Thread(new Runnable() {
+                    public void run() {
+                        synchronized (lock) {
+                            synchronized (lock) {
+                                synchronized (obj) {
+                                    synchronized (this) {
+                                        synchronized (obj) {
+                                            synchronized (this) {
+                                                try {
+                                                    this.wait(10);
+                                                } catch (InterruptedException e1) {
+                                                    System.err.println(e1);
+                                                }
+                                            }
+                                            try {
+                                                obj.wait(10);
+                                            } catch (InterruptedException e2) {
+                                                System.err.println(e2);
+                                            }
+                                        }
+                                        this.notifyAll();
+                                    }
+                                    obj.notify();
+                                }
+                                try {
+                                    lock.wait(10);
+                                } catch (InterruptedException e3) {
+                                    System.err.println(e3);
+                                }
+                            }
+                            lock.notifyAll();
+                        }
+                    }
+                });
+            }
+            startTime = System.currentTimeMillis();
+            for (int i = 0; i < tt.length; i++) {
+                tt[i].start();
+            }
+            for (int i = 0; i < tt.length; i++) {
+                try {
+                    tt[i].join();
+                }catch (InterruptedException e) {
+                    System.err.println(e);
+                }
+            }
+            endTime = System.currentTimeMillis();
+            //System.out.println(startTime);
+            //System.out.println(endTime);
+            //System.out.println(endTime - startTime);
+            ThreadPerformance1Test[ii] = endTime - startTime;
+        }
+        for(int ii = 0; ii < ThreadPerformance1Test.length; ii++) {
+            sum += ThreadPerformance1Test[ii];
+        }
+        ave = sum / ThreadPerformance1Test.length;
+        //System.out.println("ave=" + ave + "ms");
+        System.out.println(0);
+        return;
+    }
+}
diff --git a/testsuite/java_test/thread_test/issue-RT0392-rt-Thread-Threadperformance1/test.cfg b/testsuite/java_test/thread_test/issue-RT0392-rt-Thread-Threadperformance1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..21844a77bd9e4cf55831316385ee77a630bf674e
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0392-rt-Thread-Threadperformance1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadPerformance1Test.java)
+run(ThreadPerformance1Test)
diff --git a/testsuite/java_test/thread_test/issue-RT0393-rt-Thread-Threadperformance2/ThreadPerformance2Test.java b/testsuite/java_test/thread_test/issue-RT0393-rt-Thread-Threadperformance2/ThreadPerformance2Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..f49f8a55b15a8a3826b79863d5ecf09803ddcb19
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0393-rt-Thread-Threadperformance2/ThreadPerformance2Test.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadPerformance2Test extends Thread {
+    public static void main(String[] args) {
+        long startTime;
+        long endTime;
+        long sum = 0;
+        long ave;
+        long[] ThreadPerformance2Test = new long[20];
+        Thread[] tt = new Thread[10000];
+        for (int ii = 0; ii < ThreadPerformance2Test.length; ii++) {
+            for (int i = 0; i < tt.length; i++) {
+                tt[i] = new Thread() {
+                    public void run() {
+                        yield();
+                        try {
+                            sleep(0);
+                        }catch (InterruptedException e) {
+                            System.err.println(e);
+                        }
+                    }
+                };
+            }
+            startTime = System.currentTimeMillis();
+            for (int i = 0; i < tt.length; i++) {
+                tt[i].start();
+            }
+            for (int i = 0; i < tt.length; i++) {
+                try {
+                    tt[i].join();
+                } catch (InterruptedException e) {
+                    System.err.println(e);
+                }
+            }
+            endTime = System.currentTimeMillis();
+            ThreadPerformance2Test[ii] = endTime - startTime;
+        }
+        for (int ii = 0; ii < ThreadPerformance2Test.length; ii++) {
+            sum += ThreadPerformance2Test[ii];
+        }
+        ave = sum / ThreadPerformance2Test.length;
+        if (ave < 6000) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+        return;
+    }
+}
diff --git a/testsuite/java_test/thread_test/issue-RT0393-rt-Thread-Threadperformance2/expected.txt b/testsuite/java_test/thread_test/issue-RT0393-rt-Thread-Threadperformance2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0393-rt-Thread-Threadperformance2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-RT0393-rt-Thread-Threadperformance2/test.cfg b/testsuite/java_test/thread_test/issue-RT0393-rt-Thread-Threadperformance2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3aae2f16f5859317e6ec4b58d547be2b862ebce6
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0393-rt-Thread-Threadperformance2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadPerformance2Test.java)
+run(ThreadPerformance2Test)
diff --git a/testsuite/java_test/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/ThreadStateNewTest.java b/testsuite/java_test/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/ThreadStateNewTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..18b4dd199bbb54252fdd4747af8778b95d3688f2
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/ThreadStateNewTest.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadStateNewTest extends Thread {
+    public static void main(String[] args) {
+        ThreadStateNewTest cls = new ThreadStateNewTest();
+        if (cls.getState().toString().equals("NEW")) {
+            System.out.println(0);
+            return;
+        }
+        System.out.println(2);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/expected.txt b/testsuite/java_test/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/test.cfg b/testsuite/java_test/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2c969e80f2c2f741473debf33878c488603d2003
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0427-rt-Thread-ThreadStatenew/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadStateNewTest)
+run(ThreadStateNewTest)
diff --git a/testsuite/java_test/thread_test/issue-RT0453-rt-Thread-TLRemoveTest/ThreadLocalRemoveTest.java b/testsuite/java_test/thread_test/issue-RT0453-rt-Thread-TLRemoveTest/ThreadLocalRemoveTest.java
new file mode 100755
index 0000000000000000000000000000000000000000..3373b3d15c949b365e6b854722b8e6d3e4bd53d5
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0453-rt-Thread-TLRemoveTest/ThreadLocalRemoveTest.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadLocalRemoveTest {
+    private static final int INITIAL_VALUE = 101;
+    private static final int REMOVE_SET_VALUE = 102;
+    static ThreadLocal<Integer> n = new ThreadLocal<Integer>() {
+        protected synchronized Integer initialValue() {
+            return INITIAL_VALUE;
+        }
+    };
+    public static void main(String[] args) throws Throwable {
+        int threadCount = 100;
+        final int[] removeNode = {10, 20, 45, 38};
+        // ThreadLocal values will be removed for these threads.
+        final int[] removeAndSet = {12, 34, 10};
+        // ThreadLocal values will be removed and sets new values..
+        Thread[] th = new Thread[threadCount];
+        final int[] x = new int[threadCount];
+        final Throwable[] exceptions = new Throwable[threadCount];
+        for (int i = 0; i < threadCount; i++) {
+            final int threadId = i;
+            th[i] = new Thread() {
+                public void run() {
+                    try {
+                        n.set(threadId); // Sets threadId as threadLocal value...
+                        for (int j = 0; j < threadId; j++) {
+                            yield();
+                        }
+                        // To remove the ThreadLocal ....
+                        for (int removeId : removeNode) {
+                            if (threadId == removeId) {
+                                n.remove(); // Removes ThreadLocal values..
+                                break;
+                            }
+                        }
+                        // To remove the ThreadLocal value and set new value ...
+                        for (int removeId : removeAndSet) {
+                            if (threadId == removeId) {
+                                n.remove(); // Removes the ThreadLocal Value...
+                                n.set(REMOVE_SET_VALUE); /* Setting new Values to
+                                                          ThreadLocal*/
+
+                                break;
+                            }
+                        }
+                        /* Storing the threadLocal values in 'x'
+                           ...so that it can be used for checking results...*/
+
+                        x[threadId] = n.get();
+                    } catch (Throwable ex) {
+                        exceptions[threadId] = ex;
+                    }
+                }
+            };
+            th[i].start();
+        }
+        // Wait for the threads to finish
+        for (int i = 0; i < threadCount; i++) {
+            th[i].join();
+        }
+        // Check results
+        for (int i = 0; i < threadCount; i++) {
+            int checkValue = i;
+            /* If the remove method is called then the ThreadLocal value will
+             * be its initial value*/
+
+            for (int removeId : removeNode) {
+                if (removeId == i) {
+                    checkValue = INITIAL_VALUE;
+                    break;
+                }
+            }
+            for (int removeId : removeAndSet) {
+                if (removeId == i) {
+                    checkValue = REMOVE_SET_VALUE;
+                    break;
+                }
+            }
+            if (exceptions[i] != null) {
+                throw (exceptions[i]);
+            }
+            if (x[i] != checkValue) {
+                throw (new Throwable("x[" + i + "] =" + x[i]));
+            }
+        }
+        System.out.println("0");
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/issue-RT0453-rt-Thread-TLRemoveTest/expected.txt b/testsuite/java_test/thread_test/issue-RT0453-rt-Thread-TLRemoveTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2ae28399f5fda2dfb1b04405f4a3b4895f5fac1e
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0453-rt-Thread-TLRemoveTest/expected.txt
@@ -0,0 +1 @@
+pass
diff --git a/testsuite/java_test/thread_test/issue-RT0453-rt-Thread-TLRemoveTest/test.cfg b/testsuite/java_test/thread_test/issue-RT0453-rt-Thread-TLRemoveTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..422e6d018a498c6f284a55019bed74a775004148
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0453-rt-Thread-TLRemoveTest/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadLocalRemoveTest)
+run(ThreadLocalRemoveTest)
diff --git a/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/ThreadPerf.java b/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/ThreadPerf.java
new file mode 100755
index 0000000000000000000000000000000000000000..b5ca92ba8eebf08d11d6fa0370881fc921dfa47b
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/ThreadPerf.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadPerf {
+    static long test(final int threadCount, final int workAmountPerThread) throws InterruptedException {
+        Thread[] tt = new Thread[threadCount];
+        final int[] aa = new int[tt.length];
+//        System.out.print("Creating " + tt.length + " Thread objects.");
+        long t0 = System.nanoTime(), t00 = t0;
+        for (int i = 0; i < tt.length; i++) { 
+            final int j = i;
+            tt[i] = new Thread() {
+                public void run() {
+                    int k = j;
+                    for (int l = 0; l < workAmountPerThread; l++) {
+                        k += k*k+l;
+                    }
+                    aa[j] = k;
+                }
+            };
+        }
+//        System.out.println("-- Done in " + (System.nanoTime() - t0)*1E-6 + " ms.");
+//        System.out.println("Starting " + tt.length + " threads with " + workAmountPerThread + " steps of work per thread.");
+        t0 = System.nanoTime();
+        for (int i = 0; i < tt.length; i++) { 
+            tt[i].start();
+        }
+        long t1 = System.nanoTime() - t0;
+//        System.out.println("-- Done in " + t1 * 1E-6 + " ms.");
+//        System.out.println("Joining " + tt.length + " threads.");
+        t0 = System.nanoTime();
+        for (int i = 0; i < tt.length; i++) { 
+            tt[i].join();
+        }
+        long t2 = System.nanoTime() - t0;
+//        System.out.println("-- Done in "+ t2*1E-6 + " ms.");
+        long totalTime = t1 + t2; //total time during thread.start() and thread.join()
+        int checkSum = 0; 
+        //display checksum in order to give the JVM no chance 
+        //to optimize out the contents of the run() method and possibly even thread creation
+        for (int a : aa) {
+            checkSum += a;
+        }
+//        System.out.println("Checksum: " + checkSum);
+//        System.out.println("Total time: " + totalTime*1E-6 + " ms");
+//        System.out.println();
+        return totalTime;
+    }
+    public static void main(String[] kr) throws InterruptedException {
+        int workAmount = 100000000;
+        int[] threadCount = new int[]{1, 2, 10, 50, 100, 200, 500, 1000, 10000};
+        int trialCount = 3; //run the test trialCount times
+        long[][] time = new long[threadCount.length][trialCount];
+        for (int j = 0; j < trialCount; j++) {
+            for (int i = 0; i < threadCount.length; i++) {
+                time[i][j] = test(threadCount[i], workAmount/threadCount[i]); 
+            }
+        }
+//        System.out.println("***************** time during thread.start() and thread.join() ******************\n");
+//        System.out.print("Number of threads ");
+        for (long t : threadCount) {
+//            System.out.print("\t" + t);
+        }
+//        System.out.println();
+        for (int j = 0; j < trialCount; j++) {
+//            System.out.print((j + 1) + ". trial time (ms)");
+            for (int i = 0; i < threadCount.length; i++) {
+//                System.out.print("\t" + Math.round(time[i][j]*1E-6));
+            }
+//            System.out.println();
+        }
+	System.out.println(0);
+    }
+}
+/*
+The results on 64-bit Windows 7 with 32-bit Sun's Java 1.6.0_21 Client VM on Intel Core2 Duo E6400 @2.13 GHz are as follows:
+Number of threads  1    2    10   100  1000 10000 100000
+1. trial time (ms) 346  181  179  191  286  1229  11308
+2. trial time (ms) 346  181  187  189  281  1224  10651
+*/
diff --git a/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/ThreadPerf1.gold b/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/ThreadPerf1.gold
new file mode 100755
index 0000000000000000000000000000000000000000..d5fb1de84ea7c4312d92c05ca8148552ba170dae
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/ThreadPerf1.gold
@@ -0,0 +1 @@
+"in join(millis), millis is negative join(millis) OK in join(millis, nanos), nanosecond out of range in join(millis, nanos), millis is negative join(millis, nanos) OK PASS"
diff --git a/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/expected.txt b/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/test.cfg b/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e4e13997278ad1ea742097b9aa58be93c3414490
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0463-rt-Thread-ThreadPerf1/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadPerf.java)
+run(ThreadPerf)
diff --git a/testsuite/java_test/thread_test/issue-RT0467-rt-Thread-JGFForkJoinBench/JGFForkJoinBench.java b/testsuite/java_test/thread_test/issue-RT0467-rt-Thread-JGFForkJoinBench/JGFForkJoinBench.java
new file mode 100755
index 0000000000000000000000000000000000000000..f11e1258c63fc62d888de9abc59efbec02cc209d
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0467-rt-Thread-JGFForkJoinBench/JGFForkJoinBench.java
@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Hashtable;
+public class JGFForkJoinBench implements JGFSection1{
+    public static int nThreads;
+    private static final int INITSIZE = 1000;
+    private static final int MAXSIZE = 10000;
+    private static final double TARGETTIME = 10.0;
+    public JGFForkJoinBench(int nThreads) {
+        this.nThreads = nThreads;
+    }
+    public void JGFRun() {
+        int i;
+        int size;
+        double time;
+        double time2;
+        time = 0.0;
+        time2 = 0.0;
+        size = INITSIZE;
+        Runnable thObjects[] = new Runnable [nThreads];
+        Thread th[] = new Thread [nThreads];
+        JGFInstrumentor.addTimer("Section1:ForkJoin:Simple", "forkjoins");
+        while (size < MAXSIZE) {
+            JGFInstrumentor.resetTimer("Section1:ForkJoin:Simple");
+            JGFInstrumentor.startTimer("Section1:ForkJoin:Simple");
+            for (int k = 0; k < size; k++) {
+                for(i = 1; i < nThreads; i++) {
+                    thObjects[i] = new ForkJoinThread(i);
+                    th[i] = new Thread(thObjects[i]);
+                    th[i].start();
+                }
+                thObjects[0] = new ForkJoinThread(0);
+                thObjects[0].run();
+                for(i = 1; i < nThreads; i++) {
+                    try {
+                        th[i].join();
+                    } catch (InterruptedException e) {
+                        System.out.println("Join is interrupted");
+                    }
+                }
+            }
+            JGFInstrumentor.stopTimer("Section1:ForkJoin:Simple");
+            time = JGFInstrumentor.readTimer("Section1:ForkJoin:Simple");
+            JGFInstrumentor.addOpsToTimer("Section1:ForkJoin:Simple",(double) size);
+            size *= 2;
+        }
+        size /= 2;
+        JGFInstrumentor.addTimer("Section1:SerialForkJoin:Simple", "forkjoins");
+        JGFInstrumentor.startTimer("Section1:SerialForkJoin:Simple");
+        for (int k = 0; k < size; k++) {
+            thObjects[0] = new ForkJoinThread(0);
+            thObjects[0].run();
+        }
+        JGFInstrumentor.stopTimer("Section1:SerialForkJoin:Simple");
+        time2 = JGFInstrumentor.readTimer("Section1:SerialForkJoin:Simple");
+        JGFInstrumentor.addTimeToTimer("Section1:ForkJoin:Simple", -time2);
+        JGFInstrumentor.printPerTimer("Section1:ForkJoin:Simple");
+    }
+    public static void main(String[] argv) {
+        nThreads = 4;
+        JGFInstrumentor.printHeader(1, 0, nThreads);
+        JGFForkJoinBench fj = new JGFForkJoinBench(nThreads);
+        fj.JGFRun();
+        System.out.println(0);
+    }
+}
+class ForkJoinThread implements Runnable {
+    int id;
+    long j;
+    public ForkJoinThread(int id) {
+        this.id = id;
+    }
+    public void run() {
+        // do something trivial but which won't be optimised away!
+        double theta=37.2, sInt, res;
+        sInt = Math.sin(theta);
+        res = sInt*sInt;
+    }
+}
+interface JGFSection1 {
+    public final int INITSIZE = 10000;
+    public final int MAXSIZE = 1000000000;
+    public final double TARGETTIME = 1.0;
+    public void JGFRun();
+}
+class JGFInstrumentor{
+    private static Hashtable timers;
+    private static Hashtable data;
+    static {
+        timers = new Hashtable();
+        data = new Hashtable();
+    }
+    public static synchronized void addTimer(String name) {
+        if (!timers.containsKey(name)) {
+            timers.put(name, new JGFTimer(name));
+        }
+    }
+    public static synchronized void addTimer (String name, String opName) {
+        if (!timers.containsKey(name)) {
+            timers.put(name, new JGFTimer(name,opName));
+        }
+    }
+    public static synchronized void addTimer (String name, String opName, int size) {
+        if (!timers.containsKey(name)) {
+            timers.put(name, new JGFTimer(name,opName,size));
+        }
+    }
+    public static synchronized void startTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).start();
+        }
+    }
+    public static synchronized void stopTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).stop();
+        }
+    }
+    public static synchronized void addOpsToTimer(String name, double count) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).addOps(count);
+        }
+    }
+    public static synchronized void addTimeToTimer(String name, double added_time) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).addTime(added_time);
+        }
+    }
+    public static synchronized double readTimer(String name) {
+        double time;
+        if (timers.containsKey(name)) {
+            time = ((JGFTimer) timers.get(name)).time;
+        } else {
+            time = 0.0;
+        }
+        return time;
+    }
+    public static synchronized void resetTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).reset();
+        }
+    }
+    public static synchronized void printTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).print();
+        }
+    }
+    public static synchronized void printPerTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).printPer();
+        }
+    }
+    public static synchronized void storeData(String name, Object obj) {
+        data.put(name,obj);
+    }
+    public static synchronized void retrieveData(String name, Object obj) {
+        obj = data.get(name);
+    }
+    public static synchronized void printHeader(int section, int size, int nThreads) {
+        String header;
+        String base;
+        header = "";
+        base = "Java Grande Forum Thread Benchmark Suite - Version 1.0 - Section ";
+        switch (section) {
+            case 1:
+                header = base + "1";
+                break;
+            case 2:
+                switch (size) {
+                    case 0:
+                        header = base + "2 - Size A";
+                        break;
+                    case 1:
+                        header = base + "2 - Size B";
+                        break;
+                    case 2:
+                        header = base + "2 - Size C";
+                        break;
+                }
+                break;
+            case 3:
+                switch (size) {
+                    case 0:
+                        header = base + "3 - Size A";
+                        break;
+                    case 1:
+                        header = base + "3 - Size B";
+                        break;
+                }
+                break;
+        }
+    }
+}
+class JGFTimer {
+    public String name;
+    public String opName;
+    public double time;
+    public double opCount;
+    public long calls;
+    public int size = -1;
+    private long start_time;
+    private boolean on;
+    public JGFTimer(String name, String opName) {
+        this.name = name;
+        this.opName = opName;
+        reset();
+    }
+    public JGFTimer(String name, String opName, int size) {
+        this.name = name;
+        this.opName = opName;
+        this.size = size;
+        reset();
+    }
+    public JGFTimer(String name) {
+        this(name,"");
+    }
+    public void start() {
+        on = true;
+        start_time = System.currentTimeMillis();
+    }
+    public void stop() {
+        time += (double) (System.currentTimeMillis()-start_time) / 1000.;
+        calls++;
+        on = false;
+    }
+    public void addOps(double count) {
+        opCount += count;
+    }
+    public void addTime(double added_time) {
+        time += added_time;
+    }
+    public void reset() {
+        time = 0.0;
+        calls = 0;
+        opCount = 0;
+        on = false;
+    }
+    public double per() {
+        return opCount / time;
+    }
+    public void longPrint() {
+    }
+    public void print() {
+        if (opName.equals("")) {
+        } else {
+            switch(size) {
+                case 0:
+                    break;
+                case 1:
+                    break;
+                case 2:
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    public void printPer() {
+        String name;
+        name = this.name;
+        // pad name to 40 characters
+        while ( name.length() < 40 ) {
+            name = name + " ";
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/issue-RT0467-rt-Thread-JGFForkJoinBench/expected.txt b/testsuite/java_test/thread_test/issue-RT0467-rt-Thread-JGFForkJoinBench/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0467-rt-Thread-JGFForkJoinBench/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-RT0467-rt-Thread-JGFForkJoinBench/test.cfg b/testsuite/java_test/thread_test/issue-RT0467-rt-Thread-JGFForkJoinBench/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e4ff1b4f057eb50152e1974aba2c64fc504f76e8
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0467-rt-Thread-JGFForkJoinBench/test.cfg
@@ -0,0 +1,2 @@
+compile(JGFForkJoinBench.java)
+run(JGFForkJoinBench)
diff --git a/testsuite/java_test/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/GenerifyStackTraces.java b/testsuite/java_test/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/GenerifyStackTraces.java
new file mode 100755
index 0000000000000000000000000000000000000000..87c6c84a0c960ee7790999615e25e1fd7d8a419f
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/GenerifyStackTraces.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.*;
+public class GenerifyStackTraces {
+    private static Object go = new Object();
+    private static String[] methodNames = {"run", "A", "B", "C", "Done"};
+    private static int DONE_DEPTH = 5;
+    private static boolean testFailed = false;
+    private static Thread one;
+    private static boolean trace = false;
+    public static void main(String[] args) throws Exception {
+        if (args.length > 0 && args[0].equals("trace")) {
+            trace = true;
+        }
+        one = new ThreadOne();
+        one.start();
+        DumpThread dt = new DumpThread();
+        dt.start();
+        try {
+            one.join();
+        } finally {
+            dt.shutdown();
+        }
+        if (testFailed) {
+            throw new RuntimeException("Test Failed.");
+        }
+        System.out.println(0);
+    }
+    static class DumpThread extends Thread {
+        private volatile boolean finished = false;
+        public void run() {
+            int depth = 2;
+            while (!finished) {
+                // At each iterator, wait until ThreadOne blocks to wait for thread dump.
+                // Then dump stack trace and notify ThreadOne to continue.
+                try {
+                    sleep(2000);
+                    dumpStacks(depth);
+                    depth++;
+                    finishDump();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    testFailed = true;
+                }
+            }
+        }
+        public void shutdown() throws InterruptedException {
+            finished = true;
+            this.join();
+        }
+    }
+    static class ThreadOne extends Thread {
+        public void run() {
+            A();
+        }
+        private void A() {
+            waitForDump();
+            B();
+        }
+        private void B() {
+            waitForDump();
+            C();
+        }
+        private void C() {
+            waitForDump();
+            Done();
+        }
+        private void Done() {
+            waitForDump();
+            // Get stack trace of current thread
+            StackTraceElement[] stack = getStackTrace();
+            try {
+                checkStack(this, stack, DONE_DEPTH);
+            } catch (Exception e) {
+                e.printStackTrace();
+                testFailed = true;
+            }
+        }
+    }
+    static private void waitForDump() {
+        synchronized(go) {
+            try {
+               go.wait();
+            } catch (Exception e) {
+               throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+    static private void finishDump() {
+        synchronized(go) {
+            try {
+               go.notifyAll();
+            } catch (Exception e) {
+               throw new RuntimeException("Unexpected exception" + e);
+            }
+        }
+    }
+    public static void dumpStacks(int depth) throws Exception {
+        // Get stack trace of another thread
+        StackTraceElement[] stack = one.getStackTrace();
+        checkStack(one, stack, depth);
+        // Get stack traces of all Threads
+        for (Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
+            Thread t = entry.getKey();
+            stack = entry.getValue();
+            if (t == null || stack == null) {
+                throw new RuntimeException("Null thread or stacktrace returned");
+            }
+            if (t == one) {
+                checkStack(t, stack, depth);
+            }
+        }
+    }
+    private static void checkStack(Thread t, StackTraceElement[] stack, int depth) throws Exception {
+        if (trace) {
+            printStack(t, stack);
+        }
+        int frame = stack.length - 1;
+        for (int i = 0; i < depth && frame >= 0; i++) {
+            if (! stack[frame].getMethodName().equals(methodNames[i])) {
+                throw new RuntimeException("Expected " + methodNames[i] + " in frame " + frame + " but got " +
+                                           stack[frame].getMethodName());
+            }
+            frame--;
+        }
+    }
+    private static void printStack(Thread t, StackTraceElement[] stack) {
+        System.out.println(t + " stack: (length = " + stack.length + ")");
+        if (t != null) {
+            for (int j = 0; j < stack.length; j++) {
+                System.out.println(stack[j]);
+            }
+            System.out.println();
+        }
+    }
+}
diff --git a/testsuite/java_test/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/expected.txt b/testsuite/java_test/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/test.cfg b/testsuite/java_test/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ca31711dee34f5c6575a1c7bca7fd1fef1a9fdbf
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0475-rt-Thread-GenerifyStackTraces/test.cfg
@@ -0,0 +1,2 @@
+compile(GenerifyStackTraces.java)
+run(GenerifyStackTraces)
diff --git a/testsuite/java_test/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/JGFSyncBench.java b/testsuite/java_test/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/JGFSyncBench.java
new file mode 100755
index 0000000000000000000000000000000000000000..1d893bf72a703101922fe4e05e2aa751cc7a53d3
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/JGFSyncBench.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import java.util.Hashtable;
+public class JGFSyncBench implements JGFSection1 {
+    public static int nThreads;
+    private static final int INITSIZE = 1000;
+    private static final int MAXSIZE = 100000;
+    private static final double TARGETTIME = 10.0;
+    public JGFSyncBench(int nThreads) {
+        this.nThreads = nThreads;
+    }
+    public void JGFRun() {
+        int i,size;
+        double time;
+        int counter = 0;
+        int shared_cont = 0;
+        size=INITSIZE;
+        time = 0.0;
+        Runnable thoObjects[] = new Runnable[nThreads + 1];
+        Thread th[] = new Thread[nThreads + 1];
+        CounterClass conTm = new CounterClass(shared_cont);
+        CounterClass conTo = new CounterClass(shared_cont);
+        JGFInstrumentor.addTimer("Section1:Sync:Method", "synchronisations");
+        while (size < MAXSIZE) {
+            JGFInstrumentor.resetTimer("Section1:Sync:Method");
+            JGFInstrumentor.startTimer("Section1:Sync:Method");
+            for(i = 1; i < nThreads + 1; i++) {
+                thoObjects[i] = new SyncMethodRunner(i,conTm,size);
+                th[i] = new Thread(thoObjects[i]);
+                th[i].start();
+            }
+            thoObjects[0] = new SyncMethodRunner(0, conTm, size);
+            thoObjects[0].run();
+            for(i = 1; i < nThreads + 1; i++) {
+                try {
+                    th[i].join();
+                }
+                catch (InterruptedException e) {
+                    System.out.println("Join is interrupted");
+                }
+            }
+            JGFInstrumentor.stopTimer("Section1:Sync:Method");
+            time = JGFInstrumentor.readTimer("Section1:Sync:Method");
+            JGFInstrumentor.addOpsToTimer("Section1:Sync:Method", (double) size);
+            size *= 2;
+        }
+        JGFInstrumentor.printPerTimer("Section1:Sync:Method");
+        size = INITSIZE;
+        time = 0.0;
+        JGFInstrumentor.addTimer("Section1:Sync:Object", "synchronisations");
+        while (size < MAXSIZE) {
+            JGFInstrumentor.resetTimer("Section1:Sync:Object");
+            JGFInstrumentor.startTimer("Section1:Sync:Object");
+            for(i = 1; i < nThreads + 1; i++) {
+                thoObjects[i] = new SyncObjectRunner(i, conTo, size);
+                th[i] = new Thread(thoObjects[i]);
+                th[i].start();
+            }
+            thoObjects[0] = new SyncObjectRunner(i, conTo, size);
+            thoObjects[0].run();
+            for(i = 1; i < nThreads + 1; i++) {
+                try {
+                    th[i].join();
+                } catch (InterruptedException e) {
+                    System.out.println("Join is interrupted");
+                }
+            }
+            JGFInstrumentor.stopTimer("Section1:Sync:Object");
+            time = JGFInstrumentor.readTimer("Section1:Sync:Object");
+            JGFInstrumentor.addOpsToTimer("Section1:Sync:Object",(double) size);
+            size *= 2;
+        }
+        JGFInstrumentor.printPerTimer("Section1:Sync:Object");
+    }
+    public static void main(String[] argv) {
+        nThreads = 4;
+        JGFInstrumentor.printHeader(1, 0, nThreads);
+        JGFSyncBench sb = new JGFSyncBench(nThreads);
+        sb.JGFRun();
+        System.out.println(0);
+    }
+}
+class CounterClass {
+    int shared_cont;
+    public CounterClass(int shared_cont) {
+        this.shared_cont = shared_cont;
+    }
+    public synchronized void update() {
+        shared_cont++;
+    }
+}
+class SyncMethodRunner implements Runnable {
+    int id;
+    int size;
+    CounterClass cont;
+    public SyncMethodRunner(int id, CounterClass cont ,int size) {
+        this.id = id;
+        this.cont = cont;
+        this.size = size;
+    }
+    public void run() {
+        for(int i = 0; i < size; i++) {
+            cont.update();
+        }
+    }
+}
+class SyncObjectRunner implements Runnable {
+    int id;
+    int size;
+    CounterClass cont;
+    public SyncObjectRunner(int id, CounterClass cont, int size) {
+        this.id = id;
+        this.cont = cont;
+        this.size = size;
+    }
+    public void run() {
+        for(int i = 0; i < size; i++) {
+            synchronized(cont) {
+                cont.shared_cont++;
+            }
+        }
+    }
+}
+class JGFInstrumentor{
+    private static Hashtable timers;
+    private static Hashtable data;
+    static {
+        timers = new Hashtable();
+        data = new Hashtable();
+    }
+    public static synchronized void addTimer (String name) {
+        if (!timers.containsKey(name)) {
+            timers.put(name, new JGFTimer(name));
+        }
+    }
+    public static synchronized void addTimer (String name, String opname) {
+        if (!timers.containsKey(name)) {
+            timers.put(name, new JGFTimer(name,opname));
+        }
+    }
+    public static synchronized void addTimer (String name, String opname, int size) {
+        if (!timers.containsKey(name)) {
+            timers.put(name, new JGFTimer(name,opname,size));
+        }
+    }
+    public static synchronized void startTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).start();
+        }
+    }
+    public static synchronized void stopTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).stop();
+        }
+    }
+    public static synchronized void addOpsToTimer(String name, double count) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).addOps(count);
+        }
+    }
+    public static synchronized void addTimeToTimer(String name, double added_time) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).addTime(added_time);
+        }
+    }
+    public static synchronized double readTimer(String name) {
+        double time;
+        if (timers.containsKey(name)) {
+            time = ((JGFTimer) timers.get(name)).time;
+        } else {
+            time = 0.0;
+        }
+        return time;
+    }
+    public static synchronized void resetTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).reset();
+        }
+    }
+    public static synchronized void printTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).print();
+        }
+    }
+    public static synchronized void printPerTimer(String name) {
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).printPer();
+        }
+    }
+    public static synchronized void storeData(String name, Object obj) {
+        data.put(name,obj);
+    }
+    public static synchronized void retrieveData(String name, Object obj) {
+        obj = data.get(name);
+    }
+    public static synchronized void printHeader(int section, int size,int nThreads) {
+        String header;
+        String base;
+        header = "";
+        base = "Java Grande Forum Thread Benchmark Suite - Version 1.0 - Section ";
+        switch (section) {
+            case 1:
+                header = base + "1";
+                break;
+            case 2:
+                switch (size) {
+                    case 0:
+                        header = base + "2 - Size A";
+                        break;
+                    case 1:
+                        header = base + "2 - Size B";
+                        break;
+                    case 2:
+                        header = base + "2 - Size C";
+                        break;
+                }
+                break;
+            case 3:
+                switch (size) {
+                    case 0:
+                        header = base + "3 - Size A";
+                        break;
+                    case 1:
+                        header = base + "3 - Size B";
+                        break;
+                }
+                break;
+        }
+    }
+}
+interface JGFSection1 {
+    public final int INITSIZE = 10000;
+    public final int MAXSIZE = 1000000000;
+    public final double TARGETTIME = 1.0;
+    public void JGFRun();
+}
+class JGFTimer {
+    public String name;
+    public String opName;
+    public double time;
+    public double opCount;
+    public long calls;
+    public int size = -1;
+    private long start_time;
+    private boolean on;
+    public JGFTimer(String name, String opName) {
+        this.name = name;
+        this.opName = opName;
+        reset();
+    }
+    public JGFTimer(String name, String opName, int size) {
+        this.name = name;
+        this.opName = opName;
+        this.size = size;
+        reset();
+    }
+    public JGFTimer(String name) {
+        this(name,"");
+    }
+    public void start() {
+        if (on) {
+            on = true;
+        }
+        start_time = System.currentTimeMillis();
+    }
+    public void stop() {
+        time += (double) (System.currentTimeMillis()-start_time) / 1000.;
+        if (!on) {
+            calls++;
+        }
+        on = false;
+    }
+    public void addOps(double count) {
+        opCount += count;
+    }
+    public void addTime(double added_time) {
+        time += added_time;
+    }
+    public void reset() {
+        time = 0.0;
+        calls = 0;
+        opCount = 0;
+        on = false;
+    }
+    public double per() {
+        return opCount / time;
+    }
+    public void print() {
+        if (!opName.equals("")) {
+            switch(size) {
+                case 0:
+                    break;
+                case 1:
+                    break;
+                case 2:
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    public void printPer() {
+        String name;
+        name = this.name;
+        // pad name to 40 characters
+        while ( name.length() < 40 ) {
+            name = name + " ";
+        }
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/expected.txt b/testsuite/java_test/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/test.cfg b/testsuite/java_test/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..005d078e028a1c9a701dd40b2584f3746f98a506
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0508-rt-Thread-JGFSyncBench/test.cfg
@@ -0,0 +1,2 @@
+compile(JGFSyncBench.java)
+run(JGFSyncBench)
diff --git a/testsuite/java_test/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/ThreadSetContextClassLoader2.java b/testsuite/java_test/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/ThreadSetContextClassLoader2.java
new file mode 100644
index 0000000000000000000000000000000000000000..8dbdf4efd698a5826180dc1e062d82038fa232e3
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/ThreadSetContextClassLoader2.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetContextClassLoader2 extends Thread {
+    static int i;
+    public static void main(String[] args) {
+        ThreadSetContextClassLoader2 threadSetContextClassLoader2 = new ThreadSetContextClassLoader2();
+        ClassLoader cl = threadSetContextClassLoader2.getContextClassLoader();
+        threadSetContextClassLoader2.setContextClassLoader(cl.getParent());
+        threadSetContextClassLoader2.start();
+        try {
+            threadSetContextClassLoader2.join();
+        } catch (InterruptedException e) {
+            System.out.println("Join is interrupted");
+        }
+        if (i == 1) {
+            if (threadSetContextClassLoader2.getContextClassLoader() != cl) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+    }
+    public void run() {
+        i++;
+        super.run();
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/expected.txt b/testsuite/java_test/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/test.cfg b/testsuite/java_test/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..9283736eee887daad2944e27ca4ccd7d66c9a0c2
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0577-rt-Thread-ThreadsetContextClassLoader2/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetContextClassLoader2)
+run(ThreadSetContextClassLoader2)
diff --git a/testsuite/java_test/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/ThreadSetName3Test.java b/testsuite/java_test/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/ThreadSetName3Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1453d51789c19a3771d16f11143d346739bff58
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/ThreadSetName3Test.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+public class ThreadSetName3Test extends Thread {
+    public static void main(String[] args) {
+        ThreadSetName3Test testName1 = new ThreadSetName3Test();
+        ThreadSetName3Test testName2 = new ThreadSetName3Test();
+        testName1.start();
+        testName1.setName("");
+        testName2.start();
+        testName2.setName("");
+        if (testName1.getName().equals("")) {
+            if (testName1.getName().equals("")) {
+                System.out.println(0);
+                return;
+            }
+        }
+        System.out.println(2);
+        return;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/expected.txt b/testsuite/java_test/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/test.cfg b/testsuite/java_test/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..306dd8e1800f88d2dbdc66ffa457d16418bf3f27
--- /dev/null
+++ b/testsuite/java_test/thread_test/issue-RT0579-rt-Thread-ThreadsetName3/test.cfg
@@ -0,0 +1,2 @@
+compile(ThreadSetName3Test)
+run(ThreadSetName3Test)
diff --git a/testsuite/java_test/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/UnsafegetIntVolatileTest.java b/testsuite/java_test/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/UnsafegetIntVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..24d9d312ea46adcc6aad7da9f9caa5995e3e4441
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/UnsafegetIntVolatileTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.TreeSet;
+public class UnsafegetIntVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetIntVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetIntVolatileTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetIntVolatileTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetIntVolatileTest_1()  {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie6.class.getDeclaredField("age");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie6();
+            result = unsafe.getIntVolatile(obj, offset);
+            if(result == 18){
+                UnsafegetIntVolatileTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie6{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/expected.txt b/testsuite/java_test/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/test.cfg b/testsuite/java_test/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..c9f46a40dd5cfd0990e90557da1cd03f6ed3e56f
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0001-rt-unsafe-UnsafegetIntVolatileTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetIntVolatileTest)
+run(UnsafegetIntVolatileTest)
diff --git a/testsuite/java_test/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/UnsafeallocateMemoryTest.java b/testsuite/java_test/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/UnsafeallocateMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b83ef69a474a1fd0469f5dd5c86d22887c1fef9
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/UnsafeallocateMemoryTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeallocateMemoryTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeallocateMemoryTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeallocateMemoryTest.res -= 2;
+        }
+        if (result == 3 && UnsafeallocateMemoryTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeallocateMemoryTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            UnsafeallocateMemoryTest.res -= 2;
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/expected.txt b/testsuite/java_test/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/test.cfg b/testsuite/java_test/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..857bdbb70dcdf72254aee8fb98e87091e26aa955
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0002-rt-unsafe-UnsafeallocateMemoryTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeallocateMemoryTest)
+run(UnsafeallocateMemoryTest)
diff --git a/testsuite/java_test/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/UnsafearrayBaseOffsetTest.java b/testsuite/java_test/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/UnsafearrayBaseOffsetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1765751977b62c8a698778c38e67b01ce63ce7fa
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/UnsafearrayBaseOffsetTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafearrayBaseOffsetTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafearrayFieldOffsetTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafearrayBaseOffsetTest.res = UnsafearrayBaseOffsetTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafearrayBaseOffsetTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafearrayFieldOffsetTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Object obj;
+        long offset;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            obj = new int[]{101, 2, 3};
+            offset = unsafe.arrayBaseOffset(obj.getClass());
+            int result = unsafe.getInt(obj, offset);
+            if(result == 101){
+                UnsafearrayBaseOffsetTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/expected.txt b/testsuite/java_test/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/test.cfg b/testsuite/java_test/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..982989c16828961f54c75e405002ec319dc18447
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0003-rt-unsafe-UnsafearrayBaseOffsetTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafearrayBaseOffsetTest)
+run(UnsafearrayBaseOffsetTest)
diff --git a/testsuite/java_test/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/UnsafearrayIndexScaleTest.java b/testsuite/java_test/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/UnsafearrayIndexScaleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a1b4f6286c11a1d395c0700858fa37d72a3f50c
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/UnsafearrayIndexScaleTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafearrayIndexScaleTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafearrayIndexSacleTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafearrayIndexScaleTest.res = UnsafearrayIndexScaleTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafearrayIndexScaleTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafearrayIndexSacleTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Object obj;
+        long scale;
+        long offset;
+        long result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new long[]{9, 8, 7, 6};
+            scale =  unsafe.arrayIndexScale(obj.getClass());
+            offset = unsafe.arrayBaseOffset(obj.getClass());
+            result = unsafe.getLong(obj, offset + 2*scale);
+            if(result == 7){
+                UnsafearrayIndexScaleTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
\ No newline at end of file
diff --git a/testsuite/java_test/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/expected.txt b/testsuite/java_test/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/test.cfg b/testsuite/java_test/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f5f62e415b976f836ce9d099bcd769272dfabb3c
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0004-rt-unsafe-UnsafearrayIndexScaleTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafearrayIndexScaleTest)
+run(UnsafearrayIndexScaleTest)
diff --git a/testsuite/java_test/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/UnsafecompareAndSwapIntTest.java b/testsuite/java_test/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/UnsafecompareAndSwapIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ee2f5438592c8c37d1a73ffb819ced599a9596e
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/UnsafecompareAndSwapIntTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafecompareAndSwapIntTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecompareAndSwapIntTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafecompareAndSwapIntTest.res = UnsafecompareAndSwapIntTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafecompareAndSwapIntTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafecompareAndSwapIntTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Field param;
+        Object obj;
+        long scale;
+        long offset;
+        int result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new Billie3();
+            param = Billie3.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            unsafe.compareAndSwapInt(obj, offset, 8, 10);
+            result = unsafe.getInt(obj, offset);
+            if(result == 10){
+                UnsafecompareAndSwapIntTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie3{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+}
diff --git a/testsuite/java_test/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/expected.txt b/testsuite/java_test/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/test.cfg b/testsuite/java_test/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..347b18606b58ac5ef03978e9829c5de90882800a
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0005-rt-unsafe-UnsafecompareAndSwapIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafecompareAndSwapIntTest)
+run(UnsafecompareAndSwapIntTest)
diff --git a/testsuite/java_test/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/UnsafecompareAndSwapLongTest.java b/testsuite/java_test/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/UnsafecompareAndSwapLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..454165ea8e2c0e5a8a267a75f306a84089b57950
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/UnsafecompareAndSwapLongTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafecompareAndSwapLongTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecompareAndSwapLongTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafecompareAndSwapLongTest.res = UnsafecompareAndSwapLongTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafecompareAndSwapLongTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafecompareAndSwapLongTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Field param;
+        Object obj;
+        long offset;
+        long result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new Billie4();
+            param = Billie4.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            unsafe.compareAndSwapLong(obj, offset, 100L, 200L);
+            result = unsafe.getLong(obj, offset);
+            if(result == 200L){
+                UnsafecompareAndSwapLongTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie4{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/expected.txt b/testsuite/java_test/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/test.cfg b/testsuite/java_test/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..03bb5d09bb973fbe7e79ea7c3371f893fd42b7d9
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0006-rt-unsafe-UnsafecompareAndSwapLongTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafecompareAndSwapLongTest)
+run(UnsafecompareAndSwapLongTest)
diff --git a/testsuite/java_test/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/UnsafecompareAndSwapObjectTest.java b/testsuite/java_test/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/UnsafecompareAndSwapObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3b2023d476812061df24b3266982a0ef611269b
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/UnsafecompareAndSwapObjectTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafecompareAndSwapObjectTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecompareAndSwapObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafecompareAndSwapObjectTest.res = UnsafecompareAndSwapObjectTest.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafearrayBaseOffsetTest.res);
+        if (result == 3 && UnsafecompareAndSwapObjectTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafecompareAndSwapObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Field param;
+        Object obj;
+        long offset;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            obj = new Billie5();
+            param = Billie5.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            unsafe.compareAndSwapObject(obj, offset, "Me", "billie5");
+            result = unsafe.getObject(obj, offset);
+            if(result.equals("billie5")){
+                UnsafecompareAndSwapObjectTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie5{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/expected.txt b/testsuite/java_test/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/test.cfg b/testsuite/java_test/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7dc94b399d6dbffe4544fc2f5c36134784162d05
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafecompareAndSwapObjectTest)
+run(UnsafecompareAndSwapObjectTest)
diff --git a/testsuite/java_test/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/UnsafecopyMemoryTest.java b/testsuite/java_test/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/UnsafecopyMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4995b6a11579bfaef77d01f9aaedc53cc5af568d
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/UnsafecopyMemoryTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+public class UnsafecopyMemoryTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafecopyMemoryTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafecopyMemoryTest.res -= 2;
+        }
+        if (result == 3 && UnsafecopyMemoryTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafecopyMemoryTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address1;
+        long address2;
+        byte result;
+        Method m;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address1 = unsafe.allocateMemory(5);
+            byte b = 101;
+            unsafe.putByte(address1, b);
+            address2 = unsafe.allocateMemory(5);
+            unsafe.copyMemory(address1, address2, 5);
+//            System.out.println(Arrays.toString(bytes));
+            result = unsafe.getByte(address2);
+//            System.out.println(result);
+            if(result == 101){
+                UnsafecopyMemoryTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/expected.txt b/testsuite/java_test/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/test.cfg b/testsuite/java_test/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..44b9cce09839171e0e7bb4cc068894316777caf3
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0008-rt-unsafe-UnsafecopyMemoryTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafecopyMemoryTest)
+run(UnsafecopyMemoryTest)
diff --git a/testsuite/java_test/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/UnsafefreeMemoryTest.java b/testsuite/java_test/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/UnsafefreeMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e93a11d1e57f0018d11008fa794fd30314e171cb
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/UnsafefreeMemoryTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafefreeMemoryTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafefreeMemoryTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafefreeMemoryTest.res -= 2;
+        }
+        if (result == 3 && UnsafefreeMemoryTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafefreeMemoryTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            unsafe.freeMemory(address);
+            UnsafefreeMemoryTest.res -= 2;
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/expected.txt b/testsuite/java_test/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/test.cfg b/testsuite/java_test/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d8dd29f16876deae546163a22eaa7e08470640ed
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0009-rt-unsafe-UnsafefreeMemoryTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafefreeMemoryTest)
+run(UnsafefreeMemoryTest)
diff --git a/testsuite/java_test/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/UnsafegetAndAddIntTest.java b/testsuite/java_test/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/UnsafegetAndAddIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0987b66b1cc7e8416a17d5c3b565063334feb170
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/UnsafegetAndAddIntTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetAndAddIntTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndAddIntTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetAndAddIntTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetAndAddIntTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetAndAddIntTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        int result2;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie35.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie35();
+            result = unsafe.getAndAddInt(obj, offset, 20);
+//            System.out.println(result);
+            result2 = unsafe.getInt(obj, offset);
+//            System.out.println(result2);
+            if(result == 8 && result2 == 28){
+                UnsafegetAndAddIntTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie35{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/expected.txt b/testsuite/java_test/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/test.cfg b/testsuite/java_test/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..91a5b455bd82b875d1370ff4cbd0bb8745b116cb
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0010-rt-unsafe-UnsafegetAndAddIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetAndAddIntTest)
+run(UnsafegetAndAddIntTest)
diff --git a/testsuite/java_test/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/UnsafegetAndAddLongTest.java b/testsuite/java_test/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/UnsafegetAndAddLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ffb9db75f0b4f8babb729a9614f847e54546a05
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/UnsafegetAndAddLongTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetAndAddLongTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndAddLongTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetAndAddLongTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetAndAddLongTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetAndAddLongTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        long result;
+        long result2;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie37.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie37();
+            result = unsafe.getAndAddLong(obj, offset, 1L);
+//            System.out.println(result);
+            result2 = unsafe.getLong(obj, offset);
+//            System.out.println(result2);
+            if(result == 100 && result2 == 101){
+                UnsafegetAndAddLongTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie37{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/expected.txt b/testsuite/java_test/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/test.cfg b/testsuite/java_test/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cc28cbaabf12582d416d6258dc20b8a32d4bfcce
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0011-rt-unsafe-UnsafegetAndAddLongTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetAndAddLongTest)
+run(UnsafegetAndAddLongTest)
diff --git a/testsuite/java_test/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/UnsafegetAndSetIntTest.java b/testsuite/java_test/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/UnsafegetAndSetIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d0dc5f128d5e601b762065bdc55dd5f36f8cc26c
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/UnsafegetAndSetIntTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafegetAndSetIntTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndSetIntTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetAndSetIntTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetAndSetIntTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetAndSetIntTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        int result2;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie36.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie36();
+            result = unsafe.getAndSetInt(obj, offset, 20);
+//            System.out.println(result);
+            result2 = unsafe.getInt(obj, offset);
+//            System.out.println(result2);
+            if(result == 8 && result2 == 20){
+                UnsafegetAndSetIntTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie36{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/expected.txt b/testsuite/java_test/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/test.cfg b/testsuite/java_test/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..76b4e2baba15aefd415cae2a998596da4c93d463
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0012-rt-unsafe-UnsafegetAndSetIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetAndSetIntTest)
+run(UnsafegetAndSetIntTest)
diff --git a/testsuite/java_test/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/UnsafegetAndSetLongTest.java b/testsuite/java_test/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/UnsafegetAndSetLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..78ba129f52aa48785aa07e23e37ffdb146389c4e
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/UnsafegetAndSetLongTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafegetAndSetLongTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndSetLongTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetAndSetLongTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetAndSetLongTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetAndSetLongTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        long result;
+        long result2;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie38.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie38();
+            result = unsafe.getAndSetLong(obj, offset, 99L);
+//            System.out.println(result);
+            result2 = unsafe.getInt(obj, offset);
+//            System.out.println(result2);
+            if(result == 100 && result2 == 99){
+                UnsafegetAndSetLongTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie38{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/expected.txt b/testsuite/java_test/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/test.cfg b/testsuite/java_test/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..55774b253580e91631fcae2680e0914b64db31e8
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0013-rt-unsafe-UnsafegetAndSetLongTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetAndSetLongTest)
+run(UnsafegetAndSetLongTest)
diff --git a/testsuite/java_test/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/UnsafegetAndSetObjectTest.java b/testsuite/java_test/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/UnsafegetAndSetObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..87ed6bd1d01d723693194f7ebba9248a3afc9cca
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/UnsafegetAndSetObjectTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafegetAndSetObjectTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetAndSetObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetAndSetObjectTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetAndSetObjectTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetAndSetObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        Object result2;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie39.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie39();
+            result = unsafe.getAndSetObject(obj, offset, "she");
+//            System.out.println(result);
+            result2 = unsafe.getObject(obj, offset);
+//            System.out.println(result2);
+            if(result.equals("Me") && result2.equals("she")){
+                UnsafegetAndSetObjectTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie39{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/expected.txt b/testsuite/java_test/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/test.cfg b/testsuite/java_test/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a9baf991050ce033dfa00c38730ce6c407ed7d4
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0014-rt-unsafe-UnsafegetAndSetObjectTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetAndSetObjectTest)
+run(UnsafegetAndSetObjectTest)
diff --git a/testsuite/java_test/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/UnsafegetBooleanTest.java b/testsuite/java_test/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/UnsafegetBooleanTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d723fefba9f48f1c9a7cd1b582b491ca9cafde7
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/UnsafegetBooleanTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetBooleanTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetBooleanTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetBooleanTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetBooleanTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetBooleanTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        boolean result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie21.class.getDeclaredField("gender");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie21();
+            result = unsafe.getBoolean(obj, offset);
+            if(!result){
+                UnsafegetBooleanTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie21{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/expected.txt b/testsuite/java_test/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/test.cfg b/testsuite/java_test/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5a61862b19860fc4ad599c83123a99bb50b8e56f
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0015-rt-unsafe-UnsafegetBooleanTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetBooleanTest)
+run(UnsafegetBooleanTest)
diff --git a/testsuite/java_test/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/UnsafegetCharByAddressTest.java b/testsuite/java_test/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/UnsafegetCharByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae5d0e44936b0f8e79ad6a2c7bcc02fc288a7036
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/UnsafegetCharByAddressTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafegetCharByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetCharByAddressTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetCharByAddressTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetCharByAddressTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetCharByAddressTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        char result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(2);
+//            System.out.println(address);
+            char c = 'a';
+            unsafe.putChar(address, c);
+            result = unsafe.getChar(address);
+//            System.out.println(result);
+            if(result == c){
+                UnsafegetCharByAddressTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/expected.txt b/testsuite/java_test/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/test.cfg b/testsuite/java_test/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d07e9d72dc7249a3d4bb215e4b962c98d45e89a0
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0016-rt-unsafe-UnsafegetCharByAddressTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetCharByAddressTest)
+run(UnsafegetCharByAddressTest)
diff --git a/testsuite/java_test/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/UnsafegetCharTest.java b/testsuite/java_test/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/UnsafegetCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..266db7c946f4a9f3fa3ca551a051e8285b91bc70
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/UnsafegetCharTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetCharTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetCharTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetCharTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetCharTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetCharTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        char result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie25.class.getDeclaredField("favorite");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie25();
+            result = unsafe.getChar(obj, offset);
+            if(result == '7'){
+                UnsafegetCharTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie25{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+}
diff --git a/testsuite/java_test/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/expected.txt b/testsuite/java_test/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/test.cfg b/testsuite/java_test/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..07d9896184bded02e05a39397ae6edc3da989979
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0017-rt-unsafe-UnsafegetCharTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetCharTest)
+run(UnsafegetCharTest)
diff --git a/testsuite/java_test/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/UnsafegetDoubleByAddressTest.java b/testsuite/java_test/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/UnsafegetDoubleByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bfad530af96ecb9d24f0a8de16dd8eecb9030b1
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/UnsafegetDoubleByAddressTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafegetDoubleByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetDoubleByAddressTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetDoubleByAddressTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetDoubleByAddressTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetDoubleByAddressTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        double result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(8);
+//            System.out.println(address);
+            double d = 111;
+            unsafe.putDouble(address, d);
+            result = unsafe.getDouble(address);
+//            System.out.println(result);
+            if(result == d){
+                UnsafegetDoubleByAddressTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/expected.txt b/testsuite/java_test/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/test.cfg b/testsuite/java_test/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0357394590a319f1a539c1b3bb3109ac347910c8
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0018-rt-unsafe-UnsafegetDoubleByAddressTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetDoubleByAddressTest)
+run(UnsafegetDoubleByAddressTest)
diff --git a/testsuite/java_test/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/UnsafegetDoubleTest.java b/testsuite/java_test/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/UnsafegetDoubleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b90b5fc3216ebaca2ef88908c51b79a3ecb546a
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/UnsafegetDoubleTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetDoubleTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetDoubleTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetDoubleTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetDoubleTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetDoubleTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        double result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie29.class.getDeclaredField("grade");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie29();
+            result = unsafe.getDouble(obj, offset);
+            if(result == 99.99){
+                UnsafegetDoubleTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie29{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/expected.txt b/testsuite/java_test/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/test.cfg b/testsuite/java_test/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7ad264d7b1828788d8ab43bd507f2373781bcc0a
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0019-rt-unsafe-UnsafegetDoubleTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetDoubleTest)
+run(UnsafegetDoubleTest)
diff --git a/testsuite/java_test/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/UnsafegetFloatByAddressTest.java b/testsuite/java_test/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/UnsafegetFloatByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..624ebdd52f7b8930e211656817a0e9933a780f1e
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/UnsafegetFloatByAddressTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafegetFloatByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetFloatByAddressTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetFloatByAddressTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetFloatByAddressTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetFloatByAddressTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        float result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            float f = 111f;
+            unsafe.putFloat(address, f);
+            result = unsafe.getFloat(address);
+//            System.out.println(result);
+            if(result == f){
+                UnsafegetFloatByAddressTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/expected.txt b/testsuite/java_test/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/test.cfg b/testsuite/java_test/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..61d6c7fc8128acd45e9081d82274f10167d231c8
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0020-rt-unsafe-UnsafegetFloatByAddressTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetFloatByAddressTest)
+run(UnsafegetFloatByAddressTest)
diff --git a/testsuite/java_test/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/UnsafegetFloatTest.java b/testsuite/java_test/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/UnsafegetFloatTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fcf637e2caa8411893875e46ead6716f31a28ef8
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/UnsafegetFloatTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetFloatTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetFloatTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetFloatTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetFloatTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetFloatTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Float result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie31.class.getDeclaredField("aFloat");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie31();
+            result = unsafe.getFloat(obj, offset);
+            if(result == 66.66f){
+                UnsafegetFloatTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie31{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/expected.txt b/testsuite/java_test/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/test.cfg b/testsuite/java_test/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..86b9fdb4ef7363aabfeec344f16e62d713740fa9
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0021-rt-unsafe-UnsafegetFloatTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetFloatTest)
+run(UnsafegetFloatTest)
diff --git a/testsuite/java_test/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/UnsafegetIntByAddressTest.java b/testsuite/java_test/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/UnsafegetIntByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..584807192e38d462672ce3d8ade13012a1cd50bc
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/UnsafegetIntByAddressTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafegetIntByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetIntByAddressTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetIntByAddressTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetIntByAddressTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetIntByAddressTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        int result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            int i = 111;
+            unsafe.putInt(address, i);
+            result = unsafe.getInt(address);
+//            System.out.println(result);
+            if(result == i){
+                UnsafegetIntByAddressTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/expected.txt b/testsuite/java_test/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/test.cfg b/testsuite/java_test/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a19a2f56f0e346a55d2d4ca98bd850aa96bcc6db
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0022-rt-unsafe-UnsafegetIntByAddressTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetIntByAddressTest)
+run(UnsafegetIntByAddressTest)
diff --git a/testsuite/java_test/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/UnsafegetIntTest.java b/testsuite/java_test/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/UnsafegetIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a5635633a8c6f49101527a55e58983c8f660b47
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/UnsafegetIntTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetIntTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetIntTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetIntTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetIntTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetIntTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie12.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie12();
+            result = unsafe.getInt(obj, offset);
+            if(result == 8){
+                UnsafegetIntTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie12{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/expected.txt b/testsuite/java_test/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/test.cfg b/testsuite/java_test/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fb94d18cbfc8737ef5e7a2b4d346a2af9dd1e921
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0023-rt-unsafe-UnsafegetIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetIntTest)
+run(UnsafegetIntTest)
diff --git a/testsuite/java_test/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/UnsafegetLongTest.java b/testsuite/java_test/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/UnsafegetLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a3a4bea9fab83da668866c29b5f2901e09b2b97
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/UnsafegetLongTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetLongTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetLongTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetLongTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetLongTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetLongTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Long result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie15.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie15();
+            result = unsafe.getLong(obj, offset);
+            if(result == 100L){
+                UnsafegetLongTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie15{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/expected.txt b/testsuite/java_test/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/test.cfg b/testsuite/java_test/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..595f8c1ffbb1a08790e1789ce911b78124ad112e
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0024-rt-unsafe-UnsafegetLongTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetLongTest)
+run(UnsafegetLongTest)
diff --git a/testsuite/java_test/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/UnsafegetLongVolatileTest.java b/testsuite/java_test/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/UnsafegetLongVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..dfcec0edd38c0367380de7f10069e9923bbac512
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/UnsafegetLongVolatileTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetLongVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetLongVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetLongVolatileTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetLongVolatileTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetLongVolatileTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Long result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie8.class.getDeclaredField("birth");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie8();
+            result = unsafe.getLongVolatile(obj, offset);
+            if(result == 20010214L){
+                UnsafegetLongVolatileTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie8{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/expected.txt b/testsuite/java_test/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/test.cfg b/testsuite/java_test/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d41d19c13a3d8235cc6d93b4aaf409fe079def45
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0025-rt-unsafe-UnsafegetLongVolatileTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetLongVolatileTest)
+run(UnsafegetLongVolatileTest)
diff --git a/testsuite/java_test/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/UnsafegetObjectTest.java b/testsuite/java_test/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/UnsafegetObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff55776899be59ae5dc420352a3ca501f3e62d49
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/UnsafegetObjectTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetObjectTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetObjectTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetObjectTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie18.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie18();
+            result = unsafe.getObject(obj, offset);
+            if(result.equals("Me")){
+                UnsafegetObjectTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie18{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/expected.txt b/testsuite/java_test/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/test.cfg b/testsuite/java_test/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3aa85cb91d74b06311f88ac538c14c47f600222a
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0026-rt-unsafe-UnsafegetObjectTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetObjectTest)
+run(UnsafegetObjectTest)
diff --git a/testsuite/java_test/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/UnsafegetObjectVolatileTest.java b/testsuite/java_test/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/UnsafegetObjectVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b0d0993034db9fcf2aa54070af6e0bfe241add1
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/UnsafegetObjectVolatileTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetObjectVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetObjectVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetObjectVolatileTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetObjectVolatileTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetObjectVolatileTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie10.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie10();
+            result = unsafe.getObjectVolatile(obj, offset);
+            if(result.equals("eilish")){
+                UnsafegetObjectVolatileTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie10{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/expected.txt b/testsuite/java_test/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/test.cfg b/testsuite/java_test/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..17c43db627d2d23aa22800806a95431bd58c77b1
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0027-rt-unsafe-UnsafegetObjectVolatileTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetObjectVolatileTest)
+run(UnsafegetObjectVolatileTest)
diff --git a/testsuite/java_test/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/UnsafegetShortByAddressTest.java b/testsuite/java_test/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/UnsafegetShortByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6a94e4d8e078992656c6a272d6a2e8349d3a78e
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/UnsafegetShortByAddressTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafegetShortByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetShortByAddressTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetShortByAddressTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetShortByAddressTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetShortByAddressTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        short result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(2);
+//            System.out.println(address);
+            short s = 1;
+            unsafe.putShort(address, s);
+            result = unsafe.getShort(address);
+//            System.out.println(result);
+            if(result == s){
+                UnsafegetShortByAddressTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/expected.txt b/testsuite/java_test/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/test.cfg b/testsuite/java_test/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..adf4f23cc7e271dc8274adf0f565f89304042a4f
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0028-rt-unsafe-UnsafegetShortByAddressTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetShortByAddressTest)
+run(UnsafegetShortByAddressTest)
diff --git a/testsuite/java_test/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/UnsafegetShortTest.java b/testsuite/java_test/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/UnsafegetShortTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..09b40720b39c04d25cf34798850230d02b183305
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/UnsafegetShortTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetShortTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetShortTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetShortTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetShortTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetShortTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        short result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie27.class.getDeclaredField("date");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie27();
+            result = unsafe.getShort(obj, offset);
+            if(result == 6){
+                UnsafegetShortTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie27{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/expected.txt b/testsuite/java_test/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/test.cfg b/testsuite/java_test/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b9aaffa02db163263bb228c4e9b29f7d5bf6973b
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0029-rt-unsafe-UnsafegetShortTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetShortTest)
+run(UnsafegetShortTest)
diff --git a/testsuite/java_test/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/UnsafeobjectFieldOffeset.java b/testsuite/java_test/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/UnsafeobjectFieldOffeset.java
new file mode 100644
index 0000000000000000000000000000000000000000..547793988b380a1060061acbb5e9262f4120f528
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/UnsafeobjectFieldOffeset.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeobjectFieldOffeset {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeobjectFieldOffsetTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeobjectFieldOffeset.res = UnsafeobjectFieldOffeset.res - 10;
+        }
+//        System.out.println(result);
+//        System.out.println(UnsafeobjectFieldOffeset.res);
+        if (result == 3 && UnsafeobjectFieldOffeset.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeobjectFieldOffsetTest_1(){
+        Unsafe unsafe;
+        Object obj = new Billie();
+        Field field;
+        Field param1;
+        String result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+            param1 = obj.getClass().getDeclaredField("owner");
+            long offset = unsafe.objectFieldOffset(param1);
+//            System.out.println(offset);
+//            System.out.println(unsafe.getObject(obj, offset));
+            result = (String)unsafe.getObject(obj, offset);
+//            System.out.println(result);
+            if(result.equals("Me")){
+                UnsafeobjectFieldOffeset.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+}
\ No newline at end of file
diff --git a/testsuite/java_test/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/expected.txt b/testsuite/java_test/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/test.cfg b/testsuite/java_test/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0143eec92865fc11e1f5a566d67911be3af99302
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0030-rt-unsafe-UnsafeobjectFieldOffeset/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeobjectFieldOffeset)
+run(UnsafeobjectFieldOffeset)
diff --git a/testsuite/java_test/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/UnsafeputBooleanTest.java b/testsuite/java_test/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/UnsafeputBooleanTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..47660beafd43d7ff9f22a56ca77f05985d9a1f58
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/UnsafeputBooleanTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafeputBooleanTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputBooleanTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputBooleanTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputBooleanTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputBooleanTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        boolean result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie22.class.getDeclaredField("gender");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie22();
+            result = unsafe.getBoolean(obj, offset);
+            unsafe.putBoolean(obj, offset, true);
+            result = unsafe.getBoolean(obj, offset);
+            if(result){
+                UnsafeputBooleanTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie22{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/expected.txt b/testsuite/java_test/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/test.cfg b/testsuite/java_test/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8044bb7b5141c385c3271d37ad357154adb10b94
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0032-rt-unsafe-UnsafeputBooleanTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputBooleanTest)
+run(UnsafeputBooleanTest)
diff --git a/testsuite/java_test/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/UnsafeputByteByAddressTest.java b/testsuite/java_test/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/UnsafeputByteByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5793fa04b71273cc4a63fdd7bbc9205fb13df8fe
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/UnsafeputByteByAddressTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeputByteByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputByteByAddressTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputByteByAddressTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputByteByAddressTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputByteByAddressTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        byte result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            byte b = 127;
+            unsafe.putByte(address, b);
+            result = unsafe.getByte(address);
+//            System.out.println(result);
+            if(result == b){
+                UnsafeputByteByAddressTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/expected.txt b/testsuite/java_test/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/test.cfg b/testsuite/java_test/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d3728e7a6f3f9af3f73a4dbfe253a1f36b923598
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0033-rt-unsafe-UnsafeputByteByAddressTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputByteByAddressTest)
+run(UnsafeputByteByAddressTest)
diff --git a/testsuite/java_test/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/UnsafeputByteTest.java b/testsuite/java_test/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/UnsafeputByteTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..63d194a7b7128678ec78c8518ef16a9a004443a2
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/UnsafeputByteTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafeputByteTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputByteTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputByteTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputByteTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputByteTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        byte result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie24.class.getDeclaredField("length");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie24();
+            result = unsafe.getByte(obj, offset);
+            byte b = 12;
+            unsafe.putByte(obj, offset, b);
+            result = unsafe.getByte(obj, offset);
+            if(result == 12){
+                UnsafeputByteTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie24{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/expected.txt b/testsuite/java_test/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/test.cfg b/testsuite/java_test/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1deed3fa4e3bee4e985521a9696aa2ca993ca306
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0034-rt-unsafe-UnsafeputByteTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputByteTest)
+run(UnsafeputByteTest)
diff --git a/testsuite/java_test/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/UnsafeputCharTest.java b/testsuite/java_test/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/UnsafeputCharTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1077e4f5e46971ec9b842633ac82d357dd99ee4
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/UnsafeputCharTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafeputCharTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputCharTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputCharTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputCharTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputCharTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        char result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie26.class.getDeclaredField("favorite");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie26();
+            result = unsafe.getChar(obj, offset);
+            unsafe.putChar(obj, offset, 's');
+            result = unsafe.getChar(obj, offset);
+            if(result == 's'){
+                UnsafeputCharTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie26{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/expected.txt b/testsuite/java_test/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/test.cfg b/testsuite/java_test/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..34d053b1ff77fa1679e64b461e994dfbf45400ee
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0035-rt-unsafe-UnsafeputCharTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputCharTest)
+run(UnsafeputCharTest)
diff --git a/testsuite/java_test/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/UnsafeputDoubleTest.java b/testsuite/java_test/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/UnsafeputDoubleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e0b7f30612f8472643ca8e43269188e5869035f0
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/UnsafeputDoubleTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafeputDoubleTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputDoubleTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputDoubleTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputDoubleTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputDoubleTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        double result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie30.class.getDeclaredField("grade");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie30();
+            result = unsafe.getDouble(obj, offset);
+            double d = 11.11;
+            unsafe.putDouble(obj, offset, d);
+            result = unsafe.getDouble(obj, offset);
+            if(result == d){
+                UnsafeputDoubleTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie30{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/expected.txt b/testsuite/java_test/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/test.cfg b/testsuite/java_test/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..66c7cd4ef80ae27f9d1ba3774a1898aff4c0060a
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0036-rt-unsafe-UnsafeputDoubleTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputDoubleTest)
+run(UnsafeputDoubleTest)
diff --git a/testsuite/java_test/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/UnsafeputFloatTest.java b/testsuite/java_test/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/UnsafeputFloatTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..110162aae36828fca214964ea8e278d14c360914
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/UnsafeputFloatTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafeputFloatTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputFloatTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputFloatTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputFloatTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputFloatTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Float result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie32.class.getDeclaredField("aFloat");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie32();
+            result = unsafe.getFloat(obj, offset);
+            unsafe.putFloat(obj, offset, 11.11f);
+            result = unsafe.getFloat(obj, offset);
+            if(result == 11.11f){
+                UnsafeputFloatTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie32{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/expected.txt b/testsuite/java_test/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/test.cfg b/testsuite/java_test/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..6b1be614ecb744b6dbf0d9e6a12755818373c2dd
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0037-rt-unsafe-UnsafeputFloatTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputFloatTest)
+run(UnsafeputFloatTest)
diff --git a/testsuite/java_test/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/UnsafeputIntTest.java b/testsuite/java_test/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/UnsafeputIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..06b1781d4cd70f6dbb6859c97e5ddb487a8bb664
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/UnsafeputIntTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeputIntTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputIntTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputIntTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputIntTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputIntTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie13.class.getDeclaredField("height");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie13();
+            result = unsafe.getInt(obj, offset);
+            unsafe.putInt(obj, offset, 10);
+            result = unsafe.getInt(obj,offset);
+            if(result == 10){
+                UnsafeputIntTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie13{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/expected.txt b/testsuite/java_test/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/test.cfg b/testsuite/java_test/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..22de3326dea02fad65b57a7fc9fdb9afc800aaad
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0038-rt-unsafe-UnsafeputIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputIntTest)
+run(UnsafeputIntTest)
diff --git a/testsuite/java_test/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/UnsafeputIntVolatileTest.java b/testsuite/java_test/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/UnsafeputIntVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7b2a049d3a0d0b0af93d2e9a42d377f3a7b6e8d
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/UnsafeputIntVolatileTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.TreeSet;
+public class UnsafeputIntVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputIntVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputIntVolatileTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputIntVolatileTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputIntVolatileTest_1()  {
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        int result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie7.class.getDeclaredField("age");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie7();
+            result = unsafe.getIntVolatile(obj, offset);
+            unsafe.putIntVolatile(obj, offset, 20);
+            result = unsafe.getIntVolatile(obj, offset);
+            if(result == 20){
+                UnsafeputIntVolatileTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie7{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/expected.txt b/testsuite/java_test/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/test.cfg b/testsuite/java_test/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4fb7d5cb867b38c2734808ae08aeda8f231517cc
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0039-rt-unsafe-UnsafeputIntVolatileTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputIntVolatileTest)
+run(UnsafeputIntVolatileTest)
diff --git a/testsuite/java_test/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/UnsafeputLongTest.java b/testsuite/java_test/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/UnsafeputLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5435de5c064bce69cb1896cf835092e974436f0
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/UnsafeputLongTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeputLongTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputLongTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputLongTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputLongTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputLongTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        long result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie16.class.getDeclaredField("weight");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie16();
+            result = unsafe.getLong(obj, offset);
+            unsafe.putLong(obj, offset, 200L);
+            result = unsafe.getLong(obj,offset);
+            if(result == 200L){
+                UnsafeputLongTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie16{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/expected.txt b/testsuite/java_test/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/test.cfg b/testsuite/java_test/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..070f3815056a169836589231137bfe9a774fee1b
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0040-rt-unsafe-UnsafeputLongTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputLongTest)
+run(UnsafeputLongTest)
diff --git a/testsuite/java_test/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/UnsafeputLongVolatileTest.java b/testsuite/java_test/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/UnsafeputLongVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3be080bbfc848ee93bad06b6575a673ce761bdf
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/UnsafeputLongVolatileTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafeputLongVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputLongVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputLongVolatileTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputLongVolatileTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputLongVolatileTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Long result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie9.class.getDeclaredField("birth");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie9();
+            result = unsafe.getLongVolatile(obj, offset);
+            unsafe.putLongVolatile(obj, offset, 20020214L);
+            result = unsafe.getLongVolatile(obj, offset);
+            if(result == 20020214L){
+                UnsafeputLongVolatileTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie9{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/expected.txt b/testsuite/java_test/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/test.cfg b/testsuite/java_test/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..71372f27c2ccca5f403ede5fb5b35211e15619dc
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0041-rt-unsafe-UnsafeputLongVolatileTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputLongVolatileTest)
+run(UnsafeputLongVolatileTest)
diff --git a/testsuite/java_test/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/UnsafeputObjectTest.java b/testsuite/java_test/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/UnsafeputObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5b7af7fafa19143b02899c15934a2c9b5badbb7
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/UnsafeputObjectTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeputObjectTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputObjectTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputObjectTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputObjectTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie19.class.getDeclaredField("owner");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie19();
+            result = unsafe.getObject(obj, offset);
+            unsafe.putObject(obj, offset, "she");
+            result = unsafe.getObject(obj,offset);
+            if(result.equals("she")){
+                UnsafeputObjectTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie19{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/expected.txt b/testsuite/java_test/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/test.cfg b/testsuite/java_test/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..99b3e788cb1832126b0545d577028af969ab2e45
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0042-rt-unsafe-UnsafeputObjectTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputObjectTest)
+run(UnsafeputObjectTest)
diff --git a/testsuite/java_test/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/UnsafeputObjectVolatileTest.java b/testsuite/java_test/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/UnsafeputObjectVolatileTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e971d0b8dace4dd6a4747158d01707f640fcd32
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/UnsafeputObjectVolatileTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeputObjectVolatileTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputObjectVolatileTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputObjectVolatileTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputObjectVolatileTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputObjectVolatileTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        Object result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie11.class.getDeclaredField("lastname");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie11();
+            result = unsafe.getObjectVolatile(obj, offset);
+            unsafe.putObjectVolatile(obj, offset, "Eilish");
+            result = unsafe.getObjectVolatile(obj, offset);
+            if(result.equals("Eilish")){
+                UnsafeputObjectVolatileTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie11{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/expected.txt b/testsuite/java_test/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/test.cfg b/testsuite/java_test/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b2096916920bbbc464f70ef12ebe81ff18d1e5a8
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0043-rt-unsafe-UnsafeputObjectVolatileTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputObjectVolatileTest)
+run(UnsafeputObjectVolatileTest)
diff --git a/testsuite/java_test/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/UnsafeputOrderedIntTest.java b/testsuite/java_test/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/UnsafeputOrderedIntTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ed00730b271f4404ab904a59bfe86dace77b1a3
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/UnsafeputOrderedIntTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeputOrderedIntTest {
+    private static int res = 99;
+    private static Object obj = new Object();
+    private static Long offset =0l;
+    private static int flag =0;
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out) throws InterruptedException {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputOrderedIntTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputOrderedIntTest.res -= 2;
+        }
+//        System.out.println(flag);
+        if (flag==0){
+//            System.out.println("It is true");
+        }
+        Thread.sleep(4000);
+//        System.out.println(flag);
+//        System.out.println("result:" +result);
+//        System.out.println("res: "+ res);
+        if (result == 3 && UnsafeputOrderedIntTest.flag == 10){
+            result = 0;
+        }
+        return result;
+    }
+    private static int UnsafeputOrderedIntTest_1(){
+        int result = 3;
+        Field field;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            Unsafe unsafe = (Unsafe)field.get(null);
+            Thread boyThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    Field param = null;
+                    try {
+                        param = Billie14.class.getDeclaredField("height");
+                    } catch (NoSuchFieldException e) {
+                        e.printStackTrace();
+                    }
+                    offset = unsafe.objectFieldOffset(param);
+                    obj = new Billie14();
+                    unsafe.putOrderedInt(obj, offset, 10);
+                }
+            });
+            Thread girlThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    int result;
+                    flag = unsafe.getInt(obj,offset);
+//                    System.out.println("======================="+flag);
+                    try {
+                        Thread.sleep(3000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    flag = unsafe.getInt(obj,offset);
+//                    System.out.println("======================="+flag);
+                }
+            });
+            boyThread.start();
+            girlThread.start();
+        }catch (Exception e){
+            e.printStackTrace();
+            return 40;
+        }
+        return result;
+    }
+}
+class Billie14{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/expected.txt b/testsuite/java_test/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/test.cfg b/testsuite/java_test/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..b7525ad3403d667296acbeb577be3e5d70dd9c59
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0044-rt-unsafe-UnsafeputOrderedIntTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputOrderedIntTest)
+run(UnsafeputOrderedIntTest)
diff --git a/testsuite/java_test/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/UnsafeputOrderedLongTest.java b/testsuite/java_test/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/UnsafeputOrderedLongTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1be324e2fc23aceddeaa88b9c88a58214af54049
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/UnsafeputOrderedLongTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeputOrderedLongTest {
+    private static int res = 99;
+    private static Object obj = new Object();
+    private static Long offset =0l;
+    private static long flag =0l;
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out) throws InterruptedException {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputOrderedLongTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputOrderedLongTest.res -= 2;
+        }
+//        System.out.println(flag);
+        if (flag==0){
+//            System.out.println("It is true");
+        }
+        Thread.sleep(4000);
+//        System.out.println(flag);
+//        System.out.println("result:" +result);
+//        System.out.println("res: "+ res);
+        if (result == 3 && UnsafeputOrderedLongTest.flag == 200L){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputOrderedLongTest_1(){
+        int result =3;
+        Field field;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            Unsafe unsafe = (Unsafe)field.get(null);
+            Thread boyThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    Field param = null;
+                    try {
+                        param = Billie17.class.getDeclaredField("weight");
+                    } catch (NoSuchFieldException e) {
+                        e.printStackTrace();
+                    }
+                    offset = unsafe.objectFieldOffset(param);
+                    obj = new Billie17();
+                    unsafe.putOrderedLong(obj, offset, 200L);
+                }
+            });
+            Thread girlThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    int result;
+                    flag = unsafe.getLong(obj,offset);
+//                    System.out.println("======================="+flag);
+                    try {
+                        Thread.sleep(3000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    flag = unsafe.getLong(obj,offset);
+//                    System.out.println("======================="+flag);
+                }
+            });
+            boyThread.start();
+            girlThread.start();
+        }catch (Exception e){
+            e.printStackTrace();
+            return 40;
+        }
+        return 3;
+    }
+}
+class Billie17{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/expected.txt b/testsuite/java_test/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/test.cfg b/testsuite/java_test/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..8bce24786fb3de1a6e0e9877fc6ed6297f12dfc5
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0045-rt-unsafe-UnsafeputOrderedLongTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputOrderedLongTest)
+run(UnsafeputOrderedLongTest)
diff --git a/testsuite/java_test/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/UnsafeputOrderedObjectTest.java b/testsuite/java_test/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/UnsafeputOrderedObjectTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2e23b73f938370022895960ddcba4c69059f30b
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/UnsafeputOrderedObjectTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeputOrderedObjectTest {
+    private static int res = 99;
+    private static Object obj = new Object();
+    private static Long offset =0l;
+    private static Object flag = new Object();
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out) throws InterruptedException {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeputOrderedObjectTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputOrderedObjectTest.res -= 2;
+        }
+//        System.out.println(flag.toString());
+        if (flag.equals("")){
+//            System.out.println("It is true");
+        }
+        Thread.sleep(4000);
+//        System.out.println(flag.toString());
+//        System.out.println("result:" +result);
+//        System.out.println("res: "+ res);
+        if (result == 3 && UnsafeputOrderedObjectTest.flag.equals("Yours")){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeputOrderedObjectTest_1(){
+        int result =3;
+        Field field;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            Unsafe unsafe = (Unsafe)field.get(null);
+            Thread boyThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    Field param = null;
+                    try {
+                        param = Billie20.class.getDeclaredField("owner");
+                    } catch (NoSuchFieldException e) {
+                        e.printStackTrace();
+                    }
+                    offset = unsafe.objectFieldOffset(param);
+                    obj = new Billie20();
+                    unsafe.putOrderedObject(obj, offset, "Yours");
+                }
+            });
+            Thread girlThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    int result;
+                    flag = unsafe.getObject(obj,offset);
+//                    System.out.println("======================="+flag);
+                    try {
+                        Thread.sleep(3000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    flag = unsafe.getObject(obj,offset);
+//                    System.out.println("======================="+flag);
+                }
+            });
+            boyThread.start();
+            girlThread.start();
+        }catch (Exception e){
+            e.printStackTrace();
+            return 40;
+        }
+        return 3;
+    }
+}
+class Billie20{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+}
diff --git a/testsuite/java_test/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/expected.txt b/testsuite/java_test/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/test.cfg b/testsuite/java_test/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..76c80038787aa692dc9c480e12cb052b7f70ff92
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0046-rt-unsafe-UnsafeputOrderedObjectTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputOrderedObjectTest)
+run(UnsafeputOrderedObjectTest)
diff --git a/testsuite/java_test/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/UnsafeputShortTest.java b/testsuite/java_test/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/UnsafeputShortTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f90c2d7b49add050b86a2d0244e78f3aacd4810f
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/UnsafeputShortTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafeputShortTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetShortTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeputShortTest.res -= 2;
+        }
+        if (result == 3 && UnsafeputShortTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetShortTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        short result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie28.class.getDeclaredField("date");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie28();
+            result = unsafe.getShort(obj, offset);
+            short s = 10;
+            unsafe.putShort(obj, offset, s);
+            result = unsafe.getShort(obj, offset);
+            if(result == 10){
+                UnsafeputShortTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie28{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+    private char favorite = '7';
+    private short date = 6;
+    private double grade = 99.99;
+    private float aFloat = 66.66f;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/expected.txt b/testsuite/java_test/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/test.cfg b/testsuite/java_test/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..53972f83427c2280ea639d7d0cfb0564a44f5e99
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0047-rt-unsafe-UnsafeputShortTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeputShortTest)
+run(UnsafeputShortTest)
diff --git a/testsuite/java_test/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/UnsafesetMemoryTest.java b/testsuite/java_test/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/UnsafesetMemoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fdf08a74ee397eb56a2f74006d88a20306789f38
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/UnsafesetMemoryTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafesetMemoryTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafesetMemoryTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafesetMemoryTest.res -= 2;
+        }
+        if (result == 3 && UnsafesetMemoryTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafesetMemoryTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        byte result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(4);
+//            System.out.println(address);
+            byte b = 127;
+            unsafe.setMemory(address, 4L, b);
+            result = unsafe.getByte(address);
+//            System.out.println(result);
+            if(result == b){
+                UnsafesetMemoryTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/expected.txt b/testsuite/java_test/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/test.cfg b/testsuite/java_test/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..805b3f8b19227fdca72df080433ff34dc9203e62
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0048-rt-unsafe-UnsafesetMemoryTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafesetMemoryTest)
+run(UnsafesetMemoryTest)
diff --git a/testsuite/java_test/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/UnsafegetByteTest.java b/testsuite/java_test/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/UnsafegetByteTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ddd1f5efb35391ef06473fe32d670104da6f6e19
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/UnsafegetByteTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+public class UnsafegetByteTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetByteTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetByteTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetByteTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetByteTest_1(){
+        Unsafe unsafe;
+        Field field;
+        Long offset;
+        Field param;
+        Object obj;
+        byte result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            param = Billie23.class.getDeclaredField("length");
+            offset = unsafe.objectFieldOffset(param);
+            obj = new Billie23();
+            result = unsafe.getByte(obj, offset);
+            if(result == 7){
+                UnsafegetByteTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
+class Billie23{
+    public int height = 8;
+    private String[] color = {"black","white"};
+    private String owner = "Me";
+    private byte length = 0x7;
+    private String[] water = {"day","wet"};
+    private long weight = 100L;
+    private volatile int age = 18;
+    private volatile long birth = 20010214L;
+    private volatile String lastname = "eilish";
+    private boolean gender  = false;
+}
diff --git a/testsuite/java_test/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/expected.txt b/testsuite/java_test/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/test.cfg b/testsuite/java_test/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..f5df4fe7a482ae69ad476144a108d7be83ede521
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0850-rt-unsafe-UnsafegetByteTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetByteTest)
+run(UnsafegetByteTest)
diff --git a/testsuite/java_test/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/UnsafegetLongByAddressTest.java b/testsuite/java_test/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/UnsafegetLongByAddressTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ca6231fef45fbd6d7555c37266148e85222b997f
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/UnsafegetLongByAddressTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafegetLongByAddressTest {
+    private static int res = 99;
+    public static void main(String[] args){
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out){
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafegetLongByAddressTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafegetLongByAddressTest.res -= 2;
+        }
+        if (result == 3 && UnsafegetLongByAddressTest.res == 97){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafegetLongByAddressTest_1(){
+        Unsafe unsafe;
+        Field field;
+        long address;
+        long result;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe)field.get(null);
+            address = unsafe.allocateMemory(8);
+//            System.out.println(address);
+            long l = 111L;
+            unsafe.putLong(address, l);
+            result = unsafe.getLong(address);
+//            System.out.println(result);
+            if(result == l){
+                UnsafegetLongByAddressTest.res -= 2;
+            }
+        }catch (NoSuchFieldException e){
+            e.printStackTrace();
+            return 40;
+        }catch (IllegalAccessException e){
+            e.printStackTrace();
+            return 41;
+        }
+        return 3;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/expected.txt b/testsuite/java_test/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/test.cfg b/testsuite/java_test/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..4b506eccc9034408be66eb87a154799bcf18fc7b
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/RT0909-rt-unsafe-UnsafegetLongByAddressTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafegetLongByAddressTest)
+run(UnsafegetLongByAddressTest)
diff --git a/testsuite/java_test/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/UnsafeunparkTest.java b/testsuite/java_test/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/UnsafeunparkTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ea73b6cbd057dcc2cc0ddf2633dad80a0368725
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/UnsafeunparkTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+*/
+
+
+import sun.misc.Unsafe;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+public class UnsafeunparkTest {
+    private static int res = 99;
+    private static int flag = 0;
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println(run(args, System.out));
+    }
+    private static int run(String[] args, PrintStream out) throws InterruptedException {
+        int result = 2/*STATUS_FAILED*/;
+        try {
+            result = UnsafeunparkTest_1();
+        } catch(Exception e){
+            e.printStackTrace();
+            UnsafeunparkTest.res -= 2;
+        }
+        Thread.sleep(4000);
+//        System.out.println("===================="+flag);
+        if (result == 3 && UnsafeunparkTest.flag == 1214210){
+            result =0;
+        }
+        return result;
+    }
+    private static int UnsafeunparkTest_1(){
+        int result = 3;
+        Field field;
+        try{
+            field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            Unsafe unsafe = (Unsafe)field.get(null);
+            Thread boyThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+//                    System.out.println("boy: 我要吃鸡");
+                    flag += (flag+1)*10;
+//                    System.out.println(flag);
+                    unsafe.park(false,0);
+//                    System.out.println("boy: park1");
+                    flag += (flag+3)*1000;
+//                    System.out.println(flag);
+//                    unsafe.park(false,0); // 第二次会阻塞住，因为只有一个permit
+//                    System.out.println("boy: park2");
+//                    System.out.println("boy: 不会再执行了");
+                }
+            });
+            Thread girlThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        Thread.sleep(3000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+//                    System.out.println("girl: OK");
+                    flag += (flag+2)*100;
+//                    System.out.println(flag);
+                    unsafe.unpark(boyThread); // unpark两次，但是permit不会叠加
+                    unsafe.unpark(boyThread);
+                }
+            });
+            boyThread.start();
+            girlThread.start();
+        }catch (Exception e){
+            e.printStackTrace();
+            return 40;
+        }
+        return result;
+    }
+}
diff --git a/testsuite/java_test/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/expected.txt b/testsuite/java_test/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/expected.txt
@@ -0,0 +1 @@
+0
diff --git a/testsuite/java_test/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/test.cfg b/testsuite/java_test/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/test.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..97bfaf4b9130cb6db8e1c527acdbb5ddccfe3f94
--- /dev/null
+++ b/testsuite/java_test/unsafe_test/issue-RT0935-rt-unsafe-UnsafeunparkTest/test.cfg
@@ -0,0 +1,2 @@
+compile(UnsafeunparkTest)
+run(UnsafeunparkTest)
diff --git a/third_party/aosp_10.0.0_r35 b/third_party/aosp_10.0.0_r35
new file mode 120000
index 0000000000000000000000000000000000000000..96990686a6809dca17a855e5f842eef739fbe518
--- /dev/null
+++ b/third_party/aosp_10.0.0_r35
@@ -0,0 +1 @@
+../../ThirdParty/aosp_10.0.0_r35
\ No newline at end of file
diff --git a/third_party/bounds_checking_function b/third_party/bounds_checking_function
new file mode 120000
index 0000000000000000000000000000000000000000..0a3a14f49f7bcf8a1438acff8d68c7ea23f80538
--- /dev/null
+++ b/third_party/bounds_checking_function
@@ -0,0 +1 @@
+../../ThirdParty/bounds_checking_function
\ No newline at end of file
diff --git a/tools/README b/tools/README
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tools/build_and_run.sh b/tools/build_and_run.sh
new file mode 100755
index 0000000000000000000000000000000000000000..41e0e4685c833b769b628bd07dec2946e7ecf369
--- /dev/null
+++ b/tools/build_and_run.sh
@@ -0,0 +1,48 @@
+#!/bin/bash
+#
+# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
+#
+# Licensed under the Mulan Permissive Software License v2.
+# You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+# You may obtain a copy of MulanPSL - 2.0 at:
+#
+#   https://opensource.org/licenses/MulanPSL-2.0
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the MulanPSL - 2.0 for more details.
+#
+
+set -e
+
+if [ -z "$MAPLE_ROOT" ]; then
+  echo "Please \"source build/envsetup.sh\" to setup environment"
+  exit 1
+fi
+
+today=$(date +%Y-%m-%d-%H_%M)
+
+cd $MAPLE_ROOT
+make clean
+
+mkdir -p output
+REPORT=output/report.txt
+touch $REPORT
+
+echo $today >> $REPORT
+
+echo "start OpenArkCompiler build and testing..." >> $REPORT
+
+echo "make setup" >> $REPORT
+make setup
+echo "make" >> $REPORT
+make
+
+echo "make libcore"
+make libcore
+echo "make testall" >> $REPORT
+make testall 2>> $REPORT
+
+cat $REPORT
+echo "end OpenArkCompiler ..."
diff --git a/src/MapleFE/ladetect/build.sh b/tools/gtest_lib/example/CMakeLists.txt
old mode 100755
new mode 100644
similarity index 38%
rename from src/MapleFE/ladetect/build.sh
rename to tools/gtest_lib/example/CMakeLists.txt
index 47c2c86d37e31dbf089ebe557c817e8395d39bcc..00c18dc0aa0964a6b998f66fff75eb3085567c17
--- a/src/MapleFE/ladetect/build.sh
+++ b/tools/gtest_lib/example/CMakeLists.txt
@@ -1,39 +1,26 @@
-# Copyright (C) [2020] Futurewei Technologies, Inc. All rights reverved.
-# 
-# OpenArkFE is licensed under the Mulan PSL v2.
+#
+# Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under Mulan PSL v2.
 # You can use this software according to the terms and conditions of the Mulan PSL v2.
 # You may obtain a copy of Mulan PSL v2 at:
-# 
-#  http://license.coscl.org.cn/MulanPSL2
-# 
+#
+#     http://license.coscl.org.cn/MulanPSL2
+#
 # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
 # FIT FOR A PARTICULAR PURPOSE.
 # See the Mulan PSL v2 for more details.
-# 
-
-#!/bin/bash
-
-# Usage:
-#  ./build.sh [LANG]
 #
-# eg. ./build.sh java
-
-#rm -rf $BUILDDIR/ladetect
-#rm -rf $BUILDDIR/ladetect/$1
-
-rm -rf $1
-mkdir -p $1
 
-cp ../$1/include/gen_*.h $1/
-cp ../$1/src/gen_*.cpp $1/
+cmake_minimum_required(VERSION 3.16)
+project(gtest_example)
 
-# The two generated files shouldn't be taken in.
-rm $1/gen_lookahead.h
-rm $1/gen_lookahead.cpp
-rm $1/gen_recursion.h
-rm $1/gen_recursion.cpp
+#set(CMAKE_CXX_STANDARD 17)
+find_package(Threads REQUIRED)
 
-mkdir -p $BUILDDIR/ladetect
-mkdir -p $BUILDDIR/ladetect/$1
-make LANG=$1
+add_executable(gtest_example test_example.cpp)
+target_link_libraries(gtest_example PUBLIC ${CMAKE_SOURCE_DIR}/../lib/libgtest.a
+                                           ${CMAKE_SOURCE_DIR}/../lib/libgtest_main.a
+                                           Threads::Threads)
+target_include_directories(gtest_example PUBLIC ../include)
diff --git a/tools/gtest_lib/example/test_example.cpp b/tools/gtest_lib/example/test_example.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2fe89414efdb0d05a04c209acd4835814416722e
--- /dev/null
+++ b/tools/gtest_lib/example/test_example.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include <gtest/gtest.h>
+
+static int TestFunc(int in) {
+  return in * 7;
+}
+
+// Demonstrate some basic assertions.
+TEST(HelloTest, BasicAssertions) {
+  // Expect two strings not to be equal.
+  EXPECT_STRNE("hello", "world");
+
+  // Expect equality.
+  EXPECT_EQ(TestFunc(6), 42);
+}
diff --git a/tools/gtest_lib/include/gmock/gmock-actions.h b/tools/gtest_lib/include/gmock/gmock-actions.h
new file mode 100644
index 0000000000000000000000000000000000000000..70c325a4648fa6f019093763f6f8cb61472dc74e
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/gmock-actions.h
@@ -0,0 +1,1687 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// The ACTION* family of macros can be used in a namespace scope to
+// define custom actions easily.  The syntax:
+//
+//   ACTION(name) { statements; }
+//
+// will define an action with the given name that executes the
+// statements.  The value returned by the statements will be used as
+// the return value of the action.  Inside the statements, you can
+// refer to the K-th (0-based) argument of the mock function by
+// 'argK', and refer to its type by 'argK_type'.  For example:
+//
+//   ACTION(IncrementArg1) {
+//     arg1_type temp = arg1;
+//     return ++(*temp);
+//   }
+//
+// allows you to write
+//
+//   ...WillOnce(IncrementArg1());
+//
+// You can also refer to the entire argument tuple and its type by
+// 'args' and 'args_type', and refer to the mock function type and its
+// return type by 'function_type' and 'return_type'.
+//
+// Note that you don't need to specify the types of the mock function
+// arguments.  However rest assured that your code is still type-safe:
+// you'll get a compiler error if *arg1 doesn't support the ++
+// operator, or if the type of ++(*arg1) isn't compatible with the
+// mock function's return type, for example.
+//
+// Sometimes you'll want to parameterize the action.   For that you can use
+// another macro:
+//
+//   ACTION_P(name, param_name) { statements; }
+//
+// For example:
+//
+//   ACTION_P(Add, n) { return arg0 + n; }
+//
+// will allow you to write:
+//
+//   ...WillOnce(Add(5));
+//
+// Note that you don't need to provide the type of the parameter
+// either.  If you need to reference the type of a parameter named
+// 'foo', you can write 'foo_type'.  For example, in the body of
+// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
+// of 'n'.
+//
+// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
+// multi-parameter actions.
+//
+// For the purpose of typing, you can view
+//
+//   ACTION_Pk(Foo, p1, ..., pk) { ... }
+//
+// as shorthand for
+//
+//   template <typename p1_type, ..., typename pk_type>
+//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
+//
+// In particular, you can provide the template type arguments
+// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
+// although usually you can rely on the compiler to infer the types
+// for you automatically.  You can assign the result of expression
+// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
+// pk_type>.  This can be useful when composing actions.
+//
+// You can also overload actions with different numbers of parameters:
+//
+//   ACTION_P(Plus, a) { ... }
+//   ACTION_P2(Plus, a, b) { ... }
+//
+// While it's tempting to always use the ACTION* macros when defining
+// a new action, you should also consider implementing ActionInterface
+// or using MakePolymorphicAction() instead, especially if you need to
+// use the action a lot.  While these approaches require more work,
+// they give you more control on the types of the mock function
+// arguments and the action parameters, which in general leads to
+// better compiler error messages that pay off in the long run.  They
+// also allow overloading actions based on parameter types (as opposed
+// to just based on the number of parameters).
+//
+// CAVEAT:
+//
+// ACTION*() can only be used in a namespace scope as templates cannot be
+// declared inside of a local class.
+// Users can, however, define any local functors (e.g. a lambda) that
+// can be used as actions.
+//
+// MORE INFORMATION:
+//
+// To learn more about using these macros, please search for 'ACTION' on
+// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+
+#ifndef _WIN32_WCE
+# include <errno.h>
+#endif
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+#include "gmock/internal/gmock-pp.h"
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+namespace testing {
+
+// To implement an action Foo, define:
+//   1. a class FooAction that implements the ActionInterface interface, and
+//   2. a factory function that creates an Action object from a
+//      const FooAction*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Action objects can now be copied like plain values.
+
+namespace internal {
+
+// BuiltInDefaultValueGetter<T, true>::Get() returns a
+// default-constructed T value.  BuiltInDefaultValueGetter<T,
+// false>::Get() crashes with an error.
+//
+// This primary template is used when kDefaultConstructible is true.
+template <typename T, bool kDefaultConstructible>
+struct BuiltInDefaultValueGetter {
+  static T Get() { return T(); }
+};
+template <typename T>
+struct BuiltInDefaultValueGetter<T, false> {
+  static T Get() {
+    Assert(false, __FILE__, __LINE__,
+           "Default action undefined for the function return type.");
+    return internal::Invalid<T>();
+    // The above statement will never be reached, but is required in
+    // order for this function to compile.
+  }
+};
+
+// BuiltInDefaultValue<T>::Get() returns the "built-in" default value
+// for type T, which is NULL when T is a raw pointer type, 0 when T is
+// a numeric type, false when T is bool, or "" when T is string or
+// std::string.  In addition, in C++11 and above, it turns a
+// default-constructed T value if T is default constructible.  For any
+// other type T, the built-in default T value is undefined, and the
+// function will abort the process.
+template <typename T>
+class BuiltInDefaultValue {
+ public:
+  // This function returns true if and only if type T has a built-in default
+  // value.
+  static bool Exists() {
+    return ::std::is_default_constructible<T>::value;
+  }
+
+  static T Get() {
+    return BuiltInDefaultValueGetter<
+        T, ::std::is_default_constructible<T>::value>::Get();
+  }
+};
+
+// This partial specialization says that we use the same built-in
+// default value for T and const T.
+template <typename T>
+class BuiltInDefaultValue<const T> {
+ public:
+  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
+  static T Get() { return BuiltInDefaultValue<T>::Get(); }
+};
+
+// This partial specialization defines the default values for pointer
+// types.
+template <typename T>
+class BuiltInDefaultValue<T*> {
+ public:
+  static bool Exists() { return true; }
+  static T* Get() { return nullptr; }
+};
+
+// The following specializations define the default values for
+// specific types we care about.
+#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
+  template <> \
+  class BuiltInDefaultValue<type> { \
+   public: \
+    static bool Exists() { return true; } \
+    static type Get() { return value; } \
+  }
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');
+
+// There's no need for a default action for signed wchar_t, as that
+// type is the same as wchar_t for gcc, and invalid for MSVC.
+//
+// There's also no need for a default action for unsigned wchar_t, as
+// that type is the same as unsigned int for gcc, and invalid for
+// MSVC.
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
+#endif
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
+
+#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
+
+// Simple two-arg form of std::disjunction.
+template <typename P, typename Q>
+using disjunction = typename ::std::conditional<P::value, P, Q>::type;
+
+}  // namespace internal
+
+// When an unexpected function call is encountered, Google Mock will
+// let it return a default value if the user has specified one for its
+// return type, or if the return type has a built-in default value;
+// otherwise Google Mock won't know what value to return and will have
+// to abort the process.
+//
+// The DefaultValue<T> class allows a user to specify the
+// default value for a type T that is both copyable and publicly
+// destructible (i.e. anything that can be used as a function return
+// type).  The usage is:
+//
+//   // Sets the default value for type T to be foo.
+//   DefaultValue<T>::Set(foo);
+template <typename T>
+class DefaultValue {
+ public:
+  // Sets the default value for type T; requires T to be
+  // copy-constructable and have a public destructor.
+  static void Set(T x) {
+    delete producer_;
+    producer_ = new FixedValueProducer(x);
+  }
+
+  // Provides a factory function to be called to generate the default value.
+  // This method can be used even if T is only move-constructible, but it is not
+  // limited to that case.
+  typedef T (*FactoryFunction)();
+  static void SetFactory(FactoryFunction factory) {
+    delete producer_;
+    producer_ = new FactoryValueProducer(factory);
+  }
+
+  // Unsets the default value for type T.
+  static void Clear() {
+    delete producer_;
+    producer_ = nullptr;
+  }
+
+  // Returns true if and only if the user has set the default value for type T.
+  static bool IsSet() { return producer_ != nullptr; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();
+  }
+
+  // Returns the default value for type T if the user has set one;
+  // otherwise returns the built-in default value. Requires that Exists()
+  // is true, which ensures that the return value is well-defined.
+  static T Get() {
+    return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get()
+                                : producer_->Produce();
+  }
+
+ private:
+  class ValueProducer {
+   public:
+    virtual ~ValueProducer() {}
+    virtual T Produce() = 0;
+  };
+
+  class FixedValueProducer : public ValueProducer {
+   public:
+    explicit FixedValueProducer(T value) : value_(value) {}
+    T Produce() override { return value_; }
+
+   private:
+    const T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
+  };
+
+  class FactoryValueProducer : public ValueProducer {
+   public:
+    explicit FactoryValueProducer(FactoryFunction factory)
+        : factory_(factory) {}
+    T Produce() override { return factory_(); }
+
+   private:
+    const FactoryFunction factory_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
+  };
+
+  static ValueProducer* producer_;
+};
+
+// This partial specialization allows a user to set default values for
+// reference types.
+template <typename T>
+class DefaultValue<T&> {
+ public:
+  // Sets the default value for type T&.
+  static void Set(T& x) {  // NOLINT
+    address_ = &x;
+  }
+
+  // Unsets the default value for type T&.
+  static void Clear() { address_ = nullptr; }
+
+  // Returns true if and only if the user has set the default value for type T&.
+  static bool IsSet() { return address_ != nullptr; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();
+  }
+
+  // Returns the default value for type T& if the user has set one;
+  // otherwise returns the built-in default value if there is one;
+  // otherwise aborts the process.
+  static T& Get() {
+    return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get()
+                               : *address_;
+  }
+
+ private:
+  static T* address_;
+};
+
+// This specialization allows DefaultValue<void>::Get() to
+// compile.
+template <>
+class DefaultValue<void> {
+ public:
+  static bool Exists() { return true; }
+  static void Get() {}
+};
+
+// Points to the user-set default value for type T.
+template <typename T>
+typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr;
+
+// Points to the user-set default value for type T&.
+template <typename T>
+T* DefaultValue<T&>::address_ = nullptr;
+
+// Implement this interface to define an action for function type F.
+template <typename F>
+class ActionInterface {
+ public:
+  typedef typename internal::Function<F>::Result Result;
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  ActionInterface() {}
+  virtual ~ActionInterface() {}
+
+  // Performs the action.  This method is not const, as in general an
+  // action can have side effects and be stateful.  For example, a
+  // get-the-next-element-from-the-collection action will need to
+  // remember the current element.
+  virtual Result Perform(const ArgumentTuple& args) = 0;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
+};
+
+// An Action<F> is a copyable and IMMUTABLE (except by assignment)
+// object that represents an action to be taken when a mock function
+// of type F is called.  The implementation of Action<T> is just a
+// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action!
+// You can view an object implementing ActionInterface<F> as a
+// concrete action (including its current state), and an Action<F>
+// object as a handle to it.
+template <typename F>
+class Action {
+  // Adapter class to allow constructing Action from a legacy ActionInterface.
+  // New code should create Actions from functors instead.
+  struct ActionAdapter {
+    // Adapter must be copyable to satisfy std::function requirements.
+    ::std::shared_ptr<ActionInterface<F>> impl_;
+
+    template <typename... Args>
+    typename internal::Function<F>::Result operator()(Args&&... args) {
+      return impl_->Perform(
+          ::std::forward_as_tuple(::std::forward<Args>(args)...));
+    }
+  };
+
+  template <typename G>
+  using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>;
+
+ public:
+  typedef typename internal::Function<F>::Result Result;
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  // Constructs a null Action.  Needed for storing Action objects in
+  // STL containers.
+  Action() {}
+
+  // Construct an Action from a specified callable.
+  // This cannot take std::function directly, because then Action would not be
+  // directly constructible from lambda (it would require two conversions).
+  template <
+      typename G,
+      typename = typename std::enable_if<internal::disjunction<
+          IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>,
+                                                        G>>::value>::type>
+  Action(G&& fun) {  // NOLINT
+    Init(::std::forward<G>(fun), IsCompatibleFunctor<G>());
+  }
+
+  // Constructs an Action from its implementation.
+  explicit Action(ActionInterface<F>* impl)
+      : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {}
+
+  // This constructor allows us to turn an Action<Func> object into an
+  // Action<F>, as long as F's arguments can be implicitly converted
+  // to Func's and Func's return type can be implicitly converted to F's.
+  template <typename Func>
+  explicit Action(const Action<Func>& action) : fun_(action.fun_) {}
+
+  // Returns true if and only if this is the DoDefault() action.
+  bool IsDoDefault() const { return fun_ == nullptr; }
+
+  // Performs the action.  Note that this method is const even though
+  // the corresponding method in ActionInterface is not.  The reason
+  // is that a const Action<F> means that it cannot be re-bound to
+  // another concrete action, not that the concrete action it binds to
+  // cannot change state.  (Think of the difference between a const
+  // pointer and a pointer to const.)
+  Result Perform(ArgumentTuple args) const {
+    if (IsDoDefault()) {
+      internal::IllegalDoDefault(__FILE__, __LINE__);
+    }
+    return internal::Apply(fun_, ::std::move(args));
+  }
+
+ private:
+  template <typename G>
+  friend class Action;
+
+  template <typename G>
+  void Init(G&& g, ::std::true_type) {
+    fun_ = ::std::forward<G>(g);
+  }
+
+  template <typename G>
+  void Init(G&& g, ::std::false_type) {
+    fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)};
+  }
+
+  template <typename FunctionImpl>
+  struct IgnoreArgs {
+    template <typename... Args>
+    Result operator()(const Args&...) const {
+      return function_impl();
+    }
+
+    FunctionImpl function_impl;
+  };
+
+  // fun_ is an empty function if and only if this is the DoDefault() action.
+  ::std::function<F> fun_;
+};
+
+// The PolymorphicAction class template makes it easy to implement a
+// polymorphic action (i.e. an action that can be used in mock
+// functions of than one type, e.g. Return()).
+//
+// To define a polymorphic action, a user first provides a COPYABLE
+// implementation class that has a Perform() method template:
+//
+//   class FooAction {
+//    public:
+//     template <typename Result, typename ArgumentTuple>
+//     Result Perform(const ArgumentTuple& args) const {
+//       // Processes the arguments and returns a result, using
+//       // std::get<N>(args) to get the N-th (0-based) argument in the tuple.
+//     }
+//     ...
+//   };
+//
+// Then the user creates the polymorphic action using
+// MakePolymorphicAction(object) where object has type FooAction.  See
+// the definition of Return(void) and SetArgumentPointee<N>(value) for
+// complete examples.
+template <typename Impl>
+class PolymorphicAction {
+ public:
+  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    return Action<F>(new MonomorphicImpl<F>(impl_));
+  }
+
+ private:
+  template <typename F>
+  class MonomorphicImpl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    Result Perform(const ArgumentTuple& args) override {
+      return impl_.template Perform<Result>(args);
+    }
+
+   private:
+    Impl impl_;
+  };
+
+  Impl impl_;
+};
+
+// Creates an Action from its implementation and returns it.  The
+// created Action object owns the implementation.
+template <typename F>
+Action<F> MakeAction(ActionInterface<F>* impl) {
+  return Action<F>(impl);
+}
+
+// Creates a polymorphic action from its implementation.  This is
+// easier to use than the PolymorphicAction<Impl> constructor as it
+// doesn't require you to explicitly write the template argument, e.g.
+//
+//   MakePolymorphicAction(foo);
+// vs
+//   PolymorphicAction<TypeOfFoo>(foo);
+template <typename Impl>
+inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
+  return PolymorphicAction<Impl>(impl);
+}
+
+namespace internal {
+
+// Helper struct to specialize ReturnAction to execute a move instead of a copy
+// on return. Useful for move-only types, but could be used on any type.
+template <typename T>
+struct ByMoveWrapper {
+  explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
+  T payload;
+};
+
+// Implements the polymorphic Return(x) action, which can be used in
+// any function that returns the type of x, regardless of the argument
+// types.
+//
+// Note: The value passed into Return must be converted into
+// Function<F>::Result when this action is cast to Action<F> rather than
+// when that action is performed. This is important in scenarios like
+//
+// MOCK_METHOD1(Method, T(U));
+// ...
+// {
+//   Foo foo;
+//   X x(&foo);
+//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
+// }
+//
+// In the example above the variable x holds reference to foo which leaves
+// scope and gets destroyed.  If copying X just copies a reference to foo,
+// that copy will be left with a hanging reference.  If conversion to T
+// makes a copy of foo, the above code is safe. To support that scenario, we
+// need to make sure that the type conversion happens inside the EXPECT_CALL
+// statement, and conversion of the result of Return to Action<T(U)> is a
+// good place for that.
+//
+// The real life example of the above scenario happens when an invocation
+// of gtl::Container() is passed into Return.
+//
+template <typename R>
+class ReturnAction {
+ public:
+  // Constructs a ReturnAction object from the value to be returned.
+  // 'value' is passed by value instead of by const reference in order
+  // to allow Return("string literal") to compile.
+  explicit ReturnAction(R value) : value_(new R(std::move(value))) {}
+
+  // This template type conversion operator allows Return(x) to be
+  // used in ANY function that returns x's type.
+  template <typename F>
+  operator Action<F>() const {  // NOLINT
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename Function<F>::Result Result;
+    GTEST_COMPILE_ASSERT_(
+        !std::is_reference<Result>::value,
+        use_ReturnRef_instead_of_Return_to_return_a_reference);
+    static_assert(!std::is_void<Result>::value,
+                  "Can't use Return() on an action expected to return `void`.");
+    return Action<F>(new Impl<R, F>(value_));
+  }
+
+ private:
+  // Implements the Return(x) action for a particular function type F.
+  template <typename R_, typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    // The implicit cast is necessary when Result has more than one
+    // single-argument constructor (e.g. Result is std::vector<int>) and R
+    // has a type conversion operator template.  In that case, value_(value)
+    // won't compile as the compiler doesn't known which constructor of
+    // Result to call.  ImplicitCast_ forces the compiler to convert R to
+    // Result without considering explicit constructors, thus resolving the
+    // ambiguity. value_ is then initialized using its copy constructor.
+    explicit Impl(const std::shared_ptr<R>& value)
+        : value_before_cast_(*value),
+          value_(ImplicitCast_<Result>(value_before_cast_)) {}
+
+    Result Perform(const ArgumentTuple&) override { return value_; }
+
+   private:
+    GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
+                          Result_cannot_be_a_reference_type);
+    // We save the value before casting just in case it is being cast to a
+    // wrapper type.
+    R value_before_cast_;
+    Result value_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
+  // move its contents instead.
+  template <typename R_, typename F>
+  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const std::shared_ptr<R>& wrapper)
+        : performed_(false), wrapper_(wrapper) {}
+
+    Result Perform(const ArgumentTuple&) override {
+      GTEST_CHECK_(!performed_)
+          << "A ByMove() action should only be performed once.";
+      performed_ = true;
+      return std::move(wrapper_->payload);
+    }
+
+   private:
+    bool performed_;
+    const std::shared_ptr<R> wrapper_;
+  };
+
+  const std::shared_ptr<R> value_;
+};
+
+// Implements the ReturnNull() action.
+class ReturnNullAction {
+ public:
+  // Allows ReturnNull() to be used in any pointer-returning function. In C++11
+  // this is enforced by returning nullptr, and in non-C++11 by asserting a
+  // pointer type on compile time.
+  template <typename Result, typename ArgumentTuple>
+  static Result Perform(const ArgumentTuple&) {
+    return nullptr;
+  }
+};
+
+// Implements the Return() action.
+class ReturnVoidAction {
+ public:
+  // Allows Return() to be used in any void-returning function.
+  template <typename Result, typename ArgumentTuple>
+  static void Perform(const ArgumentTuple&) {
+    static_assert(std::is_void<Result>::value, "Result should be void.");
+  }
+};
+
+// Implements the polymorphic ReturnRef(x) action, which can be used
+// in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefAction {
+ public:
+  // Constructs a ReturnRefAction object from the reference to be returned.
+  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRef(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // Asserts that the function return type is a reference.  This
+    // catches the user error of using ReturnRef(x) when Return(x)
+    // should be used, and generates some helpful error message.
+    GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
+                          use_Return_instead_of_ReturnRef_to_return_a_value);
+    return Action<F>(new Impl<F>(ref_));
+  }
+
+ private:
+  // Implements the ReturnRef(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(T& ref) : ref_(ref) {}  // NOLINT
+
+    Result Perform(const ArgumentTuple&) override { return ref_; }
+
+   private:
+    T& ref_;
+  };
+
+  T& ref_;
+};
+
+// Implements the polymorphic ReturnRefOfCopy(x) action, which can be
+// used in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefOfCopyAction {
+ public:
+  // Constructs a ReturnRefOfCopyAction object from the reference to
+  // be returned.
+  explicit ReturnRefOfCopyAction(const T& value) : value_(value) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRefOfCopy(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // Asserts that the function return type is a reference.  This
+    // catches the user error of using ReturnRefOfCopy(x) when Return(x)
+    // should be used, and generates some helpful error message.
+    GTEST_COMPILE_ASSERT_(
+        std::is_reference<Result>::value,
+        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
+    return Action<F>(new Impl<F>(value_));
+  }
+
+ private:
+  // Implements the ReturnRefOfCopy(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const T& value) : value_(value) {}  // NOLINT
+
+    Result Perform(const ArgumentTuple&) override { return value_; }
+
+   private:
+    T value_;
+  };
+
+  const T value_;
+};
+
+// Implements the polymorphic ReturnRoundRobin(v) action, which can be
+// used in any function that returns the element_type of v.
+template <typename T>
+class ReturnRoundRobinAction {
+ public:
+  explicit ReturnRoundRobinAction(std::vector<T> values) {
+    GTEST_CHECK_(!values.empty())
+        << "ReturnRoundRobin requires at least one element.";
+    state_->values = std::move(values);
+  }
+
+  template <typename... Args>
+  T operator()(Args&&...) const {
+     return state_->Next();
+  }
+
+ private:
+  struct State {
+    T Next() {
+      T ret_val = values[i++];
+      if (i == values.size()) i = 0;
+      return ret_val;
+    }
+
+    std::vector<T> values;
+    size_t i = 0;
+  };
+  std::shared_ptr<State> state_ = std::make_shared<State>();
+};
+
+// Implements the polymorphic DoDefault() action.
+class DoDefaultAction {
+ public:
+  // This template type conversion operator allows DoDefault() to be
+  // used in any function.
+  template <typename F>
+  operator Action<F>() const { return Action<F>(); }  // NOLINT
+};
+
+// Implements the Assign action to set a given pointer referent to a
+// particular value.
+template <typename T1, typename T2>
+class AssignAction {
+ public:
+  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
+
+  template <typename Result, typename ArgumentTuple>
+  void Perform(const ArgumentTuple& /* args */) const {
+    *ptr_ = value_;
+  }
+
+ private:
+  T1* const ptr_;
+  const T2 value_;
+};
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Implements the SetErrnoAndReturn action to simulate return from
+// various system calls and libc functions.
+template <typename T>
+class SetErrnoAndReturnAction {
+ public:
+  SetErrnoAndReturnAction(int errno_value, T result)
+      : errno_(errno_value),
+        result_(result) {}
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& /* args */) const {
+    errno = errno_;
+    return result_;
+  }
+
+ private:
+  const int errno_;
+  const T result_;
+};
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Implements the SetArgumentPointee<N>(x) action for any function
+// whose N-th argument (0-based) is a pointer to x's type.
+template <size_t N, typename A, typename = void>
+struct SetArgumentPointeeAction {
+  A value;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    *::std::get<N>(std::tie(args...)) = value;
+  }
+};
+
+// Implements the Invoke(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+struct InvokeMethodAction {
+  Class* const obj_ptr;
+  const MethodPtr method_ptr;
+
+  template <typename... Args>
+  auto operator()(Args&&... args) const
+      -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
+    return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
+  }
+};
+
+// Implements the InvokeWithoutArgs(f) action.  The template argument
+// FunctionImpl is the implementation type of f, which can be either a
+// function pointer or a functor.  InvokeWithoutArgs(f) can be used as an
+// Action<F> as long as f's type is compatible with F.
+template <typename FunctionImpl>
+struct InvokeWithoutArgsAction {
+  FunctionImpl function_impl;
+
+  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
+  // compatible with f.
+  template <typename... Args>
+  auto operator()(const Args&...) -> decltype(function_impl()) {
+    return function_impl();
+  }
+};
+
+// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+struct InvokeMethodWithoutArgsAction {
+  Class* const obj_ptr;
+  const MethodPtr method_ptr;
+
+  using ReturnType =
+      decltype((std::declval<Class*>()->*std::declval<MethodPtr>())());
+
+  template <typename... Args>
+  ReturnType operator()(const Args&...) const {
+    return (obj_ptr->*method_ptr)();
+  }
+};
+
+// Implements the IgnoreResult(action) action.
+template <typename A>
+class IgnoreResultAction {
+ public:
+  explicit IgnoreResultAction(const A& action) : action_(action) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename internal::Function<F>::Result Result;
+
+    // Asserts at compile time that F returns void.
+    static_assert(std::is_void<Result>::value, "Result type should be void.");
+
+    return Action<F>(new Impl<F>(action_));
+  }
+
+ private:
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const A& action) : action_(action) {}
+
+    void Perform(const ArgumentTuple& args) override {
+      // Performs the action and ignores its result.
+      action_.Perform(args);
+    }
+
+   private:
+    // Type OriginalFunction is the same as F except that its return
+    // type is IgnoredValue.
+    typedef typename internal::Function<F>::MakeResultIgnoredValue
+        OriginalFunction;
+
+    const Action<OriginalFunction> action_;
+  };
+
+  const A action_;
+};
+
+template <typename InnerAction, size_t... I>
+struct WithArgsAction {
+  InnerAction action;
+
+  // The inner action could be anything convertible to Action<X>.
+  // We use the conversion operator to detect the signature of the inner Action.
+  template <typename R, typename... Args>
+  operator Action<R(Args...)>() const {  // NOLINT
+    using TupleType = std::tuple<Args...>;
+    Action<R(typename std::tuple_element<I, TupleType>::type...)>
+        converted(action);
+
+    return [converted](Args... args) -> R {
+      return converted.Perform(std::forward_as_tuple(
+        std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
+    };
+  }
+};
+
+template <typename... Actions>
+struct DoAllAction {
+ private:
+  template <typename T>
+  using NonFinalType =
+      typename std::conditional<std::is_scalar<T>::value, T, const T&>::type;
+
+  template <typename ActionT, size_t... I>
+  std::vector<ActionT> Convert(IndexSequence<I...>) const {
+    return {ActionT(std::get<I>(actions))...};
+  }
+
+ public:
+  std::tuple<Actions...> actions;
+
+  template <typename R, typename... Args>
+  operator Action<R(Args...)>() const {  // NOLINT
+    struct Op {
+      std::vector<Action<void(NonFinalType<Args>...)>> converted;
+      Action<R(Args...)> last;
+      R operator()(Args... args) const {
+        auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...);
+        for (auto& a : converted) {
+          a.Perform(tuple_args);
+        }
+        return last.Perform(std::move(tuple_args));
+      }
+    };
+    return Op{Convert<Action<void(NonFinalType<Args>...)>>(
+                  MakeIndexSequence<sizeof...(Actions) - 1>()),
+              std::get<sizeof...(Actions) - 1>(actions)};
+  }
+};
+
+template <typename T, typename... Params>
+struct ReturnNewAction {
+  T* operator()() const {
+    return internal::Apply(
+        [](const Params&... unpacked_params) {
+          return new T(unpacked_params...);
+        },
+        params);
+  }
+  std::tuple<Params...> params;
+};
+
+template <size_t k>
+struct ReturnArgAction {
+  template <typename... Args>
+  auto operator()(Args&&... args) const -> decltype(std::get<k>(
+      std::forward_as_tuple(std::forward<Args>(args)...))) {
+    return std::get<k>(std::forward_as_tuple(std::forward<Args>(args)...));
+  }
+};
+
+template <size_t k, typename Ptr>
+struct SaveArgAction {
+  Ptr pointer;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    *pointer = std::get<k>(std::tie(args...));
+  }
+};
+
+template <size_t k, typename Ptr>
+struct SaveArgPointeeAction {
+  Ptr pointer;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    *pointer = *std::get<k>(std::tie(args...));
+  }
+};
+
+template <size_t k, typename T>
+struct SetArgRefereeAction {
+  T value;
+
+  template <typename... Args>
+  void operator()(Args&&... args) const {
+    using argk_type =
+        typename ::std::tuple_element<k, std::tuple<Args...>>::type;
+    static_assert(std::is_lvalue_reference<argk_type>::value,
+                  "Argument must be a reference type.");
+    std::get<k>(std::tie(args...)) = value;
+  }
+};
+
+template <size_t k, typename I1, typename I2>
+struct SetArrayArgumentAction {
+  I1 first;
+  I2 last;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    auto value = std::get<k>(std::tie(args...));
+    for (auto it = first; it != last; ++it, (void)++value) {
+      *value = *it;
+    }
+  }
+};
+
+template <size_t k>
+struct DeleteArgAction {
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    delete std::get<k>(std::tie(args...));
+  }
+};
+
+template <typename Ptr>
+struct ReturnPointeeAction {
+  Ptr pointer;
+  template <typename... Args>
+  auto operator()(const Args&...) const -> decltype(*pointer) {
+    return *pointer;
+  }
+};
+
+#if GTEST_HAS_EXCEPTIONS
+template <typename T>
+struct ThrowAction {
+  T exception;
+  // We use a conversion operator to adapt to any return type.
+  template <typename R, typename... Args>
+  operator Action<R(Args...)>() const {  // NOLINT
+    T copy = exception;
+    return [copy](Args...) -> R { throw copy; };
+  }
+};
+#endif  // GTEST_HAS_EXCEPTIONS
+
+}  // namespace internal
+
+// An Unused object can be implicitly constructed from ANY value.
+// This is handy when defining actions that ignore some or all of the
+// mock function arguments.  For example, given
+//
+//   MOCK_METHOD3(Foo, double(const string& label, double x, double y));
+//   MOCK_METHOD3(Bar, double(int index, double x, double y));
+//
+// instead of
+//
+//   double DistanceToOriginWithLabel(const string& label, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   double DistanceToOriginWithIndex(int index, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXPECT_CALL(mock, Foo("abc", _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithLabel));
+//   EXPECT_CALL(mock, Bar(5, _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithIndex));
+//
+// you could write
+//
+//   // We can declare any uninteresting argument as Unused.
+//   double DistanceToOrigin(Unused, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
+//   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
+typedef internal::IgnoredValue Unused;
+
+// Creates an action that does actions a1, a2, ..., sequentially in
+// each invocation. All but the last action will have a readonly view of the
+// arguments.
+template <typename... Action>
+internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
+    Action&&... action) {
+  return {std::forward_as_tuple(std::forward<Action>(action)...)};
+}
+
+// WithArg<k>(an_action) creates an action that passes the k-th
+// (0-based) argument of the mock function to an_action and performs
+// it.  It adapts an action accepting one argument to one that accepts
+// multiple arguments.  For convenience, we also provide
+// WithArgs<k>(an_action) (defined below) as a synonym.
+template <size_t k, typename InnerAction>
+internal::WithArgsAction<typename std::decay<InnerAction>::type, k>
+WithArg(InnerAction&& action) {
+  return {std::forward<InnerAction>(action)};
+}
+
+// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
+// the selected arguments of the mock function to an_action and
+// performs it.  It serves as an adaptor between actions with
+// different argument lists.
+template <size_t k, size_t... ks, typename InnerAction>
+internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...>
+WithArgs(InnerAction&& action) {
+  return {std::forward<InnerAction>(action)};
+}
+
+// WithoutArgs(inner_action) can be used in a mock function with a
+// non-empty argument list to perform inner_action, which takes no
+// argument.  In other words, it adapts an action accepting no
+// argument to one that accepts (and ignores) arguments.
+template <typename InnerAction>
+internal::WithArgsAction<typename std::decay<InnerAction>::type>
+WithoutArgs(InnerAction&& action) {
+  return {std::forward<InnerAction>(action)};
+}
+
+// Creates an action that returns 'value'.  'value' is passed by value
+// instead of const reference - otherwise Return("string literal")
+// will trigger a compiler error about using array as initializer.
+template <typename R>
+internal::ReturnAction<R> Return(R value) {
+  return internal::ReturnAction<R>(std::move(value));
+}
+
+// Creates an action that returns NULL.
+inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
+  return MakePolymorphicAction(internal::ReturnNullAction());
+}
+
+// Creates an action that returns from a void function.
+inline PolymorphicAction<internal::ReturnVoidAction> Return() {
+  return MakePolymorphicAction(internal::ReturnVoidAction());
+}
+
+// Creates an action that returns the reference to a variable.
+template <typename R>
+inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
+  return internal::ReturnRefAction<R>(x);
+}
+
+// Prevent using ReturnRef on reference to temporary.
+template <typename R, R* = nullptr>
+internal::ReturnRefAction<R> ReturnRef(R&&) = delete;
+
+// Creates an action that returns the reference to a copy of the
+// argument.  The copy is created when the action is constructed and
+// lives as long as the action.
+template <typename R>
+inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
+  return internal::ReturnRefOfCopyAction<R>(x);
+}
+
+// Modifies the parent action (a Return() action) to perform a move of the
+// argument instead of a copy.
+// Return(ByMove()) actions can only be executed once and will assert this
+// invariant.
+template <typename R>
+internal::ByMoveWrapper<R> ByMove(R x) {
+  return internal::ByMoveWrapper<R>(std::move(x));
+}
+
+// Creates an action that returns an element of `vals`. Calling this action will
+// repeatedly return the next value from `vals` until it reaches the end and
+// will restart from the beginning.
+template <typename T>
+internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) {
+  return internal::ReturnRoundRobinAction<T>(std::move(vals));
+}
+
+// Creates an action that returns an element of `vals`. Calling this action will
+// repeatedly return the next value from `vals` until it reaches the end and
+// will restart from the beginning.
+template <typename T>
+internal::ReturnRoundRobinAction<T> ReturnRoundRobin(
+    std::initializer_list<T> vals) {
+  return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals));
+}
+
+// Creates an action that does the default action for the give mock function.
+inline internal::DoDefaultAction DoDefault() {
+  return internal::DoDefaultAction();
+}
+
+// Creates an action that sets the variable pointed by the N-th
+// (0-based) function argument to 'value'.
+template <size_t N, typename T>
+internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) {
+  return {std::move(value)};
+}
+
+// The following version is DEPRECATED.
+template <size_t N, typename T>
+internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
+  return {std::move(value)};
+}
+
+// Creates an action that sets a pointer referent to a given value.
+template <typename T1, typename T2>
+PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
+  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
+}
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Creates an action that sets errno and returns the appropriate error.
+template <typename T>
+PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
+SetErrnoAndReturn(int errval, T result) {
+  return MakePolymorphicAction(
+      internal::SetErrnoAndReturnAction<T>(errval, result));
+}
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Various overloads for Invoke().
+
+// Legacy function.
+// Actions can now be implicitly constructed from callables. No need to create
+// wrapper objects.
+// This function exists for backwards compatibility.
+template <typename FunctionImpl>
+typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) {
+  return std::forward<FunctionImpl>(function_impl);
+}
+
+// Creates an action that invokes the given method on the given object
+// with the mock function's arguments.
+template <class Class, typename MethodPtr>
+internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
+                                                      MethodPtr method_ptr) {
+  return {obj_ptr, method_ptr};
+}
+
+// Creates an action that invokes 'function_impl' with no argument.
+template <typename FunctionImpl>
+internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
+InvokeWithoutArgs(FunctionImpl function_impl) {
+  return {std::move(function_impl)};
+}
+
+// Creates an action that invokes the given method on the given object
+// with no argument.
+template <class Class, typename MethodPtr>
+internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs(
+    Class* obj_ptr, MethodPtr method_ptr) {
+  return {obj_ptr, method_ptr};
+}
+
+// Creates an action that performs an_action and throws away its
+// result.  In other words, it changes the return type of an_action to
+// void.  an_action MUST NOT return void, or the code won't compile.
+template <typename A>
+inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
+  return internal::IgnoreResultAction<A>(an_action);
+}
+
+// Creates a reference wrapper for the given L-value.  If necessary,
+// you can explicitly specify the type of the reference.  For example,
+// suppose 'derived' is an object of type Derived, ByRef(derived)
+// would wrap a Derived&.  If you want to wrap a const Base& instead,
+// where Base is a base class of Derived, just write:
+//
+//   ByRef<const Base>(derived)
+//
+// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper.
+// However, it may still be used for consistency with ByMove().
+template <typename T>
+inline ::std::reference_wrapper<T> ByRef(T& l_value) {  // NOLINT
+  return ::std::reference_wrapper<T>(l_value);
+}
+
+// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
+// instance of type T, constructed on the heap with constructor arguments
+// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
+template <typename T, typename... Params>
+internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew(
+    Params&&... params) {
+  return {std::forward_as_tuple(std::forward<Params>(params)...)};
+}
+
+// Action ReturnArg<k>() returns the k-th argument of the mock function.
+template <size_t k>
+internal::ReturnArgAction<k> ReturnArg() {
+  return {};
+}
+
+// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
+// mock function to *pointer.
+template <size_t k, typename Ptr>
+internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) {
+  return {pointer};
+}
+
+// Action SaveArgPointee<k>(pointer) saves the value pointed to
+// by the k-th (0-based) argument of the mock function to *pointer.
+template <size_t k, typename Ptr>
+internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) {
+  return {pointer};
+}
+
+// Action SetArgReferee<k>(value) assigns 'value' to the variable
+// referenced by the k-th (0-based) argument of the mock function.
+template <size_t k, typename T>
+internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee(
+    T&& value) {
+  return {std::forward<T>(value)};
+}
+
+// Action SetArrayArgument<k>(first, last) copies the elements in
+// source range [first, last) to the array pointed to by the k-th
+// (0-based) argument, which can be either a pointer or an
+// iterator. The action does not take ownership of the elements in the
+// source range.
+template <size_t k, typename I1, typename I2>
+internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first,
+                                                             I2 last) {
+  return {first, last};
+}
+
+// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
+// function.
+template <size_t k>
+internal::DeleteArgAction<k> DeleteArg() {
+  return {};
+}
+
+// This action returns the value pointed to by 'pointer'.
+template <typename Ptr>
+internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
+  return {pointer};
+}
+
+// Action Throw(exception) can be used in a mock function of any type
+// to throw the given exception.  Any copyable value can be thrown.
+#if GTEST_HAS_EXCEPTIONS
+template <typename T>
+internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
+  return {std::forward<T>(exception)};
+}
+#endif  // GTEST_HAS_EXCEPTIONS
+
+namespace internal {
+
+// A macro from the ACTION* family (defined later in gmock-generated-actions.h)
+// defines an action that can be used in a mock function.  Typically,
+// these actions only care about a subset of the arguments of the mock
+// function.  For example, if such an action only uses the second
+// argument, it can be used in any mock function that takes >= 2
+// arguments where the type of the second argument is compatible.
+//
+// Therefore, the action implementation must be prepared to take more
+// arguments than it needs.  The ExcessiveArg type is used to
+// represent those excessive arguments.  In order to keep the compiler
+// error messages tractable, we define it in the testing namespace
+// instead of testing::internal.  However, this is an INTERNAL TYPE
+// and subject to change without notice, so a user MUST NOT USE THIS
+// TYPE DIRECTLY.
+struct ExcessiveArg {};
+
+// Builds an implementation of an Action<> for some particular signature, using
+// a class defined by an ACTION* macro.
+template <typename F, typename Impl> struct ActionImpl;
+
+template <typename Impl>
+struct ImplBase {
+  struct Holder {
+    // Allows each copy of the Action<> to get to the Impl.
+    explicit operator const Impl&() const { return *ptr; }
+    std::shared_ptr<Impl> ptr;
+  };
+  using type = typename std::conditional<std::is_constructible<Impl>::value,
+                                         Impl, Holder>::type;
+};
+
+template <typename R, typename... Args, typename Impl>
+struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
+  using Base = typename ImplBase<Impl>::type;
+  using function_type = R(Args...);
+  using args_type = std::tuple<Args...>;
+
+  ActionImpl() = default;  // Only defined if appropriate for Base.
+  explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} { }
+
+  R operator()(Args&&... arg) const {
+    static constexpr size_t kMaxArgs =
+        sizeof...(Args) <= 10 ? sizeof...(Args) : 10;
+    return Apply(MakeIndexSequence<kMaxArgs>{},
+                 MakeIndexSequence<10 - kMaxArgs>{},
+                 args_type{std::forward<Args>(arg)...});
+  }
+
+  template <std::size_t... arg_id, std::size_t... excess_id>
+  R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>,
+          const args_type& args) const {
+    // Impl need not be specific to the signature of action being implemented;
+    // only the implementing function body needs to have all of the specific
+    // types instantiated.  Up to 10 of the args that are provided by the
+    // args_type get passed, followed by a dummy of unspecified type for the
+    // remainder up to 10 explicit args.
+    static constexpr ExcessiveArg kExcessArg{};
+    return static_cast<const Impl&>(*this).template gmock_PerformImpl<
+        /*function_type=*/function_type, /*return_type=*/R,
+        /*args_type=*/args_type,
+        /*argN_type=*/typename std::tuple_element<arg_id, args_type>::type...>(
+        /*args=*/args, std::get<arg_id>(args)...,
+        ((void)excess_id, kExcessArg)...);
+  }
+};
+
+// Stores a default-constructed Impl as part of the Action<>'s
+// std::function<>. The Impl should be trivial to copy.
+template <typename F, typename Impl>
+::testing::Action<F> MakeAction() {
+  return ::testing::Action<F>(ActionImpl<F, Impl>());
+}
+
+// Stores just the one given instance of Impl.
+template <typename F, typename Impl>
+::testing::Action<F> MakeAction(std::shared_ptr<Impl> impl) {
+  return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl)));
+}
+
+#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
+  , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_           \
+  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
+      GMOCK_INTERNAL_ARG_UNUSED, , 10)
+
+#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \
+  const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)
+
+#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type
+#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \
+  GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))
+
+#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type
+#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))
+
+#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type
+#define GMOCK_ACTION_TYPE_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))
+
+#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \
+  , param##_type gmock_p##i
+#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))
+
+#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \
+  , std::forward<param##_type>(gmock_p##i)
+#define GMOCK_ACTION_GVALUE_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))
+
+#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \
+  , param(::std::forward<param##_type>(gmock_p##i))
+#define GMOCK_ACTION_INIT_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))
+
+#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param;
+#define GMOCK_ACTION_FIELD_PARAMS_(params) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)
+
+#define GMOCK_INTERNAL_ACTION(name, full_name, params)                        \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
+  class full_name {                                                           \
+   public:                                                                    \
+    explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))              \
+        : impl_(std::make_shared<gmock_Impl>(                                 \
+                GMOCK_ACTION_GVALUE_PARAMS_(params))) { }                     \
+    full_name(const full_name&) = default;                                    \
+    full_name(full_name&&) noexcept = default;                                \
+    template <typename F>                                                     \
+    operator ::testing::Action<F>() const {                                   \
+      return ::testing::internal::MakeAction<F>(impl_);                       \
+    }                                                                         \
+   private:                                                                   \
+    class gmock_Impl {                                                        \
+     public:                                                                  \
+      explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))           \
+          : GMOCK_ACTION_INIT_PARAMS_(params) {}                              \
+      template <typename function_type, typename return_type,                 \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
+      GMOCK_ACTION_FIELD_PARAMS_(params)                                      \
+    };                                                                        \
+    std::shared_ptr<const gmock_Impl> impl_;                                  \
+  };                                                                          \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
+  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                   \
+      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                             \
+    return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>(                      \
+        GMOCK_ACTION_GVALUE_PARAMS_(params));                                 \
+  }                                                                           \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
+  template <typename function_type, typename return_type, typename args_type, \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
+  return_type full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::      \
+  gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+}  // namespace internal
+
+// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored.
+#define ACTION(name)                                                          \
+  class name##Action {                                                        \
+   public:                                                                    \
+   explicit name##Action() noexcept {}                                        \
+   name##Action(const name##Action&) noexcept {}                              \
+    template <typename F>                                                     \
+    operator ::testing::Action<F>() const {                                   \
+      return ::testing::internal::MakeAction<F, gmock_Impl>();                \
+    }                                                                         \
+   private:                                                                   \
+    class gmock_Impl {                                                        \
+     public:                                                                  \
+      template <typename function_type, typename return_type,                 \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
+    };                                                                        \
+  };                                                                          \
+  inline name##Action name() GTEST_MUST_USE_RESULT_;                          \
+  inline name##Action name() { return name##Action(); }                       \
+  template <typename function_type, typename return_type, typename args_type, \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
+  return_type name##Action::gmock_Impl::gmock_PerformImpl(                    \
+      GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))
+
+#define ACTION_P2(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))
+
+#define ACTION_P3(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))
+
+#define ACTION_P4(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))
+
+#define ACTION_P5(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))
+
+#define ACTION_P6(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))
+
+#define ACTION_P7(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))
+
+#define ACTION_P8(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))
+
+#define ACTION_P9(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))
+
+#define ACTION_P10(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))
+
+}  // namespace testing
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
diff --git a/tools/gtest_lib/include/gmock/gmock-cardinalities.h b/tools/gtest_lib/include/gmock/gmock-cardinalities.h
new file mode 100644
index 0000000000000000000000000000000000000000..48196dd2f44dad6103952d3e0c8e7a88051c338b
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/gmock-cardinalities.h
@@ -0,0 +1,157 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used cardinalities.  More
+// cardinalities can be defined by the user implementing the
+// CardinalityInterface interface if necessary.
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+
+#include <limits.h>
+#include <memory>
+#include <ostream>  // NOLINT
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// To implement a cardinality Foo, define:
+//   1. a class FooCardinality that implements the
+//      CardinalityInterface interface, and
+//   2. a factory function that creates a Cardinality object from a
+//      const FooCardinality*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Cardinality objects can now be copied like plain values.
+
+// The implementation of a cardinality.
+class CardinalityInterface {
+ public:
+  virtual ~CardinalityInterface() {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  virtual int ConservativeLowerBound() const { return 0; }
+  virtual int ConservativeUpperBound() const { return INT_MAX; }
+
+  // Returns true if and only if call_count calls will satisfy this
+  // cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
+
+  // Returns true if and only if call_count calls will saturate this
+  // cardinality.
+  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+};
+
+// A Cardinality is a copyable and IMMUTABLE (except by assignment)
+// object that specifies how many times a mock function is expected to
+// be called.  The implementation of Cardinality is just a std::shared_ptr
+// to const CardinalityInterface. Don't inherit from Cardinality!
+class GTEST_API_ Cardinality {
+ public:
+  // Constructs a null cardinality.  Needed for storing Cardinality
+  // objects in STL containers.
+  Cardinality() {}
+
+  // Constructs a Cardinality from its implementation.
+  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
+  int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }
+
+  // Returns true if and only if call_count calls will satisfy this
+  // cardinality.
+  bool IsSatisfiedByCallCount(int call_count) const {
+    return impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Returns true if and only if call_count calls will saturate this
+  // cardinality.
+  bool IsSaturatedByCallCount(int call_count) const {
+    return impl_->IsSaturatedByCallCount(call_count);
+  }
+
+  // Returns true if and only if call_count calls will over-saturate this
+  // cardinality, i.e. exceed the maximum number of allowed calls.
+  bool IsOverSaturatedByCallCount(int call_count) const {
+    return impl_->IsSaturatedByCallCount(call_count) &&
+        !impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Describes self to an ostream
+  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
+
+  // Describes the given actual call count to an ostream.
+  static void DescribeActualCallCountTo(int actual_call_count,
+                                        ::std::ostream* os);
+
+ private:
+  std::shared_ptr<const CardinalityInterface> impl_;
+};
+
+// Creates a cardinality that allows at least n calls.
+GTEST_API_ Cardinality AtLeast(int n);
+
+// Creates a cardinality that allows at most n calls.
+GTEST_API_ Cardinality AtMost(int n);
+
+// Creates a cardinality that allows any number of calls.
+GTEST_API_ Cardinality AnyNumber();
+
+// Creates a cardinality that allows between min and max calls.
+GTEST_API_ Cardinality Between(int min, int max);
+
+// Creates a cardinality that allows exactly n calls.
+GTEST_API_ Cardinality Exactly(int n);
+
+// Creates a cardinality from its implementation.
+inline Cardinality MakeCardinality(const CardinalityInterface* c) {
+  return Cardinality(c);
+}
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
diff --git a/tools/gtest_lib/include/gmock/gmock-function-mocker.h b/tools/gtest_lib/include/gmock/gmock-function-mocker.h
new file mode 100644
index 0000000000000000000000000000000000000000..2de1d41b1a2bd6ae5aa6e3773e6d046d6d1ed1cd
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/gmock-function-mocker.h
@@ -0,0 +1,514 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements MOCK_METHOD.
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
+
+#include <type_traits>  // IWYU pragma: keep
+#include <utility>      // IWYU pragma: keep
+
+#include "gmock/gmock-spec-builders.h"
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-pp.h"
+
+namespace testing {
+namespace internal {
+template <typename T>
+using identity_t = T;
+
+template <typename Pattern>
+struct ThisRefAdjuster {
+  template <typename T>
+  using AdjustT = typename std::conditional<
+      std::is_const<typename std::remove_reference<Pattern>::type>::value,
+      typename std::conditional<std::is_lvalue_reference<Pattern>::value,
+                                const T&, const T&&>::type,
+      typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&,
+                                T&&>::type>::type;
+
+  template <typename MockType>
+  static AdjustT<MockType> Adjust(const MockType& mock) {
+    return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock));
+  }
+};
+
+constexpr bool PrefixOf(const char* a, const char* b) {
+  return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1));
+}
+
+template <int N, int M>
+constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) {
+  return N <= M && internal::PrefixOf(prefix, str);
+}
+
+template <int N, int M>
+constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) {
+  return N <= M && internal::PrefixOf(suffix, str + M - N);
+}
+
+template <int N, int M>
+constexpr bool Equals(const char (&a)[N], const char (&b)[M]) {
+  return N == M && internal::PrefixOf(a, b);
+}
+
+template <int N>
+constexpr bool ValidateSpec(const char (&spec)[N]) {
+  return internal::Equals("const", spec) ||
+         internal::Equals("override", spec) ||
+         internal::Equals("final", spec) ||
+         internal::Equals("noexcept", spec) ||
+         (internal::StartsWith("noexcept(", spec) &&
+          internal::EndsWith(")", spec)) ||
+         internal::Equals("ref(&)", spec) ||
+         internal::Equals("ref(&&)", spec) ||
+         (internal::StartsWith("Calltype(", spec) &&
+          internal::EndsWith(")", spec));
+}
+
+}  // namespace internal
+
+// The style guide prohibits "using" statements in a namespace scope
+// inside a header file.  However, the FunctionMocker class template
+// is meant to be defined in the ::testing namespace.  The following
+// line is just a trick for working around a bug in MSVC 8.0, which
+// cannot handle it if we define FunctionMocker in ::testing.
+using internal::FunctionMocker;
+}  // namespace testing
+
+#define MOCK_METHOD(...) \
+  GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \
+  GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ())
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)  \
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);                                \
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);                                \
+  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                   \
+      GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));        \
+  GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)                                  \
+  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                         \
+      GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec),  \
+      GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \
+      GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec),                             \
+      GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Spec),                             \
+      GMOCK_INTERNAL_GET_REF_SPEC(_Spec),                                  \
+      (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)))
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_WRONG_ARITY(...)                                      \
+  static_assert(                                                             \
+      false,                                                                 \
+      "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, "             \
+      "_MethodName, _Args and optionally _Spec. _Args and _Spec must be "    \
+      "enclosed in parentheses. If _Ret is a type with unprotected commas, " \
+      "it must also be enclosed in parentheses.")
+
+#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \
+  static_assert(                                  \
+      GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple),        \
+      GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.")
+
+#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...)                 \
+  static_assert(                                                       \
+      std::is_function<__VA_ARGS__>::value,                            \
+      "Signature must be a function type, maybe return type contains " \
+      "unprotected comma.");                                           \
+  static_assert(                                                       \
+      ::testing::tuple_size<typename ::testing::internal::Function<    \
+              __VA_ARGS__>::ArgumentTuple>::value == _N,               \
+      "This method does not take " GMOCK_PP_STRINGIZE(                 \
+          _N) " arguments. Parenthesize all types with unprotected commas.")
+
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness,           \
+                                        _Override, _Final, _NoexceptSpec,      \
+                                        _CallType, _RefSpec, _Signature)       \
+  typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS(               \
+      _Signature)>::Result                                                     \
+  GMOCK_INTERNAL_EXPAND(_CallType)                                             \
+      _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N))   \
+          GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec              \
+          GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) {    \
+    GMOCK_MOCKER_(_N, _Constness, _MethodName)                                 \
+        .SetOwnerAndName(this, #_MethodName);                                  \
+    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
+        .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N));  \
+  }                                                                            \
+  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
+      GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N))       \
+      GMOCK_PP_IF(_Constness, const, ) _RefSpec {                              \
+    GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this);            \
+    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
+        .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N));         \
+  }                                                                            \
+  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
+      const ::testing::internal::WithoutMatchers&,                             \
+      GMOCK_PP_IF(_Constness, const, )::testing::internal::Function<           \
+          GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \
+    return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF(                   \
+        _Constness, const, ) int _RefSpec>::Adjust(*this)                      \
+        .gmock_##_MethodName(GMOCK_PP_REPEAT(                                  \
+            GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N));               \
+  }                                                                            \
+  mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)>        \
+      GMOCK_MOCKER_(_N, _Constness, _MethodName)
+
+#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__
+
+// Valid modifiers.
+#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple))
+
+#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \
+  GMOCK_PP_HAS_COMMA(                       \
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple))
+
+#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple))
+
+#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple)
+
+#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem)          \
+  GMOCK_PP_IF(                                                          \
+      GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \
+      _elem, )
+
+#define GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE, ~, _Tuple)
+
+#define GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE(_i, _, _elem)          \
+  GMOCK_PP_IF(                                                          \
+      GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem)), \
+      GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )
+
+#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple)
+
+#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem)                       \
+  GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \
+              GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )
+
+#ifdef GMOCK_INTERNAL_STRICT_SPEC_ASSERT
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \
+  static_assert(                                                     \
+      ::testing::internal::ValidateSpec(GMOCK_PP_STRINGIZE(_elem)),  \
+      "Token \'" GMOCK_PP_STRINGIZE(                                 \
+          _elem) "\' cannot be recognized as a valid specification " \
+                 "modifier. Is a ',' missing?");
+#else
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)                 \
+  static_assert(                                                               \
+      (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +         \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) +      \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +         \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) +      \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) +           \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem))) == 1, \
+      GMOCK_PP_STRINGIZE(                                                      \
+          _elem) " cannot be recognized as a valid specification modifier.");
+#endif  // GMOCK_INTERNAL_STRICT_SPEC_ASSERT
+
+// Modifiers implementation.
+#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_CONST_I_const ,
+
+#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override ,
+
+#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_FINAL_I_final ,
+
+#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept ,
+
+#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_REF_I_ref ,
+
+#define GMOCK_INTERNAL_UNPACK_ref(x) x
+
+#define GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CALLTYPE_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_CALLTYPE_I_Calltype ,
+
+#define GMOCK_INTERNAL_UNPACK_Calltype(...) __VA_ARGS__
+
+// Note: The use of `identity_t` here allows _Ret to represent return types that
+// would normally need to be specified in a different way. For example, a method
+// returning a function pointer must be written as
+//
+// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...)
+//
+// But we only support placing the return type at the beginning. To handle this,
+// we wrap all calls in identity_t, so that a declaration will be expanded to
+//
+// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...)
+//
+// This allows us to work around the syntactic oddities of function/method
+// types.
+#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)                                 \
+  ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \
+                                              GMOCK_PP_REMOVE_PARENS,         \
+                                              GMOCK_PP_IDENTITY)(_Ret)>(      \
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args))
+
+#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem)                          \
+  GMOCK_PP_COMMA_IF(_i)                                                \
+  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \
+              GMOCK_PP_IDENTITY)                                       \
+  (_elem)
+
+#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _)            \
+  GMOCK_PP_COMMA_IF(_i)                                        \
+  GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
+  gmock_a##_i
+
+#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \
+  GMOCK_PP_COMMA_IF(_i)                               \
+  ::std::forward<GMOCK_INTERNAL_ARG_O(                \
+      _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i)
+
+#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _)        \
+  GMOCK_PP_COMMA_IF(_i)                                            \
+  GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
+  gmock_a##_i
+
+#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \
+  GMOCK_PP_COMMA_IF(_i)                             \
+  gmock_a##_i
+
+#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \
+  GMOCK_PP_COMMA_IF(_i)                                      \
+  ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>()
+
+#define GMOCK_INTERNAL_ARG_O(_i, ...) \
+  typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type
+
+#define GMOCK_INTERNAL_MATCHER_O(_i, ...)                          \
+  const ::testing::Matcher<typename ::testing::internal::Function< \
+      __VA_ARGS__>::template Arg<_i>::type>&
+
+#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__)
+#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__)
+#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__)
+#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__)
+#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__)
+#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__)
+#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__)
+#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__)
+#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__)
+#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__)
+#define MOCK_METHOD10(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__)
+#define MOCK_CONST_METHOD1(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__)
+#define MOCK_CONST_METHOD2(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__)
+#define MOCK_CONST_METHOD3(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__)
+#define MOCK_CONST_METHOD4(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__)
+#define MOCK_CONST_METHOD5(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__)
+#define MOCK_CONST_METHOD6(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__)
+#define MOCK_CONST_METHOD7(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__)
+#define MOCK_CONST_METHOD8(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__)
+#define MOCK_CONST_METHOD9(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__)
+#define MOCK_CONST_METHOD10(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__)
+
+#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__)
+#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__)
+#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__)
+#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__)
+#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__)
+#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__)
+#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__)
+#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__)
+#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__)
+#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__)
+#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__)
+
+#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__)
+#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__)
+#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__)
+#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__)
+#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__)
+#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__)
+#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__)
+#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__)
+#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__)
+#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__)
+#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__)
+
+#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \
+  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                  \
+      args_num, ::testing::internal::identity_t<__VA_ARGS__>);            \
+  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                        \
+      args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, ,          \
+      (::testing::internal::identity_t<__VA_ARGS__>))
+
+#define GMOCK_MOCKER_(arity, constness, Method) \
+  GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
diff --git a/tools/gtest_lib/include/gmock/gmock-matchers.h b/tools/gtest_lib/include/gmock/gmock-matchers.h
new file mode 100644
index 0000000000000000000000000000000000000000..9584586481251d9c2b7d5cedbf5818808c6d93fa
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/gmock-matchers.h
@@ -0,0 +1,5603 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// The MATCHER* family of macros can be used in a namespace scope to
+// define custom matchers easily.
+//
+// Basic Usage
+// ===========
+//
+// The syntax
+//
+//   MATCHER(name, description_string) { statements; }
+//
+// defines a matcher with the given name that executes the statements,
+// which must return a bool to indicate if the match succeeds.  Inside
+// the statements, you can refer to the value being matched by 'arg',
+// and refer to its type by 'arg_type'.
+//
+// The description string documents what the matcher does, and is used
+// to generate the failure message when the match fails.  Since a
+// MATCHER() is usually defined in a header file shared by multiple
+// C++ source files, we require the description to be a C-string
+// literal to avoid possible side effects.  It can be empty, in which
+// case we'll use the sequence of words in the matcher name as the
+// description.
+//
+// For example:
+//
+//   MATCHER(IsEven, "") { return (arg % 2) == 0; }
+//
+// allows you to write
+//
+//   // Expects mock_foo.Bar(n) to be called where n is even.
+//   EXPECT_CALL(mock_foo, Bar(IsEven()));
+//
+// or,
+//
+//   // Verifies that the value of some_expression is even.
+//   EXPECT_THAT(some_expression, IsEven());
+//
+// If the above assertion fails, it will print something like:
+//
+//   Value of: some_expression
+//   Expected: is even
+//     Actual: 7
+//
+// where the description "is even" is automatically calculated from the
+// matcher name IsEven.
+//
+// Argument Type
+// =============
+//
+// Note that the type of the value being matched (arg_type) is
+// determined by the context in which you use the matcher and is
+// supplied to you by the compiler, so you don't need to worry about
+// declaring it (nor can you).  This allows the matcher to be
+// polymorphic.  For example, IsEven() can be used to match any type
+// where the value of "(arg % 2) == 0" can be implicitly converted to
+// a bool.  In the "Bar(IsEven())" example above, if method Bar()
+// takes an int, 'arg_type' will be int; if it takes an unsigned long,
+// 'arg_type' will be unsigned long; and so on.
+//
+// Parameterizing Matchers
+// =======================
+//
+// Sometimes you'll want to parameterize the matcher.  For that you
+// can use another macro:
+//
+//   MATCHER_P(name, param_name, description_string) { statements; }
+//
+// For example:
+//
+//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
+//
+// will allow you to write:
+//
+//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
+//
+// which may lead to this message (assuming n is 10):
+//
+//   Value of: Blah("a")
+//   Expected: has absolute value 10
+//     Actual: -9
+//
+// Note that both the matcher description and its parameter are
+// printed, making the message human-friendly.
+//
+// In the matcher definition body, you can write 'foo_type' to
+// reference the type of a parameter named 'foo'.  For example, in the
+// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
+// 'value_type' to refer to the type of 'value'.
+//
+// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to
+// support multi-parameter matchers.
+//
+// Describing Parameterized Matchers
+// =================================
+//
+// The last argument to MATCHER*() is a string-typed expression.  The
+// expression can reference all of the matcher's parameters and a
+// special bool-typed variable named 'negation'.  When 'negation' is
+// false, the expression should evaluate to the matcher's description;
+// otherwise it should evaluate to the description of the negation of
+// the matcher.  For example,
+//
+//   using testing::PrintToString;
+//
+//   MATCHER_P2(InClosedRange, low, hi,
+//       std::string(negation ? "is not" : "is") + " in range [" +
+//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
+//     return low <= arg && arg <= hi;
+//   }
+//   ...
+//   EXPECT_THAT(3, InClosedRange(4, 6));
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
+//
+// would generate two failures that contain the text:
+//
+//   Expected: is in range [4, 6]
+//   ...
+//   Expected: is not in range [2, 4]
+//
+// If you specify "" as the description, the failure message will
+// contain the sequence of words in the matcher name followed by the
+// parameter values printed as a tuple.  For example,
+//
+//   MATCHER_P2(InClosedRange, low, hi, "") { ... }
+//   ...
+//   EXPECT_THAT(3, InClosedRange(4, 6));
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
+//
+// would generate two failures that contain the text:
+//
+//   Expected: in closed range (4, 6)
+//   ...
+//   Expected: not (in closed range (2, 4))
+//
+// Types of Matcher Parameters
+// ===========================
+//
+// For the purpose of typing, you can view
+//
+//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
+//
+// as shorthand for
+//
+//   template <typename p1_type, ..., typename pk_type>
+//   FooMatcherPk<p1_type, ..., pk_type>
+//   Foo(p1_type p1, ..., pk_type pk) { ... }
+//
+// When you write Foo(v1, ..., vk), the compiler infers the types of
+// the parameters v1, ..., and vk for you.  If you are not happy with
+// the result of the type inference, you can specify the types by
+// explicitly instantiating the template, as in Foo<long, bool>(5,
+// false).  As said earlier, you don't get to (or need to) specify
+// 'arg_type' as that's determined by the context in which the matcher
+// is used.  You can assign the result of expression Foo(p1, ..., pk)
+// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
+// can be useful when composing matchers.
+//
+// While you can instantiate a matcher template with reference types,
+// passing the parameters by pointer usually makes your code more
+// readable.  If, however, you still want to pass a parameter by
+// reference, be aware that in the failure message generated by the
+// matcher you will see the value of the referenced object but not its
+// address.
+//
+// Explaining Match Results
+// ========================
+//
+// Sometimes the matcher description alone isn't enough to explain why
+// the match has failed or succeeded.  For example, when expecting a
+// long string, it can be very helpful to also print the diff between
+// the expected string and the actual one.  To achieve that, you can
+// optionally stream additional information to a special variable
+// named result_listener, whose type is a pointer to class
+// MatchResultListener:
+//
+//   MATCHER_P(EqualsLongString, str, "") {
+//     if (arg == str) return true;
+//
+//     *result_listener << "the difference: "
+///                     << DiffStrings(str, arg);
+//     return false;
+//   }
+//
+// Overloading Matchers
+// ====================
+//
+// You can overload matchers with different numbers of parameters:
+//
+//   MATCHER_P(Blah, a, description_string1) { ... }
+//   MATCHER_P2(Blah, a, b, description_string2) { ... }
+//
+// Caveats
+// =======
+//
+// When defining a new matcher, you should also consider implementing
+// MatcherInterface or using MakePolymorphicMatcher().  These
+// approaches require more work than the MATCHER* macros, but also
+// give you more control on the types of the value being matched and
+// the matcher parameters, which may leads to better compiler error
+// messages when the matcher is used wrong.  They also allow
+// overloading matchers based on parameter types (as opposed to just
+// based on the number of parameters).
+//
+// MATCHER*() can only be used in a namespace scope as templates cannot be
+// declared inside of a local class.
+//
+// More Information
+// ================
+//
+// To learn more about using these macros, please search for 'MATCHER'
+// on
+// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
+//
+// This file also implements some commonly used argument matchers.  More
+// matchers can be defined by the user implementing the
+// MatcherInterface<T> interface if necessary.
+//
+// See googletest/include/gtest/gtest-matchers.h for the definition of class
+// Matcher, class MatcherInterface, and others.
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+
+#include <algorithm>
+#include <cmath>
+#include <initializer_list>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+#include "gmock/internal/gmock-pp.h"
+#include "gtest/gtest.h"
+
+// MSVC warning C5046 is new as of VS2017 version 15.8.
+#if defined(_MSC_VER) && _MSC_VER >= 1915
+#define GMOCK_MAYBE_5046_ 5046
+#else
+#define GMOCK_MAYBE_5046_
+#endif
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(
+    4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by
+                              clients of class B */
+    /* Symbol involving type with internal linkage not defined */)
+
+namespace testing {
+
+// To implement a matcher Foo for type T, define:
+//   1. a class FooMatcherImpl that implements the
+//      MatcherInterface<T> interface, and
+//   2. a factory function that creates a Matcher<T> object from a
+//      FooMatcherImpl*.
+//
+// The two-level delegation design makes it possible to allow a user
+// to write "v" instead of "Eq(v)" where a Matcher is expected, which
+// is impossible if we pass matchers by pointers.  It also eases
+// ownership management as Matcher objects can now be copied like
+// plain values.
+
+// A match result listener that stores the explanation in a string.
+class StringMatchResultListener : public MatchResultListener {
+ public:
+  StringMatchResultListener() : MatchResultListener(&ss_) {}
+
+  // Returns the explanation accumulated so far.
+  std::string str() const { return ss_.str(); }
+
+  // Clears the explanation accumulated so far.
+  void Clear() { ss_.str(""); }
+
+ private:
+  ::std::stringstream ss_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
+};
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// The MatcherCastImpl class template is a helper for implementing
+// MatcherCast().  We need this helper in order to partially
+// specialize the implementation of MatcherCast() (C++ allows
+// class/struct templates to be partially specialized, but not
+// function templates.).
+
+// This general version is used when MatcherCast()'s argument is a
+// polymorphic matcher (i.e. something that can be converted to a
+// Matcher but is not one yet; for example, Eq(value)) or a value (for
+// example, "hello").
+template <typename T, typename M>
+class MatcherCastImpl {
+ public:
+  static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
+    // M can be a polymorphic matcher, in which case we want to use
+    // its conversion operator to create Matcher<T>.  Or it can be a value
+    // that should be passed to the Matcher<T>'s constructor.
+    //
+    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
+    // polymorphic matcher because it'll be ambiguous if T has an implicit
+    // constructor from M (this usually happens when T has an implicit
+    // constructor from any type).
+    //
+    // It won't work to unconditionally implicit_cast
+    // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
+    // a user-defined conversion from M to T if one exists (assuming M is
+    // a value).
+    return CastImpl(polymorphic_matcher_or_value,
+                    std::is_convertible<M, Matcher<T>>{},
+                    std::is_convertible<M, T>{});
+  }
+
+ private:
+  template <bool Ignore>
+  static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
+                             std::true_type /* convertible_to_matcher */,
+                             std::integral_constant<bool, Ignore>) {
+    // M is implicitly convertible to Matcher<T>, which means that either
+    // M is a polymorphic matcher or Matcher<T> has an implicit constructor
+    // from M.  In both cases using the implicit conversion will produce a
+    // matcher.
+    //
+    // Even if T has an implicit constructor from M, it won't be called because
+    // creating Matcher<T> would require a chain of two user-defined conversions
+    // (first to create T from M and then to create Matcher<T> from T).
+    return polymorphic_matcher_or_value;
+  }
+
+  // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
+  // matcher. It's a value of a type implicitly convertible to T. Use direct
+  // initialization to create a matcher.
+  static Matcher<T> CastImpl(const M& value,
+                             std::false_type /* convertible_to_matcher */,
+                             std::true_type /* convertible_to_T */) {
+    return Matcher<T>(ImplicitCast_<T>(value));
+  }
+
+  // M can't be implicitly converted to either Matcher<T> or T. Attempt to use
+  // polymorphic matcher Eq(value) in this case.
+  //
+  // Note that we first attempt to perform an implicit cast on the value and
+  // only fall back to the polymorphic Eq() matcher afterwards because the
+  // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end
+  // which might be undefined even when Rhs is implicitly convertible to Lhs
+  // (e.g. std::pair<const int, int> vs. std::pair<int, int>).
+  //
+  // We don't define this method inline as we need the declaration of Eq().
+  static Matcher<T> CastImpl(const M& value,
+                             std::false_type /* convertible_to_matcher */,
+                             std::false_type /* convertible_to_T */);
+};
+
+// This more specialized version is used when MatcherCast()'s argument
+// is already a Matcher.  This only compiles when type T can be
+// statically converted to type U.
+template <typename T, typename U>
+class MatcherCastImpl<T, Matcher<U>> {
+ public:
+  static Matcher<T> Cast(const Matcher<U>& source_matcher) {
+    return Matcher<T>(new Impl(source_matcher));
+  }
+
+ private:
+  class Impl : public MatcherInterface<T> {
+   public:
+    explicit Impl(const Matcher<U>& source_matcher)
+        : source_matcher_(source_matcher) {}
+
+    // We delegate the matching logic to the source matcher.
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+      using FromType = typename std::remove_cv<typename std::remove_pointer<
+          typename std::remove_reference<T>::type>::type>::type;
+      using ToType = typename std::remove_cv<typename std::remove_pointer<
+          typename std::remove_reference<U>::type>::type>::type;
+      // Do not allow implicitly converting base*/& to derived*/&.
+      static_assert(
+          // Do not trigger if only one of them is a pointer. That implies a
+          // regular conversion and not a down_cast.
+          (std::is_pointer<typename std::remove_reference<T>::type>::value !=
+           std::is_pointer<typename std::remove_reference<U>::type>::value) ||
+              std::is_same<FromType, ToType>::value ||
+              !std::is_base_of<FromType, ToType>::value,
+          "Can't implicitly convert from <base> to <derived>");
+
+      // Do the cast to `U` explicitly if necessary.
+      // Otherwise, let implicit conversions do the trick.
+      using CastType =
+          typename std::conditional<std::is_convertible<T&, const U&>::value,
+                                    T&, U>::type;
+
+      return source_matcher_.MatchAndExplain(static_cast<CastType>(x),
+                                             listener);
+    }
+
+    void DescribeTo(::std::ostream* os) const override {
+      source_matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      source_matcher_.DescribeNegationTo(os);
+    }
+
+   private:
+    const Matcher<U> source_matcher_;
+  };
+};
+
+// This even more specialized version is used for efficiently casting
+// a matcher to its own type.
+template <typename T>
+class MatcherCastImpl<T, Matcher<T>> {
+ public:
+  static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
+};
+
+// Template specialization for parameterless Matcher.
+template <typename Derived>
+class MatcherBaseImpl {
+ public:
+  MatcherBaseImpl() = default;
+
+  template <typename T>
+  operator ::testing::Matcher<T>() const {  // NOLINT(runtime/explicit)
+    return ::testing::Matcher<T>(new
+                                 typename Derived::template gmock_Impl<T>());
+  }
+};
+
+// Template specialization for Matcher with parameters.
+template <template <typename...> class Derived, typename... Ts>
+class MatcherBaseImpl<Derived<Ts...>> {
+ public:
+  // Mark the constructor explicit for single argument T to avoid implicit
+  // conversions.
+  template <typename E = std::enable_if<sizeof...(Ts) == 1>,
+            typename E::type* = nullptr>
+  explicit MatcherBaseImpl(Ts... params)
+      : params_(std::forward<Ts>(params)...) {}
+  template <typename E = std::enable_if<sizeof...(Ts) != 1>,
+            typename = typename E::type>
+  MatcherBaseImpl(Ts... params)  // NOLINT
+      : params_(std::forward<Ts>(params)...) {}
+
+  template <typename F>
+  operator ::testing::Matcher<F>() const {  // NOLINT(runtime/explicit)
+    return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{});
+  }
+
+ private:
+  template <typename F, std::size_t... tuple_ids>
+  ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const {
+    return ::testing::Matcher<F>(
+        new typename Derived<Ts...>::template gmock_Impl<F>(
+            std::get<tuple_ids>(params_)...));
+  }
+
+  const std::tuple<Ts...> params_;
+};
+
+}  // namespace internal
+
+// In order to be safe and clear, casting between different matcher
+// types is done explicitly via MatcherCast<T>(m), which takes a
+// matcher m and returns a Matcher<T>.  It compiles only when T can be
+// statically converted to the argument type of m.
+template <typename T, typename M>
+inline Matcher<T> MatcherCast(const M& matcher) {
+  return internal::MatcherCastImpl<T, M>::Cast(matcher);
+}
+
+// This overload handles polymorphic matchers and values only since
+// monomorphic matchers are handled by the next one.
+template <typename T, typename M>
+inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) {
+  return MatcherCast<T>(polymorphic_matcher_or_value);
+}
+
+// This overload handles monomorphic matchers.
+//
+// In general, if type T can be implicitly converted to type U, we can
+// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
+// contravariant): just keep a copy of the original Matcher<U>, convert the
+// argument from type T to U, and then pass it to the underlying Matcher<U>.
+// The only exception is when U is a reference and T is not, as the
+// underlying Matcher<U> may be interested in the argument's address, which
+// is not preserved in the conversion from T to U.
+template <typename T, typename U>
+inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {
+  // Enforce that T can be implicitly converted to U.
+  static_assert(std::is_convertible<const T&, const U&>::value,
+                "T must be implicitly convertible to U");
+  // Enforce that we are not converting a non-reference type T to a reference
+  // type U.
+  GTEST_COMPILE_ASSERT_(
+      std::is_reference<T>::value || !std::is_reference<U>::value,
+      cannot_convert_non_reference_arg_to_reference);
+  // In case both T and U are arithmetic types, enforce that the
+  // conversion is not lossy.
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
+  constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
+  constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
+  GTEST_COMPILE_ASSERT_(
+      kTIsOther || kUIsOther ||
+          (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
+      conversion_of_arithmetic_types_must_be_lossless);
+  return MatcherCast<T>(matcher);
+}
+
+// A<T>() returns a matcher that matches any value of type T.
+template <typename T>
+Matcher<T> A();
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// If the explanation is not empty, prints it to the ostream.
+inline void PrintIfNotEmpty(const std::string& explanation,
+                            ::std::ostream* os) {
+  if (explanation != "" && os != nullptr) {
+    *os << ", " << explanation;
+  }
+}
+
+// Returns true if the given type name is easy to read by a human.
+// This is used to decide whether printing the type of a value might
+// be helpful.
+inline bool IsReadableTypeName(const std::string& type_name) {
+  // We consider a type name readable if it's short or doesn't contain
+  // a template or function type.
+  return (type_name.length() <= 20 ||
+          type_name.find_first_of("<(") == std::string::npos);
+}
+
+// Matches the value against the given matcher, prints the value and explains
+// the match result to the listener. Returns the match result.
+// 'listener' must not be NULL.
+// Value cannot be passed by const reference, because some matchers take a
+// non-const argument.
+template <typename Value, typename T>
+bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
+                          MatchResultListener* listener) {
+  if (!listener->IsInterested()) {
+    // If the listener is not interested, we do not need to construct the
+    // inner explanation.
+    return matcher.Matches(value);
+  }
+
+  StringMatchResultListener inner_listener;
+  const bool match = matcher.MatchAndExplain(value, &inner_listener);
+
+  UniversalPrint(value, listener->stream());
+#if GTEST_HAS_RTTI
+  const std::string& type_name = GetTypeName<Value>();
+  if (IsReadableTypeName(type_name))
+    *listener->stream() << " (of type " << type_name << ")";
+#endif
+  PrintIfNotEmpty(inner_listener.str(), listener->stream());
+
+  return match;
+}
+
+// An internal helper class for doing compile-time loop on a tuple's
+// fields.
+template <size_t N>
+class TuplePrefix {
+ public:
+  // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
+  // if and only if the first N fields of matcher_tuple matches
+  // the first N fields of value_tuple, respectively.
+  template <typename MatcherTuple, typename ValueTuple>
+  static bool Matches(const MatcherTuple& matcher_tuple,
+                      const ValueTuple& value_tuple) {
+    return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) &&
+           std::get<N - 1>(matcher_tuple).Matches(std::get<N - 1>(value_tuple));
+  }
+
+  // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
+  // describes failures in matching the first N fields of matchers
+  // against the first N fields of values.  If there is no failure,
+  // nothing will be streamed to os.
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
+                                     const ValueTuple& values,
+                                     ::std::ostream* os) {
+    // First, describes failures in the first N - 1 fields.
+    TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
+
+    // Then describes the failure (if any) in the (N - 1)-th (0-based)
+    // field.
+    typename std::tuple_element<N - 1, MatcherTuple>::type matcher =
+        std::get<N - 1>(matchers);
+    typedef typename std::tuple_element<N - 1, ValueTuple>::type Value;
+    const Value& value = std::get<N - 1>(values);
+    StringMatchResultListener listener;
+    if (!matcher.MatchAndExplain(value, &listener)) {
+      *os << "  Expected arg #" << N - 1 << ": ";
+      std::get<N - 1>(matchers).DescribeTo(os);
+      *os << "\n           Actual: ";
+      // We remove the reference in type Value to prevent the
+      // universal printer from printing the address of value, which
+      // isn't interesting to the user most of the time.  The
+      // matcher's MatchAndExplain() method handles the case when
+      // the address is interesting.
+      internal::UniversalPrint(value, os);
+      PrintIfNotEmpty(listener.str(), os);
+      *os << "\n";
+    }
+  }
+};
+
+// The base case.
+template <>
+class TuplePrefix<0> {
+ public:
+  template <typename MatcherTuple, typename ValueTuple>
+  static bool Matches(const MatcherTuple& /* matcher_tuple */,
+                      const ValueTuple& /* value_tuple */) {
+    return true;
+  }
+
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
+                                     const ValueTuple& /* values */,
+                                     ::std::ostream* /* os */) {}
+};
+
+// TupleMatches(matcher_tuple, value_tuple) returns true if and only if
+// all matchers in matcher_tuple match the corresponding fields in
+// value_tuple.  It is a compiler error if matcher_tuple and
+// value_tuple have different number of fields or incompatible field
+// types.
+template <typename MatcherTuple, typename ValueTuple>
+bool TupleMatches(const MatcherTuple& matcher_tuple,
+                  const ValueTuple& value_tuple) {
+  // Makes sure that matcher_tuple and value_tuple have the same
+  // number of fields.
+  GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value ==
+                            std::tuple_size<ValueTuple>::value,
+                        matcher_and_value_have_different_numbers_of_fields);
+  return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple,
+                                                                  value_tuple);
+}
+
+// Describes failures in matching matchers against values.  If there
+// is no failure, nothing will be streamed to os.
+template <typename MatcherTuple, typename ValueTuple>
+void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
+                                const ValueTuple& values, ::std::ostream* os) {
+  TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
+      matchers, values, os);
+}
+
+// TransformTupleValues and its helper.
+//
+// TransformTupleValuesHelper hides the internal machinery that
+// TransformTupleValues uses to implement a tuple traversal.
+template <typename Tuple, typename Func, typename OutIter>
+class TransformTupleValuesHelper {
+ private:
+  typedef ::std::tuple_size<Tuple> TupleSize;
+
+ public:
+  // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
+  // Returns the final value of 'out' in case the caller needs it.
+  static OutIter Run(Func f, const Tuple& t, OutIter out) {
+    return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);
+  }
+
+ private:
+  template <typename Tup, size_t kRemainingSize>
+  struct IterateOverTuple {
+    OutIter operator()(Func f, const Tup& t, OutIter out) const {
+      *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t));
+      return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
+    }
+  };
+  template <typename Tup>
+  struct IterateOverTuple<Tup, 0> {
+    OutIter operator()(Func /* f */, const Tup& /* t */, OutIter out) const {
+      return out;
+    }
+  };
+};
+
+// Successively invokes 'f(element)' on each element of the tuple 't',
+// appending each result to the 'out' iterator. Returns the final value
+// of 'out'.
+template <typename Tuple, typename Func, typename OutIter>
+OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
+  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
+}
+
+// Implements _, a matcher that matches any value of any
+// type.  This is a polymorphic matcher, so we need a template type
+// conversion operator to make it appearing as a Matcher<T> for any
+// type T.
+class AnythingMatcher {
+ public:
+  using is_gtest_matcher = void;
+
+  template <typename T>
+  bool MatchAndExplain(const T& /* x */, std::ostream* /* listener */) const {
+    return true;
+  }
+  void DescribeTo(std::ostream* os) const { *os << "is anything"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    // This is mostly for completeness' sake, as it's not very useful
+    // to write Not(A<bool>()).  However we cannot completely rule out
+    // such a possibility, and it doesn't hurt to be prepared.
+    *os << "never matches";
+  }
+};
+
+// Implements the polymorphic IsNull() matcher, which matches any raw or smart
+// pointer that is NULL.
+class IsNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+    return p == nullptr;
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NULL"; }
+};
+
+// Implements the polymorphic NotNull() matcher, which matches any raw or smart
+// pointer that is not NULL.
+class NotNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+    return p != nullptr;
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
+};
+
+// Ref(variable) matches any argument that is a reference to
+// 'variable'.  This matcher is polymorphic as it can match any
+// super type of the type of 'variable'.
+//
+// The RefMatcher template class implements Ref(variable).  It can
+// only be instantiated with a reference type.  This prevents a user
+// from mistakenly using Ref(x) to match a non-reference function
+// argument.  For example, the following will righteously cause a
+// compiler error:
+//
+//   int n;
+//   Matcher<int> m1 = Ref(n);   // This won't compile.
+//   Matcher<int&> m2 = Ref(n);  // This will compile.
+template <typename T>
+class RefMatcher;
+
+template <typename T>
+class RefMatcher<T&> {
+  // Google Mock is a generic framework and thus needs to support
+  // mocking any function types, including those that take non-const
+  // reference arguments.  Therefore the template parameter T (and
+  // Super below) can be instantiated to either a const type or a
+  // non-const type.
+ public:
+  // RefMatcher() takes a T& instead of const T&, as we want the
+  // compiler to catch using Ref(const_value) as a matcher for a
+  // non-const reference.
+  explicit RefMatcher(T& x) : object_(x) {}  // NOLINT
+
+  template <typename Super>
+  operator Matcher<Super&>() const {
+    // By passing object_ (type T&) to Impl(), which expects a Super&,
+    // we make sure that Super is a super type of T.  In particular,
+    // this catches using Ref(const_value) as a matcher for a
+    // non-const reference, as you cannot implicitly convert a const
+    // reference to a non-const reference.
+    return MakeMatcher(new Impl<Super>(object_));
+  }
+
+ private:
+  template <typename Super>
+  class Impl : public MatcherInterface<Super&> {
+   public:
+    explicit Impl(Super& x) : object_(x) {}  // NOLINT
+
+    // MatchAndExplain() takes a Super& (as opposed to const Super&)
+    // in order to match the interface MatcherInterface<Super&>.
+    bool MatchAndExplain(Super& x,
+                         MatchResultListener* listener) const override {
+      *listener << "which is located @" << static_cast<const void*>(&x);
+      return &x == &object_;
+    }
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "references the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "does not reference the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+   private:
+    const Super& object_;
+  };
+
+  T& object_;
+};
+
+// Polymorphic helper functions for narrow and wide string matchers.
+inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
+  return String::CaseInsensitiveCStringEquals(lhs, rhs);
+}
+
+inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
+                                         const wchar_t* rhs) {
+  return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
+}
+
+// String comparison for narrow or wide strings that can have embedded NUL
+// characters.
+template <typename StringType>
+bool CaseInsensitiveStringEquals(const StringType& s1, const StringType& s2) {
+  // Are the heads equal?
+  if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
+    return false;
+  }
+
+  // Skip the equal heads.
+  const typename StringType::value_type nul = 0;
+  const size_t i1 = s1.find(nul), i2 = s2.find(nul);
+
+  // Are we at the end of either s1 or s2?
+  if (i1 == StringType::npos || i2 == StringType::npos) {
+    return i1 == i2;
+  }
+
+  // Are the tails equal?
+  return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
+}
+
+// String matchers.
+
+// Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
+template <typename StringType>
+class StrEqualityMatcher {
+ public:
+  StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive)
+      : string_(std::move(str)),
+        expect_eq_(expect_eq),
+        case_sensitive_(case_sensitive) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    if (s == nullptr) {
+      return !expect_eq_;
+    }
+    return MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType s2(s);
+    const bool eq = case_sensitive_ ? s2 == string_
+                                    : CaseInsensitiveStringEquals(s2, string_);
+    return expect_eq_ == eq;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    DescribeToHelper(expect_eq_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    DescribeToHelper(!expect_eq_, os);
+  }
+
+ private:
+  void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
+    *os << (expect_eq ? "is " : "isn't ");
+    *os << "equal to ";
+    if (!case_sensitive_) {
+      *os << "(ignoring case) ";
+    }
+    UniversalPrint(string_, os);
+  }
+
+  const StringType string_;
+  const bool expect_eq_;
+  const bool case_sensitive_;
+};
+
+// Implements the polymorphic HasSubstr(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class HasSubstrMatcher {
+ public:
+  explicit HasSubstrMatcher(const StringType& substring)
+      : substring_(substring) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    return StringType(s).find(substring_) != StringType::npos;
+  }
+
+  // Describes what this matcher matches.
+  void DescribeTo(::std::ostream* os) const {
+    *os << "has substring ";
+    UniversalPrint(substring_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "has no substring ";
+    UniversalPrint(substring_, os);
+  }
+
+ private:
+  const StringType substring_;
+};
+
+// Implements the polymorphic StartsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class StartsWithMatcher {
+ public:
+  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= prefix_.length() &&
+           s2.substr(0, prefix_.length()) == prefix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "starts with ";
+    UniversalPrint(prefix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't start with ";
+    UniversalPrint(prefix_, os);
+  }
+
+ private:
+  const StringType prefix_;
+};
+
+// Implements the polymorphic EndsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class EndsWithMatcher {
+ public:
+  explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= suffix_.length() &&
+           s2.substr(s2.length() - suffix_.length()) == suffix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "ends with ";
+    UniversalPrint(suffix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't end with ";
+    UniversalPrint(suffix_, os);
+  }
+
+ private:
+  const StringType suffix_;
+};
+
+// Implements the polymorphic WhenBase64Unescaped(matcher) matcher, which can be
+// used as a Matcher<T> as long as T can be converted to a string.
+class WhenBase64UnescapedMatcher {
+ public:
+  using is_gtest_matcher = void;
+
+  explicit WhenBase64UnescapedMatcher(
+      const Matcher<const std::string&>& internal_matcher)
+      : internal_matcher_(internal_matcher) {}
+
+  // Matches anything that can convert to std::string.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* listener) const {
+    const std::string s2(s);  // NOLINT (needed for working with string_view).
+    std::string unescaped;
+    if (!internal::Base64Unescape(s2, &unescaped)) {
+      if (listener != nullptr) {
+        *listener << "is not a valid base64 escaped string";
+      }
+      return false;
+    }
+    return MatchPrintAndExplain(unescaped, internal_matcher_, listener);
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "matches after Base64Unescape ";
+    internal_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "does not match after Base64Unescape ";
+    internal_matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<const std::string&> internal_matcher_;
+};
+
+// Implements a matcher that compares the two fields of a 2-tuple
+// using one of the ==, <=, <, etc, operators.  The two fields being
+// compared don't have to have the same type.
+//
+// The matcher defined here is polymorphic (for example, Eq() can be
+// used to match a std::tuple<int, short>, a std::tuple<const long&, double>,
+// etc).  Therefore we use a template type conversion operator in the
+// implementation.
+template <typename D, typename Op>
+class PairMatchBase {
+ public:
+  template <typename T1, typename T2>
+  operator Matcher<::std::tuple<T1, T2>>() const {
+    return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1, T2>&>);
+  }
+  template <typename T1, typename T2>
+  operator Matcher<const ::std::tuple<T1, T2>&>() const {
+    return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>);
+  }
+
+ private:
+  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
+    return os << D::Desc();
+  }
+
+  template <typename Tuple>
+  class Impl : public MatcherInterface<Tuple> {
+   public:
+    bool MatchAndExplain(Tuple args,
+                         MatchResultListener* /* listener */) const override {
+      return Op()(::std::get<0>(args), ::std::get<1>(args));
+    }
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "are " << GetDesc;
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "aren't " << GetDesc;
+    }
+  };
+};
+
+class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> {
+ public:
+  static const char* Desc() { return "an equal pair"; }
+};
+class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> {
+ public:
+  static const char* Desc() { return "an unequal pair"; }
+};
+class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> {
+ public:
+  static const char* Desc() { return "a pair where the first < the second"; }
+};
+class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> {
+ public:
+  static const char* Desc() { return "a pair where the first > the second"; }
+};
+class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> {
+ public:
+  static const char* Desc() { return "a pair where the first <= the second"; }
+};
+class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
+ public:
+  static const char* Desc() { return "a pair where the first >= the second"; }
+};
+
+// Implements the Not(...) matcher for a particular argument type T.
+// We do not nest it inside the NotMatcher class template, as that
+// will prevent different instantiations of NotMatcher from sharing
+// the same NotMatcherImpl<T> class.
+template <typename T>
+class NotMatcherImpl : public MatcherInterface<const T&> {
+ public:
+  explicit NotMatcherImpl(const Matcher<T>& matcher) : matcher_(matcher) {}
+
+  bool MatchAndExplain(const T& x,
+                       MatchResultListener* listener) const override {
+    return !matcher_.MatchAndExplain(x, listener);
+  }
+
+  void DescribeTo(::std::ostream* os) const override {
+    matcher_.DescribeNegationTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<T> matcher_;
+};
+
+// Implements the Not(m) matcher, which matches a value that doesn't
+// match matcher m.
+template <typename InnerMatcher>
+class NotMatcher {
+ public:
+  explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
+
+  // This template type conversion operator allows Not(m) to be used
+  // to match any type m can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
+  }
+
+ private:
+  InnerMatcher matcher_;
+};
+
+// Implements the AllOf(m1, m2) matcher for a particular argument type
+// T. We do not nest it inside the BothOfMatcher class template, as
+// that will prevent different instantiations of BothOfMatcher from
+// sharing the same BothOfMatcherImpl<T> class.
+template <typename T>
+class AllOfMatcherImpl : public MatcherInterface<const T&> {
+ public:
+  explicit AllOfMatcherImpl(std::vector<Matcher<T>> matchers)
+      : matchers_(std::move(matchers)) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") and (";
+      matchers_[i].DescribeTo(os);
+    }
+    *os << ")";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") or (";
+      matchers_[i].DescribeNegationTo(os);
+    }
+    *os << ")";
+  }
+
+  bool MatchAndExplain(const T& x,
+                       MatchResultListener* listener) const override {
+    // If either matcher1_ or matcher2_ doesn't match x, we only need
+    // to explain why one of them fails.
+    std::string all_match_result;
+
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      StringMatchResultListener slistener;
+      if (matchers_[i].MatchAndExplain(x, &slistener)) {
+        if (all_match_result.empty()) {
+          all_match_result = slistener.str();
+        } else {
+          std::string result = slistener.str();
+          if (!result.empty()) {
+            all_match_result += ", and ";
+            all_match_result += result;
+          }
+        }
+      } else {
+        *listener << slistener.str();
+        return false;
+      }
+    }
+
+    // Otherwise we need to explain why *both* of them match.
+    *listener << all_match_result;
+    return true;
+  }
+
+ private:
+  const std::vector<Matcher<T>> matchers_;
+};
+
+// VariadicMatcher is used for the variadic implementation of
+// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
+// CombiningMatcher<T> is used to recursively combine the provided matchers
+// (of type Args...).
+template <template <typename T> class CombiningMatcher, typename... Args>
+class VariadicMatcher {
+ public:
+  VariadicMatcher(const Args&... matchers)  // NOLINT
+      : matchers_(matchers...) {
+    static_assert(sizeof...(Args) > 0, "Must have at least one matcher.");
+  }
+
+  VariadicMatcher(const VariadicMatcher&) = default;
+  VariadicMatcher& operator=(const VariadicMatcher&) = delete;
+
+  // This template type conversion operator allows an
+  // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
+  // all of the provided matchers (Matcher1, Matcher2, ...) can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    std::vector<Matcher<T>> values;
+    CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>());
+    return Matcher<T>(new CombiningMatcher<T>(std::move(values)));
+  }
+
+ private:
+  template <typename T, size_t I>
+  void CreateVariadicMatcher(std::vector<Matcher<T>>* values,
+                             std::integral_constant<size_t, I>) const {
+    values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_)));
+    CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>());
+  }
+
+  template <typename T>
+  void CreateVariadicMatcher(
+      std::vector<Matcher<T>>*,
+      std::integral_constant<size_t, sizeof...(Args)>) const {}
+
+  std::tuple<Args...> matchers_;
+};
+
+template <typename... Args>
+using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>;
+
+// Implements the AnyOf(m1, m2) matcher for a particular argument type
+// T.  We do not nest it inside the AnyOfMatcher class template, as
+// that will prevent different instantiations of AnyOfMatcher from
+// sharing the same EitherOfMatcherImpl<T> class.
+template <typename T>
+class AnyOfMatcherImpl : public MatcherInterface<const T&> {
+ public:
+  explicit AnyOfMatcherImpl(std::vector<Matcher<T>> matchers)
+      : matchers_(std::move(matchers)) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") or (";
+      matchers_[i].DescribeTo(os);
+    }
+    *os << ")";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") and (";
+      matchers_[i].DescribeNegationTo(os);
+    }
+    *os << ")";
+  }
+
+  bool MatchAndExplain(const T& x,
+                       MatchResultListener* listener) const override {
+    std::string no_match_result;
+
+    // If either matcher1_ or matcher2_ matches x, we just need to
+    // explain why *one* of them matches.
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      StringMatchResultListener slistener;
+      if (matchers_[i].MatchAndExplain(x, &slistener)) {
+        *listener << slistener.str();
+        return true;
+      } else {
+        if (no_match_result.empty()) {
+          no_match_result = slistener.str();
+        } else {
+          std::string result = slistener.str();
+          if (!result.empty()) {
+            no_match_result += ", and ";
+            no_match_result += result;
+          }
+        }
+      }
+    }
+
+    // Otherwise we need to explain why *both* of them fail.
+    *listener << no_match_result;
+    return false;
+  }
+
+ private:
+  const std::vector<Matcher<T>> matchers_;
+};
+
+// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
+template <typename... Args>
+using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>;
+
+// ConditionalMatcher is the implementation of Conditional(cond, m1, m2)
+template <typename MatcherTrue, typename MatcherFalse>
+class ConditionalMatcher {
+ public:
+  ConditionalMatcher(bool condition, MatcherTrue matcher_true,
+                     MatcherFalse matcher_false)
+      : condition_(condition),
+        matcher_true_(std::move(matcher_true)),
+        matcher_false_(std::move(matcher_false)) {}
+
+  template <typename T>
+  operator Matcher<T>() const {  // NOLINT(runtime/explicit)
+    return condition_ ? SafeMatcherCast<T>(matcher_true_)
+                      : SafeMatcherCast<T>(matcher_false_);
+  }
+
+ private:
+  bool condition_;
+  MatcherTrue matcher_true_;
+  MatcherFalse matcher_false_;
+};
+
+// Wrapper for implementation of Any/AllOfArray().
+template <template <class> class MatcherImpl, typename T>
+class SomeOfArrayMatcher {
+ public:
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename Iter>
+  SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
+
+  template <typename U>
+  operator Matcher<U>() const {  // NOLINT
+    using RawU = typename std::decay<U>::type;
+    std::vector<Matcher<RawU>> matchers;
+    for (const auto& matcher : matchers_) {
+      matchers.push_back(MatcherCast<RawU>(matcher));
+    }
+    return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers)));
+  }
+
+ private:
+  const ::std::vector<T> matchers_;
+};
+
+template <typename T>
+using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>;
+
+template <typename T>
+using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>;
+
+// Used for implementing Truly(pred), which turns a predicate into a
+// matcher.
+template <typename Predicate>
+class TrulyMatcher {
+ public:
+  explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}
+
+  // This method template allows Truly(pred) to be used as a matcher
+  // for type T where T is the argument type of predicate 'pred'.  The
+  // argument is passed by reference as the predicate may be
+  // interested in the address of the argument.
+  template <typename T>
+  bool MatchAndExplain(T& x,  // NOLINT
+                       MatchResultListener* listener) const {
+    // Without the if-statement, MSVC sometimes warns about converting
+    // a value to bool (warning 4800).
+    //
+    // We cannot write 'return !!predicate_(x);' as that doesn't work
+    // when predicate_(x) returns a class convertible to bool but
+    // having no operator!().
+    if (predicate_(x)) return true;
+    *listener << "didn't satisfy the given predicate";
+    return false;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "satisfies the given predicate";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't satisfy the given predicate";
+  }
+
+ private:
+  Predicate predicate_;
+};
+
+// Used for implementing Matches(matcher), which turns a matcher into
+// a predicate.
+template <typename M>
+class MatcherAsPredicate {
+ public:
+  explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
+
+  // This template operator() allows Matches(m) to be used as a
+  // predicate on type T where m is a matcher on type T.
+  //
+  // The argument x is passed by reference instead of by value, as
+  // some matcher may be interested in its address (e.g. as in
+  // Matches(Ref(n))(x)).
+  template <typename T>
+  bool operator()(const T& x) const {
+    // We let matcher_ commit to a particular type here instead of
+    // when the MatcherAsPredicate object was constructed.  This
+    // allows us to write Matches(m) where m is a polymorphic matcher
+    // (e.g. Eq(5)).
+    //
+    // If we write Matcher<T>(matcher_).Matches(x) here, it won't
+    // compile when matcher_ has type Matcher<const T&>; if we write
+    // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
+    // when matcher_ has type Matcher<T>; if we just write
+    // matcher_.Matches(x), it won't compile when matcher_ is
+    // polymorphic, e.g. Eq(5).
+    //
+    // MatcherCast<const T&>() is necessary for making the code work
+    // in all of the above situations.
+    return MatcherCast<const T&>(matcher_).Matches(x);
+  }
+
+ private:
+  M matcher_;
+};
+
+// For implementing ASSERT_THAT() and EXPECT_THAT().  The template
+// argument M must be a type that can be converted to a matcher.
+template <typename M>
+class PredicateFormatterFromMatcher {
+ public:
+  explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {}
+
+  // This template () operator allows a PredicateFormatterFromMatcher
+  // object to act as a predicate-formatter suitable for using with
+  // Google Test's EXPECT_PRED_FORMAT1() macro.
+  template <typename T>
+  AssertionResult operator()(const char* value_text, const T& x) const {
+    // We convert matcher_ to a Matcher<const T&> *now* instead of
+    // when the PredicateFormatterFromMatcher object was constructed,
+    // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
+    // know which type to instantiate it to until we actually see the
+    // type of x here.
+    //
+    // We write SafeMatcherCast<const T&>(matcher_) instead of
+    // Matcher<const T&>(matcher_), as the latter won't compile when
+    // matcher_ has type Matcher<T> (e.g. An<int>()).
+    // We don't write MatcherCast<const T&> either, as that allows
+    // potentially unsafe downcasting of the matcher argument.
+    const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
+
+    // The expected path here is that the matcher should match (i.e. that most
+    // tests pass) so optimize for this case.
+    if (matcher.Matches(x)) {
+      return AssertionSuccess();
+    }
+
+    ::std::stringstream ss;
+    ss << "Value of: " << value_text << "\n"
+       << "Expected: ";
+    matcher.DescribeTo(&ss);
+
+    // Rerun the matcher to "PrintAndExplain" the failure.
+    StringMatchResultListener listener;
+    if (MatchPrintAndExplain(x, matcher, &listener)) {
+      ss << "\n  The matcher failed on the initial attempt; but passed when "
+            "rerun to generate the explanation.";
+    }
+    ss << "\n  Actual: " << listener.str();
+    return AssertionFailure() << ss.str();
+  }
+
+ private:
+  const M matcher_;
+};
+
+// A helper function for converting a matcher to a predicate-formatter
+// without the user needing to explicitly write the type.  This is
+// used for implementing ASSERT_THAT() and EXPECT_THAT().
+// Implementation detail: 'matcher' is received by-value to force decaying.
+template <typename M>
+inline PredicateFormatterFromMatcher<M> MakePredicateFormatterFromMatcher(
+    M matcher) {
+  return PredicateFormatterFromMatcher<M>(std::move(matcher));
+}
+
+// Implements the polymorphic IsNan() matcher, which matches any floating type
+// value that is Nan.
+class IsNanMatcher {
+ public:
+  template <typename FloatType>
+  bool MatchAndExplain(const FloatType& f,
+                       MatchResultListener* /* listener */) const {
+    return (::std::isnan)(f);
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }
+  void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NaN"; }
+};
+
+// Implements the polymorphic floating point equality matcher, which matches
+// two float values using ULP-based approximation or, optionally, a
+// user-specified epsilon.  The template is meant to be instantiated with
+// FloatType being either float or double.
+template <typename FloatType>
+class FloatingEqMatcher {
+ public:
+  // Constructor for FloatingEqMatcher.
+  // The matcher's input will be compared with expected.  The matcher treats two
+  // NANs as equal if nan_eq_nan is true.  Otherwise, under IEEE standards,
+  // equality comparisons between NANs will always return false.  We specify a
+  // negative max_abs_error_ term to indicate that ULP-based approximation will
+  // be used for comparison.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan)
+      : expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {}
+
+  // Constructor that supports a user-specified max_abs_error that will be used
+  // for comparison instead of ULP-based approximation.  The max absolute
+  // should be non-negative.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan,
+                    FloatType max_abs_error)
+      : expected_(expected),
+        nan_eq_nan_(nan_eq_nan),
+        max_abs_error_(max_abs_error) {
+    GTEST_CHECK_(max_abs_error >= 0)
+        << ", where max_abs_error is" << max_abs_error;
+  }
+
+  // Implements floating point equality matcher as a Matcher<T>.
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
+        : expected_(expected),
+          nan_eq_nan_(nan_eq_nan),
+          max_abs_error_(max_abs_error) {}
+
+    bool MatchAndExplain(T value,
+                         MatchResultListener* listener) const override {
+      const FloatingPoint<FloatType> actual(value), expected(expected_);
+
+      // Compares NaNs first, if nan_eq_nan_ is true.
+      if (actual.is_nan() || expected.is_nan()) {
+        if (actual.is_nan() && expected.is_nan()) {
+          return nan_eq_nan_;
+        }
+        // One is nan; the other is not nan.
+        return false;
+      }
+      if (HasMaxAbsError()) {
+        // We perform an equality check so that inf will match inf, regardless
+        // of error bounds.  If the result of value - expected_ would result in
+        // overflow or if either value is inf, the default result is infinity,
+        // which should only match if max_abs_error_ is also infinity.
+        if (value == expected_) {
+          return true;
+        }
+
+        const FloatType diff = value - expected_;
+        if (::std::fabs(diff) <= max_abs_error_) {
+          return true;
+        }
+
+        if (listener->IsInterested()) {
+          *listener << "which is " << diff << " from " << expected_;
+        }
+        return false;
+      } else {
+        return actual.AlmostEquals(expected);
+      }
+    }
+
+    void DescribeTo(::std::ostream* os) const override {
+      // os->precision() returns the previously set precision, which we
+      // store to restore the ostream to its original configuration
+      // after outputting.
+      const ::std::streamsize old_precision =
+          os->precision(::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "is NaN";
+        } else {
+          *os << "never matches";
+        }
+      } else {
+        *os << "is approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error <= " << max_abs_error_ << ")";
+        }
+      }
+      os->precision(old_precision);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      // As before, get original precision.
+      const ::std::streamsize old_precision =
+          os->precision(::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "isn't NaN";
+        } else {
+          *os << "is anything";
+        }
+      } else {
+        *os << "isn't approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error > " << max_abs_error_ << ")";
+        }
+      }
+      // Restore original precision.
+      os->precision(old_precision);
+    }
+
+   private:
+    bool HasMaxAbsError() const { return max_abs_error_ >= 0; }
+
+    const FloatType expected_;
+    const bool nan_eq_nan_;
+    // max_abs_error will be used for value comparison when >= 0.
+    const FloatType max_abs_error_;
+  };
+
+  // The following 3 type conversion operators allow FloatEq(expected) and
+  // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a
+  // Matcher<const float&>, or a Matcher<float&>, but nothing else.
+  operator Matcher<FloatType>() const {
+    return MakeMatcher(
+        new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<const FloatType&>() const {
+    return MakeMatcher(
+        new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<FloatType&>() const {
+    return MakeMatcher(
+        new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+ private:
+  const FloatType expected_;
+  const bool nan_eq_nan_;
+  // max_abs_error will be used for value comparison when >= 0.
+  const FloatType max_abs_error_;
+};
+
+// A 2-tuple ("binary") wrapper around FloatingEqMatcher:
+// FloatingEq2Matcher() matches (x, y) by matching FloatingEqMatcher(x, false)
+// against y, and FloatingEq2Matcher(e) matches FloatingEqMatcher(x, false, e)
+// against y. The former implements "Eq", the latter "Near". At present, there
+// is no version that compares NaNs as equal.
+template <typename FloatType>
+class FloatingEq2Matcher {
+ public:
+  FloatingEq2Matcher() { Init(-1, false); }
+
+  explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); }
+
+  explicit FloatingEq2Matcher(FloatType max_abs_error) {
+    Init(max_abs_error, false);
+  }
+
+  FloatingEq2Matcher(FloatType max_abs_error, bool nan_eq_nan) {
+    Init(max_abs_error, nan_eq_nan);
+  }
+
+  template <typename T1, typename T2>
+  operator Matcher<::std::tuple<T1, T2>>() const {
+    return MakeMatcher(
+        new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_));
+  }
+  template <typename T1, typename T2>
+  operator Matcher<const ::std::tuple<T1, T2>&>() const {
+    return MakeMatcher(
+        new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_, nan_eq_nan_));
+  }
+
+ private:
+  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
+    return os << "an almost-equal pair";
+  }
+
+  template <typename Tuple>
+  class Impl : public MatcherInterface<Tuple> {
+   public:
+    Impl(FloatType max_abs_error, bool nan_eq_nan)
+        : max_abs_error_(max_abs_error), nan_eq_nan_(nan_eq_nan) {}
+
+    bool MatchAndExplain(Tuple args,
+                         MatchResultListener* listener) const override {
+      if (max_abs_error_ == -1) {
+        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_);
+        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
+            ::std::get<1>(args), listener);
+      } else {
+        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_,
+                                        max_abs_error_);
+        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
+            ::std::get<1>(args), listener);
+      }
+    }
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "are " << GetDesc;
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "aren't " << GetDesc;
+    }
+
+   private:
+    FloatType max_abs_error_;
+    const bool nan_eq_nan_;
+  };
+
+  void Init(FloatType max_abs_error_val, bool nan_eq_nan_val) {
+    max_abs_error_ = max_abs_error_val;
+    nan_eq_nan_ = nan_eq_nan_val;
+  }
+  FloatType max_abs_error_;
+  bool nan_eq_nan_;
+};
+
+// Implements the Pointee(m) matcher for matching a pointer whose
+// pointee matches matcher m.  The pointer can be either raw or smart.
+template <typename InnerMatcher>
+class PointeeMatcher {
+ public:
+  explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
+
+  // This type conversion operator template allows Pointee(m) to be
+  // used as a matcher for any pointer type whose pointee type is
+  // compatible with the inner matcher, where type Pointer can be
+  // either a raw pointer or a smart pointer.
+  //
+  // The reason we do this instead of relying on
+  // MakePolymorphicMatcher() is that the latter is not flexible
+  // enough for implementing the DescribeTo() method of Pointee().
+  template <typename Pointer>
+  operator Matcher<Pointer>() const {
+    return Matcher<Pointer>(new Impl<const Pointer&>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular pointer type.
+  template <typename Pointer>
+  class Impl : public MatcherInterface<Pointer> {
+   public:
+    using Pointee =
+        typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
+            Pointer)>::element_type;
+
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<const Pointee&>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "points to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "does not point to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(Pointer pointer,
+                         MatchResultListener* listener) const override {
+      if (GetRawPointer(pointer) == nullptr) return false;
+
+      *listener << "which points to ";
+      return MatchPrintAndExplain(*pointer, matcher_, listener);
+    }
+
+   private:
+    const Matcher<const Pointee&> matcher_;
+  };
+
+  const InnerMatcher matcher_;
+};
+
+// Implements the Pointer(m) matcher
+// Implements the Pointer(m) matcher for matching a pointer that matches matcher
+// m.  The pointer can be either raw or smart, and will match `m` against the
+// raw pointer.
+template <typename InnerMatcher>
+class PointerMatcher {
+ public:
+  explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
+
+  // This type conversion operator template allows Pointer(m) to be
+  // used as a matcher for any pointer type whose pointer type is
+  // compatible with the inner matcher, where type PointerType can be
+  // either a raw pointer or a smart pointer.
+  //
+  // The reason we do this instead of relying on
+  // MakePolymorphicMatcher() is that the latter is not flexible
+  // enough for implementing the DescribeTo() method of Pointer().
+  template <typename PointerType>
+  operator Matcher<PointerType>() const {  // NOLINT
+    return Matcher<PointerType>(new Impl<const PointerType&>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular pointer type.
+  template <typename PointerType>
+  class Impl : public MatcherInterface<PointerType> {
+   public:
+    using Pointer =
+        const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
+            PointerType)>::element_type*;
+
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<Pointer>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "is a pointer that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "is not a pointer that ";
+      matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(PointerType pointer,
+                         MatchResultListener* listener) const override {
+      *listener << "which is a pointer that ";
+      Pointer p = GetRawPointer(pointer);
+      return MatchPrintAndExplain(p, matcher_, listener);
+    }
+
+   private:
+    Matcher<Pointer> matcher_;
+  };
+
+  const InnerMatcher matcher_;
+};
+
+#if GTEST_HAS_RTTI
+// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
+// reference that matches inner_matcher when dynamic_cast<T> is applied.
+// The result of dynamic_cast<To> is forwarded to the inner matcher.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+class WhenDynamicCastToMatcherBase {
+ public:
+  explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)
+      : matcher_(matcher) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeNegationTo(os);
+  }
+
+ protected:
+  const Matcher<To> matcher_;
+
+  static std::string GetToName() { return GetTypeName<To>(); }
+
+ private:
+  static void GetCastTypeDescription(::std::ostream* os) {
+    *os << "when dynamic_cast to " << GetToName() << ", ";
+  }
+};
+
+// Primary template.
+// To is a pointer. Cast and forward the result.
+template <typename To>
+class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)
+      : WhenDynamicCastToMatcherBase<To>(matcher) {}
+
+  template <typename From>
+  bool MatchAndExplain(From from, MatchResultListener* listener) const {
+    To to = dynamic_cast<To>(from);
+    return MatchPrintAndExplain(to, this->matcher_, listener);
+  }
+};
+
+// Specialize for references.
+// In this case we return false if the dynamic_cast fails.
+template <typename To>
+class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)
+      : WhenDynamicCastToMatcherBase<To&>(matcher) {}
+
+  template <typename From>
+  bool MatchAndExplain(From& from, MatchResultListener* listener) const {
+    // We don't want an std::bad_cast here, so do the cast with pointers.
+    To* to = dynamic_cast<To*>(&from);
+    if (to == nullptr) {
+      *listener << "which cannot be dynamic_cast to " << this->GetToName();
+      return false;
+    }
+    return MatchPrintAndExplain(*to, this->matcher_, listener);
+  }
+};
+#endif  // GTEST_HAS_RTTI
+
+// Implements the Field() matcher for matching a field (i.e. member
+// variable) of an object.
+template <typename Class, typename FieldType>
+class FieldMatcher {
+ public:
+  FieldMatcher(FieldType Class::*field,
+               const Matcher<const FieldType&>& matcher)
+      : field_(field), matcher_(matcher), whose_field_("whose given field ") {}
+
+  FieldMatcher(const std::string& field_name, FieldType Class::*field,
+               const Matcher<const FieldType&>& matcher)
+      : field_(field),
+        matcher_(matcher),
+        whose_field_("whose field `" + field_name + "` ") {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object " << whose_field_;
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object " << whose_field_;
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
+    // FIXME: The dispatch on std::is_pointer was introduced as a workaround for
+    // a compiler bug, and can now be removed.
+    return MatchAndExplainImpl(
+        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
+        value, listener);
+  }
+
+ private:
+  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
+                           const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << whose_field_ << "is ";
+    return MatchPrintAndExplain(obj.*field_, matcher_, listener);
+  }
+
+  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == nullptr) return false;
+
+    *listener << "which points to an object ";
+    // Since *p has a field, it must be a class/struct/union type and
+    // thus cannot be a pointer.  Therefore we pass false_type() as
+    // the first argument.
+    return MatchAndExplainImpl(std::false_type(), *p, listener);
+  }
+
+  const FieldType Class::*field_;
+  const Matcher<const FieldType&> matcher_;
+
+  // Contains either "whose given field " if the name of the field is unknown
+  // or "whose field `name_of_field` " if the name is known.
+  const std::string whose_field_;
+};
+
+// Implements the Property() matcher for matching a property
+// (i.e. return value of a getter method) of an object.
+//
+// Property is a const-qualified member function of Class returning
+// PropertyType.
+template <typename Class, typename PropertyType, typename Property>
+class PropertyMatcher {
+ public:
+  typedef const PropertyType& RefToConstProperty;
+
+  PropertyMatcher(Property property, const Matcher<RefToConstProperty>& matcher)
+      : property_(property),
+        matcher_(matcher),
+        whose_property_("whose given property ") {}
+
+  PropertyMatcher(const std::string& property_name, Property property,
+                  const Matcher<RefToConstProperty>& matcher)
+      : property_(property),
+        matcher_(matcher),
+        whose_property_("whose property `" + property_name + "` ") {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object " << whose_property_;
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object " << whose_property_;
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
+    return MatchAndExplainImpl(
+        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
+        value, listener);
+  }
+
+ private:
+  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
+                           const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << whose_property_ << "is ";
+    // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
+    // which takes a non-const reference as argument.
+    RefToConstProperty result = (obj.*property_)();
+    return MatchPrintAndExplain(result, matcher_, listener);
+  }
+
+  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == nullptr) return false;
+
+    *listener << "which points to an object ";
+    // Since *p has a property method, it must be a class/struct/union
+    // type and thus cannot be a pointer.  Therefore we pass
+    // false_type() as the first argument.
+    return MatchAndExplainImpl(std::false_type(), *p, listener);
+  }
+
+  Property property_;
+  const Matcher<RefToConstProperty> matcher_;
+
+  // Contains either "whose given property " if the name of the property is
+  // unknown or "whose property `name_of_property` " if the name is known.
+  const std::string whose_property_;
+};
+
+// Type traits specifying various features of different functors for ResultOf.
+// The default template specifies features for functor objects.
+template <typename Functor>
+struct CallableTraits {
+  typedef Functor StorageType;
+
+  static void CheckIsValid(Functor /* functor */) {}
+
+  template <typename T>
+  static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) {
+    return f(arg);
+  }
+};
+
+// Specialization for function pointers.
+template <typename ArgType, typename ResType>
+struct CallableTraits<ResType (*)(ArgType)> {
+  typedef ResType ResultType;
+  typedef ResType (*StorageType)(ArgType);
+
+  static void CheckIsValid(ResType (*f)(ArgType)) {
+    GTEST_CHECK_(f != nullptr)
+        << "NULL function pointer is passed into ResultOf().";
+  }
+  template <typename T>
+  static ResType Invoke(ResType (*f)(ArgType), T arg) {
+    return (*f)(arg);
+  }
+};
+
+// Implements the ResultOf() matcher for matching a return value of a
+// unary function of an object.
+template <typename Callable, typename InnerMatcher>
+class ResultOfMatcher {
+ public:
+  ResultOfMatcher(Callable callable, InnerMatcher matcher)
+      : ResultOfMatcher(/*result_description=*/"", std::move(callable),
+                        std::move(matcher)) {}
+
+  ResultOfMatcher(const std::string& result_description, Callable callable,
+                  InnerMatcher matcher)
+      : result_description_(result_description),
+        callable_(std::move(callable)),
+        matcher_(std::move(matcher)) {
+    CallableTraits<Callable>::CheckIsValid(callable_);
+  }
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(
+        new Impl<const T&>(result_description_, callable_, matcher_));
+  }
+
+ private:
+  typedef typename CallableTraits<Callable>::StorageType CallableStorageType;
+
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+    using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>(
+        std::declval<CallableStorageType>(), std::declval<T>()));
+
+   public:
+    template <typename M>
+    Impl(const std::string& result_description,
+         const CallableStorageType& callable, const M& matcher)
+        : result_description_(result_description),
+          callable_(callable),
+          matcher_(MatcherCast<ResultType>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      if (result_description_.empty()) {
+        *os << "is mapped by the given callable to a value that ";
+      } else {
+        *os << "whose " << result_description_ << " ";
+      }
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      if (result_description_.empty()) {
+        *os << "is mapped by the given callable to a value that ";
+      } else {
+        *os << "whose " << result_description_ << " ";
+      }
+      matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
+      *listener << "which is mapped by the given callable to ";
+      // Cannot pass the return value directly to MatchPrintAndExplain, which
+      // takes a non-const reference as argument.
+      // Also, specifying template argument explicitly is needed because T could
+      // be a non-const reference (e.g. Matcher<Uncopyable&>).
+      ResultType result =
+          CallableTraits<Callable>::template Invoke<T>(callable_, obj);
+      return MatchPrintAndExplain(result, matcher_, listener);
+    }
+
+   private:
+    const std::string result_description_;
+    // Functors often define operator() as non-const method even though
+    // they are actually stateless. But we need to use them even when
+    // 'this' is a const pointer. It's the user's responsibility not to
+    // use stateful callables with ResultOf(), which doesn't guarantee
+    // how many times the callable will be invoked.
+    mutable CallableStorageType callable_;
+    const Matcher<ResultType> matcher_;
+  };  // class Impl
+
+  const std::string result_description_;
+  const CallableStorageType callable_;
+  const InnerMatcher matcher_;
+};
+
+// Implements a matcher that checks the size of an STL-style container.
+template <typename SizeMatcher>
+class SizeIsMatcher {
+ public:
+  explicit SizeIsMatcher(const SizeMatcher& size_matcher)
+      : size_matcher_(size_matcher) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(new Impl<const Container&>(size_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    using SizeType = decltype(std::declval<Container>().size());
+    explicit Impl(const SizeMatcher& size_matcher)
+        : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "size ";
+      size_matcher_.DescribeTo(os);
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "size ";
+      size_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(Container container,
+                         MatchResultListener* listener) const override {
+      SizeType size = container.size();
+      StringMatchResultListener size_listener;
+      const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
+      *listener << "whose size " << size
+                << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(size_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<SizeType> size_matcher_;
+  };
+
+ private:
+  const SizeMatcher size_matcher_;
+};
+
+// Implements a matcher that checks the begin()..end() distance of an STL-style
+// container.
+template <typename DistanceMatcher>
+class BeginEndDistanceIsMatcher {
+ public:
+  explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)
+      : distance_matcher_(distance_matcher) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(new Impl<const Container&>(distance_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_(
+        Container)>
+        ContainerView;
+    typedef typename std::iterator_traits<
+        typename ContainerView::type::const_iterator>::difference_type
+        DistanceType;
+    explicit Impl(const DistanceMatcher& distance_matcher)
+        : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeTo(os);
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(Container container,
+                         MatchResultListener* listener) const override {
+      using std::begin;
+      using std::end;
+      DistanceType distance = std::distance(begin(container), end(container));
+      StringMatchResultListener distance_listener;
+      const bool result =
+          distance_matcher_.MatchAndExplain(distance, &distance_listener);
+      *listener << "whose distance between begin() and end() " << distance
+                << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(distance_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<DistanceType> distance_matcher_;
+  };
+
+ private:
+  const DistanceMatcher distance_matcher_;
+};
+
+// Implements an equality matcher for any STL-style container whose elements
+// support ==. This matcher is like Eq(), but its failure explanations provide
+// more detailed information that is useful when the container is used as a set.
+// The failure message reports elements that are in one of the operands but not
+// the other. The failure messages do not report duplicate or out-of-order
+// elements in the containers (which don't properly matter to sets, but can
+// occur if the containers are vectors or lists, for example).
+//
+// Uses the container's const_iterator, value_type, operator ==,
+// begin(), and end().
+template <typename Container>
+class ContainerEqMatcher {
+ public:
+  typedef internal::StlContainerView<Container> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+
+  static_assert(!std::is_const<Container>::value,
+                "Container type must not be const");
+  static_assert(!std::is_reference<Container>::value,
+                "Container type must not be a reference");
+
+  // We make a copy of expected in case the elements in it are modified
+  // after this matcher is created.
+  explicit ContainerEqMatcher(const Container& expected)
+      : expected_(View::Copy(expected)) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "equals ";
+    UniversalPrint(expected_, os);
+  }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "does not equal ";
+    UniversalPrint(expected_, os);
+  }
+
+  template <typename LhsContainer>
+  bool MatchAndExplain(const LhsContainer& lhs,
+                       MatchResultListener* listener) const {
+    typedef internal::StlContainerView<
+        typename std::remove_const<LhsContainer>::type>
+        LhsView;
+    StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+    if (lhs_stl_container == expected_) return true;
+
+    ::std::ostream* const os = listener->stream();
+    if (os != nullptr) {
+      // Something is different. Check for extra values first.
+      bool printed_header = false;
+      for (auto it = lhs_stl_container.begin(); it != lhs_stl_container.end();
+           ++it) {
+        if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
+            expected_.end()) {
+          if (printed_header) {
+            *os << ", ";
+          } else {
+            *os << "which has these unexpected elements: ";
+            printed_header = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+
+      // Now check for missing values.
+      bool printed_header2 = false;
+      for (auto it = expected_.begin(); it != expected_.end(); ++it) {
+        if (internal::ArrayAwareFind(lhs_stl_container.begin(),
+                                     lhs_stl_container.end(),
+                                     *it) == lhs_stl_container.end()) {
+          if (printed_header2) {
+            *os << ", ";
+          } else {
+            *os << (printed_header ? ",\nand" : "which")
+                << " doesn't have these expected elements: ";
+            printed_header2 = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+    }
+
+    return false;
+  }
+
+ private:
+  const StlContainer expected_;
+};
+
+// A comparator functor that uses the < operator to compare two values.
+struct LessComparator {
+  template <typename T, typename U>
+  bool operator()(const T& lhs, const U& rhs) const {
+    return lhs < rhs;
+  }
+};
+
+// Implements WhenSortedBy(comparator, container_matcher).
+template <typename Comparator, typename ContainerMatcher>
+class WhenSortedByMatcher {
+ public:
+  WhenSortedByMatcher(const Comparator& comparator,
+                      const ContainerMatcher& matcher)
+      : comparator_(comparator), matcher_(matcher) {}
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_(
+        LhsContainer)>
+        LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
+    // so that we can match associative containers.
+    typedef
+        typename RemoveConstFromKey<typename LhsStlContainer::value_type>::type
+            LhsValue;
+
+    Impl(const Comparator& comparator, const ContainerMatcher& matcher)
+        : comparator_(comparator), matcher_(matcher) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "(when sorted) ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "(when sorted) ";
+      matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(LhsContainer lhs,
+                         MatchResultListener* listener) const override {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
+                                               lhs_stl_container.end());
+      ::std::sort(sorted_container.begin(), sorted_container.end(),
+                  comparator_);
+
+      if (!listener->IsInterested()) {
+        // If the listener is not interested, we do not need to
+        // construct the inner explanation.
+        return matcher_.Matches(sorted_container);
+      }
+
+      *listener << "which is ";
+      UniversalPrint(sorted_container, listener->stream());
+      *listener << " when sorted";
+
+      StringMatchResultListener inner_listener;
+      const bool match =
+          matcher_.MatchAndExplain(sorted_container, &inner_listener);
+      PrintIfNotEmpty(inner_listener.str(), listener->stream());
+      return match;
+    }
+
+   private:
+    const Comparator comparator_;
+    const Matcher<const ::std::vector<LhsValue>&> matcher_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+ private:
+  const Comparator comparator_;
+  const ContainerMatcher matcher_;
+};
+
+// Implements Pointwise(tuple_matcher, rhs_container).  tuple_matcher
+// must be able to be safely cast to Matcher<std::tuple<const T1&, const
+// T2&> >, where T1 and T2 are the types of elements in the LHS
+// container and the RHS container respectively.
+template <typename TupleMatcher, typename RhsContainer>
+class PointwiseMatcher {
+  GTEST_COMPILE_ASSERT_(
+      !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value,
+      use_UnorderedPointwise_with_hash_tables);
+
+ public:
+  typedef internal::StlContainerView<RhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type RhsValue;
+
+  static_assert(!std::is_const<RhsContainer>::value,
+                "RhsContainer type must not be const");
+  static_assert(!std::is_reference<RhsContainer>::value,
+                "RhsContainer type must not be a reference");
+
+  // Like ContainerEq, we make a copy of rhs in case the elements in
+  // it are modified after this matcher is created.
+  PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)
+      : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {}
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    GTEST_COMPILE_ASSERT_(
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value,
+        use_UnorderedPointwise_with_hash_tables);
+
+    return Matcher<LhsContainer>(
+        new Impl<const LhsContainer&>(tuple_matcher_, rhs_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_(
+        LhsContainer)>
+        LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    typedef typename LhsStlContainer::value_type LhsValue;
+    // We pass the LHS value and the RHS value to the inner matcher by
+    // reference, as they may be expensive to copy.  We must use tuple
+    // instead of pair here, as a pair cannot hold references (C++ 98,
+    // 20.2.2 [lib.pairs]).
+    typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
+
+    Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
+        // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher.
+        : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),
+          rhs_(rhs) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "contains " << rhs_.size()
+          << " values, where each value and its corresponding value in ";
+      UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeTo(os);
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "doesn't contain exactly " << rhs_.size()
+          << " values, or contains a value x at some index i"
+          << " where x and the i-th value of ";
+      UniversalPrint(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(LhsContainer lhs,
+                         MatchResultListener* listener) const override {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      const size_t actual_size = lhs_stl_container.size();
+      if (actual_size != rhs_.size()) {
+        *listener << "which contains " << actual_size << " values";
+        return false;
+      }
+
+      auto left = lhs_stl_container.begin();
+      auto right = rhs_.begin();
+      for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
+        if (listener->IsInterested()) {
+          StringMatchResultListener inner_listener;
+          // Create InnerMatcherArg as a temporarily object to avoid it outlives
+          // *left and *right. Dereference or the conversion to `const T&` may
+          // return temp objects, e.g. for vector<bool>.
+          if (!mono_tuple_matcher_.MatchAndExplain(
+                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
+                                  ImplicitCast_<const RhsValue&>(*right)),
+                  &inner_listener)) {
+            *listener << "where the value pair (";
+            UniversalPrint(*left, listener->stream());
+            *listener << ", ";
+            UniversalPrint(*right, listener->stream());
+            *listener << ") at index #" << i << " don't match";
+            PrintIfNotEmpty(inner_listener.str(), listener->stream());
+            return false;
+          }
+        } else {
+          if (!mono_tuple_matcher_.Matches(
+                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
+                                  ImplicitCast_<const RhsValue&>(*right))))
+            return false;
+        }
+      }
+
+      return true;
+    }
+
+   private:
+    const Matcher<InnerMatcherArg> mono_tuple_matcher_;
+    const RhsStlContainer rhs_;
+  };
+
+ private:
+  const TupleMatcher tuple_matcher_;
+  const RhsStlContainer rhs_;
+};
+
+// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.
+template <typename Container>
+class QuantifierMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  template <typename InnerMatcher>
+  explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+            testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
+
+  // Checks whether:
+  // * All elements in the container match, if all_elements_should_match.
+  // * Any element in the container matches, if !all_elements_should_match.
+  bool MatchAndExplainImpl(bool all_elements_should_match, Container container,
+                           MatchResultListener* listener) const {
+    StlContainerReference stl_container = View::ConstReference(container);
+    size_t i = 0;
+    for (auto it = stl_container.begin(); it != stl_container.end();
+         ++it, ++i) {
+      StringMatchResultListener inner_listener;
+      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
+
+      if (matches != all_elements_should_match) {
+        *listener << "whose element #" << i
+                  << (matches ? " matches" : " doesn't match");
+        PrintIfNotEmpty(inner_listener.str(), listener->stream());
+        return !all_elements_should_match;
+      }
+    }
+    return all_elements_should_match;
+  }
+
+  bool MatchAndExplainImpl(const Matcher<size_t>& count_matcher,
+                           Container container,
+                           MatchResultListener* listener) const {
+    StlContainerReference stl_container = View::ConstReference(container);
+    size_t i = 0;
+    std::vector<size_t> match_elements;
+    for (auto it = stl_container.begin(); it != stl_container.end();
+         ++it, ++i) {
+      StringMatchResultListener inner_listener;
+      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
+      if (matches) {
+        match_elements.push_back(i);
+      }
+    }
+    if (listener->IsInterested()) {
+      if (match_elements.empty()) {
+        *listener << "has no element that matches";
+      } else if (match_elements.size() == 1) {
+        *listener << "whose element #" << match_elements[0] << " matches";
+      } else {
+        *listener << "whose elements (";
+        std::string sep = "";
+        for (size_t e : match_elements) {
+          *listener << sep << e;
+          sep = ", ";
+        }
+        *listener << ") match";
+      }
+    }
+    StringMatchResultListener count_listener;
+    if (count_matcher.MatchAndExplain(match_elements.size(), &count_listener)) {
+      *listener << " and whose match quantity of " << match_elements.size()
+                << " matches";
+      PrintIfNotEmpty(count_listener.str(), listener->stream());
+      return true;
+    } else {
+      if (match_elements.empty()) {
+        *listener << " and";
+      } else {
+        *listener << " but";
+      }
+      *listener << " whose match quantity of " << match_elements.size()
+                << " does not match";
+      PrintIfNotEmpty(count_listener.str(), listener->stream());
+      return false;
+    }
+  }
+
+ protected:
+  const Matcher<const Element&> inner_matcher_;
+};
+
+// Implements Contains(element_matcher) for the given argument type Container.
+// Symmetric to EachMatcherImpl.
+template <typename Container>
+class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit ContainsMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "contains at least one element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "doesn't contain any element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    return this->MatchAndExplainImpl(false, container, listener);
+  }
+};
+
+// Implements Each(element_matcher) for the given argument type Container.
+// Symmetric to ContainsMatcherImpl.
+template <typename Container>
+class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit EachMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "only contains elements that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "contains some element that ";
+    this->inner_matcher_.DescribeNegationTo(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    return this->MatchAndExplainImpl(true, container, listener);
+  }
+};
+
+// Implements Contains(element_matcher).Times(n) for the given argument type
+// Container.
+template <typename Container>
+class ContainsTimesMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit ContainsTimesMatcherImpl(InnerMatcher inner_matcher,
+                                    Matcher<size_t> count_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher),
+        count_matcher_(std::move(count_matcher)) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "quantity of elements that match ";
+    this->inner_matcher_.DescribeTo(os);
+    *os << " ";
+    count_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "quantity of elements that match ";
+    this->inner_matcher_.DescribeTo(os);
+    *os << " ";
+    count_matcher_.DescribeNegationTo(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    return this->MatchAndExplainImpl(count_matcher_, container, listener);
+  }
+
+ private:
+  const Matcher<size_t> count_matcher_;
+};
+
+// Implements polymorphic Contains(element_matcher).Times(n).
+template <typename M>
+class ContainsTimesMatcher {
+ public:
+  explicit ContainsTimesMatcher(M m, Matcher<size_t> count_matcher)
+      : inner_matcher_(m), count_matcher_(std::move(count_matcher)) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {  // NOLINT
+    return Matcher<Container>(new ContainsTimesMatcherImpl<const Container&>(
+        inner_matcher_, count_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+  const Matcher<size_t> count_matcher_;
+};
+
+// Implements polymorphic Contains(element_matcher).
+template <typename M>
+class ContainsMatcher {
+ public:
+  explicit ContainsMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {  // NOLINT
+    return Matcher<Container>(
+        new ContainsMatcherImpl<const Container&>(inner_matcher_));
+  }
+
+  ContainsTimesMatcher<M> Times(Matcher<size_t> count_matcher) const {
+    return ContainsTimesMatcher<M>(inner_matcher_, std::move(count_matcher));
+  }
+
+ private:
+  const M inner_matcher_;
+};
+
+// Implements polymorphic Each(element_matcher).
+template <typename M>
+class EachMatcher {
+ public:
+  explicit EachMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {  // NOLINT
+    return Matcher<Container>(
+        new EachMatcherImpl<const Container&>(inner_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+};
+
+struct Rank1 {};
+struct Rank0 : Rank1 {};
+
+namespace pair_getters {
+using std::get;
+template <typename T>
+auto First(T& x, Rank1) -> decltype(get<0>(x)) {  // NOLINT
+  return get<0>(x);
+}
+template <typename T>
+auto First(T& x, Rank0) -> decltype((x.first)) {  // NOLINT
+  return x.first;
+}
+
+template <typename T>
+auto Second(T& x, Rank1) -> decltype(get<1>(x)) {  // NOLINT
+  return get<1>(x);
+}
+template <typename T>
+auto Second(T& x, Rank0) -> decltype((x.second)) {  // NOLINT
+  return x.second;
+}
+}  // namespace pair_getters
+
+// Implements Key(inner_matcher) for the given argument pair type.
+// Key(inner_matcher) matches an std::pair whose 'first' field matches
+// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
+// std::map that contains at least one element whose key is >= 5.
+template <typename PairType>
+class KeyMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type KeyType;
+
+  template <typename InnerMatcher>
+  explicit KeyMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+            testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {}
+
+  // Returns true if and only if 'key_value.first' (the key) matches the inner
+  // matcher.
+  bool MatchAndExplain(PairType key_value,
+                       MatchResultListener* listener) const override {
+    StringMatchResultListener inner_listener;
+    const bool match = inner_matcher_.MatchAndExplain(
+        pair_getters::First(key_value, Rank0()), &inner_listener);
+    const std::string explanation = inner_listener.str();
+    if (explanation != "") {
+      *listener << "whose first field is a value " << explanation;
+    }
+    return match;
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "has a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "doesn't have a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<const KeyType&> inner_matcher_;
+};
+
+// Implements polymorphic Key(matcher_for_key).
+template <typename M>
+class KeyMatcher {
+ public:
+  explicit KeyMatcher(M m) : matcher_for_key_(m) {}
+
+  template <typename PairType>
+  operator Matcher<PairType>() const {
+    return Matcher<PairType>(
+        new KeyMatcherImpl<const PairType&>(matcher_for_key_));
+  }
+
+ private:
+  const M matcher_for_key_;
+};
+
+// Implements polymorphic Address(matcher_for_address).
+template <typename InnerMatcher>
+class AddressMatcher {
+ public:
+  explicit AddressMatcher(InnerMatcher m) : matcher_(m) {}
+
+  template <typename Type>
+  operator Matcher<Type>() const {  // NOLINT
+    return Matcher<Type>(new Impl<const Type&>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular object type.
+  template <typename Type>
+  class Impl : public MatcherInterface<Type> {
+   public:
+    using Address = const GTEST_REMOVE_REFERENCE_AND_CONST_(Type) *;
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<Address>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "has address that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "does not have address that ";
+      matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(Type object,
+                         MatchResultListener* listener) const override {
+      *listener << "which has address ";
+      Address address = std::addressof(object);
+      return MatchPrintAndExplain(address, matcher_, listener);
+    }
+
+   private:
+    const Matcher<Address> matcher_;
+  };
+  const InnerMatcher matcher_;
+};
+
+// Implements Pair(first_matcher, second_matcher) for the given argument pair
+// type with its two matchers. See Pair() function below.
+template <typename PairType>
+class PairMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type FirstType;
+  typedef typename RawPairType::second_type SecondType;
+
+  template <typename FirstMatcher, typename SecondMatcher>
+  PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(
+            testing::SafeMatcherCast<const FirstType&>(first_matcher)),
+        second_matcher_(
+            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {}
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "has a first field that ";
+    first_matcher_.DescribeTo(os);
+    *os << ", and has a second field that ";
+    second_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "has a first field that ";
+    first_matcher_.DescribeNegationTo(os);
+    *os << ", or has a second field that ";
+    second_matcher_.DescribeNegationTo(os);
+  }
+
+  // Returns true if and only if 'a_pair.first' matches first_matcher and
+  // 'a_pair.second' matches second_matcher.
+  bool MatchAndExplain(PairType a_pair,
+                       MatchResultListener* listener) const override {
+    if (!listener->IsInterested()) {
+      // If the listener is not interested, we don't need to construct the
+      // explanation.
+      return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) &&
+             second_matcher_.Matches(pair_getters::Second(a_pair, Rank0()));
+    }
+    StringMatchResultListener first_inner_listener;
+    if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()),
+                                        &first_inner_listener)) {
+      *listener << "whose first field does not match";
+      PrintIfNotEmpty(first_inner_listener.str(), listener->stream());
+      return false;
+    }
+    StringMatchResultListener second_inner_listener;
+    if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()),
+                                         &second_inner_listener)) {
+      *listener << "whose second field does not match";
+      PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
+      return false;
+    }
+    ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),
+                   listener);
+    return true;
+  }
+
+ private:
+  void ExplainSuccess(const std::string& first_explanation,
+                      const std::string& second_explanation,
+                      MatchResultListener* listener) const {
+    *listener << "whose both fields match";
+    if (first_explanation != "") {
+      *listener << ", where the first field is a value " << first_explanation;
+    }
+    if (second_explanation != "") {
+      *listener << ", ";
+      if (first_explanation != "") {
+        *listener << "and ";
+      } else {
+        *listener << "where ";
+      }
+      *listener << "the second field is a value " << second_explanation;
+    }
+  }
+
+  const Matcher<const FirstType&> first_matcher_;
+  const Matcher<const SecondType&> second_matcher_;
+};
+
+// Implements polymorphic Pair(first_matcher, second_matcher).
+template <typename FirstMatcher, typename SecondMatcher>
+class PairMatcher {
+ public:
+  PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
+
+  template <typename PairType>
+  operator Matcher<PairType>() const {
+    return Matcher<PairType>(
+        new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_));
+  }
+
+ private:
+  const FirstMatcher first_matcher_;
+  const SecondMatcher second_matcher_;
+};
+
+template <typename T, size_t... I>
+auto UnpackStructImpl(const T& t, IndexSequence<I...>, int)
+    -> decltype(std::tie(get<I>(t)...)) {
+  static_assert(std::tuple_size<T>::value == sizeof...(I),
+                "Number of arguments doesn't match the number of fields.");
+  return std::tie(get<I>(t)...);
+}
+
+#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) {
+  const auto& [a] = t;
+  return std::tie(a);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) {
+  const auto& [a, b] = t;
+  return std::tie(a, b);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) {
+  const auto& [a, b, c] = t;
+  return std::tie(a, b, c);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) {
+  const auto& [a, b, c, d] = t;
+  return std::tie(a, b, c, d);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) {
+  const auto& [a, b, c, d, e] = t;
+  return std::tie(a, b, c, d, e);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) {
+  const auto& [a, b, c, d, e, f] = t;
+  return std::tie(a, b, c, d, e, f);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) {
+  const auto& [a, b, c, d, e, f, g] = t;
+  return std::tie(a, b, c, d, e, f, g);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) {
+  const auto& [a, b, c, d, e, f, g, h] = t;
+  return std::tie(a, b, c, d, e, f, g, h);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
+}
+#endif  // defined(__cpp_structured_bindings)
+
+template <size_t I, typename T>
+auto UnpackStruct(const T& t)
+    -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) {
+  return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0);
+}
+
+// Helper function to do comma folding in C++11.
+// The array ensures left-to-right order of evaluation.
+// Usage: VariadicExpand({expr...});
+template <typename T, size_t N>
+void VariadicExpand(const T (&)[N]) {}
+
+template <typename Struct, typename StructSize>
+class FieldsAreMatcherImpl;
+
+template <typename Struct, size_t... I>
+class FieldsAreMatcherImpl<Struct, IndexSequence<I...>>
+    : public MatcherInterface<Struct> {
+  using UnpackedType =
+      decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>()));
+  using MatchersType = std::tuple<
+      Matcher<const typename std::tuple_element<I, UnpackedType>::type&>...>;
+
+ public:
+  template <typename Inner>
+  explicit FieldsAreMatcherImpl(const Inner& matchers)
+      : matchers_(testing::SafeMatcherCast<
+                  const typename std::tuple_element<I, UnpackedType>::type&>(
+            std::get<I>(matchers))...) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    const char* separator = "";
+    VariadicExpand(
+        {(*os << separator << "has field #" << I << " that ",
+          std::get<I>(matchers_).DescribeTo(os), separator = ", and ")...});
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    const char* separator = "";
+    VariadicExpand({(*os << separator << "has field #" << I << " that ",
+                     std::get<I>(matchers_).DescribeNegationTo(os),
+                     separator = ", or ")...});
+  }
+
+  bool MatchAndExplain(Struct t, MatchResultListener* listener) const override {
+    return MatchInternal((UnpackStruct<sizeof...(I)>)(t), listener);
+  }
+
+ private:
+  bool MatchInternal(UnpackedType tuple, MatchResultListener* listener) const {
+    if (!listener->IsInterested()) {
+      // If the listener is not interested, we don't need to construct the
+      // explanation.
+      bool good = true;
+      VariadicExpand({good = good && std::get<I>(matchers_).Matches(
+                                         std::get<I>(tuple))...});
+      return good;
+    }
+
+    size_t failed_pos = ~size_t{};
+
+    std::vector<StringMatchResultListener> inner_listener(sizeof...(I));
+
+    VariadicExpand(
+        {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain(
+                                        std::get<I>(tuple), &inner_listener[I])
+             ? failed_pos = I
+             : 0 ...});
+    if (failed_pos != ~size_t{}) {
+      *listener << "whose field #" << failed_pos << " does not match";
+      PrintIfNotEmpty(inner_listener[failed_pos].str(), listener->stream());
+      return false;
+    }
+
+    *listener << "whose all elements match";
+    const char* separator = ", where";
+    for (size_t index = 0; index < sizeof...(I); ++index) {
+      const std::string str = inner_listener[index].str();
+      if (!str.empty()) {
+        *listener << separator << " field #" << index << " is a value " << str;
+        separator = ", and";
+      }
+    }
+
+    return true;
+  }
+
+  MatchersType matchers_;
+};
+
+template <typename... Inner>
+class FieldsAreMatcher {
+ public:
+  explicit FieldsAreMatcher(Inner... inner) : matchers_(std::move(inner)...) {}
+
+  template <typename Struct>
+  operator Matcher<Struct>() const {  // NOLINT
+    return Matcher<Struct>(
+        new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>(
+            matchers_));
+  }
+
+ private:
+  std::tuple<Inner...> matchers_;
+};
+
+// Implements ElementsAre() and ElementsAreArray().
+template <typename Container>
+class ElementsAreMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename InputIter>
+  ElementsAreMatcherImpl(InputIter first, InputIter last) {
+    while (first != last) {
+      matchers_.push_back(MatcherCast<const Element&>(*first++));
+    }
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    if (count() == 0) {
+      *os << "is empty";
+    } else if (count() == 1) {
+      *os << "has 1 element that ";
+      matchers_[0].DescribeTo(os);
+    } else {
+      *os << "has " << Elements(count()) << " where\n";
+      for (size_t i = 0; i != count(); ++i) {
+        *os << "element #" << i << " ";
+        matchers_[i].DescribeTo(os);
+        if (i + 1 < count()) {
+          *os << ",\n";
+        }
+      }
+    }
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    if (count() == 0) {
+      *os << "isn't empty";
+      return;
+    }
+
+    *os << "doesn't have " << Elements(count()) << ", or\n";
+    for (size_t i = 0; i != count(); ++i) {
+      *os << "element #" << i << " ";
+      matchers_[i].DescribeNegationTo(os);
+      if (i + 1 < count()) {
+        *os << ", or\n";
+      }
+    }
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    // To work with stream-like "containers", we must only walk
+    // through the elements in one pass.
+
+    const bool listener_interested = listener->IsInterested();
+
+    // explanations[i] is the explanation of the element at index i.
+    ::std::vector<std::string> explanations(count());
+    StlContainerReference stl_container = View::ConstReference(container);
+    auto it = stl_container.begin();
+    size_t exam_pos = 0;
+    bool mismatch_found = false;  // Have we found a mismatched element yet?
+
+    // Go through the elements and matchers in pairs, until we reach
+    // the end of either the elements or the matchers, or until we find a
+    // mismatch.
+    for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
+      bool match;  // Does the current element match the current matcher?
+      if (listener_interested) {
+        StringMatchResultListener s;
+        match = matchers_[exam_pos].MatchAndExplain(*it, &s);
+        explanations[exam_pos] = s.str();
+      } else {
+        match = matchers_[exam_pos].Matches(*it);
+      }
+
+      if (!match) {
+        mismatch_found = true;
+        break;
+      }
+    }
+    // If mismatch_found is true, 'exam_pos' is the index of the mismatch.
+
+    // Find how many elements the actual container has.  We avoid
+    // calling size() s.t. this code works for stream-like "containers"
+    // that don't define size().
+    size_t actual_count = exam_pos;
+    for (; it != stl_container.end(); ++it) {
+      ++actual_count;
+    }
+
+    if (actual_count != count()) {
+      // The element count doesn't match.  If the container is empty,
+      // there's no need to explain anything as Google Mock already
+      // prints the empty container.  Otherwise we just need to show
+      // how many elements there actually are.
+      if (listener_interested && (actual_count != 0)) {
+        *listener << "which has " << Elements(actual_count);
+      }
+      return false;
+    }
+
+    if (mismatch_found) {
+      // The element count matches, but the exam_pos-th element doesn't match.
+      if (listener_interested) {
+        *listener << "whose element #" << exam_pos << " doesn't match";
+        PrintIfNotEmpty(explanations[exam_pos], listener->stream());
+      }
+      return false;
+    }
+
+    // Every element matches its expectation.  We need to explain why
+    // (the obvious ones can be skipped).
+    if (listener_interested) {
+      bool reason_printed = false;
+      for (size_t i = 0; i != count(); ++i) {
+        const std::string& s = explanations[i];
+        if (!s.empty()) {
+          if (reason_printed) {
+            *listener << ",\nand ";
+          }
+          *listener << "whose element #" << i << " matches, " << s;
+          reason_printed = true;
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  static Message Elements(size_t count) {
+    return Message() << count << (count == 1 ? " element" : " elements");
+  }
+
+  size_t count() const { return matchers_.size(); }
+
+  ::std::vector<Matcher<const Element&>> matchers_;
+};
+
+// Connectivity matrix of (elements X matchers), in element-major order.
+// Initially, there are no edges.
+// Use NextGraph() to iterate over all possible edge configurations.
+// Use Randomize() to generate a random edge configuration.
+class GTEST_API_ MatchMatrix {
+ public:
+  MatchMatrix(size_t num_elements, size_t num_matchers)
+      : num_elements_(num_elements),
+        num_matchers_(num_matchers),
+        matched_(num_elements_ * num_matchers_, 0) {}
+
+  size_t LhsSize() const { return num_elements_; }
+  size_t RhsSize() const { return num_matchers_; }
+  bool HasEdge(size_t ilhs, size_t irhs) const {
+    return matched_[SpaceIndex(ilhs, irhs)] == 1;
+  }
+  void SetEdge(size_t ilhs, size_t irhs, bool b) {
+    matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
+  }
+
+  // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,
+  // adds 1 to that number; returns false if incrementing the graph left it
+  // empty.
+  bool NextGraph();
+
+  void Randomize();
+
+  std::string DebugString() const;
+
+ private:
+  size_t SpaceIndex(size_t ilhs, size_t irhs) const {
+    return ilhs * num_matchers_ + irhs;
+  }
+
+  size_t num_elements_;
+  size_t num_matchers_;
+
+  // Each element is a char interpreted as bool. They are stored as a
+  // flattened array in lhs-major order, use 'SpaceIndex()' to translate
+  // a (ilhs, irhs) matrix coordinate into an offset.
+  ::std::vector<char> matched_;
+};
+
+typedef ::std::pair<size_t, size_t> ElementMatcherPair;
+typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
+
+// Returns a maximum bipartite matching for the specified graph 'g'.
+// The matching is represented as a vector of {element, matcher} pairs.
+GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g);
+
+struct UnorderedMatcherRequire {
+  enum Flags {
+    Superset = 1 << 0,
+    Subset = 1 << 1,
+    ExactMatch = Superset | Subset,
+  };
+};
+
+// Untyped base class for implementing UnorderedElementsAre.  By
+// putting logic that's not specific to the element type here, we
+// reduce binary bloat and increase compilation speed.
+class GTEST_API_ UnorderedElementsAreMatcherImplBase {
+ protected:
+  explicit UnorderedElementsAreMatcherImplBase(
+      UnorderedMatcherRequire::Flags matcher_flags)
+      : match_flags_(matcher_flags) {}
+
+  // A vector of matcher describers, one for each element matcher.
+  // Does not own the describers (and thus can be used only when the
+  // element matchers are alive).
+  typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;
+
+  // Describes this UnorderedElementsAre matcher.
+  void DescribeToImpl(::std::ostream* os) const;
+
+  // Describes the negation of this UnorderedElementsAre matcher.
+  void DescribeNegationToImpl(::std::ostream* os) const;
+
+  bool VerifyMatchMatrix(const ::std::vector<std::string>& element_printouts,
+                         const MatchMatrix& matrix,
+                         MatchResultListener* listener) const;
+
+  bool FindPairing(const MatchMatrix& matrix,
+                   MatchResultListener* listener) const;
+
+  MatcherDescriberVec& matcher_describers() { return matcher_describers_; }
+
+  static Message Elements(size_t n) {
+    return Message() << n << " element" << (n == 1 ? "" : "s");
+  }
+
+  UnorderedMatcherRequire::Flags match_flags() const { return match_flags_; }
+
+ private:
+  UnorderedMatcherRequire::Flags match_flags_;
+  MatcherDescriberVec matcher_describers_;
+};
+
+// Implements UnorderedElementsAre, UnorderedElementsAreArray, IsSubsetOf, and
+// IsSupersetOf.
+template <typename Container>
+class UnorderedElementsAreMatcherImpl
+    : public MatcherInterface<Container>,
+      public UnorderedElementsAreMatcherImplBase {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  template <typename InputIter>
+  UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags,
+                                  InputIter first, InputIter last)
+      : UnorderedElementsAreMatcherImplBase(matcher_flags) {
+    for (; first != last; ++first) {
+      matchers_.push_back(MatcherCast<const Element&>(*first));
+    }
+    for (const auto& m : matchers_) {
+      matcher_describers().push_back(m.GetDescriber());
+    }
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    StlContainerReference stl_container = View::ConstReference(container);
+    ::std::vector<std::string> element_printouts;
+    MatchMatrix matrix =
+        AnalyzeElements(stl_container.begin(), stl_container.end(),
+                        &element_printouts, listener);
+
+    if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) {
+      return true;
+    }
+
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      if (matrix.LhsSize() != matrix.RhsSize()) {
+        // The element count doesn't match.  If the container is empty,
+        // there's no need to explain anything as Google Mock already
+        // prints the empty container. Otherwise we just need to show
+        // how many elements there actually are.
+        if (matrix.LhsSize() != 0 && listener->IsInterested()) {
+          *listener << "which has " << Elements(matrix.LhsSize());
+        }
+        return false;
+      }
+    }
+
+    return VerifyMatchMatrix(element_printouts, matrix, listener) &&
+           FindPairing(matrix, listener);
+  }
+
+ private:
+  template <typename ElementIter>
+  MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
+                              ::std::vector<std::string>* element_printouts,
+                              MatchResultListener* listener) const {
+    element_printouts->clear();
+    ::std::vector<char> did_match;
+    size_t num_elements = 0;
+    DummyMatchResultListener dummy;
+    for (; elem_first != elem_last; ++num_elements, ++elem_first) {
+      if (listener->IsInterested()) {
+        element_printouts->push_back(PrintToString(*elem_first));
+      }
+      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
+        did_match.push_back(
+            matchers_[irhs].MatchAndExplain(*elem_first, &dummy));
+      }
+    }
+
+    MatchMatrix matrix(num_elements, matchers_.size());
+    ::std::vector<char>::const_iterator did_match_iter = did_match.begin();
+    for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) {
+      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
+        matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);
+      }
+    }
+    return matrix;
+  }
+
+  ::std::vector<Matcher<const Element&>> matchers_;
+};
+
+// Functor for use in TransformTuple.
+// Performs MatcherCast<Target> on an input argument of any type.
+template <typename Target>
+struct CastAndAppendTransform {
+  template <typename Arg>
+  Matcher<Target> operator()(const Arg& a) const {
+    return MatcherCast<Target>(a);
+  }
+};
+
+// Implements UnorderedElementsAre.
+template <typename MatcherTuple>
+class UnorderedElementsAreMatcher {
+ public:
+  explicit UnorderedElementsAreMatcher(const MatcherTuple& args)
+      : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+    typedef typename internal::StlContainerView<RawContainer>::type View;
+    typedef typename View::value_type Element;
+    typedef ::std::vector<Matcher<const Element&>> MatcherVec;
+    MatcherVec matchers;
+    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return Matcher<Container>(
+        new UnorderedElementsAreMatcherImpl<const Container&>(
+            UnorderedMatcherRequire::ExactMatch, matchers.begin(),
+            matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+};
+
+// Implements ElementsAre.
+template <typename MatcherTuple>
+class ElementsAreMatcher {
+ public:
+  explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    GTEST_COMPILE_ASSERT_(
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
+            ::std::tuple_size<MatcherTuple>::value < 2,
+        use_UnorderedElementsAre_with_hash_tables);
+
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+    typedef typename internal::StlContainerView<RawContainer>::type View;
+    typedef typename View::value_type Element;
+    typedef ::std::vector<Matcher<const Element&>> MatcherVec;
+    MatcherVec matchers;
+    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
+        matchers.begin(), matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+};
+
+// Implements UnorderedElementsAreArray(), IsSubsetOf(), and IsSupersetOf().
+template <typename T>
+class UnorderedElementsAreArrayMatcher {
+ public:
+  template <typename Iter>
+  UnorderedElementsAreArrayMatcher(UnorderedMatcherRequire::Flags match_flags,
+                                   Iter first, Iter last)
+      : match_flags_(match_flags), matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(
+        new UnorderedElementsAreMatcherImpl<const Container&>(
+            match_flags_, matchers_.begin(), matchers_.end()));
+  }
+
+ private:
+  UnorderedMatcherRequire::Flags match_flags_;
+  ::std::vector<T> matchers_;
+};
+
+// Implements ElementsAreArray().
+template <typename T>
+class ElementsAreArrayMatcher {
+ public:
+  template <typename Iter>
+  ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    GTEST_COMPILE_ASSERT_(
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value,
+        use_UnorderedElementsAreArray_with_hash_tables);
+
+    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
+        matchers_.begin(), matchers_.end()));
+  }
+
+ private:
+  const ::std::vector<T> matchers_;
+};
+
+// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
+// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,
+// second) is a polymorphic matcher that matches a value x if and only if
+// tm matches tuple (x, second).  Useful for implementing
+// UnorderedPointwise() in terms of UnorderedElementsAreArray().
+//
+// BoundSecondMatcher is copyable and assignable, as we need to put
+// instances of this class in a vector when implementing
+// UnorderedPointwise().
+template <typename Tuple2Matcher, typename Second>
+class BoundSecondMatcher {
+ public:
+  BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
+      : tuple2_matcher_(tm), second_value_(second) {}
+
+  BoundSecondMatcher(const BoundSecondMatcher& other) = default;
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
+  }
+
+  // We have to define this for UnorderedPointwise() to compile in
+  // C++98 mode, as it puts BoundSecondMatcher instances in a vector,
+  // which requires the elements to be assignable in C++98.  The
+  // compiler cannot generate the operator= for us, as Tuple2Matcher
+  // and Second may not be assignable.
+  //
+  // However, this should never be called, so the implementation just
+  // need to assert.
+  void operator=(const BoundSecondMatcher& /*rhs*/) {
+    GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";
+  }
+
+ private:
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    typedef ::std::tuple<T, Second> ArgTuple;
+
+    Impl(const Tuple2Matcher& tm, const Second& second)
+        : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
+          second_value_(second) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "and ";
+      UniversalPrint(second_value_, os);
+      *os << " ";
+      mono_tuple2_matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+      return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
+                                                  listener);
+    }
+
+   private:
+    const Matcher<const ArgTuple&> mono_tuple2_matcher_;
+    const Second second_value_;
+  };
+
+  const Tuple2Matcher tuple2_matcher_;
+  const Second second_value_;
+};
+
+// Given a 2-tuple matcher tm and a value second,
+// MatcherBindSecond(tm, second) returns a matcher that matches a
+// value x if and only if tm matches tuple (x, second).  Useful for
+// implementing UnorderedPointwise() in terms of UnorderedElementsAreArray().
+template <typename Tuple2Matcher, typename Second>
+BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
+    const Tuple2Matcher& tm, const Second& second) {
+  return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
+}
+
+// Returns the description for a matcher defined using the MATCHER*()
+// macro where the user-supplied description string is "", if
+// 'negation' is false; otherwise returns the description of the
+// negation of the matcher.  'param_values' contains a list of strings
+// that are the print-out of the matcher's parameters.
+GTEST_API_ std::string FormatMatcherDescription(
+    bool negation, const char* matcher_name,
+    const std::vector<const char*>& param_names, const Strings& param_values);
+
+// Implements a matcher that checks the value of a optional<> type variable.
+template <typename ValueMatcher>
+class OptionalMatcher {
+ public:
+  explicit OptionalMatcher(const ValueMatcher& value_matcher)
+      : value_matcher_(value_matcher) {}
+
+  template <typename Optional>
+  operator Matcher<Optional>() const {
+    return Matcher<Optional>(new Impl<const Optional&>(value_matcher_));
+  }
+
+  template <typename Optional>
+  class Impl : public MatcherInterface<Optional> {
+   public:
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Optional) OptionalView;
+    typedef typename OptionalView::value_type ValueType;
+    explicit Impl(const ValueMatcher& value_matcher)
+        : value_matcher_(MatcherCast<ValueType>(value_matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "value ";
+      value_matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "value ";
+      value_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(Optional optional,
+                         MatchResultListener* listener) const override {
+      if (!optional) {
+        *listener << "which is not engaged";
+        return false;
+      }
+      const ValueType& value = *optional;
+      StringMatchResultListener value_listener;
+      const bool match = value_matcher_.MatchAndExplain(value, &value_listener);
+      *listener << "whose value " << PrintToString(value)
+                << (match ? " matches" : " doesn't match");
+      PrintIfNotEmpty(value_listener.str(), listener->stream());
+      return match;
+    }
+
+   private:
+    const Matcher<ValueType> value_matcher_;
+  };
+
+ private:
+  const ValueMatcher value_matcher_;
+};
+
+namespace variant_matcher {
+// Overloads to allow VariantMatcher to do proper ADL lookup.
+template <typename T>
+void holds_alternative() {}
+template <typename T>
+void get() {}
+
+// Implements a matcher that checks the value of a variant<> type variable.
+template <typename T>
+class VariantMatcher {
+ public:
+  explicit VariantMatcher(::testing::Matcher<const T&> matcher)
+      : matcher_(std::move(matcher)) {}
+
+  template <typename Variant>
+  bool MatchAndExplain(const Variant& value,
+                       ::testing::MatchResultListener* listener) const {
+    using std::get;
+    if (!listener->IsInterested()) {
+      return holds_alternative<T>(value) && matcher_.Matches(get<T>(value));
+    }
+
+    if (!holds_alternative<T>(value)) {
+      *listener << "whose value is not of type '" << GetTypeName() << "'";
+      return false;
+    }
+
+    const T& elem = get<T>(value);
+    StringMatchResultListener elem_listener;
+    const bool match = matcher_.MatchAndExplain(elem, &elem_listener);
+    *listener << "whose value " << PrintToString(elem)
+              << (match ? " matches" : " doesn't match");
+    PrintIfNotEmpty(elem_listener.str(), listener->stream());
+    return match;
+  }
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "is a variant<> with value of type '" << GetTypeName()
+        << "' and the value ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "is a variant<> with value of type other than '" << GetTypeName()
+        << "' or the value ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  static std::string GetTypeName() {
+#if GTEST_HAS_RTTI
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        return internal::GetTypeName<T>());
+#endif
+    return "the element type";
+  }
+
+  const ::testing::Matcher<const T&> matcher_;
+};
+
+}  // namespace variant_matcher
+
+namespace any_cast_matcher {
+
+// Overloads to allow AnyCastMatcher to do proper ADL lookup.
+template <typename T>
+void any_cast() {}
+
+// Implements a matcher that any_casts the value.
+template <typename T>
+class AnyCastMatcher {
+ public:
+  explicit AnyCastMatcher(const ::testing::Matcher<const T&>& matcher)
+      : matcher_(matcher) {}
+
+  template <typename AnyType>
+  bool MatchAndExplain(const AnyType& value,
+                       ::testing::MatchResultListener* listener) const {
+    if (!listener->IsInterested()) {
+      const T* ptr = any_cast<T>(&value);
+      return ptr != nullptr && matcher_.Matches(*ptr);
+    }
+
+    const T* elem = any_cast<T>(&value);
+    if (elem == nullptr) {
+      *listener << "whose value is not of type '" << GetTypeName() << "'";
+      return false;
+    }
+
+    StringMatchResultListener elem_listener;
+    const bool match = matcher_.MatchAndExplain(*elem, &elem_listener);
+    *listener << "whose value " << PrintToString(*elem)
+              << (match ? " matches" : " doesn't match");
+    PrintIfNotEmpty(elem_listener.str(), listener->stream());
+    return match;
+  }
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "is an 'any' type with value of type '" << GetTypeName()
+        << "' and the value ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "is an 'any' type with value of type other than '" << GetTypeName()
+        << "' or the value ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  static std::string GetTypeName() {
+#if GTEST_HAS_RTTI
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        return internal::GetTypeName<T>());
+#endif
+    return "the element type";
+  }
+
+  const ::testing::Matcher<const T&> matcher_;
+};
+
+}  // namespace any_cast_matcher
+
+// Implements the Args() matcher.
+template <class ArgsTuple, size_t... k>
+class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
+ public:
+  using RawArgsTuple = typename std::decay<ArgsTuple>::type;
+  using SelectedArgs =
+      std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>;
+  using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>;
+
+  template <typename InnerMatcher>
+  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
+      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
+
+  bool MatchAndExplain(ArgsTuple args,
+                       MatchResultListener* listener) const override {
+    // Workaround spurious C4100 on MSVC<=15.7 when k is empty.
+    (void)args;
+    const SelectedArgs& selected_args =
+        std::forward_as_tuple(std::get<k>(args)...);
+    if (!listener->IsInterested()) return inner_matcher_.Matches(selected_args);
+
+    PrintIndices(listener->stream());
+    *listener << "are " << PrintToString(selected_args);
+
+    StringMatchResultListener inner_listener;
+    const bool match =
+        inner_matcher_.MatchAndExplain(selected_args, &inner_listener);
+    PrintIfNotEmpty(inner_listener.str(), listener->stream());
+    return match;
+  }
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  // Prints the indices of the selected fields.
+  static void PrintIndices(::std::ostream* os) {
+    *os << "whose fields (";
+    const char* sep = "";
+    // Workaround spurious C4189 on MSVC<=15.7 when k is empty.
+    (void)sep;
+    const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...};
+    (void)dummy;
+    *os << ") ";
+  }
+
+  MonomorphicInnerMatcher inner_matcher_;
+};
+
+template <class InnerMatcher, size_t... k>
+class ArgsMatcher {
+ public:
+  explicit ArgsMatcher(InnerMatcher inner_matcher)
+      : inner_matcher_(std::move(inner_matcher)) {}
+
+  template <typename ArgsTuple>
+  operator Matcher<ArgsTuple>() const {  // NOLINT
+    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k...>(inner_matcher_));
+  }
+
+ private:
+  InnerMatcher inner_matcher_;
+};
+
+}  // namespace internal
+
+// ElementsAreArray(iterator_first, iterator_last)
+// ElementsAreArray(pointer, count)
+// ElementsAreArray(array)
+// ElementsAreArray(container)
+// ElementsAreArray({ e1, e2, ..., en })
+//
+// The ElementsAreArray() functions are like ElementsAre(...), except
+// that they are given a homogeneous sequence rather than taking each
+// element as a function argument. The sequence can be specified as an
+// array, a pointer and count, a vector, an initializer list, or an
+// STL iterator range. In each of these cases, the underlying sequence
+// can be either a sequence of values or a sequence of matchers.
+//
+// All forms of ElementsAreArray() make a copy of the input matcher sequence.
+
+template <typename Iter>
+inline internal::ElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+ElementsAreArray(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::ElementsAreArrayMatcher<T>(first, last);
+}
+
+template <typename T>
+inline auto ElementsAreArray(const T* pointer, size_t count)
+    -> decltype(ElementsAreArray(pointer, pointer + count)) {
+  return ElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline auto ElementsAreArray(const T (&array)[N])
+    -> decltype(ElementsAreArray(array, N)) {
+  return ElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline auto ElementsAreArray(const Container& container)
+    -> decltype(ElementsAreArray(container.begin(), container.end())) {
+  return ElementsAreArray(container.begin(), container.end());
+}
+
+template <typename T>
+inline auto ElementsAreArray(::std::initializer_list<T> xs)
+    -> decltype(ElementsAreArray(xs.begin(), xs.end())) {
+  return ElementsAreArray(xs.begin(), xs.end());
+}
+
+// UnorderedElementsAreArray(iterator_first, iterator_last)
+// UnorderedElementsAreArray(pointer, count)
+// UnorderedElementsAreArray(array)
+// UnorderedElementsAreArray(container)
+// UnorderedElementsAreArray({ e1, e2, ..., en })
+//
+// UnorderedElementsAreArray() verifies that a bijective mapping onto a
+// collection of matchers exists.
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+UnorderedElementsAreArray(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(
+      internal::UnorderedMatcherRequire::ExactMatch, first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray(
+    const T* pointer, size_t count) {
+  return UnorderedElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray(
+    const T (&array)[N]) {
+  return UnorderedElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+UnorderedElementsAreArray(const Container& container) {
+  return UnorderedElementsAreArray(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray(
+    ::std::initializer_list<T> xs) {
+  return UnorderedElementsAreArray(xs.begin(), xs.end());
+}
+
+// _ is a matcher that matches anything of any type.
+//
+// This definition is fine as:
+//
+//   1. The C++ standard permits using the name _ in a namespace that
+//      is not the global namespace or ::std.
+//   2. The AnythingMatcher class has no data member or constructor,
+//      so it's OK to create global variables of this type.
+//   3. c-style has approved of using _ in this case.
+const internal::AnythingMatcher _ = {};
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> A() {
+  return _;
+}
+
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> An() {
+  return _;
+}
+
+template <typename T, typename M>
+Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl(
+    const M& value, std::false_type /* convertible_to_matcher */,
+    std::false_type /* convertible_to_T */) {
+  return Eq(value);
+}
+
+// Creates a polymorphic matcher that matches any NULL pointer.
+inline PolymorphicMatcher<internal::IsNullMatcher> IsNull() {
+  return MakePolymorphicMatcher(internal::IsNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any non-NULL pointer.
+// This is convenient as Not(NULL) doesn't compile (the compiler
+// thinks that that expression is comparing a pointer with an integer).
+inline PolymorphicMatcher<internal::NotNullMatcher> NotNull() {
+  return MakePolymorphicMatcher(internal::NotNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any argument that
+// references variable x.
+template <typename T>
+inline internal::RefMatcher<T&> Ref(T& x) {  // NOLINT
+  return internal::RefMatcher<T&>(x);
+}
+
+// Creates a polymorphic matcher that matches any NaN floating point.
+inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() {
+  return MakePolymorphicMatcher(internal::IsNanMatcher());
+}
+
+// Creates a matcher that matches any double argument approximately
+// equal to rhs, where two NANs are considered unequal.
+inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
+  return internal::FloatingEqMatcher<double>(rhs, false);
+}
+
+// Creates a matcher that matches any double argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
+  return internal::FloatingEqMatcher<double>(rhs, true);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> DoubleNear(double rhs,
+                                                      double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
+    double rhs, double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, where two NANs are considered unequal.
+inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, false);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, true);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> FloatNear(float rhs,
+                                                    float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
+    float rhs, float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches a pointer (raw or smart) that points
+// to a value that matches inner_matcher.
+template <typename InnerMatcher>
+inline internal::PointeeMatcher<InnerMatcher> Pointee(
+    const InnerMatcher& inner_matcher) {
+  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
+}
+
+#if GTEST_HAS_RTTI
+// Creates a matcher that matches a pointer or reference that matches
+// inner_matcher when dynamic_cast<To> is applied.
+// The result of dynamic_cast<To> is forwarded to the inner matcher.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To>>
+WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
+  return MakePolymorphicMatcher(
+      internal::WhenDynamicCastToMatcher<To>(inner_matcher));
+}
+#endif  // GTEST_HAS_RTTI
+
+// Creates a matcher that matches an object whose given field matches
+// 'matcher'.  For example,
+//   Field(&Foo::number, Ge(5))
+// matches a Foo object x if and only if x.number >= 5.
+template <typename Class, typename FieldType, typename FieldMatcher>
+inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType>> Field(
+    FieldType Class::*field, const FieldMatcher& matcher) {
+  return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(
+      field, MatcherCast<const FieldType&>(matcher)));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   Field(&Foo::bar, m)
+  // to compile where bar is an int32 and m is a matcher for int64.
+}
+
+// Same as Field() but also takes the name of the field to provide better error
+// messages.
+template <typename Class, typename FieldType, typename FieldMatcher>
+inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType>> Field(
+    const std::string& field_name, FieldType Class::*field,
+    const FieldMatcher& matcher) {
+  return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(
+      field_name, field, MatcherCast<const FieldType&>(matcher)));
+}
+
+// Creates a matcher that matches an object whose given property
+// matches 'matcher'.  For example,
+//   Property(&Foo::str, StartsWith("hi"))
+// matches a Foo object x if and only if x.str() starts with "hi".
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const>>
+Property(PropertyType (Class::*property)() const,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const>(
+          property, MatcherCast<const PropertyType&>(matcher)));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   Property(&Foo::bar, m)
+  // to compile where bar() returns an int32 and m is a matcher for int64.
+}
+
+// Same as Property() above, but also takes the name of the property to provide
+// better error messages.
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const>>
+Property(const std::string& property_name,
+         PropertyType (Class::*property)() const,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const>(
+          property_name, property, MatcherCast<const PropertyType&>(matcher)));
+}
+
+// The same as above but for reference-qualified member functions.
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const&>>
+Property(PropertyType (Class::*property)() const&,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const&>(
+          property, MatcherCast<const PropertyType&>(matcher)));
+}
+
+// Three-argument form for reference-qualified member functions.
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const&>>
+Property(const std::string& property_name,
+         PropertyType (Class::*property)() const&,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const&>(
+          property_name, property, MatcherCast<const PropertyType&>(matcher)));
+}
+
+// Creates a matcher that matches an object if and only if the result of
+// applying a callable to x matches 'matcher'. For example,
+//   ResultOf(f, StartsWith("hi"))
+// matches a Foo object x if and only if f(x) starts with "hi".
+// `callable` parameter can be a function, function pointer, or a functor. It is
+// required to keep no state affecting the results of the calls on it and make
+// no assumptions about how many calls will be made. Any state it keeps must be
+// protected from the concurrent access.
+template <typename Callable, typename InnerMatcher>
+internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
+    Callable callable, InnerMatcher matcher) {
+  return internal::ResultOfMatcher<Callable, InnerMatcher>(std::move(callable),
+                                                           std::move(matcher));
+}
+
+// Same as ResultOf() above, but also takes a description of the `callable`
+// result to provide better error messages.
+template <typename Callable, typename InnerMatcher>
+internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
+    const std::string& result_description, Callable callable,
+    InnerMatcher matcher) {
+  return internal::ResultOfMatcher<Callable, InnerMatcher>(
+      result_description, std::move(callable), std::move(matcher));
+}
+
+// String matchers.
+
+// Matches a string equal to str.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrEq(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::string>(std::string(str), true, true));
+}
+
+// Matches a string not equal to str.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrNe(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::string>(std::string(str), false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseEq(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::string>(std::string(str), true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseNe(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>(
+      std::string(str), false, false));
+}
+
+// Creates a matcher that matches any string, std::string, or C string
+// that contains the given substring.
+template <typename T = std::string>
+PolymorphicMatcher<internal::HasSubstrMatcher<std::string>> HasSubstr(
+    const internal::StringLike<T>& substring) {
+  return MakePolymorphicMatcher(
+      internal::HasSubstrMatcher<std::string>(std::string(substring)));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+template <typename T = std::string>
+PolymorphicMatcher<internal::StartsWithMatcher<std::string>> StartsWith(
+    const internal::StringLike<T>& prefix) {
+  return MakePolymorphicMatcher(
+      internal::StartsWithMatcher<std::string>(std::string(prefix)));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+template <typename T = std::string>
+PolymorphicMatcher<internal::EndsWithMatcher<std::string>> EndsWith(
+    const internal::StringLike<T>& suffix) {
+  return MakePolymorphicMatcher(
+      internal::EndsWithMatcher<std::string>(std::string(suffix)));
+}
+
+#if GTEST_HAS_STD_WSTRING
+// Wide string matchers.
+
+// Matches a string equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrEq(
+    const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, true, true));
+}
+
+// Matches a string not equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrNe(
+    const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseEq(
+    const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseNe(
+    const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, false, false));
+}
+
+// Creates a matcher that matches any ::wstring, std::wstring, or C wide string
+// that contains the given substring.
+inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring>> HasSubstr(
+    const std::wstring& substring) {
+  return MakePolymorphicMatcher(
+      internal::HasSubstrMatcher<std::wstring>(substring));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring>> StartsWith(
+    const std::wstring& prefix) {
+  return MakePolymorphicMatcher(
+      internal::StartsWithMatcher<std::wstring>(prefix));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring>> EndsWith(
+    const std::wstring& suffix) {
+  return MakePolymorphicMatcher(
+      internal::EndsWithMatcher<std::wstring>(suffix));
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field == the second field.
+inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field >= the second field.
+inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field > the second field.
+inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field <= the second field.
+inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field < the second field.
+inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field != the second field.
+inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatEq(first field) matches the second field.
+inline internal::FloatingEq2Matcher<float> FloatEq() {
+  return internal::FloatingEq2Matcher<float>();
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleEq(first field) matches the second field.
+inline internal::FloatingEq2Matcher<double> DoubleEq() {
+  return internal::FloatingEq2Matcher<double>();
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatEq(first field) matches the second field with NaN equality.
+inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() {
+  return internal::FloatingEq2Matcher<float>(true);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleEq(first field) matches the second field with NaN equality.
+inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() {
+  return internal::FloatingEq2Matcher<double>(true);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatNear(first field, max_abs_error) matches the second field.
+inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) {
+  return internal::FloatingEq2Matcher<float>(max_abs_error);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleNear(first field, max_abs_error) matches the second field.
+inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_error) {
+  return internal::FloatingEq2Matcher<double>(max_abs_error);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatNear(first field, max_abs_error) matches the second field with NaN
+// equality.
+inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear(
+    float max_abs_error) {
+  return internal::FloatingEq2Matcher<float>(max_abs_error, true);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleNear(first field, max_abs_error) matches the second field with NaN
+// equality.
+inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear(
+    double max_abs_error) {
+  return internal::FloatingEq2Matcher<double>(max_abs_error, true);
+}
+
+// Creates a matcher that matches any value of type T that m doesn't
+// match.
+template <typename InnerMatcher>
+inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
+  return internal::NotMatcher<InnerMatcher>(m);
+}
+
+// Returns a matcher that matches anything that satisfies the given
+// predicate.  The predicate can be any unary function or functor
+// whose return type can be implicitly converted to bool.
+template <typename Predicate>
+inline PolymorphicMatcher<internal::TrulyMatcher<Predicate>> Truly(
+    Predicate pred) {
+  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
+}
+
+// Returns a matcher that matches the container size. The container must
+// support both size() and size_type which all STL-like containers provide.
+// Note that the parameter 'size' can be a value of type size_type as well as
+// matcher. For instance:
+//   EXPECT_THAT(container, SizeIs(2));     // Checks container has 2 elements.
+//   EXPECT_THAT(container, SizeIs(Le(2));  // Checks container has at most 2.
+template <typename SizeMatcher>
+inline internal::SizeIsMatcher<SizeMatcher> SizeIs(
+    const SizeMatcher& size_matcher) {
+  return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
+}
+
+// Returns a matcher that matches the distance between the container's begin()
+// iterator and its end() iterator, i.e. the size of the container. This matcher
+// can be used instead of SizeIs with containers such as std::forward_list which
+// do not implement size(). The container must provide const_iterator (with
+// valid iterator_traits), begin() and end().
+template <typename DistanceMatcher>
+inline internal::BeginEndDistanceIsMatcher<DistanceMatcher> BeginEndDistanceIs(
+    const DistanceMatcher& distance_matcher) {
+  return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
+}
+
+// Returns a matcher that matches an equal container.
+// This matcher behaves like Eq(), but in the event of mismatch lists the
+// values that are included in one container but not the other. (Duplicate
+// values and order differences are not explained.)
+template <typename Container>
+inline PolymorphicMatcher<
+    internal::ContainerEqMatcher<typename std::remove_const<Container>::type>>
+ContainerEq(const Container& rhs) {
+  return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs));
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the given comparator, matches container_matcher.
+template <typename Comparator, typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher> WhenSortedBy(
+    const Comparator& comparator, const ContainerMatcher& container_matcher) {
+  return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
+      comparator, container_matcher);
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the < operator, matches container_matcher.
+template <typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
+WhenSorted(const ContainerMatcher& container_matcher) {
+  return internal::WhenSortedByMatcher<internal::LessComparator,
+                                       ContainerMatcher>(
+      internal::LessComparator(), container_matcher);
+}
+
+// Matches an STL-style container or a native array that contains the
+// same number of elements as in rhs, where its i-th element and rhs's
+// i-th element (as a pair) satisfy the given pair matcher, for all i.
+// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const
+// T1&, const T2&> >, where T1 and T2 are the types of elements in the
+// LHS container and the RHS container respectively.
+template <typename TupleMatcher, typename Container>
+inline internal::PointwiseMatcher<TupleMatcher,
+                                  typename std::remove_const<Container>::type>
+Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
+  return internal::PointwiseMatcher<TupleMatcher, Container>(tuple_matcher,
+                                                             rhs);
+}
+
+// Supports the Pointwise(m, {a, b, c}) syntax.
+template <typename TupleMatcher, typename T>
+inline internal::PointwiseMatcher<TupleMatcher, std::vector<T>> Pointwise(
+    const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
+  return Pointwise(tuple_matcher, std::vector<T>(rhs));
+}
+
+// UnorderedPointwise(pair_matcher, rhs) matches an STL-style
+// container or a native array that contains the same number of
+// elements as in rhs, where in some permutation of the container, its
+// i-th element and rhs's i-th element (as a pair) satisfy the given
+// pair matcher, for all i.  Tuple2Matcher must be able to be safely
+// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are
+// the types of elements in the LHS container and the RHS container
+// respectively.
+//
+// This is like Pointwise(pair_matcher, rhs), except that the element
+// order doesn't matter.
+template <typename Tuple2Matcher, typename RhsContainer>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<
+        Tuple2Matcher,
+        typename internal::StlContainerView<
+            typename std::remove_const<RhsContainer>::type>::type::value_type>>
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   const RhsContainer& rhs_container) {
+  // RhsView allows the same code to handle RhsContainer being a
+  // STL-style container and it being a native C-style array.
+  typedef typename internal::StlContainerView<RhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type Second;
+  const RhsStlContainer& rhs_stl_container =
+      RhsView::ConstReference(rhs_container);
+
+  // Create a matcher for each element in rhs_container.
+  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second>> matchers;
+  for (auto it = rhs_stl_container.begin(); it != rhs_stl_container.end();
+       ++it) {
+    matchers.push_back(internal::MatcherBindSecond(tuple2_matcher, *it));
+  }
+
+  // Delegate the work to UnorderedElementsAreArray().
+  return UnorderedElementsAreArray(matchers);
+}
+
+// Supports the UnorderedPointwise(m, {a, b, c}) syntax.
+template <typename Tuple2Matcher, typename T>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<Tuple2Matcher, T>>
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   std::initializer_list<T> rhs) {
+  return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
+}
+
+// Matches an STL-style container or a native array that contains at
+// least one element matching the given value or matcher.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   page_ids.insert(3);
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Contains(1));
+//   EXPECT_THAT(page_ids, Contains(Gt(2)));
+//   EXPECT_THAT(page_ids, Not(Contains(4)));  // See below for Times(0)
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   EXPECT_THAT(page_lengths,
+//               Contains(::std::pair<const int, size_t>(1, 100)));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
+//
+// The matcher supports a modifier `Times` that allows to check for arbitrary
+// occurrences including testing for absence with Times(0).
+//
+// Examples:
+//   ::std::vector<int> ids;
+//   ids.insert(1);
+//   ids.insert(1);
+//   ids.insert(3);
+//   EXPECT_THAT(ids, Contains(1).Times(2));      // 1 occurs 2 times
+//   EXPECT_THAT(ids, Contains(2).Times(0));      // 2 is not present
+//   EXPECT_THAT(ids, Contains(3).Times(Ge(1)));  // 3 occurs at least once
+
+template <typename M>
+inline internal::ContainsMatcher<M> Contains(M matcher) {
+  return internal::ContainsMatcher<M>(matcher);
+}
+
+// IsSupersetOf(iterator_first, iterator_last)
+// IsSupersetOf(pointer, count)
+// IsSupersetOf(array)
+// IsSupersetOf(container)
+// IsSupersetOf({e1, e2, ..., en})
+//
+// IsSupersetOf() verifies that a surjective partial mapping onto a collection
+// of matchers exists. In other words, a container matches
+// IsSupersetOf({e1, ..., en}) if and only if there is a permutation
+// {y1, ..., yn} of some of the container's elements where y1 matches e1,
+// ..., and yn matches en. Obviously, the size of the container must be >= n
+// in order to have a match. Examples:
+//
+// - {1, 2, 3} matches IsSupersetOf({Ge(3), Ne(0)}), as 3 matches Ge(3) and
+//   1 matches Ne(0).
+// - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches
+//   both Eq(1) and Lt(2). The reason is that different matchers must be used
+//   for elements in different slots of the container.
+// - {1, 1, 2} matches IsSupersetOf({Eq(1), Lt(2)}), as (the first) 1 matches
+//   Eq(1) and (the second) 1 matches Lt(2).
+// - {1, 2, 3} matches IsSupersetOf(Gt(1), Gt(1)), as 2 matches (the first)
+//   Gt(1) and 3 matches (the second) Gt(1).
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+IsSupersetOf(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(
+      internal::UnorderedMatcherRequire::Superset, first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
+    const T* pointer, size_t count) {
+  return IsSupersetOf(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
+    const T (&array)[N]) {
+  return IsSupersetOf(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+IsSupersetOf(const Container& container) {
+  return IsSupersetOf(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
+    ::std::initializer_list<T> xs) {
+  return IsSupersetOf(xs.begin(), xs.end());
+}
+
+// IsSubsetOf(iterator_first, iterator_last)
+// IsSubsetOf(pointer, count)
+// IsSubsetOf(array)
+// IsSubsetOf(container)
+// IsSubsetOf({e1, e2, ..., en})
+//
+// IsSubsetOf() verifies that an injective mapping onto a collection of matchers
+// exists.  In other words, a container matches IsSubsetOf({e1, ..., en}) if and
+// only if there is a subset of matchers {m1, ..., mk} which would match the
+// container using UnorderedElementsAre.  Obviously, the size of the container
+// must be <= n in order to have a match. Examples:
+//
+// - {1} matches IsSubsetOf({Gt(0), Lt(0)}), as 1 matches Gt(0).
+// - {1, -1} matches IsSubsetOf({Lt(0), Gt(0)}), as 1 matches Gt(0) and -1
+//   matches Lt(0).
+// - {1, 2} doesn't matches IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both
+//   match Gt(0). The reason is that different matchers must be used for
+//   elements in different slots of the container.
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+IsSubsetOf(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(
+      internal::UnorderedMatcherRequire::Subset, first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
+    const T* pointer, size_t count) {
+  return IsSubsetOf(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
+    const T (&array)[N]) {
+  return IsSubsetOf(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+IsSubsetOf(const Container& container) {
+  return IsSubsetOf(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
+    ::std::initializer_list<T> xs) {
+  return IsSubsetOf(xs.begin(), xs.end());
+}
+
+// Matches an STL-style container or a native array that contains only
+// elements matching the given value or matcher.
+//
+// Each(m) is semantically equivalent to `Not(Contains(Not(m)))`. Only
+// the messages are different.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   // Each(m) matches an empty container, regardless of what m is.
+//   EXPECT_THAT(page_ids, Each(Eq(1)));
+//   EXPECT_THAT(page_ids, Each(Eq(77)));
+//
+//   page_ids.insert(3);
+//   EXPECT_THAT(page_ids, Each(Gt(0)));
+//   EXPECT_THAT(page_ids, Not(Each(Gt(4))));
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Not(Each(Lt(2))));
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   page_lengths[2] = 200;
+//   page_lengths[3] = 300;
+//   EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));
+//   EXPECT_THAT(page_lengths, Each(Key(Le(3))));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));
+template <typename M>
+inline internal::EachMatcher<M> Each(M matcher) {
+  return internal::EachMatcher<M>(matcher);
+}
+
+// Key(inner_matcher) matches an std::pair whose 'first' field matches
+// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
+// std::map that contains at least one element whose key is >= 5.
+template <typename M>
+inline internal::KeyMatcher<M> Key(M inner_matcher) {
+  return internal::KeyMatcher<M>(inner_matcher);
+}
+
+// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field
+// matches first_matcher and whose 'second' field matches second_matcher.  For
+// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used
+// to match a std::map<int, string> that contains exactly one element whose key
+// is >= 5 and whose value equals "foo".
+template <typename FirstMatcher, typename SecondMatcher>
+inline internal::PairMatcher<FirstMatcher, SecondMatcher> Pair(
+    FirstMatcher first_matcher, SecondMatcher second_matcher) {
+  return internal::PairMatcher<FirstMatcher, SecondMatcher>(first_matcher,
+                                                            second_matcher);
+}
+
+namespace no_adl {
+// Conditional() creates a matcher that conditionally uses either the first or
+// second matcher provided. For example, we could create an `equal if, and only
+// if' matcher using the Conditional wrapper as follows:
+//
+//   EXPECT_THAT(result, Conditional(condition, Eq(expected), Ne(expected)));
+template <typename MatcherTrue, typename MatcherFalse>
+internal::ConditionalMatcher<MatcherTrue, MatcherFalse> Conditional(
+    bool condition, MatcherTrue matcher_true, MatcherFalse matcher_false) {
+  return internal::ConditionalMatcher<MatcherTrue, MatcherFalse>(
+      condition, std::move(matcher_true), std::move(matcher_false));
+}
+
+// FieldsAre(matchers...) matches piecewise the fields of compatible structs.
+// These include those that support `get<I>(obj)`, and when structured bindings
+// are enabled any class that supports them.
+// In particular, `std::tuple`, `std::pair`, `std::array` and aggregate types.
+template <typename... M>
+internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre(
+    M&&... matchers) {
+  return internal::FieldsAreMatcher<typename std::decay<M>::type...>(
+      std::forward<M>(matchers)...);
+}
+
+// Creates a matcher that matches a pointer (raw or smart) that matches
+// inner_matcher.
+template <typename InnerMatcher>
+inline internal::PointerMatcher<InnerMatcher> Pointer(
+    const InnerMatcher& inner_matcher) {
+  return internal::PointerMatcher<InnerMatcher>(inner_matcher);
+}
+
+// Creates a matcher that matches an object that has an address that matches
+// inner_matcher.
+template <typename InnerMatcher>
+inline internal::AddressMatcher<InnerMatcher> Address(
+    const InnerMatcher& inner_matcher) {
+  return internal::AddressMatcher<InnerMatcher>(inner_matcher);
+}
+
+// Matches a base64 escaped string, when the unescaped string matches the
+// internal matcher.
+template <typename MatcherType>
+internal::WhenBase64UnescapedMatcher WhenBase64Unescaped(
+    const MatcherType& internal_matcher) {
+  return internal::WhenBase64UnescapedMatcher(internal_matcher);
+}
+}  // namespace no_adl
+
+// Returns a predicate that is satisfied by anything that matches the
+// given matcher.
+template <typename M>
+inline internal::MatcherAsPredicate<M> Matches(M matcher) {
+  return internal::MatcherAsPredicate<M>(matcher);
+}
+
+// Returns true if and only if the value matches the matcher.
+template <typename T, typename M>
+inline bool Value(const T& value, M matcher) {
+  return testing::Matches(matcher)(value);
+}
+
+// Matches the value against the given matcher and explains the match
+// result to listener.
+template <typename T, typename M>
+inline bool ExplainMatchResult(M matcher, const T& value,
+                               MatchResultListener* listener) {
+  return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
+}
+
+// Returns a string representation of the given matcher.  Useful for description
+// strings of matchers defined using MATCHER_P* macros that accept matchers as
+// their arguments.  For example:
+//
+// MATCHER_P(XAndYThat, matcher,
+//           "X that " + DescribeMatcher<int>(matcher, negation) +
+//               " and Y that " + DescribeMatcher<double>(matcher, negation)) {
+//   return ExplainMatchResult(matcher, arg.x(), result_listener) &&
+//          ExplainMatchResult(matcher, arg.y(), result_listener);
+// }
+template <typename T, typename M>
+std::string DescribeMatcher(const M& matcher, bool negation = false) {
+  ::std::stringstream ss;
+  Matcher<T> monomorphic_matcher = SafeMatcherCast<T>(matcher);
+  if (negation) {
+    monomorphic_matcher.DescribeNegationTo(&ss);
+  } else {
+    monomorphic_matcher.DescribeTo(&ss);
+  }
+  return ss.str();
+}
+
+template <typename... Args>
+internal::ElementsAreMatcher<
+    std::tuple<typename std::decay<const Args&>::type...>>
+ElementsAre(const Args&... matchers) {
+  return internal::ElementsAreMatcher<
+      std::tuple<typename std::decay<const Args&>::type...>>(
+      std::make_tuple(matchers...));
+}
+
+template <typename... Args>
+internal::UnorderedElementsAreMatcher<
+    std::tuple<typename std::decay<const Args&>::type...>>
+UnorderedElementsAre(const Args&... matchers) {
+  return internal::UnorderedElementsAreMatcher<
+      std::tuple<typename std::decay<const Args&>::type...>>(
+      std::make_tuple(matchers...));
+}
+
+// Define variadic matcher versions.
+template <typename... Args>
+internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf(
+    const Args&... matchers) {
+  return internal::AllOfMatcher<typename std::decay<const Args&>::type...>(
+      matchers...);
+}
+
+template <typename... Args>
+internal::AnyOfMatcher<typename std::decay<const Args&>::type...> AnyOf(
+    const Args&... matchers) {
+  return internal::AnyOfMatcher<typename std::decay<const Args&>::type...>(
+      matchers...);
+}
+
+// AnyOfArray(array)
+// AnyOfArray(pointer, count)
+// AnyOfArray(container)
+// AnyOfArray({ e1, e2, ..., en })
+// AnyOfArray(iterator_first, iterator_last)
+//
+// AnyOfArray() verifies whether a given value matches any member of a
+// collection of matchers.
+//
+// AllOfArray(array)
+// AllOfArray(pointer, count)
+// AllOfArray(container)
+// AllOfArray({ e1, e2, ..., en })
+// AllOfArray(iterator_first, iterator_last)
+//
+// AllOfArray() verifies whether a given value matches all members of a
+// collection of matchers.
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::AnyOfArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+AnyOfArray(Iter first, Iter last) {
+  return internal::AnyOfArrayMatcher<
+      typename ::std::iterator_traits<Iter>::value_type>(first, last);
+}
+
+template <typename Iter>
+inline internal::AllOfArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+AllOfArray(Iter first, Iter last) {
+  return internal::AllOfArrayMatcher<
+      typename ::std::iterator_traits<Iter>::value_type>(first, last);
+}
+
+template <typename T>
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t count) {
+  return AnyOfArray(ptr, ptr + count);
+}
+
+template <typename T>
+inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t count) {
+  return AllOfArray(ptr, ptr + count);
+}
+
+template <typename T, size_t N>
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) {
+  return AnyOfArray(array, N);
+}
+
+template <typename T, size_t N>
+inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) {
+  return AllOfArray(array, N);
+}
+
+template <typename Container>
+inline internal::AnyOfArrayMatcher<typename Container::value_type> AnyOfArray(
+    const Container& container) {
+  return AnyOfArray(container.begin(), container.end());
+}
+
+template <typename Container>
+inline internal::AllOfArrayMatcher<typename Container::value_type> AllOfArray(
+    const Container& container) {
+  return AllOfArray(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(
+    ::std::initializer_list<T> xs) {
+  return AnyOfArray(xs.begin(), xs.end());
+}
+
+template <typename T>
+inline internal::AllOfArrayMatcher<T> AllOfArray(
+    ::std::initializer_list<T> xs) {
+  return AllOfArray(xs.begin(), xs.end());
+}
+
+// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
+// fields of it matches a_matcher.  C++ doesn't support default
+// arguments for function templates, so we have to overload it.
+template <size_t... k, typename InnerMatcher>
+internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args(
+    InnerMatcher&& matcher) {
+  return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...>(
+      std::forward<InnerMatcher>(matcher));
+}
+
+// AllArgs(m) is a synonym of m.  This is useful in
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
+//
+// which is easier to read than
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(Eq());
+template <typename InnerMatcher>
+inline InnerMatcher AllArgs(const InnerMatcher& matcher) {
+  return matcher;
+}
+
+// Returns a matcher that matches the value of an optional<> type variable.
+// The matcher implementation only uses '!arg' and requires that the optional<>
+// type has a 'value_type' member type and that '*arg' is of type 'value_type'
+// and is printable using 'PrintToString'. It is compatible with
+// std::optional/std::experimental::optional.
+// Note that to compare an optional type variable against nullopt you should
+// use Eq(nullopt) and not Eq(Optional(nullopt)). The latter implies that the
+// optional value contains an optional itself.
+template <typename ValueMatcher>
+inline internal::OptionalMatcher<ValueMatcher> Optional(
+    const ValueMatcher& value_matcher) {
+  return internal::OptionalMatcher<ValueMatcher>(value_matcher);
+}
+
+// Returns a matcher that matches the value of a absl::any type variable.
+template <typename T>
+PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T>> AnyWith(
+    const Matcher<const T&>& matcher) {
+  return MakePolymorphicMatcher(
+      internal::any_cast_matcher::AnyCastMatcher<T>(matcher));
+}
+
+// Returns a matcher that matches the value of a variant<> type variable.
+// The matcher implementation uses ADL to find the holds_alternative and get
+// functions.
+// It is compatible with std::variant.
+template <typename T>
+PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T>> VariantWith(
+    const Matcher<const T&>& matcher) {
+  return MakePolymorphicMatcher(
+      internal::variant_matcher::VariantMatcher<T>(matcher));
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Anything inside the `internal` namespace is internal to the implementation
+// and must not be used in user code!
+namespace internal {
+
+class WithWhatMatcherImpl {
+ public:
+  WithWhatMatcherImpl(Matcher<std::string> matcher)
+      : matcher_(std::move(matcher)) {}
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "contains .what() that ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "contains .what() that does not ";
+    matcher_.DescribeTo(os);
+  }
+
+  template <typename Err>
+  bool MatchAndExplain(const Err& err, MatchResultListener* listener) const {
+    *listener << "which contains .what() (of value = " << err.what()
+              << ") that ";
+    return matcher_.MatchAndExplain(err.what(), listener);
+  }
+
+ private:
+  const Matcher<std::string> matcher_;
+};
+
+inline PolymorphicMatcher<WithWhatMatcherImpl> WithWhat(
+    Matcher<std::string> m) {
+  return MakePolymorphicMatcher(WithWhatMatcherImpl(std::move(m)));
+}
+
+template <typename Err>
+class ExceptionMatcherImpl {
+  class NeverThrown {
+   public:
+    const char* what() const noexcept {
+      return "this exception should never be thrown";
+    }
+  };
+
+  // If the matchee raises an exception of a wrong type, we'd like to
+  // catch it and print its message and type. To do that, we add an additional
+  // catch clause:
+  //
+  //     try { ... }
+  //     catch (const Err&) { /* an expected exception */ }
+  //     catch (const std::exception&) { /* exception of a wrong type */ }
+  //
+  // However, if the `Err` itself is `std::exception`, we'd end up with two
+  // identical `catch` clauses:
+  //
+  //     try { ... }
+  //     catch (const std::exception&) { /* an expected exception */ }
+  //     catch (const std::exception&) { /* exception of a wrong type */ }
+  //
+  // This can cause a warning or an error in some compilers. To resolve
+  // the issue, we use a fake error type whenever `Err` is `std::exception`:
+  //
+  //     try { ... }
+  //     catch (const std::exception&) { /* an expected exception */ }
+  //     catch (const NeverThrown&) { /* exception of a wrong type */ }
+  using DefaultExceptionType = typename std::conditional<
+      std::is_same<typename std::remove_cv<
+                       typename std::remove_reference<Err>::type>::type,
+                   std::exception>::value,
+      const NeverThrown&, const std::exception&>::type;
+
+ public:
+  ExceptionMatcherImpl(Matcher<const Err&> matcher)
+      : matcher_(std::move(matcher)) {}
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "throws an exception which is a " << GetTypeName<Err>();
+    *os << " which ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "throws an exception which is not a " << GetTypeName<Err>();
+    *os << " which ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(T&& x, MatchResultListener* listener) const {
+    try {
+      (void)(std::forward<T>(x)());
+    } catch (const Err& err) {
+      *listener << "throws an exception which is a " << GetTypeName<Err>();
+      *listener << " ";
+      return matcher_.MatchAndExplain(err, listener);
+    } catch (DefaultExceptionType err) {
+#if GTEST_HAS_RTTI
+      *listener << "throws an exception of type " << GetTypeName(typeid(err));
+      *listener << " ";
+#else
+      *listener << "throws an std::exception-derived type ";
+#endif
+      *listener << "with description \"" << err.what() << "\"";
+      return false;
+    } catch (...) {
+      *listener << "throws an exception of an unknown type";
+      return false;
+    }
+
+    *listener << "does not throw any exception";
+    return false;
+  }
+
+ private:
+  const Matcher<const Err&> matcher_;
+};
+
+}  // namespace internal
+
+// Throws()
+// Throws(exceptionMatcher)
+// ThrowsMessage(messageMatcher)
+//
+// This matcher accepts a callable and verifies that when invoked, it throws
+// an exception with the given type and properties.
+//
+// Examples:
+//
+//   EXPECT_THAT(
+//       []() { throw std::runtime_error("message"); },
+//       Throws<std::runtime_error>());
+//
+//   EXPECT_THAT(
+//       []() { throw std::runtime_error("message"); },
+//       ThrowsMessage<std::runtime_error>(HasSubstr("message")));
+//
+//   EXPECT_THAT(
+//       []() { throw std::runtime_error("message"); },
+//       Throws<std::runtime_error>(
+//           Property(&std::runtime_error::what, HasSubstr("message"))));
+
+template <typename Err>
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws() {
+  return MakePolymorphicMatcher(
+      internal::ExceptionMatcherImpl<Err>(A<const Err&>()));
+}
+
+template <typename Err, typename ExceptionMatcher>
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws(
+    const ExceptionMatcher& exception_matcher) {
+  // Using matcher cast allows users to pass a matcher of a more broad type.
+  // For example user may want to pass Matcher<std::exception>
+  // to Throws<std::runtime_error>, or Matcher<int64> to Throws<int32>.
+  return MakePolymorphicMatcher(internal::ExceptionMatcherImpl<Err>(
+      SafeMatcherCast<const Err&>(exception_matcher)));
+}
+
+template <typename Err, typename MessageMatcher>
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
+    MessageMatcher&& message_matcher) {
+  static_assert(std::is_base_of<std::exception, Err>::value,
+                "expected an std::exception-derived type");
+  return Throws<Err>(internal::WithWhat(
+      MatcherCast<std::string>(std::forward<MessageMatcher>(message_matcher))));
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// These macros allow using matchers to check values in Google Test
+// tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
+// succeed if and only if the value matches the matcher.  If the assertion
+// fails, the value and the description of the matcher will be printed.
+#define ASSERT_THAT(value, matcher) \
+  ASSERT_PRED_FORMAT1(              \
+      ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+#define EXPECT_THAT(value, matcher) \
+  EXPECT_PRED_FORMAT1(              \
+      ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+
+// MATCHER* macros itself are listed below.
+#define MATCHER(name, description)                                             \
+  class name##Matcher                                                          \
+      : public ::testing::internal::MatcherBaseImpl<name##Matcher> {           \
+   public:                                                                     \
+    template <typename arg_type>                                               \
+    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
+     public:                                                                   \
+      gmock_Impl() {}                                                          \
+      bool MatchAndExplain(                                                    \
+          const arg_type& arg,                                                 \
+          ::testing::MatchResultListener* result_listener) const override;     \
+      void DescribeTo(::std::ostream* gmock_os) const override {               \
+        *gmock_os << FormatDescription(false);                                 \
+      }                                                                        \
+      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \
+        *gmock_os << FormatDescription(true);                                  \
+      }                                                                        \
+                                                                               \
+     private:                                                                  \
+      ::std::string FormatDescription(bool negation) const {                   \
+        /* NOLINTNEXTLINE readability-redundant-string-init */                 \
+        ::std::string gmock_description = (description);                       \
+        if (!gmock_description.empty()) {                                      \
+          return gmock_description;                                            \
+        }                                                                      \
+        return ::testing::internal::FormatMatcherDescription(negation, #name,  \
+                                                             {}, {});          \
+      }                                                                        \
+    };                                                                         \
+  };                                                                           \
+  GTEST_ATTRIBUTE_UNUSED_ inline name##Matcher name() { return {}; }           \
+  template <typename arg_type>                                                 \
+  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(                   \
+      const arg_type& arg,                                                     \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \
+      const
+
+#define MATCHER_P(name, p0, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (#p0), (p0))
+#define MATCHER_P2(name, p0, p1, description)                            \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (#p0, #p1), \
+                         (p0, p1))
+#define MATCHER_P3(name, p0, p1, p2, description)                             \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (#p0, #p1, #p2), \
+                         (p0, p1, p2))
+#define MATCHER_P4(name, p0, p1, p2, p3, description)        \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, \
+                         (#p0, #p1, #p2, #p3), (p0, p1, p2, p3))
+#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)    \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \
+                         (#p0, #p1, #p2, #p3, #p4), (p0, p1, p2, p3, p4))
+#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description,  \
+                         (#p0, #p1, #p2, #p3, #p4, #p5),      \
+                         (p0, p1, p2, p3, p4, p5))
+#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description,      \
+                         (#p0, #p1, #p2, #p3, #p4, #p5, #p6),     \
+                         (p0, p1, p2, p3, p4, p5, p6))
+#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description,          \
+                         (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7),    \
+                         (p0, p1, p2, p3, p4, p5, p6, p7))
+#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description,              \
+                         (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7, #p8),   \
+                         (p0, p1, p2, p3, p4, p5, p6, p7, p8))
+#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description,                  \
+                         (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7, #p8, #p9),   \
+                         (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))
+
+#define GMOCK_INTERNAL_MATCHER(name, full_name, description, arg_names, args)  \
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
+  class full_name : public ::testing::internal::MatcherBaseImpl<               \
+                        full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \
+   public:                                                                     \
+    using full_name::MatcherBaseImpl::MatcherBaseImpl;                         \
+    template <typename arg_type>                                               \
+    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
+     public:                                                                   \
+      explicit gmock_Impl(GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args))          \
+          : GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) {}                       \
+      bool MatchAndExplain(                                                    \
+          const arg_type& arg,                                                 \
+          ::testing::MatchResultListener* result_listener) const override;     \
+      void DescribeTo(::std::ostream* gmock_os) const override {               \
+        *gmock_os << FormatDescription(false);                                 \
+      }                                                                        \
+      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \
+        *gmock_os << FormatDescription(true);                                  \
+      }                                                                        \
+      GMOCK_INTERNAL_MATCHER_MEMBERS(args)                                     \
+                                                                               \
+     private:                                                                  \
+      ::std::string FormatDescription(bool negation) const {                   \
+        ::std::string gmock_description = (description);                       \
+        if (!gmock_description.empty()) {                                      \
+          return gmock_description;                                            \
+        }                                                                      \
+        return ::testing::internal::FormatMatcherDescription(                  \
+            negation, #name, {GMOCK_PP_REMOVE_PARENS(arg_names)},              \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(      \
+                ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(        \
+                    GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args))));             \
+      }                                                                        \
+    };                                                                         \
+  };                                                                           \
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
+  inline full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)> name(             \
+      GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) {                            \
+    return full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(                \
+        GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args));                              \
+  }                                                                            \
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
+  template <typename arg_type>                                                 \
+  bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl<        \
+      arg_type>::MatchAndExplain(const arg_type& arg,                          \
+                                 ::testing::MatchResultListener*               \
+                                     result_listener GTEST_ATTRIBUTE_UNUSED_)  \
+      const
+
+#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \
+  GMOCK_PP_TAIL(                                     \
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM, , args))
+#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM(i_unused, data_unused, arg) \
+  , typename arg##_type
+
+#define GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TYPE_PARAM, , args))
+#define GMOCK_INTERNAL_MATCHER_TYPE_PARAM(i_unused, data_unused, arg) \
+  , arg##_type
+
+#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args) \
+  GMOCK_PP_TAIL(dummy_first GMOCK_PP_FOR_EACH(     \
+      GMOCK_INTERNAL_MATCHER_FUNCTION_ARG, , args))
+#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARG(i, data_unused, arg) \
+  , arg##_type gmock_p##i
+
+#define GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_FORWARD_ARG, , args))
+#define GMOCK_INTERNAL_MATCHER_FORWARD_ARG(i, data_unused, arg) \
+  , arg(::std::forward<arg##_type>(gmock_p##i))
+
+#define GMOCK_INTERNAL_MATCHER_MEMBERS(args) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER, , args)
+#define GMOCK_INTERNAL_MATCHER_MEMBER(i_unused, data_unused, arg) \
+  const arg##_type arg;
+
+#define GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER_USAGE, , args))
+#define GMOCK_INTERNAL_MATCHER_MEMBER_USAGE(i_unused, data_unused, arg) , arg
+
+#define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args))
+#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \
+  , gmock_p##i
+
+// To prevent ADL on certain functions we put them on a separate namespace.
+using namespace no_adl;  // NOLINT
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046
+
+// Include any custom callback matchers added by the local installation.
+// We must include this header at the end to make sure it can use the
+// declarations from this file.
+#include "gmock/internal/custom/gmock-matchers.h"
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
diff --git a/tools/gtest_lib/include/gmock/gmock-more-actions.h b/tools/gtest_lib/include/gmock/gmock-more-actions.h
new file mode 100644
index 0000000000000000000000000000000000000000..bf85ff51c6507d570407845d8b0509541ccede16
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/gmock-more-actions.h
@@ -0,0 +1,573 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used variadic actions.
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+
+#include <memory>
+#include <utility>
+
+#include "gmock/gmock-actions.h"
+#include "gmock/internal/gmock-port.h"
+
+// Include any custom callback actions added by the local installation.
+#include "gmock/internal/custom/gmock-generated-actions.h"
+
+// Sometimes you want to give an action explicit template parameters
+// that cannot be inferred from its value parameters.  ACTION() and
+// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that
+// and can be viewed as an extension to ACTION() and ACTION_P*().
+//
+// The syntax:
+//
+//   ACTION_TEMPLATE(ActionName,
+//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
+//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
+//
+// defines an action template that takes m explicit template
+// parameters and n value parameters.  name_i is the name of the i-th
+// template parameter, and kind_i specifies whether it's a typename,
+// an integral constant, or a template.  p_i is the name of the i-th
+// value parameter.
+//
+// Example:
+//
+//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock
+//   // function to type T and copies it to *output.
+//   ACTION_TEMPLATE(DuplicateArg,
+//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
+//                   AND_1_VALUE_PARAMS(output)) {
+//     *output = T(::std::get<k>(args));
+//   }
+//   ...
+//     int n;
+//     EXPECT_CALL(mock, Foo(_, _))
+//         .WillOnce(DuplicateArg<1, unsigned char>(&n));
+//
+// To create an instance of an action template, write:
+//
+//   ActionName<t1, ..., t_m>(v1, ..., v_n)
+//
+// where the ts are the template arguments and the vs are the value
+// arguments.  The value argument types are inferred by the compiler.
+// If you want to explicitly specify the value argument types, you can
+// provide additional template arguments:
+//
+//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
+//
+// where u_i is the desired type of v_i.
+//
+// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
+// number of value parameters, but not on the number of template
+// parameters.  Without the restriction, the meaning of the following
+// is unclear:
+//
+//   OverloadedAction<int, bool>(x);
+//
+// Are we using a single-template-parameter action where 'bool' refers
+// to the type of x, or are we using a two-template-parameter action
+// where the compiler is asked to infer the type of x?
+//
+// Implementation notes:
+//
+// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
+// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
+// implementing ACTION_TEMPLATE.  The main trick we use is to create
+// new macro invocations when expanding a macro.  For example, we have
+//
+//   #define ACTION_TEMPLATE(name, template_params, value_params)
+//       ... GMOCK_INTERNAL_DECL_##template_params ...
+//
+// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
+// to expand to
+//
+//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
+//
+// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
+// preprocessor will continue to expand it to
+//
+//       ... typename T ...
+//
+// This technique conforms to the C++ standard and is portable.  It
+// allows us to implement action templates using O(N) code, where N is
+// the maximum number of template/value parameters supported.  Without
+// using it, we'd have to devote O(N^2) amount of code to implement all
+// combinations of m and n.
+
+// Declares the template parameters.
+#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
+#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1) kind0 name0, kind1 name1
+#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2) kind0 name0, kind1 name1, kind2 name2
+#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
+    kind3 name3
+#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
+    kind2 name2, kind3 name3, kind4 name4
+#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
+#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
+    kind5 name5, kind6 name6
+#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
+    kind4 name4, kind5 name5, kind6 name6, kind7 name7
+#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
+    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
+    kind8 name8
+#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
+    kind6 name6, kind7 name7, kind8 name8, kind9 name9
+
+// Lists the template parameters.
+#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
+#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1) name0, name1
+#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2) name0, name1, name2
+#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3) name0, name1, name2, name3
+#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
+    name4
+#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
+    name2, name3, name4, name5
+#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6) name0, name1, name2, name3, name4, name5, name6
+#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
+#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
+    name6, name7, name8
+#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
+    name3, name4, name5, name6, name7, name8, name9
+
+// Declares the types of value parameters.
+#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
+    typename p0##_type, typename p1##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
+    typename p0##_type, typename p1##_type, typename p2##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type, typename p7##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type, typename p7##_type, typename p8##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
+    typename p2##_type, typename p3##_type, typename p4##_type, \
+    typename p5##_type, typename p6##_type, typename p7##_type, \
+    typename p8##_type, typename p9##_type
+
+// Initializes the value parameters.
+#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
+    ()
+#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
+    (p0##_type gmock_p0) : p0(::std::move(gmock_p0))
+#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
+    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1))
+#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2))
+#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3))
+#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4))
+#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5))
+#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6))
+#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+        p7(::std::move(gmock_p7))
+#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7, \
+        p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8))
+#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
+        p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
+        p9(::std::move(gmock_p9))
+
+// Defines the copy constructor
+#define GMOCK_INTERNAL_DEFN_COPY_AND_0_VALUE_PARAMS() \
+    {}  // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134
+#define GMOCK_INTERNAL_DEFN_COPY_AND_1_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_2_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_3_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_4_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_5_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_6_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_7_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_8_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_9_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_10_VALUE_PARAMS(...) = default;
+
+// Declares the fields for storing the value parameters.
+#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
+#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
+    p1##_type p1;
+#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
+    p1##_type p1; p2##_type p2;
+#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
+    p1##_type p1; p2##_type p2; p3##_type p3;
+#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
+    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
+#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
+    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5;
+#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5; p6##_type p6;
+#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5; p6##_type p6; p7##_type p7;
+#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
+#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
+    p9##_type p9;
+
+// Lists the value parameters.
+#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
+#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
+#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
+#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
+#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
+    p2, p3, p4
+#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
+    p1, p2, p3, p4, p5
+#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0, p1, p2, p3, p4, p5, p6
+#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0, p1, p2, p3, p4, p5, p6, p7
+#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
+#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
+
+// Lists the value parameter types.
+#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
+    p1##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
+    p1##_type, p2##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
+    p0##_type, p1##_type, p2##_type, p3##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
+    p6##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type, p8##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
+
+// Declares the value parameters.
+#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
+#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
+    p1##_type p1
+#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
+    p1##_type p1, p2##_type p2
+#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
+    p1##_type p1, p2##_type p2, p3##_type p3
+#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
+    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
+#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
+    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5
+#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5, p6##_type p6
+#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5, p6##_type p6, p7##_type p7
+#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
+#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
+    p9##_type p9
+
+// The suffix of the class template implementing the action template.
+#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
+#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
+#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
+#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
+#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
+#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
+#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
+#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) P8
+#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) P9
+#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) P10
+
+// The name of the class template implementing the action template.
+#define GMOCK_ACTION_CLASS_(name, value_params)\
+    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
+
+#define ACTION_TEMPLATE(name, template_params, value_params)                   \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  class GMOCK_ACTION_CLASS_(name, value_params) {                              \
+   public:                                                                     \
+    explicit GMOCK_ACTION_CLASS_(name, value_params)(                          \
+        GMOCK_INTERNAL_DECL_##value_params)                                    \
+        GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),    \
+                    = default; ,                                               \
+                    : impl_(std::make_shared<gmock_Impl>(                      \
+                                GMOCK_INTERNAL_LIST_##value_params)) { })      \
+    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
+        const GMOCK_ACTION_CLASS_(name, value_params)&) noexcept               \
+        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
+    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
+        GMOCK_ACTION_CLASS_(name, value_params)&&) noexcept                    \
+        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
+    template <typename F>                                                      \
+    operator ::testing::Action<F>() const {                                    \
+      return GMOCK_PP_IF(                                                      \
+          GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),              \
+                      (::testing::internal::MakeAction<F, gmock_Impl>()),      \
+                      (::testing::internal::MakeAction<F>(impl_)));            \
+    }                                                                          \
+   private:                                                                    \
+    class gmock_Impl {                                                         \
+     public:                                                                   \
+      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}                \
+      template <typename function_type, typename return_type,                  \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>         \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const;  \
+      GMOCK_INTERNAL_DEFN_##value_params                                       \
+    };                                                                         \
+    GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),        \
+                , std::shared_ptr<const gmock_Impl> impl_;)                    \
+  };                                                                           \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  GMOCK_ACTION_CLASS_(name, value_params)<                                     \
+      GMOCK_INTERNAL_LIST_##template_params                                    \
+      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
+          GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_;          \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  inline GMOCK_ACTION_CLASS_(name, value_params)<                              \
+      GMOCK_INTERNAL_LIST_##template_params                                    \
+      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
+          GMOCK_INTERNAL_DECL_##value_params) {                                \
+    return GMOCK_ACTION_CLASS_(name, value_params)<                            \
+        GMOCK_INTERNAL_LIST_##template_params                                  \
+        GMOCK_INTERNAL_LIST_TYPE_##value_params>(                              \
+            GMOCK_INTERNAL_LIST_##value_params);                               \
+  }                                                                            \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  template <typename function_type, typename return_type, typename args_type,  \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                 \
+  return_type GMOCK_ACTION_CLASS_(name, value_params)<                         \
+      GMOCK_INTERNAL_LIST_##template_params                                    \
+      GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::gmock_PerformImpl( \
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+namespace testing {
+
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+namespace internal {
+
+// internal::InvokeArgument - a helper for InvokeArgument action.
+// The basic overloads are provided here for generic functors.
+// Overloads for other custom-callables are provided in the
+// internal/custom/gmock-generated-actions.h header.
+template <typename F, typename... Args>
+auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
+  return f(args...);
+}
+
+template <std::size_t index, typename... Params>
+struct InvokeArgumentAction {
+  template <typename... Args>
+  auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument(
+      std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)),
+      std::declval<const Params&>()...)) {
+    internal::FlatTuple<Args&&...> args_tuple(FlatTupleConstructTag{},
+                                              std::forward<Args>(args)...);
+    return params.Apply([&](const Params&... unpacked_params) {
+      auto&& callable = args_tuple.template Get<index>();
+      return internal::InvokeArgument(
+          std::forward<decltype(callable)>(callable), unpacked_params...);
+    });
+  }
+
+  internal::FlatTuple<Params...> params;
+};
+
+}  // namespace internal
+
+// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
+// (0-based) argument, which must be a k-ary callable, of the mock
+// function, with arguments a1, a2, ..., a_k.
+//
+// Notes:
+//
+//   1. The arguments are passed by value by default.  If you need to
+//   pass an argument by reference, wrap it inside std::ref().  For
+//   example,
+//
+//     InvokeArgument<1>(5, string("Hello"), std::ref(foo))
+//
+//   passes 5 and string("Hello") by value, and passes foo by
+//   reference.
+//
+//   2. If the callable takes an argument by reference but std::ref() is
+//   not used, it will receive the reference to a copy of the value,
+//   instead of the original value.  For example, when the 0-th
+//   argument of the mock function takes a const string&, the action
+//
+//     InvokeArgument<0>(string("Hello"))
+//
+//   makes a copy of the temporary string("Hello") object and passes a
+//   reference of the copy, instead of the original temporary object,
+//   to the callable.  This makes it easy for a user to define an
+//   InvokeArgument action from temporary values and have it performed
+//   later.
+template <std::size_t index, typename... Params>
+internal::InvokeArgumentAction<index, typename std::decay<Params>::type...>
+InvokeArgument(Params&&... params) {
+  return {internal::FlatTuple<typename std::decay<Params>::type...>(
+      internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)};
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
diff --git a/tools/gtest_lib/include/gmock/gmock-more-matchers.h b/tools/gtest_lib/include/gmock/gmock-more-matchers.h
new file mode 100644
index 0000000000000000000000000000000000000000..6442d2fa78fe5cb0690f3d625c19c1c9d7cb745d
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/gmock-more-matchers.h
@@ -0,0 +1,92 @@
+// Copyright 2013, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some matchers that depend on gmock-matchers.h.
+//
+// Note that tests are implemented in gmock-matchers_test.cc rather than
+// gmock-more-matchers-test.cc.
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
+
+#include "gmock/gmock-matchers.h"
+
+namespace testing {
+
+// Silence C4100 (unreferenced formal
+// parameter) for MSVC
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#if (_MSC_VER == 1900)
+// and silence C4800 (C4800: 'int *const ': forcing value
+// to bool 'true' or 'false') for MSVC 14
+# pragma warning(disable:4800)
+  #endif
+#endif
+
+// Defines a matcher that matches an empty container. The container must
+// support both size() and empty(), which all STL-like containers provide.
+MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") {
+  if (arg.empty()) {
+    return true;
+  }
+  *result_listener << "whose size is " << arg.size();
+  return false;
+}
+
+// Define a matcher that matches a value that evaluates in boolean
+// context to true.  Useful for types that define "explicit operator
+// bool" operators and so can't be compared for equality with true
+// and false.
+MATCHER(IsTrue, negation ? "is false" : "is true") {
+  return static_cast<bool>(arg);
+}
+
+// Define a matcher that matches a value that evaluates in boolean
+// context to false.  Useful for types that define "explicit operator
+// bool" operators and so can't be compared for equality with true
+// and false.
+MATCHER(IsFalse, negation ? "is true" : "is false") {
+  return !static_cast<bool>(arg);
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
diff --git a/tools/gtest_lib/include/gmock/gmock-nice-strict.h b/tools/gtest_lib/include/gmock/gmock-nice-strict.h
new file mode 100644
index 0000000000000000000000000000000000000000..f421deaf438a66d8f6ab74335f204c9e5a912b33
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/gmock-nice-strict.h
@@ -0,0 +1,261 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Implements class templates NiceMock, NaggyMock, and StrictMock.
+//
+// Given a mock class MockFoo that is created using Google Mock,
+// NiceMock<MockFoo> is a subclass of MockFoo that allows
+// uninteresting calls (i.e. calls to mock methods that have no
+// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
+// that prints a warning when an uninteresting call occurs, and
+// StrictMock<MockFoo> is a subclass of MockFoo that treats all
+// uninteresting calls as errors.
+//
+// Currently a mock is naggy by default, so MockFoo and
+// NaggyMock<MockFoo> behave like the same.  However, we will soon
+// switch the default behavior of mocks to be nice, as that in general
+// leads to more maintainable tests.  When that happens, MockFoo will
+// stop behaving like NaggyMock<MockFoo> and start behaving like
+// NiceMock<MockFoo>.
+//
+// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
+// their respective base class.  Therefore you can write
+// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
+// has a constructor that accepts (int, const char*), for example.
+//
+// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
+// and StrictMock<MockFoo> only works for mock methods defined using
+// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
+// If a mock method is defined in a base class of MockFoo, the "nice"
+// or "strict" modifier may not affect it, depending on the compiler.
+// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
+// supported.
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
+
+#include <type_traits>
+
+#include "gmock/gmock-spec-builders.h"
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+template <class MockClass>
+class NiceMock;
+template <class MockClass>
+class NaggyMock;
+template <class MockClass>
+class StrictMock;
+
+namespace internal {
+template <typename T>
+std::true_type StrictnessModifierProbe(const NiceMock<T>&);
+template <typename T>
+std::true_type StrictnessModifierProbe(const NaggyMock<T>&);
+template <typename T>
+std::true_type StrictnessModifierProbe(const StrictMock<T>&);
+std::false_type StrictnessModifierProbe(...);
+
+template <typename T>
+constexpr bool HasStrictnessModifier() {
+  return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value;
+}
+
+// Base classes that register and deregister with testing::Mock to alter the
+// default behavior around uninteresting calls. Inheriting from one of these
+// classes first and then MockClass ensures the MockClass constructor is run
+// after registration, and that the MockClass destructor runs before
+// deregistration. This guarantees that MockClass's constructor and destructor
+// run with the same level of strictness as its instance methods.
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \
+    (defined(_MSC_VER) || defined(__clang__))
+// We need to mark these classes with this declspec to ensure that
+// the empty base class optimization is performed.
+#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases)
+#else
+#define GTEST_INTERNAL_EMPTY_BASE_CLASS
+#endif
+
+template <typename Base>
+class NiceMockImpl {
+ public:
+  NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); }
+
+  ~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+};
+
+template <typename Base>
+class NaggyMockImpl {
+ public:
+  NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); }
+
+  ~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+};
+
+template <typename Base>
+class StrictMockImpl {
+ public:
+  StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); }
+
+  ~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+};
+
+}  // namespace internal
+
+template <class MockClass>
+class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
+    : private internal::NiceMockImpl<MockClass>,
+      public MockClass {
+ public:
+  static_assert(!internal::HasStrictnessModifier<MockClass>(),
+                "Can't apply NiceMock to a class hierarchy that already has a "
+                "strictness modifier. See "
+                "https://google.github.io/googletest/"
+                "gmock_cook_book.html#NiceStrictNaggy");
+  NiceMock() : MockClass() {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  // Ideally, we would inherit base class's constructors through a using
+  // declaration, which would preserve their visibility. However, many existing
+  // tests rely on the fact that current implementation reexports protected
+  // constructors as public. These tests would need to be cleaned up first.
+
+  // Single argument constructor is special-cased so that it can be
+  // made explicit.
+  template <typename A>
+  explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  template <typename TArg1, typename TArg2, typename... An>
+  NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
+                  std::forward<An>(args)...) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
+};
+
+template <class MockClass>
+class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
+    : private internal::NaggyMockImpl<MockClass>,
+      public MockClass {
+  static_assert(!internal::HasStrictnessModifier<MockClass>(),
+                "Can't apply NaggyMock to a class hierarchy that already has a "
+                "strictness modifier. See "
+                "https://google.github.io/googletest/"
+                "gmock_cook_book.html#NiceStrictNaggy");
+
+ public:
+  NaggyMock() : MockClass() {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  // Ideally, we would inherit base class's constructors through a using
+  // declaration, which would preserve their visibility. However, many existing
+  // tests rely on the fact that current implementation reexports protected
+  // constructors as public. These tests would need to be cleaned up first.
+
+  // Single argument constructor is special-cased so that it can be
+  // made explicit.
+  template <typename A>
+  explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  template <typename TArg1, typename TArg2, typename... An>
+  NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
+                  std::forward<An>(args)...) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
+};
+
+template <class MockClass>
+class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
+    : private internal::StrictMockImpl<MockClass>,
+      public MockClass {
+ public:
+  static_assert(
+      !internal::HasStrictnessModifier<MockClass>(),
+      "Can't apply StrictMock to a class hierarchy that already has a "
+      "strictness modifier. See "
+      "https://google.github.io/googletest/"
+      "gmock_cook_book.html#NiceStrictNaggy");
+  StrictMock() : MockClass() {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  // Ideally, we would inherit base class's constructors through a using
+  // declaration, which would preserve their visibility. However, many existing
+  // tests rely on the fact that current implementation reexports protected
+  // constructors as public. These tests would need to be cleaned up first.
+
+  // Single argument constructor is special-cased so that it can be
+  // made explicit.
+  template <typename A>
+  explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  template <typename TArg1, typename TArg2, typename... An>
+  StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
+                  std::forward<An>(args)...) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
+};
+
+#undef GTEST_INTERNAL_EMPTY_BASE_CLASS
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
diff --git a/tools/gtest_lib/include/gmock/gmock-spec-builders.h b/tools/gtest_lib/include/gmock/gmock-spec-builders.h
new file mode 100644
index 0000000000000000000000000000000000000000..dfe642dcc3e0d0fc1180b4b045d71387d334bf5f
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/gmock-spec-builders.h
@@ -0,0 +1,2038 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements the ON_CALL() and EXPECT_CALL() macros.
+//
+// A user can use the ON_CALL() macro to specify the default action of
+// a mock method.  The syntax is:
+//
+//   ON_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matcher)
+//       .WillByDefault(action);
+//
+//  where the .With() clause is optional.
+//
+// A user can use the EXPECT_CALL() macro to specify an expectation on
+// a mock method.  The syntax is:
+//
+//   EXPECT_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matchers)
+//       .Times(cardinality)
+//       .InSequence(sequences)
+//       .After(expectations)
+//       .WillOnce(action)
+//       .WillRepeatedly(action)
+//       .RetiresOnSaturation();
+//
+// where all clauses are optional, and .InSequence()/.After()/
+// .WillOnce() can appear any number of times.
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "gmock/gmock-actions.h"
+#include "gmock/gmock-cardinalities.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>  // NOLINT
+#endif
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// An abstract handle of an expectation.
+class Expectation;
+
+// A set of expectation handles.
+class ExpectationSet;
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// Implements a mock function.
+template <typename F> class FunctionMocker;
+
+// Base class for expectations.
+class ExpectationBase;
+
+// Implements an expectation.
+template <typename F> class TypedExpectation;
+
+// Helper class for testing the Expectation class template.
+class ExpectationTester;
+
+// Helper classes for implementing NiceMock, StrictMock, and NaggyMock.
+template <typename MockClass>
+class NiceMockImpl;
+template <typename MockClass>
+class StrictMockImpl;
+template <typename MockClass>
+class NaggyMockImpl;
+
+// Protects the mock object registry (in class Mock), all function
+// mockers, and all expectations.
+//
+// The reason we don't use more fine-grained protection is: when a
+// mock function Foo() is called, it needs to consult its expectations
+// to see which one should be picked.  If another thread is allowed to
+// call a mock function (either Foo() or a different one) at the same
+// time, it could affect the "retired" attributes of Foo()'s
+// expectations when InSequence() is used, and thus affect which
+// expectation gets picked.  Therefore, we sequence all mock function
+// calls to ensure the integrity of the mock objects' states.
+GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
+
+// Untyped base class for ActionResultHolder<R>.
+class UntypedActionResultHolderBase;
+
+// Abstract base class of FunctionMocker.  This is the
+// type-agnostic part of the function mocker interface.  Its pure
+// virtual methods are implemented by FunctionMocker.
+class GTEST_API_ UntypedFunctionMockerBase {
+ public:
+  UntypedFunctionMockerBase();
+  virtual ~UntypedFunctionMockerBase();
+
+  // Verifies that all expectations on this mock function have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  bool VerifyAndClearExpectationsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Clears the ON_CALL()s set on this mock function.
+  virtual void ClearDefaultActionsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;
+
+  // In all of the following Untyped* functions, it's the caller's
+  // responsibility to guarantee the correctness of the arguments'
+  // types.
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      void* untyped_args, const std::string& call_description) const = 0;
+
+  // Performs the given action with the given arguments and returns
+  // the action's result.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformAction(
+      const void* untyped_action, void* untyped_args) const = 0;
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  virtual void UntypedDescribeUninterestingCall(
+      const void* untyped_args,
+      ::std::ostream* os) const
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  virtual const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args,
+      const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Prints the given function arguments to the ostream.
+  virtual void UntypedPrintArgs(const void* untyped_args,
+                                ::std::ostream* os) const = 0;
+
+  // Sets the mock object this mock method belongs to, and registers
+  // this information in the global mock registry.  Will be called
+  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
+  // method.
+  void RegisterOwner(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Sets the mock object this mock method belongs to, and sets the
+  // name of the mock function.  Will be called upon each invocation
+  // of this mock function.
+  void SetOwnerAndName(const void* mock_obj, const char* name)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the mock object this mock method belongs to.  Must be
+  // called after RegisterOwner() or SetOwnerAndName() has been
+  // called.
+  const void* MockObject() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the name of this mock method.  Must be called after
+  // SetOwnerAndName() has been called.
+  const char* Name() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.  The caller is responsible for deleting the
+  // result.
+  UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+ protected:
+  typedef std::vector<const void*> UntypedOnCallSpecs;
+
+  using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;
+
+  // Returns an Expectation object that references and co-owns exp,
+  // which must be an expectation on this mock function.
+  Expectation GetHandleOf(ExpectationBase* exp);
+
+  // Address of the mock object this mock method belongs to.  Only
+  // valid after this mock method has been called or
+  // ON_CALL/EXPECT_CALL has been invoked on it.
+  const void* mock_obj_;  // Protected by g_gmock_mutex.
+
+  // Name of the function being mocked.  Only valid after this mock
+  // method has been called.
+  const char* name_;  // Protected by g_gmock_mutex.
+
+  // All default action specs for this function mocker.
+  UntypedOnCallSpecs untyped_on_call_specs_;
+
+  // All expectations for this function mocker.
+  //
+  // It's undefined behavior to interleave expectations (EXPECT_CALLs
+  // or ON_CALLs) and mock function calls.  Also, the order of
+  // expectations is important.  Therefore it's a logic race condition
+  // to read/write untyped_expectations_ concurrently.  In order for
+  // tools like tsan to catch concurrent read/write accesses to
+  // untyped_expectations, we deliberately leave accesses to it
+  // unprotected.
+  UntypedExpectations untyped_expectations_;
+};  // class UntypedFunctionMockerBase
+
+// Untyped base class for OnCallSpec<F>.
+class UntypedOnCallSpecBase {
+ public:
+  // The arguments are the location of the ON_CALL() statement.
+  UntypedOnCallSpecBase(const char* a_file, int a_line)
+      : file_(a_file), line_(a_line), last_clause_(kNone) {}
+
+  // Where in the source file was the default action spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+
+ protected:
+  // Gives each clause in the ON_CALL() statement a name.
+  enum Clause {
+    // Do not change the order of the enum members!  The run-time
+    // syntax checking relies on it.
+    kNone,
+    kWith,
+    kWillByDefault
+  };
+
+  // Asserts that the ON_CALL() statement has a certain property.
+  void AssertSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Assert(property, file_, line_, failure_message);
+  }
+
+  // Expects that the ON_CALL() statement has a certain property.
+  void ExpectSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  const char* file_;
+  int line_;
+
+  // The last clause in the ON_CALL() statement as seen so far.
+  // Initially kNone and changes as the statement is parsed.
+  Clause last_clause_;
+};  // class UntypedOnCallSpecBase
+
+// This template class implements an ON_CALL spec.
+template <typename F>
+class OnCallSpec : public UntypedOnCallSpecBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+
+  // Constructs an OnCallSpec object from the information inside
+  // the parenthesis of an ON_CALL() statement.
+  OnCallSpec(const char* a_file, int a_line,
+             const ArgumentMatcherTuple& matchers)
+      : UntypedOnCallSpecBase(a_file, a_line),
+        matchers_(matchers),
+        // By default, extra_matcher_ should match anything.  However,
+        // we cannot initialize it with _ as that causes ambiguity between
+        // Matcher's copy and move constructor for some argument types.
+        extra_matcher_(A<const ArgumentTuple&>()) {}
+
+  // Implements the .With() clause.
+  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
+    // Makes sure this is called at most once.
+    ExpectSpecProperty(last_clause_ < kWith,
+                       ".With() cannot appear "
+                       "more than once in an ON_CALL().");
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    return *this;
+  }
+
+  // Implements the .WillByDefault() clause.
+  OnCallSpec& WillByDefault(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ < kWillByDefault,
+                       ".WillByDefault() must appear "
+                       "exactly once in an ON_CALL().");
+    last_clause_ = kWillByDefault;
+
+    ExpectSpecProperty(!action.IsDoDefault(),
+                       "DoDefault() cannot be used in ON_CALL().");
+    action_ = action;
+    return *this;
+  }
+
+  // Returns true if and only if the given arguments match the matchers.
+  bool Matches(const ArgumentTuple& args) const {
+    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
+  }
+
+  // Returns the action specified by the user.
+  const Action<F>& GetAction() const {
+    AssertSpecProperty(last_clause_ == kWillByDefault,
+                       ".WillByDefault() must appear exactly "
+                       "once in an ON_CALL().");
+    return action_;
+  }
+
+ private:
+  // The information in statement
+  //
+  //   ON_CALL(mock_object, Method(matchers))
+  //       .With(multi-argument-matcher)
+  //       .WillByDefault(action);
+  //
+  // is recorded in the data members like this:
+  //
+  //   source file that contains the statement => file_
+  //   line number of the statement            => line_
+  //   matchers                                => matchers_
+  //   multi-argument-matcher                  => extra_matcher_
+  //   action                                  => action_
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> action_;
+};  // class OnCallSpec
+
+// Possible reactions on uninteresting calls.
+enum CallReaction {
+  kAllow,
+  kWarn,
+  kFail,
+};
+
+}  // namespace internal
+
+// Utilities for manipulating mock objects.
+class GTEST_API_ Mock {
+ public:
+  // The following public methods can be called concurrently.
+
+  // Tells Google Mock to ignore mock_obj when checking for leaked
+  // mock objects.
+  static void AllowLeak(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies and clears all expectations on the given mock object.
+  // If the expectations aren't satisfied, generates one or more
+  // Google Test non-fatal failures and returns false.
+  static bool VerifyAndClearExpectations(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies all expectations on the given mock object and clears its
+  // default actions and expectations.  Returns true if and only if the
+  // verification was successful.
+  static bool VerifyAndClear(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Returns whether the mock was created as a naggy mock (default)
+  static bool IsNaggy(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+  // Returns whether the mock was created as a nice mock
+  static bool IsNice(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+  // Returns whether the mock was created as a strict mock
+  static bool IsStrict(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+ private:
+  friend class internal::UntypedFunctionMockerBase;
+
+  // Needed for a function mocker to register itself (so that we know
+  // how to clear a mock object).
+  template <typename F>
+  friend class internal::FunctionMocker;
+
+  template <typename MockClass>
+  friend class internal::NiceMockImpl;
+  template <typename MockClass>
+  friend class internal::NaggyMockImpl;
+  template <typename MockClass>
+  friend class internal::StrictMockImpl;
+
+  // Tells Google Mock to allow uninteresting calls on the given mock
+  // object.
+  static void AllowUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to warn the user about uninteresting calls on
+  // the given mock object.
+  static void WarnUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to fail uninteresting calls on the given mock
+  // object.
+  static void FailUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock the given mock object is being destroyed and
+  // its entry in the call-reaction table should be removed.
+  static void UnregisterCallReaction(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Returns the reaction Google Mock will have on uninteresting calls
+  // made on the given mock object.
+  static internal::CallReaction GetReactionOnUninterestingCalls(
+      const void* mock_obj)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies that all expectations on the given mock object have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  static bool VerifyAndClearExpectationsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Clears all ON_CALL()s set on the given mock object.
+  static void ClearDefaultActionsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Registers a mock object and a mock method it owns.
+  static void Register(
+      const void* mock_obj,
+      internal::UntypedFunctionMockerBase* mocker)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock where in the source code mock_obj is used in an
+  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
+  // information helps the user identify which object it is.
+  static void RegisterUseByOnCallOrExpectCall(
+      const void* mock_obj, const char* file, int line)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Unregisters a mock method; removes the owning mock object from
+  // the registry when the last mock method associated with it has
+  // been unregistered.  This is called only in the destructor of
+  // FunctionMocker.
+  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+};  // class Mock
+
+// An abstract handle of an expectation.  Useful in the .After()
+// clause of EXPECT_CALL() for setting the (partial) order of
+// expectations.  The syntax:
+//
+//   Expectation e1 = EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(e1)...;
+//
+// sets two expectations where the latter can only be matched after
+// the former has been satisfied.
+//
+// Notes:
+//   - This class is copyable and has value semantics.
+//   - Constness is shallow: a const Expectation object itself cannot
+//     be modified, but the mutable methods of the ExpectationBase
+//     object it references can be called via expectation_base().
+
+class GTEST_API_ Expectation {
+ public:
+  // Constructs a null object that doesn't reference any expectation.
+  Expectation();
+  Expectation(Expectation&&) = default;
+  Expectation(const Expectation&) = default;
+  Expectation& operator=(Expectation&&) = default;
+  Expectation& operator=(const Expectation&) = default;
+  ~Expectation();
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   Expectation e = EXPECT_CALL(...);
+  // syntax.
+  //
+  // A TypedExpectation object stores its pre-requisites as
+  // Expectation objects, and needs to call the non-const Retire()
+  // method on the ExpectationBase objects they reference.  Therefore
+  // Expectation must receive a *non-const* reference to the
+  // ExpectationBase object.
+  Expectation(internal::ExpectationBase& exp);  // NOLINT
+
+  // The compiler-generated copy ctor and operator= work exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true if and only if rhs references the same expectation as this
+  // object does.
+  bool operator==(const Expectation& rhs) const {
+    return expectation_base_ == rhs.expectation_base_;
+  }
+
+  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
+
+ private:
+  friend class ExpectationSet;
+  friend class Sequence;
+  friend class ::testing::internal::ExpectationBase;
+  friend class ::testing::internal::UntypedFunctionMockerBase;
+
+  template <typename F>
+  friend class ::testing::internal::FunctionMocker;
+
+  template <typename F>
+  friend class ::testing::internal::TypedExpectation;
+
+  // This comparator is needed for putting Expectation objects into a set.
+  class Less {
+   public:
+    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
+      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
+    }
+  };
+
+  typedef ::std::set<Expectation, Less> Set;
+
+  Expectation(
+      const std::shared_ptr<internal::ExpectationBase>& expectation_base);
+
+  // Returns the expectation this object references.
+  const std::shared_ptr<internal::ExpectationBase>& expectation_base() const {
+    return expectation_base_;
+  }
+
+  // A shared_ptr that co-owns the expectation this handle references.
+  std::shared_ptr<internal::ExpectationBase> expectation_base_;
+};
+
+// A set of expectation handles.  Useful in the .After() clause of
+// EXPECT_CALL() for setting the (partial) order of expectations.  The
+// syntax:
+//
+//   ExpectationSet es;
+//   es += EXPECT_CALL(...)...;
+//   es += EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(es)...;
+//
+// sets three expectations where the last one can only be matched
+// after the first two have both been satisfied.
+//
+// This class is copyable and has value semantics.
+class ExpectationSet {
+ public:
+  // A bidirectional iterator that can read a const element in the set.
+  typedef Expectation::Set::const_iterator const_iterator;
+
+  // An object stored in the set.  This is an alias of Expectation.
+  typedef Expectation::Set::value_type value_type;
+
+  // Constructs an empty set.
+  ExpectationSet() {}
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   ExpectationSet es = EXPECT_CALL(...);
+  // syntax.
+  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
+    *this += Expectation(exp);
+  }
+
+  // This single-argument ctor implements implicit conversion from
+  // Expectation and thus must not be explicit.  This allows either an
+  // Expectation or an ExpectationSet to be used in .After().
+  ExpectationSet(const Expectation& e) {  // NOLINT
+    *this += e;
+  }
+
+  // The compiler-generator ctor and operator= works exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true if and only if rhs contains the same set of Expectation
+  // objects as this does.
+  bool operator==(const ExpectationSet& rhs) const {
+    return expectations_ == rhs.expectations_;
+  }
+
+  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
+
+  // Implements the syntax
+  //   expectation_set += EXPECT_CALL(...);
+  ExpectationSet& operator+=(const Expectation& e) {
+    expectations_.insert(e);
+    return *this;
+  }
+
+  int size() const { return static_cast<int>(expectations_.size()); }
+
+  const_iterator begin() const { return expectations_.begin(); }
+  const_iterator end() const { return expectations_.end(); }
+
+ private:
+  Expectation::Set expectations_;
+};
+
+
+// Sequence objects are used by a user to specify the relative order
+// in which the expectations should match.  They are copyable (we rely
+// on the compiler-defined copy constructor and assignment operator).
+class GTEST_API_ Sequence {
+ public:
+  // Constructs an empty sequence.
+  Sequence() : last_expectation_(new Expectation) {}
+
+  // Adds an expectation to this sequence.  The caller must ensure
+  // that no other thread is accessing this Sequence object.
+  void AddExpectation(const Expectation& expectation) const;
+
+ private:
+  // The last expectation in this sequence.
+  std::shared_ptr<Expectation> last_expectation_;
+};  // class Sequence
+
+// An object of this type causes all EXPECT_CALL() statements
+// encountered in its scope to be put in an anonymous sequence.  The
+// work is done in the constructor and destructor.  You should only
+// create an InSequence object on the stack.
+//
+// The sole purpose for this class is to support easy definition of
+// sequential expectations, e.g.
+//
+//   {
+//     InSequence dummy;  // The name of the object doesn't matter.
+//
+//     // The following expectations must match in the order they appear.
+//     EXPECT_CALL(a, Bar())...;
+//     EXPECT_CALL(a, Baz())...;
+//     ...
+//     EXPECT_CALL(b, Xyz())...;
+//   }
+//
+// You can create InSequence objects in multiple threads, as long as
+// they are used to affect different mock objects.  The idea is that
+// each thread can create and set up its own mocks as if it's the only
+// thread.  However, for clarity of your tests we recommend you to set
+// up mocks in the main thread unless you have a good reason not to do
+// so.
+class GTEST_API_ InSequence {
+ public:
+  InSequence();
+  ~InSequence();
+ private:
+  bool sequence_created_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
+} GTEST_ATTRIBUTE_UNUSED_;
+
+namespace internal {
+
+// Points to the implicit sequence introduced by a living InSequence
+// object (if any) in the current thread or NULL.
+GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
+
+// Base class for implementing expectations.
+//
+// There are two reasons for having a type-agnostic base class for
+// Expectation:
+//
+//   1. We need to store collections of expectations of different
+//   types (e.g. all pre-requisites of a particular expectation, all
+//   expectations in a sequence).  Therefore these expectation objects
+//   must share a common base class.
+//
+//   2. We can avoid binary code bloat by moving methods not depending
+//   on the template argument of Expectation to the base class.
+//
+// This class is internal and mustn't be used by user code directly.
+class GTEST_API_ ExpectationBase {
+ public:
+  // source_text is the EXPECT_CALL(...) source that created this Expectation.
+  ExpectationBase(const char* file, int line, const std::string& source_text);
+
+  virtual ~ExpectationBase();
+
+  // Where in the source file was the expectation spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+  const char* source_text() const { return source_text_.c_str(); }
+  // Returns the cardinality specified in the expectation spec.
+  const Cardinality& cardinality() const { return cardinality_; }
+
+  // Describes the source file location of this expectation.
+  void DescribeLocationTo(::std::ostream* os) const {
+    *os << FormatFileLocation(file(), line()) << " ";
+  }
+
+  // Describes how many times a function call matching this
+  // expectation has occurred.
+  void DescribeCallCountTo(::std::ostream* os) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
+
+ protected:
+  friend class ::testing::Expectation;
+  friend class UntypedFunctionMockerBase;
+
+  enum Clause {
+    // Don't change the order of the enum members!
+    kNone,
+    kWith,
+    kTimes,
+    kInSequence,
+    kAfter,
+    kWillOnce,
+    kWillRepeatedly,
+    kRetiresOnSaturation
+  };
+
+  typedef std::vector<const void*> UntypedActions;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  virtual Expectation GetHandle() = 0;
+
+  // Asserts that the EXPECT_CALL() statement has the given property.
+  void AssertSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Assert(property, file_, line_, failure_message);
+  }
+
+  // Expects that the EXPECT_CALL() statement has the given property.
+  void ExpectSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  // Explicitly specifies the cardinality of this expectation.  Used
+  // by the subclasses to implement the .Times() clause.
+  void SpecifyCardinality(const Cardinality& cardinality);
+
+  // Returns true if and only if the user specified the cardinality
+  // explicitly using a .Times().
+  bool cardinality_specified() const { return cardinality_specified_; }
+
+  // Sets the cardinality of this expectation spec.
+  void set_cardinality(const Cardinality& a_cardinality) {
+    cardinality_ = a_cardinality;
+  }
+
+  // The following group of methods should only be called after the
+  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
+  // the current thread.
+
+  // Retires all pre-requisites of this expectation.
+  void RetireAllPreRequisites()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns true if and only if this expectation is retired.
+  bool is_retired() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return retired_;
+  }
+
+  // Retires this expectation.
+  void Retire()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    retired_ = true;
+  }
+
+  // Returns true if and only if this expectation is satisfied.
+  bool IsSatisfied() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsSatisfiedByCallCount(call_count_);
+  }
+
+  // Returns true if and only if this expectation is saturated.
+  bool IsSaturated() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsSaturatedByCallCount(call_count_);
+  }
+
+  // Returns true if and only if this expectation is over-saturated.
+  bool IsOverSaturated() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsOverSaturatedByCallCount(call_count_);
+  }
+
+  // Returns true if and only if all pre-requisites of this expectation are
+  // satisfied.
+  bool AllPrerequisitesAreSatisfied() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Adds unsatisfied pre-requisites of this expectation to 'result'.
+  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns the number this expectation has been invoked.
+  int call_count() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return call_count_;
+  }
+
+  // Increments the number this expectation has been invoked.
+  void IncrementCallCount()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    call_count_++;
+  }
+
+  // Checks the action count (i.e. the number of WillOnce() and
+  // WillRepeatedly() clauses) against the cardinality if this hasn't
+  // been done before.  Prints a warning if there are too many or too
+  // few actions.
+  void CheckActionCountIfNotDone() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  friend class ::testing::Sequence;
+  friend class ::testing::internal::ExpectationTester;
+
+  template <typename Function>
+  friend class TypedExpectation;
+
+  // Implements the .Times() clause.
+  void UntypedTimes(const Cardinality& a_cardinality);
+
+  // This group of fields are part of the spec and won't change after
+  // an EXPECT_CALL() statement finishes.
+  const char* file_;          // The file that contains the expectation.
+  int line_;                  // The line number of the expectation.
+  const std::string source_text_;  // The EXPECT_CALL(...) source text.
+  // True if and only if the cardinality is specified explicitly.
+  bool cardinality_specified_;
+  Cardinality cardinality_;            // The cardinality of the expectation.
+  // The immediate pre-requisites (i.e. expectations that must be
+  // satisfied before this expectation can be matched) of this
+  // expectation.  We use std::shared_ptr in the set because we want an
+  // Expectation object to be co-owned by its FunctionMocker and its
+  // successors.  This allows multiple mock objects to be deleted at
+  // different times.
+  ExpectationSet immediate_prerequisites_;
+
+  // This group of fields are the current state of the expectation,
+  // and can change as the mock function is called.
+  int call_count_;  // How many times this expectation has been invoked.
+  bool retired_;    // True if and only if this expectation has retired.
+  UntypedActions untyped_actions_;
+  bool extra_matcher_specified_;
+  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
+  bool retires_on_saturation_;
+  Clause last_clause_;
+  mutable bool action_count_checked_;  // Under mutex_.
+  mutable Mutex mutex_;  // Protects action_count_checked_.
+};  // class ExpectationBase
+
+// Implements an expectation for the given function type.
+template <typename F>
+class TypedExpectation : public ExpectationBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+  typedef typename Function<F>::Result Result;
+
+  TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line,
+                   const std::string& a_source_text,
+                   const ArgumentMatcherTuple& m)
+      : ExpectationBase(a_file, a_line, a_source_text),
+        owner_(owner),
+        matchers_(m),
+        // By default, extra_matcher_ should match anything.  However,
+        // we cannot initialize it with _ as that causes ambiguity between
+        // Matcher's copy and move constructor for some argument types.
+        extra_matcher_(A<const ArgumentTuple&>()),
+        repeated_action_(DoDefault()) {}
+
+  ~TypedExpectation() override {
+    // Check the validity of the action count if it hasn't been done
+    // yet (for example, if the expectation was never used).
+    CheckActionCountIfNotDone();
+    for (UntypedActions::const_iterator it = untyped_actions_.begin();
+         it != untyped_actions_.end(); ++it) {
+      delete static_cast<const Action<F>*>(*it);
+    }
+  }
+
+  // Implements the .With() clause.
+  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
+    if (last_clause_ == kWith) {
+      ExpectSpecProperty(false,
+                         ".With() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWith,
+                         ".With() must be the first "
+                         "clause in an EXPECT_CALL().");
+    }
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    extra_matcher_specified_ = true;
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(const Cardinality& a_cardinality) {
+    ExpectationBase::UntypedTimes(a_cardinality);
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(int n) {
+    return Times(Exactly(n));
+  }
+
+  // Implements the .InSequence() clause.
+  TypedExpectation& InSequence(const Sequence& s) {
+    ExpectSpecProperty(last_clause_ <= kInSequence,
+                       ".InSequence() cannot appear after .After(),"
+                       " .WillOnce(), .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kInSequence;
+
+    s.AddExpectation(GetHandle());
+    return *this;
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
+    return InSequence(s1).InSequence(s2);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3) {
+    return InSequence(s1, s2).InSequence(s3);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4) {
+    return InSequence(s1, s2, s3).InSequence(s4);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4,
+                               const Sequence& s5) {
+    return InSequence(s1, s2, s3, s4).InSequence(s5);
+  }
+
+  // Implements that .After() clause.
+  TypedExpectation& After(const ExpectationSet& s) {
+    ExpectSpecProperty(last_clause_ <= kAfter,
+                       ".After() cannot appear after .WillOnce(),"
+                       " .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kAfter;
+
+    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
+      immediate_prerequisites_ += *it;
+    }
+    return *this;
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
+    return After(s1).After(s2);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3) {
+    return After(s1, s2).After(s3);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4) {
+    return After(s1, s2, s3).After(s4);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4,
+                          const ExpectationSet& s5) {
+    return After(s1, s2, s3, s4).After(s5);
+  }
+
+  // Implements the .WillOnce() clause.
+  TypedExpectation& WillOnce(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ <= kWillOnce,
+                       ".WillOnce() cannot appear after "
+                       ".WillRepeatedly() or .RetiresOnSaturation().");
+    last_clause_ = kWillOnce;
+
+    untyped_actions_.push_back(new Action<F>(action));
+    if (!cardinality_specified()) {
+      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
+    }
+    return *this;
+  }
+
+  // Implements the .WillRepeatedly() clause.
+  TypedExpectation& WillRepeatedly(const Action<F>& action) {
+    if (last_clause_ == kWillRepeatedly) {
+      ExpectSpecProperty(false,
+                         ".WillRepeatedly() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
+                         ".WillRepeatedly() cannot appear "
+                         "after .RetiresOnSaturation().");
+    }
+    last_clause_ = kWillRepeatedly;
+    repeated_action_specified_ = true;
+
+    repeated_action_ = action;
+    if (!cardinality_specified()) {
+      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
+    }
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Implements the .RetiresOnSaturation() clause.
+  TypedExpectation& RetiresOnSaturation() {
+    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
+                       ".RetiresOnSaturation() cannot appear "
+                       "more than once.");
+    last_clause_ = kRetiresOnSaturation;
+    retires_on_saturation_ = true;
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Returns the matchers for the arguments as specified inside the
+  // EXPECT_CALL() macro.
+  const ArgumentMatcherTuple& matchers() const {
+    return matchers_;
+  }
+
+  // Returns the matcher specified by the .With() clause.
+  const Matcher<const ArgumentTuple&>& extra_matcher() const {
+    return extra_matcher_;
+  }
+
+  // Returns the action specified by the .WillRepeatedly() clause.
+  const Action<F>& repeated_action() const { return repeated_action_; }
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  void MaybeDescribeExtraMatcherTo(::std::ostream* os) override {
+    if (extra_matcher_specified_) {
+      *os << "    Expected args: ";
+      extra_matcher_.DescribeTo(os);
+      *os << "\n";
+    }
+  }
+
+ private:
+  template <typename Function>
+  friend class FunctionMocker;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  Expectation GetHandle() override { return owner_->GetHandleOf(this); }
+
+  // The following methods will be called only after the EXPECT_CALL()
+  // statement finishes and when the current thread holds
+  // g_gmock_mutex.
+
+  // Returns true if and only if this expectation matches the given arguments.
+  bool Matches(const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
+  }
+
+  // Returns true if and only if this expectation should handle the given
+  // arguments.
+  bool ShouldHandleArguments(const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // In case the action count wasn't checked when the expectation
+    // was defined (e.g. if this expectation has no WillRepeatedly()
+    // or RetiresOnSaturation() clause), we check it when the
+    // expectation is used for the first time.
+    CheckActionCountIfNotDone();
+    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
+  }
+
+  // Describes the result of matching the arguments against this
+  // expectation to the given ostream.
+  void ExplainMatchResultTo(
+      const ArgumentTuple& args,
+      ::std::ostream* os) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    if (is_retired()) {
+      *os << "         Expected: the expectation is active\n"
+          << "           Actual: it is retired\n";
+    } else if (!Matches(args)) {
+      if (!TupleMatches(matchers_, args)) {
+        ExplainMatchFailureTupleTo(matchers_, args, os);
+      }
+      StringMatchResultListener listener;
+      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
+        *os << "    Expected args: ";
+        extra_matcher_.DescribeTo(os);
+        *os << "\n           Actual: don't match";
+
+        internal::PrintIfNotEmpty(listener.str(), os);
+        *os << "\n";
+      }
+    } else if (!AllPrerequisitesAreSatisfied()) {
+      *os << "         Expected: all pre-requisites are satisfied\n"
+          << "           Actual: the following immediate pre-requisites "
+          << "are not satisfied:\n";
+      ExpectationSet unsatisfied_prereqs;
+      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
+      int i = 0;
+      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
+           it != unsatisfied_prereqs.end(); ++it) {
+        it->expectation_base()->DescribeLocationTo(os);
+        *os << "pre-requisite #" << i++ << "\n";
+      }
+      *os << "                   (end of pre-requisites)\n";
+    } else {
+      // This line is here just for completeness' sake.  It will never
+      // be executed as currently the ExplainMatchResultTo() function
+      // is called only when the mock function call does NOT match the
+      // expectation.
+      *os << "The call matches the expectation.\n";
+    }
+  }
+
+  // Returns the action that should be taken for the current invocation.
+  const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker,
+                                    const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    const int count = call_count();
+    Assert(count >= 1, __FILE__, __LINE__,
+           "call_count() is <= 0 when GetCurrentAction() is "
+           "called - this should never happen.");
+
+    const int action_count = static_cast<int>(untyped_actions_.size());
+    if (action_count > 0 && !repeated_action_specified_ &&
+        count > action_count) {
+      // If there is at least one WillOnce() and no WillRepeatedly(),
+      // we warn the user when the WillOnce() clauses ran out.
+      ::std::stringstream ss;
+      DescribeLocationTo(&ss);
+      ss << "Actions ran out in " << source_text() << "...\n"
+         << "Called " << count << " times, but only "
+         << action_count << " WillOnce()"
+         << (action_count == 1 ? " is" : "s are") << " specified - ";
+      mocker->DescribeDefaultActionTo(args, &ss);
+      Log(kWarning, ss.str(), 1);
+    }
+
+    return count <= action_count
+               ? *static_cast<const Action<F>*>(
+                     untyped_actions_[static_cast<size_t>(count - 1)])
+               : repeated_action();
+  }
+
+  // Given the arguments of a mock function call, if the call will
+  // over-saturate this expectation, returns the default action;
+  // otherwise, returns the next action in this expectation.  Also
+  // describes *what* happened to 'what', and explains *why* Google
+  // Mock does it to 'why'.  This method is not const as it calls
+  // IncrementCallCount().  A return value of NULL means the default
+  // action.
+  const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker,
+                                         const ArgumentTuple& args,
+                                         ::std::ostream* what,
+                                         ::std::ostream* why)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    if (IsSaturated()) {
+      // We have an excessive call.
+      IncrementCallCount();
+      *what << "Mock function called more times than expected - ";
+      mocker->DescribeDefaultActionTo(args, what);
+      DescribeCallCountTo(why);
+
+      return nullptr;
+    }
+
+    IncrementCallCount();
+    RetireAllPreRequisites();
+
+    if (retires_on_saturation_ && IsSaturated()) {
+      Retire();
+    }
+
+    // Must be done after IncrementCount()!
+    *what << "Mock function call matches " << source_text() <<"...\n";
+    return &(GetCurrentAction(mocker, args));
+  }
+
+  // All the fields below won't change once the EXPECT_CALL()
+  // statement finishes.
+  FunctionMocker<F>* const owner_;
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> repeated_action_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
+};  // class TypedExpectation
+
+// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
+// specifying the default behavior of, or expectation on, a mock
+// function.
+
+// Note: class MockSpec really belongs to the ::testing namespace.
+// However if we define it in ::testing, MSVC will complain when
+// classes in ::testing::internal declare it as a friend class
+// template.  To workaround this compiler bug, we define MockSpec in
+// ::testing::internal and import it into ::testing.
+
+// Logs a message including file and line number information.
+GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
+                                const char* file, int line,
+                                const std::string& message);
+
+template <typename F>
+class MockSpec {
+ public:
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename internal::Function<F>::ArgumentMatcherTuple
+      ArgumentMatcherTuple;
+
+  // Constructs a MockSpec object, given the function mocker object
+  // that the spec is associated with.
+  MockSpec(internal::FunctionMocker<F>* function_mocker,
+           const ArgumentMatcherTuple& matchers)
+      : function_mocker_(function_mocker), matchers_(matchers) {}
+
+  // Adds a new default action spec to the function mocker and returns
+  // the newly created spec.
+  internal::OnCallSpec<F>& InternalDefaultActionSetAt(
+      const char* file, int line, const char* obj, const char* call) {
+    LogWithLocation(internal::kInfo, file, line,
+                    std::string("ON_CALL(") + obj + ", " + call + ") invoked");
+    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
+  }
+
+  // Adds a new expectation spec to the function mocker and returns
+  // the newly created spec.
+  internal::TypedExpectation<F>& InternalExpectedAt(
+      const char* file, int line, const char* obj, const char* call) {
+    const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " +
+                                  call + ")");
+    LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
+    return function_mocker_->AddNewExpectation(
+        file, line, source_text, matchers_);
+  }
+
+  // This operator overload is used to swallow the superfluous parameter list
+  // introduced by the ON/EXPECT_CALL macros. See the macro comments for more
+  // explanation.
+  MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) {
+    return *this;
+  }
+
+ private:
+  template <typename Function>
+  friend class internal::FunctionMocker;
+
+  // The function mocker that owns this spec.
+  internal::FunctionMocker<F>* const function_mocker_;
+  // The argument matchers specified in the spec.
+  ArgumentMatcherTuple matchers_;
+};  // class MockSpec
+
+// Wrapper type for generically holding an ordinary value or lvalue reference.
+// If T is not a reference type, it must be copyable or movable.
+// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
+// T is a move-only value type (which means that it will always be copyable
+// if the current platform does not support move semantics).
+//
+// The primary template defines handling for values, but function header
+// comments describe the contract for the whole template (including
+// specializations).
+template <typename T>
+class ReferenceOrValueWrapper {
+ public:
+  // Constructs a wrapper from the given value/reference.
+  explicit ReferenceOrValueWrapper(T value)
+      : value_(std::move(value)) {
+  }
+
+  // Unwraps and returns the underlying value/reference, exactly as
+  // originally passed. The behavior of calling this more than once on
+  // the same object is unspecified.
+  T Unwrap() { return std::move(value_); }
+
+  // Provides nondestructive access to the underlying value/reference.
+  // Always returns a const reference (more precisely,
+  // const std::add_lvalue_reference<T>::type). The behavior of calling this
+  // after calling Unwrap on the same object is unspecified.
+  const T& Peek() const {
+    return value_;
+  }
+
+ private:
+  T value_;
+};
+
+// Specialization for lvalue reference types. See primary template
+// for documentation.
+template <typename T>
+class ReferenceOrValueWrapper<T&> {
+ public:
+  // Workaround for debatable pass-by-reference lint warning (c-library-team
+  // policy precludes NOLINT in this context)
+  typedef T& reference;
+  explicit ReferenceOrValueWrapper(reference ref)
+      : value_ptr_(&ref) {}
+  T& Unwrap() { return *value_ptr_; }
+  const T& Peek() const { return *value_ptr_; }
+
+ private:
+  T* value_ptr_;
+};
+
+// C++ treats the void type specially.  For example, you cannot define
+// a void-typed variable or pass a void value to a function.
+// ActionResultHolder<T> holds a value of type T, where T must be a
+// copyable type or void (T doesn't need to be default-constructable).
+// It hides the syntactic difference between void and other types, and
+// is used to unify the code for invoking both void-returning and
+// non-void-returning mock functions.
+
+// Untyped base class for ActionResultHolder<T>.
+class UntypedActionResultHolderBase {
+ public:
+  virtual ~UntypedActionResultHolderBase() {}
+
+  // Prints the held value as an action's result to os.
+  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
+};
+
+// This generic definition is used when T is not void.
+template <typename T>
+class ActionResultHolder : public UntypedActionResultHolderBase {
+ public:
+  // Returns the held value. Must not be called more than once.
+  T Unwrap() {
+    return result_.Unwrap();
+  }
+
+  // Prints the held value as an action's result to os.
+  void PrintAsActionResult(::std::ostream* os) const override {
+    *os << "\n          Returns: ";
+    // T may be a reference type, so we don't use UniversalPrint().
+    UniversalPrinter<T>::Print(result_.Peek(), os);
+  }
+
+  // Performs the given mock function's default action and returns the
+  // result in a new-ed ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMocker<F>* func_mocker,
+      typename Function<F>::ArgumentTuple&& args,
+      const std::string& call_description) {
+    return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction(
+        std::move(args), call_description)));
+  }
+
+  // Performs the given action and returns the result in a new-ed
+  // ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformAction(
+      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
+    return new ActionResultHolder(
+        Wrapper(action.Perform(std::move(args))));
+  }
+
+ private:
+  typedef ReferenceOrValueWrapper<T> Wrapper;
+
+  explicit ActionResultHolder(Wrapper result)
+      : result_(std::move(result)) {
+  }
+
+  Wrapper result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+// Specialization for T = void.
+template <>
+class ActionResultHolder<void> : public UntypedActionResultHolderBase {
+ public:
+  void Unwrap() { }
+
+  void PrintAsActionResult(::std::ostream* /* os */) const override {}
+
+  // Performs the given mock function's default action and returns ownership
+  // of an empty ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMocker<F>* func_mocker,
+      typename Function<F>::ArgumentTuple&& args,
+      const std::string& call_description) {
+    func_mocker->PerformDefaultAction(std::move(args), call_description);
+    return new ActionResultHolder;
+  }
+
+  // Performs the given action and returns ownership of an empty
+  // ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformAction(
+      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
+    action.Perform(std::move(args));
+    return new ActionResultHolder;
+  }
+
+ private:
+  ActionResultHolder() {}
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+template <typename F>
+class FunctionMocker;
+
+template <typename R, typename... Args>
+class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
+  using F = R(Args...);
+
+ public:
+  using Result = R;
+  using ArgumentTuple = std::tuple<Args...>;
+  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
+
+  FunctionMocker() {}
+
+  // There is no generally useful and implementable semantics of
+  // copying a mock object, so copying a mock is usually a user error.
+  // Thus we disallow copying function mockers.  If the user really
+  // wants to copy a mock object, they should implement their own copy
+  // operation, for example:
+  //
+  //   class MockFoo : public Foo {
+  //    public:
+  //     // Defines a copy constructor explicitly.
+  //     MockFoo(const MockFoo& src) {}
+  //     ...
+  //   };
+  FunctionMocker(const FunctionMocker&) = delete;
+  FunctionMocker& operator=(const FunctionMocker&) = delete;
+
+  // The destructor verifies that all expectations on this mock
+  // function have been satisfied.  If not, it will report Google Test
+  // non-fatal failures for the violations.
+  ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    MutexLock l(&g_gmock_mutex);
+    VerifyAndClearExpectationsLocked();
+    Mock::UnregisterLocked(this);
+    ClearDefaultActionsLocked();
+  }
+
+  // Returns the ON_CALL spec that matches this mock function with the
+  // given arguments; returns NULL if no matching ON_CALL is found.
+  // L = *
+  const OnCallSpec<F>* FindOnCallSpec(
+      const ArgumentTuple& args) const {
+    for (UntypedOnCallSpecs::const_reverse_iterator it
+             = untyped_on_call_specs_.rbegin();
+         it != untyped_on_call_specs_.rend(); ++it) {
+      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
+      if (spec->Matches(args))
+        return spec;
+    }
+
+    return nullptr;
+  }
+
+  // Performs the default action of this mock function on the given
+  // arguments and returns the result. Asserts (or throws if
+  // exceptions are enabled) with a helpful call description if there
+  // is no valid return value. This method doesn't depend on the
+  // mutable state of this object, and thus can be called concurrently
+  // without locking.
+  // L = *
+  Result PerformDefaultAction(ArgumentTuple&& args,
+                              const std::string& call_description) const {
+    const OnCallSpec<F>* const spec =
+        this->FindOnCallSpec(args);
+    if (spec != nullptr) {
+      return spec->GetAction().Perform(std::move(args));
+    }
+    const std::string message =
+        call_description +
+        "\n    The mock function has no default action "
+        "set, and its return type has no default value set.";
+#if GTEST_HAS_EXCEPTIONS
+    if (!DefaultValue<Result>::Exists()) {
+      throw std::runtime_error(message);
+    }
+#else
+    Assert(DefaultValue<Result>::Exists(), "", -1, message);
+#endif
+    return DefaultValue<Result>::Get();
+  }
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.  The caller is responsible for deleting the result.
+  // L = *
+  UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      void* untyped_args,  // must point to an ArgumentTuple
+      const std::string& call_description) const override {
+    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformDefaultAction(this, std::move(*args),
+                                              call_description);
+  }
+
+  // Performs the given action with the given arguments and returns
+  // the action's result.  The caller is responsible for deleting the
+  // result.
+  // L = *
+  UntypedActionResultHolderBase* UntypedPerformAction(
+      const void* untyped_action, void* untyped_args) const override {
+    // Make a copy of the action before performing it, in case the
+    // action deletes the mock object (and thus deletes itself).
+    const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
+    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformAction(action, std::move(*args));
+  }
+
+  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
+  // clears the ON_CALL()s set on this mock function.
+  void ClearDefaultActionsLocked() override
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // Deleting our default actions may trigger other mock objects to be
+    // deleted, for example if an action contains a reference counted smart
+    // pointer to that mock object, and that is the last reference. So if we
+    // delete our actions within the context of the global mutex we may deadlock
+    // when this method is called again. Instead, make a copy of the set of
+    // actions to delete, clear our set within the mutex, and then delete the
+    // actions outside of the mutex.
+    UntypedOnCallSpecs specs_to_delete;
+    untyped_on_call_specs_.swap(specs_to_delete);
+
+    g_gmock_mutex.Unlock();
+    for (UntypedOnCallSpecs::const_iterator it =
+             specs_to_delete.begin();
+         it != specs_to_delete.end(); ++it) {
+      delete static_cast<const OnCallSpec<F>*>(*it);
+    }
+
+    // Lock the mutex again, since the caller expects it to be locked when we
+    // return.
+    g_gmock_mutex.Lock();
+  }
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.
+  Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    ArgumentTuple tuple(std::forward<Args>(args)...);
+    std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
+        this->UntypedInvokeWith(static_cast<void*>(&tuple))));
+    return holder->Unwrap();
+  }
+
+  MockSpec<F> With(Matcher<Args>... m) {
+    return MockSpec<F>(this, ::std::make_tuple(std::move(m)...));
+  }
+
+ protected:
+  template <typename Function>
+  friend class MockSpec;
+
+  typedef ActionResultHolder<Result> ResultHolder;
+
+  // Adds and returns a default action spec for this mock function.
+  OnCallSpec<F>& AddNewOnCallSpec(
+      const char* file, int line,
+      const ArgumentMatcherTuple& m)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
+    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
+    untyped_on_call_specs_.push_back(on_call_spec);
+    return *on_call_spec;
+  }
+
+  // Adds and returns an expectation spec for this mock function.
+  TypedExpectation<F>& AddNewExpectation(const char* file, int line,
+                                         const std::string& source_text,
+                                         const ArgumentMatcherTuple& m)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
+    TypedExpectation<F>* const expectation =
+        new TypedExpectation<F>(this, file, line, source_text, m);
+    const std::shared_ptr<ExpectationBase> untyped_expectation(expectation);
+    // See the definition of untyped_expectations_ for why access to
+    // it is unprotected here.
+    untyped_expectations_.push_back(untyped_expectation);
+
+    // Adds this expectation into the implicit sequence if there is one.
+    Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
+    if (implicit_sequence != nullptr) {
+      implicit_sequence->AddExpectation(Expectation(untyped_expectation));
+    }
+
+    return *expectation;
+  }
+
+ private:
+  template <typename Func> friend class TypedExpectation;
+
+  // Some utilities needed for implementing UntypedInvokeWith().
+
+  // Describes what default action will be performed for the given
+  // arguments.
+  // L = *
+  void DescribeDefaultActionTo(const ArgumentTuple& args,
+                               ::std::ostream* os) const {
+    const OnCallSpec<F>* const spec = FindOnCallSpec(args);
+
+    if (spec == nullptr) {
+      *os << (std::is_void<Result>::value ? "returning directly.\n"
+                                          : "returning default value.\n");
+    } else {
+      *os << "taking default action specified at:\n"
+          << FormatFileLocation(spec->file(), spec->line()) << "\n";
+    }
+  }
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  void UntypedDescribeUninterestingCall(const void* untyped_args,
+                                        ::std::ostream* os) const override
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    *os << "Uninteresting mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    *os << "    Function call: " << Name();
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  //
+  // Critical section: We must find the matching expectation and the
+  // corresponding action that needs to be taken in an ATOMIC
+  // transaction.  Otherwise another thread may call this mock
+  // method in the middle and mess up the state.
+  //
+  // However, performing the action has to be left out of the critical
+  // section.  The reason is that we have no control on what the
+  // action does (it can invoke an arbitrary user function or even a
+  // mock function) and excessive locking could cause a dead lock.
+  const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args, const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why) override
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    MutexLock l(&g_gmock_mutex);
+    TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
+    if (exp == nullptr) {  // A match wasn't found.
+      this->FormatUnexpectedCallMessageLocked(args, what, why);
+      return nullptr;
+    }
+
+    // This line must be done before calling GetActionForArguments(),
+    // which will increment the call count for *exp and thus affect
+    // its saturation status.
+    *is_excessive = exp->IsSaturated();
+    const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
+    if (action != nullptr && action->IsDoDefault())
+      action = nullptr;  // Normalize "do default" to NULL.
+    *untyped_action = action;
+    return exp;
+  }
+
+  // Prints the given function arguments to the ostream.
+  void UntypedPrintArgs(const void* untyped_args,
+                        ::std::ostream* os) const override {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the arguments, or NULL if no
+  // expectation matches them.
+  TypedExpectation<F>* FindMatchingExpectationLocked(
+      const ArgumentTuple& args) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    // See the definition of untyped_expectations_ for why access to
+    // it is unprotected here.
+    for (typename UntypedExpectations::const_reverse_iterator it =
+             untyped_expectations_.rbegin();
+         it != untyped_expectations_.rend(); ++it) {
+      TypedExpectation<F>* const exp =
+          static_cast<TypedExpectation<F>*>(it->get());
+      if (exp->ShouldHandleArguments(args)) {
+        return exp;
+      }
+    }
+    return nullptr;
+  }
+
+  // Returns a message that the arguments don't match any expectation.
+  void FormatUnexpectedCallMessageLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* os,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    *os << "\nUnexpected mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    PrintTriedExpectationsLocked(args, why);
+  }
+
+  // Prints a list of expectations that have been tried against the
+  // current mock function call.
+  void PrintTriedExpectationsLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    const size_t count = untyped_expectations_.size();
+    *why << "Google Mock tried the following " << count << " "
+         << (count == 1 ? "expectation, but it didn't match" :
+             "expectations, but none matched")
+         << ":\n";
+    for (size_t i = 0; i < count; i++) {
+      TypedExpectation<F>* const expectation =
+          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
+      *why << "\n";
+      expectation->DescribeLocationTo(why);
+      if (count > 1) {
+        *why << "tried expectation #" << i << ": ";
+      }
+      *why << expectation->source_text() << "...\n";
+      expectation->ExplainMatchResultTo(args, why);
+      expectation->DescribeCallCountTo(why);
+    }
+  }
+};  // class FunctionMocker
+
+// Reports an uninteresting call (whose description is in msg) in the
+// manner specified by 'reaction'.
+void ReportUninterestingCall(CallReaction reaction, const std::string& msg);
+
+}  // namespace internal
+
+namespace internal {
+
+template <typename F>
+class MockFunction;
+
+template <typename R, typename... Args>
+class MockFunction<R(Args...)> {
+ public:
+  MockFunction(const MockFunction&) = delete;
+  MockFunction& operator=(const MockFunction&) = delete;
+
+  std::function<R(Args...)> AsStdFunction() {
+    return [this](Args... args) -> R {
+      return this->Call(std::forward<Args>(args)...);
+    };
+  }
+
+  // Implementation detail: the expansion of the MOCK_METHOD macro.
+  R Call(Args... args) {
+    mock_.SetOwnerAndName(this, "Call");
+    return mock_.Invoke(std::forward<Args>(args)...);
+  }
+
+  MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
+    mock_.RegisterOwner(this);
+    return mock_.With(std::move(m)...);
+  }
+
+  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) {
+    return this->gmock_Call(::testing::A<Args>()...);
+  }
+
+ protected:
+  MockFunction() = default;
+  ~MockFunction() = default;
+
+ private:
+  FunctionMocker<R(Args...)> mock_;
+};
+
+/*
+The SignatureOf<F> struct is a meta-function returning function signature
+corresponding to the provided F argument.
+
+It makes use of MockFunction easier by allowing it to accept more F arguments
+than just function signatures.
+
+Specializations provided here cover a signature type itself and any template
+that can be parameterized with a signature, including std::function and
+boost::function.
+*/
+
+template <typename F, typename = void>
+struct SignatureOf;
+
+template <typename R, typename... Args>
+struct SignatureOf<R(Args...)> {
+  using type = R(Args...);
+};
+
+template <template <typename> class C, typename F>
+struct SignatureOf<C<F>,
+                   typename std::enable_if<std::is_function<F>::value>::type>
+    : SignatureOf<F> {};
+
+template <typename F>
+using SignatureOfT = typename SignatureOf<F>::type;
+
+}  // namespace internal
+
+// A MockFunction<F> type has one mock method whose type is
+// internal::SignatureOfT<F>.  It is useful when you just want your
+// test code to emit some messages and have Google Mock verify the
+// right messages are sent (and perhaps at the right times).  For
+// example, if you are exercising code:
+//
+//   Foo(1);
+//   Foo(2);
+//   Foo(3);
+//
+// and want to verify that Foo(1) and Foo(3) both invoke
+// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
+//
+// TEST(FooTest, InvokesBarCorrectly) {
+//   MyMock mock;
+//   MockFunction<void(string check_point_name)> check;
+//   {
+//     InSequence s;
+//
+//     EXPECT_CALL(mock, Bar("a"));
+//     EXPECT_CALL(check, Call("1"));
+//     EXPECT_CALL(check, Call("2"));
+//     EXPECT_CALL(mock, Bar("a"));
+//   }
+//   Foo(1);
+//   check.Call("1");
+//   Foo(2);
+//   check.Call("2");
+//   Foo(3);
+// }
+//
+// The expectation spec says that the first Bar("a") must happen
+// before check point "1", the second Bar("a") must happen after check
+// point "2", and nothing should happen between the two check
+// points. The explicit check points make it easy to tell which
+// Bar("a") is called by which call to Foo().
+//
+// MockFunction<F> can also be used to exercise code that accepts
+// std::function<internal::SignatureOfT<F>> callbacks. To do so, use
+// AsStdFunction() method to create std::function proxy forwarding to
+// original object's Call. Example:
+//
+// TEST(FooTest, RunsCallbackWithBarArgument) {
+//   MockFunction<int(string)> callback;
+//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
+//   Foo(callback.AsStdFunction());
+// }
+//
+// The internal::SignatureOfT<F> indirection allows to use other types
+// than just function signature type. This is typically useful when
+// providing a mock for a predefined std::function type. Example:
+//
+// using FilterPredicate = std::function<bool(string)>;
+// void MyFilterAlgorithm(FilterPredicate predicate);
+//
+// TEST(FooTest, FilterPredicateAlwaysAccepts) {
+//   MockFunction<FilterPredicate> predicateMock;
+//   EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true));
+//   MyFilterAlgorithm(predicateMock.AsStdFunction());
+// }
+template <typename F>
+class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> {
+  using Base = internal::MockFunction<internal::SignatureOfT<F>>;
+
+ public:
+  using Base::Base;
+};
+
+// The style guide prohibits "using" statements in a namespace scope
+// inside a header file.  However, the MockSpec class template is
+// meant to be defined in the ::testing namespace.  The following line
+// is just a trick for working around a bug in MSVC 8.0, which cannot
+// handle it if we define MockSpec in ::testing.
+using internal::MockSpec;
+
+// Const(x) is a convenient function for obtaining a const reference
+// to x.  This is useful for setting expectations on an overloaded
+// const mock method, e.g.
+//
+//   class MockFoo : public FooInterface {
+//    public:
+//     MOCK_METHOD0(Bar, int());
+//     MOCK_CONST_METHOD0(Bar, int&());
+//   };
+//
+//   MockFoo foo;
+//   // Expects a call to non-const MockFoo::Bar().
+//   EXPECT_CALL(foo, Bar());
+//   // Expects a call to const MockFoo::Bar().
+//   EXPECT_CALL(Const(foo), Bar());
+template <typename T>
+inline const T& Const(const T& x) { return x; }
+
+// Constructs an Expectation object that references and co-owns exp.
+inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
+    : expectation_base_(exp.GetHandle().expectation_base()) {}
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is
+// required to avoid compile errors when the name of the method used in call is
+// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro
+// tests in internal/gmock-spec-builders_test.cc for more details.
+//
+// This macro supports statements both with and without parameter matchers. If
+// the parameter list is omitted, gMock will accept any parameters, which allows
+// tests to be written that don't need to encode the number of method
+// parameter. This technique may only be used for non-overloaded methods.
+//
+//   // These are the same:
+//   ON_CALL(mock, NoArgsMethod()).WillByDefault(...);
+//   ON_CALL(mock, NoArgsMethod).WillByDefault(...);
+//
+//   // As are these:
+//   ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...);
+//   ON_CALL(mock, TwoArgsMethod).WillByDefault(...);
+//
+//   // Can also specify args if you want, of course:
+//   ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...);
+//
+//   // Overloads work as long as you specify parameters:
+//   ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...);
+//   ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...);
+//
+//   // Oops! Which overload did you want?
+//   ON_CALL(mock, OverloadedMethod).WillByDefault(...);
+//     => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous
+//
+// How this works: The mock class uses two overloads of the gmock_Method
+// expectation setter method plus an operator() overload on the MockSpec object.
+// In the matcher list form, the macro expands to:
+//
+//   // This statement:
+//   ON_CALL(mock, TwoArgsMethod(_, 45))...
+//
+//   // ...expands to:
+//   mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)...
+//   |-------------v---------------||------------v-------------|
+//       invokes first overload        swallowed by operator()
+//
+//   // ...which is essentially:
+//   mock.gmock_TwoArgsMethod(_, 45)...
+//
+// Whereas the form without a matcher list:
+//
+//   // This statement:
+//   ON_CALL(mock, TwoArgsMethod)...
+//
+//   // ...expands to:
+//   mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)...
+//   |-----------------------v--------------------------|
+//                 invokes second overload
+//
+//   // ...which is essentially:
+//   mock.gmock_TwoArgsMethod(_, _)...
+//
+// The WithoutMatchers() argument is used to disambiguate overloads and to
+// block the caller from accidentally invoking the second overload directly. The
+// second argument is an internal type derived from the method signature. The
+// failure to disambiguate two overloads of this method in the ON_CALL statement
+// is how we block callers from setting expectations on overloaded methods.
+#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call)                    \
+  ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \
+                             nullptr)                                   \
+      .Setter(__FILE__, __LINE__, #mock_expr, #call)
+
+#define ON_CALL(obj, call) \
+  GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call)
+
+#define EXPECT_CALL(obj, call) \
+  GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call)
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
diff --git a/tools/gtest_lib/include/gmock/gmock.h b/tools/gtest_lib/include/gmock/gmock.h
new file mode 100644
index 0000000000000000000000000000000000000000..568c8c71d78578ffab629c3634fea890c5accfd6
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/gmock.h
@@ -0,0 +1,96 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This is the main header file a user should include.
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
+
+// This file implements the following syntax:
+//
+//   ON_CALL(mock_object, Method(...))
+//     .With(...) ?
+//     .WillByDefault(...);
+//
+// where With() is optional and WillByDefault() must appear exactly
+// once.
+//
+//   EXPECT_CALL(mock_object, Method(...))
+//     .With(...) ?
+//     .Times(...) ?
+//     .InSequence(...) *
+//     .WillOnce(...) *
+//     .WillRepeatedly(...) ?
+//     .RetiresOnSaturation() ? ;
+//
+// where all clauses are optional and WillOnce() can be repeated.
+
+#include "gmock/gmock-actions.h"
+#include "gmock/gmock-cardinalities.h"
+#include "gmock/gmock-function-mocker.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock-more-actions.h"
+#include "gmock/gmock-more-matchers.h"
+#include "gmock/gmock-nice-strict.h"
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+
+// Declares Google Mock flags that we want a user to use programmatically.
+GMOCK_DECLARE_bool_(catch_leaked_mocks);
+GMOCK_DECLARE_string_(verbose);
+GMOCK_DECLARE_int32_(default_mock_behavior);
+
+namespace testing {
+
+// Initializes Google Mock.  This must be called before running the
+// tests.  In particular, it parses the command line for the flags
+// that Google Mock recognizes.  Whenever a Google Mock flag is seen,
+// it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Mock flag variables are
+// updated.
+//
+// Since Google Test is needed for Google Mock to work, this function
+// also initializes Google Test and parses its flags, if that hasn't
+// been done.
+GTEST_API_ void InitGoogleMock(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+GTEST_API_ void InitGoogleMock();
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
diff --git a/tools/gtest_lib/include/gmock/internal/custom/README.md b/tools/gtest_lib/include/gmock/internal/custom/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9c4874fd0cb31e89682088eb1a91cc7a43857bee
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/internal/custom/README.md
@@ -0,0 +1,18 @@
+# Customization Points
+
+The custom directory is an injection point for custom user configurations.
+
+## Header `gmock-port.h`
+
+The following macros can be defined:
+
+### Flag related macros:
+
+*   `GMOCK_DECLARE_bool_(name)`
+*   `GMOCK_DECLARE_int32_(name)`
+*   `GMOCK_DECLARE_string_(name)`
+*   `GMOCK_DEFINE_bool_(name, default_val, doc)`
+*   `GMOCK_DEFINE_int32_(name, default_val, doc)`
+*   `GMOCK_DEFINE_string_(name, default_val, doc)`
+*   `GMOCK_FLAG_GET(flag_name)`
+*   `GMOCK_FLAG_SET(flag_name, value)`
diff --git a/tools/gtest_lib/include/gmock/internal/custom/gmock-generated-actions.h b/tools/gtest_lib/include/gmock/internal/custom/gmock-generated-actions.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbcad31c76efa9a05a9acb4032f73f6fd656b42e
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/internal/custom/gmock-generated-actions.h
@@ -0,0 +1,7 @@
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
diff --git a/tools/gtest_lib/include/gmock/internal/custom/gmock-matchers.h b/tools/gtest_lib/include/gmock/internal/custom/gmock-matchers.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb7dcbaa4cb20035c897d55ba5e58f8c5d4c9cb3
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/internal/custom/gmock-matchers.h
@@ -0,0 +1,37 @@
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Injection point for custom user configurations. See README for details
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
diff --git a/tools/gtest_lib/include/gmock/internal/custom/gmock-port.h b/tools/gtest_lib/include/gmock/internal/custom/gmock-port.h
new file mode 100644
index 0000000000000000000000000000000000000000..f055f7506b82ec481b295881a2c3f7f1b0a685e4
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/internal/custom/gmock-port.h
@@ -0,0 +1,40 @@
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
diff --git a/tools/gtest_lib/include/gmock/internal/gmock-internal-utils.h b/tools/gtest_lib/include/gmock/internal/gmock-internal-utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..d9d812a368dd337ac9177aa87e08387b04062ad1
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/internal/gmock-internal-utils.h
@@ -0,0 +1,472 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file defines some utilities useful for implementing Google
+// Mock.  They are subject to change without notice, so please DO NOT
+// USE THEM IN USER CODE.
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+
+#include <stdio.h>
+
+#include <ostream>  // NOLINT
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+
+template <typename>
+class Matcher;
+
+namespace internal {
+
+// Silence MSVC C4100 (unreferenced formal parameter) and
+// C4805('==': unsafe mix of type 'const int' and type 'const bool')
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+# pragma warning(disable:4805)
+#endif
+
+// Joins a vector of strings as if they are fields of a tuple; returns
+// the joined string.
+GTEST_API_ std::string JoinAsKeyValueTuple(
+    const std::vector<const char*>& names, const Strings& values);
+
+// Converts an identifier name to a space-separated list of lower-case
+// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
+// treated as one word.  For example, both "FooBar123" and
+// "foo_bar_123" are converted to "foo bar 123".
+GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name);
+
+// GetRawPointer(p) returns the raw pointer underlying p when p is a
+// smart pointer, or returns p itself when p is already a raw pointer.
+// The following default implementation is for the smart pointer case.
+template <typename Pointer>
+inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) {
+  return p.get();
+}
+// This overload version is for std::reference_wrapper, which does not work with
+// the overload above, as it does not have an `element_type`.
+template <typename Element>
+inline const Element* GetRawPointer(const std::reference_wrapper<Element>& r) {
+  return &r.get();
+}
+
+// This overloaded version is for the raw pointer case.
+template <typename Element>
+inline Element* GetRawPointer(Element* p) { return p; }
+
+// MSVC treats wchar_t as a native type usually, but treats it as the
+// same as unsigned short when the compiler option /Zc:wchar_t- is
+// specified.  It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
+// is a native type.
+#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
+// wchar_t is a typedef.
+#else
+# define GMOCK_WCHAR_T_IS_NATIVE_ 1
+#endif
+
+// In what follows, we use the term "kind" to indicate whether a type
+// is bool, an integer type (excluding bool), a floating-point type,
+// or none of them.  This categorization is useful for determining
+// when a matcher argument type can be safely converted to another
+// type in the implementation of SafeMatcherCast.
+enum TypeKind {
+  kBool, kInteger, kFloatingPoint, kOther
+};
+
+// KindOf<T>::value is the kind of type T.
+template <typename T> struct KindOf {
+  enum { value = kOther };  // The default kind.
+};
+
+// This macro declares that the kind of 'type' is 'kind'.
+#define GMOCK_DECLARE_KIND_(type, kind) \
+  template <> struct KindOf<type> { enum { value = kind }; }
+
+GMOCK_DECLARE_KIND_(bool, kBool);
+
+// All standard integer types.
+GMOCK_DECLARE_KIND_(char, kInteger);
+GMOCK_DECLARE_KIND_(signed char, kInteger);
+GMOCK_DECLARE_KIND_(unsigned char, kInteger);
+GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(int, kInteger);
+GMOCK_DECLARE_KIND_(unsigned int, kInteger);
+GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(long long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long long, kInteger);  // NOLINT
+
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DECLARE_KIND_(wchar_t, kInteger);
+#endif
+
+// All standard floating-point types.
+GMOCK_DECLARE_KIND_(float, kFloatingPoint);
+GMOCK_DECLARE_KIND_(double, kFloatingPoint);
+GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
+
+#undef GMOCK_DECLARE_KIND_
+
+// Evaluates to the kind of 'type'.
+#define GMOCK_KIND_OF_(type) \
+  static_cast< ::testing::internal::TypeKind>( \
+      ::testing::internal::KindOf<type>::value)
+
+// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
+// is true if and only if arithmetic type From can be losslessly converted to
+// arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types, kFromKind is the kind of
+// From, and kToKind is the kind of To; the value is
+// implementation-defined when the above pre-condition is violated.
+template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To>
+using LosslessArithmeticConvertibleImpl = std::integral_constant<
+    bool,
+    // clang-format off
+      // Converting from bool is always lossless
+      (kFromKind == kBool) ? true
+      // Converting between any other type kinds will be lossy if the type
+      // kinds are not the same.
+    : (kFromKind != kToKind) ? false
+    : (kFromKind == kInteger &&
+       // Converting between integers of different widths is allowed so long
+       // as the conversion does not go from signed to unsigned.
+      (((sizeof(From) < sizeof(To)) &&
+        !(std::is_signed<From>::value && !std::is_signed<To>::value)) ||
+       // Converting between integers of the same width only requires the
+       // two types to have the same signedness.
+       ((sizeof(From) == sizeof(To)) &&
+        (std::is_signed<From>::value == std::is_signed<To>::value)))
+       ) ? true
+      // Floating point conversions are lossless if and only if `To` is at least
+      // as wide as `From`.
+    : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true
+    : false
+    // clang-format on
+    >;
+
+// LosslessArithmeticConvertible<From, To>::value is true if and only if
+// arithmetic type From can be losslessly converted to arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types; the value is
+// implementation-defined when the above pre-condition is violated.
+template <typename From, typename To>
+using LosslessArithmeticConvertible =
+    LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From,
+                                      GMOCK_KIND_OF_(To), To>;
+
+// This interface knows how to report a Google Mock failure (either
+// non-fatal or fatal).
+class FailureReporterInterface {
+ public:
+  // The type of a failure (either non-fatal or fatal).
+  enum FailureType {
+    kNonfatal, kFatal
+  };
+
+  virtual ~FailureReporterInterface() {}
+
+  // Reports a failure that occurred at the given source file location.
+  virtual void ReportFailure(FailureType type, const char* file, int line,
+                             const std::string& message) = 0;
+};
+
+// Returns the failure reporter used by Google Mock.
+GTEST_API_ FailureReporterInterface* GetFailureReporter();
+
+// Asserts that condition is true; aborts the process with the given
+// message if condition is false.  We cannot use LOG(FATAL) or CHECK()
+// as Google Mock might be used to mock the log sink itself.  We
+// inline this function to prevent it from showing up in the stack
+// trace.
+inline void Assert(bool condition, const char* file, int line,
+                   const std::string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
+                                        file, line, msg);
+  }
+}
+inline void Assert(bool condition, const char* file, int line) {
+  Assert(condition, file, line, "Assertion failed.");
+}
+
+// Verifies that condition is true; generates a non-fatal failure if
+// condition is false.
+inline void Expect(bool condition, const char* file, int line,
+                   const std::string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
+                                        file, line, msg);
+  }
+}
+inline void Expect(bool condition, const char* file, int line) {
+  Expect(condition, file, line, "Expectation failed.");
+}
+
+// Severity level of a log.
+enum LogSeverity {
+  kInfo = 0,
+  kWarning = 1
+};
+
+// Valid values for the --gmock_verbose flag.
+
+// All logs (informational and warnings) are printed.
+const char kInfoVerbosity[] = "info";
+// Only warnings are printed.
+const char kWarningVerbosity[] = "warning";
+// No logs are printed.
+const char kErrorVerbosity[] = "error";
+
+// Returns true if and only if a log with the given severity is visible
+// according to the --gmock_verbose flag.
+GTEST_API_ bool LogIsVisible(LogSeverity severity);
+
+// Prints the given message to stdout if and only if 'severity' >= the level
+// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
+// 0, also prints the stack trace excluding the top
+// stack_frames_to_skip frames.  In opt mode, any positive
+// stack_frames_to_skip is treated as 0, since we don't know which
+// function calls will be inlined by the compiler and need to be
+// conservative.
+GTEST_API_ void Log(LogSeverity severity, const std::string& message,
+                    int stack_frames_to_skip);
+
+// A marker class that is used to resolve parameterless expectations to the
+// correct overload. This must not be instantiable, to prevent client code from
+// accidentally resolving to the overload; for example:
+//
+//    ON_CALL(mock, Method({}, nullptr))...
+//
+class WithoutMatchers {
+ private:
+  WithoutMatchers() {}
+  friend GTEST_API_ WithoutMatchers GetWithoutMatchers();
+};
+
+// Internal use only: access the singleton instance of WithoutMatchers.
+GTEST_API_ WithoutMatchers GetWithoutMatchers();
+
+// Disable MSVC warnings for infinite recursion, since in this case the
+// recursion is unreachable.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4717)
+#endif
+
+// Invalid<T>() is usable as an expression of type T, but will terminate
+// the program with an assertion failure if actually run.  This is useful
+// when a value of type T is needed for compilation, but the statement
+// will not really be executed (or we don't care if the statement
+// crashes).
+template <typename T>
+inline T Invalid() {
+  Assert(false, "", -1, "Internal error: attempt to return invalid value");
+  // This statement is unreachable, and would never terminate even if it
+  // could be reached. It is provided only to placate compiler warnings
+  // about missing return statements.
+  return Invalid<T>();
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+// Given a raw type (i.e. having no top-level reference or const
+// modifier) RawContainer that's either an STL-style container or a
+// native array, class StlContainerView<RawContainer> has the
+// following members:
+//
+//   - type is a type that provides an STL-style container view to
+//     (i.e. implements the STL container concept for) RawContainer;
+//   - const_reference is a type that provides a reference to a const
+//     RawContainer;
+//   - ConstReference(raw_container) returns a const reference to an STL-style
+//     container view to raw_container, which is a RawContainer.
+//   - Copy(raw_container) returns an STL-style container view of a
+//     copy of raw_container, which is a RawContainer.
+//
+// This generic version is used when RawContainer itself is already an
+// STL-style container.
+template <class RawContainer>
+class StlContainerView {
+ public:
+  typedef RawContainer type;
+  typedef const type& const_reference;
+
+  static const_reference ConstReference(const RawContainer& container) {
+    static_assert(!std::is_const<RawContainer>::value,
+                  "RawContainer type must not be const");
+    return container;
+  }
+  static type Copy(const RawContainer& container) { return container; }
+};
+
+// This specialization is used when RawContainer is a native array type.
+template <typename Element, size_t N>
+class StlContainerView<Element[N]> {
+ public:
+  typedef typename std::remove_const<Element>::type RawElement;
+  typedef internal::NativeArray<RawElement> type;
+  // NativeArray<T> can represent a native array either by value or by
+  // reference (selected by a constructor argument), so 'const type'
+  // can be used to reference a const native array.  We cannot
+  // 'typedef const type& const_reference' here, as that would mean
+  // ConstReference() has to return a reference to a local variable.
+  typedef const type const_reference;
+
+  static const_reference ConstReference(const Element (&array)[N]) {
+    static_assert(std::is_same<Element, RawElement>::value,
+                  "Element type must not be const");
+    return type(array, N, RelationToSourceReference());
+  }
+  static type Copy(const Element (&array)[N]) {
+    return type(array, N, RelationToSourceCopy());
+  }
+};
+
+// This specialization is used when RawContainer is a native array
+// represented as a (pointer, size) tuple.
+template <typename ElementPointer, typename Size>
+class StlContainerView< ::std::tuple<ElementPointer, Size> > {
+ public:
+  typedef typename std::remove_const<
+      typename std::pointer_traits<ElementPointer>::element_type>::type
+      RawElement;
+  typedef internal::NativeArray<RawElement> type;
+  typedef const type const_reference;
+
+  static const_reference ConstReference(
+      const ::std::tuple<ElementPointer, Size>& array) {
+    return type(std::get<0>(array), std::get<1>(array),
+                RelationToSourceReference());
+  }
+  static type Copy(const ::std::tuple<ElementPointer, Size>& array) {
+    return type(std::get<0>(array), std::get<1>(array), RelationToSourceCopy());
+  }
+};
+
+// The following specialization prevents the user from instantiating
+// StlContainer with a reference type.
+template <typename T> class StlContainerView<T&>;
+
+// A type transform to remove constness from the first part of a pair.
+// Pairs like that are used as the value_type of associative containers,
+// and this transform produces a similar but assignable pair.
+template <typename T>
+struct RemoveConstFromKey {
+  typedef T type;
+};
+
+// Partially specialized to remove constness from std::pair<const K, V>.
+template <typename K, typename V>
+struct RemoveConstFromKey<std::pair<const K, V> > {
+  typedef std::pair<K, V> type;
+};
+
+// Emit an assertion failure due to incorrect DoDefault() usage. Out-of-lined to
+// reduce code size.
+GTEST_API_ void IllegalDoDefault(const char* file, int line);
+
+template <typename F, typename Tuple, size_t... Idx>
+auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>) -> decltype(
+    std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...)) {
+  return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
+}
+
+// Apply the function to a tuple of arguments.
+template <typename F, typename Tuple>
+auto Apply(F&& f, Tuple&& args) -> decltype(
+    ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
+              MakeIndexSequence<std::tuple_size<
+                  typename std::remove_reference<Tuple>::type>::value>())) {
+  return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
+                   MakeIndexSequence<std::tuple_size<
+                       typename std::remove_reference<Tuple>::type>::value>());
+}
+
+// Template struct Function<F>, where F must be a function type, contains
+// the following typedefs:
+//
+//   Result:               the function's return type.
+//   Arg<N>:               the type of the N-th argument, where N starts with 0.
+//   ArgumentTuple:        the tuple type consisting of all parameters of F.
+//   ArgumentMatcherTuple: the tuple type consisting of Matchers for all
+//                         parameters of F.
+//   MakeResultVoid:       the function type obtained by substituting void
+//                         for the return type of F.
+//   MakeResultIgnoredValue:
+//                         the function type obtained by substituting Something
+//                         for the return type of F.
+template <typename T>
+struct Function;
+
+template <typename R, typename... Args>
+struct Function<R(Args...)> {
+  using Result = R;
+  static constexpr size_t ArgumentCount = sizeof...(Args);
+  template <size_t I>
+  using Arg = ElemFromList<I, Args...>;
+  using ArgumentTuple = std::tuple<Args...>;
+  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
+  using MakeResultVoid = void(Args...);
+  using MakeResultIgnoredValue = IgnoredValue(Args...);
+};
+
+template <typename R, typename... Args>
+constexpr size_t Function<R(Args...)>::ArgumentCount;
+
+bool Base64Unescape(const std::string& encoded, std::string* decoded);
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
diff --git a/tools/gtest_lib/include/gmock/internal/gmock-port.h b/tools/gtest_lib/include/gmock/internal/gmock-port.h
new file mode 100644
index 0000000000000000000000000000000000000000..998f6c79376d11087a93e963d46143957615afe9
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/internal/gmock-port.h
@@ -0,0 +1,105 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Low-level types and utilities for porting Google Mock to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Mock MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Mock's public API and can be used by
+// code outside Google Mock.
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+
+#include <assert.h>
+#include <stdlib.h>
+#include <cstdint>
+#include <iostream>
+
+// Most of the utilities needed for porting Google Mock are also
+// required for Google Test and are defined in gtest-port.h.
+//
+// Note to maintainers: to reduce code duplication, prefer adding
+// portability utilities to Google Test's gtest-port.h instead of
+// here, as Google Mock depends on Google Test.  Only add a utility
+// here if it's truly specific to Google Mock.
+
+#include "gtest/internal/gtest-port.h"
+#include "gmock/internal/custom/gmock-port.h"
+
+// For MS Visual C++, check the compiler version. At least VS 2015 is
+// required to compile Google Mock.
+#if defined(_MSC_VER) && _MSC_VER < 1900
+# error "At least Visual C++ 2015 (14.0) is required to compile Google Mock."
+#endif
+
+// Macro for referencing flags.  This is public as we want the user to
+// use this syntax to reference Google Mock flags.
+#define GMOCK_FLAG(name) FLAGS_gmock_##name
+
+#if !defined(GMOCK_DECLARE_bool_)
+
+// Macros for declaring flags.
+#define GMOCK_DECLARE_bool_(name)          \
+  namespace testing {                      \
+  GTEST_API_ extern bool GMOCK_FLAG(name); \
+  } static_assert(true, "no-op to require trailing semicolon")
+#define GMOCK_DECLARE_int32_(name)            \
+  namespace testing {                         \
+  GTEST_API_ extern int32_t GMOCK_FLAG(name); \
+  } static_assert(true, "no-op to require trailing semicolon")
+#define GMOCK_DECLARE_string_(name)                 \
+  namespace testing {                               \
+  GTEST_API_ extern ::std::string GMOCK_FLAG(name); \
+  } static_assert(true, "no-op to require trailing semicolon")
+
+// Macros for defining flags.
+#define GMOCK_DEFINE_bool_(name, default_val, doc)  \
+  namespace testing {                               \
+  GTEST_API_ bool GMOCK_FLAG(name) = (default_val); \
+  } static_assert(true, "no-op to require trailing semicolon")
+#define GMOCK_DEFINE_int32_(name, default_val, doc)    \
+  namespace testing {                                  \
+  GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val); \
+  } static_assert(true, "no-op to require trailing semicolon")
+#define GMOCK_DEFINE_string_(name, default_val, doc)         \
+  namespace testing {                                        \
+  GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val); \
+  } static_assert(true, "no-op to require trailing semicolon")
+#endif  // !defined(GMOCK_DECLARE_bool_)
+
+#if !defined(GMOCK_FLAG_GET)
+#define GMOCK_FLAG_GET(name) ::testing::GMOCK_FLAG(name)
+#define GMOCK_FLAG_SET(name, value) (void)(::testing::GMOCK_FLAG(name) = value)
+#endif  // !defined(GMOCK_FLAG_GET)
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
diff --git a/tools/gtest_lib/include/gmock/internal/gmock-pp.h b/tools/gtest_lib/include/gmock/internal/gmock-pp.h
new file mode 100644
index 0000000000000000000000000000000000000000..94d61c09c87036dca0afc42e623ce3e15745d5cd
--- /dev/null
+++ b/tools/gtest_lib/include/gmock/internal/gmock-pp.h
@@ -0,0 +1,279 @@
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
+
+// Expands and concatenates the arguments. Constructed macros reevaluate.
+#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2)
+
+// Expands and stringifies the only argument.
+#define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__)
+
+// Returns empty. Given a variadic number of arguments.
+#define GMOCK_PP_EMPTY(...)
+
+// Returns a comma. Given a variadic number of arguments.
+#define GMOCK_PP_COMMA(...) ,
+
+// Returns the only argument.
+#define GMOCK_PP_IDENTITY(_1) _1
+
+// Evaluates to the number of arguments after expansion.
+//
+//   #define PAIR x, y
+//
+//   GMOCK_PP_NARG() => 1
+//   GMOCK_PP_NARG(x) => 1
+//   GMOCK_PP_NARG(x, y) => 2
+//   GMOCK_PP_NARG(PAIR) => 2
+//
+// Requires: the number of arguments after expansion is at most 15.
+#define GMOCK_PP_NARG(...) \
+  GMOCK_PP_INTERNAL_16TH(  \
+      (__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
+
+// Returns 1 if the expansion of arguments has an unprotected comma. Otherwise
+// returns 0. Requires no more than 15 unprotected commas.
+#define GMOCK_PP_HAS_COMMA(...) \
+  GMOCK_PP_INTERNAL_16TH(       \
+      (__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0))
+
+// Returns the first argument.
+#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD((__VA_ARGS__, unusedArg))
+
+// Returns the tail. A variadic list of all arguments minus the first. Requires
+// at least one argument.
+#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL((__VA_ARGS__))
+
+// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__)
+#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \
+  GMOCK_PP_IDENTITY(                        \
+      GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__))
+
+// If the arguments after expansion have no tokens, evaluates to `1`. Otherwise
+// evaluates to `0`.
+//
+// Requires: * the number of arguments after expansion is at most 15.
+//           * If the argument is a macro, it must be able to be called with one
+//             argument.
+//
+// Implementation details:
+//
+// There is one case when it generates a compile error: if the argument is macro
+// that cannot be called with one argument.
+//
+//   #define M(a, b)  // it doesn't matter what it expands to
+//
+//   // Expected: expands to `0`.
+//   // Actual: compile error.
+//   GMOCK_PP_IS_EMPTY(M)
+//
+// There are 4 cases tested:
+//
+// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0.
+// * __VA_ARGS__ possible expansion is not enclosed in parenthesis. Expected 0.
+// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a comma.
+//   Expected 0
+// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in
+//   parenthesis, or is a macro that ()-evaluates to comma. Expected 1.
+//
+// We trigger detection on '0001', i.e. on empty.
+#define GMOCK_PP_IS_EMPTY(...)                                               \
+  GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__),                \
+                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__), \
+                             GMOCK_PP_HAS_COMMA(__VA_ARGS__()),              \
+                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__()))
+
+// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0.
+#define GMOCK_PP_IF(_Cond, _Then, _Else) \
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else)
+
+// Similar to GMOCK_PP_IF but takes _Then and _Else in parentheses.
+//
+// GMOCK_PP_GENERIC_IF(1, (a, b, c), (d, e, f)) => a, b, c
+// GMOCK_PP_GENERIC_IF(0, (a, b, c), (d, e, f)) => d, e, f
+//
+#define GMOCK_PP_GENERIC_IF(_Cond, _Then, _Else) \
+  GMOCK_PP_REMOVE_PARENS(GMOCK_PP_IF(_Cond, _Then, _Else))
+
+// Evaluates to the number of arguments after expansion. Identifies 'empty' as
+// 0.
+//
+//   #define PAIR x, y
+//
+//   GMOCK_PP_NARG0() => 0
+//   GMOCK_PP_NARG0(x) => 1
+//   GMOCK_PP_NARG0(x, y) => 2
+//   GMOCK_PP_NARG0(PAIR) => 2
+//
+// Requires: * the number of arguments after expansion is at most 15.
+//           * If the argument is a macro, it must be able to be called with one
+//             argument.
+#define GMOCK_PP_NARG0(...) \
+  GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0, GMOCK_PP_NARG(__VA_ARGS__))
+
+// Expands to 1 if the first argument starts with something in parentheses,
+// otherwise to 0.
+#define GMOCK_PP_IS_BEGIN_PARENS(...)                              \
+  GMOCK_PP_HEAD(GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \
+                             GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__))
+
+// Expands to 1 is there is only one argument and it is enclosed in parentheses.
+#define GMOCK_PP_IS_ENCLOSED_PARENS(...)             \
+  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \
+              GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0)
+
+// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1.
+#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS __VA_ARGS__
+
+// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data,
+// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple.
+// Requires: * |_Macro| can be called with 3 arguments.
+//           * |_Tuple| expansion has no more than 15 elements.
+#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple)                        \
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \
+  (0, _Macro, _Data, _Tuple)
+
+// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, )
+// Empty if _K = 0.
+// Requires: * |_Macro| can be called with 3 arguments.
+//           * |_K| literal between 0 and 15
+#define GMOCK_PP_REPEAT(_Macro, _Data, _N)           \
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \
+  (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE)
+
+// Increments the argument, requires the argument to be between 0 and 15.
+#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i)
+
+// Returns comma if _i != 0. Requires _i to be between 0 and 15.
+#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i)
+
+// Internal details follow. Do not use any of these symbols outside of this
+// file or we will break your code.
+#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , )
+#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2
+#define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__
+#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5
+#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4)                             \
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_, \
+                                             _1, _2, _3, _4))
+#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 ,
+#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then
+#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else
+
+// Because of MSVC treating a token with a comma in it as a single token when
+// passed to another macro, we need to force it to evaluate it as multiple
+// tokens. We do that by using a "IDENTITY(MACRO PARENTHESIZED_ARGS)" macro. We
+// define one per possible macro that relies on this behavior. Note "_Args" must
+// be parenthesized.
+#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \
+                                        _10, _11, _12, _13, _14, _15, _16,  \
+                                        ...)                                \
+  _16
+#define GMOCK_PP_INTERNAL_16TH(_Args) \
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_16TH _Args)
+#define GMOCK_PP_INTERNAL_INTERNAL_HEAD(_1, ...) _1
+#define GMOCK_PP_INTERNAL_HEAD(_Args) \
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_HEAD _Args)
+#define GMOCK_PP_INTERNAL_INTERNAL_TAIL(_1, ...) __VA_ARGS__
+#define GMOCK_PP_INTERNAL_TAIL(_Args) \
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_TAIL _Args)
+
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1,
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \
+  0,
+#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__
+#define GMOCK_PP_INTERNAL_INC_0 1
+#define GMOCK_PP_INTERNAL_INC_1 2
+#define GMOCK_PP_INTERNAL_INC_2 3
+#define GMOCK_PP_INTERNAL_INC_3 4
+#define GMOCK_PP_INTERNAL_INC_4 5
+#define GMOCK_PP_INTERNAL_INC_5 6
+#define GMOCK_PP_INTERNAL_INC_6 7
+#define GMOCK_PP_INTERNAL_INC_7 8
+#define GMOCK_PP_INTERNAL_INC_8 9
+#define GMOCK_PP_INTERNAL_INC_9 10
+#define GMOCK_PP_INTERNAL_INC_10 11
+#define GMOCK_PP_INTERNAL_INC_11 12
+#define GMOCK_PP_INTERNAL_INC_12 13
+#define GMOCK_PP_INTERNAL_INC_13 14
+#define GMOCK_PP_INTERNAL_INC_14 15
+#define GMOCK_PP_INTERNAL_INC_15 16
+#define GMOCK_PP_INTERNAL_COMMA_IF_0
+#define GMOCK_PP_INTERNAL_COMMA_IF_1 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_2 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_3 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_4 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_5 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_6 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_7 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_8 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_9 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_10 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_11 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_12 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_13 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_14 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_15 ,
+#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \
+  _Macro(_i, _Data, _element)
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple)
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple)
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
diff --git a/tools/gtest_lib/include/gtest/gtest-assertion-result.h b/tools/gtest_lib/include/gtest/gtest-assertion-result.h
new file mode 100644
index 0000000000000000000000000000000000000000..e020c48943f467c021d8ff754a4e5817668fb967
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest-assertion-result.h
@@ -0,0 +1,232 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This file implements the AssertionResult type.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_
+
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+
+// A class for indicating whether an assertion was successful.  When
+// the assertion wasn't successful, the AssertionResult object
+// remembers a non-empty message that describes how it failed.
+//
+// To create an instance of this class, use one of the factory functions
+// (AssertionSuccess() and AssertionFailure()).
+//
+// This class is useful for two purposes:
+//   1. Defining predicate functions to be used with Boolean test assertions
+//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
+//   2. Defining predicate-format functions to be
+//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
+//
+// For example, if you define IsEven predicate:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
+// will print the message
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false (5 is odd)
+//   Expected: true
+//
+// instead of a more opaque
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false
+//   Expected: true
+//
+// in case IsEven is a simple Boolean predicate.
+//
+// If you expect your predicate to be reused and want to support informative
+// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
+// about half as often as positive ones in our tests), supply messages for
+// both success and failure cases:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess() << n << " is even";
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
+//
+//   Value of: IsEven(Fib(6))
+//     Actual: true (8 is even)
+//   Expected: false
+//
+// NB: Predicates that support negative Boolean assertions have reduced
+// performance in positive ones so be careful not to use them in tests
+// that have lots (tens of thousands) of positive Boolean assertions.
+//
+// To use this class with EXPECT_PRED_FORMAT assertions such as:
+//
+//   // Verifies that Foo() returns an even number.
+//   EXPECT_PRED_FORMAT1(IsEven, Foo());
+//
+// you need to define:
+//
+//   testing::AssertionResult IsEven(const char* expr, int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure()
+//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
+//   }
+//
+// If Foo() returns 5, you will see the following message:
+//
+//   Expected: Foo() is even
+//     Actual: it's 5
+//
+class GTEST_API_ AssertionResult {
+ public:
+  // Copy constructor.
+  // Used in EXPECT_TRUE/FALSE(assertion_result).
+  AssertionResult(const AssertionResult& other);
+
+// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
+// This warning is not emitted in Visual Studio 2017.
+// This warning is off by default starting in Visual Studio 2019 but can be
+// enabled with command-line options.
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
+#endif
+
+  // Used in the EXPECT_TRUE/FALSE(bool_expression).
+  //
+  // T must be contextually convertible to bool.
+  //
+  // The second parameter prevents this overload from being considered if
+  // the argument is implicitly convertible to AssertionResult. In that case
+  // we want AssertionResult's copy constructor to be used.
+  template <typename T>
+  explicit AssertionResult(
+      const T& success,
+      typename std::enable_if<
+          !std::is_convertible<T, AssertionResult>::value>::type*
+      /*enabler*/
+      = nullptr)
+      : success_(success) {}
+
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+  // Assignment operator.
+  AssertionResult& operator=(AssertionResult other) {
+    swap(other);
+    return *this;
+  }
+
+  // Returns true if and only if the assertion succeeded.
+  operator bool() const { return success_; }  // NOLINT
+
+  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+  AssertionResult operator!() const;
+
+  // Returns the text streamed into this AssertionResult. Test assertions
+  // use it when they fail (i.e., the predicate's outcome doesn't match the
+  // assertion's expectation). When nothing has been streamed into the
+  // object, returns an empty string.
+  const char* message() const {
+    return message_.get() != nullptr ? message_->c_str() : "";
+  }
+  // Deprecated; please use message() instead.
+  const char* failure_message() const { return message(); }
+
+  // Streams a custom failure message into this object.
+  template <typename T>
+  AssertionResult& operator<<(const T& value) {
+    AppendMessage(Message() << value);
+    return *this;
+  }
+
+  // Allows streaming basic output manipulators such as endl or flush into
+  // this object.
+  AssertionResult& operator<<(
+      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
+    AppendMessage(Message() << basic_manipulator);
+    return *this;
+  }
+
+ private:
+  // Appends the contents of message to message_.
+  void AppendMessage(const Message& a_message) {
+    if (message_.get() == nullptr) message_.reset(new ::std::string);
+    message_->append(a_message.GetString().c_str());
+  }
+
+  // Swap the contents of this AssertionResult with other.
+  void swap(AssertionResult& other);
+
+  // Stores result of the assertion predicate.
+  bool success_;
+  // Stores the message describing the condition in case the expectation
+  // construct is not satisfied with the predicate's outcome.
+  // Referenced via a pointer to avoid taking too much stack frame space
+  // with test assertions.
+  std::unique_ptr< ::std::string> message_;
+};
+
+// Makes a successful assertion result.
+GTEST_API_ AssertionResult AssertionSuccess();
+
+// Makes a failed assertion result.
+GTEST_API_ AssertionResult AssertionFailure();
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << msg.
+GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_
diff --git a/tools/gtest_lib/include/gtest/gtest-death-test.h b/tools/gtest_lib/include/gtest/gtest-death-test.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd34e1f2e852295e2416334fd12cb982917448a6
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest-death-test.h
@@ -0,0 +1,346 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the public API for death tests.  It is
+// #included by gtest.h so a user doesn't need to include this
+// directly.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+
+#include "gtest/internal/gtest-death-test-internal.h"
+
+// This flag controls the style of death tests.  Valid values are "threadsafe",
+// meaning that the death test child process will re-execute the test binary
+// from the start, running only a single death test, or "fast",
+// meaning that the child process will execute the test logic immediately
+// after forking.
+GTEST_DECLARE_string_(death_test_style);
+
+namespace testing {
+
+#if GTEST_HAS_DEATH_TEST
+
+namespace internal {
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+GTEST_API_ bool InDeathTestChild();
+
+}  // namespace internal
+
+// The following macros are useful for writing death tests.
+
+// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
+// executed:
+//
+//   1. It generates a warning if there is more than one active
+//   thread.  This is because it's safe to fork() or clone() only
+//   when there is a single thread.
+//
+//   2. The parent process clone()s a sub-process and runs the death
+//   test in it; the sub-process exits with code 0 at the end of the
+//   death test, if it hasn't exited already.
+//
+//   3. The parent process waits for the sub-process to terminate.
+//
+//   4. The parent process checks the exit code and error message of
+//   the sub-process.
+//
+// Examples:
+//
+//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
+//   for (int i = 0; i < 5; i++) {
+//     EXPECT_DEATH(server.ProcessRequest(i),
+//                  "Invalid request .* in ProcessRequest()")
+//                  << "Failed to die on request " << i;
+//   }
+//
+//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
+//
+//   bool KilledBySIGHUP(int exit_code) {
+//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
+//   }
+//
+//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
+//
+// The final parameter to each of these macros is a matcher applied to any data
+// the sub-process wrote to stderr.  For compatibility with existing tests, a
+// bare string is interpreted as a regular expression matcher.
+//
+// On the regular expressions used in death tests:
+//
+//   On POSIX-compliant systems (*nix), we use the <regex.h> library,
+//   which uses the POSIX extended regex syntax.
+//
+//   On other platforms (e.g. Windows or Mac), we only support a simple regex
+//   syntax implemented as part of Google Test.  This limited
+//   implementation should be enough most of the time when writing
+//   death tests; though it lacks many features you can find in PCRE
+//   or POSIX extended regex syntax.  For example, we don't support
+//   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
+//   repetition count ("x{5,7}"), among others.
+//
+//   Below is the syntax that we do support.  We chose it to be a
+//   subset of both PCRE and POSIX extended regex, so it's easy to
+//   learn wherever you come from.  In the following: 'A' denotes a
+//   literal character, period (.), or a single \\ escape sequence;
+//   'x' and 'y' denote regular expressions; 'm' and 'n' are for
+//   natural numbers.
+//
+//     c     matches any literal character c
+//     \\d   matches any decimal digit
+//     \\D   matches any character that's not a decimal digit
+//     \\f   matches \f
+//     \\n   matches \n
+//     \\r   matches \r
+//     \\s   matches any ASCII whitespace, including \n
+//     \\S   matches any character that's not a whitespace
+//     \\t   matches \t
+//     \\v   matches \v
+//     \\w   matches any letter, _, or decimal digit
+//     \\W   matches any character that \\w doesn't match
+//     \\c   matches any literal character c, which must be a punctuation
+//     .     matches any single character except \n
+//     A?    matches 0 or 1 occurrences of A
+//     A*    matches 0 or many occurrences of A
+//     A+    matches 1 or many occurrences of A
+//     ^     matches the beginning of a string (not that of each line)
+//     $     matches the end of a string (not that of each line)
+//     xy    matches x followed by y
+//
+//   If you accidentally use PCRE or POSIX extended regex features
+//   not implemented by us, you will get a run-time failure.  In that
+//   case, please try to rewrite your regular expression within the
+//   above syntax.
+//
+//   This implementation is *not* meant to be as highly tuned or robust
+//   as a compiled regex library, but should perform well enough for a
+//   death test, which already incurs significant overhead by launching
+//   a child process.
+//
+// Known caveats:
+//
+//   A "threadsafe" style death test obtains the path to the test
+//   program from argv[0] and re-executes it in the sub-process.  For
+//   simplicity, the current implementation doesn't search the PATH
+//   when launching the sub-process.  This means that the user must
+//   invoke the test program via a path that contains at least one
+//   path separator (e.g. path/to/foo_test and
+//   /absolute/path/to/bar_test are fine, but foo_test is not).  This
+//   is rarely a problem as people usually don't put the test binary
+//   directory in PATH.
+//
+
+// Asserts that a given `statement` causes the program to exit, with an
+// integer exit status that satisfies `predicate`, and emitting error output
+// that matches `matcher`.
+# define ASSERT_EXIT(statement, predicate, matcher) \
+    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_FATAL_FAILURE_)
+
+// Like `ASSERT_EXIT`, but continues on to successive tests in the
+// test suite, if any:
+# define EXPECT_EXIT(statement, predicate, matcher) \
+    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_NONFATAL_FAILURE_)
+
+// Asserts that a given `statement` causes the program to exit, either by
+// explicitly exiting with a nonzero exit code or being killed by a
+// signal, and emitting error output that matches `matcher`.
+# define ASSERT_DEATH(statement, matcher) \
+    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
+
+// Like `ASSERT_DEATH`, but continues on to successive tests in the
+// test suite, if any:
+# define EXPECT_DEATH(statement, matcher) \
+    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
+
+// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
+
+// Tests that an exit code describes a normal exit with a given exit code.
+class GTEST_API_ ExitedWithCode {
+ public:
+  explicit ExitedWithCode(int exit_code);
+  ExitedWithCode(const ExitedWithCode&) = default;
+  void operator=(const ExitedWithCode& other) = delete;
+  bool operator()(int exit_status) const;
+ private:
+  const int exit_code_;
+};
+
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+// Tests that an exit code describes an exit due to termination by a
+// given signal.
+class GTEST_API_ KilledBySignal {
+ public:
+  explicit KilledBySignal(int signum);
+  bool operator()(int exit_status) const;
+ private:
+  const int signum_;
+};
+# endif  // !GTEST_OS_WINDOWS
+
+// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
+// The death testing framework causes this to have interesting semantics,
+// since the sideeffects of the call are only visible in opt mode, and not
+// in debug mode.
+//
+// In practice, this can be used to test functions that utilize the
+// LOG(DFATAL) macro using the following style:
+//
+// int DieInDebugOr12(int* sideeffect) {
+//   if (sideeffect) {
+//     *sideeffect = 12;
+//   }
+//   LOG(DFATAL) << "death";
+//   return 12;
+// }
+//
+// TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) {
+//   int sideeffect = 0;
+//   // Only asserts in dbg.
+//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
+//
+// #ifdef NDEBUG
+//   // opt-mode has sideeffect visible.
+//   EXPECT_EQ(12, sideeffect);
+// #else
+//   // dbg-mode no visible sideeffect.
+//   EXPECT_EQ(0, sideeffect);
+// #endif
+// }
+//
+// This will assert that DieInDebugReturn12InOpt() crashes in debug
+// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
+// appropriate fallback value (12 in this case) in opt mode. If you
+// need to test that a function has appropriate side-effects in opt
+// mode, include assertions against the side-effects.  A general
+// pattern for this is:
+//
+// EXPECT_DEBUG_DEATH({
+//   // Side-effects here will have an effect after this statement in
+//   // opt mode, but none in debug mode.
+//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
+// }, "death");
+//
+# ifdef NDEBUG
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+# else
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  EXPECT_DEATH(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  ASSERT_DEATH(statement, regex)
+
+# endif  // NDEBUG for EXPECT_DEBUG_DEATH
+#endif  // GTEST_HAS_DEATH_TEST
+
+// This macro is used for implementing macros such as
+// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
+// death tests are not supported. Those macros must compile on such systems
+// if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same parameters
+// on systems that support death tests. This allows one to write such a macro on
+// a system that does not support death tests and be sure that it will compile
+// on a death-test supporting system. It is exposed publicly so that systems
+// that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST
+// can write their own equivalent of EXPECT_DEATH_IF_SUPPORTED and
+// ASSERT_DEATH_IF_SUPPORTED.
+//
+// Parameters:
+//   statement -  A statement that a macro such as EXPECT_DEATH would test
+//                for program termination. This macro has to make sure this
+//                statement is compiled but not executed, to ensure that
+//                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
+//                parameter if and only if EXPECT_DEATH compiles with it.
+//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
+//                the output of statement.  This parameter has to be
+//                compiled but not evaluated by this macro, to ensure that
+//                this macro only accepts expressions that a macro such as
+//                EXPECT_DEATH would accept.
+//   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
+//                and a return statement for ASSERT_DEATH_IF_SUPPORTED.
+//                This ensures that ASSERT_DEATH_IF_SUPPORTED will not
+//                compile inside functions where ASSERT_DEATH doesn't
+//                compile.
+//
+//  The branch that has an always false condition is used to ensure that
+//  statement and regex are compiled (and thus syntactically correct) but
+//  never executed. The unreachable code macro protects the terminator
+//  statement from generating an 'unreachable code' warning in case
+//  statement unconditionally returns or throws. The Message constructor at
+//  the end allows the syntax of streaming additional messages into the
+//  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
+# define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+    if (::testing::internal::AlwaysTrue()) { \
+      GTEST_LOG_(WARNING) \
+          << "Death tests are not supported on this platform.\n" \
+          << "Statement '" #statement "' cannot be verified."; \
+    } else if (::testing::internal::AlwaysFalse()) { \
+      ::testing::internal::RE::PartialMatch(".*", (regex)); \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+      terminator; \
+    } else \
+      ::testing::Message()
+
+// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
+// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
+// death tests are supported; otherwise they just issue a warning.  This is
+// useful when you are combining death test assertions with normal test
+// assertions in one test.
+#if GTEST_HAS_DEATH_TEST
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    EXPECT_DEATH(statement, regex)
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    ASSERT_DEATH(statement, regex)
+#else
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)
+#endif
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
diff --git a/tools/gtest_lib/include/gtest/gtest-matchers.h b/tools/gtest_lib/include/gtest/gtest-matchers.h
new file mode 100644
index 0000000000000000000000000000000000000000..3472db7e17ec34512907a45d0f0dc8a65aa8fe8e
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest-matchers.h
@@ -0,0 +1,934 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This file implements just enough of the matcher interface to allow
+// EXPECT_DEATH and friends to accept a matcher argument.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
+
+#include <atomic>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+#include "gtest/gtest-printers.h"
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+
+// MSVC warning C5046 is new as of VS2017 version 15.8.
+#if defined(_MSC_VER) && _MSC_VER >= 1915
+#define GTEST_MAYBE_5046_ 5046
+#else
+#define GTEST_MAYBE_5046_
+#endif
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(
+    4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be used by
+                              clients of class B */
+    /* Symbol involving type with internal linkage not defined */)
+
+namespace testing {
+
+// To implement a matcher Foo for type T, define:
+//   1. a class FooMatcherMatcher that implements the matcher interface:
+//     using is_gtest_matcher = void;
+//     bool MatchAndExplain(const T&, std::ostream*);
+//       (MatchResultListener* can also be used instead of std::ostream*)
+//     void DescribeTo(std::ostream*);
+//     void DescribeNegationTo(std::ostream*);
+//
+//   2. a factory function that creates a Matcher<T> object from a
+//      FooMatcherMatcher.
+
+class MatchResultListener {
+ public:
+  // Creates a listener object with the given underlying ostream.  The
+  // listener does not own the ostream, and does not dereference it
+  // in the constructor or destructor.
+  explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
+  virtual ~MatchResultListener() = 0;  // Makes this class abstract.
+
+  // Streams x to the underlying ostream; does nothing if the ostream
+  // is NULL.
+  template <typename T>
+  MatchResultListener& operator<<(const T& x) {
+    if (stream_ != nullptr) *stream_ << x;
+    return *this;
+  }
+
+  // Returns the underlying ostream.
+  ::std::ostream* stream() { return stream_; }
+
+  // Returns true if and only if the listener is interested in an explanation
+  // of the match result.  A matcher's MatchAndExplain() method can use
+  // this information to avoid generating the explanation when no one
+  // intends to hear it.
+  bool IsInterested() const { return stream_ != nullptr; }
+
+ private:
+  ::std::ostream* const stream_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
+};
+
+inline MatchResultListener::~MatchResultListener() {
+}
+
+// An instance of a subclass of this knows how to describe itself as a
+// matcher.
+class GTEST_API_ MatcherDescriberInterface {
+ public:
+  virtual ~MatcherDescriberInterface() {}
+
+  // Describes this matcher to an ostream.  The function should print
+  // a verb phrase that describes the property a value matching this
+  // matcher should have.  The subject of the verb phrase is the value
+  // being matched.  For example, the DescribeTo() method of the Gt(7)
+  // matcher prints "is greater than 7".
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+
+  // Describes the negation of this matcher to an ostream.  For
+  // example, if the description of this matcher is "is greater than
+  // 7", the negated description could be "is not greater than 7".
+  // You are not required to override this when implementing
+  // MatcherInterface, but it is highly advised so that your matcher
+  // can produce good error messages.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "not (";
+    DescribeTo(os);
+    *os << ")";
+  }
+};
+
+// The implementation of a matcher.
+template <typename T>
+class MatcherInterface : public MatcherDescriberInterface {
+ public:
+  // Returns true if and only if the matcher matches x; also explains the
+  // match result to 'listener' if necessary (see the next paragraph), in
+  // the form of a non-restrictive relative clause ("which ...",
+  // "whose ...", etc) that describes x.  For example, the
+  // MatchAndExplain() method of the Pointee(...) matcher should
+  // generate an explanation like "which points to ...".
+  //
+  // Implementations of MatchAndExplain() should add an explanation of
+  // the match result *if and only if* they can provide additional
+  // information that's not already present (or not obvious) in the
+  // print-out of x and the matcher's description.  Whether the match
+  // succeeds is not a factor in deciding whether an explanation is
+  // needed, as sometimes the caller needs to print a failure message
+  // when the match succeeds (e.g. when the matcher is used inside
+  // Not()).
+  //
+  // For example, a "has at least 10 elements" matcher should explain
+  // what the actual element count is, regardless of the match result,
+  // as it is useful information to the reader; on the other hand, an
+  // "is empty" matcher probably only needs to explain what the actual
+  // size is when the match fails, as it's redundant to say that the
+  // size is 0 when the value is already known to be empty.
+  //
+  // You should override this method when defining a new matcher.
+  //
+  // It's the responsibility of the caller (Google Test) to guarantee
+  // that 'listener' is not NULL.  This helps to simplify a matcher's
+  // implementation when it doesn't care about the performance, as it
+  // can talk to 'listener' without checking its validity first.
+  // However, in order to implement dummy listeners efficiently,
+  // listener->stream() may be NULL.
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
+
+  // Inherits these methods from MatcherDescriberInterface:
+  //   virtual void DescribeTo(::std::ostream* os) const = 0;
+  //   virtual void DescribeNegationTo(::std::ostream* os) const;
+};
+
+namespace internal {
+
+struct AnyEq {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a == b; }
+};
+struct AnyNe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a != b; }
+};
+struct AnyLt {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a < b; }
+};
+struct AnyGt {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a > b; }
+};
+struct AnyLe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a <= b; }
+};
+struct AnyGe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a >= b; }
+};
+
+// A match result listener that ignores the explanation.
+class DummyMatchResultListener : public MatchResultListener {
+ public:
+  DummyMatchResultListener() : MatchResultListener(nullptr) {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
+};
+
+// A match result listener that forwards the explanation to a given
+// ostream.  The difference between this and MatchResultListener is
+// that the former is concrete.
+class StreamMatchResultListener : public MatchResultListener {
+ public:
+  explicit StreamMatchResultListener(::std::ostream* os)
+      : MatchResultListener(os) {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
+};
+
+struct SharedPayloadBase {
+  std::atomic<int> ref{1};
+  void Ref() { ref.fetch_add(1, std::memory_order_relaxed); }
+  bool Unref() { return ref.fetch_sub(1, std::memory_order_acq_rel) == 1; }
+};
+
+template <typename T>
+struct SharedPayload : SharedPayloadBase {
+  explicit SharedPayload(const T& v) : value(v) {}
+  explicit SharedPayload(T&& v) : value(std::move(v)) {}
+
+  static void Destroy(SharedPayloadBase* shared) {
+    delete static_cast<SharedPayload*>(shared);
+  }
+
+  T value;
+};
+
+// An internal class for implementing Matcher<T>, which will derive
+// from it.  We put functionalities common to all Matcher<T>
+// specializations here to avoid code duplication.
+template <typename T>
+class MatcherBase : private MatcherDescriberInterface {
+ public:
+  // Returns true if and only if the matcher matches x; also explains the
+  // match result to 'listener'.
+  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
+    GTEST_CHECK_(vtable_ != nullptr);
+    return vtable_->match_and_explain(*this, x, listener);
+  }
+
+  // Returns true if and only if this matcher matches x.
+  bool Matches(const T& x) const {
+    DummyMatchResultListener dummy;
+    return MatchAndExplain(x, &dummy);
+  }
+
+  // Describes this matcher to an ostream.
+  void DescribeTo(::std::ostream* os) const final {
+    GTEST_CHECK_(vtable_ != nullptr);
+    vtable_->describe(*this, os, false);
+  }
+
+  // Describes the negation of this matcher to an ostream.
+  void DescribeNegationTo(::std::ostream* os) const final {
+    GTEST_CHECK_(vtable_ != nullptr);
+    vtable_->describe(*this, os, true);
+  }
+
+  // Explains why x matches, or doesn't match, the matcher.
+  void ExplainMatchResultTo(const T& x, ::std::ostream* os) const {
+    StreamMatchResultListener listener(os);
+    MatchAndExplain(x, &listener);
+  }
+
+  // Returns the describer for this matcher object; retains ownership
+  // of the describer, which is only guaranteed to be alive when
+  // this matcher object is alive.
+  const MatcherDescriberInterface* GetDescriber() const {
+    if (vtable_ == nullptr) return nullptr;
+    return vtable_->get_describer(*this);
+  }
+
+ protected:
+  MatcherBase() : vtable_(nullptr) {}
+
+  // Constructs a matcher from its implementation.
+  template <typename U>
+  explicit MatcherBase(const MatcherInterface<U>* impl) {
+    Init(impl);
+  }
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  MatcherBase(M&& m) {  // NOLINT
+    Init(std::forward<M>(m));
+  }
+
+  MatcherBase(const MatcherBase& other)
+      : vtable_(other.vtable_), buffer_(other.buffer_) {
+    if (IsShared()) buffer_.shared->Ref();
+  }
+
+  MatcherBase& operator=(const MatcherBase& other) {
+    if (this == &other) return *this;
+    Destroy();
+    vtable_ = other.vtable_;
+    buffer_ = other.buffer_;
+    if (IsShared()) buffer_.shared->Ref();
+    return *this;
+  }
+
+  MatcherBase(MatcherBase&& other)
+      : vtable_(other.vtable_), buffer_(other.buffer_) {
+    other.vtable_ = nullptr;
+  }
+
+  MatcherBase& operator=(MatcherBase&& other) {
+    if (this == &other) return *this;
+    Destroy();
+    vtable_ = other.vtable_;
+    buffer_ = other.buffer_;
+    other.vtable_ = nullptr;
+    return *this;
+  }
+
+  ~MatcherBase() override { Destroy(); }
+
+ private:
+  struct VTable {
+    bool (*match_and_explain)(const MatcherBase&, const T&,
+                              MatchResultListener*);
+    void (*describe)(const MatcherBase&, std::ostream*, bool negation);
+    // Returns the captured object if it implements the interface, otherwise
+    // returns the MatcherBase itself.
+    const MatcherDescriberInterface* (*get_describer)(const MatcherBase&);
+    // Called on shared instances when the reference count reaches 0.
+    void (*shared_destroy)(SharedPayloadBase*);
+  };
+
+  bool IsShared() const {
+    return vtable_ != nullptr && vtable_->shared_destroy != nullptr;
+  }
+
+  // If the implementation uses a listener, call that.
+  template <typename P>
+  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
+                                  MatchResultListener* listener)
+      -> decltype(P::Get(m).MatchAndExplain(value, listener->stream())) {
+    return P::Get(m).MatchAndExplain(value, listener->stream());
+  }
+
+  template <typename P>
+  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
+                                  MatchResultListener* listener)
+      -> decltype(P::Get(m).MatchAndExplain(value, listener)) {
+    return P::Get(m).MatchAndExplain(value, listener);
+  }
+
+  template <typename P>
+  static void DescribeImpl(const MatcherBase& m, std::ostream* os,
+                           bool negation) {
+    if (negation) {
+      P::Get(m).DescribeNegationTo(os);
+    } else {
+      P::Get(m).DescribeTo(os);
+    }
+  }
+
+  template <typename P>
+  static const MatcherDescriberInterface* GetDescriberImpl(
+      const MatcherBase& m) {
+    // If the impl is a MatcherDescriberInterface, then return it.
+    // Otherwise use MatcherBase itself.
+    // This allows us to implement the GetDescriber() function without support
+    // from the impl, but some users really want to get their impl back when
+    // they call GetDescriber().
+    // We use std::get on a tuple as a workaround of not having `if constexpr`.
+    return std::get<(
+        std::is_convertible<decltype(&P::Get(m)),
+                            const MatcherDescriberInterface*>::value
+            ? 1
+            : 0)>(std::make_tuple(&m, &P::Get(m)));
+  }
+
+  template <typename P>
+  const VTable* GetVTable() {
+    static constexpr VTable kVTable = {&MatchAndExplainImpl<P>,
+                                       &DescribeImpl<P>, &GetDescriberImpl<P>,
+                                       P::shared_destroy};
+    return &kVTable;
+  }
+
+  union Buffer {
+    // Add some types to give Buffer some common alignment/size use cases.
+    void* ptr;
+    double d;
+    int64_t i;
+    // And add one for the out-of-line cases.
+    SharedPayloadBase* shared;
+  };
+
+  void Destroy() {
+    if (IsShared() && buffer_.shared->Unref()) {
+      vtable_->shared_destroy(buffer_.shared);
+    }
+  }
+
+  template <typename M>
+  static constexpr bool IsInlined() {
+    return sizeof(M) <= sizeof(Buffer) && alignof(M) <= alignof(Buffer) &&
+           std::is_trivially_copy_constructible<M>::value &&
+           std::is_trivially_destructible<M>::value;
+  }
+
+  template <typename M, bool = MatcherBase::IsInlined<M>()>
+  struct ValuePolicy {
+    static const M& Get(const MatcherBase& m) {
+      // When inlined along with Init, need to be explicit to avoid violating
+      // strict aliasing rules.
+      const M *ptr = static_cast<const M*>(
+          static_cast<const void*>(&m.buffer_));
+      return *ptr;
+    }
+    static void Init(MatcherBase& m, M impl) {
+      ::new (static_cast<void*>(&m.buffer_)) M(impl);
+    }
+    static constexpr auto shared_destroy = nullptr;
+  };
+
+  template <typename M>
+  struct ValuePolicy<M, false> {
+    using Shared = SharedPayload<M>;
+    static const M& Get(const MatcherBase& m) {
+      return static_cast<Shared*>(m.buffer_.shared)->value;
+    }
+    template <typename Arg>
+    static void Init(MatcherBase& m, Arg&& arg) {
+      m.buffer_.shared = new Shared(std::forward<Arg>(arg));
+    }
+    static constexpr auto shared_destroy = &Shared::Destroy;
+  };
+
+  template <typename U, bool B>
+  struct ValuePolicy<const MatcherInterface<U>*, B> {
+    using M = const MatcherInterface<U>;
+    using Shared = SharedPayload<std::unique_ptr<M>>;
+    static const M& Get(const MatcherBase& m) {
+      return *static_cast<Shared*>(m.buffer_.shared)->value;
+    }
+    static void Init(MatcherBase& m, M* impl) {
+      m.buffer_.shared = new Shared(std::unique_ptr<M>(impl));
+    }
+
+    static constexpr auto shared_destroy = &Shared::Destroy;
+  };
+
+  template <typename M>
+  void Init(M&& m) {
+    using MM = typename std::decay<M>::type;
+    using Policy = ValuePolicy<MM>;
+    vtable_ = GetVTable<Policy>();
+    Policy::Init(*this, std::forward<M>(m));
+  }
+
+  const VTable* vtable_;
+  Buffer buffer_;
+};
+
+}  // namespace internal
+
+// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
+// object that can check whether a value of type T matches.  The
+// implementation of Matcher<T> is just a std::shared_ptr to const
+// MatcherInterface<T>.  Don't inherit from Matcher!
+template <typename T>
+class Matcher : public internal::MatcherBase<T> {
+ public:
+  // Constructs a null matcher.  Needed for storing Matcher objects in STL
+  // containers.  A default-constructed matcher is not yet initialized.  You
+  // cannot use it until a valid value has been assigned to it.
+  explicit Matcher() {}  // NOLINT
+
+  // Constructs a matcher from its implementation.
+  explicit Matcher(const MatcherInterface<const T&>* impl)
+      : internal::MatcherBase<T>(impl) {}
+
+  template <typename U>
+  explicit Matcher(
+      const MatcherInterface<U>* impl,
+      typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
+          nullptr)
+      : internal::MatcherBase<T>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m) : internal::MatcherBase<T>(std::forward<M>(m)) {}  // NOLINT
+
+  // Implicit constructor here allows people to write
+  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
+  Matcher(T value);  // NOLINT
+};
+
+// The following two specializations allow the user to write str
+// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const std::string&>
+    : public internal::MatcherBase<const std::string&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const std::string&>* impl)
+      : internal::MatcherBase<const std::string&>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<const std::string&>(std::forward<M>(m)) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a std::string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<std::string>
+    : public internal::MatcherBase<std::string> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const std::string&>* impl)
+      : internal::MatcherBase<std::string>(impl) {}
+  explicit Matcher(const MatcherInterface<std::string>* impl)
+      : internal::MatcherBase<std::string>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<std::string>(std::forward<M>(m)) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// The following two specializations allow the user to write str
+// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const internal::StringView&>
+    : public internal::MatcherBase<const internal::StringView&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
+      : internal::MatcherBase<const internal::StringView&>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) {
+  }
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a std::string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass absl::string_views or std::string_views directly.
+  Matcher(internal::StringView s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<internal::StringView>
+    : public internal::MatcherBase<internal::StringView> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
+      : internal::MatcherBase<internal::StringView>(impl) {}
+  explicit Matcher(const MatcherInterface<internal::StringView>* impl)
+      : internal::MatcherBase<internal::StringView>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a std::string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass absl::string_views or std::string_views directly.
+  Matcher(internal::StringView s);  // NOLINT
+};
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+// Prints a matcher in a human-readable format.
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
+  matcher.DescribeTo(&os);
+  return os;
+}
+
+// The PolymorphicMatcher class template makes it easy to implement a
+// polymorphic matcher (i.e. a matcher that can match values of more
+// than one type, e.g. Eq(n) and NotNull()).
+//
+// To define a polymorphic matcher, a user should provide an Impl
+// class that has a DescribeTo() method and a DescribeNegationTo()
+// method, and define a member function (or member function template)
+//
+//   bool MatchAndExplain(const Value& value,
+//                        MatchResultListener* listener) const;
+//
+// See the definition of NotNull() for a complete example.
+template <class Impl>
+class PolymorphicMatcher {
+ public:
+  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
+
+  // Returns a mutable reference to the underlying matcher
+  // implementation object.
+  Impl& mutable_impl() { return impl_; }
+
+  // Returns an immutable reference to the underlying matcher
+  // implementation object.
+  const Impl& impl() const { return impl_; }
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new MonomorphicImpl<const T&>(impl_));
+  }
+
+ private:
+  template <typename T>
+  class MonomorphicImpl : public MatcherInterface<T> {
+   public:
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    void DescribeTo(::std::ostream* os) const override { impl_.DescribeTo(os); }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      impl_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+      return impl_.MatchAndExplain(x, listener);
+    }
+
+   private:
+    const Impl impl_;
+  };
+
+  Impl impl_;
+};
+
+// Creates a matcher from its implementation.
+// DEPRECATED: Especially in the generic code, prefer:
+//   Matcher<T>(new MyMatcherImpl<const T&>(...));
+//
+// MakeMatcher may create a Matcher that accepts its argument by value, which
+// leads to unnecessary copies & lack of support for non-copyable types.
+template <typename T>
+inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
+  return Matcher<T>(impl);
+}
+
+// Creates a polymorphic matcher from its implementation.  This is
+// easier to use than the PolymorphicMatcher<Impl> constructor as it
+// doesn't require you to explicitly write the template argument, e.g.
+//
+//   MakePolymorphicMatcher(foo);
+// vs
+//   PolymorphicMatcher<TypeOfFoo>(foo);
+template <class Impl>
+inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
+  return PolymorphicMatcher<Impl>(impl);
+}
+
+namespace internal {
+// Implements a matcher that compares a given value with a
+// pre-supplied value using one of the ==, <=, <, etc, operators.  The
+// two values being compared don't have to have the same type.
+//
+// The matcher defined here is polymorphic (for example, Eq(5) can be
+// used to match an int, a short, a double, etc).  Therefore we use
+// a template type conversion operator in the implementation.
+//
+// The following template definition assumes that the Rhs parameter is
+// a "bare" type (i.e. neither 'const T' nor 'T&').
+template <typename D, typename Rhs, typename Op>
+class ComparisonBase {
+ public:
+  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
+
+  using is_gtest_matcher = void;
+
+  template <typename Lhs>
+  bool MatchAndExplain(const Lhs& lhs, std::ostream*) const {
+    return Op()(lhs, Unwrap(rhs_));
+  }
+  void DescribeTo(std::ostream* os) const {
+    *os << D::Desc() << " ";
+    UniversalPrint(Unwrap(rhs_), os);
+  }
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << D::NegatedDesc() << " ";
+    UniversalPrint(Unwrap(rhs_), os);
+  }
+
+ private:
+  template <typename T>
+  static const T& Unwrap(const T& v) {
+    return v;
+  }
+  template <typename T>
+  static const T& Unwrap(std::reference_wrapper<T> v) {
+    return v;
+  }
+
+  Rhs rhs_;
+};
+
+template <typename Rhs>
+class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
+ public:
+  explicit EqMatcher(const Rhs& rhs)
+      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
+  static const char* Desc() { return "is equal to"; }
+  static const char* NegatedDesc() { return "isn't equal to"; }
+};
+template <typename Rhs>
+class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
+ public:
+  explicit NeMatcher(const Rhs& rhs)
+      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
+  static const char* Desc() { return "isn't equal to"; }
+  static const char* NegatedDesc() { return "is equal to"; }
+};
+template <typename Rhs>
+class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
+ public:
+  explicit LtMatcher(const Rhs& rhs)
+      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
+  static const char* Desc() { return "is <"; }
+  static const char* NegatedDesc() { return "isn't <"; }
+};
+template <typename Rhs>
+class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
+ public:
+  explicit GtMatcher(const Rhs& rhs)
+      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
+  static const char* Desc() { return "is >"; }
+  static const char* NegatedDesc() { return "isn't >"; }
+};
+template <typename Rhs>
+class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
+ public:
+  explicit LeMatcher(const Rhs& rhs)
+      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
+  static const char* Desc() { return "is <="; }
+  static const char* NegatedDesc() { return "isn't <="; }
+};
+template <typename Rhs>
+class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
+ public:
+  explicit GeMatcher(const Rhs& rhs)
+      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
+  static const char* Desc() { return "is >="; }
+  static const char* NegatedDesc() { return "isn't >="; }
+};
+
+template <typename T, typename = typename std::enable_if<
+                          std::is_constructible<std::string, T>::value>::type>
+using StringLike = T;
+
+// Implements polymorphic matchers MatchesRegex(regex) and
+// ContainsRegex(regex), which can be used as a Matcher<T> as long as
+// T can be converted to a string.
+class MatchesRegexMatcher {
+ public:
+  MatchesRegexMatcher(const RE* regex, bool full_match)
+      : regex_(regex), full_match_(full_match) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    return MatchAndExplain(std::string(s), listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(std::string(s), listener);
+  }
+
+  // Matches anything that can convert to std::string.
+  //
+  // This is a template, not just a plain function with const std::string&,
+  // because absl::string_view has some interfering non-explicit constructors.
+  template <class MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const std::string& s2(s);
+    return full_match_ ? RE::FullMatch(s2, *regex_)
+                       : RE::PartialMatch(s2, *regex_);
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << (full_match_ ? "matches" : "contains") << " regular expression ";
+    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't " << (full_match_ ? "match" : "contain")
+        << " regular expression ";
+    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
+  }
+
+ private:
+  const std::shared_ptr<const RE> regex_;
+  const bool full_match_;
+};
+}  // namespace internal
+
+// Matches a string that fully matches regular expression 'regex'.
+// The matcher takes ownership of 'regex'.
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+    const internal::RE* regex) {
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
+}
+template <typename T = std::string>
+PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+    const internal::StringLike<T>& regex) {
+  return MatchesRegex(new internal::RE(std::string(regex)));
+}
+
+// Matches a string that contains regular expression 'regex'.
+// The matcher takes ownership of 'regex'.
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+    const internal::RE* regex) {
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
+}
+template <typename T = std::string>
+PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+    const internal::StringLike<T>& regex) {
+  return ContainsRegex(new internal::RE(std::string(regex)));
+}
+
+// Creates a polymorphic matcher that matches anything equal to x.
+// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
+// wouldn't compile.
+template <typename T>
+inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
+
+// Constructs a Matcher<T> from a 'value' of type T.  The constructed
+// matcher matches any value that's equal to 'value'.
+template <typename T>
+Matcher<T>::Matcher(T value) { *this = Eq(value); }
+
+// Creates a monomorphic matcher that matches anything with type Lhs
+// and equal to rhs.  A user may need to use this instead of Eq(...)
+// in order to resolve an overloading ambiguity.
+//
+// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
+// or Matcher<T>(x), but more readable than the latter.
+//
+// We could define similar monomorphic matchers for other comparison
+// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
+// it yet as those are used much less than Eq() in practice.  A user
+// can always write Matcher<T>(Lt(5)) to be explicit about the type,
+// for example.
+template <typename Lhs, typename Rhs>
+inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
+
+// Creates a polymorphic matcher that matches anything >= x.
+template <typename Rhs>
+inline internal::GeMatcher<Rhs> Ge(Rhs x) {
+  return internal::GeMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything > x.
+template <typename Rhs>
+inline internal::GtMatcher<Rhs> Gt(Rhs x) {
+  return internal::GtMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything <= x.
+template <typename Rhs>
+inline internal::LeMatcher<Rhs> Le(Rhs x) {
+  return internal::LeMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything < x.
+template <typename Rhs>
+inline internal::LtMatcher<Rhs> Lt(Rhs x) {
+  return internal::LtMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything != x.
+template <typename Rhs>
+inline internal::NeMatcher<Rhs> Ne(Rhs x) {
+  return internal::NeMatcher<Rhs>(x);
+}
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
diff --git a/tools/gtest_lib/include/gtest/gtest-message.h b/tools/gtest_lib/include/gtest/gtest-message.h
new file mode 100644
index 0000000000000000000000000000000000000000..9419229ffa077548eeae83aa1843e66d570fc7ca
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest-message.h
@@ -0,0 +1,220 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the Message class.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+
+#include <limits>
+#include <memory>
+#include <sstream>
+
+#include "gtest/internal/gtest-port.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// Ensures that there is at least one operator<< in the global namespace.
+// See Message& operator<<(...) below for why.
+void operator<<(const testing::internal::Secret&, int);
+
+namespace testing {
+
+// The Message class works like an ostream repeater.
+//
+// Typical usage:
+//
+//   1. You stream a bunch of values to a Message object.
+//      It will remember the text in a stringstream.
+//   2. Then you stream the Message object to an ostream.
+//      This causes the text in the Message to be streamed
+//      to the ostream.
+//
+// For example;
+//
+//   testing::Message foo;
+//   foo << 1 << " != " << 2;
+//   std::cout << foo;
+//
+// will print "1 != 2".
+//
+// Message is not intended to be inherited from.  In particular, its
+// destructor is not virtual.
+//
+// Note that stringstream behaves differently in gcc and in MSVC.  You
+// can stream a NULL char pointer to it in the former, but not in the
+// latter (it causes an access violation if you do).  The Message
+// class hides this difference by treating a NULL char pointer as
+// "(null)".
+class GTEST_API_ Message {
+ private:
+  // The type of basic IO manipulators (endl, ends, and flush) for
+  // narrow streams.
+  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
+
+ public:
+  // Constructs an empty Message.
+  Message();
+
+  // Copy constructor.
+  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
+    *ss_ << msg.GetString();
+  }
+
+  // Constructs a Message from a C-string.
+  explicit Message(const char* str) : ss_(new ::std::stringstream) {
+    *ss_ << str;
+  }
+
+  // Streams a non-pointer value to this object.
+  template <typename T>
+  inline Message& operator <<(const T& val) {
+    // Some libraries overload << for STL containers.  These
+    // overloads are defined in the global namespace instead of ::std.
+    //
+    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
+    // overloads are visible in either the std namespace or the global
+    // namespace, but not other namespaces, including the testing
+    // namespace which Google Test's Message class is in.
+    //
+    // To allow STL containers (and other types that has a << operator
+    // defined in the global namespace) to be used in Google Test
+    // assertions, testing::Message must access the custom << operator
+    // from the global namespace.  With this using declaration,
+    // overloads of << defined in the global namespace and those
+    // visible via Koenig lookup are both exposed in this function.
+    using ::operator <<;
+    *ss_ << val;
+    return *this;
+  }
+
+  // Streams a pointer value to this object.
+  //
+  // This function is an overload of the previous one.  When you
+  // stream a pointer to a Message, this definition will be used as it
+  // is more specialized.  (The C++ Standard, section
+  // [temp.func.order].)  If you stream a non-pointer, then the
+  // previous definition will be used.
+  //
+  // The reason for this overload is that streaming a NULL pointer to
+  // ostream is undefined behavior.  Depending on the compiler, you
+  // may get "0", "(nil)", "(null)", or an access violation.  To
+  // ensure consistent result across compilers, we always treat NULL
+  // as "(null)".
+  template <typename T>
+  inline Message& operator <<(T* const& pointer) {  // NOLINT
+    if (pointer == nullptr) {
+      *ss_ << "(null)";
+    } else {
+      *ss_ << pointer;
+    }
+    return *this;
+  }
+
+  // Since the basic IO manipulators are overloaded for both narrow
+  // and wide streams, we have to provide this specialized definition
+  // of operator <<, even though its body is the same as the
+  // templatized version above.  Without this definition, streaming
+  // endl or other basic IO manipulators to Message will confuse the
+  // compiler.
+  Message& operator <<(BasicNarrowIoManip val) {
+    *ss_ << val;
+    return *this;
+  }
+
+  // Instead of 1/0, we want to see true/false for bool values.
+  Message& operator <<(bool b) {
+    return *this << (b ? "true" : "false");
+  }
+
+  // These two overloads allow streaming a wide C string to a Message
+  // using the UTF-8 encoding.
+  Message& operator <<(const wchar_t* wide_c_str);
+  Message& operator <<(wchar_t* wide_c_str);
+
+#if GTEST_HAS_STD_WSTRING
+  // Converts the given wide string to a narrow string using the UTF-8
+  // encoding, and streams the result to this Message object.
+  Message& operator <<(const ::std::wstring& wstr);
+#endif  // GTEST_HAS_STD_WSTRING
+
+  // Gets the text streamed to this object so far as an std::string.
+  // Each '\0' character in the buffer is replaced with "\\0".
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  std::string GetString() const;
+
+ private:
+  // We'll hold the text streamed to this object here.
+  const std::unique_ptr< ::std::stringstream> ss_;
+
+  // We declare (but don't implement) this to prevent the compiler
+  // from implementing the assignment operator.
+  void operator=(const Message&);
+};
+
+// Streams a Message to an ostream.
+inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
+  return os << sb.GetString();
+}
+
+namespace internal {
+
+// Converts a streamable value to an std::string.  A NULL pointer is
+// converted to "(null)".  When the input value is a ::string,
+// ::std::string, ::wstring, or ::std::wstring object, each NUL
+// character in it is replaced with "\\0".
+template <typename T>
+std::string StreamableToString(const T& streamable) {
+  return (Message() << streamable).GetString();
+}
+
+}  // namespace internal
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
diff --git a/tools/gtest_lib/include/gtest/gtest-param-test.h b/tools/gtest_lib/include/gtest/gtest-param-test.h
new file mode 100644
index 0000000000000000000000000000000000000000..96c1c72254f28e5cd8c13b17219c652773804777
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest-param-test.h
@@ -0,0 +1,510 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Macros and functions for implementing parameterized tests
+// in Google C++ Testing and Mocking Framework (Google Test)
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+
+// Value-parameterized tests allow you to test your code with different
+// parameters without writing multiple copies of the same test.
+//
+// Here is how you use value-parameterized tests:
+
+#if 0
+
+// To write value-parameterized tests, first you should define a fixture
+// class. It is usually derived from testing::TestWithParam<T> (see below for
+// another inheritance scheme that's sometimes useful in more complicated
+// class hierarchies), where the type of your parameter values.
+// TestWithParam<T> is itself derived from testing::Test. T can be any
+// copyable type. If it's a raw pointer, you are responsible for managing the
+// lifespan of the pointed values.
+
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual class fixture members here.
+};
+
+// Then, use the TEST_P macro to define as many parameterized tests
+// for this fixture as you want. The _P suffix is for "parameterized"
+// or "pattern", whichever you prefer to think.
+
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+
+// Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test
+// case with any set of parameters you want. Google Test defines a number
+// of functions for generating test parameters. They return what we call
+// (surprise!) parameter generators. Here is a summary of them, which
+// are all in the testing namespace:
+//
+//
+//  Range(begin, end [, step]) - Yields values {begin, begin+step,
+//                               begin+step+step, ...}. The values do not
+//                               include end. step defaults to 1.
+//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
+//  ValuesIn(container)        - Yields values from a C-style array, an STL
+//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
+//  Bool()                     - Yields sequence {false, true}.
+//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
+//                               for the math savvy) of the values generated
+//                               by the N generators.
+//
+// For more details, see comments at the definitions of these functions below
+// in this file.
+//
+// The following statement will instantiate tests from the FooTest test suite
+// each with parameter values "meeny", "miny", and "moe".
+
+INSTANTIATE_TEST_SUITE_P(InstantiationName,
+                         FooTest,
+                         Values("meeny", "miny", "moe"));
+
+// To distinguish different instances of the pattern, (yes, you
+// can instantiate it more than once) the first argument to the
+// INSTANTIATE_TEST_SUITE_P macro is a prefix that will be added to the
+// actual test suite name. Remember to pick unique prefixes for different
+// instantiations. The tests from the instantiation above will have
+// these names:
+//
+//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
+//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
+//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
+//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
+//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
+//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
+//
+// You can use these names in --gtest_filter.
+//
+// This statement will instantiate all tests from FooTest again, each
+// with parameter values "cat" and "dog":
+
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
+
+// The tests from the instantiation above will have these names:
+//
+//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
+//
+// Please note that INSTANTIATE_TEST_SUITE_P will instantiate all tests
+// in the given test suite, whether their definitions come before or
+// AFTER the INSTANTIATE_TEST_SUITE_P statement.
+//
+// Please also note that generator expressions (including parameters to the
+// generators) are evaluated in InitGoogleTest(), after main() has started.
+// This allows the user on one hand, to adjust generator parameters in order
+// to dynamically determine a set of tests to run and on the other hand,
+// give the user a chance to inspect the generated tests with Google Test
+// reflection API before RUN_ALL_TESTS() is executed.
+//
+// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
+// for more examples.
+//
+// In the future, we plan to publish the API for defining new parameter
+// generators. But for now this interface remains part of the internal
+// implementation and is subject to change.
+//
+//
+// A parameterized test fixture must be derived from testing::Test and from
+// testing::WithParamInterface<T>, where T is the type of the parameter
+// values. Inheriting from TestWithParam<T> satisfies that requirement because
+// TestWithParam<T> inherits from both Test and WithParamInterface. In more
+// complicated hierarchies, however, it is occasionally useful to inherit
+// separately from Test and WithParamInterface. For example:
+
+class BaseTest : public ::testing::Test {
+  // You can inherit all the usual members for a non-parameterized test
+  // fixture here.
+};
+
+class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
+  // The usual test fixture members go here too.
+};
+
+TEST_F(BaseTest, HasFoo) {
+  // This is an ordinary non-parameterized test.
+}
+
+TEST_P(DerivedTest, DoesBlah) {
+  // GetParam works just the same here as if you inherit from TestWithParam.
+  EXPECT_TRUE(foo.Blah(GetParam()));
+}
+
+#endif  // 0
+
+#include <iterator>
+#include <utility>
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-param-util.h"
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+
+// Functions producing parameter generators.
+//
+// Google Test uses these generators to produce parameters for value-
+// parameterized tests. When a parameterized test suite is instantiated
+// with a particular generator, Google Test creates and runs tests
+// for each element in the sequence produced by the generator.
+//
+// In the following sample, tests from test suite FooTest are instantiated
+// each three times with parameter values 3, 5, and 8:
+//
+// class FooTest : public TestWithParam<int> { ... };
+//
+// TEST_P(FooTest, TestThis) {
+// }
+// TEST_P(FooTest, TestThat) {
+// }
+// INSTANTIATE_TEST_SUITE_P(TestSequence, FooTest, Values(3, 5, 8));
+//
+
+// Range() returns generators providing sequences of values in a range.
+//
+// Synopsis:
+// Range(start, end)
+//   - returns a generator producing a sequence of values {start, start+1,
+//     start+2, ..., }.
+// Range(start, end, step)
+//   - returns a generator producing a sequence of values {start, start+step,
+//     start+step+step, ..., }.
+// Notes:
+//   * The generated sequences never include end. For example, Range(1, 5)
+//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
+//     returns a generator producing {1, 3, 5, 7}.
+//   * start and end must have the same type. That type may be any integral or
+//     floating-point type or a user defined type satisfying these conditions:
+//     * It must be assignable (have operator=() defined).
+//     * It must have operator+() (operator+(int-compatible type) for
+//       two-operand version).
+//     * It must have operator<() defined.
+//     Elements in the resulting sequences will also have that type.
+//   * Condition start < end must be satisfied in order for resulting sequences
+//     to contain any elements.
+//
+template <typename T, typename IncrementT>
+internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
+  return internal::ParamGenerator<T>(
+      new internal::RangeGenerator<T, IncrementT>(start, end, step));
+}
+
+template <typename T>
+internal::ParamGenerator<T> Range(T start, T end) {
+  return Range(start, end, 1);
+}
+
+// ValuesIn() function allows generation of tests with parameters coming from
+// a container.
+//
+// Synopsis:
+// ValuesIn(const T (&array)[N])
+//   - returns a generator producing sequences with elements from
+//     a C-style array.
+// ValuesIn(const Container& container)
+//   - returns a generator producing sequences with elements from
+//     an STL-style container.
+// ValuesIn(Iterator begin, Iterator end)
+//   - returns a generator producing sequences with elements from
+//     a range [begin, end) defined by a pair of STL-style iterators. These
+//     iterators can also be plain C pointers.
+//
+// Please note that ValuesIn copies the values from the containers
+// passed in and keeps them to generate tests in RUN_ALL_TESTS().
+//
+// Examples:
+//
+// This instantiates tests from test suite StringTest
+// each with C-string values of "foo", "bar", and "baz":
+//
+// const char* strings[] = {"foo", "bar", "baz"};
+// INSTANTIATE_TEST_SUITE_P(StringSequence, StringTest, ValuesIn(strings));
+//
+// This instantiates tests from test suite StlStringTest
+// each with STL strings with values "a" and "b":
+//
+// ::std::vector< ::std::string> GetParameterStrings() {
+//   ::std::vector< ::std::string> v;
+//   v.push_back("a");
+//   v.push_back("b");
+//   return v;
+// }
+//
+// INSTANTIATE_TEST_SUITE_P(CharSequence,
+//                          StlStringTest,
+//                          ValuesIn(GetParameterStrings()));
+//
+//
+// This will also instantiate tests from CharTest
+// each with parameter values 'a' and 'b':
+//
+// ::std::list<char> GetParameterChars() {
+//   ::std::list<char> list;
+//   list.push_back('a');
+//   list.push_back('b');
+//   return list;
+// }
+// ::std::list<char> l = GetParameterChars();
+// INSTANTIATE_TEST_SUITE_P(CharSequence2,
+//                          CharTest,
+//                          ValuesIn(l.begin(), l.end()));
+//
+template <typename ForwardIterator>
+internal::ParamGenerator<
+    typename std::iterator_traits<ForwardIterator>::value_type>
+ValuesIn(ForwardIterator begin, ForwardIterator end) {
+  typedef typename std::iterator_traits<ForwardIterator>::value_type ParamType;
+  return internal::ParamGenerator<ParamType>(
+      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
+}
+
+template <typename T, size_t N>
+internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
+  return ValuesIn(array, array + N);
+}
+
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container) {
+  return ValuesIn(container.begin(), container.end());
+}
+
+// Values() allows generating tests from explicitly specified list of
+// parameters.
+//
+// Synopsis:
+// Values(T v1, T v2, ..., T vN)
+//   - returns a generator producing sequences with elements v1, v2, ..., vN.
+//
+// For example, this instantiates tests from test suite BarTest each
+// with values "one", "two", and "three":
+//
+// INSTANTIATE_TEST_SUITE_P(NumSequence,
+//                          BarTest,
+//                          Values("one", "two", "three"));
+//
+// This instantiates tests from test suite BazTest each with values 1, 2, 3.5.
+// The exact type of values will depend on the type of parameter in BazTest.
+//
+// INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
+//
+//
+template <typename... T>
+internal::ValueArray<T...> Values(T... v) {
+  return internal::ValueArray<T...>(std::move(v)...);
+}
+
+// Bool() allows generating tests with parameters in a set of (false, true).
+//
+// Synopsis:
+// Bool()
+//   - returns a generator producing sequences with elements {false, true}.
+//
+// It is useful when testing code that depends on Boolean flags. Combinations
+// of multiple flags can be tested when several Bool()'s are combined using
+// Combine() function.
+//
+// In the following example all tests in the test suite FlagDependentTest
+// will be instantiated twice with parameters false and true.
+//
+// class FlagDependentTest : public testing::TestWithParam<bool> {
+//   virtual void SetUp() {
+//     external_flag = GetParam();
+//   }
+// }
+// INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool());
+//
+inline internal::ParamGenerator<bool> Bool() {
+  return Values(false, true);
+}
+
+// Combine() allows the user to combine two or more sequences to produce
+// values of a Cartesian product of those sequences' elements.
+//
+// Synopsis:
+// Combine(gen1, gen2, ..., genN)
+//   - returns a generator producing sequences with elements coming from
+//     the Cartesian product of elements from the sequences generated by
+//     gen1, gen2, ..., genN. The sequence elements will have a type of
+//     std::tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
+//     of elements from sequences produces by gen1, gen2, ..., genN.
+//
+// Example:
+//
+// This will instantiate tests in test suite AnimalTest each one with
+// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
+// tuple("dog", BLACK), and tuple("dog", WHITE):
+//
+// enum Color { BLACK, GRAY, WHITE };
+// class AnimalTest
+//     : public testing::TestWithParam<std::tuple<const char*, Color> > {...};
+//
+// TEST_P(AnimalTest, AnimalLooksNice) {...}
+//
+// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest,
+//                          Combine(Values("cat", "dog"),
+//                                  Values(BLACK, WHITE)));
+//
+// This will instantiate tests in FlagDependentTest with all variations of two
+// Boolean flags:
+//
+// class FlagDependentTest
+//     : public testing::TestWithParam<std::tuple<bool, bool> > {
+//   virtual void SetUp() {
+//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
+//     std::tie(external_flag_1, external_flag_2) = GetParam();
+//   }
+// };
+//
+// TEST_P(FlagDependentTest, TestFeature1) {
+//   // Test your code using external_flag_1 and external_flag_2 here.
+// }
+// INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest,
+//                          Combine(Bool(), Bool()));
+//
+template <typename... Generator>
+internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
+  return internal::CartesianProductHolder<Generator...>(g...);
+}
+
+#define TEST_P(test_suite_name, test_name)                                     \
+  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
+      : public test_suite_name {                                               \
+   public:                                                                     \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                    \
+    void TestBody() override;                                                  \
+                                                                               \
+   private:                                                                    \
+    static int AddToRegistry() {                                               \
+      ::testing::UnitTest::GetInstance()                                       \
+          ->parameterized_test_registry()                                      \
+          .GetTestSuitePatternHolder<test_suite_name>(                         \
+              GTEST_STRINGIFY_(test_suite_name),                               \
+              ::testing::internal::CodeLocation(__FILE__, __LINE__))           \
+          ->AddTestPattern(                                                    \
+              GTEST_STRINGIFY_(test_suite_name), GTEST_STRINGIFY_(test_name),  \
+              new ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \
+                  test_suite_name, test_name)>(),                              \
+              ::testing::internal::CodeLocation(__FILE__, __LINE__));          \
+      return 0;                                                                \
+    }                                                                          \
+    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,    \
+                                                           test_name));        \
+  };                                                                           \
+  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
+                             test_name)::gtest_registering_dummy_ =            \
+      GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::AddToRegistry();     \
+  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
+
+// The last argument to INSTANTIATE_TEST_SUITE_P allows the user to specify
+// generator and an optional function or functor that generates custom test name
+// suffixes based on the test parameters. Such a function or functor should
+// accept one argument of type testing::TestParamInfo<class ParamType>, and
+// return std::string.
+//
+// testing::PrintToStringParamName is a builtin test suffix generator that
+// returns the value of testing::PrintToString(GetParam()).
+//
+// Note: test names must be non-empty, unique, and may only contain ASCII
+// alphanumeric characters or underscore. Because PrintToString adds quotes
+// to std::string and C strings, it won't work for these types.
+
+#define GTEST_EXPAND_(arg) arg
+#define GTEST_GET_FIRST_(first, ...) first
+#define GTEST_GET_SECOND_(first, second, ...) second
+
+#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)                \
+  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>      \
+      gtest_##prefix##test_suite_name##_EvalGenerator_() {                    \
+    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));        \
+  }                                                                           \
+  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(   \
+      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {     \
+    if (::testing::internal::AlwaysFalse()) {                                 \
+      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(      \
+          __VA_ARGS__,                                                        \
+          ::testing::internal::DefaultParamName<test_suite_name::ParamType>,  \
+          DUMMY_PARAM_)));                                                    \
+      auto t = std::make_tuple(__VA_ARGS__);                                  \
+      static_assert(std::tuple_size<decltype(t)>::value <= 2,                 \
+                    "Too Many Args!");                                        \
+    }                                                                         \
+    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                 \
+        __VA_ARGS__,                                                          \
+        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,    \
+        DUMMY_PARAM_))))(info);                                               \
+  }                                                                           \
+  static int gtest_##prefix##test_suite_name##_dummy_                         \
+      GTEST_ATTRIBUTE_UNUSED_ =                                               \
+          ::testing::UnitTest::GetInstance()                                  \
+              ->parameterized_test_registry()                                 \
+              .GetTestSuitePatternHolder<test_suite_name>(                    \
+                  GTEST_STRINGIFY_(test_suite_name),                          \
+                  ::testing::internal::CodeLocation(__FILE__, __LINE__))      \
+              ->AddTestSuiteInstantiation(                                    \
+                  GTEST_STRINGIFY_(prefix),                                   \
+                  &gtest_##prefix##test_suite_name##_EvalGenerator_,          \
+                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,       \
+                  __FILE__, __LINE__)
+
+
+// Allow Marking a Parameterized test class as not needing to be instantiated.
+#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                   \
+  namespace gtest_do_not_use_outside_namespace_scope {}                   \
+  static const ::testing::internal::MarkAsIgnored gtest_allow_ignore_##T( \
+      GTEST_STRINGIFY_(T))
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define INSTANTIATE_TEST_CASE_P                                            \
+  static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \
+                "");                                                       \
+  INSTANTIATE_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
diff --git a/tools/gtest_lib/include/gtest/gtest-printers.h b/tools/gtest_lib/include/gtest/gtest-printers.h
new file mode 100644
index 0000000000000000000000000000000000000000..b097e9886df6bd5a2ac674279cffbc716ffa779c
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest-printers.h
@@ -0,0 +1,1050 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Test - The Google C++ Testing and Mocking Framework
+//
+// This file implements a universal value printer that can print a
+// value of any type T:
+//
+//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
+//
+// A user can teach this function how to print a class type T by
+// defining either operator<<() or PrintTo() in the namespace that
+// defines T.  More specifically, the FIRST defined function in the
+// following list will be used (assuming T is defined in namespace
+// foo):
+//
+//   1. foo::PrintTo(const T&, ostream*)
+//   2. operator<<(ostream&, const T&) defined in either foo or the
+//      global namespace.
+//
+// However if T is an STL-style container then it is printed element-wise
+// unless foo::PrintTo(const T&, ostream*) is defined. Note that
+// operator<<() is ignored for container types.
+//
+// If none of the above is defined, it will print the debug string of
+// the value if it is a protocol buffer, or print the raw bytes in the
+// value otherwise.
+//
+// To aid debugging: when T is a reference type, the address of the
+// value is also printed; when T is a (const) char pointer, both the
+// pointer value and the NUL-terminated string it points to are
+// printed.
+//
+// We also provide some convenient wrappers:
+//
+//   // Prints a value to a string.  For a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   std::string ::testing::PrintToString(const T& value);
+//
+//   // Prints a value tersely: for a reference type, the referenced
+//   // value (but not the address) is printed; for a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
+//
+//   // Prints value using the type inferred by the compiler.  The difference
+//   // from UniversalTersePrint() is that this function prints both the
+//   // pointer and the NUL-terminated string for a (const or not) char pointer.
+//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
+//
+//   // Prints the fields of a tuple tersely to a string vector, one
+//   // element for each field. Tuple support must be enabled in
+//   // gtest-port.h.
+//   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
+//       const Tuple& value);
+//
+// Known limitation:
+//
+// The print primitives print the elements of an STL-style container
+// using the compiler-inferred type of *iter where iter is a
+// const_iterator of the container.  When const_iterator is an input
+// iterator but not a forward iterator, this inferred type may not
+// match value_type, and the print output may be incorrect.  In
+// practice, this is rarely a problem as for most containers
+// const_iterator is a forward iterator.  We'll fix this if there's an
+// actual need for it.  Note that this fix cannot rely on value_type
+// being defined as many user-defined container types don't have
+// value_type.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+
+#include <functional>
+#include <memory>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+
+// Definitions in the internal* namespaces are subject to change without notice.
+// DO NOT USE THEM IN USER CODE!
+namespace internal {
+
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os);
+
+// Used to print an STL-style container when the user doesn't define
+// a PrintTo() for it.
+struct ContainerPrinter {
+  template <typename T,
+            typename = typename std::enable_if<
+                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
+                !IsRecursiveContainer<T>::value>::type>
+  static void PrintValue(const T& container, std::ostream* os) {
+    const size_t kMaxCount = 32;  // The maximum number of elements to print.
+    *os << '{';
+    size_t count = 0;
+    for (auto&& elem : container) {
+      if (count > 0) {
+        *os << ',';
+        if (count == kMaxCount) {  // Enough has been printed.
+          *os << " ...";
+          break;
+        }
+      }
+      *os << ' ';
+      // We cannot call PrintTo(elem, os) here as PrintTo() doesn't
+      // handle `elem` being a native array.
+      internal::UniversalPrint(elem, os);
+      ++count;
+    }
+
+    if (count > 0) {
+      *os << ' ';
+    }
+    *os << '}';
+  }
+};
+
+// Used to print a pointer that is neither a char pointer nor a member
+// pointer, when the user doesn't define PrintTo() for it.  (A member
+// variable pointer or member function pointer doesn't really point to
+// a location in the address space.  Their representation is
+// implementation-defined.  Therefore they will be printed as raw
+// bytes.)
+struct FunctionPointerPrinter {
+  template <typename T, typename = typename std::enable_if<
+                            std::is_function<T>::value>::type>
+  static void PrintValue(T* p, ::std::ostream* os) {
+    if (p == nullptr) {
+      *os << "NULL";
+    } else {
+      // T is a function type, so '*os << p' doesn't do what we want
+      // (it just prints p as bool).  We want to print p as a const
+      // void*.
+      *os << reinterpret_cast<const void*>(p);
+    }
+  }
+};
+
+struct PointerPrinter {
+  template <typename T>
+  static void PrintValue(T* p, ::std::ostream* os) {
+    if (p == nullptr) {
+      *os << "NULL";
+    } else {
+      // T is not a function type.  We just call << to print p,
+      // relying on ADL to pick up user-defined << for their pointer
+      // types, if any.
+      *os << p;
+    }
+  }
+};
+
+namespace internal_stream_operator_without_lexical_name_lookup {
+
+// The presence of an operator<< here will terminate lexical scope lookup
+// straight away (even though it cannot be a match because of its argument
+// types). Thus, the two operator<< calls in StreamPrinter will find only ADL
+// candidates.
+struct LookupBlocker {};
+void operator<<(LookupBlocker, LookupBlocker);
+
+struct StreamPrinter {
+  template <typename T,
+            // Don't accept member pointers here. We'd print them via implicit
+            // conversion to bool, which isn't useful.
+            typename = typename std::enable_if<
+                !std::is_member_pointer<T>::value>::type,
+            // Only accept types for which we can find a streaming operator via
+            // ADL (possibly involving implicit conversions).
+            typename = decltype(std::declval<std::ostream&>()
+                                << std::declval<const T&>())>
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    // Call streaming operator found by ADL, possibly with implicit conversions
+    // of the arguments.
+    *os << value;
+  }
+};
+
+}  // namespace internal_stream_operator_without_lexical_name_lookup
+
+struct ProtobufPrinter {
+  // We print a protobuf using its ShortDebugString() when the string
+  // doesn't exceed this many characters; otherwise we print it using
+  // DebugString() for better readability.
+  static const size_t kProtobufOneLinerMaxLength = 50;
+
+  template <typename T,
+            typename = typename std::enable_if<
+                internal::HasDebugStringAndShortDebugString<T>::value>::type>
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    std::string pretty_str = value.ShortDebugString();
+    if (pretty_str.length() > kProtobufOneLinerMaxLength) {
+      pretty_str = "\n" + value.DebugString();
+    }
+    *os << ("<" + pretty_str + ">");
+  }
+};
+
+struct ConvertibleToIntegerPrinter {
+  // Since T has no << operator or PrintTo() but can be implicitly
+  // converted to BiggestInt, we print it as a BiggestInt.
+  //
+  // Most likely T is an enum type (either named or unnamed), in which
+  // case printing it as an integer is the desired behavior.  In case
+  // T is not an enum, printing it as an integer is the best we can do
+  // given that it has no user-defined printer.
+  static void PrintValue(internal::BiggestInt value, ::std::ostream* os) {
+    *os << value;
+  }
+};
+
+struct ConvertibleToStringViewPrinter {
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  static void PrintValue(internal::StringView value, ::std::ostream* os) {
+    internal::UniversalPrint(value, os);
+  }
+#endif
+};
+
+
+// Prints the given number of bytes in the given object to the given
+// ostream.
+GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
+                                     size_t count,
+                                     ::std::ostream* os);
+struct RawBytesPrinter {
+  // SFINAE on `sizeof` to make sure we have a complete type.
+  template <typename T, size_t = sizeof(T)>
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    PrintBytesInObjectTo(
+        static_cast<const unsigned char*>(
+            // Load bearing cast to void* to support iOS
+            reinterpret_cast<const void*>(std::addressof(value))),
+        sizeof(value), os);
+  }
+};
+
+struct FallbackPrinter {
+  template <typename T>
+  static void PrintValue(const T&, ::std::ostream* os) {
+    *os << "(incomplete type)";
+  }
+};
+
+// Try every printer in order and return the first one that works.
+template <typename T, typename E, typename Printer, typename... Printers>
+struct FindFirstPrinter : FindFirstPrinter<T, E, Printers...> {};
+
+template <typename T, typename Printer, typename... Printers>
+struct FindFirstPrinter<
+    T, decltype(Printer::PrintValue(std::declval<const T&>(), nullptr)),
+    Printer, Printers...> {
+  using type = Printer;
+};
+
+// Select the best printer in the following order:
+//  - Print containers (they have begin/end/etc).
+//  - Print function pointers.
+//  - Print object pointers.
+//  - Use the stream operator, if available.
+//  - Print protocol buffers.
+//  - Print types convertible to BiggestInt.
+//  - Print types convertible to StringView, if available.
+//  - Fallback to printing the raw bytes of the object.
+template <typename T>
+void PrintWithFallback(const T& value, ::std::ostream* os) {
+  using Printer = typename FindFirstPrinter<
+      T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
+      internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
+      ProtobufPrinter, ConvertibleToIntegerPrinter,
+      ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type;
+  Printer::PrintValue(value, os);
+}
+
+// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
+// value of type ToPrint that is an operand of a comparison assertion
+// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
+// the comparison, and is used to help determine the best way to
+// format the value.  In particular, when the value is a C string
+// (char pointer) and the other operand is an STL string object, we
+// want to format the C string as a string, since we know it is
+// compared by value with the string object.  If the value is a char
+// pointer but the other operand is not an STL string object, we don't
+// know whether the pointer is supposed to point to a NUL-terminated
+// string, and thus want to print it as a pointer to be safe.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// The default case.
+template <typename ToPrint, typename OtherOperand>
+class FormatForComparison {
+ public:
+  static ::std::string Format(const ToPrint& value) {
+    return ::testing::PrintToString(value);
+  }
+};
+
+// Array.
+template <typename ToPrint, size_t N, typename OtherOperand>
+class FormatForComparison<ToPrint[N], OtherOperand> {
+ public:
+  static ::std::string Format(const ToPrint* value) {
+    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
+  }
+};
+
+// By default, print C string as pointers to be safe, as we don't know
+// whether they actually point to a NUL-terminated string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
+  template <typename OtherOperand>                                      \
+  class FormatForComparison<CharType*, OtherOperand> {                  \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(static_cast<const void*>(value)); \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
+#ifdef __cpp_lib_char8_t
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t);
+#endif
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char16_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char16_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char32_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
+
+// If a C string is compared with an STL string object, we know it's meant
+// to point to a NUL-terminated string, and thus can print it as a string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
+  template <>                                                           \
+  class FormatForComparison<CharType*, OtherStringType> {               \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(value);                           \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
+#ifdef __cpp_char8_t
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);
+#endif
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char32_t, ::std::u32string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char32_t, ::std::u32string);
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
+#endif
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
+
+// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
+// operand to be used in a failure message.  The type (but not value)
+// of the other operand may affect the format.  This allows us to
+// print a char* as a raw pointer when it is compared against another
+// char* or void*, and print it as a C string when it is compared
+// against an std::string object, for example.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename T1, typename T2>
+std::string FormatForComparisonFailureMessage(
+    const T1& value, const T2& /* other_operand */) {
+  return FormatForComparison<T1, T2>::Format(value);
+}
+
+// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
+// value to the given ostream.  The caller must ensure that
+// 'ostream_ptr' is not NULL, or the behavior is undefined.
+//
+// We define UniversalPrinter as a class template (as opposed to a
+// function template), as we need to partially specialize it for
+// reference types, which cannot be done with function templates.
+template <typename T>
+class UniversalPrinter;
+
+// Prints the given value using the << operator if it has one;
+// otherwise prints the bytes in it.  This is what
+// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
+// or overloaded for type T.
+//
+// A user can override this behavior for a class type Foo by defining
+// an overload of PrintTo() in the namespace where Foo is defined.  We
+// give the user this option as sometimes defining a << operator for
+// Foo is not desirable (e.g. the coding style may prevent doing it,
+// or there is already a << operator but it doesn't do what the user
+// wants).
+template <typename T>
+void PrintTo(const T& value, ::std::ostream* os) {
+  internal::PrintWithFallback(value, os);
+}
+
+// The following list of PrintTo() overloads tells
+// UniversalPrinter<T>::Print() how to print standard types (built-in
+// types, strings, plain arrays, and pointers).
+
+// Overloads for various char types.
+GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
+GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
+inline void PrintTo(char c, ::std::ostream* os) {
+  // When printing a plain char, we always treat it as unsigned.  This
+  // way, the output won't be affected by whether the compiler thinks
+  // char is signed or not.
+  PrintTo(static_cast<unsigned char>(c), os);
+}
+
+// Overloads for other simple built-in types.
+inline void PrintTo(bool x, ::std::ostream* os) {
+  *os << (x ? "true" : "false");
+}
+
+// Overload for wchar_t type.
+// Prints a wchar_t as a symbol if it is printable or as its internal
+// code otherwise and also as its decimal code (except for L'\0').
+// The L'\0' char is printed as "L'\\0'". The decimal code is printed
+// as signed integer when wchar_t is implemented by the compiler
+// as a signed type and is printed as an unsigned integer when wchar_t
+// is implemented as an unsigned type.
+GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
+
+GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);
+inline void PrintTo(char16_t c, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<char32_t>(c), os);
+}
+#ifdef __cpp_char8_t
+inline void PrintTo(char8_t c, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<char32_t>(c), os);
+}
+#endif
+
+// gcc/clang __{u,}int128_t
+#if defined(__SIZEOF_INT128__)
+GTEST_API_ void PrintTo(__uint128_t v, ::std::ostream* os);
+GTEST_API_ void PrintTo(__int128_t v, ::std::ostream* os);
+#endif  // __SIZEOF_INT128__
+
+// Overloads for C strings.
+GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
+inline void PrintTo(char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char*>(s), os);
+}
+
+// signed/unsigned char is often used for representing binary data, so
+// we print pointers to it as void* to be safe.
+inline void PrintTo(const signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+#ifdef __cpp_char8_t
+// Overloads for u8 strings.
+GTEST_API_ void PrintTo(const char8_t* s, ::std::ostream* os);
+inline void PrintTo(char8_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char8_t*>(s), os);
+}
+#endif
+// Overloads for u16 strings.
+GTEST_API_ void PrintTo(const char16_t* s, ::std::ostream* os);
+inline void PrintTo(char16_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char16_t*>(s), os);
+}
+// Overloads for u32 strings.
+GTEST_API_ void PrintTo(const char32_t* s, ::std::ostream* os);
+inline void PrintTo(char32_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char32_t*>(s), os);
+}
+
+// MSVC can be configured to define wchar_t as a typedef of unsigned
+// short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
+// type.  When wchar_t is a typedef, defining an overload for const
+// wchar_t* would cause unsigned short* be printed as a wide string,
+// possibly causing invalid memory accesses.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+// Overloads for wide C strings
+GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
+inline void PrintTo(wchar_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
+}
+#endif
+
+// Overload for C arrays.  Multi-dimensional arrays are printed
+// properly.
+
+// Prints the given number of elements in an array, without printing
+// the curly braces.
+template <typename T>
+void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
+  UniversalPrint(a[0], os);
+  for (size_t i = 1; i != count; i++) {
+    *os << ", ";
+    UniversalPrint(a[i], os);
+  }
+}
+
+// Overloads for ::std::string.
+GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
+inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
+  PrintStringTo(s, os);
+}
+
+// Overloads for ::std::u8string
+#ifdef __cpp_char8_t
+GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);
+inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
+  PrintU8StringTo(s, os);
+}
+#endif
+
+// Overloads for ::std::u16string
+GTEST_API_ void PrintU16StringTo(const ::std::u16string& s, ::std::ostream* os);
+inline void PrintTo(const ::std::u16string& s, ::std::ostream* os) {
+  PrintU16StringTo(s, os);
+}
+
+// Overloads for ::std::u32string
+GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os);
+inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {
+  PrintU32StringTo(s, os);
+}
+
+// Overloads for ::std::wstring.
+#if GTEST_HAS_STD_WSTRING
+GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
+inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
+  PrintWideStringTo(s, os);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// Overload for internal::StringView.
+inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
+  PrintTo(::std::string(sp), os);
+}
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
+
+#if GTEST_HAS_RTTI
+inline void PrintTo(const std::type_info& info, std::ostream* os) {
+  *os << internal::GetTypeName(info);
+}
+#endif  // GTEST_HAS_RTTI
+
+template <typename T>
+void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
+  UniversalPrinter<T&>::Print(ref.get(), os);
+}
+
+inline const void* VoidifyPointer(const void* p) { return p; }
+inline const void* VoidifyPointer(volatile const void* p) {
+  return const_cast<const void*>(p);
+}
+
+template <typename T, typename Ptr>
+void PrintSmartPointer(const Ptr& ptr, std::ostream* os, char) {
+  if (ptr == nullptr) {
+    *os << "(nullptr)";
+  } else {
+    // We can't print the value. Just print the pointer..
+    *os << "(" << (VoidifyPointer)(ptr.get()) << ")";
+  }
+}
+template <typename T, typename Ptr,
+          typename = typename std::enable_if<!std::is_void<T>::value &&
+                                             !std::is_array<T>::value>::type>
+void PrintSmartPointer(const Ptr& ptr, std::ostream* os, int) {
+  if (ptr == nullptr) {
+    *os << "(nullptr)";
+  } else {
+    *os << "(ptr = " << (VoidifyPointer)(ptr.get()) << ", value = ";
+    UniversalPrinter<T>::Print(*ptr, os);
+    *os << ")";
+  }
+}
+
+template <typename T, typename D>
+void PrintTo(const std::unique_ptr<T, D>& ptr, std::ostream* os) {
+  (PrintSmartPointer<T>)(ptr, os, 0);
+}
+
+template <typename T>
+void PrintTo(const std::shared_ptr<T>& ptr, std::ostream* os) {
+  (PrintSmartPointer<T>)(ptr, os, 0);
+}
+
+// Helper function for printing a tuple.  T must be instantiated with
+// a tuple type.
+template <typename T>
+void PrintTupleTo(const T&, std::integral_constant<size_t, 0>,
+                  ::std::ostream*) {}
+
+template <typename T, size_t I>
+void PrintTupleTo(const T& t, std::integral_constant<size_t, I>,
+                  ::std::ostream* os) {
+  PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os);
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (I > 1) {
+    GTEST_INTENTIONAL_CONST_COND_POP_()
+    *os << ", ";
+  }
+  UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
+      std::get<I - 1>(t), os);
+}
+
+template <typename... Types>
+void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
+  *os << "(";
+  PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os);
+  *os << ")";
+}
+
+// Overload for std::pair.
+template <typename T1, typename T2>
+void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
+  *os << '(';
+  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
+  // a reference type.  The same for printing value.second.
+  UniversalPrinter<T1>::Print(value.first, os);
+  *os << ", ";
+  UniversalPrinter<T2>::Print(value.second, os);
+  *os << ')';
+}
+
+// Implements printing a non-reference type T by letting the compiler
+// pick the right overload of PrintTo() for T.
+template <typename T>
+class UniversalPrinter {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  // Note: we deliberately don't call this PrintTo(), as that name
+  // conflicts with ::testing::internal::PrintTo in the body of the
+  // function.
+  static void Print(const T& value, ::std::ostream* os) {
+    // By default, ::testing::internal::PrintTo() is used for printing
+    // the value.
+    //
+    // Thanks to Koenig look-up, if T is a class and has its own
+    // PrintTo() function defined in its namespace, that function will
+    // be visible here.  Since it is more specific than the generic ones
+    // in ::testing::internal, it will be picked by the compiler in the
+    // following statement - exactly what we want.
+    PrintTo(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// Remove any const-qualifiers before passing a type to UniversalPrinter.
+template <typename T>
+class UniversalPrinter<const T> : public UniversalPrinter<T> {};
+
+#if GTEST_INTERNAL_HAS_ANY
+
+// Printer for std::any / absl::any
+
+template <>
+class UniversalPrinter<Any> {
+ public:
+  static void Print(const Any& value, ::std::ostream* os) {
+    if (value.has_value()) {
+      *os << "value of type " << GetTypeName(value);
+    } else {
+      *os << "no value";
+    }
+  }
+
+ private:
+  static std::string GetTypeName(const Any& value) {
+#if GTEST_HAS_RTTI
+    return internal::GetTypeName(value.type());
+#else
+    static_cast<void>(value);  // possibly unused
+    return "<unknown_type>";
+#endif  // GTEST_HAS_RTTI
+  }
+};
+
+#endif  // GTEST_INTERNAL_HAS_ANY
+
+#if GTEST_INTERNAL_HAS_OPTIONAL
+
+// Printer for std::optional / absl::optional
+
+template <typename T>
+class UniversalPrinter<Optional<T>> {
+ public:
+  static void Print(const Optional<T>& value, ::std::ostream* os) {
+    *os << '(';
+    if (!value) {
+      *os << "nullopt";
+    } else {
+      UniversalPrint(*value, os);
+    }
+    *os << ')';
+  }
+};
+
+template <>
+class UniversalPrinter<decltype(Nullopt())> {
+ public:
+  static void Print(decltype(Nullopt()), ::std::ostream* os) {
+    *os << "(nullopt)";
+  }
+};
+
+#endif  // GTEST_INTERNAL_HAS_OPTIONAL
+
+#if GTEST_INTERNAL_HAS_VARIANT
+
+// Printer for std::variant / absl::variant
+
+template <typename... T>
+class UniversalPrinter<Variant<T...>> {
+ public:
+  static void Print(const Variant<T...>& value, ::std::ostream* os) {
+    *os << '(';
+#if GTEST_HAS_ABSL
+    absl::visit(Visitor{os, value.index()}, value);
+#else
+    std::visit(Visitor{os, value.index()}, value);
+#endif  // GTEST_HAS_ABSL
+    *os << ')';
+  }
+
+ private:
+  struct Visitor {
+    template <typename U>
+    void operator()(const U& u) const {
+      *os << "'" << GetTypeName<U>() << "(index = " << index
+          << ")' with value ";
+      UniversalPrint(u, os);
+    }
+    ::std::ostream* os;
+    std::size_t index;
+  };
+};
+
+#endif  // GTEST_INTERNAL_HAS_VARIANT
+
+// UniversalPrintArray(begin, len, os) prints an array of 'len'
+// elements, starting at address 'begin'.
+template <typename T>
+void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
+  if (len == 0) {
+    *os << "{}";
+  } else {
+    *os << "{ ";
+    const size_t kThreshold = 18;
+    const size_t kChunkSize = 8;
+    // If the array has more than kThreshold elements, we'll have to
+    // omit some details by printing only the first and the last
+    // kChunkSize elements.
+    if (len <= kThreshold) {
+      PrintRawArrayTo(begin, len, os);
+    } else {
+      PrintRawArrayTo(begin, kChunkSize, os);
+      *os << ", ..., ";
+      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
+    }
+    *os << " }";
+  }
+}
+// This overload prints a (const) char array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const char* begin, size_t len, ::std::ostream* os);
+
+#ifdef __cpp_char8_t
+// This overload prints a (const) char8_t array compactly.
+GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len,
+                                    ::std::ostream* os);
+#endif
+
+// This overload prints a (const) char16_t array compactly.
+GTEST_API_ void UniversalPrintArray(const char16_t* begin, size_t len,
+                                    ::std::ostream* os);
+
+// This overload prints a (const) char32_t array compactly.
+GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len,
+                                    ::std::ostream* os);
+
+// This overload prints a (const) wchar_t array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const wchar_t* begin, size_t len, ::std::ostream* os);
+
+// Implements printing an array type T[N].
+template <typename T, size_t N>
+class UniversalPrinter<T[N]> {
+ public:
+  // Prints the given array, omitting some elements when there are too
+  // many.
+  static void Print(const T (&a)[N], ::std::ostream* os) {
+    UniversalPrintArray(a, N, os);
+  }
+};
+
+// Implements printing a reference type T&.
+template <typename T>
+class UniversalPrinter<T&> {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  static void Print(const T& value, ::std::ostream* os) {
+    // Prints the address of the value.  We use reinterpret_cast here
+    // as static_cast doesn't compile when T is a function type.
+    *os << "@" << reinterpret_cast<const void*>(&value) << " ";
+
+    // Then prints the value itself.
+    UniversalPrint(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// Prints a value tersely: for a reference type, the referenced value
+// (but not the address) is printed; for a (const) char pointer, the
+// NUL-terminated string (but not the pointer) is printed.
+
+template <typename T>
+class UniversalTersePrinter {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T>
+class UniversalTersePrinter<T&> {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T, size_t N>
+class UniversalTersePrinter<T[N]> {
+ public:
+  static void Print(const T (&value)[N], ::std::ostream* os) {
+    UniversalPrinter<T[N]>::Print(value, os);
+  }
+};
+template <>
+class UniversalTersePrinter<const char*> {
+ public:
+  static void Print(const char* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(std::string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> {
+};
+
+#ifdef __cpp_char8_t
+template <>
+class UniversalTersePrinter<const char8_t*> {
+ public:
+  static void Print(const char8_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::u8string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char8_t*>
+    : public UniversalTersePrinter<const char8_t*> {};
+#endif
+
+template <>
+class UniversalTersePrinter<const char16_t*> {
+ public:
+  static void Print(const char16_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::u16string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char16_t*>
+    : public UniversalTersePrinter<const char16_t*> {};
+
+template <>
+class UniversalTersePrinter<const char32_t*> {
+ public:
+  static void Print(const char32_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::u32string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char32_t*>
+    : public UniversalTersePrinter<const char32_t*> {};
+
+#if GTEST_HAS_STD_WSTRING
+template <>
+class UniversalTersePrinter<const wchar_t*> {
+ public:
+  static void Print(const wchar_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::wstring(str), os);
+    }
+  }
+};
+#endif
+
+template <>
+class UniversalTersePrinter<wchar_t*> {
+ public:
+  static void Print(wchar_t* str, ::std::ostream* os) {
+    UniversalTersePrinter<const wchar_t*>::Print(str, os);
+  }
+};
+
+template <typename T>
+void UniversalTersePrint(const T& value, ::std::ostream* os) {
+  UniversalTersePrinter<T>::Print(value, os);
+}
+
+// Prints a value using the type inferred by the compiler.  The
+// difference between this and UniversalTersePrint() is that for a
+// (const) char pointer, this prints both the pointer and the
+// NUL-terminated string.
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os) {
+  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
+  // UniversalPrinter with T directly.
+  typedef T T1;
+  UniversalPrinter<T1>::Print(value, os);
+}
+
+typedef ::std::vector< ::std::string> Strings;
+
+  // Tersely prints the first N fields of a tuple to a string vector,
+  // one element for each field.
+template <typename Tuple>
+void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,
+                               Strings*) {}
+template <typename Tuple, size_t I>
+void TersePrintPrefixToStrings(const Tuple& t,
+                               std::integral_constant<size_t, I>,
+                               Strings* strings) {
+  TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
+                            strings);
+  ::std::stringstream ss;
+  UniversalTersePrint(std::get<I - 1>(t), &ss);
+  strings->push_back(ss.str());
+}
+
+// Prints the fields of a tuple tersely to a string vector, one
+// element for each field.  See the comment before
+// UniversalTersePrint() for how we define "tersely".
+template <typename Tuple>
+Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
+  Strings result;
+  TersePrintPrefixToStrings(
+      value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(),
+      &result);
+  return result;
+}
+
+}  // namespace internal
+
+template <typename T>
+::std::string PrintToString(const T& value) {
+  ::std::stringstream ss;
+  internal::UniversalTersePrinter<T>::Print(value, &ss);
+  return ss.str();
+}
+
+}  // namespace testing
+
+// Include any custom printer added by the local installation.
+// We must include this header at the end to make sure it can use the
+// declarations from this file.
+#include "gtest/internal/custom/gtest-printers.h"
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
diff --git a/tools/gtest_lib/include/gtest/gtest-spi.h b/tools/gtest_lib/include/gtest/gtest-spi.h
new file mode 100644
index 0000000000000000000000000000000000000000..12c94e4a28daedbe2cfbc234a760db2a9be64228
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest-spi.h
@@ -0,0 +1,235 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Utilities for testing Google Test itself and code that uses Google Test
+// (e.g. frameworks built on top of Google Test).
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+#include "gtest/gtest.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// This helper class can be used to mock out Google Test failure reporting
+// so that we can test Google Test or code that builds on Google Test.
+//
+// An object of this class appends a TestPartResult object to the
+// TestPartResultArray object given in the constructor whenever a Google Test
+// failure is reported. It can either intercept only failures that are
+// generated in the same thread that created this object or it can intercept
+// all generated failures. The scope of this mock object can be controlled with
+// the second argument to the two arguments constructor.
+class GTEST_API_ ScopedFakeTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  // The two possible mocking modes of this object.
+  enum InterceptMode {
+    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
+    INTERCEPT_ALL_THREADS           // Intercepts all failures.
+  };
+
+  // The c'tor sets this object as the test part result reporter used
+  // by Google Test.  The 'result' parameter specifies where to report the
+  // results. This reporter will only catch failures generated in the current
+  // thread. DEPRECATED
+  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
+
+  // Same as above, but you can choose the interception scope of this object.
+  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
+                                   TestPartResultArray* result);
+
+  // The d'tor restores the previous test part result reporter.
+  ~ScopedFakeTestPartResultReporter() override;
+
+  // Appends the TestPartResult object to the TestPartResultArray
+  // received in the constructor.
+  //
+  // This method is from the TestPartResultReporterInterface
+  // interface.
+  void ReportTestPartResult(const TestPartResult& result) override;
+
+ private:
+  void Init();
+
+  const InterceptMode intercept_mode_;
+  TestPartResultReporterInterface* old_reporter_;
+  TestPartResultArray* const result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
+};
+
+namespace internal {
+
+// A helper class for implementing EXPECT_FATAL_FAILURE() and
+// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+class GTEST_API_ SingleFailureChecker {
+ public:
+  // The constructor remembers the arguments.
+  SingleFailureChecker(const TestPartResultArray* results,
+                       TestPartResult::Type type, const std::string& substr);
+  ~SingleFailureChecker();
+ private:
+  const TestPartResultArray* const results_;
+  const TestPartResult::Type type_;
+  const std::string substr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// A set of macros for testing Google Test assertions or code that's expected
+// to generate Google Test fatal failures.  It verifies that the given
+// statement will cause exactly one fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - 'statement' cannot reference local non-static variables or
+//     non-static members of the current object.
+//   - 'statement' cannot return a value.
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
+// gtest_unittest.cc will fail to compile if we do that.
+#define EXPECT_FATAL_FAILURE(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ALL_THREADS, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test non-fatal failures.  It asserts that the given
+// statement will cause exactly one non-fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// 'statement' is allowed to reference local variables and members of
+// the current object.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  If we do that, the code won't compile when the user gives
+// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
+// expands to code containing an unprotected comma.  The
+// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
+// catches that.
+//
+// For the same reason, we have to write
+//   if (::testing::internal::AlwaysTrue()) { statement; }
+// instead of
+//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+// to avoid an MSVC warning on unreachable code.
+#define EXPECT_NONFATAL_FAILURE(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
+          &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
diff --git a/tools/gtest_lib/include/gtest/gtest-test-part.h b/tools/gtest_lib/include/gtest/gtest-test-part.h
new file mode 100644
index 0000000000000000000000000000000000000000..39393b212cfa4eabf3d9e7514b798d20b0278adb
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest-test-part.h
@@ -0,0 +1,186 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+
+#include <iosfwd>
+#include <vector>
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-string.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// A copyable object representing the result of a test part (i.e. an
+// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
+//
+// Don't inherit from TestPartResult as its destructor is not virtual.
+class GTEST_API_ TestPartResult {
+ public:
+  // The possible outcomes of a test part (i.e. an assertion or an
+  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
+  enum Type {
+    kSuccess,          // Succeeded.
+    kNonFatalFailure,  // Failed but the test can continue.
+    kFatalFailure,     // Failed and the test should be terminated.
+    kSkip              // Skipped.
+  };
+
+  // C'tor.  TestPartResult does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestPartResult object.
+  TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
+                 const char* a_message)
+      : type_(a_type),
+        file_name_(a_file_name == nullptr ? "" : a_file_name),
+        line_number_(a_line_number),
+        summary_(ExtractSummary(a_message)),
+        message_(a_message) {}
+
+  // Gets the outcome of the test part.
+  Type type() const { return type_; }
+
+  // Gets the name of the source file where the test part took place, or
+  // NULL if it's unknown.
+  const char* file_name() const {
+    return file_name_.empty() ? nullptr : file_name_.c_str();
+  }
+
+  // Gets the line in the source file where the test part took place,
+  // or -1 if it's unknown.
+  int line_number() const { return line_number_; }
+
+  // Gets the summary of the failure message.
+  const char* summary() const { return summary_.c_str(); }
+
+  // Gets the message associated with the test part.
+  const char* message() const { return message_.c_str(); }
+
+  // Returns true if and only if the test part was skipped.
+  bool skipped() const { return type_ == kSkip; }
+
+  // Returns true if and only if the test part passed.
+  bool passed() const { return type_ == kSuccess; }
+
+  // Returns true if and only if the test part non-fatally failed.
+  bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
+
+  // Returns true if and only if the test part fatally failed.
+  bool fatally_failed() const { return type_ == kFatalFailure; }
+
+  // Returns true if and only if the test part failed.
+  bool failed() const { return fatally_failed() || nonfatally_failed(); }
+
+ private:
+  Type type_;
+
+  // Gets the summary of the failure message by omitting the stack
+  // trace in it.
+  static std::string ExtractSummary(const char* message);
+
+  // The name of the source file where the test part took place, or
+  // "" if the source file is unknown.
+  std::string file_name_;
+  // The line in the source file where the test part took place, or -1
+  // if the line number is unknown.
+  int line_number_;
+  std::string summary_;  // The test failure summary.
+  std::string message_;  // The test failure message.
+};
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
+
+// An array of TestPartResult objects.
+//
+// Don't inherit from TestPartResultArray as its destructor is not
+// virtual.
+class GTEST_API_ TestPartResultArray {
+ public:
+  TestPartResultArray() {}
+
+  // Appends the given TestPartResult to the array.
+  void Append(const TestPartResult& result);
+
+  // Returns the TestPartResult at the given index (0-based).
+  const TestPartResult& GetTestPartResult(int index) const;
+
+  // Returns the number of TestPartResult objects in the array.
+  int size() const;
+
+ private:
+  std::vector<TestPartResult> array_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
+};
+
+// This interface knows how to report a test part result.
+class GTEST_API_ TestPartResultReporterInterface {
+ public:
+  virtual ~TestPartResultReporterInterface() {}
+
+  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
+};
+
+namespace internal {
+
+// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
+// statement generates new fatal failures. To do so it registers itself as the
+// current test part result reporter. Besides checking if fatal failures were
+// reported, it only delegates the reporting to the former result reporter.
+// The original result reporter is restored in the destructor.
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+class GTEST_API_ HasNewFatalFailureHelper
+    : public TestPartResultReporterInterface {
+ public:
+  HasNewFatalFailureHelper();
+  ~HasNewFatalFailureHelper() override;
+  void ReportTestPartResult(const TestPartResult& result) override;
+  bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
+ private:
+  bool has_new_fatal_failure_;
+  TestPartResultReporterInterface* original_reporter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
diff --git a/tools/gtest_lib/include/gtest/gtest-typed-test.h b/tools/gtest_lib/include/gtest/gtest-typed-test.h
new file mode 100644
index 0000000000000000000000000000000000000000..343bf6fe98c1a87951e059d3a8b5414b00b77935
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest-typed-test.h
@@ -0,0 +1,331 @@
+// Copyright 2008 Google Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+
+// This header implements typed tests and type-parameterized tests.
+
+// Typed (aka type-driven) tests repeat the same test for types in a
+// list.  You must know which types you want to test with when writing
+// typed tests. Here's how you do it:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+ public:
+  ...
+  typedef std::list<T> List;
+  static T shared_;
+  T value_;
+};
+
+// Next, associate a list of types with the test suite, which will be
+// repeated for each type in the list.  The typedef is necessary for
+// the macro to parse correctly.
+typedef testing::Types<char, int, unsigned int> MyTypes;
+TYPED_TEST_SUITE(FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   TYPED_TEST_SUITE(FooTest, int);
+
+// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
+// tests for this test suite as you want.
+TYPED_TEST(FooTest, DoesBlah) {
+  // Inside a test, refer to the special name TypeParam to get the type
+  // parameter.  Since we are inside a derived class template, C++ requires
+  // us to visit the members of FooTest via 'this'.
+  TypeParam n = this->value_;
+
+  // To visit static members of the fixture, add the TestFixture::
+  // prefix.
+  n += TestFixture::shared_;
+
+  // To refer to typedefs in the fixture, add the "typename
+  // TestFixture::" prefix.
+  typename TestFixture::List values;
+  values.push_back(n);
+  ...
+}
+
+TYPED_TEST(FooTest, HasPropertyA) { ... }
+
+// TYPED_TEST_SUITE takes an optional third argument which allows to specify a
+// class that generates custom test name suffixes based on the type. This should
+// be a class which has a static template function GetName(int index) returning
+// a string for each type. The provided integer index equals the index of the
+// type in the provided type list. In many cases the index can be ignored.
+//
+// For example:
+//   class MyTypeNames {
+//    public:
+//     template <typename T>
+//     static std::string GetName(int) {
+//       if (std::is_same<T, char>()) return "char";
+//       if (std::is_same<T, int>()) return "int";
+//       if (std::is_same<T, unsigned int>()) return "unsignedInt";
+//     }
+//   };
+//   TYPED_TEST_SUITE(FooTest, MyTypes, MyTypeNames);
+
+#endif  // 0
+
+// Type-parameterized tests are abstract test patterns parameterized
+// by a type.  Compared with typed tests, type-parameterized tests
+// allow you to define the test pattern without knowing what the type
+// parameters are.  The defined pattern can be instantiated with
+// different types any number of times, in any number of translation
+// units.
+//
+// If you are designing an interface or concept, you can define a
+// suite of type-parameterized tests to verify properties that any
+// valid implementation of the interface/concept should have.  Then,
+// each implementation can easily instantiate the test suite to verify
+// that it conforms to the requirements, without having to write
+// similar tests repeatedly.  Here's an example:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+  ...
+};
+
+// Next, declare that you will define a type-parameterized test suite
+// (the _P suffix is for "parameterized" or "pattern", whichever you
+// prefer):
+TYPED_TEST_SUITE_P(FooTest);
+
+// Then, use TYPED_TEST_P() to define as many type-parameterized tests
+// for this type-parameterized test suite as you want.
+TYPED_TEST_P(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  TypeParam n = 0;
+  ...
+}
+
+TYPED_TEST_P(FooTest, HasPropertyA) { ... }
+
+// Now the tricky part: you need to register all test patterns before
+// you can instantiate them.  The first argument of the macro is the
+// test suite name; the rest are the names of the tests in this test
+// case.
+REGISTER_TYPED_TEST_SUITE_P(FooTest,
+                            DoesBlah, HasPropertyA);
+
+// Finally, you are free to instantiate the pattern with the types you
+// want.  If you put the above code in a header file, you can #include
+// it in multiple C++ source files and instantiate it multiple times.
+//
+// To distinguish different instances of the pattern, the first
+// argument to the INSTANTIATE_* macro is a prefix that will be added
+// to the actual test suite name.  Remember to pick unique prefixes for
+// different instances.
+typedef testing::Types<char, int, unsigned int> MyTypes;
+INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int);
+//
+// Similar to the optional argument of TYPED_TEST_SUITE above,
+// INSTANTIATE_TEST_SUITE_P takes an optional fourth argument which allows to
+// generate custom names.
+//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames);
+
+#endif  // 0
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+#include "gtest/internal/gtest-type-util.h"
+
+// Implements typed tests.
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the name of the typedef for the type parameters of the
+// given test suite.
+#define GTEST_TYPE_PARAMS_(TestSuiteName) gtest_type_params_##TestSuiteName##_
+
+// Expands to the name of the typedef for the NameGenerator, responsible for
+// creating the suffixes of the name.
+#define GTEST_NAME_GENERATOR_(TestSuiteName) \
+  gtest_type_params_##TestSuiteName##_NameGenerator
+
+#define TYPED_TEST_SUITE(CaseName, Types, ...)                          \
+  typedef ::testing::internal::GenerateTypeList<Types>::type            \
+      GTEST_TYPE_PARAMS_(CaseName);                                     \
+  typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \
+      GTEST_NAME_GENERATOR_(CaseName)
+
+#define TYPED_TEST(CaseName, TestName)                                        \
+  static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1,                       \
+                "test-name must not be empty");                               \
+  template <typename gtest_TypeParam_>                                        \
+  class GTEST_TEST_CLASS_NAME_(CaseName, TestName)                            \
+      : public CaseName<gtest_TypeParam_> {                                   \
+   private:                                                                   \
+    typedef CaseName<gtest_TypeParam_> TestFixture;                           \
+    typedef gtest_TypeParam_ TypeParam;                                       \
+    void TestBody() override;                                                 \
+  };                                                                          \
+  static bool gtest_##CaseName##_##TestName##_registered_                     \
+      GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest<   \
+          CaseName,                                                           \
+          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \
+                                                                  TestName)>, \
+          GTEST_TYPE_PARAMS_(                                                 \
+              CaseName)>::Register("",                                        \
+                                   ::testing::internal::CodeLocation(         \
+                                       __FILE__, __LINE__),                   \
+                                   GTEST_STRINGIFY_(CaseName),                \
+                                   GTEST_STRINGIFY_(TestName), 0,             \
+                                   ::testing::internal::GenerateNames<        \
+                                       GTEST_NAME_GENERATOR_(CaseName),       \
+                                       GTEST_TYPE_PARAMS_(CaseName)>());      \
+  template <typename gtest_TypeParam_>                                        \
+  void GTEST_TEST_CLASS_NAME_(CaseName,                                       \
+                              TestName)<gtest_TypeParam_>::TestBody()
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define TYPED_TEST_CASE                                                \
+  static_assert(::testing::internal::TypedTestCaseIsDeprecated(), ""); \
+  TYPED_TEST_SUITE
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// Implements type-parameterized tests.
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the namespace name that the type-parameterized tests for
+// the given type-parameterized test suite are defined in.  The exact
+// name of the namespace is subject to change without notice.
+#define GTEST_SUITE_NAMESPACE_(TestSuiteName) gtest_suite_##TestSuiteName##_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the name of the variable used to remember the names of
+// the defined tests in the given test suite.
+#define GTEST_TYPED_TEST_SUITE_P_STATE_(TestSuiteName) \
+  gtest_typed_test_suite_p_state_##TestSuiteName##_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
+//
+// Expands to the name of the variable used to remember the names of
+// the registered tests in the given test suite.
+#define GTEST_REGISTERED_TEST_NAMES_(TestSuiteName) \
+  gtest_registered_test_names_##TestSuiteName##_
+
+// The variables defined in the type-parameterized test macros are
+// static as typically these macros are used in a .h file that can be
+// #included in multiple translation units linked together.
+#define TYPED_TEST_SUITE_P(SuiteName)              \
+  static ::testing::internal::TypedTestSuitePState \
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName)
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define TYPED_TEST_CASE_P                                                 \
+  static_assert(::testing::internal::TypedTestCase_P_IsDeprecated(), ""); \
+  TYPED_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+#define TYPED_TEST_P(SuiteName, TestName)                             \
+  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                       \
+    template <typename gtest_TypeParam_>                              \
+    class TestName : public SuiteName<gtest_TypeParam_> {             \
+     private:                                                         \
+      typedef SuiteName<gtest_TypeParam_> TestFixture;                \
+      typedef gtest_TypeParam_ TypeParam;                             \
+      void TestBody() override;                                       \
+    };                                                                \
+    static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
+        GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName(       \
+            __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),          \
+            GTEST_STRINGIFY_(TestName));                              \
+  }                                                                   \
+  template <typename gtest_TypeParam_>                                \
+  void GTEST_SUITE_NAMESPACE_(                                        \
+      SuiteName)::TestName<gtest_TypeParam_>::TestBody()
+
+// Note: this won't work correctly if the trailing arguments are macros.
+#define REGISTER_TYPED_TEST_SUITE_P(SuiteName, ...)                         \
+  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                             \
+    typedef ::testing::internal::Templates<__VA_ARGS__> gtest_AllTests_;    \
+  }                                                                         \
+  static const char* const GTEST_REGISTERED_TEST_NAMES_(                    \
+      SuiteName) GTEST_ATTRIBUTE_UNUSED_ =                                  \
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \
+          GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__)
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define REGISTER_TYPED_TEST_CASE_P                                           \
+  static_assert(::testing::internal::RegisterTypedTestCase_P_IsDeprecated(), \
+                "");                                                         \
+  REGISTER_TYPED_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)       \
+  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                       \
+                "test-suit-prefix must not be empty");                      \
+  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =        \
+      ::testing::internal::TypeParameterizedTestSuite<                      \
+          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,    \
+          ::testing::internal::GenerateTypeList<Types>::type>::             \
+          Register(GTEST_STRINGIFY_(Prefix),                                \
+                   ::testing::internal::CodeLocation(__FILE__, __LINE__),   \
+                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),             \
+                   GTEST_STRINGIFY_(SuiteName),                             \
+                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),                 \
+                   ::testing::internal::GenerateNames<                      \
+                       ::testing::internal::NameGeneratorSelector<          \
+                           __VA_ARGS__>::type,                              \
+                       ::testing::internal::GenerateTypeList<Types>::type>())
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define INSTANTIATE_TYPED_TEST_CASE_P                                      \
+  static_assert(                                                           \
+      ::testing::internal::InstantiateTypedTestCase_P_IsDeprecated(), ""); \
+  INSTANTIATE_TYPED_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
diff --git a/tools/gtest_lib/include/gtest/gtest.h b/tools/gtest_lib/include/gtest/gtest.h
new file mode 100644
index 0000000000000000000000000000000000000000..a4174cd4e535be8ac961a10c693b8aecdb442ad9
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest.h
@@ -0,0 +1,2316 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the public API for Google Test.  It should be
+// included by any test program that uses Google Test.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+//
+// Acknowledgment: Google Test borrowed the idea of automatic test
+// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
+// easyUnit framework.
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_H_
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <ostream>
+#include <type_traits>
+#include <vector>
+
+#include "gtest/gtest-assertion-result.h"
+#include "gtest/gtest-death-test.h"
+#include "gtest/gtest-matchers.h"
+#include "gtest/gtest-message.h"
+#include "gtest/gtest-param-test.h"
+#include "gtest/gtest-printers.h"
+#include "gtest/gtest-test-part.h"
+#include "gtest/gtest-typed-test.h"
+#include "gtest/gtest_pred_impl.h"
+#include "gtest/gtest_prod.h"
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-string.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// Declares the flags.
+
+// This flag temporary enables the disabled tests.
+GTEST_DECLARE_bool_(also_run_disabled_tests);
+
+// This flag brings the debugger on an assertion failure.
+GTEST_DECLARE_bool_(break_on_failure);
+
+// This flag controls whether Google Test catches all test-thrown exceptions
+// and logs them as failures.
+GTEST_DECLARE_bool_(catch_exceptions);
+
+// This flag enables using colors in terminal output. Available values are
+// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
+// to let Google Test decide.
+GTEST_DECLARE_string_(color);
+
+// This flag controls whether the test runner should continue execution past
+// first failure.
+GTEST_DECLARE_bool_(fail_fast);
+
+// This flag sets up the filter to select by name using a glob pattern
+// the tests to run. If the filter is not given all tests are executed.
+GTEST_DECLARE_string_(filter);
+
+// This flag controls whether Google Test installs a signal handler that dumps
+// debugging information when fatal signals are raised.
+GTEST_DECLARE_bool_(install_failure_signal_handler);
+
+// This flag causes the Google Test to list tests. None of the tests listed
+// are actually run if the flag is provided.
+GTEST_DECLARE_bool_(list_tests);
+
+// This flag controls whether Google Test emits a detailed XML report to a file
+// in addition to its normal textual output.
+GTEST_DECLARE_string_(output);
+
+// This flags control whether Google Test prints only test failures.
+GTEST_DECLARE_bool_(brief);
+
+// This flags control whether Google Test prints the elapsed time for each
+// test.
+GTEST_DECLARE_bool_(print_time);
+
+// This flags control whether Google Test prints UTF8 characters as text.
+GTEST_DECLARE_bool_(print_utf8);
+
+// This flag specifies the random number seed.
+GTEST_DECLARE_int32_(random_seed);
+
+// This flag sets how many times the tests are repeated. The default value
+// is 1. If the value is -1 the tests are repeating forever.
+GTEST_DECLARE_int32_(repeat);
+
+// This flag controls whether Google Test Environments are recreated for each
+// repeat of the tests. The default value is true. If set to false the global
+// test Environment objects are only set up once, for the first iteration, and
+// only torn down once, for the last.
+GTEST_DECLARE_bool_(recreate_environments_when_repeating);
+
+// This flag controls whether Google Test includes Google Test internal
+// stack frames in failure stack traces.
+GTEST_DECLARE_bool_(show_internal_stack_frames);
+
+// When this flag is specified, tests' order is randomized on every iteration.
+GTEST_DECLARE_bool_(shuffle);
+
+// This flag specifies the maximum number of stack frames to be
+// printed in a failure message.
+GTEST_DECLARE_int32_(stack_trace_depth);
+
+// When this flag is specified, a failed assertion will throw an
+// exception if exceptions are enabled, or exit the program with a
+// non-zero code otherwise. For use with an external test framework.
+GTEST_DECLARE_bool_(throw_on_failure);
+
+// When this flag is set with a "host:port" string, on supported
+// platforms test results are streamed to the specified port on
+// the specified host machine.
+GTEST_DECLARE_string_(stream_result_to);
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+GTEST_DECLARE_string_(flagfile);
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+namespace testing {
+
+// Silence C4100 (unreferenced formal parameter) and 4805
+// unsafe mix of type 'const int' and type 'const bool'
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4805)
+#pragma warning(disable : 4100)
+#endif
+
+// The upper limit for valid stack trace depths.
+const int kMaxStackTraceDepth = 100;
+
+namespace internal {
+
+class AssertHelper;
+class DefaultGlobalTestPartResultReporter;
+class ExecDeathTest;
+class NoExecDeathTest;
+class FinalSuccessChecker;
+class GTestFlagSaver;
+class StreamingListenerTest;
+class TestResultAccessor;
+class TestEventListenersAccessor;
+class TestEventRepeater;
+class UnitTestRecordPropertyTestHelper;
+class WindowsDeathTest;
+class FuchsiaDeathTest;
+class UnitTestImpl* GetUnitTestImpl();
+void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
+                                    const std::string& message);
+std::set<std::string>* GetIgnoredParameterizedTestSuites();
+
+}  // namespace internal
+
+// The friend relationship of some of these classes is cyclic.
+// If we don't forward declare them the compiler might confuse the classes
+// in friendship clauses with same named classes on the scope.
+class Test;
+class TestSuite;
+
+// Old API is still available but deprecated
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+using TestCase = TestSuite;
+#endif
+class TestInfo;
+class UnitTest;
+
+// The abstract class that all tests inherit from.
+//
+// In Google Test, a unit test program contains one or many TestSuites, and
+// each TestSuite contains one or many Tests.
+//
+// When you define a test using the TEST macro, you don't need to
+// explicitly derive from Test - the TEST macro automatically does
+// this for you.
+//
+// The only time you derive from Test is when defining a test fixture
+// to be used in a TEST_F.  For example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     void SetUp() override { ... }
+//     void TearDown() override { ... }
+//     ...
+//   };
+//
+//   TEST_F(FooTest, Bar) { ... }
+//   TEST_F(FooTest, Baz) { ... }
+//
+// Test is not copyable.
+class GTEST_API_ Test {
+ public:
+  friend class TestInfo;
+
+  // The d'tor is virtual as we intend to inherit from Test.
+  virtual ~Test();
+
+  // Sets up the stuff shared by all tests in this test suite.
+  //
+  // Google Test will call Foo::SetUpTestSuite() before running the first
+  // test in test suite Foo.  Hence a sub-class can define its own
+  // SetUpTestSuite() method to shadow the one defined in the super
+  // class.
+  static void SetUpTestSuite() {}
+
+  // Tears down the stuff shared by all tests in this test suite.
+  //
+  // Google Test will call Foo::TearDownTestSuite() after running the last
+  // test in test suite Foo.  Hence a sub-class can define its own
+  // TearDownTestSuite() method to shadow the one defined in the super
+  // class.
+  static void TearDownTestSuite() {}
+
+  // Legacy API is deprecated but still available. Use SetUpTestSuite and
+  // TearDownTestSuite instead.
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  static void TearDownTestCase() {}
+  static void SetUpTestCase() {}
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Returns true if and only if the current test has a fatal failure.
+  static bool HasFatalFailure();
+
+  // Returns true if and only if the current test has a non-fatal failure.
+  static bool HasNonfatalFailure();
+
+  // Returns true if and only if the current test was skipped.
+  static bool IsSkipped();
+
+  // Returns true if and only if the current test has a (either fatal or
+  // non-fatal) failure.
+  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
+
+  // Logs a property for the current test, test suite, or for the entire
+  // invocation of the test program when used outside of the context of a
+  // test suite.  Only the last value for a given key is remembered.  These
+  // are public static so they can be called from utility functions that are
+  // not members of the test fixture.  Calls to RecordProperty made during
+  // lifespan of the test (from the moment its constructor starts to the
+  // moment its destructor finishes) will be output in XML as attributes of
+  // the <testcase> element.  Properties recorded from fixture's
+  // SetUpTestSuite or TearDownTestSuite are logged as attributes of the
+  // corresponding <testsuite> element.  Calls to RecordProperty made in the
+  // global context (before or after invocation of RUN_ALL_TESTS and from
+  // SetUp/TearDown method of Environment objects registered with Google
+  // Test) will be output as attributes of the <testsuites> element.
+  static void RecordProperty(const std::string& key, const std::string& value);
+  static void RecordProperty(const std::string& key, int value);
+
+ protected:
+  // Creates a Test object.
+  Test();
+
+  // Sets up the test fixture.
+  virtual void SetUp();
+
+  // Tears down the test fixture.
+  virtual void TearDown();
+
+ private:
+  // Returns true if and only if the current test has the same fixture class
+  // as the first test in the current test suite.
+  static bool HasSameFixtureClass();
+
+  // Runs the test after the test fixture has been set up.
+  //
+  // A sub-class must implement this to define the test logic.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
+  // Instead, use the TEST or TEST_F macro.
+  virtual void TestBody() = 0;
+
+  // Sets up, executes, and tears down the test.
+  void Run();
+
+  // Deletes self.  We deliberately pick an unusual name for this
+  // internal method to avoid clashing with names used in user TESTs.
+  void DeleteSelf_() { delete this; }
+
+  const std::unique_ptr<GTEST_FLAG_SAVER_> gtest_flag_saver_;
+
+  // Often a user misspells SetUp() as Setup() and spends a long time
+  // wondering why it is never called by Google Test.  The declaration of
+  // the following method is solely for catching such an error at
+  // compile time:
+  //
+  //   - The return type is deliberately chosen to be not void, so it
+  //   will be a conflict if void Setup() is declared in the user's
+  //   test fixture.
+  //
+  //   - This method is private, so it will be another compiler error
+  //   if the method is called from the user's test fixture.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION.
+  //
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
+
+  // We disallow copying Tests.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
+};
+
+typedef internal::TimeInMillis TimeInMillis;
+
+// A copyable object representing a user specified test property which can be
+// output as a key/value string pair.
+//
+// Don't inherit from TestProperty as its destructor is not virtual.
+class TestProperty {
+ public:
+  // C'tor.  TestProperty does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestProperty object.
+  TestProperty(const std::string& a_key, const std::string& a_value) :
+    key_(a_key), value_(a_value) {
+  }
+
+  // Gets the user supplied key.
+  const char* key() const {
+    return key_.c_str();
+  }
+
+  // Gets the user supplied value.
+  const char* value() const {
+    return value_.c_str();
+  }
+
+  // Sets a new value, overriding the one supplied in the constructor.
+  void SetValue(const std::string& new_value) {
+    value_ = new_value;
+  }
+
+ private:
+  // The key supplied by the user.
+  std::string key_;
+  // The value supplied by the user.
+  std::string value_;
+};
+
+// The result of a single Test.  This includes a list of
+// TestPartResults, a list of TestProperties, a count of how many
+// death tests there are in the Test, and how much time it took to run
+// the Test.
+//
+// TestResult is not copyable.
+class GTEST_API_ TestResult {
+ public:
+  // Creates an empty TestResult.
+  TestResult();
+
+  // D'tor.  Do not inherit from TestResult.
+  ~TestResult();
+
+  // Gets the number of all test parts.  This is the sum of the number
+  // of successful test parts and the number of failed test parts.
+  int total_part_count() const;
+
+  // Returns the number of the test properties.
+  int test_property_count() const;
+
+  // Returns true if and only if the test passed (i.e. no test part failed).
+  bool Passed() const { return !Skipped() && !Failed(); }
+
+  // Returns true if and only if the test was skipped.
+  bool Skipped() const;
+
+  // Returns true if and only if the test failed.
+  bool Failed() const;
+
+  // Returns true if and only if the test fatally failed.
+  bool HasFatalFailure() const;
+
+  // Returns true if and only if the test has a non-fatal failure.
+  bool HasNonfatalFailure() const;
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Gets the time of the test case start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Returns the i-th test part result among all the results. i can range from 0
+  // to total_part_count() - 1. If i is not in that range, aborts the program.
+  const TestPartResult& GetTestPartResult(int i) const;
+
+  // Returns the i-th test property. i can range from 0 to
+  // test_property_count() - 1. If i is not in that range, aborts the
+  // program.
+  const TestProperty& GetTestProperty(int i) const;
+
+ private:
+  friend class TestInfo;
+  friend class TestSuite;
+  friend class UnitTest;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::ExecDeathTest;
+  friend class internal::TestResultAccessor;
+  friend class internal::UnitTestImpl;
+  friend class internal::WindowsDeathTest;
+  friend class internal::FuchsiaDeathTest;
+
+  // Gets the vector of TestPartResults.
+  const std::vector<TestPartResult>& test_part_results() const {
+    return test_part_results_;
+  }
+
+  // Gets the vector of TestProperties.
+  const std::vector<TestProperty>& test_properties() const {
+    return test_properties_;
+  }
+
+  // Sets the start time.
+  void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }
+
+  // Sets the elapsed time.
+  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
+
+  // Adds a test property to the list. The property is validated and may add
+  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
+  // key names). If a property is already recorded for the same key, the
+  // value will be updated, rather than storing multiple values for the same
+  // key.  xml_element specifies the element for which the property is being
+  // recorded and is used for validation.
+  void RecordProperty(const std::string& xml_element,
+                      const TestProperty& test_property);
+
+  // Adds a failure if the key is a reserved attribute of Google Test
+  // testsuite tags.  Returns true if the property is valid.
+  // FIXME: Validate attribute names are legal and human readable.
+  static bool ValidateTestProperty(const std::string& xml_element,
+                                   const TestProperty& test_property);
+
+  // Adds a test part result to the list.
+  void AddTestPartResult(const TestPartResult& test_part_result);
+
+  // Returns the death test count.
+  int death_test_count() const { return death_test_count_; }
+
+  // Increments the death test count, returning the new count.
+  int increment_death_test_count() { return ++death_test_count_; }
+
+  // Clears the test part results.
+  void ClearTestPartResults();
+
+  // Clears the object.
+  void Clear();
+
+  // Protects mutable state of the property vector and of owned
+  // properties, whose values may be updated.
+  internal::Mutex test_properties_mutex_;
+
+  // The vector of TestPartResults
+  std::vector<TestPartResult> test_part_results_;
+  // The vector of TestProperties
+  std::vector<TestProperty> test_properties_;
+  // Running count of death tests.
+  int death_test_count_;
+  // The start time, in milliseconds since UNIX Epoch.
+  TimeInMillis start_timestamp_;
+  // The elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+  // We disallow copying TestResult.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
+};  // class TestResult
+
+// A TestInfo object stores the following information about a test:
+//
+//   Test suite name
+//   Test name
+//   Whether the test should be run
+//   A function pointer that creates the test object when invoked
+//   Test result
+//
+// The constructor of TestInfo registers itself with the UnitTest
+// singleton such that the RUN_ALL_TESTS() macro knows which tests to
+// run.
+class GTEST_API_ TestInfo {
+ public:
+  // Destructs a TestInfo object.  This function is not virtual, so
+  // don't inherit from TestInfo.
+  ~TestInfo();
+
+  // Returns the test suite name.
+  const char* test_suite_name() const { return test_suite_name_.c_str(); }
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const char* test_case_name() const { return test_suite_name(); }
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Returns the test name.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns the name of the parameter type, or NULL if this is not a typed
+  // or a type-parameterized test.
+  const char* type_param() const {
+    if (type_param_.get() != nullptr) return type_param_->c_str();
+    return nullptr;
+  }
+
+  // Returns the text representation of the value parameter, or NULL if this
+  // is not a value-parameterized test.
+  const char* value_param() const {
+    if (value_param_.get() != nullptr) return value_param_->c_str();
+    return nullptr;
+  }
+
+  // Returns the file name where this test is defined.
+  const char* file() const { return location_.file.c_str(); }
+
+  // Returns the line where this test is defined.
+  int line() const { return location_.line; }
+
+  // Return true if this test should not be run because it's in another shard.
+  bool is_in_another_shard() const { return is_in_another_shard_; }
+
+  // Returns true if this test should run, that is if the test is not
+  // disabled (or it is disabled but the also_run_disabled_tests flag has
+  // been specified) and its full name matches the user-specified filter.
+  //
+  // Google Test allows the user to filter the tests by their full names.
+  // The full name of a test Bar in test suite Foo is defined as
+  // "Foo.Bar".  Only the tests that match the filter will run.
+  //
+  // A filter is a colon-separated list of glob (not regex) patterns,
+  // optionally followed by a '-' and a colon-separated list of
+  // negative patterns (tests to exclude).  A test is run if it
+  // matches one of the positive patterns and does not match any of
+  // the negative patterns.
+  //
+  // For example, *A*:Foo.* is a filter that matches any string that
+  // contains the character 'A' or starts with "Foo.".
+  bool should_run() const { return should_run_; }
+
+  // Returns true if and only if this test will appear in the XML report.
+  bool is_reportable() const {
+    // The XML report includes tests matching the filter, excluding those
+    // run in other shards.
+    return matches_filter_ && !is_in_another_shard_;
+  }
+
+  // Returns the result of the test.
+  const TestResult* result() const { return &result_; }
+
+ private:
+#if GTEST_HAS_DEATH_TEST
+  friend class internal::DefaultDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+  friend class Test;
+  friend class TestSuite;
+  friend class internal::UnitTestImpl;
+  friend class internal::StreamingListenerTest;
+  friend TestInfo* internal::MakeAndRegisterTestInfo(
+      const char* test_suite_name, const char* name, const char* type_param,
+      const char* value_param, internal::CodeLocation code_location,
+      internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
+      internal::TearDownTestSuiteFunc tear_down_tc,
+      internal::TestFactoryBase* factory);
+
+  // Constructs a TestInfo object. The newly constructed instance assumes
+  // ownership of the factory object.
+  TestInfo(const std::string& test_suite_name, const std::string& name,
+           const char* a_type_param,   // NULL if not a type-parameterized test
+           const char* a_value_param,  // NULL if not a value-parameterized test
+           internal::CodeLocation a_code_location,
+           internal::TypeId fixture_class_id,
+           internal::TestFactoryBase* factory);
+
+  // Increments the number of death tests encountered in this test so
+  // far.
+  int increment_death_test_count() {
+    return result_.increment_death_test_count();
+  }
+
+  // Creates the test object, runs it, records its result, and then
+  // deletes it.
+  void Run();
+
+  // Skip and records the test result for this object.
+  void Skip();
+
+  static void ClearTestResult(TestInfo* test_info) {
+    test_info->result_.Clear();
+  }
+
+  // These fields are immutable properties of the test.
+  const std::string test_suite_name_;    // test suite name
+  const std::string name_;               // Test name
+  // Name of the parameter type, or NULL if this is not a typed or a
+  // type-parameterized test.
+  const std::unique_ptr<const ::std::string> type_param_;
+  // Text representation of the value parameter, or NULL if this is not a
+  // value-parameterized test.
+  const std::unique_ptr<const ::std::string> value_param_;
+  internal::CodeLocation location_;
+  const internal::TypeId fixture_class_id_;  // ID of the test fixture class
+  bool should_run_;           // True if and only if this test should run
+  bool is_disabled_;          // True if and only if this test is disabled
+  bool matches_filter_;       // True if this test matches the
+                              // user-specified filter.
+  bool is_in_another_shard_;  // Will be run in another shard.
+  internal::TestFactoryBase* const factory_;  // The factory that creates
+                                              // the test object
+
+  // This field is mutable and needs to be reset before running the
+  // test for the second time.
+  TestResult result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
+};
+
+// A test suite, which consists of a vector of TestInfos.
+//
+// TestSuite is not copyable.
+class GTEST_API_ TestSuite {
+ public:
+  // Creates a TestSuite with the given name.
+  //
+  // TestSuite does NOT have a default constructor.  Always use this
+  // constructor to create a TestSuite object.
+  //
+  // Arguments:
+  //
+  //   name:         name of the test suite
+  //   a_type_param: the name of the test's type parameter, or NULL if
+  //                 this is not a type-parameterized test.
+  //   set_up_tc:    pointer to the function that sets up the test suite
+  //   tear_down_tc: pointer to the function that tears down the test suite
+  TestSuite(const char* name, const char* a_type_param,
+            internal::SetUpTestSuiteFunc set_up_tc,
+            internal::TearDownTestSuiteFunc tear_down_tc);
+
+  // Destructor of TestSuite.
+  virtual ~TestSuite();
+
+  // Gets the name of the TestSuite.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns the name of the parameter type, or NULL if this is not a
+  // type-parameterized test suite.
+  const char* type_param() const {
+    if (type_param_.get() != nullptr) return type_param_->c_str();
+    return nullptr;
+  }
+
+  // Returns true if any test in this test suite should run.
+  bool should_run() const { return should_run_; }
+
+  // Gets the number of successful tests in this test suite.
+  int successful_test_count() const;
+
+  // Gets the number of skipped tests in this test suite.
+  int skipped_test_count() const;
+
+  // Gets the number of failed tests in this test suite.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests in this test suite.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Get the number of tests in this test suite that should run.
+  int test_to_run_count() const;
+
+  // Gets the number of all tests in this test suite.
+  int total_test_count() const;
+
+  // Returns true if and only if the test suite passed.
+  bool Passed() const { return !Failed(); }
+
+  // Returns true if and only if the test suite failed.
+  bool Failed() const {
+    return failed_test_count() > 0 || ad_hoc_test_result().Failed();
+  }
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Gets the time of the test suite start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  const TestInfo* GetTestInfo(int i) const;
+
+  // Returns the TestResult that holds test properties recorded during
+  // execution of SetUpTestSuite and TearDownTestSuite.
+  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
+
+ private:
+  friend class Test;
+  friend class internal::UnitTestImpl;
+
+  // Gets the (mutable) vector of TestInfos in this TestSuite.
+  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
+
+  // Gets the (immutable) vector of TestInfos in this TestSuite.
+  const std::vector<TestInfo*>& test_info_list() const {
+    return test_info_list_;
+  }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  TestInfo* GetMutableTestInfo(int i);
+
+  // Sets the should_run member.
+  void set_should_run(bool should) { should_run_ = should; }
+
+  // Adds a TestInfo to this test suite.  Will delete the TestInfo upon
+  // destruction of the TestSuite object.
+  void AddTestInfo(TestInfo * test_info);
+
+  // Clears the results of all tests in this test suite.
+  void ClearResult();
+
+  // Clears the results of all tests in the given test suite.
+  static void ClearTestSuiteResult(TestSuite* test_suite) {
+    test_suite->ClearResult();
+  }
+
+  // Runs every test in this TestSuite.
+  void Run();
+
+  // Skips the execution of tests under this TestSuite
+  void Skip();
+
+  // Runs SetUpTestSuite() for this TestSuite.  This wrapper is needed
+  // for catching exceptions thrown from SetUpTestSuite().
+  void RunSetUpTestSuite() {
+    if (set_up_tc_ != nullptr) {
+      (*set_up_tc_)();
+    }
+  }
+
+  // Runs TearDownTestSuite() for this TestSuite.  This wrapper is
+  // needed for catching exceptions thrown from TearDownTestSuite().
+  void RunTearDownTestSuite() {
+    if (tear_down_tc_ != nullptr) {
+      (*tear_down_tc_)();
+    }
+  }
+
+  // Returns true if and only if test passed.
+  static bool TestPassed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Passed();
+  }
+
+  // Returns true if and only if test skipped.
+  static bool TestSkipped(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Skipped();
+  }
+
+  // Returns true if and only if test failed.
+  static bool TestFailed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Failed();
+  }
+
+  // Returns true if and only if the test is disabled and will be reported in
+  // the XML report.
+  static bool TestReportableDisabled(const TestInfo* test_info) {
+    return test_info->is_reportable() && test_info->is_disabled_;
+  }
+
+  // Returns true if and only if test is disabled.
+  static bool TestDisabled(const TestInfo* test_info) {
+    return test_info->is_disabled_;
+  }
+
+  // Returns true if and only if this test will appear in the XML report.
+  static bool TestReportable(const TestInfo* test_info) {
+    return test_info->is_reportable();
+  }
+
+  // Returns true if the given test should run.
+  static bool ShouldRunTest(const TestInfo* test_info) {
+    return test_info->should_run();
+  }
+
+  // Shuffles the tests in this test suite.
+  void ShuffleTests(internal::Random* random);
+
+  // Restores the test order to before the first shuffle.
+  void UnshuffleTests();
+
+  // Name of the test suite.
+  std::string name_;
+  // Name of the parameter type, or NULL if this is not a typed or a
+  // type-parameterized test.
+  const std::unique_ptr<const ::std::string> type_param_;
+  // The vector of TestInfos in their original order.  It owns the
+  // elements in the vector.
+  std::vector<TestInfo*> test_info_list_;
+  // Provides a level of indirection for the test list to allow easy
+  // shuffling and restoring the test order.  The i-th element in this
+  // vector is the index of the i-th test in the shuffled test list.
+  std::vector<int> test_indices_;
+  // Pointer to the function that sets up the test suite.
+  internal::SetUpTestSuiteFunc set_up_tc_;
+  // Pointer to the function that tears down the test suite.
+  internal::TearDownTestSuiteFunc tear_down_tc_;
+  // True if and only if any test in this test suite should run.
+  bool should_run_;
+  // The start time, in milliseconds since UNIX Epoch.
+  TimeInMillis start_timestamp_;
+  // Elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+  // Holds test properties recorded during execution of SetUpTestSuite and
+  // TearDownTestSuite.
+  TestResult ad_hoc_test_result_;
+
+  // We disallow copying TestSuites.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
+};
+
+// An Environment object is capable of setting up and tearing down an
+// environment.  You should subclass this to define your own
+// environment(s).
+//
+// An Environment object does the set-up and tear-down in virtual
+// methods SetUp() and TearDown() instead of the constructor and the
+// destructor, as:
+//
+//   1. You cannot safely throw from a destructor.  This is a problem
+//      as in some cases Google Test is used where exceptions are enabled, and
+//      we may want to implement ASSERT_* using exceptions where they are
+//      available.
+//   2. You cannot use ASSERT_* directly in a constructor or
+//      destructor.
+class Environment {
+ public:
+  // The d'tor is virtual as we need to subclass Environment.
+  virtual ~Environment() {}
+
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+ private:
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
+};
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Exception which can be thrown from TestEventListener::OnTestPartResult.
+class GTEST_API_ AssertionException
+    : public internal::GoogleTestFailureException {
+ public:
+  explicit AssertionException(const TestPartResult& result)
+      : GoogleTestFailureException(result) {}
+};
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// The interface for tracing execution of tests. The methods are organized in
+// the order the corresponding events are fired.
+class TestEventListener {
+ public:
+  virtual ~TestEventListener() {}
+
+  // Fired before any test activity starts.
+  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
+
+  // Fired before each iteration of tests starts.  There may be more than
+  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
+  // index, starting from 0.
+  virtual void OnTestIterationStart(const UnitTest& unit_test,
+                                    int iteration) = 0;
+
+  // Fired before environment set-up for each iteration of tests starts.
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment set-up for each iteration of tests ends.
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
+
+  // Fired before the test suite starts.
+  virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}
+
+  //  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Fired before the test starts.
+  virtual void OnTestStart(const TestInfo& test_info) = 0;
+
+  // Fired when a test is disabled
+  virtual void OnTestDisabled(const TestInfo& /*test_info*/) {}
+
+  // Fired after a failed assertion or a SUCCEED() invocation.
+  // If you want to throw an exception from this function to skip to the next
+  // TEST, it must be AssertionException defined above, or inherited from it.
+  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
+
+  // Fired after the test ends.
+  virtual void OnTestEnd(const TestInfo& test_info) = 0;
+
+  // Fired after the test suite ends.
+  virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {}
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Fired before environment tear-down for each iteration of tests starts.
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment tear-down for each iteration of tests ends.
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
+
+  // Fired after each iteration of tests finishes.
+  virtual void OnTestIterationEnd(const UnitTest& unit_test,
+                                  int iteration) = 0;
+
+  // Fired after all test activities have ended.
+  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
+};
+
+// The convenience class for users who need to override just one or two
+// methods and are not concerned that a possible change to a signature of
+// the methods they override will not be caught during the build.  For
+// comments about each method please see the definition of TestEventListener
+// above.
+class EmptyTestEventListener : public TestEventListener {
+ public:
+  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                            int /*iteration*/) override {}
+  void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnTestStart(const TestInfo& /*test_info*/) override {}
+  void OnTestDisabled(const TestInfo& /*test_info*/) override {}
+  void OnTestPartResult(const TestPartResult& /*test_part_result*/) override {}
+  void OnTestEnd(const TestInfo& /*test_info*/) override {}
+  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                          int /*iteration*/) override {}
+  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
+};
+
+// TestEventListeners lets users add listeners to track events in Google Test.
+class GTEST_API_ TestEventListeners {
+ public:
+  TestEventListeners();
+  ~TestEventListeners();
+
+  // Appends an event listener to the end of the list. Google Test assumes
+  // the ownership of the listener (i.e. it will delete the listener when
+  // the test program finishes).
+  void Append(TestEventListener* listener);
+
+  // Removes the given event listener from the list and returns it.  It then
+  // becomes the caller's responsibility to delete the listener. Returns
+  // NULL if the listener is not found in the list.
+  TestEventListener* Release(TestEventListener* listener);
+
+  // Returns the standard listener responsible for the default console
+  // output.  Can be removed from the listeners list to shut down default
+  // console output.  Note that removing this object from the listener list
+  // with Release transfers its ownership to the caller and makes this
+  // function return NULL the next time.
+  TestEventListener* default_result_printer() const {
+    return default_result_printer_;
+  }
+
+  // Returns the standard listener responsible for the default XML output
+  // controlled by the --gtest_output=xml flag.  Can be removed from the
+  // listeners list by users who want to shut down the default XML output
+  // controlled by this flag and substitute it with custom one.  Note that
+  // removing this object from the listener list with Release transfers its
+  // ownership to the caller and makes this function return NULL the next
+  // time.
+  TestEventListener* default_xml_generator() const {
+    return default_xml_generator_;
+  }
+
+ private:
+  friend class TestSuite;
+  friend class TestInfo;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::NoExecDeathTest;
+  friend class internal::TestEventListenersAccessor;
+  friend class internal::UnitTestImpl;
+
+  // Returns repeater that broadcasts the TestEventListener events to all
+  // subscribers.
+  TestEventListener* repeater();
+
+  // Sets the default_result_printer attribute to the provided listener.
+  // The listener is also added to the listener list and previous
+  // default_result_printer is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultResultPrinter(TestEventListener* listener);
+
+  // Sets the default_xml_generator attribute to the provided listener.  The
+  // listener is also added to the listener list and previous
+  // default_xml_generator is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultXmlGenerator(TestEventListener* listener);
+
+  // Controls whether events will be forwarded by the repeater to the
+  // listeners in the list.
+  bool EventForwardingEnabled() const;
+  void SuppressEventForwarding();
+
+  // The actual list of listeners.
+  internal::TestEventRepeater* repeater_;
+  // Listener responsible for the standard result output.
+  TestEventListener* default_result_printer_;
+  // Listener responsible for the creation of the XML output file.
+  TestEventListener* default_xml_generator_;
+
+  // We disallow copying TestEventListeners.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
+};
+
+// A UnitTest consists of a vector of TestSuites.
+//
+// This is a singleton class.  The only instance of UnitTest is
+// created when UnitTest::GetInstance() is first called.  This
+// instance is never deleted.
+//
+// UnitTest is not copyable.
+//
+// This class is thread-safe as long as the methods are called
+// according to their specification.
+class GTEST_API_ UnitTest {
+ public:
+  // Gets the singleton UnitTest object.  The first time this method
+  // is called, a UnitTest object is constructed and returned.
+  // Consecutive calls will return the same object.
+  static UnitTest* GetInstance();
+
+  // Runs all tests in this UnitTest object and prints the result.
+  // Returns 0 if successful, or 1 otherwise.
+  //
+  // This method can only be called from the main thread.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  int Run() GTEST_MUST_USE_RESULT_;
+
+  // Returns the working directory when the first TEST() or TEST_F()
+  // was executed.  The UnitTest object owns the string.
+  const char* original_working_dir() const;
+
+  // Returns the TestSuite object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestSuite* current_test_suite() const GTEST_LOCK_EXCLUDED_(mutex_);
+
+// Legacy API is still available but deprecated
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_);
+#endif
+
+  // Returns the TestInfo object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestInfo* current_test_info() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Returns the random seed used at the start of the current test run.
+  int random_seed() const;
+
+  // Returns the ParameterizedTestSuiteRegistry object used to keep track of
+  // value-parameterized tests and instantiate and register them.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Gets the number of successful test suites.
+  int successful_test_suite_count() const;
+
+  // Gets the number of failed test suites.
+  int failed_test_suite_count() const;
+
+  // Gets the number of all test suites.
+  int total_test_suite_count() const;
+
+  // Gets the number of all test suites that contain at least one test
+  // that should run.
+  int test_suite_to_run_count() const;
+
+  //  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  int successful_test_case_count() const;
+  int failed_test_case_count() const;
+  int total_test_case_count() const;
+  int test_case_to_run_count() const;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of skipped tests.
+  int skipped_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const;
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const;
+
+  // Returns true if and only if the unit test passed (i.e. all test suites
+  // passed).
+  bool Passed() const;
+
+  // Returns true if and only if the unit test failed (i.e. some test suite
+  // failed or something outside of all tests failed).
+  bool Failed() const;
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  const TestSuite* GetTestSuite(int i) const;
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const TestCase* GetTestCase(int i) const;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Returns the TestResult containing information on test failures and
+  // properties logged outside of individual test suites.
+  const TestResult& ad_hoc_test_result() const;
+
+  // Returns the list of event listeners that can be used to track events
+  // inside Google Test.
+  TestEventListeners& listeners();
+
+ private:
+  // Registers and returns a global test environment.  When a test
+  // program is run, all global test environments will be set-up in
+  // the order they were registered.  After all tests in the program
+  // have finished, all global test environments will be torn-down in
+  // the *reverse* order they were registered.
+  //
+  // The UnitTest object takes ownership of the given environment.
+  //
+  // This method can only be called from the main thread.
+  Environment* AddEnvironment(Environment* env);
+
+  // Adds a TestPartResult to the current TestResult object.  All
+  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
+  // eventually call this to report their results.  The user code
+  // should use the assertion macros instead of calling this directly.
+  void AddTestPartResult(TestPartResult::Type result_type,
+                         const char* file_name,
+                         int line_number,
+                         const std::string& message,
+                         const std::string& os_stack_trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Adds a TestProperty to the current TestResult object when invoked from
+  // inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
+  // from SetUpTestSuite or TearDownTestSuite, or to the global property set
+  // when invoked elsewhere.  If the result already contains a property with
+  // the same key, the value will be updated.
+  void RecordProperty(const std::string& key, const std::string& value);
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  TestSuite* GetMutableTestSuite(int i);
+
+  // Accessors for the implementation object.
+  internal::UnitTestImpl* impl() { return impl_; }
+  const internal::UnitTestImpl* impl() const { return impl_; }
+
+  // These classes and functions are friends as they need to access private
+  // members of UnitTest.
+  friend class ScopedTrace;
+  friend class Test;
+  friend class internal::AssertHelper;
+  friend class internal::StreamingListenerTest;
+  friend class internal::UnitTestRecordPropertyTestHelper;
+  friend Environment* AddGlobalTestEnvironment(Environment* env);
+  friend std::set<std::string>* internal::GetIgnoredParameterizedTestSuites();
+  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
+  friend void internal::ReportFailureInUnknownLocation(
+      TestPartResult::Type result_type,
+      const std::string& message);
+
+  // Creates an empty UnitTest.
+  UnitTest();
+
+  // D'tor
+  virtual ~UnitTest();
+
+  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+  // Google Test trace stack.
+  void PushGTestTrace(const internal::TraceInfo& trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Pops a trace from the per-thread Google Test trace stack.
+  void PopGTestTrace()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Protects mutable state in *impl_.  This is mutable as some const
+  // methods need to lock it too.
+  mutable internal::Mutex mutex_;
+
+  // Opaque implementation object.  This field is never changed once
+  // the object is constructed.  We don't mark it as const here, as
+  // doing so will cause a warning in the constructor of UnitTest.
+  // Mutable state in *impl_ is protected by mutex_.
+  internal::UnitTestImpl* impl_;
+
+  // We disallow copying UnitTest.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
+};
+
+// A convenient wrapper for adding an environment for the test
+// program.
+//
+// You should call this before RUN_ALL_TESTS() is called, probably in
+// main().  If you use gtest_main, you need to call this before main()
+// starts for it to take effect.  For example, you can define a global
+// variable like this:
+//
+//   testing::Environment* const foo_env =
+//       testing::AddGlobalTestEnvironment(new FooEnvironment);
+//
+// However, we strongly recommend you to write your own main() and
+// call AddGlobalTestEnvironment() there, as relying on initialization
+// of global variables makes the code harder to read and may cause
+// problems when you register multiple environments from different
+// translation units and the environments have dependencies among them
+// (remember that the compiler doesn't guarantee the order in which
+// global variables from different translation units are initialized).
+inline Environment* AddGlobalTestEnvironment(Environment* env) {
+  return UnitTest::GetInstance()->AddEnvironment(env);
+}
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+//
+// Calling the function for the second time has no user-visible effect.
+GTEST_API_ void InitGoogleTest(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+GTEST_API_ void InitGoogleTest();
+
+namespace internal {
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_* in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQFailure(const char* lhs_expression,
+                                   const char* rhs_expression,
+                                   const T1& lhs, const T2& rhs) {
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   FormatForComparisonFailureMessage(lhs, rhs),
+                   FormatForComparisonFailureMessage(rhs, lhs),
+                   false);
+}
+
+// This block of code defines operator==/!=
+// to block lexical scope lookup.
+// It prevents using invalid operator==/!= defined at namespace scope.
+struct faketype {};
+inline bool operator==(faketype, faketype) { return true; }
+inline bool operator!=(faketype, faketype) { return false; }
+
+// The helper function for {ASSERT|EXPECT}_EQ.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQ(const char* lhs_expression,
+                            const char* rhs_expression,
+                            const T1& lhs,
+                            const T2& rhs) {
+  if (lhs == rhs) {
+    return AssertionSuccess();
+  }
+
+  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
+}
+
+class EqHelper {
+ public:
+  // This templatized version is for the general case.
+  template <
+      typename T1, typename T2,
+      // Disable this overload for cases where one argument is a pointer
+      // and the other is the null pointer constant.
+      typename std::enable_if<!std::is_integral<T1>::value ||
+                              !std::is_pointer<T2>::value>::type* = nullptr>
+  static AssertionResult Compare(const char* lhs_expression,
+                                 const char* rhs_expression, const T1& lhs,
+                                 const T2& rhs) {
+    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
+  }
+
+  // With this overloaded version, we allow anonymous enums to be used
+  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
+  // enums can be implicitly cast to BiggestInt.
+  //
+  // Even though its body looks the same as the above version, we
+  // cannot merge the two, as it will make anonymous enums unhappy.
+  static AssertionResult Compare(const char* lhs_expression,
+                                 const char* rhs_expression,
+                                 BiggestInt lhs,
+                                 BiggestInt rhs) {
+    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
+  }
+
+  template <typename T>
+  static AssertionResult Compare(
+      const char* lhs_expression, const char* rhs_expression,
+      // Handle cases where '0' is used as a null pointer literal.
+      std::nullptr_t /* lhs */, T* rhs) {
+    // We already know that 'lhs' is a null pointer.
+    return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
+                       rhs);
+  }
+};
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_OP in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
+                                   const T1& val1, const T2& val2,
+                                   const char* op) {
+  return AssertionFailure()
+         << "Expected: (" << expr1 << ") " << op << " (" << expr2
+         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
+         << " vs " << FormatForComparisonFailureMessage(val2, val1);
+}
+
+// A macro for implementing the helper functions needed to implement
+// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
+// of similar code.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
+template <typename T1, typename T2>\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   const T1& val1, const T2& val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
+  }\
+}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// Implements the helper function for {ASSERT|EXPECT}_NE
+GTEST_IMPL_CMP_HELPER_(NE, !=)
+// Implements the helper function for {ASSERT|EXPECT}_LE
+GTEST_IMPL_CMP_HELPER_(LE, <=)
+// Implements the helper function for {ASSERT|EXPECT}_LT
+GTEST_IMPL_CMP_HELPER_(LT, <)
+// Implements the helper function for {ASSERT|EXPECT}_GE
+GTEST_IMPL_CMP_HELPER_(GE, >=)
+// Implements the helper function for {ASSERT|EXPECT}_GT
+GTEST_IMPL_CMP_HELPER_(GT, >)
+
+#undef GTEST_IMPL_CMP_HELPER_
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const char* s1,
+                                          const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
+                                              const char* s2_expression,
+                                              const char* s1,
+                                              const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const char* s1,
+                                          const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                              const char* s2_expression,
+                                              const char* s1,
+                                              const char* s2);
+
+
+// Helper function for *_STREQ on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const wchar_t* s1,
+                                          const wchar_t* s2);
+
+// Helper function for *_STRNE on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const wchar_t* s1,
+                                          const wchar_t* s2);
+
+}  // namespace internal
+
+// IsSubstring() and IsNotSubstring() are intended to be used as the
+// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
+// themselves.  They check whether needle is a substring of haystack
+// (NULL is considered a substring of itself only), and return an
+// appropriate error message when they fail.
+//
+// The {needle,haystack}_expr arguments are the stringified
+// expressions that generated the two real arguments.
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+// Helper template function for comparing floating-points.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename RawType>
+AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
+                                         const char* rhs_expression,
+                                         RawType lhs_value,
+                                         RawType rhs_value) {
+  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
+
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  ::std::stringstream lhs_ss;
+  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << lhs_value;
+
+  ::std::stringstream rhs_ss;
+  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << rhs_value;
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   StringStreamToString(&lhs_ss),
+                   StringStreamToString(&rhs_ss),
+                   false);
+}
+
+// Helper function for implementing ASSERT_NEAR.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
+                                                const char* expr2,
+                                                const char* abs_error_expr,
+                                                double val1,
+                                                double val2,
+                                                double abs_error);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+// A class that enables one to stream messages to assertion macros
+class GTEST_API_ AssertHelper {
+ public:
+  // Constructor.
+  AssertHelper(TestPartResult::Type type,
+               const char* file,
+               int line,
+               const char* message);
+  ~AssertHelper();
+
+  // Message assignment is a semantic trick to enable assertion
+  // streaming; see the GTEST_MESSAGE_ macro below.
+  void operator=(const Message& message) const;
+
+ private:
+  // We put our data in a struct so that the size of the AssertHelper class can
+  // be as small as possible.  This is important because gcc is incapable of
+  // re-using stack space even for temporary variables, so every EXPECT_EQ
+  // reserves stack space for another AssertHelper.
+  struct AssertHelperData {
+    AssertHelperData(TestPartResult::Type t,
+                     const char* srcfile,
+                     int line_num,
+                     const char* msg)
+        : type(t), file(srcfile), line(line_num), message(msg) { }
+
+    TestPartResult::Type const type;
+    const char* const file;
+    int const line;
+    std::string const message;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
+  };
+
+  AssertHelperData* const data_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
+};
+
+}  // namespace internal
+
+// The pure interface class that all value-parameterized tests inherit from.
+// A value-parameterized class must inherit from both ::testing::Test and
+// ::testing::WithParamInterface. In most cases that just means inheriting
+// from ::testing::TestWithParam, but more complicated test hierarchies
+// may need to inherit from Test and WithParamInterface at different levels.
+//
+// This interface has support for accessing the test parameter value via
+// the GetParam() method.
+//
+// Use it with one of the parameter generator defining functions, like Range(),
+// Values(), ValuesIn(), Bool(), and Combine().
+//
+// class FooTest : public ::testing::TestWithParam<int> {
+//  protected:
+//   FooTest() {
+//     // Can use GetParam() here.
+//   }
+//   ~FooTest() override {
+//     // Can use GetParam() here.
+//   }
+//   void SetUp() override {
+//     // Can use GetParam() here.
+//   }
+//   void TearDown override {
+//     // Can use GetParam() here.
+//   }
+// };
+// TEST_P(FooTest, DoesBar) {
+//   // Can use GetParam() method here.
+//   Foo foo;
+//   ASSERT_TRUE(foo.DoesBar(GetParam()));
+// }
+// INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
+
+template <typename T>
+class WithParamInterface {
+ public:
+  typedef T ParamType;
+  virtual ~WithParamInterface() {}
+
+  // The current parameter value. Is also available in the test fixture's
+  // constructor.
+  static const ParamType& GetParam() {
+    GTEST_CHECK_(parameter_ != nullptr)
+        << "GetParam() can only be called inside a value-parameterized test "
+        << "-- did you intend to write TEST_P instead of TEST_F?";
+    return *parameter_;
+  }
+
+ private:
+  // Sets parameter value. The caller is responsible for making sure the value
+  // remains alive and unchanged throughout the current test.
+  static void SetParam(const ParamType* parameter) {
+    parameter_ = parameter;
+  }
+
+  // Static value used for accessing parameter during a test lifetime.
+  static const ParamType* parameter_;
+
+  // TestClass must be a subclass of WithParamInterface<T> and Test.
+  template <class TestClass> friend class internal::ParameterizedTestFactory;
+};
+
+template <typename T>
+const T* WithParamInterface<T>::parameter_ = nullptr;
+
+// Most value-parameterized classes can ignore the existence of
+// WithParamInterface, and can just inherit from ::testing::TestWithParam.
+
+template <typename T>
+class TestWithParam : public Test, public WithParamInterface<T> {
+};
+
+// Macros for indicating success/failure in test code.
+
+// Skips test in runtime.
+// Skipping test aborts current function.
+// Skipped tests are neither successful nor failed.
+#define GTEST_SKIP() GTEST_SKIP_("")
+
+// ADD_FAILURE unconditionally adds a failure to the current test.
+// SUCCEED generates a success - it doesn't automatically make the
+// current test successful, as a test is only successful when it has
+// no failure.
+//
+// EXPECT_* verifies that a certain condition is satisfied.  If not,
+// it behaves like ADD_FAILURE.  In particular:
+//
+//   EXPECT_TRUE  verifies that a Boolean condition is true.
+//   EXPECT_FALSE verifies that a Boolean condition is false.
+//
+// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
+// that they will also abort the current function on failure.  People
+// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
+// writing data-driven tests often find themselves using ADD_FAILURE
+// and EXPECT_* more.
+
+// Generates a nonfatal failure with a generic message.
+#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
+
+// Generates a nonfatal failure at the given source file location with
+// a generic message.
+#define ADD_FAILURE_AT(file, line) \
+  GTEST_MESSAGE_AT_(file, line, "Failed", \
+                    ::testing::TestPartResult::kNonFatalFailure)
+
+// Generates a fatal failure with a generic message.
+#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
+
+// Like GTEST_FAIL(), but at the given source file location.
+#define GTEST_FAIL_AT(file, line)         \
+  GTEST_MESSAGE_AT_(file, line, "Failed", \
+                    ::testing::TestPartResult::kFatalFailure)
+
+// Define this macro to 1 to omit the definition of FAIL(), which is a
+// generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_FAIL
+# define FAIL() GTEST_FAIL()
+#endif
+
+// Generates a success with a generic message.
+#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
+
+// Define this macro to 1 to omit the definition of SUCCEED(), which
+// is a generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_SUCCEED
+# define SUCCEED() GTEST_SUCCEED()
+#endif
+
+// Macros for testing exceptions.
+//
+//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
+//         Tests that the statement throws the expected exception.
+//    * {ASSERT|EXPECT}_NO_THROW(statement):
+//         Tests that the statement doesn't throw any exception.
+//    * {ASSERT|EXPECT}_ANY_THROW(statement):
+//         Tests that the statement throws an exception.
+
+#define EXPECT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
+#define ASSERT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
+#define ASSERT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
+
+// Boolean assertions. Condition can be either a Boolean expression or an
+// AssertionResult. For more information on how to use AssertionResult with
+// these macros see comments on that class.
+#define GTEST_EXPECT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
+                      GTEST_NONFATAL_FAILURE_)
+#define GTEST_EXPECT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_NONFATAL_FAILURE_)
+#define GTEST_ASSERT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
+                      GTEST_FATAL_FAILURE_)
+#define GTEST_ASSERT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_FATAL_FAILURE_)
+
+// Define these macros to 1 to omit the definition of the corresponding
+// EXPECT or ASSERT, which clashes with some users' own code.
+
+#if !GTEST_DONT_DEFINE_EXPECT_TRUE
+#define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)
+#endif
+
+#if !GTEST_DONT_DEFINE_EXPECT_FALSE
+#define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_TRUE
+#define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_FALSE
+#define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)
+#endif
+
+// Macros for testing equalities and inequalities.
+//
+//    * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
+//    * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
+//    * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
+//    * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
+//    * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2
+//    * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2
+//
+// When they are not, Google Test prints both the tested expressions and
+// their actual values.  The values must be compatible built-in types,
+// or you will get a compiler error.  By "compatible" we mean that the
+// values can be compared by the respective operator.
+//
+// Note:
+//
+//   1. It is possible to make a user-defined type work with
+//   {ASSERT|EXPECT}_??(), but that requires overloading the
+//   comparison operators and is thus discouraged by the Google C++
+//   Usage Guide.  Therefore, you are advised to use the
+//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
+//   equal.
+//
+//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
+//   pointers (in particular, C strings).  Therefore, if you use it
+//   with two C strings, you are testing how their locations in memory
+//   are related, not how their content is related.  To compare two C
+//   strings by content, use {ASSERT|EXPECT}_STR*().
+//
+//   3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to
+//   {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you
+//   what the actual value is when it fails, and similarly for the
+//   other comparisons.
+//
+//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
+//   evaluate their arguments, which is undefined.
+//
+//   5. These macros evaluate their arguments exactly once.
+//
+// Examples:
+//
+//   EXPECT_NE(Foo(), 5);
+//   EXPECT_EQ(a_pointer, NULL);
+//   ASSERT_LT(i, array_size);
+//   ASSERT_GT(records.size(), 0) << "There is no record left.";
+
+#define EXPECT_EQ(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
+#define EXPECT_NE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define EXPECT_LE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define EXPECT_LT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define EXPECT_GE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define EXPECT_GT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+#define GTEST_ASSERT_EQ(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
+#define GTEST_ASSERT_NE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define GTEST_ASSERT_LE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define GTEST_ASSERT_LT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define GTEST_ASSERT_GE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define GTEST_ASSERT_GT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
+// ASSERT_XY(), which clashes with some users' own code.
+
+#if !GTEST_DONT_DEFINE_ASSERT_EQ
+# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_NE
+# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LE
+# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LT
+# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GE
+# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GT
+# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
+#endif
+
+// C-string Comparisons.  All tests treat NULL and any non-NULL string
+// as different.  Two NULLs are equal.
+//
+//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
+//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
+//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
+//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
+//
+// For wide or narrow string objects, you can use the
+// {ASSERT|EXPECT}_??() macros.
+//
+// Don't depend on the order in which the arguments are evaluated,
+// which is undefined.
+//
+// These macros evaluate their arguments exactly once.
+
+#define EXPECT_STREQ(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
+#define EXPECT_STRNE(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define EXPECT_STRCASEEQ(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
+#define EXPECT_STRCASENE(s1, s2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+#define ASSERT_STREQ(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
+#define ASSERT_STRNE(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define ASSERT_STRCASEEQ(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
+#define ASSERT_STRCASENE(s1, s2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+// Macros for comparing floating-point numbers.
+//
+//    * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2):
+//         Tests that two float values are almost equal.
+//    * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2):
+//         Tests that two double values are almost equal.
+//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
+//         Tests that v1 and v2 are within the given distance to each other.
+//
+// Google Test uses ULP-based comparison to automatically pick a default
+// error bound that is appropriate for the operands.  See the
+// FloatingPoint template class in gtest-internal.h if you are
+// interested in the implementation details.
+
+#define EXPECT_FLOAT_EQ(val1, val2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      val1, val2)
+
+#define EXPECT_DOUBLE_EQ(val1, val2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      val1, val2)
+
+#define ASSERT_FLOAT_EQ(val1, val2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      val1, val2)
+
+#define ASSERT_DOUBLE_EQ(val1, val2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      val1, val2)
+
+#define EXPECT_NEAR(val1, val2, abs_error)\
+  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+#define ASSERT_NEAR(val1, val2, abs_error)\
+  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+// These predicate format functions work on floating-point values, and
+// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
+//
+//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
+                                   float val1, float val2);
+GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                                    double val1, double val2);
+
+
+#if GTEST_OS_WINDOWS
+
+// Macros that test for HRESULT failure and success, these are only useful
+// on Windows, and rely on Windows SDK macros and APIs to compile.
+//
+//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
+//
+// When expr unexpectedly fails or succeeds, Google Test prints the
+// expected result and the actual result with both a human-readable
+// string representation of the error, if available, as well as the
+// hex result code.
+# define EXPECT_HRESULT_SUCCEEDED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define ASSERT_HRESULT_SUCCEEDED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define EXPECT_HRESULT_FAILED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+# define ASSERT_HRESULT_FAILED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+#endif  // GTEST_OS_WINDOWS
+
+// Macros that execute statement and check that it doesn't generate new fatal
+// failures in the current thread.
+//
+//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
+//
+// Examples:
+//
+//   EXPECT_NO_FATAL_FAILURE(Process());
+//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
+//
+#define ASSERT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
+#define EXPECT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
+
+// Causes a trace (including the given source file path and line number,
+// and the given message) to be included in every test failure message generated
+// by code in the scope of the lifetime of an instance of this class. The effect
+// is undone with the destruction of the instance.
+//
+// The message argument can be anything streamable to std::ostream.
+//
+// Example:
+//   testing::ScopedTrace trace("file.cc", 123, "message");
+//
+class GTEST_API_ ScopedTrace {
+ public:
+  // The c'tor pushes the given source file location and message onto
+  // a trace stack maintained by Google Test.
+
+  // Template version. Uses Message() to convert the values into strings.
+  // Slow, but flexible.
+  template <typename T>
+  ScopedTrace(const char* file, int line, const T& message) {
+    PushTrace(file, line, (Message() << message).GetString());
+  }
+
+  // Optimize for some known types.
+  ScopedTrace(const char* file, int line, const char* message) {
+    PushTrace(file, line, message ? message : "(null)");
+  }
+
+  ScopedTrace(const char* file, int line, const std::string& message) {
+    PushTrace(file, line, message);
+  }
+
+  // The d'tor pops the info pushed by the c'tor.
+  //
+  // Note that the d'tor is not virtual in order to be efficient.
+  // Don't inherit from ScopedTrace!
+  ~ScopedTrace();
+
+ private:
+  void PushTrace(const char* file, int line, std::string message);
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
+} GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
+                            // c'tor and d'tor.  Therefore it doesn't
+                            // need to be used otherwise.
+
+// Causes a trace (including the source file path, the current line
+// number, and the given message) to be included in every test failure
+// message generated by code in the current scope.  The effect is
+// undone when the control leaves the current scope.
+//
+// The message argument can be anything streamable to std::ostream.
+//
+// In the implementation, we include the current line number as part
+// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
+// to appear in the same block - as long as they are on different
+// lines.
+//
+// Assuming that each thread maintains its own stack of traces.
+// Therefore, a SCOPED_TRACE() would (correctly) only affect the
+// assertions in its own thread.
+#define SCOPED_TRACE(message) \
+  ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
+    __FILE__, __LINE__, (message))
+
+// Compile-time assertion for type equality.
+// StaticAssertTypeEq<type1, type2>() compiles if and only if type1 and type2
+// are the same type.  The value it returns is not interesting.
+//
+// Instead of making StaticAssertTypeEq a class template, we make it a
+// function template that invokes a helper class template.  This
+// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
+// defining objects of that type.
+//
+// CAVEAT:
+//
+// When used inside a method of a class template,
+// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
+// instantiated.  For example, given:
+//
+//   template <typename T> class Foo {
+//    public:
+//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
+//   };
+//
+// the code:
+//
+//   void Test1() { Foo<bool> foo; }
+//
+// will NOT generate a compiler error, as Foo<bool>::Bar() is never
+// actually instantiated.  Instead, you need:
+//
+//   void Test2() { Foo<bool> foo; foo.Bar(); }
+//
+// to cause a compiler error.
+template <typename T1, typename T2>
+constexpr bool StaticAssertTypeEq() noexcept {
+  static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type");
+  return true;
+}
+
+// Defines a test.
+//
+// The first parameter is the name of the test suite, and the second
+// parameter is the name of the test within the test suite.
+//
+// The convention is to end the test suite name with "Test".  For
+// example, a test suite for the Foo class can be named FooTest.
+//
+// Test code should appear between braces after an invocation of
+// this macro.  Example:
+//
+//   TEST(FooTest, InitializesCorrectly) {
+//     Foo foo;
+//     EXPECT_TRUE(foo.StatusIsOK());
+//   }
+
+// Note that we call GetTestTypeId() instead of GetTypeId<
+// ::testing::Test>() here to get the type ID of testing::Test.  This
+// is to work around a suspected linker bug when using Google Test as
+// a framework on Mac OS X.  The bug causes GetTypeId<
+// ::testing::Test>() to return different values depending on whether
+// the call is from the Google Test framework itself or from user test
+// code.  GetTestTypeId() is guaranteed to always return the same
+// value, as it always calls GetTypeId<>() from the Google Test
+// framework.
+#define GTEST_TEST(test_suite_name, test_name)             \
+  GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
+              ::testing::internal::GetTestTypeId())
+
+// Define this macro to 1 to omit the definition of TEST(), which
+// is a generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_TEST
+#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)
+#endif
+
+// Defines a test that uses a test fixture.
+//
+// The first parameter is the name of the test fixture class, which
+// also doubles as the test suite name.  The second parameter is the
+// name of the test within the test suite.
+//
+// A test fixture class must be declared earlier.  The user should put
+// the test code between braces after using this macro.  Example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     void SetUp() override { b_.AddElement(3); }
+//
+//     Foo a_;
+//     Foo b_;
+//   };
+//
+//   TEST_F(FooTest, InitializesCorrectly) {
+//     EXPECT_TRUE(a_.StatusIsOK());
+//   }
+//
+//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
+//     EXPECT_EQ(a_.size(), 0);
+//     EXPECT_EQ(b_.size(), 1);
+//   }
+#define GTEST_TEST_F(test_fixture, test_name)\
+  GTEST_TEST_(test_fixture, test_name, test_fixture, \
+              ::testing::internal::GetTypeId<test_fixture>())
+#if !GTEST_DONT_DEFINE_TEST_F
+#define TEST_F(test_fixture, test_name) GTEST_TEST_F(test_fixture, test_name)
+#endif
+
+// Returns a path to temporary directory.
+// Tries to determine an appropriate directory for the platform.
+GTEST_API_ std::string TempDir();
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
+
+// Dynamically registers a test with the framework.
+//
+// This is an advanced API only to be used when the `TEST` macros are
+// insufficient. The macros should be preferred when possible, as they avoid
+// most of the complexity of calling this function.
+//
+// The `factory` argument is a factory callable (move-constructible) object or
+// function pointer that creates a new instance of the Test object. It
+// handles ownership to the caller. The signature of the callable is
+// `Fixture*()`, where `Fixture` is the test fixture class for the test. All
+// tests registered with the same `test_suite_name` must return the same
+// fixture type. This is checked at runtime.
+//
+// The framework will infer the fixture class from the factory and will call
+// the `SetUpTestSuite` and `TearDownTestSuite` for it.
+//
+// Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is
+// undefined.
+//
+// Use case example:
+//
+// class MyFixture : public ::testing::Test {
+//  public:
+//   // All of these optional, just like in regular macro usage.
+//   static void SetUpTestSuite() { ... }
+//   static void TearDownTestSuite() { ... }
+//   void SetUp() override { ... }
+//   void TearDown() override { ... }
+// };
+//
+// class MyTest : public MyFixture {
+//  public:
+//   explicit MyTest(int data) : data_(data) {}
+//   void TestBody() override { ... }
+//
+//  private:
+//   int data_;
+// };
+//
+// void RegisterMyTests(const std::vector<int>& values) {
+//   for (int v : values) {
+//     ::testing::RegisterTest(
+//         "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr,
+//         std::to_string(v).c_str(),
+//         __FILE__, __LINE__,
+//         // Important to use the fixture type as the return type here.
+//         [=]() -> MyFixture* { return new MyTest(v); });
+//   }
+// }
+// ...
+// int main(int argc, char** argv) {
+//   ::testing::InitGoogleTest(&argc, argv);
+//   std::vector<int> values_to_test = LoadValuesFromConfig();
+//   RegisterMyTests(values_to_test);
+//   ...
+//   return RUN_ALL_TESTS();
+// }
+//
+template <int&... ExplicitParameterBarrier, typename Factory>
+TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
+                       const char* type_param, const char* value_param,
+                       const char* file, int line, Factory factory) {
+  using TestT = typename std::remove_pointer<decltype(factory())>::type;
+
+  class FactoryImpl : public internal::TestFactoryBase {
+   public:
+    explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
+    Test* CreateTest() override { return factory_(); }
+
+   private:
+    Factory factory_;
+  };
+
+  return internal::MakeAndRegisterTestInfo(
+      test_suite_name, test_name, type_param, value_param,
+      internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
+      internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line),
+      internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line),
+      new FactoryImpl{std::move(factory)});
+}
+
+}  // namespace testing
+
+// Use this function in main() to run all tests.  It returns 0 if all
+// tests are successful, or 1 otherwise.
+//
+// RUN_ALL_TESTS() should be invoked after the command line has been
+// parsed by InitGoogleTest().
+//
+// This function was formerly a macro; thus, it is in the global
+// namespace and has an all-caps name.
+int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
+
+inline int RUN_ALL_TESTS() {
+  return ::testing::UnitTest::GetInstance()->Run();
+}
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_H_
diff --git a/tools/gtest_lib/include/gtest/gtest_pred_impl.h b/tools/gtest_lib/include/gtest/gtest_pred_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..96b36fabf5ad02c90d25255e85541f1ec2125133
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest_pred_impl.h
@@ -0,0 +1,364 @@
+// Copyright 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is AUTOMATICALLY GENERATED on 07/21/2021 by command
+// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
+//
+// Implements a family of generic predicate assertion macros.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+
+#include "gtest/gtest-assertion-result.h"
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+
+// This header implements a family of generic predicate assertion
+// macros:
+//
+//   ASSERT_PRED_FORMAT1(pred_format, v1)
+//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
+//   ...
+//
+// where pred_format is a function or functor that takes n (in the
+// case of ASSERT_PRED_FORMATn) values and their source expression
+// text, and returns a testing::AssertionResult.  See the definition
+// of ASSERT_EQ in gtest.h for an example.
+//
+// If you don't care about formatting, you can use the more
+// restrictive version:
+//
+//   ASSERT_PRED1(pred, v1)
+//   ASSERT_PRED2(pred, v1, v2)
+//   ...
+//
+// where pred is an n-ary function or functor that returns bool,
+// and the values v1, v2, ..., must support the << operator for
+// streaming to std::ostream.
+//
+// We also define the EXPECT_* variations.
+//
+// For now we only support predicates whose arity is at most 5.
+// Please email googletestframework@googlegroups.com if you need
+// support for higher arities.
+
+// GTEST_ASSERT_ is the basic statement to which all of the assertions
+// in this file reduce.  Don't use this in your code.
+
+#define GTEST_ASSERT_(expression, on_failure) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar = (expression)) \
+    ; \
+  else \
+    on_failure(gtest_ar.failure_message())
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1>
+AssertionResult AssertPred1Helper(const char* pred_text,
+                                  const char* e1,
+                                  Pred pred,
+                                  const T1& v1) {
+  if (pred(v1)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, v1), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+#define GTEST_PRED1_(pred, v1, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
+                                             #v1, \
+                                             pred, \
+                                             v1), on_failure)
+
+// Unary predicate assertion macros.
+#define EXPECT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2>
+AssertionResult AssertPred2Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2) {
+  if (pred(v1, v2)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2
+         << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+#define GTEST_PRED2_(pred, v1, v2, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             pred, \
+                                             v1, \
+                                             v2), on_failure)
+
+// Binary predicate assertion macros.
+#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3>
+AssertionResult AssertPred3Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3) {
+  if (pred(v1, v2, v3)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3
+         << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
+         << e3 << " evaluates to " << ::testing::PrintToString(v3);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3), on_failure)
+
+// Ternary predicate assertion macros.
+#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4>
+AssertionResult AssertPred4Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4) {
+  if (pred(v1, v2, v3, v4)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
+         << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
+         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
+         << e4 << " evaluates to " << ::testing::PrintToString(v4);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4), on_failure)
+
+// 4-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5>
+AssertionResult AssertPred5Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  const char* e5,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4,
+                                  const T5& v5) {
+  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
+         << ", " << e5 << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
+         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
+         << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n"
+         << e5 << " evaluates to " << ::testing::PrintToString(v5);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             #v5, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4, \
+                                             v5), on_failure)
+
+// 5-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+
+
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
diff --git a/tools/gtest_lib/include/gtest/gtest_prod.h b/tools/gtest_lib/include/gtest/gtest_prod.h
new file mode 100644
index 0000000000000000000000000000000000000000..b22030a8a8f3f8f9739f8d5f30d52e647d9d438e
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/gtest_prod.h
@@ -0,0 +1,60 @@
+// Copyright 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google C++ Testing and Mocking Framework definitions useful in production
+// code.
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+
+// When you need to test the private or protected members of a class,
+// use the FRIEND_TEST macro to declare your tests as friends of the
+// class.  For example:
+//
+// class MyClass {
+//  private:
+//   void PrivateMethod();
+//   FRIEND_TEST(MyClassTest, PrivateMethodWorks);
+// };
+//
+// class MyClassTest : public testing::Test {
+//   // ...
+// };
+//
+// TEST_F(MyClassTest, PrivateMethodWorks) {
+//   // Can call MyClass::PrivateMethod() here.
+// }
+//
+// Note: The test class must be in the same namespace as the class being tested.
+// For example, putting MyClassTest in an anonymous namespace will not work.
+
+#define FRIEND_TEST(test_case_name, test_name)\
+friend class test_case_name##_##test_name##_Test
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
diff --git a/tools/gtest_lib/include/gtest/internal/custom/README.md b/tools/gtest_lib/include/gtest/internal/custom/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0af3539abf11a93a44fe84c1dd6e7fc8ae1eb4bc
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/custom/README.md
@@ -0,0 +1,58 @@
+# Customization Points
+
+The custom directory is an injection point for custom user configurations.
+
+## Header `gtest.h`
+
+### The following macros can be defined:
+
+*   `GTEST_OS_STACK_TRACE_GETTER_` - The name of an implementation of
+    `OsStackTraceGetterInterface`.
+*   `GTEST_CUSTOM_TEMPDIR_FUNCTION_` - An override for `testing::TempDir()`. See
+    `testing::TempDir` for semantics and signature.
+
+## Header `gtest-port.h`
+
+The following macros can be defined:
+
+### Flag related macros:
+
+*   `GTEST_FLAG(flag_name)`
+*   `GTEST_USE_OWN_FLAGFILE_FLAG_` - Define to 0 when the system provides its
+    own flagfile flag parsing.
+*   `GTEST_DECLARE_bool_(name)`
+*   `GTEST_DECLARE_int32_(name)`
+*   `GTEST_DECLARE_string_(name)`
+*   `GTEST_DEFINE_bool_(name, default_val, doc)`
+*   `GTEST_DEFINE_int32_(name, default_val, doc)`
+*   `GTEST_DEFINE_string_(name, default_val, doc)`
+*   `GTEST_FLAG_GET(flag_name)`
+*   `GTEST_FLAG_SET(flag_name, value)`
+
+### Logging:
+
+*   `GTEST_LOG_(severity)`
+*   `GTEST_CHECK_(condition)`
+*   Functions `LogToStderr()` and `FlushInfoLog()` have to be provided too.
+
+### Threading:
+
+*   `GTEST_HAS_NOTIFICATION_` - Enabled if Notification is already provided.
+*   `GTEST_HAS_MUTEX_AND_THREAD_LOCAL_` - Enabled if `Mutex` and `ThreadLocal`
+    are already provided. Must also provide `GTEST_DECLARE_STATIC_MUTEX_(mutex)`
+    and `GTEST_DEFINE_STATIC_MUTEX_(mutex)`
+*   `GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)`
+*   `GTEST_LOCK_EXCLUDED_(locks)`
+
+### Underlying library support features
+
+*   `GTEST_HAS_CXXABI_H_`
+
+### Exporting API symbols:
+
+*   `GTEST_API_` - Specifier for exported symbols.
+
+## Header `gtest-printers.h`
+
+*   See documentation at `gtest/gtest-printers.h` for details on how to define a
+    custom printer.
diff --git a/tools/gtest_lib/include/gtest/internal/custom/gtest-port.h b/tools/gtest_lib/include/gtest/internal/custom/gtest-port.h
new file mode 100644
index 0000000000000000000000000000000000000000..db02881c0c899a74f07985980afa2e6e98c68875
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/custom/gtest-port.h
@@ -0,0 +1,37 @@
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
diff --git a/tools/gtest_lib/include/gtest/internal/custom/gtest-printers.h b/tools/gtest_lib/include/gtest/internal/custom/gtest-printers.h
new file mode 100644
index 0000000000000000000000000000000000000000..b9495d83783bcde050f5fdc177036aa4880b3fd9
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/custom/gtest-printers.h
@@ -0,0 +1,42 @@
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// This file provides an injection point for custom printers in a local
+// installation of gTest.
+// It will be included from gtest-printers.h and the overrides in this file
+// will be visible to everyone.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
diff --git a/tools/gtest_lib/include/gtest/internal/custom/gtest.h b/tools/gtest_lib/include/gtest/internal/custom/gtest.h
new file mode 100644
index 0000000000000000000000000000000000000000..afaaf17ba28e3beb790a12638cffec8dba5698ea
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/custom/gtest.h
@@ -0,0 +1,37 @@
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
diff --git a/tools/gtest_lib/include/gtest/internal/gtest-death-test-internal.h b/tools/gtest_lib/include/gtest/internal/gtest-death-test-internal.h
new file mode 100644
index 0000000000000000000000000000000000000000..128e0f4c28c4afb335e509f06c8c7615e35a5623
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/gtest-death-test-internal.h
@@ -0,0 +1,305 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines internal utilities needed for implementing
+// death tests.  They are subject to change without notice.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+
+#include "gtest/gtest-matchers.h"
+#include "gtest/internal/gtest-internal.h"
+
+#include <stdio.h>
+#include <memory>
+
+GTEST_DECLARE_string_(internal_run_death_test);
+
+namespace testing {
+namespace internal {
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kDeathTestStyleFlag[] = "death_test_style";
+const char kDeathTestUseFork[] = "death_test_use_fork";
+const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
+
+#if GTEST_HAS_DEATH_TEST
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// DeathTest is a class that hides much of the complexity of the
+// GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
+// returns a concrete class that depends on the prevailing death test
+// style, as defined by the --gtest_death_test_style and/or
+// --gtest_internal_run_death_test flags.
+
+// In describing the results of death tests, these terms are used with
+// the corresponding definitions:
+//
+// exit status:  The integer exit information in the format specified
+//               by wait(2)
+// exit code:    The integer code passed to exit(3), _exit(2), or
+//               returned from main()
+class GTEST_API_ DeathTest {
+ public:
+  // Create returns false if there was an error determining the
+  // appropriate action to take for the current death test; for example,
+  // if the gtest_death_test_style flag is set to an invalid value.
+  // The LastMessage method will return a more detailed message in that
+  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
+  // argument is set.  If the death test should be skipped, the pointer
+  // is set to NULL; otherwise, it is set to the address of a new concrete
+  // DeathTest object that controls the execution of the current test.
+  static bool Create(const char* statement, Matcher<const std::string&> matcher,
+                     const char* file, int line, DeathTest** test);
+  DeathTest();
+  virtual ~DeathTest() { }
+
+  // A helper class that aborts a death test when it's deleted.
+  class ReturnSentinel {
+   public:
+    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
+    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
+   private:
+    DeathTest* const test_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
+  } GTEST_ATTRIBUTE_UNUSED_;
+
+  // An enumeration of possible roles that may be taken when a death
+  // test is encountered.  EXECUTE means that the death test logic should
+  // be executed immediately.  OVERSEE means that the program should prepare
+  // the appropriate environment for a child process to execute the death
+  // test, then wait for it to complete.
+  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
+
+  // An enumeration of the three reasons that a test might be aborted.
+  enum AbortReason {
+    TEST_ENCOUNTERED_RETURN_STATEMENT,
+    TEST_THREW_EXCEPTION,
+    TEST_DID_NOT_DIE
+  };
+
+  // Assumes one of the above roles.
+  virtual TestRole AssumeRole() = 0;
+
+  // Waits for the death test to finish and returns its status.
+  virtual int Wait() = 0;
+
+  // Returns true if the death test passed; that is, the test process
+  // exited during the test, its exit status matches a user-supplied
+  // predicate, and its stderr output matches a user-supplied regular
+  // expression.
+  // The user-supplied predicate may be a macro expression rather
+  // than a function pointer or functor, or else Wait and Passed could
+  // be combined.
+  virtual bool Passed(bool exit_status_ok) = 0;
+
+  // Signals that the death test did not die as expected.
+  virtual void Abort(AbortReason reason) = 0;
+
+  // Returns a human-readable outcome message regarding the outcome of
+  // the last death test.
+  static const char* LastMessage();
+
+  static void set_last_death_test_message(const std::string& message);
+
+ private:
+  // A string containing a description of the outcome of the last death test.
+  static std::string last_death_test_message_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
+};
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// Factory interface for death tests.  May be mocked out for testing.
+class DeathTestFactory {
+ public:
+  virtual ~DeathTestFactory() { }
+  virtual bool Create(const char* statement,
+                      Matcher<const std::string&> matcher, const char* file,
+                      int line, DeathTest** test) = 0;
+};
+
+// A concrete DeathTestFactory implementation for normal use.
+class DefaultDeathTestFactory : public DeathTestFactory {
+ public:
+  bool Create(const char* statement, Matcher<const std::string&> matcher,
+              const char* file, int line, DeathTest** test) override;
+};
+
+// Returns true if exit_status describes a process that was terminated
+// by a signal, or exited normally with a nonzero exit code.
+GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
+
+// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
+// and interpreted as a regex (rather than an Eq matcher) for legacy
+// compatibility.
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(
+    ::testing::internal::RE regex) {
+  return ContainsRegex(regex.pattern());
+}
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
+  return ContainsRegex(regex);
+}
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(
+    const ::std::string& regex) {
+  return ContainsRegex(regex);
+}
+
+// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
+// used directly.
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(
+    Matcher<const ::std::string&> matcher) {
+  return matcher;
+}
+
+// Traps C++ exceptions escaping statement and reports them as test
+// failures. Note that trapping SEH exceptions is not implemented here.
+# if GTEST_HAS_EXCEPTIONS
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  try { \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+  } catch (const ::std::exception& gtest_exception) { \
+    fprintf(\
+        stderr, \
+        "\n%s: Caught std::exception-derived exception escaping the " \
+        "death test statement. Exception message: %s\n", \
+        ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
+        gtest_exception.what()); \
+    fflush(stderr); \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  } catch (...) { \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  }
+
+# else
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+
+# endif
+
+// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
+// ASSERT_EXIT*, and EXPECT_EXIT*.
+#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail)        \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
+  if (::testing::internal::AlwaysTrue()) {                                     \
+    ::testing::internal::DeathTest* gtest_dt;                                  \
+    if (!::testing::internal::DeathTest::Create(                               \
+            #statement,                                                        \
+            ::testing::internal::MakeDeathTestMatcher(regex_or_matcher),       \
+            __FILE__, __LINE__, &gtest_dt)) {                                  \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \
+    }                                                                          \
+    if (gtest_dt != nullptr) {                                                 \
+      std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
+      switch (gtest_dt->AssumeRole()) {                                        \
+        case ::testing::internal::DeathTest::OVERSEE_TEST:                     \
+          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \
+            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                  \
+          }                                                                    \
+          break;                                                               \
+        case ::testing::internal::DeathTest::EXECUTE_TEST: {                   \
+          ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel(       \
+              gtest_dt);                                                       \
+          GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt);            \
+          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);   \
+          break;                                                               \
+        }                                                                      \
+      }                                                                        \
+    }                                                                          \
+  } else                                                                       \
+    GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__)                                \
+        : fail(::testing::internal::DeathTest::LastMessage())
+// The symbol "fail" here expands to something into which a message
+// can be streamed.
+
+// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
+// NDEBUG mode. In this case we need the statements to be executed and the macro
+// must accept a streamed message even though the message is never printed.
+// The regex object is not evaluated, but it is used to prevent "unused"
+// warnings and to avoid an expression that doesn't compile in debug mode.
+#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher)    \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                  \
+  if (::testing::internal::AlwaysTrue()) {                       \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);   \
+  } else if (!::testing::internal::AlwaysTrue()) {               \
+    ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
+  } else                                                         \
+    ::testing::Message()
+
+// A class representing the parsed contents of the
+// --gtest_internal_run_death_test flag, as it existed when
+// RUN_ALL_TESTS was called.
+class InternalRunDeathTestFlag {
+ public:
+  InternalRunDeathTestFlag(const std::string& a_file,
+                           int a_line,
+                           int an_index,
+                           int a_write_fd)
+      : file_(a_file), line_(a_line), index_(an_index),
+        write_fd_(a_write_fd) {}
+
+  ~InternalRunDeathTestFlag() {
+    if (write_fd_ >= 0)
+      posix::Close(write_fd_);
+  }
+
+  const std::string& file() const { return file_; }
+  int line() const { return line_; }
+  int index() const { return index_; }
+  int write_fd() const { return write_fd_; }
+
+ private:
+  std::string file_;
+  int line_;
+  int index_;
+  int write_fd_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
+};
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
diff --git a/tools/gtest_lib/include/gtest/internal/gtest-filepath.h b/tools/gtest_lib/include/gtest/internal/gtest-filepath.h
new file mode 100644
index 0000000000000000000000000000000000000000..4dfe2e22272d394a06ba29639cba0b91953b1362
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/gtest-filepath.h
@@ -0,0 +1,213 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Test filepath utilities
+//
+// This header file declares classes and functions used internally by
+// Google Test.  They are subject to change without notice.
+//
+// This file is #included in gtest/internal/gtest-internal.h.
+// Do not include this header file separately!
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+
+#include "gtest/internal/gtest-string.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+namespace internal {
+
+// FilePath - a class for file and directory pathname manipulation which
+// handles platform-specific conventions (like the pathname separator).
+// Used for helper functions for naming files in a directory for xml output.
+// Except for Set methods, all methods are const or static, which provides an
+// "immutable value object" -- useful for peace of mind.
+// A FilePath with a value ending in a path separator ("like/this/") represents
+// a directory, otherwise it is assumed to represent a file. In either case,
+// it may or may not represent an actual file or directory in the file system.
+// Names are NOT checked for syntax correctness -- no checking for illegal
+// characters, malformed paths, etc.
+
+class GTEST_API_ FilePath {
+ public:
+  FilePath() : pathname_("") { }
+  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
+
+  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
+    Normalize();
+  }
+
+  FilePath& operator=(const FilePath& rhs) {
+    Set(rhs);
+    return *this;
+  }
+
+  void Set(const FilePath& rhs) {
+    pathname_ = rhs.pathname_;
+  }
+
+  const std::string& string() const { return pathname_; }
+  const char* c_str() const { return pathname_.c_str(); }
+
+  // Returns the current working directory, or "" if unsuccessful.
+  static FilePath GetCurrentDir();
+
+  // Given directory = "dir", base_name = "test", number = 0,
+  // extension = "xml", returns "dir/test.xml". If number is greater
+  // than zero (e.g., 12), returns "dir/test_12.xml".
+  // On Windows platform, uses \ as the separator rather than /.
+  static FilePath MakeFileName(const FilePath& directory,
+                               const FilePath& base_name,
+                               int number,
+                               const char* extension);
+
+  // Given directory = "dir", relative_path = "test.xml",
+  // returns "dir/test.xml".
+  // On Windows, uses \ as the separator rather than /.
+  static FilePath ConcatPaths(const FilePath& directory,
+                              const FilePath& relative_path);
+
+  // Returns a pathname for a file that does not currently exist. The pathname
+  // will be directory/base_name.extension or
+  // directory/base_name_<number>.extension if directory/base_name.extension
+  // already exists. The number will be incremented until a pathname is found
+  // that does not already exist.
+  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+  // There could be a race condition if two or more processes are calling this
+  // function at the same time -- they could both pick the same filename.
+  static FilePath GenerateUniqueFileName(const FilePath& directory,
+                                         const FilePath& base_name,
+                                         const char* extension);
+
+  // Returns true if and only if the path is "".
+  bool IsEmpty() const { return pathname_.empty(); }
+
+  // If input name has a trailing separator character, removes it and returns
+  // the name, otherwise return the name string unmodified.
+  // On Windows platform, uses \ as the separator, other platforms use /.
+  FilePath RemoveTrailingPathSeparator() const;
+
+  // Returns a copy of the FilePath with the directory part removed.
+  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
+  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
+  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
+  // returns an empty FilePath ("").
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveDirectoryName() const;
+
+  // RemoveFileName returns the directory path with the filename removed.
+  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveFileName() const;
+
+  // Returns a copy of the FilePath with the case-insensitive extension removed.
+  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+  // FilePath("dir/file"). If a case-insensitive extension is not
+  // found, returns a copy of the original FilePath.
+  FilePath RemoveExtension(const char* extension) const;
+
+  // Creates directories so that path exists. Returns true if successful or if
+  // the directories already exist; returns false if unable to create
+  // directories for any reason. Will also return false if the FilePath does
+  // not represent a directory (that is, it doesn't end with a path separator).
+  bool CreateDirectoriesRecursively() const;
+
+  // Create the directory so that path exists. Returns true if successful or
+  // if the directory already exists; returns false if unable to create the
+  // directory for any reason, including if the parent directory does not
+  // exist. Not named "CreateDirectory" because that's a macro on Windows.
+  bool CreateFolder() const;
+
+  // Returns true if FilePath describes something in the file-system,
+  // either a file, directory, or whatever, and that something exists.
+  bool FileOrDirectoryExists() const;
+
+  // Returns true if pathname describes a directory in the file-system
+  // that exists.
+  bool DirectoryExists() const;
+
+  // Returns true if FilePath ends with a path separator, which indicates that
+  // it is intended to represent a directory. Returns false otherwise.
+  // This does NOT check that a directory (or file) actually exists.
+  bool IsDirectory() const;
+
+  // Returns true if pathname describes a root directory. (Windows has one
+  // root directory per disk drive.)
+  bool IsRootDirectory() const;
+
+  // Returns true if pathname describes an absolute path.
+  bool IsAbsolutePath() const;
+
+ private:
+  // Replaces multiple consecutive separators with a single separator.
+  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
+  // redundancies that might be in a pathname involving "." or "..".
+  //
+  // A pathname with multiple consecutive separators may occur either through
+  // user error or as a result of some scripts or APIs that generate a pathname
+  // with a trailing separator. On other platforms the same API or script
+  // may NOT generate a pathname with a trailing "/". Then elsewhere that
+  // pathname may have another "/" and pathname components added to it,
+  // without checking for the separator already being there.
+  // The script language and operating system may allow paths like "foo//bar"
+  // but some of the functions in FilePath will not handle that correctly. In
+  // particular, RemoveTrailingPathSeparator() only removes one separator, and
+  // it is called in CreateDirectoriesRecursively() assuming that it will change
+  // a pathname from directory syntax (trailing separator) to filename syntax.
+  //
+  // On Windows this method also replaces the alternate path separator '/' with
+  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
+  // "bar\\foo".
+
+  void Normalize();
+
+  // Returns a pointer to the last occurrence of a valid path separator in
+  // the FilePath. On Windows, for example, both '/' and '\' are valid path
+  // separators. Returns NULL if no path separator was found.
+  const char* FindLastPathSeparator() const;
+
+  std::string pathname_;
+};  // class FilePath
+
+}  // namespace internal
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
diff --git a/tools/gtest_lib/include/gtest/internal/gtest-internal.h b/tools/gtest_lib/include/gtest/internal/gtest-internal.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc15e94785d482b40e219ce4e1c16c8ca08dde5e
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/gtest-internal.h
@@ -0,0 +1,1562 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file declares functions and macros used internally by
+// Google Test.  They are subject to change without notice.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+
+#include "gtest/internal/gtest-port.h"
+
+#if GTEST_OS_LINUX
+# include <stdlib.h>
+# include <sys/types.h>
+# include <sys/wait.h>
+# include <unistd.h>
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
+#include <ctype.h>
+#include <float.h>
+#include <string.h>
+#include <cstdint>
+#include <iomanip>
+#include <limits>
+#include <map>
+#include <set>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-filepath.h"
+#include "gtest/internal/gtest-string.h"
+#include "gtest/internal/gtest-type-util.h"
+
+// Due to C++ preprocessor weirdness, we need double indirection to
+// concatenate two tokens when one of them is __LINE__.  Writing
+//
+//   foo ## __LINE__
+//
+// will result in the token foo__LINE__, instead of foo followed by
+// the current line number.  For more details, see
+// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
+#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
+#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
+
+// Stringifies its argument.
+// Work around a bug in visual studio which doesn't accept code like this:
+//
+//   #define GTEST_STRINGIFY_(name) #name
+//   #define MACRO(a, b, c) ... GTEST_STRINGIFY_(a) ...
+//   MACRO(, x, y)
+//
+// Complaining about the argument to GTEST_STRINGIFY_ being empty.
+// This is allowed by the spec.
+#define GTEST_STRINGIFY_HELPER_(name, ...) #name
+#define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, )
+
+namespace proto2 {
+class MessageLite;
+}
+
+namespace testing {
+
+// Forward declarations.
+
+class AssertionResult;                 // Result of an assertion.
+class Message;                         // Represents a failure message.
+class Test;                            // Represents a test.
+class TestInfo;                        // Information about a test.
+class TestPartResult;                  // Result of a test part.
+class UnitTest;                        // A collection of test suites.
+
+template <typename T>
+::std::string PrintToString(const T& value);
+
+namespace internal {
+
+struct TraceInfo;                      // Information about a trace point.
+class TestInfoImpl;                    // Opaque implementation of TestInfo
+class UnitTestImpl;                    // Opaque implementation of UnitTest
+
+// The text used in failure messages to indicate the start of the
+// stack trace.
+GTEST_API_ extern const char kStackTraceMarker[];
+
+// An IgnoredValue object can be implicitly constructed from ANY value.
+class IgnoredValue {
+  struct Sink {};
+ public:
+  // This constructor template allows any value to be implicitly
+  // converted to IgnoredValue.  The object has no data member and
+  // doesn't try to remember anything about the argument.  We
+  // deliberately omit the 'explicit' keyword in order to allow the
+  // conversion to be implicit.
+  // Disable the conversion if T already has a magical conversion operator.
+  // Otherwise we get ambiguity.
+  template <typename T,
+            typename std::enable_if<!std::is_convertible<T, Sink>::value,
+                                    int>::type = 0>
+  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
+};
+
+// Appends the user-supplied message to the Google-Test-generated message.
+GTEST_API_ std::string AppendUserMessage(
+    const std::string& gtest_msg, const Message& user_msg);
+
+#if GTEST_HAS_EXCEPTIONS
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \
+/* an exported class was derived from a class that was not exported */)
+
+// This exception is thrown by (and only by) a failed Google Test
+// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
+// are enabled).  We derive it from std::runtime_error, which is for
+// errors presumably detectable only at run time.  Since
+// std::runtime_error inherits from std::exception, many testing
+// frameworks know how to extract and print the message inside it.
+class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
+ public:
+  explicit GoogleTestFailureException(const TestPartResult& failure);
+};
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4275
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+namespace edit_distance {
+// Returns the optimal edits to go from 'left' to 'right'.
+// All edits cost the same, with replace having lower priority than
+// add/remove.
+// Simple implementation of the Wagner-Fischer algorithm.
+// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
+enum EditType { kMatch, kAdd, kRemove, kReplace };
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<size_t>& left, const std::vector<size_t>& right);
+
+// Same as above, but the input is represented as strings.
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<std::string>& left,
+    const std::vector<std::string>& right);
+
+// Create a diff of the input strings in Unified diff format.
+GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
+                                         const std::vector<std::string>& right,
+                                         size_t context = 2);
+
+}  // namespace edit_distance
+
+// Calculate the diff between 'left' and 'right' and return it in unified diff
+// format.
+// If not null, stores in 'total_line_count' the total number of lines found
+// in left + right.
+GTEST_API_ std::string DiffStrings(const std::string& left,
+                                   const std::string& right,
+                                   size_t* total_line_count);
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   expected_expression: "foo"
+//   actual_expression:   "bar"
+//   expected_value:      "5"
+//   actual_value:        "6"
+//
+// The ignoring_case parameter is true if and only if the assertion is a
+// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
+// be inserted into the message.
+GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
+                                     const char* actual_expression,
+                                     const std::string& expected_value,
+                                     const std::string& actual_value,
+                                     bool ignoring_case);
+
+// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
+GTEST_API_ std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value);
+
+// This template class represents an IEEE floating-point number
+// (either single-precision or double-precision, depending on the
+// template parameters).
+//
+// The purpose of this class is to do more sophisticated number
+// comparison.  (Due to round-off error, etc, it's very unlikely that
+// two floating-points will be equal exactly.  Hence a naive
+// comparison by the == operation often doesn't work.)
+//
+// Format of IEEE floating-point:
+//
+//   The most-significant bit being the leftmost, an IEEE
+//   floating-point looks like
+//
+//     sign_bit exponent_bits fraction_bits
+//
+//   Here, sign_bit is a single bit that designates the sign of the
+//   number.
+//
+//   For float, there are 8 exponent bits and 23 fraction bits.
+//
+//   For double, there are 11 exponent bits and 52 fraction bits.
+//
+//   More details can be found at
+//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+template <typename RawType>
+class FloatingPoint {
+ public:
+  // Defines the unsigned integer type that has the same size as the
+  // floating point number.
+  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
+
+  // Constants.
+
+  // # of bits in a number.
+  static const size_t kBitCount = 8*sizeof(RawType);
+
+  // # of fraction bits in a number.
+  static const size_t kFractionBitCount =
+    std::numeric_limits<RawType>::digits - 1;
+
+  // # of exponent bits in a number.
+  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
+
+  // The mask for the sign bit.
+  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
+
+  // The mask for the fraction bits.
+  static const Bits kFractionBitMask =
+    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
+
+  // The mask for the exponent bits.
+  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
+
+  // How many ULP's (Units in the Last Place) we want to tolerate when
+  // comparing two numbers.  The larger the value, the more error we
+  // allow.  A 0 value means that two numbers must be exactly the same
+  // to be considered equal.
+  //
+  // The maximum error of a single floating-point operation is 0.5
+  // units in the last place.  On Intel CPU's, all floating-point
+  // calculations are done with 80-bit precision, while double has 64
+  // bits.  Therefore, 4 should be enough for ordinary use.
+  //
+  // See the following article for more details on ULP:
+  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+  static const uint32_t kMaxUlps = 4;
+
+  // Constructs a FloatingPoint from a raw floating-point number.
+  //
+  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
+  // around may change its bits, although the new value is guaranteed
+  // to be also a NAN.  Therefore, don't expect this constructor to
+  // preserve the bits in x when x is a NAN.
+  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
+
+  // Static methods
+
+  // Reinterprets a bit pattern as a floating-point number.
+  //
+  // This function is needed to test the AlmostEquals() method.
+  static RawType ReinterpretBits(const Bits bits) {
+    FloatingPoint fp(0);
+    fp.u_.bits_ = bits;
+    return fp.u_.value_;
+  }
+
+  // Returns the floating-point number that represent positive infinity.
+  static RawType Infinity() {
+    return ReinterpretBits(kExponentBitMask);
+  }
+
+  // Returns the maximum representable finite floating-point number.
+  static RawType Max();
+
+  // Non-static methods
+
+  // Returns the bits that represents this number.
+  const Bits &bits() const { return u_.bits_; }
+
+  // Returns the exponent bits of this number.
+  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
+
+  // Returns the fraction bits of this number.
+  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
+
+  // Returns the sign bit of this number.
+  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
+
+  // Returns true if and only if this is NAN (not a number).
+  bool is_nan() const {
+    // It's a NAN if the exponent bits are all ones and the fraction
+    // bits are not entirely zeros.
+    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
+  }
+
+  // Returns true if and only if this number is at most kMaxUlps ULP's away
+  // from rhs.  In particular, this function:
+  //
+  //   - returns false if either number is (or both are) NAN.
+  //   - treats really large numbers as almost equal to infinity.
+  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
+  bool AlmostEquals(const FloatingPoint& rhs) const {
+    // The IEEE standard says that any comparison operation involving
+    // a NAN must return false.
+    if (is_nan() || rhs.is_nan()) return false;
+
+    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
+        <= kMaxUlps;
+  }
+
+ private:
+  // The data type used to store the actual floating-point number.
+  union FloatingPointUnion {
+    RawType value_;  // The raw floating-point number.
+    Bits bits_;      // The bits that represent the number.
+  };
+
+  // Converts an integer from the sign-and-magnitude representation to
+  // the biased representation.  More precisely, let N be 2 to the
+  // power of (kBitCount - 1), an integer x is represented by the
+  // unsigned number x + N.
+  //
+  // For instance,
+  //
+  //   -N + 1 (the most negative number representable using
+  //          sign-and-magnitude) is represented by 1;
+  //   0      is represented by N; and
+  //   N - 1  (the biggest number representable using
+  //          sign-and-magnitude) is represented by 2N - 1.
+  //
+  // Read http://en.wikipedia.org/wiki/Signed_number_representations
+  // for more details on signed number representations.
+  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
+    if (kSignBitMask & sam) {
+      // sam represents a negative number.
+      return ~sam + 1;
+    } else {
+      // sam represents a positive number.
+      return kSignBitMask | sam;
+    }
+  }
+
+  // Given two numbers in the sign-and-magnitude representation,
+  // returns the distance between them as an unsigned number.
+  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
+                                                     const Bits &sam2) {
+    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
+    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
+    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
+  }
+
+  FloatingPointUnion u_;
+};
+
+// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
+// macro defined by <windows.h>.
+template <>
+inline float FloatingPoint<float>::Max() { return FLT_MAX; }
+template <>
+inline double FloatingPoint<double>::Max() { return DBL_MAX; }
+
+// Typedefs the instances of the FloatingPoint template class that we
+// care to use.
+typedef FloatingPoint<float> Float;
+typedef FloatingPoint<double> Double;
+
+// In order to catch the mistake of putting tests that use different
+// test fixture classes in the same test suite, we need to assign
+// unique IDs to fixture classes and compare them.  The TypeId type is
+// used to hold such IDs.  The user should treat TypeId as an opaque
+// type: the only operation allowed on TypeId values is to compare
+// them for equality using the == operator.
+typedef const void* TypeId;
+
+template <typename T>
+class TypeIdHelper {
+ public:
+  // dummy_ must not have a const type.  Otherwise an overly eager
+  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
+  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
+  static bool dummy_;
+};
+
+template <typename T>
+bool TypeIdHelper<T>::dummy_ = false;
+
+// GetTypeId<T>() returns the ID of type T.  Different values will be
+// returned for different types.  Calling the function twice with the
+// same type argument is guaranteed to return the same ID.
+template <typename T>
+TypeId GetTypeId() {
+  // The compiler is required to allocate a different
+  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
+  // the template.  Therefore, the address of dummy_ is guaranteed to
+  // be unique.
+  return &(TypeIdHelper<T>::dummy_);
+}
+
+// Returns the type ID of ::testing::Test.  Always call this instead
+// of GetTypeId< ::testing::Test>() to get the type ID of
+// ::testing::Test, as the latter may give the wrong result due to a
+// suspected linker bug when compiling Google Test as a Mac OS X
+// framework.
+GTEST_API_ TypeId GetTestTypeId();
+
+// Defines the abstract factory interface that creates instances
+// of a Test object.
+class TestFactoryBase {
+ public:
+  virtual ~TestFactoryBase() {}
+
+  // Creates a test instance to run. The instance is both created and destroyed
+  // within TestInfoImpl::Run()
+  virtual Test* CreateTest() = 0;
+
+ protected:
+  TestFactoryBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
+};
+
+// This class provides implementation of TeastFactoryBase interface.
+// It is used in TEST and TEST_F macros.
+template <class TestClass>
+class TestFactoryImpl : public TestFactoryBase {
+ public:
+  Test* CreateTest() override { return new TestClass; }
+};
+
+#if GTEST_OS_WINDOWS
+
+// Predicate-formatters for implementing the HRESULT checking macros
+// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
+// We pass a long instead of HRESULT to avoid causing an
+// include dependency for the HRESULT type.
+GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
+                                            long hr);  // NOLINT
+GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
+                                            long hr);  // NOLINT
+
+#endif  // GTEST_OS_WINDOWS
+
+// Types of SetUpTestSuite() and TearDownTestSuite() functions.
+using SetUpTestSuiteFunc = void (*)();
+using TearDownTestSuiteFunc = void (*)();
+
+struct CodeLocation {
+  CodeLocation(const std::string& a_file, int a_line)
+      : file(a_file), line(a_line) {}
+
+  std::string file;
+  int line;
+};
+
+//  Helper to identify which setup function for TestCase / TestSuite to call.
+//  Only one function is allowed, either TestCase or TestSute but not both.
+
+// Utility functions to help SuiteApiResolver
+using SetUpTearDownSuiteFuncType = void (*)();
+
+inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
+    SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) {
+  return a == def ? nullptr : a;
+}
+
+template <typename T>
+//  Note that SuiteApiResolver inherits from T because
+//  SetUpTestSuite()/TearDownTestSuite() could be protected. This way
+//  SuiteApiResolver can access them.
+struct SuiteApiResolver : T {
+  // testing::Test is only forward declared at this point. So we make it a
+  // dependent class for the compiler to be OK with it.
+  using Test =
+      typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type;
+
+  static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
+                                                        int line_num) {
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+    SetUpTearDownSuiteFuncType test_case_fp =
+        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
+    SetUpTearDownSuiteFuncType test_suite_fp =
+        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
+
+    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
+        << "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
+           "make sure there is only one present at "
+        << filename << ":" << line_num;
+
+    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
+#else
+    (void)(filename);
+    (void)(line_num);
+    return &T::SetUpTestSuite;
+#endif
+  }
+
+  static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
+                                                           int line_num) {
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+    SetUpTearDownSuiteFuncType test_case_fp =
+        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
+    SetUpTearDownSuiteFuncType test_suite_fp =
+        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
+
+    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
+        << "Test can not provide both TearDownTestSuite and TearDownTestCase,"
+           " please make sure there is only one present at"
+        << filename << ":" << line_num;
+
+    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
+#else
+    (void)(filename);
+    (void)(line_num);
+    return &T::TearDownTestSuite;
+#endif
+  }
+};
+
+// Creates a new TestInfo object and registers it with Google Test;
+// returns the created object.
+//
+// Arguments:
+//
+//   test_suite_name:  name of the test suite
+//   name:             name of the test
+//   type_param:       the name of the test's type parameter, or NULL if
+//                     this is not a typed or a type-parameterized test.
+//   value_param:      text representation of the test's value parameter,
+//                     or NULL if this is not a type-parameterized test.
+//   code_location:    code location where the test is defined
+//   fixture_class_id: ID of the test fixture class
+//   set_up_tc:        pointer to the function that sets up the test suite
+//   tear_down_tc:     pointer to the function that tears down the test suite
+//   factory:          pointer to the factory that creates a test object.
+//                     The newly created TestInfo instance will assume
+//                     ownership of the factory object.
+GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
+    const char* test_suite_name, const char* name, const char* type_param,
+    const char* value_param, CodeLocation code_location,
+    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
+    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);
+
+// If *pstr starts with the given prefix, modifies *pstr to be right
+// past the prefix and returns true; otherwise leaves *pstr unchanged
+// and returns false.  None of pstr, *pstr, and prefix can be NULL.
+GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// State of the definition of a type-parameterized test suite.
+class GTEST_API_ TypedTestSuitePState {
+ public:
+  TypedTestSuitePState() : registered_(false) {}
+
+  // Adds the given test name to defined_test_names_ and return true
+  // if the test suite hasn't been registered; otherwise aborts the
+  // program.
+  bool AddTestName(const char* file, int line, const char* case_name,
+                   const char* test_name) {
+    if (registered_) {
+      fprintf(stderr,
+              "%s Test %s must be defined before "
+              "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
+              FormatFileLocation(file, line).c_str(), test_name, case_name);
+      fflush(stderr);
+      posix::Abort();
+    }
+    registered_tests_.insert(
+        ::std::make_pair(test_name, CodeLocation(file, line)));
+    return true;
+  }
+
+  bool TestExists(const std::string& test_name) const {
+    return registered_tests_.count(test_name) > 0;
+  }
+
+  const CodeLocation& GetCodeLocation(const std::string& test_name) const {
+    RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
+    GTEST_CHECK_(it != registered_tests_.end());
+    return it->second;
+  }
+
+  // Verifies that registered_tests match the test names in
+  // defined_test_names_; returns registered_tests if successful, or
+  // aborts the program otherwise.
+  const char* VerifyRegisteredTestNames(const char* test_suite_name,
+                                        const char* file, int line,
+                                        const char* registered_tests);
+
+ private:
+  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
+
+  bool registered_;
+  RegisteredTestsMap registered_tests_;
+};
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+using TypedTestCasePState = TypedTestSuitePState;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// Skips to the first non-space char after the first comma in 'str';
+// returns NULL if no comma is found in 'str'.
+inline const char* SkipComma(const char* str) {
+  const char* comma = strchr(str, ',');
+  if (comma == nullptr) {
+    return nullptr;
+  }
+  while (IsSpace(*(++comma))) {}
+  return comma;
+}
+
+// Returns the prefix of 'str' before the first comma in it; returns
+// the entire string if it contains no comma.
+inline std::string GetPrefixUntilComma(const char* str) {
+  const char* comma = strchr(str, ',');
+  return comma == nullptr ? str : std::string(str, comma);
+}
+
+// Splits a given string on a given delimiter, populating a given
+// vector with the fields.
+void SplitString(const ::std::string& str, char delimiter,
+                 ::std::vector< ::std::string>* dest);
+
+// The default argument to the template below for the case when the user does
+// not provide a name generator.
+struct DefaultNameGenerator {
+  template <typename T>
+  static std::string GetName(int i) {
+    return StreamableToString(i);
+  }
+};
+
+template <typename Provided = DefaultNameGenerator>
+struct NameGeneratorSelector {
+  typedef Provided type;
+};
+
+template <typename NameGenerator>
+void GenerateNamesRecursively(internal::None, std::vector<std::string>*, int) {}
+
+template <typename NameGenerator, typename Types>
+void GenerateNamesRecursively(Types, std::vector<std::string>* result, int i) {
+  result->push_back(NameGenerator::template GetName<typename Types::Head>(i));
+  GenerateNamesRecursively<NameGenerator>(typename Types::Tail(), result,
+                                          i + 1);
+}
+
+template <typename NameGenerator, typename Types>
+std::vector<std::string> GenerateNames() {
+  std::vector<std::string> result;
+  GenerateNamesRecursively<NameGenerator>(Types(), &result, 0);
+  return result;
+}
+
+// TypeParameterizedTest<Fixture, TestSel, Types>::Register()
+// registers a list of type-parameterized tests with Google Test.  The
+// return value is insignificant - we just need to return something
+// such that we can call this function in a namespace scope.
+//
+// Implementation note: The GTEST_TEMPLATE_ macro declares a template
+// template parameter.  It's defined in gtest-type-util.h.
+template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
+class TypeParameterizedTest {
+ public:
+  // 'index' is the index of the test in the type list 'Types'
+  // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
+  // Types).  Valid values for 'index' are [0, N - 1] where N is the
+  // length of Types.
+  static bool Register(const char* prefix, const CodeLocation& code_location,
+                       const char* case_name, const char* test_names, int index,
+                       const std::vector<std::string>& type_names =
+                           GenerateNames<DefaultNameGenerator, Types>()) {
+    typedef typename Types::Head Type;
+    typedef Fixture<Type> FixtureClass;
+    typedef typename GTEST_BIND_(TestSel, Type) TestClass;
+
+    // First, registers the first type-parameterized test in the type
+    // list.
+    MakeAndRegisterTestInfo(
+        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
+         "/" + type_names[static_cast<size_t>(index)])
+            .c_str(),
+        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
+        GetTypeName<Type>().c_str(),
+        nullptr,  // No value parameter.
+        code_location, GetTypeId<FixtureClass>(),
+        SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite(
+            code_location.file.c_str(), code_location.line),
+        SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite(
+            code_location.file.c_str(), code_location.line),
+        new TestFactoryImpl<TestClass>);
+
+    // Next, recurses (at compile time) with the tail of the type list.
+    return TypeParameterizedTest<Fixture, TestSel,
+                                 typename Types::Tail>::Register(prefix,
+                                                                 code_location,
+                                                                 case_name,
+                                                                 test_names,
+                                                                 index + 1,
+                                                                 type_names);
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, class TestSel>
+class TypeParameterizedTest<Fixture, TestSel, internal::None> {
+ public:
+  static bool Register(const char* /*prefix*/, const CodeLocation&,
+                       const char* /*case_name*/, const char* /*test_names*/,
+                       int /*index*/,
+                       const std::vector<std::string>& =
+                           std::vector<std::string>() /*type_names*/) {
+    return true;
+  }
+};
+
+GTEST_API_ void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
+                                                   CodeLocation code_location);
+GTEST_API_ void RegisterTypeParameterizedTestSuiteInstantiation(
+    const char* case_name);
+
+// TypeParameterizedTestSuite<Fixture, Tests, Types>::Register()
+// registers *all combinations* of 'Tests' and 'Types' with Google
+// Test.  The return value is insignificant - we just need to return
+// something such that we can call this function in a namespace scope.
+template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
+class TypeParameterizedTestSuite {
+ public:
+  static bool Register(const char* prefix, CodeLocation code_location,
+                       const TypedTestSuitePState* state, const char* case_name,
+                       const char* test_names,
+                       const std::vector<std::string>& type_names =
+                           GenerateNames<DefaultNameGenerator, Types>()) {
+    RegisterTypeParameterizedTestSuiteInstantiation(case_name);
+    std::string test_name = StripTrailingSpaces(
+        GetPrefixUntilComma(test_names));
+    if (!state->TestExists(test_name)) {
+      fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
+              case_name, test_name.c_str(),
+              FormatFileLocation(code_location.file.c_str(),
+                                 code_location.line).c_str());
+      fflush(stderr);
+      posix::Abort();
+    }
+    const CodeLocation& test_location = state->GetCodeLocation(test_name);
+
+    typedef typename Tests::Head Head;
+
+    // First, register the first test in 'Test' for each type in 'Types'.
+    TypeParameterizedTest<Fixture, Head, Types>::Register(
+        prefix, test_location, case_name, test_names, 0, type_names);
+
+    // Next, recurses (at compile time) with the tail of the test list.
+    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
+                                      Types>::Register(prefix, code_location,
+                                                       state, case_name,
+                                                       SkipComma(test_names),
+                                                       type_names);
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, typename Types>
+class TypeParameterizedTestSuite<Fixture, internal::None, Types> {
+ public:
+  static bool Register(const char* /*prefix*/, const CodeLocation&,
+                       const TypedTestSuitePState* /*state*/,
+                       const char* /*case_name*/, const char* /*test_names*/,
+                       const std::vector<std::string>& =
+                           std::vector<std::string>() /*type_names*/) {
+    return true;
+  }
+};
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
+// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
+GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
+    UnitTest* unit_test, int skip_count);
+
+// Helpers for suppressing warnings on unreachable code or constant
+// condition.
+
+// Always returns true.
+GTEST_API_ bool AlwaysTrue();
+
+// Always returns false.
+inline bool AlwaysFalse() { return !AlwaysTrue(); }
+
+// Helper for suppressing false warning from Clang on a const char*
+// variable declared in a conditional expression always being NULL in
+// the else branch.
+struct GTEST_API_ ConstCharPtr {
+  ConstCharPtr(const char* str) : value(str) {}
+  operator bool() const { return true; }
+  const char* value;
+};
+
+// Helper for declaring std::string within 'if' statement
+// in pre C++17 build environment.
+struct TrueWithString {
+  TrueWithString() = default;
+  explicit TrueWithString(const char* str) : value(str) {}
+  explicit TrueWithString(const std::string& str) : value(str) {}
+  explicit operator bool() const { return true; }
+  std::string value;
+};
+
+// A simple Linear Congruential Generator for generating random
+// numbers with a uniform distribution.  Unlike rand() and srand(), it
+// doesn't use global state (and therefore can't interfere with user
+// code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
+// but it's good enough for our purposes.
+class GTEST_API_ Random {
+ public:
+  static const uint32_t kMaxRange = 1u << 31;
+
+  explicit Random(uint32_t seed) : state_(seed) {}
+
+  void Reseed(uint32_t seed) { state_ = seed; }
+
+  // Generates a random number from [0, range).  Crashes if 'range' is
+  // 0 or greater than kMaxRange.
+  uint32_t Generate(uint32_t range);
+
+ private:
+  uint32_t state_;
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
+};
+
+// Turns const U&, U&, const U, and U all into U.
+#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
+  typename std::remove_const<typename std::remove_reference<T>::type>::type
+
+// HasDebugStringAndShortDebugString<T>::value is a compile-time bool constant
+// that's true if and only if T has methods DebugString() and ShortDebugString()
+// that return std::string.
+template <typename T>
+class HasDebugStringAndShortDebugString {
+ private:
+  template <typename C>
+  static auto CheckDebugString(C*) -> typename std::is_same<
+      std::string, decltype(std::declval<const C>().DebugString())>::type;
+  template <typename>
+  static std::false_type CheckDebugString(...);
+
+  template <typename C>
+  static auto CheckShortDebugString(C*) -> typename std::is_same<
+      std::string, decltype(std::declval<const C>().ShortDebugString())>::type;
+  template <typename>
+  static std::false_type CheckShortDebugString(...);
+
+  using HasDebugStringType = decltype(CheckDebugString<T>(nullptr));
+  using HasShortDebugStringType = decltype(CheckShortDebugString<T>(nullptr));
+
+ public:
+  static constexpr bool value =
+      HasDebugStringType::value && HasShortDebugStringType::value;
+};
+
+template <typename T>
+constexpr bool HasDebugStringAndShortDebugString<T>::value;
+
+// When the compiler sees expression IsContainerTest<C>(0), if C is an
+// STL-style container class, the first overload of IsContainerTest
+// will be viable (since both C::iterator* and C::const_iterator* are
+// valid types and NULL can be implicitly converted to them).  It will
+// be picked over the second overload as 'int' is a perfect match for
+// the type of argument 0.  If C::iterator or C::const_iterator is not
+// a valid type, the first overload is not viable, and the second
+// overload will be picked.  Therefore, we can determine whether C is
+// a container class by checking the type of IsContainerTest<C>(0).
+// The value of the expression is insignificant.
+//
+// In C++11 mode we check the existence of a const_iterator and that an
+// iterator is properly implemented for the container.
+//
+// For pre-C++11 that we look for both C::iterator and C::const_iterator.
+// The reason is that C++ injects the name of a class as a member of the
+// class itself (e.g. you can refer to class iterator as either
+// 'iterator' or 'iterator::iterator').  If we look for C::iterator
+// only, for example, we would mistakenly think that a class named
+// iterator is an STL container.
+//
+// Also note that the simpler approach of overloading
+// IsContainerTest(typename C::const_iterator*) and
+// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
+typedef int IsContainer;
+template <class C,
+          class Iterator = decltype(::std::declval<const C&>().begin()),
+          class = decltype(::std::declval<const C&>().end()),
+          class = decltype(++::std::declval<Iterator&>()),
+          class = decltype(*::std::declval<Iterator>()),
+          class = typename C::const_iterator>
+IsContainer IsContainerTest(int /* dummy */) {
+  return 0;
+}
+
+typedef char IsNotContainer;
+template <class C>
+IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
+
+// Trait to detect whether a type T is a hash table.
+// The heuristic used is that the type contains an inner type `hasher` and does
+// not contain an inner type `reverse_iterator`.
+// If the container is iterable in reverse, then order might actually matter.
+template <typename T>
+struct IsHashTable {
+ private:
+  template <typename U>
+  static char test(typename U::hasher*, typename U::reverse_iterator*);
+  template <typename U>
+  static int test(typename U::hasher*, ...);
+  template <typename U>
+  static char test(...);
+
+ public:
+  static const bool value = sizeof(test<T>(nullptr, nullptr)) == sizeof(int);
+};
+
+template <typename T>
+const bool IsHashTable<T>::value;
+
+template <typename C,
+          bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer)>
+struct IsRecursiveContainerImpl;
+
+template <typename C>
+struct IsRecursiveContainerImpl<C, false> : public std::false_type {};
+
+// Since the IsRecursiveContainerImpl depends on the IsContainerTest we need to
+// obey the same inconsistencies as the IsContainerTest, namely check if
+// something is a container is relying on only const_iterator in C++11 and
+// is relying on both const_iterator and iterator otherwise
+template <typename C>
+struct IsRecursiveContainerImpl<C, true> {
+  using value_type = decltype(*std::declval<typename C::const_iterator>());
+  using type =
+      std::is_same<typename std::remove_const<
+                       typename std::remove_reference<value_type>::type>::type,
+                   C>;
+};
+
+// IsRecursiveContainer<Type> is a unary compile-time predicate that
+// evaluates whether C is a recursive container type. A recursive container
+// type is a container type whose value_type is equal to the container type
+// itself. An example for a recursive container type is
+// boost::filesystem::path, whose iterator has a value_type that is equal to
+// boost::filesystem::path.
+template <typename C>
+struct IsRecursiveContainer : public IsRecursiveContainerImpl<C>::type {};
+
+// Utilities for native arrays.
+
+// ArrayEq() compares two k-dimensional native arrays using the
+// elements' operator==, where k can be any integer >= 0.  When k is
+// 0, ArrayEq() degenerates into comparing a single pair of values.
+
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
+  return internal::ArrayEq(lhs, N, rhs);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous ArrayEq() function, arrays with different sizes would
+// lead to different copies of the template code.
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
+  for (size_t i = 0; i != size; i++) {
+    if (!internal::ArrayEq(lhs[i], rhs[i]))
+      return false;
+  }
+  return true;
+}
+
+// Finds the first element in the iterator range [begin, end) that
+// equals elem.  Element may be a native array type itself.
+template <typename Iter, typename Element>
+Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
+  for (Iter it = begin; it != end; ++it) {
+    if (internal::ArrayEq(*it, elem))
+      return it;
+  }
+  return end;
+}
+
+// CopyArray() copies a k-dimensional native array using the elements'
+// operator=, where k can be any integer >= 0.  When k is 0,
+// CopyArray() degenerates into copying a single value.
+
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline void CopyArray(const T& from, U* to) { *to = from; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline void CopyArray(const T(&from)[N], U(*to)[N]) {
+  internal::CopyArray(from, N, *to);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous CopyArray() function, arrays with different sizes
+// would lead to different copies of the template code.
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to) {
+  for (size_t i = 0; i != size; i++) {
+    internal::CopyArray(from[i], to + i);
+  }
+}
+
+// The relation between an NativeArray object (see below) and the
+// native array it represents.
+// We use 2 different structs to allow non-copyable types to be used, as long
+// as RelationToSourceReference() is passed.
+struct RelationToSourceReference {};
+struct RelationToSourceCopy {};
+
+// Adapts a native array to a read-only STL-style container.  Instead
+// of the complete STL container concept, this adaptor only implements
+// members useful for Google Mock's container matchers.  New members
+// should be added as needed.  To simplify the implementation, we only
+// support Element being a raw type (i.e. having no top-level const or
+// reference modifier).  It's the client's responsibility to satisfy
+// this requirement.  Element can be an array type itself (hence
+// multi-dimensional arrays are supported).
+template <typename Element>
+class NativeArray {
+ public:
+  // STL-style container typedefs.
+  typedef Element value_type;
+  typedef Element* iterator;
+  typedef const Element* const_iterator;
+
+  // Constructs from a native array. References the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceReference) {
+    InitRef(array, count);
+  }
+
+  // Constructs from a native array. Copies the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
+    InitCopy(array, count);
+  }
+
+  // Copy constructor.
+  NativeArray(const NativeArray& rhs) {
+    (this->*rhs.clone_)(rhs.array_, rhs.size_);
+  }
+
+  ~NativeArray() {
+    if (clone_ != &NativeArray::InitRef)
+      delete[] array_;
+  }
+
+  // STL-style container methods.
+  size_t size() const { return size_; }
+  const_iterator begin() const { return array_; }
+  const_iterator end() const { return array_ + size_; }
+  bool operator==(const NativeArray& rhs) const {
+    return size() == rhs.size() &&
+        ArrayEq(begin(), size(), rhs.begin());
+  }
+
+ private:
+  static_assert(!std::is_const<Element>::value, "Type must not be const");
+  static_assert(!std::is_reference<Element>::value,
+                "Type must not be a reference");
+
+  // Initializes this object with a copy of the input.
+  void InitCopy(const Element* array, size_t a_size) {
+    Element* const copy = new Element[a_size];
+    CopyArray(array, a_size, copy);
+    array_ = copy;
+    size_ = a_size;
+    clone_ = &NativeArray::InitCopy;
+  }
+
+  // Initializes this object with a reference of the input.
+  void InitRef(const Element* array, size_t a_size) {
+    array_ = array;
+    size_ = a_size;
+    clone_ = &NativeArray::InitRef;
+  }
+
+  const Element* array_;
+  size_t size_;
+  void (NativeArray::*clone_)(const Element*, size_t);
+};
+
+// Backport of std::index_sequence.
+template <size_t... Is>
+struct IndexSequence {
+  using type = IndexSequence;
+};
+
+// Double the IndexSequence, and one if plus_one is true.
+template <bool plus_one, typename T, size_t sizeofT>
+struct DoubleSequence;
+template <size_t... I, size_t sizeofT>
+struct DoubleSequence<true, IndexSequence<I...>, sizeofT> {
+  using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>;
+};
+template <size_t... I, size_t sizeofT>
+struct DoubleSequence<false, IndexSequence<I...>, sizeofT> {
+  using type = IndexSequence<I..., (sizeofT + I)...>;
+};
+
+// Backport of std::make_index_sequence.
+// It uses O(ln(N)) instantiation depth.
+template <size_t N>
+struct MakeIndexSequenceImpl
+    : DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type,
+                     N / 2>::type {};
+
+template <>
+struct MakeIndexSequenceImpl<0> : IndexSequence<> {};
+
+template <size_t N>
+using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type;
+
+template <typename... T>
+using IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type;
+
+template <size_t>
+struct Ignore {
+  Ignore(...);  // NOLINT
+};
+
+template <typename>
+struct ElemFromListImpl;
+template <size_t... I>
+struct ElemFromListImpl<IndexSequence<I...>> {
+  // We make Ignore a template to solve a problem with MSVC.
+  // A non-template Ignore would work fine with `decltype(Ignore(I))...`, but
+  // MSVC doesn't understand how to deal with that pack expansion.
+  // Use `0 * I` to have a single instantiation of Ignore.
+  template <typename R>
+  static R Apply(Ignore<0 * I>..., R (*)(), ...);
+};
+
+template <size_t N, typename... T>
+struct ElemFromList {
+  using type =
+      decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply(
+          static_cast<T (*)()>(nullptr)...));
+};
+
+struct FlatTupleConstructTag {};
+
+template <typename... T>
+class FlatTuple;
+
+template <typename Derived, size_t I>
+struct FlatTupleElemBase;
+
+template <typename... T, size_t I>
+struct FlatTupleElemBase<FlatTuple<T...>, I> {
+  using value_type = typename ElemFromList<I, T...>::type;
+  FlatTupleElemBase() = default;
+  template <typename Arg>
+  explicit FlatTupleElemBase(FlatTupleConstructTag, Arg&& t)
+      : value(std::forward<Arg>(t)) {}
+  value_type value;
+};
+
+template <typename Derived, typename Idx>
+struct FlatTupleBase;
+
+template <size_t... Idx, typename... T>
+struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
+    : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
+  using Indices = IndexSequence<Idx...>;
+  FlatTupleBase() = default;
+  template <typename... Args>
+  explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args)
+      : FlatTupleElemBase<FlatTuple<T...>, Idx>(FlatTupleConstructTag{},
+                                                std::forward<Args>(args))... {}
+
+  template <size_t I>
+  const typename ElemFromList<I, T...>::type& Get() const {
+    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
+  }
+
+  template <size_t I>
+  typename ElemFromList<I, T...>::type& Get() {
+    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
+  }
+
+  template <typename F>
+  auto Apply(F&& f) -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
+    return std::forward<F>(f)(Get<Idx>()...);
+  }
+
+  template <typename F>
+  auto Apply(F&& f) const -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
+    return std::forward<F>(f)(Get<Idx>()...);
+  }
+};
+
+// Analog to std::tuple but with different tradeoffs.
+// This class minimizes the template instantiation depth, thus allowing more
+// elements than std::tuple would. std::tuple has been seen to require an
+// instantiation depth of more than 10x the number of elements in some
+// implementations.
+// FlatTuple and ElemFromList are not recursive and have a fixed depth
+// regardless of T...
+// MakeIndexSequence, on the other hand, it is recursive but with an
+// instantiation depth of O(ln(N)).
+template <typename... T>
+class FlatTuple
+    : private FlatTupleBase<FlatTuple<T...>,
+                            typename MakeIndexSequence<sizeof...(T)>::type> {
+  using Indices = typename FlatTupleBase<
+      FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices;
+
+ public:
+  FlatTuple() = default;
+  template <typename... Args>
+  explicit FlatTuple(FlatTupleConstructTag tag, Args&&... args)
+      : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {}
+
+  using FlatTuple::FlatTupleBase::Apply;
+  using FlatTuple::FlatTupleBase::Get;
+};
+
+// Utility functions to be called with static_assert to induce deprecation
+// warnings.
+GTEST_INTERNAL_DEPRECATED(
+    "INSTANTIATE_TEST_CASE_P is deprecated, please use "
+    "INSTANTIATE_TEST_SUITE_P")
+constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "TYPED_TEST_CASE_P is deprecated, please use "
+    "TYPED_TEST_SUITE_P")
+constexpr bool TypedTestCase_P_IsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "TYPED_TEST_CASE is deprecated, please use "
+    "TYPED_TEST_SUITE")
+constexpr bool TypedTestCaseIsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
+    "REGISTER_TYPED_TEST_SUITE_P")
+constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
+    "INSTANTIATE_TYPED_TEST_SUITE_P")
+constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; }
+
+}  // namespace internal
+}  // namespace testing
+
+namespace std {
+// Some standard library implementations use `struct tuple_size` and some use
+// `class tuple_size`. Clang warns about the mismatch.
+// https://reviews.llvm.org/D55466
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template <typename... Ts>
+struct tuple_size<testing::internal::FlatTuple<Ts...>>
+    : std::integral_constant<size_t, sizeof...(Ts)> {};
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}  // namespace std
+
+#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
+  ::testing::internal::AssertHelper(result_type, file, line, message) \
+    = ::testing::Message()
+
+#define GTEST_MESSAGE_(message, result_type) \
+  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
+
+#define GTEST_FATAL_FAILURE_(message) \
+  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
+
+#define GTEST_NONFATAL_FAILURE_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
+
+#define GTEST_SUCCESS_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
+
+#define GTEST_SKIP_(message) \
+  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)
+
+// Suppress MSVC warning 4072 (unreachable code) for the code following
+// statement if it returns or throws (or doesn't return or throw in some
+// situations).
+// NOTE: The "else" is important to keep this expansion to prevent a top-level
+// "else" from attaching to our "if".
+#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
+  if (::testing::internal::AlwaysTrue()) {                        \
+    statement;                                                    \
+  } else                     /* NOLINT */                         \
+    static_assert(true, "")  // User must have a semicolon after expansion.
+
+#if GTEST_HAS_EXCEPTIONS
+
+namespace testing {
+namespace internal {
+
+class NeverThrown {
+ public:
+  const char* what() const noexcept {
+    return "this exception should never be thrown";
+  }
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#if GTEST_HAS_RTTI
+
+#define GTEST_EXCEPTION_TYPE_(e) ::testing::internal::GetTypeName(typeid(e))
+
+#else  // GTEST_HAS_RTTI
+
+#define GTEST_EXCEPTION_TYPE_(e) \
+  std::string { "an std::exception-derived error" }
+
+#endif  // GTEST_HAS_RTTI
+
+#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)   \
+  catch (typename std::conditional<                                            \
+         std::is_same<typename std::remove_cv<typename std::remove_reference<  \
+                          expected_exception>::type>::type,                    \
+                      std::exception>::value,                                  \
+         const ::testing::internal::NeverThrown&, const std::exception&>::type \
+             e) {                                                              \
+    gtest_msg.value = "Expected: " #statement                                  \
+                      " throws an exception of type " #expected_exception      \
+                      ".\n  Actual: it throws ";                               \
+    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                               \
+    gtest_msg.value += " with description \"";                                 \
+    gtest_msg.value += e.what();                                               \
+    gtest_msg.value += "\".";                                                  \
+    goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);                \
+  }
+
+#else  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_THROW_(statement, expected_exception, fail)              \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
+  if (::testing::internal::TrueWithString gtest_msg{}) {                    \
+    bool gtest_caught_expected = false;                                     \
+    try {                                                                   \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);            \
+    } catch (expected_exception const&) {                                   \
+      gtest_caught_expected = true;                                         \
+    }                                                                       \
+    GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)    \
+    catch (...) {                                                           \
+      gtest_msg.value = "Expected: " #statement                             \
+                        " throws an exception of type " #expected_exception \
+                        ".\n  Actual: it throws a different type.";         \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
+    }                                                                       \
+    if (!gtest_caught_expected) {                                           \
+      gtest_msg.value = "Expected: " #statement                             \
+                        " throws an exception of type " #expected_exception \
+                        ".\n  Actual: it throws nothing.";                  \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
+    }                                                                       \
+  } else /*NOLINT*/                                                         \
+    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                   \
+        : fail(gtest_msg.value.c_str())
+
+#if GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()                \
+  catch (std::exception const& e) {                               \
+    gtest_msg.value = "it throws ";                               \
+    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                  \
+    gtest_msg.value += " with description \"";                    \
+    gtest_msg.value += e.what();                                  \
+    gtest_msg.value += "\".";                                     \
+    goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
+  }
+
+#else  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_NO_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::TrueWithString gtest_msg{}) { \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
+    catch (...) { \
+      gtest_msg.value = "it throws."; \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
+      fail(("Expected: " #statement " doesn't throw an exception.\n" \
+            "  Actual: " + gtest_msg.value).c_str())
+
+#define GTEST_TEST_ANY_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    bool gtest_caught_any = false; \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    catch (...) { \
+      gtest_caught_any = true; \
+    } \
+    if (!gtest_caught_any) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
+      fail("Expected: " #statement " throws an exception.\n" \
+           "  Actual: it doesn't.")
+
+
+// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
+// either a boolean expression or an AssertionResult. text is a textual
+// representation of expression as it was passed into the EXPECT_TRUE.
+#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar_ = \
+      ::testing::AssertionResult(expression)) \
+    ; \
+  else \
+    fail(::testing::internal::GetBoolAssertionFailureMessage(\
+        gtest_ar_, text, #actual, #expected).c_str())
+
+#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
+      fail("Expected: " #statement " doesn't generate new fatal " \
+           "failures in the current thread.\n" \
+           "  Actual: it does.")
+
+// Expands to the name of the class that implements the given test.
+#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
+  test_suite_name##_##test_name##_Test
+
+// Helper macro for defining tests.
+#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)      \
+  static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,                \
+                "test_suite_name must not be empty");                         \
+  static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,                      \
+                "test_name must not be empty");                               \
+  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \
+      : public parent_class {                                                 \
+   public:                                                                    \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;           \
+    ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
+                                                           test_name));       \
+    GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
+                                                           test_name));       \
+                                                                              \
+   private:                                                                   \
+    void TestBody() override;                                                 \
+    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;     \
+  };                                                                          \
+                                                                              \
+  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,          \
+                                                    test_name)::test_info_ =  \
+      ::testing::internal::MakeAndRegisterTestInfo(                           \
+          #test_suite_name, #test_name, nullptr, nullptr,                     \
+          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
+          ::testing::internal::SuiteApiResolver<                              \
+              parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),         \
+          ::testing::internal::SuiteApiResolver<                              \
+              parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),      \
+          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(    \
+              test_suite_name, test_name)>);                                  \
+  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
diff --git a/tools/gtest_lib/include/gtest/internal/gtest-param-util.h b/tools/gtest_lib/include/gtest/internal/gtest-param-util.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff25d9950aaf198e200f3b404d89284923df1322
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/gtest-param-util.h
@@ -0,0 +1,948 @@
+// Copyright 2008 Google Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Type and function utilities for implementing parameterized tests.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+
+#include <ctype.h>
+
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <set>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+#include "gtest/gtest-printers.h"
+#include "gtest/gtest-test-part.h"
+
+namespace testing {
+// Input to a parameterized test name generator, describing a test parameter.
+// Consists of the parameter value and the integer parameter index.
+template <class ParamType>
+struct TestParamInfo {
+  TestParamInfo(const ParamType& a_param, size_t an_index) :
+    param(a_param),
+    index(an_index) {}
+  ParamType param;
+  size_t index;
+};
+
+// A builtin parameterized test name generator which returns the result of
+// testing::PrintToString.
+struct PrintToStringParamName {
+  template <class ParamType>
+  std::string operator()(const TestParamInfo<ParamType>& info) const {
+    return PrintToString(info.param);
+  }
+};
+
+namespace internal {
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+// Utility Functions
+
+// Outputs a message explaining invalid registration of different
+// fixture class for the same test suite. This may happen when
+// TEST_P macro is used to define two tests with the same name
+// but in different namespaces.
+GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
+                                           CodeLocation code_location);
+
+template <typename> class ParamGeneratorInterface;
+template <typename> class ParamGenerator;
+
+// Interface for iterating over elements provided by an implementation
+// of ParamGeneratorInterface<T>.
+template <typename T>
+class ParamIteratorInterface {
+ public:
+  virtual ~ParamIteratorInterface() {}
+  // A pointer to the base generator instance.
+  // Used only for the purposes of iterator comparison
+  // to make sure that two iterators belong to the same generator.
+  virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
+  // Advances iterator to point to the next element
+  // provided by the generator. The caller is responsible
+  // for not calling Advance() on an iterator equal to
+  // BaseGenerator()->End().
+  virtual void Advance() = 0;
+  // Clones the iterator object. Used for implementing copy semantics
+  // of ParamIterator<T>.
+  virtual ParamIteratorInterface* Clone() const = 0;
+  // Dereferences the current iterator and provides (read-only) access
+  // to the pointed value. It is the caller's responsibility not to call
+  // Current() on an iterator equal to BaseGenerator()->End().
+  // Used for implementing ParamGenerator<T>::operator*().
+  virtual const T* Current() const = 0;
+  // Determines whether the given iterator and other point to the same
+  // element in the sequence generated by the generator.
+  // Used for implementing ParamGenerator<T>::operator==().
+  virtual bool Equals(const ParamIteratorInterface& other) const = 0;
+};
+
+// Class iterating over elements provided by an implementation of
+// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
+// and implements the const forward iterator concept.
+template <typename T>
+class ParamIterator {
+ public:
+  typedef T value_type;
+  typedef const T& reference;
+  typedef ptrdiff_t difference_type;
+
+  // ParamIterator assumes ownership of the impl_ pointer.
+  ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
+  ParamIterator& operator=(const ParamIterator& other) {
+    if (this != &other)
+      impl_.reset(other.impl_->Clone());
+    return *this;
+  }
+
+  const T& operator*() const { return *impl_->Current(); }
+  const T* operator->() const { return impl_->Current(); }
+  // Prefix version of operator++.
+  ParamIterator& operator++() {
+    impl_->Advance();
+    return *this;
+  }
+  // Postfix version of operator++.
+  ParamIterator operator++(int /*unused*/) {
+    ParamIteratorInterface<T>* clone = impl_->Clone();
+    impl_->Advance();
+    return ParamIterator(clone);
+  }
+  bool operator==(const ParamIterator& other) const {
+    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
+  }
+  bool operator!=(const ParamIterator& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  friend class ParamGenerator<T>;
+  explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
+  std::unique_ptr<ParamIteratorInterface<T> > impl_;
+};
+
+// ParamGeneratorInterface<T> is the binary interface to access generators
+// defined in other translation units.
+template <typename T>
+class ParamGeneratorInterface {
+ public:
+  typedef T ParamType;
+
+  virtual ~ParamGeneratorInterface() {}
+
+  // Generator interface definition
+  virtual ParamIteratorInterface<T>* Begin() const = 0;
+  virtual ParamIteratorInterface<T>* End() const = 0;
+};
+
+// Wraps ParamGeneratorInterface<T> and provides general generator syntax
+// compatible with the STL Container concept.
+// This class implements copy initialization semantics and the contained
+// ParamGeneratorInterface<T> instance is shared among all copies
+// of the original object. This is possible because that instance is immutable.
+template<typename T>
+class ParamGenerator {
+ public:
+  typedef ParamIterator<T> iterator;
+
+  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
+  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
+
+  ParamGenerator& operator=(const ParamGenerator& other) {
+    impl_ = other.impl_;
+    return *this;
+  }
+
+  iterator begin() const { return iterator(impl_->Begin()); }
+  iterator end() const { return iterator(impl_->End()); }
+
+ private:
+  std::shared_ptr<const ParamGeneratorInterface<T> > impl_;
+};
+
+// Generates values from a range of two comparable values. Can be used to
+// generate sequences of user-defined types that implement operator+() and
+// operator<().
+// This class is used in the Range() function.
+template <typename T, typename IncrementT>
+class RangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  RangeGenerator(T begin, T end, IncrementT step)
+      : begin_(begin), end_(end),
+        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
+  ~RangeGenerator() override {}
+
+  ParamIteratorInterface<T>* Begin() const override {
+    return new Iterator(this, begin_, 0, step_);
+  }
+  ParamIteratorInterface<T>* End() const override {
+    return new Iterator(this, end_, end_index_, step_);
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
+             IncrementT step)
+        : base_(base), value_(value), index_(index), step_(step) {}
+    ~Iterator() override {}
+
+    const ParamGeneratorInterface<T>* BaseGenerator() const override {
+      return base_;
+    }
+    void Advance() override {
+      value_ = static_cast<T>(value_ + step_);
+      index_++;
+    }
+    ParamIteratorInterface<T>* Clone() const override {
+      return new Iterator(*this);
+    }
+    const T* Current() const override { return &value_; }
+    bool Equals(const ParamIteratorInterface<T>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const int other_index =
+          CheckedDowncastToActualType<const Iterator>(&other)->index_;
+      return index_ == other_index;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : ParamIteratorInterface<T>(),
+          base_(other.base_), value_(other.value_), index_(other.index_),
+          step_(other.step_) {}
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<T>* const base_;
+    T value_;
+    int index_;
+    const IncrementT step_;
+  };  // class RangeGenerator::Iterator
+
+  static int CalculateEndIndex(const T& begin,
+                               const T& end,
+                               const IncrementT& step) {
+    int end_index = 0;
+    for (T i = begin; i < end; i = static_cast<T>(i + step))
+      end_index++;
+    return end_index;
+  }
+
+  // No implementation - assignment is unsupported.
+  void operator=(const RangeGenerator& other);
+
+  const T begin_;
+  const T end_;
+  const IncrementT step_;
+  // The index for the end() iterator. All the elements in the generated
+  // sequence are indexed (0-based) to aid iterator comparison.
+  const int end_index_;
+};  // class RangeGenerator
+
+
+// Generates values from a pair of STL-style iterators. Used in the
+// ValuesIn() function. The elements are copied from the source range
+// since the source can be located on the stack, and the generator
+// is likely to persist beyond that stack frame.
+template <typename T>
+class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  template <typename ForwardIterator>
+  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
+      : container_(begin, end) {}
+  ~ValuesInIteratorRangeGenerator() override {}
+
+  ParamIteratorInterface<T>* Begin() const override {
+    return new Iterator(this, container_.begin());
+  }
+  ParamIteratorInterface<T>* End() const override {
+    return new Iterator(this, container_.end());
+  }
+
+ private:
+  typedef typename ::std::vector<T> ContainerType;
+
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base,
+             typename ContainerType::const_iterator iterator)
+        : base_(base), iterator_(iterator) {}
+    ~Iterator() override {}
+
+    const ParamGeneratorInterface<T>* BaseGenerator() const override {
+      return base_;
+    }
+    void Advance() override {
+      ++iterator_;
+      value_.reset();
+    }
+    ParamIteratorInterface<T>* Clone() const override {
+      return new Iterator(*this);
+    }
+    // We need to use cached value referenced by iterator_ because *iterator_
+    // can return a temporary object (and of type other then T), so just
+    // having "return &*iterator_;" doesn't work.
+    // value_ is updated here and not in Advance() because Advance()
+    // can advance iterator_ beyond the end of the range, and we cannot
+    // detect that fact. The client code, on the other hand, is
+    // responsible for not calling Current() on an out-of-range iterator.
+    const T* Current() const override {
+      if (value_.get() == nullptr) value_.reset(new T(*iterator_));
+      return value_.get();
+    }
+    bool Equals(const ParamIteratorInterface<T>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      return iterator_ ==
+          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+          // The explicit constructor call suppresses a false warning
+          // emitted by gcc when supplied with the -Wextra option.
+        : ParamIteratorInterface<T>(),
+          base_(other.base_),
+          iterator_(other.iterator_) {}
+
+    const ParamGeneratorInterface<T>* const base_;
+    typename ContainerType::const_iterator iterator_;
+    // A cached value of *iterator_. We keep it here to allow access by
+    // pointer in the wrapping iterator's operator->().
+    // value_ needs to be mutable to be accessed in Current().
+    // Use of std::unique_ptr helps manage cached value's lifetime,
+    // which is bound by the lifespan of the iterator itself.
+    mutable std::unique_ptr<const T> value_;
+  };  // class ValuesInIteratorRangeGenerator::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const ValuesInIteratorRangeGenerator& other);
+
+  const ContainerType container_;
+};  // class ValuesInIteratorRangeGenerator
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Default parameterized test name generator, returns a string containing the
+// integer test parameter index.
+template <class ParamType>
+std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
+  Message name_stream;
+  name_stream << info.index;
+  return name_stream.GetString();
+}
+
+template <typename T = int>
+void TestNotEmpty() {
+  static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");
+}
+template <typename T = int>
+void TestNotEmpty(const T&) {}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Stores a parameter value and later creates tests parameterized with that
+// value.
+template <class TestClass>
+class ParameterizedTestFactory : public TestFactoryBase {
+ public:
+  typedef typename TestClass::ParamType ParamType;
+  explicit ParameterizedTestFactory(ParamType parameter) :
+      parameter_(parameter) {}
+  Test* CreateTest() override {
+    TestClass::SetParam(&parameter_);
+    return new TestClass();
+  }
+
+ private:
+  const ParamType parameter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// TestMetaFactoryBase is a base class for meta-factories that create
+// test factories for passing into MakeAndRegisterTestInfo function.
+template <class ParamType>
+class TestMetaFactoryBase {
+ public:
+  virtual ~TestMetaFactoryBase() {}
+
+  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// TestMetaFactory creates test factories for passing into
+// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
+// ownership of test factory pointer, same factory object cannot be passed
+// into that method twice. But ParameterizedTestSuiteInfo is going to call
+// it for each Test/Parameter value combination. Thus it needs meta factory
+// creator class.
+template <class TestSuite>
+class TestMetaFactory
+    : public TestMetaFactoryBase<typename TestSuite::ParamType> {
+ public:
+  using ParamType = typename TestSuite::ParamType;
+
+  TestMetaFactory() {}
+
+  TestFactoryBase* CreateTestFactory(ParamType parameter) override {
+    return new ParameterizedTestFactory<TestSuite>(parameter);
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestSuiteInfoBase is a generic interface
+// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase
+// accumulates test information provided by TEST_P macro invocations
+// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations
+// and uses that information to register all resulting test instances
+// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
+// a collection of pointers to the ParameterizedTestSuiteInfo objects
+// and calls RegisterTests() on each of them when asked.
+class ParameterizedTestSuiteInfoBase {
+ public:
+  virtual ~ParameterizedTestSuiteInfoBase() {}
+
+  // Base part of test suite name for display purposes.
+  virtual const std::string& GetTestSuiteName() const = 0;
+  // Test suite id to verify identity.
+  virtual TypeId GetTestSuiteTypeId() const = 0;
+  // UnitTest class invokes this method to register tests in this
+  // test suite right before running them in RUN_ALL_TESTS macro.
+  // This method should not be called more than once on any single
+  // instance of a ParameterizedTestSuiteInfoBase derived class.
+  virtual void RegisterTests() = 0;
+
+ protected:
+  ParameterizedTestSuiteInfoBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Report a the name of a test_suit as safe to ignore
+// as the side effect of construction of this type.
+struct GTEST_API_ MarkAsIgnored {
+  explicit MarkAsIgnored(const char* test_suite);
+};
+
+GTEST_API_ void InsertSyntheticTestCase(const std::string& name,
+                                        CodeLocation location, bool has_test_p);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P
+// macro invocations for a particular test suite and generators
+// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that
+// test suite. It registers tests with all values generated by all
+// generators when asked.
+template <class TestSuite>
+class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
+ public:
+  // ParamType and GeneratorCreationFunc are private types but are required
+  // for declarations of public methods AddTestPattern() and
+  // AddTestSuiteInstantiation().
+  using ParamType = typename TestSuite::ParamType;
+  // A function that returns an instance of appropriate generator type.
+  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
+  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);
+
+  explicit ParameterizedTestSuiteInfo(const char* name,
+                                      CodeLocation code_location)
+      : test_suite_name_(name), code_location_(code_location) {}
+
+  // Test suite base name for display purposes.
+  const std::string& GetTestSuiteName() const override {
+    return test_suite_name_;
+  }
+  // Test suite id to verify identity.
+  TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); }
+  // TEST_P macro uses AddTestPattern() to record information
+  // about a single test in a LocalTestInfo structure.
+  // test_suite_name is the base name of the test suite (without invocation
+  // prefix). test_base_name is the name of an individual test without
+  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
+  // test suite base name and DoBar is test base name.
+  void AddTestPattern(const char* test_suite_name, const char* test_base_name,
+                      TestMetaFactoryBase<ParamType>* meta_factory,
+                      CodeLocation code_location) {
+    tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(
+        test_suite_name, test_base_name, meta_factory, code_location)));
+  }
+  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
+  // about a generator.
+  int AddTestSuiteInstantiation(const std::string& instantiation_name,
+                                GeneratorCreationFunc* func,
+                                ParamNameGeneratorFunc* name_func,
+                                const char* file, int line) {
+    instantiations_.push_back(
+        InstantiationInfo(instantiation_name, func, name_func, file, line));
+    return 0;  // Return value used only to run this method in namespace scope.
+  }
+  // UnitTest class invokes this method to register tests in this test suite
+  // right before running tests in RUN_ALL_TESTS macro.
+  // This method should not be called more than once on any single
+  // instance of a ParameterizedTestSuiteInfoBase derived class.
+  // UnitTest has a guard to prevent from calling this method more than once.
+  void RegisterTests() override {
+    bool generated_instantiations = false;
+
+    for (typename TestInfoContainer::iterator test_it = tests_.begin();
+         test_it != tests_.end(); ++test_it) {
+      std::shared_ptr<TestInfo> test_info = *test_it;
+      for (typename InstantiationContainer::iterator gen_it =
+               instantiations_.begin(); gen_it != instantiations_.end();
+               ++gen_it) {
+        const std::string& instantiation_name = gen_it->name;
+        ParamGenerator<ParamType> generator((*gen_it->generator)());
+        ParamNameGeneratorFunc* name_func = gen_it->name_func;
+        const char* file = gen_it->file;
+        int line = gen_it->line;
+
+        std::string test_suite_name;
+        if ( !instantiation_name.empty() )
+          test_suite_name = instantiation_name + "/";
+        test_suite_name += test_info->test_suite_base_name;
+
+        size_t i = 0;
+        std::set<std::string> test_param_names;
+        for (typename ParamGenerator<ParamType>::iterator param_it =
+                 generator.begin();
+             param_it != generator.end(); ++param_it, ++i) {
+          generated_instantiations = true;
+
+          Message test_name_stream;
+
+          std::string param_name = name_func(
+              TestParamInfo<ParamType>(*param_it, i));
+
+          GTEST_CHECK_(IsValidParamName(param_name))
+              << "Parameterized test name '" << param_name
+              << "' is invalid, in " << file
+              << " line " << line << std::endl;
+
+          GTEST_CHECK_(test_param_names.count(param_name) == 0)
+              << "Duplicate parameterized test name '" << param_name
+              << "', in " << file << " line " << line << std::endl;
+
+          test_param_names.insert(param_name);
+
+          if (!test_info->test_base_name.empty()) {
+            test_name_stream << test_info->test_base_name << "/";
+          }
+          test_name_stream << param_name;
+          MakeAndRegisterTestInfo(
+              test_suite_name.c_str(), test_name_stream.GetString().c_str(),
+              nullptr,  // No type parameter.
+              PrintToString(*param_it).c_str(), test_info->code_location,
+              GetTestSuiteTypeId(),
+              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
+              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
+              test_info->test_meta_factory->CreateTestFactory(*param_it));
+        }  // for param_it
+      }  // for gen_it
+    }  // for test_it
+
+    if (!generated_instantiations) {
+      // There are no generaotrs, or they all generate nothing ...
+      InsertSyntheticTestCase(GetTestSuiteName(), code_location_,
+                              !tests_.empty());
+    }
+  }    // RegisterTests
+
+ private:
+  // LocalTestInfo structure keeps information about a single test registered
+  // with TEST_P macro.
+  struct TestInfo {
+    TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
+             TestMetaFactoryBase<ParamType>* a_test_meta_factory,
+             CodeLocation a_code_location)
+        : test_suite_base_name(a_test_suite_base_name),
+          test_base_name(a_test_base_name),
+          test_meta_factory(a_test_meta_factory),
+          code_location(a_code_location) {}
+
+    const std::string test_suite_base_name;
+    const std::string test_base_name;
+    const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
+    const CodeLocation code_location;
+  };
+  using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >;
+  // Records data received from INSTANTIATE_TEST_SUITE_P macros:
+  //  <Instantiation name, Sequence generator creation function,
+  //     Name generator function, Source file, Source line>
+  struct InstantiationInfo {
+      InstantiationInfo(const std::string &name_in,
+                        GeneratorCreationFunc* generator_in,
+                        ParamNameGeneratorFunc* name_func_in,
+                        const char* file_in,
+                        int line_in)
+          : name(name_in),
+            generator(generator_in),
+            name_func(name_func_in),
+            file(file_in),
+            line(line_in) {}
+
+      std::string name;
+      GeneratorCreationFunc* generator;
+      ParamNameGeneratorFunc* name_func;
+      const char* file;
+      int line;
+  };
+  typedef ::std::vector<InstantiationInfo> InstantiationContainer;
+
+  static bool IsValidParamName(const std::string& name) {
+    // Check for empty string
+    if (name.empty())
+      return false;
+
+    // Check for invalid characters
+    for (std::string::size_type index = 0; index < name.size(); ++index) {
+      if (!IsAlNum(name[index]) && name[index] != '_')
+        return false;
+    }
+
+    return true;
+  }
+
+  const std::string test_suite_name_;
+  CodeLocation code_location_;
+  TestInfoContainer tests_;
+  InstantiationContainer instantiations_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo);
+};  // class ParameterizedTestSuiteInfo
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+template <class TestCase>
+using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestSuiteRegistry contains a map of
+// ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P
+// and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding
+// ParameterizedTestSuiteInfo descriptors.
+class ParameterizedTestSuiteRegistry {
+ public:
+  ParameterizedTestSuiteRegistry() {}
+  ~ParameterizedTestSuiteRegistry() {
+    for (auto& test_suite_info : test_suite_infos_) {
+      delete test_suite_info;
+    }
+  }
+
+  // Looks up or creates and returns a structure containing information about
+  // tests and instantiations of a particular test suite.
+  template <class TestSuite>
+  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
+      const char* test_suite_name, CodeLocation code_location) {
+    ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
+    for (auto& test_suite_info : test_suite_infos_) {
+      if (test_suite_info->GetTestSuiteName() == test_suite_name) {
+        if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
+          // Complain about incorrect usage of Google Test facilities
+          // and terminate the program since we cannot guaranty correct
+          // test suite setup and tear-down in this case.
+          ReportInvalidTestSuiteType(test_suite_name, code_location);
+          posix::Abort();
+        } else {
+          // At this point we are sure that the object we found is of the same
+          // type we are looking for, so we downcast it to that type
+          // without further checks.
+          typed_test_info = CheckedDowncastToActualType<
+              ParameterizedTestSuiteInfo<TestSuite> >(test_suite_info);
+        }
+        break;
+      }
+    }
+    if (typed_test_info == nullptr) {
+      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
+          test_suite_name, code_location);
+      test_suite_infos_.push_back(typed_test_info);
+    }
+    return typed_test_info;
+  }
+  void RegisterTests() {
+    for (auto& test_suite_info : test_suite_infos_) {
+      test_suite_info->RegisterTests();
+    }
+  }
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  template <class TestCase>
+  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
+      const char* test_case_name, CodeLocation code_location) {
+    return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
+  }
+
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+ private:
+  using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;
+
+  TestSuiteInfoContainer test_suite_infos_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry);
+};
+
+// Keep track of what type-parameterized test suite are defined and
+// where as well as which are intatiated. This allows susequently
+// identifying suits that are defined but never used.
+class TypeParameterizedTestSuiteRegistry {
+ public:
+  // Add a suite definition
+  void RegisterTestSuite(const char* test_suite_name,
+                         CodeLocation code_location);
+
+  // Add an instantiation of a suit.
+  void RegisterInstantiation(const char* test_suite_name);
+
+  // For each suit repored as defined but not reported as instantiation,
+  // emit a test that reports that fact (configurably, as an error).
+  void CheckForInstantiations();
+
+ private:
+  struct TypeParameterizedTestSuiteInfo {
+    explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
+        : code_location(c), instantiated(false) {}
+
+    CodeLocation code_location;
+    bool instantiated;
+  };
+
+  std::map<std::string, TypeParameterizedTestSuiteInfo> suites_;
+};
+
+}  // namespace internal
+
+// Forward declarations of ValuesIn(), which is implemented in
+// include/gtest/gtest-param-test.h.
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container);
+
+namespace internal {
+// Used in the Values() function to provide polymorphic capabilities.
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+
+template <typename... Ts>
+class ValueArray {
+ public:
+  explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {  // NOLINT
+    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
+  }
+
+ private:
+  template <typename T, size_t... I>
+  std::vector<T> MakeVector(IndexSequence<I...>) const {
+    return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
+  }
+
+  FlatTuple<Ts...> v_;
+};
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+template <typename... T>
+class CartesianProductGenerator
+    : public ParamGeneratorInterface<::std::tuple<T...>> {
+ public:
+  typedef ::std::tuple<T...> ParamType;
+
+  CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
+      : generators_(g) {}
+  ~CartesianProductGenerator() override {}
+
+  ParamIteratorInterface<ParamType>* Begin() const override {
+    return new Iterator(this, generators_, false);
+  }
+  ParamIteratorInterface<ParamType>* End() const override {
+    return new Iterator(this, generators_, true);
+  }
+
+ private:
+  template <class I>
+  class IteratorImpl;
+  template <size_t... I>
+  class IteratorImpl<IndexSequence<I...>>
+      : public ParamIteratorInterface<ParamType> {
+   public:
+    IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
+             const std::tuple<ParamGenerator<T>...>& generators, bool is_end)
+        : base_(base),
+          begin_(std::get<I>(generators).begin()...),
+          end_(std::get<I>(generators).end()...),
+          current_(is_end ? end_ : begin_) {
+      ComputeCurrentValue();
+    }
+    ~IteratorImpl() override {}
+
+    const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    void Advance() override {
+      assert(!AtEnd());
+      // Advance the last iterator.
+      ++std::get<sizeof...(T) - 1>(current_);
+      // if that reaches end, propagate that up.
+      AdvanceIfEnd<sizeof...(T) - 1>();
+      ComputeCurrentValue();
+    }
+    ParamIteratorInterface<ParamType>* Clone() const override {
+      return new IteratorImpl(*this);
+    }
+
+    const ParamType* Current() const override { return current_value_.get(); }
+
+    bool Equals(const ParamIteratorInterface<ParamType>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const IteratorImpl* typed_other =
+          CheckedDowncastToActualType<const IteratorImpl>(&other);
+
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      if (AtEnd() && typed_other->AtEnd()) return true;
+
+      bool same = true;
+      bool dummy[] = {
+          (same = same && std::get<I>(current_) ==
+                              std::get<I>(typed_other->current_))...};
+      (void)dummy;
+      return same;
+    }
+
+   private:
+    template <size_t ThisI>
+    void AdvanceIfEnd() {
+      if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return;
+
+      bool last = ThisI == 0;
+      if (last) {
+        // We are done. Nothing else to propagate.
+        return;
+      }
+
+      constexpr size_t NextI = ThisI - (ThisI != 0);
+      std::get<ThisI>(current_) = std::get<ThisI>(begin_);
+      ++std::get<NextI>(current_);
+      AdvanceIfEnd<NextI>();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
+    }
+    bool AtEnd() const {
+      bool at_end = false;
+      bool dummy[] = {
+          (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};
+      (void)dummy;
+      return at_end;
+    }
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    std::tuple<typename ParamGenerator<T>::iterator...> begin_;
+    std::tuple<typename ParamGenerator<T>::iterator...> end_;
+    std::tuple<typename ParamGenerator<T>::iterator...> current_;
+    std::shared_ptr<ParamType> current_value_;
+  };
+
+  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;
+
+  std::tuple<ParamGenerator<T>...> generators_;
+};
+
+template <class... Gen>
+class CartesianProductHolder {
+ public:
+  CartesianProductHolder(const Gen&... g) : generators_(g...) {}
+  template <typename... T>
+  operator ParamGenerator<::std::tuple<T...>>() const {
+    return ParamGenerator<::std::tuple<T...>>(
+        new CartesianProductGenerator<T...>(generators_));
+  }
+
+ private:
+  std::tuple<Gen...> generators_;
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
diff --git a/tools/gtest_lib/include/gtest/internal/gtest-port-arch.h b/tools/gtest_lib/include/gtest/internal/gtest-port-arch.h
new file mode 100644
index 0000000000000000000000000000000000000000..22bbad97eb6b80db70e2e390c74542b122e66eb0
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/gtest-port-arch.h
@@ -0,0 +1,116 @@
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the GTEST_OS_* macro.
+// It is separate from gtest-port.h so that custom/gtest-port.h can include it.
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+
+// Determines the platform on which Google Test is compiled.
+#ifdef __CYGWIN__
+# define GTEST_OS_CYGWIN 1
+# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
+#  define GTEST_OS_WINDOWS_MINGW 1
+#  define GTEST_OS_WINDOWS 1
+#elif defined _WIN32
+# define GTEST_OS_WINDOWS 1
+# ifdef _WIN32_WCE
+#  define GTEST_OS_WINDOWS_MOBILE 1
+# elif defined(WINAPI_FAMILY)
+#  include <winapifamily.h>
+#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
+#   define GTEST_OS_WINDOWS_PHONE 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#   define GTEST_OS_WINDOWS_RT 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
+#   define GTEST_OS_WINDOWS_PHONE 1
+#   define GTEST_OS_WINDOWS_TV_TITLE 1
+#  else
+    // WINAPI_FAMILY defined but no known partition matched.
+    // Default to desktop.
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  endif
+# else
+#  define GTEST_OS_WINDOWS_DESKTOP 1
+# endif  // _WIN32_WCE
+#elif defined __OS2__
+# define GTEST_OS_OS2 1
+#elif defined __APPLE__
+# define GTEST_OS_MAC 1
+# include <TargetConditionals.h>
+# if TARGET_OS_IPHONE
+#  define GTEST_OS_IOS 1
+# endif
+#elif defined __DragonFly__
+# define GTEST_OS_DRAGONFLY 1
+#elif defined __FreeBSD__
+# define GTEST_OS_FREEBSD 1
+#elif defined __Fuchsia__
+# define GTEST_OS_FUCHSIA 1
+#elif defined(__GNU__)
+# define GTEST_OS_GNU_HURD 1
+#elif defined(__GLIBC__) && defined(__FreeBSD_kernel__)
+# define GTEST_OS_GNU_KFREEBSD 1
+#elif defined __linux__
+# define GTEST_OS_LINUX 1
+# if defined __ANDROID__
+#  define GTEST_OS_LINUX_ANDROID 1
+# endif
+#elif defined __MVS__
+# define GTEST_OS_ZOS 1
+#elif defined(__sun) && defined(__SVR4)
+# define GTEST_OS_SOLARIS 1
+#elif defined(_AIX)
+# define GTEST_OS_AIX 1
+#elif defined(__hpux)
+# define GTEST_OS_HPUX 1
+#elif defined __native_client__
+# define GTEST_OS_NACL 1
+#elif defined __NetBSD__
+# define GTEST_OS_NETBSD 1
+#elif defined __OpenBSD__
+# define GTEST_OS_OPENBSD 1
+#elif defined __QNX__
+# define GTEST_OS_QNX 1
+#elif defined(__HAIKU__)
+#define GTEST_OS_HAIKU 1
+#elif defined ESP8266
+#define GTEST_OS_ESP8266 1
+#elif defined ESP32
+#define GTEST_OS_ESP32 1
+#elif defined(__XTENSA__)
+#define GTEST_OS_XTENSA 1
+#endif  // __CYGWIN__
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
diff --git a/tools/gtest_lib/include/gtest/internal/gtest-port.h b/tools/gtest_lib/include/gtest/internal/gtest-port.h
new file mode 100644
index 0000000000000000000000000000000000000000..929b7090cab34d1a4145ff766c747f3bd100fcd7
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/gtest-port.h
@@ -0,0 +1,2381 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Low-level types and utilities for porting Google Test to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Test's public API and can be used by
+// code outside Google Test.
+//
+// This file is fundamental to Google Test.  All other Google Test source
+// files are expected to #include this.  Therefore, it cannot #include
+// any other Google Test header.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+
+// Environment-describing macros
+// -----------------------------
+//
+// Google Test can be used in many different environments.  Macros in
+// this section tell Google Test what kind of environment it is being
+// used in, such that Google Test can provide environment-specific
+// features and implementations.
+//
+// Google Test tries to automatically detect the properties of its
+// environment, so users usually don't need to worry about these
+// macros.  However, the automatic detection is not perfect.
+// Sometimes it's necessary for a user to define some of the following
+// macros in the build script to override Google Test's decisions.
+//
+// If the user doesn't define a macro in the list, Google Test will
+// provide a default definition.  After this header is #included, all
+// macros in this list will be defined to either 1 or 0.
+//
+// Notes to maintainers:
+//   - Each macro here is a user-tweakable knob; do not grow the list
+//     lightly.
+//   - Use #if to key off these macros.  Don't use #ifdef or "#if
+//     defined(...)", which will not work as these macros are ALWAYS
+//     defined.
+//
+//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
+//                              is/isn't available.
+//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
+//                              are enabled.
+//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
+//                              expressions are/aren't available.
+//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
+//                              is/isn't available.
+//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
+//                              enabled.
+//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
+//                              std::wstring does/doesn't work (Google Test can
+//                              be used where std::wstring is unavailable).
+//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
+//                              compiler supports Microsoft's "Structured
+//                              Exception Handling".
+//   GTEST_HAS_STREAM_REDIRECTION
+//                            - Define it to 1/0 to indicate whether the
+//                              platform supports I/O stream redirection using
+//                              dup() and dup2().
+//   GTEST_LINKED_AS_SHARED_LIBRARY
+//                            - Define to 1 when compiling tests that use
+//                              Google Test as a shared library (known as
+//                              DLL on Windows).
+//   GTEST_CREATE_SHARED_LIBRARY
+//                            - Define to 1 when compiling Google Test itself
+//                              as a shared library.
+//   GTEST_DEFAULT_DEATH_TEST_STYLE
+//                            - The default value of --gtest_death_test_style.
+//                              The legacy default has been "fast" in the open
+//                              source version since 2008. The recommended value
+//                              is "threadsafe", and can be set in
+//                              custom/gtest-port.h.
+
+// Platform-indicating macros
+// --------------------------
+//
+// Macros indicating the platform on which Google Test is being used
+// (a macro is defined to 1 if compiled on the given platform;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+//   GTEST_OS_AIX      - IBM AIX
+//   GTEST_OS_CYGWIN   - Cygwin
+//   GTEST_OS_DRAGONFLY - DragonFlyBSD
+//   GTEST_OS_FREEBSD  - FreeBSD
+//   GTEST_OS_FUCHSIA  - Fuchsia
+//   GTEST_OS_GNU_HURD - GNU/Hurd
+//   GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD
+//   GTEST_OS_HAIKU    - Haiku
+//   GTEST_OS_HPUX     - HP-UX
+//   GTEST_OS_LINUX    - Linux
+//     GTEST_OS_LINUX_ANDROID - Google Android
+//   GTEST_OS_MAC      - Mac OS X
+//     GTEST_OS_IOS    - iOS
+//   GTEST_OS_NACL     - Google Native Client (NaCl)
+//   GTEST_OS_NETBSD   - NetBSD
+//   GTEST_OS_OPENBSD  - OpenBSD
+//   GTEST_OS_OS2      - OS/2
+//   GTEST_OS_QNX      - QNX
+//   GTEST_OS_SOLARIS  - Sun Solaris
+//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
+//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
+//     GTEST_OS_WINDOWS_MINGW    - MinGW
+//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
+//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
+//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
+//   GTEST_OS_ZOS      - z/OS
+//
+// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the
+// most stable support.  Since core members of the Google Test project
+// don't have access to other platforms, support for them may be less
+// stable.  If you notice any problems on your platform, please notify
+// googletestframework@googlegroups.com (patches for fixing them are
+// even more welcome!).
+//
+// It is possible that none of the GTEST_OS_* macros are defined.
+
+// Feature-indicating macros
+// -------------------------
+//
+// Macros indicating which Google Test features are available (a macro
+// is defined to 1 if the corresponding feature is supported;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+// These macros are public so that portable tests can be written.
+// Such tests typically surround code using a feature with an #if
+// which controls that code.  For example:
+//
+// #if GTEST_HAS_DEATH_TEST
+//   EXPECT_DEATH(DoSomethingDeadly());
+// #endif
+//
+//   GTEST_HAS_DEATH_TEST   - death tests
+//   GTEST_HAS_TYPED_TEST   - typed tests
+//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
+//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
+//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
+//                            GTEST_HAS_POSIX_RE (see above) which users can
+//                            define themselves.
+//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
+//                            the above RE\b(s) are mutually exclusive.
+
+// Misc public macros
+// ------------------
+//
+//   GTEST_FLAG(flag_name)  - references the variable corresponding to
+//                            the given Google Test flag.
+
+// Internal utilities
+// ------------------
+//
+// The following macros and utilities are for Google Test's INTERNAL
+// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
+//
+// Macros for basic C++ coding:
+//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
+//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
+//                              variable don't have to be used.
+//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
+//   GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=.
+//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
+//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
+//                                        suppressed (constant conditional).
+//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
+//                                        is suppressed.
+//   GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or
+//                            UniversalPrinter<absl::any> specializations.
+//   GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional>
+//   or
+//                                 UniversalPrinter<absl::optional>
+//                                 specializations.
+//   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or
+//                                    Matcher<absl::string_view>
+//                                    specializations.
+//   GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or
+//                                UniversalPrinter<absl::variant>
+//                                specializations.
+//
+// Synchronization:
+//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
+//                            - synchronization primitives.
+//
+// Regular expressions:
+//   RE             - a simple regular expression class using the POSIX
+//                    Extended Regular Expression syntax on UNIX-like platforms
+//                    or a reduced regular exception syntax on other
+//                    platforms, including Windows.
+// Logging:
+//   GTEST_LOG_()   - logs messages at the specified severity level.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+//
+// Stdout and stderr capturing:
+//   CaptureStdout()     - starts capturing stdout.
+//   GetCapturedStdout() - stops capturing stdout and returns the captured
+//                         string.
+//   CaptureStderr()     - starts capturing stderr.
+//   GetCapturedStderr() - stops capturing stderr and returns the captured
+//                         string.
+//
+// Integer types:
+//   TypeWithSize   - maps an integer to a int type.
+//   TimeInMillis   - integers of known sizes.
+//   BiggestInt     - the biggest signed integer type.
+//
+// Command-line utilities:
+//   GTEST_DECLARE_*()  - declares a flag.
+//   GTEST_DEFINE_*()   - defines a flag.
+//   GetInjectableArgvs() - returns the command line as a vector of strings.
+//
+// Environment variable utilities:
+//   GetEnv()             - gets the value of an environment variable.
+//   BoolFromGTestEnv()   - parses a bool environment variable.
+//   Int32FromGTestEnv()  - parses an int32_t environment variable.
+//   StringFromGTestEnv() - parses a string environment variable.
+//
+// Deprecation warnings:
+//   GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as
+//                                        deprecated; calling a marked function
+//                                        should generate a compiler warning
+
+#include <ctype.h>   // for isspace, etc
+#include <stddef.h>  // for ptrdiff_t
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cerrno>
+// #include <condition_variable>  // Guarded by GTEST_IS_THREADSAFE below
+#include <cstdint>
+#include <iostream>
+#include <limits>
+#include <locale>
+#include <memory>
+#include <string>
+// #include <mutex>  // Guarded by GTEST_IS_THREADSAFE below
+#include <tuple>
+#include <type_traits>
+#include <vector>
+
+#ifndef _WIN32_WCE
+# include <sys/types.h>
+# include <sys/stat.h>
+#endif  // !_WIN32_WCE
+
+#if defined __APPLE__
+# include <AvailabilityMacros.h>
+# include <TargetConditionals.h>
+#endif
+
+#include "gtest/internal/custom/gtest-port.h"
+#include "gtest/internal/gtest-port-arch.h"
+
+#if !defined(GTEST_DEV_EMAIL_)
+# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
+# define GTEST_FLAG_PREFIX_ "gtest_"
+# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
+# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
+# define GTEST_NAME_ "Google Test"
+# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
+#endif  // !defined(GTEST_DEV_EMAIL_)
+
+#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
+#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+
+// Determines the version of gcc that is used to compile this.
+#ifdef __GNUC__
+// 40302 means version 4.3.2.
+# define GTEST_GCC_VER_ \
+    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
+#endif  // __GNUC__
+
+// Macros for disabling Microsoft Visual C++ warnings.
+//
+//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
+//   /* code that triggers warnings C4800 and C4385 */
+//   GTEST_DISABLE_MSC_WARNINGS_POP_()
+#if defined(_MSC_VER)
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
+    __pragma(warning(push))                        \
+    __pragma(warning(disable: warnings))
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
+    __pragma(warning(pop))
+#else
+// Not all compilers are MSVC
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+// Clang on Windows does not understand MSVC's pragma warning.
+// We need clang-specific way to disable function deprecation warning.
+#ifdef __clang__
+# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                         \
+    _Pragma("clang diagnostic push")                                  \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
+#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
+    _Pragma("clang diagnostic pop")
+#else
+# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+// Brings in definitions for functions used in the testing::internal::posix
+// namespace (read, write, close, chdir, isatty, stat). We do not currently
+// use them on Windows Mobile.
+#if GTEST_OS_WINDOWS
+# if !GTEST_OS_WINDOWS_MOBILE
+#  include <direct.h>
+#  include <io.h>
+# endif
+// In order to avoid having to include <windows.h>, use forward declaration
+#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
+// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two
+// separate (equivalent) structs, instead of using typedef
+typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
+#else
+// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
+// This assumption is verified by
+// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
+typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
+#endif
+#elif GTEST_OS_XTENSA
+#include <unistd.h>
+// Xtensa toolchains define strcasecmp in the string.h header instead of
+// strings.h. string.h is already included.
+#else
+// This assumes that non-Windows OSes provide unistd.h. For OSes where this
+// is not the case, we need to include headers that provide the functions
+// mentioned above.
+# include <unistd.h>
+# include <strings.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_LINUX_ANDROID
+// Used to define __ANDROID_API__ matching the target NDK API level.
+#  include <android/api-level.h>  // NOLINT
+#endif
+
+// Defines this to true if and only if Google Test can use POSIX regular
+// expressions.
+#ifndef GTEST_HAS_POSIX_RE
+# if GTEST_OS_LINUX_ANDROID
+// On Android, <regex.h> is only available starting with Gingerbread.
+#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
+# else
+#define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA)
+# endif
+#endif
+
+#if GTEST_USES_PCRE
+// The appropriate headers have already been included.
+
+#elif GTEST_HAS_POSIX_RE
+
+// On some platforms, <regex.h> needs someone to define size_t, and
+// won't compile otherwise.  We can #include it here as we already
+// included <stdlib.h>, which is guaranteed to define size_t through
+// <stddef.h>.
+# include <regex.h>  // NOLINT
+
+# define GTEST_USES_POSIX_RE 1
+
+#elif GTEST_OS_WINDOWS
+
+// <regex.h> is not available on Windows.  Use our own simple regex
+// implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#else
+
+// <regex.h> may not be available on this platform.  Use our own
+// simple regex implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#endif  // GTEST_USES_PCRE
+
+#ifndef GTEST_HAS_EXCEPTIONS
+// The user didn't tell us whether exceptions are enabled, so we need
+// to figure it out.
+# if defined(_MSC_VER) && defined(_CPPUNWIND)
+// MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__BORLANDC__)
+// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS
+// macro to enable exceptions, so we'll do the same.
+// Assumes that exceptions are enabled by default.
+#  ifndef _HAS_EXCEPTIONS
+#   define _HAS_EXCEPTIONS 1
+#  endif  // _HAS_EXCEPTIONS
+#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
+# elif defined(__clang__)
+// clang defines __EXCEPTIONS if and only if exceptions are enabled before clang
+// 220714, but if and only if cleanups are enabled after that. In Obj-C++ files,
+// there can be cleanups for ObjC exceptions which also need cleanups, even if
+// C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which
+// checks for C++ exceptions starting at clang r206352, but which checked for
+// cleanups prior to that. To reliably check for C++ exception availability with
+// clang, check for
+// __EXCEPTIONS && __has_feature(cxx_exceptions).
+#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
+# elif defined(__GNUC__) && __EXCEPTIONS
+// gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__SUNPRO_CC)
+// Sun Pro CC supports exceptions.  However, there is no compile-time way of
+// detecting whether they are enabled or not.  Therefore, we assume that
+// they are enabled unless the user tells us otherwise.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__IBMCPP__) && __EXCEPTIONS
+// xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__HP_aCC)
+// Exception handling is in effect by default in HP aCC compiler. It has to
+// be turned of by +noeh compiler option if desired.
+#  define GTEST_HAS_EXCEPTIONS 1
+# else
+// For other compilers, we assume exceptions are disabled to be
+// conservative.
+#  define GTEST_HAS_EXCEPTIONS 0
+# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#ifndef GTEST_HAS_STD_WSTRING
+// The user didn't tell us whether ::std::wstring is available, so we need
+// to figure it out.
+// Cygwin 1.7 and below doesn't support ::std::wstring.
+// Solaris' libc++ doesn't support it either.  Android has
+// no support for it at least as recent as Froyo (2.2).
+#define GTEST_HAS_STD_WSTRING                                         \
+  (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
+     GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA))
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Determines whether RTTI is available.
+#ifndef GTEST_HAS_RTTI
+// The user didn't tell us whether RTTI is enabled, so we need to
+// figure it out.
+
+# ifdef _MSC_VER
+
+#ifdef _CPPRTTI  // MSVC defines this macro if and only if RTTI is enabled.
+#   define GTEST_HAS_RTTI 1
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif
+
+// Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is
+// enabled.
+# elif defined(__GNUC__)
+
+#  ifdef __GXX_RTTI
+// When building against STLport with the Android NDK and with
+// -frtti -fno-exceptions, the build fails at link time with undefined
+// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
+// so disable RTTI when detected.
+#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
+       !defined(__EXCEPTIONS)
+#    define GTEST_HAS_RTTI 0
+#   else
+#    define GTEST_HAS_RTTI 1
+#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif  // __GXX_RTTI
+
+// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
+// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
+// first version with C++ support.
+# elif defined(__clang__)
+
+#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
+
+// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
+// both the typeid and dynamic_cast features are present.
+# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
+
+#  ifdef __RTTI_ALL__
+#   define GTEST_HAS_RTTI 1
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif
+
+# else
+
+// For all other compilers, we assume RTTI is enabled.
+#  define GTEST_HAS_RTTI 1
+
+# endif  // _MSC_VER
+
+#endif  // GTEST_HAS_RTTI
+
+// It's this header's responsibility to #include <typeinfo> when RTTI
+// is enabled.
+#if GTEST_HAS_RTTI
+# include <typeinfo>
+#endif
+
+// Determines whether Google Test can use the pthreads library.
+#ifndef GTEST_HAS_PTHREAD
+// The user didn't tell us explicitly, so we make reasonable assumptions about
+// which platforms have pthreads support.
+//
+// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
+// to your compiler flags.
+#define GTEST_HAS_PTHREAD                                                      \
+  (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX ||          \
+   GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
+   GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD ||          \
+   GTEST_OS_HAIKU || GTEST_OS_GNU_HURD)
+#endif  // GTEST_HAS_PTHREAD
+
+#if GTEST_HAS_PTHREAD
+// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
+// true.
+# include <pthread.h>  // NOLINT
+
+// For timespec and nanosleep, used below.
+# include <time.h>  // NOLINT
+#endif
+
+// Determines whether clone(2) is supported.
+// Usually it will only be available on Linux, excluding
+// Linux on the Itanium architecture.
+// Also see http://linux.die.net/man/2/clone.
+#ifndef GTEST_HAS_CLONE
+// The user didn't tell us, so we need to figure it out.
+
+# if GTEST_OS_LINUX && !defined(__ia64__)
+#  if GTEST_OS_LINUX_ANDROID
+// On Android, clone() became available at different API levels for each 32-bit
+// architecture.
+#    if defined(__LP64__) || \
+        (defined(__arm__) && __ANDROID_API__ >= 9) || \
+        (defined(__mips__) && __ANDROID_API__ >= 12) || \
+        (defined(__i386__) && __ANDROID_API__ >= 17)
+#     define GTEST_HAS_CLONE 1
+#    else
+#     define GTEST_HAS_CLONE 0
+#    endif
+#  else
+#   define GTEST_HAS_CLONE 1
+#  endif
+# else
+#  define GTEST_HAS_CLONE 0
+# endif  // GTEST_OS_LINUX && !defined(__ia64__)
+
+#endif  // GTEST_HAS_CLONE
+
+// Determines whether to support stream redirection. This is used to test
+// output correctness and to implement death tests.
+#ifndef GTEST_HAS_STREAM_REDIRECTION
+// By default, we assume that stream redirection is supported on all
+// platforms except known mobile ones.
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+#  define GTEST_HAS_STREAM_REDIRECTION 0
+# else
+#  define GTEST_HAS_STREAM_REDIRECTION 1
+# endif  // !GTEST_OS_WINDOWS_MOBILE
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Determines whether to support death tests.
+// pops up a dialog window that cannot be suppressed programmatically.
+#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS ||             \
+     (GTEST_OS_MAC && !GTEST_OS_IOS) ||                                   \
+     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW ||  \
+     GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
+     GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA ||           \
+     GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU ||     \
+     GTEST_OS_GNU_HURD)
+# define GTEST_HAS_DEATH_TEST 1
+#endif
+
+// Determines whether to support type-driven tests.
+
+// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
+// Sun Pro CC, IBM Visual Age, and HP aCC support.
+#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
+    defined(__IBMCPP__) || defined(__HP_aCC)
+# define GTEST_HAS_TYPED_TEST 1
+# define GTEST_HAS_TYPED_TEST_P 1
+#endif
+
+// Determines whether the system compiler uses UTF-16 for encoding wide strings.
+#define GTEST_WIDE_STRING_USES_UTF16_ \
+  (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
+
+// Determines whether test results can be streamed to a socket.
+#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
+    GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD ||       \
+    GTEST_OS_GNU_HURD
+# define GTEST_CAN_STREAM_RESULTS_ 1
+#endif
+
+// Defines some utility macros.
+
+// The GNU compiler emits a warning if nested "if" statements are followed by
+// an "else" statement and braces are not used to explicitly disambiguate the
+// "else" binding.  This leads to problems with code like:
+//
+//   if (gate)
+//     ASSERT_*(condition) << "Some message";
+//
+// The "switch (0) case 0:" idiom is used to suppress this.
+#ifdef __INTEL_COMPILER
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
+#else
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
+#endif
+
+// Use this annotation at the end of a struct/class definition to
+// prevent the compiler from optimizing away instances that are never
+// used.  This is useful when all interesting logic happens inside the
+// c'tor and / or d'tor.  Example:
+//
+//   struct Foo {
+//     Foo() { ... }
+//   } GTEST_ATTRIBUTE_UNUSED_;
+//
+// Also use it after a variable or parameter declaration to tell the
+// compiler the variable/parameter does not have to be used.
+#if defined(__GNUC__) && !defined(COMPILER_ICC)
+# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+#elif defined(__clang__)
+# if __has_attribute(unused)
+#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+# endif
+#endif
+#ifndef GTEST_ATTRIBUTE_UNUSED_
+# define GTEST_ATTRIBUTE_UNUSED_
+#endif
+
+// Use this annotation before a function that takes a printf format string.
+#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
+# if defined(__MINGW_PRINTF_FORMAT)
+// MinGW has two different printf implementations. Ensure the format macro
+// matches the selected implementation. See
+// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.
+#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
+       __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
+                                 first_to_check)))
+# else
+#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
+       __attribute__((__format__(__printf__, string_index, first_to_check)))
+# endif
+#else
+# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
+#endif
+
+// A macro to disallow copy constructor and operator=
+// This should be used in the private: declarations for a class.
+// NOLINT is for modernize-use-trailing-return-type in macro uses.
+#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
+  type(type const&) = delete;                 \
+  type& operator=(type const&) = delete /* NOLINT */
+
+// A macro to disallow move constructor and operator=
+// This should be used in the private: declarations for a class.
+// NOLINT is for modernize-use-trailing-return-type in macro uses.
+#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \
+  type(type&&) noexcept = delete;             \
+  type& operator=(type&&) noexcept = delete /* NOLINT */
+
+// Tell the compiler to warn about unused return values for functions declared
+// with this macro.  The macro should be used on function declarations
+// following the argument list:
+//
+//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
+#if defined(__GNUC__) && !defined(COMPILER_ICC)
+# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
+#else
+# define GTEST_MUST_USE_RESULT_
+#endif  // __GNUC__ && !COMPILER_ICC
+
+// MS C++ compiler emits warning when a conditional expression is compile time
+// constant. In some contexts this warning is false positive and needs to be
+// suppressed. Use the following two macros in such cases:
+//
+// GTEST_INTENTIONAL_CONST_COND_PUSH_()
+// while (true) {
+// GTEST_INTENTIONAL_CONST_COND_POP_()
+// }
+# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
+# define GTEST_INTENTIONAL_CONST_COND_POP_() \
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+// Determine whether the compiler supports Microsoft's Structured Exception
+// Handling.  This is supported by several Windows compilers but generally
+// does not exist on any other system.
+#ifndef GTEST_HAS_SEH
+// The user didn't tell us, so we need to figure it out.
+
+# if defined(_MSC_VER) || defined(__BORLANDC__)
+// These two compilers are known to support SEH.
+#  define GTEST_HAS_SEH 1
+# else
+// Assume no SEH.
+#  define GTEST_HAS_SEH 0
+# endif
+
+#endif  // GTEST_HAS_SEH
+
+#ifndef GTEST_IS_THREADSAFE
+
+#define GTEST_IS_THREADSAFE                                                 \
+  (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||                                     \
+   (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
+   GTEST_HAS_PTHREAD)
+
+#endif  // GTEST_IS_THREADSAFE
+
+#if GTEST_IS_THREADSAFE
+// Some platforms don't support including these threading related headers.
+#include <condition_variable>  // NOLINT
+#include <mutex>  // NOLINT
+#endif  // GTEST_IS_THREADSAFE
+
+// GTEST_API_ qualifies all symbols that must be exported. The definitions below
+// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in
+// gtest/internal/custom/gtest-port.h
+#ifndef GTEST_API_
+
+#ifdef _MSC_VER
+# if GTEST_LINKED_AS_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllimport)
+# elif GTEST_CREATE_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllexport)
+# endif
+#elif __GNUC__ >= 4 || defined(__clang__)
+# define GTEST_API_ __attribute__((visibility ("default")))
+#endif  // _MSC_VER
+
+#endif  // GTEST_API_
+
+#ifndef GTEST_API_
+# define GTEST_API_
+#endif  // GTEST_API_
+
+#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
+# define GTEST_DEFAULT_DEATH_TEST_STYLE  "fast"
+#endif  // GTEST_DEFAULT_DEATH_TEST_STYLE
+
+#ifdef __GNUC__
+// Ask the compiler to never inline a given function.
+# define GTEST_NO_INLINE_ __attribute__((noinline))
+#else
+# define GTEST_NO_INLINE_
+#endif
+
+#if defined(__clang__)
+// Nested ifs to avoid triggering MSVC warning.
+#if __has_attribute(disable_tail_calls)
+// Ask the compiler not to perform tail call optimization inside
+// the marked function.
+#define GTEST_NO_TAIL_CALL_ __attribute__((disable_tail_calls))
+#endif
+#elif __GNUC__
+#define GTEST_NO_TAIL_CALL_ \
+  __attribute__((optimize("no-optimize-sibling-calls")))
+#else
+#define GTEST_NO_TAIL_CALL_
+#endif
+
+// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
+#if !defined(GTEST_HAS_CXXABI_H_)
+# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
+#  define GTEST_HAS_CXXABI_H_ 1
+# else
+#  define GTEST_HAS_CXXABI_H_ 0
+# endif
+#endif
+
+// A function level attribute to disable checking for use of uninitialized
+// memory when built with MemorySanitizer.
+#if defined(__clang__)
+# if __has_feature(memory_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
+       __attribute__((no_sanitize_memory))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+# endif  // __has_feature(memory_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+#endif  // __clang__
+
+// A function level attribute to disable AddressSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(address_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
+       __attribute__((no_sanitize_address))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+# endif  // __has_feature(address_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+#endif  // __clang__
+
+// A function level attribute to disable HWAddressSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(hwaddress_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
+       __attribute__((no_sanitize("hwaddress")))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+# endif  // __has_feature(hwaddress_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+#endif  // __clang__
+
+// A function level attribute to disable ThreadSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(thread_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
+       __attribute__((no_sanitize_thread))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+# endif  // __has_feature(thread_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+#endif  // __clang__
+
+namespace testing {
+
+class Message;
+
+// Legacy imports for backwards compatibility.
+// New code should use std:: names directly.
+using std::get;
+using std::make_tuple;
+using std::tuple;
+using std::tuple_element;
+using std::tuple_size;
+
+namespace internal {
+
+// A secret type that Google Test users don't know about.  It has no
+// definition on purpose.  Therefore it's impossible to create a
+// Secret object, which is what we want.
+class Secret;
+
+// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile
+// time expression is true (in new code, use static_assert instead). For
+// example, you could use it to verify the size of a static array:
+//
+//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
+//                         names_incorrect_size);
+//
+// The second argument to the macro must be a valid C++ identifier. If the
+// expression is false, compiler will issue an error containing this identifier.
+#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
+
+// A helper for suppressing warnings on constant condition.  It just
+// returns 'condition'.
+GTEST_API_ bool IsTrue(bool condition);
+
+// Defines RE.
+
+#if GTEST_USES_PCRE
+// if used, PCRE is injected by custom/gtest-port.h
+#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
+
+// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
+// Regular Expression syntax.
+class GTEST_API_ RE {
+ public:
+  // A copy constructor is required by the Standard to initialize object
+  // references from r-values.
+  RE(const RE& other) { Init(other.pattern()); }
+
+  // Constructs an RE from a string.
+  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
+
+  RE(const char* regex) { Init(regex); }  // NOLINT
+  ~RE();
+
+  // Returns the string representation of the regex.
+  const char* pattern() const { return pattern_; }
+
+  // FullMatch(str, re) returns true if and only if regular expression re
+  // matches the entire str.
+  // PartialMatch(str, re) returns true if and only if regular expression re
+  // matches a substring of str (including str itself).
+  static bool FullMatch(const ::std::string& str, const RE& re) {
+    return FullMatch(str.c_str(), re);
+  }
+  static bool PartialMatch(const ::std::string& str, const RE& re) {
+    return PartialMatch(str.c_str(), re);
+  }
+
+  static bool FullMatch(const char* str, const RE& re);
+  static bool PartialMatch(const char* str, const RE& re);
+
+ private:
+  void Init(const char* regex);
+  const char* pattern_;
+  bool is_valid_;
+
+# if GTEST_USES_POSIX_RE
+
+  regex_t full_regex_;     // For FullMatch().
+  regex_t partial_regex_;  // For PartialMatch().
+
+# else  // GTEST_USES_SIMPLE_RE
+
+  const char* full_pattern_;  // For FullMatch();
+
+# endif
+};
+
+#endif  // GTEST_USES_PCRE
+
+// Formats a source file path and a line number as they would appear
+// in an error message from the compiler used to compile this code.
+GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
+
+// Formats a file location for compiler-independent XML output.
+// Although this function is not platform dependent, we put it next to
+// FormatFileLocation in order to contrast the two functions.
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
+                                                               int line);
+
+// Defines logging utilities:
+//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
+//                          message itself is streamed into the macro.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+
+enum GTestLogSeverity {
+  GTEST_INFO,
+  GTEST_WARNING,
+  GTEST_ERROR,
+  GTEST_FATAL
+};
+
+// Formats log entry severity, provides a stream object for streaming the
+// log message, and terminates the message with a newline when going out of
+// scope.
+class GTEST_API_ GTestLog {
+ public:
+  GTestLog(GTestLogSeverity severity, const char* file, int line);
+
+  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
+  ~GTestLog();
+
+  ::std::ostream& GetStream() { return ::std::cerr; }
+
+ private:
+  const GTestLogSeverity severity_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
+};
+
+#if !defined(GTEST_LOG_)
+
+# define GTEST_LOG_(severity) \
+    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
+                                  __FILE__, __LINE__).GetStream()
+
+inline void LogToStderr() {}
+inline void FlushInfoLog() { fflush(nullptr); }
+
+#endif  // !defined(GTEST_LOG_)
+
+#if !defined(GTEST_CHECK_)
+// INTERNAL IMPLEMENTATION - DO NOT USE.
+//
+// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
+// is not satisfied.
+//  Synopsis:
+//    GTEST_CHECK_(boolean_condition);
+//     or
+//    GTEST_CHECK_(boolean_condition) << "Additional message";
+//
+//    This checks the condition and if the condition is not satisfied
+//    it prints message about the condition violation, including the
+//    condition itself, plus additional message streamed into it, if any,
+//    and then it aborts the program. It aborts the program irrespective of
+//    whether it is built in the debug mode or not.
+# define GTEST_CHECK_(condition) \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+    if (::testing::internal::IsTrue(condition)) \
+      ; \
+    else \
+      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
+#endif  // !defined(GTEST_CHECK_)
+
+// An all-mode assert to verify that the given POSIX-style function
+// call returns 0 (indicating success).  Known limitation: this
+// doesn't expand to a balanced 'if' statement, so enclose the macro
+// in {} if you need to use it as the only statement in an 'if'
+// branch.
+#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
+  if (const int gtest_error = (posix_call)) \
+    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
+                      << gtest_error
+
+// Transforms "T" into "const T&" according to standard reference collapsing
+// rules (this is only needed as a backport for C++98 compilers that do not
+// support reference collapsing). Specifically, it transforms:
+//
+//   char         ==> const char&
+//   const char   ==> const char&
+//   char&        ==> char&
+//   const char&  ==> const char&
+//
+// Note that the non-const reference will not have "const" added. This is
+// standard, and necessary so that "T" can always bind to "const T&".
+template <typename T>
+struct ConstRef { typedef const T& type; };
+template <typename T>
+struct ConstRef<T&> { typedef T& type; };
+
+// The argument T must depend on some template parameters.
+#define GTEST_REFERENCE_TO_CONST_(T) \
+  typename ::testing::internal::ConstRef<T>::type
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Use ImplicitCast_ as a safe version of static_cast for upcasting in
+// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
+// const Foo*).  When you use ImplicitCast_, the compiler checks that
+// the cast is safe.  Such explicit ImplicitCast_s are necessary in
+// surprisingly many situations where C++ demands an exact type match
+// instead of an argument type convertible to a target type.
+//
+// The syntax for using ImplicitCast_ is the same as for static_cast:
+//
+//   ImplicitCast_<ToType>(expr)
+//
+// ImplicitCast_ would have been part of the C++ standard library,
+// but the proposal was submitted too late.  It will probably make
+// its way into the language in the future.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., implicit_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To>
+inline To ImplicitCast_(To x) { return x; }
+
+// When you upcast (that is, cast a pointer from type Foo to type
+// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
+// always succeed.  When you downcast (that is, cast a pointer from
+// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
+// how do you know the pointer is really of type SubclassOfFoo?  It
+// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
+// when you downcast, you should use this macro.  In debug mode, we
+// use dynamic_cast<> to double-check the downcast is legal (we die
+// if it's not).  In normal mode, we do the efficient static_cast<>
+// instead.  Thus, it's important to test in debug mode to make sure
+// the cast is legal!
+//    This is the only place in the code we should use dynamic_cast<>.
+// In particular, you SHOULDN'T be using dynamic_cast<> in order to
+// do RTTI (eg code like this:
+//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
+//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
+// You should design the code some other way not to need this.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., down_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
+inline To DownCast_(From* f) {  // so we only accept pointers
+  // Ensures that To is a sub-type of From *.  This test is here only
+  // for compile-time type checking, and has no overhead in an
+  // optimized build at run-time, as it will be optimized away
+  // completely.
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (false) {
+  GTEST_INTENTIONAL_CONST_COND_POP_()
+  const To to = nullptr;
+  ::testing::internal::ImplicitCast_<From*>(to);
+  }
+
+#if GTEST_HAS_RTTI
+  // RTTI: debug mode only!
+  GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr);
+#endif
+  return static_cast<To>(f);
+}
+
+// Downcasts the pointer of type Base to Derived.
+// Derived must be a subclass of Base. The parameter MUST
+// point to a class of type Derived, not any subclass of it.
+// When RTTI is available, the function performs a runtime
+// check to enforce this.
+template <class Derived, class Base>
+Derived* CheckedDowncastToActualType(Base* base) {
+#if GTEST_HAS_RTTI
+  GTEST_CHECK_(typeid(*base) == typeid(Derived));
+#endif
+
+#if GTEST_HAS_DOWNCAST_
+  return ::down_cast<Derived*>(base);
+#elif GTEST_HAS_RTTI
+  return dynamic_cast<Derived*>(base);  // NOLINT
+#else
+  return static_cast<Derived*>(base);  // Poor man's downcast.
+#endif
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Defines the stderr capturer:
+//   CaptureStdout     - starts capturing stdout.
+//   GetCapturedStdout - stops capturing stdout and returns the captured string.
+//   CaptureStderr     - starts capturing stderr.
+//   GetCapturedStderr - stops capturing stderr and returns the captured string.
+//
+GTEST_API_ void CaptureStdout();
+GTEST_API_ std::string GetCapturedStdout();
+GTEST_API_ void CaptureStderr();
+GTEST_API_ std::string GetCapturedStderr();
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+// Returns the size (in bytes) of a file.
+GTEST_API_ size_t GetFileSize(FILE* file);
+
+// Reads the entire content of a file as a string.
+GTEST_API_ std::string ReadEntireFile(FILE* file);
+
+// All command line arguments.
+GTEST_API_ std::vector<std::string> GetArgvs();
+
+#if GTEST_HAS_DEATH_TEST
+
+std::vector<std::string> GetInjectableArgvs();
+// Deprecated: pass the args vector by value instead.
+void SetInjectableArgvs(const std::vector<std::string>* new_argvs);
+void SetInjectableArgvs(const std::vector<std::string>& new_argvs);
+void ClearInjectableArgvs();
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Defines synchronization primitives.
+#if GTEST_IS_THREADSAFE
+
+# if GTEST_OS_WINDOWS
+// Provides leak-safe Windows kernel handle ownership.
+// Used in death tests and in threading support.
+class GTEST_API_ AutoHandle {
+ public:
+  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
+  // avoid including <windows.h> in this header file. Including <windows.h> is
+  // undesirable because it defines a lot of symbols and macros that tend to
+  // conflict with client code. This assumption is verified by
+  // WindowsTypesTest.HANDLEIsVoidStar.
+  typedef void* Handle;
+  AutoHandle();
+  explicit AutoHandle(Handle handle);
+
+  ~AutoHandle();
+
+  Handle Get() const;
+  void Reset();
+  void Reset(Handle handle);
+
+ private:
+  // Returns true if and only if the handle is a valid handle object that can be
+  // closed.
+  bool IsCloseable() const;
+
+  Handle handle_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
+};
+# endif
+
+# if GTEST_HAS_NOTIFICATION_
+// Notification has already been imported into the namespace.
+// Nothing to do here.
+
+# else
+// Allows a controller thread to pause execution of newly created
+// threads until notified.  Instances of this class must be created
+// and destroyed in the controller thread.
+//
+// This class is only for testing Google Test's own constructs. Do not
+// use it in user tests, either directly or indirectly.
+// TODO(b/203539622): Replace unconditionally with absl::Notification.
+class GTEST_API_ Notification {
+ public:
+  Notification() : notified_(false) {}
+  Notification(const Notification&) = delete;
+  Notification& operator=(const Notification&) = delete;
+
+  // Notifies all threads created with this notification to start. Must
+  // be called from the controller thread.
+  void Notify() {
+    std::lock_guard<std::mutex> lock(mu_);
+    notified_ = true;
+    cv_.notify_all();
+  }
+
+  // Blocks until the controller thread notifies. Must be called from a test
+  // thread.
+  void WaitForNotification() {
+    std::unique_lock<std::mutex> lock(mu_);
+    cv_.wait(lock, [this]() { return notified_; });
+  }
+
+ private:
+  std::mutex mu_;
+  std::condition_variable cv_;
+  bool notified_;
+};
+# endif  // GTEST_HAS_NOTIFICATION_
+
+// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
+// defined, but we don't want to use MinGW's pthreads implementation, which
+// has conformance problems with some versions of the POSIX standard.
+# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
+
+// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
+// Consequently, it cannot select a correct instantiation of ThreadWithParam
+// in order to call its Run(). Introducing ThreadWithParamBase as a
+// non-templated base class for ThreadWithParam allows us to bypass this
+// problem.
+class ThreadWithParamBase {
+ public:
+  virtual ~ThreadWithParamBase() {}
+  virtual void Run() = 0;
+};
+
+// pthread_create() accepts a pointer to a function type with the C linkage.
+// According to the Standard (7.5/1), function types with different linkages
+// are different even if they are otherwise identical.  Some compilers (for
+// example, SunStudio) treat them as different types.  Since class methods
+// cannot be defined with C-linkage we need to define a free C-function to
+// pass into pthread_create().
+extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
+  static_cast<ThreadWithParamBase*>(thread)->Run();
+  return nullptr;
+}
+
+// Helper class for testing Google Test's multi-threading constructs.
+// To use it, write:
+//
+//   void ThreadFunc(int param) { /* Do things with param */ }
+//   Notification thread_can_start;
+//   ...
+//   // The thread_can_start parameter is optional; you can supply NULL.
+//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
+//   thread_can_start.Notify();
+//
+// These classes are only for testing Google Test's own constructs. Do
+// not use them in user tests, either directly or indirectly.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : func_(func),
+        param_(param),
+        thread_can_start_(thread_can_start),
+        finished_(false) {
+    ThreadWithParamBase* const base = this;
+    // The thread can be created only after all fields except thread_
+    // have been initialized.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base));
+  }
+  ~ThreadWithParam() override { Join(); }
+
+  void Join() {
+    if (!finished_) {
+      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr));
+      finished_ = true;
+    }
+  }
+
+  void Run() override {
+    if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification();
+    func_(param_);
+  }
+
+ private:
+  UserThreadFunc* const func_;  // User-supplied thread function.
+  const T param_;  // User-supplied parameter to the thread function.
+  // When non-NULL, used to block execution until the controller thread
+  // notifies.
+  Notification* const thread_can_start_;
+  bool finished_;  // true if and only if we know that the thread function has
+                   // finished.
+  pthread_t thread_;  // The native thread object.
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
+         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+// Mutex and ThreadLocal have already been imported into the namespace.
+// Nothing to do here.
+
+# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+// Mutex implements mutex on Windows platforms.  It is used in conjunction
+// with class MutexLock:
+//
+//   Mutex mutex;
+//   ...
+//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
+//                            // end of the current scope.
+//
+// A static Mutex *must* be defined or declared using one of the following
+// macros:
+//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
+//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
+//
+// (A non-static Mutex is defined/declared in the usual way).
+class GTEST_API_ Mutex {
+ public:
+  enum MutexType { kStatic = 0, kDynamic = 1 };
+  // We rely on kStaticMutex being 0 as it is to what the linker initializes
+  // type_ in static mutexes.  critical_section_ will be initialized lazily
+  // in ThreadSafeLazyInit().
+  enum StaticConstructorSelector { kStaticMutex = 0 };
+
+  // This constructor intentionally does nothing.  It relies on type_ being
+  // statically initialized to 0 (effectively setting it to kStatic) and on
+  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
+  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
+
+  Mutex();
+  ~Mutex();
+
+  void Lock();
+
+  void Unlock();
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld();
+
+ private:
+  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
+  void ThreadSafeLazyInit();
+
+  // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503,
+  // we assume that 0 is an invalid value for thread IDs.
+  unsigned int owner_thread_id_;
+
+  // For static mutexes, we rely on these members being initialized to zeros
+  // by the linker.
+  MutexType type_;
+  long critical_section_init_phase_;  // NOLINT
+  GTEST_CRITICAL_SECTION* critical_section_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+    extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  Mutex* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
+// without knowing its type.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Provides a way for a thread to send notifications to a ThreadLocal
+// regardless of its parameter type.
+class ThreadLocalBase {
+ public:
+  // Creates a new ValueHolder<T> object holding a default value passed to
+  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
+  // responsibility not to call this when the ThreadLocal<T> instance already
+  // has a value on the current thread.
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
+
+ protected:
+  ThreadLocalBase() {}
+  virtual ~ThreadLocalBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
+};
+
+// Maps a thread to a set of ThreadLocals that have values instantiated on that
+// thread and notifies them when the thread exits.  A ThreadLocal instance is
+// expected to persist until all threads it has values on have terminated.
+class GTEST_API_ ThreadLocalRegistry {
+ public:
+  // Registers thread_local_instance as having value on the current thread.
+  // Returns a value that can be used to identify the thread from other threads.
+  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance);
+
+  // Invoked when a ThreadLocal instance is destroyed.
+  static void OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance);
+};
+
+class GTEST_API_ ThreadWithParamBase {
+ public:
+  void Join();
+
+ protected:
+  class Runnable {
+   public:
+    virtual ~Runnable() {}
+    virtual void Run() = 0;
+  };
+
+  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
+  virtual ~ThreadWithParamBase();
+
+ private:
+  AutoHandle thread_;
+};
+
+// Helper class for testing Google Test's multi-threading constructs.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
+  }
+  virtual ~ThreadWithParam() {}
+
+ private:
+  class RunnableImpl : public Runnable {
+   public:
+    RunnableImpl(UserThreadFunc* func, T param)
+        : func_(func),
+          param_(param) {
+    }
+    virtual ~RunnableImpl() {}
+    virtual void Run() {
+      func_(param_);
+    }
+
+   private:
+    UserThreadFunc* const func_;
+    const T param_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
+  };
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+
+// Implements thread-local storage on Windows systems.
+//
+//   // Thread 1
+//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
+//
+//   // Thread 2
+//   tl.set(150);  // Changes the value for thread 2 only.
+//   EXPECT_EQ(150, tl.get());
+//
+//   // Thread 1
+//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
+//   tl.set(200);
+//   EXPECT_EQ(200, tl.get());
+//
+// The template type argument T must have a public copy constructor.
+// In addition, the default ThreadLocal constructor requires T to have
+// a public default constructor.
+//
+// The users of a TheadLocal instance have to make sure that all but one
+// threads (including the main one) using that instance have exited before
+// destroying it. Otherwise, the per-thread objects managed for them by the
+// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
+//
+// Google Test only uses global ThreadLocal objects.  That means they
+// will die after main() has returned.  Therefore, no per-thread
+// object managed by Google Test will be leaked as long as all threads
+// using Google Test have exited when main() returns.
+template <typename T>
+class ThreadLocal : public ThreadLocalBase {
+ public:
+  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of T.  Can be deleted via its base class without the caller
+  // knowing the type of T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+
+  T* GetOrCreateValue() const {
+    return static_cast<ValueHolder*>(
+        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
+  }
+
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
+    return default_factory_->MakeNewHolder();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    ValueHolder* MakeNewHolder() const override {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  std::unique_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# elif GTEST_HAS_PTHREAD
+
+// MutexBase and Mutex implement mutex on pthreads-based platforms.
+class MutexBase {
+ public:
+  // Acquires this mutex.
+  void Lock() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
+    owner_ = pthread_self();
+    has_owner_ = true;
+  }
+
+  // Releases this mutex.
+  void Unlock() {
+    // Since the lock is being released the owner_ field should no longer be
+    // considered valid. We don't protect writing to has_owner_ here, as it's
+    // the caller's responsibility to ensure that the current thread holds the
+    // mutex when this is called.
+    has_owner_ = false;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
+  }
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld() const {
+    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
+        << "The current thread is not holding the mutex @" << this;
+  }
+
+  // A static mutex may be used before main() is entered.  It may even
+  // be used before the dynamic initialization stage.  Therefore we
+  // must be able to initialize a static mutex object at link time.
+  // This means MutexBase has to be a POD and its member variables
+  // have to be public.
+ public:
+  pthread_mutex_t mutex_;  // The underlying pthread mutex.
+  // has_owner_ indicates whether the owner_ field below contains a valid thread
+  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
+  // accesses to the owner_ field should be protected by a check of this field.
+  // An alternative might be to memset() owner_ to all zeros, but there's no
+  // guarantee that a zero'd pthread_t is necessarily invalid or even different
+  // from pthread_self().
+  bool has_owner_;
+  pthread_t owner_;  // The thread holding the mutex.
+};
+
+// Forward-declares a static mutex.
+#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+     extern ::testing::internal::MutexBase mutex
+
+// Defines and statically (i.e. at link time) initializes a static mutex.
+// The initialization list here does not explicitly initialize each field,
+// instead relying on default initialization for the unspecified fields. In
+// particular, the owner_ field (a pthread_t) is not explicitly initialized.
+// This allows initialization to work whether pthread_t is a scalar or struct.
+// The flag -Wmissing-field-initializers must not be specified for this to work.
+#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+  ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}
+
+// The Mutex class can only be used for mutexes created at runtime. It
+// shares its API with MutexBase otherwise.
+class Mutex : public MutexBase {
+ public:
+  Mutex() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
+    has_owner_ = false;
+  }
+  ~Mutex() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(MutexBase* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  MutexBase* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Helpers for ThreadLocal.
+
+// pthread_key_create() requires DeleteThreadLocalValue() to have
+// C-linkage.  Therefore it cannot be templatized to access
+// ThreadLocal<T>.  Hence the need for class
+// ThreadLocalValueHolderBase.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Called by pthread to delete thread-local data stored by
+// pthread_setspecific().
+extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
+  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
+}
+
+// Implements thread-local storage on pthreads-based systems.
+template <typename T>
+class GTEST_API_ ThreadLocal {
+ public:
+  ThreadLocal()
+      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : key_(CreateKey()),
+        default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() {
+    // Destroys the managed object for the current thread, if any.
+    DeleteThreadLocalValue(pthread_getspecific(key_));
+
+    // Releases resources associated with the key.  This will *not*
+    // delete managed objects for other threads.
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
+  }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of type T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+  static pthread_key_t CreateKey() {
+    pthread_key_t key;
+    // When a thread exits, DeleteThreadLocalValue() will be called on
+    // the object managed for that thread.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_key_create(&key, &DeleteThreadLocalValue));
+    return key;
+  }
+
+  T* GetOrCreateValue() const {
+    ThreadLocalValueHolderBase* const holder =
+        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
+    if (holder != nullptr) {
+      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
+    }
+
+    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
+    ThreadLocalValueHolderBase* const holder_base = new_holder;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
+    return new_holder->pointer();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    ValueHolder* MakeNewHolder() const override {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  // A key pthreads uses for looking up per-thread values.
+  const pthread_key_t key_;
+  std::unique_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+#else  // GTEST_IS_THREADSAFE
+
+// A dummy implementation of synchronization primitives (mutex, lock,
+// and thread-local variable).  Necessary for compiling Google Test where
+// mutex is not supported - using Google Test in multiple threads is not
+// supported on such platforms.
+
+class Mutex {
+ public:
+  Mutex() {}
+  void Lock() {}
+  void Unlock() {}
+  void AssertHeld() const {}
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+  extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex*) {}  // NOLINT
+};
+
+typedef GTestMutexLock MutexLock;
+
+template <typename T>
+class GTEST_API_ ThreadLocal {
+ public:
+  ThreadLocal() : value_() {}
+  explicit ThreadLocal(const T& value) : value_(value) {}
+  T* pointer() { return &value_; }
+  const T* pointer() const { return &value_; }
+  const T& get() const { return value_; }
+  void set(const T& value) { value_ = value; }
+ private:
+  T value_;
+};
+
+#endif  // GTEST_IS_THREADSAFE
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+GTEST_API_ size_t GetThreadCount();
+
+#if GTEST_OS_WINDOWS
+# define GTEST_PATH_SEP_ "\\"
+# define GTEST_HAS_ALT_PATH_SEP_ 1
+#else
+# define GTEST_PATH_SEP_ "/"
+# define GTEST_HAS_ALT_PATH_SEP_ 0
+#endif  // GTEST_OS_WINDOWS
+
+// Utilities for char.
+
+// isspace(int ch) and friends accept an unsigned char or EOF.  char
+// may be signed, depending on the compiler (or compiler flags).
+// Therefore we need to cast a char to unsigned char before calling
+// isspace(), etc.
+
+inline bool IsAlpha(char ch) {
+  return isalpha(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsAlNum(char ch) {
+  return isalnum(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsDigit(char ch) {
+  return isdigit(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsLower(char ch) {
+  return islower(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsSpace(char ch) {
+  return isspace(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsUpper(char ch) {
+  return isupper(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsXDigit(char ch) {
+  return isxdigit(static_cast<unsigned char>(ch)) != 0;
+}
+#ifdef __cpp_char8_t
+inline bool IsXDigit(char8_t ch) {
+  return isxdigit(static_cast<unsigned char>(ch)) != 0;
+}
+#endif
+inline bool IsXDigit(char16_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+inline bool IsXDigit(char32_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+inline bool IsXDigit(wchar_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+
+inline char ToLower(char ch) {
+  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
+}
+inline char ToUpper(char ch) {
+  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
+}
+
+inline std::string StripTrailingSpaces(std::string str) {
+  std::string::iterator it = str.end();
+  while (it != str.begin() && IsSpace(*--it))
+    it = str.erase(it);
+  return str;
+}
+
+// The testing::internal::posix namespace holds wrappers for common
+// POSIX functions.  These wrappers hide the differences between
+// Windows/MSVC and POSIX systems.  Since some compilers define these
+// standard functions as macros, the wrapper cannot have the same name
+// as the wrapped function.
+
+namespace posix {
+
+// Functions with a different name on Windows.
+
+#if GTEST_OS_WINDOWS
+
+typedef struct _stat StatStruct;
+
+# ifdef __BORLANDC__
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+# else  // !__BORLANDC__
+#  if GTEST_OS_WINDOWS_MOBILE
+inline int DoIsATTY(int /* fd */) { return 0; }
+#  else
+inline int DoIsATTY(int fd) { return _isatty(fd); }
+#  endif  // GTEST_OS_WINDOWS_MOBILE
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return _stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return _strdup(src); }
+# endif  // __BORLANDC__
+
+# if GTEST_OS_WINDOWS_MOBILE
+inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
+// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
+// time and thus not defined there.
+# else
+inline int FileNo(FILE* file) { return _fileno(file); }
+inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
+inline int RmDir(const char* dir) { return _rmdir(dir); }
+inline bool IsDir(const StatStruct& st) {
+  return (_S_IFDIR & st.st_mode) != 0;
+}
+# endif  // GTEST_OS_WINDOWS_MOBILE
+
+#elif GTEST_OS_ESP8266
+typedef struct stat StatStruct;
+
+inline int FileNo(FILE* file) { return fileno(file); }
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int Stat(const char* path, StatStruct* buf) {
+  // stat function not implemented on ESP8266
+  return 0;
+}
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return strcasecmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+inline int RmDir(const char* dir) { return rmdir(dir); }
+inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
+
+#else
+
+typedef struct stat StatStruct;
+
+inline int FileNo(FILE* file) { return fileno(file); }
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return strcasecmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+inline int RmDir(const char* dir) { return rmdir(dir); }
+inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
+
+#endif  // GTEST_OS_WINDOWS
+
+inline int IsATTY(int fd) {
+  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
+  // to a file on Linux), which is unexpected, so save the previous value, and
+  // restore it after the call.
+  int savedErrno = errno;
+  int isAttyValue = DoIsATTY(fd);
+  errno = savedErrno;
+
+  return isAttyValue;
+}
+
+// Functions deprecated by MSVC 8.0.
+
+GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
+
+// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
+// StrError() aren't needed on Windows CE at this time and thus not
+// defined there.
+
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
+    !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA
+inline int ChDir(const char* dir) { return chdir(dir); }
+#endif
+inline FILE* FOpen(const char* path, const char* mode) {
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+  struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {};
+  std::wstring_convert<wchar_codecvt> converter;
+  std::wstring wide_path = converter.from_bytes(path);
+  std::wstring wide_mode = converter.from_bytes(mode);
+  return _wfopen(wide_path.c_str(), wide_mode.c_str());
+#else  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+  return fopen(path, mode);
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+}
+#if !GTEST_OS_WINDOWS_MOBILE
+inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
+  return freopen(path, mode, stream);
+}
+inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
+#endif
+inline int FClose(FILE* fp) { return fclose(fp); }
+#if !GTEST_OS_WINDOWS_MOBILE
+inline int Read(int fd, void* buf, unsigned int count) {
+  return static_cast<int>(read(fd, buf, count));
+}
+inline int Write(int fd, const void* buf, unsigned int count) {
+  return static_cast<int>(write(fd, buf, count));
+}
+inline int Close(int fd) { return close(fd); }
+inline const char* StrError(int errnum) { return strerror(errnum); }
+#endif
+inline const char* GetEnv(const char* name) {
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+  // We are on an embedded platform, which has no environment variables.
+  static_cast<void>(name);  // To prevent 'unused argument' warning.
+  return nullptr;
+#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
+  // Environment variables which we programmatically clear will be set to the
+  // empty string rather than unset (NULL).  Handle that case.
+  const char* const env = getenv(name);
+  return (env != nullptr && env[0] != '\0') ? env : nullptr;
+#else
+  return getenv(name);
+#endif
+}
+
+GTEST_DISABLE_MSC_DEPRECATED_POP_()
+
+#if GTEST_OS_WINDOWS_MOBILE
+// Windows CE has no C library. The abort() function is used in
+// several places in Google Test. This implementation provides a reasonable
+// imitation of standard behaviour.
+[[noreturn]] void Abort();
+#else
+[[noreturn]] inline void Abort() { abort(); }
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+}  // namespace posix
+
+// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
+// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
+// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
+// function in order to achieve that.  We use macro definition here because
+// snprintf is a variadic function.
+#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
+// MSVC 2005 and above support variadic macros.
+# define GTEST_SNPRINTF_(buffer, size, format, ...) \
+     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
+#elif defined(_MSC_VER)
+// Windows CE does not define _snprintf_s
+# define GTEST_SNPRINTF_ _snprintf
+#else
+# define GTEST_SNPRINTF_ snprintf
+#endif
+
+// The biggest signed integer type the compiler supports.
+//
+// long long is guaranteed to be at least 64-bits in C++11.
+using BiggestInt = long long;  // NOLINT
+
+// The maximum number a BiggestInt can represent.
+constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)();
+
+// This template class serves as a compile-time function from size to
+// type.  It maps a size in bytes to a primitive type with that
+// size. e.g.
+//
+//   TypeWithSize<4>::UInt
+//
+// is typedef-ed to be unsigned int (unsigned integer made up of 4
+// bytes).
+//
+// Such functionality should belong to STL, but I cannot find it
+// there.
+//
+// Google Test uses this class in the implementation of floating-point
+// comparison.
+//
+// For now it only handles UInt (unsigned int) as that's all Google Test
+// needs.  Other types can be easily added in the future if need
+// arises.
+template <size_t size>
+class TypeWithSize {
+ public:
+  // This prevents the user from using TypeWithSize<N> with incorrect
+  // values of N.
+  using UInt = void;
+};
+
+// The specialization for size 4.
+template <>
+class TypeWithSize<4> {
+ public:
+  using Int = std::int32_t;
+  using UInt = std::uint32_t;
+};
+
+// The specialization for size 8.
+template <>
+class TypeWithSize<8> {
+ public:
+  using Int = std::int64_t;
+  using UInt = std::uint64_t;
+};
+
+// Integer types of known sizes.
+using TimeInMillis = int64_t;  // Represents time in milliseconds.
+
+// Utilities for command line flags and environment variables.
+
+// Macro for referencing flags.
+#if !defined(GTEST_FLAG)
+# define GTEST_FLAG(name) FLAGS_gtest_##name
+#endif  // !defined(GTEST_FLAG)
+
+#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
+#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+
+#if !defined(GTEST_DECLARE_bool_)
+# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
+
+// Macros for declaring flags.
+#define GTEST_DECLARE_bool_(name)          \
+  namespace testing {                      \
+  GTEST_API_ extern bool GTEST_FLAG(name); \
+  } static_assert(true, "no-op to require trailing semicolon")
+#define GTEST_DECLARE_int32_(name)                 \
+  namespace testing {                              \
+  GTEST_API_ extern std::int32_t GTEST_FLAG(name); \
+  } static_assert(true, "no-op to require trailing semicolon")
+#define GTEST_DECLARE_string_(name)                 \
+  namespace testing {                               \
+  GTEST_API_ extern ::std::string GTEST_FLAG(name); \
+  } static_assert(true, "no-op to require trailing semicolon")
+
+// Macros for defining flags.
+#define GTEST_DEFINE_bool_(name, default_val, doc)  \
+  namespace testing {                               \
+  GTEST_API_ bool GTEST_FLAG(name) = (default_val); \
+  } static_assert(true, "no-op to require trailing semicolon")
+#define GTEST_DEFINE_int32_(name, default_val, doc)         \
+  namespace testing {                                       \
+  GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val); \
+  } static_assert(true, "no-op to require trailing semicolon")
+#define GTEST_DEFINE_string_(name, default_val, doc)         \
+  namespace testing {                                        \
+  GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val); \
+  } static_assert(true, "no-op to require trailing semicolon")
+
+#endif  // !defined(GTEST_DECLARE_bool_)
+
+#if !defined(GTEST_FLAG_GET)
+#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
+#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
+#endif  // !defined(GTEST_FLAG_GET)
+
+// Thread annotations
+#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
+# define GTEST_LOCK_EXCLUDED_(locks)
+#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+
+// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
+// to *value and returns true; otherwise leaves *value unchanged and returns
+// false.
+GTEST_API_ bool ParseInt32(const Message& src_text, const char* str,
+                           int32_t* value);
+
+// Parses a bool/int32_t/string from the environment variable
+// corresponding to the given Google Test flag.
+bool BoolFromGTestEnv(const char* flag, bool default_val);
+GTEST_API_ int32_t Int32FromGTestEnv(const char* flag, int32_t default_val);
+std::string OutputFlagAlsoCheckEnvVar();
+const char* StringFromGTestEnv(const char* flag, const char* default_val);
+
+}  // namespace internal
+}  // namespace testing
+
+#if !defined(GTEST_INTERNAL_DEPRECATED)
+
+// Internal Macro to mark an API deprecated, for googletest usage only
+// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or
+// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every usage of
+// a deprecated entity will trigger a warning when compiled with
+// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler).
+// For msvc /W3 option will need to be used
+// Note that for 'other' compilers this macro evaluates to nothing to prevent
+// compilations errors.
+#if defined(_MSC_VER)
+#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
+#elif defined(__GNUC__)
+#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))
+#else
+#define GTEST_INTERNAL_DEPRECATED(message)
+#endif
+
+#endif  // !defined(GTEST_INTERNAL_DEPRECATED)
+
+#if GTEST_HAS_ABSL
+// Always use absl::any for UniversalPrinter<> specializations if googletest
+// is built with absl support.
+#define GTEST_INTERNAL_HAS_ANY 1
+#include "absl/types/any.h"
+namespace testing {
+namespace internal {
+using Any = ::absl::any;
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<any>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::any for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_ANY 1
+#include <any>
+namespace testing {
+namespace internal {
+using Any = ::std::any;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::any is not
+// supported.
+#endif  // __has_include(<any>) && __cplusplus >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_ABSL
+// Always use absl::optional for UniversalPrinter<> specializations if
+// googletest is built with absl support.
+#define GTEST_INTERNAL_HAS_OPTIONAL 1
+#include "absl/types/optional.h"
+namespace testing {
+namespace internal {
+template <typename T>
+using Optional = ::absl::optional<T>;
+inline ::absl::nullopt_t Nullopt() { return ::absl::nullopt; }
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::optional for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_OPTIONAL 1
+#include <optional>
+namespace testing {
+namespace internal {
+template <typename T>
+using Optional = ::std::optional<T>;
+inline ::std::nullopt_t Nullopt() { return ::std::nullopt; }
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::optional is not
+// supported.
+#endif  // __has_include(<optional>) && __cplusplus >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_ABSL
+// Always use absl::string_view for Matcher<> specializations if googletest
+// is built with absl support.
+# define GTEST_INTERNAL_HAS_STRING_VIEW 1
+#include "absl/strings/string_view.h"
+namespace testing {
+namespace internal {
+using StringView = ::absl::string_view;
+}  // namespace internal
+}  // namespace testing
+#else
+# ifdef __has_include
+#   if __has_include(<string_view>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::string_view for Matcher<>
+// specializations.
+#   define GTEST_INTERNAL_HAS_STRING_VIEW 1
+#include <string_view>
+namespace testing {
+namespace internal {
+using StringView = ::std::string_view;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::string_view is not
+// supported.
+#  endif  // __has_include(<string_view>) && __cplusplus >= 201703L
+# endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_ABSL
+// Always use absl::variant for UniversalPrinter<> specializations if googletest
+// is built with absl support.
+#define GTEST_INTERNAL_HAS_VARIANT 1
+#include "absl/types/variant.h"
+namespace testing {
+namespace internal {
+template <typename... T>
+using Variant = ::absl::variant<T...>;
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<variant>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::variant for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_VARIANT 1
+#include <variant>
+namespace testing {
+namespace internal {
+template <typename... T>
+using Variant = ::std::variant<T...>;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::variant is not supported.
+#endif  // __has_include(<variant>) && __cplusplus >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
diff --git a/tools/gtest_lib/include/gtest/internal/gtest-string.h b/tools/gtest_lib/include/gtest/internal/gtest-string.h
new file mode 100644
index 0000000000000000000000000000000000000000..4cb8e07cf9f40169a1fd84f1019bbad41f9222d0
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/gtest-string.h
@@ -0,0 +1,177 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file declares the String class and functions used internally by
+// Google Test.  They are subject to change without notice. They should not used
+// by code external to Google Test.
+//
+// This header file is #included by gtest-internal.h.
+// It should not be #included by other files.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+
+#ifdef __BORLANDC__
+// string.h is not guaranteed to provide strcpy on C++ Builder.
+# include <mem.h>
+#endif
+
+#include <string.h>
+#include <cstdint>
+#include <string>
+
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+namespace internal {
+
+// String - an abstract class holding static string utilities.
+class GTEST_API_ String {
+ public:
+  // Static utility methods
+
+  // Clones a 0-terminated C string, allocating memory using new.  The
+  // caller is responsible for deleting the return value using
+  // delete[].  Returns the cloned string, or NULL if the input is
+  // NULL.
+  //
+  // This is different from strdup() in string.h, which allocates
+  // memory using malloc().
+  static const char* CloneCString(const char* c_str);
+
+#if GTEST_OS_WINDOWS_MOBILE
+  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
+  // able to pass strings to Win32 APIs on CE we need to convert them
+  // to 'Unicode', UTF-16.
+
+  // Creates a UTF-16 wide string from the given ANSI string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the wide string, or NULL if the
+  // input is NULL.
+  //
+  // The wide string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static LPCWSTR AnsiToUtf16(const char* c_str);
+
+  // Creates an ANSI string from the given wide string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the ANSI string, or NULL if the
+  // input is NULL.
+  //
+  // The returned string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
+#endif
+
+  // Compares two C strings.  Returns true if and only if they have the same
+  // content.
+  //
+  // Unlike strcmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CStringEquals(const char* lhs, const char* rhs);
+
+  // Converts a wide C string to a String using the UTF-8 encoding.
+  // NULL will be converted to "(null)".  If an error occurred during
+  // the conversion, "(failed to convert from wide string)" is
+  // returned.
+  static std::string ShowWideCString(const wchar_t* wide_c_str);
+
+  // Compares two wide C strings.  Returns true if and only if they have the
+  // same content.
+  //
+  // Unlike wcscmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
+
+  // Compares two C strings, ignoring case.  Returns true if and only if
+  // they have the same content.
+  //
+  // Unlike strcasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CaseInsensitiveCStringEquals(const char* lhs,
+                                           const char* rhs);
+
+  // Compares two wide C strings, ignoring case.  Returns true if and only if
+  // they have the same content.
+  //
+  // Unlike wcscasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL wide C string,
+  // including the empty string.
+  // NB: The implementations on different platforms slightly differ.
+  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
+  // environment variable. On GNU platform this method uses wcscasecmp
+  // which compares according to LC_CTYPE category of the current locale.
+  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
+  // current locale.
+  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
+                                               const wchar_t* rhs);
+
+  // Returns true if and only if the given string ends with the given suffix,
+  // ignoring case. Any string is considered to end with an empty suffix.
+  static bool EndsWithCaseInsensitive(
+      const std::string& str, const std::string& suffix);
+
+  // Formats an int value as "%02d".
+  static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
+
+  // Formats an int value to given width with leading zeros.
+  static std::string FormatIntWidthN(int value, int width);
+
+  // Formats an int value as "%X".
+  static std::string FormatHexInt(int value);
+
+  // Formats an int value as "%X".
+  static std::string FormatHexUInt32(uint32_t value);
+
+  // Formats a byte as "%02X".
+  static std::string FormatByte(unsigned char value);
+
+ private:
+  String();  // Not meant to be instantiated.
+};  // class String
+
+// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
+// character in the buffer is replaced with "\\0".
+GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
diff --git a/tools/gtest_lib/include/gtest/internal/gtest-type-util.h b/tools/gtest_lib/include/gtest/internal/gtest-type-util.h
new file mode 100644
index 0000000000000000000000000000000000000000..665564a97ac94d08c6870b838ab6af5a715b39bd
--- /dev/null
+++ b/tools/gtest_lib/include/gtest/internal/gtest-type-util.h
@@ -0,0 +1,185 @@
+// Copyright 2008 Google Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Type utilities needed for implementing typed and type-parameterized
+// tests.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+
+#include "gtest/internal/gtest-port.h"
+
+// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
+// libstdc++ (which is where cxxabi.h comes from).
+# if GTEST_HAS_CXXABI_H_
+#  include <cxxabi.h>
+# elif defined(__HP_aCC)
+#  include <acxx_demangle.h>
+# endif  // GTEST_HASH_CXXABI_H_
+
+namespace testing {
+namespace internal {
+
+// Canonicalizes a given name with respect to the Standard C++ Library.
+// This handles removing the inline namespace within `std` that is
+// used by various standard libraries (e.g., `std::__1`).  Names outside
+// of namespace std are returned unmodified.
+inline std::string CanonicalizeForStdLibVersioning(std::string s) {
+  static const char prefix[] = "std::__";
+  if (s.compare(0, strlen(prefix), prefix) == 0) {
+    std::string::size_type end = s.find("::", strlen(prefix));
+    if (end != s.npos) {
+      // Erase everything between the initial `std` and the second `::`.
+      s.erase(strlen("std"), end - strlen("std"));
+    }
+  }
+  return s;
+}
+
+#if GTEST_HAS_RTTI
+// GetTypeName(const std::type_info&) returns a human-readable name of type T.
+inline std::string GetTypeName(const std::type_info& type) {
+  const char* const name = type.name();
+#if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
+  int status = 0;
+  // gcc's implementation of typeid(T).name() mangles the type name,
+  // so we have to demangle it.
+#if GTEST_HAS_CXXABI_H_
+  using abi::__cxa_demangle;
+#endif  // GTEST_HAS_CXXABI_H_
+  char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status);
+  const std::string name_str(status == 0 ? readable_name : name);
+  free(readable_name);
+  return CanonicalizeForStdLibVersioning(name_str);
+#else
+  return name;
+#endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
+}
+#endif  // GTEST_HAS_RTTI
+
+// GetTypeName<T>() returns a human-readable name of type T if and only if
+// RTTI is enabled, otherwise it returns a dummy type name.
+// NB: This function is also used in Google Mock, so don't move it inside of
+// the typed-test-only section below.
+template <typename T>
+std::string GetTypeName() {
+#if GTEST_HAS_RTTI
+  return GetTypeName(typeid(T));
+#else
+  return "<type>";
+#endif  // GTEST_HAS_RTTI
+}
+
+// A unique type indicating an empty node
+struct None {};
+
+# define GTEST_TEMPLATE_ template <typename T> class
+
+// The template "selector" struct TemplateSel<Tmpl> is used to
+// represent Tmpl, which must be a class template with one type
+// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
+// as the type Tmpl<T>.  This allows us to actually instantiate the
+// template "selected" by TemplateSel<Tmpl>.
+//
+// This trick is necessary for simulating typedef for class templates,
+// which C++ doesn't support directly.
+template <GTEST_TEMPLATE_ Tmpl>
+struct TemplateSel {
+  template <typename T>
+  struct Bind {
+    typedef Tmpl<T> type;
+  };
+};
+
+# define GTEST_BIND_(TmplSel, T) \
+  TmplSel::template Bind<T>::type
+
+template <GTEST_TEMPLATE_ Head_, GTEST_TEMPLATE_... Tail_>
+struct Templates {
+  using Head = TemplateSel<Head_>;
+  using Tail = Templates<Tail_...>;
+};
+
+template <GTEST_TEMPLATE_ Head_>
+struct Templates<Head_> {
+  using Head = TemplateSel<Head_>;
+  using Tail = None;
+};
+
+// Tuple-like type lists
+template <typename Head_, typename... Tail_>
+struct Types {
+  using Head = Head_;
+  using Tail = Types<Tail_...>;
+};
+
+template <typename Head_>
+struct Types<Head_> {
+  using Head = Head_;
+  using Tail = None;
+};
+
+// Helper metafunctions to tell apart a single type from types
+// generated by ::testing::Types
+template <typename... Ts>
+struct ProxyTypeList {
+  using type = Types<Ts...>;
+};
+
+template <typename>
+struct is_proxy_type_list : std::false_type {};
+
+template <typename... Ts>
+struct is_proxy_type_list<ProxyTypeList<Ts...>> : std::true_type {};
+
+// Generator which conditionally creates type lists.
+// It recognizes if a requested type list should be created
+// and prevents creating a new type list nested within another one.
+template <typename T>
+struct GenerateTypeList {
+ private:
+  using proxy = typename std::conditional<is_proxy_type_list<T>::value, T,
+                                          ProxyTypeList<T>>::type;
+
+ public:
+  using type = typename proxy::type;
+};
+
+}  // namespace internal
+
+template <typename... Ts>
+using Types = internal::ProxyTypeList<Ts...>;
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
diff --git a/tools/gtest_lib/lib/libgmock.a b/tools/gtest_lib/lib/libgmock.a
new file mode 100644
index 0000000000000000000000000000000000000000..85d219d73aebbfd94248478c673c4928feaa3890
Binary files /dev/null and b/tools/gtest_lib/lib/libgmock.a differ
diff --git a/tools/gtest_lib/lib/libgmock_main.a b/tools/gtest_lib/lib/libgmock_main.a
new file mode 100644
index 0000000000000000000000000000000000000000..fa1d27ceade9af905d75ad5338f08434d25c83cb
Binary files /dev/null and b/tools/gtest_lib/lib/libgmock_main.a differ
diff --git a/tools/gtest_lib/lib/libgtest.a b/tools/gtest_lib/lib/libgtest.a
new file mode 100644
index 0000000000000000000000000000000000000000..6ded702237731d7ad6f9ab60e7286655e0b73b8c
Binary files /dev/null and b/tools/gtest_lib/lib/libgtest.a differ
diff --git a/tools/gtest_lib/lib/libgtest_main.a b/tools/gtest_lib/lib/libgtest_main.a
new file mode 100644
index 0000000000000000000000000000000000000000..214d7ca3f096357ef28b8ea5b224323fd119a42a
Binary files /dev/null and b/tools/gtest_lib/lib/libgtest_main.a differ
diff --git a/tools/maple_autocompletion.sh b/tools/maple_autocompletion.sh
new file mode 100644
index 0000000000000000000000000000000000000000..7775e87192419c948781c0272be592f6717ff174
--- /dev/null
+++ b/tools/maple_autocompletion.sh
@@ -0,0 +1,27 @@
+_maple_complete()
+{
+    local cur_word prev_word type_list
+
+    cur_word="${COMP_WORDS[COMP_CWORD]}"
+    prev_word="${COMP_WORDS[COMP_CWORD-1]}"
+
+    # generate a list of options it supports
+    type_list=`maple --help`
+
+    # Only perform completion by "--help parsing" if the current word starts with a dash ('-'),
+    # meaning that the user is trying to complete an option.
+    # Else, show input files as the options.
+    # COMPREPLY is the array of possible completions, generated with
+    # the compgen builtin.
+    if [[ ${cur_word} == -* ]] ; then
+	# Parse --help output to show options
+        COMPREPLY=( $(compgen -W "${type_list}" -- ${cur_word}) $(compgen -f -- ${cur_word}) )
+    else
+	# Input files
+	COMPREPLY=( $(compgen -f -- ${cur_word}) )
+    fi
+    return 0
+}
+
+# Register _maple_complete to provide completion for the maple driver
+complete -F _maple_complete maple
diff --git a/tools/run_spec/Makefile b/tools/run_spec/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..fa03641b8c639fc438c84bfc5a9876d9a295c912
--- /dev/null
+++ b/tools/run_spec/Makefile
@@ -0,0 +1,38 @@
+ifndef MAPLE_ROOT
+  $(error MAPLE_ROOT is not set. Please source zeiss/envsetup.sh to set the build environment)
+endif
+
+help:
+	@echo "================================================================"
+	@echo "1. setup spec2017 source"
+	@echo "  make setup"
+	@echo ""
+	@echo "2. setup env"
+	@echo "  source envsetup.sh [ clang2mpl | hir2mpl ] # select frontend"
+	@echo ""
+	@echo "3. build and run, eg for benchmark 605.mcf_s:"
+	@echo "  make build.605 # optional" 
+	@echo "  make test.605"
+	@echo "  make train.605"
+	@echo "  make ref.605"
+	@echo "================================================================"
+
+setup:
+	@if [ -d $(HOME)/spec2017 ]; then\
+		echo "Already copied $(HOME)/spec2017.";\
+	else \
+		cp -pr /maple/spec2017 $(HOME);\
+	fi
+	cp -f $(MAPLE_ROOT)/build/tools/spec/*.cfg $(HOME)/spec2017/config
+
+build.%:
+	runcpu --config=$(SPEC_CFG).cfg --action build $* --rebuild
+
+test.%:
+	runcpu --config=$(SPEC_CFG).cfg -i test --action run $*
+
+train.%:
+	runcpu --config=$(SPEC_CFG).cfg -i train --action run $*
+
+ref.%:
+	runcpu --config=$(SPEC_CFG).cfg -i ref --action run $*
diff --git a/tools/run_spec/README.md b/tools/run_spec/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..32325e775dd249218e31ad994c0f18048c2208a1
--- /dev/null
+++ b/tools/run_spec/README.md
@@ -0,0 +1,47 @@
+# Build and Run SPEC with Maple
+
+1. Setup and build OAC
+
+```
+# Clone the repo
+git clone https://gitee.com/openarkcompiler/OpenArkCompiler.git oac
+# Or alternatively update the repo
+cd oac
+git pull
+
+# Setup the environment
+source build/envsetup.sh arm release
+make setup
+
+# Build OAC
+make
+# If using clang2mpl, build it
+make clang2mpl
+```
+
+2. Setup the environment for running SPEC
+
+```
+cd tools/run_spec
+make setup
+source envsetup.sh [ clang2mpl | hir2mpl ] # select frontend
+```
+
+3. Run a test
+
+```
+make test.602
+
+# Build only
+make build.600
+
+# Run the train or ref sizes
+make train.605
+make ref.605
+```
+
+## Quick Patch to Run QEMU on Ubuntu 20.04
+```shell
+sudo apt udpate && sudo apt install -y qemu qemu-user qemu-user-binfmt
+sudo cp $MAPLE_ROOT/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/lib/ld-linux-aarch64.so.1 /lib
+```
diff --git a/tools/run_spec/envsetup.sh b/tools/run_spec/envsetup.sh
new file mode 100644
index 0000000000000000000000000000000000000000..69d39630f019a4210bf8399f264e61c949e8f464
--- /dev/null
+++ b/tools/run_spec/envsetup.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+# export LD_LIBRARY_PATH=$MAPLE_ROOT/tools/gcc-linaro-7.5.0/aarch64-linux-gnu/libc/lib
+# spec
+export SPEC=$HOME/spec2017
+echo SPEC=$SPEC
+cd ${SPEC}
+source shrc
+cd -
+ulimit -s unlimited
+
+if [ $# -eq 1 ]; then
+  export SPEC_CFG=$1;
+  echo "You choose $1 as the front end."
+else
+  export SPEC_CFG=hir2mpl
+  echo "You choose hir2mpl as the front end."
+fi
+
+#echo 3 | sudo tee /proc/sys/vm/drop_caches
diff --git a/tools/setup_tools.sh b/tools/setup_tools.sh
new file mode 100755
index 0000000000000000000000000000000000000000..1eb956864f3dbfd6d06f83532a7d76d915b2e236
--- /dev/null
+++ b/tools/setup_tools.sh
@@ -0,0 +1,202 @@
+#!/bin/bash
+#
+# Copyright (C) [2020-2021] Futurewei Technologies, Inc. All rights reverved.
+#
+# Licensed under the Mulan Permissive Software License v2.
+# You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+# You may obtain a copy of MulanPSL - 2.0 at:
+#
+#   https://opensource.org/licenses/MulanPSL-2.0
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the MulanPSL - 2.0 for more details.
+#
+
+set -e
+
+if [ -z "$MAPLE_ROOT" ]; then
+  echo "Please \"source build/envsetup.sh\" to setup environment"
+  exit 1
+fi
+echo MAPLE_ROOT: $MAPLE_ROOT
+
+android_env=$1
+
+TOOLS=$MAPLE_ROOT/tools
+
+ANDROID_VERSION=android-10.0.0_r35
+ANDROID_SRCDIR=$MAPLE_ROOT/../android/$ANDROID_VERSION
+
+ANDROID_DIR=$MAPLE_ROOT/android
+
+#USR_EMAIL=`git config user.email`
+
+if [ "$android_env" == "android" ]; then
+  if [ ! -f $TOOLS/android-ndk-r21/ndk-build ]; then
+    cd $TOOLS
+    wget https://dl.google.com/android/repository/android-ndk-r21d-linux-x86_64.zip --no-check-certificate
+    echo unpacking android ndk ...
+    unzip android-ndk-r21d-linux-x86_64.zip > /dev/null
+    mv android-ndk-r21d android-ndk-r21
+    echo Downloaded android ndk.
+  fi
+  
+  if [ ! -L $TOOLS/gcc ]; then
+    cd $TOOLS
+    ln -s ../android/prebuilts/gcc .
+    echo Linked gcc.
+  fi
+  
+  if [ ! -L $TOOLS/clang-r353983c ]; then
+    cd $TOOLS
+    ln -s ../android/prebuilts/clang/host/linux-x86/clang-r353983c .
+    echo Linked clang.
+  fi
+fi
+
+if [ ! -f $TOOLS/ninja/ninja ]; then
+  cd $TOOLS
+  echo Start wget ninja ...
+  mkdir -p ./ninja
+  cd ./ninja || exit 3
+  wget https://github.com/ninja-build/ninja/releases/download/v1.10.0/ninja-linux.zip --no-check-certificate
+  unzip ninja-linux.zip
+  echo Downloaded ninja.
+fi
+
+if [ ! -f $TOOLS/gn/gn ]; then
+  cd $TOOLS
+  echo Start clone gn ...
+  git clone --depth 1 https://gitee.com/xlnb/gn_binary.git gn
+  chmod +x gn/gn
+  echo Downloaded gn.
+fi
+
+if [ ! -f $TOOLS/gcc-linaro-7.5.0/bin/aarch64-linux-gnu-gcc ]; then
+  cd $TOOLS
+  echo Start wget gcc-linaro-7.5.0 ...
+  wget https://releases.linaro.org/components/toolchain/binaries/latest-7/aarch64-linux-gnu/gcc-linaro-7.5.0-2019.12-i686_aarch64-linux-gnu.tar.xz --no-check-certificate
+  echo unpacking gcc ...
+  tar xf gcc-linaro-7.5.0-2019.12-i686_aarch64-linux-gnu.tar.xz
+  mv gcc-linaro-7.5.0-2019.12-i686_aarch64-linux-gnu gcc-linaro-7.5.0
+  echo Downloaded gcc aarch64 compiler.
+fi
+
+if [ ! -d $TOOLS/sysroot-glibc-linaro-2.25 ]; then
+  cd $TOOLS
+  echo Start wget sysroot-glibc-linaro-2.25 ...
+  wget https://releases.linaro.org/components/toolchain/binaries/latest-7/aarch64-linux-gnu/sysroot-glibc-linaro-2.25-2019.12-aarch64-linux-gnu.tar.xz --no-check-certificate
+  echo unpacking sysroot ...
+  tar xf sysroot-glibc-linaro-2.25-2019.12-aarch64-linux-gnu.tar.xz
+  mv sysroot-glibc-linaro-2.25-2019.12-aarch64-linux-gnu sysroot-glibc-linaro-2.25
+  echo Downloaded aarch64 sysroot.
+fi
+
+if [ ! -f $MAPLE_ROOT/third_party/d8/lib/d8.jar ]; then
+  cd $TOOLS
+  echo Start clone d8 ...
+  git clone --depth 1 https://gitee.com/xlnb/r8-d81513.git
+  mkdir -p $MAPLE_ROOT/third_party/d8/lib
+  cp -f r8-d81513/d8/lib/d8.jar $MAPLE_ROOT/third_party/d8/lib
+  echo Downloaded d8.jar.
+fi
+
+if [ ! -d $MAPLE_ROOT/third_party/icu ]; then
+  cd $TOOLS
+  echo Start clone ICU4C ...
+  git clone --depth 1 https://gitee.com/xlnb/icu4c.git
+  mkdir -p $MAPLE_ROOT/third_party/icu
+  cp -r icu4c/lib/ $MAPLE_ROOT/third_party/icu/
+  echo Downloaded icu4c libs
+fi
+
+# download prebuilt andriod
+if [ ! -d $ANDROID_DIR/out/target/product/generic_arm64 ]; then
+  cd $TOOLS
+  echo Start clone AOSP CORE LIB ...
+  git clone --depth 1 https://gitee.com/xlnb/aosp_core_bin.git
+  cp -r aosp_core_bin/android $MAPLE_ROOT/
+  cp -r aosp_core_bin/libjava-core $MAPLE_ROOT/
+  echo Downloaded AOSP CORE LIB
+fi
+
+if [ ! -f $MAPLE_ROOT/third_party/libdex/prebuilts/aarch64-linux-gnu/libz.so.1.2.8 ]; then
+  cd $TOOLS
+  echo Start wget libz ...
+  wget http://ports.ubuntu.com/pool/main/z/zlib/zlib1g_1.2.8.dfsg-2ubuntu4_arm64.deb --no-check-certificate
+  mkdir -p libz_extract
+  dpkg --extract zlib1g_1.2.8.dfsg-2ubuntu4_arm64.deb libz_extract
+  ZLIBDIR=$MAPLE_ROOT/third_party/libdex/prebuilts/aarch64-linux-gnu
+  mkdir -p $ZLIBDIR
+  cp -f libz_extract/lib/aarch64-linux-gnu/libz.so.1.2.8 $ZLIBDIR
+  echo Downloaded libz.
+fi
+
+# install a stable qemu-user based on different OS
+
+QEMU_VERSION=`$TOOLS/qemu/usr/bin/qemu-aarch64 -version | awk 'NR == 1' | awk '{print $3}' | sed -e "s/^[^0-9]*//" -e "s/\..*//"`
+
+if [ "$QEMU_VERSION" = "3" ] || [ "$QEMU_VERSION" = "4" ]; then
+  echo "QEMU version is too new and QEMU will be reversed to a stable version."
+  rm -rf $TOOLS/qemu
+fi
+
+if [ ! -f $TOOLS/qemu/usr/bin/qemu-aarch64 ]; then
+  cd $TOOLS
+  echo Start wget qemu-user ...
+  rm -rf qemu
+  mkdir -p qemu
+  if [ "$OLD_OS" == "1" ];then
+    wget http://archive.ubuntu.com/ubuntu/pool/universe/q/qemu/qemu-user_2.11+dfsg-1ubuntu7.40_amd64.deb --no-check-certificate
+    dpkg-deb -R qemu-user_2.11+dfsg-1ubuntu7.40_amd64.deb qemu
+  else
+    # we will use QEMU 2.11 for now, and will upgrade it to a new version after further investigations
+    wget http://archive.ubuntu.com/ubuntu/pool/universe/q/qemu/qemu-user_2.11+dfsg-1ubuntu7.40_amd64.deb --no-check-certificate
+    dpkg-deb -R qemu-user_2.11+dfsg-1ubuntu7.40_amd64.deb qemu
+  fi
+  echo Installed qemu-aarch64
+fi
+
+# clang2mpl
+if [ ! -d $TOOLS/clang2mpl ]; then
+  cd $TOOLS
+  git clone --depth 1 https://gitee.com/openarkcompiler-incubator/clang2mpl.git
+fi
+# routinly updated to be compatible with maple
+cd $TOOLS/clang2mpl
+git clean -df
+git checkout .
+git checkout master
+git pull
+
+if [ ! -d $MAPLE_ROOT/../ThirdParty ]; then
+  cd $MAPLE_ROOT/../
+  git clone --depth 1 https://gitee.com/openarkcompiler/ThirdParty.git
+  cd -
+else
+  cd $MAPLE_ROOT/../ThirdParty
+  git pull origin master
+  cd -
+fi
+
+mkdir -p ${TOOL_BIN_PATH}
+ln -s -f ${MAPLE_ROOT}/../ThirdParty/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04 ${MAPLE_ROOT}/tools
+ln -s -f ${MAPLE_ROOT}/../ThirdParty/llvm-12.0.0.src ${MAPLE_ROOT}/third_party/llvm-12.0.0.src
+ln -s -f ${MAPLE_ROOT}/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/clang++ ${TOOL_BIN_PATH}/clang++
+ln -s -f ${MAPLE_ROOT}/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/clang ${TOOL_BIN_PATH}/clang
+ln -s -f ${MAPLE_ROOT}/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/llvm-ar ${TOOL_BIN_PATH}/llvm-ar
+ln -s -f ${MAPLE_ROOT}/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/llvm-ranlib ${TOOL_BIN_PATH}/llvm-ranlib
+ln -s -f ${MAPLE_ROOT}/tools/clang+llvm-12.0.0-x86_64-linux-gnu-ubuntu-18.04/bin/FileCheck ${TOOL_BIN_PATH}/FileCheck
+ln -s -f ${MAPLE_ROOT}/tools/qemu/usr/bin/qemu-aarch64 ${TOOL_BIN_PATH}/qemu-aarch64
+ln -s -f ${MAPLE_ROOT}/build/java2dex ${TOOL_BIN_PATH}/java2dex
+ln -s -f ${MAPLE_ROOT}/tools/r8-d81513/d8/lib ${MAPLE_ROOT}/tools/lib
+ln -s -f ${MAPLE_ROOT}/tools/gcc-linaro-7.5.0/bin/aarch64-linux-gnu-gcc ${TOOL_BIN_PATH}/aarch64-linux-gnu-gcc
+ln -s -f ${MAPLE_ROOT}/tools/gcc-linaro-7.5.0/bin/aarch64-linux-gnu-as ${TOOL_BIN_PATH}/aarch64-linux-gnu-as
+ln -s -f ${MAPLE_ROOT}/tools/gcc-linaro-7.5.0/bin/aarch64-linux-gnu-ld ${TOOL_BIN_PATH}/aarch64-linux-gnu-ld
+
+# prepare scripts for tests
+mkdir -p ${MAPLE_ROOT}/output/script
+cp ${MAPLE_ROOT}/testsuite/driver/script/check.py ${MAPLE_ROOT}/output/script/
+cp ${MAPLE_ROOT}/testsuite/driver/script/kernel.py ${MAPLE_ROOT}/output/script/